Программирование с Qt

Часть 1. Введение. Инструменты разработчика и объектная модель

Серия контента:

1. Введение

Существуют версии Qt для unix-подобных операционных систем с X Window System (например, X.Org (EN), Mac OS X и ОС Windows). Также Qt Software портирует свой продукт на мобильные платформы: Embedded Linux (EN), S60 (EN) и Windows CE. Qt предоставляет большие возможности кросс-платформенной разработки самых разных программ, не обязательно с графическим интерфейсом. На нем, в частности, основана популярная среда рабочего стола KDE (EN).

Инструментарий разбит на модули , каждый из которых размещается в отдельной библиотеке. Базовые классы находятся в QtCore , компоненты графических интерфейсов – в QtGui , классы для работы с сетью – в QtNetwork и т.д. Таким образом, можно собирать программы даже для платформ, где нет X11 или другой совместимой графической подсистемы.

2. Установка Qt

Нам потребуется установить среду разработки Qt. Программное обеспечение распространяется на условиях свободной лицензии GPL 3.0 или LGPL 2.1. Его можно получить по адресу http://www.qtsoftware.com/downloads (EN).

2.1. Базовые библиотеки и инструменты

В репозиториях популярных дистрибутивов GNU/Linux уже есть готовые пакеты со средой разработки Qt (например, в Debian, Fedora, Gentoo, Mandriva, Ubuntu). Тем не менее, пользователь может собрать и установить инструментарий из исходных текстов.

Для систем, использующих X11, необходимо загрузить файл qt-x11-opensource-src-4.x.y.tar.gz , где 4.x.y – последняя доступная версия из стабильных. Мы будем устанавливать версию 4.5.0.

В директории с файлом qt-x11-opensource-src-4.5.0.tar.gz выполните следующие команды:

Прежде чем собирать Qt, запустите скрипт configure . Полный набор его опций выдается по команде./configure -help , но обычно можно использовать типовые настройки.

Параметр -prefix задает каталог для установки (по умолчанию используется /usr/local/Trolltech/Qt-4.5.0). Также имеются ключи для инсталляции различных компонентов (исполняемых файлов, библиотек, документации, и т.д.) в разные директории.

При запуске скрипт требует подтвердить согласие пользователя с условиями лицензии GPL / LGPL. После выполнения

можно запустить сборку и установку при помощи команд:

Имейте в виду, что компиляция занимает много времени, а для установки Qt могут потребоваться права суперпользователя (файлы записываются в /usr/local/).

Если в дальнейшем вам понадобится в той же директории заново сконфигурировать и пересобрать Qt, удалите все следы предыдущей конфигурации при помощи make confclean , прежде чем снова запускать./configure .

Путь к исполняемым файлам Qt нужно добавить в переменную окружения PATH. В оболочках bash, ksh, zsh и sh это можно сделать, дописав в файл ~/.profile следующие строки:

В csh и tcsh нужно дописать в ~/.login строку:

Если вы используете другую оболочку, то обратитесь к соответствующим разделам документации.

Кроме того, необходимо добавить строку /usr/local/Trolltech/Qt-4.5.0/lib в переменную LD_LIBRARY_PATH , если компилятор не поддерживает RPATH. Мы используем GNU/Linux и GCC (EN), поэтому пропускаем этот шаг.

Затем с помощью утилиты qtdemo запустите демонстрационные приложения для проверки работоспособности установленного инструментария.

2.2. SDK

Недавно появилась кросс-платформенная среда разработки Qt Creator. На сайте Qt Software можно найти полный SDK, включающий IDE (помимо библиотек и основных средств разработчика). Загрузите бинарный файл qt-sdk-linux-x86-opensource-xxx.bin и запустите мастер установки:

Если не собираетесь устанавливать SDK в домашнюю директорию, то запускайте инсталлятор с правами суперпользователя.

3. Инструменты разработчика

В состав Qt включены инструменты разработчика с графическим или консольным интерфейсом. В их числе:

• assistant – графическое средство для просмотра гипертекстовой документации по инструментарию и библиотекам Qt.
• designer – графическое средство для создания и сборки пользовательских интерфейсов на основе компонентов Qt.
• qmake – кросс-платформенный генератор Makefile.
• moc – компилятор метаобъектов (обработчик расширений Qt для C++).
• uic – компилятор пользовательских интерфейсов из файлов.ui, созданных в Qt Designer.
• rcc – компилятор ресурсов из файлов.qrc.
• qtconfig – графическое средство установки пользовательских настроек для приложений Qt.
• qtdemo – запуск примеров и демонстрационных программ.
• qt3to4 – средство переноса проектов с Qt 3 на Qt 4.
• linguist – средство для локализации приложений.
• pixeltool – экранная лупа.

3.1. qmake

Утилита qmake используется для автоматического генерирования Makefile на различных платформах.

В целом qmake ориентируется на Qt. Если вас интересуют кросс-платформенные системы сборки более широкого назначения, то можете обратиться к CMake, которая также поддерживает Qt.

Новичкам стоит остановиться на qmake.

