← Back to branch summary

~ubuntu-dev/wxwidgets2.6/upstream-debian

« back to all changes in this revision

Viewing changes to wxPython/src/_menu.i

  • Committer: Daniel T Chen
  • Date: 2006-06-26 10:15:11 UTC
  • Revision ID: crimsun@ubuntu.com-20060626101511-a4436cec4c6d9b35
Import Debian 2.6.3.2.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
wxPython/src/_menu.i
 
1
/////////////////////////////////////////////////////////////////////////////
 
2
// Name:        _menu.i
 
3
// Purpose:     SWIG interface defs for wxMenuBar, wxMenu and wxMenuItem
 
4
//
 
5
// Author:      Robin Dunn
 
6
//
 
7
// Created:     24-June-1997
 
8
// RCS-ID:      $Id: _menu.i,v 1.16.2.1 2006/01/10 21:23:25 RD Exp $
 
9
// Copyright:   (c) 2003 by Total Control Software
 
10
// Licence:     wxWindows license
 
11
/////////////////////////////////////////////////////////////////////////////
 
12
 
 
13
// Not a %module
 
14
 
 
15
 
 
16
//---------------------------------------------------------------------------
 
17
%newgroup
 
18
 
 
19
 
 
20
MustHaveApp(wxMenu);
 
21
 
 
22
class wxMenu : public wxEvtHandler
 
