FCL/sf/mw/qt: comparison util/src/gui/graphicsview/qgraphicswidget.cpp

equal deleted inserted replaced

-:41300fa6a67c
+:f7bc934e204c
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "qglobal.h"
+#ifndef QT_NO_GRAPHICSVIEW
+#include "qgraphicswidget.h"
+#include "qgraphicswidget_p.h"
+#include "qgraphicslayout.h"
+#include "qgraphicslayout_p.h"
+#include "qgraphicsscene.h"
+#include "qgraphicssceneevent.h"
+#ifndef QT_NO_ACTION
+#include <private/qaction_p.h>
+#endif
+#include <private/qapplication_p.h>
+#include <private/qgraphicsscene_p.h>
+#ifndef QT_NO_SHORTCUT
+#include <private/qshortcutmap_p.h>
+#endif
+#include <QtCore/qmutex.h>
+#include <QtGui/qapplication.h>
+#include <QtGui/qgraphicsview.h>
+#include <QtGui/qgraphicsproxywidget.h>
+#include <QtGui/qpalette.h>
+#include <QtGui/qstyleoption.h>
+#include <qdebug.h>
+QT_BEGIN_NAMESPACE
+/*!
+\class QGraphicsWidget
+\brief The QGraphicsWidget class is the base class for all widget
+items in a QGraphicsScene.
+\since 4.4
+\ingroup graphicsview-api
+QGraphicsWidget is an extended base item that provides extra functionality
+over QGraphicsItem. It is similar to QWidget in many ways:
+\list
+\o Provides a \l palette, a \l font and a \l style().
+\o Has a defined geometry().
+\o Supports layouts with setLayout() and layout().
+\o Supports shortcuts and actions with grabShortcut() and insertAction()
+\endlist
+Unlike QGraphicsItem, QGraphicsWidget is not an abstract class; you can
+create instances of a QGraphicsWidget without having to subclass it.
+This approach is useful for widgets that only serve the purpose of
+organizing child widgets into a layout.
+QGraphicsWidget can be used as a base item for your own custom item if
+you require advanced input focus handling, e.g., tab focus and activation, or
+layouts.
+Since QGraphicsWidget resembles QWidget and has similar API, it is
+easier to port a widget from QWidget to QGraphicsWidget, instead of
+QGraphicsItem.
+\note QWidget-based widgets can be directly embedded into a
+QGraphicsScene using QGraphicsProxyWidget.
+Noticeable differences between QGraphicsWidget and QWidget are:
+\table
+\header \o QGraphicsWidget
+\o QWidget
+\row      \o Coordinates and geometry are defined with qreals (doubles or
+floats, depending on the platform).
+\o QWidget uses integer geometry (QPoint, QRect).
+\row      \o The widget is already visible by default; you do not have to
+call show() to display the widget.
+\o QWidget is hidden by default until you call show().
+\row      \o A subset of widget attributes are supported.
+\o All widget attributes are supported.
+\row      \o A top-level item's style defaults to QGraphicsScene::style
+\o A top-level widget's style defaults to QApplication::style
+\row      \o Graphics View provides a custom drag and drop framework, different
+from QWidget.
+\o Standard drag and drop framework.
+\row      \o Widget items do not support modality.
+\o Full modality support.
+\endtable
+QGraphicsWidget supports a subset of Qt's widget attributes,
+(Qt::WidgetAttribute), as shown in the table below. Any attributes not
+listed in this table are unsupported, or otherwise unused.
+\table
+\header \o Widget Attribute                         \o Usage
+\row    \o Qt::WA_SetLayoutDirection
+\o Set by setLayoutDirection(), cleared by
+unsetLayoutDirection(). You can test this attribute to
+check if the widget has been explicitly assigned a
+\l{QGraphicsWidget::layoutDirection()}
+{layoutDirection}. If the attribute is not set, the
+\l{QGraphicsWidget::layoutDirection()}
+{layoutDirection()} is inherited.
+\row    \o Qt::WA_RightToLeft
+\o Toggled by setLayoutDirection(). Inherited from the
+parent/scene. If set, the widget's layout will order
+horizontally arranged widgets from right to left.
+\row    \o Qt::WA_SetStyle
+\o Set and cleared by setStyle(). If this attribute is
+set, the widget has been explicitly assigned a style.
+If it is unset, the widget will use the scene's or the
+application's style.
+\row    \o Qt::WA_Resized
+\o Set by setGeometry() and resize().
+\row    \o Qt::WA_SetPalette
+\o Set by setPalette().
+\row    \o Qt::WA_SetFont
+\o Set by setPalette().
+\row    \o Qt::WA_WindowPropagation
+\o Enables propagation to window widgets.
+\endtable
+Although QGraphicsWidget inherits from both QObject and QGraphicsItem,
+you should use the functions provided by QGraphicsItem, \e not QObject, to
+manage the relationships between parent and child items. These functions
+control the stacking order of items as well as their ownership.
+\note The QObject::parent() should always return 0 for QGraphicsWidgets,
+but this policy is not strictly defined.
+\sa QGraphicsProxyWidget, QGraphicsItem, {Widgets and Layouts}
+*/
+/*!
+Constructs a QGraphicsWidget instance. The optional \a parent argument is
+passed to QGraphicsItem's constructor. The optional \a wFlags argument
+specifies the widget's window flags (e.g., whether the widget should be a
+window, a tool, a popup, etc).
+*/
+QGraphicsWidget::QGraphicsWidget(QGraphicsItem *parent, Qt::WindowFlags wFlags)
+: QGraphicsObject(*new QGraphicsWidgetPrivate, 0, 0), QGraphicsLayoutItem(0, false)
+{
+Q_D(QGraphicsWidget);
+d->init(parent, wFlags);
+}
+/*!
+\internal
+Constructs a new QGraphicsWidget, using \a dd as parent.
+*/
+QGraphicsWidget::QGraphicsWidget(QGraphicsWidgetPrivate &dd, QGraphicsItem *parent, QGraphicsScene *scene, Qt::WindowFlags wFlags)
+: QGraphicsObject(dd, 0, scene), QGraphicsLayoutItem(0, false)
+{
+Q_D(QGraphicsWidget);
+d->init(parent, wFlags);
+}
+/*
+\internal
+\class QGraphicsWidgetStyles
+We use this thread-safe class to maintain a hash of styles for widgets
+styles. Note that QApplication::style() itself isn't thread-safe, QStyle
+isn't thread-safe, and we don't have a thread-safe factory for creating
+the default style, nor cloning a style.
+*/
+class QGraphicsWidgetStyles
+{
+public:
+QStyle *styleForWidget(const QGraphicsWidget *widget) const
+{
+QMutexLocker locker(&mutex);
+return styles.value(widget, 0);
+}
+void setStyleForWidget(QGraphicsWidget *widget, QStyle *style)
+{
+QMutexLocker locker(&mutex);
+if (style)
+styles[widget] = style;
+else
+styles.remove(widget);
+}
+private:
+QMap<const QGraphicsWidget *, QStyle *> styles;
+mutable QMutex mutex;
+};
+Q_GLOBAL_STATIC(QGraphicsWidgetStyles, widgetStyles)
+/*!
+Destroys the QGraphicsWidget instance.
+*/
+QGraphicsWidget::~QGraphicsWidget()
+{
+Q_D(QGraphicsWidget);
+#ifndef QT_NO_ACTION
+// Remove all actions from this widget
+for (int i = 0; i < d->actions.size(); ++i) {
+QActionPrivate *apriv = d->actions.at(i)->d_func();
+apriv->graphicsWidgets.removeAll(this);
+}
+d->actions.clear();
+#endif
+if (QGraphicsScene *scn = scene()) {
+QGraphicsScenePrivate *sceneD = scn->d_func();
+if (sceneD->tabFocusFirst == this)
+sceneD->tabFocusFirst = (d->focusNext == this ? 0 : d->focusNext);
+}
+d->focusPrev->d_func()->focusNext = d->focusNext;
+d->focusNext->d_func()->focusPrev = d->focusPrev;
+// Play it really safe
+d->focusNext = this;
+d->focusPrev = this;
+clearFocus();
+//we check if we have a layout previously
+if (d->layout) {
+QGraphicsLayout *temp = d->layout;
+foreach (QGraphicsItem * item, childItems()) {
+// In case of a custom layout which doesn't remove and delete items, we ensure that
+// the parent layout item does not point to the deleted layout. This code is here to
+// avoid regression from 4.4 to 4.5, because according to 4.5 docs it is not really needed.
+if (item->isWidget()) {
+QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(item);
+if (widget->parentLayoutItem() == d->layout)
+widget->setParentLayoutItem(0);
+}
+}
+d->layout = 0;
+delete temp;
+}
+// Remove this graphics widget from widgetStyles
+widgetStyles()->setStyleForWidget(this, 0);
+}
+/*!
+\property QGraphicsWidget::size
+\brief the size of the widget
+Calling resize() resizes the widget to a \a size bounded by minimumSize()
+and maximumSize(). This property only affects the widget's width and
+height (e.g., its right and bottom edges); the widget's position and
+top-left corner remains unaffected.
+Resizing a widget triggers the widget to immediately receive a
+\l{QEvent::GraphicsSceneResize}{GraphicsSceneResize} event with the
+widget's old and new size.  If the widget has a layout assigned when this
+event arrives, the layout will be activated and it will automatically
+update any child widgets's geometry.
+This property does not affect any layout of the parent widget. If the
+widget itself is managed by a parent layout; e.g., it has a parent widget
+with a layout assigned, that layout will not activate.
+By default, this property contains a size with zero width and height.
+\sa setGeometry(), QGraphicsSceneResizeEvent, QGraphicsLayout
+*/
+QSizeF QGraphicsWidget::size() const
+{
+return QGraphicsLayoutItem::geometry().size();
+}
+void QGraphicsWidget::resize(const QSizeF &size)
+{
+setGeometry(QRectF(pos(), size));
+}
+/*!
+\fn void QGraphicsWidget::resize(qreal w, qreal h)
+This convenience function is equivalent to calling resize(QSizeF(w, h)).
+\sa setGeometry(), setTransform()
+*/
+/*!
+\property QGraphicsWidget::sizePolicy
+\brief the size policy for the widget
+\sa sizePolicy(), setSizePolicy(), QWidget::sizePolicy()
+*/
+/*!
+\fn QGraphicsWidget::geometryChanged()
+This signal gets emitted whenever the geometry of the item changes
+\internal
+*/
+/*!
+\property QGraphicsWidget::geometry
+\brief the geometry of the widget
+Sets the item's geometry to \a rect. The item's position and size are
+modified as a result of calling this function. The item is first moved,
+then resized.
+A side effect of calling this function is that the widget will receive
+a move event and a resize event. Also, if the widget has a layout
+assigned, the layout will activate.
+\sa geometry(), resize()
+*/
+void QGraphicsWidget::setGeometry(const QRectF &rect)
+{
+QGraphicsWidgetPrivate *wd = QGraphicsWidget::d_func();
+QGraphicsLayoutItemPrivate *d = QGraphicsLayoutItem::d_ptr.data();
+QRectF newGeom;
+QPointF oldPos = d->geom.topLeft();
+if (!wd->inSetPos) {
+setAttribute(Qt::WA_Resized);
+newGeom = rect;
+newGeom.setSize(rect.size().expandedTo(effectiveSizeHint(Qt::MinimumSize))
+.boundedTo(effectiveSizeHint(Qt::MaximumSize)));
+if (newGeom == d->geom)
+return;
+// setPos triggers ItemPositionChange, which can adjust position
+wd->inSetGeometry = 1;
+setPos(newGeom.topLeft());
+wd->inSetGeometry = 0;
+newGeom.moveTopLeft(pos());
+if (newGeom == d->geom)
+return;
+// Update and prepare to change the geometry (remove from index) if the size has changed.
+if (wd->scene) {
+if (rect.topLeft() == d->geom.topLeft()) {
+prepareGeometryChange();
+}
+}
+}
+// Update the layout item geometry
+bool moved = oldPos != pos();
+if (moved) {
+// Send move event.
+QGraphicsSceneMoveEvent event;
+event.setOldPos(oldPos);
+event.setNewPos(pos());
+QApplication::sendEvent(this, &event);
+if (wd->inSetPos) {
+//set the new pos
+d->geom.moveTopLeft(pos());
+return;
+}
+}
+QSizeF oldSize = size();
+QGraphicsLayoutItem::setGeometry(newGeom);
+emit geometryChanged();
+// Send resize event
+bool resized = newGeom.size() != oldSize;
+if (resized) {
+QGraphicsSceneResizeEvent re;
+re.setOldSize(oldSize);
+re.setNewSize(newGeom.size());
+if (oldSize.width() != newGeom.size().width())
+emit widthChanged();
+if (oldSize.height() != newGeom.size().height())
+emit heightChanged();
+QApplication::sendEvent(this, &re);
+}
+}
+/*!
+\fn QRectF QGraphicsWidget::rect() const
+Returns the item's local rect as a QRectF. This function is equivalent
+to QRectF(QPointF(), size()).
+\sa setGeometry(), resize()
+*/
+/*!
+\fn void QGraphicsWidget::setGeometry(qreal x, qreal y, qreal w, qreal h)
+This convenience function is equivalent to calling setGeometry(QRectF(
+\a x, \a y, \a w, \a h)).
+\sa geometry(), resize()
+*/
+/*!
+\property QGraphicsWidget::minimumSize
+\brief the minimum size of the widget
+\sa setMinimumSize(), minimumSize(), preferredSize, maximumSize
+*/
+/*!
+\property QGraphicsWidget::preferredSize
+\brief the preferred size of the widget
+\sa setPreferredSize(), preferredSize(), minimumSize, maximumSize
+*/
+/*!
+\property QGraphicsWidget::maximumSize
+\brief the maximum size of the widget
+\sa setMaximumSize(), maximumSize(), minimumSize, preferredSize
+*/
+/*!
+Sets the widget's contents margins to \a left, \a top, \a right and \a
+bottom.
+Contents margins are used by the assigned layout to define the placement
+of subwidgets and layouts. Margins are particularily useful for widgets
+that constrain subwidgets to only a section of its own geometry. For
+example, a group box with a layout will place subwidgets inside its frame,
+but below the title.
+Changing a widget's contents margins will always trigger an update(), and
+any assigned layout will be activated automatically. The widget will then
+receive a \l{QEvent::ContentsRectChange}{ContentsRectChange} event.
+\sa getContentsMargins(), setGeometry()
+*/
+void QGraphicsWidget::setContentsMargins(qreal left, qreal top, qreal right, qreal bottom)
+{
+Q_D(QGraphicsWidget);
+if (!d->margins && left == 0 && top == 0 && right == 0 && bottom == 0)
+return;
+d->ensureMargins();
+if (left == d->margins[d->Left]
+&& top == d->margins[d->Top]
+&& right == d->margins[d->Right]
+&& bottom == d->margins[d->Bottom])
+return;
+d->margins[d->Left] = left;
+d->margins[d->Top] = top;
+d->margins[d->Right] = right;
+d->margins[d->Bottom] = bottom;
+if (QGraphicsLayout *l = d->layout)
+l->invalidate();
+else
+updateGeometry();
+QEvent e(QEvent::ContentsRectChange);
+QApplication::sendEvent(this, &e);
+}
+/*!
+Gets the widget's contents margins. The margins are stored in \a left, \a
+top, \a right and \a bottom, as pointers to qreals. Each argument can
+be \e {omitted} by passing 0.
+\sa setContentsMargins()
+*/
+void QGraphicsWidget::getContentsMargins(qreal *left, qreal *top, qreal *right, qreal *bottom) const
+{
+Q_D(const QGraphicsWidget);
+if (left || top || right || bottom)
+d->ensureMargins();
+if (left)
+*left = d->margins[d->Left];
+if (top)
+*top = d->margins[d->Top];
+if (right)
+*right = d->margins[d->Right];
+if (bottom)
+*bottom = d->margins[d->Bottom];
+}
+/*!
+Sets the widget's window frame margins to \a left, \a top, \a right and
+\a bottom. The default frame margins are provided by the style, and they
+depend on the current window flags.
+If you would like to draw your own window decoration, you can set your
+own frame margins to override the default margins.
+\sa unsetWindowFrameMargins(), getWindowFrameMargins(), windowFrameRect()
+*/
+void QGraphicsWidget::setWindowFrameMargins(qreal left, qreal top, qreal right, qreal bottom)
+{
+Q_D(QGraphicsWidget);
+if (!d->windowFrameMargins && left == 0 && top == 0 && right == 0 && bottom == 0)
+return;
+d->ensureWindowFrameMargins();
+bool unchanged =
+d->windowFrameMargins[d->Left] == left
+&& d->windowFrameMargins[d->Top] == top
+&& d->windowFrameMargins[d->Right] == right
+&& d->windowFrameMargins[d->Bottom] == bottom;
+if (d->setWindowFrameMargins && unchanged)
+return;
+if (!unchanged)
+prepareGeometryChange();
+d->windowFrameMargins[d->Left] = left;
+d->windowFrameMargins[d->Top] = top;
+d->windowFrameMargins[d->Right] = right;
+d->windowFrameMargins[d->Bottom] = bottom;
+d->setWindowFrameMargins = true;
+}
+/*!
+Gets the widget's window frame margins. The margins are stored in \a left,
+\a top, \a right and \a bottom as pointers to qreals. Each argument can
+be \e {omitted} by passing 0.
+\sa setWindowFrameMargins(), windowFrameRect()
+*/
+void QGraphicsWidget::getWindowFrameMargins(qreal *left, qreal *top, qreal *right, qreal *bottom) const
+{
+Q_D(const QGraphicsWidget);
+if (left || top || right || bottom)
+d->ensureWindowFrameMargins();
+if (left)
+*left = d->windowFrameMargins[d->Left];
+if (top)
+*top = d->windowFrameMargins[d->Top];
+if (right)
+*right = d->windowFrameMargins[d->Right];
+if (bottom)
+*bottom = d->windowFrameMargins[d->Bottom];
+}
+/*!
+Resets the window frame margins to the default value, provided by the style.
+\sa setWindowFrameMargins(), getWindowFrameMargins(), windowFrameRect()
+*/
+void QGraphicsWidget::unsetWindowFrameMargins()
+{
+Q_D(QGraphicsWidget);
+if ((d->windowFlags & Qt::Window) && (d->windowFlags & Qt::WindowType_Mask) != Qt::Popup &&
+(d->windowFlags & Qt::WindowType_Mask) != Qt::ToolTip && !(d->windowFlags & Qt::FramelessWindowHint)) {
+QStyleOptionTitleBar bar;
+d->initStyleOptionTitleBar(&bar);
+QStyle *style = this->style();
+qreal margin = style->pixelMetric(QStyle::PM_MdiSubWindowFrameWidth);
+qreal titleBarHeight  = d->titleBarHeight(bar);
+setWindowFrameMargins(margin, titleBarHeight, margin, margin);
+} else {
+setWindowFrameMargins(0, 0, 0, 0);
+}
+d->setWindowFrameMargins = false;
+}
+/*!
+Returns the widget's geometry in parent coordinates including any window
+frame.
+\sa windowFrameRect(), getWindowFrameMargins(), setWindowFrameMargins()
+*/
+QRectF QGraphicsWidget::windowFrameGeometry() const
+{
+Q_D(const QGraphicsWidget);
+return d->windowFrameMargins
+? geometry().adjusted(-d->windowFrameMargins[d->Left], -d->windowFrameMargins[d->Top],
+d->windowFrameMargins[d->Right], d->windowFrameMargins[d->Bottom])
+: geometry();
+}
+/*!
+Returns the widget's local rect including any window frame.
+\sa windowFrameGeometry(), getWindowFrameMargins(), setWindowFrameMargins()
+*/
+QRectF QGraphicsWidget::windowFrameRect() const
+{
+Q_D(const QGraphicsWidget);
+return d->windowFrameMargins
+? rect().adjusted(-d->windowFrameMargins[d->Left], -d->windowFrameMargins[d->Top],
+d->windowFrameMargins[d->Right], d->windowFrameMargins[d->Bottom])
+: rect();
+}
+/*!
+Populates a style option object for this widget based on its current
+state, and stores the output in \a option. The default implementation
+populates \a option with the following properties.
+\table
+\header
+\o Style Option Property
+\o Value
+\row
+\o state & QStyle::State_Enabled
+\o Corresponds to QGraphicsItem::isEnabled().
+\row
+\o state & QStyle::State_HasFocus
+\o Corresponds to QGraphicsItem::hasFocus().
+\row
+\o state & QStyle::State_MouseOver
+\o Corresponds to QGraphicsItem::isUnderMouse().
+\row
+\o direction
+\o Corresponds to QGraphicsWidget::layoutDirection().
+\row
+\o rect
+\o Corresponds to QGraphicsWidget::rect().toRect().
+\row
+\o palette
+\o Corresponds to QGraphicsWidget::palette().
+\row
+\o fontMetrics
+\o Corresponds to QFontMetrics(QGraphicsWidget::font()).
+\endtable
+Subclasses of QGraphicsWidget should call the base implementation, and
+then test the type of \a option using qstyleoption_cast<>() or test
+QStyleOption::Type before storing widget-specific options.
+For example:
+\snippet doc/src/snippets/code/src_gui_graphicsview_qgraphicswidget.cpp 0
+\sa QStyleOption::initFrom()
+*/
+void QGraphicsWidget::initStyleOption(QStyleOption *option) const
+{
+Q_ASSERT(option);
+option->state = QStyle::State_None;
+if (isEnabled())
+option->state |= QStyle::State_Enabled;
+if (hasFocus())
+option->state |= QStyle::State_HasFocus;
+// if (window->testAttribute(Qt::WA_KeyboardFocusChange)) // ### Window
+//     option->state |= QStyle::State_KeyboardFocusChange;
+if (isUnderMouse())
+option->state |= QStyle::State_MouseOver;
+if (QGraphicsWidget *w = window()) {
+if (w->isActiveWindow())
+option->state |= QStyle::State_Active;
+}
+if (isWindow())
+option->state |= QStyle::State_Window;
+/*
+###
+#ifdef Q_WS_MAC
+extern bool qt_mac_can_clickThrough(const QGraphicsWidget *w); //qwidget_mac.cpp
+if (!(option->state & QStyle::State_Active) && !qt_mac_can_clickThrough(widget))
+option->state &= ~QStyle::State_Enabled;
+switch (QMacStyle::widgetSizePolicy(widget)) {
+case QMacStyle::SizeSmall:
+option->state |= QStyle::State_Small;
+break;
+case QMacStyle::SizeMini:
+option->state |= QStyle::State_Mini;
+break;
+default:
+;
+}
+#endif
+#ifdef QT_KEYPAD_NAVIGATION
+if (widget->hasEditFocus())
+state |= QStyle::State_HasEditFocus;
+#endif
+*/
+option->direction = layoutDirection();
+option->rect = rect().toRect(); // ### truncation!
+option->palette = palette();
+if (!isEnabled()) {
+option->palette.setCurrentColorGroup(QPalette::Disabled);
+} else if (isActiveWindow()) {
+option->palette.setCurrentColorGroup(QPalette::Active);
+} else {
+option->palette.setCurrentColorGroup(QPalette::Inactive);
+}
+option->fontMetrics = QFontMetrics(font());
+}
+/*!
+\reimp
+*/
+QSizeF QGraphicsWidget::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
+{
+Q_D(const QGraphicsWidget);
+QSizeF sh;
+if (d->layout) {
+QSizeF marginSize(0,0);
+if (d->margins) {
+marginSize = QSizeF(d->margins[d->Left] + d->margins[d->Right],
+d->margins[d->Top] + d->margins[d->Bottom]);
+}
+sh = d->layout->effectiveSizeHint(which, constraint - marginSize);
+sh += marginSize;
+} else {
+switch (which) {
+case Qt::MinimumSize:
+sh = QSizeF(0, 0);
+break;
+case Qt::PreferredSize:
+sh = QSizeF(50, 50);    //rather arbitrary
+break;
+case Qt::MaximumSize:
+sh = QSizeF(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
+break;
+default:
+qWarning("QGraphicsWidget::sizeHint(): Don't know how to handle the value of 'which'");
+break;
+}
+}
+return sh;
+}
+/*!
+Returns this widget's layout, or 0 if no layout is currently managing this
+widget.
+\sa setLayout()
+*/
+QGraphicsLayout *QGraphicsWidget::layout() const
+{
+Q_D(const QGraphicsWidget);
+return d->layout;
+}
+/*!
+\fn void QGraphicsWidget::setLayout(QGraphicsLayout *layout)
+Sets the layout for this widget to \a layout. Any existing layout manager
+is deleted before the new layout is assigned. If \a layout is 0, the
+widget is left without a layout. Existing subwidgets' geometries will
+remain unaffected.
+All widgets that are currently managed by \a layout or all of its
+sublayouts, are automatically reparented to this item. The layout is then
+invalidated, and the child widget geometries are adjusted according to
+this item's geometry() and contentsMargins(). Children who are not
+explicitly managed by \a layout remain unaffected by the layout after
+it has been assigned to this widget.
+QGraphicsWidget takes ownership of \a layout.
+\sa layout(), QGraphicsLinearLayout::addItem(), QGraphicsLayout::invalidate()
+*/
+void QGraphicsWidget::setLayout(QGraphicsLayout *l)
+{
+Q_D(QGraphicsWidget);
+if (d->layout == l)
+return;
+d->setLayout_helper(l);
+if (!l)
+return;
+// Prevent assigning a layout that is already assigned to another widget.
+QGraphicsLayoutItem *oldParent = l->parentLayoutItem();
+if (oldParent && oldParent != this) {
+qWarning("QGraphicsWidget::setLayout: Attempting to set a layout on %s"
+" \"%s\", when the layout already has a parent",
+metaObject()->className(), qPrintable(objectName()));
+return;
+}
+// Install and activate the layout.
+l->setParentLayoutItem(this);
+l->d_func()->reparentChildItems(this);
+l->invalidate();
+}
+/*!
+Adjusts the size of the widget to its effective preferred size hint.
+This function is called implicitly when the item is shown for the first
+time.
+\sa effectiveSizeHint(), Qt::MinimumSize
+*/
+void QGraphicsWidget::adjustSize()
+{
+QSizeF sz = effectiveSizeHint(Qt::PreferredSize);
+// What if sz is not valid?!
+if (sz.isValid())
+resize(sz);
+}
+/*!
+\property QGraphicsWidget::layoutDirection
+\brief the layout direction for this widget.
+This property modifies this widget's and all of its descendants'
+Qt::WA_RightToLeft attribute. It also sets this widget's
+Qt::WA_SetLayoutDirection attribute.
+The widget's layout direction determines the order in which the layout
+manager horizontally arranges subwidgets of this widget. The default
+value depends on the language and locale of the application, and is
+typically in the same direction as words are read and written. With
+Qt::LeftToRight, the layout starts placing subwidgets from the left
+side of this widget towards the right. Qt::RightToLeft does the opposite -
+the layout will place widgets starting from the right edge moving towards
+the left.
+Subwidgets inherit their layout direction from the parent. Top-level
+widget items inherit their layout direction from
+QGraphicsScene::layoutDirection. If you change a widget's layout direction
+by calling setLayoutDirection(), the widget will send itself a
+\l{QEvent::LayoutDirectionChange}{LayoutDirectionChange} event, and then
+propagate the new layout direction to all its descendants.
+\sa QWidget::layoutDirection, QApplication::layoutDirection
+*/
+Qt::LayoutDirection QGraphicsWidget::layoutDirection() const
+{
+return testAttribute(Qt::WA_RightToLeft) ? Qt::RightToLeft : Qt::LeftToRight;
+}
+void QGraphicsWidget::setLayoutDirection(Qt::LayoutDirection direction)
+{
+Q_D(QGraphicsWidget);
+setAttribute(Qt::WA_SetLayoutDirection, true);
+d->setLayoutDirection_helper(direction);
+}
+void QGraphicsWidget::unsetLayoutDirection()
+{
+Q_D(QGraphicsWidget);
+setAttribute(Qt::WA_SetLayoutDirection, false);
+d->resolveLayoutDirection();
+}
+/*!
+Returns a pointer to the widget's style. If this widget does not have any
+explicitly assigned style, the scene's style is returned instead. In turn,
+if the scene does not have any assigned style, this function returns
+QApplication::style().
+\sa setStyle()
+*/
+QStyle *QGraphicsWidget::style() const
+{
+if (QStyle *style = widgetStyles()->styleForWidget(this))
+return style;
+// ### This is not thread-safe. QApplication::style() is not thread-safe.
+return scene() ? scene()->style() : QApplication::style();
+}
+/*!
+Sets the widget's style to \a style. QGraphicsWidget does \e not take
+ownership of \a style.
+If no style is assigned, or \a style is 0, the widget will use
+QGraphicsScene::style() (if this has been set). Otherwise the widget will
+use QApplication::style().
+This function sets the Qt::WA_SetStyle attribute if \a style is not 0;
+otherwise it clears the attribute.
+\sa style()
+*/
+void QGraphicsWidget::setStyle(QStyle *style)
+{
+setAttribute(Qt::WA_SetStyle, style != 0);
+widgetStyles()->setStyleForWidget(this, style);
+// Deliver StyleChange to the widget itself (doesn't propagate).
+QEvent event(QEvent::StyleChange);
+QApplication::sendEvent(this, &event);
+}
+/*!
+\property QGraphicsWidget::font
+\brief the widgets' font
+This property provides the widget's font.
+QFont consists of font properties that have been explicitly defined and
+properties implicitly inherited from the widget's parent. Hence, font()
+can return a different font compared to the one set with setFont().
+This scheme allows you to define single entries in a font without
+affecting the font's inherited entries.
+When a widget's font changes, it resolves its entries against its
+parent widget. If the widget does not have a parent widget, it resolves
+its entries against the scene. The widget then sends itself a
+\l{QEvent::FontChange}{FontChange} event and notifies all its
+descendants so that they can resolve their fonts as well.
+By default, this property contains the application's default font.
+\sa QApplication::font(), QGraphicsScene::font, QFont::resolve()
+*/
+QFont QGraphicsWidget::font() const
+{
+Q_D(const QGraphicsWidget);
+return d->font;
+}
+void QGraphicsWidget::setFont(const QFont &font)
+{
+Q_D(QGraphicsWidget);
+setAttribute(Qt::WA_SetFont, font.resolve() != 0);
+QFont naturalFont = d->naturalWidgetFont();
+QFont resolvedFont = font.resolve(naturalFont);
+d->setFont_helper(resolvedFont);
+}
+/*!
+\property QGraphicsWidget::palette
+\brief the widget's palette
+This property provides the widget's palette. The palette provides colors
+and brushes for color groups (e.g., QPalette::Button) and states (e.g.,
+QPalette::Inactive), loosely defining the general look of the widget and
+its children.
+QPalette consists of color groups that have been explicitly defined, and
+groups that are implicitly inherited from the widget's parent. Because of
+this, palette() can return a different palette than what has been set with
+setPalette(). This scheme allows you to define single entries in a palette
+without affecting the palette's inherited entries.
+When a widget's palette changes, it resolves its entries against its
+parent widget, or if it doesn't have a parent widget, it resolves against
+the scene. It then sends itself a \l{QEvent::PaletteChange}{PaletteChange}
+event, and notifies all its descendants so they can resolve their palettes
+as well.
+By default, this property contains the application's default palette.
+\sa QApplication::palette(), QGraphicsScene::palette, QPalette::resolve()
+*/
+QPalette QGraphicsWidget::palette() const
+{
+Q_D(const QGraphicsWidget);
+return d->palette;
+}
+void QGraphicsWidget::setPalette(const QPalette &palette)
+{
+Q_D(QGraphicsWidget);
+setAttribute(Qt::WA_SetPalette, palette.resolve() != 0);
+QPalette naturalPalette = d->naturalWidgetPalette();
+QPalette resolvedPalette = palette.resolve(naturalPalette);
+d->setPalette_helper(resolvedPalette);
+}
+/*!
+If this widget is currently managed by a layout, this function notifies
+the layout that the widget's size hints have changed and the layout
+may need to resize and reposition the widget accordingly.
+Call this function if the widget's sizeHint() has changed.
+\sa QGraphicsLayout::invalidate()
+*/
+void QGraphicsWidget::updateGeometry()
+{
+QGraphicsLayoutItem::updateGeometry();
+QGraphicsLayoutItem *parentItem = parentLayoutItem();
+if (parentItem && parentItem->isLayout()) {
+parentItem->updateGeometry();
+} else {
+if (parentItem) {
+QGraphicsWidget *parentWid = parentWidget();    //###
+if (parentWid->isVisible())
+QApplication::postEvent(parentWid, new QEvent(QEvent::LayoutRequest));
+}
+bool wasResized = testAttribute(Qt::WA_Resized);
+resize(size()); // this will restrict the size
+setAttribute(Qt::WA_Resized, wasResized);
+}
+}
+/*!
+\reimp
+QGraphicsWidget uses the base implementation of this function to catch and
+deliver events related to state changes in the item. Because of this, it is
+very important that subclasses call the base implementation.
+\a change specifies the type of change, and \a value is the new value.
+For example, QGraphicsWidget uses ItemVisibleChange to deliver
+\l{QEvent::Show} {Show} and \l{QEvent::Hide}{Hide} events,
+ItemPositionHasChanged to deliver \l{QEvent::Move}{Move} events,
+and ItemParentChange both to deliver \l{QEvent::ParentChange}
+{ParentChange} events, and for managing the focus chain.
+QGraphicsWidget enables the ItemSendsGeometryChanges flag by default in
+order to track position changes.
+\sa QGraphicsItem::itemChange()
+*/
+QVariant QGraphicsWidget::itemChange(GraphicsItemChange change, const QVariant &value)
+{
+Q_D(QGraphicsWidget);
+switch (change) {
+case ItemEnabledHasChanged: {
+// Send EnabledChange after the enabled state has changed.
+QEvent event(QEvent::EnabledChange);
+QApplication::sendEvent(this, &event);
+break;
+}
+case ItemVisibleChange:
+if (value.toBool()) {
+// Send Show event before the item has been shown.
+QShowEvent event;
+QApplication::sendEvent(this, &event);
+bool resized = testAttribute(Qt::WA_Resized);
+if (!resized) {
+adjustSize();
+setAttribute(Qt::WA_Resized, false);
+}
+}
+break;
+case ItemVisibleHasChanged:
+if (!value.toBool()) {
+// Send Hide event after the item has been hidden.
+QHideEvent event;
+QApplication::sendEvent(this, &event);
+}
+break;
+case ItemPositionHasChanged:
+if (!d->inSetGeometry) {
+d->inSetPos = 1;
+// Ensure setGeometry is called (avoid recursion when setPos is
+// called from within setGeometry).
+setGeometry(QRectF(pos(), size()));
+d->inSetPos = 0 ;
+}
+break;
+case ItemParentChange: {
+QGraphicsItem *parent = qVariantValue<QGraphicsItem *>(value);
+d->fixFocusChainBeforeReparenting((parent && parent->isWidget()) ? static_cast<QGraphicsWidget *>(parent) : 0, scene());
+// Deliver ParentAboutToChange.
+QEvent event(QEvent::ParentAboutToChange);
+QApplication::sendEvent(this, &event);
+break;
+}
+case ItemParentHasChanged: {
+// Deliver ParentChange.
+QEvent event(QEvent::ParentChange);
+QApplication::sendEvent(this, &event);
+break;
+}
+case ItemCursorChange: {
+// Deliver CursorChange.
+QEvent event(QEvent::CursorChange);
+QApplication::sendEvent(this, &event);
+break;
+}
+case ItemToolTipChange: {
+// Deliver ToolTipChange.
+QEvent event(QEvent::ToolTipChange);
+QApplication::sendEvent(this, &event);
+break;
+}
+default:
+break;
+}
+return QGraphicsItem::itemChange(change, value);
+}
+/*!
+\internal
+This virtual function is used to notify changes to any property (both
+dynamic properties, and registered with Q_PROPERTY) in the
+widget. Depending on the property itself, the notification can be
+delivered before or after the value has changed.
+\a propertyName is the name of the property (e.g., "size" or "font"), and
+\a value is the (proposed) new value of the property. The function returns
+the new value, which may be different from \a value if the notification
+supports adjusting the property value. The base implementation simply
+returns \a value for any \a propertyName.
+QGraphicsWidget delivers notifications for the following properties:
+\table     \o propertyName        \o Property
+\row       \o layoutDirection     \o QGraphicsWidget::layoutDirection
+\row       \o size                \o QGraphicsWidget::size
+\row       \o font                \o QGraphicsWidget::font
+\row       \o palette             \o QGraphicsWidget::palette
+\endtable
+\sa itemChange()
+*/
+QVariant QGraphicsWidget::propertyChange(const QString &propertyName, const QVariant &value)
+{
+Q_UNUSED(propertyName);
+return value;
+}
+/*!
+QGraphicsWidget's implementation of sceneEvent() simply passes \a event to
+QGraphicsWidget::event(). You can handle all events for your widget in
+event() or in any of the convenience functions; you should not have to
+reimplement this function in a subclass of QGraphicsWidget.
+\sa QGraphicsItem::sceneEvent()
+*/
+bool QGraphicsWidget::sceneEvent(QEvent *event)
+{
+return QGraphicsItem::sceneEvent(event);
+}
+/*!
+This event handler, for \a event, receives events for the window frame if
+this widget is a window. Its base implementation provides support for
+default window frame interaction such as moving, resizing, etc.
+You can reimplement this handler in a subclass of QGraphicsWidget to
+provide your own custom window frame interaction support.
+Returns true if \a event has been recognized and processed; otherwise,
+returns false.
+\sa event()
+*/
+bool QGraphicsWidget::windowFrameEvent(QEvent *event)
+{
+Q_D(QGraphicsWidget);
+switch (event->type()) {
+case QEvent::GraphicsSceneMousePress:
+d->windowFrameMousePressEvent(static_cast<QGraphicsSceneMouseEvent *>(event));
+break;
+case QEvent::GraphicsSceneMouseMove:
+d->ensureWindowData();
+if (d->windowData->grabbedSection != Qt::NoSection) {
+d->windowFrameMouseMoveEvent(static_cast<QGraphicsSceneMouseEvent *>(event));
+event->accept();
+}
+break;
+case QEvent::GraphicsSceneMouseRelease:
+d->windowFrameMouseReleaseEvent(static_cast<QGraphicsSceneMouseEvent *>(event));
+break;
+case QEvent::GraphicsSceneHoverMove:
+d->windowFrameHoverMoveEvent(static_cast<QGraphicsSceneHoverEvent *>(event));
+break;
+case QEvent::GraphicsSceneHoverLeave:
+d->windowFrameHoverLeaveEvent(static_cast<QGraphicsSceneHoverEvent *>(event));
+break;
+default:
+break;
+}
+return event->isAccepted();
+}
+/*!
+\since 4.4
+Returns the window frame section at position \a pos, or
+Qt::NoSection if there is no window frame section at this
+position.
+This function is used in QGraphicsWidget's base implementation for window
+frame interaction.
+You can reimplement this function if you want to customize how a window
+can be interactively moved or resized.  For instance, if you only want to
+allow a window to be resized by the bottom right corner, you can
+reimplement this function to return Qt::NoSection for all sections except
+Qt::BottomRightSection.
+\sa windowFrameEvent(), paintWindowFrame(), windowFrameGeometry()
+*/
+Qt::WindowFrameSection QGraphicsWidget::windowFrameSectionAt(const QPointF &pos) const
+{
+Q_D(const QGraphicsWidget);
+const QRectF r = windowFrameRect();
+if (!r.contains(pos))
+return Qt::NoSection;
+const qreal left = r.left();
+const qreal top = r.top();
+const qreal right = r.right();
+const qreal bottom = r.bottom();
+const qreal x = pos.x();
+const qreal y = pos.y();
+const qreal cornerMargin = 20;
+//### Not sure of this one, it should be the same value for all edges.
+const qreal windowFrameWidth = d->windowFrameMargins
+? d->windowFrameMargins[d->Left] : 0;
+Qt::WindowFrameSection s = Qt::NoSection;
+if (x <= left + cornerMargin) {
+if (y <= top + windowFrameWidth || (x <= left + windowFrameWidth && y <= top + cornerMargin)) {
+s = Qt::TopLeftSection;
+} else if (y >= bottom - windowFrameWidth || (x <= left + windowFrameWidth && y >= bottom - windowFrameWidth)) {
+s = Qt::BottomLeftSection;
+} else if (x <= left + windowFrameWidth) {
+s = Qt::LeftSection;
+}
+} else if (x >= right - cornerMargin) {
+if (y <= top + windowFrameWidth || (x >= right - windowFrameWidth && y <= top + cornerMargin)) {
+s = Qt::TopRightSection;
+} else if (y >= bottom - windowFrameWidth || (x >= right - windowFrameWidth && y >= bottom - windowFrameWidth)) {
+s = Qt::BottomRightSection;
+} else if (x >= right - windowFrameWidth) {
+s = Qt::RightSection;
+}
+} else if (y <= top + windowFrameWidth) {
+s = Qt::TopSection;
+} else if (y >= bottom - windowFrameWidth) {
+s = Qt::BottomSection;
+}
+if (s == Qt::NoSection) {
+QRectF r1 = r;
+r1.setHeight(d->windowFrameMargins
+? d->windowFrameMargins[d->Top] : 0);
+if (r1.contains(pos))
+s = Qt::TitleBarArea;
+}
+return s;
+}
+/*!
+\reimp
+Handles the \a event.  QGraphicsWidget handles the following
+events:
+\table   \o Event                 \o Usage
+\row     \o Polish
+\o Delivered to the widget some time after it has been
+shown.
+\row     \o GraphicsSceneMove
+\o Delivered to the widget after its local position has
+changed.
+\row     \o GraphicsSceneResize
+\o Delivered to the widget after its size has changed.
+\row     \o Show
+\o Delivered to the widget before it has been shown.
+\row     \o Hide
+\o Delivered to the widget after it has been hidden.
+\row     \o PaletteChange
+\o Delivered to the widget after its palette has changed.
+\row     \o FontChange
+\o Delivered to the widget after its font has changed.
+\row     \o EnabledChange
+\o Delivered to the widget after its enabled state has
+changed.
+\row     \o StyleChange
+\o Delivered to the widget after its style has changed.
+\row     \o LayoutDirectionChange
+\o Delivered to the widget after its layout direction has
+changed.
+\row     \o ContentsRectChange
+\o Delivered to the widget after its contents margins/
+contents rect has changed.
+\endtable
+*/
+bool QGraphicsWidget::event(QEvent *event)
+{
+Q_D(QGraphicsWidget);
+// Forward the event to the layout first.
+if (d->layout)
+d->layout->widgetEvent(event);
+// Handle the event itself.
+switch (event->type()) {
+case QEvent::GraphicsSceneMove:
+moveEvent(static_cast<QGraphicsSceneMoveEvent *>(event));
+break;
+case QEvent::GraphicsSceneResize:
+resizeEvent(static_cast<QGraphicsSceneResizeEvent *>(event));
+break;
+case QEvent::Show:
+showEvent(static_cast<QShowEvent *>(event));
+break;
+case QEvent::Hide:
+hideEvent(static_cast<QHideEvent *>(event));
+break;
+case QEvent::Polish:
+polishEvent();
+d->polished = true;
+if (!d->font.isCopyOf(QApplication::font()))
+d->updateFont(d->font);
+break;
+case QEvent::WindowActivate:
+case QEvent::WindowDeactivate:
+update();
+break;
+// Taken from QWidget::event
+case QEvent::ActivationChange:
+case QEvent::EnabledChange:
+case QEvent::FontChange:
+case QEvent::StyleChange:
+case QEvent::PaletteChange:
+case QEvent::ParentChange:
+case QEvent::ContentsRectChange:
+case QEvent::LayoutDirectionChange:
+changeEvent(event);
+break;
+case QEvent::Close:
+closeEvent((QCloseEvent *)event);
+break;
+case QEvent::GrabMouse:
+grabMouseEvent(event);
+break;
+case QEvent::UngrabMouse:
+ungrabMouseEvent(event);
+break;
+case QEvent::GrabKeyboard:
+grabKeyboardEvent(event);
+break;
+case QEvent::UngrabKeyboard:
+ungrabKeyboardEvent(event);
+break;
+case QEvent::GraphicsSceneMousePress:
+if (d->hasDecoration() && windowFrameEvent(event))
+return true;
+case QEvent::GraphicsSceneMouseMove:
+case QEvent::GraphicsSceneMouseRelease:
+case QEvent::GraphicsSceneMouseDoubleClick:
+d->ensureWindowData();
+if (d->hasDecoration() && d->windowData->grabbedSection != Qt::NoSection)
+return windowFrameEvent(event);
+break;
+case QEvent::GraphicsSceneHoverEnter:
+case QEvent::GraphicsSceneHoverMove:
+case QEvent::GraphicsSceneHoverLeave:
+if (d->hasDecoration()) {
+windowFrameEvent(event);
+// Filter out hover events if they were sent to us only because of the
+// decoration (special case in QGraphicsScenePrivate::dispatchHoverEvent).
+if (!acceptsHoverEvents())
+return true;
+}
+break;
+default:
+break;
+}
+return QObject::event(event);
+}
+/*!
+This event handler can be reimplemented to handle state changes.
+The state being changed in this event can be retrieved through \a event.
+Change events include: QEvent::ActivationChange, QEvent::EnabledChange,
+QEvent::FontChange, QEvent::StyleChange, QEvent::PaletteChange,
+QEvent::ParentChange, QEvent::LayoutDirectionChange, and
+QEvent::ContentsRectChange.
+*/
+void QGraphicsWidget::changeEvent(QEvent *event)
+{
+Q_D(QGraphicsWidget);
+switch (event->type()) {
+case QEvent::StyleChange:
+// ### Don't unset if the margins are explicitly set.
+unsetWindowFrameMargins();
+if (d->layout)
+d->layout->invalidate();
+case QEvent::FontChange:
+update();
+updateGeometry();
+break;
+case QEvent::PaletteChange:
+update();
+break;
+case QEvent::ParentChange:
+d->resolveFont(d->inheritedFontResolveMask);
+d->resolvePalette(d->inheritedPaletteResolveMask);
+break;
+default:
+break;
+}
+}
+/*!
+This event handler, for \a event, can be reimplemented in a subclass to
+receive widget close events.  The default implementation accepts the
+event.
+\sa close(), QCloseEvent
+*/
+void QGraphicsWidget::closeEvent(QCloseEvent *event)
+{
+event->accept();
+}
+/*!
+\reimp
+*/
+void QGraphicsWidget::focusInEvent(QFocusEvent *event)
+{
+Q_UNUSED(event);
+if (focusPolicy() != Qt::NoFocus)
+update();
+}
+/*!
+Finds a new widget to give the keyboard focus to, as appropriate for Tab
+and Shift+Tab, and returns true if it can find a new widget; returns false
+otherwise. If \a next is true, this function searches forward; if \a next
+is false, it searches backward.
+Sometimes, you will want to reimplement this function to provide special
+focus handling for your widget and its subwidgets. For example, a web
+browser might reimplement it to move its current active link forward or
+backward, and call the base implementation only when it reaches the last
+or first link on the page.
+Child widgets call focusNextPrevChild() on their parent widgets, but only
+the window that contains the child widgets decides where to redirect
+focus. By reimplementing this function for an object, you gain control of
+focus traversal for all child widgets.
+\sa focusPolicy()
+*/
+bool QGraphicsWidget::focusNextPrevChild(bool next)
+{
+Q_D(QGraphicsWidget);
+// Let the parent's focusNextPrevChild implementation decide what to do.
+QGraphicsWidget *parent = 0;
+if (!isWindow() && (parent = parentWidget()))
+return parent->focusNextPrevChild(next);
+if (!d->scene)
+return false;
+if (d->scene->focusNextPrevChild(next))
+return true;
+if (isWindow()) {
+setFocus(next ? Qt::TabFocusReason : Qt::BacktabFocusReason);
+if (hasFocus())
+return true;
+}
+return false;
+}
+/*!
+\reimp
+*/
+void QGraphicsWidget::focusOutEvent(QFocusEvent *event)
+{
+Q_UNUSED(event);
+if (focusPolicy() != Qt::NoFocus)
+update();
+}
+/*!
+This event handler, for \l{QEvent::Hide}{Hide} events, is delivered after
+the widget has been hidden, for example, setVisible(false) has been called
+for the widget or one of its ancestors when the widget was previously
+shown.
+You can reimplement this event handler to detect when your widget is
+hidden. Calling QEvent::accept() or QEvent::ignore() on \a event has no
+effect.
+\sa showEvent(), QWidget::hideEvent(), ItemVisibleChange
+*/
+void QGraphicsWidget::hideEvent(QHideEvent *event)
+{
+///### focusNextPrevChild(true), don't lose focus when the focus widget
+// is hidden.
+Q_UNUSED(event);
+}
+/*!
+This event handler, for \l{QEvent::GraphicsSceneMove}{GraphicsSceneMove}
+events, is delivered after the widget has moved (e.g., its local position
+has changed).
+This event is only delivered when the item is moved locally. Calling
+setTransform() or moving any of the item's ancestors does not affect the
+item's local position.
+You can reimplement this event handler to detect when your widget has
+moved. Calling QEvent::accept() or QEvent::ignore() on \a event has no
+effect.
+\sa ItemPositionChange, ItemPositionHasChanged
+*/
+void QGraphicsWidget::moveEvent(QGraphicsSceneMoveEvent *event)
+{
+// ### Last position is always == current position
+Q_UNUSED(event);
+}
+/*!
+This event is delivered to the item by the scene at some point after it
+has been constructed, but before it is shown or otherwise accessed through
+the scene. You can use this event handler to do last-minute initializations
+of the widget which require the item to be fully constructed.
+The base implementation does nothing.
+*/
+void QGraphicsWidget::polishEvent()
+{
+}
+/*!
+This event handler, for
+\l{QEvent::GraphicsSceneResize}{GraphicsSceneResize} events, is
+delivered after the widget has been resized (i.e., its local size has
+changed). \a event contains both the old and the new size.
+This event is only delivered when the widget is resized locally; calling
+setTransform() on the widget or any of its ancestors or view, does not
+affect the widget's local size.
+You can reimplement this event handler to detect when your widget has been
+resized. Calling QEvent::accept() or QEvent::ignore() on \a event has no
+effect.
+\sa geometry(), setGeometry()
+*/
+void QGraphicsWidget::resizeEvent(QGraphicsSceneResizeEvent *event)
+{
+Q_UNUSED(event);
+}
+/*!
+This event handler, for \l{QEvent::Show}{Show} events, is delivered before
+the widget has been shown, for example, setVisible(true) has been called
+for the widget or one of its ancestors when the widget was previously
+hidden.
+You can reimplement this event handler to detect when your widget is
+shown. Calling QEvent::accept() or QEvent::ignore() on \a event has no
+effect.
+\sa hideEvent(), QWidget::showEvent(), ItemVisibleChange
+*/
+void QGraphicsWidget::showEvent(QShowEvent *event)
+{
+Q_UNUSED(event);
+}
+/*!
+\reimp
+*/
+void QGraphicsWidget::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
+Q_UNUSED(event);
+}
+/*!
+\reimp
+*/
+void QGraphicsWidget::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
+{
+Q_UNUSED(event);
+}
+/*!
+This event handler, for \a event, can be reimplemented in a subclass to
+receive notifications for Qt::GrabMouse events.
+\sa grabMouse(), grabKeyboard()
+*/
+void QGraphicsWidget::grabMouseEvent(QEvent *event)
+{
+Q_UNUSED(event);
+}
+/*!
+This event handler, for \a event, can be reimplemented in a subclass to
+receive notifications for Qt::UngrabMouse events.
+\sa ungrabMouse(), ungrabKeyboard()
+*/
+void QGraphicsWidget::ungrabMouseEvent(QEvent *event)
+{
+Q_UNUSED(event);
+}
+/*!
+This event handler, for \a event, can be reimplemented in a subclass to
+receive notifications for Qt::GrabKeyboard events.
+\sa grabKeyboard(), grabMouse()
+*/
+void QGraphicsWidget::grabKeyboardEvent(QEvent *event)
+{
+Q_UNUSED(event);
+}
+/*!
+This event handler, for \a event, can be reimplemented in a subclass to
+receive notifications for Qt::UngrabKeyboard events.
+\sa ungrabKeyboard(), ungrabMouse()
+*/
+void QGraphicsWidget::ungrabKeyboardEvent(QEvent *event)
+{
+Q_UNUSED(event);
+}
+/*!
+Returns the widgets window type.
+\sa windowFlags(), isWindow(), isPanel()
+*/
+Qt::WindowType QGraphicsWidget::windowType() const
+{
+return Qt::WindowType(int(windowFlags()) & Qt::WindowType_Mask);
+}
+/*!
+\property QGraphicsWidget::windowFlags
+\brief the widget's window flags
+Window flags are a combination of a window type (e.g., Qt::Dialog) and
+several flags giving hints on the behavior of the window. The behavior
+is platform-dependent.
+By default, this property contains no window flags.
+Windows are panels. If you set the Qt::Window flag, the ItemIsPanel flag
+will be set automatically. If you clear the Qt::Window flag, the
+ItemIsPanel flag is also cleared. Note that the ItemIsPanel flag can be
+set independently of Qt::Window.
+\sa isWindow(), isPanel()
+*/
+Qt::WindowFlags QGraphicsWidget::windowFlags() const
+{
+Q_D(const QGraphicsWidget);
+return d->windowFlags;
+}
+void QGraphicsWidget::setWindowFlags(Qt::WindowFlags wFlags)
+{
+Q_D(QGraphicsWidget);
+if (d->windowFlags == wFlags)
+return;
+bool wasPopup = (d->windowFlags & Qt::WindowType_Mask) == Qt::Popup;
+d->adjustWindowFlags(&wFlags);
+d->windowFlags = wFlags;
+if (!d->setWindowFrameMargins)
+unsetWindowFrameMargins();
+setFlag(ItemIsPanel, d->windowFlags & Qt::Window);
+bool isPopup = (d->windowFlags & Qt::WindowType_Mask) == Qt::Popup;
+if (d->scene && isVisible() && wasPopup != isPopup) {
+// Popup state changed; update implicit mouse grab.
+if (!isPopup)
+d->scene->d_func()->removePopup(this);
+else
+d->scene->d_func()->addPopup(this);
+}
+if (d->scene && d->scene->d_func()->allItemsIgnoreHoverEvents && d->hasDecoration()) {
+d->scene->d_func()->allItemsIgnoreHoverEvents = false;
+d->scene->d_func()->enableMouseTrackingOnViews();
+}
+}
+/*!
+Returns true if this widget's window is in the active window, or if the
+widget does not have a window but is in an active scene (i.e., a scene
+that currently has focus).
+The active window is the window that either contains a child widget that
+currently has input focus, or that itself has input focus.
+\sa QGraphicsScene::activeWindow(), QGraphicsScene::setActiveWindow(), isActive()
+*/
+bool QGraphicsWidget::isActiveWindow() const
+{
+return isActive();
+}
+/*!
+\property QGraphicsWidget::windowTitle
+\brief This property holds the window title (caption).
+This property is only used for windows.
+By default, if no title has been set, this property contains an
+empty string.
+*/
+void QGraphicsWidget::setWindowTitle(const QString &title)
+{
+Q_D(QGraphicsWidget);
+d->ensureWindowData();
+d->windowData->windowTitle = title;
+}
+QString QGraphicsWidget::windowTitle() const
+{
+Q_D(const QGraphicsWidget);
+return d->windowData ? d->windowData->windowTitle : QString();
+}
+/*!
+\property QGraphicsWidget::focusPolicy
+\brief the way the widget accepts keyboard focus
+The focus policy is Qt::TabFocus if the widget accepts keyboard focus by
+tabbing, Qt::ClickFocus if the widget accepts focus by clicking,
+Qt::StrongFocus if it accepts both, and Qt::NoFocus (the default) if it
+does not accept focus at all.
+You must enable keyboard focus for a widget if it processes keyboard
+events. This is normally done from the widget's constructor. For instance,
+the QLineEdit constructor calls setFocusPolicy(Qt::StrongFocus).
+If you enable a focus policy (i.e., not Qt::NoFocus), QGraphicsWidget will
+automatically enable the ItemIsFocusable flag.  Setting Qt::NoFocus on a
+widget will clear the ItemIsFocusable flag. If the widget currently has
+keyboard focus, the widget will automatically lose focus.
+\sa focusInEvent(), focusOutEvent(), keyPressEvent(), keyReleaseEvent(), enabled
+*/
+Qt::FocusPolicy QGraphicsWidget::focusPolicy() const
+{
+Q_D(const QGraphicsWidget);
+return d->focusPolicy;
+}
+void QGraphicsWidget::setFocusPolicy(Qt::FocusPolicy policy)
+{
+Q_D(QGraphicsWidget);
+if (d->focusPolicy == policy)
+return;
+d->focusPolicy = policy;
+if (hasFocus() && policy == Qt::NoFocus)
+clearFocus();
+setFlag(ItemIsFocusable, policy != Qt::NoFocus);
+}
+/*!
+If this widget, a child or descendant of this widget currently has input
+focus, this function will return a pointer to that widget. If
+no descendant widget has input focus, 0 is returned.
+\sa QGraphicsItem::focusItem(), QWidget::focusWidget()
+*/
+QGraphicsWidget *QGraphicsWidget::focusWidget() const
+{
+Q_D(const QGraphicsWidget);
+if (d->subFocusItem && d->subFocusItem->d_ptr->isWidget)
+return static_cast<QGraphicsWidget *>(d->subFocusItem);
+return 0;
+}
+#ifndef QT_NO_SHORTCUT
+/*!
+\since 4.5
+Adds a shortcut to Qt's shortcut system that watches for the given key \a
+sequence in the given \a context. If the \a context is
+Qt::ApplicationShortcut, the shortcut applies to the application as a
+whole. Otherwise, it is either local to this widget, Qt::WidgetShortcut,
+or to the window itself, Qt::WindowShortcut. For widgets that are not part
+of a window (i.e., top-level widgets and their children),
+Qt::WindowShortcut shortcuts apply to the scene.
+If the same key \a sequence has been grabbed by several widgets,
+when the key \a sequence occurs a QEvent::Shortcut event is sent
+to all the widgets to which it applies in a non-deterministic
+order, but with the ``ambiguous'' flag set to true.
+\warning You should not normally need to use this function;
+instead create \l{QAction}s with the shortcut key sequences you
+require (if you also want equivalent menu options and toolbar
+buttons), or create \l{QShortcut}s if you just need key sequences.
+Both QAction and QShortcut handle all the event filtering for you,
+and provide signals which are triggered when the user triggers the
+key sequence, so are much easier to use than this low-level
+function.
+\sa releaseShortcut() setShortcutEnabled() QWidget::grabShortcut()
+*/
+int QGraphicsWidget::grabShortcut(const QKeySequence &sequence, Qt::ShortcutContext context)
+{
+Q_ASSERT(qApp);
+if (sequence.isEmpty())
+return 0;
+// ### setAttribute(Qt::WA_GrabbedShortcut);
+return qApp->d_func()->shortcutMap.addShortcut(this, sequence, context);
+}
+/*!
+\since 4.5
+Removes the shortcut with the given \a id from Qt's shortcut
+system. The widget will no longer receive QEvent::Shortcut events
+for the shortcut's key sequence (unless it has other shortcuts
+with the same key sequence).
+\warning You should not normally need to use this function since
+Qt's shortcut system removes shortcuts automatically when their
+parent widget is destroyed. It is best to use QAction or
+QShortcut to handle shortcuts, since they are easier to use than
+this low-level function. Note also that this is an expensive
+operation.
+\sa grabShortcut() setShortcutEnabled() , QWidget::releaseShortcut()
+*/
+void QGraphicsWidget::releaseShortcut(int id)
+{
+Q_ASSERT(qApp);
+if (id)
+qApp->d_func()->shortcutMap.removeShortcut(id, this, 0);
+}
+/*!
+\since 4.5
+If \a enabled is true, the shortcut with the given \a id is
+enabled; otherwise the shortcut is disabled.
+\warning You should not normally need to use this function since
+Qt's shortcut system enables/disables shortcuts automatically as
+widgets become hidden/visible and gain or lose focus. It is best
+to use QAction or QShortcut to handle shortcuts, since they are
+easier to use than this low-level function.
+\sa grabShortcut() releaseShortcut(), QWidget::setShortcutEnabled()
+*/
+void QGraphicsWidget::setShortcutEnabled(int id, bool enabled)
+{
+Q_ASSERT(qApp);
+if (id)
+qApp->d_func()->shortcutMap.setShortcutEnabled(enabled, id, this, 0);
+}
+/*!
+\since 4.5
+If \a enabled is true, auto repeat of the shortcut with the
+given \a id is enabled; otherwise it is disabled.
+\sa grabShortcut() releaseShortcut() QWidget::setShortcutAutoRepeat()
+*/
+void QGraphicsWidget::setShortcutAutoRepeat(int id, bool enabled)
+{
+Q_ASSERT(qApp);
+if (id)
+qApp->d_func()->shortcutMap.setShortcutAutoRepeat(enabled, id, this, 0);
+}
+#endif
+#ifndef QT_NO_ACTION
+/*!
+\since 4.5
+Appends the action \a action to this widget's list of actions.
+All QGraphicsWidgets have a list of \l{QAction}s, however they can be
+represented graphically in many different ways. The default use of the
+QAction list (as returned by actions()) is to create a context QMenu.
+A QGraphicsWidget should only have one of each action and adding an action
+it already has will not cause the same action to be in the widget twice.
+\sa removeAction(), insertAction(), actions(), QWidget::addAction()
+*/
+void QGraphicsWidget::addAction(QAction *action)
+{
+insertAction(0, action);
+}
+/*!
+\since 4.5
+Appends the actions \a actions to this widget's list of actions.
+\sa removeAction(), QMenu, addAction(), QWidget::addActions()
+*/
+void QGraphicsWidget::addActions(QList<QAction *> actions)
+{
+for (int i = 0; i < actions.count(); ++i)
+insertAction(0, actions.at(i));
+}
+/*!
+\since 4.5
+Inserts the action \a action to this widget's list of actions,
+before the action \a before. It appends the action if \a before is 0 or
+\a before is not a valid action for this widget.
+A QGraphicsWidget should only have one of each action.
+\sa removeAction(), addAction(), QMenu, actions(),
+QWidget::insertActions()
+*/
+void QGraphicsWidget::insertAction(QAction *before, QAction *action)
+{
+if (!action) {
+qWarning("QWidget::insertAction: Attempt to insert null action");
+return;
+}
+Q_D(QGraphicsWidget);
+int index = d->actions.indexOf(action);
+if (index != -1)
+d->actions.removeAt(index);
+int pos = d->actions.indexOf(before);
+if (pos < 0) {
+before = 0;
+pos = d->actions.size();
+}
+d->actions.insert(pos, action);
+if (index == -1) {
+QActionPrivate *apriv = action->d_func();
+apriv->graphicsWidgets.append(this);
+}
+QActionEvent e(QEvent::ActionAdded, action, before);
+QApplication::sendEvent(this, &e);
+}
+/*!
+\since 4.5
+Inserts the actions \a actions to this widget's list of actions,
+before the action \a before. It appends the action if \a before is 0 or
+\a before is not a valid action for this widget.
+A QGraphicsWidget can have at most one of each action.
+\sa removeAction(), QMenu, insertAction(), QWidget::insertActions()
+*/
+void QGraphicsWidget::insertActions(QAction *before, QList<QAction *> actions)
+{
+for (int i = 0; i < actions.count(); ++i)
+insertAction(before, actions.at(i));
+}
+/*!
+\since 4.5
+Removes the action \a action from this widget's list of actions.
+\sa insertAction(), actions(), insertAction(), QWidget::removeAction()
+*/
+void QGraphicsWidget::removeAction(QAction *action)
+{
+if (!action)
+return;
+Q_D(QGraphicsWidget);
+QActionPrivate *apriv = action->d_func();
+apriv->graphicsWidgets.removeAll(this);
+if (d->actions.removeAll(action)) {
+QActionEvent e(QEvent::ActionRemoved, action);
+QApplication::sendEvent(this, &e);
+}
+}
+/*!
+\since 4.5
+Returns the (possibly empty) list of this widget's actions.
+\sa insertAction(), removeAction(), QWidget::actions(),
+QAction::associatedWidgets(), QAction::associatedGraphicsWidgets()
+*/
+QList<QAction *> QGraphicsWidget::actions() const
+{
+Q_D(const QGraphicsWidget);
+return d->actions;
+}
+#endif
+/*!
+Moves the \a second widget around the ring of focus widgets so that
+keyboard focus moves from the \a first widget to the \a second widget when
+the Tab key is pressed.
+Note that since the tab order of the \a second widget is changed, you
+should order a chain like this:
+\snippet doc/src/snippets/code/src_gui_graphicsview_qgraphicswidget.cpp 1
+\e not like this:
+\snippet doc/src/snippets/code/src_gui_graphicsview_qgraphicswidget.cpp 2
+If \a first is 0, this indicates that \a second should be the first widget
+to receive input focus should the scene gain Tab focus (i.e., the user
+hits Tab so that focus passes into the scene). If \a second is 0, this
+indicates that \a first should be the first widget to gain focus if the
+scene gained BackTab focus.
+By default, tab order is defined implicitly using widget creation order.
+\sa focusPolicy, {Keyboard Focus}
+*/
+void QGraphicsWidget::setTabOrder(QGraphicsWidget *first, QGraphicsWidget *second)
+{
+if (!first && !second) {
+qWarning("QGraphicsWidget::setTabOrder(0, 0) is undefined");
+return;
+}
+if ((first && second) && first->scene() != second->scene()) {
+qWarning("QGraphicsWidget::setTabOrder: scenes %p and %p are different",
+first->scene(), second->scene());
+return;
+}
+QGraphicsScene *scene = first ? first->scene() : second->scene();
+if (!scene && (!first || !second)) {
+qWarning("QGraphicsWidget::setTabOrder: assigning tab order from/to the"
+" scene requires the item to be in a scene.");
+return;
+}
+// If either first or second are 0, the scene's tabFocusFirst is updated
+// to point to the first item in the scene's focus chain. Then first or
+// second are set to point to tabFocusFirst.
+QGraphicsScenePrivate *sceneD = scene->d_func();
+if (!first) {
+sceneD->tabFocusFirst = second;
+return;
+}
+if (!second) {
+sceneD->tabFocusFirst = first->d_func()->focusNext;
+return;
+}
+// Both first and second are != 0.
+QGraphicsWidget *firstFocusNext = first->d_func()->focusNext;
+if (firstFocusNext == second) {
+// Nothing to do.
+return;
+}
+// Update the focus chain.
+QGraphicsWidget *secondFocusPrev = second->d_func()->focusPrev;
+QGraphicsWidget *secondFocusNext = second->d_func()->focusNext;
+firstFocusNext->d_func()->focusPrev = second;
+first->d_func()->focusNext = second;
+second->d_func()->focusNext = firstFocusNext;
+second->d_func()->focusPrev = first;
+secondFocusPrev->d_func()->focusNext = secondFocusNext;
+secondFocusNext->d_func()->focusPrev = secondFocusPrev;
+Q_ASSERT(first->d_func()->focusNext->d_func()->focusPrev == first);
+Q_ASSERT(first->d_func()->focusPrev->d_func()->focusNext == first);
+Q_ASSERT(second->d_func()->focusNext->d_func()->focusPrev == second);
+Q_ASSERT(second->d_func()->focusPrev->d_func()->focusNext == second);
+}
+/*!
+If \a on is true, this function enables \a attribute; otherwise
+\a attribute is disabled.
+See the class documentation for QGraphicsWidget for a complete list of
+which attributes are supported, and what they are for.
+\sa testAttribute(), QWidget::setAttribute()
+*/
+void QGraphicsWidget::setAttribute(Qt::WidgetAttribute attribute, bool on)
+{
+Q_D(QGraphicsWidget);
+// ### most flags require some immediate action
+// ### we might want to qWarn use of unsupported attributes
+// ### we might want to not use Qt::WidgetAttribute, but roll our own instead
+d->setAttribute(attribute, on);
+}
+/*!
+Returns true if \a attribute is enabled for this widget; otherwise,
+returns false.
+\sa setAttribute()
+*/
+bool QGraphicsWidget::testAttribute(Qt::WidgetAttribute attribute) const
+{
+Q_D(const QGraphicsWidget);
+return d->testAttribute(attribute);
+}
+/*!
+\reimp
+*/
+int QGraphicsWidget::type() const
+{
+return Type;
+}
+/*!
+\reimp
+*/
+void QGraphicsWidget::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
+{
+Q_UNUSED(painter);
+Q_UNUSED(option);
+Q_UNUSED(widget);
+}
+/*!
+This virtual function is called by QGraphicsScene to draw the window frame
+for windows using \a painter, \a option, and \a widget, in local
+coordinates. The base implementation uses the current style to render the
+frame and title bar.
+You can reimplement this function in a subclass of QGraphicsWidget to
+provide custom rendering of the widget's window frame.
+\sa QGraphicsItem::paint()
+*/
+void QGraphicsWidget::paintWindowFrame(QPainter *painter, const QStyleOptionGraphicsItem *option,
+QWidget *widget)
+{
+const bool fillBackground = !testAttribute(Qt::WA_OpaquePaintEvent)
+&& !testAttribute(Qt::WA_NoSystemBackground);
+QGraphicsProxyWidget *proxy = qobject_cast<QGraphicsProxyWidget *>(this);
+const bool embeddedWidgetFillsOwnBackground = proxy && proxy->widget();
+if (rect().contains(option->exposedRect)) {
+if (fillBackground && !embeddedWidgetFillsOwnBackground)
+painter->fillRect(option->exposedRect, palette().window());
+return;
+}
+Q_D(QGraphicsWidget);
+QRect windowFrameRect = QRect(QPoint(), windowFrameGeometry().size().toSize());
+QStyleOptionTitleBar bar;
+bar.QStyleOption::operator=(*option);
+d->initStyleOptionTitleBar(&bar);   // this clear flags in bar.state
+d->ensureWindowData();
+if (d->windowData->buttonMouseOver)
+bar.state |= QStyle::State_MouseOver;
+else
+bar.state &= ~QStyle::State_MouseOver;
+if (d->windowData->buttonSunken)
+bar.state |= QStyle::State_Sunken;
+else
+bar.state &= ~QStyle::State_Sunken;
+bar.rect = windowFrameRect;
+// translate painter to make the style happy
+const QPointF styleOrigin = this->windowFrameRect().topLeft();
+painter->translate(styleOrigin);
+#ifdef Q_WS_MAC
+const QSize pixmapSize = windowFrameRect.size();
+if (pixmapSize.width() <= 0 || pixmapSize.height() <= 0)
+return;
+QPainter *realPainter = painter;
+QPixmap pm(pixmapSize);
+painter = new QPainter(&pm);
+#endif
+// Fill background
+QStyleHintReturnMask mask;
+bool setMask = style()->styleHint(QStyle::SH_WindowFrame_Mask, &bar, widget, &mask) && !mask.region.isEmpty();
+bool hasBorder = !style()->styleHint(QStyle::SH_TitleBar_NoBorder, &bar, widget);
+int frameWidth = style()->pixelMetric(QStyle::PM_MDIFrameWidth, &bar, widget);
+if (setMask) {
+painter->save();
+painter->setClipRegion(mask.region, Qt::IntersectClip);
+}
+if (fillBackground) {
+if (embeddedWidgetFillsOwnBackground) {
+// Don't fill the background twice.
+QPainterPath windowFrameBackground;
+windowFrameBackground.addRect(windowFrameRect);
+// Adjust with 0.5 to avoid border artifacts between
+// widget background and frame background.
+windowFrameBackground.addRect(rect().translated(-styleOrigin).adjusted(0.5, 0.5, -0.5, -0.5));
+painter->fillPath(windowFrameBackground, palette().window());
+} else {
+painter->fillRect(windowFrameRect, palette().window());
+}
+}
+painter->setRenderHint(QPainter::NonCosmeticDefaultPen);
+// Draw title
+int height = (int)d->titleBarHeight(bar);
+bar.rect.setHeight(height);
+if (hasBorder) // Frame is painted by PE_FrameWindow
+bar.rect.adjust(frameWidth, frameWidth, -frameWidth, 0);
+painter->save();
+painter->setFont(QApplication::font("QWorkspaceTitleBar"));
+style()->drawComplexControl(QStyle::CC_TitleBar, &bar, painter, widget);
+painter->restore();
+if (setMask)
+painter->restore();
+// Draw window frame
+QStyleOptionFrame frameOptions;
+frameOptions.QStyleOption::operator=(*option);
+initStyleOption(&frameOptions);
+if (!hasBorder)
+painter->setClipRect(windowFrameRect.adjusted(0, +height, 0, 0), Qt::IntersectClip);
+if (hasFocus()) {
+frameOptions.state |= QStyle::State_HasFocus;
+} else {
+frameOptions.state &= ~QStyle::State_HasFocus;
+}
+bool isActive = isActiveWindow();
+if (isActive) {
+frameOptions.state |= QStyle::State_Active;
+} else {
+frameOptions.state &= ~QStyle::State_Active;
+}
+frameOptions.palette.setCurrentColorGroup(isActive ? QPalette::Active : QPalette::Normal);
+frameOptions.rect = windowFrameRect;
+frameOptions.lineWidth = style()->pixelMetric(QStyle::PM_MdiSubWindowFrameWidth, 0, widget);
+frameOptions.midLineWidth = 1;
+style()->drawPrimitive(QStyle::PE_FrameWindow, &frameOptions, painter, widget);
+#ifdef Q_WS_MAC
+realPainter->drawPixmap(QPoint(), pm);
+delete painter;
+#endif
+}
+/*!
+\reimp
+*/
+QRectF QGraphicsWidget::boundingRect() const
+{
+return windowFrameRect();
+}
+/*!
+\reimp
+*/
+QPainterPath QGraphicsWidget::shape() const
+{
+QPainterPath path;
+path.addRect(rect());
+return path;
+}
+/*!
+Call this function to close the widget.
+Returns true if the widget was closed; otherwise returns false.
+This slot will first send a QCloseEvent to the widget, which may or may
+not accept the event. If the event was ignored, nothing happens. If the
+event was accepted, it will hide() the widget.
+If the widget has the Qt::WA_DeleteOnClose attribute set it will be
+deleted.
+*/
+bool QGraphicsWidget::close()
+{
+QCloseEvent closeEvent;
+QApplication::sendEvent(this, &closeEvent);
+if (!closeEvent.isAccepted()) {
+return false;
+}
+// hide
+if (isVisible()) {
+hide();
+}
+if (testAttribute(Qt::WA_DeleteOnClose)) {
+deleteLater();
+}
+return true;
+}
+#ifdef Q_NO_USING_KEYWORD
+/*!
+\fn const QObjectList &QGraphicsWidget::children() const
+\internal
+This function returns the same value as QObject::children(). It's
+provided to differentiate between the obsolete member
+QGraphicsItem::children() and QObject::children(). QGraphicsItem now
+provides childItems() instead.
+*/
+#endif
+#if 0
+void QGraphicsWidget::dumpFocusChain()
+{
+qDebug() << "=========== Dumping focus chain ==============";
+int i = 0;
+QGraphicsWidget *next = this;
+QSet<QGraphicsWidget*> visited;
+do {
+if (!next) {
+qWarning("Found a focus chain that is not circular, (next == 0)");
+break;
+}
+qDebug() << i++ << QString::number(uint(next), 16) << next->className() << next->data(0) << QString::fromAscii("focusItem:%1").arg(next->hasFocus() ? '1' : '0') << QLatin1String("next:") << next->d_func()->focusNext->data(0) << QLatin1String("prev:") << next->d_func()->focusPrev->data(0);
+if (visited.contains(next)) {
+qWarning("Already visited this node. However, I expected to dump until I found myself.");
+break;
+}
+visited << next;
+next = next->d_func()->focusNext;
+} while (next != this);
+}
+#endif
+QT_END_NAMESPACE
+#endif //QT_NO_GRAPHICSVIEW