wxPython/src/_treectrl.i

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        _treectrl.i
   3 // Purpose:     SWIG interface file for wxTreeCtrl and related classes
   4 //
   5 // Author:      Robin Dunn
   6 //
   7 // Created:     10-June-1998
   8 // RCS-ID:      $Id$
   9 // Copyright:   (c) 2002 by Total Control Software
  10 // Licence:     wxWindows license
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 // Not a %module
  14
  15
  16 //---------------------------------------------------------------------------
  17
  18 %{
  19 #include <wx/treectrl.h>
  20 #include "wx/wxPython/pytree.h"
  21 %}
  22
  23 MAKE_CONST_WXSTRING2(TreeCtrlNameStr, _T("wxTreeCtrl"));
  24
  25 //---------------------------------------------------------------------------
  26 %newgroup
  27
  28
  29 // wxTreeCtrl flags
  30 enum {
  31     wxTR_NO_BUTTONS,
  32     wxTR_HAS_BUTTONS,
  33     wxTR_NO_LINES,
  34     wxTR_LINES_AT_ROOT,
  35
  36     wxTR_SINGLE,
  37     wxTR_MULTIPLE,
  38     wxTR_EXTENDED,
  39     wxTR_HAS_VARIABLE_ROW_HEIGHT,
  40
  41     wxTR_EDIT_LABELS,
  42     wxTR_HIDE_ROOT,
  43     wxTR_ROW_LINES,
  44
  45     wxTR_FULL_ROW_HIGHLIGHT,
  46     wxTR_DEFAULT_STYLE,
  47
  48     wxTR_TWIST_BUTTONS,
  49     wxTR_MAC_BUTTONS,
  50     wxTR_AQUA_BUTTONS,
  51 };
  52
  53
  54 enum wxTreeItemIcon
  55 {
  56     wxTreeItemIcon_Normal,              // not selected, not expanded
  57     wxTreeItemIcon_Selected,            //     selected, not expanded
  58     wxTreeItemIcon_Expanded,            // not selected,     expanded
  59     wxTreeItemIcon_SelectedExpanded,    //     selected,     expanded
  60     wxTreeItemIcon_Max
  61 };
  62
  63
  64 // constants for HitTest
  65 enum {
  66     wxTREE_HITTEST_ABOVE,
  67     wxTREE_HITTEST_BELOW,
  68     wxTREE_HITTEST_NOWHERE,
  69     wxTREE_HITTEST_ONITEMBUTTON,
  70     wxTREE_HITTEST_ONITEMICON,
  71     wxTREE_HITTEST_ONITEMINDENT,
  72     wxTREE_HITTEST_ONITEMLABEL,
  73     wxTREE_HITTEST_ONITEMRIGHT,
  74     wxTREE_HITTEST_ONITEMSTATEICON,
  75     wxTREE_HITTEST_TOLEFT,
  76     wxTREE_HITTEST_TORIGHT,
  77     wxTREE_HITTEST_ONITEMUPPERPART,
  78     wxTREE_HITTEST_ONITEMLOWERPART,
  79     wxTREE_HITTEST_ONITEM
  80 };
  81
  82 //---------------------------------------------------------------------------
  83 %newgroup
  84
  85
  86 // wxTreeItemId identifies an element of the tree. In this implementation, it's
  87 // just a trivial wrapper around Win32 HTREEITEM or a pointer to some private
  88 // data structure in the generic version. It's opaque for the application and
  89 // the only method which can be used by user code is IsOk().
  90 class wxTreeItemId {
  91 public:
  92     wxTreeItemId();
  93     ~wxTreeItemId();
  94
  95     // is this a valid tree item?
  96     bool IsOk() const;
  97
  98     %extend {
  99         bool __eq__(const wxTreeItemId* other) { return other ? (*self == *other) : false; }
 100         bool __ne__(const wxTreeItemId* other) { return other ? (*self != *other) : true;  }
 101     }
 102
 103     void*  m_pItem;
 104
 105
 106     %pythoncode {
 107         Ok = IsOk
 108         def __nonzero__(self): return self.IsOk() }
 109 };
 110
 111
 112
 113
 114 // wxTreeItemData is some (arbitrary) user data associated with some tree
 115 // item.  The Python version is just a simple wrapper around a Python object
 116 // that knows how to handle references properly.  Using this class directly in
 117 // Python code should rarely be neccessary.  Just use the GetItemPyData and
 118 // SetItemPyData tree methods instead of the GetItemData and SetItemData
 119 // methods.
 120 %rename(TreeItemData) wxPyTreeItemData;
 121 class wxPyTreeItemData {
 122 public:
 123     wxPyTreeItemData(PyObject* obj = NULL);
 124
 125     PyObject* GetData();
 126     void      SetData(PyObject* obj);
 127
 128     const wxTreeItemId& GetId();
 129     void                SetId(const wxTreeItemId& id);
 130
 131     %extend { void Destroy() { delete self; } }
 132 };
 133
 134
 135
 136 #if 0  // it's not currently used anywhere...
 137
 138 // wxTreeItemAttr: a structure containing the visual attributes of an item
 139 class wxTreeItemAttr
 140 {
 141 public:
 142     // ctors
 143     //wxTreeItemAttr() { }
 144     wxTreeItemAttr(const wxColour& colText = wxNullColour,
 145                    const wxColour& colBack = wxNullColour,
 146                    const wxFont& font = wxNullFont);
 147
 148     // setters
 149     void SetTextColour(const wxColour& colText);
 150     void SetBackgroundColour(const wxColour& colBack);
 151     void SetFont(const wxFont& font);
 152
 153     // accessors
 154     bool HasTextColour();
 155     bool HasBackgroundColour();
 156     bool HasFont();
 157
 158     wxColour GetTextColour();
 159     wxColour GetBackgroundColour();
 160     wxFont GetFont();
 161
 162     %extend { void Destroy() { delete self; } }
 163 };
 164
 165 #endif
 166
 167
 168 //---------------------------------------------------------------------------
 169 %newgroup
 170
 171 /* Tree control event types */
 172 %constant wxEventType wxEVT_COMMAND_TREE_BEGIN_DRAG;
 173 %constant wxEventType wxEVT_COMMAND_TREE_BEGIN_RDRAG;
 174 %constant wxEventType wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT;
 175 %constant wxEventType wxEVT_COMMAND_TREE_END_LABEL_EDIT;
 176 %constant wxEventType wxEVT_COMMAND_TREE_DELETE_ITEM;
 177 %constant wxEventType wxEVT_COMMAND_TREE_GET_INFO;
 178 %constant wxEventType wxEVT_COMMAND_TREE_SET_INFO;
 179 %constant wxEventType wxEVT_COMMAND_TREE_ITEM_EXPANDED;
 180 %constant wxEventType wxEVT_COMMAND_TREE_ITEM_EXPANDING;
 181 %constant wxEventType wxEVT_COMMAND_TREE_ITEM_COLLAPSED;
 182 %constant wxEventType wxEVT_COMMAND_TREE_ITEM_COLLAPSING;
 183 %constant wxEventType wxEVT_COMMAND_TREE_SEL_CHANGED;
 184 %constant wxEventType wxEVT_COMMAND_TREE_SEL_CHANGING;
 185 %constant wxEventType wxEVT_COMMAND_TREE_KEY_DOWN;
 186 %constant wxEventType wxEVT_COMMAND_TREE_ITEM_ACTIVATED;
 187 %constant wxEventType wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK;
 188 %constant wxEventType wxEVT_COMMAND_TREE_ITEM_MIDDLE_CLICK;
 189 %constant wxEventType wxEVT_COMMAND_TREE_END_DRAG;
 190 %constant wxEventType wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK;
 191 %constant wxEventType wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP;
 192 %constant wxEventType wxEVT_COMMAND_TREE_ITEM_MENU;
 193
 194 %pythoncode {
 195
 196 EVT_TREE_BEGIN_DRAG        = wx.PyEventBinder(wxEVT_COMMAND_TREE_BEGIN_DRAG       , 1)
 197 EVT_TREE_BEGIN_RDRAG       = wx.PyEventBinder(wxEVT_COMMAND_TREE_BEGIN_RDRAG      , 1)
 198 EVT_TREE_BEGIN_LABEL_EDIT  = wx.PyEventBinder(wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT , 1)
 199 EVT_TREE_END_LABEL_EDIT    = wx.PyEventBinder(wxEVT_COMMAND_TREE_END_LABEL_EDIT   , 1)
 200 EVT_TREE_DELETE_ITEM       = wx.PyEventBinder(wxEVT_COMMAND_TREE_DELETE_ITEM      , 1)
 201 EVT_TREE_GET_INFO          = wx.PyEventBinder(wxEVT_COMMAND_TREE_GET_INFO         , 1)
 202 EVT_TREE_SET_INFO          = wx.PyEventBinder(wxEVT_COMMAND_TREE_SET_INFO         , 1)
 203 EVT_TREE_ITEM_EXPANDED     = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_EXPANDED    , 1)
 204 EVT_TREE_ITEM_EXPANDING    = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_EXPANDING   , 1)
 205 EVT_TREE_ITEM_COLLAPSED    = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_COLLAPSED   , 1)
 206 EVT_TREE_ITEM_COLLAPSING   = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_COLLAPSING  , 1)
 207 EVT_TREE_SEL_CHANGED       = wx.PyEventBinder(wxEVT_COMMAND_TREE_SEL_CHANGED      , 1)
 208 EVT_TREE_SEL_CHANGING      = wx.PyEventBinder(wxEVT_COMMAND_TREE_SEL_CHANGING     , 1)
 209 EVT_TREE_KEY_DOWN          = wx.PyEventBinder(wxEVT_COMMAND_TREE_KEY_DOWN         , 1)
 210 EVT_TREE_ITEM_ACTIVATED    = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_ACTIVATED   , 1)
 211 EVT_TREE_ITEM_RIGHT_CLICK  = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK , 1)
 212 EVT_TREE_ITEM_MIDDLE_CLICK = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_MIDDLE_CLICK, 1)
 213 EVT_TREE_END_DRAG          = wx.PyEventBinder(wxEVT_COMMAND_TREE_END_DRAG         , 1)
 214 EVT_TREE_STATE_IMAGE_CLICK = wx.PyEventBinder(wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK, 1)
 215 EVT_TREE_ITEM_GETTOOLTIP   = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP,   1)
 216 EVT_COMMAND_TREE_ITEM_MENU = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_MENU,         1)
 217 }
 218
 219
 220
 221 // wxTreeEvent is a special class for all events associated with tree controls
 222 //
 223 // NB: note that not all accessors make sense for all events, see the event
 224 //     descriptions below
 225 class wxTreeEvent : public wxNotifyEvent {
 226 public:
 227     wxTreeEvent(wxEventType commandType = wxEVT_NULL, int id = 0);
 228
 229         // get the item on which the operation was performed or the newly
 230         // selected item for wxEVT_COMMAND_TREE_SEL_CHANGED/ING events
 231     wxTreeItemId GetItem() const;
 232     void SetItem(const wxTreeItemId& item);
 233
 234         // for wxEVT_COMMAND_TREE_SEL_CHANGED/ING events, get the previously
 235         // selected item
 236     wxTreeItemId GetOldItem() const;
 237     void SetOldItem(const wxTreeItemId& item);
 238
 239         // the point where the mouse was when the drag operation started (for
 240         // wxEVT_COMMAND_TREE_BEGIN_(R)DRAG events only) or click position
 241     wxPoint GetPoint() const;
 242     void SetPoint(const wxPoint& pt);
 243
 244         // keyboard data (for wxEVT_COMMAND_TREE_KEY_DOWN only)
 245     const wxKeyEvent& GetKeyEvent() const;
 246     int GetKeyCode() const;
 247     void SetKeyEvent(const wxKeyEvent& evt);
 248
 249         // label (for EVT_TREE_{BEGIN|END}_LABEL_EDIT only)
 250     const wxString& GetLabel() const;
 251     void SetLabel(const wxString& label);
 252
 253         // edit cancel flag (for EVT_TREE_{BEGIN|END}_LABEL_EDIT only)
 254     bool IsEditCancelled() const;
 255     void SetEditCanceled(bool editCancelled);
 256
 257         // Set the tooltip for the item (for EVT_TREE_ITEM_GETTOOLTIP events)
 258     void SetToolTip(const wxString& toolTip);
 259     wxString GetToolTip();
 260 };
 261
 262 //---------------------------------------------------------------------------
 263 %newgroup
 264
 265 %{ // C++ version of Python aware wxTreeCtrl
 266 class wxPyTreeCtrl : public wxTreeCtrl {
 267     DECLARE_ABSTRACT_CLASS(wxPyTreeCtrl);
 268 public:
 269     wxPyTreeCtrl() : wxTreeCtrl() {}
 270     wxPyTreeCtrl(wxWindow *parent, wxWindowID id,
 271                  const wxPoint& pos,
 272                  const wxSize& size,
 273                  long style,
 274                  const wxValidator& validator,
 275                  const wxString& name) :
 276         wxTreeCtrl(parent, id, pos, size, style, validator, name) {}
 277
 278     bool Create(wxWindow *parent, wxWindowID id,
 279                 const wxPoint& pos,
 280                 const wxSize& size,
 281                 long style,
 282                 const wxValidator& validator,
 283                 const wxString& name) {
 284         return wxTreeCtrl::Create(parent, id, pos, size, style, validator, name);
 285     }
 286
 287
 288     int OnCompareItems(const wxTreeItemId& item1,
 289                        const wxTreeItemId& item2) {
 290         int rval = 0;
 291         bool found;
 292         wxPyBlock_t blocked = wxPyBeginBlockThreads();
 293         if ((found = wxPyCBH_findCallback(m_myInst, "OnCompareItems"))) {
 294             PyObject *o1 = wxPyConstructObject((void*)&item1, wxT("wxTreeItemId"), false);
 295             PyObject *o2 = wxPyConstructObject((void*)&item2, wxT("wxTreeItemId"), false);
 296             rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)",o1,o2));
 297             Py_DECREF(o1);
 298             Py_DECREF(o2);
 299         }
 300         wxPyEndBlockThreads(blocked);
 301         if (! found)
 302             rval = wxTreeCtrl::OnCompareItems(item1, item2);
 303         return rval;
 304     }
 305     PYPRIVATE;
 306 };
 307
 308 IMPLEMENT_ABSTRACT_CLASS(wxPyTreeCtrl, wxTreeCtrl);
 309
 310 %}
 311
 312
 313
 314
 315 MustHaveApp(wxPyTreeCtrl);
 316
 317 %rename(TreeCtrl) wxPyTreeCtrl;
 318 class wxPyTreeCtrl : public wxControl {
 319 public:
 320     %pythonAppend wxPyTreeCtrl         "self._setOORInfo(self);self._setCallbackInfo(self, TreeCtrl)"
 321     %pythonAppend wxPyTreeCtrl()       ""
 322     %typemap(out) wxPyTreeCtrl*;    // turn off this typemap
 323
 324     wxPyTreeCtrl(wxWindow *parent, wxWindowID id = -1,
 325                  const wxPoint& pos = wxDefaultPosition,
 326                  const wxSize& size = wxDefaultSize,
 327                  long style = wxTR_DEFAULT_STYLE,
 328                  const wxValidator& validator = wxDefaultValidator,
 329                  const wxString& name = wxPyTreeCtrlNameStr);
 330     %RenameCtor(PreTreeCtrl, wxPyTreeCtrl());
 331
 332     // Turn it back on again
 333     %typemap(out) wxPyTreeCtrl* { $result = wxPyMake_wxObject($1, $owner); }
 334
 335     bool Create(wxWindow *parent, wxWindowID id = -1,
 336                 const wxPoint& pos = wxDefaultPosition,
 337                 const wxSize& size = wxDefaultSize,
 338                 long style = wxTR_DEFAULT_STYLE,
 339                 const wxValidator& validator = wxDefaultValidator,
 340                 const wxString& name = wxPyTreeCtrlNameStr);
 341
 342     void _setCallbackInfo(PyObject* self, PyObject* _class);
 343
 344
 345     // get the total number of items in the control
 346     size_t GetCount() const;
 347
 348     // indent is the number of pixels the children are indented relative to
 349     // the parents position. SetIndent() also redraws the control
 350     // immediately.
 351     unsigned int GetIndent() const;
 352     void SetIndent(unsigned int indent);
 353
 354     // spacing is the number of pixels between the start and the Text
 355     // not implemented under wxMSW
 356     unsigned int GetSpacing() const;
 357     void SetSpacing(unsigned int spacing);
 358
 359
 360     // image list: these functions allow to associate an image list with
 361     // the control and retrieve it. Note that the control does _not_ delete
 362     // the associated image list when it's deleted in order to allow image
 363     // lists to be shared between different controls.
 364     //
 365     // The normal image list is for the icons which correspond to the
 366     // normal tree item state (whether it is selected or not).
 367     // Additionally, the application might choose to show a state icon
 368     // which corresponds to an app-defined item state (for example,
 369     // checked/unchecked) which are taken from the state image list.
 370     wxImageList *GetImageList() const;
 371     wxImageList *GetStateImageList() const;
 372
 373     void SetImageList(wxImageList *imageList);
 374     void SetStateImageList(wxImageList *imageList);
 375
 376     %apply SWIGTYPE *DISOWN { wxImageList *imageList };
 377     void AssignImageList(wxImageList *imageList);
 378     void AssignStateImageList(wxImageList *imageList);
 379     %clear wxImageList *imageList;
 380
 381
 382     // retrieve items label
 383     wxString GetItemText(const wxTreeItemId& item) const;
 384
 385     // get one of the images associated with the item (normal by default)
 386     int GetItemImage(const wxTreeItemId& item,
 387                      wxTreeItemIcon which = wxTreeItemIcon_Normal) const;
 388
 389     %extend {
 390         // get the wxPyTreeItemData associated with the tree item
 391         wxPyTreeItemData* GetItemData(const wxTreeItemId& item) {
 392             wxPyTreeItemData* data = (wxPyTreeItemData*)self->GetItemData(item);
 393             if (data == NULL) {
 394                 data = new wxPyTreeItemData();
 395                 data->SetId(item); // set the id
 396                 self->SetItemData(item, data);
 397             }
 398             return data;
 399         }
 400         // Get the Python object associated with the tree item
 401         PyObject* GetItemPyData(const wxTreeItemId& item) {
 402             wxPyTreeItemData* data = (wxPyTreeItemData*)self->GetItemData(item);
 403             if (data == NULL) {
 404                 data = new wxPyTreeItemData();
 405                 data->SetId(item); // set the id
 406                 self->SetItemData(item, data);
 407             }
 408             return data->GetData();
 409         }
 410     }
 411     %pythoncode { GetPyData = GetItemPyData }
 412
 413
 414     // get the item's text colour
 415     wxColour GetItemTextColour(const wxTreeItemId& item) const;
 416
 417     // get the item's background colour
 418     wxColour GetItemBackgroundColour(const wxTreeItemId& item) const;
 419
 420     // get the item's font
 421     wxFont GetItemFont(const wxTreeItemId& item) const;
 422
 423
 424
 425     // set items label
 426     void SetItemText(const wxTreeItemId& item, const wxString& text);
 427
 428     // get one of the images associated with the item (normal by default)
 429     void SetItemImage(const wxTreeItemId& item, int image,
 430                       wxTreeItemIcon which = wxTreeItemIcon_Normal);
 431
 432     %extend {
 433         // associate a wxPyTreeItemData with the tree item
 434         void SetItemData(const wxTreeItemId& item, wxPyTreeItemData* data) {
 435             data->SetId(item); // set the id
 436             self->SetItemData(item, data);
 437         }
 438
 439         // associate a Python object with the tree item
 440         void SetItemPyData(const wxTreeItemId& item, PyObject* obj) {
 441             wxPyTreeItemData* data = (wxPyTreeItemData*)self->GetItemData(item);
 442             if (data == NULL) {
 443                 data = new wxPyTreeItemData(obj);
 444                 data->SetId(item); // set the id
 445                 self->SetItemData(item, data);
 446             } else
 447                 data->SetData(obj);
 448         }
 449     }
 450     %pythoncode { SetPyData = SetItemPyData }
 451
 452
 453     // force appearance of [+] button near the item. This is useful to
 454     // allow the user to expand the items which don't have any children now
 455     // - but instead add them only when needed, thus minimizing memory
 456     // usage and loading time.
 457     void SetItemHasChildren(const wxTreeItemId& item, bool has = true);
 458
 459     // the item will be shown in bold
 460     void SetItemBold(const wxTreeItemId& item, bool bold = true);
 461
 462     // the item will be shown with a drop highlight
 463     void SetItemDropHighlight(const wxTreeItemId& item, bool highlight = true);
 464
 465     // set the items text colour
 466     void SetItemTextColour(const wxTreeItemId& item, const wxColour& col);
 467
 468     // set the items background colour
 469     void SetItemBackgroundColour(const wxTreeItemId& item, const wxColour& col);
 470
 471     // set the items font (should be of the same height for all items)
 472     void SetItemFont(const wxTreeItemId& item, const wxFont& font);
 473
 474
 475     // is the item visible (it might be outside the view or not expanded)?
 476     bool IsVisible(const wxTreeItemId& item) const;
 477
 478     // does the item has any children?
 479     bool ItemHasChildren(const wxTreeItemId& item) const;
 480
 481     // is the item expanded (only makes sense if HasChildren())?
 482     bool IsExpanded(const wxTreeItemId& item) const;
 483
 484     // is this item currently selected (the same as has focus)?
 485     bool IsSelected(const wxTreeItemId& item) const;
 486
 487     // is item text in bold font?
 488     bool IsBold(const wxTreeItemId& item) const;
 489
 490
 491     // if 'recursively' is False, only immediate children count, otherwise
 492     // the returned number is the number of all items in this branch
 493     size_t GetChildrenCount(const wxTreeItemId& item,
 494                             bool recursively = true) /*const*/;
 495
 496
 497
 498     // get the root tree item
 499     // wxTreeItemId.IsOk() will return False if there is no such item
 500     wxTreeItemId GetRootItem() const;
 501
 502     // get the item currently selected
 503     // wxTreeItemId.IsOk() will return False if there is no such item
 504     wxTreeItemId GetSelection() const;
 505
 506     %extend {
 507         // get the items currently selected, return the number of such item
 508         //
 509         // NB: this operation is expensive and can take a long time for a
 510         //     control with a lot of items (~ O(number of items)).
 511         PyObject* GetSelections() {
 512             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 513             PyObject*           rval = PyList_New(0);
 514             wxArrayTreeItemIds  array;
 515             size_t              num, x;
 516             num = self->GetSelections(array);
 517             for (x=0; x < num; x++) {
 518                 wxTreeItemId *tii = new wxTreeItemId(array.Item(x));
 519                 PyObject* item = wxPyConstructObject((void*)tii, wxT("wxTreeItemId"), true);
 520                 PyList_Append(rval, item);
 521                 Py_DECREF(item);
 522             }
 523             wxPyEndBlockThreads(blocked);
 524             return rval;
 525         }
 526     }
 527
 528     // get the parent of this item
 529     // wxTreeItemId.IsOk() will return False if there is no such item
 530     wxTreeItemId GetItemParent(const wxTreeItemId& item) const;
 531
 532
 533     // NOTE: These are a copy of the same methods in gizmos.i, be sure to
 534     // update both at the same time.  (Or find a good way to refactor!)
 535     %extend {
 536         // Get the first child of this item.  Returns a wxTreeItemId and an
 537         // opaque "cookie" value that should be passed to GetNextChild in
 538         // order to continue the search.
 539         PyObject* GetFirstChild(const wxTreeItemId& item) {
 540             void* cookie = 0;
 541             wxTreeItemId* ritem = new wxTreeItemId(self->GetFirstChild(item, cookie));
 542             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 543             PyObject* tup = PyTuple_New(2);
 544             PyTuple_SET_ITEM(tup, 0, wxPyConstructObject(ritem, wxT("wxTreeItemId"), true));
 545             PyTuple_SET_ITEM(tup, 1, wxPyMakeSwigPtr(cookie, wxT("void")));
 546             wxPyEndBlockThreads(blocked);
 547             return tup;
 548         }
 549
 550
 551         // Get the next child of this item.  The cookie parameter is the 2nd
 552         // value returned from GetFirstChild or the previous GetNextChild.
 553         // Returns a wxTreeItemId and an opaque "cookie" value that should be
 554         // passed to GetNextChild in order to continue the search.
 555         PyObject* GetNextChild(const wxTreeItemId& item, void* cookie) {
 556             wxTreeItemId* ritem = new wxTreeItemId(self->GetNextChild(item, cookie));
 557             wxPyBlock_t blocked = wxPyBeginBlockThreads();
 558             PyObject* tup = PyTuple_New(2);
 559             PyTuple_SET_ITEM(tup, 0, wxPyConstructObject(ritem, wxT("wxTreeItemId"), true));
 560             PyTuple_SET_ITEM(tup, 1, wxPyMakeSwigPtr(cookie, wxT("void")));
 561             wxPyEndBlockThreads(blocked);
 562             return tup;
 563         }
 564     }
 565
 566     // get the last child of this item
 567     wxTreeItemId GetLastChild(const wxTreeItemId& item) const;
 568
 569     // get the next sibling of this item
 570     wxTreeItemId GetNextSibling(const wxTreeItemId& item) const;
 571
 572     // get the previous sibling
 573     wxTreeItemId GetPrevSibling(const wxTreeItemId& item) const;
 574
 575     // get first visible item
 576     wxTreeItemId GetFirstVisibleItem() const;
 577
 578     // get the next visible item: item must be visible itself!
 579     // see IsVisible() and wxTreeCtrl::GetFirstVisibleItem()
 580     wxTreeItemId GetNextVisible(const wxTreeItemId& item) const;
 581
 582     // get the previous visible item: item must be visible itself!
 583     wxTreeItemId GetPrevVisible(const wxTreeItemId& item) const;
 584
 585
 586
 587     // add the root node to the tree
 588     wxTreeItemId AddRoot(const wxString& text,
 589                          int image = -1, int selectedImage = -1,
 590                          wxPyTreeItemData *data = NULL);
 591
 592     // insert a new item in as the first child of the parent
 593     wxTreeItemId PrependItem(const wxTreeItemId& parent,
 594                              const wxString& text,
 595                              int image = -1, int selectedImage = -1,
 596                              wxPyTreeItemData *data = NULL);
 597
 598     // insert a new item after a given one
 599     wxTreeItemId InsertItem(const wxTreeItemId& parent,
 600                             const wxTreeItemId& idPrevious,
 601                             const wxString& text,
 602                             int image = -1, int selectedImage = -1,
 603                             wxPyTreeItemData *data = NULL);
 604
 605     // insert a new item before the one with the given index
 606     %Rename(InsertItemBefore,
 607     wxTreeItemId, InsertItem(const wxTreeItemId& parent,
 608                             size_t index,
 609                             const wxString& text,
 610                             int image = -1, int selectedImage = -1,
 611                             wxPyTreeItemData *data = NULL));
 612
 613         // insert a new item in as the last child of the parent
 614     wxTreeItemId AppendItem(const wxTreeItemId& parent,
 615                             const wxString& text,
 616                             int image = -1, int selectedImage = -1,
 617                             wxPyTreeItemData *data = NULL);
 618
 619
 620
 621     // delete this item and associated data if any
 622     void Delete(const wxTreeItemId& item);
 623
 624     // delete all children (but don't delete the item itself)
 625     // NB: this won't send wxEVT_COMMAND_TREE_ITEM_DELETED events
 626     void DeleteChildren(const wxTreeItemId& item);
 627
 628     // delete all items from the tree
 629     // NB: this won't send wxEVT_COMMAND_TREE_ITEM_DELETED events
 630     void DeleteAllItems();
 631
 632
 633     // expand this item
 634     void Expand(const wxTreeItemId& item);
 635
 636     // collapse the item without removing its children
 637     void Collapse(const wxTreeItemId& item);
 638
 639     // collapse the item and remove all children
 640     void CollapseAndReset(const wxTreeItemId& item);
 641
 642     // toggles the current state
 643     void Toggle(const wxTreeItemId& item);
 644
 645
 646     // remove the selection from currently selected item (if any)
 647     void Unselect();
 648
 649     // remove the selection from the given one (multiselect mode only)
 650     void UnselectItem(const wxTreeItemId& item);
 651
 652     // unselect all items (only makes sense for multiple selection control)
 653     void UnselectAll();
 654
 655     // select this item
 656     void SelectItem(const wxTreeItemId& item, bool select = true);
 657
 658     // toggle the item selection
 659     void ToggleItemSelection(const wxTreeItemId& item);
 660
 661
 662     // make sure this item is visible (expanding the parent item and/or
 663     // scrolling to this item if necessary)
 664     void EnsureVisible(const wxTreeItemId& item);
 665
 666     // scroll to this item (but don't expand its parent)
 667     void ScrollTo(const wxTreeItemId& item);
 668
 669
 670
 671     // start editing the item label: this (temporarily) replaces the item
 672     // with a one line edit control. The item will be selected if it hadn't
 673     // been before.
 674     /**wxTextCtrl* */ void  EditLabel(const wxTreeItemId& item);
 675
 676     // returns the same pointer as StartEdit() if the item is being edited,
 677     // NULL otherwise (it's assumed that no more than one item may be
 678     // edited simultaneously)
 679     wxTextCtrl* GetEditControl() const;
 680
 681 #ifdef __WXMSW__
 682     // end editing and accept or discard the changes to item label
 683     void EndEditLabel(const wxTreeItemId& item, bool discardChanges = false);
 684 #endif
 685
 686
 687     // Sort the children of this item using OnCompareItems, a member function
 688     // that is called to compare 2 items and should return -1, 0 or +1 if the
 689     // first item is less than, equal to or greater than the second one. The
 690     // base class version performs alphabetic comparaison of item labels
 691     // (GetText)
 692     void SortChildren(const wxTreeItemId& item);
 693
 694
 695
 696     DocDeclAStr(
 697         wxTreeItemId, HitTest(const wxPoint& point, int& OUTPUT),
 698         "HitTest(Point point) -> (item, where)",
 699         "Determine which item (if any) belongs the given point.  The coordinates
 700 specified are relative to the client area of tree ctrl and the where return
 701 value is set to a bitmask of wxTREE_HITTEST_xxx constants.
 702 ", "");
 703
 704
 705     %extend {
 706         // get the bounding rectangle of the item (or of its label only)
 707         PyObject* GetBoundingRect(const wxTreeItemId& item,  bool textOnly = false) {
 708              wxRect rect;
 709             if (self->GetBoundingRect(item, rect, textOnly)) {
 710                 wxPyBlock_t blocked = wxPyBeginBlockThreads();
 711                 wxRect* r = new wxRect(rect);
 712                 PyObject* val = wxPyConstructObject((void*)r, wxT("wxRect"), true);
 713                 wxPyEndBlockThreads(blocked);
 714                 return val;
 715             }
 716             else
 717                 RETURN_NONE();
 718         }
 719     }
 720
 721 #ifdef __WXMSW__
 722     // set/get the item state.image (state == -1 means cycle to the next one)
 723     void SetState(const wxTreeItemId& node, int state);
 724     int GetState(const wxTreeItemId& node);
 725 #endif
 726
 727     static wxVisualAttributes
 728     GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
 729 };
 730
 731
 732 //---------------------------------------------------------------------------
 733 %init %{
 734     // Map renamed classes back to their common name for OOR
 735     wxPyPtrTypeMap_Add("wxTreeItemData", "wxPyTreeItemData");
 736     wxPyPtrTypeMap_Add("wxTreeCtrl", "wxPyTreeCtrl");
 737 %}
 738 //---------------------------------------------------------------------------