| // Windows Template Library - WTL version 8.0 |
| // Copyright (C) Microsoft Corporation. All rights reserved. |
| // |
| // This file is a part of the Windows Template Library. |
| // The use and distribution terms for this software are covered by the |
| // Microsoft Permissive License (Ms-PL) which can be found in the file |
| // Ms-PL.txt at the root of this distribution. |
| |
| #ifndef __ATLWINCE_H__ |
| #define __ATLWINCE_H__ |
| |
| #pragma once |
| |
| #ifndef __cplusplus |
| #error ATL requires C++ compilation (use a .cpp suffix) |
| #endif |
| |
| #ifndef __ATLAPP_H__ |
| #error atlwince.h requires atlapp.h to be included first |
| #endif |
| |
| #ifndef __ATLWIN_H__ |
| #error atlwince.h requires atlwin.h to be included first |
| #endif |
| |
| #ifndef _WIN32_WCE |
| #error atlwince.h compiles under Windows CE only |
| #elif (_WIN32_WCE < 300) |
| #error atlwince.h requires Windows CE 3.0 or higher. |
| #endif |
| |
| #if defined(WIN32_PLATFORM_WFSP) && _MSC_VER < 1400 // EVC compiling SmartPhone code |
| #if (WIN32_PLATFORM_WFSP < 200) |
| #error atlwince.h requires Smartphone 2003 or higher |
| #endif |
| #endif // WIN32_PLATFORM_WFSP |
| |
| #if defined(WIN32_PLATFORM_PSPC) && _MSC_VER < 1400 // EVC compiling Pocket PC code |
| #if (WIN32_PLATFORM_PSPC < 310) |
| #error atlwince.h requires Pocket PC 2002 or higher |
| #endif |
| #endif // WIN32_PLATFORM_PSPC |
| |
| #if !defined(_AYGSHELL_H_) && !defined(__AYGSHELL_H__) |
| #error atlwince.h requires aygshell.h to be included first |
| #else |
| #if defined(WIN32_PLATFORM_WFSP) && !defined(_TPCSHELL_H_) |
| #error SmartPhone dialog classes require tpcshell.h to be included first |
| #endif |
| #endif |
| |
| #if (_MSC_VER >= 1400) // VS2005 |
| #include <DeviceResolutionAware.h> |
| #define _WTL_CE_DRA |
| #endif // (_MSC_VER >= 1400) |
| |
| #if !defined(_WTL_CE_NO_DIALOGS) && !defined(__ATLFRAME_H__) |
| #error Orientation aware dialog classes require atlframe.h to be included first |
| #endif |
| |
| #if !defined(_WTL_CE_NO_APPWINDOW) && !defined(__ATLFRAME_H__) |
| #error Application window class require atlframe.h to be included first |
| #endif |
| |
| #if !defined(_WTL_CE_NO_ZOOMSCROLL) && !defined(__ATLSCRL_H__) |
| #error ZoomScroll implementation requires atlscrl.h to be included first |
| #endif |
| |
| #if !defined(_WTL_CE_NO_ZOOMSCROLL) |
| #if !(defined(__ATLTYPES_H__) || (defined(__ATLMISC_H__) && !defined(_WTL_NO_WTYPES))) |
| #error ZoomScroll requires _WTL_NO_WTYPES not to be defined and either atlmisc.h or atltypes.h to be included first |
| #endif // !(defined(__ATLTYPES_H__) || (defined(__ATLMISC_H__) && !defined(_WTL_NO_WTYPES))) |
| #endif // !defined(_WTL_CE_NO_ZOOMSCROLL) |
| |
| #if !defined(WIN32_PLATFORM_WFSP) && !defined(WIN32_PLATFORM_PSPC) |
| #define _WTL_CE_NO_CONTROLS |
| #endif // !defined(WIN32_PLATFORM_WFSP) && !defined(WIN32_PLATFORM_PSPC) |
| |
| #ifndef _WTL_CE_NO_CONTROLS |
| #ifndef __ATLCTRLS_H__ |
| #error The PPC/SmartPhone controls classes require atlctrls.h to be included first |
| #endif |
| |
| #include <htmlctrl.h> |
| #pragma comment(lib, "htmlview.lib") |
| |
| #include <voicectl.h> |
| #pragma comment(lib, "voicectl.lib") |
| |
| #ifdef WIN32_PLATFORM_PSPC |
| #include <richink.h> |
| #pragma comment(lib, "richink.lib") |
| |
| #include <inkx.h> |
| #pragma comment(lib, "inkx.lib") |
| |
| #include <doclist.h> |
| #pragma comment(lib, "doclist.lib") |
| #endif |
| #endif |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Classes in this file: |
| // |
| // CStdDialogBase<T, t_shidiFlags, t_bModal> : Standard PPC/SmartPhone dialog base class |
| // CStdDialogImplBase - Base implementation of standard dialog |
| // CStdDialogImpl<T, t_shidiFlags, t_bModal> : Standard dialog implementation |
| // CStdIndirectDialogImpl - implementation of standard indirect PPC/SmartPhone dialog |
| // CStdAxDialogImpl<T, t_shidiFlags, t_bModal> : Standard AxDialog implementation |
| // CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags> : Standard simple dialog |
| // CStdDialogResizeImplBase - Base implementation of orientation resizing standard dialog |
| // CStdDialogResizeImpl<T, t_shidiFlags, t_bModal> : Orientation resizing standard dialog implementation |
| // CStdAxDialogResizeImpl - implementation of orientation resizing standard AxDialog |
| // CStdSimpleDialogResizeImpl<T, t_wDlgTemplateID, t_shidiFlags> : Standard resizing simple dialog implementation |
| // CStdOrientedDialogBase - Oriented PPC standard dialog base class |
| // CStdOrientedDialogImplBase - Oriented PPC standard dialog base implementation |
| // CStdOrientedDialogImpl<T, t_shidiFlags, t_bModal> : Oriented PPC standard dialog implementation |
| // CStdAxOrientedDialogImpl - Oriented PPC standard AxDialog implementation |
| // CStdSimpleOrientedDialog<t_wDlgTemplateID, t_wDlgLandscapeID, t_shidiFlags> : Standard simple orientable dialog |
| // |
| // CAppInfoBase : Helper for application state save/restore to registry |
| // CAppInfoT<T> : CAppInfoBase constructed from a CAppWindow<T> |
| // CAppWindowBase<T> : Base class for PPC/SmartPhone well-behaved application window or dialog |
| // CAppWindow<T> : PPC/SmartPhone well-behaved application window class |
| // CAppDialog<T> : PPC/SmartPhone well-behaved application dialog class |
| // CAppStdDialogImplBase - Base implementation of standard application dialogs |
| // CAppStdDialogImpl<T, t_shidiFlags, t_bModal> : Implementation of standard application dialog |
| // CAppStdDialogResizeImpl - implementation of orientation resizing standard application dialog |
| // CAppStdAxDialogImpl - Implementation of standard application AxDialog |
| // CAppStdAxDialogResizeImpl - implementation of orientation resizing standard application AxDialog |
| // CAppStdOrientedDialogImpl - implementation of oriented PPC standard application dialog |
| // CAppStdAxOrientedDialogImpl - implementation of oriented PPC standard application AxDialog |
| // |
| // CFullScreenFrame<T, t_bHasSip> : Full screen frame class |
| // |
| // CZoomScrollImpl<T> : WinCE zooming implementation |
| // |
| // CBottomTabViewImpl<T, TBase, TWinTraits> - CBottomTabView |
| // CHtmlCtrlT<TBase> - CHtmlCtrl |
| // CRichInkCtrlT<TBase> - CRichInkCtrl |
| // CInkXCtrlT<TBase> - CInkXCtrl |
| // CVoiceRecorderCtrlT<TBase> - CVoiceRecorderCtrl |
| // CDocListCtrlT<TBase> - CDocListCtrl |
| // CCapEditT<TBase> - CCapEdit |
| // CTTStaticT<TBase> - CTTStatic |
| // CTTButtonT<TBase> - CTTButton |
| // |
| // CSpinCtrlT<TBase> - CSpinCtrl : SmartPhone specific UpDown control |
| // CSpinned<TBase, t_bExpandOnly> : SmartPhone association of control and Spin |
| // CSpinListBox : SmartPhone spinned ListBox control |
| // CExpandListBox : SmartPhone expandable ListBox control |
| // CExpandEdit : SmartPhone expandable Edit control |
| // CExpandCapEdit : SmartPhone expandable CapEdit control |
| // |
| // Global functions: |
| // AtlCreateMenuBar() |
| // AtlCreateEmptyMenuBar() |
| // AtlIsEditFocus() |
| // AtlActivateBackKey() |
| |
| namespace WTL |
| { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // MenuBar creation functions for property sheets and dialogs |
| // Frame windows use CreateSimpleCEMenuBar |
| |
| inline HWND AtlCreateMenuBar(SHMENUBARINFO& mbi) |
| { |
| ATLASSERT(::IsWindow(mbi.hwndParent)); |
| ATLVERIFY(::SHCreateMenuBar(&mbi) != FALSE); |
| return mbi.hwndMB; |
| }; |
| |
| inline HWND AtlCreateMenuBar(HWND hWnd, UINT nToolBarId = ATL_IDW_TOOLBAR, DWORD dwFlags = 0, int nBmpId = 0, int cBmpImages = 0, COLORREF clrBk = 0) |
| { |
| SHMENUBARINFO mbi = { sizeof(mbi), hWnd, dwFlags, nToolBarId, ModuleHelper::GetResourceInstance(), nBmpId, cBmpImages, 0, clrBk }; |
| return AtlCreateMenuBar(mbi); |
| } |
| |
| inline HWND AtlCreateEmptyMenuBar(HWND hWnd, bool bSip = true) |
| { |
| SHMENUBARINFO embi = { sizeof(SHMENUBARINFO), hWnd, SHCMBF_EMPTYBAR }; |
| if (!bSip) |
| embi.dwFlags |= SHCMBF_HIDESIPBUTTON; |
| |
| return AtlCreateMenuBar(embi); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Helper functions for SmartPhone back key handling |
| |
| inline bool AtlIsEditFocus() |
| { |
| ATL::CWindow wCtrl = GetFocus(); |
| if (wCtrl.IsWindow()) |
| { |
| TCHAR szClassName[8] = {0}; |
| ATLVERIFY(::GetClassName(wCtrl.m_hWnd, szClassName, 8)); |
| return !_tcscmp(szClassName, _T("Edit")) || !_tcscmp(szClassName, WC_CAPEDIT); |
| } |
| return false; |
| } |
| |
| #if defined WIN32_PLATFORM_WFSP |
| inline void AtlActivateBackKey(HWND hMenuBar) |
| { |
| ATLASSERT(::IsWindow(hMenuBar)); |
| ::SendMessage(hMenuBar, SHCMBM_OVERRIDEKEY, VK_TBACK, |
| MAKELPARAM(SHMBOF_NODEFAULT | SHMBOF_NOTIFY, SHMBOF_NODEFAULT | SHMBOF_NOTIFY)); |
| } |
| #endif // WIN32_PLATFORM_WFSP |
| |
| // --- Standard PPC/SmartPhone dialogs --- |
| |
| #ifndef _WTL_CE_NO_DIALOGS |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CStdDialogBase - base class for standard PPC/SmartPhone dialogs |
| |
| #define WTL_STD_SHIDIF SHIDIF_DONEBUTTON | SHIDIF_SIPDOWN | SHIDIF_SIZEDLGFULLSCREEN |
| #define WTL_SP_SHIDIF SHIDIF_SIZEDLGFULLSCREEN |
| |
| // Title setting macros |
| #define WTL_DLG_TITLEHEIGHT(iHeight) static const int GetTitleHeight(){return iHeight;} |
| #define WTL_DLG_NOTITLE WTL_DLG_TITLEHEIGHT(0) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CStdDialogBase - Base class for standard PPC/SmartPhone dialog |
| |
| template <class T, UINT t_shidiFlags, bool t_bModal = true> |
| class CStdDialogBase |
| { |
| public: |
| #ifdef WIN32_PLATFORM_PSPC |
| // Pocket PC only Dialog title handling |
| const int nTitleHeight; |
| |
| CStdDialogBase() : nTitleHeight(T::GetTitleHeight()) |
| { } |
| |
| // Overloads |
| BOOL GetClientRect(LPRECT lpRect) |
| { |
| T* pT = static_cast<T*>(this); |
| ATLASSERT(pT->IsWindow()); |
| BOOL bRes = ::GetClientRect(pT->m_hWnd, lpRect); |
| lpRect->top += nTitleHeight; |
| return bRes; |
| } |
| |
| BOOL SetWindowText(LPCTSTR lpszString) |
| { |
| T* pT = static_cast<T*>(this); |
| ATLASSERT(pT->IsWindow()); |
| BOOL bRes = ::SetWindowText(pT->m_hWnd, lpszString); |
| if (nTitleHeight != 0) |
| pT->DoPaintTitle(); |
| return bRes; |
| } |
| |
| // Overrideables |
| static const int GetTitleHeight() |
| { |
| #ifdef _WTL_CE_DRA |
| return DRA::SCALEY(24); |
| #else // !_WTL_CE_DRA |
| CWindowDC dc(NULL); |
| return dc.GetDeviceCaps(LOGPIXELSY) >> 2; // LOGPIXELSY * 24 / 96, |
| #endif // !_WTL_CE_DRA |
| } |
| |
| // Title painting |
| bool DoPaintTitle() |
| { |
| T* pT = static_cast<T*>(this); |
| ATLASSERT(pT->IsWindow()); |
| TCHAR sTitle[48]; |
| |
| // Preparation |
| CPaintDC dc(pT->m_hWnd); |
| CFont fontTitle = AtlCreateBoldFont(); |
| CFontHandle fontOld = dc.SelectFont(fontTitle); |
| dc.SetTextColor(GetSysColor(COLOR_HIGHLIGHT)); |
| int nLen = pT->GetWindowText(sTitle, 48); |
| int nWidth = dc.GetDeviceCaps(HORZRES); |
| |
| // Display title text |
| RECT rTitle = { 0, 0, nWidth, nTitleHeight }; |
| dc.FillRect(&rTitle, COLOR_3DHIGHLIGHT); |
| #ifdef _WTL_CE_DRA |
| rTitle.left = DRA::SCALEX(8); |
| #else // !_WTL_CE_DRA |
| rTitle.left = nTitleHeight / 3; // 8 == 24 / 3 |
| #endif // !_WTL_CE_DRA |
| dc.DrawText(sTitle, nLen, &rTitle, DT_VCENTER | DT_SINGLELINE); |
| dc.SelectFont(fontOld); |
| |
| // Draw bottom line, 2 pixels thick if HI_RES_AWARE |
| CPenHandle penOld = dc.SelectStockPen(BLACK_PEN); |
| POINT line[4] = {{0, nTitleHeight}, {nWidth, nTitleHeight}, {0, nTitleHeight - 1}, {nWidth, nTitleHeight - 1}}; |
| |
| #ifdef _WTL_CE_DRA |
| int nSeg = DRA::SCALEY(1); |
| #else // !_WTL_CE_DRA |
| int nSeg = nTitleHeight / 24; |
| #endif // !_WTL_CE_DRA |
| |
| dc.Polyline(line, nSeg <= 2 ? nSeg * 2 : 4); |
| dc.SelectPen(penOld); |
| |
| return false; |
| } |
| |
| // Title preparation: move the dialog controls down to make room for title |
| void DialogTitleInit() |
| { |
| T* pT = static_cast<T*>(this); |
| ATLASSERT(pT->IsWindow()); |
| |
| ATL::CWindow wCtl = pT->GetWindow(GW_CHILD); |
| while (wCtl.IsWindow()) |
| { |
| RECT rCtl = { 0 }; |
| wCtl.GetWindowRect(&rCtl); |
| ::MapWindowPoints(NULL, pT->m_hWnd, (LPPOINT)&rCtl, 2); |
| ::OffsetRect(&rCtl, 0, nTitleHeight); |
| wCtl.MoveWindow(&rCtl, FALSE); |
| wCtl = wCtl.GetWindow(GW_HWNDNEXT); |
| } |
| } |
| |
| // SIP management |
| void DoSipInfo() |
| { |
| T* pT = static_cast<T*>(this); |
| ATLASSERT(pT->IsWindow()); |
| |
| SIPINFO si = {sizeof(SIPINFO)}; |
| SipGetInfo(&si); |
| if ((si.fdwFlags & SIPF_ON) ^ SIPF_ON) |
| si.rcVisibleDesktop.bottom = si.rcSipRect.bottom; |
| pT->MoveWindow(&si.rcVisibleDesktop, FALSE); |
| } |
| |
| // Title painting handler |
| LRESULT OnPaintTitle(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| T* pT = static_cast<T*>(this); |
| return bHandled = nTitleHeight ? pT->DoPaintTitle() : FALSE; |
| } |
| |
| // SIP handler |
| LRESULT OnSettingChange(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| T* pT = static_cast<T*>(this); |
| if (wParam == SPI_SETSIPINFO) |
| { |
| pT->DoSipInfo(); |
| return TRUE; |
| } |
| return bHandled = FALSE; |
| } |
| |
| #elif defined WIN32_PLATFORM_WFSP |
| // SmartPhone VK_TBACK key standard management |
| LRESULT OnHotKey(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/) |
| { |
| T* pT = static_cast<T*>(this); |
| const UINT uModif = (UINT)LOWORD(lParam); |
| const UINT uVirtKey = (UINT)HIWORD(lParam); |
| |
| if(uVirtKey == VK_TBACK) |
| if (AtlIsEditFocus()) |
| ::SHSendBackToFocusWindow(uMsg, wParam, lParam); |
| else if (uModif & MOD_KEYUP) |
| pT->StdCloseDialog(IDCANCEL); |
| return 1; |
| } |
| |
| // SmartPhone MenuBar and VK_TBACK key initialization |
| void StdSPInit() |
| { |
| T* pT = static_cast<T*>(this); |
| HWND hMenuBar = ::SHFindMenuBar(pT->m_hWnd); |
| |
| if (!hMenuBar && (t_shidiFlags & SHIDIF_DONEBUTTON)) |
| hMenuBar = CreateMenuBar(ATL_IDM_MENU_DONE); |
| |
| if(hMenuBar != NULL) |
| AtlActivateBackKey(hMenuBar); |
| } |
| |
| void SetStaticBold() |
| { |
| T* pT = static_cast<T*>(this); |
| ATLASSERT(pT->IsWindow()); |
| |
| CFontHandle fontBold = AtlCreateBoldFont(pT->GetFont()); |
| |
| ATL::CWindow wCtl = pT->GetWindow(GW_CHILD); |
| |
| while (wCtl.IsWindow()) |
| { |
| if ((short int)wCtl.GetDlgCtrlID() == IDC_STATIC) |
| wCtl.SetFont(fontBold); |
| wCtl = wCtl.GetWindow(GW_HWNDNEXT); |
| } |
| } |
| #endif // WIN32_PLATFORM_WFSP |
| |
| // Platform dependant initialization |
| void StdPlatformInit() |
| { |
| T* pT = static_cast<T*>(this); |
| #ifdef WIN32_PLATFORM_PSPC // Pocket PC title initialization |
| if (nTitleHeight != 0) |
| pT->DialogTitleInit(); |
| #elif defined(WIN32_PLATFORM_WFSP) |
| pT->StdSPInit(); |
| SetStaticBold(); |
| #endif // WIN32_PLATFORM_WFSP |
| } |
| |
| // Menu bar creation |
| HWND CreateMenuBar(UINT uiMB = T::IDD, int nBmpImages = 0) |
| { |
| T* pT = static_cast<T*>(this); |
| return AtlCreateMenuBar(pT->m_hWnd, uiMB, 0, nBmpImages ? uiMB : 0, nBmpImages); |
| } |
| |
| // Dialog closing |
| void StdCloseDialog(WORD wID) |
| { |
| T* pT = static_cast<T*>(this); |
| if (t_bModal) |
| ::EndDialog(pT->m_hWnd, wID); |
| else |
| pT->DestroyWindow(); |
| } |
| |
| // Shell dialog layout initialization |
| void StdShidInit() |
| { |
| T* pT = static_cast<T*>(this); |
| SHINITDLGINFO shidi = { SHIDIM_FLAGS, pT->m_hWnd, t_shidiFlags }; |
| ::SHInitDialog(&shidi); |
| } |
| |
| // IDC_INFOSTATIC background setting |
| LRESULT OnColorStatic(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled) |
| { |
| if (::GetDlgCtrlID((HWND)lParam) == IDC_INFOSTATIC) |
| { |
| ::SetBkMode((HDC)wParam, TRANSPARENT); |
| return (LRESULT)::GetSysColorBrush(COLOR_INFOBK); |
| } |
| return bHandled = FALSE; |
| } |
| |
| // Menu dialog ending |
| LRESULT OnMenuClose(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/) |
| { |
| T* pT = static_cast<T*>(this); |
| pT->StdCloseDialog((WORD)(wID - ID_MENU_OK + IDOK)); |
| return 0; |
| } |
| |
| // Standard dialog ending: may be used with any command |
| LRESULT OnCloseCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/) |
| { |
| T* pT = static_cast<T*>(this); |
| pT->StdCloseDialog(wID); |
| return 0; |
| } |
| }; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CStdDialogImplBase - Base implementation of standard PPC/SmartPhone dialog |
| |
| template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true, class TBase = ATL::CDialogImpl< T > > |
| class ATL_NO_VTABLE CStdDialogImplBase : |
| public TBase, |
| public CStdDialogBase<T, t_shidiFlags, t_bModal> |
| { |
| public: |
| #ifdef WIN32_PLATFORM_PSPC |
| BOOL GetClientRect(LPRECT lpRect) |
| { |
| return CStdDialogBase<T, t_shidiFlags, t_bModal>::GetClientRect(lpRect); |
| } |
| |
| BOOL SetWindowText(LPCTSTR lpszString) |
| { |
| return CStdDialogBase<T, t_shidiFlags, t_bModal>::SetWindowText(lpszString); |
| } |
| #endif |
| |
| BEGIN_MSG_MAP(CStdDialogImplBase) |
| #ifdef WIN32_PLATFORM_PSPC // Pocket PC title and SIP |
| MESSAGE_HANDLER(WM_PAINT, OnPaintTitle) |
| MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange) |
| #elif defined(WIN32_PLATFORM_WFSP) // SmartPhone VK_TBACK key |
| MESSAGE_HANDLER(WM_HOTKEY, OnHotKey) |
| #endif |
| MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorStatic) |
| MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) |
| COMMAND_RANGE_HANDLER(IDOK, IDCANCEL, OnCloseCmd) |
| COMMAND_RANGE_HANDLER(ID_MENU_OK, ID_MENU_CANCEL, OnMenuClose) |
| END_MSG_MAP() |
| |
| LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| #ifdef _DEBUG |
| T* pT = static_cast<T*>(this); |
| ATLASSERT(t_bModal == pT->m_bModal); |
| #endif |
| StdPlatformInit(); |
| StdShidInit(); |
| return bHandled = FALSE; |
| } |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CStdDialogImpl - implementation of standard PPC/SmartPhone dialog |
| |
| template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true > |
| class ATL_NO_VTABLE CStdDialogImpl : public CStdDialogImplBase< T, t_shidiFlags, t_bModal> |
| {}; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CStdIndirectDialogImpl - implementation of standard indirect PPC/SmartPhone dialog |
| |
| #if defined __ATLDLGS_H__ |
| |
| template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true> |
| class ATL_NO_VTABLE CStdIndirectDialogImpl : |
| public CIndirectDialogImpl< T, CMemDlgTemplate, CStdDialogImpl<T, t_shidiFlags, t_bModal> > |
| { |
| public: |
| typedef CIndirectDialogImpl< T, CMemDlgTemplate, CStdDialogImpl<T, t_shidiFlags, t_bModal> > _baseClass; |
| typedef CStdDialogImpl<T, t_shidiFlags, t_bModal> _baseStd; |
| |
| INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow(), LPARAM dwInitParam = NULL) |
| { |
| ATLASSERT(t_bModal); |
| |
| if (!m_Template.IsValid()) |
| CreateTemplate(); |
| |
| if (m_Template.IsTemplateEx()) |
| { |
| if (m_Template.GetTemplateExPtr()->style & DS_CENTER) |
| { |
| ATLASSERT(m_Template.GetTemplateExPtr()->style ^ WS_CHILD); |
| GetTemplateExPtr()->style |= WS_POPUP; |
| } |
| } |
| else |
| { |
| if (m_Template.GetTemplatePtr()->style & DS_CENTER) |
| { |
| ATLASSERT(m_Template.GetTemplatePtr()->style ^ WS_CHILD); |
| m_Template.GetTemplatePtr()->style |= WS_POPUP; |
| } |
| } |
| |
| return _baseClass::DoModal(hWndParent, dwInitParam); |
| } |
| |
| HWND Create(HWND hWndParent, LPARAM dwInitParam = NULL) |
| { |
| ATLASSERT(!t_bModal); |
| |
| if (!m_Template.IsValid()) |
| CreateTemplate(); |
| |
| if (m_Template.IsTemplateEx()) |
| { |
| if (GetTemplateExPtr()->style & DS_CENTER) |
| { |
| ATLASSERT(GetTemplateExPtr()->style ^ WS_CHILD); |
| GetTemplateExPtr()->style |= WS_POPUP; |
| } |
| } |
| else |
| { |
| if (GetTemplatePtr()->style & DS_CENTER) |
| { |
| ATLASSERT(GetTemplatePtr()->style ^ WS_CHILD); |
| GetTemplatePtr()->style |= WS_POPUP; |
| } |
| } |
| |
| return _baseClass::Create(hWndParent, dwInitParam); |
| } |
| |
| BEGIN_MSG_MAP(CStdIndirectDialogImpl) |
| CHAIN_MSG_MAP(_baseStd) |
| END_MSG_MAP() |
| |
| }; |
| |
| #endif // defined __ATLDLGS_H__ |
| |
| #ifndef _ATL_NO_HOSTING |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CStdAxDialogImpl - implementation of standard PPC/SmartPhone AxDialog |
| |
| template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true > |
| class ATL_NO_VTABLE CStdAxDialogImpl : public CStdDialogImplBase< T, t_shidiFlags, t_bModal, ATL::CAxDialogImpl< T > > |
| {}; |
| #endif // _ATL_NO_HOSTING |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CStdSimpleDialog - standard PPC/SmartPhone simple dialog with SHIDIF_xxx flags |
| |
| template <WORD t_wDlgTemplateID, UINT t_shidiFlags = WTL_STD_SHIDIF> |
| class CStdSimpleDialog : |
| public ATL::CSimpleDialog<t_wDlgTemplateID, FALSE>, |
| public CStdDialogBase<CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags>, t_shidiFlags> |
| { |
| public: |
| typedef CStdDialogBase<CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags>, t_shidiFlags> baseClass; |
| |
| #ifdef WIN32_PLATFORM_PSPC |
| BOOL GetClientRect(LPRECT lpRect) |
| { |
| return baseClass::GetClientRect(lpRect); |
| } |
| |
| BOOL SetWindowText(LPCTSTR lpszString) |
| { |
| return baseClass::SetWindowText(lpszString); |
| } |
| #endif |
| |
| BEGIN_MSG_MAP(CStdSimpleDialog) |
| #ifdef WIN32_PLATFORM_PSPC // Pocket PC title and SIP |
| MESSAGE_HANDLER(WM_PAINT, OnPaintTitle) |
| MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange) |
| #elif defined(WIN32_PLATFORM_WFSP) // SmartPhone VK_TBACK key |
| MESSAGE_HANDLER(WM_HOTKEY, OnHotKey) |
| #endif |
| MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorStatic) |
| MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) |
| COMMAND_RANGE_HANDLER(ID_MENU_OK, ID_MENU_CANCEL, OnMenuClose) |
| COMMAND_RANGE_HANDLER(IDOK, IDCANCEL, baseClass::OnCloseCmd) |
| END_MSG_MAP() |
| |
| LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| StdPlatformInit(); |
| StdShidInit(); |
| return bHandled = FALSE; |
| } |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CStdDialogResizeImplBase - Base implementation of orientation resizing standard PPC/SmartPhone dialog |
| |
| template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true, class TBase = ATL::CDialogImpl<T> > |
| class ATL_NO_VTABLE CStdDialogResizeImplBase : |
| public CStdDialogImplBase< T, t_shidiFlags, t_bModal, TBase>, |
| public CDialogResize<T> |
| { |
| public: |
| // Note: BEGIN_DLGRESIZE_MAP is required in the derived class. |
| |
| BEGIN_MSG_MAP(CStdResizeDialogImplBase) |
| #ifdef WIN32_PLATFORM_PSPC // Pocket PC title |
| MESSAGE_HANDLER(WM_PAINT, OnPaintTitle) |
| #elif defined(WIN32_PLATFORM_WFSP) // SmartPhone VK_TBACK key |
| MESSAGE_HANDLER(WM_HOTKEY, OnHotKey) |
| #endif |
| MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorStatic) |
| MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) |
| COMMAND_RANGE_HANDLER(IDOK, IDCANCEL, OnCloseCmd) |
| COMMAND_RANGE_HANDLER(ID_MENU_OK, ID_MENU_CANCEL, OnMenuClose) |
| CHAIN_MSG_MAP(CDialogResize< T >) |
| END_MSG_MAP() |
| |
| LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| #ifdef _DEBUG |
| T* pT = static_cast<T*>(this); |
| ATLASSERT(t_bModal == pT->m_bModal); |
| #endif |
| StdPlatformInit(); |
| DlgResize_Init(FALSE); |
| StdShidInit(); |
| return bHandled = FALSE; |
| } |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CStdDialogResizeImpl - implementation of orientation resizing standard PPC/SmartPhone dialog |
| |
| template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true > |
| class ATL_NO_VTABLE CStdDialogResizeImpl : public CStdDialogResizeImplBase< T, t_shidiFlags, t_bModal> |
| {}; |
| |
| #ifndef _ATL_NO_HOSTING |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CStdAxDialogResizeImpl - implementation of orientation resizing standard PPC/SmartPhone AxDialog |
| |
| template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true > |
| class ATL_NO_VTABLE CStdAxDialogResizeImpl : public CStdDialogResizeImplBase< T, t_shidiFlags, t_bModal, ATL::CAxDialogImpl<T> > |
| {}; |
| #endif // _ATL_NO_HOSTING |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CStdSimpleDialogResizeImpl - implementation of standard resizing simple dialog with SHIDIF_xxx flags |
| |
| // Usage: |
| // class CMyDlg : public CStdSimpleDialogResize<CMyDlg, |
| // IDD_MYDLG, SHIDIF_DONEBUTTON | SHIDIF_FULLSCREENNOMENUBAR> |
| // { |
| // public: |
| // BEGIN_DLGRESIZE_MAP(CMyDlg) |
| // ... |
| // END_DLGRESIZE_MAP() |
| // }; |
| |
| template <class T, WORD t_wDlgTemplateID, UINT t_shidiFlags = WTL_STD_SHIDIF> |
| class ATL_NO_VTABLE CStdSimpleDialogResizeImpl : |
| public CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags>, |
| public CDialogResize< T > |
| { |
| public: |
| typedef CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags>::baseClass baseClass; |
| |
| BEGIN_MSG_MAP(CStdSimpleDialogResizeImpl) |
| #ifdef WIN32_PLATFORM_PSPC // Pocket PC title |
| MESSAGE_HANDLER(WM_PAINT, OnPaintTitle) |
| #elif defined(WIN32_PLATFORM_WFSP) // SmartPhone VK_TBACK key |
| MESSAGE_HANDLER(WM_HOTKEY, OnHotKey) |
| #endif |
| MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorStatic) |
| MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) |
| COMMAND_RANGE_HANDLER(IDOK, IDCANCEL, baseClass::OnCloseCmd) |
| COMMAND_RANGE_HANDLER(ID_MENU_OK, ID_MENU_CANCEL, OnMenuClose) |
| CHAIN_MSG_MAP(CDialogResize< T >) |
| END_MSG_MAP() |
| |
| LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| StdPlatformInit(); |
| DlgResize_Init(FALSE); |
| StdShidInit(); |
| return bHandled = FALSE; |
| } |
| }; |
| |
| #if defined(_WTL_CE_DRA) && defined(WIN32_PLATFORM_PSPC) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CStdOrientedDialogBase - Oriented PPC standard dialog base class |
| |
| template <class T> |
| class CStdOrientedDialogBase |
| { |
| public: |
| // Operation |
| BOOL SetOrientation(DRA::DisplayMode mode) |
| { |
| T* pT = static_cast<T*>(this); |
| ATLASSERT(pT->IsWindow()); |
| ATLASSERT(mode == DRA::GetDisplayMode()); |
| |
| // Derived dialog must enumerate TWO dialog templates with the same control ids and types ie: |
| // enum { IDD = IDD_MYDLG, IDD_LANDSCAPE = IDD_MYDLG_L }; |
| UINT iResource = (mode == DRA::Landscape)? T::IDD_LANDSCAPE : T::IDD; |
| |
| BOOL bRes = DRA::RelayoutDialog(ModuleHelper::GetResourceInstance(), pT->m_hWnd, MAKEINTRESOURCE(iResource)); |
| pT->OnOrientation(mode); |
| return bRes; |
| } |
| |
| // Override |
| void OnOrientation(DRA::DisplayMode /*mode*/) |
| {} |
| |
| // Message handlers |
| LRESULT OnSettingChange(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| T* pT = static_cast<T*>(this); |
| ATLASSERT(pT->IsWindow()); |
| if (wParam == SETTINGCHANGE_RESET) |
| { |
| SetOrientation(DRA::GetDisplayMode()); |
| pT->StdPlatformInit(); |
| pT->StdShidInit(); |
| } |
| else if (wParam == SPI_SETSIPINFO) |
| { |
| pT->DoSipInfo(); |
| return TRUE; |
| } |
| return bHandled = FALSE; |
| } |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CStdOrientedDialogImplBase - Oriented PPC standard dialog base implementation |
| |
| template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true, class TBase = ATL::CDialogImpl<T> > |
| class ATL_NO_VTABLE CStdOrientedDialogImplBase : |
| public CStdDialogImplBase< T, t_shidiFlags, t_bModal, TBase>, |
| public CStdOrientedDialogBase<T> |
| { |
| public: |
| BEGIN_MSG_MAP(CStdOrientedDialogImpl) |
| MESSAGE_HANDLER(WM_PAINT, OnPaintTitle) |
| MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorStatic) |
| MESSAGE_HANDLER(WM_SETTINGCHANGE, CStdOrientedDialogBase<T>::OnSettingChange) |
| MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) |
| COMMAND_RANGE_HANDLER(IDOK, IDCANCEL, OnCloseCmd) |
| COMMAND_RANGE_HANDLER(ID_MENU_OK, ID_MENU_CANCEL, OnMenuClose) |
| END_MSG_MAP() |
| |
| LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| T* pT = static_cast<T*>(this); |
| #ifdef _DEBUG |
| ATLASSERT(t_bModal == pT->m_bModal); |
| #endif |
| if (DRA::GetDisplayMode() == DRA::Landscape) |
| SetOrientation(DRA::Landscape); |
| pT->StdPlatformInit(); |
| pT->StdShidInit(); |
| return bHandled = FALSE; |
| } |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CStdOrientedDialogImpl - Oriented PPC standard dialog implementation |
| |
| template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true > |
| class ATL_NO_VTABLE CStdOrientedDialogImpl : public CStdOrientedDialogImplBase< T, t_shidiFlags, t_bModal> |
| {}; |
| |
| #ifndef _ATL_NO_HOSTING |
| /////////////////////////////////////////////////////////////////////////////// |
| // CStdAxOrientedDialogImpl - Oriented PPC standard AxDialog implementation |
| |
| template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true > |
| class ATL_NO_VTABLE CStdAxOrientedDialogImpl : public CStdOrientedDialogImplBase< T, t_shidiFlags, t_bModal, ATL::CAxDialogImpl<T> > |
| {}; |
| #endif // _ATL_NO_HOSTING |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CStdSimpleOrientedDialog - Standard simple orientable dialog |
| |
| template <WORD t_wDlgTemplateID, WORD t_wDlgLandscapeID, UINT t_shidiFlags = WTL_STD_SHIDIF> |
| class CStdSimpleOrientedDialog : |
| public CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags>, |
| public CStdOrientedDialogBase<CStdSimpleOrientedDialog<t_wDlgTemplateID, t_wDlgLandscapeID, t_shidiFlags> > |
| { |
| public: |
| typedef CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags>::baseClass baseClass; |
| typedef CStdOrientedDialogBase<CStdSimpleOrientedDialog<t_wDlgTemplateID, t_wDlgLandscapeID, t_shidiFlags> > baseOriented; |
| |
| enum {IDD = t_wDlgTemplateID, IDD_LANDSCAPE = t_wDlgLandscapeID}; |
| |
| BEGIN_MSG_MAP(CStdSimpleDialog) |
| MESSAGE_HANDLER(WM_PAINT, OnPaintTitle) |
| MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorStatic) |
| MESSAGE_HANDLER(WM_SETTINGCHANGE, baseOriented::OnSettingChange) |
| MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog) |
| COMMAND_RANGE_HANDLER(IDOK, IDCANCEL, baseClass::OnCloseCmd) |
| COMMAND_RANGE_HANDLER(ID_MENU_OK, ID_MENU_CANCEL, OnMenuClose) |
| END_MSG_MAP() |
| |
| LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| if (DRA::GetDisplayMode() == DRA::Landscape) |
| SetOrientation(DRA::Landscape); |
| StdPlatformInit(); |
| StdShidInit(); |
| return bHandled = FALSE; |
| } |
| }; |
| |
| #endif // _WTL_CE_DRA |
| |
| |
| #endif // _WTL_CE_NO_DIALOGS |
| |
| |
| // --- PPC/SmartPhone application window and helpers --- |
| |
| #ifndef _WTL_CE_NO_APPWINDOW |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CAppInfoBase - Helper for application state save/restore to registry |
| |
| class CAppInfoBase |
| { |
| public: |
| ATL::CRegKey m_Key; |
| |
| CAppInfoBase(ATL::_U_STRINGorID sAppKey) |
| { |
| m_Key.Create(HKEY_CURRENT_USER, sAppKey.m_lpstr); |
| ATLASSERT(m_Key.m_hKey); |
| } |
| |
| template <class V> |
| LONG Save(V& val, ATL::_U_STRINGorID sName) |
| { |
| return ::RegSetValueEx(m_Key, sName.m_lpstr, 0, REG_BINARY, (LPBYTE)&val, sizeof(V)); |
| } |
| |
| template <class V> |
| LONG Save(int nb, V& val0, ATL::_U_STRINGorID sName) |
| { |
| return ::RegSetValueEx(m_Key, sName.m_lpstr, 0, REG_BINARY, (LPBYTE)&val0, nb * sizeof(V)); |
| } |
| |
| template <class V> |
| LONG Restore(V& val, ATL::_U_STRINGorID sName) |
| { |
| DWORD valtype; |
| DWORD bufSize = sizeof(V); |
| return ::RegQueryValueEx(m_Key, sName.m_lpstr, 0, &valtype, (LPBYTE)&val, &bufSize); |
| } |
| |
| template <class V> |
| LONG Restore(int nb, V& val0, ATL::_U_STRINGorID sName) |
| { |
| DWORD valtype; |
| DWORD bufSize = nb * sizeof(V); |
| return ::RegQueryValueEx(m_Key, sName.m_lpstr, 0, &valtype, (LPBYTE)&val0, &bufSize); |
| } |
| |
| #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__) |
| #if (_ATL_VER < 0x0800) |
| LONG Save(_CSTRING_NS::CString& sval, ATL::_U_STRINGorID sName) |
| { |
| return m_Key.SetValue(sval, sName.m_lpstr); |
| } |
| |
| LONG Restore(_CSTRING_NS::CString& sval, ATL::_U_STRINGorID sName) |
| { |
| DWORD size = MAX_PATH; |
| LONG res = m_Key.QueryValue(sval.GetBuffer(size), sName.m_lpstr, &size); |
| sval.ReleaseBuffer(); |
| return res; |
| } |
| #else // !(_ATL_VER < 0x0800) |
| LONG Save(_CSTRING_NS::CString& sval, ATL::_U_STRINGorID sName) |
| { |
| return m_Key.SetStringValue(sName.m_lpstr, sval); |
| } |
| |
| LONG Restore(_CSTRING_NS::CString& sval, ATL::_U_STRINGorID sName) |
| { |
| DWORD size = MAX_PATH; |
| LONG res = m_Key.QueryStringValue(sName.m_lpstr, sval.GetBuffer(size), &size); |
| sval.ReleaseBuffer(); |
| return res; |
| } |
| #endif // !(_ATL_VER < 0x0800) |
| #else |
| #pragma message("Warning: CAppInfoBase compiles without CString support. Do not use CString in Save or Restore.") |
| #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__) |
| |
| #if (_ATL_VER < 0x0800) |
| LONG Save(LPCTSTR sval, ATL::_U_STRINGorID sName) |
| { |
| return m_Key.SetValue(sval, sName.m_lpstr); |
| } |
| |
| LONG Restore(LPTSTR sval, ATL::_U_STRINGorID sName, DWORD *plength) |
| { |
| return m_Key.QueryValue(sval, sName.m_lpstr, plength); |
| } |
| #else // !(_ATL_VER < 0x0800) |
| LONG Save(LPCTSTR sval, ATL::_U_STRINGorID sName) |
| { |
| return m_Key.SetStringValue(sName.m_lpstr, sval); |
| } |
| |
| LONG Restore(LPTSTR sval, ATL::_U_STRINGorID sName, DWORD *plength) |
| { |
| return m_Key.QueryStringValue(sName.m_lpstr, sval, plength); |
| } |
| #endif // !(_ATL_VER < 0x0800) |
| |
| LONG Delete(ATL::_U_STRINGorID sName) |
| { |
| return m_Key.DeleteValue(sName.m_lpstr); |
| } |
| }; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CAppInfoT - CAppInfoBase constructed from a class with T::GetAppKey() |
| |
| // Macro for declaring AppKey |
| #define DECLARE_APPKEY(uAppKey) \ |
| static LPCTSTR GetAppKey() \ |
| { \ |
| static LPCTSTR sAppKey = ATL::_U_STRINGorID(uAppKey).m_lpstr; \ |
| return sAppKey; \ |
| } |
| |
| template <class T> |
| class CAppInfoT : public CAppInfoBase |
| { |
| public: |
| CAppInfoT() : CAppInfoBase(T::GetAppKey()){} |
| }; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CAppWindowBase - Base class for PPC/SmartPhone "well-behaved" application window or dialog |
| |
| // Macros for declaring frame WNDCLASS and AppKey |
| #define DECLARE_APP_FRAME_CLASS(WndClassName, uCommonResourceID, uAppKey) \ |
| DECLARE_FRAME_WND_CLASS(WndClassName, uCommonResourceID) \ |
| DECLARE_APPKEY(uAppKey) |
| |
| #define DECLARE_APP_FRAME_CLASS_EX(WndClassName, uCommonResourceID, style, bkgnd, uAppKey) \ |
| DECLARE_FRAME_WND_CLASS_EX(WndClassName, uCommonResourceID, style, bkgnd) \ |
| DECLARE_APPKEY(uAppKey) |
| |
| template <class T> |
| class CAppWindowBase |
| { |
| public: |
| typedef class CAppInfoT< T > CAppInfo; |
| |
| #ifndef WIN32_PLATFORM_WFSP |
| SHACTIVATEINFO m_sai; // NoOp on SmartPhones |
| #endif // WIN32_PLATFORM_WFSP |
| |
| bool m_bHibernate; |
| |
| CAppWindowBase< T >() : m_bHibernate(false) |
| { |
| #ifndef WIN32_PLATFORM_WFSP |
| SHACTIVATEINFO sai = { sizeof(SHACTIVATEINFO) }; |
| m_sai = sai; |
| #endif // WIN32_PLATFORM_WFSP |
| }; |
| |
| // Same as WTL 7.1 AppWizard generated ActivatePreviousInstance + SendMessage WM_COPYDATA |
| static HRESULT ActivatePreviousInstance(HINSTANCE hInstance, LPCTSTR lpstrCmdLine, bool bDialog) |
| { |
| // requires T does DECLARE_APP_FRAME_CLASS, DECLARE_APP_FRAME_CLASS_EX or DECLARE_APP_DLG_CLASS |
| CFrameWndClassInfo& classInfo = T::GetWndClassInfo(); |
| |
| ATLVERIFY(::LoadString(hInstance, classInfo.m_uCommonResourceID, classInfo.m_szAutoName, sizeof(classInfo.m_szAutoName)/sizeof(classInfo.m_szAutoName[0])) != 0); |
| |
| classInfo.m_wc.lpszClassName = classInfo.m_szAutoName; |
| |
| const TCHAR* pszClass = classInfo.m_wc.lpszClassName; |
| |
| if(NULL == pszClass || '\0' == *pszClass) |
| { |
| return E_FAIL; |
| } |
| |
| const DWORD dRetryInterval = 100; |
| const int iMaxRetries = 25; |
| |
| for(int i = 0; i < iMaxRetries; ++i) |
| { |
| HANDLE hMutex = CreateMutex(NULL, FALSE, pszClass); |
| |
| DWORD dw = GetLastError(); |
| |
| if(NULL == hMutex) |
| { |
| HRESULT hr; |
| |
| switch(dw) |
| { |
| case ERROR_INVALID_HANDLE: |
| // A non-mutext object with this name already exists. |
| hr = E_INVALIDARG; |
| break; |
| default: |
| // This should never happen... |
| hr = E_FAIL; |
| } |
| |
| return hr; |
| } |
| |
| // If the mutex already exists, then there should be another instance running |
| if(dw == ERROR_ALREADY_EXISTS) |
| { |
| CloseHandle(hMutex); |
| |
| HWND hwnd = NULL; |
| if (bDialog) |
| hwnd = FindWindow(NULL, pszClass); |
| else |
| hwnd = FindWindow(pszClass, NULL); |
| |
| if(hwnd == NULL) |
| { |
| Sleep(dRetryInterval); |
| continue; |
| } |
| else |
| { |
| // Transmit our params to previous instance |
| if (lpstrCmdLine && *lpstrCmdLine) |
| { |
| COPYDATASTRUCT cd = { NULL, sizeof(TCHAR) * (wcslen(lpstrCmdLine) + 1), (PVOID)lpstrCmdLine }; |
| ::SendMessage(hwnd, WM_COPYDATA, NULL, (LPARAM)&cd); |
| } |
| // Set the previous instance as the foreground window |
| if(0 != SetForegroundWindow(reinterpret_cast<HWND>(reinterpret_cast<ULONG>(hwnd) | 0x1))) |
| return S_FALSE; |
| } |
| } |
| else |
| { |
| return S_OK; |
| } |
| } |
| return S_OK; |
| } |
| |
| // Operations overriden in derived class |
| bool AppHibernate(bool /*bHibernate*/) |
| { |
| return false; |
| } |
| |
| bool AppNewInstance(LPCTSTR /*lpstrCmdLine*/) |
| { |
| return false; |
| } |
| |
| void AppSave() |
| { |
| } |
| |
| #ifdef WIN32_PLATFORM_WFSP |
| void AppBackKey() |
| { |
| ::SHNavigateBack(); |
| } |
| #endif |
| |
| // Message map and handlers |
| BEGIN_MSG_MAP(CAppWindowBase) |
| MESSAGE_HANDLER(WM_ACTIVATE, OnActivate) |
| #ifdef WIN32_PLATFORM_WFSP |
| MESSAGE_HANDLER(WM_HOTKEY, OnHotKey) |
| #else |
| MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange) |
| #endif // WIN32_PLATFORM_WFSP |
| MESSAGE_HANDLER(WM_HIBERNATE, OnHibernate) |
| MESSAGE_HANDLER(WM_COPYDATA, OnNewInstance) |
| MESSAGE_HANDLER(WM_CLOSE, OnClose) |
| END_MSG_MAP() |
| |
| LRESULT OnActivate(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled) |
| { |
| T* pT = static_cast<T*>(this); |
| if (m_bHibernate) |
| m_bHibernate = pT->AppHibernate(false); |
| #ifndef WIN32_PLATFORM_WFSP |
| ::SHHandleWMActivate(pT->m_hWnd, wParam, lParam, &m_sai, 0); |
| #else |
| wParam; |
| lParam; |
| #endif // WIN32_PLATFORM_WFSP |
| return bHandled = FALSE; |
| } |
| |
| #ifdef WIN32_PLATFORM_WFSP |
| // SmartPhone VK_TBACK key standard management |
| LRESULT OnHotKey(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/) |
| { |
| T* pT = static_cast<T*>(this); |
| const UINT uModif = (UINT)LOWORD(lParam); |
| const UINT uVirtKey = (UINT)HIWORD(lParam); |
| if(uVirtKey == VK_TBACK) |
| if (AtlIsEditFocus()) |
| ::SHSendBackToFocusWindow(uMsg, wParam, lParam); |
| else if (uModif & MOD_KEYUP) |
| pT->AppBackKey(); |
| return 1; |
| } |
| |
| #else // !WIN32_PLATFORM_WFSP |
| // PPC SIP handling |
| LRESULT OnSettingChange(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled) |
| { |
| T* pT = static_cast<T*>(this); |
| bHandled = FALSE; |
| return ::SHHandleWMSettingChange(pT->m_hWnd, wParam, lParam, &m_sai); |
| } |
| #endif // !WIN32_PLATFORM_WFSP |
| |
| LRESULT OnHibernate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) |
| { |
| T* pT = static_cast<T*>(this); |
| return m_bHibernate = pT->AppHibernate(true); |
| } |
| |
| LRESULT OnNewInstance(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/) |
| { |
| T* pT = static_cast<T*>(this); |
| PCOPYDATASTRUCT pcds = (PCOPYDATASTRUCT)lParam; |
| return pT->AppNewInstance((LPCTSTR)pcds->lpData); |
| } |
| |
| LRESULT OnClose(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| T* pT = static_cast<T*>(this); |
| pT->AppSave(); |
| bHandled = FALSE; |
| return 1; |
| } |
| }; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CAppWindow - PPC/SmartPhone "well-behaved" application window class |
| |
| template <class T> |
| class CAppWindow : public CAppWindowBase< T > |
| { |
| public: |
| // Same as WTL 7.1 AppWizard generated Run + lpstrCmdLine in CreateEx |
| static int AppRun(LPTSTR lpstrCmdLine = NULL, int nCmdShow = SW_SHOWNORMAL) |
| { |
| CMessageLoop theLoop; |
| _Module.AddMessageLoop(&theLoop); |
| |
| T wndMain; |
| |
| if(wndMain.CreateEx(NULL, NULL, 0, 0, lpstrCmdLine) == NULL) |
| { |
| ATLTRACE2(atlTraceUI, 0, _T("Main window creation failed!\n")); |
| return 0; |
| } |
| |
| wndMain.ShowWindow(nCmdShow); |
| |
| int nRet = theLoop.Run(); |
| |
| _Module.RemoveMessageLoop(); |
| return nRet; |
| } |
| |
| static HRESULT ActivatePreviousInstance(HINSTANCE hInstance, LPCTSTR lpstrCmdLine) |
| { |
| return CAppWindowBase< T >::ActivatePreviousInstance(hInstance, lpstrCmdLine, false); |
| } |
| }; |
| |
| |
| #ifndef _WTL_CE_NO_DIALOGS |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CAppDialog - PPC/SmartPhone "well-behaved" dialog application class |
| |
| // Macro for declaring dialog WNDCLASS and AppKey |
| #define DECLARE_APP_DLG_CLASS(WndClassName, uCommonResourceID, uAppKey) \ |
| static WTL::CFrameWndClassInfo& GetWndClassInfo() \ |
| { \ |
| static WTL::CFrameWndClassInfo wc = \ |
| { \ |
| { 0, (WNDPROC)StartDialogProc, \ |
| 0, 0, NULL, NULL, NULL, (HBRUSH)(COLOR_WINDOW + 1), NULL, WndClassName }, \ |
| NULL, NULL, IDC_ARROW, TRUE, 0, _T(""), uCommonResourceID \ |
| }; \ |
| return wc; \ |
| }; \ |
| DECLARE_APPKEY(uAppKey) |
| |
| template <class T> |
| class CAppDialog : public CAppWindowBase< T > |
| { |
| public: |
| static int AppRun(LPTSTR lpstrCmdLine = NULL, int nCmdShow = SW_SHOWNORMAL) |
| { |
| CMessageLoop theLoop; |
| _Module.AddMessageLoop(&theLoop); |
| |
| T dlgMain; |
| |
| if(dlgMain.Create(NULL, (LPARAM)lpstrCmdLine) == NULL) |
| { |
| ATLTRACE2(atlTraceUI, 0, _T("Main dialog creation failed!\n")); |
| return 0; |
| } |
| |
| dlgMain.ShowWindow(nCmdShow); |
| |
| int nRet = theLoop.Run(); |
| |
| _Module.RemoveMessageLoop(); |
| return nRet; |
| } |
| |
| static HRESULT ActivatePreviousInstance(HINSTANCE hInstance, LPCTSTR lpstrCmdLine) |
| { |
| return CAppWindowBase< T >::ActivatePreviousInstance(hInstance, lpstrCmdLine, true); |
| }; |
| }; |
| |
| // PPC/SmartPhone standard application dialogs |
| |
| #ifdef WIN32_PLATFORM_WFSP |
| #define WTL_APP_SHIDIF WTL_SP_SHIDIF |
| #else |
| #define WTL_APP_SHIDIF WTL_STD_SHIDIF |
| #endif |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CAppStdDialogImplBase - Base implementation of standard application dialogs |
| |
| template <class T, class TImplBase, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false> |
| class ATL_NO_VTABLE CAppStdDialogImplBase : |
| public TImplBase, |
| public CAppDialog< T > |
| { |
| public: |
| WTL_DLG_NOTITLE; |
| |
| void StdCloseDialog(int nVal) |
| { |
| T* pT = static_cast<T*>(this); |
| if (nVal != IDCANCEL) |
| pT->AppSave(); |
| if (t_bModal == false) |
| { |
| pT->DestroyWindow(); |
| ::PostQuitMessage(nVal); |
| } |
| else |
| ::EndDialog(pT->m_hWnd, nVal); |
| } |
| |
| BEGIN_MSG_MAP(CAppStdDialogImplBase) |
| MESSAGE_HANDLER(WM_CLOSE, OnSystemClose) |
| CHAIN_MSG_MAP(TImplBase) |
| CHAIN_MSG_MAP(CAppDialog< T >) |
| END_MSG_MAP() |
| |
| LRESULT OnSystemClose(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) |
| { |
| T* pT = static_cast<T*>(this); |
| pT->StdCloseDialog(IDCANCEL); |
| return 0; |
| } |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CAppStdDialogImpl - Implementation of standard application dialog |
| |
| template <class T, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false> |
| class ATL_NO_VTABLE CAppStdDialogImpl : |
| public CAppStdDialogImplBase<T, CStdDialogImpl<T, t_shidiFlags, t_bModal>, t_shidiFlags, t_bModal> |
| {}; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CAppStdDialogResizeImpl - implementation of orientation resizing standard application dialog |
| |
| template <class T, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false> |
| class ATL_NO_VTABLE CAppStdDialogResizeImpl : |
| public CAppStdDialogImplBase<T, CStdDialogResizeImpl<T, t_shidiFlags, t_bModal>, t_shidiFlags, t_bModal> |
| {}; |
| |
| #ifndef _ATL_NO_HOSTING |
| /////////////////////////////////////////////////////////////////////////////// |
| // CAppStdAxDialogImpl - Implementation of standard application AxDialog |
| |
| template <class T, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false> |
| class ATL_NO_VTABLE CAppStdAxDialogImpl : |
| public CAppStdDialogImplBase<T, CStdAxDialogImpl<T, t_shidiFlags, t_bModal>, t_shidiFlags, t_bModal> |
| {}; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CAppStdAxDialogResizeImpl - implementation of orientation resizing standard application AxDialog |
| |
| template <class T, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false> |
| class ATL_NO_VTABLE CAppStdAxDialogResizeImpl : |
| public CAppStdDialogImplBase<T, CStdAxDialogResizeImpl<T, t_shidiFlags, t_bModal>, t_shidiFlags, t_bModal> |
| {}; |
| #endif // _ATL_NO_HOSTING |
| |
| #if defined(_WTL_CE_DRA) && defined(WIN32_PLATFORM_PSPC) |
| /////////////////////////////////////////////////////////////////////////////// |
| // CAppStdOrientedDialogImpl - implementation of oriented PPC standard application dialog |
| |
| template <class T, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false> |
| class ATL_NO_VTABLE CAppStdOrientedDialogImpl : |
| public CAppStdDialogImplBase<T, CStdOrientedDialogImpl<T, t_shidiFlags, t_bModal>, t_shidiFlags, t_bModal> |
| {}; |
| |
| #ifndef _ATL_NO_HOSTING |
| /////////////////////////////////////////////////////////////////////////////// |
| // CAppStdAxOrientedDialogImpl - implementation of oriented PPC standard application AxDialog |
| |
| template <class T, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false> |
| class ATL_NO_VTABLE CAppStdAxOrientedDialogImpl : |
| public CAppStdDialogImplBase<T, CStdAxOrientedDialogImpl<T, t_shidiFlags, t_bModal>, t_shidiFlags, t_bModal> |
| {}; |
| #endif // _ATL_NO_HOSTING |
| |
| #endif // defined(_WTL_CE_DRA) && defined(WIN32_PLATFORM_PSPC) |
| |
| #endif // _WTL_CE_NO_DIALOGS |
| |
| #endif // _WTL_CE_NO_APPWINDOW |
| |
| |
| // --- Full screen support --- |
| |
| #ifndef _WTL_CE_NO_FULLSCREEN |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CFullScreenFrame - full screen frame implementation |
| |
| template <class T, bool t_bHasSip = true> |
| class CFullScreenFrame |
| { |
| public: |
| bool m_bFullScreen; |
| |
| CFullScreenFrame() : m_bFullScreen(false) |
| { } |
| |
| // Operation |
| void SetFullScreen(bool bFull) |
| { |
| m_bFullScreen = bFull; |
| ShowTaskBar(!bFull, false); |
| ShowMenuBar(!bFull); |
| } |
| |
| // Manage TaskBar for modal dialogs and property sheets |
| template <class D> |
| int FSDoModal(D& dlg) |
| { |
| T* pT = static_cast<T*>(this); |
| pT; // avoid level 4 warning |
| ATLASSERT(pT->IsWindow()); |
| if (m_bFullScreen) // Show taskbar if hidden |
| ShowTaskBar(true, false); |
| int iRet = dlg.DoModal(); |
| if (m_bFullScreen) // Hide taskbar if restored |
| ShowTaskBar(false); |
| return iRet; |
| } |
| |
| // Implementation |
| void ShowMenuBar(bool bShow) |
| { |
| T* pT = static_cast<T*>(this); |
| ATLASSERT(pT->IsWindow()); |
| ATL::CWindow MenuBar = pT->m_hWndCECommandBar; |
| ATLASSERT(MenuBar.IsWindow()); |
| MenuBar.ShowWindow(bShow ? SW_SHOWNORMAL : SW_HIDE); |
| pT->SizeToMenuBar(); |
| } |
| |
| void ShowTaskBar(bool bShow, bool bRepaint = true) |
| { |
| T* pT = static_cast<T*>(this); |
| ATLASSERT(pT->IsWindow()); |
| RECT rect = { 0 }; |
| SystemParametersInfo(SPI_GETWORKAREA, NULL, &rect, FALSE); |
| if (!bShow) |
| rect.top = 0; |
| |
| #ifdef WIN32_PLATFORM_PSPC // Pocket PC code |
| UINT uShow = t_bHasSip ? SHFS_SHOWTASKBAR | SHFS_SHOWSIPBUTTON : SHFS_SHOWTASKBAR | SHFS_HIDESIPBUTTON; |
| SHFullScreen(pT->m_hWnd, bShow ? uShow : SHFS_HIDETASKBAR | SHFS_HIDESIPBUTTON); |
| #elif _WIN32_WCE > 0x500 // Smartphone 2005 code |
| SHFullScreen(pT->m_hWnd, bShow ? SHFS_SHOWTASKBAR : SHFS_HIDETASKBAR); |
| #else // Smartphone 2003 |
| HWND hTaskBar = FindWindow(_T("tray"), NULL); |
| ATLASSERT(::IsWindow(hTaskBar)); |
| ::ShowWindow(hTaskBar, bShow ? SW_SHOW : SW_HIDE); |
| #endif // WIN32_PLATFORM_PSPC |
| |
| pT->MoveWindow(&rect, bRepaint); |
| } |
| |
| // Message map and handler |
| BEGIN_MSG_MAP(CFullScreenFrame) |
| MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange) |
| MESSAGE_HANDLER(WM_ACTIVATE, OnActivate) |
| END_MSG_MAP() |
| |
| LRESULT OnSettingChange(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| #ifndef SETTINGCHANGE_RESET // not defined for PPC 2002 |
| #define SETTINGCHANGE_RESET SPI_SETWORKAREA |
| #endif |
| if (m_bFullScreen && (wParam & SETTINGCHANGE_RESET)) |
| SetFullScreen(m_bFullScreen); |
| return bHandled = FALSE; |
| } |
| |
| LRESULT OnActivate(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| if (m_bFullScreen) |
| { |
| ShowTaskBar(!wParam); |
| ShowMenuBar(!wParam); |
| } |
| return bHandled = FALSE; |
| } |
| }; |
| |
| #endif // _WTL_CE_NO_FULLSCREEN |
| |
| |
| // --- WinCE zoom support --- |
| |
| #ifndef _WTL_CE_NO_ZOOMSCROLL |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CZoomScrollImpl - WinCE zooming implementation on top of CScrollImpl |
| |
| template <class T> |
| class CZoomScrollImpl: public CScrollImpl< T > |
| { |
| public: |
| // Data members |
| _WTYPES_NS::CSize m_sizeTrue; |
| double m_fzoom; |
| |
| // Creation |
| CZoomScrollImpl() : m_sizeTrue(0), m_fzoom(1.) |
| { } |
| |
| // Zoom operations and access |
| void SetZoomScrollSize(_WTYPES_NS::CSize sizeTrue, double fzoom = 1., BOOL bRedraw = TRUE) |
| { |
| ATLASSERT(fzoom > 0.); |
| m_sizeTrue = sizeTrue; |
| m_fzoom = fzoom; |
| |
| CScrollImpl< T >::SetScrollSize(sizeTrue / fzoom, bRedraw); |
| } |
| |
| void SetZoomScrollSize(int cx, int cy, double fzoom=1., BOOL bRedraw = TRUE) |
| { |
| SetZoomScrollSize(_WTYPES_NS::CSize(cx, cy), fzoom, bRedraw); |
| } |
| |
| void SetZoom(double fzoom, BOOL bRedraw = TRUE) |
| { |
| _WTYPES_NS::CPoint ptCenter = WndtoTrue(m_sizeClient / 2); |
| _WTYPES_NS::CSize sizePage = GetScrollPage(); |
| _WTYPES_NS::CSize sizeLine = GetScrollLine(); |
| |
| SetZoomScrollSize(GetScrollSize(), fzoom, bRedraw); |
| |
| SetScrollLine(sizeLine); |
| SetScrollPage(sizePage); |
| _WTYPES_NS::CPoint ptOffset = ptCenter - (m_sizeClient / 2) * fzoom; |
| SetScrollOffset(ptOffset, bRedraw); |
| } |
| |
| double GetZoom() |
| { |
| return m_fzoom; |
| } |
| |
| // CScrollImpl overrides |
| void SetScrollOffset(int x, int y, BOOL bRedraw = TRUE) |
| { |
| CScrollImpl< T >::SetScrollOffset((int)(x / m_fzoom), (int)(y / m_fzoom), bRedraw); |
| } |
| |
| void SetScrollOffset(POINT ptOffset, BOOL bRedraw = TRUE) |
| { |
| SetScrollOffset(ptOffset.x, ptOffset.y, bRedraw); |
| } |
| |
| void GetScrollOffset(POINT& ptOffset) |
| { |
| ptOffset.x = (LONG)(m_ptOffset.x * m_fzoom); |
| ptOffset.y = (LONG)(m_ptOffset.y * m_fzoom); |
| } |
| |
| void SetScrollSize(int cx, int cy, BOOL bRedraw = TRUE) |
| { |
| SetZoomScrollSize(cx, cy, GetZoom(), bRedraw); |
| } |
| |
| void SetScrollSize(SIZE sizeTrue, BOOL bRedraw = TRUE) |
| { |
| SetZoomScrollSize(sizeTrue, GetZoom(), bRedraw); |
| } |
| |
| void GetScrollSize(SIZE& sizeTrue) const |
| { |
| sizeTrue = m_sizeTrue; |
| } |
| |
| void SetScrollPage(int cxPage, int cyPage) |
| { |
| SetScrollPage(_WTYPES_NS::CSize(cxPage, cyPage)); |
| } |
| |
| void SetScrollPage(SIZE sizePage) |
| { |
| CScrollImpl< T >::SetScrollPage(sizePage / m_fzoom); |
| } |
| |
| void GetScrollPage(SIZE& sizePage) const |
| { |
| sizePage = m_sizePage * m_fzoom; |
| } |
| |
| void SetScrollLine(int cxLine, int cyLine) |
| { |
| SetScrollLine(_WTYPES_NS::CSize(cxLine, cyLine)); |
| } |
| |
| void SetScrollLine(SIZE sizeLine) |
| { |
| CScrollImpl< T >::SetScrollLine(sizeLine / m_fzoom); |
| } |
| |
| void GetScrollLine(SIZE& sizeLine) const |
| { |
| sizeLine = m_sizeLine * m_fzoom; |
| } |
| |
| // Data access complements |
| _WTYPES_NS::CSize GetScrollSize() |
| { |
| return m_sizeTrue; |
| } |
| |
| _WTYPES_NS::CSize GetScrollPage() |
| { |
| return m_sizePage * m_fzoom; |
| } |
| |
| _WTYPES_NS::CSize GetScrollLine() |
| { |
| return m_sizeLine * m_fzoom; |
| } |
| |
| _WTYPES_NS::CPoint GetScrollOffset() |
| { |
| return (_WTYPES_NS::CSize)m_ptOffset * m_fzoom; |
| } |
| |
| // Helper coordinate functions |
| _WTYPES_NS::CPoint WndtoTrue(CPoint ptW) |
| { |
| return (_WTYPES_NS::CSize)ptW * GetZoom() + GetScrollOffset(); |
| } |
| |
| void WndtoTrue(LPPOINT aptW, int nPts) // in place coord transformation |
| { |
| for (int i = 0 ; i < nPts ; i++) |
| aptW[i] = WndtoTrue(aptW[i]); |
| } |
| |
| void WndtoTrue(LPRECT prectW) // in place coord transformation |
| { |
| WndtoTrue((LPPOINT)prectW, 2); |
| } |
| |
| _WTYPES_NS::CPoint TruetoWnd(CPoint ptT) |
| { |
| return (ptT - GetScrollOffset()) / GetZoom(); |
| } |
| |
| void TruetoWnd(LPPOINT aptT, int nPts) // in place coord transformation |
| { |
| for (int i = 0 ; i < nPts ; i++) |
| aptT[i] = TruetoWnd(aptT[i]); |
| } |
| |
| void TruetoWnd(LPRECT prectT) // in place coord transformation |
| { |
| TruetoWnd((LPPOINT)prectT, 2); |
| } |
| |
| // Drawing operations : assume adequate setting of data members |
| BOOL Draw(HBITMAP hbm, HDC hdestDC, DWORD dwROP = SRCCOPY) |
| { |
| CDC memDC = CreateCompatibleDC(hdestDC); |
| CBitmapHandle bmpOld = memDC.SelectBitmap(hbm); |
| BOOL bRes = Draw(memDC, hdestDC, dwROP); |
| memDC.SelectBitmap(bmpOld); |
| return bRes; |
| } |
| |
| BOOL Draw(HDC hsourceDC, HDC hdestDC, DWORD dwROP = SRCCOPY) |
| { |
| CDCHandle destDC = hdestDC; |
| destDC.SetViewportOrg(0,0); |
| _WTYPES_NS::CPoint ptOffset = GetScrollOffset(); |
| _WTYPES_NS::CSize sizeZClient = m_sizeClient * GetZoom(); |
| return destDC.StretchBlt(0, 0, m_sizeClient.cx, m_sizeClient.cy, hsourceDC, ptOffset.x, ptOffset.y, sizeZClient.cx, sizeZClient.cy, dwROP); |
| } |
| |
| #ifdef _IMAGING_H |
| BOOL Draw(IImage* pIImage, HDC hdestDC) |
| { |
| CDCHandle destDC = hdestDC; |
| destDC.SetViewportOrg(0,0); |
| return SUCCEEDED(pIImage->Draw(destDC, _WTYPES_NS::CRect(-_WTYPES_NS::CPoint(m_ptOffset), m_sizeAll), NULL)); |
| } |
| #endif |
| |
| // Message map and handlers |
| BEGIN_MSG_MAP(CZoomScrollImpl< T >) |
| MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBkgnd) |
| CHAIN_MSG_MAP(CScrollImpl< T >) |
| END_MSG_MAP() |
| |
| LRESULT OnEraseBkgnd(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled) |
| { |
| T* pT = static_cast<T*>(this); |
| ATLASSERT(::IsWindow(pT->m_hWnd)); |
| if ((GetScrollExtendedStyle() & SCRL_ERASEBACKGROUND)) |
| { |
| _WTYPES_NS::CRect rect; |
| pT->GetClientRect(rect); |
| _WTYPES_NS::CSize sizeClient=rect.Size(); |
| |
| if (m_sizeAll.cx < sizeClient.cx || m_sizeAll.cy < sizeClient.cy) |
| { |
| CDCHandle hdc = (HDC)wParam; |
| HBRUSH hbr = GetSysColorBrush((int)T::GetWndClassInfo().m_wc.hbrBackground - 1); |
| |
| if (m_sizeAll.cx < sizeClient.cx) |
| { |
| _WTYPES_NS::CRect rectBG(_WTYPES_NS::CPoint(m_sizeAll.cx, 0), sizeClient); |
| hdc.FillRect(rectBG, hbr); |
| } |
| |
| if (m_sizeAll.cy < sizeClient.cy) |
| { |
| _WTYPES_NS::CRect rectBG(_WTYPES_NS::CPoint(0, m_sizeAll.cy), sizeClient); |
| hdc.FillRect(rectBG, hbr); |
| } |
| } |
| } |
| else |
| { |
| bHandled = FALSE; |
| } |
| |
| return 1; |
| } |
| }; |
| |
| #endif // _WTL_CE_NO_ZOOMSCROLL |
| |
| #ifndef _WTL_CE_NO_CONTROLS |
| |
| // --- PPC bottom TabView control --- |
| |
| #if defined(__ATLCTRLX_H__) && defined(WIN32_PLATFORM_PSPC) |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CBottomTabViewImpl |
| |
| template <class T, class TBase = ATL::CWindow, class TWinTraits = ATL::CControlWinTraits> |
| class ATL_NO_VTABLE CBottomTabViewImpl : public CTabViewImpl<T, TBase, TWinTraits> |
| { |
| public: |
| DECLARE_WND_CLASS_EX(NULL, 0, COLOR_APPWORKSPACE) |
| |
| // Implementation overrideables |
| bool CreateTabControl() |
| { |
| m_tab.Create(m_hWnd, rcDefault, NULL, WS_CHILD | TCS_BOTTOM, 0, m_nTabID); |
| |
| ATLASSERT(m_tab.m_hWnd != NULL); |
| if(m_tab.m_hWnd == NULL) |
| return false; |
| |
| m_tab.SendMessage(CCM_SETVERSION, COMCTL32_VERSION); |
| m_tab.SetItemExtra(sizeof(TABVIEWPAGE)); |
| |
| T* pT = static_cast<T*>(this); |
| m_cyTabHeight = pT->CalcTabHeight(); |
| |
| return true; |
| } |
| |
| int CalcTabHeight() |
| { |
| int nCount = m_tab.GetItemCount(); |
| TCITEMEXTRA tcix = { 0 }; |
| tcix.tciheader.mask = TCIF_TEXT; |
| tcix.tciheader.pszText = _T("NS"); |
| int nIndex = m_tab.InsertItem(nCount, tcix); |
| |
| RECT rect = { 0 }; |
| SystemParametersInfo(SPI_GETWORKAREA, 0, &rect, 0); |
| RECT rcWnd = rect; |
| |
| m_tab.AdjustRect(FALSE, &rect); |
| rcWnd.top = rect.bottom; |
| ::AdjustWindowRectEx(&rcWnd, m_tab.GetStyle(), FALSE, m_tab.GetExStyle()); |
| m_tab.DeleteItem(nIndex); |
| |
| return rcWnd.bottom - rcWnd.top; |
| } |
| |
| void UpdateLayout() |
| { |
| RECT rect; |
| GetClientRect(&rect); |
| |
| if(m_tab.IsWindow() && ((m_tab.GetStyle() & WS_VISIBLE) != 0)) |
| m_tab.SetWindowPos(NULL, 0, rect.bottom - m_cyTabHeight, rect.right - rect.left, m_cyTabHeight, SWP_NOZORDER /*| SWP_SHOWWINDOW*/); |
| |
| if(m_nActivePage != -1) |
| ::SetWindowPos(GetPageHWND(m_nActivePage), NULL, 0, 0, rect.right - rect.left, rect.bottom - m_cyTabHeight, SWP_NOZORDER); |
| } |
| |
| }; |
| |
| class CBottomTabView : public CBottomTabViewImpl<CBottomTabView> |
| { |
| public: |
| DECLARE_WND_CLASS_EX(_T("WTL_BottomTabView"), 0, COLOR_APPWORKSPACE) |
| }; |
| |
| #endif // defined(__ATLCTRLX_H__) && defined(WIN32_PLATFORM_PSPC) |
| |
| |
| // --- PPC/SmartPhone controls --- |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // These are wrapper classes for the Pocket PC 2002/2003 and SmartPhone 2003 controls |
| // To implement a window based on a control, use following: |
| // Example: Implementing a window based on a Html control |
| // |
| // class CMyHtml : CWindowImpl<CMyHtml, CHtmlCtrl> |
| // { |
| // public: |
| // BEGIN_MSG_MAP(CMyHtml) |
| // // put your message handler entries here |
| // END_MSG_MAP() |
| // }; |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CHtmlCtrl |
| |
| template <class TBase> |
| class CHtmlCtrlT : public TBase |
| { |
| public: |
| // Constructors |
| CHtmlCtrlT(HWND hWnd = NULL) : TBase(hWnd) |
| { } |
| |
| CHtmlCtrlT< TBase >& operator =(HWND hWnd) |
| { |
| m_hWnd = hWnd; |
| return *this; |
| } |
| |
| HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL, |
| DWORD dwStyle = 0, DWORD dwExStyle = 0, |
| ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) |
| { |
| HWND hWnd = TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); |
| ATLASSERT(hWnd != NULL); // Did you remember to call InitHTMLControl(hInstance) ?? |
| return hWnd; |
| } |
| |
| // Attributes |
| static LPCTSTR GetWndClassName() |
| { |
| return WC_HTML; |
| } |
| |
| #if (_WIN32_WCE >= 400) |
| void AddStyle(LPCWSTR pszStyle) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DTM_ADDSTYLE, 0, (LPARAM)pszStyle); |
| } |
| #endif // (_WIN32_WCE >= 400) |
| |
| void AddText(BOOL bPlainText, LPCSTR pszText) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DTM_ADDTEXT, (WPARAM)bPlainText, (LPARAM)pszText); |
| } |
| |
| void AddHTML(LPCSTR pszHTML) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DTM_ADDTEXT, (WPARAM)FALSE, (LPARAM)pszHTML); |
| } |
| |
| void AddText(BOOL bPlainText, LPCWSTR pszText) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DTM_ADDTEXTW, (WPARAM)bPlainText, (LPARAM)pszText); |
| } |
| |
| void AddHTML(LPCWSTR pszHTML) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DTM_ADDTEXTW, (WPARAM)FALSE, (LPARAM)pszHTML); |
| } |
| |
| void Anchor(LPCSTR pszAnchor) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DTM_ANCHOR, 0, (LPARAM)pszAnchor); |
| } |
| |
| void Anchor(LPCWSTR pszAnchor) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DTM_ANCHORW, 0, (LPARAM)pszAnchor); |
| } |
| |
| #if (_WIN32_WCE >= 420) |
| void GetBrowserDispatch(IDispatch** ppDispatch) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(ppDispatch); |
| ATLASSERT(*ppDispatch==NULL); |
| ::SendMessage(m_hWnd, DTM_BROWSERDISPATCH, 0, (LPARAM)ppDispatch); |
| } |
| void GetDocumentDispatch(IDispatch** ppDispatch) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(ppDispatch); |
| ATLASSERT(*ppDispatch==NULL); |
| ::SendMessage(m_hWnd, DTM_DOCUMENTDISPATCH , 0, (LPARAM)ppDispatch); |
| } |
| #endif // (_WIN32_WCE >= 420) |
| |
| void Clear() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DTM_CLEAR, 0, 0L); |
| } |
| |
| void EnableClearType(BOOL bEnable = TRUE) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DTM_ENABLECLEARTYPE, 0, (LPARAM)bEnable); |
| } |
| |
| void EnableContextMenu(BOOL bEnable = TRUE) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DTM_ENABLECONTEXTMENU, 0, (LPARAM)bEnable); |
| } |
| |
| void EnableScripting(BOOL bEnable = TRUE) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DTM_ENABLESCRIPTING, 0, (LPARAM)bEnable); |
| } |
| |
| void EnableShrink(BOOL bEnable = TRUE) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DTM_ENABLESHRINK, 0, (LPARAM)bEnable); |
| } |
| |
| void EndOfSource() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DTM_ENDOFSOURCE, 0, 0L); |
| } |
| |
| void ImageFail(DWORD dwCookie) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DTM_IMAGEFAIL, 0, (LPARAM)dwCookie); |
| } |
| |
| int GetLayoutHeight() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (int)::SendMessage(m_hWnd, DTM_LAYOUTHEIGHT, 0, 0L); |
| } |
| |
| int GetLayoutWidth() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (int)::SendMessage(m_hWnd, DTM_LAYOUTWIDTH, 0, 0L); |
| } |
| |
| void Navigate(LPCTSTR pstrURL, UINT uFlags = 0) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(pstrURL); |
| ::SendMessage(m_hWnd, DTM_NAVIGATE, (WPARAM)uFlags, (LPARAM)pstrURL); |
| } |
| |
| void SelectAll() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DTM_SELECTALL, 0, 0L); |
| } |
| |
| void SetImage(INLINEIMAGEINFO* pImageInfo) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(pImageInfo); |
| ::SendMessage(m_hWnd, DTM_SETIMAGE, 0, (LPARAM)pImageInfo); |
| } |
| |
| void ZoomLevel(int iLevel) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DTM_ZOOMLEVEL, 0, (LPARAM)iLevel); |
| } |
| |
| #if (_WIN32_WCE >= 400) |
| void Stop() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DTM_STOP, 0, 0L); |
| } |
| #endif // (_WIN32_WCE >= 400) |
| |
| void GetScriptDispatch(IDispatch** ppDispatch) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(ppDispatch); |
| ATLASSERT(*ppDispatch==NULL); |
| ::SendMessage(m_hWnd, DTM_SCRIPTDISPATCH, 0, (LPARAM)ppDispatch); |
| } |
| }; |
| |
| typedef CHtmlCtrlT<ATL::CWindow> CHtmlCtrl; |
| |
| |
| #ifdef WIN32_PLATFORM_PSPC |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CRichInkCtrl |
| |
| template <class TBase> |
| class CRichInkCtrlT : public TBase |
| { |
| public: |
| // Constructors |
| CRichInkCtrlT(HWND hWnd = NULL) : TBase(hWnd) |
| { } |
| |
| CRichInkCtrlT< TBase >& operator =(HWND hWnd) |
| { |
| m_hWnd = hWnd; |
| return *this; |
| } |
| |
| HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL, |
| DWORD dwStyle = 0, DWORD dwExStyle = 0, |
| ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) |
| { |
| HWND hWnd = TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); |
| ATLASSERT(hWnd != NULL); // Did you remember to call InitRichInkDLL() ?? |
| return hWnd; |
| } |
| |
| // Attributes |
| static LPCTSTR GetWndClassName() |
| { |
| return WC_RICHINK; |
| } |
| |
| BOOL CanPaste(UINT uFormat = 0) const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (BOOL)::SendMessage(m_hWnd, EM_CANPASTE, (WPARAM)uFormat, 0L); |
| } |
| |
| BOOL CanRedo() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (BOOL)::SendMessage(m_hWnd, EM_CANREDO, 0, 0L); |
| } |
| |
| BOOL CanUndo() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (BOOL)::SendMessage(m_hWnd, EM_CANUNDO, 0, 0L); |
| } |
| |
| void ClearAll(BOOL bRepaint = TRUE) const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, EM_CLEARALL, (WPARAM)bRepaint, 0L); |
| } |
| |
| BOOL GetModify() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (BOOL)::SendMessage(m_hWnd, EM_GETMODIFY, 0, 0L); |
| } |
| |
| UINT GetPageStyle() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (UINT)::SendMessage(m_hWnd, EM_GETPAGESTYLE, 0, 0L); |
| } |
| |
| UINT GetPenMode() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (UINT)::SendMessage(m_hWnd, EM_GETPENMODE, 0, 0L); |
| } |
| |
| UINT GetViewStyle() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (UINT)::SendMessage(m_hWnd, EM_GETVIEW, 0, 0L); |
| } |
| |
| UINT GetWrapMode() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (UINT)::SendMessage(m_hWnd, EM_GETWRAPMODE, 0, 0L); |
| } |
| |
| UINT GetZoomPercent() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (UINT)::SendMessage(m_hWnd, EM_GETZOOMPERCENT, 0, 0L); |
| } |
| |
| void InsertLinks(LPWSTR lpString, int cchLength = -1) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| if(cchLength == -1) |
| cchLength = lstrlen(lpString); |
| ::SendMessage(m_hWnd, EM_INSERTLINKS, (WPARAM)cchLength, (LPARAM)lpString); |
| } |
| |
| void RedoEvent() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, EM_REDOEVENT, 0, 0L); |
| } |
| |
| UINT SetInkLayer(UINT uLayer) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (UINT)::SendMessage(m_hWnd, EM_SETINKLAYER, (WPARAM)uLayer, 0L); |
| } |
| |
| void SetPageStyle(UINT uStyle) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, EM_SETPAGESTYLE, (WPARAM)uStyle, 0L); |
| } |
| |
| void SetPenMode(UINT uMode) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, EM_SETPENMODE, (WPARAM)uMode, 0L); |
| } |
| |
| void SetViewStyle(UINT uStyle) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, EM_SETVIEW, (WPARAM)uStyle, 0L); |
| } |
| |
| void SetViewAttributes(VIEWATTRIBUTES* pAttribs) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(pAttribs); |
| ::SendMessage(m_hWnd, EM_SETVIEWATTRIBUTES, 0, (LPARAM)pAttribs); |
| } |
| |
| void SetWrapMode(UINT uMode) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, EM_SETWRAPMODE, (WPARAM)uMode, 0L); |
| } |
| |
| void SetZoomPercent(UINT uPercent) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, EM_SETZOOMPERCENT, (WPARAM)uPercent, 0L); |
| } |
| |
| LONG StreamIn(UINT uFormat, EDITSTREAM& es) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (LONG)::SendMessage(m_hWnd, EM_STREAMIN, (WPARAM)uFormat, (LPARAM)&es); |
| } |
| |
| LONG StreamOut(UINT uFormat, EDITSTREAM& es) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (LONG)::SendMessage(m_hWnd, EM_STREAMOUT, (WPARAM)uFormat, (LPARAM)&es); |
| } |
| |
| void UndoEvent() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, EM_UNDOEVENT, 0, 0L); |
| } |
| |
| // Standard EM_xxx messages |
| DWORD GetSel() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (DWORD)::SendMessage(m_hWnd, EM_GETSEL, 0, 0L); |
| } |
| |
| void GetSel(int& nStartChar, int& nEndChar) const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, EM_GETSEL, (WPARAM)&nStartChar, (LPARAM)&nEndChar); |
| } |
| |
| void ReplaceSel(LPCTSTR lpszNewText, BOOL bCanUndo = FALSE) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, EM_REPLACESEL, (WPARAM)bCanUndo, (LPARAM)lpszNewText); |
| } |
| |
| void SetModify(BOOL bModified = TRUE) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, EM_SETMODIFY, (WPARAM)bModified, 0L); |
| } |
| |
| int GetTextLength() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (int)::SendMessage(m_hWnd, WM_GETTEXTLENGTH, 0, 0L); |
| } |
| |
| // Clipboard operations |
| void Clear() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, WM_CLEAR, 0, 0L); |
| } |
| |
| void Copy() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, WM_COPY, 0, 0L); |
| } |
| |
| void Cut() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, WM_CUT, 0, 0L); |
| } |
| |
| void Paste() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, WM_PASTE, 0, 0L); |
| } |
| }; |
| |
| typedef CRichInkCtrlT<ATL::CWindow> CRichInkCtrl; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CInkXCtrl |
| |
| template <class TBase> |
| class CInkXCtrlT : public TBase |
| { |
| public: |
| // Constructors |
| CInkXCtrlT(HWND hWnd = NULL) : TBase(hWnd) |
| { } |
| |
| CInkXCtrlT< TBase >& operator =(HWND hWnd) |
| { |
| m_hWnd = hWnd; |
| return *this; |
| } |
| |
| HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL, |
| DWORD dwStyle = 0, DWORD dwExStyle = 0, |
| ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) |
| { |
| HWND hWnd = TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); |
| ATLASSERT(hWnd != NULL); // Did you remember to call InitInkX() ?? |
| return hWnd; |
| } |
| |
| // Attributes |
| static LPCTSTR GetWndClassName() |
| { |
| return WC_INKX; |
| } |
| |
| static UINT GetHotRecordingMessage() |
| { |
| return ::RegisterWindowMessage(szHotRecording); |
| } |
| |
| void ClearAll() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, IM_CLEARALL, 0, 0L); |
| } |
| |
| int GetData(BYTE* lpBuffer, INT cbBuffer) const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(lpBuffer); |
| return (int)::SendMessage(m_hWnd, IM_GETDATA, (WPARAM)cbBuffer, (LPARAM)lpBuffer); |
| } |
| |
| int GetDataLen() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (int)::SendMessage(m_hWnd, IM_GETDATALEN, 0, 0L); |
| } |
| |
| CRichInkCtrl GetRichInk() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (HWND)::SendMessage(m_hWnd, IM_GETRICHINK, 0, 0L); |
| } |
| |
| BOOL IsRecording() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (BOOL)::SendMessage(m_hWnd, IM_RECORDING, 0, 0L); |
| } |
| |
| void ReInit() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, IM_REINIT, 0, 0L); |
| } |
| |
| void SetData(const BYTE* lpInkData, INT cbInkData) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(lpInkData); |
| ::SendMessage(m_hWnd, IM_SETDATA, (WPARAM)cbInkData, (LPARAM)lpInkData); |
| } |
| |
| void VoicePlay() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, IM_VOICE_PLAY, 0, 0L); |
| } |
| |
| BOOL IsVoicePlaying() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (BOOL)::SendMessage(m_hWnd, IM_VOICE_PLAYING, 0, 0L); |
| } |
| |
| BOOL VoiceRecord() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (BOOL)::SendMessage(m_hWnd, IM_VOICE_RECORD, 0, 0L); |
| } |
| |
| void VoiceStop() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, IM_VOICE_STOP, 0, 0L); |
| } |
| |
| void ShowVoiceBar(BOOL bShow = TRUE) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, IM_VOICEBAR, (WPARAM)bShow, 0L); |
| } |
| }; |
| |
| typedef CInkXCtrlT<ATL::CWindow> CInkXCtrl; |
| |
| #endif // WIN32_PLATFORM_PSPC |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CVoiceRecorderCtrl |
| |
| template <class TBase> |
| class CVoiceRecorderCtrlT : public TBase |
| { |
| public: |
| // Constructors |
| CVoiceRecorderCtrlT(HWND hWnd = NULL) : TBase(hWnd) |
| { } |
| |
| CVoiceRecorderCtrlT< TBase >& operator =(HWND hWnd) |
| { |
| m_hWnd = hWnd; |
| return *this; |
| } |
| |
| HWND Create(HWND hWndParent, const POINT pt, LPTSTR pstrFileName, UINT nID, DWORD dwStyle = 0) |
| { |
| ATLASSERT(pstrFileName != NULL); |
| CM_VOICE_RECORDER cmvr = { 0 }; |
| cmvr.cb = sizeof(CM_VOICE_RECORDER); |
| cmvr.dwStyle = dwStyle; |
| cmvr.xPos = pt.x; |
| cmvr.yPos = pt.y; |
| cmvr.hwndParent = hWndParent; |
| cmvr.id = nID; |
| cmvr.lpszRecordFileName = pstrFileName; |
| m_hWnd = VoiceRecorder_Create(&cmvr); |
| return m_hWnd; |
| } |
| |
| HWND Create(LPCM_VOICE_RECORDER pAttribs) |
| { |
| ATLASSERT(pAttribs); |
| m_hWnd = VoiceRecorder_Create(pAttribs); |
| return m_hWnd; |
| } |
| |
| // Attributes |
| void Record() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, VRM_RECORD, 0, 0L); |
| } |
| |
| void Play() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, VRM_PLAY, 0, 0L); |
| } |
| |
| void Stop() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, VRM_STOP, 0, 0L); |
| } |
| |
| void Cancel() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, VRM_CANCEL, 0, 0L); |
| } |
| |
| void Done() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, VRM_OK, 0, 0L); |
| } |
| }; |
| |
| typedef CVoiceRecorderCtrlT<ATL::CWindow> CVoiceRecorderCtrl; |
| |
| |
| #ifdef WIN32_PLATFORM_PSPC |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CDocListCtrl |
| |
| template <class TBase> |
| class CDocListCtrlT : public TBase |
| { |
| public: |
| // Attributes |
| DOCLISTCREATE m_dlc; |
| TCHAR m_szPath[MAX_PATH]; |
| |
| // Constructors |
| CDocListCtrlT(HWND hWnd = NULL) : TBase(hWnd) |
| { } |
| |
| CDocListCtrlT< TBase >& operator =(HWND hWnd) |
| { |
| m_hWnd = hWnd; |
| return *this; |
| } |
| |
| HWND Create(HWND hWndParent, WORD wId, LPCTSTR pszFolder = NULL, LPCTSTR pstrFilter = NULL, |
| WORD wFilterIndex = 0, DWORD dwFlags = DLF_SHOWEXTENSION) |
| { |
| ATLASSERT(pstrFilter != NULL); // It seems to need a filter badly!! |
| ::ZeroMemory(&m_dlc, sizeof(DOCLISTCREATE)); |
| ::ZeroMemory(m_szPath, sizeof(m_szPath)); |
| if(pszFolder != NULL) |
| ::lstrcpyn(m_szPath, pszFolder, MAX_PATH - 1); |
| m_dlc.dwStructSize = sizeof(DOCLISTCREATE); |
| m_dlc.hwndParent = hWndParent; |
| m_dlc.pszFolder = m_szPath; |
| m_dlc.pstrFilter = pstrFilter; |
| m_dlc.wFilterIndex = wFilterIndex; |
| m_dlc.wId = wId; |
| m_dlc.dwFlags = dwFlags; |
| m_hWnd = DocList_Create(&m_dlc); |
| return m_hWnd; |
| } |
| |
| HWND Create(DOCLISTCREATE* pDlc) |
| { |
| m_dlc = *pDlc; |
| m_hWnd = DocList_Create(&m_dlc); |
| return m_hWnd; |
| } |
| |
| // Attributes |
| void DeleteSel() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DLM_DELETESEL, 0, 0L); |
| } |
| |
| void DisableUpdates() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DLM_DISABLEUPDATES, 0, 0L); |
| } |
| |
| void EnableUpdates() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DLM_ENABLEUPDATES, 0, 0L); |
| } |
| |
| int GetFilterIndex() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (int)::SendMessage(m_hWnd, DLM_GETFILTERINDEX, 0, 0L); |
| } |
| |
| int GetItemCount() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (int)::SendMessage(m_hWnd, DLM_GETITEMCOUNT, 0, 0L); |
| } |
| |
| int GetNextItem(int iIndex, DWORD dwRelation = LVNI_ALL) const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (int)::SendMessage(m_hWnd, DLM_GETNEXTITEM, (WPARAM)iIndex, (LPARAM)dwRelation); |
| } |
| |
| int GetFirstItem(DWORD dwRelation = LVNI_ALL) const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (int)::SendMessage(m_hWnd, DLM_GETNEXTITEM, (WPARAM)-1, (LPARAM)dwRelation); |
| } |
| |
| BOOL GetNextWave(int* pIndex) const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(pIndex); |
| return (BOOL)::SendMessage(m_hWnd, DLM_GETNEXTWAVE, 0, (LPARAM)pIndex); |
| } |
| |
| BOOL GetPrevWave(int* pIndex) const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(pIndex); |
| return (BOOL)::SendMessage(m_hWnd, DLM_GETPREVWAVE, 0, (LPARAM)pIndex); |
| } |
| |
| int GetSelCount() const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (int)::SendMessage(m_hWnd, DLM_GETSELCOUNT, 0, 0L); |
| } |
| |
| BOOL GetSelPathName(LPTSTR pstrPath, int cchMax) const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(pstrPath); |
| return (BOOL)::SendMessage(m_hWnd, DLM_GETSELPATHNAME, (WPARAM)cchMax, (LPARAM)pstrPath); |
| } |
| |
| void ReceiveIR(LPCTSTR pstrPath) const |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(pstrPath); |
| ::SendMessage(m_hWnd, DLM_RECEIVEIR, 0, (LPARAM)pstrPath); |
| } |
| |
| void Refresh() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DLM_REFRESH, 0, 0L); |
| } |
| |
| BOOL RenameMoveSelectedItems() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (BOOL)::SendMessage(m_hWnd, DLM_RENAMEMOVE, 0, 0L); |
| } |
| |
| int SelectAll() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (int)::SendMessage(m_hWnd, DLM_SELECTALL, 0, 0L); |
| } |
| |
| HRESULT SelectItem(LPCTSTR pstrPath, BOOL bVisible = TRUE) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(pstrPath); |
| return (HRESULT)::SendMessage(m_hWnd, DLM_SELECTITEM, (WPARAM)bVisible, (LPARAM)pstrPath); |
| } |
| |
| void SendEMail(LPCTSTR pstrAttachment) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DLM_SENDEMAIL, 0, (LPARAM)pstrAttachment); |
| } |
| |
| void SendIR(LPCTSTR pstrPath) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DLM_SENDIR, 0, (LPARAM)pstrPath); |
| } |
| |
| HRESULT SetFilterIndex(int iIndex) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (HRESULT)::SendMessage(m_hWnd, DLM_SETFILTERINDEX, (WPARAM)iIndex, 0L); |
| } |
| |
| void SetFolder(LPCTSTR pstrPath) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(pstrPath); |
| ::SendMessage(m_hWnd, DLM_SETFOLDER, 0, (LPARAM)pstrPath); |
| } |
| |
| BOOL SetItemState(int iIndex, const LVITEM* pItem) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(pItem); |
| return (BOOL)::SendMessage(m_hWnd, DLM_SETITEMSTATE, (WPARAM)iIndex, (LPARAM)pItem); |
| } |
| |
| BOOL SetItemState(int iIndex, UINT uState, UINT uMask) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| LV_ITEM lvi = { 0 }; |
| lvi.stateMask = uMask; |
| lvi.state = uState; |
| return (BOOL)::SendMessage(m_hWnd, DLM_SETITEMSTATE, (WPARAM)iIndex, (LPARAM)&lvi); |
| } |
| |
| void SetOneItem(int iIndex, LPCVOID pPA) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DLM_SETONEITEM, (WPARAM)iIndex, (LPARAM)pPA); |
| } |
| |
| void SetSelect(int iIndex) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ::SendMessage(m_hWnd, DLM_SETSELECT, (WPARAM)iIndex, 0L); |
| } |
| |
| void SetSelPathName(LPCTSTR pstrPath) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(pstrPath); |
| ::SendMessage(m_hWnd, DLM_SETSELPATHNAME, 0, (LPARAM)pstrPath); |
| } |
| |
| BOOL SetSortOrder() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (BOOL)::SendMessage(m_hWnd, DLM_SETSORTORDER, 0, 0L); |
| } |
| |
| HRESULT Update() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (HRESULT)::SendMessage(m_hWnd, DLM_UPDATE, 0, 0L); |
| } |
| |
| BOOL ValidateFolder() |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return (BOOL)::SendMessage(m_hWnd, DLM_VALIDATEFOLDER, 0, 0L); |
| } |
| |
| // Functions |
| BOOL GetFirstSelectedWaveFile(int* pIndex, LPTSTR szPath, const size_t cchPath) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return DocList_GetFirstSelectedWaveFile(m_hWnd, pIndex, szPath, cchPath); |
| } |
| |
| BOOL GetNextSelectedWaveFile(int* pIndex, LPTSTR szPath, const size_t cchPath) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| return DocList_GetNextSelectedWaveFile(m_hWnd, pIndex, szPath, cchPath); |
| } |
| }; |
| |
| typedef CDocListCtrlT<ATL::CWindow> CDocListCtrl; |
| |
| #endif // WIN32_PLATFORM_PSPC |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CCapEdit |
| |
| template <class TBase> |
| class CCapEditT : public TBase |
| { |
| public: |
| // Constructors |
| CCapEditT(HWND hWnd = NULL) : TBase(hWnd) |
| { } |
| |
| CCapEditT< TBase >& operator =(HWND hWnd) |
| { |
| m_hWnd = hWnd; |
| return *this; |
| } |
| |
| HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL, |
| DWORD dwStyle = 0, DWORD dwExStyle = 0, |
| ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) |
| { |
| HWND hWnd = /*TBase*/CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); |
| ATLASSERT(hWnd != NULL); // Did you remember to call SHInitExtraControls() ?? |
| return hWnd; |
| } |
| |
| // Attributes |
| static LPCTSTR GetWndClassName() |
| { |
| return WC_CAPEDIT; |
| } |
| }; |
| |
| typedef CCapEditT<WTL::CEdit> CCapEdit; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CTTStatic |
| |
| #ifndef WIN32_PLATFORM_WFSP // Tooltips not supported on SmartPhone |
| |
| template <class TBase> |
| class CTTStaticT : public TBase |
| { |
| public: |
| // Constructors |
| CTTStaticT(HWND hWnd = NULL) : TBase(hWnd) |
| { } |
| |
| CTTStaticT< TBase >& operator =(HWND hWnd) |
| { |
| m_hWnd = hWnd; |
| return *this; |
| } |
| |
| HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL, |
| DWORD dwStyle = 0, DWORD dwExStyle = 0, |
| ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) |
| { |
| HWND hWnd = TBase::Create(hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); |
| ATLASSERT(hWnd != NULL); // Did you remember to call SHInitExtraControls() ?? |
| return hWnd; |
| } |
| |
| // Attributes |
| static LPCTSTR GetWndClassName() |
| { |
| return WC_TSTATIC; |
| } |
| |
| // Operations |
| BOOL SetToolTipText(LPCTSTR pstrTipText) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(pstrTipText); |
| ATLASSERT(lstrlen(pstrTipText)<= 253); |
| CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff; |
| LPTSTR pstr = buff.Allocate(lstrlen(pstrTipText) + 3); |
| if(pstr == NULL) |
| return FALSE; |
| ::lstrcpy(pstr, _T("~~")); |
| ::lstrcat(pstr, pstrTipText); |
| return SetWindowText(pstr); |
| } |
| }; |
| |
| typedef CTTStaticT<WTL::CStatic> CTTStatic; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CTTButton |
| |
| template <class TBase> |
| class CTTButtonT : public TBase |
| { |
| public: |
| // Constructors |
| CTTButtonT(HWND hWnd = NULL) : TBase(hWnd) |
| { } |
| |
| CTTButtonT< TBase >& operator =(HWND hWnd) |
| { |
| m_hWnd = hWnd; |
| return *this; |
| } |
| |
| HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL, |
| DWORD dwStyle = 0, DWORD dwExStyle = 0, |
| ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) |
| { |
| HWND hWnd = TBase::Create(hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam); |
| ATLASSERT(hWnd != NULL); // Did you remember to call SHInitExtraControls() ?? |
| return hWnd; |
| } |
| |
| // Attributes |
| static LPCTSTR GetWndClassName() |
| { |
| return WC_TBUTTON; |
| } |
| |
| // Operations |
| BOOL SetToolTipText(LPCTSTR pstrTipText) |
| { |
| ATLASSERT(::IsWindow(m_hWnd)); |
| ATLASSERT(pstrTipText); |
| ATLASSERT(lstrlen(pstrTipText)<= 253); |
| CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff; |
| LPTSTR pstr = buff.Allocate(lstrlen(pstrTipText) + 3); |
| if(pstr == NULL) |
| return FALSE; |
| ::lstrcpy(pstr, _T("~~")); |
| ::lstrcat(pstr, pstrTipText); |
| return SetWindowText(pstr); |
| } |
| }; |
| |
| typedef CTTButtonT<WTL::CButton> CTTButton; |
| |
| #endif // !WIN32_PLATFORM_WFSP |
| |
| |
| // --- SmartPhone specific controls --- |
| |
| #ifdef WIN32_PLATFORM_WFSP |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CSpinCtrlT - CSpinCtrl : SmartPhone adapted UpDown control |
| |
| template <class TBase> |
| class CSpinCtrlT : public CUpDownCtrlT< TBase > |
| { |
| public: |
| // Constructors |
| CSpinCtrlT(HWND hWnd = NULL) : CUpDownCtrlT< TBase >(hWnd) |
| { } |
| |
| CSpinCtrlT< TBase >& operator =(HWND hWnd) |
| { |
| m_hWnd = hWnd; |
| return *this; |
| } |
| |
| HWND Create(HWND hWndParent, HWND hBuddy, DWORD dwStyle, int nID, LPCTSTR szExpandedName = NULL) |
| { |
| ATLASSERT(::IsWindow(hWndParent)); |
| CUpDownCtrlT< TBase >::Create(hWndParent, NULL, szExpandedName, dwStyle, 0, nID, NULL); |
| ATLASSERT(m_hWnd != NULL); // Did you remember to call AtlInitCommonControls(ICC_UPDOWN_CLASS)? |
| if (hBuddy != NULL) |
| { |
| ATLASSERT(::IsWindow(hBuddy)); |
| SetBuddy(hBuddy); |
| } |
| return m_hWnd; |
| } |
| }; |
| |
| typedef CSpinCtrlT<ATL::CWindow> CSpinCtrl; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CSpinned - SmartPhone association of control and Spin |
| |
| template <class TBase, bool t_bExpandOnly> |
| class CSpinned : public TBase |
| { |
| public: |
| CSpinCtrl m_SpinCtrl; |
| DWORD m_dwSpinnedStyle; |
| |
| // Constructors |
| CSpinned(HWND hWnd = NULL) : TBase(hWnd) |
| { |
| m_dwSpinnedStyle = WS_VISIBLE | UDS_ALIGNRIGHT | UDS_EXPANDABLE; |
| |
| if (t_bExpandOnly == true) |
| m_dwSpinnedStyle |= UDS_NOSCROLL; |
| else |
| m_dwSpinnedStyle |= UDS_HORZ | UDS_ARROWKEYS | UDS_SETBUDDYINT | UDS_WRAP; |
| |
| if (hWnd != NULL) |
| AttachOrCreateSpinCtrl(); |
| } |
| |
| CSpinned<TBase, t_bExpandOnly>& operator =(HWND hWnd) |
| { |
| Attach(hWnd); |
| return *this; |
| } |
| |
| void Attach(HWND hWnd) |
| { |
| ATLASSERT(!IsWindow()); |
| TBase* pT = static_cast<TBase*>(this); |
| pT->m_hWnd = hWnd; |
| if (hWnd != NULL) |
| AttachOrCreateSpinCtrl(); |
| } |
| |
| HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szExpandedName = NULL, |
| DWORD dwStyle = 0, DWORD dwExStyle = 0, |
| ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL) |
| { |
| |
| TBase* pT = static_cast<TBase*>(this); |
| TBase::Create(hWndParent, rect, NULL, dwStyle, dwExStyle, MenuOrID, lpCreateParam); |
| ATLASSERT(pT->m_hWnd != NULL); |
| |
| m_SpinCtrl.Create(hWndParent, pT->m_hWnd, m_dwSpinnedStyle, ATL_IDW_SPIN_ID + (int)MenuOrID.m_hMenu, szExpandedName); |
| |
| ATLASSERT(m_SpinCtrl.m_hWnd != NULL); // Did you remember to call AtlInitCommonControls(ICC_UPDOWN_CLASS)? |
| |
| return pT->m_hWnd; |
| } |
| |
| // Attributes |
| CSpinCtrl& GetSpinCtrl() |
| { |
| return m_SpinCtrl; |
| } |
| |
| // Implementation |
| // Attach our existing SpinCtrl or create one |
| bool AttachOrCreateSpinCtrl() |
| { |
| TBase* pT = static_cast<TBase*>(this); |
| |
| HWND hSpin = ::GetDlgItem(pT->GetParent(), ATL_IDW_SPIN_ID + pT->GetDlgCtrlID()); |
| |
| if (hSpin != NULL) |
| { |
| m_SpinCtrl.Attach(hSpin); |
| #ifdef DEBUG |
| TCHAR sClassName[16]; |
| ::GetClassName(hSpin, sClassName, 16); |
| ATLASSERT(!_tcscmp(sClassName, UPDOWN_CLASS)); |
| ATLASSERT(m_SpinCtrl.GetBuddy().m_hWnd == pT->m_hWnd); |
| #endif // DEBUG |
| } |
| else |
| { |
| m_SpinCtrl.Create(pT->GetParent(), pT->m_hWnd, m_dwSpinnedStyle, ATL_IDW_SPIN_ID + pT->GetDlgCtrlID()); |
| } |
| |
| return m_SpinCtrl.m_hWnd != NULL; |
| } |
| }; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // CSpinListBox - SmartPhone spinned ListBox control |
| // CExpandListBox - SmartPhone expandable ListBox control |
| // CExpandEdit - SmartPhone expandable Edit control |
| // CExpandCapEdit - SmartPhone expandable CapEdit control |
| |
| typedef CSpinned<CListBox, false> CSpinListBox; |
| typedef CSpinned<CListBox, true> CExpandListBox; |
| typedef CSpinned<CEdit, true> CExpandEdit; |
| typedef CSpinned<CCapEdit, true> CExpandCapEdit; |
| |
| #endif // WIN32_PLATFORM_WFSP |
| |
| #endif // _WTL_CE_NO_CONTROLS |
| |
| }; // namespace WTL |
| |
| #endif // __ATLWINCE_H__ |