source: trunk/src/WTLx/atldlgx.h @ 493

Revision 493, 50.4 KB checked in by Eoin, 12 years ago (diff)

Freedom from automatic ATL and/or WTL namespaces.

Line 
1// atldlgx.h
2//
3// Unusual but useful specializable WTL dialog classes
4//
5// Copyright (c) Alain Rist 2007
6//
7// The use and distribution terms for this software are covered by the
8// Common Public License 1.0 (http://opensource.org/osi3.0/licenses/cpl1.0.php)
9// By using this software in any fashion, you are agreeing to be bound by
10// the terms of this license. You must not remove this notice, or
11// any other, from this software.
12
13#ifndef __ATLDLGX_H__
14#define __ATLDLGX_H__
15
16#pragma once
17
18#ifndef _WTL_VER
19        #error atldlgx.h requires the Windows Template Library
20#elif _WTL_VER < 0x800
21        #error atldlgx.h requires WTL version 8.0 or over
22#endif
23
24#ifndef __ATLDLGS_H__
25        #error atldlgx.h requires atldlgs.h to be included first
26#endif
27
28#ifndef __ATLCTRLS_H__
29        #error atldlgx.h requires atlctrls.h to be included first
30#endif
31
32///////////////////////////////////////////////////////////////////////////////
33// Classes in this file:
34//
35// CEmptyDlgTemplate - Empty dialog template loading the dialog title from a resource string
36// CEmptyDialogImpl - Implements empty dialogs
37// CMenuDialog - MI class for any modal dialog to behave as a menu
38// CCellMenu - Specializable cell composed dialog to use as a menu
39// CControlDialogImpl - Single control dialog implementation
40// CControlDialog - Specializable single control dialog
41// CInPlaceEditor - In place editing dialog
42// CSplitDialogImpl - Split dialog implementation
43// CSplitDialog - Specializable split dialog
44// CVSplitDialog - Specializable vertical WTL::CSplitterImpl based split dialog
45// CHSplitDialog - Specializable horizontal WTL::CSplitterImpl based split dialog
46//
47// aero::CEmptyDialogImpl - Aero enabled CEmptyDialogImpl
48// aero::CControlDialog - Aero enabled CControlDialog
49// aero::CSplitDialog - Aero enabled CSplitDialog
50//
51// CStdEmptyDialogImpl - base class for Mobile Device standard empty dialog classes
52// CStdControlDialog - Mobile Device specializable standard single control dialog class
53// CStdSplitDialog - Mobile Device specializable standard split dialog class
54// CStdVSplitDialog - Specializable vertical WTL::CSplitterImpl based split dialog
55// CStdHSplitDialog - Specializable horizontal WTL::CSplitterImpl based split dialog
56
57// Macros
58
59#ifndef MESSAGE_ANSWER
60#define MESSAGE_ANSWER(msg, res) \
61        if(uMsg == msg) \
62        { \
63                lResult = res; \
64                return bHandled = TRUE; \
65        }
66#endif
67
68namespace WTL
69{
70
71/////////////////////////////////////////////////////////////////
72// CEmptyDlgTemplate : Empty dialog template loading the dialog title from a resource string
73//
74
75typedef ATL::CWinTraits<WS_VISIBLE | WS_POPUP> CEmptyDlgTraits;
76
77template <UINT t_uIDS, class TDlgTraits = CEmptyDlgTraits>
78class CEmptyDlgTemplate : public CMemDlgTemplate
79{
80public:
81        void Create(POINT point, SIZE size)
82        {
83                DWORD dw0 = NULL;
84                DLGTEMPLATE dt = {TDlgTraits::GetWndStyle(0), TDlgTraits::GetWndExStyle(0), 0, (SHORT)point.x, (SHORT)point.y, (SHORT)size.cx, (SHORT)size.cy};
85                AddData(&dt, sizeof(dt));
86                AddData(&dw0, sizeof(DWORD));
87                if (t_uIDS)
88                {
89        #ifdef _WIN32_WCE
90                        AddString(AtlLoadString(t_uIDS));
91        #else
92                        CTempBuffer<TCHAR> sTitle(255);
93                        AtlLoadString(t_uIDS, sTitle, 255);
94                        AddString(sTitle);
95        #endif
96                }
97        }
98
99};
100
101///////////////////////////////////////////////////////////////////////////////
102// CEmptyDialogImpl - Implements empty dialogs
103//                 
104
105template
106        < class T,              // Actual dialog class: ie CMyEmptyDialog 
107        UINT t_uIDD,    // Dialog IDD, title, icon, toolbar, menu (if matching resources exist)
108        class TDlgTemplate      // In memory dialog template
109                = CEmptyDlgTemplate<t_uIDD, CEmptyDlgTraits>, // default for TDlgTemplate
110        class TBase                     // CIndirectDialogImpl::TBase class
111                = ATL::CDialogImpl<T, ATL::CWindow>  // default for TBase
112        >
113class ATL_NO_VTABLE CEmptyDialogImpl : 
114        public CIndirectDialogImpl<
115        T,
116        TDlgTemplate, 
117        TBase
118        > // CIndirectDialogImpl
119{
120        typedef CEmptyDialogImpl<T, t_uIDD, TDlgTemplate, TBase> thisClass;
121public:
122        typedef thisClass EmptyDialog;
123
124// Constructors
125        // Empty constructor : derived class performs m_Template and m_Data initializations
126        CEmptyDialogImpl(){}
127
128        // Sizing constructor : sets origin to {0,0}
129        CEmptyDialogImpl(SIZE size, bool bDLU = true) : m_Data(0)
130        {
131                POINT point = {0};
132                if(bDLU)
133                        PixToDLU(size);
134                m_Template.Create(point, size);
135        }
136
137        // Positioning constructor
138        CEmptyDialogImpl(POINT point, SIZE size, bool bDLU = true) : m_Data(0)
139        {
140                if(bDLU)
141                {
142                        PixToDLU(point);
143                        PixToDLU(size);
144                }
145                m_Template.Create(point, size);
146        }
147
148        // Positioning constructor
149        CEmptyDialogImpl(RECT rect, bool bDLU = true) : m_Data(0)
150        {
151                POINT point = {rect.left, rect.top};
152                SIZE size = { rect.right - rect.left, rect.bottom - rect.top};
153                if(bDLU)
154                {
155                        PixToDLU(point);
156                        PixToDLU(size);
157                }
158                m_Template.Create(point, size);
159        }
160
161        // Data members
162        enum {IDD = t_uIDD};
163        LPARAM m_Data; // user data
164
165        // ToolBar management
166#ifndef _WIN32_WCE // WTL 8.0 does not support WinCE standalone toolbars
167        HWND m_hWndToolBar;
168
169        HWND CreateToolBar(UINT nID = t_uIDD)
170        {
171                return m_hWndToolBar = AtlCreateSimpleToolBar(m_hWnd, nID);
172        }
173
174        BOOL GetClientRect(LPRECT lpRect) 
175        {
176                ATLASSERT(IsWindow());
177
178                BOOL bRes = ::GetClientRect(m_hWnd, lpRect);
179                if(::IsWindow(m_hWndToolBar) && bRes)
180                {
181                        RECT rTB;
182                        ::GetWindowRect(m_hWndToolBar, &rTB);
183                        // assume CCS_TOP style
184                        lpRect->top += rTB.bottom - rTB.top;
185                }
186                return bRes;
187        }
188#endif // !_WIN32_WCE
189
190// Overrideable
191        bool Init(LPARAM lParam)
192        {
193                return DefInit(lParam);
194        }
195
196        bool Size(WPARAM /*wParam*/,LPARAM /*lParam*/)
197        {
198                Invalidate();
199                return false;
200        }
201
202        bool Paint(HDC /*hdc*/)
203        {
204                return false;
205        }
206
207        void Close(INT iCmd) 
208        {
209                // Modal closing
210                ATLVERIFY(EndDialog(iCmd));
211        }
212
213// Implementation
214        bool DefInit(LPARAM lParam)
215        {
216                m_Data = lParam;
217#ifndef _WIN32_WCE
218                CreateToolBar();
219                SetMenu(AtlLoadMenu(t_uIDD));
220#endif
221                if (HICON hIconSmall = (HICON)::LoadImage(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(t_uIDD), 
222                        IMAGE_ICON, ::GetSystemMetrics(SM_CXSMICON), ::GetSystemMetrics(SM_CYSMICON), LR_DEFAULTCOLOR))
223                                SetIcon(hIconSmall, FALSE);
224
225                m_Template.Reset(); // free DLGTEMPLATE memory
226                return false; // WM_INITDIALOG not handled
227        }
228
229        // Prevent non modal execution
230        HWND Create(HWND, LPARAM)
231        {
232                ATLASSERT(FALSE); 
233                return NULL;
234        }
235
236// Message map and handlers
237        BEGIN_MSG_MAP(CEmptyDialogImpl)
238                MESSAGE_ANSWER(WM_ERASEBKGND, TRUE)
239                MESSAGE_HANDLER(WM_PAINT, OnPaint)
240                MESSAGE_HANDLER(WM_SIZE, OnSize)
241                MESSAGE_HANDLER(WM_SYSCOMMAND, OnSysCommand)
242                COMMAND_RANGE_HANDLER(IDOK, IDCANCEL, OnCloseCommand)
243                MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
244#ifndef _WIN32_WCE
245                MESSAGE_HANDLER(WM_PRINTCLIENT, OnPaint)
246#endif
247        END_MSG_MAP()
248
249        LRESULT OnSize(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
250        {
251#ifndef _WIN32_WCE
252                if(::IsWindow(m_hWndToolBar))
253                        CToolBarCtrl(m_hWndToolBar).AutoSize();
254#endif
255                bHandled = static_cast<T*>(this)->Size(wParam, lParam);
256                return 0;
257        }
258
259        LRESULT OnPaint(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
260        {
261                T* pT = static_cast<T*>(this);
262                if (wParam == NULL)
263                {
264                        CPaintDC dc(/*pT->*/m_hWnd);
265                        return bHandled = pT->Paint(dc.m_hDC);
266                }
267                else
268                        return bHandled = pT->Paint((HDC)wParam);
269        }
270
271        LRESULT OnSysCommand(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
272        {
273                if(wParam == SC_CLOSE)
274                        static_cast<T*>(this)->Close(IDCANCEL);
275                else
276                        bHandled = FALSE;
277                return 0;
278        }
279
280        LRESULT OnCloseCommand(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
281        {
282                static_cast<T*>(this)->Close(wID);
283                return 0;
284        }
285
286        LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
287        {
288                bHandled = static_cast<T*>(this)->Init(lParam);
289                return FALSE; // don't set focus to default control
290        }
291
292// Implementation helpers
293        bool MoveToTemplatePix()
294        {
295                ATLASSERT(IsWindow());
296                ATLASSERT(m_Template.IsValid());
297
298                LPDLGTEMPLATE pdt = m_Template.GetTemplatePtr();
299                return MoveWindow(pdt->x, pdt->y, pdt->cx, pdt->cy, FALSE) == TRUE;
300        }
301
302        static void PixToDLU(LONG &x, LONG &y) 
303        {
304                LONG lBaseUnit = ::GetDialogBaseUnits();
305                x = ::MulDiv(x , 4, LOWORD(lBaseUnit));
306                y = ::MulDiv(y , 8, HIWORD(lBaseUnit));
307        }
308
309        static void PixToDLU(SIZE &size) 
310        {
311                PixToDLU(size.cx, size.cy);
312        }
313
314        static void PixToDLU(POINT &point) 
315        {
316                PixToDLU(point.x, point.y);
317        }
318
319};
320
321///////////////////////////////////////////////////////////////////
322// CMenuDialog - MI class for any modal dialog to behave as a menu
323//
324
325template <class T>
326class CMenuDialog
327{
328public:
329        // Constructor
330        CMenuDialog() : m_bAccept(false)
331        {}
332
333        bool m_bAccept;
334
335// Message map and handlers
336        BEGIN_MSG_MAP(CMenuDialog)
337#ifndef _WIN32_WCE
338                MESSAGE_HANDLER(WM_INITDIALOG, OnInit)
339#else
340                MESSAGE_HANDLER(WM_SETFOCUS, OnSetFocus)
341                MESSAGE_HANDLER(WM_CANCELMODE, OnKill)
342                MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSetting)
343#endif // _WIN32_WCE
344                MESSAGE_HANDLER(WM_ACTIVATE, OnActivate)
345                COMMAND_ID_HANDLER(IDOK, OnOK)
346        END_MSG_MAP()
347
348        LRESULT OnActivate(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
349        {
350                if ((wParam == WA_INACTIVE) && !m_bAccept)
351                        static_cast<T*>(this)->PostMessage(WM_COMMAND, IDCANCEL);
352                return bHandled =FALSE;
353        }
354
355        LRESULT OnOK(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& bHandled)
356        {
357                m_bAccept = true;
358                return bHandled = FALSE;
359        }
360
361#ifndef _WIN32_WCE
362        LRESULT OnInit(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
363        {
364                T* pT = static_cast<T*>(this);
365                ::EnableWindow(pT->GetParent(), TRUE);
366                pT->SetFocus();
367                return bHandled = FALSE;
368        }
369#else // _WIN32_WCE
370        LRESULT OnSetFocus(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
371        {
372                ::EnableWindow(static_cast<T*>(this)->GetParent(), TRUE);
373                return bHandled = FALSE;
374        }
375
376        LRESULT OnKill(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
377        {
378                if(!m_bAccept)
379                        static_cast<T*>(this)->PostMessage(WM_COMMAND, IDCANCEL);
380                return bHandled =FALSE;
381        }
382
383        LRESULT OnSetting(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
384        {
385                if(!m_bAccept && (wParam == SETTINGCHANGE_RESET))
386                        static_cast<T*>(this)->PostMessage(WM_COMMAND, IDCANCEL);
387                return bHandled = FALSE;
388        }
389#endif // _WIN32_WCE
390
391};
392
393/////////////////////////////////////////////////////////////////////////////
394// CCellMenu - Cell composed dialog to use as a menu
395//
396// This is a specializable class. The default code loads a ribbon BITMAP resource
397// with t_uIDD identifier, sizes the cells and paints them from this bitmap.
398//
399// If there is no t_uIDD BITMAP resource, the cell size is computed from SM_CXSMICON and
400// SM_CYSMICON and you must provide at least a specialized PaintCell() member.
401//
402// The initial selection index is passed as a LPARAM to DoModal().
403// The return value is the selected cell index or -1 if cancelled.
404//
405// TrackCellMenu() positions the dialog with same semantics as TrackPopupMenu
406// and returns the result of DoModal().
407//
408
409typedef ATL::CWinTraits<WS_POPUP | WS_BORDER> CMenuDialogTraits;
410
411class CMenuDlgTemplate : public CEmptyDlgTemplate<0, CMenuDialogTraits>
412{};
413
414template
415        < UINT t_uIDD,  // Menu dialog IDD and bitmap (if matching resource exists)
416        INT t_nCol,             // Number of columns
417        INT t_nRow              // Number of rows
418        >
419class CCellMenu : 
420        public CEmptyDialogImpl<
421                /*thisClass*/CCellMenu<t_uIDD, t_nCol, t_nRow>, 
422                t_uIDD,
423                /*TDlgTemplate*/CMenuDlgTemplate
424                >, // CEmptyDialogImpl
425        public CMenuDialog<
426                /*thisClass*/CCellMenu<t_uIDD, t_nCol, t_nRow> 
427                > // CMenuDialog
428{
429        typedef CCellMenu<t_uIDD, t_nCol, t_nRow> thisClass;
430public:
431        typedef CMenuDialog<thisClass> MenuDialog;
432
433        // Helper for size and position computations
434        struct CELL
435        {
436                // Construct from coordinates
437                CELL(int xCol, int yRow) : xcol(xCol), yrow(yRow)
438                {}
439
440                // Construct from index
441                CELL(int index) : xcol(index % t_nCol), yrow(index / t_nCol)
442                {}
443
444                // Construct from mouse message lParam
445                CELL(LPARAM lParam) : xcol(GET_X_LPARAM(lParam) / Size().cx), yrow(GET_Y_LPARAM(lParam) / Size().cy)
446                {}
447
448#if (_MSC_VER < 1300) || (_ATL_VER < 0x700)  // eVC-VC6 and VCExpress-ATL3
449                static const int Cxy()
450                {
451                        return 2;
452                }
453
454                static const SIZE Size()
455                {
456                        static SIZE s = CellSize();
457                        return s;
458                }
459
460#else // VS 7.0 and over, not VCExpress-ATL3
461                static const int cxy;
462                static const SIZE size;
463
464                static const int Cxy()
465                {
466                        return cxy;
467                }
468
469                static const SIZE Size()
470                {
471                        return size;
472                }
473
474#endif // _MSC_VER < 1300 || (_ATL_VER < 0x700)
475
476                const int Left(bool bPaint = false)
477                {
478                        return xcol * Size().cx + Cxy() * bPaint;
479                }
480
481                const int Top(bool bPaint = false)
482                {
483                        return yrow * Size().cy + Cxy() * bPaint;
484                }
485
486                const RECT Rect(bool bPaint = false)
487                {
488                        RECT r = {Left(bPaint), Top(bPaint), 
489                                Left(bPaint) + Size().cx - 1 - 2 * Cxy() * bPaint, 
490                                Top(bPaint) + Size().cy - 1 - 2 * Cxy() * bPaint};
491                        return r;
492                }
493
494                int xcol;
495                int yrow;
496
497                const int Index()
498                {
499                        return yrow * t_nCol + xcol;
500                }
501
502                void Key(UINT uKey)
503                {
504                        // First and last cell specific
505                        if ((xcol + yrow == 0) && ((uKey == VK_UP) || (uKey == VK_LEFT)))
506                                uKey = VK_END;
507                        else if ((xcol == t_nCol - 1) && (yrow  == t_nRow - 1) && ((uKey == VK_DOWN) || (uKey == VK_RIGHT)))
508                                uKey = VK_HOME;
509                        // Adjust cell position
510                        switch (uKey)
511                        {
512                                case VK_LEFT:   xcol -- ; break;
513                                case VK_UP:     yrow -- ; break;
514                                case VK_RIGHT:  xcol ++ ; break;
515                                case VK_DOWN:   yrow ++ ; break;
516                                case VK_HOME:   xcol = 0; // fall through
517                                case VK_PRIOR:  yrow = 0; return;
518                                case VK_END:    xcol = t_nCol - 1; // fall through
519                                case VK_NEXT:   yrow = t_nRow - 1; // fall through
520                                default: return;
521                        }
522                        // Move around if out of bounds
523                        if (xcol < 0)
524                                xcol = t_nCol - 1, yrow--;
525                        else if (xcol >= t_nCol)
526                                xcol = 0, yrow ++;
527                        if (yrow < 0)
528                                yrow = t_nRow - 1, xcol--;
529                        else if (yrow >= t_nRow)
530                                yrow = 0, xcol++;
531                }
532        }; // struct CELL
533
534        // Constructor
535        CCellMenu(POINT ptOrig) : EmptyDialog(ptOrig, MenuSize(), false)
536        {}
537
538        // Overrides
539        void Close(INT iCmd)
540        {
541                EndDialog(iCmd == IDOK ? m_Data : -1);
542        }
543
544        bool Init(LPARAM lParam)
545        {
546                m_Data = lParam;
547                MoveToTemplatePix();
548                m_Template.Reset(); // free DLGTEMPLATE memory
549                return false;
550        }
551
552        bool Mouse(UINT uMsg, WPARAM /*wParam*/,LPARAM lParam)
553        {
554                switch(uMsg)
555                {
556                case WM_LBUTTONUP:
557                        m_Data = CELL(lParam).Index();
558                        PostMessage(WM_COMMAND,IDOK);
559                        break;
560                case WM_LBUTTONDOWN:
561                case WM_MOUSEMOVE:
562                        {
563                                CELL cell(lParam);
564                                if ((INT)m_Data != cell.Index())
565                                        UpdateSelection(cell);
566                        }
567                        break;
568                default:
569                        return false;
570                }
571                return true;
572        }
573
574        bool Key(UINT uMsg, WPARAM wParam, LPARAM /*lParam*/)
575        {
576                if (uMsg == WM_KEYUP)
577                {
578                        CELL cell((INT)m_Data);
579                        cell.Key((UINT)wParam);
580                        if ((INT)m_Data != cell.Index())
581                                UpdateSelection(cell);
582                        return true;
583                }
584                return false;
585        };
586
587// Specializables
588        void PrePaint(HDC hdc)
589        {
590                SIZE s = MenuSize();
591                RECT rect = {0, 0, s.cx, s.cy};
592                CDCHandle(hdc).FillSolidRect(&rect, GetSysColor(COLOR_MENU));
593        }
594
595        void PaintCells(HDC hdc)
596        {
597                for (int iRow = 0; iRow <  t_nRow; iRow++)
598                        for (int iCol = 0; iCol < t_nCol; iCol++)
599                        {
600                                CELL cell(iCol, iRow);
601                                PaintCell(hdc, cell);
602                        }
603        }
604
605        void PaintCell(HDC hdc, CELL &cell)
606        {
607                GetImageList().Draw(hdc, cell.Index(), cell.Left(true), cell.Top(true), 
608                        cell.Index() == (INT)m_Data ? ILD_SELECTED : ILD_NORMAL);
609        }
610
611        void FocusSelection(HDC hdc)
612        {
613                RECT rect = CELL((INT)m_Data).Rect();
614                CDCHandle(hdc).DrawFocusRect(&rect);
615        }
616
617        bool Paint(HDC hdc)
618        {
619                PrePaint(hdc);
620                PaintCells(hdc);
621                FocusSelection(hdc);
622                return true;
623        }
624
625// Operation
626        static int TrackCellMenu(POINT pt, UINT uFlags = 0, LPARAM lParam = 0, HWND hWndParent = GetActiveWindow())
627        {
628                const SIZE sAll = MenuSize();
629
630                // Horizontal position
631                if (uFlags & TPM_RIGHTALIGN)
632                        pt.x -= sAll.cx;
633                else if (uFlags & TPM_CENTERALIGN)
634                        pt.x -= sAll.cx / 2;
635                // Try to stay inside parent
636                if (pt.x < 0)
637                        pt.x = 0;
638                else 
639                {
640                        int xmax = GetDeviceCaps(::GetDC(hWndParent), HORZRES);
641                        if ((pt.x + sAll.cx) > xmax)
642                                pt.x = xmax - sAll.cx;
643                }
644
645                // Vertical position
646                if (uFlags & TPM_BOTTOMALIGN)
647                        pt.y -= sAll.cy;
648                else if (uFlags & TPM_VCENTERALIGN)
649                        pt.y -= sAll.cy / 2;
650                // Try to stay inside parent
651                if (pt.y < 0)
652                        pt.y = 0;
653                else
654                {
655                        int ymax = GetDeviceCaps(::GetDC(hWndParent), VERTRES);
656                        if ((pt.y + sAll.cy) > ymax)
657                                pt.y = ymax - sAll.cy;
658                }
659
660                // Return user selection
661                return CCellMenu(pt).DoModal(hWndParent, lParam);
662        }
663
664        // Implementation
665        void  UpdateSelection(CELL &cell)
666        {
667                RECT r = CELL((INT)m_Data).Rect();
668                InvalidateRect(&r, FALSE);
669                r = cell.Rect();
670                InvalidateRect(&r, FALSE);
671                m_Data = cell.Index();
672        }
673
674        static CImageList& GetImageList()
675        {
676                static CImageList iml;
677                if (iml.IsNull())
678#ifndef _WIN32_WCE
679                        iml.CreateFromImage(t_uIDD, CELL::Size().cx - 2 * CELL::Cxy(), 0, 
680                                AtlIsAlphaBitmapResource(t_uIDD) ? CLR_NONE : CLR_DEFAULT,
681                                IMAGE_BITMAP, LR_CREATEDIBSECTION | LR_DEFAULTSIZE);
682#else
683                        iml.Create(t_uIDD, CELL::Size().cx - 2 * CELL::Cxy(), 0, CLR_DEFAULT);
684#endif // _WIN32_WCE
685                ATLASSERT(!iml.IsNull());
686                return iml;
687        }
688
689        // Message map and handlers
690        BEGIN_MSG_MAP(CCellMenu)
691                MESSAGE_RANGE_HANDLER(WM_MOUSEFIRST, WM_MOUSELAST, OnMouse)
692                MESSAGE_RANGE_HANDLER(WM_KEYFIRST, WM_KEYLAST, OnKey)
693                CHAIN_MSG_MAP(MenuDialog)
694                CHAIN_MSG_MAP(EmptyDialog)
695        END_MSG_MAP()
696               
697        LRESULT OnMouse(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
698        {
699                bHandled = Mouse(uMsg, wParam, lParam);
700                return 0;
701        }
702
703        LRESULT OnKey(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
704        {
705#if defined(WIN32_PLATFORM_WFSP)
706                if( wParam == VK_TBACK) // SmartPhone back key
707                        Close(IDCANCEL);
708                else
709#endif
710                        bHandled = Key(uMsg, wParam, lParam);
711                return 0;
712        }
713
714        // Cell constants overrideables
715        static const SIZE CellSize()
716        {
717                SIZE size;
718                CBitmap bm = AtlLoadBitmap(t_uIDD);
719
720                if (bm.IsNull())
721                {
722                        size.cx = GetSystemMetrics(SM_CXSMICON) + 2 * CELL::Cxy();
723                        size.cy = GetSystemMetrics(SM_CYSMICON) + 2 * CELL::Cxy();
724                }
725                else
726                {
727                        SIZE sbm;
728                        bm.GetSize(sbm);
729                        size.cx = sbm.cx / (t_nCol * t_nRow) + 2 * CELL::Cxy();
730                        size.cy = sbm.cy + 2 * CELL::Cxy();
731                }
732                return size;
733        }
734
735        static const SIZE MenuSize() 
736        {
737                static SIZE sMenu = {CELL::Size().cx * t_nCol + CELL::Cxy() - 1, 
738                        CELL::Size().cy * t_nRow + CELL::Cxy() - 1};
739                return sMenu;
740        }
741};
742
743#if (_MSC_VER >= 1300) && (_ATL_VER >= 0x700)// VC7.0 and over except VCExpress-ATL3
744
745template <UINT t_uIDD, INT t_nCol, INT t_nRow>
746#ifdef _WTL_CE_DRA // Mobile resolution awareness
747_declspec(selectany) const int CCellMenu<t_uIDD, t_nCol, t_nRow>::CELL::cxy = DRA::SCALEX(2);
748#else
749_declspec(selectany) const int CCellMenu<t_uIDD, t_nCol, t_nRow>::CELL::cxy = 2;
750#endif
751
752template <UINT t_uIDD, INT t_nCol, INT t_nRow>
753_declspec(selectany) const SIZE CCellMenu<t_uIDD, t_nCol, t_nRow>::CELL::size = CellSize();
754
755#endif // (_MSC_VER >= 1300) && (_ATL_VER >= 0x700)
756
757// -- Single control dialog classes
758
759///////////////////////////////////////////////////////////////////////////////
760// CControlDialogImpl - Single control dialog implementation
761//
762
763typedef ATL::CWinTraits<WS_VISIBLE | WS_POPUP | WS_CAPTION | WS_SYSMENU | DS_CENTER, WS_EX_DLGMODALFRAME> CControlDlgTraits;
764
765template
766        < class T,              // Actual dialog class: ie CMyControlDialog
767        UINT t_uIDD,    // Dialog IDD, title, icon, toolbar, menu (if matching resources exist)
768        class TCtrl,    // Control class
769        class TControlTraits // Control styles
770                = ATL::CControlWinTraits,       // default control styles
771        class TDlgImpl  // Empty dialog base class
772                = CEmptyDialogImpl<T, t_uIDD, CControlDlgTraits> // default for TDlgImpl
773        >
774class CControlDialogImpl : 
775        public TDlgImpl
776{
777        typedef CControlDialogImpl<T, t_uIDD, TCtrl, TControlTraits, TDlgImpl> thisClass;
778public:
779        typedef thisClass ControlDialog;
780
781// Construction
782        CControlDialogImpl(){}
783        CControlDialogImpl(SIZE size, bool bDLU = true) : EmptyDialog(size, bDLU){}
784        CControlDialogImpl(POINT point, SIZE size, bool bDLU = true) : EmptyDialog(point, size, bDLU){}
785        CControlDialogImpl(RECT rect, bool bDLU = true) : EmptyDialog(rect, bDLU){}
786
787// Control member
788        TCtrl m_Ctrl;
789
790// Overrideables
791        bool Init(LPARAM lParam)
792        {
793                return DefInit(lParam);
794        }
795
796        bool Size(WPARAM wParam, LPARAM lParam)
797        {
798                return DefSize(wParam, lParam); 
799        }
800
801        bool Notify(int /*idCtrl*/, LPNMHDR /*pnmhdr*/)
802        {
803                return false;
804        }
805
806        bool Command(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/)
807        {
808                return false;
809        }
810
811        bool Key(UINT /*uMsg*/, WPARAM /*wParam*/,LPARAM /*lParam*/)
812        {
813                return false;
814        }
815
816        HBRUSH CtlColor(HDC /*hdc*/)
817        {
818                return NULL;
819        }
820
821        // Implementation
822        bool DefInit(LPARAM lParam)
823        {
824                EmptyDialog::Init(lParam);
825                ControlInit();
826                return false; 
827        }
828
829        void ControlInit()
830        {
831                RECT rCtrl;
832                GetClientRect(&rCtrl);
833                ATLVERIFY(m_Ctrl.Create(m_hWnd, rCtrl, NULL, 
834                        TControlTraits::GetWndStyle(0), 
835                        TControlTraits::GetWndExStyle(0), ATL_IDM_WINDOW_FIRST));
836                m_Ctrl.SetFocus();
837        }
838
839        bool DefSize(WPARAM wParam, LPARAM /*lParam*/)
840        {
841                if (m_Ctrl.IsWindow() && wParam != SIZE_MINIMIZED)
842                {
843                        RECT rClient;
844                        GetClientRect(&rClient);
845                        m_Ctrl.MoveWindow(&rClient);
846                }
847                return false; 
848        }
849
850        BEGIN_MSG_MAP(CControlDialogImpl)
851                MESSAGE_HANDLER(WM_NOTIFY, OnNotify)
852                MESSAGE_HANDLER(WM_COMMAND, OnCommand)
853                MESSAGE_HANDLER(WM_SETFOCUS, OnSetFocus)
854                MESSAGE_RANGE_HANDLER(WM_CTLCOLOREDIT, WM_CTLCOLORSTATIC, OnCtlColor)
855                MESSAGE_RANGE_HANDLER(WM_KEYFIRST, WM_KEYLAST, OnKey)
856                CHAIN_MSG_MAP(EmptyDialog)
857                REFLECT_NOTIFICATIONS()
858        END_MSG_MAP()
859
860        LRESULT OnCtlColor(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
861        {
862                return (LRESULT)static_cast<T*>(this)->CtlColor((HDC)wParam);
863        }
864
865        LRESULT OnSetFocus(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
866        {
867                if (m_Ctrl.IsWindow())
868                        m_Ctrl.SetFocus();
869                return 0;
870        }
871
872        LRESULT OnNotify(UINT /*uMsg*/, WPARAM wParam/**/, LPARAM lParam/**/, BOOL& bHandled)
873        {
874                return bHandled = static_cast<T*>(this)->Notify((int) wParam, (LPNMHDR)lParam);
875        }
876
877        LRESULT OnCommand(UINT /*uMsg*/, WPARAM wParam/**/, LPARAM lParam/**/, BOOL& bHandled)
878        {
879                bHandled = static_cast<T*>(this)->Command(HIWORD(wParam), LOWORD(wParam), (HWND)lParam);
880                return !bHandled;
881        }
882
883        LRESULT OnKey(UINT uMsg/**/, WPARAM wParam/**/, LPARAM lParam/**/, BOOL& bHandled)
884        {
885                return bHandled = static_cast<T*>(this)->Key(uMsg, wParam, lParam);
886        }
887
888};
889
890///////////////////////////////////////////////////////////////////////////////
891// CControlDialog - Specializable single control dialog
892//
893
894template
895        < UINT t_uIDD,          // Dialog IDD, title, icon, toolbar, menu (if matching resources exist)
896        class TCtrl,            // Control class
897        class TControlTraits    // Control styles
898                = ATL::CControlWinTraits,       // default for TControlTraits   
899        class TControlDlgTraits         // Dialog styles
900                = CControlDlgTraits             // default for TControlDlgTraits
901        >
902class CControlDialog : 
903        public CControlDialogImpl< 
904                /*thisClass*/CControlDialog<t_uIDD, TCtrl, TControlTraits, TControlDlgTraits>, 
905                t_uIDD, 
906                TCtrl, 
907                TControlTraits, 
908                /*TDlgImpl*/CEmptyDialogImpl< 
909                        /*thisClass*/CControlDialog<t_uIDD, TCtrl, TControlTraits, TControlDlgTraits> , 
910                        t_uIDD, 
911                        /*TDlgTemplate*/CEmptyDlgTemplate<t_uIDD, TControlDlgTraits> 
912                > // CEmptyDialogImpl
913        > // CControlDialogImpl
914{
915        typedef CControlDialog<t_uIDD, TCtrl, TControlTraits, TControlDlgTraits> thisClass;
916public:
917        // Constructors
918        CControlDialog(){}
919        CControlDialog(SIZE size, bool bDLU = true) : ControlDialog(size, bDLU){}
920        CControlDialog(POINT point, SIZE size, bool bDLU = true) : ControlDialog(point, size, bDLU){}
921        CControlDialog(RECT rect, bool bDLU = true) : ControlDialog(rect, bDLU){}
922
923};
924
925////////////////////////////////////////////////////////////
926// CInPlaceEditor : In place editing dialog
927//
928typedef ATL::CWinTraitsOR<ES_AUTOHSCROLL> CInPlaceEditTraits;
929
930template <
931        UINT t_uLength, // length of text buffer passed as lParam in DoModal() call
932        class TEditCtrl // edit control class
933                = CEdit,        // default for TEditCtrl
934        class TEditTraits       // edit control styles
935                = CInPlaceEditTraits // default for TEditTraits
936        >
937class CInPlaceEditor : 
938        public CControlDialogImpl<
939                /*thisClass*/CInPlaceEditor<t_uLength, TEditCtrl, TEditTraits>, 
940                /*t_uIDD*/t_uLength, 
941                /*TCtrl*/TEditCtrl, 
942                /*TCtrlTraits*/TEditTraits,
943                /*TDlgImpl*/CEmptyDialogImpl<
944                        /*thisClass*/CInPlaceEditor<t_uLength, TEditCtrl, TEditTraits>,
945                        /*t_uIDD*/t_uLength, 
946                        /*TDlgTemplate*/CMenuDlgTemplate
947                        > // CEmptyDialogImpl
948                >, // CControlDialogImpl
949        public CMenuDialog<CInPlaceEditor<t_uLength, TEditCtrl, TEditTraits> >
950{
951        typedef CInPlaceEditor<t_uLength, TEditCtrl, TEditTraits> thisClass;
952public:
953        // Constructor
954        CInPlaceEditor(RECT rect) : ControlDialog(rect)
955        {}
956
957        // Operation
958        static bool Edit(RECT& rEdit, LPTSTR sText, HWND hwndParent = GetActiveWindow())
959        {
960                return thisClass(rEdit).DoModal(hwndParent, (LPARAM)sText) == IDOK;
961        }
962
963        // Specialized
964        bool Init(LPARAM lParam)
965        {
966                return DefInit(lParam);
967        }
968
969        // Implementation
970        bool DefInit(LPARAM lParam)
971        {
972                m_Data = lParam;
973                m_Template.Reset(); // free DLGTEMPLATE memory
974                ControlInit();
975
976                if (!m_Ctrl.GetFont())
977                        m_Ctrl.SetFont(AtlGetDefaultGuiFont());
978                m_Ctrl.LimitText(t_uLength);
979
980                if(lParam)
981                {
982                        ATLASSERT(!IsBadWritePtr((LPVOID)lParam, t_uLength * sizeof(TCHAR)));
983                        m_Ctrl.SetWindowText((LPCTSTR)lParam);
984                        m_Ctrl.SetSel((INT)t_uLength, t_uLength);
985                }
986                return false;
987        }
988
989        HBRUSH CtlColor(HDC /*hdc*/)
990        {
991                return GetSysColorBrush(COLOR_HIGHLIGHT);
992        }
993
994        void Close(INT iCmd) 
995        {
996                if((iCmd == IDOK) && m_Data)
997                        m_Ctrl.GetWindowText((LPTSTR)m_Data, t_uLength);
998                EmptyDialog::Close(iCmd);
999        }
1000
1001        // Message map
1002        BEGIN_MSG_MAP(CInPlaceEditor)
1003                CHAIN_MSG_MAP(CMenuDialog<thisClass>)
1004                CHAIN_MSG_MAP(ControlDialog)
1005        END_MSG_MAP()
1006
1007};
1008
1009// Split dialog classes
1010
1011///////////////////////////////////////////////////////////////////////////////
1012// CSplitDialogImpl - Split dialog implementation
1013//
1014
1015typedef ATL::CWinTraitsOR<WS_THICKFRAME, 0, CControlDlgTraits> CSplitDlgTraits;
1016
1017typedef ATL::CWinTraitsOR<WS_TABSTOP> CSplitControlTraits;
1018
1019template<UINT t_uIDD>
1020class CSplitDlgTemplate : public CEmptyDlgTemplate<t_uIDD, CSplitDlgTraits>
1021{};
1022
1023template
1024        < class T,              // Actual dialog class: ie CMySplitDialog
1025        UINT t_uIDD,    // Dialog IDD, title, icon, toolbar, menu (if matching resources exist)
1026        class TSplitImpl,       // Splitter implementation class: ie WTL::CSplitterImpl<CMySplitDialog, true>
1027        class TLeft,            // Left (or top) control class
1028        class TRight,           // Right (or bottom) control class
1029        class TLeftTraits       // Left (or top) control styles
1030                = CSplitControlTraits,  // default for TLeftTraits
1031        class TRightTraits      // Right (or bottom) control styles
1032                = CSplitControlTraits,  // default for TRightTraits
1033        class TDlgImpl  // Empty dialog base class
1034                = CEmptyDialogImpl<T, t_uIDD, CSplitDlgTemplate<t_uIDD> > // default for TDlgImpl
1035        >               
1036class ATL_NO_VTABLE CSplitDialogImpl : 
1037        public TDlgImpl, 
1038        public TSplitImpl
1039{
1040        typedef CSplitDialogImpl<T, t_uIDD, TSplitImpl, TLeft, TRight, TLeftTraits, TRightTraits, TDlgImpl> thisClass;
1041public:
1042        typedef thisClass SplitDialog;
1043        typedef TSplitImpl Splitter;
1044// Construction
1045        CSplitDialogImpl(){}
1046        CSplitDialogImpl(SIZE size, bool bDLU = true) : EmptyDialog(size, bDLU){}
1047        CSplitDialogImpl(POINT point, SIZE size, bool bDLU = true) : EmptyDialog(point, size, bDLU){}
1048        CSplitDialogImpl(RECT rect, bool bDLU = true) : EmptyDialog(rect, bDLU){}
1049
1050        // Control members
1051        TLeft m_Left;   // Left or top control member
1052        TRight m_Right; // Right or bottom control member
1053
1054// Overrideable
1055        bool Init(LPARAM lParam)
1056        {
1057                return DefInit(lParam);
1058        }
1059
1060        bool Size(WPARAM wParam, LPARAM /*lParam*/)
1061        {
1062                if(wParam != SIZE_MINIMIZED)
1063                        Splitter::SetSplitterRect();
1064                return false;
1065        }
1066
1067        bool Notify(int /*idCtrl*/, LPNMHDR pnmhdr)
1068        {
1069                return false;
1070        }
1071
1072        HBRUSH CtlColor(HDC /*hdc*/, HWND /*hWnd*/)
1073        {
1074                return NULL;
1075        }
1076
1077        bool Command(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/)
1078        {
1079                return static_cast<T*>(this)->PaneCommand(wID);
1080        }
1081
1082// Implementation
1083        bool DefInit(LPARAM lParam)
1084        {
1085                EmptyDialog::Init(lParam);
1086                Splitter::GetSystemSettings(false);
1087
1088                m_Left.Create(m_hWnd, rcDefault, NULL, TLeftTraits::GetWndStyle(0), TLeftTraits::GetWndExStyle(0), ATL_IDM_WINDOW_FIRST);
1089                m_Right.Create(m_hWnd, rcDefault, NULL, TRightTraits::GetWndStyle(0), TRightTraits::GetWndExStyle(0), ATL_IDM_WINDOW_LAST);
1090                Splitter::SetSplitterPanes(m_Left, m_Right);
1091
1092                Splitter::SetSplitterRect();
1093                Splitter::SetSinglePaneMode();
1094                Splitter::SetSplitterPos();
1095               
1096                return false;// WM_INITDIALOG not handled
1097        }
1098
1099        // Pane related commands
1100        bool PaneCommand(WORD wID)
1101        {
1102                switch(wID)
1103                {
1104                case ID_WINDOW_SPLIT:
1105                        Splitter::SetSinglePaneMode(Splitter::GetSinglePaneMode() == SPLIT_PANE_NONE ? 
1106                                Splitter::GetActivePane() : SPLIT_PANE_NONE);
1107                        break;
1108                case ID_NEXT_PANE:
1109                case ID_PREV_PANE:
1110                        if (Splitter::GetSinglePaneMode() != SPLIT_PANE_NONE)
1111                                Splitter::SetSinglePaneMode(!Splitter::GetActivePane());
1112                        else
1113                                Splitter::ActivateNextPane();
1114                        break;
1115                default:
1116                        return false;
1117                }
1118#if defined(__ATLWINCE_H__)
1119                SetFocus();
1120#endif
1121                return true;
1122        }
1123
1124        // CSplitterImpl requires this
1125        LRESULT DefWindowProc(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/)
1126        {
1127                return NULL;
1128        }
1129
1130// Message map and handlers
1131        BEGIN_MSG_MAP(CSplitDialogImpl)
1132                MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBkgnd)
1133                MESSAGE_RANGE_HANDLER(WM_CTLCOLOREDIT, WM_CTLCOLORSTATIC, OnCtlColor)
1134                MESSAGE_HANDLER(WM_NOTIFY, OnNotify)
1135                MESSAGE_HANDLER(WM_COMMAND, OnCommand)
1136                CHAIN_MSG_MAP(EmptyDialog)
1137                CHAIN_MSG_MAP(Splitter)
1138                REFLECT_NOTIFICATIONS()
1139        END_MSG_MAP()
1140
1141        LRESULT OnEraseBkgnd(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
1142        {
1143                Splitter::DrawSplitterBar((HDC)wParam);
1144                return TRUE; // background is erased
1145        }
1146
1147        LRESULT OnNotify(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1148        {
1149                return bHandled = static_cast<T*>(this)->Notify((int)wParam, (LPNMHDR)lParam);
1150        }
1151
1152        LRESULT OnCtlColor(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
1153        {
1154                return (LRESULT)static_cast<T*>(this)->CtlColor((HDC)wParam, (HWND)lParam);
1155        }
1156
1157        LRESULT OnCommand(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
1158        {
1159                bHandled = static_cast<T*>(this)->Command(HIWORD(wParam), LOWORD(wParam), (HWND)lParam);
1160                return !bHandled;
1161        }
1162
1163};
1164
1165/////////////////////////////////////////////////////////////////
1166// CSplitDialog - Generic split dialog
1167//
1168
1169template
1170        < UINT t_uIDD,  // Dialog IDD, title, icon, toolbar, menu (if matching resources exist)
1171        class TSplitImpl,       // Splitter implementation class: ie WTL::CSplitterImpl<CMySplitDialog, true>
1172        class TLeft,            // Left (or top) control class
1173        class TRight,           // Right (or bottom) control class
1174        class TLeftTraits       // Left (or top) control styles
1175                = CSplitControlTraits,  // default for TLeftTraits
1176        class TRightTraits      // Right (or bottom) control styles
1177                = CSplitControlTraits,  // default for TRightTraits
1178        class TSplitDialogTraits        // Dialog styles
1179                = CSplitDlgTraits       // default for TSplitDialogTraits
1180        >
1181class CSplitDialog : 
1182        public CSplitDialogImpl<
1183                /*thisClass*/CSplitDialog<t_uIDD, TSplitImpl, TLeft, TRight, TLeftTraits, TRightTraits, TSplitDialogTraits>, 
1184                t_uIDD, 
1185                TSplitImpl, 
1186                TLeft, 
1187                TRight, 
1188                TLeftTraits, 
1189                TRightTraits,
1190                /*TDlgImpl*/CEmptyDialogImpl< 
1191                        /*thisClass*/CSplitDialog<t_uIDD, TSplitImpl, TLeft, TRight, TLeftTraits, TRightTraits, TSplitDialogTraits>, 
1192                        t_uIDD,
1193                        /*TDlgTemplate*/CEmptyDlgTemplate<t_uIDD, TSplitDialogTraits> 
1194                > // CEmptyDialogImpl
1195        > // CSplitDialogImpl
1196{
1197        typedef CSplitDialog<t_uIDD, TSplitImpl, TLeft, TRight, TLeftTraits, TRightTraits, TSplitDialogTraits> thisClass;
1198public:
1199// Constructors
1200        CSplitDialog(){}
1201        CSplitDialog(SIZE size, bool bDLU = true) : SplitDialog(size, bDLU){}
1202        CSplitDialog(POINT point, SIZE size, bool bDLU = true) : SplitDialog(point, size, bDLU){}
1203        CSplitDialog(RECT rect, bool bDLU = true) : SplitDialog(rect, bDLU){}
1204
1205};
1206
1207#ifdef __ATLSPLIT_H__
1208
1209/////////////////////////////////////////////////////////////////
1210// CVSplitDialog - Vertical WTL::CSplitterImpl based split dialog
1211//
1212
1213template // see CSplitDialog template parameters description
1214        < UINT t_uIDD,
1215        class TLeft, class TRight, 
1216        class TLeftTraits = ATL::CControlWinTraits, 
1217        class TRightTraits = ATL::CControlWinTraits, 
1218        class TSplitDialogTraits = CSplitDlgTraits
1219        >
1220class CVSplitDialog : 
1221        public CSplitDialogImpl<
1222                /*thisClass*/CVSplitDialog<t_uIDD, TLeft, TRight, TLeftTraits, TRightTraits, TSplitDialogTraits>, 
1223                t_uIDD, 
1224                /*TSplitImpl*/CSplitterImpl<
1225                        /*thisClass*/CVSplitDialog<t_uIDD, TLeft, TRight, TLeftTraits, TRightTraits, TSplitDialogTraits>,
1226                        true
1227                        >, // CSplitterImpl
1228                TLeft, TRight, TLeftTraits, TRightTraits,
1229                /*TDlgImpl*/CEmptyDialogImpl< 
1230                        /*thisClass*/CVSplitDialog<t_uIDD, TLeft, TRight, TLeftTraits, TRightTraits,TSplitDialogTraits> , 
1231                        t_uIDD,
1232                        /*TDlgTemplate*/CEmptyDlgTemplate<t_uIDD, TSplitDialogTraits> 
1233                > // CEmptyDialogImpl 
1234        > // CSplitDialogImpl
1235{
1236        typedef CVSplitDialog<t_uIDD, TLeft, TRight, TLeftTraits, TRightTraits, TSplitDialogTraits> thisClass;
1237public:
1238// Constructors
1239        CVSplitDialog(){}
1240        CVSplitDialog(SIZE size, bool bDLU = true) : SplitDialog(size, bDLU){}
1241        CVSplitDialog(POINT point, SIZE size, bool bDLU = true) : SplitDialog(point, size, bDLU){}
1242        CVSplitDialog(RECT rect, bool bDLU = true) : SplitDialog(rect, bDLU){}
1243
1244};
1245
1246/////////////////////////////////////////////////////////////////
1247// CHSplitDialog - Horizontal WTL::CSplitterImpl based split dialog
1248//
1249
1250template // see CSplitDialog template parameters description
1251        < UINT t_uIDD, 
1252        class TLeft, class TRight, 
1253        class TLeftTraits = ATL::CControlWinTraits, 
1254        class TRightTraits = ATL::CControlWinTraits, 
1255        class TSplitDialogTraits = CSplitDlgTraits
1256        >
1257class CHSplitDialog : 
1258        public CSplitDialogImpl<
1259                /*thisClass*/CHSplitDialog<t_uIDD, TLeft, TRight, TLeftTraits, TRightTraits, TSplitDialogTraits>, 
1260                t_uIDD, 
1261                /*TSplitImpl*/CSplitterImpl<
1262                        /*thisClass*/CHSplitDialog<t_uIDD, TLeft, TRight, TLeftTraits, TRightTraits, TSplitDialogTraits>, 
1263                        false
1264                        >, // CSplitterImpl
1265                TLeft, TRight, TLeftTraits, TRightTraits,
1266                /*TDlgImpl*/CEmptyDialogImpl< 
1267                        /*thisClass*/CHSplitDialog<t_uIDD, TLeft, TRight, TLeftTraits, TRightTraits,TSplitDialogTraits> , 
1268                        t_uIDD,
1269                        /*TDlgTemplate*/CEmptyDlgTemplate<t_uIDD, TSplitDialogTraits> 
1270                > // CEmptyDialogImpl 
1271        > // CSplitDialogImpl
1272{
1273        typedef CHSplitDialog<t_uIDD, TLeft, TRight, TLeftTraits, TRightTraits, TSplitDialogTraits> thisClass;
1274public:
1275// Constructors
1276        CHSplitDialog(){}
1277        CHSplitDialog(SIZE size, bool bDLU = true) : SplitDialog(size, bDLU){}
1278        CHSplitDialog(POINT point, SIZE size, bool bDLU = true) : SplitDialog(point, size, bDLU){}
1279        CHSplitDialog(RECT rect, bool bDLU = true) : SplitDialog(rect, bDLU){}
1280
1281};
1282#endif // __ATLSPLIT_H__
1283
1284#if defined __WTL_AERO_H__
1285
1286// Aero enabled classes
1287
1288namespace aero {
1289
1290//////////////////////////////////////////////////////////
1291// aero::CEmptyDialogImpl - Aero enabled CEmptyDialogImpl
1292
1293template
1294        < class T,              // Actual dialog class: ie CMyAeroEmptyDialog 
1295        UINT t_uIDD,    // Dialog IDD, title, icon, toolbar, menu (if matching resources exist)
1296        class TDlgTemplate      // In memory dialog template
1297                = CEmptyDlgTemplate<t_uIDD, CEmptyDlgTraits> // default for TDlgTemplate
1298        >
1299class ATL_NO_VTABLE CEmptyDialogImpl : 
1300        public WTL::CEmptyDialogImpl<
1301        T,
1302        t_uIDD, 
1303        TDlgTemplate,
1304        aero::CDialogImpl<T>
1305        > // WTL::CEmptyDialogImpl
1306{
1307        typedef aero::CEmptyDialogImpl<T, t_uIDD, TDlgTemplate> thisClass;
1308public:
1309        typedef aero::CDialogImpl<T> AeroDialog;
1310        typedef WTL::CEmptyDialogImpl<T, t_uIDD, TDlgTemplate, AeroDialog> BaseEmptyDialog;
1311        typedef thisClass EmptyDialog;
1312
1313// Constructors
1314        CEmptyDialogImpl(){}
1315
1316        CEmptyDialogImpl(SIZE size, bool bDLU = true) : BaseEmptyDialog(size, bDLU)
1317        {}
1318
1319        CEmptyDialogImpl(POINT point, SIZE size, bool bDLU = true) : BaseEmptyDialog(point, size, bDLU)
1320        {}
1321
1322        CEmptyDialogImpl(RECT rect, bool bDLU = true) : BaseEmptyDialog(rect, bDLU)
1323        {}
1324
1325        // Data member
1326        aero::CToolBarCtrl m_ATB;
1327
1328        // EmptyDialog::Init() override
1329        bool Init(LPARAM lParam)
1330        {
1331                bool bRes = DefInit(lParam);
1332                if (::IsWindow(m_hWndToolBar))
1333                        aero::Subclass(m_ATB, m_hWndToolBar);
1334                return bRes;
1335        }
1336
1337        // AeroDialog::Paint() override
1338        void Paint(CDCHandle /*dc*/, RECT& /*rClient*/, RECT& /*rView*/, RECT& /*rDest*/)
1339        {}
1340
1341        // EmptyDialog::Paint() override
1342        bool Paint(HDC /*hdc*/)
1343        {
1344                return false;
1345        }
1346
1347        // Message map
1348        BEGIN_MSG_MAP(CEmptyDialogImpl)
1349                CHAIN_MSG_MAP(AeroDialog)
1350                CHAIN_MSG_MAP(BaseEmptyDialog)
1351        END_MSG_MAP()
1352
1353};
1354
1355///////////////////////////////////////////////////////////////////////////////
1356// aero::CControlDialog - Aero enabled CControlDialog
1357//
1358
1359template
1360        < UINT t_uIDD,          // Dialog IDD, title, icon, toolbar, menu (if matching resources exist)
1361        class TCtrl,            // Aero enabled Control class
1362        class TControlTraits    // Control styles
1363                = ATL::CControlWinTraits,       // default for TControlTraits   
1364        class TControlDlgTraits         // Dialog styles
1365                = CControlDlgTraits             // default for TControlDlgTraits
1366        >
1367class CControlDialog : 
1368        public WTL::CControlDialogImpl< 
1369        /*thisClass*/aero::CControlDialog<t_uIDD, TCtrl, TControlTraits, TControlDlgTraits>, 
1370                t_uIDD, 
1371                TCtrl, 
1372                TControlTraits, 
1373                /*TDlgImpl*/aero::CEmptyDialogImpl< 
1374                        /*thisClass*/aero::CControlDialog<t_uIDD, TCtrl, TControlTraits, TControlDlgTraits> , 
1375                        t_uIDD, 
1376                        /*TDlgTemplate*/CEmptyDlgTemplate<t_uIDD, TControlDlgTraits> 
1377                > // aero::CEmptyDialogImpl
1378        > // WTL::CControlDialogImpl
1379{
1380        typedef aero::CControlDialog<t_uIDD, TCtrl, TControlTraits, TControlDlgTraits> thisClass;
1381public:
1382        // Constructors
1383        CControlDialog(){}
1384        CControlDialog(SIZE size, bool bDLU = true) : ControlDialog(size, bDLU){}
1385        CControlDialog(POINT point, SIZE size, bool bDLU = true) : ControlDialog(point, size, bDLU){}
1386        CControlDialog(RECT rect, bool bDLU = true) : ControlDialog(rect, bDLU){}
1387
1388};
1389
1390/////////////////////////////////////////////////////////////////
1391// aero::CSplitDialog - Aero enabled CSplitDialog
1392//
1393
1394template
1395        < UINT t_uIDD,  // Dialog IDD, title, icon, toolbar, menu (if matching resources exist)
1396        class TSplitImpl,       // Aero enabled splitter implementation class: ie aero::CSplitterImpl<CMySplitDialog, true>
1397        class TLeft,            // Aero enabled reft (or top) control class
1398        class TRight,           // Aero enabled right (or bottom) control class
1399        class TLeftTraits       // Left (or top) control styles
1400                = CSplitControlTraits,  // default for TLeftTraits
1401        class TRightTraits      // Right (or bottom) control styles
1402                = CSplitControlTraits,  // default for TRightTraits
1403        class TSplitDialogTraits        // Dialog styles
1404                = CSplitDlgTraits       // default for TSplitDialogTraits
1405        >
1406class CSplitDialog : 
1407        public WTL::CSplitDialogImpl<
1408        /*thisClass*/aero::CSplitDialog<t_uIDD, TSplitImpl, TLeft, TRight, TLeftTraits, TRightTraits, TSplitDialogTraits>, 
1409                t_uIDD, 
1410                TSplitImpl, 
1411                TLeft, 
1412                TRight, 
1413                TLeftTraits, 
1414                TRightTraits,
1415                /*TDlgImpl*/aero::CEmptyDialogImpl< 
1416                /*thisClass*/aero::CSplitDialog<t_uIDD, TSplitImpl, TLeft, TRight, TLeftTraits, TRightTraits, TSplitDialogTraits>, 
1417                        t_uIDD,
1418                        /*TDlgTemplate*/CEmptyDlgTemplate<t_uIDD, TSplitDialogTraits> 
1419                > // aero::CEmptyDialogImpl
1420        > // WTL::CSplitDialogImpl
1421{
1422        typedef aero::CSplitDialog<t_uIDD, TSplitImpl, TLeft, TRight, TLeftTraits, TRightTraits, TSplitDialogTraits> thisClass;
1423public:
1424// Constructors
1425        CSplitDialog(){}
1426        CSplitDialog(SIZE size, bool bDLU = true) : SplitDialog(size, bDLU){}
1427        CSplitDialog(POINT point, SIZE size, bool bDLU = true) : SplitDialog(point, size, bDLU){}
1428        CSplitDialog(RECT rect, bool bDLU = true) : SplitDialog(rect, bDLU){}
1429
1430};
1431
1432}; // namespace aero
1433
1434#endif // defined __WTL_AERO_H__
1435
1436// Windows Mobile classes
1437
1438#if defined(__ATLWINCE_H__) && !defined(_WTL_CE_NO_DIALOGS)
1439
1440///////////////////////////////////////////////////////////////////////////////
1441// CStdEmptyDialogImpl - base class for Mobile Device standard empty dialog classes
1442//
1443
1444typedef ATL::CWinTraits<WS_VISIBLE | DS_CENTER | WS_POPUP> CStdEmptyDlgTraits;
1445
1446template <UINT t_uIDS>
1447class CStdEmptyDlgTemplate : public CEmptyDlgTemplate<t_uIDS, CStdEmptyDlgTraits>
1448{};
1449
1450template
1451        < class T,              // Actual dialog class: ie CMyStdEmptyDialog
1452        UINT t_uIDD,    // Dialog IDD, title, MenuBar (if matching resources exist)
1453        UINT t_shidiFlags       // Position flags for ::SHInitDialog()
1454                = WTL_STD_SHIDIF,       // default for t_shidiFlags
1455        class TDlgTemplate      // In memory dialog template
1456                = CStdEmptyDlgTemplate<t_uIDD> // default for TDlgTemplate
1457        >
1458class ATL_NO_VTABLE CStdEmptyDialogImpl : 
1459        public CEmptyDialogImpl<
1460                T, 
1461                t_uIDD, 
1462                TDlgTemplate, 
1463                /*TBase*/CStdDialogImpl<T, t_shidiFlags, true> 
1464        > // CEmptyDialogImpl
1465{
1466        typedef CStdEmptyDialogImpl<T, t_uIDD, t_shidiFlags, TDlgTemplate> thisClass;
1467public:
1468        typedef CStdDialogImpl<T, t_shidiFlags, true> Std;
1469        //typedef CStdDialogImpl<thisClass, t_shidiFlags, true> Std;
1470        typedef thisClass EmptyDialog;
1471        typedef CEmptyDialogImpl<T, t_uIDD, TDlgTemplate, Std> BaseEmptyDialog;
1472        //typedef CEmptyDialogImpl<thisClass, t_uIDD, TDlgTemplate, Std> BaseEmptyDialog;
1473
1474        // Constructor
1475        CStdEmptyDialogImpl() 
1476        {
1477                m_Data = 0;
1478                SIZE size = {0};
1479                POINT pt = {0};
1480                m_Template.Create(pt, size);
1481        }
1482
1483        // Formal unimplemented constructors
1484        CStdEmptyDialogImpl(SIZE size, bool bDLU = true);
1485        CStdEmptyDialogImpl(POINT point, SIZE size, bool bDLU = true);
1486        CStdEmptyDialogImpl(RECT rect, bool bDLU = true);
1487
1488// Overrideable
1489        bool Init(LPARAM lParam)
1490        {
1491                return DefInit(lParam);
1492        }
1493
1494// Implementation
1495        bool DefInit(LPARAM lParam, UINT uiMB = 0, int nBmpImages = 0)
1496        {
1497#ifdef _DEBUG
1498                ATLASSERT(static_cast<T*>(this)->m_bModal);
1499#endif
1500                m_Data = lParam;
1501                m_Template.Reset(); // free DLGTEMPLATE memory
1502
1503                if (uiMB == 0)
1504                        uiMB = ::FindResource(ModuleHelper::GetResourceInstance(), MAKEINTRESOURCE(t_uIDD), RT_RCDATA) ? t_uIDD : ATL_IDM_MENU_DONECANCEL;
1505                CreateMenuBar(uiMB, nBmpImages);
1506
1507#if defined(WIN32_PLATFORM_WFSP)
1508                StdSPInit();
1509#endif
1510                StdShidInit();
1511                return false; 
1512        }
1513
1514#ifdef WIN32_PLATFORM_PSPC // WTL 8.0 bug fix
1515        BOOL GetClientRect(LPRECT lpRect) 
1516        {
1517                T* pT = static_cast<T*>(this);
1518                ATLASSERT(pT->IsWindow());
1519                BOOL bRes = ::GetClientRect(pT->m_hWnd, lpRect);
1520                if (nTitleHeight)
1521                        lpRect->top += nTitleHeight + 1;
1522                return bRes;
1523        }
1524#endif
1525
1526        // MenuBar command buttons helpers
1527#if _WIN32_WCE > 0x500 || defined WIN32_PLATFORM_PSPC // All platforms except SmartPhone 2003
1528        BOOL SetMenuBarCommand(INT iID, LPCTSTR psText, bool bRight = false)
1529        {
1530                CMenuBarCtrl mb = ::SHFindMenuBar(m_hWnd);
1531                ATLASSERT(mb.IsWindow());
1532                TBBUTTONINFO tbbi = {sizeof(TBBUTTONINFO), TBIF_TEXT | TBIF_COMMAND, iID};
1533                tbbi.pszText = (LPTSTR)psText;
1534
1535#if _WIN32_WCE > 0x500
1536                tbbi.dwMask |= TBIF_BYINDEX;
1537                return mb.SetButtonInfo(bRight, &tbbi);
1538#else
1539                TBBUTTON tbb = {0};
1540                ATLVERIFY(mb.GetButton(bRight, &tbb));
1541                return mb.SetButtonInfo(tbb.idCommand, &tbbi);
1542#endif // _WIN32_WCE > 0x500
1543        }
1544
1545        BOOL SetMenuBarCommand(INT iID, bool bRight = false)
1546        {
1547                return SetMenuBarCommand(iID, AtlLoadString(iID), bRight);
1548        }
1549#endif // _WIN32_WCE > 0x500 || defined WIN32_PLATFORM_PSPC
1550
1551        BOOL SetMenuBarCommand(UINT uOldId, UINT uNewId, LPTSTR sText = NULL)
1552        {
1553                CMenuBarCtrl mb = ::SHFindMenuBar(m_hWnd);
1554                ATLASSERT(mb.IsWindow());
1555
1556                TBBUTTONINFO tbbi = {sizeof(TBBUTTONINFO), TBIF_TEXT | TBIF_COMMAND, uNewId};
1557                tbbi.pszText = sText ? sText : (LPTSTR)AtlLoadString(uNewId);
1558
1559                return mb.SetButtonInfo(uOldId, &tbbi);
1560        }
1561
1562        // Message map and local handlers
1563        BEGIN_MSG_MAP(CStdEmptyDialogImpl)
1564                MESSAGE_ANSWER(WM_ERASEBKGND, TRUE)
1565                MESSAGE_HANDLER(WM_INITDIALOG, /*BaseEmptyDialog::*/OnInitDialog)
1566                MESSAGE_HANDLER(WM_SIZE, /*BaseEmptyDialog::*/OnSize)
1567                MESSAGE_HANDLER(WM_PAINT, /*thisClass::*/OnPaint)
1568#ifdef WIN32_PLATFORM_PSPC
1569                MESSAGE_HANDLER(WM_SETTINGCHANGE, /*Std::*/OnSettingChange)
1570#elif defined(WIN32_PLATFORM_WFSP)
1571                MESSAGE_HANDLER(WM_HOTKEY, /*Std::*/OnHotKey)
1572                MESSAGE_ANSWER(WM_GETDLGCODE, DLGC_WANTALLKEYS)
1573#endif
1574                COMMAND_RANGE_HANDLER(IDOK, IDCANCEL, /*BaseEmptyDialog::*/OnCloseCommand)
1575                COMMAND_RANGE_HANDLER(ID_MENU_OK, ID_MENU_CANCEL, /*thisClass::*/OnMenuClose)
1576        END_MSG_MAP()
1577
1578        LRESULT OnPaint(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
1579        {
1580                T* pT = static_cast<T*>(this);
1581#ifdef WIN32_PLATFORM_PSPC
1582                if(nTitleHeight)
1583                        pT->DoPaintTitle();
1584#endif
1585                return bHandled = pT->Paint((HDC)wParam);
1586        }
1587
1588        LRESULT OnMenuClose(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
1589        {
1590                static_cast<T*>(this)->Close(wID - ID_MENU_OK + IDOK);
1591                return 0;
1592        }
1593
1594};
1595
1596///////////////////////////////////////////////////////////////////////////////
1597// CStdControlDialog - Mobile Device specializable standard single control dialog class
1598//
1599
1600template
1601        < UINT t_uIDD,  // Dialog IDD, title, MenuBar (if matching resources exist)   
1602        class TCtrl,    // Control class
1603        class TControlTraits    // Control styles
1604                = ATL::CControlWinTraits,       // default for TControlTraits
1605        UINT t_shidiFlags       // Position flags for ::SHInitDialog()
1606                = WTL_STD_SHIDIF,       // default for t_shidiFlags
1607        class TDlgTemplate      // In memory dialog template
1608                = CStdEmptyDlgTemplate<t_uIDD> // default for TDlgTemplate
1609        >
1610class CStdControlDialog : 
1611        public CControlDialogImpl< 
1612                /*thisClass*/CStdControlDialog<t_uIDD, TCtrl, TControlTraits, t_shidiFlags, TDlgTemplate>, 
1613                t_uIDD, 
1614                TCtrl, 
1615                TControlTraits,
1616                /*TDlgImpl*/CStdEmptyDialogImpl<
1617                        /*thisClass*/CStdControlDialog<t_uIDD, TCtrl, TControlTraits, t_shidiFlags, TDlgTemplate> , 
1618                        t_uIDD, 
1619                        t_shidiFlags, 
1620                        TDlgTemplate
1621                        > //  CStdEmptyDialogImpl
1622                > // CControlDialogImpl
1623{
1624        typedef CStdControlDialog<t_uIDD, TCtrl, TControlTraits, t_shidiFlags, TDlgTemplate> thisClass;
1625};
1626
1627
1628///////////////////////////////////////////////////////////////////////////////
1629// CStdSplitDialog - Mobile Device specializable split standard dialog class
1630//
1631
1632typedef ATL::CWinTraitsOR<0, WS_EX_CLIENTEDGE, CStdEmptyDlgTraits> CStdSplitDlgTraits;
1633
1634template <UINT t_uIDS>
1635class CStdSplitDlgTemplate : public CEmptyDlgTemplate<t_uIDS, CStdSplitDlgTraits>
1636{};
1637
1638template
1639        < UINT t_uIDD,  // Dialog IDD, title, MenuBar (if matching resources exist) 
1640        class TSplitImpl,       // Splitter implementation class: ie WTL::CSplitterImpl<CMyStdSplitDialog, true>
1641        class TLeft,            // Left (or top) control class
1642        class TRight,           // Right (or bottom) control class
1643        class TLeftTraits       // Left (or top) control styles
1644                = CSplitControlTraits,  // default for TLeftTraits
1645        class TRightTraits      // Right (or bottom) control styles
1646                = CSplitControlTraits,  // default for TRightTraits
1647        UINT t_shidiFlags       // Position flags for ::SHInitDialog()
1648                = WTL_STD_SHIDIF,       // default for t_shidiFlags
1649        class TDlgTemplate      // In memory dialog template
1650                = CStdSplitDlgTemplate<t_uIDD> // default for TDlgTemplate
1651        >
1652class CStdSplitDialog : 
1653        public CSplitDialogImpl<
1654                /*thisClass*/CStdSplitDialog<t_uIDD, TSplitImpl, TLeft, TRight, TLeftTraits, TRightTraits, t_shidiFlags, TDlgTemplate>, 
1655                t_uIDD, 
1656                TSplitImpl, 
1657                TLeft, 
1658                TRight, 
1659                TLeftTraits, 
1660                TRightTraits, 
1661                /*TDlgImpl*/CStdEmptyDialogImpl <
1662                        /*thisClass*/CStdSplitDialog<t_uIDD, TSplitImpl, TLeft, TRight, TLeftTraits, TRightTraits, t_shidiFlags, TDlgTemplate>, 
1663                        t_uIDD, 
1664                        t_shidiFlags, 
1665                        TDlgTemplate
1666                        > //  CStdEmptyDialogImpl
1667                > // CSplitDialogImpl
1668{
1669        typedef CStdSplitDialog<t_uIDD, TSplitImpl, TLeft, TRight, TLeftTraits, TRightTraits, t_shidiFlags, TDlgTemplate> thisClass;
1670};
1671
1672#ifdef __ATLSPLIT_H__
1673
1674/////////////////////////////////////////////////////////////////
1675// CStdVSplitDialog - Vertical WTL::CSplitterImpl based Mobile split dialog
1676//
1677
1678template // see CStdSplitDialog template parameters description
1679        < UINT t_uIDD, 
1680        class TLeft, class TRight, 
1681        class TLeftTraits = CSplitControlTraits, 
1682        class TRightTraits = CSplitControlTraits, 
1683        UINT t_shidiFlags = WTL_STD_SHIDIF,
1684        class TDlgTemplate = CStdSplitDlgTemplate<t_uIDD>
1685        >
1686class CStdVSplitDialog : 
1687        public CSplitDialogImpl<
1688                /*thisClass*/CStdVSplitDialog<t_uIDD, TLeft, TRight, TLeftTraits, TRightTraits, t_shidiFlags, TDlgTemplate>, 
1689                t_uIDD, 
1690                /*TSplitImpl*/CSplitterImpl<
1691                        /*thisClass*/CStdVSplitDialog<t_uIDD, TLeft, TRight, TLeftTraits, TRightTraits, t_shidiFlags, TDlgTemplate>, 
1692                        true
1693                        >, // CSplitterImpl
1694                TLeft, 
1695                TRight, 
1696                TLeftTraits, 
1697                TRightTraits, 
1698                /*TDlgImpl*/CStdEmptyDialogImpl <
1699                        /*thisClass*/CStdVSplitDialog<t_uIDD, TLeft, TRight, TLeftTraits, TRightTraits, t_shidiFlags, TDlgTemplate>, 
1700                        t_uIDD, 
1701                        t_shidiFlags, 
1702                        TDlgTemplate
1703                        > // CEmptyDialogImpl
1704                > // CSplitDialogImpl
1705{
1706        typedef CStdVSplitDialog<t_uIDD, TLeft, TRight, TLeftTraits, TRightTraits, t_shidiFlags, TDlgTemplate> thisClass;
1707};
1708
1709/////////////////////////////////////////////////////////////////
1710// CStdHSplitDialog - Horizontal WTL::CSplitterImpl based Mobile split dialog
1711//
1712
1713template // see CStdSplitDialog template parameters description
1714        < UINT t_uIDD, 
1715        class TLeft, class TRight, 
1716        class TLeftTraits = CSplitControlTraits, 
1717        class TRightTraits = CSplitControlTraits, 
1718        UINT t_shidiFlags = WTL_STD_SHIDIF,
1719        class TDlgTemplate = CStdSplitDlgTemplate<t_uIDD>
1720        >
1721class CStdHSplitDialog : 
1722        public CSplitDialogImpl<
1723                /*thisClass*/CStdHSplitDialog<t_uIDD, TLeft, TRight, TLeftTraits, TRightTraits, t_shidiFlags, TDlgTemplate>, 
1724                t_uIDD, 
1725                /*TSplitImpl*/CSplitterImpl<
1726                        /*thisClass*/CStdHSplitDialog<t_uIDD, TLeft, TRight, TLeftTraits, TRightTraits, t_shidiFlags, TDlgTemplate>, 
1727                        false
1728                        >, // CSplitterImpl
1729                TLeft, 
1730                TRight, 
1731                TLeftTraits, 
1732                TRightTraits, 
1733                /*TDlgImpl*/CStdEmptyDialogImpl <
1734                        /*thisClass*/CStdHSplitDialog<t_uIDD, TLeft, TRight, TLeftTraits, TRightTraits, t_shidiFlags, TDlgTemplate>, 
1735                        t_uIDD, 
1736                        t_shidiFlags, 
1737                        TDlgTemplate
1738                        > // CEmptyDialogImpl
1739                > // CSplitDialogImpl
1740{
1741        typedef CStdHSplitDialog<t_uIDD, TLeft, TRight, TLeftTraits, TRightTraits, t_shidiFlags, TDlgTemplate> thisClass;
1742};
1743
1744#endif // __ATLSPLIT_H__
1745
1746#endif // defined(__ATLWINCE_H__) && !defined(_WTL_CE_NO_DIALOGS)
1747
1748
1749}; // namespace WTL
1750
1751#endif // __ATLDLGX_H__
Note: See TracBrowser for help on using the repository browser.