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

**

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

#ifndef QT_NO_MAINWINDOW

#include "qapplication.h"

#include "qbitmap.h"

#include "qcursor.h"

#include "qdatetime.h"

#include "q3dockarea.h"

#include "qevent.h"

#include "qlayout.h"

#include "qmap.h"

#include "qmenubar.h"

#include "qpainter.h"

#include "q3popupmenu.h"

#include "q3scrollview.h"

#include "qstatusbar.h"

#include "qstringlist.h"

#include "qstyle.h"

#include "qstyleoption.h"

#include "qtimer.h"

#include "q3toolbar.h"

#include "qtooltip.h"

#include "qwhatsthis.h"

#ifdef Q_WS_MAC

#  include <private/qt_mac_p.h>

#endif

#include <private/q3mainwindow_p.h>

QT_BEGIN_NAMESPACE

class QHideDock;

/* Q3MainWindowLayout, respects widthForHeight layouts (like the left

  and right docks are)

*/

class Q3MainWindowLayout : public QLayout

{

    Q_OBJECT

public:

    Q3MainWindowLayout(Q3MainWindow *mw);

    ~Q3MainWindowLayout() {}

    void addItem(QLayoutItem *);

    void setLeftDock(Q3DockArea *l);

    void setRightDock(Q3DockArea *r);

    void setCentralWidget(QWidget *w);

    bool hasHeightForWidth() const { return false; }

    QSize sizeHint() const;

    QSize minimumSize() const;

    QLayoutItem *itemAt(int) const { return 0; } //###

    QLayoutItem *takeAt(int) { return 0; } //###

    int count() const { return 0; } //###

protected:

    void setGeometry(const QRect &r) {

        QLayout::setGeometry(r);

        layoutItems(r);

    }

private:

    int layoutItems(const QRect&, bool testonly = false);

    int extraPixels() const;

    Q3DockArea *left, *right;

    QWidget *central;

    Q3MainWindow *mainWindow;

};

QSize Q3MainWindowLayout::sizeHint() const

{

    int w = 0;

    int h = 0;

    if (left) {

        w += left->sizeHint().width();

        h = qMax(h, left->sizeHint().height());

    }

    if (right) {

        w += right->sizeHint().width();

        h = qMax(h, right->sizeHint().height());

    }

    if (central) {

        w += central->sizeHint().width();

        int diff = extraPixels();

        h = qMax(h, central->sizeHint().height() + diff);

    }

    return QSize(w, h);

}

QSize Q3MainWindowLayout::minimumSize() const

{

    int w = 0;

    int h = 0;

    if (left) {

        QSize ms = left->minimumSizeHint().expandedTo(left->minimumSize());

        w += ms.width();

        h = qMax(h, ms.height());

    }

    if (right) {

        QSize ms = right->minimumSizeHint().expandedTo(right->minimumSize());

        w += ms.width();

        h = qMax(h, ms.height());

    }

    if (central) {

        QSize min = central->minimumSize().isNull() ?

                    central->minimumSizeHint() : central->minimumSize();

        w += min.width();

        int diff = extraPixels();

        h = qMax(h, min.height() + diff);

    }

    return QSize(w, h);

}

Q3MainWindowLayout::Q3MainWindowLayout(Q3MainWindow *mw)

    : left(0), right(0), central(0)

{

    mainWindow = mw;

}

void Q3MainWindowLayout::setLeftDock(Q3DockArea *l)

{

    left = l;

}

void Q3MainWindowLayout::setRightDock(Q3DockArea *r)

{

    right = r;

}

void Q3MainWindowLayout::setCentralWidget(QWidget *w)

{

    central = w;

}

int Q3MainWindowLayout::layoutItems(const QRect &r, bool testonly)

{

    if (!left && !central && !right)

        return 0;

    int wl = 0, wr = 0;

    if (left)

        wl = ((Q3DockAreaLayout*)left->QWidget::layout())->widthForHeight(r.height());

    if (right)

        wr = ((Q3DockAreaLayout*)right->QWidget::layout())->widthForHeight(r.height());

    int w = r.width() - wr - wl;

    if (w < 0)

        w = 0;

    int diff = extraPixels();

    if (!testonly) {

        QRect g(geometry());

        if (left)

            left->setGeometry(QRect(g.x(), g.y() + diff, wl, r.height() - diff));

        if (right)

            right->setGeometry(QRect(g.x() + g.width() - wr, g.y() + diff, wr, r.height() - diff));

        if (central)

            central->setGeometry(g.x() + wl, g.y() + diff, w, r.height() - diff);

    }

    w = wl + wr;

    if (central)

        w += central->minimumSize().width();

    return w;

}

int Q3MainWindowLayout::extraPixels() const

{

    if (mainWindow->d_func()->topDock->isEmpty() &&

         !(mainWindow->d_func()->leftDock->isEmpty() &&

           mainWindow->d_func()->rightDock->isEmpty())) {

        return 2;

    } else {

        return 0;

    }

}

