Справочная документация по Qt

Оглавление

Каркас Графического представления

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

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

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

Графическое представление было введено в Qt 4.2 и заменило своего предшественника, класс QCanvas. О том как выполнить перенос кода, использующего QCanvas, смотрите Переход на Графическое представление.

Темы:

Архитектура графического представления

Графическое представление предоставляет основанный на элементах подход к программированию модель-представление, вроде вспомогательных классов InterView: QTableView, QTreeView и QListView. Несколько представлений могут отображать одну и ту же сцену, а сцена может содержать элементы самой разнообразной геометрической формы.

Сцена

Класс QGraphicsScene предоставляет сцену графического представления. Сцена выполняет следующие обязанности:

Сцена выступает в качестве контейнера для объектов QGraphicsItem. Элементы добавляются в сцену с помощью вызова QGraphicsScene::addItem(), а затем их можно получить с помощью вызова одной из множества функций обнаружения элементов. QGraphicsScene::items() и его перегруженные варианты возвращают все элементы, содержащиеся или пересекающиеся с точкой, прямоугольником, многоугольником или основной траекторией вектора. QGraphicsScene::itemAt() возвращает самый верхний элемент в данной точке. Все функции обнаружения элемента возвращают элементы в порядке убывания наложения элементов (т.е. первым возвращается самый верхний, а последним - самый нижний).

 QGraphicsScene scene;
 QGraphicsRectItem *rect = scene.addRect(QRectF(0, 0, 100, 100));

 QGraphicsItem *item = scene.itemAt(50, 50);
 // item == rect

Архитектура передачи событий QGraphicsScene планирует события сцены для доставки каждому элементу, а также управляет их распространением между элементами. Если сцена получает событие о нажатии кнопки мыши в какой-либо точке, посылается событие всем элементам, которые находятся в этой позиции.

QGraphicsScene также управляет определёнными состояниями элементов, такими как выбор и фокус элемента. Вы можете выбрать элементы в сцене с помощью вызова QGraphicsScene::setSelectionArea(), передав любую фигуру. Эта функциональность также используется как базовая для выделения с резиновыми линиями (rubberband selection) в QGraphicsView. Для получения списка всех выбранных сейчас элементов вызовите QGraphicsScene::selectedItems(). Другим состоянием, обрабатываемым QGraphicsScene, является наличие или отсутствие фокуса ввода с клавиатуры у элемента. Вы можете установить фокус элементу с помощью вызова QGraphicsScene::setFocusItem() или QGraphicsItem::setFocus(), или получить текущий элемент с фокусом вызвав QGraphicsScene::focusItem().

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

Представление

QGraphicsView предоставляет виджет представления (view widget), который визуализирует содержимое сцены. Вы можете присоединить несколько представлений к одной и той же сцене, чтобы предоставить несколько окон просмотра одного и того же набора данных. Виджет представления является прокручиваемой областью, и предоставляет линейки прокрутки для навигации по большим сценам. Для разрешения поддержки OpenGL, вы можете установить QGLWidget как окно просмотра с помощью вызова QGraphicsView::setViewport().

 QGraphicsScene scene;
 myPopulateScene(&scene);

 QGraphicsView view(&scene);
 view.show();

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

Используя свои преобразования матриц, QGraphicsView::transform(), представление может преобразовать систему координат сцены. Это позволяет использовать расширенные возможности навигации, такие как масштабирование и вращение. Для удобства, QGraphicsView также предоставляет функции преобразования между координатами представления и сцены: QGraphicsView::mapToScene() и QGraphicsView::mapFromScene().

Элемент

QGraphicsItem - базовый класс для графических элементов сцены. Графическое представление предоставляет несколько стандартных элементов для обычных фигур, таких как прямоугольники (QGraphicsRectItem), эллипсы (QGraphicsEllipseItem) и текстовые элементы (QGraphicsTextItem), но наиболее мощные возможности QGraphicsItem доступны когда вы создаете пользовательский элемент. Между прочим, QGraphicsItem поддерживает следующие возможности:

