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