Полную документацию по этой утилите вы можете найти в Qt Assistant. Также с Qt поставляются страницы руководства, в том числе qmake(1) (наберите в командной строке man qmake). Здесь мы приведем основные указания, которые помогут вам собирать код примеров статьи, а также свои простые проекты.

В качестве примера создадим директорию myproject и добавим туда файлы hello.h, hello.cpp и main.cpp . В hello.h опишем прототип функции hello():

Листинг 1.1. Объявления функций программы «Hello, World!»

Реализацию hello() поместим в hello.cpp:

Листинг 1.2. Реализации функций программы «Hello, World!»

Здесь qDebug() используется для вывода отладочной информации. Ее можно убрать, объявив при компиляции символ QT_NO_DEBUG_OUTPUT . Также имеется функция qWarning() , выдающая предупреждения, и qFatal() , завершающая работу приложения после вывода сообщения о критической ошибке в STDERR (то же самое, но без завершения работы, делает qCritical()).

В заголовочном файле содержатся объявления, добавляющие для qDebug(), qWarning() и qCritical() более удобный синтаксис оператора << . При этом между аргументами (как в случае qDebug() << a << b << c;) автоматически расставляются пробелы, поддерживается вывод многих типов C++ и Qt, а в конце автоматически добавляется перевод строки.

Код основного приложения (здесь мы следуем соглашению, по которому main() помещается в файл main.cpp):

Листинг 1.3. Функция main() программы «Hello, World!»

Чтобы создать файл проекта, запустите

После этого должен появиться файл myproject.pro примерно такого содержания:

#################################### # Automatically generated by qmake #################################### TEMPLATE = app TARGET = DEPENDPATH += . INCLUDEPATH += . # Input HEADERS += hello.h SOURCES += hello.cpp main.cpp

Оператор = используется для присвоения значений переменным, += добавляет новую опцию к переменной, -= удаляет указанную опцию.

TEMPLATE = app обозначает, что мы собираем приложение; для библиотеки используется TEMPLATE = lib .

TARGET – имя целевого файла (укажите TARGET = foobar , чтобы получить исполняемый файл foobar).

DEPENDPATH – директории для поиска при разрешении зависимостей.

INCLUDEPATH – директории с заголовочными файлами.

После запуска

на основе myproject.pro в GNU/Linux будет создан обычный Makefile:

####### Compile hello.o: hello.cpp hello.h $(CXX) -c $(CXXFLAGS) $ (INCPATH) -o hello.o hello.cpp main.o: main.cpp hello.h $(CXX) -c $(CXXFLAGS) $ (INCPATH) -o main.o main.cpp ####### Install install: FORCE uninstall: FORCE FORCE:

Опции qmake влияют на содержимое Makefile. Например, qmake -Wall добавит к флагам компилятора -Wall – вывод всех предупреждений.

По команде make мы получим исполняемый файл myproject , который выводит на экран строку «Hello, World!».

Эта схема может показаться слишком сложной, но в реальных проектах qmake берет на себя большую часть работы по сборке (например, запускает компилятор метаобъектов).

3.2. Qt Creator

Описанных выше инструментов достаточно для разработки приложений. Вы можете использовать любимый текстовый редактор, например GNU Emacs или Vim. С Qt работают также традиционные IDE, такие как KDevelop.

Однако не так давно Qt Software выпустила свою кросс-платформенную IDE Qt Creator. В неё встроены все инструменты разработчика, имеется редактор с подсветкой и дополнением кода, отладчик (графический интерфейс для gdb), а также реализована поддержка Perforce, SVN и Git.

При работе в Qt Creator используется несколько режимов, которым соответствуют вкладки на панели слева. Для быстрого переключения между режимами можно использовать комбинации клавиш Ctrl+1, Ctrl+2 , и т.д. Основному режиму редактирования соответствует Ctrl+2 .

Для навигации в редакторе применяется комбинация клавиш Ctrl+K . После ее нажатия нужно указать один из префиксов:

Таблица 1. Префиксы для навигации в Qt Creator

После префикса нажмите пробел и введите соответствующую информацию. Например, для перехода на строку 93 текущего файла нужно напечатать " l 93 " (то же самое можно сделать при помощи Ctrl+L), для перехода к документации по теме qobject_cast – "? qobject_cast" и т.д.

В нижней части окна при этом отображается поле с автоматическим дополнением.

Рисунок 5. Поле для навигации в Qt Creator

Таблица 2. Комбинации клавиш для редактора Qt Creator

Во встроенном редакторе реализовано «умное» дополнение кода, вызываемое комбинацией клавиш Ctrl+<Пробел> . База символов составляется на основе заголовочных файлов проекта из INCLUDEPATH .

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

Чтобы переключиться из режима справки или отладки в основной режим редактирования, нажмите Esc . В режиме редактирования Esc переводит фокус из дополнительных окон (например, вывода компиляции или контекстной справки) на редактор. Если нажать Esc еще раз, то дополнительные окна закрываются.

Как и qmake , Qt Creator использует файлы в формате.pro , поэтому в IDE легко импортируются старые проекты, созданные вручную. Также доступен мастер, при помощи которого можно создать заготовку нового проекта.

Сейчас Qt Creator активно разрабатывается, но если вам нужна классическая IDE для Qt, работающая на различных платформах, то это лучший вариант.