Элементы существуют в локальной системе координат, и подобно QGraphicsView, они также предоставляют множество функций для отображения из координат элемента в координаты сцены, и между элементами. Также, подобно QGraphicsView, они могут преобразовать свою систему координат используя матрицу: QGraphicsItem::transform(). Это полезно при вращении и масштабировании отдельных элементов.

Элементы могут содержать другие элементы (дочерние). Преобразования элементов-родителей наследуются всеми потомками. Однако независимо от суммарного преобразования элемента, все его функции (например, QGraphicsItem::contains(), QGraphicsItem::boundingRect(), QGraphicsItem::collidesWith()) по-прежнему работают в локальных координатах.

QGraphicsItem поддерживает обнаружение столкновений посредством функций QGraphicsItem::shape() и QGraphicsItem::collidesWith(), которые являются виртуальными. Возвращая фигуру вашего элемента как локальную координату QPainterPath из QGraphicsItem::shape(), QGraphicsItem будет обрабатывать для вас все обнаружения столкновений. Тем не менее, если вы хотите предоставить собственное обнаружение столкновений, вы можете переопределить QGraphicsItem::collidesWith().

Классы в каркасе Графического представления

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

QAbstractGraphicsShapeItem

Общая основа для всех элементов траекторий

QGraphicsAnchor

Представляет якорь между двумя элементами в QGraphicsAnchorLayout

QGraphicsAnchorLayout

Компоновщик, в котором можно скреплять виджеты вместе в графическом представлении

QGraphicsEffect

Базовый класс для всех графических эффектов

QGraphicsEllipseItem

Элемент эллипса, который вы можете добавить в QGraphicsScene

QGraphicsGridLayout

Компоновка-сетка для управления виджетами в графическом представлении

QGraphicsItem

Базовый класс для графических элементов в QGraphicsScene

QGraphicsItemAnimation

Поддержка простой анимации для QGraphicsItem

QGraphicsItemGroup

Контейнер, который рассматривает группу элементов в качестве единого элемента

QGraphicsLayout

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

QGraphicsLayoutItem

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

QGraphicsLineItem

Элемент линии, который вы можете добавить в QGraphicsScene

QGraphicsLinearLayout

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

QGraphicsObject

Базовый класс для всех графических элементов, которым требуются сигналы, слоты и свойства

QGraphicsPathItem

Элемент траектории (path), который вы можете добавить в QGraphicsScene

QGraphicsPixmapItem

Элемент растрового изображения (pixmap), который вы можете добавить в QGraphicsScene

QGraphicsPolygonItem

Элемент многоугольник, который вы можете добавить в QGraphicsScene

QGraphicsProxyWidget

Компоновка-посредник для встраивания QWidget в QGraphicsScene

QGraphicsRectItem

Элемент прямоугольник, который вы можете добавить в QGraphicsScene

QGraphicsScene

Поверхность для управления большим числом графических 2D элементов

QGraphicsSceneContextMenuEvent

События контекстного меню в библиотеке графического отображения

QGraphicsSceneDragDropEvent

События перетаскивания (drag and drop) в каркасе графического представления

QGraphicsSceneEvent

Базовый класс для всех событий, связанных с графическим представлением

QGraphicsSceneHelpEvent

События при запросе всплывающей подсказки (tooltip)

QGraphicsSceneHoverEvent

События наведения на объект в каркасе графического представления

QGraphicsSceneMouseEvent

События мыши в каркасе графического представления

QGraphicsSceneMoveEvent

События перемещения виджетов в каркасе графического представления

QGraphicsSceneResizeEvent

События изменения размеров виджетов в каркасе графического представления

QGraphicsSceneWheelEvent

События колеса прокрутки в каркасе графического представления

QGraphicsSimpleTextItem

Элемент простого текста, который вы можете добавить в QGraphicsScene

QGraphicsSvgItem

QGraphicsItem, который может быть использован для отображения SVG-файлов

QGraphicsTextItem

Текстовый элемент, который вы можете добавить в QGraphicsScene для отображения отформатированного текста

QGraphicsTransform

