Стили и стилизованные виджеты

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

Qt поставляется с набором встроенных стилей. Некоторые стили доступны только на определённых платформах. Пользовательские стили предоставляются в виде плагинов или путём создания экземпляра конкретного класса стиля с помощью QStyleFactory::create() и его установки с помощью QApplication::setStyle().

Настройка стиля

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

Реализация пользовательского стиля

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

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

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

Классы для стилизации виджетов

Эти классы используются для настройки внешнего вида и стиля приложения.

Реализация QStyle

API QStyle содержит функции, которые рисуют виджеты, статические вспомогательные функции для выполнения общих и сложных задач (например, вычисления положения ползунков ползунков), и функции для выполнения различных вычислений во время рисования (например, для вычисления подсказок размера виджетов). Стиль также помогает некоторым виджетам с макетом их содержимого. Кроме того, он создаёт QPalette, содержащую QBrushes для рисования.

QStyle рисует графические элементы; элемент — это виджет или часть виджета, например, отступ кнопки, рамка окна или полоса прокрутки. Большинство функций рисования теперь принимают четыре аргумента:

• значение перечисления, определяющее, какой графический элемент следует отрисовать
• QStyleOption, определяющий, как и где отрисовать этот элемент
• QPainter, который должен использоваться для отрисовки элемента
• QWidget, на котором выполняется отрисовка (необязательно)

Когда виджет просит стиль отрисовать элемент, он предоставляет стилю QStyleOption, который является классом, содержащим информацию, необходимую для отрисовки. Благодаря QStyleOption возможно сделать QStyle отрисовать виджеты без связывания какого-либо кода для виджета. Это позволяет использовать функции рисования QStyle на любом устройстве рисования, то есть вы можете нарисовать раскрывающийся список на любом виджете, а не только на QComboBox.

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

В этом разделе мы рассмотрим элементы стиля, параметры стиля и функции QStyle. В заключение, мы опишем, как используется палитра.

Элементы в представлениях элементов отрисовываются делегатами в Qt. Заголовки представления элементов всё ещё отрисовываются стилем. По умолчанию делегат Qt, QStyledItemDelegate, частично отрисовывает свои элементы с помощью текущего стиля; он отрисовывает индикаторы флажков и вычисляет ограничивающие прямоугольники для элементов, из которых состоит элемент. В этом документе мы описываем только то, как реализовать подкласс QStyle. Если вы хотите добавить поддержку других типов данных, чем те, которые поддерживаются QStyledItemDelegate, вам необходимо реализовать пользовательский делегат. Обратите внимание, что делегаты должны быть установлены программно для каждого отдельного виджета (т.е. делегаты по умолчанию не могут быть предоставлены в виде плагинов).

Элементы стиля

Элемент стиля — это графическая часть графического интерфейса. Виджет состоит из иерархии (или дерева) элементов стиля. Например, когда стиль получает запрос на отрисовку кнопки (например, из QPushButton), он отрисовывает метку (текст и значок), отступ кнопки и рамку фокуса. Отступ кнопки, в свою очередь, состоит из рамки вокруг отступа и двух других элементов, которые мы рассмотрим позже. Ниже представлена концептуальная иллюстрация дерева элементов кнопки.

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

Существует три типа элементов: примитивные элементы, элементы управления и сложные элементы управления. Элементы определяются перечислениями ComplexControl, ControlElement и PrimitiveElement. Значения каждого перечисления имеют префикс для идентификации их типа: CC_ для сложных элементов, CE_ для элементов управления и PE_ для примитивных элементов. В следующих трёх разделах мы рассмотрим, что определяет различные элементы, и увидим примеры виджетов, которые их используют.

Описание класса QStyle содержит список этих элементов и их роли в стилизации виджетов. Мы увидим, как они используются при стилизации отдельных виджетов.

Примитивные элементы

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

Элементы управления

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

Сложные элементы управления

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

Помимо рисования, стиль должен предоставлять виджетам информацию о том, на какой подэлемент управления (если таковой имеется) произошло нажатие мыши. Например, QScrollBar должен знать, нажал ли пользователь на ползунок, желобок ползунка или на одну из кнопок.

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

Другие задачи QStyle

Элементы стиля и виджеты, как уже упоминалось, используют стиль для вычисления границ подэлементов и подэлементов управления. Для измерений при рисовании также используются пиксельные метрики, которые представляют собой зависящие от стиля размеры в пикселях экрана. Доступные прямоугольники и пиксельные метрики представлены тремя перечислениями в QStyle: SubElement, SubControl и PixelMetric. Значения перечислений легко идентифицировать, так как они начинаются с SE_, SC_ и PM_.

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

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

Стиль вычисляет интервалы между виджетами в макетах. Существует два способа, которыми стиль может обрабатывать эти вычисления. Вы можете установить PM_LayoutHorizontalSpacing и PM_LayoutVerticalSpacing, что является способом, которым это делает стиль Java (через QCommonStyle). В качестве альтернативы вы можете реализовать QStyle::layoutSpacing() и QStyle::layoutSpacingImplementation(), если вам нужен больший контроль над этой частью макета. В этих функциях вы можете вычислить интервал, основываясь на типах элементов управления (QSizePolicy::ControlType) для различных политик размеров (QSizePolicy::Policy), а также на параметре стиля для данного виджета.

