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

**

** Copyright (C) 2009 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 "qtoolbar.h"

#ifndef QT_NO_TOOLBAR

#include <qapplication.h>

#include <qcombobox.h>

#include <qevent.h>

#include <qlayout.h>

#include <qmainwindow.h>

#include <qmenu.h>

#include <qmenubar.h>

#include <qrubberband.h>

#include <qsignalmapper.h>

#include <qstylepainter.h>

#include <qtoolbutton.h>

#include <qwidgetaction.h>

#include <qtimer.h>

#include <private/qwidgetaction_p.h>

#ifdef Q_WS_MAC

#include <private/qt_mac_p.h>

#include <private/qt_cocoa_helpers_mac_p.h>

#endif

#include <private/qmainwindowlayout_p.h>

#include "qtoolbar_p.h"

#include "qtoolbarseparator_p.h"

#include "qtoolbarlayout_p.h"

#include  "qdebug.h"

#define POPUP_TIMER_INTERVAL 500

QT_BEGIN_NAMESPACE

#ifdef Q_WS_MAC

static void qt_mac_updateToolBarButtonHint(QWidget *parentWidget)

{

    if (!(parentWidget->windowFlags() & Qt::CustomizeWindowHint))

        parentWidget->setWindowFlags(parentWidget->windowFlags() | Qt::MacWindowToolBarButtonHint);

}

#endif

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

** QToolBarPrivate

*/

void QToolBarPrivate::init()

{

    Q_Q(QToolBar);

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

    q->setBackgroundRole(QPalette::Button);

    q->setAttribute(Qt::WA_Hover);

    q->setAttribute(Qt::WA_X11NetWmWindowTypeToolBar);

    QStyle *style = q->style();

    int e = style->pixelMetric(QStyle::PM_ToolBarIconSize, 0, q);

    iconSize = QSize(e, e);

    layout = new QToolBarLayout(q);

    layout->updateMarginAndSpacing();

#ifdef Q_WS_MAC

    if (q->parentWidget() && q->parentWidget()->isWindow()) {

        // Make sure that the window has the "toolbar" button.

        QWidget *parentWidget = q->parentWidget();

        qt_mac_updateToolBarButtonHint(parentWidget);

        reinterpret_cast<QToolBar *>(parentWidget)->d_func()->createWinId(); // Please let me create your winId...

        extern OSWindowRef qt_mac_window_for(const QWidget *); // qwidget_mac.cpp

        macWindowToolbarShow(q->parentWidget(), true);

    }

#endif

    toggleViewAction = new QAction(q);

    toggleViewAction->setCheckable(true);

    q->setMovable(q->style()->styleHint(QStyle::SH_ToolBar_Movable, 0, q ));

    QObject::connect(toggleViewAction, SIGNAL(triggered(bool)), q, SLOT(_q_toggleView(bool)));

}

void QToolBarPrivate::_q_toggleView(bool b)

{

    Q_Q(QToolBar);

    if (b == q->isHidden()) {

        if (b)

            q->show();

        else

            q->close();

    }

}

void QToolBarPrivate::_q_updateIconSize(const QSize &sz)

{

    Q_Q(QToolBar);

    if (!explicitIconSize) {

        // iconSize not explicitly set

        q->setIconSize(sz);

        explicitIconSize = false;

    }

}

void QToolBarPrivate::_q_updateToolButtonStyle(Qt::ToolButtonStyle style)

{

    Q_Q(QToolBar);

    if (!explicitToolButtonStyle) {

        q->setToolButtonStyle(style);

        explicitToolButtonStyle = false;

    }

}

void QToolBarPrivate::updateWindowFlags(bool floating, bool unplug)

{

    Q_Q(QToolBar);

    Qt::WindowFlags flags = floating ? Qt::Tool : Qt::Widget;

    flags |= Qt::FramelessWindowHint;

    if (unplug) {

        flags |= Qt::X11BypassWindowManagerHint;

#ifdef Q_WS_MAC

        flags |= Qt::WindowStaysOnTopHint;

#endif

    }

    q->setWindowFlags(flags);

}

void QToolBarPrivate::setWindowState(bool floating, bool unplug, const QRect &rect)

{

    Q_Q(QToolBar);

    bool visible = !q->isHidden();

    bool wasFloating = q->isFloating(); // ...is also currently using popup menus

    q->hide();

    updateWindowFlags(floating, unplug);

    if (floating != wasFloating)

        layout->checkUsePopupMenu();

    if (!rect.isNull())

        q->setGeometry(rect);

    if (visible)

        q->show();

}

void QToolBarPrivate::initDrag(const QPoint &pos)