void Q3MainWindowLayout::addItem(QLayoutItem * /* item */)

{

}

/*

  QHideToolTip and QHideDock - minimized dock

*/

#if 0

class QHideToolTip : public QToolTip

{

public:

    QHideToolTip(QWidget *parent) : QToolTip(parent) {}

    void maybeTip(const QPoint &pos);

};

#endif

class QHideDock : public QWidget

{

    Q_OBJECT

public:

    QHideDock(Q3MainWindow *parent) : QWidget(parent, "qt_hide_dock") {

        hide();

        setFixedHeight(style()->pixelMetric(QStyle::PM_DockWidgetHandleExtent, 0, this) + 3);

        pressedHandle = -1;

        pressed = false;

        setMouseTracking(true);

        win = parent;

#if 0

        tip = new QHideToolTip(this);

#endif

    }

    ~QHideDock()

    {

#if 0

        delete tip;

#endif

    }

protected:

    void paintEvent(QPaintEvent *e) {

        QObjectList childList = children();

        if (childList.isEmpty())

            return;

        QPainter p(this);

        p.setClipRegion(e->rect());

        p.fillRect(e->rect(), palette().brush(QPalette::Window));

        int x = 0;

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

            QObject *o = childList.at(i);

            Q3DockWindow *dw = qobject_cast<Q3DockWindow*>(o);

            if (!dw || !dw->isVisible())

                continue;

            QStyleOptionQ3DockWindow opt;

            opt.rect.setRect(x, 0, 30, 10);

            opt.palette = palette();

            opt.docked = dw->area();

            opt.closeEnabled = dw->isCloseEnabled();

            opt.state = QStyle::State_None;

            if (i == pressedHandle)

                opt.state |= QStyle::State_On;

            style()->drawPrimitive(QStyle::PE_IndicatorToolBarHandle, &opt, &p, this);

            x += 30;

        }

    }

    void mousePressEvent(QMouseEvent *e) {

        pressed = true;

        QObjectList childList = children();

        if (childList.isEmpty())

            return;

        mouseMoveEvent(e);

        pressedHandle = -1;

        if (e->button() == Qt::RightButton && win->isDockMenuEnabled()) {

            // ### TODO: HideDock menu

        } else {

            mouseMoveEvent(e);

        }

    }

    void mouseMoveEvent(QMouseEvent *e) {

        QObjectList childList = children();

        if (childList.isEmpty())

            return;

        if (!pressed)

            return;

        int x = 0;

        if (e->y() >= 0 && e->y() <= height()) {

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

                QObject *o = childList.at(i);

                Q3DockWindow *dw = qobject_cast<Q3DockWindow*>(o);

                if (!dw || !dw->isVisible())

                    continue;

                if (e->x() >= x && e->x() <= x + 30) {

                    int old = pressedHandle;

                    pressedHandle = i;

                    if (pressedHandle != old)

                        repaint();

                    return;

                }

                x += 30;

            }

        }

        int old = pressedHandle;

        pressedHandle = -1;

        if (old != -1)

            repaint();

    }

    void mouseReleaseEvent(QMouseEvent *e) {

        pressed = false;

        if (pressedHandle == -1)

            return;

        QObjectList childList = children();

        if (childList.isEmpty())

            return;

        if (e->button() == Qt::LeftButton) {

            if (e->y() >= 0 && e->y() <= height()) {

                QObject *o = childList.at(pressedHandle);

                Q3DockWindow *dw = qobject_cast<Q3DockWindow*>(o);

                if (dw) {

                    dw->show();

                    dw->dock();

                }

            }

        }

        pressedHandle = -1;

        repaint();

    }

    bool eventFilter(QObject *o, QEvent *e) {

        if (o == this || !o->isWidgetType())

            return QWidget::eventFilter(o, e);

        if (e->type() == QEvent::HideToParent ||

             e->type() == QEvent::ShowToParent)

            updateState();

        return QWidget::eventFilter(o, e);

    }

    void updateState() {

        bool visible = true;

        QObjectList childList = children();

        if (childList.isEmpty())

            return;

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

            QObject *o = childList.at(i);

            Q3DockWindow *dw = qobject_cast<Q3DockWindow*>(o);

            if (!dw)

                continue;

            if (dw->isHidden()) {

                visible = false;

                continue;

            }

            if (!dw->isVisible())

                continue;

            visible = true;

            break;

        }

        if (visible)

            show();

        else

            hide();

        win->triggerLayout(false);

        update();

    }

    void childEvent(QChildEvent *e) {

        QWidget::childEvent(e);

        if (e->type() == QEvent::ChildInserted)

            e->child()->installEventFilter(this);

        else

            e->child()->removeEventFilter(this);

        updateState();

    }