Абстрактный базовый класс для построения сложных преобразований над QGraphicsItem

QGraphicsView

Виджет для показа содержимого QGraphicsScene

QGraphicsWidget

Базовый класс для всех элементов виджетов в QGraphicsScene

QStyleOptionGraphicsItem

Используется для описания параметров, требующихся для рисования QGraphicsItem

Система координат графического представления

Графическое представление основано на декартовой системе координат; положение и геометрия элементов на сцене представляется наборами из пары чисел: x-координаты и y-координаты. Когда сцену наблюдают с использованием непреобразованного вида, один элемент сцены изображается одним пикселем на сцене.

Замечание: Система координат с опрокинутой осью Y (где y растёт вверх) не поддерживаются как Графические представления используют систему координат Qt.

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

При визуализации координаты сцены графического представления согласовываются с логическими координатами QPainter'а, а координаты представления - это те же самые координаты устройства. В документации по Системе координат вы можете прочитать о соотношении между логическими координатами и координатами устройства.

Координаты элемента

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

При создании пользовательского элемента все, о чем вам необходимо побеспокоиться - это о его координатах; QGraphicsScene и QGraphicsView выполнят для вас любые преобразования. Это делает реализацию пользовательских элементов чрезвычайно легкой. Например, если вы получаете событие нажатия кнопки мыши или событие начала перетаскивания, место события задается в координатах элемента. Виртуальная функция QGraphicsItem::contains(), которая возвращает true если определенная точка находится внутри вашего элемента, и false в противном случае, принимает аргумент точки в координатах элемента. Аналогично, ограничивающий прямоугольник элемента и его форма заданы в координатах элемента.

Положение элемента - это координаты центральной точки элемента в координатной системе его родителя; иногда называемые родительскими координатами. Сцена, в этом смысле, рассматривается как "родитель" всех элементов не имеющих родителя. Положение элементов верхнего уровня задается в координатах сцены.

Дочерние координаты являются относительными к родительским координатам. Если дочерний элемент не подвергался преобразованиям, разница между дочерними координатами и родительскими координатами равна расстоянию между элементами в родительских координатах. Например: Если дочерний элемент, не подвергавшийся преобразованиям, находится точно в центральной точке родителя, то обе координатные системы элементов будут тождественными. Если дочерний элемент расположен в точке (10, 0), несмотря на это точка дочернего элемента (0, 10) будет соответствовать точке родителя (10, 10).

Так как положение элементов и преобразование задаются относительно родителя, дочерние координаты элемента являются неизменными при преобразованиях родителя несмотря на то, что преобразования родителя полностью преобразуют и дочерний элемент. В приведенном выше примере даже если вращать и масштабировать родителя, дочерняя точка (0, 10) будет по-прежнему соответствовать родительской точке (10, 10). Однако, относительно сцены дочерний элемент будет повторять преобразования родителя и его положение. Если родитель масштабируется (2x, 2x), то положение дочернего элемента в координатах сцены будет (20, 0), а его точка (10, 0) будет соответствовать точке (40, 0) на сцене.

С помощью QGraphicsItem::pos(), являющейся одной из нескольких исключений, функции QGraphicsItem оперируют с координатами элемента независимо от элемента или любых преобразований его родителя. Например, ограничивающий прямоугольник элемента (т.е. QGraphicsItem::boundingRect()) всегда задается в координатах элемента.

Координаты сцены

Сцена представляет базовую систему координат для всех своих элементов. Система координат сцены описывает позицию каждого элемента верхнего уровня, а также формирует основу для всех событий сцены, доставляемых в сцену из представления. Каждый элементе на сцене имеет сценическую позицию (scene position) и ограничивающий прямоугольник (QGraphicsItem::scenePos(), QGraphicsItem::sceneBoundingRect()), в дополнение к своей локальному положению элемента и ограничивающему прямоугольнику. Сценическая позиция описывает положение элемента в координатах сцены, а его сценический ограничивающий прямоугольник (scene bounding rect) образует основу того, как QGraphicsScene определяет какие области сцены изменились. Об изменениях в сцене сообщает сигнал QGraphicsScene::changed(), а аргументом является список сценических прямоугольников (scene rectangles).

