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

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