wxPython/src/_toolbar.i

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        _toolbar.i
   3 // Purpose:     SWIG interface defs for wxStatusBar
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     24-Aug-1998
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 2003 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 // Not a %module
  14
  15
  16 //---------------------------------------------------------------------------
  17
  18 MAKE_CONST_WXSTRING_NOSWIG(ToolBarNameStr);
  19
  20
  21 //---------------------------------------------------------------------------
  22 %newgroup;
  23
  24
  25 class wxToolBarBase;
  26
  27 enum wxToolBarToolStyle
  28 {
  29     wxTOOL_STYLE_BUTTON    = 1,
  30     wxTOOL_STYLE_SEPARATOR = 2,
  31     wxTOOL_STYLE_CONTROL
  32 };
  33
  34 enum {
  35     wxTB_HORIZONTAL,
  36     wxTB_VERTICAL,
  37     wxTB_3DBUTTONS,
  38     wxTB_FLAT,
  39     wxTB_DOCKABLE,
  40     wxTB_NOICONS,
  41     wxTB_TEXT,
  42     wxTB_NODIVIDER,
  43     wxTB_NOALIGN,
  44     wxTB_HORZ_LAYOUT,
  45     wxTB_HORZ_TEXT,
  46 };
  47
  48
  49
  50 // wxToolBarTool is a toolbar element.
  51 //
  52 // It has a unique id (except for the separators which always have id -1), the
  53 // style (telling whether it is a normal button, separator or a control), the
  54 // state (toggled or not, enabled or not) and short and long help strings. The
  55 // default implementations use the short help string for the tooltip text which
  56 // is popped up when the mouse pointer enters the tool and the long help string
  57 // for the applications status bar.
  58 class wxToolBarToolBase : public wxObject {
  59 public:
  60 //      wxToolBarToolBase(wxToolBarBase *tbar = (wxToolBarBase *)NULL,
  61 //                        int id = wxID_SEPARATOR,
  62 //                        const wxString& label = wxPyEmptyString,
  63 //                        const wxBitmap& bmpNormal = wxNullBitmap,
  64 //                        const wxBitmap& bmpDisabled = wxNullBitmap,
  65 //                        wxItemKind kind = wxITEM_NORMAL,
  66 //                        wxObject *clientData = (wxObject *) NULL,
  67 //                        const wxString& shortHelpString = wxPyEmptyString,
  68 //                        const wxString& longHelpString = wxPyEmptyString)
  69 //      ~wxToolBarToolBase();
  70
  71     int GetId();
  72     wxControl *GetControl();
  73     wxToolBarBase *GetToolBar();
  74     int IsButton();
  75     int IsControl();
  76     int IsSeparator();
  77     int GetStyle();
  78     wxItemKind GetKind();
  79     bool IsEnabled();
  80     bool IsToggled();
  81     bool CanBeToggled();
  82     const wxBitmap& GetNormalBitmap();
  83     const wxBitmap& GetDisabledBitmap();
  84     wxBitmap GetBitmap();
  85     wxString GetLabel();
  86     wxString GetShortHelp();
  87     wxString GetLongHelp();
  88     bool Enable(bool enable);
  89     void Toggle();
  90     bool SetToggle(bool toggle);
  91     bool SetShortHelp(const wxString& help);
  92     bool SetLongHelp(const wxString& help);
  93     void SetNormalBitmap(const wxBitmap& bmp);
  94     void SetDisabledBitmap(const wxBitmap& bmp);
  95     void SetLabel(const wxString& label);
  96     void Detach();
  97     void Attach(wxToolBarBase *tbar);
  98
  99     //wxObject *GetClientData();
 100     %extend {
 101         // convert the ClientData back to a PyObject
 102         PyObject* GetClientData() {
 103             wxPyUserData* udata = (wxPyUserData*)self->GetClientData();
 104             if (udata) {
 105                 Py_INCREF(udata->m_obj);
 106                 return udata->m_obj;
 107             } else {
 108                 Py_INCREF(Py_None);
 109                 return Py_None;
 110             }
 111         }
 112
 113         void SetClientData(PyObject* clientData) {
 114             self->SetClientData(new wxPyUserData(clientData));
 115         }
 116     }
 117
 118     %pythoncode {
 119     GetBitmap1 = GetNormalBitmap
 120     GetBitmap2 = GetDisabledBitmap
 121     SetBitmap1 = SetNormalBitmap
 122     SetBitmap2 = SetDisabledBitmap
 123     }
 124 };
 125
 126
 127
 128
 129 class wxToolBarBase : public wxControl {
 130 public:
 131
 132     // This is an Abstract Base Class
 133
 134     %extend {
 135
 136         // The full AddTool() function.  Call it DoAddTool in wxPython and
 137         // implement the other Add methods by calling it.
 138         //
 139         // If bmpDisabled is wxNullBitmap, a shadowed version of the normal bitmap
 140         // is created and used as the disabled image.
 141         wxToolBarToolBase *DoAddTool(int id,
 142                                      const wxString& label,
 143                                      const wxBitmap& bitmap,
 144                                      const wxBitmap& bmpDisabled = wxNullBitmap,
 145                                      wxItemKind kind = wxITEM_NORMAL,
 146                                      const wxString& shortHelp = wxPyEmptyString,
 147                                      const wxString& longHelp = wxPyEmptyString,
 148                                      PyObject *clientData = NULL)
 149         {
 150             wxPyUserData* udata = NULL;
 151             if (clientData && clientData != Py_None)
 152                 udata = new wxPyUserData(clientData);
 153             return self->AddTool(id, label, bitmap, bmpDisabled, kind,
 154                                  shortHelp, longHelp, udata);
 155         }
 156
 157
 158         // Insert the new tool at the given position, if pos == GetToolsCount(), it
 159         // is equivalent to DoAddTool()
 160         wxToolBarToolBase *DoInsertTool(size_t pos,
 161                                       int id,
 162                                       const wxString& label,
 163                                       const wxBitmap& bitmap,
 164                                       const wxBitmap& bmpDisabled = wxNullBitmap,
 165                                       wxItemKind kind = wxITEM_NORMAL,
 166                                       const wxString& shortHelp = wxPyEmptyString,
 167                                       const wxString& longHelp = wxPyEmptyString,
 168                                       PyObject *clientData = NULL)
 169         {
 170             wxPyUserData* udata = NULL;
 171             if (clientData && clientData != Py_None)
 172                 udata = new wxPyUserData(clientData);
 173             return self->InsertTool(pos, id, label, bitmap, bmpDisabled, kind,
 174                                     shortHelp, longHelp, udata);
 175         }
 176
 177     }
 178
 179
 180     %pythoncode {
 181     %# These match the original Add methods for this class, kept for
 182     %# backwards compatibility with versions < 2.3.3.
 183
 184
 185     def AddTool(self, id, bitmap,
 186                 pushedBitmap = wx.NullBitmap,
 187                 isToggle = 0,
 188                 clientData = None,
 189                 shortHelpString = '',
 190                 longHelpString = '') :
 191         '''Old style method to add a tool to the toolbar.'''
 192         kind = wx.ITEM_NORMAL
 193         if isToggle: kind = wx.ITEM_CHECK
 194         return self.DoAddTool(id, '', bitmap, pushedBitmap, kind,
 195                               shortHelpString, longHelpString, clientData)
 196
 197     def AddSimpleTool(self, id, bitmap,
 198                       shortHelpString = '',
 199                       longHelpString = '',
 200                       isToggle = 0):
 201         '''Old style method to add a tool to the toolbar.'''
 202         kind = wx.ITEM_NORMAL
 203         if isToggle: kind = wx.ITEM_CHECK
 204         return self.DoAddTool(id, '', bitmap, wx.NullBitmap, kind,
 205                               shortHelpString, longHelpString, None)
 206
 207     def InsertTool(self, pos, id, bitmap,
 208                    pushedBitmap = wx.NullBitmap,
 209                    isToggle = 0,
 210                    clientData = None,
 211                    shortHelpString = '',
 212                    longHelpString = ''):
 213         '''Old style method to insert a tool in the toolbar.'''
 214         kind = wx.ITEM_NORMAL
 215         if isToggle: kind = wx.ITEM_CHECK
 216         return self.DoInsertTool(pos, id, '', bitmap, pushedBitmap, kind,
 217                                  shortHelpString, longHelpString, clientData)
 218
 219     def InsertSimpleTool(self, pos, id, bitmap,
 220                          shortHelpString = '',
 221                          longHelpString = '',
 222                          isToggle = 0):
 223         '''Old style method to insert a tool in the toolbar.'''
 224         kind = wx.ITEM_NORMAL
 225         if isToggle: kind = wx.ITEM_CHECK
 226         return self.DoInsertTool(pos, id, '', bitmap, wx.NullBitmap, kind,
 227                                  shortHelpString, longHelpString, None)
 228
 229
 230     %# The following are the new toolbar Add methods starting with
 231     %# 2.3.3.  They are renamed to have 'Label' in the name so as to be
 232     %# able to keep backwards compatibility with using the above
 233     %# methods.  Eventually these should migrate to be the methods used
 234     %# primarily and lose the 'Label' in the name...
 235
 236     def AddLabelTool(self, id, label, bitmap,
 237                      bmpDisabled = wx.NullBitmap,
 238                      kind = wx.ITEM_NORMAL,
 239                      shortHelp = '', longHelp = '',
 240                      clientData = None):
 241         '''
 242         The full AddTool() function.
 243
 244         If bmpDisabled is wx.NullBitmap, a shadowed version of the normal bitmap
 245         is created and used as the disabled image.
 246         '''
 247         return self.DoAddTool(id, label, bitmap, bmpDisabled, kind,
 248                               shortHelp, longHelp, clientData)
 249
 250
 251     def InsertLabelTool(self, pos, id, label, bitmap,
 252                         bmpDisabled = wx.NullBitmap,
 253                         kind = wx.ITEM_NORMAL,
 254                         shortHelp = '', longHelp = '',
 255                         clientData = None):
 256         '''
 257         Insert the new tool at the given position, if pos == GetToolsCount(), it
 258         is equivalent to AddTool()
 259         '''
 260         return self.DoInsertTool(pos, id, label, bitmap, bmpDisabled, kind,
 261                                  shortHelp, longHelp, clientData)
 262
 263     def AddCheckLabelTool(self, id, label, bitmap,
 264                         bmpDisabled = wx.NullBitmap,
 265                         shortHelp = '', longHelp = '',
 266                         clientData = None):
 267         '''Add a check tool, i.e. a tool which can be toggled'''
 268         return self.DoAddTool(id, label, bitmap, bmpDisabled, wx.ITEM_CHECK,
 269                               shortHelp, longHelp, clientData)
 270
 271     def AddRadioLabelTool(self, id, label, bitmap,
 272                           bmpDisabled = wx.NullBitmap,
 273                           shortHelp = '', longHelp = '',
 274                           clientData = None):
 275         '''
 276         Add a radio tool, i.e. a tool which can be toggled and releases any
 277         other toggled radio tools in the same group when it happens
 278         '''
 279         return self.DoAddTool(id, label, bitmap, bmpDisabled, wx.ITEM_RADIO,
 280                               shortHelp, longHelp, clientData)
 281
 282
 283     %# For consistency with the backwards compatible methods above, here are
 284     %# some non-'Label' versions of the Check and Radio methods
 285
 286     def AddCheckTool(self, id, bitmap,
 287                      bmpDisabled = wx.NullBitmap,
 288                      shortHelp = '', longHelp = '',
 289                      clientData = None):
 290         '''Add a check tool, i.e. a tool which can be toggled'''
 291         return self.DoAddTool(id, '', bitmap, bmpDisabled, wx.ITEM_CHECK,
 292                               shortHelp, longHelp, clientData)
 293
 294     def AddRadioTool(self, id, bitmap,
 295                      bmpDisabled = wx.NullBitmap,
 296                      shortHelp = '', longHelp = '',
 297                      clientData = None):
 298         '''
 299         Add a radio tool, i.e. a tool which can be toggled and releases any
 300         other toggled radio tools in the same group when it happens
 301         '''
 302         return self.DoAddTool(id, '', bitmap, bmpDisabled, wx.ITEM_RADIO,
 303                               shortHelp, longHelp, clientData)
 304     }
 305
 306     %name(AddToolItem) wxToolBarToolBase *AddTool (wxToolBarToolBase *tool);
 307     %name(InsertToolItem) wxToolBarToolBase *InsertTool (size_t pos, wxToolBarToolBase *tool);
 308
 309     wxToolBarToolBase *AddControl(wxControl *control);
 310     wxToolBarToolBase *InsertControl(size_t pos, wxControl *control);
 311     wxControl *FindControl( int id );
 312
 313     wxToolBarToolBase *AddSeparator();
 314     wxToolBarToolBase *InsertSeparator(size_t pos);
 315
 316     wxToolBarToolBase *RemoveTool(int id);
 317
 318     bool DeleteToolByPos(size_t pos);
 319     bool DeleteTool(int id);
 320     void ClearTools();
 321     bool Realize();
 322
 323     void EnableTool(int id, bool enable);
 324     void ToggleTool(int id, bool toggle);
 325     void SetToggle(int id, bool toggle);
 326
 327
 328     %extend {
 329         // convert the ClientData back to a PyObject
 330         PyObject* GetToolClientData(int id) {
 331             wxPyUserData* udata = (wxPyUserData*)self->GetToolClientData(id);
 332             if (udata) {
 333                 Py_INCREF(udata->m_obj);
 334                 return udata->m_obj;
 335             } else {
 336                 Py_INCREF(Py_None);
 337                 return Py_None;
 338             }
 339         }
 340
 341         void SetToolClientData(int id, PyObject* clientData) {
 342             self->SetToolClientData(id, new wxPyUserData(clientData));
 343         }
 344     }
 345
 346     // returns tool pos, or wxNOT_FOUND if tool isn't found
 347     int GetToolPos(int id) const;
 348
 349     bool GetToolState(int id);
 350     bool GetToolEnabled(int id);
 351     void SetToolShortHelp(int id, const wxString& helpString);
 352     wxString GetToolShortHelp(int id);
 353     void SetToolLongHelp(int id, const wxString& helpString);
 354     wxString GetToolLongHelp(int id);
 355
 356     %name(SetMarginsXY) void SetMargins(int x, int y);
 357     void SetMargins(const wxSize& size);
 358     void SetToolPacking(int packing);
 359     void SetToolSeparation(int separation);
 360     wxSize GetToolMargins();
 361     wxSize GetMargins();
 362     int GetToolPacking();
 363     int GetToolSeparation();
 364
 365     void SetRows(int nRows);
 366     void SetMaxRowsCols(int rows, int cols);
 367     int GetMaxRows();
 368     int GetMaxCols();
 369
 370     void SetToolBitmapSize(const wxSize& size);
 371     wxSize GetToolBitmapSize();
 372     wxSize GetToolSize();
 373
 374     // returns a (non separator) tool containing the point (x, y) or NULL if
 375     // there is no tool at this point (corrdinates are client)
 376     wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y);
 377
 378     // find the tool by id
 379     wxToolBarToolBase *FindById(int toolid) const;
 380
 381     // return True if this is a vertical toolbar, otherwise False
 382     bool IsVertical();
 383 };
 384
 385
 386
 387
 388 MustHaveApp(wxToolBar);
 389
 390 class wxToolBar : public wxToolBarBase {
 391 public:
 392     %pythonAppend wxToolBar         "self._setOORInfo(self)"
 393     %pythonAppend wxToolBar()       ""
 394     %typemap(out) wxToolBar*;    // turn off this typemap
 395
 396     wxToolBar(wxWindow *parent,
 397               wxWindowID id=-1,
 398               const wxPoint& pos = wxDefaultPosition,
 399               const wxSize& size = wxDefaultSize,
 400               long style = wxNO_BORDER | wxTB_HORIZONTAL,
 401               const wxString& name = wxPyToolBarNameStr);
 402     %name(PreToolBar)wxToolBar();
 403
 404     // Turn it back on again
 405     %typemap(out) wxToolBar* { $result = wxPyMake_wxObject($1, $owner); }
 406
 407     bool Create(wxWindow *parent,
 408               wxWindowID id=-1,
 409               const wxPoint& pos = wxDefaultPosition,
 410               const wxSize& size = wxDefaultSize,
 411               long style = wxNO_BORDER | wxTB_HORIZONTAL,
 412               const wxString& name = wxPyToolBarNameStr);
 413
 414     wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y);
 415
 416     static wxVisualAttributes
 417     GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
 418 };
 419
 420 //---------------------------------------------------------------------------