]> git.saurik.com Git - wxWidgets.git/commitdiff
Attempted to add the SplitTree gizmo classes, but it is not working on
authorRobin Dunn <robin@alldunn.com>
Fri, 30 Nov 2001 21:16:36 +0000 (21:16 +0000)
committerRobin Dunn <robin@alldunn.com>
Fri, 30 Nov 2001 21:16:36 +0000 (21:16 +0000)
MSW... :-(

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@12764 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

15 files changed:
wxPython/CHANGES.txt
wxPython/contrib/gizmos/_gizmoextras.py
wxPython/contrib/gizmos/gizmos.cpp
wxPython/contrib/gizmos/gizmos.i
wxPython/contrib/gizmos/gizmos.py
wxPython/demo/ContextHelp.py
wxPython/demo/Main.py
wxPython/demo/SplitTree.py [new file with mode: 0644]
wxPython/demo/bmp_source/file1.ico [new file with mode: 0644]
wxPython/demo/bmp_source/folder1.ico [new file with mode: 0644]
wxPython/demo/bmp_source/folder2.ico [new file with mode: 0644]
wxPython/demo/encode_bitmaps.py
wxPython/demo/images.py
wxPython/demo/wxCheckListBox.py
wxPython/demo/wxEditableListBox.py

index 168cee6bb5bcd85879d2aebd3b95daada24a4219..f504f9d0f0f413b90d90fa9ddc538e3f8af8db7e 100644 (file)
@@ -93,6 +93,8 @@ by dragging a little tab next to the scrollbars.  Added a demo to show
 this and also the ability of multiple wxStyledStectCtrls to share the
 same document.
 
 this and also the ability of multiple wxStyledStectCtrls to share the
 same document.
 
+Added wxEditableListBox gizmo.
+
 
 
 
 
 
 
index 43ed797c50664800a8ce68be0585642688de168f..982d200ffc458b2c63c94fbe6262c29aa9e61883 100644 (file)
@@ -3,3 +3,10 @@
 wx.wxDynamicSashSplitEventPtr       = wxDynamicSashSplitEventPtr
 wx.wxDynamicSashUnifyEventPtr       = wxDynamicSashUnifyEventPtr
 wx.wxDynamicSashWindowPtr           = wxDynamicSashWindowPtr
 wx.wxDynamicSashSplitEventPtr       = wxDynamicSashSplitEventPtr
 wx.wxDynamicSashUnifyEventPtr       = wxDynamicSashUnifyEventPtr
 wx.wxDynamicSashWindowPtr           = wxDynamicSashWindowPtr
+
+wx.wxEditableListBoxPtr             = wxEditableListBoxPtr
+
+wx.wxRemotelyScrolledTreeCtrlPtr    = wxRemotelyScrolledTreeCtrlPtr
+wx.wxTreeCompanionWindowPtr         = wxTreeCompanionWindowPtr
+wx.wxThinSplitterWindowPtr          = wxThinSplitterWindowPtr
+wx.wxSplitterScrolledWindowPtr      = wxSplitterScrolledWindowPtr
index cb9d8ac35d8433603cc5b4c6c06732837e87df53..7cd433e1410e4fb1f3b53c04e9c47469e711193e 100644 (file)
@@ -56,8 +56,9 @@ extern PyObject *SWIG_newvarlink(void);
 #define SWIG_name    "gizmosc"
 
 #include "export.h"
 #define SWIG_name    "gizmosc"
 
 #include "export.h"
-#include "wx/gizmos/dynamicsash.h"
-#include "wx/gizmos/editlbox.h"
+#include <wx/gizmos/dynamicsash.h>
+#include <wx/gizmos/editlbox.h>
+#include <wx/gizmos/splittree.h>
 
 
 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
 
 
 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
@@ -91,6 +92,38 @@ static PyObject* t_output_helper(PyObject* target, PyObject* o) {
 #else
     static char* wxStringErrorMsg = "String type required";
 #endif
 #else
     static char* wxStringErrorMsg = "String type required";
 #endif
+
+    typedef wxTreeCtrl wxPyTreeCtrl;
+
+class wxPyTreeCompanionWindow: public wxTreeCompanionWindow
+{
+public:
+    wxPyTreeCompanionWindow(wxWindow* parent, wxWindowID id = -1,
+                            const wxPoint& pos = wxDefaultPosition,
+                            const wxSize& size = wxDefaultSize,
+                            long style = 0)
+        : wxTreeCompanionWindow(parent, id, pos, size, style) {}
+
+
+    virtual void DrawItem(wxDC& dc, wxTreeItemId id, const wxRect& rect) {
+        bool found;
+        wxPyTState* state = wxPyBeginBlockThreads();
+        if ((found = wxPyCBH_findCallback(m_myInst, "DrawItem"))) {
+            PyObject* dcobj = wxPyMake_wxObject(&dc);
+            PyObject* idobj = wxPyConstructObject((void*)&id, "wxTreeItemId", FALSE);
+            PyObject* recobj= wxPyConstructObject((void*)&rect, "wxRect", FALSE);
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOO)", dcobj, idobj, recobj));
+            Py_DECREF(dcobj);
+            Py_DECREF(idobj);
+            Py_DECREF(recobj);
+        }
+        wxPyEndBlockThreads(state);
+        if (! found)
+            wxTreeCompanionWindow::DrawItem(dc, id, rect);
+    }
+
+    PYPRIVATE;
+};
 #ifdef __cplusplus
 extern "C" {
 #endif
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -648,7 +681,659 @@ static PyObject *_wrap_wxEditableListBox_GetStrings(PyObject *self, PyObject *ar
     return _resultobj;
 }
 
     return _resultobj;
 }
 
+static void *SwigwxRemotelyScrolledTreeCtrlTowxPyTreeCtrl(void *ptr) {
+    wxRemotelyScrolledTreeCtrl *src;
+    wxPyTreeCtrl *dest;
+    src = (wxRemotelyScrolledTreeCtrl *) ptr;
+    dest = (wxPyTreeCtrl *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxRemotelyScrolledTreeCtrlTowxControl(void *ptr) {
+    wxRemotelyScrolledTreeCtrl *src;
+    wxControl *dest;
+    src = (wxRemotelyScrolledTreeCtrl *) ptr;
+    dest = (wxControl *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxRemotelyScrolledTreeCtrlTowxWindow(void *ptr) {
+    wxRemotelyScrolledTreeCtrl *src;
+    wxWindow *dest;
+    src = (wxRemotelyScrolledTreeCtrl *) ptr;
+    dest = (wxWindow *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxRemotelyScrolledTreeCtrlTowxEvtHandler(void *ptr) {
+    wxRemotelyScrolledTreeCtrl *src;
+    wxEvtHandler *dest;
+    src = (wxRemotelyScrolledTreeCtrl *) ptr;
+    dest = (wxEvtHandler *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxRemotelyScrolledTreeCtrlTowxObject(void *ptr) {
+    wxRemotelyScrolledTreeCtrl *src;
+    wxObject *dest;
+    src = (wxRemotelyScrolledTreeCtrl *) ptr;
+    dest = (wxObject *) src;
+    return (void *) dest;
+}
+
+#define new_wxRemotelyScrolledTreeCtrl(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4) (new wxRemotelyScrolledTreeCtrl(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
+static PyObject *_wrap_new_wxRemotelyScrolledTreeCtrl(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxRemotelyScrolledTreeCtrl * _result;
+    wxWindow * _arg0;
+    wxWindowID  _arg1;
+    wxPoint * _arg2 = (wxPoint *) &wxDefaultPosition;
+    wxSize * _arg3 = (wxSize *) &wxDefaultSize;
+    long  _arg4 = (long ) wxTR_HAS_BUTTONS;
+    PyObject * _argo0 = 0;
+    wxPoint  temp;
+    PyObject * _obj2 = 0;
+    wxSize  temp0;
+    PyObject * _obj3 = 0;
+    char *_kwnames[] = { "parent","id","pos","size","style", NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oi|OOl:new_wxRemotelyScrolledTreeCtrl",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWindow_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxRemotelyScrolledTreeCtrl. Expected _wxWindow_p.");
+        return NULL;
+        }
+    }
+    if (_obj2)
+{
+    _arg2 = &temp;
+    if (! wxPoint_helper(_obj2, &_arg2))
+        return NULL;
+}
+    if (_obj3)
+{
+    _arg3 = &temp0;
+    if (! wxSize_helper(_obj3, &_arg3))
+        return NULL;
+}
+{
+    wxPy_BEGIN_ALLOW_THREADS;
+        _result = (wxRemotelyScrolledTreeCtrl *)new_wxRemotelyScrolledTreeCtrl(_arg0,_arg1,*_arg2,*_arg3,_arg4);
+
+    wxPy_END_ALLOW_THREADS;
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxRemotelyScrolledTreeCtrl_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
+    return _resultobj;
+}
+
+#define wxRemotelyScrolledTreeCtrl_HideVScrollbar(_swigobj)  (_swigobj->HideVScrollbar())
+static PyObject *_wrap_wxRemotelyScrolledTreeCtrl_HideVScrollbar(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxRemotelyScrolledTreeCtrl * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRemotelyScrolledTreeCtrl_HideVScrollbar",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRemotelyScrolledTreeCtrl_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRemotelyScrolledTreeCtrl_HideVScrollbar. Expected _wxRemotelyScrolledTreeCtrl_p.");
+        return NULL;
+        }
+    }
+{
+    wxPy_BEGIN_ALLOW_THREADS;
+        wxRemotelyScrolledTreeCtrl_HideVScrollbar(_arg0);
+
+    wxPy_END_ALLOW_THREADS;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxRemotelyScrolledTreeCtrl_AdjustRemoteScrollbars(_swigobj)  (_swigobj->AdjustRemoteScrollbars())
+static PyObject *_wrap_wxRemotelyScrolledTreeCtrl_AdjustRemoteScrollbars(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxRemotelyScrolledTreeCtrl * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRemotelyScrolledTreeCtrl_AdjustRemoteScrollbars",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRemotelyScrolledTreeCtrl_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRemotelyScrolledTreeCtrl_AdjustRemoteScrollbars. Expected _wxRemotelyScrolledTreeCtrl_p.");
+        return NULL;
+        }
+    }
+{
+    wxPy_BEGIN_ALLOW_THREADS;
+        wxRemotelyScrolledTreeCtrl_AdjustRemoteScrollbars(_arg0);
+
+    wxPy_END_ALLOW_THREADS;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxRemotelyScrolledTreeCtrl_GetScrolledWindow(_swigobj)  (_swigobj->GetScrolledWindow())
+static PyObject *_wrap_wxRemotelyScrolledTreeCtrl_GetScrolledWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxScrolledWindow * _result;
+    wxRemotelyScrolledTreeCtrl * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRemotelyScrolledTreeCtrl_GetScrolledWindow",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRemotelyScrolledTreeCtrl_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRemotelyScrolledTreeCtrl_GetScrolledWindow. Expected _wxRemotelyScrolledTreeCtrl_p.");
+        return NULL;
+        }
+    }
+{
+    wxPy_BEGIN_ALLOW_THREADS;
+        _result = (wxScrolledWindow *)wxRemotelyScrolledTreeCtrl_GetScrolledWindow(_arg0);
+
+    wxPy_END_ALLOW_THREADS;
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxScrolledWindow_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
+    return _resultobj;
+}
+
+#define wxRemotelyScrolledTreeCtrl_ScrollToLine(_swigobj,_swigarg0,_swigarg1)  (_swigobj->ScrollToLine(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxRemotelyScrolledTreeCtrl_ScrollToLine(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxRemotelyScrolledTreeCtrl * _arg0;
+    int  _arg1;
+    int  _arg2;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self","posHoriz","posVert", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"Oii:wxRemotelyScrolledTreeCtrl_ScrollToLine",_kwnames,&_argo0,&_arg1,&_arg2)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRemotelyScrolledTreeCtrl_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRemotelyScrolledTreeCtrl_ScrollToLine. Expected _wxRemotelyScrolledTreeCtrl_p.");
+        return NULL;
+        }
+    }
+{
+    wxPy_BEGIN_ALLOW_THREADS;
+        wxRemotelyScrolledTreeCtrl_ScrollToLine(_arg0,_arg1,_arg2);
+
+    wxPy_END_ALLOW_THREADS;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxRemotelyScrolledTreeCtrl_SetCompanionWindow(_swigobj,_swigarg0)  (_swigobj->SetCompanionWindow(_swigarg0))
+static PyObject *_wrap_wxRemotelyScrolledTreeCtrl_SetCompanionWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxRemotelyScrolledTreeCtrl * _arg0;
+    wxWindow * _arg1;
+    PyObject * _argo0 = 0;
+    PyObject * _argo1 = 0;
+    char *_kwnames[] = { "self","companion", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxRemotelyScrolledTreeCtrl_SetCompanionWindow",_kwnames,&_argo0,&_argo1)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRemotelyScrolledTreeCtrl_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRemotelyScrolledTreeCtrl_SetCompanionWindow. Expected _wxRemotelyScrolledTreeCtrl_p.");
+        return NULL;
+        }
+    }
+    if (_argo1) {
+        if (_argo1 == Py_None) { _arg1 = NULL; }
+        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxWindow_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxRemotelyScrolledTreeCtrl_SetCompanionWindow. Expected _wxWindow_p.");
+        return NULL;
+        }
+    }
+{
+    wxPy_BEGIN_ALLOW_THREADS;
+        wxRemotelyScrolledTreeCtrl_SetCompanionWindow(_arg0,_arg1);
+
+    wxPy_END_ALLOW_THREADS;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxRemotelyScrolledTreeCtrl_GetCompanionWindow(_swigobj)  (_swigobj->GetCompanionWindow())
+static PyObject *_wrap_wxRemotelyScrolledTreeCtrl_GetCompanionWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxWindow * _result;
+    wxRemotelyScrolledTreeCtrl * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxRemotelyScrolledTreeCtrl_GetCompanionWindow",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxRemotelyScrolledTreeCtrl_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxRemotelyScrolledTreeCtrl_GetCompanionWindow. Expected _wxRemotelyScrolledTreeCtrl_p.");
+        return NULL;
+        }
+    }
+{
+    wxPy_BEGIN_ALLOW_THREADS;
+        _result = (wxWindow *)wxRemotelyScrolledTreeCtrl_GetCompanionWindow(_arg0);
+
+    wxPy_END_ALLOW_THREADS;
+}{ _resultobj = wxPyMake_wxObject(_result); }
+    return _resultobj;
+}
+
+static void *SwigwxPyTreeCompanionWindowTowxWindow(void *ptr) {
+    wxPyTreeCompanionWindow *src;
+    wxWindow *dest;
+    src = (wxPyTreeCompanionWindow *) ptr;
+    dest = (wxWindow *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxPyTreeCompanionWindowTowxEvtHandler(void *ptr) {
+    wxPyTreeCompanionWindow *src;
+    wxEvtHandler *dest;
+    src = (wxPyTreeCompanionWindow *) ptr;
+    dest = (wxEvtHandler *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxPyTreeCompanionWindowTowxObject(void *ptr) {
+    wxPyTreeCompanionWindow *src;
+    wxObject *dest;
+    src = (wxPyTreeCompanionWindow *) ptr;
+    dest = (wxObject *) src;
+    return (void *) dest;
+}
+
+#define new_wxTreeCompanionWindow(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4) (new wxPyTreeCompanionWindow(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
+static PyObject *_wrap_new_wxTreeCompanionWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxPyTreeCompanionWindow * _result;
+    wxWindow * _arg0;
+    wxWindowID  _arg1 = (wxWindowID ) -1;
+    wxPoint * _arg2 = (wxPoint *) &wxDefaultPosition;
+    wxSize * _arg3 = (wxSize *) &wxDefaultSize;
+    long  _arg4 = (long ) 0;
+    PyObject * _argo0 = 0;
+    wxPoint  temp;
+    PyObject * _obj2 = 0;
+    wxSize  temp0;
+    PyObject * _obj3 = 0;
+    char *_kwnames[] = { "parent","id","pos","size","style", NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iOOl:new_wxTreeCompanionWindow",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWindow_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxTreeCompanionWindow. Expected _wxWindow_p.");
+        return NULL;
+        }
+    }
+    if (_obj2)
+{
+    _arg2 = &temp;
+    if (! wxPoint_helper(_obj2, &_arg2))
+        return NULL;
+}
+    if (_obj3)
+{
+    _arg3 = &temp0;
+    if (! wxSize_helper(_obj3, &_arg3))
+        return NULL;
+}
+{
+    wxPy_BEGIN_ALLOW_THREADS;
+        _result = (wxPyTreeCompanionWindow *)new_wxTreeCompanionWindow(_arg0,_arg1,*_arg2,*_arg3,_arg4);
+
+    wxPy_END_ALLOW_THREADS;
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxPyTreeCompanionWindow_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
+    return _resultobj;
+}
+
+#define wxTreeCompanionWindow__setCallbackInfo(_swigobj,_swigarg0,_swigarg1)  (_swigobj->_setCallbackInfo(_swigarg0,_swigarg1))
+static PyObject *_wrap_wxTreeCompanionWindow__setCallbackInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxPyTreeCompanionWindow * _arg0;
+    PyObject * _arg1;
+    PyObject * _arg2;
+    PyObject * _argo0 = 0;
+    PyObject * _obj1 = 0;
+    PyObject * _obj2 = 0;
+    char *_kwnames[] = { "self","self","_class", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OOO:wxTreeCompanionWindow__setCallbackInfo",_kwnames,&_argo0,&_obj1,&_obj2)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyTreeCompanionWindow_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTreeCompanionWindow__setCallbackInfo. Expected _wxPyTreeCompanionWindow_p.");
+        return NULL;
+        }
+    }
+{
+  _arg1 = _obj1;
+}
+{
+  _arg2 = _obj2;
+}
+{
+    wxPy_BEGIN_ALLOW_THREADS;
+        wxTreeCompanionWindow__setCallbackInfo(_arg0,_arg1,_arg2);
+
+    wxPy_END_ALLOW_THREADS;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+#define wxTreeCompanionWindow_GetTreeCtrl(_swigobj)  (_swigobj->GetTreeCtrl())
+static PyObject *_wrap_wxTreeCompanionWindow_GetTreeCtrl(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxRemotelyScrolledTreeCtrl * _result;
+    wxPyTreeCompanionWindow * _arg0;
+    PyObject * _argo0 = 0;
+    char *_kwnames[] = { "self", NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O:wxTreeCompanionWindow_GetTreeCtrl",_kwnames,&_argo0)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyTreeCompanionWindow_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTreeCompanionWindow_GetTreeCtrl. Expected _wxPyTreeCompanionWindow_p.");
+        return NULL;
+        }
+    }
+{
+    wxPy_BEGIN_ALLOW_THREADS;
+        _result = (wxRemotelyScrolledTreeCtrl *)wxTreeCompanionWindow_GetTreeCtrl(_arg0);
+
+    wxPy_END_ALLOW_THREADS;
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxRemotelyScrolledTreeCtrl_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
+    return _resultobj;
+}
+
+#define wxTreeCompanionWindow_SetTreeCtrl(_swigobj,_swigarg0)  (_swigobj->SetTreeCtrl(_swigarg0))
+static PyObject *_wrap_wxTreeCompanionWindow_SetTreeCtrl(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxPyTreeCompanionWindow * _arg0;
+    wxRemotelyScrolledTreeCtrl * _arg1;
+    PyObject * _argo0 = 0;
+    PyObject * _argo1 = 0;
+    char *_kwnames[] = { "self","treeCtrl", NULL };
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"OO:wxTreeCompanionWindow_SetTreeCtrl",_kwnames,&_argo0,&_argo1)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxPyTreeCompanionWindow_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of wxTreeCompanionWindow_SetTreeCtrl. Expected _wxPyTreeCompanionWindow_p.");
+        return NULL;
+        }
+    }
+    if (_argo1) {
+        if (_argo1 == Py_None) { _arg1 = NULL; }
+        else if (SWIG_GetPtrObj(_argo1,(void **) &_arg1,"_wxRemotelyScrolledTreeCtrl_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 2 of wxTreeCompanionWindow_SetTreeCtrl. Expected _wxRemotelyScrolledTreeCtrl_p.");
+        return NULL;
+        }
+    }
+{
+    wxPy_BEGIN_ALLOW_THREADS;
+        wxTreeCompanionWindow_SetTreeCtrl(_arg0,_arg1);
+
+    wxPy_END_ALLOW_THREADS;
+}    Py_INCREF(Py_None);
+    _resultobj = Py_None;
+    return _resultobj;
+}
+
+static void *SwigwxThinSplitterWindowTowxSplitterWindow(void *ptr) {
+    wxThinSplitterWindow *src;
+    wxSplitterWindow *dest;
+    src = (wxThinSplitterWindow *) ptr;
+    dest = (wxSplitterWindow *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxThinSplitterWindowTowxWindow(void *ptr) {
+    wxThinSplitterWindow *src;
+    wxWindow *dest;
+    src = (wxThinSplitterWindow *) ptr;
+    dest = (wxWindow *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxThinSplitterWindowTowxEvtHandler(void *ptr) {
+    wxThinSplitterWindow *src;
+    wxEvtHandler *dest;
+    src = (wxThinSplitterWindow *) ptr;
+    dest = (wxEvtHandler *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxThinSplitterWindowTowxObject(void *ptr) {
+    wxThinSplitterWindow *src;
+    wxObject *dest;
+    src = (wxThinSplitterWindow *) ptr;
+    dest = (wxObject *) src;
+    return (void *) dest;
+}
+
+#define new_wxThinSplitterWindow(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4) (new wxThinSplitterWindow(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
+static PyObject *_wrap_new_wxThinSplitterWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxThinSplitterWindow * _result;
+    wxWindow * _arg0;
+    wxWindowID  _arg1 = (wxWindowID ) -1;
+    wxPoint * _arg2 = (wxPoint *) &wxDefaultPosition;
+    wxSize * _arg3 = (wxSize *) &wxDefaultSize;
+    long  _arg4 = (long ) wxSP_3D|wxCLIP_CHILDREN;
+    PyObject * _argo0 = 0;
+    wxPoint  temp;
+    PyObject * _obj2 = 0;
+    wxSize  temp0;
+    PyObject * _obj3 = 0;
+    char *_kwnames[] = { "parent","id","pos","size","style", NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iOOl:new_wxThinSplitterWindow",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWindow_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxThinSplitterWindow. Expected _wxWindow_p.");
+        return NULL;
+        }
+    }
+    if (_obj2)
+{
+    _arg2 = &temp;
+    if (! wxPoint_helper(_obj2, &_arg2))
+        return NULL;
+}
+    if (_obj3)
+{
+    _arg3 = &temp0;
+    if (! wxSize_helper(_obj3, &_arg3))
+        return NULL;
+}
+{
+    wxPy_BEGIN_ALLOW_THREADS;
+        _result = (wxThinSplitterWindow *)new_wxThinSplitterWindow(_arg0,_arg1,*_arg2,*_arg3,_arg4);
+
+    wxPy_END_ALLOW_THREADS;
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxThinSplitterWindow_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
+    return _resultobj;
+}
+
+static void *SwigwxSplitterScrolledWindowTowxScrolledWindow(void *ptr) {
+    wxSplitterScrolledWindow *src;
+    wxScrolledWindow *dest;
+    src = (wxSplitterScrolledWindow *) ptr;
+    dest = (wxScrolledWindow *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxSplitterScrolledWindowTowxPanel(void *ptr) {
+    wxSplitterScrolledWindow *src;
+    wxPanel *dest;
+    src = (wxSplitterScrolledWindow *) ptr;
+    dest = (wxPanel *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxSplitterScrolledWindowTowxWindow(void *ptr) {
+    wxSplitterScrolledWindow *src;
+    wxWindow *dest;
+    src = (wxSplitterScrolledWindow *) ptr;
+    dest = (wxWindow *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxSplitterScrolledWindowTowxEvtHandler(void *ptr) {
+    wxSplitterScrolledWindow *src;
+    wxEvtHandler *dest;
+    src = (wxSplitterScrolledWindow *) ptr;
+    dest = (wxEvtHandler *) src;
+    return (void *) dest;
+}
+
+static void *SwigwxSplitterScrolledWindowTowxObject(void *ptr) {
+    wxSplitterScrolledWindow *src;
+    wxObject *dest;
+    src = (wxSplitterScrolledWindow *) ptr;
+    dest = (wxObject *) src;
+    return (void *) dest;
+}
+
+#define new_wxSplitterScrolledWindow(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4) (new wxSplitterScrolledWindow(_swigarg0,_swigarg1,_swigarg2,_swigarg3,_swigarg4))
+static PyObject *_wrap_new_wxSplitterScrolledWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
+    PyObject * _resultobj;
+    wxSplitterScrolledWindow * _result;
+    wxWindow * _arg0;
+    wxWindowID  _arg1 = (wxWindowID ) -1;
+    wxPoint * _arg2 = (wxPoint *) &wxDefaultPosition;
+    wxSize * _arg3 = (wxSize *) &wxDefaultSize;
+    long  _arg4 = (long ) 0;
+    PyObject * _argo0 = 0;
+    wxPoint  temp;
+    PyObject * _obj2 = 0;
+    wxSize  temp0;
+    PyObject * _obj3 = 0;
+    char *_kwnames[] = { "parent","id","pos","size","style", NULL };
+    char _ptemp[128];
+
+    self = self;
+    if(!PyArg_ParseTupleAndKeywords(args,kwargs,"O|iOOl:new_wxSplitterScrolledWindow",_kwnames,&_argo0,&_arg1,&_obj2,&_obj3,&_arg4)) 
+        return NULL;
+    if (_argo0) {
+        if (_argo0 == Py_None) { _arg0 = NULL; }
+        else if (SWIG_GetPtrObj(_argo0,(void **) &_arg0,"_wxWindow_p")) {
+            PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of new_wxSplitterScrolledWindow. Expected _wxWindow_p.");
+        return NULL;
+        }
+    }
+    if (_obj2)
+{
+    _arg2 = &temp;
+    if (! wxPoint_helper(_obj2, &_arg2))
+        return NULL;
+}
+    if (_obj3)
+{
+    _arg3 = &temp0;
+    if (! wxSize_helper(_obj3, &_arg3))
+        return NULL;
+}
+{
+    wxPy_BEGIN_ALLOW_THREADS;
+        _result = (wxSplitterScrolledWindow *)new_wxSplitterScrolledWindow(_arg0,_arg1,*_arg2,*_arg3,_arg4);
+
+    wxPy_END_ALLOW_THREADS;
+}    if (_result) {
+        SWIG_MakePtr(_ptemp, (char *) _result,"_wxSplitterScrolledWindow_p");
+        _resultobj = Py_BuildValue("s",_ptemp);
+    } else {
+        Py_INCREF(Py_None);
+        _resultobj = Py_None;
+    }
+    return _resultobj;
+}
+
 static PyMethodDef gizmoscMethods[] = {
 static PyMethodDef gizmoscMethods[] = {
+        { "new_wxSplitterScrolledWindow", (PyCFunction) _wrap_new_wxSplitterScrolledWindow, METH_VARARGS | METH_KEYWORDS },
+        { "new_wxThinSplitterWindow", (PyCFunction) _wrap_new_wxThinSplitterWindow, METH_VARARGS | METH_KEYWORDS },
+        { "wxTreeCompanionWindow_SetTreeCtrl", (PyCFunction) _wrap_wxTreeCompanionWindow_SetTreeCtrl, METH_VARARGS | METH_KEYWORDS },
+        { "wxTreeCompanionWindow_GetTreeCtrl", (PyCFunction) _wrap_wxTreeCompanionWindow_GetTreeCtrl, METH_VARARGS | METH_KEYWORDS },
+        { "wxTreeCompanionWindow__setCallbackInfo", (PyCFunction) _wrap_wxTreeCompanionWindow__setCallbackInfo, METH_VARARGS | METH_KEYWORDS },
+        { "new_wxTreeCompanionWindow", (PyCFunction) _wrap_new_wxTreeCompanionWindow, METH_VARARGS | METH_KEYWORDS },
+        { "wxRemotelyScrolledTreeCtrl_GetCompanionWindow", (PyCFunction) _wrap_wxRemotelyScrolledTreeCtrl_GetCompanionWindow, METH_VARARGS | METH_KEYWORDS },
+        { "wxRemotelyScrolledTreeCtrl_SetCompanionWindow", (PyCFunction) _wrap_wxRemotelyScrolledTreeCtrl_SetCompanionWindow, METH_VARARGS | METH_KEYWORDS },
+        { "wxRemotelyScrolledTreeCtrl_ScrollToLine", (PyCFunction) _wrap_wxRemotelyScrolledTreeCtrl_ScrollToLine, METH_VARARGS | METH_KEYWORDS },
+        { "wxRemotelyScrolledTreeCtrl_GetScrolledWindow", (PyCFunction) _wrap_wxRemotelyScrolledTreeCtrl_GetScrolledWindow, METH_VARARGS | METH_KEYWORDS },
+        { "wxRemotelyScrolledTreeCtrl_AdjustRemoteScrollbars", (PyCFunction) _wrap_wxRemotelyScrolledTreeCtrl_AdjustRemoteScrollbars, METH_VARARGS | METH_KEYWORDS },
+        { "wxRemotelyScrolledTreeCtrl_HideVScrollbar", (PyCFunction) _wrap_wxRemotelyScrolledTreeCtrl_HideVScrollbar, METH_VARARGS | METH_KEYWORDS },
+        { "new_wxRemotelyScrolledTreeCtrl", (PyCFunction) _wrap_new_wxRemotelyScrolledTreeCtrl, METH_VARARGS | METH_KEYWORDS },
         { "wxEditableListBox_GetStrings", (PyCFunction) _wrap_wxEditableListBox_GetStrings, METH_VARARGS | METH_KEYWORDS },
         { "wxEditableListBox_SetStrings", (PyCFunction) _wrap_wxEditableListBox_SetStrings, METH_VARARGS | METH_KEYWORDS },
         { "new_wxEditableListBox", (PyCFunction) _wrap_new_wxEditableListBox, METH_VARARGS | METH_KEYWORDS },
         { "wxEditableListBox_GetStrings", (PyCFunction) _wrap_wxEditableListBox_GetStrings, METH_VARARGS | METH_KEYWORDS },
         { "wxEditableListBox_SetStrings", (PyCFunction) _wrap_wxEditableListBox_SetStrings, METH_VARARGS | METH_KEYWORDS },
         { "new_wxEditableListBox", (PyCFunction) _wrap_new_wxEditableListBox, METH_VARARGS | METH_KEYWORDS },
@@ -680,6 +1365,7 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
     { "_wxPrintQuality","_EBool",0},
     { "_wxPrintQuality","_size_t",0},
     { "_wxPrintQuality","_time_t",0},
     { "_wxPrintQuality","_EBool",0},
     { "_wxPrintQuality","_size_t",0},
     { "_wxPrintQuality","_time_t",0},
+    { "_wxPyTreeCtrl","_wxRemotelyScrolledTreeCtrl",SwigwxRemotelyScrolledTreeCtrlTowxPyTreeCtrl},
     { "_byte","_unsigned_char",0},
     { "_long","_unsigned_long",0},
     { "_long","_signed_long",0},
     { "_byte","_unsigned_char",0},
     { "_long","_unsigned_long",0},
     { "_long","_signed_long",0},
@@ -690,6 +1376,7 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
     { "_size_t","_int",0},
     { "_size_t","_wxWindowID",0},
     { "_size_t","_uint",0},
     { "_size_t","_int",0},
     { "_size_t","_wxWindowID",0},
     { "_size_t","_uint",0},
+    { "_wxPanel","_wxSplitterScrolledWindow",SwigwxSplitterScrolledWindowTowxPanel},
     { "_wxPanel","_wxEditableListBox",SwigwxEditableListBoxTowxPanel},
     { "_uint","_wxCoord",0},
     { "_uint","_wxPrintQuality",0},
     { "_wxPanel","_wxEditableListBox",SwigwxEditableListBoxTowxPanel},
     { "_uint","_wxCoord",0},
     { "_uint","_wxPrintQuality",0},
@@ -722,13 +1409,20 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
     { "_unsigned_short","_wxDateTime_t",0},
     { "_unsigned_short","_WXTYPE",0},
     { "_unsigned_short","_short",0},
     { "_unsigned_short","_wxDateTime_t",0},
     { "_unsigned_short","_WXTYPE",0},
     { "_unsigned_short","_short",0},
+    { "_wxSplitterWindow","_wxThinSplitterWindow",SwigwxThinSplitterWindowTowxSplitterWindow},
+    { "_wxObject","_wxSplitterScrolledWindow",SwigwxSplitterScrolledWindowTowxObject},
+    { "_wxObject","_wxThinSplitterWindow",SwigwxThinSplitterWindowTowxObject},
+    { "_wxObject","_wxPyTreeCompanionWindow",SwigwxPyTreeCompanionWindowTowxObject},
+    { "_wxObject","_wxRemotelyScrolledTreeCtrl",SwigwxRemotelyScrolledTreeCtrlTowxObject},
     { "_wxObject","_wxEditableListBox",SwigwxEditableListBoxTowxObject},
     { "_wxObject","_wxDynamicSashWindow",SwigwxDynamicSashWindowTowxObject},
     { "_wxObject","_wxDynamicSashUnifyEvent",SwigwxDynamicSashUnifyEventTowxObject},
     { "_wxObject","_wxDynamicSashSplitEvent",SwigwxDynamicSashSplitEventTowxObject},
     { "_signed_short","_WXTYPE",0},
     { "_signed_short","_short",0},
     { "_wxObject","_wxEditableListBox",SwigwxEditableListBoxTowxObject},
     { "_wxObject","_wxDynamicSashWindow",SwigwxDynamicSashWindowTowxObject},
     { "_wxObject","_wxDynamicSashUnifyEvent",SwigwxDynamicSashUnifyEventTowxObject},
     { "_wxObject","_wxDynamicSashSplitEvent",SwigwxDynamicSashSplitEventTowxObject},
     { "_signed_short","_WXTYPE",0},
     { "_signed_short","_short",0},
+    { "_wxScrolledWindow","_wxSplitterScrolledWindow",SwigwxSplitterScrolledWindowTowxScrolledWindow},
     { "_unsigned_char","_byte",0},
     { "_unsigned_char","_byte",0},
+    { "_wxControl","_wxRemotelyScrolledTreeCtrl",SwigwxRemotelyScrolledTreeCtrlTowxControl},
     { "_unsigned_int","_wxCoord",0},
     { "_unsigned_int","_wxPrintQuality",0},
     { "_unsigned_int","_time_t",0},
     { "_unsigned_int","_wxCoord",0},
     { "_unsigned_int","_wxPrintQuality",0},
     { "_unsigned_int","_time_t",0},
@@ -777,8 +1471,16 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
     { "_wxCoord","_size_t",0},
     { "_wxCoord","_time_t",0},
     { "_wxCoord","_wxPrintQuality",0},
     { "_wxCoord","_size_t",0},
     { "_wxCoord","_time_t",0},
     { "_wxCoord","_wxPrintQuality",0},
+    { "_wxEvtHandler","_wxSplitterScrolledWindow",SwigwxSplitterScrolledWindowTowxEvtHandler},
+    { "_wxEvtHandler","_wxThinSplitterWindow",SwigwxThinSplitterWindowTowxEvtHandler},
+    { "_wxEvtHandler","_wxPyTreeCompanionWindow",SwigwxPyTreeCompanionWindowTowxEvtHandler},
+    { "_wxEvtHandler","_wxRemotelyScrolledTreeCtrl",SwigwxRemotelyScrolledTreeCtrlTowxEvtHandler},
     { "_wxEvtHandler","_wxEditableListBox",SwigwxEditableListBoxTowxEvtHandler},
     { "_wxEvtHandler","_wxDynamicSashWindow",SwigwxDynamicSashWindowTowxEvtHandler},
     { "_wxEvtHandler","_wxEditableListBox",SwigwxEditableListBoxTowxEvtHandler},
     { "_wxEvtHandler","_wxDynamicSashWindow",SwigwxDynamicSashWindowTowxEvtHandler},
+    { "_wxWindow","_wxSplitterScrolledWindow",SwigwxSplitterScrolledWindowTowxWindow},
+    { "_wxWindow","_wxThinSplitterWindow",SwigwxThinSplitterWindowTowxWindow},
+    { "_wxWindow","_wxPyTreeCompanionWindow",SwigwxPyTreeCompanionWindowTowxWindow},
+    { "_wxWindow","_wxRemotelyScrolledTreeCtrl",SwigwxRemotelyScrolledTreeCtrlTowxWindow},
     { "_wxWindow","_wxEditableListBox",SwigwxEditableListBoxTowxWindow},
     { "_wxWindow","_wxDynamicSashWindow",SwigwxDynamicSashWindowTowxWindow},
 {0,0,0}};
     { "_wxWindow","_wxEditableListBox",SwigwxEditableListBoxTowxWindow},
     { "_wxWindow","_wxDynamicSashWindow",SwigwxDynamicSashWindowTowxWindow},
 {0,0,0}};
@@ -801,6 +1503,7 @@ SWIGEXPORT(void) initgizmosc() {
     wxClassInfo::CleanUpClasses();
     wxClassInfo::InitializeClasses();
 
     wxClassInfo::CleanUpClasses();
     wxClassInfo::InitializeClasses();
 
+    wxPyPtrTypeMap_Add("wxTreeCompanionWindow", "wxPyTreeCompanionWindow");
 {
    int i;
    for (i = 0; _swig_mapping[i].n1; i++)
 {
    int i;
    for (i = 0; _swig_mapping[i].n1; i++)
index 2702de80b8a2527064dbd27ed8ab9c6684448159..e607fd129b1b20f061b5532d3a5217aad995cabb 100644 (file)
@@ -15,8 +15,9 @@
 
 %{
 #include "export.h"
 
 %{
 #include "export.h"
-#include "wx/gizmos/dynamicsash.h"
-#include "wx/gizmos/editlbox.h"
+#include <wx/gizmos/dynamicsash.h>
+#include <wx/gizmos/editlbox.h>
+#include <wx/gizmos/splittree.h>
 %}
 
 //---------------------------------------------------------------------------
 %}
 
 //---------------------------------------------------------------------------
@@ -90,7 +91,7 @@ public:
 
     As an application developer, you will simply create a wxDynamicSashWindow
     using either the Create() function or the more complex constructor
 
     As an application developer, you will simply create a wxDynamicSashWindow
     using either the Create() function or the more complex constructor
-    provided below, and then create a viewfrom wxPython.wx import * window whose parent is the
+    provided below, and then create a view window whose parent is the
     wxDynamicSashWindow.  The child should respond to
     wxDynamicSashSplitEvents -- perhaps with an OnSplit() event handler -- by
     constructing a new view window whose parent is also the
     wxDynamicSashWindow.  The child should respond to
     wxDynamicSashSplitEvents -- perhaps with an OnSplit() event handler -- by
     constructing a new view window whose parent is also the
@@ -102,7 +103,7 @@ public:
     complex.  (You might want to handle scrollbar events yourself, if,
     for instance, you wish to scroll a subwindow of the view you add to
     your wxDynamicSashWindow object, rather than scrolling the whole view.)
     complex.  (You might want to handle scrollbar events yourself, if,
     for instance, you wish to scroll a subwindow of the view you add to
     your wxDynamicSashWindow object, rather than scrolling the whole view.)
-    In this case, you will need to construfrom wxPython.wx import *ct your wxDynamicSashWindow without
+    In this case, you will need to construct your wxDynamicSashWindow without
     the wxDS_MANAGE_SCROLLBARS style and  you will need to use the
     GetHScrollBar() and GetVScrollBar() methods to retrieve the scrollbar
     controls and call SetEventHanler() on them to redirect the scrolling
     the wxDS_MANAGE_SCROLLBARS style and  you will need to use the
     GetHScrollBar() and GetVScrollBar() methods to retrieve the scrollbar
     controls and call SetEventHanler() on them to redirect the scrolling
@@ -165,6 +166,8 @@ public:
                       const wxSize& size = wxDefaultSize,
                       const char* name = "editableListBox");
 
                       const wxSize& size = wxDefaultSize,
                       const char* name = "editableListBox");
 
+    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
+
     void SetStrings(const wxArrayString& strings);
 
     //void GetStrings(wxArrayString& strings);
     void SetStrings(const wxArrayString& strings);
 
     //void GetStrings(wxArrayString& strings);
@@ -179,6 +182,146 @@ public:
 
 
 
 
 
 
+//----------------------------------------------------------------------
+
+
+/*
+ * wxRemotelyScrolledTreeCtrl
+ *
+ * This tree control disables its vertical scrollbar and catches scroll
+ * events passed by a scrolled window higher in the hierarchy.
+ * It also updates the scrolled window vertical scrollbar as appropriate.
+ */
+
+%{
+    typedef wxTreeCtrl wxPyTreeCtrl;
+%}
+
+class wxRemotelyScrolledTreeCtrl: public wxPyTreeCtrl
+{
+public:
+    wxRemotelyScrolledTreeCtrl(wxWindow* parent, wxWindowID id,
+                               const wxPoint& pos = wxDefaultPosition,
+                               const wxSize& size = wxDefaultSize,
+                               long style = wxTR_HAS_BUTTONS);
+    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
+
+
+    void HideVScrollbar();
+
+    // Adjust the containing wxScrolledWindow's scrollbars appropriately
+    void AdjustRemoteScrollbars();
+
+    // Find the scrolled window that contains this control
+    wxScrolledWindow* GetScrolledWindow() const;
+
+    // Scroll to the given line (in scroll units where each unit is
+    // the height of an item)
+    void ScrollToLine(int posHoriz, int posVert);
+
+    // The companion window is one which will get notified when certain
+    // events happen such as node expansion
+    void SetCompanionWindow(wxWindow* companion);
+    wxWindow* GetCompanionWindow() const;
+};
+
+
+
+/*
+ * wxTreeCompanionWindow
+ *
+ * A window displaying values associated with tree control items.
+ */
+
+%{
+class wxPyTreeCompanionWindow: public wxTreeCompanionWindow
+{
+public:
+    wxPyTreeCompanionWindow(wxWindow* parent, wxWindowID id = -1,
+                            const wxPoint& pos = wxDefaultPosition,
+                            const wxSize& size = wxDefaultSize,
+                            long style = 0)
+        : wxTreeCompanionWindow(parent, id, pos, size, style) {}
+
+
+    virtual void DrawItem(wxDC& dc, wxTreeItemId id, const wxRect& rect) {
+        bool found;
+        wxPyTState* state = wxPyBeginBlockThreads();
+        if ((found = wxPyCBH_findCallback(m_myInst, "DrawItem"))) {
+            PyObject* dcobj = wxPyMake_wxObject(&dc);
+            PyObject* idobj = wxPyConstructObject((void*)&id, "wxTreeItemId", FALSE);
+            PyObject* recobj= wxPyConstructObject((void*)&rect, "wxRect", FALSE);
+            wxPyCBH_callCallback(m_myInst, Py_BuildValue("(OOO)", dcobj, idobj, recobj));
+            Py_DECREF(dcobj);
+            Py_DECREF(idobj);
+            Py_DECREF(recobj);
+        }
+        wxPyEndBlockThreads(state);
+        if (! found)
+            wxTreeCompanionWindow::DrawItem(dc, id, rect);
+    }
+
+    PYPRIVATE;
+};
+%}
+
+
+%name(wxTreeCompanionWindow) class wxPyTreeCompanionWindow: public wxWindow
+{
+public:
+    wxPyTreeCompanionWindow(wxWindow* parent, wxWindowID id = -1,
+                            const wxPoint& pos = wxDefaultPosition,
+                            const wxSize& size = wxDefaultSize,
+                            long style = 0);
+    void _setCallbackInfo(PyObject* self, PyObject* _class);
+    %pragma(python) addtomethod = "__init__:self._setCallbackInfo(self, wxTreeCompanionWindow)"
+    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
+
+    wxRemotelyScrolledTreeCtrl* GetTreeCtrl() const;
+    void SetTreeCtrl(wxRemotelyScrolledTreeCtrl* treeCtrl);
+};
+
+
+
+/*
+ * wxThinSplitterWindow
+ *
+ * Implements a splitter with a less obvious sash
+ * than the usual one.
+ */
+
+class wxThinSplitterWindow: public wxSplitterWindow
+{
+public:
+    wxThinSplitterWindow(wxWindow* parent, wxWindowID id = -1,
+                         const wxPoint& pos = wxDefaultPosition,
+                         const wxSize& size = wxDefaultSize,
+                         long style = wxSP_3D | wxCLIP_CHILDREN);
+    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
+
+};
+
+
+/*
+ * wxSplitterScrolledWindow
+ *
+ * This scrolled window is aware of the fact that one of its
+ * children is a splitter window. It passes on its scroll events
+ * (after some processing) to both splitter children for them
+ * scroll appropriately.
+ */
+
+class wxSplitterScrolledWindow: public wxScrolledWindow
+{
+public:
+    wxSplitterScrolledWindow(wxWindow* parent, wxWindowID id = -1,
+                             const wxPoint& pos = wxDefaultPosition,
+                             const wxSize& size = wxDefaultSize,
+                             long style = 0);
+    %pragma(python) addtomethod = "__init__:self._setOORInfo(self)"
+};
+
+
 //----------------------------------------------------------------------
 
 %init %{
 //----------------------------------------------------------------------
 
 %init %{
@@ -186,6 +329,7 @@ public:
     wxClassInfo::CleanUpClasses();
     wxClassInfo::InitializeClasses();
 
     wxClassInfo::CleanUpClasses();
     wxClassInfo::InitializeClasses();
 
+    wxPyPtrTypeMap_Add("wxTreeCompanionWindow", "wxPyTreeCompanionWindow");
 %}
 
 
 %}
 
 
@@ -195,3 +339,7 @@ public:
 //----------------------------------------------------------------------
 
 
 //----------------------------------------------------------------------
 
 
+
+
+
+
index 7828ecd390027e44d00e268365b91ac418a0c506..1c57d48029e22e7a8a4e0ba2ece5a4752fb0b09e 100644 (file)
@@ -123,6 +123,97 @@ class wxEditableListBox(wxEditableListBoxPtr):
     def __init__(self,*_args,**_kwargs):
         self.this = apply(gizmosc.new_wxEditableListBox,_args,_kwargs)
         self.thisown = 1
     def __init__(self,*_args,**_kwargs):
         self.this = apply(gizmosc.new_wxEditableListBox,_args,_kwargs)
         self.thisown = 1
+        self._setOORInfo(self)
+
+
+
+
+class wxRemotelyScrolledTreeCtrlPtr(wxTreeCtrlPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def HideVScrollbar(self, *_args, **_kwargs):
+        val = apply(gizmosc.wxRemotelyScrolledTreeCtrl_HideVScrollbar,(self,) + _args, _kwargs)
+        return val
+    def AdjustRemoteScrollbars(self, *_args, **_kwargs):
+        val = apply(gizmosc.wxRemotelyScrolledTreeCtrl_AdjustRemoteScrollbars,(self,) + _args, _kwargs)
+        return val
+    def GetScrolledWindow(self, *_args, **_kwargs):
+        val = apply(gizmosc.wxRemotelyScrolledTreeCtrl_GetScrolledWindow,(self,) + _args, _kwargs)
+        if val: val = wxScrolledWindowPtr(val) 
+        return val
+    def ScrollToLine(self, *_args, **_kwargs):
+        val = apply(gizmosc.wxRemotelyScrolledTreeCtrl_ScrollToLine,(self,) + _args, _kwargs)
+        return val
+    def SetCompanionWindow(self, *_args, **_kwargs):
+        val = apply(gizmosc.wxRemotelyScrolledTreeCtrl_SetCompanionWindow,(self,) + _args, _kwargs)
+        return val
+    def GetCompanionWindow(self, *_args, **_kwargs):
+        val = apply(gizmosc.wxRemotelyScrolledTreeCtrl_GetCompanionWindow,(self,) + _args, _kwargs)
+        return val
+    def __repr__(self):
+        return "<C wxRemotelyScrolledTreeCtrl instance at %s>" % (self.this,)
+class wxRemotelyScrolledTreeCtrl(wxRemotelyScrolledTreeCtrlPtr):
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(gizmosc.new_wxRemotelyScrolledTreeCtrl,_args,_kwargs)
+        self.thisown = 1
+        self._setOORInfo(self)
+
+
+
+
+class wxTreeCompanionWindowPtr(wxWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def _setCallbackInfo(self, *_args, **_kwargs):
+        val = apply(gizmosc.wxTreeCompanionWindow__setCallbackInfo,(self,) + _args, _kwargs)
+        return val
+    def GetTreeCtrl(self, *_args, **_kwargs):
+        val = apply(gizmosc.wxTreeCompanionWindow_GetTreeCtrl,(self,) + _args, _kwargs)
+        if val: val = wxRemotelyScrolledTreeCtrlPtr(val) 
+        return val
+    def SetTreeCtrl(self, *_args, **_kwargs):
+        val = apply(gizmosc.wxTreeCompanionWindow_SetTreeCtrl,(self,) + _args, _kwargs)
+        return val
+    def __repr__(self):
+        return "<C wxTreeCompanionWindow instance at %s>" % (self.this,)
+class wxTreeCompanionWindow(wxTreeCompanionWindowPtr):
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(gizmosc.new_wxTreeCompanionWindow,_args,_kwargs)
+        self.thisown = 1
+        self._setCallbackInfo(self, wxTreeCompanionWindow)
+        self._setOORInfo(self)
+
+
+
+
+class wxThinSplitterWindowPtr(wxSplitterWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxThinSplitterWindow instance at %s>" % (self.this,)
+class wxThinSplitterWindow(wxThinSplitterWindowPtr):
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(gizmosc.new_wxThinSplitterWindow,_args,_kwargs)
+        self.thisown = 1
+        self._setOORInfo(self)
+
+
+
+
+class wxSplitterScrolledWindowPtr(wxScrolledWindowPtr):
+    def __init__(self,this):
+        self.this = this
+        self.thisown = 0
+    def __repr__(self):
+        return "<C wxSplitterScrolledWindow instance at %s>" % (self.this,)
+class wxSplitterScrolledWindow(wxSplitterScrolledWindowPtr):
+    def __init__(self,*_args,**_kwargs):
+        self.this = apply(gizmosc.new_wxSplitterScrolledWindow,_args,_kwargs)
+        self.thisown = 1
+        self._setOORInfo(self)
 
 
 
 
 
 
@@ -148,3 +239,10 @@ wxDS_DRAG_CORNER = gizmosc.wxDS_DRAG_CORNER
 wx.wxDynamicSashSplitEventPtr       = wxDynamicSashSplitEventPtr
 wx.wxDynamicSashUnifyEventPtr       = wxDynamicSashUnifyEventPtr
 wx.wxDynamicSashWindowPtr           = wxDynamicSashWindowPtr
 wx.wxDynamicSashSplitEventPtr       = wxDynamicSashSplitEventPtr
 wx.wxDynamicSashUnifyEventPtr       = wxDynamicSashUnifyEventPtr
 wx.wxDynamicSashWindowPtr           = wxDynamicSashWindowPtr
+
+wx.wxEditableListBoxPtr             = wxEditableListBoxPtr
+
+wx.wxRemotelyScrolledTreeCtrlPtr    = wxRemotelyScrolledTreeCtrlPtr
+wx.wxTreeCompanionWindowPtr         = wxTreeCompanionWindowPtr
+wx.wxThinSplitterWindowPtr          = wxThinSplitterWindowPtr
+wx.wxSplitterScrolledWindowPtr      = wxSplitterScrolledWindowPtr
index 6985790b696160615a4d789e9c232454e8c14063..d66719655c45f94aed690cb96b398b8c05b581a9 100644 (file)
@@ -3,7 +3,7 @@ from wxPython.wx import *
 from wxPython.help import *
 
 #----------------------------------------------------------------------
 from wxPython.help import *
 
 #----------------------------------------------------------------------
-# We first have to set an application wide help provider.  Normally you
+# We first have to set an application-wide help provider.  Normally you
 # would do this in your app's OnInit or in other startup code...
 
 provider = wxSimpleHelpProvider()
 # would do this in your app's OnInit or in other startup code...
 
 provider = wxSimpleHelpProvider()
index 2b4f3eae840d450c9693a490743d74bef654318e..a3b065e521369e4d60fa276792636d3146bc1090 100644 (file)
@@ -85,7 +85,10 @@ _treeList = [
                           'wxRightTextCtrl',
                           ]),
 
                           'wxRightTextCtrl',
                           ]),
 
-    ('Cool Contribs', ['pyTree', 'hangman', 'SlashDot', 'XMLtreeview']),
+    ('Cool Contribs', ['pyTree', 'hangman',
+                       #'SlashDot',
+                       'XMLtreeview'
+                       ]),
 
     ]
 
 
     ]
 
diff --git a/wxPython/demo/SplitTree.py b/wxPython/demo/SplitTree.py
new file mode 100644 (file)
index 0000000..ee6b5f1
--- /dev/null
@@ -0,0 +1,97 @@
+from wxPython.wx import *
+from wxPython.gizmos import *
+
+import images
+
+#----------------------------------------------------------------------
+
+class TestTree(wxRemotelyScrolledTreeCtrl):
+    def __init__(self, parent, ID, pos=wxDefaultPosition, size=wxDefaultSize,
+                 style=wxTR_HAS_BUTTONS):
+        wxRemotelyScrolledTreeCtrl.__init__(self, parent, ID, pos, size, style)
+        self.SetBackgroundColour("LIGHT BLUE")
+
+        # make an image list
+        self.il = wxImageList(16, 16)
+        im1 = self.il.AddIcon(wxIconFromXPMData(images.getFolder1Data()))
+        im2 = self.il.AddIcon(wxIconFromXPMData(images.getFile1Data()))
+
+        # Add some items
+        root = self.AddRoot("Root")
+        for i in range(30):
+            item = self.AppendItem(root, "Item %d" % i, im1)
+            for j in range(10):
+                self.AppendItem(item, "Child %d" % j, im2)
+
+        self.Expand(root)
+
+
+
+class TestValueWindow(wxTreeCompanionWindow):
+    def __init__(self, parent, ID, pos=wxDefaultPosition, size=wxDefaultSize, style=0):
+        wxTreeCompanionWindow.__init__(self, parent, ID, pos, size, style)
+        self.SetBackgroundColour("WHITE")
+
+    # This method is called to draw each item in the value window
+    def DrawItem(self, dc, itemId, rect):
+        tree = self.GetTreeCtrl()
+        if tree:
+            text = "This is "
+            parent = tree.GetItemParent(itemId)
+            if parent.IsOk():
+                ptext = tree.GetItemText(parent)
+                text = text + ptext + " --> "
+            text = text + tree.GetItemText(itemId)
+            dc.SetTextForeground("BLACK")
+            dc.SetBackgroundMode(wxTRANSPARENT)
+            tw, th = dc.GetTextExtent(text)
+            x = 5
+            y = rect.y + max(0, (rect.height - th) / 2)
+            dc.DrawText(text, x, y)
+
+
+
+class TestPanel(wxPanel):
+    def __init__(self, parent, log):
+        wxPanel.__init__(self, parent, -1)
+        self.log = log
+
+        scroller = wxSplitterScrolledWindow(self, -1, (50,50), (350, 250),
+                                      style=wxNO_BORDER | wxCLIP_CHILDREN | wxVSCROLL)
+        splitter = wxThinSplitterWindow(scroller, -1, style=wxSP_3DBORDER | wxCLIP_CHILDREN)
+        splitter.SetSashSize(2)
+        self.tree = TestTree(splitter, -1, style=wxTR_HAS_BUTTONS | wxTR_NO_LINES | wxNO_BORDER)
+        valueWindow = TestValueWindow(splitter, -1, style=wxNO_BORDER)
+
+        splitter.SplitVertically(self.tree, valueWindow)
+        splitter.SetSashPosition(150)
+        scroller.SetTargetWindow(self.tree)
+        scroller.EnableScrolling(FALSE, FALSE)
+
+        valueWindow.SetTreeCtrl(self.tree)
+        self.tree.SetCompanionWindow(valueWindow)
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, log)
+    return win
+
+
+#----------------------------------------------------------------------
+
+
+
+
+
+overview = """\
+This demo shows a collection of classes that were designed to operate
+together and provide a tree control with additional columns for each
+item.  The classes are wxRemotelyScrolledTreeCtrl, wxTreeCompanionWindow,
+wxThinSplitterWindow, and wxSplitterScrolledWindow, some of which may
+also be useful by themselves.
+"""
+
+
diff --git a/wxPython/demo/bmp_source/file1.ico b/wxPython/demo/bmp_source/file1.ico
new file mode 100644 (file)
index 0000000..cc828ab
Binary files /dev/null and b/wxPython/demo/bmp_source/file1.ico differ
diff --git a/wxPython/demo/bmp_source/folder1.ico b/wxPython/demo/bmp_source/folder1.ico
new file mode 100644 (file)
index 0000000..c43de1c
Binary files /dev/null and b/wxPython/demo/bmp_source/folder1.ico differ
diff --git a/wxPython/demo/bmp_source/folder2.ico b/wxPython/demo/bmp_source/folder2.ico
new file mode 100644 (file)
index 0000000..98b6d3f
Binary files /dev/null and b/wxPython/demo/bmp_source/folder2.ico differ
index aaec4e1da49adde6dce7852d436c323441953801..65d89dc118e80d39789fba7d5784394d52388342 100644 (file)
@@ -51,6 +51,10 @@ command_lines = [
     "-a -n SmallUpArrow  -m #0000FF bmp_source/sm_up.bmp images.py",
     "-a -n SmallDnArrow  -m #0000FF bmp_source/sm_down.bmp images.py",
 
     "-a -n SmallUpArrow  -m #0000FF bmp_source/sm_up.bmp images.py",
     "-a -n SmallDnArrow  -m #0000FF bmp_source/sm_down.bmp images.py",
 
+    "-a -n Folder1 bmp_source/folder1.ico images.py",
+    "-a -n Folder2 bmp_source/folder2.ico images.py",
+    "-a -n File1   bmp_source/file1.ico   images.py",
+
     ]
 
 
     ]
 
 
index ff15d9d7fa21dd51f13b780f6f4576125696470e..90d2a5750d845fcac38e605d1113d75c85b07905 100644 (file)
@@ -1934,3 +1934,160 @@ def getSmallDnArrowBitmap():
 def getSmallDnArrowImage():
     return wxImageFromBitmap(getSmallDnArrowBitmap())
 
 def getSmallDnArrowImage():
     return wxImageFromBitmap(getSmallDnArrowBitmap())
 
+#----------------------------------------------------------------------
+def getFolder1Data():
+    return cPickle.loads(zlib.decompress(
+'x\xda\xd3\xc8)0\xe4\nV76R\x00"C\x05Cu\xae\xc4`u\x05\x85d\x05\xbf\xfc\xbcT(\
+\x07?\x18U4\xaahT\xd1\xa8\xa2\x81Q\xa4\x07\x00jB\xa8\xe5' ))
+
+def getFolder1Bitmap():
+    return wxBitmapFromXPMData(getFolder1Data())
+
+def getFolder1Image():
+    return wxImageFromBitmap(getFolder1Bitmap())
+
+#----------------------------------------------------------------------
+def getFolder2Data():
+    return cPickle.loads(zlib.decompress(
+'x\xda\xcdYkS\x14K\x12\xfd~\x7fE"o\xd0\xb4g\xbagz\xda\x07A?UDFD1\xd5\x10AT@\
+\xc1\xc27\xa0\xf2\xdb\xb7\xbaNV\xb5z\x8d\x8dkll\xecN\xfa\xc5cUV\xe6\xc9Ge\
+\xb5s\x87\xc7\xbd\xbf6f\xe3>\xb5\x7f\xd2\x01\xf5g\xff\xda\xd9\x98]\x1e\xd3.\
+\x15\x87;\xbbo\xdc_\xaf\x91\xfd\xebd3l\x86y\xee\x80+\xdc\x02uY\x97\x83\xd2\
+\x01\xcf\x1d\xd0\xe4M\x1e%\x0eX1-P\xf6\xca^6t\xc0e\xa7\xa3\xca\xaa,\x8b\x1dp\
+\xe2\xb6\x14eQ\xa6\xd8r\xcf\x01\xa3\xd2\n\xb6<\x0b\xc7\x16\x99\x03\xee8\xa5y\
+\xd6\x8a\x03f\x1cP\xa7u\x9a@\xe9\x14\x07\x00J\'\xc5mI\xf2d\x84-\xb7\x1cP%U\
+\x92\xc2\xf4\x1b\x14\x80\xca\x01\x8b\xad\xf3\x93\xf1\xa0\x15\x07\xbc7aE\xed\
+\x80\x03\xf1\xee\xa7#\xb8\x1f,-q\xca\xa1xo\xf3\xc6\x01\xc3@P\xbfp\xc0;\xf6J3\
+pn\x82\xa59L_w\xc7fM\xd6\x8c"\x07\xec\xb8-e^\xda%\x0ex\xe1V\x0c\xf3V\xc0X\
+\xb7E\x95:_\x92\xf6\x188\xf7\x02\xac\xa7E:\x82sO\xe0K\xbf\xee\x0fz\x0exC\x01\
+\x80\x8e\xefp\xae\xd7\xf4J\x98>\xd7m\x01\xeb\xd3\xe2\xddo\x10\xb9\x8d\xe0~\
+\x05>\x9e\xb17,\x03\x1f\xe2\x0c\x1b\x0eZq@\x0e\x92\xed/\x81\xb7\xe4V\xe4U^\r\
+\x00\xc4\xe2\xed\xa8a\xe9\x18\x9c\x0e\x9aA\x0c\xf7\x93n\x05L\xff\n>l\xbe\x8c\
+\x109vJ\xb3A6\x18"rK\xe4C\xa9\x91\xcb\x1cP6e\xa39\xf6\x88\xc3\x16$\x8c\x84\
+\x0c\xaa\x10\xa8\xa6[\x01\x92_\x81\xe4~\xd1\xcf`\xe95\xf6J\x0bx\xbb\xe6\x80\
+\xb4j\xc5\x01\x1f\xc4\xfb2H\x1d\xb0\xe0\xec\x18F\xad\xa0&\xc5G\xdf\x17P\xb7\
+\x05\x86-9o\x07\xc5\xa0Hp\xca\x03p:\xaaFJ\xe1f\xb04s+.\xcc\xa2\xa2F\xf9h8\
+\xb8\xe0\x08\ny\x9a\x83\xc2\xe7nE\\\xb7\x82\x94\xeaV\xc0\xd2u(\x8d\xb2(E~\\t\
+[\xa2\xa4\x15\x07lS\xd8\x02\x1d\x93(\xd3\xa2.b\xe8\xb8I\x01@\\\xee\xa3\xb2\
+\x87\xf5\xb0\x87\x15\x13\xe4}I\xe1\xcb#\t\x00,\x1d\xa1\x1a\xb2a\xd6\x83\x1d\
+\x93\xc1}\xed0s!\xb5K(=r+\xd2\xb8\x15\x94\xa9xKKP\xd8\xeb\x00li\xc4[\xaa\xac\
+\xbf\x0b\xa7\x8c\x00D\xc1\xd2\x11b\xdb\x0f+4\x1d>\x91\x8f\\\x01\xd3\xc7\xe4\
+\xc3\x90\xc3\xfd\x8f\xc1}\xedc\x15\x05@\xeb\xb6\xd3\x01NW%\xac@\x11\n\xd2\
+\xa1\xd7\x8a\x03>\x07\x92\x95\xb1\x19\xf4\xa0\xb8\x8aST\xe5\x8e\xdb\xd2K[A\
+\x18\xc4\xaf\x18\x81\xa0\x1b\x1d\x00Ko\x85\xd86(\xc2O`\xacnj\xed\x0e\xafB\
+\xa0\n\x00Y(\xf5\n\x04\xdd\x80\xb7\xb6\xae\xb5\xe3\x9e\xa3^\xb22\xd3\xa4\xdb\
+\xc4u\x12\xb5\xe2\x80y\xb7"\x8f[\xc1\xed\xe1V\x14\xbd\xa2\xa7\x9d\xee\xb1;v4\
+l\x05m\x9c\xbc\xe9\x19L\x7f\x0bKmO\x8a\xb1\xe5\x8b\x032\xfb\x1b\xe0\xd83\xa7\
+\xb4I\x9a\xa4\x87\xd8^\r\x8c\xe9M8\x1d\xc2\xd0\xc0\xf4]\xf2\xbe\x0c\x00\x1cv\
+\x00\xec\x98\t\xf9Q\xc1\x8e\x03\xb8o)\x8b\x10\xa8\xd5`\xa9^|\xecV\x8cz\xad\
+\x80d\xf0a\xfb\x96\xa6\xd4E\xf8\x125Q\x8d\x84\x19u\x00\xecXb\xefK\x82\xe8\
+\xdf5\x9ed\xad\xdb2\x00z\xca!\xc2\x90\x94\xc9\x00+VQ\xeaI\x96\x0cA\xd0\xed\
+\x0e@\x06=&oX\x01\x1d7\xc2\x8a\x14\xc0C\xe4i^\xfbQ\xe1=\xfb\xc8\xe9\xa8`\x9c\
+\x0eG)\x94\xce\x87\xc4\xad\xc0\xfa5gi\xd2o\xc5\x01\xaf\xc1XY\x95C$\xeei\xc8B\
+\xbd\x80?\x92\'Y+\xea3Bi;p\x82\xd8\x0e\xc8\xbb\xaf\xb1]\x08:J\x9c\xf2N<\x1fz\
+\xbd\x1e\xbb-\xa9\xfb\xa1LMX\x01\xa5c\xe3sL\x95\xde\xc7\x94\xd3\x8c\x1a\x1d&\
+\xaa\x0e\x80\xa5w\x03\xa0\xf7\xfe\x94\xf1\x8c\xc5\x08\xc3\n\x05\x00\xa7\x1c\
+\x05\xd3\xf5\x16{\x1d*\xaa\x04\xeb3\xc1\x17\xbd\x1a\xcf\xc4\xf3\xa1\xb3CN\
+\x9e\x0f\xed\x85\x1f1\x90\xb47\x0eNILX\x01\n\xaf\xb3\xb7C\x9b\xd2\x8a\x84\
+\x15\x00\x96\x03\xc9)b{\x89|\x16f`\xecr\xe7-\xdc\x7f\x82t\xc8\x8b\\o\xc2\x03\
+\x90\xdco\xc5\x01{\xe2\x83\x9dCi?\x14\xb2\xba?\xe8\x0087\n\x8ciU\xee#\xb5\
+\xad\x12\xad\xfd\xab\xc10M\x18\x16O\xa1\x8e\x1b\x93h\xd2i+\x98\xa5\xc2\x96\
+\x02\x85\\\xe3X\xebJ\x0f\x91{\x8f\x1e\xe4\x1a;f\x18\xc4eP\x0f\x12l\xf9\x8c&\
+\x1d\xb5\x82;[\xc2\n\xf82\xec\xb6\xe4\xb8\xb3\xbb\x15\x85\xbb\xb3o#r\xfd\xaa\
+\xafi9\xcd\x01@(\x9f\x82\xe4\xc1h\x90\xc2\x8e\x13\xa4e\xdc\xc4\x11\xf8\xf8\
+\x1c"\xa7\xbedh\xb0\xfdV\x1c\xf0\r\r6*"m\xb0}\xf6\xde\xea%~\x19\xd3\x96\x1d\
+\xfaF\xc8\x8fO \xd9\x0e\xf4\tr}\xc2\x9d\xd2oo`\x00[\xdd\x16\xe8\x18\xb0wN\
+\xdb\xc51\xd2\xc1N5\x18\xe0/\xcc\x86B.\x1b\xe7\xfe\x1e\x80\xa8\x8e\x06\xba\
+\x02\xdeF\xad\xb8\x15G\x0e\x18\xc6\xad\xa0\x90\xc9\xbb\x1f\x83\xe4\xdbH\xed\
+\xa2\xf2\xa3\xd3\xa5P\x1e5\x0c[\x0c\x8c\xe9|\xfa\x14\xa3\x93MT\x1c;;\xd1\x01\
+\xa8\x97\xfb\xe4M\xd7\xa9\xaf\x1f\xb2\xb0\x84\xfb\x0f\xd0\x1c\xe3,\xd6\xd4\
+\xce;\x00\x96naPl\x07v\xd4\xfe)\xd2\xc1\xfe\xfa\xc8\xd3K\x01\x88a\xd8\x074\
+\xc7^+\xe8\xb8\xe4\x9d\xd3\xe6\xf84\xd8QA\xc7\xd5\xe0\xbe\x8e\xc5\'\xdd\x168\
+\xb7/\xde\xfd!\x94>\n:j\xa4Td|E\x95\xc8\x8f\xcb\xe2\rKp\xec\x1d\xf2\x19T\xc0\
+\xd2u\x94G2Jz8\xe5"\xf9\x94\xd2\xa4\xfb\x0eN\xed\x03G\xbb\xd4\x11\x94fu\xd6\
+\xc7)\x17\xd9[\x9aA\xe9\n\xa2_[\x81\xa57;\x00\x9c\xde\x0c:\xb4\x9fN\x91O:\
+\xbd+\x0fMX\x81S\x08\xc9\x9f\x15\x99f\xf2\x02\x87\x15\xa0\xf0\x1b\xfb\xe8\
+\xe7P\xfa"\xb8\xafwe)\xc1\x0e\x00_Qs\xc3j\xa8\xcd\xf1n\x07 \x0cw\x10}7\x90\
+\xe1q&\xde[\xbdNVaiR\'}\x00K\xa1\x07\x95\xc8\xc2\xac\x03\xe0\xcb\x15\xf8b\
+\xafSel\xdf\xf8\x02\xaa\x01\x9c\xa2n\xedO\xaf\xd7\x14q\xb1\x0f\x98\x18\x14\
+\xee!\xd8q+\x98\x93\x03\x1fCm\xf4\xec}\xd1F_ \x0cY+\xb8\xa3\xd8s\xaa/qb\x9fc\
+z\xdf.\x04\xe7\xf4\xc1\xbbN\x01\xc0\x96m\t\x008]F&\xf7\xaa\x9e6\x14\n\x8cU\
+\xfazE\xa0z\xad`\xa2\xc7\x96\xa6j4\x1d\xae\x86\\\xafp\xca7\x00\xfd\xa6\x1f\
+\x01H\xbb\x15\xe0t\x8c\xe7l\xda\nfK\xa7\xb4\xdf\xf6`\xacxI\xde\xb0\x0c\x96R\
+\x0b\xac\x99\xb7/\xe1\x08\x1a\xa1\xbd\xc0\x95\x9d{\xe4\xd3G_\xdd\x8f\xd1\x1a\
+\xd2,\xd5w\xe8\x94x\xfetJ\xcc\xc5\xeb\xc8\xb0b\x137g\x93\xfa\xd1"\x85\xab\
+\xf6Q\xad}\xafF\xaf\x18\xb4\x82\xb2\x06\xe5U]\xe9\x15V\x86c\xb5\xa9\xbf\r\
+\x86\xd5pd\x1e5j\x7f:5\xaf9;\xd2(\x8d\xfa\xfa\xe1\x02\x85\x9f\xb4\x82\nD\xfa\
+\xa4e\xaa\xb3yA\xfe\x14\xcd\x96\x1e\xf9|\xaa\x10%\x81/\xee\xfa\x85\xe90\xac\
+\x9f\xf5u\x1a\xd9t\xc7\x0e\xaaV\xf0\x15\x82\xbc/z\xdb\xc4\xec#\xad\xc7\xbeA.\
+\xd8\xb7K\x06\xa5o\x91\x936Y4\xf3\xcb\xce\x0ep\xba\x85\xd0[J\x95\x8f$\x14K\
+\x01\x92w;\xa5\x00&\x82\xa5z?\x9f\x91\x0f\xc3\x10\xb1\xfd\x16N\xa9\xb5\xedw+\
+p\xec\xeb\x90\x82\xfa\xbd\xe4\x99\x84\x15\xf0v\x17a\x88\xf2H3.\n\x86i\'\xd8\
+\x11\xef\xbe\xe6G\x1a\xbc\xd5\xa9\xe8K`L\x0b\xee\x0c\x8cEU\xa4/\xb3\x98\xbc\
+\xfb:\x04m \x94\xfd\xd2\x7f\xeb\xa8\x83\xe9#8\xf7\x15\xad\xa1m\xbfH\xbac\xbc\
+\xba\xeb\xb4\x8e\xb0\xe2\x16ZC\xfb \x02\xa7\x1b\x1d\x80c\xef`\xf2.\xcaBS\xea\
+\xa5\xf1J\xf5:\xbe-\x01\x00\xc9\xdb\x9d\x0e\xf01\x0f\xf7mzh\x06=\x17\xef\xad\
+^\xb6\x06\xc3\x98\xfb\xf4\x87A\xca\x84-\xb0\xf4z\x88~\xa9\xef\x1d\xd8\x11\
+\xd7\xb1\xde\xbe\x128U>\xd6B{\xd1\xcb\xf6\x15yK\xf5\xcbN\x14b\xab\xf7\xe2\
+\x93\x10J\xffu\x88\xbd\xfb\xfa\xb6\xbfe\xfc)\xda\xc4\x18\x9f\x8b\x8aV0\xbd\
+\xc3\x8eQ1\xd2k0\t\xb1\xd5\\\xaf\x82\xfb\x19\xb6|\xc7\x96\xb8\x88u\x809\'\
+\xef\x9c\x0e\xa7\xa7\x88~\xd1\x14:\x9c\xbe\t\xee\xeb7\x86\xeb\x1d\x8004\xe43\
+HG\xe0"\xf4 }\xcc-\x86\x1c\xd3\x84\x19\xe3\xa2\x8c\xad\xe0\xd8W\x81\x8f\x1c\
+\xc0q\x08e\x01\x82\xae\x05\n\x95\xe4s\x07$\xed\xbb\x13\x96\xee\x81\xc2a9T\
+\xc3\xae\x07\xc34\x93_v+\x00<D\xdd\x0e\xed\x95\x06\x1d\x1f\xc8\x9f\xd2@\xc7A\
+`Ls\xec^\xf8\x02\xd9\xd7\xefG\xa1\x9f\xea\xc8\xb7H>.:h/\xa3\xf5\xb9>\x0e;\
+\xd0>m+\xd4~Z`jv/ \xcc\t!\x94\xda.\x1et\x00\xec\x98\x0b_\xca5\xc7\xce;\x00[F\
+\xecOI\xe1\xdc\x95\x90\x96\x15r\xeck\x08\xb6\xce\x1a\xdf\xc3g\xef\x18e\xfa%|\
+\xc3\xd6\xcf4_LX\xa1\x0f1\xe3?\x04k\x97\xda\x0f\xff\r\xa0S\xd1\xd3\xf0\xa9X\
+\xbf\xeb\xad\xe1\x99\xe5&K46\xac\xb0\xbei\xae?\xc4]\xd9k\x05\x9c\x8awNs\xec\
+\x8ax\xd3KX:\x0c\x1f\xe8\xb3\xca\xdf\xbe\xff\xd1\xef\xbf\xa7\x84\xed\xc4\xf2\
+\xb3\x98?W2\xa6\xc5_d\xf9\xcf\x940M\xd2\x14M\xff"3V\xcd\xc2?W2\xa6\xebt\x89\
+\xae\xd2\x15Z\xa2\x8bt\x8dz\xd4\xa7\x98\x12\x1a\xfc\x1bk~R\x02+\x86\x94\xd2\
+\x882\x8a\xe8\x1d}\xa1\x97\xf4\x9e>\xd2)}r\xd6\x1c\xfcV~RrL;\xf4\x81^\xd0+\
+\xda\xa3}zMo\xe8\x90\xce\xe8\xc4&\xc4gzNo\xe9\x88\xee\xfc"kT\xd0\xe6\xef\x94\
+\x94\xf4\x98r\xda\xa0\x8a\x1a\xbaA7i\x85n\xd3*\xdd\xa5[\xf6\xdf\x1e\xfc"\x8f\
+\xe8\xbe*\xb9\xf0\xb3\x92{T\xd3CZ\xb7\xe7OX;\xce\xad=[t\x99\xe6h\x9e\x9e\xd1\
+6\xcd\xd2SzB_\xe9;\xd9\xa1\x80\x99\x857\xe9\xc2\xdf-1<\xe6uZ\xe4e\x9e\xe4)\
+\x9e\xe6\x19^\xe0\xeb|\x89\xaf\xf2\x15^\xe2\x8b|\x8d{\xdc\xe7\x98\x13\x1e\
+\xf0\x90S\xfe\xc5\x9d\x11g\x1c\xf1;\xfe\xc2/\xf9=\x7f\xe4S\xfe\xc4\x07|\xcc;\
+\xfc\x81_\xf0+\xde\xe3}~\xcdo\xf8\x90\xcf\xf8\x84w\xf93?\xe7\xb7?*9\xe2;\xbc\
+\xc6\x05or\xc9\x8f9\xe7\r\xae\xb8\xe1\x1b|\x93W\xf86\xaf\xf2]\xbe\xc5\x0f\
+\xf8\x11\xdf\xe7{\\\xf3C^\xe7\t>\xffA\x89\xe3d\x8b/\xf3\x1c\xcf\xff\x03y\xc6\
+\xdb<k\xe5)?\xe1\xaf\xfc]9Q%\xf6\xe9%\xfc\x0fD\xc4H\xabd,\x8b\xb2,\x93\xf2\
+\x03\xb1[<%\xd32#\x0br].\xc9U\xb9"KrQ\xaeIO\xfa\x12K"\x03\x19J*#\xc9$\x92w\
+\xf2E^\xca\x11\xbf\x97\x8f\xb2\xf9#\'Pr*\x9f\xe4@\x8eeG>\xc8\x0by%{\xb2/\xaf\
+\xe5\x8d\x1c\xca\x99\x9c\xc8\xae|\x96\xe7\xf2V\x8e\xe4\x8e\xacI!\x9bR\xcac\
+\xf9A\x89\xa1\\6\xa4\x92Sj\xe4\x86\xec\xd3MY\xa7\x19^\x91\xdb\xb2*w\xe5\x96<\
+\x90\x05~$\xf7\xe5\x9c\xeeI-\x0fe]&\xe4\\\xdap\xfc\x92l\xcb\xb6\xcc>\xd1\x96\
+\\\x969\x99\x97gv\xfb\xb6\xacHN\xb3V\xc5S\xab\xea\x89L\xf1\x19}\x95\xefb\x9f\
+7\x86\x8d\x98B\x8c\xf9m\xb2\x8d\xcd\xa2\xd9\x96e3i\xa6\xcc\xaa\xcc\xf0\xb4\
+\x991\x0b|W\xa6y\xc1L\xf2\x84M\xc3\xeb\xe6\x92\xb9j\xae\x98%s\xd1\\3\xbf\xad\
+\x9d\x9e\xe9\x9b\x13\x8a\xcd\x9c$f`\xd6i[&\xe8\x91\xb5bh\xceh\x99wiU\x1e\xd2\
+\xb4\xd9\xa3\xd4\x8c~\xa7\xe4\xc8\xe6@f2\x13\x99w\xe6\x8b\x89\xcd\xb2\x99\
+\x97)\xf3\xd2\xbc7\xd3\xfc\xd1Z\xb1\xcc\x8b\xb6 N\xcd>}\xb2\xd6\x1d\x98c\xb3\
+c>\x98\x17\xe6oM\xe9\x95\xd93\xfb\xe6\xb5Usbm\x98\xb3\x14\x0f\xcc\x1bsnKq\
+\xc2\x96\xe4\xba-\xcd\xc4Zqh\xce\xcc\x89\xd95\x9f\xcds\xf3\xf6\xefJ\x8e\xcc\
+\x1d\xb3f\n\xb3iJ\xf3\xd8\xe4f\xc3T\xa617\xccM\xb3bn\x9bUs\xd7\xdc2\x0f\xcc#\
++\xf7\xcd=\xb3\xc5\xf6\x9d\xf5st\xa0\xe4\xa1U3i\x03\xben&\xcc\xb9\xd92\x97\
+\xcd\x9c\x997\xcf\xcc\xb6\x995O\xcd\x13\xf3\xd5|7\xdf\xac\xd0\x98\xc7k,c3\
+\xbe\xf0\xb7\x1e;>\xa0?\x95\xdf^\x19\x8b\xe3?\x93\xdf*Y\x1e\xff\x99\xfc\x9f\
+\xdf\xc5\xff+%\xfc/J\xa6~h' ))
+
+def getFolder2Bitmap():
+    return wxBitmapFromXPMData(getFolder2Data())
+
+def getFolder2Image():
+    return wxImageFromBitmap(getFolder2Bitmap())
+
+#----------------------------------------------------------------------
+def getFile1Data():
+    return cPickle.loads(zlib.decompress(
+'x\xda\xd3\xc8)0\xe4\nV76R\x00"C\x05Cu\xae\xc4`u\x05\x85d\x05\xbf\xfc\xbcT(\
+\x07?\x18U4\xaahT\xd1\xa8\xa2\x81Q\xa4\x07\x00jB\xa8\xe5' ))
+
+def getFile1Bitmap():
+    return wxBitmapFromXPMData(getFile1Data())
+
+def getFile1Image():
+    return wxImageFromBitmap(getFile1Bitmap())
+
index 72003af446c8d1984c8c773a57a8b70d76671409..00fab47ec4d7261c4f3f750c11247941cd55f808 100644 (file)
@@ -33,7 +33,7 @@ class TestPanel(wxPanel):
     def OnDoPopup(self, evt):
         menu = wxMenu()
         # Make this first item bold
     def OnDoPopup(self, evt):
         menu = wxMenu()
         # Make this first item bold
-        item = wxMenuItem(menu, wxNewId(), "If supported, this is &bold")
+        item = wxMenuItem(menu, wxNewId(), "If supported, this is bold")
         df = wxSystemSettings_GetSystemFont(wxSYS_DEFAULT_GUI_FONT)
         nf = wxFont(df.GetPointSize(), df.GetFamily(), df.GetStyle(), wxBOLD,
                     false, df.GetFaceName())
         df = wxSystemSettings_GetSystemFont(wxSYS_DEFAULT_GUI_FONT)
         nf = wxFont(df.GetPointSize(), df.GetFamily(), df.GetStyle(), wxBOLD,
                     false, df.GetFaceName())
index 6dab278ed65e421cd0f266df173cb3c760875fca..27ebfe4e852c41729f08a401f4d9ff158884ebab 100644 (file)
@@ -36,5 +36,5 @@ def runTest(frame, nb, log):
 
 overview = """\
 This class provides a composite control that lets the
 
 overview = """\
 This class provides a composite control that lets the
-user easily enter list of strings.
+user easily enter and edit a list of strings.
 """
 """