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     return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
  44 }
  45
  46 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
  47 {
  48     return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
  49 }
  50
  51 %}
  52
  53
  54 //---------------------------------------------------------------------------
  55 %newgroup;
  56
  57
  58 class wxGBPosition
  59 {
  60 public:
  61     wxGBPosition(int row=0, int col=0);
  62
  63     int GetRow() const;
  64     int GetCol() const;
  65     void SetRow(int row);
  66     void SetCol(int col);
  67
  68     %extend {
  69         bool __eq__(const wxGBPosition* other) { return other ? (*self == *other) : False; }
  70         bool __ne__(const wxGBPosition* other) { return other ? (*self != *other) : True;  }
  71     }
  72
  73     %extend {
  74         void Set(int row=0, int col=0) {
  75             self->SetRow(row);
  76             self->SetCol(col);
  77         }
  78
  79         PyObject* Get() {
  80             wxPyBeginBlockThreads();
  81             PyObject* tup = PyTuple_New(2);
  82             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
  83             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
  84             wxPyEndBlockThreads();
  85             return tup;
  86         }
  87     }
  88     %pythoncode {
  89     asTuple = Get
  90     def __str__(self):                   return str(self.Get())
  91     def __repr__(self):                  return 'wx.GBPosition'+str(self.Get())
  92     def __len__(self):                   return len(self.Get())
  93     def __getitem__(self, index):        return self.Get()[index]
  94     def __setitem__(self, index, val):
  95         if index == 0: self.SetRow(val)
  96         elif index == 1: self.SetCol(val)
  97         else: raise IndexError
  98     def __nonzero__(self):               return self.Get() != (0,0)
  99     __safe_for_unpickling__ = True
 100     def __reduce__(self):                return (wx.GBPosition, self.Get())
 101     }
 102
 103     %pythoncode {
 104     row = property(GetRow, SetRow)
 105     col = property(GetCol, SetCol)
 106     }
 107 };
 108
 109
 110
 111
 112 class wxGBSpan
 113 {
 114 public:
 115     wxGBSpan(int rowspan=1, int colspan=1);
 116
 117     int GetRowspan() const;
 118     int GetColspan() const;
 119     void SetRowspan(int rowspan);
 120     void SetColspan(int colspan);
 121
 122     %extend {
 123         bool __eq__(const wxGBSpan* other) { return other ? (*self == *other) : False; }
 124         bool __ne__(const wxGBSpan* other) { return other ? (*self != *other) : True;  }
 125     }
 126
 127     %extend {
 128         void Set(int rowspan=1, int colspan=1) {
 129             self->SetRowspan(rowspan);
 130             self->SetColspan(colspan);
 131         }
 132
 133         PyObject* Get() {
 134             wxPyBeginBlockThreads();
 135             PyObject* tup = PyTuple_New(2);
 136             PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
 137             PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
 138             wxPyEndBlockThreads();
 139             return tup;
 140         }
 141     }
 142     %pythoncode {
 143     asTuple = Get
 144     def __str__(self):                   return str(self.Get())
 145     def __repr__(self):                  return 'wx.GBSpan'+str(self.Get())
 146     def __len__(self):                   return len(self.Get())
 147     def __getitem__(self, index):        return self.Get()[index]
 148     def __setitem__(self, index, val):
 149         if index == 0: self.SetRowspan(val)
 150         elif index == 1: self.SetColspan(val)
 151         else: raise IndexError
 152     def __nonzero__(self):               return self.Get() != (0,0)
 153     __safe_for_unpickling__ = True
 154     def __reduce__(self):                return (wx.GBSpan, self.Get())
 155     }
 156
 157     %pythoncode {
 158     rowspan = property(GetRowspan, SetRowspan)
 159     colspan = property(GetColspan, SetColspan)
 160     }
 161 };
 162
 163
 164 %immutable;
 165 const wxGBSpan wxDefaultSpan;
 166 %mutable;
 167
 168
 169 //---------------------------------------------------------------------------
 170
 171
 172 class wxGBSizerItem : public wxSizerItem
 173 {
 174 public:
 175     wxGBSizerItem();
 176
 177     %name(GBSizerItemWindow) wxGBSizerItem( wxWindow *window,
 178                    const wxGBPosition& pos,
 179                    const wxGBSpan& span,
 180                    int flag,
 181                    int border,
 182                    wxObject* userData );
 183
 184     %name(GBSizerItemSizer) wxGBSizerItem( wxSizer *sizer,
 185                    const wxGBPosition& pos,
 186                    const wxGBSpan& span,
 187                    int flag,
 188                    int border,
 189                    wxObject* userData );
 190
 191     %name(GBSizerItemSpacer) wxGBSizerItem( int width,
 192                    int height,
 193                    const wxGBPosition& pos,
 194                    const wxGBSpan& span,
 195                    int flag,
 196                    int border,
 197                    wxObject* userData);
 198
 199
 200     // Get the grid position of the item
 201     wxGBPosition GetPos() const;
 202     %pythoncode { def GetPosTuple(self): return self.GetPos().Get() }
 203
 204     // Get the row and column spanning of the item
 205     wxGBSpan GetSpan() const;
 206     %pythoncode { def GetSpanTuple(self): return self.GetSpan().Get() }
 207
 208     // If the item is already a member of a sizer then first ensure that there
 209     // is no other item that would intersect with this one at the new
 210     // position, then set the new position.  Returns True if the change is
 211     // successful and after the next Layout the item will be moved.
 212     bool SetPos( const wxGBPosition& pos );
 213
 214     // If the item is already a member of a sizer then first ensure that there
 215     // is no other item that would intersect with this one with its new
 216     // spanning size, then set the new spanning.  Returns True if the change
 217     // is successful and after the next Layout the item will be resized.
 218     bool SetSpan( const wxGBSpan& span );
 219
 220     %nokwargs Intersects;
 221
 222     // Returns True if this item and the other item instersect
 223     bool Intersects(const wxGBSizerItem& other);
 224
 225     // Returns True if the given pos/span would intersect with this item.
 226     bool Intersects(const wxGBPosition& pos, const wxGBSpan& span);
 227
 228     // Get the row and column of the endpoint of this item
 229     void GetEndPos(int& row, int& col);
 230
 231
 232     wxGridBagSizer* GetGBSizer() const;
 233     void SetGBSizer(wxGridBagSizer* sizer);
 234
 235 };
 236
 237
 238 //---------------------------------------------------------------------------
 239
 240
 241 class wxGridBagSizer : public wxFlexGridSizer
 242 {
 243 public:
 244     wxGridBagSizer(int vgap = 0, int hgap = 0 );
 245
 246     // The Add method returns True if the item was successfully placed at the
 247     // given cell position, False if something was already there.
 248     %extend {
 249         bool Add( PyObject* item,
 250                   const wxGBPosition& pos,
 251                   const wxGBSpan& span = wxDefaultSpan,
 252                   int flag = 0,
 253                   int border = 0,
 254                   PyObject* userData = NULL ) {
 255
 256             wxPyUserData* data = NULL;
 257             wxPyBeginBlockThreads();
 258             wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, True, False);
 259             if ( userData && (info.window || info.sizer || info.gotSize) )
 260                 data = new wxPyUserData(userData);
 261             wxPyEndBlockThreads();
 262
 263             // Now call the real Add method if a valid item type was found
 264             if ( info.window )
 265                 return self->Add(info.window, pos, span, flag, border, data);
 266             else if ( info.sizer )
 267                 return self->Add(info.sizer, pos, span, flag, border, data);
 268             else if (info.gotSize)
 269                 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
 270                                  pos, span, flag, border, data);
 271             return False;
 272         }
 273     }
 274
 275     %name(AddItem) bool Add( wxGBSizerItem *item );
 276
 277
 278     // Get/Set the size used for cells in the grid with no item.
 279     wxSize GetEmptyCellSize() const;
 280     void SetEmptyCellSize(const wxSize& sz);
 281
 282     // Get the grid position of the specified item
 283     %nokwargs GetItemPosition;
 284     wxGBPosition GetItemPosition(wxWindow *window);
 285     wxGBPosition GetItemPosition(wxSizer *sizer);
 286     wxGBPosition GetItemPosition(size_t index);
 287
 288     // Set the grid position of the specified item.  Returns True on success.
 289     // If the move is not allowed (because an item is already there) then
 290     // False is returned.
 291     %nokwargs SetItemPosition;
 292     bool SetItemPosition(wxWindow *window, const wxGBPosition& pos);
 293     bool SetItemPosition(wxSizer *sizer, const wxGBPosition& pos);
 294     bool SetItemPosition(size_t index, const wxGBPosition& pos);
 295
 296     // Get the row/col spanning of the specified item
 297     %nokwargs GetItemSpan;
 298     wxGBSpan GetItemSpan(wxWindow *window);
 299     wxGBSpan GetItemSpan(wxSizer *sizer);
 300     wxGBSpan GetItemSpan(size_t index);
 301
 302     // Set the row/col spanning of the specified item. Returns True on
 303     // success.  If the move is not allowed (because an item is already there)
 304     // then False is returned.
 305     %nokwargs SetItemSpan;
 306     bool SetItemSpan(wxWindow *window, const wxGBSpan& span);
 307     bool SetItemSpan(wxSizer *sizer, const wxGBSpan& span);
 308     bool SetItemSpan(size_t index, const wxGBSpan& span);
 309
 310
 311     // Find the sizer item for the given window or subsizer, returns NULL if
 312     // not found. (non-recursive)
 313     %nokwargs FindItem;
 314     wxGBSizerItem* FindItem(wxWindow* window);
 315     wxGBSizerItem* FindItem(wxSizer* sizer);
 316
 317
 318     // Return the sizer item for the given grid cell, or NULL if there is no
 319     // item at that position. (non-recursive)
 320     wxGBSizerItem* FindItemAtPosition(const wxGBPosition& pos);
 321
 322
 323     // Return the sizer item located at the point given in pt, or NULL if
 324     // there is no item at that point. The (x,y) coordinates in pt correspond
 325     // to the client coordinates of the window using the sizer for
 326     // layout. (non-recursive)
 327     wxGBSizerItem* FindItemAtPoint(const wxPoint& pt);
 328
 329
 330     // Return the sizer item that has a matching user data (it only compares
 331     // pointer values) or NULL if not found. (non-recursive)
 332     wxGBSizerItem* FindItemWithData(const wxObject* userData);
 333
 334
 335     // These are what make the sizer do size calculations and layout
 336     virtual void RecalcSizes();
 337     virtual wxSize CalcMin();
 338
 339
 340     // Look at all items and see if any intersect (or would overlap) the given
 341     // item.  Returns True if so, False if there would be no overlap.  If an
 342     // excludeItem is given then it will not be checked for intersection, for
 343     // example it may be the item we are checking the position of.
 344     %nokwargs CheckForIntersection;
 345     bool CheckForIntersection(wxGBSizerItem* item, wxGBSizerItem* excludeItem = NULL);
 346     bool CheckForIntersection(const wxGBPosition& pos, const wxGBSpan& span, wxGBSizerItem* excludeItem = NULL);
 347
 348 };
 349
 350
 351 //---------------------------------------------------------------------------