mainfrm.h

WTL 实现WINCE 下slide view的源码

// MainFrm.h : interface of the CMainFrame class
//
/////////////////////////////////////////////////////////////////////////////

#pragma once
#include <atlcrack.h>
#include "ChildViewAnimate.h"


class CMainFrame :	public CFrameWindowImpl<CMainFrame>, 
					public CUpdateUI<CMainFrame>,
					public CChildViewAnimate<CMainFrame>,
					public CMessageFilter, 
					public CIdleHandler
{
private:
	CSlideFormView	m_viewForm;
	CSlideTreeView	m_viewTree;
	CSlideListView	m_viewList;
#ifdef WIN32_PLATFORM_PSPC
	CSelectionBar	m_selBar;
#endif
	ViewAnimation	m_nAnimate;

	void UpdateAnimateMenu(int nID)
	{
		UISetCheck(ID_ANIMATE_LEFT,		nID == ID_ANIMATE_LEFT	);
		UISetCheck(ID_ANIMATE_RIGHT,	nID == ID_ANIMATE_RIGHT	);
		UISetCheck(ID_ANIMATE_UP,		nID == ID_ANIMATE_UP	);
		UISetCheck(ID_ANIMATE_DOWN,		nID == ID_ANIMATE_DOWN	);
		UISetCheck(ID_ANIMATE_NONE,		nID == ID_ANIMATE_NONE	);
	}

public:

	DECLARE_FRAME_WND_CLASS(NULL, IDR_MAINFRAME)

	CMainFrame()
	:	m_nAnimate	(None)
	{
	}

	virtual BOOL PreTranslateMessage(MSG* pMsg)
	{
		if(CFrameWindowImpl<CMainFrame>::PreTranslateMessage(pMsg))
			return TRUE;

		return ChildPreTranslateMessage(pMsg);
	}

	virtual BOOL OnIdle()
	{
		return FALSE;
	}

	BEGIN_UPDATE_UI_MAP(CMainFrame)
		UPDATE_ELEMENT(ID_ANIMATE_LEFT,		UPDUI_MENUPOPUP)
		UPDATE_ELEMENT(ID_ANIMATE_RIGHT,	UPDUI_MENUPOPUP)
		UPDATE_ELEMENT(ID_ANIMATE_UP,		UPDUI_MENUPOPUP)
		UPDATE_ELEMENT(ID_ANIMATE_DOWN,		UPDUI_MENUPOPUP)
		UPDATE_ELEMENT(ID_ANIMATE_NONE,		UPDUI_MENUPOPUP)
	END_UPDATE_UI_MAP()

	BEGIN_MSG_MAP(CMainFrame)
		MESSAGE_HANDLER(WM_CREATE, OnCreate)
		COMMAND_ID_HANDLER(ID_ACTION, OnAction)
		COMMAND_ID_HANDLER(ID_APP_EXIT, OnFileExit)
		COMMAND_ID_HANDLER(ID_FILE_NEW, OnFileNew)
		COMMAND_ID_HANDLER(ID_APP_ABOUT, OnAppAbout)
		COMMAND_ID_HANDLER_EX(ID_VIEW_LIST, OnViewList)
		COMMAND_ID_HANDLER_EX(ID_VIEW_TREE, OnViewTree)
		COMMAND_ID_HANDLER_EX(ID_VIEW_FORM, OnViewForm)
		COMMAND_ID_HANDLER_EX(ID_ANIMATE_DOWN, OnAnimateDown)
		COMMAND_ID_HANDLER_EX(ID_ANIMATE_LEFT, OnAnimateLeft)
		COMMAND_ID_HANDLER_EX(ID_ANIMATE_NONE, OnAnimateNone)
		COMMAND_ID_HANDLER_EX(ID_ANIMATE_RIGHT, OnAnimateRight)
		COMMAND_ID_HANDLER_EX(ID_ANIMATE_UP, OnAnimateUp)
		CHAIN_MSG_MAP(CUpdateUI<CMainFrame>)
		CHAIN_MSG_MAP(CFrameWindowImpl<CMainFrame>)

		REFLECT_NOTIFICATIONS()
	END_MSG_MAP()

// Handler prototypes (uncomment arguments if needed):
//	LRESULT MessageHandler(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
//	LRESULT CommandHandler(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
//	LRESULT NotifyHandler(int /*idCtrl*/, LPNMHDR /*pnmh*/, BOOL& /*bHandled*/)

	LRESULT OnCreate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
	{
		CreateSimpleCEMenuBar(IDR_MAINFRAME, SHCMBF_HMENU);

		m_hWndClient	= m_viewForm.Create(m_hWnd);

#ifdef WIN32_PLATFORM_PSPC
		m_hWndToolBar	= m_selBar.Create(m_hWnd);
		if(m_hWndToolBar)
		{
			m_selBar.SetTitle	(SBB_LEFT,  _T("Animate"));
			m_selBar.SetOption	(SBB_LEFT,	_T("None"));
			m_selBar.SetMenu	(SBB_LEFT,	MAKEINTRESOURCE(IDR_ANIMATE));

			m_selBar.SetTitle	(SBB_RIGHT, _T("Views"));
			m_selBar.SetOption	(SBB_RIGHT, _T("Form"));
			m_selBar.SetMenu	(SBB_RIGHT, MAKEINTRESOURCE(IDR_VIEWS));
		}
#endif

		m_pView = &m_viewForm;

		// register object for message filtering and idle updates
		CMessageLoop* pLoop = _Module.GetMessageLoop();
		ATLASSERT(pLoop != NULL);
		pLoop->AddMessageFilter(this);
		pLoop->AddIdleHandler(this);

		UpdateAnimateMenu(ID_ANIMATE_NONE);

		return 0;
	}

	LRESULT OnAction(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
	{
		// TODO: add code

		return 0;
	}

	LRESULT OnFileExit(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
	{
		PostMessage(WM_CLOSE);
		return 0;
	}

	LRESULT OnFileNew(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
	{
		// TODO: add code to initialize document

		return 0;
	}

	LRESULT OnAppAbout(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
	{
		CAboutDlg dlg;
		dlg.DoModal();
		return 0;
	}

	static HRESULT ActivatePreviousInstance(HINSTANCE hInstance)
	{
		CFrameWndClassInfo& classInfo = CMainFrame::GetWndClassInfo();
		ATLVERIFY(::LoadString(hInstance, IDR_MAINFRAME, classInfo.m_szAutoName, sizeof(classInfo.m_szAutoName)/sizeof(classInfo.m_szAutoName[0])));
		classInfo.m_wc.lpszClassName = classInfo.m_szAutoName;
		const TCHAR* pszClass = classInfo.m_wc.lpszClassName;
		if(pszClass == NULL || *pszClass == _T('\0'))
		{
			return E_FAIL;
		}

		// Orginally 500ms in SmartPhone 2003 App Wizard generated code
		// A lower value will result in a more responsive start-up of 
		// the existing instance or termination of this instance.
		const DWORD dRetryInterval = 100; 

		// Orginally 5 in SmartPhone 2003 App Wizard generated code
		// Multiplied by 5, since wait time was divided by 5.
		const int iMaxRetries = 25;

		for(int i = 0; i < iMaxRetries; ++i)
		{
			// Don't need ownership of the mutex
			HANDLE hMutex = CreateMutex(NULL, FALSE, pszClass);

			DWORD dw = GetLastError();

			if(hMutex == NULL)
			{
				// ERROR_INVALID_HANDLE - A non-mutex object with this name already exists.
				HRESULT hr = (dw == ERROR_INVALID_HANDLE) ? E_INVALIDARG : E_FAIL;
				return hr;
			}

			// If the mutex already exists, then there should be another instance running
			if(dw == ERROR_ALREADY_EXISTS)
			{
				// Just needed the error result, in this case, so close the handle.
				CloseHandle(hMutex);

				// Try to find the other instance, don't need to close HWND's.
				// Don't check title in case it is changed by app after init.
				HWND hwnd = FindWindow(pszClass, NULL);

				if(hwnd == NULL)
				{
					// It's possible that the other istance is in the process of starting up or shutting down.
					// So wait a bit and try again.
					Sleep(dRetryInterval);
					continue;
				}
				else
				{
					// Set the previous instance as the foreground window

					// The "| 0x1" in the code below activates the correct owned window 
					// of the previous instance's main window according to the SmartPhone 2003
					// wizard generated code.
					if(SetForegroundWindow(reinterpret_cast<HWND>(reinterpret_cast<ULONG>(hwnd) | 0x1)) != 0)
					{
						// S_FALSE indicates that another instance was activated, so this instance should terminate.
						return S_FALSE;
					}
				}
			}
			else
			{
				// This is the first istance, so return S_OK.
				// Don't close the mutext handle here.
				// Do it on app shutdown instead.
				return S_OK;
			}
		}

		// The mutex was created by another instance, but it's window couldn't be brought
		// to the foreground, so ssume  it's not a invalid instance (not this app, hung, etc.)
		// and let this one start.
		return S_OK;
	}

	LRESULT OnViewList(WORD wNotifyCode, WORD wID, HWND hWndCtl)
	{
		HWND	hWnd	= m_viewList.m_hWnd;

		if(hWnd == NULL)
		{
			int		nWidth;
			DWORD	dwStyle	= WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | LVS_REPORT | LVS_SHOWSELALWAYS;
			CRect	rc;
			CWindow	wndView(*m_pView);

			wndView.GetClientRect(&rc);

			nWidth		= rc.Width();
			rc.left		+= nWidth;
			rc.right	+= nWidth;

			hWnd = m_viewList.Create(m_hWnd, &rc, NULL, dwStyle);
			if(hWnd)
			{
				m_viewList.InsertColumn(0, _T("View"), LVCFMT_LEFT, 80, -1);

				m_viewList.InsertItem(0, _T("Form"));
				m_viewList.InsertItem(1, _T("List"));
				m_viewList.InsertItem(2, _T("Tree"));
			}
		}

		if(hWnd != NULL)
		{
			SwitchToView(&m_viewList, m_nAnimate);
#ifdef WIN32_PLATFORM_PSPC
			m_selBar.SetOption(SBB_RIGHT, _T("List"));
#endif
		}

		return 0;
	}

	LRESULT OnViewTree(WORD wNotifyCode, WORD wID, HWND hWndCtl)
	{
		HWND hWnd = m_viewTree.m_hWnd;

		if(hWnd == NULL)
		{
			int		nWidth;
			DWORD	dwStyle	= WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;// | TVS_HASBUTTONS | TVS_HASLINES | TVS_LINESATROOT | TVS_SHOWSELALWAYS;
			CRect	rc;
			CWindow	wndView(*m_pView);

			wndView.GetClientRect(&rc);

			nWidth		= rc.Width();
			rc.left		+= nWidth;
			rc.right	+= nWidth;

			hWnd = m_viewTree.Create(m_hWnd, &rc, NULL, dwStyle);
			if(hWnd)
			{
			}
		}

		if(hWnd != NULL)
		{
			SwitchToView(&m_viewTree, m_nAnimate);
#ifdef WIN32_PLATFORM_PSPC
			m_selBar.SetOption(SBB_RIGHT, _T("Tree"));
#endif
		}

		return 0;
	}

	LRESULT OnViewForm(WORD wNotifyCode, WORD wID, HWND hWndCtl)
	{
		SwitchToView(&m_viewForm, m_nAnimate);
#ifdef WIN32_PLATFORM_PSPC
		m_selBar.SetOption(SBB_RIGHT, _T("Form"));
#endif
		return 0;
	}

	LRESULT OnAnimateDown(WORD wNotifyCode, WORD wID, HWND hWndCtl)
	{
		m_nAnimate = ScrollDown;
#ifdef WIN32_PLATFORM_PSPC
		m_selBar.SetOption(SBB_LEFT, _T("Down"));
#endif
		UpdateAnimateMenu(ID_ANIMATE_DOWN);
		return 0;
	}

	LRESULT OnAnimateLeft(WORD wNotifyCode, WORD wID, HWND hWndCtl)
	{
		m_nAnimate = ScrollLeft;
#ifdef WIN32_PLATFORM_PSPC
		m_selBar.SetOption(SBB_LEFT, _T("Left"));
#endif
		UpdateAnimateMenu(ID_ANIMATE_LEFT);
		return 0;
	}

	LRESULT OnAnimateNone(WORD wNotifyCode, WORD wID, HWND hWndCtl)
	{
		m_nAnimate = None;
#ifdef WIN32_PLATFORM_PSPC
		m_selBar.SetOption(SBB_LEFT, _T("None"));
#endif
		UpdateAnimateMenu(ID_ANIMATE_NONE);
		return 0;
	}

	LRESULT OnAnimateRight(WORD wNotifyCode, WORD wID, HWND hWndCtl)
	{
		m_nAnimate = ScrollRight;
#ifdef WIN32_PLATFORM_PSPC
		m_selBar.SetOption(SBB_LEFT, _T("Right"));
#endif
		UpdateAnimateMenu(ID_ANIMATE_RIGHT);
		return 0;
	}

	LRESULT OnAnimateUp(WORD wNotifyCode, WORD wID, HWND hWndCtl)
	{
		m_nAnimate = ScrollUp;
#ifdef WIN32_PLATFORM_PSPC
		m_selBar.SetOption(SBB_LEFT, _T("Up"));
#endif
		UpdateAnimateMenu(ID_ANIMATE_UP);
		return 0;
	}
};