1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <qmenubar.h>

    43 

    44 #include <qstyle.h>

    45 #include <qlayout.h>

    46 #include <qapplication.h>

    47 #include <qdesktopwidget.h>

    48 #ifndef QT_NO_ACCESSIBILITY

    49 # include <qaccessible.h>

    50 #endif

    51 #include <qpainter.h>

    52 #include <qstylepainter.h>

    53 #include <qevent.h>

    54 #include <qmainwindow.h>

    55 #include <qtoolbar.h>

    56 #include <qtoolbutton.h>

    57 #include <qwhatsthis.h>

    58 

    59 #ifndef QT_NO_MENUBAR

    60 

    61 #ifdef QT3_SUPPORT

    62 #include <private/qaction_p.h>

    63 #include <qmenudata.h>

    64 #endif

    65 

    66 #include "qmenu_p.h"

    67 #include "qmenubar_p.h"

    68 #include "qdebug.h"

    69 

    70 #ifdef Q_WS_WINCE

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

    72 #endif

    73 

    74 #ifdef QT_SOFTKEYS_ENABLED

    75 #include <private/qsoftkeymanager_p.h>

    76 #endif

    77 

    78 QT_BEGIN_NAMESPACE

    79 

    80 class QMenuBarExtension : public QToolButton

    81 {

    82 public:

    83     explicit QMenuBarExtension(QWidget *parent);

    84 

    85     QSize sizeHint() const;

    86     void paintEvent(QPaintEvent *);

    87 };

    88 

    89 QMenuBarExtension::QMenuBarExtension(QWidget *parent)

    90     : QToolButton(parent)

    91 {

    92     setObjectName(QLatin1String("qt_menubar_ext_button"));

    93     setAutoRaise(true);

    94 #ifndef QT_NO_MENU

    95     setPopupMode(QToolButton::InstantPopup);

    96 #endif

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

    98 }

    99 

   100 void QMenuBarExtension::paintEvent(QPaintEvent *)

   101 {

   102     QStylePainter p(this);

   103     QStyleOptionToolButton opt;

   104     initStyleOption(&opt);

   105     // We do not need to draw both extention arrows

   106     opt.features &= ~QStyleOptionToolButton::HasMenu;

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

   108 }

   109 

   110 

   111 QSize QMenuBarExtension::sizeHint() const

   112 {

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

   114     return QSize(ext, ext);

   115 }

   116 

   117 

   118 /*!

   119     \internal

   120 */

   121 QAction *QMenuBarPrivate::actionAt(QPoint p) const

   122 {

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

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

   125             return actions.at(i);

   126     }

   127     return 0;

   128 }

   129 

   130 QRect QMenuBarPrivate::menuRect(bool extVisible) const

   131 {

   132     Q_Q(const QMenuBar);

   133 

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

   135     QRect result = q->rect();

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

   137 

   138     if (extVisible) {

   139         if (q->isRightToLeft())

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

   141         else

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

   143     }

   144 

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

   146         QSize sz = leftWidget->sizeHint();

   147         if (q->isRightToLeft())

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

   149         else

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

   151     }

   152 

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

   154         QSize sz = rightWidget->sizeHint();

   155         if (q->isRightToLeft())

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

   157         else

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

   159     }

   160 

   161     return result;

   162 }

   163 

   164 bool QMenuBarPrivate::isVisible(QAction *action)

   165 {

   166     return !hiddenActions.contains(action);

   167 }

   168 

   169 void QMenuBarPrivate::updateGeometries()

   170 {

   171     Q_Q(QMenuBar);

   172     if(!itemsDirty)

   173         return;

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

   175     int q_start = -1;

   176     if(leftWidget || rightWidget) {

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

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

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

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

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

   182             QSize sz = leftWidget->sizeHint();

   183             q_width -= sz.width();

   184             q_start = sz.width();

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

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

   187             leftWidget->setGeometry(vRect);

   188         }

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

   190             QSize sz = rightWidget->sizeHint();

   191             q_width -= sz.width();

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

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

   194             rightWidget->setGeometry(vRect);

   195         }

   196     }

   197 

   198 #ifdef Q_WS_MAC

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

   200         itemsDirty = false;

   201         return;

   202     }

   203 #endif

   204     calcActionRects(q_width, q_start);

   205     currentAction = 0;

   206 #ifndef QT_NO_SHORTCUT

   207     if(itemsDirty) {

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

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

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

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

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

   213     }

   214 #endif

   215     itemsDirty = false;

   216 

   217     hiddenActions.clear();

   218     //this is the menu rectangle without any extension

   219     QRect menuRect = this->menuRect(false);

   220 

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

   222     bool hasHiddenActions = false;

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

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

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

   226             hasHiddenActions = true;

   227             break;

   228         }

   229     }

   230 

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

   232     if (hasHiddenActions) {

   233         menuRect = this->menuRect(true);

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

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

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

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

   238             }

   239         }

   240     }

   241 

   242     if (hiddenActions.count() > 0) {

   243         QMenu *pop = extension->menu();

   244         if (!pop) {

   245             pop = new QMenu(q);

   246             extension->setMenu(pop);

   247         }

   248         pop->clear();

   249         pop->addActions(hiddenActions);

   250 

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

   252         int x = q->isRightToLeft()

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

   254                 : menuRect.right();

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

   256         extension->show();

   257     } else {

   258         extension->hide();

   259     }

   260     q->updateGeometry();

   261 #ifdef QT3_SUPPORT

   262     if (parent) {

   263         QMenubarUpdatedEvent menubarUpdated(q);

   264         QApplication::sendEvent(parent, &menubarUpdated);

   265     }

   266 #endif

   267 }

   268 

   269 QRect QMenuBarPrivate::actionRect(QAction *act) const

   270 {

   271     Q_Q(const QMenuBar);

   272     const int index = actions.indexOf(act);

   273     if (index == -1)

   274         return QRect();

   275 

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

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

   278 

   279     if (index >= actionRects.count())

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

   281 

   282     QRect ret = actionRects.at(index);

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

   284 }

   285 

   286 void QMenuBarPrivate::focusFirstAction()

   287 {

   288     if(!currentAction) {

   289         updateGeometries();

   290         int index = 0;

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

   292         if (index < actions.count())

   293             setCurrentAction(actions.at(index));

   294     }

   295 }

   296 

   297 void QMenuBarPrivate::setKeyboardMode(bool b)

   298 {

   299     Q_Q(QMenuBar);

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

   301         setCurrentAction(0);

   302         return;

   303     }

   304     keyboardState = b;

   305     if(b) {

   306         QWidget *fw = QApplication::focusWidget();

   307         if (fw != q)

   308             keyboardFocusWidget = fw;

   309         focusFirstAction();

   310         q->setFocus(Qt::MenuBarFocusReason);

   311     } else {

   312         if(!popupState)

   313             setCurrentAction(0);

   314         if(keyboardFocusWidget) {

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

   316                 keyboardFocusWidget->setFocus(Qt::MenuBarFocusReason);

   317             keyboardFocusWidget = 0;

   318         }

   319     }

   320     q->update();

   321 }

   322 

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

   324 {

   325     Q_Q(QMenuBar);

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

   327         return;

   328     popupState = true;

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

   330         closePopupMode = 0;

   331         activeMenu = action->menu();

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

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

   334 

   335         QRect adjustedActionRect = actionRect(action);

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

   337         QSize popup_size = activeMenu->sizeHint();

   338 

   339         //we put the popup menu on the screen containing the bottom-center of the action rect

   340         QRect screenRect = QApplication::desktop()->screenGeometry(pos + QPoint(adjustedActionRect.width() / 2, 0));

   341         pos = QPoint(qMax(pos.x(), screenRect.x()), qMax(pos.y(), screenRect.y()));

   342 

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

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

   345         const bool rtl = q->isRightToLeft();

   346         const int actionWidth = adjustedActionRect.width();

   347 

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

   349             bool shouldShiftToRight = !rtl;

   350             if (rtl && popup_size.width() > pos.x())

   351                 shouldShiftToRight = true;

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

   353                 shouldShiftToRight = false;

   354 

   355             if (shouldShiftToRight) {

   356                 pos.rx() += actionWidth + (rtl ? popup_size.width() : 0);

   357             } else {

   358                 //shift to left

   359                 if (!rtl)

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

   361             }

   362         } else if (rtl) {

   363             pos.rx() += actionWidth;

   364         }

   365 

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

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

   368         activeMenu->popup(pos);

   369         if(activateFirst)

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

   371     }

   372     q->update(actionRect(action));

   373 }

   374 

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

   376 {

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

   378         return;

   379 

   380     autoReleaseTimer.stop();

   381 

   382     doChildEffects = (popup && !activeMenu);

   383     Q_Q(QMenuBar);

   384     QWidget *fw = 0;

   385     if(QMenu *menu = activeMenu) {

   386         activeMenu = 0;

   387         if (popup) {

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

   389             q->setFocus(Qt::NoFocusReason);

   390         }

   391         menu->hide();

   392     }

   393 

   394     if(currentAction)

   395         q->update(actionRect(currentAction));

   396 

   397     popupState = popup;

   398 #ifndef QT_NO_STATUSTIP

   399     QAction *previousAction = currentAction;

   400 #endif

   401     currentAction = action;

   402     if (action) {

   403         activateAction(action, QAction::Hover);

   404         if(popup)

   405             popupAction(action, activateFirst);

   406         q->update(actionRect(action));

   407 #ifndef QT_NO_STATUSTIP

   408     }  else if (previousAction) {

   409         QString empty;

   410         QStatusTipEvent tip(empty);

   411         QApplication::sendEvent(q, &tip);

   412 #endif

   413     }

   414     if (fw)

   415         fw->setFocus(Qt::NoFocusReason);

   416 }

   417 

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

   419 {

   420     Q_Q(const QMenuBar);

   421 

   422     if(!itemsDirty)

   423         return;

   424 

   425     //let's reinitialize the buffer

   426     actionRects.resize(actions.count());

   427     actionRects.fill(QRect());

   428 

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

   430 

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

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

   433 

   434     //calculate size

   435     const QFontMetrics fm = q->fontMetrics();

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

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

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

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

   440         QAction *action = actions.at(i);

   441         if(!action->isVisible())

   442             continue;

   443 

   444         QSize sz;

   445 

   446         //calc what I think the size is..

   447         if(action->isSeparator()) {

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

   449                 separator = i;

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

   451         } else {

   452             const QString s = action->text();

   453             QIcon is = action->icon();

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

   455             if (!is.isNull())

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

   457             else if (!s.isEmpty())

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

   459         }

   460 

   461         //let the style modify the above size..

   462         QStyleOptionMenuItem opt;

   463         q->initStyleOption(&opt, action);

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

   465 

   466         if(!sz.isEmpty()) {

   467             { //update the separator state

   468                 int iWidth = sz.width() + itemSpacing;

   469                 if(separator == -1)

   470                     separator_start += iWidth;

   471                 else

   472                     separator_len += iWidth;

   473             }

   474             //maximum height

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

   476             //append

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

   478         }

   479     }

   480 

   481     //calculate position

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

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

   484     int y = fw + vmargin;

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

   486         QRect &rect = actionRects[i];

   487         if (rect.isNull())

   488             continue;

   489 

   490         //resize

   491         rect.setHeight(max_item_height);

   492 

   493         //move

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

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

   496             if(left < separator_start) { //wrap

   497                 separator_start = x = hmargin;

   498                 y += max_item_height;

   499             }

   500             rect.moveLeft(left);

   501         } else {

   502             rect.moveLeft(x);

   503         }

   504         rect.moveTop(y);

   505 

   506         //keep moving along..

   507         x += rect.width() + itemSpacing;

   508     }

   509 }

   510 

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

   512 {

   513     Q_Q(QMenuBar);

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

   515         return;

   516     action->activate(action_e);

   517     if (action_e == QAction::Hover)

   518         action->showStatusText(q);

   519 

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

   521 //         emit q->activated(action);

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

   523 //         emit q->highlighted(action);

   524 }

   525 

   526 

   527 void QMenuBarPrivate::_q_actionTriggered()

   528 {

   529     Q_Q(QMenuBar);

   530     if (QAction *action = qobject_cast<QAction *>(q->sender())) {

   531         emit q->triggered(action);

   532 #ifdef QT3_SUPPORT

   533         emit q->activated(q->findIdForAction(action));

   534 #endif

   535     }

   536 }

   537 

   538 void QMenuBarPrivate::_q_actionHovered()

   539 {

   540     Q_Q(QMenuBar);

   541     if (QAction *action = qobject_cast<QAction *>(q->sender())) {

   542         emit q->hovered(action);

   543 #ifndef QT_NO_ACCESSIBILITY

   544         if (QAccessible::isActive()) {

   545             int actionIndex = actions.indexOf(action);

   546             ++actionIndex;

   547             QAccessible::updateAccessibility(q, actionIndex, QAccessible::Focus);

   548             QAccessible::updateAccessibility(q, actionIndex, QAccessible::Selection);

   549         }

   550 #endif //QT_NO_ACCESSIBILITY

   551 #ifdef QT3_SUPPORT

   552         emit q->highlighted(q->findIdForAction(action));

   553 #endif

   554     }

   555 }

   556 

   557 /*!

   558     Initialize \a option with the values from the menu bar and information from \a action. This method

   559     is useful for subclasses when they need a QStyleOptionMenuItem, but don't want

   560     to fill in all the information themselves.

   561 

   562     \sa QStyleOption::initFrom() QMenu::initStyleOption()

   563 */

   564 void QMenuBar::initStyleOption(QStyleOptionMenuItem *option, const QAction *action) const

   565 {

   566     if (!option || !action)

   567         return;

   568     Q_D(const QMenuBar);

   569     option->palette = palette();

   570     option->state = QStyle::State_None;

   571     if (isEnabled() && action->isEnabled())

   572         option->state |= QStyle::State_Enabled;

   573     else

   574         option->palette.setCurrentColorGroup(QPalette::Disabled);

   575     option->fontMetrics = fontMetrics();

   576     if (d->currentAction && d->currentAction == action) {

   577         option->state |= QStyle::State_Selected;

   578         if (d->popupState && !d->closePopupMode)

   579             option->state |= QStyle::State_Sunken;

   580     }

   581     if (hasFocus() || d->currentAction)

   582         option->state |= QStyle::State_HasFocus;

   583     option->menuRect = rect();

   584     option->menuItemType = QStyleOptionMenuItem::Normal;

   585     option->checkType = QStyleOptionMenuItem::NotCheckable;

   586     option->text = action->text();

   587     option->icon = action->icon();

   588 }

   589 

   590 /*!

   591     \class QMenuBar

   592     \brief The QMenuBar class provides a horizontal menu bar.

   593 

   594     \ingroup mainwindow-classes

   595 

   596     A menu bar consists of a list of pull-down menu items. You add

   597     menu items with addMenu(). For example, asuming that \c menubar

   598     is a pointer to a QMenuBar and \c fileMenu is a pointer to a

   599     QMenu, the following statement inserts the menu into the menu bar:

   600     \snippet doc/src/snippets/code/src_gui_widgets_qmenubar.cpp 0

   601 

   602     The ampersand in the menu item's text sets Alt+F as a shortcut for

   603     this menu. (You can use "\&\&" to get a real ampersand in the menu

   604     bar.)

   605 

   606     There is no need to lay out a menu bar. It automatically sets its

   607     own geometry to the top of the parent widget and changes it

   608     appropriately whenever the parent is resized.

   609 

   610     \section1 Usage

   611 

   612     In most main window style applications you would use the

   613     \l{QMainWindow::}{menuBar()} function provided in QMainWindow,

   614     adding \l{QMenu}s to the menu bar and adding \l{QAction}s to the

   615     pop-up menus.

   616 

   617     Example (from the \l{mainwindows/menus}{Menus} example):

   618 

   619     \snippet examples/mainwindows/menus/mainwindow.cpp 9

   620 

   621     Menu items may be removed with removeAction().

   622 

   623     Widgets can be added to menus by using instances of the QWidgetAction

   624     class to hold them. These actions can then be inserted into menus

   625     in the usual way; see the QMenu documentation for more details.

   626 

   627     \section1 Platform Dependent Look and Feel

   628 

   629     Different platforms have different requirements for the appearance

   630     of menu bars and their behavior when the user interacts with them.

   631     For example, Windows systems are often configured so that the

   632     underlined character mnemonics that indicate keyboard shortcuts

   633     for items in the menu bar are only shown when the \gui{Alt} key is

   634     pressed.

   635 

   636     \table

   637 

   638     \row \o \inlineimage plastique-menubar.png A menu bar shown in the

   639     Plastique widget style.

   640 

   641     \o The \l{QPlastiqueStyle}{Plastique widget style}, like most

   642     other styles, handles the \gui{Help} menu in the same way as it

   643     handles any other menu.

   644 

   645     \row \o \inlineimage motif-menubar.png A menu bar shown in the

   646     Motif widget style.

   647 

   648     \o The \l{QMotifStyle}{Motif widget style} treats \gui{Help} menus

   649     in a special way, placing them at right-hand end of the menu bar.

   650 

   651     \endtable

   652 

   653     \section1 QMenuBar on Mac OS X

   654 

   655     QMenuBar on Mac OS X is a wrapper for using the system-wide menu bar.

   656     If you have multiple menu bars in one dialog the outermost menu bar

   657     (normally inside a widget with widget flag Qt::Window) will

   658     be used for the system-wide menu bar.

   659 

   660     Qt for Mac OS X also provides a menu bar merging feature to make

   661     QMenuBar conform more closely to accepted Mac OS X menu bar layout.

   662     The merging functionality is based on string matching the title of

   663     a QMenu entry. These strings are translated (using QObject::tr())

   664     in the "QMenuBar" context. If an entry is moved its slots will still

   665     fire as if it was in the original place. The table below outlines

   666     the strings looked for and where the entry is placed if matched:

   667 

   668     \table

   669     \header \i String matches \i Placement \i Notes

   670     \row \i about.*

   671          \i Application Menu | About <application name>

   672          \i The application name is fetched from the \c {Info.plist} file

   673             (see note below). If this entry is not found no About item

   674             will appear in the Application Menu.

   675     \row \i config, options, setup, settings or preferences

   676          \i Application Menu | Preferences

   677          \i If this entry is not found the Settings item will be disabled

   678     \row \i quit or exit

   679          \i Application Menu | Quit <application name>

   680          \i If this entry is not found a default Quit item will be

   681             created to call QApplication::quit()

   682     \endtable

   683 

   684     You can override this behavior by using the QAction::menuRole()

   685     property.

   686 

   687     If you want all windows in a Mac application to share one menu

   688     bar, you must create a menu bar that does not have a parent.

   689     Create a parent-less menu bar this way:

   690 

   691     \snippet doc/src/snippets/code/src_gui_widgets_qmenubar.cpp 1

   692 

   693     \bold{Note:} Do \e{not} call QMainWindow::menuBar() to create the

   694     shared menu bar, because that menu bar will have the QMainWindow

   695     as its parent. That menu bar would only be displayed for the

   696     parent QMainWindow.

   697 

   698     \bold{Note:} The text used for the application name in the menu

   699     bar is obtained from the value set in the \c{Info.plist} file in

   700     the application's bundle. See \l{Deploying an Application on

   701     Mac OS X} for more information.

   702 

   703     \section1 QMenuBar on Windows CE

   704 

   705     QMenuBar on Windows CE is a wrapper for using the system-wide menu bar,

   706     similar to the Mac.  This feature is activated for Windows Mobile

   707     and integrates QMenuBar with the native soft keys. The left soft

   708     key can be controlled with QMenuBar::setDefaultAction() and the

   709     right soft key can be used to access the menu bar.

   710 

   711     The hovered() signal is not supported for the native menu

   712     integration. Also, it is not possible to display an icon in a

   713     native menu on Windows Mobile.

   714 

   715     \section1 Examples

   716 

   717     The \l{mainwindows/menus}{Menus} example shows how to use QMenuBar

   718     and QMenu.  The other \l{Main Window Examples}{main window

   719     application examples} also provide menus using these classes.

   720 

   721     \sa QMenu, QShortcut, QAction,

   722         {http://developer.apple.com/documentation/UserExperience/Conceptual/AppleHIGuidelines/XHIGIntro/XHIGIntro.html}{Introduction to Apple Human Interface Guidelines},

   723         {fowler}{GUI Design Handbook: Menu Bar}, {Menus Example}

   724 */

   725 

   726 

   727 void QMenuBarPrivate::init()

   728 {

   729     Q_Q(QMenuBar);

   730     q->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Minimum);

   731     q->setAttribute(Qt::WA_CustomWhatsThis);

   732 #ifdef Q_WS_MAC

   733     macCreateMenuBar(q->parentWidget());

   734     if(mac_menubar)

   735         q->hide();

   736 #endif

   737 #ifdef Q_WS_WINCE

   738     if (qt_wince_is_mobile()) {

   739         wceCreateMenuBar(q->parentWidget());

   740         if(wce_menubar)

   741             q->hide();

   742     }

   743     else {

   744         QApplication::setAttribute(Qt::AA_DontUseNativeMenuBar, true);

   745     }

   746 #endif

   747     q->setBackgroundRole(QPalette::Button);

   748     oldWindow = oldParent = 0;

   749 #ifdef QT3_SUPPORT

   750     doAutoResize = false;

   751 #endif

   752 #ifdef QT_SOFTKEYS_ENABLED

   753     menuBarAction = 0;

   754 #endif

   755     handleReparent();

   756     q->setMouseTracking(q->style()->styleHint(QStyle::SH_MenuBar_MouseTracking, 0, q));

   757 

   758     extension = new QMenuBarExtension(q);

   759     extension->setFocusPolicy(Qt::NoFocus);

   760     extension->hide();

   761 }

   762 

   763 //Gets the next action for keyboard navigation

   764 QAction *QMenuBarPrivate::getNextAction(const int _start, const int increment) const

   765 {

   766     Q_Q(const QMenuBar);

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

   768     bool allowActiveAndDisabled = q->style()->styleHint(QStyle::SH_Menu_AllowActiveAndDisabled, 0, q);

   769     const int start = (_start == -1 && increment == -1) ? actions.count() : _start;

   770     const int end =  increment == -1 ? 0 : actions.count() - 1;

   771 

   772     for (int i = start; start != end;) {

   773         i += increment;

   774         QAction *current = actions.at(i);

   775         if (!actionRects.at(i).isNull() && (allowActiveAndDisabled || current->isEnabled()))

   776             return current;

   777     }

   778 

   779     if (_start != -1) //let's try from the beginning or the end

   780         return getNextAction(-1, increment);

   781 

   782     return 0;

   783 }

   784 

   785 /*!

   786     Constructs a menu bar with parent \a parent.

   787 */

   788 QMenuBar::QMenuBar(QWidget *parent) : QWidget(*new QMenuBarPrivate, parent, 0)

   789 {

   790     Q_D(QMenuBar);

   791     d->init();

   792 }

   793 

   794 #ifdef QT3_SUPPORT

   795 /*!

   796     Use one of the constructors that doesn't take the \a name

   797     argument and then use setObjectName() instead.

   798 */

   799 QMenuBar::QMenuBar(QWidget *parent, const char *name) : QWidget(*new QMenuBarPrivate, parent, 0)

   800 {

   801     Q_D(QMenuBar);

   802     d->init();

   803     setObjectName(QString::fromAscii(name));

   804 }

   805 #endif

   806 

   807 /*!

   808     Destroys the menu bar.

   809 */

   810 QMenuBar::~QMenuBar()

   811 {

   812 #ifdef Q_WS_MAC

   813     Q_D(QMenuBar);

   814     d->macDestroyMenuBar();

   815 #endif

   816 #ifdef Q_WS_WINCE

   817     Q_D(QMenuBar);

   818     if (qt_wince_is_mobile())

   819         d->wceDestroyMenuBar();

   820 #endif

   821 #ifdef Q_WS_S60

   822     Q_D(QMenuBar);

   823     d->symbianDestroyMenuBar();

   824 #endif

   825 }

   826 

   827 /*!

   828     \overload

   829 

   830     This convenience function creates a new action with \a text.

   831     The function adds the newly created action to the menu's

   832     list of actions, and returns it.

   833 

   834     \sa QWidget::addAction(), QWidget::actions()

   835 */

   836 QAction *QMenuBar::addAction(const QString &text)

   837 {

   838     QAction *ret = new QAction(text, this);

   839     addAction(ret);

   840     return ret;

   841 }

   842 

   843 /*!

   844     \overload

   845 

   846     This convenience function creates a new action with the given \a

   847     text. The action's triggered() signal is connected to the \a

   848     receiver's \a member slot. The function adds the newly created

   849     action to the menu's list of actions and returns it.

   850 

   851     \sa QWidget::addAction(), QWidget::actions()

   852 */

   853 QAction *QMenuBar::addAction(const QString &text, const QObject *receiver, const char* member)

   854 {

   855     QAction *ret = new QAction(text, this);

   856     QObject::connect(ret, SIGNAL(triggered(bool)), receiver, member);

   857     addAction(ret);

   858     return ret;

   859 }

   860 

   861 /*!

   862   Appends a new QMenu with \a title to the menu bar. The menu bar

   863   takes ownership of the menu. Returns the new menu.

   864 

   865   \sa QWidget::addAction() QMenu::menuAction()

   866 */

   867 QMenu *QMenuBar::addMenu(const QString &title)

   868 {

   869     QMenu *menu = new QMenu(title, this);

   870     addAction(menu->menuAction());

   871     return menu;

   872 }

   873 

   874 /*!

   875   Appends a new QMenu with \a icon and \a title to the menu bar. The menu bar

   876   takes ownership of the menu. Returns the new menu.

   877 

   878   \sa QWidget::addAction() QMenu::menuAction()

   879 */

   880 QMenu *QMenuBar::addMenu(const QIcon &icon, const QString &title)

   881 {

   882     QMenu *menu = new QMenu(title, this);

   883     menu->setIcon(icon);

   884     addAction(menu->menuAction());

   885     return menu;

   886 }

   887 

   888 /*!

   889     Appends \a menu to the menu bar. Returns the menu's menuAction().

   890 

   891     \note The returned QAction object can be used to hide the corresponding

   892     menu.

   893 

   894     \sa QWidget::addAction() QMenu::menuAction()

   895 */

   896 QAction *QMenuBar::addMenu(QMenu *menu)

   897 {

   898     QAction *action = menu->menuAction();

   899     addAction(action);

   900     return action;

   901 }

   902 

   903 /*!

   904   Appends a separator to the menu.

   905 */

   906 QAction *QMenuBar::addSeparator()

   907 {

   908     QAction *ret = new QAction(this);

   909     ret->setSeparator(true);

   910     addAction(ret);

   911     return ret;

   912 }

   913 

   914 /*!

   915     This convenience function creates a new separator action, i.e. an

   916     action with QAction::isSeparator() returning true. The function inserts

   917     the newly created action into this menu bar's list of actions before

   918     action \a before and returns it.

   919 

   920     \sa QWidget::insertAction(), addSeparator()

   921 */

   922 QAction *QMenuBar::insertSeparator(QAction *before)

   923 {

   924     QAction *action = new QAction(this);

   925     action->setSeparator(true);

   926     insertAction(before, action);

   927     return action;

   928 }

   929 

   930 /*!

   931   This convenience function inserts \a menu before action \a before

   932   and returns the menus menuAction().

   933 

   934   \sa QWidget::insertAction() addMenu()

   935 */

   936 QAction *QMenuBar::insertMenu(QAction *before, QMenu *menu)

   937 {

   938     QAction *action = menu->menuAction();

   939     insertAction(before, action);

   940     return action;

   941 }

   942 

   943 /*!

   944   Returns the QAction that is currently highlighted. A null pointer

   945   will be returned if no action is currently selected.

   946 */

   947 QAction *QMenuBar::activeAction() const

   948 {

   949     Q_D(const QMenuBar);

   950     return d->currentAction;

   951 }

   952 

   953 /*!

   954     \since 4.1

   955 

   956     Sets the currently highlighted action to \a act.

   957 */

   958 void QMenuBar::setActiveAction(QAction *act)

   959 {

   960     Q_D(QMenuBar);

   961     d->setCurrentAction(act, true, false);

   962 }

   963 

   964 

   965 /*!

   966     Removes all the actions from the menu bar.

   967 

   968     \note On Mac OS X, menu items that have been merged to the system

   969     menu bar are not removed by this function. One way to handle this

   970     would be to remove the extra actions yourself. You can set the

   971     \l{QAction::MenuRole}{menu role} on the different menus, so that

   972     you know ahead of time which menu items get merged and which do

   973     not. Then decide what to recreate or remove yourself.

   974 

   975     \sa removeAction()

   976 */

   977 void QMenuBar::clear()

   978 {

   979     QList<QAction*> acts = actions();

   980     for(int i = 0; i < acts.size(); i++)

   981         removeAction(acts[i]);

   982 }

   983 

   984 /*!

   985     \property QMenuBar::defaultUp

   986     \brief the popup orientation

   987 

   988     The default popup orientation. By default, menus pop "down" the

   989     screen. By setting the property to true, the menu will pop "up".

   990     You might call this for menus that are \e below the document to

   991     which they refer.

   992 

   993     If the menu would not fit on the screen, the other direction is

   994     used automatically.

   995 */

   996 void QMenuBar::setDefaultUp(bool b)

   997 {

   998     Q_D(QMenuBar);

   999     d->defaultPopDown = !b;

  1000 }

  1001 

  1002 bool QMenuBar::isDefaultUp() const

  1003 {

  1004     Q_D(const QMenuBar);

  1005     return !d->defaultPopDown;

  1006 }

  1007 

  1008 /*!

  1009   \reimp

  1010 */

  1011 void QMenuBar::resizeEvent(QResizeEvent *)

  1012 {

  1013     Q_D(QMenuBar);

  1014     d->itemsDirty = true;

  1015     d->updateGeometries();

  1016 }

  1017 

  1018 /*!

  1019   \reimp

  1020 */

  1021 void QMenuBar::paintEvent(QPaintEvent *e)

  1022 {

  1023     Q_D(QMenuBar);

  1024     QPainter p(this);

  1025     QRegion emptyArea(rect());

  1026 

  1027     //draw the items

  1028     for (int i = 0; i < d->actions.count(); ++i) {

  1029         QAction *action = d->actions.at(i);

  1030         QRect adjustedActionRect = d->actionRect(action);

  1031         if (adjustedActionRect.isEmpty() || !d->isVisible(action))

  1032             continue;

  1033         if(!e->rect().intersects(adjustedActionRect))

  1034             continue;

  1035 

  1036         emptyArea -= adjustedActionRect;

  1037         QStyleOptionMenuItem opt;

  1038         initStyleOption(&opt, action);

  1039         opt.rect = adjustedActionRect;

  1040         p.setClipRect(adjustedActionRect);

  1041         style()->drawControl(QStyle::CE_MenuBarItem, &opt, &p, this);

  1042     }

  1043      //draw border

  1044     if(int fw = style()->pixelMetric(QStyle::PM_MenuBarPanelWidth, 0, this)) {

  1045         QRegion borderReg;

  1046         borderReg += QRect(0, 0, fw, height()); //left

  1047         borderReg += QRect(width()-fw, 0, fw, height()); //right

  1048         borderReg += QRect(0, 0, width(), fw); //top

  1049         borderReg += QRect(0, height()-fw, width(), fw); //bottom

  1050         p.setClipRegion(borderReg);

  1051         emptyArea -= borderReg;

  1052         QStyleOptionFrame frame;

  1053         frame.rect = rect();

  1054         frame.palette = palette();

  1055         frame.state = QStyle::State_None;

  1056         frame.lineWidth = style()->pixelMetric(QStyle::PM_MenuBarPanelWidth);

  1057         frame.midLineWidth = 0;

  1058         style()->drawPrimitive(QStyle::PE_PanelMenuBar, &frame, &p, this);

  1059     }

  1060     p.setClipRegion(emptyArea);

  1061     QStyleOptionMenuItem menuOpt;

  1062     menuOpt.palette = palette();

  1063     menuOpt.state = QStyle::State_None;

  1064     menuOpt.menuItemType = QStyleOptionMenuItem::EmptyArea;

  1065     menuOpt.checkType = QStyleOptionMenuItem::NotCheckable;

  1066     menuOpt.rect = rect();

  1067     menuOpt.menuRect = rect();

  1068     style()->drawControl(QStyle::CE_MenuBarEmptyArea, &menuOpt, &p, this);

  1069 }

  1070 

  1071 /*!

  1072   \reimp

  1073 */

  1074 void QMenuBar::setVisible(bool visible)

  1075 {

  1076 #if defined(Q_WS_MAC) || defined(Q_OS_WINCE) || defined(Q_WS_S60)

  1077     if (isNativeMenuBar())

  1078         return;

  1079 #endif

  1080     QWidget::setVisible(visible);

  1081 }

  1082 

  1083 /*!

  1084   \reimp

  1085 */

  1086 void QMenuBar::mousePressEvent(QMouseEvent *e)

  1087 {

  1088     Q_D(QMenuBar);

  1089     if(e->button() != Qt::LeftButton)

  1090         return;

  1091 

  1092     d->mouseDown = true;

  1093 

  1094     QAction *action = d->actionAt(e->pos());

  1095     if (!action || !d->isVisible(action)) {

  1096         d->setCurrentAction(0);

  1097 #ifndef QT_NO_WHATSTHIS

  1098         if (QWhatsThis::inWhatsThisMode())

  1099             QWhatsThis::showText(e->globalPos(), d->whatsThis, this);

  1100 #endif

  1101         return;

  1102     }

  1103 

  1104     if(d->currentAction == action && d->popupState) {

  1105         if(QMenu *menu = d->activeMenu) {

  1106             d->activeMenu = 0;

  1107             menu->hide();

  1108         }

  1109 #ifdef Q_WS_WIN

  1110         if((d->closePopupMode = style()->styleHint(QStyle::SH_MenuBar_DismissOnSecondClick)))

  1111             update(d->actionRect(action));

  1112 #endif

  1113     } else {

  1114         d->setCurrentAction(action, true);

  1115     }

  1116 }

  1117 

  1118 /*!

  1119   \reimp

  1120 */

  1121 void QMenuBar::mouseReleaseEvent(QMouseEvent *e)

  1122 {

  1123     Q_D(QMenuBar);

  1124     if(e->button() != Qt::LeftButton || !d->mouseDown)

  1125         return;

  1126 

  1127     d->mouseDown = false;

  1128     QAction *action = d->actionAt(e->pos());

  1129     if((d->closePopupMode && action == d->currentAction) || !action || !action->menu()) {

  1130         //we set the current action before activating

  1131         //so that we let the leave event set the current back to 0

  1132         d->setCurrentAction(action, false);

  1133         if(action)

  1134             d->activateAction(action, QAction::Trigger);

  1135     }