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

**

** 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 <qmenubar.h>

#include <qstyle.h>

#include <qlayout.h>

#include <qapplication.h>

#include <qdesktopwidget.h>

#ifndef QT_NO_ACCESSIBILITY

# include <qaccessible.h>

#endif

#include <qpainter.h>

#include <qstylepainter.h>

#include <qevent.h>

#include <qmainwindow.h>

#include <qtoolbar.h>

#include <qtoolbutton.h>

#include <qwhatsthis.h>

#ifndef QT_NO_MENUBAR

#ifdef QT3_SUPPORT

#include <private/qaction_p.h>

#include <qmenudata.h>

#endif

#include "qmenu_p.h"

#include "qmenubar_p.h"

#include "qdebug.h"

#ifdef Q_WS_WINCE

extern bool qt_wince_is_mobile(); //defined in qguifunctions_wce.cpp

#endif

QT_BEGIN_NAMESPACE

class QMenuBarExtension : public QToolButton

{

public:

    explicit QMenuBarExtension(QWidget *parent);

    QSize sizeHint() const;

    void paintEvent(QPaintEvent *);

};

QMenuBarExtension::QMenuBarExtension(QWidget *parent)

    : QToolButton(parent)

{

    setObjectName(QLatin1String("qt_menubar_ext_button"));

    setAutoRaise(true);

#ifndef QT_NO_MENU

    setPopupMode(QToolButton::InstantPopup);

#endif

    setIcon(style()->standardIcon(QStyle::SP_ToolBarHorizontalExtensionButton, 0, parentWidget()));

}

void QMenuBarExtension::paintEvent(QPaintEvent *)

{

    QStylePainter p(this);

    QStyleOptionToolButton opt;

    initStyleOption(&opt);

    // We do not need to draw both extention arrows

    opt.features &= ~QStyleOptionToolButton::HasMenu;

    p.drawComplexControl(QStyle::CC_ToolButton, opt);

}

QSize QMenuBarExtension::sizeHint() const

{

    int ext = style()->pixelMetric(QStyle::PM_ToolBarExtensionExtent, 0, parentWidget());

    return QSize(ext, ext);

}

/*!

    \internal

*/

QAction *QMenuBarPrivate::actionAt(QPoint p) const

{

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

        if(actionRect(actions.at(i)).contains(p))

            return actions.at(i);

    }

    return 0;

}

QRect QMenuBarPrivate::menuRect(bool extVisible) const

{

    Q_Q(const QMenuBar);

    int hmargin = q->style()->pixelMetric(QStyle::PM_MenuBarPanelWidth, 0, q);

    QRect result = q->rect();

    result.adjust(hmargin, 0, -hmargin, 0);

    if (extVisible) {

        if (q->isRightToLeft())

            result.setLeft(result.left() + extension->sizeHint().width());

        else

            result.setWidth(result.width() - extension->sizeHint().width());

    }

    if (leftWidget && leftWidget->isVisible()) {

        QSize sz = leftWidget->sizeHint();

        if (q->isRightToLeft())

            result.setRight(result.right() - sz.width());

        else

            result.setLeft(result.left() + sz.width());

    }

    if (rightWidget && rightWidget->isVisible()) {

        QSize sz = rightWidget->sizeHint();

        if (q->isRightToLeft())

            result.setLeft(result.left() + sz.width());

        else

            result.setRight(result.right() - sz.width());

    }

    return result;

}

bool QMenuBarPrivate::isVisible(QAction *action)

{

    return !hiddenActions.contains(action);

}

void QMenuBarPrivate::updateGeometries()

