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