|
1
|
1 // Windows Template Library - WTL version 10.0
|
|
|
2 // Copyright (C) Microsoft Corporation, WTL Team. All rights reserved.
|
|
|
3 //
|
|
|
4 // This file is a part of the Windows Template Library.
|
|
|
5 // The use and distribution terms for this software are covered by the
|
|
|
6 // Microsoft Public License (http://opensource.org/licenses/MS-PL)
|
|
|
7 // which can be found in the file MS-PL.txt at the root folder.
|
|
|
8
|
|
|
9 #ifndef __ATLSCRL_H__
|
|
|
10 #define __ATLSCRL_H__
|
|
|
11
|
|
|
12 #pragma once
|
|
|
13
|
|
|
14 #ifndef __ATLAPP_H__
|
|
|
15 #error atlscrl.h requires atlapp.h to be included first
|
|
|
16 #endif
|
|
|
17
|
|
|
18 #ifndef __ATLWIN_H__
|
|
|
19 #error atlscrl.h requires atlwin.h to be included first
|
|
|
20 #endif
|
|
|
21
|
|
|
22
|
|
|
23 ///////////////////////////////////////////////////////////////////////////////
|
|
|
24 // Classes in this file:
|
|
|
25 //
|
|
|
26 // CScrollImpl<T>
|
|
|
27 // CScrollWindowImpl<T, TBase, TWinTraits>
|
|
|
28 // CMapScrollImpl<T>
|
|
|
29 // CMapScrollWindowImpl<T, TBase, TWinTraits>
|
|
|
30 // CFSBWindowT<TBase>
|
|
|
31 // CZoomScrollImpl<T>
|
|
|
32 // CZoomScrollWindowImpl<T, TBase, TWinTraits>
|
|
|
33 // CScrollContainerImpl<T, TBase, TWinTraits>
|
|
|
34 // CScrollContainer
|
|
|
35
|
|
|
36 namespace WTL
|
|
|
37 {
|
|
|
38
|
|
|
39 ///////////////////////////////////////////////////////////////////////////////
|
|
|
40 // CScrollImpl - Provides scrolling support to any window
|
|
|
41
|
|
|
42 // Scroll extended styles
|
|
|
43 #define SCRL_SCROLLCHILDREN 0x00000001
|
|
|
44 #define SCRL_ERASEBACKGROUND 0x00000002
|
|
|
45 #define SCRL_NOTHUMBTRACKING 0x00000004
|
|
|
46 #define SCRL_SMOOTHSCROLL 0x00000008
|
|
|
47 #define SCRL_DISABLENOSCROLLV 0x00000010
|
|
|
48 #define SCRL_DISABLENOSCROLLH 0x00000020
|
|
|
49 #define SCRL_DISABLENOSCROLL (SCRL_DISABLENOSCROLLV | SCRL_DISABLENOSCROLLH)
|
|
|
50
|
|
|
51
|
|
|
52 template <class T>
|
|
|
53 class CScrollImpl
|
|
|
54 {
|
|
|
55 public:
|
|
|
56 enum { uSCROLL_FLAGS = SW_INVALIDATE };
|
|
|
57
|
|
|
58 POINT m_ptOffset;
|
|
|
59 SIZE m_sizeAll;
|
|
|
60 SIZE m_sizeLine;
|
|
|
61 SIZE m_sizePage;
|
|
|
62 SIZE m_sizeClient;
|
|
|
63 int m_zDelta; // current wheel value
|
|
|
64 int m_nWheelLines; // number of lines to scroll on wheel
|
|
|
65 int m_zHDelta; // current horizontal wheel value
|
|
|
66 int m_nHWheelChars; // number of chars to scroll on horizontal wheel
|
|
|
67 UINT m_uScrollFlags;
|
|
|
68 DWORD m_dwExtendedStyle; // scroll specific extended styles
|
|
|
69
|
|
|
70 // Constructor
|
|
|
71 CScrollImpl() : m_zDelta(0), m_nWheelLines(3),
|
|
|
72 m_zHDelta(0), m_nHWheelChars(3),
|
|
|
73 m_uScrollFlags(0U), m_dwExtendedStyle(0)
|
|
|
74 {
|
|
|
75 m_ptOffset.x = 0;
|
|
|
76 m_ptOffset.y = 0;
|
|
|
77 m_sizeAll.cx = 0;
|
|
|
78 m_sizeAll.cy = 0;
|
|
|
79 m_sizePage.cx = 0;
|
|
|
80 m_sizePage.cy = 0;
|
|
|
81 m_sizeLine.cx = 0;
|
|
|
82 m_sizeLine.cy = 0;
|
|
|
83 m_sizeClient.cx = 0;
|
|
|
84 m_sizeClient.cy = 0;
|
|
|
85
|
|
|
86 SetScrollExtendedStyle(SCRL_SCROLLCHILDREN | SCRL_ERASEBACKGROUND);
|
|
|
87 }
|
|
|
88
|
|
|
89 // Attributes & Operations
|
|
|
90 DWORD GetScrollExtendedStyle() const
|
|
|
91 {
|
|
|
92 return m_dwExtendedStyle;
|
|
|
93 }
|
|
|
94
|
|
|
95 DWORD SetScrollExtendedStyle(DWORD dwExtendedStyle, DWORD dwMask = 0)
|
|
|
96 {
|
|
|
97 DWORD dwPrevStyle = m_dwExtendedStyle;
|
|
|
98 if(dwMask == 0)
|
|
|
99 m_dwExtendedStyle = dwExtendedStyle;
|
|
|
100 else
|
|
|
101 m_dwExtendedStyle = (m_dwExtendedStyle & ~dwMask) | (dwExtendedStyle & dwMask);
|
|
|
102 // cache scroll flags
|
|
|
103 T* pT = static_cast<T*>(this);
|
|
|
104 (void)pT; // avoid level 4 warning
|
|
|
105 m_uScrollFlags = pT->uSCROLL_FLAGS | (IsScrollingChildren() ? SW_SCROLLCHILDREN : 0) | (IsErasingBackground() ? SW_ERASE : 0);
|
|
|
106 m_uScrollFlags |= (IsSmoothScroll() ? SW_SMOOTHSCROLL : 0);
|
|
|
107 return dwPrevStyle;
|
|
|
108 }
|
|
|
109
|
|
|
110 // offset operations
|
|
|
111 void SetScrollOffset(int x, int y, BOOL bRedraw = TRUE)
|
|
|
112 {
|
|
|
113 T* pT = static_cast<T*>(this);
|
|
|
114 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
115
|
|
|
116 pT->AdjustScrollOffset(x, y);
|
|
|
117
|
|
|
118 int dx = m_ptOffset.x - x;
|
|
|
119 int dy = m_ptOffset.y - y;
|
|
|
120 m_ptOffset.x = x;
|
|
|
121 m_ptOffset.y = y;
|
|
|
122
|
|
|
123 // block: set horizontal scroll bar
|
|
|
124 {
|
|
|
125 SCROLLINFO si = { sizeof(SCROLLINFO) };
|
|
|
126 si.fMask = SIF_POS;
|
|
|
127 if((m_dwExtendedStyle & SCRL_DISABLENOSCROLLH) != 0)
|
|
|
128 si.fMask |= SIF_DISABLENOSCROLL;
|
|
|
129 si.nPos = m_ptOffset.x;
|
|
|
130 pT->SetScrollInfo(SB_HORZ, &si, bRedraw);
|
|
|
131 }
|
|
|
132
|
|
|
133 // block: set vertical scroll bar
|
|
|
134 {
|
|
|
135 SCROLLINFO si = { sizeof(SCROLLINFO) };
|
|
|
136 si.fMask = SIF_POS;
|
|
|
137 if((m_dwExtendedStyle & SCRL_DISABLENOSCROLLV) != 0)
|
|
|
138 si.fMask |= SIF_DISABLENOSCROLL;
|
|
|
139 si.nPos = m_ptOffset.y;
|
|
|
140 pT->SetScrollInfo(SB_VERT, &si, bRedraw);
|
|
|
141 }
|
|
|
142
|
|
|
143 // Move all children if needed
|
|
|
144 if(IsScrollingChildren() && ((dx != 0) || (dy != 0)))
|
|
|
145 {
|
|
|
146 for(HWND hWndChild = ::GetWindow(pT->m_hWnd, GW_CHILD); hWndChild != NULL; hWndChild = ::GetWindow(hWndChild, GW_HWNDNEXT))
|
|
|
147 {
|
|
|
148 RECT rect = {};
|
|
|
149 ::GetWindowRect(hWndChild, &rect);
|
|
|
150 ::MapWindowPoints(NULL, pT->m_hWnd, (LPPOINT)&rect, 1);
|
|
|
151 ::SetWindowPos(hWndChild, NULL, rect.left + dx, rect.top + dy, 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
|
|
|
152 }
|
|
|
153 }
|
|
|
154
|
|
|
155 if(bRedraw)
|
|
|
156 pT->Invalidate();
|
|
|
157 }
|
|
|
158
|
|
|
159 void SetScrollOffset(POINT ptOffset, BOOL bRedraw = TRUE)
|
|
|
160 {
|
|
|
161 SetScrollOffset(ptOffset.x, ptOffset.y, bRedraw);
|
|
|
162 }
|
|
|
163
|
|
|
164 void GetScrollOffset(POINT& ptOffset) const
|
|
|
165 {
|
|
|
166 ptOffset = m_ptOffset;
|
|
|
167 }
|
|
|
168
|
|
|
169 // size operations
|
|
|
170 void SetScrollSize(int cx, int cy, BOOL bRedraw = TRUE, bool bResetOffset = true)
|
|
|
171 {
|
|
|
172 T* pT = static_cast<T*>(this);
|
|
|
173 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
174
|
|
|
175 m_sizeAll.cx = cx;
|
|
|
176 m_sizeAll.cy = cy;
|
|
|
177
|
|
|
178 int x = 0;
|
|
|
179 int y = 0;
|
|
|
180 if(!bResetOffset)
|
|
|
181 {
|
|
|
182 x = m_ptOffset.x;
|
|
|
183 y = m_ptOffset.y;
|
|
|
184 pT->AdjustScrollOffset(x, y);
|
|
|
185 }
|
|
|
186
|
|
|
187 int dx = m_ptOffset.x - x;
|
|
|
188 int dy = m_ptOffset.y - y;
|
|
|
189 m_ptOffset.x = x;
|
|
|
190 m_ptOffset.y = y;
|
|
|
191
|
|
|
192 // block: set horizontal scroll bar
|
|
|
193 {
|
|
|
194 SCROLLINFO si = { sizeof(SCROLLINFO) };
|
|
|
195 si.fMask = SIF_PAGE | SIF_RANGE | SIF_POS;
|
|
|
196 if((m_dwExtendedStyle & SCRL_DISABLENOSCROLLH) != 0)
|
|
|
197 si.fMask |= SIF_DISABLENOSCROLL;
|
|
|
198 si.nMin = 0;
|
|
|
199 si.nMax = m_sizeAll.cx - 1;
|
|
|
200 si.nPage = m_sizeClient.cx;
|
|
|
201 si.nPos = m_ptOffset.x;
|
|
|
202 pT->SetScrollInfo(SB_HORZ, &si, bRedraw);
|
|
|
203 }
|
|
|
204
|
|
|
205 // block: set vertical scroll bar
|
|
|
206 {
|
|
|
207 SCROLLINFO si = { sizeof(SCROLLINFO) };
|
|
|
208 si.fMask = SIF_PAGE | SIF_RANGE | SIF_POS;
|
|
|
209 if((m_dwExtendedStyle & SCRL_DISABLENOSCROLLV) != 0)
|
|
|
210 si.fMask |= SIF_DISABLENOSCROLL;
|
|
|
211 si.nMin = 0;
|
|
|
212 si.nMax = m_sizeAll.cy - 1;
|
|
|
213 si.nPage = m_sizeClient.cy;
|
|
|
214 si.nPos = m_ptOffset.y;
|
|
|
215 pT->SetScrollInfo(SB_VERT, &si, bRedraw);
|
|
|
216 }
|
|
|
217
|
|
|
218 // Move all children if needed
|
|
|
219 if(IsScrollingChildren() && ((dx != 0) || (dy != 0)))
|
|
|
220 {
|
|
|
221 for(HWND hWndChild = ::GetWindow(pT->m_hWnd, GW_CHILD); hWndChild != NULL; hWndChild = ::GetWindow(hWndChild, GW_HWNDNEXT))
|
|
|
222 {
|
|
|
223 RECT rect = {};
|
|
|
224 ::GetWindowRect(hWndChild, &rect);
|
|
|
225 ::MapWindowPoints(NULL, pT->m_hWnd, (LPPOINT)&rect, 1);
|
|
|
226 ::SetWindowPos(hWndChild, NULL, rect.left + dx, rect.top + dy, 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
|
|
|
227 }
|
|
|
228 }
|
|
|
229
|
|
|
230 SetScrollLine(0, 0);
|
|
|
231 SetScrollPage(0, 0);
|
|
|
232
|
|
|
233 if(bRedraw)
|
|
|
234 pT->Invalidate();
|
|
|
235 }
|
|
|
236
|
|
|
237 void SetScrollSize(SIZE size, BOOL bRedraw = TRUE, bool bResetOffset = true)
|
|
|
238 {
|
|
|
239 SetScrollSize(size.cx, size.cy, bRedraw, bResetOffset);
|
|
|
240 }
|
|
|
241
|
|
|
242 void GetScrollSize(SIZE& sizeWnd) const
|
|
|
243 {
|
|
|
244 sizeWnd = m_sizeAll;
|
|
|
245 }
|
|
|
246
|
|
|
247 // line operations
|
|
|
248 void SetScrollLine(int cxLine, int cyLine)
|
|
|
249 {
|
|
|
250 ATLASSERT((cxLine >= 0) && (cyLine >= 0));
|
|
|
251 ATLASSERT((m_sizeAll.cx != 0) && (m_sizeAll.cy != 0));
|
|
|
252
|
|
|
253 m_sizeLine.cx = T::CalcLineOrPage(cxLine, m_sizeAll.cx, 100);
|
|
|
254 m_sizeLine.cy = T::CalcLineOrPage(cyLine, m_sizeAll.cy, 100);
|
|
|
255 }
|
|
|
256
|
|
|
257 void SetScrollLine(SIZE sizeLine)
|
|
|
258 {
|
|
|
259 SetScrollLine(sizeLine.cx, sizeLine.cy);
|
|
|
260 }
|
|
|
261
|
|
|
262 void GetScrollLine(SIZE& sizeLine) const
|
|
|
263 {
|
|
|
264 sizeLine = m_sizeLine;
|
|
|
265 }
|
|
|
266
|
|
|
267 // page operations
|
|
|
268 void SetScrollPage(int cxPage, int cyPage)
|
|
|
269 {
|
|
|
270 ATLASSERT((cxPage >= 0) && (cyPage >= 0));
|
|
|
271 ATLASSERT((m_sizeAll.cx != 0) && (m_sizeAll.cy != 0));
|
|
|
272
|
|
|
273 m_sizePage.cx = T::CalcLineOrPage(cxPage, m_sizeAll.cx, 10);
|
|
|
274 m_sizePage.cy = T::CalcLineOrPage(cyPage, m_sizeAll.cy, 10);
|
|
|
275 }
|
|
|
276
|
|
|
277 void SetScrollPage(SIZE sizePage)
|
|
|
278 {
|
|
|
279 SetScrollPage(sizePage.cx, sizePage.cy);
|
|
|
280 }
|
|
|
281
|
|
|
282 void GetScrollPage(SIZE& sizePage) const
|
|
|
283 {
|
|
|
284 sizePage = m_sizePage;
|
|
|
285 }
|
|
|
286
|
|
|
287 // commands
|
|
|
288 void ScrollLineDown()
|
|
|
289 {
|
|
|
290 T* pT = static_cast<T*>(this);
|
|
|
291 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
292 pT->DoScroll(SB_VERT, SB_LINEDOWN, (int&)m_ptOffset.y, m_sizeAll.cy, m_sizePage.cy, m_sizeLine.cy);
|
|
|
293 }
|
|
|
294
|
|
|
295 void ScrollLineUp()
|
|
|
296 {
|
|
|
297 T* pT = static_cast<T*>(this);
|
|
|
298 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
299 pT->DoScroll(SB_VERT, SB_LINEUP, (int&)m_ptOffset.y, m_sizeAll.cy, m_sizePage.cy, m_sizeLine.cy);
|
|
|
300 }
|
|
|
301
|
|
|
302 void ScrollPageDown()
|
|
|
303 {
|
|
|
304 T* pT = static_cast<T*>(this);
|
|
|
305 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
306 pT->DoScroll(SB_VERT, SB_PAGEDOWN, (int&)m_ptOffset.y, m_sizeAll.cy, m_sizePage.cy, m_sizeLine.cy);
|
|
|
307 }
|
|
|
308
|
|
|
309 void ScrollPageUp()
|
|
|
310 {
|
|
|
311 T* pT = static_cast<T*>(this);
|
|
|
312 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
313 pT->DoScroll(SB_VERT, SB_PAGEUP, (int&)m_ptOffset.y, m_sizeAll.cy, m_sizePage.cy, m_sizeLine.cy);
|
|
|
314 }
|
|
|
315
|
|
|
316 void ScrollTop()
|
|
|
317 {
|
|
|
318 T* pT = static_cast<T*>(this);
|
|
|
319 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
320 pT->DoScroll(SB_VERT, SB_TOP, (int&)m_ptOffset.y, m_sizeAll.cy, m_sizePage.cy, m_sizeLine.cy);
|
|
|
321 }
|
|
|
322
|
|
|
323 void ScrollBottom()
|
|
|
324 {
|
|
|
325 T* pT = static_cast<T*>(this);
|
|
|
326 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
327 pT->DoScroll(SB_VERT, SB_BOTTOM, (int&)m_ptOffset.y, m_sizeAll.cy, m_sizePage.cy, m_sizeLine.cy);
|
|
|
328 }
|
|
|
329
|
|
|
330 void ScrollLineRight()
|
|
|
331 {
|
|
|
332 T* pT = static_cast<T*>(this);
|
|
|
333 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
334 pT->DoScroll(SB_HORZ, SB_LINEDOWN, (int&)m_ptOffset.x, m_sizeAll.cx, m_sizePage.cx, m_sizeLine.cx);
|
|
|
335 }
|
|
|
336
|
|
|
337 void ScrollLineLeft()
|
|
|
338 {
|
|
|
339 T* pT = static_cast<T*>(this);
|
|
|
340 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
341 pT->DoScroll(SB_HORZ, SB_LINEUP, (int&)m_ptOffset.x, m_sizeAll.cx, m_sizePage.cx, m_sizeLine.cx);
|
|
|
342 }
|
|
|
343
|
|
|
344 void ScrollPageRight()
|
|
|
345 {
|
|
|
346 T* pT = static_cast<T*>(this);
|
|
|
347 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
348 pT->DoScroll(SB_HORZ, SB_PAGEDOWN, (int&)m_ptOffset.x, m_sizeAll.cx, m_sizePage.cx, m_sizeLine.cx);
|
|
|
349 }
|
|
|
350
|
|
|
351 void ScrollPageLeft()
|
|
|
352 {
|
|
|
353 T* pT = static_cast<T*>(this);
|
|
|
354 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
355 pT->DoScroll(SB_HORZ, SB_PAGEUP, (int&)m_ptOffset.x, m_sizeAll.cx, m_sizePage.cx, m_sizeLine.cx);
|
|
|
356 }
|
|
|
357
|
|
|
358 void ScrollAllLeft()
|
|
|
359 {
|
|
|
360 T* pT = static_cast<T*>(this);
|
|
|
361 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
362 pT->DoScroll(SB_HORZ, SB_TOP, (int&)m_ptOffset.x, m_sizeAll.cx, m_sizePage.cx, m_sizeLine.cx);
|
|
|
363 }
|
|
|
364
|
|
|
365 void ScrollAllRight()
|
|
|
366 {
|
|
|
367 T* pT = static_cast<T*>(this);
|
|
|
368 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
369 pT->DoScroll(SB_HORZ, SB_BOTTOM, (int&)m_ptOffset.x, m_sizeAll.cx, m_sizePage.cx, m_sizeLine.cx);
|
|
|
370 }
|
|
|
371
|
|
|
372 // scroll to make point/view/window visible
|
|
|
373 void ScrollToView(POINT pt)
|
|
|
374 {
|
|
|
375 T* pT = static_cast<T*>(this);
|
|
|
376 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
377 RECT rect = { pt.x, pt.y, pt.x, pt.y };
|
|
|
378 pT->ScrollToView(rect);
|
|
|
379 }
|
|
|
380
|
|
|
381 void ScrollToView(RECT& rect)
|
|
|
382 {
|
|
|
383 T* pT = static_cast<T*>(this);
|
|
|
384 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
385
|
|
|
386 RECT rcClient = {};
|
|
|
387 pT->GetClientRect(&rcClient);
|
|
|
388
|
|
|
389 int x = m_ptOffset.x;
|
|
|
390 if(rect.left < m_ptOffset.x)
|
|
|
391 x = rect.left;
|
|
|
392 else if(rect.right > (m_ptOffset.x + rcClient.right))
|
|
|
393 x = rect.right - rcClient.right;
|
|
|
394
|
|
|
395 int y = m_ptOffset.y;
|
|
|
396 if(rect.top < m_ptOffset.y)
|
|
|
397 y = rect.top;
|
|
|
398 else if(rect.bottom > (m_ptOffset.y + rcClient.bottom))
|
|
|
399 y = rect.bottom - rcClient.bottom;
|
|
|
400
|
|
|
401 SetScrollOffset(x, y);
|
|
|
402 }
|
|
|
403
|
|
|
404 void ScrollToView(HWND hWnd)
|
|
|
405 {
|
|
|
406 T* pT = static_cast<T*>(this);
|
|
|
407 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
408
|
|
|
409 RECT rect = {};
|
|
|
410 ::GetWindowRect(hWnd, &rect);
|
|
|
411 ::OffsetRect(&rect, m_ptOffset.x, m_ptOffset.y);
|
|
|
412 ::MapWindowPoints(NULL, pT->m_hWnd, (LPPOINT)&rect, 2);
|
|
|
413 ScrollToView(rect);
|
|
|
414 }
|
|
|
415
|
|
|
416 BEGIN_MSG_MAP(CScrollImpl)
|
|
|
417 MESSAGE_HANDLER(WM_CREATE, OnCreate)
|
|
|
418 MESSAGE_HANDLER(WM_VSCROLL, OnVScroll)
|
|
|
419 MESSAGE_HANDLER(WM_HSCROLL, OnHScroll)
|
|
|
420 MESSAGE_HANDLER(WM_MOUSEWHEEL, OnMouseWheel)
|
|
|
421 MESSAGE_HANDLER(WM_MOUSEHWHEEL, OnMouseHWheel)
|
|
|
422 MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange)
|
|
|
423 MESSAGE_HANDLER(WM_SIZE, OnSize)
|
|
|
424 MESSAGE_HANDLER(WM_PAINT, OnPaint)
|
|
|
425 MESSAGE_HANDLER(WM_PRINTCLIENT, OnPaint)
|
|
|
426 // standard scroll commands
|
|
|
427 ALT_MSG_MAP(1)
|
|
|
428 COMMAND_ID_HANDLER(ID_SCROLL_UP, OnScrollUp)
|
|
|
429 COMMAND_ID_HANDLER(ID_SCROLL_DOWN, OnScrollDown)
|
|
|
430 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_UP, OnScrollPageUp)
|
|
|
431 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_DOWN, OnScrollPageDown)
|
|
|
432 COMMAND_ID_HANDLER(ID_SCROLL_TOP, OnScrollTop)
|
|
|
433 COMMAND_ID_HANDLER(ID_SCROLL_BOTTOM, OnScrollBottom)
|
|
|
434 COMMAND_ID_HANDLER(ID_SCROLL_LEFT, OnScrollLeft)
|
|
|
435 COMMAND_ID_HANDLER(ID_SCROLL_RIGHT, OnScrollRight)
|
|
|
436 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_LEFT, OnScrollPageLeft)
|
|
|
437 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_RIGHT, OnScrollPageRight)
|
|
|
438 COMMAND_ID_HANDLER(ID_SCROLL_ALL_LEFT, OnScrollAllLeft)
|
|
|
439 COMMAND_ID_HANDLER(ID_SCROLL_ALL_RIGHT, OnScrollAllRight)
|
|
|
440 END_MSG_MAP()
|
|
|
441
|
|
|
442 LRESULT OnCreate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
|
|
|
443 {
|
|
|
444 T* pT = static_cast<T*>(this);
|
|
|
445 pT->GetSystemSettings();
|
|
|
446
|
|
|
447 bHandled = FALSE;
|
|
|
448 return 1;
|
|
|
449 }
|
|
|
450
|
|
|
451 LRESULT OnVScroll(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
|
|
|
452 {
|
|
|
453 T* pT = static_cast<T*>(this);
|
|
|
454 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
455 pT->DoScroll(SB_VERT, (int)(short)LOWORD(wParam), (int&)m_ptOffset.y, m_sizeAll.cy, m_sizePage.cy, m_sizeLine.cy);
|
|
|
456 return 0;
|
|
|
457 }
|
|
|
458
|
|
|
459 LRESULT OnHScroll(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
|
|
|
460 {
|
|
|
461 T* pT = static_cast<T*>(this);
|
|
|
462 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
463 pT->DoScroll(SB_HORZ, (int)(short)LOWORD(wParam), (int&)m_ptOffset.x, m_sizeAll.cx, m_sizePage.cx, m_sizeLine.cx);
|
|
|
464 return 0;
|
|
|
465 }
|
|
|
466
|
|
|
467 LRESULT OnMouseWheel(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
|
|
|
468 {
|
|
|
469 T* pT = static_cast<T*>(this);
|
|
|
470 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
471
|
|
|
472 int zDelta = (int)GET_WHEEL_DELTA_WPARAM(wParam);
|
|
|
473 int nScrollCode = (m_nWheelLines == WHEEL_PAGESCROLL) ? ((zDelta > 0) ? SB_PAGEUP : SB_PAGEDOWN) : ((zDelta > 0) ? SB_LINEUP : SB_LINEDOWN);
|
|
|
474 m_zDelta += zDelta; // cumulative
|
|
|
475 int zTotal = (m_nWheelLines == WHEEL_PAGESCROLL) ? abs(m_zDelta) : abs(m_zDelta) * m_nWheelLines;
|
|
|
476 if(m_sizeAll.cy > m_sizeClient.cy)
|
|
|
477 {
|
|
|
478 for(int i = 0; i < zTotal; i += WHEEL_DELTA)
|
|
|
479 {
|
|
|
480 pT->DoScroll(SB_VERT, nScrollCode, (int&)m_ptOffset.y, m_sizeAll.cy, m_sizePage.cy, m_sizeLine.cy);
|
|
|
481 pT->UpdateWindow();
|
|
|
482 }
|
|
|
483 }
|
|
|
484 else if(m_sizeAll.cx > m_sizeClient.cx) // can't scroll vertically, scroll horizontally
|
|
|
485 {
|
|
|
486 for(int i = 0; i < zTotal; i += WHEEL_DELTA)
|
|
|
487 {
|
|
|
488 pT->DoScroll(SB_HORZ, nScrollCode, (int&)m_ptOffset.x, m_sizeAll.cx, m_sizePage.cx, m_sizeLine.cx);
|
|
|
489 pT->UpdateWindow();
|
|
|
490 }
|
|
|
491 }
|
|
|
492 m_zDelta %= WHEEL_DELTA;
|
|
|
493
|
|
|
494 return 0;
|
|
|
495 }
|
|
|
496
|
|
|
497 LRESULT OnMouseHWheel(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
|
|
|
498 {
|
|
|
499 T* pT = static_cast<T*>(this);
|
|
|
500 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
501
|
|
|
502 int zDelta = (int)GET_WHEEL_DELTA_WPARAM(wParam);
|
|
|
503 int nScrollCode = (m_nHWheelChars == WHEEL_PAGESCROLL) ? ((zDelta > 0) ? SB_PAGERIGHT : SB_PAGELEFT) : ((zDelta > 0) ? SB_LINERIGHT : SB_LINELEFT);
|
|
|
504 m_zHDelta += zDelta; // cumulative
|
|
|
505 int zTotal = (m_nHWheelChars == WHEEL_PAGESCROLL) ? abs(m_zHDelta) : abs(m_zHDelta) * m_nHWheelChars;
|
|
|
506 if(m_sizeAll.cx > m_sizeClient.cx)
|
|
|
507 {
|
|
|
508 for(int i = 0; i < zTotal; i += WHEEL_DELTA)
|
|
|
509 {
|
|
|
510 pT->DoScroll(SB_HORZ, nScrollCode, (int&)m_ptOffset.x, m_sizeAll.cx, m_sizePage.cx, m_sizeLine.cx);
|
|
|
511 pT->UpdateWindow();
|
|
|
512 }
|
|
|
513 }
|
|
|
514 m_zHDelta %= WHEEL_DELTA;
|
|
|
515
|
|
|
516 return 0;
|
|
|
517 }
|
|
|
518
|
|
|
519 LRESULT OnSettingChange(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
|
|
|
520 {
|
|
|
521 GetSystemSettings();
|
|
|
522 return 0;
|
|
|
523 }
|
|
|
524
|
|
|
525 LRESULT OnSize(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
|
|
|
526 {
|
|
|
527 T* pT = static_cast<T*>(this);
|
|
|
528 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
529
|
|
|
530 pT->DoSize(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
|
|
|
531
|
|
|
532 bHandled = FALSE;
|
|
|
533 return 1;
|
|
|
534 }
|
|
|
535
|
|
|
536 LRESULT OnPaint(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
|
|
|
537 {
|
|
|
538 T* pT = static_cast<T*>(this);
|
|
|
539 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
540 if(wParam != NULL)
|
|
|
541 {
|
|
|
542 CDCHandle dc = (HDC)wParam;
|
|
|
543 POINT ptViewportOrg = { 0, 0 };
|
|
|
544 dc.SetViewportOrg(-m_ptOffset.x, -m_ptOffset.y, &ptViewportOrg);
|
|
|
545 pT->DoPaint(dc);
|
|
|
546 dc.SetViewportOrg(ptViewportOrg);
|
|
|
547 }
|
|
|
548 else
|
|
|
549 {
|
|
|
550 CPaintDC dc(pT->m_hWnd);
|
|
|
551 dc.SetViewportOrg(-m_ptOffset.x, -m_ptOffset.y);
|
|
|
552 pT->DoPaint(dc.m_hDC);
|
|
|
553 }
|
|
|
554 return 0;
|
|
|
555 }
|
|
|
556
|
|
|
557 // scrolling handlers
|
|
|
558 LRESULT OnScrollUp(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
|
|
|
559 {
|
|
|
560 ScrollLineUp();
|
|
|
561 return 0;
|
|
|
562 }
|
|
|
563
|
|
|
564 LRESULT OnScrollDown(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
|
|
|
565 {
|
|
|
566 ScrollLineDown();
|
|
|
567 return 0;
|
|
|
568 }
|
|
|
569
|
|
|
570 LRESULT OnScrollPageUp(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
|
|
|
571 {
|
|
|
572 ScrollPageUp();
|
|
|
573 return 0;
|
|
|
574 }
|
|
|
575
|
|
|
576 LRESULT OnScrollPageDown(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
|
|
|
577 {
|
|
|
578 ScrollPageDown();
|
|
|
579 return 0;
|
|
|
580 }
|
|
|
581
|
|
|
582 LRESULT OnScrollTop(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
|
|
|
583 {
|
|
|
584 ScrollTop();
|
|
|
585 return 0;
|
|
|
586 }
|
|
|
587
|
|
|
588 LRESULT OnScrollBottom(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
|
|
|
589 {
|
|
|
590 ScrollBottom();
|
|
|
591 return 0;
|
|
|
592 }
|
|
|
593
|
|
|
594 LRESULT OnScrollLeft(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
|
|
|
595 {
|
|
|
596 ScrollLineLeft();
|
|
|
597 return 0;
|
|
|
598 }
|
|
|
599
|
|
|
600 LRESULT OnScrollRight(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
|
|
|
601 {
|
|
|
602 ScrollLineRight();
|
|
|
603 return 0;
|
|
|
604 }
|
|
|
605
|
|
|
606 LRESULT OnScrollPageLeft(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
|
|
|
607 {
|
|
|
608 ScrollPageLeft();
|
|
|
609 return 0;
|
|
|
610 }
|
|
|
611
|
|
|
612 LRESULT OnScrollPageRight(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
|
|
|
613 {
|
|
|
614 ScrollPageRight();
|
|
|
615 return 0;
|
|
|
616 }
|
|
|
617
|
|
|
618 LRESULT OnScrollAllLeft(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
|
|
|
619 {
|
|
|
620 ScrollAllLeft();
|
|
|
621 return 0;
|
|
|
622 }
|
|
|
623
|
|
|
624 LRESULT OnScrollAllRight(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
|
|
|
625 {
|
|
|
626 ScrollAllRight();
|
|
|
627 return 0;
|
|
|
628 }
|
|
|
629
|
|
|
630 // Overrideables
|
|
|
631 void DoPaint(CDCHandle /*dc*/)
|
|
|
632 {
|
|
|
633 // must be implemented in a derived class
|
|
|
634 ATLASSERT(FALSE);
|
|
|
635 }
|
|
|
636
|
|
|
637 // Implementation
|
|
|
638 void DoSize(int cx, int cy)
|
|
|
639 {
|
|
|
640 m_sizeClient.cx = cx;
|
|
|
641 m_sizeClient.cy = cy;
|
|
|
642
|
|
|
643 T* pT = static_cast<T*>(this);
|
|
|
644
|
|
|
645 // block: set horizontal scroll bar
|
|
|
646 {
|
|
|
647 SCROLLINFO si = { sizeof(SCROLLINFO) };
|
|
|
648 si.fMask = SIF_PAGE | SIF_RANGE | SIF_POS;
|
|
|
649 si.nMin = 0;
|
|
|
650 si.nMax = m_sizeAll.cx - 1;
|
|
|
651 if((m_dwExtendedStyle & SCRL_DISABLENOSCROLLH) != 0)
|
|
|
652 si.fMask |= SIF_DISABLENOSCROLL;
|
|
|
653 si.nPage = m_sizeClient.cx;
|
|
|
654 si.nPos = m_ptOffset.x;
|
|
|
655 pT->SetScrollInfo(SB_HORZ, &si, TRUE);
|
|
|
656 }
|
|
|
657
|
|
|
658 // block: set vertical scroll bar
|
|
|
659 {
|
|
|
660 SCROLLINFO si = { sizeof(SCROLLINFO) };
|
|
|
661 si.fMask = SIF_PAGE | SIF_RANGE | SIF_POS;
|
|
|
662 si.nMin = 0;
|
|
|
663 si.nMax = m_sizeAll.cy - 1;
|
|
|
664 if((m_dwExtendedStyle & SCRL_DISABLENOSCROLLV) != 0)
|
|
|
665 si.fMask |= SIF_DISABLENOSCROLL;
|
|
|
666 si.nPage = m_sizeClient.cy;
|
|
|
667 si.nPos = m_ptOffset.y;
|
|
|
668 pT->SetScrollInfo(SB_VERT, &si, TRUE);
|
|
|
669 }
|
|
|
670
|
|
|
671 int x = m_ptOffset.x;
|
|
|
672 int y = m_ptOffset.y;
|
|
|
673 if(pT->AdjustScrollOffset(x, y))
|
|
|
674 {
|
|
|
675 // Children will be moved in SetScrollOffset, if needed
|
|
|
676 pT->ScrollWindowEx(m_ptOffset.x - x, m_ptOffset.y - y, (m_uScrollFlags & ~SCRL_SCROLLCHILDREN));
|
|
|
677 SetScrollOffset(x, y, FALSE);
|
|
|
678 }
|
|
|
679 }
|
|
|
680
|
|
|
681 void DoScroll(int nType, int nScrollCode, int& cxyOffset, int cxySizeAll, int cxySizePage, int cxySizeLine)
|
|
|
682 {
|
|
|
683 T* pT = static_cast<T*>(this);
|
|
|
684 RECT rect = {};
|
|
|
685 pT->GetClientRect(&rect);
|
|
|
686 int cxyClient = (nType == SB_VERT) ? rect.bottom : rect.right;
|
|
|
687 int cxyMax = cxySizeAll - cxyClient;
|
|
|
688
|
|
|
689 if(cxyMax < 0) // can't scroll, client area is bigger
|
|
|
690 return;
|
|
|
691
|
|
|
692 bool bUpdate = true;
|
|
|
693 int cxyScroll = 0;
|
|
|
694
|
|
|
695 switch(nScrollCode)
|
|
|
696 {
|
|
|
697 case SB_TOP: // top or all left
|
|
|
698 cxyScroll = cxyOffset;
|
|
|
699 cxyOffset = 0;
|
|
|
700 break;
|
|
|
701 case SB_BOTTOM: // bottom or all right
|
|
|
702 cxyScroll = cxyOffset - cxyMax;
|
|
|
703 cxyOffset = cxyMax;
|
|
|
704 break;
|
|
|
705 case SB_LINEUP: // line up or line left
|
|
|
706 if(cxyOffset >= cxySizeLine)
|
|
|
707 {
|
|
|
708 cxyScroll = cxySizeLine;
|
|
|
709 cxyOffset -= cxySizeLine;
|
|
|
710 }
|
|
|
711 else
|
|
|
712 {
|
|
|
713 cxyScroll = cxyOffset;
|
|
|
714 cxyOffset = 0;
|
|
|
715 }
|
|
|
716 break;
|
|
|
717 case SB_LINEDOWN: // line down or line right
|
|
|
718 if(cxyOffset < cxyMax - cxySizeLine)
|
|
|
719 {
|
|
|
720 cxyScroll = -cxySizeLine;
|
|
|
721 cxyOffset += cxySizeLine;
|
|
|
722 }
|
|
|
723 else
|
|
|
724 {
|
|
|
725 cxyScroll = cxyOffset - cxyMax;
|
|
|
726 cxyOffset = cxyMax;
|
|
|
727 }
|
|
|
728 break;
|
|
|
729 case SB_PAGEUP: // page up or page left
|
|
|
730 if(cxyOffset >= cxySizePage)
|
|
|
731 {
|
|
|
732 cxyScroll = cxySizePage;
|
|
|
733 cxyOffset -= cxySizePage;
|
|
|
734 }
|
|
|
735 else
|
|
|
736 {
|
|
|
737 cxyScroll = cxyOffset;
|
|
|
738 cxyOffset = 0;
|
|
|
739 }
|
|
|
740 break;
|
|
|
741 case SB_PAGEDOWN: // page down or page right
|
|
|
742 if(cxyOffset < cxyMax - cxySizePage)
|
|
|
743 {
|
|
|
744 cxyScroll = -cxySizePage;
|
|
|
745 cxyOffset += cxySizePage;
|
|
|
746 }
|
|
|
747 else
|
|
|
748 {
|
|
|
749 cxyScroll = cxyOffset - cxyMax;
|
|
|
750 cxyOffset = cxyMax;
|
|
|
751 }
|
|
|
752 break;
|
|
|
753 case SB_THUMBTRACK:
|
|
|
754 if(IsNoThumbTracking())
|
|
|
755 break;
|
|
|
756 // else fall through
|
|
|
757 case SB_THUMBPOSITION:
|
|
|
758 {
|
|
|
759 SCROLLINFO si = { sizeof(SCROLLINFO), SIF_TRACKPOS };
|
|
|
760 if(pT->GetScrollInfo(nType, &si))
|
|
|
761 {
|
|
|
762 cxyScroll = cxyOffset - si.nTrackPos;
|
|
|
763 cxyOffset = si.nTrackPos;
|
|
|
764 }
|
|
|
765 }
|
|
|
766 break;
|
|
|
767 case SB_ENDSCROLL:
|
|
|
768 default:
|
|
|
769 bUpdate = false;
|
|
|
770 break;
|
|
|
771 }
|
|
|
772
|
|
|
773 if(bUpdate && (cxyScroll != 0))
|
|
|
774 {
|
|
|
775 pT->SetScrollPos(nType, cxyOffset, TRUE);
|
|
|
776 if(nType == SB_VERT)
|
|
|
777 pT->ScrollWindowEx(0, cxyScroll, m_uScrollFlags);
|
|
|
778 else
|
|
|
779 pT->ScrollWindowEx(cxyScroll, 0, m_uScrollFlags);
|
|
|
780 }
|
|
|
781 }
|
|
|
782
|
|
|
783 static int CalcLineOrPage(int nVal, int nMax, int nDiv)
|
|
|
784 {
|
|
|
785 if(nVal == 0)
|
|
|
786 {
|
|
|
787 nVal = nMax / nDiv;
|
|
|
788 if(nVal < 1)
|
|
|
789 nVal = 1;
|
|
|
790 }
|
|
|
791 else if(nVal > nMax)
|
|
|
792 {
|
|
|
793 nVal = nMax;
|
|
|
794 }
|
|
|
795
|
|
|
796 return nVal;
|
|
|
797 }
|
|
|
798
|
|
|
799 bool AdjustScrollOffset(int& x, int& y)
|
|
|
800 {
|
|
|
801 int xOld = x;
|
|
|
802 int yOld = y;
|
|
|
803
|
|
|
804 int cxMax = m_sizeAll.cx - m_sizeClient.cx;
|
|
|
805 if(x > cxMax)
|
|
|
806 x = (cxMax >= 0) ? cxMax : 0;
|
|
|
807 else if(x < 0)
|
|
|
808 x = 0;
|
|
|
809
|
|
|
810 int cyMax = m_sizeAll.cy - m_sizeClient.cy;
|
|
|
811 if(y > cyMax)
|
|
|
812 y = (cyMax >= 0) ? cyMax : 0;
|
|
|
813 else if(y < 0)
|
|
|
814 y = 0;
|
|
|
815
|
|
|
816 return ((x != xOld) || (y != yOld));
|
|
|
817 }
|
|
|
818
|
|
|
819 void GetSystemSettings()
|
|
|
820 {
|
|
|
821 ::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &m_nWheelLines, 0);
|
|
|
822
|
|
|
823 #ifndef SPI_GETWHEELSCROLLCHARS
|
|
|
824 const UINT SPI_GETWHEELSCROLLCHARS = 0x006C;
|
|
|
825 #endif
|
|
|
826 ::SystemParametersInfo(SPI_GETWHEELSCROLLCHARS, 0, &m_nHWheelChars, 0);
|
|
|
827 }
|
|
|
828
|
|
|
829 bool IsScrollingChildren() const
|
|
|
830 {
|
|
|
831 return (m_dwExtendedStyle & SCRL_SCROLLCHILDREN) != 0;
|
|
|
832 }
|
|
|
833
|
|
|
834 bool IsErasingBackground() const
|
|
|
835 {
|
|
|
836 return (m_dwExtendedStyle & SCRL_ERASEBACKGROUND) != 0;
|
|
|
837 }
|
|
|
838
|
|
|
839 bool IsNoThumbTracking() const
|
|
|
840 {
|
|
|
841 return (m_dwExtendedStyle & SCRL_NOTHUMBTRACKING) != 0;
|
|
|
842 }
|
|
|
843
|
|
|
844 bool IsSmoothScroll() const
|
|
|
845 {
|
|
|
846 return (m_dwExtendedStyle & SCRL_SMOOTHSCROLL) != 0;
|
|
|
847 }
|
|
|
848 };
|
|
|
849
|
|
|
850
|
|
|
851 ///////////////////////////////////////////////////////////////////////////////
|
|
|
852 // CScrollWindowImpl - Implements a scrollable window
|
|
|
853
|
|
|
854 template <class T, class TBase = ATL::CWindow, class TWinTraits = ATL::CControlWinTraits>
|
|
|
855 class ATL_NO_VTABLE CScrollWindowImpl : public ATL::CWindowImpl<T, TBase, TWinTraits>, public CScrollImpl< T >
|
|
|
856 {
|
|
|
857 public:
|
|
|
858 BOOL SubclassWindow(HWND hWnd)
|
|
|
859 {
|
|
|
860 BOOL bRet = ATL::CWindowImpl< T, TBase, TWinTraits >::SubclassWindow(hWnd);
|
|
|
861 if(bRet != FALSE)
|
|
|
862 {
|
|
|
863 T* pT = static_cast<T*>(this);
|
|
|
864 pT->GetSystemSettings();
|
|
|
865
|
|
|
866 RECT rect = {};
|
|
|
867 this->GetClientRect(&rect);
|
|
|
868 pT->DoSize(rect.right, rect.bottom);
|
|
|
869 }
|
|
|
870
|
|
|
871 return bRet;
|
|
|
872 }
|
|
|
873
|
|
|
874 BEGIN_MSG_MAP(CScrollWindowImpl)
|
|
|
875 MESSAGE_HANDLER(WM_VSCROLL, CScrollImpl< T >::OnVScroll)
|
|
|
876 MESSAGE_HANDLER(WM_HSCROLL, CScrollImpl< T >::OnHScroll)
|
|
|
877 MESSAGE_HANDLER(WM_MOUSEWHEEL, CScrollImpl< T >::OnMouseWheel)
|
|
|
878 MESSAGE_HANDLER(WM_MOUSEHWHEEL, CScrollImpl< T >::OnMouseHWheel)
|
|
|
879 MESSAGE_HANDLER(WM_SETTINGCHANGE, CScrollImpl< T >::OnSettingChange)
|
|
|
880 MESSAGE_HANDLER(WM_SIZE, CScrollImpl< T >::OnSize)
|
|
|
881 MESSAGE_HANDLER(WM_PAINT, CScrollImpl< T >::OnPaint)
|
|
|
882 MESSAGE_HANDLER(WM_PRINTCLIENT, CScrollImpl< T >::OnPaint)
|
|
|
883 ALT_MSG_MAP(1)
|
|
|
884 COMMAND_ID_HANDLER(ID_SCROLL_UP, CScrollImpl< T >::OnScrollUp)
|
|
|
885 COMMAND_ID_HANDLER(ID_SCROLL_DOWN, CScrollImpl< T >::OnScrollDown)
|
|
|
886 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_UP, CScrollImpl< T >::OnScrollPageUp)
|
|
|
887 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_DOWN, CScrollImpl< T >::OnScrollPageDown)
|
|
|
888 COMMAND_ID_HANDLER(ID_SCROLL_TOP, CScrollImpl< T >::OnScrollTop)
|
|
|
889 COMMAND_ID_HANDLER(ID_SCROLL_BOTTOM, CScrollImpl< T >::OnScrollBottom)
|
|
|
890 COMMAND_ID_HANDLER(ID_SCROLL_LEFT, CScrollImpl< T >::OnScrollLeft)
|
|
|
891 COMMAND_ID_HANDLER(ID_SCROLL_RIGHT, CScrollImpl< T >::OnScrollRight)
|
|
|
892 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_LEFT, CScrollImpl< T >::OnScrollPageLeft)
|
|
|
893 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_RIGHT, CScrollImpl< T >::OnScrollPageRight)
|
|
|
894 COMMAND_ID_HANDLER(ID_SCROLL_ALL_LEFT, CScrollImpl< T >::OnScrollAllLeft)
|
|
|
895 COMMAND_ID_HANDLER(ID_SCROLL_ALL_RIGHT, CScrollImpl< T >::OnScrollAllRight)
|
|
|
896 END_MSG_MAP()
|
|
|
897 };
|
|
|
898
|
|
|
899
|
|
|
900 ///////////////////////////////////////////////////////////////////////////////
|
|
|
901 // CMapScrollImpl - Provides mapping and scrolling support to any window
|
|
|
902
|
|
|
903 template <class T>
|
|
|
904 class CMapScrollImpl : public CScrollImpl< T >
|
|
|
905 {
|
|
|
906 public:
|
|
|
907 int m_nMapMode;
|
|
|
908 RECT m_rectLogAll;
|
|
|
909 SIZE m_sizeLogLine;
|
|
|
910 SIZE m_sizeLogPage;
|
|
|
911
|
|
|
912 // Constructor
|
|
|
913 CMapScrollImpl() : m_nMapMode(MM_TEXT)
|
|
|
914 {
|
|
|
915 ::SetRectEmpty(&m_rectLogAll);
|
|
|
916 m_sizeLogPage.cx = 0;
|
|
|
917 m_sizeLogPage.cy = 0;
|
|
|
918 m_sizeLogLine.cx = 0;
|
|
|
919 m_sizeLogLine.cy = 0;
|
|
|
920 }
|
|
|
921
|
|
|
922 // Attributes & Operations
|
|
|
923 // mapping mode operations
|
|
|
924 void SetScrollMapMode(int nMapMode)
|
|
|
925 {
|
|
|
926 ATLASSERT((nMapMode >= MM_MIN) && (nMapMode <= MM_MAX_FIXEDSCALE));
|
|
|
927 m_nMapMode = nMapMode;
|
|
|
928 }
|
|
|
929
|
|
|
930 int GetScrollMapMode() const
|
|
|
931 {
|
|
|
932 ATLASSERT((m_nMapMode >= MM_MIN) && (m_nMapMode <= MM_MAX_FIXEDSCALE));
|
|
|
933 return m_nMapMode;
|
|
|
934 }
|
|
|
935
|
|
|
936 // offset operations
|
|
|
937 void SetScrollOffset(int x, int y, BOOL bRedraw = TRUE)
|
|
|
938 {
|
|
|
939 ATLASSERT((m_nMapMode >= MM_MIN) && (m_nMapMode <= MM_MAX_FIXEDSCALE));
|
|
|
940 POINT ptOff = { x, y };
|
|
|
941 // block: convert logical to device units
|
|
|
942 {
|
|
|
943 CWindowDC dc(NULL);
|
|
|
944 dc.SetMapMode(m_nMapMode);
|
|
|
945 dc.LPtoDP(&ptOff);
|
|
|
946 }
|
|
|
947 CScrollImpl< T >::SetScrollOffset(ptOff, bRedraw);
|
|
|
948 }
|
|
|
949
|
|
|
950 void SetScrollOffset(POINT ptOffset, BOOL bRedraw = TRUE)
|
|
|
951 {
|
|
|
952 SetScrollOffset(ptOffset.x, ptOffset.y, bRedraw);
|
|
|
953 }
|
|
|
954
|
|
|
955 void GetScrollOffset(POINT& ptOffset) const
|
|
|
956 {
|
|
|
957 ATLASSERT((m_nMapMode >= MM_MIN) && (m_nMapMode <= MM_MAX_FIXEDSCALE));
|
|
|
958 ptOffset = this->m_ptOffset;
|
|
|
959 // block: convert device to logical units
|
|
|
960 {
|
|
|
961 CWindowDC dc(NULL);
|
|
|
962 dc.SetMapMode(m_nMapMode);
|
|
|
963 dc.DPtoLP(&ptOffset);
|
|
|
964 }
|
|
|
965 }
|
|
|
966
|
|
|
967 // size operations
|
|
|
968 void SetScrollSize(int xMin, int yMin, int xMax, int yMax, BOOL bRedraw = TRUE, bool bResetOffset = true)
|
|
|
969 {
|
|
|
970 ATLASSERT((xMax > xMin) && (yMax > yMin));
|
|
|
971 ATLASSERT((m_nMapMode >= MM_MIN) && (m_nMapMode <= MM_MAX_FIXEDSCALE));
|
|
|
972
|
|
|
973 ::SetRect(&m_rectLogAll, xMin, yMin, xMax, yMax);
|
|
|
974
|
|
|
975 SIZE sizeAll = {};
|
|
|
976 sizeAll.cx = xMax - xMin + 1;
|
|
|
977 sizeAll.cy = yMax - yMin + 1;
|
|
|
978 // block: convert logical to device units
|
|
|
979 {
|
|
|
980 CWindowDC dc(NULL);
|
|
|
981 dc.SetMapMode(m_nMapMode);
|
|
|
982 dc.LPtoDP(&sizeAll);
|
|
|
983 }
|
|
|
984 CScrollImpl< T >::SetScrollSize(sizeAll, bRedraw, bResetOffset);
|
|
|
985 SetScrollLine(0, 0);
|
|
|
986 SetScrollPage(0, 0);
|
|
|
987 }
|
|
|
988
|
|
|
989 void SetScrollSize(RECT& rcScroll, BOOL bRedraw = TRUE, bool bResetOffset = true)
|
|
|
990 {
|
|
|
991 SetScrollSize(rcScroll.left, rcScroll.top, rcScroll.right, rcScroll.bottom, bRedraw, bResetOffset);
|
|
|
992 }
|
|
|
993
|
|
|
994 void SetScrollSize(int cx, int cy, BOOL bRedraw = TRUE, bool bResetOffset = true)
|
|
|
995 {
|
|
|
996 SetScrollSize(0, 0, cx, cy, bRedraw, bResetOffset);
|
|
|
997 }
|
|
|
998
|
|
|
999 void SetScrollSize(SIZE size, BOOL bRedraw = TRUE, bool bResetOffset = true)
|
|
|
1000 {
|
|
|
1001 SetScrollSize(0, 0, size.cx, size.cy, bRedraw, bResetOffset);
|
|
|
1002 }
|
|
|
1003
|
|
|
1004 void GetScrollSize(RECT& rcScroll) const
|
|
|
1005 {
|
|
|
1006 ATLASSERT((m_nMapMode >= MM_MIN) && (m_nMapMode <= MM_MAX_FIXEDSCALE));
|
|
|
1007 rcScroll = m_rectLogAll;
|
|
|
1008 }
|
|
|
1009
|
|
|
1010 // line operations
|
|
|
1011 void SetScrollLine(int cxLine, int cyLine)
|
|
|
1012 {
|
|
|
1013 ATLASSERT((cxLine >= 0) && (cyLine >= 0));
|
|
|
1014 ATLASSERT((m_nMapMode >= MM_MIN) && (m_nMapMode <= MM_MAX_FIXEDSCALE));
|
|
|
1015
|
|
|
1016 m_sizeLogLine.cx = cxLine;
|
|
|
1017 m_sizeLogLine.cy = cyLine;
|
|
|
1018 SIZE sizeLine = m_sizeLogLine;
|
|
|
1019 // block: convert logical to device units
|
|
|
1020 {
|
|
|
1021 CWindowDC dc(NULL);
|
|
|
1022 dc.SetMapMode(m_nMapMode);
|
|
|
1023 dc.LPtoDP(&sizeLine);
|
|
|
1024 }
|
|
|
1025 CScrollImpl< T >::SetScrollLine(sizeLine);
|
|
|
1026 }
|
|
|
1027
|
|
|
1028 void SetScrollLine(SIZE sizeLine)
|
|
|
1029 {
|
|
|
1030 SetScrollLine(sizeLine.cx, sizeLine.cy);
|
|
|
1031 }
|
|
|
1032
|
|
|
1033 void GetScrollLine(SIZE& sizeLine) const
|
|
|
1034 {
|
|
|
1035 ATLASSERT((m_nMapMode >= MM_MIN) && (m_nMapMode <= MM_MAX_FIXEDSCALE));
|
|
|
1036 sizeLine = m_sizeLogLine;
|
|
|
1037 }
|
|
|
1038
|
|
|
1039 // page operations
|
|
|
1040 void SetScrollPage(int cxPage, int cyPage)
|
|
|
1041 {
|
|
|
1042 ATLASSERT((cxPage >= 0) && (cyPage >= 0));
|
|
|
1043 ATLASSERT((m_nMapMode >= MM_MIN) && (m_nMapMode <= MM_MAX_FIXEDSCALE));
|
|
|
1044
|
|
|
1045 m_sizeLogPage.cx = cxPage;
|
|
|
1046 m_sizeLogPage.cy = cyPage;
|
|
|
1047 SIZE sizePage = m_sizeLogPage;
|
|
|
1048 // block: convert logical to device units
|
|
|
1049 {
|
|
|
1050 CWindowDC dc(NULL);
|
|
|
1051 dc.SetMapMode(m_nMapMode);
|
|
|
1052 dc.LPtoDP(&sizePage);
|
|
|
1053 }
|
|
|
1054 CScrollImpl< T >::SetScrollPage(sizePage);
|
|
|
1055 }
|
|
|
1056
|
|
|
1057 void SetScrollPage(SIZE sizePage)
|
|
|
1058 {
|
|
|
1059 SetScrollPage(sizePage.cx, sizePage.cy);
|
|
|
1060 }
|
|
|
1061
|
|
|
1062 void GetScrollPage(SIZE& sizePage) const
|
|
|
1063 {
|
|
|
1064 ATLASSERT((m_nMapMode >= MM_MIN) && (m_nMapMode <= MM_MAX_FIXEDSCALE));
|
|
|
1065 sizePage = m_sizeLogPage;
|
|
|
1066 }
|
|
|
1067
|
|
|
1068 BEGIN_MSG_MAP(CMapScrollImpl)
|
|
|
1069 MESSAGE_HANDLER(WM_VSCROLL, CScrollImpl< T >::OnVScroll)
|
|
|
1070 MESSAGE_HANDLER(WM_HSCROLL, CScrollImpl< T >::OnHScroll)
|
|
|
1071 MESSAGE_HANDLER(WM_MOUSEWHEEL, CScrollImpl< T >::OnMouseWheel)
|
|
|
1072 MESSAGE_HANDLER(WM_MOUSEHWHEEL, CScrollImpl< T >::OnMouseHWheel)
|
|
|
1073 MESSAGE_HANDLER(WM_SETTINGCHANGE, CScrollImpl< T >::OnSettingChange)
|
|
|
1074 MESSAGE_HANDLER(WM_SIZE, CScrollImpl< T >::OnSize)
|
|
|
1075 MESSAGE_HANDLER(WM_PAINT, OnPaint)
|
|
|
1076 MESSAGE_HANDLER(WM_PRINTCLIENT, OnPaint)
|
|
|
1077 ALT_MSG_MAP(1)
|
|
|
1078 COMMAND_ID_HANDLER(ID_SCROLL_UP, CScrollImpl< T >::OnScrollUp)
|
|
|
1079 COMMAND_ID_HANDLER(ID_SCROLL_DOWN, CScrollImpl< T >::OnScrollDown)
|
|
|
1080 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_UP, CScrollImpl< T >::OnScrollPageUp)
|
|
|
1081 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_DOWN, CScrollImpl< T >::OnScrollPageDown)
|
|
|
1082 COMMAND_ID_HANDLER(ID_SCROLL_TOP, CScrollImpl< T >::OnScrollTop)
|
|
|
1083 COMMAND_ID_HANDLER(ID_SCROLL_BOTTOM, CScrollImpl< T >::OnScrollBottom)
|
|
|
1084 COMMAND_ID_HANDLER(ID_SCROLL_LEFT, CScrollImpl< T >::OnScrollLeft)
|
|
|
1085 COMMAND_ID_HANDLER(ID_SCROLL_RIGHT, CScrollImpl< T >::OnScrollRight)
|
|
|
1086 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_LEFT, CScrollImpl< T >::OnScrollPageLeft)
|
|
|
1087 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_RIGHT, CScrollImpl< T >::OnScrollPageRight)
|
|
|
1088 COMMAND_ID_HANDLER(ID_SCROLL_ALL_LEFT, CScrollImpl< T >::OnScrollAllLeft)
|
|
|
1089 COMMAND_ID_HANDLER(ID_SCROLL_ALL_RIGHT, CScrollImpl< T >::OnScrollAllRight)
|
|
|
1090 END_MSG_MAP()
|
|
|
1091
|
|
|
1092 LRESULT OnPaint(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
|
|
|
1093 {
|
|
|
1094 T* pT = static_cast<T*>(this);
|
|
|
1095 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
1096 if(wParam != NULL)
|
|
|
1097 {
|
|
|
1098 CDCHandle dc = (HDC)wParam;
|
|
|
1099 int nMapModeSav = dc.GetMapMode();
|
|
|
1100 dc.SetMapMode(m_nMapMode);
|
|
|
1101 POINT ptViewportOrg = { 0, 0 };
|
|
|
1102 if(m_nMapMode == MM_TEXT)
|
|
|
1103 dc.SetViewportOrg(-this->m_ptOffset.x, -this->m_ptOffset.y, &ptViewportOrg);
|
|
|
1104 else
|
|
|
1105 dc.SetViewportOrg(-this->m_ptOffset.x, -this->m_ptOffset.y + this->m_sizeAll.cy, &ptViewportOrg);
|
|
|
1106 POINT ptWindowOrg = { 0, 0 };
|
|
|
1107 dc.SetWindowOrg(m_rectLogAll.left, m_rectLogAll.top, &ptWindowOrg);
|
|
|
1108
|
|
|
1109 pT->DoPaint(dc);
|
|
|
1110
|
|
|
1111 dc.SetMapMode(nMapModeSav);
|
|
|
1112 dc.SetViewportOrg(ptViewportOrg);
|
|
|
1113 dc.SetWindowOrg(ptWindowOrg);
|
|
|
1114 }
|
|
|
1115 else
|
|
|
1116 {
|
|
|
1117 CPaintDC dc(pT->m_hWnd);
|
|
|
1118 dc.SetMapMode(m_nMapMode);
|
|
|
1119 if(m_nMapMode == MM_TEXT)
|
|
|
1120 dc.SetViewportOrg(-this->m_ptOffset.x, -this->m_ptOffset.y);
|
|
|
1121 else
|
|
|
1122 dc.SetViewportOrg(-this->m_ptOffset.x, -this->m_ptOffset.y + this->m_sizeAll.cy);
|
|
|
1123 dc.SetWindowOrg(m_rectLogAll.left, m_rectLogAll.top);
|
|
|
1124 pT->DoPaint(dc.m_hDC);
|
|
|
1125 }
|
|
|
1126 return 0;
|
|
|
1127 }
|
|
|
1128 };
|
|
|
1129
|
|
|
1130
|
|
|
1131 ///////////////////////////////////////////////////////////////////////////////
|
|
|
1132 // CMapScrollWindowImpl - Implements scrolling window with mapping
|
|
|
1133
|
|
|
1134 template <class T, class TBase = ATL::CWindow, class TWinTraits = ATL::CControlWinTraits>
|
|
|
1135 class ATL_NO_VTABLE CMapScrollWindowImpl : public ATL::CWindowImpl< T, TBase, TWinTraits >, public CMapScrollImpl< T >
|
|
|
1136 {
|
|
|
1137 public:
|
|
|
1138 BOOL SubclassWindow(HWND hWnd)
|
|
|
1139 {
|
|
|
1140 BOOL bRet = ATL::CWindowImpl< T, TBase, TWinTraits >::SubclassWindow(hWnd);
|
|
|
1141 if(bRet != FALSE)
|
|
|
1142 {
|
|
|
1143 T* pT = static_cast<T*>(this);
|
|
|
1144 pT->GetSystemSettings();
|
|
|
1145
|
|
|
1146 RECT rect = {};
|
|
|
1147 this->GetClientRect(&rect);
|
|
|
1148 pT->DoSize(rect.right, rect.bottom);
|
|
|
1149 }
|
|
|
1150
|
|
|
1151 return bRet;
|
|
|
1152 }
|
|
|
1153
|
|
|
1154 BEGIN_MSG_MAP(CMapScrollWindowImpl)
|
|
|
1155 MESSAGE_HANDLER(WM_VSCROLL, CScrollImpl< T >::OnVScroll)
|
|
|
1156 MESSAGE_HANDLER(WM_HSCROLL, CScrollImpl< T >::OnHScroll)
|
|
|
1157 MESSAGE_HANDLER(WM_MOUSEWHEEL, CScrollImpl< T >::OnMouseWheel)
|
|
|
1158 MESSAGE_HANDLER(WM_MOUSEHWHEEL, CScrollImpl< T >::OnMouseHWheel)
|
|
|
1159 MESSAGE_HANDLER(WM_SETTINGCHANGE, CScrollImpl< T >::OnSettingChange)
|
|
|
1160 MESSAGE_HANDLER(WM_SIZE, CScrollImpl< T >::OnSize)
|
|
|
1161 MESSAGE_HANDLER(WM_PAINT, CMapScrollImpl< T >::OnPaint)
|
|
|
1162 MESSAGE_HANDLER(WM_PRINTCLIENT, CMapScrollImpl< T >::OnPaint)
|
|
|
1163 ALT_MSG_MAP(1)
|
|
|
1164 COMMAND_ID_HANDLER(ID_SCROLL_UP, CScrollImpl< T >::OnScrollUp)
|
|
|
1165 COMMAND_ID_HANDLER(ID_SCROLL_DOWN, CScrollImpl< T >::OnScrollDown)
|
|
|
1166 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_UP, CScrollImpl< T >::OnScrollPageUp)
|
|
|
1167 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_DOWN, CScrollImpl< T >::OnScrollPageDown)
|
|
|
1168 COMMAND_ID_HANDLER(ID_SCROLL_TOP, CScrollImpl< T >::OnScrollTop)
|
|
|
1169 COMMAND_ID_HANDLER(ID_SCROLL_BOTTOM, CScrollImpl< T >::OnScrollBottom)
|
|
|
1170 COMMAND_ID_HANDLER(ID_SCROLL_LEFT, CScrollImpl< T >::OnScrollLeft)
|
|
|
1171 COMMAND_ID_HANDLER(ID_SCROLL_RIGHT, CScrollImpl< T >::OnScrollRight)
|
|
|
1172 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_LEFT, CScrollImpl< T >::OnScrollPageLeft)
|
|
|
1173 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_RIGHT, CScrollImpl< T >::OnScrollPageRight)
|
|
|
1174 COMMAND_ID_HANDLER(ID_SCROLL_ALL_LEFT, CScrollImpl< T >::OnScrollAllLeft)
|
|
|
1175 COMMAND_ID_HANDLER(ID_SCROLL_ALL_RIGHT, CScrollImpl< T >::OnScrollAllRight)
|
|
|
1176 END_MSG_MAP()
|
|
|
1177 };
|
|
|
1178
|
|
|
1179
|
|
|
1180 ///////////////////////////////////////////////////////////////////////////////
|
|
|
1181 // CFSBWindow - Use as a base instead of CWindow to get flat scroll bar support
|
|
|
1182
|
|
|
1183 #ifdef __ATLCTRLS_H__
|
|
|
1184
|
|
|
1185 template <class TBase = ATL::CWindow>
|
|
|
1186 class CFSBWindowT : public TBase, public CFlatScrollBarImpl<CFSBWindowT< TBase > >
|
|
|
1187 {
|
|
|
1188 public:
|
|
|
1189 // Constructors
|
|
|
1190 CFSBWindowT(HWND hWnd = NULL) : TBase(hWnd)
|
|
|
1191 { }
|
|
|
1192
|
|
|
1193 CFSBWindowT< TBase >& operator =(HWND hWnd)
|
|
|
1194 {
|
|
|
1195 this->m_hWnd = hWnd;
|
|
|
1196 return *this;
|
|
|
1197 }
|
|
|
1198
|
|
|
1199 // CWindow overrides that use flat scroll bar API
|
|
|
1200 // (only those methods that are used by scroll window classes)
|
|
|
1201 int SetScrollPos(int nBar, int nPos, BOOL bRedraw = TRUE)
|
|
|
1202 {
|
|
|
1203 ATLASSERT(::IsWindow(this->m_hWnd));
|
|
|
1204 return this->FlatSB_SetScrollPos(nBar, nPos, bRedraw);
|
|
|
1205 }
|
|
|
1206
|
|
|
1207 BOOL GetScrollInfo(int nBar, LPSCROLLINFO lpScrollInfo)
|
|
|
1208 {
|
|
|
1209 ATLASSERT(::IsWindow(this->m_hWnd));
|
|
|
1210 return this->FlatSB_GetScrollInfo(nBar, lpScrollInfo);
|
|
|
1211 }
|
|
|
1212
|
|
|
1213 BOOL SetScrollInfo(int nBar, LPSCROLLINFO lpScrollInfo, BOOL bRedraw = TRUE)
|
|
|
1214 {
|
|
|
1215 ATLASSERT(::IsWindow(this->m_hWnd));
|
|
|
1216 return this->FlatSB_SetScrollInfo(nBar, lpScrollInfo, bRedraw);
|
|
|
1217 }
|
|
|
1218 };
|
|
|
1219
|
|
|
1220 typedef CFSBWindowT<ATL::CWindow> CFSBWindow;
|
|
|
1221
|
|
|
1222 #endif // __ATLCTRLS_H__
|
|
|
1223
|
|
|
1224
|
|
|
1225 ///////////////////////////////////////////////////////////////////////////////
|
|
|
1226 // CZoomScrollImpl - Provides zooming and scrolling support to any window
|
|
|
1227
|
|
|
1228 // The zoom modes that can be set with the SetZoomMode method
|
|
|
1229 enum
|
|
|
1230 {
|
|
|
1231 ZOOMMODE_OFF,
|
|
|
1232 ZOOMMODE_IN, // If left mouse button is clicked or dragged, zoom in on point clicked or rectangle dragged.
|
|
|
1233 ZOOMMODE_OUT // If left mouse button clicked, zoom out on point clicked.
|
|
|
1234 };
|
|
|
1235
|
|
|
1236 // Notification to parent that zoom scale changed as a result of user mouse action.
|
|
|
1237 #define ZSN_ZOOMCHANGED (NM_FIRST - 50)
|
|
|
1238
|
|
|
1239 template <class T>
|
|
|
1240 class CZoomScrollImpl : public CScrollImpl< T >
|
|
|
1241 {
|
|
|
1242 public:
|
|
|
1243 enum { m_cxyMinZoomRect = 12 }; // min rect size to zoom in on rect.
|
|
|
1244
|
|
|
1245 struct _ChildPlacement
|
|
|
1246 {
|
|
|
1247 HWND hWnd;
|
|
|
1248 int x;
|
|
|
1249 int y;
|
|
|
1250 int cx;
|
|
|
1251 int cy;
|
|
|
1252
|
|
|
1253 bool operator ==(const _ChildPlacement& cp) const { return (memcmp(this, &cp, sizeof(_ChildPlacement)) == 0); }
|
|
|
1254 };
|
|
|
1255
|
|
|
1256 // Data members
|
|
|
1257 SIZE m_sizeLogAll;
|
|
|
1258 SIZE m_sizeLogLine;
|
|
|
1259 SIZE m_sizeLogPage;
|
|
|
1260 float m_fZoomScale;
|
|
|
1261 float m_fZoomScaleMin;
|
|
|
1262 float m_fZoomScaleMax;
|
|
|
1263 float m_fZoomDelta; // Used in ZOOMMODE_IN and ZOOMMODE_OUT on left-button click.
|
|
|
1264 int m_nZoomMode;
|
|
|
1265 RECT m_rcTrack;
|
|
|
1266 bool m_bTracking;
|
|
|
1267
|
|
|
1268 bool m_bZoomChildren;
|
|
|
1269 ATL::CSimpleArray<_ChildPlacement> m_arrChildren;
|
|
|
1270
|
|
|
1271 // Constructor
|
|
|
1272 CZoomScrollImpl(): m_fZoomScale(1.0f), m_fZoomScaleMin(0.1f), m_fZoomScaleMax(100.0f), m_fZoomDelta(0.5f),
|
|
|
1273 m_nZoomMode(ZOOMMODE_OFF), m_bTracking(false), m_bZoomChildren(false)
|
|
|
1274 {
|
|
|
1275 m_sizeLogAll.cx = 0;
|
|
|
1276 m_sizeLogAll.cy = 0;
|
|
|
1277 m_sizeLogPage.cx = 0;
|
|
|
1278 m_sizeLogPage.cy = 0;
|
|
|
1279 m_sizeLogLine.cx = 0;
|
|
|
1280 m_sizeLogLine.cy = 0;
|
|
|
1281 ::SetRectEmpty(&m_rcTrack);
|
|
|
1282 }
|
|
|
1283
|
|
|
1284 // Attributes & Operations
|
|
|
1285 // size operations
|
|
|
1286 void SetScrollSize(int cxLog, int cyLog, BOOL bRedraw = TRUE, bool bResetOffset = true)
|
|
|
1287 {
|
|
|
1288 ATLASSERT((cxLog >= 0) && (cyLog >= 0));
|
|
|
1289
|
|
|
1290 // Set up the defaults
|
|
|
1291 if((cxLog == 0) && (cyLog == 0))
|
|
|
1292 {
|
|
|
1293 cxLog = 1;
|
|
|
1294 cyLog = 1;
|
|
|
1295 }
|
|
|
1296
|
|
|
1297 m_sizeLogAll.cx = cxLog;
|
|
|
1298 m_sizeLogAll.cy = cyLog;
|
|
|
1299 SIZE sizeAll = {};
|
|
|
1300 sizeAll.cx = (int)((float)m_sizeLogAll.cx * m_fZoomScale);
|
|
|
1301 sizeAll.cy = (int)((float)m_sizeLogAll.cy * m_fZoomScale);
|
|
|
1302
|
|
|
1303 CScrollImpl< T >::SetScrollSize(sizeAll, bRedraw, bResetOffset);
|
|
|
1304 }
|
|
|
1305
|
|
|
1306 void SetScrollSize(SIZE sizeLog, BOOL bRedraw = TRUE, bool bResetOffset = true)
|
|
|
1307 {
|
|
|
1308 SetScrollSize(sizeLog.cx, sizeLog.cy, bRedraw, bResetOffset);
|
|
|
1309 }
|
|
|
1310
|
|
|
1311 void GetScrollSize(SIZE& sizeLog) const
|
|
|
1312 {
|
|
|
1313 sizeLog = m_sizeLogAll;
|
|
|
1314 }
|
|
|
1315
|
|
|
1316 // line operations
|
|
|
1317 void SetScrollLine(int cxLogLine, int cyLogLine)
|
|
|
1318 {
|
|
|
1319 ATLASSERT((cxLogLine >= 0) && (cyLogLine >= 0));
|
|
|
1320
|
|
|
1321 m_sizeLogLine.cx = cxLogLine;
|
|
|
1322 m_sizeLogLine.cy = cyLogLine;
|
|
|
1323
|
|
|
1324 SIZE sizeLine = {};
|
|
|
1325 sizeLine.cx = (int)((float)m_sizeLogLine.cx * m_fZoomScale);
|
|
|
1326 sizeLine.cy = (int)((float)m_sizeLogLine.cy * m_fZoomScale);
|
|
|
1327 CScrollImpl< T >::SetScrollLine(sizeLine);
|
|
|
1328 }
|
|
|
1329
|
|
|
1330 void SetScrollLine(SIZE sizeLogLine)
|
|
|
1331 {
|
|
|
1332 SetScrollLine(sizeLogLine.cx, sizeLogLine.cy);
|
|
|
1333 }
|
|
|
1334
|
|
|
1335 void GetScrollLine(SIZE& sizeLogLine) const
|
|
|
1336 {
|
|
|
1337 sizeLogLine = m_sizeLogLine;
|
|
|
1338 }
|
|
|
1339
|
|
|
1340 // page operations
|
|
|
1341 void SetScrollPage(int cxLogPage, int cyLogPage)
|
|
|
1342 {
|
|
|
1343 ATLASSERT((cxLogPage >= 0) && (cyLogPage >= 0));
|
|
|
1344
|
|
|
1345 m_sizeLogPage.cx = cxLogPage;
|
|
|
1346 m_sizeLogPage.cy = cyLogPage;
|
|
|
1347
|
|
|
1348 SIZE sizePage = {};
|
|
|
1349 sizePage.cx = (int)((float)m_sizeLogPage.cx * m_fZoomScale);
|
|
|
1350 sizePage.cy = (int)((float)m_sizeLogPage.cy * m_fZoomScale);
|
|
|
1351
|
|
|
1352 CScrollImpl< T >::SetScrollPage(sizePage);
|
|
|
1353 }
|
|
|
1354
|
|
|
1355 void SetScrollPage(SIZE sizeLogPage)
|
|
|
1356 {
|
|
|
1357 SetScrollPage(sizeLogPage.cx, sizeLogPage.cy);
|
|
|
1358 }
|
|
|
1359
|
|
|
1360 void GetScrollPage(SIZE& sizeLogPage) const
|
|
|
1361 {
|
|
|
1362 sizeLogPage = m_sizeLogPage;
|
|
|
1363 }
|
|
|
1364
|
|
|
1365 void SetZoomScale(float fZoomScale)
|
|
|
1366 {
|
|
|
1367 ATLASSERT(fZoomScale > 0.0f);
|
|
|
1368 if(fZoomScale <= 0.0f)
|
|
|
1369 return;
|
|
|
1370
|
|
|
1371 m_fZoomScale = fZoomScale;
|
|
|
1372 if(m_fZoomScale < m_fZoomScaleMin)
|
|
|
1373 m_fZoomScale = m_fZoomScaleMin;
|
|
|
1374 else if(m_fZoomScale > m_fZoomScaleMax)
|
|
|
1375 m_fZoomScale = m_fZoomScaleMax;
|
|
|
1376 }
|
|
|
1377
|
|
|
1378 float GetZoomScale() const
|
|
|
1379 {
|
|
|
1380 return m_fZoomScale;
|
|
|
1381 }
|
|
|
1382
|
|
|
1383 void SetZoomScaleMin(float fZoomScaleMin)
|
|
|
1384 {
|
|
|
1385 ATLASSERT(fZoomScaleMin > 0.0f);
|
|
|
1386 ATLASSERT(fZoomScaleMin <= m_fZoomScaleMax);
|
|
|
1387
|
|
|
1388 m_fZoomScaleMin = fZoomScaleMin;
|
|
|
1389 }
|
|
|
1390
|
|
|
1391 float GetZoomScaleMin() const
|
|
|
1392 {
|
|
|
1393 return m_fZoomScaleMin;
|
|
|
1394 }
|
|
|
1395
|
|
|
1396 void SetZoomScaleMax(float fZoomScaleMax)
|
|
|
1397 {
|
|
|
1398 ATLASSERT(fZoomScaleMax > 0.0f);
|
|
|
1399 ATLASSERT(m_fZoomScaleMin <= fZoomScaleMax);
|
|
|
1400
|
|
|
1401 m_fZoomScaleMax = fZoomScaleMax;
|
|
|
1402 }
|
|
|
1403
|
|
|
1404 float GetZoomScaleMax() const
|
|
|
1405 {
|
|
|
1406 return m_fZoomScaleMax;
|
|
|
1407 }
|
|
|
1408
|
|
|
1409 void SetZoomDelta(float fZoomDelta)
|
|
|
1410 {
|
|
|
1411 ATLASSERT(fZoomDelta >= 0.0f);
|
|
|
1412
|
|
|
1413 if(fZoomDelta >= 0.0f)
|
|
|
1414 m_fZoomDelta = fZoomDelta;
|
|
|
1415 }
|
|
|
1416
|
|
|
1417 float GetZoomDelta() const
|
|
|
1418 {
|
|
|
1419 return m_fZoomDelta;
|
|
|
1420 }
|
|
|
1421
|
|
|
1422 void SetZoomMode(int nZoomMode)
|
|
|
1423 {
|
|
|
1424 m_nZoomMode = nZoomMode;
|
|
|
1425 }
|
|
|
1426
|
|
|
1427 int GetZoomMode() const
|
|
|
1428 {
|
|
|
1429 return m_nZoomMode;
|
|
|
1430 }
|
|
|
1431
|
|
|
1432 void SetZoomChildren(bool bEnable = true)
|
|
|
1433 {
|
|
|
1434 T* pT = static_cast<T*>(this);
|
|
|
1435 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
1436
|
|
|
1437 m_bZoomChildren = bEnable;
|
|
|
1438
|
|
|
1439 m_arrChildren.RemoveAll();
|
|
|
1440 if(m_bZoomChildren)
|
|
|
1441 {
|
|
|
1442 for(HWND hWndChild = ::GetWindow(pT->m_hWnd, GW_CHILD); hWndChild != NULL; hWndChild = ::GetWindow(hWndChild, GW_HWNDNEXT))
|
|
|
1443 {
|
|
|
1444 RECT rect = {};
|
|
|
1445 ::GetWindowRect(hWndChild, &rect);
|
|
|
1446 ::MapWindowPoints(NULL, pT->m_hWnd, (LPPOINT)&rect, 2);
|
|
|
1447
|
|
|
1448 _ChildPlacement cp = {};
|
|
|
1449 cp.hWnd = hWndChild;
|
|
|
1450 cp.x = rect.left;
|
|
|
1451 cp.y = rect.top;
|
|
|
1452 cp.cx = rect.right - rect.left;
|
|
|
1453 cp.cy = rect.bottom - rect.top;
|
|
|
1454 m_arrChildren.Add(cp);
|
|
|
1455 }
|
|
|
1456 }
|
|
|
1457 }
|
|
|
1458
|
|
|
1459 bool GetZoomChildren() const
|
|
|
1460 {
|
|
|
1461 return m_bZoomChildren;
|
|
|
1462 }
|
|
|
1463
|
|
|
1464 void Zoom(int x, int y, float fZoomScale)
|
|
|
1465 {
|
|
|
1466 if(fZoomScale <= 0.0f)
|
|
|
1467 return;
|
|
|
1468
|
|
|
1469 if(fZoomScale < m_fZoomScaleMin)
|
|
|
1470 fZoomScale = m_fZoomScaleMin;
|
|
|
1471 else if(fZoomScale > m_fZoomScaleMax)
|
|
|
1472 fZoomScale = m_fZoomScaleMax;
|
|
|
1473
|
|
|
1474 T* pT = static_cast<T*>(this);
|
|
|
1475 POINT pt = { x, y };
|
|
|
1476 if(!pT->PtInDevRect(pt))
|
|
|
1477 return;
|
|
|
1478
|
|
|
1479 pT->ViewDPtoLP(&pt);
|
|
|
1480 pT->Zoom(fZoomScale, false);
|
|
|
1481 pT->CenterOnLogicalPoint(pt);
|
|
|
1482 }
|
|
|
1483
|
|
|
1484 void Zoom(POINT pt, float fZoomScale)
|
|
|
1485 {
|
|
|
1486 T* pT = static_cast<T*>(this);
|
|
|
1487 pT->Zoom(pt.x, pt.y, fZoomScale);
|
|
|
1488 }
|
|
|
1489
|
|
|
1490 void Zoom(RECT& rc)
|
|
|
1491 {
|
|
|
1492 T* pT = static_cast<T*>(this);
|
|
|
1493 RECT rcZoom = rc;
|
|
|
1494 pT->NormalizeRect(rcZoom);
|
|
|
1495 SIZE size = { rcZoom.right - rcZoom.left, rcZoom.bottom - rcZoom.top };
|
|
|
1496 POINT pt = { rcZoom.left + size.cx / 2, rcZoom.top + size.cy / 2 };
|
|
|
1497 if((size.cx < m_cxyMinZoomRect) || (size.cy < m_cxyMinZoomRect))
|
|
|
1498 {
|
|
|
1499 pT->Zoom(pt, m_fZoomScale + m_fZoomDelta);
|
|
|
1500 return;
|
|
|
1501 }
|
|
|
1502
|
|
|
1503 ATLASSERT((size.cx > 0) && (size.cy > 0));
|
|
|
1504
|
|
|
1505 float fScaleH = (float)(this->m_sizeClient.cx + 1) / (float)size.cx;
|
|
|
1506 float fScaleV = (float)(this->m_sizeClient.cy + 1) / (float)size.cy;
|
|
|
1507 float fZoomScale = __min(fScaleH, fScaleV) * m_fZoomScale;
|
|
|
1508 pT->Zoom(pt, fZoomScale);
|
|
|
1509 }
|
|
|
1510
|
|
|
1511 void Zoom(float fZoomScale, bool bCenter = true)
|
|
|
1512 {
|
|
|
1513 if(fZoomScale <= 0.0f)
|
|
|
1514 return;
|
|
|
1515
|
|
|
1516 if(fZoomScale < m_fZoomScaleMin)
|
|
|
1517 fZoomScale = m_fZoomScaleMin;
|
|
|
1518 else if(fZoomScale > m_fZoomScaleMax)
|
|
|
1519 fZoomScale = m_fZoomScaleMax;
|
|
|
1520
|
|
|
1521 T* pT = static_cast<T*>(this);
|
|
|
1522 POINT pt = { 0, 0 };
|
|
|
1523 if(bCenter)
|
|
|
1524 {
|
|
|
1525 RECT rcClient = {};
|
|
|
1526 ::GetClientRect(pT->m_hWnd, &rcClient);
|
|
|
1527 pt.x = rcClient.right / 2;
|
|
|
1528 pt.y = rcClient.bottom / 2;
|
|
|
1529 pT->ViewDPtoLP(&pt);
|
|
|
1530 }
|
|
|
1531
|
|
|
1532 // Modify the Viewport extent
|
|
|
1533 SIZE sizeAll = {};
|
|
|
1534 sizeAll.cx = (int)((float)m_sizeLogAll.cx * fZoomScale);
|
|
|
1535 sizeAll.cy = (int)((float)m_sizeLogAll.cy * fZoomScale);
|
|
|
1536
|
|
|
1537 // Update scroll bars and window
|
|
|
1538 CScrollImpl< T >::SetScrollSize(sizeAll);
|
|
|
1539
|
|
|
1540 // Zoom all children if needed
|
|
|
1541 if(m_bZoomChildren && (m_fZoomScale != fZoomScale))
|
|
|
1542 {
|
|
|
1543 for(int i = 0; i < m_arrChildren.GetSize(); i++)
|
|
|
1544 {
|
|
|
1545 ATLASSERT(::IsWindow(m_arrChildren[i].hWnd));
|
|
|
1546
|
|
|
1547 ::SetWindowPos(m_arrChildren[i].hWnd, NULL,
|
|
|
1548 (int)((float)m_arrChildren[i].x * fZoomScale + 0.5f),
|
|
|
1549 (int)((float)m_arrChildren[i].y * fZoomScale + 0.5f),
|
|
|
1550 (int)((float)m_arrChildren[i].cx * fZoomScale + 0.5f),
|
|
|
1551 (int)((float)m_arrChildren[i].cy * fZoomScale + 0.5f),
|
|
|
1552 SWP_NOZORDER | SWP_NOACTIVATE);
|
|
|
1553 }
|
|
|
1554 }
|
|
|
1555
|
|
|
1556 // Set new zoom scale
|
|
|
1557 m_fZoomScale = fZoomScale;
|
|
|
1558
|
|
|
1559 if(bCenter)
|
|
|
1560 pT->CenterOnLogicalPoint(pt);
|
|
|
1561 }
|
|
|
1562
|
|
|
1563 void ZoomIn(bool bCenter = true)
|
|
|
1564 {
|
|
|
1565 T* pT = static_cast<T*>(this);
|
|
|
1566 pT->Zoom(m_fZoomScale + m_fZoomDelta, bCenter);
|
|
|
1567 }
|
|
|
1568
|
|
|
1569 void ZoomOut(bool bCenter = true)
|
|
|
1570 {
|
|
|
1571 T* pT = static_cast<T*>(this);
|
|
|
1572 pT->Zoom(m_fZoomScale - m_fZoomDelta, bCenter);
|
|
|
1573 }
|
|
|
1574
|
|
|
1575 void ZoomDefault(bool bCenter = true)
|
|
|
1576 {
|
|
|
1577 T* pT = static_cast<T*>(this);
|
|
|
1578 pT->Zoom(1.0f, bCenter);
|
|
|
1579 }
|
|
|
1580
|
|
|
1581 // Helper functions
|
|
|
1582 void PrepareDC(CDCHandle dc)
|
|
|
1583 {
|
|
|
1584 ATLASSERT((this->m_sizeAll.cx >= 0) && (this->m_sizeAll.cy >= 0));
|
|
|
1585 dc.SetMapMode(MM_ANISOTROPIC);
|
|
|
1586 dc.SetWindowExt(this->m_sizeLogAll);
|
|
|
1587 dc.SetViewportExt(this->m_sizeAll);
|
|
|
1588 dc.SetViewportOrg(-this->m_ptOffset.x, -this->m_ptOffset.y);
|
|
|
1589 }
|
|
|
1590
|
|
|
1591 void ViewDPtoLP(LPPOINT lpPoints, int nCount = 1)
|
|
|
1592 {
|
|
|
1593 ATLASSERT(lpPoints);
|
|
|
1594 T* pT = static_cast<T*>(this);
|
|
|
1595 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
1596
|
|
|
1597 CWindowDC dc(pT->m_hWnd);
|
|
|
1598 pT->PrepareDC(dc.m_hDC);
|
|
|
1599 dc.DPtoLP(lpPoints, nCount);
|
|
|
1600 }
|
|
|
1601
|
|
|
1602 void ViewLPtoDP(LPPOINT lpPoints, int nCount = 1)
|
|
|
1603 {
|
|
|
1604 ATLASSERT(lpPoints);
|
|
|
1605 T* pT = static_cast<T*>(this);
|
|
|
1606 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
1607
|
|
|
1608 CWindowDC dc(pT->m_hWnd);
|
|
|
1609 pT->PrepareDC(dc.m_hDC);
|
|
|
1610 dc.LPtoDP(lpPoints, nCount);
|
|
|
1611 }
|
|
|
1612
|
|
|
1613 void ClientToDevice(POINT &pt)
|
|
|
1614 {
|
|
|
1615 pt.x += this->m_ptOffset.x;
|
|
|
1616 pt.y += this->m_ptOffset.y;
|
|
|
1617 }
|
|
|
1618
|
|
|
1619 void DeviceToClient(POINT &pt)
|
|
|
1620 {
|
|
|
1621 pt.x -= this->m_ptOffset.x;
|
|
|
1622 pt.y -= this->m_ptOffset.y;
|
|
|
1623 }
|
|
|
1624
|
|
|
1625 void CenterOnPoint(POINT pt)
|
|
|
1626 {
|
|
|
1627 T* pT = static_cast<T*>(this);
|
|
|
1628 RECT rect = {};
|
|
|
1629 pT->GetClientRect(&rect);
|
|
|
1630
|
|
|
1631 int xOfs = pt.x - (rect.right / 2) + this->m_ptOffset.x;
|
|
|
1632 if(xOfs < 0)
|
|
|
1633 {
|
|
|
1634 xOfs = 0;
|
|
|
1635 }
|
|
|
1636 else
|
|
|
1637 {
|
|
|
1638 int xMax = __max((int)(this->m_sizeAll.cx - rect.right), 0);
|
|
|
1639 if(xOfs > xMax)
|
|
|
1640 xOfs = xMax;
|
|
|
1641 }
|
|
|
1642
|
|
|
1643 int yOfs = pt.y - (rect.bottom / 2) + this->m_ptOffset.y;
|
|
|
1644 if(yOfs < 0)
|
|
|
1645 {
|
|
|
1646 yOfs = 0;
|
|
|
1647 }
|
|
|
1648 else
|
|
|
1649 {
|
|
|
1650 int yMax = __max((int)(this->m_sizeAll.cy - rect.bottom), 0);
|
|
|
1651 if(yOfs > yMax)
|
|
|
1652 yOfs = yMax;
|
|
|
1653 }
|
|
|
1654
|
|
|
1655 CScrollImpl< T >::SetScrollOffset(xOfs, yOfs);
|
|
|
1656 }
|
|
|
1657
|
|
|
1658 void CenterOnLogicalPoint(POINT ptLog)
|
|
|
1659 {
|
|
|
1660 T* pT = static_cast<T*>(this);
|
|
|
1661 pT->ViewLPtoDP(&ptLog);
|
|
|
1662 pT->DeviceToClient(ptLog);
|
|
|
1663 pT->CenterOnPoint(ptLog);
|
|
|
1664 }
|
|
|
1665
|
|
|
1666 BOOL PtInDevRect(POINT pt)
|
|
|
1667 {
|
|
|
1668 RECT rc = { 0, 0, this->m_sizeAll.cx, this->m_sizeAll.cy };
|
|
|
1669 ::OffsetRect(&rc, -this->m_ptOffset.x, -this->m_ptOffset.y);
|
|
|
1670 return ::PtInRect(&rc, pt);
|
|
|
1671 }
|
|
|
1672
|
|
|
1673 void NormalizeRect(RECT& rc)
|
|
|
1674 {
|
|
|
1675 if(rc.left > rc.right)
|
|
|
1676 {
|
|
|
1677 int r = rc.right;
|
|
|
1678 rc.right = rc.left;
|
|
|
1679 rc.left = r;
|
|
|
1680 }
|
|
|
1681
|
|
|
1682 if(rc.top > rc.bottom)
|
|
|
1683 {
|
|
|
1684 int b = rc.bottom;
|
|
|
1685 rc.bottom = rc.top;
|
|
|
1686 rc.top = b;
|
|
|
1687 }
|
|
|
1688 }
|
|
|
1689
|
|
|
1690 void DrawTrackRect()
|
|
|
1691 {
|
|
|
1692 T* pT = static_cast<T*>(this);
|
|
|
1693 const SIZE sizeLines = { 2, 2 };
|
|
|
1694 RECT rc = m_rcTrack;
|
|
|
1695 pT->NormalizeRect(rc);
|
|
|
1696 if(!::IsRectEmpty(&rc))
|
|
|
1697 {
|
|
|
1698 CClientDC dc(pT->m_hWnd);
|
|
|
1699 dc.DrawDragRect(&rc, sizeLines, NULL, sizeLines);
|
|
|
1700 }
|
|
|
1701 }
|
|
|
1702
|
|
|
1703 void NotifyParentZoomChanged()
|
|
|
1704 {
|
|
|
1705 T* pT = static_cast<T*>(this);
|
|
|
1706 int nId = pT->GetDlgCtrlID();
|
|
|
1707 NMHDR nmhdr = { pT->m_hWnd, (UINT_PTR)nId, ZSN_ZOOMCHANGED };
|
|
|
1708 ::SendMessage(pT->GetParent(), WM_NOTIFY, (WPARAM)nId, (LPARAM)&nmhdr);
|
|
|
1709 }
|
|
|
1710
|
|
|
1711 void DoWheelZoom(int zDelta)
|
|
|
1712 {
|
|
|
1713 float fZoomScale = m_fZoomScale + ((zDelta > 0) ? m_fZoomDelta : -m_fZoomDelta);
|
|
|
1714 T* pT = static_cast<T*>(this);
|
|
|
1715 pT->Zoom(fZoomScale);
|
|
|
1716 pT->NotifyParentZoomChanged();
|
|
|
1717 }
|
|
|
1718
|
|
|
1719 BEGIN_MSG_MAP(CZoomScrollImpl)
|
|
|
1720 MESSAGE_HANDLER(WM_SETCURSOR, OnSetCursor)
|
|
|
1721 MESSAGE_HANDLER(WM_VSCROLL, CScrollImpl< T >::OnVScroll)
|
|
|
1722 MESSAGE_HANDLER(WM_HSCROLL, CScrollImpl< T >::OnHScroll)
|
|
|
1723 MESSAGE_HANDLER(WM_MOUSEWHEEL, OnMouseWheel)
|
|
|
1724 MESSAGE_HANDLER(WM_MOUSEHWHEEL, CScrollImpl< T >::OnMouseHWheel)
|
|
|
1725 MESSAGE_HANDLER(WM_SETTINGCHANGE, CScrollImpl< T >::OnSettingChange)
|
|
|
1726 MESSAGE_HANDLER(WM_SIZE, CScrollImpl< T >::OnSize)
|
|
|
1727 MESSAGE_HANDLER(WM_PAINT, OnPaint)
|
|
|
1728 MESSAGE_HANDLER(WM_PRINTCLIENT, OnPaint)
|
|
|
1729 MESSAGE_HANDLER(WM_LBUTTONDOWN, OnLButtonDown)
|
|
|
1730 MESSAGE_HANDLER(WM_MOUSEMOVE, OnMouseMove)
|
|
|
1731 MESSAGE_HANDLER(WM_LBUTTONUP, OnLButtonUp)
|
|
|
1732 MESSAGE_HANDLER(WM_CAPTURECHANGED, OnCaptureChanged)
|
|
|
1733 ALT_MSG_MAP(1)
|
|
|
1734 COMMAND_ID_HANDLER(ID_SCROLL_UP, CScrollImpl< T >::OnScrollUp)
|
|
|
1735 COMMAND_ID_HANDLER(ID_SCROLL_DOWN, CScrollImpl< T >::OnScrollDown)
|
|
|
1736 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_UP, CScrollImpl< T >::OnScrollPageUp)
|
|
|
1737 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_DOWN, CScrollImpl< T >::OnScrollPageDown)
|
|
|
1738 COMMAND_ID_HANDLER(ID_SCROLL_TOP, CScrollImpl< T >::OnScrollTop)
|
|
|
1739 COMMAND_ID_HANDLER(ID_SCROLL_BOTTOM, CScrollImpl< T >::OnScrollBottom)
|
|
|
1740 COMMAND_ID_HANDLER(ID_SCROLL_LEFT, CScrollImpl< T >::OnScrollLeft)
|
|
|
1741 COMMAND_ID_HANDLER(ID_SCROLL_RIGHT, CScrollImpl< T >::OnScrollRight)
|
|
|
1742 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_LEFT, CScrollImpl< T >::OnScrollPageLeft)
|
|
|
1743 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_RIGHT, CScrollImpl< T >::OnScrollPageRight)
|
|
|
1744 COMMAND_ID_HANDLER(ID_SCROLL_ALL_LEFT, CScrollImpl< T >::OnScrollAllLeft)
|
|
|
1745 COMMAND_ID_HANDLER(ID_SCROLL_ALL_RIGHT, CScrollImpl< T >::OnScrollAllRight)
|
|
|
1746 END_MSG_MAP()
|
|
|
1747
|
|
|
1748 LRESULT OnSetCursor(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
|
|
|
1749 {
|
|
|
1750 if((LOWORD(lParam) == HTCLIENT) && (m_nZoomMode != ZOOMMODE_OFF))
|
|
|
1751 {
|
|
|
1752 T* pT = static_cast<T*>(this);
|
|
|
1753 if((HWND)wParam == pT->m_hWnd)
|
|
|
1754 {
|
|
|
1755 DWORD dwPos = ::GetMessagePos();
|
|
|
1756 POINT pt = { GET_X_LPARAM(dwPos), GET_Y_LPARAM(dwPos) };
|
|
|
1757 pT->ScreenToClient(&pt);
|
|
|
1758 if(pT->PtInDevRect(pt))
|
|
|
1759 {
|
|
|
1760 ::SetCursor(::LoadCursor(NULL, IDC_CROSS));
|
|
|
1761 return 1;
|
|
|
1762 }
|
|
|
1763 }
|
|
|
1764 }
|
|
|
1765
|
|
|
1766 bHandled = FALSE;
|
|
|
1767 return 0;
|
|
|
1768 }
|
|
|
1769
|
|
|
1770 LRESULT OnMouseWheel(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
|
|
|
1771 {
|
|
|
1772 if((GET_KEYSTATE_WPARAM(wParam) & MK_CONTROL) != 0) // handle zoom if Ctrl is pressed
|
|
|
1773 {
|
|
|
1774 int zDelta = (int)GET_WHEEL_DELTA_WPARAM(wParam);
|
|
|
1775 T* pT = static_cast<T*>(this);
|
|
|
1776 pT->DoWheelZoom(zDelta);
|
|
|
1777 }
|
|
|
1778 else
|
|
|
1779 {
|
|
|
1780 CScrollImpl< T >::OnMouseWheel(uMsg, wParam, lParam, bHandled);
|
|
|
1781 }
|
|
|
1782
|
|
|
1783 return 0;
|
|
|
1784 }
|
|
|
1785
|
|
|
1786 LRESULT OnPaint(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
|
|
|
1787 {
|
|
|
1788 T* pT = static_cast<T*>(this);
|
|
|
1789 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
1790 ATLASSERT((m_sizeLogAll.cx >= 0) && (m_sizeLogAll.cy >= 0));
|
|
|
1791 ATLASSERT((this->m_sizeAll.cx >= 0) && (this->m_sizeAll.cy >= 0));
|
|
|
1792
|
|
|
1793 if(wParam != NULL)
|
|
|
1794 {
|
|
|
1795 CDCHandle dc = (HDC)wParam;
|
|
|
1796 int nMapModeSav = dc.GetMapMode();
|
|
|
1797 dc.SetMapMode(MM_ANISOTROPIC);
|
|
|
1798 SIZE szWindowExt = { 0, 0 };
|
|
|
1799 dc.SetWindowExt(m_sizeLogAll, &szWindowExt);
|
|
|
1800 SIZE szViewportExt = { 0, 0 };
|
|
|
1801 dc.SetViewportExt(this->m_sizeAll, &szViewportExt);
|
|
|
1802 POINT ptViewportOrg = { 0, 0 };
|
|
|
1803 dc.SetViewportOrg(-this->m_ptOffset.x, -this->m_ptOffset.y, &ptViewportOrg);
|
|
|
1804
|
|
|
1805 pT->DoPaint(dc);
|
|
|
1806
|
|
|
1807 dc.SetMapMode(nMapModeSav);
|
|
|
1808 dc.SetWindowExt(szWindowExt);
|
|
|
1809 dc.SetViewportExt(szViewportExt);
|
|
|
1810 dc.SetViewportOrg(ptViewportOrg);
|
|
|
1811 }
|
|
|
1812 else
|
|
|
1813 {
|
|
|
1814 CPaintDC dc(pT->m_hWnd);
|
|
|
1815 pT->PrepareDC(dc.m_hDC);
|
|
|
1816 pT->DoPaint(dc.m_hDC);
|
|
|
1817 }
|
|
|
1818
|
|
|
1819 return 0;
|
|
|
1820 }
|
|
|
1821
|
|
|
1822 LRESULT OnLButtonDown(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
|
|
|
1823 {
|
|
|
1824 if((m_nZoomMode == ZOOMMODE_IN) && !m_bTracking)
|
|
|
1825 {
|
|
|
1826 T* pT = static_cast<T*>(this);
|
|
|
1827 POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
|
|
|
1828 if(pT->PtInDevRect(pt))
|
|
|
1829 {
|
|
|
1830 pT->SetCapture();
|
|
|
1831 m_bTracking = true;
|
|
|
1832 ::SetRect(&m_rcTrack, pt.x, pt.y, pt.x, pt.y);
|
|
|
1833
|
|
|
1834 RECT rcClip;
|
|
|
1835 pT->GetClientRect(&rcClip);
|
|
|
1836 if((this->m_ptOffset.x == 0) && (this->m_ptOffset.y == 0))
|
|
|
1837 {
|
|
|
1838 if(rcClip.right > this->m_sizeAll.cx)
|
|
|
1839 rcClip.right = this->m_sizeAll.cx;
|
|
|
1840 if(rcClip.bottom > this->m_sizeAll.cy)
|
|
|
1841 rcClip.bottom = this->m_sizeAll.cy;
|
|
|
1842 }
|
|
|
1843 ::MapWindowPoints(pT->m_hWnd, NULL, (LPPOINT)&rcClip, 2);
|
|
|
1844 ::ClipCursor(&rcClip);
|
|
|
1845 }
|
|
|
1846 }
|
|
|
1847
|
|
|
1848 bHandled = FALSE;
|
|
|
1849 return 0;
|
|
|
1850 }
|
|
|
1851
|
|
|
1852 LRESULT OnMouseMove(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
|
|
|
1853 {
|
|
|
1854 if(m_bTracking)
|
|
|
1855 {
|
|
|
1856 T* pT = static_cast<T*>(this);
|
|
|
1857 POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
|
|
|
1858 if(pT->PtInDevRect(pt))
|
|
|
1859 {
|
|
|
1860 pT->DrawTrackRect();
|
|
|
1861 m_rcTrack.right = pt.x + 1;
|
|
|
1862 m_rcTrack.bottom = pt.y + 1;
|
|
|
1863 pT->DrawTrackRect();
|
|
|
1864 }
|
|
|
1865 }
|
|
|
1866
|
|
|
1867 bHandled = FALSE;
|
|
|
1868 return 0;
|
|
|
1869 }
|
|
|
1870
|
|
|
1871 LRESULT OnLButtonUp(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
|
|
|
1872 {
|
|
|
1873 ::ReleaseCapture();
|
|
|
1874 if(m_nZoomMode == ZOOMMODE_OUT)
|
|
|
1875 {
|
|
|
1876 T* pT = static_cast<T*>(this);
|
|
|
1877 pT->Zoom(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), m_fZoomScale - m_fZoomDelta);
|
|
|
1878 pT->NotifyParentZoomChanged();
|
|
|
1879 }
|
|
|
1880
|
|
|
1881 bHandled = FALSE;
|
|
|
1882 return 0;
|
|
|
1883 }
|
|
|
1884
|
|
|
1885 LRESULT OnCaptureChanged(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
|
|
|
1886 {
|
|
|
1887 if(m_bTracking)
|
|
|
1888 {
|
|
|
1889 m_bTracking = false;
|
|
|
1890 T* pT = static_cast<T*>(this);
|
|
|
1891 pT->DrawTrackRect();
|
|
|
1892 pT->Zoom(m_rcTrack);
|
|
|
1893 pT->NotifyParentZoomChanged();
|
|
|
1894 ::SetRectEmpty(&m_rcTrack);
|
|
|
1895 ::ClipCursor(NULL);
|
|
|
1896 }
|
|
|
1897
|
|
|
1898 bHandled = FALSE;
|
|
|
1899 return 0;
|
|
|
1900 }
|
|
|
1901 };
|
|
|
1902
|
|
|
1903 ///////////////////////////////////////////////////////////////////////////////
|
|
|
1904 // CZoomScrollWindowImpl - Implements scrolling window with zooming
|
|
|
1905
|
|
|
1906 template <class T, class TBase = ATL::CWindow, class TWinTraits = ATL::CControlWinTraits>
|
|
|
1907 class ATL_NO_VTABLE CZoomScrollWindowImpl : public ATL::CWindowImpl< T, TBase, TWinTraits >, public CZoomScrollImpl< T >
|
|
|
1908 {
|
|
|
1909 public:
|
|
|
1910 BOOL SubclassWindow(HWND hWnd)
|
|
|
1911 {
|
|
|
1912 BOOL bRet = ATL::CWindowImpl< T, TBase, TWinTraits >::SubclassWindow(hWnd);
|
|
|
1913 if(bRet != FALSE)
|
|
|
1914 {
|
|
|
1915 T* pT = static_cast<T*>(this);
|
|
|
1916 pT->GetSystemSettings();
|
|
|
1917
|
|
|
1918 RECT rect = {};
|
|
|
1919 this->GetClientRect(&rect);
|
|
|
1920 pT->DoSize(rect.right, rect.bottom);
|
|
|
1921 }
|
|
|
1922
|
|
|
1923 return bRet;
|
|
|
1924 }
|
|
|
1925
|
|
|
1926 BEGIN_MSG_MAP(CZoomScrollWindowImpl)
|
|
|
1927 MESSAGE_HANDLER(WM_SETCURSOR, CZoomScrollImpl< T >::OnSetCursor)
|
|
|
1928 MESSAGE_HANDLER(WM_VSCROLL, CScrollImpl< T >::OnVScroll)
|
|
|
1929 MESSAGE_HANDLER(WM_HSCROLL, CScrollImpl< T >::OnHScroll)
|
|
|
1930 MESSAGE_HANDLER(WM_MOUSEWHEEL, CZoomScrollImpl< T >::OnMouseWheel)
|
|
|
1931 MESSAGE_HANDLER(WM_MOUSEHWHEEL, CScrollImpl< T >::OnMouseHWheel)
|
|
|
1932 MESSAGE_HANDLER(WM_SETTINGCHANGE, CScrollImpl< T >::OnSettingChange)
|
|
|
1933 MESSAGE_HANDLER(WM_SIZE, CScrollImpl< T >::OnSize)
|
|
|
1934 MESSAGE_HANDLER(WM_PAINT, CZoomScrollImpl< T >::OnPaint)
|
|
|
1935 MESSAGE_HANDLER(WM_PRINTCLIENT, CZoomScrollImpl< T >::OnPaint)
|
|
|
1936 MESSAGE_HANDLER(WM_LBUTTONDOWN, CZoomScrollImpl< T >::OnLButtonDown)
|
|
|
1937 MESSAGE_HANDLER(WM_MOUSEMOVE, CZoomScrollImpl< T >::OnMouseMove)
|
|
|
1938 MESSAGE_HANDLER(WM_LBUTTONUP, CZoomScrollImpl< T >::OnLButtonUp)
|
|
|
1939 MESSAGE_HANDLER(WM_CAPTURECHANGED, CZoomScrollImpl< T >::OnCaptureChanged)
|
|
|
1940 ALT_MSG_MAP(1)
|
|
|
1941 COMMAND_ID_HANDLER(ID_SCROLL_UP, CScrollImpl< T >::OnScrollUp)
|
|
|
1942 COMMAND_ID_HANDLER(ID_SCROLL_DOWN, CScrollImpl< T >::OnScrollDown)
|
|
|
1943 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_UP, CScrollImpl< T >::OnScrollPageUp)
|
|
|
1944 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_DOWN, CScrollImpl< T >::OnScrollPageDown)
|
|
|
1945 COMMAND_ID_HANDLER(ID_SCROLL_TOP, CScrollImpl< T >::OnScrollTop)
|
|
|
1946 COMMAND_ID_HANDLER(ID_SCROLL_BOTTOM, CScrollImpl< T >::OnScrollBottom)
|
|
|
1947 COMMAND_ID_HANDLER(ID_SCROLL_LEFT, CScrollImpl< T >::OnScrollLeft)
|
|
|
1948 COMMAND_ID_HANDLER(ID_SCROLL_RIGHT, CScrollImpl< T >::OnScrollRight)
|
|
|
1949 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_LEFT, CScrollImpl< T >::OnScrollPageLeft)
|
|
|
1950 COMMAND_ID_HANDLER(ID_SCROLL_PAGE_RIGHT, CScrollImpl< T >::OnScrollPageRight)
|
|
|
1951 COMMAND_ID_HANDLER(ID_SCROLL_ALL_LEFT, CScrollImpl< T >::OnScrollAllLeft)
|
|
|
1952 COMMAND_ID_HANDLER(ID_SCROLL_ALL_RIGHT, CScrollImpl< T >::OnScrollAllRight)
|
|
|
1953 END_MSG_MAP()
|
|
|
1954 };
|
|
|
1955
|
|
|
1956
|
|
|
1957 ///////////////////////////////////////////////////////////////////////////////
|
|
|
1958 // CScrollContainer
|
|
|
1959
|
|
|
1960 template <class T, class TBase = ATL::CWindow, class TWinTraits = ATL::CControlWinTraits>
|
|
|
1961 class ATL_NO_VTABLE CScrollContainerImpl : public CScrollWindowImpl< T, TBase, TWinTraits >
|
|
|
1962 {
|
|
|
1963 public:
|
|
|
1964 DECLARE_WND_CLASS_EX2(NULL, T, 0, -1)
|
|
|
1965
|
|
|
1966 typedef CScrollWindowImpl< T, TBase, TWinTraits > _baseClass;
|
|
|
1967
|
|
|
1968 // Data members
|
|
|
1969 ATL::CWindow m_wndClient;
|
|
|
1970 bool m_bAutoSizeClient;
|
|
|
1971 bool m_bDrawEdgeIfEmpty;
|
|
|
1972
|
|
|
1973 // Constructor
|
|
|
1974 CScrollContainerImpl() : m_bAutoSizeClient(true), m_bDrawEdgeIfEmpty(false)
|
|
|
1975 {
|
|
|
1976 // Set CScrollWindowImpl extended style
|
|
|
1977 this->SetScrollExtendedStyle(SCRL_SCROLLCHILDREN);
|
|
|
1978 }
|
|
|
1979
|
|
|
1980 // Attributes
|
|
|
1981 HWND GetClient() const
|
|
|
1982 {
|
|
|
1983 return m_wndClient;
|
|
|
1984 }
|
|
|
1985
|
|
|
1986 HWND SetClient(HWND hWndClient, bool bClientSizeAsMin = true)
|
|
|
1987 {
|
|
|
1988 ATLASSERT(::IsWindow(this->m_hWnd));
|
|
|
1989
|
|
|
1990 HWND hWndOldClient = m_wndClient;
|
|
|
1991 m_wndClient = hWndClient;
|
|
|
1992
|
|
|
1993 this->SetRedraw(FALSE);
|
|
|
1994 this->SetScrollSize(1, 1, FALSE);
|
|
|
1995
|
|
|
1996 if(m_wndClient.m_hWnd != NULL)
|
|
|
1997 {
|
|
|
1998 m_wndClient.SetWindowPos(NULL, 0, 0, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
|
|
|
1999
|
|
|
2000 if(bClientSizeAsMin)
|
|
|
2001 {
|
|
|
2002 RECT rect = {};
|
|
|
2003 m_wndClient.GetWindowRect(&rect);
|
|
|
2004 if(((rect.right - rect.left) > 0) && ((rect.bottom - rect.top) > 0))
|
|
|
2005 this->SetScrollSize(rect.right - rect.left, rect.bottom - rect.top, FALSE);
|
|
|
2006 }
|
|
|
2007
|
|
|
2008 T* pT = static_cast<T*>(this);
|
|
|
2009 pT->UpdateLayout();
|
|
|
2010 }
|
|
|
2011
|
|
|
2012 this->SetRedraw(TRUE);
|
|
|
2013 this->RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_UPDATENOW | RDW_ALLCHILDREN);
|
|
|
2014
|
|
|
2015 return hWndOldClient;
|
|
|
2016 }
|
|
|
2017
|
|
|
2018 // Message map and handlers
|
|
|
2019 BEGIN_MSG_MAP(CScrollContainerImpl)
|
|
|
2020 MESSAGE_HANDLER(WM_SETFOCUS, OnSetFocus)
|
|
|
2021 MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)
|
|
|
2022 CHAIN_MSG_MAP(_baseClass)
|
|
|
2023 FORWARD_NOTIFICATIONS()
|
|
|
2024 ALT_MSG_MAP(1)
|
|
|
2025 CHAIN_MSG_MAP_ALT(_baseClass, 1)
|
|
|
2026 END_MSG_MAP()
|
|
|
2027
|
|
|
2028 LRESULT OnSetFocus(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
|
|
|
2029 {
|
|
|
2030 if(m_wndClient.m_hWnd != NULL)
|
|
|
2031 m_wndClient.SetFocus();
|
|
|
2032
|
|
|
2033 return 0;
|
|
|
2034 }
|
|
|
2035
|
|
|
2036 LRESULT OnEraseBackground(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
|
|
|
2037 {
|
|
|
2038 return 1; // no background needed
|
|
|
2039 }
|
|
|
2040
|
|
|
2041 // Overrides for CScrollWindowImpl
|
|
|
2042 void DoSize(int cx, int cy)
|
|
|
2043 {
|
|
|
2044 _baseClass::DoSize(cx, cy);
|
|
|
2045
|
|
|
2046 T* pT = static_cast<T*>(this);
|
|
|
2047 pT->UpdateLayout();
|
|
|
2048 }
|
|
|
2049
|
|
|
2050 void DoPaint(CDCHandle dc)
|
|
|
2051 {
|
|
|
2052 if(!m_bAutoSizeClient || (m_wndClient.m_hWnd == NULL))
|
|
|
2053 {
|
|
|
2054 T* pT = static_cast<T*>(this);
|
|
|
2055 RECT rect = {};
|
|
|
2056 pT->GetContainerRect(rect);
|
|
|
2057
|
|
|
2058 if(m_bDrawEdgeIfEmpty && (m_wndClient.m_hWnd == NULL))
|
|
|
2059 dc.DrawEdge(&rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
|
|
|
2060
|
|
|
2061 dc.FillRect(&rect, COLOR_APPWORKSPACE);
|
|
|
2062 }
|
|
|
2063 }
|
|
|
2064
|
|
|
2065 void ScrollToView(POINT pt)
|
|
|
2066 {
|
|
|
2067 CScrollWindowImpl< T, TBase, TWinTraits >::ScrollToView(pt);
|
|
|
2068 }
|
|
|
2069
|
|
|
2070 void ScrollToView(RECT& rect)
|
|
|
2071 {
|
|
|
2072 CScrollWindowImpl< T, TBase, TWinTraits >::ScrollToView(rect);
|
|
|
2073 }
|
|
|
2074
|
|
|
2075 void ScrollToView(HWND hWnd) // client window coordinates
|
|
|
2076 {
|
|
|
2077 T* pT = static_cast<T*>(this);
|
|
|
2078 (void)pT; // avoid level 4 warning
|
|
|
2079 ATLASSERT(::IsWindow(pT->m_hWnd));
|
|
|
2080 ATLASSERT(m_wndClient.IsWindow());
|
|
|
2081
|
|
|
2082 RECT rect = {};
|
|
|
2083 ::GetWindowRect(hWnd, &rect);
|
|
|
2084 ::MapWindowPoints(NULL, m_wndClient.m_hWnd, (LPPOINT)&rect, 2);
|
|
|
2085 ScrollToView(rect);
|
|
|
2086 }
|
|
|
2087
|
|
|
2088 // Implementation - overrideable methods
|
|
|
2089 void UpdateLayout()
|
|
|
2090 {
|
|
|
2091 ATLASSERT(::IsWindow(this->m_hWnd));
|
|
|
2092
|
|
|
2093 if(m_bAutoSizeClient && (m_wndClient.m_hWnd != NULL))
|
|
|
2094 {
|
|
|
2095 T* pT = static_cast<T*>(this);
|
|
|
2096 RECT rect = {};
|
|
|
2097 pT->GetContainerRect(rect);
|
|
|
2098
|
|
|
2099 m_wndClient.SetWindowPos(NULL, &rect, SWP_NOZORDER | SWP_NOMOVE);
|
|
|
2100 }
|
|
|
2101 else
|
|
|
2102 {
|
|
|
2103 this->Invalidate();
|
|
|
2104 }
|
|
|
2105 }
|
|
|
2106
|
|
|
2107 void GetContainerRect(RECT& rect)
|
|
|
2108 {
|
|
|
2109 this->GetClientRect(&rect);
|
|
|
2110
|
|
|
2111 if(rect.right < this->m_sizeAll.cx)
|
|
|
2112 rect.right = this->m_sizeAll.cx;
|
|
|
2113
|
|
|
2114 if(rect.bottom < this->m_sizeAll.cy)
|
|
|
2115 rect.bottom = this->m_sizeAll.cy;
|
|
|
2116 }
|
|
|
2117 };
|
|
|
2118
|
|
|
2119 class CScrollContainer : public CScrollContainerImpl<CScrollContainer>
|
|
|
2120 {
|
|
|
2121 public:
|
|
|
2122 DECLARE_WND_CLASS_EX(_T("WTL_ScrollContainer"), 0, -1)
|
|
|
2123 };
|
|
|
2124
|
|
|
2125 } // namespace WTL
|
|
|
2126
|
|
|
2127 #endif // __ATLSCRL_H__
|
