1.1. Hello, Qt!

Ниже приводится текст простейшей Qt программы:

 1 #include <qapplication.h>
 
  2 #include <qlabel.h>
  3 int main(int argc, char *argv[])
  4 {
  5     QApplication app(argc, argv);
  6     QLabel *label = new QLabel("Hello, Qt!", 0);
  7     app.setMainWidget(label);
  8     label->show();
  9     return app.exec();
 10 }
       
 

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

В строке 6 создается визуальный компонент QLabel, который отображает надпись "Hello, Qt!". В терминологии Qt, все визуальные компоненты, из которых строится графический интерфейс, называются виджетами (widgets). Кнопки, меню, полосы прокрутки и разнообразные рамки -- все это виджеты. Одни виджеты могут содержать в себе другие виджеты, например, главное окно приложения -- это самый обычный виджет, который может содержать QMenuBar, QToolBar, QStatusBar и др. Аргумент 0,передаваемый конструктору QLabel (в строке 6) -- это "пустой" (null) указатель, который сообщает о том, что этот виджет не имеет "хозяина", т.е. не включается в другой виджет.

В строке 7 назначается "главный" виджет приложения. Когда пользователь закрывает "главный" виджет приложения (например, нажатием на кнопку "X" в заголовке окна), то программа завершает свою работу. Если в программе не назначить главный виджет, то она продолжит исполнение в фоновом режиме даже после того, как пользователь закроет окно.

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

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

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

Теперь самое время проверить работу нашего приложения. Но прежде всего -- необходимо, чтобы у вас была установлена Qt 3.2 (или более поздняя версия), а переменная окружения PATH содержала корректный путь к каталогу bin. (В Windows настройка переменной PATH выполняется автоматически, в процессе установки библиотеки Qt)

Скопируйте текст программы в файл, с именем hello.cpp, в каталог hello.

Перейдите в этот каталог и дайте команду:

qmake -project      
       
 

qmake hello.pro      
       
 
 

qmake -tp vc hello.pro      
       
 

А теперь немного развлечемся. Изменим внешний вид метки, добавив форматирование текста в стиле HTML. Для этого, замените строку

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

QLabel *label = new QLabel("<h2 ><i>Hello</i> "
                            "<font color=red>Qt!</font></h2>", 0);
       
 
 

1.2. Обработка сигналов.

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

 1 #include <qapplication.h>
 
  2 #include <qpushbutton.h> 
  3 int main(int argc, char *argv[]) 
  4 { 
  5   QApplication app(argc, argv); 
  6   QPushButton *button = new QPushButton("Quit", 0);      
  7   QObject::connect(button, SIGNAL(clicked()), 
  8                    &app, SLOT(quit())); 
  9   app.setMainWidget(button); 
 10   button->show(); 
 11   return app.exec(); 
 12 }
       
 

Теперь соберем приложение. Надеемся, что вы уже создали каталог quit и разместили в нем файл quit.cpp. Дайте команду qmake, для создания файла проекта, а затем второй раз -- для создания Makefile:

qmake -project 
 qmake quit.pro      
       
 
 

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

Приложение содержит три виджета: QSpinBox, QSlider и QHBox (область горизонтальной разметки). Главным виджетом приложения назначен QHBox. Компоненты QSpinBox и QSlider помещены внутрь QHBox и являются подчиненными, по отношению к нему.

 1     #include <qapplication.h> 
  2      #include <qhbox.h>
 
  3      #include <qslider.h>
  4      #include <qspinbox.h>
  5      int main(int argc, char *argv[]) 
  6      { 
  7        QApplication app(argc, argv); 
  8        QHBox *hbox = new QHBox(0); 
  9        hbox->setCaption("Enter Your Age"); 
 10        hbox->setMargin(6); 
 11        hbox->setSpacing(6); 
 12        QSpinBox *spinBox = new QSpinBox(hbox); 
 13        QSlider *slider = new QSlider(Qt::Horizontal, hbox); 
 14        spinBox->setRange(0, 130); 
 15        slider->setRange(0, 130); 
 16        QObject::connect(spinBox, SIGNAL(valueChanged(int)), 
 17                         slider, SLOT(setValue(int))); 
 18        QObject::connect(slider, SIGNAL(valueChanged(int)), 
 19                         spinBox, SLOT(setValue(int))); 
 20        spinBox->setValue(35); 
 21        app.setMainWidget(hbox); 
 22        hbox->show(); 
 23        return app.exec(); 
 24      }      
       
 
 

В строках 12 и 13 создаются QSpinBox и QSlider, которым, в качестве владельца, назначается QHBox.

Не смотря на то, что мы явно не задали ни положение, ни размеры виджетов QSpinBox и QSlider, тем менее они очень аккуратно расположились внутри QHBox. Собственно для этого и предназначен QHBox. Он выполняет автоматическое размещение подчиненных виджетов, назначая им координаты размещения и размеры, в зависимости от их требований и собственных настроек. В Qt имеется много классов, подобных QHBox, которые избавляют нас от рутинной работы по ручной подгонке положения и размеров визуальных компонентов.

В строках 14 и 15 устанавливаются допустимые пределы изменения счетчика и ползунка. (Мы можем смело предположить, что возраст нашего пользователя едва ли превысит 130 лет.) Два вызова connect(), в строках с 16 по 19 синхронизируют ползунок и счетчик, благодаря чему они всегда будут отображать одно и то же значение. Всякий раз, когда значение одного из виджетов изменяется, он посылает сигнал valueChanged( int ), который поступает в слот setValue( int ) другого виджета.

В строке 20 устанавливается первоначальное значение (35) счетчика. Когда это происходит, счетчик посылает сигнал valueChanged(int), со значением входного аргумента, равным 35. Это число передается в слот setValue(int) виджета QSlider, который устанавливает значение этого виджета равным 35. После этого уже QSlider посылает сигнал valueChanged(int), поскольку его значение только что изменилось, вызывая таким образом слот setValue(int) виджета QSpinBox. Но на этот раз счетчик не посылает сигнал, поскольку его значение и так было равно 35. Таким образом предотвращается бесконечная рекурсия. Рисунок 1.6 иллюстрирует эту ситуацию.

В строке 22 QHBox делается видимым (вместе со всеми подчиненными виджетами).

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

1.3. Работа со справочной системой.

Справочная система в Qt -- это пожалуй самый основной инструмент любого разработчика. Она описывает все классы и функции в этой библиотеке. (Документация к Qt 3.2 включает в себя описанее более 400 классов и 6000 функций.) В этой книге вы встретитесь с большим количеством классов и функций Qt, но далеко не со всеми. Поэтому совершенно необходимо, чтобы вы самостоятельно ознакомились со справочной системой Qt.

 
     ./age -style=Platinum        
             
 

Документация хранится в каталоге doc\html в виде html-файлов. Для ее просмотра может использоваться любой web-браузер. Но Qt имеет свою утилиту просмотра документации -- Qt Assistant, которая предоставляет очень удобный способ навигации по справочнику, гораздо удобнее, чем этого можно добиться в web-браузере. Чтобы запустить утилиту -- выберите пункт Qt 3.2.x|Qt Assistant в меню "Пуск" операционной системы Windows или дайте команду assistant в Unix.

Ссылки в разделе "API Reference" дают возможность навигации по классам различными способами. Так например, перейдя по ссылке "All Classes" вы получите список всех классов библиотеки. По ссылке "Main Classes" -- только самые основные классы. В качестве упражнения попробуйте найти описания классов и функций, использовавшихся в нашем приложении. Обратите внимание: наследуемые методы описываются в базовых классах, например, описание класса QPushButton не содержит метода show(), поскольку он наследуется от класса QWidget. На рисунке ниже приводится диаграмма наследования для классов, использованных в нашем приложении:

Справочная документация для текущей версии Qt (и некоторых, более ранних версий) выкладывается в он-лайн по адресу: http://doc.trolltech.com/. Здесь же вы найдете отдельные статьи из ежеквартальника Qt Quarterly, который рассылается всем коммерческим пользователям.

2.1. Создание дочернего класса от QDialog.

Наш первый пример -- это диалог поиска. Диалог будет реализован в виде класса, со своей собственной функциональностью. Это будет независимый компонент со своими сигналами и слотами.

Исходные тексты приложения будут размещаться в двух файлах: finddialog.h и finddialog.cpp. Начнем с файла finddialog.h.

 1 #ifndef FINDDIALOG_H 
  2 #define FINDDIALOG_H 
  3 #include <qdialog.h>
 
  4 class QCheckBox; 
  5 class QLabel; 
  6 class QLineEdit; 
  7 class QPushButton;      
       
 

В строке 3 подключается определение класса QDialog -- базового для всех диалогов в Qt. QDialog порожден от класса QWidget.

Строки с 4 по 7 -- это опережающие описания классов Qt, которые используются в нашем диалоге. Опережающее описание сообщает компилятору C++ о том, что этот класс существует, но подробности описания класса (обычно расположенного в отдельном заголовочном файле) здесь использоваться не будут. Ниже мы еще вернемся к этой теме.

Теперь определим класс FindDialog, указав в качестве родительского класса QDialog:

 8 class FindDialog : public QDialog 
  9 { 
 10     Q_OBJECT 
 11 public: 
 12     FindDialog(QWidget *parent = 0, const char *name = 0);      
       
 
 

Далее следует типичный, для всех виджетов в Qt, конструктор -- FindDialog. Параметр parent задает "владельца", т.е. виджет, на котором будет размещен данный компонент, а параметр name -- имя (название) виджета. Параметр name не является обязательным, в основном он используется для нужд отладки и тестирования.

13 signals: 
 14     void findNext(const QString &str, bool caseSensitive); 
 15     void findPrev(const QString &str, bool caseSensitive);      
       
 

Ключевое слово signals, фактически является макроопределением. Препроцессор C++ преобразует его в стандартное представление C++ и только потом оно будет передано компилятору.

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      
       
 

Поскольку все поля-переменные -- это указатели, нам нет нужды подключать заголовочные файлы, содержащие полные определения этих классов. Благодаря наличию опережающего описания, компилятор удовольствуется тем, что есть. Вместо опережающего описания классов мы могли бы подключить соответствующие заголовочные файлы (<qcheckbox.h>, <qlabel.h> и т.д.), но это отрицательно скажется на скорости компиляции. Для маленьких приложений это не так заметно, но для больших проектов опережающее описание может дать существенный выигрыш.

Перейдем к файлу finddialog.cpp, который содержит реализацию класса FindDialog:

 1 #include <qcheckbox.h>
  2 #include <qlabel.h>
  3 #include <qlayout.h>
  4 #include <qlineedit.h>
 
  5 #include <qpushbutton.h>
  
  6 #include "finddialog.h"      
       
 

 7 FindDialog::FindDialog(QWidget *parent, const char *name) 
  8     : QDialog(parent, name) 
  9 { 
 10     setCaption(tr("Find")); 
 11     label = new QLabel(tr("Find &what:"), this); 
 12     lineEdit = new QLineEdit(this); 
 13     label->setBuddy(lineEdit); 
 14     caseCheckBox = new QCheckBox(tr("Match &case"), this); 
 15     backwardCheckBox = new QCheckBox(tr("Search &backward"), this); 
 16     findButton = new QPushButton(tr("&Find"), this); 
 17     findButton->setDefault(true); 
 18     findButton->setEnabled(false); 
 19     closeButton = new QPushButton(tr("Close"), this);      
       
 
 

В строке 10 задается надпись, которая будет выводиться в заголовке окна -- "Find". Функция tr() определена в классе QObject и любом другом подклассе, описание которого содержит вызов макроса Q_OBJECT. Она выполняет трансляцию текста, передаваемого ей, на другие языки человеческого общения. Считается хорошим тоном, все строки, которые будут выводиться на экран, передавать через эту функцию, даже в том случае, если вы не планируете интернационализацию своего приложения. Проблемы интернационализации будут подробно освещены в Главе 15.

Затем, начиная со строки 11, создаются подчиненные виджеты. Здесь символ амперсанда ('&') используется для обозначения клавиши быстрого доступа (акселератор). Например, в строке 16 создается кнопка Find, активировать которую можно нажатием на комбинацию клавиш Alt+F. Амперсанды так же могут использоваться для передачи фокуса ввода: в строке 11 создается метка, с акселератором (Alt+W), а в строке 13 метке назначается "дружественный" (buddy) компонент -- однострочное поле ввода. "Дружественный" виджет -- это такой компонент, который будет получать фокус ввода при нажатии ускоряющей комбинации клавиш метки. Таким образом, когда пользователь нажмет комбинацию клавиш Alt+W (акселератор метки), то фокус ввода будет передан "дружественному" виджету, т.е. -- полю ввода.

В строке 17, вызовом метода setDefault(true) [5] , назначается кнопка по-умолчанию. Кнопка по-умолчанию -- это такая кнопка, которая будет активироваться при нажатии на клавишу Enter. В строке 18 накладывается запрет на кнопку Find. Когда виджет запрещен, он обычно отображается в серых тонах и не реагирует на действия пользователя.

20 connect(lineEdit, SIGNAL(textChanged(const QString &)), 
 21     this, SLOT(enableFindButton(const QString &))); 
 22 connect(findButton, SIGNAL(clicked()), 
 23     this, SLOT(findClicked())); 
 24 connect(closeButton, SIGNAL(clicked()), 
 25     this, SLOT(close()));      
       
 

Поскольку QObject является одним из предков класса FindDialog, то мы можем опустить префикс QObject:: перед именем метода connect().

26     QHBoxLayout *topLeftLayout = new QHBoxLayout; 
 27     topLeftLayout->addWidget(label); 
 28     topLeftLayout->addWidget(lineEdit); 
 29     QVBoxLayout *leftLayout = new QVBoxLayout; 
 30     leftLayout->addLayout(topLeftLayout); 
 31     leftLayout->addWidget(caseCheckBox); 
 32     leftLayout->addWidget(backwardCheckBox); 
 33     QVBoxLayout *rightLayout = new QVBoxLayout; 
 34     rightLayout->addWidget(findButton); 
 35     rightLayout->addWidget(closeButton); 
 36     rightLayout->addStretch(1); 
 37     QHBoxLayout *mainLayout = new QHBoxLayout(this); 
 38     mainLayout->setMargin(11);
 39     mainLayout->setSpacing(6); 
 40     mainLayout->addLayout(leftLayout); 
 41     mainLayout->addLayout(rightLayout); 
 42 }      
       
 
 

В нашем приложении мы использовали два QHBoxLayout и два QVBoxLayout, как это показано на Рисунке 2.2. Внешний менеджер компоновки (mainLayout) является главным, поскольку при создании ему был назначен, в качестве владельца, экземпляр класса FindDialog -- (this). Он отвечает за размещение всех визуальных компонентов в области окна приложения. Оставшиеся 3 менеджера размещения являются подчиненными. Маленькая "пружинка", которая видна в правом нижнем углу рисунка -- это распорка (spacer). Она заполняет пустое пространство под кнопками Find и Close, заставляя их держаться в верхней части области выравнивания.

Здесь есть один важный момент. Менеджеры компоновки не являются виджетами. Они порождены от класса QLayout, который в свою очередь порожден от класса QObject. На рисунке, контуры виджетов отрисованы сплошными линиями, а областей компоновки -- пунктирными, чтобы подчеркнуть различия, имеющиеся между ними. Во время работы приложения, менеджеры размещения (области выравнивания) не видны.

Хотя менеджеры компоновки и не являются виджетами (визуальными компонентами), тем не менее они могут иметь как владельца, так и подчиненные компоненты. Понятия термина "владелец", у менеджера размещения и виджета, различаются. Если менеджер размещения встраивается в виджет (который передается менеджеру в качестве владельца), как это происходит в случае с mainLayout, то он автоматически встраивается в этот виджет. Если менеджер создается без владельца (в данном случае это: topLeftLayout, leftLayout и rightLayout), то он должен быть включен в состав другого менеджера, вызовом addLayout().

Механизм "владелец-подчиненный" реализован в классе QObject, который является предком как для QWidget, так и для QLayout. Когда создается некий объект (виджет, менеджер компоновки или что-то еще), для которого явно указывается владелец, то он добавляется владельцем в свой список подчиненных компонентов. Когда владелец уничтожается, он проходит по списку подчиненных компонентов и уничтожает их одного за другим. Подчиненные компоненты, в свою очередь просматривают свои списки и уничтожают компоненты, подчиненные им и так до тех пор, пока дело не дойдет до компонентов, которые не имеют подчиненных объектов.

Этот механизм упрощает управление памятью в приложении, снижая риск "утечки". Единственные объекты, которые необходимо уничтожать явно -- это те, которые были созданы оператором new, и не имеют владельца. Если первым удаляется подчиненный компонент, то Qt автоматически исключит его из списка владельца.

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

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

На рисунке 2.3 показано дерево "владелец-подчиненный" для приложения Find. Порядок взаимоотношений в этом дереве легко выводится из текста конструктора FindDialog, достаточно выделить строки, содержащие new и addLayout(). Важное замечание: Запомните, менеджеры размещения НЕ ЯВЛЯЮТСЯ владельцами виджетов, размещением которых они управляют.

В дополнение к менеджарам размещения, Qt предоставляет несколько виджетов размещения: QHBox (с которым мы уже встречались в Главе 1), QVBox и QGrid. Для своих подчиненных компонентов, эти классы выступают как в качестве владельцев так и в качестве менеджеров размещения. Для небольших приложений виджеты размещения более удобны, но они менее гибкие и требуют больший объем ресурсов, чем менеджеры.

На этом мы заканчиваем рассмотрение реализации конструктора FindDialog. Поскольку подчиненные виджеты и менеджеры размещения создавались нами с помощью оператора new, то, казалось бы, возникает необходимость в написании деструктора, который удалил бы из памяти все, созданные нами компоненты, во время завершения приложения. Однако в этом нет необходимости, поскольку Qt автоматически сделает это во время уничтожения владельца, т.е. во время уничтожения класса FindDialog.

Перейдем к рассмотрению слотов:

43 void FindDialog::findClicked() 
 44 { 
 45     QString text = lineEdit->text(); 
 46     bool caseSensitive = caseCheckBox->isOn(); 
 
 47     if (backwardCheckBox->isOn()) 
 48         emit findPrev(text, caseSensitive); 
 49     else 
 50         emit findNext(text, caseSensitive); 
 51 } 
 
 52 void FindDialog::enableFindButton(const QString &text) 
 53 { 
 54     findButton->setEnabled(!text.isEmpty()); 
 55 }      
       
 
 

Слот enableFindButton() вызывается, когда пользователь изменяет содержимое поля ввода. Если оно содержит какие-либо символы, то разрешается кнопка Find, в противном случае она запрещается.

Реализацией этих двух слотов завершается разработка нашего диалога. Теперь создадим файл main.cpp, в котором разместим текст основной программы для тестирования нашего виджета:

 1 #include <qapplication.h>
  
  2 #include "finddialog.h" 
  
  3 int main(int argc, char *argv[]) 
  4 { 
  5     QApplication app(argc, argv); 
  6     FindDialog *dialog = new FindDialog; 
  7     app.setMainWidget(dialog); 
  8     dialog->show(); 
  9     return app.exec(); 
 10 }      
       
 
 

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

Классы, в определении которых встречается макрос Q_OBJECT, должны обрабатываться компилятором метаобъектов в обязательном порядке. На самом деле, это не такая большая проблема, поскольку qmake автоматически добавит все необходимые правила в Makefile. Но если вы забудете перегенерировать Makefile, то линковщик будет "жаловаться" на отсутствие некоторых функций. Эти сообщения об ошибках могут порой вводить в заблуждение. Например, GCC выдает примерно такое предупреждение:

   finddialog.o(.text+0x28): undefined reference to  
    FindDialog::QPaintDevice virtual table    
       
 

   finddialog.obj : error LNK2001: unresolved external symbol 
    "public:~virtual bool __thiscall FindDialog::qt_property(int, 
    int,class QVariant *)"      
       
 

Теперь запустите программу. Проверьте работу акселераторов Alt+W, Alt+C, Alt+B и Alt+F. Попробуйте "пройтись" по виджетам с помощью клавиши Tab. По-умолчанию, порядок навигации с помощью клавиши Tab, соответствует порядку, в котором создавались компоненты. Но он может быть изменен вызовом метода QWidget::setTabOrder(). Установку акселераторов и настройку порядка навигации по компонентам, с помощью клавиши Tab, можно считать дружественным жестом в сторону пользователей, которые не могут или не хотят пользоваться мышью. Удобное управление с клавиатуры высоко оценят опытные пользователи.

В Главе 3 мы будем использовать наш диалог в реально работающем приложении. Там сигналы findPrev() и findNext() будут подключаться к соответствующим слотам.

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

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

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

Объявление connect() выглядит следующим образом:

connect(sender, SIGNAL(signal), receiver, SLOT(slot));      
       
 

• Один сигнал может быть подключен к нескольким слотам:

  connect(slider, SIGNAL(valueChanged(int)), 
           spinBox, SLOT(setValue(int))); 
   connect(slider, SIGNAL(valueChanged(int)), 
           this, SLOT(updateStatusBarIndicator(int)));          
               
   

  Когда подается сигнал, то функции-слоты вызываются одна за другой, в порядке подключения.
  
  

• К одному слоту может быть подключено несколько сигналов:

  connect(lcd, SIGNAL(overflow()), 
           this, SLOT(handleMathError())); 
   connect(calculator, SIGNAL(divisionByZero()), 
           this, SLOT(handleMathError()));            
               
   

  Когда посылается какой-либо из сигналов -- вызывается функция-слот.
  
  

• Сигнал может быть подключен к другому сигналу:

  connect(lineEdit, SIGNAL(textChanged(const QString &)), 
           this, SIGNAL(updateRecord(const QString &)));            
               
   

  Когда посылается первый сигнал, то вслед за ним подается и второй. С точки зрения программы, соединение типа сигнал-сигнал ничем не отличается от соединения типа сигнал-слот.
  
  

• Связь между сигналом и слотом может быть разорвана:

  disconnect(lcd, SIGNAL(overflow()), 
              this, SLOT(handleMathError()));            
               
   

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

connect(ftp, SIGNAL(rawCommandReply(int, const QString &)), 
         this, SLOT(processReply(int, const QString &)));      
       
 

Если типы входных аргументов не совместимы, или сигнал или слот не определены, Qt выдаст предупреждение во время исполнения. Точно так же Qt выдаст предупреждение, если в сигнатуры сигналов или слотов включены имена аргументов (в методе connect()).

До сих пор мы использовали сигналы и слоты исключительно с виджетами. Однако, этот механизм реализован непосредственно в классе QObject и область его применения не ограничивается графическим интерфейсом. Он может использоваться любым классом, наследником QObject:

class Employee : public QObject
 {
     Q_OBJECT
 public:
     Employee() { mySalary = 0; }
     int salary() const { return mySalary; }
 public slots:
     void setSalary(int newSalary);
 signals:
     void salaryChanged(int newSalary);
 private:
     int mySalary;
 };
 void Employee::setSalary(int newSalary)
 {
     if (newSalary != mySalary) {
          mySalary = newSalary;
          emit salaryChanged(mySalary);
     }
 }
       
 

Обратите внимание на реализацию слота setSalary(). Сигнал salaryChanged() посылается только в том случае, когда newSalary != mySalary. Такой способ предотвращает попадание в бесконечный цикл при наличии обратной связи с другим объектом.

2.3. Быстрая разработка диалогов.

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

В этом разделе мы, с помощью Qt Designer, напишем диалог Go-to-Cell ("Перейти к ячейке"), показанный на рисунке 2.4. Совершенно неважно, как разрабатывается диалог -- вручную ли, или с помощью Qt Designer, всегда выполняется одна и та же последовательность действий:

• Создаются и инициализируются подчиненные виджеты.

• Подчиненные виджеты вставляются в менеджеры размещения.

• Настраивается порядок навигации по виджетам клавишей Tab.

• Устанавливаются соединения сигнал-слот

• Реализуются дополнительные слоты диалога, если это необходимо.

Чтобы запустить Qt Designer, выберите пункт Qt 3.2.x|Qt Designer в меню "Пуск" -- в ОС Windows или дайте команду designer -- в Unix. После того как программа запустится, она предложит на выбор список шаблонов. Щелкните по шаблону "Dialog" и нажмите кнопку OK. После этого перед вами должна появиться заготовка будущего окна диалога с именем "Form1".

Для начала разместим виджеты на форме. На инструментальной панели, слева, щелкните по компоненту TextLabel, затем щелкните по форме -- в результате на форме появится компонент "метка". Аналогичным образом разместите на форме одно поле ввода (LineEdit), одну горизонтальную распорку (Spacer) и две кнопки (PushButton). Разместите их так, чтобы у вас получилось нечто похожее на рисунок 2.6. Не тратьте слишком много времени на позиционирование виджетов. Мы все равно будем использовать менеджеры размещения, которые выполнят эту работу за нас.

Распорка (spacer) отображается на заготовке в виде синей пружинки. Во время работы уже готовой программы распорки не будут отображаться.

Установите свойства для каждого из виджетов, используя Редактор свойств, расположенный в правой части главного окна Qt Designer.

1. Щелкните по компоненту TextLabel и запишите в его свойство name строку "label", а в свойство text -- "&Cell Location:".

2. Щелкните по компоненту LineEdit и запишите в свойство name строку "lineEdit".

3. Для распорки запишите в свойство orientation "Horizontal".

4. Для первой кнопки запишите в свойство name строку "okButton", в свойство enabled -- "False", в свойство default -- "True" и в свойство text -- "OK".

5. Для второй кнопки. Запишите в свойство name строку "cancelButton", а в свойство text -- в "OK".

6. Щелкните в любом свободном месте формы и запишите в свойство name строку "GoToCellDialog", а в свойство caption -- "Go to Cell".

Но это еще не все, нам нужно назначить дружественный компонент для метки, который будет реагировать на акселератор Alt+C. На данный момент метка отображается как "&Cell Location:". Выберите пункт меню Tools|Set Buddy (курсор мыши приобретет вид крестика). Затем поместите указатель мыши на метку, нажмите левую кнопку и, удерживая ее в нажатом положении, переместите указатель мыши на компонент LineEdit. Затем отпустите кнопку мыши. Изображение метки изменится -- символ амперсанда исчезнет, а первый символ метки приобретет знак подчеркивания. В принципе, то же самое можно сделать внутри редактора свойств, установкой свойства buddy метки.

Следующий шаг -- размещение виджетов на форме с помощью менеджеров компоновки:

1. Щелкните мышью по метке. Нажмите клавишу Shift и удерживая ее -- щелкните по полю ввода. Оба компонента окажутся выделенными. Теперь выберите пункт меню Layout|Lay Out Horizontally.

2. Щелкните мышью по распорке. Нажмите клавишу Shift и удерживая ее -- щелкните сначала по кнопке "OK", а затем по кнопке "Cancel". Теперь выберите пункт меню Layout|Lay Out Horizontally.

3. Щелкните по свободному пространству на форме и выберите пункт меню Layout|Lay Out Vertically.

4. Выберите пункт меню Layout|Adjust Size.

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

Теперь выберите пункт меню Tools|Tab Order. На каждом из виджетов, которые могут принимать фокус, появятся цифры в синих кружочках. Щелчками мыши по компонентам установите желаемый порядок навигации клавишей Tab и нажмите Esc.

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

Для начала создадим новый слот: щелкните по кнопке Edit Slots.... Перед вами откроется окно редактора слотов (см. рис. 2.11). Создайте приватный слот с именем enableOkButton().

Затем необходимо настроить три соединения. Чтобы создать соединение -- щелкните по кнопке "New" и установите поля Sender, Signal, Receiver и Slot, выбирая требуемые значения из выпадающих списков в каждом из них. У вас должно получиться следующее:

okButton   clicked()      GoToCellDialog   accept()
 cancelButton  clicked()     GoToCellDialog   reject()      
 lineEdit textChanged(const QString &) GoToCellDialog enableOkButton()
       
 

Чтобы посмотреть, как будет выглядеть окно диалога во время работы программы -- выберите пункт меню Preview|Preview Form. Проверьте порядок навигации клавишей Tab. Проверьте работу акселератора Alt+C (поле ввода должно получить фокус ввода). Нажмите кнопку Cancel, чтобы закрыть окно.

Сохраните результаты работы в файле gotocelldialog.ui в каталоге gotocell и создайте файл main.cpp, в том же каталоге, с помощью обычного текстового редактора:

#include <qapplication.h>
 #include "gotocelldialog.h"
 int main(int argc, char *argv[])
 {
     QApplication app(argc, argv);
     GoToCellDialog *dialog = new GoToCellDialog;
     app.setMainWidget(dialog);
     dialog->show();
     return app.exec();
 }
       
 

Вся прелесть Qt Designer-а состоит в том, что вы можете свободно изменять дизайн формы без необходимости вторгаться в исходный код на C++. Когда разработка дизайна ведется в тексте программы (вручную) то это может отнять довольно значительное время. Qt Designer сохранит ваши силы и время.

Если теперь запустить программу, то вы заметите:

• Кнопка "OK" всегда остается запрещенной.

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

Щелкните дважды по свободному пространству на форме, чтобы вызвать редактор исходного кода. В окне редактора добавьте следующие строки:

#include <qvalidator.h>
 void GoToCellDialog::init()
 {
     QRegExp regExp("[A-Za-z][1-9][0-9]{0,2}");
     lineEdit->setValidator(new QRegExpValidator(regExp, this));
 }
 void GoToCellDialog::enableOkButton()
 {
     okButton->setEnabled(lineEdit->hasAcceptableInput());
 }
       
 
 

Передавая аргумент this (в вызов конструктора QRegExpValidator()), мы делаем объект класса QRegExpValidator подчиненным, по отношению к GoToCellDialog. Таким образом мы снимаем с себя ответственность за удаление этого объекта из памяти по завершении работы приложения.

Слот enableOkButton() разрешает или запрещает кнопку "OK", в зависимости от того, насколько правильный номер ячейки содержится в поле ввода. Для проверки правильности используется функция QLineEdit::hasAcceptableInput(), которая обращается к объекту класса QRegExpValidator, созданному в функции init().

После этого опять сохраните диалог. Qt Designer сохранит оба файла -- и gotocelldialog.ui, и gotocelldialog.ui.h. Пересоберите приложение и запустите его. Введите в поле ввода строку "A12" -- кнопка "OK" перейдет в разрешенное состояние. Попробуйте набрать произвольный текст и понаблюдайте за тем, как работает проверка корректности ввода. Нажмите кнопку "Cancel", чтобы завершить работу программы.

В этом примере мы создали диалог с помощью Qt Designer и добавили некоторый код, с помощью редактора исходного кода Qt Designer-а. Интерфейсная часть диалога была сохранена в файле gotocelldialog.ui (по сути файл формата XML), а исходный текст -- в файле gotocelldialog.ui.h. Это очень удобно, поскольку gotocelldialog.ui.h можно править в любом текстовом редакторе.

Альтернативный подход заключается в разработке формы с помощью Qt Designer (как обычно), а затем создается дополнительный класс, порожденный от класса формы, в котором реализуется вся необходимая функциональность. Например, для нашего диалога Go-to-Cell можно было бы создать класс GoToCellDialogImpl, как наследник класса GoToCellDialog и реализовать в нем все необходимые функции. В результате такого подхода, новый заголовочный файл должен получиться таким:

#ifndef GOTOCELLDIALOGIMPL_H
 #define GOTOCELLDIALOGIMPL_H
 #include "gotocelldialog.h"
 class GoToCellDialogImpl : public GoToCellDialog
 {
     Q_OBJECT
 public:
     GoToCellDialogImpl(QWidget *parent = 0, const char *name = 0);
 private slots:
     void enableOkButton();
 };
 #endif
       
 

#include <qlineedit.h>
 #include <qpushbutton.h>
 #include <qvalidator.h>
 #include "gotocelldialogimpl.h"
 GoToCellDialogImpl::GoToCellDialogImpl(QWidget *parent,
                                        const char *name)
     : GoToCellDialog(parent, name)
 {
     QRegExp regExp("[A-Za-z][1-9][0-9]{0,2}");
     lineEdit->setValidator(new QRegExpValidator(regExp, this));
 }
 void GoToCellDialogImpl::enableOkButton()
 {
     okButton->setEnabled(lineEdit->hasAcceptableInput());
 }
       
 

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