23
{
 
24
public:
 
25
    %pythonAppend wxMenu         "self._setOORInfo(self)"
 
26
    %typemap(out) wxMenu*;    // turn off this typemap
 
27
 
 
28
    wxMenu(const wxString& title = wxPyEmptyString, long style = 0);
 
29
 
 
30
    // Turn it back on again
 
31
    %typemap(out) wxMenu* { $result = wxPyMake_wxObject($1, $owner); }
 
32
 
 
33
    
 
34
    // append any kind of item (normal/check/radio/separator)
 
35
    wxMenuItem* Append(int id,
 
36
                       const wxString& text,
 
37
                       const wxString& help = wxPyEmptyString,
 
38
                       wxItemKind kind = wxITEM_NORMAL);
 
39
 
 
40
    // append a separator to the menu
 
41
    wxMenuItem* AppendSeparator();
 
42
 
 
43
    // append a check item
 
44
    wxMenuItem* AppendCheckItem(int id,
 
45
                                const wxString& text,
 
46
                                const wxString& help = wxPyEmptyString);
 
47
 
 
48
    // append a radio item
 
49
    wxMenuItem* AppendRadioItem(int id,
 
50
                                const wxString& text,
 
51
                                const wxString& help = wxPyEmptyString);
 
52
    // append a submenu
 
53
    %Rename(AppendMenu, wxMenuItem*, Append(int id,
 
54
                                           const wxString& text,
 
55
                                           wxMenu *submenu,
 
56
                                           const wxString& help = wxPyEmptyString));
 
57
 
 
58
    // the most generic form of Append() - append anything
 
59
    %Rename(AppendItem, wxMenuItem*, Append(wxMenuItem *item));
 
60
 
 
61
    // insert a break in the menu (only works when appending the items, not
 
62
    // inserting them)
 
63
    virtual void Break();
 
64
 
 
65
    // insert an item before given position
 
66
    %Rename(InsertItem, wxMenuItem*, Insert(size_t pos, wxMenuItem *item));
 
67
 
 
68
    // insert an item before given position
 
69
    wxMenuItem* Insert(size_t pos,
 
70
                       int id,
 
71
                       const wxString& text,
 
72
                       const wxString& help = wxPyEmptyString,
 
73
                       wxItemKind kind = wxITEM_NORMAL);
 
74
 
 
75
    // insert a separator
 
76
    wxMenuItem* InsertSeparator(size_t pos);
 
77
 
 
78
    // insert a check item
 
79
    wxMenuItem* InsertCheckItem(size_t pos,
 
80
                                int id,
 
81
                                const wxString& text,
 
82
                                const wxString& help = wxPyEmptyString);
 
83
 
 
84
    // insert a radio item
 
85
    wxMenuItem* InsertRadioItem(size_t pos,
 
86
                                int id,
 
87
                                const wxString& text,
 
88
                                const wxString& help = wxPyEmptyString);
 
89
 
 
90
    // insert a submenu
 
91
    %Rename(InsertMenu, wxMenuItem*, Insert(size_t pos,
 
92
                                         int id,
 
93
                                         const wxString& text,
 
94
                                         wxMenu *submenu,
 
95
                                         const wxString& help = wxPyEmptyString));
 
96
 
 
97
    // prepend an item to the menu
 
98
    %Rename(PrependItem,  wxMenuItem*, Prepend(wxMenuItem *item));
 
99
 
 
100
    // prepend any item to the menu
 
101
    wxMenuItem* Prepend(int id,
 
102
                        const wxString& text,
 
103
                        const wxString& help = wxPyEmptyString,
 
104
                        wxItemKind kind = wxITEM_NORMAL);
 
105
 
 
106
    // prepend a separator
 
107
    wxMenuItem*  PrependSeparator();
 
108
 
 
109
    // prepend a check item
 
110
    wxMenuItem* PrependCheckItem(int id,
 
111
                                 const wxString& text,
 
112
                                 const wxString& help = wxPyEmptyString);
 
113
 
 
114
    // prepend a radio item
 
115
    wxMenuItem*  PrependRadioItem(int id,
 
116
                                  const wxString& text,
 
117
                                  const wxString& help = wxPyEmptyString);
 
118
 
 
119
    // prepend a submenu
 
120
    %Rename(PrependMenu,  wxMenuItem*, Prepend(int id,
 
121
                                           const wxString& text,
 
122
                                           wxMenu *submenu,
 
123
                                           const wxString& help = wxPyEmptyString));
 
124
 
 
125
    // detach an item from the menu, but don't delete it so that it can be
 
126
    // added back later (but if it's not, the caller is responsible for
 
127
    // deleting it!)
 
128
    wxMenuItem *Remove(int id);
 
129
    %Rename(RemoveItem,  wxMenuItem*, Remove(wxMenuItem *item));
 
130
 
 
131
    // delete an item from the menu (submenus are not destroyed by this
 
132
    // function, see Destroy)
 
133
    bool Delete(int id);
 
134
    %Rename(DeleteItem,  bool, Delete(wxMenuItem *item));
 
135
 
 
136
    // delete the item from menu and destroy it (if it's a submenu)
 
137
    %extend { void Destroy() { delete self; } }
 
138
    %Rename(DestroyId,  bool, Destroy(int id));
 
139
    %Rename(DestroyItem,  bool, Destroy(wxMenuItem *item));
 
140
 
 
141
 
 
142
    // get the items
 
143
    size_t GetMenuItemCount() const;
 
144
    %extend {
 
145
        PyObject* GetMenuItems() {
 
146
            wxMenuItemList& list = self->GetMenuItems();
 
147
            return wxPy_ConvertList(&list);
 
148
        }
 
149
    }
 
150
 
 
151
    // search
 
152
    int FindItem(const wxString& item) const;
 
153
    %Rename(FindItemById, wxMenuItem*, FindItem(int id /*, wxMenu **menu = NULL*/) const);
 
154
 
 
155
    // find by position
 
156
    wxMenuItem* FindItemByPosition(size_t position) const;
 
157
 
 
158
    // get/set items attributes
 
159
    void Enable(int id, bool enable);
 
160
    bool IsEnabled(int id) const;
 
161
 
 
162
    void Check(int id, bool check);
 
163
    bool IsChecked(int id) const;
 
164
 
 
165
    void SetLabel(int id, const wxString& label);
 
166
    wxString GetLabel(int id) const;
 
167
 
 
168
    virtual void SetHelpString(int id, const wxString& helpString);
 
169
    virtual wxString GetHelpString(int id) const;
 
170
 
 
171
 
 
172
    // the title
 
173
    virtual void SetTitle(const wxString& title);
 
174
    const wxString GetTitle() const;
 
175
 
 
176
    // event handler
 
177
    void SetEventHandler(wxEvtHandler *handler);
 
178
    wxEvtHandler *GetEventHandler() const;
 
179
 
 
180
    // invoking window
 
181
    void SetInvokingWindow(wxWindow *win);
 
182
    wxWindow *GetInvokingWindow() const;
 
183
 
 
184
    // style
 
185
    long GetStyle() const { return m_style; }
 
186
 
 
187
 
 
188
    // Updates the UI for a menu and all submenus recursively. source is the
 
189
    // object that has the update event handlers defined for it. If NULL, the
 
190
    // menu or associated window will be used.
 
191
    void UpdateUI(wxEvtHandler* source = NULL);
 
192
 
 
193
    // get the menu bar this menu is attached to (may be NULL, always NULL for
 
194
    // popup menus)
 
195
    wxMenuBar *GetMenuBar() const;
 
196
 
 
197
// TODO:  Should these be exposed?
 
198
    // called when the menu is attached/detached to/from a menu bar
 
199
    virtual void Attach(wxMenuBarBase *menubar);
 
200
    virtual void Detach();
 
201
 
 
202
    // is the menu attached to a menu bar (or is it a popup one)?
 
203
    bool IsAttached() const;
 
204
 
 
205
    // set/get the parent of this menu
 
206
    void SetParent(wxMenu *parent);
 
207
    wxMenu *GetParent() const;
 
208
};
 
209
 
 
210
//---------------------------------------------------------------------------
 
211
%newgroup
 
