?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update mojo sdk to rev 1dc8a9a5db73d3718d99917fadf31f5fb2ebad4f
[chromium-blink-merge.git] / third_party / wtl / include / atlctrlx.h
blobe1ce59ed2642cf7bd9068fcb94670aa196d926d1
1 // Windows Template Library - WTL version 8.0
2 // Copyright (C) Microsoft Corporation. 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 Permissive License (Ms-PL) which can be found in the file
7 // Ms-PL.txt at the root of this distribution.
8
9 #ifndef __ATLCTRLX_H__
10 #define __ATLCTRLX_H__
11
12 #pragma once
13
14 #ifndef __cplusplus
15 #error ATL requires C++ compilation (use a .cpp suffix)
16 #endif
17
18 #ifndef __ATLAPP_H__
19 #error atlctrlx.h requires atlapp.h to be included first
20 #endif
21
22 #ifndef __ATLCTRLS_H__
23 #error atlctrlx.h requires atlctrls.h to be included first
24 #endif
25
26 #ifndef WM_UPDATEUISTATE
27 #define WM_UPDATEUISTATE 0x0128
28 #endif // !WM_UPDATEUISTATE
29
30
31 ///////////////////////////////////////////////////////////////////////////////
32 // Classes in this file:
33 //
34 // CBitmapButtonImpl<T, TBase, TWinTraits>
35 // CBitmapButton
36 // CCheckListViewCtrlImpl<T, TBase, TWinTraits>
37 // CCheckListViewCtrl
38 // CHyperLinkImpl<T, TBase, TWinTraits>
39 // CHyperLink
40 // CWaitCursor
41 // CCustomWaitCursor
42 // CMultiPaneStatusBarCtrlImpl<T, TBase>
43 // CMultiPaneStatusBarCtrl
44 // CPaneContainerImpl<T, TBase, TWinTraits>
45 // CPaneContainer
46 // CSortListViewImpl<T>
47 // CSortListViewCtrlImpl<T, TBase, TWinTraits>
48 // CSortListViewCtrl
49 // CTabViewImpl<T, TBase, TWinTraits>
50 // CTabView
51
52 namespace WTL
53 {
54
55 ///////////////////////////////////////////////////////////////////////////////
56 // CBitmapButton - bitmap button implementation
57
58 #ifndef _WIN32_WCE
59
60 // bitmap button extended styles
61 #define BMPBTN_HOVER 0x00000001
62 #define BMPBTN_AUTO3D_SINGLE 0x00000002
63 #define BMPBTN_AUTO3D_DOUBLE 0x00000004
64 #define BMPBTN_AUTOSIZE 0x00000008
65 #define BMPBTN_SHAREIMAGELISTS 0x00000010
66 #define BMPBTN_AUTOFIRE 0x00000020
67
68 template <class T, class TBase = CButton, class TWinTraits = ATL::CControlWinTraits>
69 class ATL_NO_VTABLE CBitmapButtonImpl : public ATL::CWindowImpl< T, TBase, TWinTraits>
70 {
71 public:
72 DECLARE_WND_SUPERCLASS(NULL, TBase::GetWndClassName())
73
74 enum
75 {
76 _nImageNormal = 0,
77 _nImagePushed,
78 _nImageFocusOrHover,
79 _nImageDisabled,
80
81 _nImageCount = 4,
82 };
83
84 enum
85 {
86 ID_TIMER_FIRST = 1000,
87 ID_TIMER_REPEAT = 1001
88 };
89
90 // Bitmap button specific extended styles
91 DWORD m_dwExtendedStyle;
92
93 CImageList m_ImageList;
94 int m_nImage[_nImageCount];
95
96 CToolTipCtrl m_tip;
97 LPTSTR m_lpstrToolTipText;
98
99 // Internal states
100 unsigned m_fMouseOver:1;
101 unsigned m_fFocus:1;
102 unsigned m_fPressed:1;
103
104
105 // Constructor/Destructor
106 CBitmapButtonImpl(DWORD dwExtendedStyle = BMPBTN_AUTOSIZE, HIMAGELIST hImageList = NULL) :
107 m_ImageList(hImageList), m_dwExtendedStyle(dwExtendedStyle),
108 m_lpstrToolTipText(NULL),
109 m_fMouseOver(0), m_fFocus(0), m_fPressed(0)
110 {
111 m_nImage[_nImageNormal] = -1;
112 m_nImage[_nImagePushed] = -1;
113 m_nImage[_nImageFocusOrHover] = -1;
114 m_nImage[_nImageDisabled] = -1;
115 }
116
117 ~CBitmapButtonImpl()
118 {
119 if((m_dwExtendedStyle & BMPBTN_SHAREIMAGELISTS) == 0)
120 m_ImageList.Destroy();
121 delete [] m_lpstrToolTipText;
122 }
123
124 // overridden to provide proper initialization
125 BOOL SubclassWindow(HWND hWnd)
126 {
127 #if (_MSC_VER >= 1300)
128 BOOL bRet = ATL::CWindowImpl< T, TBase, TWinTraits>::SubclassWindow(hWnd);
129 #else // !(_MSC_VER >= 1300)
130 typedef ATL::CWindowImpl< T, TBase, TWinTraits> _baseClass;
131 BOOL bRet = _baseClass::SubclassWindow(hWnd);
132 #endif // !(_MSC_VER >= 1300)
133 if(bRet)
134 Init();
135 return bRet;
136 }
137
138 // Attributes
139 DWORD GetBitmapButtonExtendedStyle() const
140 {
141 return m_dwExtendedStyle;
142 }
143
144 DWORD SetBitmapButtonExtendedStyle(DWORD dwExtendedStyle, DWORD dwMask = 0)
145 {
146 DWORD dwPrevStyle = m_dwExtendedStyle;
147 if(dwMask == 0)
148 m_dwExtendedStyle = dwExtendedStyle;
149 else
150 m_dwExtendedStyle = (m_dwExtendedStyle & ~dwMask) | (dwExtendedStyle & dwMask);
151 return dwPrevStyle;
152 }
153
154 HIMAGELIST GetImageList() const
155 {
156 return m_ImageList;
157 }
158
159 HIMAGELIST SetImageList(HIMAGELIST hImageList)
160 {
161 HIMAGELIST hImageListPrev = m_ImageList;
162 m_ImageList = hImageList;
163 if((m_dwExtendedStyle & BMPBTN_AUTOSIZE) != 0 && ::IsWindow(m_hWnd))
164 SizeToImage();
165 return hImageListPrev;
166 }
167
168 int GetToolTipTextLength() const
169 {
170 return (m_lpstrToolTipText == NULL) ? -1 : lstrlen(m_lpstrToolTipText);
171 }
172
173 bool GetToolTipText(LPTSTR lpstrText, int nLength) const
174 {
175 ATLASSERT(lpstrText != NULL);
176 if(m_lpstrToolTipText == NULL)
177 return false;
178
179 errno_t nRet = SecureHelper::strncpy_x(lpstrText, nLength, m_lpstrToolTipText, _TRUNCATE);
180
181 return (nRet == 0 || nRet == STRUNCATE);
182 }
183
184 bool SetToolTipText(LPCTSTR lpstrText)
185 {
186 if(m_lpstrToolTipText != NULL)
187 {
188 delete [] m_lpstrToolTipText;
189 m_lpstrToolTipText = NULL;
190 }
191
192 if(lpstrText == NULL)
193 {
194 if(m_tip.IsWindow())
195 m_tip.Activate(FALSE);
196 return true;
197 }
198
199 int cchLen = lstrlen(lpstrText) + 1;
200 ATLTRY(m_lpstrToolTipText = new TCHAR[cchLen]);
201 if(m_lpstrToolTipText == NULL)
202 return false;
203
204 SecureHelper::strcpy_x(m_lpstrToolTipText, cchLen, lpstrText);
205 if(m_tip.IsWindow())
206 {
207 m_tip.Activate(TRUE);
208 m_tip.AddTool(m_hWnd, m_lpstrToolTipText);
209 }
210
211 return true;
212 }
213
214 // Operations
215 void SetImages(int nNormal, int nPushed = -1, int nFocusOrHover = -1, int nDisabled = -1)
216 {
217 if(nNormal != -1)
218 m_nImage[_nImageNormal] = nNormal;
219 if(nPushed != -1)
220 m_nImage[_nImagePushed] = nPushed;
221 if(nFocusOrHover != -1)
222 m_nImage[_nImageFocusOrHover] = nFocusOrHover;
223 if(nDisabled != -1)
224 m_nImage[_nImageDisabled] = nDisabled;
225 }
226
227 BOOL SizeToImage()
228 {
229 ATLASSERT(::IsWindow(m_hWnd) && m_ImageList.m_hImageList != NULL);
230 int cx = 0;
231 int cy = 0;
232 if(!m_ImageList.GetIconSize(cx, cy))
233 return FALSE;
234 return ResizeClient(cx, cy);
235 }
236
237 // Overrideables
238 void DoPaint(CDCHandle dc)
239 {
240 ATLASSERT(m_ImageList.m_hImageList != NULL); // image list must be set
241 ATLASSERT(m_nImage[0] != -1); // main bitmap must be set
242
243 // set bitmap according to the current button state
244 int nImage = -1;
245 bool bHover = IsHoverMode();
246 if(!IsWindowEnabled())
247 nImage = m_nImage[_nImageDisabled];
248 else if(m_fPressed == 1)
249 nImage = m_nImage[_nImagePushed];
250 else if((!bHover && m_fFocus == 1) || (bHover && m_fMouseOver == 1))
251 nImage = m_nImage[_nImageFocusOrHover];
252 if(nImage == -1) // not there, use default one
253 nImage = m_nImage[_nImageNormal];
254
255 // draw the button image
256 int xyPos = 0;
257 if((m_fPressed == 1) && ((m_dwExtendedStyle & (BMPBTN_AUTO3D_SINGLE | BMPBTN_AUTO3D_DOUBLE)) != 0) && (m_nImage[_nImagePushed] == -1))
258 xyPos = 1;
259 m_ImageList.Draw(dc, nImage, xyPos, xyPos, ILD_NORMAL);
260
261 // draw 3D border if required
262 if((m_dwExtendedStyle & (BMPBTN_AUTO3D_SINGLE | BMPBTN_AUTO3D_DOUBLE)) != 0)
263 {
264 RECT rect;
265 GetClientRect(&rect);
266
267 if(m_fPressed == 1)
268 dc.DrawEdge(&rect, ((m_dwExtendedStyle & BMPBTN_AUTO3D_SINGLE) != 0) ? BDR_SUNKENOUTER : EDGE_SUNKEN, BF_RECT);
269 else if(!bHover || m_fMouseOver == 1)
270 dc.DrawEdge(&rect, ((m_dwExtendedStyle & BMPBTN_AUTO3D_SINGLE) != 0) ? BDR_RAISEDINNER : EDGE_RAISED, BF_RECT);
271
272 if(!bHover && m_fFocus == 1)
273 {
274 ::InflateRect(&rect, -2 * ::GetSystemMetrics(SM_CXEDGE), -2 * ::GetSystemMetrics(SM_CYEDGE));
275 dc.DrawFocusRect(&rect);
276 }
277 }
278 }
279
280 // Message map and handlers
281 BEGIN_MSG_MAP(CBitmapButtonImpl)
282 MESSAGE_HANDLER(WM_CREATE, OnCreate)
283 MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
284 MESSAGE_RANGE_HANDLER(WM_MOUSEFIRST, WM_MOUSELAST, OnMouseMessage)
285 MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)
286 MESSAGE_HANDLER(WM_PAINT, OnPaint)
287 MESSAGE_HANDLER(WM_PRINTCLIENT, OnPaint)
288 MESSAGE_HANDLER(WM_SETFOCUS, OnFocus)
289 MESSAGE_HANDLER(WM_KILLFOCUS, OnFocus)
290 MESSAGE_HANDLER(WM_LBUTTONDOWN, OnLButtonDown)
291 MESSAGE_HANDLER(WM_LBUTTONDBLCLK, OnLButtonDblClk)
292 MESSAGE_HANDLER(WM_LBUTTONUP, OnLButtonUp)
293 MESSAGE_HANDLER(WM_CAPTURECHANGED, OnCaptureChanged)
294 MESSAGE_HANDLER(WM_ENABLE, OnEnable)
295 MESSAGE_HANDLER(WM_MOUSEMOVE, OnMouseMove)
296 MESSAGE_HANDLER(WM_MOUSELEAVE, OnMouseLeave)
297 MESSAGE_HANDLER(WM_KEYDOWN, OnKeyDown)
298 MESSAGE_HANDLER(WM_KEYUP, OnKeyUp)
299 MESSAGE_HANDLER(WM_TIMER, OnTimer)
300 MESSAGE_HANDLER(WM_UPDATEUISTATE, OnUpdateUiState)
301 END_MSG_MAP()
302
303 LRESULT OnCreate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
304 {
305 Init();
306 bHandled = FALSE;
307 return 1;
308 }
309
310 LRESULT OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
311 {
312 if(m_tip.IsWindow())
313 {
314 m_tip.DestroyWindow();
315 m_tip.m_hWnd = NULL;
316 }
317 bHandled = FALSE;
318 return 1;
319 }
320
321 LRESULT OnMouseMessage(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
322 {
323 MSG msg = { m_hWnd, uMsg, wParam, lParam };
324 if(m_tip.IsWindow())
325 m_tip.RelayEvent(&msg);
326 bHandled = FALSE;
327 return 1;
328 }
329
330 LRESULT OnEraseBackground(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
331 {
332 return 1; // no background needed
333 }
334
335 LRESULT OnPaint(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
336 {
337 T* pT = static_cast<T*>(this);
338 if(wParam != NULL)
339 {
340 pT->DoPaint((HDC)wParam);
341 }
342 else
343 {
344 CPaintDC dc(m_hWnd);
345 pT->DoPaint(dc.m_hDC);
346 }
347 return 0;
348 }
349
350 LRESULT OnFocus(UINT uMsg, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
351 {
352 m_fFocus = (uMsg == WM_SETFOCUS) ? 1 : 0;
353 Invalidate();
354 UpdateWindow();
355 bHandled = FALSE;
356 return 1;
357 }
358
359 LRESULT OnLButtonDown(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
360 {
361 LRESULT lRet = 0;
362 if(IsHoverMode())
363 SetCapture();
364 else
365 lRet = DefWindowProc(uMsg, wParam, lParam);
366 if(::GetCapture() == m_hWnd)
367 {
368 m_fPressed = 1;
369 Invalidate();
370 UpdateWindow();
371 }
372 if((m_dwExtendedStyle & BMPBTN_AUTOFIRE) != 0)
373 {
374 int nElapse = 250;
375 int nDelay = 0;
376 if(::SystemParametersInfo(SPI_GETKEYBOARDDELAY, 0, &nDelay, 0))
377 nElapse += nDelay * 250; // all milli-seconds
378 SetTimer(ID_TIMER_FIRST, nElapse);
379 }
380 return lRet;
381 }
382
383 LRESULT OnLButtonDblClk(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
384 {
385 LRESULT lRet = 0;
386 if(!IsHoverMode())
387 lRet = DefWindowProc(uMsg, wParam, lParam);
388 if(::GetCapture() != m_hWnd)
389 SetCapture();
390 if(m_fPressed == 0)
391 {
392 m_fPressed = 1;
393 Invalidate();
394 UpdateWindow();
395 }
396 return lRet;
397 }
398
399 LRESULT OnLButtonUp(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
400 {
401 LRESULT lRet = 0;
402 bool bHover = IsHoverMode();
403 if(!bHover)
404 lRet = DefWindowProc(uMsg, wParam, lParam);
405 if(::GetCapture() == m_hWnd)
406 {
407 if(bHover && m_fPressed == 1)
408 ::SendMessage(GetParent(), WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(), BN_CLICKED), (LPARAM)m_hWnd);
409 ::ReleaseCapture();
410 }
411 return lRet;
412 }
413
414 LRESULT OnCaptureChanged(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
415 {
416 if(m_fPressed == 1)
417 {
418 m_fPressed = 0;
419 Invalidate();
420 UpdateWindow();
421 }
422 bHandled = FALSE;
423 return 1;
424 }
425
426 LRESULT OnEnable(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
427 {
428 Invalidate();
429 UpdateWindow();
430 bHandled = FALSE;
431 return 1;
432 }
433
434 LRESULT OnMouseMove(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
435 {
436 if(::GetCapture() == m_hWnd)
437 {
438 POINT ptCursor = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
439 ClientToScreen(&ptCursor);
440 RECT rect = { 0 };
441 GetWindowRect(&rect);
442 unsigned int uPressed = ::PtInRect(&rect, ptCursor) ? 1 : 0;
443 if(m_fPressed != uPressed)
444 {
445 m_fPressed = uPressed;
446 Invalidate();
447 UpdateWindow();
448 }
449 }
450 else if(IsHoverMode() && m_fMouseOver == 0)
451 {
452 m_fMouseOver = 1;
453 Invalidate();
454 UpdateWindow();
455 StartTrackMouseLeave();
456 }
457 bHandled = FALSE;
458 return 1;
459 }
460
461 LRESULT OnMouseLeave(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
462 {
463 if(m_fMouseOver == 1)
464 {
465 m_fMouseOver = 0;
466 Invalidate();
467 UpdateWindow();
468 }
469 return 0;
470 }
471
472 LRESULT OnKeyDown(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
473 {
474 if(wParam == VK_SPACE && IsHoverMode())
475 return 0; // ignore if in hover mode
476 if(wParam == VK_SPACE && m_fPressed == 0)
477 {
478 m_fPressed = 1;
479 Invalidate();
480 UpdateWindow();
481 }
482 bHandled = FALSE;
483 return 1;
484 }
485
486 LRESULT OnKeyUp(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
487 {
488 if(wParam == VK_SPACE && IsHoverMode())
489 return 0; // ignore if in hover mode
490 if(wParam == VK_SPACE && m_fPressed == 1)
491 {
492 m_fPressed = 0;
493 Invalidate();
494 UpdateWindow();
495 }
496 bHandled = FALSE;
497 return 1;
498 }
499
500 LRESULT OnTimer(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
501 {
502 ATLASSERT((m_dwExtendedStyle & BMPBTN_AUTOFIRE) != 0);
503 switch(wParam) // timer ID
504 {
505 case ID_TIMER_FIRST:
506 KillTimer(ID_TIMER_FIRST);
507 if(m_fPressed == 1)
508 {
509 ::SendMessage(GetParent(), WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(), BN_CLICKED), (LPARAM)m_hWnd);
510 int nElapse = 250;
511 int nRepeat = 40;
512 if(::SystemParametersInfo(SPI_GETKEYBOARDSPEED, 0, &nRepeat, 0))
513 nElapse = 10000 / (10 * nRepeat + 25); // milli-seconds, approximated
514 SetTimer(ID_TIMER_REPEAT, nElapse);
515 }
516 break;
517 case ID_TIMER_REPEAT:
518 if(m_fPressed == 1)
519 ::SendMessage(GetParent(), WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(), BN_CLICKED), (LPARAM)m_hWnd);
520 else if(::GetCapture() != m_hWnd)
521 KillTimer(ID_TIMER_REPEAT);
522 break;
523 default: // not our timer
524 break;
525 }
526 return 0;
527 }
528
529 LRESULT OnUpdateUiState(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
530 {
531 // If the control is subclassed or superclassed, this message can cause
532 // repainting without WM_PAINT. We don't use this state, so just do nothing.
533 return 0;
534 }
535
536 // Implementation
537 void Init()
538 {
539 // We need this style to prevent Windows from painting the button
540 ModifyStyle(0, BS_OWNERDRAW);
541
542 // create a tool tip
543 m_tip.Create(m_hWnd);
544 ATLASSERT(m_tip.IsWindow());
545 if(m_tip.IsWindow() && m_lpstrToolTipText != NULL)
546 {
547 m_tip.Activate(TRUE);
548 m_tip.AddTool(m_hWnd, m_lpstrToolTipText);
549 }
550
551 if(m_ImageList.m_hImageList != NULL && (m_dwExtendedStyle & BMPBTN_AUTOSIZE) != 0)
552 SizeToImage();
553 }
554
555 BOOL StartTrackMouseLeave()
556 {
557 TRACKMOUSEEVENT tme = { 0 };
558 tme.cbSize = sizeof(tme);
559 tme.dwFlags = TME_LEAVE;
560 tme.hwndTrack = m_hWnd;
561 return _TrackMouseEvent(&tme);
562 }
563
564 bool IsHoverMode() const
565 {
566 return ((m_dwExtendedStyle & BMPBTN_HOVER) != 0);
567 }
568 };
569
570
571 class CBitmapButton : public CBitmapButtonImpl<CBitmapButton>
572 {
573 public:
574 DECLARE_WND_SUPERCLASS(_T("WTL_BitmapButton"), GetWndClassName())
575
576 CBitmapButton(DWORD dwExtendedStyle = BMPBTN_AUTOSIZE, HIMAGELIST hImageList = NULL) :
577 CBitmapButtonImpl<CBitmapButton>(dwExtendedStyle, hImageList)
578 { }
579 };
580
581 #endif // !_WIN32_WCE
582
583
584 ///////////////////////////////////////////////////////////////////////////////
585 // CCheckListCtrlView - list view control with check boxes
586
587 template <DWORD t_dwStyle, DWORD t_dwExStyle, DWORD t_dwExListViewStyle>
588 class CCheckListViewCtrlImplTraits
589 {
590 public:
591 static DWORD GetWndStyle(DWORD dwStyle)
592 {
593 return (dwStyle == 0) ? t_dwStyle : dwStyle;
594 }
595
596 static DWORD GetWndExStyle(DWORD dwExStyle)
597 {
598 return (dwExStyle == 0) ? t_dwExStyle : dwExStyle;
599 }
600
601 static DWORD GetExtendedLVStyle()
602 {
603 return t_dwExListViewStyle;
604 }
605 };
606
607 typedef CCheckListViewCtrlImplTraits<WS_CHILD | WS_VISIBLE | LVS_REPORT | LVS_SHOWSELALWAYS, WS_EX_CLIENTEDGE, LVS_EX_CHECKBOXES | LVS_EX_FULLROWSELECT> CCheckListViewCtrlTraits;
608
609 template <class T, class TBase = CListViewCtrl, class TWinTraits = CCheckListViewCtrlTraits>
610 class ATL_NO_VTABLE CCheckListViewCtrlImpl : public ATL::CWindowImpl<T, TBase, TWinTraits>
611 {
612 public:
613 DECLARE_WND_SUPERCLASS(NULL, TBase::GetWndClassName())
614
615 // Attributes
616 static DWORD GetExtendedLVStyle()
617 {
618 return TWinTraits::GetExtendedLVStyle();
619 }
620
621 // Operations
622 BOOL SubclassWindow(HWND hWnd)
623 {
624 #if (_MSC_VER >= 1300)
625 BOOL bRet = ATL::CWindowImplBaseT< TBase, TWinTraits>::SubclassWindow(hWnd);
626 #else // !(_MSC_VER >= 1300)
627 typedef ATL::CWindowImplBaseT< TBase, TWinTraits> _baseClass;
628 BOOL bRet = _baseClass::SubclassWindow(hWnd);
629 #endif // !(_MSC_VER >= 1300)
630 if(bRet)
631 {
632 T* pT = static_cast<T*>(this);
633 pT;
634 ATLASSERT((pT->GetExtendedLVStyle() & LVS_EX_CHECKBOXES) != 0);
635 SetExtendedListViewStyle(pT->GetExtendedLVStyle());
636 }
637 return bRet;
638 }
639
640 void CheckSelectedItems(int nCurrItem)
641 {
642 // first check if this item is selected
643 LVITEM lvi = { 0 };
644 lvi.iItem = nCurrItem;
645 lvi.iSubItem = 0;
646 lvi.mask = LVIF_STATE;
647 lvi.stateMask = LVIS_SELECTED;
648 GetItem(&lvi);
649 // if item is not selected, don't do anything
650 if(!(lvi.state & LVIS_SELECTED))
651 return;
652 // new check state will be reverse of the current state,
653 BOOL bCheck = !GetCheckState(nCurrItem);
654 int nItem = -1;
655 int nOldItem = -1;
656 while((nItem = GetNextItem(nOldItem, LVNI_SELECTED)) != -1)
657 {
658 if(nItem != nCurrItem)
659 SetCheckState(nItem, bCheck);
660 nOldItem = nItem;
661 }
662 }
663
664 // Implementation
665 BEGIN_MSG_MAP(CCheckListViewCtrlImpl)
666 MESSAGE_HANDLER(WM_CREATE, OnCreate)
667 MESSAGE_HANDLER(WM_LBUTTONDOWN, OnLButtonDown)
668 MESSAGE_HANDLER(WM_LBUTTONDBLCLK, OnLButtonDown)
669 MESSAGE_HANDLER(WM_KEYDOWN, OnKeyDown)
670 END_MSG_MAP()
671
672 LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
673 {
674 // first let list view control initialize everything
675 LRESULT lRet = DefWindowProc(uMsg, wParam, lParam);
676 T* pT = static_cast<T*>(this);
677 pT;
678 ATLASSERT((pT->GetExtendedLVStyle() & LVS_EX_CHECKBOXES) != 0);
679 SetExtendedListViewStyle(pT->GetExtendedLVStyle());
680 return lRet;
681 }
682
683 LRESULT OnLButtonDown(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
684 {
685 POINT ptMsg = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
686 LVHITTESTINFO lvh = { 0 };
687 lvh.pt = ptMsg;
688 if(HitTest(&lvh) != -1 && lvh.flags == LVHT_ONITEMSTATEICON && ::GetKeyState(VK_CONTROL) >= 0)
689 {
690 T* pT = static_cast<T*>(this);
691 pT->CheckSelectedItems(lvh.iItem);
692 }
693 bHandled = FALSE;
694 return 1;
695 }
696
697 LRESULT OnKeyDown(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
698 {
699 if(wParam == VK_SPACE)
700 {
701 int nCurrItem = GetNextItem(-1, LVNI_FOCUSED);
702 if(nCurrItem != -1 && ::GetKeyState(VK_CONTROL) >= 0)
703 {
704 T* pT = static_cast<T*>(this);
705 pT->CheckSelectedItems(nCurrItem);
706 }
707 }
708 bHandled = FALSE;
709 return 1;
710 }
711 };
712
713 class CCheckListViewCtrl : public CCheckListViewCtrlImpl<CCheckListViewCtrl>
714 {
715 public:
716 DECLARE_WND_SUPERCLASS(_T("WTL_CheckListView"), GetWndClassName())
717 };
718
719
720 ///////////////////////////////////////////////////////////////////////////////
721 // CHyperLink - hyper link control implementation
722
723 #if (WINVER < 0x0500) && !defined(_WIN32_WCE)
724 __declspec(selectany) struct
725 {
726 enum { cxWidth = 32, cyHeight = 32 };
727 int xHotSpot;
728 int yHotSpot;
729 unsigned char arrANDPlane[cxWidth * cyHeight / 8];
730 unsigned char arrXORPlane[cxWidth * cyHeight / 8];
731 } _AtlHyperLink_CursorData =
732 {
733 5, 0,
734 {
735 0xF9, 0xFF, 0xFF, 0xFF, 0xF0, 0xFF, 0xFF, 0xFF, 0xF0, 0xFF, 0xFF, 0xFF, 0xF0, 0xFF, 0xFF, 0xFF,
736 0xF0, 0xFF, 0xFF, 0xFF, 0xF0, 0x3F, 0xFF, 0xFF, 0xF0, 0x07, 0xFF, 0xFF, 0xF0, 0x01, 0xFF, 0xFF,
737 0xF0, 0x00, 0xFF, 0xFF, 0x10, 0x00, 0x7F, 0xFF, 0x00, 0x00, 0x7F, 0xFF, 0x00, 0x00, 0x7F, 0xFF,
738 0x80, 0x00, 0x7F, 0xFF, 0xC0, 0x00, 0x7F, 0xFF, 0xC0, 0x00, 0x7F, 0xFF, 0xE0, 0x00, 0x7F, 0xFF,
739 0xE0, 0x00, 0xFF, 0xFF, 0xF0, 0x00, 0xFF, 0xFF, 0xF0, 0x00, 0xFF, 0xFF, 0xF8, 0x01, 0xFF, 0xFF,
740 0xF8, 0x01, 0xFF, 0xFF, 0xF8, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
741 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
742 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
743 },
744 {
745 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
746 0x06, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x06, 0xC0, 0x00, 0x00, 0x06, 0xD8, 0x00, 0x00,
747 0x06, 0xDA, 0x00, 0x00, 0x06, 0xDB, 0x00, 0x00, 0x67, 0xFB, 0x00, 0x00, 0x77, 0xFF, 0x00, 0x00,
748 0x37, 0xFF, 0x00, 0x00, 0x17, 0xFF, 0x00, 0x00, 0x1F, 0xFF, 0x00, 0x00, 0x0F, 0xFF, 0x00, 0x00,
749 0x0F, 0xFE, 0x00, 0x00, 0x07, 0xFE, 0x00, 0x00, 0x07, 0xFE, 0x00, 0x00, 0x03, 0xFC, 0x00, 0x00,
750 0x03, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
751 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
752 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
753 }
754 };
755 #endif // (WINVER < 0x0500) && !defined(_WIN32_WCE)
756
757 #define HLINK_UNDERLINED 0x00000000
758 #define HLINK_NOTUNDERLINED 0x00000001
759 #define HLINK_UNDERLINEHOVER 0x00000002
760 #define HLINK_COMMANDBUTTON 0x00000004
761 #define HLINK_NOTIFYBUTTON 0x0000000C
762 #define HLINK_USETAGS 0x00000010
763 #define HLINK_USETAGSBOLD 0x00000030
764 #define HLINK_NOTOOLTIP 0x00000040
765
766 // Notes:
767 // - HLINK_USETAGS and HLINK_USETAGSBOLD are always left-aligned
768 // - When HLINK_USETAGSBOLD is used, the underlined styles will be ignored
769
770 template <class T, class TBase = ATL::CWindow, class TWinTraits = ATL::CControlWinTraits>
771 class ATL_NO_VTABLE CHyperLinkImpl : public ATL::CWindowImpl< T, TBase, TWinTraits >
772 {
773 public:
774 LPTSTR m_lpstrLabel;
775 LPTSTR m_lpstrHyperLink;
776
777 HCURSOR m_hCursor;
778 HFONT m_hFont;
779 HFONT m_hFontNormal;
780
781 RECT m_rcLink;
782 #ifndef _WIN32_WCE
783 CToolTipCtrl m_tip;
784 #endif // !_WIN32_WCE
785
786 COLORREF m_clrLink;
787 COLORREF m_clrVisited;
788
789 DWORD m_dwExtendedStyle; // Hyper Link specific extended styles
790
791 bool m_bPaintLabel:1;
792 bool m_bVisited:1;
793 bool m_bHover:1;
794 bool m_bInternalLinkFont:1;
795
796
797 // Constructor/Destructor
798 CHyperLinkImpl(DWORD dwExtendedStyle = HLINK_UNDERLINED) :
799 m_lpstrLabel(NULL), m_lpstrHyperLink(NULL),
800 m_hCursor(NULL), m_hFont(NULL), m_hFontNormal(NULL),
801 m_clrLink(RGB(0, 0, 255)), m_clrVisited(RGB(128, 0, 128)),
802 m_dwExtendedStyle(dwExtendedStyle),
803 m_bPaintLabel(true), m_bVisited(false),
804 m_bHover(false), m_bInternalLinkFont(false)
805 {
806 ::SetRectEmpty(&m_rcLink);
807 }
808
809 ~CHyperLinkImpl()
810 {
811 delete [] m_lpstrLabel;
812 delete [] m_lpstrHyperLink;
813 if(m_bInternalLinkFont && m_hFont != NULL)
814 ::DeleteObject(m_hFont);
815 #if (WINVER < 0x0500) && !defined(_WIN32_WCE)
816 // It was created, not loaded, so we have to destroy it
817 if(m_hCursor != NULL)
818 ::DestroyCursor(m_hCursor);
819 #endif // (WINVER < 0x0500) && !defined(_WIN32_WCE)
820 }
821
822 // Attributes
823 DWORD GetHyperLinkExtendedStyle() const
824 {
825 return m_dwExtendedStyle;
826 }
827
828 DWORD SetHyperLinkExtendedStyle(DWORD dwExtendedStyle, DWORD dwMask = 0)
829 {
830 DWORD dwPrevStyle = m_dwExtendedStyle;
831 if(dwMask == 0)
832 m_dwExtendedStyle = dwExtendedStyle;
833 else
834 m_dwExtendedStyle = (m_dwExtendedStyle & ~dwMask) | (dwExtendedStyle & dwMask);
835 return dwPrevStyle;
836 }
837
838 bool GetLabel(LPTSTR lpstrBuffer, int nLength) const
839 {
840 if(m_lpstrLabel == NULL)
841 return false;
842 ATLASSERT(lpstrBuffer != NULL);
843 if(nLength <= lstrlen(m_lpstrLabel))
844 return false;
845
846 SecureHelper::strcpy_x(lpstrBuffer, nLength, m_lpstrLabel);
847
848 return true;
849 }
850
851 bool SetLabel(LPCTSTR lpstrLabel)
852 {
853 delete [] m_lpstrLabel;
854 m_lpstrLabel = NULL;
855 int cchLen = lstrlen(lpstrLabel) + 1;
856 ATLTRY(m_lpstrLabel = new TCHAR[cchLen]);
857 if(m_lpstrLabel == NULL)
858 return false;
859
860 SecureHelper::strcpy_x(m_lpstrLabel, cchLen, lpstrLabel);
861 T* pT = static_cast<T*>(this);
862 pT->CalcLabelRect();
863
864 if(m_hWnd != NULL)
865 SetWindowText(lpstrLabel); // Set this for accessibility
866
867 return true;
868 }
869
870 bool GetHyperLink(LPTSTR lpstrBuffer, int nLength) const
871 {
872 if(m_lpstrHyperLink == NULL)
873 return false;
874 ATLASSERT(lpstrBuffer != NULL);
875 if(nLength <= lstrlen(m_lpstrHyperLink))
876 return false;
877
878 SecureHelper::strcpy_x(lpstrBuffer, nLength, m_lpstrHyperLink);
879
880 return true;
881 }
882
883 bool SetHyperLink(LPCTSTR lpstrLink)
884 {
885 delete [] m_lpstrHyperLink;
886 m_lpstrHyperLink = NULL;
887 int cchLen = lstrlen(lpstrLink) + 1;
888 ATLTRY(m_lpstrHyperLink = new TCHAR[cchLen]);
889 if(m_lpstrHyperLink == NULL)
890 return false;
891
892 SecureHelper::strcpy_x(m_lpstrHyperLink, cchLen, lpstrLink);
893 if(m_lpstrLabel == NULL)
894 {
895 T* pT = static_cast<T*>(this);
896 pT->CalcLabelRect();
897 }
898 #ifndef _WIN32_WCE
899 if(m_tip.IsWindow())
900 {
901 m_tip.Activate(TRUE);
902 m_tip.AddTool(m_hWnd, m_lpstrHyperLink, &m_rcLink, 1);
903 }
904 #endif // !_WIN32_WCE
905 return true;
906 }
907
908 HFONT GetLinkFont() const
909 {
910 return m_hFont;
911 }
912
913 void SetLinkFont(HFONT hFont)
914 {
915 if(m_bInternalLinkFont && m_hFont != NULL)
916 {
917 ::DeleteObject(m_hFont);
918 m_bInternalLinkFont = false;
919 }
920 m_hFont = hFont;
921 }
922
923 int GetIdealHeight() const
924 {
925 ATLASSERT(::IsWindow(m_hWnd));
926 if(m_lpstrLabel == NULL && m_lpstrHyperLink == NULL)
927 return -1;
928 if(!m_bPaintLabel)
929 return -1;
930
931 CClientDC dc(m_hWnd);
932 RECT rect = { 0 };
933 GetClientRect(&rect);
934 HFONT hFontOld = dc.SelectFont(m_hFontNormal);
935 RECT rcText = rect;
936 dc.DrawText(_T("NS"), -1, &rcText, DT_LEFT | DT_WORDBREAK | DT_CALCRECT);
937 dc.SelectFont(m_hFont);
938 RECT rcLink = rect;
939 dc.DrawText(_T("NS"), -1, &rcLink, DT_LEFT | DT_WORDBREAK | DT_CALCRECT);
940 dc.SelectFont(hFontOld);
941 return __max(rcText.bottom - rcText.top, rcLink.bottom - rcLink.top);
942 }
943
944 bool GetIdealSize(SIZE& size) const
945 {
946 int cx = 0, cy = 0;
947 bool bRet = GetIdealSize(cx, cy);
948 if(bRet)
949 {
950 size.cx = cx;
951 size.cy = cy;
952 }
953 return bRet;
954 }
955
956 bool GetIdealSize(int& cx, int& cy) const
957 {
958 ATLASSERT(::IsWindow(m_hWnd));
959 if(m_lpstrLabel == NULL && m_lpstrHyperLink == NULL)
960 return false;
961 if(!m_bPaintLabel)
962 return false;
963
964 CClientDC dc(m_hWnd);
965 RECT rcClient = { 0 };
966 GetClientRect(&rcClient);
967 RECT rcAll = rcClient;
968
969 if(IsUsingTags())
970 {
971 // find tags and label parts
972 LPTSTR lpstrLeft = NULL;
973 int cchLeft = 0;
974 LPTSTR lpstrLink = NULL;
975 int cchLink = 0;
976 LPTSTR lpstrRight = NULL;
977 int cchRight = 0;
978
979 const T* pT = static_cast<const T*>(this);
980 pT->CalcLabelParts(lpstrLeft, cchLeft, lpstrLink, cchLink, lpstrRight, cchRight);
981
982 // get label part rects
983 HFONT hFontOld = dc.SelectFont(m_hFontNormal);
984 RECT rcLeft = rcClient;
985 dc.DrawText(lpstrLeft, cchLeft, &rcLeft, DT_LEFT | DT_WORDBREAK | DT_CALCRECT);
986
987 dc.SelectFont(m_hFont);
988 RECT rcLink = { rcLeft.right, rcLeft.top, rcClient.right, rcClient.bottom };
989 dc.DrawText(lpstrLink, cchLink, &rcLink, DT_LEFT | DT_WORDBREAK | DT_CALCRECT);
990
991 dc.SelectFont(m_hFontNormal);
992 RECT rcRight = { rcLink.right, rcLink.top, rcClient.right, rcClient.bottom };
993 dc.DrawText(lpstrRight, cchRight, &rcRight, DT_LEFT | DT_WORDBREAK | DT_CALCRECT);
994
995 dc.SelectFont(hFontOld);
996
997 int cyMax = __max(rcLeft.bottom, max(rcLink.bottom, rcRight.bottom));
998 ::SetRect(&rcAll, rcLeft.left, rcLeft.top, rcRight.right, cyMax);
999 }
1000 else
1001 {
1002 HFONT hOldFont = NULL;
1003 if(m_hFont != NULL)
1004 hOldFont = dc.SelectFont(m_hFont);
1005 LPTSTR lpstrText = (m_lpstrLabel != NULL) ? m_lpstrLabel : m_lpstrHyperLink;
1006 DWORD dwStyle = GetStyle();
1007 int nDrawStyle = DT_LEFT;
1008 if (dwStyle & SS_CENTER)
1009 nDrawStyle = DT_CENTER;
1010 else if (dwStyle & SS_RIGHT)
1011 nDrawStyle = DT_RIGHT;
1012 dc.DrawText(lpstrText, -1, &rcAll, nDrawStyle | DT_WORDBREAK | DT_CALCRECT);
1013 if(m_hFont != NULL)
1014 dc.SelectFont(hOldFont);
1015 if (dwStyle & SS_CENTER)
1016 {
1017 int dx = (rcClient.right - rcAll.right) / 2;
1018 ::OffsetRect(&rcAll, dx, 0);
1019 }
1020 else if (dwStyle & SS_RIGHT)
1021 {
1022 int dx = rcClient.right - rcAll.right;
1023 ::OffsetRect(&rcAll, dx, 0);
1024 }
1025 }
1026
1027 cx = rcAll.right - rcAll.left;
1028 cy = rcAll.bottom - rcAll.top;
1029
1030 return true;
1031 }
1032
1033 // for command buttons only
1034 bool GetToolTipText(LPTSTR lpstrBuffer, int nLength) const
1035 {
1036 ATLASSERT(IsCommandButton());
1037 return GetHyperLink(lpstrBuffer, nLength);
1038 }
1039
1040 bool SetToolTipText(LPCTSTR lpstrToolTipText)
1041 {
1042 ATLASSERT(IsCommandButton());
1043 return SetHyperLink(lpstrToolTipText);
1044 }
1045
1046 // Operations
1047 BOOL SubclassWindow(HWND hWnd)
1048 {
1049 ATLASSERT(m_hWnd == NULL);
1050 ATLASSERT(::IsWindow(hWnd));
1051 #if (_MSC_VER >= 1300)
1052 BOOL bRet = ATL::CWindowImpl< T, TBase, TWinTraits>::SubclassWindow(hWnd);
1053 #else // !(_MSC_VER >= 1300)
1054 typedef ATL::CWindowImpl< T, TBase, TWinTraits> _baseClass;
1055 BOOL bRet = _baseClass::SubclassWindow(hWnd);
1056 #endif // !(_MSC_VER >= 1300)
1057 if(bRet)
1058 {
1059 T* pT = static_cast<T*>(this);
1060 pT->Init();
1061 }
1062 return bRet;
1063 }
1064
1065 bool Navigate()
1066 {
1067 ATLASSERT(::IsWindow(m_hWnd));
1068 bool bRet = true;
1069 if(IsNotifyButton())
1070 {
1071 NMHDR nmhdr = { m_hWnd, GetDlgCtrlID(), NM_CLICK };
1072 ::SendMessage(GetParent(), WM_NOTIFY, GetDlgCtrlID(), (LPARAM)&nmhdr);
1073 }
1074 else if(IsCommandButton())
1075 {
1076 ::SendMessage(GetParent(), WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(), BN_CLICKED), (LPARAM)m_hWnd);
1077 }
1078 else
1079 {
1080 ATLASSERT(m_lpstrHyperLink != NULL);
1081 #ifndef _WIN32_WCE
1082 DWORD_PTR dwRet = (DWORD_PTR)::ShellExecute(0, _T("open"), m_lpstrHyperLink, 0, 0, SW_SHOWNORMAL);
1083 bRet = (dwRet > 32);
1084 #else // CE specific
1085 SHELLEXECUTEINFO shExeInfo = { sizeof(SHELLEXECUTEINFO), 0, 0, L"open", m_lpstrHyperLink, 0, 0, SW_SHOWNORMAL, 0, 0, 0, 0, 0, 0, 0 };
1086 ::ShellExecuteEx(&shExeInfo);
1087 DWORD_PTR dwRet = (DWORD_PTR)shExeInfo.hInstApp;
1088 bRet = (dwRet == 0) || (dwRet > 32);
1089 #endif // _WIN32_WCE
1090 ATLASSERT(bRet);
1091 if(bRet)
1092 {
1093 m_bVisited = true;
1094 Invalidate();
1095 }
1096 }
1097 return bRet;
1098 }
1099
1100 // Message map and handlers
1101 BEGIN_MSG_MAP(CHyperLinkImpl)
1102 MESSAGE_HANDLER(WM_CREATE, OnCreate)
1103 #ifndef _WIN32_WCE
1104 MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
1105 MESSAGE_RANGE_HANDLER(WM_MOUSEFIRST, WM_MOUSELAST, OnMouseMessage)
1106 #endif // !_WIN32_WCE
1107 MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)
1108 MESSAGE_HANDLER(WM_PAINT, OnPaint)
1109 #ifndef _WIN32_WCE
1110 MESSAGE_HANDLER(WM_PRINTCLIENT, OnPaint)
1111 #endif // !_WIN32_WCE
1112 MESSAGE_HANDLER(WM_SETFOCUS, OnFocus)
1113 MESSAGE_HANDLER(WM_KILLFOCUS, OnFocus)
1114 MESSAGE_HANDLER(WM_MOUSEMOVE, OnMouseMove)
1115 #ifndef _WIN32_WCE
1116 MESSAGE_HANDLER(WM_MOUSELEAVE, OnMouseLeave)
1117 #endif // !_WIN32_WCE
1118 MESSAGE_HANDLER(WM_LBUTTONDOWN, OnLButtonDown)
1119 MESSAGE_HANDLER(WM_LBUTTONUP, OnLButtonUp)
1120 MESSAGE_HANDLER(WM_CHAR, OnChar)
1121 MESSAGE_HANDLER(WM_GETDLGCODE, OnGetDlgCode)
1122 MESSAGE_HANDLER(WM_SETCURSOR, OnSetCursor)
1123 MESSAGE_HANDLER(WM_ENABLE, OnEnable)
1124 MESSAGE_HANDLER(WM_GETFONT, OnGetFont)
1125 MESSAGE_HANDLER(WM_SETFONT, OnSetFont)
1126 MESSAGE_HANDLER(WM_UPDATEUISTATE, OnUpdateUiState)
1127 MESSAGE_HANDLER(WM_SIZE, OnSize)
1128 END_MSG_MAP()
1129
1130 LRESULT OnCreate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
1131 {
1132 T* pT = static_cast<T*>(this);
1133 pT->Init();
1134 return 0;
1135 }
1136
1137 #ifndef _WIN32_WCE
1138 LRESULT OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
1139 {
1140 if(m_tip.IsWindow())
1141 {
1142 m_tip.DestroyWindow();
1143 m_tip.m_hWnd = NULL;
1144 }
1145 bHandled = FALSE;
1146 return 1;
1147 }
1148
1149 LRESULT OnMouseMessage(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1150 {
1151 MSG msg = { m_hWnd, uMsg, wParam, lParam };
1152 if(m_tip.IsWindow() && IsUsingToolTip())
1153 m_tip.RelayEvent(&msg);
1154 bHandled = FALSE;
1155 return 1;
1156 }
1157 #endif // !_WIN32_WCE
1158
1159 LRESULT OnEraseBackground(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
1160 {
1161 return 1; // no background painting needed (we do it all during WM_PAINT)
1162 }
1163
1164 LRESULT OnPaint(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
1165 {
1166 if(!m_bPaintLabel)
1167 {
1168 bHandled = FALSE;
1169 return 1;
1170 }
1171
1172 T* pT = static_cast<T*>(this);
1173 if(wParam != NULL)
1174 {
1175 pT->DoEraseBackground((HDC)wParam);
1176 pT->DoPaint((HDC)wParam);
1177 }
1178 else
1179 {
1180 CPaintDC dc(m_hWnd);
1181 pT->DoEraseBackground(dc.m_hDC);
1182 pT->DoPaint(dc.m_hDC);
1183 }
1184
1185 return 0;
1186 }
1187
1188 LRESULT OnFocus(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
1189 {
1190 if(m_bPaintLabel)
1191 Invalidate();
1192 else
1193 bHandled = FALSE;
1194 return 0;
1195 }
1196
1197 LRESULT OnMouseMove(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
1198 {
1199 POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
1200 if((m_lpstrHyperLink != NULL || IsCommandButton()) && ::PtInRect(&m_rcLink, pt))
1201 {
1202 ::SetCursor(m_hCursor);
1203 if(IsUnderlineHover())
1204 {
1205 if(!m_bHover)
1206 {
1207 m_bHover = true;
1208 InvalidateRect(&m_rcLink);
1209 UpdateWindow();
1210 #ifndef _WIN32_WCE
1211 StartTrackMouseLeave();
1212 #endif // !_WIN32_WCE
1213 }
1214 }
1215 }
1216 else
1217 {
1218 if(IsUnderlineHover())
1219 {
1220 if(m_bHover)
1221 {
1222 m_bHover = false;
1223 InvalidateRect(&m_rcLink);
1224 UpdateWindow();
1225 }
1226 }
1227 bHandled = FALSE;
1228 }
1229 return 0;
1230 }
1231
1232 #ifndef _WIN32_WCE
1233 LRESULT OnMouseLeave(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
1234 {
1235 if(IsUnderlineHover() && m_bHover)
1236 {
1237 m_bHover = false;
1238 InvalidateRect(&m_rcLink);
1239 UpdateWindow();
1240 }
1241 return 0;
1242 }
1243 #endif // !_WIN32_WCE
1244
1245 LRESULT OnLButtonDown(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/)
1246 {
1247 POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
1248 if(::PtInRect(&m_rcLink, pt))
1249 {
1250 SetFocus();
1251 SetCapture();
1252 }
1253 return 0;
1254 }
1255
1256 LRESULT OnLButtonUp(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/)
1257 {
1258 if(GetCapture() == m_hWnd)
1259 {
1260 ReleaseCapture();
1261 POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
1262 if(::PtInRect(&m_rcLink, pt))
1263 {
1264 T* pT = static_cast<T*>(this);
1265 pT->Navigate();
1266 }
1267 }
1268 return 0;
1269 }
1270
1271 LRESULT OnChar(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
1272 {
1273 if(wParam == VK_RETURN || wParam == VK_SPACE)
1274 {
1275 T* pT = static_cast<T*>(this);
1276 pT->Navigate();
1277 }
1278 return 0;
1279 }
1280
1281 LRESULT OnGetDlgCode(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
1282 {
1283 return DLGC_WANTCHARS;
1284 }
1285
1286 LRESULT OnSetCursor(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
1287 {
1288 POINT pt = { 0, 0 };
1289 GetCursorPos(&pt);
1290 ScreenToClient(&pt);
1291 if((m_lpstrHyperLink != NULL || IsCommandButton()) && ::PtInRect(&m_rcLink, pt))
1292 {
1293 return TRUE;
1294 }
1295 bHandled = FALSE;
1296 return FALSE;
1297 }
1298
1299 LRESULT OnEnable(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
1300 {
1301 Invalidate();
1302 UpdateWindow();
1303 return 0;
1304 }
1305
1306 LRESULT OnGetFont(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
1307 {
1308 return (LRESULT)m_hFontNormal;
1309 }
1310
1311 LRESULT OnSetFont(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
1312 {
1313 m_hFontNormal = (HFONT)wParam;
1314 if((BOOL)lParam)
1315 {
1316 Invalidate();
1317 UpdateWindow();
1318 }
1319 return 0;
1320 }
1321
1322 LRESULT OnUpdateUiState(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
1323 {
1324 // If the control is subclassed or superclassed, this message can cause
1325 // repainting without WM_PAINT. We don't use this state, so just do nothing.
1326 return 0;
1327 }
1328
1329 LRESULT OnSize(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
1330 {
1331 T* pT = static_cast<T*>(this);
1332 pT->CalcLabelRect();
1333 pT->Invalidate();
1334 return 0;
1335 }
1336
1337 // Implementation
1338 void Init()
1339 {
1340 ATLASSERT(::IsWindow(m_hWnd));
1341
1342 // Check if we should paint a label
1343 const int cchBuff = 8;
1344 TCHAR szBuffer[cchBuff] = { 0 };
1345 if(::GetClassName(m_hWnd, szBuffer, cchBuff))
1346 {
1347 if(lstrcmpi(szBuffer, _T("static")) == 0)
1348 {
1349 ModifyStyle(0, SS_NOTIFY); // we need this
1350 DWORD dwStyle = GetStyle() & 0x000000FF;
1351 #ifndef _WIN32_WCE
1352 if(dwStyle == SS_ICON || dwStyle == SS_BLACKRECT || dwStyle == SS_GRAYRECT ||
1353 dwStyle == SS_WHITERECT || dwStyle == SS_BLACKFRAME || dwStyle == SS_GRAYFRAME ||
1354 dwStyle == SS_WHITEFRAME || dwStyle == SS_OWNERDRAW ||
1355 dwStyle == SS_BITMAP || dwStyle == SS_ENHMETAFILE)
1356 #else // CE specific
1357 if(dwStyle == SS_ICON || dwStyle == SS_BITMAP)
1358 #endif // _WIN32_WCE
1359 m_bPaintLabel = false;
1360 }
1361 }
1362
1363 // create or load a cursor
1364 #if (WINVER >= 0x0500) || defined(_WIN32_WCE)
1365 m_hCursor = ::LoadCursor(NULL, IDC_HAND);
1366 #else
1367 m_hCursor = ::CreateCursor(ModuleHelper::GetModuleInstance(), _AtlHyperLink_CursorData.xHotSpot, _AtlHyperLink_CursorData.yHotSpot, _AtlHyperLink_CursorData.cxWidth, _AtlHyperLink_CursorData.cyHeight, _AtlHyperLink_CursorData.arrANDPlane, _AtlHyperLink_CursorData.arrXORPlane);
1368 #endif
1369 ATLASSERT(m_hCursor != NULL);
1370
1371 // set font
1372 if(m_bPaintLabel)
1373 {
1374 ATL::CWindow wnd = GetParent();
1375 m_hFontNormal = wnd.GetFont();
1376 if(m_hFontNormal == NULL)
1377 m_hFontNormal = (HFONT)::GetStockObject(SYSTEM_FONT);
1378 if(m_hFontNormal != NULL && m_hFont == NULL)
1379 {
1380 LOGFONT lf = { 0 };
1381 CFontHandle font = m_hFontNormal;
1382 font.GetLogFont(&lf);
1383 if(IsUsingTagsBold())
1384 lf.lfWeight = FW_BOLD;
1385 else if(!IsNotUnderlined())
1386 lf.lfUnderline = TRUE;
1387 m_hFont = ::CreateFontIndirect(&lf);
1388 m_bInternalLinkFont = true;
1389 ATLASSERT(m_hFont != NULL);
1390 }
1391 }
1392
1393 #ifndef _WIN32_WCE
1394 // create a tool tip
1395 m_tip.Create(m_hWnd);
1396 ATLASSERT(m_tip.IsWindow());
1397 #endif // !_WIN32_WCE
1398
1399 // set label (defaults to window text)
1400 if(m_lpstrLabel == NULL)
1401 {
1402 int nLen = GetWindowTextLength();
1403 if(nLen > 0)
1404 {
1405 CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
1406 LPTSTR lpstrText = buff.Allocate(nLen + 1);
1407 ATLASSERT(lpstrText != NULL);
1408 if((lpstrText != NULL) && (GetWindowText(lpstrText, nLen + 1) > 0))
1409 SetLabel(lpstrText);
1410 }
1411 }
1412
1413 T* pT = static_cast<T*>(this);
1414 pT->CalcLabelRect();
1415
1416 // set hyperlink (defaults to label), or just activate tool tip if already set
1417 if(m_lpstrHyperLink == NULL && !IsCommandButton())
1418 {
1419 if(m_lpstrLabel != NULL)
1420 SetHyperLink(m_lpstrLabel);
1421 }
1422 #ifndef _WIN32_WCE
1423 else
1424 {
1425 m_tip.Activate(TRUE);
1426 m_tip.AddTool(m_hWnd, m_lpstrHyperLink, &m_rcLink, 1);
1427 }
1428 #endif // !_WIN32_WCE
1429
1430 // set link colors
1431 if(m_bPaintLabel)
1432 {
1433 ATL::CRegKey rk;
1434 LONG lRet = rk.Open(HKEY_CURRENT_USER, _T("Software\\Microsoft\\Internet Explorer\\Settings"));
1435 if(lRet == 0)
1436 {
1437 const int cchValue = 12;
1438 TCHAR szValue[cchValue] = { 0 };
1439 #if (_ATL_VER >= 0x0700)
1440 ULONG ulCount = cchValue;
1441 lRet = rk.QueryStringValue(_T("Anchor Color"), szValue, &ulCount);
1442 #else
1443 DWORD dwCount = cchValue * sizeof(TCHAR);
1444 lRet = rk.QueryValue(szValue, _T("Anchor Color"), &dwCount);
1445 #endif
1446 if(lRet == 0)
1447 {
1448 COLORREF clr = pT->_ParseColorString(szValue);
1449 ATLASSERT(clr != CLR_INVALID);
1450 if(clr != CLR_INVALID)
1451 m_clrLink = clr;
1452 }
1453
1454 #if (_ATL_VER >= 0x0700)
1455 ulCount = cchValue;
1456 lRet = rk.QueryStringValue(_T("Anchor Color Visited"), szValue, &ulCount);
1457 #else
1458 dwCount = cchValue * sizeof(TCHAR);
1459 lRet = rk.QueryValue(szValue, _T("Anchor Color Visited"), &dwCount);
1460 #endif
1461 if(lRet == 0)
1462 {
1463 COLORREF clr = pT->_ParseColorString(szValue);
1464 ATLASSERT(clr != CLR_INVALID);
1465 if(clr != CLR_INVALID)
1466 m_clrVisited = clr;
1467 }
1468 }
1469 }
1470 }
1471
1472 static COLORREF _ParseColorString(LPTSTR lpstr)
1473 {
1474 int c[3] = { -1, -1, -1 };
1475 LPTSTR p = NULL;
1476 for(int i = 0; i < 2; i++)
1477 {
1478 for(p = lpstr; *p != _T('\0'); p = ::CharNext(p))
1479 {
1480 if(*p == _T(','))
1481 {
1482 *p = _T('\0');
1483 c[i] = T::_xttoi(lpstr);
1484 lpstr = &p[1];
1485 break;
1486 }
1487 }
1488 if(c[i] == -1)
1489 return CLR_INVALID;
1490 }
1491 if(*lpstr == _T('\0'))
1492 return CLR_INVALID;
1493 c[2] = T::_xttoi(lpstr);
1494
1495 return RGB(c[0], c[1], c[2]);
1496 }
1497
1498 bool CalcLabelRect()
1499 {
1500 if(!::IsWindow(m_hWnd))
1501 return false;
1502 if(m_lpstrLabel == NULL && m_lpstrHyperLink == NULL)
1503 return false;
1504
1505 CClientDC dc(m_hWnd);
1506 RECT rcClient = { 0 };
1507 GetClientRect(&rcClient);
1508 m_rcLink = rcClient;
1509 if(!m_bPaintLabel)
1510 return true;
1511
1512 if(IsUsingTags())
1513 {
1514 // find tags and label parts
1515 LPTSTR lpstrLeft = NULL;
1516 int cchLeft = 0;
1517 LPTSTR lpstrLink = NULL;
1518 int cchLink = 0;
1519 LPTSTR lpstrRight = NULL;
1520 int cchRight = 0;
1521
1522 T* pT = static_cast<T*>(this);
1523 pT->CalcLabelParts(lpstrLeft, cchLeft, lpstrLink, cchLink, lpstrRight, cchRight);
1524 ATLASSERT(lpstrLink != NULL);
1525 ATLASSERT(cchLink > 0);
1526
1527 // get label part rects
1528 HFONT hFontOld = dc.SelectFont(m_hFontNormal);
1529
1530 RECT rcLeft = rcClient;
1531 if(lpstrLeft != NULL)
1532 dc.DrawText(lpstrLeft, cchLeft, &rcLeft, DT_LEFT | DT_WORDBREAK | DT_CALCRECT);
1533
1534 dc.SelectFont(m_hFont);
1535 RECT rcLink = rcClient;
1536 if(lpstrLeft != NULL)
1537 rcLink.left = rcLeft.right;
1538 dc.DrawText(lpstrLink, cchLink, &rcLink, DT_LEFT | DT_WORDBREAK | DT_CALCRECT);
1539
1540 dc.SelectFont(hFontOld);
1541
1542 m_rcLink = rcLink;
1543 }
1544 else
1545 {
1546 HFONT hOldFont = NULL;
1547 if(m_hFont != NULL)
1548 hOldFont = dc.SelectFont(m_hFont);
1549 LPTSTR lpstrText = (m_lpstrLabel != NULL) ? m_lpstrLabel : m_lpstrHyperLink;
1550 DWORD dwStyle = GetStyle();
1551 int nDrawStyle = DT_LEFT;
1552 if (dwStyle & SS_CENTER)
1553 nDrawStyle = DT_CENTER;
1554 else if (dwStyle & SS_RIGHT)
1555 nDrawStyle = DT_RIGHT;
1556 dc.DrawText(lpstrText, -1, &m_rcLink, nDrawStyle | DT_WORDBREAK | DT_CALCRECT);
1557 if(m_hFont != NULL)
1558 dc.SelectFont(hOldFont);
1559 if (dwStyle & SS_CENTER)
1560 {
1561 int dx = (rcClient.right - m_rcLink.right) / 2;
1562 ::OffsetRect(&m_rcLink, dx, 0);
1563 }
1564 else if (dwStyle & SS_RIGHT)
1565 {
1566 int dx = rcClient.right - m_rcLink.right;
1567 ::OffsetRect(&m_rcLink, dx, 0);
1568 }
1569 }
1570
1571 return true;
1572 }
1573
1574 void CalcLabelParts(LPTSTR& lpstrLeft, int& cchLeft, LPTSTR& lpstrLink, int& cchLink, LPTSTR& lpstrRight, int& cchRight) const
1575 {
1576 lpstrLeft = NULL;
1577 cchLeft = 0;
1578 lpstrLink = NULL;
1579 cchLink = 0;
1580 lpstrRight = NULL;
1581 cchRight = 0;
1582
1583 LPTSTR lpstrText = (m_lpstrLabel != NULL) ? m_lpstrLabel : m_lpstrHyperLink;
1584 int cchText = lstrlen(lpstrText);
1585 bool bOutsideLink = true;
1586 for(int i = 0; i < cchText; i++)
1587 {
1588 if(lpstrText[i] != _T('<'))
1589 continue;
1590
1591 if(bOutsideLink)
1592 {
1593 if(::CompareString(LOCALE_USER_DEFAULT, NORM_IGNORECASE, &lpstrText[i], 3, _T("<A>"), 3) == CSTR_EQUAL)
1594 {
1595 if(i > 0)
1596 {
1597 lpstrLeft = lpstrText;
1598 cchLeft = i;
1599 }
1600 lpstrLink = &lpstrText[i + 3];
1601 bOutsideLink = false;
1602 }
1603 }
1604 else
1605 {
1606 if(::CompareString(LOCALE_USER_DEFAULT, NORM_IGNORECASE, &lpstrText[i], 4, _T("</A>"), 4) == CSTR_EQUAL)
1607 {
1608 cchLink = i - 3 - cchLeft;
1609 if(lpstrText[i + 4] != 0)
1610 {
1611 lpstrRight = &lpstrText[i + 4];
1612 cchRight = cchText - (i + 4);
1613 break;
1614 }
1615 }
1616 }
1617 }
1618
1619 }
1620
1621 void DoEraseBackground(CDCHandle dc)
1622 {
1623 HBRUSH hBrush = (HBRUSH)::SendMessage(GetParent(), WM_CTLCOLORSTATIC, (WPARAM)dc.m_hDC, (LPARAM)m_hWnd);
1624 if(hBrush != NULL)
1625 {
1626 RECT rect = { 0 };
1627 GetClientRect(&rect);
1628 dc.FillRect(&rect, hBrush);
1629 }
1630 }
1631
1632 void DoPaint(CDCHandle dc)
1633 {
1634 if(IsUsingTags())
1635 {
1636 // find tags and label parts
1637 LPTSTR lpstrLeft = NULL;
1638 int cchLeft = 0;
1639 LPTSTR lpstrLink = NULL;
1640 int cchLink = 0;
1641 LPTSTR lpstrRight = NULL;
1642 int cchRight = 0;
1643
1644 T* pT = static_cast<T*>(this);
1645 pT->CalcLabelParts(lpstrLeft, cchLeft, lpstrLink, cchLink, lpstrRight, cchRight);
1646
1647 // get label part rects
1648 RECT rcClient = { 0 };
1649 GetClientRect(&rcClient);
1650
1651 dc.SetBkMode(TRANSPARENT);
1652 HFONT hFontOld = dc.SelectFont(m_hFontNormal);
1653
1654 if(lpstrLeft != NULL)
1655 dc.DrawText(lpstrLeft, cchLeft, &rcClient, DT_LEFT | DT_WORDBREAK);
1656
1657 COLORREF clrOld = dc.SetTextColor(IsWindowEnabled() ? (m_bVisited ? m_clrVisited : m_clrLink) : (::GetSysColor(COLOR_GRAYTEXT)));
1658 if(m_hFont != NULL && (!IsUnderlineHover() || (IsUnderlineHover() && m_bHover)))
1659 dc.SelectFont(m_hFont);
1660 else
1661 dc.SelectFont(m_hFontNormal);
1662
1663 dc.DrawText(lpstrLink, cchLink, &m_rcLink, DT_LEFT | DT_WORDBREAK);
1664
1665 dc.SetTextColor(clrOld);
1666 dc.SelectFont(m_hFontNormal);
1667 if(lpstrRight != NULL)
1668 {
1669 RECT rcRight = { m_rcLink.right, m_rcLink.top, rcClient.right, rcClient.bottom };
1670 dc.DrawText(lpstrRight, cchRight, &rcRight, DT_LEFT | DT_WORDBREAK);
1671 }
1672
1673 if(GetFocus() == m_hWnd)
1674 dc.DrawFocusRect(&m_rcLink);
1675
1676 dc.SelectFont(hFontOld);
1677 }
1678 else
1679 {
1680 dc.SetBkMode(TRANSPARENT);
1681 COLORREF clrOld = dc.SetTextColor(IsWindowEnabled() ? (m_bVisited ? m_clrVisited : m_clrLink) : (::GetSysColor(COLOR_GRAYTEXT)));
1682
1683 HFONT hFontOld = NULL;
1684 if(m_hFont != NULL && (!IsUnderlineHover() || (IsUnderlineHover() && m_bHover)))
1685 hFontOld = dc.SelectFont(m_hFont);
1686 else
1687 hFontOld = dc.SelectFont(m_hFontNormal);
1688
1689 LPTSTR lpstrText = (m_lpstrLabel != NULL) ? m_lpstrLabel : m_lpstrHyperLink;
1690
1691 DWORD dwStyle = GetStyle();
1692 int nDrawStyle = DT_LEFT;
1693 if (dwStyle & SS_CENTER)
1694 nDrawStyle = DT_CENTER;
1695 else if (dwStyle & SS_RIGHT)
1696 nDrawStyle = DT_RIGHT;
1697
1698 dc.DrawText(lpstrText, -1, &m_rcLink, nDrawStyle | DT_WORDBREAK);
1699
1700 if(GetFocus() == m_hWnd)
1701 dc.DrawFocusRect(&m_rcLink);
1702
1703 dc.SetTextColor(clrOld);
1704 dc.SelectFont(hFontOld);
1705 }
1706 }
1707
1708 #ifndef _WIN32_WCE
1709 BOOL StartTrackMouseLeave()
1710 {
1711 TRACKMOUSEEVENT tme = { 0 };
1712 tme.cbSize = sizeof(tme);
1713 tme.dwFlags = TME_LEAVE;
1714 tme.hwndTrack = m_hWnd;
1715 return _TrackMouseEvent(&tme);
1716 }
1717 #endif // !_WIN32_WCE
1718
1719 // Implementation helpers
1720 bool IsUnderlined() const
1721 {
1722 return ((m_dwExtendedStyle & (HLINK_NOTUNDERLINED | HLINK_UNDERLINEHOVER)) == 0);
1723 }
1724
1725 bool IsNotUnderlined() const
1726 {
1727 return ((m_dwExtendedStyle & HLINK_NOTUNDERLINED) != 0);
1728 }
1729
1730 bool IsUnderlineHover() const
1731 {
1732 return ((m_dwExtendedStyle & HLINK_UNDERLINEHOVER) != 0);
1733 }
1734
1735 bool IsCommandButton() const
1736 {
1737 return ((m_dwExtendedStyle & HLINK_COMMANDBUTTON) != 0);
1738 }
1739
1740 bool IsNotifyButton() const
1741 {
1742 return ((m_dwExtendedStyle & HLINK_NOTIFYBUTTON) == HLINK_NOTIFYBUTTON);
1743 }
1744
1745 bool IsUsingTags() const
1746 {
1747 return ((m_dwExtendedStyle & HLINK_USETAGS) != 0);
1748 }
1749
1750 bool IsUsingTagsBold() const
1751 {
1752 return ((m_dwExtendedStyle & HLINK_USETAGSBOLD) == HLINK_USETAGSBOLD);
1753 }
1754
1755 bool IsUsingToolTip() const
1756 {
1757 return ((m_dwExtendedStyle & HLINK_NOTOOLTIP) == 0);
1758 }
1759
1760 static int _xttoi(const TCHAR* nptr)
1761 {
1762 #ifndef _ATL_MIN_CRT
1763 return _ttoi(nptr);
1764 #else // _ATL_MIN_CRT
1765 while(*nptr == _T(' ')) // skip spaces
1766 ++nptr;
1767
1768 int c = (int)(_TUCHAR)*nptr++;
1769 int sign = c; // save sign indication
1770 if (c == _T('-') || c == _T('+'))
1771 c = (int)(_TUCHAR)*nptr++; // skip sign
1772
1773 int total = 0;
1774 while((TCHAR)c >= _T('0') && (TCHAR)c <= _T('9'))
1775 {
1776 total = 10 * total + ((TCHAR)c - _T('0')); // accumulate digit
1777 c = (int)(_TUCHAR)*nptr++; // get next char
1778 }
1779
1780 // return result, negated if necessary
1781 return ((TCHAR)sign != _T('-')) ? total : -total;
1782 #endif // _ATL_MIN_CRT
1783 }
1784 };
1785
1786
1787 class CHyperLink : public CHyperLinkImpl<CHyperLink>
1788 {
1789 public:
1790 DECLARE_WND_CLASS(_T("WTL_HyperLink"))
1791 };
1792
1793
1794 ///////////////////////////////////////////////////////////////////////////////
1795 // CWaitCursor - displays a wait cursor
1796
1797 class CWaitCursor
1798 {
1799 public:
1800 // Data
1801 HCURSOR m_hWaitCursor;
1802 HCURSOR m_hOldCursor;
1803 bool m_bInUse;
1804
1805 // Constructor/destructor
1806 CWaitCursor(bool bSet = true, LPCTSTR lpstrCursor = IDC_WAIT, bool bSys = true) : m_hOldCursor(NULL), m_bInUse(false)
1807 {
1808 HINSTANCE hInstance = bSys ? NULL : ModuleHelper::GetResourceInstance();
1809 m_hWaitCursor = ::LoadCursor(hInstance, lpstrCursor);
1810 ATLASSERT(m_hWaitCursor != NULL);
1811
1812 if(bSet)
1813 Set();
1814 }
1815
1816 ~CWaitCursor()
1817 {
1818 Restore();
1819 }
1820
1821 // Methods
1822 bool Set()
1823 {
1824 if(m_bInUse)
1825 return false;
1826 m_hOldCursor = ::SetCursor(m_hWaitCursor);
1827 m_bInUse = true;
1828 return true;
1829 }
1830
1831 bool Restore()
1832 {
1833 if(!m_bInUse)
1834 return false;
1835 ::SetCursor(m_hOldCursor);
1836 m_bInUse = false;
1837 return true;
1838 }
1839 };
1840
1841
1842 ///////////////////////////////////////////////////////////////////////////////
1843 // CCustomWaitCursor - for custom and animated cursors
1844
1845 class CCustomWaitCursor : public CWaitCursor
1846 {
1847 public:
1848 // Constructor/destructor
1849 CCustomWaitCursor(ATL::_U_STRINGorID cursor, bool bSet = true, HINSTANCE hInstance = NULL) :
1850 CWaitCursor(false, IDC_WAIT, true)
1851 {
1852 if(hInstance == NULL)
1853 hInstance = ModuleHelper::GetResourceInstance();
1854 m_hWaitCursor = (HCURSOR)::LoadImage(hInstance, cursor.m_lpstr, IMAGE_CURSOR, 0, 0, LR_DEFAULTSIZE);
1855
1856 if(bSet)
1857 Set();
1858 }
1859
1860 ~CCustomWaitCursor()
1861 {
1862 Restore();
1863 #if !defined(_WIN32_WCE) || ((_WIN32_WCE >= 0x400) && !(defined(WIN32_PLATFORM_PSPC) || defined(WIN32_PLATFORM_WFSP)))
1864 ::DestroyCursor(m_hWaitCursor);
1865 #endif // !defined(_WIN32_WCE) || ((_WIN32_WCE >= 0x400) && !(defined(WIN32_PLATFORM_PSPC) || defined(WIN32_PLATFORM_WFSP)))
1866 }
1867 };
1868
1869
1870 ///////////////////////////////////////////////////////////////////////////////
1871 // CMultiPaneStatusBarCtrl - Status Bar with multiple panes
1872
1873 template <class T, class TBase = CStatusBarCtrl>
1874 class ATL_NO_VTABLE CMultiPaneStatusBarCtrlImpl : public ATL::CWindowImpl< T, TBase >
1875 {
1876 public:
1877 DECLARE_WND_SUPERCLASS(NULL, TBase::GetWndClassName())
1878
1879 // Data
1880 enum { m_cxPaneMargin = 3 };
1881
1882 int m_nPanes;
1883 int* m_pPane;
1884
1885 // Constructor/destructor
1886 CMultiPaneStatusBarCtrlImpl() : m_nPanes(0), m_pPane(NULL)
1887 { }
1888
1889 ~CMultiPaneStatusBarCtrlImpl()
1890 {
1891 delete [] m_pPane;
1892 }
1893
1894 // Methods
1895 HWND Create(HWND hWndParent, LPCTSTR lpstrText, DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | SBARS_SIZEGRIP, UINT nID = ATL_IDW_STATUS_BAR)
1896 {
1897 #if (_MSC_VER >= 1300)
1898 return ATL::CWindowImpl< T, TBase >::Create(hWndParent, rcDefault, lpstrText, dwStyle, 0, nID);
1899 #else // !(_MSC_VER >= 1300)
1900 typedef ATL::CWindowImpl< T, TBase > _baseClass;
1901 return _baseClass::Create(hWndParent, rcDefault, lpstrText, dwStyle, 0, nID);
1902 #endif // !(_MSC_VER >= 1300)
1903 }
1904
1905 HWND Create(HWND hWndParent, UINT nTextID = ATL_IDS_IDLEMESSAGE, DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | SBARS_SIZEGRIP, UINT nID = ATL_IDW_STATUS_BAR)
1906 {
1907 const int cchMax = 128; // max text length is 127 for status bars (+1 for null)
1908 TCHAR szText[cchMax];
1909 szText[0] = 0;
1910 ::LoadString(ModuleHelper::GetResourceInstance(), nTextID, szText, cchMax);
1911 return Create(hWndParent, szText, dwStyle, nID);
1912 }
1913
1914 BOOL SetPanes(int* pPanes, int nPanes, bool bSetText = true)
1915 {
1916 ATLASSERT(::IsWindow(m_hWnd));
1917 ATLASSERT(nPanes > 0);
1918
1919 m_nPanes = nPanes;
1920 delete [] m_pPane;
1921 m_pPane = NULL;
1922
1923 ATLTRY(m_pPane = new int[nPanes]);
1924 ATLASSERT(m_pPane != NULL);
1925 if(m_pPane == NULL)
1926 return FALSE;
1927
1928 CTempBuffer<int, _WTL_STACK_ALLOC_THRESHOLD> buff;
1929 int* pPanesPos = buff.Allocate(nPanes);
1930 ATLASSERT(pPanesPos != NULL);
1931 if(pPanesPos == NULL)
1932 return FALSE;
1933
1934 SecureHelper::memcpy_x(m_pPane, nPanes * sizeof(int), pPanes, nPanes * sizeof(int));
1935
1936 // get status bar DC and set font
1937 CClientDC dc(m_hWnd);
1938 HFONT hOldFont = dc.SelectFont(GetFont());
1939
1940 // get status bar borders
1941 int arrBorders[3] = { 0 };
1942 GetBorders(arrBorders);
1943
1944 const int cchBuff = 128;
1945 TCHAR szBuff[cchBuff] = { 0 };
1946 SIZE size = { 0, 0 };
1947 int cxLeft = arrBorders[0];
1948
1949 // calculate right edge of each part
1950 for(int i = 0; i < nPanes; i++)
1951 {
1952 if(pPanes[i] == ID_DEFAULT_PANE)
1953 {
1954 // make very large, will be resized later
1955 pPanesPos[i] = INT_MAX / 2;
1956 }
1957 else
1958 {
1959 ::LoadString(ModuleHelper::GetResourceInstance(), pPanes[i], szBuff, cchBuff);
1960 dc.GetTextExtent(szBuff, lstrlen(szBuff), &size);
1961 T* pT = static_cast<T*>(this);
1962 pT;
1963 pPanesPos[i] = cxLeft + size.cx + arrBorders[2] + 2 * pT->m_cxPaneMargin;
1964 }
1965 cxLeft = pPanesPos[i];
1966 }
1967
1968 BOOL bRet = SetParts(nPanes, pPanesPos);
1969
1970 if(bRet && bSetText)
1971 {
1972 for(int i = 0; i < nPanes; i++)
1973 {
1974 if(pPanes[i] != ID_DEFAULT_PANE)
1975 {
1976 ::LoadString(ModuleHelper::GetResourceInstance(), pPanes[i], szBuff, cchBuff);
1977 SetPaneText(m_pPane[i], szBuff);
1978 }
1979 }
1980 }
1981
1982 dc.SelectFont(hOldFont);
1983 return bRet;
1984 }
1985
1986 bool GetPaneTextLength(int nPaneID, int* pcchLength = NULL, int* pnType = NULL) const
1987 {
1988 ATLASSERT(::IsWindow(m_hWnd));
1989 int nIndex = GetPaneIndexFromID(nPaneID);
1990 if(nIndex == -1)
1991 return false;
1992
1993 int nLength = GetTextLength(nIndex, pnType);
1994 if(pcchLength != NULL)
1995 *pcchLength = nLength;
1996
1997 return true;
1998 }
1999
2000 BOOL GetPaneText(int nPaneID, LPTSTR lpstrText, int* pcchLength = NULL, int* pnType = NULL) const
2001 {
2002 ATLASSERT(::IsWindow(m_hWnd));
2003 int nIndex = GetPaneIndexFromID(nPaneID);
2004 if(nIndex == -1)
2005 return FALSE;
2006
2007 int nLength = GetText(nIndex, lpstrText, pnType);
2008 if(pcchLength != NULL)
2009 *pcchLength = nLength;
2010
2011 return TRUE;
2012 }
2013
2014 BOOL SetPaneText(int nPaneID, LPCTSTR lpstrText, int nType = 0)
2015 {
2016 ATLASSERT(::IsWindow(m_hWnd));
2017 int nIndex = GetPaneIndexFromID(nPaneID);
2018 if(nIndex == -1)
2019 return FALSE;
2020
2021 return SetText(nIndex, lpstrText, nType);
2022 }
2023
2024 BOOL GetPaneRect(int nPaneID, LPRECT lpRect) const
2025 {
2026 ATLASSERT(::IsWindow(m_hWnd));
2027 int nIndex = GetPaneIndexFromID(nPaneID);
2028 if(nIndex == -1)
2029 return FALSE;
2030
2031 return GetRect(nIndex, lpRect);
2032 }
2033
2034 BOOL SetPaneWidth(int nPaneID, int cxWidth)
2035 {
2036 ATLASSERT(::IsWindow(m_hWnd));
2037 ATLASSERT(nPaneID != ID_DEFAULT_PANE); // Can't resize this one
2038 int nIndex = GetPaneIndexFromID(nPaneID);
2039 if(nIndex == -1)
2040 return FALSE;
2041
2042 // get pane positions
2043 CTempBuffer<int, _WTL_STACK_ALLOC_THRESHOLD> buff;
2044 int* pPanesPos = buff.Allocate(m_nPanes);
2045 if(pPanesPos == NULL)
2046 return FALSE;
2047 GetParts(m_nPanes, pPanesPos);
2048 // calculate offset
2049 int cxPaneWidth = pPanesPos[nIndex] - ((nIndex == 0) ? 0 : pPanesPos[nIndex - 1]);
2050 int cxOff = cxWidth - cxPaneWidth;
2051 // find variable width pane
2052 int nDef = m_nPanes;
2053 for(int i = 0; i < m_nPanes; i++)
2054 {
2055 if(m_pPane[i] == ID_DEFAULT_PANE)
2056 {
2057 nDef = i;
2058 break;
2059 }
2060 }
2061 // resize
2062 if(nIndex < nDef) // before default pane
2063 {
2064 for(int i = nIndex; i < nDef; i++)
2065 pPanesPos[i] += cxOff;
2066
2067 }
2068 else // after default one
2069 {
2070 for(int i = nDef; i < nIndex; i++)
2071 pPanesPos[i] -= cxOff;
2072 }
2073 // set pane postions
2074 return SetParts(m_nPanes, pPanesPos);
2075 }
2076
2077 #if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
2078 BOOL GetPaneTipText(int nPaneID, LPTSTR lpstrText, int nSize) const
2079 {
2080 ATLASSERT(::IsWindow(m_hWnd));
2081 int nIndex = GetPaneIndexFromID(nPaneID);
2082 if(nIndex == -1)
2083 return FALSE;
2084
2085 GetTipText(nIndex, lpstrText, nSize);
2086 return TRUE;
2087 }
2088
2089 BOOL SetPaneTipText(int nPaneID, LPCTSTR lpstrText)
2090 {
2091 ATLASSERT(::IsWindow(m_hWnd));
2092 int nIndex = GetPaneIndexFromID(nPaneID);
2093 if(nIndex == -1)
2094 return FALSE;
2095
2096 SetTipText(nIndex, lpstrText);
2097 return TRUE;
2098 }
2099 #endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
2100
2101 #if ((_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)) || (defined(_WIN32_WCE) && (_WIN32_WCE >= 0x0500))
2102 BOOL GetPaneIcon(int nPaneID, HICON& hIcon) const
2103 {
2104 ATLASSERT(::IsWindow(m_hWnd));
2105 int nIndex = GetPaneIndexFromID(nPaneID);
2106 if(nIndex == -1)
2107 return FALSE;
2108
2109 hIcon = GetIcon(nIndex);
2110 return TRUE;
2111 }
2112
2113 BOOL SetPaneIcon(int nPaneID, HICON hIcon)
2114 {
2115 ATLASSERT(::IsWindow(m_hWnd));
2116 int nIndex = GetPaneIndexFromID(nPaneID);
2117 if(nIndex == -1)
2118 return FALSE;
2119
2120 return SetIcon(nIndex, hIcon);
2121 }
2122 #endif // ((_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)) || (defined(_WIN32_WCE) && (_WIN32_WCE >= 0x0500))
2123
2124 // Message map and handlers
2125 BEGIN_MSG_MAP(CMultiPaneStatusBarCtrlImpl< T >)
2126 MESSAGE_HANDLER(WM_SIZE, OnSize)
2127 END_MSG_MAP()
2128
2129 LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
2130 {
2131 LRESULT lRet = DefWindowProc(uMsg, wParam, lParam);
2132 if(wParam != SIZE_MINIMIZED && m_nPanes > 0)
2133 {
2134 T* pT = static_cast<T*>(this);
2135 pT->UpdatePanesLayout();
2136 }
2137 return lRet;
2138 }
2139
2140 // Implementation
2141 BOOL UpdatePanesLayout()
2142 {
2143 // get pane positions
2144 CTempBuffer<int, _WTL_STACK_ALLOC_THRESHOLD> buff;
2145 int* pPanesPos = buff.Allocate(m_nPanes);
2146 ATLASSERT(pPanesPos != NULL);
2147 if(pPanesPos == NULL)
2148 return FALSE;
2149 int nRet = GetParts(m_nPanes, pPanesPos);
2150 ATLASSERT(nRet == m_nPanes);
2151 if(nRet != m_nPanes)
2152 return FALSE;
2153 // calculate offset
2154 RECT rcClient = { 0 };
2155 GetClientRect(&rcClient);
2156 int cxOff = rcClient.right - pPanesPos[m_nPanes - 1];
2157 #ifndef _WIN32_WCE
2158 // Move panes left if size grip box is present
2159 if((GetStyle() & SBARS_SIZEGRIP) != 0)
2160 cxOff -= ::GetSystemMetrics(SM_CXVSCROLL) + ::GetSystemMetrics(SM_CXEDGE);
2161 #endif // !_WIN32_WCE
2162 // find variable width pane
2163 int i;
2164 for(i = 0; i < m_nPanes; i++)
2165 {
2166 if(m_pPane[i] == ID_DEFAULT_PANE)
2167 break;
2168 }
2169 // resize all panes from the variable one to the right
2170 if((i < m_nPanes) && (pPanesPos[i] + cxOff) > ((i == 0) ? 0 : pPanesPos[i - 1]))
2171 {
2172 for(; i < m_nPanes; i++)
2173 pPanesPos[i] += cxOff;
2174 }
2175 // set pane postions
2176 return SetParts(m_nPanes, pPanesPos);
2177 }
2178
2179 int GetPaneIndexFromID(int nPaneID) const
2180 {
2181 for(int i = 0; i < m_nPanes; i++)
2182 {
2183 if(m_pPane[i] == nPaneID)
2184 return i;
2185 }
2186
2187 return -1; // not found
2188 }
2189 };
2190
2191 class CMultiPaneStatusBarCtrl : public CMultiPaneStatusBarCtrlImpl<CMultiPaneStatusBarCtrl>
2192 {
2193 public:
2194 DECLARE_WND_SUPERCLASS(_T("WTL_MultiPaneStatusBar"), GetWndClassName())
2195 };
2196
2197
2198 ///////////////////////////////////////////////////////////////////////////////
2199 // CPaneContainer - provides header with title and close button for panes
2200
2201 // pane container extended styles
2202 #define PANECNT_NOCLOSEBUTTON 0x00000001
2203 #define PANECNT_VERTICAL 0x00000002
2204 #define PANECNT_FLATBORDER 0x00000004
2205 #define PANECNT_NOBORDER 0x00000008
2206
2207 template <class T, class TBase = ATL::CWindow, class TWinTraits = ATL::CControlWinTraits>
2208 class ATL_NO_VTABLE CPaneContainerImpl : public ATL::CWindowImpl< T, TBase, TWinTraits >, public CCustomDraw< T >
2209 {
2210 public:
2211 DECLARE_WND_CLASS_EX(NULL, 0, -1)
2212
2213 // Constants
2214 enum
2215 {
2216 m_cxyBorder = 2,
2217 m_cxyTextOffset = 4,
2218 m_cxyBtnOffset = 1,
2219
2220 m_cchTitle = 80,
2221
2222 m_cxImageTB = 13,
2223 m_cyImageTB = 11,
2224 m_cxyBtnAddTB = 7,
2225
2226 m_cxToolBar = m_cxImageTB + m_cxyBtnAddTB + m_cxyBorder + m_cxyBtnOffset,
2227
2228 m_xBtnImageLeft = 6,
2229 m_yBtnImageTop = 5,
2230 m_xBtnImageRight = 12,
2231 m_yBtnImageBottom = 11,
2232
2233 m_nCloseBtnID = ID_PANE_CLOSE
2234 };
2235
2236 // Data members
2237 CToolBarCtrl m_tb;
2238 ATL::CWindow m_wndClient;
2239 int m_cxyHeader;
2240 TCHAR m_szTitle[m_cchTitle];
2241 DWORD m_dwExtendedStyle; // Pane container specific extended styles
2242
2243
2244 // Constructor
2245 CPaneContainerImpl() : m_cxyHeader(0), m_dwExtendedStyle(0)
2246 {
2247 m_szTitle[0] = 0;
2248 }
2249
2250 // Attributes
2251 DWORD GetPaneContainerExtendedStyle() const
2252 {
2253 return m_dwExtendedStyle;
2254 }
2255
2256 DWORD SetPaneContainerExtendedStyle(DWORD dwExtendedStyle, DWORD dwMask = 0)
2257 {
2258 DWORD dwPrevStyle = m_dwExtendedStyle;
2259 if(dwMask == 0)
2260 m_dwExtendedStyle = dwExtendedStyle;
2261 else
2262 m_dwExtendedStyle = (m_dwExtendedStyle & ~dwMask) | (dwExtendedStyle & dwMask);
2263 if(m_hWnd != NULL)
2264 {
2265 T* pT = static_cast<T*>(this);
2266 bool bUpdate = false;
2267
2268 if(((dwPrevStyle & PANECNT_NOCLOSEBUTTON) != 0) && ((m_dwExtendedStyle & PANECNT_NOCLOSEBUTTON) == 0)) // add close button
2269 {
2270 pT->CreateCloseButton();
2271 bUpdate = true;
2272 }
2273 else if(((dwPrevStyle & PANECNT_NOCLOSEBUTTON) == 0) && ((m_dwExtendedStyle & PANECNT_NOCLOSEBUTTON) != 0)) // remove close button
2274 {
2275 pT->DestroyCloseButton();
2276 bUpdate = true;
2277 }
2278
2279 if((dwPrevStyle & PANECNT_VERTICAL) != (m_dwExtendedStyle & PANECNT_VERTICAL)) // change orientation
2280 {
2281 pT->CalcSize();
2282 bUpdate = true;
2283 }
2284
2285 if((dwPrevStyle & (PANECNT_FLATBORDER | PANECNT_NOBORDER)) !=
2286 (m_dwExtendedStyle & (PANECNT_FLATBORDER | PANECNT_NOBORDER))) // change border
2287 {
2288 bUpdate = true;
2289 }
2290
2291 if(bUpdate)
2292 pT->UpdateLayout();
2293 }
2294 return dwPrevStyle;
2295 }
2296
2297 HWND GetClient() const
2298 {
2299 return m_wndClient;
2300 }
2301
2302 HWND SetClient(HWND hWndClient)
2303 {
2304 HWND hWndOldClient = m_wndClient;
2305 m_wndClient = hWndClient;
2306 if(m_hWnd != NULL)
2307 {
2308 T* pT = static_cast<T*>(this);
2309 pT->UpdateLayout();
2310 }
2311 return hWndOldClient;
2312 }
2313
2314 BOOL GetTitle(LPTSTR lpstrTitle, int cchLength) const
2315 {
2316 ATLASSERT(lpstrTitle != NULL);
2317
2318 errno_t nRet = SecureHelper::strncpy_x(lpstrTitle, cchLength, m_szTitle, _TRUNCATE);
2319
2320 return (nRet == 0 || nRet == STRUNCATE);
2321 }
2322
2323 BOOL SetTitle(LPCTSTR lpstrTitle)
2324 {
2325 ATLASSERT(lpstrTitle != NULL);
2326
2327 errno_t nRet = SecureHelper::strncpy_x(m_szTitle, m_cchTitle, lpstrTitle, _TRUNCATE);
2328 bool bRet = (nRet == 0 || nRet == STRUNCATE);
2329 if(bRet && m_hWnd != NULL)
2330 {
2331 T* pT = static_cast<T*>(this);
2332 pT->UpdateLayout();
2333 }
2334
2335 return bRet;
2336 }
2337
2338 int GetTitleLength() const
2339 {
2340 return lstrlen(m_szTitle);
2341 }
2342
2343 // Methods
2344 HWND Create(HWND hWndParent, LPCTSTR lpstrTitle = NULL, DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
2345 DWORD dwExStyle = 0, UINT nID = 0, LPVOID lpCreateParam = NULL)
2346 {
2347 if(lpstrTitle != NULL)
2348 SecureHelper::strncpy_x(m_szTitle, m_cchTitle, lpstrTitle, _TRUNCATE);
2349 #if (_MSC_VER >= 1300)
2350 return ATL::CWindowImpl< T, TBase, TWinTraits >::Create(hWndParent, rcDefault, NULL, dwStyle, dwExStyle, nID, lpCreateParam);
2351 #else // !(_MSC_VER >= 1300)
2352 typedef ATL::CWindowImpl< T, TBase, TWinTraits > _baseClass;
2353 return _baseClass::Create(hWndParent, rcDefault, NULL, dwStyle, dwExStyle, nID, lpCreateParam);
2354 #endif // !(_MSC_VER >= 1300)
2355 }
2356
2357 HWND Create(HWND hWndParent, UINT uTitleID, DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
2358 DWORD dwExStyle = 0, UINT nID = 0, LPVOID lpCreateParam = NULL)
2359 {
2360 if(uTitleID != 0U)
2361 ::LoadString(ModuleHelper::GetResourceInstance(), uTitleID, m_szTitle, m_cchTitle);
2362 #if (_MSC_VER >= 1300)
2363 return ATL::CWindowImpl< T, TBase, TWinTraits >::Create(hWndParent, rcDefault, NULL, dwStyle, dwExStyle, nID, lpCreateParam);
2364 #else // !(_MSC_VER >= 1300)
2365 typedef ATL::CWindowImpl< T, TBase, TWinTraits > _baseClass;
2366 return _baseClass::Create(hWndParent, rcDefault, NULL, dwStyle, dwExStyle, nID, lpCreateParam);
2367 #endif // !(_MSC_VER >= 1300)
2368 }
2369
2370 BOOL EnableCloseButton(BOOL bEnable)
2371 {
2372 ATLASSERT(::IsWindow(m_hWnd));
2373 T* pT = static_cast<T*>(this);
2374 pT; // avoid level 4 warning
2375 return (m_tb.m_hWnd != NULL) ? m_tb.EnableButton(pT->m_nCloseBtnID, bEnable) : FALSE;
2376 }
2377
2378 void UpdateLayout()
2379 {
2380 RECT rcClient = { 0 };
2381 GetClientRect(&rcClient);
2382 T* pT = static_cast<T*>(this);
2383 pT->UpdateLayout(rcClient.right, rcClient.bottom);
2384 }
2385
2386 // Message map and handlers
2387 BEGIN_MSG_MAP(CPaneContainerImpl)
2388 MESSAGE_HANDLER(WM_CREATE, OnCreate)
2389 MESSAGE_HANDLER(WM_SIZE, OnSize)
2390 MESSAGE_HANDLER(WM_SETFOCUS, OnSetFocus)
2391 MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)
2392 MESSAGE_HANDLER(WM_PAINT, OnPaint)
2393 #ifndef _WIN32_WCE
2394 MESSAGE_HANDLER(WM_PRINTCLIENT, OnPaint)
2395 #endif // !_WIN32_WCE
2396 MESSAGE_HANDLER(WM_NOTIFY, OnNotify)
2397 MESSAGE_HANDLER(WM_COMMAND, OnCommand)
2398 FORWARD_NOTIFICATIONS()
2399 END_MSG_MAP()
2400
2401 LRESULT OnCreate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
2402 {
2403 T* pT = static_cast<T*>(this);
2404 pT->CalcSize();
2405
2406 if((m_dwExtendedStyle & PANECNT_NOCLOSEBUTTON) == 0)
2407 pT->CreateCloseButton();
2408
2409 return 0;
2410 }
2411
2412 LRESULT OnSize(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/)
2413 {
2414 T* pT = static_cast<T*>(this);
2415 pT->UpdateLayout(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
2416 return 0;
2417 }
2418
2419 LRESULT OnSetFocus(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
2420 {
2421 if(m_wndClient.m_hWnd != NULL)
2422 m_wndClient.SetFocus();
2423 return 0;
2424 }
2425
2426 LRESULT OnEraseBackground(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
2427 {
2428 return 1; // no background needed
2429 }
2430
2431 LRESULT OnPaint(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
2432 {
2433 T* pT = static_cast<T*>(this);
2434 if(wParam != NULL)
2435 {
2436 pT->DrawPaneTitle((HDC)wParam);
2437
2438 if(m_wndClient.m_hWnd == NULL) // no client window
2439 pT->DrawPane((HDC)wParam);
2440 }
2441 else
2442 {
2443 CPaintDC dc(m_hWnd);
2444 pT->DrawPaneTitle(dc.m_hDC);
2445
2446 if(m_wndClient.m_hWnd == NULL) // no client window
2447 pT->DrawPane(dc.m_hDC);
2448 }
2449
2450 return 0;
2451 }
2452
2453 LRESULT OnNotify(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
2454 {
2455 if(m_tb.m_hWnd == NULL)
2456 {
2457 bHandled = FALSE;
2458 return 1;
2459 }
2460
2461 T* pT = static_cast<T*>(this);
2462 pT;
2463 LPNMHDR lpnmh = (LPNMHDR)lParam;
2464 LRESULT lRet = 0;
2465
2466 // pass toolbar custom draw notifications to the base class
2467 if(lpnmh->code == NM_CUSTOMDRAW && lpnmh->hwndFrom == m_tb.m_hWnd)
2468 lRet = CCustomDraw< T >::OnCustomDraw(0, lpnmh, bHandled);
2469 #ifndef _WIN32_WCE
2470 // tooltip notifications come with the tooltip window handle and button ID,
2471 // pass them to the parent if we don't handle them
2472 else if(lpnmh->code == TTN_GETDISPINFO && lpnmh->idFrom == pT->m_nCloseBtnID)
2473 bHandled = pT->GetToolTipText(lpnmh);
2474 #endif // !_WIN32_WCE
2475 // only let notifications not from the toolbar go to the parent
2476 else if(lpnmh->hwndFrom != m_tb.m_hWnd && lpnmh->idFrom != pT->m_nCloseBtnID)
2477 bHandled = FALSE;
2478
2479 return lRet;
2480 }
2481
2482 LRESULT OnCommand(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
2483 {
2484 // if command comes from the close button, substitute HWND of the pane container instead
2485 if(m_tb.m_hWnd != NULL && (HWND)lParam == m_tb.m_hWnd)
2486 return ::SendMessage(GetParent(), WM_COMMAND, wParam, (LPARAM)m_hWnd);
2487
2488 bHandled = FALSE;
2489 return 1;
2490 }
2491
2492 // Custom draw overrides
2493 DWORD OnPrePaint(int /*idCtrl*/, LPNMCUSTOMDRAW /*lpNMCustomDraw*/)
2494 {
2495 return CDRF_NOTIFYITEMDRAW; // we need per-item notifications
2496 }
2497
2498 DWORD OnItemPrePaint(int /*idCtrl*/, LPNMCUSTOMDRAW lpNMCustomDraw)
2499 {
2500 CDCHandle dc = lpNMCustomDraw->hdc;
2501 #if (_WIN32_IE >= 0x0400)
2502 RECT& rc = lpNMCustomDraw->rc;
2503 #else // !(_WIN32_IE >= 0x0400)
2504 RECT rc;
2505 m_tb.GetItemRect(0, &rc);
2506 #endif // !(_WIN32_IE >= 0x0400)
2507
2508 dc.FillRect(&rc, COLOR_3DFACE);
2509
2510 return CDRF_NOTIFYPOSTPAINT;
2511 }
2512
2513 DWORD OnItemPostPaint(int /*idCtrl*/, LPNMCUSTOMDRAW lpNMCustomDraw)
2514 {
2515 CDCHandle dc = lpNMCustomDraw->hdc;
2516 #if (_WIN32_IE >= 0x0400)
2517 RECT& rc = lpNMCustomDraw->rc;
2518 #else // !(_WIN32_IE >= 0x0400)
2519 RECT rc = { 0 };
2520 m_tb.GetItemRect(0, &rc);
2521 #endif // !(_WIN32_IE >= 0x0400)
2522
2523 RECT rcImage = { m_xBtnImageLeft, m_yBtnImageTop, m_xBtnImageRight + 1, m_yBtnImageBottom + 1 };
2524 ::OffsetRect(&rcImage, rc.left, rc.top);
2525 T* pT = static_cast<T*>(this);
2526
2527 if((lpNMCustomDraw->uItemState & CDIS_DISABLED) != 0)
2528 {
2529 RECT rcShadow = rcImage;
2530 ::OffsetRect(&rcShadow, 1, 1);
2531 CPen pen1;
2532 pen1.CreatePen(PS_SOLID, 0, ::GetSysColor(COLOR_3DHILIGHT));
2533 pT->DrawButtonImage(dc, rcShadow, pen1);
2534 CPen pen2;
2535 pen2.CreatePen(PS_SOLID, 0, ::GetSysColor(COLOR_3DSHADOW));
2536 pT->DrawButtonImage(dc, rcImage, pen2);
2537 }
2538 else
2539 {
2540 if((lpNMCustomDraw->uItemState & CDIS_SELECTED) != 0)
2541 ::OffsetRect(&rcImage, 1, 1);
2542 CPen pen;
2543 pen.CreatePen(PS_SOLID, 0, ::GetSysColor(COLOR_BTNTEXT));
2544 pT->DrawButtonImage(dc, rcImage, pen);
2545 }
2546
2547 return CDRF_DODEFAULT; // continue with the default item painting
2548 }
2549
2550 // Implementation - overrideable methods
2551 void UpdateLayout(int cxWidth, int cyHeight)
2552 {
2553 ATLASSERT(::IsWindow(m_hWnd));
2554 RECT rect = { 0 };
2555
2556 if(IsVertical())
2557 {
2558 ::SetRect(&rect, 0, 0, m_cxyHeader, cyHeight);
2559 if(m_tb.m_hWnd != NULL)
2560 m_tb.SetWindowPos(NULL, m_cxyBorder, m_cxyBorder + m_cxyBtnOffset, 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
2561
2562 if(m_wndClient.m_hWnd != NULL)
2563 m_wndClient.SetWindowPos(NULL, m_cxyHeader, 0, cxWidth - m_cxyHeader, cyHeight, SWP_NOZORDER);
2564 else
2565 rect.right = cxWidth;
2566 }
2567 else
2568 {
2569 ::SetRect(&rect, 0, 0, cxWidth, m_cxyHeader);
2570 if(m_tb.m_hWnd != NULL)
2571 m_tb.SetWindowPos(NULL, rect.right - m_cxToolBar, m_cxyBorder + m_cxyBtnOffset, 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
2572
2573 if(m_wndClient.m_hWnd != NULL)
2574 m_wndClient.SetWindowPos(NULL, 0, m_cxyHeader, cxWidth, cyHeight - m_cxyHeader, SWP_NOZORDER);
2575 else
2576 rect.bottom = cyHeight;
2577 }
2578
2579 InvalidateRect(&rect);
2580 }
2581
2582 void CreateCloseButton()
2583 {
2584 ATLASSERT(m_tb.m_hWnd == NULL);
2585 // create toolbar for the "x" button
2586 m_tb.Create(m_hWnd, rcDefault, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | CCS_NODIVIDER | CCS_NORESIZE | CCS_NOPARENTALIGN | CCS_NOMOVEY | TBSTYLE_TOOLTIPS | TBSTYLE_FLAT, 0);
2587 ATLASSERT(m_tb.IsWindow());
2588
2589 if(m_tb.m_hWnd != NULL)
2590 {
2591 T* pT = static_cast<T*>(this);
2592 pT; // avoid level 4 warning
2593
2594 m_tb.SetButtonStructSize();
2595
2596 TBBUTTON tbbtn = { 0 };
2597 tbbtn.idCommand = pT->m_nCloseBtnID;
2598 tbbtn.fsState = TBSTATE_ENABLED;
2599 tbbtn.fsStyle = TBSTYLE_BUTTON;
2600 m_tb.AddButtons(1, &tbbtn);
2601
2602 m_tb.SetBitmapSize(m_cxImageTB, m_cyImageTB);
2603 m_tb.SetButtonSize(m_cxImageTB + m_cxyBtnAddTB, m_cyImageTB + m_cxyBtnAddTB);
2604
2605 if(IsVertical())
2606 m_tb.SetWindowPos(NULL, m_cxyBorder + m_cxyBtnOffset, m_cxyBorder + m_cxyBtnOffset, m_cxImageTB + m_cxyBtnAddTB, m_cyImageTB + m_cxyBtnAddTB, SWP_NOZORDER | SWP_NOACTIVATE);
2607 else
2608 m_tb.SetWindowPos(NULL, 0, 0, m_cxImageTB + m_cxyBtnAddTB, m_cyImageTB + m_cxyBtnAddTB, SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
2609 }
2610 }
2611
2612 void DestroyCloseButton()
2613 {
2614 if(m_tb.m_hWnd != NULL)
2615 m_tb.DestroyWindow();
2616 }
2617
2618 void CalcSize()
2619 {
2620 T* pT = static_cast<T*>(this);
2621 CFontHandle font = pT->GetTitleFont();
2622 LOGFONT lf = { 0 };
2623 font.GetLogFont(lf);
2624 if(IsVertical())
2625 {
2626 m_cxyHeader = m_cxImageTB + m_cxyBtnAddTB + m_cxyBorder;
2627 }
2628 else
2629 {
2630 int cyFont = abs(lf.lfHeight) + m_cxyBorder + 2 * m_cxyTextOffset;
2631 int cyBtn = m_cyImageTB + m_cxyBtnAddTB + m_cxyBorder + 2 * m_cxyBtnOffset;
2632 m_cxyHeader = __max(cyFont, cyBtn);
2633 }
2634 }
2635
2636 HFONT GetTitleFont() const
2637 {
2638 return AtlGetDefaultGuiFont();
2639 }
2640
2641 #ifndef _WIN32_WCE
2642 BOOL GetToolTipText(LPNMHDR /*lpnmh*/)
2643 {
2644 return FALSE;
2645 }
2646 #endif // !_WIN32_WCE
2647
2648 void DrawPaneTitle(CDCHandle dc)
2649 {
2650 RECT rect = { 0 };
2651 GetClientRect(&rect);
2652
2653 UINT uBorder = BF_LEFT | BF_TOP | BF_ADJUST;
2654 if(IsVertical())
2655 {
2656 rect.right = rect.left + m_cxyHeader;
2657 uBorder |= BF_BOTTOM;
2658 }
2659 else
2660 {
2661 rect.bottom = rect.top + m_cxyHeader;
2662 uBorder |= BF_RIGHT;
2663 }
2664
2665 if((m_dwExtendedStyle & PANECNT_NOBORDER) == 0)
2666 {
2667 if((m_dwExtendedStyle & PANECNT_FLATBORDER) != 0)
2668 uBorder |= BF_FLAT;
2669 dc.DrawEdge(&rect, EDGE_ETCHED, uBorder);
2670 }
2671 dc.FillRect(&rect, COLOR_3DFACE);
2672
2673 if(!IsVertical()) // draw title only for horizontal pane container
2674 {
2675 dc.SetTextColor(::GetSysColor(COLOR_WINDOWTEXT));
2676 dc.SetBkMode(TRANSPARENT);
2677 T* pT = static_cast<T*>(this);
2678 HFONT hFontOld = dc.SelectFont(pT->GetTitleFont());
2679 rect.left += m_cxyTextOffset;
2680 rect.right -= m_cxyTextOffset;
2681 if(m_tb.m_hWnd != NULL)
2682 rect.right -= m_cxToolBar;;
2683 #ifndef _WIN32_WCE
2684 dc.DrawText(m_szTitle, -1, &rect, DT_LEFT | DT_SINGLELINE | DT_VCENTER | DT_END_ELLIPSIS);
2685 #else // CE specific
2686 dc.DrawText(m_szTitle, -1, &rect, DT_LEFT | DT_SINGLELINE | DT_VCENTER);
2687 #endif // _WIN32_WCE
2688 dc.SelectFont(hFontOld);
2689 }
2690 }
2691
2692 // called only if pane is empty
2693 void DrawPane(CDCHandle dc)
2694 {
2695 RECT rect = { 0 };
2696 GetClientRect(&rect);
2697 if(IsVertical())
2698 rect.left += m_cxyHeader;
2699 else
2700 rect.top += m_cxyHeader;
2701 if((GetExStyle() & WS_EX_CLIENTEDGE) == 0)
2702 dc.DrawEdge(&rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
2703 dc.FillRect(&rect, COLOR_APPWORKSPACE);
2704 }
2705
2706 // drawing helper - draws "x" button image
2707 void DrawButtonImage(CDCHandle dc, RECT& rcImage, HPEN hPen)
2708 {
2709 #if !defined(_WIN32_WCE) || (_WIN32_WCE >= 400)
2710 HPEN hPenOld = dc.SelectPen(hPen);
2711
2712 dc.MoveTo(rcImage.left, rcImage.top);
2713 dc.LineTo(rcImage.right, rcImage.bottom);
2714 dc.MoveTo(rcImage.left + 1, rcImage.top);
2715 dc.LineTo(rcImage.right + 1, rcImage.bottom);
2716
2717 dc.MoveTo(rcImage.left, rcImage.bottom - 1);
2718 dc.LineTo(rcImage.right, rcImage.top - 1);
2719 dc.MoveTo(rcImage.left + 1, rcImage.bottom - 1);
2720 dc.LineTo(rcImage.right + 1, rcImage.top - 1);
2721
2722 dc.SelectPen(hPenOld);
2723 #else // (_WIN32_WCE < 400)
2724 rcImage;
2725 hPen;
2726 // no support for the "x" button image
2727 #endif // (_WIN32_WCE < 400)
2728 }
2729
2730 bool IsVertical() const
2731 {
2732 return ((m_dwExtendedStyle & PANECNT_VERTICAL) != 0);
2733 }
2734 };
2735
2736 class CPaneContainer : public CPaneContainerImpl<CPaneContainer>
2737 {
2738 public:
2739 DECLARE_WND_CLASS_EX(_T("WTL_PaneContainer"), 0, -1)
2740 };
2741
2742
2743 ///////////////////////////////////////////////////////////////////////////////
2744 // CSortListViewCtrl - implements sorting for a listview control
2745
2746 // sort listview extended styles
2747 #define SORTLV_USESHELLBITMAPS 0x00000001
2748
2749 // Notification sent to parent when sort column is changed by user clicking header.
2750 #define SLVN_SORTCHANGED LVN_LAST
2751
2752 // A LPNMSORTLISTVIEW is sent with the SLVN_SORTCHANGED notification
2753 typedef struct tagNMSORTLISTVIEW
2754 {
2755 NMHDR hdr;
2756 int iNewSortColumn;
2757 int iOldSortColumn;
2758 } NMSORTLISTVIEW, *LPNMSORTLISTVIEW;
2759
2760 // Column sort types. Can be set on a per-column basis with the SetColumnSortType method.
2761 enum
2762 {
2763 LVCOLSORT_NONE,
2764 LVCOLSORT_TEXT, // default
2765 LVCOLSORT_TEXTNOCASE,
2766 LVCOLSORT_LONG,
2767 LVCOLSORT_DOUBLE,
2768 LVCOLSORT_DECIMAL,
2769 LVCOLSORT_DATETIME,
2770 LVCOLSORT_DATE,
2771 LVCOLSORT_TIME,
2772 LVCOLSORT_CUSTOM,
2773 LVCOLSORT_LAST = LVCOLSORT_CUSTOM
2774 };
2775
2776
2777 template <class T>
2778 class CSortListViewImpl
2779 {
2780 public:
2781 enum
2782 {
2783 m_cchCmpTextMax = 32, // overrideable
2784 m_cxSortImage = 16,
2785 m_cySortImage = 15,
2786 m_cxSortArrow = 11,
2787 m_cySortArrow = 6,
2788 m_iSortUp = 0, // index of sort bitmaps
2789 m_iSortDown = 1,
2790 m_nShellSortUpID = 133
2791 };
2792
2793 // passed to LVCompare functions as lParam1 and lParam2
2794 struct LVCompareParam
2795 {
2796 int iItem;
2797 DWORD_PTR dwItemData;
2798 union
2799 {
2800 long lValue;
2801 double dblValue;
2802 DECIMAL decValue;
2803 LPCTSTR pszValue;
2804 };
2805 };
2806
2807 // passed to LVCompare functions as the lParamSort parameter
2808 struct LVSortInfo
2809 {
2810 T* pT;
2811 int iSortCol;
2812 bool bDescending;
2813 };
2814
2815 bool m_bSortDescending;
2816 bool m_bCommCtrl6;
2817 int m_iSortColumn;
2818 CBitmap m_bmSort[2];
2819 int m_fmtOldSortCol;
2820 HBITMAP m_hbmOldSortCol;
2821 DWORD m_dwSortLVExtendedStyle;
2822 ATL::CSimpleArray<WORD> m_arrColSortType;
2823 bool m_bUseWaitCursor;
2824
2825 CSortListViewImpl() :
2826 m_bSortDescending(false),
2827 m_bCommCtrl6(false),
2828 m_iSortColumn(-1),
2829 m_fmtOldSortCol(0),
2830 m_hbmOldSortCol(NULL),
2831 m_dwSortLVExtendedStyle(SORTLV_USESHELLBITMAPS),
2832 m_bUseWaitCursor(true)
2833 {
2834 #ifndef _WIN32_WCE
2835 DWORD dwMajor = 0;
2836 DWORD dwMinor = 0;
2837 HRESULT hRet = ATL::AtlGetCommCtrlVersion(&dwMajor, &dwMinor);
2838 m_bCommCtrl6 = SUCCEEDED(hRet) && dwMajor >= 6;
2839 #endif // !_WIN32_WCE
2840 }
2841
2842 // Attributes
2843 void SetSortColumn(int iCol)
2844 {
2845 T* pT = static_cast<T*>(this);
2846 ATLASSERT(::IsWindow(pT->m_hWnd));
2847 CHeaderCtrl header = pT->GetHeader();
2848 ATLASSERT(header.m_hWnd != NULL);
2849 ATLASSERT(iCol >= -1 && iCol < m_arrColSortType.GetSize());
2850
2851 int iOldSortCol = m_iSortColumn;
2852 m_iSortColumn = iCol;
2853 if(m_bCommCtrl6)
2854 {
2855 #ifndef HDF_SORTUP
2856 const int HDF_SORTUP = 0x0400;
2857 #endif // HDF_SORTUP
2858 #ifndef HDF_SORTDOWN
2859 const int HDF_SORTDOWN = 0x0200;
2860 #endif // HDF_SORTDOWN
2861 const int nMask = HDF_SORTUP | HDF_SORTDOWN;
2862 HDITEM hditem = { HDI_FORMAT };
2863 if(iOldSortCol != iCol && iOldSortCol >= 0 && header.GetItem(iOldSortCol, &hditem))
2864 {
2865 hditem.fmt &= ~nMask;
2866 header.SetItem(iOldSortCol, &hditem);
2867 }
2868 if(iCol >= 0 && header.GetItem(iCol, &hditem))
2869 {
2870 hditem.fmt &= ~nMask;
2871 hditem.fmt |= m_bSortDescending ? HDF_SORTDOWN : HDF_SORTUP;
2872 header.SetItem(iCol, &hditem);
2873 }
2874 return;
2875 }
2876
2877 if(m_bmSort[m_iSortUp].IsNull())
2878 pT->CreateSortBitmaps();
2879
2880 // restore previous sort column's bitmap, if any, and format
2881 HDITEM hditem = { HDI_BITMAP | HDI_FORMAT };
2882 if(iOldSortCol != iCol && iOldSortCol >= 0)
2883 {
2884 hditem.hbm = m_hbmOldSortCol;
2885 hditem.fmt = m_fmtOldSortCol;
2886 header.SetItem(iOldSortCol, &hditem);
2887 }
2888
2889 // save new sort column's bitmap and format, and add our sort bitmap
2890 if(iCol >= 0 && header.GetItem(iCol, &hditem))
2891 {
2892 if(iOldSortCol != iCol)
2893 {
2894 m_fmtOldSortCol = hditem.fmt;
2895 m_hbmOldSortCol = hditem.hbm;
2896 }
2897 hditem.fmt &= ~HDF_IMAGE;
2898 hditem.fmt |= HDF_BITMAP | HDF_BITMAP_ON_RIGHT;
2899 int i = m_bSortDescending ? m_iSortDown : m_iSortUp;
2900 hditem.hbm = m_bmSort[i];
2901 header.SetItem(iCol, &hditem);
2902 }
2903 }
2904
2905 int GetSortColumn() const
2906 {
2907 return m_iSortColumn;
2908 }
2909
2910 void SetColumnSortType(int iCol, WORD wType)
2911 {
2912 ATLASSERT(iCol >= 0 && iCol < m_arrColSortType.GetSize());
2913 ATLASSERT(wType >= LVCOLSORT_NONE && wType <= LVCOLSORT_LAST);
2914 m_arrColSortType[iCol] = wType;
2915 }
2916
2917 WORD GetColumnSortType(int iCol) const
2918 {
2919 ATLASSERT((iCol >= 0) && iCol < m_arrColSortType.GetSize());
2920 return m_arrColSortType[iCol];
2921 }
2922
2923 int GetColumnCount() const
2924 {
2925 const T* pT = static_cast<const T*>(this);
2926 ATLASSERT(::IsWindow(pT->m_hWnd));
2927 CHeaderCtrl header = pT->GetHeader();
2928 return header.m_hWnd != NULL ? header.GetItemCount() : 0;
2929 }
2930
2931 bool IsSortDescending() const
2932 {
2933 return m_bSortDescending;
2934 }
2935
2936 DWORD GetSortListViewExtendedStyle() const
2937 {
2938 return m_dwSortLVExtendedStyle;
2939 }
2940
2941 DWORD SetSortListViewExtendedStyle(DWORD dwExtendedStyle, DWORD dwMask = 0)
2942 {
2943 DWORD dwPrevStyle = m_dwSortLVExtendedStyle;
2944 if(dwMask == 0)
2945 m_dwSortLVExtendedStyle = dwExtendedStyle;
2946 else
2947 m_dwSortLVExtendedStyle = (m_dwSortLVExtendedStyle & ~dwMask) | (dwExtendedStyle & dwMask);
2948 return dwPrevStyle;
2949 }
2950
2951 // Operations
2952 bool DoSortItems(int iCol, bool bDescending = false)
2953 {
2954 T* pT = static_cast<T*>(this);
2955 ATLASSERT(::IsWindow(pT->m_hWnd));
2956 ATLASSERT(iCol >= 0 && iCol < m_arrColSortType.GetSize());
2957
2958 WORD wType = m_arrColSortType[iCol];
2959 if(wType == LVCOLSORT_NONE)
2960 return false;
2961
2962 int nCount = pT->GetItemCount();
2963 if(nCount < 2)
2964 {
2965 m_bSortDescending = bDescending;
2966 SetSortColumn(iCol);
2967 return true;
2968 }
2969
2970 CWaitCursor waitCursor(false);
2971 if(m_bUseWaitCursor)
2972 waitCursor.Set();
2973
2974 LVCompareParam* pParam = NULL;
2975 ATLTRY(pParam = new LVCompareParam[nCount]);
2976 PFNLVCOMPARE pFunc = NULL;
2977 TCHAR pszTemp[pT->m_cchCmpTextMax];
2978 bool bStrValue = false;
2979
2980 switch(wType)
2981 {
2982 case LVCOLSORT_TEXT:
2983 pFunc = (PFNLVCOMPARE)pT->LVCompareText;
2984 case LVCOLSORT_TEXTNOCASE:
2985 if(pFunc == NULL)
2986 pFunc = (PFNLVCOMPARE)pT->LVCompareTextNoCase;
2987 case LVCOLSORT_CUSTOM:
2988 {
2989 if(pFunc == NULL)
2990 pFunc = (PFNLVCOMPARE)pT->LVCompareCustom;
2991
2992 for(int i = 0; i < nCount; i++)
2993 {
2994 pParam[i].iItem = i;
2995 pParam[i].dwItemData = pT->GetItemData(i);
2996 pParam[i].pszValue = new TCHAR[pT->m_cchCmpTextMax];
2997 pT->GetItemText(i, iCol, (LPTSTR)pParam[i].pszValue, pT->m_cchCmpTextMax);
2998 pT->SetItemData(i, (DWORD_PTR)&pParam[i]);
2999 }
3000 bStrValue = true;
3001 }
3002 break;
3003 case LVCOLSORT_LONG:
3004 {
3005 pFunc = (PFNLVCOMPARE)pT->LVCompareLong;
3006 for(int i = 0; i < nCount; i++)
3007 {
3008 pParam[i].iItem = i;
3009 pParam[i].dwItemData = pT->GetItemData(i);
3010 pT->GetItemText(i, iCol, pszTemp, pT->m_cchCmpTextMax);
3011 pParam[i].lValue = pT->StrToLong(pszTemp);
3012 pT->SetItemData(i, (DWORD_PTR)&pParam[i]);
3013 }
3014 }
3015 break;
3016 case LVCOLSORT_DOUBLE:
3017 {
3018 pFunc = (PFNLVCOMPARE)pT->LVCompareDouble;
3019 for(int i = 0; i < nCount; i++)
3020 {
3021 pParam[i].iItem = i;
3022 pParam[i].dwItemData = pT->GetItemData(i);
3023 pT->GetItemText(i, iCol, pszTemp, pT->m_cchCmpTextMax);
3024 pParam[i].dblValue = pT->StrToDouble(pszTemp);
3025 pT->SetItemData(i, (DWORD_PTR)&pParam[i]);
3026 }
3027 }
3028 break;
3029 case LVCOLSORT_DECIMAL:
3030 {
3031 pFunc = (PFNLVCOMPARE)pT->LVCompareDecimal;
3032 for(int i = 0; i < nCount; i++)
3033 {
3034 pParam[i].iItem = i;
3035 pParam[i].dwItemData = pT->GetItemData(i);
3036 pT->GetItemText(i, iCol, pszTemp, pT->m_cchCmpTextMax);
3037 pT->StrToDecimal(pszTemp, &pParam[i].decValue);
3038 pT->SetItemData(i, (DWORD_PTR)&pParam[i]);
3039 }
3040 }
3041 break;
3042 case LVCOLSORT_DATETIME:
3043 case LVCOLSORT_DATE:
3044 case LVCOLSORT_TIME:
3045 {
3046 pFunc = (PFNLVCOMPARE)pT->LVCompareDouble;
3047 DWORD dwFlags = LOCALE_NOUSEROVERRIDE;
3048 if(wType == LVCOLSORT_DATE)
3049 dwFlags |= VAR_DATEVALUEONLY;
3050 else if(wType == LVCOLSORT_TIME)
3051 dwFlags |= VAR_TIMEVALUEONLY;
3052 for(int i = 0; i < nCount; i++)
3053 {
3054 pParam[i].iItem = i;
3055 pParam[i].dwItemData = pT->GetItemData(i);
3056 pT->GetItemText(i, iCol, pszTemp, pT->m_cchCmpTextMax);
3057 pParam[i].dblValue = pT->DateStrToDouble(pszTemp, dwFlags);
3058 pT->SetItemData(i, (DWORD_PTR)&pParam[i]);
3059 }
3060 }
3061 break;
3062 default:
3063 ATLTRACE2(atlTraceUI, 0, _T("Unknown value for sort type in CSortListViewImpl::DoSortItems()\n"));
3064 break;
3065 } // switch(wType)
3066
3067 ATLASSERT(pFunc != NULL);
3068 LVSortInfo lvsi = { pT, iCol, bDescending };
3069 bool bRet = ((BOOL)pT->DefWindowProc(LVM_SORTITEMS, (WPARAM)&lvsi, (LPARAM)pFunc) != FALSE);
3070 for(int i = 0; i < nCount; i++)
3071 {
3072 DWORD_PTR dwItemData = pT->GetItemData(i);
3073 LVCompareParam* p = (LVCompareParam*)dwItemData;
3074 ATLASSERT(p != NULL);
3075 if(bStrValue)
3076 delete [] (TCHAR*)p->pszValue;
3077 pT->SetItemData(i, p->dwItemData);
3078 }
3079 delete [] pParam;
3080
3081 if(bRet)
3082 {
3083 m_bSortDescending = bDescending;
3084 SetSortColumn(iCol);
3085 }
3086
3087 if(m_bUseWaitCursor)
3088 waitCursor.Restore();
3089
3090 return bRet;
3091 }
3092
3093 void CreateSortBitmaps()
3094 {
3095 if((m_dwSortLVExtendedStyle & SORTLV_USESHELLBITMAPS) != 0)
3096 {
3097 bool bFree = false;
3098 LPCTSTR pszModule = _T("shell32.dll");
3099 HINSTANCE hShell = ::GetModuleHandle(pszModule);
3100
3101 if (hShell == NULL)
3102 {
3103 hShell = ::LoadLibrary(pszModule);
3104 bFree = true;
3105 }
3106
3107 if (hShell != NULL)
3108 {
3109 bool bSuccess = true;
3110 for(int i = m_iSortUp; i <= m_iSortDown; i++)
3111 {
3112 if(!m_bmSort[i].IsNull())
3113 m_bmSort[i].DeleteObject();
3114 m_bmSort[i] = (HBITMAP)::LoadImage(hShell, MAKEINTRESOURCE(m_nShellSortUpID + i),
3115 #ifndef _WIN32_WCE
3116 IMAGE_BITMAP, 0, 0, LR_LOADMAP3DCOLORS);
3117 #else // CE specific
3118 IMAGE_BITMAP, 0, 0, 0);
3119 #endif // _WIN32_WCE
3120 if(m_bmSort[i].IsNull())
3121 {
3122 bSuccess = false;
3123 break;
3124 }
3125 }
3126 if(bFree)
3127 ::FreeLibrary(hShell);
3128 if(bSuccess)
3129 return;
3130 }
3131 }
3132
3133 T* pT = static_cast<T*>(this);
3134 for(int i = m_iSortUp; i <= m_iSortDown; i++)
3135 {
3136 if(!m_bmSort[i].IsNull())
3137 m_bmSort[i].DeleteObject();
3138
3139 CDC dcMem;
3140 CClientDC dc(::GetDesktopWindow());
3141 dcMem.CreateCompatibleDC(dc.m_hDC);
3142 m_bmSort[i].CreateCompatibleBitmap(dc.m_hDC, m_cxSortImage, m_cySortImage);
3143 HBITMAP hbmOld = dcMem.SelectBitmap(m_bmSort[i]);
3144 RECT rc = {0,0,m_cxSortImage, m_cySortImage};
3145 pT->DrawSortBitmap(dcMem.m_hDC, i, &rc);
3146 dcMem.SelectBitmap(hbmOld);
3147 dcMem.DeleteDC();
3148 }
3149 }
3150
3151 void NotifyParentSortChanged(int iNewSortCol, int iOldSortCol)
3152 {
3153 T* pT = static_cast<T*>(this);
3154 int nID = pT->GetDlgCtrlID();
3155 NMSORTLISTVIEW nm = { { pT->m_hWnd, nID, SLVN_SORTCHANGED }, iNewSortCol, iOldSortCol };
3156 ::SendMessage(pT->GetParent(), WM_NOTIFY, (WPARAM)nID, (LPARAM)&nm);
3157 }
3158
3159 // Overrideables
3160 int CompareItemsCustom(LVCompareParam* /*pItem1*/, LVCompareParam* /*pItem2*/, int /*iSortCol*/)
3161 {
3162 // pItem1 and pItem2 contain valid iItem, dwItemData, and pszValue members.
3163 // If item1 > item2 return 1, if item1 < item2 return -1, else return 0.
3164 return 0;
3165 }
3166
3167 void DrawSortBitmap(CDCHandle dc, int iBitmap, LPRECT prc)
3168 {
3169 dc.FillRect(prc, ::GetSysColorBrush(COLOR_BTNFACE));
3170 HBRUSH hbrOld = dc.SelectBrush(::GetSysColorBrush(COLOR_BTNSHADOW));
3171 CPen pen;
3172 pen.CreatePen(PS_SOLID, 0, ::GetSysColor(COLOR_BTNSHADOW));
3173 HPEN hpenOld = dc.SelectPen(pen);
3174 POINT ptOrg = { (m_cxSortImage - m_cxSortArrow) / 2, (m_cySortImage - m_cySortArrow) / 2 };
3175 if(iBitmap == m_iSortUp)
3176 {
3177 POINT pts[3] =
3178 {
3179 { ptOrg.x + m_cxSortArrow / 2, ptOrg.y },
3180 { ptOrg.x, ptOrg.y + m_cySortArrow - 1 },
3181 { ptOrg.x + m_cxSortArrow - 1, ptOrg.y + m_cySortArrow - 1 }
3182 };
3183 dc.Polygon(pts, 3);
3184 }
3185 else
3186 {
3187 POINT pts[3] =
3188 {
3189 { ptOrg.x, ptOrg.y },
3190 { ptOrg.x + m_cxSortArrow / 2, ptOrg.y + m_cySortArrow - 1 },
3191 { ptOrg.x + m_cxSortArrow - 1, ptOrg.y }
3192 };
3193 dc.Polygon(pts, 3);
3194 }
3195 dc.SelectBrush(hbrOld);
3196 dc.SelectPen(hpenOld);
3197 }
3198
3199 double DateStrToDouble(LPCTSTR lpstr, DWORD dwFlags)
3200 {
3201 ATLASSERT(lpstr != NULL);
3202 if(lpstr == NULL || lpstr[0] == _T('\0'))
3203 return 0;
3204
3205 USES_CONVERSION;
3206 HRESULT hRet = E_FAIL;
3207 DATE dRet = 0;
3208 if (FAILED(hRet = ::VarDateFromStr((LPOLESTR)T2COLE(lpstr), LANG_USER_DEFAULT, dwFlags, &dRet)))
3209 {
3210 ATLTRACE2(atlTraceUI, 0, _T("VarDateFromStr failed with result of 0x%8.8X\n"), hRet);
3211 dRet = 0;
3212 }
3213 return dRet;
3214 }
3215
3216 long StrToLong(LPCTSTR lpstr)
3217 {
3218 ATLASSERT(lpstr != NULL);
3219 if(lpstr == NULL || lpstr[0] == _T('\0'))
3220 return 0;
3221
3222 USES_CONVERSION;
3223 HRESULT hRet = E_FAIL;
3224 long lRet = 0;
3225 if (FAILED(hRet = ::VarI4FromStr((LPOLESTR)T2COLE(lpstr), LANG_USER_DEFAULT, LOCALE_NOUSEROVERRIDE, &lRet)))
3226 {
3227 ATLTRACE2(atlTraceUI, 0, _T("VarI4FromStr failed with result of 0x%8.8X\n"), hRet);
3228 lRet = 0;
3229 }
3230 return lRet;
3231 }
3232
3233 double StrToDouble(LPCTSTR lpstr)
3234 {
3235 ATLASSERT(lpstr != NULL);
3236 if(lpstr == NULL || lpstr[0] == _T('\0'))
3237 return 0;
3238
3239 USES_CONVERSION;
3240 HRESULT hRet = E_FAIL;
3241 double dblRet = 0;
3242 if (FAILED(hRet = ::VarR8FromStr((LPOLESTR)T2COLE(lpstr), LANG_USER_DEFAULT, LOCALE_NOUSEROVERRIDE, &dblRet)))
3243 {
3244 ATLTRACE2(atlTraceUI, 0, _T("VarR8FromStr failed with result of 0x%8.8X\n"), hRet);
3245 dblRet = 0;
3246 }
3247 return dblRet;
3248 }
3249
3250 bool StrToDecimal(LPCTSTR lpstr, DECIMAL* pDecimal)
3251 {
3252 ATLASSERT(lpstr != NULL);
3253 ATLASSERT(pDecimal != NULL);
3254 if(lpstr == NULL || pDecimal == NULL)
3255 return false;
3256
3257 USES_CONVERSION;
3258 HRESULT hRet = E_FAIL;
3259 if (FAILED(hRet = ::VarDecFromStr((LPOLESTR)T2COLE(lpstr), LANG_USER_DEFAULT, LOCALE_NOUSEROVERRIDE, pDecimal)))
3260 {
3261 ATLTRACE2(atlTraceUI, 0, _T("VarDecFromStr failed with result of 0x%8.8X\n"), hRet);
3262 pDecimal->Lo64 = 0;
3263 pDecimal->Hi32 = 0;
3264 pDecimal->signscale = 0;
3265 return false;
3266 }
3267 return true;
3268 }
3269
3270 // Overrideable PFNLVCOMPARE functions
3271 static int CALLBACK LVCompareText(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
3272 {
3273 ATLASSERT(lParam1 != NULL && lParam2 != NULL && lParamSort != NULL);
3274
3275 LVCompareParam* pParam1 = (LVCompareParam*)lParam1;
3276 LVCompareParam* pParam2 = (LVCompareParam*)lParam2;
3277 LVSortInfo* pInfo = (LVSortInfo*)lParamSort;
3278
3279 int nRet = lstrcmp(pParam1->pszValue, pParam2->pszValue);
3280 return pInfo->bDescending ? -nRet : nRet;
3281 }
3282
3283 static int CALLBACK LVCompareTextNoCase(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
3284 {
3285 ATLASSERT(lParam1 != NULL && lParam2 != NULL && lParamSort != NULL);
3286
3287 LVCompareParam* pParam1 = (LVCompareParam*)lParam1;
3288 LVCompareParam* pParam2 = (LVCompareParam*)lParam2;
3289 LVSortInfo* pInfo = (LVSortInfo*)lParamSort;
3290
3291 int nRet = lstrcmpi(pParam1->pszValue, pParam2->pszValue);
3292 return pInfo->bDescending ? -nRet : nRet;
3293 }
3294
3295 static int CALLBACK LVCompareLong(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
3296 {
3297 ATLASSERT(lParam1 != NULL && lParam2 != NULL && lParamSort != NULL);
3298
3299 LVCompareParam* pParam1 = (LVCompareParam*)lParam1;
3300 LVCompareParam* pParam2 = (LVCompareParam*)lParam2;
3301 LVSortInfo* pInfo = (LVSortInfo*)lParamSort;
3302
3303 int nRet = 0;
3304 if(pParam1->lValue > pParam2->lValue)
3305 nRet = 1;
3306 else if(pParam1->lValue < pParam2->lValue)
3307 nRet = -1;
3308 return pInfo->bDescending ? -nRet : nRet;
3309 }
3310
3311 static int CALLBACK LVCompareDouble(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
3312 {
3313 ATLASSERT(lParam1 != NULL && lParam2 != NULL && lParamSort != NULL);
3314
3315 LVCompareParam* pParam1 = (LVCompareParam*)lParam1;
3316 LVCompareParam* pParam2 = (LVCompareParam*)lParam2;
3317 LVSortInfo* pInfo = (LVSortInfo*)lParamSort;
3318
3319 int nRet = 0;
3320 if(pParam1->dblValue > pParam2->dblValue)
3321 nRet = 1;
3322 else if(pParam1->dblValue < pParam2->dblValue)
3323 nRet = -1;
3324 return pInfo->bDescending ? -nRet : nRet;
3325 }
3326
3327 static int CALLBACK LVCompareCustom(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
3328 {
3329 ATLASSERT(lParam1 != NULL && lParam2 != NULL && lParamSort != NULL);
3330
3331 LVCompareParam* pParam1 = (LVCompareParam*)lParam1;
3332 LVCompareParam* pParam2 = (LVCompareParam*)lParam2;
3333 LVSortInfo* pInfo = (LVSortInfo*)lParamSort;
3334
3335 int nRet = pInfo->pT->CompareItemsCustom(pParam1, pParam2, pInfo->iSortCol);
3336 return pInfo->bDescending ? -nRet : nRet;
3337 }
3338
3339 #ifndef _WIN32_WCE
3340 static int CALLBACK LVCompareDecimal(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
3341 {
3342 ATLASSERT(lParam1 != NULL && lParam2 != NULL && lParamSort != NULL);
3343
3344 LVCompareParam* pParam1 = (LVCompareParam*)lParam1;
3345 LVCompareParam* pParam2 = (LVCompareParam*)lParam2;
3346 LVSortInfo* pInfo = (LVSortInfo*)lParamSort;
3347
3348 int nRet = (int)::VarDecCmp(&pParam1->decValue, &pParam2->decValue);
3349 nRet--;
3350 return pInfo->bDescending ? -nRet : nRet;
3351 }
3352 #else
3353 // Compare mantissas, ignore sign and scale
3354 static int CompareMantissas(const DECIMAL& decLeft, const DECIMAL& decRight)
3355 {
3356 if (decLeft.Hi32 < decRight.Hi32)
3357 {
3358 return -1;
3359 }
3360 if (decLeft.Hi32 > decRight.Hi32)
3361 {
3362 return 1;
3363 }
3364 // Here, decLeft.Hi32 == decRight.Hi32
3365 if (decLeft.Lo64 < decRight.Lo64)
3366 {
3367 return -1;
3368 }
3369 if (decLeft.Lo64 > decRight.Lo64)
3370 {
3371 return 1;
3372 }
3373 return 0;
3374 }
3375
3376 // return values: VARCMP_LT, VARCMP_EQ, VARCMP_GT, VARCMP_NULL
3377 static HRESULT VarDecCmp(const DECIMAL* pdecLeft, const DECIMAL* pdecRight)
3378 {
3379 static const ULONG powersOfTen[] =
3380 {
3381 10ul,
3382 100ul,
3383 1000ul,
3384 10000ul,
3385 100000ul,
3386 1000000ul,
3387 10000000ul,
3388 100000000ul,
3389 1000000000ul
3390 };
3391 static const int largestPower = sizeof(powersOfTen) / sizeof(powersOfTen[0]);
3392 if (!pdecLeft || !pdecRight)
3393 {
3394 return VARCMP_NULL;
3395 }
3396
3397 // Degenerate case - at least one comparand is of the form
3398 // [+-]0*10^N (denormalized zero)
3399 bool bLeftZero = (!pdecLeft->Lo64 && !pdecLeft->Hi32);
3400 bool bRightZero = (!pdecRight->Lo64 && !pdecRight->Hi32);
3401 if (bLeftZero && bRightZero)
3402 {
3403 return VARCMP_EQ;
3404 }
3405 bool bLeftNeg = ((pdecLeft->sign & DECIMAL_NEG) != 0);
3406 bool bRightNeg = ((pdecRight->sign & DECIMAL_NEG) != 0);
3407 if (bLeftZero)
3408 {
3409 return (bRightNeg ? VARCMP_GT : VARCMP_LT);
3410 }
3411 // This also covers the case where the comparands have different signs
3412 if (bRightZero || bLeftNeg != bRightNeg)
3413 {
3414 return (bLeftNeg ? VARCMP_LT : VARCMP_GT);
3415 }
3416
3417 // Here both comparands have the same sign and need to be compared
3418 // on mantissa and scale. The result is obvious when
3419 // 1. Scales are equal (then compare mantissas)
3420 // 2. A number with smaller scale is also the one with larger mantissa
3421 // (then this number is obviously larger)
3422 // In the remaining case, we would multiply the number with smaller
3423 // scale by 10 and simultaneously increment its scale (which amounts to
3424 // adding trailing zeros after decimal point), until the numbers fall under
3425 // one of the two cases above
3426 DECIMAL temp;
3427 bool bInvert = bLeftNeg; // the final result needs to be inverted
3428 if (pdecLeft->scale < pdecRight->scale)
3429 {
3430 temp = *pdecLeft;
3431 }
3432 else
3433 {
3434 temp = *pdecRight;
3435 pdecRight = pdecLeft;
3436 bInvert = !bInvert;
3437 }
3438
3439 // Now temp is the number with smaller (or equal) scale, and
3440 // we can modify it freely without touching original parameters
3441 int comp;
3442 while ((comp = CompareMantissas(temp, *pdecRight)) < 0 &&
3443 temp.scale < pdecRight->scale)
3444 {
3445 // Multiply by an appropriate power of 10
3446 int scaleDiff = pdecRight->scale - temp.scale;
3447 if (scaleDiff > largestPower)
3448 {
3449 // Keep the multiplier representable in 32bit
3450 scaleDiff = largestPower;
3451 }
3452 DWORDLONG power = powersOfTen[scaleDiff - 1];
3453 // Multiply temp's mantissa by power
3454 DWORDLONG product = temp.Lo32 * power;
3455 ULONG carry = static_cast<ULONG>(product >> 32);
3456 temp.Lo32 = static_cast<ULONG>(product);
3457 product = temp.Mid32 * power + carry;
3458 carry = static_cast<ULONG>(product >> 32);
3459 temp.Mid32 = static_cast<ULONG>(product);
3460 product = temp.Hi32 * power + carry;
3461 if (static_cast<ULONG>(product >> 32))
3462 {
3463 // Multiplication overflowed - pdecLeft is clearly larger
3464 break;
3465 }
3466 temp.Hi32 = static_cast<ULONG>(product);
3467 temp.scale = (BYTE)(temp.scale + scaleDiff);
3468 }
3469 if (temp.scale < pdecRight->scale)
3470 {
3471 comp = 1;
3472 }
3473 if (bInvert)
3474 {
3475 comp = -comp;
3476 }
3477 return (comp > 0 ? VARCMP_GT : comp < 0 ? VARCMP_LT : VARCMP_EQ);
3478 }
3479
3480 static int CALLBACK LVCompareDecimal(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
3481 {
3482 ATLASSERT(lParam1 != NULL && lParam2 != NULL && lParamSort != NULL);
3483
3484 LVCompareParam* pParam1 = (LVCompareParam*)lParam1;
3485 LVCompareParam* pParam2 = (LVCompareParam*)lParam2;
3486 LVSortInfo* pInfo = (LVSortInfo*)lParamSort;
3487
3488 int nRet = (int)VarDecCmp(&pParam1->decValue, &pParam2->decValue);
3489 nRet--;
3490 return pInfo->bDescending ? -nRet : nRet;
3491 }
3492 #endif // !_WIN32_WCE
3493
3494 BEGIN_MSG_MAP(CSortListViewImpl)
3495 MESSAGE_HANDLER(LVM_INSERTCOLUMN, OnInsertColumn)
3496 MESSAGE_HANDLER(LVM_DELETECOLUMN, OnDeleteColumn)
3497 NOTIFY_CODE_HANDLER(HDN_ITEMCLICKA, OnHeaderItemClick)
3498 NOTIFY_CODE_HANDLER(HDN_ITEMCLICKW, OnHeaderItemClick)
3499 MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange)
3500 END_MSG_MAP()
3501
3502 LRESULT OnInsertColumn(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
3503 {
3504 T* pT = static_cast<T*>(this);
3505 LRESULT lRet = pT->DefWindowProc(uMsg, wParam, lParam);
3506 if(lRet == -1)
3507 return -1;
3508
3509 WORD wType = 0;
3510 m_arrColSortType.Add(wType);
3511 int nCount = m_arrColSortType.GetSize();
3512 ATLASSERT(nCount == GetColumnCount());
3513
3514 for(int i = nCount - 1; i > lRet; i--)
3515 m_arrColSortType[i] = m_arrColSortType[i - 1];
3516 m_arrColSortType[(int)lRet] = LVCOLSORT_TEXT;
3517
3518 if(lRet <= m_iSortColumn)
3519 m_iSortColumn++;
3520
3521 return lRet;
3522 }
3523
3524 LRESULT OnDeleteColumn(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
3525 {
3526 T* pT = static_cast<T*>(this);
3527 LRESULT lRet = pT->DefWindowProc(uMsg, wParam, lParam);
3528 if(lRet == 0)
3529 return 0;
3530
3531 int iCol = (int)wParam;
3532 if(m_iSortColumn == iCol)
3533 m_iSortColumn = -1;
3534 else if(m_iSortColumn > iCol)
3535 m_iSortColumn--;
3536 m_arrColSortType.RemoveAt(iCol);
3537
3538 return lRet;
3539 }
3540
3541 LRESULT OnHeaderItemClick(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled)
3542 {
3543 LPNMHEADER p = (LPNMHEADER)pnmh;
3544 if(p->iButton == 0)
3545 {
3546 int iOld = m_iSortColumn;
3547 bool bDescending = (m_iSortColumn == p->iItem) ? !m_bSortDescending : false;
3548 if(DoSortItems(p->iItem, bDescending))
3549 NotifyParentSortChanged(p->iItem, iOld);
3550 }
3551 bHandled = FALSE;
3552 return 0;
3553 }
3554
3555 LRESULT OnSettingChange(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
3556 {
3557 #ifndef _WIN32_WCE
3558 if(wParam == SPI_SETNONCLIENTMETRICS)
3559 GetSystemSettings();
3560 #else // CE specific
3561 wParam; // avoid level 4 warning
3562 GetSystemSettings();
3563 #endif // _WIN32_WCE
3564 bHandled = FALSE;
3565 return 0;
3566 }
3567
3568 void GetSystemSettings()
3569 {
3570 if(!m_bCommCtrl6 && !m_bmSort[m_iSortUp].IsNull())
3571 {
3572 T* pT = static_cast<T*>(this);
3573 pT->CreateSortBitmaps();
3574 if(m_iSortColumn != -1)
3575 SetSortColumn(m_iSortColumn);
3576 }
3577 }
3578
3579 };
3580
3581
3582 typedef ATL::CWinTraits<WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | LVS_REPORT | LVS_SHOWSELALWAYS , WS_EX_CLIENTEDGE> CSortListViewCtrlTraits;
3583
3584 template <class T, class TBase = CListViewCtrl, class TWinTraits = CSortListViewCtrlTraits>
3585 class ATL_NO_VTABLE CSortListViewCtrlImpl: public ATL::CWindowImpl<T, TBase, TWinTraits>, public CSortListViewImpl<T>
3586 {
3587 public:
3588 DECLARE_WND_SUPERCLASS(NULL, TBase::GetWndClassName())
3589
3590 bool SortItems(int iCol, bool bDescending = false)
3591 {
3592 return DoSortItems(iCol, bDescending);
3593 }
3594
3595 BEGIN_MSG_MAP(CSortListViewCtrlImpl)
3596 MESSAGE_HANDLER(LVM_INSERTCOLUMN, CSortListViewImpl<T>::OnInsertColumn)
3597 MESSAGE_HANDLER(LVM_DELETECOLUMN, CSortListViewImpl<T>::OnDeleteColumn)
3598 NOTIFY_CODE_HANDLER(HDN_ITEMCLICKA, CSortListViewImpl<T>::OnHeaderItemClick)
3599 NOTIFY_CODE_HANDLER(HDN_ITEMCLICKW, CSortListViewImpl<T>::OnHeaderItemClick)
3600 MESSAGE_HANDLER(WM_SETTINGCHANGE, CSortListViewImpl<T>::OnSettingChange)
3601 END_MSG_MAP()
3602 };
3603
3604 class CSortListViewCtrl : public CSortListViewCtrlImpl<CSortListViewCtrl>
3605 {
3606 public:
3607 DECLARE_WND_SUPERCLASS(_T("WTL_SortListViewCtrl"), GetWndClassName())
3608 };
3609
3610
3611 ///////////////////////////////////////////////////////////////////////////////
3612 // CTabView - implements tab view window
3613
3614 // TabView Notifications
3615 #define TBVN_PAGEACTIVATED (0U-741)
3616 #define TBVN_CONTEXTMENU (0U-742)
3617
3618 // Notification data for TBVN_CONTEXTMENU
3619 struct TBVCONTEXTMENUINFO
3620 {
3621 NMHDR hdr;
3622 POINT pt;
3623 };
3624
3625 typedef TBVCONTEXTMENUINFO* LPTBVCONTEXTMENUINFO;
3626
3627
3628 template <class T, class TBase = ATL::CWindow, class TWinTraits = ATL::CControlWinTraits>
3629 class ATL_NO_VTABLE CTabViewImpl : public ATL::CWindowImpl<T, TBase, TWinTraits>
3630 {
3631 public:
3632 DECLARE_WND_CLASS_EX(NULL, 0, COLOR_APPWORKSPACE)
3633
3634 // Declarations and enums
3635 struct TABVIEWPAGE
3636 {
3637 HWND hWnd;
3638 LPTSTR lpstrTitle;
3639 LPVOID pData;
3640 };
3641
3642 struct TCITEMEXTRA
3643 {
3644 TCITEMHEADER tciheader;
3645 TABVIEWPAGE tvpage;
3646
3647 operator LPTCITEM() { return (LPTCITEM)this; }
3648 };
3649
3650 enum
3651 {
3652 m_nTabID = 1313,
3653 m_cxMoveMark = 6,
3654 m_cyMoveMark = 3,
3655 m_nMenuItemsMax = (ID_WINDOW_TABLAST - ID_WINDOW_TABFIRST + 1)
3656 };
3657
3658 // Data members
3659 ATL::CContainedWindowT<CTabCtrl> m_tab;
3660 int m_cyTabHeight;
3661
3662 int m_nActivePage;
3663
3664 int m_nInsertItem;
3665 POINT m_ptStartDrag;
3666
3667 CMenuHandle m_menu;
3668
3669 int m_cchTabTextLength;
3670
3671 int m_nMenuItemsCount;
3672
3673 ATL::CWindow m_wndTitleBar;
3674 LPTSTR m_lpstrTitleBarBase;
3675 int m_cchTitleBarLength;
3676
3677 CImageList m_ilDrag;
3678
3679 bool m_bDestroyPageOnRemove:1;
3680 bool m_bDestroyImageList:1;
3681 bool m_bActivePageMenuItem:1;
3682 bool m_bActiveAsDefaultMenuItem:1;
3683 bool m_bEmptyMenuItem:1;
3684 bool m_bWindowsMenuItem:1;
3685 // internal
3686 bool m_bTabCapture:1;
3687 bool m_bTabDrag:1;
3688
3689 // Constructor/destructor
3690 CTabViewImpl() :
3691 m_nActivePage(-1),
3692 m_cyTabHeight(0),
3693 m_tab(this, 1),
3694 m_nInsertItem(-1),
3695 m_cchTabTextLength(30),
3696 m_nMenuItemsCount(10),
3697 m_lpstrTitleBarBase(NULL),
3698 m_cchTitleBarLength(100),
3699 m_bDestroyPageOnRemove(true),
3700 m_bDestroyImageList(true),
3701 m_bActivePageMenuItem(true),
3702 m_bActiveAsDefaultMenuItem(false),
3703 m_bEmptyMenuItem(false),
3704 m_bWindowsMenuItem(false),
3705 m_bTabCapture(false),
3706 m_bTabDrag(false)
3707 {
3708 m_ptStartDrag.x = 0;
3709 m_ptStartDrag.y = 0;
3710 }
3711
3712 ~CTabViewImpl()
3713 {
3714 delete [] m_lpstrTitleBarBase;
3715 }
3716
3717 // Message filter function - to be called from PreTranslateMessage of the main window
3718 BOOL PreTranslateMessage(MSG* pMsg)
3719 {
3720 if(IsWindow() == FALSE)
3721 return FALSE;
3722
3723 BOOL bRet = FALSE;
3724
3725 // Check for TabView built-in accelerators (Ctrl+Tab/Ctrl+Shift+Tab - next/previous page)
3726 int nCount = GetPageCount();
3727 if(nCount > 0)
3728 {
3729 bool bControl = (::GetKeyState(VK_CONTROL) < 0);
3730 if((pMsg->message == WM_KEYDOWN) && (pMsg->wParam == VK_TAB) && bControl)
3731 {
3732 if(nCount > 1)
3733 {
3734 int nPage = m_nActivePage;
3735 bool bShift = (::GetKeyState(VK_SHIFT) < 0);
3736 if(bShift)
3737 nPage = (nPage > 0) ? (nPage - 1) : (nCount - 1);
3738 else
3739 nPage = ((nPage >= 0) && (nPage < (nCount - 1))) ? (nPage + 1) : 0;
3740
3741 SetActivePage(nPage);
3742 T* pT = static_cast<T*>(this);
3743 pT->OnPageActivated(m_nActivePage);
3744 }
3745
3746 bRet = TRUE;
3747 }
3748 }
3749
3750 // If we are doing drag-drop, check for Escape key that cancels it
3751 if(bRet == FALSE)
3752 {
3753 if(m_bTabCapture && pMsg->message == WM_KEYDOWN && pMsg->wParam == VK_ESCAPE)
3754 {
3755 ::ReleaseCapture();
3756 bRet = TRUE;
3757 }
3758 }
3759
3760 // Pass the message to the active page
3761 if(bRet == FALSE)
3762 {
3763 if(m_nActivePage != -1)
3764 bRet = (BOOL)::SendMessage(GetPageHWND(m_nActivePage), WM_FORWARDMSG, 0, (LPARAM)pMsg);
3765 }
3766
3767 return bRet;
3768 }
3769
3770 // Attributes
3771 int GetPageCount() const
3772 {
3773 ATLASSERT(::IsWindow(m_hWnd));
3774 return m_tab.GetItemCount();
3775 }
3776
3777 int GetActivePage() const
3778 {
3779 return m_nActivePage;
3780 }
3781
3782 void SetActivePage(int nPage)
3783 {
3784 ATLASSERT(::IsWindow(m_hWnd));
3785 ATLASSERT(IsValidPageIndex(nPage));
3786
3787 T* pT = static_cast<T*>(this);
3788
3789 SetRedraw(FALSE);
3790
3791 if(m_nActivePage != -1)
3792 ::ShowWindow(GetPageHWND(m_nActivePage), FALSE);
3793 m_nActivePage = nPage;
3794 m_tab.SetCurSel(m_nActivePage);
3795 ::ShowWindow(GetPageHWND(m_nActivePage), TRUE);
3796
3797 pT->UpdateLayout();
3798
3799 SetRedraw(TRUE);
3800 RedrawWindow(NULL, NULL, RDW_FRAME | RDW_INVALIDATE | RDW_UPDATENOW | RDW_ALLCHILDREN);
3801
3802 if(::GetFocus() != m_tab.m_hWnd)
3803 ::SetFocus(GetPageHWND(m_nActivePage));
3804
3805 pT->UpdateTitleBar();
3806 pT->UpdateMenu();
3807 }
3808
3809 HIMAGELIST GetImageList() const
3810 {
3811 ATLASSERT(::IsWindow(m_hWnd));
3812 return m_tab.GetImageList();
3813 }
3814
3815 HIMAGELIST SetImageList(HIMAGELIST hImageList)
3816 {
3817 ATLASSERT(::IsWindow(m_hWnd));
3818 return m_tab.SetImageList(hImageList);
3819 }
3820
3821 void SetWindowMenu(HMENU hMenu)
3822 {
3823 ATLASSERT(::IsWindow(m_hWnd));
3824
3825 m_menu = hMenu;
3826
3827 T* pT = static_cast<T*>(this);
3828 pT->UpdateMenu();
3829 }
3830
3831 void SetTitleBarWindow(HWND hWnd)
3832 {
3833 ATLASSERT(::IsWindow(m_hWnd));
3834
3835 delete [] m_lpstrTitleBarBase;
3836 m_lpstrTitleBarBase = NULL;
3837
3838 m_wndTitleBar = hWnd;
3839 if(hWnd == NULL)
3840 return;
3841
3842 int cchLen = m_wndTitleBar.GetWindowTextLength() + 1;
3843 ATLTRY(m_lpstrTitleBarBase = new TCHAR[cchLen]);
3844 if(m_lpstrTitleBarBase != NULL)
3845 {
3846 m_wndTitleBar.GetWindowText(m_lpstrTitleBarBase, cchLen);
3847 T* pT = static_cast<T*>(this);
3848 pT->UpdateTitleBar();
3849 }
3850 }
3851
3852 // Page attributes
3853 HWND GetPageHWND(int nPage) const
3854 {
3855 ATLASSERT(::IsWindow(m_hWnd));
3856 ATLASSERT(IsValidPageIndex(nPage));
3857
3858 TCITEMEXTRA tcix = { 0 };
3859 tcix.tciheader.mask = TCIF_PARAM;
3860 m_tab.GetItem(nPage, tcix);
3861
3862 return tcix.tvpage.hWnd;
3863 }
3864
3865 LPCTSTR GetPageTitle(int nPage) const
3866 {
3867 ATLASSERT(::IsWindow(m_hWnd));
3868 ATLASSERT(IsValidPageIndex(nPage));
3869
3870 TCITEMEXTRA tcix = { 0 };
3871 tcix.tciheader.mask = TCIF_PARAM;
3872 if(m_tab.GetItem(nPage, tcix) == FALSE)
3873 return NULL;
3874
3875 return tcix.tvpage.lpstrTitle;
3876 }
3877
3878 bool SetPageTitle(int nPage, LPCTSTR lpstrTitle)
3879 {
3880 ATLASSERT(::IsWindow(m_hWnd));
3881 ATLASSERT(IsValidPageIndex(nPage));
3882
3883 T* pT = static_cast<T*>(this);
3884
3885 int cchBuff = lstrlen(lpstrTitle) + 1;
3886 LPTSTR lpstrBuff = NULL;
3887 ATLTRY(lpstrBuff = new TCHAR[cchBuff]);
3888 if(lpstrBuff == NULL)
3889 return false;
3890
3891 SecureHelper::strcpy_x(lpstrBuff, cchBuff, lpstrTitle);
3892 TCITEMEXTRA tcix = { 0 };
3893 tcix.tciheader.mask = TCIF_PARAM;
3894 if(m_tab.GetItem(nPage, tcix) == FALSE)
3895 return false;
3896
3897 CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
3898 LPTSTR lpstrTabText = buff.Allocate(m_cchTabTextLength + 1);
3899 if(lpstrTabText == NULL)
3900 return false;
3901
3902 delete [] tcix.tvpage.lpstrTitle;
3903
3904 pT->ShortenTitle(lpstrTitle, lpstrTabText, m_cchTabTextLength + 1);
3905
3906 tcix.tciheader.mask = TCIF_TEXT | TCIF_PARAM;
3907 tcix.tciheader.pszText = lpstrTabText;
3908 tcix.tvpage.lpstrTitle = lpstrBuff;
3909 if(m_tab.SetItem(nPage, tcix) == FALSE)
3910 return false;
3911
3912 pT->UpdateTitleBar();
3913 pT->UpdateMenu();
3914
3915 return true;
3916 }
3917
3918 LPVOID GetPageData(int nPage) const
3919 {
3920 ATLASSERT(::IsWindow(m_hWnd));
3921 ATLASSERT(IsValidPageIndex(nPage));
3922
3923 TCITEMEXTRA tcix = { 0 };
3924 tcix.tciheader.mask = TCIF_PARAM;
3925 m_tab.GetItem(nPage, tcix);
3926
3927 return tcix.tvpage.pData;
3928 }
3929
3930 LPVOID SetPageData(int nPage, LPVOID pData)
3931 {
3932 ATLASSERT(::IsWindow(m_hWnd));
3933 ATLASSERT(IsValidPageIndex(nPage));
3934
3935 TCITEMEXTRA tcix = { 0 };
3936 tcix.tciheader.mask = TCIF_PARAM;
3937 m_tab.GetItem(nPage, tcix);
3938 LPVOID pDataOld = tcix.tvpage.pData;
3939
3940 tcix.tvpage.pData = pData;
3941 m_tab.SetItem(nPage, tcix);
3942
3943 return pDataOld;
3944 }
3945
3946 int GetPageImage(int nPage) const
3947 {
3948 ATLASSERT(::IsWindow(m_hWnd));
3949 ATLASSERT(IsValidPageIndex(nPage));
3950
3951 TCITEMEXTRA tcix = { 0 };
3952 tcix.tciheader.mask = TCIF_IMAGE;
3953 m_tab.GetItem(nPage, tcix);
3954
3955 return tcix.tciheader.iImage;
3956 }
3957
3958 int SetPageImage(int nPage, int nImage)
3959 {
3960 ATLASSERT(::IsWindow(m_hWnd));
3961 ATLASSERT(IsValidPageIndex(nPage));
3962
3963 TCITEMEXTRA tcix = { 0 };
3964 tcix.tciheader.mask = TCIF_IMAGE;
3965 m_tab.GetItem(nPage, tcix);
3966 int nImageOld = tcix.tciheader.iImage;
3967
3968 tcix.tciheader.iImage = nImage;
3969 m_tab.SetItem(nPage, tcix);
3970
3971 return nImageOld;
3972 }
3973
3974 // Operations
3975 bool AddPage(HWND hWndView, LPCTSTR lpstrTitle, int nImage = -1, LPVOID pData = NULL)
3976 {
3977 return InsertPage(GetPageCount(), hWndView, lpstrTitle, nImage, pData);
3978 }
3979
3980 bool InsertPage(int nPage, HWND hWndView, LPCTSTR lpstrTitle, int nImage = -1, LPVOID pData = NULL)
3981 {
3982 ATLASSERT(::IsWindow(m_hWnd));
3983 ATLASSERT(nPage == GetPageCount() || IsValidPageIndex(nPage));
3984
3985 T* pT = static_cast<T*>(this);
3986
3987 int cchBuff = lstrlen(lpstrTitle) + 1;
3988 LPTSTR lpstrBuff = NULL;
3989 ATLTRY(lpstrBuff = new TCHAR[cchBuff]);
3990 if(lpstrBuff == NULL)
3991 return false;
3992
3993 SecureHelper::strcpy_x(lpstrBuff, cchBuff, lpstrTitle);
3994
3995 CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
3996 LPTSTR lpstrTabText = buff.Allocate(m_cchTabTextLength + 1);
3997 if(lpstrTabText == NULL)
3998 return false;
3999
4000 pT->ShortenTitle(lpstrTitle, lpstrTabText, m_cchTabTextLength + 1);
4001
4002 SetRedraw(FALSE);
4003
4004 TCITEMEXTRA tcix = { 0 };
4005 tcix.tciheader.mask = TCIF_TEXT | TCIF_IMAGE | TCIF_PARAM;
4006 tcix.tciheader.pszText = lpstrTabText;
4007 tcix.tciheader.iImage = nImage;
4008 tcix.tvpage.hWnd = hWndView;
4009 tcix.tvpage.lpstrTitle = lpstrBuff;
4010 tcix.tvpage.pData = pData;
4011 int nItem = m_tab.InsertItem(nPage, tcix);
4012 if(nItem == -1)
4013 {
4014 delete [] lpstrBuff;
4015 SetRedraw(TRUE);
4016 return false;
4017 }
4018
4019 SetActivePage(nItem);
4020 pT->OnPageActivated(m_nActivePage);
4021
4022 if(GetPageCount() == 1)
4023 pT->ShowTabControl(true);
4024
4025 pT->UpdateLayout();
4026
4027 SetRedraw(TRUE);
4028 RedrawWindow(NULL, NULL, RDW_FRAME | RDW_INVALIDATE | RDW_UPDATENOW | RDW_ALLCHILDREN);
4029
4030 return true;
4031 }
4032
4033 void RemovePage(int nPage)
4034 {
4035 ATLASSERT(::IsWindow(m_hWnd));
4036 ATLASSERT(IsValidPageIndex(nPage));
4037
4038 T* pT = static_cast<T*>(this);
4039
4040 SetRedraw(FALSE);
4041
4042 if(GetPageCount() == 1)
4043 pT->ShowTabControl(false);
4044
4045 if(m_bDestroyPageOnRemove)
4046 ::DestroyWindow(GetPageHWND(nPage));
4047 else
4048 ::ShowWindow(GetPageHWND(nPage), FALSE);
4049 LPTSTR lpstrTitle = (LPTSTR)GetPageTitle(nPage);
4050 delete [] lpstrTitle;
4051
4052 ATLVERIFY(m_tab.DeleteItem(nPage) != FALSE);
4053
4054 if(m_nActivePage == nPage)
4055 {
4056 m_nActivePage = -1;
4057
4058 if(nPage > 0)
4059 {
4060 SetActivePage(nPage - 1);
4061 }
4062 else if(GetPageCount() > 0)
4063 {
4064 SetActivePage(nPage);
4065 }
4066 else
4067 {
4068 SetRedraw(TRUE);
4069 Invalidate();
4070 UpdateWindow();
4071 pT->UpdateTitleBar();
4072 pT->UpdateMenu();
4073 }
4074 }
4075 else
4076 {
4077 nPage = (nPage < m_nActivePage) ? (m_nActivePage - 1) : m_nActivePage;
4078 m_nActivePage = -1;
4079 SetActivePage(nPage);
4080 }
4081
4082 pT->OnPageActivated(m_nActivePage);
4083 }
4084
4085 void RemoveAllPages()
4086 {
4087 ATLASSERT(::IsWindow(m_hWnd));
4088
4089 if(GetPageCount() == 0)
4090 return;
4091
4092 T* pT = static_cast<T*>(this);
4093
4094 SetRedraw(FALSE);
4095
4096 pT->ShowTabControl(false);
4097
4098 for(int i = 0; i < GetPageCount(); i++)
4099 {
4100 if(m_bDestroyPageOnRemove)
4101 ::DestroyWindow(GetPageHWND(i));
4102 else
4103 ::ShowWindow(GetPageHWND(i), FALSE);
4104 LPTSTR lpstrTitle = (LPTSTR)GetPageTitle(i);
4105 delete [] lpstrTitle;
4106 }
4107 m_tab.DeleteAllItems();
4108
4109 m_nActivePage = -1;
4110 pT->OnPageActivated(m_nActivePage);
4111
4112 SetRedraw(TRUE);
4113 Invalidate();
4114 UpdateWindow();
4115
4116 pT->UpdateTitleBar();
4117 pT->UpdateMenu();
4118 }
4119
4120 int PageIndexFromHwnd(HWND hWnd) const
4121 {
4122 int nIndex = -1;
4123
4124 for(int i = 0; i < GetPageCount(); i++)
4125 {
4126 if(GetPageHWND(i) == hWnd)
4127 {
4128 nIndex = i;
4129 break;
4130 }
4131 }
4132
4133 return nIndex;
4134 }
4135
4136 void BuildWindowMenu(HMENU hMenu, int nMenuItemsCount = 10, bool bEmptyMenuItem = true, bool bWindowsMenuItem = true, bool bActivePageMenuItem = true, bool bActiveAsDefaultMenuItem = false)
4137 {
4138 ATLASSERT(::IsWindow(m_hWnd));
4139
4140 CMenuHandle menu = hMenu;
4141 T* pT = static_cast<T*>(this);
4142 pT; // avoid level 4 warning
4143 int nFirstPos = 0;
4144
4145 // Find first menu item in our range
4146 #ifndef _WIN32_WCE
4147 for(nFirstPos = 0; nFirstPos < menu.GetMenuItemCount(); nFirstPos++)
4148 {
4149 UINT nID = menu.GetMenuItemID(nFirstPos);
4150 if((nID >= ID_WINDOW_TABFIRST && nID <= ID_WINDOW_TABLAST) || nID == ID_WINDOW_SHOWTABLIST)
4151 break;
4152 }
4153 #else // CE specific
4154 for(nFirstPos = 0; ; nFirstPos++)
4155 {
4156 CMenuItemInfo mii;
4157 mii.fMask = MIIM_ID;
4158 BOOL bRet = menu.GetMenuItemInfo(nFirstPos, TRUE, &mii);
4159 if(bRet == FALSE)
4160 break;
4161 if((mii.wID >= ID_WINDOW_TABFIRST && mii.wID <= ID_WINDOW_TABLAST) || mii.wID == ID_WINDOW_SHOWTABLIST)
4162 break;
4163 }
4164 #endif // _WIN32_WCE
4165
4166 // Remove all menu items for tab pages
4167 BOOL bRet = TRUE;
4168 while(bRet != FALSE)
4169 bRet = menu.DeleteMenu(nFirstPos, MF_BYPOSITION);
4170
4171 // Add separator if it's not already there
4172 int nPageCount = GetPageCount();
4173 if((bWindowsMenuItem || (nPageCount > 0)) && (nFirstPos > 0))
4174 {
4175 CMenuItemInfo mii;
4176 mii.fMask = MIIM_TYPE;
4177 menu.GetMenuItemInfo(nFirstPos - 1, TRUE, &mii);
4178 if((nFirstPos <= 0) || ((mii.fType & MFT_SEPARATOR) == 0))
4179 {
4180 menu.AppendMenu(MF_SEPARATOR);
4181 nFirstPos++;
4182 }
4183 }
4184
4185 // Add menu items for all pages
4186 if(nPageCount > 0)
4187 {
4188 // Append menu items for all pages
4189 const int cchPrefix = 3; // 2 digits + space
4190 nMenuItemsCount = __min(min(nPageCount, nMenuItemsCount), (int)m_nMenuItemsMax);
4191 ATLASSERT(nMenuItemsCount < 100); // 2 digits only
4192 if(nMenuItemsCount >= 100)
4193 nMenuItemsCount = 99;
4194
4195 for(int i = 0; i < nMenuItemsCount; i++)
4196 {
4197 LPCTSTR lpstrTitle = GetPageTitle(i);
4198 int nLen = lstrlen(lpstrTitle);
4199 CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
4200 LPTSTR lpstrText = buff.Allocate(cchPrefix + nLen + 1);
4201 ATLASSERT(lpstrText != NULL);
4202 if(lpstrText != NULL)
4203 {
4204 LPCTSTR lpstrFormat = (i < 9) ? _T("&%i %s") : _T("%i %s");
4205 SecureHelper::wsprintf_x(lpstrText, cchPrefix + nLen + 1, lpstrFormat, i + 1, lpstrTitle);
4206 menu.AppendMenu(MF_STRING, ID_WINDOW_TABFIRST + i, lpstrText);
4207 }
4208 }
4209
4210 // Mark active page
4211 if(bActivePageMenuItem && (m_nActivePage != -1))
4212 {
4213 #ifndef _WIN32_WCE
4214 if(bActiveAsDefaultMenuItem)
4215 {
4216 menu.SetMenuDefaultItem((UINT)-1, TRUE);
4217 menu.SetMenuDefaultItem(nFirstPos + m_nActivePage, TRUE);
4218 }
4219 else
4220 #else // CE specific
4221 bActiveAsDefaultMenuItem; // avoid level 4 warning
4222 #endif // _WIN32_WCE
4223 {
4224 menu.CheckMenuRadioItem(nFirstPos, nFirstPos + nMenuItemsCount, nFirstPos + m_nActivePage, MF_BYPOSITION);
4225 }
4226 }
4227 }
4228 else
4229 {
4230 if(bEmptyMenuItem)
4231 {
4232 menu.AppendMenu(MF_BYPOSITION | MF_STRING, ID_WINDOW_TABFIRST, pT->GetEmptyListText());
4233 menu.EnableMenuItem(ID_WINDOW_TABFIRST, MF_GRAYED);
4234 }
4235
4236 // Remove separator if nothing else is there
4237 if(!bEmptyMenuItem && !bWindowsMenuItem && (nFirstPos > 0))
4238 {
4239 CMenuItemInfo mii;
4240 mii.fMask = MIIM_TYPE;
4241 menu.GetMenuItemInfo(nFirstPos - 1, TRUE, &mii);
4242 if((mii.fType & MFT_SEPARATOR) != 0)
4243 menu.DeleteMenu(nFirstPos - 1, MF_BYPOSITION);
4244 }
4245 }
4246
4247 // Add "Windows..." menu item
4248 if(bWindowsMenuItem)
4249 menu.AppendMenu(MF_BYPOSITION | MF_STRING, ID_WINDOW_SHOWTABLIST, pT->GetWindowsMenuItemText());
4250 }
4251
4252 // Message map and handlers
4253 BEGIN_MSG_MAP(CTabViewImpl)
4254 MESSAGE_HANDLER(WM_CREATE, OnCreate)
4255 MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
4256 MESSAGE_HANDLER(WM_SIZE, OnSize)
4257 MESSAGE_HANDLER(WM_SETFOCUS, OnSetFocus)
4258 NOTIFY_HANDLER(m_nTabID, TCN_SELCHANGE, OnTabChanged)
4259 NOTIFY_ID_HANDLER(m_nTabID, OnTabNotification)
4260 #ifndef _WIN32_WCE
4261 NOTIFY_CODE_HANDLER(TTN_GETDISPINFO, OnTabGetDispInfo)
4262 #endif // !_WIN32_WCE
4263 FORWARD_NOTIFICATIONS()
4264 ALT_MSG_MAP(1) // tab control
4265 MESSAGE_HANDLER(WM_LBUTTONDOWN, OnTabLButtonDown)
4266 MESSAGE_HANDLER(WM_LBUTTONUP, OnTabLButtonUp)
4267 MESSAGE_HANDLER(WM_CAPTURECHANGED, OnTabCaptureChanged)
4268 MESSAGE_HANDLER(WM_MOUSEMOVE, OnTabMouseMove)
4269 MESSAGE_HANDLER(WM_RBUTTONUP, OnTabRButtonUp)
4270 MESSAGE_HANDLER(WM_SYSKEYDOWN, OnTabSysKeyDown)
4271 END_MSG_MAP()
4272
4273 LRESULT OnCreate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
4274 {
4275 T* pT = static_cast<T*>(this);
4276 pT->CreateTabControl();
4277
4278 return 0;
4279 }
4280
4281 LRESULT OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
4282 {
4283 RemoveAllPages();
4284
4285 if(m_bDestroyImageList)
4286 {
4287 CImageList il = m_tab.SetImageList(NULL);
4288 if(il.m_hImageList != NULL)
4289 il.Destroy();
4290 }
4291
4292 return 0;
4293 }
4294
4295 LRESULT OnSize(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
4296 {
4297 T* pT = static_cast<T*>(this);
4298 pT->UpdateLayout();
4299 return 0;
4300 }
4301
4302 LRESULT OnSetFocus(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
4303 {
4304 if(m_nActivePage != -1)
4305 ::SetFocus(GetPageHWND(m_nActivePage));
4306 return 0;
4307 }
4308
4309 LRESULT OnTabChanged(int /*idCtrl*/, LPNMHDR /*pnmh*/, BOOL& /*bHandled*/)
4310 {
4311 SetActivePage(m_tab.GetCurSel());
4312 T* pT = static_cast<T*>(this);
4313 pT->OnPageActivated(m_nActivePage);
4314
4315 return 0;
4316 }
4317
4318 LRESULT OnTabNotification(int /*idCtrl*/, LPNMHDR /*pnmh*/, BOOL& /*bHandled*/)
4319 {
4320 // nothing to do - this just blocks all tab control
4321 // notifications from being propagated further
4322 return 0;
4323 }
4324
4325 #ifndef _WIN32_WCE
4326 LRESULT OnTabGetDispInfo(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled)
4327 {
4328 LPNMTTDISPINFO pTTDI = (LPNMTTDISPINFO)pnmh;
4329 if(pTTDI->hdr.hwndFrom == m_tab.GetTooltips())
4330 {
4331 T* pT = static_cast<T*>(this);
4332 pT->UpdateTooltipText(pTTDI);
4333 }
4334 else
4335 {
4336 bHandled = FALSE;
4337 }
4338
4339 return 0;
4340 }
4341 #endif // !_WIN32_WCE
4342
4343 // Tab control message handlers
4344 LRESULT OnTabLButtonDown(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
4345 {
4346 if(m_tab.GetItemCount() > 1)
4347 {
4348 m_bTabCapture = true;
4349 m_tab.SetCapture();
4350
4351 m_ptStartDrag.x = GET_X_LPARAM(lParam);
4352 m_ptStartDrag.y = GET_Y_LPARAM(lParam);
4353 }
4354
4355 bHandled = FALSE;
4356 return 0;
4357 }
4358
4359 LRESULT OnTabLButtonUp(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
4360 {
4361 if(m_bTabCapture)
4362 {
4363 if(m_bTabDrag)
4364 {
4365 TCHITTESTINFO hti = { 0 };
4366 hti.pt.x = GET_X_LPARAM(lParam);
4367 hti.pt.y = GET_Y_LPARAM(lParam);
4368 int nItem = m_tab.HitTest(&hti);
4369 if(nItem != -1)
4370 MovePage(m_nActivePage, nItem);
4371 }
4372
4373 ::ReleaseCapture();
4374 }
4375
4376 bHandled = FALSE;
4377 return 0;
4378 }
4379
4380 LRESULT OnTabCaptureChanged(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
4381 {
4382 if(m_bTabCapture)
4383 {
4384 m_bTabCapture = false;
4385
4386 if(m_bTabDrag)
4387 {
4388 m_bTabDrag = false;
4389 T* pT = static_cast<T*>(this);
4390 pT->DrawMoveMark(-1);
4391
4392 #ifndef _WIN32_WCE
4393 m_ilDrag.DragLeave(GetDesktopWindow());
4394 #endif // !_WIN32_WCE
4395 m_ilDrag.EndDrag();
4396
4397 m_ilDrag.Destroy();
4398 m_ilDrag.m_hImageList = NULL;
4399 }
4400 }
4401
4402 bHandled = FALSE;
4403 return 0;
4404 }
4405
4406 LRESULT OnTabMouseMove(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
4407 {
4408 bHandled = FALSE;
4409
4410 if(m_bTabCapture)
4411 {
4412 POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
4413
4414 if(!m_bTabDrag)
4415 {
4416 #ifndef _WIN32_WCE
4417 if(abs(m_ptStartDrag.x - GET_X_LPARAM(lParam)) >= ::GetSystemMetrics(SM_CXDRAG) ||
4418 abs(m_ptStartDrag.y - GET_Y_LPARAM(lParam)) >= ::GetSystemMetrics(SM_CYDRAG))
4419 #else // CE specific
4420 if(abs(m_ptStartDrag.x - GET_X_LPARAM(lParam)) >= 4 ||
4421 abs(m_ptStartDrag.y - GET_Y_LPARAM(lParam)) >= 4)
4422 #endif // _WIN32_WCE
4423 {
4424 T* pT = static_cast<T*>(this);
4425 pT->GenerateDragImage(m_nActivePage);
4426
4427 int cxCursor = ::GetSystemMetrics(SM_CXCURSOR);
4428 int cyCursor = ::GetSystemMetrics(SM_CYCURSOR);
4429 m_ilDrag.BeginDrag(0, -(cxCursor / 2), -(cyCursor / 2));
4430 #ifndef _WIN32_WCE
4431 POINT ptEnter = m_ptStartDrag;
4432 m_tab.ClientToScreen(&ptEnter);
4433 m_ilDrag.DragEnter(GetDesktopWindow(), ptEnter);
4434 #endif // !_WIN32_WCE
4435
4436 m_bTabDrag = true;
4437 }
4438 }
4439
4440 if(m_bTabDrag)
4441 {
4442 TCHITTESTINFO hti = { 0 };
4443 hti.pt = pt;
4444 int nItem = m_tab.HitTest(&hti);
4445
4446 T* pT = static_cast<T*>(this);
4447 pT->SetMoveCursor(nItem != -1);
4448
4449 if(m_nInsertItem != nItem)
4450 pT->DrawMoveMark(nItem);
4451
4452 m_ilDrag.DragShowNolock((nItem != -1) ? TRUE : FALSE);
4453 m_tab.ClientToScreen(&pt);
4454 m_ilDrag.DragMove(pt);
4455
4456 bHandled = TRUE;
4457 }
4458 }
4459
4460 return 0;
4461 }
4462
4463 LRESULT OnTabRButtonUp(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/)
4464 {
4465 TCHITTESTINFO hti = { 0 };
4466 hti.pt.x = GET_X_LPARAM(lParam);
4467 hti.pt.y = GET_Y_LPARAM(lParam);
4468 int nItem = m_tab.HitTest(&hti);
4469 if(nItem != -1)
4470 {
4471 T* pT = static_cast<T*>(this);
4472 pT->OnContextMenu(nItem, hti.pt);
4473 }
4474
4475 return 0;
4476 }
4477
4478 LRESULT OnTabSysKeyDown(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
4479 {
4480 bool bShift = (::GetKeyState(VK_SHIFT) < 0);
4481 if(wParam == VK_F10 && bShift)
4482 {
4483 if(m_nActivePage != -1)
4484 {
4485 RECT rect = { 0 };
4486 m_tab.GetItemRect(m_nActivePage, &rect);
4487 POINT pt = { rect.left, rect.bottom };
4488 T* pT = static_cast<T*>(this);
4489 pT->OnContextMenu(m_nActivePage, pt);
4490 }
4491 }
4492 else
4493 {
4494 bHandled = FALSE;
4495 }
4496
4497 return 0;
4498 }
4499
4500 // Implementation helpers
4501 bool IsValidPageIndex(int nPage) const
4502 {
4503 return (nPage >= 0 && nPage < GetPageCount());
4504 }
4505
4506 bool MovePage(int nMovePage, int nInsertBeforePage)
4507 {
4508 ATLASSERT(IsValidPageIndex(nMovePage));
4509 ATLASSERT(IsValidPageIndex(nInsertBeforePage));
4510
4511 if(!IsValidPageIndex(nMovePage) || !IsValidPageIndex(nInsertBeforePage))
4512 return false;
4513
4514 if(nMovePage == nInsertBeforePage)
4515 return true; // nothing to do
4516
4517 CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
4518 LPTSTR lpstrTabText = buff.Allocate(m_cchTabTextLength + 1);
4519 if(lpstrTabText == NULL)
4520 return false;
4521 TCITEMEXTRA tcix = { 0 };
4522 tcix.tciheader.mask = TCIF_TEXT | TCIF_IMAGE | TCIF_PARAM;
4523 tcix.tciheader.pszText = lpstrTabText;
4524 tcix.tciheader.cchTextMax = m_cchTabTextLength + 1;
4525 BOOL bRet = m_tab.GetItem(nMovePage, tcix);
4526 ATLASSERT(bRet != FALSE);
4527 if(bRet == FALSE)
4528 return false;
4529
4530 int nInsertItem = (nInsertBeforePage > nMovePage) ? nInsertBeforePage + 1 : nInsertBeforePage;
4531 int nNewItem = m_tab.InsertItem(nInsertItem, tcix);
4532 ATLASSERT(nNewItem == nInsertItem);
4533 if(nNewItem != nInsertItem)
4534 {
4535 ATLVERIFY(m_tab.DeleteItem(nNewItem));
4536 return false;
4537 }
4538
4539 if(nMovePage > nInsertBeforePage)
4540 ATLVERIFY(m_tab.DeleteItem(nMovePage + 1) != FALSE);
4541 else if(nMovePage < nInsertBeforePage)
4542 ATLVERIFY(m_tab.DeleteItem(nMovePage) != FALSE);
4543
4544 SetActivePage(nInsertBeforePage);
4545 T* pT = static_cast<T*>(this);
4546 pT->OnPageActivated(m_nActivePage);
4547
4548 return true;
4549 }
4550
4551 // Implementation overrideables
4552 bool CreateTabControl()
4553 {
4554 #ifndef _WIN32_WCE
4555 m_tab.Create(m_hWnd, rcDefault, NULL, WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TCS_TOOLTIPS, 0, m_nTabID);
4556 #else // CE specific
4557 m_tab.Create(m_hWnd, rcDefault, NULL, WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, 0, m_nTabID);
4558 #endif // _WIN32_WCE
4559 ATLASSERT(m_tab.m_hWnd != NULL);
4560 if(m_tab.m_hWnd == NULL)
4561 return false;
4562
4563 m_tab.SetFont(AtlGetDefaultGuiFont());
4564
4565 m_tab.SetItemExtra(sizeof(TABVIEWPAGE));
4566
4567 T* pT = static_cast<T*>(this);
4568 m_cyTabHeight = pT->CalcTabHeight();
4569
4570 return true;
4571 }
4572
4573 int CalcTabHeight()
4574 {
4575 int nCount = m_tab.GetItemCount();
4576 TCITEMEXTRA tcix = { 0 };
4577 tcix.tciheader.mask = TCIF_TEXT;
4578 tcix.tciheader.pszText = _T("NS");
4579 int nIndex = m_tab.InsertItem(nCount, tcix);
4580
4581 RECT rect = { 0, 0, 1000, 1000 };
4582 m_tab.AdjustRect(FALSE, &rect);
4583
4584 RECT rcWnd = { 0, 0, 1000, rect.top };
4585 ::AdjustWindowRectEx(&rcWnd, m_tab.GetStyle(), FALSE, m_tab.GetExStyle());
4586
4587 int nHeight = rcWnd.bottom - rcWnd.top;
4588
4589 m_tab.DeleteItem(nIndex);
4590
4591 return nHeight;
4592 }
4593
4594 void ShowTabControl(bool bShow)
4595 {
4596 m_tab.ShowWindow(bShow ? SW_SHOWNOACTIVATE : SW_HIDE);
4597 }
4598
4599 void UpdateLayout()
4600 {
4601 RECT rect;
4602 GetClientRect(&rect);
4603
4604 if(m_tab.IsWindow() && ((m_tab.GetStyle() & WS_VISIBLE) != 0))
4605 m_tab.SetWindowPos(NULL, 0, 0, rect.right - rect.left, m_cyTabHeight, SWP_NOZORDER);
4606
4607 if(m_nActivePage != -1)
4608 ::SetWindowPos(GetPageHWND(m_nActivePage), NULL, 0, m_cyTabHeight, rect.right - rect.left, rect.bottom - rect.top - m_cyTabHeight, SWP_NOZORDER);
4609 }
4610
4611 void UpdateMenu()
4612 {
4613 if(m_menu.m_hMenu != NULL)
4614 BuildWindowMenu(m_menu, m_nMenuItemsCount, m_bEmptyMenuItem, m_bWindowsMenuItem, m_bActivePageMenuItem, m_bActiveAsDefaultMenuItem);
4615 }
4616
4617 void UpdateTitleBar()
4618 {
4619 if(!m_wndTitleBar.IsWindow() || m_lpstrTitleBarBase == NULL)
4620 return; // nothing to do
4621
4622 if(m_nActivePage != -1)
4623 {
4624 T* pT = static_cast<T*>(this);
4625 LPCTSTR lpstrTitle = pT->GetPageTitle(m_nActivePage);
4626 LPCTSTR lpstrDivider = pT->GetTitleDividerText();
4627 int cchBuffer = m_cchTitleBarLength + lstrlen(lpstrDivider) + lstrlen(m_lpstrTitleBarBase) + 1;
4628 CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
4629 LPTSTR lpstrPageTitle = buff.Allocate(cchBuffer);
4630 ATLASSERT(lpstrPageTitle != NULL);
4631 if(lpstrPageTitle != NULL)
4632 {
4633 pT->ShortenTitle(lpstrTitle, lpstrPageTitle, m_cchTitleBarLength + 1);
4634 SecureHelper::strcat_x(lpstrPageTitle, cchBuffer, lpstrDivider);
4635 SecureHelper::strcat_x(lpstrPageTitle, cchBuffer, m_lpstrTitleBarBase);
4636 }
4637 else
4638 {
4639 lpstrPageTitle = m_lpstrTitleBarBase;
4640 }
4641
4642 m_wndTitleBar.SetWindowText(lpstrPageTitle);
4643 }
4644 else
4645 {
4646 m_wndTitleBar.SetWindowText(m_lpstrTitleBarBase);
4647 }
4648 }
4649
4650 void DrawMoveMark(int nItem)
4651 {
4652 T* pT = static_cast<T*>(this);
4653
4654 if(m_nInsertItem != -1)
4655 {
4656 RECT rect = { 0 };
4657 pT->GetMoveMarkRect(rect);
4658 m_tab.InvalidateRect(&rect);
4659 }
4660
4661 m_nInsertItem = nItem;
4662
4663 if(m_nInsertItem != -1)
4664 {
4665 CClientDC dc(m_tab.m_hWnd);
4666
4667 RECT rect = { 0 };
4668 pT->GetMoveMarkRect(rect);
4669
4670 CPen pen;
4671 pen.CreatePen(PS_SOLID, 1, ::GetSysColor(COLOR_WINDOWTEXT));
4672 CBrush brush;
4673 brush.CreateSolidBrush(::GetSysColor(COLOR_WINDOWTEXT));
4674
4675 HPEN hPenOld = dc.SelectPen(pen);
4676 HBRUSH hBrushOld = dc.SelectBrush(brush);
4677
4678 int x = rect.left;
4679 int y = rect.top;
4680 POINT ptsTop[3] = { { x, y }, { x + m_cxMoveMark, y }, { x + (m_cxMoveMark / 2), y + m_cyMoveMark } };
4681 dc.Polygon(ptsTop, 3);
4682
4683 y = rect.bottom - 1;
4684 POINT ptsBottom[3] = { { x, y }, { x + m_cxMoveMark, y }, { x + (m_cxMoveMark / 2), y - m_cyMoveMark } };
4685 dc.Polygon(ptsBottom, 3);
4686
4687 dc.SelectPen(hPenOld);
4688 dc.SelectBrush(hBrushOld);
4689 }
4690 }
4691
4692 void GetMoveMarkRect(RECT& rect) const
4693 {
4694 m_tab.GetClientRect(&rect);
4695
4696 RECT rcItem = { 0 };
4697 m_tab.GetItemRect(m_nInsertItem, &rcItem);
4698
4699 if(m_nInsertItem <= m_nActivePage)
4700 {
4701 rect.left = rcItem.left - m_cxMoveMark / 2 - 1;
4702 rect.right = rcItem.left + m_cxMoveMark / 2;
4703 }
4704 else
4705 {
4706 rect.left = rcItem.right - m_cxMoveMark / 2 - 1;
4707 rect.right = rcItem.right + m_cxMoveMark / 2;
4708 }
4709 }
4710
4711 void SetMoveCursor(bool bCanMove)
4712 {
4713 ::SetCursor(::LoadCursor(NULL, bCanMove ? IDC_ARROW : IDC_NO));
4714 }
4715
4716 void GenerateDragImage(int nItem)
4717 {
4718 ATLASSERT(IsValidPageIndex(nItem));
4719
4720 #ifndef _WIN32_WCE
4721 RECT rcItem = { 0 };
4722 m_tab.GetItemRect(nItem, &rcItem);
4723 ::InflateRect(&rcItem, 2, 2); // make bigger to cover selected item
4724 #else // CE specific
4725 nItem; // avoid level 4 warning
4726 RECT rcItem = { 0, 0, 40, 20 };
4727 #endif // _WIN32_WCE
4728
4729 ATLASSERT(m_ilDrag.m_hImageList == NULL);
4730 m_ilDrag.Create(rcItem.right - rcItem.left, rcItem.bottom - rcItem.top, ILC_COLORDDB | ILC_MASK, 1, 1);
4731
4732 CClientDC dc(m_hWnd);
4733 CDC dcMem;
4734 dcMem.CreateCompatibleDC(dc);
4735 ATLASSERT(dcMem.m_hDC != NULL);
4736 dcMem.SetViewportOrg(-rcItem.left, -rcItem.top);
4737
4738 CBitmap bmp;
4739 bmp.CreateCompatibleBitmap(dc, rcItem.right - rcItem.left, rcItem.bottom - rcItem.top);
4740 ATLASSERT(bmp.m_hBitmap != NULL);
4741
4742 HBITMAP hBmpOld = dcMem.SelectBitmap(bmp);
4743 #ifndef _WIN32_WCE
4744 m_tab.SendMessage(WM_PRINTCLIENT, (WPARAM)dcMem.m_hDC);
4745 #else // CE specific
4746 dcMem.Rectangle(&rcItem);
4747 #endif // _WIN32_WCE
4748 dcMem.SelectBitmap(hBmpOld);
4749
4750 ATLVERIFY(m_ilDrag.Add(bmp.m_hBitmap, RGB(255, 0, 255)) != -1);
4751 }
4752
4753 void ShortenTitle(LPCTSTR lpstrTitle, LPTSTR lpstrShortTitle, int cchShortTitle)
4754 {
4755 if(lstrlen(lpstrTitle) >= cchShortTitle)
4756 {
4757 LPCTSTR lpstrEllipsis = _T("...");
4758 int cchEllipsis = lstrlen(lpstrEllipsis);
4759 SecureHelper::strncpy_x(lpstrShortTitle, cchShortTitle, lpstrTitle, cchShortTitle - cchEllipsis - 1);
4760 SecureHelper::strcat_x(lpstrShortTitle, cchShortTitle, lpstrEllipsis);
4761 }
4762 else
4763 {
4764 SecureHelper::strcpy_x(lpstrShortTitle, cchShortTitle, lpstrTitle);
4765 }
4766 }
4767
4768 #ifndef _WIN32_WCE
4769 void UpdateTooltipText(LPNMTTDISPINFO pTTDI)
4770 {
4771 ATLASSERT(pTTDI != NULL);
4772 pTTDI->lpszText = (LPTSTR)GetPageTitle((int)pTTDI->hdr.idFrom);
4773 }
4774 #endif // !_WIN32_WCE
4775
4776 // Text for menu items and title bar - override to provide different strings
4777 static LPCTSTR GetEmptyListText()
4778 {
4779 return _T("(Empty)");
4780 }
4781
4782 static LPCTSTR GetWindowsMenuItemText()
4783 {
4784 return _T("&Windows...");
4785 }
4786
4787 static LPCTSTR GetTitleDividerText()
4788 {
4789 return _T(" - ");
4790 }
4791
4792 // Notifications - override to provide different behavior
4793 void OnPageActivated(int nPage)
4794 {
4795 NMHDR nmhdr = { 0 };
4796 nmhdr.hwndFrom = m_hWnd;
4797 nmhdr.idFrom = nPage;
4798 nmhdr.code = TBVN_PAGEACTIVATED;
4799 ::SendMessage(GetParent(), WM_NOTIFY, GetDlgCtrlID(), (LPARAM)&nmhdr);
4800 }
4801
4802 void OnContextMenu(int nPage, POINT pt)
4803 {
4804 m_tab.ClientToScreen(&pt);
4805
4806 TBVCONTEXTMENUINFO cmi = { 0 };
4807 cmi.hdr.hwndFrom = m_hWnd;
4808 cmi.hdr.idFrom = nPage;
4809 cmi.hdr.code = TBVN_CONTEXTMENU;
4810 cmi.pt = pt;
4811 ::SendMessage(GetParent(), WM_NOTIFY, GetDlgCtrlID(), (LPARAM)&cmi);
4812 }
4813 };
4814
4815
4816 class CTabView : public CTabViewImpl<CTabView>
4817 {
4818 public:
4819 DECLARE_WND_CLASS_EX(_T("WTL_TabView"), 0, COLOR_APPWORKSPACE)
4820 };
4821
4822 }; // namespace WTL
4823
4824 #endif // __ATLCTRLX_H__