{

    Q_Q(QMenuBar);

    if(!itemsDirty)

        return;

    int q_width = q->width()-(q->style()->pixelMetric(QStyle::PM_MenuBarPanelWidth, 0, q)*2);

    int q_start = -1;

    if(leftWidget || rightWidget) {

        int vmargin = q->style()->pixelMetric(QStyle::PM_MenuBarVMargin, 0, q)

                      + q->style()->pixelMetric(QStyle::PM_MenuBarPanelWidth, 0, q);

        int hmargin = q->style()->pixelMetric(QStyle::PM_MenuBarHMargin, 0, q)

                      + q->style()->pixelMetric(QStyle::PM_MenuBarPanelWidth, 0, q);

        if (leftWidget && leftWidget->isVisible()) {

            QSize sz = leftWidget->sizeHint();

            q_width -= sz.width();

            q_start = sz.width();

            QPoint pos(hmargin, (q->height() - leftWidget->height()) / 2);

            QRect vRect = QStyle::visualRect(q->layoutDirection(), q->rect(), QRect(pos, sz));

            leftWidget->setGeometry(vRect);

        }

        if (rightWidget && rightWidget->isVisible()) {

            QSize sz = rightWidget->sizeHint();

            q_width -= sz.width();

            QPoint pos(q->width() - sz.width() - hmargin, vmargin);

            QRect vRect = QStyle::visualRect(q->layoutDirection(), q->rect(), QRect(pos, sz));

            rightWidget->setGeometry(vRect);

        }

    }

#ifdef Q_WS_MAC

    if(q->isNativeMenuBar()) {//nothing to see here folks, move along..

        itemsDirty = false;

        return;

    }

#endif

    calcActionRects(q_width, q_start);

    currentAction = 0;

#ifndef QT_NO_SHORTCUT

    if(itemsDirty) {

        for(int j = 0; j < shortcutIndexMap.size(); ++j)

            q->releaseShortcut(shortcutIndexMap.value(j));

        shortcutIndexMap.resize(0); // faster than clear

        for(int i = 0; i < actions.count(); i++)

            shortcutIndexMap.append(q->grabShortcut(QKeySequence::mnemonic(actions.at(i)->text())));

    }

#endif

    itemsDirty = false;

    hiddenActions.clear();

    //this is the menu rectangle without any extension

    QRect menuRect = this->menuRect(false);

    //we try to see if the actions will fit there

    bool hasHiddenActions = false;

    for (int i = 0; i < actions.count(); ++i) {

        const QRect &rect = actionRects.at(i);

        if (rect.isValid() && !menuRect.contains(rect)) {

            hasHiddenActions = true;

            break;

        }

    }

    //...and if not, determine the ones that fit on the menu with the extension visible

    if (hasHiddenActions) {

        menuRect = this->menuRect(true);

        for (int i = 0; i < actions.count(); ++i) {

            const QRect &rect = actionRects.at(i);

            if (rect.isValid() && !menuRect.contains(rect)) {

                hiddenActions.append(actions.at(i));

            }

        }

    }

    if (hiddenActions.count() > 0) {

        QMenu *pop = extension->menu();

        if (!pop) {

            pop = new QMenu(q);

            extension->setMenu(pop);

        }

        pop->clear();

        pop->addActions(hiddenActions);

        int vmargin = q->style()->pixelMetric(QStyle::PM_MenuBarVMargin, 0, q);

        int x = q->isRightToLeft()

                ? menuRect.left() - extension->sizeHint().width() + 1

                : menuRect.right();

        extension->setGeometry(x, vmargin, extension->sizeHint().width(), menuRect.height() - vmargin*2);

        extension->show();

    } else {

        extension->hide();

    }

    q->updateGeometry();

#ifdef QT3_SUPPORT

    if (parent) {

        QMenubarUpdatedEvent menubarUpdated(q);

        QApplication::sendEvent(parent, &menubarUpdated);

    }

#endif

}

QRect QMenuBarPrivate::actionRect(QAction *act) const

{

    Q_Q(const QMenuBar);

    const int index = actions.indexOf(act);

    if (index == -1)

        return QRect();

    //makes sure the geometries are up-to-date

    const_cast<QMenuBarPrivate*>(this)->updateGeometries();

    if (index >= actionRects.count())

        return QRect(); // that can happen in case of native menubar

    QRect ret = actionRects.at(index);

    return QStyle::visualRect(q->layoutDirection(), q->rect(), ret);

}

void QMenuBarPrivate::focusFirstAction()