В данной книге мы будем работать только с файлами .ui.h, поскольку это наиболее общеупотребимая практика, а создание дочерних классов, с помощью uic, довольно простая задача. Чтобы поглубже разобраться в различиях этих двух подходов, рекомендуем прочитать главу "Designer Approach" в справочном руководстве, поставляемом вместе с Qt Designer. Кроме того, прочитайте главу "Creating Dialogs", где показывается, как можно использовать вкладку "Members" для создания полей (переменных-членов) в классе формы.

2.4. Диалоги с изменяющимся внешним видом.

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

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

Это диалог сортировки, используемый в электронных таблицах. Он появляется, когда пользователь пытается отсортировать данные по одному или нескольким столбцам. В сокращенном представлении диалог позволяет выбрать столбец и порядок сортировки, в расширенном варианте добавляется возможность указать еще два столбца и порядок сортировки по каждому из них. Кнопка "More" позволяет переходить из сокращенного режима -- в расширенный и обратно.

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

1. Положите на заготовку формы GroupBox, два TextLabel, два ComboBox и одну горизонтальную распорку.

2. "Растяните" GroupBox побольше, ухватив мышкой за правый нижний его угол.

3. Разместите виджеты внутри GroupBox-а примерно так, как показано на рисунке 2.14(а)

4. Ухватив мышкой за правый край второго ComboBox-а, сделайте его примерно в два раз больше первого.

5. Запишите в свойство title, GroupBox-а, строку "&Primary Key". В свойство text первой метки -- "Column:", второй метки -- "Order:".

6. Щелкните мышкой дважды по первому ComboBox. Перед вами появится окно редактора, в котором добавьте один элемент с текстом "None".

7. Щелкните мышкой дважды по второму ComboBox и добавьте элементы "Ascending" и "Descending".

8. Теперь скомпонуем виджеты внутри GroupBox, для этого, щелкните по GroupBox и выберите пункт меню Layout|Lay Out in a Grid. В результате вы должны получить нечто похожее на рисунок 2.14(б).

Если компоновка выполнилась не так как надо или вы допустили какую нибудь ошибку, вы всегда можете выбрать пункт меню Edit|Undo и отменить произведенное действие. После чего можете повторить попытку.

Теперь добавим группы виджетов для расширенного представления:

1. Растяните форму диалога, чтобы хватило места для дополнительных виджетов. Выберите GroupBox и скопируйте его в буфер обмена, выбрав пункт меню Edit|Copy. Вставьте новые группы виджетов, дважды выбрав пункт меню Edit|Paste. Переместите новые GroupBox-ы на свои места. Измените у них свойство title.

2. Создайте кнопки "OK", "Cancel" и "More".

3. Для кнопки "OK" установите свойство default в TRUE.

4. Добавьте две вертикальные распорки.

5. Расположите кнопки "OK", "Cancel" и "More" по вертикали. Переместите одну из распорок так, чтобы она встала между кнопками "Cancel" и "More". Выделите все четыре элемента и выберите пункт меню Layout|Lay Out Vertically.

6. Вторую распорку переместите так, чтобы она встала между первым и вторым GroupBox.

7. Установите свойство sizeHint у вертикальных распорок в значение (20, 10).

8. Разместите виджеты так, как это показано нарисунке 2.15(а).

9. Выберите пункт меню Layout|Lay Out in a Grid. У вас должна получиться заготовка, показанная на рисунке 2.15(б)

В результате такого размещения мы получили "сетку" из двух колонок и четырех строк -- всего восемь ячеек. Первый GroupBox, левая вертикальная распорка, второй и третий GroupBox занимают по одной ячейке. Кнопки "OK", "Cancel", "More" и правая вертикальная распорка занимают две ячейки. И вправом нижнем углу диалога у нас остаются две пустых ячейки. Если у вас не получилась такая компоновка виджетов -- отмените ее и повторите попытку.

Проверьте свойство формы resizeMode. Оно должно быть установлено как "Fixed", благодаря чему пользователь не сможет растягивать окно диалога. Тогда, всю ответственность за размер окна диалога возьмут на себя менеджеры размещения, изменяя его в случае, когда подчиненные виджеты показываются или скрываются. Это гарантирует показ окна диалога с оптимальными размерами.

Дайте форме имя "SortDialog" и установите свойство caption в "Sort". Дайте имена виджетам, в соответствии с рисунком 2.16.

В заключение соединим сигналы и слоты:

1. Соедините okButton clicked() с SortDialog accept()

2. Соедините cancelButton clicked() с SortDialog reject()

3. Соедините moreButton toggled(bool) с secondaryGroupBox setShown(bool)

4. Соедините moreButton toggled(bool) с tertiaryGroupBox setShown(bool)

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

 1 void SortDialog::init()
  2 {
  3     secondaryGroupBox->hide();
  4     tertiaryGroupBox->hide();
  5     setColumnRange('A', 'Z');
  6 }
  
  7 void SortDialog::setColumnRange(QChar first, QChar last)
  8 {
  9     primaryColumnCombo->clear();
 10     secondaryColumnCombo->clear();
 11     tertiaryColumnCombo->clear();
 
 12     secondaryColumnCombo->insertItem(tr("None"));
 13     tertiaryColumnCombo->insertItem(tr("None"));
 
 14     primaryColumnCombo->setMinimumSize(
 15             secondaryColumnCombo->sizeHint());
 16     QChar ch = first;
 17     while (ch <= last) {
 18         primaryColumnCombo->insertItem(ch);
 19         secondaryColumnCombo->insertItem(ch);
 20         tertiaryColumnCombo->insertItem(ch);
 21         ch = ch.unicode() + 1;
 22     }
 23   }
       
 
 

Слот setColumnRange() инициализирует содержимое выпадающих списков, в соответствии с именами выделенных колонок в электронной таблице. Мы вставили элемент "None", во второй и третий выпадающий списки, на тот случай, если пользователь пожелает выполнить сортировку только по одному столбцу. Не смотря на то, что мы не создавали это слот в Qt Designer, тем не менее он его обнаружит самостоятельно, а uic создаст соответствующее объявление в определении класса SortDialog.

В строках 14 и 15 можно наблюдать один хитрый трюк, связаный с размещением компонента. Функция QWidget::sizeHint() возвращает "идеальный" размер виджета, который пробует соблюсти система размещения. Дело в том, что виджетам с различным содержимым могут быть заданы различные размеры. Для выпадающих списков это означает, что второй и третий списки, содержащие слово "None", могут иметь больший размер, чем первый, в котором указано односимвольное имя столбца. Чтобы избежать такой несогласованности, мы задаем мнимальный размер, для первого выпадающего списка, равный "идеальному" размеру второго.

Ниже приводится текст функции main(), которая устанавливает диапазон выделенных столбцов от "C" до "F" и затем вызывает диалог:

#include <qapplication.h>
 
 #include "sortdialog.h"
 int main(int argc, char *argv[])
 {
     QApplication app(argc, argv);
     SortDialog *dialog = new SortDialog;
     app.setMainWidget(dialog);
     dialog->setColumnRange('C', 'F');
     dialog->show();
     return app.exec();
 }
       
 

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

• В качестве основы можно использовать QTabWidget. Сверху он имеет набор вкладок, которые управляются встроенным QWidgetStack.

• Можно использовать связку QListBox и QWidgetStack, в которой текущий элемент QListBox-а определяет страницу в QWidgetStack.

• Или связку из классов QListView или QIconView и QWidgetStack, объединяемые так же как и в случае с QListBox.

2.5. Динамические диалоги.

Динамическими называются такие диалоги, которые создаются на основе .ui файлов во время работы программы (то бишь "на лету"). В случае с динамическими диалогами, файлы .ui не конвертируются утилитой uic в код C++, а загружаются программой во время исполнения, с помощью класса QWidgetFactory, примерно таким образом:

QDialog *sortDialog = (QDialog *)
                       QWidgetFactory::create("sortdialog.ui");
       
 

QComboBox *primaryColumnCombo = (QComboBox *)
         sortDialog->child("primaryColumnCombo", "QComboBox");
       
 

Класс QWidgetFactory размещен в отдельной библиотеке. Чтобы иметь возможность работы с классом QWidgetFactory из Qt приложений, необходимо добавить такую строчку в .pro файл:

LIBS += -lqui      
       
 

Динамические диалоги позволяют изменять компоновку формы без необходимости пересборки приложения. Исчерпывающий пример работы с динамическими диалогами вы найдете в главе "Subclassing and Dynamic Dialogs" справочного руководства к Qt Designer.

2.6. Встроенные виджеты и классы диалогов.

Qt предоставляет полный набор встроенных виджетов и диалогов общего назначения, которые подойдут в большинстве ситуаций. В этом разделе мы представим изображения большинства из них. Некоторые из специализированных визуальных компонентов будут рассматриваться ниже, в Главе 3 (QMenuBar, QPopupMenu и QToolBar) и в Главе 12 (компоненты для работы с базами данных, такие как QDataView и QDataTable). Большинство из встроенных виджетов и диалогов будут использоваться в примерах программ в данной книге. Ниже представлены скриншоты виджетов в классическом Windows-стиле.

В Qt имеется три вида "кнопок": QPushButton, QCheckBox и QRadioButton. Кнопка типа QPushButton обычно используется для того, чтобы инициировать какое-либо действие. Может работать как кнопка с фиксацией (первый щелчок, чтобы нажать, второй -- чтобы отпустить). Кнопки типа QRadioButton обычно используются совместно с QButtonGroup и работают как группа кнопок с взаимозависимой фиксацией, т.е. в каждой группе кнопок, в нажатом состоянии может находиться только одна из них. Кнопки типа QCheckBox, в отличие от QRadioButton, работают как кнопки с взаимонезависимой фиксацией.

Контейнеры в Qt -- это виджеты, которые могут содержать в себе другие виджеты. Кроме того, контейнер QFrame может использоваться как самостоятельный виджет, для рисования линий. Здесь не показан контейнер QButtonGroup, визуально он идентичен контейнеру QGroupBox.

Контейнеры QTabWidget и QToolBox -- это многостраничные виджеты. Каждая страница -- это подчиненный виджет. Нумерация страниц начинается с 0.

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

Виджет QLabel используется для вывода надписей в форматированном виде (с использованием простейших тегов HTML)

Виджет QTextBrowser (здесь не приводится), порожден от QTextEdit и предназначен для вывода текста в режиме read-only (только для чтения). Обладает поддержкой синтаксиса HTML, которая включает в себя поддержку списков, таблиц, изображений и гиперссылок. Qt Assistant использует этот виджет для вывода текста документации.

Виджет QLineEdit обладает возможностью наложения ограничений на вводимые символы с помощью маски ввода или проверки корректности ввода (validator). Виджет QTextEdit, наследник класса QScrollView, обладает возможностью редактирования текста большого объема.

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

В операционных системах Windows и Mac OS X, по мере возможности, используются "родные" диалоги.

В Qt так же имеется целый ряд диалогов обратной связи с пользователем. Диалоги QMessageBox и QErrorMessage используются для вывода сообщений, причем последний запоминает -- выводилось ли это сообщение ранее. Операции, протяженные по времени, могут быть оформлены в виде QProgressDialog, показывающего ход выполнения работы. Для того, чтобы запросить у пользователя ввод одной строки или числа, очень удобно использовать QInputDialog.

И последний диалог, который мы покажем -- это QWizard, своего рода каркас для создания разного рода "мастеров".

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

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

3.1. Создание класса-наследника от QMainWindow.

Главное окно любого приложения -- это класс-наследник QMainWindow. Большинство приемов, используемых при создания диалогов и о которых мы говорили в Главе 2, вполне применимы и при создании главного окна приложения.

Главное окно может быть создано в Qt Designer, но мы все будем делать "вручную", чтобы продемонстрировать процесс создания главного окна во всех деталях. Если вы предпочитаете визуальное проектирование -- прочитайте главу "Creating a Main Window Application" в справочном руководстве к Qt Designer.

Исходные тексты главного окна будут располагаться в двух файлах: mainwindow.cpp и mainwindow.cpp. Начнем с файла заголовка:

#ifndef MAINWINDOW_H 
 #define MAINWINDOW_H 
 #include <qmainwindow.h> 
 #include <qstringlist.h> 
 class QAction; 
 class QLabel; 
 class FindDialog; 
 class Spreadsheet; 
 
 class MainWindow : public QMainWindow 
 { 
   Q_OBJECT 
 public: 
   MainWindow(QWidget *parent = 0, const char *name = 0); 
 
 protected: 
   void closeEvent(QCloseEvent *event); 
   void contextMenuEvent(QContextMenuEvent *event);      
       
 

Функция closeEvent(), в классе QWidget, объявлена как виртуальная. Она автоматически вызывается перед завершением приложения. Мы перекрываем ее в MainWindow для того, чтобы иметь возможность спросить у пользователя -- желает ли он сохранить произведенные изменения, а также для того, чтобы сохранить на диск пользовательские настройки.

Аналогично, функция contextMenuEvent() вызывается, когда пользователь щелкает правой кнопкой мыши по виджету. Мы перекрываем ее в MainWindow для того, чтобы вывести контекстное меню.

private slots: 
   void newFile();
   void open(); 
   bool save(); 
   bool saveAs(); 
   void find(); 
   void goToCell(); 
   void sort(); 
   void about();     
       
 

  void updateCellIndicators(); 
   void spreadsheetModified(); 
   void openRecentFile(int param); 
 
 private: 
   void createActions(); 
   void createMenus(); 
   void createToolBars(); 
   void createStatusBar(); 
   void readSettings(); 
   void writeSettings(); 
   bool maybeSave(); 
   void loadFile(const QString &fileName); 
   void saveFile(const QString &fileName); 
   void setCurrentFile(const QString &fileName); 
   void updateRecentFileItems(); 
   QString strippedName(const QString &fullFileName);      
       
 
 

  Spreadsheet *spreadsheet; 
   FindDialog *findDialog; 
   QLabel *locationLabel; 
   QLabel *formulaLabel; 
   QLabel *modLabel; 
   QStringList recentFiles; 
   QString curFile; 
   QString fileFilters; 
   bool modified; 
   
   enum { MaxRecentFiles = 5 }; 
   int recentFileIds[MaxRecentFiles]; 
   
   QPopupMenu *fileMenu; 
   QPopupMenu *editMenu; 
   QPopupMenu *selectSubMenu; 
   QPopupMenu *toolsMenu; 
   QPopupMenu *optionsMenu; 
   QPopupMenu *helpMenu; 
   QToolBar *fileToolBar; 
   QToolBar *editToolBar;
   QAction *newAct; 
   QAction *openAct; 
   QAction *saveAct; 
   ... 
   QAction *aboutAct; 
   QAction *aboutQtAct; 
 }; 
 #endif      
       
 

Теперь перейдем к реализации:

#include <qaction.h> 
 #include <qapplication.h> 
 
 #include <qcombobox.h> 
 #include <qfiledialog.h> 
 #include <qlabel.h> 
 #include <qlineedit.h> 
 #include <qmenubar.h> 
 #include <qmessagebox.h> 
 
 #include <qpopupmenu.h> 
 #include <qsettings.h> 
 #include <qstatusbar.h> 
 
 #include "cell.h" 
 #include "finddialog.h" 
 #include "gotocelldialog.h" 
 #include "mainwindow.h" 
 #include "sortdialog.h" 
 #include "spreadsheet.h"      
       
 

  MainWindow::MainWindow(QWidget *parent, const char *name) 
     : QMainWindow(parent, name) 
   { 
     spreadsheet = new Spreadsheet(this); 
     setCentralWidget(spreadsheet); 
     createActions(); 
     createMenus(); 
     createToolBars(); 
     createStatusBar(); 
     readSettings(); 
     setCaption(tr("Spreadsheet")); 
     setIcon(QPixmap::fromMimeSource("icon.png")); 
     findDialog = 0; 
     fileFilters = tr("Spreadsheet files (*.sp)"); 
     modified = false; 
   }      
       
 
 

Далее вызываются приватные функции createActions(), createMenus(), createToolBars() и createStatusBar(), которые создают остальную часть главного окна. Для восстановления пользовательских настроек вызывается функция readSettings().

В качестве иконки приложения устанавливается icon.png. Qt поддерживает различные форматы графических файлов, включая BMP, GIF [6] , JPEG, MNG, PNG, PNM, XBM и XPM. Вызов QWidget::setIcon() выводит иконку в верхний левый угол окна. К сожалению, отсутствует платформо-независимый способ помещения иконки на рабочий стол.

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

• Сохранение изображений в файлы и загрузка из файлов, в процессе работы приложения.

• Включение изображений формата XPM в исходный код.

• Механизм "коллекции изображений" ("image collection").

В данном примере мы будем использовать механизм "коллекции изображений", поскольку работать с ним намного проще, чем загружать файлы в процессе исполнения. К тому же он может взаимодействовать со всеми, поддерживаемыми библиотекой, графическими форматами. Все изображения мы будем хранить в каталоге images. Чтобы создать файл на языке C++ (он будет создан утилитой uic), который будет хранить наши изображения, добавим следующие строки в файл .pro:

IMAGES = images/icon.png \ 
          images/new.png \ 
          images/open.png \ 
          ... 
          images/find.png \ 
          images/gotocell.png      
       
 

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

3.2. Создание меню и панелей инструментов.

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

Qt значительно упрощает разработку меню и панелей инструментов за счет использования концепции "действия" (action). Action -- это элемент, который может быть добавлен в меню и/или на панель инструментов. Для создания меню и панели инструментов необходимо выполнить следующие шаги:

• Создать "действие" (action).

• Добавить его в меню.

• Добавить его на панель инструментов.

void MainWindow::createActions() 
 { 
   newAct = new QAction(tr("&New"), tr("Ctrl+N"), this); 
   newAct->setIconSet(QPixmap::fromMimeSource("new.png")); 
   newAct->setStatusTip(tr("Create a new spreadsheet file")); 
   connect(newAct, SIGNAL(activated()), this, SLOT(newFile()));      
       
 

Аналогичным образом создаются все остальные "действия" (action).

Команда (action) "Show Grid", в меню "Options" реализуется несколько иначе:

  showGridAct = new QAction(tr("&Show Grid"), 0, this); 
   showGridAct->setToggleAction(true); 
   showGridAct->setOn(spreadsheet->showGrid()); 
   showGridAct->setStatusTip(tr("Show or hide the spreadsheet s " "grid")); 
   connect(showGridAct, SIGNAL(toggled(bool)), spreadsheet, SLOT(setShowGrid(bool)));      
       
 

Команды "Show Grid" и "Auto-recalculate" -- являются "действиями" с независимой фиксацией. Однако, QAction имеет наследника -- QActionGroup, с помощью которого можно создавать группы "действий" с зависимой фиксацией.

  aboutQtAct = new QAction(tr("About &Qt"), 0, this); 
   aboutQtAct->setStatusTip(tr("Show the Qt library's About box")); 
   connect(aboutQtAct, SIGNAL(activated()), qApp, SLOT(aboutQt())); 
 }    
     
 

Для вызова диалога "AboutQt" используется слот aboutQt() глобальной переменной qApp -- экземпляр класса QApplication.

После создания всех "действий" (action) мы можем разместить их в меню:

void MainWindow::createMenus() 
 { 
   fileMenu = new QPopupMenu(this); 
   newAct->addTo(fileMenu); 
   openAct->addTo(fileMenu); 
   saveAct->addTo(fileMenu); 
   saveAsAct->addTo(fileMenu); 
   fileMenu->insertSeparator(); 
   exitAct->addTo(fileMenu); 
   
   for (int i = 0; i < MaxRecentFiles; ++i) 
     recentFileIds[i] = -1;      
       
 

  editMenu = new QPopupMenu(this); 
   cutAct->addTo(editMenu); 
   copyAct->addTo(editMenu); 
   pasteAct->addTo(editMenu); 
   deleteAct->addTo(editMenu); 
   
   selectSubMenu = new QPopupMenu(this); 
   selectRowAct->addTo(selectSubMenu); 
   selectColumnAct->addTo(selectSubMenu); 
   selectAllAct->addTo(selectSubMenu); 
   editMenu->insertItem(tr("&Select"), selectSubMenu); 
   
   editMenu->insertSeparator(); 
   findAct->addTo(editMenu); 
   goToCellAct->addTo(editMenu);      
       
 
 

  toolsMenu = new QPopupMenu(this); 
   recalculateAct->addTo(toolsMenu); 
   sortAct->addTo(toolsMenu); 
   
   optionsMenu = new QPopupMenu(this); 
   showGridAct->addTo(optionsMenu);      
   autoRecalcAct->addTo(optionsMenu); 
   
   helpMenu = new QPopupMenu(this); 
   aboutAct->addTo(helpMenu); 
   aboutQtAct->addTo(helpMenu); 
   
   menuBar()->insertItem(tr("&File"), fileMenu); 
   menuBar()->insertItem(tr("&Edit"), editMenu); 
   menuBar()->insertItem(tr("&Tools"), toolsMenu); 
   menuBar()->insertItem(tr("&Options"), optionsMenu); 
   menuBar()->insertSeparator(); 
   menuBar()->insertItem(tr("&Help"), helpMenu); 
 }  
       
 
 

Создание панелей инструментов происходит очень похожим образом:

void MainWindow::createToolBars() 
 { 
   fileToolBar = new QToolBar(tr("File"), this); 
   newAct->addTo(fileToolBar); 
   openAct->addTo(fileToolBar); 
   saveAct->addTo(fileToolBar); 
   
   editToolBar = new QToolBar(tr("Edit"), this); 
   cutAct->addTo(editToolBar); 
   copyAct->addTo(editToolBar); 
   pasteAct->addTo(editToolBar); 
   editToolBar->addSeparator(); 
   findAct->addTo(editToolBar); 
   goToCellAct->addTo(editToolBar); 
 }      
       
 

<"images/qt3_files/fig3_024.png"> <"images/qt3_files/fig3_009.png">

Рисунок 3.6. Панели инструментов приложения Spreadsheet.

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

void MainWindow::contextMenuEvent(QContextMenuEvent *event) 
 { 
   QPopupMenu contextMenu(this); 
   cutAct->addTo(&contextMenu); 
   copyAct->addTo(&contextMenu); 
   pasteAct->addTo(&contextMenu); 
   contextMenu.exec(event->globalPos()); 
 }      
       
 
 

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

Отлавливать событие мы будем в MainWindow потому, что здесь реализуются все наши "действия" (actions). Однако, это событие можно поймать и в виджете Spreadsheet. Когда пользователь щелкнет правой кнопкой мыши по виджету, то этот виджет первым получит событие. Если виджет перекроет реализацию функции contextMenuEvent() и обработает событие, то дальше передаваться оно не будет. В противном случае оно будет передано дальше -- владельцу виджета (MainWindow). Более подробно события будут рассматриваться в Главе 7.

Функция-обработчик события вызова контекстного меню отличается от всего, что мы до сих пор видели, поскольку она создает экземпляр QPopupMenu, размещая его на стеке. Хотя, в принципе, можно было бы создать/удалить этот виджет и с помощью операторов new/delete:

  QPopupMenu *contextMenu = new QPopupMenu(this); 
   cutAct->addTo(contextMenu); 
   copyAct->addTo(contextMenu); 
   pasteAct->addTo(contextMenu); 
   contextMenu->exec(event->globalPos()); 
   delete contextMenu;      
       
 

Часть интерфейса, касающуюся меню и панелей инструментов, можно считать завершенной. В следующем разделе мы рассмотрим реализацию слотов меню "File".

3.3. Реализация меню "File".

В этом разделе мы рассмотрим реализацию всех слотов меню "File".

void MainWindow::newFile() 
 { 
   if (maybeSave()) { 
     spreadsheet->clear(); 
     setCurrentFile(""); 
   } 
 }      
       
 

bool MainWindow::maybeSave() 
 { 
   if (modified) { 
     int ret = QMessageBox::warning(this, tr("Spreadsheet"), 
                   tr("The document has been modified.\n" 
                      "Do you want to save your changes?"), 
                   QMessageBox::Yes | QMessageBox::Default, 
                   QMessageBox::No, 
                   QMessageBox::Cancel | QMessageBox::Escape); 
     if (ret == QMessageBox::Yes) 
       return save(); 
     else if (ret == QMessageBox::Cancel) 
       return false;      
   } return true; 
 }  
       
 

Вызов QMessageBox::warning() может показаться на первый взгляд немного не понятным. Синтаксис этого метода:

QMessageBox::warning(parent, caption, messageText, 
                      button0, button1, ...);      
       
 

void MainWindow::open() 
 { 
   if (maybeSave()) { 
     QString fileName = 
             QFileDialog::getOpenFileName(".", fileFilters, this); 
     if (!fileName.isEmpty()) 
       loadFile(fileName); 
   } 
 }      
       
 
 

Функции getOpenFileName() передаются три аргумента. Первый аргумент -- это каталог, где может находиться файл, в нашем случае -- это текущий каталог. Второй аргумент -- fileFilters, задет фильтр имен файлов. Фильтр состоит из двух частей -- текста описания и шаблона. В конструкторе MainWindow фильтр был инициализирован так:

  fileFilters = tr("Spreadsheet files (*.sp)");      
       
 

  fileFilters = tr("Spreadsheet files (*.sp)\n" 
                    "Comma-separated values files (*.csv)\n" 
                    "Lotus 1-2-3 files (*.wk?)");      
       
 
 

Для диалоговых окон, отношение "владелец-подчиненный", носит иной смысл, чем для виджетов. Диалоговое окно всегда отображает поверх других окон, но если оно имеет владельца, то центрируется относительно него. Этот же диалог вызывается по нажатии на кнопку "Open", на панели инструментов.

void MainWindow::loadFile(const QString &fileName) 
 { 
   if (spreadsheet->readFile(fileName)) { 
     setCurrentFile(fileName); 
     statusBar()->message(tr("File loaded"), 2000); 
   } else { 
     statusBar()->message(tr("Loading canceled"), 2000); 
   } 
 }      
       
 

Непосредственное чтение файла с диска выполняется в функции Spreadsheet::readFile(). Если чтение прошло без ошибок, то вызывается setCurrentFile(), чтобы обновить заголовок окна. В противном случае readFile() выведет окно с сообщением об ошибке. Обычно, считается хорошей практикой давать возможность низкоуровневым компонентам выводить свои сообщения, поскольку в этом случае диагностика ошибок может быть выполнена более точно.

В обоих случаях, в строку состояния выводится сообщение, которое демонстрируется 2000 миллисекунд (2 секунды).

bool MainWindow::save() 
 { 
   if (curFile.isEmpty()) { 
     return saveAs(); 
   } else { 
     saveFile(curFile); 
     return true; 
   } 
 } 
 
 void MainWindow::saveFile(const QString &fileName) 
 { 
   if (spreadsheet->writeFile(fileName)) { 
     setCurrentFile(fileName); 
     statusBar()->message(tr("File saved"), 2000); 
   } else { 
     statusBar()->message(tr("Saving canceled"), 2000); 
   } 
 }      
       
 

bool MainWindow::saveAs() 
 { 
   QString fileName = 
           QFileDialog::getSaveFileName(".", fileFilters, this); 
   if (fileName.isEmpty()) 
     return false; 
     
   if (QFile::exists(fileName)) { 
     int ret = QMessageBox::warning(this, tr("Spreadsheet"), 
                 tr("File %1 already exists.\n" 
                    "Do you want to overwrite it?") 
                 .arg(QDir::convertSeparators(fileName)), 
                 QMessageBox::Yes | QMessageBox::Default, 
                 QMessageBox::No | QMessageBox::Escape); 
     if (ret == QMessageBox::No) 
       return true; 
   } 
   if (!fileName.isEmpty()) 
     saveFile(fileName); 
   return true; 
 }      
       
 
 

Диалогу передается текст:

      tr("File %1 already exists\n" 
          "Do you want to override it?") 
       .arg(QDir::convertSeparators(fileName))      
       
 
 

      "File A:\\tab04.sp already exists.\n" 
       "Do you want to override it?"     
       
 

void MainWindow::closeEvent(QCloseEvent *event) 
 { 
   if (maybeSave()) { 
     writeSettings(); 
     event->accept(); 
   } else { 
     event->ignore(); 
   } 
 }      
       
 
 

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

void MainWindow::setCurrentFile(const QString &fileName) 
 { 
   curFile = fileName; 
   modLabel->clear(); 
   modified = false; 
   if (curFile.isEmpty()) { 
     setCaption(tr("Spreadsheet")); 
   } else { 
     setCaption(tr("%1 - %2").arg(strippedName(curFile)) 
                             .arg(tr("Spreadsheet"))); 
     recentFiles.remove(curFile); 
     recentFiles.push_front(curFile); 
     updateRecentFileItems(); 
   } 
 } 
 
 QString MainWindow::strippedName(const QString &fullFileName) 
 { 
   return QFileInfo(fullFileName).fileName(); 
 }      
       
 

setCaption(strippedName(curFile) + tr(" - Spreadsheet"));     
      

Затем обновляется список файлов recentFiles, использовавшихся недавно. Для начала вызывается remove(), которая удаляет имя файла из списка, а затем push_front() добавляет имя файла в начало. Вызов remove() необходим для предотвращения появления дублирующихся записей. После обновления списка вызывается updateRecentFileItems(), которая выполняет обновление меню "File".

Переменная recentFiles имеет тип QStringList (список строк QString). В Главе 11 мы подробнее остановимся на классах-контейнерах, таких как QStringList.

На этом реализация меню "File" практически завершена. Но остается еще один момент. Необходимо выполнить реализацию слота открывающего файлы из списка недавно использовавшихся файлов.

void MainWindow::updateRecentFileItems() 
 { 
   while ((int)recentFiles.size() > MaxRecentFiles) 
     recentFiles.pop_back(); 
     
   for (int i = 0; i < (int)recentFiles.size(); ++i) { 
     QString text = tr("&%1 %2") 
                    .arg(i + 1) 
                    .arg(strippedName(recentFiles[i])); 
     if (recentFileIds[i] == -1) { 
       if (i == 0) 
         fileMenu->insertSeparator(fileMenu->count() - 2); 
       recentFileIds[i] = 
               fileMenu->insertItem(text, this,
                                    SLOT(openRecentFile(int)), 
                                    0, -1, 
                                    fileMenu->count() - 2); 
       fileMenu->setItemParameter(recentFileIds[i], i); 
     } else { 
       fileMenu->changeItem(recentFileIds[i], text); 
     } 
   } 
 }
       
 
 

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

На первый взгляд кажется странным, что в функции updateRecentFileItems() мы создаем элементы меню, но никогда не удаляем их! Однако тут нет ничего странного. Мы можем смело утверждать, что в течение сессии список файлов уменьшаться не будет.

Функция QPopupMenu::insertItem() имеет следующий синтаксис:

 fileMenu->insertItem(text, receiver, slot, accelerator, id, index);      
    

Аргументы receiver и slot определяют функцию-обработчик, которая будет вызываться при выборе этого пункта меню. В нашем примере мы указали слот openRecentFile(int) главного окна.

В аргументах accelerator и id мы передаем значения по-умолчанию. Это означает, что данный пункт меню не имеет комбинации "горячих" клавиш, а идентификатор (id) генерируется автоматически. Мы сохраняем полученный id в массиве recentFileIds, что позднее позволит нам обращаться к пункту меню по его идентификатору.

Аргумент index -- это порядковый номер записи в меню. Значение fileMenu->count()-2, означает, что пункт меню вставляется выше разделителя, отделяющего пункт "Exit".

void MainWindow::openRecentFile(int param) 
 { 
   if (maybeSave()) 
     loadFile(recentFiles[param]); 
 }      
       
 

Таким образом мы решаем проблему сопоставления пунктов меню полным именам файлов. Менее элегантный способ заключается в создании пяти "действий" (action) и соединении их с пятью различными слотами.

3.4. Настройка строки состояния.

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

Рисунок 3.13. Строка состояния.

Создается и настраивается строка состояния в функции createStatusBar(), которая вызывается из конструктора MainWindow:

