wxPython/src/_sizers.i

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        _sizers.i
   3 // Purpose:     SWIG interface defs for the Sizers
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     18-Sept-1999
   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 %{
  19 %}
  20
  21 //---------------------------------------------------------------------------
  22 %newgroup;
  23
  24
  25 class wxSizerItem : public wxObject {
  26 public:
  27     wxSizerItem();
  28
  29     %name(SizerItemSpacer) wxSizerItem( int width, int height, int proportion, int flag, int border, wxObject* userData);
  30     %name(SizerItemWindow) wxSizerItem( wxWindow *window, int proportion, int flag, int border, wxObject* userData );
  31     %name(SizerItemSizer) wxSizerItem( wxSizer *sizer, int proportion, int flag, int border, wxObject* userData );
  32
  33     void DeleteWindows();
  34     void DetachSizer();
  35
  36     wxSize GetSize();
  37     wxSize CalcMin();
  38     void SetDimension( wxPoint pos, wxSize size );
  39
  40     wxSize GetMinSize();
  41     void SetInitSize( int x, int y );
  42
  43     %name(SetRatioWH) void SetRatio( int width, int height );
  44     %name(SetRatioSize) void SetRatio( wxSize size );
  45     void SetRatio( float ratio );
  46     float GetRatio();
  47
  48     bool IsWindow();
  49     bool IsSizer();
  50     bool IsSpacer();
  51
  52     void SetProportion( int proportion );
  53     int GetProportion();
  54     %pythoncode { SetOption = SetProportion}
  55     %pythoncode { GetOption = GetProportion}
  56
  57     void SetFlag( int flag );
  58     int GetFlag();
  59
  60     void SetBorder( int border );
  61     int GetBorder();
  62
  63     wxWindow *GetWindow();
  64     void SetWindow( wxWindow *window );
  65
  66     wxSizer *GetSizer();
  67     void SetSizer( wxSizer *sizer );
  68
  69     const wxSize& GetSpacer();
  70     void SetSpacer( const wxSize &size );
  71
  72     void Show( bool show );
  73     bool IsShown();
  74
  75     wxPoint GetPosition();
  76
  77     // wxObject* GetUserData();
  78     %extend {
  79         // Assume that the user data is a wxPyUserData object and return the contents
  80         PyObject* GetUserData() {
  81             wxPyUserData* data = (wxPyUserData*)self->GetUserData();
  82             if (data) {
  83                 Py_INCREF(data->m_obj);
  84                 return data->m_obj;
  85             } else {
  86                 Py_INCREF(Py_None);
  87                 return Py_None;
  88             }
  89         }
  90     }
  91 };
  92
  93
  94 //---------------------------------------------------------------------------
  95
  96 %{
  97 // Figure out the type of the sizer item
  98
  99 struct wxPySizerItemInfo {
 100     wxPySizerItemInfo()
 101         : window(NULL), sizer(NULL), gotSize(False),
 102           size(wxDefaultSize), gotPos(False), pos(-1)
 103     {}
 104
 105     wxWindow* window;
 106     wxSizer*  sizer;
 107     bool      gotSize;
 108     wxSize    size;
 109     bool      gotPos;
 110     int       pos;
 111 };
 112
 113 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
 114
 115     wxPySizerItemInfo info;
 116     wxSize  size;
 117     wxSize* sizePtr = &size;
 118
 119     // Find out what the type of the item is
 120     // try wxWindow
 121     if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
 122         PyErr_Clear();
 123         info.window = NULL;
 124
 125         // try wxSizer
 126         if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
 127             PyErr_Clear();
 128             info.sizer = NULL;
 129
 130             // try wxSize or (w,h)
 131             if ( checkSize && wxSize_helper(item, &sizePtr)) {
 132                 info.size = *sizePtr;
 133                 info.gotSize = True;
 134             }
 135
 136             // or a single int
 137             if (checkIdx && PyInt_Check(item)) {
 138                 info.pos = PyInt_AsLong(item);
 139                 info.gotPos = True;
 140             }
 141         }
 142     }
 143
 144     if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
 145         // no expected type, figure out what kind of error message to generate
 146         if ( !checkSize && !checkIdx )
 147             PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
 148         else if ( checkSize && !checkIdx )
 149             PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
 150         else if ( !checkSize && checkIdx)
 151             PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
 152         else
 153             // can this one happen?
 154             PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
 155     }
 156
 157     return info;
 158 }
 159 %}
 160
 161
 162
 163
 164 class wxSizer : public wxObject {
 165 public:
 166     // wxSizer();      ****  abstract, can't instantiate
 167     // ~wxSizer();
 168
 169     %extend {
 170         void _setOORInfo(PyObject* _self) {
 171             self->SetClientObject(new wxPyOORClientData(_self));
 172         }
 173
 174
 175         void Add(PyObject* item, int proportion=0, int flag=0, int border=0,
 176                   PyObject* userData=NULL) {
 177
 178             wxPyUserData* data = NULL;
 179             bool blocked = wxPyBeginBlockThreads();
 180             wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, True, False);
 181             if ( userData && (info.window || info.sizer || info.gotSize) )
 182                 data = new wxPyUserData(userData);
 183             wxPyEndBlockThreads(blocked);
 184
 185             // Now call the real Add method if a valid item type was found
 186             if ( info.window )
 187                 self->Add(info.window, proportion, flag, border, data);
 188             else if ( info.sizer )
 189                 self->Add(info.sizer, proportion, flag, border, data);
 190             else if (info.gotSize)
 191                 self->Add(info.size.GetWidth(), info.size.GetHeight(),
 192                           proportion, flag, border, data);
 193         }
 194
 195
 196         void Insert(int before, PyObject* item, int proportion=0, int flag=0,
 197                      int border=0, PyObject* userData=NULL) {
 198
 199             wxPyUserData* data = NULL;
 200             bool blocked = wxPyBeginBlockThreads();
 201             wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, True, False);
 202             if ( userData && (info.window || info.sizer || info.gotSize) )
 203                 data = new wxPyUserData(userData);
 204             wxPyEndBlockThreads(blocked);
 205
 206             // Now call the real Insert method if a valid item type was found
 207             if ( info.window )
 208                 self->Insert(before, info.window, proportion, flag, border, data);
 209             else if ( info.sizer )
 210                 self->Insert(before, info.sizer, proportion, flag, border, data);
 211             else if (info.gotSize)
 212                 self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
 213                              proportion, flag, border, data);
 214         }
 215
 216
 217
 218         void Prepend(PyObject* item, int proportion=0, int flag=0, int border=0,
 219                      PyObject* userData=NULL) {
 220
 221             wxPyUserData* data = NULL;
 222             bool blocked = wxPyBeginBlockThreads();
 223             wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, True, False);
 224             if ( userData && (info.window || info.sizer || info.gotSize) )
 225                 data = new wxPyUserData(userData);
 226             wxPyEndBlockThreads(blocked);
 227
 228             // Now call the real Prepend method if a valid item type was found
 229             if ( info.window )
 230                 self->Prepend(info.window, proportion, flag, border, data);
 231             else if ( info.sizer )
 232                 self->Prepend(info.sizer, proportion, flag, border, data);
 233             else if (info.gotSize)
 234                 self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
 235                               proportion, flag, border, data);
 236         }
 237
 238
 239         bool Remove(PyObject* item) {
 240             bool blocked = wxPyBeginBlockThreads();
 241             wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, True);
 242             wxPyEndBlockThreads(blocked);
 243             if ( info.window )
 244                 return self->Remove(info.window);
 245             else if ( info.sizer )
 246                 return self->Remove(info.sizer);
 247             else if ( info.gotPos )
 248                 return self->Remove(info.pos);
 249             else
 250                 return False;
 251         }
 252
 253
 254         void _SetItemMinSize(PyObject* item, const wxSize& size) {
 255             bool blocked = wxPyBeginBlockThreads();
 256             wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, True);
 257             wxPyEndBlockThreads(blocked);
 258             if ( info.window )
 259                 self->SetItemMinSize(info.window, size);
 260             else if ( info.sizer )
 261                 self->SetItemMinSize(info.sizer, size);
 262             else if ( info.gotPos )
 263                 self->SetItemMinSize(info.pos, size);
 264         }
 265     }
 266
 267     %name(AddItem) void Add( wxSizerItem *item );
 268     %name(InsertItem) void Insert( size_t index, wxSizerItem *item );
 269     %name(PrependItem) void Prepend( wxSizerItem *item );
 270
 271
 272     %pythoncode {
 273     def AddMany(self, widgets):
 274         """
 275         AddMany is a convenience method for adding several items
 276         to a sizer at one time.  Simply pass it a list of tuples,
 277         where each tuple consists of the parameters that you
 278         would normally pass to the `Add` method.
 279         """
 280         for childinfo in widgets:
 281             if type(childinfo) != type(()) or (len(childinfo) == 2 and type(childinfo[0]) == type(1)):
 282                 childinfo = (childinfo, )
 283             self.Add(*childinfo)
 284
 285     %# for backwards compatibility only, please do not use in new code
 286     AddWindow     = wx._deprecated(Add, "AddWindow is deprecated, use `Add` instead.")
 287     AddSizer      = wx._deprecated(Add, "AddSizer is deprecated, use `Add` instead.")
 288     AddSpacer     = wx._deprecated(Add, "AddSpacer is deprecated, use `Add` instead.")
 289     PrependWindow = wx._deprecated(Prepend, "PrependWindow is deprecated, use `Prepend` instead.")
 290     PrependSizer  = wx._deprecated(Prepend, "PrependSizer is deprecated, use `Prepend` instead.")
 291     PrependSpacer = wx._deprecated(Prepend, "PrependSpacer is deprecated, use `Prepend` instead.")
 292     InsertWindow  = wx._deprecated(Insert, "InsertWindow is deprecated, use `Insert` instead.")
 293     InsertSizer   = wx._deprecated(Insert, "InsertSizer is deprecated, use `Insert` instead.")
 294     InsertSpacer  = wx._deprecated(Insert, "InsertSpacer is deprecated, use `Insert` instead.")
 295     RemoveWindow  = wx._deprecated(Remove, "RemoveWindow is deprecated, use `Remove` instead.")
 296     RemoveSizer   = wx._deprecated(Remove, "RemoveSizer is deprecated, use `Remove` instead.")
 297     RemovePos     = wx._deprecated(Remove, "RemovePos is deprecated, use `Remove` instead.")
 298
 299
 300     def SetItemMinSize(self, item, *args):
 301         if len(args) == 2:
 302             return self._SetItemMinSize(item, args)
 303         else:
 304             return self._SetItemMinSize(item, args[0])
 305     }
 306
 307
 308     void SetDimension( int x, int y, int width, int height );
 309     void SetMinSize( const wxSize &size );
 310
 311     wxSize GetSize();
 312     wxPoint GetPosition();
 313     wxSize GetMinSize();
 314
 315     %pythoncode {
 316     def GetSizeTuple(self):
 317         return self.GetSize().asTuple()
 318     def GetPositionTuple(self):
 319         return self.GetPosition().asTuple()
 320     def GetMinSizeTuple(self):
 321         return self.GetMinSize().asTuple()
 322     }
 323
 324     virtual void RecalcSizes();
 325     virtual wxSize CalcMin();
 326
 327     void Layout();
 328
 329     wxSize Fit( wxWindow *window );
 330     void FitInside( wxWindow *window );
 331
 332     void SetSizeHints( wxWindow *window );
 333     void SetVirtualSizeHints( wxWindow *window );
 334
 335     void Clear( bool delete_windows=False );
 336     void DeleteWindows();
 337
 338
 339     // wxList& GetChildren();
 340     %extend {
 341         PyObject* GetChildren() {
 342             wxSizerItemList& list = self->GetChildren();
 343             return wxPy_ConvertList(&list);
 344         }
 345     }
 346
 347
 348     // Manage whether individual windows or sub-sizers are considered
 349     // in the layout calculations or not.
 350
 351     %extend {
 352         void Show(PyObject* item, bool show = True) {
 353             bool blocked = wxPyBeginBlockThreads();
 354             wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, False);
 355             wxPyEndBlockThreads(blocked);
 356             if ( info.window )
 357                 self->Show(info.window, show);
 358             else if ( info.sizer )
 359                 self->Show(info.sizer, show);
 360         }
 361
 362
 363         void Hide(PyObject* item) {
 364             bool blocked = wxPyBeginBlockThreads();
 365             wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, False);
 366             wxPyEndBlockThreads(blocked);
 367             if ( info.window )
 368                 self->Hide(info.window);
 369             else if ( info.sizer )
 370                 self->Hide(info.sizer);
 371         }
 372
 373
 374         bool IsShown(PyObject* item) {
 375             bool blocked = wxPyBeginBlockThreads();
 376             wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, False);
 377             wxPyEndBlockThreads(blocked);
 378             if ( info.window )
 379                 return self->IsShown(info.window);
 380             else if ( info.sizer )
 381                 return self->IsShown(info.sizer);
 382             else
 383                 return False;
 384         }
 385     }
 386
 387
 388     // Recursively call wxWindow::Show() on all sizer items.
 389     void ShowItems(bool show);
 390
 391 };
 392
 393
 394 //---------------------------------------------------------------------------
 395 // Use this one for deriving Python classes from
 396 %{
 397 // See pyclasses.h
 398 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
 399 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
 400 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
 401 %}
 402
 403
 404
 405 class wxPySizer : public wxSizer {
 406 public:
 407     %pythonAppend wxPySizer "self._setCallbackInfo(self, PySizer);self._setOORInfo(self)"
 408
 409     wxPySizer();
 410     void _setCallbackInfo(PyObject* self, PyObject* _class);
 411 };
 412
 413
 414 //---------------------------------------------------------------------------
 415 %newgroup;
 416
 417 class  wxBoxSizer : public wxSizer {
 418 public:
 419     %pythonAppend wxBoxSizer "self._setOORInfo(self)"
 420
 421     wxBoxSizer(int orient = wxHORIZONTAL);
 422
 423     int GetOrientation();
 424     void SetOrientation(int orient);
 425     void RecalcSizes();
 426     wxSize CalcMin();
 427 };
 428
 429 //---------------------------------------------------------------------------
 430 %newgroup;
 431
 432 class  wxStaticBoxSizer : public wxBoxSizer {
 433 public:
 434     %pythonAppend wxStaticBoxSizer "self._setOORInfo(self)"
 435
 436     wxStaticBoxSizer(wxStaticBox *box, int orient = wxHORIZONTAL);
 437
 438     wxStaticBox *GetStaticBox();
 439     void RecalcSizes();
 440     wxSize CalcMin();
 441 };
 442
 443 //---------------------------------------------------------------------------
 444 %newgroup;
 445
 446 class wxGridSizer: public wxSizer
 447 {
 448 public:
 449     %pythonAppend wxGridSizer "self._setOORInfo(self)"
 450
 451     wxGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 );
 452
 453     void RecalcSizes();
 454     wxSize CalcMin();
 455
 456     void SetCols( int cols );
 457     void SetRows( int rows );
 458     void SetVGap( int gap );
 459     void SetHGap( int gap );
 460     int GetCols();
 461     int GetRows();
 462     int GetVGap();
 463     int GetHGap();
 464 };
 465
 466 //---------------------------------------------------------------------------
 467 %newgroup;
 468
 469 enum wxFlexSizerGrowMode
 470 {
 471     // don't resize the cells in non-flexible direction at all
 472     wxFLEX_GROWMODE_NONE,
 473
 474     // uniformly resize only the specified ones (default)
 475     wxFLEX_GROWMODE_SPECIFIED,
 476
 477     // uniformly resize all cells
 478     wxFLEX_GROWMODE_ALL
 479 };
 480
 481
 482 class wxFlexGridSizer: public wxGridSizer
 483 {
 484 public:
 485     %pythonAppend wxFlexGridSizer "self._setOORInfo(self)"
 486
 487     wxFlexGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 );
 488
 489     void RecalcSizes();
 490     wxSize CalcMin();
 491
 492     void AddGrowableRow( size_t idx, int proportion = 0  );
 493     void RemoveGrowableRow( size_t idx );
 494     void AddGrowableCol( size_t idx, int proportion = 0  );
 495     void RemoveGrowableCol( size_t idx );
 496
 497     // the sizer cells may grow in both directions, not grow at all or only
 498     // grow in one direction but not the other
 499
 500     // the direction may be wxVERTICAL, wxHORIZONTAL or wxBOTH (default)
 501     void SetFlexibleDirection(int direction);
 502     int GetFlexibleDirection();
 503
 504     // note that the grow mode only applies to the direction which is not
 505     // flexible
 506     void SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode);
 507     wxFlexSizerGrowMode GetNonFlexibleGrowMode();
 508
 509     // Read-only access to the row heights and col widths arrays
 510     const wxArrayInt& GetRowHeights() const;
 511     const wxArrayInt& GetColWidths() const;
 512 };
 513
 514 //---------------------------------------------------------------------------