]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/os2/menu.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Fix typo in last commit
[wxWidgets.git] / src / os2 / menu.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/os2/menu.cpp
3// Purpose: wxMenu, wxMenuBar, wxMenuItem
4// Author: David Webster
5// Modified by:
6// Created: 10/10/99
7// RCS-ID: $Id$
8// Copyright: (c) David Webster
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12// For compilers that support precompilation, includes "wx.h".
13#include "wx/wxprec.h"
14
15#include "wx/menu.h"
16
17#ifndef WX_PRECOMP
18 #include "wx/app.h"
19 #include "wx/frame.h"
20 #include "wx/utils.h"
21 #include "wx/intl.h"
22 #include "wx/log.h"
23#endif
24
25#if wxUSE_OWNER_DRAWN
26 #include "wx/ownerdrw.h"
27#endif
28
29#include "wx/os2/private.h"
30
31// other standard headers
32#include <string.h>
33
34// ----------------------------------------------------------------------------
35// global variables
36// ----------------------------------------------------------------------------
37
38extern wxMenu* wxCurrentPopupMenu;
39
40// ----------------------------------------------------------------------------
41// constants
42// ----------------------------------------------------------------------------
43
44//
45// The (popup) menu title has this special id
46//
47static const int idMenuTitle = -3;
48
49//
50// The unique ID for Menus
51//
52USHORT wxMenu::m_nextMenuId = 0;
53
54// ----------------------------------------------------------------------------
55// macros
56// ----------------------------------------------------------------------------
57
58// ============================================================================
59// implementation
60// ============================================================================
61
62// ---------------------------------------------------------------------------
63// wxMenu construction, adding and removing menu items
64// ---------------------------------------------------------------------------
65
66//
67// Construct a menu with optional title (then use append)
68//
69void wxMenu::Init()
70{
71 m_bDoBreak = false;
72 m_nStartRadioGroup = -1;
73
74 //
75 // Create the menu (to be used as a submenu or a popup)
76 //
77 if ((m_hMenu = ::WinCreateWindow( HWND_DESKTOP
78 ,WC_MENU
79 ,"Menu"
80 ,0L
81 ,0L
82 ,0L
83 ,0L
84 ,0L
85 ,NULLHANDLE
86 ,HWND_TOP
87 ,0L
88 ,NULL
89 ,NULL
90 )) == 0)
91 {
92 wxLogLastError(wxT("WinLoadMenu"));
93 }
94 m_vMenuData.iPosition = 0;
95 m_vMenuData.afStyle = MIS_SUBMENU | MIS_TEXT;
96 m_vMenuData.afAttribute = (USHORT)0;
97 m_vMenuData.id = m_nextMenuId++;
98 m_vMenuData.hwndSubMenu = m_hMenu;
99 m_vMenuData.hItem = NULLHANDLE;
100
101 //
102 // If we have a title, insert it in the beginning of the menu
103 //
104 if (!m_title.empty())
105 {
106 Append( idMenuTitle
107 ,m_title
108 ,wxEmptyString
109 ,wxITEM_NORMAL
110 );
111 AppendSeparator();
112 }
113} // end of wxMenu::Init
114
115//
116// The wxWindow destructor will take care of deleting the submenus.
117//
118wxMenu::~wxMenu()
119{
120 //
121 // We should free PM resources only if PM doesn't do it for us
122 // which happens if we're attached to a menubar or a submenu of another
123 // menu
124 if (!IsAttached() && !GetParent())
125 {
126 if (!::WinDestroyWindow((HWND)GetHmenu()) )
127 {
128 wxLogLastError(wxT("WinDestroyWindow"));
129 }
130 }
131
132#if wxUSE_ACCEL
133 //
134 // Delete accels
135 //
136 WX_CLEAR_ARRAY(m_vAccels);
137#endif // wxUSE_ACCEL
138} // end of wxMenu::~wxMenu
139
140void wxMenu::Break()
141{
142 // this will take effect during the next call to Append()
143 m_bDoBreak = true;
144} // end of wxMenu::Break
145
146void wxMenu::Attach(
147 wxMenuBarBase* pMenubar
148)
149{
150 wxMenuBase::Attach(pMenubar);
151 EndRadioGroup();
152} // end of wxMenu::Break;
153
154#if wxUSE_ACCEL
155
156int wxMenu::FindAccel(
157 int nId
158) const
159{
160 size_t n;
161 size_t nCount = m_vAccels.GetCount();
162
163 for (n = 0; n < nCount; n++)
164 if (m_vAccels[n]->m_command == nId)
165 return n;
166 return wxNOT_FOUND;
167} // end of wxMenu::FindAccel
168
169void wxMenu::UpdateAccel(
170 wxMenuItem* pItem
171)
172{
173 if (pItem->IsSubMenu())
174 {
175 wxMenu* pSubmenu = pItem->GetSubMenu();
176 wxMenuItemList::compatibility_iterator node = pSubmenu->GetMenuItems().GetFirst();
177
178 while (node)
179 {
180 UpdateAccel(node->GetData());
181 node = node->GetNext();
182 }
183 }
184 else if (!pItem->IsSeparator())
185 {
186 //
187 // Recurse upwards: we should only modify m_accels of the top level
188 // menus, not of the submenus as wxMenuBar doesn't look at them
189 // (alternative and arguable cleaner solution would be to recurse
190 // downwards in GetAccelCount() and CopyAccels())
191 //
192 if (GetParent())
193 {
194 GetParent()->UpdateAccel(pItem);
195 return;
196 }
197
198 //
199 // Find the (new) accel for this item
200 //
201 wxAcceleratorEntry* pAccel = wxAcceleratorEntry::Create(pItem->GetItemLabel());
202
203 if (pAccel)
204 pAccel->m_command = pItem->GetId();
205
206 //
207 // Find the old one
208 //
209 size_t n = FindAccel(pItem->GetId());
210
211 if (n == (size_t)wxNOT_FOUND)
212 {
213 //
214 // No old, add new if any
215 //
216 if (pAccel)
217 m_vAccels.Add(pAccel);
218 else
219 return;
220 }
221 else
222 {
223 //
224 // Replace old with new or just remove the old one if no new
225 //
226 delete m_vAccels[n];
227 if (pAccel)
228 m_vAccels[n] = pAccel;
229 else
230 m_vAccels.RemoveAt(n);
231 }
232
233 if (IsAttached())
234 {
235 GetMenuBar()->RebuildAccelTable();
236 }
237 }
238} // wxMenu::UpdateAccel
239
240#endif // wxUSE_ACCEL
241
242//
243// Append a new item or submenu to the menu
244//
245bool wxMenu::DoInsertOrAppend( wxMenuItem* pItem,
246 size_t nPos )
247{
248 wxMenu* pSubmenu = pItem->GetSubMenu();
249 MENUITEM& rItem = (pSubmenu != NULL)?pSubmenu->m_vMenuData:
250 pItem->m_vMenuData;
251
252 ERRORID vError;
253 wxString sError;
254
255#if wxUSE_ACCEL
256 UpdateAccel(pItem);
257#endif // wxUSE_ACCEL
258
259 //
260 // If "Break" has just been called, insert a menu break before this item
261 // (and don't forget to reset the flag)
262 //
263 if (m_bDoBreak)
264 {
265 rItem.afStyle |= MIS_BREAK;
266 m_bDoBreak = false;
267 }
268
269 //
270 // Id is the numeric id for normal menu items and HMENU for submenus as
271 // required by ::MM_INSERTITEM message API
272 //
273 if (pSubmenu != NULL)
274 {
275 wxASSERT_MSG(pSubmenu->GetHMenu(), wxT("invalid submenu"));
276 pSubmenu->SetParent(this);
277
278 rItem.iPosition = 0; // submenus have a 0 position
279 rItem.id = (USHORT)pSubmenu->GetHMenu();
280 rItem.afStyle |= MIS_SUBMENU | MIS_TEXT;
281 }
282 else
283 {
284 rItem.id = (USHORT)pItem->GetId();
285 }
286
287 char *pData = NULL;
288
289#if wxUSE_OWNER_DRAWN
290 if (pItem->IsOwnerDrawn())
291 {
292 //
293 // Want to get {Measure|Draw}Item messages?
294 // item draws itself, passing pointer to data doesn't work in OS/2
295 // Will eventually need to set the image handle somewhere into vItem.hItem
296 //
297 rItem.afStyle |= MIS_OWNERDRAW;
298 pData = NULL;
299 rItem.hItem = (HBITMAP)pItem->GetBitmap().GetHBITMAP();
300 pItem->m_vMenuData.afStyle = rItem.afStyle;
301 pItem->m_vMenuData.hItem = rItem.hItem;
302 }
303 else
304#endif
305 if (pItem->IsSeparator())
306 {
307 rItem.afStyle = MIS_SEPARATOR;
308 }
309 else
310 {
311 if (pItem->GetId() == idMenuTitle)
312 {
313 // Item is an unselectable title to be passed via pData
314 rItem.afStyle = MIS_STATIC;
315 }
316 else
317 {
318 //
319 // Menu is just a normal string (passed in data parameter)
320 //
321 rItem.afStyle |= MIS_TEXT;
322 }
323 pData = (char*) pItem->GetItemLabel().wx_str();
324 }
325
326 if (nPos == (size_t)-1)
327 {
328 rItem.iPosition = MIT_END;
329 }
330 else
331 {
332 rItem.iPosition = (SHORT)nPos;
333 }
334
335 APIRET rc;
336
337 rc = (APIRET)::WinSendMsg( GetHmenu()
338 ,MM_INSERTITEM
339 ,(MPARAM)&rItem
340 ,(MPARAM)pData
341 );
342#if wxUSE_OWNER_DRAWN
343 if (pItem->IsOwnerDrawn())
344 {
345 MENUITEM vMenuItem;
346
347 ::WinSendMsg( GetHmenu()
348 ,MM_QUERYITEM
349 ,MPFROM2SHORT( (USHORT)pItem->GetId()
350 ,(USHORT)(FALSE)
351 )
352 ,&vMenuItem
353 );
354 }
355#endif
356
357 if (rc == (APIRET)MIT_MEMERROR || rc == (APIRET)MIT_ERROR)
358 {
359 vError = ::WinGetLastError(vHabmain);
360 sError = wxPMErrorToStr(vError);
361 wxLogError(wxT("Error inserting or appending a menuitem. Error: %s\n"), sError.c_str());
362 wxLogLastError(wxT("Insert or AppendMenu"));
363 return false;
364 }
365
366 //
367 // If we're already attached to the menubar, we must update it
368 //
369 if (IsAttached() && GetMenuBar()->IsAttached())
370 {
371 GetMenuBar()->Refresh();
372 }
373
374 return true;
375} // end of wxMenu::DoInsertOrAppend
376
377void wxMenu::EndRadioGroup()
378{
379 //
380 // We're not inside a radio group any longer
381 //
382 m_nStartRadioGroup = -1;
383} // end of wxMenu::EndRadioGroup
384
385wxMenuItem* wxMenu::DoAppend( wxMenuItem* pItem )
386{
387 wxCHECK_MSG( pItem, NULL, wxT("NULL item in wxMenu::DoAppend") );
388
389 bool bCheck = false;
390
391 if (pItem->GetKind() == wxITEM_RADIO)
392 {
393 int nCount = GetMenuItemCount();
394
395 if (m_nStartRadioGroup == -1)
396 {
397 //
398 // Start a new radio group
399 //
400 m_nStartRadioGroup = nCount;
401
402 //
403 // For now it has just one element
404 //
405 pItem->SetAsRadioGroupStart();
406 pItem->SetRadioGroupEnd(m_nStartRadioGroup);
407
408 //
409 // Ensure that we have a checked item in the radio group
410 //
411 bCheck = true;
412 }
413 else // extend the current radio group
414 {
415 //
416 // We need to update its end item
417 //
418 pItem->SetRadioGroupStart(m_nStartRadioGroup);
419
420 wxMenuItemList::compatibility_iterator node = GetMenuItems().Item(m_nStartRadioGroup);
421
422 if (node)
423 {
424 node->GetData()->SetRadioGroupEnd(nCount);
425 }
426 else
427 {
428 wxFAIL_MSG( wxT("where is the radio group start item?") );
429 }
430 }
431 }
432 else // not a radio item
433 {
434 EndRadioGroup();
435 }
436
437 if (!wxMenuBase::DoAppend(pItem) || !DoInsertOrAppend(pItem))
438 {
439 return NULL;
440 }
441 if (bCheck)
442 {
443 //
444 // Check the item initially
445 //
446 pItem->Check(true);
447 }
448 return pItem;
449} // end of wxMenu::DoAppend
450
451wxMenuItem* wxMenu::DoInsert(
452 size_t nPos
453, wxMenuItem* pItem
454)
455{
456 if ( wxMenuBase::DoInsert( nPos
457 ,pItem) &&
458 DoInsertOrAppend( pItem
459 ,nPos
460 ))
461 return pItem;
462 else
463 return NULL;
464} // end of wxMenu::DoInsert
465
466wxMenuItem* wxMenu::DoRemove(
467 wxMenuItem* pItem
468)
469{
470 //
471 // We need to find the items position in the child list
472 //
473 size_t nPos;
474 wxMenuItemList::compatibility_iterator node = GetMenuItems().GetFirst();
475
476 for (nPos = 0; node; nPos++)
477 {
478 if (node->GetData() == pItem)
479 break;
480 node = node->GetNext();
481 }
482
483 //
484 // DoRemove() (unlike Remove) can only be called for existing item!
485 //
486 wxCHECK_MSG(node, NULL, wxT("bug in wxMenu::Remove logic"));
487
488#if wxUSE_ACCEL
489 //
490 // Remove the corresponding accel from the accel table
491 //
492 int n = FindAccel(pItem->GetId());
493
494 if (n != wxNOT_FOUND)
495 {
496 delete m_vAccels[n];
497 m_vAccels.RemoveAt(n);
498 }
499
500#endif // wxUSE_ACCEL
501 //
502 // Remove the item from the menu
503 //
504 ::WinSendMsg( GetHmenu()
505 ,MM_REMOVEITEM
506 ,MPFROM2SHORT(pItem->GetId(), TRUE)
507 ,(MPARAM)0
508 );
509 if (IsAttached() && GetMenuBar()->IsAttached())
510 {
511 //
512 // Otherwise, the chane won't be visible
513 //
514 GetMenuBar()->Refresh();
515 }
516
517 //
518 // And from internal data structures
519 //
520 return wxMenuBase::DoRemove(pItem);
521} // end of wxMenu::DoRemove
522
523// ---------------------------------------------------------------------------
524// accelerator helpers
525// ---------------------------------------------------------------------------
526
527#if wxUSE_ACCEL
528
529//
530// Create the wxAcceleratorEntries for our accels and put them into provided
531// array - return the number of accels we have
532//
533size_t wxMenu::CopyAccels(
534 wxAcceleratorEntry* pAccels
535) const
536{
537 size_t nCount = GetAccelCount();
538
539 for (size_t n = 0; n < nCount; n++)
540 {
541 *pAccels++ = *m_vAccels[n];
542 }
543 return nCount;
544} // end of wxMenu::CopyAccels
545
546#endif // wxUSE_ACCEL
547
548// ---------------------------------------------------------------------------
549// set wxMenu title
550// ---------------------------------------------------------------------------
551
552void wxMenu::SetTitle( const wxString& rLabel )
553{
554 bool bHasNoTitle = m_title.empty();
555 HWND hMenu = GetHmenu();
556
557 m_title = rLabel;
558 if (bHasNoTitle)
559 {
560 if (!rLabel.empty())
561 {
562 if (!::WinSetWindowText(hMenu, rLabel.c_str()))
563 {
564 wxLogLastError(wxT("SetMenuTitle"));
565 }
566 }
567 }
568 else
569 {
570 if (rLabel.empty() )
571 {
572 ::WinSendMsg( GetHmenu()
573 ,MM_REMOVEITEM
574 ,MPFROM2SHORT(hMenu, TRUE)
575 ,(MPARAM)0
576 );
577 }
578 else
579 {
580 //
581 // Modify the title
582 //
583 if (!::WinSetWindowText(hMenu, rLabel.c_str()))
584 {
585 wxLogLastError(wxT("SetMenuTitle"));
586 }
587 }
588 }
589} // end of wxMenu::SetTitle
590
591// ---------------------------------------------------------------------------
592// event processing
593// ---------------------------------------------------------------------------
594
595bool wxMenu::OS2Command( WXUINT WXUNUSED(uParam),
596 WXWORD vId )
597{
598 //
599 // Ignore commands from the menu title
600 //
601
602 if (vId != (WXWORD)idMenuTitle)
603 {
604 SendEvent( vId
605 ,(int)::WinSendMsg( GetHmenu()
606 ,MM_QUERYITEMATTR
607 ,MPFROMSHORT(vId)
608 ,(MPARAM)MIA_CHECKED
609 )
610 );
611 }
612 return true;
613} // end of wxMenu::OS2Command
614
615// ---------------------------------------------------------------------------
616// other
617// ---------------------------------------------------------------------------
618
619wxWindow* wxMenu::GetWindow() const
620{
621 if (m_invokingWindow != NULL)
622 return m_invokingWindow;
623 else if ( GetMenuBar() != NULL)
624 return GetMenuBar()->GetFrame();
625
626 return NULL;
627} // end of wxMenu::GetWindow
628
629// recursive search for item by id
630wxMenuItem* wxMenu::FindItem(
631 int nItemId
632, ULONG hItem
633, wxMenu** ppItemMenu
634) const
635{
636 if ( ppItemMenu )
637 *ppItemMenu = NULL;
638
639 wxMenuItem* pItem = NULL;
640
641 for ( wxMenuItemList::compatibility_iterator node = m_items.GetFirst();
642 node && !pItem;
643 node = node->GetNext() )
644 {
645 pItem = node->GetData();
646
647 if ( pItem->GetId() == nItemId && pItem->m_vMenuData.hItem == hItem)
648 {
649 if ( ppItemMenu )
650 *ppItemMenu = (wxMenu *)this;
651 }
652 else if ( pItem->IsSubMenu() )
653 {
654 pItem = pItem->GetSubMenu()->FindItem( nItemId
655 ,hItem
656 ,ppItemMenu
657 );
658 if (pItem)
659 break;
660 }
661 else
662 {
663 // don't exit the loop
664 pItem = NULL;
665 }
666 }
667 return pItem;
668} // end of wxMenu::FindItem
669
670// ---------------------------------------------------------------------------
671// Menu Bar
672// ---------------------------------------------------------------------------
673
674void wxMenuBar::Init()
675{
676 m_eventHandler = this;
677 m_menuBarFrame = NULL;
678 m_hMenu = 0;
679} // end of wxMenuBar::Init
680
681wxMenuBar::wxMenuBar()
682{
683 Init();
684} // end of wxMenuBar::wxMenuBar
685
686wxMenuBar::wxMenuBar(
687 long WXUNUSED(lStyle)
688)
689{
690 Init();
691} // end of wxMenuBar::wxMenuBar
692
693wxMenuBar::wxMenuBar(
694 int nCount
695, wxMenu* vMenus[]
696, const wxString sTitles[]
697, long WXUNUSED(lStyle)
698)
699{
700 Init();
701
702 m_titles.Alloc(nCount);
703 for ( int i = 0; i < nCount; i++ )
704 {
705 m_menus.Append(vMenus[i]);
706 m_titles.Add(sTitles[i]);
707 vMenus[i]->Attach(this);
708 }
709} // end of wxMenuBar::wxMenuBar
710
711wxMenuBar::~wxMenuBar()
712{
713 //
714 // We should free PM's resources only if PM doesn't do it for us
715 // which happens if we're attached to a frame
716 //
717 if (m_hMenu && !IsAttached())
718 {
719 ::WinDestroyWindow((HMENU)m_hMenu);
720 m_hMenu = (WXHMENU)NULL;
721 }
722} // end of wxMenuBar::~wxMenuBar
723
724// ---------------------------------------------------------------------------
725// wxMenuBar helpers
726// ---------------------------------------------------------------------------
727
728void wxMenuBar::Refresh()
729{
730 wxCHECK_RET( IsAttached(), wxT("can't refresh unatteched menubar") );
731
732 WinSendMsg(GetWinHwnd(m_menuBarFrame), WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
733} // end of wxMenuBar::Refresh
734
735WXHMENU wxMenuBar::Create()
736{
737 HWND hFrame;
738
739 if (m_hMenu != 0 )
740 return m_hMenu;
741
742 wxCHECK_MSG(!m_hMenu, TRUE, wxT("menubar already created"));
743
744 //
745 // Menubars should be associated with a frame otherwise they are popups
746 //
747 if (m_menuBarFrame != NULL)
748 hFrame = GetWinHwnd(m_menuBarFrame);
749 else
750 hFrame = HWND_DESKTOP;
751 //
752 // Create an empty menu and then fill it with insertions
753 //
754 if ((m_hMenu = ::WinCreateWindow( hFrame
755 ,WC_MENU
756 ,NULL
757 ,MS_ACTIONBAR | WS_SYNCPAINT | WS_VISIBLE
758 ,0L
759 ,0L
760 ,0L
761 ,0L
762 ,hFrame
763 ,HWND_TOP
764 ,FID_MENU
765 ,NULL
766 ,NULL
767 )) == 0)
768 {
769 wxLogLastError(wxT("WinLoadMenu"));
770 }
771 else
772 {
773 size_t nCount = GetMenuCount(), i;
774 wxMenuList::iterator it;
775 for (i = 0, it = m_menus.begin(); i < nCount; i++, it++)
776 {
777 APIRET rc;
778 ERRORID vError;
779 wxString sError;
780 HWND hSubMenu;
781
782 //
783 // Set the parent and owner of the submenues to be the menubar, not the desktop
784 //
785 hSubMenu = (*it)->m_vMenuData.hwndSubMenu;
786 if (!::WinSetParent((*it)->m_vMenuData.hwndSubMenu, m_hMenu, FALSE))
787 {
788 vError = ::WinGetLastError(vHabmain);
789 sError = wxPMErrorToStr(vError);
790 wxLogError(wxT("Error setting parent for submenu. Error: %s\n"), sError.c_str());
791 return NULLHANDLE;
792 }
793
794 if (!::WinSetOwner((*it)->m_vMenuData.hwndSubMenu, m_hMenu))
795 {
796 vError = ::WinGetLastError(vHabmain);
797 sError = wxPMErrorToStr(vError);
798 wxLogError(wxT("Error setting parent for submenu. Error: %s\n"), sError.c_str());
799 return NULLHANDLE;
800 }
801
802 (*it)->m_vMenuData.iPosition = (SHORT)i;
803
804 rc = (APIRET)::WinSendMsg(m_hMenu, MM_INSERTITEM, (MPARAM)&(*it)->m_vMenuData, (MPARAM)m_titles[i].wx_str());
805 if (rc == (APIRET)MIT_MEMERROR || rc == (APIRET)MIT_ERROR)
806 {
807 vError = ::WinGetLastError(vHabmain);
808 sError = wxPMErrorToStr(vError);
809 wxLogError(wxT("Error inserting or appending a menuitem. Error: %s\n"), sError.c_str());
810 return NULLHANDLE;
811 }
812 }
813 }
814 return m_hMenu;
815} // end of wxMenuBar::Create
816
817// ---------------------------------------------------------------------------
818// wxMenuBar functions to work with the top level submenus
819// ---------------------------------------------------------------------------
820
821//
822// NB: we don't support owner drawn top level items for now, if we do these
823// functions would have to be changed to use wxMenuItem as well
824//
825void wxMenuBar::EnableTop(
826 size_t nPos
827, bool bEnable
828)
829{
830 wxCHECK_RET(IsAttached(), wxT("doesn't work with unattached menubars"));
831 USHORT uFlag = 0;
832 SHORT nId;
833
834 if(!bEnable)
835 uFlag = MIA_DISABLED;
836
837 nId = SHORT1FROMMR(::WinSendMsg((HWND)m_hMenu, MM_ITEMIDFROMPOSITION, MPFROMSHORT(nPos), (MPARAM)0));
838 if (nId == MIT_ERROR)
839 {
840 wxLogLastError(wxT("LogLastError"));
841 return;
842 }
843 ::WinSendMsg((HWND)m_hMenu, MM_SETITEMATTR, MPFROM2SHORT(nId, TRUE), MPFROM2SHORT(MIA_DISABLED, uFlag));
844 Refresh();
845} // end of wxMenuBar::EnableTop
846
847void wxMenuBar::SetMenuLabel(
848 size_t nPos
849, const wxString& rLabel
850)
851{
852 SHORT nId;
853 MENUITEM vItem;
854
855 wxCHECK_RET(nPos < GetMenuCount(), wxT("invalid menu index"));
856 m_titles[nPos] = rLabel;
857
858 if (!IsAttached())
859 {
860 return;
861 }
862
863 nId = SHORT1FROMMR(::WinSendMsg((HWND)m_hMenu, MM_ITEMIDFROMPOSITION, MPFROMSHORT(nPos), (MPARAM)0));
864 if (nId == MIT_ERROR)
865 {
866 wxLogLastError(wxT("LogLastError"));
867 return;
868 }
869 if(!::WinSendMsg( (HWND)m_hMenu
870 ,MM_QUERYITEM
871 ,MPFROM2SHORT(nId, TRUE)
872 ,MPARAM(&vItem)
873 ))
874 {
875 wxLogLastError(wxT("QueryItem"));
876 }
877 nId = vItem.id;
878
879 if (::WinSendMsg(GetHmenu(), MM_SETITEMTEXT, MPFROMSHORT(nId), (MPARAM)rLabel.wx_str()));
880 {
881 wxLogLastError(wxT("ModifyMenu"));
882 }
883 Refresh();
884} // end of wxMenuBar::SetMenuLabel
885
886wxString wxMenuBar::GetMenuLabel(
887 size_t nPos
888) const
889{
890 wxCHECK_MSG( nPos < GetMenuCount(), wxEmptyString,
891 wxT("invalid menu index in wxMenuBar::GetMenuLabel") );
892 return m_titles[nPos];
893} // end of wxMenuBar::GetMenuLabel
894
895// ---------------------------------------------------------------------------
896// wxMenuBar construction
897// ---------------------------------------------------------------------------
898
899wxMenu* wxMenuBar::Replace(
900 size_t nPos
901, wxMenu* pMenu
902, const wxString& rTitle
903)
904{
905 SHORT nId;
906 wxString sTitle = wxPMTextToLabel(rTitle);
907 wxMenu* pMenuOld = wxMenuBarBase::Replace( nPos
908 ,pMenu
909 ,sTitle
910 );
911
912
913 nId = SHORT1FROMMR(::WinSendMsg((HWND)m_hMenu, MM_ITEMIDFROMPOSITION, MPFROMSHORT(nPos), (MPARAM)0));
914 if (nId == MIT_ERROR)
915 {
916 wxLogLastError(wxT("LogLastError"));
917 return NULL;
918 }
919 if (!pMenuOld)
920 return NULL;
921 m_titles[nPos] = sTitle;
922 if (IsAttached())
923 {
924 ::WinSendMsg((HWND)m_hMenu, MM_REMOVEITEM, MPFROM2SHORT(nId, TRUE), (MPARAM)0);
925 ::WinSendMsg((HWND)m_hMenu, MM_INSERTITEM, (MPARAM)&pMenu->m_vMenuData, (MPARAM)sTitle.wx_str());
926
927#if wxUSE_ACCEL
928 if (pMenuOld->HasAccels() || pMenu->HasAccels())
929 {
930 //
931 // Need to rebuild accell table
932 //
933 RebuildAccelTable();
934 }
935#endif // wxUSE_ACCEL
936 Refresh();
937 }
938 return pMenuOld;
939} // end of wxMenuBar::Replace
940
941bool wxMenuBar::Insert( size_t nPos,
942 wxMenu* pMenu,
943 const wxString& rTitle )
944{
945 wxString sTitle = wxPMTextToLabel(rTitle);
946
947 if (!wxMenuBarBase::Insert( nPos, pMenu, sTitle ))
948 return false;
949
950 m_titles.Insert( sTitle, nPos );
951
952 if (IsAttached())
953 {
954 pMenu->m_vMenuData.iPosition = (SHORT)nPos;
955 ::WinSendMsg( (HWND)m_hMenu
956 ,MM_INSERTITEM
957 ,(MPARAM)&pMenu->m_vMenuData
958 ,(MPARAM)sTitle.wx_str()
959 );
960#if wxUSE_ACCEL
961 if (pMenu->HasAccels())
962 {
963 // need to rebuild accell table
964 RebuildAccelTable();
965 }
966#endif // wxUSE_ACCEL
967 Refresh();
968 }
969
970 return true;
971} // end of wxMenuBar::Insert
972
973bool wxMenuBar::Append( wxMenu* pMenu,
974 const wxString& rsTitle )
975{
976 WXHMENU hSubmenu = pMenu ? pMenu->GetHMenu() : 0;
977
978 wxCHECK_MSG(hSubmenu, false, wxT("can't append invalid menu to menubar"));
979
980 wxString sTitle = wxPMTextToLabel(rsTitle);
981
982 if (!wxMenuBarBase::Append(pMenu, sTitle))
983 return false;
984
985 m_titles.Add(sTitle);
986
987 if ( IsAttached() )
988 {
989 pMenu->m_vMenuData.iPosition = MIT_END;
990 ::WinSendMsg((HWND)m_hMenu, MM_INSERTITEM, (MPARAM)&pMenu->m_vMenuData, (MPARAM)sTitle.wx_str());
991#if wxUSE_ACCEL
992 if (pMenu->HasAccels())
993 {
994 //
995 // Need to rebuild accell table
996 //
997 RebuildAccelTable();
998 }
999#endif // wxUSE_ACCEL
1000 Refresh();
1001 }
1002 return true;
1003} // end of wxMenuBar::Append
1004
1005wxMenu* wxMenuBar::Remove(
1006 size_t nPos
1007)
1008{
1009 wxMenu* pMenu = wxMenuBarBase::Remove(nPos);
1010 SHORT nId;
1011
1012 if (!pMenu)
1013 return NULL;
1014
1015 nId = SHORT1FROMMR(::WinSendMsg( (HWND)GetHmenu()
1016 ,MM_ITEMIDFROMPOSITION
1017 ,MPFROMSHORT(nPos)
1018 ,(MPARAM)0)
1019 );
1020 if (nId == MIT_ERROR)
1021 {
1022 wxLogLastError(wxT("LogLastError"));
1023 return NULL;
1024 }
1025 if (IsAttached())
1026 {
1027 ::WinSendMsg( (HWND)GetHmenu()
1028 ,MM_REMOVEITEM
1029 ,MPFROM2SHORT(nId, TRUE)
1030 ,(MPARAM)0
1031 );
1032
1033#if wxUSE_ACCEL
1034 if (pMenu->HasAccels())
1035 {
1036 //
1037 // Need to rebuild accell table
1038 //
1039 RebuildAccelTable();
1040 }
1041#endif // wxUSE_ACCEL
1042 Refresh();
1043 }
1044 m_titles.RemoveAt(nPos);
1045 return pMenu;
1046} // end of wxMenuBar::Remove
1047
1048#if wxUSE_ACCEL
1049
1050void wxMenuBar::RebuildAccelTable()
1051{
1052 //
1053 // Merge the accelerators of all menus into one accel table
1054 //
1055 size_t nAccelCount = 0;
1056 size_t i;
1057 size_t nCount = GetMenuCount();
1058 wxMenuList::iterator it;
1059 for (i = 0, it = m_menus.begin(); i < nCount; i++, it++)
1060 {
1061 nAccelCount += (*it)->GetAccelCount();
1062 }
1063
1064 if (nAccelCount)
1065 {
1066 wxAcceleratorEntry* pAccelEntries = new wxAcceleratorEntry[nAccelCount];
1067
1068 nAccelCount = 0;
1069 for (i = 0, it = m_menus.begin(); i < nCount; i++, it++)
1070 {
1071 nAccelCount += (*it)->CopyAccels(&pAccelEntries[nAccelCount]);
1072 }
1073 m_vAccelTable = wxAcceleratorTable( nAccelCount
1074 ,pAccelEntries
1075 );
1076 delete [] pAccelEntries;
1077 }
1078} // end of wxMenuBar::RebuildAccelTable
1079
1080#endif // wxUSE_ACCEL
1081
1082void wxMenuBar::Attach(
1083 wxFrame* pFrame
1084)
1085{
1086 wxMenuBarBase::Attach(pFrame);
1087
1088#if wxUSE_ACCEL
1089 RebuildAccelTable();
1090 //
1091 // Ensure the accelerator table is set to the frame (not the client!)
1092 //
1093 if (!::WinSetAccelTable( vHabmain
1094 ,m_vAccelTable.GetHACCEL()
1095 ,(HWND)pFrame->GetFrame()
1096 ))
1097 {
1098 wxLogLastError(wxT("WinSetAccelTable"));
1099 }
1100#endif // wxUSE_ACCEL
1101} // end of wxMenuBar::Attach
1102
1103void wxMenuBar::Detach()
1104{
1105 ::WinDestroyWindow((HWND)m_hMenu);
1106 m_hMenu = (WXHMENU)NULL;
1107 m_menuBarFrame = NULL;
1108} // end of wxMenuBar::Detach
1109
1110// ---------------------------------------------------------------------------
1111// wxMenuBar searching for menu items
1112// ---------------------------------------------------------------------------
1113
1114//
1115// Find the itemString in menuString, and return the item id or wxNOT_FOUND
1116//
1117int wxMenuBar::FindMenuItem(
1118 const wxString& rMenuString
1119, const wxString& rItemString
1120) const
1121{
1122 wxString sMenuLabel = wxStripMenuCodes(rMenuString);
1123 size_t nCount = GetMenuCount(), i;
1124 wxMenuList::const_iterator it;
1125 for (i = 0, it = m_menus.begin(); i < nCount; i++, it++)
1126 {
1127 wxString sTitle = wxStripMenuCodes(m_titles[i]);
1128
1129 if (rMenuString == sTitle)
1130 return (*it)->FindItem(rItemString);
1131 }
1132 return wxNOT_FOUND;
1133} // end of wxMenuBar::FindMenuItem
1134
1135wxMenuItem* wxMenuBar::FindItem(
1136 int nId
1137, wxMenu** ppItemMenu
1138) const
1139{
1140 if (ppItemMenu)
1141 *ppItemMenu = NULL;
1142
1143 wxMenuItem* pItem = NULL;
1144 size_t nCount = GetMenuCount(), i;
1145 wxMenuList::const_iterator it;
1146 for (i = 0, it = m_menus.begin(); !pItem && (i < nCount); i++, it++)
1147 {
1148 pItem = (*it)->FindItem( nId
1149 ,ppItemMenu
1150 );
1151 }
1152 return pItem;
1153} // end of wxMenuBar::FindItem
1154
1155wxMenuItem* wxMenuBar::FindItem(
1156 int nId
1157, ULONG hItem
1158, wxMenu** ppItemMenu
1159) const
1160{
1161 if (ppItemMenu)
1162 *ppItemMenu = NULL;
1163
1164 wxMenuItem* pItem = NULL;
1165 size_t nCount = GetMenuCount(), i;
1166 wxMenuList::const_iterator it;
1167 for (i = 0, it = m_menus.begin(); !pItem && (i < nCount); i++, it++)
1168 {
1169 pItem = (*it)->FindItem( nId
1170 ,hItem
1171 ,ppItemMenu
1172 );
1173 }
1174 return pItem;
1175} // end of wxMenuBar::FindItem
wxWidgets (Impactor)