В данной главе показано на примере создания простого приложения с графическим интерфейсом пользователя (GUI — graphical user interface), как можно обычные средства С++ совместить с функциональными возможностями Qt. Здесь также рассматриваются две ключевые идеи Qt: сигналы и слоты (signals and slots) и компоновка графических элементов (layout). В главе 2 мы рассмотрим более подробно возможности Qt, а в главе 3 мы начнем разрабатывать более реалистичное приложение.
   Если вы уже знакомы c Java или C#, но имеете лишь ограниченный опыт работы с С++, возможно, вы захотите начать с Приложения Б, в котором дается введение в С++.

   Давайте начнем с очень простой Qt—программы. Сначала мы разберем каждую строку этой программы, а затем покажем способы ее компиляции и выполнения.
   01 #include <QApplication>
   02 #include <QLabel>
   03 int main(int argc, char *argv[])
   04 {
   05 QApplication app(argc, argv);
   06 QLabel *label = new QLabel("Hello Qt!");
   07 label->show();
   08 return app.exec();
   09 }
   В строках 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 и задайте команду:
   qmake -project
   для создания файла проекта, независимого от платформы (hello.pro), и затем задайте команду:
   qmake hello.pro
   для создания на основе файла проекта зависимого от платформы файла makefile.
   Выполните команду make для построения программы ^[1]. Затем выполняйте программу, задавая команду hello в системе Windows или ./hello в системе Unix и open hello.app в системе Mac OS X. Для завершения программы нажмите кнопку закрытия окна, расположенную в заголовке окна. Если вы используете Windows и установили версию Qt с открытым исходным кодом вместе с компилятором MinGW, вы получите ярлык для окна DOS, в котором переменные среды правильно настроены на Qt. Вызвав это окно, вы можете компилировать в нем Qt—приложения, используя описанныевыше команды qmake и make. Формируемые исполнительные модули помещаются в папку debug или release, например, C:\qt-book\hello\release\hello.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("<h2><i>Hello</i> "
    "<font color=red>Qt!</font></h2>");
   и снова выполним построение приложения. Как иллюстрирует этот пример, совсем не трудно выделять элементы пользовательского интерфейса Qt—приложения с использованием некоторых простых средств форматирования документов HTML.

   Второй пример показывает возможности взаимодействия пользователя с программой. Приложение представляет собой кнопку, которую пользователь может нажать и тогда приложение закончит свою работу. Исходный код этой программы очень напоминает исходный код программы Hello, но здесь вместо QLabel используется QPushButton в качестве главного виджета и добавляется код, обеспечивающий реакцию программы на действие пользователя (нажатие кнопки).
   Исходный код этого приложения находится на компакт-диске в файле /examples/chap01/quit/quit.cpp. Ниже приводится содержимое этого файла:
   01 #include <QAapplication>
   02 #include <QPushButton.h>
   03 int main(int argc, char *argv[])
   04 {
   05 QApplication app(argc, argv);
   06 QPushButton *button = new QPushButton("Quit");
   07 QObject::connect(button, SIGNAL(clicked()),
   08 &app, SL0T(quit()));
   09 button->show();
   10 return app.exec();
   11 }
   Виджеты Qt генерируют сигналы^[2] в ответ на выполнение пользователем какого-то действия или изменение состояния. Например, QPushButton генерируют сигнал clicked() при нажатии пользователем кнопки. Сигнал может быть связан с функцией (называемой слотом в данном контексте) для автоматического ее выполнения при получении данного сигнала. В нашем примере мы связываем сигнал кнопки clicked() со слотом quit() объекта приложения QApplication. Макросы SIGNAL() и SLOT() являются частью синтаксиса; более подробно они объясняются в следующей главе.
   Рис. 1.3. Приложение Quit (завершить работу).
   Теперь мы построим приложение. Мы предполагаем, что вами создан каталог quit и в нем находится файл quit.cpp. Выполните команду qmake из каталога quit для формирования файла проекта, затем используйте полученный файл для создания файла makefile:
   qmake -project
   qmake quit.pro
   Теперь постройте приложение и запустите его на выполнение. Если вы нажмете кнопку quit или клавишу пробела на клавиатуре (она также приводит к нажатию этой кнопки), приложение завершит свою работу.

   В данном разделе мы создадим небольшое приложение, которое демонстрирует применение менеджеров компоновки для размещения виджетов в окне и использование сигналов и слотов для синхронизации работы двух виджетов. Приложение предлагает пользователю указать свой возраст, что можно сделать при помощи либо наборного счетчика (spin box), либо ползунка (slider).
   Это приложение состоит из трех виджетов: QSpinBox, QSlider и QWidget. QWidget является главным окном приложения. Виджеты QSpinBox и QSlider помещены внутрь QWidget, и они являются дочерними виджетами по отношению к QWidget. С другой стороны, мы можем сказать, что QWidget является родительским виджетом по отношению к QSpinBox и QSlider. Сам QWidget не имеет родителя, потому что используется в качестве окна самого верхнего уровня. Конструкторы QWidget и все его подклассы принимают параметр QWidget *, задающий родительский виджет.
   Рис. 1.4. Приложение Age (возраст).
   Ниже приводится исходный код:
   01 #include <QApplication>
   02 #include <QHBoxLayout>
   03 #include <QSlider>
   04 #include <QSpinbox>
   05 int main(int argc, char *argv[])
   06 {
   07 QApplication app(argc, argv);
   08 QWidget *window = new QWidget;
   09 window->setWindowTitle("Enter Your Age");
   10 QSpinBox *spinBox = new QSpinBox;
   11 QSlider *slider = new QSlider(Qt::Horizontal);
   12 spinBox->setRange(0, 130);
   13 slider->setRange(0, 130);
   14 QObject::connect(spinBox, SIGNAL(valueChanged(int)),
   15 slider, SLOT(setValue(int)));
   16 QObject::connect(slider, SIGNAL(valueChanged(int)),
   17 spinBox, SLOT(setValue(int)));
   18 spinBox->setValue(35);
   19 QHBoxLayout *layout = new QHBoxLayout;
   20 layout->addWidget(spinBox);
   21 layout->addWidget(slider);
   22 window->setLayout(layout);
   23 window->show();
   24 return app.exec();
   25 }
   Строки 8 и 9 создают и настраивают виджет QWidget, который является главным окном приложения. Нами вызывается функция setWindowTitle() для вывода текстовой строки в заголовке окна.
   Строки 10 и 11 создают виджеты QSpinBox и QSlider, а строки 12 и 13 устанавливают допустимый диапазон изменения их значений. Мы вполне можем допустить, что возраст человека не будет превышать 130 лет. Мы могли бы передать window в конструкторах QSpinBox и QSlider, указывая на то, что window должен быть их родительским виджетом, но здесь это делать необязательно, поскольку система компоновки определит это самостоятельно и автоматически установит родительский виджет для наборного счетчика и ползунка, как мы это увидим вскоре.
   Два вызова функции QObject::connect(), выполненные в строках с 14 по 17, обеспечивают синхронизацию работы наборного счетчика и ползунка, заставляя их всегда показывать одинаковое значение. Если один из виджетов изменяет значение, то генерируется сигнал valueChanged(int) и вызывается слот setValue(int) другого виджета с новым значением возраста.
   В строке 18 наборный счетчик устанавливается в значение 35. В результате виджет QSpinBox генерирует сигнал valueChanged(int) с целочисленным аргументом 35. Этот аргумент передается слоту setValue(int) виджета QSlider, и в результате ползунок устанавливается в значение 35. Ползунок затем также генерирует сигнал valueChanged(int), поскольку его значение изменилось, и вызывает слот setValue(int) наборного счетчика. Но на этот раз функция setValue(int) не будет генерировать сигнал, поскольку наборный счетчик уже имеет значение 35. Это не позволяет повторять эти действия бесконечно. Описанная ситуация продемонстрирована на рис. 1.5.
   Рис. 1.5. Изменение значения в одном из виджетов приводит к изменению значения в другом виджете.
   В строках с 19 по 22 мы размещаем виджеты наборного счетчика и ползунка, используя менеджер компоновки. Менеджер компоновки — это объект, который устанавливает размер и положение виджетов, которые располагаются в зоне его действия. Qt имеет три основных класса менеджеров компоновки:
   • QHBoxLayout размещает виджеты по горизонтали слева направо (или справа налево, в зависимости от культурных традиций);
   • QVBoxLayout размещает виджеты по вертикали сверху вниз;
   • QGridLayout размещает виджеты в ячейках сетки.
   Выполненный в строке 22 вызов QWidget::setLayout() устанавливает менеджер компоновки для окна. За кулисами создаются дочерние связи QSpinBox и QSlider с виджетом, для которого установлен менеджер компоновки, и по этой причине нам не требуется в явной форме задавать родительский виджет при конструировании виджета, размещаемого в зоне действия менеджера компоновки.
   Рис. 1.6. Виджеты приложения Age.
   Несмотря на то что мы не задавали в явной форме положение и размер ни одного из виджетов, QSpinBox и QSlider аккуратно расположились в ряд. Это объясняется тем, что QHBoxLayout автоматически определяет разумные размеры и положение виджетов, попадающих в зону его действия, в зависимости от потребностей этих виджетов. Менеджеры компоновки освобождают нас от нудного кодирования размещения виджетов нашего приложения на экране и гарантируют плавное изменение размеров окон.
   Используемый средствами разработки Qt подход к построению графического пользовательского интерфейса легко понятен и очень гибок. Среди работающих в Qt программистов наиболее распространен подход, когда сначала создаются все необходимые графические элементы, а затем соответствующим образом настраиваются их свойства. Программисты добавляют виджеты к компоновщикам графических элементов, которые автоматически устанавливают для них нужные размер и положение. Управление работой графического интерфейса осуществляется через взаимодействие виджетов друг с другом посредством применения механизма сигналов и слотов Qt.

Стили виджетов

   В данной главе вы научитесь создавать диалоговые окна с использованием средств разработки Qt. Диалоговые окна предоставляют пользователю возможность задавать необходимые значения параметров и выбирать определенные режимы работы. Они называются диалоговыми окнами или просто «диалогами» (dialogs), поскольку представляют собой средство, с помощью которого пользователи и приложения могут «переговариваться» друг с другом.
   Большинство приложений с графическим пользовательским интерфейсом имеют главное окно с панелью меню и инструментальной панелью, а также десятки диалоговых окон, естественно дополняющих главное окно. Можно также создать приложение из одного диалогового окна, которое будет непосредственно реагировать на выбор пользователя, выполняя соответствующие действия (например, таким приложением может быть калькулятор).
   Первое диалоговое окно мы создадим полностью вручную, чтобы было ясно, как выглядит исходный код такой программы. Затем мы покажем способы построении диалоговых окон в Qt Designer, который является средством визуального проектирования в Qt. Использование Qt Designer позволяет получать результат значительно быстрее, чем при ручном кодировании, и полученные в нем различные варианты проектов легче тестировать и изменять в будущем.

   Первым нашим примером будет диалоговое окно Find (найти) для поиска заданной пользователем последовательности символов, и оно будет полностью написано на С++. Мы реализуем это диалоговое окно в виде его собственного класса. Причем мы сделаем его независимым и самодостаточным компонентом, со своими сигналами и слотами.
   Рис. 2.1. Диалоговое окно поиска.
   Исходный код программы содержится в двух файлах: finddialog.h и finddialog.cpp. Сначала приведем файл finddialog.h:
   01 #ifndef FINDDIALOG_H
   02 #define FINDDIALOG_H
   03 #include <QDialog.h>
   04 class QCheckBox;
   05 class QLabel;
   06 class QLineEdit;
   07 class QPushButton;
   Строки 1 и 2 (а также строка 27) предотвращают многократное включение в программу этого заголовочного файла.
   В строке 3 в программу включается определение QDialog — базового класса для диалоговых окон в Qt. Класс QDialog наследует свойства класса QWidget.
   В строках с 4 по 7 даются предварительные объявления классов Qt, использующихся для реализации диалогового окна. Предварительное объявление (forward declaration) указывает компилятору С++ только на существование класса, не давая подробного определения этого класса (обычно определение класса содержится в его собственном заголовочном файле). Чуть позже мы поговорим об этом более подробно.
   Затем мы определяем FindDialog как подкласс QDialog:
   08 class FindDialog : public QDialog
   09 {
   10 Q_OBJECT
   11 public:
   12 FindDialog(QWidget *parent = 0);
   Макрос Q_OBJECT необходимо задавать в начале определения любого класса, содержащего сигналы или слоты.
   Конструктор FindDialog является типичным для классов виджетов в Qt. В параметре parent (родитель) указывается родительский виджет. По умолчанию задается нулевой указатель, указывающий на то, что у данного диалога нет родительского виджета.
   13 signals:
   14 void findNext(const QString &str, Qt::CaseSensitivity cs);
   15 void findPrev(const QString &str, Qt::CaseSensitivity cs);
   В секции signals объявляется два сигнала, которые генерируются диалоговым окном при нажатии пользователем кнопки Find (найти). Если установлен флажок поиска в обратном направлении (Search backward), генерируется сигнал findPrevious(); в противном случае генерируется сигнал findNext ().
   Ключевое слово signals на самом деле является макросом. Препроцессор С++ преобразует его в стандартные инструкции языка С++ и затем передает их компилятору. Qt::CaseSensitivity является перечислением и может принимать значение Qt::CaseSensitive или Qt::CaseInsensitive.
   16 private slots:
   17 void findClicked();
   18 void enableFindButton(const QString &text);
   19 private:
   20 QLabel *label;
   21 QLineEdit *lineEdit;
   22 QCheckBox *caseCheckBox;
   23 QCheckBox *backwardCheckBox;
   24 QPushButton *findButton;
   25 QPushButton *closeButton;
   26 };
   27 #endif
   В закрытой (private) секции класса мы объявляем два слота. Для реализации слотов нам потребуется большинство дочерних виджетов диалогового окна, поэтому мы резервируем для них соответствующие переменные—указатели. Ключевое слово slots, так же как и signals, является макросом, который преобразуется в последовательность инструкций, понятных компилятору С++.
   Для закрытых переменных мы использовали предварительные объявления их классов. Это допустимо, потому что все они являются указателями, и мы не используем их в заголовочном файле — поэтому компилятору не требуется иметь полные определения классов. Мы могли бы воспользоваться соответствующими заголовочными файлами (<QCheckbox>, <QLabel> и так далее), но при использовании предварительных объявлений компилятор работает немного быстрее.
   Теперь рассмотрим файл finddialog.cpp, в котором находится реализация класса FindDialog.
   01 #include <QtGui>
   02 #include "finddialog.h"
   Во-первых, мы включаем <QtGui> — заголовочный файл, который содержит определения классов графического интерфейса Qt. Qt состоит из нескольких модулей, каждый из которых находится в своей собственной библиотеке. Наиболее важными модулями являются QtCore, QtGui, QtNetwork, QtOpenGL, QtSql, QtSvg и QtXml. Заголовочный файл <QtGui> содержит определение всех классов, входящих в модули QtCore и QtGui. Включив этот заголовочный файл, мы можем не беспокоиться о включении каждого отдельного класса.
   В filedialog.h вместо включения <QDialog> и использования предварительных объявлений для классов QCheckBox, QLabel, QLineEdit и QPushButton мы могли бы просто включить <QtGui>. Однако включение такого большого заголовочного файла, взятого из другого заголовочного файла, обычно свидетельствует о плохом стиле кодирования, особенно при разработке больших приложений.
   03 FindDialog::FindDialog(QWidget *parent)
   04 : QDialog(parent)
   05 {
   06 label = new QLabel(tr("Find &what:"));
   07 lineEdit = new QLineEdit;
   08 label->setBuddy(lineEdit);
   09 caseCheckBox = new QCheckBox(tr("Match &case"));
   10 backwardCheckBox = new QCheckBox(tr("Search backward"));
   11 findButton = new QPushButton(tr("&Find"));
   12 findButton->setDefault(true);
   13 findButton->setEnabled(false);
   14 closeButton = new QPushButton(tr("Close"));
   В строке 4 конструктору базового класса передается указатель на родительский виджет (параметр parent). Затем мы создаем дочерние виджеты. Функция tr() переводит строковые литералы на другие языки. Она объявляется в классе QObject и в каждом подклассе, содержащем макрос Q_OBJECT. Любое строковое значение, которое пользователь будет видеть на экране, полезно преобразовывать функцией tr(), даже если вы не планируете в настоящий момент переводить ваше приложение на какой-нибудь другой язык. Перевод приложений Qt на другие языки рассматривается в главе 17.
   Мы используем знак амперсанда ('&') для задания клавиш быстрого доступа. Например, в строке 11 создается кнопка Find, которая может быть активирована нажатием пользователем сочетания клавиш Alt+F на платформах, поддерживающих клавиши быстрого доступа. Амперсанды могут также применяться для управления фокусом: в строке 6 мы создаем текстовую метку с клавишей быстрого доступа (Alt+W), а в строке 8 мы устанавливаем строку редактирования в качестве «партнера» этой текстовой метки. Партнером (buddy) называется виджет, на который передается фокус при нажатии клавиши быстрого доступа текстовой метки. Поэтому при нажатии пользователем сочетания клавиш Alt+W (клавиша быстрого доступа текстовой метки) фокус переходит на строку редактирования (которая является партнером текстовой метки).
   В строке 12 мы делаем кнопку Find используемой по умолчанию, вызывая функцию setDefault(true)^[3]. Кнопка, для которой задан режим использования по умолчанию, будет срабатывать при нажатии пользователем клавиши Enter (ввод). В строке 13 мы устанавливаем кнопку Find в неактивный режим. В неактивном режиме виджет обычно имеет серый цвет и не реагирует на действия пользователя.
   15 connect(lineEdit, SIGNAL(textChanged(const QString &)),
   16 this, SLOT(enableFindButton(const QString &)));
   17 connect(findButton, SIGNAL(clicked()),
   18 this, SLOT(findClicked()));
   19 connect(closeButton, SIGNAL(clicked()),
   20 this, SLOT(close()));
   Закрытый слот enableFindButton(const QString &) вызывается при всяком изменении значения в строке редактирования. Закрытый слот findClicked() вызывается при нажатии пользователем кнопки Find. Само диалоговое окно закрывается при нажатии пользователем кнопки Close (закрыть). Слот close() наследуется от класса QWidget, и по умолчанию он делает виджет невидимым (но не удаляет его). Программный код слотов enableFindButton() и findClicked() мы рассмотрим позднее.
   Поскольку QObject является одним из прародителей FindDialog, мы можем не указывать префикс QObject:: перед вызовами connect().
   21 QHBoxLayout *topLeftLayout = new QHBoxLayout;
   22 topLeftLayout->addWidget(label);
   23 topLeftLayout->addWidget(lineEdit);
   24 QVBoxLayout *leftLayout = new QVBoxLayout;
   25 leftLayout->addLayout(topLeftLayout);
   26 leftLayout->addWidget(caseCheckBox);
   27 leftLayout->addWidget(backwardCheckBox);
   28 QVBoxLayout *rightLayout = new QVBoxLayout;
   29 rightLayout->addWidget(findButton);
   30 rightLayout->addWidget(closeButton);
   31 rightLayout->addStretch();
   32 QHBoxLayout *mainLayout = new QHBoxLayout;
   33 mainLayout->addLayout(leftLayout);
   34 mainLayout->addLayout(rightLayout);
   35 setLayout(mainLayout);
   Затем для размещения виджетов в окне мы используем менеджеры компоновки (layout managers). Менеджеры компоновки могут содержать как виджеты, так и другие менеджеры компоновки. Используя различные вложенные комбинации менеджеров компоновки QHBoxLayout, QVBoxLayout и QGridLayout, можно построить очень сложные диалоговые окна.
   Рис. 2.2. Менеджеры компоновки диалогового окна поиска данных.
   Для диалогового окна поиска мы используем два менеджера горизонтальной компоновки QHBoxLayout и два менеджера вертикальной компоновки QVBoxLayout (см. рис. 2.2). Внешний менеджер компоновки является главным; он устанавливается в FindDialog в строке 35 и ответственен за всю область, занимаемую диалоговым окном. Остальные три менеджера компоновки являются внутренними. Показанная в нижнем правом углу на рис. 2.2 маленькая «пружинка» является пустым промежутком («распоркой»). Она применяется для образования ниже кнопок Find и Close пустого пространства, обеспечивающего перемещение кнопок в верхнюю часть своего менеджера компоновки.
   Одна из особенностей классов менеджеров компоновки заключается в том, что они не являются виджетами. Взамен этого они наследуют свойства класса QLayout, который, в свою очередь, является наследником класса QObject. На данном рисунке виджеты выделены сплошными линиями, а менеджеры компоновки очерчены пунктирными линиями, чтобы подчеркнуть их различие. При работе приложения менеджеры компоновки невидимы.
   При добавлении внутренних менеджеров компоновки к родительскому менеджеру компоновки (строки 25, 33 и 34) для них автоматически устанавливается родительская связь. Затем, когда главный менеджер компоновки устанавливается для диалога (строка 35), он становится дочерним элементом диалога и все виджеты в менеджерах компоновки становятся дочерними элементами диалога. Иерархия полученных родословных связей представлена на рис. 2.3.
   Рис. 2.3. Родословная объектов диалогового окна поиска данных.
   36 setWindowTitle(tr("Find"));
   37 setFixedHeight(sizeHint().height());
   38 }
   Наконец, мы задаем название диалогового окна и устанавливаем фиксированной его высоту, поскольку в диалоговом окне нет виджетов, которым может понадобиться дополнительное пространство по вертикали. Функция QWidget::sizeHint() возвращает «идеальный» размер виджета.
   На этом завершается рассмотрение конструктора FindDialog. Поскольку нами использован оператор new при создании виджетов и менеджеров компоновки, нам, по-видимому, придется написать деструктор, где будут предусмотрены операторы delete для удаления каждого созданного нами виджета и менеджера компоновки. Но поступать так не обязательно, поскольку Qt автоматически удаляет дочерние объекты при разрушении родительского объекта, а все дочерние виджеты и менеджеры компоновки являются потомками FindDialog.
   Теперь мы рассмотрим слоты диалогового окна:
   39 void FindDialog::findClicked()
   40 {
   41 QString text = lineEdit->text();
   42 Qt::CaseSensitivity cs =
   43 caseCheckBox->isChecked() ? Qt::CaseSensitive
   44 : Qt::CaseInsensitive;
   45 if (backwardCheckBox->isChecked()) {
   46 emit findPrevious(text, cs);
   47 } else {
   48 emit findNext(text, cs);
   49 }
   50 }
 
   51 void FindDialog::enableFindButton(const QString &text)
   52 {
   53 findButton->setEnabled(!text.isEmpty());
   54 }
   Слот findClicked() вызывается при нажатии пользователем кнопки Find. Он генерирует сигнал findPrevious() или findNext() в зависимости от состояния флажка Search backward (поиск в обратном направлении). Ключевое слово emit (генерировать сигнал) имеет особый смысл в Qt; как и другие расширения Qt, оно преобразуется препроцессором С++ в стандартные инструкции С++.
   Слот enableFindButton() вызывается при любом изменении значения в строке редактирования. Он устанавливает активный режим кнопки, если в редактируемой строке имеется какой-нибудь текст; в противном случае кнопка устанавливается в неактивный режим.
   Эти два слота завершают написание программы диалогового окна. Теперь мы можем создать файл main.cpp и протестировать наш виджет FindDialog:
   01 #include <QApplication>
   02 #include "finddialog.h"
   03 int main(int argc, char *argv[])
   04 {
   05 QApplication app(argc, argv);
   06 FindDialog *dialog = new FindDialog;
   07 dialog->show();
   08 return app.exec();
   09 }
   Для компиляции этой программы выполните обычную команду qmake. Поскольку определение класса FindDialog содержит макрос Q_OBJECT, сформированный командой qmake, файл makefile будет содержать специальные правила для запуска moc — мета—объектного компилятора Qt. (Мета—объектная система Qt рассматривается в следующем разделе.)
   Для правильной работы moc мы должны включить определение класса в заголовочный файл, то есть отделить его от файла реализации класса. Сформированный moc программный код содержит этот заголовочный файл и собственно сгенерированные инструкции С++.
   Классы с макросом Q_OBJECT сначала должны пройти через компилятор moc. Здесь не будет проблем, поскольку qmake автоматически добавляет в файл makefile необходимые команды. Однако если вы забудете сгенерировать файл makefile командой qmake, программа не пройдет через компилятор moc и компоновщик программы пожалуется на то, что некоторые объявленные функции не реализованы. Эти сообщения могут выглядеть достаточно странно. GCC выдает сообщения следующего вида:
   finddialog.o(.text+0x28): undefined reference to
    'FindDialog::QPaintDevice virtual table'
   (не определена ссылка на «виртуальную таблицу
    FindDialog::QPaintDevice»)
   finddialog.o: In function 'FindDialog::tr(char const*. char const*)':
    /usr/lib/qt/src/corelib/global/qglobal.h:1430: undefined reference to
    'FindDialog::staticMetaObject'
   (В функции 'FindDialog::tr(…)' не определена ссылка на
    'FindDialog::staticMetaObject')
   Сообщения в Visual С++ выглядят следующим образом:
   finddialog.obj : error LNK2001: unresolved external symbol
    "public:~virtual int __thiscall MyClass::qt_metacall(enum QMetaObject::Call,int,void * *)"
   (ошибка LNK2001: неразрешенная внешняя ссылка)
   При появлении подобных сообщений снова выполните команду qmake для обновления файла makefile, затем заново постройте приложение.
   Теперь выполните программу. Если клавиши быстрого доступа доступны на вашей платформе, убедитесь в правильной работе клавиш Alt+W, Alt+C, Alt+B и Alt+F. Для перехода с одного виджета на другой используйте клавишу табуляции Tab. По умолчанию последовательность таких переходов соответствует порядку создания виджетов. Эту последовательность можно изменить с помощью функции QWidget::setTabOrder().
   Обеспечение осмысленного порядка переходов с одного виджета на другой с помощью клавиши табуляции и применение клавиш быстрого доступа позволяют использовать все возможности приложений тем пользователям, которые не хотят (или не могут) пользоваться мышкой. Тот, кто быстро работает с клавиатурой, также предпочитает иметь возможность полного управления приложением посредством клавиатуры.
   В главе 3 диалоговое окно поиска будет использовано нами в реальном приложении и мы подключим сигналы findPrevious() и findNext() к некоторым слотам.

Метаобъектная система Qt

   Средства разработки Qt спроектированы таким образом, чтобы было приятно программировать «вручную» и чтобы этот процесс был интуитивно понятен; и нет ничего необычного в разработке всего приложения Qt на «чистом» языке С++. Все же многие программисты предпочитают применять визуальные средства проектирования форм, поскольку этот метод представляется более естественным и позволяет получать конечный результат быстрее, чем при программировании «вручную», и такой подход дает возможность программистам быстрее и легче экспериментировать и изменять дизайн.
   Qt Designer расширяет возможности программистов, предоставляя визуальные средства проектирования. Qt Designer может использоваться для разработки всех или только некоторых форм приложения. Формы, созданные с помощью Qt Designer, в конце концов представляются в виде программного кода на С++, поэтому Qt Designer может использоваться совместно с обычными средствами разработки, и он не налагает никаких специальных требований на компилятор.
   В данном разделе мы применяем Qt Designer для создания диалогового окна (см. рис. 2.4), которое управляет переходом на заданную ячейку таблицы (Go-to-Cell dialog). Создание диалогового окна как при ручном кодирования, так и при использовании Qt Designer предусматривает выполнение следующих шагов:
   • создание и инициализация дочерних виджетов;
   • размещение дочерних виджетов в менеджерах компоновки;
   • определение последовательности переходов по клавише табуляции;
   • установка соединений «сигнал — слот»;
   • реализация пользовательских слотов диалогового окна.
   Рис. 2.4. Диалоговое окно для перехода на заданную ячейку таблицы.
   Для запуска Qt Designer выберите функцию Qt by Trolltech v4.x.y | Designer в меню Start системы Windows, наберите designer в командной строке системы Unix или дважды щелкните по Designer в системе Mac OS X Finder. После старта Qt Designer выдает список шаблонов. Выберите шаблон «Widget», затем нажмите на кнопку ОК. (Привлекательным может показаться шаблон «Dialog with Buttons Bottom» (диалог с кнопками в нижней части), но в этом примере мы покажем, как создавать кнопки OK и Cancel вручную.) Вы получите на экране окно с заголовком «Untitled».
   По умолчанию интерфейс пользователя в Qt Designer содержит несколько окон верхнего уровня. Если вы предпочитаете интерфейс в стиле MDI с одним окном верхнего уровня и несколькими подчиненными окнами, выберите функцию Edit | User Interface Mode | Docked Window.
   На первом этапе создайте дочерние виджеты и поместите их в форму. Создайте одну текстовую метку, одну строку редактирования, одну (горизонтальную) pacпорку (spacer) и две кнопки. При создании любого элемента перенесите его название или пиктограмму из окна виджетов Qt Designer на форму приблизительно в то место, где он должен располагаться. Элемент распорка, который не будет видим при работе формы, в QtDesigner показан в виде синей пружинки.
   Рис. 2.5. Qt Designer в режиме пристыкованного окна в системе Windows.
   Затем передвиньте низ формы вверх, чтобы она стала короче. В результате вы получите форму, похожую на показанную на рис. 2.6. Не тратьте слишком много времени на позиционирование элементов на форме; менеджеры компоновки Qt позже выполнят точное их позиционирование.
   Рис. 2.6. Форма с несколькими виджетами.
   Задайте свойства каждого виджета, используя редактор свойств Qt Designer.
   1. Щелкните по текстовой метке. Убедитесь, что свойство objectName (имя объекта) имеет значение «label» (текстовая метка), а свойство text (текст) установите на значение «&Cell Location» (расположение ячейки).
   2. Щелкните по строке редактирования. Убедитесь, что свойство objectName имеет значение «lineEdit» (строка редактирования).
   3. Щелкните по первой кнопке. Установите свойство objectName на значение «okButton» (кнопка подтверждения), свойство enabled (включена) на значение «false» (ложь), свойство default (режим умолчания) на «true» (истина), свойство text на значение «OK» (подтвердить).
   4. Щелкните по второй кнопке. Установите свойство objectName на значение «cancelButton» (кнопка отмены) и свойство text на значение «Cancel» (отменить).
   5. Щелкните по свободному месту формы для выбора самой формы. Установите objectName на значение «GoToCellDialog» (диалоговое окно перехода на ячейку) и windowTitle (заголовок окна) на значение «Go to Cell» (перейти на ячейку).
   Теперь все виджеты выглядят привлекательно, кроме текстовой метки &Cell Location. Выберите Edit | Edit Buddies (Правка | Редактировать партнеров) для входа в специальный режим, позволяющий задавать партнеров. Щелкните по этой метке и перенесите красную стрелку на строку редактирования, а затем отпустите кнопку мышки. Теперь эта метка будет выглядеть как Cell Location и иметь строку редактирования в качестве партнера. Выберите Click Edit | Edit Widgets (Правка | Редактировать виджеты) для выхода из режима установки партнеров.
   Рис. 2.7. Вид формы после установки свойств виджетов.
   На следующем этапе виджеты размещаются в форме требуемым образом:
   1. Щелкните по текстовой метке Cell Location и нажмите клавишу Shift одновременно со щелчком по полю редактирования, обеспечив одновременный выбор этих виджетов. Выберите в меню Form | Lay Out Horizontally (Форма | Горизонтальная компоновка).
   2. Щелкните по растяжке, затем, удерживая клавишу Shift, щелкните по клавишам OK и Cancel. Выберите в меню Form | Lay Out Horizontally.
   3. Щелкните по свободному месту формы, аннулируя выбор любых виджетов, затем выберите в меню функцию Form | Lay Out Vertically (Форма | Вертикальная компоновка).
   4. Выберите в меню функцию Form | Adjust Size для установки предпочитаемого размера формы.
   Красными линиями на форме обозначаются созданные менеджеры компоновки. Они невидимы при выполнении программы.
   Рис. 2.8. Форма с менеджерами компоновки.
   Теперь выберите в меню функцию Edit | Edit Tab Order (Правка | Редактировать порядок перехода по клавише табуляции). Рядом с каждым виджетом, которому может передаваться фокус, появятся синие прямоугольники. Щелкните по каждому виджету, соблюдая необходимую вам последовательность перевода фокуса, затем выберите в меню функцию Edit | Edit Widgets для выхода из режима редактирования переходов по клавише табуляции.
   Рис. 2.9. Установка последовательности перевода фокуса по виджетам формы.
   Для предварительного просмотра спроектированного диалогового окна выберите в меню функцию Form | Preview (Форма | Предварительный просмотр). Проверьте последовательность перехода фокуса, нажимая несколько раз клавишу табуляции. Нажмите одновременно клавиши Alt+C для перевода фокуса на строку редактирования. Нажмите на кнопку Cancel для прекращения работы.
   Сохраните спроектированное диалоговое окно в файле gotocelldialog.ui в каталоге с названием gotocell и создайте файл main.cpp в том же каталоге с помощью обычного текстового редактора.
   01 #include <QApplication>
   02 #include <QDialog>
   03 #include "ui_gotocelldialog.h"
 
   04 int main(int argc, char *argv[])
   05 {
   06 QApplication app(argc, argv);
   07 Ui::GoToCellDialog ui;
   08 QDialog *dialog = new QDialog;
   09 ui.setupUi(dialog);
   10 dialog->show();
   11 return app.exec();
   12 }
   Теперь выполните команду qmake для создания файла с расширением .pro и затем создайте файл makefile (команды qmake —project; qmake gotocell.pro). Программе qmake «хватит ума» обнаружить файл пользовательского интерфейса gotocelldialog.ui и сгенерировать соответствующие команды для вызова uic — компилятора пользовательского интерфейса, входящего в состав средств разработки Qt. Компилятор uic преобразует gotocelldialog.ui в инструкции С++ и помещает результат в ui_gotocelldialog.h.
   Полученный файл ui_gotocelldialog.h содержит определение класса Ui::GoToCellDialog, который содержит инструкции С++, эквивалентные файлу gotocelldialog.ui. В этом классе объявляются переменные—члены, в которых содержатся дочерние виджеты и менеджеры компоновки формы, а также функция setupUi(), которая инициализирует форму. Сгенерированный класс выглядит следующим образом:
   class Ui::GoToCellDialog
   {
   public:
    QLabel *label;
    QLineEdit *lineEdit;
    QSpacerItem *spacerItem;
    QPushButton *okButton;
    QPushButton *cancelButton;
    …
    void setupUi(QWidget *widget) {
    …
    }
   };
   Сгенерированный класс не наследует никакой Qt—класс. При использовании формы в main.cpp мы создаем QDialog и передаем его функции setupUi().
   Если вы станете выполнять программу в данный момент, она будет работать, но не совсем так, как требуется:
   • кнопка OK всегда будет в неактивном состоянии;
   • кнопка Cancel не выполняет никаких действий;
   • поле редактирования будет принимать любой текст, а оно должно принимать только допустимое обозначение ячейки.
   Правильную работу диалогового окна мы можем обеспечить, написав некоторый программный код. Лучше всего создать новый класс, который наследует QDialog и Ui::GoToCellDialog и реализует недостающую функциональность (подтверждая известное утверждение, что любую проблему программного обеспечения можно решить, просто добавив еще один уровень представления объектов). По нашим правилам мы даем этому новому классу такое же имя, которое генерируется компилятором uic, но без префикса Ui::.
   Используя текстовый редактор, создайте файл с именем gotocelldialog.h, который будет содержать следующий код:
   01 #ifndef GOTOCELLDIALOG_H
   02 #define GOTOCELLDIALOG_H
   03 #include <QDialog>
   04 #include "ui_gotocelldialog.h"
   05 class GoToCellDialog : public QDialog, public Ui::GoToCellDialog
   06 {
   07 Q_OBJECT
   08 public:
   09 GoToCellDialog(QWidget *parent = 0);
   10 private slots:
   11 void on_lineEdit_textChanged();
   12 };
   13 #endif
   Реализация методов класса делается в файле gotocelldialog.cpp:
   01 #include <QtGui>
   02 #include "gotocelldialog.h"
 
   03 GoToCellDialog::GoToCellDialog(QWidget *parent)
   04 : QDialog(parent)
   05 {
   06 setupUi(this);
   07 QRegExp regExp("[A-Za-z][1-9][0-9]{0,2}");
   08 lineEdit->setValidator(new QRegExpValidator(regExp, this));
   09 connect(okButton, SIGNAL(clicked()),
   10 this, SLOT(accept()));
   11 connect(cancelButton, SIGNAL(clicked()),
   12 this, SLOT(reject()));
   13 }
 
   14 void GoToCellDialog::on_lineEdit_textChanged()
   15 {
   16 okButton->setEnabled(lineEdit->hasAcceptableInput());
   17 }
   В конструкторе мы вызываем setupUi() для инициализации формы. Благодаря множественному наследованию мы можем непосредственно получить доступ к членам класса Ui::GoToCellDialog. После создания пользовательского интерфейса setupUi() будет также автоматически подключать все слоты с именами типа on_objectName_signalName() к соответствующему сигналу signalName() виджета objectName. В нашем примере это означает, что setupUi() будет устанавливать следующее соединение «сигнал—слот»:
   connect(lineEdit, SIGNAL(textChanged(const QString &)),
    this, SLOT(on_lineEdit_textChanged()));
   Также в конструкторе мы задаем ограничение на допустимый диапазон вводимых значений. Qt обеспечивает три встроенных класса по проверке правильности значений: QIntValidator, QDoubleValidator и QRegExpValidator. В нашем случае мы используем QRegExpValidator, задавая регулярное выражение «[A—Za—z][1—9][0—9]{0,2}», которое означает следующее: допускается одна маленькая или большая буква, за которой следует одна цифра в диапазоне от 1 до 9; затем идут ноль, одна или две цифры в диапазоне от 0 до 9. (Введение в регулярные выражения вы можете найти в документации по классу QRegExp.)
   Указывая в конструкторе QRegExpValidator значение this, мы его делаем дочерним элементом объекта GoToCellDialog. После этого нам можно не беспокоиться об удалении в будущем QRegExpValidator; этот объект будет удален автоматически после удаления его родительского элемента.
   Механизм взаимодействия объекта с родительскими и дочерними элементами реализован в QObject. Когда мы создаем объект (виджет, функцию по проверке правильности значений или любой другой объект) и он имеет родительский объект, то к списку дочерних элементов этого родителя добавится и данный объект. При удалении родительского элемента будет просмотрен список его дочерних элементов и все они будут удалены. Эти дочерние элементы, в свою очередь, сами удалят все свои дочерние элементы, и эта процедура будет выполняться до тех пор, пока ничего не останется.
   Механизм взаимодействия объекта с родительскими и дочерними элементами значительно упрощает управление памятью, снижая риск утечек памяти. Явным образом мы должны удалять только объекты, которые созданы оператором new и которые не имеют родительского элемента. А если мы удаляем дочерний элемент до удаления его родителя, то Qt автоматически удалит этот объект из списка дочерних объектов этого родителя.
   Для виджетов родительский объект имеет дополнительный смысл: дочерние виджеты размещаются внутри области, которую занимает родительский объект. При удалении родительского виджета не только освобождается занимаемая дочерними объектами память — он исчезает с экрана.
   В конце конструктора мы подключаем кнопку OK к слоту accept() виджета QDialog и кнопку Cancel к слоту reject(). Оба слота закрывают диалог, но accept() устанавливает результат диалога на значение QDialog::Accepted (которое равно 1), a reject() устанавливает значение QDialog::Rejected (которое равно 0). При использовании этого диалога мы можем использовать значение результата, чтобы узнать, была ли нажата кнопка OK, и действовать соответствующим образом.
   Слот on_lineEdit_textChanged() устанавливает кнопку OK в активное или неактивное состояние в зависимости от наличия в строке редактирования допустимого обозначения ячейки. QLineEdit::hasAcceptableInput() использует функцию проверки допустимости значений, которую мы задали в конструкторе.
   На этом завершается построение диалога. Теперь мы можем переписать main.cpp следующим образом:
   01 #include <QApplication>
   02 #include "gotocelldialog.h"
   03 int main(int argc, char *argv[])
   04 {
   05 QApplication app(argc, argv);
   06 GoToCellDialog *dialog = new GoToCellDialog;
   07 dialog->show();
   08 return app.exec();
   09 }
   Постройте еще раз приложение (qmake —project; qmake gotocell.pro) и выполните его. Наберите в строке редактирования значение «A12» и обратите внимание на то, как кнопка OK становится активной. Попытайтесь ввести какой-нибудь произвольный текст и посмотрите, как сработает функция по проверке допустимости значения. Нажмите кнопку Cancel для закрытия диалогового окна.
   Привлекательной особенностью применения Qt Designer является возможность для программиста действовать достаточно свободно при изменении дизайна формы, причем при этом исходный код программы не будет нарушен. При разработке формы с непосредственным написанием операторов С++ на изменение дизайна уходит много времени. При использовании Qt Designer не будет тратиться много времени, поскольку uic просто заново генерирует исходный код программы для форм, которые были изменены. Пользовательский интерфейс диалога сохраняется в файле .ui (который имеет формат XML), а соответствующая функциональная часть реализуется путем создания подкласса, сгенерированного компилятором uic класса.

   Нами были рассмотрены способы формирования диалоговых окон, которые всегда содержат одни и те же виджеты. В некоторых случаях требуется иметь диалоговые окна, форма которых может меняться. Наиболее известны два типа изменяющихся диалоговых окон: расширяемые диалоговые окна (area extension dialogs) и многостраничные диалоговые окна (multi—page dialogs). Оба типа диалоговых окон можно реализовать в Qt либо с помощью непосредственного кодирования, либо посредством применения Qt Designer.
   Расширяемые диалоговые окна, как правило, имеют обычное (нерасширенное) представление и содержат кнопку для переключения между обычным и расширенным представлениями этого диалогового окна. Расширяемые диалоговые окна обычно применяются в тех приложениях, которые предназначаются как для неопытных, так и для опытных пользователей и скрывают дополнительные опции до тех пор, пока пользователь явным образом не захочет ими воспользоваться. В данном разделе мы используем Qt Designer для создания расширяемого диалогового окна, показанного на рис. 2.10.
   Рис. 2.10. Обычный и расширенный виды окна сортировки данных.
   Данное диалоговое окно является окном сортировки в приложении Электронная таблица, позволяющим пользователю задавать один или несколько столбцов сортировки. В обычном представлении этого окна пользователь может ввести один ключ сортировки, а в расширенном представлении он может ввести дополнительно еще два ключа сортировки. Кнопка More (больше) позволяет пользователю переключаться с обычного представления на расширенное и наоборот.
   Мы создадим в Qt Designer расширенное представление виджета, второй и третий ключи сортировки которого не будут видны при выполнении программы, когда они не нужны. Этот виджет кажется сложным, однако он очень легко строится в Qt Designer. Сначала нужно создать ту часть, которая относится к первичному ключу, затем сдублировать ее дважды, получая вторичный и третичный ключи.
   1. Выберите функцию меню File | New Form и затем шаблон «Dialog with Buttons Right» (диалог с кнопками, расположенными справа).
   2. Создайте кнопку More (больше) и перенесите ее в вертикальный менеджер компоновки ниже вертикальной распорки. Установите свойство text кнопки More на значение «&More», а свойство checkable — на значение «true». Задайте свойство default кнопки OK на значение «true».
   3. Создайте объект «группа элементов (group box)», две текстовые метки, два поля с выпадающим списком (comboboxes) и одну горизонтальную распорку и разместите их где-нибудь на форме.
   4. Передвиньте нижний правый угол элемента группа, увеличивая его. Затем перенесите другие виджеты внутрь элемента группа и расположите их приблизительно так, как показано на рис. 2.11 (а).
   Рис. 2.11. Размещение дочерних виджетов группового элемента в табличной сетке.
   5. Перетащите правый край второго поля с выпадающим списком так, чтобы оно было в два раза шире первого поля.
   6. Свойство title (заголовок) группы установите на значение «&PrimaryKey» (первичный ключ), свойство text первой текстовой метки установите на значение «Column:» (столбец), а свойство text второй текстовой метки установите на значение «Order:» (порядок сортировки).
   7. Щелкните правой клавишей мышки по первому полю с выпадающим списком и выберите функцию Edit Items (редактировать элементы) в контекстном меню для вызова в Qt Designer редактора списков. Создайте один элемент со значением «None» (нет значений).
   8. Щелкните правой клавишей мышки по второму полю с выпадающим списком и выберите функцию Edit Items. Создайте элементы «Ascending» (по возрастанию) и «Descending» (по убыванию).
   9. Щелкните по группе и выберите в меню функцию Form | Lay Out in a Grid (Форма | Размещение в сетке). Еще раз щелкните по группе и выберите в меню функцию Form | Adjust Size (Форма | Настроить размер). В результате получите изображение, представленное на рис. 2.11 (б).
   Если изображение оказалось не совсем таким или вы ошиблись, то всегда можно выбрать в меню функцию Edit | Undo (Правка | Отменить) или Form | Break Layout (Форма | Прервать компоновку), затем изменить положение виджетов и снова повторить все действия.
   Теперь мы добавим групповые элементы для второго и третьего ключей сортировки.
   1. Увеличьте высоту диалогового окна, чтобы можно было в нем разместить дополнительные части.
   2. При нажатой клавише Ctrl (Alt в системе Mac) щелкните по элементу группы Primary Key (первичный ключ) для создания копии элемента группа (и его содержимого) над оригинальным элементом. Перетащите эту копию ниже оригинального элемента группа, по-прежнему нажимая клавишу Ctrl (или Alt). Повторите этот процесс для создания третьего элемента группа, размещая его ниже второго элемента группа.
   3. Измените их свойство title на значения «&Secondary Key» (вторичный ключ) и «&Tertiary Key» (третичный ключ).
   4. Создайте одну вертикальную растяжку и расположите ее между элементом группы первичного ключа и элементом группы вторичного ключа.
   5. Расположите виджеты в сетке, как показано на рис. 2.12 (а).
   6. Щелкните по форме, чтобы отменить выбор любых виджетов, затем выберите функцию меню Form | Lay Out in a Grid (Форма | Расположить в сетке). Форма должна иметь вид, показанный на рис. 2.12 (б).
   7. Свойство sizeHint («идеальный» размер) двух вертикальных растяжек установите на значение [20, 0].
   В результате менеджер компоновки в ячейках сетки будет иметь два столбца и четыре строки — всего восемь ячеек. Элемент группа первичного ключа, левая вертикальная распорка, элемент группа вторичного ключа и элемент группа третичного ключа — каждый из них занимает одну ячейку. Менеджер вертикальной компоновки, содержащий кнопки OK, Cancel и More, занимает две ячейки. Справа внизу диалогового окна будет две свободные ячейки. Если у вас получилась другая картинка, отмените компоновку, измените положение виджетов и повторите все сначала.
   Рис. 2.12. Расположение дочерних элементов формы в сетке.
   Переименуйте форму на «SortDialog» (диалоговое окно сортировки) и измените заголовок на «Sort» (сортировка). Задайте имена дочерним виджетам, как показано на рис. 2.13.
   Выберите функцию меню Edit | Edit Tab Order. Щелкайте поочередно по каждому выпадающему списку, начиная с верхнего и заканчивая нижним, затем щелкайте по кнопкам OK, Cancel и Моге, которые расположены справа. Выберите функцию меню Edit | Edit Widgets для выхода из режима установки переходов по клавише табуляции.
   Теперь, когда форма спроектирована, мы готовы обеспечить ее функциональное наполнение, устанавливая некоторые соединения «сигнал—слот». Qt Designer позволяет устанавливать соединения между виджетами одной формы. Нам требуется обеспечить два соединения.
   Выберите функцию меню Edit | Edit Signals/Slots (Правка | Редактировать сигналы и слоты) для входа в режим формирования соединений в Qt Designer. Соединения представлены синими стрелками между виджетами формы. Поскольку нами выбран шаблон «Dialog with Buttons Right», кнопки OK и CanceI уже подключены к слотам accept() и reject() виджета QDialog. Эти соединения также указаны в окне редактора сигналов и слотов Qt Designer.
   Рис. 2.13. Имена виджетов формы.
   Для установки соединения между двумя виджетами щелкните по виджету, передающему сигнал, соедините красную стрелку с виджетом — получателем сигнала и отпустите клавишу мышки. В результате будет выдано диалоговое окно, позволяющее выбрать для соединения сигнал и слот.
   Рис. 2.14. Соединение виджетов формы.
   Сначала устанавливается соединение между moreButton и secondaryGroupBox. Соедините эти два виджета красной стрелкой, затем выберите toggled(bool) в качестве сигнала и setVisible(bool) в качестве слота. По умолчанию Qt Designer не имеет в списке слотов setVisible(bool), но он появится, если вы включите режим «Show all signals and slots» (Показывать все сигналы и слоты).
   Рис. 2.15. Редактор соединений в QtDesigner.
   Второе соединение устанавливается между сигналом toggled(bool) виджета moreButton и слотом setVisible(bool) виджета tertiaryGroupBox. После установки соединения выберите функцию меню Edit | Edit Widgets для выхода из режима установки соединений.
   Сохраните диалог под именем sortdialog.ui в каталоге sort. Для добавления программного кода в форму мы будем использовать тот же подход на основе множественного наследования, который нами применялся в предыдущем разделе для диалога «Go-to-Cell».
   Сначала создаем файл sortdialog.h со следующим содержимым:
   01 #ifndef SORTDIALOG_H
   02 #define SORTDIALOG_H
   03 #include <QDialog>
   04 #include "ui_sortdialog.h"
   05 class SortDialog : public QDialog, public Ui::SortDialog
   06 {
   07 Q_OBJECT
   08 public:
   09 SortDialog(QWidget *parent = 0);
   10 void setColumnRange(QChar first, QChar last);
   11 };
   12 #endif
 
   Затем создаем sortdialog.cpp:
   01 #include <QtGui>
   02 #include "sortdialog.h"
 
   03 SortDialog::SortDialog(QWidget *parent)
   04 : QDialog(parent)
   05 {
   06 setupUi(this);
   07 secondaryGroupBox->hide();
   08 tertiaryGroupBox->hide();
   09 layout()->setSizeConstraint(QLayout::SetFixedSize);
   10 setColumnRange('А', 'Z');
   11 }
 
   12 void SortDialog::setColumnRange(QChar first, QChar last)
   13 {
   14 primaryColumnCombo->clear();
   15 secondaryColumnCombo->clear();
   16 tertiaryColumnCombo->clear();
 
   17 secondaryColumnCombo->addItem(tr("None"));
   18 tertiaryColumnCombo->addItem(tr("None"));
 
   19 primaryColumnCombo->setMinimumSize(
   20 secondaryColumnCombo->sizeHint());
   21 QChar ch = first;
   22 while (ch <= last) {
   23 primaryColumnCombo->addItem(QString(ch));
   24 secondaryColumnCombo->addItem(QString(ch));
   25 tertiaryColumnCombo->addItem(QString(ch));
   26 ch = ch.unicode() + 1;
   27 }
   28 }
   Конструктор прячет ту часть диалогового окна, где располагаются поля второго и третьего ключей. Он также устанавливает свойство sizeConstraint менеджера компоновки формы на значение QLayout::SetFixedSize, не позволяя пользователю изме-
   От составителя. Страница №42 в исходном DjVu была пропущена! У кого есть — вставьте.
   Создавать в Qt другой распространенный тип изменяющихся диалоговых окон, многостраничные диалоговые окна, даже еще проще как при ручном кодировании, так и при использовании Qt Designer. Такие диалоговые окна можно строить различными способами:
   • можно непосредственно воспользоваться виджетом окно с вкладками QTabWidget. Здесь сверху окна имеется полоска вкладок, которая находится под управлением стека QStackedWidget;
   • можно совместно использовать список QListWidget и стек QStackedWidget, где текущий элемент списка будет определять страницу, показываемую стеком QStackedWidget, обеспечив связь сигнала QListWidget::currentRowChanged() со слотом QStackedWidget::setCurrentIndex();
   • можно виджет древовидной структуры QTreeWidget совместно использовать со стеком QStackedWidget, как в предыдущем случае.
   Класс стека QStackedWidget рассматривается в главе 6 («Управление компоновкой»).

   Динамическими называются диалоговые окна, которые создаются на основе файлов .ui, сделанных в Qt Designer, во время выполнения приложения. Вместо преобразования файла .ui компилятором uic в программу на С++ мы можем загрузить этот файл на этапе выполнения, используя класс QUiLoader:
   QUiLoader uiLoader;
   QFile file("sortdialog.ui");
   QWidget *sortDialog = uiLoader.load(&file);
   if (sortDialog) {
    …
   }
   Мы можем осуществлять доступ к дочерним виджетам формы при помощи функции QObject::findChild<T>():
   QComboBox *primaryColumnCombo =
    sortDialog->findChild<QComboBox *>("primaryColumnCombo");
   if (primaryColumnCombo) {
    …
   }
   Функция findChild<T>() является шаблонной функцией—членом, которая возвращает дочерний объект по заданному имени и типу. Эта функция отсутствует для MSVC 6 из-за ограничений этого компилятора. Если вам необходимо использовать компилятор MSVC 6, вместо этой функции следует вызывать глобальную функцию qFindChild<T>(), которая работает точно так же.
   Класс QUiLoader расположен в отдельной библиотеке. Для использования класса QUiLoader в приложении Qt мы должны добавить в файл .pro следующую строку:
   CONFIG += uitools
   Динамические диалоговые окна позволяют изменять компоновку элементов формы без повторной компиляции приложения. Они могут также использоваться для создания «тонких» клиентских приложений, когда в исполняемый модуль встраивается только основная форма пользовательского интерфейса, а все другие формы создаются по мере необходимости.

   Qt содержит большой набор встроенных виджетов и стандартных диалоговых окон, с помощью которых можно реализовать большинство возможных ситуаций. В данном разделе мы представим изображения экранов почти со всеми из них. Несколько специальных виджетов будет рассматриваться позже: такие виджеты главного окна, как QMenuBar, QToolBar и QStatusBar, обсуждаются в главе 3, а виджеты, связанные с компоновкой элементов (такие, как QSplitter и QScrollArea), рассматриваются в главе 6. Большинство встроенных виджетов и диалоговых окон входят в примеры данной книги. В представленных ниже экранах виджеты используют стиль Plastique.
   Рис. 2.16. Виджеты кнопок Qt.
   Qt содержит четыре вида кнопок: QPushButton, QToolButton, QCheckBox и QRadioButton. Кнопки QPushButton и QToolButton получили наибольшее распространение и используются для инициации какого-то действия при их нажатии, но они также могут применяться как переключатели (один щелчок нажимает кнопку, другой щелчок отпускает кнопку). Флажок QCheckBox может использоваться для включения и выключения независимых опций, в то время как переключатели (радиокнопки) QRadioButton обычно задают взаимоисключающие возможности.
   Рис. 2.17. Виджеты одностраничных контейнеров Qt.
   Контейнеры Qt — это виджеты, которые содержат в себе другие виджеты. Фрейм QFrame, кроме того, может использоваться самостоятельно просто для вычерчивания линий, и он наследуется многими другими классами виджетов, включая QToolBox и QLabel.
   Рис. 2.18. Виджеты многостраничных контейнеров Qt.
   QTabWidget и QToolBox являются многостраничными виджетами. Каждая страница является дочерним виджетом, и страницы нумеруются с нуля.
   Виджеты для просмотра списков элементов оптимизированы для работы с большими наборами данных, и в них часто используются полосы прокрутки. Работа полосы прокрутки реализуется классом QAbstractScrollArea, который является базовым для просмотра списков элементов и для других виджетов, обеспечивающих скроллинг.
   Qt имеет несколько виджетов, которые предназначены для простого отображения информации. Наиболее важным из них является текстовая метка QLabel, и она может также использоваться для форматированного отображения текста (используя простой синтаксис, подобный HTML) и вывода изображений.
   Рис. 2.19. Виджеты для просмотра списков объектов.
   Текстовый браузер QTextBrowser представляет собой подкласс поля редактирования, работающий только в режиме чтения и обеспечивающий основные возможности формата HTML, включая списки, таблицы, изображения и гипертекстовые ссылки. Qt Assistant использует браузер QTextBrowser для представления документации пользователю.
   Рис. 2.20. Виджеты отображения данных в Qt.
   Qt содержит несколько виджетов для ввода данных. Строка редактирования QLineEdit может ограничивать ввод данных, применяя маску ввода или функцию проверки допустимости данных. Поле редактирования QTextEdit является подклассом QAbstractScrollArea, позволяющим редактировать тексты большого объема.
   Рис. 2.21. Виджеты ввода данных в Qt.
   Qt содержит стандартный набор диалоговых окон для выбора пользователем цвета, шрифта, файла или для печати документа.
   Рис. 2.22. Диалоговое окно выбора цвета и диалоговое окно выбора шрифта в Qt.
   В системах Windows и Mac Os X по мере возможности используются «родные» диалоговые окна, а не их общие аналоги.
   Рис. 2.23. Диалоговое окно для выбора файла и диалоговое окно печати документов в Qt.
   Qt содержит разнообразные диалоговые окна для передачи сообщений об ошибках и других сообщений, причем они обеспечивают обратную связь с пользователем. При выполнении продолжительных операций могут использоваться диалоговый индикатор состояния процесса QProgressDialog и показанный ранее индикатор состояния процесса без обратной связи QProgressBar. Очень удобно пользоваться диалоговым окном QInputDialog, когда пользователю требуется ввести одну строку или одно число.
   Рис. 2.24. Диалоговые окна для установки обратной связи с пользователем.
   Встроенные виджеты и стандартные диалоговые окна обладают большими функциональными возможностями, которыми можно пользоваться без дополнительного программирования. Многие специальные требования обеспечиваются установкой свойств виджетов или путем применения механизма сигналов и слотов и реализации пользовательских определений слотов.
   В некоторых случаях может возникнуть потребность в создании пользовательского виджета без помощи стандартных средств. В Qt это делается просто, и возможности пользовательских виджетов будут обладать таким же свойством независимости от платформы, как и возможности встроенных виджетов Qt. Пользовательские виджеты даже можно интегрировать в Qt Designer, и тогда они могут применяться так же, как и встроенные виджеты Qt. В главе 5 объясняются способы создания пользовательских виджетов.

   В данной главе вы научитесь создавать главные окна при помощи средств разработки Qt. К концу главы вы будете способны построить законченный графический пользовательский интерфейс приложения, который имеет меню, панели инструментов и строку состояния, и все необходимые приложению диалоговые окна.
   Главное окно приложения обеспечивает каркас для построения пользовательского интерфейса приложения. Данная глава будет строиться на основе главного окна приложения Электронная таблица, показанного на рис. 3.1. В приложении Электронная таблица используются созданные в главе 2 диалоговые окна Find, Go-to-Cell и Sort (найти, перейти на ячейку и сортировать).
   Рис. 3.1. Приложение Электронная таблица.
   В основе большинства приложений с графическим интерфейсом лежит программный код, обеспечивающий базовые функции, например, чтения и записи файлов или обработки данных, представленных в пользовательском интерфейсе. В главе 4 мы рассмотрим способы реализации такой функциональности, вновь используя в качестве примера приложение Электронная таблица.

   Главное окно приложения создается в виде подкласса QMainWindow. Многие из представленных в главе 2 методов также подходят для построения главных окон, поскольку оба класса QDialog и QMainWindow являются наследниками QWidget.
   Главные окна можно создавать при помощи Qt Designer, но в данной главе мы продемонстрируем, как это все делается при непосредственном программировании. Если вы предпочитаете пользоваться визуальными средствами проектирования, то необходимую информацию вы сможете найти в главе «Creating a Main Window Application» (Создание приложения на основе класса главного окна) в онлайновом руководстве по Qt Designer.
   Исходный код программы главного окна приложения Электронная таблица содержится в двух файлах: mainwindow.h и mainwindow.cpp. Сначала приведем заголовочный файл:
   01 #ifndef MAINWINDOW_H
   02 #define MAINWINDOW_H
   03 #include <QMainWindow>
 
   04 class QAction;
   05 class QLabel;
   06 class FindDialog;
   07 class Spreadsheet;
 
   08 class MainWindow : public QMainWindow
   09 {
   10 Q_OBJECT
   11 public:
   12 MainWindow();
   13 protected:
   14 void closeEvent(QCloseEvent *event);
   Мы определяем класс MainWindow как подкласс QMainWindow. Он содержит макрос Q_OBJECT, поскольку имеет собственные сигналы и слоты.
   Функция closeEvent() определена в QWidget как виртуальная функция; она автоматически вызывается при закрытии окна пользователем. Она переопределяется в MainWindow для того, чтобы можно было задать пользователю стандартный вопрос относительно возможности сохранения изменений («Do you want to save your changes?») и чтобы сохранить на диске пользовательские настройки.
   15 private slots:
   16 void newFile();
   17 void open();
   18 bool save();
   19 bool saveAs();
   20 void find();
   21 void goToCell();
   22 void sort();
   23 void about();
   Некоторые функции меню, как, например, File | New (Файл | Создать) или Help | About (Помощь | О программе), реализованы в MainWindow в виде закрытых слотов. Большинство слотов возвращают значение типа void, однако save() и saveAs() возвращают значение типа bool. Возвращаемое значение игнорируется при выполнении слота в ответ на сигнал, но при вызове слота в качестве функции мы может воспользоваться возвращаемым значением, как это мы можем делать при вызове любой обычной функции С++.
   24 void openRecentFile();
   25 void updateStatusBar();
   26 void spreadsheetModified();
   27 private:
   28 void createActions();
   29 void createMenus();
   30 void createContextMenu();
   31 void createToolBars();
   32 void createStatusBar();
   33 void readSettings();
   34 void writeSettings();
   35 bool okToContinue();
   36 bool loadFile(const QString &fileName);
   37 bool saveFile(const QString &fileName);
   38 void setCurrentFile(const QString &fileName);
   39 void updateRecentFileActions();
   40 QString strippedName(const QString &fullFileName);
   Для поддержки пользовательского интерфейса главному окну потребуется еще несколько закрытых слотов и закрытых функций.
   41 Spreadsheet *spreadsheet;
   42 FindDialog *findDialog;
   43 QLabel *locationLabel;
   44 QLabel *formulaLabel;
   45 QStringList recentFiles;
   46 QString curFile;
 
   47 enum { MaxRecentFiles = 5 };
   48 QAction *recentFileActions[MaxRecentFiles];
   49 QAction *separatorAction;
 
   50 QMenu *fileMenu;
   51 QMenu *editMenu;
    …
   52 QToolBar *fileToolBar;
   53 QToolBar *editToolBar;
   54 QAction *newAction;
   55 QAction *openAction;
    …
   56 QAction *aboutQtAction;
   57 };
   58 #endif
   Кроме этих закрытых слотов и закрытых функций в подклассе MainWindow имеется также много закрытых переменных. По мере их использования мы будем объяснять их назначение.
   Теперь мы кратко рассмотрим реализацию этого подкласса:
   01 #include <QtGui>
   02 #include "finddialog.h"
   03 #include "gotocelldialog.h"
   04 #include "mainwindow.h"
   05 #include "sortdialog.h"
   06 #include "spreadsheet.h"
   Мы включаем заголовочный файл <QtGui>, который содержит определения всех классов Qt, используемых нашим подклассом. Мы также включаем некоторые пользовательские заголовочные файлы из главы 2, а именно finddialog.h, gotocelldialog.h и sortdialog.h.
   07 MainWindow::MainWindow()
   08 {
   09 spreadsheet = new Spreadsheet;
   10 setCentralWidget(spreadsheet);
 
   11 createActions();
   12 createMenus();
   13 createContextMenu();
   14 createToolBars();
   15 createStatusBar();
 
   16 readSettings();
   17 findDialog = 0;
   18 setWindowIcon(QIcon(":/images/icon.png"));
   19 setCurrentFile("");
   20 }
   В конструкторе мы начинаем создание виджета Электронная таблица Spreadsheet и определяем его в качестве центрального виджета главного окна. Центральный виджет занимает среднюю часть главного окна (см. рис. 3.2). Класс Spreadsheet является подклассом QTableWidget, который обладает некоторыми возможностями электронной таблицы: например, он поддерживает формулы электронной таблицы. Реализацию этого класса мы рассмотрим в главе 4.
   Рис. 3.2. Области главного окна QMainWindow.
   Мы вызываем закрытые функции createActions(), createMenus(), createContextMenu(), createToolBars() и createStatusBar() для построения остальной части главного окна. Мы также вызываем закрытую функцию readSettings() для чтения настроек, сохраненных в приложении.
   Мы инициализируем указатель findDialog в нулевое значение, а при первом вызове MainWindow::find() мы создадим объект FindDialog. B конце конструктора в качестве пиктограммы окна мы задаем PNG—файл: icon.png. Qt поддерживает многие форматы графических файлов, включая BMP, GIF^[4], JPEG, PNG, PNM, XBM и XPM. Функция QWidget::setWindowIcon() устанавливает пиктограмму в левый верхний угол окна. К сожалению, не существует независимого от платформы способа установки пиктограммы приложения, отображаемого на рабочем столе компьютера. Описание этой процедуры для различных платформ можно найти в сети Интернет по адресу http://doc.trolltech.com/4.1/appicon.html.
   В приложениях с графическим пользовательским интерфейсом обычно используется много изображений. Существует много различных методов, предназначенных для работы приложения с изображениями. Наиболее распространенными являются:
   • хранение изображений в файлах и загрузка их во время выполнения приложения;
   • включение файлов XPM в исходный код программы; это возможно, поскольку файлы XPM являются совместимыми с файлами исходного кода С++);
   • использование механизма определения ресурсов, предусмотренного в Qt.
   Мы используем здесь механизм определения ресурсов, поскольку он более удобен, чем загрузка файлов во время выполнения приложения, и он работает со всеми поддерживаемыми форматами графических файлов. Мы храним изображения в подкаталоге images исходного дерева.
   Для применения системы ресурсов Qt мы должны создать файл ресурсов и добавить в файл .pro строку, которая задает этот файл ресурсов. В нашем примере мы назвали файл ресурсов spreadsheet.qrc, поэтому в файл .pro мы добавляем следующую строку:
   RESOURCES = spreadsheet.qrc
   Сам файл ресурсов имеет простой XML—формат. Ниже показан фрагмент из используемого нами файла ресурсов:
   <!DOCTYPE RCC><RCC version="1.0">
    <qresource>
    <file>images/icon.png</file>
    …
    <file>images/gotocell.png</file>
    </qresource>
   </RCC>
   Файлы ресурсов после компиляции входят в состав исполняемого модуля приложения, поэтому они не могут теряться. При ссылке на ресурсы мы используемпрефикс пути :/ (двоеточие и слеш), и именно поэтому пиктограмма задается как :/images/icon.png. Ресурсами могут быть любые файлы (не только изображения), и мы можем их использовать в большинстве случаев, когда в Qt ожидается применение имени файла. Они более подробно рассматриваются в гл. 12.

   Большинство современных приложений с графическим пользовательским интерфейсом содержат меню, контекстное меню и панели инструментов. Меню позволяют пользователям исследовать возможности приложения и узнать новые способы работы, а контекстные меню и панели инструментов обеспечивают быстрый доступ к часто используемым функциям.
   Рис. 3.3. Меню приложения Электронная таблица.
   Использование понятия «действия» упрощает программирование меню и панелей инструментов при помощи средств разработки Qt. Элемент action (действие) можно добавлять к любому количеству меню и панелей инструментов. Создание в Qt меню и панелей инструментов разбивается на следующие этапы:
   • создание и настройка действий;
   • создание меню и добавление к ним действий;
   • создание панелей инструментов и добавление к ним действий.
   В приложении Электронная таблица действия создаются в createActions():
   01 void MainWindow::createActions()
   02 {
   03 newAction = new QAction(tr("&New"), this);
   04 newAction->setIcon(QIcon(":/images/new.png"));
   05 newAction->setShortcut(tr("Ctrl+N"));
   06 newAction->setStatusTip(tr("Create a new spreadsheet file"));
   07 connect(newAction, SIGNAL(triggered()),
   08 this, SLOT(newFile()));
   Действие New (создать) имеет клавишу быстрого выбора пункта меню (New)^[5], родительское окно (главное окно), пиктограмму (new.png), клавишу быстрого вызова команды (Ctrl+N) и сообщение в строке состояния. Мы подсоединяем к сигналу этого действия triggered() закрытый слот главного окна newFile(); этот слот мы реализуем в следующем разделе. Это соединение гарантирует, что при выборе пользователем пункта меню File | New (файл | создать), при нажатии им кнопки New на панели инструментов или при нажатии клавиш Ctrl+N будет вызван слот newFile().
   Создание действий Open (открыть), Save (сохранить) и Save As (сохранить как) очень похоже на создание действия New, поэтому мы сразу переходим к строке «recently opened files» (недавно открытые файлы) меню File:
   09 for (int i = 0; i < MaxRecentFiles; ++i)
   10 {
   11 recentFileActions[i] = new QAction(this);
   12 recentFileActions[i]->setVisible(false);
   13 connect(recentFileActions[i], SIGNAL(triggered()),
   14 this, SLOT(openRecentFile()));
   15 }
   Мы заполняем действиями массив recentFileActions. Каждое действие скрыто и подключается к слоту openRecentFile(). Далее мы покажем, как действия в списке недавно используемых файлов сделать видимыми, чтобы можно было ими воспользоваться.
   Теперь перейдем к действию Select All (выделить все):
   16 selectAllAction = new QAction(tr("&All"), this);
   17 selectAllAction->setShortcut(tr("Ctrl+A"));
   18 selectAllAction->setStatusTip(tr("Select all the cells in the spreadsheet"));
   19 connect(selectAllAction, SIGNAL(triggered()),
   20 spreadsheet, SLOT(selectAll()));
   Слот selectAll() обеспечивается в QAbstractItemView, который является одним из базовых классов QTableWidget, поэтому нам самим не надо его реализовывать.
   Давайте теперь перейдем к действию Show Grid (показать сетку) из меню Options (опции):
   21 showGridAction = new QAction(tr("&Show Grid"), this);
   22 showGridAction->setCheckable(true);
   23 showGridAction->setChecked(spreadsheet->showGrid());
   24 showGridAction->setStatusTip(tr("Show or hide the spreadsheet's grid"));
   25 connect(showGridAction, SIGNAL(toggled(bool)),
   26 spreadsheet, SLOT(setShowGrid(bool)));
   Действие Show Grid является включаемым. Оно имеет маркер флажка в меню и реализуется как кнопка—переключатель на панели инструментов. Когда это действие включено, на компоненте Spreadsheet отображается сетка. При запуске приложения мы инициализируем это действие в соответствии со значениями, которые принимаются по умолчанию компонентом Spreadsheet, и поэтому работа этого переключателя будет с самого начала синхронизирована. Затем мы соединяем сигнал toggled(bool) действия Show Grid со слотом setShowGrid(bool) компонента Spreadsheet, который наследуется от QTableWidget. После добавления этого действия к меню или панели инструментов пользователь сможет включать и выключать сетку.
   Действия—переключатели Show Grid и Auto—Recalculate (автопересчет) работают независимо. Кроме того, Qt обеспечивает возможность определения взаимоисключающих действий путем применения своего собственного класса QActionGroup.
   27 aboutQtAction = new QAction(tr("About &Qt"), this);
   28 aboutQtAction->setStatusTip(tr("Show the Qt library's About box"));
   29 connect(aboutQtAction, SIGNAL(triggered()),
   30 qApp, SLOT(aboutQt()));
   31 }
   Для действия About Qt (справка по средствам разработки Qt) мы используем слот aboutQt() объекта QApplication, который доступен через глобальную переменную qApp.
   Рис. 3.4. Диалоговое окно About Qt.
   Действия нами созданы, и теперь мы можем перейти к построению системы меню с этими действиями.
   01 void MainWindow::createMenus()
   02 {
   03 fileMenu = menuBar()->addMenu(tr("&File"));
   04 fileMenu->addAction(newAction);
   05 fileMenu->addAction(openAction);
   06 fileMenu->addAction(saveAction);
   07 fileMenu->addAction(saveAsAction);
   08 separatorAction = fileMenu->addSeparator();
   09 for (int i = 0; i < MaxRecentFiles; ++i)
   10 fileMenu->addAction(recentFileActions[i]);
   11 fileMenu->addSeparator();
   12 fileMenu->addAction(exitAction);
   В Qt все меню являются экземплярами класса QMenu. Функция addMenu() создает виджет QMenu с заданным текстом и добавляет его в строку меню. Функция QMainWindow::menuBar() возвращает указатель на QMenuBar. Строка меню создается при первом вызове menuBar().
   Сначала мы создаем меню File (файл) и затем добавляем к нему действия New, Open, Save и Save As (создать, открыть, сохранить и сохранить как). Мы вставляем разделитель для визуального выделения группы взаимосвязанных пунктов меню. Мы используем цикл for для добавления (первоначально скрытых) действий из массива recentFileActions, а в конце добавляем действие exitAction.
   Мы сохранили указатель на один из разделителей. Это позволяет нам скрывать этот разделитель (если файлы не использовались) или показывать его, поскольку мы не хотим отображать два разделителя, когда между ними ничего нет.
   13 editMenu = menuBar()->addMenu(tr("&Edit"));
   14 editMenu->addAction(cutAction);
   15 editMenu->addAction(copyAction);
   16 editMenu->addAction(pasteAction);
   17 editMenu->addAction(deleteAction);
 
   18 selectSubMenu = editMenu->addMenu(tr("&Select"));
   19 selectSubMenu->addAction(selectRowAction);
   20 selectSubMenu->addAction(selectColumnAction);
   21 selectSubMenu->addAction(selectAllAction);
 
   22 editMenu->addSeparator();
   23 editMenu->addAction(findAction);
   24 editMenu->addAction(goToCellAction);
   В меню Edit (правка) включается подменю. Это подменю (как и меню, к которому оно принадлежит) является экземпляром класса QPopupMenu. Мы просто создаем подменю путем указания this в качестве его родителя и вставляем его в то место меню Edit, где мы собираемся его расположить.
   Теперь мы создаем меню Edit (правка), добавляя действия при помощи QMenu::addAction(), как мы это делали для меню File, и добавляя подменю в нужную позицию при помощи QMenu::addMenu(). Подменю, как и меню, к которому оно относится, имеет тип QMenu.
   25 toolsMenu = menuBar()->addMenu(tr("&Tools"));
   26 toolsMenu->addAction(recalculateAction);
   27 toolsMenu->addAction(sortAction);
 
   28 optionsMenu = menuBar()->addMenu(tr("&Options"));
   29 optionsMenu->addAction(showGridAction);
   30 optionsMenu->addAction(autoRecalcAction);
 
   31 menuBar()->addSeparator();
   32 helpMenu = menuBar()->addMenu(tr("&Help"));
   33 helpMenu->addAction(aboutAction);
   34 helpMenu->addAction(aboutQtAction);
   35 }
   Подобным же образом мы создаем меню Tools, Options и Help (инструменты, опции и помощь). Мы вставляем разделитель между меню Options и Help. В системах Motif и CDE этот разделитель сдвигает меню Help вправо; в других случаях этот разделитель игнорируется.
   Рис. 3.5. Полоса главного меню в стилях систем Motif и Windows.
   01 void MainWindow::createContextMenu()
   02 {
   03 spreadsheet->addAction(copyAction);
   04 spreadsheet->addAction(pasteAction);
   05 spreadsheet->addAction(cutAction);
   06 spreadsheet->setContextMenuPolicy(Qt::ActionsContextMenu);
   07 }
   Любой виджет в Qt может иметь связанный с ним список действий QAction. Для обеспечения в приложении контекстного меню мы добавляем необходимые нам действия в виджет Spreadsheet и устанавливаем политику контекстного меню виджета на отображение контекстного меню с этими действиями. Контекстные меню вызываются при щелчке правой клавишей мышки по виджету или при нажатии специальной клавиши клавиатуры, зависящей от платформы.
   Рис. 3.6. Контекстное меню приложения Электронная таблица.
   Более сложный способ обеспечения контекстного меню заключается в переопределении функции QWidget::contextMenuEvent(), создании виджета QMenu, заполнении его требуемыми действиями и вызове для него функции exec().
   01 void Mainwindow::createToolBars()
   02 {
   03 fileToolBar = addToolBar(tr("&File"));
   04 fileToolBar->addAction(newAction);
   05 fileToolBar->addAction(openAction);
   06 fileToolBar->addAction(saveAction);
   07 editToolBar = addToolBar(tr("&Edif));
   08 editToolBar->addAction(cutAction);
   09 editToolBar->addAction(copyAction);
   10 editToolBar->addAction(pasteAction);
   11 editToolBar->addSeparator();
   12 editToolBar->addAction(findAction);
   13 editToolBar->addAction(goToCellAction);
   14 }
   Создание панелей инструментов очень похоже на создание меню. Мы создаем панель инструментов File и панель инструментов Edit. Как и меню, панель инструментов может иметь разделители.
   Рис. 3.7. Панели инструментов приложения Электронная таблица.

   После создания меню и панелей инструментов мы готовы приступить к созданию строки состояния приложения Электронная таблица.
   Обычно строка состояния содержит два индикатора: положение текущей ячейки и формулу текущей ячейки. Полоса состояния также используется для вывода подсказок и других временных сообщений.
   Для создания строки состояния в конструкторе MainWindow вызывается функция createStatusBar():
   01 void MainWindow::createStatusBar()
   02 {
   03 locationLabel = new QLabel(" W999 ");
   04 locationLabel->setAlignment(Qt::AlignHCenter);
   05 locationLabel->setMinimumSize(locationLabel->sizeHint());
   06 formulaLabel = new QLabel;
   07 formulaLabel->setIndent(3);
   08 statusBar()->addWidget(locationLabel);
   09 statusBar()->addWidget(formulaLabel, 1);
   10 connect(spreadsheet, SIGNAL(currentCellChanged(int, int, int, int)),
   11 this, SLOT(updateStatusBar()));
   12 connect(spreadsheet, SIGNAL(modified()),
   13 this, SLOT(spreadsheetModified()));
   14 updateStatusBar();
   15 }
   Функция QMainWindow::statusBar() возвращает указатель на строку состояния. (Строка состояния создается при первом вызове функции statusBar.) В качестве индикаторов состояния просто используются текстовые метки QLabel, текст которых изменяется по мере необходимости. Мы добавили отступ для formulaLabel, чтобы указанный здесь текст отображался с небольшим смещением от левого края. При добавлении текстовых меток QLabel в строку состояния они автоматически становятся дочерними по отношению к строке состояния.
   Рис. 3.8 показывает, что эти две текстовые метки занимают различное пространство. Индикатор ячейки занимает очень немного места, и при изменении размеров окна дополнительное пространство будет использовано для правого индикатора, где отображается формула ячейки. Это достигается путем установки фактора растяжения на 1 при вызове функции QStatusBar::addWidget() для формулы ячейки при создании двух других индикаторов. Для индикатора позиции фактор растяжения по умолчанию равен 0, и поэтому он не будет растягиваться.
   Рис. 3.8. Строка состояния приложения Электронная таблица.
   Когда QStatusBar располагает виджеты индикаторов, он постарается обеспечить «идеальный» размер виджетов, заданный функцией QWidget::sizeHint(), и затем растянет виджеты, которые допускают растяжение, заполняя дополнительное пространство. Идеальный размер виджета зависит от его содержания и будет сам изменяться по мере изменения содержания. Чтобы предотвратить постоянное изменение размера индикатора ячейки, мы устанавливаем его минимальный размер на значение, достаточное для размещения в нем самого большого возможного текстового значения («W999»), и добавляем еще немного пространства. Мы также устанавливаем его параметр выравнивания на значение AlignHCenter для выравнивания по центру текста в области индикатора.
   Перед завершением функции мы соединяем два сигнала Spreadsheet с двумя слотами главного окна MainWindow: updateStatusBar() и spreadsheetModified().
   01 void MainWindow::updateStatusBar()
   02 {
   03 locationLabel->setText(spreadsheet->currentLocation());
   04 formulaLabel->setText(spreadsheet->currentFormula());
   05 }
   Слот updateStatusBar() обновляет индикаторы расположения ячейки и формулы ячейки. Он вызывается при любом перемещении пользователем курсора ячейки на новую ячейку. В конце функции createStatusBar() этот слот используется как обычная функция для инициализации индикаторов. Это необходимо, поскольку Spreadsheet при запуске не генерирует сигнал currentCellChanged().
   06 void MainWindow::spreadsheetModified()
   07 {
   08 setWindowModified(true);
   09 updateStatusBar();
   10 }
   Слот spreadsheetModified() обновляет все три индикатора для отражения ими текущего состояния приложения и устанавливает переменную modified на значение true. (Мы использовали переменную modified при реализации меню File для контроля несохраненных изменений.) Слот spreadsheetModified() устанавливает свойство windowModified в значение true, обновляя строку заголовка. Эта функция обновляет также индикаторы расположения и формулы ячейки, чтобы они отражали текущее состояние.

   В данном разделе мы определим слоты и закрытые функции, необходимые для обеспечения работы меню File и для управления списком недавно используемых файлов.
   01 void MainWindow::newFile()
   02 {
   03 if (okToContinue ())
   04 {
   05 spreadsheet->clear();
   06 setCurrentFile("");
   07 }
   08 }
   Слот newFile() вызывается при выборе пользователем пункта меню File | New или при нажатии кнопки New на панели инструментов. Закрытая функция okToContinue() задает пользователю вопрос относительно необходимости сохранения изменений («Do you want to save your changes?» — Сохранить изменения?), если изменения до этого не были сохранены. Она возвращает значение true, если пользователь отвечает Yes или No (сохраняя документ при ответе Yes), и она возвращает значение false, если пользователь отвечает Cancel. Функция Spreadsheet::clear() очищает все ячейки и формулы электронной таблицы. Закрытая функция setCurrentFile() кроме установки закрытой переменной curFile и обновления списка недавно используемых файлов изменяет заголовок окна, отражая тот факт, что редактируемый документ не имеет заголовка.
   01 bool MainWindow::okToContinue()
   02 {
   03 if (isWindowModified()) {
   04 int r = QMessageBox::warning(this,
   05 tr("Spreadsheet"), tr("The document has been modified.\n"
   06 "Do you want to save your changes?"),
   07 QMessageBox::Yes | QMessageBox::Default,
   08 QMessageBox::No,
   09 QMessageBox::Cancel | QMessageBox::Escape);
   10 if (r == QMessageBox::Yes) {
   11 return save();
   12 } else if (r == QMessageBox::Cancel) {
   13 return false;
   14 }
   15 }
   16 return true;
   17 }
   B okToContinue() мы проверяем свойство windowModified. Если оно имеет значение true, мы выводим на экран сообщение, показанное на рис. 3.9. Окно сообщения содержит кнопки Yes, No и Cancel. Модификатор QMessageBox::Default делает Yes кнопкой, которая выбирается по умолчанию. Модификатор QMessageBox::Escape задает клавишу Esc в качестве синонима кнопки Cancel.
   Рис. 3.9. «Сохранить изменения?»
   Вызов функции warning() на первый взгляд может показаться слишком сложным, но он имеет очень простой формат:
   QMessageBox::warning(родительский объект, заголовок, сообщение, кнопка0, кнопка1, …);
   QMessageBox содержит функции information(), question() и critical(), каждая из которых имеет собственную пиктограмму.
   Рис. 3.10. Пиктограммы окна сообщения.
   01 void MainWindow::open()
   02 {
   03 if (okToContinue()) {
   04 QString fileName = QFileDialog::getOpenFileName(".", fileFilters, this);
   05 if (!fileName.isEmpty())
   06 loadFile(fileName);
   07 }
   08 }
   Слот open() соответствует пункту меню File | Open. Как и слот newFile(), он сначала вызывает okToContinue() для обработки несохраненных изменений. Затем он вызывает удобную статическую функцию QFileDialog::getOpenFileName() для получения от пользователя нового имени файла. Эта функция выводит на экран диалоговое окно для выбора пользователем файла и возвращает имя файла или пустую строку при нажатии пользователем клавиши Cancel.
   В первом аргументе функции QFileDialog::getOpenFileName() задается родительский виджет. Взаимодействие родительских и дочерних объектов для диалоговых окон и для других виджетов будет различно. Диалоговое окно всегда является самостоятельным окном, однако если у него имеется родитель, то оно размещается по умолчанию в верхней части родительского объекта. Кроме того, дочернее диалоговое окно использует панель задач родительского объекта.
   Во втором аргументе задается название диалогового окна. В третьем аргументе задается каталог начала просмотра файлов; в нашем случае это будет текущий каталог.
   Четвертый аргумент определяет фильтры файлов. Фильтр файла состоит из описательной части и образца поиска. Если допустить поддержку не только родного формата файлов приложения Электронная таблица, а также формата файлов с запятой в качестве разделителя и файлов Lotus 1-2-3, нам пришлось бы инициализировать переменные следующим образом:
   tr("Spreadsheet files (*.sp)\n"
    "Comma-separated values files (*.csv)\n"
    "Lotus 1-2-3 files (*.wk1 *.wks)")
   Закрытая функция loadFile() вызвана в open() для загрузки файла. Мы делаем эту функцию независимой, поскольку нам потребуется выполнить те же действия для загрузки файлов, которые открывались недавно:
   01 bool MainWindow::loadFile(const QString &fileName)
   02 {
   03 if (!spreadsheet->readFile(fileName)) {
   04 statusBar()->showMessage(tr("Loading canceled"), 2000);
   05 return false;
   06 }
   07 setCurrentFile(fileName);
   08 statusBar()->showMessage(tr("File loaded"), 2000);
   09 return true;
   10 }
   Мы используем функцию Spreadsheet::readFile() для чтения файла с диска. Если загрузка завершилась успешно, мы вызываем функцию setCurrentFile() для обновления заголовка окна; в противном случае функция Spreadsheet::readFile() уведомит пользователя о возникшей проблеме, выдав соответствующее сообщение. В целом полезно предусматривать выдачу сообщений об ошибках в компонентах низкого уровня, поскольку они могут обеспечить получение точной информации о причинах ошибки.
   В обоих случаях мы будем выдавать сообщение в строке состояния в течение 2 секунд (2000 миллисекунд) для того, чтобы пользователь знал о выполняемых приложением действиях.
   01 bool MainWindow::save()
   02 {
   03 if (curFile.isEmpty()) {
   04 return saveAs();
   05 } else {
   06 return saveFile(curFile);
   07 }
   08 }
 
   09 bool MainWindow::saveFile(const QString &fileName)
   10 {
   11 if (!spreadsheet->writeFile(fileName)) {
   12 statusBar()->showMessage(tr("Saving canceled"), 2000);
   13 return false;
   14 }
   15 setCurrentFile(fileName);
   16 statusBar()->showMessage(tr("File saved"), 2000);
   17 return true;
   18 }
   Слот save() соответствует пункту меню File | Save. Если файл уже имеет имя, потому что уже открывался до этого или уже сохранялся, слот save() вызывает saveFile(), задавая это имя; в противном случае он просто вызывает saveAs().
   01 bool MainWindow::saveAs()
   02 {
   03 QString fileName = QFileDialog::getSaveFileName(this,
   04 tr("SaveSpreadsheet"),
   05 tr("Spreadsheet files (*.sp)"));
   06 if (fileName.isEmpty())
   07 return false;
   08 return saveFile(fileName);
   09 }
   Слот saveAs() соответствует пункту меню File | Save As. Мы вызываем QFileDialog::getSaveFileName() для получения имени файла от пользователя. Если пользователь нажимает кнопку Cancel, мы возвращаем значение false, которое передается дальше вплоть до вызвавшей функции (save() или okToContinue()).
   Если файл с данным именем уже существует, функция getSaveFileName() попросит пользователя подтвердить его перезапись. Такое поведение можно предотвратить, передавая функции getSaveFileName() дополнительный аргумент QFileDialog::DontConfirmOverwrite.
   01 void MainWindow::closeEvent(QCloseEvent *event)
   02 {
   03 if (okToContinue()) {
   04 writeSettings();
   05 event->accept();
   06 } else {
   07 event->ignore();
   08 }
   09 }
   Когда пользователь выбирает пункт меню File | Exit или щелкает по кнопке X заголовка окна, вызывается слот QWidget::close(). В результате будет сгенерировано событие виджета «close» (закрытие). Переопределяя функцию QWidget::closeEvent(), мы можем перехватывать команды по закрытию главного окна и принимать решения относительно возможности его фактического закрытия.
   Если изменения не сохранены и пользователь нажимает кнопку Cancel, мы «игнорируем» это событие, и оно никак не повлияет на окно. В обычном случае мы реагируем на это событие, и в результате Qt закроет окно. Мы вызываем также закрытую функцию writeSettings() для сохранения текущих настроек приложения.
   Когда закрывается последнее окно, приложение завершает работу. При необходимости мы можем отменить такой режим работы, устанавливая свойство quitOnLastWindowClosed класса QApplication на значение false, и в результате приложение продолжит выполняться до тех пор, пока мы не вызовем функцию QApplication::quit().
   01 void MainWindow::setCurrentFile(const QString &fileName)
   02 {
   03 curFile = fileName;
   04 setWindowModified(false);
   05 QString shownName = "Untitled";
   06 if (!curFile.isEmpty()) {
   07 shownName = strippedName(curFile);
   08 recentFiles.removeAll(curFile);
   09 recentFiles.prepend(curFile);
   10 updateRecentFileActions();
   11 }
   12 setWindowTitle(tr("%1[*] - %2").arg(shownName)
   13 .arg(tr("Spreadsheet")));
   14 }
 
   15 QString MainWindow::strippedName(const QString &fullFileName)
   16 {
   17 return QFileInfo(fullFileName).fileName();
   18 }
   В функции setCurrentFile() мы задаем значение закрытой переменной curFile, в которой содержится имя редактируемого файла. Перед тем как отобразить имя файла в заголовке, мы убираем путь к файлу с помощью функции strippedName(), чтобы имя файла выглядело более привлекательно.
   Каждый QWidget имеет свойство windowModified, которое должно быть установлено на значение true, если документ окна содержит несохраненные изменения, и на значение false в противном случае. В системе Mac OS X несохраненные документы отмечаются точкой на кнопке закрытия, расположенной в заголовке окна, в других системах такие документы отмечаются звездочкой в конце имени файла. Все это обеспечивается в Qt автоматически, если мы своевременно обновляем свойство windowModified и помещаем маркер «[*]» в заголовок окна по мере необходимости.
   В функцию setWindowTitle() мы передали следующий текст:
   tr("%1[*] - %2").arg(shownName)
    .arg(tr("Spreadsheet"))
   Функция QString::arg() заменяет своим аргументом параметр «%n» с наименьшим номером и возвращает полученную строку. В нашем случае arg() имеет два параметра «%n». При первом вызове функция arg() заменяет параметр «%1»; второй вызов заменяет «%2». Если файл имеет имя «budget.sp» и файл перевода не загружен, мы получим строку «budget.sp[*] — Spreadsheet». Проще написать:
   setWindowTitle(shownName + tr("[*] - Spreadsheet"));
   но применение arg() облегчает перевод сообщения на другие языки.
   Если задано имя файла, мы обновляем recentFiles — список имен файлов, которые открывались в приложении недавно. Мы вызываем функцию removeAll() для удаления всех файлов с этим именем из списка, чтобы избежать дублирования; затем мы вызываем функцию prepend() для помещения имени данного файла в начало списка. После обновления списка имен файлов мы вызываем функцию updateRecentFileActions() для обновления пунктов меню File.
   01 void MainWindow::updateRecentFileActions()
   02 {
   03 QMutableStringListIterator i(recentFiles);
   04 while (i.hasNext()) {
   05 if (!QFile::exists(i.next()))
   06 i.remove();
   07 }
   08 for (int j = 0; j < MaxRecentFiles; ++j) {
   09 if (j < recentFiles.count()) {
   10 QString text = tr("&%1 %2")
   11 .arg(j + 1)
   12 .arg(strippedName(recent Files[j]));
   13 recentFileActions[j]->setText(text);
   14 recentFileActions[j]->setData(recentFiles[j]);
   15 recentFileActions[j]->setVisible(true);
   16 } else {
   17 recentFileActions[j]->setVisible(false);
   18 }
   19 }
   20 separatorAction->setVisible(!recentFiles.isEmpty());
   21 }
   Сначала мы удаляем все файлы, которые больше не существуют, используя итератор в стиле Java. Некоторые файлы могли использоваться в предыдущем сеансе, но с этого момента их уже не будет. Переменная recentFiles имеет тип QStringList (список QStrings). В главе 11 подробно рассматриваются такие классы—контейнеры, как QStringList, и их связь со стандартной библиотекой шаблонов С++ (Standard Template Library — STL), a также применение в Qt классов итераторов в стиле Java.
   Затем мы снова проходим по списку файла, на этот раз пользуясь индексацией массива. Для каждого файла мы создаем строку из амперсанда, номера файла (j + 1), пробела и имени файла (без пути). Для соответствующего пункта меню мы задаем этот текст. Например, если первым был файл С:\My Documents\tab04.sp, пункт меню первого недавно используемого файла будет иметь текст «&1 tab04.sp».
   Рис. 3.11. Меню File со списком файлов, которые открывались недавно.
   С каждым пунктом меню recentFileActions может быть связан элемент данных «data» типа QVariant. Тип QVariant может хранить многие типы С++ и Qt; он рассматривается в гл. 11. Здесь в элементе меню «data» мы храним полное имя файла, чтобы позже можно было легко его найти. Мы также делаем этот пункт меню видимым.
   Если пунктов меню (массив recentFileActions) больше, чем недавно открытых файлов (массив recentFiles), мы просто не отображаем дополнительные пункты. Наконец, если существует по крайней мере один недавно используемый файл, мы делаем разделитель видимым.
   01 void MainWindow::openRecentFile()
   02 {
   03 if (okToContinue()) {
   04 QAction *action = qobject_cast<QAction *>(sender());
   05 if (action)
   06 loadFile(action->data(). toString());
   07 }
   08 }
   При выборе пользователем какого-нибудь недавно используемого файла вызывается слот openRecentFile(). Функция okToContinue() используется в том случае, когда имеются несохраненные изменения, и если пользователь не отменил сохранение изменений, мы определяем, какой конкретный пункт меню вызвал слот, используя функцию QObject::sender().
   Функция qobject_cast<T>() выполняет динамическое приведение типов на основе мета―информации, сгенерированной moc — компилятором мета—объектов Qt. Она возвращает указатель на запрошенный подкласс QObject или 0, если нельзя объект привести к данному типу. В отличие от функции dynamic_cast<T>() стандартного С++, функция Qt qobject_cast<T>() работает правильно за пределами динамической библиотеки. В нашем примере мы используем qobject_cast<T>() для приведения указателя QObject в указатель QAction. Если приведение удачно (а оно должно быть удачным), мы вызываем функцию loadFile(), задавая полное имя файла, которое мы извлекаем из элемента данных пункта меню.
   Поскольку мы знаем, что слот вызывался объектом QAction, в данном случае программа все же правильно сработала бы при использовании функции static_cast<T>() или при традиционном приведении С—типов. (См. раздел «Преобразование типов» в приложении Б, где дается обзор различных методов приведения типов в С++.)

   В данном разделе мы рассмотрим способы применения диалоговых окон в Qt: как они создаются и инициализируются и как они реагируют на действия пользователя при работе с ними. Мы будем использовать диалоговые окна Find, Go-to-Cell и Sort (найти, перейти в ячейку и сортировать), которые были созданы нами в главе 2. Мы также создадим простое окно About (справка о программе).
   Рис. 3.12. Диалоговое окно Find приложения Электронная таблица.
   Мы начнем с диалогового окна Find. Поскольку мы хотим, чтобы пользователь имел возможность свободно переключаться с главного окна приложения Электронная таблица на диалоговое окно Find и обратно, это диалоговое окно должно быть немодальным. Немодальным называется окно, которое может работать независимо от других окон приложения.
   При создании немодальных диалоговых окон они обычно имеют свои сигналы, соединенные со слотами, которые реагируют на действия пользователя:
   01 void MainWindow::find()
   02 {
   03 if (!findDialog) {
   04 findDialog = new FindDialog(this);
   05 connect(findDialog, SIGNAL (findNext(const QString &,
   06 Qt::CaseSensitivity)),
   07 spreadsheet, SLOT (findNext(const QString &,
   08 Qt::CaseSensitivity)));
   09 connect(findDialog, SIGNAL(findPrevious(const QString &,
   10 Qt::CaseSensitivity)),
   11 spreadsheet, SLOT(findPrevious(const QString &,
   12 Qt::CaseSensitivity)));
   13 }
   14 findDialog->show();
   15 findDialog->activateWindow();
   16 }
   Диалоговое окно Find позволяет пользователю выполнять поиск текста в электронной таблице. Слот find() вызывается при выборе пользователем пункта меню Edit | Find (Правка | Найти) для вывода на экран диалогового окна Find. После этого возможны три сценария развития событий в зависимости от следующих условий:
   • диалоговое окно Find вызывается пользователем первый раз;
   • диалоговое окно Find уже вызывалось, но пользователь его закрыл;
   • диалоговое окно Find уже вызывалось, и оно по-прежнему видимо.
   Если нет диалогового окна Find, мы создаем его, а его функции findNext() и findPrevious() подсоединяем к соответствующим слотам электронной таблицы Spreadsheet. Мы могли бы также создать это диалоговое окно в конструкторе MainWindow, но отсрочка его создания ускоряет запуск приложения. Кроме того, если это диалоговое окно никогда не будет использовано, то оно и не будет создаваться, что сэкономит время и память.
   Затем мы вызываем функции show() и activateWindow() и тем самым делаем это окно видимым и активным. Чтобы сделать скрытое окно видимым и активным, достаточно вызвать функцию show(), но диалоговое окно Find может вызываться, когда оно уже имеется на экране, и в этом случае функция show() ничего не будет делать и необходимо вызвать activateWindow(), чтобы сделать окно активным. Можно поступить по-другому и написать:
   if (findDialog->isHidden()) {
    findDialog->show();
   } else {
    findDialog->activateWindow();
   }
   что аналогично ситуации, когда вы смотрите в обе стороны при переходе улицы с односторонним движением.
   Теперь мы перейдем к созданию диалогового окна Go-to-Cell (перейти на ячейку). Мы хотим, чтобы пользователь мог его вызвать, произвести соответствующие действия с его помощью и затем закрыть его, причем пользователь не должен иметь возможность переходить на любое другое окно приложения. Это означает, что диалоговое окно перехода на ячейку должно быть модальным. Окно называется модальным, если после его вызова работа приложения блокируется и оказывается невозможной работа с другими окнами приложения до закрытия этого окна. Все используемые нами до сих пор файловые диалоговые окна и окна с сообщениями были модальными.
   Рис. 3.13. Диалоговое окно Go-to-Cell приложения Электронная таблица.
   Диалоговое окно будет немодальным, если оно вызывается с помощью функции show() (если мы не сделали до этого его модальным, воспользовавшись функцией setModal()); оно будет модальным, если вызывается при помощи функции exec().
   01 void MainWindow::goToCell()
   02 {
   03 GoToCellDialog dialog(this);
   04 if (dialog.exec()) {
   05 QString str = dialog.lineEdit->text().toUpper();
   06 spreadsheet->setCurrentCell(str.mid(1).toInt() - 1,
   07 str[0].unicode() - 'А');
   08 }
   09 }
   Функция QDialog::exec() возвращает значение true (QDialog::Accepted), если через диалоговое окно подтверждается действие, и значение false (QDialog::Rejected) в противном случае. Напомним, что мы в главе 2 создали диалоговое окно перехода на ячейку при помощи Qt Designer и подсоединили кнопку OK к слоту accept(), а кнопку Cancel — к слоту reject(). Если пользователь нажимает кнопку OK, мы устанавливаем текущую ячейку таблицы на значение, заданное в строке редактирования.
   В функции QTableWidget::setCurrentCell() задаются два аргумента: индекс строки и индекс столбца. В приложении Электронная таблица обозначение A1 относится к ячейке (0, 0), а обозначение B27 относится к ячейке (26, 1). Для получения индекса строки из возвращаемого функцией QLineEdit::text() значения типа QString мы выделяем номер строки с помощью функции QString::mid() (которая возвращает подстроку с первой позиции до конца этой строки), преобразуем ее в целое число типа int при помощи функции QString::toInt() и вычитаем единицу. Для получения номера столбца мы вычитаем числовой код буквы «А» из числового кода первой буквы строки, преобразованной в прописную. Мы знаем, что строка будет иметь правильный формат, потому что осуществляемый нами контроль диалога с помощью QRegExpValidator делает кнопку OK активной только в том случае, если за буквой располагается не более трех цифр.
   Функция goToCell() отличается от приводимого до сих пор программного кода тем, что она создает виджет (GoToCellDialog) в виде переменной стека. Мы столь же легко могли бы воспользоваться операторами new и delete, что увеличило бы программный код только на одну строку:
   01 void MainWindow::goToCell()
   02 {
   03 GoToCellDialog *dialog = new GoToCellDialog(this);
   04 if (dialog->exec()) {
   05 QString str = dialog->lineEdit->text().toUpper();
   06 spreadsheet->setCurrentCell(str.mid(1).toInt() - 1,
   07 str[0].unicode() - 'A');
   08 }
   09 delete dialog;
   10 }
   Создание модальных диалоговых окон (и контекстных меню при переопределении QWidget::contextMenuEvent()) является обычной практикой программирования, поскольку такое окно (или меню) будет не нужно после его использования, и оно будет автоматически уничтожено при выходе из области видимости.
   Теперь мы перейдем к созданию диалогового окна Sort. Это диалоговое окно является модальным и позволяет пользователю упорядочить текущую выбранную область, задавая в качестве ключей сортировки определенные столбцы. На рис. 3.14 показан пример сортировки, когда в качестве главного ключа сортировки используется столбец В, а в качестве вторичного ключа сортировки используется столбец А (в обоих случаях сортировка выполняется по возрастанию значений).
   Рис. 3.14. Сортировка выделенной области электронной таблицы.
   01 void MainWindow::sort()
   02 {
   03 SortDialog dialog(this);
   04 QTableWidgetSelectionRange range = spreadsheet->selectedRange();
   05 dialog.setColumnRange('A' + range.leftColumn(),
   06 'А' + range.rightColumn());
   07 if (dialog.exec()) {
   08 SpreadsheetCompare compare;
   09 compare.keys[0] =
   10 dialog.primaryColumnCombo->currentIndex();
   11 compare.keys[1] =
   12 dialog.secondaryColumnCombo->currentIndex() - 1;
   13 compare.keys[2] =
   14 dialog.tertiaryColumnCombo->currentIndex() - 1;
   15 compare.ascending[0] =
   16 (dialog.primaryOrderCombo->currentIndex() == 0);
   17 compare.ascending[1] =
   18 (dialog.secondaryOrderCombo->currentIndex() == 0);
   19 compare.ascending[2] =
   20 (dialog.tertiaryOrderCombo->currentIndex() == 0);
   21 spreadsheet->sort(compaге);
   22 }
   23 }
   Порядок действий при программировании функции sort() аналогичен порядку действий, применяемому при программировании функции goToCell();
   • мы создаем диалоговое окно в стеке и инициализируем его;
   • мы вызываем диалоговое окно при помощи функции exec();
   • если пользователь нажимает кнопку OK, мы используем введенные пользователем в диалоговом окне значения соответствующим образом.
   Вызов setColumnRange() задает столбцы, выбранные для сортировки. Например, при выделении области, показанной на рис. 3.14, функция range.leftColumn() возвратит 0, давая в результате 'A' + 0 = 'A', a range.rightColumn() возвратит 2, давая в результате 'A' + 2 = 'C'.
   В объекте compare хранятся первичный, вторичный и третичный ключи, а также порядок сортировки по ним. (Определение класса SpreadsheetCompare мы рассмотрим в следующей главе.) Этот объект используется функцией Spreadsheet::sort() для сортировки строк. В массиве keys содержатся номера столбцов ключей. Например, если выбрана область с C2 по E5, то столбец С будет иметь индекс 0. В массиве ascending в переменных типа bool хранятся значения направления сортировки для каждого ключа. Функция QComboBox::currentIndex() возвращает индекс текущего элемента (начиная с 0). Для вторичного и третичного ключей мы вычитаем единицу из текущего элемента, чтобы учесть значения «None» (отсутствует).
   Функция sort() сделает свою работу, но она не совсем надежна. Она предполагает определенный способ реализации диалогового окна, а именно использование выпадающих списков и элементов со значением «None». Это означает, что при изменении дизайна диалогового окна Sort нам, возможно, потребуется изменить также программный код. Такой подход можно использовать для диалогового окна, применяемого только в одном месте; однако это может вызвать серьезные проблемы сопровождения, если это диалоговое окно станет использоваться в различных местах.
   Более надежным будет такой подход, когда класс SortDialog делается более «разумным» и может создавать свой собственный объект SpreadsheetCompare, доступный вызывающему его компоненту. Это значительно упрощает функцию MainWindow::sort():
   01 void MainWindow::sort()
   02 {
   03 SortDialog dialog(this);
   04 QTableWidgetSelectionRange range = spreadsheet->selectedRange();
   05 dialog.setColumnRange('A' + range.leftColumn(),
   06 'А' + range.rightColumn());
   07 if (dialog.exec())
   08 spreadsheet->performSort(dialog.comparisonObject());
   09 }
   Такой подход приводит к созданию слабо связанных компонентов, и выбор его почти всегда будет правилен для диалоговых окон, которые вызываются из нескольких мест.
   Более «радикальный» подход мог бы заключаться в передаче указателя на объект Spreadsheet при инициализации объекта SortDialog и разрешении диалоговому окну работать непосредственно с объектом Spreadsheet. Это значительно снизит универсальность диалогового окна SortDialog, поскольку оно будет работать только с виджетами определенного типа, но это позволит еще больше упростить программу из-за возможности исключения функции SortDialog::setColumnRange(). В этом случае функция MainWindow::sort() примет следующий вид:
   01 void MainWindow::sort()
   02 {
   03 SortDialog dialog(this);
   04 dialog.setSpreadsheet(spreadsheet);
   05 dialog.exec();
   06 }
   Этот подход является зеркальным отражением первого: вместо знания вызывающим компонентом характерных особенностей диалогового окна теперь само диалоговое окно должно иметь представление об особенностях структур данных, передаваемых вызывающим компонентом. Этот подход полезно применять, когда диалоговому окну требуется отслеживать изменения. В то время как при первом подходе ненадежен код вызвавшего компонента, третий подход перестает работать при изменении структуры данных.
   Некоторые разработчики выбирают один из подходов и всегда следуют ему. При этом разработка диалоговых окон становится более привычным и простым делом, однако достоинства других подходов не будут использованы. В идеале решение по выбору конкретного подхода должно учитывать в каждом случае особенности конкретного диалогового окна.
   Мы завершим данный раздел созданием диалогового окна About (справка о программе). Мы могли бы создать для представления данных о программе специальное диалоговое окно наподобие созданных нами ранее Find или Go-to-Cell, но поскольку диалоговые окна About сильно стилизованы, в средствах разработки Qt предусмотрено простое решение:
   01 void MainWindow::about()
   02 {
   03 QMessageBox::about(this, tr("About Spreadsheet"),
   04 tr("<h2>Spreadsheet 1.1</h2>"
   05 "<p>Copyright &copy; 2006 Software Inc."
   06 "<p>Spreadsheet is a small application that "
   07 "demonstrates QAction, QMainWindow, QMenuBar, "
   08 "QStatusBar, QTableWidget, QToolBar, and many other "
   09 "Qt classes."));
   10 }
   Рис. 3.15. Справка о приложении Электронная таблица.
   Диалоговое окно About получается путем вызова удобной статической функции QMessageBox::about(). Эта функция очень напоминает функцию QMessageBox::warning(), однако здесь вместо стандартных «предупреждающих» пиктограмм используется пиктограмма родительского окна.
   Таким образом, мы уже сумели воспользоваться несколькими удобными статическими функциями, определенными в классах QMessageBox и QFileDialog. Эти функции создают диалоговое окно, инициализируют его и вызывают для него функцию exec(). Кроме того, вполне возможно, хотя и менее удобно, создать виджет QMessageBox или QFileDialog так же, как это делается для любого другого виджета, и явно вызвать для него функцию exec() или даже show().

   В конструкторе MainWindow мы уже вызывали функцию readSettings() для загрузки сохраненных приложением настроек. Аналогично в функции closeEvent() мы вызывали writeSettings() для сохранения настроек. Эти функции являются последними функциями—членами MainWindow, которые необходимо реализовать.
   01 void MainWindow::writeSettings()
   02 {
   03 QSettings settings("Software Inc.", "Spreadsheet");
   04 settings.setValue("geometry", geometry());
   05 settings.setValue("recentFiles", recentFiles);
   06 settings.setValue("showGrid", showGridAction->isChecked());
   07 settings.setValue("autoRecalc", autoRecalcAction->isChecked());
   08 }
   Функция writeSettings() сохраняет «геометрию» окна (положение и размер), список последних открывавшихся файлов и опции Show Grid (показать сетку) и Auto—Recalculate (автоматический повтор вычислений).
   По умолчанию QSettings сохраняет настройки приложения в месте, которое зависит от используемой платформы. В системе Windows для этого используется системный реестр; в системе Unix данные хранятся в текстовых файлах; в системе Mac OS X для этого используется прикладной интерфейс задания установок Core Foundation Preferences.
   В аргументах конструктора задаются название организации и имя приложения. Эта информация используется затем (причем по-разному для различных платформ) для определения места расположения настроек.
   QSettings хранит настройки в виде пары ключ—значение. Здесь ключ подобен пути файловой системы. Подключи можно задавать, используя синтаксис, подобный тому, который применяется при указании пути (например, findDialog/matchCase), или используя beginGroup() и endGroup():
   settings.beginGroup("findDialog");
   settings.setValue("matchCase", caseCheckBox->isChecked());
   settings.setValue("searchBackward", backwardCheckBox->isChecked());
   settings.endGroup();
   Значение value может иметь типы int, bool, double, QString, QStringList или любой другой, поддерживаемый QVariant, включая зарегистрированные пользовательские типы.
   01 void MainWindow::readSettings()
   02 {
   03 QSettings settings("Software Inc.", "Spreadsheet");
   04 QRect rect = settings.value("geometry",
   05 QRect(200, 200, 400, 400)).toRect();
   06 move(rect.topLeft());
   07 resize(rect.size());
   08 recentFiles = settings.value("recentFiles").toStringList();
   09 updateRecentFileActions();
   10 bool showGrid = settings.value("showGrid", true).toBool();
   11 showGridAction->setChecked(showGrid);
   12 bool autoRecalc = settings.value("autoRecalc", true).toBool();
   13 autoRecalcAction->setChecked(autoRecalc);
   14 }
   Функция readSettings() загружает настройки, которые были сохранены функцией writeSettings(). Второй аргумент функции value() определяет значение, принимаемое по умолчанию в случае отсутствия запрашиваемого параметра. Принимаемые по умолчанию значения будут использованы при первом запуске приложения. Поскольку второй аргумент не задан для списка недавно используемых файлов, этот список будет пустым при первом запуске приложения.
   Qt содержит функцию QWidget::setGeometry(), которая дополняет функцию QWidget:: geometry(), однако они не всегда работают должным образом в системе X11 из-за ограничений многих оконных менеджеров. По этой причине мы используем вместо них функции move() и resize(). (Подробную информацию по тому вопросу можно найти по адресу http://doc.trolltech.com/4.1/geometry.html.)
   Весь программный код MainWindow, относящийся к объектам QSettings, мы разместили в функциях readSettings() и writeSettings(); такой подход лишь один из возможных. Объект QSettings может создаваться для запроса или модификации каких-нибудь настроек в любой момент во время выполнения приложения и из любого места программы.
   Теперь мы завершили построение главного окна MainWindow приложения Электронная таблица. В следующих разделах мы рассмотрим возможность модификации приложения Электронная таблица для обеспечения работы со многими документами и реализации экранных заставок. Мы завершим реализацию этих функций, в том числе обеспечивающих обработку формул и сортировку, в следующей главе.

   Теперь мы готовы написать функцию main() приложения Электронная таблица:
   01 #include <QApplication>
   02 #include "mainwindow.h"
   03 int main(int argc, char *argv[])
   04 {
   05 QApplication app(argc, argv);
   06 MainWindow mainWin;
   07 mainWin.show();
   08 return app.exec();
   09 }
   Данная функция main() немного отличается от написанных ранее: мы создали экземпляр MainWindow в виде переменной стека, а не использовали оператор new. Экземпляр MainWindow будет автоматически уничтожен после завершения функции.
   При применении данной функции main() приложение Электронная таблица обеспечивает вывод на экран только одного главного окна и позволяет работать только с одним документом. Если мы хотим одновременно редактировать несколько документов, нам придется запускать несколько приложений Электронная таблица. Но это будет не так удобно, как если бы один экземпляр приложения обеспечивал вывод на экран многих главных окон, подобно тому как один экземпляр веб-браузера позволяет просматривать одновременно несколько окон.
   Мы модифицируем приложение Электронная таблица для обеспечения возможности работы со многими документами. Для начала нам потребуется немного видоизменить меню File:
   • пункт меню File | New создает новое главное окно с пустым документом вместо повторного использования существующего главного окна;
   • пункт меню File | Close закрывает текущее главное окно;
   • пункт меню File | Exit закрывает все окна.
   Рис. 3.16. Новое меню File.
   В первоначальной версии меню File не было пункта Close (закрыть), поскольку он выполнял бы ту же функцию, что и пункт меню Exit. Новая функция main() примет следующий вид:
   01 int main(int argc, char *argv[])
   02 {
   03 QApplication app(argc, argv);
   04 MainWindow *mainWin = new MainWindow;
   05 mainWin->show();
   06 return app.exec();
   07 }
   При работе со многими окнами теперь имеет смысл создавать MainWindow оператором new, потому что затем мы можем использовать оператор delete для удаления главного окна после завершения работы с ним с целью экономии памяти.
   Новый слот MainWindow::newFile() будет выглядеть следующим образом:
   01 void MainWindow::newFile()
   02 {
   03 MainWindow *mainWin = new MainWindow;
   04 mainWin->show();
   05 }
   Мы просто создаем новый экземпляр MainWindow. Может показаться странным, что мы нигде не сохраняем указатель на новое окно, но это не составит проблемы, поскольку Qt отслеживает все окна.
   Действия Close и Exit будут задаваться следующим образом:
   01 void MainWindow::createActions()
   02 {
   03 closeAction = new QAction(tr("&Close"), this);
   04 closeAction->setShortcut(tr("Ctrl+W"));
   05 closeAction->setStatusTip(tr("Close this window"));
   06 connect(closeAction, SIGNAL(triggered()), this, SLOT(close()));
   07 exitAction = new QAction(tr("E&xit"), this);
   08 exitAction->setShortcut(tr("Ctrl+Q"));
   09 exitAction->setStatusTip(tr("Exit the application"));
   10 connect(exitAction, SIGNAL(triggered()),
   11 qApp, SLOT(closeAllWindows()));
   12 }
   Слот closeAllWindows() объекта QApplication закрывает все окна приложения, если только никакое из них не отклоняет запрос (event) на его закрытие. Именно такой режим работы нам здесь нужен. Нам не надо беспокоиться о несохраненных изменениях, поскольку обработка этого события выполняется функцией MainWindow::closeEvent() при каждом закрытии окна.
   Можно подумать, что на этом завершается построение приложения, работающего со многими документами. К сожалению, одна проблема оказалась незамеченной. Если пользователь будет постоянно создавать и закрывать главные окна, в конце концов может не хватить памяти компьютера. Это происходит из-за того, что мы создаем виджеты MainWindow в функции newFile(), но никогда не удаляем их. Когда пользователь закрывает главное окно, оно исчезает с экрана, но по-прежнему остается в памяти. При создании многих окон может возникнуть проблема.
   Решение состоит в установке признака Qt::WA_DeleteOnClose в конструкторе:
   01 MainWindow::MainWindow()
   02 {
   03 setAttribute(Qt::WA_DeleteOnClose);
   04 }
   Это указывает Qt на необходимость удаления окна при его закрытии. Кроме Qt::WA_DeleteOnClose в конструкторе QWidget можно устанавливать много других флажков, задавая необходимый режим работы виджета.
   Утечка памяти — не единственная проблема, с которой мы можем столкнуться. В нашем первоначальном проекте приложения подразумевалось, что у нас будет только одно главное окно. При работе со многими окнами каждое главное окно будет иметь свой список файлов, открывавшихся последними, и свои параметры работы. Очевидно, что список последних открывавшихся файлов должен относиться ко всему приложению. Это можно обеспечить очень просто путем объявления статической переменной recentFiles, и тогда во всем приложении будет только один ее экземпляр. Но здесь мы должны обеспечить при каждом вызове функции updateRecentFileActions() для обновления меню File вызов ее для всех главных окон. Это выполняет следующий программный код:
   foreach (QWidget *win, QApplication::topLevelWidgets()) {
    if (MainWindow *mainWin = qobject_cast<MainWindow *>(win))
    mainWin->updateRecentFileActions();
   }
   Здесь используется конструкция Qt foreach (она рассматривается в главе 11) для прохода по всем имеющимся в приложении виджетам и делается вызов функции updateRecentFileItems() для всех виджетов типа MainWindow. Аналогичным образом можно синхронизировать установку опций ShowGrid и Auto—Recalculate или убедиться в том, что не загружены два файла с одинаковым именем.
   Рис. 3.17. Однодокументный и многодокументный интерфейсы.
   Приложения, обеспечивающие работу с одним документом в главном окне, называются приложениями с однодокументным интерфейсом (SDI — single document interface). Распространенной альтернативой ему в Windows стал многодокументный интерфейс (MDI — multiple document interface), когда приложение имеет одно главное окно, в центральной области которого могут находиться окна многих документов. С помощью средств разработки Qt можно создавать как приложения SDI, так и приложения MDI на всех поддерживаемых платформах. На рис. 3.17 показан вид приложения Электронная таблица при использовании обоих подходов. Интерфейс MDI рассматривается в главе 6 («Управление компоновкой»).

   Многие приложения при запуске выводят на экран заставки. Некоторыми разработчиками заставки используются, чтобы сделать менее заметным медленный запуск приложения, а в других случаях это делается для удовлетворения требований отделений, отвечающих за маркетинг. Можно очень просто добавить заставку в приложение Qt, используя класс QSplashScreen.
   Класс QSplashScreen выводит на экран изображение до появления главного окна. Он также может вывести на изображение сообщение, информирующее пользователя о ходе процесса инициализации приложения. Обычно вызов заставки делается в функции main() до вызова функции QApplication::exec().
   Ниже приводится пример функции main(), которая использует QSplashScreen для вывода заставки приложения, которое загружает модули и устанавливает сетевые соединения при запуске.
   01 int main(int argc, char *argv[])
   02 {
   03 QApplication app(argc, argv);
   04 QSplashScreen *splash = new QSplashScreen;
   05 splash->setPixmap(QPixmap(":/images/splash.png"));
   06 splash->show();
   07 Qt::Alignment topRight = Qt::AlignRight | Qt::AlignTop;
   08 splash->showMessage(QObject::tr("Setting up the main window…"),
   09 topRight, Qt::white);
   10 MainWindow mainWin;
   11 splash->showMessage(QObject::tr("Loading modules…"),
   12 topRight, Qt::white);
   13 loadModules();
   14 splash->showMessage(QObject::tr("Establishing connections…"),
   15 topRight, Qt::white);
   16 establishConnections();
   17 mainWin.show();
   18 splash->finish(&mainWin);
   19 delete splash;
   20 return app.exec();
   21 }
   Рис. 3.18. Экранная заставка.
   Теперь мы завершили пользовательский интерфейс приложения Электронная таблица. В следующей главе мы реализуем базовые функции электронной таблицы и на этом завершим построение этого приложения.

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

   Центральную область QMainWindow может занимать любой виджет. Ниже дается краткий обзор возможных вариантов.
   1. Стандартный виджет Qt
   В качестве центрального могут использоваться стандартные виджеты, например QTableWidget или QTextEdit. В данном случае такие функции, как загрузка и сохранение файлов, должны быть реализованы в другом месте (например, в подклассе QMainWindow).
   2. Пользовательский виджет
   В специализированных приложениях часто требуется показывать данные в пользовательском виджете. Например, программа редактирования пиктограмм могла бы в качестве центрального использовать виджет IconEditor. В главе 5 рассматриваются способы написания пользовательских виджетов с помощью средств разработки Qt.
   3. Базовый виджет QWidget с менеджером компоновки
   Иногда в центральной области приложения размещается много виджетов. Это можно сделать путем применения QWidget в качестве родительского виджета по отношению ко всем другим виджетам и использовать менеджеры компоновки для задания дочерним виджетам их размера и положения.
   4. Разделитель
   Другой способ размещения в центральной области нескольких виджетов заключается в применении разделителя QSplitter. QSplitter размещает свои дочерние виджеты по горизонтали или по вертикали и предоставляет пользователю некоторые возможности по управлению размерами виджетов. Разделители могут содержать любые виджеты, включая другие разделители.
   5. Рабочая область (workspace) интерфейса MDI
   Если в приложении используется интерфейс MDI, центральную область будет занимать виджет QWorkspace, а каждое окно интерфейса MDI будет являться дочерним виджетом.
   Менеджеры компоновки, разделители и рабочие области MDI могут использоваться совместно со стандартными виджетами Qt или с пользовательскими виджетами. В главе 6 подробно рассматриваются эти классы.
   В приложении Электронная таблица в качестве центрального виджета применяется некоторый подкласс класса QTableWidget. Класс QTableWidget уже обеспечивает большинство необходимых нам функций электронной таблицы, но он не может понимать формулы электронной таблицы вида «=Al+A2+A3» и не поддерживает операции с буфером обмена. Мы реализуем эти недостающие функции в классе Spreadsheet, который наследует QTableWidget.

Хранение данных в объектах типа «элемент»

   Теперь мы реализуем загрузку и сохранение файла данных для приложения Электронная таблица, используя двоичный пользовательский формат. Для этого мы используем объекты QFile и QDataStream, которые совместно обеспечивают независимый от платформы ввод—вывод в двоичном формате.
   Мы начнем с записи файла данных Электронная таблица:
   01 bool Spreadsheet::writeFile(const QString &fileName)
   02 {
   03 QFile file(fileName);
   04 if (!file.open(QIODevice::WriteOnly)) {
   05 QMessageBox::warning(this, tr("Spreadsheet"),
   06 tr("Cannot write file %1:\n%2.")
   07 .arg(file.fileName())
   08 .arg(file.errorString()));
   09 return false;
   10 }
 
   11 QDataStream out(&file);
   12 out.setVersion(QDataStream::Qt_4_1);
   13 out << quint32(MagicNumber);
   14 QApplication::setOverrideCursor(Qt::WaitCursor);
 
   15 for (int row = 0; row < RowCount; ++row) {
   16 for (int column = 0; column < ColumnCount; ++column) {
   17 QString str = formula(row, column);
   18 if (!str.isEmpty())
   19 out << quint16(row) << quint16(column) << str;
   20 }
   21 }
 
   22 QApplication::restoreOverrideCursor();
   23 return true;
   24 }
   Функция writeFile() вызывается из MainWindow::saveFile() для записи файла на диск. Она возвращает true при успешном завершении и false при ошибке.
   Мы создаем объект QFile, задавая имя файла, и вызываем функцию open() для открытия файла для записи данных. Мы также создаем объект QDataStream, который предназначен для работы с QFile и использует его для записи данных.
   Непосредственно перед записью данных мы изменяем курсор приложения на стандартный курсор ожидания (обычно он имеет вид песочных часов) и затем восстанавливаем нормальный курсор после окончания записи данных. В конце функции файл автоматически закрывается деструктором QFile.
   QDataStream поддерживает основные типы С++ совместно со многими типами Qt. Их синтаксис напоминает синтаксис классов <iostream> стандартного С++. Например,
   out << x << у << z;
   выполняет запись в поток значений переменных x, у и z, а
   in >> x >> у >> z;
   считывает их из потока. Поскольку базовые типы С++, такие как char, short, int, long и long long, на различных платформах могут иметь различный размер, надежнее преобразовать их типы в qint8, quint8, qint16, quint16, qint32, quint32, qint64 и quint64, что гарантирует использование объявленного в них размера (в битах).
   Файл данных Электронная таблица имеет очень простой формат. Он начинается с 32-битового числа, идентифицирующего формат файла («волшебное» число MagicNumber определено в spreadsheet.h как 0x7F51C883 — произвольное случайное число). Затем идет последовательность блоков, каждый из которых содержит строку, столбец и формулу одной ячейки. Для экономии места мы не заполняем пустые ячейки.
   Рис. 4.3. Формат файла данных для приложения Электронная таблица.
   Точное представление типов данных определяется в QDataStream. Например, quint16 представляется двумя байтами со старшим байтом в конце, a QString задается длиной строки, за которой следуют символы в коде Unicode.
   Двоичное представление типов в Qt достаточно сильно усовершенствовалось со времени выхода версии Qt 1.0. Такая тенденция, вероятно, сохранится в будущих версиях Qt, чтобы идти вровень с развитием существующих типов и обеспечить новые типы в Qt. По умолчанию класс QDataStream использует самую последнюю версию двоичного формата (версия 7 в Qt 4.1), но он также может быть настроен на чтение прошлых версий. Для того чтобы избежать проблем совместимости при перекомпиляции приложения в будущем, в новой версии Qt мы заставляем QDataStream использовать версию 7 вне зависимости от версии Qt, в которой оно компилируется. (Для удобства используется константа QDataStream::Qt_4_1, равная 7.)
   Класс QDataStream достаточно универсален. Он может использоваться для объекта QFile, но также и для QBuffer, QProcess, QTcpSocket или QUdpSocket. Qt также предоставляет класс QTextStream, который может использоваться с QDataStream для чтения и записи текстовых файлов. В главе 10 подробно рассматриваются эти классы и описываются различные методы работы с разными версиями QDataStream.
   01 bool Spreadsheet::readFile(const QString &fileName)
   02 {
   03 QFile file(fileName);
   04 if (!file.open(QIODevice::ReadOnly)) {
   05 QMessageBox::warning(this, tr("Spreadsheet"),
   06 tr("Cannot read file %1:\n%2.")
   07 .arg(file.fileName())
   08 .arg(file.errorString()));
   09 return false;
   10 }
 
   11 QDataStream in(&file);
   12 in.setVersion(QDataStream::Qt_4_1);
   13 quint32 magic;
   14 in >> magic;
   15 if (magic != MagicNumber) {
   16 QMessageBox::warning(this, tr("Spreadsheet"),
   17 tr("The file is not a Spreadsheet file."));
   18 return false;
   19 }
 
   20 clear();
   21 quint16 row;
   22 quint16 column;
   23 QString str;
   24 QApplication::setOverrideCursor(Qt::WaitCursor);
   25 while (!in.atEnd()) {
   26 in >> row >> column >> str;
   27 setFormula(row, column, str);
   28 }
   29 QApplication::restoreOverrideCursor();
   30 return true;
   31 }
   Функция readFile() очень напоминает writeFile(). Для чтения файла мы пользуемся объектом QFile, но теперь мы используем флажок QIODevice::ReadOnly, а не QIODevice::WriteOnly. Затем мы устанавливаем версию QDataStream на значение 7. Формат чтения всегда должен совпадать с форматом записи.
   Если в начале файла содержится правильное «волшебное» число, мы вызываем функцию clear() для очистки в электронной таблице всех ячеек и затем считываем данные ячеек. Поскольку файл содержит только данные для непустых ячеек, маловероятно, что будет заполнена каждая ячейка электронной таблицы, поэтому мы должны очистить все ячейки перед чтением файла.

   Теперь мы готовы приступить к реализации слотов, относящихся к меню Edit данного приложения.
   Рис. 4.4. Меню Edit приложения Электронная таблица.
   01 void Spreadsheet::cut()
   02 {
   03 copy();
   04 del();
   05 }
   Слот cut() соответствует пункту меню Edit | Cut (Правка | Вырезать). Он реализуется просто, поскольку операция Cut выполняется с помощью операции Сору, за которой следует операция Delete.
   01 void Spreadsheet::copy()
   02 {
   03 QTableWidgetSelectionRange range = selectedRange();
   04 QString str;
   05 for (int i = 0; i < range.rowCount(); ++i) {
   06 if (i > 0)
   07 str += "\n";
   08 for (int j = 0; j < range.columnCount(); ++j) {
   09 if (j > 0)
   10 str += "\t";
   11 str += formula(range.topRow() + i, range.leftColumn() + j);
   12 }
   13 }
   14 QApplication::clipboard()->setText(str);
   15 }
   Слот copy() соответствует пункту меню Edit | Copy (Правка | Копировать). Он в цикле обрабатывает всю выделенную область ячеек (если нет явно выделенной области, то ею будет просто текущая ячейка). Формула каждой выделенной ячейки добавляется в QString, причем строки отделяются символом новой строки, а столбцы разделяются символом табуляции.
   Доступ к буферу обмена в Qt осуществляется при помощи статической функции QApplication::clipboard(). Вызывая функцию QClipboard::setText(), мы делаем текст доступным через буфер обмена; причем этот текст могут использовать и данное, и другие приложения, поддерживающие работу с простыми текстами. Применяемый нами формат со знаками табуляции и новой строки в качестве разделителей понятен многим приложениям, включая Excel от компании Microsoft.
   Рис. 4.5. Копирование выделенных ячеек в буфер обмена.
   Функция QTableWidget::selectedRange() возвращает список выделенных диапазонов. Мы знаем, что может быть не более одного диапазона, потому что мы задали в конструкторе режим выделения QAbstractItemView::ContiguousSelection. Для удобства мы определяем функцию selectedRange(), которая возвращает выделенный диапазон:
   01 QTableWidgetSelectionRange Spreadsheet::selectedRange() const
   02 {
   03 QList<QTableWidgetSelectionRange> ranges = selectedRanges();
   04 if (ranges.isEmpty())
   05 return QTableWidgetSelectionRange();
   06 return ranges.first();
   07 }
   Если выделение вообще имеет место, мы возвращаем первую (и единственную) выделенную область. Мы никогда не встретимся с ситуацией, когда не выбрано никакой области, поскольку в режиме ContiguousSelection текущая ячейка рассматривается как выделенная. Однако такую ситуацию мы все же обрабатываем, чтобы защититься от ошибки в нашей программе, приводящей к отсутствию текущей ячейки.
   01 void Spreadsheet::paste()
   02 {
   03 QTableWidgetSelectionRange range = selectedRange();
   04 QString str = QApplication::clipboard()->text();
   05 QStringList rows = str.split('\n');
   06 int numRows = rows.count();
   07 int numColumns = rows.first().count('\t') + 1;
 
   08 if (range.rowCount() * range.columnCount() != 1
   09 && (range.rowCount() != numRows
   10 || range.columnCount() !=numColumns)) {
   11 QMessageBox::information(this, tr("Spreadsheet"),
   12 tr("The information cannot be pasted because the copy "
   13 "and paste areas aren't the same size."));
   14 return;
   15 }
 
   16 for (int i = 0; i < numRows; ++i) {
   17 QStringList columns = rows[i].split('\t');
   18 for (int j = 0; j < numColumns; ++j) {
   19 int row = range.topRow() + i;
   20 int column = range.leftColumn() + j;
   21 if (row < RowCount && column < ColumnCount)
   22 setFormula(row, column, columns[j]);
   23 }
   24 }
   25 somethingChanged();
   26 }
   Слот paste() соответствует пункту меню Edit | Paste (Правка | Вставить). Мы считываем текст из буфера обмена и вызываем статическую функцию QString::split() для разбиения строки и представления ее в виде списка QStringList. Каждая строка таблицы представлена в этом списке одной строкой.
   Затем мы определяем размеры области копирования. Номер строки в таблице является номером строки в QStringList; номер столбца является номером символа табуляции в первой строке плюс 1. Если выделена только одна ячейка, мы используем ее в качестве верхнего левого угла области вставки; в противном случае мы используем текущую выделенную область для вставки.
   При выполнении операции вставки мы в цикле проходим по строкам и разбиваем каждую строку на значения ячеек, снова используя функцию QString::split(), но теперь в качестве разделителя применяется знак табуляции. Рис. 4.6 иллюстрирует эти действия.
   Рис. 4.6. Вставка текста из буфера обмена в электронную таблицу.
   01 void Spreadsheet::del()
   02 {
   03 foreach (QTableWidgetltem *item, selectedItems())
   04 delete item;
   05 }
   Слот del() соответствует пункту меню Edit | Delete (Правка | Удалить). Для очистки ячеек достаточно использовать оператор delete для каждого объекта Cell. Объект QTableWidget замечает, когда удаляются его элементы QTableWidgetltem, и автоматически перерисовывает себя, если какой-нибудь из элементов оказывается видимым. Если мы вызываем функцию cell(), указывая координаты удаленной ячейки, то она возвратит нулевой указатель.
   01 void Spreadsheet::selectCurrentRow()
   02 {
   03 selectRow(currentRow());
   04 }
   05 void Spreadsheet::selectCurrentColumn()
   06 {
   07 selectColumn(currentColumn());
   08 }
   Функции selectCurrentRow() и selectCurrentColumn() соответствуют пунктам меню Edit | Select | Row и Edit | Select | Column (Правка | Выделить | Строка и Правка | Выделить | Столбец). Здесь используется реализация функций selectRow() и selectColumn() класса QTableWidget. Нам не требуется реализовывать функциональность пункта меню Edit | Select | All (Правка | Выделить | Все), поскольку она обеспечивается в QTableWidget унаследованной функцией QAbstractItemView::selectAll().
   01 void Spreadsheet::findNext(const QString &str, Qt::CaseSensitivity cs)
   02 {
   03 int row = currentRow();
   04 int column = currentColumn() + 1;
   05 while (row < RowCount) {
   06 while (column < ColumnCount) {
   07 if (text(row, column).contains(str, cs)) {
   08 clearSelection();
   09 setCurrentCell(row, column);
   10 activateWindow();
   11 return;
   12 }
   13 ++column;
   14 }
   15 column = 0;
   16 ++row;
   17 }
   18 QApplication::beep();
   19 }
   Слот findNext() в цикле просматривает ячейки, начиная с ячейки, расположенной правее курсора, и двигается вправо до достижения последнего столбца; затем процесс идет с первого столбца строки, расположенной ниже, и так продолжается, пока не будет найден требуемый текст или пока не будет достигнута самая последняя ячейка. Например, если текущей является ячейка C24, поиск будет продолжаться по ячейкам D24, E24, … Z24, затем no A25, B25, C25, … Z25 и так далее, пока не будет достигнута ячейка Z999. Если соответствующее значение найдено, мы сбрасываем текущее выделение и перемещаем курсор на ячейку, в которой оно находится, и делаем активным окно, содержащее эту электронную таблицу Spreadsheet. При неудачном завершении поиска мы заставляем приложение выдать соответствующий звуковой сигнал.
   01 void Spreadsheet::findPrevious(const QString &str, Qt::CaseSensitivity cs)
   02 {
   03 int row = currentRow();
   04 int column = currentColumn() - 1;
   05 while (row>= 0) {
   06 while (column >= 0) {
   07 if (text(row, column).contains(str, cs)) {
   08 clearSelection();
   09 setCurrentCell(row, column);
   10 activateWindow();
   11 return;
   12 }
   13 --column;
   14 }
   15 column = ColumnCount - 1;
   16 --row;
   17 }
   18 QApplication::beep();
   19 }
   Слот findPrevious() похож на findNext(), но здесь цикл выполняется в обратном направлении и заканчивается в ячейке A1.

   Теперь мы реализуем слоты для пунктов меню Tools и Options.
   Рис. 4.7. Меню Tools и Options приложения Электронная таблица.
   01 void Spreadsheet::recalculate()
   02 {
   03 for (int row = 0; row < RowCount; ++row) {
   04 for (int column = 0; column < ColumnCount; ++column) {
   05 if (cell(row, column))
   06 cell(row, column)->setDirty();
   07 }
   08 }
   09 viewport()->update();
   10 }
   Слот recalculate() соответствует пункту меню Tools | Recalculate (Инструменты | Пересчитать). Он также вызывается в Spreadsheet автоматически по мере необходимости.
   Мы выполняем цикл по всем ячейкам и вызываем функцию setDirty(), которая помечает каждую из них для перерасчета значения. В следующий раз, когда QTableWidget для получения отображаемого в электронной таблице значения вызовет text() для некоторой ячейки Cell, значение этой ячейки будет пересчитано.
   Затем мы вызываем для области отображения функцию update() для перерисовки всей электронной таблицы. При этом используемый в QTableWidget программный код по перерисовке вызывает функцию text() для каждой видимой ячейки для получения отображаемого значения. Поскольку функция setDirty() вызывалась нами для каждой ячейки, в вызовах text() будет использовано новое рассчитанное значение. В этом случае может потребоваться расчет невидимых ячеек, который будет проводиться до тех пор, пока не будут рассчитаны все ячейки, влияющие на правильное отображение текста в перерассчитанной области отображения. Этот расчет выполняется в классе Cell.
   01 void Spreadsheet::setAutoRecalculate(bool recalc)
   02 {
   03 autoRecalc = recalc;
   04 if (autoRecalc)
   05 recalculate();
   06 }
   Слот setAutoRecalculate() соответствует пункту меню Options | Auto—Recalculate. Если эта опция включена, мы сразу же пересчитаем всю электронную таблицу и будем уверены, что она показывает обновленные значения; впоследствии функция recalculate() будет автоматически вызываться из somethingChanged().
   Нам не нужно реализовывать специальную функцию для пункта меню Options | Show Grid, поскольку в QTableWidget уже содержится слот setShowGrid(), который наследуется от базового класса QTableView. Остается только реализовать функцию Spreadsheet::sort(), которая вызывается из MainWindow::sort():
   01 void Spreadsheet::sort(const SpreadsheetCompare &compare)
   02 {
   03 QList<QStringList> rows;
   04 QTableWidgetSelectionRange range = selectedRange();
   05 int i;
   06 for (i = 0; i < range.rowCount(); ++i) {
   07 QStringList row;
   08 for (int j = 0; j < range.columnCount(); ++j)
   09 row.append(formula(range.topRow() + i,
   10 range.leftColumn() + j));
   11 rows.append(row);
   12 }
 
   13 qStableSort(rows.begin(), rows.end(), compare);
   14 for (i = 0; i < range.rowCount(); ++i) {
   15 for (int j = 0; j < range.columnCount(); ++j)
   16 setFormula(range.topRow() + i, range.leftColumn() + j, rows[i][j]);
   17 }
 
   18 clearSelection();
   19 somethingChanged();
   20 }
   Сортировка работает на текущей выделенной области и переупорядочивает строки в соответствии со значениями ключей порядка сортировки, хранящимися в объекте compare. Мы представляем каждую строку данных в QStringList, а выделенную область храним в виде списка строк. Мы используем алгоритм Qt qStableSort() и для простоты сортируем по выражениям формул, а не по их значениям. Стандартные алгоритмы и структуры данных Qt рассматривается в главе 11 («Классы—контейнеры»).
   Рис. 4.8. Хранение выделенной области в виде списка строк.
   В качестве аргументов функции qStableSort() используются итератор начала, итератор конца и функция сравнения. Функция сравнения имеет два аргумента (оба имеют тип QStringLists), и она возвращает true, когда первый аргумент «больше, чем» второй аргумент, и false в противном случае. Передаваемый как функция сравнения объект compare фактически не является функцией, но он может использоваться и в таком качестве, в чем мы вскоре сможем убедиться.
   Рис. 4.9. Помещение данных в таблицу после сортировки.
   После выполнения функции qStableSort() мы помещаем данные обратно в таблицу, сбрасываем выделение области и вызываем функцию somethingChanged(). Класс SpreadsheetCompare в spreadsheet.h определен следующим образом:
   01 class SpreadsheetCompare
   02 {
   03 public:
   04 bool operator()(const QStringList &row1,
   05 const QStringList &row2) const;
   06 enum { KeyCount = 3 };
   07 int keys[KeyCount];
   08 bool ascending[KeyCount];
   09 };
   Класс SpreadsheetCompare является специальным классом, реализующим оператор (). Это позволяет нам применять этот класс в качестве функции. Такие классы называются объектами функций или функторами (functors).
   Для лучшего понимания работы функторов мы сначала разберем простой пример:
   01 class Square
   02 {
   03 public:
   04 int operator()(int x) const { return x * x; }
   05 }
   Класс Square содержит одну функцию operator()(int), которая возвращает квадрат переданного ей значения параметра. Обозначая функцию в виде operator()(int), а не в виде, например, compute(int), мы получаем возможность применения объекта типа Square как функции:
   Square square;
   int у = square(5);
   Теперь рассмотрим пример с применением объекта SpreadsheetCompare:
   QStringList row1, row2;
   QSpreadsheetCompare compare;
   …
   if (compare(row1, row2)) {
    // строка row1 меньше, чем row2
   }
   Объект compare можно использовать так же, как если бы он был обычной функцией compare(). Кроме того, он может быть реализован таким образом, что будет осуществлять доступ ко всем ключам сортировки и всем признакам порядка сортировки, которые хранятся в переменных—членах класса.
   Можно использовать другой подход, когда ключи сортировки и признаки порядка сортировки хранятся в глобальных переменных и используется функция обычного типа compare(). Однако связь через глобальные переменные выглядит неизящно и может быть причиной тонких ошибок. Функторы представляют собой более мощное средство связи для таких функций—шаблонов, как qStableSort().
   Ниже приводится реализация функции, которая применяется для сравнения двух строк электронной таблицы:
   01 bool SpreadsheetCompare::operator()(const QStringList &row1,
   02 const QStringList &row2) const
   03 {
   04 for (int i = 0; i < KeyCount; ++i) {
   05 int column = keys[i];
   06 if (column != -1) {
   07 if (row1[column] != row2[column]) {
   08 if (ascending[i]) {
   09 return row1[column] < row2[column];
   10 } else {
   11 return row1[column] > row2[column];
   12 }
   13 }
   14 }
   15 }
   16 return false;
   17 }
   Этот оператор возвращает true, если первая строка меньше второй; в противном случае он возвращает false. Функция qStableSort() для выполнения сортировки использует результат этой функции.
   Массивы keys и ascending объекта SpreadsheetCompare заполняются при работе функции MainWindow::sort() (она приводится в главе 2). Каждый ключ содержит индекс столбца или имеет значение —1 («None» — нет значения).
   Мы сравниваем значения соответствующих ячеек двух строк, учитывая порядок ключей сортировки. Как только оказывается, что они различны, мы возвращаем соответствующее значение: true или false. Если все значения оказываются равными, мы возвращаем false. При совпадении значений функция qStableSort() сохраняет порядок до сортировки; если строка row1 располагалась первоначально перед строкой row2 и ни одна из них не оказалась «меньше другой», то в результате строка row1 по-прежнему будет предшествовать строке row2. Именно этим функция qStableSort() отличается от своего нестабильного «родственника» qSort().
   Теперь мы закончили класс Spreadsheet. В следующем разделе мы рассмотрим класс Cell. Этот класс применяется для хранения формул ячеек и обеспечивает переопределение функции QTableWidgetltem::data(), которая вызывается в Spreadsheet через функцию QTableWidgetItem::text() для отображения результата вычисления формулы ячейки.

   Класс Cell наследует QTableWidgetltem. Этот класс спроектирован для удобства работы с Spreadsheet, но он не имеет никаких особых связей с данным классом электронной таблицы и теоретически может применяться для любого объекта QTableWidget. Ниже приводится заголовочный файл:
   01 #ifndef CELL_H
   02 #define CELL_H
   03 #include <QTableWidgetItem>
 
   04 class Cell : public QTableWidgetltem
   05 {
   06 public:
   07 Cell();
   08 QTableWidgetltem *clone() const;
   09 void setData(int role, const QVariant &value);
   10 QVariant data(int role) const;
   11 void setFormula(const QString &formula);
   12 QString formula() const;
   13 void setDirty();
 
   14 private:
   15 QVariant value() const;
   16 QVariant evalExpression(const QString &str, int &pos) const;
   17 QVariant evalTerm(const QString &str, int &pos) const;
   18 QVariant evalFactor(const QString &str, int &pos) const;
   19 mutable QVariant cachedValue;
   20 mutable bool cacheIsDirty;
   21 };
   22 #endif
   Класс Cell расширяет QTableWidgetltem, добавляя две закрытые переменные:
   • переменная cachedValue кэширует значение ячейки в виде значения типа QVariant;
   • переменная cacheIsDirty принимает значение true, если кэшируемое значение устарело.
   Мы используем QVariant, поскольку некоторые ячейки имеют тип числа двойной точности double, а другие имеют тип строки QString.
   При объявлении переменных cachedValue и cacheIsDirty используется ключевое слово mutable языка С++. Это позволяет нам модифицировать эти переменные в функциях с модификатором const. Мы могли бы поступить по-другому и заново выполнять расчет при каждом вызове функции text(), но эта неэффективность будет не оправдана.
   Следует отметить, что в определении класса не используется макрос Q_OBJECT. Класс Cell является «чистым» классом С++, который не имеет сигналов и слотов. На самом деле из-за того, что QTableWidgetltem не является наследником QObject, мы не можем использовать в Cell как таковые сигналы и слоты. Классы элементов Qt не наследуют QObject, чтобы свести к минимуму затраты на их обработку. Если сигналы и слоты необходимы, они могут быть реализованы в виджете, содержащем элементы, или (в виде исключения) при помощи множественного наследования класса QObject.
   Теперь мы перейдем к написанию cell.cpp:
   01 #include <QtGui>
   02 #include "cell.h"
   03 Cell::Cell()
   04 {
   05 setDirty();
   06 }
   В конструкторе нам необходимо установить признак «dirty» («грязный») только для кэша. Передавать родительский объект нет необходимости; когда делается вставка ячейки в QTableWidget с помощью setItem(), QTableWidget автоматически станет ее владельцем.
   Каждый элемент QTableWidgetltem может иметь некоторые данные — до одного типа QVariant на каждую «роль» данных. Наиболее распространенными ролями являются Qt::EditRole и Qt::DisplayRole (роль правки и роль отображения). Роль правки используется для данных, которые должны редактироваться, а роль отображения — для данных, которые должны отображаться на экране. Часто обе роли используются для одних и тех же данных, однако в Cell роль правки соответствует формуле ячейки, а роль отображения — значению ячейки (результату вычисления формулы).
   02 QTableWidgetltem *Cell::clone() const
   03 {
   04 return new Cell(*this);
   05 }
   Функция clone() вызывается в QTableWidget, когда необходимо создать новую ячейку, например когда пользователь начинает вводить данные в пустую ячейку, которая до сих пор не использовалась. Переданный функции QTableWidget::setItemPrototype() экземпляр является дубликатом. Поскольку для копирования Cell можно ограничиться функцией—членом, мы полагаемся на используемый по умолчанию конструктор копирования, автоматически создаваемый С++ при создании экземпляров новых ячеек Cell в функции clone().
   06 void Cell::setFormula(const QString &formula)
   07 {
   08 setData(Qt::EditRole, formula);
   09 }
   Функция setFormula() задает формулу ячейки. Это просто удобная функция для вызова setData() с указанием роли правки. Она вызывается из функции Spreadsheet::setFormula().
   10 QString Cell::formula() const
   11 {
   12 return data(Qt::EditRole).toString();
   13 }
   Функция formula() вызывается из Spreadsheet::formula(). Подобно setFormula() этой функцией удобно пользоваться на этот раз для получения данных EditRole заданного элемента.
   14 void Cell::setData(int role, const QVariant &value)
   15 {
   16 QTableWidgetltem::setData(role, value);
   17 if (role == Qt::EditRole)
   18 setDirty();
   19 }
   Если мы имеем новую формулу, мы устанавливаем cacheIsDirty на значение true, чтобы обеспечить перерасчет ячейки при последующем вызове text().
   В Cell нет определения функции text(), хотя мы и вызываем text() для экземпляров Cell в функции Spreadsheet::text(). QTableWidgetltem содержит удобную функцию text(), которая эквивалентна вызову data(Qt::DisplayRole).toString().
   20 void Cell::setDirty()
   21 {
   22 cacheIsDirty = true;
   23 }
   Функция setDirty() вызывается для принудительного перерасчета значения ячейки. Она просто устанавливает флажок cacheIsDirty на значение true, указывая на то, что значение cachedValue больше не отражает текущее состояние. Перерасчет не будет выполняться до тех пор, пока он не станет действительно необходим.
   24 QVariant Cell::data(int role) const
   25 {
   26 if (role == Qt::DisplayRole) {
   27 if (value().isValid()) {
   28 return value().toString();
   29 } else {
   30 return "####";
   31 }
   32 } else if (role == Qt::TextAlignmentRole) {
   33 if (value().type() == QVariant::String) {
   34 return int(Qt::AlignLeft | Qt::AlignVCenter);
   35 } else {
   36 return int(Qt::AlignRight | Qt::AlignVCenter);
   37 }
   38 } else {
   39 return QTableWidgetltem::data(role);
   40 }
   41 }
   Функция data() класса QTableWidgetltem переопределяется. Она возвращает текст, который должен отображаться в электронной таблице, если в вызове указана роль Qt::DisplayRole, или формулу, если в вызове указана роль Qt::EditRole. Она обеспечивает подходящее выравнивание, если вызывается с ролью Qt::TextAlignmentRole. При задании роли DisplayRole она использует функцию value() для расчета значения ячейки. Если нельзя получить достоверное значение (из-за того, что формула неверна), мы возвращаем значение «####».
   Функция Cell::value(), используемая в data(), возвращает значение типа QVariant. Объекты типа QVariant могут содержать значения различных типов, например double или QString, и поддерживают функции для преобразования их в другие типы. Например, при вызове toString() для переменной типа QVariant, содержащей значение типа double, в результате мы получим строковое представление числа с двойной точностью. Используемый по умолчанию конструктор QVariant устанавливает значение «invalid» (недопустимое).
   42 const QVariant Invalid;
 
   43 QVariant Cell::value() const
   44 {
   45 if (cacheIsDirty) {
   46 cacheIsDirty = false;
 
   47 QString formulaStr = formula();
   48 if (formulaStr.startsWith('\'')) {
   49 cachedValue = formulaStr.mid(1);
   50 } else if (formulaStr.startsWith('=')) {
   51 cachedValue = Invalid;
   52 QString expr = formulaStr.mid(1);
   53 expr.replace(" ", "");
   54 expr.append(QChar::Null);
 
   55 int pos = 0;
   56 cachedValue = evalExpression(expr, pos);
   57 if (expr[pos] != QChar::Null)
   58 cachedValue = Invalid;
   59 } else {
   60 bool ok;
   61 double d = formulaStr.toDouble(&ok);
   62 if (ok) {
   63 cachedValue = d;
   64 } else {
   65 cachedValue = formulaStr;
   66 }
   67 }
   68 }
   69 return cachedValue;
   70 }
   Закрытая функция value() возвращает значение ячейки. Если флажок cacheIsDirty имеет значение true, нам необходимо выполнить перерасчет значения.
   Если формула начинается с одиночной кавычки (например, «'12345»), то одиночная кавычка занимает позицию 0, а значение представляет собой строку в позициях с 1 до последней.
   Если формула начинается со знака равенства («=»), мы выделяем строку, начиная с позиции 1, и удаляем из нее любые пробелы. Затем мы вызываем функцию evalExpression() для вычисления значения выражения. Аргумент pos передается по ссылке; он задает позицию символа, с которого должен начинаться синтаксический анализ выражения. После вызова функции evalExpression() в позиции pos нами должен быть установлен символ QChar::Null, если синтаксический анализ завершился успешно. Если синтаксический анализ не закончился успешно, мы устанавливаем cachedValue на значение Invalid.
   Если формула не начинается с одиночной кавычки или знака равенства, мы пытаемся преобразовать ее в число с плавающей точкой, используя функцию toDouble(). Если преобразование удается выполнить, мы устанавливаем cachedValue на полученное значение; в противном случае мы устанавливаем cachedValue на строку формулы. Например, формула «1.50» приводит к тому, что функция toDouble() устанавливает переменную ok на значение true и возвращает 1.5, а формула «World Population» (население Земли) приводит к тому, что функция toDouble() устанавливает переменную ok на значение false и возвращает 0.0.
   Благодаря заданному в функции toDouble() указателю на булево значение мы можем отличать строку преобразования, представляющую числовое значение 0.0, от ошибки преобразования (в последнем случае также возвращается 0.0, но булева переменная устанавливается в значение false). Иногда нулевое значение при неудачном преобразовании оказывается именно тем, что нам нужно; в этом случае нет необходимости передавать указать на переменную типа bool. По причинам, связанным с производительностью и переносимостью, в Qt никогда не используются исключения С++ для вывода сообщений об ошибках. Это не значит, что вы не можете использовать их в своих Qt—программах, если ваш компилятор поддерживает исключения С++.
   Функция value() объявлена с модификатором const. При объявлении переменных cachedValue и cacheIsValid мы использовали ключевое слово mutable, чтобы компилятор позволял нам модифицировать эти переменные в функциях типа const. Может показаться заманчивой возможность сделать функцию value() не типа const и удалить ключевые слова mutable, но это не пропустит компилятор, поскольку мы вызываем value() из data() — функции с модификатором const.
 
   Теперь можно считать, что мы завершили приложение Электронная таблица, если не брать в расчет синтаксический анализ формул. В остальной части данного раздела рассматриваются функция evalExpression() и две вспомогательные функции evalTerm() и evalFactor(). Их программный код немного сложен, но он включен сюда, чтобы приложение имело законченный вид. Поскольку этот программный код не относится к программированию графического интерфейса, вы можете спокойно его пропустить и продолжить чтение с главы 5.
   Функция evalExpression() возвращает значение выражения из ячейки электронной таблицы. Выражение состоит из одного или нескольких термов, разделенных знаками операций «+» или «—». Термы состоят из одного или нескольких факторов (factors), разделенных знаками операций «*» или «/». Разбивая выражения на термы, а термы на факторы, мы обеспечиваем правильную последовательность выполнения операций.
   Например, «2*C5+D6» является выражением, первый терм которого будет «2*C5», а второй терм — «D6». «2*C5» является термом, первый фактор которого будет «2», а второй фактор — «C5»; «D6» состоит из одного фактора — «D6». Фактором могут быть число («2»), обозначение ячейки («C5») или выражение в скобках, перед которым может стоять знак минуса.
   Рис. 4.10. Блок—схема синтаксического анализа выражений электронной таблицы.
   Блок—схема синтаксического анализа выражений электронной таблицы представлена на рис. 4.10. Для каждого грамматического символа (Expression, Term и Factor — выражение, терм и фактор) имеется соответствующая функция—член, которая выполняет его синтаксический анализ и структура которой очень хорошо отражает его грамматику. Построенные таким образом синтаксические анализаторы называются парсерами с рекурсивным спуском (recursive—descent parsers).
   Давайте начнем с evalExpression(), то есть с функции, которая выполняет синтаксический разбор выражения:
   01 QVariant Cell::evalExpression(const QString &str, int &pos) const
   02 {
   03 QVariant result = evalTerm(str, pos);
   04 while (str[pos] != QChar::Null) {
   05 QChar op = str[pos];
   06 if (op != '+' && op != '-') return result;
   07 ++pos;
 
   08 QVariant term = evalTerm(str, pos);
   09 if (result.type() == QVariant::Double
   10 && term.type() == QVariant::Double) {
   11 if (op == '+') {
   12 result = result.toDouble() + term.toDouble();
   13 } else {
   14 result= result.toDouble() - term.toDouble();
   15 }
   16 } else {
   17 result = Invalid;
   18 }
   19 }
   20 return result;
   21 }
   Во-первых, мы вызываем функцию evalTerm() для получения значения первого терма. Если за ним идет символ «+» или «—», мы вызываем второй раз evalTerm(); в противном случае выражение состоит из единственного терма, и мы возвращаем его значение в качестве значения всего выражения. После получения значений первых двух термов мы вычисляем результат операции в зависимости от оператора. Если при оценке обоих термов их значения будут иметь тип double, мы рассчитываем результат в виде числа типа double; в противном случае мы устанавливаем результат на значение Invalid.
   Мы продолжаем эту процедуру, пока не закончатся термы. Это даст правильный результат, потому что операции сложения и вычитания обладают свойством «ассоциативности слева» (left—associative), то есть «1—2—3» означает «(1—2)—3», а не «1—(2—3)».
   01 QVariant Cell::evalTerm(const QString &str, int &pos) const
   02 {
   03 QVariant result = evalFactor(str, pos);
   04 while (str[pos] != QChar::Null) {
   05 QChar op = str[pos];
   06 if (op != '*' && op != '/')
   07 return result;
   08 ++pos;
 
   09 QVariant factor = evalFactor(str, pos);
   10 if (result.type() == QVariant::Double &&
   11 factor.type() == QVariant::Double) {
   12 if (op == '*') {
   13 result = result.toDouble() * factor.toDouble();
   14 } else {
   15 if (factor.toDouble() == 0.0) {
   16 result = Invalid;
   17 } else {
   18 result = result.toDouble() / factor.toDouble();
   19 }
   20 }
   21 } else {
   22 result = Invalid;
   23 }
   24 }
   25 return result;
   26 }
   Функция evalTerm() очень напоминает функцию evalExpression(), но, в отличие от последней, она имеет дело с операциями умножения и деления. В функции evalTerm() необходимо учитывать одну тонкость, а именно: нельзя допускать деления на нуль, так как это приводит к ошибке на некоторых процессорах. Хотя не рекомендуется проверять равенство чисел с плавающей точкой из-за ошибки округления, можно спокойно делать проверку на равенство значению 0.0 для предотвращения деления на нуль.
   01 QVariant Cell::evalFactor(const QString &str, int &pos) const
   02 {
   03 QVariant result;
   04 bool negative = false;
   05 if (str[pos] == '-') {
   06 negative = true;
   07 ++pos;
   08 }
   09 if (str[pos] == '(') {
   10 ++pos;
   11 result = evalExpression(str, pos);
   12 if (str[pos] != ')')
   13 result = Invalid;
   14 ++pos;
   15 } else {
   16 QRegExp regExp("[A-Za-z][1-9][0-9]{0,2}");
   17 QString token;
   18 while (str[pos].isLetterOrNumber() || str[pos] == '.') {
   19 token += str[pos];
   20 ++pos;
   21 }
 
   22 if (regExp.exactMatch(token)) {
   23 int column = token[0].toUpper().unicode() - 'A';
   24 int row = token.mid(1).toInt() - 1;
   25 Cell *c = static_cast<Cell *>(tableWidget()->item(row, column));
   26 if (c) {
   27 result = c->value();
   28 } else {
   29 result = 0.0;
   30 }
   31 } else {
   32 bool ok;
   33 result = token.toDouble(&ok);
   34 if (!ok)
   35 result = Invalid;
   36 }
   37 }
 
   38 if (negative) {
   39 if (result.type() == QVariant::Double) {
   40 result = -result.toDouble();
   41 } else {
   42 result = Invalid;
   43 }
   44 }
   45 return result;
   46 }
   Функция evalFactor() немного сложнее, чем evalExpression() и evalTerm(). Мы начинаем с проверки, не является ли фактор отрицательным. Затем мы проверяем наличие открытой скобки. Если она имеется, мы анализируем значение внутри скобок как выражение, вызывая evalExpression(). При анализе выражения в скобках evalExpression() вызывает функцию evalTerm(), которая вызывает функцию evalFactor(), которая вновь вызывает функцию evalExpression(). Именно в этом месте осуществляется рекурсия при синтаксическом анализе.
   Если фактором не является вложенное выражение, мы выделяем следующую лексему (token), и она должна задавать обозначение ячейки или быть числом. Если эта лексема удовлетворяет регулярному выражению в переменной QRegExp, мы считаем, что она является ссылкой на ячейку, и вызываем функцию value() для этой ячейки. Ячейка может располагаться в любом месте в электронной таблице, и она может ссылаться на другие ячейки. Такая зависимость не вызывает проблемы и просто приводит к дополнительным вызовам функции value() и к дополнительному синтаксическому анализу ячеек с признаком «dirty» («грязный») для перерасчета значений всех зависимых ячеек. Если лексема не является ссылкой на ячейку, мы рассматриваем ее как число.
   Что произойдет, если ячейка A1 содержит формулу «=A1»? Или если ячейка A1 содержит «=A2», а ячейка A2 содержит «=A1»? Хотя нами не написан специальный программный код для обнаружения бесконечных циклов в рекурсивных зависимостях, парсер прекрасно справится с этой ситуацией и возвратит недопустимое значение переменной типа QVariant. Это даст нужный результат, поскольку мы устанавливаем флажок cacheIsDirty на значение false и переменную cachedValue на значение Invalid в функции value() перед вызовом evalExpression(). Если evalExpression() рекурсивно вызывает функцию value() для той же ячейки, она немедленно возвращает значение Invalid, и тогда все выражение принимает значение Invalid.
   Теперь мы завершили программу синтаксического анализа формул. Ее можно легко модифицировать для обработки стандартных функций электронной таблицы, например «sum()» и «avg()», расширяя грамматическое определение фактора. Можно также легко расширить эту реализацию, обеспечив возможность выполнения операции «+» над строковыми операндами (для их конкатенации); это не потребует внесения изменений в грамматику.

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

   В некоторых случаях мы обнаруживаем необходимость в более специализированной настройке виджета Qt по сравнению с той, которую можно обеспечить путем установки его свойств в Qt Designer или с помощью вызова его функций. Простое и прямое решение заключается в создании подкласса соответствующего виджетного класса и адаптации его под наши требования.
   Рис. 5.1. Виджет HexSpinBox.
   Чтобы показать, как это делается, в данном разделе мы разработаем шестнадцатеричный наборный счетчик. Наборный счетчик QSpinBox поддерживает только десятичные целые числа, но путем создания подкласса достаточно легко можно заставить его принимать и отображать шестнадцатеричные значения.
   01 #ifndef HEXSPINBOX_H
   02 #define HEXSPINBOX_H
   03 #include <QSpinBox>
   04 class QRegExpValidator;
 
   05 class HexSpinBox : public QSpinBox
   06 {
   07 Q_OBJECT
   08 public:
   09 HexSpinBox(QWidget *parent = 0);
   10 protected:
   11 QValidator::State validate(QString &text, int &pos) const;
   12 int valueFromText(const QString &text) const;
   13 QString textFromValue(int value) const;
   14 private:
   15 QRegExpValidator *validator;
   16 };
   17 #endif
   Шестнадцатеричный наборный счетчик HexSpinBox наследует большую часть функциональности от QSpinBox. Он содержит обычный конструктор и переопределяет три виртуальные функции класса QSpinBox.
   01 #include <QtGui>
   02 #include "hexspinbox.h"
   03 HexSpinBox::HexSpinBox(QWidget *parent)
   04 : QSpinBox(parent)
   05 {
   06 setRange(0, 255);
   07 validator = new QRegExpValidator(QRegExp("[0-9A-Fa-f]{1,8}"), this);
   08 }
   Мы устанавливаем по умолчанию диапазон от 0 до 255 (от 0x00 до 0xFF), который лучше соответствует шестнадцатеричному наборному счетчику, чем диапазон от 0 до 99, принимаемый по умолчанию в QSpinBox.
   Пользователь может модифицировать текущее значение наборного счетчика, щелкая по верхней или нижней стрелке или вводя значения в строке редактирования наборного счетчика. В последнем случае мы хотим, чтобы пользователь мог вводить только правильные шестнадцатеричные числа. Для достижения этого мы используем QRegExpValidator, который принимает один или несколько символов со значениями каждого символа в диапазонах от «0» до «9», от «А» до «F» или от «а» до «f».
   09 QValidator::State HexSpinBox::validate(QString &text, int &pos) const
   10 {
   11 return validator->validate(text, pos);
   12 }
   Эта функция вызывается в QSpinBox для проверки допустимости введенного текста. Результат может иметь одно из трех значений: Invalid (текст не соответствует регулярному выражению), Intermediate (текст, вероятно, является частью допустимого значения) и Acceptable (текст допустим). QRegExpValidator имеет подходящую функцию validate(), поэтому мы просто возвращаем результат ее вызова. Теоретически следует возвращать Invalid или Intermediate для значений, лежащих вне диапазона наборного счетчика, но QSpinBox достаточно «умен» и может самостоятельно отследить эту ситуацию.
   13 QString HexSpinBox::textFromValue(int value) const
   14 {
   15 return QString::number(value, 16).toUpper();
   16 }
   Функция textFromValue() преобразует целое число в строку. QSpinBox вызывает ее для обновления строки редактирования в наборном счетчике, когда пользователь нажимает клавиши верхней или нижней стрелки наборного счетчика. Мы используем статическую функцию QString::number(), задавая 16 в качестве второго аргумента для преобразования значения в представленное в нижнем регистре шестнадцатеричное число, и вызываем функцию QString::toUpper() для преобразования результата в верхний регистр.
   17 int HexSpinBox::valueFromText(const QString &text) const
   18 {
   19 bool ok;
   20 return text.toInt(&ok, 16);
   21 }
   Функция valueFromText() выполняет обратное преобразование из строки в целое число. Она вызывается в QSpinBox, когда пользователь вводит значение в строку редактирования наборного счетчика и нажимает клавишу Enter. Мы используем функцию QString::toInt() для попытки преобразования текущего текстового значения (возвращаемого QSpinBox::text()) в целое число, вновь используя 16 в качестве базы. Если строка не является правильным шестнадцатеричным числом, ok устанавливается на значение false и toInt() возвращает 0. Здесь нет необходимости рассматривать такую возможность, поскольку контролирующая функция (validator) позволяет вводить только правильные шестнадцатеричные значения. Вместо передачи адреса переменной ok мы могли бы задать нулевой указатель в первом аргументе функции toInt().
   Этим мы завершили создание шестнадцатеричного наборного счетчика. Настройка других виджетов Qt осуществляется по тому же образцу: подобрать подходящий виджет Qt, создать его подкласс и переопределить несколько виртуальных функций для изменения режима его работы.

   Многие пользовательские виджеты являются простой комбинацией существующих виджетов, либо встроенных в Qt, либо других пользовательских виджетов (таких, как HexSpinBox). Если пользовательские виджеты строятся на основе существующих виджетов, то они, как правило, могут разрабатываться в Qt Designer.
   • создайте новую форму, используя шаблон «Widget» (виджет);
   • добавьте в эту форму необходимые виджеты и затем расположите их соответствующим образом;
   • установите соединения сигналов и слотов;
   • если необходима функциональность, которую нельзя обеспечить с помощью механизма сигналов и слотов, необходимый программный код следует писать в рамках класса, который наследует как класс QWidget, так и класс, сгенерированный компилятором uic.
   Естественно, комбинация существующих виджетов может быть также полностью запрограммирована вручную. При любом подходе полученный класс наследует непосредственно QWidget.
   Если виджет не имеет своих собственных сигналов и слотов и не переопределяет никакую виртуальную функцию, можно просто собрать виджет из существующих виджетов, не создавая подкласс. Этим методом мы пользовались в главе 1 для создания приложения Age с применением QWidget, QSpinBox и QSlider. Даже в этом случае мы могли бы легко определить подкласс QWidget и в его конструкторе создать QSpinBox и QSlider.
   Когда под рукой нет подходящих виджетов Qt и когда нельзя получить желаемый результат, комбинируя и адаптируя существующие виджеты, мы можем все же создать требуемый виджет. Это достигается путем создания подкласса QWidget и переопределением обработчиков некоторых событий, связанных с рисованием виджета и реагированием на щелчки мышки. При таком подходе мы свободно можем определять и управлять как внешним видом, так и режимом работы нашего виджета. Такие встроенные в Qt виджеты, как QLabel, QPushButton и QTableWidget, реализованы именно так. Если бы их не было в Qt, все же можно было бы создать их самостоятельно при помощи предусмотренных в классе QWidget открытых функций, обеспечивающих полную независимость от платформы.
   Для демонстрации данного подхода при написании пользовательского виджета мы создадим виджет IconEditor, показанный на рис. 5.2. Виджет IconEditor может использоваться в программе редактирования пиктограмм.
   Рис. 5.2. Виджет IconEditor.
   Сначала рассмотрим заголовочный файл.
   01 #ifndef ICONEDITOR_H
   02 #define ICONEDITOR_H
   03 #include <QColor>
   04 #include <QImage>
   05 #include <QWidget>
 
   06 class IconEditor : public QWidget
   07 {
   08 Q_OBJECT
   09 Q_PROPERTY(QColor penColor READ penColor WRITE setPenColor)
   10 Q_PROPERTY(QImage iconImage READ iconImage WRITE setIconImage)
   11 Q_PROPERTY(int zoomFactor READ zoomFactor WRITE setZoomFactor)
 
   12 public:
   13 IconEditor(QWidget *parent = 0);
   14 void setPenColor(const QColor &newColor);
   15 QColor penColor() const { return curColor; }
   16 void setIconImage(const QImage &newImage);
   17 QImage iconImage() const { return image; }
   18 QSize sizeHint() const;
   19 void setZoomFactor(int newZoom);
   20 int zoomFactor() const { return zoom; }
   Класс IconEditor использует макрос Q_PROPERTY() для объявления трех пользовательских свойств: penColor, iconImage и zoomFactor. Каждое свойство имеет тип данных, функцию «чтения» и необязательную функцию «записи». Например, свойство penColor имеет тип QColor и может считываться и записываться при помощи функций penColor() и setPenColor().
   Когда мы используем виджет в Qt Designer, пользовательские свойства появляются в редакторе свойств Qt Designer ниже свойств, унаследованных от QWidget. Свойства могут иметь любой тип, поддерживаемый QVariant. Макрос Q_OBJECT необходим для классов, в которых определяются свойства.
   21 protected:
   22 void mousePressEvent(QMouseEvent *event);
   23 void mouseMoveEvent(QMouseEvent *event);
   24 void paintEvent(QPaintEvent *event);
 
   25 private:
   26 void setImagePixel(const QPoint &pos, bool opaque);
   27 QRect pixelRect(int i, int j) const;
   28 QColor curColor;
   29 QImage image;
   30 int zoom;
   31 };
   32 #endif
   IconEditor переопределяет три защищенные функции QWidget и имеет несколько закрытых функций и переменных. В трех закрытых переменных содержатся значения трех свойств.
   Файл реализации класса начинается с конструктора IconEditor:
   01 #include <QtGui>
   02 #include "iconeditor.h"
   03 IconEditor::IconEditor(QWidget *parent)
   04 : QWidget(parent)
   05 {
   06 setAttribute(Qt::WA_StaticContents);
   07 setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
   08 curColor = Qt::black;
   09 zoom = 8;
   10 image = QImage(16, 16, QImage::Format_ARGB32);
   11 image.fill(qRgba(0, 0, 0, 0));
   12 }
   В конструкторе имеется несколько тонких моментов, связанных с применением атрибута Qt::WA_StaticContents и вызовом функции setSizePolicy(). Вскоре мы обсудим их.
   Устанавливается черный цвет пера. Коэффициент масштабирования изображения (zoom factor) устанавливается на 8, то есть каждый пиксель пиктограммы представляется квадратом 8 × 8.
   Данные пиктограммы хранятся в переменной—члене image, и доступ к ним может осуществляться при помощи функций setIconImage() и iconImage(). Программа редактирования пиктограмм обычно вызывает функцию setIconImage() при открытии пользователем файла пиктограммы и функцию iconImage() для считывания пиктограммы из памяти, когда пользователь хочет ее сохранить. Переменная image имеет тип QImage. Мы инициализируем ее областью в 16 × 16 пикселей и на 32-битовый формат ARGB, который поддерживает полупрозрачность. Мы очищаем данные изображения, устанавливая признак прозрачности.
   Способ хранения изображения в классе QImage не зависит от оборудования. При этом его глубина может устанавливаться на 1, 8 или 32 бита. Изображения с 32-битовой глубиной используют по 8 бит на красный, зеленый и синий компоненты пикселя. В остальных 8 битах хранится альфа—компонент пикселя (уровень его прозрачности). Например, компоненты красный, зеленый и синий «чистого» красного цвета и альфа—компонент имеют значения 255, 0, 0 и 255. В Qt этот цвет можно задавать так:
   QRgb red = qRgba(255, 0, 0, 255);
   или так (поскольку этот цвет непрозрачен):
   QRgb red = qRgb(255, 0, 0);
   Тип QRgb просто синоним типа unsigned int, созданный с помощью директивы typedef, a qRgb() и qRgba() являются встроенными функциями (то есть со спецификатором inline), которые преобразуют свои аргументы в 32-битовое целое число. Допускается также запись
   QRgb red = 0xFFFF0000;
   где первые FF соответствуют альфа—компоненту, а вторые FF — красному компоненту. В конструкторе класса IconEditor мы делаем QImage прозрачным, используя 0 в качестве значения альфа—компонента.
   В Qt для хранения цветов предусмотрено два типа: QRgb и QColor. В то время как QRgb всего лишь определяется в QImage ключевым словом typedef для представления пикселей 32-битовым значением, QColor является классом, который имеет много полезных функций и широко используется в Qt для хранения цветов. В виджете IconEditor мы используем QRgb только при работе с QImage; мы применяем QColor во всех остальных случаях, включая свойство цвет пера penColor.
   13 QSize IconEditor::sizeHint() const
   14 {
   15 QSize size = zoom * image.size();
   16 if (zoom >= 3)
   17 size += QSize(1, 1);
   18 return size;
   19 }
   Функция sizeHint() класса QWidget переопределяется и возвращает «идеальный» размер виджета. Здесь мы размер изображения умножаем на масштабный коэффициент и в случае, когда масштабный коэффициент равен или больше 3, добавляем еще один пиксель по каждому направлению для размещения сетки. (Мы не показываем сетку при масштабном коэффициенте 1 или 2, поскольку в этом случае едва ли найдется место для пикселей пиктограммы.)
   Идеальный размер виджета играет очень заметную роль при размещении виджетов. Менеджеры компоновки Qt стараются максимально учесть идеальный размер виджета при размещении дочерних виджетов. Для того чтобы IconEditor был удобен для менеджера компоновки, он должен сообщить свой правдоподобный идеальный размер.
   Кроме идеального размера виджет имеет «политику размера», которая говорит системе компоновки о желательности или нежелательности его растяжения или сжатия. Вызывая в конструкторе функцию setSizePolicy() со значением QSizePolicy::Minimum в качестве горизонтальной и вертикальной политики, мы указываем менеджеру компоновки, который отвечает за размещение этого виджета, на то, что идеальный размер является фактически его минимальным размером. Другими словами, при необходимости виджет может растягиваться, но он никогда не должен сжиматься до размеров меньших, чем идеальный. Политику размера можно изменять в Qt Designer путем установки свойства виджета sizePolicy. Смысл различной политики размеров объясняется в главе 6 («Управление компоновкой»).
   20 void IconEditor::setPenColor(const QColor &newColor)
   21 {
   22 curColor = newColor;
   23 }
   Функция setPenColor() устанавливает текущий цвет пера. Этот цвет будет использоваться при выводе на экран новых пикселей.
   24 void IconEditor::setIconImage(const QImage &newImage)
   25 {
   26 if (newImage != image) {
   27 image = newImage.convertToFormat(QImage::Format_ARGB32);
   28 update();
   29 updateGeometry();
   30 }
   31 }
   Функция setIconImage() задает изображение для редактирования. Мы вызываем convertToFormat() для установки 32-битовой глубины изображения с альфа—буфером, если это еще не сделано. В дальнейшем везде мы будем предполагать, что изображение хранится в 32-битовых элементах типа ARGB.
   После установки переменной image мы вызываем функцию QWidget::update() для принудительной перерисовки виджета с новым изображением. Затем мы вызываем QWidget::updateGeometry(), чтобы сообщить всем содержащим этот виджет менеджерам компоновки об изменении идеального размера виджета. Размещение виджета затем будет автоматически адаптировано к его новому идеальному размеру.
   32 void IconEditor::setZoomFactor(int newZoom)
   33 {
   34 if (newZoom < 1)
   35 newZoom = 1;
   36 if (newZoom != zoom) {
   37 zoom = newZoom;
   38 update();
   39 updateGeometry();
   40 }
   41 }
   Функция setZoomFactor() устанавливает масштабный коэффициент изображения. Для предотвращения деления на нуль мы корректируем всякое значение, меньшее, чем 1. Мы опять вызываем функции update() и updateGeometry() для перерисовки виджета и уведомления всех менеджеров компоновки об изменении идеального размера.
   Функции penColor(), iconImage() и zoomFactor() реализуются в заголовочном файле как встроенные функции.
   Теперь мы рассмотрим программный код функции paintEvent(). Эта функция играет очень важную роль в классе IconEditor. Она вызывается всякий раз, когда требуется перерисовать виджет. Используемая по умолчанию ее реализация в QWidget ничего не делает, оставляя виджет пустым.
   Так же как рассмотренная нами в главе 3 функция closeEvent(), функция paintEvent() является обработчиком события. В Qt предусмотрено много других обработчиков событий, каждый из которых относится к определенному типу события. Обработка событий подробно рассматривается в главе 7.
   Существует множество ситуаций, когда генерируется событие рисования (paint) и вызывается функция paintEvent():
   • при первоначальном выводе на экран виджета система автоматически генерирует событие рисования, чтобы виджет нарисовал сам себя;
   • при изменении размеров виджета система генерирует событие рисования;
   • если виджет перекрывается другим окном и затем вновь оказывается видимым, генерируется событие рисования для областей, которые закрывались (если только система управления окнами не сохранит закрытую область).
   Мы можем также принудительно сгенерировать событие рисования путем вызова функции QWidget::update() или QWidget::repaint(). Различие между этими функциями следующее: repaint() приводит к немедленной перерисовке, а функция update() просто передает событие рисования в очередь событий, обрабатываемых Qt. (Обе функции ничего не будут делать, если виджет невидим на экране.) Если update() вызывается несколько раз, Qt из нескольких следующих друг за другом событий рисования делает одно событие для предотвращения мерцания. В классе IconEditor мы всегда используем функцию update().
   Ниже приводится программный код:
   42 void IconEditor::paintEvent(QPaintEvent *event)
   43 {
   44 QPainter painter(this);
   45 if (zoom >= 3) {
   46 painter.setPen(palette().foreground().color());
   47 for (int i = 0; i <= image.width(); ++i)
   48 painter.drawLine(zoom * i, 0,
   49 zoom * i, zoom * image.height());
   50 for (int j = 0; j <= image.height(); ++j)
   51 painter.drawLine(0, zoom * j,
   52 zoom * image.width(), zoom * j);
   53 }
 
   54 for (int i = 0; i < image.width(); ++i) {
   55 for (int j = 0; j < image.height(); ++j) {
   56 QRect rect = pixelRect(i, j);
   57 if (!event->region().intersect(rect).isEmpty()) {
   58 QColor color = QColor::fromRgba(image.pixel(i, j));
   59 painter.fillRect(rect, color);
   60 }
   61 }
   62 }
   63 }
   Мы начинаем с построения объекта QPainter нашего виджета. Если масштабный коэффициент равен или больше 3, мы вычерчиваем с помощью функции QPainter::drawLine() горизонтальные и вертикальные линии сетки.
   Вызов функции QPainter::drawLine() имеетследующий формат:
   painter.drawLine(x1, y1, x2, y2);
   где (x1, y1) задает положение одного конца линии и (x2, y2) задает положение другого конца линии. Существует перегруженный вариант функции, которая принимает два объекта типа QPoint вместо четырех целых чисел.
   Пиксель в верхнем левом углу виджета Qt имеет координаты (0, 0), а пиксель в нижнем правом углу имеет координаты (width() — 1, height() — 1). Это напоминает обычную декартовскую систему координат, но только перевернутую сверху вниз. Мы можем изменить систему координат в QPainter, трансформируя ее такими способами, как смещение, масштабирование, вращение и отсечение. Эти вопросы рассматриваются в главе 8 («Графика 2D и 3D»).
   Рис. 5.3. Вычерчивание линии при помощи QPainter.
   Перед вызовом в QPainter функции drawLine() мы устанавливаем цвет линии, используя функцию setPen(). Мы могли бы жестко запрограммировать цвет (например, черный или серый), но лучше использовать палитру виджета.
   Каждый виджет имеет палитру, которая определяет назначение цветов. Например, предусмотрен цвет фона виджетов (обычно светло—серый) и цвет текста на этом фоне (обычно черный). По умолчанию палитра виджета адаптирована под схему цветов оконной системы. Используя цвета из палитры, мы обеспечим в IconEditor учет пользовательских настроек.
   Палитра виджета состоит из трех цветовых групп: активной, неактивной и нерабочей. Цветовая группа выбирается в зависимости от текущего состояния виджета:
   • группа Active используется для виджетов текущего активного окна;
   • группа Inactive используется виджетами других окон;
   • группа Disabled используется отключенными виджетами любого окна.
   Функция QWidget::palette() возвращает палитру виджета в виде объекта QPalette. Цветовые группы определяются как элементы перечисления типа QPalette::QColorGroup. Удобная функция QWidget::colorGroup() возвращает правильную цветовую группу текущего состояния виджета, и поэтому нам редко придется выбирать цвет непосредственно из палитры.
   Когда нам нужно получить соответствующую кисть или цвет для рисования, правильный подход связан с применением текущей палитры, полученной функцией QWidget::palette(), и соответствующей ролевой функции, например QPalette::foreground(). Каждая ролевая функция возвращает кисть, что обычно и требуется, однако если нам нужен только цвет, его можно извлечь из кисти, как мы это делали в paintEvent(). По умолчанию возвращаемые кисти соответствуют состоянию виджета, поэтому нам не надо указывать цветовую группу.
   Функция paintEvent() завершает рисование изображения. Вызов IconEditor::pixelRect() возвращает QRect, который определяет область перерисовки. Мы не выдаем пиксели, которые попадают за пределы данной области, обеспечивая простую оптимизацию.
   Рис. 5.4. Вычерчивание прямоугольника при помощи QPainter.
   Мы вызываем QPainter::fillRect() для вывода на экран масштабируемого пикселя. QPainter::fillRect() принимает QRect и QBrush. Передавая QColor в качестве кисти, мы обеспечиваем равномерное заполнение области.
   64 QRect IconEditor::pixelRect(int i, int j) const
   65 {
   66 if (zoom >= 3) {
   67 return QRect(zoom * i + 1, zoom * j + 1, zoom - 1, zoom - 1);
   68 } else {
   69 return QRect(zoom * i, zoom * j, zoom, zoom);
   70 }
   71 }
   Функция pixelRect() возвращает объект QRect, который может использоваться функцией QPainter::fillRect(). Параметры i и j являются координатами пикселя в QImage, а не в виджете. Если коэффициент масштабирования равен 1, обе системы координат будут полностью совпадать.
   Конструктор QRect имеет синтаксис QRect(x, у, width, height), где (x, у) являются координатами верхнего левого угла прямоугольника, a width и height являются размерами прямоугольника (шириной и высотой). Если коэффициент масштабирования равен не менее 3, мы уменьшаем размеры прямоугольника на один пиксель по горизонтали и по вертикали, чтобы не загораживать линии сетки.
   72 void IconEditor::mousePressEvent(QMouseEvent *event)
   73 {
   74 if (event->button() == Qt::LeftButton) {
   75 setImagePixel(event->pos(), true);
   76 } else if (event->button() == Qt::RightButton) {
   77 setImagePixel(event->pos(), false);
   78 }
   79 }
   Когда пользователь нажимает кнопку мышки, система генерирует событие «клавиша мышки нажата» (mouse press). Путем переопределения функции QWidget::mousePressEvent() мы можем обработать это событие и установить или стереть пиксель изображения, находящийся под курсором мышки.
   Если пользователь нажал левую кнопку мышки, мы вызываем закрытую функцию setImagePixel() c true в качестве второго аргумента, указывая на необходимость установки цвета пикселя на текущий цвет пера. Если пользователь нажал правую кнопку мышки, мы также вызываем функцию setImagePixel(), но передаем false для стирания пикселя.
   80 void IconEditor::mouseMoveEvent(QMouseEvent *event)
   81 {
   82 if (event->buttons() & Qt::LeftButton) {
   83 setImagePixel(event->pos(), true);
   84 } else if (event->buttons() & Qt::RightButton) {
   85 setImagePixel(event->pos(), false);
   86 }
   87 }
   Функция mouseMoveEvent() обрабатывает события «перемещение мышки». По умолчанию эти события генерируются только при нажатой пользователем кнопки мышки. Можно изменить этот режим работы с помощью вызова функции QWidget::setMouseTracking(), но нам не нужно это делать в нашем примере.
   Как при нажатии левой или правой кнопки мышки устанавливается или стирается пиксель, так и при удерживании нажатой кнопки над пикселем тоже будет устанавливаться или стираться пиксель. Поскольку допускается удерживать нажатыми одновременно несколько кнопок, возвращаемое функцией QMouseEvent::buttons() значение представляет собой результат логической операции поразрядного ИЛИ для кнопок. Мы проверяем нажатие определенной кнопки при помощи оператора & и при наличии соответствующего состояния вызываем функцию setImagePixel().
   88 void IconEditor::setImagePixel(const QPoint &pos, bool opaque)
   89 {
   90 int i = pos.x() / zoom;
   91 int j = pos.y() / zoom;
   92 if (image.rect().contains(i, j)) {
   93 if (opaque) {
   94 image.setPixel(i, j, penColor().rgba());
   95 } else {
   96 image.setPixel(i, j, qRgba(0, 0, 0, 0));
   97 }
   98 update(pixelRect(i, j));
   99 }
   100 }
   Функция setImagePixel() вызывается из mousePressEvent() и mouseMoveEvent() для установки или стирания пикселя. Параметр pos определяет положение мышки на виджете.
   На первом этапе надо преобразовать положение мышки из системы координат виджета в систему координат изображения. Это достигается путем деления координат положения мышки x() и y() на коэффициент масштабирования. Затем мы проверяем попадание точки в нужную область. Это легко сделать при помощи функций QImage::rect() и QRect::contains(); фактически здесь проверяется попадание значения переменной i в промежуток между 0 и значением image.width() — 1, а переменной j — в промежуток между 0 и значением image.height() — 1.
   В зависимости от значения параметра opaque мы устанавливаем или стираем пиксель в изображении. При стирании пиксель фактически становится прозрачным. Для вызова QImage::setPixel() мы должны преобразовать перо QColor в 32-битовое значение ARGB. В конце мы вызываем функцию update() с передачей объекта QRect, задающего область перерисовки.
   Теперь, когда уже рассмотрены функции—члены, мы вернемся к используемому в конструкторе атрибуту Qt::WA_StaticContents. Этот атрибут указывает Qt на то, что содержимое виджета не изменяется при изменении его размеров и что его верхний левый угол остается на прежнем месте. Qt использует эту информацию, чтобы лишний раз не перерисовывать при изменении размеров виджета уже видимые его области.
   Обычно при изменении размеров виджета Qt генерирует событие рисования для всей видимой области виджета. Но если виджет создается с установленным флажком Qt::WA_StaticContents, область рисования ограничивается не показанными ранее пикселями. Это подразумевает, что, если размеры виджета уменьшаются, событие рисования вообще не будет сгенерировано.
   Рис. 5.5. Изменение размеров виджета Qt::WA_StaticContents.
   Теперь виджет IconEditor полностью построен. На основе применения приводимых в предыдущих главах сведений и примеров мы можем написать программу, в которой виджет IconEditor будет сам являться окном, использоваться в качестве центрального виджета в главном окне QMainWindow, в качестве дочернего виджета менеджера компоновки или в качестве дочернего виджета объекта QScrollArea. В следующем разделе мы рассмотрим способы его интеграции в Qt Designer.

   Прежде чем мы сможем использовать пользовательские виджеты в Qt Designer, мы должны сделать так, что Qt Designer будет знать о них. Для этого существует два способа: метод «продвижения» (promotion) и метод подключения (plugin).
   Метод продвижения является самым быстрым и самым простым. Он заключается в выборе некоторого встроенного виджета Qt, программный интерфейс которого похож на программный интерфейс пользовательского виджета, и заполнении полей диалогового окна в Qt Designer некоторыми данными о пользовательском виджете. Впоследствии этот виджет может использоваться в формах, разработанных с помощью Qt Designer, но при редактировании или просмотре он отображается просто в виде выбранного встроенного виджета Qt.
   Ниже приводится порядок действий при интеграции данным методом виджета HexSpinBox:
   1. Создайте наборный счетчик QSpinBox, перетаскивая его с панели виджетов Qt Designer на форму.
   2. Щелкните правой клавишей мышки по наборному счетчику и выберите пункт контекстного меню Promote to Custom Widget (Преобразовать в пользовательский виджет).
   3. Заполните в появившемся диалоговом окне поле названия класса значением «HexSpinBox» и поле заголовочного файла значением «hexspinbox.h».
   Вот и все! Сгенерированный компилятором uic программный код будет содержать оператор #include hexspinbox.h вместо <QSpinBox> и будет инстанцировать HexSpinBox. В Qt Designer виджет HexSpinBox будет представлен виджетом QSpinBox, позволяя нам устанавливать любые свойства QSpinBox (например, допустимый диапазон значений и текущее значение).
   Рис. 5.6. Диалоговое окно для создания пользовательских виджетов Qt Designer.
   Недостатками метода продвижения являются недоступность в Qt Designer свойств, характерных для пользовательского виджета, и то, что пользовательский виджет представляется в QtDesigner не своим изображением. Обе эти проблемы могут быть решены при применении метода подключения.
   Метод подключения требует создания библиотеки подключаемых модулей, которую Qt Designer может загружать во время выполнения и использовать для создания экземпляров виджетов. В этом случае при редактировании формы и ее просмотре в Qt Designer будет использован реальный виджет, и благодаря мета—объектной системе Qt можно динамически получать список его свойств в Qt Designer. Для демонстрации этого метода мы с его помощью выполним интеграцию редактора пиктограмм IconEditor, описанного в предыдущем разделе.
   Во-первых, мы должны создать подкласс QDesignerCustomWidgetInterface и переопределить несколько виртуальных функций. Мы предположим, что исходный файл подключаемого модуля расположен в каталоге с именем iconeditorplugin, а исходный текст программы IconEditor расположен в параллельном каталоге с именем iconeditor.
   Ниже приводится определение класса:
   01 #include <QDesignerCustomWidgetInterface>
   02 class IconEditorPlugin : public QObject,
   03 public QDesignerCustomWidgetInterface
   04 {
   05 Q_OBJECT
   06 Q_INTERFACES(QDesignerCustomWidgetInterface)
   07 public:
   08 IconEditorPlugin(QObject *parent = 0);
   09 QString name() const;
   10 QString includeFile() const;
   11 QString group() const;
   12 QIcon icon() const;
   13 QString toolTip() const;
   14 QString whatsThis() const;
   15 bool isContainer() const;
   16 QWidget *createWidget(QWidget *parent);
   17 };
   Подкласс IconEditorPlugin является фабрикой класса (factory class), который инкапсулирует виджет IconEditor. Он является наследником классов QObject и QDesignerCustomWidgetIterface и использует макрос Q_INTERFACES(), указывая компилятору moc на то, что второй базовый класс представляет собой подключаемый интерфейс. Его функции применяются Qt Designer для создания экземпляров класса и получения информации о нем.
   01 IconEditorPlugin::IconEditorPlugin(QObject *parent)
   02 : QObject(parent)
   03 {
   04 }
   IconEditorPlugin имеет тривиальный конструктор.
   05 QString IconEditorPlugin::name() const
   06 {
   07 return "IconEditor";
   08 }
   Функция name() возвращает имя подключаемого виджета.
   09 QString IconEditorPlugin::includeFile() const
   10 {
   11 return "iconeditor.h";
   12 }
   Функция includeFile() возвращает имя заголовочного файла для заданного виджета, который инкапсулирован в подключаемом модуле. Заголовочный файл включается в программный код, сгенерированный компилятором uic.
   13 QString IconEditorPlugin::group() const
   14 {
   15 return tr("Image Manipulation Widgets");
   16 }
   Функция group() возвращает имя группы на панели виджетов, к которой принадлежит пользовательский виджет. Если это имя еще не используется, Qt Designer coздаст новую группу для виджета.
   17 QIcon IconEditorPlugin::icon() const
   18 {
   19 return QIcon(":/images/iconeditor.png");
   20 }
   Функция icon() возвращает пиктограмму которая будет использоваться для представления пользовательского виджета на панели виджетов Qt Designer. В нашем случае мы предполагаем, что IconEditorPlugin имеет ресурсный файл Qt, содержащий соответствующий элемент для изображения редактора пиктограмм.
   21 QString IconEditorPlugin::toolTip() const
   22 {
   23 return tr("An icon editor widget");
   24 }
   Функция toolTip() возвращает всплывающую подсказку, которая появляется, когда мышка находится на пользовательском виджете в панели виджетов Qt Designer.
   25 QString IconEditorPlugin::whatsThis() const
   26 {
   27 return tr("This widget is presented in Chapter 5 of <i>C++ GUI "
   28 "Programming with Qt 4</i> as an example of a custom Qt "
   29 "widget.");
   30 }
   Функция whatsThis() возвращает текст «What's This?» (что это?) для отображения в Qt Designer.
   31 bool IconEditorPlugin::isContainer() const
   32 {
   33 return false;
   34 }
   Функция isContainer() возвращает true, если данный виджет может содержать другие виджеты; в противном случае он возвращает false. Например, QFrame представляет собой виджет, который может содержать другие виджеты. В целом любой виджет может содержать другие виджеты, но Qt Designer не позволяет это делать, если isContainer() возвращает false.
   35 QWidget *IconEditorPlugin::createWidget(QWidget *parent)
   36 {
   37 return new IconEditor(parent);
   38 }
   Функция createWidget() вызывается Qt Designer для создания экземпляра класса виджета для указанного родительского виджета.
   39 Q_EXPORT_PLUGIN2(iconeditorplugin, IconEditorPlugin)
   В конце исходного файла реализации класса подключаемого модуля мы должны использовать макрос Q_EXPORT_PLUGIN2(), чтобы сделать его доступным для Qt Designer. Первый аргумент — назначаемое нами имя подключаемого модуля, второй аргумент — имя класса, который его реализует.
   Используемый для построения подключаемого модуля файл .pго выглядит следующим образом:
   TEMPLATE = lib
   CONFIG += designer plugin release
   HEADERS = ../iconeditor/iconeditor.h \
   iconeditorplugin.h
   SOURCES = ../iconeditor/iconeditor.cpp \
   iconeditorplugin.cpp
   RESOURCES = iconeditorplugin.qrc
   DESTDIR = $(QTDIR)/plugins/designer
   Файл .pro предполагает, что переменная окружения QTDIR установлена на каталог, где располагается Qt. Когда вы вводите команду make или nmake для построения подключаемого модуля, он автоматически устанавливается в каталог plugins Qt Designer. Поле построения подключаемого модуля виджет IconEditor мoжeт использоваться в Qt Designer таким же образом как, любые встроенные виджеты Qt.
   Если требуется интегрировать в Qt Designer несколько пользовательских виджетов, вы можете либо создать отдельный подключаемый модуль для каждого из них, либо объединить все в один подключаемый модуль, реализуя интерфейс QDesignerCustomWidgetCollectionInterface.

   Двойная буферизация является методом программирования графического пользовательского интерфейса, при котором изображение виджета формируется вне экрана в виде пиксельной карты, и затем эта пиксельная карта выводится на экран. В ранних версиях Qt этот метод часто использовался для предотвращения мерцания изображения и для построения более быстрого пользовательского интерфейса.
   В Qt 4 класс QWidget это делает автоматически, поэтому нам редко приходится беспокоиться о мерцании виджетов. Все же явная двойная буферизация оказывается полезной, если виджет воспроизводится сложным образом и это приходится делать постоянно. Мы можем постоянно хранить с виджетом пиксельную карту, которая всегда будет готова отреагировать на следующее событие рисования, и копировать пиксельную карту в виджет при получении нами любого события рисования. Она особенно полезна в тех случаях, когда мы хотим выполнить небольшие модификации, например начертить резиновую ленту без необходимости постоянной перерисовки виджета.
   Мы закончим данную главу рассмотрением пользовательского виджета Plotter (построитель графиков). Этот виджет использует двойную буферизацию и также демонстрирует некоторые другие аспекты Qt—программирования, в том числе обработку событий клавиатуры, ручную компоновку виджетов и координатные системы.
   Виджет Plotter выводит на экран одну или несколько кривых, задаваемых вектором ее координат. Пользователь может начертить на изображении резиновую ленту, и Plotter отобразит крупным планом заключенную в ней область. Пользователь вычерчивает резиновую ленту, делая сначала щелчок в некоторой точке изображения, перетаскивая затем мышку с нажатой левой кнопкой в другую позицию и освобождая клавишу мышки.
   Рис. 5.7. Увеличение изображения виджета Plotter.
   Пользователь может увеличивать изображение, несколько раз используя резиновую ленту, уменьшить изображение при помощи кнопки Zoom Out (уменьшить изображение) и затем вновь его увеличить с помощью кнопки Zoom In (увеличить изображение). Кнопки Zoom In и Zoom Out появляются при первом изменении масштаба изображения, и поэтому они не будут заслонять экран, если пользователь не изменяет масштаб представления диаграммы.
   Виджет Plotter может содержать данные любого количества кривых. Он также содержит стек параметров графика PlotSettings, каждое значение которого соответствует конкретному масштабу изображения.
   Давайте рассмотрим этот класс, начиная с заголовочного файла plotter.h:
   01 #ifndef PLOTTER_H
   02 #define PLOTTER_H
   03 #include <QMap>
   04 #include <QPixmap>
   05 #include <QVector>
   06 #include <QWidget>
   07 class QToolButton;
   08 class PlotSettings;
 
   09 class Plotter : public QWidget
   10 {
   11 Q_OBJECT
   12 public:
   13 Plotter(QWidget *parent = 0);
   14 void setPlotSettings(const PlotSettings &settings);
   15 void setCurveData(int id, const QVector<QPointF> &data);
   16 void clearCurve(int id);
   17 QSize minimumSizeHint() const;
   18 QSize sizeHint() const;
   19 public slots:
   20 void zoomIn();
   21 void zoomOut();
   Сначала мы включаем заголовочные файлы для Qt—классов, используемых в заголовочном файле построителя графиков, и предварительно объявляем классы, на которые имеются указатели или ссылки в заголовочном файле.
   В классе Plotter мы предоставляем три открытые функции для настройки графика и два открытых слота для увеличения и уменьшения масштаба изображения. Мы также переопределяем функции minimumSizeHint() и sizeHint() класса QWidget. Мы храним точки кривой в векторе QVector<QPointF>, где QPointF — версия QPoint для значений с плавающей точкой.
   22 protected:
   23 void paintEvent(QPaintEvent *event);
   24 void resizeEvent(QResizeEvent *event);
   25 void mousePressEvent(QMouseEvent *event);
   26 void mouseMoveEvent(QMouseEvent *event);
   27 void mouseReleaseEvent(QMouseEvent *event);
   28 void keyPressEvent(QKeyEvent *event);
   29 void wheelEvent(QWheelEvent *event);
   В защищенной секции класса мы объявляем все обработчики событий QWidget, которые хотим переопределить.
   30 private:
   31 void updateRubberBandRegion();
   32 void refreshPixmap();
   33 void drawGrid(QPainter *painter);
   34 void drawCurves(QPainter *painter);
   35 enum { Margin = 50 };
   36 QToolButton *zoomInButton;
   37 QToolButton *zoomOutButton;
 
   38 QMap<int, QVector<QPointF> > curveMap;
   39 QVector<PlotSettings> zoomStack;
   40 int curZoom;
   41 bool rubberBandIsShown;
   42 QRect rubberBandRect;
   43 QPixmap pixmap;
   44 };
   В закрытой секции класса мы объявляем несколько функций для рисования виджета, константу и несколько переменных—членов. Константа Margin применяется для обеспечения некоторого свободного пространства вокруг диаграммы.
   Среди переменных—членов находится pixmap, которая имеет тип QPixmap. Эта переменная содержит копию всего виджета, идентичную его изображению на экране. График всегда сначала строится вне экрана на пиксельной карте, и затем пиксельная карта помещается на виджет.
   45 class PlotSettings
   46 {
   47 public:
   48 PlotSettings();
 
   49 void scroll(int dx, int dy);
   50 void adjust();
   51 double spanX() const { return maxX - minX; }
   52 double spanY() const { return maxY - minY; }
 
   53 double minX;
   54 double maxX;
   55 int numXTicks;
   56 double minY;
   57 double maxY;
   58 int numYTicks;
 
   59 private:
   60 static void adjustAxis(double &min, double &max, int &numTicks);
   61 };
   62 #endif
   Класс PlotSettings задает диапазон значений по осям x и y и количество отметок на этих осях. На рис. 5.8 показано соответствие между объектом PlotSettings и виджетом Plotter.
   По условному соглашению значение в numXTicks и numYTicks задается на единицу меньше; если numXTicks равно 5, Plotter будет на самом деле выводить 6 отметок по оси x. Это упростит расчеты в будущем.
   Рис. 5.8. Переменные—члены настроек графика PlotSettings.
   Теперь давайте рассмотрим файл реализации:
   001 #include <QtGui>
   002 #include <cmath>
   003 #include "plotter.h"
   Мы включаем необходимые заголовочные файлы и импортируем все символы пространства имен std в глобальное пространство имен. Это позволяет нам получать доступ к функциям, объявленным в <cmath>, без указания префикса std:: (например, floor() вместо std::floor()).
   004 Plotter::Plotter(QWidget *parent)
   005 : QWidget(parent)
   006 {
   007 setBackgroundRole(QPalette::Dark);
   008 setAutoFillBackground(true);
   009 setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
   010 setFocusPolicy(Qt::StrongFocus);
   011 rubberBandIsShown = false;
 
   012 zoomInButton = new QToolButton(this);
   013 zoomInButton->setIcon(QIcon(":/images/zoomin.png"));
   014 zoomInButton->adjustSize();
   015 connect(zoomInButton, SIGNAL(clicked()), this, SLOT(zoomIn()));
 
   016 zoomOutButton = new QToolButton(this);
   017 zoomOutButton->setIcon(QIcon(":/images/zoomout.png"));
   018 zoomOutButton->adjustSize();
   019 connect(zoomOutButton, SIGNAL(clicked()), this, SLOT(zoomOut()));
 
   020 setPlotSettings(PlotSettings());
   021 }
   Вызов setBackgroundRole() указывает QWidget на необходимость использования для цвета стирания виджета «темного» компонента палитры вместо компонента «window» (окно). Этим мы определяем цвет, который будет использоваться в Qt по умолчанию для заполнения любых вновь появившихся пикселей при увеличении размеров виджета прежде, чем paintEvent() получит возможность рисования нового пикселя. Для включения этого механизма необходимо также вызвать setAutoFillBackground(true). (По умолчанию дочерние виджеты наследуют фон своего родительского виджета.)
   Вызов setSizePolicy() устанавливает политику размера виджета по обоим направлениям на значение QSizePolicy::Expanding. Это подсказывает любому менеджеру компоновки, который ответственен за виджет, что он прежде всего склонен к росту, но может также сжиматься. Такая настройка параметров типична для виджетов, которые занимают много места на экране. По умолчанию в обоих направлениях устанавливается политика QSizePolicy::Preferred, означающая, что для виджета предпочтительно устанавливать размер на основе его идеального размера, но он может сжиматься до своего минимального идеального размера или расширяться в любых пределах при необходимости.
   Вызов setFocusPolicy(Qt::StrongFocus) заставляет виджет получать фокус при нажатии клавиши табуляции Tab. Когда Plotter получает фокус, он будет реагировать на события нажития клавиш. Виджет Plotter понимает несколько клавиш: «+» для увеличения изображения, «—» для уменьшения изображения и клавиш стрелок для прокрутки вверх, вниз, влево и вправо.
   Рис. 5.9. Скроллинг виджета Plotter.
   Также в конструкторе мы создаем две кнопки QToolButtons, каждая из которых имеет пиктограмму. Эти кнопки дают возможность пользователю увеличивать и уменьшать масштаб изображения. Пиктограммы кнопок хранятся в файле ресурсов, поэтому любое приложение, использующее виджет Plotter, должно иметь следующую строку в файле .pro:
   RESOURCES = plotter.qrc
   Этот файл ресурсов похож на файл, который мы использовали для приложения Электронная таблица:
   <!DOCTYPE RCC><RCC version="1.0">
    <qresource>
    <file>images/zoomin.png</file>
    <file>images/zoomout.png</file>
    </qresource>
   </RCC>
   Вызовы функции adjustSize() устанавливают для кнопок их идеальные размеры. Кнопки не размещаются в менеджере компоновки; вместо этого мы задаем их положение вручную при обработке события изменения размеров виджета Plotter. Поскольку мы не пользуемся никакими менеджерами компоновки, необходимо явно задавать родительский виджет кнопок, передавая this конструктору QPushButton.
   Вызов в конце функции setPlotSettings() завершает инициализацию.
   022 void Plotter::setPlotSettings(const PlotSettings &settings)
   023 {
   024 zoomStack.clear();
   025 zoomStack.append(settings);
   026 curZoom = 0;
   027 zoomInButton->hide();
   028 zoomOutButton->hide();
   029 refreshPixmap();
   030 }
   Функция setPlotSettings() устанавливает настройки PlotSettings для отображения графика. Ее вызывает конструктор Plotter, и она может также вызываться пользователями класса. Построитель кривых начинает работу с принятого по умолчанию масштаба изображения. Каждый раз, когда пользователь увеличивает изображение, создается новый экземпляр PlotSettings, который затем помещается в стек масштабов изображения. Этот стек масштабов изображений представлен двумя переменными—членами:
   • zoomStack содержит настройки для различных масштабов изображения в объекте QVector<PlotSettings>;
   • curZoom содержит индекс текущего элемента PlotSettings стека zoomStack.
   После вызова функции setPlotSettings() в стеке масштабов изображений будет находиться только один элемент, а кнопки Zoom In и Zoom Out будут скрыты. Эти кнопки не будут видны на экране до тех пор, пока мы не вызовем для них функцию show() в слотах zoomIn() и zoomOut(). (Обычно для показа всех дочерних виджетов достаточно вызвать функцию show() для виджета верхнего уровня. Но когда мы явным образом вызываем для дочернего виджета функцию hide(), этот виджет будет скрыт до вызова для него функции show().)
   Вызов функции refreshPixmap() необходим для обновления изображения на экране. Обычно мы вызываем функцию update(), но здесь мы поступаем немного по-другому, потому что хотим иметь пиксельную карту QPixmap постоянно в обновленном состоянии. После регенерации пиксельной карты функция refreshPixmap() вызывает update() для помещения пиксельной карты на виджет.
   031 void Plotter::zoomOut()
   032 {
   033 if (curZoom > 0) {
   034 --curZoom;
   035 zoomOutButton->setEnabled(curZoom > 0);
   036 zoomInButton->setEnabled(true);
   037 zoomInButton->show();
   038 refreshPixmap();
   039 }
   040 }
   Слот zoomOut() уменьшает масштаб диаграммы, если она отображена крупным планом. Он уменьшает на единицу текущий масштаб изображения и включает или выключает кнопку ZoomOut, в зависимости от возможности дальнейшего уменьшения диаграммы. Кнопка Zoom In включается и отображается на экране, а изображение диаграммы обновляется посредством вызова функции refreshPixmap().
   041 void Plotter::zoomIn()
   042 {
   043 zoomInButton->setEnabled(curZoom< zoomStack.count() - 1);
   044 if (curZoom < zoomStack.count() - 1) {
   045 ++curZoom;
   046 zoomOutButton->setEnabled(true);
   047 zoomOutButton->show();
   048 refreshPixmap();
   049 }
   050 }
   Если пользователь сначала увеличил изображение, а затем вновь его уменьшил, настройки PlotSettings для следующего масштаба изображения уже будут в стеке масштабов изображения, и мы можем увеличить его. (В противном случае можно все же увеличить изображение при помощи резиновой ленты.)
   Слот увеличивает на единицу значение curZoom для перехода на один уровень вглубь стека масштабов изображения, включает или выключает кнопку Zoom In взависимости от возможности дальнейшего увеличения изображения и включает и показывает кнопку Zoom Out. И вновь мы вызываем refreshPixmap() для использования построителем графиков настроек самого последнего масштаба изображения.
   051 void Plotter::setCurveData(int id, const QVector<QPointF> &data)
   052 {
   053 curveMap[id] = data;
   054 refreshPixmap();
   055 }
   Функция setCurveData() устанавливает данные для кривой с заданным идентификатором. Если в curveMap уже имеется кривая с таким идентификатором, ее данные заменяются новыми значениями; в противном случае просто добавляется новая кривая. Переменная—член curveMap имеет тип QMap<int, QVector<QPointF> >.
   056 void Plotter::clearCurve(int id)
   057 {
   058 curveMap.remove(id);
   059 refreshPixmap();
   060 }
   Функция clearCurve() удаляет заданную кривую из curveMap.
   061 QSize Plotter::minimumSizeHint() const
   062 {
   063 return QSize(6 * Margin, 4 * Margin);
   064 }
   Функция minimumSizeHint() напоминает sizeHint(); в то время как функция sizeHint() устанавливает идеальный размер виджета, minimumSizeHint() задает идеальный минимальный размер виджета. Менеджер компоновки никогда не станет задавать виджету размеры ниже идеального минимального размера.
   Мы возвращаем значение 300 × 200 (поскольку Margin равен 50) для того, чтобы можно было разместить окаймляющую кромку по всем четырем сторонам и обеспечить некоторое пространство для самого графика. При меньших размерах считается, что график будет слишком мал и бесполезен.
   065 QSize Plotter::sizeHint() const
   066 {
   067 return QSize(12 * Margin, 8 * Margin);
   068 }
   В функции sizeHint() мы возвращаем «идеальный» размер относительно константы Margin, причем горизонтальный и вертикальный компоненты этого размера составляют ту же самую приятную для глаза пропорцию 3:2, которую мы использовали для minimumSizeHint().
   Мы завершаем рассмотрение открытых функций и слотов построителя графиков Plotter. Теперь давайте рассмотрим защищенные обработчики событий.
   069 void Plotter::paintEvent(QPaintEvent * /* event */)
   070 {
   071 QStylePainter painter(this);
   072 painter.drawPixmap(0, 0, pixmap);
   073 if (rubberBandIsShown) {
   074 painter.setPen(palette().light().color());
   075 painter.drawRect(rubberBandRect.normalized()
   076 .adjusted(0, 0, -1, -1));
   077 }
 
   078 if (hasFocus()) {
   079 QStyleOptionFocusRect option;
   080 option.initFrom(this);
   081 option.backgroundColor = palette().dark().color();
   082 painter.drawPrimitive(QStyle::PE_FrameFocusRect, option);
   083 }
   084 }
   Обычно все действия по рисованию выполняются функцией paintEvent(). Но в данном случае вся диаграмма уже нарисована функцией refreshPixmap(), и поэтому мы можем воспроизвести весь график, просто копируя пиксельную карту в виджет в позицию (0, 0).
   Если резиновая лента должна быть видимой, мы рисуем ее поверх графика. Мы используем светлый («light») компонент из текущей цветовой группы виджета в качестве цвета пера для обеспечения хорошего контраста с темным («dark») фоном. Следует отметить, что мы рисуем непосредственно на виджете, оставляя нетронутым внеэкранное изображение на пиксельной карте. Вызов QRect::normalized() гарантирует наличие положительных значений ширины и высоты прямоугольника резиновой ленты (выполняя обмен значений координат при необходимости), а вызов adjusted() уменьшает размер прямоугольника на один пиксель, позволяя вывести на экран его контур шириной в один пиксель.
   Если Plotter получает фокус, вывод фокусного прямоугольника выполняется с использованием функции drawPrimitive(), задающей стиль виджета, с передачей QStyle::PE_FrameFocusRect в качестве первого аргумента и объекта QStyleOptionFocusRect в качестве второго аргумента. Опции рисования фокусного прямоугольника наследуются от виджета Plotter (путем вызова initFrom()). Цвет фона должен задаваться явно.
   Если при рисовании требуется использовать текущий стиль, мы можем либо непосредственно вызвать функцию QStyle, например
   style()->drawPrimitive(QStyle::PE_FrameFocusRect, &option, &painter, this);
   либо использовать QStylePainter вместо обычного QPainter (как мы это делали в Plotter), что делает рисование более удобным.
   Функция QWidget::style() возвращает стиль, который будет использован для рисования виджета. В Qt стиль виджета является подклассом QStyle. Встроенными являются стили QWindowsStyle, QWindowsXPStyle, QMotifStyle, QCDEStyle, QMacStyle и OPlastiqueStyle. Все эти стили переопределяют виртуальные функции класса QStyle, чтобы обеспечить корректное рисование в стиле имитируемой платформы. Функция drawPrimitive() класса QStylePainter вызывает функцию класса QStyle с тем именем, которое используется для рисования таких «примитивов», как панели, кнопки и фокусные прямоугольники. Обычно все виджеты используют стиль приложения (QApplication::style()), но в любом виджете стиль может переопределяться с помощью функции QWidget::setStyle().
   Путем создания подкласса QStyle можно определить пользовательский стиль. Это можно делать с целью придания отличительных стилевых особенностей одному какому-то приложению или группе из нескольких приложений. Хотя рекомендуется в целом придерживаться «родного» стиля выбранной платформы, Qt предлагает достаточно гибкие средства по управлению стилем тем, у кого большая фантазия.
   Встроенные в Qt виджеты при рисовании самих себя почти полностью зависят от QStyle. Именно поэтому они выглядят естественно на всех платформах, поддерживаемых Qt. Пользовательские виджеты могут создаваться чувствительными к стилю либо путем применения QStyle (через QStylePainter) при рисовании самих себя, либо используя встроенные виджеты Qt в качестве дочерних. В Plotter мы используем оба подхода: фокусный прямоугольник рисуется с применением QStyle, а кнопки Zoom In и Zoom Out являются встроенными виджетами Qt.
   085 void Plotter::resizeEvent(QResizeEvent * /* event */ )
   086 {
   087 int x= width() - (zoomInButton->width()
   088 + zoomOutButton->width() + 10);
   089 zoomInButton->move(x, 5);
   090 zoomOutButton->move(x + zoomInButton->width() + 5, 5);
   091 refreshPixmap();
   092 }
   При всяком изменении размера виджета Plotter Qt генерирует событие «изменение размера». Здесь мы переопределяем функцию resizeEvent() для размещения кнопок Zoom In и Zoom Out в верхнем правом углу виджета Plotter.
   Мы располагаем кнопки Zoom In и Zoom Out рядом, отделяя их 5-пиксельным промежутком от верхнего и правого краев родительского виджета.
   Если бы нам захотелось оставить эти кнопки в верхнем левом углу, который имеет координаты (0, 0), мы бы просто переместили их туда в конструкторе Plotter. Но мы хотим, чтобы они находились в верхнем правом углу, координаты которого зависят от размеров виджета. По этой причине необходимо переопределить функцию resizeEvent() и в ней устанавливать положение кнопок.
   Мы не устанавливали положение каких-либо кнопок в конструкторе Plotter. Это сделано из-за того, что Qt всегда генерирует событие изменения размера до первого появления на экране виджета.
   В качестве альтернативы переопределению функции resizeEvent() и размещению дочерних виджетов «вручную» можно использовать менеджер компоновки (например, QGridLayout). При применении менеджеров компоновки это выполнить немного сложнее и такой подход потребовал бы больше ресурсов; с другой стороны, это дало бы элегантное решение компоновки справа налево, что необходимо для таких языков, как арабский и еврейский.
   В конце мы вызываем функцию refreshPixmap() для перерисовки пиксельной карты с новым размером.
   093 void Plotter::mousePressEvent(QMouseEvent *event)
   094 {
   095 QRect rect(Margin, Margin,
   096 width() - 2 * Margin, height() - 2 * Margin);
   097 if (event->button() == Qt::LeftButton) {
   098 if (rect.contains(event->pos())) {
   099 rubberBandIsShown = true;
   100 rubberBandRect.setTopLeft(event->pos());
   101 rubberBandRect.setBottomRight(event->pos());
   102 updateRubberBandRegion();
   103 setCursor(Qt::CrossCursor);
   104 }
   105 }
   106 }
   Когда пользователь нажимает левую кнопку мышки, мы начинаем отображать на экране резиновую ленту. Для этого необходимо установить флажок rubberBandIsShown на значение true, инициализировать переменную—член rubberBandRect на значение текущей позиции курсора мышки, поставить в очередь событие рисования для вычерчивания резиновой ленты и изменить изображение курсора мышки на перекрестие.
   Переменная rubberBandRect имеет тип QRect. Объект QRect может задаваться либо четырьмя параметрами (x, у, w, h), где (x, у) является позицией верхнего левого угла и w × h определяет размеры четырехугольника, либо парой точек верхнего левого и нижнего правого углов. Здесь мы используем формат с парой точек. То место, где пользователь первый раз щелкнул мышкой, становится верхним левым углом, а текущая позиция курсора определяет позицию нижнего правого угла. Затем мы вызываем updateRubberBandRegion() для принудительной перерисовки (небольшой) области, покрываемой резиновой лентой.
   В Qt предусмотрено два способа управления формой курсора мышки:
   • QWidget::setCursor() устанавливает форму курсора, которая используется при его нахождении на конкретном виджете. Если для виджета курсор не задан, используется курсор родительского виджета. По умолчанию для виджета верхнего уровня назначается курсор в виде стрелки;
   • QApplication::setOverrideCursor() устанавливает форму курсора для всего приложения, отменяя формы курсоров отдельных виджетов до вызова функции restoreOverrideCursor().
   В главе 4 мы вызывали функцию QApplication::setOverrideCursor() с параметром Qt::WaitCursor для установки курсора приложения на стандартный курсор ожидания.
   107 void Plotter::mouseMoveEvent(QMouseEvent *event)
   108 {
   109 if (rubberBandIsShown) {
   110 updateRubberBandRegion();
   111 rubberBandRect.setBottomRight(event->pos());
   112 updateRubberBandRegion();
   113 }
   114 }
   Когда пользователь перемещает курсор мышки с нажатой левой кнопкой, мы сначала вызываем функцию updateRubberBandRegion() для постановки в очередь события рисования для перерисовки области, занятой резиновой лентой, затем пересчитываем значение переменной rubberBandRect для учета перемещения курсора и, наконец, второй раз вызываем функцию updateRubberBandRegion() для перерисовки области, в которую переместилась резиновая лента. Это фактически приводит к стиранию резиновой ленты и ее вычерчиванию с новыми координатами.
   Если пользователь перемещает мышку вверх или влево, может оказаться, что номинальный нижний правый угол резиновой ленты rubberBandRect выше или левее верхнего левого угла. В этом случае QRect будет иметь отрицательную ширину или высоту. В paintEvent() нами использована функция QRect::normalized(), которая настраивает координаты верхнего левого и нижнего правого углов для получения положительного значения ширины и высоты.
   115 void Plotter::mouseReleaseEvent(QMouseEvent *event)
   116 {
   117 if ((event->button() == Qt::LeftButton) &&
   118 rubberBandIsShown) {
   119 rubberBandIsShown = false;
   120 updateRubberBandRegion();
   121 unsetCursor();
 
   122 QRect rect = rubberBandRect.normalized();
   123 if (rect.width() < 4 || rect.height() < 4)
   124 return;
   125 rect.translate(-Margin, -Margin);
 
   126 PlotSettings prevSettings = zoomStack[curZoom];
   127 PlotSettings settings;
   128 double dx = prevSettings.spanX() / (width() - 2 * Margin);
   130 double dy = prevSettings.spanY() / (height() - 2 * Margin);
 
   131 settings.minX = prevSettings.minX + dx * rect.left();
   132 settings.maxX = prevSettings.minX + dx * rect.right();
   133 settings.minY = prevSettings.maxY - dy * rect.bottom();
   134 settings.maxY = prevSettings.maxY - dy * rect.top();
   135 settings.adjust();
 
   136 zoomStack.resize(curZoom + 1);
   137 zoomStack.append(settings);
   138 zoomIn();
   139 }
   140 }
   Когда пользователь отпускает левую кнопку мышки, мы стираем резиновую ленту и восстанавливаем стандартный курсор в виде стрелки. Если резиновая лента ограничивает прямоугольник, по крайней мере размером 4 × 4, мы изменяем масштаб изображения. Если резиновая лента выделяет прямоугольник меньшего размера, то, по-видимому, пользователь сделал щелчок мышкой по ошибке или просто перевел фокус, и поэтому мы ничего не делаем.
   Программный код по изменению масштаба изображения немного сложен. Это вызвано тем, что мы работаем сразу с двумя системами координат: виджета и построителя графиков. Большинство выполняемых здесь действий связано с преобразованием координат объекта rubberBandRect (прямоугольник резиновой ленты) из системы координат виджета в систему координат построителя графиков. После выполнения преобразований мы вызываем функцию PlotSettings::adjust() для округления чисел и определения разумного количества отметок по обеим осям. Эта ситуация отражена на рис. 5.10 и 5.11.
   Рис. 5.10. Преобразование прямоугольника резиновой ленты из системы координат виджета в систему координат построителя графиков.
   Рис. 5.11. Настройка прямоугольника резиновой ленты в системе координат построителя графиков и увеличение изображения.
   Затем мы изменяем масштаб изображения. Это достигается путем помещения новых, только что рассчитанных настроек PlotSettings в вершину стека масштабов изображения и вызова функции zoomIn(), которая выполняет всю остальную работу.
   141 void Plotter::keyPressEvent(QKeyEvent *event)
   142 {
   143 switch (event->key()) {
   144 case Qt::Key_Plus:
   145 zoomIn();
   146 break;
   147 case Qt::Key_Minus:
   148 zoomOut();
   149 break;
   150 case Qt::Key_Left:
   151 zoomStack[curZoom].scroll(-1, 0);
   152 refreshPixmap();
   153 break;
   154 case Qt::Key_Right:
   155 zoomStack[сurZoom].scrol1(+1, 0);
   156 refreshPixmap();
   157 break;
   158 case Qt::Key_Down:
   159 zoomStack[curZoom].scroll(0, -1);
   160 refreshPixmap();
   161 break;
   162 case Qt::Key_Up:
   163 zoomStack[curZoom].scroll(0, +1);
   164 refreshPixmap();
   165 break;
   166 default:
   167 QWidget::keyPressEvent(event);
   168 }
   169 }
   Когда пользователь нажимает на клавиатуре какую-нибудь клавишу и фокус имеет построитель графиков Plotter, вызывается функция keyPressEvent(). Мы ее переопределяем здесь, чтобы она реагировала на шесть клавиш: +, —, Up (вверх), Down (вниз), Left (влево) и Right (вправо). Если пользователь нажимает другую клавишу, мы вызываем реализацию этой функции из базового класса. Для простоты мы не учитываем ключи модификаторов Shift, Ctrl и Alt, доступ к которым осуществляется с помощью функции QKeyEvent::modifiers().
   170 void Plotter::wheelEvent(QWheelEvent *event)
   171 {
   172 int numDegrees= event->delta() / 8;
   173 int numTicks = numDegrees / 15;
   174 if (event->orientation() == Qt::Horizontal) {
   175 zoomStack[curZoom].scroll(numTicks, 0);
   176 } else {
   177 zoomStack[curZoom].scroll(0, numTicks);
   178 }
   179 refreshPixmap();
   180 }
   События колесика мышки возникают при повороте колесика мышки. В большинстве мышек предусматривается колесико для перемещения по вертикали, но некоторые мышки имеют также колесико для перемещения по горизонтали. Qt поддерживает оба вида колесиков. События колесика мышки передаются виджету, на котором находится фокус. Функция delta() возвращает перемещение колесика, выраженное в восьмых долях градуса. Обычно шаг работы колесика мышки составляет 15 градусов. Здесь мы перемещаемся на заданное количество отметок, модифицируя верхний элемент стека масштабов изображений, и обновляем изображение, используя refreshPixmap().
   Наиболее распространенное применение колесико мышки получило для продвижения по полосе прокрутки. При использовании нами QScrollArea (рассматривается в главе 6) с полосами прокрутки QScrollArea автоматически управляет событиями колесика мышки и нам не приходится самим переопределять функцию wheelEvent().
   Этим завершается реализация обработчиков событий. Теперь давайте рассмотрим закрытые функции.
   181 void Plotter::updateRubberBandRegion()
   182 {
   183 QRect rect = rubberBandRect.normalized();
   184 update(rect.left(), rect.top(), rect.width(), 1);
   185 update(rect.left(), rect.top(), 1, rect.height());
   186 update(rect.left(), rect.bottom(), rect.width(), 1);
   187 update(rect.right(), rect.top(), 1, rect.height());
   188 }
   Функция updateRubberBand() вызывается из mousePressEvent(), mouseMoveEvent() и mouseReleaseEvent() для стирания или перерисовки резиновой ленты. Она состоит из четырех вызовов функции update(), которая устанавливает в очередь событие рисования для четырех небольших прямоугольных областей, составляющих изображение резиновой ленты (две вертикальные и две горизонтальные линии). Для рисования резиновой ленты в Qt предусмотрен класс QRubberBand, однако в нашем случае ручное кодирование обеспечило более тонкое управление.
   189 void Plotter::refreshPixmap()
   190 {
   191 pixmap = QPixmap(size());
   192 pixmap.fill(this, 0, 0);
   193 QPainter painter(&pixmap);
   194 painter.initFrom(this);
   195 drawGrid(&painter);
   196 drawCurves(&painter);
   197 update();
   198 }
   Функция refreshPixmap() перерисовывает график на внеэкранной пиксельной карте и обновляет изображение на экране. Мы изменяем размеры пиксельной карты на размеры виджета и заполняем ее цветом стертого виджета. Этот цвет является «темным» компонентом палитры из-за вызова функции setBackgroundRole() в конструкторе Plotter. Если фон задается неоднородной кистью, в функции QPixmap::fill() необходимо указать смещение в виджете, где будет заканчиваться пиксельная карта, чтобы правильно выравнить образец кисти. Здесь пиксельная карта соответствует всему виджету, поэтому мы задаем позицию (0, 0).
   Затем мы создаем QPainter для вычерчивания диаграммы на пиксельной карте. Вызов initFrom() устанавливает в рисовальщике перо, фон и шрифт такими же, как для виджета Plotter. Затем мы вызываем функции drawGrid() и drawCurves(), которые рисуют диаграмму. В конце мы вызываем функцию update() для инициации события рисования всего виджета. Пиксельная карта копируется в виджет функцией paintEvent().
   199 void Plotter::drawGrid(QPainter *painter)
   200 {
   201 QRect rect(Margin, Margin,
   202 width() - 2 * Margin, height() - 2 * Margin);
   203 if (!rect.isValid())
   204 return;
   205 PlotSettings settings = zoomStack[curZoom];
   206 QPen quiteDark = palette().dark().color().light();
   207 QPen light = palette().light().color();
 
   208 for (int i = 0; i <= settings.numXTicks; ++i) {
   209 int x = rect.left() + (i * (rect.width() - 1)
   210 / settings.numXTicks);
   211 double label = settings.minX + (i * settings.spanX()
   212 / settings.numXTicks);
   213 painter->setPen(quiteDark);
   214 painter->drawLine(x, rect.top(), x, rect.bottom());
   215 painter->setPen(light);
   216 painter->drawLine(x, rect.bottom(), x, rect.bottom() + 5);
   217 painter->drawText(x - 50, rect.bottom() + 5, 100, 15,
   218 Qt::AlignHCenter | Qt::AlignTop,
   219 QString::number(label));
   220 }
 
   221 for (int j = 0; j <= settings.numVTicks; ++j) {
   222 int y = rect.bottom() - (j * (rect.height() - 1)
   223 / settings.numYTicks);
   224 double label = settings.minY + (j * settings.spanY()
   225 / settings.numYTicks);
   226 painter->setPen(quiteDark);
   227 painter->drawLine(rect.left(), у, rect.right(), у);
   228 painter->setPen(light);
   229 painter->drawLine(rect.left() - 5, y, rect.left(), у);
   230 painter->drawText(rect.left() - Margin, у - 10, Margin - 5, 20,
   231 Qt::AlignRight | Qt::AlignVCenter,
   232 QString::number(label));
   233 }
   234 painter->drawRect(rect.adjusted(0, 0, -1, -1));
   235 }
   Функция drawGrid() чертит сетку под кривыми и осями. Область для вычерчивания сетки задается прямоугольником rect. Если размеры виджета недостаточны для размещения графика, мы сразу возвращаем управление.
   Первый цикл for проводит вертикальные линии сетки и отметки по оси x. Второй цикл for выводит горизонтальные линии и отметки по оси y. В конце мы рисуем прямоугольники по окаймляющей кромке. Функция drawText() применяется для вывода числовых значений для отметок обеиз осей.
   Вызовы функции drawText() имеют следующий формат:
   painter.drawText(x, у, ширина, высота, смещение, текст);
   где (x, у, ширина, высота) определяют прямоугольник, смещение задает позицию текста в этом прямоугольнике и текст представляет собой выводимый текст.
   236 void Plotter::drawCurves(QPainter *painter)
   237 {
   238 static const QColor colorForIds[6] = {
   239 Qt::red, Qt::green, Qt::blue, Qt::cyan, Qt::magenta, Qt::yellow };
   240 PlotSettings settings = zoomStack[curZoom];
   241 QRect rect(Margin, Margin,
   242 width() - 2 * Margin, height() - 2 * Margin);
   243 if (!rect.isValid())
   244 return;
 
   245 painter->setClipRect(rect.adjusted(+1, +1, -1, -1));
   246 QMapIterator<int, QVector<QPointF> > i(curveMap);
   247 while (i.hasNext()) {
   248 i.next();
   249 int id = i.key();
   250 const QVector<QPointF> &data = i.value();
   251 QPolygonF polyline(data.count());
   252 for (int j = 0; j < data.count(); ++j) {
   253 double dx = data[j].x() - settings.minX;
   254 double dy = data[j].y() - settings.minY;
   255 double x = rect.left() + (dx * (rect.width() - 1)
   256 / settings.spanX());
   257 double у = rect.bottom() - (dy * (rect.height() - 1)
   258 / settings.spanY());
   259 polyline[j] = QPointF(x, у);
   260 }
   261 painter->setPen(colorForIds[uint(id) % 6]);
   262 painter->drawPolyline(polyline);
   263 }
   264 }
   Функция drawCurves() рисует кривые поверх сетки. Мы начинаем с вызова функции setClipRect для ограничения области отображения QPainter прямоугольником, содержащим кривые (без окаймляющей кромки и рамки вокруг графика). После этого QPainter будет игнорировать вывод пикселей вне этой области.
   Затем мы выполняем цикл по всем кривым, используя итератор в стиле Java, и для каждой кривой мы выполняем цикл по ее точкам QPointF. Функция key() позволяет получить идентификатор кривой, а функция value() — данные соответствующей кривой в виде вектора QVector<QPointF>. Внутри цикла for производятся преобразование всех точек QPointF из системы координат построителя графика в систему координат виджета и сохранение их в переменной polyline.
   После преобразования всех точек кривой в систему координат виджета мы устанавливаем цвет пера для кривой (используя один из наборов заранее определенных цветов) и вызываем drawPolyline() для вычерчивания линии, которая проходит по всем точкам кривой.
   Этим мы завершаем построение класса Plotter. Остается только рассмотреть несколько функций настроек графика PlotSettings.
   265 PlotSettings::PlotSettings()
   266 {
   267 minX = 0.0;
   268 maxX = 10.0;
   269 numXTicks = 5;
   270 minY = 0.0;
   271 maxY = 10.0;
   272 numYTicks = 5;
   273 }
   Конструктор PlotSettings инициализирует обе оси координат диапазоном от 0 до 10 с пятью отметками.
   274 void PlotSettings::scroll(int dx, int dy)
   275 {
   276 double stepX = spanX() / numXTicks;
   277 minX += dx * stepX;
   278 maxX += dx * stepX;
   279 double stepY = spanY() / numYTicks;
   280 minY += dy * stepY;
   281 maxY += dy *stepY;
   282 }
   Функция scroll() увеличивает (или уменьшает) minX, maxX, minY и maxY на интервал между двух отметок, помноженный на заданное число. Данная функция применяется для реализации скроллинга в функции Plotter::keyPressEvent().
   283 void PlotSettings::adjust()
   284 {
   285 adjustAxis(minX, maxX, numXTicks);
   286 adjustAxis(minY, maxY, numYTicks);
   287 }
   Функция adjust() вызывается из mouseReleaseEvent() для округления значений minX, maxX, minY и maxY, чтобы получить «удобные» значения, и определения количества меток на каждой оси. Закрытая фyнкция adjustAxis() выполняет эти действия отдельно для каждой оси.
   288 void PlotSettings::adjustAxis(double &min, double &max, int &numTiсks)
   289 {
   290 const int MinTicks = 4;
   291 double grossStep = (max - min) / MinTicks;
   292 double step = pow(10.0, floor(log10(grossStep)));
   293 if (5 * step < grossStep) {
   294 step *= 5;
   295 } else if (2* step < grossStep) {
   296 step *= 2;
   297 }
   298 numTicks = int (ceil(max / step) - floor(min / step));
   299 if (numTicks < MinTicks)
   300 numTicks = MinTicks;
   301 min = floor(min / step) * step;
   302 max = ceil(max / step) * step;
   303 }
   Функция adjustAxis() преобразует свои параметры min и max в «удобные» числа и устанавливает свой параметр numTicks на количество меток, которое, по ее расчету, подходит для заданного диапазона [min, max]. Поскольку в функции adjustAxis() фактически требуется модифицировать переменные (minX, maxX, numXTicks и так далее), а не просто копировать их, для этих параметров не используется модификатор const. Большая часть программного кода в adjustAxis() предназначена просто для определения соответствующего значения интервала между двумя метками (переменная step — шаг). Для получения на оси удобных чисел мы должнытщательно выбирать этот шаг. Например, значение шага 3.8 привело бы к появлению на оси чисел, кратных 3.8, что затрудняет восприятие диаграммы человеком. Для осей с десятичной системой обозначения «удобными» значениями шага являются числа вида 10ⁿ, 2 • 10ⁿ или 5 • 10ⁿ.
   Мы начинаем расчет с «крупного шага», то есть с определенного максимального значения шага. Затем мы находим число вида 10ⁿ, меньшее или равное крупному шагу. Мы его получаем путем взятия десятичного логарифма от крупного шага, затем округляем полученное значение до целого числа, после чего возводим 10 в степень, равную этому округленному значению. Например, если крупный шаг равен 236, мы вычисляем log 236 = 2.37291…; затем мы округляем это значение до 2 и получаем 10² = 100 в качестве кандидата на значениешага в форме числа 10ⁿ.
   После получения первого кандидата на значение шага мы можем его использовать для расчета двух других кандидатов: 2 • 10ⁿ и 5 • 10ⁿ. Для нашего примера два других кандидата являются числами 200 и 500. Кандидат 500 имеет значение большее, чем крупный шаг, и поэтому мы не можем использовать его. Но 200 меньше, чем 236, и поэтому мы можем использовать 200 в качестве размера шага в нашем примере.
   Достаточно легко получить numTicks, min и max из значения шага. Новое значение min получается путем округления снизу первоначального min до ближайшего числа, кратного этому шагу, а новое значение max получается путем округления сверху до ближайшего числа, кратного этому шагу. Новое значение numTicks представляет собой количество интервалов между округленными значениями min и max. Например, если при входе в функцию min равно 240, а max равно 1184, то новый диапазон будет равен [200, 1200] с пятью отметками.
   Этот алгоритм в некоторых случаях дает почти оптимальный результат. Более изощренный алгоритм описан в статье Поля С. Хекберта (Paul S. Heckbert) «Nice Numbers for Graph Labels» (удобные числа для меток графа), опубликованной в Graphics Gems (ISBN 0—12—286166—3).
   Данная глава является последней в части I. В ней объяснены способы настройки существующего виджета Qt и способы построения виджета с использованием в качестве основы базового класса виджетов QWidget. В главе 2 мы уже узнали, как можно построить виджет на основе существующих виджетов, и мы еще вернемся к этой теме в главе 6.
   К этому моменту у нас достаточно знаний для написания законченных приложений с графическим интерфейсом с помощью средств разработки Qt. В частях II и III мы проведем более глубокое исследование Qt, чтобы можно было в полной мере использовать возможности Qt.

   Каждому размещаемому в форме виджету необходимо задать соответствующие размер и позицию. Qt содержит несколько классов, обеспечивающих компоновку виджетов на форме: QHBoxLayout, QVBoxLayout, QGridLayout и QStackLayout. Эти классы настолько удобно и просто применять, что почти каждый Qt—разработчик их использует либо непосредственно в исходном коде программы, либо через Qt Designer.
   Другая причина применения классов Qt по компоновке виджетов — гарантия автоматической адаптации формы к различным шрифтам, языкам и платформам. Если пользователь изменяет настройки шрифта системы, формы приложения немедленно на это отреагируют, изменяя при необходимости свои размеры. И если вы переводите интерфейс пользователя приложения на другие языки, классы компоновки будут учитывать содержание переведенных виджетов, чтобы избежать усечения текста.
   К другим классам, управляющим компоновкой, относятся QSplitter, QScrollArea, QMainWindow и QWorkspace. Общая черта этих классов — обеспечение гибкой компоновки виджетов, которой может управлять пользователь. Например, QSplitter обеспечивает наличие разделительной линии, которую пользователь может передвигать для изменения размеров виджетов, a QWorkspace обеспечивает поддержку MDI (multiple document interface — многодокументный интерфейс), позволяющего в главном окне приложения показывать сразу несколько документов. Поскольку эти классы часто используются как альтернатива основным классам компоновки, они также рассматриваются в данной главе.

   Существует три основных способа управления компоновкой дочерних виджетов формы: абсолютное позиционирование, ручная компоновка и применение менеджеров компоновки. Мы рассмотрим по очереди каждый из этих методов, используя в качестве нашего примера диалоговое окно Find File (найти файл), показанное на рис. 6.1.
   Рис. 6.1. Окно диалога Find File.
   Абсолютное позиционирование является самым негибким способом компоновки виджетов. Он предусматривает жесткое кодирование в программе размеров и позиций дочерних виджетов формы и фиксированный размер самой формы. Ниже показано, какой вид принимает конструктор FindFileDialog при применении абсолютного позиционирования:
   01 FindFileDialog::FindFileDialog(QWidget *parent)
   02 : QDialog(parent)
   03 {
   04 namedLabel->setGeometry(9, 9, 50, 25);
   05 namedLineEdit->setGeometry(65, 9, 200, 25);
   06 lookInLabel->setGeometry(9, 40, 50, 25);
   07 lookInLineEdit->setGeometry(65, 40, 200, 25);
   08 subfoldersCheckBox->setGeometry(9, 71, 256, 23);
   09 tableWidget->setGeometry(9, 100, 256, 100);
   10 messageLabel->setGeometry(9, 206, 256, 25);
   11 findButton->setGeometry(271, 9, 85, 32);
   12 stopButton->setGeometry(271, 47, 85, 32);
   13 closeButton->setGeometry(271, 84, 85, 32);
   14 helpButton->setGeometry(271, 199, 85, 32);
   15 setWindowTitle(tr("Find Files or Folders"));
   16 setFixedSize(365, 240);
   17 }
   Абсолютное позиционирование имеет много недостатков:
   • пользователь не может изменить размер окна;
   • некоторый текст может оказаться отсеченным, если пользователь выбирает необычно большой шрифт или если приложение переводится на другой язык;
   • виджеты могут иметь неправильные размеры для некоторых стилей;
   • расчет позиций и размеров должен производиться вручную. Этот процесс утомителен и приводит к ошибкам; кроме того, это сильно затрудняет сопровождение.
   В качестве альтернативы абсолютному позиционированию используется ручная компоновка. При ручной компоновке виджетам все же придаются абсолютные позиции, но размеры виджетов становятся пропорциональными размеру окна, а не жестко кодируются в программе. Это может достигаться путем переопределения функции формы resizeEvent() для установки геометрических размеров своих дочерних виджетов:
   01 FindFileDialog::FindFileDialog(QWidget *parent)
   02 : QDialog(parent)
   03 {
   04 SetMinimumSize(265, 190);
   05 resize(365, 240);
   06 }
 
   07 void FindFileDialog::resizeEvent(QResizeEvent * /* event */)
   08 {
   09 int extraWidth = width() - minimumWidth();
   10 int extraHeight = height() - minimumHeight();
   11 namedLabel->setGeometry(9, 9, 50, 25);
   12 namedLineEdit->setGeometry(65, 9, 100 + extraWidth, 25);
   13 lookInLabel->setGeometry(9, 40, 50, 25);
   14 lookInLineEdit->setGeometry(65, 40, 100 + extraWidth, 25);
   15 subfoldersCheckBox->setGeometry(9, 71, 156 + extraWidth, 23);
   16 tableWidget->setGeometry(9, 100, 156 + extraWidth, 50 + extraHeight);
   17 messageLabel->setGeometry(9, 156 + extraHeight, 156 + extraWidth, 25);
   18 findButton->setGeometry(171 + extraWidth, 9, 85, 32);
   19 stopButton->setGeometry(171 + extraWidth, 47, 85, 32);
   20 closeButton->setGeometry(171 + extraWidth, 84, 85, 32);
   21 helpButton->setGeometry(171 + extraWidth, 149 + extraHeight, 85, 32);
   22 }
   Мы устанавливаем в конструкторе FindFileDialog минимальный размер формы на значение 265 × 190 и ее начальный размер на значение 365 × 240. В обработчике событий resizeEvent() мы отдаем все дополнительное пространство виджетам, размеры которых мы хотим увеличить. Это обеспечивает плавное изменение вида формы при изменении пользователем ее размеров.
   Рис. 6.2. Изменение размеров диалогового окна, допускающего изменение своих размеров.
   Точно так же, как при абсолютном позиционировании, при ручной компоновке в программе приходится жестко задавать много констант, рассчитываемых программистом. Написание подобной программы представляет собой нудное занятие, особенно если проект изменяется. И все-таки существует риск отсечения текста. Этого риска можно избежать, принимая во внимание идеальные размеры дочерних виджетов, но это еще больше усложняет программу.
   Самый удобный метод компоновки виджетов на форме — использование менеджеров компоновки Qt. Менеджеры компоновки обеспечивают осмысленные, принимаемые по умолчанию значения параметров для каждого типа виджета и учитывают идеальный размер каждого виджета, который, в свою очередь, обычно зависит от шрифта виджета, его стиля и содержимого. Менеджеры компоновки также учитывают максимальные и минимальные размеры и автоматически подстраивают компоновку в ответ на изменения шрифта, изменения содержимого и изменения размеров окна.
   Существует три наиболее важных менеджера компоновки: QHBoxLayout, QVBoxLayout и QGridLayout. Эти классы наследуют QLayout, который обеспечивает основной каркас для менеджеров компоновки. Все эти три класса полностью поддерживаются Qt Designer и могут также использоваться непосредственно в программе.
   Ниже приводится программный код FindFileDialog, в котором используются менеджеры компоновки:
   01 FindFileDialog::FindFileDialog(QWidget *parent)
   02 : QDialog(parent)
   03 {
   04 QGridLayout *leftLayout = new QGridLayout;
   05 leftLayout->addWidget(namedLabel, 0, 0);
   06 leftLayout->addWidget(namedLineEdit, 0, 1);
   07 leftLayout->addWidget(lookInLabel, 1, 0);
   08 leftLayout->addWidget(lookInLineEdit, 1, 1);
   09 leftLayout->addWidget(subfoldersCheckBox, 2, 0, 1, 2);
   10 leftLayout->addWidget(tableWidget, 3, 0, 1, 2);
   11 leftLayout->addWidget(messageLabel, 4, 0, 1, 2);
 
   12 QVBoxLayout *rightLayout = new QVBoxLayout;
   13 rightLayout->addWidget(findButton);
   14 rightLayout->addWidget(stopButtpn);
   15 rightLayout->addWidget(closeButton);
   16 rightLayout->addStretch();
   17 rightLayout->addWidget(helpButton);
 
   18 QHBoxLayout *mainLayout = new QHBoxLayout;
   19 mainLayout->addLayout(leftLayout);
   20 mainLayout->addLayout(rightLayout);
   21 setLayout(mainLayout);
   22 setWindowTitle(tr("Find Files or Folders"));
   23 }
   Компоновка обеспечивается одним менеджером компоновки по горизонтали QHBoxLayout, одним менеджером компоновки в ячейках сетки QGridLayout и одним менеджером компоновки по вертикали QVBoxLayout. Менеджер QGridLayout слева и менеджер QVBoxLayout справа размещаются рядом внутри внешнего менеджера QHBoxLayout. Кромка по периметру диалогового окна и промежуток между дочерними виджетами устанавливаются в значения по умолчанию, которые зависят от текущего стиля виджета; они могут быть изменены, если использовать функции QLayout::setMargin() и QLayout::setSpacing().
   Такое же диалоговое окно можно было бы создать с помощью визуальных средства разработки Qt Designer, задавая приблизительное положение дочерним виджетам, выделяя те, которые необходимо расположить рядом, и выбирая пункты меню Form | Lay Out Horizontally, Form | Lay Out Vertically или Form | Lay Out in a Grid. Мы использовали данный подход в главе 2 для создания диалоговых окон Go-to-Cell и Sort приложения Электронная таблица.
   Рис. 6.3. Компоновка диалогового окна Find File.
   Применение QHBoxLayout и QVBoxLayout достаточно очевидное, однако с QGridLayout дело обстоит несколько сложнее. Менеджер QGridLayout работает с двухмерной сеткой ячеек. Текстовая метка QLabel, расположенная в верхнем левом углу этого менеджера компоновки, имеет координаты (0, 0), a соответствующая строка редактирования QLineEdit имеет координаты (0, 1). Флажок QCheckBox размещается в двух столбцах; он занимает ячейки с координатами (2, 0) и (2, 1). Расположенные под ним объекты QTreeWidget и QLabel также занимают два столбца. Вызовы функции addWidget() имеют следующий формат:
   layout->addWidget(виджeт, cтpoкa, cтoлбeц, колСтрок, колСтолбцов);
   Здесь виджет является дочерним виджетом, который вставляется в менеджер компоновки, (строка, столбец) — коррдинаты верхней левой ячейки, занимаемой виджетом, колСтрок — количество строк, занимаемое виджетом, и колСтолбцов — количество столбцов, занимаемое виджетом. Если параметры колСтрок и колСтолбцов не заданы, они принимают значение по умолчанию, равное 1.
   Вызов addStretch() говорит менеджеру компоновки о необходимости выделения свободного пространства в данной точке. Добавив элемент распорки, мы заставляем менеджер компоновки выделить дополнительное пространство между кнопкой Close и кнопкой Help. B Qt Designer мы можем добиться того же самого эффекта, вставляя распорку. Распорки в Qt Designer отображаются в виде синих «пружинок».
   Помимо рассмотренных нами до сих пор случаев использование менеджеров компоновки дает дополнительные выгоды. Если мы добавляем виджет к менеджеру или убираем виджет из него, менеджер компоновки автоматически адаптируется к новой ситуации. То же самое происходит, если мы вызываем hide() или show() для дочернего виджета. Если идеальный размер дочернего виджета изменяется, компоновка автоматически перестраивается, учитывая новый идеальный размер. Кроме того, менеджеры компоновки автоматически устанавливают минимальный размер всей формы на основе минимальных размеров и идеальных размеров дочерних виджетов формы.
   В представленных до сих пор примерах мы просто помещали виджеты в менеджеры и использовали распорки для выделения дополнительного пространства. Иногда этого недостаточно для того, чтобы компоновка приняла нужный нам вид. В таких ситуациях мы можем настроить компоновку, изменяя политику размеров и идеальные размеры размещаемых виджетов.
   Политика размера виджета говорит системе компоновки, как его следует растягивать или сжимать. Qt обеспечивает разумные, принимаемые по умолчанию значения политик размеров для всех своих встроенных виджетов, но поскольку ни одно принимаемое по умолчанию значение не может учесть всевозможные варианты компоновки, все-таки обычной практикой для разработчиков является изменение политики размеров одного или двух виджетов формы. QSizePolicy имеет как горизонтальный, так и вертикальный компоненты. Ниже приводятся наиболее полезные значения:
   • Fixed (фиксированное) означает, что виджет не может увеличиваться или сжиматься. Размер виджета всегда сохраняет значение его идеального размера;
   • Minimum означает, что идеальный размер виджета является его минимальным размером. Размер виджета не может стать меньше идеального размера, но он может при необходимости вырасти для заполнения доступного пространства;
   • Maximum означает, что идеальный размер виджета является его максимальным размером. Размер виджета может уменьшаться до его минимального идеального размера;
   • Preferred (предпочитаемое) означает, что идеальный размервиджета является его предпочитаемым размером, но виджет может при необходимости сжиматься или растягиваться;
   • Expanding (расширяемый) означает, что виджет может сжиматься или растягиваться, но впервую очередь он стремится увеличить свои размеры.
   На рис. 6.4 приводится иллюстрация смысла различных политик размеров, причем в качестве примера здесь используется текстовая метка QLabel с текстом «Какой-то текст».
   На рисунке политики Preferred и Expanding представлены одинаково. Так в чем же их отличие? При изменении размеров формы, содержащей одновременно виджеты с политикой размера Preferred и Expanding, дополнительное пространство отдается виджетам Expanding, а виджеты Preferred по-прежнему будут иметь свой идеальный размер.
   Рис. 6.4. Смысл различных политик размеров.
   Существует еще две политики размеров: MinimumExpanding и Ignored. Первая была необходима в некоторых редких случаях для старых версий Qt, но теперь она не применяется; предпочтительнее использовать политику Expanding и соответствующим образом переопределить функцию minimumSizeHint(). Последняя напоминает Expanding, но при этом игнорируется идеальный размер виджета и минимальный идеальный его размер.
   Кроме горизонтального и вертикального компонентов политики размеров класс QSizePolicy хранит коэффициенты растяжения по горизонтали и вертикали. Эти коэффициенты растяжения могут использоваться для указания того, что различные дочерние виджеты могут растягиваться по-разному при расширении формы. Например, если QTreeWidget располагается над QTextEdit и мы хотим, чтобы QTextEdit был в два раза больше по высоте, чем QTreeWidget, мы можем установить коэффициент растяжения по вертикали для QTextEdit на значение 2, а тот же коэффициент для QTreeWidget — на значение 1.
   Другой способ воздействия на компоновку заключается в установке минимального размера, максимального размера или фиксированного размера дочерних виджетов. Менеджер компоновки будет учитывать эти ограничения при компоновке виджетов. Но если этого недостаточно, мы можем всегда создать подкласс дочернего виджета и переопределить функцию sizeHint() для получения необходимого нам идеального размера.

   Класс QStackedLayout (менеджер стековой компоновки) управляет компоновкой набора дочерних виджетов или «страниц», показывая в каждый конкретный момент только одну из них и скрывая от пользователя остальные. Сам менеджер QStackedLayout невидим и не содержит внутри себя средства для пользователя по изменению страницы. Показанные на рис. 6.5 небольшие стрелки и темно—серая рамка обеспечиваются Qt Designer, чтобы упростить применение этого менеджера компоновки при проектировании формы. Для удобства в Qt предусмотрен класс QStackedWidget, представляющий собой QWidget со встроенным QStackedLayout.
   Рис. 6.5. QStackedLayout.
   Страницы нумеруются с 0. Если мы хотим сделать какой-нибудь конкретный виджет видимым, мы можем вызвать функцию setCurrentIndex(), задавая номер страницы. Номер страницы дочернего виджета можно получить с помощью функции indexOf().
   Рис. 6.6. Две страницы диалогового окна Preferences.
   Показанное на рис. 6.6 диалоговое окно Preferences (настройка предпочтений) представляет собой пример использования QStackedLayout. Окно диалога состоит из виджета QListWidget слева и менеджера стековой компоновки QStackedLayout справа. Каждый элемент в списке QListWidget соответствует одной странице QStackedLayout. Ниже приводится соответствующий программный код конструктора этого диалогового окна:
   01 PreferenceDialog::PreferenceDialog(QWidget *parent)
   02 : QDialog(parent)
   03 {
   04 listWidget = new QListWidget;
   05 listWidget->addItem(tr("Web Browser"));
   06 listWidget->addItem(tr("Mail & News"));
   07 listWidget->addItem(tr("Advanced"));
   08 listWidget->addItem(tr("Appearance"));
 
   09 stackedLayout = new QStackedLayout;
   10 stacked Layout->addWidget(appearancePage);
   11 stackedLayout->addWidget(webBrowserPage);
   12 stackedLayout->addWidget(mailAndNewsPage);
   13 stackedLayout->addWidget(advancedPage);
 
   14 connect(listWidget, SIGNAL(currentRowChanged(int)).
   15 stackedLayout, SLOT(setCurrentIndex(int)));
   16 listWidget->setCurrentRow(0);
   17 }
   Мы создаем QListWidget и заполняем его названиями страниц. Затем мы создаем QStackedLayout и вызываем для каждой страницы функцию addWidget(). Мы связываем сигнал спискового виджета currentRowChanged(int) с setCurrentIndex(int) менеджера стековой компоновки для переключения страниц и вызываем функцию спискового виджета setCurrentRow() в конце конструктора, чтобы начать со страницы 0.
   Подобные формы также очень легко создавать при помощи Qt Designer.
   1. Создайте новую форму на основе шаблона «Dialog» или «Widget».
   2. Добавьте в форму виджеты QListWidget и QStackedWidget.
   3. Заполните каждую страницу дочерними виджетами и менеджерами компоновки. (Для создания новой страницы нажмите на правую кнопку мышки и выберите пункт меню Insert Page (вставить страницу); для перехода с одной страницы на другую щелкните по маленькой левой или правой стрелке, расположенной в верхнем правом углу виджета QStackedWidget.)
   4. Расположите виджеты рядом, используя менеджер горизонтальной компоновки.
   5. Подсоедините сигнал виджета списка элементов currentRowChanged(int) к слоту стекового виджета setCurrentIndex(int).
   6. Установите значение свойства виджета списка элементов currentRow на 0.
   Поскольку мы реализовали переключение страниц с помощью предварительно определенных сигналов и слотов, диалоговое окно будет правильно работать при предварительном просмотре в Qt Designer.

   Разделитель QSplitter представляет собой виджет, который содержит другие виджеты. Виджеты в разделителе отделены друг от друга разделительными линиями. Пользователи могут изменять размеры дочерних виджетов разделителя посредством перемещения разделительных линий. Разделители могут часто использоваться в качестве альтернативы менеджерам компоновки, предоставляя пользователю больше возможностей по управлению компоновкой.
   Рис. 6.7. Приложение Splitter.
   Дочерние виджеты QSplitter автоматически располагаются рядом (или один под другим) в порядке их создания, причем между соседними виджетами размещаются разделительные линии. Ниже приводится программный код для создания представленного на рис. 6.7 окна:
   01 int main(int argc, char *argv[])
   02 {
   03 QApplication app(argc, argv);
   04 QTextEdit *editor1 = new QTextEdit;
   05 QTextEdit *editor2 = new QTextEdit;
   06 QTextEdit *editor3 = new QTextEdit;
   07 QSplitter splitter(Qt::Horizontal);
   08 splitter.addWidget(editor1);
   09 splitter.addWidget(editor2);
   10 splitter.addWidget(editor3);
   11 splitter.show();
   12 return app.exec();
   13 }
   Этот пример состоит из трех полей редактирования QTextEdit, расположенных горизонтально в виджете QSplitter. В отличие от менеджеров компоновки, которые просто размещают в форме дочерние виджеты, а сами не имеют визуального представления, QSplitter наследует QWidget и может использоваться как любой другой виджет.
   Рис. 6.8. Виджеты приложения Splitter.
   Можно обеспечить сложную компоновку путем применения вложенных горизонтальных и вертикальных разделителей QSplitter. Например, показанное на рис. 6.9 приложение Mail Client (почтовый клиент) состоит из горизонтального QSplitter, который содержит справа от себя вертикальный QSplitter.
   Рис. 6.9. Приложение Mail Client в системе Mac OS X.
   Ниже приводится программный код конструктора подкласса QMainWindow приложения Mail Client:
   01 MailClient::MailClient()
   02 {
   03 …
   04 rightSplitter = new QSplitter(Qt::Vertical);
   05 rightSplitter->addWidget(messagesTreeWidget);
   06 rightSplitter->addWidget(textEdit);
   07 rightSplitter->setStretchFactor(1, 1);
   08 mainSplitter = new QSplitter(Qt::Horizontal);
   09 mainSplitter->addWidget(foldersTreeWidget);
   10 mainSplitter->addWidget(rigntSplitter);
   11 mainSplitter->setStretchFactor(1, 1);
   12 setCentralWidget(mainSplitter);
   13 setWindowTitle(tr("Mail Client"));
   14 readSettings();
   15 }
   После создания трех виджетов, которые мы собираемся выводить на экран, мы создаем вертикальный разделитель rightSplitter и добавляем два виджета, которые мы собираемся отображать справа. Затем мы создаем горизонтальный разделитель mainSplitter и добавляем виджет, который мы хотим отображать слева, и rightSplitter, виджеты которого мы хотим показывать справа. Мы делаем mainSplitter центральным виджетом QMainWindow.
   Когда пользователь изменяет размер окна, QSplitter обычно распределяет пространство таким образом, что относительные размеры дочерних виджетов остаются прежними. В примере приложения Mail Client нам не нужен такой режим работы; вместо этого мы хотим, чтобы QTreeWidget и QTableWidget сохраняли свои размеры, и мы хотим отдавать любое дополнительное пространство полю редактирования QTextEdit. Это достигается с помощью двух вызовов функции setStretchFactor(). В первом аргументе задается индекс дочернего виджета разделителя (индексация начинается с нуля), а во втором аргументе — коэффициент растяжения; по умолчанию используется 0.
   Рис.6.10. Индексация разделителя в приложении Mail Client.
   Первый вызов setStretchFactor() делаем для rightSplitter, устанавливая виджет в позицию 1 (textEdit) и коэффициент растяжения на 1. Второй вызов setStretcnFactor() делаем для mainSplitter, устанавливая виджет в позицию 1 (rightSplitter) и коэффициент растяжения на 1. Это обеспечивает получение всего дополнительного пространства полем редактирования textEdit.
   При запуске приложения разделитель QSplitter задает дочерним виджетам соответствующие размеры на основе их первоначального размера (или на основе их идеального размера, если начальный размер не указан). Мы можем передвигать разделительные линии программно, вызывaя фyнкцию QSplitter::setSizes(). Класс QSplitter предоставляет также средство сохранения своего состояния и его восстановления при следующем запуске приложения. Ниже приводится функция writeSettings(), которая сохраняет настройки Mail Client:
   01 void MailClient::writeSettings()
   02 {
   03 QSettings settings("Software Inc.", "Mail Client");
   04 settings.beginGroup("mainWindow");
   05 settings.setValue("size", size());
   06 settings.setValue("mainSplitter", mainSplitter->saveState());
   07 settings.setValue("rightSplitter", rightSplitter->saveState());
   08 settings.endGroup();
   09 }
   Ниже приводится соответствующая функция по чтению настроек readSettings():
   01 void MailClient::readSettings()
   02 {
   03 QSettings settings("Software Inc.", "Mail Client");
   04 settings.beginGroup("mainWindow");
   05 resize(settings.value("size", QSize(480, 360)).toSize());
   06 mainSplitter->restoreState(
   07 settings.value("mainSplitter").toByteArray());
   08 rightSplitter->restoreState(
   09 settings.value("rightSplitter").toByteArray());
   10 settings.endGroup();
   11 }
   Разделитель QSplitter полностью поддерживается Qt Designer. Для размещения виджетов в разделителе поместите дочерние виджеты приблизительно в то место, где они должны находиться, выделите их и выберите пункт меню Form | Lay Out Horizontally in Splitter или Form | Lay Out Vertically in Splitter (Форма | Компоновка no roризонтали в разделитель или Форма | Компоновка по вертикали в разделитель).

   Класс QScrollArea содержит область отображения, которую можно прокручивать, и две полосы прокрутки. Если мы хотим добавить в виджет полосы прокрутки, значительно проще использовать класс QScrollArea, чем создавать свои собственные экземпляры QScrollBar и самим реализовывать функциональность скроллинга.
   Рис. 6.11. Виджеты, составляющие область с прокруткой QScrollArea.
   Способ применения QScrollArea состоит в следующем: вызывается функция setWidget() с виджетом, к которому мы хотим добавить полосы прокрутки. QScrollArea автоматически делает этот виджет дочерним (если он еще не является таковым) по отношению к области отображения (он доступен при помощи функции QScrollArea::viewport()). Например, если мы хотим иметь полосы прокрутки вокруг виджета IconEditor, который мы разработали в главе 5, мы можем написать такую программу:
   01 int main(int argc, char *argv[])
   02 {
   03 QApplication app(argc, argv);
   04 IconEditor *iconEditor = new IconEditor;
   05 iconEditor->setIconImage(QImage(":/images/mouse.png"));
   06 QScrollArea scrollArea;
   07 scrollArea.setWidget(iconEditor);
   08 scrollArea.viewport()->setBackgroundRole(QPalette::Dark);
   09 scrollArea.viewport()->setAutoFillBackground(true);
   10 scrollArea.setWindowTitle(QObject::tr("Icon Editor"));
   11 scrollArea.show();
   12 return app.exec();
   13 }
   Рис. 6.12. Изменение размеров области с прокруткой QScrollArea.
   QScrollArea при отображении виджета использует его текущий или идеальный размер, если размеры виджета еще ни разу не изменялись. Делая вызов setWidgetResizable(true), мы указываем QScrollArea на необходимость автоматического изменения размеров виджета, чтобы можно было воспользоваться любым дополнительным пространством за пределами его идеальных размеров.
   По умолчанию полосы прокрутки видны на экране только в том случае, когда область отображения меньше дочернего виджета. Мы можем сделать полосы прокрутки постоянно видимыми при помощи установки следующих политик полос прокрутки:
   scrollArea.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
   scrollArea.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
   QScrollArea большую часть своей функциональности наследует от QAbstractScrollArea. Такие классы, как QTextEdit и QAbstractItemView (базовый класс для классов отображения элементов в Qt), являются производными от QAbstractScrollArea, поэтому нам не надо для них формировать оболочку из QScrollArea для получения полос прокрутки.

   Прикрепляемыми являются виджеты, которые могут крепиться к определенным областям главного окна приложения QMainWindow или быть независимыми «плавающими» окнами. QMainWindow имеет четыре области крепления таких виджетов: одна сверху, одна снизу, одна слева и одна справа от центрального виджета. В таких приложениях, как Microsoft Visual Studio и Qt Linguist, широко используются прикрепляемые окна для обеспечения очень гибкого интерфейса пользователя. В Qt прикрепляемые виджеты представляют собой экземпляры класса QDockWidget.
   Каждый прикрепляемый виджет имеет свой собственный заголовок, даже когда он прикреплен. Пользователи могут перемещать прикрепляемые окна с одного места крепления на другое, передвигая полосу заголовка. Они могут также отсоединять прикрепляемое окно от области крепления и сделать его независимым плавающим окном, располагая прикрепляемое окно вне областей крепления. Свободные плавающие прикрепляемые окна всегда находятся «поверх» их главного окна. Пользователи могут закрыть QDockWidget, щелкая по кнопке закрытия, расположенной в заголовке виджета. Любые комбинации этих возможностей можно отключать с помощью вызова QDockWidget::setFeatures().
   Рис. 6.13. QMainWindow с прикрепленным виджетом.
   В ранних версиях Qt панели инструментов рассматривались как прикрепляемые виджеты, использующие те же самые области крепления. Начиная с Qt 4 панели инструментов размещаются в собственных областях, расположенных по периметру центрального виджета (как показано на рис. 6.14), и они не могут открепляться. Если требуется иметь плавающую панель инструментов, можно просто поместить ее внутрь QDockWindow.
   Рис. 6.14. Области крепления виджетов и области панелей инструментов QMainWindow.
   Углы, обозначенные пунктирными линиями, могут принадлежать обеим соседним областям крепления. Например, мы могли бы верхний левый угол назначить левой области крепления с помощью вызова QMainWindow::setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea).
   Следующий фрагмент программного кода показывает, как для существующего виджета (в данном случае для QTreeWidget) можно оформить оболочку в виде QDockWidget и вставить ее в правую область крепления:
   QDockWidget *shapesDockWidget = new QDockWidget(tr("Shapes"));
   shapesDockWidget->setWidget(treeWidget);
   shapesDockWidget->setAllowedAreas(Qt::LeftDockWidgetArea
    | Qt::RightDockWidgetArea);
   addDockWidget(Qt::RightDockWidgetArea, shapesDockWidget);
   В вызове setAllowedAreas() задаются допустимые области крепления прикрепляемого окна. В нашем случае мы позволяем пользователю перетаскивать прикрепляемое окно только в левую или правую область крепления, где имеется достаточно пространства по вертикали для его нормального отображения. Если допустимые области не задаются явно, пользователь может перетаскивать прикрепляемое окно в любую из четырех областей.
   Ниже приводится фрагмент из конструктора подкласса QMainWindow, который показывает, как можно создавать панель инструментов, содержащую QComboBox, QSpinBox и несколько кнопок QToolButton:
   QToolBar *fontToolBar = new QToolBar(tr("Font"));
   fontToolBar->addWidget(familyComboBox);
   fontToolBar->addWidget(sizeSpinBox);
   fontToolBar->addAction(boldAction);
   fontToolBar->addAction(italicAction);
   fontToolBar->addAction(underlineAction);
   fontToolBar->setAllowedAreas(Qt::TopToolBarArea
    | Qt::BottomToolBarArea);
   addToolBar(fontToolBar);
   Если мы хотим сохранять позиции всех прикрепляемых виджетов и панелей инструментов, чтобы иметь возможность их восстановления при следующем запуске приложения, мы можем написать почти такой же программный код, как для сохранения состояния разделителя QSplitter, используя функции класса QMainWindow saveState() и restoreState():
   01 void MainWindow::writeSettings()
   02 {
   03 QSettings settings("Software Inc.", "Icon Editor");
   04 settings.beginGroup("mainWindow");
   05 settings.setValue("size", size());
   06 settings.setValue("state", saveState());
   07 settings.endGroup();
   08 }
 
   09 void MainWindow::readSettings()
   10 {
   11 QSettings settings("Software Inc.", "Icon Editor");
   12 settings.beginGroup("mainWindow");
   13 resize(settings.value("size").toSize());
   14 restoreState(settings.value("state").toByteArray());
   15 settings.endGroup();
   16 }
   Наконец, QMainWindow обеспечивает контекстное меню, в котором представлены все прикрепляемые окна и панели инструментов. Используя это меню, пользователь может закрывать и восстанавливать прикрепляемые окна и панели инструментов.
   Рис. 6.15. Контекстное меню QMainWindow.

   Приложения, которые обеспечивают работу со многими документами в центральной области главного окна, называются приложениями с многодокументным интерфейсом или MDI—приложениями. В Qt MDI—приложения создаются с использованием в качестве центрального виджета класса QWorkspace и путем представления каждого документа в виде дочернего окна QWorkspace.
   Обычно MDI—приложения содержат пункт главного меню Windows (окна) с командами по управлению окнами и их списком. Активное окно отмечается галочкой. Пользователь может сделать любое окно активным, щелкая по его названию в меню Windows.
   В данном разделе для демонстрации способов создания приложения с интерфейсом MDI и способов реализации его меню Windows мы разработаем MDI—приложение Editor (редактор), показанное на рис. 6.16.
   Рис. 6.16. MDI—приложение Editor.
   Это приложение состоит из двух классов: MainWindow и Editor. Его программный код находится на компакт-диске, и поскольку большая часть его либо совпадает, либо очень похожа на программный код приложения Электронная таблица из части I, здесь мы представим только новый программный код.
   Рис. 6.17. Меню MDI—приложения Editor.
   Давайте начнем с класса MainWindow.
   01 MainWindow::MainWindow()
   02 {
   03 workspace = new QWorkspace;
   04 setCentralWidget(workspace);
   05 connect(workspace, SIGNAL(windowActivated(QWidget *)),
   06 this, SLOT(updateMenus()));
   07 createActions();
   08 createMenus();
   09 createToolBars();
   10 createStatusBar();
   11 setWindowTitle(tr("MDI Editor"));
   12 setWindowIcon(QPixmap(":/images/icon.png"));
   13 }
   В конструкторе MainWindow мы создаем виджет QWorkspace и делаем его центральным виджетом. Мы связываем сигнал windowActivated() класса QWorkspace со слотом, который мы будем использовать для обеспечения актуального состояния меню Window.
   01 void MainWindow::newFile()
   02 {
   03 Editor *editor = createEditor();
   04 editor->newFile();
   05 editor->show();
   06 }
   Слот newFile() соответствует пункту меню File | New. Он зависит от закрытой функции createEditor(), создающей дочерний виджет Editor.
   01 Editor *MainWindow::createEditor()
   02 {
   03 Editor *editor = new Editor;
   04 connect(editor, SIGNAL(copyAvailable(bool)),
   05 cutAction, SLOT(setEnabled(bool)));
   06 connect(editor, SIGNAL(copyAvailable(bool)),
   07 copyAction, SLOT(setEnabled(bool)));
   08 workspace->addWindow(editor);
   09 windowMenu->addAction(editor->windowMenuAction());
   10 windowActionGroup->addAction(editor->windowMenuAction());
   11 return editor;
   12 }
   Функция createEditor() создает виджет Editor и устанавливает два соединения «сигнал—слот». Эти соединения обеспечивают включение или выключение пунктов меню Edit | Cut и Edit | Copy в зависимости от наличия выделенной области текста.
   Поскольку мы используем интерфейс MDI, может оказаться, что работа будет вестись одновременно с несколькими виджетами Editor. На это надо обратить внимание, поскольку мы заинтересованы в ответе на сигнал copyAvailable(bool), поступающий только от активного окна редактора Editor, но не от других окон. Но эти сигналы могут порождаться только активным окном, поэтому это практически не составляет проблему.
   После настройки Editor мы добавляем QAction для представления окна в меню Window. Это действие обеспечивается классом Editor, который мы скоро рассмотрим. Мы также добавляем это действие в объект QActionGroup. QActionGroup гарантирует, что в любой момент времени оказывается отмеченной только одна строка меню Window.
   01 void MainWindow::open()
   02 {
   03 Editor *editor = createEditor();
   04 if (editor->open()) {
   05 editor->show();
   06 } else {
   07 editor->close();
   08 }
   09 }
   Функция open() соответствует пункту меню File | Open. Этот пункт меню создает Editor для нового документа и вызывает функцию open() для Editor. Имеет смысл выполнять файловые операции в классе Editor, а не в классе MainWindow, поскольку каждый Editor требует поддержки своего собственного состояния.
   Если функция open() завершится неудачей, мы просто закроем редактор, поскольку пользователь уже будет уведомлен об ошибке. Мы не обязаны сами явно удалять объект Editor; это происходит автоматически при условии установки атрибута виджета Qt::WA_DeleteOnClose, что и делается в конструкторе Editor.
   01 void MainWindow::save()
   02 {
   03 if (activeEditor()) {
   04 activeEditor()->save();
   05 }
   06 }
   Слот save() вызывает функцию Editor::save() для активного редактора, если таковой имеется. И снова программный код по выполнению реальной работы находится в классе Editor.
   01 Editor *MainWindow::activeEditor()
   02 {
   03 return qobject_cast<Editor *>(workspace->activeWindow());
   04 }
   Закрытая функция activeEditor() возвращает активное дочернее окно в виде указателя типа Editor или нулевой указатель при отсутствии такого окна.
   01 void MainWindow::cut()
   02 {
   03 if (activeEditor())
   04 activeEditor()->cut();
   05 }
   Слот cut() вызывает функцию Editor::cut() для активного редактора. Мы не приводим слоты copy(), paste() и del(), потому что они имеют такой же вид.
   01 void MainWindow::updateMenus()
   02 {
   03 bool hasEditor = (activeEditor() != 0);
   04 bool hasSelection = activeEditor()
   05 && activeEditor()->textCursor().hasSelection();
   06 saveAction->setEnabled(hasEditor);
   07 saveAsAction->setEnabled(hasEditor);
   08 pasteAction->setEnabled(hasEditor);
   09 cutAction->setEnabled(hasSelection);
   10 copyAction->setEnabled(hasSelection);
   11 closeAction->setEnabled(hasEditor);
   12 closeAllAction->setEnabled(hasEditor);
   13 tileAction->setEnabled(hasEditor);
   14 cascadeAction->setEnabled(hasEditor);
   15 nextAction->setEnabled(hasEditor);
   16 previousAction->setEnabled(hasEditor);
   17 separatorAction->setVisible (hasEditor);
   18 if (activeEditor())
   19 activeEditor()->windowMenuAction()->setChecked(true);
   20 }
   Слот updateMenus() вызывается всякий раз, когда окно становится активным (и когда закрывается последнее окно) для обновления системы меню благодаря помещенному нами в конструктор MainWindow соединению «сигнал—слот».
   Большинство пунктов меню имеет смысл при существовании активного окна, поэтому мы их отключаем при отсутствии активного окна. В конце мы вызываем setChecked() для QAction, представляющего активное окно. Благодаря использованию QActionGroup нам не требуется явно сбрасывать флажок предьщущего активного окна.
   01 void MainWindow::createMenus()
   02 {
   03 windowMenu = menuBar()->addMenu(tr("&Window"));
   04 windowMenu->addAction(closeAction);
   05 windowMenu->addAction(closeAllAction);
   06 windowMenu->addSeparator();
   07 windowMenu->addAction(tileAction);
   08 windowMenu->addAction(cascadeAction);
   09 windowMenu->addSeparator();
   10 windowMenu->addAction(nextAction);
   11 windowMenu->addAction(previousAction);
   12 windowMenu->addAction(separatorAction);
   13 }
   Закрытая функция createMenus() заполняет меню Window командами. Здесь используются типичные для такого рода меню команды, и они легко реализуются с применением слотов closeActiveWindow(), closeAllWindows(), tile() и cascade() класса QWorkspace. Всякий раз, когда пользователь открывает новое окно, в меню Window добавляется список действий. (Это делается в функции createEditor(), которую мы видели.) При закрытии пользователем окна редактора соответствующий ему пункт в меню Window удаляется (поскольку его владельцем является это окно редактора), т.е. пункт меню удаляется из меню Window автоматически.
   01 void MainWindow::closeEvent(QCloseEvent *event)
   02 {
   03 workspace->closeAllWindows();
   04 if (activeEditor()) {
   05 event->ignore();
   06 } else {
   07 event->accept();
   08 }
   09 }
   Функция closeEvent() переопределяется для закрытия всех дочерних окон, обеспечивая получение всеми дочерними виджетами сигнала о возникновении события закрытия. Если один из дочерних виджетов «игнорирует» свое событие закрытия (прежде всего из-за того, что пользователь нажал кнопку отмены при выдаче соответствующего сообщения о «несохраненных изменениях»), мы игнорируем событие закрытия для MainWindow; в противном случае мы принимаем его, и в результате Qt закрывает окно. Если бы мы не переопределили функцию closeEvent() в MainWindow, у пользователя не было бы никакой возможности сохранения ни одного из несохраненных изменений.
   Теперь мы закончили наш обзор MainWindow, и поэтому мы можем перейти к реализации класса Editor. Класс Editor представляет одно дочернее окно. Он наследует QTextEdit, который обеспечивает функциональность текстового редактора. Точно так же, как любой виджет, который может использоваться в качестве автономного окна, он может использоваться и в качестве дочернего окна в рабочем пространстве интерфейса MDI.
   Ниже приводится определение класса:
   01 class Editor : public QTextEdit
   02 {
   03 Q_OBJECT
   04 public:
   05 Editor(QWidget *parent = 0);
   06 bool openFile(const QString &fileName);
   07 bool save();
   08 bool saveAs();
   09 void newFile();
   10 bool open();
 
   11 protected:
   12 QSize sizeHint() const;
   13 QAction *windowMenuAction() const { return action; }
   14 void closeEvent(QCloseEvent *event);
   15 private slots:
   16 void documentWasModified();
 
   17 private:
   18 bool okToContinue();
   19 bool saveFile(const QString &fileName);
   20 void setCurrentFile(const QString &fileName);
   21 bool readFile(const QString &fileName);
   22 bool writeFile(const QString &fileName);
   23 QString strippedName(const QString &fullFileName);
   24 QString curFile;
   25 bool isUntitled;
   26 QString fileFilters;
   27 QAction *action;
   28 }
   Присутствующие в классе MainWindow приложения Электронная таблица четыре закрытые функции имеются также в классе Editor: okToContinue(), saveFile(), setCurrentFile() и strippedName().
   01 Editor::Editor(QWidget *parent)
   02 : QTextEdit(parent)
   03 {
   04 action = new QAction(this);
   05 action->setCheckable(true);
   06 connect(action, SIGNAL(triggered()), this, SLOT(show()));
   07 connect(action, SIGNAL(triggered()), this, SLOT(setFocus()));
   08 isUntitled = true;
   09 fileFilters = tr("Text files (*.txt)\nAll files (*)");
   10 connect(document(), SIGNAL(contentsChanged()),
   11 this, SLOT(documentWasModified()));
   12 setWindowIcon(QPixmap(":/images/document.png"));
   13 setAttribute(Qt::WA_DeleteOnClose);
   14 }
   Сначала мы создаем действие QAction, представляющее редактор в меню приложения Window, и связываем его со слотами show() и setFocus().
   Поскольку мы разрешаем пользователям создавать любое количество окон редактора, мы должны предусмотреть соответствующую систему их наименования, чтобы они отличались до первого их сохранения. Один из распространенных методов решения этой проблемы заключается в назначении имен с числами (например, document1.txt). Мы используем переменную isUntitled, чтобы отличить предоставляемые пользователем имена документов и сгенерированные программно.
   Мы связываем сигнал текстового документа contentsChanged() c закрытым слотом documentWasModified(). Этот слот просто вызывает setWindowModified(true).
   Наконец, мы устанавливаем атрибут Qt::WA_DeleteOnClose для предотвращения утечек памяти при закрытии пользователем окна Editor.
   После выпрлнения конструктора мы ожидаем вызова либо функции newFile(), либо функции open().
   01 void Editor::newFile()
   02 {
   03 static int documentNumber = 1;
   04 curFile = tr("document%1.txt").arg(documentNumber);
   05 setWindowTitle(curFile + "[*]");
   06 action->setText(curFile);
   07 isUntitled = true;
   08 ++documentNumber;
   09 }
   Функция newFile() генерирует для нового документа имя типа document1.txt. Этот программный код помещен в функцию newFile(), a не в конструктор, поскольку мы не хотим использовать числа при вызове функции open() для открытия существующего документа во вновь созданном редакторе Editor. Поскольку переменная documentNumber объявлена как статическая, она совместно используется всеми экземплярами Editor.
   Маркер «[*]» в заголовке окна указывает место, где мы хотим выдавать звездочку при несохраненных изменениях файла для платформ, отличных от Mac OS X. Мы рассматривали этот маркер в главе 3.
   01 bool Editor::open()
   02 {
   03 QString fileName = QFileDialog::getOpenFileName(
   04 this, tr("Open"), fileFilters);
   05 if(fileName.isEmpty())
   06 return false;
   07 return openFile(fileName);
   08 }
   Функция open() пытается открыть сущеcтвующий файл при помощи функции openFile().
   01 bool Editor::save()
   02 {
   03 if (isUntitled) {
   04 return saveAs();
   05 } else {
   06 return saveFile(curFile);
   07 }
   Функция save() используёт переменную isUntitled для определения вида вызываемой функции saveFile() или saveAs().
   01 void Editor::closeEvent(QCloseEvent *event)
   02 {
   03 if (okToContinue()) {
   04 event->accept();
   05 } else {
   06 event->ignore();
   07 }
   08 }
   Функция closeEvent() переопределяется, чтобы разрешить пользователю сохранить несохраненные изменения. Вся логика содержится в функции okToContinue(), которая выводит сообщение «Do you want to save your changes?» (Сохранить изменения?). Если функция okToContinue() возвращает true, мы обрабатывам событие закрытия; в противном случае мы «игнорируем» его и окно оставляем прежним.
   01 void Editor::setCurrentFile(const QString &fileName)
   02 {
   03 curFile = fileName;
   04 isUntitled = false;
   05 action->setText(strippedName(curFile));
   06 document()->setModified(false);
   07 setWindowTitle(strippedName(curFile) + "[*]");
   08 setWindowModified(false);
   09 }
   Функция setCurrentFile() вызывается из openFile() и saveFile() для обновления переменных curFile и isUntitled, установки текста заголовка окна и пункта меню, а также для установки значения флажка модификации документа на false. Всякий раз, когда пользователь изменяет текст в редакторе, объект базового класса QTextDocument генерирует сигнал contentsChanged() и устанавливает свой внутренний флажок модификации на значение true.
   01 QSize Editor::sizeHint() const
   02 {
   03 return QSize(72 * fontMetrics().width('x'),
   04 25 * fontMetrics().lineSpacing());
   05 }
   Функция sizeHint() возвращает размер, рассчитанный на основе ширины буквы «x» и высоты строки текста. QWorkspace использует идеальный размер в качестве начального размера окна.
   Ниже приводится файл main.cpp MDI—приложения Editor:
   01 #include <QApplication>
   02 #include "mainwindow.h"
   03 int main(int argc, char *argv[])
   04 {
   05 QApplication app(argc, argv);
   06 QStringList args = app.arguments();
   07 MainWindow mainWin;
   08 if (args.count() > 1) {
   09 for (int i = 1; i < args.count(); ++i)
   10 mainWin.openFile(args[i]);
   11 } else {
   12 mainWin.newFile();
   13 }
   14 mainWin.show();
   15 return app.exec();
   16 }
   Еслй пользователь задает в командной строке какие-нибудь файлы, мы пытаемся их загрузить, в противном случае мы начинаем работу с пустым документом. Такие характерные для Qt опции командной строки, как —style и —font (стиль и шрифт), автоматически убираются из списка аргументов конструктором QApplication. Поэтому, если мы напишем в командной строке
   mdieditor -style motif readme.txt
   QApplication::arguments() возвратит QStringList с двумя элементами («mdieditor» и «readme.txt»), а МDI—приложение Editor запустится с документом readme.txt.
   Интерфейс MDI представляет собой один из способов работы одновременно со многими документами. В системе MacOS Х более предпочтителен подход, связанный с применением нескольких окон верхнего уровня. Этот подход рассматривается в разделе «Работа со многими документами» главы З.

   События генерируются оконной системой или Qt в ответ на различные действия. Когда пользователь нажимает или отпускает клавишу или кнопку мышки, генерируется событие клавиши клавиатуры или кнопки мышки; когда окно впервые выводится на экран, генерируется событие рисования, указывая появившемуся окну на необходимость его прорисовки. Большинство событий генерируются в ответ на действия пользователя, но некоторые события, например, события таймера, генерируются самой системой и не зависят от действий пользователя.
   При программировании в Qt нам редко приходится думать о событиях, поскольку виджеты Qt сами генерируют сигналы в ответ на любое существенное событие. События становятся полезными при создании нами своих сооственных виджетов, или когда мы хотим модифицировать поведение существующих виджетов Qt.
   События не следует путать с сигналами. Как правило, сигналы полезны при uспользовании виджета, в то время как события полезны при реализации виджета. Например, при применении кнопки QPushButton мы больше заинтересованы в ее сигнале clicked(), чем в обработке низкоуровневых событий мышки или клавиатуры, сгенерировавших этот сигнал. Но если мы реализуем такой класс, как QPushButton, нам необходимо написать программный код для обработки событий мышки и клавиатуры и при необходимости сгенерировать сигнал clicked().

   В Qt событие (event) — это объект, производный от QEvent. Qt обрабатывает более сотни типов событий, каждое из которых идентифицируется определенным значением перечисления. Например, QEvent::type() возвращает QEvent::MouseButtonPress для событий нажатия кнопки мышки.
   Для событий многих типов недостаточно тех данных, которые могут храниться в простом объекте QEvent: например, для событий нажатия кнопки мышки необходимо иметь информацию о том, какая кнопка мышки привела к возникновению данного события, а также о том, где находился курсор мышкй в момент возникновения события. Эта дополнительная информация хранится в определенных подклассах QEvent, например, в QMouseEvent.
   События уведомляют объекты о себе при помощи своих функций event(), унаследованных от класса QObject. Реализация event() в QWidget передает большинство обычных событий конкретным обработчикам событий, например mousePressEvent(), keyPressEvent() и paintEvent().
   Мы уже ознакомились в предыдущих главах со многими обработчиками событий при реализации MainWindow, IconEditor и Plotter. Существует много других типов событий, приводимых в справочной документации по QEvent, и можно также самому создавать и генерировать события. В данной главе мы рассмотрим два распространенных типа событий, заслуживающих более детального обсуждения, а именно события клавиатуры и события таймера.
   События клавиатуры обрабатываются путем переопределения функций keyPressEvent() и keyReleaseEvent(). Виджет Plotter переопределяет keyPressEvent(). Обычно нам требуется переопределить только keyPressEvent(), поскольку отпускание клавиш важно только для клавиш—модификаторов, то есть для клавиш Ctrl, Shift и Alt, а их можно проконтролировать в keyPressEvent() при помощи функции QKeyEvent::modifiers(). Например, если бы нам пришлось реализовывать виджет CodeEditor (редактор программного кода), общий вид его функции keyPressEvent() с различной обработкой клавиш Home и Ctrl+Home был бы следующим:
   01 void CodeEditor::keyPressEvent(QKeyEvent *event)
   02 {
   03 switch (event->key()) {
   04 case Qt::Key_Home:
   05 if (event->modifiers() & Qt::ControlModifier) {
   06 goToBeginningOfDocument();
   07 } else {
   08 goToBeginningOfLine();
   09 }
   10 break;
   11 case Qt::Key_End:
   12 …
   13 default:
   14 QWidget::keyPressEvent(event);
   15 }
   16 }
   Клавиши Tab и Backtab (Shift+Tab) представляют собой особый случай. Они обрабатываются функцией QWidget::event() до вызова keyPressEvent() c установкой фокуса на следующий или предыдущий виджет в фокусной цепочке. Обычно нам нужен именно такой режим работы, но в виджете CodeEditor мы, возможно, предпочтем использовать клавишу табуляции Tab для обеспечения отступа в начале строки. Переопределение функции event() выглядело бы следующим образом:
   01 bool CodeEditor::event(QEvent *event)
   02 {
   03 if (event->type() == QEvent::KeyFress) {
   04 QKeyEvent *keyEvent = static_cast<QKeyEvent *>event;
   05 if (keyEvent->key() == Qt::Key_Tab) {
   06 insertAtCurrentPosition('\t');
   07 return true;
   08 }
   09 }
   10 return QWidget::event(event);
   11 }
   Если событие сгенерировано нажатием клавиши клавиатуры, мы преобразуем объект типа QEvent в QKeyEvent и проверяем, какая клавиша была нажата. Если это клавиша Tab, мы выполняем некоторую обработку и возвращаем true, чтобы уведомить Qt об обработке нами события. Если бы мы вернули false, Qt передала бы cобытие родительскому виджету.
   Высокоуровневый метод обработки клавиш клавиатуры заключается в применении класса QAction. Например, если goToBeginningOfLine() и goToBeginningOfDocument() являются открытыми слотами виджета CodeEditor и CodeEditor применяется в качестве центрального виджета класса MainWindow, мы могли бы обеспечить обработку клавиш при помощи следующего программного кода:
   01 MainWindow::MainWindow()
   02 {
   03 editor = new CodeEditor;
   04 setCentralWidget(editor);
   05 goToBeginningOfLineAction =
   06 new QAction(tr("Go to Beginning of Line"), this);
   07 goToBeginningOfLineAction->setShortcut(tr("Home"));
   08 connect(goToBeginningOfLineAction, SIGNAL(activated()),
   09 editor, SLOT(goToBeginningOfLine()));
   10 goToBeginningOfDocumentAction =
   11 new QAction(tr("Go to Beginning of Document"), this);
   12 goToBeginningOfDocumentAction->setShortcut(tr("Ctrl+Home"));
   13 connect(goToBeginningOfDocumentAction, SlGNAL(activated()),
   14 editor, SLOT(goToBeginningOfDocument());
   15 …
   16 }
   Это позволяет легко добавлять команды в меню или в панель инструментов, что мы видели в главе 3. Если команды не отображаются в интерфейсе пользователя, объект QAction можно заменить объектом QShortcut; этот класс используется в QAction для связывания клавиши клавиатуры со своим обработчиком.
   По умолчанию связывание клавиши в виджете, выполненное с использованием QAction или QShortcut, будет постоянно действовать, пока активно окно, содержащее этот виджет. Это можно изменить с помощью вызова QAction::setShortcutContext() или QShortcut::setContext().
   Другим распространенным типом события является событие таймера. Если большинство других событий возникают в результате действий пользователя, то события таймера позволяют приложениям выполнять какую-то обработку через определенные интервалы времени. События таймера могут использоваться для реализации мигающих курсоров и другой анимации или просто для обновления экрана.
   Для демонстрации событий таймера мы реализуем виджет Ticker. Этот виджет отображает текстовый баннер, который сдвигается на один пиксель влево через каждые 30 миллисекунд. Если виджет шире текста, последний повторяется необходимое число раз и заполняет виджет по всей его ширине.
   Рис. 7.1. Виджет Ticker.
   Ниже приводится заголовочный файл:
   01 #ifndef TICKER_H
   02 #define TICKER_H
   03 #include <QWidget>
 
   04 class Ticker : public QWidget
   05 {
   06 Q_OBJECT
   07 Q_PROPERTY(QString text READ text WRITE setText)
 
   08 public:
   09 Ticker(QWidget *parent = 0);
   10 void setText(const QString &newText);
   11 QString text() const { return myText; }
   12 QSize sizeHint() const;
 
   13 protected:
   14 void paintEvent(QPaintEvent *event);
   15 void timerEvent(QTimerEvent *event);
   16 void showEvent(QShowEvent *event);
   17 void hideEvent(QHideEvent *event);
 
   18 private:
   19 QString myText;
   20 int offset;
   21 int myTimerId;
   22 };
   23 #endif
   Мы переопределяем в Ticker четыре обработчика событий, с тремя из которых мы до сих пор не встречались: timerEvent(), showEvent() и hideEvent().
   Теперь давайте рассмотрим реализацию:
   01 #include <QtGui>
   02 #include "ticker.h"
   03 Ticker::Ticker(QWidget *parent)
   04 : QWidget(parent)
   05 {
   06 offset = 0;
   07 myTimerId = 0;
   08 }
   Конструктор инициализирует смещение offset значением 0. Координата x начала вывода текста рассчитывается на основе значения offset. Таймер всегда имеет ненулевой идентификатор, поэтому мы используем 0, показывая, что таймер еще не запущен.
   09 void Ticker::setText(const QString &newText)
   10 {
   11 myText = newText;
   12 update();
   13 updateGeometry();
   14 }
   Функция setText() ycтaнaвливaeт oтoбpaжaeмый тeкcт. Oнa вызывaeт update() для выдачи запроса на перерисовку и updateGeometry() для уведомления всех менеджеров компоновки, содержащих виджет Ticker, об изменении идеального размера.
   15 QSizeTicker::sizeHint() const
   16 {
   17 return fontMetrics().size(0, text());
   18 }
   Функция sizeHint() возвращает в качестве идеального размера виджета размеры области, занимаемой текстом. Функция QWidget::fontMetrics() возвращает объект QFontMetrics, который можно использовать для получения информации относительно шрифта виджета. В данном случае мы определяем размер заданного текста. (В первом аргументе функции QFontMetrics::size() задается флажок, который не нужен для простых строк, поэтому мы просто передаем 0.)
   19 void Ticker::paintEvent(QPaintEvent * /* event */)
   20 {
   21 QPainter painter(this);
   22 int textWidth = fontMetrics().width(text());
   23 if (textWidth < 1)
   24 return;
   25 int х= -offset;
   26 while (x < width()) {
   27 painter.drawText(x, 0, textWidth, height(),
   28 Qt::AlignLeft | Qt::AlignVCenter, text());
   29 x += textWidth;
   30 }
   31 }
   Функция paintEvent() отображает текст при помощи функции QPainter::drawText(). Она использует функцию fontMetrics() для определения размера области, занимаемой текстом по горизонтали, и затем выводит текст столько раз, сколько необходимо для заполнения виджета по всей его ширине, учитывая значение смещения offset.
   32 void Ticker::showEvent(QShowEvent * /* event */)
   33 {
   34 myTimerId = startTimer(30);
   35 }
   функция showEvent() запускает таймер. Вызов QObject::startTimer() возвращает число—идентификатор, которое мы можем использовать позже для идентификации таймера. QObject поддерживает несколько независимых таймеров, каждый из которых использует свой временной интервал. После вызова функции startTimer() Qt генерирует событие таймера приблизительно через каждые 30 миллисекунд, причем точность зависит от базовой операционной системы.
   Мы могли бы функцию startTimer() вызвать в конструкторе Ticker, но мы экономим некоторые ресурсы за счет генерации Qt событий таймера только в тех случаях, когда виджет действительно видим.
   36 void Ticker::timerEvent(QTimerEvent *event)
   37 {
   38 if (event->timerId() == myTimerId) {
   39 ++offset;
   40 if (offset >= fontMetrics().width(text()))
   41 offset= 0;
   42 scroll(-1, 0);
   43 } else {
   44 QWidget::timerEvent(event);
   45 }
   46 }
   Функция timerEvent() вызывается системой в соответствующие моменты времени. Она увеличивает смещение offset на 1 для имитации движения по всей области вывода текста. Затем она перемещает содержимое виджета на один пиксель влево при помощи фyнкции QWidget::scroll(). Вполне достаточно было бы вызывать функцию update() вместо scroll(), но вызов функции scroll() более эффективен, потому что она просто перемещает существующие на экране пиксели и генерирует событие рисования для открывшейся области виджета (которая в данном случае представляет собой полосу шириной в один пиксель).
   Если событие таймера не относится к нашему таймеру, мы передаем его дальше в наш базовый класс.
   47 void Ticker::hideEvent(QHideEvent * /* event */)
   48 {
   49 killTimer(myTimerId);
   50 }
   Функция hideEvent() вызывает QObject::killTimer() для остановки таймера.
   События таймера являются низкоуровневыми событиями, и если нам необходимо иметь несколько таймеров, это может усложнить отслеживание всех идентификаторов таймеров. В таких ситуациях обычно легче создавать для каждого таймера объект QTimer. QTimer генерирует через заданный временной интервал сигнал timeout(). QTimer также обеспечивает удобный интерфейс для однократных таймеров (то есть таймеров, которые срабатывают только один раз).

   Одним из действительно эффективных средств в модели событий Qt является возможность с помощью некоторого экземпляра объекта QObject контролировать события другого экземпляра объекта QObject еще до того, как они дойдут до последнего.
   Предположим, что наш виджет CustomerInfoDialog состоит из нескольких редакторов строк QLineEdit и мы хотим использовать клавишу Space (пробел) для передачи фокуса следующему QLineEdit. Такой необычный режим работы может оказаться полезным для разработки, предназначенной для собственных нужд, и когда пользователи имеют навык работы в таком режиме. Простое решение заключается в создании подкласса QLineEdit и переопределении фyнкции keyPressEvent() для вызова focusNextChild(), и оно выглядит следующим образом:
   01 void MyLineEdit::keyPressEvent(QKeyEvent *event)
   02 {
   03 if (event->key()== Qt::Key_Space) {
   04 focusNextChild();
   05 } else {
   06 QLineEdit::keyPressEvent(event);
   07 }
   08 }
   Этот подход имеет один основной недостаток: если мы используем в форме несколько различных видов виджетов (например, QComboBox и QSpinBox), мы должны также создать их подклассы для обеспечения единообразного поведения. Лучшее решение заключается в перехвате виджетом CustomerInfoDialog событий нажатия клавиш клавиатуры своих дочерних виджетов и в обеспечении необходимого поведения в его программном коде. Это можно сделать при помощи фильтров событий. Настройка фильтров событий сострит из двух этапов:
   1. Зарегистрируйте объект—перехватчик с целевым объектом посредством вызова функции installEventFilter() для целевого объекта.
   2. Выполните обработку событий целевого объекта в функции eventFilter() перехватчика.
   Регистрацию объекта контроля удобно выполнять в конструкторе CustomerInfoDialog:
   01 CustomerInfoDialog::CustomerInfoDialog(QWidget *parent)
   02 : QDialog(parent)
   03 {
   04 firstNameEdit->installEventFilter(this);
   05 lastNameEdit->installEventFilter(this);
   06 cityEdit->installEventFilter(this);
   07 phoneNumberEdit->installEvehtFilter(this);
   08 }
   После регистрации фильтра события те из них, которые посылаются виджетам firstNameEdit, lastNameEdit, cityEdit и phoneNumberEdit, сначала будут переданы функции eventFilter() виджета CustomerInfoDialog и лишь затем дойдут по своему прямому назначению. (Если для одного объекта установлено несколько фильтров событий, они вызываются по очереди, начиная с установленного последним и последовательно возвращаясь к первому.)
   Ниже приводится функция eventFilter(), которая перехватывает события:
   01 bool CustomerInfoDialog::eventFilter(QObject *target, QEvent *event)
   02 {
   03 if (target == firstNameEdit || target == lastNameEdit
   04 || target == cityEdit || target == phoneNumberEdit) {
   05 if (event->type() == QEvent::KeyPress) {
   06 QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
   07 if (keyEvent->key() == Qt::Key_Space) {
   08 focusNextChild();
   09 return true;
   10 }
   11 }
   12 }
   13 return QDialog::eventFilter(target, event);
   14 }
   Во-первых, мы проверяем, является ли целевой виджет строкой редактирования QLineEdit. Если событие вызвано нажатием клавиши клавиатуры, мы преобразуем его тип в QKeyEvent и проверяем, какая клавиша нажата. Если нажата клавиша пробела Space, мы вызываем функрию focusNextChild() для перехода фокуса на следующий виджет в фокусной цепочке и возвращаем true для уведомления Qt о завершении нами обработки события. Если бы мы вернули false, Qt отослала бы событие по его прямому назначению,что привело бы к вставке лишнего пробела в строку редактирования QLineEdit.
   Если целевым виджетом не является QLineEdit или если событие не вызвано нажатием клавиши Space, мы передаем управление функции базового класса eventFilter(). Целевым виджетом мог бы быть также некоторый виджет, базовый класс которого QDialog осуществляет контроль. (В Qt 4.1 этого не происходит с QDialog. Однако другие классы виджетов в Qt, например QScrollArea, контролируют по различным причинам некоторые свои дочерние виджеты.)
   Qt предусматривает пять уровней обработки и фильтрации событий:
   1. Мы можем переопределять конкретный обработчик событий.
   Переопределение таких обработчиков событий, как mousePressEvent(), keyPressEvent() и paintEvent(), представляет собой очень распространенный способ обработки событий. Мы уже видели много примеров такой обработки.
   2. Мы можем переопределять функцию QObject::event().
   Путем переопределения функции event() мы можем обрабатывать события до того, как они дойдут до обработчиков соответствующих событий. Этот подход очень хорош для изменения принятого по умолчанию поведения клавиши табуляции Tab, что было показано ранее. Он также используется для обработки редких событий, для которых не предусмотрены отдельные обработчики событий (например, QEvent::HoverEnter). При переопределении функции event() нам необходимо вызывать функцию базового класса event() для обработки тех событий, которые мы сами не обрабатываем.
   3. Мы можем устанавливать фильтр событий для отдельного объекта QObject.
   После регистрации объекта с помощью функции installEventFilter() все события целевого объекта сначала передаются функции контролирующего объекта eventFilter(). Если для одного объекта установлено несколько фильтров, они действуют поочередно, начиная с того, который установлен последним, и кончая тем, который установлен первым.
   4. Мы можем устанавливать фильтр событий для объекта QApplication.
   После регистрации фильтра для qApp (уникальный объект типа QApplication) каждое событие каждого объекта приложения передается функции eventFilter() до его передачи любым другим фильтрам событий. Этот подход очень удобен для отладки. Он может также использоваться для обработки событий мышки, посылаемых для отключенных виджетов, которые обычно отклоняются QApplication.
   5. Мы можем создать подкласс QApplication и переопределить функцию notify().
   Qt вызывает QApplication::notify() для генерации события. Переопределение этой функции представляет собой единственный способ получения доступа ко всем событиям до того, как ими займутся фильтры событий. Пользоваться фильтрами событий, как правило, удобнее, поскольку параллельно может существовать любое количество фильтров событий и только одна функция notify().
   События многих типов, в том числе события мышки и клавиатуры, могут передаваться дальше по системе объектов приложения. Если событие не было обработано ни на пути к целевому объекту, ни самим целевым объектом, процесс обработки события повторяется, но теперь в качестве нового целевого объекта используется родительский объект. Этот процесс продолжается, управление передается от одного родительского объекта к другому до тех пор, пока либо событие не будет обработано, либо не будет достигнут объект самого верхнего уровня.
   Рис. 7.2. Передача события в диалоговом окне.
   На рис. 7.2 показано, как событие нажатия клавиши пересылается в диалоговом окне от дочернего объекта к родительскому. Когда пользователь нажимает клавишу на клавиатуре, сначала событие передается виджету, на котором установлен фокус — в данном случае это расположенный в нижнем правом углу флажок QCheckBox. Если QCheckBox не обрабатывает это событие, Qt передает его объекту QGroupBox и в конце концов объекту QDialog.

   Когда мы вызываем QApplication::exec(), тем самым начинаем цикл обработки событий Qt. При запуске пpилoжeния Qt генерирует несколько событий для отображения на экране виджетов. После этого начинает выполняться цикл обработки событий: постоянно проверяется их возникновение, и эти события отправляются к объектам QObject данного приложения.
   Во время обработки события могут генерироваться другие события, которые ставятся в конец очереди событий Qt. Если слишком много времени уходит на обработку одного события, интерфейс пользователя становится невосприимчивым к действиям пользователя. Например, любые сгенерированные оконной системой события во время сохранения файла на диск не будут обрабатываться до тех пор, пока весь файл не будет записан. В ходе записи файла приложение не будет отвечать на запросы оконной системы на перерисовку приложения.
   Одно из решений заключается в применении многопоточной обработки: один процесс для работы с интерфейсом пользователя приложения и другой процесс для выполнения операции сохранения файла (или любой другой длительной операции). В этом случае интерфейс пользователя приложения сможет реагировать на события в процессе выполнения операции сохранения файла. Мы рассмотрим способы обеспечения такого режима работы в главе 18.
   Более простое решение заключается в выполнении частых вызовов функции QApplication::processEvents() в программном коде сохранения файла. Данная функция говорит Qt о необходимости обработки ожидающих в очереди событий и затем возвращает управление вызвавшей ее функции. Фактически функция QApplication::exec() представляет собой не более чем вызов функции processEvents() в цикле while.
   Ниже приводится пример того, как мы можем сохранить работоспособность интерфейса пользователя при помощи функции processEvents(), причем за основу взят программный код сохранения файла в приложении Spreadsheet:
   01 bool Spreadsheet::writeFile(const QString &fileName)
   02 {
   03 QFile file(fileName);
   04 …
   05 for (int row = 0; row < RowCount; ++row) {
   06 for (int column = 0; column < ColumnCount; ++column) {
   07 QString str = formula(row, column);
   08 if (!str.isEmpty())
   09 out << quint16(row) << quint16(column) << str;
   10 }
   11 qApp->processEvents();
   12 }
   13 return true;
   14 }
   При использовании этого метода существует опасность того, что пользователь может закрыть главное окно во время выполнения операции сохранения файла или даже выбрать повторно File | Save, что приведет к непредсказуемому результату. Наиболее простое решение заключается в замене вызова
   qApp->processEvents();
   на вызов
   qApp->processEvents(QEventLoop::ExcludeUserInputEvents);
   который указывает Qt на необходимость игнорирования событий мышки и клавиатуры.
   Часто нам хочется показывать индикатор состояния процесса QProgressDialog в ходе выполнения продолжительной операции. QProgressDialog имеет полоску индикатора, информирующую пользователя о ходе выполнения операции приложением. QProgressDialog также содержит кнопку Cancel, которая позволяет пользователю прекратить выполнение операции. Ниже приводится программный код, применяющий данный подход при сохранении файла приложения Электронная таблица:
   01 bool Spreadsheet::writeFile(const QString &fileName)
   02 {
   03 QFile file(fileName);
   04 …
   05 QProgressDialog progress(this);
   07 progress.setLabelText(tr("Saving %1").arg(fileName));
   08 progress.setRange(0, RowCount);
   09 progress.setModal(true);
   10 for (int row = 0; row < RowCount; ++row) {
   11 progress.setValue(row);
   12 qApp->processEvents();
   13 if (progress.wasCanceled()) {
   14 file.remove();
   15 return false;
   16 }
   17 for (int column = 0; column < ColumnCount; ++column) {
   18 QString str = formula(row, column);
   19 if (!str.isEmpty())
   20 out << quint16(row) << quint16(column) << str;
   21 }
   22 }
   23 return true;
   24 }
   Мы создаем QProgressDialog, в котором RowCount является общим количеством шагов. Затем при обработке каждой строки мы вызываем функцию setValue() для обновления состояния индикатора. QProgressDialog автоматически вычисляет процент завершения операции путем деления текущего значения индикатора на общее количество шагов. Мы вызываем функцию QApplication::processEvents() для обработки любых событий перерисовки либо нажатия пользователем кнопки мышки или клавиши клавиатуры (например, чтобы разрешить пользователю нажимать кнопку Cancel). Если пользователь нажимает кнопку Cancel, мы прекращаем операцию сохранения файла и удаляем файл.
   Мы не вызываем для QProgressDialog функцию show(), так как индикатор состояния сам делает это. Если оказывается так, что операция выполняется быстро, прежде всего из-за малого размера файла или высокого быстродействия компьютера, QProgressDialog обнаружит это и вообще не станет выводить себя на экран.
   Кроме многопоточности и применения QProgressDialog существует совершенно другой способ работы с продолжительными операциями. Вместо выполнения заданной обработки сразу по поступлении запроса пользователя мы можем отложить эту обработку до момента перехода приложения в состояние ожидания. Этим способом можно пользоваться в тех случаях, когда обработку можно легко прерывать и затем возобновлять, поскольку мы не можем предсказать, как долго приложение будет в состоянии ожидания.
   В Qt этот подход можно реализовать путем применения 0—миллисекундного таймера. Таймеры этого типа paботают при отсутствии ожидающих событий. Ниже приводится пример реализации функции timerEvent(), которая демонстрирует обработку в состоянии ожидании:
   01 void Spreadsheet::timerEvent(QTimerEvent *event)
   02 {
   03 if(event->timerId() == myTimerId) {
   04 while (step < MaxStep &&
   05 !qApp->hasPendingEvents()) {
   06 performStep(step);
   07 ++step;
   08 }
   09 } else {
   10 QTableWidget::timerEvent(event);
   11 }
   12 }
   Если фyнкция hasPendingEvents() возвращает true, мы останавливаем процесс и передаем управление обратно Qt. Этот процесс будет возобновлен после обработки Qt всех своих ожидающих событий.

   Основу используемых в Qt средств графики 2D составляет класс QPainter (рисовальщик Qt). Этот класс может использоваться для рисования геометрически фигур (точек, линий, прямоугольников, эллипсов, дуг, сегментов и секторов окружности, многоугольников и кривых Безье), а также пиксельных карт, изображений и текста. Кроме того, QPainter поддерживает такие продвинутые функции, как сглаживание линий (antialiasing) при начертании фигур и букв в тексте, альфа—смешение (alpha blending), плавный переход цветов (gradient filling) и цепочки графических элементов (vector paths). QPainter также поддерживает преобразование координат, что делает графику 2D независимой от разрешающей способности.
   QPainter может использоваться для вычерчивания на таких «устройствах рисования», как QWidget, QPixmap или QImage. QPainter удобно применять, когда мы программируем пользовательские виджеты или классы пользовательских графических элементов с особым внешним видом и режимом работы. Класс QPainter можно также использовать совместно с QPrinter для вывода графики на печатающее устройство и для генерации файлов PDF. Это значит, что во многих случаях мы можем использовать тот же самый программный код при отображении данных на экран и при получении напечатанных отчетов.
   В качестве альтернативы классам QPainter можно использовать OpenGL. OpenGL является стандартной библиотекой графических средств 2D и 3D. Модуль QtOpenGL позволяет очень легко интегрировать OpenGL в приложения Qt.

   Чтобы начать рисовать на устройстве рисования (обычно это виджет), мы просто создаем объект QPainter и передаем ему указатель на устройство. Например:
   void MyWidget::paintEvent(QPaintEvent *event)
   {
    QPainter painter(this);
    …
   }
   Мы можем рисовать различные фигуры, используя функции QPainter вида draw…(). На рис 8.1 приведены наиболее важные из них.
   Рис. 8.1. Часто используемые функции draw…() рисовальщика QPainter.
   Параметры настройки QPainter влияют на режим рисования. Некоторые из них устанавливаются на параметры настройки устройства, а другие инициализируются значениями по умолчанию. Тремя основными параметрами настройки рисовальщика являются перо, кисть и шрифт:
   • Перо используется для отображения прямых линий и контуров фигур. Оно имеет цвет, толщину, стиль линии, стиль окончания линии и стиль соединения линий.
   • Кисть представляет собой шаблон, который используется для заполнения геометрических фигур. Он обычно имеет цвет и стиль, но может также представлять собой текстуру (пиксельную карту, повторяющуюся бесконечно) или цветовой градиент.
   • Шрифт используется для отображения текста. Шрифт имеет много атрибутов, в том числе название и размер.
   Эти настройки можно в любое время модифицировать при помощи функций setPen(), setBrush() и setFont(), вызываемых для объектов QPen, QBrush или QFont.
   Рис. 8.2. Стили окончания линий и стили соединения линий.
   Рис. 8.3. Стили пера.
   Рис. 8.4. Определенные в Qt стили кисти.
 
   Рис. 8.5. Примеры геометрических фигур.
   Давайте рассмотрим несколько примеров. Ниже приводится программный код для вычерчивания эллипса, показанного на рис. 8.5 (а):
   QPainter painter(this);
   painter.setRenderHint(QPainter::Antialiasing, true);
   painter.setPen(QPen(Qt::black, 12, Qt::DashDotLine, Qt::RoundCap));
   painter.setBrush(QBrush(Qt::green, Qt::SolidPattern));
   painter.drawEllipse(80, 80, 400, 240);
   Вызов setRenderHint() включает режим сглаживания линий, указывая QPainter на необходимость использования по краям цветов различной интенсивности, чтобы уменьшить визуальное искажение, которое обычно заметно, когда края фигуры представляются пикселями. В результате края воспринимаются более ровными на тех платформах и устройствах, которые поддерживают эту функцию.
   Ниже приводится программный код для вычерчивания сектора эллипса, показанного на рис. 8.5 (б):
   QPainter painter(this);
   painter.setRenderHint(QPainter::Antialiasing, true);
   painter.setPen(QPen(Qt::black, 15, Qt::SolidLine, Qt::RoundCap, Qt::MiterJoin));
    painter.setBrush(QBrush(Qt::blue, Qt::DiagCrossPattern));
   painter.drawPie(80, 80, 400, 240, 60 * 16, 270 * 16);
   Два последних аргумента функции drawPie() задаются в шестнадцатых долях градуса.
   Ниже приводится программный код для вычерчивания кривой Безье третьего порядка, показанной на рис. 8.5 (в):
   QPainter painter(this);
   painter.setRenderHint(QPainter::Antialiasing, true);
   QPainterPath path;
   path.moveTo(80, 320);
   path.cubicTo(200, 80, 320, 80, 480, 320);
   painter.setPen(QPen(Qt::black, 8));
   painter.drawPath(path);
   Класс QPainterPath может определять произвольные фигуры векторной графики, соединяя друг с другом основные графические элементы: прямые линии, эллипсы, многоугольники, дуги, кривые Безье второго и третьего порядка и другие цепочки графических элементов рисовальщика (painter paths). Такие цепочки являются законченными элементарными рисунками в том смысле, что любая фигура или любая комбинация фигур может быть представлена в виде некоторой цепочки графических элементов.
   Цепочка графических элементов определяет контур, а область внутри контура можно заполнить какой-нибудь кистью. В примере, представленном на рис. 8.5 (в), мы не задавали кисть, поэтому нарисован только контур.
   В трех представленных выше примерах используются встроенные шаблоны кисти (Qt::SolidPattern, Qt::DiagCrossPattern и Qt::NoBrush). В современных приложениях градиентные заполнители являются популярной альтернативой однородным заполнителям. Цветовые градиенты основаны на интерполяции цветов, обеспечивающей сглаженные переходы между двумя или более цветами. Они часто применяются для получения эффекта трехмерности изображения, например стиль Plastique использует цветовые градиенты при воспроизведении кнопок QPushButton.
   Qt поддерживает три типа цветовых градиентов: линейный, конический и радиальный. В примере таймера духовки, который приводится в следующем разделе, в одном виджете используется комбинация всех трех типов градиентов для того, чтобы изображение выглядело реалистически.
   Рис. 8.6. Кисти QPainter с цветовыми градиентами.
   • Линейные градиенты определяются двумя контрольными точками и рядом «цветовых отметок» на линии, соединяющей эти точки. Например, линейный градиент на рис. 8.6 создан при помощи следующего программного кода:
   QLinearGradient gradient(50, 100, 300, 350);
   gradient.setColorAt(0.0, Qt::white);
   gradient.setColorAt(0.2, Qt::green);
   gradient.setColorAt(1.0, Qt::black);
   Мы задали три цвета в трех разных позициях между двумя контрольными точками. Позиции представляются в виде чисел с плавающей точкой в диапазоне между 0 и 1, где 0 соответствует первой контрольной точке, а 1 — последней контрольной точке. Цвет между этими позициями интерполируется.
   • Радиальные градиенты определяются центральной точкой (х_с, у_с), радиусом r и точкой фокуса (x_f, y_f), которая дополняет цветовые метки. Центральная точка и радиус определяют окружность. Изменение цвета распространяется во все стороны из точки фокуса, которая может совпадать с центральной точкой или может быть любой другой точкой внутри окружности.
   • Конические градиенты определяются центральной точкой (х_с, у_с) и углом α. Изменение цвета распространяется вокруг центральной точки подобно перемещению секундной стрелки часов.
   До сих пор мы говорили о настройках пера, кисти и шрифта рисовальщика. QPainter имеет другие параметры настройки, влияющие на способ рисования фигур и текста:
   • Кисть фона (background brush) используется для заполнения фона геометрических фигур (то есть под шаблоном кисти), текста или пиксельной карты, когда в качестве режима отображения фона задан Qt::OpaqueMode (непрозрачный режим) (по умолчанию используется режим Qt::TransparentMode — прозрачный).
   • Исходная точка кисти (brush origin) задает точку начала отображения шаблона кисти, в качестве которой обычно используется точка верхнего левого угла виджета.
   • Границы области рисования (clip region) определяют область рисования устройства. Операции рисования, которые выходят за пределы этой области, игнорируются.
   • Область отображения, окно и универсальная матрица преобразования (viewport, window и world matfix) определяют способ перевода логических координат QPainter в физические координаты устройства рисования. По умолчанию системы логических и физических координат совпадают. Системы координат рассматриваются в следующем разделе.
   • Режим композиции (composition mode) определяет способ взаимодействия новых выводимых пикселей с пикселями, уже присутствующими на устройстве рисования. По умолчанию используется режим «source over», при котором новые пиксели рисуются поверх существующих. Этот режим поддерживается только определенными устройствами, и он рассматривается позже в данной главе.
   В любой момент времени мы можем сохранить в стеке текущее состояние рисовальщика, вызывая функцию save(), и восстановить его позже, вызывая функцию restore(). Это может быть полезно, если требуется временно изменить некоторые параметры настройки рисовальщика и затем их восстановить в прежние значения, как мы это увидим в следующем разделе.

   В используемой по умолчанию координатной системе рисовальщика QPainter точка (0, 0) находится в левом верхнем углу устройства рисования; значение координат x увеличивается при перемещении вправо, а значение координат у увеличивается при перемещении вниз. Каждый пиксель занимает область 1 × 1 в координатной системе, применяемой по умолчанию.
   Необходимо помнить об одной важной особенности: центр пикселя имеет «полупиксельные» координаты. Например, пиксель в верхнем левом углу занимает область между точками (0, 0) и (1, 1), а его центр находится в точке (0.5, 0.5). Если мы просим QPainter нарисовать пиксель, например, в точке (100, 100), его координаты будут смещены на величину +0.5 по обоим направлениям, и в результате нарисованный пиксель будет иметь центр в точке (100.5, 100.5).
   На первый взгляд эта особенность представляет лишь теоретический интерес, однако она имеет важные практические последствия. Во-первых, смещение +0.5 действует только при отключении сглаживания линий (режим по умолчанию); если режим сглаживания линий включен и мы пытаемся нарисовать пиксель черного цвета в точке (100, 100), QPainter фактически выведет на экран четыре светло-серых пикселя в точках (99.5, 99.5), (99.5, 100.5), (100.5, 99.5) и (100.5, 100.5), чтобы создалось впечатление расположения пикселя точно в точке соприкосновения всех этих четырех пикселей. Если этот эффект нежелателен, его можно избежать, указывая полупиксельные координаты, например (100.5, 100.5).
   При начертании таких фигур, как линии, прямоугольники и эллипсы, действуют аналогичные правила. На рис 8.7 показано, как изменяется результат вызова drawRect(2, 2, 6, 5) в зависимости от ширины пера, когда сглаживание линий отключено. В частности, важно отметить, что прямоугольник 6 × 5, вычерчиваемый пером с шириной 1, фактически занимает область размером 7 × 6. Это не делалось прежними инструментальными средствами, в том числе в ранних версиях Qt, но такой подход существенен для получения действительно масштабируемой, независимой от разрешающей способности векторной графики.
   Рис. 8.7. Вычерчивание прямоугольника 6 × 5 при отсутствии сглаживания линий.
   Теперь, когда мы ознакомились с используемой по умолчанию координатной системой, мы можем внимательно рассмотреть возможные ее изменения при использовании рисовальщиком QPainter области отображения, окна и универсальной матрицы преобразования. (В данном контексте термин «окно» не является обозначением окна виджета верхнего уровня, а термин «область отображения» никак нe связан с областью отображения QScrollArea.)
   Термины «область отображения» и «окно» сильно связаны друг с другом. Область отображения является произвольным прямоугольником, заданным в физических координатах. Окно определяет такой же прямоугольник, но в логических координатах. При рисовании мы задаем координаты точек в логической системе координат, и эти координаты с помощью линейного алгебраического преобразования переводятся в физическую систему координат на основе текущих настроек связи «окно—область отображения».
   По умолчанию область отображения и окно устанавливаются на прямоугольную область устройства рисования. Например, если этим устройством является виджет размером 320 × 200, область отображения и окно представляют собой одинаковый прямоугольник 320 × 200, верхний левый угол которого располагается в позиции (0, 0). В данном случае системы логических и физических координат совпадают.
   Механизм «окно—область отображения» удобно применять для создания программного кода, который не будет зависеть от размера или разрешающей способности устройства рисования. Например, если мы хотим обеспечить логические координаты в диапазоне от (—50, —50) до (+50, +50) с (0, 0) в середине, мы можем задать окно следующим образом:
   painter.setWindow(-50, -50, 100, 100):
   Пара аргументов (—50, —50) задает начальную точку, а пара аргументов (100, 100) задает ширину и высоту. Это означает, что точка с логическими координатами (—50, —50) теперь соответствует точке с физическими координатами (0, 0), а точка с логическими координатами (+50, +50) соответствует точке с физическими координатами (320, 200). В этом примере мы не изменяли область отображения.
   Рис. 8.8. Преобразование логических координат в физические координаты.
   Теперь очередь дошла до универсальной матрицы преобразования. Эта матрица используется как дополнение к преобразованию «окно—область отображения». Она позволяет нам перемещать начало координат, изменять масштаб, поворачивать и обрезать графические элементы. Например, если бы нам понадобилось отобразить текст под углом 45°, мы бы использовали такой программный код:
   QMatrix matrix;
   matrix.rotate(45.0);
   painter.setMatrix(matrix);
   painter.drawText(rect, Qt::AlignCenter, tr("Revenue"));
   Логические координаты, которые мы передаем функции drawText(), преобразуются при помощи универсальной матрицы и затем переводятся в физические координаты, используя связь «окно—область отображения».
   Если мы задаем несколько преобразований, они осуществляются в порядке поступления. Например, если мы хотим использовать точку (10, 20) в качестве точки поворота, мы можем перенести начало координат окна, выполнить поворот и затем сделать обратный перенос начала координат окна, устанавливая его в прежнее положение.
   QMatrix matrix;
   matrix.translate(-10.0, -20.0);
   matrix.rotate(45.0);
   matrix.translate(+10.0, +20.0);
   painter.setMatrix(matrix);
   painter.drawText(rect, Qt::AlignCenter, tr("Revenue"));
   Более удобно осуществлять преобразования путем применения соответствующих функций класса QPainter — translate(), scale(), rotate() и shear():
   painter.translate(-10.0, -20.0);
   painter.rotate(45.0);
   painter.translate(+10.0, +20.0);
   painter.drawText(rect, Qt::AlignCenter, tr("Revenue"));
   Но если мы хотим регулярно делать одни и те же преобразования, то они будут выполняться более эффективно при их хранении в объекте QMatrix и затем применении универсальной матрицы преобразования для рисовальщика всякий раз, когда требуется выполнить преобразование.
   Рис. 8.9. Виджет OvenTimer.
   Для иллюстрации преобразования рисовальщика мы рассмотрим программный код виджета OvenTimer (таймер духовки), показанного на рис. 8.9. Виджет OvenTimer имитирует кухонные таймеры, которые широко использовались до того, как в духовках стали применяться встроенные часы. Пользователь может повернуть ручку и установить требуемую длительность. Диск переключателя автоматически поворачивается против часовой стрелки, пока не достигнет отметки 0, в результате чего OvenTimer генерирует сигнал timeout().
   01 class OvenTimer : public QWidget
   02 {
   03 Q_OBJECT
   04 public:
   05 OvenTimer(QWidget *parent = 0);
   06 void setDuration(int secs);
   07 int duration() const;
   08 void draw(QPainter *painter);
   09 signals:
   10 void timeout();
   11 protected:
   12 void paintEvent(QPaintEvent *event);
   13 void mousePressEvent(QMouseEvent *event);
   14 private:
   15 QDateTime finishTime;
   16 QTimer *updateTimer;
   17 QTimer *finishTimer;
   18 }
   Класс OvenTimer наследует QWidget и переопределяет две виртуальные функции: paintEvent() и mousePressEvent().
   const double DegreesPerMinute = 7.0;
   const double DegreesPerSecond = DegreesPerMinute / 60;
   const int MaxMinutes = 45;
   const int MaxSeconds = MaxMinutes * 60;
   const int UpdateInterval = 1;
   Мы начнем с нескольких констант, управляющих внешним видом и режимом работы таймера духовки.
   01 OvenTimer::OvenTimer(QWidget *parent)
   02 : QWidget(parent)
   03 {
   04 finishTime = QDateTime::currentDateTime();
   05 updateTimer = new QTimer(this);
   06 connect(updateTimer, SIGNAL(timeouf()),
   07 this, SLOT(update()));
   08 finishTimer = new QTimer(this);
   09 finishTimer->setSingleShot(true);
   10 connect(finishTimer, SIGNAL(timeout()),
   11 this, SIGNAL(timeout()));
   12 connect(finishTimer, SIGNAL(timeout()),
   13 updateTimer, SLOT(stop()));
   14 }
   В конструкторе мы создаем два объекта QTimer: updateTimer используется для обновления внешнего вида виджета через каждую секунду, a finishTimer генерирует сигнал виджета timeout() при достижении отметки 0. Объект finishTimer должен генерировать только один сигнал тайм-аута, поэтому мы вызываем setSingleShot(true); по умолчанию таймеры запускаются повторно, пока они не будут остановлены или не будут уничтожены. Последний вызов connect() является оптимизационным и обеспечивает прекращение обновления виджета каждую секунду, когда таймер неактивен.
   01 void OvenTimer::setDuration(int secs)
   02 {
   03 if (secs > MaxSeconds) {
   04 secs = MaxSeconds;
   05 } else if (secs <= 0) {
   06 secs = 0;
   07 }
   08 finishTime = QDateTime::currentDateTime().addSecs(secs);
   09 if (secs > 0) {
   10 updateTimer->start(UpdateInterval * 1000);
   11 finishTimer->start(secs * 1000);
   12 } else {
   13 updateTimer->stop();
   14 finishTimer->stop();
   15 }
   16 update();
   17 }
   Функция setDuration() выставляет таймер духовки, задавая требуемое количество секунд. Время окончания мы рассчитываем путем добавления продолжительности его работы к текущему времени, полученному функцией QDateTime::currentDateTime(), и сохраняем его в закрытой переменной finishTime. B конце мы вызываем update() для перерисовки виджета с новой продолжительностью работы.
   Переменная finishTime имеет тип QDateTime. Поскольку она содержит дату и время, мы избегаем ошибки из-за смены суток, когда текущее время оказывается до полуночи, а время окончания — после полуночи.
   01 int OvenTimer::duration() const
   02 {
   03 int secs = QDateTime::currentDateTime().
   04 secsTo(finishTime);
   05 if (secs < 0)
   06 secs = 0;
   07 return secs;
   08 }
   Функция duration() возвращает количество секунд, оставшееся до завершения работы таймера. Если таймер неактивен, мы возвращаем 0.
   01 void OvenTimer::mousePressEvent(QMouseEvent *event)
   02 {
   03 QPointF point = event->pos() - rect().center();
   04 double theta = atan2(-point.x(), -point.y()) * 180 / 3.14159265359;
   05 setDuration(duration() + int(theta / DegreesPerSecond));
   06 update();
   07 }
   Если пользователь щелкает по этому виджету, мы находим ближайшую метку, используя тонкую, но эффективную математическую формулу, а результат идет на установку новой продолжительности таймера. Затем мы генерируем событие перерисовки. Метка, по которой щелкнул пользователь, теперь будет располагаться сверху поворотного диска и будет поворачиваться против часовой стрелки до тех пор, пока не будет достигнуто значение 0.
   01 void OvenTimer::paintEvent(QPaintEvent * /* event */)
   02 {
   03 QPainter painter(this);
   04 painter.setRenderHint(QPainter::Antialiasing, true);
   05 int side = qMin(width(), height());
   06 painter.setViewport((width() - side) / 2, (height() - side) / 2,
   07 side, side);
   08 painter.setWindow(-50, -50, 100, 100);
   09 draw(&painter);
   10 }
   B paintEvent() мы устанавливаем область отображения на максимальный квадрат, который можно разместить внутри виджета, и мы устанавливаем окно на прямоугольник (—50, —50, 100, 100), то есть на прямоугольник с размерами 100 × 100, который покрывает пространство от точки (—50, —50) до точки (+50, +50). Шаблонная функция qMin возвращает наименьшее из двух значений аргументов. Затем мы вызываем функцию draw() для фактического вывода рисунка на экран.
   Рис. 8.10. Вид виджета OvenTimer при трех различных размерах.
   Если область отображения не была бы квадратом, таймер духовки принял бы форму эллипса, когда форма виджета перестанет быть квадратной после изменения его размеров. Чтобы избежать такой деформации, мы должны устанавливать область отображения и окно на прямоугольник с одинаковым соотношением сторон.
   Теперь давайте рассмотрим программный код рисования:
   01 void OvenTimer::draw(QPainter *painter)
   02 {
   03 static const int triangle[3][2] = {
   04 { -2, -49 }, { +2, -49 }, { 0, -47 }
   05 };
   10 QPen thickPen(palette().foreground(), 1.5);
   11 QPen thinPen(palette().foreground(), 0.5);
   12 QColor niceBlue(150, 150, 200);
   13 painter->setPen(thinPen);
   14 painter->setBrush(palette().foreground());
   15 painter->drawPolygon(QPolygon(3, &triangle[0][0]));
   Мы начинаем с отображения маленького треугольника в позиции 0 в верхней части виджета. Этот треугольник задается в программе тремя фиксированными координатами, и мы используем функцию drawPolygon() для его воспроизведения.
   Одно из удобств применения механизма «окно—область отображения» заключается в том, что мы можем при программировании в командах рисования жестко задавать координаты точек и тем не менее добиваться необходимого изменения размеров.
   16 QConicalGradient coneGradient(0, 0, -90.0);
   17 coneGradient.setColorAt(0.0, Qt::darkGray);
   18 coneGradient.setColorAt(0.2, niceBlue);
   19 coneGradient.setColorAt(0.5, Qt::white);
   20 coneGradient.setColorAt(1.0, Qt::darkGray);
   21 painter->setBrush(coneGradient);
   22 painter->drawEllipse(-46, -46, 92, 92);
   Мы рисуем внешнюю окружность и заполняем ее, используя конический градиент. Центр градиента находится в точке (0, 0), а его угол равен —90°.
   23 QRadialGradient haloGradient(0, 0, 20, 0, 0);
   24 haloGradient.setColorAt(0.0, Qt::lightGray);
   25 haloGradient.setColorAt(0.8, Qt::darkGray);
   26 haloGradient.setColorAt(0.9, Qt::white);
   27 haloGradient.setColorAt(1.0, Qt::black);
   28 painter->setPen(Qt::NoPen);
   29 painter->setBrush(haloGradient);
   30 painter->drawEllipse(-20, -20, 40, 40);
   Мы заполняем внутреннюю окружность, используя радиальный градиент. Центр и фокус градиента располагаются в точке (0, 0). Радиус градиента равен 20.
   31 QLinearGradient knobGradient(-7, -25, 7, -25);
   32 knobGradient.setColorAt(0.0, Qt::black);
   33 knobGradient.setColorAt(0.2, niceBlue);
   34 knobGradient.setColorAt(0.3, Qt::lightGray);
   35 knobGradient.setColorAt(0.8, Qt::white);
   36 knobGradient.setColorAt(1.0, Qt::black);
 
   37 painter->rotate(duration() * DegreesPerSecond);
   38 painter->setBrush(knobGradient);
   39 painter->setPen(thinPen);
   40 painter->drawRoundRect(-7, -25, 14, 50, 150, 50);
 
   41 for (int i = 0; i <= MaxMinutes; ++i) {
   42 if (i % 5 == 0) {
   43 painter->setPen(thickPen);
   44 painter->drawLine(0, -41, 0, -44);
   45 painter->drawText(-15, -41, 30, 25,
   46 Qt::AlignHCenter | Qt::AlignTop,
   47 QString::number(i));
   48 } else {
   49 painter->setPen(thinPen);
   50 painter->drawLine(0, -42, 0, -44);
   51 }
   52 painter->rotate(-DegreesPerMinute);
   53 }
   54 }
   Мы вызываем функцию rotate() для поворота системы координат рисовальщика. В старой системе координат нулевая отметка находилась сверху; теперь нулевая отметка перемещается для установки соответствующего времени, которое остается до срабатывания таймера. После каждого поворота мы снова рисуем ручку таймера, поскольку его ориентация зависит от угла поворота.
   В цикле for мы рисуем минутные отметки по внешней окружности и отображаем количество минут через каждые 5 минутных меток. Текст размещается в невидимом прямоугольнике под минутной отметкой. В конце каждой итерации цикла мы поворачиваем рисовальщик по часовой стрелке на 7°, что соответствует одной минуте. При рисовании минутной отметки следующий раз она будет отображаться в другом месте окружности, хотя мы передаем одни и те же координаты функциям drawLine() и drawText().
   В этом программном коде в цикле for имеется незаметная погрешность, которая быстро стала бы очевидной, если бы мы выполнили больше итераций. При каждом вызове rotate() мы фактически умножаем текущую универсальную матрицу преобразования на матрицу поворота, получая новую универсальную матрицу преобразования. Ошибка округления чисел с плавающей точкой еще больше увеличивает неточность универсальной матрицы преобразования. Ниже показан один из возможных способов решения этой проблемы путем перезаписи программного кода с использованием save() и restore() для сохранения и восстановления первоначальной матрицы преобразования на каждом шаге итерации:
   41 for (int i = 0; i <= MaxMinutes; ++i) {
   42 painter->save();
   43 painter->rotate(-i * DegreesPerMinute);
   44 if (i % 5 == 0) {
   45 painter->setPen(thickPen);
   46 painter->drawLine(0, -41, 0, -44);
   47 painter->drawText(-15, -41, 30, 25,
   48 Qt::AlignHCenter | Qt::AlignTop,
   49 QString::number(i));
   50 } else {
   51 painter->setPen(thinPen);
   52 painter->drawLine(0, -42, 0, -44);
   53 }
   54 painter->restore();
   55 }
   При другом способе реализации таймера духовки нам нужно было бы самим рассчитывать координаты (x, y), используя функции sin() и cos() для определения их позиции на окружности. Но тогда нам все же пришлось бы выполнять перенос и поворот системы координат для отображения текста под некоторым углом.

   При рисовании мы можем столкнуться с необходимостью принятия компромиссных решений относительно скорости и точности. Например, в системах X11 и Mac OS X рисование по виджету QWidget или по пиксельной карте QPixmap основано на применении родного для платформы графического процессора (paint engine). В системе X11 это обеспечивает минимальную связь с Х—сервером; посылаются только команды рисования, а не данные реального изображения. Основным недостатком этого подхода является то, что возможности Qt ограничиваются родными для данной платформы средствами поддержки:
   • в системе Х11 такие возможности, как сглаживание линий и поддержка дробных координат, доступны только в том случае, если Х—сервер использует расширение X Render;
   • в системе Mac OS X родной графический процессор, обеспечивающий сглаживание линий, использует алгоритмы рисования многоугольников, которые отличаются от алгоритмов в X11 и Windows, что приводит к получению немного других результатов.
   Когда точность важнее эффективности, мы можем рисовать по QImage и копировать результат на экран. В этом случае Qt всегда использует собственный внутренний графический процессор и результат на всех платформах получается идентичным. Единственное ограничение заключается в том, что QImage, по которому мы рисуем, должен создаваться с аргументом QImage::Format_RGB32 или QImage::Format_ARGB32_Premultiplied.
   Второй формат почти идентичен обычному формату ARGB32 (0xaarrggbb); отличие в том, что красный, зеленый и синий компоненты «предварительно умножаются» на альфа—компонент. Это значит, что значения RGB, которые обычно находятся в диапазоне от 0x00 до 0xFF, теперь принимают значения от 0x00 до значения альфа-компонента. Например, синий цвет с прозрачностью 50% представляется значением 0x7F0000FF в формате ARGB32, но он имеет значение 0x7F00007F в формате ARGB32 с предварительным умножением компонент, и, аналогично, темно-зеленый цвет с прозрачностью 75% имеет значение 0x3F008000 в формате ARGB32 и значение 0x3F002000 в фopмaтe ARGB32 с предварительным умножением компонент.
   Предположим, что мы хотим использовать сглаживание линий при рисовании виджета и нам нужно получить хорошие результаты даже в системах X11, которые не используют расширение X Render. Обработчик событий paintEvent(), предполагающий применение X Render для сглаживания линий, мог бы выглядеть следующим образом:
   01 void MyWidget::paintEvent(QPaintEvent *event)
   02 {
   03 QPainter painter(this);
   04 painter.setRenderHint(QPainter::Antialiasing, true);
   05 draw(&painter);
   06 }
   Ниже показано, как можно переписать виджетную функцию paintEvent() для применения независимого от платформы графического процессора Qt:
   01 void MyWidget::paintEvent(QPaintEvent *event)
   02 {
   03 QImage image(size(), QImage::Format_ARGB32_Premultiplied);
   04 QPainter imagePainter(&image);
   05 imagePainter.initFrom(this);
   06 imagePainter.setRenderHint(QPainter::Antialiasing, true);
   07 imagePainter.eraseRect(rect());
   08 draw(&imagePainter);
   09 imagePainter.end();
   10 QPainter widgetPainter(this);
   11 widgetPainter.drawImage(0,0, image);
   12 }
   Мы создаем объект QImage с тем же размером, который имеет виджет, в формате ARGB32 с умножением компонент, и объект QPainter для рисования по изображению. Вызов initFrom() инициализирует в рисовальщике перо, фон и шрифт значениями, используемыми виджетом. Мы рисуем, используя QPainter как обычно, а в конце еще раз используем объект QPainter для копирования изображения на виджет.
   Этот подход дает одинаково высококачественный результат на всех платформах, за исключением воспроизведения шрифта, что зависит от установленных в системе шрифтов.
   Особенно эффективным средством графического процессора Qt является его поддержка режимов композиции. Эти режимы определяют способ слияния исходного и нового пикселя при рисовании. Это относится ко всем операциям рисования, в том числе относящимся к перу, кисти, градиенту и изображению.
   Режимом композиции по умолчанию является QImage::CompositionMode_SourceOver, означающий, что исходный пиксель (тот, который рисуется в данный момент) налагается поверх существующего на изображении пикселя, причем альфа—компонент исходного пикселя определяет степень его прозрачности. На рис. 8.11 показан результат рисования полупрозрачной бабочки поверх тестового шаблона при использовании разных режимов.
 
   Рис. 8.11. Режимы композиции QPainter.
   Режимы композиции устанавливаются функцией QPainter::setCompositionMode(). Например, ниже показано, как можно создать объект QImage, объединяющий пиксели бабочки и тестового шаблона с помощью операции XOR:
   QImage resultImage = checkerPatternImage;
   QPainter painter(&resultImage);
   painter.setCompositionMode(QPainter::CompositionMode_Xor);
   painter.drawImage(0, 0, butterflyImage);
   Следует иметь в виду, что операция QImage::CompositionMode_Xor применяется к альфа—компоненту. Это означает, что если мы применим операцию XOR при наложении белого цвета (0xFFFFFFFF) на белый цвет, мы получим прозрачный цвет (0х00000000), а не черный цвет(0хFF000000).

   Вывод на печатающее устройство в Qt подобен рисованию по QWidget, QPixmap или QImage. Порядок действий при этом будет следующим:
   1. Создайте в качестве устройства рисования объект QPrinter.
   2. Выведите на экран диалоговое окно печати QPrintDialog, позволяя пользователю выбрать печатающее устройство и установить некоторые параметры печати.
   3. Создайте объект QPainter для работы с QPrinter.
   4. Нарисуйте страницу, используя QPainter.
   5. Вызовите функцию QPrinter::newPage() для перехода на следующую страницу.
   6. Повторяйте пункты 4 и 5 до тех пор, пока не будут распечатаны все страницы.
   В операционных системах Windows и Mac OS X QPrinter использует системные драйверы принтеров. В системе Unix он формирует файл PostScript и передает его lp или lpr (или другой программе, установленной функцией QPrinter::setPrintProgram()). QPrinter может также использоваться для генерации файлов PDF, если вызвать setOutputFormat(QPrinter::PdfFormat).
   Давайте начнем с рассмотрения какого-нибудь простого примера по распечатке одной страницы. Первый пример распечатывает объект QImage:
   01 void PrintWindow::printImage(const Qlmage &image)
   02 {
   03 QPrintDialog printDialog(&printer, this);
   04 if (printDialog.exec()) {
   05 QPainter painter(&printer);
   06 QRect rect = painter.viewport();
   07 QSize size = image.size();
   08 size.scale(rect.size(), Qt::KeepAspectRatio);
   09 painter.setViewport(rect.x(). rect.y(), size.width(), size.height());
   10 painter.setWindow (image.rect());
   11 painter.drawImage(0, 0, image);
   12 }
   13 }
   Рис. 8.12. Вывод на печатающее устройство объекта QImage.
   Мы предполагаем, что класс PrintWindow имеет переменную—член printer типа QPrinter. Мы могли бы просто поместить QPrinter в стек в функции printImage(), но тогда не сохранялись бы настройки пользователя при переходе от одной печати к другой.
   Мы создаем объект QPrintDialog и вызываем функцию exec() для вывода на экран диалогового окна печати. Оно возвращает true, если пользователь нажал кнопку OK; в противном случае оно возвращает false. После вызова функции exec() объект QPrinter готов для использования. (Можно также печатать, не используя QPrintDialog, а напрямую вызывая функции—члены класса QPrinter для подготовки печати.)
   Затем мы создаем QPainter для рисования на QPrinter. Мы устанавливаем окно на прямоугольник изображения и область отображения на прямоугольник с тем же соотношением сторон, и мы рисуем изображение в позиции (0, 0).
   По умолчанию окно QPrinter инициализируется таким образом, что разрешающая способность принтера будет аналогична разрешающей способности экрана (обычно она составляет примерно от 72 до 100 точек на дюйм), позволяя легко использовать для печати программный код по рисованию виджета. Здесь это не имеет значения, поскольку мы сами задали параметры нашего окна.
   Вывод на печатающее устройство элементов, занимающих не более одной страницы, выполняется достаточно просто, но во многих приложениях приходится печатать несколько страниц. В таких случаях мы должны сначала нарисовать одну страницу и затем вызвать функцию newPage() для перехода на следующую страницу. Здесь возникает проблема определения того количества информации, которое будет печататься на одной странице. Существует два подхода при обработке многостраничных документов в Qt:
   • Мы можем преобразовать наши данные в формат HTML и затем воспроизвести их с применением класса QTextDocument, процессора форматированного текста Qt.
   • Мы можем выполнить рисование и разбивку на страницы вручную.
   Мы рассмотрим по очереди оба подхода. В качестве примера мы распечатаем цветочный справочник: список названий цветов с текстовым описанием. Каждый элемент этого справочника представляется строкой формата «название: описание», например:
   Miltonopsis santanae: Самый опасный вид орхидеи.
   Поскольку данные каждого цветка представлены одной строкой, мы можем представить цветочный справочник при помощи одного объекта QStringList. Ниже приводится функция печати цветочного справочника, использующая процессор форматированного текста Qt:
   01 void PrintWindow::printFlowerGuide(const QStringList &entries)
   02 {
   03 QString html;
   04 foreach(QString entry, entries) {
   05 QStringList fields = entry.split(": ");
   06 QString title = Qt::escape(fields[0]);
   07 QString body = Qt::escape(fields[1]);
   08 html = "<table width=\"100%\" border=1 cellspacing=0>\n"
   09 "<tr><td bgcolor=\"lightgray\"><font size=\"+1\">"
   10 "<b><i>" + title + "</i></b></font>\n<tr><td>" + body"
   11 + "\n</table>\n<br>\n";
   12 }
   13 printHtml(html);
   14 }
   На первом этапе QStringList преобразуется в формат HTML. Каждый цветок представляется таблицей HTML с двумя ячейками. Мы используем функцию Qt::escape() для замены специальных символов «&», «<», «>» на соответствующие элементы формата HTML(«&amp;», «&lt;», «&gt;»). Затем мы вызываем функцию printHtml() для печати текста.
   01 void PrintWindow::printHtml(const QString &html)
   02 {
   03 QPrintDialog printDialog(&printer, this);
   04 if (printDialog.exec()) {
   05 QPainter painter(&printer);
   06 QTextDocument textDocument;
   07 textDocument.setHtml(html);
   08 textDocument.print(&printer);
   09 }
   10 }
   Функция printHtml() выводит диалоговое окно QPrintDialog и выполняет печать документа HTML. Она может без изменений повторно использоваться в любом приложении Qt для распечатки страниц произвольного текста в формате HTML.
   Рис. 8.13. Вывод на печать цветочного справочника с применением QTextDocument.
   Преобразование документа в формат HTML и использование QTextDocument для его распечатки являются самым удобным способом печати отчетов и других сложных документов. В тех случаях, когда требуется обеспечить больший контроль, мы можем вручную выполнить компоновку страниц и их рисование. Давайте теперь посмотрим, как можно напечатать цветочный справочник при помощи класса QPainter. Ниже приводится новая версия функции printFlowerGuide():
   01 void PrintWindow::printFlowerGuide(const QStringList &entries)
   02 {
   03 QPrintDialog printDialog(&printer, this);
   04 if (printDialog.exec()) {
   05 QPainter painter(&printer);
   06 QList<QStringList> pages;
   07 paginate(&painter, &pages, entries);
   08 printPages(&painter, pages);
   09 }
   10 }
   После настройки принтера и построения объекта рисовальщика мы вызываем вспомогательную функцию paginate() для определения содержимого каждой страницы. В результате получается вектор списков QStringList, причем каждый список QStringList содержит элементы одной страницы. Результат мы передаем функции printPages().
   Например, предположим, что цветочный справочник содержит всего 6 элементов, которые мы обозначим буквами А, Б, В, Г, Д и E. Теперь предположим, что имеется достаточно места для элементов А и Б на первой странице, В, Г и Д на второй странице и Е на третьей странице. Тогда список pages содержал бы список [А, Б] в элементе с индексом 0, список [В, Г, Д] в элементе с индексом 1 и список [E] в элементе с индексом 2.
   01 void PrintWindow::paginate(QPainter *painter, QList<QStringList> *pages,
   02 const QStringList &entries)
   03 {
   04 QStringList currentPage;
   05 int pageHeight = painter->window().height() - 2 * LargeGap;
   06 int у = 0;
   07 foreach (QString entry, entries) {
   08 int height = entryHeight(painter, entry);
   09 if (у + height > pageHeight && !currentPage.empty()) {
   10 pages->append(currentPage);
   11 currentPage.clear();
   12 y = 0;
   13 }
   14 currentPage.append(entry);
   15 у += height + MediumGap;
   16 }
   17 if (!currentPage.empty())
   18 pages->append(currentPage);
   19 }
   Функция paginate() распределяет элементы справочника цветов по страницам. Ее работа основана на применении функции entryHeight(), рассчитывающей высоту каждого элемента. Она также учитывает наличие сверху и снизу страницы полей с размером LargeGap.
   Мы выполняем цикл по элементам и добавляем их в конец текущей страницы до тех пор, пока не окажется, что элемент не вмещается на страницу; затем мы добавляем текущую страницу в конец списка pages и начинаем формировать новую страницу.
   01 int PrintWindow::entryHeight(QPainter *painter, const QString &entry)
   02 {
   03 int textWidth = painter->window().width() - 2 * SmallGap;
   04 QString title = fields[0];
   05 QString body = fields[1];
   06 QStringList fields = entry.split(": ");
   07 int maxHeight = painter->window().height();
   08 painter->setFont(titleFont);
   09 QRect titleRect = painter->boundingRect(0, 0, textWidth, maxHeight,
   10 Qt::TextWordWrap, title);
   11 painter->setFont(bodyFont);
   12 QRect bodyRect = painter->boundingRect(0, 0, textWidth, maxHeight,
   13 Qt::TextWordWrap, body);
   14 return titleRect.height() + bodyRect.height() + 4 * SmallGap;
   15 }
   Функция entryHeight() использует QPainter::boundingRect() для вычисления размера области, занимаемой одним элементом по вертикали. На рис. 8.14 показана компоновка элементов одного цветка на странице и проиллюстрирован смысл констант SmallGap и MediumGap.
   Рис. 8.14. Компоновка элементов справочника цветов на странице.
   01 void PrintWindow::printPages(QPainter *painter,
   02 const QList<QStringList> &pages)
   03 {
   04 int firstPage = printer.fromPage() - 1;
   05 if (firstPage >= pages.size())
   06 return;
   07 if (firstPage == -1)
   08 firstPage = 0;
   09 int lastPage = printer.toPage() - 1;
   10 if (lastPage == -1 || lastPage >= pages.size())
   11 lastPage = pages.size() - 1;
   12 int numPages = lastPage - firstPage + 1;
   13 for (int i = 0; i < printer.numCopies(); ++i) {
   14 for (int j = 0; j < numPages; ++j) {
   15 if (i != 0 || j != 0)
   16 printer.newPage();
   17 int index;
   18 if (printer.pageOrder() == QPrinter::FirstPageFirst) {
   19 index = firstPage + j;
   20 } else {
   21 index = lastPage - j;
   22 }
   23 printPage(painter, pages[index], index + 1);
   24 }
   25 }
   26 }
   Функция printPages() предназначена для печати каждой страницы функцией printPage() с обеспечением правильного числа и правильной последовательности вызовов последней. Применяя QPrintDialog, пользователь может запросить распечатку нескольких копий, указать диапазон страниц или запросить распечатку страниц в обратной последовательности. Мы сами должны включать или отключать эти опции, используя функцию QPrintDialog::setEnabledOptions().
   Мы начинаем с определения диапазона печати. Функции QPrinter fromPage() и toPage() возвращают заданные пользователем номера страниц или 0, если диапазон не указан. Мы вычитаем 1, потому что наш список страниц pages нумеруется с нуля, и устанавливаем переменные firstPage и lastPage (первая и последняя страницы) на охват всех страниц, если диапазон не задан пользователем.
   Затем мы печатаем каждую страницу. Внешний цикл for определяется количеством копий, запрошенных пользователем. Большинство драйверов принтеров поддерживают печать нескольких копий, поэтому для них функция QPrinter::numCopies() всегда возвращает 1. Если драйвер принтера не может печатать несколько копий, numCopies() возвращает количество копий, запрошенное пользователем, и за печать этого количества копий отвечает приложение. (В примере с QImage, приведенном ранее в данном разделе, мы для простоты проигнорировали numCopies().)
   Рис. 8.15 аналогичен 8.13.
   Внутренний цикл for выполняется по всем страницам. Если страница не первая, мы вызываем newPage(), чтобы сбросить на печатающее устройство старую страницу и начать рисование новой страницы. Мы вызываем printPage() для распечатки каждой страницы.
   01 void PrintWindow::printPage(QPainter *painter,
   02 const QStringList &entries, int pageNumber)
   03 {
   04 painter->save();
   05 painter->translate(0, LargeGap);
   06 foreach (QString entry, entries) {
   07 QStringList fields = entry.split(": ");
   08 QString title = fields[0];
   09 QString body = fields[1];
   10 printBox(painter, title, titleFont, Qt::lightGray);
   11 printBox(painter, body, bodyFont, Qt::white);
   12 painter->translate(0, MediumGap);
   13 }
   14 painter->restore();
   15 painter->setFont(footerFont);
   16 painter->drawText(painter->window(),
   17 Qt::AlignHCenter | Qt::AlignBottom,
   18 QString::number(pageNumber));
   19 }
   Функция printPage() обрабатывает в цикле все элементы справочника цветов и печатает их при помощи двух вызовов функции printBox(): один для заголовка (название цветка) и другой для «тела» (описание цветка). Она также отображает номер страницы внизу по центру страницы.
   01 void PrintWindow::printBox(QPainter *painter, const QString &str,
   02 const QFont &font, const QBrush &brush)
   03 {
   04 painter->setFont(font);
   05 int boxWidth = painter->window().width();
   06 int textWidth = boxWidth - 2 * SmallGap;
   07 int maxHeight = painter->window().height();
   08 QRect textRect = painter->boundingRect(SmallGap, SmallGap,
   09 textWidth, maxHeight, Qt::TextWordWrap, str);
   10 int boxHeight = textRect.height() + 2 * SmallGap;
   11 painter->setPen(QPen(Qt::black, 2, Qt::SolidLine));
   12 painter->setBrush(brush);
   13 painter->drawRect(0, 0, boxWidth, boxHeight);
   14 painter->drawText(textRect, Qt::TextWordWrap, str);
   15 painter->translate(0, boxHeight);
   16 }
   Рис. 8.16. Компоновка страницы справочника по цветам.
   Функция printBox() вычерчивает контур блока, затем отображает текст внутри него.

   OpenGL является стандартным программным интерфейсом, предназначенным для воспроизведения графики 2D и 3D. Приложения Qt могут отображать графику 3D, используя модуль QtOpenGL, который рассчитан на применение системной библиотеки OpenGL. При изложении данного раздела предполагается, что вы знакомы с OpenGL. Если вы не знакомы с OpenGL, хорошо начинать его изучение с посещения сайта http://www.opengl.org/.
   Рис. 8.17. Приложение Тетраэдр.
   Вывод графики при помощи OpenGL в приложении Qt выполняется достаточно просто: мы должны создать подкласс QGLWidget, переопределить несколько виртуальных функций и собрать приложение вместе с библиотеками QtOpenGL и OpenGL. Из-за того, что QGLWidget наследует QWidget, большая часть наших знаний остается применимой и здесь. Основное отличие заключается в том, что вместо QPainter для выполнения графических операций мы используем стандартные функции библиотеки OpenGL.
   Для демонстрации этого подхода мы рассмотрим программный код приложения Тетраэдр, показанного на рис. 8.17. Это приложение отображает в пространстве тетраэдр или четырехгранник, грани которого имеют различные цвета. Пользователь может поворачивать тетраэдр, нажимая кнопку мышки и перемещая ее. Пользователь может задавать цвет поверхности грани путем двойного щелчка с последующим выбором цвета в диалоговом окне QColorDialog, которое выдается на экран.
   01 class Tetrahedron : public QGLWidget
   02 {
   03 Q_OBJECT
   04 public:
   05 Tetrahedron(QWidget *parent = 0);
 
   06 protected:
   07 void initializeGL();
   08 void resizeGL(int width, int height);
   09 void paintGL();
   10 void mousePressEvent(QMouseEvent *event);
   11 void mouseMoveEvent(QMouseEvent *event);
   12 void mouseDoubleClickEvent(QMouseEvent *event);
 
   13 private:
   14 void draw();
   15 int faceAtPosition(const QPoint &pos);
   16 GLfloat rotationX;
   17 GLfloat rotationY;
   18 GLfloat rotationZ;
   19 QColor faceColors[4];
   20 QPoint lastPos;
   21 }
   Класс Tetrahedron наследует QGLWidget. Функции класса QGLWidget initializeGL(), resizeGL() и paintGL() переопределяются. Обработчики событий мышки класса QWidget переопределяются обычным образом.
   01 Tetrahedron::Tetrahedron(QWidget *parent)
   02 : QGLWidget(parent)
   03 {
   04 setFormat(QGLFormat(QGL::DoubleBuffer | QGL::DepthBuffer)
   05 rotationX = -21.0;
   06 rotationY = -57.0;
   07 rotationZ = 0.0;
   08 faceColors[0] = Qt::red;
   09 faceColors[1] = Qt::green;
   10 faceColors[2] = Qt::blue;
   11 faceColors[3] = Qt::yellow;
   12 }
   В конструкторе мы вызываем функцию QGLWidget::setFormat() для установки контекста экрана OpenGL и инициализируем закрытые переменные этого класса.
   01 void Tetrahedron::initializeGL()
   02 {
   03 qglClearColor(Qt::black);
   04 glShadeModel(GL_FLAT);
   05 glEnable(GL_DEPTH_TEST);
   06 glEnable(GL_CULL_FACE);
   07 }
   Функция initializeGL() вызывается только один раз перед вызовом функции paintGL(). Именно в этом месте мы можем задавать контекст воспроизведения OpenGL, определять списки отображаемых элементов и выполнять остальную инициализацию.
   Весь программный код является стандартным кодом OpenGL, за исключением вызовов функции qglClearColor() класса QGLWidget. Если бы мы захотели строго придерживаться стандартных возможностей OpenGL, мы вместо этого вызывали бы функцию glClearColor() при использовании режима RGBA и glClearIndex() при использовании режима индексированных цветов.
   01 void Tetrahedron::resizeGL(int width, int height)
   02 {
   03 glViewport(0, 0, width, height);
   04 glMatrixMode(GL_PROJECTION);
   05 glLoadIdentity();
   06 GLfloat x = GLfloat(width) / height;
   07 glFrustum(-x, x, -1.0, 1.0, 4.0, 15.0);
   08 glMatrixMode(GL_MODELVIEW);
   09 }
   Функция resizeGL() вызывается один раз перед первым вызовом функции paintGL(), но после вызова функции initializeGL(). Oнa также всегда вызывается при изменении размера виджета. Именно в этом месте мы можем задавать область отображения OpenGL, ее проекцию и делать любые другие настройки, зависящие от размера виджета.
   01 void Tetrahedron::paintGL()
   02 {
   03 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   04 draw();
   05 }
   Функция paintGL() вызывается всякий раз, когда необходимо перерисовать виджет. Это напоминает функцию QWidget::paintEvent(), но вместо функций класса QPainter здесь мы используем функции библиотеки OpenGL. Реальное рисование выполняется закрытой функцией draw().
   01 void Tetrahedron::draw()
   02 {
   04 static const GLfloat P1[3]= { 0.0, -1.0, +2.0 };
   05 static const GLfloat P2[3] = { +1.73205081, -1.0, -1.0 };
   06 static const GLfloat P3[3] = { -1.73205081, -1.0, -1.0 };
   07 static const GLfloat P4[3] = { 0.0, +2.0, 0.0 };
   08 static const GLfloat * const coords[4][3] = {
   09 { P1, P2, РЗ }, { P1, РЗ, P4 }, { P1, P4, P2 }, { P2, P4, РЗ }
   10 };
 
   11 glMatrixMode(GL_MODELVIEW);
   12 glLoadIdentity();
   13 glTranslatef(0.0, 0.0, -10.0);
   14 glRotatef(rotationX, 1.0, 0.0, 0.0);
   15 glRotatef(rotationY, 0.0, 1.0, 0.0);
   16 glRotatef(rotationZ, 0.0, 0.0, 1.0);
 
   17 for (int i = 0; i < 4; ++i) {
   18 glLoadName(i);
   19 glBegin(GL_TRIANGLES);
   20 qglColor(faceColors[i]);
   21 for (int j = 0; j < 3; ++j) {
   22 glVertex3f(coords[i][j][0],
   23 coords[i][j][1], coords[i][j][2]);
   24 }
   25 glEnd();
   26 }
   27 }
   В функции draw() мы рисуем тетраэдр, учитывая повороты по осям x, у и z, а также цвета в массиве faceColors. Везде вызываются стандартные функции библиотеки OpenGL, за исключением вызова qglColor(). Вместо этого мы могли бы использовать одну из функций OpenGL — glColor3d() или glIndex() — в зависимости от используемого режима.
   01 void Tetrahedron::mousePressEvent(QMouseEvent *event)
   02 {
   03 lastPos = event->pos();
   04 }
 
   05 void Tetrahedron::mouseMoveEvent(QMouseEvent *event)
   06 {
   07 GLfloat dx = GLfloat(event->x() - lastPos.x()) / width();
   08 GLfloat dy = GLfloat(event->y() - lastPos.y()) / height();
   09 if (event->buttons() & Qt::LeftButton) {
   10 rotationX += 180 * dy;
   11 rotationY += 180 * dx;
   12 updateGL();
   13 } else if (event->buttons() & Qt::RightButton) {
   14 rotationX += 180 * dy;
   15 rotationZ += 180 * dx;
   16 updateGL();
   17 }
   18 lastPos = event->pos();
   19 }
   Функции класса QWidget mousePressEvent() и mouseMoveEvent() переопределяются, чтобы разрешить пользователю поворачивать изображение щелчком мышки и ее перемещением. Левая кнопка мышки позволяет пользователю поворачивать вокруг осей x и у, а правая кнопка мышки — вокруг осей x и z.
   После модификации переменных rotationX и rotationY или rotationZ мы вызываем функцию updateGL() для перерисовки сцены.
   01 void Tetrahedron::mouseDoubleClickEvent(QMouseEvent *event)
   02 {
   03 int face = faceAtPosition(event->pos());
   04 if (face != -1) {
   05 QColor color = QColorDialog::getColor(faceColors[face], this);
   06 if (color.isValid()) {
   07 faceColors[face] = color;
   08 updateGL();
   09 }
   10 }
   11 }
   Функция mouseDoubleClickEvent() класса QWidget переопределяется, чтобы разрешить пользователю устанавливать цвет грани тетраэдра с помощью двойного щелчка. Мы вызываем закрытую функцию faceAtPosition() для определения той грани, на которой находится курсор (если он вообще находится на какой-нибудь грани). При двойном щелчке по грани тетраэдра мы вызываем функцию QColorDialog::getColor() для получения нового цвета для этой грани. Затем мы обновляем массив цветов faceColors новым цветом, и мы вызываем функцию updateGL() для перерисовки экрана.
   01 int Tetrahedron::faceAtPosition(const QPoint &pos)
   02 {
   03 const int MaxSize = 512;
   04 GLuint buffer[MaxSize];
   05 GLint viewport[4];
 
   06 glGetIntegerv(GL_VIEWPORT, viewport);
   07 glSelectBuffer(MaxSize, buffer);
   08 glRenderMode(GL_SELECT);
   09 glInitNames();
   10 glPushName(0);
 
   11 glMatrixMode(GL_PROJECTION);
   12 glPushMatrix();
   13 glLoadIdentity();
   14 gluPickMatrix(GLdouble(pos.x()),
   15 GLdouble(viewport[3] - pos.y()),
   16 5.0, 5.0, viewport);
   17 GLfloat x = GLfloat(width()) / height();
   18 glFrustum(-x, x, -1.0, 1.0, 4.0, 15.0);
   19 draw();
   20 glMatrixMode(GL_PROJECTION);
   21 glPopMatrix();
 
   22 if (!glRenderMode(GL_RENDER))
   23 return -1;
   24 return buffer[3];
   25 }
   Функция faceAtPosition() возвращает номер грани для заданной точки виджета или —1, если данная точка не попадает на грань. Программный код этой функции, выполненной с помощью средств OpenGL, немного сложен. Фактически мы переводим работу в режим GL_SELECT, чтобы воспользоваться возможностями OpenGL по идентификации элементов изображения, и затем получаем номер грани (ее «имя») из записи нажатия OpenGL.
   Ниже приводится файл main.cpp:
   01 #include <QApplication>
   02 #include <iostream>
   03 #include "tetrahedron.h"
   04 using namespace std;
 
   05 int main(int argc, char *argv[])
   06 {
   07 QApplication app(argc, argv);
   08 if (!QGLFormat::hasOpenGL()) {
   09 cerr << "This system has no OpenGL support" << endl;
   10 return 1;
   11 }
   12 Tetrahedron tetrahedron;
   13 tetrahedron.setWindowTitle(QObject::tr("Tetrahedron"));
   14 tetrahedron.resize(300, 300);
   15 tetrahedron.show();
   16 return app.exec();
   17 }
   Если система пользователя не поддерживает OpenGL, мы выдаем на консоль сообщение об ошибке и сразу же возвращаем управление.
   Для сборки приложения совместно с модулем QtOpenGL и системной библиотекой OpenGL файл .pro должен содержать следующий элемент:
   QT += opengl
   Этим заканчивается разработка приложения Тетраэдр. Более подробную информацию о модуле QtOpenGL вы найдете в справочной документации по классам QGLWidget, QGLFormat, QGLContext, QGLColormap и QGLPixelBuffer.

   Технология «drag-and-drop» («перетащить и отпустить») является современным и интуитивным способом передачи информации внутри одного приложения или между разными приложениями. Она часто является дополнением к операциям с буфером обмена по перемещению и копированию данных.
   В данной главе мы увидим, как можно добавить в приложение Qt возможность поддержки технологии «drag-and-drop» и как обрабатывать пользовательские форматы. Затем мы используем программный код этой технологии для реализации операций с буфером обмена. Такое повторное использование данного программного кода возможно благодаря тому, что оба механизма основаны на применении одного класса QMimeData — базового класса, обеспечивающего представление данных в нескольких форматах.

   Технология «drag-and-drop» состоит из двух действий: перетаскивание «захваченных» объектов и их «освобождение». Виджеты в Qt могут использоваться в качестве переносимых объектов, в качестве места отпускания этих объектов или в обоих качествах.
   В нашем первом примере мы показываем, как приложение Qt принимает объект, перенесенный из другого приложения. Приложение Qt представляет собой главное окно, использующее текстовый редактор QTextEdit в качестве центрального виджета. Когда пользователь переносит текстовый файл с рабочего стола компьютера или из проводника файловой системы и оставляет его в окне этого приложения, оно загружает файл в QTextEdit.
   Ниже приводится пример определения класса MainWindow:
   01 class MainWindow : public QMainWindow
   02 {
   03 Q_OBJECT
   04 public:
   05 MainWindow();
   06 protected:
   07 void dragEnterEvent(QDragEnterEvent *event);
   08 void dropEvent(QDropEvent *event);
   09 private:
   10 bool readFile(const QString &fileName);
   11 QTextEdit *textEdit;
   12 }
   Класс MainWindow переопределяет функции dragEnterEvent() и dropEvent() класса QWidget. Поскольку целью примера является демонстрация механизма «drag-and-drop», большая часть функциональности класса главного окна здесь не рассматривается.
   01 MainWindow::MainWindow()
   02 {
   03 textEdit = new QTextEdit;
   04 setCentralWidget(textEdit);
   05 textEdit->setAcceptDrops(false);
   06 setAcceptDrops(true);
   07 setWindowTitle(tr("Text Editor"));
   08 }
   В конструкторе мы создаем QTextEdit и назначаем его в качестве центрального виджета. По умолчанию QTextEdit принимает переносимые текстовые объекты из других приложений, и если пользователь отпускает на этом виджете файл, имя этого файла будет вставлено в текст. Поскольку события отпускания объектов передаются от дочерних виджетов к родительским, отключая возможность отпускать переносимый объектв области отображения QTextEdit и включая ее для главного окна, мы получаем события отпускания объектов в MainWindow для всего главного окна.
   01 voidMainWindow::dragEnterEvent(QDragEnterEvent *event)
   02 {
   03 if (event->mimeData()->hasFormat("text/uri-list"))
   04 event->acceptProposedAction();
   05 }
   Функция dragEnterEvent() вызывается всякий раз, когда пользователь переносит объект на какой-нибудь виджет. Если мы вызываем функцию acceptProposedAction() при обработке этого события, мы указываем, что пользователь может отпустить переносимый объект в данном виджете. По умолчанию виджет не смог бы принять переносимый объект. Qt автоматически изменяет форму курсора для уведомления пользователя о возможности или невозможности приема объекта виджетом.
   Здесь мы хотим позволить пользователю переносить файлы, но не более того. Для этого мы проверяем MIME—тип переносимого объекта. MIME—тип text/uri-list используется для хранения списка универсальных идентификаторов ресурсов (URI — universal resource identifier), в качестве которых могут выступать имена файлов, адреса URL (например, адресные пути HTTP и FTP) или идентификаторы других глобальных ресурсов. Стандартные типы MIME определяются Агентством по выделению имен и уникальных параметров протоколов сети Интернет (Internet Assigned Numbers Authority — IANA). Они состоят из типа и подтипа, разделенных слешем. Типы MIME используются буфером обмена и механизмом «drag-and-drop» для идентификации различных типов данных. Официальный список MIME—типов доступен по адресу http://www.iana.org/assignments/media-types/.
   01 void MainWindow::dropEvent(QDropEvent *event)
   02 {
   03 QList<QUrl> urls = event->mimeData()->urls();
   04 if (urls.isEmpty())
   05 return;
   06 QString fileName = urls.first().toLocalFile();
   07 if (fileName.isEmpty())
   08 return;
   09 if (readFile(fileName))
   10 setWindowTitle(tr("%1 -%2").arg(fileName)
   11 .arg(tr("Drag File")));
   12 }
   Функция dropEvent() вызывается, когда пользователь отпускает объект на виджете. Мы вызываем функцию QMimeData::urls() для получения списка адресов QUrl. Обычно пользователи переносят одновременно только один файл, но возможен также перенос сразу нескольких выделенных файлов. Если имеется несколько URL или полученный URL оказывается нелокальным, мы немедленно возвращаем управление.
   QWidget содержит также функции dragMoveEvent() и dragLeaveEvent(), но для большинства приложений не потребуется их переопределять.
   Второй пример показывает, как следует инициировать перетаскивание объекта и принимать его после отпускания. Мы создадим подкласс QListWidget, который будет поддерживать механизм «drag-and-drop» и входить в приложение Project Chooser (составитель проектов), показанное на рис. 9.1.
   Рис. 9.1. Приложение Project Chooser.
   Приложение Project Chooser предоставляет пользователю два виджета со списками имен людей. Каждый список представляет проект. Пользователь может с помощью механизма «drag-and-drop» перевести человека из одного проекта в другой.
   Программный код по обеспечению механизма «drag-and-drop» находится в подклассе QListWidget. Ниже приводится определение класса:
   01 class ProjectListWidget : public QListWidget
   02 {
   03 Q_OBJECT
   04 public:
   05 ProjectListWidget(QWidget *parent= 0);
   06 protected:
   07 void mousePressEvent(QMouseEvent *event);
   08 void mouseMoveEvent(QMouseEvent *event);
   09 void dragEnterEvent(QDragEnterEvent *event);
   10 void dragMoveEvent(QDragMoveEvent *event);
   11 void dropEvent(QDropEvent *event);
   12 private:
   13 void startDrag();
   14 QPoint startPos;
   15 };
   ProjectListWidget переопределяет пять обработчиков событий, которые объявлены в QWidget.
   01 ProjectListWidget::ProjectListWidget(QWidget *parent)
   02 : QListWidget(parent)
   03 {
   04 setAcceptDrops(true);
   05 }
   В конструкторе мы обеспечиваем возможность приема переносимого объекта в виджете со списком.
   01 void ProjectListWidget::mousePressEvent(QMouseEvent *event)
   02 {
   03 if (event->button() == Qt::LeftButton)
   04 startPos = event->pos();
   05 QListWidget::mousePressEvent(event);
   06 }
   Когда пользователь нажимает левую кнопку мышки, мы сохраняем позицию мышки в закрытой переменной startPos. Мы вызываем определенную в классе QListWidget функцию mousePressEvent() для обеспечения обработки в QListWidget обычным образом события нажатия кнопкй мышки.
   01 void ProjectListWidget::mouseMoveEvent(QMouseEvent *event)
   02 {
   03 if (event->buttons() & Qt::LeftButton) {
   04 int distance = (event->pos() - startPos).manhattanLength();
   05 if (distance >= QApplication::startDragDistance())
   06 startDrag();
   07 }
   08 QListWidget::mouseMoveEvent(event);
   09 }
   Действие, при котором пользователь перемещает курсор мышки и одновременно держит нажатой левую кнопку, мы рассматриваем как начало перетаскивания объекта. Мы вычисляем расстояние между текущей позицией мышки и позицией нажатия левой кнопки мышки. Если это расстояние превышает рекомендованное в QApplication расстояние для регистрации начала перетаскивания (обычно 4 пикселя), мы вызываем закрытую функцию startDrag() для запуска процесса перетаскивания объекта. Это предотвращает инициирование процесса перетаскивания из-за дрожания руки пользователя.
   01 void ProjectListWidget::startDrag()
   02 {
   03 QListWidgetItem *item = currentItem();
   04 if (item) {
   05 QMimeData *mimeData = new QMimeData;
   06 mimeData->setText(item->text());
   07 QDrag *drag = new QDrag(this);
   08 drag->setMimeData(mimeData);
   09 drag->setPixmap(QPixmap(":/images/реrson.png"));
   10 if (drag->start(Qt::MoveAction) == Qt::MoveAction)
   11 delete item;
   12 }
   13 }
   В функции startDrag() мы создаем объект типа QDrag с указанием this в качестве родительского элемента. Объект QDrag хранит данные в объекте QMimeData. В нашем примере мы обеспечиваем данные типа text/plain, используя функцию QMimeData::setText(). Класс QMimeData содержит несколько функций, предназначенных для обработки наиболее распространенных типрв объектов переноса (изображений, адресов URL, цветов и т.д.); он может обрабатывать произвольные типы MIME, представленные массивами QByteArray. Вызов QDrag::setPixmap() задает пиктограмму, которая следует за курсором в процессе перетаскивания объекта.
   Вызов функции QDrag::start() запускает операцию перетаскивания объекта и ждет, пока пользователь не отпустит перетаскиваемый объект или не отменит перетаскивание. В аргументе этой функции задается перечень поддерживаемых «операций перетаскивания» (Qt::CopyAction, Qt::MoveAction и Qt::LinkAction); она возвращает ту операцию перетаскивания, которая была выполнена (или Qt::IgnoreAction, если не было выполнено никакой операции). Тип выполняемой операции зависит от того, какие операции допускаются исходным виджетом, какие операции поддерживает целевой виджет и какие клавиши—модификаторы нажаты в момент отпуска переносимого объекта. После вызова этой функции Qt становится владельцем переносимого объекта и удалит его, когда он станет ненужным.
   01 void ProjectListWidget::dragEnterEvent(QDragEnterEvent *event)
   02 {
   03 ProjectListWidget *source =
   04 qobject_cast<ProjectListWidget *>(event->source());
   05 if (source && source != this) {
   06 event->setDropAction(Qt::MoveAction);
   07 event->accept();
   08 }
   09 }
   Виджет ProjectListWidget не только инициирует перенос объектов, он также является местом приема таких объектов, если они приходят от другого виджета ProjectListWidget того же самого приложения. QDragEnterEvent::source() возвращает указатель на виджет, который инициирует перенос, если этот виджет принадлежит тому же самому приложению; в противном случае он возвращает нулевой указатель. Мы используем qobject_cast<T>(), чтобы убедиться в инициировании переноса виджетом ProjectListWidget. Если все верно, мы указываем Qt на нашу готовность восприятия данного действия как переноса.
   01 void ProjectListWidget::dragMoveEvent(QDragMoveEvent *event)
   02 {
   03 ProjectListWidget *source =
   04 qobject_cast<ProjectListWidget *>(event->source());
   05 if (source && source != this) {
   07 event->setDropAction(Qt::MoveAction);
   08 event->accept();
   09 }
   10 }
   Программный код функции dragMoveEvent() идентичен тому, что мы делали в функции dragEnterEvent(). Он необходим, потому что нам приходится переопределять реализацию этой функции в классе QListWidget (в действительности в классе QAbstractItemView).
   01 void ProjectListWidget::dropEvent(QDropEvent *event)
   02 {
   03 ProjectListWidget *source =
   04 qobject_cast<ProjectListWidget *>(event->source());
   05 if (source && source != this) {
   06 addItem(event->mimeData()->text());
   07 event->setDropAction(Qt::MoveAction);
   08 event->accept();
   09 }
   10 }
   В DropEvent() мы используем функцию QMimeData::text() для получения перенесенного текста и создаем элемент с этим текстом. Нам также необходимо воспринять данное событие как «операцию перетаскивания», чтобы указать исходному виджету на то, что он может теперь удалить первоначальную версию перенесенного элемента.
   «Drag-and-drop» — мощный механизм передачи данных между приложениями. Однако в некоторых случаях его можно реализовать, не используя предусмотренные в Qt средства механизма «drag-and-drop». Если нам требуется переносить данные внутри одного виджета некоторого приложения, во многих случаях мы можем просто переопределить функции mousePressEvent() и mouseReleaseEvent().

   До сих пор в представленных примерах мы полагались на поддержку QMimeData распространенных типов MIME. Так, мы вызывали QMimeData::setText() для создания объекта переноса текста и использовали QMimeData:urls() для получения содержимого объекта переноса типа text/uri-list. Если мы хотим перетаскивать обычный текст, текст в формате HTML, изображения, адреса URL или цвета, мы можем спокойно использовать класс QMimeData. Но если мы хотим перетаскивать пользовательские данные, необходимо сделать выбор между следующими альтернативами:
   1. Мы можем обеспечить произвольные данные в виде массива QByteArray, используя функцию QMimeData::setData(), и извлекать их позже, используя функцию QMimeData::data().
   2. Мы можем создать подкласс QMimeData и переопределить функции formats() и retrieveData() для обработки наших пользовательских типов данных.
   3. Для выполнения операций механизма «drag-and-drop» в рамках одного приложения мы можем создать подкласс QMimeData и хранить данные в любых структурах данных.
   Первый подход не требует никаких подклассов, но имеет некоторые недостатки: нам необходимо преобразбвать наши структуры данных в тип QByteArray, даже если переносимый объект не принимается, а если требуется обеспечить несколько MIME—типов, чтобы можно было хорошо взаимодействовать с самыми разными приложениями, нам придется сохранять несколько копий данных (по одной на каждый тип MIME). Если данные имеют большой размер, это может излишне замедлять работу приложения. При использовании второго и третьего подходов можно избежать или свести к минимуму эти проблемы. В этом случае мы получаем полное управление и можем использовать эти два подхода совместно.
   Для демонстрации этих подходов мы покажем, как можно добавить возможности технологии «drag-and-drop» в виджет QTableWidget. Будет поддерживаться перенос следующих типов MIME: text/plain, text/html и text/csv. При применении первого подхода инициирование переноса выглядит следующим образом:
   01 void MyTableWidget::mouseMoveEvent(QMouseEvent *event)
   02 {
   03 if (event->buttons() & Qt::LeftButton) {
   04 int distance = (event->pos() - startPos).manhattanLength();
   05 if(distance >= QApplication::startDragDistance())
   06 startDrag();
   07 }
   08 QTableWidget::mouseMoveEvent(event);
   09 }
 
   10 void MyTableWidget::startDrag()
   11 {
   12 QString plainText= selectionAsPlainText();
   13 if (plainText.isEmpty())
   14 return;
 
   15 QMimeData *mimeData = new QMimeData;
   16 mimeData->setText(plainText);
   17 mimeData->setHtml(toHtml(plainText));
   18 mimeData->setData("text/csv", toCsv(plainText).toUtf8());
 
   19 QDrag *drag = new QDrag(this);
   20 drag->setMimeData(mimeData);
   21 if (drag->start(Qt::CopyAction | Qt::MoveAction) == Qt::MoveAction)
   22 deleteSelection();
   23 }
   Закрытая функция startDrag() вызывается из mouseMoveEvent() для инициирования переноса выделенной прямоугольной области. Мы устанавливаем типы MIME text/plain и text/html, используя функции setText() и setHtml(), а тип text/csv мы устанавливаем функцией setData(), которая принимает произвольный тип MIME и массив QByteArray. Программный код для функции selectionAsString() более или менее совпадает с кодом функции Spreadsheet::copy(), рассмотренной в главе 4.
   01 QString MyTableWidget::toCsv(const QString &plainText)
   02 {
   03 QString result = plainText;
   04 result.replace("\\", "\\\\");
   05 result.replace("\"", "\\\"");
   06 result.replace("\t", "\", \"")
   07 result.replace("\n", "\"\n\"");
   08 result.prepend("\"");
   09 result.append("\"");
   10 return result;
   11 }
 
   12 QString MyTableWidget::toHtml(const QString &plainText)
   13 {
   14 QString result = Qt::escape(plainText);
   15 result.replace("\t", "<td>");
   16 result.replace("\n", "\n<tr><td>");
   17 result.prepend("<table>\n<tr><td>");
   18 result.append("\n</table>");
   19 return result;
   20 }
   Функции toCsv() и toHtml() преобразуют строку со знаками табуляции и конца строки в формат CSV (comma—separated values — значения, разделенные запятыми) и HTML соответственно. Например, данные
   Red Green Blue
   Cyan Yellow Magenta
   преобразуются в
   "Red", "Green", "Blue"
   "Cyan", "Yellow", "Magenta"
   или в
   <table>
   <tr><td>Red<td>Green<td>Blue
   <tr><td>Cyan<td>Yellow<td>Magenta
   </table>
   Преобразование выполняется самым простым из возможных способов с применением функции QString::replace(). Для удаления специальных символов формата HTML мы используем функцию Qt::escape().
   01 void MyTableWidget::dropEvent(QDropEvent *event)
   02 {
   03 if (event->mimeData()->hasFormat("text/csv")) {
   04 QByteArray csvData = event->mimeData()->data("text/csv");
   05 QString csvText = QString::fromUtf8(csvData);
   06 …
   07 event->acceptProposedAction();
   08 } else if (event->mimeData()->hasFormat("text/plain")) {
   09 QString plainText = event->mimeData()->text();
   10 …
   11 event->acceptProposedAction();
   12 }
   13 }
   Хотя мы предоставляем данные в трех разных форматах, мы принимаем в dropEvent() только два из них. Если подьзователь переносит ячейки из таблицы QTableWidget в редактор HTML, нам нужно, чтобы ячейки были преобразованы в таблицу HTML. Но если пользователь переносит произвольный текст HTML в таблицу QTableWidget, мы не станем его принимать.
   Для того чтобы этот пример заработал, нам потребуется также вызвать setAcceptDrops(true) и setSelectionMode(ContiguousSelection) в конструкторе MyTableWidget.
   Теперь мы переделаем этот пример, но на этот раз мы создадим подкласс QMimeData, чтобы отложить или избежать (потенциально затратных) преобразований между элементами QTableWidgetltem и массивом QByteArray. Ниже приводится определение нашего подкласса:
   01 class TableMimeData : public QMimeData
   02 {
   03 Q_OBJECT
   04 public:
   05 TableMimeData(const QTableWidget *tableWidget,
   06 const QTableWidgetSelectionRange &range);
   07 const QTableWidget *tableWidget() const
   08 { return myTableWidget; }
   09 QTableWidgetSelectionRange range() const { return myRange; }
   10 QStringList formats() const;
 
   11 protected:
   12 QVariant retrieveData(const QString &format,
   13 QVariant::Type preferredType) const;
 
   14 private:
   15 static QString toHtml(const QString &plainText);
   16 static QString toCsv(const QString &plainText);
   17 QString text(int row, int column) const;
   18 QString rangeAsPlainText() const;
   19 const QTableWidget *myTableWidget;
   20 QTableWidgetSelectionRange myRange;
   21 QStringList myFormats;
   22 };
   Вместо реальных данных мы храним объект QTableWidgetSelectionRange, который определяет область переносимых ячеек и сохраняет указатель на QTableWidget. Функции formats() и retrieveData() класса QMimeData переопределяются.
   01 TableMimeData::TableMimeData(const QTableWidget *tableWidget,
   02 const QTableWidgetSelectionRange &range)
   03 {
   04 myTableWidget = tableWidget;
   05 myRange = range;
   06 myFormats << "text/csv" << "text/html" << "text/plain";
   07 }
   В конструкторе мы инициализируем закрытые переменные.
   01 QStringList TableMimeData::formats() const
   02 {
   03 return myFormats;
   04 }
   Функция formats() возвращает список MIME—типов, находящихся в объекте MIME—данных. Последовательность форматов обычно несущественна, однако на практике желательно первыми указывать «лучшие» форматы. Приложения, поддерживающие несколько форматов, иногда будут использовать первый подходящий.
   01 QVariant TableMimeData::retrieveData(const QString &format,
   02 QVariant::Type preferredType) const
   03 {
   04 if (format == "text/plain") {
   05 return rangeAsPlainText();
   06 } else if (format =="text/csv") {
   07 return toCsv(rangeAsPlainText()); }
   08 else if (format == "text/html") {
   09 return toHtml(rangeAsPlainText());
   10 } else {
   11 return QMimeData::retrieveData(format, preferredType);
   12 }
   13 }
   Функция retrieveData() возвращает данные для заданного MIME—типа в виде объекта QVariant. Параметр format обычно содержит одну из строк, возвращенных функцией formats(), однако нам не следует на это рассчитывать, поскольку не все приложения проверяют MIME—тип на соответствие форматам функции formats(). Предусмотренные в классе QMimeData функции получения данных text(), html(), urls(), imageData(), colorData() и data() реализуются с помощью функции retrieveData().
   Параметр preferredType определяет тип, который следует поместить в объект QVariant. Здесь мы его игнорируем и рассчитываем на то, что QMimeData преобразует при необходимости возвращенное значение в требуемый тип.
   01 void MyTableWidget::dropEvent(QDropEvent *event)
   02 {
   03 const TableMimeData *tableData =
   04 qobject_cast<const TableMimeData *>(event->mimeData());
   05 if (tableData) {
   06 const QTableWidget *otherTable = tableData->tableWidget();
   07 QTableWidgetSelectionRange otherRange = tableData->range();
   08 …
   09 event->acceptProposedAction();
   10 } else if (event->mimeData()->hasFormat("text/csv")) {
   11 QByteArray csvData = event->mimeData()->data("text/csv");
   12 QString csvText = QString::fromUtf8(csVData);
   13 …
   14 event->acceptProposedAction();
   15 } else if (event->mimeData()->hasFormat("text/plain")) {
   16 QString plainText = event->mimeData()->text();
   17 …
   18 event->acceptProposedAction();
   19 }
   20 QTableWidget::mouseMoveEvent(event);
   21 }
   Функция dropEvent() аналогична функции с тем же названием, которую мы рассматривали ранее в данном разделе, но на этот раз мы ее оптимизируем, делая вначале проверку возможности приведения типа QMimeData в тип TableMimeData. Если qobject_cast<T>() срабатывает, это значит, что перенос был инициирован виджетом MyTableWidget, расположенным в том же самом приложении, и мы можем получить непосредственный доступ к данным таблицы вместо того, чтобы пробираться сквозь программный интерфейс класса QMimeData. Если приведение типов оказывается неудачным, мы извлекаем данные стандартным способом.
   В этом примере мы кодировали CSV—текст, используя кодировку UTF-8. Если бы мы хотели быть уверенными в применении правильной кодировки, мы могли бы использовать параметр charset в MIME—типе text/plain для явного задания типа кодировки. Ниже приводится несколько примеров:
   text/plain; charset=US-ASCII
   text/plain; charset=ISO-8859-1
   text/plain; charset=Shift_JIS
   text/plain; charset=UTF-8