Параметры стиля

Подклассы QStyleOption содержат всю информацию, необходимую для стилизации отдельных элементов. Параметры стиля создаются — обычно в стеке — и заполняются вызывающим функцией QStyle. В зависимости от того, что рисуется, стиль будет ожидать другой класс параметров стиля. Например, элемент QStyle::PE_FrameFocusRect ожидает аргумент QStyleOptionFocusRect, и можно создать пользовательские подклассы, которые может использовать пользовательский стиль. Параметры стиля хранят общедоступные переменные для повышения производительности.

Виджеты могут находиться в нескольких различных состояниях, которые определяются перечислением State. Некоторые флаги состояния имеют разное значение в зависимости от виджета, но другие являются общими для всех виджетов, например State_Disabled. Именно QStyleOption устанавливает общие состояния с помощью QStyleOption::initFrom(); остальные состояния устанавливаются отдельными виджетами.

Наиболее важным образом параметры стиля содержат палитру и прямоугольники виджетов, которые необходимо отобразить. Большинство виджетов имеют специализированные параметры стиля. QPushButton и QCheckBox, например, используют QStyleOptionButton в качестве своего параметра стиля, который содержит текст, значок и размер значка. Точное содержание всех параметров описано при рассмотрении отдельных виджетов.

При повторной реализации функций QStyle, которые принимают параметр QStyleOption, вам часто необходимо привести параметр QStyleOption к подклассу (например, QStyleOptionFocusRect). Для безопасности можно использовать qstyleoption_cast() для проверки правильности типа указателя. Если объект не является нужного типа, qstyleoption_cast() возвращает nullptr. Например:

const QStyleOptionFocusRect *focusRectOption =
        qstyleoption_cast<const QStyleOptionFocusRect *>(option);
if (focusRectOption) {
    ...
}

Следующий фрагмент кода иллюстрирует, как использовать QStyle для рисования прямоугольника фокуса из пользовательского виджета в функции paintEvent():

void MyWidget::paintEvent(QPaintEvent *event)
{
    QPainter painter(this);
    ...

    QStyleOptionFocusRect option(1);
    option.init(this);
    option.backgroundColor = palette().color(QPalette::Window);

    style().drawPrimitive(QStyle::PE_FrameFocusRect, &option, &painter,
                          this);
}

Следующий пример демонстрирует, как наследоваться от существующего стиля для настройки внешнего вида графического элемента:

class CustomStyle : public QProxyStyle
{
    Q_OBJECT

public:
    CustomStyle();
    ~CustomStyle() {}

    void drawPrimitive(PrimitiveElement element, const QStyleOption *option,
                       QPainter *painter, const QWidget *widget) const override;
};

void CustomStyle::drawPrimitive(PrimitiveElement element, const QStyleOption *option,
                                QPainter *painter, const QWidget *widget) const
{
    if (element == PE_IndicatorSpinUp || element == PE_IndicatorSpinDown) {
        QPolygon points(3);
        int x = option->rect.x();
        int y = option->rect.y();
        int w = option->rect.width() / 2;
        int h = option->rect.height() / 2;
        x += (option->rect.width() - w) / 2;
        y += (option->rect.height() - h) / 2;

        if (element == PE_IndicatorSpinUp) {
            points[0] = QPoint(x, y + h);
            points[1] = QPoint(x + w, y + h);
            points[2] = QPoint(x + w / 2, y);
        } else { // PE_SpinBoxDown
            points[0] = QPoint(x, y);
            points[1] = QPoint(x + w, y);
            points[2] = QPoint(x + w / 2, y + h);
        }

        if (option->state & State_Enabled) {
            painter->setPen(option->palette.mid().color());
            painter->setBrush(option->palette.buttonText());
        } else {
            painter->setPen(option->palette.buttonText().color());
            painter->setBrush(option->palette.mid());
        }
        painter->drawPolygon(points);
    } else {
    QProxyStyle::drawPrimitive(element, option, painter, widget);
    }
}

Функции QStyle

Класс QStyle определяет три функции для рисования примитивных, элементов управления и сложных элементов: drawPrimitive(), drawControl() и drawComplexControl(). Функции принимают следующие параметры:

• значение перечисления элемента для рисования.
• параметр QStyleOption, содержащий информацию, необходимую для рисования элемента.
• объект QPainter для рисования элемента.
• указатель на QWidget, обычно виджет, на котором нарисован элемент.

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

Класс QStyle также предоставляет вспомогательные функции, которые используются при рисовании элементов. Функция drawItemText() рисует текст в заданном прямоугольнике, принимая QPalette в качестве параметра. Функция drawItemPixmap() помогает выровнять пиксель внутри заданного прямоугольника.

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