void MainWindow::createStatusBar() 
 { 
   locationLabel = new QLabel(" W999 ", this); 
   locationLabel->setAlignment(AlignHCenter); 
   locationLabel->setMinimumSize(locationLabel->sizeHint()); 
   
   formulaLabel = new QLabel(this); 
   
   modLabel = new QLabel(tr(" MOD "), this); 
   modLabel->setAlignment(AlignHCenter); 
   modLabel->setMinimumSize(modLabel->sizeHint());      
   modLabel->clear(); 
   
   statusBar()->addWidget(locationLabel); 
   statusBar()->addWidget(formulaLabel, 1); 
   statusBar()->addWidget(modLabel); 
   
   connect(spreadsheet, SIGNAL(currentChanged(int, int)), 
           this, SLOT(updateCellIndicators())); 
   connect(spreadsheet, SIGNAL(modified()), 
           this, SLOT(spreadsheetModified())); 
   updateCellIndicators(); 
 }
       
 

Из рисунка 3.13 видно, что метки имеют различные размеры. Адрес ячейки и индикатор MOD -- самые короткие, а метка, отображающая действующую в ячейке формулу, самая длинная. Кроме того, при изменении размеров окна, все дополнительное пространство должно выделяться именно ей. Такое поведение достигается за счет указания фактора "stretch" (значение 1 в вызове QStatusBar::addWidget()). Для других двух меток этот фактор по-умолчанию принимается равным нулю, что означает фиксированный размер меток.

Когда QStatusBar размещает виджеты, он сначала выделяет место для "нерастягиваемых" компонентов (выделяя им "идеальный" размер, определяемый вызовом QWidget::sizeHint()), а затем все остальное пространство отдается "растягиваемым" виджетам. "Идеальный" размер, в свою очередь, зависит от содержимого виджетов и меняется при изменении содержимого. Задавая начальные значения меток ("W999" и "MOD"), мы тем самым определяем их минимально возможный размер.

В конце функции мы выполняем соединения между сигналами Spreadsheet к двум слотам MainWindow: updateCellIndicators() и spreadsheetModified().

void MainWindow::updateCellIndicators() 
 { 
 locationLabel->setText(spreadsheet->currentLocation()); 
 formulaLabel->setText(" " + spreadsheet->currentFormula()); 
 }
       
 
 

void MainWindow::spreadsheetModified() 
 { 
   modLabel->setText(tr("MOD")); 
   modified = true; 
   updateCellIndicators(); 
 }
       
 

3.5. Использование диалогов.

Здесь мы расскажем о принципах работы с диалогами в Qt -- о том как они создаются, инициализируются, запускаются и как от них получить выбор, сделанный пользователем. Здесь мы будем использовать диалоги "Find", "Go-to-Cell" и "Sort", созданные нами в Главе 2. Кроме того, мы создадим простенький диалог "About" ("О программе").

Начнем с диалога "Find". Так как мы хотим, чтобы пользователь имел возможность переключаться между главным окном приложения и окном диалога, необходимо, чтобы диалоговое окно было НЕМОДАЛЬНЫМ. Немодальным называется такое окно, которое работает независимо от остальных окон приложения.

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

void MainWindow::find() 
 { 
   if (!findDialog) { 
     findDialog = new FindDialog(this); 
     connect(findDialog, SIGNAL(findNext(const QString &, bool)), 
             spreadsheet, SLOT(findNext(const QString &, bool))); 
     connect(findDialog, SIGNAL(findPrev(const QString &, bool)), 
             spreadsheet, SLOT(findPrev(const QString &, bool))); 
   } 
   
   findDialog->show(); 
   findDialog->raise(); 
   findDialog->setActiveWindow(); 
 }
       
 

• Пользователь вызвал диалог впервые.

• Диалог вызывался ранее, но после этого пользователь закрыл его.

• Диалог вызывался ранее и не закрывался (окно диалога видно на экране).

Далее вызываются show(), raise() и setActiveWindow(), которые выводят окно диалога на экран, поверх других окон приложения, и активизируют его. Метод show() делает окно диалога видимым, но оно может уже присутствовать на экране -- в этом случае функция show() ничего не делает. Так как нам необходимо вывести диалог поверх других окон и активизировать его, мы должны вызвать raise() и setActiveWindow(). В качестве альтернативы можно предложить следующий код:

  if (findDialog->isHidden()) { 
     findDialog->show(); 
   } else { 
     findDialog->raise(); 
     findDialog->setActiveWindow(); 
   }     
       
 

Перейдем к диалогу "Go-to-Cell". В этом случае нет необходимости переключаться между окном приложения и окном диалога. Отсюда следует, что окно диалога "Go-to-Cell" должно быть МОДАЛЬНЫМ. Модальным называется такое окно, которое блокирует возможность взаимодействия пользователя с другими окнами приложения до тех пор, пока не будет закрыто модальное окно. Все диалоги нашего приложения, за исключением "Find", будут модальными.

Немодальные диалоги вызываются при помощи функции show() (если перед этим не вызывалась функция setModal(), которая делает окно модальным). Модальные диалоги вызываются функцией exec(). Как правило, для модальных диалогов не требуется устанавливать соединения между сигналами и слотами.

void MainWindow::goToCell() 
 { 
   GoToCellDialog dialog(this); 
   if (dialog.exec()) { 
     QString str = dialog.lineEdit->text(); 
     spreadsheet->setCurrentCell(str.mid(1).toInt() - 1, 
                                 str[0].upper().unicode() -  'A' ); 
   } 
 }
       
 

Функция QTable::setCurrentCell() принимает два аргумента: номер строки и номер колонки. В нашем приложении, адрес A1, например, соответствует ячейке (0, 0) в таблице, а адрес B27 -- ячейке (26, 1). Чтобы получить номер строки, из QString, возвращаемой QLabel::text(), извлекается ее часть, с помощью QString::mid() и затем преобразуется в целое число с помощью QString::toInt(). После этого, из полученного числа вычитается единица (поскольку нумерация строк в QTable начинается с 0). Чтобы получить номер колонки, из кода символа колонки мы просто вычитаем код символа "A".

В отличие от диалога "Find", экземпляр диалога "Go-to-Cell" создается на стеке. Это общепринятая практика для модальных диалогов, вызываемых из разного рода меню, поскольку они становятся не нужны после их использования.

А теперь перейдем к диалогу сортировки. Этот диалог так же является модальным и позволяет отсортировать выделенный дипазон ячеек по заданным колонкам. На рисунке 3.14 показан пример сортировки по колонкам B (первичный ключ) и A (вторичный ключ) в порядке возрастания.

void MainWindow::sort() 
 { 
   SortDialog dialog(this); 
   QTableSelection sel = spreadsheet->selection(); 
   dialog.setColumnRange( A  + sel.leftCol(),  A  + sel.rightCol()); 
   
   if (dialog.exec()) { 
     SpreadsheetCompare compare; 
     compare.keys[0] = 
           dialog.primaryColumnCombo->currentItem(); 
     compare.keys[1] = 
           dialog.secondaryColumnCombo->currentItem() - 1; 
     compare.keys[2] = 
           dialog.tertiaryColumnCombo->currentItem() - 1; 
     compare.ascending[0] = 
           (dialog.primaryOrderCombo->currentItem() == 0); 
     compare.ascending[1] = 
           (dialog.secondaryOrderCombo->currentItem() == 0); 
     compare.ascending[2] = 
           (dialog.tertiaryOrderCombo->currentItem() == 0); 
     spreadsheet->sort(compare); 
   } 
 }
       
 
 

• Диалог создается на стеке и инициализируется.

• Диалог запускается вызовом exec()

• Если пользователь нажал кнопку OK, то из виджетов диалога извлекается необходимая информация и выполняется сортировка.

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

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

void MainWindow::sort() 
 { 
   SortDialog dialog(this); 
   QTableSelection sel = spreadsheet->selection(); 
   dialog.setColumnRange( 'A' + sel.leftCol(), 'A' + sel.rightCol()); 
   if (dialog.exec()) 
     spreadsheet->performSort(dialog.comparisonObject()); 
 }
       
 

Более радикальный подход -- передать диалогу указатель на Spreadsheet и позволить ему напрямую работать с таблицей. Это несколько снижает универсальность диалога, так как он теперь будет "привязан" к определенному типу виджета, но значительно упрощает код за счет отказа от функции SortDialog::setColumnRange(). В этом случае, код функции MainWindow::sort() приобретает такой вид:

void MainWindow::sort() 
 { 
   SortDialog dialog(this); 
   dialog.setSpreadsheet(spreadsheet);      
   
   dialog.exec(); 
 }  
       
 

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

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

void MainWindow::about() 
 { 
   QMessageBox::about(this, tr("About Spreadsheet"), 
           tr("<h2>Spreadsheet 1.0</h2>" 
           "<p>Copyright &copy; 2003 Software Inc." 
           "<p>Spreadsheet is a small application that " 
 "demonstrates <b>QAction</b>, <b>QMainWindow</b>, " 
           "<b>QMenuBar</b>, <b>QStatusBar</b>, " 
           "<b>QToolBar</b>, and many other Qt classes.")); 
 }
       
 
 

До сих пор мы использовали ряд, очень удобных в обращении, статических функций-членов из классов QMessageBox и QFileDialog. Эти функции "на лету" создают диалоги, инициализируют их и вызывают функцию exec(). Но можно, хотя это и менее удобно, самому создать QMessageBox или QFileDialog, подобно любому другому виджету, и явно вызвать exec() или даже show().

3.6. Сохранение пользовательских настроек приложения.

В конструкторе MainWindow, для загрузки пользовательских настроек, мы вызывали функцию readSettings(). Аналогично, для их сохранения, в обработчике closeEvent(), вызывалась функция writeSettings(). Пришло время рассмотреть реализацию обоих функций, которые являются методами класса MainWindow.

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

void MainWindow::writeSettings() 
 { 
   QSettings settings; 
   settings.setPath("software-inc.com", "Spreadsheet"); 
   settings.beginGroup("/Spreadsheet"); 
   settings.writeEntry("/geometry/x", x()); 
   settings.writeEntry("/geometry/y", y()); 
   settings.writeEntry("/geometry/width", width()); 
   settings.writeEntry("/geometry/height", height()); 
   settings.writeEntry("/recentFiles", recentFiles); 
   settings.writeEntry("/showGrid", showGridAct->isOn()); 
   settings.writeEntry("/autoRecalc", showGridAct->isOn()); 
   settings.endGroup(); 
 }
       
 

Место, куда QSettings сохраняет настройки, зависит от используемой платформы. В Windows сохранение производится в системный реестр, в Unix -- в текстовый файл, в Mac OS X используется Carbon API. Методу setPath() передаются названия организации и программного продукта. Эти сведения используются для преобразование в платформо-зависимое представление места сохранения настроек.

Настройки хранятся в виде пары: ключ-значение. Ключ очень похож на строку пути в файловой системе и всегда должен начинаться с названия приложения. Например, /Spreadsheet/geometry/x или /Spreadsheet/showGrid. (Функция beginGroup() "запоминает" префикс ключа - название приложения, которое будет автоматически подставляться в начало ключа, что позволяет нам сэкономить на своих усилиях.) Значение, той или иной настройки, может быть одного из пяти типов: int, bool, double, QString или QStringList.

void MainWindow::readSettings() 
 { 
   QSettings settings; 
   settings.setPath("software-inc.com", "Spreadsheet"); 
   settings.beginGroup("/Spreadsheet"); 
   int x = settings.readNumEntry("/geometry/x", 200); 
   int y = settings.readNumEntry("/geometry/y", 200);      
   int w = settings.readNumEntry("/geometry/width", 400); 
   int h = settings.readNumEntry("/geometry/height", 400); 
   move(x, y); 
   resize(w, h); 
   
   recentFiles = settings.readListEntry("/recentFiles"); 
   updateRecentFileItems(); 
   
   showGridAct->setOn( 
           settings.readBoolEntry("/showGrid", true)); 
   autoRecalcAct->setOn( 
           settings.readBoolEntry("/autoRecalc", true)); 
           
   settings.endGroup(); 
 }
       
 

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

3.7. Работа с несколькими документами одновременно.

Мы готовы приступить к созданию функции main():

#include <qapplication.h> 
 #include "mainwindow.h" 
 
 int main(int argc, char *argv[]) 
 { 
   QApplication app(argc, argv); 
   MainWindow mainWin; 
   app.setMainWidget(&mainWin); 
   mainWin.show(); 
   return app.exec(); 
 }      
       
 

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

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

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

В своем первоначальном варианте, меню File не имело пункта Close, поскольку смысл операции закрытия окна был равносилен завершению приложения (пункт Exit).

Так выглядит новый вариант функции main():

#include <qapplication.h> 
 #include "mainwindow.h" 
 
 int main(int argc, char *argv[]) 
 { 
   QApplication app(argc, argv); 
   MainWindow *mainWin = new MainWindow; 
   mainWin->show(); 
   QObject::connect(&app, SIGNAL(lastWindowClosed()), 
                    &app, SLOT(quit())); 
   return app.exec(); 
 }      
       
 

В данном варианте, теперь имеет смысл создавать экземпляр MainWindow оператором new, поскольку затем, при закрытии окна, он будет удаляться оператором delete. Эта необходимость не возникает в случае приложения, которое работает с единственным документом.

Ниже приводится измененный вариант слота MainWindow::newFile():

void MainWindow::newFile() 
 { 
   MainWindow *mainWin = new MainWindow; 
   mainWin->show(); 
 }      
       
 

Ниже приводится код, создающий "действия" (actions) Close и Exit:

  closeAct = new QAction(tr("&Close"), tr("Ctrl+W"), this); 
   connect(closeAct, SIGNAL(activated()), this, SLOT(close())); 
   
 exitAct = new QAction(tr("E&xit"), tr("Ctrl+Q"), this); 
 connect(exitAct, SIGNAL(activated()), qApp, SLOT(closeAllWindows()));      
       
 

Теперь наше приложение в состоянии работать с несколькими окнами. К сожалению, на данный момент у нас в программе кроется трудноуловимая ошибка. Если пользователь будет создавать и закрывать окна приложения, то может наступить момент, когда вся доступная память в машине будет исчерпана! Это происходит потому, что мы создаем новые окна, выбирая пункт меню File|New, но нигде не удаляем их из памяти. Когда пользователь закрывает очередное окно, то объект класса MainWindow не удаляется из памяти, а просто делается невидимым.

Решение этой проблемы заключается в добавлении флага WDestructiveClose в конструктор:

MainWindow::MainWindow(QWidget *parent, const char *name) 
 : QMainWindow(parent, name, WDestructiveClose) 
 { 
   ...
 }
       
 

Однако, утечка памяти -- не единственная проблема, с которой мы можем столкнуться. Весь наш первоначальный дизайн предполагал работу с единственным главным окном. Теперь, каждое из окон приложения может иметь свой список недавно использовавшихся файлов и свои дополнительные настройки. Совершенно очевидно, что список недавно использовавшихся файлов должен быть глобальным для всего приложения. Сделать это можно довольно легко, достаточно просто объявить переменную recentFiles статической. Но, теперь везде, где необходимо вызвать updateRecentFileItems() для обновления меню File, мы должны вызвать эту функцию для всех главных окон. Ниже приводится код, который делает это:

QWidgetList *list = QApplication::topLevelWidgets(); 
   QWidgetListIt it(*list); 
   QWidget *widget; 
   while ((widget = it.current())) { 
     if (widget->inherits("MainWindow")) 
       ((MainWindow *)widget)->updateRecentFileItems(); 
       ++it; 
   } 
   delete list;      
       
 

Когда приложение открывает каждый следующий документ в новом окне, то говорят, что приложение относится к классу SDI-приложений (от англ. single document interface -- однодокументный интерфейс). Популярная альтернатива SDI -- MDI (от англ. multiple document interface -- многодокументный интерфейс), в этом случае приложение имеет одно главное окно, которое может включать в себя несколько дочерних окон с открытыми документами и разделяющими между собой пространство главного окна. С помощью Qt можно создавать как SDI, так и MDI приложения. На рисунке 3.17 показаны оба варианта оформления приложения Spreadsheet. Более подробно MDI будет описан в Главе 6.

3.8. Экран-заставка.

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

В Qt реализация экрана-заставки выполнена в виде класса QSplashScreen, который выводит на экран окно с изображением до того, как приложение будет полностью загружено. Имеется возможность отображать ход загрузки на заставке. Код, который выводит заставку на экран, как правило размещается в функции main(), перед вызовом QApplication::exec().

Ниже показан пример функции main(), использующей QSplashScreen для вывода заставки на время загрузки дополнительных модулей и установки соединения по сети.

int main(int argc, char *argv[]) 
 { 
   QApplication app(argc, argv);  
   QSplashScreen *splash = 
   new QSplashScreen(QPixmap::fromMimeSource("splash.png")); 
   splash->show(); 
   
   splash->message(QObject::tr("Setting up the main window..."), 
                   Qt::AlignRight | Qt::AlignTop, Qt::white); 
   MainWindow mainWin; 
   app.setMainWidget(&mainWin); 
   
   splash->message(QObject::tr("Loading modules..."),
                   Qt::AlignRight | Qt::AlignTop, Qt::white); 
   loadModules(); 
   
   splash->message(QObject::tr("Establishing connections..."), 
                   Qt::AlignRight | Qt::AlignTop, Qt::white); 
   establishConnections(); 
   
   mainWin.show(); 
   splash->finish(&mainWin); 
   delete splash; 
   
   return app.exec(); 
 }
       
 
 

4.1. Центральный виджет.

Центральная область окна приложения может быть занята виджетом любого типа. Рассмотрим возможные варианты:

1. Стандартный виджет Qt.

   В качестве центрального виджета может быть использован один из стандартного набора, предлагаемого библиотекой Qt, например, QTable или QTextEdit. В этом случае функциональность приложения должна быть реализована отдельно (например в потомке класса QMainWindow).

2. Виджет, созданный разработчиком.

   Для специализированных применений, разработчики достаточно часто создают свои собственные виджеты. Например, программа редактирования файлов с иконками может иметь, в качестве центрального, виджет IconEditor. В Главе 5 мы рассмотрим проблему создания своих виджетов.

3. Обычный QWidget с менеджером размещения.

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

4. Splitter (разделитель)

   Другой способ размещения нескольких виджетов в окне -- использовать разделитель (QSplitter). QSplitter размещает подчиненные виджеты по горизонтали, подобно QHBox, или по вертикали, подобно QVBox, с возможностью управления размерами виджетов по одной из осей. Разделители могут содержать в себе виджеты любого другого типа, в том числе и другие разделители.

5. Рабочее пространство MDI

   Если приложение реализует многодокументный интерфейс (MDI), то в этом случае всю область окна занимает виджет QWorkspace, а каждое дочернее окно является подчиненным, по отношению к нему.

Области размещения (layouts), разделители (splitters) и рабочие пространства MDI могут комбинироваться как со стандартными виджетами Qt, так и с виджетами, разработанными вами. В Главе 6 мы рассмотрим эти классы поближе.

В нашем примере, в качестве центрального, используется виджет, порожденный от QTable. Класс QTable уже имеет многое из того, что нам необходимо, но он не поддерживает формулы, например: "=A1+A2+A3", а так же не поддерживает операции с буфером обмена. Поэтому мы займемся добавлением необходимой функциональности в виде класса Spreadsheet, потомка класса QTable.

4.2. Создание класса-потомка от QTable.

Начнем создание нашего класса Spreadsheet с оформления файла заголовка:

#ifndef SPREADSHEET_H 
 #define SPREADSHEET_H 
 
 #include <qstringlist.h> 
 
 #include <qtable.h> 
 
 class Cell; 
 class SpreadsheetCompare;      
       
 

Атрибуты ячейки в QTable, такие как текст и выравнивание, хранятся в элементе QTableItem. В отличие от QTable, класс QTableItem не является виджетом и предназначен исключительно для хранения данных. Класс Cell порожден от QTableItem. В дополнение к атрибутам родительского класса, он имеет возможность хранить формулу вычисления содержимого ячейки.

Мы подробно обсудим реализацию класса Cell в последнем разделе этой главы.

class Spreadsheet : public QTable 
 { 
   Q_OBJECT 
 public: 
   Spreadsheet(QWidget *parent = 0, const char *name = 0); 
   
   void clear(); 
   QString currentLocation() const; 
   QString currentFormula() const; 
   bool autoRecalculate() const { return autoRecalc; } 
   bool readFile(const QString &fileName); 
   bool writeFile(const QString &fileName); 
   QTableSelection selection(); 
   void sort(const SpreadsheetCompare &compare);
       
 

В Главе 3, при разработке MainWindow, мы уже использовали некоторые из публичных методов Spreadsheet. Например, мы вызывали clear() из MainWindow::newFile(). Кроме того были использованы некоторые функции, унаследованные от QTable, например setCurrentCell() и setShowGrid().

public slots: 
   void cut(); 
   void copy(); 
   void paste(); 
   void del(); 
   void selectRow(); 
   void selectColumn(); 
   void selectAll(); 
   void recalculate(); 
   void setAutoRecalculate(bool on); 
   void findNext(const QString &str, bool caseSensitive); 
   void findPrev(const QString &str, bool caseSensitive); 
 
 signals: 
   void modified();      
       
 

protected: 
   QWidget *createEditor(int row, int col, bool initFromCell) const; 
   void endEdit(int row, int col, bool accepted, bool wasReplacing);      
       
 

private: 
   enum { MagicNumber = 0x7F51C882, NumRows = 999, NumCols = 26 }; 
   
   Cell *cell(int row, int col) const; 
   void setFormula(int row, int col, const QString &formula); 
   QString formula(int row, int col) const; 
   void somethingChanged(); 
   
   bool autoRecalc; 
 };
       
 
 

class SpreadsheetCompare 
 { 
 public: 
   bool operator()(const QStringList &row1, 
                   const QStringList &row2) const; 
   
   enum { NumKeys = 3 }; 
   int keys[NumKeys]; 
   bool ascending[NumKeys]; 
 }; 
 #endif      
       
 

Теперь перейдем к рассмотрению реализации каждой из функций:

#include <qapplication.h> 
 
 #include <qclipboard.h> 
 #include <qdatastream.h> 
 #include <qfile.h> 
 #include <qlineedit.h> 
 #include <qmessagebox.h> 
 #include <qregexp.h> 
 
 #include <qvariant.h> 
 
 #include <algorithm> 
 #include <vector> 
 using namespace std; 
 
 #include "cell.h" 
 #include "spreadsheet.h"      
       
 

Spreadsheet::Spreadsheet(QWidget *parent, const char *name) 
     : QTable(parent, name) 
 { 
   autoRecalc = true; 
   setSelectionMode(Single); 
   clear(); 
 }
       
 

void Spreadsheet::clear() 
 { 
   setNumRows(0); 
   setNumCols(0); 
   setNumRows(NumRows); 
   setNumCols(NumCols); 
   for (int i = 0; i < NumCols; i++) 
     horizontalHeader()->setLabel(i, QChar('A' + i)); 
   setCurrentCell(0, 0); 
 }
       
 
 

Собственно очистка производится за счет изменения размера таблицы до (0 X 0), после чего восстановливается ее первоначальный размер (26 X 999). Затем выполняется заполнение меток столбцов: "A", "B", ..., "Z" (номера столбцов 1, 2, ..., 26, соответственно) и перемещение курсора в ячейку A1.

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

Cell *Spreadsheet::cell(int row, int col) const 
 { 
   return (Cell *)item(row, col); 
 }
       
 

QString Spreadsheet::formula(int row, int col) const 
 { 
   Cell *c = cell(row, col); 
   if (c) 
     return c->formula(); 
   else      
     return ""; 
 }  
       
 

void Spreadsheet::setFormula(int row, int col, 
                              const QString &formula) 
 { 
   Cell *c = cell(row, col); 
   if (c) { 
     c->setFormula(formula); 
     updateCell(row, col); 
   } else { 
     setItem(row, col, new Cell(this, formula)); 
   } 
 }
       
 
 

QString Spreadsheet::currentLocation() const 
 { 
   return QChar('A' + currentColumn()) 
          + QString::number(currentRow() + 1); 
 }
       
 
 

QString Spreadsheet::currentFormula() const 
 { 
   return formula(currentRow(), currentColumn()); 
 }
       
 

QWidget *Spreadsheet::createEditor(int row, int col, 
                                    bool initFromCell) const 
 { 
   QLineEdit *lineEdit = new QLineEdit(viewport()); 
   lineEdit->setFrame(false); 
   if (initFromCell) 
     lineEdit->setText(formula(row, col)); 
   return lineEdit; 
 }
       
 
 

createEditor() создает объект класса QLineEdit и записывает в него содержимое ячейки, если initFromCell содержит значение true. Мы выполнили повторную реализацию этой функции для того, чтобы показывать формулу ячейки вместо ее содержимого.

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

• Если формула -- это число, то она будет интерпретирована как число. Например, формула "1.50" интерпретируется как число 1.5, типа double, и отображается в таблице с выравниванием по правому краю.

• Если формула начинается с одиночной кавычки, то она интерпретируется как текст. Например, формула "'12345" будет интерпретирована как строка символов "12345".

• Если формула начинается с символа "=", то она будет интерпретирована как арифметическое выражение. Например, если ячейка A1 содержит "12", а A2 -- "6", то формула "=A1+A2" вернет сумму "18".

void Spreadsheet::endEdit(int row, int col, bool accepted, 
                           bool wasReplacing) 
 { 
   QLineEdit *lineEdit = (QLineEdit *)cellWidget(row, col); 
   if (!lineEdit) 
     return; 
   QString oldFormula = formula(row, col); 
   QString newFormula = lineEdit->text(); 
   
   QTable::endEdit(row, col, false, wasReplacing); 
   
   if (accepted && newFormula != oldFormula) { 
     setFormula(row, col, newFormula);
     somethingChanged(); 
   } 
 }
       
 

Доступ к редактору выполняется через обращение к QTable::cellWidget(). Мы можем без опаски выполнить приведение типа к QLineEdit, поскольку создаваемый нами компонент редактора -- всегда QLineEdit.

void Spreadsheet::somethingChanged() 
 { 
   if (autoRecalc) 
     recalculate(); 
   emit modified(); 
 }
       
 
 

4.3. Загрузка и сохранение.

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

Начнем с функции записи файла на диск:

bool Spreadsheet::writeFile(const QString &fileName) 
 { 
   QFile file(fileName); 
   if (!file.open(IO_WriteOnly)) { 
     QMessageBox::warning(this, tr("Spreadsheet"), 
                          tr("Cannot write file %1:\n%2.") 
                          .arg(file.name()) 
                          .arg(file.errorString())); 
     return false;
   } 
   
   QDataStream out(&file); 
   out.setVersion(5); 
   
   out << (Q_UINT32)MagicNumber; 
   
   QApplication::setOverrideCursor(waitCursor); 
   for (int row = 0; row < NumRows; ++row) { 
     for (int col = 0; col < NumCols; ++col) { 
       QString str = formula(row, col); 
       if (!str.isEmpty()) 
         out << (Q_UINT16)row << (Q_UINT16)col << str; 
     } 
   } 
   QApplication::restoreOverrideCursor(); 
   return true; 
 }
       
 
 

Функция начинается с создания экземпляра QFile, с заданным именем файла, после чего файл открывается на запись. Затем создается объект QDataStream, который, используя QFile, записывает данные на диск. Непосредственно перед записью данных, мы меняем внешний вид курсора мыши, показывая занятость приложения. А после записи -- восстанавливаем его. В конце функции файл автоматически закрывается деструктором QFile.

QDataStream поддерживает основные типы языка C++, а так же ряд типов, определяемых библиотекой Qt. Синтаксис соответствует стандарту классов <iostream>. Например,

        out << x << y << z;     
       
 
 

        in >> x >> y >> z;
       
 

Поскольку базовые типы языка C++ char, short, int, long и long long могут иметь различный размер на разных платформах, в целях безопасности их следует приводить к одному из следующих: Q_INT8, Q_UINT8, Q_INT16, Q_UINT16, Q_INT32, Q_UINT32, Q_INT64, Q_UINT64, которые гарантированно имеют декларируемый, в битах, размер.

QDataStream -- довольно универсальный класс, он может совместно работать не только с QFile, но так же и с QBuffer, и с QSocket, и с QSocketDevice. Точно так же QFile может использоваться совместно с QTextStream и как самостоятельное средство работы с файлами. В Главе 10 мы глубже рассмотрим эти классы.

Формат файлов приложения Spreadsheet очень прост. Начинается файл с 32-х битного числа, идентифицирующего формат (MagicNumber определена как 0x7F51C882 в spreadsheet.h). Далее следует серия блоков, каждый из которых соответствует одной ячейке (номера строки и колонки, и формула). Для экономии мы не записываем в файл пустые ячейки.

Двоичное представление типов, определяемых библиотекой Qt, стало осуществляться еще в Qt 1.0 и, вероятно, будет развиваться и дальше, чтобы в процессе развития библиотеки имелась возможность представлять в двоичном виде вновь появляющиеся типы. По-умолчанию, QDataStream использует самую современную версию двоичного формата (версия 5 в Qt 3.2), но способен работать и с более ранними версиями. Воизбежание проблем с совместимостью, на тот случай, если наша программа будет скомпилирована с более свежим выпуском Qt, мы укажем QDataStream на то, что необходимо использовать 5-ю версию, независимо от того, с какой версией Qt была скомпилирована программа.

      
 bool Spreadsheet::readFile(const QString &fileName) 
 { 
   QFile file(fileName); 
   if (!file.open(IO_ReadOnly)) { 
     QMessageBox::warning(this, tr("Spreadsheet"), 
                          tr("Cannot read file %1:\n%2.") 
                          .arg(file.name()) 
                          .arg(file.errorString())); 
     return false; 
   } 
   
   QDataStream in(&file); 
   in.setVersion(5); 
   
   Q_UINT32 magic; 
   in >> magic; 
   if (magic != MagicNumber) { 
     QMessageBox::warning(this, tr("Spreadsheet"), 
          tr("The file is not a " "Spreadsheet file.")); 
     return false; 
   } 
   
   clear(); 
   
   Q_UINT16 row; 
   Q_UINT16 col; 
   QString str; 
   
   QApplication::setOverrideCursor(waitCursor); 
   while (!in.atEnd()) {
     in >> row >> col >> str; 
     setFormula(row, col, str); 
   } 
   QApplication::restoreOverrideCursor(); 
   return true; 
 }
       
 
 

Если сигнатура файла (magic number) представлена корректным значением, то вызывается clear(), для очистки таблицы, поскольку в файле могут быть представлены не все ячейки.

4.4. Реализация меню Edit.

Приступим к созданию слотов, соответствующих пунктам меню Edit.

      
 void Spreadsheet::cut() 
 { 
   copy(); 
   del(); 
 }      
       
 

      
 void Spreadsheet::copy() 
 { 
   QTableSelection sel = selection(); 
   QString str; 
   
   for (int i = 0; i < sel.numRows(); ++i) { 
     if (i > 0) 
       str += "\n"; 
     for (int j = 0; j < sel.numCols(); ++j) { 
       if (j > 0) 
         str += "\t"; 
       str += formula(sel.topRow() + i, sel.leftCol() + j); 
     } 
   }
   
   QApplication::clipboard()->setText(str); 
 }
       
 
 

QTableSelection Spreadsheet::selection() 
 { 
   if (QTable::selection(0).isEmpty()) 
     return QTableSelection(currentRow(), currentColumn(), 
                            currentRow(), currentColumn()); 
   
   return QTable::selection(0); 
 }
       
 
 

void Spreadsheet::paste() 
 { 
   QTableSelection sel = selection(); 
   QString str = QApplication::clipboard()->text(); 
   QStringList rows = QStringList::split("\n", str, true); 
   int numRows = rows.size(); 
   int numCols = rows.first().contains("\t") + 1; 
   
   if (sel.numRows() * sel.numCols() != 1 
       && (sel.numRows() != numRows 
           || sel.numCols() != numCols)) { 
       QMessageBox::information(this, tr("Spreadsheet"), 
                  tr("The information cannot be pasted because the " 
                 "copy and paste areas aren't the same size."));     
       return; 
   } 
   
   for (int i = 0; i < numRows; ++i) { 
     QStringList cols = QStringList::split("\t", rows[i], true); 
     for (int j = 0; j < numCols; ++j) { 
       int row = sel.topRow() + i; 
       int col = sel.leftCol() + j; 
       if (row < NumRows && col < NumCols) 
         setFormula(row, col, cols[j]); 
     } 
   } 
   somethingChanged(); 
 }
       
 

