]>
Commit | Line | Data |
---|---|---|
cf7d6329 VZ |
1 | ///////////////////////////////////////////////////////////////////////////// |
2 | // Name: include/wx/vscroll.h | |
f18eaf26 | 3 | // Purpose: Variable scrolled windows (wx[V/H/HV]ScrolledWindow) |
cf7d6329 | 4 | // Author: Vadim Zeitlin |
f18eaf26 | 5 | // Modified by: Brad Anderson, Bryan Petty |
cf7d6329 VZ |
6 | // Created: 30.05.03 |
7 | // RCS-ID: $Id$ | |
77ffb593 | 8 | // Copyright: (c) 2003 Vadim Zeitlin <vadim@wxwidgets.org> |
65571936 | 9 | // Licence: wxWindows licence |
cf7d6329 VZ |
10 | ///////////////////////////////////////////////////////////////////////////// |
11 | ||
12 | #ifndef _WX_VSCROLL_H_ | |
13 | #define _WX_VSCROLL_H_ | |
14 | ||
f18eaf26 VZ |
15 | #include "wx/panel.h" |
16 | #include "wx/position.h" | |
17 | ||
18 | class WXDLLEXPORT wxVarScrollHelperEvtHandler; | |
19 | ||
20 | ||
21 | // Using the same techniques as the wxScrolledWindow class | | |
22 | // hierarchy, the wx[V/H/HV]ScrolledWindow classes are slightly | | |
23 | // more complex (compare with the diagram outlined in | | |
24 | // scrolwin.h) for the purpose of reducing code duplication | | |
25 | // through the use of mix-in classes. | | |
26 | // | | |
27 | // wxVarScrollHelperBase | | |
28 | // / \ | | |
29 | // / \ | | |
30 | // V V | | |
31 | // wxVarHScrollHelper wxVarVScrollHelper | | |
32 | // | \ / | | | |
33 | // | \ / | | | |
34 | // | V V | | | |
35 | // | wxVarHVScrollHelper | | | |
36 | // | | | | | |
37 | // | | V | | |
38 | // | wxPanel | wxVarVScrollLegacyAdaptor | | |
39 | // | / \ \ | | | | |
40 | // | / \ `-----|----------. | | | |
41 | // | / \ | \ | | | |
42 | // | / \ | \ | | | |
43 | // V V \ | V V | | |
44 | // wxHScrolledWindow \ | wxVScrolledWindow | | |
45 | // V V | | |
46 | // wxHVScrolledWindow | | |
47 | // | | |
48 | // | | |
49 | // Border added to suppress GCC multi-line comment warnings ->| | |
50 | ||
51 | ||
52 | // =========================================================================== | |
53 | // wxVarScrollHelperBase | |
54 | // =========================================================================== | |
55 | ||
56 | // Provides all base common scroll calculations needed for either orientation, | |
57 | // automatic scrollbar functionality, saved scroll positions, functionality | |
58 | // for changing the target window to be scrolled, as well as defining all | |
59 | // required virtual functions that need to be implemented for any orientation | |
60 | // specific work. | |
61 | ||
62 | class WXDLLEXPORT wxVarScrollHelperBase | |
cf7d6329 VZ |
63 | { |
64 | public: | |
65 | // constructors and such | |
66 | // --------------------- | |
67 | ||
f18eaf26 VZ |
68 | wxVarScrollHelperBase(wxWindow *winToScroll); |
69 | virtual ~wxVarScrollHelperBase(); | |
cf7d6329 | 70 | |
f18eaf26 VZ |
71 | // operations |
72 | // ---------- | |
73 | ||
74 | // with physical scrolling on, the device origin is changed properly when | |
75 | // a wxPaintDC is prepared, children are actually moved and laid out | |
76 | // properly, and the contents of the window (pixels) are actually moved | |
77 | void EnablePhysicalScrolling(bool scrolling = true) | |
78 | { m_physicalScrolling = scrolling; } | |
79 | ||
80 | // wxNOT_FOUND if none, i.e. if it is below the last item | |
81 | virtual int HitTest(wxCoord coord) const; | |
82 | ||
83 | // recalculate all our parameters and redisplay all units | |
84 | virtual void RefreshAll(); | |
85 | ||
86 | // accessors | |
87 | // --------- | |
88 | ||
89 | // get the first currently visible unit | |
90 | size_t GetVisibleBegin() const { return m_unitFirst; } | |
91 | ||
92 | // get the last currently visible unit | |
93 | size_t GetVisibleEnd() const | |
94 | { return m_unitFirst + m_nUnitsVisible; } | |
95 | ||
96 | // is this unit currently visible? | |
97 | bool IsVisible(size_t unit) const | |
98 | { return unit >= m_unitFirst && unit < GetVisibleEnd(); } | |
99 | ||
100 | // translate between scrolled and unscrolled coordinates | |
101 | int CalcScrolledPosition(int coord) const | |
102 | { return DoCalcScrolledPosition(coord); } | |
103 | int CalcUnscrolledPosition(int coord) const | |
104 | { return DoCalcUnscrolledPosition(coord); } | |
105 | ||
106 | virtual int DoCalcScrolledPosition(int coord) const; | |
107 | virtual int DoCalcUnscrolledPosition(int coord) const; | |
108 | ||
109 | // update the thumb size shown by the scrollbar | |
110 | virtual void UpdateScrollbar(); | |
111 | void RemoveScrollbar(); | |
112 | ||
113 | // Normally the wxScrolledWindow will scroll itself, but in some rare | |
114 | // occasions you might want it to scroll [part of] another window (e.g. a | |
115 | // child of it in order to scroll only a portion the area between the | |
116 | // scrollbars (spreadsheet: only cell area will move). | |
117 | virtual void SetTargetWindow(wxWindow *target); | |
118 | virtual wxWindow *GetTargetWindow() const { return m_targetWindow; } | |
119 | ||
120 | // Override this function to draw the graphic (or just process EVT_PAINT) | |
121 | //virtual void OnDraw(wxDC& WXUNUSED(dc)) { } | |
122 | ||
123 | // change the DC origin according to the scroll position. To properly | |
124 | // forward calls to wxWindow::Layout use WX_FORWARD_TO_SCROLL_HELPER() | |
125 | // derived class | |
126 | virtual void DoPrepareDC(wxDC& dc); | |
127 | ||
128 | // the methods to be called from the window event handlers | |
129 | void HandleOnScroll(wxScrollWinEvent& event); | |
130 | void HandleOnSize(wxSizeEvent& event); | |
131 | #if wxUSE_MOUSEWHEEL | |
132 | void HandleOnMouseWheel(wxMouseEvent& event); | |
133 | #endif // wxUSE_MOUSEWHEEL | |
134 | ||
135 | // these functions must be overidden in the derived class to return | |
136 | // orientation specific data (e.g. the width for vertically scrolling | |
137 | // derivatives in the case of GetOrientationTargetSize()) | |
138 | virtual int GetOrientationTargetSize() const = 0; | |
139 | virtual int GetNonOrientationTargetSize() const = 0; | |
140 | virtual wxOrientation GetOrientation() const = 0; | |
141 | ||
142 | protected: | |
143 | // all *Unit* functions are protected to be exposed by | |
144 | // wxVarScrollHelperBase implementations (with appropriate names) | |
145 | ||
146 | // get the number of units this window contains (previously set by | |
147 | // SetUnitCount()) | |
148 | size_t GetUnitCount() const { return m_unitMax; } | |
149 | ||
150 | // set the number of units the helper contains: the derived class must | |
151 | // provide the sizes for all units with indices up to the one given here | |
152 | // in its OnGetUnitSize() | |
153 | void SetUnitCount(size_t count); | |
154 | ||
155 | // redraw the specified unit | |
156 | virtual void RefreshUnit(size_t unit); | |
157 | ||
158 | // redraw all units in the specified range (inclusive) | |
159 | virtual void RefreshUnits(size_t from, size_t to); | |
160 | ||
161 | // scroll to the specified unit: it will become the first visible unit in | |
162 | // the window | |
cf7d6329 | 163 | // |
f18eaf26 VZ |
164 | // return true if we scrolled the window, false if nothing was done |
165 | bool DoScrollToUnit(size_t unit); | |
166 | ||
167 | // scroll by the specified number of units/pages | |
168 | virtual bool DoScrollUnits(int units); | |
169 | virtual bool DoScrollPages(int pages); | |
170 | ||
171 | // this function must be overridden in the derived class and it should | |
172 | // return the size of the given unit in pixels | |
173 | virtual wxCoord OnGetUnitSize(size_t n) const = 0; | |
174 | ||
175 | // this function doesn't have to be overridden but it may be useful to do | |
176 | // it if calculating the units' sizes is a relatively expensive operation | |
177 | // as it gives the user code a possibility to calculate several of them at | |
178 | // once | |
179 | // | |
180 | // OnGetUnitsSizeHint() is normally called just before OnGetUnitSize() but | |
181 | // you shouldn't rely on the latter being called for all units in the | |
182 | // interval specified here. It is also possible that OnGetUnitHeight() will | |
183 | // be called for the units outside of this interval, so this is really just | |
184 | // a hint, not a promise. | |
185 | // | |
186 | // finally note that unitMin is inclusive, while unitMax is exclusive, as | |
187 | // usual | |
188 | virtual void OnGetUnitsSizeHint(size_t WXUNUSED(unitMin), | |
189 | size_t WXUNUSED(unitMax)) const | |
190 | { } | |
191 | ||
192 | // when the number of units changes, we try to estimate the total size | |
193 | // of all units which is a rather expensive operation in terms of unit | |
194 | // access, so if the user code may estimate the average size | |
195 | // better/faster than we do, it should override this function to implement | |
196 | // its own logic | |
197 | // | |
198 | // this function should return the best guess for the total size it may | |
199 | // make | |
200 | virtual wxCoord EstimateTotalSize() const { return DoEstimateTotalSize(); } | |
201 | ||
202 | wxCoord DoEstimateTotalSize() const; | |
203 | ||
204 | // find the index of the unit we need to show to fit the specified unit on | |
205 | // the opposite side either fully or partially (depending on fullyVisible) | |
206 | size_t FindFirstVisibleFromLast(size_t last, | |
207 | bool fullyVisible = false) const; | |
208 | ||
209 | // get the total size of the units between unitMin (inclusive) and | |
210 | // unitMax (exclusive) | |
211 | wxCoord GetUnitsSize(size_t unitMin, size_t unitMax) const; | |
212 | ||
213 | // get the offset of the first visible unit | |
214 | wxCoord GetScrollOffset() const | |
215 | { return GetUnitsSize(0, GetVisibleBegin()); } | |
216 | ||
217 | // get the size of the target window | |
218 | wxSize GetTargetSize() const { return m_targetWindow->GetClientSize(); } | |
219 | ||
220 | void GetTargetSize(int *w, int *h) | |
cf7d6329 | 221 | { |
f18eaf26 VZ |
222 | wxSize size = GetTargetSize(); |
223 | if ( w ) | |
224 | *w = size.x; | |
225 | if ( h ) | |
226 | *h = size.y; | |
227 | } | |
cf7d6329 | 228 | |
f18eaf26 VZ |
229 | // calculate the new scroll position based on scroll event type |
230 | size_t GetNewScrollPosition(wxScrollWinEvent& event) const; | |
231 | ||
232 | // replacement implementation of wxWindow::Layout virtual method. To | |
233 | // properly forward calls to wxWindow::Layout use | |
234 | // WX_FORWARD_TO_SCROLL_HELPER() derived class | |
235 | bool ScrollLayout(); | |
236 | ||
237 | #ifdef __WXMAC__ | |
238 | // queue mac window update after handling scroll event | |
239 | virtual void UpdateMacScrollWindow() = 0; | |
240 | #endif // __WXMAC__ | |
241 | ||
242 | // change the target window | |
243 | void DoSetTargetWindow(wxWindow *target); | |
244 | ||
245 | // delete the event handler we installed | |
246 | void DeleteEvtHandler(); | |
247 | ||
248 | // helper function abstracting the orientation test: with vertical | |
249 | // orientation, it assigns the first value to x and the second one to y, | |
250 | // with horizontal orientation it reverses them, i.e. the first value is | |
251 | // assigned to y and the second one to x | |
252 | void AssignOrient(wxCoord& x, wxCoord& y, wxCoord first, wxCoord second); | |
253 | ||
254 | // similar to "oriented assignment" above but does "oriented increment": | |
255 | // for vertical orientation, y is incremented by the given value and x if | |
256 | // left unchanged, for horizontal orientation x is incremented | |
257 | void IncOrient(wxCoord& x, wxCoord& y, wxCoord inc); | |
258 | ||
259 | private: | |
260 | ||
261 | // the window that receives the scroll events and the window to actually | |
262 | // scroll, respectively | |
263 | wxWindow *m_win, | |
264 | *m_targetWindow; | |
265 | ||
266 | // the total number of (logical) units | |
267 | size_t m_unitMax; | |
268 | ||
269 | // the total (estimated) size | |
270 | wxCoord m_sizeTotal; | |
271 | ||
272 | // the first currently visible unit | |
273 | size_t m_unitFirst; | |
274 | ||
275 | // the number of currently visible units (including the last, possibly only | |
276 | // partly, visible one) | |
277 | size_t m_nUnitsVisible; | |
278 | ||
279 | // accumulated mouse wheel rotation | |
280 | #if wxUSE_MOUSEWHEEL | |
281 | int m_sumWheelRotation; | |
282 | #endif | |
283 | ||
284 | // do child scrolling (used in DoPrepareDC()) | |
285 | bool m_physicalScrolling; | |
286 | ||
287 | // handler injected into target window to forward some useful events to us | |
288 | wxVarScrollHelperEvtHandler *m_handler; | |
289 | }; | |
290 | ||
291 | ||
292 | ||
293 | // =========================================================================== | |
294 | // wxVarVScrollHelper | |
295 | // =========================================================================== | |
296 | ||
297 | // Provides public API functions targeted for vertical-specific scrolling, | |
298 | // wrapping the functionality of wxVarScrollHelperBase. | |
299 | ||
300 | class WXDLLEXPORT wxVarVScrollHelper : public wxVarScrollHelperBase | |
301 | { | |
302 | public: | |
303 | // constructors and such | |
304 | // --------------------- | |
305 | ||
306 | // ctor must be given the associated window | |
307 | wxVarVScrollHelper(wxWindow *winToScroll) | |
308 | : wxVarScrollHelperBase(winToScroll) | |
309 | { | |
cf7d6329 VZ |
310 | } |
311 | ||
f18eaf26 VZ |
312 | // operators |
313 | ||
314 | void SetRowCount(size_t rowCount) { SetUnitCount(rowCount); } | |
315 | bool ScrollToRow(size_t row) { return DoScrollToUnit(row); } | |
316 | ||
317 | virtual bool ScrollRows(int rows) | |
318 | { return DoScrollUnits(rows); } | |
319 | virtual bool ScrollRowPages(int pages) | |
320 | { return DoScrollPages(pages); } | |
321 | ||
322 | virtual void RefreshRow(size_t row) | |
323 | { RefreshUnit(row); } | |
324 | virtual void RefreshRows(size_t from, size_t to) | |
325 | { RefreshUnits(from, to); } | |
326 | ||
327 | virtual int HitTest(wxCoord y) const | |
328 | { return wxVarScrollHelperBase::HitTest(y); } | |
329 | ||
330 | // accessors | |
331 | ||
332 | size_t GetRowCount() const { return GetUnitCount(); } | |
333 | size_t GetVisibleRowsBegin() const { return GetVisibleBegin(); } | |
334 | size_t GetVisibleRowsEnd() const { return GetVisibleEnd(); } | |
335 | bool IsRowVisible(size_t row) const { return IsVisible(row); } | |
336 | ||
337 | virtual int GetOrientationTargetSize() const | |
338 | { return GetTargetWindow()->GetClientSize().y; } | |
339 | virtual int GetNonOrientationTargetSize() const | |
340 | { return GetTargetWindow()->GetClientSize().x; } | |
341 | virtual wxOrientation GetOrientation() const { return wxVERTICAL; } | |
342 | ||
343 | protected: | |
344 | // this function must be overridden in the derived class and it should | |
345 | // return the size of the given row in pixels | |
346 | virtual wxCoord OnGetRowHeight(size_t n) const = 0; | |
347 | wxCoord OnGetUnitSize(size_t n) const { return OnGetRowHeight(n); } | |
348 | ||
349 | virtual void OnGetRowsHeightHint(size_t WXUNUSED(rowMin), | |
350 | size_t WXUNUSED(rowMax)) const { } | |
351 | ||
352 | // forward calls to OnGetRowsHeightHint() | |
353 | virtual void OnGetUnitsSizeHint(size_t unitMin, size_t unitMax) const | |
a81a4db3 | 354 | { OnGetRowsHeightHint(unitMin, unitMax); } |
f18eaf26 VZ |
355 | |
356 | // again, if not overridden, it will fall back on default method | |
357 | virtual wxCoord EstimateTotalHeight() const | |
358 | { return DoEstimateTotalSize(); } | |
359 | ||
360 | // forward calls to EstimateTotalHeight() | |
361 | virtual wxCoord EstimateTotalSize() const { return EstimateTotalHeight(); } | |
362 | ||
363 | wxCoord GetRowsHeight(size_t rowMin, size_t rowMax) const | |
364 | { return GetUnitsSize(rowMin, rowMax); } | |
365 | }; | |
366 | ||
367 | ||
368 | ||
369 | // =========================================================================== | |
370 | // wxVarHScrollHelper | |
371 | // =========================================================================== | |
372 | ||
373 | // Provides public API functions targeted for horizontal-specific scrolling, | |
374 | // wrapping the functionality of wxVarScrollHelperBase. | |
375 | ||
376 | class WXDLLEXPORT wxVarHScrollHelper : public wxVarScrollHelperBase | |
377 | { | |
378 | public: | |
379 | // constructors and such | |
380 | // --------------------- | |
381 | ||
382 | // ctor must be given the associated window | |
383 | wxVarHScrollHelper(wxWindow *winToScroll) | |
384 | : wxVarScrollHelperBase(winToScroll) | |
cf7d6329 | 385 | { |
cf7d6329 VZ |
386 | } |
387 | ||
f18eaf26 | 388 | // operators |
cf7d6329 | 389 | |
f18eaf26 VZ |
390 | void SetColumnCount(size_t columnCount) |
391 | { SetUnitCount(columnCount); } | |
cf7d6329 | 392 | |
f18eaf26 VZ |
393 | bool ScrollToColumn(size_t column) |
394 | { return DoScrollToUnit(column); } | |
395 | virtual bool ScrollColumns(int columns) | |
396 | { return DoScrollUnits(columns); } | |
397 | virtual bool ScrollColumnPages(int pages) | |
398 | { return DoScrollPages(pages); } | |
cf7d6329 | 399 | |
f18eaf26 VZ |
400 | virtual void RefreshColumn(size_t column) |
401 | { RefreshUnit(column); } | |
402 | virtual void RefreshColumns(size_t from, size_t to) | |
403 | { RefreshUnits(from, to); } | |
404 | virtual int HitTest(wxCoord x) const | |
405 | { return wxVarScrollHelperBase::HitTest(x); } | |
cf7d6329 | 406 | |
f18eaf26 | 407 | // accessors |
cf7d6329 | 408 | |
f18eaf26 VZ |
409 | size_t GetColumnCount() const |
410 | { return GetUnitCount(); } | |
411 | size_t GetVisibleColumnsBegin() const | |
412 | { return GetVisibleBegin(); } | |
413 | size_t GetVisibleColumnsEnd() const | |
414 | { return GetVisibleEnd(); } | |
415 | bool IsColumnVisible(size_t column) const | |
416 | { return IsVisible(column); } | |
e0c6027b | 417 | |
ae0f0223 | 418 | |
f18eaf26 VZ |
419 | virtual int GetOrientationTargetSize() const |
420 | { return GetTargetWindow()->GetClientSize().x; } | |
421 | virtual int GetNonOrientationTargetSize() const | |
422 | { return GetTargetWindow()->GetClientSize().y; } | |
423 | virtual wxOrientation GetOrientation() const { return wxHORIZONTAL; } | |
ceb71775 | 424 | |
f18eaf26 VZ |
425 | protected: |
426 | // this function must be overridden in the derived class and it should | |
427 | // return the size of the given column in pixels | |
428 | virtual wxCoord OnGetColumnWidth(size_t n) const = 0; | |
429 | wxCoord OnGetUnitSize(size_t n) const { return OnGetColumnWidth(n); } | |
e0c6027b | 430 | |
f18eaf26 VZ |
431 | virtual void OnGetColumnsWidthHint(size_t WXUNUSED(columnMin), |
432 | size_t WXUNUSED(columnMax)) const | |
433 | { } | |
8b053348 | 434 | |
f18eaf26 VZ |
435 | // forward calls to OnGetColumnsWidthHint() |
436 | virtual void OnGetUnitsSizeHint(size_t unitMin, size_t unitMax) const | |
21e3e3bc | 437 | { OnGetColumnsWidthHint(unitMin, unitMax); } |
f18eaf26 VZ |
438 | |
439 | // again, if not overridden, it will fall back on default method | |
440 | virtual wxCoord EstimateTotalWidth() const { return DoEstimateTotalSize(); } | |
441 | ||
442 | // forward calls to EstimateTotalWidth() | |
443 | virtual wxCoord EstimateTotalSize() const { return EstimateTotalWidth(); } | |
444 | ||
445 | wxCoord GetColumnsWidth(size_t columnMin, size_t columnMax) const | |
446 | { return GetUnitsSize(columnMin, columnMax); } | |
447 | }; | |
448 | ||
449 | ||
450 | ||
451 | // =========================================================================== | |
452 | // wxVarHVScrollHelper | |
453 | // =========================================================================== | |
454 | ||
455 | // Provides public API functions targeted at functions with similar names in | |
456 | // both wxVScrollHelper and wxHScrollHelper so class scope doesn't need to be | |
457 | // specified (since we are using multiple inheritance). It also provides | |
458 | // functions to make changing values for both orientations at the same time | |
459 | // easier. | |
460 | ||
461 | class WXDLLEXPORT wxVarHVScrollHelper : public wxVarVScrollHelper, | |
462 | public wxVarHScrollHelper | |
463 | { | |
464 | public: | |
465 | // constructors and such | |
466 | // --------------------- | |
467 | ||
468 | // ctor must be given the associated window | |
469 | wxVarHVScrollHelper(wxWindow *winToScroll) | |
470 | : wxVarVScrollHelper(winToScroll), wxVarHScrollHelper(winToScroll) { } | |
471 | ||
472 | // operators | |
473 | // --------- | |
474 | ||
475 | // set the number of units the window contains for each axis: the derived | |
476 | // class must provide the widths and heights for all units with indices up | |
477 | // to each of the one given here in its OnGetColumnWidth() and | |
478 | // OnGetRowHeight() | |
479 | void SetRowColumnCount(size_t rowCount, size_t columnCount); | |
480 | ||
481 | ||
482 | // with physical scrolling on, the device origin is changed properly when | |
483 | // a wxPaintDC is prepared, children are actually moved and laid out | |
484 | // properly, and the contents of the window (pixels) are actually moved | |
485 | void EnablePhysicalScrolling(bool vscrolling = true, bool hscrolling = true) | |
486 | { | |
487 | wxVarVScrollHelper::EnablePhysicalScrolling(vscrolling); | |
488 | wxVarHScrollHelper::EnablePhysicalScrolling(hscrolling); | |
489 | } | |
490 | ||
491 | // scroll to the specified row/column: it will become the first visible | |
492 | // cell in the window | |
493 | // | |
494 | // return true if we scrolled the window, false if nothing was done | |
495 | bool ScrollToRowColumn(size_t row, size_t column); | |
496 | bool ScrollToRowColumn(const wxPosition &pos) | |
497 | { return ScrollToRowColumn(pos.GetRow(), pos.GetColumn()); } | |
498 | ||
499 | // redraw the specified cell | |
500 | virtual void RefreshRowColumn(size_t row, size_t column); | |
501 | virtual void RefreshRowColumn(const wxPosition &pos) | |
502 | { RefreshRowColumn(pos.GetRow(), pos.GetColumn()); } | |
503 | ||
504 | // redraw the specified regions (inclusive). If the target window for | |
505 | // both orientations is the same the rectangle of cells is refreshed; if | |
506 | // the target windows differ the entire client size opposite the | |
507 | // orientation direction is refreshed between the specified limits | |
508 | virtual void RefreshRowsColumns(size_t fromRow, size_t toRow, | |
509 | size_t fromColumn, size_t toColumn); | |
510 | virtual void RefreshRowsColumns(const wxPosition& from, | |
511 | const wxPosition& to) | |
512 | { | |
513 | RefreshRowsColumns(from.GetRow(), to.GetRow(), | |
514 | from.GetColumn(), to.GetColumn()); | |
515 | } | |
516 | ||
517 | // Override wxPanel::HitTest to use our version | |
518 | virtual wxPosition HitTest(wxCoord x, wxCoord y) const; | |
519 | virtual wxPosition HitTest(const wxPoint &pos) const | |
520 | { return HitTest(pos.x, pos.y); } | |
521 | ||
522 | // change the DC origin according to the scroll position. To properly | |
523 | // forward calls to wxWindow::Layout use WX_FORWARD_TO_SCROLL_HELPER() | |
524 | // derived class. We use this version to call both base classes' | |
525 | // DoPrepareDC() | |
526 | virtual void DoPrepareDC(wxDC& dc); | |
527 | ||
528 | // replacement implementation of wxWindow::Layout virtual method. To | |
529 | // properly forward calls to wxWindow::Layout use | |
530 | // WX_FORWARD_TO_SCROLL_HELPER() derived class. We use this version to | |
531 | // call both base classes' ScrollLayout() | |
532 | bool ScrollLayout(); | |
cf7d6329 VZ |
533 | |
534 | // accessors | |
535 | // --------- | |
536 | ||
f18eaf26 VZ |
537 | // get the number of units this window contains (previously set by |
538 | // Set[Column/Row/RowColumn/Unit]Count()) | |
539 | wxSize GetRowColumnCount() const; | |
540 | ||
541 | // get the first currently visible units | |
542 | wxPosition GetVisibleBegin() const; | |
543 | wxPosition GetVisibleEnd() const; | |
544 | ||
545 | // is this cell currently visible? | |
546 | bool IsVisible(size_t row, size_t column) const; | |
547 | bool IsVisible(const wxPosition &pos) const | |
548 | { return IsVisible(pos.GetRow(), pos.GetColumn()); } | |
549 | }; | |
550 | ||
551 | ||
cf7d6329 | 552 | |
f18eaf26 | 553 | #if WXWIN_COMPATIBILITY_2_8 |
cf7d6329 | 554 | |
f18eaf26 VZ |
555 | // =========================================================================== |
556 | // wxVarVScrollLegacyAdaptor | |
557 | // =========================================================================== | |
cf7d6329 | 558 | |
f18eaf26 VZ |
559 | // Provides backwards compatible API for applications originally built using |
560 | // wxVScrolledWindow in 2.6 or 2.8. Originally, wxVScrolledWindow referred | |
561 | // to scrolling "lines". We use "units" in wxVarScrollHelperBase to avoid | |
562 | // implying any orientation (since the functions are used for both horizontal | |
563 | // and vertical scrolling in derived classes). And in the new | |
564 | // wxVScrolledWindow and wxHScrolledWindow classes, we refer to them as | |
565 | // "rows" and "columns", respectively. This is to help clear some confusion | |
566 | // in not only those classes, but also in wxHVScrolledWindow where functions | |
567 | // are inherited from both. | |
dd932cbe | 568 | |
f18eaf26 VZ |
569 | class WXDLLEXPORT wxVarVScrollLegacyAdaptor : public wxVarVScrollHelper |
570 | { | |
571 | public: | |
572 | // constructors and such | |
573 | // --------------------- | |
574 | wxVarVScrollLegacyAdaptor(wxWindow *winToScroll) | |
575 | : wxVarVScrollHelper(winToScroll) | |
576 | { | |
577 | } | |
578 | ||
579 | // accessors | |
580 | // --------- | |
dd932cbe | 581 | |
f18eaf26 | 582 | // this is the same as GetVisibleRowsBegin(), exists to match |
dd932cbe | 583 | // GetLastVisibleLine() and for backwards compatibility only |
f18eaf26 | 584 | size_t GetFirstVisibleLine() const { return GetVisibleRowsBegin(); } |
dd932cbe VZ |
585 | |
586 | // get the last currently visible line | |
587 | // | |
588 | // this function is unsafe as it returns (size_t)-1 (i.e. a huge positive | |
f18eaf26 VZ |
589 | // number) if the control is empty, use GetVisibleRowsEnd() instead, this |
590 | // one is kept for backwards compatibility | |
591 | size_t GetLastVisibleLine() const { return GetVisibleRowsEnd() - 1; } | |
e0c6027b | 592 | |
f18eaf26 VZ |
593 | // "line" to "unit" compatibility functions |
594 | // ---------------------------------------- | |
595 | ||
596 | // get the number of lines this window contains (set by SetLineCount()) | |
597 | size_t GetLineCount() const { return GetRowCount(); } | |
598 | ||
599 | // set the number of lines the helper contains: the derived class must | |
600 | // provide the sizes for all lines with indices up to the one given here | |
601 | // in its OnGetLineHeight() | |
602 | void SetLineCount(size_t count) { SetRowCount(count); } | |
603 | ||
604 | // redraw the specified line | |
605 | virtual void RefreshLine(size_t line) { RefreshRow(line); } | |
606 | ||
607 | // redraw all lines in the specified range (inclusive) | |
608 | virtual void RefreshLines(size_t from, size_t to) { RefreshRows(from, to); } | |
609 | ||
610 | // scroll to the specified line: it will become the first visible line in | |
611 | // the window | |
612 | // | |
613 | // return true if we scrolled the window, false if nothing was done | |
614 | bool ScrollToLine(size_t line) { return ScrollToRow(line); } | |
615 | ||
616 | // scroll by the specified number of lines/pages | |
617 | virtual bool ScrollLines(int lines) { return ScrollRows(lines); } | |
618 | virtual bool ScrollPages(int pages) { return ScrollRowPages(pages); } | |
cf7d6329 | 619 | |
e0c6027b | 620 | protected: |
79b83ef0 | 621 | // unless the code has been updated to override OnGetRowHeight() instead, |
cf7d6329 | 622 | // this function must be overridden in the derived class and it should |
f18eaf26 | 623 | // return the height of the given row in pixels |
32a2c06e | 624 | virtual wxCoord OnGetLineHeight(size_t WXUNUSED(n)) const |
79b83ef0 VZ |
625 | { |
626 | wxFAIL_MSG( _T("must be overridden if OnGetRowHeight() isn't!") ); | |
627 | ||
628 | return -1; | |
629 | } | |
cf7d6329 | 630 | |
f18eaf26 VZ |
631 | // forwards the calls from base class pure virtual function to pure virtual |
632 | // OnGetLineHeight instead (backwards compatible name) | |
633 | // note that we don't need to forward OnGetUnitSize() as it is already | |
634 | // forwarded to OnGetRowHeight() in wxVarVScrollHelper | |
635 | virtual wxCoord OnGetRowHeight(size_t n) const | |
636 | { return OnGetLineHeight(n); } | |
637 | ||
cf7d6329 VZ |
638 | // this function doesn't have to be overridden but it may be useful to do |
639 | // it if calculating the lines heights is a relatively expensive operation | |
640 | // as it gives the user code a possibility to calculate several of them at | |
641 | // once | |
642 | // | |
643 | // OnGetLinesHint() is normally called just before OnGetLineHeight() but you | |
644 | // shouldn't rely on the latter being called for all lines in the interval | |
645 | // specified here. It is also possible that OnGetLineHeight() will be | |
646 | // called for the lines outside of this interval, so this is really just a | |
647 | // hint, not a promise. | |
648 | // | |
649 | // finally note that lineMin is inclusive, while lineMax is exclusive, as | |
650 | // usual | |
27d0dcd0 VZ |
651 | virtual void OnGetLinesHint(size_t WXUNUSED(lineMin), |
652 | size_t WXUNUSED(lineMax)) const { } | |
cf7d6329 | 653 | |
f18eaf26 VZ |
654 | // forwards the calls from base class pure virtual function to pure virtual |
655 | // OnGetLinesHint instead (backwards compatible name) | |
656 | void OnGetRowsHeightHint(size_t rowMin, size_t rowMax) const | |
21e3e3bc | 657 | { OnGetLinesHint(rowMin, rowMax); } |
e0c6027b | 658 | |
cf7d6329 VZ |
659 | |
660 | // get the total height of the lines between lineMin (inclusive) and | |
661 | // lineMax (exclusive) | |
f18eaf26 VZ |
662 | wxCoord GetLinesHeight(size_t lineMin, size_t lineMax) const |
663 | { return GetRowsHeight(lineMin, lineMax); } | |
664 | }; | |
cf7d6329 | 665 | |
f18eaf26 | 666 | #else // !WXWIN_COMPATIBILITY_2_8 |
cf7d6329 | 667 | |
f18eaf26 | 668 | // shortcut to avoid checking compatibility modes later |
e02c72fa | 669 | // remove this and all references to wxVarVScrollLegacyAdaptor once |
f18eaf26 | 670 | // wxWidgets 2.6 and 2.8 compatibility is removed |
e02c72fa | 671 | typedef wxVarVScrollHelper wxVarVScrollLegacyAdaptor; |
c1aa5517 | 672 | |
f18eaf26 | 673 | #endif // WXWIN_COMPATIBILITY_2_8/!WXWIN_COMPATIBILITY_2_8 |
cf7d6329 VZ |
674 | |
675 | ||
f18eaf26 VZ |
676 | // this macro must be used in declaration of wxVarScrollHelperBase-derived |
677 | // classes | |
678 | #define WX_FORWARD_TO_VAR_SCROLL_HELPER() \ | |
679 | public: \ | |
680 | virtual void PrepareDC(wxDC& dc) { DoPrepareDC(dc); } \ | |
681 | virtual bool Layout() { return ScrollLayout(); } | |
cf7d6329 | 682 | |
cf7d6329 | 683 | |
cf7d6329 | 684 | |
f18eaf26 VZ |
685 | // =========================================================================== |
686 | // wxVScrolledWindow | |
687 | // =========================================================================== | |
cf7d6329 | 688 | |
f18eaf26 VZ |
689 | // In the name of this class, "V" may stand for "variable" because it can be |
690 | // used for scrolling rows of variable heights; "virtual", because it is not | |
691 | // necessary to know the heights of all rows in advance -- only those which | |
692 | // are shown on the screen need to be measured; or even "vertical", because | |
693 | // this class only supports scrolling vertically. | |
694 | ||
695 | // In any case, this is a generalization of the wxScrolledWindow class which | |
696 | // can be only used when all rows have the same heights. It lacks some other | |
697 | // wxScrolledWindow features however, notably it can't scroll only a rectangle | |
698 | // of the window and not its entire client area. | |
699 | ||
700 | class WXDLLEXPORT wxVScrolledWindow : public wxPanel, | |
701 | public wxVarVScrollLegacyAdaptor | |
702 | { | |
703 | public: | |
704 | // constructors and such | |
705 | // --------------------- | |
706 | ||
707 | // default ctor, you must call Create() later | |
708 | wxVScrolledWindow() : wxVarVScrollLegacyAdaptor(this) { } | |
709 | ||
710 | // normal ctor, no need to call Create() after this one | |
711 | // | |
712 | // note that wxVSCROLL is always automatically added to our style, there is | |
713 | // no need to specify it explicitly | |
714 | wxVScrolledWindow(wxWindow *parent, | |
715 | wxWindowID id = wxID_ANY, | |
716 | const wxPoint& pos = wxDefaultPosition, | |
717 | const wxSize& size = wxDefaultSize, | |
718 | long style = 0, | |
719 | const wxString& name = wxPanelNameStr) | |
720 | : wxVarVScrollLegacyAdaptor(this) | |
721 | { | |
722 | (void)Create(parent, id, pos, size, style, name); | |
723 | } | |
724 | ||
725 | // same as the previous ctor but returns status code: true if ok | |
726 | // | |
727 | // just as with the ctor above, wxVSCROLL style is always used, there is no | |
728 | // need to specify it | |
729 | bool Create(wxWindow *parent, | |
730 | wxWindowID id = wxID_ANY, | |
731 | const wxPoint& pos = wxDefaultPosition, | |
732 | const wxSize& size = wxDefaultSize, | |
733 | long style = 0, | |
734 | const wxString& name = wxPanelNameStr) | |
735 | { | |
736 | return wxPanel::Create(parent, id, pos, size, style | wxVSCROLL, name); | |
737 | } | |
738 | ||
739 | // Make sure we prefer our version of HitTest rather than wxWindow's | |
740 | int HitTest(wxCoord WXUNUSED(x), wxCoord y) const | |
741 | { return wxVarVScrollHelper::HitTest(y); } | |
742 | int HitTest(const wxPoint& pt) const | |
743 | { return HitTest(pt.x, pt.y); } | |
744 | ||
745 | WX_FORWARD_TO_VAR_SCROLL_HELPER() | |
cf7d6329 | 746 | |
f18eaf26 VZ |
747 | #ifdef __WXMAC__ |
748 | protected: | |
749 | virtual void UpdateMacScrollWindow() { Update(); } | |
750 | #endif // __WXMAC__ | |
751 | ||
752 | private: | |
27d0dcd0 | 753 | DECLARE_NO_COPY_CLASS(wxVScrolledWindow) |
0c8392ca | 754 | DECLARE_ABSTRACT_CLASS(wxVScrolledWindow) |
cf7d6329 VZ |
755 | }; |
756 | ||
f18eaf26 VZ |
757 | |
758 | ||
759 | // =========================================================================== | |
760 | // wxHScrolledWindow | |
761 | // =========================================================================== | |
762 | ||
763 | // In the name of this class, "H" stands for "horizontal" because it can be | |
764 | // used for scrolling columns of variable widths. It is not necessary to know | |
765 | // the widths of all columns in advance -- only those which are shown on the | |
766 | // screen need to be measured. | |
767 | ||
768 | // This is a generalization of the wxScrolledWindow class which can be only | |
769 | // used when all columns have the same width. It lacks some other | |
770 | // wxScrolledWindow features however, notably it can't scroll only a rectangle | |
771 | // of the window and not its entire client area. | |
772 | ||
773 | class WXDLLEXPORT wxHScrolledWindow : public wxPanel, | |
774 | public wxVarHScrollHelper | |
775 | { | |
776 | public: | |
777 | // constructors and such | |
778 | // --------------------- | |
779 | ||
780 | // default ctor, you must call Create() later | |
781 | wxHScrolledWindow() : wxVarHScrollHelper(this) { } | |
782 | ||
783 | // normal ctor, no need to call Create() after this one | |
784 | // | |
785 | // note that wxHSCROLL is always automatically added to our style, there is | |
786 | // no need to specify it explicitly | |
787 | wxHScrolledWindow(wxWindow *parent, | |
788 | wxWindowID id = wxID_ANY, | |
789 | const wxPoint& pos = wxDefaultPosition, | |
790 | const wxSize& size = wxDefaultSize, | |
791 | long style = 0, | |
792 | const wxString& name = wxPanelNameStr) | |
793 | : wxVarHScrollHelper(this) | |
794 | { | |
795 | (void)Create(parent, id, pos, size, style, name); | |
796 | } | |
797 | ||
798 | // same as the previous ctor but returns status code: true if ok | |
799 | // | |
800 | // just as with the ctor above, wxHSCROLL style is always used, there is no | |
801 | // need to specify it | |
802 | bool Create(wxWindow *parent, | |
803 | wxWindowID id = wxID_ANY, | |
804 | const wxPoint& pos = wxDefaultPosition, | |
805 | const wxSize& size = wxDefaultSize, | |
806 | long style = 0, | |
807 | const wxString& name = wxPanelNameStr) | |
808 | { | |
809 | return wxPanel::Create(parent, id, pos, size, style | wxHSCROLL, name); | |
810 | } | |
811 | ||
812 | // Make sure we prefer our version of HitTest rather than wxWindow's | |
813 | int HitTest(wxCoord x, wxCoord WXUNUSED(y)) const | |
814 | { return wxVarHScrollHelper::HitTest(x); } | |
815 | int HitTest(const wxPoint& pt) const | |
816 | { return HitTest(pt.x, pt.y); } | |
817 | ||
818 | WX_FORWARD_TO_VAR_SCROLL_HELPER() | |
819 | ||
820 | #ifdef __WXMAC__ | |
821 | protected: | |
822 | virtual void UpdateMacScrollWindow() { Update(); } | |
823 | #endif // __WXMAC__ | |
824 | ||
825 | private: | |
826 | DECLARE_NO_COPY_CLASS(wxHScrolledWindow) | |
827 | DECLARE_ABSTRACT_CLASS(wxHScrolledWindow) | |
828 | }; | |
829 | ||
830 | ||
831 | ||
832 | // =========================================================================== | |
833 | // wxHVScrolledWindow | |
834 | // =========================================================================== | |
835 | ||
836 | // This window inherits all functionality of both vertical and horizontal | |
837 | // scrolled windows automatically handling everything needed to scroll both | |
838 | // axis simultaneously. | |
839 | ||
840 | class WXDLLEXPORT wxHVScrolledWindow : public wxPanel, | |
841 | public wxVarHVScrollHelper | |
842 | { | |
843 | public: | |
844 | // constructors and such | |
845 | // --------------------- | |
846 | ||
847 | // default ctor, you must call Create() later | |
848 | wxHVScrolledWindow() | |
849 | : wxPanel(), | |
850 | wxVarHVScrollHelper(this) { } | |
851 | ||
852 | // normal ctor, no need to call Create() after this one | |
853 | // | |
854 | // note that wxVSCROLL and wxHSCROLL are always automatically added to our | |
855 | // style, there is no need to specify them explicitly | |
856 | wxHVScrolledWindow(wxWindow *parent, | |
857 | wxWindowID id = wxID_ANY, | |
858 | const wxPoint& pos = wxDefaultPosition, | |
859 | const wxSize& size = wxDefaultSize, | |
860 | long style = 0, | |
861 | const wxString& name = wxPanelNameStr) | |
862 | : wxPanel(), | |
863 | wxVarHVScrollHelper(this) | |
864 | { | |
865 | (void)Create(parent, id, pos, size, style, name); | |
866 | } | |
867 | ||
868 | // same as the previous ctor but returns status code: true if ok | |
869 | // | |
870 | // just as with the ctor above, wxVSCROLL and wxHSCROLL styles are always | |
871 | // used, there is no need to specify them | |
872 | bool Create(wxWindow *parent, | |
873 | wxWindowID id = wxID_ANY, | |
874 | const wxPoint& pos = wxDefaultPosition, | |
875 | const wxSize& size = wxDefaultSize, | |
876 | long style = 0, | |
877 | const wxString& name = wxPanelNameStr) | |
878 | { | |
879 | return wxPanel::Create(parent, id, pos, size, | |
880 | style | wxVSCROLL | wxHSCROLL, name); | |
881 | } | |
882 | ||
883 | // Make sure we prefer our version of HitTest rather than wxWindow's | |
884 | wxPosition HitTest(wxCoord x, wxCoord y) const | |
885 | { return wxVarHVScrollHelper::HitTest(x, y); } | |
886 | wxPosition HitTest(const wxPoint &pt) const | |
887 | { return HitTest(pt.x, pt.y); } | |
888 | ||
889 | WX_FORWARD_TO_VAR_SCROLL_HELPER() | |
890 | ||
891 | #ifdef __WXMAC__ | |
892 | protected: | |
893 | virtual void UpdateMacScrollWindow() { Update(); } | |
894 | #endif // __WXMAC__ | |
895 | ||
896 | private: | |
897 | DECLARE_NO_COPY_CLASS(wxHVScrolledWindow) | |
898 | DECLARE_ABSTRACT_CLASS(wxHVScrolledWindow) | |
899 | }; | |
900 | ||
cf7d6329 VZ |
901 | #endif // _WX_VSCROLL_H_ |
902 |