• Функция subElementRect() принимает значение перечисления SubElement и вычисляет границу подэлемента. Стиль использует эту функцию, чтобы знать, где рисовать различные части элемента. Это в основном делается для повторного использования; если вы создаете новый стиль, вы можете использовать то же положение подэлементов, что и в суперклассе.
• Функция subControlRect() используется для вычисления границ подэлементов управления в сложных элементах управления. При реализации нового стиля вы переопределяете subControlRect() и вычисляете прямоугольники, отличающиеся от суперкласса.
• Функция pixelMetric() возвращает пиксельную метрику, которая представляет собой зависящий от стиля размер в пикселях экрана. Она принимает значение перечисления PixelMetric и возвращает правильное измерение. Обратите внимание, что пиксельные метрики не обязательно должны быть статическими измерениями, но могут вычисляться, например, с использованием параметра стиля.
• Функция hitTestComplexControl() возвращает подэлемент управления, над которым наведен указатель мыши в сложном элементе управления. Обычно это просто вопрос использования subControlRect() для получения границ подэлементов управления, а затем проверки, содержит ли какой-либо прямоугольник положение курсора.

QStyle также имеет функции polish() и unpolish(). Все виджеты отправляются в функцию polish() перед отображением и в функцию unpolish() при их скрытии. Вы можете использовать эти функции для установки атрибутов на виджетах или для выполнения других задач, требуемых вашим стилем. Например, если вам нужно знать, когда курсор находится над виджетом, вам необходимо установить атрибут виджета WA_Hover. Тогда флаг состояния State_MouseOver будет установлен в параметрах стиля виджета.

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

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

Палитра

Каждый стиль предоставляет палитру цветов — то есть, QBrush — которая должна использоваться для рисования виджетов. Существует один набор цветов для различных состояний виджетов (QPalette::ColorGroup): активное (виджеты в окне, у которых есть фокус клавиатуры), неактивное (виджеты, используемые для других окон) и отключенное (виджеты, которые отключены). Состояния можно найти, запросив флаги состояния State_Active и State_Enabled. Каждый набор содержит определённые роли цветов, задаваемые перечислением QPalette::ColorRole. Роли описывают ситуации, в которых цвета должны использоваться (например, для рисования фонов виджетов, текста или кнопок).

Как используются роли цветов, зависит от стиля. Например, если стиль использует градиенты, можно использовать цвет из палитры и сделать его темнее или светлее с помощью QColor::darker() и QColor::lighter() для создания градиента. В общем случае, если вам нужен кисть, который не предоставляется палитрой, вы должны попытаться получить его из одной.

QPalette, который предоставляет палитру, хранит цвета для различных состояний виджетов и ролей цветов. Палитра для стиля возвращается функцией standardPalette(). Стандартная палитра не устанавливается автоматически при установке нового стиля на приложение (QApplication::setStyle()) или виджет (QWidget::setStyle()), поэтому вы должны установить палитру самостоятельно с помощью (QApplication::setPalette()) или (QWidget::setPalette()).

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

Проблемы реализации

При реализации стилей необходимо учитывать несколько проблем. Здесь мы предоставим некоторые подсказки и рекомендации по реализации.

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

Рекомендуется, чтобы стили не изменяли предлагаемый размер виджетов с помощью функции QStyle::sizeFromContents(), а позволили реализации QCommonStyle обрабатывать это вместо этого. Если изменения необходимы, следует стараться делать их небольшими; разработка приложений может быть затруднена, если макет виджетов выглядит существенно по-разному в различных стилях.

Стиль Java

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

В этом разделе мы рассмотрим некоторые проблемы реализации. Наконец, мы увидим полный пример стилизации виджета Java. Мы будем продолжать использовать стиль Java в документе для примеров и изображений виджетов. Сама реализация довольно сложная, и не предполагается, что вы будете читать её целиком.

Проектирование и реализация

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

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

Ограничения и отличия от Java

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

Не все виджеты реализуют все состояния. Это относится к общим состояниям, например, State_Disabled. Однако каждое состояние реализовано по крайней мере для одного виджета.

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

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

Мы жёстко закодировали цвета (мы не используем QPalette) для линейных градиентов, которые используются, например, для наклонов кнопок, панелей инструментов и флажков. Это связано с тем, что палитра Java не может генерировать эти цвета. Java также не изменяет эти цвета в зависимости от группы цветов или роли виджета (они не зависят от палитры), поэтому это не проблема в любом случае.

Стилизуются виджеты Qt. Некоторые виджеты вообще не существуют в Java, например, QToolBox. Другие содержат элементы, которых нет в виджетах Java. Деревовидный виджет является примером последнего, в котором в Java JTree нет заголовка.

Стиль не обрабатывает обратные макеты. Мы предполагаем, что направление макета слева направо. QCommonStyle обрабатывает обратные виджеты; если бы мы реализовали обратные макеты, виджеты, которые мы изменяем позицию дочерних элементов или сами обрабатываем выравнивание текста в метках, необходимо было бы обновить.

Стилизация флажков Java

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

Мы начнём с просмотра того, как QCheckBox создаёт свой вариант стиля, который является QStyleOptionButton для флажков:

    opt.initFrom(q);
        if (down)
        opt.state |= QStyle::State_Sunken;
    if (tristate && noChange)
        opt.state |= QStyle::State_NoChange;
    else
        opt.state |= checked ? QStyle::State_On :
        QStyle::State_Off;
    if (q->testAttribute(Qt::WA_Hover) &&  q->underMouse()) {
        if (hovering)
        opt.state |= QStyle::State_MouseOver;
        else
        opt.state &= ~QStyle::State_MouseOver;
    }
    opt.text = text;
    opt.icon = icon;
    opt.iconSize = q->iconSize();

