]> git.saurik.com Git - wxWidgets.git/blob - src/msw/menu.cpp
projects / wxWidgets.git / blob
? search:


4157d86fb0d7cd0bc752875126aeddf816e8c104
[wxWidgets.git] / src / msw / menu.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/menu.cpp
3 // Purpose: wxMenu, wxMenuBar, wxMenuItem
4 // Author: Julian Smart
5 // Modified by: Vadim Zeitlin
6 // Created: 04/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ===========================================================================
13 // declarations
14 // ===========================================================================
15
16 // ---------------------------------------------------------------------------
17 // headers
18 // ---------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #if wxUSE_MENUS
28
29 #ifndef WX_PRECOMP
30 #include "wx/frame.h"
31 #include "wx/menu.h"
32 #include "wx/utils.h"
33 #include "wx/intl.h"
34 #include "wx/log.h"
35 #endif
36
37 #if wxUSE_OWNER_DRAWN
38 #include "wx/ownerdrw.h"
39 #endif
40
41 #include "wx/msw/private.h"
42
43 #ifdef __WXWINCE__
44 #include <windows.h>
45 #include <windowsx.h>
46 #include <tchar.h>
47 #include <ole2.h>
48 #include <shellapi.h>
49 #include <commctrl.h>
50 #if (_WIN32_WCE < 400) && !defined(__HANDHELDPC__)
51 #include <aygshell.h>
52 #endif
53
54 #include "wx/msw/wince/missing.h"
55
56 #endif
57
58 // other standard headers
59 #include <string.h>
60
61 #if wxUSE_OWNER_DRAWN && defined(MIIM_BITMAP)
62 #include "wx/dynlib.h"
63 #endif
64
65 #ifndef MNS_CHECKORBMP
66 #define MNS_CHECKORBMP 0x04000000
67 #endif
68 #ifndef MIM_STYLE
69 #define MIM_STYLE 0x00000010
70 #endif
71
72 // ----------------------------------------------------------------------------
73 // global variables
74 // ----------------------------------------------------------------------------
75
76 // ----------------------------------------------------------------------------
77 // constants
78 // ----------------------------------------------------------------------------
79
80 // the (popup) menu title has this special id
81 static const int idMenuTitle = -3;
82
83 // ----------------------------------------------------------------------------
84 // private functions
85 // ----------------------------------------------------------------------------
86
87 // make the given menu item default
88 static void SetDefaultMenuItem(HMENU WXUNUSED_IN_WINCE(hmenu),
89 UINT WXUNUSED_IN_WINCE(id))
90 {
91 #ifndef __WXWINCE__
92 MENUITEMINFO mii;
93 wxZeroMemory(mii);
94 mii.cbSize = sizeof(MENUITEMINFO);
95 mii.fMask = MIIM_STATE;
96 mii.fState = MFS_DEFAULT;
97
98 if ( !::SetMenuItemInfo(hmenu, id, FALSE, &mii) )
99 {
100 wxLogLastError(wxT("SetMenuItemInfo"));
101 }
102 #endif
103 }
104
105 #ifdef __WXWINCE__
106 UINT GetMenuState(HMENU hMenu, UINT id, UINT flags)
107 {
108 MENUITEMINFO info;
109 wxZeroMemory(info);
110 info.cbSize = sizeof(info);
111 info.fMask = MIIM_STATE;
112 // MF_BYCOMMAND is zero so test MF_BYPOSITION
113 if ( !::GetMenuItemInfo(hMenu, id, flags & MF_BYPOSITION ? TRUE : FALSE , & info) )
114 wxLogLastError(wxT("GetMenuItemInfo"));
115 return info.fState;
116 }
117 #endif
118
119 // ============================================================================
120 // implementation
121 // ============================================================================
122
123 #include "wx/listimpl.cpp"
124
125 WX_DEFINE_LIST( wxMenuInfoList )
126
127 #if wxUSE_EXTENDED_RTTI
128
129 WX_DEFINE_FLAGS( wxMenuStyle )
130
131 wxBEGIN_FLAGS( wxMenuStyle )
132 wxFLAGS_MEMBER(wxMENU_TEAROFF)
133 wxEND_FLAGS( wxMenuStyle )
134
135 IMPLEMENT_DYNAMIC_CLASS_XTI(wxMenu, wxEvtHandler,"wx/menu.h")
136
137 wxCOLLECTION_TYPE_INFO( wxMenuItem * , wxMenuItemList ) ;
138
139 template<> void wxCollectionToVariantArray( wxMenuItemList const &theList, wxxVariantArray &value)
140 {
141 wxListCollectionToVariantArray<wxMenuItemList::compatibility_iterator>( theList , value ) ;
142 }
143
144 wxBEGIN_PROPERTIES_TABLE(wxMenu)
145 wxEVENT_PROPERTY( Select , wxEVT_COMMAND_MENU_SELECTED , wxCommandEvent)
146 wxPROPERTY( Title, wxString , SetTitle, GetTitle, wxString(), 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
147 wxREADONLY_PROPERTY_FLAGS( MenuStyle , wxMenuStyle , long , GetStyle , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
148 wxPROPERTY_COLLECTION( MenuItems , wxMenuItemList , wxMenuItem* , Append , GetMenuItems , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
149 wxEND_PROPERTIES_TABLE()
150
151 wxBEGIN_HANDLERS_TABLE(wxMenu)
152 wxEND_HANDLERS_TABLE()
153
154 wxDIRECT_CONSTRUCTOR_2( wxMenu , wxString , Title , long , MenuStyle )
155
156 WX_DEFINE_FLAGS( wxMenuBarStyle )
157
158 wxBEGIN_FLAGS( wxMenuBarStyle )
159 wxFLAGS_MEMBER(wxMB_DOCKABLE)
160 wxEND_FLAGS( wxMenuBarStyle )
161
162 // the negative id would lead the window (its superclass !) to vetoe streaming out otherwise
163 bool wxMenuBarStreamingCallback( const wxObject *WXUNUSED(object), wxWriter * , wxPersister * , wxxVariantArray & )
164 {
165 return true ;
166 }
167
168 IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxMenuBar, wxWindow ,"wx/menu.h",wxMenuBarStreamingCallback)
169
170 IMPLEMENT_DYNAMIC_CLASS_XTI(wxMenuInfo, wxObject , "wx/menu.h" )
171
172 wxBEGIN_PROPERTIES_TABLE(wxMenuInfo)
173 wxREADONLY_PROPERTY( Menu , wxMenu* , GetMenu , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
174 wxREADONLY_PROPERTY( Title , wxString , GetTitle , wxString() , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
175 wxEND_PROPERTIES_TABLE()
176
177 wxBEGIN_HANDLERS_TABLE(wxMenuInfo)
178 wxEND_HANDLERS_TABLE()
179
180 wxCONSTRUCTOR_2( wxMenuInfo , wxMenu* , Menu , wxString , Title )
181
182 wxCOLLECTION_TYPE_INFO( wxMenuInfo * , wxMenuInfoList ) ;
183
184 template<> void wxCollectionToVariantArray( wxMenuInfoList const &theList, wxxVariantArray &value)
185 {
186 wxListCollectionToVariantArray<wxMenuInfoList::compatibility_iterator>( theList , value ) ;
187 }
188
189 wxBEGIN_PROPERTIES_TABLE(wxMenuBar)
190 wxPROPERTY_COLLECTION( MenuInfos , wxMenuInfoList , wxMenuInfo* , Append , GetMenuInfos , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
191 wxEND_PROPERTIES_TABLE()
192
193 wxBEGIN_HANDLERS_TABLE(wxMenuBar)
194 wxEND_HANDLERS_TABLE()
195
196 wxCONSTRUCTOR_DUMMY( wxMenuBar )
197
198 #else
199 IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
200 IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxWindow)
201 IMPLEMENT_DYNAMIC_CLASS(wxMenuInfo, wxObject)
202 #endif
203
204 const wxMenuInfoList& wxMenuBar::GetMenuInfos() const
205 {
206 wxMenuInfoList* list = const_cast< wxMenuInfoList* >( &m_menuInfos ) ;
207 WX_CLEAR_LIST( wxMenuInfoList , *list ) ;
208 for( size_t i = 0 ; i < GetMenuCount() ; ++i )
209 {
210 wxMenuInfo* info = new wxMenuInfo() ;
211 info->Create( const_cast<wxMenuBar*>(this)->GetMenu(i) , GetLabelTop(i) ) ;
212 list->Append( info ) ;
213 }
214 return m_menuInfos ;
215 }
216
217 // ---------------------------------------------------------------------------
218 // wxMenu construction, adding and removing menu items
219 // ---------------------------------------------------------------------------
220
221 // Construct a menu with optional title (then use append)
222 void wxMenu::Init()
223 {
224 m_doBreak = false;
225 m_startRadioGroup = -1;
226
227 // create the menu
228 m_hMenu = (WXHMENU)CreatePopupMenu();
229 if ( !m_hMenu )
230 {
231 wxLogLastError(wxT("CreatePopupMenu"));
232 }
233
234 // if we have a title, insert it in the beginning of the menu
235 if ( !m_title.empty() )
236 {
237 Append(idMenuTitle, m_title);
238 AppendSeparator();
239 }
240 }
241
242 // The wxWindow destructor will take care of deleting the submenus.
243 wxMenu::~wxMenu()
244 {
245 // we should free Windows resources only if Windows doesn't do it for us
246 // which happens if we're attached to a menubar or a submenu of another
247 // menu
248 if ( !IsAttached() && !GetParent() )
249 {
250 if ( !::DestroyMenu(GetHmenu()) )
251 {
252 wxLogLastError(wxT("DestroyMenu"));
253 }
254 }
255
256 #if wxUSE_ACCEL
257 // delete accels
258 WX_CLEAR_ARRAY(m_accels);
259 #endif // wxUSE_ACCEL
260 }
261
262 void wxMenu::Break()
263 {
264 // this will take effect during the next call to Append()
265 m_doBreak = true;
266 }
267
268 void wxMenu::Attach(wxMenuBarBase *menubar)
269 {
270 wxMenuBase::Attach(menubar);
271
272 EndRadioGroup();
273 }
274
275 #if wxUSE_ACCEL
276
277 int wxMenu::FindAccel(int id) const
278 {
279 size_t n, count = m_accels.GetCount();
280 for ( n = 0; n < count; n++ )
281 {
282 if ( m_accels[n]->m_command == id )
283 return n;
284 }
285
286 return wxNOT_FOUND;
287 }
288
289 void wxMenu::UpdateAccel(wxMenuItem *item)
290 {
291 if ( item->IsSubMenu() )
292 {
293 wxMenu *submenu = item->GetSubMenu();
294 wxMenuItemList::compatibility_iterator node = submenu->GetMenuItems().GetFirst();
295 while ( node )
296 {
297 UpdateAccel(node->GetData());
298
299 node = node->GetNext();
300 }
301 }
302 else if ( !item->IsSeparator() )
303 {
304 // recurse upwards: we should only modify m_accels of the top level
305 // menus, not of the submenus as wxMenuBar doesn't look at them
306 // (alternative and arguable cleaner solution would be to recurse
307 // downwards in GetAccelCount() and CopyAccels())
308 if ( GetParent() )
309 {
310 GetParent()->UpdateAccel(item);
311 return;
312 }
313
314 // find the (new) accel for this item
315 wxAcceleratorEntry *accel = wxGetAccelFromString(item->GetText());
316 if ( accel )
317 accel->m_command = item->GetId();
318
319 // find the old one
320 int n = FindAccel(item->GetId());
321 if ( n == wxNOT_FOUND )
322 {
323 // no old, add new if any
324 if ( accel )
325 m_accels.Add(accel);
326 else
327 return; // skipping RebuildAccelTable() below
328 }
329 else
330 {
331 // replace old with new or just remove the old one if no new
332 delete m_accels[n];
333 if ( accel )
334 m_accels[n] = accel;
335 else
336 m_accels.RemoveAt(n);
337 }
338
339 if ( IsAttached() )
340 {
341 GetMenuBar()->RebuildAccelTable();
342 }
343 }
344 //else: it is a separator, they can't have accels, nothing to do
345 }
346
347 #endif // wxUSE_ACCEL
348
349 // append a new item or submenu to the menu
350 bool wxMenu::DoInsertOrAppend(wxMenuItem *pItem, size_t pos)
351 {
352 #if wxUSE_ACCEL
353 UpdateAccel(pItem);
354 #endif // wxUSE_ACCEL
355
356 UINT flags = 0;
357
358 // if "Break" has just been called, insert a menu break before this item
359 // (and don't forget to reset the flag)
360 if ( m_doBreak ) {
361 flags |= MF_MENUBREAK;
362 m_doBreak = false;
363 }
364
365 if ( pItem->IsSeparator() ) {
366 flags |= MF_SEPARATOR;
367 }
368
369 // id is the numeric id for normal menu items and HMENU for submenus as
370 // required by ::AppendMenu() API
371 UINT id;
372 wxMenu *submenu = pItem->GetSubMenu();
373 if ( submenu != NULL ) {
374 wxASSERT_MSG( submenu->GetHMenu(), wxT("invalid submenu") );
375
376 submenu->SetParent(this);
377
378 id = (UINT)submenu->GetHMenu();
379
380 flags |= MF_POPUP;
381 }
382 else {
383 id = pItem->GetId();
384 }
385
386
387 // prepare to insert the item in the menu
388 wxString itemText = pItem->GetText();
389 LPCTSTR pData = NULL;
390 if ( pos == (size_t)-1 )
391 {
392 // append at the end (note that the item is already appended to
393 // internal data structures)
394 pos = GetMenuItemCount() - 1;
395 }
396
397 // adjust position to account for the title, if any
398 if ( !m_title.empty() )
399 pos += 2; // for the title itself and its separator
400
401 BOOL ok = false;
402
403 // check if we have something more than a simple text item
404 #if wxUSE_OWNER_DRAWN
405 if ( pItem->IsOwnerDrawn() )
406 {
407 // is the item owner-drawn just because of the bitmap?
408 if ( pItem->GetBitmap().Ok() &&
409 !pItem->GetTextColour().Ok() &&
410 !pItem->GetBackgroundColour().Ok() &&
411 !pItem->GetFont().Ok() &&
412 !pItem->GetBitmap(true).Ok() )
413 {
414 // try to use InsertMenuItem() as it's guaranteed to look correctly
415 // while our owner-drawning code is not
416
417 // first compile-time check
418 #ifdef MIIM_BITMAP
419 WinStruct<MENUITEMINFO> mii;
420
421 // now run-time one: MIIM_BITMAP only works under WinME/2000+
422 if ( wxGetWinVersion() >= wxWinVersion_98 )
423 {
424 mii.fMask = MIIM_STRING | MIIM_DATA | MIIM_BITMAP;
425 mii.cch = itemText.length();
426 mii.dwTypeData = wx_const_cast(wxChar *, itemText.c_str());
427
428 if (flags & MF_POPUP)
429 {
430 mii.fMask |= MIIM_SUBMENU;
431 mii.hSubMenu = (HMENU)pItem->GetSubMenu()->GetHMenu();
432 }
433 else
434 {
435 mii.fMask |= MIIM_ID;
436 mii.wID = id;
437 }
438
439 // we can't pass HBITMAP directly as hbmpItem for 2 reasons:
440 // 1. we can't draw it with transparency then (this is not
441 // very important now but would be with themed menu bg)
442 // 2. worse, Windows inverses the bitmap for the selected
443 // item and this looks downright ugly
444 //
445 // so instead draw it ourselves in MSWOnDrawItem()
446 mii.dwItemData = wx_reinterpret_cast(ULONG_PTR, pItem);
447 mii.hbmpItem = HBMMENU_CALLBACK;
448
449 ok = ::InsertMenuItem(GetHmenu(), pos, TRUE /* by pos */, &mii);
450 if ( !ok )
451 {
452 wxLogLastError(wxT("InsertMenuItem()"));
453 }
454 else // InsertMenuItem() ok
455 {
456 // we need to remove the extra indent which is reserved for
457 // the checkboxes by default as it looks ugly unless check
458 // boxes are used together with bitmaps and this is not the
459 // case in wx API
460 WinStruct<MENUINFO> mi;
461
462 // don't call SetMenuInfo() directly, this would prevent
463 // the app from starting up under Windows 95/NT 4
464 typedef BOOL (WINAPI *SetMenuInfo_t)(HMENU, MENUINFO *);
465
466 wxDynamicLibrary dllUser(_T("user32"));
467 wxDYNLIB_FUNCTION(SetMenuInfo_t, SetMenuInfo, dllUser);
468 if ( pfnSetMenuInfo )
469 {
470 mi.fMask = MIM_STYLE;
471 mi.dwStyle = MNS_CHECKORBMP;
472 if ( !(*pfnSetMenuInfo)(GetHmenu(), &mi) )
473 wxLogLastError(_T("SetMenuInfo(MNS_NOCHECK)"));
474 }
475
476 // tell the item that it's not really owner-drawn but only
477 // needs to draw its bitmap, the rest is done by Windows
478 pItem->ResetOwnerDrawn();
479 }
480 }
481 #endif // MIIM_BITMAP
482 }
483
484 if ( !ok )
485 {
486 // item draws itself, pass pointer to it in data parameter
487 flags |= MF_OWNERDRAW;
488 pData = (LPCTSTR)pItem;
489 }
490 }
491 else
492 #endif // wxUSE_OWNER_DRAWN
493 {
494 // menu is just a normal string (passed in data parameter)
495 flags |= MF_STRING;
496
497 #ifdef __WXWINCE__
498 itemText = wxMenuItem::GetLabelFromText(itemText);
499 #endif
500
501 pData = (wxChar*)itemText.c_str();
502 }
503
504 // item might have been already inserted by InsertMenuItem() above
505 if ( !ok )
506 {
507 if ( !::InsertMenu(GetHmenu(), pos, flags | MF_BYPOSITION, id, pData) )
508 {
509 wxLogLastError(wxT("InsertMenu[Item]()"));
510
511 return false;
512 }
513 }
514
515
516 // if we just appended the title, highlight it
517 if ( (int)id == idMenuTitle )
518 {
519 // visually select the menu title
520 SetDefaultMenuItem(GetHmenu(), id);
521 }
522
523 // if we're already attached to the menubar, we must update it
524 if ( IsAttached() && GetMenuBar()->IsAttached() )
525 {
526 GetMenuBar()->Refresh();
527 }
528
529 return true;
530 }
531
532 void wxMenu::EndRadioGroup()
533 {
534 // we're not inside a radio group any longer
535 m_startRadioGroup = -1;
536 }
537
538 wxMenuItem* wxMenu::DoAppend(wxMenuItem *item)
539 {
540 wxCHECK_MSG( item, NULL, _T("NULL item in wxMenu::DoAppend") );
541
542 bool check = false;
543
544 if ( item->GetKind() == wxITEM_RADIO )
545 {
546 int count = GetMenuItemCount();
547
548 if ( m_startRadioGroup == -1 )
549 {
550 // start a new radio group
551 m_startRadioGroup = count;
552
553 // for now it has just one element
554 item->SetAsRadioGroupStart();
555 item->SetRadioGroupEnd(m_startRadioGroup);
556
557 // ensure that we have a checked item in the radio group
558 check = true;
559 }
560 else // extend the current radio group
561 {
562 // we need to update its end item
563 item->SetRadioGroupStart(m_startRadioGroup);
564 wxMenuItemList::compatibility_iterator node = GetMenuItems().Item(m_startRadioGroup);
565
566 if ( node )
567 {
568 node->GetData()->SetRadioGroupEnd(count);
569 }
570 else
571 {
572 wxFAIL_MSG( _T("where is the radio group start item?") );
573 }
574 }
575 }
576 else // not a radio item
577 {
578 EndRadioGroup();
579 }
580
581 if ( !wxMenuBase::DoAppend(item) || !DoInsertOrAppend(item) )
582 {
583 return NULL;
584 }
585
586 if ( check )
587 {
588 // check the item initially
589 item->Check(true);
590 }
591
592 return item;
593 }
594
595 wxMenuItem* wxMenu::DoInsert(size_t pos, wxMenuItem *item)
596 {
597 if (wxMenuBase::DoInsert(pos, item) && DoInsertOrAppend(item, pos))
598 return item;
599 else
600 return NULL;
601 }
602
603 wxMenuItem *wxMenu::DoRemove(wxMenuItem *item)
604 {
605 // we need to find the items position in the child list
606 size_t pos;
607 wxMenuItemList::compatibility_iterator node = GetMenuItems().GetFirst();
608 for ( pos = 0; node; pos++ )
609 {
610 if ( node->GetData() == item )
611 break;
612
613 node = node->GetNext();
614 }
615
616 // DoRemove() (unlike Remove) can only be called for existing item!
617 wxCHECK_MSG( node, NULL, wxT("bug in wxMenu::Remove logic") );
618
619 #if wxUSE_ACCEL
620 // remove the corresponding accel from the accel table
621 int n = FindAccel(item->GetId());
622 if ( n != wxNOT_FOUND )
623 {
624 delete m_accels[n];
625
626 m_accels.RemoveAt(n);
627 }
628 //else: this item doesn't have an accel, nothing to do
629 #endif // wxUSE_ACCEL
630
631 // remove the item from the menu
632 if ( !::RemoveMenu(GetHmenu(), (UINT)pos, MF_BYPOSITION) )
633 {
634 wxLogLastError(wxT("RemoveMenu"));
635 }
636
637 if ( IsAttached() && GetMenuBar()->IsAttached() )
638 {
639 // otherwise, the chane won't be visible
640 GetMenuBar()->Refresh();
641 }
642
643 // and from internal data structures
644 return wxMenuBase::DoRemove(item);
645 }
646
647 // ---------------------------------------------------------------------------
648 // accelerator helpers
649 // ---------------------------------------------------------------------------
650
651 #if wxUSE_ACCEL
652
653 // create the wxAcceleratorEntries for our accels and put them into provided
654 // array - return the number of accels we have
655 size_t wxMenu::CopyAccels(wxAcceleratorEntry *accels) const
656 {
657 size_t count = GetAccelCount();
658 for ( size_t n = 0; n < count; n++ )
659 {
660 *accels++ = *m_accels[n];
661 }
662
663 return count;
664 }
665
666 #endif // wxUSE_ACCEL
667
668 // ---------------------------------------------------------------------------
669 // set wxMenu title
670 // ---------------------------------------------------------------------------
671
672 void wxMenu::SetTitle(const wxString& label)
673 {
674 bool hasNoTitle = m_title.empty();
675 m_title = label;
676
677 HMENU hMenu = GetHmenu();
678
679 if ( hasNoTitle )
680 {
681 if ( !label.empty() )
682 {
683 if ( !::InsertMenu(hMenu, 0u, MF_BYPOSITION | MF_STRING,
684 (unsigned)idMenuTitle, m_title) ||
685 !::InsertMenu(hMenu, 1u, MF_BYPOSITION, (unsigned)-1, NULL) )
686 {
687 wxLogLastError(wxT("InsertMenu"));
688 }
689 }
690 }
691 else
692 {
693 if ( label.empty() )
694 {
695 // remove the title and the separator after it
696 if ( !RemoveMenu(hMenu, 0, MF_BYPOSITION) ||
697 !RemoveMenu(hMenu, 0, MF_BYPOSITION) )
698 {
699 wxLogLastError(wxT("RemoveMenu"));
700 }
701 }
702 else
703 {
704 // modify the title
705 #ifdef __WXWINCE__
706 MENUITEMINFO info;
707 wxZeroMemory(info);
708 info.cbSize = sizeof(info);
709 info.fMask = MIIM_TYPE;
710 info.fType = MFT_STRING;
711 info.cch = m_title.length();
712 info.dwTypeData = (LPTSTR) m_title.c_str();
713 if ( !SetMenuItemInfo(hMenu, 0, TRUE, & info) )
714 {
715 wxLogLastError(wxT("SetMenuItemInfo"));
716 }
717 #else
718 if ( !ModifyMenu(hMenu, 0u,
719 MF_BYPOSITION | MF_STRING,
720 (unsigned)idMenuTitle, m_title) )
721 {
722 wxLogLastError(wxT("ModifyMenu"));
723 }
724 #endif
725 }
726 }
727
728 #ifdef __WIN32__
729 // put the title string in bold face
730 if ( !m_title.empty() )
731 {
732 SetDefaultMenuItem(GetHmenu(), (UINT)idMenuTitle);
733 }
734 #endif // Win32
735 }
736
737 // ---------------------------------------------------------------------------
738 // event processing
739 // ---------------------------------------------------------------------------
740
741 bool wxMenu::MSWCommand(WXUINT WXUNUSED(param), WXWORD id)
742 {
743 // ignore commands from the menu title
744 if ( id != (WXWORD)idMenuTitle )
745 {
746 // get the checked status of the command: notice that menuState is the
747 // old state of the menu, so the test for MF_CHECKED must be inverted
748 UINT menuState = ::GetMenuState(GetHmenu(), id, MF_BYCOMMAND);
749 SendEvent(id, !(menuState & MF_CHECKED));
750 }
751
752 return true;
753 }
754
755 // ---------------------------------------------------------------------------
756 // other
757 // ---------------------------------------------------------------------------
758
759 wxWindow *wxMenu::GetWindow() const
760 {
761 if ( m_invokingWindow != NULL )
762 return m_invokingWindow;
763 else if ( GetMenuBar() != NULL)
764 return GetMenuBar()->GetFrame();
765
766 return NULL;
767 }
768
769 // ---------------------------------------------------------------------------
770 // Menu Bar
771 // ---------------------------------------------------------------------------
772
773 void wxMenuBar::Init()
774 {
775 m_eventHandler = this;
776 m_hMenu = 0;
777 #if wxUSE_TOOLBAR && defined(__WXWINCE__)
778 m_toolBar = NULL;
779 #endif
780 // Not using a combined wxToolBar/wxMenuBar? then use
781 // a commandbar in WinCE .NET just to implement the
782 // menubar.
783 #if defined(WINCE_WITH_COMMANDBAR)
784 m_commandBar = NULL;
785 m_adornmentsAdded = false;
786 #endif
787 }
788
789 wxMenuBar::wxMenuBar()
790 {
791 Init();
792 }
793
794 wxMenuBar::wxMenuBar( long WXUNUSED(style) )
795 {
796 Init();
797 }
798
799 wxMenuBar::wxMenuBar(size_t count, wxMenu *menus[], const wxString titles[], long WXUNUSED(style))
800 {
801 Init();
802
803 m_titles.Alloc(count);
804
805 for ( size_t i = 0; i < count; i++ )
806 {
807 m_menus.Append(menus[i]);
808 m_titles.Add(titles[i]);
809
810 menus[i]->Attach(this);
811 }
812 }
813
814 wxMenuBar::~wxMenuBar()
815 {
816 // In Windows CE (not .NET), the menubar is always associated
817 // with a toolbar, which destroys the menu implicitly.
818 #if defined(WINCE_WITHOUT_COMMANDBAR) && defined(__POCKETPC__)
819 if (GetToolBar())
820 {
821 wxToolMenuBar* toolMenuBar = wxDynamicCast(GetToolBar(), wxToolMenuBar);
822 if (toolMenuBar)
823 toolMenuBar->SetMenuBar(NULL);
824 }
825 #else
826 // we should free Windows resources only if Windows doesn't do it for us
827 // which happens if we're attached to a frame
828 if (m_hMenu && !IsAttached())
829 {
830 #if defined(WINCE_WITH_COMMANDBAR)
831 ::DestroyWindow((HWND) m_commandBar);
832 m_commandBar = (WXHWND) NULL;
833 #else
834 ::DestroyMenu((HMENU)m_hMenu);
835 #endif
836 m_hMenu = (WXHMENU)NULL;
837 }
838 #endif
839 }
840
841 // ---------------------------------------------------------------------------
842 // wxMenuBar helpers
843 // ---------------------------------------------------------------------------
844
845 void wxMenuBar::Refresh()
846 {
847 wxCHECK_RET( IsAttached(), wxT("can't refresh unattached menubar") );
848
849 #if defined(WINCE_WITHOUT_COMMANDBAR)
850 if (GetToolBar())
851 {
852 CommandBar_DrawMenuBar((HWND) GetToolBar()->GetHWND(), 0);
853 }
854 #elif defined(WINCE_WITH_COMMANDBAR)
855 if (m_commandBar)
856 DrawMenuBar((HWND) m_commandBar);
857 #else
858 DrawMenuBar(GetHwndOf(GetFrame()));
859 #endif
860 }
861
862 WXHMENU wxMenuBar::Create()
863 {
864 // Note: this totally doesn't work on Smartphone,
865 // since you have to use resources.
866 // We'll have to find another way to add a menu
867 // by changing/adding menu items to an existing menu.
868 #if defined(WINCE_WITHOUT_COMMANDBAR)
869 if ( m_hMenu != 0 )
870 return m_hMenu;
871
872 if (!GetToolBar())
873 return 0;
874
875 HWND hCommandBar = (HWND) GetToolBar()->GetHWND();
876 HMENU hMenu = (HMENU)::SendMessage(hCommandBar, SHCMBM_GETMENU, (WPARAM)0, (LPARAM)0);
877 if (hMenu)
878 {
879 TBBUTTON tbButton;
880 memset(&tbButton, 0, sizeof(TBBUTTON));
881 tbButton.iBitmap = I_IMAGENONE;
882 tbButton.fsState = TBSTATE_ENABLED;
883 tbButton.fsStyle = TBSTYLE_DROPDOWN | TBSTYLE_NO_DROPDOWN_ARROW | TBSTYLE_AUTOSIZE;
884
885 size_t i;
886 for (i = 0; i < GetMenuCount(); i++)
887 {
888 HMENU hPopupMenu = (HMENU) GetMenu(i)->GetHMenu() ;
889 tbButton.dwData = (DWORD)hPopupMenu;
890 wxString label = wxStripMenuCodes(GetLabelTop(i));
891 tbButton.iString = (int) label.c_str();
892
893 int position = i;
894
895 tbButton.idCommand = NewControlId();
896 if (!::SendMessage(hCommandBar, TB_INSERTBUTTON, position, (LPARAM)&tbButton))
897 {
898 wxLogLastError(wxT("TB_INSERTBUTTON"));
899 }
900 }
901 }
902 m_hMenu = (WXHMENU) hMenu;
903 return m_hMenu;
904 #else
905 if ( m_hMenu != 0 )
906 return m_hMenu;
907
908 m_hMenu = (WXHMENU)::CreateMenu();
909
910 if ( !m_hMenu )
911 {
912 wxLogLastError(wxT("CreateMenu"));
913 }
914 else
915 {
916 size_t count = GetMenuCount(), i;
917 wxMenuList::iterator it;
918 for ( i = 0, it = m_menus.begin(); i < count; i++, it++ )
919 {
920 if ( !::AppendMenu((HMENU)m_hMenu, MF_POPUP | MF_STRING,
921 (UINT)(*it)->GetHMenu(),
922 m_titles[i]) )
923 {
924 wxLogLastError(wxT("AppendMenu"));
925 }
926 }
927 }
928
929 return m_hMenu;
930 #endif
931 }
932
933 int wxMenuBar::MSWPositionForWxMenu(wxMenu *menu, int wxpos)
934 {
935 wxASSERT(menu);
936 wxASSERT(menu->GetHMenu());
937 wxASSERT(m_hMenu);
938
939 #if defined(__WXWINCE__)
940 int totalMSWItems = GetMenuCount();
941 #else
942 int totalMSWItems = GetMenuItemCount((HMENU)m_hMenu);
943 #endif
944
945 int i; // For old C++ compatibility
946 for(i=wxpos; i<totalMSWItems; i++)
947 {
948 if(GetSubMenu((HMENU)m_hMenu,i)==(HMENU)menu->GetHMenu())
949 return i;
950 }
951 for(i=0; i<wxpos; i++)
952 {
953 if(GetSubMenu((HMENU)m_hMenu,i)==(HMENU)menu->GetHMenu())
954 return i;
955 }
956 wxFAIL;
957 return -1;
958 }
959
960 // ---------------------------------------------------------------------------
961 // wxMenuBar functions to work with the top level submenus
962 // ---------------------------------------------------------------------------
963
964 // NB: we don't support owner drawn top level items for now, if we do these
965 // functions would have to be changed to use wxMenuItem as well
966
967 void wxMenuBar::EnableTop(size_t pos, bool enable)
968 {
969 wxCHECK_RET( IsAttached(), wxT("doesn't work with unattached menubars") );
970 wxCHECK_RET( pos < GetMenuCount(), wxT("invalid menu index") );
971
972 int flag = enable ? MF_ENABLED : MF_GRAYED;
973
974 EnableMenuItem((HMENU)m_hMenu, MSWPositionForWxMenu(GetMenu(pos),pos), MF_BYPOSITION | flag);
975
976 Refresh();
977 }
978
979 void wxMenuBar::SetLabelTop(size_t pos, const wxString& label)
980 {
981 wxCHECK_RET( pos < GetMenuCount(), wxT("invalid menu index") );
982
983 m_titles[pos] = label;
984
985 if ( !IsAttached() )
986 {
987 return;
988 }
989 //else: have to modify the existing menu
990
991 int mswpos = MSWPositionForWxMenu(GetMenu(pos),pos);
992
993 UINT id;
994 UINT flagsOld = ::GetMenuState((HMENU)m_hMenu, mswpos, MF_BYPOSITION);
995 if ( flagsOld == 0xFFFFFFFF )
996 {
997 wxLogLastError(wxT("GetMenuState"));
998
999 return;
1000 }
1001
1002 if ( flagsOld & MF_POPUP )
1003 {
1004 // HIBYTE contains the number of items in the submenu in this case
1005 flagsOld &= 0xff;
1006 id = (UINT)::GetSubMenu((HMENU)m_hMenu, mswpos);
1007 }
1008 else
1009 {
1010 id = pos;
1011 }
1012
1013 #ifdef __WXWINCE__
1014 MENUITEMINFO info;
1015 wxZeroMemory(info);
1016 info.cbSize = sizeof(info);
1017 info.fMask = MIIM_TYPE;
1018 info.fType = MFT_STRING;
1019 info.cch = label.length();
1020 info.dwTypeData = (LPTSTR) label.c_str();
1021 if ( !SetMenuItemInfo(GetHmenu(), id, TRUE, & info) )
1022 {
1023 wxLogLastError(wxT("SetMenuItemInfo"));
1024 }
1025
1026 #else
1027 if ( ::ModifyMenu(GetHmenu(), mswpos, MF_BYPOSITION | MF_STRING | flagsOld,
1028 id, label) == (int)0xFFFFFFFF )
1029 {
1030 wxLogLastError(wxT("ModifyMenu"));
1031 }
1032 #endif
1033
1034 Refresh();
1035 }
1036
1037 wxString wxMenuBar::GetLabelTop(size_t pos) const
1038 {
1039 wxCHECK_MSG( pos < GetMenuCount(), wxEmptyString,
1040 wxT("invalid menu index in wxMenuBar::GetLabelTop") );
1041
1042 return wxMenuItem::GetLabelFromText(m_titles[pos]);
1043 }
1044
1045 // ---------------------------------------------------------------------------
1046 // wxMenuBar construction
1047 // ---------------------------------------------------------------------------
1048
1049 wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title)
1050 {
1051 wxMenu *menuOld = wxMenuBarBase::Replace(pos, menu, title);
1052 if ( !menuOld )
1053 return NULL;
1054
1055 m_titles[pos] = title;
1056
1057 if ( IsAttached() )
1058 {
1059 int mswpos = MSWPositionForWxMenu(menuOld,pos);
1060
1061 // can't use ModifyMenu() because it deletes the submenu it replaces
1062 if ( !::RemoveMenu(GetHmenu(), (UINT)mswpos, MF_BYPOSITION) )
1063 {
1064 wxLogLastError(wxT("RemoveMenu"));
1065 }
1066
1067 if ( !::InsertMenu(GetHmenu(), (UINT)mswpos,
1068 MF_BYPOSITION | MF_POPUP | MF_STRING,
1069 (UINT)GetHmenuOf(menu), title) )
1070 {
1071 wxLogLastError(wxT("InsertMenu"));
1072 }
1073
1074 #if wxUSE_ACCEL
1075 if ( menuOld->HasAccels() || menu->HasAccels() )
1076 {
1077 // need to rebuild accell table
1078 RebuildAccelTable();
1079 }
1080 #endif // wxUSE_ACCEL
1081
1082 Refresh();
1083 }
1084
1085 return menuOld;
1086 }
1087
1088 bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
1089 {
1090 // Find out which MSW item before which we'll be inserting before
1091 // wxMenuBarBase::Insert is called and GetMenu(pos) is the new menu.
1092 // If IsAttached() is false this won't be used anyway
1093 int mswpos = (!IsAttached() || (pos == m_menus.GetCount()))
1094 ? -1 // append the menu
1095 : MSWPositionForWxMenu(GetMenu(pos),pos);
1096
1097 if ( !wxMenuBarBase::Insert(pos, menu, title) )
1098 return false;
1099
1100 m_titles.Insert(title, pos);
1101
1102 if ( IsAttached() )
1103 {
1104 #if defined(WINCE_WITHOUT_COMMANDAR)
1105 if (!GetToolBar())
1106 return false;
1107 TBBUTTON tbButton;
1108 memset(&tbButton, 0, sizeof(TBBUTTON));
1109 tbButton.iBitmap = I_IMAGENONE;
1110 tbButton.fsState = TBSTATE_ENABLED;
1111 tbButton.fsStyle = TBSTYLE_DROPDOWN | TBSTYLE_NO_DROPDOWN_ARROW | TBSTYLE_AUTOSIZE;
1112
1113 HMENU hPopupMenu = (HMENU) menu->GetHMenu() ;
1114 tbButton.dwData = (DWORD)hPopupMenu;
1115 wxString label = wxStripMenuCodes(title);
1116 tbButton.iString = (int) label.c_str();
1117
1118 tbButton.idCommand = NewControlId();
1119 if (!::SendMessage((HWND) GetToolBar()->GetHWND(), TB_INSERTBUTTON, pos, (LPARAM)&tbButton))
1120 {
1121 wxLogLastError(wxT("TB_INSERTBUTTON"));
1122 return false;
1123 }
1124 #else
1125 if ( !::InsertMenu(GetHmenu(), mswpos,
1126 MF_BYPOSITION | MF_POPUP | MF_STRING,
1127 (UINT)GetHmenuOf(menu), title) )
1128 {
1129 wxLogLastError(wxT("InsertMenu"));
1130 }
1131 #endif
1132 #if wxUSE_ACCEL
1133 if ( menu->HasAccels() )
1134 {
1135 // need to rebuild accell table
1136 RebuildAccelTable();
1137 }
1138 #endif // wxUSE_ACCEL
1139
1140 Refresh();
1141 }
1142
1143 return true;
1144 }
1145
1146 bool wxMenuBar::Append(wxMenu *menu, const wxString& title)
1147 {
1148 WXHMENU submenu = menu ? menu->GetHMenu() : 0;
1149 wxCHECK_MSG( submenu, false, wxT("can't append invalid menu to menubar") );
1150
1151 if ( !wxMenuBarBase::Append(menu, title) )
1152 return false;
1153
1154 m_titles.Add(title);
1155
1156 if ( IsAttached() )
1157 {
1158 #if defined(WINCE_WITHOUT_COMMANDAR)
1159 if (!GetToolBar())
1160 return false;
1161 TBBUTTON tbButton;
1162 memset(&tbButton, 0, sizeof(TBBUTTON));
1163 tbButton.iBitmap = I_IMAGENONE;
1164 tbButton.fsState = TBSTATE_ENABLED;
1165 tbButton.fsStyle = TBSTYLE_DROPDOWN | TBSTYLE_NO_DROPDOWN_ARROW | TBSTYLE_AUTOSIZE;
1166
1167 size_t pos = GetMenuCount();
1168 HMENU hPopupMenu = (HMENU) menu->GetHMenu() ;
1169 tbButton.dwData = (DWORD)hPopupMenu;
1170 wxString label = wxStripMenuCodes(title);
1171 tbButton.iString = (int) label.c_str();
1172
1173 tbButton.idCommand = NewControlId();
1174 if (!::SendMessage((HWND) GetToolBar()->GetHWND(), TB_INSERTBUTTON, pos, (LPARAM)&tbButton))
1175 {
1176 wxLogLastError(wxT("TB_INSERTBUTTON"));
1177 return false;
1178 }
1179 #else
1180 if ( !::AppendMenu(GetHmenu(), MF_POPUP | MF_STRING,
1181 (UINT)submenu, title) )
1182 {
1183 wxLogLastError(wxT("AppendMenu"));
1184 }
1185 #endif
1186
1187 #if wxUSE_ACCEL
1188 if ( menu->HasAccels() )
1189 {
1190 // need to rebuild accelerator table
1191 RebuildAccelTable();
1192 }
1193 #endif // wxUSE_ACCEL
1194
1195 Refresh();
1196 }
1197
1198 return true;
1199 }
1200
1201 wxMenu *wxMenuBar::Remove(size_t pos)
1202 {
1203 wxMenu *menu = wxMenuBarBase::Remove(pos);
1204 if ( !menu )
1205 return NULL;
1206
1207 if ( IsAttached() )
1208 {
1209 #if defined(WINCE_WITHOUT_COMMANDAR)
1210 if (GetToolBar())
1211 {
1212 if (!::SendMessage((HWND) GetToolBar()->GetHWND(), TB_DELETEBUTTON, (UINT) pos, (LPARAM) 0))
1213 {
1214 wxLogLastError(wxT("TB_DELETEBUTTON"));
1215 }
1216 }
1217 #else
1218 if ( !::RemoveMenu(GetHmenu(), (UINT)MSWPositionForWxMenu(menu,pos), MF_BYPOSITION) )
1219 {
1220 wxLogLastError(wxT("RemoveMenu"));
1221 }
1222 #endif
1223
1224 #if wxUSE_ACCEL
1225 if ( menu->HasAccels() )
1226 {
1227 // need to rebuild accell table
1228 RebuildAccelTable();
1229 }
1230 #endif // wxUSE_ACCEL
1231
1232 Refresh();
1233 }
1234
1235
1236 m_titles.RemoveAt(pos);
1237
1238 return menu;
1239 }
1240
1241 #if wxUSE_ACCEL
1242
1243 void wxMenuBar::RebuildAccelTable()
1244 {
1245 // merge the accelerators of all menus into one accel table
1246 size_t nAccelCount = 0;
1247 size_t i, count = GetMenuCount();
1248 wxMenuList::iterator it;
1249 for ( i = 0, it = m_menus.begin(); i < count; i++, it++ )
1250 {
1251 nAccelCount += (*it)->GetAccelCount();
1252 }
1253
1254 if ( nAccelCount )
1255 {
1256 wxAcceleratorEntry *accelEntries = new wxAcceleratorEntry[nAccelCount];
1257
1258 nAccelCount = 0;
1259 for ( i = 0, it = m_menus.begin(); i < count; i++, it++ )
1260 {
1261 nAccelCount += (*it)->CopyAccels(&accelEntries[nAccelCount]);
1262 }
1263
1264 m_accelTable = wxAcceleratorTable(nAccelCount, accelEntries);
1265
1266 delete [] accelEntries;
1267 }
1268 }
1269
1270 #endif // wxUSE_ACCEL
1271
1272 void wxMenuBar::Attach(wxFrame *frame)
1273 {
1274 wxMenuBarBase::Attach(frame);
1275
1276 #if defined(WINCE_WITH_COMMANDBAR)
1277 if (!m_hMenu)
1278 this->Create();
1279 if (!m_commandBar)
1280 m_commandBar = (WXHWND) CommandBar_Create(wxGetInstance(), (HWND) frame->GetHWND(), NewControlId());
1281 if (m_commandBar)
1282 {
1283 if (m_hMenu)
1284 {
1285 if (!CommandBar_InsertMenubarEx((HWND) m_commandBar, NULL, (LPTSTR) m_hMenu, 0))
1286 {
1287 wxLogLastError(wxT("CommandBar_InsertMenubarEx"));
1288 }
1289 }
1290 }
1291 #endif
1292
1293 #if wxUSE_ACCEL
1294 RebuildAccelTable();
1295 #endif // wxUSE_ACCEL
1296 }
1297
1298 #if defined(WINCE_WITH_COMMANDBAR)
1299 bool wxMenuBar::AddAdornments(long style)
1300 {
1301 if (m_adornmentsAdded || !m_commandBar)
1302 return false;
1303
1304 if (style & wxCLOSE_BOX)
1305 {
1306 if (!CommandBar_AddAdornments((HWND) m_commandBar, 0, 0))
1307 wxLogLastError(wxT("CommandBar_AddAdornments"));
1308 else
1309 return true;
1310 }
1311 return false;
1312 }
1313 #endif
1314
1315 void wxMenuBar::Detach()
1316 {
1317 wxMenuBarBase::Detach();
1318 }
1319
1320 #endif // wxUSE_MENUS
wxWidgets (Impactor)