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