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

**

** 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 <QtCore/qdebug.h>

#include "qgraphicswidget_p.h"

#include "qgraphicslayout.h"

#include "qgraphicsscene_p.h"

#include <QtGui/qapplication.h>

#include <QtGui/qgraphicsscene.h>

#include <QtGui/qstyleoption.h>

#include <QtGui/QStyleOptionTitleBar>

#include <QtGui/QGraphicsSceneMouseEvent>

#if defined(Q_WS_MAC) && !defined(QT_NO_STYLE_MAC)

# include <QMacStyle>

#endif

QT_BEGIN_NAMESPACE

void QGraphicsWidgetPrivate::init(QGraphicsItem *parentItem, Qt::WindowFlags wFlags)

{

    Q_Q(QGraphicsWidget);

    attributes = 0;

    isWidget = 1; // QGraphicsItem::isWidget() returns true.

    focusNext = focusPrev = q;

    focusPolicy = Qt::NoFocus;

    adjustWindowFlags(&wFlags);

    windowFlags = wFlags;

    q->setParentItem(parentItem);

    q->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred, QSizePolicy::DefaultType));

    q->setGraphicsItem(q);

    resolveLayoutDirection();

    q->unsetWindowFrameMargins();

    q->setFlag(QGraphicsItem::ItemUsesExtendedStyleOption);

    q->setFlag(QGraphicsItem::ItemSendsGeometryChanges);

}

qreal QGraphicsWidgetPrivate::titleBarHeight(const QStyleOptionTitleBar &options) const

{

    Q_Q(const QGraphicsWidget);

    int height = q->style()->pixelMetric(QStyle::PM_TitleBarHeight, &options);

#if defined(Q_WS_MAC) && !defined(QT_NO_STYLE_MAC)

    if (qobject_cast<QMacStyle*>(q->style())) {

        height -=4;

    }

#endif

    return (qreal)height;

}

/*!

    \internal

*/

QGraphicsWidgetPrivate::~QGraphicsWidgetPrivate()

{

    // Remove any lazily allocated data

    delete[] margins;

    delete[] windowFrameMargins;

    delete windowData;

}

/*!

    \internal

     Ensures that margins is allocated.

     This function must be called before any dereferencing.

*/

void QGraphicsWidgetPrivate::ensureMargins() const

{

    if (!margins) {

        margins = new qreal[4];

        for (int i = 0; i < 4; ++i)

            margins[i] = 0;

    }

}

/*!

    \internal

     Ensures that windowFrameMargins is allocated.

     This function must be called before any dereferencing.

*/

void QGraphicsWidgetPrivate::ensureWindowFrameMargins() const

{

    if (!windowFrameMargins) {

        windowFrameMargins = new qreal[4];

        for (int i = 0; i < 4; ++i)

            windowFrameMargins[i] = 0;

    }

}

/*!

    \internal

     Ensures that windowData is allocated.

     This function must be called before any dereferencing.

*/

void QGraphicsWidgetPrivate::ensureWindowData()

{

    if (!windowData)

        windowData = new WindowData;

}

void QGraphicsWidgetPrivate::setPalette_helper(const QPalette &palette)

{

    if (this->palette == palette && this->palette.resolve() == palette.resolve())

        return;

    updatePalette(palette);

}

void QGraphicsWidgetPrivate::resolvePalette(uint inheritedMask)

{

    inheritedPaletteResolveMask = inheritedMask;

    QPalette naturalPalette = naturalWidgetPalette();

    QPalette resolvedPalette = palette.resolve(naturalPalette);

    updatePalette(resolvedPalette);

}

void QGraphicsWidgetPrivate::updatePalette(const QPalette &palette)

{

    Q_Q(QGraphicsWidget);

    // Update local palette setting.

    this->palette = palette;

    // Calculate new mask.

    if (q->isWindow() && !q->testAttribute(Qt::WA_WindowPropagation))

        inheritedPaletteResolveMask = 0;

    int mask = palette.resolve() | inheritedPaletteResolveMask;

    // Propagate to children.

    for (int i = 0; i < children.size(); ++i) {

        QGraphicsItem *item = children.at(i);

        if (item->isWidget()) {

            QGraphicsWidget *w = static_cast<QGraphicsWidget *>(item);

            if (!w->isWindow() || w->testAttribute(Qt::WA_WindowPropagation))

                w->d_func()->resolvePalette(mask);

        } else {

            item->d_ptr->resolvePalette(mask);

        }

    }

    // Notify change.

    QEvent event(QEvent::PaletteChange);

    QApplication::sendEvent(q, &event);

}

