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

     2 **

     3 ** Copyright (C) 2009 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 QT_BEGIN_NAMESPACE

    75 

    76 class QMenuBarExtension : public QToolButton

    77 {

    78 public:

    79     explicit QMenuBarExtension(QWidget *parent);

    80 

    81     QSize sizeHint() const;

    82     void paintEvent(QPaintEvent *);

    83 };

    84 

    85 QMenuBarExtension::QMenuBarExtension(QWidget *parent)

    86     : QToolButton(parent)

    87 {

    88     setObjectName(QLatin1String("qt_menubar_ext_button"));

    89     setAutoRaise(true);

    90 #ifndef QT_NO_MENU

    91     setPopupMode(QToolButton::InstantPopup);

    92 #endif

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

    94 }

    95 

    96 void QMenuBarExtension::paintEvent(QPaintEvent *)

    97 {

    98     QStylePainter p(this);

    99     QStyleOptionToolButton opt;

   100     initStyleOption(&opt);

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

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

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

   104 }

   105 

   106 

   107 QSize QMenuBarExtension::sizeHint() const

   108 {

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

   110     return QSize(ext, ext);

   111 }

   112 

   113 

   114 /*!

   115     \internal

   116 */

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

   118 {

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

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

   121             return actions.at(i);

   122     }

   123     return 0;

   124 }

   125 

   126 QRect QMenuBarPrivate::menuRect(bool extVisible) const

   127 {

   128     Q_Q(const QMenuBar);

   129 

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

   131     QRect result = q->rect();

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

   133 

   134     if (extVisible) {

   135         if (q->isRightToLeft())

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

   137         else

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

   139     }

   140 

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

   142         QSize sz = leftWidget->sizeHint();

   143         if (q->isRightToLeft())

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

   145         else

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

   147     }

   148 

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

   150         QSize sz = rightWidget->sizeHint();

   151         if (q->isRightToLeft())

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

   153         else

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

   155     }

   156 

   157     return result;

   158 }

   159 

   160 bool QMenuBarPrivate::isVisible(QAction *action)

   161 {

   162     return !hiddenActions.contains(action);

   163 }

   164 

   165 void QMenuBarPrivate::updateGeometries()

   166 {

   167     Q_Q(QMenuBar);

   168     if(!itemsDirty)

   169         return;

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

   171     int q_start = -1;

   172     if(leftWidget || rightWidget) {

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

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

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

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

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

   178             QSize sz = leftWidget->sizeHint();

   179             q_width -= sz.width();

   180             q_start = sz.width();

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

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

   183             leftWidget->setGeometry(vRect);

   184         }

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

   186             QSize sz = rightWidget->sizeHint();

   187             q_width -= sz.width();

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

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

   190             rightWidget->setGeometry(vRect);

   191         }

   192     }

   193 

   194 #ifdef Q_WS_MAC

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

   196         itemsDirty = false;

   197         return;

   198     }

   199 #endif

   200     calcActionRects(q_width, q_start);

   201     currentAction = 0;

   202 #ifndef QT_NO_SHORTCUT

   203     if(itemsDirty) {

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

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

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

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

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

   209     }

   210 #endif

   211     itemsDirty = false;

   212 

   213     hiddenActions.clear();

   214     //this is the menu rectangle without any extension

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

   216 

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

   218     bool hasHiddenActions = false;

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

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

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

   222             hasHiddenActions = true;

   223             break;

   224         }

   225     }

   226 

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

   228     if (hasHiddenActions) {

   229         menuRect = this->menuRect(true);

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

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

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

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

   234             }

   235         }

   236     }

   237 

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

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

   240         if (!pop) {

   241             pop = new QMenu(q);

   242             extension->setMenu(pop);

   243         }

   244         pop->clear();

   245         pop->addActions(hiddenActions);

   246 

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

   248         int x = q->isRightToLeft()

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

   250                 : menuRect.right();

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

   252         extension->show();

   253     } else {

   254         extension->hide();

   255     }

   256     q->updateGeometry();

   257 #ifdef QT3_SUPPORT

   258     if (parent) {

   259         QMenubarUpdatedEvent menubarUpdated(q);

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

   261     }

   262 #endif

   263 }

   264 

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

   266 {

   267     Q_Q(const QMenuBar);

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

   269     if (index == -1)

   270         return QRect();

   271 

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

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

   274 

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

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

   277 

   278     QRect ret = actionRects.at(index);

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

   280 }

   281 

   282 void QMenuBarPrivate::focusFirstAction()

   283 {

   284     if(!currentAction) {

   285         updateGeometries();

   286         int index = 0;

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

   288         if (index < actions.count())

   289             setCurrentAction(actions.at(index));

   290     }

   291 }

   292 

   293 void QMenuBarPrivate::setKeyboardMode(bool b)

   294 {

   295     Q_Q(QMenuBar);

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

   297         setCurrentAction(0);

   298         return;

   299     }

   300     keyboardState = b;

   301     if(b) {

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

   303         if (fw != q)

   304             keyboardFocusWidget = fw;

   305         focusFirstAction();

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

   307     } else {

   308         if(!popupState)

   309             setCurrentAction(0);

   310         if(keyboardFocusWidget) {

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

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

   313             keyboardFocusWidget = 0;

   314         }

   315     }

   316     q->update();

   317 }

   318 

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

   320 {

   321     Q_Q(QMenuBar);

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

   323         return;

   324     popupState = true;

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

   326         closePopupMode = 0;

   327         activeMenu = action->menu();

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

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

   330 

   331         QRect adjustedActionRect = actionRect(action);

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

   333         QSize popup_size = activeMenu->sizeHint();

   334 

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

   336 

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

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

   339         const int actionWidth = adjustedActionRect.width();

   340 

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

   342             bool shouldShiftToRight = !q->isRightToLeft();

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

   344                 shouldShiftToRight = true;

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

   346                 shouldShiftToRight = false;

   347 

   348             if (shouldShiftToRight)

   349                 pos.rx() += actionWidth;

   350             else

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

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

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

   354         }

   355 

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

   357             pos.setX(screenRect.x());

   358         } else {

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

   360             if(off > 0)

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

   362 

   363         }

   364 

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

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

   367         activeMenu->popup(pos);

   368         if(activateFirst)

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

   370     }

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

   372 }

   373 

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

   375 {

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

   377         return;

   378 

   379     autoReleaseTimer.stop();

   380 

   381     doChildEffects = (popup && !activeMenu);

   382     Q_Q(QMenuBar);

   383     QWidget *fw = 0;

   384     if(QMenu *menu = activeMenu) {

   385         activeMenu = 0;

   386         if (popup) {

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

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

   389         }

   390         menu->hide();

   391     }

   392 

   393     if(currentAction)

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

   395 

   396     popupState = popup;

   397 #ifndef QT_NO_STATUSTIP

   398     QAction *previousAction = currentAction;

   399 #endif

   400     currentAction = action;

   401     if (action) {

   402         activateAction(action, QAction::Hover);

   403         if(popup)

   404             popupAction(action, activateFirst);

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

   406 #ifndef QT_NO_STATUSTIP

   407     }  else if (previousAction) {

   408         QString empty;

   409         QStatusTipEvent tip(empty);

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

   411 #endif

   412     }

   413     if (fw)

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

   415 }

   416 

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

   418 {

   419     Q_Q(const QMenuBar);

   420 

   421     if(!itemsDirty)

   422         return;

   423 

   424     //let's reinitialize the buffer

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

   426     actionRects.fill(QRect());

   427 

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

   429 

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

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

   432 

   433     //calculate size

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

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

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

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

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

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

   440         if(!action->isVisible())

   441             continue;

   442 

   443         QSize sz;

   444 

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

   446         if(action->isSeparator()) {

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

   448                 separator = i;

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

   450         } else {

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

   452             QIcon is = action->icon();

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

   454             if (!is.isNull())

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

   456             else if (!s.isEmpty())

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

   458         }

   459 

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

   461         QStyleOptionMenuItem opt;

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

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

   464 

   465         if(!sz.isEmpty()) {

   466             { //update the separator state

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

   468                 if(separator == -1)

   469                     separator_start += iWidth;

   470                 else

   471                     separator_len += iWidth;

   472             }

   473             //maximum height

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

   475             //append

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

   477         }

   478     }

   479 

   480     //calculate position

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

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

   483     int y = fw + vmargin;

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

   485         QRect &rect = actionRects[i];

   486         if (rect.isNull())

   487             continue;

   488 

   489         //resize

   490         rect.setHeight(max_item_height);

   491 

   492         //move

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

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

   495             if(left < separator_start) { //wrap

   496                 separator_start = x = hmargin;

   497                 y += max_item_height;

   498             }

   499             rect.moveLeft(left);

   500         } else {

   501             rect.moveLeft(x);

   502         }

   503         rect.moveTop(y);

   504 

   505         //keep moving along..

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

   507     }

   508 }

   509 

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

   511 {

   512     Q_Q(QMenuBar);

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

   514         return;

   515     action->activate(action_e);

   516     if (action_e == QAction::Hover)

   517         action->showStatusText(q);

   518 

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

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

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

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

   523 }

   524 

   525 

   526 void QMenuBarPrivate::_q_actionTriggered()

   527 {

   528     Q_Q(QMenuBar);

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

   530         emit q->triggered(action);

   531 #ifdef QT3_SUPPORT

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

   533 #endif

   534     }

   535 }

   536 

   537 void QMenuBarPrivate::_q_actionHovered()

   538 {

   539     Q_Q(QMenuBar);

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

   541         emit q->hovered(action);

   542 #ifndef QT_NO_ACCESSIBILITY

   543         if (QAccessible::isActive()) {

   544             int actionIndex = actions.indexOf(action);

   545             ++actionIndex;

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

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

   548         }

   549 #endif //QT_NO_ACCESSIBILITY

   550 #ifdef QT3_SUPPORT

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

   552 #endif

   553     }

   554 }

   555 

   556 /*!

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

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

   559     to fill in all the information themselves.

   560 

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

   562 */

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

   564 {

   565     if (!option || !action)

   566         return;

   567     Q_D(const QMenuBar);

   568     option->palette = palette();

   569     option->state = QStyle::State_None;

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

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

   572     else

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

   574     option->fontMetrics = fontMetrics();

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

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

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

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

   579     }

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

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

   582     option->menuRect = rect();

   583     option->menuItemType = QStyleOptionMenuItem::Normal;

   584     option->checkType = QStyleOptionMenuItem::NotCheckable;

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

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

   587 }

   588 

   589 /*!

   590     \class QMenuBar

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

   592 

   593     \ingroup mainwindow-classes

   594 

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

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

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

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

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

   600 

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

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

   603     bar.)

   604 

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

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

   607     appropriately whenever the parent is resized.

   608 

   609     \section1 Usage

   610 

   611     In most main window style applications you would use the

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

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

   614     pop-up menus.

   615 

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

   617 

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

   619 

   620     Menu items may be removed with removeAction().

   621 

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

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

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

   625 

   626     \section1 Platform Dependent Look and Feel

   627 

   628     Different platforms have different requirements for the appearance

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

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

   631     underlined character mnemonics that indicate keyboard shortcuts

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

   633     pressed.

   634 

   635     \table

   636 

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

   638     Plastique widget style.

   639 

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

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

   642     handles any other menu.

   643 

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

   645     Motif widget style.

   646 

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

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

   649 

   650     \endtable

   651 

   652     \section1 QMenuBar on Mac OS X

   653 

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

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

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

   657     be used for the system-wide menu bar.

   658 

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

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

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

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

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

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

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

   666 

   667     \table

   668     \header \i String matches \i Placement \i Notes

   669     \row \i about.*

   670          \i Application Menu | About <application name>

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

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

   673             will appear in the Application Menu. 

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

   675          \i Application Menu | Preferences

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

   677     \row \i quit or exit

   678          \i Application Menu | Quit <application name>

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

   680             created to call QApplication::quit()

   681     \endtable

   682 

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

   684     property.

   685 

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

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

   688     Create a parent-less menu bar this way:

   689 

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

   691 

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

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

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

   695     parent QMainWindow.

   696 

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

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

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

   700     Mac OS X} for more information.

   701 

   702     \section1 QMenuBar on Windows CE

   703 

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

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

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

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

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

   709 

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

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

   712     native menu on Windows Mobile.

   713 

   714     \section1 Examples

   715 

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

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

   718     application examples} also provide menus using these classes.

   719 

   720     \sa QMenu, QShortcut, QAction,

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

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

   723 */

   724 

   725 

   726 void QMenuBarPrivate::init()

   727 {

   728     Q_Q(QMenuBar);

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

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

   731 #ifdef Q_WS_MAC

   732     macCreateMenuBar(q->parentWidget());

   733     if(mac_menubar)

   734         q->hide();

   735 #endif

   736 #ifdef Q_WS_WINCE

   737     if (qt_wince_is_mobile()) {

   738         wceCreateMenuBar(q->parentWidget());

   739         if(wce_menubar)

   740             q->hide();

   741     }

   742 #endif

   743 #ifdef Q_WS_S60

   744     symbianCreateMenuBar(q->parentWidget());

   745     if(symbian_menubar)

   746         q->hide();

   747 #endif

   748 

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

   750     oldWindow = oldParent = 0;

   751 #ifdef QT3_SUPPORT

   752     doAutoResize = false;

   753 #endif

   754     handleReparent();

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

   756 

   757     extension = new QMenuBarExtension(q);

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

   759     extension->hide();

   760 }

   761 

   762 //Gets the next action for keyboard navigation

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

   764 {

   765     Q_Q(const QMenuBar);

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

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

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

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

   770 

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

   772         i += increment;

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

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

   775             return current;

   776     }

   777 

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

   779         return getNextAction(-1, increment);

   780 

   781     return 0;

   782 }

   783 

   784 /*!

   785     Constructs a menu bar with parent \a parent.

   786 */

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

   788 {

   789     Q_D(QMenuBar);

   790     d->init();

   791 }

   792 

   793 #ifdef QT3_SUPPORT

   794 /*!

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

   796     argument and then use setObjectName() instead.

   797 */

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

   799 {

   800     Q_D(QMenuBar);

   801     d->init();

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

   803 }

   804 #endif

   805 

   806 /*!

   807     Destroys the menu bar.

   808 */

   809 QMenuBar::~QMenuBar()

   810 {

   811 #ifdef Q_WS_MAC

   812     Q_D(QMenuBar);

   813     d->macDestroyMenuBar();

   814 #endif

   815 #ifdef Q_WS_WINCE

   816     Q_D(QMenuBar);

   817     if (qt_wince_is_mobile())

   818         d->wceDestroyMenuBar();

   819 #endif

   820 #ifdef Q_WS_S60

   821     Q_D(QMenuBar);

   822     d->symbianDestroyMenuBar();

   823 #endif

   824 }

   825 

   826 /*!

   827     \overload

   828 

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

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

   831     list of actions, and returns it.

   832 

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

   834 */

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

   836 {

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

   838     addAction(ret);

   839     return ret;

   840 }

   841 

   842 /*!

   843     \overload

   844 

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

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

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

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

   849 

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

   851 */

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

   853 {

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

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

   856     addAction(ret);

   857     return ret;

   858 }

   859 

   860 /*!

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

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

   863 

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

   865 */

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

   867 {

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

   869     addAction(menu->menuAction());

   870     return menu;

   871 }

   872 

   873 /*!

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

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

   876 

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

   878 */

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

   880 {

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

   882     menu->setIcon(icon);

   883     addAction(menu->menuAction());

   884     return menu;

   885 }

   886 

   887 /*!

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

   889 

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

   891     menu.

   892 

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

   894 */

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

   896 {

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

   898     addAction(action);

   899     return action;

   900 }

   901 

   902 /*!

   903   Appends a separator to the menu.

   904 */

   905 QAction *QMenuBar::addSeparator()

   906 {

   907     QAction *ret = new QAction(this);

   908     ret->setSeparator(true);

   909     addAction(ret);

   910     return ret;

   911 }

   912 

   913 /*!

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

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

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

   917     action \a before and returns it.

   918 

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

   920 */

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

   922 {

   923     QAction *action = new QAction(this);

   924     action->setSeparator(true);

   925     insertAction(before, action);

   926     return action;

   927 }

   928 

   929 /*!

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

   931   and returns the menus menuAction().

   932 

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

   934 */

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

   936 {

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

   938     insertAction(before, action);

   939     return action;

   940 }

   941 

   942 /*!

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

   944   will be returned if no action is currently selected.

   945 */

   946 QAction *QMenuBar::activeAction() const

   947 {

   948     Q_D(const QMenuBar);

   949     return d->currentAction;

   950 }

   951 

   952 /*!

   953     \since 4.1

   954 

   955     Sets the currently highlighted action to \a act.

   956 */

   957 void QMenuBar::setActiveAction(QAction *act)

   958 {

   959     Q_D(QMenuBar);

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

   961 }

   962 

   963 

   964 /*!

   965     Removes all the actions from the menu bar.

   966 

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

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

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

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

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

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

   973 

   974     \sa removeAction()

   975 */

   976 void QMenuBar::clear()

   977 {

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

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

   980         removeAction(acts[i]);

   981 }

   982 

   983 /*!

   984     \property QMenuBar::defaultUp

   985     \brief the popup orientation

   986 

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

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

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

   990     which they refer.

   991 

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

   993     used automatically.

   994 */

   995 void QMenuBar::setDefaultUp(bool b)

   996 {

   997     Q_D(QMenuBar);

   998     d->defaultPopDown = !b;

   999 }

  1000 

  1001 bool QMenuBar::isDefaultUp() const

  1002 {

  1003     Q_D(const QMenuBar);

  1004     return !d->defaultPopDown;

  1005 }

  1006 

  1007 /*!

  1008   \reimp

  1009 */

  1010 void QMenuBar::resizeEvent(QResizeEvent *)

  1011 {

  1012     Q_D(QMenuBar);

  1013     d->itemsDirty = true;

  1014     d->updateGeometries();

  1015 }

  1016 

  1017 /*!

  1018   \reimp

  1019 */

  1020 void QMenuBar::paintEvent(QPaintEvent *e)

  1021 {

  1022     Q_D(QMenuBar);

  1023     QPainter p(this);

  1024     QRegion emptyArea(rect());

  1025 

  1026     //draw the items

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

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

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

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

  1031             continue;

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

  1033             continue;

  1034 

  1035         emptyArea -= adjustedActionRect;

  1036         QStyleOptionMenuItem opt;

  1037         initStyleOption(&opt, action);

  1038         opt.rect = adjustedActionRect;

  1039         p.setClipRect(adjustedActionRect);

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

  1041     }

  1042      //draw border

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

  1044         QRegion borderReg;

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

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

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

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

  1049         p.setClipRegion(borderReg);

  1050         emptyArea -= borderReg;

  1051         QStyleOptionFrame frame;

  1052         frame.rect = rect();

  1053         frame.palette = palette();

  1054         frame.state = QStyle::State_None;

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

  1056         frame.midLineWidth = 0;

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

  1058     }

  1059     p.setClipRegion(emptyArea);

  1060     QStyleOptionMenuItem menuOpt;

  1061     menuOpt.palette = palette();

  1062     menuOpt.state = QStyle::State_None;

  1063     menuOpt.menuItemType = QStyleOptionMenuItem::EmptyArea;

  1064     menuOpt.checkType = QStyleOptionMenuItem::NotCheckable;

  1065     menuOpt.rect = rect();

  1066     menuOpt.menuRect = rect();

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

  1068 }

  1069 

  1070 /*!

  1071   \reimp

  1072 */

  1073 void QMenuBar::setVisible(bool visible)

  1074 {

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

  1076     if (isNativeMenuBar())

  1077         return;

  1078 #endif

  1079     QWidget::setVisible(visible);

  1080 }

  1081 

  1082 /*!

  1083   \reimp

  1084 */

  1085 void QMenuBar::mousePressEvent(QMouseEvent *e)

  1086 {

  1087     Q_D(QMenuBar);

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

  1089         return;

  1090 

  1091     d->mouseDown = true;

  1092 

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

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

  1095         d->setCurrentAction(0);

  1096 #ifndef QT_NO_WHATSTHIS

  1097         if (QWhatsThis::inWhatsThisMode())

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

  1099 #endif

  1100         return;

  1101     }

  1102 

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

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

  1105             d->activeMenu = 0;

  1106             menu->hide();

  1107         }

  1108 #ifdef Q_WS_WIN

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

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

  1111 #endif

  1112     } else {

  1113         d->setCurrentAction(action, true);

  1114     }

  1115 }

  1116 

  1117 /*!

  1118   \reimp

  1119 */

  1120 void QMenuBar::mouseReleaseEvent(QMouseEvent *e)

  1121 {

  1122     Q_D(QMenuBar);

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

  1124         return;

  1125 

  1126     d->mouseDown = false;

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

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

  1129         //we set the current action before activating

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

  1131         d->setCurrentAction(action, false);

  1132         if(action)

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

  1134     }