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