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

**

** 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 "qgraphicslayout.h"

#include "qgraphicsproxywidget.h"

#include "private/qgraphicsproxywidget_p.h"

#include "private/qwidget_p.h"

#include "private/qapplication_p.h"

#include <QtCore/qdebug.h>

#include <QtGui/qevent.h>

#include <QtGui/qgraphicsscene.h>

#include <QtGui/qgraphicssceneevent.h>

#include <QtGui/qlayout.h>

#include <QtGui/qpainter.h>

#include <QtGui/qstyleoption.h>

#include <QtGui/qgraphicsview.h>

#include <QtGui/qlistview.h>

#include <QtGui/qlineedit.h>

#include <QtGui/qtextedit.h>

QT_BEGIN_NAMESPACE

//#define GRAPHICSPROXYWIDGET_DEBUG

/*!

    \class QGraphicsProxyWidget

    \brief The QGraphicsProxyWidget class provides a proxy layer for embedding

    a QWidget in a QGraphicsScene.

    \since 4.4

    \ingroup graphicsview-api

    QGraphicsProxyWidget embeds QWidget-based widgets, for example, a

    QPushButton, QFontComboBox, or even QFileDialog, into

    QGraphicsScene. It forwards events between the two objects and

    translates between QWidget's integer-based geometry and

    QGraphicsWidget's qreal-based geometry. QGraphicsProxyWidget

    supports all core features of QWidget, including tab focus,

    keyboard input, Drag & Drop, and popups.  You can also embed

    complex widgets, e.g., widgets with subwidgets.

    Example:

    \snippet doc/src/snippets/code/src_gui_graphicsview_qgraphicsproxywidget.cpp 0

    QGraphicsProxyWidget takes care of automatically embedding popup children

    of embedded widgets through creating a child proxy for each popup. This

    means that when an embedded QComboBox shows its popup list, a new

    QGraphicsProxyWidget is created automatically, embedding the popup, and

    positioning it correctly. This only works if the popup is child of the

    embedded widget (for example QToolButton::setMenu() requires the QMenu instance

    to be child of the QToolButton).

    \section1 Embedding a Widget with QGraphicsProxyWidget

    There are two ways to embed a widget using QGraphicsProxyWidget. The most

    common way is to pass a widget pointer to QGraphicsScene::addWidget()

    together with any relevant \l Qt::WindowFlags. This function returns a

    pointer to a QGraphicsProxyWidget. You can then choose to reparent or

    position either the proxy, or the embedded widget itself.

    For example, in the code snippet below, we embed a group box into the proxy:

    \snippet doc/src/snippets/code/src_gui_graphicsview_qgraphicsproxywidget.cpp 1

    The image below is the output obtained with its contents margin and

    contents rect labeled.

    \image qgraphicsproxywidget-embed.png

    Alternatively, you can start by creating a new QGraphicsProxyWidget item,

    and then call setWidget() to embed a QWidget later. The widget() function

    returns a pointer to the embedded widget. QGraphicsProxyWidget shares

    ownership with QWidget, so if either of the two widgets are destroyed, the

    other widget will be automatically destroyed as well.

    \section1 Synchronizing Widget States

    QGraphicsProxyWidget keeps its state in sync with the embedded widget. For

    example, if the proxy is hidden or disabled, the embedded widget will be

    hidden or disabled as well, and vice versa. When the widget is embedded by

    calling addWidget(), QGraphicsProxyWidget copies the state from the widget

    into the proxy, and after that, the two will stay synchronized where

    possible. By default, when you embed a widget into a proxy, both the widget

    and the proxy will be visible because a QGraphicsWidget is visible when

    created (you do not have to call show()). If you explicitly hide the

    embedded widget, the proxy will also become invisible.

    Example:

    \snippet doc/src/snippets/code/src_gui_graphicsview_qgraphicsproxywidget.cpp 2

    QGraphicsProxyWidget maintains symmetry for the following states:

    \table

    \header \o QWidget state       \o QGraphicsProxyWidget state      \o Notes

    \row     \o QWidget::enabled

                    \o QGraphicsProxyWidget::enabled

                        \o

    \row    \o QWidget::visible

                    \o QGraphicsProxyWidget::visible

                        \o The explicit state is also symmetric.

    \row    \o QWidget::geometry

                    \o QGraphicsProxyWidget::geometry

                        \o Geometry is only guaranteed to be symmetric while

                            the embedded widget is visible.

    \row    \o QWidget::layoutDirection

                    \o QGraphicsProxyWidget::layoutDirection

                        \o

    \row    \o QWidget::style

                    \o QGraphicsProxyWidget::style

                        \o

    \row    \o QWidget::palette

                    \o QGraphicsProxyWidget::palette

                        \o

    \row    \o QWidget::font

                    \o QGraphicsProxyWidget::font

                        \o

    \row    \o QWidget::cursor

                    \o QGraphicsProxyWidget::cursor

                        \o The embedded widget overrides the proxy widget

                            cursor. The proxy cursor changes depending on

                            which embedded subwidget is currently under the

                            mouse.

    \row    \o QWidget::sizeHint()

                    \o QGraphicsProxyWidget::sizeHint()

                        \o All size hint functionality from the embedded

                            widget is forwarded by the proxy.

    \row    \o QWidget::getContentsMargins()

                    \o QGraphicsProxyWidget::getContentsMargins()

                        \o Updated once by setWidget().

    \row    \o QWidget::windowTitle

                    \o QGraphicsProxyWidget::windowTitle

                        \o Updated once by setWidget().

    \endtable

    \note QGraphicsScene keeps the embedded widget in a special state that

    prevents it from disturbing other widgets (both embedded and not embedded)

    while the widget is embedded. In this state, the widget may differ slightly

    in behavior from when it is not embedded.

    \warning This class is provided for convenience when bridging

    QWidgets and QGraphicsItems, it should not be used for

    high-performance scenarios.

    \sa QGraphicsScene::addWidget(), QGraphicsWidget

*/

