X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/dd9f7fea29e3f8bb61861f52984b7943512346ac..3eddc6bc00bcbdea23d52a8724f46ad56768f8b6:/wxPython/src/_vscroll.i diff --git a/wxPython/src/_vscroll.i b/wxPython/src/_vscroll.i index ac2dcd8b5f..512f817f0e 100644 --- a/wxPython/src/_vscroll.i +++ b/wxPython/src/_vscroll.i @@ -18,24 +18,235 @@ %{ #include +#include %} -//--------------------------------------------------------------------------- %newgroup; +//--------------------------------------------------------------------------- +// Base classes. I don't expect that these will ever be used directly from +// Python, (especially being derived from) so I own't worry about making their +// virutals overridable. They're just defined here for their public methods. + + + +// Provides all base common scroll calculations needed for either orientation, +// automatic scrollbar functionality, saved scroll positions, functionality +// for changing the target window to be scrolled, as well as defining all +// required virtual functions that need to be implemented for any orientation +// specific work. + +class wxVarScrollHelperBase +{ +public: + +// wxVarScrollHelperBase(wxWindow *winToScroll); *** ABC, can't instantiate +// virtual ~wxVarScrollHelperBase(); + + + // with physical scrolling on, the device origin is changed properly when + // a wxPaintDC is prepared, children are actually moved and laid out + // properly, and the contents of the window (pixels) are actually moved + void EnablePhysicalScrolling(bool scrolling = true); + + // wxNOT_FOUND if none, i.e. if it is below the last item + virtual int HitTest(wxCoord coord) const; + + // recalculate all our parameters and redisplay all units + virtual void RefreshAll(); + + + // get the first currently visible unit + size_t GetVisibleBegin() const; + + // get the last currently visible unit + size_t GetVisibleEnd() const; + + // is this unit currently visible? + bool IsVisible(size_t unit) const; + + // translate between scrolled and unscrolled coordinates + int CalcScrolledPosition(int coord) const; + int CalcUnscrolledPosition(int coord) const; + + // update the thumb size shown by the scrollbar + virtual void UpdateScrollbar(); + void RemoveScrollbar(); + + // Normally the wxScrolledWindow will scroll itself, but in some rare + // occasions you might want it to scroll [part of] another window (e.g. a + // child of it in order to scroll only a portion the area between the + // scrollbars (spreadsheet: only cell area will move). + virtual void SetTargetWindow(wxWindow *target); + virtual wxWindow *GetTargetWindow() const; + + + // these functions must be overidden in the derived class to return + // orientation specific data (e.g. the width for vertically scrolling + // derivatives in the case of GetOrientationTargetSize()) + virtual int GetOrientationTargetSize() const; // = 0; + virtual int GetNonOrientationTargetSize() const; // = 0; + virtual wxOrientation GetOrientation() const; // = 0; +}; + + + + + +// Provides public API functions targeted for vertical-specific scrolling, +// wrapping the functionality of wxVarScrollHelperBase. + +class wxVarVScrollHelper : public wxVarScrollHelperBase +{ +public: + +// wxVarVScrollHelper(wxWindow *winToScroll); *** ABC, can't instantiate + + void SetRowCount(size_t rowCount); + bool ScrollToRow(size_t row); + + virtual bool ScrollRows(int rows); + virtual bool ScrollRowPages(int pages); + + virtual void RefreshRow(size_t row); + virtual void RefreshRows(size_t from, size_t to); + + virtual int HitTest(wxCoord y) const; + + + size_t GetRowCount() const; + size_t GetVisibleRowsBegin() const; + size_t GetVisibleRowsEnd() const; + bool IsRowVisible(size_t row) const; + + virtual int GetOrientationTargetSize() const; + virtual int GetNonOrientationTargetSize() const; + virtual wxOrientation GetOrientation() const; +}; + + + + + +// Provides public API functions targeted for horizontal-specific scrolling, +// wrapping the functionality of wxVarScrollHelperBase. + +class wxVarHScrollHelper : public wxVarScrollHelperBase +{ +public: + +// wxVarHScrollHelper(wxWindow *winToScroll) *** ABC, can't instantiate + + void SetColumnCount(size_t columnCount); + + bool ScrollToColumn(size_t column); + virtual bool ScrollColumns(int columns); + virtual bool ScrollColumnPages(int pages); + + virtual void RefreshColumn(size_t column); + virtual void RefreshColumns(size_t from, size_t to); + virtual int HitTest(wxCoord x) const; + + + size_t GetColumnCount() const; + size_t GetVisibleColumnsBegin() const; + size_t GetVisibleColumnsEnd() const; + bool IsColumnVisible(size_t column) const; + + + virtual int GetOrientationTargetSize() const; + virtual int GetNonOrientationTargetSize() const; + virtual wxOrientation GetOrientation() const; + +}; + + + + +// Provides public API functions targeted at functions with similar names in +// both wxVScrollHelper and wxHScrollHelper so class scope doesn't need to be +// specified (since we are using multiple inheritance). It also provides +// functions to make changing values for both orientations at the same time +// easier. + +class wxVarHVScrollHelper : public wxVarVScrollHelper, + public wxVarHScrollHelper +{ +public: + +// wxVarHVScrollHelper(wxWindow *winToScroll); *** ABC, can't instantiate + + + // set the number of units the window contains for each axis: the derived + // class must provide the widths and heights for all units with indices up + // to each of the one given here in its OnGetColumnWidth() and + // OnGetRowHeight() + void SetRowColumnCount(size_t rowCount, size_t columnCount); + + + // with physical scrolling on, the device origin is changed properly when + // a wxPaintDC is prepared, children are actually moved and laid out + // properly, and the contents of the window (pixels) are actually moved + void EnablePhysicalScrolling(bool vscrolling = true, bool hscrolling = true); + + + // scroll to the specified row/column: it will become the first visible + // cell in the window + // + // return true if we scrolled the window, false if nothing was done +// bool ScrollToRowColumn(size_t row, size_t column); + bool ScrollToRowColumn(const wxPosition &pos); + + // redraw the specified cell +// virtual void RefreshRowColumn(size_t row, size_t column); + virtual void RefreshRowColumn(const wxPosition &pos); + + // redraw the specified regions (inclusive). If the target window for + // both orientations is the same the rectangle of cells is refreshed; if + // the target windows differ the entire client size opposite the + // orientation direction is refreshed between the specified limits +// virtual void RefreshRowsColumns(size_t fromRow, size_t toRow, +// size_t fromColumn, size_t toColumn); + virtual void RefreshRowsColumns(const wxPosition& from, + const wxPosition& to); + + // Override wxPanel::HitTest to use our version +// virtual wxPosition HitTest(wxCoord x, wxCoord y) const; + virtual wxPosition HitTest(const wxPoint &pos) const; + + // replacement implementation of wxWindow::Layout virtual method. To + // properly forward calls to wxWindow::Layout use + // WX_FORWARD_TO_SCROLL_HELPER() derived class. We use this version to + // call both base classes' ScrollLayout() + bool ScrollLayout(); + + // get the number of units this window contains (previously set by + // Set[Column/Row/RowColumn/Unit]Count()) + wxSize GetRowColumnCount() const; + + // get the first currently visible units + wxPosition GetVisibleBegin() const; + wxPosition GetVisibleEnd() const; + + // is this cell currently visible? +// bool IsVisible(size_t row, size_t column) const; + bool IsVisible(const wxPosition &pos) const; +}; + + + + +//--------------------------------------------------------------------------- // wxVScrolledWindow -%{ -#include -%} -// First, the C++ version +// First, the C++ version that can redirect to overridden Python methods %{ class wxPyVScrolledWindow : public wxVScrolledWindow { - DECLARE_ABSTRACT_CLASS(wxPyVScrolledWindow); + DECLARE_ABSTRACT_CLASS(wxPyVScrolledWindow) public: wxPyVScrolledWindow() : wxVScrolledWindow() {} @@ -52,24 +263,24 @@ public: // this function must be overridden in the derived class and it should // return the height of the given line in pixels - DEC_PYCALLBACK_COORD_SIZET_constpure(OnGetLineHeight); - + DEC_PYCALLBACK_COORD_SIZET_constpure(OnGetRowHeight); + DEC_PYCALLBACK_COORD_SIZET_constpure(OnGetLineHeight); // old name // this function doesn't have to be overridden but it may be useful to do // it if calculating the lines heights is a relatively expensive operation // as it gives the user code a possibility to calculate several of them at // once // - // OnGetLinesHint() is normally called just before OnGetLineHeight() but you + // OnGetLinesHint() is normally called just before OnGetRowHeight() but you // shouldn't rely on the latter being called for all lines in the interval - // specified here. It is also possible that OnGetLineHeight() will be + // specified here. It is also possible that OnGetRowHeight() will be // called for the lines outside of this interval, so this is really just a // hint, not a promise. // // finally note that lineMin is inclusive, while lineMax is exclusive, as // usual - DEC_PYCALLBACK_VOID_SIZETSIZET_const(OnGetLinesHint); - + DEC_PYCALLBACK_VOID_SIZETSIZET_const(OnGetRowsHeightHint); + DEC_PYCALLBACK_VOID_SIZETSIZET_const(OnGetLinesHint); // old name // when the number of lines changes, we try to estimate the total height // of all lines which is a rather expensive operation in terms of lines @@ -85,15 +296,10 @@ public: // Also expose some other interesting protected methods - // find the index of the line we need to show at the top of the window such - // that the last (fully or partially) visible line is the given one - size_t FindFirstFromBottom(size_t lineLast, bool fullyVisible = False) - { return wxVScrolledWindow::FindFirstFromBottom(lineLast, fullyVisible); } - // get the total height of the lines between lineMin (inclusive) and // lineMax (exclusive) - wxCoord GetLinesHeight(size_t lineMin, size_t lineMax) const - { return wxVScrolledWindow::GetLinesHeight(lineMin, lineMax); } + wxCoord GetRowsHeight(size_t lineMin, size_t lineMax) const + { return wxVScrolledWindow::GetRowsHeight(lineMin, lineMax); } PYPRIVATE; @@ -101,13 +307,18 @@ public: IMPLEMENT_ABSTRACT_CLASS(wxPyVScrolledWindow, wxVScrolledWindow); +IMP_PYCALLBACK_COORD_SIZET_constpure(wxPyVScrolledWindow, wxVScrolledWindow, OnGetRowHeight); IMP_PYCALLBACK_COORD_SIZET_constpure(wxPyVScrolledWindow, wxVScrolledWindow, OnGetLineHeight); +IMP_PYCALLBACK_VOID_SIZETSIZET_const(wxPyVScrolledWindow, wxVScrolledWindow, OnGetRowsHeightHint); IMP_PYCALLBACK_VOID_SIZETSIZET_const(wxPyVScrolledWindow, wxVScrolledWindow, OnGetLinesHint); + IMP_PYCALLBACK_COORD_const (wxPyVScrolledWindow, wxVScrolledWindow, EstimateTotalHeight); %} + + // Now define this class for SWIG /* @@ -125,11 +336,16 @@ IMP_PYCALLBACK_COORD_const (wxPyVScrolledWindow, wxVScrolledWindow, Est of the window and not its entire client area. */ -%name(VScrolledWindow) class wxPyVScrolledWindow : public wxPanel +MustHaveApp(wxPyVScrolledWindow); + +%rename(VScrolledWindow) wxPyVScrolledWindow; + +class wxPyVScrolledWindow : public wxPanel, + public wxVarVScrollHelper { public: - %addtofunc wxPyVScrolledWindow "self._setOORInfo(self); self._setCallbackInfo(self, VScrolledWindow)" - %addtofunc wxPyVScrolledWindow() "" + %pythonAppend wxPyVScrolledWindow "self._setOORInfo(self);" setCallbackInfo(VScrolledWindow) + %pythonAppend wxPyVScrolledWindow() "" wxPyVScrolledWindow(wxWindow *parent, @@ -139,7 +355,7 @@ public: long style = 0, const wxString& name = wxPyPanelNameStr); - %name(PreVScrolledWindow)wxPyVScrolledWindow(); + %RenameCtor(PreVScrolledWindow, wxPyVScrolledWindow()); void _setCallbackInfo(PyObject* self, PyObject* _class); @@ -151,65 +367,273 @@ public: const wxString& name = wxPyPanelNameStr); - // set the number of lines the window contains: the derived class must - // provide the heights for all lines with indices up to the one given here - // in its OnGetLineHeight() - void SetLineCount(size_t count); + // get the total height of the lines between lineMin (inclusive) and + // lineMax (exclusive) + wxCoord GetRowsHeight(size_t lineMin, size_t lineMax) const; + %pythoncode { GetLinesHeight = wx._deprecated(GetRowsHeight, + "Use GetRowsHeight instead.") } + + virtual wxCoord EstimateTotalHeight() const; - // scroll to the specified line: it will become the first visible line in - // the window - // - // return True if we scrolled the window, False if nothing was done - bool ScrollToLine(size_t line); + int HitTest(const wxPoint& pt) const; - // scroll by the specified number of lines/pages - virtual bool ScrollLines(int lines); - virtual bool ScrollPages(int pages); + + // Deprecated wrappers for methods whose name changed when adding the H + // classes. I just put them here instead of wrapping the + // wxVarVScrollLegacyAdaptor class. + %pythoncode { + def GetFirstVisibleLine(self): + return self.GetVisibleRowsBegin() + GetFirstVisibleLine = wx._deprecated(GetFirstVisibleLine, "Use GetVisibleRowsBegin instead" ) + + def GetLastVisibleLine(self): + return self.GetVisibleRowsEnd() - 1 + GetLastVisibleLine = wx._deprecated(GetLastVisibleLine, "Use GetVisibleRowsEnd instead") + + def GetLineCount(self): + return self.GetRowCount() + GetLineCount = wx._deprecated(GetLineCount, "Use GetRowCount instead") + + def SetLineCount(self, count): + self.SetRowCount(count) + SetLineCount = wx._deprecated(SetLineCount, "Use SetRowCount instead") + + def RefreshLine(self, line): + self.RefreshRow(line) + RefreshLine = wx._deprecated(RefreshLine, "Use RefreshRow instead") + + def RefreshLines(self, frm, to): + self.RefreshRows(frm, to) + RefreshLines = wx._deprecated(RefreshLines, "Use RefreshRows instead") + + def ScrollToLine(self, line): + return self.ScrollToRow(line) + ScrollToLine = wx._deprecated(ScrollToLine, "Use RefreshRow instead") + + def ScrollLines(self, lines): + return self.ScrollRows(lines) + ScrollLines = wx._deprecated(ScrollLines, "Use ScrollRows instead") + + def ScrollPages(self, pages): + return self.ScrollRowPages(pages) + ScrollPages = wx._deprecated(ScrollPages, "Use ScrollRowPages instead") + } + +}; - // redraw the specified line - void RefreshLine(size_t line); - // redraw all lines in the specified range (inclusive) - void RefreshLines(size_t from, size_t to); - // return the item at the specified (in physical coordinates) position or - // wxNOT_FOUND if none, i.e. if it is below the last item - %name(HitTestXT) int HitTest(wxCoord x, wxCoord y) const; +//--------------------------------------------------------------------------- +// wxHScrolledWindow + + +// First, the C++ version that can redirect to overridden Python methods +%{ +class wxPyHScrolledWindow : public wxHScrolledWindow +{ + DECLARE_ABSTRACT_CLASS(wxPyHScrolledWindow) +public: + wxPyHScrolledWindow() : wxHScrolledWindow() {} + + wxPyHScrolledWindow(wxWindow *parent, + wxWindowID id = wxID_ANY, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = 0, + const wxString& name = wxPyPanelNameStr) + : wxHScrolledWindow(parent, id, pos, size, style, name) + {} + + // Overridable virtuals + DEC_PYCALLBACK_COORD_SIZET_constpure(OnGetColumnWidth); + DEC_PYCALLBACK_VOID_SIZETSIZET_const(OnGetColumnsWidthHint); + DEC_PYCALLBACK_COORD_const(EstimateTotalWidth); + + wxCoord GetColumnsWidth(size_t columnMin, size_t columnMax) const + { return wxHScrolledWindow::GetColumnsWidth(columnMin, columnMax); } + + PYPRIVATE; +}; + +IMPLEMENT_ABSTRACT_CLASS(wxPyHScrolledWindow, wxHScrolledWindow); + +IMP_PYCALLBACK_COORD_SIZET_constpure(wxPyHScrolledWindow, wxHScrolledWindow, OnGetColumnWidth); +IMP_PYCALLBACK_VOID_SIZETSIZET_const(wxPyHScrolledWindow, wxHScrolledWindow, OnGetColumnsWidthHint); +IMP_PYCALLBACK_COORD_const (wxPyHScrolledWindow, wxHScrolledWindow, EstimateTotalWidth); + +%} + + + +// Now define this class for SWIG + +// In the name of this class, "H" stands for "horizontal" because it can be +// used for scrolling columns of variable widths. It is not necessary to know +// the widths of all columns in advance -- only those which are shown on the +// screen need to be measured. + +// This is a generalization of the wxScrolledWindow class which can be only +// used when all columns have the same width. It lacks some other +// wxScrolledWindow features however, notably it can't scroll only a rectangle +// of the window and not its entire client area. + +MustHaveApp(wxPyHScrolledWindow); + +%rename(HScrolledWindow) wxPyHScrolledWindow; + +class wxPyHScrolledWindow : public wxPanel, + public wxVarHScrollHelper +{ +public: + %pythonAppend wxPyHScrolledWindow "self._setOORInfo(self);" setCallbackInfo(HScrolledWindow) + %pythonAppend wxPyHScrolledWindow() "" + + + wxPyHScrolledWindow(wxWindow *parent, + wxWindowID id = wxID_ANY, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = 0, + const wxString& name = wxPyPanelNameStr); + + %RenameCtor(PreHScrolledWindow, wxPyHScrolledWindow()); + + void _setCallbackInfo(PyObject* self, PyObject* _class); + + bool Create(wxWindow *parent, + wxWindowID id = wxID_ANY, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = 0, + const wxString& name = wxPyPanelNameStr); + + int HitTest(const wxPoint& pt) const; + wxCoord GetColumnsWidth(size_t columnMin, size_t columnMax) const; + wxCoord EstimateTotalWidth() const; +}; + + + +//--------------------------------------------------------------------------- +// wxHVScrolledWindow - // recalculate all our parameters and redisplay all lines - virtual void RefreshAll(); - // get the number of lines this window contains (previously set by - // SetLineCount()) - size_t GetLineCount() const; +// First, the C++ version that can redirect to overridden Python methods +%{ +class wxPyHVScrolledWindow : public wxHVScrolledWindow +{ + DECLARE_ABSTRACT_CLASS(wxPyHScrolledWindow) +public: + wxPyHVScrolledWindow() : wxHVScrolledWindow() {} + + wxPyHVScrolledWindow(wxWindow *parent, + wxWindowID id = wxID_ANY, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = 0, + const wxString& name = wxPyPanelNameStr) + : wxHVScrolledWindow(parent, id, pos, size, style, name) + {} + + // Overridable virtuals + DEC_PYCALLBACK_COORD_SIZET_constpure(OnGetRowHeight); + DEC_PYCALLBACK_VOID_SIZETSIZET_const(OnGetRowsHeightHint); + DEC_PYCALLBACK_COORD_const(EstimateTotalHeight); - // get the first currently visible line - size_t GetFirstVisibleLine() const; + DEC_PYCALLBACK_COORD_SIZET_constpure(OnGetColumnWidth); + DEC_PYCALLBACK_VOID_SIZETSIZET_const(OnGetColumnsWidthHint); + DEC_PYCALLBACK_COORD_const(EstimateTotalWidth); - // get the last currently visible line - size_t GetLastVisibleLine() const; + wxCoord GetRowsHeight(size_t lineMin, size_t lineMax) const + { return wxHVScrolledWindow::GetRowsHeight(lineMin, lineMax); } - // is this line currently visible? - bool IsVisible(size_t line) const; + wxCoord GetColumnsWidth(size_t columnMin, size_t columnMax) const + { return wxHVScrolledWindow::GetColumnsWidth(columnMin, columnMax); } + PYPRIVATE; }; +IMPLEMENT_ABSTRACT_CLASS(wxPyHVScrolledWindow, wxHVScrolledWindow); + +IMP_PYCALLBACK_COORD_SIZET_constpure(wxPyHVScrolledWindow, wxHVScrolledWindow, OnGetRowHeight); +IMP_PYCALLBACK_VOID_SIZETSIZET_const(wxPyHVScrolledWindow, wxHVScrolledWindow, OnGetRowsHeightHint); +IMP_PYCALLBACK_COORD_const (wxPyHVScrolledWindow, wxHVScrolledWindow, EstimateTotalHeight); + +IMP_PYCALLBACK_COORD_SIZET_constpure(wxPyHVScrolledWindow, wxHVScrolledWindow, OnGetColumnWidth); +IMP_PYCALLBACK_VOID_SIZETSIZET_const(wxPyHVScrolledWindow, wxHVScrolledWindow, OnGetColumnsWidthHint); +IMP_PYCALLBACK_COORD_const (wxPyHVScrolledWindow, wxHVScrolledWindow, EstimateTotalWidth); + +%} + + + + +// Now define this class for SWIG + +// This window inherits all functionality of both vertical and horizontal +// scrolled windows automatically handling everything needed to scroll both +// axis simultaneously. + +MustHaveApp(wxPyHVScrolledWindow); + +%rename(HVScrolledWindow) wxPyHVScrolledWindow; + +class wxPyHVScrolledWindow : public wxPanel, + public wxVarHVScrollHelper +{ +public: + %pythonAppend wxPyHVScrolledWindow "self._setOORInfo(self);" setCallbackInfo(HVScrolledWindow) + %pythonAppend wxPyHVScrolledWindow() "" + + + wxPyHVScrolledWindow(wxWindow *parent, + wxWindowID id = wxID_ANY, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = 0, + const wxString& name = wxPyPanelNameStr); + + %RenameCtor(PreHVScrolledWindow, wxPyHVScrolledWindow()); + + void _setCallbackInfo(PyObject* self, PyObject* _class); + + bool Create(wxWindow *parent, + wxWindowID id = wxID_ANY, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = 0, + const wxString& name = wxPyPanelNameStr); + + + wxPosition HitTest(const wxPoint& pt) const; + + wxCoord GetRowsHeight(size_t lineMin, size_t lineMax) const; + wxCoord EstimateTotalHeight() const; + + wxCoord GetColumnsWidth(size_t columnMin, size_t columnMax) const; + wxCoord EstimateTotalWidth() const; +}; + + + +//--------------------------------------------------------------------------- //--------------------------------------------------------------------------- // wxVListBox %{ #include -DECLARE_DEF_STRING(VListBoxNameStr); %} +MAKE_CONST_WXSTRING(VListBoxNameStr); + // First, the C++ version %{ class wxPyVListBox : public wxVListBox { - DECLARE_ABSTRACT_CLASS(wxPyVListBox); + DECLARE_ABSTRACT_CLASS(wxPyVListBox) public: wxPyVListBox() : wxVListBox() {} @@ -242,7 +666,7 @@ public: // // the base class version doesn't do anything // virtual void OnDrawSeparator(wxDC& dc, wxRect& rect, size_t n) const; - DEC_PYCALLBACK__DCRECTSIZET_constpure(OnDrawSeparator); + DEC_PYCALLBACK__DCRECTSIZET2_const(OnDrawSeparator); // this method is used to draw the items background and, maybe, a border @@ -263,7 +687,7 @@ IMPLEMENT_ABSTRACT_CLASS(wxPyVListBox, wxVListBox); IMP_PYCALLBACK__DCRECTSIZET_constpure(wxPyVListBox, wxVListBox, OnDrawItem); IMP_PYCALLBACK_COORD_SIZET_constpure (wxPyVListBox, wxVListBox, OnMeasureItem); -IMP_PYCALLBACK__DCRECTSIZET_constpure(wxPyVListBox, wxVListBox, OnDrawSeparator); +IMP_PYCALLBACK__DCRECTSIZET2_const (wxPyVListBox, wxVListBox, OnDrawSeparator); IMP_PYCALLBACK__DCRECTSIZET_const (wxPyVListBox, wxVListBox, OnDrawBackground); %} @@ -281,11 +705,14 @@ IMP_PYCALLBACK__DCRECTSIZET_const (wxPyVListBox, wxVListBox, OnDrawBackground It emits the same events as wxListBox and the same event macros may be used with it. */ -%name(VListBox) class wxPyVListBox : public wxPyVScrolledWindow +MustHaveApp(wxPyVListBox); + +%rename(VListBox) wxPyVListBox; +class wxPyVListBox : public wxPyVScrolledWindow { public: - %addtofunc wxPyVListBox "self._setOORInfo(self);self._setCallbackInfo(self, VListBox)" - %addtofunc wxPyVListBox() "" + %pythonAppend wxPyVListBox "self._setOORInfo(self);" setCallbackInfo(VListBox) + %pythonAppend wxPyVListBox() "" wxPyVListBox(wxWindow *parent, @@ -295,7 +722,7 @@ public: long style = 0, const wxString& name = wxPyVListBoxNameStr); - %name(PreVListBox) wxPyVListBox(); + %RenameCtor(PreVListBox, wxPyVListBox()); void _setCallbackInfo(PyObject* self, PyObject* _class); @@ -328,22 +755,44 @@ public: // this method is valid for both single and multi selection listboxes size_t GetSelectedCount() const; - // get the first selected item, returns wxNOT_FOUND if none - // - // cookie is an opaque parameter which should be passed to - // GetNextSelected() later - // - // this method is only valid for the multi selection listboxes - int GetFirstSelected(unsigned long& cookie) const; - - // get next selection item, return wxNOT_FOUND if no more - // - // cookie must be the same parameter that was passed to GetFirstSelected() - // before - // - // this method is only valid for the multi selection listboxes - int GetNextSelected(unsigned long& cookie) const; + %extend { + // get the first selected item, returns wxNOT_FOUND if none + // + // cookie is an opaque parameter which should be passed to + // GetNextSelected() later + // + // this method is only valid for the multi selection listboxes + //int GetFirstSelected(unsigned long& cookie) const; + PyObject* GetFirstSelected() { + unsigned long cookie = 0; + int selected = self->GetFirstSelected(cookie); + wxPyBlock_t blocked = wxPyBeginBlockThreads(); + PyObject* tup = PyTuple_New(2); + PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(selected)); + PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(cookie)); + wxPyEndBlockThreads(blocked); + return tup; + } + + // get next selection item, return wxNOT_FOUND if no more + // + // cookie must be the same parameter that was passed to GetFirstSelected() + // before + // + // this method is only valid for the multi selection listboxes + // int GetNextSelected(unsigned long& cookie) const; + PyObject* GetNextSelected(unsigned long cookie) { + int selected = self->GetNextSelected(cookie); + wxPyBlock_t blocked = wxPyBeginBlockThreads(); + PyObject* tup = PyTuple_New(2); + PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(selected)); + PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(cookie)); + wxPyEndBlockThreads(blocked); + return tup; + } + } + // get the margins around each item wxPoint GetMargins() const; @@ -372,7 +821,7 @@ public: // otherwise // // this function is only valid for the multiple selection listboxes - bool Select(size_t item, bool select = True); + bool Select(size_t item, bool select = true); // selects the items in the specified range whose end points may be given // in any order @@ -404,11 +853,23 @@ public: // // by default both margins are 0 void SetMargins(const wxPoint& pt); - %name(SetMarginsXY) void SetMargins(wxCoord x, wxCoord y); + %Rename(SetMarginsXY, void, SetMargins(wxCoord x, wxCoord y)); // change the background colour of the selected cells void SetSelectionBackground(const wxColour& col); + // refreshes only the selected items + void RefreshSelected(); + + virtual void OnDrawSeparator(wxDC& dc, wxRect& rect, size_t n) const; + virtual void OnDrawBackground(wxDC& dc, const wxRect& rect, size_t n) const; + + %property(FirstSelected, GetFirstSelected, doc="See `GetFirstSelected`"); + %property(ItemCount, GetItemCount, SetItemCount, doc="See `GetItemCount` and `SetItemCount`"); + %property(Margins, GetMargins, SetMargins, doc="See `GetMargins` and `SetMargins`"); + %property(SelectedCount, GetSelectedCount, doc="See `GetSelectedCount`"); + %property(Selection, GetSelection, SetSelection, doc="See `GetSelection` and `SetSelection`"); + %property(SelectionBackground, GetSelectionBackground, SetSelectionBackground, doc="See `GetSelectionBackground` and `SetSelectionBackground`"); }; @@ -423,7 +884,7 @@ public: %{ class wxPyHtmlListBox : public wxHtmlListBox { - DECLARE_ABSTRACT_CLASS(wxPyHtmlListBox); + DECLARE_ABSTRACT_CLASS(wxPyHtmlListBox) public: wxPyHtmlListBox() : wxHtmlListBox() {} @@ -445,6 +906,10 @@ public: // this function may be overridden to decorate HTML returned by OnGetItem() DEC_PYCALLBACK_STRING_SIZET(OnGetItemMarkup); + // These are from wxVListBox + DEC_PYCALLBACK__DCRECTSIZET2_const(OnDrawSeparator); + DEC_PYCALLBACK__DCRECTSIZET_const(OnDrawBackground); + // TODO: // // this method allows to customize the selection appearance: it may be used // // to specify the colour of the text which normally has the given colour @@ -459,6 +924,11 @@ public: // // globally using SetSelectionBackground() // virtual wxColour GetSelectedTextBgColour(const wxColour& colBg) const; + + // This method may be overriden to handle clicking on a link in + // the listbox. By default, clicking links is ignored. + virtual void OnLinkClicked(size_t n, + const wxHtmlLinkInfo& link); PYPRIVATE; }; @@ -468,7 +938,24 @@ IMPLEMENT_ABSTRACT_CLASS(wxPyHtmlListBox, wxHtmlListBox) IMP_PYCALLBACK_STRING_SIZET_pure(wxPyHtmlListBox, wxHtmlListBox, OnGetItem); IMP_PYCALLBACK_STRING_SIZET (wxPyHtmlListBox, wxHtmlListBox, OnGetItemMarkup); - +IMP_PYCALLBACK__DCRECTSIZET2_const (wxPyHtmlListBox, wxHtmlListBox, OnDrawSeparator); +IMP_PYCALLBACK__DCRECTSIZET_const (wxPyHtmlListBox, wxHtmlListBox, OnDrawBackground); + + +void wxPyHtmlListBox::OnLinkClicked(size_t n, + const wxHtmlLinkInfo& link) { + bool found; + wxPyBlock_t blocked = wxPyBeginBlockThreads(); + if ((found = wxPyCBH_findCallback(m_myInst, "OnLinkClicked"))) { + PyObject* obj = wxPyConstructObject((void*)&link, wxT("wxHtmlLinkInfo"), 0); + wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iO)", n, obj)); + Py_DECREF(obj); + } + wxPyEndBlockThreads(blocked); + if (! found) + wxPyHtmlListBox::OnLinkClicked(n, link); +} + %} @@ -477,11 +964,13 @@ IMP_PYCALLBACK_STRING_SIZET (wxPyHtmlListBox, wxHtmlListBox, OnGetItemMarkup // wxHtmlListBox is a listbox whose items are wxHtmlCells -%name(HtmlListBox) class wxPyHtmlListBox : public wxPyVListBox +MustHaveApp(wxPyHtmlListBox); +%rename(HtmlListBox) wxPyHtmlListBox; +class wxPyHtmlListBox : public wxPyVListBox { public: - %addtofunc wxPyHtmlListBox "self._setOORInfo(self);self._setCallbackInfo(self, HtmlListBox)" - %addtofunc wxPyHtmlListBox() "" + %pythonAppend wxPyHtmlListBox "self._setOORInfo(self);" setCallbackInfo(HtmlListBox) + %pythonAppend wxPyHtmlListBox() "" // normal constructor which calls Create() internally @@ -492,7 +981,7 @@ public: long style = 0, const wxString& name = wxPyVListBoxNameStr); - %name(PreHtmlListBox) wxPyHtmlListBox(); + %RenameCtor(PreHtmlListBox, wxPyHtmlListBox()); void _setCallbackInfo(PyObject* self, PyObject* _class); @@ -507,9 +996,58 @@ public: void RefreshAll(); void SetItemCount(size_t count); + // retrieve the file system used by the wxHtmlWinParser: if you use + // relative paths in your HTML, you should use its ChangePathTo() method + wxFileSystem& GetFileSystem(); + + void OnLinkClicked(size_t n, const wxHtmlLinkInfo& link); + + %property(FileSystem, GetFileSystem, doc="See `GetFileSystem`"); +}; + + + +//--------------------------------------------------------------------------- + +%{ + const wxArrayString wxPyEmptyStringArray; +%} +MAKE_CONST_WXSTRING(SimpleHtmlListBoxNameStr); + + +enum { + wxHLB_DEFAULT_STYLE, + wxHLB_MULTIPLE }; +MustHaveApp(wxSimpleHtmlListBox); +class wxSimpleHtmlListBox : public wxPyHtmlListBox, + public wxItemContainer +{ +public: + %pythonAppend wxSimpleHtmlListBox "self._setOORInfo(self)"; + %pythonAppend wxSimpleHtmlListBox() ""; + + wxSimpleHtmlListBox(wxWindow *parent, + wxWindowID id = -1, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + const wxArrayString& choices = wxPyEmptyStringArray, + long style = wxHLB_DEFAULT_STYLE, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxPySimpleHtmlListBoxNameStr); + %RenameCtor(PreSimpleHtmlListBox, wxSimpleHtmlListBox()); + + bool Create(wxWindow *parent, + wxWindowID id = -1, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size= wxDefaultSize, + const wxArrayString& choices = wxPyEmptyStringArray, + long style = wxHLB_DEFAULT_STYLE, + const wxValidator& validator = wxDefaultValidator, + const wxString& name = wxPySimpleHtmlListBoxNameStr); +}; //---------------------------------------------------------------------------