# Основы программирования в &kdevelop;

2002-12-05
2.0
Ralf
Nolden

    Ralf.Nolden@post.rwth-aachen.de

Caleb
Tennis

    caleb@aei-tech.com

1999
Ralf Nolden
2002
Caleb Tennis
&FDLNotice;

Руководство по написанию C++ приложений для KDE с использованием &kdevelop;

KDE
KDevelop
IDE
разработка
программирование

## Введение

С приобретением Unix-подобными системами всё большей популярности даже среди начинающих пользователей из-за таких преимуществ, как стабильность, гибкость и функциональность (а также из-за решения начальства о переходе на эти ОС - прим. перев.), большинство из них разочаровывают из-за непохожего внешнего вида программ и их различного поведения. Разработчикам, пишущим приложения под KDE, предоставляется возможность писать первоклассные программы для Unix-клонов, что способствует расширению сообщества пользователей этих операционных систем посредством предоставления приложений лучшего качества. Поэтому KDE становится всё более популярной средой для программистов, которые хотят сосредоточиться на главной цели своего проекта, оставив основную работу по созданию интерфейса библиотекам KDE.

### Что нужно знать

Далее предполагается, что вы уже знаете C++. Если это не так, попрактикуйтесь сначала в самом языке. Книги о нём можно найти либо в местном книжном магазине, либо в электронном виде в Сети. Знания о разработке графического пользовательского интерфейса (GUI) не обязательны, т.к. в этом руководстве также даётся введение в разработку дизайна на базе библиотек Qt и KDE. Также вам нужно освоиться с &kdevelop;, в чём вам поможет Руководство &kdevelop;, содержащее обзор функциональности этой среды разработки.

### Об этом руководстве

Это руководство написано для ознакомления программистов с разработкой приложений KDE в интегрированной среде разработки KDevelop.

Следующие главы содержат способы создания проектов, описание начального исходного кода, созданного мастером, добавление таких элементы интерфейса, как панели инструментов, меню, и области представления (view).

Затем идёт обсуждение редактора диалогов с изложением механизма создания элементов управления (элементов пользовательского интерфейса, называемых также виджетами) и изменения их свойств.

Завершается руководство несколькими темами, которые дополнят ваши знания по проектированию и написанию документации.

#### В следующей главе

Мы обратим наш взгляд на библиотеки Qt и KDE, их основные принципы и вообще почему всё сделано так, как оно есть. Также будет описано создание учебных программ под Qt с помощью &kdevelop;, так что начинающие смогут получить первые результаты, а также освоиться с основными возможностями &kdevelop;.

#### В следующих главах

Вы научитесь:

- создавать приложения с помощью KAppWizard

- узнаете, что уже есть в проекте сразу после его создания

- что делает уже созданный код

- настраивать представление

- добавлять новые возможности в ваше приложение с помощью диалогов, меню и панелей инструментов

- делать приложение простым в использовании с помощью контекстной справки

- создавать документацию

### Дополнительная информация

Дополнительная информация по программированию в Qt/KDE:

- Программирование под Qt под редакцией Matthias Kalle Dalheimer

- Руководство KDevelop, поставляемое с KDevelop

- Справочник по функциям библиотеки Qt

- Сайт разработчиков KDE

Также вы можете получить дополнительную информацию, воспользовавшись поисковой машиной, подпиской на различные списки рассылки, сетью Usenet.

Для получения помощи по KDevelop IDE посылайте запросы в список рассылки kdevelop@kdevelop.org. Помните, что команда разработчиков KDevelop оказывает вам помощь бесплатно и её возможности ограничены. Пожалуйста, задавайте вопросы только по KDevelop.

## Библиотеки KDE и Qt