extern bool qt_sendSpontaneousEvent(QObject *, QEvent *);

/*!

    \internal

*/

void QGraphicsProxyWidgetPrivate::init()

{

    Q_Q(QGraphicsProxyWidget);

    q->setFocusPolicy(Qt::WheelFocus);

    q->setAcceptDrops(true);

}

/*!

    \internal

*/

void QGraphicsProxyWidgetPrivate::sendWidgetMouseEvent(QGraphicsSceneHoverEvent *event)

{

    QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseMove);

    mouseEvent.setPos(event->pos());

    mouseEvent.setScreenPos(event->screenPos());

    mouseEvent.setButton(Qt::NoButton);

    mouseEvent.setButtons(0);

    mouseEvent.setModifiers(event->modifiers());

    sendWidgetMouseEvent(&mouseEvent);

    event->setAccepted(mouseEvent.isAccepted());

}

/*!

    \internal

*/

void QGraphicsProxyWidgetPrivate::sendWidgetMouseEvent(QGraphicsSceneMouseEvent *event)

{

    if (!event || !widget || !widget->isVisible())

        return;

    Q_Q(QGraphicsProxyWidget);

    // Find widget position and receiver.

    QPointF pos = event->pos();

    QPointer<QWidget> alienWidget = widget->childAt(pos.toPoint());

    QPointer<QWidget> receiver =  alienWidget ? alienWidget : widget;

    if (QWidgetPrivate::nearestGraphicsProxyWidget(receiver) != q)

        return; //another proxywidget will handle the events

    // Translate QGraphicsSceneMouse events to QMouseEvents.

    QEvent::Type type = QEvent::None;

    switch (event->type()) {

    case QEvent::GraphicsSceneMousePress:

        type = QEvent::MouseButtonPress;

        if (!embeddedMouseGrabber)

            embeddedMouseGrabber = receiver;

        else

            receiver = embeddedMouseGrabber;

        break;

    case QEvent::GraphicsSceneMouseRelease:

        type = QEvent::MouseButtonRelease;

        if (embeddedMouseGrabber)

            receiver = embeddedMouseGrabber;

        break;

    case QEvent::GraphicsSceneMouseDoubleClick:

        type = QEvent::MouseButtonDblClick;

        if (!embeddedMouseGrabber)

            embeddedMouseGrabber = receiver;

        else

            receiver = embeddedMouseGrabber;

        break;

    case QEvent::GraphicsSceneMouseMove:

        type = QEvent::MouseMove;

        if (embeddedMouseGrabber)

            receiver = embeddedMouseGrabber;

        break;

    default:

        Q_ASSERT_X(false, "QGraphicsProxyWidget", "internal error");

        break;

    }

    if (!lastWidgetUnderMouse) {

        QApplicationPrivate::dispatchEnterLeave(embeddedMouseGrabber ? embeddedMouseGrabber : widget, 0);

        lastWidgetUnderMouse = widget;

    }

    // Map event position from us to the receiver

    pos = mapToReceiver(pos, receiver);

    // Send mouse event.

    QMouseEvent *mouseEvent = QMouseEvent::createExtendedMouseEvent(type, pos,

                                                                    receiver->mapToGlobal(pos.toPoint()), event->button(),

                                                                    event->buttons(), event->modifiers());

    QWidget *embeddedMouseGrabberPtr = (QWidget *)embeddedMouseGrabber;

    QApplicationPrivate::sendMouseEvent(receiver, mouseEvent, alienWidget, widget,

                                        &embeddedMouseGrabberPtr, lastWidgetUnderMouse, event->spontaneous());

    embeddedMouseGrabber = embeddedMouseGrabberPtr;

    // Handle enter/leave events when last button is released from mouse

    // grabber child widget.

    if (embeddedMouseGrabber && type == QEvent::MouseButtonRelease && !event->buttons()) {

        Q_Q(QGraphicsProxyWidget);

        if (q->rect().contains(event->pos()) && q->acceptsHoverEvents())

            lastWidgetUnderMouse = alienWidget ? alienWidget : widget;

        else // released on the frame our outside the item, or doesn't accept hover events.

            lastWidgetUnderMouse = 0;

        QApplicationPrivate::dispatchEnterLeave(lastWidgetUnderMouse, embeddedMouseGrabber);

        embeddedMouseGrabber = 0;

#ifndef QT_NO_CURSOR

        // ### Restore the cursor, don't override it.

        if (!lastWidgetUnderMouse)

            q->unsetCursor();

#endif

    }

    event->setAccepted(mouseEvent->isAccepted());

    delete mouseEvent;

}