void QGraphicsWidgetPrivate::setLayoutDirection_helper(Qt::LayoutDirection direction)

{

    Q_Q(QGraphicsWidget);

    if ((direction == Qt::RightToLeft) == (testAttribute(Qt::WA_RightToLeft)))

        return;

    q->setAttribute(Qt::WA_RightToLeft, (direction == Qt::RightToLeft));

    // Propagate this change to all children.

    for (int i = 0; i < children.size(); ++i) {

        QGraphicsItem *item = children.at(i);

        if (item->isWidget()) {

            QGraphicsWidget *widget = static_cast<QGraphicsWidget *>(item);

            if (widget->parentWidget() && !widget->testAttribute(Qt::WA_SetLayoutDirection))

                widget->d_func()->setLayoutDirection_helper(direction);

        }

    }

    // Send the notification event to this widget item.

    QEvent e(QEvent::LayoutDirectionChange);

    QApplication::sendEvent(q, &e);

}

void QGraphicsWidgetPrivate::resolveLayoutDirection()

{

    Q_Q(QGraphicsWidget);

    if (q->testAttribute(Qt::WA_SetLayoutDirection)) {

        return;

    }

    if (QGraphicsWidget *parentWidget = q->parentWidget()) {

        setLayoutDirection_helper(parentWidget->layoutDirection());

    } else if (scene) {

        // ### shouldn't the scene have a layoutdirection really? how does

        // ### QGraphicsWidget get changes from QApplication::layoutDirection?

        setLayoutDirection_helper(QApplication::layoutDirection());

    } else {

        setLayoutDirection_helper(QApplication::layoutDirection());

    }

}

QPalette QGraphicsWidgetPrivate::naturalWidgetPalette() const

{

    Q_Q(const QGraphicsWidget);

    QPalette palette;

    if (QGraphicsWidget *parent = q->parentWidget()) {

        palette = parent->palette();

    } else if (scene) {

        palette = scene->palette();

    }

    palette.resolve(0);

    return palette;

}

void QGraphicsWidgetPrivate::setFont_helper(const QFont &font)

{

    if (this->font == font && this->font.resolve() == font.resolve())

        return;

    updateFont(font);

}

void QGraphicsWidgetPrivate::resolveFont(uint inheritedMask)

{

    inheritedFontResolveMask = inheritedMask;

    QFont naturalFont = naturalWidgetFont();

    QFont resolvedFont = font.resolve(naturalFont);

    updateFont(resolvedFont);

}

void QGraphicsWidgetPrivate::updateFont(const QFont &font)

{

    Q_Q(QGraphicsWidget);

    // Update the local font setting.

    this->font = font;

    // Calculate new mask.

    if (q->isWindow() && !q->testAttribute(Qt::WA_WindowPropagation))

        inheritedFontResolveMask = 0;

    int mask = font.resolve() | inheritedFontResolveMask;

    // Propagate to children.

    for (int i = 0; i < children.size(); ++i) {

        QGraphicsItem *item = children.at(i);

        if (item->isWidget()) {

            QGraphicsWidget *w = static_cast<QGraphicsWidget *>(item);

            if (!w->isWindow() || w->testAttribute(Qt::WA_WindowPropagation))

                w->d_func()->resolveFont(mask);

        } else {

            item->d_ptr->resolveFont(mask);

        }

    }

    if (!polished)

        return;

    // Notify change.

    QEvent event(QEvent::FontChange);

    QApplication::sendEvent(q, &event);

}

QFont QGraphicsWidgetPrivate::naturalWidgetFont() const

{

    Q_Q(const QGraphicsWidget);

    QFont naturalFont; // ### no application font support

    if (QGraphicsWidget *parent = q->parentWidget()) {

        naturalFont = parent->font();

    } else if (scene) {

        naturalFont = scene->font();

    }

    naturalFont.resolve(0);

    return naturalFont;

}

void QGraphicsWidgetPrivate::initStyleOptionTitleBar(QStyleOptionTitleBar *option)

