X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/6463b9f5399b8670a0c74f2f8666bc2c9f37a406..46b8d15a67701e1a2594b0eca820f166645e1b31:/include/wx/scrolwin.h diff --git a/include/wx/scrolwin.h b/include/wx/scrolwin.h index 9ebdc14f1b..1b41c43d9b 100644 --- a/include/wx/scrolwin.h +++ b/include/wx/scrolwin.h @@ -12,54 +12,111 @@ #ifndef _WX_SCROLWIN_H_BASE_ #define _WX_SCROLWIN_H_BASE_ -#include "wx/window.h" +#include "wx/panel.h" -class WXDLLEXPORT wxScrollHelperEvtHandler; -class WXDLLEXPORT wxTimer; +class WXDLLIMPEXP_FWD_CORE wxScrollHelperEvtHandler; +class WXDLLIMPEXP_FWD_BASE wxTimer; + +// default scrolled window style: scroll in both directions +#define wxScrolledWindowStyle (wxHSCROLL | wxVSCROLL) + +// values for the second argument of wxScrollHelper::ShowScrollbars() +enum wxScrollbarVisibility +{ + wxSHOW_SB_NEVER = -1, // never show the scrollbar at all + wxSHOW_SB_DEFAULT, // show scrollbar only if it is needed + wxSHOW_SB_ALWAYS // always show scrollbar, even if not needed +}; // ---------------------------------------------------------------------------- -// wxScrollHelper: this class implements the scrolling logic which is used by -// wxScrolledWindow and wxScrolledControl. It is a mix-in: just derive from it -// to implement scrolling in your class. +// The hierarchy of scrolling classes is a bit complicated because we want to +// put as much functionality as possible in a mix-in class not deriving from +// wxWindow so that other classes could derive from the same base class on all +// platforms irrespectively of whether they are native controls (and hence +// don't use our scrolling) or not. +// +// So we have +// +// wxScrollHelperBase +// | +// | +// \|/ +// wxWindow wxScrollHelper +// | \ / / +// | \ / / +// | _| |_ / +// | wxScrolledWindow / +// | / +// \|/ / +// wxControl / +// \ / +// \ / +// _| |_ +// wxScrolledControl +// // ---------------------------------------------------------------------------- -class WXDLLEXPORT wxScrollHelper +class WXDLLIMPEXP_CORE wxScrollHelperBase { public: - // ctor and dtor - wxScrollHelper(wxWindow *winToScroll = (wxWindow *)NULL); - void SetWindow(wxWindow *winToScroll); - virtual ~wxScrollHelper(); + // ctor must be given the associated window + wxScrollHelperBase(wxWindow *winToScroll); + virtual ~wxScrollHelperBase(); // configure the scrolling virtual void SetScrollbars(int pixelsPerUnitX, int pixelsPerUnitY, int noUnitsX, int noUnitsY, int xPos = 0, int yPos = 0, - bool noRefresh = FALSE ); + bool noRefresh = false ); // scroll to the given (in logical coords) position - virtual void Scroll(int x, int y); + // + // notice that for backwards compatibility reasons Scroll() is virtual as + // the existing code could override it but new code should override + // DoScroll() instead + virtual void Scroll(int x, int y) { DoScroll(x, y); } + virtual void Scroll(const wxPoint& pt) { DoScroll(pt.x, pt.y); } // get/set the page size for this orientation (wxVERTICAL/wxHORIZONTAL) int GetScrollPageSize(int orient) const; void SetScrollPageSize(int orient, int pageSize); + // get the number of lines the window can scroll, + // returns 0 if no scrollbars are there. + int GetScrollLines( int orient ) const; + // Set the x, y scrolling increments. void SetScrollRate( int xstep, int ystep ); // get the size of one logical unit in physical ones - virtual void GetScrollPixelsPerUnit(int *pixelsPerUnitX, - int *pixelsPerUnitY) const; + void GetScrollPixelsPerUnit(int *pixelsPerUnitX, int *pixelsPerUnitY) const; + + // Set scrollbar visibility: it is possible to show scrollbar only if it is + // needed (i.e. if our virtual size is greater than the current size of the + // associated window), always (as wxALWAYS_SHOW_SB style does) or never (in + // which case you should provide some other way to scroll the window as the + // user wouldn't be able to do it at all) + void ShowScrollbars(wxScrollbarVisibility horz, wxScrollbarVisibility vert) + { + DoShowScrollbars(horz, vert); + } - // Enable/disable Windows scrolling in either direction. If TRUE, wxWindows + // Enable/disable Windows scrolling in either direction. If true, wxWidgets // scrolls the canvas and only a bit of the canvas is invalidated; no - // Clear() is necessary. If FALSE, the whole canvas is invalidated and a + // Clear() is necessary. If false, the whole canvas is invalidated and a // Clear() is necessary. Disable for when the scroll increment is used to // actually scroll a non-constant distance virtual void EnableScrolling(bool x_scrolling, bool y_scrolling); // Get the view start - virtual void GetViewStart(int *x, int *y) const; + void GetViewStart(int *x, int *y) const { DoGetViewStart(x, y); } + + wxPoint GetViewStart() const + { + wxPoint pt; + DoGetViewStart(&pt.x, &pt.y); + return pt; + } // Set the scale factor, used in PrepareDC void SetScale(double xs, double ys) { m_scaleX = xs; m_scaleY = ys; } @@ -85,21 +142,21 @@ public: return p2; } - virtual void DoCalcScrolledPosition(int x, int y, int *xx, int *yy) const; - virtual void DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) const; + void DoCalcScrolledPosition(int x, int y, int *xx, int *yy) const; + void DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) const; // Adjust the scrollbars - virtual void AdjustScrollbars(void); + virtual void AdjustScrollbars() = 0; // Calculate scroll increment - virtual int CalcScrollInc(wxScrollWinEvent& event); + int CalcScrollInc(wxScrollWinEvent& event); // 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; + void SetTargetWindow(wxWindow *target); + wxWindow *GetTargetWindow() const; void SetTargetRect(const wxRect& rect) { m_rectToScroll = rect; } wxRect GetTargetRect() const { return m_rectToScroll; } @@ -121,7 +178,7 @@ public: // stop the timer, so it will be called repeatedly and will typically // return different values depending on the current mouse position // - // the base class version just returns TRUE + // the base class version just returns true virtual bool SendAutoScrollEvents(wxScrollWinEvent& event) const; // the methods to be called from the window event handlers @@ -134,15 +191,13 @@ public: #if wxUSE_MOUSEWHEEL void HandleOnMouseWheel(wxMouseEvent& event); #endif // wxUSE_MOUSEWHEEL + void HandleOnChildFocus(wxChildFocusEvent& event); - // FIXME: this is needed for now for wxPlot compilation, should be removed - // once it is fixed! - void OnScroll(wxScrollWinEvent& event) { HandleOnScroll(event); } - -#if WXWIN_COMPATIBILITY_2_2 - // Compatibility only, don't use - void ViewStart(int *x, int *y) const { GetViewStart( x, y ); } -#endif // WXWIN_COMPATIBILITY_2_2 +#if WXWIN_COMPATIBILITY_2_8 + wxDEPRECATED( + void OnScroll(wxScrollWinEvent& event) { HandleOnScroll(event); } + ) +#endif // WXWIN_COMPATIBILITY_2_8 protected: // get pointer to our scroll rect if we use it or NULL @@ -158,7 +213,7 @@ protected: : m_targetWindow->GetClientSize(); } - void GetTargetSize(int *w, int *h) + void GetTargetSize(int *w, int *h) const { wxSize size = GetTargetSize(); if ( w ) @@ -167,6 +222,18 @@ protected: *h = size.y; } + // implementation of public methods with the same name + virtual void DoGetViewStart(int *x, int *y) const; + virtual void DoScroll(int x, int y) = 0; + virtual void DoShowScrollbars(wxScrollbarVisibility horz, + wxScrollbarVisibility vert) = 0; + + // implementations of various wxWindow virtual methods which should be + // forwarded to us (this can be done by WX_FORWARD_TO_SCROLL_HELPER()) + bool ScrollLayout(); + void ScrollDoSetVirtualSize(int x, int y); + wxSize ScrollGetBestVirtualSize() const; + // change just the target window (unlike SetWindow which changes m_win as // well) void DoSetTargetWindow(wxWindow *target); @@ -174,6 +241,30 @@ protected: // delete the event handler we installed void DeleteEvtHandler(); + // calls wxScrollHelperEvtHandler::ResetDrawnFlag(), see explanation + // in wxScrollHelperEvtHandler::ProcessEvent() + void ResetDrawnFlag(); + + // this function should be overridden to return the size available for + // m_targetWindow inside m_win of the given size + // + // the default implementation is only good for m_targetWindow == m_win + // case, if we're scrolling a subwindow you must override this method + virtual wxSize GetSizeAvailableForScrollTarget(const wxSize& size) + { + // returning just size from here is wrong but it was decided that it is + // not wrong enough to break the existing code (which doesn't override + // this recently added function at all) by adding this assert + // + // wxASSERT_MSG( m_targetWindow == m_win, "must be overridden" ); + + return size; + } + + + double m_scaleX; + double m_scaleY; + wxWindow *m_win, *m_targetWindow; @@ -193,48 +284,161 @@ protected: bool m_xScrollingEnabled; bool m_yScrollingEnabled; - double m_scaleX; - double m_scaleY; - #if wxUSE_MOUSEWHEEL int m_wheelRotation; #endif // wxUSE_MOUSEWHEEL wxScrollHelperEvtHandler *m_handler; - DECLARE_NO_COPY_CLASS(wxScrollHelper) + wxDECLARE_NO_COPY_CLASS(wxScrollHelperBase); }; +// this macro can be used in a wxScrollHelper-derived class to forward wxWindow +// methods to corresponding wxScrollHelper methods +#define WX_FORWARD_TO_SCROLL_HELPER() \ +public: \ + virtual void PrepareDC(wxDC& dc) { DoPrepareDC(dc); } \ + virtual bool Layout() { return ScrollLayout(); } \ + virtual void DoSetVirtualSize(int x, int y) \ + { ScrollDoSetVirtualSize(x, y); } \ + virtual wxSize GetBestVirtualSize() const \ + { return ScrollGetBestVirtualSize(); } + +// include the declaration of the real wxScrollHelper +#if defined(__WXGTK20__) && !defined(__WXUNIVERSAL__) + #include "wx/gtk/scrolwin.h" +#elif defined(__WXGTK__) && !defined(__WXUNIVERSAL__) + #include "wx/gtk1/scrolwin.h" +#else + #define wxHAS_GENERIC_SCROLLWIN + #include "wx/generic/scrolwin.h" +#endif + // ---------------------------------------------------------------------------- -// wxScrolledWindow: a wxWindow which knows how to scroll +// wxScrolled: a wxWindow which knows how to scroll // ---------------------------------------------------------------------------- -#if defined(__WXGTK__) && !defined(__WXUNIVERSAL__) - #include "wx/gtk/scrolwin.h" -#else // !wxGTK - #include "wx/generic/scrolwin.h" +// helper class for wxScrolled below +struct WXDLLIMPEXP_CORE wxScrolledT_Helper +{ + static wxSize FilterBestSize(const wxWindow *win, + const wxScrollHelper *helper, + const wxSize& origBest); +#ifdef __WXMSW__ + static WXLRESULT FilterMSWWindowProc(WXUINT nMsg, WXLRESULT origResult); +#endif +}; - class WXDLLEXPORT wxScrolledWindow : public wxGenericScrolledWindow +// Scrollable window base on window type T. This used to be wxScrolledWindow, +// but wxScrolledWindow includes wxControlContainer functionality and that's +// not always desirable. +template +class wxScrolled : public T, + public wxScrollHelper, + private wxScrolledT_Helper +{ +public: + wxScrolled() : wxScrollHelper(this) { } + wxScrolled(wxWindow *parent, + wxWindowID winid = wxID_ANY, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxScrolledWindowStyle, + const wxString& name = wxPanelNameStr) + : wxScrollHelper(this) { - public: - wxScrolledWindow() { } - wxScrolledWindow(wxWindow *parent, - wxWindowID winid = -1, - const wxPoint& pos = wxDefaultPosition, - const wxSize& size = wxDefaultSize, - long style = wxScrolledWindowStyle, - const wxString& name = wxPanelNameStr) - : wxGenericScrolledWindow(parent, winid, pos, size, style, name) - { - } - - private: - DECLARE_DYNAMIC_CLASS_NO_COPY(wxScrolledWindow) - }; - - #define wxSCROLLED_WINDOW_IS_GENERIC 1 + Create(parent, winid, pos, size, style, name); + } + + bool Create(wxWindow *parent, + wxWindowID winid, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxScrolledWindowStyle, + const wxString& name = wxPanelNameStr) + { + m_targetWindow = this; + +#ifdef __WXMAC__ + this->MacSetClipChildren(true); #endif + this->Connect(wxEVT_PAINT, wxPaintEventHandler(wxScrolled::OnPaint)); + + // by default, we're scrollable in both directions (but if one of the + // styles is specified explicitly, we shouldn't add the other one + // automatically) + if ( !(style & (wxHSCROLL | wxVSCROLL)) ) + style |= wxHSCROLL | wxVSCROLL; + + return T::Create(parent, winid, pos, size, style, name); + } + + // we need to return a special WM_GETDLGCODE value to process just the + // arrows but let the other navigation characters through +#ifdef __WXMSW__ + virtual WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) + { + return FilterMSWWindowProc(nMsg, T::MSWWindowProc(nMsg, wParam, lParam)); + } +#endif // __WXMSW__ + + WX_FORWARD_TO_SCROLL_HELPER() + +protected: + virtual wxSize DoGetBestSize() const + { + return FilterBestSize(this, this, T::DoGetBestSize()); + } + +private: + // this is needed for wxEVT_PAINT processing hack described in + // wxScrollHelperEvtHandler::ProcessEvent() + void OnPaint(wxPaintEvent& event) + { + // the user code didn't really draw the window if we got here, so set + // this flag to try to call OnDraw() later + ResetDrawnFlag(); + event.Skip(); + } + + // VC++ 6 gives warning for the declaration of template member function + // without definition +#ifndef __VISUALC6__ + wxDECLARE_NO_COPY_CLASS(wxScrolled); +#endif +}; + +#ifdef __VISUALC6__ + // disable the warning about non dll-interface class used as base for + // dll-interface class: it's harmless in this case + #pragma warning(push) + #pragma warning(disable:4275) +#endif + +// for compatibility with existing code, we provide wxScrolledWindow +// "typedef" for wxScrolled. It's not a real typedef because we +// want wxScrolledWindow to show in wxRTTI information (the class is widely +// used and likelihood of its wxRTTI information being used too is high): +class WXDLLIMPEXP_CORE wxScrolledWindow : public wxScrolled +{ +public: + wxScrolledWindow() : wxScrolled() {} + wxScrolledWindow(wxWindow *parent, + wxWindowID winid = wxID_ANY, + const wxPoint& pos = wxDefaultPosition, + const wxSize& size = wxDefaultSize, + long style = wxScrolledWindowStyle, + const wxString& name = wxPanelNameStr) + : wxScrolled(parent, winid, pos, size, style, name) {} + + DECLARE_DYNAMIC_CLASS_NO_COPY(wxScrolledWindow) +}; + +typedef wxScrolled wxScrolledCanvas; + +#ifdef __VISUALC6__ + #pragma warning(pop) #endif - // _WX_SCROLWIN_H_BASE_ +#endif // _WX_SCROLWIN_H_BASE_