]> git.saurik.com Git - wxWidgets.git/blob - wxPython/contrib/gizmos/gizmos.i
warning fix
[wxWidgets.git] / wxPython / contrib / gizmos / gizmos.i
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: gizmos.i
3 // Purpose: Wrappers for the "gizmo" classes in wx/contrib
4 //
5 // Author: Robin Dunn
6 //
7 // Created: 23-Nov-2001
8 // RCS-ID: $Id$
9 // Copyright: (c) 2001 by Total Control Software
10 // Licence: wxWindows license
11 /////////////////////////////////////////////////////////////////////////////
12
13 %define DOCSTRING
14 "Various *gizmo* classes: `DynamicSashWindow`, `EditableListBox`,
15 `LEDNumberCtrl`, `TreeListCtrl`, etc."
16 %enddef
17
18 %module(package="wx", docstring=DOCSTRING) gizmos
19
20
21 %{
22 #include "wx/wxPython/wxPython.h"
23 #include "wx/wxPython/pyclasses.h"
24
25 #include <wx/gizmos/dynamicsash.h>
26 #include <wx/gizmos/editlbox.h>
27 #include <wx/gizmos/splittree.h>
28 #include <wx/gizmos/ledctrl.h>
29
30 #include <wx/listctrl.h>
31 #include <wx/treectrl.h>
32 #include <wx/imaglist.h>
33
34 #include "wx/treelistctrl.h"
35 #include "wx/wxPython/pytree.h"
36
37 %}
38
39 //---------------------------------------------------------------------------
40
41 %import windows.i
42 %import controls.i
43 %pythoncode { import wx }
44 %pythoncode { __docfilter__ = wx._core.__DocFilter(globals()) }
45
46
47 MAKE_CONST_WXSTRING2(DynamicSashNameStr, wxT("dynamicSashWindow"));
48 MAKE_CONST_WXSTRING2(EditableListBoxNameStr, wxT("editableListBox"));
49 MAKE_CONST_WXSTRING2(TreeListCtrlNameStr, wxT("treelistctrl"));
50
51 MAKE_CONST_WXSTRING_NOSWIG(EmptyString);
52
53
54 %include _gizmos_rename.i
55
56 //---------------------------------------------------------------------------
57
58 enum {
59 wxEVT_DYNAMIC_SASH_SPLIT,
60 wxEVT_DYNAMIC_SASH_UNIFY,
61
62 wxDS_MANAGE_SCROLLBARS,
63 wxDS_DRAG_CORNER,
64 };
65
66
67 /*
68 wxDynamicSashSplitEvents are sent to your view by wxDynamicSashWindow
69 whenever your view is being split by the user. It is your
70 responsibility to handle this event by creating a new view window as
71 a child of the wxDynamicSashWindow. wxDynamicSashWindow will
72 automatically reparent it to the proper place in its window hierarchy.
73 */
74 class wxDynamicSashSplitEvent : public wxCommandEvent {
75 public:
76 wxDynamicSashSplitEvent(wxObject *target);
77 };
78
79
80 /*
81 wxDynamicSashUnifyEvents are sent to your view by wxDynamicSashWindow
82 whenever the sash which splits your view and its sibling is being
83 reunified such that your view is expanding to replace its sibling.
84 You needn't do anything with this event if you are allowing
85 wxDynamicSashWindow to manage your view's scrollbars, but it is useful
86 if you are managing the scrollbars yourself so that you can keep
87 the scrollbars' event handlers connected to your view's event handler
88 class.
89 */
90 class wxDynamicSashUnifyEvent : public wxCommandEvent {
91 public:
92 wxDynamicSashUnifyEvent(wxObject *target);
93 };
94
95
96
97 /*
98
99 wxDynamicSashWindow
100
101 wxDynamicSashWindow widgets manages the way other widgets are viewed.
102 When a wxDynamicSashWindow is first shown, it will contain one child
103 view, a viewport for that child, and a pair of scrollbars to allow the
104 user to navigate the child view area. Next to each scrollbar is a small
105 tab. By clicking on either tab and dragging to the appropriate spot, a
106 user can split the view area into two smaller views separated by a
107 draggable sash. Later, when the user wishes to reunify the two subviews,
108 the user simply drags the sash to the side of the window.
109 wxDynamicSashWindow will automatically reparent the appropriate child
110 view back up the window hierarchy, and the wxDynamicSashWindow will have
111 only one child view once again.
112
113 As an application developer, you will simply create a wxDynamicSashWindow
114 using either the Create() function or the more complex constructor
115 provided below, and then create a view window whose parent is the
116 wxDynamicSashWindow. The child should respond to
117 wxDynamicSashSplitEvents -- perhaps with an OnSplit() event handler -- by
118 constructing a new view window whose parent is also the
119 wxDynamicSashWindow. That's it! Now your users can dynamically split
120 and reunify the view you provided.
121
122 If you wish to handle the scrollbar events for your view, rather than
123 allowing wxDynamicSashWindow to do it for you, things are a bit more
124 complex. (You might want to handle scrollbar events yourself, if,
125 for instance, you wish to scroll a subwindow of the view you add to
126 your wxDynamicSashWindow object, rather than scrolling the whole view.)
127 In this case, you will need to construct your wxDynamicSashWindow without
128 the wxDS_MANAGE_SCROLLBARS style and you will need to use the
129 GetHScrollBar() and GetVScrollBar() methods to retrieve the scrollbar
130 controls and call SetEventHanler() on them to redirect the scrolling
131 events whenever your window is reparented by wxDyanmicSashWindow.
132 You will need to set the scrollbars' event handler at three times:
133
134 * When your view is created
135 * When your view receives a wxDynamicSashSplitEvent
136 * When your view receives a wxDynamicSashUnifyEvent
137
138 See the dynsash_switch sample application for an example which does this.
139
140 */
141
142 MustHaveApp(wxDynamicSashWindow);
143
144 class wxDynamicSashWindow : public wxWindow {
145 public:
146 %pythonAppend wxDynamicSashWindow "self._setOORInfo(self)"
147 %pythonAppend wxDynamicSashWindow() ""
148
149 wxDynamicSashWindow(wxWindow *parent, wxWindowID id=-1,
150 const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
151 long style = wxCLIP_CHILDREN | wxDS_MANAGE_SCROLLBARS | wxDS_DRAG_CORNER,
152 const wxString& name = wxPyDynamicSashNameStr);
153 %RenameCtor(PreDynamicSashWindow, wxDynamicSashWindow());
154
155 bool Create(wxWindow *parent, wxWindowID id=-1,
156 const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
157 long style = wxCLIP_CHILDREN | wxDS_MANAGE_SCROLLBARS | wxDS_DRAG_CORNER,
158 const wxString& name = wxPyDynamicSashNameStr);
159
160 wxScrollBar *GetHScrollBar(const wxWindow *child) const;
161 wxScrollBar *GetVScrollBar(const wxWindow *child) const;
162 };
163
164
165
166 %pythoncode {
167 EVT_DYNAMIC_SASH_SPLIT = wx.PyEventBinder( wxEVT_DYNAMIC_SASH_SPLIT, 1 )
168 EVT_DYNAMIC_SASH_UNIFY = wx.PyEventBinder( wxEVT_DYNAMIC_SASH_UNIFY, 1 )
169 }
170
171 //---------------------------------------------------------------------------
172 //---------------------------------------------------------------------------
173
174 enum {
175 wxEL_ALLOW_NEW,
176 wxEL_ALLOW_EDIT,
177 wxEL_ALLOW_DELETE,
178 };
179
180 // This class provides a composite control that lets the
181 // user easily enter list of strings
182 MustHaveApp(wxEditableListBox);
183 class wxEditableListBox : public wxPanel
184 {
185 public:
186 %pythonAppend wxEditableListBox "self._setOORInfo(self)"
187 %pythonAppend wxEditableListBox() ""
188
189 wxEditableListBox(wxWindow *parent, wxWindowID id=-1,
190 const wxString& label = wxPyEmptyString,
191 const wxPoint& pos = wxDefaultPosition,
192 const wxSize& size = wxDefaultSize,
193 long style = wxEL_ALLOW_NEW | wxEL_ALLOW_EDIT | wxEL_ALLOW_DELETE,
194 const wxString& name = wxPyEditableListBoxNameStr);
195
196
197 void SetStrings(const wxArrayString& strings);
198
199 //void GetStrings(wxArrayString& strings);
200 %extend {
201 PyObject* GetStrings() {
202 wxArrayString strings;
203 self->GetStrings(strings);
204 return wxArrayString2PyList_helper(strings);
205 }
206 }
207
208 wxPyListCtrl* GetListCtrl();
209 wxBitmapButton* GetDelButton();
210 wxBitmapButton* GetNewButton();
211 wxBitmapButton* GetUpButton();
212 wxBitmapButton* GetDownButton();
213 wxBitmapButton* GetEditButton();
214 };
215
216
217
218 //---------------------------------------------------------------------------
219
220
221 /*
222 * wxRemotelyScrolledTreeCtrl
223 *
224 * This tree control disables its vertical scrollbar and catches scroll
225 * events passed by a scrolled window higher in the hierarchy.
226 * It also updates the scrolled window vertical scrollbar as appropriate.
227 */
228
229 %{
230 typedef wxTreeCtrl wxPyTreeCtrl;
231 %}
232
233 MustHaveApp(wxRemotelyScrolledTreeCtrl);
234
235 class wxRemotelyScrolledTreeCtrl: public wxPyTreeCtrl
236 {
237 public:
238 %pythonAppend wxRemotelyScrolledTreeCtrl "self._setOORInfo(self)"
239 %pythonAppend wxRemotelyScrolledTreeCtrl() ""
240
241 wxRemotelyScrolledTreeCtrl(wxWindow* parent, wxWindowID id,
242 const wxPoint& pos = wxDefaultPosition,
243 const wxSize& size = wxDefaultSize,
244 long style = wxTR_HAS_BUTTONS);
245
246
247 void HideVScrollbar();
248
249 // Adjust the containing wxScrolledWindow's scrollbars appropriately
250 void AdjustRemoteScrollbars();
251
252 // Find the scrolled window that contains this control
253 wxScrolledWindow* GetScrolledWindow() const;
254
255 // Scroll to the given line (in scroll units where each unit is
256 // the height of an item)
257 void ScrollToLine(int posHoriz, int posVert);
258
259 // The companion window is one which will get notified when certain
260 // events happen such as node expansion
261 void SetCompanionWindow(wxWindow* companion);
262 wxWindow* GetCompanionWindow() const;
263 };
264
265
266
267 /*
268 * wxTreeCompanionWindow
269 *
270 * A window displaying values associated with tree control items.
271 */
272
273 %{
274 class wxPyTreeCompanionWindow: public wxTreeCompanionWindow
275 {
276 public:
277 wxPyTreeCompanionWindow(wxWindow* parent, wxWindowID id = -1,
278 const wxPoint& pos = wxDefaultPosition,
279 const wxSize& size = wxDefaultSize,
280 long style = 0)
281 : wxTreeCompanionWindow(parent, id, pos, size, style) {}
282
283
284 virtual void DrawItem(wxDC& dc, wxTreeItemId id, const wxRect& rect) {
285 bool found;
286 bool blocked = wxPyBeginBlockThreads();
287 if ((found = wxPyCBH_findCallback(m_myInst, "DrawItem"))) {
288 PyObject* dcobj = wxPyMake_wxObject(&dc,false);
289 PyObject* idobj = wxPyConstructObject((void*)&id, wxT("wxTreeItemId"), false);
290 PyObject* recobj= wxPyConstructObject((void*)&rect, wxT("wxRect"), false);
291 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOO)", dcobj, idobj, recobj));
292 Py_DECREF(dcobj);
293 Py_DECREF(idobj);
294 Py_DECREF(recobj);
295 }
296 wxPyEndBlockThreads(blocked);
297 if (! found)
298 wxTreeCompanionWindow::DrawItem(dc, id, rect);
299 }
300
301 PYPRIVATE;
302 };
303 %}
304
305
306 MustHaveApp(wxPyTreeCompanionWindow);
307
308 %rename(TreeCompanionWindow) wxPyTreeCompanionWindow;
309 class wxPyTreeCompanionWindow: public wxWindow
310 {
311 public:
312 %pythonAppend wxPyTreeCompanionWindow "self._setOORInfo(self);self._setCallbackInfo(self, TreeCompanionWindow)"
313 %pythonAppend wxPyTreeCompanionWindow() ""
314
315 wxPyTreeCompanionWindow(wxWindow* parent, wxWindowID id = -1,
316 const wxPoint& pos = wxDefaultPosition,
317 const wxSize& size = wxDefaultSize,
318 long style = 0);
319 void _setCallbackInfo(PyObject* self, PyObject* _class);
320
321 wxRemotelyScrolledTreeCtrl* GetTreeCtrl() const;
322 void SetTreeCtrl(wxRemotelyScrolledTreeCtrl* treeCtrl);
323 };
324
325
326
327 /*
328 * wxThinSplitterWindow
329 *
330 * Implements a splitter with a less obvious sash
331 * than the usual one.
332 */
333
334 MustHaveApp(wxThinSplitterWindow);
335
336 class wxThinSplitterWindow: public wxSplitterWindow
337 {
338 public:
339 %pythonAppend wxThinSplitterWindow "self._setOORInfo(self)"
340 %pythonAppend wxThinSplitterWindow() ""
341
342 wxThinSplitterWindow(wxWindow* parent, wxWindowID id = -1,
343 const wxPoint& pos = wxDefaultPosition,
344 const wxSize& size = wxDefaultSize,
345 long style = wxSP_3D | wxCLIP_CHILDREN);
346 };
347
348
349
350 /*
351 * wxSplitterScrolledWindow
352 *
353 * This scrolled window is aware of the fact that one of its
354 * children is a splitter window. It passes on its scroll events
355 * (after some processing) to both splitter children for them
356 * scroll appropriately.
357 */
358
359 MustHaveApp(wxSplitterScrolledWindow);
360
361 class wxSplitterScrolledWindow: public wxScrolledWindow
362 {
363 public:
364 %pythonAppend wxSplitterScrolledWindow "self._setOORInfo(self)"
365 %pythonAppend wxSplitterScrolledWindow() ""
366
367 wxSplitterScrolledWindow(wxWindow* parent, wxWindowID id = -1,
368 const wxPoint& pos = wxDefaultPosition,
369 const wxSize& size = wxDefaultSize,
370 long style = 0);
371 };
372
373
374 //---------------------------------------------------------------------------
375 //---------------------------------------------------------------------------
376
377
378 enum wxLEDValueAlign
379 {
380 wxLED_ALIGN_LEFT,
381 wxLED_ALIGN_RIGHT,
382 wxLED_ALIGN_CENTER,
383
384 wxLED_ALIGN_MASK,
385
386 wxLED_DRAW_FADED,
387 };
388
389
390 MustHaveApp(wxLEDNumberCtrl);
391
392 class wxLEDNumberCtrl : public wxControl
393 {
394 public:
395 %pythonAppend wxLEDNumberCtrl "self._setOORInfo(self)"
396 %pythonAppend wxLEDNumberCtrl() ""
397
398 wxLEDNumberCtrl(wxWindow *parent, wxWindowID id = -1,
399 const wxPoint& pos = wxDefaultPosition,
400 const wxSize& size = wxDefaultSize,
401 long style = wxLED_ALIGN_LEFT | wxLED_DRAW_FADED);
402 %RenameCtor(PreLEDNumberCtrl, wxLEDNumberCtrl());
403
404 bool Create(wxWindow *parent, wxWindowID id = -1,
405 const wxPoint& pos = wxDefaultPosition,
406 const wxSize& size = wxDefaultSize,
407 long style = wxLED_ALIGN_LEFT | wxLED_DRAW_FADED);
408
409 wxLEDValueAlign GetAlignment() const;
410 bool GetDrawFaded() const;
411 const wxString &GetValue() const;
412
413 void SetAlignment(wxLEDValueAlign Alignment, bool Redraw = true);
414 void SetDrawFaded(bool DrawFaded, bool Redraw = true);
415 void SetValue(const wxString &Value, bool Redraw = true);
416
417 };
418
419
420
421 //----------------------------------------------------------------------------
422 // wxTreeListCtrl - the multicolumn tree control
423 //----------------------------------------------------------------------------
424
425 enum wxTreeListColumnAlign {
426 wxTL_ALIGN_LEFT,
427 wxTL_ALIGN_RIGHT,
428 wxTL_ALIGN_CENTER
429 };
430
431
432
433 enum {
434 wxTREE_HITTEST_ONITEMCOLUMN
435 };
436
437
438 enum {
439 // flags for FindItem
440 wxTL_SEARCH_VISIBLE,
441 wxTL_SEARCH_LEVEL,
442 wxTL_SEARCH_FULL,
443 wxTL_SEARCH_PARTIAL,
444 wxTL_SEARCH_NOCASE
445 };
446
447 enum {
448 // extra tree styles
449 wxTR_DONT_ADJUST_MAC
450 };
451 %pythoncode { wx.TR_DONT_ADJUST_MAC = TR_DONT_ADJUST_MAC }
452
453
454 class wxTreeListColumnInfo: public wxObject {
455 public:
456 wxTreeListColumnInfo(const wxString& text = wxPyEmptyString,
457 int image = -1,
458 size_t width = 100,
459 bool shown = true,
460 wxTreeListColumnAlign alignment = wxTL_ALIGN_LEFT);
461
462 bool GetShown() const;
463 wxTreeListColumnAlign GetAlignment() const;
464 wxString GetText() const;
465 int GetImage() const;
466 int GetSelectedImage() const;
467 size_t GetWidth() const;
468
469 // TODO: These all actually return wxTreeListColumnInfo&, any problem with doing it for Python too?
470 void SetShown(bool shown);
471 void SetAlignment(wxTreeListColumnAlign alignment);
472 void SetText(const wxString& text);
473 void SetImage(int image);
474 void SetSelectedImage(int image);
475 void SetWidth(size_t with);
476 };
477
478
479
480
481 %{ // C++ version of Python aware control
482 class wxPyTreeListCtrl : public wxTreeListCtrl {
483 DECLARE_ABSTRACT_CLASS(wxPyTreeListCtrl);
484 public:
485 wxPyTreeListCtrl() : wxTreeListCtrl() {}
486 wxPyTreeListCtrl(wxWindow *parent, wxWindowID id,
487 const wxPoint& pos,
488 const wxSize& size,
489 long style,
490 const wxValidator &validator,
491 const wxString& name) :
492 wxTreeListCtrl(parent, id, pos, size, style, validator, name) {}
493
494 int OnCompareItems(const wxTreeItemId& item1,
495 const wxTreeItemId& item2) {
496 int rval = 0;
497 bool found;
498 bool blocked = wxPyBeginBlockThreads();
499 if ((found = wxPyCBH_findCallback(m_myInst, "OnCompareItems"))) {
500 PyObject *o1 = wxPyConstructObject((void*)&item1, wxT("wxTreeItemId"), 0);
501 PyObject *o2 = wxPyConstructObject((void*)&item2, wxT("wxTreeItemId"), 0);
502 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OO)",o1,o2));
503 Py_DECREF(o1);
504 Py_DECREF(o2);
505 }
506 wxPyEndBlockThreads(blocked);
507 if (! found)
508 rval = wxTreeListCtrl::OnCompareItems(item1, item2);
509 return rval;
510 }
511 PYPRIVATE;
512 };
513
514 IMPLEMENT_ABSTRACT_CLASS(wxPyTreeListCtrl, wxTreeListCtrl)
515
516 %}
517
518
519
520
521
522
523 MustHaveApp(wxPyTreeListCtrl);
524
525 %rename(TreeListCtrl) wxPyTreeListCtrl;
526 class wxPyTreeListCtrl : public wxControl
527 {
528 public:
529 %pythonAppend wxPyTreeListCtrl "self._setOORInfo(self);self._setCallbackInfo(self, TreeListCtrl)"
530 %pythonAppend wxPyTreeListCtrl() ""
531
532 wxPyTreeListCtrl(wxWindow *parent, wxWindowID id = -1,
533 const wxPoint& pos = wxDefaultPosition,
534 const wxSize& size = wxDefaultSize,
535 long style = wxTR_DEFAULT_STYLE,
536 const wxValidator &validator = wxDefaultValidator,
537 const wxString& name = wxPyTreeListCtrlNameStr );
538 %RenameCtor(PreTreeListCtrl, wxPyTreeListCtrl());
539
540 bool Create(wxWindow *parent, wxWindowID id = -1,
541 const wxPoint& pos = wxDefaultPosition,
542 const wxSize& size = wxDefaultSize,
543 long style = wxTR_DEFAULT_STYLE,
544 const wxValidator &validator = wxDefaultValidator,
545 const wxString& name = wxPyTreeListCtrlNameStr );
546
547 void _setCallbackInfo(PyObject* self, PyObject* _class);
548
549
550 // get the total number of items in the control
551 size_t GetCount() const;
552
553 // indent is the number of pixels the children are indented relative to
554 // the parents position. SetIndent() also redraws the control
555 // immediately.
556 unsigned int GetIndent() const;
557 void SetIndent(unsigned int indent);
558
559 // line spacing is the space above and below the text on each line
560 unsigned int GetLineSpacing() const;
561 void SetLineSpacing(unsigned int spacing);
562
563 // image list: these functions allow to associate an image list with
564 // the control and retrieve it. Note that when assigned with
565 // SetImageList, the control does _not_ delete
566 // the associated image list when it's deleted in order to allow image
567 // lists to be shared between different controls. If you use
568 // AssignImageList, the control _does_ delete the image list.
569 //
570 // The normal image list is for the icons which correspond to the
571 // normal tree item state (whether it is selected or not).
572 // Additionally, the application might choose to show a state icon
573 // which corresponds to an app-defined item state (for example,
574 // checked/unchecked) which are taken from the state image list.
575 wxImageList *GetImageList() const;
576 wxImageList *GetStateImageList() const;
577 wxImageList *GetButtonsImageList() const;
578
579 void SetImageList(wxImageList *imageList);
580 void SetStateImageList(wxImageList *imageList);
581 void SetButtonsImageList(wxImageList *imageList);
582
583 %apply SWIGTYPE *DISOWN { wxImageList *imageList };
584 void AssignImageList(wxImageList *imageList);
585 void AssignStateImageList(wxImageList *imageList);
586 void AssignButtonsImageList(wxImageList *imageList);
587 %clear wxImageList *imageList;
588
589
590 // adds a column
591 void AddColumn(const wxString& text);
592 // void AddColumn(const wxString& text,
593 // size_t width,
594 // wxTreeListColumnAlign alignment = wxTL_ALIGN_LEFT);
595 %Rename(AddColumnInfo, void, AddColumn(const wxTreeListColumnInfo& col));
596
597 // inserts a column before the given one
598 void InsertColumn(size_t before, const wxString& text);
599 %Rename(InsertColumnInfo, void, InsertColumn(size_t before, const wxTreeListColumnInfo& col));
600
601 // deletes the given column - does not delete the corresponding column
602 // of each item
603 void RemoveColumn(size_t column);
604
605 // returns the number of columns in the ctrl
606 size_t GetColumnCount() const;
607
608 void SetColumnWidth(size_t column, size_t width);
609 int GetColumnWidth(size_t column) const;
610
611 // tells which column is the "main" one, i.e. the "threaded" one
612 void SetMainColumn(size_t column);
613 size_t GetMainColumn() const;
614
615 void SetColumnText(size_t column, const wxString& text);
616 wxString GetColumnText(size_t column) const;
617
618 void SetColumn(size_t column, const wxTreeListColumnInfo& info);
619 wxTreeListColumnInfo& GetColumn(size_t column);
620
621 // other column-related methods
622 void SetColumnAlignment(size_t column, wxTreeListColumnAlign align);
623 wxTreeListColumnAlign GetColumnAlignment(size_t column) const;
624
625 void SetColumnImage(size_t column, int image);
626 int GetColumnImage(size_t column) const;
627
628 void ShowColumn(size_t column, bool shown);
629 bool IsColumnShown(size_t column) const;
630
631 %extend {
632 // retrieves item's label of the given column (main column by default)
633 wxString GetItemText(const wxTreeItemId& item, int column = -1) {
634 if (column < 0) column = self->GetMainColumn();
635 return self->GetItemText(item, column);
636 }
637
638 // get one of the images associated with the item (normal by default)
639 int GetItemImage(const wxTreeItemId& item, int column = -1,
640 wxTreeItemIcon which = wxTreeItemIcon_Normal) {
641 if (column < 0) column = self->GetMainColumn();
642 return self->GetItemImage(item, column, which);
643 }
644
645 // set item's label (main column by default)
646 void SetItemText(const wxTreeItemId& item, const wxString& text, int column = -1) {
647 if (column < 0) column = self->GetMainColumn();
648 self->SetItemText(item, column, text);
649 }
650
651 // set one of the images associated with the item (normal by default)
652 // the which parameter is ignored for all columns but the main one
653 void SetItemImage(const wxTreeItemId& item, int image, int column = -1,
654 wxTreeItemIcon which = wxTreeItemIcon_Normal) {
655 if (column < 0) column = self->GetMainColumn();
656 self->SetItemImage(item, column, image, which);
657 }
658
659
660 // [Get|Set]ItemData substitutes. Automatically create wxPyTreeItemData
661 // if needed.
662 wxPyTreeItemData* GetItemData(const wxTreeItemId& item) {
663 wxPyTreeItemData* data = (wxPyTreeItemData*)self->GetItemData(item);
664 if (data == NULL) {
665 data = new wxPyTreeItemData();
666 data->SetId(item); // set the id
667 self->SetItemData(item, data);
668 }
669 return data;
670 }
671
672 void SetItemData(const wxTreeItemId& item, wxPyTreeItemData* data) {
673 data->SetId(item); // set the id
674 self->SetItemData(item, data);
675 }
676
677 // [Get|Set]ItemPyData are short-cuts. Also made somewhat crash-proof by
678 // automatically creating data classes.
679 PyObject* GetItemPyData(const wxTreeItemId& item) {
680 wxPyTreeItemData* data = (wxPyTreeItemData*)self->GetItemData(item);
681 if (data == NULL) {
682 data = new wxPyTreeItemData();
683 data->SetId(item); // set the id
684 self->SetItemData(item, data);
685 }
686 return data->GetData();
687 }
688
689 void SetItemPyData(const wxTreeItemId& item, PyObject* obj) {
690 wxPyTreeItemData* data = (wxPyTreeItemData*)self->GetItemData(item);
691 if (data == NULL) {
692 data = new wxPyTreeItemData(obj);
693 data->SetId(item); // set the id
694 self->SetItemData(item, data);
695 } else
696 data->SetData(obj);
697 }
698 }
699 %pythoncode { GetPyData = GetItemPyData }
700 %pythoncode { SetPyData = SetItemPyData }
701
702
703 // force appearance of [+] button near the item. This is useful to
704 // allow the user to expand the items which don't have any children now
705 // - but instead add them only when needed, thus minimizing memory
706 // usage and loading time.
707 void SetItemHasChildren(const wxTreeItemId& item, bool has = true);
708
709 // the item will be shown in bold
710 void SetItemBold(const wxTreeItemId& item, bool bold = true);
711
712 // set the item's text colour
713 void SetItemTextColour(const wxTreeItemId& item, const wxColour& colour);
714
715 // set the item's background colour
716 void SetItemBackgroundColour(const wxTreeItemId& item,
717 const wxColour& colour);
718
719 // set the item's font (should be of the same height for all items)
720 void SetItemFont(const wxTreeItemId& item, const wxFont& font);
721
722
723 bool GetItemBold(const wxTreeItemId& item) const;
724 wxColour GetItemTextColour(const wxTreeItemId& item) const;
725 wxColour GetItemBackgroundColour(const wxTreeItemId& item) const;
726 wxFont GetItemFont(const wxTreeItemId& item) const;
727
728 // is the item visible (it might be outside the view or not expanded)?
729 bool IsVisible(const wxTreeItemId& item) const;
730
731 // does the item has any children?
732 bool ItemHasChildren(const wxTreeItemId& item) const;
733
734 // is the item expanded (only makes sense if HasChildren())?
735 bool IsExpanded(const wxTreeItemId& item) const;
736
737 // is this item currently selected (the same as has focus)?
738 bool IsSelected(const wxTreeItemId& item) const;
739
740 // is item text in bold font?
741 bool IsBold(const wxTreeItemId& item) const;
742
743 // if 'recursively' is False, only immediate children count, otherwise
744 // the returned number is the number of all items in this branch
745 size_t GetChildrenCount(const wxTreeItemId& item, bool recursively = true);
746
747
748 // wxTreeItemId.IsOk() will return False if there is no such item
749
750 // get the root tree item
751 wxTreeItemId GetRootItem() const;
752
753 // get the item currently selected (may return NULL if no selection)
754 wxTreeItemId GetSelection() const;
755
756 // get the items currently selected, return the number of such item
757 //size_t GetSelections(wxArrayTreeItemIds&) const;
758 %extend {
759 PyObject* GetSelections() {
760 bool blocked = wxPyBeginBlockThreads();
761 PyObject* rval = PyList_New(0);
762 wxArrayTreeItemIds array;
763 size_t num, x;
764 num = self->GetSelections(array);
765 for (x=0; x < num; x++) {
766 wxTreeItemId *tii = new wxTreeItemId(array.Item(x));
767 PyObject* item = wxPyConstructObject((void*)tii, wxT("wxTreeItemId"), true);
768 PyList_Append(rval, item);
769 }
770 wxPyEndBlockThreads(blocked);
771 return rval;
772 }
773 }
774
775
776 // get the parent of this item (may return NULL if root)
777 wxTreeItemId GetItemParent(const wxTreeItemId& item) const;
778
779 // for this enumeration function you must pass in a "cookie" parameter
780 // which is opaque for the application but is necessary for the library
781 // to make these functions reentrant (i.e. allow more than one
782 // enumeration on one and the same object simultaneously). Of course,
783 // the "cookie" passed to GetFirstChild() and GetNextChild() should be
784 // the same!
785
786
787 // NOTE: These are a copy of the same methods in _treectrl.i, be sure to
788 // update both at the same time. (Or find a good way to refactor!)
789 %extend {
790 // Get the first child of this item. Returns a wxTreeItemId and an
791 // opaque "cookie" value that should be passed to GetNextChild in
792 // order to continue the search.
793 PyObject* GetFirstChild(const wxTreeItemId& item) {
794 void* cookie = 0;
795 wxTreeItemId* ritem = new wxTreeItemId(self->GetFirstChild(item, cookie));
796 bool blocked = wxPyBeginBlockThreads();
797 PyObject* tup = PyTuple_New(2);
798 PyTuple_SET_ITEM(tup, 0, wxPyConstructObject(ritem, wxT("wxTreeItemId"), true));
799 PyTuple_SET_ITEM(tup, 1, wxPyMakeSwigPtr(cookie, wxT("void")));
800 wxPyEndBlockThreads(blocked);
801 return tup;
802 }
803
804
805 // Get the next child of this item. The cookie parameter is the 2nd
806 // value returned from GetFirstChild or the previous GetNextChild.
807 // Returns a wxTreeItemId and an opaque "cookie" value that should be
808 // passed to GetNextChild in order to continue the search.
809 PyObject* GetNextChild(const wxTreeItemId& item, void* cookie) {
810 wxTreeItemId* ritem = new wxTreeItemId(self->GetNextChild(item, cookie));
811 bool blocked = wxPyBeginBlockThreads();
812 PyObject* tup = PyTuple_New(2);
813 PyTuple_SET_ITEM(tup, 0, wxPyConstructObject(ritem, wxT("wxTreeItemId"), true));
814 PyTuple_SET_ITEM(tup, 1, wxPyMakeSwigPtr(cookie, wxT("void")));
815 wxPyEndBlockThreads(blocked);
816 return tup;
817 }
818
819
820 // TODO: GetPrevChild
821
822 }
823
824 // get the last child of this item - this method doesn't use cookies
825 wxTreeItemId GetLastChild(const wxTreeItemId& item) const;
826
827 // get the next sibling of this item
828 wxTreeItemId GetNextSibling(const wxTreeItemId& item) const;
829
830 // get the previous sibling
831 wxTreeItemId GetPrevSibling(const wxTreeItemId& item) const;
832
833 // get first visible item
834 wxTreeItemId GetFirstVisibleItem() const;
835
836 // get the next visible item: item must be visible itself!
837 // see IsVisible() and wxTreeCtrl::GetFirstVisibleItem()
838 wxTreeItemId GetNextVisible(const wxTreeItemId& item) const;
839
840 // get the previous visible item: item must be visible itself!
841 wxTreeItemId GetPrevVisible(const wxTreeItemId& item) const;
842
843 // Only for internal use right now, but should probably be public
844 wxTreeItemId GetNext(const wxTreeItemId& item) const;
845
846
847 // add the root node to the tree
848 wxTreeItemId AddRoot(const wxString& text,
849 int image = -1, int selectedImage = -1,
850 wxPyTreeItemData *data = NULL);
851
852 // insert a new item in as the first child of the parent
853 wxTreeItemId PrependItem(const wxTreeItemId& parent,
854 const wxString& text,
855 int image = -1, int selectedImage = -1,
856 wxPyTreeItemData *data = NULL);
857
858 // insert a new item after a given one
859 wxTreeItemId InsertItem(const wxTreeItemId& parent,
860 const wxTreeItemId& idPrevious,
861 const wxString& text,
862 int image = -1, int selectedImage = -1,
863 wxPyTreeItemData *data = NULL);
864
865 // insert a new item before the one with the given index
866 %Rename(InsertItemBefore,
867 wxTreeItemId, InsertItem(const wxTreeItemId& parent,
868 size_t index,
869 const wxString& text,
870 int image = -1, int selectedImage = -1,
871 wxPyTreeItemData *data = NULL));
872
873 // insert a new item in as the last child of the parent
874 wxTreeItemId AppendItem(const wxTreeItemId& parent,
875 const wxString& text,
876 int image = -1, int selectedImage = -1,
877 wxPyTreeItemData *data = NULL);
878
879 // delete this item and associated data if any
880 void Delete(const wxTreeItemId& item);
881
882 // delete all children (but don't delete the item itself)
883 // NB: this won't send wxEVT_COMMAND_TREE_ITEM_DELETED events
884 void DeleteChildren(const wxTreeItemId& item);
885
886 // delete all items from the tree
887 // NB: this won't send wxEVT_COMMAND_TREE_ITEM_DELETED events
888 void DeleteAllItems();
889
890 // expand this item
891 void Expand(const wxTreeItemId& item);
892
893 // expand this item and all subitems recursively
894 void ExpandAll(const wxTreeItemId& item);
895
896 // collapse the item without removing its children
897 void Collapse(const wxTreeItemId& item);
898
899 // collapse the item and remove all children
900 void CollapseAndReset(const wxTreeItemId& item);
901
902 // toggles the current state
903 void Toggle(const wxTreeItemId& item);
904
905 // remove the selection from currently selected item (if any)
906 void Unselect();
907 void UnselectAll();
908
909 // select this item
910 void SelectItem(const wxTreeItemId& item, bool unselect_others=true,
911 bool extended_select=false);
912
913 void SelectAll(bool extended_select=false);
914
915 // make sure this item is visible (expanding the parent item and/or
916 // scrolling to this item if necessary)
917 void EnsureVisible(const wxTreeItemId& item);
918
919 // scroll to this item (but don't expand its parent)
920 void ScrollTo(const wxTreeItemId& item);
921
922 // Returns wxTreeItemId, flags, and column
923 wxTreeItemId HitTest(const wxPoint& point, int& OUTPUT, int& OUTPUT);
924
925 %extend {
926 // get the bounding rectangle of the item (or of its label only)
927 PyObject* GetBoundingRect(const wxTreeItemId& item, bool textOnly = false) {
928 wxRect rect;
929 if (self->GetBoundingRect(item, rect, textOnly)) {
930 bool blocked = wxPyBeginBlockThreads();
931 wxRect* r = new wxRect(rect);
932 PyObject* val = wxPyConstructObject((void*)r, wxT("wxRect"), 1);
933 wxPyEndBlockThreads(blocked);
934 return val;
935 }
936 else {
937 RETURN_NONE();
938 }
939 }
940 }
941
942
943 // Start editing the item label: this (temporarily) replaces the item
944 // with a one line edit control. The item will be selected if it hadn't
945 // been before.
946 void EditLabel( const wxTreeItemId& item );
947 void Edit( const wxTreeItemId& item );
948
949 // sort the children of this item using OnCompareItems
950 void SortChildren(const wxTreeItemId& item);
951
952 // searching
953 wxTreeItemId FindItem (const wxTreeItemId& item, const wxString& str, int flags = 0);
954
955 wxWindow* GetHeaderWindow() const;
956 wxScrolledWindow* GetMainWindow() const;
957
958 };
959
960
961
962
963 //----------------------------------------------------------------------
964 //----------------------------------------------------------------------
965
966 %init %{
967
968 wxPyPtrTypeMap_Add("wxTreeCompanionWindow", "wxPyTreeCompanionWindow");
969 wxPyPtrTypeMap_Add("wxTreeListCtrl", "wxPyTreeListCtrl");
970 %}
971
972
973 %pragma(python) include="_gizmoextras.py";
974
975 //----------------------------------------------------------------------
976 //----------------------------------------------------------------------
977