X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/a72f4631fe5ab7ebeefdacf8ec9c826ea962133f..bc50a2ae95f2ab36b16ceedc7902a9cbfb2f70ea:/wxPython/src/_vscroll.i diff --git a/wxPython/src/_vscroll.i b/wxPython/src/_vscroll.i index 7a9b32dba6..5d387f1244 100644 --- a/wxPython/src/_vscroll.i +++ b/wxPython/src/_vscroll.i @@ -35,7 +35,7 @@ %{ class wxPyVScrolledWindow : public wxVScrolledWindow { - DECLARE_ABSTRACT_CLASS(wxPyVScrolledWindow); + DECLARE_ABSTRACT_CLASS(wxPyVScrolledWindow) public: wxPyVScrolledWindow() : wxVScrolledWindow() {} @@ -127,7 +127,8 @@ IMP_PYCALLBACK_COORD_const (wxPyVScrolledWindow, wxVScrolledWindow, Est MustHaveApp(wxPyVScrolledWindow); -%name(VScrolledWindow) class wxPyVScrolledWindow : public wxPanel +%rename(VScrolledWindow) wxPyVScrolledWindow; +class wxPyVScrolledWindow : public wxPanel { public: %pythonAppend wxPyVScrolledWindow "self._setOORInfo(self); self._setCallbackInfo(self, VScrolledWindow)" @@ -141,7 +142,7 @@ public: long style = 0, const wxString& name = wxPyPanelNameStr); - %name(PreVScrolledWindow)wxPyVScrolledWindow(); + %RenameCtor(PreVScrolledWindow, wxPyVScrolledWindow()); void _setCallbackInfo(PyObject* self, PyObject* _class); @@ -176,7 +177,7 @@ public: // 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(HitTestXY) int HitTest(wxCoord x, wxCoord y) const; + %Rename(HitTestXY, int, HitTest(wxCoord x, wxCoord y) const); int HitTest(const wxPoint& pt) const; // recalculate all our parameters and redisplay all lines @@ -188,16 +189,287 @@ public: size_t GetLineCount() const; // get the first currently visible line - size_t GetFirstVisibleLine() const; + size_t GetVisibleBegin() const; // get the last currently visible line - size_t GetLastVisibleLine() const; + size_t GetVisibleEnd() const; // is this line currently visible? bool IsVisible(size_t line) const; + // this is the same as GetVisibleBegin(), exists to match + // GetLastVisibleLine() and for backwards compatibility only + size_t GetFirstVisibleLine() const; + + // get the last currently visible line + // + // this function is unsafe as it returns (size_t)-1 (i.e. a huge positive + // number) if the control is empty, use GetVisibleEnd() instead, this one + // is kept for backwards compatibility + size_t GetLastVisibleLine() const; + + // 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); + + // get the total height of the lines between lineMin (inclusive) and + // lineMax (exclusive) + wxCoord GetLinesHeight(size_t lineMin, size_t lineMax) const; }; + + +// //---------------------------------------------------------------------------- +// %newgroup; + +// // wxHVScrolledWindow + +// // First, the C++ version +// %{ +// class wxPyHVScrolledWindow : public wxHVScrolledWindow +// { +// DECLARE_ABSTRACT_CLASS(wxPyHVScrolledWindow) +// 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 + +// // these functions must be overridden in the derived class and they should +// // return the width or height of the given line in pixels +// DEC_PYCALLBACK_COORD_SIZET_constpure(OnGetRowHeight); +// DEC_PYCALLBACK_COORD_SIZET_constpure(OnGetColumnWidth); + +// // the following functions don't need to be overridden but it may be useful +// // to do if calculating the lines widths or heights is a relatively +// // expensive operation as it gives the user code a possibility to calculate +// // several of them at once +// // +// // OnGetRowsHeightHint() and OnGetColumnsWidthHint() are normally called +// // just before OnGetRowHeight() and OnGetColumnWidth(), respectively, but +// // you shouldn't rely on the latter methods being called for all lines in +// // the interval specified here. It is also possible that OnGetRowHeight() +// // or OnGetColumnWidth() will be called for the lines outside of this +// // interval, so this is really just a hint, not a promise. +// // +// // finally note that min is inclusive, while max is exclusive, as usual +// DEC_PYCALLBACK_VOID_SIZETSIZET_const(OnGetRowsHeightHint); +// DEC_PYCALLBACK_VOID_SIZETSIZET_const(OnGetColumnsWidthHint); + +// // when the number of lines changes, we try to estimate the total width or +// // height of all lines which is a rather expensive operation in terms of +// // lines access, so if the user code may estimate the average height +// // better/faster than we do, it should override this function to implement +// // its own logic +// // +// // this function should return the best guess for the total height it may +// // make +// DEC_PYCALLBACK_COORD_const(EstimateTotalHeight); +// DEC_PYCALLBACK_COORD_const(EstimateTotalWidth); + + +// // Also expose some other interesting protected methods + +// // find the index of the horizontal 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 FindFirstFromRight(size_t columnLast, bool fullyVisible = false) +// { return wxHVScrolledWindow::FindFirstFromRight(columnLast, fullyVisible); } + +// // find the index of the vertical 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 wxHVScrolledWindow::FindFirstFromBottom(lineLast, fullyVisible); } + + +// // get the total width or height of the lines between lineMin (inclusive) +// // and lineMax (exclusive) +// wxCoord GetRowsHeight(size_t lineMin, size_t lineMax) const +// { return wxHVScrolledWindow::GetRowsHeight(lineMin, lineMax); } +// 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_COORD_SIZET_constpure(wxPyHVScrolledWindow, wxHVScrolledWindow, OnGetColumnWidth); +// IMP_PYCALLBACK_VOID_SIZETSIZET_const(wxPyHVScrolledWindow, wxHVScrolledWindow, OnGetRowsHeightHint); +// IMP_PYCALLBACK_VOID_SIZETSIZET_const(wxPyHVScrolledWindow, wxHVScrolledWindow, OnGetColumnsWidthHint); +// IMP_PYCALLBACK_COORD_const (wxPyHVScrolledWindow, wxHVScrolledWindow, EstimateTotalHeight); +// IMP_PYCALLBACK_COORD_const (wxPyHVScrolledWindow, wxHVScrolledWindow, EstimateTotalWidth); +// %} + + + + +// // Now define this class for SWIG + +// /* +// This class is strongly influenced by wxVScrolledWindow. In fact, much of +// code is line for line the same except it EXPLICITLY states which axis is +// being worked on. Like wxVScrolledWindow, this class is here to provide +// an easy way to implement variable line sizes. The difference is that +// wxVScrolledWindow only works with vertical scrolling. This class extends +// the behavior of wxVScrolledWindow to the horizontal axis in addition to the +// vertical axis. + +// The scrolling is also "virtual" in the sense that line widths and heights +// only need to be known for lines that are currently visible. + +// Like wxVScrolledWindow, this is a generalization of the wxScrolledWindow +// class which can be only used when all horizontal lines have the same width +// and all of the vertical lines have the same height. Like wxVScrolledWinow +// it lacks some of wxScrolledWindow features such as scrolling another window +// or only scrolling a rectangle of the window and not its entire client area. + +// If only vertical scrolling is needed, wxVScrolledWindow is recommended +// because it is simpler to use (and you get to type less). + +// There is no wxHScrolledWindow but horizontal only scrolling is implemented +// easily enough with this class. If someone feels the need for such a class, +// implementing it is trivial. +// */ +// MustHaveApp(wxPyHVScrolledWindow); + +// %rename(HVScrolledWindow) wxPyHVScrolledWindow; +// class wxPyHVScrolledWindow : public wxPanel +// { +// public: +// %pythonAppend wxPyHVScrolledWindow "self._setOORInfo(self); self._setCallbackInfo(self, VScrolledWindow)" +// %pythonAppend wxPyHVScrolledWindow() "" + +// // normal ctor, no need to call Create() after this one +// // +// // note that wxVSCROLL and wxHSCROLL are always automatically added to our +// // style, there is no need to specify them explicitly +// 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); + + +// // operations +// // ---------- + +// // set the number of lines the window contains for each axis: the derived +// // class must provide the widths and heights for all lines with indices up +// // to each of the one given here in its OnGetColumnWidth() and +// // OnGetRowHeight() +// void SetRowColumnCounts(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 layed out +// // properly, and the contents of the window (pixels) are actually moved +// void EnablePhysicalScrolling(bool scrolling = true); + +// // 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 ScrollToRow(size_t row); +// bool ScrollToColumn(size_t column); +// bool ScrollToRowColumn(size_t row, size_t column); + +// // scroll by the specified number of lines/pages +// virtual bool ScrollRows(int rows); +// virtual bool ScrollColumns(int columns); +// virtual bool ScrollRowsColumns(int rows, int columns); +// virtual bool ScrollRowPages(int pages); +// virtual bool ScrollColumnPages(int pages); +// virtual bool ScrollPages(int rowPages, int columnPages); + +// // redraw the specified line +// virtual void RefreshRow(size_t line); +// virtual void RefreshColumn(size_t line); +// virtual void RefreshRowColumn(size_t row, size_t column); + +// // redraw all lines in the specified range (inclusive) +// virtual void RefreshRows(size_t from, size_t to); +// virtual void RefreshColumns(size_t from, size_t to); +// virtual void RefreshRowsColumns(size_t fromRow, size_t toRow, +// size_t fromColumn, size_t toColumn); + +// // return the horizontal and vertical line within a wxPoint at the +// // specified (in physical coordinates) position or. + +// // wxNOT_FOUND in either or both axes if no line is present at the +// // requested coordinates, i.e. if it is past the last lines +// %Rename(HitTestXY, wxPoint, HitTest(wxCoord x, wxCoord y) const); +// wxPoint HitTest(const wxPoint& pt) const; + +// // recalculate all our parameters and redisplay all lines +// virtual void RefreshAll(); + + +// // accessors +// // --------- + +// // get the number of lines this window contains (previously set by +// // SetLineCount()) +// size_t GetRowCount() const; +// size_t GetColumnCount() const; +// wxSize GetRowColumnCounts() const; + +// // get the first currently visible line/lines +// size_t GetVisibleRowsBegin() const; +// size_t GetVisibleColumnsBegin() const; +// wxPoint GetVisibleBegin() const; + +// // get the last currently visible line/lines +// size_t GetVisibleRowsEnd() const; +// size_t GetVisibleColumnsEnd() const; +// wxPoint GetVisibleEnd() const; + +// // is this line currently visible? +// bool IsRowVisible(size_t row) const; +// bool IsColumnVisible(size_t column) const; +// bool IsVisible(size_t row, size_t column) const; + + +// // find the index of the horizontal 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 FindFirstFromRight(size_t columnLast, bool fullyVisible = false); + +// // find the index of the vertical 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); + + +// // get the total width or height of the lines between lineMin (inclusive) +// // and lineMax (exclusive) +// wxCoord GetRowsHeight(size_t lineMin, size_t lineMax) const; +// wxCoord GetColumnsWidth(size_t columnMin, size_t columnMax) const; + +// }; + + + //--------------------------------------------------------------------------- // wxVListBox @@ -212,7 +484,7 @@ MAKE_CONST_WXSTRING(VListBoxNameStr); %{ class wxPyVListBox : public wxVListBox { - DECLARE_ABSTRACT_CLASS(wxPyVListBox); + DECLARE_ABSTRACT_CLASS(wxPyVListBox) public: wxPyVListBox() : wxVListBox() {} @@ -286,7 +558,8 @@ IMP_PYCALLBACK__DCRECTSIZET_const (wxPyVListBox, wxVListBox, OnDrawBackground */ MustHaveApp(wxPyVListBox); -%name(VListBox) class wxPyVListBox : public wxPyVScrolledWindow +%rename(VListBox) wxPyVListBox; +class wxPyVListBox : public wxPyVScrolledWindow { public: %pythonAppend wxPyVListBox "self._setOORInfo(self);self._setCallbackInfo(self, VListBox)" @@ -300,7 +573,7 @@ public: long style = 0, const wxString& name = wxPyVListBoxNameStr); - %name(PreVListBox) wxPyVListBox(); + %RenameCtor(PreVListBox, wxPyVListBox()); void _setCallbackInfo(PyObject* self, PyObject* _class); @@ -344,7 +617,7 @@ public: PyObject* GetFirstSelected() { unsigned long cookie = 0; int selected = self->GetFirstSelected(cookie); - bool blocked = wxPyBeginBlockThreads(); + 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)); @@ -361,7 +634,7 @@ public: // int GetNextSelected(unsigned long& cookie) const; PyObject* GetNextSelected(unsigned long cookie) { int selected = self->GetNextSelected(cookie); - bool blocked = wxPyBeginBlockThreads(); + 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)); @@ -431,7 +704,7 @@ 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); @@ -450,7 +723,7 @@ public: %{ class wxPyHtmlListBox : public wxHtmlListBox { - DECLARE_ABSTRACT_CLASS(wxPyHtmlListBox); + DECLARE_ABSTRACT_CLASS(wxPyHtmlListBox) public: wxPyHtmlListBox() : wxHtmlListBox() {} @@ -505,7 +778,8 @@ IMP_PYCALLBACK_STRING_SIZET (wxPyHtmlListBox, wxHtmlListBox, OnGetItemMarkup // wxHtmlListBox is a listbox whose items are wxHtmlCells MustHaveApp(wxPyHtmlListBox); -%name(HtmlListBox) class wxPyHtmlListBox : public wxPyVListBox +%rename(HtmlListBox) wxPyHtmlListBox; +class wxPyHtmlListBox : public wxPyVListBox { public: %pythonAppend wxPyHtmlListBox "self._setOORInfo(self);self._setCallbackInfo(self, HtmlListBox)" @@ -520,7 +794,7 @@ public: long style = 0, const wxString& name = wxPyVListBoxNameStr); - %name(PreHtmlListBox) wxPyHtmlListBox(); + %RenameCtor(PreHtmlListBox, wxPyHtmlListBox()); void _setCallbackInfo(PyObject* self, PyObject* _class);