Координаты представления

Координаты представления являются координатами виджета. Каждая единица в координатах представления соответствует одному пикселю. Что особенного с этой координатной системой, так это то, что она относится к виджету или окну просмотра и не изменяется наблюдаемой сценой. Верхний левый угол окна просмотра QGraphicsView всегда равен (0, 0), а нижний правый угол всегда равен (ширина окна просмотра, высота окна просмотра). Все события мыши и события перетаскивания (drag and drop) первоначально получаются как координаты представления, и вам нужно по порядку отобразить эти координаты на сцену для взаимодействия с элементами.

Преобразование координат

Когда имеешь дело с элементами на сцене, часто бывает полезным преобразовать координаты и произвольные фигуры из координат сцены в координаты элемента, из координат элемента в координаты другого элемента или из координат представления в координаты сцены. Например, когда вы щелкаете кнопкой мыши в окне просмотра QGraphicsView, вы можете запросить сцену о том, какой элемент находится под курсором, вызвав QGraphicsView::mapToScene(), а затем QGraphicsScene::itemAt(). Если вы хотите узнать, где в окне просмотра располагается элемент, то вы можете вызвать для элемента QGraphicsItem::mapToScene(), затем для окна просмотра QGraphicsView::mapFromScene(). В заключение, если вы хотите найти какие элементы находятся внутри видимого эллипса (view ellipse), вы можете передать QPainterPath в mapToScene(), а затем передать отображенную траекторию в QGraphicsScene::items().

Вы можете преобразовывать координаты элемента и фигуры в координаты сцены и обратно вызывая QGraphicsItem::mapToScene() и QGraphicsItem::mapFromScene(). Вы можете также отображать в координаты родительского элемента вызывая QGraphicsItem::mapToParent() и QGraphicsItem::mapFromParent(), или между элементами - вызывая QGraphicsItem::mapToItem() и QGraphicsItem::mapFromItem(). Все функции преобразования могут отображать точки, прямоугольники, многоугольники и траектории.

Такие же функции преобразования доступны в представлении для отображения на сцену и из сцены. QGraphicsView::mapFromScene() и QGraphicsView::mapToScene(). Для преобразования из координат представления в координаты элемента, сначала преобразуйте в координаты сцены, а затем преобразуйте из координат сцены в координаты элемента.

Основные возможности

Масштабирование и вращение

QGraphicsView поддерживает такие же аффинные преобразования (affine transformations), что и QPainter через QGraphicsView::setMatrix(). Применив преобразование к представлению, вы легко можете добавить поддержку общих возможностей навигации таких, как масштабирование и вращение.

Вот пример как реализовать масштабирование и вращение слотов в подклассе QGraphicsView:

 class View : public QGraphicsView
 {
 Q_OBJECT
     ...
 public slots:
     void zoomIn() { scale(1.2, 1.2); }
     void zoomOut() { scale(1 / 1.2, 1 / 1.2); }
     void rotateLeft() { rotate(-10); }
     void rotateRight() { rotate(10); }
     ...
 };

Слоты могут быть соединены с QToolButtons с разрешенным autoRepeat.

QGraphicsView сохраняет центр выравнивания представления при преобразовании представления.

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

Печать

Графическое представление предоставляет построчную печать (single-line printing) посредством своих функций визуализации, QGraphicsScene::render() и QGraphicsView::render(). Функции предоставляют одинаковый API: Вы можете полностью визуализировать сцену или представление или же часть их содержимого в любое устройство рисования с помощью передачи QPainter в ту или другую функцию визуализации. Этот пример показывает как распечатать всю сцену на всю страницу, используя QPrinter.

 QGraphicsScene scene;
 scene.addRect(QRectF(0, 0, 100, 200), QPen(Qt::black), QBrush(Qt::green));

 QPrinter printer;
 if (QPrintDialog(&printer).exec() == QDialog::Accepted) {
     QPainter painter(&printer);
     painter.setRenderHint(QPainter::Antialiasing);
     scene.render(&painter);
 }