4. Стиль Qt

В Qt используется CamelCasing : имена классов выглядят как MyClassName , а имена методов – как myMethodName .

При этом имена всех классов Qt начинаются с Q , например QObject, QList или QFont .

Большинству классов соответствуют заголовочные файлы с тем же именем (без расширения.h), т.е. нужно использовать:

Поэтому в дальнейшем мы не будем отдельно оговаривать, где объявлен тот или иной класс.

Методы для получения и установки свойств (getter и setter ) именуются следующим образом: свойство fooBar можно получить при помощи метода fooBar() и установить при помощи setFooBar() .

При разработке собственных приложений на Qt стоит придерживаться этого стиля.

5. Объектная модель

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

• древовидные иерархии объектов;
• аналог dynamic_cast для библиотеки, не использующий RTTI;
• взаимодействие объектов через сигналы и слоты ;
• свойства объектов.

Многие объекты определяются значением сразу нескольких свойств, внутренними состояниями и связями с другими объектами. Они представляют собой индивидуальные сущности, и для них не имеет смысла операция буквального копирования, а также разделение данных в памяти. В Qt эти объекты наследуют свойства QObject .

В тех случаях, когда объект требовалось бы рассматривать не как сущность, а как значение (например, при хранении в контейнере) – используются указатели. Иногда указатель на объект, наследуемый от QObject , называют просто объектом.

Инструментарий спроектирован так, что для QObject и всех его потомков конструктор копирования и оператор присваивания недоступны – они объявлены в разделе private через макрос Q_DISABLE_COPY() :

Будьте внимательны и не используйте конструкцию

Foo bar = Foo (baz);

Другие объекты (например, контейнеры и строки) полностью определяются представляемыми данными, поэтому в соответствующих классах имеются операция присваивания и конструктор копирования. Кроме того, объекты, представляющие одинаковые данные, могут прозрачно для программиста разделять их в памяти.

5.1. Система метаобъектов

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

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

В сложных ситуациях Qt использует свой компилятор метаобъектов moc , преобразующий код с расширениями в стандартный код C++. Для обозначения того, что класс использует метаобъектные возможности (и, соответственно, должен обрабатываться moc), в разделе private нужно указать макрос Q_OBJECT .

Если вы встречаете странные ошибки компиляции, сообщающие, что у класса не определен конструктор, либо у него нет таблицы виртуальных функций (vtbl), скорее всего вы забыли код, генерируемый moc. Обычно это происходит, если не указан макрос Q_OBJECT .

Во избежание ошибок Q_OBJECT лучше использовать во всех классах, наследуемых от QObject (косвенно либо напрямую).

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

В числе прочих, метаобъектный код добавляет метод

virtual const QMetaObject* QObject::metaObject() const;

который возвращает указатель на метаобъект объекта.

На системе метаобъектов основаны сигналы, слоты и свойства.

При наследовании от QObject помните об ограничениях, налагаемых moc:

