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

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