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     def AddCheckTool(self, id, bitmap,
 286                      bmpDisabled = wx.NullBitmap,
 287                      shortHelp = '', longHelp = '',
 288                      clientData = None):
 289         '''Add a check tool, i.e. a tool which can be toggled'''
 290         return self.DoAddTool(id, '', bitmap, bmpDisabled, wx.ITEM_CHECK,
 291                               shortHelp, longHelp, clientData)
 292
 293     def AddRadioTool(self, id, bitmap,
 294                      bmpDisabled = wx.NullBitmap,
 295                      shortHelp = '', longHelp = '',
 296                      clientData = None):
 297         '''
 298         Add a radio tool, i.e. a tool which can be toggled and releases any
 299         other toggled radio tools in the same group when it happens
 300         '''
 301         return self.DoAddTool(id, '', bitmap, bmpDisabled, wx.ITEM_RADIO,
 302                               shortHelp, longHelp, clientData)
 303     }
 304
 305     %name(AddToolItem) wxToolBarToolBase *AddTool (wxToolBarToolBase *tool);
 306     %name(InsertToolItem) wxToolBarToolBase *InsertTool (size_t pos, wxToolBarToolBase *tool);
 307
 308     wxToolBarToolBase *AddControl(wxControl *control);
 309     wxToolBarToolBase *InsertControl(size_t pos, wxControl *control);
 310     wxControl *FindControl( int id );
 311
 312     wxToolBarToolBase *AddSeparator();
 313     wxToolBarToolBase *InsertSeparator(size_t pos);
 314
 315     wxToolBarToolBase *RemoveTool(int id);
 316
 317     bool DeleteToolByPos(size_t pos);
 318     bool DeleteTool(int id);
 319     void ClearTools();
 320     bool Realize();
 321
 322     void EnableTool(int id, bool enable);
 323     void ToggleTool(int id, bool toggle);
 324     void SetToggle(int id, bool toggle);
 325
 326
 327     %extend {
 328         // convert the ClientData back to a PyObject
 329         PyObject* GetToolClientData(int id) {
 330             wxPyUserData* udata = (wxPyUserData*)self->GetToolClientData(id);
 331             if (udata) {
 332                 Py_INCREF(udata->m_obj);
 333                 return udata->m_obj;
 334             } else {
 335                 Py_INCREF(Py_None);
 336                 return Py_None;
 337             }
 338         }
 339
 340         void SetToolClientData(int id, PyObject* clientData) {
 341             self->SetToolClientData(id, new wxPyUserData(clientData));
 342         }
 343     }
 344
 345     // returns tool pos, or wxNOT_FOUND if tool isn't found
 346     int GetToolPos(int id) const;
 347
 348     bool GetToolState(int id);
 349     bool GetToolEnabled(int id);
 350     void SetToolShortHelp(int id, const wxString& helpString);
 351     wxString GetToolShortHelp(int id);
 352     void SetToolLongHelp(int id, const wxString& helpString);
 353     wxString GetToolLongHelp(int id);
 354
 355     %name(SetMarginsXY) void SetMargins(int x, int y);
 356     void SetMargins(const wxSize& size);
 357     void SetToolPacking(int packing);
 358     void SetToolSeparation(int separation);
 359     wxSize GetToolMargins();
 360     wxSize GetMargins();
 361     int GetToolPacking();
 362     int GetToolSeparation();
 363
 364     void SetRows(int nRows);
 365     void SetMaxRowsCols(int rows, int cols);
 366     int GetMaxRows();
 367     int GetMaxCols();
 368
 369     void SetToolBitmapSize(const wxSize& size);
 370     wxSize GetToolBitmapSize();
 371     wxSize GetToolSize();
 372
 373     // returns a (non separator) tool containing the point (x, y) or NULL if
 374     // there is no tool at this point (corrdinates are client)
 375     wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y);
 376
 377     // find the tool by id
 378     wxToolBarToolBase *FindById(int toolid) const;
 379
 380     // return True if this is a vertical toolbar, otherwise False
 381     bool IsVertical();
 382 };
 383
 384
 385
 386
 387 class wxToolBar : public wxToolBarBase {
 388 public:
 389     %pythonAppend wxToolBar         "self._setOORInfo(self)"
 390     %pythonAppend wxToolBar()       ""
 391
 392     wxToolBar(wxWindow *parent,
 393               wxWindowID id,
 394               const wxPoint& pos = wxDefaultPosition,
 395               const wxSize& size = wxDefaultSize,
 396               long style = wxNO_BORDER | wxTB_HORIZONTAL,
 397               const wxString& name = wxPyToolBarNameStr);
 398     %name(PreToolBar)wxToolBar();
 399
 400     bool Create(wxWindow *parent,
 401               wxWindowID id,
 402               const wxPoint& pos = wxDefaultPosition,
 403               const wxSize& size = wxDefaultSize,
 404               long style = wxNO_BORDER | wxTB_HORIZONTAL,
 405               const wxString& name = wxPyToolBarNameStr);
 406
 407     wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y);
 408
 409     static wxVisualAttributes
 410     GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
 411 };
 412
 413 //---------------------------------------------------------------------------