{

    if(!currentAction) {

        updateGeometries();

        int index = 0;

        while (index < actions.count() && actionRects.at(index).isNull()) ++index;

        if (index < actions.count())

            setCurrentAction(actions.at(index));

    }

}

void QMenuBarPrivate::setKeyboardMode(bool b)

{

    Q_Q(QMenuBar);

    if (b && !q->style()->styleHint(QStyle::SH_MenuBar_AltKeyNavigation, 0, q)) {

        setCurrentAction(0);

        return;

    }

    keyboardState = b;

    if(b) {

        QWidget *fw = QApplication::focusWidget();

        if (fw != q)

            keyboardFocusWidget = fw;

        focusFirstAction();

        q->setFocus(Qt::MenuBarFocusReason);

    } else {

        if(!popupState)

            setCurrentAction(0);

        if(keyboardFocusWidget) {

            if (QApplication::focusWidget() == q)

                keyboardFocusWidget->setFocus(Qt::MenuBarFocusReason);

            keyboardFocusWidget = 0;

        }

    }

    q->update();

}

void QMenuBarPrivate::popupAction(QAction *action, bool activateFirst)

{

    Q_Q(QMenuBar);

    if(!action || !action->menu() || closePopupMode)

        return;

    popupState = true;

    if (action->isEnabled() && action->menu()->isEnabled()) {

        closePopupMode = 0;

        activeMenu = action->menu();

        activeMenu->d_func()->causedPopup.widget = q;

        activeMenu->d_func()->causedPopup.action = action;

        QRect adjustedActionRect = actionRect(action);

        QPoint pos(q->mapToGlobal(QPoint(adjustedActionRect.left(), adjustedActionRect.bottom() + 1)));

        QSize popup_size = activeMenu->sizeHint();

        QRect screenRect = QApplication::desktop()->screenGeometry(pos);

        const bool fitUp = (q->mapToGlobal(adjustedActionRect.topLeft()).y() >= popup_size.height());

        const bool fitDown = (pos.y() + popup_size.height() <= screenRect.bottom());

        const int actionWidth = adjustedActionRect.width();

        if (!fitUp && !fitDown) { //we should shift the menu

            bool shouldShiftToRight = !q->isRightToLeft();

            if (q->isRightToLeft() && popup_size.width() > pos.x())

                shouldShiftToRight = true;

            else if (actionWidth + popup_size.width() + pos.x() > screenRect.right())

                shouldShiftToRight = false;

            if (shouldShiftToRight)

                pos.rx() += actionWidth;

            else

                pos.rx() -= popup_size.width();

        } else if (q->isRightToLeft()) {

            pos.setX(pos.x()-(popup_size.width() - actionWidth));

        }

        if(pos.x() < screenRect.x()) {

            pos.setX(screenRect.x());

        } else {

            const int off = pos.x()+popup_size.width() - screenRect.right();

            if(off > 0)

                pos.setX(qMax(screenRect.x(), pos.x()-off));

        }

        if(!defaultPopDown || (fitUp && !fitDown))

            pos.setY(qMax(screenRect.y(), q->mapToGlobal(QPoint(0, adjustedActionRect.top()-popup_size.height())).y()));

        activeMenu->popup(pos);

        if(activateFirst)

            activeMenu->d_func()->setFirstActionActive();

    }

    q->update(actionRect(action));

}

void QMenuBarPrivate::setCurrentAction(QAction *action, bool popup, bool activateFirst)

{

    if(currentAction == action && popup == popupState)

        return;

    autoReleaseTimer.stop();

    doChildEffects = (popup && !activeMenu);

    Q_Q(QMenuBar);

    QWidget *fw = 0;

    if(QMenu *menu = activeMenu) {

        activeMenu = 0;

        if (popup) {

            fw = q->window()->focusWidget();

            q->setFocus(Qt::NoFocusReason);

        }

        menu->hide();

    }

    if(currentAction)

        q->update(actionRect(currentAction));

    popupState = popup;

#ifndef QT_NO_STATUSTIP

    QAction *previousAction = currentAction;

#endif

    currentAction = action;

    if (action) {

        activateAction(action, QAction::Hover);

        if(popup)

            popupAction(action, activateFirst);

        q->update(actionRect(action));

#ifndef QT_NO_STATUSTIP

    }  else if (previousAction) {

        QString empty;

        QStatusTipEvent tip(empty);

        QApplication::sendEvent(q, &tip);

#endif

    }

    if (fw)

        fw->setFocus(Qt::NoFocusReason);

}