1. При множественном наследовании потомком QObject должен быть первый и только первый наследуемый класс: class MyClass: public QObject, public Foo, public Bar { // ... };
2. Виртуальное наследование с QObject не поддерживается.

5.2. qobject_cast

Для динамического приведения QObject используется функция

T qobject_cast (QObject *object);

Она работает как стандартная операция dynamic_cast в C++, но не требует поддержки со стороны системы динамической идентификации типов (RTTI).

Пусть у нас имеется класс MyClass1 , наследующий от QObject и MyClass2 , наследующий от MyClass1:

Динамическое приведение иллюстрирует следующий код:

Эти операции сработают корректно на стадии выполнения.

Как и в случае с dynamic_cast , результат приведения можно проверить:

Система метаобъектов позволяет также проверить, наследует ли a класс MyClass1:

Однако предпочтителен предыдущий вариант с qobject_cast .

5.3. Деревья объектов

Объекты классов, наследующих от QObject , могут быть организованы в древовидную структуру. При удалении объекта Qt удаляет его дочерние объекты , которые в свою очередь удаляют свои дочерние объекты, и т.д. Иными словами, удаление объекта приводит к удалению всего поддерева, корнем которого он является.

Пусть у нас имеются классы ClassA и ClassB:

Листинг 2.1. Объявление MyClass для программы, демонстрирующей порядок создания и удаления объектов

Листинг 2.2. Определение методов MyClass для программы, демонстрирующей порядок создания и удаления объектов

Здесь родительский объект устанавливается в конструкторе QObject:

QObject::QObject (QObject *parent = 0);

Его можно установить в последующем при помощи метода setParent() и получить при помощи parent() :

void QObject::setParent (QObject *parent);
QObject* QObject::parent() const;

Если создать в стеке по одному из объектов A и B, то сначала будет создан A, потом B. В соответствии со стандартом C++, удаление происходит в обратном порядке – сначала B, затем A:

Листинг 2.3. Создание экземпляров MyClass в стеке

Если создать B в куче и назначить его дочерним объектом для A, то вместе с A автоматически удалится B:

Листинг 2.4. Создание экземпляра A класса MyClass в стеке, а экземпляра B – в куче, как дочернего для A

Аналогично для более сложных деревьев:

Рисунок 8. Пример многоуровневого дерева объектов

Листинг 2.5. Многоуровневое дерево объектов с корнем в стеке

После удаления A удалится всё дерево.

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

Если объект и его дочерние объекты созданы в стеке, то подобный порядок удаления может привести к ошибкам.

Здесь при выходе из области действия сначала будет удален объект A, так как он был создан последним. При этом Qt удалит и его дочерний объект B. Но потом будет сделана попытка удаления B, что приведет к ошибке.

В другом случае проблем не будет, потому что при вызове деструктора QObject объект удаляет себя из списка дочерних объектов родительского объекта:

Вообще говоря, дочерние объекты должны размещаться в куче.

У каждого QObject есть свойство objectName , для доступа к которому используются методы

По умолчанию objectName – пустая строка. Через это свойство объектам в дереве можно присвоить имена для последующего поиска.

const QList& children() const;

– возвращает список дочерних объектов.

T findChild (const QString& name = QString()) const;

– возвращает дочерний объект с именем name , который можно привести к типу T, либо 0, если такой объект не найден. Без аргумента name возвращает все дочерние объекты. Поиск осуществляется рекурсивно.

QList QObject::findChildren (const QString& name = QString()) const;

– возвращает все дочерние объекты с именем name , которые можно привести к типу T , либо пустой список, если таких объектов не найдено. Без аргумента name возвращает все дочерние объекты. Поиск осуществляется рекурсивно.

QList QObject::findChildren (const QRegExp& regExp) const;

– аналогично, но с поиском по регулярному выражению regExp .

void dumpObjectTree();

– выводит отладочную информацию о дереве объектов с данным корнем.

5.4. Сигналы и слоты

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

В Qt вводится концепция сигналов и слотов.

Сигнал отправляется при вызове соответствующего ему метода. Программисту при этом нужно только указать прототип метода в разделе signals .

Слот является методом, исполняемым при получении сигнала. Слоты могут объявляться в разделе pulic slots, protected slots или private slots . При этом уровень защиты влияет лишь на возможность вызова слотов в качестве обычных методов, но не на возможность подключения сигналов к слотам.

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

5.4.1. Объявление сигналов и слотов, отправка сигналов

В качестве типичного примера слота рассмотрим метод получения свойства (getter ). Методу установки свойства (setter ) при этом будет соответствовать сигнал.

Листинг 3.1. Класс MyClass со слотом void setValue (int x) и сигналом void valueChanged (int x)

Обратите внимание на макрос Q_OBJECT , сигнализирующий Qt о том, что используются возможности системы метаобъектов.

Листинг 3.2. Реализация методов класса MyClass со слотом void setValue (int x) и сигналом void valueChanged (int x)

Ключевое слово emit отвечает за отправку сигнала.

Для сигнала задается только прототип, причем сигнал не может возвращать значение (т.е., указывается void). За реализацию отвечает компилятор метаобъектов, он же преобразует расширенный синтаксис с ключевыми словами signals, slots, emit в стандартный код C++.

На самом деле, ключевые слова можно заменить на макросы Q_SIGNALS, Q_SLOTS и Q_EMIT . Это полезно, если вы используете сторонние библиотеки, в которых уже используются слова signals, slots или emit .

Обработка ключевых слов отключается флагом no_keywords . В файл проекта qmake (.pro) добавьте

CONFIG += no_keywords

Вы можете посмотреть на результат работы компилятора метаобъектов в файле moc_slots.cpp , который генерируется на основе slots.h и компилируется вместе с остальными.cpp .

5.4.2. Подключение сигнала к слоту

Листинг 3.3. Подключение сигнала void MyClass::valueChanged (int x) к слоту void MyClass::setValue (int x)

Здесь при помощи QObject::connect сигнал объекта a соединяется со слотом объекта b (передаются указатели на QObject). Макросы SIGNAL и SLOT формируют строковые сигнатуры методов. Их аргументы должны содержать прототипы без указания имен переменных, т.е. SIGNAL(valueChanged(int x)) – недопустимый вариант.

Сигнатуры используются для сверки типов: сигнатура сигнала должна соответствовать сигнатуре слота. При этом у слота сигнатура может быть короче, если дополнительные аргументы игнорируются.

Другой вариант вызова QObject::connect:

b.connect (&a, SIGNAL(valueChanged(int)), SLOT(setValue(int)));

Таким образом, здесь вызов MyClass::setValue для a задействует MyClass::setValue для b .

Обратите внимание на строку if (x_ == x) return; . Она нужна, чтобы избежать проблем при циклических соединениях. Например, следующий код сработает:

Листинг 3.4. Циклическое соединение сигналов void MyClass::valueChanged (int x) со слотами void MyClass::setValue (int x)

QObject::connect возвращает true , если соединение успешно установлено, и false в противном случае – например, когда сигнал или слот не обнаружен, либо их сигнатуры несовместимы.

Если добавить при помощи QObject::connect одинаковые соединения, то слот будет вызываться несколько раз.

5.4.3. Отключение

Для отключения сигнала от слота используется QObject::disconnect:

При успешном отключении возвращается true .

Если вместо сигнала (SIGNAL(...)) указать 0, то данный получатель сигнала (b) и слот отключаются от любого сигнала:

QObject::disconnect (&a, 0, &b, SLOT(setValue(int)));

Если 0 указать вместо получателя сигнала (b) и слота (SLOT(...)) , то отключено будет всё, что подключено к данному сигналу:

QObject::disconnect (&a, SIGNAL(valueChanged(int)), 0, 0);

Если 0 указать вместо слота (SLOT(...)) , то отключено будет всё, что подключено к данному получателю сигнала (b):

QObject::disconnect (&a, SIGNAL(valueChanged(int)), &b, 0);

Получаем следующие варианты вызова QObject::disconnect:

При удалении одного из объектов соединения Qt автоматически удаляет само соединение.

5.4.4. Ограничения

У компилятора метаобъектов имеется ряд ограничений, которые распространяются и на работу с сигналами и слотами.

1. moc не обрабатывает шаблоны и макросы, поэтому шаблоны классов не могут определять сигналы и слоты, а при объявлении сигналов и слотов нельзя использовать макросы (в том числе при указании параметров).

   Макросы нельзя использовать в любых участках кода, которые должны обрабатываться moc . В частности, через них нельзя указать базовый класс.

   Однако некоторые возможности препроцессора использовать можно. Доступны простые условные конструкции (с директивами #if, #ifdef, #ifndef, #else, #elif, #endif , а также специальным оператором defined). Для создания объявлений у moc имеется опция командной строки -D . Утилита qmake передает moc все объявления, перечисленные в параметре проекта DEFINES .

   Например, moc правильно обработает

   #if 0 // Игнорируемый блок #endif
   Блок #ifdef FOO // ... #endif

   также будет обработан, только если вызвать moc -DFOO , либо если до него имеется строка #define FOO .

Типы должны быть указаны полностью, так как QObject::connect() сравнивает их буквально. В частности, если внутри класса Foo определяется перечисление Bar , то в аргументах сигнала нужно указывать Foo::Bar:

class Foo: public QObject { Q_OBJECT enum Bar { a, b, c }; signals: void somethingHappened (Foo::Bar x); };

2. В качестве параметров сигналов и слотов нельзя использовать указатели на функции. Например,

   int (*fun)(int)

   не является допустимым аргументом. Можно использовать typedef:

   typedef int (*fun)(int);

   Обычно вместо указателей лучше применять наследование и виртуальные функции.

3. Вложенные классы не могут содержать сигналы и слоты.
4. Сигналы и слоты, возвращающие ссылки, обрабатываются таким образом, как если бы они возвращали void .
5. В разделах signals и slots могут объявляться только сигналы и слоты.

5.5. Свойства

Класс, наследующий QObject , может содержать объявление свойства при помощи макроса Q_PROPERTY() :

Q_PROPERTY(type name

READ getFunction

Обязательные параметры макроса:

• type – тип свойства;
• name – имя свойства;
• getFunction – const-метод для считывания значения; возвращаемый тип должен быть type, type* либо type& .

Не обязательные параметры макроса:

• setFunction – метод для установки значения свойства, должен возвращать void и принимать только один аргумент типа type, type* , либо type& ;
• resetFunction – метод для установки значения свойства по умолчанию, зависящего от контекста, должен не иметь аргументов и возвращать void ;

Методы могут быть виртуальными либо унаследованными от базового класса. При множественном наследовании они должны принадлежать первому классу в списке.

Для не обязательных атрибутов DESIGNABLE, SCRIPTABLE, STORED, USER допускается указание булевых значений:

• DESIGNABLE – показывать ли свойство в Qt Designer и подобных графических программах. По умолчанию true , также можно указать булев метод.
• SCRIPTABLE – должно ли свойство быть видимым скриптовому движку. По умолчанию true , также можно указать булев метод.
• STORED – должно ли свойство сохраняться при сохранении состояния объекта либо оно вычисляется через другие свойства. По умолчанию true .
• USER - редактируется ли свойство пользователем. Обычно у классов, соответствующих элементам управления, бывает одно такое свойство. По умолчанию false .

Например, QWidget объявляет, в числе прочих, следующие свойства:

Q_PROPERTY (QSize minimumSize READ minimumSize WRITE setMinimumSize) Q_PROPERTY(int minimumWidth READ minimumWidth WRITE setMinimumWidth STORED false DESIGNABLE false) Q_PROPERTY(int minimumHeight READ minimumHeight WRITE setMinimumHeight STORED false DESIGNABLE false)

Свойство minimumSize имеет тип QSize и может быть получено при помощи QSize minimumSize() const и установлено при помощи void setMinimumSize (const QSize&). minimumWidth и minimumHeight вычисляются через minimumSize , поэтому для них указано STORED false .

Пример свойства с атрибутом USER – text в QLineEdit:

Для считывания и записи свойства используются методы:

property() возвращает значение свойства либо неправильный вариант QVariant , если такого свойства нет.

setProperty() возвращает true , если у объекта есть указанное свойство с типом, совместимым с переданным значением. В противном случае возвращается false .

Если в классе нет указанного свойства, то добавляется динамическое свойство объекта. Перечень динамических свойств можно получить при помощи

Рассмотрим пример использования свойств. Пусть класс MyClass имеет строковое свойство text (типа QString):

Листинг 4.1. Объявление класса MyClass со свойством text

Листинг 4.2. Определение методов класса MyClass со свойством text

Работа со свойством:

Листинг 4.3. Работа со свойством text объекта MyClass

Программа должна вывести на экран следующее:

Разумеется, безопаснее и быстрее вызывать методы конкретного класса для считывания и записи свойств. property() и setProperty() нужны в том случае, когда о классе ничего не известно кроме имен и типов свойств.

Если для класса не известен даже перечень свойств и методов, можно использовать метаобъект.

5.6. Работа с метаобъектами

Метаобъект возвращается методом

QObject::metaObject()

С его помощью можно динамически получить информацию о классе, как, например, в Java Reflecion API (EN).

5.6.1. Основная информация

Имя класса возвращает

const char * QMetaObject::className() const;

Указатель на метаобъект базового класса –

const QMetaObject* superClass() const;

5.6.2. Методы

Через систему метаобъектов доступны только те методы и конструкторы, перед объявлениями которых указан макрос Q_INVOKABLE:

Для доступа к методам (в том числе сигналам и слотам) используйте

Методы и свойства класса проиндексированы. Доступ к методу по индексу осуществляется через QMetaObject::method() .

Общее число методов, с учетом наследованных, возвращает QMetaObject::methodCount() . Смещение методов класса возвращается QMetaObject::methodOffset() , оно показывает, с какого индекса начинаются методы данного класса. Смещение увеличивается при наследовании и показывает число методов базовых классов.

Пример прохода по методам:

Если бы мы начали с индекса 0, то получили бы методы всех базовых классов, в том числе QObject:

Методы, начинающиеся с _q_ , используются внутри Qt и не являются частью API.

Конструкторы указываются отдельно:

Например, получим перечень конструкторов QObject:

Листинг 5. Вывод конструкторов QObject через систему метаобъектов

Результат:

Индекс метода, сигнала, слота или конструктора можно получить по его сигнатуре:

Для конструкторов, методов или сигналов ожидаются нормализованные сигнатуры . Их можно получить при помощи статического метода

Например,

возвращает " int*foo(QString,QObject*) ".

Аналогично работает

Это текстовое приведение к каноническому виду, используемое, в частности, при проверке совместимости сигнала и слота.

5.6.3. Свойства

Аналогично можно работать со свойствами.

(Если просмотреть все свойства, включая наследованные, то вы увидите, по меньшей мере, objectName из QObject .)

Индекс свойства можно получить по его имени:

5.6.4. Перечисления

Перечисления регистрируются в классе при помощи макроса Q_ENUMS() .

Перечисление, значения которого можно комбинировать при помощи побитового ИЛИ, называется флагом и должно регистрироваться при помощи Q_FLAGS() .

Листинг 6.1. Класс MyClass с перечислением Type и флагом Mode

Флаги используются следующим образом:

Динамическая работа с перечислениями:

Листинг 6.2. Вывод перечислений и флагов MyClass через систему метаобъектов

Результат работы:

Индекс перечисления можно получить по его имени:

5.6.5. CLASSINFO

При помощи макроса Q_CLASSINFO() к метаобъекту можно добавлять пары имя–значение. Например,

Листинг 7.1. Класс MyClass с CLASSINFO

Эти пары наследуются, и их можно получить из метаобъекта по той же схеме:

Для примера выше:

Листинг 7.2. Вывод CLASSINFO класса MyClass

Результат:

Вступление

Почему Qt? Почему мы, программисты, выбираем Qt? Конечно, существуют очевидные ответы: совместимость классов Qt, базирующаяся на применении одного источника, богатство его возможностей, производительность С++, наличие исходного кода, его документация, качественная техническая поддержка и множество других причин, указанных в глянцевых маркетинговых материалах компании «Trolltech». Все это очень хорошо, но здесь не указано самое важное: Qt пользуется успехом, потому что она нравится программистам.

Почему программистам нравится одна технология и не нравится другая? Сам я считаю, что разработчики программного обеспечения отдают предпочтение такой технологии, которая «ощущается» как правильная, и не любят все то, что не дает такого ощущения. «Ощущать» технологию как правильную означает многое. В версии этой книги для Qt 3 я упоминал телефонную систему компании «Trolltech» в качестве очень подходящего примера особенно плохой технологии. Эта телефонная система не воспринимается как правильная система, потому что она вынуждает нас совершать случайные действия в столь же случайном контексте. Случайность не создает ощущения правильности. Повторяемость и избыточность тоже воспринимаются как неправильные. Хорошие программисты ленивы. Что нас особенно привлекает в компьютерах (например, в сравнении с садоводством), так это то, что нам не приходится повторять одно и то же раз за разом.

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

Однако в реальной жизни все не так просто. Хотя никто другой в компании не испытывает никаких затруднений при работе с этими формами, у инженеров возникают проблемы. И поговорив с сотрудниками других компаний, убеждаешься в том, что это распространенное явление. Мы откладываем оформление компенсаций до самого последнего момента и иногда вообще можем забыть об этом. Почему так происходит? Заполнение форм на первый взгляд простая, стандартная процедура. Собираешь квитанции, нумеруешь и записываешь эти номера в соответствующие поля с указанием даты, места, описания и суммы. Нумерация квитанций и запись номеров в форму предназначены для облегчения кому-то работы, но, строго говоря, номера избыточны, поскольку дата, место, описание и сумма однозначно идентифицируют квитанцию. Можно подумать, что совсем немного дополнительной работы позволяет вернуть свои деньги.

Однако небольшое раздражение вызывают суточные, которые зависят от места вашей поездки. Имеется некий отдельный документ со списком стандартизованных сумм суточных для всех различных пунктов назначения командировок. Нельзя просто указать «Чикаго»; вместо этого приходится самому находить сумму суточных для Чикаго. Аналогичное раздражение вызывает поле обменного курса. Приходится искать текущий обменный курс где-нибудь в системе помощи Google и затем вводить его в каждое поле. Ну, строго говоря, следует подождать, пока компания, обслуживающая вашу кредитную карту, не пришлет вам счет с указанием фактического используемого ею обменного курса. Хотя сделать это нетрудно, просмотр различных источников и поиск в них нужных данных с последующим их переносом в различные места формы воспринимается как ничем не оправданное неудобство.

Программирование может очень сильно напоминать заполнение наших форм по компенсации командировочных расходов, только здесь все обстоит еще хуже. И здесь на помощь приходит Qt. Qt не такая. Во-первых, Qt логична. И, во-вторых, Qt вызывает интерес. Qt позволяет вам сконцентрироваться собственно на вашей задаче. Когда первоначальные создатели Qt сталкивались с проблемой, они не искали просто хорошее решение или самое простое решение. Они искали правильное решение и затем документировали его. Конечно, они делали ошибки, и, конечно, их некоторые проектные решения не прошли проверку временем, но все же многое сделано правильно, а неправильное может и должно быть исправлено. Вы можете убедиться в этом на том факте, что система, первоначально задуманная как мостик между Windows 95 и Unix/Motif, теперь объединяет такие непохожие современные настольные системы, как Windows XP, Mac OS X и GNU/Linux, и обеспечивает основу для Qtopia - платформы создания приложений для встроенных систем в Linux.

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

Maттиac Эттрич (Matthias Ettrich)

Осло, Норвегия

Июнь, 2006г.

Предисловие

Qt представляет собой комплексную рабочую среду, предназначенную для разработки на С++ межплатформенных приложений с графическим пользовательским интерфейсом по принципу «написал программу - компилируй ее в любом месте». Qt позволяет программистам использовать дерево классов с одним источником в приложениях, которые будут работать в системах от Windows 95 до XP, Mac OS X, Linux, Solaris, HP-UX и во многих других версиях Unix с X11. Библиотеки и утилиты Qt входят также в состав Qtopia Core - программного продукта, обеспечивающего собственную оконную систему для Embedded Linux.

Цель этой книги - обучение вас способам написания программ с графическим пользовательским интерфейсом при помощи средств разработки Qt 4. Книга начинается с примера «Здравствуй, Qt» и быстро переходит к таким более сложным темам, как создание пользовательских виджетов и обеспечение технологии «drag-and-drop». Текст дополняется компакт-диском, который содержит исходный код программ-примеров. Компакт-диск также содержит версию Qt 4.1.1 с открытым исходным кодом для всех поддерживаемых платформ, а также MinGW - набор свободно доступных средств разработки, которые могут использоваться для создания приложений Qt для Windows. В приложении А рассматривается порядок установки программного обеспечения.

Данная книга разделена на три части. В части I раскрыты все принципы и даются практические советы, необходимые для программирования приложений с графическим интерфейсом при помощи средств разработки Qt. Знания материала этой части вполне достаточно для создания работоспособных приложений с графическим интерфейсом. В части II более глубоко рассматриваются основные темы Qt, и в части III предоставляется более специализированный и передовой материал. Главы частей II и III можно читать в любой последовательности, но они предполагают знакомство с содержанием части I.

Читатели версии этой книги для Qt 3 обнаружат, что новое издание имеет знакомое содержание и знакомый стиль изложения. Данное издание использует новые возможности Qt 4 (причем некоторые из них были введены в версии Qt 4.1), и представленный здесь программный код демонстрирует принципы хорошего программирования с применением средств разработки Qt 4. Во многих случаях здесь используются примеры, аналогичные примерам в издании для Qt 3. Это никак не отразится на новых читателях, но поможет читателям предыдущего издания самостоятельно привыкнуть к более аккуратному, четкому и более выразительному стилю.

Это издание содержит новые главы, в которых описываются архитектура Qt 4 модель/представление, новый фреймворк для подключаемых модулей и основы программирования встроенных систем с помощью Qtopia, а также новое приложение. И так же как в книге для Qt 3, здесь основное внимание уделяется объяснению принципов Qt-программирования, а не просто изложению другими словами и обобщению обширной интерактивной документации Qt.

Предполагается, что вы знакомы с основами программирования на С++, Java или C#. Программный код примеров использует подмножество С++, избегая многие его возможности, которые редко требуются при Qt-программировании. В нескольких местах, где нельзя обойтись без специальных конструкций С++, дается подробное объяснение их применения.

Если у вас уже есть опыт программирования нa Java или C#, но мало или совсем нет опыта программирования на С++, мы рекомендуем начать с приложения к книге, содержащего введение в С++, вполне достаточного для того, чтобы можно было использовать эту книгу. В качестве более полного введения в объектно-ориентированное программирование на С++ мы рекомендуем книгу «С++ How to Program» (Как программировать на С++), написанную Харви и Полом Дейтелем (Harvey Deitel and Paul Deitel), и «С++ Primer» (Язык программирования С++. Вводный курс), написанную Стенли Б. Липпманом (Stanley В. Lippman), Жози Лажойе (Josie Lajoie) и Барбарой E. My (Barbara E. Moo).

QT 4: программирование GUI на С++ Бланшет Жасмин

«Здравствуй, Qt»

«Здравствуй, Qt»

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

01 #include

02 #include

03 int main(int argc, char *argv)

05 QApplication app(argc, argv);

06 QLabel *label = new QLabel("Hello Qt!");

07 label->show();

08 return app.exec();

В строках 1 и 2 в программу включаются определения классов QApplication и QLabel . Для каждого Qt-класса имеется заголовочный файл с тем же именем (с учетом регистра), содержащий определение этого класса.

В строке 5 создается объект QApplication для управления всеми ресурсами приложения. Для конструктора QApplication необходимо указывать параметры argc и argv , поскольку Qt сама обрабатывает некоторые из аргументов командной строки.

В строке 7 создается «виджет» текстовая метка QLabel , который выводит на экран сообщение «Hello Qt!» (здравствуй, Qt). По терминологии Qt и Unix виджетом (widget) называется любой визуальный элемент графического интерфейса пользователя. Этот термин происходит от «window gadget» и соответствует элементу управления («control») и контейнеру («container») по терминологии Windows. Кнопки, меню, полосы прокрутки и фреймы являются примерами виджетов. Одни виджеты могут содержать в себе другие виджеты. Например, окно приложения обычно является виджетом, содержащим QMenuBar (панель меню), несколько QToolBar (панель инструментов), QStatusBar (строка состояния) и некоторые другие виджеты. Большинство приложений используют QMainWindow или QDialog в качестве окна приложения, однако Qt настолько гибка, что любой виджет может быть окном. В данном примере QLabel является окном приложения.

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

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

Для простоты мы не делаем вызов оператора delete для объекта QLabel в конце функции main() . Подобная утечка памяти в такой небольшой программе безвредна, поскольку после завершения программы эта память будет возвращена операционной системой.

Рис. 1.1. Вывод приветствия программы Hello в системе Linux

Теперь вы можете проверить работу этой программы на своей машине. Сначала необходимо установить Qt 4.1.1 (или более позднюю версию Qt 4); процесс установки рассмотрен в Приложении А. С этого момента мы будем предполагать, что вы корректно установили библиотеку Qt 4 и ее каталог bin занесен в переменную окружения PATH. (В системе Windows это делается автоматически программой установки Qt.) Вам также потребуется поместить файл hello.cpp с исходным кодом программы Hello в каталог hello. Вы можете набрать файл hello.cpp вручную или взять его с компакт-диска, который входит в состав книги; на компакт-диске этот исходный код находится в файле /examples/chap01/hello/hello.cpp.

Находясь в консольном режиме, войдите в каталог hello и задайте команду:

для создания файла проекта, независимого от платформы (hello.pro ), и затем задайте команду:

для создания на основе файла проекта зависимого от платформы файла makefile .

Выполните команду make для построения программы . Затем выполняйте программу, задавая команду hello в системе Windows или ./hello в системе Unix и open hello.app в системе Mac OS X. Для завершения программы нажмите кнопку закрытия окна, расположенную в заголовке окна. Если вы используете Windows и установили версию Qt с открытым исходным кодом вместе с компилятором MinGW, вы получите ярлык для окна DOS, в котором переменные среды правильно настроены на Qt. Вызвав это окно, вы можете компилировать в нем Qt-приложения, используя описанныевыше команды qmake и make. Формируемые исполнительные модули помещаются в папку debug или release, например, C:qt-bookhello eleasehello.exe.

Если вы используете Visual С++ компании Microsoft, то вам потребуется выполнить команду nmake, а не make. Здесь вы можете поступить по-другому и создать проект в Visual Studio на основе файла hello.pro, выполняя команду:

qmake -tp vc hello.pro

и затем выполнить построение программы в системе Visual Studio. Если вы используете Xcode на Mac OS X, то можете сгенерировать проект Xcode с помощью следующей команды:

qmake -spec macx-xcode

Рис. 1.2. Текстовая метка с простым форматированием HTML.

Прежде чем перейти к следующему примеру, позволим себе небольшое развлечение, а именно заменим строку

QLabel *label = new QLabel("Hello Qt!");

на строку

QLabel *label = new QLabel("

Hello "

"Qt!

и снова выполним построение приложения. Как иллюстрирует этот пример, совсем не трудно выделять элементы пользовательского интерфейса Qt-приложения с использованием некоторых простых средств форматирования документов HTML.