]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: 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 and Markus Holzem | |
9 | // Licence: wxWindows license | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | // =========================================================================== | |
13 | // declarations | |
14 | // =========================================================================== | |
15 | ||
16 | // --------------------------------------------------------------------------- | |
17 | // headers | |
18 | // --------------------------------------------------------------------------- | |
19 | ||
20 | #ifdef __GNUG__ | |
21 | #pragma implementation "menu.h" | |
22 | #endif | |
23 | ||
24 | // For compilers that support precompilation, includes "wx.h". | |
25 | #include "wx/wxprec.h" | |
26 | ||
27 | #ifdef __BORLANDC__ | |
28 | #pragma hdrstop | |
29 | #endif | |
30 | ||
31 | #if wxUSE_MENUS | |
32 | ||
33 | #ifndef WX_PRECOMP | |
34 | #include "wx/frame.h" | |
35 | #include "wx/menu.h" | |
36 | #include "wx/utils.h" | |
37 | #include "wx/intl.h" | |
38 | #include "wx/log.h" | |
39 | #endif | |
40 | ||
41 | #if wxUSE_OWNER_DRAWN | |
42 | #include "wx/ownerdrw.h" | |
43 | #endif | |
44 | ||
45 | #include "wx/msw/private.h" | |
46 | ||
47 | // other standard headers | |
48 | #include <string.h> | |
49 | ||
50 | // ---------------------------------------------------------------------------- | |
51 | // global variables | |
52 | // ---------------------------------------------------------------------------- | |
53 | ||
54 | extern wxMenu *wxCurrentPopupMenu; | |
55 | ||
56 | // ---------------------------------------------------------------------------- | |
57 | // constants | |
58 | // ---------------------------------------------------------------------------- | |
59 | ||
60 | // the (popup) menu title has this special id | |
61 | static const int idMenuTitle = -2; | |
62 | ||
63 | // ---------------------------------------------------------------------------- | |
64 | // macros | |
65 | // ---------------------------------------------------------------------------- | |
66 | ||
67 | IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler) | |
68 | IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxWindow) | |
69 | ||
70 | // ============================================================================ | |
71 | // implementation | |
72 | // ============================================================================ | |
73 | ||
74 | // --------------------------------------------------------------------------- | |
75 | // wxMenu construction, adding and removing menu items | |
76 | // --------------------------------------------------------------------------- | |
77 | ||
78 | // Construct a menu with optional title (then use append) | |
79 | void wxMenu::Init() | |
80 | { | |
81 | m_doBreak = FALSE; | |
82 | ||
83 | // create the menu | |
84 | m_hMenu = (WXHMENU)CreatePopupMenu(); | |
85 | if ( !m_hMenu ) | |
86 | { | |
87 | wxLogLastError(wxT("CreatePopupMenu")); | |
88 | } | |
89 | ||
90 | // if we have a title, insert it in the beginning of the menu | |
91 | if ( !!m_title ) | |
92 | { | |
93 | Append(idMenuTitle, m_title); | |
94 | AppendSeparator(); | |
95 | } | |
96 | } | |
97 | ||
98 | // The wxWindow destructor will take care of deleting the submenus. | |
99 | wxMenu::~wxMenu() | |
100 | { | |
101 | // we should free Windows resources only if Windows doesn't do it for us | |
102 | // which happens if we're attached to a menubar or a submenu of another | |
103 | // menu | |
104 | if ( !IsAttached() && !GetParent() ) | |
105 | { | |
106 | if ( !::DestroyMenu(GetHmenu()) ) | |
107 | { | |
108 | wxLogLastError(wxT("DestroyMenu")); | |
109 | } | |
110 | } | |
111 | ||
112 | #if wxUSE_ACCEL | |
113 | // delete accels | |
114 | WX_CLEAR_ARRAY(m_accels); | |
115 | #endif // wxUSE_ACCEL | |
116 | } | |
117 | ||
118 | void wxMenu::Break() | |
119 | { | |
120 | // this will take effect during the next call to Append() | |
121 | m_doBreak = TRUE; | |
122 | } | |
123 | ||
124 | #if wxUSE_ACCEL | |
125 | ||
126 | int wxMenu::FindAccel(int id) const | |
127 | { | |
128 | size_t n, count = m_accels.GetCount(); | |
129 | for ( n = 0; n < count; n++ ) | |
130 | { | |
131 | if ( m_accels[n]->m_command == id ) | |
132 | return n; | |
133 | } | |
134 | ||
135 | return wxNOT_FOUND; | |
136 | } | |
137 | ||
138 | void wxMenu::UpdateAccel(wxMenuItem *item) | |
139 | { | |
140 | if ( item->IsSubMenu() ) | |
141 | { | |
142 | wxMenu *submenu = item->GetSubMenu(); | |
143 | wxMenuItemList::Node *node = submenu->GetMenuItems().GetFirst(); | |
144 | while ( node ) | |
145 | { | |
146 | UpdateAccel(node->GetData()); | |
147 | ||
148 | node = node->GetNext(); | |
149 | } | |
150 | } | |
151 | else if ( !item->IsSeparator() ) | |
152 | { | |
153 | // find the (new) accel for this item | |
154 | wxAcceleratorEntry *accel = wxGetAccelFromString(item->GetText()); | |
155 | if ( accel ) | |
156 | accel->m_command = item->GetId(); | |
157 | ||
158 | // find the old one | |
159 | int n = FindAccel(item->GetId()); | |
160 | if ( n == wxNOT_FOUND ) | |
161 | { | |
162 | // no old, add new if any | |
163 | if ( accel ) | |
164 | m_accels.Add(accel); | |
165 | else | |
166 | return; // skipping RebuildAccelTable() below | |
167 | } | |
168 | else | |
169 | { | |
170 | // replace old with new or just remove the old one if no new | |
171 | delete m_accels[n]; | |
172 | if ( accel ) | |
173 | m_accels[n] = accel; | |
174 | else | |
175 | m_accels.Remove(n); | |
176 | } | |
177 | ||
178 | if ( IsAttached() ) | |
179 | { | |
180 | m_menuBar->RebuildAccelTable(); | |
181 | } | |
182 | } | |
183 | //else: it is a separator, they can't have accels, nothing to do | |
184 | } | |
185 | ||
186 | #endif // wxUSE_ACCEL | |
187 | ||
188 | // append a new item or submenu to the menu | |
189 | bool wxMenu::DoInsertOrAppend(wxMenuItem *pItem, size_t pos) | |
190 | { | |
191 | #if wxUSE_ACCEL | |
192 | UpdateAccel(pItem); | |
193 | #endif // wxUSE_ACCEL | |
194 | ||
195 | UINT flags = 0; | |
196 | ||
197 | // if "Break" has just been called, insert a menu break before this item | |
198 | // (and don't forget to reset the flag) | |
199 | if ( m_doBreak ) { | |
200 | flags |= MF_MENUBREAK; | |
201 | m_doBreak = FALSE; | |
202 | } | |
203 | ||
204 | if ( pItem->IsSeparator() ) { | |
205 | flags |= MF_SEPARATOR; | |
206 | } | |
207 | ||
208 | // id is the numeric id for normal menu items and HMENU for submenus as | |
209 | // required by ::AppendMenu() API | |
210 | UINT id; | |
211 | wxMenu *submenu = pItem->GetSubMenu(); | |
212 | if ( submenu != NULL ) { | |
213 | wxASSERT_MSG( submenu->GetHMenu(), wxT("invalid submenu") ); | |
214 | ||
215 | submenu->SetParent(this); | |
216 | ||
217 | id = (UINT)submenu->GetHMenu(); | |
218 | ||
219 | flags |= MF_POPUP; | |
220 | } | |
221 | else { | |
222 | id = pItem->GetId(); | |
223 | } | |
224 | ||
225 | LPCTSTR pData; | |
226 | ||
227 | #if wxUSE_OWNER_DRAWN | |
228 | if ( pItem->IsOwnerDrawn() ) { // want to get {Measure|Draw}Item messages? | |
229 | // item draws itself, pass pointer to it in data parameter | |
230 | flags |= MF_OWNERDRAW; | |
231 | pData = (LPCTSTR)pItem; | |
232 | } | |
233 | else | |
234 | #endif | |
235 | { | |
236 | // menu is just a normal string (passed in data parameter) | |
237 | flags |= MF_STRING; | |
238 | ||
239 | pData = (wxChar*)pItem->GetText().c_str(); | |
240 | } | |
241 | ||
242 | BOOL ok; | |
243 | if ( pos == (size_t)-1 ) | |
244 | { | |
245 | ok = ::AppendMenu(GetHmenu(), flags, id, pData); | |
246 | } | |
247 | else | |
248 | { | |
249 | ok = ::InsertMenu(GetHmenu(), pos, flags | MF_BYPOSITION, id, pData); | |
250 | } | |
251 | ||
252 | if ( !ok ) | |
253 | { | |
254 | wxLogLastError(wxT("Insert or AppendMenu")); | |
255 | ||
256 | return FALSE; | |
257 | } | |
258 | else | |
259 | { | |
260 | // if we just appended the title, highlight it | |
261 | #ifdef __WIN32__ | |
262 | if ( (int)id == idMenuTitle ) | |
263 | { | |
264 | // visually select the menu title | |
265 | MENUITEMINFO mii; | |
266 | mii.cbSize = sizeof(mii); | |
267 | mii.fMask = MIIM_STATE; | |
268 | mii.fState = MFS_DEFAULT; | |
269 | ||
270 | if ( !SetMenuItemInfo(GetHmenu(), (unsigned)id, FALSE, &mii) ) | |
271 | { | |
272 | wxLogLastError(wxT("SetMenuItemInfo")); | |
273 | } | |
274 | } | |
275 | #endif // __WIN32__ | |
276 | ||
277 | // if we're already attached to the menubar, we must update it | |
278 | if ( IsAttached() && m_menuBar->IsAttached() ) | |
279 | { | |
280 | m_menuBar->Refresh(); | |
281 | } | |
282 | ||
283 | return TRUE; | |
284 | } | |
285 | } | |
286 | ||
287 | bool wxMenu::DoAppend(wxMenuItem *item) | |
288 | { | |
289 | return wxMenuBase::DoAppend(item) && DoInsertOrAppend(item); | |
290 | } | |
291 | ||
292 | bool wxMenu::DoInsert(size_t pos, wxMenuItem *item) | |
293 | { | |
294 | return wxMenuBase::DoInsert(pos, item) && DoInsertOrAppend(item, pos); | |
295 | } | |
296 | ||
297 | wxMenuItem *wxMenu::DoRemove(wxMenuItem *item) | |
298 | { | |
299 | // we need to find the items position in the child list | |
300 | size_t pos; | |
301 | wxMenuItemList::Node *node = GetMenuItems().GetFirst(); | |
302 | for ( pos = 0; node; pos++ ) | |
303 | { | |
304 | if ( node->GetData() == item ) | |
305 | break; | |
306 | ||
307 | node = node->GetNext(); | |
308 | } | |
309 | ||
310 | // DoRemove() (unlike Remove) can only be called for existing item! | |
311 | wxCHECK_MSG( node, NULL, wxT("bug in wxMenu::Remove logic") ); | |
312 | ||
313 | #if wxUSE_ACCEL | |
314 | // remove the corresponding accel from the accel table | |
315 | int n = FindAccel(item->GetId()); | |
316 | if ( n != wxNOT_FOUND ) | |
317 | { | |
318 | delete m_accels[n]; | |
319 | ||
320 | m_accels.Remove(n); | |
321 | } | |
322 | //else: this item doesn't have an accel, nothing to do | |
323 | #endif // wxUSE_ACCEL | |
324 | ||
325 | // remove the item from the menu | |
326 | if ( !::RemoveMenu(GetHmenu(), (UINT)pos, MF_BYPOSITION) ) | |
327 | { | |
328 | wxLogLastError(wxT("RemoveMenu")); | |
329 | } | |
330 | ||
331 | if ( IsAttached() && m_menuBar->IsAttached() ) | |
332 | { | |
333 | // otherwise, the chane won't be visible | |
334 | m_menuBar->Refresh(); | |
335 | } | |
336 | ||
337 | // and from internal data structures | |
338 | return wxMenuBase::DoRemove(item); | |
339 | } | |
340 | ||
341 | // --------------------------------------------------------------------------- | |
342 | // accelerator helpers | |
343 | // --------------------------------------------------------------------------- | |
344 | ||
345 | #if wxUSE_ACCEL | |
346 | ||
347 | // create the wxAcceleratorEntries for our accels and put them into provided | |
348 | // array - return the number of accels we have | |
349 | size_t wxMenu::CopyAccels(wxAcceleratorEntry *accels) const | |
350 | { | |
351 | size_t count = GetAccelCount(); | |
352 | for ( size_t n = 0; n < count; n++ ) | |
353 | { | |
354 | *accels++ = *m_accels[n]; | |
355 | } | |
356 | ||
357 | return count; | |
358 | } | |
359 | ||
360 | #endif // wxUSE_ACCEL | |
361 | ||
362 | // --------------------------------------------------------------------------- | |
363 | // set wxMenu title | |
364 | // --------------------------------------------------------------------------- | |
365 | ||
366 | void wxMenu::SetTitle(const wxString& label) | |
367 | { | |
368 | bool hasNoTitle = m_title.IsEmpty(); | |
369 | m_title = label; | |
370 | ||
371 | HMENU hMenu = GetHmenu(); | |
372 | ||
373 | if ( hasNoTitle ) | |
374 | { | |
375 | if ( !label.IsEmpty() ) | |
376 | { | |
377 | if ( !::InsertMenu(hMenu, 0u, MF_BYPOSITION | MF_STRING, | |
378 | (unsigned)idMenuTitle, m_title) || | |
379 | !::InsertMenu(hMenu, 1u, MF_BYPOSITION, (unsigned)-1, NULL) ) | |
380 | { | |
381 | wxLogLastError(wxT("InsertMenu")); | |
382 | } | |
383 | } | |
384 | } | |
385 | else | |
386 | { | |
387 | if ( label.IsEmpty() ) | |
388 | { | |
389 | // remove the title and the separator after it | |
390 | if ( !RemoveMenu(hMenu, 0, MF_BYPOSITION) || | |
391 | !RemoveMenu(hMenu, 0, MF_BYPOSITION) ) | |
392 | { | |
393 | wxLogLastError(wxT("RemoveMenu")); | |
394 | } | |
395 | } | |
396 | else | |
397 | { | |
398 | // modify the title | |
399 | if ( !ModifyMenu(hMenu, 0u, | |
400 | MF_BYPOSITION | MF_STRING, | |
401 | (unsigned)idMenuTitle, m_title) ) | |
402 | { | |
403 | wxLogLastError(wxT("ModifyMenu")); | |
404 | } | |
405 | } | |
406 | } | |
407 | ||
408 | #ifdef __WIN32__ | |
409 | // put the title string in bold face | |
410 | if ( !m_title.IsEmpty() ) | |
411 | { | |
412 | MENUITEMINFO mii; | |
413 | mii.cbSize = sizeof(mii); | |
414 | mii.fMask = MIIM_STATE; | |
415 | mii.fState = MFS_DEFAULT; | |
416 | ||
417 | if ( !SetMenuItemInfo(hMenu, (unsigned)idMenuTitle, FALSE, &mii) ) | |
418 | { | |
419 | wxLogLastError(wxT("SetMenuItemInfo")); | |
420 | } | |
421 | } | |
422 | #endif // Win32 | |
423 | } | |
424 | ||
425 | // --------------------------------------------------------------------------- | |
426 | // event processing | |
427 | // --------------------------------------------------------------------------- | |
428 | ||
429 | bool wxMenu::MSWCommand(WXUINT WXUNUSED(param), WXWORD id) | |
430 | { | |
431 | // ignore commands from the menu title | |
432 | ||
433 | // NB: VC++ generates wrong assembler for `if ( id != idMenuTitle )'!! | |
434 | if ( id != (WXWORD)idMenuTitle ) | |
435 | { | |
436 | // VZ: previosuly, the command int was set to id too which was quite | |
437 | // useless anyhow (as it could be retrieved using GetId()) and | |
438 | // uncompatible with wxGTK, so now we use the command int instead | |
439 | // to pass the checked status | |
440 | SendEvent(id, ::GetMenuState(GetHmenu(), id, MF_BYCOMMAND) & MF_CHECKED); | |
441 | } | |
442 | ||
443 | return TRUE; | |
444 | } | |
445 | ||
446 | // --------------------------------------------------------------------------- | |
447 | // other | |
448 | // --------------------------------------------------------------------------- | |
449 | ||
450 | wxWindow *wxMenu::GetWindow() const | |
451 | { | |
452 | if ( m_invokingWindow != NULL ) | |
453 | return m_invokingWindow; | |
454 | else if ( m_menuBar != NULL) | |
455 | return m_menuBar->GetFrame(); | |
456 | ||
457 | return NULL; | |
458 | } | |
459 | ||
460 | // --------------------------------------------------------------------------- | |
461 | // Menu Bar | |
462 | // --------------------------------------------------------------------------- | |
463 | ||
464 | void wxMenuBar::Init() | |
465 | { | |
466 | m_eventHandler = this; | |
467 | m_hMenu = 0; | |
468 | } | |
469 | ||
470 | wxMenuBar::wxMenuBar() | |
471 | { | |
472 | Init(); | |
473 | } | |
474 | ||
475 | wxMenuBar::wxMenuBar( long WXUNUSED(style) ) | |
476 | { | |
477 | Init(); | |
478 | } | |
479 | ||
480 | wxMenuBar::wxMenuBar(int count, wxMenu *menus[], const wxString titles[]) | |
481 | { | |
482 | Init(); | |
483 | ||
484 | m_titles.Alloc(count); | |
485 | ||
486 | for ( int i = 0; i < count; i++ ) | |
487 | { | |
488 | m_menus.Append(menus[i]); | |
489 | m_titles.Add(titles[i]); | |
490 | ||
491 | menus[i]->Attach(this); | |
492 | } | |
493 | } | |
494 | ||
495 | wxMenuBar::~wxMenuBar() | |
496 | { | |
497 | } | |
498 | ||
499 | // --------------------------------------------------------------------------- | |
500 | // wxMenuBar helpers | |
501 | // --------------------------------------------------------------------------- | |
502 | ||
503 | void wxMenuBar::Refresh() | |
504 | { | |
505 | wxCHECK_RET( IsAttached(), wxT("can't refresh unattached menubar") ); | |
506 | ||
507 | DrawMenuBar(GetHwndOf(GetFrame())); | |
508 | } | |
509 | ||
510 | WXHMENU wxMenuBar::Create() | |
511 | { | |
512 | if ( m_hMenu != 0 ) | |
513 | return m_hMenu; | |
514 | ||
515 | m_hMenu = (WXHMENU)::CreateMenu(); | |
516 | ||
517 | if ( !m_hMenu ) | |
518 | { | |
519 | wxLogLastError(wxT("CreateMenu")); | |
520 | } | |
521 | else | |
522 | { | |
523 | size_t count = GetMenuCount(); | |
524 | for ( size_t i = 0; i < count; i++ ) | |
525 | { | |
526 | if ( !::AppendMenu((HMENU)m_hMenu, MF_POPUP | MF_STRING, | |
527 | (UINT)m_menus[i]->GetHMenu(), | |
528 | m_titles[i]) ) | |
529 | { | |
530 | wxLogLastError(wxT("AppendMenu")); | |
531 | } | |
532 | } | |
533 | } | |
534 | ||
535 | return m_hMenu; | |
536 | } | |
537 | ||
538 | // --------------------------------------------------------------------------- | |
539 | // wxMenuBar functions to work with the top level submenus | |
540 | // --------------------------------------------------------------------------- | |
541 | ||
542 | // NB: we don't support owner drawn top level items for now, if we do these | |
543 | // functions would have to be changed to use wxMenuItem as well | |
544 | ||
545 | void wxMenuBar::EnableTop(size_t pos, bool enable) | |
546 | { | |
547 | wxCHECK_RET( IsAttached(), wxT("doesn't work with unattached menubars") ); | |
548 | ||
549 | int flag = enable ? MF_ENABLED : MF_GRAYED; | |
550 | ||
551 | EnableMenuItem((HMENU)m_hMenu, pos, MF_BYPOSITION | flag); | |
552 | ||
553 | Refresh(); | |
554 | } | |
555 | ||
556 | void wxMenuBar::SetLabelTop(size_t pos, const wxString& label) | |
557 | { | |
558 | wxCHECK_RET( pos < GetMenuCount(), wxT("invalid menu index") ); | |
559 | ||
560 | m_titles[pos] = label; | |
561 | ||
562 | if ( !IsAttached() ) | |
563 | { | |
564 | return; | |
565 | } | |
566 | //else: have to modify the existing menu | |
567 | ||
568 | UINT id; | |
569 | UINT flagsOld = ::GetMenuState((HMENU)m_hMenu, pos, MF_BYPOSITION); | |
570 | if ( flagsOld == 0xFFFFFFFF ) | |
571 | { | |
572 | wxLogLastError(wxT("GetMenuState")); | |
573 | ||
574 | return; | |
575 | } | |
576 | ||
577 | if ( flagsOld & MF_POPUP ) | |
578 | { | |
579 | // HIBYTE contains the number of items in the submenu in this case | |
580 | flagsOld &= 0xff; | |
581 | id = (UINT)::GetSubMenu((HMENU)m_hMenu, pos); | |
582 | } | |
583 | else | |
584 | { | |
585 | id = pos; | |
586 | } | |
587 | ||
588 | if ( ::ModifyMenu(GetHmenu(), pos, MF_BYPOSITION | MF_STRING | flagsOld, | |
589 | id, label) == (int)0xFFFFFFFF ) | |
590 | { | |
591 | wxLogLastError(wxT("ModifyMenu")); | |
592 | } | |
593 | ||
594 | Refresh(); | |
595 | } | |
596 | ||
597 | wxString wxMenuBar::GetLabelTop(size_t pos) const | |
598 | { | |
599 | wxCHECK_MSG( pos < GetMenuCount(), wxEmptyString, | |
600 | wxT("invalid menu index in wxMenuBar::GetLabelTop") ); | |
601 | ||
602 | return m_titles[pos]; | |
603 | } | |
604 | ||
605 | // --------------------------------------------------------------------------- | |
606 | // wxMenuBar construction | |
607 | // --------------------------------------------------------------------------- | |
608 | ||
609 | wxMenu *wxMenuBar::Replace(size_t pos, wxMenu *menu, const wxString& title) | |
610 | { | |
611 | wxMenu *menuOld = wxMenuBarBase::Replace(pos, menu, title); | |
612 | if ( !menuOld ) | |
613 | return FALSE; | |
614 | m_titles[pos] = title; | |
615 | ||
616 | if ( IsAttached() ) | |
617 | { | |
618 | // can't use ModifyMenu() because it deletes the submenu it replaces | |
619 | if ( !::RemoveMenu(GetHmenu(), (UINT)pos, MF_BYPOSITION) ) | |
620 | { | |
621 | wxLogLastError(wxT("RemoveMenu")); | |
622 | } | |
623 | ||
624 | if ( !::InsertMenu(GetHmenu(), (UINT)pos, | |
625 | MF_BYPOSITION | MF_POPUP | MF_STRING, | |
626 | (UINT)GetHmenuOf(menu), title) ) | |
627 | { | |
628 | wxLogLastError(wxT("InsertMenu")); | |
629 | } | |
630 | ||
631 | #if wxUSE_ACCEL | |
632 | if ( menuOld->HasAccels() || menu->HasAccels() ) | |
633 | { | |
634 | // need to rebuild accell table | |
635 | RebuildAccelTable(); | |
636 | } | |
637 | #endif // wxUSE_ACCEL | |
638 | ||
639 | Refresh(); | |
640 | } | |
641 | ||
642 | return menuOld; | |
643 | } | |
644 | ||
645 | bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title) | |
646 | { | |
647 | if ( !wxMenuBarBase::Insert(pos, menu, title) ) | |
648 | return FALSE; | |
649 | ||
650 | m_titles.Insert(title, pos); | |
651 | ||
652 | menu->Attach(this); | |
653 | ||
654 | if ( IsAttached() ) | |
655 | { | |
656 | if ( !::InsertMenu(GetHmenu(), pos, | |
657 | MF_BYPOSITION | MF_POPUP | MF_STRING, | |
658 | (UINT)GetHmenuOf(menu), title) ) | |
659 | { | |
660 | wxLogLastError(wxT("InsertMenu")); | |
661 | } | |
662 | ||
663 | #if wxUSE_ACCEL | |
664 | if ( menu->HasAccels() ) | |
665 | { | |
666 | // need to rebuild accell table | |
667 | RebuildAccelTable(); | |
668 | } | |
669 | #endif // wxUSE_ACCEL | |
670 | ||
671 | Refresh(); | |
672 | } | |
673 | ||
674 | return TRUE; | |
675 | } | |
676 | ||
677 | bool wxMenuBar::Append(wxMenu *menu, const wxString& title) | |
678 | { | |
679 | WXHMENU submenu = menu ? menu->GetHMenu() : 0; | |
680 | wxCHECK_MSG( submenu, FALSE, wxT("can't append invalid menu to menubar") ); | |
681 | ||
682 | if ( !wxMenuBarBase::Append(menu, title) ) | |
683 | return FALSE; | |
684 | ||
685 | // Already done in Append above | |
686 | //menu->Attach(this); | |
687 | ||
688 | m_titles.Add(title); | |
689 | ||
690 | if ( IsAttached() ) | |
691 | { | |
692 | if ( !::AppendMenu(GetHmenu(), MF_POPUP | MF_STRING, | |
693 | (UINT)submenu, title) ) | |
694 | { | |
695 | wxLogLastError(wxT("AppendMenu")); | |
696 | } | |
697 | ||
698 | #if wxUSE_ACCEL | |
699 | if ( menu->HasAccels() ) | |
700 | { | |
701 | // need to rebuild accell table | |
702 | RebuildAccelTable(); | |
703 | } | |
704 | #endif // wxUSE_ACCEL | |
705 | ||
706 | Refresh(); | |
707 | } | |
708 | ||
709 | return TRUE; | |
710 | } | |
711 | ||
712 | wxMenu *wxMenuBar::Remove(size_t pos) | |
713 | { | |
714 | wxMenu *menu = wxMenuBarBase::Remove(pos); | |
715 | if ( !menu ) | |
716 | return NULL; | |
717 | ||
718 | if ( IsAttached() ) | |
719 | { | |
720 | if ( !::RemoveMenu(GetHmenu(), (UINT)pos, MF_BYPOSITION) ) | |
721 | { | |
722 | wxLogLastError(wxT("RemoveMenu")); | |
723 | } | |
724 | ||
725 | menu->Detach(); | |
726 | ||
727 | #if wxUSE_ACCEL | |
728 | if ( menu->HasAccels() ) | |
729 | { | |
730 | // need to rebuild accell table | |
731 | RebuildAccelTable(); | |
732 | } | |
733 | #endif // wxUSE_ACCEL | |
734 | ||
735 | Refresh(); | |
736 | } | |
737 | ||
738 | m_titles.Remove(pos); | |
739 | ||
740 | return menu; | |
741 | } | |
742 | ||
743 | #if wxUSE_ACCEL | |
744 | ||
745 | void wxMenuBar::RebuildAccelTable() | |
746 | { | |
747 | // merge the accelerators of all menus into one accel table | |
748 | size_t nAccelCount = 0; | |
749 | size_t i, count = GetMenuCount(); | |
750 | for ( i = 0; i < count; i++ ) | |
751 | { | |
752 | nAccelCount += m_menus[i]->GetAccelCount(); | |
753 | } | |
754 | ||
755 | if ( nAccelCount ) | |
756 | { | |
757 | wxAcceleratorEntry *accelEntries = new wxAcceleratorEntry[nAccelCount]; | |
758 | ||
759 | nAccelCount = 0; | |
760 | for ( i = 0; i < count; i++ ) | |
761 | { | |
762 | nAccelCount += m_menus[i]->CopyAccels(&accelEntries[nAccelCount]); | |
763 | } | |
764 | ||
765 | m_accelTable = wxAcceleratorTable(nAccelCount, accelEntries); | |
766 | ||
767 | delete [] accelEntries; | |
768 | } | |
769 | } | |
770 | ||
771 | #endif // wxUSE_ACCEL | |
772 | ||
773 | void wxMenuBar::Attach(wxFrame *frame) | |
774 | { | |
775 | wxMenuBarBase::Attach(frame); | |
776 | ||
777 | m_menuBarFrame = frame; | |
778 | ||
779 | #if wxUSE_ACCEL | |
780 | RebuildAccelTable(); | |
781 | #endif // wxUSE_ACCEL | |
782 | } | |
783 | ||
784 | void wxMenuBar::Detach() | |
785 | { | |
786 | m_hMenu = (WXHMENU)NULL; | |
787 | ||
788 | wxMenuBarBase::Detach(); | |
789 | } | |
790 | ||
791 | #endif // wxUSE_MENUS |