Далее определяется размерность области копирования. Количество строк в таблице соответствует количеству строк в QStringList, а количество столбцов -- на один больше, чем количество символов табуляции в первой строке.

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

В процессе вставки, каждая строка разбивается на ячейки, вызовом QStringList::split(), но на этот раз в качестве разделителя используется символ табуляции. Рисунок 4.8 демонстрирует процесс вставки данных в таблицу из буфера обмена.

void Spreadsheet::del() 
 { 
   QTableSelection sel = selection(); 
   for (int i = 0; i < sel.numRows(); ++i) { 
     for (int j = 0; j < sel.numCols(); ++j) 
       delete cell(sel.topRow() + i, sel.leftCol() + j); 
     } 
     clearSelection(); 
 }
       
 

void Spreadsheet::selectRow() 
 { 
   clearSelection(); 
   QTable::selectRow(currentRow()); 
 } 
 
 void Spreadsheet::selectColumn() 
 { 
   clearSelection(); 
   QTable::selectColumn(currentColumn()); 
 } 
 
 void Spreadsheet::selectAll() 
 { 
   clearSelection(); 
   selectCells(0, 0, NumRows - 1, NumCols - 1); 
 }      
       
 

 void Spreadsheet::findNext(const QString &str,bool caseSensitive) 
 { 
   int row = currentRow(); 
   int col = currentColumn() + 1; 
   
   while (row < NumRows) { 
     while (col < NumCols) { 
       if (text(row, col).contains(str, caseSensitive)) { 
         clearSelection(); 
         setCurrentCell(row, col); 
         setActiveWindow(); 
         return; 
       } 
       ++col; 
     } 
     col = 0; 
     ++row; 
   } 
   qApp->beep(); 
 }
       
 

void Spreadsheet::findPrev(const QString &str, bool caseSensitive) 
 { 
   int row = currentRow(); 
   int col = currentColumn() - 1; 
   
   while (row >= 0) { 
     while (col >= 0) { 
       if (text(row, col).contains(str, caseSensitive)) { 
         clearSelection(); 
         setCurrentCell(row, col); 
         setActiveWindow(); 
         return; 
       } 
       --col; 
     } 
     col = NumCols - 1; 
     --row; 
   } 
   qApp->beep(); 
 }      
       
 
 

4.5. Реализация других меню.

Теперь перейдем к рассмотрению реализации слотов меню Tools и Options.

void Spreadsheet::recalculate() 
 { 
   int row; 
   
   for (row = 0; row < NumRows; ++row) { 
     for (int col = 0; col < NumCols; ++col) { 
       if (cell(row, col)) 
         cell(row, col)->setDirty(); 
       } 
     } 
     for (row = 0; row < NumRows; ++row) {      
       for (int col = 0; col < NumCols; ++col) { 
         if (cell(row, col)) 
           updateCell(row, col); 
       } 
     } 
 }   
       
 

В первой группе циклов все ячейки помечаются, вызовом setDirty(), как требующие пересчета. В результате, когда в следующий раз QTable вызовет метод text() ячейки Cell, то ее содержимое будет пересчитано.

Вторая группа циклов выполняет updateCell() каждой ячейки, чтобы перерисовать ее. В результате, QTable вызовет метод text() ячейки Cell, чтобы получить ее значение, а поскольку все ячейки были помечены вызовом setDirty(), то будет выполнен пересчет.

void Spreadsheet::setAutoRecalculate(bool on) 
 { 
   autoRecalc = on; 
   if (autoRecalc) 
     recalculate(); 
 }
       
 
 

void Spreadsheet::sort(const SpreadsheetCompare &compare) 
 { 
   vector<QStringList> rows; 
   QTableSelection sel = selection(); 
   int i; 
   
   for (i = 0; i < sel.numRows(); ++i) { 
     QStringList row; 
     for (int j = 0; j < sel.numCols(); ++j) 
       row.push_back(formula(sel.topRow() + i, 
                     sel.leftCol() + j)); 
     rows.push_back(row); 
   } 
   
   stable_sort(rows.begin(), rows.end(), compare); 
   
   for (i = 0; i < sel.numRows(); ++i) { 
     for (int j = 0; j < sel.numCols(); ++j) 
       setFormula(sel.topRow() + i, sel.leftCol() + j, 
                  rows[i][j]);      
   } 
   clearSelection(); 
   somethingChanged(); 
 }
       
 
 

В spreadsheet.h, класс SpreadsheetCompare определен как:

class SpreadsheetCompare 
 { 
 public: 
   bool operator()(const QStringList &row1, 
                   const QStringList &row2) const; 
                   
   enum { NumKeys = 3 }; 
   int keys[NumKeys];      
   bool ascending[NumKeys]; 
 };
       
 

class Square 
 { 
 public: 
   int operator()(int x) const { return x * x; } 
 };      
       
 
 

  Square square; 
   int y = square(5);      
       
 

  QStringList row1, row2; 
   SpreadsheetCompare compare; 
   ...
   if (compare(row1, row2)) { 
     // row1 меньше чем row2 
   }      
       
 
 

Альтернативный подход вынудил бы нас хранить параметры сортировки в глобальных переменных и использовать обычную функцию сравнения. Это очень неэлегантное решение, которое может породить трудноуловимые ошибки. Функторы -- это более мощная идиома взаимодействия с шаблонными функциями, такими как stable_sort(). Ниже приводится реализация функции, которая сравнивает две строки таблицы:

bool SpreadsheetCompare::operator()(const QStringList &row1, 
                                     const QStringList &row2) const 
 { 
   for (int i = 0; i < NumKeys; ++i) { 
     int column = keys[i]; 
     if (column != -1) { 
       if (row1[column] != row2[column]) { 
         if (ascending[i]) 
           return row1[column] < row2[column]; 
         else 
           return row1[column] > row2[column]; 
       }      
     } 
   } 
     return false; 
 }       
       
 
 

Массивы keys и ascending, заполняются внутри функции MainWindow::sort() (описаной в Главе 2). Каждый ключ сортировки -- это индекс столбца или -1 (в случае "None").

Сравнению подвергаются части строк, соответствующие ячейкам, заданным ключами сортировки, с учетом порядка сортировки. В зависимости от того были найдены отличия или нет -- возвращается значение true или false. Если строки равны, то возвращается false.

На этом мы завершаем рассмотрение класса Spreadsheet. В следующем разделе мы обсудим класс Cell. Он используется для хранения формулы и реализует свой метод text(), который используется для получения значения ячейки.

4.6. Создание дочернего класса от QTableItem.

Класс Cell порожден от класса QTableItem. Он предназначен для совместной работы с Spreadsheet, но никак не зависит от этого класса и теоретически может работать с любым экземпляром QTable.

Заголовочный файл:

#ifndef CELL_H 
 #define CELL_H 
 
 #include <qtable.h> 
 #include <qvariant.h> 
 
 class Cell : public QTableItem 
 { 
 public: 
   Cell(QTable *table, const QString &formula); 
   
   void setFormula(const QString &formula); 
   QString formula() const; 
   void setDirty(); 
   QString text() const; 
   int alignment() const; 
 
 private: 
   QVariant value() const;      
 QVariant evalExpression(const QString &str, int &pos) const; 
 QVariant evalTerm(const QString &str, int &pos) const; 
   QVariant evalFactor(const QString &str, int &pos) const; 
   
   QString formulaStr; 
   mutable QVariant cachedValue; 
   mutable bool cacheIsDirty; 
 }; 
 #endif  
       
 
 

• formulaStr -- формула ячейки, QString.

• cachedValue -- кэш ячейки, QVariant.

• cacheIsDirty -- true, если значение в кэше необходимо обновить.

Переменные cachedValue и cacheIsDirty объявлены со спецификатором mutable. Это позволяет модифицировать их из const-функций. В противном случае нам пришлось бы пересчитывать значение ячейки всякий раз, при вызове функции text(), но это было бы неэффективной тратой времени.

Примечательно, что в определении класса отсутствует макрос Q_OBJECT. Дело в том, что Cell -- это обычный класс, который не имеет ни сигналов, ни слотов. Фактически, QTableItem не является наследником класса QObject, поэтому Cell не может иметь своих собственных сигналов и слотов. Вообще, классы элементов в Qt не являются потомками QObject, чтобы свести накладные расходы к минимуму. Если вам потребуются сигналы и слоты в классах-элементах, то вы можете реализовать свой виджет, который будет содержать элемент или, в исключительных случаях, воспользоваться возможностью множественного наследования, указав в качестве одного из предков класс QObject.

Перейдем к файлу cell.cpp:

#include <qlineedit.h> 
 #include <qregexp.h> 
 
 #include "cell.h" 
 
 Cell::Cell(QTable *table, const QString &formula) 
     : QTableItem(table, OnTyping) 
 { 
   setFormula(formula); 
 }
       
 

void Cell::setFormula(const QString &formula) 
 { 
   formulaStr = formula;     
   cacheIsDirty = true; 
 } 
       
 

QString Cell::formula() const 
 { 
   return formulaStr; 
 }
       
 

void Cell::setDirty() 
 { 
   cacheIsDirty = true; 
 }
       
 
 

QString Cell::text() const 
 { 
   if (value().isValid()) 
     return value().toString(); 
   else 
     return "####"; 
 }
       
 

Функция value() возвращает значение типа QVariant. Этот тип может хранить значения самых разных типов, таких как double или QString и предоставляет в распоряжение программиста ряд методов преобразования вариантного типа в другие типы. Например, вызов toString, для варианта типа double, вернет его строковое представление.

int Cell::alignment() const 
 { 
   if (value().type() == QVariant::String) 
     return AlignLeft | AlignVCenter; 
   else 
     return AlignRight | AlignVCenter; 
 }
       
 

const QVariant Invalid; 
 
 QVariant Cell::value() const { 
   if (cacheIsDirty) { 
     cacheIsDirty = false; 
     
     if (formulaStr.startsWith("'")) { 
       cachedValue = formulaStr.mid(1); 
     } else if (formulaStr.startsWith("=")) { 
       cachedValue = Invalid; 
       QString expr = formulaStr.mid(1); 
       expr.replace(" ", ""); 
       int pos = 0; 
       cachedValue = evalExpression(expr, pos); 
       if (pos < (int)expr.length()) 
         cachedValue = Invalid; 
     } else { 
       bool ok; 
       double d = formulaStr.toDouble(&ok); 
       if (ok) 
         cachedValue = d; 
       else 
         cachedValue = formulaStr; 
     } 
   } 
   return cachedValue; 
 }
       
 

Если формула начинается с одиночной кавычки (например, "'12345"), то в качестве значения возвращается часть строки, начиная с позиции 1 и до конца. (Одиночная кавычка занимает позицию 0.)

Если формула начинается с символа "=", то берется часть строки, начиная с позиции 1 и до конца, Из нее удаляются все пробелы. Затем производится вычисление по формуле, с помощью функции evalExpression(). Аргумент pos, передаваемый по ссылке, указывает -- с какого символа в строке необходимо начинать разбор выражения. По окончании работы функции он содержит позицию символа, на котором завершился разбор. Если pos не соответствует позиции последнего символа в строке, то это означает ошибку в выражении и в этом случае cachedValue будет содержать значение Invalid.

Если формула начинается не с символа "=" и не с одиночной кавычки, то делается попытка преобразовать строку в число с плавающей точкой. Если преобразование завершилось успешно, то в cachedValue записывается число типа double, в противном случае -- строка с формулой. Например, формула "1.50" будет благополучно преобразована в число 1.5, а формула "World Population" не может быть преобразована в число и в этом случае в cachedValue будет записана сама строка "World Population".

Функция value() -- это const-функция. Но благодаря тому, что переменные-члены cachedValue и cacheIsValid объявлены как mutable, компилятор позволит нам модифицировать их внутри функции. Вам может показаться, что достаточно убрать спецификатор const функции value() и можно будет отказаться от спецификатора mutable, для переменных cachedValue и cacheIsValid, но такой вариант все равно породит ошибку времени компиляции, поскольку value() вызывается из const-функции text(). Вообще, в мире C++, кэширование и mutable идут рядом, рука об руку.

Мы практически закончили рассмотрение приложения Spreadsheet. Осталось только разобраться с синтаксическим анализом формул. Далее, до конца этого раздела, мы сконцентрируемся на evalExpression() и двух вспомогательных функциях evalTerm() и evalFactor(). Реализация функций достаточно сложна, но они совершенно необходимы для нашего приложения. С другой стороны, поскольку эти функции напрямую не связаны с разработкой графического интерфейса, вы смело можете пропустить оставшуюся часть раздела и сразу перейти к Главе 5.

Функция evalExpression() возвращает результат вычисления выражения. Выражение -- это один или более термов (term), отделяемых друг от друга операторами '+' или '-', например, "2*C5+D6" -- это выражение, состоящее из термов "2*C5" и "D6". Термы, в свою очередь, могут состоять из одного или более факторов (factor), отделяемых друг от друга операторами '*' или '/', например, терм "2*C5" состоит из двух факторов -- "2" и "C5". И наконец, фактор может быть числом ("2"), адресом ячейки ("C5") или выражением в скобках с необязательным предшествующим знаком '-' (признак отрицательного числа). Разложив выражение на термы, а термы на факторы, мы получим правильную обработку приоритетов операций.

Начнем с функции evalExpression(), которая отвечает за разбор элемента Expression:

 QVariant Cell::evalExpression(const QString &str, 
         int &pos) const 
 { 
   QVariant result = evalTerm(str, pos); 
   while (pos < (int)str.length()) { 
     QChar op = str[pos]; 
     if (op != '+' && op != '-') 
       return result; 
     ++pos; 
     
     QVariant term = evalTerm(str, pos); 
     if (result.type() == QVariant::Double 
        && term.type() == QVariant::Double) { 
       if (op == '+') 
         result = result.toDouble() + term.toDouble(); 
       else 
         result = result.toDouble() - term.toDouble(); 
     } else { 
       result = Invalid;      
     } 
   } 
   return result; 
 }
       
 

Так продолжается до тех пор, пока не будут исчерпаны все термы. В данной ситуации все работает корректно, благодаря тому, что операции сложения и вычитания лево-ассоциативны, т.е. выражению "1-2-3" соответствует "(1-2)-3", а не "1-(2-3)".

QVariant Cell::evalTerm(const QString &str, 
           int &pos) const 
 { 
   QVariant result = evalFactor(str, pos); 
   while (pos < (int)str.length()) { 
     QChar op = str[pos]; 
     if (op != '*' && op != '/') 
       return result; 
     ++pos; 
     
     QVariant factor = evalFactor(str, pos); 
     if (result.type() == QVariant::Double 
         && factor.type() == QVariant::Double) { 
           if (op == '*') { 
             result = result.toDouble() * factor.toDouble(); 
           } else { 
             if (factor.toDouble() == 0.0) 
               result = Invalid; 
             else 
               result = result.toDouble() / factor.toDouble(); 
           } 
     } else { 
       result = Invalid; 
     } 
   } 
   return result; 
 }
       
 

QVariant Cell::evalFactor(const QString &str, 
           int &фьзжpos) const 
 { 
   QVariant result; 
   bool negative = false;      
 
   if (str[pos] == '-') { 
     negative = true; 
     ++pos; 
   } 
   
   if (str[pos] == '(') { 
     ++pos; 
     result = evalExpression(str, pos); 
     if (str[pos] != ')') 
       result = Invalid; 
     ++pos; 
   } else { 
     QRegExp regExp("[A-Za-z][1-9][0-9]{0,2}"); 
     QString token; 
     
     while (str[pos].isLetterOrNumber() || str[pos] == '.') { 
       token += str[pos]; 
       ++pos; 
     } 
     
     if (regExp.exactMatch(token)) { 
       int col = token[0].upper().unicode() - 'A'; 
       int row = token.mid(1).toInt() - 1; 
       
       Cell *c = (Cell *)table()->item(row, col); 
       if (c) 
         result = c->value(); 
       else 
         result = 0.0; 
     } else { 
       bool ok; 
       result = token.toDouble(&ok); 
       if (!ok) 
         result = Invalid; 
     } 
   } 
   
   if (negative) { 
     if (result.type() == QVariant::Double) 
       result = -result.toDouble(); 
     else 
       result = Invalid; 
   } 
   return result; 
 }  
       
 
 

Если фактор не является выражением в скобках, то извлекается лексема, которая может оказаться адресом ячейки или числом. Если лексема соответствует регулярному выражению QRegExp, то она воспринимается как адрес ячейки и вызывается value() для данной ячейки. Ячейка может находиться в любом месте электронной таблицы, а ее значение может так же вычисляться на основе других ячеек. Подобные зависимости не являются проблемой для нас, просто это может потребовать некоторого дополнительного времени для рассчета значений тех ячеек, у которых установлен флаг cacheIsDirty. Если лексема не является адресом ячейки, то она считается числом.

Что произойдет, если значение ячейки A1 вычисляется по формуле "=A1"? Или если ячейка A1 вычисляется по формуле "=A2", а ячейка A2 -- по формуле "=A1"? Хотя мы и не предусмотрели проверки циклических зависимостей, тем не менее наш анализатор довольно изящно решает эту проблему, возвращая ошибочный QVariant. Это происходит потому, что в функции value() сбрасывается флаг cacheIsDirty, а в cachedValue записывается Invalid до того, как будет вызвана функция evalExpression(). Если evalExpression() рекурсивно вызывает value() своей собственной ячейки, то ей сразу же возвращается значение Invalid, которое становится результатом всего выражения.

На этом мы завершаем обсуждение синтаксического анализатора формул. Он может быть расширен за счет введения обработки предопределенных функций электронной таблицы, таких как "sum()" и "avg()", в синтаксическом элементе фактор. Довольно просто в него можно добавить операцию конкатенации ("+") строк.

5.1. Переделка существующих виджетов Qt.

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

#ifndef HEXSPINBOX_H 
 #define HEXSPINBOX_H 
 
 #include <qspinbox.h> 
 
 class HexSpinBox : public QSpinBox {      
 public: 
   HexSpinBox(QWidget *parent, const char *name = 0); 
   
 protected: 
   QString mapValueToText(int value); 
   int mapTextToValue(bool *ok); 
 }; 
 #endif
       
 

#include <qvalidator.h> 
 
 
 #include "hexspinbox.h" 
 
 HexSpinBox::HexSpinBox(QWidget *parent, const char *name) 
     : QSpinBox(parent, name) 
 { 
   QRegExp regExp("[0-9A-Fa-f]+"); 
   setValidator(new QRegExpValidator(regExp, this)); 
   setRange(0, 255); 
 }      
       
 

QString HexSpinBox::mapValueToText(int value) 
 { 
   return QString::number(value, 16).upper(); 
 }      
       
 

int HexSpinBox::mapTextToValue(bool *ok) 
 { 
   return text().toInt(ok, 16); 
 }      
       
 

Если преобразование было выполнено успешно, то QString::toInt() запишет в аргумент *ok значение true и false -- в противном случае. Это полностью соответствует тому, чего ожидает QSpinBox.

Это собственно все, что мы хотели рассказать о HexSpinBox. Расширение возможностей других виджетов Qt выполняется аналогичным образом: выбирается необходимый виджет, создается класс-потомок и перекрываются некоторые виртуальные функции, изменяющие поведение класса-предка. Это общепринятая в Qt техника программирования. Фактически мы с ней уже сталкивались в Главе 4, когда создавали класс-потомок от QTable и перекрывали методы createEditor() и endEdit().

5.2. Создание класса-потомка от QWidget.

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

• Создается новая форма, по шаблону "Widget".

• На форму добавляются необходимые виджеты.

• Устанавливаются соединения между сигналами и слотами и добавляется необходимый код (либо в файл .ui.h, либо в класс реализации).

Если виджет не имеет собственных сигналов и слотов, и не перекрывает методов родителя, то возможна простая сборка виджета путем аггрегирования существующих виджетов, без создания класса-потомка. Такой подход использовался нами в Главе 1, при создании приложения "Age", когда мы просто "собрали" его из трех компонентов: QHBox, QSpinBox и QSlider. Но даже в этом случае можно было бы породить дочерний класс от QHBox и в его конструкторе создать виджеты QSpinBox и QSlider.

Если среди виджетов Qt нет ни одного, подходящего под имеющуюся задачу, и при этом нет таких виджетов, с помощью которых можно было бы собрать свой компонент, то у нас остается единственная возможность -- создать класс-потомок от QWidget и реализовать в нем необходимые обработчики событий и функции отрисовки. Этот подход дает нам абсолютную свободу в определении внешнего вида и поведения нового компонента. Многие виджеты Qt, например: QLabel, QPushButton и QTable реализованы именно таким способом.

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

Как обычно, начнем с файла заголовка:

#ifndef ICONEDITOR_H 
 #define ICONEDITOR_H 
 
 #include <qimage.h> 
 #include <qwidget.h> 
 
 class IconEditor : public QWidget 
 { 
   Q_OBJECT 
   Q_PROPERTY(QColor penColor READ penColor WRITE setPenColor) 
   Q_PROPERTY(QImage iconImage READ iconImage WRITE setIconImage) 
   Q_PROPERTY(int zoomFactor READ zoomFactor WRITE setZoomFactor) 
   
 public: 
   IconEditor(QWidget *parent = 0, const char *name = 0); 
   void setPenColor(const QColor &newColor); 
   QColor penColor() const { return curColor; } 
   void setZoomFactor(int newZoom); 
   int zoomFactor() const { return zoom; } 
   void setIconImage(const QImage &newImage); const 
   QImage &iconImage() const { return image; } 
   QSize sizeHint() const;      
       
 

protected: 
   void mousePressEvent(QMouseEvent *event); 
   void mouseMoveEvent(QMouseEvent *event); 
   void paintEvent(QPaintEvent *event);      
 
 private: 
   void drawImagePixel(QPainter *painter, int i, int j); 
   void setImagePixel(const QPoint &pos, bool opaque); 
   
   QColor curColor; 
   QImage image; 
   int zoom; 
 }; 
 #endif 
       
 
 

Файл реализации начинается с директив подключения заголовочных файлов и конструктора класса IconEditor:

#include <qpainter.h> 
 
 #include "iconeditor.h" 
 
 IconEditor::IconEditor(QWidget *parent, const char *name) 
     : QWidget(parent, name, WStaticContents) 
 { 
   setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum); 
   curColor = black; 
   zoom = 8; 
   image.create(16, 16, 32); 
   image.fill(qRgba(0, 0, 0, 0)); 
   image.setAlphaBuffer(true); 
 }
       
 

В переменную zoom записывается число 8. Это означает, что каждый пиксель иконки будет отображаться в виде квадрата 8 X 8. Устанавливается черный цвет "чернил", символ black -- это предопределенная константа в Qt. Сама иконка хранится в переменной image, доступ к которой осуществлен посредством функций setIconImage() и iconImage(). Программа-редактор должна вызывать setIconImage(), когда пользователь открывает файл с иконкой, и iconImage() -- когда пользователь сохраняет иконку в файл.

Переменная image имеет тип QImage. При инициализации мы задаем ей размер 16 X 16 и глубину цвета -- 32 бита, затем очищаем ее и разрешаем альфа-буфер.

Класс 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 red = 0xFFFF0000;      
       
 

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

QSize IconEditor::sizeHint() const 
 { 
   QSize size = zoom * image.size(); 
   if (zoom >= 3) 
     size += QSize(1, 1); 
   return size; 
 }
       
 

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

В дополнение к идеальному размеру, виджет имеет политику изменения размера, которая сообщает менеджеру размещения -- может ли виджет растягиваться или сжиматься. Вызовом setSizePolicy() мы указали политику изменения размеров в обоих направлениях, как QSizePolicy::Minimum. Тем самым, виджет сообщает менеджерам размещения о том, что идеальный размер является минимально возможным или, говоря другими словами, виджет может быть растянут, но никогда не должен сжиматься меньше идеальных размеров. Это поведение может быть изменено в Qt Designer, установкой свойства sizePolicy виджета. Смысл и назначение различных политик управления размерами будут обсуждаться в Главе 6.

void IconEditor::setPenColor(const QColor &newColor) 
 { 
   curColor = newColor; 
 }
       
 

void IconEditor::setIconImage(const QImage &newImage) 
 { 
   if (newImage != image) { 
     image = newImage.convertDepth(32); 
     image.detach(); 
     update(); 
     updateGeometry(); 
   } 
 }
       
 

Затем вызывется detach(), для получения полной копии изображения. Это совершенно необходимо, поскольку QImage пытается сэкономить память и время, копируя изображение только в том случае, когда его явно попросят об этом. Такая оптимизация называется явное совместное использование. Она будет подробно обсуждаться в разделе Контейнеры указателей, Главы 11 .

После того, как изображение будет скопировано, мы вызываем QWidget::update(), чтобы перерисовать виджет. Затем вызывается QWidget::updateGeometry(), чтобы сообщить менеджеру размещения о том, что идеальный размер виджета изменился. После чего будет выполнена автоматическая перекомпоновка виджетов, с учетом нового идеального размера.

void IconEditor::setZoomFactor(int newZoom) 
 { 
   if (newZoom < 1) 
     newZoom = 1; 
   if (newZoom != zoom) { 
     zoom = newZoom; 
     update(); 
     updateGeometry(); 
   } 
 }
       
 

Функции penColor(), iconImage() и zoomFactor() реализованы в виде inline-функций в файле заголовка.

Теперь перейдем к функции paintEvent(). Это самая важная функция. Она вызывается, когда необходимо перерисовать виджет. Ее реализация в QWidget фактически ничего не делает, оставляя на месте виджета пустое пространство.

Аналогично функциям contextMenuEvent() и closeEvent(), с которыми мы сталкивались в Главе 3, функция paintEvent() является обработчиком события. В Qt, для обработки любого вида события, предусматривается своя функция-обработчик. Обработка событий более подробно будет обсуждаться в Главе 7.

Существует несколько ситуаций, когда возникает событие paint и вызывается paintEvent():

• Когда виджет выводится на экране самый первый раз, система автоматически генерирует событие paint, чтобы заставить виджет нарисовать себя.

• При изменении размера виджета система так же генерирует это событие.

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

void IconEditor::paintEvent(QPaintEvent *) 
 { 
   QPainter painter(this); 
   
   if (zoom >= 3) { 
     painter.setPen(colorGroup().foreground()); 
     for (int i = 0; i <= image.width(); ++i) 
       painter.drawLine(zoom * i, 0, 
                        zoom * i, zoom * image.height()); 
     for (int j = 0; j <= image.height(); ++j) 
       painter.drawLine(0, zoom * j, 
                        zoom * image.width(), zoom * j); 
   } 
   
   for (int i = 0; i < image.width(); ++i) { 
     for (int j = 0; j < image.height(); ++j) 
       drawImagePixel(&painter, i, j); 
   } 
 }      
       
 
 

Функция QPainter::drawLine() имеет следующий синтаксис вызова:

painter.drawLine(x1, y1, x2, y2);     
       
 
 

Верхний левый пиксель виджета, в Qt, имеет координаты (0, 0), правый нижний пиксель -- (width()-1, height-1). То есть, по сути, обычная Декартова система координат, с небольшим отличием -- ось OY направлена вниз, что имеет определенный смысл при программировании графического интерфейса. Система координат в QPainter может быть подвергнута таким трансформациям, как трансляция, масштабирование, вращение и сдвиг. Более подробно мы обсудим эту тему в Главе 8.

Любой виджет снабжается своей собственной палитрой цветов, которая определяет -- какой цвет для каких целей используется. Например, в палитре есть запись, которая определяет цвет фона (обычно светло-серый), есть запись, которая определяет цвет текста (обычно черный). Как правило, палитра содержит цвета, соответствующие системной цветовой схеме. Используя палитру виджета, можно быть уверенным, что учитываются цветовые предпочтения пользователя.

Палитра содержит в себе три основные группы цветов: активные, неактивные и запрещенные. Решение о том, какую группу цветов использовать, зависит от текущего состояния виджета:

• Группа активных цветов используется, когда окно, на котором размещается виджет, активно.

• Группа неактивных цветов используется, когда окно, на котором размещается виджет, неактивно.

• Группа запрещенных цветов используется, когда доступ к виджету запрещен.

Функция paintEvent() завершается перерисовкой самого изображения, вызовом IconEditor::drawImagePixel(), которая отрисовывает каждый пиксель иконки в виде закрашенного квадрата.

void IconEditor::drawImagePixel(QPainter *painter, int i, int j) 
 { 
   QColor color; 
   QRgb rgb = image.pixel(i, j); 
   
   if (qAlpha(rgb) == 0) 
     color = colorGroup().base(); 
   else 
     color.setRgb(rgb); 
   
   if (zoom >= 3) { 
     painter->fillRect(zoom * i + 1, zoom * j + 1, 
                       zoom - 1, zoom - 1, color); 
   } else { 
     painter->fillRect(zoom * i, zoom * j, 
                       zoom, zoom, color); 
   } 
 }
       
 
 

painter->fillRect(x, y, w, h, brush);      
       
 

void IconEditor::mousePressEvent(QMouseEvent *event) 
 { 
   if (event->button() == LeftButton) 
     setImagePixel(event->pos(), true); 
   else if (event->button() == RightButton)
     setImagePixel(event->pos(), false); 
 }
       
 
 

Когда пользователь щелкает левой кнопкой мыши, вызывается приватная функция setImagePixel() с аргументом true, сообщая о том, что пиксель должен быть закрашен текущим цветом "чернил". Если пользователь щелкает правой кнопкой мыши, то в функцию setImagePixel() передается аргумент false и пиксель очищается.

void IconEditor::mouseMoveEvent(QMouseEvent *event) 
 { 
   if (event->state() & LeftButton) 
     setImagePixel(event->pos(), true); 
   else if (event->state() & RightButton) 
     setImagePixel(event->pos(), false); 
 }
       
 

void IconEditor::setImagePixel(const QPoint &pos, bool opaque) 
 { 
   int i = pos.x() / zoom; 
   int j = pos.y() / zoom; 
   
   if (image.rect().contains(i, j)) { 
     if (opaque) 
       image.setPixel(i, j, penColor().rgb()); 
     else 
       image.setPixel(i, j, qRgba(0, 0, 0, 0)); 
     
     QPainter painter(this); 
     drawImagePixel(&painter, i, j); 
   } 
 }
       
 
 

На первом этапе выполняется переход от системы координат виджета к системе координат изображения. Переход осуществляется делением координат указателя мыши x и y на коэффициент масштабирования. Затем проверяется -- находятся ли координаты точки в допустимом диапазоне. Проверка выполняется с помощью QImage::rect() и QRect::contains(), которые проверяют попадание i в диапазон 0..image.width()-1 и попадание j в диапазон 0..image.height()-1.

В зависимости от параметра opaque, пиксель в изображении либо окрашивается в заданный цвет, либо очищается. "Очистка" пикселя заключается в том, что он делается прозрачным. В конце вызывается drawImagePixel() для перерисовки пикселя.

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

Когда размеры виджета изменяются, Qt обычно генерирует событие paint для всей видимой области виджета. Но, если виджет был создан с флагом WStaticContents, то действие события ограничивается пикселями, которые ранее не были показаны. Если же размеры виджета уменьшаются, то событие paint вообще не возникает.

5.3. Интеграция виджета в Qt Designer.

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

Методика "простого виджета" заключается в заполнении полей диалога Qt Designer. После этого виджет может вставляться в формы, разрабатываемые в среде Qt Designer, но отображаться на форме, во время редактирования и предварительного просмотра, он будет в виде черного прямоугольника. Ниже приводится последовательность действий по интеграции HexSpinBox таким способом:

1. Выберите пункт меню Tools|Custom|Edit Custom Widget. Перед вами появится диалоговое окно "Edit Custom Widgets".

2. Щелкните по кнопке "New Widget".

3. Измените имя класса MyCustomWidget на HexSpinBox и имя заголовочного файла mycustomwidget.h на hexspinbox.h.

4. Измените "Size Hint" на (60, 20).