212
 
 
213
MustHaveApp(wxMenuBar);
 
214
 
 
215
class wxMenuBar : public wxWindow
 
216
{
 
217
public:
 
218
    %pythonAppend wxMenuBar         "self._setOORInfo(self)"
 
219
    %typemap(out) wxMenuBar*;    // turn off this typemap
 
220
 
 
221
    wxMenuBar(long style = 0);
 
222
 
 
223
    // Turn it back on again
 
224
    %typemap(out) wxMenuBar* { $result = wxPyMake_wxObject($1, $owner); }
 
225
 
 
226
    // append a menu to the end of menubar, return True if ok
 
227
    virtual bool Append(wxMenu *menu, const wxString& title);
 
228
 
 
229
    // insert a menu before the given position into the menubar, return True
 
230
    // if inserted ok
 
231
    virtual bool Insert(size_t pos, wxMenu *menu, const wxString& title);
 
232
 
 
233
 
 
234
    // get the number of menus in the menu bar
 
235
    size_t GetMenuCount() const;
 
236
 
 
237
    // get the menu at given position
 
238
    wxMenu *GetMenu(size_t pos) const;
 
239
 
 
240
    // replace the menu at given position with another one, returns the
 
241
    // previous menu (which should be deleted by the caller)
 
242
    virtual wxMenu *Replace(size_t pos, wxMenu *menu, const wxString& title);
 
243
 
 
244
    // delete the menu at given position from the menu bar, return the pointer
 
245
    // to the menu (which should be  deleted by the caller)
 
246
    virtual wxMenu *Remove(size_t pos);
 
247
 
 
248
    // enable or disable a submenu
 
249
    virtual void EnableTop(size_t pos, bool enable);
 
250
 
 
251
    // is the menu enabled?
 
252
    virtual bool IsEnabledTop(size_t pos) const;
 
253
 
 
254
    // get or change the label of the menu at given position
 
255
    virtual void SetLabelTop(size_t pos, const wxString& label);
 
256
    virtual wxString GetLabelTop(size_t pos) const;
 
257
 
 
258
 
 
259
    // by menu and item names, returns wxNOT_FOUND if not found or id of the
 
260
    // found item
 
261
    virtual int FindMenuItem(const wxString& menu, const wxString& item) const;
 
262
 
 
263
    // find item by id (in any menu), returns NULL if not found
 
264
    //
 
265
    // if menu is !NULL, it will be filled with wxMenu this item belongs to
 
266
    %Rename(FindItemById, virtual wxMenuItem*, FindItem(int id /*, wxMenu **menu = NULL*/) const);
 
267
 
 
268
    // find menu by its caption, return wxNOT_FOUND on failure
 
269
    int FindMenu(const wxString& title);
 
270
 
 
271
 
 
272
    // all these functions just use FindItem() and then call an appropriate
 
273
    // method on it
 
274
    //
 
275
    // NB: under MSW, these methods can only be used after the menubar had
 
276
    //     been attached to the frame
 
277
 
 
278
    void Enable(int id, bool enable);
 
279
    void Check(int id, bool check);
 
280
    bool IsChecked(int id) const;
 
281
    bool IsEnabled(int id) const;
 
282
    // TODO: bool IsEnabled() const;
 
283
     
 
284
    void SetLabel(int id, const wxString &label);
 
285
    wxString GetLabel(int id) const;
 
286
 
 
287
    void SetHelpString(int id, const wxString& helpString);
 
288
    wxString GetHelpString(int id) const;
 
289
 
 
290
 
 
291
    // get the frame we are attached to (may return NULL)
 
292
    wxFrame *GetFrame() const;
 
293
 
 
294
    // returns True if we're attached to a frame
 
295
    bool IsAttached() const;
 
296
 
 
297
    // associate the menubar with the frame
 
298
    virtual void Attach(wxFrame *frame);
 
299
 
 
300
    // called before deleting the menubar normally
 
301
    virtual void Detach();
 
302
 
 
303
#ifdef __WXMAC__
 
304
    static void SetAutoWindowMenu( bool enable );
 
305
    static bool GetAutoWindowMenu();
 
306
#else
 
307
    %extend {
 
308
        static void SetAutoWindowMenu( bool enable ) {}
 
309
        static bool GetAutoWindowMenu() { return false; }
 
310
    }
 
311
#endif
 
312
};
 
313
 
 
314
//---------------------------------------------------------------------------
 
315
%newgroup
 
