]>
Commit | Line | Data |
---|---|---|
1 | /////////////////////////////////////////////////////////////////////////////// | |
2 | // Name: wx/menu.h | |
3 | // Purpose: wxMenu and wxMenuBar classes | |
4 | // Author: Vadim Zeitlin | |
5 | // Modified by: | |
6 | // Created: 26.10.99 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) wxWindows team | |
9 | // Licence: wxWindows license | |
10 | /////////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | #ifndef _WX_MENU_H_BASE_ | |
13 | #define _WX_MENU_H_BASE_ | |
14 | ||
15 | #ifdef __GNUG__ | |
16 | #pragma interface "menubase.h" | |
17 | #endif | |
18 | ||
19 | #if wxUSE_MENUS | |
20 | ||
21 | // ---------------------------------------------------------------------------- | |
22 | // headers | |
23 | // ---------------------------------------------------------------------------- | |
24 | ||
25 | #include "wx/list.h" // for "template" list classes | |
26 | #include "wx/window.h" // base class for wxMenuBar | |
27 | ||
28 | // also include this one to ensure compatibility with old code which only | |
29 | // included wx/menu.h | |
30 | #include "wx/menuitem.h" | |
31 | ||
32 | class WXDLLEXPORT wxMenu; | |
33 | class WXDLLEXPORT wxMenuBarBase; | |
34 | class WXDLLEXPORT wxMenuBar; | |
35 | class WXDLLEXPORT wxMenuItem; | |
36 | ||
37 | // pseudo template list classes | |
38 | WX_DECLARE_EXPORTED_LIST(wxMenu, wxMenuList); | |
39 | WX_DECLARE_EXPORTED_LIST(wxMenuItem, wxMenuItemList); | |
40 | ||
41 | // ---------------------------------------------------------------------------- | |
42 | // conditional compilation | |
43 | // ---------------------------------------------------------------------------- | |
44 | ||
45 | // having callbacks in menus is a wxWin 1.6x feature which should be replaced | |
46 | // with event tables in wxWin 2.xx code - however provide it because many | |
47 | // people like it a lot by default | |
48 | #ifndef wxUSE_MENU_CALLBACK | |
49 | #if WXWIN_COMPATIBILITY_2 | |
50 | #define wxUSE_MENU_CALLBACK 1 | |
51 | #else | |
52 | #define wxUSE_MENU_CALLBACK 0 | |
53 | #endif // WXWIN_COMPATIBILITY_2 | |
54 | #endif // !defined(wxUSE_MENU_CALLBACK) | |
55 | ||
56 | // ---------------------------------------------------------------------------- | |
57 | // wxMenu | |
58 | // ---------------------------------------------------------------------------- | |
59 | ||
60 | class WXDLLEXPORT wxMenuBase : public wxEvtHandler | |
61 | { | |
62 | public: | |
63 | // create a menu | |
64 | static wxMenu *New(const wxString& title = wxEmptyString, long style = 0); | |
65 | ||
66 | // ctors | |
67 | wxMenuBase(const wxString& title, long style = 0) : m_title(title) | |
68 | { Init(style); } | |
69 | wxMenuBase(long style = 0) | |
70 | { Init(style); } | |
71 | ||
72 | // dtor deletes all the menu items we own | |
73 | virtual ~wxMenuBase(); | |
74 | ||
75 | // menu construction | |
76 | // ----------------- | |
77 | ||
78 | // append any kind of item (normal/check/radio/separator) | |
79 | void Append(int id, | |
80 | const wxString& text, | |
81 | const wxString& help = wxEmptyString, | |
82 | wxItemKind kind = wxItem_Normal) | |
83 | { | |
84 | DoAppend(wxMenuItem::New((wxMenu *)this, id, text, help, kind)); | |
85 | } | |
86 | ||
87 | // append a separator to the menu | |
88 | void AppendSeparator() { Append(wxID_SEPARATOR, wxEmptyString); } | |
89 | ||
90 | // append a check item | |
91 | void AppendCheckItem(int id, | |
92 | const wxString& text, | |
93 | const wxString& help = wxEmptyString) | |
94 | { | |
95 | Append(id, text, help, wxItem_Check); | |
96 | } | |
97 | ||
98 | // append a radio item | |
99 | void AppendRadioItem(int id, | |
100 | const wxString& text, | |
101 | const wxString& help = wxEmptyString) | |
102 | { | |
103 | Append(id, text, help, wxItem_Radio); | |
104 | } | |
105 | ||
106 | // append a submenu | |
107 | void Append(int id, | |
108 | const wxString& text, | |
109 | wxMenu *submenu, | |
110 | const wxString& help = wxEmptyString) | |
111 | { | |
112 | DoAppend(wxMenuItem::New((wxMenu *)this, id, text, help, | |
113 | wxItem_Normal, submenu)); | |
114 | } | |
115 | ||
116 | // the most generic form of Append() - append anything | |
117 | void Append(wxMenuItem *item) { DoAppend(item); } | |
118 | ||
119 | // insert a break in the menu (only works when appending the items, not | |
120 | // inserting them) | |
121 | virtual void Break() { } | |
122 | ||
123 | // insert an item before given position | |
124 | bool Insert(size_t pos, wxMenuItem *item); | |
125 | ||
126 | // insert an item before given position | |
127 | void Insert(size_t pos, | |
128 | int id, | |
129 | const wxString& text, | |
130 | const wxString& help = wxEmptyString, | |
131 | wxItemKind kind = wxItem_Normal) | |
132 | { | |
133 | Insert(pos, wxMenuItem::New((wxMenu *)this, id, text, help, kind)); | |
134 | } | |
135 | ||
136 | // insert a separator | |
137 | void InsertSeparator(size_t pos) | |
138 | { | |
139 | Insert(pos, wxMenuItem::New((wxMenu *)this)); | |
140 | } | |
141 | ||
142 | // insert a check item | |
143 | void InsertCheckItem(size_t pos, | |
144 | int id, | |
145 | const wxString& text, | |
146 | const wxString& help = wxEmptyString) | |
147 | { | |
148 | Insert(pos, id, text, help, wxItem_Check); | |
149 | } | |
150 | ||
151 | // insert a radio item | |
152 | void InsertRadioItem(size_t pos, | |
153 | int id, | |
154 | const wxString& text, | |
155 | const wxString& help = wxEmptyString) | |
156 | { | |
157 | Insert(pos, id, text, help, wxItem_Radio); | |
158 | } | |
159 | ||
160 | // insert a submenu | |
161 | void Insert(size_t pos, | |
162 | int id, | |
163 | const wxString& text, | |
164 | wxMenu *submenu, | |
165 | const wxString& help = wxEmptyString) | |
166 | { | |
167 | Insert(pos, wxMenuItem::New((wxMenu *)this, id, text, help, | |
168 | wxItem_Normal, submenu)); | |
169 | } | |
170 | ||
171 | // prepend an item to the menu | |
172 | void Prepend(wxMenuItem *item) | |
173 | { | |
174 | Insert(0u, item); | |
175 | } | |
176 | ||
177 | // prepend any item to the menu | |
178 | void Prepend(int id, | |
179 | const wxString& text, | |
180 | const wxString& help = wxEmptyString, | |
181 | wxItemKind kind = wxItem_Normal) | |
182 | { | |
183 | Insert(0u, id, text, help, kind); | |
184 | } | |
185 | ||
186 | // prepend a separator | |
187 | void PrependSeparator() | |
188 | { | |
189 | InsertSeparator(0u); | |
190 | } | |
191 | ||
192 | // prepend a check item | |
193 | void PrependCheckItem(int id, | |
194 | const wxString& text, | |
195 | const wxString& help = wxEmptyString) | |
196 | { | |
197 | InsertCheckItem(0u, id, text, help); | |
198 | } | |
199 | ||
200 | // prepend a radio item | |
201 | void PrependRadioItem(int id, | |
202 | const wxString& text, | |
203 | const wxString& help = wxEmptyString) | |
204 | { | |
205 | InsertRadioItem(0u, id, text, help); | |
206 | } | |
207 | ||
208 | // prepend a submenu | |
209 | void Prepend(int id, | |
210 | const wxString& text, | |
211 | wxMenu *submenu, | |
212 | const wxString& help = wxEmptyString) | |
213 | { | |
214 | Insert(0u, id, text, submenu, help); | |
215 | } | |
216 | ||
217 | // detach an item from the menu, but don't delete it so that it can be | |
218 | // added back later (but if it's not, the caller is responsible for | |
219 | // deleting it!) | |
220 | wxMenuItem *Remove(int id) { return Remove(FindChildItem(id)); } | |
221 | wxMenuItem *Remove(wxMenuItem *item); | |
222 | ||
223 | // delete an item from the menu (submenus are not destroyed by this | |
224 | // function, see Destroy) | |
225 | bool Delete(int id) { return Delete(FindChildItem(id)); } | |
226 | bool Delete(wxMenuItem *item); | |
227 | ||
228 | // delete the item from menu and destroy it (if it's a submenu) | |
229 | bool Destroy(int id) { return Destroy(FindChildItem(id)); } | |
230 | bool Destroy(wxMenuItem *item); | |
231 | ||
232 | // menu items access | |
233 | // ----------------- | |
234 | ||
235 | // get the items | |
236 | size_t GetMenuItemCount() const { return m_items.GetCount(); } | |
237 | ||
238 | const wxMenuItemList& GetMenuItems() const { return m_items; } | |
239 | wxMenuItemList& GetMenuItems() { return m_items; } | |
240 | ||
241 | // search | |
242 | virtual int FindItem(const wxString& item) const; | |
243 | wxMenuItem* FindItem(int id, wxMenu **menu = NULL) const; | |
244 | ||
245 | // get/set items attributes | |
246 | void Enable(int id, bool enable); | |
247 | bool IsEnabled(int id) const; | |
248 | ||
249 | void Check(int id, bool check); | |
250 | bool IsChecked(int id) const; | |
251 | ||
252 | void SetLabel(int id, const wxString& label); | |
253 | wxString GetLabel(int id) const; | |
254 | ||
255 | virtual void SetHelpString(int id, const wxString& helpString); | |
256 | virtual wxString GetHelpString(int id) const; | |
257 | ||
258 | // misc accessors | |
259 | // -------------- | |
260 | ||
261 | // the title | |
262 | virtual void SetTitle(const wxString& title) { m_title = title; } | |
263 | const wxString GetTitle() const { return m_title; } | |
264 | ||
265 | // event handler | |
266 | void SetEventHandler(wxEvtHandler *handler) { m_eventHandler = handler; } | |
267 | wxEvtHandler *GetEventHandler() const { return m_eventHandler; } | |
268 | ||
269 | // invoking window | |
270 | void SetInvokingWindow(wxWindow *win) { m_invokingWindow = win; } | |
271 | wxWindow *GetInvokingWindow() const { return m_invokingWindow; } | |
272 | ||
273 | // style | |
274 | long GetStyle() const { return m_style; } | |
275 | ||
276 | // implementation helpers | |
277 | // ---------------------- | |
278 | ||
279 | // Updates the UI for a menu and all submenus recursively. source is the | |
280 | // object that has the update event handlers defined for it. If NULL, the | |
281 | // menu or associated window will be used. | |
282 | void UpdateUI(wxEvtHandler* source = (wxEvtHandler*)NULL); | |
283 | ||
284 | // get the menu bar this menu is attached to (may be NULL, always NULL for | |
285 | // popup menus) | |
286 | wxMenuBar *GetMenuBar() const { return m_menuBar; } | |
287 | ||
288 | // called when the menu is attached/detached to/from a menu bar | |
289 | virtual void Attach(wxMenuBarBase *menubar); | |
290 | virtual void Detach(); | |
291 | ||
292 | // is the menu attached to a menu bar (or is it a popup one)? | |
293 | bool IsAttached() const { return m_menuBar != NULL; } | |
294 | ||
295 | // set/get the parent of this menu | |
296 | void SetParent(wxMenu *parent) { m_menuParent = parent; } | |
297 | wxMenu *GetParent() const { return m_menuParent; } | |
298 | ||
299 | // implementation only from now on | |
300 | // ------------------------------- | |
301 | ||
302 | // unlike FindItem(), this function doesn't recurse but only looks through | |
303 | // our direct children and also may return the index of the found child if | |
304 | // pos != NULL | |
305 | wxMenuItem *FindChildItem(int id, size_t *pos = NULL) const; | |
306 | ||
307 | // called to generate a wxCommandEvent, return TRUE if it was processed, | |
308 | // FALSE otherwise | |
309 | // | |
310 | // the checked parameter may have boolean value or -1 for uncheckable items | |
311 | bool SendEvent(int id, int checked = -1); | |
312 | ||
313 | // compatibility: these functions are deprecated, use the new ones instead | |
314 | // ----------------------------------------------------------------------- | |
315 | ||
316 | // use the versions taking wxItem_XXX now instead, they're more readable | |
317 | // and allow adding the radio items as well | |
318 | void Append(int id, | |
319 | const wxString& text, | |
320 | const wxString& help, | |
321 | bool isCheckable) | |
322 | { | |
323 | Append(id, text, help, isCheckable ? wxItem_Check : wxItem_Normal); | |
324 | } | |
325 | ||
326 | void Insert(size_t pos, | |
327 | int id, | |
328 | const wxString& text, | |
329 | const wxString& help, | |
330 | bool isCheckable) | |
331 | { | |
332 | Insert(pos, id, text, help, isCheckable ? wxItem_Check : wxItem_Normal); | |
333 | } | |
334 | ||
335 | void Prepend(int id, | |
336 | const wxString& text, | |
337 | const wxString& help, | |
338 | bool isCheckable) | |
339 | { | |
340 | Insert(0u, id, text, help, isCheckable); | |
341 | } | |
342 | ||
343 | #if WXWIN_COMPATIBILITY | |
344 | bool Enabled(int id) const { return IsEnabled(id); } | |
345 | bool Checked(int id) const { return IsChecked(id); } | |
346 | ||
347 | wxMenuItem* FindItemForId(int itemId, wxMenu **itemMenu) const | |
348 | { return FindItem(itemId, itemMenu); } | |
349 | ||
350 | wxList& GetItems() const { return (wxList &)m_items; } | |
351 | #endif // WXWIN_COMPATIBILITY | |
352 | ||
353 | #if wxUSE_MENU_CALLBACK || defined(__WXMOTIF__) | |
354 | // wxWin 1.6x compatible menu event handling | |
355 | wxFunction GetCallback() const { return m_callback; } | |
356 | void Callback(const wxFunction func) { m_callback = func; } | |
357 | ||
358 | wxFunction m_callback; | |
359 | #endif // wxUSE_MENU_CALLBACK | |
360 | ||
361 | protected: | |
362 | // virtuals to override in derived classes | |
363 | // --------------------------------------- | |
364 | ||
365 | virtual bool DoAppend(wxMenuItem *item); | |
366 | virtual bool DoInsert(size_t pos, wxMenuItem *item); | |
367 | ||
368 | virtual wxMenuItem *DoRemove(wxMenuItem *item); | |
369 | virtual bool DoDelete(wxMenuItem *item); | |
370 | virtual bool DoDestroy(wxMenuItem *item); | |
371 | ||
372 | // helpers | |
373 | // ------- | |
374 | ||
375 | // common part of all ctors | |
376 | void Init(long style); | |
377 | ||
378 | // associate the submenu with this menu | |
379 | void AddSubMenu(wxMenu *submenu); | |
380 | ||
381 | wxMenuBar *m_menuBar; // menubar we belong to or NULL | |
382 | wxMenu *m_menuParent; // parent menu or NULL | |
383 | ||
384 | wxString m_title; // the menu title or label | |
385 | wxMenuItemList m_items; // the list of menu items | |
386 | ||
387 | wxWindow *m_invokingWindow; // for popup menus | |
388 | ||
389 | long m_style; // combination of wxMENU_XXX flags | |
390 | ||
391 | wxEvtHandler *m_eventHandler; // a pluggable in event handler | |
392 | }; | |
393 | ||
394 | // ---------------------------------------------------------------------------- | |
395 | // wxMenuBar | |
396 | // ---------------------------------------------------------------------------- | |
397 | ||
398 | class WXDLLEXPORT wxMenuBarBase : public wxWindow | |
399 | { | |
400 | public: | |
401 | // default ctor | |
402 | wxMenuBarBase(); | |
403 | ||
404 | // dtor will delete all menus we own | |
405 | virtual ~wxMenuBarBase(); | |
406 | ||
407 | // menu bar construction | |
408 | // --------------------- | |
409 | ||
410 | // append a menu to the end of menubar, return TRUE if ok | |
411 | virtual bool Append(wxMenu *menu, const wxString& title); | |
412 | ||
413 | // insert a menu before the given position into the menubar, return TRUE | |
414 | // if inserted ok | |
415 | virtual bool Insert(size_t pos, wxMenu *menu, const wxString& title); | |
416 | ||
417 | // menu bar items access | |
418 | // --------------------- | |
419 | ||
420 | // get the number of menus in the menu bar | |
421 | size_t GetMenuCount() const { return m_menus.GetCount(); } | |
422 | ||
423 | // get the menu at given position | |
424 | wxMenu *GetMenu(size_t pos) const; | |
425 | ||
426 | // replace the menu at given position with another one, returns the | |
427 | // previous menu (which should be deleted by the caller) | |
428 | virtual wxMenu *Replace(size_t pos, wxMenu *menu, const wxString& title); | |
429 | ||
430 | // delete the menu at given position from the menu bar, return the pointer | |
431 | // to the menu (which should be deleted by the caller) | |
432 | virtual wxMenu *Remove(size_t pos); | |
433 | ||
434 | // enable or disable a submenu | |
435 | virtual void EnableTop(size_t pos, bool enable) = 0; | |
436 | ||
437 | // is the menu enabled? | |
438 | virtual bool IsEnabledTop(size_t WXUNUSED(pos)) const { return TRUE; } | |
439 | ||
440 | // get or change the label of the menu at given position | |
441 | virtual void SetLabelTop(size_t pos, const wxString& label) = 0; | |
442 | virtual wxString GetLabelTop(size_t pos) const = 0; | |
443 | ||
444 | // item search | |
445 | // ----------- | |
446 | ||
447 | // by menu and item names, returns wxNOT_FOUND if not found or id of the | |
448 | // found item | |
449 | virtual int FindMenuItem(const wxString& menu, const wxString& item) const; | |
450 | ||
451 | // find item by id (in any menu), returns NULL if not found | |
452 | // | |
453 | // if menu is !NULL, it will be filled with wxMenu this item belongs to | |
454 | virtual wxMenuItem* FindItem(int id, wxMenu **menu = NULL) const; | |
455 | ||
456 | // find menu by its caption, return wxNOT_FOUND on failure | |
457 | int FindMenu(const wxString& title) const; | |
458 | ||
459 | // item access | |
460 | // ----------- | |
461 | ||
462 | // all these functions just use FindItem() and then call an appropriate | |
463 | // method on it | |
464 | // | |
465 | // NB: under MSW, these methods can only be used after the menubar had | |
466 | // been attached to the frame | |
467 | ||
468 | void Enable(int id, bool enable); | |
469 | void Check(int id, bool check); | |
470 | bool IsChecked(int id) const; | |
471 | bool IsEnabled(int id) const; | |
472 | ||
473 | void SetLabel(int id, const wxString &label); | |
474 | wxString GetLabel(int id) const; | |
475 | ||
476 | void SetHelpString(int id, const wxString& helpString); | |
477 | wxString GetHelpString(int id) const; | |
478 | ||
479 | // implementation helpers | |
480 | ||
481 | // get the frame we are attached to (may return NULL) | |
482 | wxFrame *GetFrame() const { return m_menuBarFrame; } | |
483 | ||
484 | // returns TRUE if we're attached to a frame | |
485 | bool IsAttached() const { return GetFrame() != NULL; } | |
486 | ||
487 | // associate the menubar with the frame | |
488 | virtual void Attach(wxFrame *frame); | |
489 | ||
490 | // called before deleting the menubar normally | |
491 | virtual void Detach(); | |
492 | ||
493 | // need to override these ones to avoid virtual function hiding | |
494 | virtual bool Enable(bool enable = TRUE) { return wxWindow::Enable(enable); } | |
495 | virtual void SetLabel(const wxString& s) { wxWindow::SetLabel(s); } | |
496 | virtual wxString GetLabel() const { return wxWindow::GetLabel(); } | |
497 | ||
498 | // don't want menu bars to accept the focus by tabbing to them | |
499 | virtual bool AcceptsFocusFromKeyboard() const { return FALSE; } | |
500 | ||
501 | // compatibility only: these functions are deprecated, use the new ones | |
502 | // instead | |
503 | #if WXWIN_COMPATIBILITY | |
504 | bool Enabled(int id) const { return IsEnabled(id); } | |
505 | bool Checked(int id) const { return IsChecked(id); } | |
506 | ||
507 | wxMenuItem* FindMenuItemById(int id) const | |
508 | { return FindItem(id); } | |
509 | wxMenuItem* FindItemForId(int id, wxMenu **menu = NULL) const | |
510 | { return FindItem(id, menu); } | |
511 | #endif // WXWIN_COMPATIBILITY | |
512 | ||
513 | protected: | |
514 | // the list of all our menus | |
515 | wxMenuList m_menus; | |
516 | ||
517 | // the frame we are attached to (may be NULL) | |
518 | wxFrame *m_menuBarFrame; | |
519 | }; | |
520 | ||
521 | // ---------------------------------------------------------------------------- | |
522 | // include the real class declaration | |
523 | // ---------------------------------------------------------------------------- | |
524 | ||
525 | #ifdef wxUSE_BASE_CLASSES_ONLY | |
526 | #define wxMenuItem wxMenuItemBase | |
527 | #else // !wxUSE_BASE_CLASSES_ONLY | |
528 | #if defined(__WXUNIVERSAL__) | |
529 | #include "wx/univ/menu.h" | |
530 | #elif defined(__WXMSW__) | |
531 | #include "wx/msw/menu.h" | |
532 | #elif defined(__WXMOTIF__) | |
533 | #include "wx/motif/menu.h" | |
534 | #elif defined(__WXGTK__) | |
535 | #include "wx/gtk/menu.h" | |
536 | #elif defined(__WXMAC__) | |
537 | #include "wx/mac/menu.h" | |
538 | #elif defined(__WXPM__) | |
539 | #include "wx/os2/menu.h" | |
540 | #elif defined(__WXSTUBS__) | |
541 | #include "wx/stubs/menu.h" | |
542 | #endif | |
543 | #endif // wxUSE_BASE_CLASSES_ONLY/!wxUSE_BASE_CLASSES_ONLY | |
544 | ||
545 | #endif // wxUSE_MENUS | |
546 | ||
547 | #endif | |
548 | // _WX_MENU_H_BASE_ |