]> 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
added new project file having the new files
[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.RemoveAt(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 char zMsg[128];
269#if wxUSE_ACCEL
270 UpdateAccel(pItem);
271#endif // wxUSE_ACCEL
272
273 //
274 // rItem is the member MENUITEM for the menu items and the submenu's
275 // MENUITEM for submenus as required by ::MM_INSERTITEM message API
276 //
277
278 wxMenu* pSubmenu = pItem->GetSubMenu();
279 MENUITEM& rItem = (pSubmenu != NULL)?pSubmenu->m_vMenuData:
280 pItem->m_vMenuData;
281 if(pSubmenu != NULL)
282 {
283 wxASSERT_MSG(pSubmenu->GetHMenu(), wxT("invalid submenu"));
284 pSubmenu->SetParent(this);
285 rItem.afStyle |= MIS_SUBMENU | MIS_TEXT;
286 }
287
288 //
289 // If "Break" has just been called, insert a menu break before this item
290 // (and don't forget to reset the flag)
291 //
292 if (m_bDoBreak)
293 {
294 rItem.afStyle |= MIS_BREAK;
295 m_bDoBreak = FALSE;
296 }
297
298 if (pItem->IsSeparator())
299 {
300 rItem.afStyle |= MIS_SEPARATOR;
301 }
302
303 //
304 // Id is the numeric id for normal menu items and HMENU for submenus as
305 // required by ::MM_INSERTITEM message API
306 //
307
308 if (pSubmenu != NULL)
309 {
310 wxASSERT_MSG(pSubmenu->GetHMenu(), wxT("invalid submenu"));
311 pSubmenu->SetParent(this);
312
313 rItem.iPosition = 0; // submenus have a 0 position
314 rItem.id = (USHORT)pSubmenu->GetHMenu();
315 rItem.afStyle |= MIS_SUBMENU | MIS_TEXT;
316 }
317 else
318 {
319 rItem.id = pItem->GetId();
320 }
321
322 BYTE* pData;
323
324#if wxUSE_OWNER_DRAWN
325 if (pItem->IsOwnerDrawn())
326 {
327 //
328 // Want to get {Measure|Draw}Item messages?
329 // item draws itself, passing pointer to data doesn't work in OS/2
330 // Will eventually need to set the image handle somewhere into vItem.hItem
331 //
332 rItem.afStyle |= MIS_OWNERDRAW;
333 pData = (BYTE*)NULL;
334 rItem.hItem = (HBITMAP)pItem->GetBitmap().GetHBITMAP();
335 pItem->m_vMenuData.afStyle = rItem.afStyle;
336 pItem->m_vMenuData.hItem = rItem.hItem;
337 }
338 else
339#endif
340 {
341 //
342 // Menu is just a normal string (passed in data parameter)
343 //
344 rItem.afStyle |= MIS_TEXT;
345 pData = (char*)pItem->GetText().c_str();
346 }
347
348 if (nPos == (size_t)-1)
349 {
350 rItem.iPosition = MIT_END;
351 }
352 else
353 {
354 rItem.iPosition = nPos;
355 }
356
357 APIRET rc;
358
359 rc = (APIRET)::WinSendMsg( GetHmenu()
360 ,MM_INSERTITEM
361 ,(MPARAM)&rItem
362 ,(MPARAM)pData
363 );
364#if wxUSE_OWNER_DRAWN
365 if (pItem->IsOwnerDrawn())
366 {
367 BOOL rc;
368 MENUITEM vMenuItem;
369
370 ::WinSendMsg( GetHmenu()
371 ,MM_QUERYITEM
372 ,MPFROM2SHORT( (USHORT)pItem->GetId()
373 ,(USHORT)(FALSE)
374 )
375 ,&vMenuItem
376 );
377 }
378#endif
379 if (rc == MIT_MEMERROR || rc == MIT_ERROR)
380 {
381 vError = ::WinGetLastError(vHabmain);
382 sError = wxPMErrorToStr(vError);
383 wxLogError("Error inserting or appending a menuitem. Error: %s\n", sError);
384 wxLogLastError("Insert or AppendMenu");
385 return FALSE;
386 }
387 else
388 {
389 //
390 // If we're already attached to the menubar, we must update it
391 //
392 if (IsAttached() && m_menuBar->IsAttached())
393 {
394 m_menuBar->Refresh();
395 }
396 return TRUE;
397 }
398 return FALSE;
399} // end of wxMenu::DoInsertOrAppend
400
401bool wxMenu::DoAppend(
402 wxMenuItem* pItem
403)
404{
405 return wxMenuBase::DoAppend(pItem) && DoInsertOrAppend(pItem);
406}
407
408bool wxMenu::DoInsert(
409 size_t nPos
410, wxMenuItem* pItem
411)
412{
413 return ( wxMenuBase::DoInsert( nPos
414 ,pItem) &&
415 DoInsertOrAppend( pItem
416 ,nPos
417 ));
418} // end of wxMenu::DoInsert
419
420wxMenuItem* wxMenu::DoRemove(
421 wxMenuItem* pItem
422)
423{
424 //
425 // We need to find the items position in the child list
426 //
427 size_t nPos;
428 wxMenuItemList::Node* pNode = GetMenuItems().GetFirst();
429
430 for (nPos = 0; pNode; nPos++)
431 {
432 if (pNode->GetData() == pItem)
433 break;
434 pNode = pNode->GetNext();
435 }
436
437 //
438 // DoRemove() (unlike Remove) can only be called for existing item!
439 //
440 wxCHECK_MSG(pNode, NULL, wxT("bug in wxMenu::Remove logic"));
441
442#if wxUSE_ACCEL
443 //
444 // Remove the corresponding accel from the accel table
445 //
446 int n = FindAccel(pItem->GetId());
447
448 if (n != wxNOT_FOUND)
449 {
450 delete m_vAccels[n];
451 m_vAccels.RemoveAt(n);
452 }
453
454#endif // wxUSE_ACCEL
455 //
456 // Remove the item from the menu
457 //
458 ::WinSendMsg( GetHmenu()
459 ,MM_REMOVEITEM
460 ,MPFROM2SHORT(pItem->GetId(), TRUE)
461 ,(MPARAM)0
462 );
463 if (IsAttached() && m_menuBar->IsAttached())
464 {
465 //
466 // Otherwise, the chane won't be visible
467 //
468 m_menuBar->Refresh();
469 }
470
471 //
472 // And from internal data structures
473 //
474 return wxMenuBase::DoRemove(pItem);
475} // end of wxMenu::DoRemove
476
477// ---------------------------------------------------------------------------
478// accelerator helpers
479// ---------------------------------------------------------------------------
480
481#if wxUSE_ACCEL
482
483//
484// Create the wxAcceleratorEntries for our accels and put them into provided
485// array - return the number of accels we have
486//
487size_t wxMenu::CopyAccels(
488 wxAcceleratorEntry* pAccels
489) const
490{
491 size_t nCount = GetAccelCount();
492
493 for (size_t n = 0; n < nCount; n++)
494 {
495 *pAccels++ = *m_vAccels[n];
496 }
497 return nCount;
498} // end of wxMenu::CopyAccels
499
500#endif // wxUSE_ACCEL
501
502// ---------------------------------------------------------------------------
503// set wxMenu title
504// ---------------------------------------------------------------------------
505
506void wxMenu::SetTitle(
507 const wxString& rLabel
508)
509{
510 bool bHasNoTitle = m_title.IsEmpty();
511 HWND hMenu = GetHmenu();
512
513 m_title = rLabel;
514 if (bHasNoTitle)
515 {
516 if (!rLabel.IsEmpty())
517 {
518 if (!::WinSetWindowText(hMenu, rLabel.c_str()))
519 {
520 wxLogLastError("SetMenuTitle");
521 }
522 }
523 }
524 else
525 {
526 if (rLabel.IsEmpty() )
527 {
528 ::WinSendMsg( GetHmenu()
529 ,MM_REMOVEITEM
530 ,MPFROM2SHORT(hMenu, TRUE)
531 ,(MPARAM)0
532 );
533 }
534 else
535 {
536 //
537 // Modify the title
538 //
539 if (!::WinSetWindowText(hMenu, rLabel.c_str()))
540 {
541 wxLogLastError("SetMenuTitle");
542 }
543 }
544 }
545} // end of wxMenu::SetTitle
546
547// ---------------------------------------------------------------------------
548// event processing
549// ---------------------------------------------------------------------------
550
551bool wxMenu::OS2Command(
552 WXUINT WXUNUSED(uParam)
553, WXWORD vId
554)
555{
556 //
557 // Ignore commands from the menu title
558 //
559
560 if (vId != (WXWORD)idMenuTitle)
561 {
562 SendEvent( vId
563 ,(int)::WinSendMsg( GetHmenu()
564 ,MM_QUERYITEMATTR
565 ,(MPARAM)vId
566 ,(MPARAM)MIA_CHECKED
567 )
568 );
569 }
570 return TRUE;
571} // end of wxMenu::OS2Command
572
573// ---------------------------------------------------------------------------
574// other
575// ---------------------------------------------------------------------------
576
577wxWindow* wxMenu::GetWindow() const
578{
579 if (m_invokingWindow != NULL)
580 return m_invokingWindow;
581 else if ( m_menuBar != NULL)
582 return m_menuBar->GetFrame();
583
584 return NULL;
585} // end of wxMenu::GetWindow
586
587// recursive search for item by id
588wxMenuItem* wxMenu::FindItem(
589 int nItemId
590, ULONG hItem
591, wxMenu** ppItemMenu
592) const
593{
594 if ( ppItemMenu )
595 *ppItemMenu = NULL;
596
597 wxMenuItem* pItem = NULL;
598
599 for ( wxMenuItemList::Node *node = m_items.GetFirst();
600 node && !pItem;
601 node = node->GetNext() )
602 {
603 pItem = node->GetData();
604
605 if ( pItem->GetId() == nItemId && pItem->m_vMenuData.hItem == hItem)
606 {
607 if ( ppItemMenu )
608 *ppItemMenu = (wxMenu *)this;
609 }
610 else if ( pItem->IsSubMenu() )
611 {
612 pItem = pItem->GetSubMenu()->FindItem(nItemId, hItem, ppItemMenu);
613 }
614 else
615 {
616 // don't exit the loop
617 pItem = NULL;
618 }
619 }
620 return pItem;
621} // end of wxMenu::FindItem
622
623// ---------------------------------------------------------------------------
624// Menu Bar
625// ---------------------------------------------------------------------------
626
627void wxMenuBar::Init()
628{
629 m_eventHandler = this;
630 m_pMenuBarFrame = NULL;
631 m_hMenu = 0;
632} // end of wxMenuBar::Init
633
634wxMenuBar::wxMenuBar()
635{
636 Init();
637} // end of wxMenuBar::wxMenuBar
638
639wxMenuBar::wxMenuBar(
640 long WXUNUSED(lStyle)
641)
642{
643 Init();
644} // end of wxMenuBar::wxMenuBar
645
646wxMenuBar::wxMenuBar(
647 int nCount
648, wxMenu* vMenus[]
649, const wxString sTitles[]
650)
651{
652 Init();
653
654 m_titles.Alloc(nCount);
655 for ( int i = 0; i < nCount; i++ )
656 {
657 m_menus.Append(vMenus[i]);
658 m_titles.Add(sTitles[i]);
659 vMenus[i]->Attach(this);
660 }
661} // end of wxMenuBar::wxMenuBar
662
663wxMenuBar::~wxMenuBar()
664{
665} // end of wxMenuBar::~wxMenuBar
666
667// ---------------------------------------------------------------------------
668// wxMenuBar helpers
669// ---------------------------------------------------------------------------
670
671void wxMenuBar::Refresh()
672{
673 wxCHECK_RET( IsAttached(), wxT("can't refresh unatteched menubar") );
674
675 WinSendMsg(GetWinHwnd(m_pMenuBarFrame), WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
676} // end of wxMenuBar::Refresh
677
678WXHMENU wxMenuBar::Create()
679{
680 MENUITEM vItem;
681 HWND hFrame;
682
683 if (m_hMenu != 0 )
684 return m_hMenu;
685
686 wxCHECK_MSG(!m_hMenu, TRUE, wxT("menubar already created"));
687
688 //
689 // Menubars should be associated with a frame otherwise they are popups
690 //
691 if (m_pMenuBarFrame != NULL)
692 hFrame = GetWinHwnd(m_pMenuBarFrame);
693 else
694 hFrame = HWND_DESKTOP;
695 //
696 // Create an empty menu and then fill it with insertions
697 //
698 if ((m_hMenu = ::WinCreateWindow( hFrame
699 ,WC_MENU
700 ,(PSZ)NULL
701 ,MS_ACTIONBAR | WS_SYNCPAINT | WS_VISIBLE
702 ,0L
703 ,0L
704 ,0L
705 ,0L
706 ,hFrame
707 ,HWND_TOP
708 ,FID_MENU
709 ,NULL
710 ,NULL
711 )) == 0)
712 {
713 wxLogLastError("WinLoadMenu");
714 }
715 else
716 {
717 size_t nCount = GetMenuCount();
718
719 for (size_t i = 0; i < nCount; i++)
720 {
721 APIRET rc;
722 ERRORID vError;
723 wxString sError;
724 HWND hSubMenu;
725
726 //
727 // Set the parent and owner of the submenues to be the menubar, not the desktop
728 //
729 hSubMenu = m_menus[i]->m_vMenuData.hwndSubMenu;
730 if (!::WinSetParent(m_menus[i]->m_vMenuData.hwndSubMenu, m_hMenu, FALSE))
731 {
732 vError = ::WinGetLastError(vHabmain);
733 sError = wxPMErrorToStr(vError);
734 wxLogError("Error setting parent for submenu. Error: %s\n", sError);
735 return NULLHANDLE;
736 }
737
738 if (!::WinSetOwner(m_menus[i]->m_vMenuData.hwndSubMenu, m_hMenu))
739 {
740 vError = ::WinGetLastError(vHabmain);
741 sError = wxPMErrorToStr(vError);
742 wxLogError("Error setting parent for submenu. Error: %s\n", sError);
743 return NULLHANDLE;
744 }
745
746 m_menus[i]->m_vMenuData.iPosition = i;
747
748 rc = (APIRET)::WinSendMsg(m_hMenu, MM_INSERTITEM, (MPARAM)&m_menus[i]->m_vMenuData, (MPARAM)m_titles[i].c_str());
749 if (rc == MIT_MEMERROR || rc == MIT_ERROR)
750 {
751 vError = ::WinGetLastError(vHabmain);
752 sError = wxPMErrorToStr(vError);
753 wxLogError("Error inserting or appending a menuitem. Error: %s\n", sError);
754 return NULLHANDLE;
755 }
756 }
757 }
758 return m_hMenu;
759} // end of wxMenuBar::Create
760
761// ---------------------------------------------------------------------------
762// wxMenuBar functions to work with the top level submenus
763// ---------------------------------------------------------------------------
764
765//
766// NB: we don't support owner drawn top level items for now, if we do these
767// functions would have to be changed to use wxMenuItem as well
768//
769void wxMenuBar::EnableTop(
770 size_t nPos
771, bool bEnable
772)
773{
774 wxCHECK_RET(IsAttached(), wxT("doesn't work with unattached menubars"));
775 USHORT uFlag = 0;
776 SHORT nId;
777
778 if(!bEnable)
779 uFlag = MIA_DISABLED;
780
781 nId = SHORT1FROMMR(::WinSendMsg((HWND)m_hMenu, MM_ITEMIDFROMPOSITION, MPFROMSHORT(nPos), (MPARAM)0));
782 if (nId == MIT_ERROR)
783 {
784 wxLogLastError("LogLastError");
785 return;
786 }
787 ::WinSendMsg((HWND)m_hMenu, MM_SETITEMATTR, MPFROM2SHORT(nId, TRUE), MPFROM2SHORT(MIA_DISABLED, uFlag));
788 Refresh();
789} // end of wxMenuBar::EnableTop
790
791void wxMenuBar::SetLabelTop(
792 size_t nPos
793, const wxString& rLabel
794)
795{
796 SHORT nId;
797 MENUITEM vItem;
798
799 wxCHECK_RET(nPos < GetMenuCount(), wxT("invalid menu index"));
800 m_titles[nPos] = rLabel;
801
802 if (!IsAttached())
803 {
804 return;
805 }
806
807 nId = SHORT1FROMMR(::WinSendMsg((HWND)m_hMenu, MM_ITEMIDFROMPOSITION, MPFROMSHORT(nPos), (MPARAM)0));
808 if (nId == MIT_ERROR)
809 {
810 wxLogLastError("LogLastError");
811 return;
812 }
813 if(!::WinSendMsg( (HWND)m_hMenu
814 ,MM_QUERYITEM
815 ,MPFROM2SHORT(nId, TRUE)
816 ,MPARAM(&vItem)
817 ))
818 {
819 wxLogLastError("QueryItem");
820 }
821 nId = vItem.id;
822
823 if (::WinSendMsg(GetHmenu(), MM_SETITEMTEXT, MPFROMSHORT(nId), (MPARAM)rLabel.c_str()));
824 {
825 wxLogLastError("ModifyMenu");
826 }
827 Refresh();
828} // end of wxMenuBar::SetLabelTop
829
830wxString wxMenuBar::GetLabelTop(
831 size_t nPos
832) const
833{
834 wxCHECK_MSG( nPos < GetMenuCount(), wxEmptyString,
835 wxT("invalid menu index in wxMenuBar::GetLabelTop") );
836 return m_titles[nPos];
837} // end of wxMenuBar::GetLabelTop
838
839// ---------------------------------------------------------------------------
840// wxMenuBar construction
841// ---------------------------------------------------------------------------
842
843wxMenu* wxMenuBar::Replace(
844 size_t nPos
845, wxMenu* pMenu
846, const wxString& rTitle
847)
848{
849 SHORT nId;
850 wxString Title = TextToLabel(rTitle);
851 wxMenu* pMenuOld = wxMenuBarBase::Replace( nPos
852 ,pMenu
853 ,Title
854 );
855
856
857 nId = SHORT1FROMMR(::WinSendMsg((HWND)m_hMenu, MM_ITEMIDFROMPOSITION, MPFROMSHORT(nPos), (MPARAM)0));
858 if (nId == MIT_ERROR)
859 {
860 wxLogLastError("LogLastError");
861 return NULL;
862 }
863 if (!pMenuOld)
864 return FALSE;
865 m_titles[nPos] = Title;
866 if (IsAttached())
867 {
868 ::WinSendMsg((HWND)m_hMenu, MM_REMOVEITEM, MPFROM2SHORT(nId, TRUE), (MPARAM)0);
869 ::WinSendMsg((HWND)m_hMenu, MM_INSERTITEM, (MPARAM)&pMenu->m_vMenuData, (MPARAM)Title.c_str());
870
871#if wxUSE_ACCEL
872 if (pMenuOld->HasAccels() || pMenu->HasAccels())
873 {
874 //
875 // Need to rebuild accell table
876 //
877 RebuildAccelTable();
878 }
879#endif // wxUSE_ACCEL
880 Refresh();
881 }
882 return pMenuOld;
883} // end of wxMenuBar::Replace
884
885bool wxMenuBar::Insert(
886 size_t nPos
887, wxMenu* pMenu
888, const wxString& rTitle
889)
890{
891 wxString Title = TextToLabel(rTitle);
892 if (!wxMenuBarBase::Insert( nPos
893 ,pMenu
894 ,Title
895 ))
896 return FALSE;
897
898 m_titles.Insert( Title
899 ,nPos
900 );
901
902 pMenu->Attach(this);
903
904 if (IsAttached())
905 {
906 ::WinSendMsg((HWND)m_hMenu, MM_INSERTITEM, (MPARAM)&pMenu->m_vMenuData, (MPARAM)Title.c_str());
907#if wxUSE_ACCEL
908 if (pMenu->HasAccels())
909 {
910 // need to rebuild accell table
911 RebuildAccelTable();
912 }
913#endif // wxUSE_ACCEL
914 Refresh();
915 }
916 return TRUE;
917} // end of wxMenuBar::Insert
918
919bool wxMenuBar::Append(
920 wxMenu* pMenu
921, const wxString& rTitle
922)
923{
924 WXHMENU hSubmenu = pMenu ? pMenu->GetHMenu() : 0;
925
926 wxCHECK_MSG(hSubmenu, FALSE, wxT("can't append invalid menu to menubar"));
927
928 wxString Title = TextToLabel(rTitle);
929 if (!wxMenuBarBase::Append(pMenu, Title))
930 return FALSE;
931
932 pMenu->Attach(this);
933 m_titles.Add(Title);
934
935 if ( IsAttached() )
936 {
937 pMenu->m_vMenuData.iPosition = MIT_END;
938 ::WinSendMsg((HWND)m_hMenu, MM_INSERTITEM, (MPARAM)&pMenu->m_vMenuData, (MPARAM)Title.c_str());
939#if wxUSE_ACCEL
940 if (pMenu->HasAccels())
941 {
942 //
943 // Need to rebuild accell table
944 //
945 RebuildAccelTable();
946 }
947#endif // wxUSE_ACCEL
948 Refresh();
949 }
950 return TRUE;
951} // end of wxMenuBar::Append
952
953wxMenu* wxMenuBar::Remove(
954 size_t nPos
955)
956{
957 wxMenu* pMenu = wxMenuBarBase::Remove(nPos);
958 SHORT nId;
959
960 if (!pMenu)
961 return NULL;
962
963 nId = SHORT1FROMMR(::WinSendMsg((HWND)GetHmenu(), MM_ITEMIDFROMPOSITION, MPFROMSHORT(nPos), (MPARAM)0));
964 if (nId == MIT_ERROR)
965 {
966 wxLogLastError("LogLastError");
967 return NULL;
968 }
969 if (IsAttached())
970 {
971 ::WinSendMsg((HWND)GetHmenu(), MM_REMOVEITEM, MPFROM2SHORT(nId, TRUE), (MPARAM)0);
972 pMenu->Detach();
973
974#if wxUSE_ACCEL
975 if (pMenu->HasAccels())
976 {
977 //
978 // Need to rebuild accell table
979 //
980 RebuildAccelTable();
981 }
982#endif // wxUSE_ACCEL
983 Refresh();
984 }
985 m_titles.Remove(nPos);
986 return pMenu;
987} // end of wxMenuBar::Remove
988
989#if wxUSE_ACCEL
990
991void wxMenuBar::RebuildAccelTable()
992{
993 //
994 // Merge the accelerators of all menus into one accel table
995 //
996 size_t nAccelCount = 0;
997 size_t i;
998 size_t nCount = GetMenuCount();
999
1000 for (i = 0; i < nCount; i++)
1001 {
1002 nAccelCount += m_menus[i]->GetAccelCount();
1003 }
1004
1005 if (nAccelCount)
1006 {
1007 wxAcceleratorEntry* pAccelEntries = new wxAcceleratorEntry[nAccelCount];
1008
1009 nAccelCount = 0;
1010 for (i = 0; i < nCount; i++)
1011 {
1012 nAccelCount += m_menus[i]->CopyAccels(&pAccelEntries[nAccelCount]);
1013 }
1014 m_vAccelTable = wxAcceleratorTable( nAccelCount
1015 ,pAccelEntries
1016 );
1017 delete [] pAccelEntries;
1018 }
1019} // end of wxMenuBar::RebuildAccelTable
1020
1021#endif // wxUSE_ACCEL
1022
1023void wxMenuBar::Attach(
1024 wxFrame* pFrame
1025)
1026{
1027 wxASSERT_MSG( !IsAttached(), wxT("menubar already attached!") );
1028 m_pMenuBarFrame = pFrame;
1029
1030#if wxUSE_ACCEL
1031 RebuildAccelTable();
1032 //
1033 // Ensure the accelerator table is set to the frame (not the client!)
1034 //
1035 if (!::WinSetAccelTable( vHabmain
1036 ,(HWND)pFrame->GetHWND()
1037 ,m_vAccelTable.GetHACCEL()
1038 ))
1039 wxLogLastError("WinSetAccelTable");
1040#endif // wxUSE_ACCEL
1041} // end of wxMenuBar::Attach
1042
1043void wxMenuBar::Detach()
1044{
1045 ::WinDestroyWindow((HWND)m_hMenu);
1046 m_hMenu = (WXHMENU)NULL;
1047 m_pMenuBarFrame = NULL;
1048} // end of wxMenuBar::Detach
1049
1050// ---------------------------------------------------------------------------
1051// wxMenuBar searching for menu items
1052// ---------------------------------------------------------------------------
1053
1054//
1055// Find the itemString in menuString, and return the item id or wxNOT_FOUND
1056//
1057int wxMenuBar::FindMenuItem(
1058 const wxString& rMenuString
1059, const wxString& rItemString
1060) const
1061{
1062 wxString sMenuLabel = wxStripMenuCodes(rMenuString);
1063 size_t nCount = GetMenuCount();
1064
1065 for (size_t i = 0; i < nCount; i++)
1066 {
1067 wxString sTitle = wxStripMenuCodes(m_titles[i]);
1068
1069 if (rMenuString == sTitle)
1070 return m_menus[i]->FindItem(rItemString);
1071 }
1072 return wxNOT_FOUND;
1073} // end of wxMenuBar::FindMenuItem
1074
1075wxMenuItem* wxMenuBar::FindItem(
1076 int nId
1077, wxMenu** ppItemMenu
1078) const
1079{
1080 if (ppItemMenu)
1081 *ppItemMenu = NULL;
1082
1083 wxMenuItem* pItem = NULL;
1084 size_t nCount = GetMenuCount();
1085
1086 for (size_t i = 0; !pItem && (i < nCount); i++)
1087 {
1088 pItem = m_menus[i]->FindItem( nId
1089 ,ppItemMenu
1090 );
1091 }
1092 return pItem;
1093} // end of wxMenuBar::FindItem
1094
1095wxMenuItem* wxMenuBar::FindItem(
1096 int nId
1097, ULONG hItem
1098, wxMenu** ppItemMenu
1099) const
1100{
1101 if (ppItemMenu)
1102 *ppItemMenu = NULL;
1103
1104 wxMenuItem* pItem = NULL;
1105 size_t nCount = GetMenuCount();
1106
1107 for (size_t i = 0; !pItem && (i < nCount); i++)
1108 {
1109 pItem = m_menus[i]->FindItem( nId
1110 ,hItem
1111 ,ppItemMenu
1112 );
1113 }
1114 return pItem;
1115} // end of wxMenuBar::FindItem
1116
wxWidgets (Impactor)