Сначала мы позволим QStyleOption настроить вариант с информацией, общей для всех виджетов с initFrom(). Мы рассмотрим это вскоре.

Переменная down QStyleOption равна true при нажатии пользователем на поле; это верно для флажка, независимо от того, отмечен он или нет. Состояние State_NoChange устанавливается, когда у нас есть трёхсостояниевый флажок и он частично отмечен. Он имеет значение State_On если поле отмечено и State_Off если оно не отмечено. State_MouseOver устанавливается, если курсор мыши находится над флажком и виджет имеет свойство Qt::WA_Hover установленное — вы устанавливаете это в QStyle::polish(). Кроме того, вариант стиля также содержит текст, значок и размер значка кнопки.

initFrom() устанавливает вариант стиля с атрибутами, общими для всех виджетов. Мы печатаем его реализацию здесь:

    state = QStyle::State_None;
    if (widget->isEnabled())
        state |= QStyle::State_Enabled;
    if (widget->hasFocus())
        state |= QStyle::State_HasFocus;
    if (widget->window()->testAttribute(Qt::WA_KeyboardFocusChange))
        state |= QStyle::State_KeyboardFocusChange;
    if (widget->underMouse())
        state |= QStyle::State_MouseOver;
    if (widget->window()->isActiveWindow())
        state |= QStyle::State_Active;
#ifdef QT_KEYPAD_NAVIGATION
    if (widget->hasEditFocus())
        state |= QStyle::State_HasEditFocus;
#endif

    direction = widget->layoutDirection();
    rect = widget->rect();
    palette = widget->palette();
    fontMetrics = widget->fontMetrics();

State_Enabled устанавливается, когда виджет включён. Когда у виджета фокус, устанавливается флаг State_HasFocus. Аналогично, флаг State_Active устанавливается, когда виджет является дочерним элементом активного окна. Флаг State_MouseOver будет установлен только в том случае, если у виджета установлен флаг окна WA_HoverEnabled. Обратите внимание, что для включения State_HasEditFocus в Qt необходимо включить навигацию с помощью клавиатуры; она не включена по умолчанию.

Помимо установки флагов состояния, QStyleOption содержит другую информацию о виджете: direction — направление макета, rect — ограничивающая прямоугольник виджета (область, в которой нужно рисовать), palette — QPalette, который следует использовать для рисования виджета, и fontMetrics — метрики шрифта, используемого виджетом.

Мы даём изображение флажка и соответствующий ему вариант стиля.

У вышеуказанного флажка в его варианте стиля будут следующие флаги состояний:

Флажок QCheckBox рисует себя в QWidget::paintEvent() с вариантом стиля opt и QStylePainter p. Класс QStylePainter — это вспомогательный класс для рисования элементов стиля. В первую очередь, он оборачивает методы в QStyle, используемые для рисования. Флажок QCheckBox рисует себя следующим образом:

    QStylePainter p(this);
    QStyleOptionButton opt = d->getStyleOption();
    p.drawControl(QStyle::CE_CheckBox, opt);

QCommonStyle обрабатывает элемент CE_CheckBox. Флажок QCheckBox имеет два подэлемента: SE_CheckBoxIndicator (индикатор отмеченного состояния) и SE_CheckBoxContents (содержимое, используемое для метки флажка). QCommonStyle также реализует ограничивающие прямоугольники этих подэлементов. Далее мы рассмотрим код QCommonStyle:

    QStyleOptionButton subopt = *btn;
    subopt.rect = subElementRect(SE_CheckBoxIndicator, btn, widget);
    drawPrimitive(PE_IndicatorCheckBox, &subopt, p, widget);
    subopt.rect = subElementRect(SE_CheckBoxContents, btn, widget);
    drawControl(CE_CheckBoxLabel, &subopt, p, widget);

    if (btn->state & State_HasFocus) {
        QStyleOptionFocusRect fropt;
        fropt.QStyleOption::operator=(*btn);
        fropt.rect = subElementRect(SE_CheckBoxFocusRect, btn, widget);
        drawPrimitive(PE_FrameFocusRect, &fropt, p, widget);
    }

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

Стиль Java рисует CE_CheckBoxIndicator, а QCommonStyle обрабатывает CE_CheckboxLabel. Мы рассмотрим каждую реализацию и начнём с CE_CheckBoxLabel:

    const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(opt);
    uint alignment = visualAlignment(btn->direction, Qt::AlignLeft | Qt::AlignVCenter);

    if (!styleHint(SH_UnderlineShortcut, btn, widget))
        alignment |= Qt::TextHideMnemonic;
    QPixmap pix;
    QRect textRect = btn->rect;
    if (!btn->icon.isNull()) {
        pix = btn->icon.pixmap(btn->iconSize, btn->state & State_Enabled ? QIcon::Normal : QIcon::Disabled);
        drawItemPixmap(p, btn->rect, alignment, pix);
        if (btn->direction == Qt::RightToLeft)
            textRect.setRight(textRect.right() - btn->iconSize.width() - 4);
        else
            textRect.setLeft(textRect.left() + btn->iconSize.width() + 4);
    }
    if (!btn->text.isEmpty()){
        drawItemText(p, textRect, alignment | Qt::TextShowMnemonic,
            btn->palette, btn->state & State_Enabled, btn->text, QPalette::WindowText);
    }