void QGraphicsProxyWidgetPrivate::sendWidgetKeyEvent(QKeyEvent *event)

{

    Q_Q(QGraphicsProxyWidget);

    if (!event || !widget || !widget->isVisible())

        return;

    QPointer<QWidget> receiver = widget->focusWidget();

    if (!receiver)

        receiver = widget;

    Q_ASSERT(receiver);

    do {

        bool res = QApplication::sendEvent(receiver, event);

        if ((res && event->isAccepted()) || (q->isWindow() && receiver == widget))

            break;

        receiver = receiver->parentWidget();

    } while (receiver);

}

/*!

    \internal

*/

void QGraphicsProxyWidgetPrivate::removeSubFocusHelper(QWidget *widget, Qt::FocusReason reason)

{

    QFocusEvent event(QEvent::FocusOut, reason);

    QPointer<QWidget> widgetGuard = widget;

    QApplication::sendEvent(widget, &event);

    if (widgetGuard && event.isAccepted())

        QApplication::sendEvent(widget->style(), &event);

}

/*!

    \internal

    Reimplemented from QGraphicsItemPrivate. ### Qt 5: Move impl to

    reimplementation QGraphicsProxyWidget::inputMethodQuery().

*/

QVariant QGraphicsProxyWidgetPrivate::inputMethodQueryHelper(Qt::InputMethodQuery query) const

{

    Q_Q(const QGraphicsProxyWidget);

    if (!widget || !q->hasFocus())

        return QVariant();

    QWidget *focusWidget = widget->focusWidget();

    if (!focusWidget)

        focusWidget = widget;

    QVariant v = focusWidget->inputMethodQuery(query);

    QPointF focusWidgetPos = q->subWidgetRect(focusWidget).topLeft();

    switch (v.type()) {

    case QVariant::RectF:

        v = v.toRectF().translated(focusWidgetPos);

        break;

    case QVariant::PointF:

        v = v.toPointF() + focusWidgetPos;

        break;

    case QVariant::Rect:

        v = v.toRect().translated(focusWidgetPos.toPoint());

        break;

    case QVariant::Point:

        v = v.toPoint() + focusWidgetPos.toPoint();

        break;

    default:

        break;

    }

    return v;

}

/*!

    \internal

    Some of the logic is shared with QApplicationPrivate::focusNextPrevChild_helper

*/

QWidget *QGraphicsProxyWidgetPrivate::findFocusChild(QWidget *child, bool next) const

{

    if (!widget)

        return 0;

    // Run around the focus chain until we find a widget that can take tab focus.

    if (!child) {

	child = next ? (QWidget *)widget : widget->d_func()->focus_prev;

    } else {

        child = next ? child->d_func()->focus_next : child->d_func()->focus_prev;

        if ((next && child == widget) || (!next && child == widget->d_func()->focus_prev)) {

             return 0;

        }

    }

    QWidget *oldChild = child;

    uint focus_flag = qt_tab_all_widgets ? Qt::TabFocus : Qt::StrongFocus;

    do {

        if (child->isEnabled()

	    && child->isVisibleTo(widget)

            && ((child->focusPolicy() & focus_flag) == focus_flag)

            && !(child->d_func()->extra && child->d_func()->extra->focus_proxy)) {

            return child;

        }

        child = next ? child->d_func()->focus_next : child->d_func()->focus_prev;

    } while (child != oldChild && !(next && child == widget) && !(!next && child == widget->d_func()->focus_prev));

    return 0;

}