5. Измените "Size Policy" на (Minimum, Fixed).

Прежде всего, необходимо создать класс-потомок от QWidgetPlugin и перекрыть некоторые виртуальные функции. Весь код можно разместить в тех же самых файлах с исходными текстами, но мы создадим файлы плагина отдельно. Допустим, что файлы, с исходным кодом плагина, находятся в каталоге iconeditorplugin, а с исходным кодом самого компонента -- в параллельном каталоге iconeditor.

Заголовочный файл плагина:

#include <qwidgetplugin.h> 
 
 #include "../iconeditor/iconeditor.h" 
 
 class IconEditorPlugin : public QWidgetPlugin 
 { 
 public: 
   QStringList keys() const; 
   QWidget *create(const QString &key, QWidget *parent, 
                   const char *name);      
   QString includeFile(const QString &key) const; 
   QString group(const QString &key) const; 
   QIconSet iconSet(const QString &key) const; 
   QString toolTip(const QString &key) const; 
   QString whatsThis(const QString &key) const; 
   bool isContainer(const QString &key) const; 
 };                  
       
 

QStringList IconEditorPlugin::keys() const 
 { 
   return QStringList() << "IconEditor"; 
 }      
       
 

QWidget *IconEditorPlugin::create(const QString &, 
           QWidget *parent, 
                                   const char *name) 
 { 
   return new IconEditor(parent, name); 
 }      
       
 
 

QString IconEditorPlugin::includeFile(const QString &) 
           const 
 { 
   return "iconeditor.h"; 
 }      
       
 

bool IconEditorPlugin::isContainer(const QString &) 
           const 
 { 
   return false; 
 }      
       
 

QString IconEditorPlugin::group(const QString &) 
           const 
 { 
   return "Plugin Widgets"; 
 }      
       
 
 

QIconSet IconEditorPlugin::iconSet(const QString &) 
           const 
 { 
   return QIconSet(QPixmap::fromMimeSource("iconeditor.png")); 
 }      
       
 

QString IconEditorPlugin::toolTip(const QString &) 
           const 
 { 
   return "Icon Editor"; 
 }      
       
 

QString IconEditorPlugin::whatsThis(const QString &) 
           const 
 { 
   return "Widget for creating and editing icons"; 
 }
       
 
 

Q_EXPORT_PLUGIN(IconEditorPlugin)      
       
 

Файл .pro для сборки плагина выглядит примерно так:

TEMPLATE   = lib 
 CONFIG    += plugin 
 HEADERS    = ../iconeditor/iconeditor.h 
 SOURCES    = iconeditorplugin.cpp \ 
              ../iconeditor/iconeditor.cpp 
 IMAGES     = images/iconeditor.png 
 DESTDIR    = $(QTDIR)/plugins/designer      
       
 

После сборки плагина вы можете использовать IconEditor в Qt Designer точно так же, как встроенные виджеты Qt.

5.4. Двойная буферизация.

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

Когда Qt генерирует событие paint, виджет сначала "стирается" -- т.е. все пиксели окрашиваются цветом фона. Затем, в функции paintEvent() виджету остается окрасить только те пиксели, цвет которых отличается от цвета фона. Такой двухшаговый алгоритм довольно удобен, поскольку мы перерисовываем только то что нужно, нимало не беспокоясь о других писелях.

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

Первое правило, на пути к устранению мерцания -- конструировать виджет с флагом WNoAutoErase. Этот флаг предотвращает стирание виджета перед передачей событие paint.

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

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

void MyWidget::paintEvent(QPaintEvent *) 
 { 
   QPainter painter(this); 
   drawMyStuff(&painter); 
 }      
       
 

void MyWidget::paintEvent(QPaintEvent *event) 
 { 
   static QPixmap pixmap; 
   QRect rect = event->rect(); 
   
   QSize newSize = rect.size().expandedTo(pixmap.size()); 
   pixmap.resize(newSize); 
   pixmap.fill(this, rect.topLeft()); 
   
   QPainter painter(&pixmap, this); 
   painter.translate(-rect.x(), -rect.y()); 
   drawMyStuff(&painter); 
   bitBlt(this, rect.x(), rect.y(), &pixmap, 0, 0, 
          rect.width(), rect.height()); 
 }
       
 

Класс QPixmap очень напоминает QImage и QWidget. Подобно QImage, он хранит изображение, но глубина цвета и цветовая палитра зависят от настроек дисплея, подобно QWidget. Если оконная система работает с 8-ми битным цветом, все QWidget и QPixmap ограничиваются 256-ю цветами, а Qt автоматически переводит 24-х битный цвет в 8-ми битное представление.

Затем создается QPainter. Передавая указатель this конструктору, мы заставляем QPainter взять некоторые настройки, например шрифт, из виджета. Вызовом translate() осуществляется переход к системе координат виджета.

В завершение, изображение копируется в виджет с помощью глобальной функции bitBlt() (от англ. "bit-block transfer" -- "перемещение битового блока").

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

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

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

Компонент может хранить данные любого числа кривых. Он так же имеет стек из экземпляров класса PlotSettings, на котором хранится история изменения масштаба пользователем.

Начнем с файла заголовка:

#ifndef PLOTTER_H 
 #define PLOTTER_H 
 
 #include <qpixmap.h> 
 #include <qwidget.h> 
 
 #include <map> 
 
 #include <vector> 
 
 class QToolButton; 
 class PlotSettings; 
 
 typedef std::vector<double> CurveData;      
       
 

Мы определили CurveData, как синоним std::vector<double>. Координаты точек, определяющих кривую на графике, предполагается хранить в виде массива пар координат x и y. Например, кривая задана тремя точками, с координатами (0, 24), (1, 44), (2, 89), что соответствует массиву значений [0, 24, 1, 44, 2, 89].

class Plotter : public QWidget 
 { 
   Q_OBJECT 
   
 public: 
   Plotter(QWidget *parent = 0, const char *name = 0, 
           WFlags flags = 0); 
   void setPlotSettings(const PlotSettings &settings); 
   void setCurveData(int id, const CurveData &data); 
   void clearCurve(int id); 
   QSize minimumSizeHint() const; 
   QSize sizeHint() const; 
   
 public slots: 
   void zoomIn(); 
   void zoomOut();      
       
 
 

protected: 
   void paintEvent(QPaintEvent *event); 
   void resizeEvent(QResizeEvent *event); 
   void mousePressEvent(QMouseEvent *event); 
   void mouseMoveEvent(QMouseEvent *event); 
   void mouseReleaseEvent(QMouseEvent *event); 
   void keyPressEvent(QKeyEvent *event); 
   void wheelEvent(QWheelEvent *event);      
       
 

private: 
   void updateRubberBandRegion(); 
   void refreshPixmap(); 
   void drawGrid(QPainter *painter); 
   void drawCurves(QPainter *painter); 
   
   enum { Margin = 40 }; 
   
   QToolButton *zoomInButton; 
   QToolButton *zoomOutButton; 
   std::map<int, CurveData> curveMap; 
   std::vector<PlotSettings> zoomStack; 
   int curZoom; 
   bool rubberBandIsShown; 
   QRect rubberBandRect; 
   QPixmap pixmap; 
 };
       
 

class PlotSettings 
 { 
 public: 
   PlotSettings();
   
   void scroll(int dx, int dy); 
   void adjust(); 
   double spanX() const { return maxX - minX; } 
   double spanY() const { return maxY - minY; } 
   
   double minX; 
   double maxX; 
   int numXTicks; 
   double minY; 
   double maxY; 
   int numYTicks; 
   
 private: 
 void adjustAxis(double &min, double &max, int &numTicks); 
 }; 
 #endif      
       
 

Строго говоря, переменные numXTicks и numYTicks хранят не число рисок, а число интервалов между рисками, т.е. если, например, в переменной numXTicks хранится число 5, то фактически, на оси x будет нарисовано 6 рисок. Такой подход упрощает расчеты, которые мы будем рассматривать чуть ниже.

#include <qpainter.h> 
 
 #include <qstyle.h> 
 #include <qtoolbutton.h> 
 
 #include <cmath> 
 using namespace std; 
 
 #include "plotter.h"      
       
 

Plotter::Plotter(QWidget *parent, const char *name, 
           WFlags flags) 
     : QWidget(parent, name, flags | WNoAutoErase) 
 { 
   setBackgroundMode(PaletteDark); 
   setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding); 
   setFocusPolicy(StrongFocus); 
   rubberBandIsShown = false; 
   
   zoomInButton = new QToolButton(this); 
   zoomInButton->setIconSet(QPixmap::fromMimeSource("zoomin.png")); 
   zoomInButton->adjustSize(); 
   connect(zoomInButton, SIGNAL(clicked()), this, SLOT(zoomIn())); 
   
   zoomOutButton = new QToolButton(this); 
   zoomOutButton->setIconSet( QPixmap::fromMimeSource("zoomout.png")); 
   zoomOutButton->adjustSize(); 
   connect(zoomOutButton, SIGNAL(clicked()), this, SLOT(zoomOut()));
   
   setPlotSettings(PlotSettings()); 
 }
       
 
 

Вызов setBackgroundMode() устанавливает в качестве фонового, вместо элемента палитры "background", элемент палитры -- "dark" (темный). Хотя в конструктор базового класса и передается флаг WNoAutoErase, тем не менее, по-прежнему необходимо иметь какой нибудь цвет в качестве фонового, которым будут закрашиваться пиксели, появляющиеся при увеличении размеров виджета, до того, как сработает обработчик paintEvent(). Поскольку фон виджета Plotter будет темным, то определенно имеет смысл окрашивать новые пиксели именно в темный цвет.

Затем, вызовом setSizePolicy(), устанавливается политика изменения размеров виджета. В данном случае, виджет может свободно изменять свои размеры по обеим осям. Такая политика изменения размеров характерна для виджетов, которые могут занимать значительную часть площади экрана. По-умолчанию, политика изменения размеров, для обеих осей, имеет значение QSizePolicy::Preferred, т.е. -- виджет "предпочитает" иметь размеры, равные "идеальным" значениям, но допускает и сжатие до минимально возможного размера (minimumSizeHint()), и растягивание до неопределенного предела.

Вызов setFocusPolicy() указывает виджету, что он может принимать фокус по щелчку мыши или по клавише Tab. Когда Plotter владеет фокусом, он может принимать и обрабатывать события от клавиатуры. Он реагирует на нажатия клавиш: "+" -- увеличить изображение, "-" -- уменьшить изображение и клавиши со стрелками -- для перемещения графика вверх, вниз, влево и вправо.

IMAGES += images/zoomin.png \ 
           images/zoomout.png      
       
 
 

И, наконец, вызов setPlotSettings() завершает инициализацию виджета.

void Plotter::setPlotSettings(const PlotSettings &settings) 
 { 
   zoomStack.resize(1); 
   zoomStack[0] = settings;
   curZoom = 0; 
   zoomInButton->hide(); 
   zoomOutButton->hide(); 
   refreshPixmap(); 
 }
       
 
 

Стек представляют две переменные:

• zoomStack -- хранит экземпляры PlotSettings в виде одномерного массива vector<PlotSettings>.

• curZoom -- индекс экземпляра PlotSettings (в массиве zoomStack), который представляет текущие настройки.

Вызов refreshPixmap() обновляет изображение. Как правило, в таких случаях, мы вызываем update(), но в данной ситуации все делается несколько иначе, поскольку необходимо, чтобы QPixmap хранил самую последнюю версию картинки, отображаемой на экране. После регенерации картинки, refreshPixmap() вызывает update(), чтобы скопировать полученное изображение в виджет.

void Plotter::zoomOut() 
 { 
   if (curZoom > 0) { 
     --curZoom; 
     zoomOutButton->setEnabled(curZoom > 0); 
     zoomInButton->setEnabled(true); 
     zoomInButton->show(); 
     refreshPixmap(); 
   } 
 }
       
 

void Plotter::zoomIn() 
 { 
   if (curZoom < (int)zoomStack.size() - 1) { 
     ++curZoom; 
     zoomInButton->setEnabled( curZoom < (int)zoomStack.size() - 1); 
     zoomOutButton->setEnabled(true); 
     zoomOutButton->show(); 
     refreshPixmap();
   } 
 }
       
 
 

Слот увеличивает значение переменной curZoom, для перемещения на очередной уровень в стеке масштабов. Разрешает или запрещает кнопку Zoom In в зависимости от того -- достигнуто ли дно стека. И разрешает кнопку Zoom Out. Напоследок вызывается refreshPixmap(), чтобы обновить изображение на экране.

void Plotter::setCurveData(int id, const CurveData &data) 
 { 
   curveMap[id] = data; 
   refreshPixmap(); 
 }
       
 

И опять же, для обновления отображения на экране, вместо update(), вызывается refreshPixmap().

void Plotter::clearCurve(int id) 
 { 
   curveMap.erase(id); 
   refreshPixmap(); 
 }
       
 

QSize Plotter::minimumSizeHint() const 
 { 
   return QSize(4 * Margin, 4 * Margin); 
 }      
       
 
 

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

QSize Plotter::sizeHint() const 
 { 
   return QSize(8 * Margin, 6 * Margin); 
 }
       
 
 

На этом мы завершаем обзор публичных методов и слотов класса Plotter и переходим к защищенным обработчикам событий.

void Plotter::paintEvent(QPaintEvent *event) 
 { 
   QMemArray<QRect> rects = event->region().rects(); 
   for (int i = 0; i < (int)rects.size(); ++i) 
     bitBlt(this, rects[i].topLeft(), &pixmap, rects[i]); 
   
   QPainter painter(this); 
   
   if (rubberBandIsShown) { 
     painter.setPen(colorGroup().light()); 
     painter.drawRect(rubberBandRect.normalize()); 
   } 
   if (hasFocus()) { 
     style().drawPrimitive(QStyle::PE_FocusRect, &painter, 
                           rect(), colorGroup(), QStyle::Style_FocusAtBorder, 
                           colorGroup().dark()); 
   } 
 }
       
 
 

Вызов QRegion::rect() возвращает массив из QRect, который задает область перерисовки. Для копирования каждой подобласти, из буфера с изображением в виджет, используется функция bitBlt(). Это функция с глобальной областью видимости. Она имеет следующий синтаксис:

bitBlt(dest, destPos, source, sourceRect);      
       
 

Как только перенос картинки из буфера будет завершен, мы приступаем к рисованию границ области выделения. Рамка рисуется цветом группы "light", чтобы обеспечить приемлемую контрастность рамки и фона. Обратите внимание: рамка рисуется прямо на виджете, оставляя буфер с рисунком в неприкосновенности. Собственно рисование выполняется функцией drawPrimitive().

Функция QWidget::style() возвращает стиль рисования виджета. В Qt стиль рисования виджета -- это подкласс QStyle. В список встроенных стилей входят QWindowsStyle, QWindowsXPStyle, QMotifStyle и QMacStyle.. Каждый из них предоставляет свою реализации виртуальных методов. Функция drawPrimitive() -- одна из них. Она рисует графические примитивы, такие как панели, кнопки и границы областей выделения, в соответствии с выбранным стилем. Как правило, для всех виджетов приложения устанавливается единый стиль отображения (QApplication::style()), но он может быть изменен для каждого из виджетов, вызовом QWidget::setStyle().

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

Стандартные виджеты Qt, практически всегда отрисовывают себя, основываясь на QStyle. Именно по этой причине они похожи на "родные" графические элементы самой операционной системы. Свои виджеты вы можете отрисовывать либо используя QStyle, либо собирая их из стандартных виджетов Qt. В случае с Plotter мы использовали оба подхода: прямоугольная рамка выделения рисуется с помощью QStyle, а кнопки Zoom In и Zoom Out -- это стандартные виджеты.

void Plotter::resizeEvent(QResizeEvent *) 
 { 
   int x = width() - (zoomInButton->width() 
           + zoomOutButton->width() + 10); 
   zoomInButton->move(x, 5); 
   zoomOutButton->move(x + zoomInButton->width() + 5, 5); 
   refreshPixmap(); 
 }
       
 

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

Нам не нужно изначально устанавливать кнопки в конструкторе, поскольку перед тем как виджет впервые появится на экране, Qt сгенерирует событие "resize".

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

В конце обработчика, для перерисовки графика с новыми размерами, вызывается refreshPixmap().

void Plotter::mousePressEvent(QMouseEvent *event) 
 { 
   if (event->button() == LeftButton) { 
     rubberBandIsShown = true; 
     rubberBandRect.setTopLeft(event->pos()); 
     rubberBandRect.setBottomRight(event->pos()); 
     updateRubberBandRegion(); 
     setCursor(crossCursor); 
   } 
 }
       
 

Qt предоставляет два основных механизма управления внешним видом указателя мыши:

• QWidget::setCursor() -- устанавливает внешний вид курсора для конкретного виджета. По-умолчанию используется внешний вид курсора, установленный для владельца виджета или в виде стрелки (если в иерархии владельцев ни у кого не задан вид курсора мыши).

• QApplication::setOverrideCursor() -- устанавливает вид курсора для всего приложения в целом. Она отменяет действие QWidget::setCursor() всех виджетов, пока не будет вызвана restoreOverrideCursor().

void Plotter::mouseMoveEvent(QMouseEvent *event) 
 { 
   if (event->state() & LeftButton) { 
     updateRubberBandRegion(); 
     rubberBandRect.setBottomRight(event->pos()); 
     updateRubberBandRegion(); 
   } 
 }
       
 
 

Переменная rubberBandRect имеет тип QRect. Экземпляры этого класса могут поставлять значения в виде (x, y, w, h), где (x, y) --это координаты левого верхнего угла, а w, h -- ширина и высота прямоугольника либо в виде пар координат верхнего левого и правого нижнего углов. В нашем случае мы используем представление в виде пар координат. В качестве координат верхнего левого угла устанавливаются координаты указателя мыши в момент нажатия на кнопку, а текущее положение курсора мыши принимается за правый нижний угол рамки выделения.

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

void Plotter::mouseReleaseEvent(QMouseEvent *event) 
 { 
   if (event->button() == LeftButton) { 
     rubberBandIsShown = false; 
     updateRubberBandRegion(); 
     unsetCursor(); 
     
     QRect rect = rubberBandRect.normalize(); 
     if (rect.width() < 4 || rect.height() < 4) 
       return; 
     rect.moveBy(-Margin, -Margin); 
     
     PlotSettings prevSettings = zoomStack[curZoom]; 
     PlotSettings settings; 
     double dx = prevSettings.spanX() / (width() - 2 * Margin); 
     double dy = prevSettings.spanY() / (height() - 2 * Margin); 
     settings.minX = prevSettings.minX + dx * rect.left(); 
     settings.maxX = prevSettings.minX + dx * rect.right(); 
     settings.minY = prevSettings.maxY - dy * rect.bottom(); 
     settings.maxY = prevSettings.maxY - dy * rect.top(); 
     settings.adjust(); 
     
     zoomStack.resize(curZoom + 1); 
     zoomStack.push_back(settings); 
     zoomIn(); 
   } 
 }
       
 
 

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

После выполнения преобразований, вызывается PlotSettings::adjust(), которая округляет размеры и находит наиболее разумные значения для рисок, наносимых на оси графика.

void Plotter::keyPressEvent(QKeyEvent *event) 
 { 
   switch (event->key()) { 
     case Key_Plus: 
         zoomIn(); 
         break; 
     case Key_Minus: 
         zoomOut(); 
         break; 
     case Key_Left: 
         zoomStack[curZoom].scroll(-1, 0); 
         refreshPixmap();      
         break; 
     case Key_Right: 
         zoomStack[curZoom].scroll(+1, 0); 
         refreshPixmap(); 
         break; 
     case Key_Down: 
         zoomStack[curZoom].scroll(0, -1); 
         refreshPixmap(); 
         break; 
     case Key_Up: 
         zoomStack[curZoom].scroll(0, +1); 
         refreshPixmap(); 
         break; 
     default: 
         QWidget::keyPressEvent(event); 
   } 
 }
       
 
 

void Plotter::wheelEvent(QWheelEvent *event) 
 { 
   int numDegrees = event->delta() / 8; 
   int numTicks = numDegrees / 15; 
   
   if (event->orientation() == Horizontal) 
     zoomStack[curZoom].scroll(numTicks, 0); 
   else 
     zoomStack[curZoom].scroll(0, numTicks); 
   
   refreshPixmap(); 
 }
       
 

На этом мы завершаем обзор обработчиков событий и переходим к приватным функциям:

void Plotter::updateRubberBandRegion() 
 { 
   QRect rect = rubberBandRect.normalize(); 
   
   update(rect.left(), rect.top(), rect.width(), 1); 
   update(rect.left(), rect.top(), 1, rect.height()); 
   update(rect.left(), rect.bottom(), rect.width(), 1); 
   update(rect.right(), rect.top(), 1, rect.height()); 
 }
       
 

void Plotter::updateRubberBandRegion() 
 { 
   QPainter painter(this); 
   painter.setRasterOp(NotROP); 
   painter.drawRect(rubberBandRect.normalize()); 
 }
               
 

void Plotter::refreshPixmap() 
 { 
   pixmap.resize(size()); 
   pixmap.fill(this, 0, 0); 
   QPainter painter(&pixmap, this); 
   
   drawGrid(&painter); 
   drawCurves(&painter); 
   update(); 
 }
       
 

Далее создается QPainter и с его помощью в буфере рисуются координатная сетка и кривые. В заключение вызывается update(), которая планирует событие "paint" для всего виджета в целом. Буфер будет скопирован в виджет -- в обработчике события paintEvent().

void Plotter::drawGrid(QPainter *painter) 
 { 
   QRect rect(Margin, Margin, 
              width() - 2 * Margin, height() - 2 * Margin); 
   PlotSettings settings = zoomStack[curZoom]; 
   QPen quiteDark = colorGroup().dark().light(); 
   QPen light = colorGroup().light(); 
   
   for (int i = 0; i <= settings.numXTicks; ++i) { 
     int x = rect.left() + (i * (rect.width() - 1) 
                              / settings.numXTicks); 
     double label = settings.minX + (i * settings.spanX() 
                                       / settings.numXTicks); 
     painter->setPen(quiteDark); 
     painter->drawLine(x, rect.top(), x, rect.bottom()); 
     painter->setPen(light); 
     painter->drawLine(x, rect.bottom(), x, rect.bottom() + 5); 
     painter->drawText(x - 50, rect.bottom() + 5, 100, 15, 
                       AlignHCenter | AlignTop, 
                       QString::number(label)); 
   } 
   
   for (int j = 0; j <= settings.numYTicks; ++j) { 
     int y = rect.bottom() - (j * (rect.height() - 1) 
                                / settings.numYTicks); 
     double label = settings.minY + (j * settings.spanY() 
                                       / settings.numYTicks); 
     painter->setPen(quiteDark); 
     painter->drawLine(rect.left(), y, rect.right(), y); 
     painter->setPen(light); 
     painter->drawLine(rect.left() - 5, y, rect.left(), y); 
     painter->drawText(rect.left() - Margin, y - 10, 
                       Margin - 5, 20, 
                       AlignRight | AlignVCenter, 
                       QString::number(label)); 
   } 
   painter->drawRect(rect); 
 }
       
 
 

Функция drawText() имеет следующий синтаксис:

painter.drawText(x, y, w, h, alignment, text);      
       
 

void Plotter::drawCurves(QPainter *painter) 
 { 
   static const QColor colorForIds[6] = { 
     red, green, blue, cyan, magenta, yellow 
   }; 
   PlotSettings settings = zoomStack[curZoom]; 
   QRect rect(Margin, Margin, 
              width() - 2 * Margin, height() - 2 * Margin); 
   painter->setClipRect(rect.x() + 1, rect.y() + 1, 
                        rect.width() - 2, rect.height() - 2); 
   map<int, CurveData>::const_iterator it = curveMap.begin(); 
   while (it != curveMap.end()) { 
     int id = (*it).first; 
     const CurveData &data = (*it).second; 
     int numPoints = 0; 
     int maxPoints = data.size() / 2; 
     QPointArray points(maxPoints); 
     
     for (int i = 0; i < maxPoints; ++i) { 
       double dx = data[2 * i] - settings.minX; 
       double dy = data[2 * i + 1] - settings.minY; 
       double x = rect.left() + (dx * (rect.width() - 1) 
                                    / settings.spanX()); 
       double y = rect.bottom() - (dy * (rect.height() - 1) 
                                      / settings.spanY()); 
       if (fabs(x) < 32768 && fabs(y) < 32768) { 
         points[numPoints] = QPoint((int)x, (int)y); 
         ++numPoints; 
       } 
     } 
     points.truncate(numPoints); 
     painter->setPen(colorForIds[(uint)id % 6]); 
     painter->drawPolyline(points); 
     ++it; 
   } 
 }      
       
 
 

Затем выполняется проход по всем кривым графика и для каждой из них -- по парам координат (x, y). Элемент итератора first дает нам ID (идентификатор) кривой, а second -- массив координат точек кривой.

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

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

На этом завершается реализация класса Plotter. И нам остается рассмотреть еще ряд функций-членов класса PlotSettings.

PlotSettings::PlotSettings() 
 { 
   minX = 0.0; 
   maxX = 10.0; 
   numXTicks = 5; 
   minY = 0.0; 
   maxY = 10.0; 
   numYTicks = 5; 
 }
       
 

void PlotSettings::scroll(int dx, int dy) 
 { 
   double stepX = spanX() / numXTicks; 
   minX += dx * stepX; 
   maxX += dx * stepX; 
   double stepY = spanY() / numYTicks; 
   minY += dy * stepY; 
   maxY += dy * stepY; 
 }
       
 

void PlotSettings::adjust() 
 { 
   adjustAxis(minX, maxX, numXTicks); 
   adjustAxis(minY, maxY, numYTicks); 
 }
       
 
 

void PlotSettings::adjustAxis(double &min, double &max, int &numTicks) 
 { 
   const int MinTicks = 4; 
   double grossStep = (max - min) / MinTicks; 
   double step = pow(10, floor(log10(grossStep))); 
   
   if (5 * step < grossStep) 
     step *= 5; 
   else if (2 * step < grossStep) 
     step *= 2; 
   
   numTicks = (int)(ceil(max / step) - floor(min / step)); 
   min = floor(min / step) * step; 
   max = ceil(max / step) * step; 
 }
       
 
 

Большая часть кода функции служит для определения наиболее подходящего "расстояния" между соседними рисками ("шаг"). К выбору шага нужно подходить очень осторожно. Дробные значения шага, например 3.8, сложнее воспринимаются людьми, чем круглые. Для осей, которые имеют метки, записываемые в десятичной нотации, "наилучшими" значениями будут числа 10^n, 2*10^n или 5*10^n.

Поиск начинается с "большого шага", своего рода максимального значения для шага. Затем находится число, ближайшее (меньше или равно) к значению "большого шага", которое можно записать в форме 10^n: берется десятичный логарифм от "большого шага", округляется вниз до ближайшего целого и затем вычисляется степень 10-ти, с найденым числом в качестве показателя. Например, пусть "большой шаг" равен числу 236, в результате получаем: log 236 = 2.37291; округление дает число 2, а 10^2 = 100 -- кандидат для размера "наилучшего" шага.

Как только мы получили значение первого "кандидата" для шага оси, необходимо рассчитать еще два значения -- 2*10^n и 5*10^n. Для примера выше, два других кандидата -- это числа 200 и 500. Но число 500 значительно больше установленного нами максимума (236), а 200 -- меньше, поэтому в качестве шага оси принимается число 200.

Теперь, основываясь на значении шага, очень легко вычислить min, max и numTicks. Значение min получается за счет округления вниз начального min, до ближайшего множителя шага, а значение max -- за счет округления вверх, до ближайшего множителя шага. Величина numTicks -- это количество шагов, укладывающихся в интервал, между min и max. Например, если начальные значения min = 240, max = 1184, то новый диапазон значений оси будет составлять [200..1200], с 5 интервалами-шагами.

