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