0
+ − 1
/****************************************************************************
+ − 2
**
4
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 3
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
0
+ − 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
7
+ − 74
#ifdef QT_SOFTKEYS_ENABLED
+ − 75
#include <private/qsoftkeymanager_p.h>
+ − 76
#endif
+ − 77
0
+ − 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
3
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 339
//we put the popup menu on the screen containing the bottom-center of the action rect
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 340
QRect screenRect = QApplication::desktop()->screenGeometry(pos + QPoint(adjustedActionRect.width() / 2, 0));
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 341
pos = QPoint(qMax(pos.x(), screenRect.x()), qMax(pos.y(), screenRect.y()));
0
+ − 342
+ − 343
const bool fitUp = (q->mapToGlobal(adjustedActionRect.topLeft()).y() >= popup_size.height());
+ − 344
const bool fitDown = (pos.y() + popup_size.height() <= screenRect.bottom());
3
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 345
const bool rtl = q->isRightToLeft();
0
+ − 346
const int actionWidth = adjustedActionRect.width();
+ − 347
+ − 348
if (!fitUp && !fitDown) { //we should shift the menu
3
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 349
bool shouldShiftToRight = !rtl;
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 350
if (rtl && popup_size.width() > pos.x())
0
+ − 351
shouldShiftToRight = true;
+ − 352
else if (actionWidth + popup_size.width() + pos.x() > screenRect.right())
+ − 353
shouldShiftToRight = false;
+ − 354
3
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 355
if (shouldShiftToRight) {
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 356
pos.rx() += actionWidth + (rtl ? popup_size.width() : 0);
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 357
} else {
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 358
//shift to left
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 359
if (!rtl)
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 360
pos.rx() -= popup_size.width();
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 361
}
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 362
} else if (rtl) {
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 363
pos.rx() += actionWidth;
0
+ − 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
5
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 674
will appear in the Application Menu.
0
+ − 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
}
3
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 743
else {
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 744
QApplication::setAttribute(Qt::AA_DontUseNativeMenuBar, true);
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 745
}
0
+ − 746
#endif
+ − 747
q->setBackgroundRole(QPalette::Button);
+ − 748
oldWindow = oldParent = 0;
+ − 749
#ifdef QT3_SUPPORT
+ − 750
doAutoResize = false;
+ − 751
#endif
7
+ − 752
#ifdef QT_SOFTKEYS_ENABLED
+ − 753
menuBarAction = 0;
+ − 754
#endif
0
+ − 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
}
+ − 1136
d->closePopupMode = 0;
+ − 1137
}
+ − 1138
+ − 1139
/*!
+ − 1140
\reimp
+ − 1141
*/
+ − 1142
void QMenuBar::keyPressEvent(QKeyEvent *e)
+ − 1143
{
+ − 1144
Q_D(QMenuBar);
+ − 1145
d->updateGeometries();
+ − 1146
int key = e->key();
+ − 1147
if(isRightToLeft()) { // in reverse mode open/close key for submenues are reversed
+ − 1148
if(key == Qt::Key_Left)
+ − 1149
key = Qt::Key_Right;
+ − 1150
else if(key == Qt::Key_Right)
+ − 1151
key = Qt::Key_Left;
+ − 1152
}
+ − 1153
if(key == Qt::Key_Tab) //means right
+ − 1154
key = Qt::Key_Right;
+ − 1155
else if(key == Qt::Key_Backtab) //means left
+ − 1156
key = Qt::Key_Left;
+ − 1157
+ − 1158
bool key_consumed = false;
+ − 1159
switch(key) {
+ − 1160
case Qt::Key_Up:
+ − 1161
case Qt::Key_Down:
+ − 1162
case Qt::Key_Enter:
+ − 1163
case Qt::Key_Space:
+ − 1164
case Qt::Key_Return: {
+ − 1165
if(!style()->styleHint(QStyle::SH_MenuBar_AltKeyNavigation, 0, this) || !d->currentAction)
+ − 1166
break;
+ − 1167
if(d->currentAction->menu()) {
+ − 1168
d->popupAction(d->currentAction, true);
+ − 1169
} else if(key == Qt::Key_Enter || key == Qt::Key_Return || key == Qt::Key_Space) {
+ − 1170
d->activateAction(d->currentAction, QAction::Trigger);
+ − 1171
d->setCurrentAction(d->currentAction, false);
+ − 1172
d->setKeyboardMode(false);
+ − 1173
}
+ − 1174
key_consumed = true;
+ − 1175
break; }
+ − 1176
+ − 1177
case Qt::Key_Right:
+ − 1178
case Qt::Key_Left: {
+ − 1179
if(d->currentAction) {
+ − 1180
int index = d->actions.indexOf(d->currentAction);
+ − 1181
if (QAction *nextAction = d->getNextAction(index, key == Qt::Key_Left ? -1 : +1)) {
+ − 1182
d->setCurrentAction(nextAction, d->popupState, true);
+ − 1183
key_consumed = true;
+ − 1184
}
+ − 1185
}
+ − 1186
break; }
+ − 1187
+ − 1188
case Qt::Key_Escape:
+ − 1189
d->setCurrentAction(0);
+ − 1190
d->setKeyboardMode(false);
+ − 1191
key_consumed = true;
+ − 1192
break;
+ − 1193
+ − 1194
default:
+ − 1195
key_consumed = false;
+ − 1196
}
+ − 1197
+ − 1198
if(!key_consumed &&
+ − 1199
(!e->modifiers() ||
+ − 1200
(e->modifiers()&(Qt::MetaModifier|Qt::AltModifier))) && e->text().length()==1 && !d->popupState) {
+ − 1201
int clashCount = 0;
+ − 1202
QAction *first = 0, *currentSelected = 0, *firstAfterCurrent = 0;
+ − 1203
{
+ − 1204
QChar c = e->text()[0].toUpper();
+ − 1205
for(int i = 0; i < d->actions.size(); ++i) {
+ − 1206
if (d->actionRects.at(i).isNull())
+ − 1207
continue;
+ − 1208
QAction *act = d->actions.at(i);
+ − 1209
QString s = act->text();
+ − 1210
if(!s.isEmpty()) {
+ − 1211
int ampersand = s.indexOf(QLatin1Char('&'));
+ − 1212
if(ampersand >= 0) {
+ − 1213
if(s[ampersand+1].toUpper() == c) {
+ − 1214
clashCount++;
+ − 1215
if(!first)
+ − 1216
first = act;
+ − 1217
if(act == d->currentAction)
+ − 1218
currentSelected = act;
+ − 1219
else if (!firstAfterCurrent && currentSelected)
+ − 1220
firstAfterCurrent = act;
+ − 1221
}
+ − 1222
}
+ − 1223
}
+ − 1224
}
+ − 1225
}
+ − 1226
QAction *next_action = 0;
+ − 1227
if(clashCount >= 1) {
+ − 1228
if(clashCount == 1 || !d->currentAction || (currentSelected && !firstAfterCurrent))
+ − 1229
next_action = first;
+ − 1230
else
+ − 1231
next_action = firstAfterCurrent;
+ − 1232
}
+ − 1233
if(next_action) {
+ − 1234
key_consumed = true;
+ − 1235
d->setCurrentAction(next_action, true, true);
+ − 1236
}
+ − 1237
}
+ − 1238
if(key_consumed)
+ − 1239
e->accept();
+ − 1240
else
+ − 1241
e->ignore();
+ − 1242
}
+ − 1243
+ − 1244
/*!
+ − 1245
\reimp
+ − 1246
*/
+ − 1247
void QMenuBar::mouseMoveEvent(QMouseEvent *e)
+ − 1248
{
+ − 1249
Q_D(QMenuBar);
+ − 1250
if (!(e->buttons() & Qt::LeftButton))
+ − 1251
d->mouseDown = false;
+ − 1252
bool popupState = d->popupState || d->mouseDown;
+ − 1253
QAction *action = d->actionAt(e->pos());
+ − 1254
if ((action && d->isVisible(action)) || !popupState)
+ − 1255
d->setCurrentAction(action, popupState);
+ − 1256
}
+ − 1257
+ − 1258
/*!
+ − 1259
\reimp
+ − 1260
*/
+ − 1261
void QMenuBar::leaveEvent(QEvent *)
+ − 1262
{
+ − 1263
Q_D(QMenuBar);
+ − 1264
if((!hasFocus() && !d->popupState) ||
+ − 1265
(d->currentAction && d->currentAction->menu() == 0))
+ − 1266
d->setCurrentAction(0);
+ − 1267
}
+ − 1268
+ − 1269
/*!
+ − 1270
\reimp
+ − 1271
*/
+ − 1272
void QMenuBar::actionEvent(QActionEvent *e)
+ − 1273
{
+ − 1274
Q_D(QMenuBar);
+ − 1275
d->itemsDirty = true;
+ − 1276
#if defined (Q_WS_MAC) || defined(Q_OS_WINCE) || defined(Q_WS_S60)
+ − 1277
if (isNativeMenuBar()) {
+ − 1278
#ifdef Q_WS_MAC
+ − 1279
QMenuBarPrivate::QMacMenuBarPrivate *nativeMenuBar = d->mac_menubar;
+ − 1280
#elif defined(Q_WS_S60)
+ − 1281
QMenuBarPrivate::QSymbianMenuBarPrivate *nativeMenuBar = d->symbian_menubar;
+ − 1282
#else
+ − 1283
QMenuBarPrivate::QWceMenuBarPrivate *nativeMenuBar = d->wce_menubar;
+ − 1284
#endif
+ − 1285
if (!nativeMenuBar)
+ − 1286
return;
+ − 1287
if(e->type() == QEvent::ActionAdded)
+ − 1288
nativeMenuBar->addAction(e->action(), nativeMenuBar->findAction(e->before()));
+ − 1289
else if(e->type() == QEvent::ActionRemoved)
+ − 1290
nativeMenuBar->removeAction(e->action());
+ − 1291
else if(e->type() == QEvent::ActionChanged)
+ − 1292
nativeMenuBar->syncAction(e->action());
+ − 1293
}
+ − 1294
#endif
+ − 1295
+ − 1296
if(e->type() == QEvent::ActionAdded) {
+ − 1297
connect(e->action(), SIGNAL(triggered()), this, SLOT(_q_actionTriggered()));
+ − 1298
connect(e->action(), SIGNAL(hovered()), this, SLOT(_q_actionHovered()));
+ − 1299
} else if(e->type() == QEvent::ActionRemoved) {
+ − 1300
e->action()->disconnect(this);
+ − 1301
}
+ − 1302
if (isVisible()) {
+ − 1303
d->updateGeometries();
+ − 1304
update();
+ − 1305
}
+ − 1306
}
+ − 1307
+ − 1308
/*!
+ − 1309
\reimp
+ − 1310
*/
+ − 1311
void QMenuBar::focusInEvent(QFocusEvent *)
+ − 1312
{
+ − 1313
Q_D(QMenuBar);
+ − 1314
if(d->keyboardState)
+ − 1315
d->focusFirstAction();
+ − 1316
}
+ − 1317
+ − 1318
/*!
+ − 1319
\reimp
+ − 1320
*/
+ − 1321
void QMenuBar::focusOutEvent(QFocusEvent *)
+ − 1322
{
+ − 1323
Q_D(QMenuBar);
+ − 1324
if(!d->popupState) {
+ − 1325
d->setCurrentAction(0);
+ − 1326
d->setKeyboardMode(false);
+ − 1327
}
+ − 1328
}
+ − 1329
+ − 1330
/*!
+ − 1331
\reimp
+ − 1332
*/
+ − 1333
void QMenuBar::timerEvent (QTimerEvent *e)
+ − 1334
{
+ − 1335
Q_D(QMenuBar);
+ − 1336
if (e->timerId() == d->autoReleaseTimer.timerId()) {
+ − 1337
d->autoReleaseTimer.stop();
+ − 1338
d->setCurrentAction(0);
+ − 1339
}
+ − 1340
QWidget::timerEvent(e);
+ − 1341
}
+ − 1342
+ − 1343
+ − 1344
void QMenuBarPrivate::handleReparent()
+ − 1345
{
+ − 1346
Q_Q(QMenuBar);
+ − 1347
QWidget *newParent = q->parentWidget();
+ − 1348
//Note: if parent is reparented, then window may change even if parent doesn't
+ − 1349
+ − 1350
// we need to install an event filter on parent, and remove the old one
+ − 1351
+ − 1352
if (oldParent != newParent) {
+ − 1353
if (oldParent)
+ − 1354
oldParent->removeEventFilter(q);
+ − 1355
if (newParent)
+ − 1356
newParent->installEventFilter(q);
+ − 1357
}
+ − 1358
+ − 1359
//we also need event filter on top-level (for shortcuts)
+ − 1360
QWidget *newWindow = newParent ? newParent->window() : 0;
+ − 1361
+ − 1362
if (oldWindow != newWindow) {
+ − 1363
if (oldParent && oldParent != oldWindow)
+ − 1364
oldWindow->removeEventFilter(q);
+ − 1365
+ − 1366
if (newParent && newParent != newWindow)
+ − 1367
newWindow->installEventFilter(q);
+ − 1368
}
+ − 1369
+ − 1370
oldParent = newParent;
+ − 1371
oldWindow = newWindow;
+ − 1372
+ − 1373
#ifdef Q_WS_MAC
+ − 1374
if (q->isNativeMenuBar() && !macWidgetHasNativeMenubar(newParent)) {
+ − 1375
// If the new parent got a native menubar from before, keep that
+ − 1376
// menubar rather than replace it with this one (because a parents
+ − 1377
// menubar has precedence over children menubars).
+ − 1378
macDestroyMenuBar();
+ − 1379
macCreateMenuBar(newParent);
+ − 1380
}
+ − 1381
#endif
+ − 1382
+ − 1383
#ifdef Q_WS_WINCE
+ − 1384
if (qt_wince_is_mobile() && wce_menubar)
+ − 1385
wce_menubar->rebuild();
+ − 1386
#endif
+ − 1387
#ifdef Q_WS_S60
7
+ − 1388
+ − 1389
// Construct symbian_menubar when this code path is entered first time
+ − 1390
// and when newParent != NULL
+ − 1391
if (!symbian_menubar)
+ − 1392
symbianCreateMenuBar(newParent);
+ − 1393
+ − 1394
// Reparent and rebuild menubar when parent is changed
+ − 1395
if (symbian_menubar) {
+ − 1396
if (oldParent != newParent)
+ − 1397
reparentMenuBar(oldParent, newParent);
+ − 1398
q->hide();
0
+ − 1399
symbian_menubar->rebuild();
7
+ − 1400
}
0
+ − 1401
7
+ − 1402
#ifdef QT_SOFTKEYS_ENABLED
+ − 1403
// Constuct menuBarAction when this code path is entered first time
+ − 1404
if (!menuBarAction) {
+ − 1405
if (newParent) {
+ − 1406
menuBarAction = QSoftKeyManager::createAction(QSoftKeyManager::MenuSoftKey, newParent);
+ − 1407
newParent->addAction(menuBarAction);
+ − 1408
}
+ − 1409
} else {
+ − 1410
// If reparenting i.e. we already have menuBarAction, remove it from old parent
+ − 1411
// and add for a new parent
+ − 1412
if (oldParent)
+ − 1413
oldParent->removeAction(menuBarAction);
+ − 1414
if (newParent)
+ − 1415
newParent->addAction(menuBarAction);
+ − 1416
}
+ − 1417
#endif // QT_SOFTKEYS_ENABLED
+ − 1418
#endif // Q_WS_S60
0
+ − 1419
}
+ − 1420
+ − 1421
#ifdef QT3_SUPPORT
+ − 1422
/*!
+ − 1423
Sets whether the menu bar should automatically resize itself
+ − 1424
when its parent widget is resized.
+ − 1425
+ − 1426
This feature is provided to help porting to Qt 4. We recommend
+ − 1427
against using it in new code.
+ − 1428
+ − 1429
\sa autoGeometry()
+ − 1430
*/
+ − 1431
void QMenuBar::setAutoGeometry(bool b)
+ − 1432
{
+ − 1433
Q_D(QMenuBar);
+ − 1434
d->doAutoResize = b;
+ − 1435
}
+ − 1436
+ − 1437
/*!
+ − 1438
Returns true if the menu bar automatically resizes itself
+ − 1439
when its parent widget is resized; otherwise returns false.
+ − 1440
+ − 1441
This feature is provided to help porting to Qt 4. We recommend
+ − 1442
against using it in new code.
+ − 1443
+ − 1444
\sa setAutoGeometry()
+ − 1445
*/
+ − 1446
bool QMenuBar::autoGeometry() const
+ − 1447
{
+ − 1448
Q_D(const QMenuBar);
+ − 1449
return d->doAutoResize;
+ − 1450
}
+ − 1451
#endif
+ − 1452
+ − 1453
/*!
+ − 1454
\reimp
+ − 1455
*/
+ − 1456
void QMenuBar::changeEvent(QEvent *e)
+ − 1457
{
+ − 1458
Q_D(QMenuBar);
+ − 1459
if(e->type() == QEvent::StyleChange) {
+ − 1460
d->itemsDirty = true;
+ − 1461
setMouseTracking(style()->styleHint(QStyle::SH_MenuBar_MouseTracking, 0, this));
+ − 1462
if(parentWidget())
+ − 1463
resize(parentWidget()->width(), heightForWidth(parentWidget()->width()));
+ − 1464
d->updateGeometries();
+ − 1465
} else if (e->type() == QEvent::ParentChange) {
+ − 1466
d->handleReparent();
+ − 1467
} else if (e->type() == QEvent::FontChange
+ − 1468
|| e->type() == QEvent::ApplicationFontChange) {
+ − 1469
d->itemsDirty = true;
+ − 1470
d->updateGeometries();
7
+ − 1471
#ifdef QT_SOFTKEYS_ENABLED
+ − 1472
} else if (e->type() == QEvent::LanguageChange) {
+ − 1473
if (d->menuBarAction)
+ − 1474
d->menuBarAction->setText(QSoftKeyManager::standardSoftKeyText(QSoftKeyManager::MenuSoftKey));
+ − 1475
#endif
0
+ − 1476
}
7
+ − 1477
0
+ − 1478
QWidget::changeEvent(e);
+ − 1479
}
+ − 1480
+ − 1481
/*!
+ − 1482
\reimp
+ − 1483
*/
+ − 1484
bool QMenuBar::event(QEvent *e)
+ − 1485
{
+ − 1486
Q_D(QMenuBar);
+ − 1487
switch (e->type()) {
+ − 1488
case QEvent::KeyPress: {
+ − 1489
QKeyEvent *ke = (QKeyEvent*)e;
+ − 1490
#if 0
+ − 1491
if(!d->keyboardState) { //all keypresses..
+ − 1492
d->setCurrentAction(0);
+ − 1493
return ;
+ − 1494
}
+ − 1495
#endif
+ − 1496
if(ke->key() == Qt::Key_Tab || ke->key() == Qt::Key_Backtab) {
+ − 1497
keyPressEvent(ke);
+ − 1498
return true;
+ − 1499
}
+ − 1500
+ − 1501
} break;
+ − 1502
#ifndef QT_NO_SHORTCUT
+ − 1503
case QEvent::Shortcut: {
+ − 1504
QShortcutEvent *se = static_cast<QShortcutEvent *>(e);
+ − 1505
int shortcutId = se->shortcutId();
+ − 1506
for(int j = 0; j < d->shortcutIndexMap.size(); ++j) {
+ − 1507
if (shortcutId == d->shortcutIndexMap.value(j))
+ − 1508
d->_q_internalShortcutActivated(j);
+ − 1509
}
+ − 1510
} break;
+ − 1511
#endif
+ − 1512
case QEvent::Show:
+ − 1513
#ifdef QT3_SUPPORT
+ − 1514
if(QWidget *p = parentWidget()) {
+ − 1515
// If itemsDirty == true, updateGeometries sends the MenubarUpdated event.
+ − 1516
if (!d->itemsDirty) {
+ − 1517
QMenubarUpdatedEvent menubarUpdated(this);
+ − 1518
QApplication::sendEvent(p, &menubarUpdated);
+ − 1519
}
+ − 1520
}
+ − 1521
#endif
+ − 1522
d->_q_updateLayout();
+ − 1523
break;
+ − 1524
case QEvent::ShortcutOverride: {
+ − 1525
QKeyEvent *kev = static_cast<QKeyEvent*>(e);
3
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 1526
//we only filter out escape if there is a current action
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 1527
if (kev->key() == Qt::Key_Escape && d->currentAction) {
0
+ − 1528
e->accept();
+ − 1529
return true;
+ − 1530
}
+ − 1531
}
+ − 1532
break;
+ − 1533
+ − 1534
#ifdef QT3_SUPPORT
+ − 1535
case QEvent::Hide: {
+ − 1536
if(QWidget *p = parentWidget()) {
+ − 1537
QMenubarUpdatedEvent menubarUpdated(this);
+ − 1538
QApplication::sendEvent(p, &menubarUpdated);
+ − 1539
}
+ − 1540
} break;
+ − 1541
#endif
+ − 1542
+ − 1543
#ifndef QT_NO_WHATSTHIS
+ − 1544
case QEvent::QueryWhatsThis:
+ − 1545
e->setAccepted(d->whatsThis.size());
+ − 1546
if (QAction *action = d->actionAt(static_cast<QHelpEvent*>(e)->pos())) {
+ − 1547
if (action->whatsThis().size() || action->menu())
+ − 1548
e->accept();
+ − 1549
}
+ − 1550
return true;
+ − 1551
#endif
+ − 1552
case QEvent::LayoutDirectionChange:
+ − 1553
d->_q_updateLayout();
+ − 1554
break;
+ − 1555
default:
+ − 1556
break;
+ − 1557
}
+ − 1558
return QWidget::event(e);
+ − 1559
}
+ − 1560
+ − 1561
/*!
+ − 1562
\reimp
+ − 1563
*/
+ − 1564
bool QMenuBar::eventFilter(QObject *object, QEvent *event)
+ − 1565
{
+ − 1566
Q_D(QMenuBar);
+ − 1567
if (object == parent() && object) {
+ − 1568
#ifdef QT3_SUPPORT
+ − 1569
if (d->doAutoResize && event->type() == QEvent::Resize) {
+ − 1570
QResizeEvent *e = (QResizeEvent *)event;
+ − 1571
int w = e->size().width();
+ − 1572
setGeometry(0, y(), w, heightForWidth(w));
+ − 1573
return false;
+ − 1574
}
+ − 1575
#endif
+ − 1576
if (event->type() == QEvent::ParentChange) //GrandparentChange
+ − 1577
d->handleReparent();
+ − 1578
}
+ − 1579
if (object == d->leftWidget || object == d->rightWidget) {
+ − 1580
switch (event->type()) {
+ − 1581
case QEvent::ShowToParent:
+ − 1582
case QEvent::HideToParent:
+ − 1583
d->_q_updateLayout();
+ − 1584
break;
+ − 1585
default:
+ − 1586
break;
+ − 1587
}
+ − 1588
}
+ − 1589
+ − 1590
if (style()->styleHint(QStyle::SH_MenuBar_AltKeyNavigation, 0, this)) {
+ − 1591
if (d->altPressed) {
+ − 1592
switch (event->type()) {
+ − 1593
case QEvent::KeyPress:
+ − 1594
case QEvent::KeyRelease:
+ − 1595
{
+ − 1596
QKeyEvent *kev = static_cast<QKeyEvent*>(event);
+ − 1597
if (kev->key() == Qt::Key_Alt || kev->key() == Qt::Key_Meta) {
+ − 1598
if (event->type() == QEvent::KeyPress) // Alt-press does not interest us, we have the shortcut-override event
+ − 1599
break;
+ − 1600
d->setKeyboardMode(!d->keyboardState);
+ − 1601
}
+ − 1602
}
+ − 1603
// fall through
+ − 1604
case QEvent::MouseButtonPress:
+ − 1605
case QEvent::MouseButtonRelease:
+ − 1606
case QEvent::MouseMove:
+ − 1607
case QEvent::FocusIn:
+ − 1608
case QEvent::FocusOut:
+ − 1609
case QEvent::ActivationChange:
+ − 1610
d->altPressed = false;
+ − 1611
qApp->removeEventFilter(this);
+ − 1612
break;
+ − 1613
default:
+ − 1614
break;
+ − 1615
}
+ − 1616
} else if (isVisible()) {
+ − 1617
if (event->type() == QEvent::ShortcutOverride) {
+ − 1618
QKeyEvent *kev = static_cast<QKeyEvent*>(event);
+ − 1619
if ((kev->key() == Qt::Key_Alt || kev->key() == Qt::Key_Meta)
+ − 1620
&& kev->modifiers() == Qt::AltModifier) {
+ − 1621
d->altPressed = true;
+ − 1622
qApp->installEventFilter(this);
+ − 1623
}
+ − 1624
}
+ − 1625
}
+ − 1626
}
+ − 1627
+ − 1628
return false;
+ − 1629
}
+ − 1630
+ − 1631
/*!
+ − 1632
\internal
+ − 1633
+ − 1634
Return the item at \a pt, or 0 if there is no item there or if it is
+ − 1635
a separator item.
+ − 1636
*/
+ − 1637
QAction *QMenuBar::actionAt(const QPoint &pt) const
+ − 1638
{
+ − 1639
Q_D(const QMenuBar);
+ − 1640
return d->actionAt(pt);
+ − 1641
}
+ − 1642
+ − 1643
/*!
+ − 1644
\internal
+ − 1645
+ − 1646
Returns the geometry of action \a act.
+ − 1647
*/
+ − 1648
QRect QMenuBar::actionGeometry(QAction *act) const
+ − 1649
{
+ − 1650
Q_D(const QMenuBar);
+ − 1651
return d->actionRect(act);
+ − 1652
}
+ − 1653
+ − 1654
/*!
+ − 1655
\reimp
+ − 1656
*/
+ − 1657
QSize QMenuBar::minimumSizeHint() const
+ − 1658
{
+ − 1659
Q_D(const QMenuBar);
+ − 1660
#if defined(Q_WS_MAC) || defined(Q_WS_WINCE) || defined(Q_WS_S60)
+ − 1661
const bool as_gui_menubar = !isNativeMenuBar();
+ − 1662
#else
+ − 1663
const bool as_gui_menubar = true;
+ − 1664
#endif
+ − 1665
+ − 1666
ensurePolished();
+ − 1667
QSize ret(0, 0);
+ − 1668
const_cast<QMenuBarPrivate*>(d)->updateGeometries();
+ − 1669
const int hmargin = style()->pixelMetric(QStyle::PM_MenuBarHMargin, 0, this);
+ − 1670
const int vmargin = style()->pixelMetric(QStyle::PM_MenuBarVMargin, 0, this);
+ − 1671
int fw = style()->pixelMetric(QStyle::PM_MenuBarPanelWidth, 0, this);
+ − 1672
int spaceBelowMenuBar = style()->styleHint(QStyle::SH_MainWindow_SpaceBelowMenuBar, 0, this);
+ − 1673
if(as_gui_menubar) {
+ − 1674
int w = parentWidget() ? parentWidget()->width() : QApplication::desktop()->width();
+ − 1675
d->calcActionRects(w - (2 * fw), 0);
+ − 1676
for (int i = 0; ret.isNull() && i < d->actions.count(); ++i)
+ − 1677
ret = d->actionRects.at(i).size();
+ − 1678
if (!d->extension->isHidden())
+ − 1679
ret += QSize(d->extension->sizeHint().width(), 0);
+ − 1680
ret += QSize(2*fw + hmargin, 2*fw + vmargin);
+ − 1681
}
+ − 1682
int margin = 2*vmargin + 2*fw + spaceBelowMenuBar;
+ − 1683
if(d->leftWidget) {
+ − 1684
QSize sz = d->leftWidget->minimumSizeHint();
+ − 1685
ret.setWidth(ret.width() + sz.width());
+ − 1686
if(sz.height() + margin > ret.height())
+ − 1687
ret.setHeight(sz.height() + margin);
+ − 1688
}
+ − 1689
if(d->rightWidget) {
+ − 1690
QSize sz = d->rightWidget->minimumSizeHint();
+ − 1691
ret.setWidth(ret.width() + sz.width());
+ − 1692
if(sz.height() + margin > ret.height())
+ − 1693
ret.setHeight(sz.height() + margin);
+ − 1694
}
+ − 1695
if(as_gui_menubar) {
+ − 1696
QStyleOptionMenuItem opt;
+ − 1697
opt.rect = rect();
+ − 1698
opt.menuRect = rect();
+ − 1699
opt.state = QStyle::State_None;
+ − 1700
opt.menuItemType = QStyleOptionMenuItem::Normal;
+ − 1701
opt.checkType = QStyleOptionMenuItem::NotCheckable;
+ − 1702
opt.palette = palette();
+ − 1703
return (style()->sizeFromContents(QStyle::CT_MenuBar, &opt,
+ − 1704
ret.expandedTo(QApplication::globalStrut()),
+ − 1705
this));
+ − 1706
}
+ − 1707
return ret;
+ − 1708
}
+ − 1709
+ − 1710
/*!
+ − 1711
\reimp
+ − 1712
*/
+ − 1713
QSize QMenuBar::sizeHint() const
+ − 1714
{
+ − 1715
Q_D(const QMenuBar);
+ − 1716
#if defined(Q_WS_MAC) || defined(Q_WS_WINCE) || defined(Q_WS_S60)
+ − 1717
const bool as_gui_menubar = !isNativeMenuBar();
+ − 1718
#else
+ − 1719
const bool as_gui_menubar = true;
+ − 1720
#endif
+ − 1721
+ − 1722
+ − 1723
ensurePolished();
+ − 1724
QSize ret(0, 0);
+ − 1725
const_cast<QMenuBarPrivate*>(d)->updateGeometries();
+ − 1726
const int hmargin = style()->pixelMetric(QStyle::PM_MenuBarHMargin, 0, this);
+ − 1727
const int vmargin = style()->pixelMetric(QStyle::PM_MenuBarVMargin, 0, this);
+ − 1728
int fw = style()->pixelMetric(QStyle::PM_MenuBarPanelWidth, 0, this);
+ − 1729
int spaceBelowMenuBar = style()->styleHint(QStyle::SH_MainWindow_SpaceBelowMenuBar, 0, this);
+ − 1730
if(as_gui_menubar) {
+ − 1731
const int w = parentWidget() ? parentWidget()->width() : QApplication::desktop()->width();
+ − 1732
d->calcActionRects(w - (2 * fw), 0);
+ − 1733
for (int i = 0; i < d->actionRects.count(); ++i) {
+ − 1734
const QRect &actionRect = d->actionRects.at(i);
+ − 1735
ret = ret.expandedTo(QSize(actionRect.x() + actionRect.width(), actionRect.y() + actionRect.height()));
+ − 1736
}
+ − 1737
//the action geometries already contain the top and left
+ − 1738
//margins. So we only need to add those from right and bottom.
+ − 1739
ret += QSize(fw + hmargin, fw + vmargin);
+ − 1740
}
+ − 1741
int margin = 2*vmargin + 2*fw + spaceBelowMenuBar;
+ − 1742
if(d->leftWidget) {
+ − 1743
QSize sz = d->leftWidget->sizeHint();
+ − 1744
ret.setWidth(ret.width() + sz.width());
+ − 1745
if(sz.height() + margin > ret.height())
+ − 1746
ret.setHeight(sz.height() + margin);
+ − 1747
}
+ − 1748
if(d->rightWidget) {
+ − 1749
QSize sz = d->rightWidget->sizeHint();
+ − 1750
ret.setWidth(ret.width() + sz.width());
+ − 1751
if(sz.height() + margin > ret.height())
+ − 1752
ret.setHeight(sz.height() + margin);
+ − 1753
}
+ − 1754
if(as_gui_menubar) {
+ − 1755
QStyleOptionMenuItem opt;
+ − 1756
opt.rect = rect();
+ − 1757
opt.menuRect = rect();
+ − 1758
opt.state = QStyle::State_None;
+ − 1759
opt.menuItemType = QStyleOptionMenuItem::Normal;
+ − 1760
opt.checkType = QStyleOptionMenuItem::NotCheckable;
+ − 1761
opt.palette = palette();
+ − 1762
return (style()->sizeFromContents(QStyle::CT_MenuBar, &opt,
+ − 1763
ret.expandedTo(QApplication::globalStrut()),
+ − 1764
this));
+ − 1765
}
+ − 1766
return ret;
+ − 1767
}
+ − 1768
+ − 1769
/*!
+ − 1770
\reimp
+ − 1771
*/
+ − 1772
int QMenuBar::heightForWidth(int) const
+ − 1773
{
+ − 1774
Q_D(const QMenuBar);
+ − 1775
#if defined(Q_WS_MAC) || defined(Q_WS_WINCE) || defined(Q_WS_S60)
+ − 1776
const bool as_gui_menubar = !isNativeMenuBar();
+ − 1777
#else
+ − 1778
const bool as_gui_menubar = true;
+ − 1779
#endif
+ − 1780
+ − 1781
const_cast<QMenuBarPrivate*>(d)->updateGeometries();
+ − 1782
int height = 0;
+ − 1783
const int vmargin = style()->pixelMetric(QStyle::PM_MenuBarVMargin, 0, this);
+ − 1784
int fw = style()->pixelMetric(QStyle::PM_MenuBarPanelWidth, 0, this);
+ − 1785
int spaceBelowMenuBar = style()->styleHint(QStyle::SH_MainWindow_SpaceBelowMenuBar, 0, this);
+ − 1786
if(as_gui_menubar) {
+ − 1787
for (int i = 0; i < d->actionRects.count(); ++i)
+ − 1788
height = qMax(height, d->actionRects.at(i).height());
+ − 1789
if (height) //there is at least one non-null item
+ − 1790
height += spaceBelowMenuBar;
+ − 1791
height += 2*fw;
+ − 1792
height += 2*vmargin;
+ − 1793
}
+ − 1794
int margin = 2*vmargin + 2*fw + spaceBelowMenuBar;
+ − 1795
if(d->leftWidget)
+ − 1796
height = qMax(d->leftWidget->sizeHint().height() + margin, height);
+ − 1797
if(d->rightWidget)
+ − 1798
height = qMax(d->rightWidget->sizeHint().height() + margin, height);
+ − 1799
if(as_gui_menubar) {
+ − 1800
QStyleOptionMenuItem opt;
+ − 1801
opt.init(this);
+ − 1802
opt.menuRect = rect();
+ − 1803
opt.state = QStyle::State_None;
+ − 1804
opt.menuItemType = QStyleOptionMenuItem::Normal;
+ − 1805
opt.checkType = QStyleOptionMenuItem::NotCheckable;
+ − 1806
return style()->sizeFromContents(QStyle::CT_MenuBar, &opt, QSize(0, height), this).height(); //not pretty..
+ − 1807
}
+ − 1808
return height;
+ − 1809
}
+ − 1810
+ − 1811
/*!
+ − 1812
\internal
+ − 1813
*/
+ − 1814
void QMenuBarPrivate::_q_internalShortcutActivated(int id)
+ − 1815
{
+ − 1816
Q_Q(QMenuBar);
+ − 1817
QAction *act = actions.at(id);
+ − 1818
setCurrentAction(act, true, true);
+ − 1819
if (act && !act->menu()) {
+ − 1820
activateAction(act, QAction::Trigger);
+ − 1821
//100 is the same as the default value in QPushButton::animateClick
+ − 1822
autoReleaseTimer.start(100, q);
+ − 1823
} else if (act && q->style()->styleHint(QStyle::SH_MenuBar_AltKeyNavigation, 0, q)) {
+ − 1824
// When we open a menu using a shortcut, we should end up in keyboard state
+ − 1825
setKeyboardMode(true);
+ − 1826
}
+ − 1827
}
+ − 1828
+ − 1829
void QMenuBarPrivate::_q_updateLayout()
+ − 1830
{
+ − 1831
Q_Q(QMenuBar);
+ − 1832
itemsDirty = true;
+ − 1833
if (q->isVisible()) {
+ − 1834
updateGeometries();
+ − 1835
q->update();
+ − 1836
}
+ − 1837
}
+ − 1838
+ − 1839
/*!
+ − 1840
\internal
+ − 1841
+ − 1842
This sets widget \a w to be shown directly on the left of the first or
+ − 1843
the right of the last menu item, depending on \a corner.
+ − 1844
*/
+ − 1845
void QMenuBar::setCornerWidget(QWidget *w, Qt::Corner corner)
+ − 1846
{
+ − 1847
Q_D(QMenuBar);
+ − 1848
switch (corner) {
+ − 1849
case Qt::TopLeftCorner:
+ − 1850
if (d->leftWidget)
+ − 1851
d->leftWidget->removeEventFilter(this);
+ − 1852
d->leftWidget = w;
+ − 1853
break;
+ − 1854
case Qt::TopRightCorner:
+ − 1855
if (d->rightWidget)
+ − 1856
d->rightWidget->removeEventFilter(this);
+ − 1857
d->rightWidget = w;
+ − 1858
break;
+ − 1859
default:
+ − 1860
qWarning("QMenuBar::setCornerWidget: Only TopLeftCorner and TopRightCorner are supported");
+ − 1861
return;
+ − 1862
}
+ − 1863
+ − 1864
if (w) {
+ − 1865
w->setParent(this);
+ − 1866
w->installEventFilter(this);
+ − 1867
}
+ − 1868
+ − 1869
d->_q_updateLayout();
+ − 1870
}
+ − 1871
+ − 1872
/*!
+ − 1873
\internal
+ − 1874
+ − 1875
Returns the widget in the left of the first or the right of the last menu
+ − 1876
item, depending on \a corner.
+ − 1877
*/
+ − 1878
QWidget *QMenuBar::cornerWidget(Qt::Corner corner) const
+ − 1879
{
+ − 1880
Q_D(const QMenuBar);
+ − 1881
QWidget *w = 0;
+ − 1882
switch(corner) {
+ − 1883
case Qt::TopLeftCorner:
+ − 1884
w = d->leftWidget;
+ − 1885
break;
+ − 1886
case Qt::TopRightCorner:
+ − 1887
w = d->rightWidget;
+ − 1888
break;
+ − 1889
default:
+ − 1890
qWarning("QMenuBar::cornerWidget: Only TopLeftCorner and TopRightCorner are supported");
+ − 1891
break;
+ − 1892
}
+ − 1893
+ − 1894
return w;
+ − 1895
}
+ − 1896
+ − 1897
/*!
+ − 1898
\property QMenuBar::nativeMenuBar
+ − 1899
\brief Whether or not a menubar will be used as a native menubar on platforms that support it
+ − 1900
\since 4.6
+ − 1901
+ − 1902
This property specifies whether or not the menubar should be used as a native menubar on platforms
+ − 1903
that support it. The currently supported platforms are Mac OS X and Windows CE. On these platforms
+ − 1904
if this property is true, the menubar is used in the native menubar and is not in the window of
+ − 1905
its parent, if false the menubar remains in the window. On other platforms the value of this
+ − 1906
attribute has no effect.
+ − 1907
+ − 1908
The default is to follow whether the Qt::AA_DontUseNativeMenuBar attribute
+ − 1909
is set for the application. Explicitly settings this property overrides
+ − 1910
the presence (or abscence) of the attribute.
+ − 1911
*/
+ − 1912
+ − 1913
void QMenuBar::setNativeMenuBar(bool nativeMenuBar)
+ − 1914
{
+ − 1915
Q_D(QMenuBar);
+ − 1916
if (d->nativeMenuBar == -1 || (nativeMenuBar != bool(d->nativeMenuBar))) {
+ − 1917
d->nativeMenuBar = nativeMenuBar;
+ − 1918
#ifdef Q_WS_MAC
+ − 1919
if (!d->nativeMenuBar) {
+ − 1920
extern void qt_mac_clear_menubar();
+ − 1921
qt_mac_clear_menubar();
+ − 1922
d->macDestroyMenuBar();
+ − 1923
const QList<QAction *> &menubarActions = actions();
+ − 1924
for (int i = 0; i < menubarActions.size(); ++i) {
+ − 1925
const QAction *action = menubarActions.at(i);
+ − 1926
if (QMenu *menu = action->menu()) {
+ − 1927
delete menu->d_func()->mac_menu;
+ − 1928
menu->d_func()->mac_menu = 0;
+ − 1929
}
+ − 1930
}
+ − 1931
} else {
+ − 1932
d->macCreateMenuBar(parentWidget());
+ − 1933
}
+ − 1934
macUpdateMenuBar();
+ − 1935
updateGeometry();
+ − 1936
setVisible(false);
+ − 1937
setVisible(true);
+ − 1938
#endif
+ − 1939
}
+ − 1940
}
+ − 1941
+ − 1942
bool QMenuBar::isNativeMenuBar() const
+ − 1943
{
+ − 1944
Q_D(const QMenuBar);
+ − 1945
if (d->nativeMenuBar == -1) {
+ − 1946
return !QApplication::instance()->testAttribute(Qt::AA_DontUseNativeMenuBar);
+ − 1947
}
+ − 1948
return d->nativeMenuBar;
+ − 1949
}
+ − 1950
+ − 1951
/*!
+ − 1952
\since 4.4
+ − 1953
+ − 1954
Sets the default action to \a act.
+ − 1955
+ − 1956
The default action is assigned to the left soft key. The menu is assigned
+ − 1957
to the right soft key.
+ − 1958
+ − 1959
Currently there is only support for the default action on Windows
+ − 1960
Mobile. All other platforms ignore the default action.
+ − 1961
+ − 1962
\sa defaultAction()
+ − 1963
*/
+ − 1964
+ − 1965
#ifdef Q_WS_WINCE
+ − 1966
void QMenuBar::setDefaultAction(QAction *act)
+ − 1967
{
+ − 1968
Q_D(QMenuBar);
+ − 1969
if (d->defaultAction == act)
+ − 1970
return;
+ − 1971
#ifdef Q_WS_WINCE
+ − 1972
if (qt_wince_is_mobile())
+ − 1973
if (d->defaultAction) {
+ − 1974
disconnect(d->defaultAction, SIGNAL(changed()), this, SLOT(_q_updateDefaultAction()));
3
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
diff
changeset
+ − 1975
disconnect(d->defaultAction, SIGNAL(destroyed()), this, SLOT(_q_updateDefaultAction()));
0
+ − 1976
}
+ − 1977
#endif
+ − 1978
d->defaultAction = act;
+ − 1979
#ifdef Q_WS_WINCE
+ − 1980
if (qt_wince_is_mobile())
+ − 1981
if (d->defaultAction) {
+ − 1982
connect(d->defaultAction, SIGNAL(changed()), this, SLOT(_q_updateDefaultAction()));
+ − 1983
connect(d->defaultAction, SIGNAL(destroyed()), this, SLOT(_q_updateDefaultAction()));
+ − 1984
}
+ − 1985
if (d->wce_menubar) {
+ − 1986
d->wce_menubar->rebuild();
+ − 1987
}
+ − 1988
#endif
+ − 1989
}
+ − 1990
+ − 1991
/*!
+ − 1992
\since 4.4
+ − 1993
+ − 1994
Returns the current default action.
+ − 1995
+ − 1996
\sa setDefaultAction()
+ − 1997
*/
+ − 1998
QAction *QMenuBar::defaultAction() const
+ − 1999
{
+ − 2000
return d_func()->defaultAction;
+ − 2001
}
+ − 2002
#endif
+ − 2003
+ − 2004
/*!
+ − 2005
\fn void QMenuBar::triggered(QAction *action)
+ − 2006
+ − 2007
This signal is emitted when an action in a menu belonging to this menubar
+ − 2008
is triggered as a result of a mouse click; \a action is the action that
+ − 2009
caused the signal to be emitted.
+ − 2010
+ − 2011
Normally, you connect each menu action to a single slot using
+ − 2012
QAction::triggered(), but sometimes you will want to connect
+ − 2013
several items to a single slot (most often if the user selects
+ − 2014
from an array). This signal is useful in such cases.
+ − 2015
+ − 2016
\sa hovered(), QAction::triggered()
+ − 2017
*/
+ − 2018
+ − 2019
/*!
+ − 2020
\fn void QMenuBar::hovered(QAction *action)
+ − 2021
+ − 2022
This signal is emitted when a menu action is highlighted; \a action
+ − 2023
is the action that caused the event to be sent.
+ − 2024
+ − 2025
Often this is used to update status information.
+ − 2026
+ − 2027
\sa triggered(), QAction::hovered()
+ − 2028
*/
+ − 2029
+ − 2030
+ − 2031
#ifdef QT3_SUPPORT
+ − 2032
/*!
+ − 2033
Use style()->pixelMetric(QStyle::PM_MenuBarPanelWidth, this)
+ − 2034
instead.
+ − 2035
*/
+ − 2036
int QMenuBar::frameWidth() const
+ − 2037
{
+ − 2038
return style()->pixelMetric(QStyle::PM_MenuBarPanelWidth, 0, this);
+ − 2039
}
+ − 2040
+ − 2041
int QMenuBar::insertAny(const QIcon *icon, const QString *text, const QObject *receiver, const char *member,
+ − 2042
const QKeySequence *shortcut, const QMenu *popup, int id, int index)
+ − 2043
{
+ − 2044
QAction *act = popup ? popup->menuAction() : new QAction(this);
+ − 2045
if(id != -1)
+ − 2046
static_cast<QMenuItem*>(act)->setId(id);
+ − 2047
if(icon)
+ − 2048
act->setIcon(*icon);
+ − 2049
if(text)
+ − 2050
act->setText(*text);
+ − 2051
if(shortcut)
+ − 2052
act->setShortcut(*shortcut);
+ − 2053
if(receiver && member)
+ − 2054
QObject::connect(act, SIGNAL(triggered(bool)), receiver, member);
+ − 2055
if(index == -1 || index >= actions().count())
+ − 2056
addAction(act);
+ − 2057
else
+ − 2058
insertAction(actions().value(index), act);
+ − 2059
return findIdForAction(act);
+ − 2060
}
+ − 2061
+ − 2062
/*!
+ − 2063
\since 4.2
+ − 2064
+ − 2065
Use addSeparator() or insertAction() instead.
+ − 2066
+ − 2067
\oldcode
+ − 2068
menuBar->insertSeparator();
+ − 2069
\newcode
+ − 2070
menuBar->addSeparator();
+ − 2071
\endcode
+ − 2072
*/
+ − 2073
int QMenuBar::insertSeparator(int index)
+ − 2074
{
+ − 2075
QAction *act = new QAction(this);
+ − 2076
act->setSeparator(true);
+ − 2077
if(index == -1 || index >= actions().count())
+ − 2078
addAction(act);
+ − 2079
else
+ − 2080
insertAction(actions().value(index), act);
+ − 2081
return findIdForAction(act);
+ − 2082
}
+ − 2083
+ − 2084
/*!
+ − 2085
Use QAction::setData() instead.
+ − 2086
*/
+ − 2087
bool QMenuBar::setItemParameter(int id, int param)
+ − 2088
{
+ − 2089
if(QAction *act = findActionForId(id)) {
+ − 2090
act->d_func()->param = param;
+ − 2091
return true;
+ − 2092
}
+ − 2093
return false;
+ − 2094
}
+ − 2095
+ − 2096
/*!
+ − 2097
Use QAction::data() instead.
+ − 2098
*/
+ − 2099
int QMenuBar::itemParameter(int id) const
+ − 2100
{
+ − 2101
if(QAction *act = findActionForId(id))
+ − 2102
return act->d_func()->param;
+ − 2103
return id;
+ − 2104
}
+ − 2105
+ − 2106
QAction *QMenuBar::findActionForId(int id) const
+ − 2107
{
+ − 2108
QList<QAction *> list = actions();
+ − 2109
for (int i = 0; i < list.size(); ++i) {
+ − 2110
QAction *act = list.at(i);
+ − 2111
if (findIdForAction(act) == id)
+ − 2112
return act;
+ − 2113
}
+ − 2114
return 0;
+ − 2115
}
+ − 2116
+ − 2117
int QMenuBar::findIdForAction(QAction *act) const
+ − 2118
{
+ − 2119
Q_ASSERT(act);
+ − 2120
return act->d_func()->id;
+ − 2121
}
+ − 2122
#endif
+ − 2123
+ − 2124
/*!
+ − 2125
\enum QMenuBar::Separator
+ − 2126
+ − 2127
\compat
+ − 2128
+ − 2129
\value Never
+ − 2130
\value InWindowsStyle
+ − 2131
+ − 2132
*/
+ − 2133
+ − 2134
/*!
+ − 2135
\fn void QMenuBar::addAction(QAction *action)
+ − 2136
\overload
+ − 2137
+ − 2138
Appends the action \a action to the menu bar's list of actions.
+ − 2139
+ − 2140
\sa QMenu::addAction(), QWidget::addAction(), QWidget::actions()
+ − 2141
*/
+ − 2142
+ − 2143
/*!
+ − 2144
\fn uint QMenuBar::count() const
+ − 2145
+ − 2146
Use actions().count() instead.
+ − 2147
*/
+ − 2148
+ − 2149
/*!
+ − 2150
\fn int QMenuBar::insertItem(const QString &text, const QObject *receiver, const char* member, const QKeySequence& shortcut, int id, int index)
+ − 2151
+ − 2152
Use one of the insertAction() or addAction() overloads instead.
+ − 2153
*/
+ − 2154
+ − 2155
/*!
+ − 2156
\fn int QMenuBar::insertItem(const QIcon& icon, const QString &text, const QObject *receiver, const char* member, const QKeySequence& shortcut, int id, int index)
+ − 2157
+ − 2158
Use one of the insertAction() or addAction() overloads instead.
+ − 2159
*/
+ − 2160
+ − 2161
/*!
+ − 2162
\fn int QMenuBar::insertItem(const QPixmap &pixmap, const QObject *receiver, const char* member, const QKeySequence& shortcut, int id, int index)
+ − 2163
+ − 2164
Use one of the insertAction(), addAction(), insertMenu(), or
+ − 2165
addMenu() overloads instead.
+ − 2166
*/
+ − 2167
+ − 2168
/*!
+ − 2169
\fn int QMenuBar::insertItem(const QString &text, int id, int index)
+ − 2170
+ − 2171
Use one of the insertAction() or addAction() overloads instead.
+ − 2172
*/
+ − 2173
+ − 2174
/*!
+ − 2175
\fn int QMenuBar::insertItem(const QIcon& icon, const QString &text, int id, int index)
+ − 2176
+ − 2177
Use one of the insertAction(), addAction(), insertMenu(), or
+ − 2178
addMenu() overloads instead.
+ − 2179
*/
+ − 2180
+ − 2181
/*!
+ − 2182
\fn int QMenuBar::insertItem(const QString &text, QMenu *popup, int id, int index)
+ − 2183
+ − 2184
Use one of the insertMenu(), or addMenu() overloads instead.
+ − 2185
*/
+ − 2186
+ − 2187
/*!
+ − 2188
\fn int QMenuBar::insertItem(const QIcon& icon, const QString &text, QMenu *popup, int id, int index)
+ − 2189
+ − 2190
Use one of the insertMenu(), or addMenu() overloads instead.
+ − 2191
*/
+ − 2192
+ − 2193
/*!
+ − 2194
\fn int QMenuBar::insertItem(const QPixmap &pixmap, int id, int index)
+ − 2195
+ − 2196
Use one of the insertAction(), addAction(), insertMenu(), or
+ − 2197
addMenu() overloads instead.
+ − 2198
*/
+ − 2199
+ − 2200
/*!
+ − 2201
\fn int QMenuBar::insertItem(const QPixmap &pixmap, QMenu *popup, int id, int index)
+ − 2202
+ − 2203
Use one of the insertMenu(), or addMenu() overloads instead.
+ − 2204
*/
+ − 2205
+ − 2206
/*!
+ − 2207
\fn void QMenuBar::removeItem(int id)
+ − 2208
+ − 2209
Use removeAction() instead.
+ − 2210
*/
+ − 2211
+ − 2212
/*!
+ − 2213
\fn void QMenuBar::removeItemAt(int index)
+ − 2214
+ − 2215
Use removeAction() instead.
+ − 2216
*/
+ − 2217
+ − 2218
/*!
+ − 2219
\fn QKeySequence QMenuBar::accel(int id) const
+ − 2220
+ − 2221
Use shortcut() on the relevant QAction instead.
+ − 2222
*/
+ − 2223
+ − 2224
/*!
+ − 2225
\fn void QMenuBar::setAccel(const QKeySequence& key, int id)
+ − 2226
+ − 2227
Use setShortcut() on the relevant QAction instead.
+ − 2228
*/
+ − 2229
+ − 2230
/*!
+ − 2231
\fn QIcon QMenuBar::iconSet(int id) const
+ − 2232
+ − 2233
Use icon() on the relevant QAction instead.
+ − 2234
*/
+ − 2235
+ − 2236
/*!
+ − 2237
\fn QString QMenuBar::text(int id) const
+ − 2238
+ − 2239
Use text() on the relevant QAction instead.
+ − 2240
*/
+ − 2241
+ − 2242
/*!
+ − 2243
\fn QPixmap QMenuBar::pixmap(int id) const
+ − 2244
+ − 2245
Use QPixmap(icon()) on the relevant QAction instead.
+ − 2246
*/
+ − 2247
+ − 2248
/*!
+ − 2249
\fn void QMenuBar::setWhatsThis(int id, const QString &w)
+ − 2250
+ − 2251
Use setWhatsThis() on the relevant QAction instead.
+ − 2252
*/
+ − 2253
+ − 2254
/*!
+ − 2255
\fn QString QMenuBar::whatsThis(int id) const
+ − 2256
+ − 2257
Use whatsThis() on the relevant QAction instead.
+ − 2258
*/
+ − 2259
+ − 2260
/*!
+ − 2261
\fn void QMenuBar::changeItem(int id, const QString &text)
+ − 2262
+ − 2263
Use setText() on the relevant QAction instead.
+ − 2264
*/
+ − 2265
+ − 2266
/*!
+ − 2267
\fn void QMenuBar::changeItem(int id, const QPixmap &pixmap)
+ − 2268
+ − 2269
Use setText() on the relevant QAction instead.
+ − 2270
*/
+ − 2271
+ − 2272
/*!
+ − 2273
\fn void QMenuBar::changeItem(int id, const QIcon &icon, const QString &text)
+ − 2274
+ − 2275
Use setIcon() and setText() on the relevant QAction instead.
+ − 2276
*/
+ − 2277
+ − 2278
/*!
+ − 2279
\fn bool QMenuBar::isItemActive(int id) const
+ − 2280
+ − 2281
Use activeAction() instead.
+ − 2282
*/
+ − 2283
+ − 2284
/*!
+ − 2285
\fn bool QMenuBar::isItemEnabled(int id) const
+ − 2286
+ − 2287
Use isEnabled() on the relevant QAction instead.
+ − 2288
*/
+ − 2289
+ − 2290
/*!
+ − 2291
\fn void QMenuBar::setItemEnabled(int id, bool enable)
+ − 2292
+ − 2293
Use setEnabled() on the relevant QAction instead.
+ − 2294
*/
+ − 2295
+ − 2296
/*!
+ − 2297
\fn bool QMenuBar::isItemChecked(int id) const
+ − 2298
+ − 2299
Use isChecked() on the relevant QAction instead.
+ − 2300
*/
+ − 2301
+ − 2302
/*!
+ − 2303
\fn void QMenuBar::setItemChecked(int id, bool check)
+ − 2304
+ − 2305
Use setChecked() on the relevant QAction instead.
+ − 2306
*/
+ − 2307
+ − 2308
/*!
+ − 2309
\fn bool QMenuBar::isItemVisible(int id) const
+ − 2310
+ − 2311
Use isVisible() on the relevant QAction instead.
+ − 2312
*/
+ − 2313
+ − 2314
/*!
+ − 2315
\fn void QMenuBar::setItemVisible(int id, bool visible)
+ − 2316
+ − 2317
Use setVisible() on the relevant QAction instead.
+ − 2318
*/
+ − 2319
+ − 2320
/*!
+ − 2321
\fn int QMenuBar::indexOf(int id) const
+ − 2322
+ − 2323
Use actions().indexOf(action) on the relevant QAction instead.
+ − 2324
*/
+ − 2325
+ − 2326
/*!
+ − 2327
\fn int QMenuBar::idAt(int index) const
+ − 2328
+ − 2329
Use actions instead.
+ − 2330
*/
+ − 2331
+ − 2332
/*!
+ − 2333
\fn void QMenuBar::activateItemAt(int index)
+ − 2334
+ − 2335
Use activate() on the relevant QAction instead.
+ − 2336
*/
+ − 2337
+ − 2338
/*!
+ − 2339
\fn bool QMenuBar::connectItem(int id, const QObject *receiver, const char* member)
+ − 2340
+ − 2341
Use connect() on the relevant QAction instead.
+ − 2342
*/
+ − 2343
+ − 2344
/*!
+ − 2345
\fn bool QMenuBar::disconnectItem(int id,const QObject *receiver, const char* member)
+ − 2346
+ − 2347
Use disconnect() on the relevant QAction instead.
+ − 2348
*/
+ − 2349
+ − 2350
/*!
+ − 2351
\fn QMenuItem *QMenuBar::findItem(int id) const
+ − 2352
+ − 2353
Use actions instead.
+ − 2354
*/
+ − 2355
+ − 2356
/*!
+ − 2357
\fn Separator QMenuBar::separator() const
+ − 2358
+ − 2359
This function is provided only to make old code compile.
+ − 2360
*/
+ − 2361
+ − 2362
/*!
+ − 2363
\fn void QMenuBar::setSeparator(Separator sep)
+ − 2364
+ − 2365
This function is provided only to make old code compile.
+ − 2366
*/
+ − 2367
+ − 2368
/*!
+ − 2369
\fn QRect QMenuBar::itemRect(int index)
+ − 2370
+ − 2371
Use actionGeometry() on the relevant QAction instead.
+ − 2372
*/
+ − 2373
+ − 2374
/*!
+ − 2375
\fn int QMenuBar::itemAtPos(const QPoint &p)
+ − 2376
+ − 2377
There is no equivalent way to achieve this in Qt 4.
+ − 2378
*/
+ − 2379
+ − 2380
/*!
+ − 2381
\fn void QMenuBar::activated(int itemId);
+ − 2382
+ − 2383
Use triggered() instead.
+ − 2384
*/
+ − 2385
+ − 2386
/*!
+ − 2387
\fn void QMenuBar::highlighted(int itemId);
+ − 2388
+ − 2389
Use hovered() instead.
+ − 2390
*/
+ − 2391
+ − 2392
/*!
+ − 2393
\fn void QMenuBar::setFrameRect(QRect)
+ − 2394
\internal
+ − 2395
*/
+ − 2396
+ − 2397
/*!
+ − 2398
\fn QRect QMenuBar::frameRect() const
+ − 2399
\internal
+ − 2400
*/
+ − 2401
/*!
+ − 2402
\enum QMenuBar::DummyFrame
+ − 2403
\internal
+ − 2404
+ − 2405
\value Box
+ − 2406
\value Sunken
+ − 2407
\value Plain
+ − 2408
\value Raised
+ − 2409
\value MShadow
+ − 2410
\value NoFrame
+ − 2411
\value Panel
+ − 2412
\value StyledPanel
+ − 2413
\value HLine
+ − 2414
\value VLine
+ − 2415
\value GroupBoxPanel
+ − 2416
\value WinPanel
+ − 2417
\value ToolBarPanel
+ − 2418
\value MenuBarPanel
+ − 2419
\value PopupPanel
+ − 2420
\value LineEditPanel
+ − 2421
\value TabWidgetPanel
+ − 2422
\value MShape
+ − 2423
*/
+ − 2424
+ − 2425
/*!
+ − 2426
\fn void QMenuBar::setFrameShadow(DummyFrame)
+ − 2427
\internal
+ − 2428
*/
+ − 2429
+ − 2430
/*!
+ − 2431
\fn DummyFrame QMenuBar::frameShadow() const
+ − 2432
\internal
+ − 2433
*/
+ − 2434
+ − 2435
/*!
+ − 2436
\fn void QMenuBar::setFrameShape(DummyFrame)
+ − 2437
\internal
+ − 2438
*/
+ − 2439
+ − 2440
/*!
+ − 2441
\fn DummyFrame QMenuBar::frameShape() const
+ − 2442
\internal
+ − 2443
*/
+ − 2444
+ − 2445
/*!
+ − 2446
\fn void QMenuBar::setFrameStyle(int)
+ − 2447
\internal
+ − 2448
*/
+ − 2449
+ − 2450
/*!
+ − 2451
\fn int QMenuBar::frameStyle() const
+ − 2452
\internal
+ − 2453
*/
+ − 2454
+ − 2455
/*!
+ − 2456
\fn void QMenuBar::setLineWidth(int)
+ − 2457
\internal
+ − 2458
*/
+ − 2459
+ − 2460
/*!
+ − 2461
\fn int QMenuBar::lineWidth() const
+ − 2462
\internal
+ − 2463
*/
+ − 2464
+ − 2465
/*!
+ − 2466
\fn void QMenuBar::setMargin(int margin)
+ − 2467
Sets the width of the margin around the contents of the widget to \a margin.
+ − 2468
+ − 2469
Use QWidget::setContentsMargins() instead.
+ − 2470
\sa margin(), QWidget::setContentsMargins()
+ − 2471
*/
+ − 2472
+ − 2473
/*!
+ − 2474
\fn int QMenuBar::margin() const
+ − 2475
Returns the width of the margin around the contents of the widget.
+ − 2476
+ − 2477
Use QWidget::getContentsMargins() instead.
+ − 2478
\sa setMargin(), QWidget::getContentsMargins()
+ − 2479
*/
+ − 2480
+ − 2481
/*!
+ − 2482
\fn void QMenuBar::setMidLineWidth(int)
+ − 2483
\internal
+ − 2484
*/
+ − 2485
+ − 2486
/*!
+ − 2487
\fn int QMenuBar::midLineWidth() const
+ − 2488
\internal
+ − 2489
*/
+ − 2490
+ − 2491
// for private slots
+ − 2492
+ − 2493
+ − 2494
QT_END_NAMESPACE
+ − 2495
+ − 2496
#include <moc_qmenubar.cpp>
+ − 2497
+ − 2498
#endif // QT_NO_MENUBAR