wxPython/src/stattool.i

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        stattool.i
   3 // Purpose:     SWIG definitions for StatusBar and ToolBar classes
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     08/24/1998
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 1998 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13
  14 %module stattool
  15
  16 %{
  17 #include "helpers.h"
  18 #include <wx/toolbar.h>
  19 #include <wx/tbarsmpl.h>
  20 %}
  21
  22 //----------------------------------------------------------------------
  23
  24 %include typemaps.i
  25 %include my_typemaps.i
  26
  27 // Import some definitions of other classes, etc.
  28 %import _defs.i
  29 %import misc.i
  30 %import windows.i
  31 %import controls.i
  32
  33 %pragma(python) code = "import wx"
  34 %pragma(python) code = "wxITEM_NORMAL = 0 # predeclare this since wx isn't fully imported yet"
  35
  36 //----------------------------------------------------------------------
  37
  38 %{
  39     // Put some wx default wxChar* values into wxStrings.
  40     DECLARE_DEF_STRING(StatusLineNameStr);
  41     DECLARE_DEF_STRING(ToolBarNameStr);
  42     static const wxString wxPyEmptyString(wxT(""));
  43 %}
  44
  45 //---------------------------------------------------------------------------
  46
  47 class wxStatusBar : public wxWindow {
  48 public:
  49     wxStatusBar(wxWindow* parent, wxWindowID id = -1,
  50                 long style = wxST_SIZEGRIP,
  51                 const wxString& name = wxPyStatusLineNameStr);
  52     %name(wxPreStatusBar)wxStatusBar();
  53
  54     bool Create(wxWindow* parent, wxWindowID id,
  55                 long style = wxST_SIZEGRIP,
  56                 const wxString& name = wxPyStatusLineNameStr);
  57
  58     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
  59     %pragma(python) addtomethod = "wxPreStatusBar:val._setOORInfo(val)"
  60
  61     %addmethods {
  62         %new wxRect* GetFieldRect(long item) {
  63             wxRect* rect= new wxRect;
  64             self->GetFieldRect(item, *rect);
  65             return rect;
  66         }
  67     }
  68     int GetFieldsCount(void);
  69     wxString GetStatusText(int ir = 0);
  70     int GetBorderX();
  71     int GetBorderY();
  72
  73     void SetFieldsCount(int number = 1);
  74     void SetStatusText(const wxString& text, int i = 0);
  75     void SetStatusWidths(int LCOUNT, int* choices);
  76     void PushStatusText(const wxString& text, int number = 0);
  77     void PopStatusText(int number = 0);
  78
  79     void SetMinHeight(int height);
  80 };
  81
  82
  83 //---------------------------------------------------------------------------
  84
  85 class wxToolBarBase;
  86
  87 enum wxToolBarToolStyle
  88 {
  89     wxTOOL_STYLE_BUTTON    = 1,
  90     wxTOOL_STYLE_SEPARATOR = 2,
  91     wxTOOL_STYLE_CONTROL
  92 };
  93
  94
  95
  96 class wxToolBarToolBase : public wxObject {
  97 public:
  98 //      wxToolBarToolBase(wxToolBarBase *tbar = (wxToolBarBase *)NULL,
  99 //                        int id = wxID_SEPARATOR,
 100 //                        const wxString& label = wxEmptyString,
 101 //                        const wxBitmap& bmpNormal = wxNullBitmap,
 102 //                        const wxBitmap& bmpDisabled = wxNullBitmap,
 103 //                        wxItemKind kind = wxITEM_NORMAL,
 104 //                        wxObject *clientData = (wxObject *) NULL,
 105 //                        const wxString& shortHelpString = wxEmptyString,
 106 //                        const wxString& longHelpString = wxEmptyString)
 107 //      ~wxToolBarToolBase();
 108
 109     %addmethods { void Destroy() { delete self; } }
 110
 111     int GetId();
 112     wxControl *GetControl();
 113     wxToolBarBase *GetToolBar();
 114     int IsButton();
 115     int IsControl();
 116     int IsSeparator();
 117     int GetStyle();
 118     wxItemKind GetKind();
 119     bool IsEnabled();
 120     bool IsToggled();
 121     bool CanBeToggled();
 122     const wxBitmap& GetNormalBitmap();
 123     const wxBitmap& GetDisabledBitmap();
 124     wxBitmap GetBitmap();
 125     wxString GetLabel();
 126     wxString GetShortHelp();
 127     wxString GetLongHelp();
 128     bool Enable(bool enable);
 129     void Toggle();
 130     bool SetToggle(bool toggle);
 131     bool SetShortHelp(const wxString& help);
 132     bool SetLongHelp(const wxString& help);
 133     void SetNormalBitmap(const wxBitmap& bmp);
 134     void SetDisabledBitmap(const wxBitmap& bmp);
 135     void SetLabel(const wxString& label);
 136     void Detach();
 137     void Attach(wxToolBarBase *tbar);
 138
 139     //wxObject *GetClientData();
 140     %addmethods {
 141         // convert the ClientData back to a PyObject
 142         PyObject* GetClientData() {
 143             wxPyUserData* udata = (wxPyUserData*)self->GetClientData();
 144             if (udata) {
 145                 Py_INCREF(udata->m_obj);
 146                 return udata->m_obj;
 147             } else {
 148                 Py_INCREF(Py_None);
 149                 return Py_None;
 150             }
 151         }
 152
 153         void SetClientData(PyObject* clientData) {
 154             self->SetClientData(new wxPyUserData(clientData));
 155         }
 156     }
 157
 158     %pragma(python) addtoclass="
 159     GetBitmap1 = GetNormalBitmap
 160     GetBitmap2 = GetDisabledBitmap
 161     SetBitmap1 = SetNormalBitmap
 162     SetBitmap2 = SetDisabledBitmap
 163     "
 164 };
 165
 166
 167
 168 class wxToolBarBase : public wxControl {
 169 public:
 170
 171     // This is an Abstract Base Class
 172
 173     %addmethods {
 174
 175         // The full AddTool() function.  Call it DoAddTool in wxPython and
 176         // implement the other Add methods by calling it.
 177         //
 178         // If bmpDisabled is wxNullBitmap, a shadowed version of the normal bitmap
 179         // is created and used as the disabled image.
 180         wxToolBarToolBase *DoAddTool(int id,
 181                                      const wxString& label,
 182                                      const wxBitmap& bitmap,
 183                                      const wxBitmap& bmpDisabled = wxNullBitmap,
 184                                      wxItemKind kind = wxITEM_NORMAL,
 185                                      const wxString& shortHelp = wxPyEmptyString,
 186                                      const wxString& longHelp = wxPyEmptyString,
 187                                      PyObject *clientData = NULL)
 188         {
 189             wxPyUserData* udata = NULL;
 190             if (clientData && clientData != Py_None)
 191                 udata = new wxPyUserData(clientData);
 192             return self->AddTool(id, label, bitmap, bmpDisabled, kind,
 193                                  shortHelp, longHelp, udata);
 194         }
 195
 196
 197         // Insert the new tool at the given position, if pos == GetToolsCount(), it
 198         // is equivalent to DoAddTool()
 199         wxToolBarToolBase *InsertTool(size_t pos,
 200                                       int id,
 201                                       const wxString& label,
 202                                       const wxBitmap& bitmap,
 203                                       const wxBitmap& bmpDisabled = wxNullBitmap,
 204                                       wxItemKind kind = wxITEM_NORMAL,
 205                                       const wxString& shortHelp = wxPyEmptyString,
 206                                       const wxString& longHelp = wxPyEmptyString,
 207                                       PyObject *clientData = NULL)
 208         {
 209             wxPyUserData* udata = NULL;
 210             if (clientData && clientData != Py_None)
 211                 udata = new wxPyUserData(clientData);
 212             return self->InsertTool(pos, id, label, bitmap, bmpDisabled, kind,
 213                                     shortHelp, longHelp, udata);
 214         }
 215
 216     }
 217
 218
 219     %pragma(python) addtoclass = "
 220     # These match the original Add methods for this class, kept for
 221     # backwards compatibility with versions < 2.3.3.
 222
 223
 224     def AddTool(self, id, bitmap,
 225                 pushedBitmap = wxNullBitmap,
 226                 isToggle = 0,
 227                 clientData = None,
 228                 shortHelpString = '',
 229                 longHelpString = '') :
 230         '''Old style method to add a tool to the toolbar.'''
 231         kind = wx.wxITEM_NORMAL
 232         if isToggle: kind = wx.wxITEM_CHECK
 233         return self.DoAddTool(id, '', bitmap, pushedBitmap, kind,
 234                               shortHelpString, longHelpString, clientData)
 235
 236     def AddSimpleTool(self, id, bitmap,
 237                       shortHelpString = '',
 238                       longHelpString = '',
 239                       isToggle = 0):
 240         '''Old style method to add a tool to the toolbar.'''
 241         kind = wx.wxITEM_NORMAL
 242         if isToggle: kind = wx.wxITEM_CHECK
 243         return self.DoAddTool(id, '', bitmap, wxNullBitmap, kind,
 244                               shortHelpString, longHelpString, None)
 245
 246     def InsertTool(self, pos, id, bitmap,
 247                    pushedBitmap = wxNullBitmap,
 248                    isToggle = 0,
 249                    clientData = None,
 250                    shortHelpString = '',
 251                    longHelpString = ''):
 252         '''Old style method to insert a tool in the toolbar.'''
 253         kind = wx.wxITEM_NORMAL
 254         if isToggle: kind = wx.wxITEM_CHECK
 255         return self.DoInsertTool(pos, id, '', bitmap, pushedBitmap, kind,
 256                                  shortHelpString, longHelpString, clientData)
 257
 258     def InsertSimpleTool(self, pos, id, bitmap,
 259                          shortHelpString = '',
 260                          longHelpString = '',
 261                          isToggle = 0):
 262         '''Old style method to insert a tool in the toolbar.'''
 263         kind = wx.wxITEM_NORMAL
 264         if isToggle: kind = wx.wxITEM_CHECK
 265         return self.DoInsertTool(pos, id, '', bitmap, wxNullBitmap, kind,
 266                                  shortHelpString, longHelpString, None)
 267
 268
 269     # The following are the new toolbar Add methods starting with
 270     # 2.3.3.  They are renamed to have 'Label' in the name so as to be
 271     # able to keep backwards compatibility with using the above
 272     # methods.  Eventually these should migrate to be the methods used
 273     # primarily and loose the 'Label' in the name...
 274
 275     def AddLabelTool(self, id, label, bitmap,
 276                      bmpDisabled = wxNullBitmap,
 277                      kind = wxITEM_NORMAL,
 278                      shortHelp = '', longHelp = '',
 279                      clientData = None):
 280         '''
 281         The full AddTool() function.
 282
 283         If bmpDisabled is wxNullBitmap, a shadowed version of the normal bitmap
 284         is created and used as the disabled image.
 285         '''
 286         return self.DoAddTool(id, label, bitmap, bmpDisabled, kind,
 287                               shortHelp, longHelp, clientData)
 288
 289
 290     def InsertLabelTool(self, pos, id, label, bitmap,
 291                         bmpDisabled = wxNullBitmap,
 292                         kind = wxITEM_NORMAL,
 293                         shortHelp = '', longHelp = '',
 294                         clientData = None):
 295         '''
 296         Insert the new tool at the given position, if pos == GetToolsCount(), it
 297         is equivalent to AddTool()
 298         '''
 299         return self.DoInsertTool(pos, id, label, bitmap, bmpDisabled, kind,
 300                                  shortHelp, longHelp, clientData)
 301
 302     def AddCheckLabelTool(self, id, label, bitmap,
 303                         bmpDisabled = wxNullBitmap,
 304                         shortHelp = '', longHelp = '',
 305                         clientData = None):
 306         '''Add a check tool, i.e. a tool which can be toggled'''
 307         return self.DoAddTool(id, label, bitmap, bmpDisabled, wx.wxITEM_CHECK,
 308                               shortHelp, longHelp, clientData)
 309
 310     def AddRadioLabelTool(self, id, label, bitmap,
 311                           bmpDisabled = wxNullBitmap,
 312                           shortHelp = '', longHelp = '',
 313                           clientData = None):
 314         '''
 315         Add a radio tool, i.e. a tool which can be toggled and releases any
 316         other toggled radio tools in the same group when it happens
 317         '''
 318         return self.DoAddTool(id, label, bitmap, bmpDisabled, wx.wxITEM_RADIO,
 319                               shortHelp, longHelp, clientData)
 320
 321
 322     # For consistency with the backwards compatible methods above, here are
 323     # some non-'Label' versions of the Check and Radio methods
 324     def AddCheckTool(self, id, bitmap,
 325                      bmpDisabled = wxNullBitmap,
 326                      shortHelp = '', longHelp = '',
 327                      clientData = None):
 328         '''Add a check tool, i.e. a tool which can be toggled'''
 329         return self.DoAddTool(id, '', bitmap, bmpDisabled, wx.wxITEM_CHECK,
 330                               shortHelp, longHelp, clientData)
 331
 332     def AddRadioTool(self, id, bitmap,
 333                      bmpDisabled = wxNullBitmap,
 334                      shortHelp = '', longHelp = '',
 335                      clientData = None):
 336         '''
 337         Add a radio tool, i.e. a tool which can be toggled and releases any
 338         other toggled radio tools in the same group when it happens
 339         '''
 340         return self.DoAddTool(id, '', bitmap, bmpDisabled, wx.wxITEM_RADIO,
 341                               shortHelp, longHelp, clientData)
 342     "
 343
 344
 345     wxToolBarToolBase *AddControl(wxControl *control);
 346     wxToolBarToolBase *InsertControl(size_t pos, wxControl *control);
 347
 348     wxToolBarToolBase *AddSeparator();
 349     wxToolBarToolBase *InsertSeparator(size_t pos);
 350
 351     wxToolBarToolBase *RemoveTool(int id);
 352
 353     bool DeleteToolByPos(size_t pos);
 354     bool DeleteTool(int id);
 355     void ClearTools();
 356     bool Realize();
 357
 358     void EnableTool(int id, bool enable);
 359     void ToggleTool(int id, bool toggle);
 360     void SetToggle(int id, bool toggle);
 361
 362
 363     %addmethods {
 364         // convert the ClientData back to a PyObject
 365         PyObject* GetToolClientData(int id) {
 366             wxPyUserData* udata = (wxPyUserData*)self->GetToolClientData(id);
 367             if (udata) {
 368                 Py_INCREF(udata->m_obj);
 369                 return udata->m_obj;
 370             } else {
 371                 Py_INCREF(Py_None);
 372                 return Py_None;
 373             }
 374         }
 375
 376         void SetToolClientData(int id, PyObject* clientData) {
 377             self->SetToolClientData(id, new wxPyUserData(clientData));
 378         }
 379     }
 380
 381
 382     bool GetToolState(int id);
 383     bool GetToolEnabled(int id);
 384     void SetToolShortHelp(int id, const wxString& helpString);
 385     wxString GetToolShortHelp(int id);
 386     void SetToolLongHelp(int id, const wxString& helpString);
 387     wxString GetToolLongHelp(int id);
 388
 389     %name(SetMarginsXY) void SetMargins(int x, int y);
 390     void SetMargins(const wxSize& size);
 391     void SetToolPacking(int packing);
 392     void SetToolSeparation(int separation);
 393     wxSize GetToolMargins();
 394     wxSize GetMargins();
 395     int GetToolPacking();
 396     int GetToolSeparation();
 397
 398     void SetRows(int nRows);
 399     void SetMaxRowsCols(int rows, int cols);
 400     int GetMaxRows();
 401     int GetMaxCols();
 402
 403     void SetToolBitmapSize(const wxSize& size);
 404     wxSize GetToolBitmapSize();
 405     wxSize GetToolSize();
 406
 407     // returns a (non separator) tool containing the point (x, y) or NULL if
 408     // there is no tool at this point (corrdinates are client)
 409     wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y);
 410
 411     // return TRUE if this is a vertical toolbar, otherwise FALSE
 412     bool IsVertical();
 413 };
 414
 415
 416
 417
 418 class wxToolBar : public wxToolBarBase {
 419 public:
 420     wxToolBar(wxWindow *parent,
 421               wxWindowID id,
 422               const wxPoint& pos = wxDefaultPosition,
 423               const wxSize& size = wxDefaultSize,
 424               long style = wxNO_BORDER | wxTB_HORIZONTAL,
 425               const wxString& name = wxPyToolBarNameStr);
 426     %name(wxPreToolBar)wxToolBar();
 427
 428     bool Create(wxWindow *parent,
 429               wxWindowID id,
 430               const wxPoint& pos = wxDefaultPosition,
 431               const wxSize& size = wxDefaultSize,
 432               long style = wxNO_BORDER | wxTB_HORIZONTAL,
 433               const wxString& name = wxPyToolBarNameStr);
 434
 435     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 436     %pragma(python) addtomethod = "wxPreToolBar:val._setOORInfo(val)"
 437
 438     wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y);
 439 };
 440
 441
 442
 443
 444 class wxToolBarSimple : public wxToolBarBase {
 445 public:
 446     wxToolBarSimple(wxWindow *parent,
 447                     wxWindowID id,
 448                     const wxPoint& pos = wxDefaultPosition,
 449                     const wxSize& size = wxDefaultSize,
 450                     long style = wxNO_BORDER | wxTB_HORIZONTAL,
 451                     const wxString& name = wxPyToolBarNameStr);
 452     %name(wxPreToolBarSimple)wxToolBarSimple();
 453
 454     bool Create(wxWindow *parent,
 455                     wxWindowID id,
 456                     const wxPoint& pos = wxDefaultPosition,
 457                     const wxSize& size = wxDefaultSize,
 458                     long style = wxNO_BORDER | wxTB_HORIZONTAL,
 459                     const wxString& name = wxPyToolBarNameStr);
 460
 461     %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
 462     %pragma(python) addtomethod = "wxPreToolBarSimple:val._setOORInfo(val)"
 463
 464     wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y);
 465 };
 466
 467 //---------------------------------------------------------------------------
 468 //---------------------------------------------------------------------------
 469