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