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