wxPython/src/_gbsizer.i

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        _gbsizer.i
   3 // Purpose:     SWIG interface stuff for wxGBGridBagSizer and etc.
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     05-Nov-2003
   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
  23 %typemap(in) wxGBPosition& (wxGBPosition temp) {
  24     $1 = &temp;
  25     if ( ! wxGBPosition_helper($input, &$1)) SWIG_fail;
  26 }
  27 %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxGBPosition& {
  28     $1 = wxPySimple_typecheck($input, wxT("wxGBPosition"), 2);
  29 }
  30
  31 %typemap(in) wxGBSpan& (wxGBSpan temp) {
  32     $1 = &temp;
  33     if ( ! wxGBSpan_helper($input, &$1)) SWIG_fail;
  34 }
  35 %typemap(typecheck, precedence=SWIG_TYPECHECK_POINTER) wxGBSpan& {
  36     $1 = wxPySimple_typecheck($input, wxT("wxGBSpan"), 2);
  37 }
  38
  39
  40 %{
  41 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
  42 {
  43     if (source == Py_None) {
  44         **obj = wxGBPosition(-1,-1);
  45         return true;
  46     }
  47     return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
  48 }
  49
  50 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
  51 {
  52     if (source == Py_None) {
  53         **obj = wxGBSpan(-1,-1);
  54         return true;
  55     }
  56     return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
  57 }
  58
  59 %}
  60
  61
  62 //---------------------------------------------------------------------------
  63 %newgroup;
  64
  65 DocStr(wxGBPosition,
  66 "This class represents the position of an item in a virtual grid of
  67 rows and columns managed by a `wx.GridBagSizer`.  wxPython has
  68 typemaps that will automatically convert from a 2-element sequence of
  69 integers to a wx.GBPosition, so you can use the more pythonic
  70 representation of the position nearly transparently in Python code.", "");
  71
  72 class wxGBPosition
  73 {
  74 public:
  75     wxGBPosition(int row=0, int col=0);
  76     ~wxGBPosition();
  77
  78     int GetRow() const;
  79     int GetCol() const;
  80     void SetRow(int row);
  81     void SetCol(int col);
  82
  83
  84     %extend {
  85         KeepGIL(__eq__);
  86         DocStr(__eq__, "Compare GBPosition for equality.", "");
  87         bool __eq__(PyObject* other) {
  88             wxGBPosition  temp, *obj = &temp;
  89             if ( other == Py_None ) return false;
  90             if ( ! wxGBPosition_helper(other, &obj) ) {
  91                 PyErr_Clear();
  92                 return false;
  93             }
  94             return self->operator==(*obj);
  95         }
  96
  97
  98         KeepGIL(__ne__);
  99         DocStr(__ne__, "Compare GBPosition for inequality.", "");
 100         bool __ne__(PyObject* other) {
 101             wxGBPosition  temp, *obj = &temp;
 102             if ( other == Py_None ) return true;
 103             if ( ! wxGBPosition_helper(other, &obj)) {
 104                 PyErr_Clear();
 105                 return true;
 106             }
 107             return self->operator!=(*obj);
 108         }
 109     }
 110
 111
 112     %extend {
 113         void Set(int row=0, int col=0) {
 114             self->SetRow(row);
 115             self->SetCol(col);
 116         }
 117
 118         PyObject* Get() {
 119             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 120             PyObject* tup = PyTuple_New(2);
 121             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
 122             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
 123             wxPyEndBlockThreads(blocked);
 124             return tup;
 125         }
 126     }
 127     %pythoncode {
 128     asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
 129     def __str__(self):                   return str(self.Get())
 130     def __repr__(self):                  return 'wx.GBPosition'+str(self.Get())
 131     def __len__(self):                   return len(self.Get())
 132     def __getitem__(self, index):        return self.Get()[index]
 133     def __setitem__(self, index, val):
 134         if index == 0: self.SetRow(val)
 135         elif index == 1: self.SetCol(val)
 136         else: raise IndexError
 137     def __nonzero__(self):               return self.Get() != (0,0)
 138     __safe_for_unpickling__ = True
 139     def __reduce__(self):                return (wx.GBPosition, self.Get())
 140     }
 141
 142     %pythoncode {
 143     row = property(GetRow, SetRow)
 144     col = property(GetCol, SetCol)
 145     }
 146 };
 147
 148
 149
 150
 151 DocStr(wxGBSpan,
 152 "This class is used to hold the row and column spanning attributes of
 153 items in a `wx.GridBagSizer`.  wxPython has typemaps that will
 154 automatically convert from a 2-element sequence of integers to a
 155 wx.GBSpan, so you can use the more pythonic representation of the span
 156 nearly transparently in Python code.
 157 ", "");
 158
 159 class wxGBSpan
 160 {
 161 public:
 162     DocCtorStr(
 163         wxGBSpan(int rowspan=1, int colspan=1),
 164         "Construct a new wxGBSpan, optionally setting the rowspan and
 165 colspan. The default is (1,1). (Meaning that the item occupies one
 166 cell in each direction.", "");
 167
 168     ~wxGBSpan();
 169
 170     int GetRowspan() const;
 171     int GetColspan() const;
 172     void SetRowspan(int rowspan);
 173     void SetColspan(int colspan);
 174
 175
 176     %extend {
 177         KeepGIL(__eq__);
 178         DocStr(__eq__, "Compare wxGBSpan for equality.", "");
 179         bool __eq__(PyObject* other) {
 180             wxGBSpan  temp, *obj = &temp;
 181             if ( other == Py_None ) return false;
 182             if ( ! wxGBSpan_helper(other, &obj) ) {
 183                 PyErr_Clear();
 184                 return false;
 185             }
 186             return self->operator==(*obj);
 187         }
 188
 189
 190         KeepGIL(__ne__);
 191         DocStr(__ne__, "Compare GBSpan for inequality.", "");
 192         bool __ne__(PyObject* other) {
 193             wxGBSpan  temp, *obj = &temp;
 194             if ( other == Py_None ) return true;
 195             if ( ! wxGBSpan_helper(other, &obj)) {
 196                 PyErr_Clear();
 197                 return true;
 198             }
 199             return self->operator!=(*obj);
 200         }
 201     }
 202
 203
 204     %extend {
 205         void Set(int rowspan=1, int colspan=1) {
 206             self->SetRowspan(rowspan);
 207             self->SetColspan(colspan);
 208         }
 209
 210         PyObject* Get() {
 211             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 212             PyObject* tup = PyTuple_New(2);
 213             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
 214             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
 215             wxPyEndBlockThreads(blocked);
 216             return tup;
 217         }
 218     }
 219     %pythoncode {
 220     asTuple = wx._deprecated(Get, "asTuple is deprecated, use `Get` instead")
 221     def __str__(self):                   return str(self.Get())
 222     def __repr__(self):                  return 'wx.GBSpan'+str(self.Get())
 223     def __len__(self):                   return len(self.Get())
 224     def __getitem__(self, index):        return self.Get()[index]
 225     def __setitem__(self, index, val):
 226         if index == 0: self.SetRowspan(val)
 227         elif index == 1: self.SetColspan(val)
 228         else: raise IndexError
 229     def __nonzero__(self):               return self.Get() != (0,0)
 230     __safe_for_unpickling__ = True
 231     def __reduce__(self):                return (wx.GBSpan, self.Get())
 232     }
 233
 234     %pythoncode {
 235     rowspan = property(GetRowspan, SetRowspan)
 236     colspan = property(GetColspan, SetColspan)
 237     }
 238 };
 239
 240
 241 %immutable;
 242 const wxGBSpan wxDefaultSpan;
 243 %mutable;
 244
 245
 246 //---------------------------------------------------------------------------
 247
 248
 249 DocStr(wxGBSizerItem,
 250 "The wx.GBSizerItem class is used to track the additional data about
 251 items in a `wx.GridBagSizer` such as the item's position in the grid
 252 and how many rows or columns it spans.
 253 ", "");
 254 class wxGBSizerItem : public wxSizerItem
 255 {
 256 public:
 257     DocCtorStr(
 258         wxGBSizerItem(),
 259         "Constructs an empty wx.GBSizerItem.  Either a window, sizer or spacer
 260 size will need to be set, as well as a position and span before this
 261 item can be used in a Sizer.
 262
 263 You will probably never need to create a wx.GBSizerItem directly as they
 264 are created automatically when the sizer's Add method is called.", "");
 265
 266     ~wxGBSizerItem();
 267
 268
 269     %extend {
 270         DocStr(wxGBSizerItem( wxWindow *window, const wxGBPosition& pos,const wxGBSpan& span,int flag,int border,PyObject* userData=NULL ),
 271                "Construct a `wx.GBSizerItem` for a window.", "");
 272
 273         %RenameCtor(GBSizerItemWindow, wxGBSizerItem( wxWindow *window,
 274                                                       const wxGBPosition& pos,
 275                                                       const wxGBSpan& span,
 276                                                       int flag,
 277                                                       int border,
 278                                                       PyObject* userData=NULL ))
 279             {
 280                 wxPyUserData* data = NULL;
 281                 if ( userData ) {
 282                     wxPyBlock_t blocked = wxPyBeginBlockThreads();
 283                     data = new wxPyUserData(userData);
 284                     wxPyEndBlockThreads(blocked);
 285                 }
 286                 return new wxGBSizerItem(window, pos, span, flag, border, data);
 287             }
 288
 289
 290         DocStr(wxGBSizerItem( wxSizer *sizer,const wxGBPosition& pos,const wxGBSpan& span,int flag,int border,PyObject* userData=NULL ),
 291                "Construct a `wx.GBSizerItem` for a sizer", "");
 292         %disownarg( wxSizer *sizer );
 293         %RenameCtor(GBSizerItemSizer, wxGBSizerItem( wxSizer *sizer,
 294                                                      const wxGBPosition& pos,
 295                                                      const wxGBSpan& span,
 296                                                      int flag,
 297                                                      int border,
 298                                                      PyObject* userData=NULL ))
 299             {
 300                 wxPyUserData* data = NULL;
 301                 if ( userData ) {
 302                     wxPyBlock_t blocked = wxPyBeginBlockThreads();
 303                     data = new wxPyUserData(userData);
 304                     wxPyEndBlockThreads(blocked);
 305                 }
 306                 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
 307             }
 308         %cleardisown( wxSizer *sizer );
 309
 310
 311         DocStr(wxGBSizerItem( int width,int height,const wxGBPosition& pos,const wxGBSpan& span,int flag,int border,PyObject* userData=NULL),
 312                "Construct a `wx.GBSizerItem` for a spacer.", "");
 313         %RenameCtor(GBSizerItemSpacer, wxGBSizerItem( int width,
 314                                                       int height,
 315                                                       const wxGBPosition& pos,
 316                                                       const wxGBSpan& span,
 317                                                       int flag,
 318                                                       int border,
 319                                                       PyObject* userData=NULL))
 320             {
 321                 wxPyUserData* data = NULL;
 322                 if ( userData ) {
 323                     wxPyBlock_t blocked = wxPyBeginBlockThreads();
 324                     data = new wxPyUserData(userData);
 325                     wxPyEndBlockThreads(blocked);
 326                 }
 327                 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
 328             }
 329     }
 330
 331
 332     DocDeclStr(
 333         wxGBPosition , GetPos() const,
 334         "Get the grid position of the item", "");
 335
 336     %pythoncode { def GetPosTuple(self): return self.GetPos().Get() }
 337
 338
 339
 340     DocDeclStr(
 341         wxGBSpan , GetSpan() const,
 342         "Get the row and column spanning of the item", "");
 343
 344     %pythoncode { def GetSpanTuple(self): return self.GetSpan().Get() }
 345
 346
 347
 348     DocDeclStr(
 349         bool , SetPos( const wxGBPosition& pos ),
 350         "If the item is already a member of a sizer then first ensure that
 351 there is no other item that would intersect with this one at the new
 352 position, then set the new position.  Returns True if the change is
 353 successful and after the next Layout() the item will be moved.", "");
 354
 355
 356     DocDeclStr(
 357         bool , SetSpan( const wxGBSpan& span ),
 358         "If the item is already a member of a sizer then first ensure that
 359 there is no other item that would intersect with this one with its new
 360 spanning size, then set the new spanning.  Returns True if the change
 361 is successful and after the next Layout() the item will be resized.
 362 ", "");
 363
 364
 365
 366     DocDeclStr(
 367         bool , Intersects(const wxGBSizerItem& other),
 368         "Returns True if this item and the other item instersect.", "");
 369
 370
 371     DocDeclStrName(
 372         bool , Intersects(const wxGBPosition& pos, const wxGBSpan& span),
 373         "Returns True if the given pos/span would intersect with this item.", "",
 374         IntersectsPos);
 375
 376
 377     %extend {
 378         DocStr(GetEndPos,
 379                "Get the row and column of the endpoint of this item.", "");
 380         wxGBPosition GetEndPos() {
 381             int row, col;
 382             self->GetEndPos(row, col);
 383             return wxGBPosition(row, col);
 384         }
 385     }
 386
 387
 388     DocDeclStr(
 389         wxGridBagSizer* , GetGBSizer() const,
 390         "Get the sizer this item is a member of.", "");
 391
 392     DocDeclStr(
 393         void , SetGBSizer(wxGridBagSizer* sizer),
 394         "Set the sizer this item is a member of.", "");
 395
 396 };
 397
 398
 399 //---------------------------------------------------------------------------
 400
 401 DocStr(wxGridBagSizer,
 402 "A `wx.Sizer` that can lay out items in a virtual grid like a
 403 `wx.FlexGridSizer` but in this case explicit positioning of the items
 404 is allowed using `wx.GBPosition`, and items can optionally span more
 405 than one row and/or column using `wx.GBSpan`.  The total size of the
 406 virtual grid is determined by the largest row and column that items are
 407 positioned at, adjusted for spanning.
 408 ", "");
 409
 410 class wxGridBagSizer : public wxFlexGridSizer
 411 {
 412 public:
 413     %pythonAppend wxGridBagSizer "self._setOORInfo(self)"
 414
 415     DocCtorStr(
 416         wxGridBagSizer(int vgap = 0, int hgap = 0 ),
 417         "Constructor, with optional parameters to specify the gap between the
 418 rows and columns.", "");
 419
 420
 421     %extend {
 422         DocAStr(Add,
 423                 "Add(self, item, GBPosition pos, GBSpan span=DefaultSpan, int flag=0,
 424 int border=0, userData=None) -> wx.GBSizerItem",
 425
 426                 "Adds an item to the sizer at the grid cell *pos*, optionally spanning
 427 more than one row or column as specified with *span*.  The remaining
 428 args behave similarly to `wx.Sizer.Add`.
 429
 430 Returns True if the item was successfully placed at the given cell
 431 position, False if something was already there.
 432 ", "");
 433         wxGBSizerItem* Add( PyObject* item,
 434                             const wxGBPosition& pos,
 435                             const wxGBSpan& span = wxDefaultSpan,
 436                             int flag = 0,
 437                             int border = 0,
 438                             PyObject* userData = NULL ) {
 439
 440             wxPyUserData* data = NULL;
 441             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 442             wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
 443             if ( userData && (info.window || info.sizer || info.gotSize) )
 444                 data = new wxPyUserData(userData);
 445             if ( info.sizer )
 446                 PyObject_SetAttrString(item,"thisown",Py_False);
 447             wxPyEndBlockThreads(blocked);
 448
 449             // Now call the real Add method if a valid item type was found
 450             if ( info.window )
 451                 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
 452             else if ( info.sizer )
 453                 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
 454             else if (info.gotSize)
 455                 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
 456                                                  pos, span, flag, border, data);
 457             return NULL;
 458         }
 459     }
 460
 461     %disownarg( wxGBSizerItem *item );
 462     DocDeclAStrName(
 463         wxGBSizerItem* , Add( wxGBSizerItem *item ),
 464         "Add(self, GBSizerItem item) -> wx.GBSizerItem",
 465         "Add an item to the sizer using a `wx.GBSizerItem`.  Returns True if
 466 the item was successfully placed at its given cell position, False if
 467 something was already there.", "",
 468         AddItem);
 469     %cleardisown( wxGBSizerItem *item );
 470
 471     DocDeclStr(
 472         wxSize , GetCellSize(int row, int col) const,
 473         "Get the size of the specified cell, including hgap and
 474 vgap.  Only valid after a Layout.", "");
 475
 476     DocDeclStr(
 477         wxSize , GetEmptyCellSize() const,
 478         "Get the size used for cells in the grid with no item.", "");
 479
 480     DocDeclStr(
 481         void , SetEmptyCellSize(const wxSize& sz),
 482         "Set the size used for cells in the grid with no item.", "");
 483
 484
 485
 486     %nokwargs GetItemPosition;
 487     %noautodoc GetItemPosition;
 488     DocStr(GetItemPosition,
 489            "GetItemPosition(self, item) -> GBPosition
 490
 491 Get the grid position of the specified *item* where *item* is either a
 492 window or subsizer that is a member of this sizer, or a zero-based
 493 index of an item.", "");
 494     wxGBPosition GetItemPosition(wxWindow *window);
 495     wxGBPosition GetItemPosition(wxSizer *sizer);
 496     wxGBPosition GetItemPosition(size_t index);
 497
 498
 499     %nokwargs SetItemPosition;
 500     %noautodoc SetItemPosition;
 501     DocStr(SetItemPosition,
 502            "SetItemPosition(self, item, GBPosition pos) -> bool
 503
 504 Set the grid position of the specified *item* where *item* is either a
 505 window or subsizer that is a member of this sizer, or a zero-based
 506 index of an item.  Returns True on success.  If the move is not
 507 allowed (because an item is already there) then False is returned.
 508 ", "");
 509     bool SetItemPosition(wxWindow *window, const wxGBPosition& pos);
 510     bool SetItemPosition(wxSizer *sizer, const wxGBPosition& pos);
 511     bool SetItemPosition(size_t index, const wxGBPosition& pos);
 512
 513
 514
 515     %nokwargs GetItemSpan;
 516     %noautodoc GetItemSpan;
 517     DocStr(GetItemSpan,
 518            "GetItemSpan(self, item) -> GBSpan
 519
 520 Get the row/col spanning of the specified *item* where *item* is
 521 either a window or subsizer that is a member of this sizer, or a
 522 zero-based index of an item.", "");
 523     wxGBSpan GetItemSpan(wxWindow *window);
 524     wxGBSpan GetItemSpan(wxSizer *sizer);
 525     wxGBSpan GetItemSpan(size_t index);
 526
 527
 528
 529     %nokwargs SetItemSpan;
 530     %noautodoc SetItemSpan;
 531     DocStr(SetItemSpan,
 532             "SetItemSpan(self, item, GBSpan span) -> bool
 533
 534 Set the row/col spanning of the specified *item* where *item* is
 535 either a window or subsizer that is a member of this sizer, or a
 536 zero-based index of an item.  Returns True on success.  If the move is
 537 not allowed (because an item is already there) then False is returned.", "");
 538     bool SetItemSpan(wxWindow *window, const wxGBSpan& span);
 539     bool SetItemSpan(wxSizer *sizer, const wxGBSpan& span);
 540     bool SetItemSpan(size_t index, const wxGBSpan& span);
 541
 542
 543
 544     %nokwargs FindItem;
 545     %noautodoc FindItem;
 546     DocStr(FindItem,
 547             "FindItem(self, item) -> GBSizerItem
 548
 549 Find the sizer item for the given window or subsizer, returns None if
 550 not found. (non-recursive)", "");
 551     wxGBSizerItem* FindItem(wxWindow* window);
 552     wxGBSizerItem* FindItem(wxSizer* sizer);
 553
 554
 555     DocDeclStr(
 556         wxGBSizerItem* , FindItemAtPosition(const wxGBPosition& pos),
 557         "Return the sizer item for the given grid cell, or None if there is no
 558 item at that position. (non-recursive)", "");
 559
 560
 561
 562     DocDeclStr(
 563         wxGBSizerItem* , FindItemAtPoint(const wxPoint& pt),
 564         "Return the sizer item located at the point given in *pt*, or None if
 565 there is no item at that point. The (x,y) coordinates in pt correspond
 566 to the client coordinates of the window using the sizer for
 567 layout. (non-recursive)", "");
 568
 569
 570
 571 //     DocDeclStr(
 572 //         wxGBSizerItem* , FindItemWithData(const wxObject* userData),
 573 //         "Return the sizer item that has a matching user data (it only compares
 574 // pointer values) or None if not found. (non-recursive)", "");
 575
 576
 577
 578     // Look at all items and see if any intersect (or would overlap) the given
 579     // item.  Returns True if so, False if there would be no overlap.  If an
 580     // excludeItem is given then it will not be checked for intersection, for
 581     // example it may be the item we are checking the position of.
 582
 583
 584     DocDeclStr(
 585         bool , CheckForIntersection(wxGBSizerItem* item, wxGBSizerItem* excludeItem = NULL),
 586         "Look at all items and see if any intersect (or would overlap) the
 587 given *item*.  Returns True if so, False if there would be no overlap.
 588 If an *excludeItem* is given then it will not be checked for
 589 intersection, for example it may be the item we are checking the
 590 position of.
 591 ", "");
 592
 593     DocDeclStrName(
 594         bool , CheckForIntersection(const wxGBPosition& pos, const wxGBSpan& span, wxGBSizerItem* excludeItem = NULL),
 595         "Look at all items and see if any intersect (or would overlap) the
 596 given position and span.  Returns True if so, False if there would be
 597 no overlap.  If an *excludeItem* is given then it will not be checked
 598 for intersection, for example it may be the item we are checking the
 599 position of.", "",
 600         CheckForIntersectionPos);
 601
 602
 603 };
 604
 605
 606 //---------------------------------------------------------------------------