/****************************************************************************

**

** 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 is changed in setGeometry().

*/

/*!

    \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);

    // 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);