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         bool Detach(PyObject* item) {
 255             bool blocked = wxPyBeginBlockThreads();
 256             wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, True);
 257             wxPyEndBlockThreads(blocked);
 258             if ( info.window )
 259                 return self->Detach(info.window);
 260             else if ( info.sizer )
 261                 return self->Detach(info.sizer);
 262             else if ( info.gotPos )
 263                 return self->Detach(info.pos);
 264             else
 265                 return False;
 266         }
 267
 268
 269         void _SetItemMinSize(PyObject* item, const wxSize& size) {
 270             bool blocked = wxPyBeginBlockThreads();
 271             wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, True);
 272             wxPyEndBlockThreads(blocked);
 273             if ( info.window )
 274                 self->SetItemMinSize(info.window, size);
 275             else if ( info.sizer )
 276                 self->SetItemMinSize(info.sizer, size);
 277             else if ( info.gotPos )
 278                 self->SetItemMinSize(info.pos, size);
 279         }
 280     }
 281
 282     %name(AddItem) void Add( wxSizerItem *item );
 283     %name(InsertItem) void Insert( size_t index, wxSizerItem *item );
 284     %name(PrependItem) void Prepend( wxSizerItem *item );
 285
 286
 287     %pythoncode {
 288     def AddMany(self, widgets):
 289         """
 290         AddMany is a convenience method for adding several items
 291         to a sizer at one time.  Simply pass it a list of tuples,
 292         where each tuple consists of the parameters that you
 293         would normally pass to the `Add` method.
 294         """
 295         for childinfo in widgets:
 296             if type(childinfo) != type(()) or (len(childinfo) == 2 and type(childinfo[0]) == type(1)):
 297                 childinfo = (childinfo, )
 298             self.Add(*childinfo)
 299
 300     %# for backwards compatibility only, please do not use in new code
 301     AddWindow     = wx._deprecated(Add, "AddWindow is deprecated, use `Add` instead.")
 302     AddSizer      = wx._deprecated(Add, "AddSizer is deprecated, use `Add` instead.")
 303     AddSpacer     = wx._deprecated(Add, "AddSpacer is deprecated, use `Add` instead.")
 304     PrependWindow = wx._deprecated(Prepend, "PrependWindow is deprecated, use `Prepend` instead.")
 305     PrependSizer  = wx._deprecated(Prepend, "PrependSizer is deprecated, use `Prepend` instead.")
 306     PrependSpacer = wx._deprecated(Prepend, "PrependSpacer is deprecated, use `Prepend` instead.")
 307     InsertWindow  = wx._deprecated(Insert, "InsertWindow is deprecated, use `Insert` instead.")
 308     InsertSizer   = wx._deprecated(Insert, "InsertSizer is deprecated, use `Insert` instead.")
 309     InsertSpacer  = wx._deprecated(Insert, "InsertSpacer is deprecated, use `Insert` instead.")
 310     RemoveWindow  = wx._deprecated(Remove, "RemoveWindow is deprecated, use `Remove` instead.")
 311     RemoveSizer   = wx._deprecated(Remove, "RemoveSizer is deprecated, use `Remove` instead.")
 312     RemovePos     = wx._deprecated(Remove, "RemovePos is deprecated, use `Remove` instead.")
 313
 314
 315     def SetItemMinSize(self, item, *args):
 316         if len(args) == 2:
 317             return self._SetItemMinSize(item, args)
 318         else:
 319             return self._SetItemMinSize(item, args[0])
 320     }
 321
 322
 323     void SetDimension( int x, int y, int width, int height );
 324     void SetMinSize( const wxSize &size );
 325
 326     wxSize GetSize();
 327     wxPoint GetPosition();
 328     wxSize GetMinSize();
 329
 330     %pythoncode {
 331     def GetSizeTuple(self):
 332         return self.GetSize().Get()
 333     def GetPositionTuple(self):
 334         return self.GetPosition().Get()
 335     def GetMinSizeTuple(self):
 336         return self.GetMinSize().Get()
 337     }
 338
 339     virtual void RecalcSizes();
 340     virtual wxSize CalcMin();
 341
 342     void Layout();
 343
 344     wxSize Fit( wxWindow *window );
 345     void FitInside( wxWindow *window );
 346
 347     void SetSizeHints( wxWindow *window );
 348     void SetVirtualSizeHints( wxWindow *window );
 349
 350     void Clear( bool delete_windows=False );
 351     void DeleteWindows();
 352
 353
 354     // wxList& GetChildren();
 355     %extend {
 356         PyObject* GetChildren() {
 357             wxSizerItemList& list = self->GetChildren();
 358             return wxPy_ConvertList(&list);
 359         }
 360     }
 361
 362
 363     // Manage whether individual windows or sub-sizers are considered
 364     // in the layout calculations or not.
 365
 366     %extend {
 367         void Show(PyObject* item, bool show = True) {
 368             bool blocked = wxPyBeginBlockThreads();
 369             wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, False);
 370             wxPyEndBlockThreads(blocked);
 371             if ( info.window )
 372                 self->Show(info.window, show);
 373             else if ( info.sizer )
 374                 self->Show(info.sizer, show);
 375         }
 376
 377
 378         void Hide(PyObject* item) {
 379             bool blocked = wxPyBeginBlockThreads();
 380             wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, False);
 381             wxPyEndBlockThreads(blocked);
 382             if ( info.window )
 383                 self->Hide(info.window);
 384             else if ( info.sizer )
 385                 self->Hide(info.sizer);
 386         }
 387
 388
 389         bool IsShown(PyObject* item) {
 390             bool blocked = wxPyBeginBlockThreads();
 391             wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, False, False);
 392             wxPyEndBlockThreads(blocked);
 393             if ( info.window )
 394                 return self->IsShown(info.window);
 395             else if ( info.sizer )
 396                 return self->IsShown(info.sizer);
 397             else
 398                 return False;
 399         }
 400     }
 401
 402
 403     // Recursively call wxWindow::Show() on all sizer items.
 404     void ShowItems(bool show);
 405
 406 };
 407
 408
 409 //---------------------------------------------------------------------------
 410 // Use this one for deriving Python classes from
 411 %{
 412 // See pyclasses.h
 413 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
 414 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
 415 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
 416 %}
 417
 418
 419
 420 class wxPySizer : public wxSizer {
 421 public:
 422     %pythonAppend wxPySizer "self._setCallbackInfo(self, PySizer);self._setOORInfo(self)"
 423
 424     wxPySizer();
 425     void _setCallbackInfo(PyObject* self, PyObject* _class);
 426 };
 427
 428
 429 //---------------------------------------------------------------------------
 430 %newgroup;
 431
 432 class  wxBoxSizer : public wxSizer {
 433 public:
 434     %pythonAppend wxBoxSizer "self._setOORInfo(self)"
 435
 436     wxBoxSizer(int orient = wxHORIZONTAL);
 437
 438     int GetOrientation();
 439     void SetOrientation(int orient);
 440     void RecalcSizes();
 441     wxSize CalcMin();
 442 };
 443
 444 //---------------------------------------------------------------------------
 445 %newgroup;
 446
 447 class  wxStaticBoxSizer : public wxBoxSizer {
 448 public:
 449     %pythonAppend wxStaticBoxSizer "self._setOORInfo(self)"
 450
 451     wxStaticBoxSizer(wxStaticBox *box, int orient = wxHORIZONTAL);
 452
 453     wxStaticBox *GetStaticBox();
 454     void RecalcSizes();
 455     wxSize CalcMin();
 456 };
 457
 458 //---------------------------------------------------------------------------
 459 %newgroup;
 460
 461 class wxGridSizer: public wxSizer
 462 {
 463 public:
 464     %pythonAppend wxGridSizer "self._setOORInfo(self)"
 465
 466     wxGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 );
 467
 468     void RecalcSizes();
 469     wxSize CalcMin();
 470
 471     void SetCols( int cols );
 472     void SetRows( int rows );
 473     void SetVGap( int gap );
 474     void SetHGap( int gap );
 475     int GetCols();
 476     int GetRows();
 477     int GetVGap();
 478     int GetHGap();
 479 };
 480
 481 //---------------------------------------------------------------------------
 482 %newgroup;
 483
 484 enum wxFlexSizerGrowMode
 485 {
 486     // don't resize the cells in non-flexible direction at all
 487     wxFLEX_GROWMODE_NONE,
 488
 489     // uniformly resize only the specified ones (default)
 490     wxFLEX_GROWMODE_SPECIFIED,
 491
 492     // uniformly resize all cells
 493     wxFLEX_GROWMODE_ALL
 494 };
 495
 496
 497 class wxFlexGridSizer: public wxGridSizer
 498 {
 499 public:
 500     %pythonAppend wxFlexGridSizer "self._setOORInfo(self)"
 501
 502     wxFlexGridSizer( int rows=1, int cols=0, int vgap=0, int hgap=0 );
 503
 504     void RecalcSizes();
 505     wxSize CalcMin();
 506
 507     void AddGrowableRow( size_t idx, int proportion = 0  );
 508     void RemoveGrowableRow( size_t idx );
 509     void AddGrowableCol( size_t idx, int proportion = 0  );
 510     void RemoveGrowableCol( size_t idx );
 511
 512     // the sizer cells may grow in both directions, not grow at all or only
 513     // grow in one direction but not the other
 514
 515     // the direction may be wxVERTICAL, wxHORIZONTAL or wxBOTH (default)
 516     void SetFlexibleDirection(int direction);
 517     int GetFlexibleDirection();
 518
 519     // note that the grow mode only applies to the direction which is not
 520     // flexible
 521     void SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode);
 522     wxFlexSizerGrowMode GetNonFlexibleGrowMode();
 523
 524     // Read-only access to the row heights and col widths arrays
 525     const wxArrayInt& GetRowHeights() const;
 526     const wxArrayInt& GetColWidths() const;
 527 };
 528
 529 //---------------------------------------------------------------------------