/*!

    \internal

*/

void QGraphicsProxyWidgetPrivate::_q_removeWidgetSlot()

{

    Q_Q(QGraphicsProxyWidget);

    widget = 0;

    delete q;

}

/*!

    \internal

*/

void QGraphicsProxyWidgetPrivate::updateWidgetGeometryFromProxy()

{

}

/*!

    \internal

*/

void QGraphicsProxyWidgetPrivate::updateProxyGeometryFromWidget()

{

    Q_Q(QGraphicsProxyWidget);

    if (!widget)

        return;

    QRectF widgetGeometry = widget->geometry();

    QWidget *parentWidget = widget->parentWidget();

    if (widget->isWindow()) {

        QGraphicsProxyWidget *proxyParent = 0;

        if (parentWidget && (proxyParent = qobject_cast<QGraphicsProxyWidget *>(q->parentWidget()))) {

            // Nested window proxy (e.g., combobox popup), map widget to the

            // parent widget's global coordinates, and map that to the parent

            // proxy's child coordinates.

            widgetGeometry.moveTo(proxyParent->subWidgetRect(parentWidget).topLeft()

                                  + parentWidget->mapFromGlobal(widget->pos()));

        }

    }

    // Adjust to size hint if the widget has never been resized.

    if (!widget->size().isValid())

        widgetGeometry.setSize(widget->sizeHint());

    // Assign new geometry.

    posChangeMode = QGraphicsProxyWidgetPrivate::WidgetToProxyMode;

    sizeChangeMode = QGraphicsProxyWidgetPrivate::WidgetToProxyMode;

    q->setGeometry(widgetGeometry);

    posChangeMode = QGraphicsProxyWidgetPrivate::NoMode;

    sizeChangeMode = QGraphicsProxyWidgetPrivate::NoMode;

}

/*!

    \internal

*/

void QGraphicsProxyWidgetPrivate::updateProxyInputMethodAcceptanceFromWidget()

{

    Q_Q(QGraphicsProxyWidget);

    if (!widget)

        return;

    QWidget *focusWidget = widget->focusWidget();

    if (!focusWidget)

        focusWidget = widget;

    q->setFlag(QGraphicsItem::ItemAcceptsInputMethod,

               focusWidget->testAttribute(Qt::WA_InputMethodEnabled));

}

/*!

    \internal

    Embeds \a subWin as a subwindow of this proxy widget. \a subWin must be a top-level

    widget and a descendant of the widget managed by this proxy. A separate subproxy

    will be created as a child of this proxy widget to manage \a subWin.

*/

void QGraphicsProxyWidgetPrivate::embedSubWindow(QWidget *subWin)

{

    QWExtra *extra;

    if (!((extra = subWin->d_func()->extra) && extra->proxyWidget)) {

        QGraphicsProxyWidget *subProxy = new QGraphicsProxyWidget(q_func(), subWin->windowFlags());

        subProxy->d_func()->setWidget_helper(subWin, false);

    }

}

/*!

    \internal

    Removes ("unembeds") \a subWin and deletes the proxy holder item. This can

    happen when QWidget::setParent() reparents the embedded window out of

    "embedded space".

*/

void QGraphicsProxyWidgetPrivate::unembedSubWindow(QWidget *subWin)

{

    foreach (QGraphicsItem *child, children) {

        if (child->isWidget()) {

            if (QGraphicsProxyWidget *proxy = qobject_cast<QGraphicsProxyWidget *>(static_cast<QGraphicsWidget *>(child))) {

                if (proxy->widget() == subWin) {

                    proxy->setWidget(0);

                    scene->removeItem(proxy);

                    delete proxy;

                    return;

                }

            }

        }

    }

}

bool QGraphicsProxyWidgetPrivate::isProxyWidget() const

{

    return true;

}

/*!

     \internal

*/

QPointF QGraphicsProxyWidgetPrivate::mapToReceiver(const QPointF &pos, const QWidget *receiver) const

{

    QPointF p = pos;

    // Map event position from us to the receiver, preserving its

    // precision (don't use QWidget::mapFrom here).

    while (receiver && receiver != widget) {