visualAlignment() настраивает выравнивание текста в соответствии с направлением макета. Затем мы рисуем значок, если он существует, и корректируем оставшееся место для текста. drawItemText() рисует текст, учитывая выравнивание, направление макета и мнeмонический символ. Также он использует палитру для рисования текста в правильном цвете.

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

Теперь мы рассмотрим реализацию Java CE_CheckBoxIndicator в drawControl():

        case PE_IndicatorCheckBox: {
            painter->save();
            drawButtonBackground(option, painter, true);

            if (option->state & State_Enabled &&
                option->state & State_MouseOver &&
                !(option->state & State_Sunken)) {
                painter->setPen(option->palette.color(QPalette::Button));
                QRect rect = option->rect.adjusted(1, 1, -2, -2);
                painter->drawRect(rect);
                rect = rect.adjusted(1, 1, -1, -1);
                painter->drawRect(rect);
            }

            if (option->state & State_On) {
                QImage image(":/images/checkboxchecked.png");
                painter->drawImage(option->rect.topLeft(), image);
            }
            painter->restore();
            break;

Сначала мы сохраняем состояние рисовальщика. Это не всегда необходимо, но в этом случае QCommonStyle нуждается в рисовальщике в том же состоянии, что и при вызове PE_IndicatorCheckBox (конечно, мы также могли бы установить состояние с помощью вызовов функций). Затем мы используем drawButtonBackground() для рисования фона индикатора флажка. Это вспомогательная функция, которая рисует фон, а также рамку кнопок и флажков. Мы рассмотрим эту функцию ниже. Затем мы проверяем, находится ли мышь над флажком. Если да, мы рисуем рамку, которая есть у флажков Java, когда ящик не нажат, а мышь находится над ним. Обратите внимание, что Java не обрабатывает трёхсостоятельные флажки, поэтому мы не реализовали эту возможность.

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

void JavaStyle::drawButtonBackground(const QStyleOption *option,
                                     QPainter *painter, bool isCheckbox) const
{
    QBrush buttonBrush = option->palette.button();
    bool sunken = option->state & State_Sunken;
    bool disabled = !(option->state & State_Enabled);
    bool on = option->state & State_On;

    if (!sunken && !disabled && (!on || isCheckbox))
        buttonBrush = gradientBrush(option->rect);

        painter->fillRect(option->rect, buttonBrush);

        QRect rect = option->rect.adjusted(0, 0, -1, -1);

        if (disabled)
            painter->setPen(option->palette.color(QPalette::Disabled,
                                                  QPalette::WindowText));
        else
            painter->setPen(option->palette.color(QPalette::Mid));

        painter->drawRect(rect);

        if (sunken && !disabled) {
            drawSunkenButtonShadow(painter, rect,
                   option->palette.color(QPalette::Mid),
                   option->direction == Qt::RightToLeft);
    }
}

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

Обзор виджетов

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

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

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

• Таблица с членами (переменными и т. д.) его опции стиля.
• Таблица флагов состояния (QStyle::StateFlag), которые могут быть установлены на виджете и при установке состояний.
• Его древовидная структура элементов (см. раздел Элементы стиля).
• Изображение виджета, на котором элементы обведены.

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

Наш подход к стилизации сосредоточен на рисовании виджетов. Вычисления прямоугольников дочерних элементов, дочерних элементов управления и метрик пикселей, используемых во время рисования, перечислены только как содержимое в древовидных структурах элементов. Обратите внимание, что есть прямоугольники и метрики пикселей, которые используются только виджетами. Это оставляет эти вычисления необработанными в обзоре. Например, функции subControlRect() и sizeFromContents() часто вызывают subElementRect() для вычисления своих прямоугольников. Мы также могли бы построить деревья для этого. Однако то, как выполняются эти вычисления, полностью зависит от отдельных стилей, и они не должны следовать определённой структуре (Qt не накладывает определённой структуры). Тем не менее, вы должны убедиться, что используете соответствующие метрики пикселей. Чтобы ограничить размер документа, мы поэтому решили не включать деревья или не описывать вычисления, выполняемые стилем Java (или любым другим).

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

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

Общие свойства виджетов

Некоторые состояния и переменные являются общими для всех виджетов. Они устанавливаются с помощью QStyleOption::initFrom(). Не все элементы используют эту функцию; это виджеты, которые создают опции стиля, и для некоторых элементов информация из initFrom() не нужна.

Следующая таблица содержит общие состояния:

Другие общие члены для виджетов:

Сложные опции стиля (классы, наследующие QStyleOptionComplex) для сложных элементов стиля используют две переменные: subControls и activeSubControls. Обе переменные представляют собой объединённые по оператору OR значения перечисления QStyle::SubControl. Они указывают, из каких подэлементов управления состоит сложное управление и какие из этих элементов управления в настоящее время активны.

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

Справочник по виджетам

Без дальнейших задержек мы представляем обзор виджетов; каждый виджет имеет свой подраздел.

Кнопки

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

Макет кнопок относительно границ элементов варьируется от стиля к стилю. Это затрудняет показ концептуальных изображений. Кроме того, элементы могут — даже должны — иметь одинаковые границы; PE_PushButtonBevel, например, используется в QCommonStyle для рисования элементов, которые он содержит: PE_FrameDefaultButton, PE_FrameButtonBevel, и PE_PanelButtonCommand, все из которых имеют общие границы в общем стиле. PE_PushButtonBevel также отвечает за рисование индикатора меню (QCommonStyle рисует PE_IndicatorArrowDown).

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

Стиль Java, а также все другие стили, реализованные в Qt, не используют PE_FrameButtonBevel. Обычно кнопка с PE_DefaultFrame корректирует прямоугольник PE_PanelButtonCommand на PM_ButtonDefaultIndicator. CE_PushButtonLabel находится путём корректировки rect на PM_DefaultFrameWidth.

Теперь мы рассмотрим опцию стиля для кнопок — QStyleOptionButton. Следующая таблица содержит состояния, которые QPushButton может установить в опции стиля:

Другие члены QStyleOptionButton:

Кнопки "галочки" и радиокнопки

Структуры для радио- и "галочных" кнопок идентичны. Мы демонстрируем структуру на примере элемента QCheckBox и названий пиксельных метрик:

QStyleOptionButton используется в качестве стиля для обеих кнопок. Сначала приведём таблицу состояний, которые можно задать в опции:

См. Кнопки для таблицы других членов класса QStyleOptionButton.

Вкладки

В Qt, QTabBar использует стиль для отрисовки вкладок. Вкладки существуют либо в QTabWidget, который содержит QTabBar, либо как отдельный бар. Если бар не является частью виджета вкладок, он рисует свою собственную основу.

QTabBar выстраивает вкладки, поэтому стиль не контролирует расположение вкладок. Однако, выстраивая свои вкладки, бар запрашивает у стиля PM_TabBarTabHSpace и PM_TabBarTabVSpace, что представляет собой дополнительную ширину и высоту по отношению к минимальному размеру метки вкладки (иконки и текста). Стиль также может влиять на размер вкладки до ее выстраивания, так как таб бар запрашивает CT_TabBarTab. Граница прямоугольника бара определяется виджетом вкладок, когда он является частью виджета (при этом учитывается CT_TabBarTab).

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

Вот структура стиля для QTabWidget и QTabBar:

Пунктирные линии указывают, что QTabWidget содержит вкладку, но не рисует её сам. QTabBar рисует только свою базовую линию, когда не является частью виджета вкладок, и сохраняет две кнопки инструментов для прокрутки бара, когда все вкладки не помещаются; см. Кнопки инструментов для их структуры элементов. Также обратите внимание, что, поскольку кнопки являются дочерними элементами бара вкладок, они отрисовываются после бара. Границы прямоугольников вкладок перекрывают базу на PM_TabBarBaseOverlap.

Вот виджет вкладок в стиле Java:

В стиле Java форма и метка вкладки имеют ту же область прямоугольника, что и CE_TabBarTab. Обратите внимание, что вкладки перекрывают рамку виджета вкладок. Основание бара вкладок (если отрисовано) — это область, где вкладки и рамка перекрываются.

Опция стиля для вкладок (QStyleOptionTab) содержит необходимую информацию для отрисовки вкладок. Опция содержит положение вкладки в баре вкладок, положение выделенной вкладки, форму вкладки, текст, иконку и размер иконки.

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

Ниже приводится таблица состояний, которые бар вкладок может устанавливать на своих вкладках:

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

Следующая таблица содержит члены QStyleOptionTab:

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

Скроллбары

Вот структура стиля для скроллбаров:

QScrollBar просто создаёт свою опцию стиля, а затем рисует CC_ScrollBar. Некоторые стили рисуют фон страницы добавления и страницы удаления с помощью PE_PanelButtonBevel, а также используют индикаторные стрелки для отрисовки стрелок в индикаторах следующей и предыдущей строк; мы не включили их в дерево, так как их использование зависит от конкретного стиля. PM_MaximumDragDistance стиля — это максимальное расстояние в пикселях, на которое мышь может отойти от границ скроллбара и при этом перемещать ползунок.

Вот изображение скроллбара в стиле Java:

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

Давайте рассмотрим различные состояния, которые скроллбар может установить в опции стиля:

Опция стиля для QScrollBar — QStyleOptionSlider. Её члены перечислены в следующей таблице. Опция используется всеми QAbstractSlider; мы описываем здесь только члены, относящиеся к скроллбарам.

Ползунки

При расчёте размера подсказки ползунка запрашиваются PM_SliderThickness и PM_SliderLength у стиля. Как и с скроллбарами, QSlider позволяет пользователю перемещать ползунок только если мышь находится в пределах PM_MaximumDragDistance от границ ползунка. При отрисовке он создаёт опцию стиля и вызывает drawComplexControl() с CC_Slider:

Мы также покажем изображение ползунка в стиле Java. Мы покажем области прямоугольников подэлементов, так как вся отрисовка выполняется в CC_Slider.

QSlider использует QStyleOptionSlider, как и все QAbstractSlider. Мы представляем таблицу с членами, которые влияют на QSlider:

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

Поле ввода со списком

Когда QSpinBox рисует себя, он создает QStyleOptionSpinBox и просит стиль нарисовать CC_SpinBox. Поле ввода — это поле редактирования, являющееся дочерним элементом поля ввода со списком. Размеры поля рассчитываются стилем с помощью SC_SpinBoxEditField.

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

QStyleOptionSpinBox, который является опцией стиля для полей ввода со списком. Он может устанавливать следующие состояния на поле ввода со списком:

Остальные члены в параметрах стиля поля ввода со списком:

Панель заголовка

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

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

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

Опция стиля для панелей заголовков — QStyleOptionTitleBar. Ее члены:

Комбо-бокс

QComboBox использует стиль для рисования кнопки и метки нередактируемых полей с помощью CC_ComboBox и CE_ComboBoxLabel.

Список, который появляется при щелчке по комбо-боксу, рисуется делегатом, который мы не рассматриваем в этом обзоре. Однако вы можете использовать стиль для управления размером и положением списка с помощью подэлемента SC_ComboBoxListBoxPopup. Стиль также определяет, где должно располагаться поле редактирования для редактируемых полей с помощью SC_ComboBoxEditField; само поле — это QLineEdit, являющийся дочерним элементом комбо-бокса.

Комбо-боксы Java не используют прямоугольник фокуса; они меняют цвет фона при фокусе. Поле SC_ComboBoxEdit используется как QComboBox для расчета размера поля редактирования, так и стилем для расчета размера метки комбо-бокса.

Опция стиля для комбо-боксов — QStyleOptionComboBox. Он может устанавливать следующие состояния:

Другие члены опций стиля:

Групповые поля

При расчете размера подсказки QGroupBox получает три метрики пикселей от стиля: PM_IndicatorWidth, PM_CheckBoxLabelSpacing, и PM_IndicatorHeight. QGroupBox имеет следующее дерево элементов стиля:

Qt не накладывает ограничений на то, как рисуется флажок; стиль Java рисует его с использованием CE_IndicatorCheckBox. См. Флажки и радиокнопки для полного дерева.

Мы также даём изображение виджета с нарисованными подконтрольными элементами и их прямоугольниками:

Опция стиля для групповых полей — QStyleOptionGroupBox. Следующие состояния могут быть установлены на ней:

Остальные члены QStyleOptionGroupBox:

Разделители

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

Для своей опции стиля разделитель использует базовый класс QStyleOption. Он может установить следующие флаги состояния:

QSplitter не использует initFrom() для настройки своей опции; он устанавливает флаги State_MouseOver и State_Disabled самостоятельно.

Полоса прогресса

Элемент CE_ProgressBar используется QProgressBar, и это единственный элемент, используемый этим виджетом. Начинаем со структуры стиля:

Вот полоса прогресса в стандартном стиле (прямоугольники стиля Java равны):

Опция стиля для QProgressBar — QStyleOptionProgressBar. Полоса не устанавливает никаких флагов состояния, но другие члены опции:

Кнопки инструментов

Кнопки инструментов существуют либо независимо, либо как часть панелей инструментов. Они рисуются одинаково в обоих случаях. QToolButton рисует только один элемент стиля: CC_ToolButton.

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

Обратите внимание, что PE_FrameButtonTool и PE_IndicatorArrowDown включены в дерево, так как стиль Java их рисует, но их можно безопасно опустить, если вы этого предпочитаете. Структура также может быть другой. QCommonStyle, например, рисует как PE_IndicatorButtonDropDown и PE_IndicatorArrowDown в CE_ToolButton.

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

Вот таблица состояний для кнопок инструментов:

QStyleOptionToolButton также содержит следующие члены:

Панели инструментов

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

Панели инструментов в Qt состоят из трёх элементов: CE_ToolBar, PE_IndicatorToolBarHandle, и PE_IndicatorToolBarSeparator. Именно QMainWindowLayout вычисляет ограничивающие прямоугольники (т.е., положение и размер панелей инструментов и их содержимого. Главное окно также использует sizeHint() элементов в панелях инструментов при вычислении размера панелей.

Вот дерево элементов для QToolBar:

Штриховые линии указывают на то, что QToolBar хранит экземпляр QToolBarLayout и QToolBarSeparators хранятся QToolBarLayout. Когда панель инструментов находится во всплывающем окне (т.е., имеет собственное окно), рисуется элемент PE_FrameMenu, иначе QToolBar рисует CE_ToolBar.

Вот изображение панели инструментов в стиле Java:

QToolBarSaparator использует QStyleOption в качестве своей опции стиля. Он устанавливает флаг State_Horizontal если панель инструментов, в которой он находится, горизонтальна. Помимо этого, они используют initFrom().

Опция стиля для QToolBar — QStyleOptionToolBar. Единственный флаг состояния, установленный (кроме общих флагов), — State_Horizontal если панель горизонтальна (т.е., в области панели инструментов «север» или «юг»). Переменные членов опции стиля:

Меню

Меню в Qt реализованы в QMenu. QMenu хранит список действий, которые он рисует как пункты меню. Когда QMenu получает события рисования, он вычисляет размер каждого пункта меню и рисует их индивидуально с помощью CE_MenuItem. Пункты меню не имеют отдельного элемента для своей метки (содержимого), поэтому все рисование выполняется в CE_MenuItem. Меню также рисует рамку меню с помощью PE_FrameMenu. Он также рисует CE_MenuScroller если стиль поддерживает прокрутку. CE_MenuTearOff рисуется, если меню слишком велико для его ограничивающего прямоугольника.

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

Элементы CE_MenuScroller и CE_MenuTearOff обрабатываются QCommonStyle и не отображаются, если меню слишком велико для экрана. PE_FrameMenu рисуется только для всплывающих меню.

QMenu рассчитывает прямоугольники на основе своих действий и вызывает CE_MenuItem и CE_MenuScroller если стиль поддерживает это.

Также обычно используется PE_IndicatorCheckBox (вместо PE_IndicatorMenuCheckMark) и PE_IndicatorRadioButton для рисования переключаемых пунктов меню; мы не включили их в дерево стиля, так как это необязательно и зависит от конкретного стиля.

Опция стиля для пунктов меню — QStyleOptionMenuItem. Следующие таблицы описывают флаги состояния и другие члены.

Настройка опции стиля для CE_MenuTearOff и CE_MenuScroller также использует QStyleOptionMenuItem; они только устанавливают переменную menuRect в дополнение к общим настройкам с QStyleOption's initFrom().

Панель меню

QMenuBar использует стиль для рисования каждого элемента панели меню и пустой области панели меню. Всплывающие меню сами являются QMenu (см. Меню). Дерево элементов стиля для панели меню:

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

QStyleOptionMenuItem используется для элементов панели меню. Члены, используемые QMenuBar, описаны в следующей таблице:

QStyleOptionMenuItem также используется для рисования CE_EmptyMenuBarArea.

QStyleOptionFrame используется для рисования рамки панели. lineWidth устанавливается в PM_MenuBarPanelWidth. midLineWidth в настоящее время всегда устанавливается в 0.

Заголовки элементов

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

Вот QTableWidget, показывающий ограничивающие прямоугольники заголовка Java:

QHeaderView использует CT_HeaderSection, PM_HeaderMargin и PM_HeaderGripMargin для вычислений размера и попадания в область. PM_HeaderMarkSize в настоящее время не используется Qt. QTableView рисует кнопку в верхнем левом углу (т. е., в области пересечения вертикального и горизонтального заголовков) как CE_Header.

Стиль-опция для заголовков представлений — QStyleOptionHeader. Представление рисует один раздел заголовка за раз, поэтому данные относятся к разделу, который рисуется. Его содержимое:

Индикаторы ветвей дерева

Индикаторы ветвей в представлении дерева рисуются стилем с помощью PE_IndicatorBranch. Мы рассматриваем индикаторы здесь как индикаторы, описывающие отношения узлов в дереве. Для рисования этих элементов в стиль отправляется общий QStyleOption. Различные типы ветвей описываются состояниями. Поскольку нет специальной опции стиля, мы просто представим таблицу состояний:

Представление дерева (и виджет дерева) использует стиль для рисования ветвей (узлов) дерева.

QStyleOption используется как стиль для PE_IndicatorBranch с установками флагов состояния в зависимости от того, какой ветвью она является.

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

Панели инструментов

PM_SmallIconSize для подсказок размера.

QToolBox — это контейнер, который хранит набор виджетов. У него есть одна вкладка для каждого виджета, и он отображает один из них за раз. Панель инструментов выкладывает отображаемые компоненты (кнопки панели инструментов и выбранный виджет) в QVBoxLayout.

Мы показываем изображение панели инструментов в стиле Plastique:

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

Опция стиля для панелей инструментов — QStyleOptionToolBox. Она содержит текст и иконку содержимого панели инструментов. Единственное состояние, устанавливаемое QToolBox, — State_Sunken, которое устанавливается, когда пользователь нажимает вкладку мышью. Остальные члены QStyleOptionToolBox:

Маркер размера

Маркер размера вычисляет свою подсказку размера с помощью CT_SizeGrip. Метрика пикселей PM_SizeGripSize в настоящее время не используется Qt. Дерево элементов для изображения в стиле Plastique QSizeGrip имеет следующий вид:

Мы показываем маркер размера в правом нижнем углу QMainWindow.

Опция стиля маркера размера, QStyleOptionSizeGrip, помимо общих членов из QStyleOption имеет один член:

Резиновая полоса

Дерево стиля QRubberBand состоит из двух узлов.

Мы представляем изображение перемещения окна в стиле Java в QMdiArea с резиновой полосой:

Опция стиля для резиновых полос — QStyleOptionRubberBand. Ее члены:

Виджеты доков

При разметке содержимого виджета доков он запрашивает у стиля эти метрики пикселей: PM_DockWidgetSeparatorExtent, PM_DockWidgetTitleBarButtonMargin, PM_DockWidgetFrameWidth, и PM_DockWidgetTitleMargin. Он также вычисляет ограничивающие прямоугольники кнопок плавания и закрытия с помощью SE_DockWidgetCloseButton и SE_DockWidgetFloatButton.

Пунктирные линии указывают, что отправитель сохраняет экземпляры получателя стрелки (т. е., это не элемент стиля для рисования). Виджет доков рисует PE_frameDockWidget только тогда, когда он отделен от основного окна (т. е., это окно верхнего уровня). Если он прикреплен, он рисует индикатор ручки изменения размера виджета дока. Мы показываем виджет дока в прикрепленном и плавающем состоянии в стиле plastique:

Опция стиля — QStyleOptionDockWidget:

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