Разница между функциями визуализации сцены и представления заключается в том, что одна оперирует в координатах сцены, а другая - в координатах представления. QGraphicsScene::render() часто является более предпочтительной для печати целых сегментов непреобразованной сцены, например, для построения геометрических данных или печати текстового документа. С другой стороны, QGraphicsView::render() подходит для получения снимков экрана; ее поведение по умолчанию - точно отобразить содержимое окна просмотра, используя предоставленного рисовальщика (painter).

 QGraphicsScene scene;
 scene.addRect(QRectF(0, 0, 100, 200), QPen(Qt::black), QBrush(Qt::green));

 QPixmap pixmap;
 QPainter painter(&pixmap);
 painter.setRenderHint(QPainter::Antialiasing);
 scene.render(&painter);
 painter.end();

 pixmap.save("scene.png");

Когда размеры областей источника и приемника не совпадают, содержимое источника масштабируется так, чтобы поместиться в область приемника. Передавая Qt::AspectRatioMode в используемую вами функцию визуализации, вы можете выбрать сохранять или игнорировать коэффициент сжатия (aspect ratio) при масштабировании содержимого сцены.

Перетаскивание (Drag and Drop)

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

Для начала перетаскивания из элемента, создается объект QDrag, передается указатель на виджет с которого начинается перетаскивание. Элементы могут отображаться во многих представлениях в одно и то же время, но только одно представление может начать перетаскивание. Перетаскивание во многих случаях начинается как результат нажатия или перемещения мыши, поэтому в mousePressEvent() или mouseMoveEvent(), вы может получить из события порождаемый виджетом указатель. Например:

 void CustomItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
 {
     QMimeData *data = new QMimeData;
     data->setColor(Qt::green);

     QDrag *drag = new QDrag(event->widget());
     drag->setMimeData(data);
     drag->start();
 }

Для перехвата событий перетаскивания сцены, переопределите QGraphicsScene::dragEnterEvent() и те обработчики событий, которые требуются вашей сцене, в подклассе QGraphicsItem. Прочитать больше о перетаскивании в графическом представлении можно в документации для каждого обработчика событий QGraphicsScene.

Элементы могут разрешить поддержку перетаскивания вызывая QGraphicsItem::setAcceptDrops(). Для обработки входящего перетаскивания, переопределите QGraphicsItem::dragEnterEvent(), QGraphicsItem::dragMoveEvent(), QGraphicsItem::dragLeaveEvent() и QGraphicsItem::dropEvent().

Смотрите также пример Drag and Drop Robot для демонстрации поддержки операций перетаскивания в графическом представлении.

Курсоры и всплывающие подсказки (Tooltips)

Аналогично QWidget, QGraphicsItem также поддерживает курсоры (QGraphicsItem::setCursor()) и всплывающие подсказки (tooltips) (QGraphicsItem::setToolTip()). Курсоры и всплывающие подсказки активируются с помощью QGraphicsView при входе курсора мыши в область элемента (обнаруживается с помощью вызова QGraphicsItem::contains()).

Вы можете также установить курсор по умолчанию непосредственно в представлении вызвав QGraphicsView::setCursor().

Смотрите также в примере Drag and Drop Robot код реализации всплывающих подсказок и обработки формы курсора.

Анимация

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

Другой альтернативой является создание пользовательского элемента, который наследуется от QObject и QGraphicsItem. Элемент может установить собственные таймеры и управлять анимацией с помощью инкрементных шагов (incremental steps) в QObject::timerEvent().

Третьей альтернативой, которая доступна в основном для совместимости с QCanvas в Qt 3, является движение (advance) сцены с помощью вызова QGraphicsScene::advance(), который по очереди вызывает QGraphicsItem::advance().

Отрисовка OpenGL

Для разрешения отрисовки OpenGL, просто установите новый QGLWidget как окно просмотра для QGraphicsView вызвав QGraphicsView::setViewport(). Если вам необходим OpenGL со сглаживанием (antialiasing), вам нужна поддержка буферов образцов (sample buffer) OpenGL (смотрите QGLFormat::sampleBuffers()).