{

    Q_Q(QToolBar);

    if (state != 0)

        return;

    QMainWindow *win = qobject_cast<QMainWindow*>(parent);

    Q_ASSERT(win != 0);

    QMainWindowLayout *layout = qobject_cast<QMainWindowLayout*>(win->layout());

    Q_ASSERT(layout != 0);

    if (layout->pluggingWidget != 0) // the main window is animating a docking operation

        return;

    state = new DragState;

    state->pressPos = pos;

    state->dragging = false;

    state->moving = false;

    state->widgetItem = 0;

    if (q->isRightToLeft())

        state->pressPos = QPoint(q->width() - state->pressPos.x(), state->pressPos.y());

}

void QToolBarPrivate::startDrag(bool moving)

{

    Q_Q(QToolBar);

    Q_ASSERT(state != 0);

    if ((moving && state->moving) || state->dragging)

        return;

    QMainWindow *win = qobject_cast<QMainWindow*>(parent);

    Q_ASSERT(win != 0);

    QMainWindowLayout *layout = qobject_cast<QMainWindowLayout*>(win->layout());

    Q_ASSERT(layout != 0);

    if (!moving) {

        state->widgetItem = layout->unplug(q);

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

        if (q->isWindow()) {

           setWindowState(true, true); //set it to floating

        }

#endif

        Q_ASSERT(state->widgetItem != 0);

    }

    state->dragging = !moving;

    state->moving = moving;

}

void QToolBarPrivate::endDrag()

{

    Q_Q(QToolBar);

    Q_ASSERT(state != 0);

    q->releaseMouse();

    if (state->dragging) {

        QMainWindowLayout *layout =

            qobject_cast<QMainWindowLayout *>(q->parentWidget()->layout());

        Q_ASSERT(layout != 0);

        if (!layout->plug(state->widgetItem)) {

            if (q->isFloatable()) {

                layout->restore();

#if defined(Q_WS_X11) || defined(Q_WS_MAC)

                setWindowState(true); // gets rid of the X11BypassWindowManager window flag

                                      // and activates the resizer

#endif

                q->activateWindow();

            } else {

                layout->revert(state->widgetItem);

            }

        }

    }

    delete state;

    state = 0;

}

bool QToolBarPrivate::mousePressEvent(QMouseEvent *event)

{

    Q_Q(QToolBar);

    QStyleOptionToolBar opt;

    q->initStyleOption(&opt);

    if (q->style()->subElementRect(QStyle::SE_ToolBarHandle, &opt, q).contains(event->pos()) == false) {

#ifdef Q_WS_MAC

        // When using the unified toolbar on Mac OS X the user can can click and

        // drag between toolbar contents to move the window. Make this work by

        // implementing the standard mouse-dragging code and then call

        // window->move() in mouseMoveEvent below.

        if (QMainWindow *mainWindow = qobject_cast<QMainWindow *>(parent)) {

            if (mainWindow->toolBarArea(q) == Qt::TopToolBarArea

                    && mainWindow->unifiedTitleAndToolBarOnMac()

                    && q->childAt(event->pos()) == 0) {

                macWindowDragging = true;

                macWindowDragPressPosition = event->pos();

                return true;

            }

        }

#endif

        return false;

    }

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

        return true;

    if (!layout->movable())

        return true;

    initDrag(event->pos());

    return true;

}

bool QToolBarPrivate::mouseReleaseEvent(QMouseEvent*)

{

    if (state != 0) {

        endDrag();

        return true;

    } else {

#ifdef Q_WS_MAC

        if (!macWindowDragging)

            return false;

        macWindowDragging = false;

        macWindowDragPressPosition = QPoint();

        return true;

#endif

        return false;

    }

}

bool QToolBarPrivate::mouseMoveEvent(QMouseEvent *event)

{

    Q_Q(QToolBar);

    if (!state) {

#ifdef Q_WS_MAC

        if (!macWindowDragging)

            return false;

        QWidget *w = q->window();

        const QPoint delta = event->pos() - macWindowDragPressPosition;

        w->move(w->pos() + delta);

        return true;

#endif

        return false;

    }

    QMainWindow *win = qobject_cast<QMainWindow*>(parent);

    if (win == 0)

        return true;

    QMainWindowLayout *layout = qobject_cast<QMainWindowLayout*>(win->layout());

    Q_ASSERT(layout != 0);

    if (layout->pluggingWidget == 0

        && (event->pos() - state->pressPos).manhattanLength() > QApplication::startDragDistance()) {

            const bool wasDragging = state->dragging;

            const bool moving = !q->isWindow() && (orientation == Qt::Vertical ?

                event->x() >= 0 && event->x() < q->width() :

                event->y() >= 0 && event->y() < q->height());

            startDrag(moving);

            if (!moving && !wasDragging) {

#ifdef Q_OS_WIN

                grabMouseWhileInWindow();

#else

                q->grabMouse();

#endif

            }

    }

    if (state->dragging) {

        QPoint pos = event->globalPos();

        // if we are right-to-left, we move so as to keep the right edge the same distance

        // from the mouse

        if (q->isLeftToRight())

            pos -= state->pressPos;

        else

            pos += QPoint(state->pressPos.x() - q->width(), -state->pressPos.y());

        q->move(pos);

        layout->hover(state->widgetItem, event->globalPos());

    } else if (state->moving) {

        const QPoint rtl(q->width() - state->pressPos.x(), state->pressPos.y()); //for RTL

        const QPoint globalPressPos = q->mapToGlobal(q->isRightToLeft() ? rtl : state->pressPos);

        int pos = 0;

        QPoint delta = event->globalPos() - globalPressPos;

        if (orientation == Qt::Vertical) {

            pos = q->y() + delta.y();

        } else {

            if (q->isRightToLeft()) {

                pos = win->width() - q->width() - q->x()  - delta.x();

            } else {

                pos = q->x() + delta.x();

            }

        }

        layout->moveToolBar(q, pos);

    }

    return true;

}