{

    Q_Q(QGraphicsWidget);

    ensureWindowData();

    q->initStyleOption(option);

    option->rect.setHeight(titleBarHeight(*option));

    option->titleBarFlags = windowFlags;

    option->subControls = QStyle::SC_TitleBarCloseButton | QStyle::SC_TitleBarLabel | QStyle::SC_TitleBarSysMenu;

    option->activeSubControls = windowData->hoveredSubControl;

    bool isActive = q->isActiveWindow();

    if (isActive) {

        option->state |= QStyle::State_Active;

        option->titleBarState = Qt::WindowActive;

        option->titleBarState |= QStyle::State_Active;

    } else {

        option->state &= ~QStyle::State_Active;

        option->titleBarState = Qt::WindowNoState;

    }

    QFont windowTitleFont = QApplication::font("QWorkspaceTitleBar");

    QRect textRect = q->style()->subControlRect(QStyle::CC_TitleBar, option, QStyle::SC_TitleBarLabel, 0);

    option->text = QFontMetrics(windowTitleFont).elidedText(

        windowData->windowTitle, Qt::ElideRight, textRect.width());

}

void QGraphicsWidgetPrivate::adjustWindowFlags(Qt::WindowFlags *flags)

{

    bool customize =  (*flags & (Qt::CustomizeWindowHint

            | Qt::FramelessWindowHint

            | Qt::WindowTitleHint

            | Qt::WindowSystemMenuHint

            | Qt::WindowMinimizeButtonHint

            | Qt::WindowMaximizeButtonHint

            | Qt::WindowContextHelpButtonHint));

    uint type = (*flags & Qt::WindowType_Mask);

    if (customize)

        ;

    else if (type == Qt::Dialog || type == Qt::Sheet)

        *flags |= Qt::WindowTitleHint | Qt::WindowSystemMenuHint | Qt::WindowContextHelpButtonHint;

    else if (type == Qt::Tool)

        *flags |= Qt::WindowTitleHint | Qt::WindowSystemMenuHint;

    else if (type == Qt::Window || type == Qt::SubWindow)

        *flags |= Qt::WindowTitleHint | Qt::WindowSystemMenuHint

                  | Qt::WindowMinimizeButtonHint | Qt::WindowMaximizeButtonHint;

}

void QGraphicsWidgetPrivate::windowFrameMouseReleaseEvent(QGraphicsSceneMouseEvent *event)

{

    Q_Q(QGraphicsWidget);

    ensureWindowData();

    if (windowData->grabbedSection != Qt::NoSection) {

        if (windowData->grabbedSection == Qt::TitleBarArea) {

            windowData->buttonSunken = false;

            QStyleOptionTitleBar bar;

            initStyleOptionTitleBar(&bar);

            // make sure that the coordinates (rect and pos) we send to the style are positive.

            bar.rect = q->windowFrameRect().toRect();

            bar.rect.moveTo(0,0);

            bar.rect.setHeight(q->style()->pixelMetric(QStyle::PM_TitleBarHeight, &bar));

            QPointF pos = event->pos();

            if (windowFrameMargins) {

                pos.rx() += windowFrameMargins[Left];

                pos.ry() += windowFrameMargins[Top];

            }

            bar.subControls = QStyle::SC_TitleBarCloseButton;

            if (q->style()->subControlRect(QStyle::CC_TitleBar, &bar,

                                           QStyle::SC_TitleBarCloseButton,

                                           event->widget()).contains(pos.toPoint())) {

                q->close();

            }

        }

        if (!(static_cast<QGraphicsSceneMouseEvent *>(event)->buttons()))

            windowData->grabbedSection = Qt::NoSection;

        event->accept();

    }

}

void QGraphicsWidgetPrivate::windowFrameMousePressEvent(QGraphicsSceneMouseEvent *event)

{

    Q_Q(QGraphicsWidget);

    if (event->button() != Qt::LeftButton)

        return;

    ensureWindowData();

    windowData->startGeometry = q->geometry();

    windowData->grabbedSection = q->windowFrameSectionAt(event->pos());

    ensureWindowData();

    if (windowData->grabbedSection == Qt::TitleBarArea

        && windowData->hoveredSubControl == QStyle::SC_TitleBarCloseButton) {

        windowData->buttonSunken = true;

        q->update();

    }

    event->setAccepted(windowData->grabbedSection != Qt::NoSection);

}

/*!

  Used to calculate the

  Precondition:

  \a widget should support either hfw or wfh

  If \a heightForWidth is set to false, this function will query the width for height

  instead. \a width will then be interpreted as height, \a minh and \a maxh will be interpreted

  as minimum width and maximum width.

 */

static qreal minimumHeightForWidth(qreal width, qreal minh, qreal maxh,

                                   const QGraphicsWidget *widget,

                                   bool heightForWidth = true)