Пример:

 QGraphicsView view(&scene);
 view.setViewport(new QGLWidget(QGLFormat(QGL::SampleBuffers)));

Группы элементов

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

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

Виджеты и компоновки

В Qt 4.4 введена поддержка геометрии и элементов, управляемых компоновкой (layout-aware), через QGraphicsWidget. Этот специальный базовый элемент похож на QWidget, но, в отличие от QWidget, он наследуется не от QPaintDevice; а скорее от QGraphicsItem. Это позволяет вам писать завершенные виджеты с событиями, сигналами и слотами, политиками (policies) и предпочитаемыми размерами (size hints), а также вы можете управлять геометрией своих виджетов в компоновках посредством QGraphicsLinearLayout и QGraphicsGridLayout.

QGraphicsWidget

Построенный на основе возможностей QGraphicsItem и требующий мало памяти, QGraphicsWidget предоставляет лучшее из двух миров: дополнительную функциональность из QWidget, например, стиль, шрифт, палитра, направление компоновки и ее геометрия, и независимость от разрешения (resolution independence) и поддержка преобразования из QGraphicsItem. Поскольку графическое представление вместо целочисленных использует действительные координаты, функции геометрии QGraphicsWidget'а также оперируют с QRectF и QPointF. Это также применимо к прямоугольникам рамок (frame rects), полям (margins) и интервалам (spacing). Для QGraphicsWidget не являются необычными значения полей, например, такие (0.5, 0.5, 0.5, 0.5). Вы можете создать как субвиджеты, так и окна верхнего уровня ("top-level"); в некоторых случаях вы можете теперь использовать графическое представление для современных MDI-приложений.

Некоторые свойства QWidget поддерживаются, включая флаги окна (window flags) и атрибуты, но не все. Вы можете обратиться к документации класса QGraphicsWidget за полным обзором того, что поддерживается и что не поддерживается. Например, вы можете создать украшенные (decorated) окна, передав флаг окна Qt::Window в конструктор QGraphicsWidget, но графическое представление сейчас не поддерживает флаги Qt::Sheet и Qt::Drawer, которые являются обычными в Mac OS X.

В зависимости от реакции сообщества возможности QGraphicsWidget будут расширяться.

QGraphicsLayout

QGraphicsLayout является частью структуры компоновки второго поколения, разработанной специально для QGraphicsWidget. Его API очень похож на API QLayout. Вы можете управлять виджетами и субкомпоновками внутри либо QGraphicsLinearLayout, либо QGraphicsGridLayout. Вы также можете легко написать собственную компоновку, создав подкласс от QGraphicsLayout, или добавить собственные элементы QGraphicsItem в компоновку, написав переходник подкласса (adaptor subclass) QGraphicsLayoutItem.

Поддержка встраиваемых виджетов

Графическое представление предоставляет бесшовную поддержку для встраивания любых виджетов в сцену. Вы можете встраивать простые виджеты, такие как QLineEdit или QPushButton, сложные виджеты такие как QTabWidget, и даже главные окна целиком. Для встраивания вашего виджета в сцену просто вызовите QGraphicsScene::addWidget(), или же создайте экземпляр класса QGraphicsProxyWidget для встраивания вашего виджета вручную.

Посредством QGraphicsProxyWidget графическое представление может глубоко интегрировать возможности виджета клиента, включая его курсоры, всплывающие подсказки, события мыши, планшета и клавиатуры, дочерние виджеты, анимацию, всплывающие окна (например, QComboBox или QCompleter) и фокус ввода виджета и активацию. QGraphicsProxyWidget даже интегрирует порядок обхода по клавише табуляции (tab order) встраиваемого виджета, так что вы можете переходить по клавише табуляции по встроенным виджетам. Вы даже можете встроить новый QGraphicsView в вашу сцену для предоставления сложных вложенных сцен.

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

Производительность

Инструкции с двойной точностью

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

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

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