From 611dc22ceee63fcfd8b6af38f7f74ba9f3c5a268 Mon Sep 17 00:00:00 2001 From: Robin Dunn Date: Fri, 30 Nov 2001 21:16:36 +0000 Subject: [PATCH] Attempted to add the SplitTree gizmo classes, but it is not working on MSW... :-( git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@12764 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- wxPython/CHANGES.txt | 2 + wxPython/contrib/gizmos/_gizmoextras.py | 7 + wxPython/contrib/gizmos/gizmos.cpp | 707 +++++++++++++++++++++++- wxPython/contrib/gizmos/gizmos.i | 156 +++++- wxPython/contrib/gizmos/gizmos.py | 98 ++++ wxPython/demo/ContextHelp.py | 2 +- wxPython/demo/Main.py | 5 +- wxPython/demo/SplitTree.py | 97 ++++ wxPython/demo/bmp_source/file1.ico | Bin 0 -> 1078 bytes wxPython/demo/bmp_source/folder1.ico | Bin 0 -> 1078 bytes wxPython/demo/bmp_source/folder2.ico | Bin 0 -> 318 bytes wxPython/demo/encode_bitmaps.py | 4 + wxPython/demo/images.py | 157 ++++++ wxPython/demo/wxCheckListBox.py | 2 +- wxPython/demo/wxEditableListBox.py | 2 +- 15 files changed, 1229 insertions(+), 10 deletions(-) create mode 100644 wxPython/demo/SplitTree.py create mode 100644 wxPython/demo/bmp_source/file1.ico create mode 100644 wxPython/demo/bmp_source/folder1.ico create mode 100644 wxPython/demo/bmp_source/folder2.ico diff --git a/wxPython/CHANGES.txt b/wxPython/CHANGES.txt index 168cee6bb5..f504f9d0f0 100644 --- a/wxPython/CHANGES.txt +++ b/wxPython/CHANGES.txt @@ -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. +Added wxEditableListBox gizmo. + diff --git a/wxPython/contrib/gizmos/_gizmoextras.py b/wxPython/contrib/gizmos/_gizmoextras.py index 43ed797c50..982d200ffc 100644 --- a/wxPython/contrib/gizmos/_gizmoextras.py +++ b/wxPython/contrib/gizmos/_gizmoextras.py @@ -3,3 +3,10 @@ wx.wxDynamicSashSplitEventPtr = wxDynamicSashSplitEventPtr wx.wxDynamicSashUnifyEventPtr = wxDynamicSashUnifyEventPtr wx.wxDynamicSashWindowPtr = wxDynamicSashWindowPtr + +wx.wxEditableListBoxPtr = wxEditableListBoxPtr + +wx.wxRemotelyScrolledTreeCtrlPtr = wxRemotelyScrolledTreeCtrlPtr +wx.wxTreeCompanionWindowPtr = wxTreeCompanionWindowPtr +wx.wxThinSplitterWindowPtr = wxThinSplitterWindowPtr +wx.wxSplitterScrolledWindowPtr = wxSplitterScrolledWindowPtr diff --git a/wxPython/contrib/gizmos/gizmos.cpp b/wxPython/contrib/gizmos/gizmos.cpp index cb9d8ac35d..7cd433e141 100644 --- a/wxPython/contrib/gizmos/gizmos.cpp +++ b/wxPython/contrib/gizmos/gizmos.cpp @@ -56,8 +56,9 @@ extern PyObject *SWIG_newvarlink(void); #define SWIG_name "gizmosc" #include "export.h" -#include "wx/gizmos/dynamicsash.h" -#include "wx/gizmos/editlbox.h" +#include +#include +#include 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 + + 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 @@ -648,7 +681,659 @@ static PyObject *_wrap_wxEditableListBox_GetStrings(PyObject *self, PyObject *ar 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[] = { + { "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 }, @@ -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}, + { "_wxPyTreeCtrl","_wxRemotelyScrolledTreeCtrl",SwigwxRemotelyScrolledTreeCtrlTowxPyTreeCtrl}, { "_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}, + { "_wxPanel","_wxSplitterScrolledWindow",SwigwxSplitterScrolledWindowTowxPanel}, { "_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}, + { "_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}, + { "_wxScrolledWindow","_wxSplitterScrolledWindow",SwigwxSplitterScrolledWindowTowxScrolledWindow}, { "_unsigned_char","_byte",0}, + { "_wxControl","_wxRemotelyScrolledTreeCtrl",SwigwxRemotelyScrolledTreeCtrlTowxControl}, { "_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}, + { "_wxEvtHandler","_wxSplitterScrolledWindow",SwigwxSplitterScrolledWindowTowxEvtHandler}, + { "_wxEvtHandler","_wxThinSplitterWindow",SwigwxThinSplitterWindowTowxEvtHandler}, + { "_wxEvtHandler","_wxPyTreeCompanionWindow",SwigwxPyTreeCompanionWindowTowxEvtHandler}, + { "_wxEvtHandler","_wxRemotelyScrolledTreeCtrl",SwigwxRemotelyScrolledTreeCtrlTowxEvtHandler}, { "_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}}; @@ -801,6 +1503,7 @@ SWIGEXPORT(void) initgizmosc() { wxClassInfo::CleanUpClasses(); wxClassInfo::InitializeClasses(); + wxPyPtrTypeMap_Add("wxTreeCompanionWindow", "wxPyTreeCompanionWindow"); { int i; for (i = 0; _swig_mapping[i].n1; i++) diff --git a/wxPython/contrib/gizmos/gizmos.i b/wxPython/contrib/gizmos/gizmos.i index 2702de80b8..e607fd129b 100644 --- a/wxPython/contrib/gizmos/gizmos.i +++ b/wxPython/contrib/gizmos/gizmos.i @@ -15,8 +15,9 @@ %{ #include "export.h" -#include "wx/gizmos/dynamicsash.h" -#include "wx/gizmos/editlbox.h" +#include +#include +#include %} //--------------------------------------------------------------------------- @@ -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 - 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 @@ -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.) - 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 @@ -165,6 +166,8 @@ public: const wxSize& size = wxDefaultSize, const char* name = "editableListBox"); + %pragma(python) addtomethod = "__init__:self._setOORInfo(self)" + 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 %{ @@ -186,6 +329,7 @@ public: wxClassInfo::CleanUpClasses(); wxClassInfo::InitializeClasses(); + wxPyPtrTypeMap_Add("wxTreeCompanionWindow", "wxPyTreeCompanionWindow"); %} @@ -195,3 +339,7 @@ public: //---------------------------------------------------------------------- + + + + diff --git a/wxPython/contrib/gizmos/gizmos.py b/wxPython/contrib/gizmos/gizmos.py index 7828ecd390..1c57d48029 100644 --- a/wxPython/contrib/gizmos/gizmos.py +++ b/wxPython/contrib/gizmos/gizmos.py @@ -123,6 +123,97 @@ class wxEditableListBox(wxEditableListBoxPtr): 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 "" % (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 "" % (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 "" % (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 "" % (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.wxEditableListBoxPtr = wxEditableListBoxPtr + +wx.wxRemotelyScrolledTreeCtrlPtr = wxRemotelyScrolledTreeCtrlPtr +wx.wxTreeCompanionWindowPtr = wxTreeCompanionWindowPtr +wx.wxThinSplitterWindowPtr = wxThinSplitterWindowPtr +wx.wxSplitterScrolledWindowPtr = wxSplitterScrolledWindowPtr diff --git a/wxPython/demo/ContextHelp.py b/wxPython/demo/ContextHelp.py index 6985790b69..d66719655c 100644 --- a/wxPython/demo/ContextHelp.py +++ b/wxPython/demo/ContextHelp.py @@ -3,7 +3,7 @@ from wxPython.wx 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() diff --git a/wxPython/demo/Main.py b/wxPython/demo/Main.py index 2b4f3eae84..a3b065e521 100644 --- a/wxPython/demo/Main.py +++ b/wxPython/demo/Main.py @@ -85,7 +85,10 @@ _treeList = [ '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 index 0000000000..ee6b5f1321 --- /dev/null +++ b/wxPython/demo/SplitTree.py @@ -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 index 0000000000000000000000000000000000000000..cc828ab4f2c896df378febb8e501332db93e4c54 GIT binary patch literal 1078 zcmeH`O%B2!6oiLr;?8mdS()BKkM@qnaa{HW_zlFwMHfw6xX>x{{^%n>1}SM$DOtv2 zlCJoiN4_NKe2^Au1>RxO5exWt8zC_iF&vgqwN|_*S|4i75#)2p=8vDg0W|PcSm#!L zfiIm0@iqdDGlQnP!xDa`^V!E|&DpTupO3!QR@&UZI-tMjuDxNrH}-nkN%m4N@aA_a FJpqxL*3JL` literal 0 HcmV?d00001 diff --git a/wxPython/demo/bmp_source/folder1.ico b/wxPython/demo/bmp_source/folder1.ico new file mode 100644 index 0000000000000000000000000000000000000000..c43de1c07cd64c30413a2c53f521d0e203198a58 GIT binary patch literal 1078 zcmeH{F%AMD5Jf+$1(o3lRA!Iiy)2xP!~?vfUP&SZtvm{`_HB2qB-9 zf(GTBYc(nu}C6AaoD0pBjeB)ZJH5J^>QMSWswUDMPn`8aB-=0Ml-AgfD*@PpCja_E+ T_r_T%*c$R5s2Azc-l_Bfjgso2 literal 0 HcmV?d00001 diff --git a/wxPython/demo/bmp_source/folder2.ico b/wxPython/demo/bmp_source/folder2.ico new file mode 100644 index 0000000000000000000000000000000000000000..98b6d3f9203d9dfca90df76cc972478ea45e33b7 GIT binary patch literal 318 zcmZ`zI}XAy41JXtGG=0C>@Bz!QigiW)~m1uiGduYM_{88gLy9vQU|d8p1-mU4AdAS z`G9c%jsQj?5+_1+Np1X#44}bmb7Y37wbHBM&ET$xpsFPLCm}aMc$HG_hB-+BW~QZt z@K$=wflJ);rH|iwpFX9@eO3P8CU9_Vw{o`K&Fv51$=cFU=>^+C`4`KX^OODuKB+QQ A&j0`b literal 0 HcmV?d00001 diff --git a/wxPython/demo/encode_bitmaps.py b/wxPython/demo/encode_bitmaps.py index aaec4e1da4..65d89dc118 100644 --- a/wxPython/demo/encode_bitmaps.py +++ b/wxPython/demo/encode_bitmaps.py @@ -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 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", + ] diff --git a/wxPython/demo/images.py b/wxPython/demo/images.py index ff15d9d7fa..90d2a5750d 100644 --- a/wxPython/demo/images.py +++ b/wxPython/demo/images.py @@ -1934,3 +1934,160 @@ def 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.: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\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()) + diff --git a/wxPython/demo/wxCheckListBox.py b/wxPython/demo/wxCheckListBox.py index 72003af446..00fab47ec4 100644 --- a/wxPython/demo/wxCheckListBox.py +++ b/wxPython/demo/wxCheckListBox.py @@ -33,7 +33,7 @@ class TestPanel(wxPanel): 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()) diff --git a/wxPython/demo/wxEditableListBox.py b/wxPython/demo/wxEditableListBox.py index 6dab278ed6..27ebfe4e85 100644 --- a/wxPython/demo/wxEditableListBox.py +++ b/wxPython/demo/wxEditableListBox.py @@ -36,5 +36,5 @@ def runTest(frame, nb, log): 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. """ -- 2.45.2