{

    qreal minimumHeightForWidth = -1;

    const QSizePolicy sp = widget->layout() ? widget->layout()->sizePolicy() : widget->sizePolicy();

    const bool hasHFW = sp.hasHeightForWidth();

    if (hasHFW == heightForWidth) {

        minimumHeightForWidth = hasHFW

                                ? widget->effectiveSizeHint(Qt::MinimumSize, QSizeF(width, -1)).height()

                                : widget->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, width)).width();    //"width" is here height!

    } else {

        // widthForHeight

        const qreal constraint = width;

        while (maxh - minh > 0.1) {

            qreal middle = minh + (maxh - minh)/2;

            // ### really bad, if we are a widget with a layout it will call

            // layout->effectiveSizeHint(Qt::MiniumumSize), which again will call

            // sizeHint three times because of how the cache works

            qreal hfw = hasHFW

                        ? widget->effectiveSizeHint(Qt::MinimumSize, QSizeF(middle, -1)).height()

                        : widget->effectiveSizeHint(Qt::MinimumSize, QSizeF(-1, middle)).width();

            if (hfw > constraint) {

                minh = middle;

            } else if (hfw <= constraint) {

                maxh = middle;

            }

        }

        minimumHeightForWidth = maxh;

    }

    return minimumHeightForWidth;

}

static qreal minimumWidthForHeight(qreal height, qreal minw, qreal maxw,

                                   const QGraphicsWidget *widget)

{

    return minimumHeightForWidth(height, minw, maxw, widget, false);

}

static QSizeF closestAcceptableSize(const QSizeF &proposed,

                                    const QGraphicsWidget *widget)

{

    const QSizeF current = widget->size();

    qreal minw = proposed.width();

    qreal maxw = current.width();

    qreal minh = proposed.height();

    qreal maxh = current.height();

    qreal middlew = maxw;

    qreal middleh = maxh;

    qreal min_hfw;

    min_hfw = minimumHeightForWidth(maxw, minh, maxh, widget);

    do {

        if (maxw - minw < 0.1) {

            // we still havent found anything, cut off binary search

            minw = maxw;

            minh = maxh;

        }

        middlew = minw + (maxw - minw)/2.0;

        middleh = minh + (maxh - minh)/2.0;

        min_hfw = minimumHeightForWidth(middlew, minh, maxh, widget);

        if (min_hfw > middleh) {

            minw = middlew;

            minh = middleh;

        } else if (min_hfw <= middleh) {

            maxw = middlew;

            maxh = middleh;

        }

    } while (maxw != minw);

    min_hfw = minimumHeightForWidth(middlew, minh, maxh, widget);

    QSizeF result;

    if (min_hfw < maxh) {

        result = QSizeF(middlew, min_hfw);

    } else {

        // Needed because of the cut-off we do above.

        result = QSizeF(minimumWidthForHeight(maxh, proposed.width(), current.width(), widget), maxh);

    }

    return result;

}

static void _q_boundGeometryToSizeConstraints(const QRectF &startGeometry,

                                              QRectF *rect, Qt::WindowFrameSection section,

                                              const QSizeF &min, const QSizeF &max,

                                              const QGraphicsWidget *widget)

{

    const QRectF proposedRect = *rect;

    qreal width = qBound(min.width(), proposedRect.width(), max.width());

    qreal height = qBound(min.height(), proposedRect.height(), max.height());

    QSizePolicy sp = widget->sizePolicy();

    if (const QGraphicsLayout *l = widget->layout()) {

        sp = l->sizePolicy();

    }

    const bool hasHFW = sp.hasHeightForWidth(); // || sp.hasWidthForHeight();

    const bool widthChanged = proposedRect.width() < widget->size().width();

    const bool heightChanged = proposedRect.height() < widget->size().height();

    if (hasHFW) {

        if (widthChanged || heightChanged) {

            const qreal minh = min.height();

            const qreal maxh = max.height();

            const qreal proposedHFW = minimumHeightForWidth(width, minh, maxh, widget);

            if (proposedHFW > proposedRect.height()) {

                QSizeF effectiveSize = closestAcceptableSize(QSizeF(width, height), widget);

                width = effectiveSize.width();

                height = effectiveSize.height();

            }

        }

    }

    switch (section) {

    case Qt::LeftSection:

        rect->setRect(startGeometry.right() - qRound(width), startGeometry.top(),

                      qRound(width), startGeometry.height());

        break;

    case Qt::TopLeftSection: