#include "StdAfx.h"
#include "CeWnd.h"
#include "CeMisc.h"
#ifdef _DEBUG
///////////////////////////////////////////////////////////////////////////////
//
// CeTrace - write a variable argument string to the debug output device
//
///////////////////////////////////////////////////////////////////////////////
void CeTrace(LPCTSTR lpszFormat, ...)
{
va_list args;
va_start(args, lpszFormat);
TCHAR szBuffer[1024];
wvsprintf(szBuffer, lpszFormat, args);
::OutputDebugString(szBuffer);
va_end(args);
}
///////////////////////////////////////////////////////////////////////////////
//
// CeAssert - checks the passed expression, breaks into the debugger if the
// boolean expression is false
//
///////////////////////////////////////////////////////////////////////////////
void CeAssert(BOOL bExp, LPCTSTR lpszExp)
{
if (! bExp)
{
::CeTrace(_T("%s\n"), lpszExp);
int nResp = ::MessageBox(NULL, lpszExp, _T("Debug Assert Failed!"), MB_OKCANCEL);
if (nResp == IDCANCEL)
DebugBreak();
}
}
#endif
// called only the first time, binds the window to a pointer and
// sets the window proc
LRESULT CALLBACK CeWnd::StartWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
CeWnd* pWnd = (CeWnd*) ::GetWindowLong(hWnd, GWL_USERDATA);
if (NULL != pWnd)
{
// we don't know ANYTHING about this window
TRACE0("WARNING: Received starting message from UNKNOWN WINDOW\n");
return ::DefWindowProc(hWnd, uMsg, wParam, lParam);
}
// TRACE(_T("pWnd = %x, hWnd = %x, uMsg = 0x%x, wParam = %x, lParam = %x\n"), pWnd, hWnd, uMsg, wParam, lParam);
// Note: _FIRST_WM_MESSAGE must be WM_NCCREATE or WM_CREATE
if (_FIRST_WM_MESSAGE == uMsg)
{
LPCREATESTRUCT lpCS = (LPCREATESTRUCT) lParam;
pWnd = (CeWnd*) lpCS->lpCreateParams;
CHW_ASSERT(ISVALIDPTR(pWnd, sizeof *pWnd));
::SetWindowLong(hWnd, GWL_WNDPROC, (LONG) WndProc);
::SetWindowLong(hWnd, GWL_USERDATA, (LONG) pWnd);
pWnd->OnFirstMessage(hWnd);
pWnd->m_hWnd = hWnd;
#ifdef STRICT
return CallWindowProc(WndProc, hWnd, uMsg, wParam, lParam);
#else
return CallWindowProc((FARPROC) WndProc, hWnd, uMsg, wParam, lParam);
#endif
}
else
{
// need to wait for the FIRST message to get the create params
// to bind the window to this message
return ::DefWindowProc(hWnd, uMsg, wParam, lParam);
}
}
///////////////////////////////////////////////////////////////////////////////
//
// WndProc - window message ALL CeWnd messages are processed through, also
// binds the window to the CREATESTRUCT passed in if the window
// hasn't been bound yet
//
///////////////////////////////////////////////////////////////////////////////
LRESULT CALLBACK CeWnd::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LRESULT lRet = 0; // default
CeWnd* pWnd = (CeWnd*) ::GetWindowLong(hWnd, GWL_USERDATA);
// TRACE(_T("pWnd = %x, hWnd = %x, uMsg = 0x%x, wParam = %x, lParam = %x\n"), pWnd, hWnd, uMsg, wParam, lParam);
if (NULL == pWnd)
{
// we don't know ANYTHING about this window
TRACE0("WARNING: Received window message from UNKNOWN WINDOW\n");
return ::DefWindowProc(hWnd, uMsg, wParam, lParam);
}
else
{
CHW_ASSERT(ISVALIDPTR(pWnd, sizeof *pWnd));
//CHW_ASSERT(pWnd->m_hWnd == hWnd);
}
// keep message for default call
pWnd->m_cemsg.hwnd = hWnd;
pWnd->m_cemsg.uMsg = uMsg;
pWnd->m_cemsg.wParam = wParam;
pWnd->m_cemsg.lParam = lParam;
bool bHandled = false; // not handled by default
// encapsulate external calls in exception handlers, CE doesn't do a
// good job of showing exception conditions in the UI
__try
{
// what to return as a result of handling message
lRet = pWnd->ProcessMessage(uMsg, wParam, lParam, bHandled);
if (! bHandled)
lRet = pWnd->Default();
if (_LAST_WM_MESSAGE == uMsg)
{
// we received the LAST message we're going to to get
// unsubclass the window
if (NULL != pWnd->m_lpfnOldWndProc)
{
// restore the window to the old window proc
::SetWindowLong(pWnd->m_hWnd, GWL_WNDPROC, (LONG) pWnd->m_lpfnOldWndProc);
}
else
{
// the window was our class but we're going away, so just set to default
// so the messages get processed anyway
::SetWindowLong(pWnd->m_hWnd, GWL_WNDPROC, (LONG) ::DefWindowProc);
}
// clear out window handle
HWND hWnd = pWnd->m_hWnd;
pWnd->m_hWnd = NULL;
// allow derived classes to clean up after window is destroyed
pWnd->OnFinalMessage(hWnd);
}
}
__except (EXCEPTION_EXECUTE_HANDLER)
{
TCHAR szErr[256];
wsprintf(szErr, _T("Window message (0x%04x) termainated abnormally by an exception"), uMsg);
::MessageBox(NULL, szErr, _T("Fatal"), MB_OK | MB_ICONSTOP);
}
return lRet;
}
BOOL CeWnd::Subclass(UINT nID, HWND hWndParent)
{
return Subclass( ::GetDlgItem(hWndParent, nID) );
}
BOOL CeWnd::Subclass(HWND hWnd)
{
CHW_ASSERT(m_hWnd == NULL);
if (NULL != m_hWnd)
return FALSE;
m_lpfnOldWndProc = (WNDPROC) ::GetWindowLong(hWnd, GWL_WNDPROC);
::SetWindowLong(hWnd, GWL_USERDATA, (LONG) this);
::SetWindowLong(hWnd, GWL_WNDPROC, (LONG) WndProc);
return Attach(hWnd);
}
HWND CeWnd::Unsubclass()
{
SetWindowLong(GWL_USERDATA, 0);
if (NULL != m_lpfnOldWndProc)
{
// restore the window to the old window proc
::SetWindowLong(m_hWnd, GWL_WNDPROC, (LONG) m_lpfnOldWndProc);
}
else
{
// the window was our class but we're going away, so just set to default
// so the messages get processed anyway
::SetWindowLong(m_hWnd, GWL_WNDPROC, (LONG) ::DefWindowProc);
}
return Detach();
}
///////////////////////////////////////////////////////////////////////////////
//
// ProcessMessage -
//
///////////////////////////////////////////////////////////////////////////////
LRESULT CeMsgWnd::ProcessMessage(UINT uMsg, WPARAM wParam, LPARAM lParam, bool& bHandled)
{
LRESULT lRet = 0; // default WndProc result
POINT pt;
bHandled = false; // we didn't handle it, but gave the oppertunity
switch (uMsg)
{
#ifndef _WIN32_WCE
case WM_QUERYENDSESSION: lRet = OnQueryEndSession((UINT) wParam, (UINT) lParam, bHandled );
break;
case WM_ENDSESSION: OnEndSession((BOOL) wParam, (UINT) lParam, bHandled );
break;
#endif
case WM_CHAR: OnChar((UINT) wParam, LOWORD(lParam), HIWORD(lParam), bHandled);
break;
case WM_CLOSE:
TRACE0("OnClose\n");
OnClose(bHandled);
break;
case WM_COMMAND:
TRACE0("OnCommand\n");
lRet = OnCommand(wParam, lParam, bHandled);
break;
case WM_CREATE: OnCreate( (LPCREATESTRUCT) lParam, bHandled );
break;
case WM_DESTROY: OnDestroy( bHandled );
break;
case WM_ENABLE: OnEnable( (BOOL) wParam, bHandled );
break;
case WM_ERASEBKGND: lRet = OnEraseBkgnd( (HDC) wParam, bHandled);
break;
case WM_KEYDOWN: OnKeyDown((UINT) wParam, LOWORD(lParam), HIWORD(lParam), bHandled);
break;
case WM_KEYUP: OnKeyUp((UINT) wParam, LOWORD(lParam), HIWORD(lParam), bHandled);
break;
case WM_LBUTTONDBLCLK: pt.x = LOWORD(lParam); pt.y = HIWORD(lParam);
OnLButtonDblClk( wParam, pt, bHandled );
break;
case WM_LBUTTONDOWN: pt.x = LOWORD(lParam); pt.y = HIWORD(lParam);
OnLButtonDown( wParam, pt, bHandled );
break;
case WM_LBUTTONUP: pt.x = LOWORD(lParam); pt.y = HIWORD(lParam);
OnLButtonUp( wParam, pt, bHandled );
break;
case WM_MOUSEMOVE: pt.x = LOWORD(lParam); pt.y = HIWORD(lParam);
OnMouseMove( wParam, pt, bHandled );
break;
case WM_MOVE: OnMove( LOWORD(lParam), HIWORD(lParam), bHandled );
break;
case WM_NOTIFY:
lRet = OnNotify((int) wParam, (LPNMHDR) lParam, bHandled);
break;
case WM_PAINT: OnPaint( bHandled );
break;
#ifndef _WIN32_WCE
case WM_SETCURSOR: lRet = OnSetCursor((HWND) wParam, LOWORD(lParam), HIWORD(lParam), bHandled );
break;
#endif
case WM_SHOWWINDOW: OnShowWindow( (BOOL) wParam, (int) lParam, bHandled );
break;
case WM_SIZE: OnSize( wParam, LOWORD(lParam), HIWORD(lParam), bHandled );
break;
case WM_TIMER: OnTimer( wParam, bHandled );
break;
case WM_SETTINGCHANGE: OnSettingChange( wParam, (LPCTSTR)lParam, bHandled );
break;
default: lRet = OnMessage( uMsg, wParam, lParam, bHandled );
break;
}
return lRet;
}
///////////////////////////////////////////////////////////////////////////////
//
// RegisterClass - Registers a window class for later use in a CeWnd derived
// class
//
///////////////////////////////////////////////////////////////////////////////
bool CeWnd::RegisterClass(LPCTSTR lpszClassName, UINT style, int cbClsExtra,
int cbWndExtra, HICON hIcon, HCURSOR hCursor, HBRUSH hbrBackground,
LPCTSTR lpszMenuName, HINSTANCE hInst)
{
WNDCLASS wc;
if (hInst == NULL)
hInst = CeGetAppInstance();
wc.lpszClassName = lpszClassName;
wc.lpfnWndProc = StartWndProc; // default proc for first message
wc.style = style;
wc.cbClsExtra = cbClsExtra;
wc.cbWndExtra = cbWndExtra;
wc.hInstance = hInst;
wc.hIcon = hIcon;
wc.hCursor = hCursor;
wc.hbrBackground = hbrBackground;
if (NULL == hbrBackground)
wc.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
wc.lpszMenuName = lpszMenuName;
#ifdef _WIN32_WCE
wc.hCursor = NULL;
wc.lpszMenuName = NULL;
#endif
ATOM a;
a = ::RegisterClass(&wc);
return (0 != a);
}
///////////////////////////////////////////////////////////////////////////////
//
// RegisterWndSuperclass -
//
///////////////////////////////////////////////////////////////////////////////
LPCTSTR CeWnd::CreateGenericWndClass(HINSTANCE hInst)
{
static bool bRegistered = false;
if (! bRegistered)
{
WNDCLASS wc;
if (hInst == NULL)
hInst = CeGetAppInstance();
wc.style = 0 ;
wc.lpfnWndProc = (WNDPROC) StartWndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInst;
wc.hIcon = NULL;
wc.hCursor = NULL;
wc.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
wc.lpszMenuName = NULL;
wc.lpszClassName = WC_CEGENERICWNDCLASS;
::RegisterClass(&wc);
bRegistered = true;
}
return WC_CEGENERICWNDCLASS;
}
///////////////////////////////////////////////////////////////////////////////
//
// RegisterWndSuperclass -
//
///////////////////////////////////////////////////////////////////////////////
BOOL CeWnd::RegisterWndSuperclass(LPCTSTR lpszClass, WNDPROC& lpfnWndProc, HINSTANCE hInst)
{
// allocate a buffer big enough for the class name + 7 double byte characters
LPTSTR lpszWndClass = (LPTSTR)_alloca((lstrlen(lpszClass) + 14) * sizeof(TCHAR));
lpfnWndProc = NULL;
if (hInst == NULL)
hInst = CeGetAppInstance();
// either a global class or preregistered
WNDCLASS wc;
if (::GetClassInfo(NULL, lpszClass, &wc))
{
wsprintf(lpszWndClass, _T("CeWnd:%s"), lpszClass);
// setup the old
lpfnWndProc = wc.lpfnWndProc;
// Check if it's already registered as a CeWnd class
WNDCLASS wc1;
if (wc.lpfnWndProc != CeWnd::WndProc || 0 == GetClassInfo(NULL, lpszWndClass, &wc1))
{
// register the class as a superclass
wc.lpszClassName = lpszWndClass;
wc.lpfnWndProc = StartWndProc;
wc.hInstance = hInst;
wc.style &= ~CS_GLOBALCLASS; // we don't register global classes
return ::RegisterClass(&wc);
}
}
return TRUE;
}
///////////////////////////////////////////////////////////////////////////////
//
// Default - Calls either the default window procedure or the
// subclassed window procedure for the active message
//
///////////////////////////////////////////////////////////////////////////////
LRESULT CeMsgWnd::Default()
{
if (m_lpfnOldWndProc)
{
#ifdef STRICT
return CallWindowProc((WNDPROC) m_lpfnOldWndProc, m_cemsg.hwnd,
m_cemsg.uMsg, m_cemsg.wParam, m_cemsg.lParam);
#else
return CallWindowProc((FARPROC) m_lpfnOldWndProc, m_cemsg.hwnd,
m_cemsg.uMsg, m_cemsg.wParam, m_cemsg.lParam);
#endif
}
else
return DefWindowProc(m_cemsg.hwnd, m_cemsg.uMsg, m_cemsg.wParam, m_cemsg.lParam);
}
///////////////////////////////////////////////////////////////////////////////
//
// IsCeWndProc - Checks to see if the class being passed in is already been
// subclassed by us.
//
///////////////////////////////////////////////////////////////////////////////
BOOL CeWnd::IsCeWndProc(LPCTSTR lpstrWndClass, HINSTANCE hInst)
{
WNDCLASS wc;
if (hInst == NULL)
hInst = CeGetAppInstance();
return (::GetClassInfo(hInst, lpstrWndClass, &wc) && wc.lpfnWndProc == CeWnd::WndProc);
}
///////////////////////////////////////////////////////////////////////////////
//
// Create - Create a child window
//
///////////////////////////////////////////////////////////////////////////////
BOOL CeWnd::Create(LPCTSTR lpstrWndClass, HWND hWndParent,
const RECT& rcPos, LPCTSTR szWindowName, DWORD dwStyle, DWORD dwExStyle,
UINT nID, HINSTANCE hInst)
{
LPCTSTR lpszClass;
if (hInst == NULL)
hInst = CeGetAppInstance();
// we have a valid window class find out if it is subclassed to our window proc
// otherwise subclass and replace the window class window proc
if (NULL != lpstrWndClass && 0 != lstrlen(lpstrWndClass))
{
if (! IsCeWndProc(lpstrWndClass, hInst))
{
RegisterWndSuperclass(lpstrWndClass, m_lpfnOldWndProc, hInst);
lpszClass = (LPTSTR)_alloca((lstrlen(lpstrWndClass) + 14) * sizeof(TCHAR));
wsprintf((LPTSTR) lpszClass, _T("CeWnd:%s"), lpstrWndClass);
}
}
if (NULL == lpstrWndClass || 0 == lstrlen(lpstrWndClass))
lpszClass = CreateGenericWndClass(hInst);
HWND hWnd = ::CreateWindowEx(dwExStyle, lpszClass, szWindowName,
dwStyle, rcPos.left, rcPos.top, rcPos.right - rcPos.left,
rcPos.bottom - rcPos.top, hWndParent, (HMENU)nID,
hInst, this);
return (NULL != hWnd && hWnd == m_hWnd);
}
///////////////////////////////////////////////////////////////////////////////
//
// Create - Create a popup window
//
///////////////////////////////////////////////////////////////////////////////
BOOL CeWnd::Create(LPCTSTR lpstrWndClass, HWND hWndParent,
LPCRECT lpRect, LPCTSTR szWindowName, DWORD dwStyle, DWORD dwExStyle,
HMENU hMenu, HINSTANCE hInst)
{
static RECT rcDefault = {CW_USEDEFAULT, CW_USEDEFAULT, 0, 0};
if (lpRect == NULL)
lpRect = &rcDefault;
return Create(lpstrWndClass,
hWndParent,
lpRect->left,
lpRect->top,
lpRect->right - lpRect->left,
lpRect->bottom - lpRect->top,
szWindowName,
dwStyle,
dwExStyle,
hMenu,
hInst);
}
BOOL CeWnd::Create(LPCTSTR lpstrWndClass, HWND hWndParent,
int x, int y, int cx, int cy, LPCTSTR szWindowName, DWORD dwStyle, DWORD dwExStyle,
HMENU hMenu, HINSTANCE hInst)
{
if (hInst == NULL)
hInst = CeGetAppInstance();
LPCTSTR lpszClass;
// we have a valid window class find out if it is sibclassed to our window proc
// otherwise subclass and replace the window class window proc
if (NULL != lpstrWndClass && 0 != lstrlen(lpstrWndClass))
{
if (! IsCeWndProc(lpstrWndClass, hInst))
{
RegisterWndSuperclass(lpstrWndClass, m_lpfnOldWndProc, hInst);
lpszClass = (LPTSTR)_alloca((lstrlen(lpstrWndClass) + 14) * sizeof(TCHAR));
wsprintf((LPTSTR) lpszClass, _T("CeWnd:%s"), lpstrWndClass);
}
}
if (NULL == lpstrWndClass || 0 == lstrlen(lpstrWndClass))
lpszClass = CreateGenericWndClass(hInst);
HWND hWnd = ::CreateWindowEx(dwExStyle, lpszClass, szWindowName,
dwStyle, x, y, cx, cy, hWndParent, hMenu, hInst, this);
return (NULL != hWnd && hWnd == m_hWnd);
}
/* static */
BOOL CeBaseWnd::ModifyStyle(HWND hWnd, DWORD dwRemove, DWORD dwAdd, UINT nFlags)
{
ASSERT(hWnd != NULL);
DWORD dwStyle = ::GetWindowLong(hWnd, GWL_STYLE);
DWORD dwNewStyle = (dwStyle & ~dwRemove) | dwAdd;
if (dwStyle == dwNewStyle)
return FALSE;
::SetWindowLong(hWnd, GWL_STYLE, dwNewStyle);
if (nFlags != 0)
{
::SetWindowPos(hWnd, NULL, 0, 0, 0, 0,
SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | nFlags);
}
return TRUE;
}
BOOL CeBaseWnd::ModifyStyle(DWORD dwRemove, DWORD dwAdd, UINT nFlags)
{
return ModifyStyle(m_hWnd, dwRemove, dwAdd, nFlags);
}
#ifdef _WIN32_WCE
BOOL CeBaseWnd::GetScrollRange(int nBar, LPINT lpMinPos, LPINT lpMaxPos) const
{
SCROLLINFO si;
memset( &si, 0, sizeof(SCROLLINFO) );
si.cbSize = sizeof(SCROLLINFO);
si.fMask = SIF_RANGE;
if(! GetScrollInfo( nBar, &si))
return (FALSE);
*lpMinPos = si.nMin;
*lpMaxPos = si.nMax;
return TRUE;
}
int CeBaseWnd::GetScrollPos(int nBar) const
{
BOOL bIsOK = FALSE;
SCROLLINFO si;
memset(&si, 0, sizeof(SCROLLINFO));
si.cbSize = sizeof(SCROLLINFO);
si.fMask = SIF_POS;
if(!GetScrollInfo(nBar, &si))
return 0;
return si.nPos;
}
#endif // _WIN32_WCE
BOOL CeBaseWnd::ShowScrollBar(int nBar, BOOL bShow)
{
// WinCE: this workaround doesn't work with x86em
#if defined(_WIN32_WCE_EMULATION)
return TRUE;
#else // _WIN32_WCE_EMULATION
DWORD dwStyle = GetStyle();
if(bShow)
dwStyle |= ((nBar == SB_HORZ) ? WS_HSCROLL : WS_VSCROLL);
else
dwStyle &= ~((nBar == SB_HORZ) ? WS_HSCROLL : WS_VSCROLL);
return (SetWindowLong(GWL_STYLE, dwStyle) != 0);
#endif // _WIN32_WCE_EMULATION
return TRUE;
}
/*
void wce_ScrollChildren(HWND hWnd, int cx, int cy)
{
// WinCE does not perform any scrolling if the window is
// not visible. This leaves child windows unscrolled.
// To account for this oversight, the child windows are moved
// directly instead.
HWND hWndChild = ::GetWindow(hWnd, GW_CHILD);
if (hWndChild != NULL)
{
for (; hWndChild != NULL;
hWndChild = ::wce_GetNextWindow(hWndChild, GW_HWNDNEXT))
{
RECT rect;
::GetWindowRect(hWndChild, &rect);
::ScreenToClient(hWnd,(POINT*)&rect.left);
::SetWindowPos(hWndChild, NULL, rect.left-cx, rect.top-cy,
0, 0, SWP_NOSIZE|SWP_NOACTIVATE|SWP_NOZORDER);
}
}
}
*/
///////////////////////////////////////////////////////////////////////////////
//
// Create - Center the window from the parent
//
///////////////////////////////////////////////////////////////////////////////
BOOL CeBaseWnd::CenterWindow(HWND hWndCenter)
{
ASSERT(::IsWindow(m_hWnd));
// determine owner window to center against
DWORD dwStyle = GetStyle();
if (hWndCenter == NULL)
{
if(dwStyle & WS_CHILD)
hWndCenter = ::GetParent(m_hWnd);
else
{
// we'll center within the visible space of the
// window when we're on a P/PC with only a portion
// of the window showing (SIP displayed)
#ifdef _WCE_PPC_
hWndCenter = ::GetWindow(m_hWnd, GW_OWNER);
#else
hWndCenter = ::GetWindow(m_hWnd, GW_OWNER);
#endif
}
}
// get coordinates of the window relative to its parent
RECT rcDlg;
::GetWindowRect(m_hWnd, &rcDlg);
RECT rcArea;
RECT rcCenter;
HWND hWndParent;
if(!(dwStyle & WS_CHILD))
{
// don't center against invisible or minimized windows
if(hWndCenter != NULL)
{
DWORD dwStyle = ::GetWindowLong(hWndCenter, GWL_STYLE);
#ifndef _WIN32_WCE
if (!(dwStyle & WS_VISIBLE) || (dwStyle & WS_MINIMIZE))
#else
if (!(dwStyle & WS_VISIBLE))
#endif
hWndCenter = NULL;
}
// center within screen coordinates
::SystemParametersInfo(SPI_GETWORKAREA, NULL, &rcArea, NULL);
if(hWndCenter == NULL)
rcCenter = rcArea;
else
::GetWindowRect(hWndCenter, &rcCenter);
}
else
{
// center within parent client coordinates
hWndParent = ::GetParent(m_hWnd);
ASSERT(::IsWindow(hWndParent));
::GetClientRect(hWndParent, &rcArea);
ASSERT(::IsWindow(hWndCenter));
::GetClientRect(hWndCenter, &rcCenter);
::MapWindowPoints(hWndCenter, hWndParent, (POINT*)&rcCenter, 2);
}
int DlgWidth = rcDlg.right - rcDlg.left;
int DlgHeight = rcDlg.bottom - rcDlg.top;
// find dialog's upper left based on rcCenter
int xLeft = (rcCenter.left + rcCenter.right) / 2 - DlgWidth / 2;
int yTop = (rcCenter.top + rcCenter.bottom) / 2 - DlgHeight / 2;
// if the dialog is outside the screen, move it inside
if(xLeft < rcArea.left)
xLeft = rcArea.left;
else if(xLeft + DlgWidth > rcArea.right)
xLeft = rcArea.right - DlgWidth;
if(yTop < rcArea.top)
yTop = rcArea.top;
else if(yTop + DlgHeight > rcArea.bottom)
yTop = rcArea.bottom - DlgHeight;
// map screen coordinates to child coordinates
return ::SetWindowPos(m_hWnd, NULL, xLeft, yTop, -1, -1,
SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
}
///////////////////////////////////////////////////////////////////////////////
//
// Window message virtual functions
//
///////////////////////////////////////////////////////////////////////////////
// Other timely virtual functions for override
void CeMsgWnd::OnFirstMessage(HWND /*hWnd*/)
{}
void CeMsgWnd::OnFinalMessage(HWND /*hWnd*/)
{}
void CeMsgWnd::OnChar( UINT nChar, UINT nRepCnt, UINT nFlags, bool& bHandled )
{}
void CeMsgWnd::OnClose( bool& bHandled )
{}
int CeMsgWnd::OnCreate( LPCREATESTRUCT lpCS, bool& bHandled )
{ return 1; }
void CeMsgWnd::OnDestroy( bool& bHandled )
{}
void CeMsgWnd::OnEnable( BOOL bEnable, bool& bHandled )
{}
BOOL CeMsgWnd::OnEraseBkgnd( HDC hDC, bool& bHandled )
{ return FALSE; }
void CeMsgWnd::OnKeyDown( UINT nChar, UINT nRepCnt, UINT nFlags, bool& bHandled )
{}
void CeMsgWnd::OnKeyUp( UINT nChar, UINT nRepCnt, UINT nFlags, bool& bHandled )
{}
void CeMsgWnd::OnLButtonDblClk( UINT nFlags, POINT point, bool& bHandled )
{}
void CeMsgWnd::OnLButtonDown( UINT nFlags, POINT point, bool& bHandled )
{}
void CeMsgWnd::OnLButtonUp( UINT nFlags, POINT point, bool& bHandled )
{}
void CeMsgWnd::OnMouseMove( UINT nFlags, POINT point, bool& bHandled )
{}
void CeMsgWnd::OnMove( int x, int y, bool& bHandled )
{}
void CeMsgWnd::OnPaint( bool& bHandled )
{}
void CeMsgWnd::OnShowWindow( BOOL bShow, UINT nStatus, bool& bHandled )
{}
void CeMsgWnd::OnSize( UINT nType, int cx, int cy, bool& bHandled )
{}
void CeMsgWnd::OnTimer( UINT nTimer, bool& bHandled )
{}
void CeMsgWnd::OnSettingChange( WORD wFlags, LPCTSTR lpszSection, bool& bHandled )
{}
LRESULT CeMsgWnd::OnNotify(int nCtrlId, LPNMHDR pNMH, bool& bHandled)
{return TRUE;}
BOOL CeMsgWnd::OnCommand( WPARAM wParam, LPARAM lParam, bool& bHandled )
{return TRUE;}
#ifndef _WIN32_WCE
BOOL CeMsgWnd::OnQueryEndSession( UINT nSource, BOOL fLogOff, bool& bHandled )
{return FALSE;}
void CeMsgWnd::OnEndSession( BOOL fEndSession, UINT fLogoff, bool& bHandled )
{}
BOOL CeMsgWnd::OnSetCursor( HWND hWnd, UINT nHitTest, UINT message, bool& bHandled )
{return FALSE;}
#endif
LRESULT CeMsgWnd::OnMessage(UINT uMsg, WPARAM wParam, LPARAM lParam, bool& bHandled)
{ return 0; }