void QMenuBarPrivate::calcActionRects(int max_width, int start) const

{

    Q_Q(const QMenuBar);

    if(!itemsDirty)

        return;

    //let's reinitialize the buffer

    actionRects.resize(actions.count());

    actionRects.fill(QRect());

    const QStyle *style = q->style();

    const int itemSpacing = style->pixelMetric(QStyle::PM_MenuBarItemSpacing, 0, q);

    int max_item_height = 0, separator = -1, separator_start = 0, separator_len = 0;

    //calculate size

    const QFontMetrics fm = q->fontMetrics();

    const int hmargin = style->pixelMetric(QStyle::PM_MenuBarHMargin, 0, q),

              vmargin = style->pixelMetric(QStyle::PM_MenuBarVMargin, 0, q),

                icone = style->pixelMetric(QStyle::PM_SmallIconSize, 0, q);

    for(int i = 0; i < actions.count(); i++) {

        QAction *action = actions.at(i);

        if(!action->isVisible())

            continue;

        QSize sz;

        //calc what I think the size is..

        if(action->isSeparator()) {

            if (style->styleHint(QStyle::SH_DrawMenuBarSeparator, 0, q))

                separator = i;

            continue; //we don't really position these!

        } else {

            const QString s = action->text();

            QIcon is = action->icon();

            // If an icon is set, only the icon is visible

            if (!is.isNull())

                sz = sz.expandedTo(QSize(icone, icone));

            else if (!s.isEmpty())

                sz = fm.size(Qt::TextShowMnemonic, s);

        }

        //let the style modify the above size..

        QStyleOptionMenuItem opt;

        q->initStyleOption(&opt, action);

        sz = q->style()->sizeFromContents(QStyle::CT_MenuBarItem, &opt, sz, q);

        if(!sz.isEmpty()) {

            { //update the separator state

                int iWidth = sz.width() + itemSpacing;

                if(separator == -1)

                    separator_start += iWidth;

                else

                    separator_len += iWidth;

            }

            //maximum height

            max_item_height = qMax(max_item_height, sz.height());

            //append

            actionRects[i] = QRect(0, 0, sz.width(), sz.height());

        }

    }

    //calculate position

    const int fw = q->style()->pixelMetric(QStyle::PM_MenuBarPanelWidth, 0, q);

    int x = fw + ((start == -1) ? hmargin : start) + itemSpacing;

    int y = fw + vmargin;

    for(int i = 0; i < actions.count(); i++) {

        QRect &rect = actionRects[i];

        if (rect.isNull())

            continue;

        //resize

        rect.setHeight(max_item_height);

        //move

        if(separator != -1 && i >= separator) { //after the separator

            int left = (max_width - separator_len - hmargin - itemSpacing) + (x - separator_start - hmargin);

            if(left < separator_start) { //wrap

                separator_start = x = hmargin;

                y += max_item_height;

            }

            rect.moveLeft(left);

        } else {

            rect.moveLeft(x);

        }

        rect.moveTop(y);

        //keep moving along..

        x += rect.width() + itemSpacing;

    }

}

void QMenuBarPrivate::activateAction(QAction *action, QAction::ActionEvent action_e)

{

    Q_Q(QMenuBar);

    if (!action || !action->isEnabled())

        return;

    action->activate(action_e);

    if (action_e == QAction::Hover)

        action->showStatusText(q);

//     if(action_e == QAction::Trigger)

//         emit q->activated(action);

//     else if(action_e == QAction::Hover)

//         emit q->highlighted(action);

}

void QMenuBarPrivate::_q_actionTriggered()

{

    Q_Q(QMenuBar);