source: trunk/Utilities/DirectionControl/MainDialog.h @ 294

Last change on this file since 294 was 294, checked in by roman, 9 years ago
File size: 19.4 KB
Line 
1////////////////////////////////////////////////////////////
2// Copyright (C) Roman Ryltsov, 2013-2014
3// Created by Roman Ryltsov roman@alax.info
4//
5// A permission to use the source code is granted as long as reference to
6// source website http://alax.info is retained.
7
8#pragma once
9
10//#import "libid:B9EC374B-834B-4DA9-BFB5-C1872CE736FF" raw_interfaces_only // AlaxInfoDirectShowSpy
11#include "AboutDialog.h"
12#include "rocontrols.h"
13
14////////////////////////////////////////////////////////////
15// CControl
16
17template <typename T, typename _Base = CStatic, class _WinTraits = CControlWinTraits>
18class ATL_NO_VTABLE CControlT : 
19        public CControlWindowT<T, _Base, _WinTraits>
20{
21public:
22
23BEGIN_MSG_MAP_EX(CRoIconStaticT)
24        MSG_WM_CREATE(OnCreate)
25        MSG_WM_DESTROY(OnDestroy)
26        MSG_WM_ENABLE(OnEnable)
27        MSG_WM_SIZE(OnSize)
28        MSG_WM_ERASEBKGND(OnEraseBkgnd)
29        MSG_WM_PAINT(OnPaint)
30        MSG_WM_PRINTCLIENT(OnPrintClient)
31        MSG_WM_UPDATEUISTATE(OnUpdateUiState)
32        MSG_WM_SETCURSOR(OnSetCursor)
33        MSG_WM_MOUSEMOVE(OnMouseMove)
34        MSG_WM_LBUTTONDOWN(OnLButtonDown)
35        MSG_WM_LBUTTONUP(OnLButtonUp)
36        DEFAULT_REFLECTION_HANDLER()
37END_MSG_MAP()
38
39public:
40
41        ////////////////////////////////////////////////////////
42        // Conrol styles
43
44        enum
45        {
46                CS_NONE = 0,
47                CS_DEFAULT = CS_NONE,
48        };
49
50        ////////////////////////////////////////////////////////
51        // Notification codes
52
53        enum
54        {
55                NC_FIRST = 1024,
56                NC_CHANGING,
57                NC_CHANGED,
58        };
59
60private:
61        ULONG m_nExtendedStyle;
62        UINT m_nVersion;
63        DOUBLE m_fAngle;
64        DOUBLE m_fToleranceAngle;
65        CPoint m_CenterPosition;
66        BOOL m_bLayoutValid;
67        LONG m_nArrowSize;
68        LONG m_nToleranceArrowSize;
69        CPoint m_ArrowHandlePosition;
70        CPoint m_ToleranceArrowHandlePositionA;
71        CPoint m_ToleranceArrowHandlePositionB;
72        UINT m_nDragVersion;
73        UINT m_nDragMode;
74        CPoint m_DragButtonDownPosition;
75        CPoint m_DragRelativeButtonDownPosition;
76
77protected:
78        VOID InitializeWindow()
79        {
80                T* pT = static_cast<T*>(this);
81                _A(IsWindow());
82                _A((GetStyle() & SS_TYPEMASK) == SS_LEFT); //_A((UINT) ((GetStyle() & SS_TYPEMASK) - SS_LEFT) < (SS_RIGHT - SS_LEFT + 1));
83                //ModifyStyle(0, SS_NOTIFY);
84                _A(GetExStyle() & WS_EX_TRANSPARENT);
85                CWindow Parent = GetParent();
86                pT->UpdateLayout();
87                m_nVersion = 0;
88                m_nDragMode = 0;
89        }
90
91public:
92// CControlT
93        CControlT() : 
94                m_nExtendedStyle(CS_DEFAULT)
95        {
96                m_fAngle = 10.0 / 180 * M_PI;
97                m_fToleranceAngle = 90.0 / 180 * M_PI;
98                m_bLayoutValid = FALSE;
99        }
100        ~CControlT()
101        {
102        }
103        ULONG GetExtendedStyle() const
104        {
105                return m_nExtendedStyle;
106        }
107        VOID SetExtendedStyle(ULONG nStyle)
108        {
109                if(m_nExtendedStyle != nStyle)
110                {
111                        m_nExtendedStyle = nStyle;
112                        if(IsWindow())
113                                _W(Invalidate());
114                }
115        }
116        static DOUBLE Round(DOUBLE fValue) 
117        {
118                return (fValue > 0.0) ? floor(fValue + 0.5) : ceil(fValue - 0.5);
119        }
120        CPoint Transform(DOUBLE fX, DOUBLE fY, DOUBLE fAngle) const
121        {
122                CPoint Value;
123                const DOUBLE S = sin(fAngle), C = cos(fAngle);
124                Value.x = (LONG) Round(fX * C + fY * S);
125                Value.y = (LONG) Round(fX * S - fY * C);
126                Value.Offset(m_CenterPosition);
127                return Value;
128        }
129        VOID UpdateLayout()
130        {
131                T* pT = static_cast<T*>(this);
132                CRect ClientPosition;
133                _W(GetClientRect(ClientPosition));
134                m_CenterPosition = ClientPosition.CenterPoint();
135                m_nArrowSize = min(ClientPosition.Width(), ClientPosition.Height()) / 2 - 2;
136                m_bLayoutValid = m_nArrowSize >= 24;
137                if(!m_bLayoutValid)
138                        return;
139                m_nToleranceArrowSize = m_nArrowSize * 3 / 4;
140                m_ArrowHandlePosition = Transform(0, m_nArrowSize - 6, m_fAngle);
141                m_ToleranceArrowHandlePositionA = Transform(0, m_nToleranceArrowSize - 6, m_fAngle - m_fToleranceAngle / 2);
142                m_ToleranceArrowHandlePositionB = Transform(0, m_nToleranceArrowSize - 6, m_fAngle + m_fToleranceAngle / 2);
143        }
144        VOID EraseBackground(CDCHandle Dc)
145        {
146                Dc;
147        }
148        VOID Paint(CDCHandle Dc)
149        {
150                const BOOL bEnabled = IsWindowEnabled();
151                CRect Position;
152                _W(GetClientRect(Position));
153                Dc.SetBkMode(TRANSPARENT);
154                if(!m_nArrowSize)
155                        return;
156                CPen ArrowPen;
157                _W(ArrowPen.CreatePen(PS_SOLID, 1, RGB(0x77, 0x77, 0x77)));
158                CGdiSelector ArrowPenSelector(Dc, ArrowPen);
159                CBrush Brush;
160                _W(Brush.CreateSolidBrush(RGB(0xFF, 0xFF, 0xFF)));
161                {
162                        #pragma region Tolerance Arrow
163                        {
164                                CBrush ToleranceArrowBrush;
165                                _W(ToleranceArrowBrush.CreateSolidBrush(RGB(0xCC, 0xFF, 0xCC)));
166                                CGdiSelector ToleranceArrowBrushSelector(Dc, ToleranceArrowBrush);
167                                if(m_fToleranceAngle > 0)
168                                {
169                                        Dc.MoveTo(m_CenterPosition.x, m_CenterPosition.y);
170                                        Dc.AngleArc(m_CenterPosition.x, m_CenterPosition.y, 2 * m_nToleranceArrowSize / 3, 90.f - (FLOAT) ((m_fAngle - m_fToleranceAngle / 2) * 180 / M_PI), (FLOAT) (-m_fToleranceAngle * 180 / M_PI));
171                                        static const LONG A = 3;
172                                        static const LONG B = 7;
173                                        static const LONG C = 12;
174                                        static const LONG D = 14;
175                                        {
176                                                const DOUBLE fAngle = m_fAngle - m_fToleranceAngle / 2;
177                                                POINT pArrowPoints[] = {
178                                                        Transform(-A, 0, fAngle),
179                                                        Transform(-A, m_nToleranceArrowSize - C, fAngle),
180                                                        Transform(-B, m_nToleranceArrowSize - D, fAngle),
181                                                        Transform( 0, m_nToleranceArrowSize,     fAngle),
182                                                        Transform(+B, m_nToleranceArrowSize - D, fAngle),
183                                                        Transform(+A, m_nToleranceArrowSize - C, fAngle),
184                                                        Transform(+A, 0, fAngle),
185                                                };
186                                                Dc.Polygon(pArrowPoints, DIM(pArrowPoints));
187                                        }
188                                        {
189                                                const DOUBLE fAngle = m_fAngle + m_fToleranceAngle / 2;
190                                                POINT pArrowPoints[] = {
191                                                        Transform(-A, 0, fAngle),
192                                                        Transform(-A, m_nToleranceArrowSize - C, fAngle),
193                                                        Transform(-B, m_nToleranceArrowSize - D, fAngle),
194                                                        Transform( 0, m_nToleranceArrowSize,     fAngle),
195                                                        Transform(+B, m_nToleranceArrowSize - D, fAngle),
196                                                        Transform(+A, m_nToleranceArrowSize - C, fAngle),
197                                                        Transform(+A, 0, fAngle),
198                                                };
199                                                Dc.Polygon(pArrowPoints, DIM(pArrowPoints));
200                                        }
201                                }
202                        }
203                        #pragma endregion
204                        #pragma region Arrow
205                        CGdiSelector BrushSelector(Dc, Brush);
206                        static const LONG A = 4;
207                        static const LONG B = 10;
208                        static const LONG C = 12;
209                        static const LONG D = 14;
210                        POINT pArrowPoints[] = {
211                                Transform(-A, 0, m_fAngle),
212                                Transform(-A, m_nArrowSize - C, m_fAngle),
213                                Transform(-B, m_nArrowSize - D, m_fAngle),
214                                Transform( 0, m_nArrowSize,     m_fAngle),
215                                Transform(+B, m_nArrowSize - D, m_fAngle),
216                                Transform(+A, m_nArrowSize - C, m_fAngle),
217                                Transform(+A, 0, m_fAngle),
218                        };
219                        Dc.Polygon(pArrowPoints, DIM(pArrowPoints));
220                        #pragma endregion
221                }
222                static const LONG D = 8;
223                static const LONG F = 1;
224                Dc.Ellipse(m_CenterPosition.x - D, m_CenterPosition.y - D, m_CenterPosition.x + D + F, m_CenterPosition.y + D + F);
225        }
226        static BOOL Close(CPoint PositionA, CPoint PositionB, LONG nDistanceThreshold, CPoint* pRelativePosition = NULL)
227        {
228                if(pRelativePosition)
229                        *pRelativePosition = PositionA - PositionB;
230                return (PositionA.x - PositionB.x) * (PositionA.x - PositionB.x) + (PositionA.y - PositionB.y) * (PositionA.y - PositionB.y) < (nDistanceThreshold * nDistanceThreshold);
231        }
232        UINT DragModeFromPosition(CPoint Position, CPoint* pRelativePosition = NULL) const
233        {
234                if(Close(m_ToleranceArrowHandlePositionA, Position, 6, pRelativePosition))
235                        return 2;
236                if(Close(m_ToleranceArrowHandlePositionB, Position, 6, pRelativePosition))
237                        return 3;
238                if(Close(m_ArrowHandlePosition, Position, 6, pRelativePosition))
239                        return 1;
240                if(Close(m_ToleranceArrowHandlePositionA, Position, 10, pRelativePosition))
241                        return 2;
242                if(Close(m_ToleranceArrowHandlePositionB, Position, 10, pRelativePosition))
243                        return 3;
244                if(Close(m_ArrowHandlePosition, Position, 10, pRelativePosition))
245                        return 1;
246                return 0;
247        }
248        DOUBLE GetAngle() const
249        {
250                return m_fAngle;
251        }
252        DOUBLE GetToleranceAngle() const
253        {
254                return m_fToleranceAngle;
255        }
256        VOID SetAngle(DOUBLE fAngle)
257        {
258                T* pT = static_cast<T*>(this);
259                if(m_fAngle == fAngle)
260                        return;
261                m_fAngle = fAngle;
262                m_nVersion++;
263                if(!pT->IsWindow())
264                        return;
265                pT->UpdateLayout();
266                pT->Invalidate();
267        }
268        VOID SetToleranceAngle(DOUBLE fToleranceAngle)
269        {
270                T* pT = static_cast<T*>(this);
271                if(m_fToleranceAngle == fToleranceAngle)
272                        return;
273                m_fToleranceAngle = fToleranceAngle;
274                m_nVersion++;
275                if(!pT->IsWindow())
276                        return;
277                pT->UpdateLayout();
278                pT->Invalidate();
279        }
280
281// CWindowImplBaseT
282        BOOL SubclassWindow(HWND hWindow)
283        {
284                _A(!IsWindow() && CWindow(hWindow).IsWindow());
285                _A(_tcsicmp(GetClassNameString(hWindow), GetWndClassName()) == 0);
286                if(!__super::SubclassWindow(hWindow))
287                        return FALSE;
288                T* pT = static_cast<T*>(this);
289                pT->InitializeWindow();
290                return TRUE;
291        }
292
293// Window Message Handler
294        LRESULT OnCreate(CREATESTRUCT*)
295        {
296                T* pT = static_cast<T*>(this);
297                if(DefWindowProc() != 0)
298                        return -1;
299                pT->InitializeWindow();
300                return 0;
301        }
302        LRESULT OnDestroy()
303        {
304                SetMsgHandled(FALSE);
305                return 0;
306        }
307        LRESULT OnEnable(BOOL)
308        {
309                _W(Invalidate());
310                _W(UpdateWindow());
311                //SetMsgHandled(FALSE);
312                return 0;
313        }
314        LRESULT OnSize(UINT, CSize)
315        {
316                T* pT = static_cast<T*>(this);
317                pT->UpdateLayout();
318                SetMsgHandled(FALSE);
319                return 0;
320        }
321        LRESULT OnEraseBkgnd(CDCHandle Dc)
322        {
323                T* pT = static_cast<T*>(this);
324                pT->EraseBackground(Dc);
325                return TRUE;
326        }
327        LRESULT OnPaint(CDCHandle Dc)
328        {
329                T* pT = static_cast<T*>(this);
330                if(Dc)
331                {
332                        pT->EraseBackground(Dc);
333                        if(pT->GetExStyle() & WS_EX_TRANSPARENT)
334                                DrawThemeParentBackground(m_hWnd, Dc, NULL);
335                        pT->Paint(Dc);
336                } else
337                {
338                        CPaintDC Dc(m_hWnd);
339                        pT->EraseBackground((HDC) Dc);
340                        if(pT->GetExStyle() & WS_EX_TRANSPARENT)
341                                DrawThemeParentBackground(m_hWnd, Dc, &Dc.m_ps.rcPaint);
342                        pT->Paint((HDC) Dc);
343                }
344                return 0;
345        }
346        LRESULT OnPrintClient(CDCHandle Dc, UINT nOptions)
347        {
348                T* pT = static_cast<T*>(this);
349                if(nOptions & PRF_ERASEBKGND)
350                        pT->EraseBackground((HDC) Dc);
351                if(nOptions & PRF_CLIENT)
352                        pT->Paint(Dc);
353                return 0;
354        }
355        LRESULT OnUpdateUiState(UINT nAction, UINT nElements)
356        {
357                // NTOE: If the control is subclassed or superclassed, this message can cause
358                //       repainting without WM_PAINT. We don't use this state, so just do nothing.
359                nAction; nElements;
360                return 0;
361        }
362        LRESULT OnSetCursor(CWindow, UINT nHitTestCode, UINT nMouseMessage)
363        {
364                nHitTestCode; nMouseMessage;
365                if(m_bLayoutValid)
366                {
367                        CPoint Position;
368                        if(GetCursorPos(&Position))
369                        {
370                                _W(ScreenToClient(&Position));
371                                const UINT nDragMode = DragModeFromPosition(Position);
372                                if(nDragMode)
373                                {
374                                        ::SetCursor(AtlLoadSysCursor(IDC_SIZEALL));
375                                        return TRUE;
376                                }
377                        }
378                }
379                SetMsgHandled(FALSE);
380                return 0;
381        }
382        LRESULT OnMouseMove(UINT nButton, CPoint Position)
383        {
384                switch(m_nDragMode)
385                {
386                case 1: // Arrow Handle
387                        {
388                                CPoint AlignPosition = Position - m_DragRelativeButtonDownPosition;
389                                const DOUBLE fAngle = atan2((DOUBLE) (Position.y - m_CenterPosition.y), (DOUBLE) (Position.x - m_CenterPosition.x)) + M_PI / 2;
390                                m_fAngle = fAngle;
391                                m_nVersion++;
392                        }
393                        break;
394                case 2: // Tolerance Arrow Handle (A)
395                        {
396                                CPoint AlignPosition = Position - m_DragRelativeButtonDownPosition;
397                                const DOUBLE fAngle = atan2((DOUBLE) (Position.y - m_CenterPosition.y), (DOUBLE) (Position.x - m_CenterPosition.x)) + M_PI / 2;
398                                DOUBLE fToleranceAngle = abs(fAngle - m_fAngle);
399                                if(fToleranceAngle > M_PI)
400                                        fToleranceAngle = 2 * M_PI - fToleranceAngle;
401                                _A(fToleranceAngle >= 0 && fToleranceAngle <= M_PI);
402                                m_fToleranceAngle = 2 * fToleranceAngle;
403                                m_nVersion++;
404                        }
405                        break;
406                case 3: // Tolerance Arrow Handle (B)
407                        {
408                                CPoint AlignPosition = Position - m_DragRelativeButtonDownPosition;
409                                const DOUBLE fAngle = atan2((DOUBLE) (Position.y - m_CenterPosition.y), (DOUBLE) (Position.x - m_CenterPosition.x)) + M_PI / 2;
410                                DOUBLE fToleranceAngle = abs(fAngle - m_fAngle);
411                                if(fToleranceAngle > M_PI)
412                                        fToleranceAngle = 2 * M_PI - fToleranceAngle;
413                                _A(fToleranceAngle >= 0 && fToleranceAngle <= M_PI);
414                                m_fToleranceAngle = 2 * fToleranceAngle;
415                                m_nVersion++;
416                        }
417                        break;
418                default:
419                        return 0;
420                }
421                #pragma region Notification
422                NMHDR Header;
423                Header.hwndFrom = m_hWnd;
424                Header.idFrom = GetDlgCtrlID();
425                Header.code = NC_CHANGING;
426                SendMessage(GetParent(), WM_NOTIFY, (WPARAM) m_hWnd, (LPARAM) &Header);
427                #pragma endregion
428                UpdateLayout();
429                Invalidate();
430                return 0;
431        }
432        LRESULT OnLButtonDown(UINT nButton, CPoint Position)
433        {
434                if(!m_bLayoutValid)
435                        return 0;
436                if(!(nButton & MK_LBUTTON))
437                        return 0;
438                CPoint RelativePosition;
439                m_nDragMode = DragModeFromPosition(Position, &RelativePosition);
440                if(!m_nDragMode)
441                        return 0;
442                m_DragButtonDownPosition = Position;
443                m_DragRelativeButtonDownPosition = RelativePosition;
444                m_nDragVersion = m_nVersion;
445                SetCapture();
446                ::SetCursor(AtlLoadSysCursor(IDC_SIZEALL));
447                return 0;
448        }
449        LRESULT OnLButtonUp(UINT nButton, CPoint Position)
450        {
451                const UINT nDragMode = m_nDragMode;
452                ReleaseCapture();
453                m_nDragMode = 0;
454                if(nDragMode && m_nVersion != m_nDragVersion)
455                {
456                        m_nDragVersion = m_nVersion;
457                        #pragma region Notification
458                        NMHDR Header;
459                        Header.hwndFrom = m_hWnd;
460                        Header.idFrom = GetDlgCtrlID();
461                        Header.code = NC_CHANGED;
462                        SendMessage(GetParent(), WM_NOTIFY, (WPARAM) m_hWnd, (LPARAM) &Header);
463                        #pragma endregion
464                }
465                return 0;
466        }
467};
468
469class CControl : 
470        public CControlT<CControl>
471{
472public:
473
474DECLARE_WND_SUPERCLASS(_T("CControl"), GetWndClassName())
475
476};
477
478////////////////////////////////////////////////////////////
479// CMainPropertySheet
480
481class CMainPropertySheet :
482        public CSizablePropertySheetT<CMainPropertySheet>
483{
484public:
485
486BEGIN_MSG_MAP_EX(CMainPropertySheet)
487        CHAIN_MSG_MAP(CSizablePropertySheet)
488        //MSG_WM_SYSCOMMAND(OnSysCommand)
489END_MSG_MAP()
490
491public:
492
493        ////////////////////////////////////////////////////////
494        // CMainPropertyPage
495
496        class CMainPropertyPage :
497                public CPropertyPageT<CMainPropertyPage>,
498                public CDialogResize<CMainPropertyPage>,
499                public CThemeImpl<CMainPropertyPage>
500        {
501        public:
502                enum { IDD = IDD_MAIN_PROPERTYPAGE };
503
504        BEGIN_MSG_MAP_EX(CMainPropertyPage)
505                CHAIN_MSG_MAP(CPropertyPage)
506                CHAIN_MSG_MAP(CDialogResize<CMainPropertyPage>)
507                CHAIN_MSG_MAP(CThemeImpl<CMainPropertyPage>)
508                MSG_WM_INITDIALOG(OnInitDialog)
509                MSG_WM_DESTROY(OnDestroy)
510                REFLECT_NOTIFICATIONS()
511        END_MSG_MAP()
512
513        BEGIN_DLGRESIZE_MAP(CMainPropertyPage)
514                DLGRESIZE_CONTROL(IDC_CONTROL, DLSZ_SIZE_X | DLSZ_SIZE_Y)
515        END_DLGRESIZE_MAP()
516
517        public:
518
519        private:
520                CMainPropertySheet& m_PropertySheet;
521                CControl m_Control;
522
523        public:
524        // CMainPropertyPage
525                CMainPropertyPage(CMainPropertySheet* pPropertySheet) :
526                        m_PropertySheet(*pPropertySheet)
527                {
528                }
529                VOID UpdateControls()
530                {
531                }
532
533        // Window Message Handler
534                LRESULT OnInitDialog(HWND, LPARAM)
535                {
536                        _ATLTRY
537                        {
538                                CWaitCursor WaitCursor;
539                                _W(m_Control.SubclassWindow(GetDlgItem(IDC_CONTROL)));
540                                DlgResize_Init(FALSE);
541                                EnableThemeDialogTexture(ETDT_ENABLETAB);
542                                UpdateControls();
543                        }
544                        _ATLCATCHALL()
545                        {
546                                for(CWindow Window = GetWindow(GW_CHILD); Window.IsWindow(); Window = Window.GetWindow(GW_HWNDNEXT))
547                                        Window.EnableWindow(FALSE);
548                                _ATLRETHROW;
549                        }
550                        return TRUE;
551                }
552                LRESULT OnDestroy()
553                {
554                        return 0;
555                }
556                INT OnSetActive()
557                {
558                        _ATLTRY
559                        {
560                                CWaitCursor WaitCursor;
561                                UpdateControls();
562                        }
563                        _ATLCATCHALL()
564                        {
565                                _Z_EXCEPTION();
566                                return -1;
567                        }
568                        return 0;
569                }
570        };
571
572private:
573        CMainPropertyPage m_MainPropertyPage;
574
575public:
576// CMainPropertySheet
577        CMainPropertySheet() :
578                CSizablePropertySheetT<CMainPropertySheet>(IDS_MAIN_PROPERTYSHEETCAPTION),
579                m_MainPropertyPage(this)
580        {
581                AddPage(m_MainPropertyPage);
582        }
583        BOOL SetInitialPosition()
584        {
585                if(!__super::SetInitialPosition())
586                        return FALSE;
587                SetIcon(AtlLoadIconImage(IDI_MODULE, LR_DEFAULTCOLOR, GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON)), TRUE);
588                SetIcon(AtlLoadIconImage(IDI_MODULE, LR_DEFAULTCOLOR, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON)), FALSE);
589                #pragma region Caption
590                CString sCaption;
591                _W(GetWindowText(sCaption));
592                #pragma region Indication of Bitness
593                #if defined(_WIN64)
594                        sCaption.Append(_T(" (64-bit)"));
595                #else
596                        if(SafeIsWow64Process())
597                                sCaption.Append(_T(" (32-bit)"));
598                #endif // defined(_WIN64)
599                #pragma endregion
600                _W(SetWindowText(sCaption));
601                #pragma endregion
602                #pragma region System Menu
603                //CMenuHandle Menu = GetSystemMenu(FALSE);
604                //_W(Menu.AppendMenu(MF_SEPARATOR));
605                //_W(Menu.AppendMenu(MF_STRING, ID_APP_ABOUT, _T("&About...")));
606                #pragma endregion
607                return TRUE;
608        }
609
610// Window Message Handelr
611        //LRESULT OnSysCommand(UINT nCommand, CPoint)
612        //{
613        //      switch(nCommand)
614        //      {
615        //      case ID_APP_ABOUT:
616        //              {
617        //                      CAboutDialog Dialog;
618        //                      Dialog.DoModal(m_hWnd);
619        //              }
620        //              break;
621        //      default:
622        //              SetMsgHandled(FALSE);
623        //      }
624        //      return 0;
625        //}
626};
627
628////////////////////////////////////////////////////////////
629// CMainDialog
630
631class CMainDialog : 
632        public CDialogImpl<CMainDialog>,
633        //public CDialogResize<CMainDialog>,
634        public CWindowWithPrivateMessagesT<CMainDialog>
635{
636public:
637        enum { IDD = IDD_MAIN };
638
639BEGIN_MSG_MAP_EX(CMainDialog)
640        //CHAIN_MSG_MAP(CDialogResize<CMainDialog>)
641        CHAIN_MSG_MAP(CWindowWithPrivateMessages)
642        MSG_WM_INITDIALOG(OnInitDialog)
643        MSG_WM_DESTROY(OnDestroy)
644        MSG_WM_SYSCOMMAND(OnSysCommand)
645        COMMAND_ID_HANDLER_EX(IDCANCEL, OnCommand)
646        COMMAND_ID_HANDLER_EX(IDC_PROPERTYSHEET, OnPropertySheet)
647        NOTIFY_HANDLER_EX(IDC_CONTROL, CControl::NC_CHANGING, OnControlChanging)
648        NOTIFY_HANDLER_EX(IDC_CONTROL, CControl::NC_CHANGED, OnControlChanged)
649        REFLECT_NOTIFICATIONS()
650END_MSG_MAP()
651
652//BEGIN_DLGRESIZE_MAP(CMainDialog)
653//      DLGRESIZE_CONTROL(IDC_PROPERTYSHEET, DLSZ_MOVE_X | DLSZ_MOVE_Y)
654//      DLGRESIZE_CONTROL(IDCANCEL, DLSZ_MOVE_X | DLSZ_MOVE_Y)
655//END_DLGRESIZE_MAP()
656
657public:
658
659private:
660        CControl m_Control;
661
662        VOID UpdateControls()
663        {
664        }
665
666public:
667// CMainDialog
668        VOID UpdateCaption(LPCTSTR pszEventName)
669        {
670                SetWindowText(AtlFormatString(_T("%s: %.1f ± %.2f"), pszEventName, m_Control.GetAngle() * 180 / M_PI, (m_Control.GetToleranceAngle() / 2) * 180 / M_PI));
671        }
672
673// Window Message Handler
674        LRESULT OnInitDialog(HWND, LPARAM)
675        {
676                _W(m_Control.SubclassWindow(GetDlgItem(IDC_CONTROL)));
677                //m_PropertySheetButton = GetDlgItem(OnPropertySheet);
678                //DlgResize_Init();
679                SetIcon(AtlLoadIconImage(IDI_MODULE, GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON), LR_DEFAULTCOLOR), TRUE);
680                //SetIcon(AtlLoadIconImage(IDI_MODULE, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), LR_DEFAULTCOLOR), FALSE);
681                CMenuHandle Menu = GetSystemMenu(FALSE);
682                _W(Menu.AppendMenu(MF_SEPARATOR));
683                _W(Menu.AppendMenu(MF_STRING, ID_APP_ABOUT, _T("&About...")));
684                _W(CenterWindow());
685                UpdateControls();
686                #if _DEVELOPMENT
687                        // ...
688                #endif // _DEVELOPMENT
689                return TRUE;
690        }
691        LRESULT OnDestroy()
692        {
693                return 0;
694        }
695        LRESULT OnSysCommand(UINT nCommand, CPoint)
696        {
697                switch(nCommand)
698                {
699                case ID_APP_ABOUT:
700                        {
701                                CAboutDialog Dialog;
702                                Dialog.DoModal(m_hWnd);
703                        }
704                        break;
705                default:
706                        SetMsgHandled(FALSE);
707                }
708                return 0;
709        }
710        LRESULT OnCommand(UINT, INT nIdentifier, HWND)
711        {
712                _W(EndDialog(nIdentifier));
713                return 0;
714        }
715        LRESULT OnControlChanging(NMHDR*)
716        {
717                UpdateCaption(_T("Changing"));
718                return 0;
719        }
720        LRESULT OnControlChanged(NMHDR*)
721        {
722                UpdateCaption(_T("Changed"));
723                return 0;
724        }
725        LRESULT OnPropertySheet(UINT, INT, HWND)
726        {
727                CMainPropertySheet PropertySheet;
728                PropertySheet.DoModal(m_hWnd);
729                return 0;
730        }
731};
Note: See TracBrowser for help on using the repository browser.