Этот алгоритм не всегда дает оптимальные значения. Более изощренный алгоритм вы найдете в статье Пауля Хекберта (Paul S. Heckbert) -- "Nice Numbers for Graph Labels", опубликованной в Graphics Gems (ISBN 0-12-286166-3). Кроме того, в ежеквартальнике Qt Quarterly имеется статья "Fast and Flicker-Free" ( http://doc.trolltech.com/qq/qq06-flicker-free.html), которая рассматривает некоторые идеи по устранению эффекта мерцания.

Эта глава завершает первую часть книги. Здесь мы рассказали как настроить стандартные виджеты Qt и как создать свой виджет, используя в качестве базового класса QWidget. В Главе 2 мы видели, как можно "собрать" виджет из других виджетов, эта тема будет рассматриваться глубже в Главе 6.

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

6.1. Основы компоновки виджетов.

Qt предоставляет три основных способа управления размещением подчиненных виджетов на форме: абсолютное позиционирование, ручное управление размещением и менеджеры компоновки. Мы рассмотрим каждый из них, на примере диалога "Find File", показанный на рисунке 6.1.

FindFileDialog::FindFileDialog(QWidget *parent, const char *name) 
     : QDialog(parent, name) 
 { 
   ... 
   namedLabel->setGeometry(10, 10, 50, 20); 
   namedLineEdit->setGeometry(70, 10, 200, 20); 
   lookInLabel->setGeometry(10, 35, 50, 20); 
   lookInLineEdit->setGeometry(70, 35, 200, 20); 
   subfoldersCheckBox->setGeometry(10, 60, 260, 20); 
   listView->setGeometry(10, 85, 260, 100); 
   messageLabel->setGeometry(10, 190, 260, 20); 
   findButton->setGeometry(275, 10, 80, 25); 
   stopButton->setGeometry(275, 40, 80, 25); 
   closeButton->setGeometry(275, 70, 80, 25); 
   helpButton->setGeometry(275, 185, 80, 25); 
   setFixedSize(365, 220); 
 }
       
 
 

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

FindFileDialog::FindFileDialog(QWidget *parent, const char *name) 
     : QDialog(parent, name) 
 { 
   ... 
   setMinimumSize(215, 170); 
   resize(365, 220); 
 } 
 
 void FindFileDialog::resizeEvent(QResizeEvent *) 
 { 
   int extraWidth = width() - minimumWidth(); 
   int extraHeight = height() - minimumHeight(); 
   
   namedLabel->setGeometry(10, 10, 50, 20); 
   namedLineEdit->setGeometry(70, 10, 50 + extraWidth, 20); 
   lookInLabel->setGeometry(10, 35, 50, 20); 
   lookInLineEdit->setGeometry(70, 35, 50 + extraWidth, 20); 
   subfoldersCheckBox->setGeometry(10, 60, 110 + extraWidth, 20);      
   listView->setGeometry(10, 85, 
                         110 + extraWidth, 50 + extraHeight); 
   messageLabel->setGeometry(10, 140 + extraHeight, 
                             110 + extraWidth, 20); 
   findButton->setGeometry(125 + extraWidth, 10, 80, 25); 
   stopButton->setGeometry(125 + extraWidth, 40, 80, 25); 
   closeButton->setGeometry(125 + extraWidth, 70, 80, 25); 
   helpButton->setGeometry(125 + extraWidth, 135 + extraHeight, 
                           80, 25); 
 }
       
 
 

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

В Qt имеется три вида менеджеров компоновки: QHBoxLayout, QVBoxLayout и QGridLayout. Это классы-потомки от QLayout, который реализует основные методы управления размещением. Все три класса полностью поддерживаются Qt Designer-ом, а так же могут использоваться при написании кода вручную. Оба варианта использования были рассмотрены в Главе 2.

Ниже приводится конструктор FindFileDialog, в котором используются менеджеры размещения:

FindFileDialog::FindFileDialog(QWidget *parent, const char *name) 
     : QDialog(parent, name) 
 {
   ...
   QGridLayout *leftLayout = new QGridLayout; 
   leftLayout->addWidget(namedLabel, 0, 0); 
   leftLayout->addWidget(namedLineEdit, 0, 1); 
   leftLayout->addWidget(lookInLabel, 1, 0); 
   leftLayout->addWidget(lookInLineEdit, 1, 1); 
   leftLayout->addMultiCellWidget(subfoldersCheckBox, 2, 2, 0, 1); 
   leftLayout->addMultiCellWidget(listView, 3, 3, 0, 1); 
   leftLayout->addMultiCellWidget(messageLabel, 4, 4, 0, 1); 
   
   QVBoxLayout *rightLayout = new QVBoxLayout; 
   rightLayout->addWidget(findButton); 
   rightLayout->addWidget(stopButton); 
   rightLayout->addWidget(closeButton); 
   rightLayout->addStretch(1); 
   rightLayout->addWidget(helpButton); 
   
   QHBoxLayout *mainLayout = new QHBoxLayout(this); 
   mainLayout->setMargin(11); 
   mainLayout->setSpacing(6); 
   mainLayout->addLayout(leftLayout); 
   mainLayout->addLayout(rightLayout); 
 }
       
 
 

leftLayout->addMultiCellWidget(widget, row1, row2, col1, col2);      
       
 

Тот же самый диалог может быть создан с помощью визуального построителя Qt Designer. Пример работы с визуальным построителем, мы рассматривали в Главе 2.

Использование менеджеров размещения дает определенные преимущества, которые мы уже обсуждали ранее. Если в область компоновки добавляется виджет или удаляется из нее, менеджер автоматически адаптируется под изменившиеся условия. То же самое применимо и к случаю, когда вызываются методы подчиненного компонента -- hide() и show(). Если подчиненный виджет изменит "идеальный" размер, то раскладка изменится, с учетом изменившихся обстоятельств. Кроме того, менеджеры размещения автоматически установят минимальный размер формы в целом, основываясь на минимальных и "идеальных" размерах дочерних виджетов.

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

Политика изменения размеров сообщает менеджеру компоновки, как виджет должен растягиваться или сжиматься. Qt по-умолчанию дает неплохие значения политики изменения размеров для всех стандартных виджетов, но никакое значение по-умолчанию не может идеально подходить под все случаи жизни. Поэтому, до сих пор обычной практикой считается дополнительная настройка политик изменения размеров для одного-двух виджетов на форме. Политика изменения размеров назначается для каждого из двух направлений (по вертикали и по горизонтали). Наиболее часто используются значения Fixed, Minimum, Maximum, Preferred и Expanding:

• Fixed -- виджет имеет фиксированные размеры, т.е. он не может ни растягиваться, ни сжиматься. Он всегда должен иметь "идеальный" ( sizeHint() ) размер.

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

• Maximum -- "идеальный" размер виджета, это максимально возможный его размер, т.е. виджет может сжиматься до минимально возможного размера, но не может растягиваться больше "идеального".

• Preferred -- "идеальный" размер виджета, это предпочтительный его размер, но в случае необходимости виджет может как растягиваться, так и сжиматься.

• Expanding -- виджет может и растягиваться, и сжиматься, но он предпочитает растягиваться.

Существует еще две политики изменения размеров: MinimumExpanding и Ignored. Первая из них использовалась в ранних версиях Qt, хотя и довольно редко, в настоящее время не играет большой роли, поскольку лучший результат дает назначение политики Expanding и повторная реализация (перекрытие) метода minimumSizeHint(). Вторая -- во многом похожа на Expanding, но при этом игнорирует "идеальные" размеры виджета.

В дополнение к политикам изменения размера, горизонтальная и вертикальная составляющие визуального компонента, QSizePolicy хранят факторы растяжения. Они используются для задания степени растяжимости. Например, предположим, что на форме находятся QListView, а под ним -- QTextEdit. Нам необходимо, чтобы при растягивании формы QTextEdit рос в два раза быстрее, чем QListView. Для этого, фактор растягивания по вертикали (verticalStretch) компонента QTextEdit устанавливаем равным 2, а QListView -- 1.

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

6.2. Разделители.

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

Разделители в Qt реализованы в виде класса QSplitter. Подчиненные виджеты автоматически размещаются друг за дружкой, в порядке их создания, в смежных областях, разделителя. Ниже приводится код, который создает окно, изображенное на рисунке 6.5.

#include <qapplication.h> 
 #include <qsplitter.h> 
 #include <qtextedit.h> 
 
 int main(int argc, char *argv[]) 
 { 
   QApplication app(argc, argv); 
   
   QSplitter splitter(Qt::Horizontal); 
   splitter.setCaption(QObject::tr("Splitter")); 
   app.setMainWidget(&splitter); 
   
   QTextEdit *firstEditor = new QTextEdit(&splitter); 
   QTextEdit *secondEditor = new QTextEdit(&splitter); 
   QTextEdit *thirdEditor = new QTextEdit(&splitter); 
   
   splitter.show(); 
   return app.exec(); 
 }
       
 
 

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

Ниже приводится код конструктора подкласса QMainWindow:

MailClient::MailClient(QWidget *parent, const char *name) 
     : QMainWindow(parent, name) 
 { 
   horizontalSplitter = new QSplitter(Horizontal, this); 
   setCentralWidget(horizontalSplitter); 
   
   foldersListView = new QListView(horizontalSplitter); 
   foldersListView->addColumn(tr("Folders"));
   foldersListView->setResizeMode(QListView::AllColumns);
   
   verticalSplitter = new QSplitter(Vertical, horizontalSplitter); 
   messagesListView = new QListView(verticalSplitter); 
   messagesListView->addColumn(tr("Subject")); 
   messagesListView->addColumn(tr("Sender")); 
   messagesListView->addColumn(tr("Date")); 
   messagesListView->setAllColumnsShowFocus(true); 
   messagesListView->setShowSortIndicator(true); 
   messagesListView->setResizeMode(QListView::AllColumns); 
   
   textEdit = new QTextEdit(verticalSplitter); 
   textEdit->setReadOnly(true); 
   
   horizontalSplitter->setResizeMode(foldersListView, 
                                     QSplitter::KeepSize); 
   verticalSplitter->setResizeMode(messagesListView, 
                                   QSplitter::KeepSize); 
   ...
   readSettings(); 
 }
       
 
 

На запуске приложения, QSplitter устанавливает размеры подчиненных виджетов, основываясь на их начальных размерах. Передвинуть разделитель можно не только вручную, но и программно, вызвав QSplitter::setSizes(). Кроме того, QSplitter предоставляет возможность сохранить свое положение, при завершении работы приложения, и восстановить его на следующем запуске. Ниже приводится функция, которая сохраняет настройки приложения - почтового клиента:

void MailClient::writeSettings() 
 { 
   QSettings settings; 
   settings.setPath("software-inc.com", "MailClient"); 
   settings.beginGroup("/MailClient"); 
   
   QString str; 
   QTextOStream out1(&str); 
   
   out1 << *horizontalSplitter; 
   settings.writeEntry("/horizontalSplitter", str); 
   QTextOStream out2(&str); 
   out2 << *verticalSplitter; 
   settings.writeEntry("/verticalSplitter", str); 
   
   settings.endGroup(); 
 }
       
 
 

void MailClient::readSettings() 
 { 
   QSettings settings; 
   settings.setPath("software-inc.com", "MailClient"); 
   settings.beginGroup("/MailClient"); 
   
   QString str1 = settings.readEntry("/horizontalSplitter"); 
   QTextIStream in1(&str1); 
   in1 >> *horizontalSplitter; 
   QString str2 = settings.readEntry("/verticalSplitter"); 
   QTextIStream in2(&str2); 
   in2 >> *verticalSplitter; 
   
   settings.endGroup(); 
 }
       
 

По-умолчанию, во время перетаскивания, разделитель отображается в виде рамки. А размеры виджетов, с обеих сторон разделителя, изменяют размер только тогда, когда пользователь отпустит кнопку мыши. Чтобы изменения размеров происходили в реальном времени, необходимо вызвать setOpaqueResize(true).

Разделители QSplitter полностью поддерживаются визуальным построителем Qt Designer. Чтобы поместить виджеты в разделитель -- разместите подчиненные виджеты на форме примерно так, как вы желаете, затем выделите их и выберите пункт меню Layout|Lay Out Horizontally (in Splitter) или Layout|Lay Out Vertically (in Splitter).

6.3. Многостраничные виджеты.

Еще один виджет, которые может оказаться полезным, в смысле компоновки -- это QWidgetStack. Он может содержать наборы виджетов, объединяемых в "страницы", и всегда показывает только одну страницу, скрывая остальные. Нумерация страниц начинается с 0. Чтобы сделать определенный подчиненный виджет-страницу видимым, необходимо вызвать функцию raiseWidget(), передав ей либо номер страницы, либо указатель на подчиненный виджет.

1. Создается новая форма из шаблона "Dialog" или "Widget".

2. На форму добавляются QListBox и QWidgetStack.

3. Каждая страница QWidgetStack заполняется необходимыми виджетами. (Чтобы создать новую страницу -- щелкните правой кнопкой мыши и выберите из контекстного меню пункт Add Page. Чтобы перейти к другой странице -- щелкните мышкой по одной из кнопок, расположенных в правом верхнем углу.)

4. Объедините QListBox и QWidgetStack менеджером горизонтального размещения.

5. Соедините сигнал highlighted(int), от QListBox, со слотом raiseWidget(int), компонента QWidgetStack.

6. Установите свойство currentItem (QListBox) равным 0.

6.4. Области просмотра с прокруткой.

Класс QScrollView представляет собой область просмотра с двумя полосами прокрутки и "угловым" компонентом, находящимся в правом нижнем углу (обычно -- пустой QWidget). Если необходимо добавить полосы прокрутки к своему виджету, то намного проще воспользоваться готовым QScrollView, чем добавлять компоненты QScrollBar к своему виджету и писать код, реализующий их функциональность.

#include <qapplication.h> 
 
 #include <qscrollview.h> 
 
 #include "iconeditor.h" 
 
 int main(int argc, char *argv[]) 
 {
   QApplication app(argc, argv); 
   
   QScrollView scrollView; 
   scrollView.setCaption(QObject::tr("Icon Editor")); 
   app.setMainWidget(&scrollView); 
   
   IconEditor *iconEditor = new IconEditor; 
   scrollView.addChild(iconEditor); 
   
   scrollView.show(); 
   return app.exec(); 
 }
       
 

scrollView.setHScrollBarMode(QScrollView::AlwaysOn); 
 scrollView.setVScrollBarMode(QScrollView::AlwaysOn);      
       
 

Чтобы продемонстрировать это на примере, попробуем написать новую версию класса IconEditor, породив его от QScrollView. Назовем новый класс ImageEditor, поскольку полосы прокрутки дают нам возможность работать с изображениями большого размера.

#ifndef IMAGEEDITOR_H 
 #define IMAGEEDITOR_H 
 
 #include <qimage.h> 
 #include <qscrollview.h>
 
 class ImageEditor : public QScrollView 
 { 
   Q_OBJECT 
   Q_PROPERTY(QColor penColor READ penColor WRITE setPenColor) 
   Q_PROPERTY(QImage image READ image WRITE setImage) 
   Q_PROPERTY(int zoomFactor READ zoomFactor WRITE setZoomFactor) 
   
 public: 
   ImageEditor(QWidget *parent = 0, const char *name = 0); 
   
   void setPenColor(const QColor &newColor); 
   QColor penColor() const { return curColor; } 
   void setZoomFactor(int newZoom); 
   int zoomFactor() const { return zoom; } 
   void setImage(const QImage &newImage); const 
   QImage &image() const { return curImage; } 
   
 protected: 
   void contentsMousePressEvent(QMouseEvent *event); 
   void contentsMouseMoveEvent(QMouseEvent *event); 
   void drawContents(QPainter *painter, int x, int y, int width, int height); 
   
 private: 
   void drawImagePixel(QPainter *painter, int i, int j); 
   void setImagePixel(const QPoint &pos, bool opaque); 
   void resizeContents(); 
   QColor curColor; 
   QImage curImage; int zoom; 
 }; 
 
 #endif
       
 

ImageEditor::ImageEditor(QWidget *parent, const char *name) 
     : QScrollView(parent, name, WStaticContents | WNoAutoErase) 
 { 
   curColor = black; 
   zoom = 8; 
   curImage.create(16, 16, 32); 
   curImage.fill(qRgba(0, 0, 0, 0)); 
   curImage.setAlphaBuffer(true); 
   resizeContents(); 
 }
       
 

void ImageEditor::resizeContents() 
 { 
   QSize size = zoom * curImage.size(); 
   if (zoom >= 3) 
     size += QSize(1, 1); 
   QScrollView::resizeContents(size.width(), size.height()); 
 }
       
 

Нам нет необходимости перекрывать функцию sizeHint(). Компонент QScrollView автоматически вычисляет "идеальный" размер, отталкиваясь от размера содержимого области просмотра.

void ImageEditor::setImage(const QImage &newImage) 
 { 
   if (newImage != curImage) { 
     curImage = newImage.convertDepth(32); 
     curImage.detach(); 
     resizeContents(); 
     updateContents(); 
   } 
 }
       
 

void ImageEditor::drawContents(QPainter *painter, int, int, int, int) 
 { 
   if (zoom >= 3) { 
     painter->setPen(colorGroup().foreground()); 
     for (int i = 0; i <= curImage.width(); ++i) 
       painter->drawLine(zoom * i, 0, 
                         zoom * i, zoom * curImage.height()); 
     for (int j = 0; j <= curImage.height(); ++j) 
       painter->drawLine(0, zoom * j, 
                         zoom * curImage.width(), zoom * j); 
   } 
   
   for (int i = 0; i < curImage.width(); ++i) { 
     for (int j = 0; j < curImage.height(); ++j) 
       drawImagePixel(painter, i, j); 
   } 
 }
       
 
 

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

Функция drawImagePixel(), обращение к которой стоит в конце drawContents(), осталась без изменений (см. оригинальную версию), поэтому здесь мы ее рассматривать не будем.

void ImageEditor::contentsMousePressEvent(QMouseEvent *event) 
 { 
   if (event->button() == LeftButton) 
     setImagePixel(event->pos(), true); 
   else if (event->button() == RightButton) 
     setImagePixel(event->pos(), false); 
 } 
 
 void ImageEditor::contentsMouseMoveEvent(QMouseEvent *event) 
 { 
   if (event->state() & LeftButton) 
     setImagePixel(event->pos(), true); 
   else if (event->state() & RightButton) 
     setImagePixel(event->pos(), false); 
 }
       
 
 

void ImageEditor::setImagePixel(const QPoint &pos, bool opaque) 
 { 
   int i = pos.x() / zoom; 
   int j = pos.y() / zoom; 
   
   if (curImage.rect().contains(i, j)) { 
     if (opaque) 
       curImage.setPixel(i, j, penColor().rgb()); 
     else curImage.setPixel(i, j, qRgba(0, 0, 0, 0)); 
     
     QPainter painter(viewport()); 
     painter.translate(-contentsX(), -contentsY()); 
     drawImagePixel(&painter, i, j); 
   } 
 }
       
 

Последние три строки, которые работают с QPainter, можно было бы заменить одной строкой:

updateContents(i * zoom, j * zoom, zoom, zoom);      
       
 

Если теперь мы попробуем поработать с ImageEditor, то мы практически не заметим разницы с оригинальным IconEditor, вставленным в QScrollView. Однако, другие виджеты, порожденные от QScrollView, используют дополнительные преимущества родительского класса. Например, QTextEdit выполняет перенос текста по словам.

Обратите внимание: вам наверняка придется использовать класс QScrollView, в качестве предка, если размеры отображаемого содержимого очень велики, поскольку некоторые оконные подсистемы не в состоянии отобразить виджеты, размеры которых превышают величину 32767 пикселей.

Еще один важный момент, которого мы не коснулись здесь: мы можем вставлять подчиненные виджеты в область просмотра, вызовом функции addWidget(), и перемещать вызовом moveWidget(). Всякий раз, когда пользователь перемещается по области просмотра, с помощью полос прокрутки, QScrollView автоматически перемещает подчиненные виджеты на экране. (Если подчиненных виджетов слишком много, то прокрутка может существенно замедляться. Чтобы оптимизировать этот процесс, можно вызвать enableClipper(true).) В качестве примера, использующего подобный подход, можно привести web-браузер, в котором большая часть содержимого может отрисовываться непосредственно в области просмотра, но кнопки и поля ввода на формах должны быть представлены в виде виджетов.

6.5. Стыкуемые окна.

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

Объекты класса QMainWindow предоставляют в распоряжение программиста четыре области стыковки: вверху, внизу, слева и справа от центрального виджета. Когда создаются экземпляры класса QToolBar, они автоматически пристыковываются к верхней области окна-владельца.

dockWindow->setCloseMode(QDockWindow::Undocked);      
       
 
 

  QToolBar *toolBar = new QToolBar(tr("Font"), this); 
   QComboBox *fontComboBox = new QComboBox(true, toolBar);      
 
   QSpinBox *fontSize = new QSpinBox(toolBar); 
   boldAct->addTo(toolBar); 
   italicAct->addTo(toolBar); 
   underlineAct->addTo(toolBar); 
   moveDockWindow(toolBar, DockBottom);
       
 
 

  setDockEnabled(toolBar, DockLeft, false); 
   setDockEnabled(toolBar, DockRight, false);      
       
 

Если виджет должен изменять свой вид, в зависимости от того, к какой из областей стыковки он присоединен, то для этого необходимо перекрыть метод QDockWindow:: setOrientation() и выполять все необходимые действия в нем.

Если необходимо сохранять положение всех панелей инструментов и других стыкуемых окон, чтобы потом, на следующем запуске приложения восстанавливать его, можно написать код, который очень похож на тот, который мы разбирали ранее, используя оператор "<<" класса QMainWindow, для записи в файл, и ">>" -- для восстановления из файла.

Приложения, подобные Microsoft Visual Studio и Qt Designer очень широко используют стыкуемые окна, чтобы сделать интерфейс с пользователем более гибким.

6.6. Многодокументный интерфейс.

Приложения, которые могут работать с несколькими документами, открываемыми в отдельных окнах и расположенных внутри главного окна, называют MDI-приложениями (MDI -- от англ. Multiple Document Interface). В Qt подобный интерфейс создается с помощью класса QWorkspace, назначаемого центральным виджетом. Каждое окно с открытым документом становится подчиненным, по отношению к QWorkspace.

В этом разделе мы создадим приложение Editor (текстовый редактор), изображенное на рисунке 6.14, чтобы продемонстрировать принципы создания MDI-приложений и оконных меню.

MainWindow::MainWindow(QWidget *parent, const char *name) 
     : QMainWindow(parent, name) 
 { 
   workspace = new QWorkspace(this); 
   setCentralWidget(workspace); 
   connect(workspace, SIGNAL(windowActivated(QWidget *)), 
           this, SLOT(updateMenus())); 
   connect(workspace, SIGNAL(windowActivated(QWidget *)), 
           this, SLOT(updateModIndicator())); 
   createActions(); 
   createMenus(); 
   createToolBars();
   createStatusBar(); 
   
   setCaption(tr("Editor")); 
   setIcon(QPixmap::fromMimeSource("icon.png")); 
 }
       
 
 

void MainWindow::newFile() 
 { 
   Editor *editor = createEditor(); 
   editor->newFile(); 
   editor->show(); 
 }
       
 

Editor *MainWindow::createEditor() 
 { 
   Editor *editor = new Editor(workspace); 
   connect(editor, SIGNAL(copyAvailable(bool)), 
           this, SLOT(copyAvailable(bool))); 
   connect(editor, SIGNAL(modificationChanged(bool)), 
           this, SLOT(updateModIndicator())); 
   return editor; 
 }
       
 
 

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

void MainWindow::open() 
 { 
   Editor *editor = createEditor(); 
   if (editor->open()) 
     editor->show(); 
   else 
     editor->close(); 
 }
       
 

void MainWindow::save() 
 { 
   if (activeEditor()) { 
     activeEditor()->save(); 
     updateModIndicator(); 
   } 
 }
       
 

Editor *MainWindow::activeEditor() 
 { 
   return (Editor *)workspace->activeWindow(); 
 }
       
 
 

void MainWindow::cut() 
 { 
   if (activeEditor()) 
     activeEditor()->cut(); 
 }
       
 

void MainWindow::updateMenus() 
 { 
   bool hasEditor = (activeEditor() != 0); 
   saveAct->setEnabled(hasEditor); 
   saveAsAct->setEnabled(hasEditor); 
   pasteAct->setEnabled(hasEditor); 
   deleteAct->setEnabled(hasEditor); 
   copyAvailable(activeEditor() 
                 && activeEditor()->hasSelectedText()); 
   closeAct->setEnabled(hasEditor); 
   closeAllAct->setEnabled(hasEditor); 
   tileAct->setEnabled(hasEditor); 
   cascadeAct->setEnabled(hasEditor); 
   nextAct->setEnabled(hasEditor); 
   previousAct->setEnabled(hasEditor); 
   
   windowsMenu->clear(); 
   createWindowsMenu(); 
 }
       
 
 

void MainWindow::createWindowsMenu() 
 { 
   closeAct->addTo(windowsMenu); 
   closeAllAct->addTo(windowsMenu); 
   windowsMenu->insertSeparator(); 
   tileAct->addTo(windowsMenu); 
   cascadeAct->addTo(windowsMenu); 
   windowsMenu->insertSeparator(); 
   nextAct->addTo(windowsMenu); 
   previousAct->addTo(windowsMenu); 
   
   if (activeEditor()) { 
     windowsMenu->insertSeparator(); 
     windows = workspace->windowList(); 
     int numVisibleEditors = 0; 
     
     for (int i = 0; i < (int)windows.count(); ++i) { 
       QWidget *win = windows.at(i); 
       if (!win->isHidden()) { 
         QString text = tr("%1 %2") 
                        .arg(numVisibleEditors + 1) 
                        .arg(win->caption()); 
         if (numVisibleEditors < 9) 
           text.prepend("&"); 
         int id = windowsMenu->insertItem( 
                       text, this, SLOT(activateWindow(int))); 
         bool isActive = (activeEditor() == win); 
         windowsMenu->setItemChecked(id, isActive); 
         windowsMenu->setItemParameter(id, i); 
         ++numVisibleEditors; 
       } 
     } 
   } 
 }
       
 
 

Активное окно, в списке, отмечается маркером, напротив имени документа. Когда пользователь выбирает пункт меню, соответствующий открытому документу, вызывается слот activateWindow(), которому в качестве аргумента передается индекс в массиве windows. Это очень похоже на то, что мы делали в Главе 3, когда создавали список недавно открывавшихся документов.

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

void MainWindow::activateWindow(int param) 
 { 
   QWidget *win = windows.at(param); 
   win->show(); 
   win->setFocus(); 
 }
       
 
 

void MainWindow::copyAvailable(bool available) 
 { 
   cutAct->setEnabled(available); 
   copyAct->setEnabled(available); 
 }
       
 

void MainWindow::updateModIndicator() 
 { 
   if (activeEditor() && activeEditor()->isModified()) 
     modLabel->setText(tr("MOD")); 
   else 
     modLabel->clear(); 
 }
       
 
 

void MainWindow::closeEvent(QCloseEvent *event) 
 { 
   workspace->closeAllWindows(); 
   if (activeEditor()) 
     event->ignore(); 
   else 
     event->accept(); 
 }
       
 

На этом мы завершаем обзор класса MainWindow и переходим к реализации класса Editor. Этот класс представляет собой одно дочернее окно. Он порожден от класса QTextEdit, который реализует всю необходимую функциональность по редактированию текста. Так же, как и любой другой виджет Qt, QTextEdit может использоваться как дочернее окно в рабочей области MDI.

Ниже приводится определение класса:

class Editor : public QTextEdit 
 { 
   Q_OBJECT 
   
 public: 
   Editor(QWidget *parent = 0, const char *name = 0); 
   
   void newFile(); 
   bool open(); 
   bool openFile(const QString &fileName); 
   bool save(); 
   bool saveAs(); 
   QSize sizeHint() const; 
   
 signals: 
   void message(const QString &fileName, int delay); 
   
 protected: 
   void closeEvent(QCloseEvent *event); 
   
 private: 
   bool maybeSave(); 
   void saveFile(const QString &fileName); 
   void setCurrentFile(const QString &fileName); 
   QString strippedName(const QString &fullFileName); 
   bool readFile(const QString &fileName); 
   bool writeFile(const QString &fileName); 
   
   QString curFile; 
   bool isUntitled; 
   QString fileFilters; 
 };
       
 

Editor::Editor(QWidget *parent, const char *name) 
     : QTextEdit(parent, name) 
 { 
   setWFlags(WDestructiveClose); 
   setIcon(QPixmap::fromMimeSource("document.png")); 
   
   isUntitled = true; 
   fileFilters = tr("Text files (*.txt)\n" 
                 "All files (*)"); 
 }
       
 

Так как мы позволяем пользователям одновременно открывать несколько документов, необходимо предусмотреть какие либо характеристики окон, чтобы потом пользователи могли как-то их отличать между собой, до того, как вновь создаваемые документы будут сохранены. Самый распространенный способ -- присваивать документам имена по-умолчанию, которые включают в себя порядковый номер (например, document1.txt). Для этой цели мы используем переменную isUntitled, которая отличает имена документов, уже существующих, и имена документов, которым имя еще не было присвоено пользователем.

После вызова конструктора должна вызываться одна из двух функций -- либо newFile(), либо open().

void Editor::newFile() 
 { 
   static int documentNumber = 1; 
   
   curFile = tr("document%1.txt").arg(documentNumber); 
   setCaption(curFile); 
   isUntitled = true; 
   ++documentNumber; 
 }
       
 

bool Editor::open() 
 { 
   QString fileName = 
           QFileDialog::getOpenFileName(".", fileFilters, this); 
   if (fileName.isEmpty()) 
     return false; 
     
   return openFile(fileName); 
 }
       
 
 

bool Editor::save() 
 { 
   if (isUntitled) { 
     return saveAs(); 
   } else { 
     saveFile(curFile); 
     return true; } 
 }
       
 

void Editor::closeEvent(QCloseEvent *event) 
 { 
   if (maybeSave()) 
     event->accept(); 
   else 
     event->ignore(); 
 }
       
 
 

void Editor::setCurrentFile(const QString &fileName) 
 { 
   curFile = fileName; 
   setCaption(strippedName(curFile)); 
   isUntitled = false; 
   setModified(false); 
 }
       
 

QSize Editor::sizeHint() const 
 { 
   return QSize(72 * fontMetrics().width( x ), 
                25 * fontMetrics().lineSpacing()); 
 }
       
 
 

И в заключение приведем исходный текст файла main.cpp:

#include <qapplication.h> 
 
 #include "mainwindow.h" 
 
 int main(int argc, char *argv[]) 
 { 
   QApplication app(argc, argv); 
   MainWindow mainWin; 
   app.setMainWidget(&mainWin); 
   if (argc > 1) { 
     for (int i = 1; i < argc; ++i) 
       mainWin.openFile(argv[i]); 
     } else { 
       mainWin.newFile(); 
     } 
     
     mainWin.show(); 
     return app.exec(); 
 }
       
 

editor -style=motif readme.txt      
       
 
 

Многодокументный интерфейс -- один из способов одновременной работы с несколькими документами. Другой способ состоит в том, чтобы использовать несколько окон верхнего уровня. Он был описан в разделе Работа с несколькими документами одновременно Главы 3.

7.1. Обработчики событий.

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

Не надо путать события с сигналами. Сигналы необходимы для организации взаимодействий между виджетами, тогда как события необходимы для организации взаимодействия между виджетом и системой. Например, когда мы используем QPushButton, нас больше интересует сигнал clicked(), нежели события от мыши или клавиатуры, которые стали причиной появления сигнала. Но если мы разрабатываем новый класс, на подобие QPushButton, то нам придется писать код, который будет обрабатывать события от мыши и клавиатуры, и выдавать сигнал clicked() по мере необходимости.

События поступают к объектам в функцию event(), унаследованную от QObject. Реализация функции event() в QWidget передает наиболее употребимые типы событий специализированным обработчикам, таким как mousePressEvent(), keyPressEvent() и paintEvent(), остальные события игнорируются.

В предыдущих главах мы уже сталкивались с обработкой событий, при создании классов MainWindow, IconEditor, Plotter, ImageEditor и Editor. Полный список типов событий вы найдете в сопроводительной документации к классу QEvent. Кроме того, за программистом сохраняется возможность создания и диспетчеризации своих собственных типов событий. Нестандартные типы событий широко применяются в многопоточных приложениях, но это тема отдельной главы. В этой главе мы рассмотрим два типа событий: события от клавиатуры и события от таймера.

События от клавиатуры обрабатываются функциями keyPressEvent() и keyReleaseEvent(). В примере с виджетом Plotter, мы перекрывали родительский обработчик keyPressEvent(). Обычно программиста интересует только keyPressEvent(), поскольку к моменту нажатия интересующей его клавиши уже нажаты клавиши-модификаторы, а к моменту отпускания нужной клавиши, клавиши-модификаторы могут быть уже отжаты. К клавишам-модификаторам относятся: Ctrl, Shift и Alt. Состояние этих клавиш может быть получено вызовом функции state(). Например, представим, что нам необходимо написать виджет CodeEditor и реализовать обработчик событий от клавиатуры, который различал бы комбинации клавиш Home и Ctrl+Home, в этом случае мы могли бы написать следующий код:

void CodeEditor::keyPressEvent(QKeyEvent *event) 
 { 
   switch (event->key()) { 
     case Key_Home: 
         if (event->state() & ControlButton) 
           goToBeginningOfDocument(); 
         else 
           goToBeginningOfLine(); 
         break; 
     case Key_End:  
         ...
     default: 
       QWidget::keyPressEvent(event); 
   } 
 }
       
 

bool CodeEditor::event(QEvent *event) 
 { 
   if (event->type() == QEvent::KeyPress) { 
     QKeyEvent *keyEvent = (QKeyEvent *)event; 
     if (keyEvent->key() == Key_Tab) { 
       insertAtCurrentPosition( \t ); 
       return true; 
     } 
   }
   return QWidget::event(event); 
 }
       
 

Использование объектов QAction дает более высокий уровень обслуживания событий. Например, если предположить, что CodeEditor имеет два публичных слота goToBeginningOfLine() и goToBeginningOfDocument() и CodeEditor назначен центральным виджетом для класса MainWindow, то можно было бы обслуживать комбинации клавиш следующим образом:

MainWindow::MainWindow(QWidget *parent, const char *name) 
     : QMainWindow(parent, name) 
 { 
   editor = new CodeEditor(this); 
   setCentralWidget(editor); 
   
   goToBeginningOfLineAct = new QAction(tr("Go to Beginning of Line"), 
                                           tr("Home"), this); 
   connect(goToBeginningOfLineAct, SIGNAL(activated()), 
           editor, SLOT(goToBeginningOfLine())); 
   goToBeginningOfDocumentAct = new QAction(tr("Go to Beginning of Document"), 
                                               tr("Ctrl+Home"), this); 
   connect(goToBeginningOfDocumentAct, SIGNAL(activated()), 
           editor, SLOT(goToBeginningOfDocument()));
   ...
 }
       
 

Разница между этими двумя подходами (перекрытие метода keyPressEvent() и использование QAction или QAccel) очень похожа на разницу между перекрытием метода resizeEvent() и использованием дочерних классов от QLayout. Если вы создаете свой виджет, порождая его от QWidget, то скорее всего вам подойдет первый вариант, связанный с написанием нескольких своих обработчиков, с жестко зашитым поведением. Но если вы предполагаете использовать уже готовый виджет, то более удобен высокоуровневый подход, связанный с использованием QAction.

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

С целью демонстрации обслуживания событий от таймера, создадим виджет Ticker. Он будет выводить строку текста и прокручивать ее справа-налево на один пиксель каждые 30 миллисекунд. Если ширина виджета больше ширины текста, то заданный текст будет нарисован столько раз, сколько уместится на виджете.

#ifndef TICKER_H 
 #define TICKER_H 
 
 #include <qwidget.h> 
 
 class Ticker : public QWidget 
 { 
   Q_OBJECT 
   Q_PROPERTY(QString text READ text WRITE setText) 
   
 public: 
   Ticker(QWidget *parent = 0, const char *name = 0); 
   
   void setText(const QString &newText); 
   QString text() const { return myText; } 
   QSize sizeHint() const; 
   
 protected: 
   void paintEvent(QPaintEvent *event); 
   void timerEvent(QTimerEvent *event); 
   void showEvent(QShowEvent *event); 
   void hideEvent(QHideEvent *event); 
   
 private: 
   QString myText; 
   int offset; 
   int myTimerId; 
 }; 
 
 #endif      
       
 

Перейдем к файлу с реализацией:

#include <qpainter.h> 
 
 #include "ticker.h" 
 
 Ticker::Ticker(QWidget *parent, const char *name) 
     : QWidget(parent, name) 
 { 
   offset = 0; 
   myTimerId = 0; 
 }
       
 

void Ticker::setText(const QString &newText) 
 { 
   myText = newText; 
   update(); 
   updateGeometry(); 
 }
       
 
 

QSize Ticker::sizeHint() const 
 { 
   return fontMetrics().size(0, text()); 
 }
       
 

void Ticker::paintEvent(QPaintEvent *) 
 { 
   QPainter painter(this); 
   
   int textWidth = fontMetrics().width(text()); 
   if (textWidth < 1) 
     return; 
   int x = -offset; 
   while (x < width()) { 
     painter.drawText(x, 0, textWidth, height(), 
                      AlignLeft | AlignVCenter, text()); 
     x += textWidth; 
   } 
 }
       
 
 

void Ticker::showEvent(QShowEvent *) 
 { 
   myTimerId = startTimer(30);
 }
       
 

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

void Ticker::timerEvent(QTimerEvent *event) 
 { 
   if (event->timerId() == myTimerId) { 
     ++offset; 
     if (offset >= fontMetrics().width(text())) 
       offset = 0; 
     scroll(-1, 0); 
   } else { 
     QWidget::timerEvent(event); 
   } 
 }
       
 

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

void Ticker::hideEvent(QHideEvent *) 
 { 
   killTimer(myTimerId); 
 }
       
 

Если необходимо создать несколько таймеров, то обработка событий от них может стать слишком громоздкой. В таких ситуациях проще создавать объекты класса QTimer для каждого таймера. QTimer выдает сигнал timeout() по истечении каждого интервала времени, кроме того, он предоставляет возможность создания таймеров-будильников, которые срабатывают один раз.

7.2. Установка фильтров событий.

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

Предположим, что у нас имеется виджет CustomerInfoDialog, собранный из нескольких QLineEdit, и нам необходимо передавать фокус ввода, от одного к другому, нажатием на клавишу "пробел". Решение "в лоб" -- создать дочерний класс от QLineEdit и перекрыть обработчик события keyPressEvent(), в котором вызывать focusNextPrevChild(), примерно так:

void MyLineEdit::keyPressEvent(QKeyEvent *event) 
 { 
   if (event->key() == Key_Space) 
     focusNextPrevChild(true); 
   else 
     QLineEdit::keyPressEvent(event); 
 }
       
 
 

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

1. Регистрация фильтра событий, вызовом функции installEventFilter() того объекта, которому предназначены события.

2. Создание обработчика перехваченных событий eventFilter().

CustomerInfoDialog::CustomerInfoDialog(QWidget *parent, 
                                        const char *name) 
     : QDialog(parent, name) 
 { 
   ...
   firstNameEdit->installEventFilter(this); 
   lastNameEdit->installEventFilter(this); 
   cityEdit->installEventFilter(this); 
   phoneNumberEdit->installEventFilter(this); 
 }
       
 

Ниже приводится исходный код функции eventFilter():

bool CustomerInfoDialog::eventFilter(QObject *target, QEvent *event) 
 { 
   if (target == firstNameEdit || target == lastNameEdit 
           || target == cityEdit || target == phoneNumberEdit) { 
     if (event->type() == QEvent::KeyPress) { 
       QKeyEvent *keyEvent = (QKeyEvent *)event; 
       if (keyEvent->key() == Key_Space) { 
         focusNextPrevChild(true); 
         return true; 
       } 
     } 
   } 
   return QDialog::eventFilter(target, event); 
 }
       
 

Если событие пришло от клавиатуры, то выполняется приведение к типу QKeyEvent и проверяется -- какая клавиша нажата. Если нажата клавиша "пробел", то вызывается функция focusNextPrevChild(), которая передает фокус вводв следующему виджету и возвращается результат true, сообщая Qt о том, что событие обработано. Если вернуть false, то Qt передаст событие объекту назначения.

Если событие порождено не клавишей "пробел", то управление передается функции eventFilter() базового класса.

В Qt предусмотрены пять уровней, на которых событие может быть перехвачено и обработано:

1. Обработка событий в функциях-обработчиках

   Перекрытие обработчиков событий, таких как: mousePressEvent(), keyPressEvent() и paintEvent(), безусловно самый распространенный способ. Мы уже видели множество примеров тому.

2. Перекрытие метода QObject::event().

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

3. Установка фильтра событий для QObject.

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

4. Установка фильтра событий объекта QApplication.

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

5. Создание дочернего класса от QApplication и перекрытие метода notify().

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

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

7.3. Сокращение времени отклика при длительной обработке данных.

С вызова функции QApplication::exec() начинается главный цикл обработки событий. Сначала Qt запускает несколько событий, чтобы отобразить и перерисовать виджеты. После этого в цикле постоянно выполняется проверка поступления новых событий и их передача виджетам приложения.

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

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

Более простое решение -- вызывать QApplication::processEvents() как можно чаще, во время длительных операций. Эта функция выполняет обработку событий, ожидающих в очереди, и затем возвращает управление в вызвавшую функцию. Фактически, QApplication::exec() -- это не более чем цикл while, в котором вызывается функция processEvents().

Ниже приводится пример того, как можно сократить время отклика приложения Spreadsheet, во время сохранения большого файла на диск (см. оригинальную версию):

bool Spreadsheet::writeFile(const QString &fileName) 
 { 
   QFile file(fileName); 
   ... 
   for (int row = 0; row < NumRows; ++row) { 
     for (int col = 0; col < NumCols; ++col) { 
       QString str = formula(row, col); 
       if (!str.isEmpty()) 
         out << (Q_UINT16)row << (Q_UINT16)col << str; 
     } 
     qApp->processEvents(); 
   } 
   return true; 
 }
       
 
 

qApp->processEvents();      
       
 

qApp->eventLoop()->processEvents(QEventLoop::ExcludeUserInput);      
       
 

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

bool Spreadsheet::writeFile(const QString &fileName) 
 { 
   QFile file(fileName); 
   ... 
   QProgressDialog progress(tr("Saving file..."), tr("Cancel"), 
                            NumRows); 
   progress.setModal(true); 
   for (int row = 0; row < NumRows; ++row) { 
     progress.setProgress(row); 
     qApp->processEvents();      
     if (progress.wasCanceled()) { 
       file.remove(); 
       return false; 
     } 
     for (int col = 0; col < NumCols; ++col) { 
       QString str = formula(row, col); 
       if (!str.isEmpty()) 
         out << (Q_UINT16)row << (Q_UINT16)col << str; 
     } 
   } 
   return true; 
 }
       
 

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

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

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

void Spreadsheet::timerEvent(QTimerEvent *event) 
 { 
   if (event->timerId() == myTimerId) { 
     while (step < MaxStep && !qApp->hasPendingEvents()) { 
       performStep(step); 
       ++step; 
     } 
   } else { 
     QTable::timerEvent(event); 
   } 
 }
       
 

8.1. Рисование средствами QPainter.

Класс QPainter используется для создания изображений на "графических устройствах", таких как виджеты или карты пикселей (pixmap). Чаще всего он используется при создании нестандартных виджетов, для придания им уникального, ни на что не похожего, внешнего вида. Однако этот класс может использоваться и для вывода графики на принтер, более подробно мы коснемся этого вопроса немного ниже.

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

Когда конструктору QPainter передается устройство для рисования, он получает часть настроек от заданного устройства, оставшиеся параметры настройки заполняет значениями по-умолчанию. Эти настройки определяют способ рисования. Тремя наиболее важными характеристиками QPainter являются перо (pen), кисть (brush) и шрифт (font).

• Перо используется для рисования линий и границ геометрических фигур. Оно характеризуется такими параметрами, как: цвет, толщина, стиль рисования линий, стиль оформления концов линий и стиль оформления углов.

  <"images/qt3_files/fig8_013.png">

  Рисунок 8.1. Методы класса QPainter, для рисования геометрических фигур.

  
  

  <"images/qt3_files/fig8_015.png">

  Рисунок 8.2. Стили пера.

  
  
  
  

• Кисть -- это шаблон, которым заполняются геометрические фигуры. Кисти характеризуются цветом и стилем.

• Шрифт используется для рисования текста. Шрифт может иметь огромное количество атрибутов, среди них: название и размер.

  QPainter painter(this); 
   painter.setPen(QPen(black, 3, DashDotLine)); 
   painter.setBrush(QBrush(red, SolidPattern)); 
   painter.drawEllipse(20, 20, 100, 60);      
       
 

  QPainter painter(this); 
   painter.setPen(QPen(black, 5, SolidLine)); 
   painter.setBrush(QBrush(red, DiagCrossPattern)); 
   painter.drawPie(20, 20, 100, 60, 60 * 16, 270 * 16);
       
 
 

  QPainter painter(this); 
   QPointArray points(4); 
   points[0] = QPoint(20, 80); 
   points[1] = QPoint(50, 20); 
   points[2] = QPoint(80, 20); 
   points[3] = QPoint(120, 80); 
   painter.setPen(QPen(black, 3, SolidLine)); 
   painter.drawCubicBezier(points);      
       
 

Кроме перечисленных выше характеристик (перо, кисть и шрифт), QPainter имеет еще целый ряд параметров настройки:

• Цвет фона (background color), который используется для заливки геометрических фигур (под шаблоном, наносимым кистью), текста или рисунков, когда background mode имеет значение OpaqueMode (по-умолчанию: TransparentMode).

• Растровые операции (raster operation) определяют, как новое изображение должно накладываться на существующее. По-умолчанию: CopyROP, т.е. новое изображение (пиксели) просто копируется на устройство рисования, ранее находившееся там изображение игнорируется. В список растровых операций так же входят: XorROP, NotROP, AndROP и NotAndROP.

• Начальные координаты кисти (brush origin) задают начальную точку рисования шаблона кисти, обычно это левый верхний угол виджета.

• Врезка (clip region) определяет область устройства, на которой может производиться рисование. Операции рисования за пределами этой области -- игнорируются.

• Область просмотра (viewport), окно (window) и матрица преобразования (world matrix) определяют отношения между логической системой координат QPainter и системой координат физического устройства. Значения по-умолчанию принимаются таковыми, что эти две системы координат совпадают.

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

По-умолчанию координаты области просмотра и окна совпадают с системой координат физического устройства. Например, если устройство отображения представляет из себя виджет, с размерами 320 X 200, то и область просмотра и окно имеют те же самые размеры. В данном случае логическая и физическая системы координат совпадают.

Подобный механизм дает возможность писать код, который не зависит от размера или разрешения устройства. Конечно же, мы и сами можем выполнять отображение логических координат в физические, но проще доверить эту работу классу QPainter. Например, представим, что нам необходимо работать в системе координат, ограниченной прямоугольником от (-50, -50) до (+50, +50), когда точка с координатами (0, 0) находится в центре прямоугольника. В этом случае можно установить параетры окна следующим образом:

  painter.setWindow(QRect(-50, -50, 100, 100));      
       
 

  QWMatrix matrix; 
   matrix.rotate(45.0); 
   painter.setWorldMatrix(matrix); 
   painter.drawText(rect, AlignCenter, tr("Revenue"));
       
 

Если указывается несколько трансформаций, то они применяются в порядке следования в исходном коде программы. Например, допустим, что необходимо повернуть изображение относительно точки с координатами (10, 20). Для этого можно задать следующий порядок трансформаций: сдвинуть окно так, чтобы центр вращения переместился в координаты (0, 0), повернуть изображение и затем выполнить обратный сдвиг:

  QWMatrix matrix; 
   matrix.translate(-10.0, -20.0); 
   matrix.rotate(45.0); 
   matrix.translate(+10.0, +20.0); 
   painter.setWorldMatrix(matrix); 
   painter.drawText(rect, AlignCenter, tr("Revenue"));
       
 

  painter.translate(-10.0, -20.0); 
   painter.rotate(45.0); 
   painter.translate(+10.0, +20.0); 
   painter.drawText(rect, AlignCenter, tr("Revenue"));
       
 
 

При необходимости, матрицу преобразований можно сохранить вызовом saveWorldMatrix() и затем восстановить вызовом restoreWorldMatrix().

class OvenTimer : public QWidget 
 { 
   Q_OBJECT 
   
 public: 
   OvenTimer(QWidget *parent, const char *name = 0); 
   
   void setDuration(int secs);
   int duration() const; 
   void draw(QPainter *painter); 
   
 signals: 
   void timeout(); 
   
 protected: 
   void paintEvent(QPaintEvent *event); 
   void mousePressEvent(QMouseEvent *event); 
 
 private: 
   QDateTime finishTime; 
   QTimer *updateTimer; 
   QTimer *finishTimer; 
 };
       
 

#include <qpainter.h> 
 
 #include <qpixmap.h> 
 #include <qtimer.h> 
 
 #include <cmath> 
 using namespace std; 
 
 #include "oventimer.h" 
 
 const double DegreesPerMinute = 7.0; 
 const double DegreesPerSecond = DegreesPerMinute / 60; 
 const int MaxMinutes = 45; 
 const int MaxSeconds = MaxMinutes * 60; 
 const int UpdateInterval = 10; 
 
 OvenTimer::OvenTimer(QWidget *parent, const char *name) 
     : QWidget(parent, name) 
 { 
   finishTime = QDateTime::currentDateTime(); 
   updateTimer = new QTimer(this); 
   finishTimer = new QTimer(this); 
   connect(updateTimer, SIGNAL(timeout()), this, SLOT(update())); 
   connect(finishTimer, SIGNAL(timeout()), this, SIGNAL(timeout())); 
 }
       
 

void OvenTimer::setDuration(int secs) 
 { 
   if (secs > MaxSeconds) 
     secs = MaxSeconds; 
   finishTime = QDateTime::currentDateTime().addSecs(secs); 
   updateTimer->start(UpdateInterval * 1000, false); 
   finishTimer->start(secs * 1000, true); 
   update(); 
 }
       
 
 

Переменная finishTime имеет тип QDateTime, который в Qt отвечает за хранение даты и времени. Объекты этого типа становятся просто незаменимы в ситуациях, когда в отмеряемый интервал времени попадает граница суток.

int OvenTimer::duration() const 
 { 
   int secs = QDateTime::currentDateTime().secsTo(finishTime); 
   if (secs < 0) 
     secs = 0; 
   return secs; 
 }
       
 

void OvenTimer::mousePressEvent(QMouseEvent *event) 
 { 
   QPoint point = event->pos() - rect().center(); 
   double theta = atan2(-(double)point.x(), -(double)point.y()) 
                  * 180 / 3.14159265359; 
   setDuration((int)(duration() + theta / DegreesPerSecond)); 
   update(); 
 }
       
 
 

void OvenTimer::paintEvent(QPaintEvent *) 
 { 
   QPainter painter(this); 
   int side = QMIN(width(), height()); 
   painter.setViewport((width() - side) / 2, (height() - side) / 2, 
                       side, side); 
   painter.setWindow(-50, -50, 100, 100); 
   draw(&painter); 
 }
       
 

Размеры окна (-50, -50, 100, 100) выбирались из следующих соображений:

• Функции рисования в QPainter, принимают значения координат в виде целых чисел. Если выбрать размер окна слишком маленьким, то координаты некоторых точек не смогут быть указаны достаточно точно, из-за возникающей проблемы округления.

• Если выбрать размер окна слишком большим, то при необходимости рисования текста функцией drawText(), нам придется выбирать шрифт большого размера.

Теперь перейдем к функции draw():

void OvenTimer::draw(QPainter *painter) 
 { 
   static const QCOORD triangle[3][2] = { 
       { -2, -49 }, { +2, -49 }, { 0, -47 } 
   }; 
   QPen thickPen(colorGroup().foreground(), 2); 
   QPen thinPen(colorGroup().foreground(), 1); 
   
   painter->setPen(thinPen); 
   painter->setBrush(colorGroup().foreground()); 
   painter->drawConvexPolygon(QPointArray(3, &triangle[0][0]));
       
 
 

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

  painter->setPen(thickPen); 
   painter->setBrush(colorGroup().light()); 
   painter->drawEllipse(-46, -46, 92, 92); 
   painter->setBrush(colorGroup().mid()); 
   painter->drawEllipse(-20, -20, 40, 40); 
   painter->drawEllipse(-15, -15, 30, 30);
       
 
 

  int secs = duration(); 
   painter->rotate(secs * DegreesPerSecond); 
   painter->drawRect(-8, -25, 16, 50); 
   
   for (int i = 0; i <= MaxMinutes; ++i) { 
     if (i % 5 == 0) { 
       painter->setPen(thickPen); 
       painter->drawLine(0, -41, 0, -44); 
       painter->drawText(-15, -41, 30, 25, 
                         AlignHCenter | AlignTop, 
                         QString::number(i)); 
       } else { 
         painter->setPen(thinPen); 
         painter->drawLine(0, -42, 0, -44); 
       } 
       painter->rotate(-DegreesPerMinute); 
   } 
 }
       
 

В цикле for, по краю внешнего круга рисуются риски, а под ними -- числа, обозначающие количество минут, с шагом 5. В конце каждой итерации выполняется поворот системы координат по часовой стрелке на 7 градусов, что соответствует одной минуте. Таким образом, каждая следующая риска будет рисоваться на своем месте, хотя координаты в drawLine() и drawText() задаются одни и те же.

Тут есть еще одна проблема, которую мы не учли -- мерцание. Виджет перерисовывается целиком каждые 10 секунд, что становится причиной появления эффекта подмаргивания изображения. Чтобы избавиться от нее, добавим двойную буферизацию. Для этого нужно передать родительскому конструктору флаг WNoAutoErase и изменить paintEvent() следующим образом:

void OvenTimer::paintEvent(QPaintEvent *event) 
 { 
   static QPixmap pixmap; 
   QRect rect = event->rect(); 
   
   QSize newSize = rect.size().expandedTo(pixmap.size()); 
   pixmap.resize(newSize); 
   pixmap.fill(this, rect.topLeft()); 
   
   QPainter painter(&pixmap, this); 
   int side = QMIN(width(), height()); 
   painter.setViewport((width() - side) / 2 - event->rect().x(), 
                       (height() - side) / 2 - event->rect().y(), 
                       side, side); 
   painter.setWindow(-50, -50, 100, 100); 
   draw(&painter); 
   bitBlt(this, event->rect().topLeft(), &pixmap); 
 }
       
 

Очень похоже на то, что мы описывали в разделе Двойная буферизация, но с одним важным отличием: в Главе 5, для выполнения сдвига, мы пользовались функцией translate(), теперь же, мы вычитаем координаты левого верхнего угла прямоугольника, требующего перерисовки, при настройке области просмотра. Использование translate() здесь было бы не очень удобным, поскольку преобразование должно быть выражено в логических координатах, в то время как событие поставляется с координатами физическими.

8.2. Рисование средствами QCanvas.

QCanvas (Canvas -- холст, полотно, канва. прим. перев.) предоставляет более высокоуровневый интерфейс, чем QPainter. Он может включать в себя элементы любой формы и имеет внутреннюю реализацию двойной буферизации. Для приложений, которые занимаются визуализацией информации или двухмерных игр, выбор QCanvas может оказаться лучшим решением.

Элементы, которые может отображать QCanvas, являются экземплярами класса QCanvasItem или его потомков. Qt содержит неплохой набор предопределенных графических элементов: QCanvasLine, QCanvasRectangle, QCanvasPolygon, QCanvasPolygonalItem, QCanvasEllipse, QCanvasSpline, QCanvasSprite и QCanvasText..

Классы QCanvas и QCanvasItem -- просто данные, они не имеют визуального представления. Для отображения QCanvas и его элементов мы должны использовать виджет QCanvasView. Такое разделение данных и средств их отображения, позволяет отображать один и тот же QCanvas в нескольких QCanvasView, причем каждый из них может визуализировать свою собственную часть QCanvas, причем с применением различных матриц преобразования.

Класс QCanvas оптимизирован для работы с большим количеством элементов. Когда изменяется какой либо элемент, то перерисовывается только та часть, которая действительно изменилась. В нем так же заложен эффективный алгоритм проверки на пересечение. Поэтому, QCanvas можно смело рассматривать как неплохую альтернативу подходам, связанным с перекрытием родительских методов paintEvent() и QScrollView::drawContents().

class DiagramView : public QCanvasView 
 { 
   Q_OBJECT 
   
 public: 
   DiagramView(QCanvas *canvas, QWidget *parent = 0, const char *name = 0); 
   
 public slots: 
   void cut(); 
   void copy(); 
   void paste(); 
   void del(); 
   void properties(); 
   void addBox();
   void addLine(); 
   void bringToFront(); 
   void sendToBack();
       
 
 

protected: 
   void contentsContextMenuEvent(QContextMenuEvent *event); 
   void contentsMousePressEvent(QMouseEvent *event); 
   void contentsMouseMoveEvent(QMouseEvent *event); 
   void contentsMouseDoubleClickEvent(QMouseEvent *event); 
   
 private: 
   void createActions(); 
   void addItem(QCanvasItem *item); 
   void setActiveItem(QCanvasItem *item); 
   void showNewItem(QCanvasItem *item); 
   
   QCanvasItem *pendingItem; 
   QCanvasItem *activeItem; 
   QPoint lastPos; 
   int minZ; 
   int maxZ; 
   
   QAction *cutAct; 
   QAction *copyAct; 
   ... 
   QAction *sendToBackAct; 
 };
       
 

class DiagramBox : public QCanvasRectangle 
 { 
 public: 
   enum { RTTI = 1001 }; 
   
   DiagramBox(QCanvas *canvas); 
   ~DiagramBox(); 
   
   void setText(const QString &newText);
   QString text() const { return str; } 
   void drawShape(QPainter &painter);
   QRect boundingRect() const; 
   int rtti() const { return RTTI; } 
 
 private: 
   QString str; 
 };
       
 

Функция rtti() перекрывает родительский метод. Имя этой функции происходит от английского "run-time type identification" -- "идентификация типа во время исполнения". Возвращаемый ею результат будет сравниваться с константой RTTI, чтобы узнать -- является ли тот или иной элемент объектом класса DiagramBox. Эту же проверку можно было бы выполнить с использованием механизма C++ dynamic_cast<T>(), но это ограничило бы нас в выборе компилятора C++.

Число 1001 выбрано случайным образом. Приемлемо любое значение, большее 1000, единственное ограничение: в одном и том же приложении не должны использоваться разные классы с одинаковым значением RTTI.

class DiagramLine : public QCanvasLine 
 { 
 public: 
   enum { RTTI = 1002 }; 
   
   DiagramLine(QCanvas *canvas); 
   ~DiagramLine(); 
   
   QPoint offset() const { return QPoint((int)x(), (int)y()); } 
   void drawShape(QPainter &painter); 
   QPointArray areaPoints() const; 
   int rtti() const { return RTTI; } 
 };
       
 

Перейдем к обзору реализации этих трех классов:

DiagramView::DiagramView(QCanvas *canvas, QWidget *parent, 
                          const char *name) 
     : QCanvasView(canvas, parent, name) 
 { 
   pendingItem = 0; 
   activeItem = 0; 
   minZ = 0; 
   maxZ = 0; 
   createActions(); 
 }
       
 

В приватной функции createActions() создаются экземпляры QAction. Мы уже рассматривали подобные функции в примерах ранее, поэтому реализацию этой функции мы опустим.

void DiagramView::contentsContextMenuEvent(QContextMenuEvent *event) 
 { 
   QPopupMenu contextMenu(this); 
   if (activeItem) { 
     cutAct->addTo(&contextMenu); 
     copyAct->addTo(&contextMenu); 
     deleteAct->addTo(&contextMenu); 
     contextMenu.insertSeparator(); 
     bringToFrontAct->addTo(&contextMenu); 
     sendToBackAct->addTo(&contextMenu); 
     contextMenu.insertSeparator(); 
     propertiesAct->addTo(&contextMenu); 
   } else { 
     pasteAct->addTo(&contextMenu); 
     contextMenu.insertSeparator(); 
     addBoxAct->addTo(&contextMenu); 
     addLineAct->addTo(&contextMenu); 
   } 
   contextMenu.exec(event->globalPos()); 
 }
       
 
 

void DiagramView::addBox() 
 { 
   addItem(new DiagramBox(canvas())); 
 } 
 
 void DiagramView::addLine() 
 { 
   addItem(new DiagramLine(canvas())); 
 }
       
 
 

void DiagramView::addItem(QCanvasItem *item) 
 { 
   delete pendingItem; 
   pendingItem = item; 
   setActiveItem(0); 
   setCursor(crossCursor); 
 }
       
 

Когда пользователь выбирает пункт контекстного меню Add Box или Add Line, изменяется внешний вид указателя мыши, но элемент будет добавлен только когда он щелкнет по канве.

void DiagramView::contentsMousePressEvent(QMouseEvent *event) 
 { 
   if (event->button() == LeftButton << pendingItem) { 
     pendingItem->move(event->pos().x(), event->pos().y()); 
     showNewItem(pendingItem); 
     pendingItem = 0; 
     unsetCursor(); 
   } else { 
     QCanvasItemList items = canvas()->collisions(event->pos()); 
     if (items.empty()) 
       setActiveItem(0); 
     else 
       setActiveItem(*items.begin()); 
   } 
   lastPos = event->pos(); 
 }
       
 

Любой другой щелчок по канве интерпретируется как попытка выделить какой либо из элементов или наоборот, снять выделение. Функция collisions() возвращает список всех элементов, находящихся под указателем мыши. Первый из этого списка активизируется. Если список содержит несколько элементов, то первым в нем всегда будет стоять тот элемент, который отображается поверх других.

void DiagramView::contentsMouseMoveEvent(QMouseEvent *event) 
 { 
   if (event->state() & LeftButton) { 
     if (activeItem) { 
       activeItem->moveBy(event->pos().x() - lastPos.x(), 
                          event->pos().y() - lastPos.y()); 
       lastPos = event->pos();
       canvas()->update(); 
     } 
   } 
 }
       
 

void DiagramView::contentsMouseDoubleClickEvent(QMouseEvent *event) 
 { 
   if (event->button() == LeftButton && activeItem 
            && activeItem->rtti() == DiagramBox::RTTI) { 
     DiagramBox *box = (DiagramBox *)activeItem; 
     bool ok; 
     
     QString newText = QInputDialog::getText( 
             tr("Diagram"), tr("Enter new text:"), 
             QLineEdit::Normal, box->text(), &ok, this); 
     if (ok) { 
       box->setText(newText); 
       canvas()->update(); 
     } 
   } 
 }
       
 
 

void DiagramView::bringToFront() 
 { 
   if (activeItem) { 
     ++maxZ; 
     activeItem->setZ(maxZ); 
     canvas()->update(); 
   } 
 }
       
 

void DiagramView::sendToBack() 
 { 
   if (activeItem) { 
     --minZ; 
     activeItem->setZ(minZ); 
     canvas()->update(); 
   } 
 }
       
 

void DiagramView::cut() 
 { 
   copy(); 
   del(); 
 }
       
 

void DiagramView::copy() 
 { 
   if (activeItem) { 
     QString str; 
     
     if (activeItem->rtti() == DiagramBox::RTTI) { 
       DiagramBox *box = (DiagramBox *)activeItem; 
       str = QString("DiagramBox %1 %2 %3 %4 %5") 
             .arg(box->width()) 
             .arg(box->height()) 
             .arg(box->pen().color().name()) 
             .arg(box->brush().color().name()) 
             .arg(box->text()); 
     } else if (activeItem->rtti() == DiagramLine::RTTI) { 
       DiagramLine *line = (DiagramLine *)activeItem; 
       QPoint delta = line->endPoint() - line->startPoint(); 
       str = QString("DiagramLine %1 %2 %3") 
             .arg(delta.x()) 
             .arg(delta.y()) 
             .arg(line->pen().color().name()); 
     } 
     QApplication::clipboard()->setText(str); 
   } 
 }
       
 
 

      DiagramBox 320 40 #000000 #ffffff My Left Foot
       
 

void DiagramView::paste() 
 { 
   QString str = QApplication::clipboard()->text(); 
   QTextIStream in(&str); 
   QString tag; 
   
   in >> tag; 
   if (tag == "DiagramBox") { 
     int width; 
     int height; 
     QString lineColor; 
     QString fillColor; 
     QString text; 
      
     in >> width >> height >> lineColor >> fillColor; 
     text = in.read(); 
      
     DiagramBox *box = new DiagramBox(canvas()); 
     box->move(20, 20); 
     box->setSize(width, height); 
     box->setText(text); 
     box->setPen(QColor(lineColor)); 
     box->setBrush(QColor(fillColor)); 
     showNewItem(box); 
   } else if (tag == "DiagramLine") {
     int deltaX; 
     int deltaY; 
     QString lineColor; 
       
     in >> deltaX >> deltaY >> lineColor; 
       
     DiagramLine *line = new DiagramLine(canvas()); 
     line->move(20, 20); 
     line->setPoints(0, 0, deltaX, deltaY); 
     line->setPen(QColor(lineColor)); 
     showNewItem(line); 
   } 
 }
       
 

void DiagramView::del() 
 { 
   if (activeItem) {
     QCanvasItem *item = activeItem; 
     setActiveItem(0); 
     delete item; 
     canvas()->update(); 
   } 
 }
       
 

void DiagramView::properties() 
 { 
   if (activeItem) { 
     PropertiesDialog dialog; 
     dialog.exec(activeItem); 
   } 
 }
       
 
 

void DiagramView::showNewItem(QCanvasItem *item) 
 { 
   setActiveItem(item); 
   bringToFront(); 
   item->show(); 
   canvas()->update(); 
 }
       
 

void DiagramView::setActiveItem(QCanvasItem *item) 
 {
   if (item != activeItem) { 
     if (activeItem) 
       activeItem->setActive(false); 
     activeItem = item; 
     if (activeItem) 
       activeItem->setActive(true); 
     canvas()->update(); 
   } 
 }
       
 
 

Перейдем к рассмотрению реализации классов DiagramBox и DiagramLine.

const int Margin = 2; 
 
 void drawActiveHandle(QPainter &painter, const QPoint &center) 
 { 
   painter.setPen(Qt::black); 
   painter.setBrush(Qt::gray); 
   painter.drawRect(center.x() - Margin, center.y() - Margin, 
                    2 * Margin + 1, 2 * Margin + 1); 
 }
       
 

DiagramBox::DiagramBox(QCanvas *canvas) 
     : QCanvasRectangle(canvas) 
 { 
   setSize(100, 60); 
   setPen(black); 
   setBrush(white); 
   str = "Text"; 
 }
       
 

DiagramBox::~DiagramBox() 
 { 
   hide(); 
 }
       
 

void DiagramBox::setText(const QString &newText) 
 { 
   str = newText; 
   update(); 
 }
       
 
 

void DiagramBox::drawShape(QPainter &painter) 
 { 
   QCanvasRectangle::drawShape(painter); 
   painter.drawText(rect(), AlignCenter, text()); 
   if (isActive()) { 
     drawActiveHandle(painter, rect().topLeft()); 
     drawActiveHandle(painter, rect().topRight()); 
     drawActiveHandle(painter, rect().bottomLeft()); 
     drawActiveHandle(painter, rect().bottomRight()); 
   } 
 }
       
 

QRect DiagramBox::boundingRect() const 
 { 
   return QRect((int)x() - Margin, (int)y() - Margin, 
                width() + 2 * Margin, height() + 2 * Margin); 
 }
       
 

Значение, которое возвращает родительский метод, нас не устраивает потому, что он не учитывает размеры маленьких квадратиков, рисуемых по углам активного элемента.

DiagramLine::DiagramLine(QCanvas *canvas) 
     : QCanvasLine(canvas) 
 { 
   setPoints(0, 0, 0, 99); 
 }
       
 

DiagramLine::~DiagramLine() 
 { 
   hide(); 
 }
       
 

void DiagramLine::drawShape(QPainter &painter) 
 { 
   QCanvasLine::drawShape(painter); 
   if (isActive()) { 
     drawActiveHandle(painter, startPoint() + offset()); 
     drawActiveHandle(painter, endPoint() + offset()); 
   } 
 }
       
 

QPointArray DiagramLine::areaPoints() const 
 { 
   const int Extra = Margin + 1; 
   QPointArray points(6); 
   QPoint pointA = startPoint() + offset(); 
   QPoint pointB = endPoint() + offset(); 
   
   if (pointA.x() > pointB.x()) 
     swap(pointA, pointB); 
   
   points[0] = pointA + QPoint(-Extra, -Extra); 
   points[1] = pointA + QPoint(-Extra, +Extra); 
   points[3] = pointB + QPoint(+Extra, +Extra); 
   points[4] = pointB + QPoint(+Extra, -Extra); 
   if (pointA.y() > pointB.y()) { 
     points[2] = pointA + QPoint(+Extra, +Extra); 
     points[5] = pointB + QPoint(-Extra, -Extra); 
   } else { 
     points[2] = pointB + QPoint(-Extra, +Extra); 
     points[5] = pointA + QPoint(+Extra, -Extra); 
   } 
   return points; 
 }
       
 

Первое, что делает функция -- сохраняет координаты точек во временных переменных pointA и pointB, а затем проверяет -- находится ли точка pointA левее точки pointB и меняет их местами, если это необходимо, с помощью функции swap() (определена в <algorithm>). После этого она выполняет различные действия для ниспадающих и восстающих линий.

Границы области рисования линии всегда представляются в виде 6 точек, но их координаты существенно зависят от того -- ниспадающая линия или восстающая. Однако, координаты 4-х точек из 6-ти (0, 1, 3 и 4) всегда одинаковы для обоих случаев. Например, точки 0 и 1 всегда определяют левый верхний и левый нижний углы конца A, а точка 2 задает правый нижний угол для восстающих линий на конце A и левый нижний угол для ниспадающих линий на конце B.

Одна деталь, которую мы опустили -- пользователь не может изменить размеры элемента, манипулируя маленькими квадратиками. Если бы мы хотели добавить такую возможность, то скорее всего нам пришлось бы сделать все немного иначе. Вместо того, чтобы рисовать квадратики в drawShape(), нам скорее всего пришлось бы сделать их самостоятельными элементами канвы. И изменять внешний вид указателя мыши, вызовом setCursor(), когда он находится над квадратиком, но для этого, сначала потребовалось бы вызвать setMouseTracking(true), потому что обычно Qt передает события перемещения мыши только тогда, когда какая либо кнопка мыши удерживается в нажатом состоянии.

Кроме того, можно было бы расширить набор элементов диаграмм, сделать возможным выделение нескольких элементов диаграммы одновременно и добавить возможность объединения элементов в группы. Статья "Canvas Item Groupies", в ежеквартальнике Qt Quarterly ( http://doc.trolltech.com/qq/qq05-canvasitemgrouping.html), описывает один из приемов реализации подобных возможностей.

В этом разделе мы предоставили пример работающего кода, использующего функциональность классов QCanvas и QCanvasView, но не раскрыли всех возможностей класса QCanvas. Например, элементы могут перемещаться по канве, если им указать скорость перемещения вызовом метода setVelocity(). За подробной информацией обращайтесь к сопроводительной документации.

8.3. Вывод на печать.

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

1. Создается экземпляр класса QPrinter, который будет представлять "устройство для рисования".

2. Вызывается функция QPrinter::setup(), которая покажет пользователю диалог выбора принтера.

3. Создается экземпляр класса QPainter, который будет взаимодействовать с объектом QPrinter.

4. Средствами QPainter рисуется изображение на странице.

5. Вызывается метод QPrinter::newPage(), чтобы прокрутить страницу.

6. Повторять действия, описанные в пунктах 4 и 5, пока не будут отпечатаны все страницы.

void PrintWindow::printOvenTimer(OvenTimer *ovenTimer) 
 { 
   if (printer.setup(this)) { 
     QPainter painter(&printer); 
     QRect rect = painter.viewport(); 
     int side = QMIN(rect.width(), 
     rect.height()); 
     painter.setViewport(0, 0, side, side); 
     painter.setWindow(-50, -50, 100, 100); 
     ovenTimer->draw(&painter); 
   } 
 }
       
 

Мы вызываем setup(), чтобы запустить диалог выбора принтера. Она возвращает true, если пользователь нажал на кнопку OK. После вызова setup(), объект QPrinter готов к работе.

Далее создается QPainter, который будет рисовать на QPrinter. Потом настраивается область просмотра (viewport) и назначается система координат окна (-50, -50, 100, 100) -- прямоугольник, который ожидает получить OvenTimer, и в завершение выполняется рисование виджета, вызовом функции draw(). Если не установить размеры области просмотра, то виджет OvenTimer будет вытянут на всю высоту страницы.

По-умолчанию QPainter устанавливает размеры окна такими, чтобы они соответствовали разрешению экрана (обычно где-то между 72 и 100 точками на дюйм), но в данном случае это не имеет большого значения, так как мы сами установили систему координат окна.

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

Более практичный пример -- вывод на печать QCanvas. Приложения, которые его используют, очень часто нуждаются в возможности вывода на печать того, что нарисует пользователь.

void PrintWindow::printCanvas(QCanvas *canvas) 
 { 
   if (printer.setup(this)) { 
     QPainter painter(&printer); 
     QRect rect = painter.viewport(); 
     QSize size = canvas->size(); 
     size.scale(rect.size(), QSize::ScaleMin); 
     painter.setViewport(rect.x(), rect.y(), 
                         size.width(), size.height()); 
     painter.setWindow(canvas->rect()); 
     painter.drawRect(painter.window()); 
     painter.setClipRect(painter.viewport()); 
     
     QCanvasItemList items = canvas->collisions(canvas->rect()); 
     QCanvasItemList::const_iterator it = items.end(); 
     while (it != items.begin()) { 
       --it; 
       (*it)->draw(painter); 
     } 
   } 
 }
       
 

Функция collisions() возвратит список видимых элементов канвы, отсортированный по значению координаты z. Список просматривается в цикле, начиная с конца, и выполняется рисование элементов списка вызовом QCanvasItem::draw(). Таким образом, чем выше в списке стоит элемент, тем позднее он будет нарисован.

Третий пример -- печать картинки из QImage.

void PrintWindow::printImage(const QImage &image) 
 { 
   if (printer.setup(this)) { 
     QPainter painter(&printer); 
     QRect rect = painter.viewport(); 
     QSize size = image.size(); 
     size.scale(rect.size(), QSize::ScaleMin); 
     painter.setViewport(rect.x(), rect.y(), 
                         size.width(), size.height()); 
     painter.setWindow(image.rect()); 
     painter.drawImage(0, 0, image); 
   } 
 }
       
 

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

Qt предлагает два варианта вывода на печать многостраничных документов:

• Можно "перегнать" документ в формат HTML и вывести его средствами QSimpleRichText.

• Можно выполнять перевод страниц вручную.

В качестве примера напечатаем справочник цветовода, который содержит названия цветов и их краткое описание. Каждая статья справочника хранится в виде "название: описание", например:

      Miltonopsis santanae: Самая опасная разновидность орхидеи.
       
 

Следующий фрагмент кода выводит на печать содержимое справочника, предварительно "перегнав" его в формат HTML:

void PrintWindow::printFlowerGuide(const QStringList &entries) 
 { 
   QString str; 
   QStringList::const_iterator it = entries.begin(); 
   while (it != entries.end()) { 
     QStringList fields = QStringList::split(": ", *it); 
     QString title = QStyleSheet::escape(fields[0]); 
     QString body = QStyleSheet::escape(fields[1]); 
     
     str += "<table width=\"100%\" border=1 cellspacing=0>\n" 
            "<tr><td bgcolor=\"lightgray\"><font size=\"+1\">" 
            "<b><i>" + title + "</i></b></font>\n<tr><td>" 
            + body + "\n</table>\n<br>\n";
     ++it; 
   } 
   printRichText(str); 
 }
       
 
 

const int LargeGap = 48; 
 
 void PrintWindow::printRichText(const QString &str) 
 { 
   if (printer.setup(this)) { 
     QPainter painter(&printer); 
     int pageHeight = painter.window().height() - 2 * LargeGap; 
     QSimpleRichText richText(str, bodyFont, "", 0, 0, 
                              pageHeight); 
     richText.setWidth(&painter, painter.window().width()); 
     int numPages = (int)ceil((double)richText.height() 
                              / pageHeight); 
     int index; 
     
     for (int i = 0; i < (int)printer.numCopies(); ++i) { 
       for (int j = 0; j < numPages; ++j) { 
         if (i > 0 || j > 0) 
           printer.newPage(); 
         if (printer.pageOrder() 
                 == QPrinter::LastPageFirst) { 
           index = numPages - j - 1;
         } else { 
           index = j; 
         } 
         printPage(&painter, richText, pageHeight, index); 
       } 
     } 
   } 
 }
       
 
 

Внутренний цикл for отсчитывет страницы. если страница не является первой, то вызывается функция newPage(). Для вывода очередной страницы на печать вызывается функция printPage().

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

В данном примере предполагается, что printer, bodyFont и footerFont -- это переменные-члены класса PrintWindow.

void PrintWindow::printPage(QPainter *painter, 
                             const QSimpleRichText &richText, 
                             int pageHeight, int index) 
 { 
   QRect rect(0, index * pageHeight + LargeGap, 
              richText.width(), pageHeight); 
   painter->saveWorldMatrix(); 
   painter->translate(0, -rect.y()); 
   richText.draw(painter, 0, LargeGap, rect, colorGroup()); 
   painter->restoreWorldMatrix(); 
   painter->setFont(footerFont); 
   painter->drawText(painter->window(), AlignHCenter | AlignBottom, 
                     QString::number(index + 1)); 
 }
       
 
 

Мы выполняем смещение системы координат и вызываем draw(), чтобы нарисовать текст, с нужной позиции. После этого, в нижнем колонтитуле, по центру страницы, выводится ее номер. Если бы нам потребовалось выводить что нибудь в верхнем колонтитуле, то мы добавили бы еще один вызов drawText().

Константа LargeGap равна числу 48. Если исходить из предположения, что разрешение экрана срставляет 96 точек на дюйм, то число 48 соответствует половине дюйма (12.7 мм). Чтобы найти точное значение для константы, в каждом конкретном случае, можно воспользоваться услугами класса QPaintDeviceMetrics:

  QPaintDeviceMetrics metrics(&printer); 
   int LargeGap = metrics.logicalDpiY() / 2;
       
 

  bodyFont = QFont("Helvetica", 14); 
   footerFont = bodyFont;
       
 
 

void PrintWindow::printFlowerGuide(const QStringList &entries) 
 { 
   if (printer.setup(this)) { 
     QPainter painter(&printer); 
     vector<QStringList> pages; 
     int index; 
     
     paginate(&painter, &pages, entries);
     for (int i = 0; i < (int)printer.numCopies(); ++i) { 
       for (int j = 0; j < (int)pages.size(); ++j) { 
         if (i > 0 || j > 0) 
           printer.newPage(); 
         
         if (printer.pageOrder() == QPrinter::LastPageFirst) { 
           index = pages.size() - j - 1; 
         } else { 
           index = j; 
         } 
         printPage(&painter, pages, index); 
       } 
     } 
   } 
 }
       
 
 

Например, допустим, что справочник содержит всего 6 статей, которые мы обозначим как A, B, C, D, E и F. Теперь предположим, что статьи A и B располагаются на первой странице, C, D и E -- на второй, а F -- на третьей. Таким образом, массив pages, в элементе с индексом 0, будет содержать статьи A и B, статьи C, D и E -- в элементе с индексом 1 и статью F -- в элементе с индексом 2.

В остальном, функция printFlowerGuide() практически идентична приведенному ранее варианту. Однако, функция printPage() имеет существенные отличия, но об этом немного позже.

void PrintWindow::paginate(QPainter *painter, 
                            vector<QStringList> *pages, 
                            const QStringList &entries) 
 { 
   QStringList currentPage; 
   int pageHeight = painter->window().height() - 2 * LargeGap; 
   int y = 0; 
   
   QStringList::const_iterator it = entries.begin(); 
   while (it != entries.end()) { 
     int height = entryHeight(painter, *it); 
     if (y + height > pageHeight && !currentPage.empty()) { 
       pages->push_back(currentPage); 
       currentPage.clear(); 
       y = 0; 
     } 
     currentPage.push_back(*it); 
     y += height + MediumGap; ++it; 
   } 
   if (!currentPage.empty()) 
     pages->push_back(currentPage); 
 }
       
 
 

int PrintWindow::entryHeight(QPainter *painter, const QString &entry) { 
   QStringList fields = QStringList::split(": ", entry); 
   QString title = fields[0]; 
   QString body = fields[1]; 
   int textWidth = painter->window().width() - 2 * SmallGap; 
   int maxHeight = painter->window().height();
   painter->setFont(titleFont); 
   QRect titleRect = painter->boundingRect(0, 0, 
                                           textWidth, maxHeight, 
                                           WordBreak, title); 
   painter->setFont(bodyFont); 
   QRect bodyRect = painter->boundingRect(0, 0, 
                                          textWidth, maxHeight, 
                                          WordBreak, body); 
   return titleRect.height() + bodyRect.height() + 4 * SmallGap; 
 }
       
 

void PrintWindow::printPage(QPainter *painter, 
                             const vector<QStringList> &pages, 
                             int index) 
 { 
   painter->saveWorldMatrix(); 
   painter->translate(0, LargeGap); 
   QStringList::const_iterator it = pages[index].begin(); 
   while (it != pages[index].end()) { 
     QStringList fields = QStringList::split(": ", *it); 
     QString title = fields[0]; 
     QString body = fields[1]; 
     printBox(painter, titleFont, title, lightGray); 
     printBox(painter, bodyFont, body, white); 
     painter->translate(0, MediumGap); 
     ++it; 
   } 
   painter->restoreWorldMatrix(); 
   painter->setFont(footerFont); 
   painter->drawText(painter->window(), AlignHCenter | AlignBottom, 
                     QString::number(index + 1)); 
 }
       
 

void PrintWindow::printBox(QPainter *painter, const QFont &font, 
                            const QString &str, const QBrush &brush) 
 { 
   painter->setFont(font); 
   int boxWidth = painter->window().width(); 
   int textWidth = boxWidth - 2 * SmallGap; 
   int maxHeight = painter->window().height(); 
   
   QRect textRect = painter->boundingRect(SmallGap, SmallGap, 
                                          textWidth, maxHeight, 
                                          WordBreak, str); 
   int boxHeight = textRect.height() + 2 * SmallGap;
   painter->setPen(QPen(black, 2, SolidLine)); 
   painter->setBrush(brush); 
   painter->drawRect(0, 0, boxWidth, boxHeight); 
   painter->drawText(textRect, WordBreak, str); 
   painter->translate(0, boxHeight); 
 }
       
 

Если на печать выводится большой документ, или пользователь заказал несколько копий одного документа, то неплохо было бы показать индикатор хода выполнения задания -- QProgressDialog. Ниже приводится модифицированный вариант функции printFlowerGuide(), которая выводит перед пользователем индикатор хода выполнения задания:

void PrintWindow::printFlowerGuide(const QStringList &entries) 
 { 
   if (printer.setup(this)) { 
     QPainter painter(&printer); 
     vector<QStringList> pages; 
     int index; 
     
     paginate(&painter, &pages, entries); 
     
     int numSteps = printer.numCopies() * pages.size(); 
     int step = 0; 
     QProgressDialog progress(tr("Printing file..."), 
                              tr("Cancel"), numSteps, this); 
     progress.setModal(true); 
     
     for (int i = 0; i < (int)printer.numCopies(); ++i) { 
       for (int j = 0; j < (int)pages.size(); ++j) { 
         progress.setProgress(step); 
         qApp->processEvents(); 
         if (progress.wasCanceled()) { 
           printer.abort(); 
           return; 
         } 
         ++step;
 
         if (i > 0 || j > 0) 
           printer.newPage(); 
         if (printer.pageOrder() == QPrinter::LastPageFirst) { 
           index = pages.size() - j - 1; 
         } else { 
           index = j; 
         } 
         printPage(&painter, pages, index); 
       } 
     } 
   } 
 }
       
 
 

8.4. Графика OpenGL.

OpenGL -- это стандарт API, для отображения двух- и трехмерной графики. Приложения Qt могут использовать OpenGL, посредством модуля QGL. Мы полагаем, что вы уже имеете некоторое знакомство с OpenGL. Если это не так, то рекомендуем начать изучение с посещения сайта http://www.opengl.org/.

Рисование трехмерных объектов, с помощью OpenGL, не так сложно, как может показаться на первый взгляд. Все что вам нужно сделать -- создать дочерний класс от QGLWidget, перекрыть некоторые виртуальные методы предка и связать приложение с модулем QGL и библиотекой OpenGL. Поскольку QGLWidget ведет свою родословную от QWidget, то здесь вполне применимы знания, которые вы уже получили. Основное отличие здесь состоит в том, что теперь, вместо QPainter, вам придется использовать стандартные функции рисования из OpenGL.

class Cube : public QGLWidget 
 { 
 public: 
   Cube(QWidget *parent = 0, const char *name = 0); 
   
 protected: 
   void initializeGL(); 
   void resizeGL(int width, int height); 
   void paintGL(); 
   void mousePressEvent(QMouseEvent *event); 
   void mouseMoveEvent(QMouseEvent *event); 
   void mouseDoubleClickEvent(QMouseEvent *event);
 
 private: 
   void draw(); 
   int faceAtPosition(const QPoint &pos); 
   GLfloat rotationX; 
   GLfloat rotationY; 
   GLfloat rotationZ; 
   QColor faceColors[6]; 
   QPoint lastPos; 
 };
       
 
 

Cube::Cube(QWidget *parent, const char *name) 
     : QGLWidget(parent, name) 
 { 
   setFormat(QGLFormat(DoubleBuffer | DepthBuffer)); 
   rotationX = 0; 
   rotationY = 0; 
   rotationZ = 0; 
   faceColors[0] = red; 
   faceColors[1] = green; 
   faceColors[2] = blue; 
   faceColors[3] = cyan; 
   faceColors[4] = yellow; 
   faceColors[5] = magenta; 
 }
       
 
 

void Cube::initializeGL() 
 { 
   qglClearColor(black); 
   glShadeModel(GL_FLAT); 
   glEnable(GL_DEPTH_TEST); 
   glEnable(GL_CULL_FACE); 
 }
       
 

Все функции являются стандартными вызовами из библиотеки OpenGL, за исключением qglClearColor() -- метода класса QGLWidget. Если задаться целью, до конца следовать стандарту OpenGL, то мы могли бы вызвать функцию glClearColor(), в режиме RGBA, или glClearIndex(), в режиме индексированных цветов.

void Cube::resizeGL(int width, int height) 
 { 
   glViewport(0, 0, width, height); 
   glMatrixMode(GL_PROJECTION); 
   glLoadIdentity(); 
   GLfloat x = (GLfloat)width / height; 
   glFrustum(-x, x, -1.0, 1.0, 4.0, 15.0);
   glMatrixMode(GL_MODELVIEW); 
 }
       
 

void Cube::paintGL() 
 { 
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
   draw(); 
 }
       
 

void Cube::draw() 
 { 
   static const GLfloat coords[6][4][3] = { 
       { { +1.0, -1.0, +1.0 }, { +1.0, -1.0, -1.0 }, 
         { +1.0, +1.0, -1.0 }, { +1.0, +1.0, +1.0 } }, 
       { { -1.0, -1.0, -1.0 }, { -1.0, -1.0, +1.0 }, 
         { -1.0, +1.0, +1.0 }, { -1.0, +1.0, -1.0 } }, 
       { { +1.0, -1.0, -1.0 }, { -1.0, -1.0, -1.0 }, 
         { -1.0, +1.0, -1.0 }, { +1.0, +1.0, -1.0 } }, 
       { { -1.0, -1.0, +1.0 }, { +1.0, -1.0, +1.0 }, 
         { +1.0, +1.0, +1.0 }, { -1.0, +1.0, +1.0 } }, 
       { { -1.0, -1.0, -1.0 }, { +1.0, -1.0, -1.0 }, 
         { +1.0, -1.0, +1.0 }, { -1.0, -1.0, +1.0 } }, 
       { { -1.0, +1.0, +1.0 }, { +1.0, +1.0, +1.0 }, 
         { +1.0, +1.0, -1.0 }, { -1.0, +1.0, -1.0 } } 
   }; 
   
   glMatrixMode(GL_MODELVIEW); 
   glLoadIdentity(); 
   glTranslatef(0.0, 0.0, -10.0); 
   glRotatef(rotationX, 1.0, 0.0, 0.0); 
   glRotatef(rotationY, 0.0, 1.0, 0.0); 
   glRotatef(rotationZ, 0.0, 0.0, 1.0);
 
   for (int i = 0; i < 6; ++i) { 
     glLoadName(i); 
     glBegin(GL_QUADS); 
     qglColor(faceColors[i]); 
     for (int j = 0; j < 4; ++j) { 
       glVertex3f(coords[i][j][0], coords[i][j][1], coords[i][j][2]); 
     } 
     glEnd(); 
   } 
 }  
       
 
 

void Cube::mousePressEvent(QMouseEvent *event) 
 { 
   lastPos = event->pos(); 
 } 
 
 void Cube::mouseMoveEvent(QMouseEvent *event) 
 { 
   GLfloat dx = (GLfloat)(event->x() - lastPos.x()) / width(); 
   GLfloat dy = (GLfloat)(event->y() - lastPos.y()) / height(); 
   
   if (event->state() & LeftButton) { 
     rotationX += 180 * dy; 
     rotationY += 180 * dx; 
     updateGL(); 
   } else if (event->state() & RightButton) { 
     rotationX += 180 * dy; 
     rotationZ += 180 * dx; 
     updateGL(); 
   } 
   lastPos = event->pos(); 
 }
       
 
 

После изменения переменных rotationX и/или rotationY и rotationZ, вызывается функция updateGL(), которая перерисовывает изображение.

void Cube::mouseDoubleClickEvent(QMouseEvent *event) 
 { 
   int face = faceAtPosition(event->pos()); 
   if (face != -1) { 
     QColor color = QColorDialog::getColor(faceColors[face], 
                                           this); 
     if (color.isValid()) { 
       faceColors[face] = color; 
       updateGL(); 
     } 
   } 
 }
       
 
 

int Cube::faceAtPosition(const QPoint &pos) 
 { 
   const int MaxSize = 512; 
   GLuint buffer[MaxSize]; 
   GLint viewport[4]; 
   
   glGetIntegerv(GL_VIEWPORT, viewport); 
   glSelectBuffer(MaxSize, buffer); 
   glRenderMode(GL_SELECT); 
   glInitNames(); 
   glPushName(0); 
   glMatrixMode(GL_PROJECTION); 
   glPushMatrix(); 
   glLoadIdentity(); 
   gluPickMatrix((GLdouble)pos.x(), 
                 (GLdouble)(viewport[3] - pos.y()), 
                 5.0, 5.0, viewport); 
   GLfloat x = (GLfloat)width() / height(); 
   glFrustum(-x, x, -1.0, 1.0, 4.0, 15.0); 
   draw(); 
   glMatrixMode(GL_PROJECTION); 
   glPopMatrix();
 
   if (!glRenderMode(GL_RENDER)) 
     return -1; 
   return buffer[3]; 
 }
       
 
 

Далее приводится содержимое файла main.cpp:

#include <qapplication.h> 
 
 
 #include "cube.h" 
 
 int main(int argc, char *argv[]) 
 { 
   QApplication app(argc, argv); 
   if (!QGLFormat::hasOpenGL()) 
     qFatal("This system has no OpenGL support"); 
     
   Cube cube; 
   cube.setCaption(QObject::tr("Cube")); 
   cube.resize(300, 300); 
   app.setMainWidget(&cube); 
   cube.show(); 
   return app.exec(); 
 }
       
 

Чтобы связать приложение Cube с модулем QGL и библиотекой OpenGL, в файл .pro нужно добавить строчку:

      CONFIG += opengl
       
 
 

9.1. Реализация механизма 'drag and drop' в приложениях.

В основе механизма "перетащил и бросил" лежат две операции: операция перетаскивания и операция сброса. Виджет может быть как источником, откуда начинается перетаскивание, так и местом, куда может производиться сбрасывание.

Это очень мощный механизм, позволяющий перетаскивать данные из одного приложения в другое. Однако, в некоторых случаях, можно реализовать некоторое подобие механизма "перетащил и бросил", не прибегая к специальным возможностям Qt. Если все, что вам нужно -- это перетащить какие либо данные внутри одного виджета, то гораздо проще это выполняется перекрытием обработчиков событий от мыши. Подобный подход мы рассматривали в Главе 8, при разработке виджета DiagramView.

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

Ниже приводится определение класса MainWindow:

class MainWindow : public QMainWindow 
 {
   Q_OBJECT 
 public: 
   MainWindow(QWidget *parent = 0, const char *name = 0); 
   
 protected: 
   void dragEnterEvent(QDragEnterEvent *event); 
   void dropEvent(QDropEvent *event); 
   
 private: 
   bool readFile(const QString &fileName); 
   QString strippedName(const QString &fullFileName); 
   
   QTextEdit *textEdit; 
 };
       
 
 

MainWindow::MainWindow(QWidget *parent, const char *name) 
     : QMainWindow(parent, name) 
 { 
   setCaption(tr("Drag File")); 
   textEdit = new QTextEdit(this); 
   setCentralWidget(textEdit); 
   textEdit->viewport()->setAcceptDrops(false); 
   setAcceptDrops(true); 
 }
       
 
 

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

Поскольку события, в случае отказа от обработки, переходят от подчиненного виджета -- виджету владельцу, то главное окно получит событие "сброса" даже в том случае, если сброс осуществлялся в области QTextEdit.

void MainWindow::dragEnterEvent(QDragEnterEvent *event) 
 { 
   event->accept(QUriDrag::canDecode(event)); 
 }
       
 
 

В нашем примере предполагается, что пользователь может сбросить в область приложения только имена файлов. Поэтому мы воспользовались услугами класса QUriDrag, который обслуживает перетаскивание файлов, для опознания перетаскиваемого объекта. Этот класс может использоваться для опознания Универсальных Идентификаторов Ресурсов (URI -- Universal Resource Identifier), таких как пути FTP или HTTP.

void MainWindow::dropEvent(QDropEvent *event) 
 { 
   QStringList fileNames; 
   if (QUriDrag::decodeLocalFiles(event, fileNames)) { 
     if (readFile(fileNames[0])) 
       setCaption(tr("%1 - Drag File") 
                  .arg(strippedName(fileNames[0]))); 
   } 
 }
       
 

Кроме того, класс QWidget предоставляет методы dragMoveEvent() и dragLeaveEvent(), но в большинстве приложений эти методы не используются.

Второй пример показывает -- как начать перетаскивание и как принять сбрасываемый объект. С этой целью мы создадим подкласс от QListBox, и реализуем в нем поддержку механизма "перетащил и бросил". Этот класс мы будем использовать в приложении "Project Chooser", показанном на рисунке 9.1.

Вся реализация будет размещаться в единственном классе, потомке QListBox. Ниже приводится определение класса:

class ProjectView : public QListBox 
 { 
   Q_OBJECT
 public: 
   ProjectView(QWidget *parent, const char *name = 0); 
   
 protected: 
   void contentsMousePressEvent(QMouseEvent *event); 
   void contentsMouseMoveEvent(QMouseEvent *event); 
   void contentsDragEnterEvent(QDragEnterEvent *event); 
   void contentsDropEvent(QDropEvent *event); 
   
 private: 
   void startDrag(); 
   QPoint dragPos; 
 };
       
 

ProjectView::ProjectView(QWidget *parent, const char *name) 
     : QListBox(parent, name) 
 { 
   viewport()->setAcceptDrops(true); 
 }
       
 
 

void ProjectView::contentsMousePressEvent(QMouseEvent *event) 
 { 
   if (event->button() == LeftButton) 
     dragPos = event->pos(); 
     QListBox::contentsMousePressEvent(event); 
 }
       
 

void ProjectView::contentsMouseMoveEvent(QMouseEvent *event) 
 { 
   if (event->state() & LeftButton) { 
     int distance = (event->pos() - dragPos).manhattanLength(); 
     if (distance > QApplication::startDragDistance()) 
       startDrag(); 
   } 
   QListBox::contentsMouseMoveEvent(event); 
 }
       
 
 

Если это расстояние больше, чем рекомендуемое классом QApplication (обычно 4 пикселя), после которого перемещение мыши действительно начинает рассматриваться как перетаскивание объекта, вызывается startDrag(), которая отмечает начало перетаскивания. Это дает возможность избежать ложного запуска процесса перетаскивания из-за дрожжания руки пользователя.

void ProjectView::startDrag() 
 { 
   QString person = currentText(); 
   if (!person.isEmpty()) { 
     QTextDrag *drag = new QTextDrag(person, this); 
     drag->setSubtype("x-person"); 
     drag->setPixmap(QPixmap::fromMimeSource("person.png")); 
     drag->drag(); 
   } 
 }
       
 
 

Затем вызывается setSubtype(), которая устанавливает подтип объекта -- x-person. После этого полный тип объекта MIME приобретает значение text/x-person. Если этого не сделать, то перетаскиваемый объект будет иметь тип MIME -- text/plain.

Стандартные типы MIME определены IANA (Internet Assigned Numbers Authority). Полный MIME тип состоит из названия типа и подтипа, разделенных символом слэша. Когда создается нестандартный тип, рекомендуется предварять название подтипа префиксом x-. Типы MIME используются буфером обмена и механизмом "drag and drop" для идентификации различных типов данных.

Функция drag() отмечает начало операции перетаскивания. После этого Qt принимает на себя обязательства по владению перетаскиваемым объектом, пока перемещение не будет завершено. Она сама удалит объект, когда нужда в нем отпадет, даже если он так и не достигнет места назначения.

void ProjectView::contentsDragEnterEvent(QDragEnterEvent *event) 
 { 
   event->accept(event->provides("text/x-person")); 
 }
       
 
 

void ProjectView::contentsDropEvent(QDropEvent *event) 
 { 
   QString person; 
   
   if (QTextDrag::decode(event, person)) { 
     QWidget *fromWidget = event->source(); 
     if (fromWidget && fromWidget != this 
             && fromWidget->inherits("ProjectView")) { 
       ProjectView *fromProject = (ProjectView *)fromWidget; 
       QListBoxItem *item = fromProject->findItem(person, ExactMatch); 
       delete item;
       insertItem(person); 
     } 
   } 
 }
       
 

9.2. Поддержка нестандартных типов данных при перетаскивании.

До сих пор мы имели дело с предопределенными типами перетаскиваемых объектов. Например, мы использовали QUriDrag, для перетаскивания файлов, и QTextDrag -- для текста. Оба этих класса являются наследниками QDragObject, который служит базой для всех перемещаемых объектов. В свою очредь, класс QDragObject наследует свойства абстрактного класса QMimeSource, предназначенного для хранения данных различных типов.

Если вы пожелаете перемещать объекты с текстовой информацией, с изображениями, с именами файлов или с информацией о цвете, то можно использовать предопределенные классы Qt: QTextDrag, QImageDrag, QUriDrag и QColorDrag. Но если вам необходимо перемещать нестандартные типы данных, то у вас есть два пути:

• Сохранить информацию, в двоичном представлении, в объекте класса QStoredDrag.

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

void MyWidget::startDrag() 
 { 
   QByteArray data = toAsdf(); 
   if (!data.isEmpty()) { 
     QStoredDrag *drag = new QStoredDrag("octet-stream/x-asdf", this); 
     drag->setEncodedData(data); 
     drag->setPixmap(QPixmap::fromMimeSource("asdf.png")); 
     drag->drag(); 
   } 
 }
       
 
 

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

Решение этих двух проблем заключается в создании дочернего класса от QDragObject и реализации двух виртуальных методов format() и encodedData(), используемых Qt для получения сведений о перетаскиваемых объектах. Чтобы показать -- как это можно сделать, мы создадим класс CellDrag, который будет хранить данные из одной или нескольких ячеек таблицы QTable.