void QToolBarPrivate::unplug(const QRect &_r)

{

    Q_Q(QToolBar);

    layout->setExpanded(false, false);

    QRect r = _r;

    r.moveTopLeft(q->mapToGlobal(QPoint(0, 0)));

    setWindowState(true, true, r);

}

void QToolBarPrivate::plug(const QRect &r)

{

    setWindowState(false, false, r);

}

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

** QToolBar

*/

/*!

    \class QToolBar

    \brief The QToolBar class provides a movable panel that contains a

    set of controls.

    \ingroup mainwindow-classes

    Toolbar buttons are added by adding \e actions, using addAction()

    or insertAction(). Groups of buttons can be separated using

    addSeparator() or insertSeparator(). If a toolbar button is not

    appropriate, a widget can be inserted instead using addWidget() or

    insertWidget(); examples of suitable widgets are QSpinBox,

    QDoubleSpinBox, and QComboBox. When a toolbar button is pressed it

    emits the actionTriggered() signal.

    A toolbar can be fixed in place in a particular area (e.g. at the

    top of the window), or it can be movable (isMovable()) between

    toolbar areas; see allowedAreas() and isAreaAllowed().

    When a toolbar is resized in such a way that it is too small to

    show all the items it contains, an extension button will appear as

    the last item in the toolbar. Pressing the extension button will

    pop up a menu containing the items that does not currently fit in

    the toolbar.

    When a QToolBar is not a child of a QMainWindow, it looses the ability

    to populate the extension pop up with widgets added to the toolbar using

    addWidget(). Please use widget actions created by inheriting QWidgetAction

    and implementing QWidgetAction::createWidget() instead. This is a known

    issue which will be fixed in a future release.

    \sa QToolButton, QMenu, QAction, {Application Example}

*/

/*!

    \fn bool QToolBar::isAreaAllowed(Qt::ToolBarArea area) const

    Returns true if this toolbar is dockable in the given \a area;

    otherwise returns false.

*/

/*!

    \fn void QToolBar::addAction(QAction *action)

    \overload

    Appends the action \a action to the toolbar's list of actions.

    \sa QMenu::addAction(), QWidget::addAction()

*/

/*!

    \fn void QToolBar::actionTriggered(QAction *action)

    This signal is emitted when an action in this toolbar is triggered.

    This happens when the action's tool button is pressed, or when the

    action is triggered in some other way outside the tool bar. The parameter

    holds the triggered \a action.

*/

/*!

    \fn void QToolBar::allowedAreasChanged(Qt::ToolBarAreas allowedAreas)

    This signal is emitted when the collection of allowed areas for the

    toolbar is changed. The new areas in which the toolbar can be positioned

    are specified by \a allowedAreas.

    \sa allowedAreas

*/

/*!

    \fn void QToolBar::iconSizeChanged(const QSize &iconSize)

    This signal is emitted when the icon size is changed.  The \a

    iconSize parameter holds the toolbar's new icon size.

    \sa iconSize QMainWindow::iconSize

*/

/*!

    \fn void QToolBar::movableChanged(bool movable)

    This signal is emitted when the toolbar becomes movable or fixed.

    If the toolbar can be moved, \a movable is true; otherwise it is

    false.

    \sa movable

*/

/*!

    \fn void QToolBar::orientationChanged(Qt::Orientation orientation)

    This signal is emitted when the orientation of the toolbar changes.

    The new orientation is specified by the \a orientation given.

    \sa orientation

*/

/*!

    \fn void QToolBar::toolButtonStyleChanged(Qt::ToolButtonStyle toolButtonStyle)

    This signal is emitted when the tool button style is changed. The

    \a toolButtonStyle parameter holds the toolbar's new tool button

    style.

    \sa toolButtonStyle QMainWindow::toolButtonStyle

*/

/*!

    Constructs a QToolBar with the given \a parent.

*/

QToolBar::QToolBar(QWidget *parent)

    : QWidget(*new QToolBarPrivate, parent, 0)

{

    Q_D(QToolBar);

    d->init();

}