source: trunk/src/gui/widgets/qmenu_wince.cpp@ 728

Last change on this file since 728 was 651, checked in by Dmitry A. Kuminov, 15 years ago

trunk: Merged in qt 4.6.2 sources.
  • Property svn:eol-style set to native
File size: 21.9 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4** All rights reserved.
5** Contact: Nokia Corporation ([email protected])
6**
7** This file is part of the QtGui module of the Qt Toolkit.
8**
9** $QT_BEGIN_LICENSE:LGPL$
10** Commercial Usage
11** Licensees holding valid Qt Commercial licenses may use this file in
12** accordance with the Qt Commercial License Agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and Nokia.
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** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you have questions regarding the use of this file, please contact
37** Nokia at [email protected].
38** $QT_END_LICENSE$
39**
40****************************************************************************/
41
42//Native menubars are only supported for Windows Mobile not the standard SDK/generic WinCE
43#ifdef Q_WS_WINCE
44#include "qmenu.h"
45#include "qt_windows.h"
46#include "qapplication.h"
47#include "qmainwindow.h"
48#include "qtoolbar.h"
49#include "qevent.h"
50#include "qstyle.h"
51#include "qdebug.h"
52#include "qwidgetaction.h"
53#include <private/qapplication_p.h>
54#include <private/qmenu_p.h>
55#include <private/qmenubar_p.h>
56
57#include "qmenu_wince_resource_p.h"
58
59#include <QtCore/qlibrary.h>
60#include <commctrl.h>
61#if Q_OS_WINCE_WM
62# include <windowsm.h>
63#endif
64
65#include "qguifunctions_wince.h"
66
67#ifndef QT_NO_MENUBAR
68
69#ifndef SHCMBF_EMPTYBAR
70#define SHCMBF_EMPTYBAR 0x0001
71#endif
72
73#ifndef SHCMBM_GETSUBMENU
74#define SHCMBM_GETSUBMENU (WM_USER + 401)
75#endif
76
77#ifdef Q_OS_WINCE_WM
78# define SHMBOF_NODEFAULT 0x00000001
79# define SHMBOF_NOTIFY 0x00000002
80# define SHCMBM_OVERRIDEKEY (WM_USER + 0x193)
81#endif
82
83extern bool qt_wince_is_smartphone();//defined in qguifunctions_wce.cpp
84extern bool qt_wince_is_pocket_pc(); //defined in qguifunctions_wce.cpp
85
86QT_BEGIN_NAMESPACE
87
88static uint qt_wce_menu_static_cmd_id = 200;
89static QList<QMenuBar*> nativeMenuBars;
90
91struct qt_SHMENUBARINFO
92{
93 DWORD cbSize;
94 HWND hwndParent;
95 DWORD dwFlags;
96 UINT nToolBarId;
97 HINSTANCE hInstRes;
98 int nBmpId;
99 int cBmpImages;
100 HWND hwndMB;
101 COLORREF clrBk;
102};
103
104typedef int (WINAPI *superfunc)(int, int);
105typedef BOOL (WINAPI *AygCreateMenuBar)(qt_SHMENUBARINFO*);
106typedef HRESULT (WINAPI *AygEnableSoftKey)(HWND,UINT,BOOL,BOOL);
107
108static bool aygResolved = false;
109static AygCreateMenuBar ptrCreateMenuBar = 0;
110static AygEnableSoftKey ptrEnableSoftKey = 0;
111
112static void resolveAygLibs()
113{
114 if (!aygResolved) {
115 aygResolved = true;
116 QLibrary aygLib(QLatin1String("aygshell"));
117 if (!aygLib.load())
118 return;
119 ptrCreateMenuBar = (AygCreateMenuBar) aygLib.resolve("SHCreateMenuBar");
120 ptrEnableSoftKey = (AygEnableSoftKey) aygLib.resolve("SHEnableSoftkey");
121 }
122}
123
124static void qt_wce_enable_soft_key(HWND handle, uint command)
125{
126 resolveAygLibs();
127 if (ptrEnableSoftKey)
128 ptrEnableSoftKey(handle, command, false, true);
129}
130static void qt_wce_disable_soft_key(HWND handle, uint command)
131{
132 resolveAygLibs();
133 if (ptrEnableSoftKey)
134 ptrEnableSoftKey(handle, command, false, false);
135}
136
137static void qt_wce_delete_action_list(QList<QWceMenuAction*> *list) {
138 for(QList<QWceMenuAction*>::Iterator it = list->begin(); it != list->end(); ++it) {
139 QWceMenuAction *action = (*it);
140 delete action;
141 action = 0;
142 }
143 list->clear();
144}
145
146//search for first QuitRole in QMenuBar
147static QAction* qt_wce_get_quit_action(QList<QAction *> actionItems) {
148 QAction *returnAction = 0;
149 for (int i = 0; i < actionItems.size(); ++i) {
150 QAction *action = actionItems.at(i);
151 if (action->menuRole() == QAction::QuitRole)
152 returnAction = action;
153 else
154 if (action->menu())
155 returnAction = qt_wce_get_quit_action(action->menu()->actions());
156 if (returnAction)
157 return returnAction; //return first action found
158 }
159 return 0; //nothing found;
160}
161
162static QAction* qt_wce_get_quit_action(QList<QWceMenuAction*> actionItems) {
163 for (int i = 0; i < actionItems.size(); ++i) {
164 if (actionItems.at(i)->action->menuRole() == QAction::QuitRole)
165 return actionItems.at(i)->action;
166 else if (actionItems.at(i)->action->menu()) {
167 QAction *returnAction = qt_wce_get_quit_action(actionItems.at(i)->action->menu()->actions());
168 if (returnAction)
169 return returnAction;
170 }
171 }
172 return 0;
173}
174
175static HMODULE qt_wce_get_module_handle() {
176 HMODULE module = 0; //handle to resources
177 if (!(module = GetModuleHandle(L"QtGui4"))) //release dynamic
178 if (!(module = GetModuleHandle(L"QtGuid4"))) //debug dynamic
179 module = (HINSTANCE)qWinAppInst(); //static
180 Q_ASSERT_X(module, "qt_wce_get_module_handle()", "cannot get handle to module?");
181 return module;
182}
183
184static void qt_wce_change_command(HWND menuHandle, int item, int command) {
185TBBUTTONINFOA tbbi;
186 memset(&tbbi,0,sizeof(tbbi));
187 tbbi.cbSize = sizeof(tbbi);
188 tbbi.dwMask = TBIF_COMMAND;
189 tbbi.idCommand = command;
190 SendMessage(menuHandle, TB_SETBUTTONINFO, item, (LPARAM)&tbbi);
191}
192
193static void qt_wce_rename_menu_item(HWND menuHandle, int item, const QString &newText) {
194 TBBUTTONINFOA tbbi;
195 memset(&tbbi,0,sizeof(tbbi));
196 tbbi.cbSize = sizeof(tbbi);
197 tbbi.dwMask = TBIF_TEXT;
198 QString text = newText;
199 text.remove(QChar::fromLatin1('&'));
200 tbbi.pszText = (LPSTR) text.utf16();
201 SendMessage(menuHandle, TB_SETBUTTONINFO, item, (LPARAM)&tbbi);
202}
203
204static HWND qt_wce_create_menubar(HWND parentHandle, HINSTANCE resourceHandle, int toolbarID, int flags = 0) {
205 resolveAygLibs();
206
207 if (ptrCreateMenuBar) {
208 qt_SHMENUBARINFO mbi;
209 memset(&mbi, 0, sizeof(qt_SHMENUBARINFO));
210 mbi.cbSize = sizeof(qt_SHMENUBARINFO);
211 mbi.hwndParent = parentHandle;
212 mbi.hInstRes = resourceHandle;
213 mbi.dwFlags = flags;
214 mbi.nToolBarId = toolbarID;
215
216 if (ptrCreateMenuBar(&mbi)) {
217#ifdef Q_OS_WINCE_WM
218 // Tell the menu bar that we want to override hot key behaviour.
219 LPARAM lparam = MAKELPARAM(SHMBOF_NODEFAULT | SHMBOF_NOTIFY,
220 SHMBOF_NODEFAULT | SHMBOF_NOTIFY);
221 SendMessage(mbi.hwndMB, SHCMBM_OVERRIDEKEY, VK_TBACK, lparam);
222#endif
223 return mbi.hwndMB;
224 }
225 }
226 return 0;
227}
228
229static void qt_wce_insert_action(HMENU menu, QWceMenuAction *action, bool created) {
230
231 Q_ASSERT_X(menu, "AppendMenu", "menu is 0");
232 if (action->action->isVisible()) {
233 int flags;
234 action->action->isEnabled() ? flags = MF_ENABLED : flags = MF_GRAYED;
235
236 QString text = action->action->iconText();
237 text.remove(QChar::fromLatin1('&'));
238 if (action->action->isSeparator()) {
239 AppendMenu (menu, MF_SEPARATOR , 0, 0);
240 }
241 else if (action->action->menu()) {
242 text.remove(QChar::fromLatin1('&'));
243 AppendMenu (menu, MF_STRING | flags | MF_POPUP,
244 (UINT) action->action->menu()->wceMenu(created), reinterpret_cast<const wchar_t *> (text.utf16()));
245 }
246 else {
247 AppendMenu (menu, MF_STRING | flags, action->command, reinterpret_cast<const wchar_t *> (text.utf16()));
248 }
249 if (action->action->isCheckable())
250 if (action->action->isChecked())
251 CheckMenuItem(menu, action->command, MF_BYCOMMAND | MF_CHECKED);
252 else
253 CheckMenuItem(menu, action->command, MF_BYCOMMAND | MF_UNCHECKED);
254 }
255}
256
257/*!
258 \internal
259
260 This function refreshes the native Windows CE menu.
261*/
262
263void QMenuBar::wceRefresh() {
264 for (int i = 0; i < nativeMenuBars.size(); ++i)
265 nativeMenuBars.at(i)->d_func()->wceRefresh();
266}
267
268void QMenuBarPrivate::wceRefresh() {
269 DrawMenuBar(wce_menubar->menubarHandle);
270}
271
272/*!
273 \internal
274
275 This function sends native Windows CE commands to Qt menus.
276*/
277
278QAction* QMenu::wceCommands(uint command) {
279 Q_D(QMenu);
280 return d->wceCommands(command);
281}
282
283/*!
284 \internal
285
286 This function sends native Windows CE commands to Qt menu bars
287 and all their child menus.
288*/
289
290void QMenuBar::wceCommands(uint command, HWND) {
291 for (int i = 0; i < nativeMenuBars.size(); ++i)
292 nativeMenuBars.at(i)->d_func()->wceCommands(command);
293}
294
295bool QMenuBarPrivate::wceEmitSignals(QList<QWceMenuAction*> actions, uint command) {
296 QAction *foundAction = 0;
297 for (int i = 0; i < actions.size(); ++i) {
298 if (foundAction)
299 break;
300 QWceMenuAction *action = actions.at(i);
301 if (action->action->menu()) {
302 foundAction = action->action->menu()->wceCommands(command);
303 }
304 else if (action->command == command) {
305 emit q_func()->triggered(action->action);
306 action->action->activate(QAction::Trigger);
307 return true;
308 }
309 }
310 if (foundAction) {
311 emit q_func()->triggered(foundAction);
312 return true;
313 }
314 return false;
315}
316
317void QMenuBarPrivate::wceCommands(uint command) {
318 if (wceClassicMenu) {
319 for (int i = 0; i < wce_menubar->actionItemsClassic.size(); ++i)
320 wceEmitSignals(wce_menubar->actionItemsClassic.at(i), command);
321 } else {
322 if (wceEmitSignals(wce_menubar->actionItems, command)) {
323 return ;
324 }
325 else if (wce_menubar->leftButtonIsMenu) {//check if command is on the left quick button
326 wceEmitSignals(wce_menubar->actionItemsLeftButton, command);
327 }
328 else if ((wce_menubar->leftButtonAction) && (command == wce_menubar->leftButtonCommand)) {
329 emit q_func()->triggered(wce_menubar->leftButtonAction);
330 wce_menubar->leftButtonAction->activate(QAction::Trigger);
331 }
332 }
333}
334
335QAction *QMenuPrivate::wceCommands(uint command) {
336 QAction *foundAction = 0;
337 for (int i = 0; i < wce_menu->actionItems.size(); ++i) {
338 if (foundAction)
339 break;
340 QWceMenuAction *action = wce_menu->actionItems.at(i);
341 if (action->action->menu()) {
342 foundAction = action->action->menu()->d_func()->wceCommands(command);
343 }
344 else if (action->command == command) {
345 action->action->activate(QAction::Trigger);
346 return action->action;
347 }
348 }
349 if (foundAction)
350 emit q_func()->triggered(foundAction);
351 return foundAction;
352}
353
354void QMenuBarPrivate::wceCreateMenuBar(QWidget *parent) {
355
356 Q_Q(QMenuBar);
357 wce_menubar = new QWceMenuBarPrivate(this);
358
359 wce_menubar->parentWindowHandle = parent ? parent->winId() : q->winId();
360 wce_menubar->leftButtonAction = defaultAction;
361
362 wce_menubar->menubarHandle = qt_wce_create_menubar(wce_menubar->parentWindowHandle, (HINSTANCE)qWinAppInst(), 0, SHCMBF_EMPTYBAR);
363 Q_ASSERT_X(wce_menubar->menubarHandle, "wceCreateMenuBar", "cannot create empty menu bar");
364 DrawMenuBar(wce_menubar->menubarHandle);
365 nativeMenuBars.append(q);
366 wceClassicMenu = (!qt_wince_is_smartphone() && !qt_wince_is_pocket_pc());
367}
368
369void QMenuBarPrivate::wceDestroyMenuBar() {
370 Q_Q(QMenuBar);
371 int index = nativeMenuBars.indexOf(q);
372 nativeMenuBars.removeAt(index);
373 if (wce_menubar)
374 delete wce_menubar;
375 wce_menubar = 0;
376}
377
378QMenuBarPrivate::QWceMenuBarPrivate::QWceMenuBarPrivate(QMenuBarPrivate *menubar) :
379 menubarHandle(0), menuHandle(0),leftButtonMenuHandle(0) ,
380 leftButtonAction(0), leftButtonIsMenu(false), d(menubar) {
381}
382
383QMenuBarPrivate::QWceMenuBarPrivate::~QWceMenuBarPrivate() {
384 if (menubarHandle)
385 DestroyWindow(menubarHandle);
386 qt_wce_delete_action_list(&actionItems);
387 qt_wce_delete_action_list(&actionItemsLeftButton);
388
389 for (int i=0; i<actionItemsClassic.size(); ++i)
390 if (!actionItemsClassic.value(i).empty())
391 qt_wce_delete_action_list(&actionItemsClassic[i]);
392 actionItemsClassic.clear();
393
394 menubarHandle = 0;
395 menuHandle = 0;
396 leftButtonMenuHandle = 0;
397 leftButtonCommand = 0;
398 QMenuBar::wceRefresh();
399}
400
401QMenuPrivate::QWceMenuPrivate::QWceMenuPrivate() {
402 menuHandle = 0;
403}
404
405QMenuPrivate::QWceMenuPrivate::~QWceMenuPrivate() {
406 qt_wce_delete_action_list(&actionItems);
407 menuHandle = 0;
408}
409
410void QMenuPrivate::QWceMenuPrivate::addAction(QAction *a, QWceMenuAction *before) {
411 QWceMenuAction *action = new QWceMenuAction;
412 action->action = a;
413 action->command = qt_wce_menu_static_cmd_id++;
414 addAction(action, before);
415}
416
417void QMenuPrivate::QWceMenuPrivate::addAction(QWceMenuAction *action, QWceMenuAction *before) {
418 if (!action)
419 return;
420 int before_index = actionItems.indexOf(before);
421 if (before_index < 0) {
422 before = 0;
423 before_index = actionItems.size();
424 }
425 actionItems.insert(before_index, action);
426 rebuild();
427}
428
429/*!
430 \internal
431
432 This function will return the HMENU used to create the native
433 Windows CE menu bar bindings.
434*/
435
436HMENU QMenu::wceMenu(bool create) { return d_func()->wceMenu(create); }
437
438HMENU QMenuPrivate::wceMenu(bool create) {
439 if (!wce_menu)
440 wce_menu = new QWceMenuPrivate;
441 if (!wce_menu->menuHandle || create)
442 wce_menu->rebuild(create);
443 return wce_menu->menuHandle;
444}
445
446void QMenuPrivate::QWceMenuPrivate::rebuild(bool reCreate) {
447 if (menuHandle && !reCreate)
448 DestroyMenu(menuHandle);
449 menuHandle = CreatePopupMenu();
450 for (int i = 0; i < actionItems.size(); ++i) {
451 QWceMenuAction *action = actionItems.at(i);
452 action->menuHandle = menuHandle;
453 qt_wce_insert_action(menuHandle, action, true);
454 }
455 QMenuBar::wceRefresh();
456}
457
458void QMenuPrivate::QWceMenuPrivate::syncAction(QWceMenuAction *) {
459 rebuild();
460}
461
462void QMenuPrivate::QWceMenuPrivate::removeAction(QWceMenuAction *action) {
463 actionItems.removeAll(action);
464 delete action;
465 action = 0;
466 rebuild();
467}
468
469void QMenuBarPrivate::QWceMenuBarPrivate::addAction(QAction *a, QWceMenuAction *before) {
470 QWceMenuAction *action = new QWceMenuAction;
471 action->action = a;
472 action->command = qt_wce_menu_static_cmd_id++;
473 addAction(action, before);
474}
475
476void QMenuBarPrivate::QWceMenuBarPrivate::addAction(QWceMenuAction *action, QWceMenuAction *before) {
477 if (!action)
478 return;
479 int before_index = actionItems.indexOf(before);
480 if (before_index < 0) {
481 before = 0;
482 before_index = actionItems.size();
483 }
484 actionItems.insert(before_index, action);
485 rebuild();
486}
487
488void QMenuBarPrivate::QWceMenuBarPrivate::syncAction(QWceMenuAction*) {
489 QMenuBar::wceRefresh();
490 rebuild();
491}
492
493void QMenuBarPrivate::QWceMenuBarPrivate::removeAction(QWceMenuAction *action) {
494 actionItems.removeAll(action);
495 delete action;
496 action = 0;
497 rebuild();
498}
499
500void QMenuBarPrivate::_q_updateDefaultAction() {
501 if (wce_menubar)
502 wce_menubar->rebuild();
503}
504
505void QMenuBarPrivate::QWceMenuBarPrivate::rebuild() {
506
507 d->q_func()->resize(0,0);
508 parentWindowHandle = d->q_func()->parentWidget() ? d->q_func()->parentWidget()->winId() : d->q_func()->winId();
509 if (d->wceClassicMenu) {
510 QList<QAction*> actions = d->actions;
511 int maxEntries;
512 int resourceHandle;
513 if (actions.size() < 5) {
514 maxEntries = 4;
515 resourceHandle = IDR_MAIN_MENU3;
516 } else if (actions.size() < 7) {
517 maxEntries = 6;
518 resourceHandle = IDR_MAIN_MENU4;
519 }
520 else {
521 maxEntries = 8;
522 resourceHandle = IDR_MAIN_MENU5;
523 }
524 Q_ASSERT_X(menubarHandle, "rebuild !created", "menubar already deleted");
525 DestroyWindow(menubarHandle);
526 menubarHandle = qt_wce_create_menubar(parentWindowHandle, qt_wce_get_module_handle(), resourceHandle);
527 Q_ASSERT_X(menubarHandle, "rebuild classic menu", "cannot create menubar from resource");
528 DrawMenuBar(menubarHandle);
529 QList<int> menu_ids;
530 QList<int> item_ids;
531 menu_ids << IDM_MENU1 << IDM_MENU2 << IDM_MENU3 << IDM_MENU4 << IDM_MENU5 << IDM_MENU6 << IDM_MENU7 << IDM_MENU8;
532 item_ids << IDM_ITEM1 << IDM_ITEM2 << IDM_ITEM3 << IDM_ITEM4 << IDM_ITEM5 << IDM_ITEM6 << IDM_ITEM7 << IDM_ITEM8;
533
534 for (int i = 0; i < actionItemsClassic.size(); ++i)
535 if (!actionItemsClassic.value(i).empty())
536 qt_wce_delete_action_list(&actionItemsClassic[i]);
537 actionItemsClassic.clear();
538
539 for (int i = 0; i < actions.size(); ++i) {
540 qt_wce_rename_menu_item(menubarHandle, menu_ids.at(i), actions.at(i)->text());
541 QList<QAction *> subActions = actions.at(i)->menu()->actions();
542 HMENU subMenuHandle = (HMENU) SendMessage(menubarHandle, SHCMBM_GETSUBMENU,0 , menu_ids.at(i));
543 DeleteMenu(subMenuHandle, item_ids.at(i), MF_BYCOMMAND);
544 for (int c = 0; c < subActions.size(); ++c) {
545 QList<QWceMenuAction*> list;
546 actionItemsClassic.append(list);
547 QWceMenuAction *action = new QWceMenuAction;
548 action->action = subActions.at(c);
549 action->command = qt_wce_menu_static_cmd_id++;
550 action->menuHandle = subMenuHandle;
551 actionItemsClassic.last().append(action);
552 qt_wce_insert_action(subMenuHandle, action, true);
553 }
554 }
555 for (int i = actions.size();i<maxEntries;++i) {
556 qt_wce_rename_menu_item(menubarHandle, menu_ids.at(i), QString());
557 qt_wce_disable_soft_key(menubarHandle, menu_ids.at(i));
558 }
559 } else {
560 leftButtonAction = d->defaultAction;
561 if (!leftButtonAction)
562 leftButtonAction = qt_wce_get_quit_action(actionItems);
563
564 leftButtonIsMenu = (leftButtonAction && leftButtonAction->menu());
565 Q_ASSERT_X(menubarHandle, "rebuild !created", "menubar already deleted");
566 DestroyWindow(menubarHandle);
567 if (leftButtonIsMenu) {
568 menubarHandle = qt_wce_create_menubar(parentWindowHandle, qt_wce_get_module_handle(), IDR_MAIN_MENU2);
569 Q_ASSERT_X(menubarHandle, "rebuild !created left menubar", "cannot create menubar from resource");
570 menuHandle = (HMENU) SendMessage(menubarHandle, SHCMBM_GETSUBMENU,0,IDM_MENU);
571 Q_ASSERT_X(menuHandle, "rebuild !created", "IDM_MENU not found - invalid resource?");
572 DeleteMenu(menuHandle, IDM_ABOUT, MF_BYCOMMAND);
573 leftButtonMenuHandle = (HMENU) SendMessage(menubarHandle, SHCMBM_GETSUBMENU,0,IDM_LEFTMENU);
574 Q_ASSERT_X(leftButtonMenuHandle, "rebuild !created", "IDM_LEFTMENU not found - invalid resource?");
575 DeleteMenu(leftButtonMenuHandle, IDM_VIEW, MF_BYCOMMAND);
576 } else {
577 menubarHandle = qt_wce_create_menubar(parentWindowHandle, qt_wce_get_module_handle(), IDR_MAIN_MENU);
578 Q_ASSERT_X(menubarHandle, "rebuild !created no left menubar", "cannot create menubar from resource");
579 menuHandle = (HMENU) SendMessage(menubarHandle, SHCMBM_GETSUBMENU,0,IDM_MENU);
580 Q_ASSERT_X(menuHandle, "rebuild !created", "IDM_MENU not found - invalid resource?");
581 DeleteMenu(menuHandle, IDM_ABOUT, MF_BYCOMMAND);
582 leftButtonMenuHandle = 0;
583 leftButtonCommand = qt_wce_menu_static_cmd_id++;
584 qt_wce_change_command(menubarHandle, IDM_EXIT, leftButtonCommand);
585 }
586
587 if (actionItems.size() == 0) {
588 qt_wce_rename_menu_item(menubarHandle, IDM_MENU, QLatin1String(""));
589 qt_wce_disable_soft_key(menubarHandle, IDM_MENU);
590 }
591 for (int i = 0; i < actionItems.size(); ++i) {
592 QWceMenuAction *action = actionItems.at(i);
593 action->menuHandle = menuHandle;
594 qt_wce_insert_action(menuHandle, action, true);
595 }
596 if (!leftButtonIsMenu) {
597 if (leftButtonAction) {
598 qt_wce_rename_menu_item(menubarHandle, leftButtonCommand, leftButtonAction->text());
599 qt_wce_enable_soft_key(menubarHandle, leftButtonCommand);
600 } else {
601 qt_wce_rename_menu_item(menubarHandle, leftButtonCommand, QLatin1String(""));
602 qt_wce_disable_soft_key(menubarHandle, leftButtonCommand);
603 }
604 } else {
605 qt_wce_rename_menu_item(menubarHandle, IDM_LEFTMENU, leftButtonAction->text());
606 QList<QAction *> actions = leftButtonAction->menu()->actions();
607 qt_wce_delete_action_list(&actionItemsLeftButton);
608 for (int i=0; i<actions.size(); ++i) {
609 QWceMenuAction *action = new QWceMenuAction;
610 action->action = actions.at(i);
611 action->command = qt_wce_menu_static_cmd_id++;
612 action->menuHandle = leftButtonMenuHandle;
613 actionItemsLeftButton.append(action);
614 qt_wce_insert_action(leftButtonMenuHandle, action, true);
615 }
616 }
617 }
618 DrawMenuBar(menubarHandle);
619}
620
621QT_END_NAMESPACE
622
623#endif //QT_NO_MENUBAR
624#endif //Q_WS_WINCE
Note: See TracBrowser for help on using the repository browser.