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