Норвежская компания TrollTech (http://www.trolltech.com) является разработчиком, т.н. GUI-инструментария, Qt. GUI расшифровывается как "Graphical User Interface" ("графический пользовательский интерфейс"). Этот инструментарий нужен для разработки приложений с графическим интерфейсом, чаще всего через интерфейс X-Window (или совместимый) на системах Unix, т.к. система X не содержит предопределённого интерфейса сама по себе (на данный момент разрабатывается альтернатива Y Window System, которая должна содержать базовый набор графических элементов, но её разработка находится только на начальной стадии - прим. перев.). Доступны и другие библиотеки пользовательского интерфейса, но Qt имеет некоторые преимущества, позволяющие создавать приложения проще и быстрее. Qt также доступна для Microsoft Windows, что позволяет делать переносимые приложения с графическим интерфейсом.

Цель команды KDE (http://www.kde.org) -- сделать системы Unix более дружественными для пользователя, используя библиотеку Qt, для разработки оконного менеджера для платформы X-Window (или совместимой с ней), а также большого количества разнообразных программ, поставляемых в пакетах KDE. После выхода первых версий KDE, многие разработчики обратили внимание на предложенную им среду разработки графических приложений. Библиотеки KDE предоставляют общие методы и классы для разработки приложений с унифицированным согласованным интерфейсом. Это значит, что пользователю не придётся осваиваться с интерфейсом каждой программы с нуля, а только со её специфическими функциями. Кроме того, программы KDE взаимодействуют друг с другом в рамках рабочего стола: они могут взаимодействовать с файловым менеджером посредством технологии "перетащить и оставить", с менеджером сессии и использовать другие возможности, предоставляемые библиотеками KDE.

И библиотека QT и библиотеки KDE написаны на языке программирования C++, поэтому почти все приложения, их использующие, тоже написаны на C++. В следующем разделе мы совершим краткий экскурс в библиотеки, увидим, какие возможности они предоставляют, и как в общих чертах создаются приложения Qt и KDE.

### GUI-инструментарий Qt

Как сказано выше, библиотека Qt предоставляет собой набор графических элементов. Кроме этого:

- Классы и методы, готовые к использованию даже не графическими программами

- Удобное решение взаимодействия с пользователем через методы и механизм сигналов/слотов

- Набор предопределённых GUI-элементов, называемых "виджетами"

- Предопределённые диалоги, например диалог открытия файла

Знание классов Qt очень полезно, даже если вы хотите программировать под KDE. Для начала разберём программу под Qt, а потом сделаем из неё программу под KDE.

#### Первое приложение Qt

Обычно в начале программы на C++ должна быть функция `main()`, которая выполняется первой при запуске программы. Так как мы хотим показать окна и настроить взаимодействие с пользователем, сначала мы должны разобраться, как эти окна будут показываться пользователю. Посмотрим первый учебный пример из документации по библиотеке Qt и разберём шаги выполнения программы, которая показывает окно:

    #include <qapplication.h>
    #include <qpushbutton.h>

    int main( int argc, char **argv )
    {
    QApplication a( argc, argv );

    QPushButton hello( "Hello world!", 0 );
    hello.resize( 100, 30 );

    a.setMainWidget( &hello );
    hello.show();
    return a.exec();
    }

Приложение прорисовывает окно с кнопкой "Hello world". Для всех Qt-приложений, нужно создать сначала экземпляр класса `QApplication`, представленного переменной a.

Далее создаётся экземпляр класса `QPushButton` и именем hello. Он представляет собой кнопку. Конструктор hello получает строку в виде аргумента и выводит её на кнопке.

Вызывается метод кнопки hello `resize()`. Он изменяет размер элемента управления `QPushButton` - ширина 100 точек и высота - 30. Наконец, вызывается метод setMainWidget() для переменной a и show() для переменной hello. QApplication выполняется методом `a.exec()`, запускается цикл опроса событий, который повторяется до тех пор, пока событием не будет возвращено целое число, сигнализирующее операционной системе о том, что работа приложения закончена.

#### Справочник Qt

Теперь давайте посмотрим на справочную документацию Qt. Запустите &kdevelop; и выберите "Qt" из дерева, расположенного на вкладке документации. Здесь вы будете получать всю необходимую информацию о классах и их методах библиотеки Qt. Кроме того, разбираемая программа показывается первой в разделе обучения. Для того, чтобы найти информацию о классах `QApplication` и `QPushButton`, выберите раздел "Alphabetical Class List" и найдите в списке имена классов. Нажмите на соответствующую ссылку для получения подробного описания класса.

Документацию по библиотеке Qt вы также можете найти на сайте компании Trolltech в разделе документация Qt (на английском языке)

`QApplication` имеет конструктор и другие методы. Если вы последуете за ссылкой, то можете больше узнать о каждом из методов. Это остаётся верным и для документации по библиотеке KDE, использующей схожий тип документации.

##### Интерпретация работы примера

Начините с `QApplication`, и вы увидите все методы, использованные в первом примере:

- конструктор `QApplication()`

- метод `setMainWidget()`

- метод `exec()`

Интерпретация работы программы очень проста:

1. Создаём экземпляр класса `QApplication` с помощью конструктора, что позволит нам использовать GUI-элементы, предоставляемые Qt

2. Создаём элемент управления в окне приложения

3. Делаем элемент управления главным для приложения (переменная 'a')

4. Запускаем экземпляр `QApplication`

Второй объект нашей программы - кнопка, экземпляр класса `QPushButton`. Из двух доступных конструкторов экземпляров этого класса мы воспользовались вторым: он принимает в виде аргумента строку текста, которая будет показана на кнопке. Затем методом `resize()` мы изменяем размер кнопки, чтобы вся строка была видна на кнопке.

Далее идёт метод `show()`. Но его нет в описании класса `QPushButton`. Этот класс наследует методы класса `QButton`, а тот, в свою очередь, наследует методы `QWidget`. Этот класс содержит огромное количество методов, в том числе `show()`. Итак, что же делалось с кнопкой:

1. Создаём экземпляр класса `QPushButton`, используя второй конструктор для указания надписи на кнопке

2. Изменяем размер кнопки

3. Делаем основным элементом управления для переменной а, экземпляра класса `QApplication`

4. Вызываем метод `show()`, который приводит к отображению элемента управления. Он наследуется от класса `QWidget`

После вызова метода `exec()`, приложение становится видимым пользователю. Окно приложения содержит кнопку "Hello world!". Примечание: GUI-программы ведут себя несколько отлично от процедурных. Главное отличие состоит в том, что приложение входит в т.н. "главный цикл событий" ("main event loop"). Это означает, что программа ожидает действий со стороны пользователя, и выдаёт на них определённую реакцию. Следующий раздел разъясняет, что это означает для программиста, и как эти события обрабатываются в Qt.

Для опытных: кнопка не имеет родителя, это значит, что это элемент управления верхнего уровня (top-level) и выполняется в локальном цикле событий, которому не нужно ждать главного цикла событий. Подробно это объяснено в документации класса QWidget и The KDE Library Reference Guide

#### Взаимодействие с пользователем

После прочтения последних разделов, вы уже должны знать:

- Что предоставляет библиотека Qt в терминах GUI-программирования

- Как создаётся программа, использующая Qt и

- Где и как найти информацию о классах, которые вам нужны

Теперь оживим нашу программу добавлением обработчика событий. В общем, есть два способа взаимодействия пользователя с программой - клавиатурой и мышью. В обоих случаях графический интерфейс предоставляет механизмы регистрации новых событий от этих устройств и методы их обработки.

Оконная система посылает все события соответствующему приложению. `QApplication` пересылает их активному окну в виде `QEvent` и элементы управления затем решают, что при этом делать. Соответствующий элемент управления принимает событие и обрабатывает `QWidget::event (QEvent*)`, в котором определяется тип события и выдаётся соответствующая реакция; `event()` - главный обработчик событий. Он передаёт событие т.н. фильтрам событий, которые определяют, что произошло и что делать с этим событием. Если фильтра для данного типа события нет, вызываются специальные обработчики событий. Они вызывают соответствующие предопределённые методы:

- События с клавиатуры - нажатие клавиш TAB и Shift-TAB:

  - `virtual void focusInEvent(QFocusEvent *)`

  - `virtual void focusOutEvent(QFocusEvent *)`

- Весь остальной ввод с клавиатуры:

  - `virtual void keyPressEvent(QKeyEvent *)`

  - `virtual void keyReleaseEvent(QKeyEvent *)`

- Движения курсора мыши:

  - `virtual void mouseMoveEvent(QMouseEvent *)`

  - `virtual void enterEvent(QEvent *)`

  - `virtual void leaveEvent(QEvent *)`

- Щелчки мышью

  - `virtual void mousePressEvent(QMouseEvent *)`

  - `virtual void mouseReleaseEvent(QMouseEvent *)`

  - `virtual void mouseDoubleClickEvent(QMouseEvent *)`

- События с окном, содержащим элемент управления

  - `virtual void moveEvent(QMoveEvent *)`

  - `virtual void resizeEvent(QResizeEvent *)`

  - `virtual void closeEvent(QCloseEvent *)`

Помните, что все функции событий являются виртуальными и защищёнными. Вы можете переназначить события, нужные вам, и определить свою реакцию. `QWidget` также содержит некоторые виртуальные методы, которые могут пригодиться в ваших программах. В любом случае, класс `QWidget` нужно узнать получше.

#### Взаимодействие объектов через сигналы и слоты

Теперь переходим к основному отличию Qt: механизму сигнал/слот. Это быстрое и удобное решение реализации взаимодействия объектов, которое обычно решается посредством callback-функций в библиотеках, работающих с X-Window. Так как такое взаимодействие требует аккуратного программирования и иногда делает создание пользовательского интерфейса очень сложным (что описано в документации по Qt и объяснено в книге К.Дальхеймера [K.Dalheimer] 'Programming with Qt'), Troll Tech придумала новую систему, где объекты могут посылать сигналы, которые можно связывать с методами, объявленными как слоты. Программисту на C++ нужно знать только некоторые вещи о механизме:

- объявление класса, использующего сигналы/слот должно содержать макрос Q_OBJECT в начале (без точки с запятой); и должно быть унаследовано от класса `QObject`

- сигнал может быть послан ключевым словом emit (например, emit signal (параметры...)) из любого метода класса, поддерживающего сигналы/слоты

- все сигналы, использующиеся не наследуемыми классами, должны быть добавлены в объявление класса в разделе signals

- все методы, которые могут быть связаны с сигналом, объявляются в разделах определения класса с дополнительным ключевым словом slot, например public slots

- компилятор метаобъектов (moc, meta-object compiler) обрабатывает заголовочные файлы, заменяя макросы на действительный код (это не обязательно знать). Вывод moc передаётся компилятору C++.

Другой способ использования сигналов без наследования от класса `QObject` - использовать класс `QSignal`: дополнительные сведения и примеры использования вы можете найти в документации. Далее подразумевается, что вы используете наследование от класса `QObject`.

В этом случае ваш класс может посылать сигналы куда угодно и создавать слоты, к которым можно привязывать любые сигналы. Используя сигналы, вам не нужно заботиться о том, кто их получает - нужно просто послать сигнал, а потом подключить любой слот, который будет выполнен при возникновении сигнала. Слоты можно использовать также как обычные методы в реализации.

Теперь, чтобы соединить сигнал со слотом,воспользуйтесь методом `connect()` класса `QObject` или, если доступно, другими специальными методами объекта для создания привязки к соответствующему сигналу.

##### Примерное использование

В качестве объяснения взаимодействия между объектами возьмём наш первый пример и расширим его простой привязкой сигнала и слота:

    #include <qapplication.h>
    #include <qpushbutton.h>

    int main( int argc, char **argv )
    {
    QApplication a( argc, argv );

    QPushButton hello( "Hello world!" , 0);
    hello.resize( 100, 30 );

    a.setMainWidget( &hello );

    QObject::connect(&hello, SIGNAL( clicked() ), &a, SLOT( quit() ));

    hello.show();
    return a.exec();
    }

Как видите, мы лишь расширили возможности кнопки с использованием метода `connect()`: `connect(&hello, SIGNAL( clicked() ), &a, SLOT( quit() ))` — всё, что мы добавили. Что же это означает? Объявление метода `connect()` в классе QObject:

`bool connect ( const QObject * sender, const char * signal, const QObject * receiver, const char * member )`

Это значит, что указатель на экземпляр `QObject` является инициатором сигнала, указанного во втором аргументе. Оставшиеся два аргумента есть объект-приёмник, который имеет слот, а затем и имя функции-слота, которая будет выполнена при получении сигнала.

С помощью сигналов и слотов, объекты ваших программ могут взаимодействовать друг с другом без явной зависимости от типа объекта-приёмника. Далее в этом руководстве приводится более подробное описание работы механзима сигналов/слотов. Коме этого, о нём можно почитать в The KDE Library Reference Guide и Qt online reference.

### Что даёт KDE

#### Библиотеки KDE 3.x

Основные библиотеки KDE, которые вам обязательно понадобятся при написании KDE-программ:

- kdecore - все классы с не графическими элементами, предназначенными для обеспечения функциональности приложений

- kdeui - элементы пользовательского интерфейса, например меню, панели инструментов и т.д.

- kfile - диалоги выбора файлов

Также возможно вам понадобятся библиотеки:

- kdefx - растровые изображения, эффекты расширения QStyle - KStyle

- khtml - компонент показа HTML

- kjs - поддержка Javascript

- kio - низкоуровневый доступ к сетевым файлам

- kparts - поддержка интерфейса компонентов (повторно используемых, внедряемых приложений)

Теперь давайте попробуем сделать из нашей первой программы на Qt KDE-программу.

#### Пример приложения KDE

В дальнейшем вы увидите, что написание программ под KDE ни капельки не труднее написания приложений на Qt. Для использования возможностей KDE, нужно использовать немного другие классы. В этом примере мы обсудим изменения по сравнению с версией на Qt:

    #include <kapplication.h>
    #include <qpushbutton.h>

    int main( int argc, char **argv )
    {
    KApplication a( argc, argv );

    QPushButton hello( "Hello world!", 0 );
    hello.resize( 100, 30 );

    a.setTopWidget( &hello );

    QObject::connect(&hello, SIGNAL( clicked() ), &a, SLOT( quit() ));

    hello.show();
    return a.exec();
    }

Вы видите, что мы поменяли класс `QApplication` на `KApplication`. Затем мы использовали метод `setTopWidget` вместо `setMainWidget()` для указания главного элемента управления для `KApplication`. Всё! Ваше первое приложение KDE готово - осталось только указать путь к заголовочным файлам KDE и скомпоновать библиотеку kdecore ключом компоновщика -lkdecore.

Если вы не собираетесь создавать такие простые программы, вам понадобится более удобная среда написания ПО. В следующей главе речь пойдёт о &kdevelop;.

Итак, к этому времени, вы уже прошлись по страницам справочной документации Qt, в т.ч. по классам `QApplication`, `QWidget` и `QObject`, а также по документации библиотеки kdecore, классу `KApplication`. KDE Library Reference handbook содержит полное описание использования конструкторов `QApplication` и `KApplication`, включая также обработку ключей командной строки.

## Создание новых приложений

### Мастер приложений

Мастер приложений (Application Wizard) поможет вам начать, предоставив скелет-основание для ваших программ. В зависимости от цели проекта, вы можете выбрать различный тип шаблона:

- KDE Application Framework: полный каркас для обычного приложения KDE

- QMake Project: структура программы основывается на системе сборки qmake фирмы Trolltech

- Simple hello world program: консольная программа на C++ без графического интерфейса

- и немалое количество других шаблонов

В этой главе мы рассмотрим использование Мастера приложений и вообще первые действия при создании проекта KDE.

### Мастер приложений и генерирование проекта

#### Запуск мастера приложений и первая страница

Откройте &kdevelop;, в меню "Проект" выберите "Новый проект". Выберите ветку C++, KDE, Application Framework.

Выберем имя KScribble. Мастер приложений

#### Система контроля версий

Далее вам нужно будет выбрать систему контроля версий, например CVS, или отказаться от её использования. В нашем случае - это последнее.

#### Шаблоны заголовочных и исходных файлов

Отредактируйте текст, который будет добавляться в начало каждого вновь создаваемого файла. Затем нажмите "Готово". Если она неактивна, вернитесь и проверьте правильность выбранных вами параметров.

#### Окончание

Откроется окно с сообщениями, в котором, после успешного завершения генерирования нового проекта, должна появиться надпись **** Success *****.

### Первая сборка

Давайте пройдёмся по выданному мастером коду для получения общего представления по структуре программы.

Далее предполагается, что вы освоились с базовой навигацией &kdevelop;. Если это не так, обратитесь к руководству KDevelop.

Менеджер Automake отображает файлы проекта: Файлы нашего проекта

Перед углублением в исходники, выполним сборку. Для этого выберите "Собрать проект" из меню "Сборка", или просто нажмите F8. В появившемся окне вывода будут выводиться сообщения сборщика `make`.

    1 cd /home/caleb/kscribble && WANT_AUTOCONF_2_5=1 WANT_AUTOMAKE_1_6=1 gmake k
    2 gmake all-recursive
    3 gmake[1]: Entering directory `/home/caleb/kscribble'
    4 Making all in doc
    5 gmake[2]: Entering directory `/home/caleb/kscribble/doc'
    6 Making all in .
    7 gmake[3]: Entering directory `/home/caleb/kscribble/doc'
    8 gmake[3]: Nothing to be done for `all-am'.
    9 gmake[3]: Leaving directory `/home/caleb/kscribble/doc'
    10 Making all in en
    11 gmake[3]: Entering directory `/home/caleb/kscribble/doc/en'
    12 /usr/local/kde3/bin/meinproc --check --cache index.cache.bz2 /home/caleb/kscribble/doc/en/index.docbook
    13 gmake[3]: Leaving directory `/home/caleb/kscribble/doc/en'
    14 gmake[2]: Leaving directory `/home/caleb/kscribble/doc'
    15 Making all in po
    16 gmake[2]: Entering directory `/home/caleb/kscribble/po'
    17 gmake[2]: Nothing to be done for `all'.
    18 gmake[2]: Leaving directory `/home/caleb/kscribble/po'
    19 Making all in src
    20 gmake[2]: Entering directory `/home/caleb/kscribble/src'
    21 source='main.cpp' object='main.o' libtool=no \
    22 depfile='.deps/main.Po' tmpdepfile='.deps/main.TPo' \
    23 depmode=gcc3 /bin/sh /home/caleb/kscribble/admin/depcomp \
    24 g++ -DHAVE_CONFIG_H -I. -I/home/caleb/kscribble/src -I.. -I/usr/local/kde3/include
       -I/usr/lib/qt/include -I/usr/X11R6/include -DQT_THREAD_SUPPORT -D_REENTRANT -Wnon-virtual-dtor
       -Wno-long-long -Wundef -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings
       -ansi -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new
       -c -o main.o `test -f 'main.cpp' || echo '/home/caleb/kscribble/src/'`main.cpp
    25 /usr/lib/qt/bin/moc /home/caleb/kscribble/src/kscribble.h -o kscribble.moc
    26 source='kscribble.cpp' object='kscribble.o' libtool=no \
    27 depfile='.deps/kscribble.Po' tmpdepfile='.deps/kscribble.TPo' \
    28 depmode=gcc3 /bin/sh /home/caleb/kscribble/admin/depcomp \
    29 g++ -DHAVE_CONFIG_H -I. -I/home/caleb/kscribble/src -I.. -I/usr/local/kde3/include
       -I/usr/lib/qt/include -I/usr/X11R6/include -DQT_THREAD_SUPPORT -D_REENTRANT -Wnon-virtual-dtor
       -Wno-long-long -Wundef -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings
       -ansi -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new
       -c -o kscribble.o `test -f 'kscribble.cpp' || echo '/home/caleb/kscribble/src/'`kscribble.cpp
    30 kscribble.cpp: In member function `void KScribble::setupActions()'
    31 kscribble.cpp:107: warning: unused variable `KAction*custom'
    32 /usr/lib/qt/bin/moc /home/caleb/kscribble/src/kscribbleview.h -o kscribbleview.moc
    33 source='kscribbleview.cpp' object='kscribbleview.o' libtool=no \
    34 depfile='.deps/kscribbleview.Po' tmpdepfile='.deps/kscribbleview.TPo' \
    35 depmode=gcc3 /bin/sh /home/caleb/kscribble/admin/depcomp \
    36 g++ -DHAVE_CONFIG_H -I. -I/home/caleb/kscribble/src -I.. -I/usr/local/kde3/include
       -I/usr/lib/qt/include -I/usr/X11R6/include -DQT_THREAD_SUPPORT -D_REENTRANT -Wnon-virtual-dtor
       -Wno-long-long -Wundef -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings -ansi
       -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new -c
       -o kscribbleview.o `test -f 'kscribbleview.cpp' || echo '/home/caleb/kscribble/src/'`kscribbleview.cpp
    37 kscribbleview.cpp: In member function `void KScribbleView::print(QPainter*,
    38  int, int)':
    39 kscribbleview.cpp:79: warning: unused parameter `QPainter*p'
    40 kscribbleview.cpp:79: warning: unused parameter `int height'
    41 kscribbleview.cpp:79: warning: unused parameter `int width'
    42 /usr/lib/qt/bin/moc /home/caleb/kscribble/src/pref.h -o pref.moc
    43 source='pref.cpp' object='pref.o' libtool=no \
    44 depfile='.deps/pref.Po' tmpdepfile='.deps/pref.TPo' \
    45 depmode=gcc3 /bin/sh /home/caleb/kscribble/admin/depcomp \
    46 g++ -DHAVE_CONFIG_H -I. -I/home/caleb/kscribble/src -I.. -I/usr/local/kde3/include
       -I/usr/lib/qt/include -I/usr/X11R6/include -DQT_THREAD_SUPPORT -D_REENTRANT -Wnon-virtual-dtor
       -Wno-long-long -Wundef -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings
       -ansi -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new
       -c -o pref.o `test -f 'pref.cpp' || echo '/home/caleb/kscribble/src/'`pref.cpp
    47 /usr/local/kde3/bin/dcopidl /home/caleb/kscribble/src/kscribbleiface.h
    > kscribbleiface.kidl ||
       ( rm -f kscribbleiface.kidl ; /bin/false )
    48 /usr/local/kde3/bin/dcopidl2cpp --c++-suffix cpp --no-signals --no-stub kscribbleiface.kidl
    49 source='kscribbleiface_skel.cpp' object='kscribbleiface_skel.o' libtool=no \
    50 depfile='.deps/kscribbleiface_skel.Po' tmpdepfile='.deps/kscribbleiface_skel.TPo' \
    51 depmode=gcc3 /bin/sh /home/caleb/kscribble/admin/depcomp \
    52 g++ -DHAVE_CONFIG_H -I. -I/home/caleb/kscribble/src -I.. -I/usr/local/kde3/include
       -I/usr/lib/qt/include -I/usr/X11R6/include -DQT_THREAD_SUPPORT -D_REENTRANT -Wnon-virtual-dtor
       -Wno-long-long -Wundef -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings
       -ansi -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new
       -c -o kscribbleiface_skel.o `test -f 'kscribbleiface_skel.cpp' ||
       echo '/home/caleb/kscribble/src/'`kscribbleiface_skel.cpp
    53 /bin/sh ../libtool --silent --mode=link --tag=CXX g++ -Wnon-virtual-dtor -Wno-long-long -Wundef -Wall
       -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings -ansi -D_XOPEN_SOURCE=500
       -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new -o kscribble -R
       /usr/local/kde3/lib -R /usr/lib/qt/lib -R /usr/X11R6/lib -L/usr/X11R6/lib -L/usr/lib/qt/lib
       -L/usr/local/kde3/lib main.o kscribble.o kscribbleview.o pref.o kscribbleiface_skel.o -lkio
    54 source='kscribble_client.cpp' object='kscribble_client.o' libtool=no \
    55 depfile='.deps/kscribble_client.Po' tmpdepfile='.deps/kscribble_client.TPo' \
    56 depmode=gcc3 /bin/sh /home/caleb/kscribble/admin/depcomp \
    57 g++ -DHAVE_CONFIG_H -I. -I/home/caleb/kscribble/src -I.. -I/usr/local/kde3/include
       -I/usr/lib/qt/include -I/usr/X11R6/include -DQT_THREAD_SUPPORT -D_REENTRANT -Wnon-virtual-dtor
       -Wno-long-long -Wundef -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings
       -ansi -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new
       -c -o kscribble_client.o `test -f 'kscribble_client.cpp' || echo
       '/home/caleb/kscribble/src/'`kscribble_client.cpp
    58 /bin/sh ../libtool --silent --mode=link --tag=CXX g++ -Wnon-virtual-dtor -Wno-long-long -Wundef
       -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings -ansi -D_XOPEN_SOURCE=500
       -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new -o kscribble_client -R
       /usr/local/kde3/lib -R /usr/lib/qt/lib -R /usr/X11R6/lib -L/usr/X11R6/lib -L/usr/lib/qt/lib
       -L/usr/local/kde3/lib kscribble_client.o -lkdecore
    59 gmake[2]: Leaving directory `/home/caleb/kscribble/src'
    60 gmake[2]: Entering directory `/home/caleb/kscribble'
    61 gmake[2]: Nothing to be done for `all-am'.
    62 gmake[2]: Leaving directory `/home/caleb/kscribble'
    63 gmake[1]: Leaving directory `/home/caleb/kscribble'
    64 *** Success ***

Мы пронумеровали строки для простоты их описания. Прежде всего, `gmake` работает рекурсивно. Это значит, что сначала он находит самый глубоковложенный каталог, обрабатывает его, затем подымается на уровень выше, обрабатывает этот каталог и так далее до самого верхнего.

Первая, интересующая нас строка - 24. В ней `make` обращается к GNU C++ компилятору `g++` для компиляции файла main.cpp. При этом используется некоторое количество дополнительных ключей, многие из которых можно настроить через &kdevelop;.

Перед компилированием следующего файла (kscribble.cpp, строка 29) вызывается команда `moc` (meta object compiler, компилятор мета-объектов) для kscribble.h (строка 25). Это из-за того, что классы KScribble используют механизм сигналов/слотов. Она подставляет вместо макроса Q_OBJECT действительный код. Получившийся файл, kscribble.moc, используется kscribble.cpp через #include.

### Базовый исходный код

Чтобы понять принцип работы KDE-программы, давайте сначала поближе рассмотрим исходный код, предоставленный Мастером приложений. Разберём код (почти) построчно, в том порядке, в котором он выполняется, до момента, когда программа войдёт в главный цикл событий и будет ожидать действий от пользователя. Т.к. большинство программ KDE имеют похожую структуру, это поможет вам легче ориентироваться в коде других программ (благо, се они распространяются с открытым исходным кодом).

#### Функция main()

Выполнение программы начинается с функции `main()`. Она прописана в файле main.cpp, её можно найти через "Обзор классов", в ветке "Глобальные функции".

    1  int main(int argc, char **argv)
    2  {
    3      KAboutData about("kscribble", I18N_NOOP("KScribble"), version, description,
    4                       KAboutData::License_GPL, "(C) 2002 Your Name", 0, 0, "you@you.com");
    5      about.addAuthor( "Your Name", 0, "you@you.com" );
    6      KCmdLineArgs::init(argc, argv, &about);
    7      KCmdLineArgs::addCmdLineOptions(options);
    8      KApplication app;
    9
    10    // register ourselves as a dcop client
    11    app.dcopClient()->registerAs(app.name(), false);
    12
    13    // see if we are starting with session management
    14    if (app.isRestored())
    15        RESTORE(KScribble)
    16    else
    17    {
    18        // no session.. just start up normally
    19        KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
    20        if (args->count() == 0)
    21        {
    22            KScribble *widget = new KScribble;
    23            widget->show();
    24        }
    25        else
    26        {
    27            int i = 0;
    28            for (; i < args->count(); i++)
    29            {
    30                KScribble *widget = new KScribble;
    31                widget->show();
    32                widget->load(args->url(i));
    33            }
    34        }
    35        args->clear();
    36    }
    37
    38    return app.exec();
    39 }

В ней создаётся объект `KApplication`, но перед этим добавляются некоторые методы KDE, указывающие информацию о программе и авторе.

#### Запуск пользвтельского приложения

... (забыли написать)

#### Конструктор

Давайте посмотрим на использование конструктора

    1  KScribble::KScribble()
    2      : KMainWindow( 0, "KScribble" ),
    3        m_view(new KScribbleView(this)),
    4        m_printer(0)
    5  {
    6      // accept dnd
    7      setAcceptDrops(true);
    8
    9      // tell the KMainWindow that this is indeed the main widget
    10     setCentralWidget(m_view);
    11
    12     // then, setup our actions
    13     setupActions();
    14
    15     // and a status bar
    16     statusBar()->show();
    17
    18     // allow the view to change the statusbar and caption
    19     connect(m_view, SIGNAL(signalChangeStatusbar(const QString&)),
    20             this,   SLOT(changeStatusbar(const QString&)));
    21     connect(m_view, SIGNAL(signalChangeCaption(const QString&)),
    22             this,   SLOT(changeCaption(const QString&)));
    23
    24  }

`KScribble` наследует класс `KMainWindow` - базовый класс KDE-программ. Класс `KScribbleView` инициализируется как центральный элемент управления, `KStatusBar` создаётся методом `statusBar()` (строка 16), затем некоторые сигналы соединяются со слотами.

## Создание представления

### Введение

При объектно-ориентированной разработке программ (с графическим интерфейсом), большая часть работы заключается в разработке т.н. "представления" ("view", дизайна пользовательского интерфейса) Нужно уметь эргономично располагать элементы управления в окнах и других объектах, не злоупотреблять, но и не пренебрегать ними. Программа реализует свою интерактивность именно через элементы управления, соединённые со слотами, а также через клавиатуру - реагируя на нажатия определённых (комбинаций) клавиш. Панель состояния предназначена для отображения текущей (некритичной) информации, например о состоянии приложения, или о свойствах открытого документа. Рассмотрим конструирование пользовательского интерфейса на примере редактора.

Редактор - это программа, предназначенная для просмотра и/или редактирования содержимого текстовых файлов. Если вы запустите Kate, то увидите следующие элементы интерфейса:

- Меню: комплексные (в т.ч. не часто используюмые) действия, открытие, сохранение и закрытие файлов и т.д.

- Панель инструментов: набор значков, предоставляющих быстрый доступ к наиболее часто используемым действиям (таковые, при желании, определяются пользователем),

- Панель состояния: позиция курсора, вставка/замена,

- Представление, отображающее содержание файла, содержащее курсор, управляемый с клавиатуры, для работы с данными.

Последняя является наиболее уникальной частю программы. Правильное её проектирование определяет простоту использования программы ("usability"). Это значит, что одним их первых шагов при разработке должно быть определение задач программы и какой дизайн подойдёт лучше, так, чтобы на обучение и, самое главное, на работу с программой, требовалось как можно меньше времени.

Для таких задач как редактирование текста и отображение HTML, библиотеки Qt и KDE предоставляют уже готовые решения, "представления", по сути - высокоуровневые элементы управления. Но для большинства приложений, всё же придётся делать новые элементы управления. Вот что делает из программиста дизайнера и где становится востребованной вещь, называемая модным словом "креатив", или попросту творчество. Тут, прежде всего, главное интуитивность. Помните, что большинство людей не будут использовать программу, которая не:

- красивая

- предлагает большое количество возможностей

- простая в использовании

- быстрая в изучении

Излишним будет говорить, что стабильность - самая главная цель. Никто не может 100% избежать ошибок ("bugs"), но разумное проектирование позволяет значительно уменьшить количество возможных недоработок. Программирование на C++, если вы знаете как использовать его лучшие стороны - наследовательность, скрытие информации (модульность) и повторное использование одного кода, безусловно принесёт вам успех.

При создании проекта KDE или Qt, его представление (view) всегда наследует QWidget, либо напрямую, либо через другие элементы управления библиотек. Мастер приложений также создёт код, содержащий класс yourappView, наследователь QWidget.

В этой главе мы опишем как использовать элементы управления библиотек для создания новыхпредставлений, потом будет обзор готовых представлений, которые они уже содержат.

### Использование библиотечных представлений

После проектирования вашего приложения, просмотрите уже существующий код. В т.ч. найдите элемент управления, который можно использовать как представление, или хотябы как его часть, либо напрямую, либо наследованием. Библиотеки KDE и Qt уже содержат набор элементов управления, которые можно для этого использовать. Есть два способа этого:

1. Удалить класс текущего представления и создать экземпляр библиотечного элемента управления, затем установить его как представление,

2. Изменить наследование текущего класса представления.

В любом случае, не забудьте связать программу с библиотекой с элементом управления, иначе компоновщик будет выдавать ошибку. Перейдите в "Проект"->"Параметры", вкладка "Параметры компоновщика" в &kdevelop;. Если в списке не будет этой библиотеки, допишите её сюда. Чтобы изменить список библиотек, которые должны быть найдены сценарием `configure`, добавьте соответствующий макрос в `configure.in` из корневого каталога вашего проекта. После этого, не забудьте выполнить "Сборка"->"Autoconf и automake" и "Сборка"->"Configure".

Также, если заголовочные файлы библиотеки находятся не в стандартном каталоге (это можно проверить по ключам -I окна вывода команды "Make"), на вкладке "Параметры компиляции" настроек проекта, добавьте нужный каталог с ключём -I или соответствующим макросом automake в поле "Дополнительные параметры".

#### Представления Qt

На первой странице документации Qt вы можете найти ссылку на "Widget Screenshots", чтобы выбрать нужный. Они уже готовы к использованию, и их можно совмещать. Далее, мы обсудим некоторые из них, но помните, что библиотеки KDE могут содержать свои (доработанные) элементы управления, предназначенные для тех же задач.

Вот несколько компонентов Qt и их назначения:

1. Если в области вашего представления не хватает свободного места, пользователь должен перемещаться по документу с помощью полос прокрутки. Для этого, в Qt есть класс `QScrollView`. Вы можете сделать свой элемент управления наследником `QScrollView` или использовать его экземпляр для управления представлением.

2. Для создания ScrollView, унаследуйте виджет-представление от `QWidget` и и добавьте вертикальные и горизонтальные полосы прокрутки `QScrollBars` (так делается в KHTMLView).

3. Для обработки текста, пвоспользуйтесь `QTextEdit`. Этот класс предоставляет законченный виджет текстового редактора, который уже поддерживает операции с буфером обмена, а также управляется полосами прокрутки scrollview.

4. Воспользуйтесь `QTable` для отображения данных, организованных в таблицу. `QTable` также управляется полосами прокрутки.

5. Для отображения двух различных виджетов или двух экземпляров одного виджета одновременно, воспользуйтесь `QSplitter` . Он позволяет разделить представления горизонтально или вертикально. Его использует KMail и KBabel.

6. `QListView` отображает данные в виде списка и дерева. Используйте его для вывода иерархических данных.

Всё, что вам нужно, уже есть в Qt, вам остаётся лишь узнать о нужном вам элементе, научиться его использовать, и, если необходимо, дополнять. Использование стандартных решений позволяет пользователям, привыкшим к ним, сконцентрироваться на информации, которую они несут.

#### Представления KDE

Библиотеки KDE созданы чтобы ещё более упростить создание приложений для K Desktop Environment. Библиотека kdeui предлагает:

1. KListView: более мощная версия `QListView`

2. KIconView: графический просмотр значков

Библиотека khtml предоставляет полный интерпретатор HTML. Вы можете использовать его для оформления вида вашего приложения по его запуску.

### Создание собственных представлений

НАПИСАТЬ

## Настройка меню и панелей инструментов

### Введение

Меню и панели инструментов - одни из самых главных частей приложения для работы с документами. Следуя общим правилам, все возможные действия должны быть доступны через меню, и только часто используемые - на панели инструментов.

В программе может быть несколько панелей инструментов. Они, кроме кнопок, могут также содержать выпадающие списки и т.д.

### Как это работает?

Приожение наследует класс `KMainWindow`, который сам заботится о создании панели инструментов и меню. В методе `KScribble::setupActions()` есть вызов `KMainWindow::createGUI()`. Этот метод загружает файл ресурсов, в нашем случае это kscribbleui.rc, для инциализации меню. Вот его содержание:

    1 <!DOCTYPE kpartgui SYSTEM "kpartgui.dtd">
    2 <kpartgui name="kscribble" version="1">
    3 <MenuBar>
    4   <Menu name="custom"
    ><text
    >C&ustom</text>
    5     <Action name="custom_action" />
    6   </Menu>
    7 </MenuBar>
    8 </kpartgui
    >

Объяснение...

Можо обойтись и без файла ресурсов. Например, метод `menuBar()` возвращает элемент управления `KMenuBar`, являющийся меню для нашей програмы. `KMenuBar` и его родительский класс `QMenuBar` имеют большое количество методов `insertItem()` для добавления пунктов меню.

Методы `KMainWindow` `statusBar()` и `toolBar()` также предоставляют соответствующие элементы управления.

### Настройка комбинаций клавиш.

Вы должны всегда заботиться о том, чтобы все действия в вашей пограмме можно было выполнить лишь с клавиатуры. Такой метод используется опытными пользователями. Для этого в библиотеках KDE естькласс `KAction`.

Программы, сгенерированные &kdevelop;, только используют стандартные комбинации клавиш, такие как F1 или Ctrl+N.

Если в вашей программе много компбинаций клавиш, лучше сделать их настраиваемыми (через меню Настройка->Комбинации клавиш). Библиотека KDE предоставляет для этого класс `KKeyChooser` для использования в диалогах с вкладками, тогда как `KKeyDialog` предоставляет отдельный диалог.

## Справка

### Введение

Помните, что не все пользователи - Linux-гуру и для некоторых из них нужна справка (как контекстная, так и просто руководство):

- Всплывающие подсказки

- Сообщения в строке состояния

- Что это?

Ну, и конечно же, руководство, вызываемое через F1. Всё это предоставляется классом `KMainWindow`, а вам лишь остаётся наполнить его содержимым.

&kdevelop; содержит вспомогательные средства для включения всех типов справки в ваше приложение.

В процессе разрабтки вашего приложения, попытайтесь быть последовательными ввезде. Пишите справку сразу после написания кода. Иначе потом придётся заново лезть в код и разбираться что к чему.

### Всплывающие подсказки

Самая простая справка - всплывающие подсказки (появляющиеся после задержки курсора над объектом). Наиболее часто они используются на панелях инструментов. За подробностями обращайтесь к документации класса `KToolBar`, расположенного в библиотке kdeui.

Как пример, мы рассмотрим кнопку "New File":

i18n("New File") нужна заключать в макрос i18n(), описанный в kapp.h, для отметки этой строки для перевода на другие языки.

Подсказки также можно добавлять в любой другой элемент управления через `QToolTip`:

### Расширение панели состояния

Т.к. приложения, наследующие класс `KMainWindow`, содержат также панель состояния, её можно использовать для отображения более длинного теекста, чем в подсказке.

### Кнопка Что это?

Подсказка Что это? должна содержать кратку справку (абзац-два) по выбраному элементу. Сама кнопка Что это? обычно располагается либо в меню, либо на панели инструментов, либо в загаловке окна. После нажатия на ней, пользователь должен нажать на нужной объекте.

Для добавления такой справки, воспользуйтесь статическим методом `QWhatsThis::add(QWidget *widget, const QString &text)`

## Документация

### Введение

Програмы, создаваемые в &kdevelop; уже содержат шаблон для документации.

### Пользовательская документация

Документация для вашего проекта располагается в путь-к-проекту/doc/en/index.docbook. Справка по языку разметки, используемому для написания докуметтации, можно найти на KDE's documentation website. Если вы испытываете трудности в написании руководства на английском, можете обратиться к KDE Editorial Team (см. ссылку выше).

### Документация для разработчиков

Данная документация обычно генерируется автоматически и содержит описание классов приложения. Например, так создаётся документация к библиотеке KDE. За подробностями обращайтесь сюда

## Интернационализация

### Введение

i18n - сокращение от internationalization. Интернационализация заключается в переводе всех сообщений программы на другие языки, а также всесторонней их поддержке (как-то множественные формы, поддержка кодировок и т.д.). Изначально программа и документация к ней должны быть на английском, т.к. большинство потенциальных переводчиков знает именно этот язык (если бы KDE был изначально на немецком, врядли мы бы увидели его русский перевод).

## Перевод

Перевод осуществил Н. Шафоростов, http://program.net.ua

## Библиография

#### GNU Make Manual

Richard M.
Stallman
Roland
McGrath

#### GNU Automake

David
MacKenzie
Tom
Tromey

#### GNU Autoconf

David
MacKenzie
Ben
Elliston

#### Using the GNU Compiler Collection

Richard M.
Stallman

#### GNU Libtool

Gordon
Matzigkeit
Alexandre
Oliva
Thomas
Tanner
Gary V.
Vaughan

#### GNU Autoconf, Automake и Libtool

1st edition
October 2000
Gary V.
Vaughan
Ben
Elliston
Tom
Tromey
Ian Lance
Taylor
New Riders Publishing
ISBN 1578701902

#### Advanced Programming in the UNIX(R) Environment

1st edition
June 1992
W. Richard
Stevens
Addison-Wesley Pub Co
ISBN 0201563177

#### Thinking in C++, Volume 1: Introduction to Standard C++

2nd Edition
April 15, 2000
Bruce
Eckel
Prentice Hall
ISBN 0139798099

#### Open Source Development with CVS

2nd Edition
October 12, 2001
Karl
Fogel
Moshe
Bar
The Coriolis Group
ISBN 158880173X

#### Programming PHP

1st edition
March 2002
Rasmus
Lerdorf
Kevin
Tatroe
O'Reilly & Associates
ISBN 1565926102

#### Programming Python

2nd Edition
March 2001
Mark
Lutz
O'Reilly & Associates
ISBN 0596000855

#### Gui Programming With Python : Using the Qt Toolkit

Bk&Cd-r edition
January 2002
Boudewijn
Rempt
Opendocs Llc
ISBN 0970033044

#### Programming Perl

The Camel book
3rd Edition
July 2000
Larry
Wall
Tom
Christiansen
Jon
Orwant
O'Reilly & Associates
ISBN 0596000278

#### Learning Perl

The Lama book
3rd Edition
July 15, 2001
Randal L.
Schwartz
Tom
Phoenix
O'Reilly & Associates
ISBN 0596001320

&underFDL;