316
 
 
317
class wxMenuItem : public wxObject {
 
318
public:
 
319
    wxMenuItem(wxMenu* parentMenu=NULL, int id=wxID_ANY,
 
320
               const wxString& text = wxPyEmptyString,
 
321
               const wxString& help = wxPyEmptyString,
 
322
               wxItemKind kind = wxITEM_NORMAL,
 
323
               wxMenu* subMenu = NULL);
 
324
 
 
325
    // the menu we're in
 
326
    wxMenu *GetMenu() const;
 
327
    void SetMenu(wxMenu* menu);
 
328
 
 
329
    // get/set id
 
330
    void SetId(int id);
 
331
    int  GetId() const;
 
332
    bool IsSeparator() const;
 
333
 
 
334
    // the item's text (or name)
 
335
    //
 
336
    // NB: the item's text includes the accelerators and mnemonics info (if
 
337
    //     any), i.e. it may contain '&' or '_' or "\t..." and thus is
 
338
    //     different from the item's label which only contains the text shown
 
339
    //     in the menu
 
340
    virtual void SetText(const wxString& str);
 
341
    wxString GetLabel() const;
 
342
    const wxString& GetText() const;
 
343
 
 
344
    // get the label from text 
 
345
    static wxString GetLabelFromText(const wxString& text);
 
346
 
 
347
    // what kind of menu item we are
 
348
    wxItemKind GetKind() const;
 
349
    void SetKind(wxItemKind kind);
 
350
 
 
351
    virtual void SetCheckable(bool checkable);
 
352
    bool IsCheckable() const;
 
353
 
 
354
    bool IsSubMenu() const;
 
355
    void SetSubMenu(wxMenu *menu);
 
356
    wxMenu *GetSubMenu() const;
 
357
 
 
358
    // state
 
359
    virtual void Enable(bool enable = true);
 
360
    virtual bool IsEnabled() const;
 
361
 
 
362
    virtual void Check(bool check = true);
 
363
    virtual bool IsChecked() const;
 
364
    void Toggle();
 
365
 
 
366
    // help string (displayed in the status bar by default)
 
367
    void SetHelp(const wxString& str);
 
368
    const wxString& GetHelp() const;
 
369
 
 
370
    // get our accelerator or NULL (caller must delete the pointer)
 
371
    virtual wxAcceleratorEntry *GetAccel() const;
 
372
 
 
373
    // set the accel for this item - this may also be done indirectly with
 
374
    // SetText()
 
375
    virtual void SetAccel(wxAcceleratorEntry *accel);
 
376
 
 
377
    void SetBitmap(const wxBitmap& bitmap);
 
378
    const wxBitmap& GetBitmap();
 
379
 
 
380
    // wxOwnerDrawn methods
 
381
#ifdef __WXMSW__
 
382
    void SetFont(const wxFont& font);
 
383
    wxFont GetFont();
 
384
    void SetTextColour(const wxColour& colText);
 
385
    wxColour GetTextColour();
 
386
    void SetBackgroundColour(const wxColour& colBack);
 
387
    wxColour GetBackgroundColour();
 
388
    void SetBitmaps(const wxBitmap& bmpChecked,
 
389
                    const wxBitmap& bmpUnchecked = wxNullBitmap);
 
390
    
 
391
    void SetDisabledBitmap( const wxBitmap& bmpDisabled );
 
392
    const wxBitmap& GetDisabledBitmap() const;
 
393
   
 
394
    void SetMarginWidth(int nWidth);
 
395
    int GetMarginWidth();
 
396
    static int GetDefaultMarginWidth();
 
397
    bool IsOwnerDrawn();
 
398
 
 
399
    // switch on/off owner-drawing the item
 
400
    void SetOwnerDrawn(bool ownerDrawn = true);
 
401
    void ResetOwnerDrawn();
 
402
#else
 
403
    %extend {
 
404
        void SetFont(const wxFont& font) {}
 
405
        wxFont GetFont() { return wxNullFont; }
 
406
        void SetTextColour(const wxColour& colText) {}
 
407
        wxColour GetTextColour() { return wxNullColour; }
 
408
        void SetBackgroundColour(const wxColour& colBack) {}
 
409
        wxColour GetBackgroundColour() { return wxNullColour; }
 
410
        
 
411
        void SetBitmaps(const wxBitmap& bmpChecked,
 
412
                        const wxBitmap& bmpUnchecked = wxNullBitmap)
 
413
            { self->SetBitmap( bmpChecked ); }
 
414
    
 
415
        void SetDisabledBitmap( const wxBitmap& bmpDisabled ) {}
 
416
        const wxBitmap& GetDisabledBitmap() const { return wxNullBitmap; }
 
417
   
 
418
        void SetMarginWidth(int nWidth) {}
 
419
        int GetMarginWidth() { return 0; }
 
420
        static int GetDefaultMarginWidth() { return 0; }
 
421
        bool IsOwnerDrawn() { return false; }
 
422
        void SetOwnerDrawn(bool ownerDrawn = true) {}
 
423
        void ResetOwnerDrawn() {}
 
424
    }
 
425
#endif
 
426
};
 
427
 
 
428
//---------------------------------------------------------------------------
 
429
//---------------------------------------------------------------------------