private:

    Q3MainWindow *win;

    int pressedHandle;

    bool pressed;

#if 0

    QHideToolTip *tip;

    friend class QHideToolTip;

#endif

};

#if 0

void QHideToolTip::maybeTip(const QPoint &pos)

{

    if (!parentWidget())

        return;

    QHideDock *dock = (QHideDock*)parentWidget();

    QObjectList dchilds = dock->children();

    if (dchilds.isEmpty())

        return;

    int x = 0;

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

        QObject *o = dchilds.at(i);

        Q3DockWindow *dw = qobject_cast<Q3DockWindow*>(o);

        if (!dw || !dw->isVisible())

            continue;

        if (pos.x() >= x && pos.x() <= x + 30) {

            Q3DockWindow *dw = (Q3DockWindow*)o;

            if (!dw->windowTitle().isEmpty())

                tip(QRect(x, 0, 30, dock->height()), dw->windowTitle());

            return;

        }

        x += 30;

    }

}

#endif

/*!

    \class Q3MainWindow

    \brief The Q3MainWindow class provides a main application window,

    with a menu bar, dock windows (e.g. for toolbars), and a status

    bar.

    \compat

    Main windows are most often used to provide menus, toolbars and a

    status bar around a large central widget, such as a text edit,

    drawing canvas or QWorkspace (for MDI applications). Q3MainWindow

    is usually subclassed since this makes it easier to encapsulate

    the central widget, menus and toolbars as well as the window's

    state. Subclassing makes it possible to create the slots that are

    called when the user clicks menu items or toolbar buttons.

    We'll briefly review adding menu items and

    toolbar buttons then describe the facilities of Q3MainWindow

    itself.

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

    Q3MainWindows may be created in their own right as shown above.

    The central widget is set with setCentralWidget(). Popup menus can

    be added to the default menu bar, widgets can be added to the

    status bar, toolbars and dock windows can be added to any of the

    dock areas.

    The main window will take care of the dock areas, and the geometry

    of the central widget, but all other aspects of the central widget

    are left to you. Q3MainWindow automatically detects the creation of

    a menu bar or status bar if you specify the Q3MainWindow as parent,

    or you can use the provided menuBar() and statusBar() functions.

    The functions menuBar() and statusBar() create a suitable widget

    if one doesn't exist, and update the window's layout to make

    space.

    New dock windows and toolbars can be added to a Q3MainWindow using

    addDockWindow(). Qt::Dock windows can be moved using moveDockWindow()

    and removed with removeDockWindow(). Q3MainWindow allows default

    dock window (toolbar) docking in all its dock areas (\c Top, \c

    Left, \c Right, \c Bottom). You can use setDockEnabled() to

    enable and disable docking areas for dock windows. When adding or

    moving dock windows you can specify their 'edge' (dock area). The

    currently available edges are: \c Top, \c Left, \c Right, \c

    Bottom, \c Minimized (effectively a 'hidden' dock area) and \c

    TornOff (floating). See \l Qt::Dock for an explanation of these

    areas. Note that the *ToolBar functions are included for backward

    compatibility; all new code should use the *DockWindow functions.

    QToolbar is a subclass of Q3DockWindow so all functions that work

    with dock windows work on toolbars in the same way.

    \target dwm

    If the user clicks the close button, then the dock window is

    hidden. A dock window can be hidden or unhidden by the user by

    right clicking a dock area and clicking the name of the relevant

    dock window on the pop up dock window menu. This menu lists the

    names of every dock window; visible dock windows have a tick

    beside their names. The dock window menu is created automatically

    as required by createDockWindowMenu(). Since it may not always be

    appropriate for a dock window to appear on this menu the

    setAppropriate() function is used to inform the main window

    whether or not the dock window menu should include a particular

    dock window. Double clicking a dock window handle (usually on the

    left-hand side of the dock window) undocks (floats) the dock

    window. Double clicking a floating dock window's title bar will

    dock the floating dock window. (See also

    \l{Q3MainWindow::DockWindows}.)

    Some functions change the appearance of a Q3MainWindow globally:

    \list

    \i Q3DockWindow::setHorizontalStretchable() and

    Q3DockWindow::setVerticalStretchable() are used to make specific dock

    windows or toolbars stretchable.

    \i setUsesBigPixmaps() is used to set whether tool buttons should

    draw small or large pixmaps (see QIcon for more information).

    \i setUsesTextLabel() is used to set whether tool buttons

    should display a textual label in addition to pixmaps

    (see QToolButton for more information).

    \endlist

    The user can drag dock windows into any enabled docking area. Qt::Dock

    windows can also be dragged \e within a docking area, for example

    to rearrange the order of some toolbars. Qt::Dock windows can also be

    dragged outside any docking area (undocked or 'floated'). Being

    able to drag dock windows can be enabled (the default) and

    disabled using setDockWindowsMovable().