1 files changed, 4498 insertions, 0 deletions

diff --git a/public/sdk/inc/mfc40/afxwin.h b/public/sdk/inc/mfc40/afxwin.h
new file mode 100644
index 000000000..ae0218ed0
--- /dev/null
+++ b/public/sdk/inc/mfc40/afxwin.h
@@ -0,0 +1,4498 @@
+// This is a part of the Microsoft Foundation Classes C++ library.
+// Copyright (C) 1992-1995 Microsoft Corporation
+// All rights reserved.
+//
+// This source code is only intended as a supplement to the
+// Microsoft Foundation Classes Reference and related
+// electronic documentation provided with the library.
+// See these sources for detailed information regarding the
+// Microsoft Foundation Classes product.
+
+#ifndef __AFXWIN_H__
+#ifndef RC_INVOKED
+#define __AFXWIN_H__
+
+/////////////////////////////////////////////////////////////////////////////
+// Make sure 'afx.h' is included first
+
+#ifndef __AFX_H__
+	#include <afx.h>
+#endif
+
+// Note: WINDOWS.H already included from AFXV_W32.H
+
+#ifndef _INC_SHELLAPI
+	#include <shellapi.h>
+#endif
+
+#ifndef __AFXRES_H__
+	#include <afxres.h>     // standard resource IDs
+#endif
+
+#ifndef __AFXCOLL_H__
+	#include <afxcoll.h>    // standard collections
+#endif
+
+#ifdef _AFX_MINREBUILD
+#pragma component(minrebuild, off)
+#endif
+#ifndef _AFX_FULLTYPEINFO
+#pragma component(mintypeinfo, on)
+#endif
+
+#ifdef _INC_WINDOWSX
+// The following names from WINDOWSX.H collide with names in this header
+#undef SubclassWindow
+#undef CopyRgn
+#endif
+
+#ifdef _AFX_PACKING
+#pragma pack(push, _AFX_PACKING)
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// Classes declared in this file
+
+class CSize;
+class CPoint;
+class CRect;
+
+//CObject
+	//CException
+		//CSimpleException
+			class CResourceException;// Win resource failure exception
+			class CUserException;    // Message Box alert and stop operation
+
+	class CGdiObject;            // CDC drawing tool
+		class CPen;              // a pen / HPEN wrapper
+		class CBrush;            // a brush / HBRUSH wrapper
+		class CFont;             // a font / HFONT wrapper
+		class CBitmap;           // a bitmap / HBITMAP wrapper
+		class CPalette;          // a palette / HPALLETE wrapper
+		class CRgn;              // a region / HRGN wrapper
+
+	class CDC;                   // a Display Context / HDC wrapper
+		class CClientDC;         // CDC for client of window
+		class CWindowDC;         // CDC for entire window
+		class CPaintDC;          // embeddable BeginPaint struct helper
+
+	class CMenu;                 // a menu / HMENU wrapper
+
+	class CCmdTarget;            // a target for user commands
+		class CWnd;                 // a window / HWND wrapper
+			class CDialog;          // a dialog
+
+			// standard windows controls
+			class CStatic;          // Static control
+			class CButton;          // Button control
+			class CListBox;         // ListBox control
+				class CCheckListBox;// special listbox with checks
+			class CComboBox;        // ComboBox control
+			class CEdit;            // Edit control
+			class CScrollBar;       // ScrollBar control
+
+			// frame windows
+			class CFrameWnd;        // standard SDI frame
+				class CMDIFrameWnd; // standard MDI frame
+				class CMDIChildWnd; // standard MDI child
+				class CMiniFrameWnd;// half-height caption frame wnd
+
+			// views on a document
+			class CView;            // a view on a document
+				class CScrollView;  // a scrolling view
+
+		class CWinThread;           // thread base class
+			class CWinApp;          // application base class
+
+		class CDocTemplate;         // template for document creation
+			class CSingleDocTemplate;// SDI support
+			class CMultiDocTemplate; // MDI support
+
+		class CDocument;            // main document abstraction
+
+
+// Helper classes
+class CCmdUI;           // Menu/button enabling
+class CDataExchange;    // Data exchange and validation context
+class CCommandLineInfo; // CommandLine parsing helper
+class CDocManager;      // CDocTemplate manager object
+
+/////////////////////////////////////////////////////////////////////////////
+
+// Type modifier for message handlers
+#ifndef afx_msg
+#define afx_msg         // intentional placeholder
+#endif
+
+#undef AFX_DATA
+#define AFX_DATA AFX_CORE_DATA
+
+/////////////////////////////////////////////////////////////////////////////
+// CSize - An extent, similar to Windows SIZE structure.
+
+class CSize : public tagSIZE
+{
+public:
+
+// Constructors
+	CSize();
+	CSize(int initCX, int initCY);
+	CSize(SIZE initSize);
+	CSize(POINT initPt);
+	CSize(DWORD dwSize);
+
+// Operations
+	BOOL operator==(SIZE size) const;
+	BOOL operator!=(SIZE size) const;
+	void operator+=(SIZE size);
+	void operator-=(SIZE size);
+
+// Operators returning CSize values
+	CSize operator+(SIZE size) const;
+	CSize operator-(SIZE size) const;
+	CSize operator-() const;
+
+// Operators returning CPoint values
+	CPoint operator+(POINT point) const;
+	CPoint operator-(POINT point) const;
+
+// Operators returning CRect values
+	CRect operator+(const RECT* lpRect) const;
+	CRect operator-(const RECT* lpRect) const;
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// CPoint - A 2-D point, similar to Windows POINT structure.
+
+class CPoint : public tagPOINT
+{
+public:
+
+// Constructors
+	CPoint();
+	CPoint(int initX, int initY);
+	CPoint(POINT initPt);
+	CPoint(SIZE initSize);
+	CPoint(DWORD dwPoint);
+
+// Operations
+	void Offset(int xOffset, int yOffset);
+	void Offset(POINT point);
+	void Offset(SIZE size);
+	BOOL operator==(POINT point) const;
+	BOOL operator!=(POINT point) const;
+	void operator+=(SIZE size);
+	void operator-=(SIZE size);
+	void operator+=(POINT point);
+	void operator-=(POINT point);
+
+// Operators returning CPoint values
+	CPoint operator+(SIZE size) const;
+	CPoint operator-(SIZE size) const;
+	CPoint operator-() const;
+	CPoint operator+(POINT point) const;
+
+// Operators returning CSize values
+	CSize operator-(POINT point) const;
+
+// Operators returning CRect values
+	CRect operator+(const RECT* lpRect) const;
+	CRect operator-(const RECT* lpRect) const;
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// CRect - A 2-D rectangle, similar to Windows RECT structure.
+
+typedef const RECT* LPCRECT;    // pointer to read/only RECT
+
+class CRect : public tagRECT
+{
+public:
+
+// Constructors
+	CRect();
+	CRect(int l, int t, int r, int b);
+	CRect(const RECT& srcRect);
+	CRect(LPCRECT lpSrcRect);
+	CRect(POINT point, SIZE size);
+	CRect(POINT topLeft, POINT bottomRight);
+
+// Attributes (in addition to RECT members)
+	int Width() const;
+	int Height() const;
+	CSize Size() const;
+	CPoint& TopLeft();
+	CPoint& BottomRight();
+	const CPoint& TopLeft() const;
+	const CPoint& BottomRight() const;
+	CPoint CenterPoint() const;
+
+	// convert between CRect and LPRECT/LPCRECT (no need for &)
+	operator LPRECT();
+	operator LPCRECT() const;
+
+	BOOL IsRectEmpty() const;
+	BOOL IsRectNull() const;
+	BOOL PtInRect(POINT point) const;
+
+// Operations
+	void SetRect(int x1, int y1, int x2, int y2);
+	void SetRect(POINT topLeft, POINT bottomRight);
+	void SetRectEmpty();
+	void CopyRect(LPCRECT lpSrcRect);
+	BOOL EqualRect(LPCRECT lpRect) const;
+
+	void InflateRect(int x, int y);
+	void InflateRect(SIZE size);
+	void InflateRect(LPCRECT lpRect);
+	void InflateRect(int l, int t, int r, int b);
+	void DeflateRect(int x, int y);
+	void DeflateRect(SIZE size);
+	void DeflateRect(LPCRECT lpRect);
+	void DeflateRect(int l, int t, int r, int b);
+
+	void OffsetRect(int x, int y);
+	void OffsetRect(SIZE size);
+	void OffsetRect(POINT point);
+	void NormalizeRect();
+
+	// operations that fill '*this' with result
+	BOOL IntersectRect(LPCRECT lpRect1, LPCRECT lpRect2);
+	BOOL UnionRect(LPCRECT lpRect1, LPCRECT lpRect2);
+	BOOL SubtractRect(LPCRECT lpRectSrc1, LPCRECT lpRectSrc2);
+
+// Additional Operations
+	void operator=(const RECT& srcRect);
+	BOOL operator==(const RECT& rect) const;
+	BOOL operator!=(const RECT& rect) const;
+	void operator+=(POINT point);
+	void operator+=(SIZE size);
+	void operator+=(LPCRECT lpRect);
+	void operator-=(POINT point);
+	void operator-=(SIZE size);
+	void operator-=(LPCRECT lpRect);
+	void operator&=(const RECT& rect);
+	void operator|=(const RECT& rect);
+
+// Operators returning CRect values
+	CRect operator+(POINT point) const;
+	CRect operator-(POINT point) const;
+	CRect operator+(LPCRECT lpRect) const;
+	CRect operator+(SIZE size) const;
+	CRect operator-(SIZE size) const;
+	CRect operator-(LPCRECT lpRect) const;
+	CRect operator&(const RECT& rect2) const;
+	CRect operator|(const RECT& rect2) const;
+	CRect MulDiv(int nMultiplier, int nDivisor) const;
+};
+
+#ifdef _DEBUG
+// Diagnostic Output
+CDumpContext& AFXAPI operator<<(CDumpContext& dc, SIZE size);
+CDumpContext& AFXAPI operator<<(CDumpContext& dc, POINT point);
+CDumpContext& AFXAPI operator<<(CDumpContext& dc, const RECT& rect);
+#endif //_DEBUG
+
+// Serialization
+CArchive& AFXAPI operator<<(CArchive& ar, SIZE size);
+CArchive& AFXAPI operator<<(CArchive& ar, POINT point);
+CArchive& AFXAPI operator<<(CArchive& ar, const RECT& rect);
+CArchive& AFXAPI operator>>(CArchive& ar, SIZE& size);
+CArchive& AFXAPI operator>>(CArchive& ar, POINT& point);
+CArchive& AFXAPI operator>>(CArchive& ar, RECT& rect);
+
+/////////////////////////////////////////////////////////////////////////////
+// Standard exceptions
+
+class CResourceException : public CSimpleException    // resource failure
+{
+	DECLARE_DYNAMIC(CResourceException)
+public:
+	CResourceException();
+
+// Implementation
+public:
+	CResourceException(BOOL bAutoDelete);
+	CResourceException(BOOL bAutoDelete, UINT nResourceID);
+	virtual ~CResourceException();
+};
+
+class CUserException : public CSimpleException   // general user visible alert
+{
+	DECLARE_DYNAMIC(CUserException)
+public:
+	CUserException();
+
+// Implementation
+public:
+	CUserException(BOOL bAutoDelete);
+	CUserException(BOOL bAutoDelete, UINT nResourceID);
+	virtual ~CUserException();
+};
+
+void AFXAPI AfxThrowResourceException();
+void AFXAPI AfxThrowUserException();
+
+/////////////////////////////////////////////////////////////////////////////
+// CGdiObject abstract class for CDC SelectObject
+
+class CGdiObject : public CObject
+{
+	DECLARE_DYNCREATE(CGdiObject)
+public:
+
+// Attributes
+	HGDIOBJ m_hObject;                  // must be first data member
+	operator HGDIOBJ() const;
+	HGDIOBJ GetSafeHandle() const;
+
+	static CGdiObject* PASCAL FromHandle(HGDIOBJ hObject);
+	static void PASCAL DeleteTempMap();
+	BOOL Attach(HGDIOBJ hObject);
+	HGDIOBJ Detach();
+
+// Constructors
+	CGdiObject(); // must Create a derived class object
+	BOOL DeleteObject();
+
+// Operations
+	int GetObject(int nCount, LPVOID lpObject) const;
+	UINT GetObjectType() const;
+	BOOL CreateStockObject(int nIndex);
+	BOOL UnrealizeObject();
+
+// Implementation
+public:
+	virtual ~CGdiObject();
+#ifdef _DEBUG
+	virtual void Dump(CDumpContext& dc) const;
+	virtual void AssertValid() const;
+#endif
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// CGdiObject subclasses (drawing tools)
+
+class CPen : public CGdiObject
+{
+	DECLARE_DYNAMIC(CPen)
+
+public:
+	static CPen* PASCAL FromHandle(HPEN hPen);
+
+// Constructors
+	CPen();
+	CPen(int nPenStyle, int nWidth, COLORREF crColor);
+#ifndef _MAC
+	CPen(int nPenStyle, int nWidth, const LOGBRUSH* pLogBrush,
+		int nStyleCount = 0, const DWORD* lpStyle = NULL);
+#endif
+	BOOL CreatePen(int nPenStyle, int nWidth, COLORREF crColor);
+#ifndef _MAC
+	BOOL CreatePen(int nPenStyle, int nWidth, const LOGBRUSH* pLogBrush,
+		int nStyleCount = 0, const DWORD* lpStyle = NULL);
+#endif
+	BOOL CreatePenIndirect(LPLOGPEN lpLogPen);
+
+// Attributes
+	operator HPEN() const;
+	int GetLogPen(LOGPEN* pLogPen);
+#ifndef _MAC
+	int GetExtLogPen(EXTLOGPEN* pLogPen);
+#endif
+
+// Implementation
+public:
+	virtual ~CPen();
+#ifdef _DEBUG
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+};
+
+class CBrush : public CGdiObject
+{
+	DECLARE_DYNAMIC(CBrush)
+
+public:
+	static CBrush* PASCAL FromHandle(HBRUSH hBrush);
+
+// Constructors
+	CBrush();
+	CBrush(COLORREF crColor);             // CreateSolidBrush
+	CBrush(int nIndex, COLORREF crColor); // CreateHatchBrush
+	CBrush(CBitmap* pBitmap);          // CreatePatternBrush
+
+	BOOL CreateSolidBrush(COLORREF crColor);
+	BOOL CreateHatchBrush(int nIndex, COLORREF crColor);
+	BOOL CreateBrushIndirect(LPLOGBRUSH lpLogBrush);
+	BOOL CreatePatternBrush(CBitmap* pBitmap);
+	BOOL CreateDIBPatternBrush(HGLOBAL hPackedDIB, UINT nUsage);
+	BOOL CreateDIBPatternBrush(const void* lpPackedDIB, UINT nUsage);
+	BOOL CreateSysColorBrush(int nIndex);
+
+// Attributes
+	operator HBRUSH() const;
+	int GetLogBrush(LOGBRUSH* pLogBrush);
+
+// Implementation
+public:
+	virtual ~CBrush();
+#ifdef _DEBUG
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+};
+
+class CFont : public CGdiObject
+{
+	DECLARE_DYNAMIC(CFont)
+
+public:
+	static CFont* PASCAL FromHandle(HFONT hFont);
+
+// Constructors
+	CFont();
+	BOOL CreateFontIndirect(const LOGFONT* lpLogFont);
+	BOOL CreateFont(int nHeight, int nWidth, int nEscapement,
+			int nOrientation, int nWeight, BYTE bItalic, BYTE bUnderline,
+			BYTE cStrikeOut, BYTE nCharSet, BYTE nOutPrecision,
+			BYTE nClipPrecision, BYTE nQuality, BYTE nPitchAndFamily,
+			LPCTSTR lpszFacename);
+	BOOL CreatePointFont(int nPointSize, LPCTSTR lpszFaceName, CDC* pDC = NULL);
+	BOOL CreatePointFontIndirect(const LOGFONT* lpLogFont, CDC* pDC = NULL);
+
+// Attributes
+	operator HFONT() const;
+	int GetLogFont(LOGFONT* pLogFont);
+
+// Implementation
+public:
+	virtual ~CFont();
+#ifdef _DEBUG
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+};
+
+class CBitmap : public CGdiObject
+{
+	DECLARE_DYNAMIC(CBitmap)
+
+public:
+	static CBitmap* PASCAL FromHandle(HBITMAP hBitmap);
+
+// Constructors
+	CBitmap();
+
+	BOOL LoadBitmap(LPCTSTR lpszResourceName);
+	BOOL LoadBitmap(UINT nIDResource);
+#ifndef _MAC
+	BOOL LoadOEMBitmap(UINT nIDBitmap); // for OBM_/OCR_/OIC_
+#endif
+	BOOL LoadMappedBitmap(UINT nIDBitmap, UINT nFlags = 0,
+		LPCOLORMAP lpColorMap = NULL, int nMapSize = 0);
+	BOOL CreateBitmap(int nWidth, int nHeight, UINT nPlanes, UINT nBitcount,
+			const void* lpBits);
+	BOOL CreateBitmapIndirect(LPBITMAP lpBitmap);
+	BOOL CreateCompatibleBitmap(CDC* pDC, int nWidth, int nHeight);
+	BOOL CreateDiscardableBitmap(CDC* pDC, int nWidth, int nHeight);
+
+// Attributes
+	operator HBITMAP() const;
+	int GetBitmap(BITMAP* pBitMap);
+
+// Operations
+	DWORD SetBitmapBits(DWORD dwCount, const void* lpBits);
+	DWORD GetBitmapBits(DWORD dwCount, LPVOID lpBits) const;
+	CSize SetBitmapDimension(int nWidth, int nHeight);
+	CSize GetBitmapDimension() const;
+
+// Implementation
+public:
+	virtual ~CBitmap();
+#ifdef _DEBUG
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+};
+
+class CPalette : public CGdiObject
+{
+	DECLARE_DYNAMIC(CPalette)
+
+public:
+	static CPalette* PASCAL FromHandle(HPALETTE hPalette);
+
+// Constructors
+	CPalette();
+	BOOL CreatePalette(LPLOGPALETTE lpLogPalette);
+#ifndef _MAC
+	BOOL CreateHalftonePalette(CDC* pDC);
+#endif
+
+// Attributes
+	operator HPALETTE() const;
+	int GetEntryCount();
+	UINT GetPaletteEntries(UINT nStartIndex, UINT nNumEntries,
+			LPPALETTEENTRY lpPaletteColors) const;
+	UINT SetPaletteEntries(UINT nStartIndex, UINT nNumEntries,
+			LPPALETTEENTRY lpPaletteColors);
+
+// Operations
+#ifndef _MAC
+	void AnimatePalette(UINT nStartIndex, UINT nNumEntries,
+			LPPALETTEENTRY lpPaletteColors);
+#endif
+	UINT GetNearestPaletteIndex(COLORREF crColor) const;
+	BOOL ResizePalette(UINT nNumEntries);
+
+// Implementation
+	virtual ~CPalette();
+};
+
+class CRgn : public CGdiObject
+{
+	DECLARE_DYNAMIC(CRgn)
+
+public:
+	static CRgn* PASCAL FromHandle(HRGN hRgn);
+	operator HRGN() const;
+
+// Constructors
+	CRgn();
+	BOOL CreateRectRgn(int x1, int y1, int x2, int y2);
+	BOOL CreateRectRgnIndirect(LPCRECT lpRect);
+	BOOL CreateEllipticRgn(int x1, int y1, int x2, int y2);
+	BOOL CreateEllipticRgnIndirect(LPCRECT lpRect);
+	BOOL CreatePolygonRgn(LPPOINT lpPoints, int nCount, int nMode);
+#ifndef _MAC
+	BOOL CreatePolyPolygonRgn(LPPOINT lpPoints, LPINT lpPolyCounts,
+			int nCount, int nPolyFillMode);
+#endif
+	BOOL CreateRoundRectRgn(int x1, int y1, int x2, int y2, int x3, int y3);
+#ifndef _MAC
+	BOOL CreateFromPath(CDC* pDC);
+	BOOL CreateFromData(const XFORM* lpXForm, int nCount,
+		const RGNDATA* pRgnData);
+#endif
+
+// Operations
+	void SetRectRgn(int x1, int y1, int x2, int y2);
+	void SetRectRgn(LPCRECT lpRect);
+	int CombineRgn(CRgn* pRgn1, CRgn* pRgn2, int nCombineMode);
+	int CopyRgn(CRgn* pRgnSrc);
+	BOOL EqualRgn(CRgn* pRgn) const;
+	int OffsetRgn(int x, int y);
+	int OffsetRgn(POINT point);
+	int GetRgnBox(LPRECT lpRect) const;
+	BOOL PtInRegion(int x, int y) const;
+	BOOL PtInRegion(POINT point) const;
+	BOOL RectInRegion(LPCRECT lpRect) const;
+#ifndef _MAC
+	int GetRegionData(LPRGNDATA lpRgnData, int nCount) const;
+#endif
+
+// Implementation
+	virtual ~CRgn();
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// The device context
+
+class CDC : public CObject
+{
+	DECLARE_DYNCREATE(CDC)
+public:
+
+// Attributes
+	HDC m_hDC;          // The output DC (must be first data member)
+	HDC m_hAttribDC;    // The Attribute DC
+	operator HDC() const;
+	HDC GetSafeHdc() const; // Always returns the Output DC
+#ifndef _MAC
+	CWnd* GetWindow() const;
+#endif
+
+	static CDC* PASCAL FromHandle(HDC hDC);
+	static void PASCAL DeleteTempMap();
+	BOOL Attach(HDC hDC);   // Attach/Detach affects only the Output DC
+	HDC Detach();
+
+	virtual void SetAttribDC(HDC hDC);  // Set the Attribute DC
+	virtual void SetOutputDC(HDC hDC);  // Set the Output DC
+	virtual void ReleaseAttribDC();     // Release the Attribute DC
+	virtual void ReleaseOutputDC();     // Release the Output DC
+
+	BOOL IsPrinting() const;            // TRUE if being used for printing
+
+	CPen* GetCurrentPen() const;
+	CBrush* GetCurrentBrush() const;
+	CPalette* GetCurrentPalette() const;
+	CFont* GetCurrentFont() const;
+	CBitmap* GetCurrentBitmap() const;
+
+// Constructors
+	CDC();
+	BOOL CreateDC(LPCTSTR lpszDriverName, LPCTSTR lpszDeviceName,
+		LPCTSTR lpszOutput, const void* lpInitData);
+	BOOL CreateIC(LPCTSTR lpszDriverName, LPCTSTR lpszDeviceName,
+		LPCTSTR lpszOutput, const void* lpInitData);
+	BOOL CreateCompatibleDC(CDC* pDC);
+
+	BOOL DeleteDC();
+
+// Device-Context Functions
+	virtual int SaveDC();
+	virtual BOOL RestoreDC(int nSavedDC);
+	int GetDeviceCaps(int nIndex) const;
+#ifndef _MAC
+	UINT SetBoundsRect(LPCRECT lpRectBounds, UINT flags);
+	UINT GetBoundsRect(LPRECT lpRectBounds, UINT flags);
+#endif
+	BOOL ResetDC(const DEVMODE* lpDevMode);
+
+// Drawing-Tool Functions
+	CPoint GetBrushOrg() const;
+	CPoint SetBrushOrg(int x, int y);
+	CPoint SetBrushOrg(POINT point);
+	int EnumObjects(int nObjectType,
+			int (CALLBACK* lpfn)(LPVOID, LPARAM), LPARAM lpData);
+
+// Type-safe selection helpers
+public:
+	virtual CGdiObject* SelectStockObject(int nIndex);
+	CPen* SelectObject(CPen* pPen);
+	CBrush* SelectObject(CBrush* pBrush);
+	virtual CFont* SelectObject(CFont* pFont);
+	CBitmap* SelectObject(CBitmap* pBitmap);
+	int SelectObject(CRgn* pRgn);       // special return for regions
+	CGdiObject* SelectObject(CGdiObject* pObject);
+		// CGdiObject* provided so compiler doesn't use SelectObject(HGDIOBJ)
+
+// Color and Color Palette Functions
+	COLORREF GetNearestColor(COLORREF crColor) const;
+	CPalette* SelectPalette(CPalette* pPalette, BOOL bForceBackground);
+	UINT RealizePalette();
+	void UpdateColors();
+
+// Drawing-Attribute Functions
+	COLORREF GetBkColor() const;
+	int GetBkMode() const;
+	int GetPolyFillMode() const;
+	int GetROP2() const;
+	int GetStretchBltMode() const;
+	COLORREF GetTextColor() const;
+
+	virtual COLORREF SetBkColor(COLORREF crColor);
+	int SetBkMode(int nBkMode);
+	int SetPolyFillMode(int nPolyFillMode);
+	int SetROP2(int nDrawMode);
+	int SetStretchBltMode(int nStretchMode);
+	virtual COLORREF SetTextColor(COLORREF crColor);
+
+#ifndef _MAC
+	BOOL GetColorAdjustment(LPCOLORADJUSTMENT lpColorAdjust) const;
+	BOOL SetColorAdjustment(const COLORADJUSTMENT* lpColorAdjust);
+#endif
+
+// Mapping Functions
+	int GetMapMode() const;
+	CPoint GetViewportOrg() const;
+	virtual int SetMapMode(int nMapMode);
+	// Viewport Origin
+	virtual CPoint SetViewportOrg(int x, int y);
+			CPoint SetViewportOrg(POINT point);
+	virtual CPoint OffsetViewportOrg(int nWidth, int nHeight);
+
+	// Viewport Extent
+	CSize GetViewportExt() const;
+	virtual CSize SetViewportExt(int cx, int cy);
+			CSize SetViewportExt(SIZE size);
+	virtual CSize ScaleViewportExt(int xNum, int xDenom, int yNum, int yDenom);
+
+	// Window Origin
+	CPoint GetWindowOrg() const;
+	CPoint SetWindowOrg(int x, int y);
+	CPoint SetWindowOrg(POINT point);
+	CPoint OffsetWindowOrg(int nWidth, int nHeight);
+
+	// Window extent
+	CSize GetWindowExt() const;
+	virtual CSize SetWindowExt(int cx, int cy);
+			CSize SetWindowExt(SIZE size);
+	virtual CSize ScaleWindowExt(int xNum, int xDenom, int yNum, int yDenom);
+
+// Coordinate Functions
+	void DPtoLP(LPPOINT lpPoints, int nCount = 1) const;
+	void DPtoLP(LPRECT lpRect) const;
+	void DPtoLP(LPSIZE lpSize) const;
+	void LPtoDP(LPPOINT lpPoints, int nCount = 1) const;
+	void LPtoDP(LPRECT lpRect) const;
+	void LPtoDP(LPSIZE lpSize) const;
+
+// Special Coordinate Functions (useful for dealing with metafiles and OLE)
+	void DPtoHIMETRIC(LPSIZE lpSize) const;
+	void LPtoHIMETRIC(LPSIZE lpSize) const;
+	void HIMETRICtoDP(LPSIZE lpSize) const;
+	void HIMETRICtoLP(LPSIZE lpSize) const;
+
+// Region Functions
+	BOOL FillRgn(CRgn* pRgn, CBrush* pBrush);
+	BOOL FrameRgn(CRgn* pRgn, CBrush* pBrush, int nWidth, int nHeight);
+	BOOL InvertRgn(CRgn* pRgn);
+	BOOL PaintRgn(CRgn* pRgn);
+
+// Clipping Functions
+	virtual int GetClipBox(LPRECT lpRect) const;
+	virtual BOOL PtVisible(int x, int y) const;
+			BOOL PtVisible(POINT point) const;
+	virtual BOOL RectVisible(LPCRECT lpRect) const;
+			int SelectClipRgn(CRgn* pRgn);
+			int ExcludeClipRect(int x1, int y1, int x2, int y2);
+			int ExcludeClipRect(LPCRECT lpRect);
+			int ExcludeUpdateRgn(CWnd* pWnd);
+			int IntersectClipRect(int x1, int y1, int x2, int y2);
+			int IntersectClipRect(LPCRECT lpRect);
+			int OffsetClipRgn(int x, int y);
+			int OffsetClipRgn(SIZE size);
+#ifndef _MAC
+	int SelectClipRgn(CRgn* pRgn, int nMode);
+#endif
+
+// Line-Output Functions
+	CPoint GetCurrentPosition() const;
+	CPoint MoveTo(int x, int y);
+	CPoint MoveTo(POINT point);
+	BOOL LineTo(int x, int y);
+	BOOL LineTo(POINT point);
+	BOOL Arc(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4);
+	BOOL Arc(LPCRECT lpRect, POINT ptStart, POINT ptEnd);
+	BOOL Polyline(LPPOINT lpPoints, int nCount);
+
+#ifndef _MAC
+	BOOL AngleArc(int x, int y, int nRadius, float fStartAngle, float fSweepAngle);
+	BOOL ArcTo(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4);
+	BOOL ArcTo(LPCRECT lpRect, POINT ptStart, POINT ptEnd);
+	int GetArcDirection() const;
+	int SetArcDirection(int nArcDirection);
+
+	BOOL PolyDraw(const POINT* lpPoints, const BYTE* lpTypes, int nCount);
+	BOOL PolylineTo(const POINT* lpPoints, int nCount);
+	BOOL PolyPolyline(const POINT* lpPoints,
+		const DWORD* lpPolyPoints, int nCount);
+
+	BOOL PolyBezier(const POINT* lpPoints, int nCount);
+	BOOL PolyBezierTo(const POINT* lpPoints, int nCount);
+#endif
+
+// Simple Drawing Functions
+	void FillRect(LPCRECT lpRect, CBrush* pBrush);
+	void FrameRect(LPCRECT lpRect, CBrush* pBrush);
+	void InvertRect(LPCRECT lpRect);
+	BOOL DrawIcon(int x, int y, HICON hIcon);
+	BOOL DrawIcon(POINT point, HICON hIcon);
+#if (WINVER >= 0x400)
+#ifndef _MAC
+	BOOL DrawState(CPoint pt, CSize size, HBITMAP hBitmap, UINT nFlags,
+		HBRUSH hBrush = NULL);
+	BOOL DrawState(CPoint pt, CSize size, CBitmap* pBitmap, UINT nFlags,
+		CBrush* pBrush = NULL);
+	BOOL DrawState(CPoint pt, CSize size, HICON hIcon, UINT nFlags,
+		HBRUSH hBrush = NULL);
+	BOOL DrawState(CPoint pt, CSize size, HICON hIcon, UINT nFlags,
+		CBrush* pBrush = NULL);
+	BOOL DrawState(CPoint pt, CSize size, LPCTSTR lpszText, UINT nFlags,
+		BOOL bPrefixText = TRUE, int nTextLen = 0, HBRUSH hBrush = NULL);
+	BOOL DrawState(CPoint pt, CSize size, LPCTSTR lpszText, UINT nFlags,
+		BOOL bPrefixText = TRUE, int nTextLen = 0, CBrush* pBrush = NULL);
+	BOOL DrawState(CPoint pt, CSize size, DRAWSTATEPROC lpDrawProc,
+		LPARAM lData, UINT nFlags, HBRUSH hBrush = NULL);
+	BOOL DrawState(CPoint pt, CSize size, DRAWSTATEPROC lpDrawProc,
+		LPARAM lData, UINT nFlags, CBrush* pBrush = NULL);
+#endif
+#endif
+
+// Ellipse and Polygon Functions
+#ifndef _MAC
+	BOOL Chord(int x1, int y1, int x2, int y2, int x3, int y3,
+		int x4, int y4);
+	BOOL Chord(LPCRECT lpRect, POINT ptStart, POINT ptEnd);
+#endif
+	void DrawFocusRect(LPCRECT lpRect);
+	BOOL Ellipse(int x1, int y1, int x2, int y2);
+	BOOL Ellipse(LPCRECT lpRect);
+	BOOL Pie(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4);
+	BOOL Pie(LPCRECT lpRect, POINT ptStart, POINT ptEnd);
+	BOOL Polygon(LPPOINT lpPoints, int nCount);
+#ifndef _MAC
+	BOOL PolyPolygon(LPPOINT lpPoints, LPINT lpPolyCounts, int nCount);
+#endif
+	BOOL Rectangle(int x1, int y1, int x2, int y2);
+	BOOL Rectangle(LPCRECT lpRect);
+	BOOL RoundRect(int x1, int y1, int x2, int y2, int x3, int y3);
+	BOOL RoundRect(LPCRECT lpRect, POINT point);
+
+// Bitmap Functions
+	BOOL PatBlt(int x, int y, int nWidth, int nHeight, DWORD dwRop);
+	BOOL BitBlt(int x, int y, int nWidth, int nHeight, CDC* pSrcDC,
+		int xSrc, int ySrc, DWORD dwRop);
+	BOOL StretchBlt(int x, int y, int nWidth, int nHeight, CDC* pSrcDC,
+		int xSrc, int ySrc, int nSrcWidth, int nSrcHeight, DWORD dwRop);
+	COLORREF GetPixel(int x, int y) const;
+	COLORREF GetPixel(POINT point) const;
+	COLORREF SetPixel(int x, int y, COLORREF crColor);
+	COLORREF SetPixel(POINT point, COLORREF crColor);
+#ifndef _MAC
+	BOOL FloodFill(int x, int y, COLORREF crColor);
+	BOOL ExtFloodFill(int x, int y, COLORREF crColor, UINT nFillType);
+	BOOL MaskBlt(int x, int y, int nWidth, int nHeight, CDC* pSrcDC,
+		int xSrc, int ySrc, CBitmap& maskBitmap, int xMask, int yMask,
+		DWORD dwRop);
+	BOOL PlgBlt(LPPOINT lpPoint, CDC* pSrcDC, int xSrc, int ySrc,
+		int nWidth, int nHeight, CBitmap& maskBitmap, int xMask, int yMask);
+	BOOL SetPixelV(int x, int y, COLORREF crColor);
+	BOOL SetPixelV(POINT point, COLORREF crColor);
+#endif
+
+// Text Functions
+	virtual BOOL TextOut(int x, int y, LPCTSTR lpszString, int nCount);
+			BOOL TextOut(int x, int y, const CString& str);
+	virtual BOOL ExtTextOut(int x, int y, UINT nOptions, LPCRECT lpRect,
+				LPCTSTR lpszString, UINT nCount, LPINT lpDxWidths);
+			BOOL ExtTextOut(int x, int y, UINT nOptions, LPCRECT lpRect,
+				const CString& str, LPINT lpDxWidths);
+	virtual CSize TabbedTextOut(int x, int y, LPCTSTR lpszString, int nCount,
+				int nTabPositions, LPINT lpnTabStopPositions, int nTabOrigin);
+			CSize TabbedTextOut(int x, int y, const CString& str,
+				int nTabPositions, LPINT lpnTabStopPositions, int nTabOrigin);
+	virtual int DrawText(LPCTSTR lpszString, int nCount, LPRECT lpRect,
+				UINT nFormat);
+			int DrawText(const CString& str, LPRECT lpRect, UINT nFormat);
+	CSize GetTextExtent(LPCTSTR lpszString, int nCount) const;
+	CSize GetTextExtent(const CString& str) const;
+	CSize GetOutputTextExtent(LPCTSTR lpszString, int nCount) const;
+	CSize GetOutputTextExtent(const CString& str) const;
+	CSize GetTabbedTextExtent(LPCTSTR lpszString, int nCount,
+		int nTabPositions, LPINT lpnTabStopPositions) const;
+	CSize GetTabbedTextExtent(const CString& str,
+		int nTabPositions, LPINT lpnTabStopPositions) const;
+	CSize GetOutputTabbedTextExtent(LPCTSTR lpszString, int nCount,
+		int nTabPositions, LPINT lpnTabStopPositions) const;
+	CSize GetOutputTabbedTextExtent(const CString& str,
+		int nTabPositions, LPINT lpnTabStopPositions) const;
+	virtual BOOL GrayString(CBrush* pBrush,
+		BOOL (CALLBACK* lpfnOutput)(HDC, LPARAM, int), LPARAM lpData,
+			int nCount, int x, int y, int nWidth, int nHeight);
+	UINT GetTextAlign() const;
+	UINT SetTextAlign(UINT nFlags);
+	int GetTextFace(int nCount, LPTSTR lpszFacename) const;
+	int GetTextFace(CString& rString) const;
+	BOOL GetTextMetrics(LPTEXTMETRIC lpMetrics) const;
+	BOOL GetOutputTextMetrics(LPTEXTMETRIC lpMetrics) const;
+#ifndef _MAC
+	int SetTextJustification(int nBreakExtra, int nBreakCount);
+#endif
+	int GetTextCharacterExtra() const;
+	int SetTextCharacterExtra(int nCharExtra);
+
+// Advanced Drawing
+#if (WINVER >= 0x400)
+#ifndef _MAC
+	BOOL DrawEdge(LPRECT lpRect, UINT nEdge, UINT nFlags);
+	BOOL DrawFrameControl(LPRECT lpRect, UINT nType, UINT nState);
+#endif
+#endif
+
+// Scrolling Functions
+	BOOL ScrollDC(int dx, int dy, LPCRECT lpRectScroll, LPCRECT lpRectClip,
+		CRgn* pRgnUpdate, LPRECT lpRectUpdate);
+
+// Font Functions
+	BOOL GetCharWidth(UINT nFirstChar, UINT nLastChar, LPINT lpBuffer) const;
+	BOOL GetOutputCharWidth(UINT nFirstChar, UINT nLastChar, LPINT lpBuffer) const;
+	DWORD SetMapperFlags(DWORD dwFlag);
+	CSize GetAspectRatioFilter() const;
+
+	BOOL GetCharABCWidths(UINT nFirstChar, UINT nLastChar, LPABC lpabc) const;
+	DWORD GetFontData(DWORD dwTable, DWORD dwOffset, LPVOID lpData, DWORD cbData) const;
+#ifndef _MAC
+	int GetKerningPairs(int nPairs, LPKERNINGPAIR lpkrnpair) const;
+#endif
+	UINT GetOutlineTextMetrics(UINT cbData, LPOUTLINETEXTMETRIC lpotm) const;
+#ifndef _MAC
+	DWORD GetGlyphOutline(UINT nChar, UINT nFormat, LPGLYPHMETRICS lpgm,
+		DWORD cbBuffer, LPVOID lpBuffer, const MAT2* lpmat2) const;
+#endif
+
+#ifndef _MAC
+	BOOL GetCharABCWidths(UINT nFirstChar, UINT nLastChar,
+		LPABCFLOAT lpABCF) const;
+	BOOL GetCharWidth(UINT nFirstChar, UINT nLastChar,
+		float* lpFloatBuffer) const;
+#endif
+
+// Printer/Device Escape Functions
+	virtual int Escape(int nEscape, int nCount,
+		LPCSTR lpszInData, LPVOID lpOutData);
+#ifndef _MAC
+	int Escape(int nEscape, int nInputSize, LPCSTR lpszInputData,
+		int nOutputSize, LPSTR lpszOutputData);
+	int DrawEscape(int nEscape, int nInputSize, LPCSTR lpszInputData);
+#endif
+
+	// Escape helpers
+	int StartDoc(LPCTSTR lpszDocName);  // old Win3.0 version
+	int StartDoc(LPDOCINFO lpDocInfo);
+	int StartPage();
+	int EndPage();
+	int SetAbortProc(BOOL (CALLBACK* lpfn)(HDC, int));
+	int AbortDoc();
+	int EndDoc();
+
+// MetaFile Functions
+	BOOL PlayMetaFile(HMETAFILE hMF);
+#ifndef _MAC
+	BOOL PlayMetaFile(HENHMETAFILE hEnhMetaFile, LPCRECT lpBounds);
+	BOOL AddMetaFileComment(UINT nDataSize, const BYTE* pCommentData);
+		// can be used for enhanced metafiles only
+
+// Path Functions
+	BOOL AbortPath();
+	BOOL BeginPath();
+	BOOL CloseFigure();
+	BOOL EndPath();
+	BOOL FillPath();
+	BOOL FlattenPath();
+	BOOL StrokeAndFillPath();
+	BOOL StrokePath();
+	BOOL WidenPath();
+	float GetMiterLimit() const;
+	BOOL SetMiterLimit(float fMiterLimit);
+	int GetPath(LPPOINT lpPoints, LPBYTE lpTypes, int nCount) const;
+	BOOL SelectClipPath(int nMode);
+#endif
+
+// Misc Helper Functions
+	static CBrush* PASCAL GetHalftoneBrush();
+	void DrawDragRect(LPCRECT lpRect, SIZE size,
+		LPCRECT lpRectLast, SIZE sizeLast,
+		CBrush* pBrush = NULL, CBrush* pBrushLast = NULL);
+	void FillSolidRect(LPCRECT lpRect, COLORREF clr);
+	void FillSolidRect(int x, int y, int cx, int cy, COLORREF clr);
+	void Draw3dRect(LPCRECT lpRect, COLORREF clrTopLeft, COLORREF clrBottomRight);
+	void Draw3dRect(int x, int y, int cx, int cy,
+		COLORREF clrTopLeft, COLORREF clrBottomRight);
+
+// Implementation
+public:
+	virtual ~CDC();
+#ifdef _DEBUG
+	virtual void AssertValid() const;
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+
+	// advanced use and implementation
+	BOOL m_bPrinting;
+	HGDIOBJ SelectObject(HGDIOBJ);      // do not use for regions
+
+protected:
+	// used for implementation of non-virtual SelectObject calls
+	static CGdiObject* PASCAL SelectGdiObject(HDC hDC, HGDIOBJ h);
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// CDC Helpers
+
+class CPaintDC : public CDC
+{
+	DECLARE_DYNAMIC(CPaintDC)
+
+// Constructors
+public:
+	CPaintDC(CWnd* pWnd);   // BeginPaint
+
+// Attributes
+protected:
+	HWND m_hWnd;
+public:
+	PAINTSTRUCT m_ps;       // actual paint struct!
+
+// Implementation
+public:
+	virtual ~CPaintDC();
+#ifdef _DEBUG
+	virtual void AssertValid() const;
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+};
+
+class CClientDC : public CDC
+{
+	DECLARE_DYNAMIC(CClientDC)
+
+// Constructors
+public:
+	CClientDC(CWnd* pWnd);
+
+// Attributes
+protected:
+	HWND m_hWnd;
+
+// Implementation
+public:
+	virtual ~CClientDC();
+#ifdef _DEBUG
+	virtual void AssertValid() const;
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+};
+
+class CWindowDC : public CDC
+{
+	DECLARE_DYNAMIC(CWindowDC)
+
+// Constructors
+public:
+	CWindowDC(CWnd* pWnd);
+
+// Attributes
+protected:
+	HWND m_hWnd;
+
+// Implementation
+public:
+	virtual ~CWindowDC();
+#ifdef _DEBUG
+	virtual void AssertValid() const;
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// CMenu
+
+class CMenu : public CObject
+{
+	DECLARE_DYNCREATE(CMenu)
+public:
+
+// Constructors
+	CMenu();
+
+	BOOL CreateMenu();
+	BOOL CreatePopupMenu();
+	BOOL LoadMenu(LPCTSTR lpszResourceName);
+	BOOL LoadMenu(UINT nIDResource);
+	BOOL LoadMenuIndirect(const void* lpMenuTemplate);
+	BOOL DestroyMenu();
+
+// Attributes
+	HMENU m_hMenu;          // must be first data member
+	HMENU GetSafeHmenu() const;
+	operator HMENU() const;
+
+	static CMenu* PASCAL FromHandle(HMENU hMenu);
+	static void PASCAL DeleteTempMap();
+	BOOL Attach(HMENU hMenu);
+	HMENU Detach();
+
+// CMenu Operations
+	BOOL DeleteMenu(UINT nPosition, UINT nFlags);
+	BOOL TrackPopupMenu(UINT nFlags, int x, int y,
+						CWnd* pWnd, LPCRECT lpRect = 0);
+
+// CMenuItem Operations
+	BOOL AppendMenu(UINT nFlags, UINT nIDNewItem = 0,
+					LPCTSTR lpszNewItem = NULL);
+	BOOL AppendMenu(UINT nFlags, UINT nIDNewItem, const CBitmap* pBmp);
+	UINT CheckMenuItem(UINT nIDCheckItem, UINT nCheck);
+	UINT EnableMenuItem(UINT nIDEnableItem, UINT nEnable);
+	UINT GetMenuItemCount() const;
+	UINT GetMenuItemID(int nPos) const;
+	UINT GetMenuState(UINT nID, UINT nFlags) const;
+	int GetMenuString(UINT nIDItem, LPTSTR lpString, int nMaxCount,
+					UINT nFlags) const;
+	int GetMenuString(UINT nIDItem, CString& rString, UINT nFlags) const;
+	CMenu* GetSubMenu(int nPos) const;
+	BOOL InsertMenu(UINT nPosition, UINT nFlags, UINT nIDNewItem = 0,
+					LPCTSTR lpszNewItem = NULL);
+	BOOL InsertMenu(UINT nPosition, UINT nFlags, UINT nIDNewItem,
+					const CBitmap* pBmp);
+	BOOL ModifyMenu(UINT nPosition, UINT nFlags, UINT nIDNewItem = 0,
+					LPCTSTR lpszNewItem = NULL);
+	BOOL ModifyMenu(UINT nPosition, UINT nFlags, UINT nIDNewItem,
+					const CBitmap* pBmp);
+	BOOL RemoveMenu(UINT nPosition, UINT nFlags);
+	BOOL SetMenuItemBitmaps(UINT nPosition, UINT nFlags,
+					const CBitmap* pBmpUnchecked, const CBitmap* pBmpChecked);
+#ifndef _MAC
+	BOOL CheckMenuRadioItem(UINT nIDFirst, UINT nIDLast, UINT nIDItem, UINT nFlags);
+#endif
+
+// Context Help Functions
+#ifndef _MAC
+	BOOL SetMenuContextHelpId(DWORD dwContextHelpId);
+	DWORD GetMenuContextHelpId() const;
+#endif
+
+// Overridables (must override draw and measure for owner-draw menu items)
+	virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct);
+	virtual void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct);
+
+// Implementation
+public:
+	virtual ~CMenu();
+#ifdef _DEBUG
+	virtual void AssertValid() const;
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+	static CMenu* PASCAL CMenu::FromHandlePermanent(HMENU hMenu);
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// Window message map handling
+
+struct AFX_MSGMAP_ENTRY;       // declared below after CWnd
+
+struct AFX_MSGMAP
+{
+#ifdef _AFXDLL
+	const AFX_MSGMAP* (PASCAL* pfnGetBaseMap)();
+#else
+	const AFX_MSGMAP* pBaseMap;
+#endif
+	const AFX_MSGMAP_ENTRY* lpEntries;
+};
+
+#ifdef _AFXDLL
+#define DECLARE_MESSAGE_MAP() \
+private: \
+	static const AFX_MSGMAP_ENTRY _messageEntries[]; \
+protected: \
+	static AFX_DATA const AFX_MSGMAP messageMap; \
+	static const AFX_MSGMAP* PASCAL _GetBaseMessageMap(); \
+	virtual const AFX_MSGMAP* GetMessageMap() const; \
+
+#else
+#define DECLARE_MESSAGE_MAP() \
+private: \
+	static const AFX_MSGMAP_ENTRY _messageEntries[]; \
+protected: \
+	static AFX_DATA const AFX_MSGMAP messageMap; \
+	virtual const AFX_MSGMAP* GetMessageMap() const; \
+
+#endif
+
+#ifdef _AFXDLL
+#define BEGIN_MESSAGE_MAP(theClass, baseClass) \
+	const AFX_MSGMAP* PASCAL theClass::_GetBaseMessageMap() \
+		{ return &baseClass::messageMap; } \
+	const AFX_MSGMAP* theClass::GetMessageMap() const \
+		{ return &theClass::messageMap; } \
+	AFX_DATADEF const AFX_MSGMAP theClass::messageMap = \
+	{ &theClass::_GetBaseMessageMap, &theClass::_messageEntries[0] }; \
+	const AFX_MSGMAP_ENTRY theClass::_messageEntries[] = \
+	{ \
+
+#else
+#define BEGIN_MESSAGE_MAP(theClass, baseClass) \
+	const AFX_MSGMAP* theClass::GetMessageMap() const \
+		{ return &theClass::messageMap; } \
+	AFX_DATADEF const AFX_MSGMAP theClass::messageMap = \
+	{ &baseClass::messageMap, &theClass::_messageEntries[0] }; \
+	const AFX_MSGMAP_ENTRY theClass::_messageEntries[] = \
+	{ \
+
+#endif
+
+#define END_MESSAGE_MAP() \
+		{0, 0, 0, 0, AfxSig_end, (AFX_PMSG)0 } \
+	}; \
+
+// Message map signature values and macros in separate header
+#include <afxmsg_.h>
+
+/////////////////////////////////////////////////////////////////////////////
+// Dialog data exchange (DDX_) and validation (DDV_)
+
+// CDataExchange - for data exchange and validation
+class CDataExchange
+{
+// Attributes
+public:
+	BOOL m_bSaveAndValidate;   // TRUE => save and validate data
+	CWnd* m_pDlgWnd;           // container usually a dialog
+
+// Operations (for implementors of DDX and DDV procs)
+	HWND PrepareCtrl(int nIDC);     // return HWND of control
+	HWND PrepareEditCtrl(int nIDC); // return HWND of control
+	void Fail();                    // will throw exception
+
+#ifndef _AFX_NO_OCC_SUPPORT
+	CWnd* PrepareOleCtrl(int nIDC); // for OLE controls in dialog
+#endif
+
+// Implementation
+	CDataExchange(CWnd* pDlgWnd, BOOL bSaveAndValidate);
+
+	HWND m_hWndLastControl;    // last control used (for validation)
+	BOOL m_bEditLastControl;   // last control was an edit item
+};
+
+#include <afxdd_.h>     // standard DDX_ and DDV_ routines
+
+/////////////////////////////////////////////////////////////////////////////
+// OLE types
+
+typedef LONG HRESULT;
+
+struct IUnknown;
+typedef IUnknown* LPUNKNOWN;
+
+struct IDispatch;
+typedef IDispatch* LPDISPATCH;
+
+struct IConnectionPoint;
+typedef IConnectionPoint* LPCONNECTIONPOINT;
+
+struct IEnumOLEVERB;
+typedef IEnumOLEVERB* LPENUMOLEVERB;
+
+typedef struct _GUID GUID;
+typedef GUID IID;
+typedef GUID CLSID;
+#ifndef _REFCLSID_DEFINED
+#define REFCLSID const CLSID &
+#endif
+
+typedef long DISPID;
+typedef unsigned short VARTYPE;
+typedef long SCODE;
+
+#if defined(WIN32) && !defined(OLE2ANSI)
+typedef WCHAR OLECHAR;
+#else
+typedef char OLECHAR;
+#endif
+typedef OLECHAR* BSTR;
+
+struct tagDISPPARAMS;
+typedef tagDISPPARAMS DISPPARAMS;
+
+struct tagVARIANT;
+typedef tagVARIANT VARIANT;
+
+struct ITypeInfo;
+typedef ITypeInfo* LPTYPEINFO;
+
+struct ITypeLib;
+typedef ITypeLib* LPTYPELIB;
+
+/////////////////////////////////////////////////////////////////////////////
+// CCmdTarget
+
+// private structures
+struct AFX_CMDHANDLERINFO;  // info about where the command is handled
+struct AFX_EVENT;           // info about an event
+class CTypeLibCache;        // cache for OLE type libraries
+
+/////////////////////////////////////////////////////////////////////////////
+// OLE interface map handling (more in AFXDISP.H)
+
+#ifndef _AFX_NO_OLE_SUPPORT
+
+struct AFX_INTERFACEMAP_ENTRY
+{
+	const void* piid;       // the interface id (IID) (NULL for aggregate)
+	size_t nOffset;         // offset of the interface vtable from m_unknown
+};
+
+struct AFX_INTERFACEMAP
+{
+#ifdef _AFXDLL
+	const AFX_INTERFACEMAP* (PASCAL* pfnGetBaseMap)(); // NULL is root class
+#else
+	const AFX_INTERFACEMAP* pBaseMap;
+#endif
+	const AFX_INTERFACEMAP_ENTRY* pEntry; // map for this class
+};
+
+
+#ifdef _AFXDLL
+#define DECLARE_INTERFACE_MAP() \
+private: \
+	static const AFX_INTERFACEMAP_ENTRY _interfaceEntries[]; \
+protected: \
+	static AFX_DATA const AFX_INTERFACEMAP interfaceMap; \
+	static const AFX_INTERFACEMAP* PASCAL _GetBaseInterfaceMap(); \
+	virtual const AFX_INTERFACEMAP* GetInterfaceMap() const; \
+
+#else
+#define DECLARE_INTERFACE_MAP() \
+private: \
+	static const AFX_INTERFACEMAP_ENTRY _interfaceEntries[]; \
+protected: \
+	static AFX_DATA const AFX_INTERFACEMAP interfaceMap; \
+	virtual const AFX_INTERFACEMAP* GetInterfaceMap() const; \
+
+#endif
+
+#endif //!_AFX_NO_OLE_SUPPORT
+
+/////////////////////////////////////////////////////////////////////////////
+// OLE dispatch map handling (more in AFXDISP.H)
+
+#ifndef _AFX_NO_OLE_SUPPORT
+
+struct AFX_DISPMAP_ENTRY;
+
+struct AFX_DISPMAP
+{
+#ifdef _AFXDLL
+	const AFX_DISPMAP* (PASCAL* pfnGetBaseMap)();
+#else
+	const AFX_DISPMAP* pBaseMap;
+#endif
+	const AFX_DISPMAP_ENTRY* lpEntries;
+	UINT* lpEntryCount;
+};
+
+#ifdef _AFXDLL
+#define DECLARE_DISPATCH_MAP() \
+private: \
+	static const AFX_DISPMAP_ENTRY _dispatchEntries[]; \
+	static UINT _dispatchEntryCount; \
+protected: \
+	static AFX_DATA const AFX_DISPMAP dispatchMap; \
+	static const AFX_DISPMAP* PASCAL _GetBaseDispatchMap(); \
+	virtual const AFX_DISPMAP* GetDispatchMap() const; \
+
+#else
+#define DECLARE_DISPATCH_MAP() \
+private: \
+	static const AFX_DISPMAP_ENTRY _dispatchEntries[]; \
+	static UINT _dispatchEntryCount; \
+protected: \
+	static AFX_DATA const AFX_DISPMAP dispatchMap; \
+	virtual const AFX_DISPMAP* GetDispatchMap() const; \
+
+#endif
+
+#endif //!_AFX_NO_OLE_SUPPORT
+
+/////////////////////////////////////////////////////////////////////////////
+// OLE event sink map handling (more in AFXDISP.H)
+
+#ifndef _AFX_NO_OCC_SUPPORT
+
+struct AFX_EVENTSINKMAP_ENTRY;
+
+struct AFX_EVENTSINKMAP
+{
+#ifdef _AFXDLL
+	const AFX_EVENTSINKMAP* (PASCAL* pfnGetBaseMap)();
+#else
+	const AFX_EVENTSINKMAP* pBaseMap;
+#endif
+	const AFX_EVENTSINKMAP_ENTRY* lpEntries;
+	UINT* lpEntryCount;
+};
+
+#ifdef _AFXDLL
+#define DECLARE_EVENTSINK_MAP() \
+private: \
+	static const AFX_EVENTSINKMAP_ENTRY _eventsinkEntries[]; \
+	static UINT _eventsinkEntryCount; \
+protected: \
+	static AFX_DATA const AFX_EVENTSINKMAP eventsinkMap; \
+	static const AFX_EVENTSINKMAP* PASCAL _GetBaseEventSinkMap(); \
+	virtual const AFX_EVENTSINKMAP* GetEventSinkMap() const; \
+
+#else
+#define DECLARE_EVENTSINK_MAP() \
+private: \
+	static const AFX_EVENTSINKMAP_ENTRY _eventsinkEntries[]; \
+	static UINT _eventsinkEntryCount; \
+protected: \
+	static AFX_DATA const AFX_EVENTSINKMAP eventsinkMap; \
+	virtual const AFX_EVENTSINKMAP* GetEventSinkMap() const; \
+
+#endif
+
+#endif //!_AFX_NO_OCC_SUPPORT
+
+/////////////////////////////////////////////////////////////////////////////
+// OLE connection map handling (more in AFXDISP.H)
+
+#ifndef _AFX_NO_OLE_SUPPORT
+
+struct AFX_CONNECTIONMAP_ENTRY
+{
+	const void* piid;   // the interface id (IID)
+	size_t nOffset;         // offset of the interface vtable from m_unknown
+};
+
+struct AFX_CONNECTIONMAP
+{
+#ifdef _AFXDLL
+	const AFX_CONNECTIONMAP* (PASCAL* pfnGetBaseMap)(); // NULL is root class
+#else
+	const AFX_CONNECTIONMAP* pBaseMap;
+#endif
+	const AFX_CONNECTIONMAP_ENTRY* pEntry; // map for this class
+};
+
+#ifdef _AFXDLL
+#define DECLARE_CONNECTION_MAP() \
+private: \
+	static const AFX_CONNECTIONMAP_ENTRY _connectionEntries[]; \
+protected: \
+	static AFX_DATA const AFX_CONNECTIONMAP connectionMap; \
+	static const AFX_CONNECTIONMAP* PASCAL _GetBaseConnectionMap(); \
+	virtual const AFX_CONNECTIONMAP* GetConnectionMap() const; \
+
+#else
+#define DECLARE_CONNECTION_MAP() \
+private: \
+	static const AFX_CONNECTIONMAP_ENTRY _connectionEntries[]; \
+protected: \
+	static AFX_DATA const AFX_CONNECTIONMAP connectionMap; \
+	virtual const AFX_CONNECTIONMAP* GetConnectionMap() const; \
+
+#endif
+
+#endif //!_AFX_NO_OLE_SUPPORT
+
+/////////////////////////////////////////////////////////////////////////////
+// CCmdTarget proper
+
+#ifndef _AFX_NO_OCC_SUPPORT
+class COccManager;      // forward reference (see ..\src\occimpl.h)
+#endif
+
+class CCmdTarget : public CObject
+{
+	DECLARE_DYNAMIC(CCmdTarget)
+protected:
+
+public:
+// Constructors
+	CCmdTarget();
+
+// Attributes
+	LPDISPATCH GetIDispatch(BOOL bAddRef);
+		// retrieve IDispatch part of CCmdTarget
+	static CCmdTarget* PASCAL FromIDispatch(LPDISPATCH lpDispatch);
+		// map LPDISPATCH back to CCmdTarget* (inverse of GetIDispatch)
+	BOOL IsResultExpected();
+		// returns TRUE if automation function should return a value
+
+// Operations
+	void EnableAutomation();
+		// call in constructor to wire up IDispatch
+	void EnableConnections();
+		// call in constructor to wire up IConnectionPointContainer
+
+	void BeginWaitCursor();
+	void EndWaitCursor();
+	void RestoreWaitCursor();       // call after messagebox
+
+#ifndef _AFX_NO_OLE_SUPPORT
+	// dispatch OLE verbs through the message map
+	BOOL EnumOleVerbs(LPENUMOLEVERB* ppenumOleVerb);
+	BOOL DoOleVerb(LONG iVerb, LPMSG lpMsg, HWND hWndParent, LPCRECT lpRect);
+#endif
+
+// Overridables
+	// route and dispatch standard command message types
+	//   (more sophisticated than OnCommand)
+	virtual BOOL OnCmdMsg(UINT nID, int nCode, void* pExtra,
+		AFX_CMDHANDLERINFO* pHandlerInfo);
+
+#ifndef _AFX_NO_OLE_SUPPORT
+	// called when last OLE reference is released
+	virtual void OnFinalRelease();
+#endif
+
+#ifndef _AFX_NO_OLE_SUPPORT
+	// called before dispatching to an automation handler function
+	virtual BOOL IsInvokeAllowed(DISPID dispid);
+#endif
+
+#ifndef _AFX_NO_OLE_SUPPORT
+	// support for OLE type libraries
+	void EnableTypeLib();
+	HRESULT GetTypeInfoOfGuid(LCID lcid, const GUID& guid,
+		LPTYPEINFO* ppTypeInfo);
+	virtual BOOL GetDispatchIID(IID* pIID);
+	virtual UINT GetTypeInfoCount();
+	virtual CTypeLibCache* GetTypeLibCache();
+	virtual HRESULT GetTypeLib(LCID lcid, LPTYPELIB* ppTypeLib);
+#endif
+
+// Implementation
+public:
+	virtual ~CCmdTarget();
+#ifdef _DEBUG
+	virtual void Dump(CDumpContext& dc) const;
+	virtual void AssertValid() const;
+#endif
+#ifndef _AFX_NO_OLE_SUPPORT
+	void GetNotSupported();
+	void SetNotSupported();
+#endif
+
+protected:
+	friend class CView;
+
+	CView* GetRoutingView();
+	CFrameWnd* GetRoutingFrame();
+	DECLARE_MESSAGE_MAP()       // base class - no {{ }} macros
+
+#ifndef _AFX_NO_OLE_SUPPORT
+	DECLARE_DISPATCH_MAP()
+	DECLARE_CONNECTION_MAP()
+	DECLARE_INTERFACE_MAP()
+
+#ifndef _AFX_NO_OCC_SUPPORT
+	DECLARE_EVENTSINK_MAP()
+#endif // !_AFX_NO_OCC_SUPPORT
+
+	// OLE interface map implementation
+public:
+	// data used when CCmdTarget is made OLE aware
+	long m_dwRef;
+	LPUNKNOWN m_pOuterUnknown;  // external controlling unknown if != NULL
+	DWORD m_xInnerUnknown;  // place-holder for inner controlling unknown
+
+public:
+	// advanced operations
+	void EnableAggregation();       // call to enable aggregation
+	void ExternalDisconnect();      // forcibly disconnect
+	LPUNKNOWN GetControllingUnknown();
+		// get controlling IUnknown for aggregate creation
+
+	// these versions do not delegate to m_pOuterUnknown
+	DWORD InternalQueryInterface(const void*, LPVOID* ppvObj);
+	DWORD InternalAddRef();
+	DWORD InternalRelease();
+	// these versions delegate to m_pOuterUnknown
+	DWORD ExternalQueryInterface(const void*, LPVOID* ppvObj);
+	DWORD ExternalAddRef();
+	DWORD ExternalRelease();
+
+	// implementation helpers
+	LPUNKNOWN GetInterface(const void*);
+	LPUNKNOWN QueryAggregates(const void*);
+
+	// advanced overrideables for implementation
+	virtual BOOL OnCreateAggregates();
+	virtual LPUNKNOWN GetInterfaceHook(const void*);
+
+	// OLE automation implementation
+protected:
+	struct XDispatch
+	{
+		DWORD m_vtbl;   // place-holder for IDispatch vtable
+#ifndef _AFX_NO_NESTED_DERIVATION
+		size_t m_nOffset;
+#endif
+	} m_xDispatch;
+	BOOL m_bResultExpected;
+
+	// member variable-based properties
+	void GetStandardProp(const AFX_DISPMAP_ENTRY* pEntry,
+		VARIANT* pvarResult, UINT* puArgErr);
+	SCODE SetStandardProp(const AFX_DISPMAP_ENTRY* pEntry,
+		DISPPARAMS* pDispParams, UINT* puArgErr);
+
+	// DISPID to dispatch map lookup
+	static UINT PASCAL GetEntryCount(const AFX_DISPMAP* pDispMap);
+	const AFX_DISPMAP_ENTRY* PASCAL GetDispEntry(LONG memid);
+	static LONG PASCAL MemberIDFromName(const AFX_DISPMAP* pDispMap, LPCTSTR lpszName);
+
+	// helpers for member function calling implementation
+	static UINT PASCAL GetStackSize(const BYTE* pbParams, VARTYPE vtResult);
+#if defined(_PPC_) || defined(_MPPC_)
+	SCODE PushStackArgs(BYTE* pStack, const BYTE* pbParams,
+		void* pResult, VARTYPE vtResult, DISPPARAMS* pDispParams,
+		UINT* puArgErr, VARIANT* rgTempVars, UINT nSizeArgs);
+#else
+	SCODE PushStackArgs(BYTE* pStack, const BYTE* pbParams,
+		void* pResult, VARTYPE vtResult, DISPPARAMS* pDispParams,
+		UINT* puArgErr, VARIANT* rgTempVars);
+#endif
+	SCODE CallMemberFunc(const AFX_DISPMAP_ENTRY* pEntry, WORD wFlags,
+		VARIANT* pvarResult, DISPPARAMS* pDispParams, UINT* puArgErr);
+
+	friend class COleDispatchImpl;
+
+#ifndef _AFX_NO_OCC_SUPPORT
+public:
+	// OLE event sink implementation
+	BOOL OnEvent(UINT idCtrl, AFX_EVENT* pEvent,
+		AFX_CMDHANDLERINFO* pHandlerInfo);
+protected:
+	const AFX_EVENTSINKMAP_ENTRY* PASCAL GetEventSinkEntry(UINT idCtrl,
+		AFX_EVENT* pEvent);
+#endif // !_AFX_NO_OCC_SUPPORT
+
+	// OLE connection implementation
+	struct XConnPtContainer
+	{
+		DWORD m_vtbl;   // place-holder for IConnectionPointContainer vtable
+#ifndef _AFX_NO_NESTED_DERIVATION
+		size_t m_nOffset;
+#endif
+	} m_xConnPtContainer;
+
+#ifdef _AFXDLL
+	AFX_MODULE_STATE* m_pModuleState;
+	friend class CInnerUnknown;
+#endif
+
+	virtual BOOL GetExtraConnectionPoints(CPtrArray* pConnPoints);
+	virtual LPCONNECTIONPOINT GetConnectionHook(const IID& iid);
+
+	friend class COleConnPtContainer;
+
+#endif //!_AFX_NO_OLE_SUPPORT
+};
+
+class CCmdUI        // simple helper class
+{
+public:
+// Attributes
+	UINT m_nID;
+	UINT m_nIndex;          // menu item or other index
+
+	// if a menu item
+	CMenu* m_pMenu;         // NULL if not a menu
+	CMenu* m_pSubMenu;      // sub containing menu item
+							// if a popup sub menu - ID is for first in popup
+
+	// if from some other window
+	CWnd* m_pOther;         // NULL if a menu or not a CWnd
+
+// Operations to do in ON_UPDATE_COMMAND_UI
+	virtual void Enable(BOOL bOn = TRUE);
+	virtual void SetCheck(int nCheck = 1);   // 0, 1 or 2 (indeterminate)
+	virtual void SetRadio(BOOL bOn = TRUE);
+	virtual void SetText(LPCTSTR lpszText);
+
+// Advanced operation
+	void ContinueRouting();
+
+// Implementation
+	CCmdUI();
+	BOOL m_bEnableChanged;
+	BOOL m_bContinueRouting;
+	UINT m_nIndexMax;       // last + 1 for iterating m_nIndex
+
+	CMenu* m_pParentMenu;   // NULL if parent menu not easily determined
+							//  (probably a secondary popup menu)
+
+	BOOL DoUpdate(CCmdTarget* pTarget, BOOL bDisableIfNoHndler);
+};
+
+// special CCmdUI derived classes are used for other UI paradigms
+//  like toolbar buttons and status indicators
+
+// pointer to afx_msg member function
+#ifndef AFX_MSG_CALL
+#define AFX_MSG_CALL
+#endif
+typedef void (AFX_MSG_CALL CCmdTarget::*AFX_PMSG)(void);
+
+enum AFX_DISPMAP_FLAGS
+{
+	afxDispCustom = 0,
+	afxDispStock = 1
+};
+
+struct AFX_DISPMAP_ENTRY
+{
+	LPCTSTR lpszName;       // member/property name
+	long lDispID;           // DISPID (may be DISPID_UNKNOWN)
+	LPCSTR lpszParams;      // member parameter description
+	WORD vt;                // return value type / or type of property
+	AFX_PMSG pfn;           // normal member On<membercall> or, OnGet<property>
+	AFX_PMSG pfnSet;        // special member for OnSet<property>
+	size_t nPropOffset;     // property offset
+	AFX_DISPMAP_FLAGS flags;// flags (e.g. stock/custom)
+};
+
+struct AFX_EVENTSINKMAP_ENTRY
+{
+	AFX_DISPMAP_ENTRY dispEntry;
+	UINT nCtrlIDFirst;
+	UINT nCtrlIDLast;
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// CWnd implementation
+
+// structures (see afxext.h)
+struct CCreateContext;      // context for creating things
+struct CPrintInfo;          // print preview customization info
+
+struct AFX_MSGMAP_ENTRY
+{
+	UINT nMessage;   // windows message
+	UINT nCode;      // control code or WM_NOTIFY code
+	UINT nID;        // control ID (or 0 for windows messages)
+	UINT nLastID;    // used for entries specifying a range of control id's
+	UINT nSig;       // signature type (action) or pointer to message #
+	AFX_PMSG pfn;    // routine to call (or special value)
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// CWnd - a Microsoft Windows application window
+
+class COleDropTarget;   // for more information see AFXOLE.H
+class COleControlContainer;
+class COleControlSite;
+
+// CWnd::m_nFlags (generic to CWnd)
+#define WF_TOOLTIPS         0x0001  // window is enabled for tooltips
+#define WF_TEMPHIDE         0x0002  // window is temporarily hidden
+#define WF_STAYDISABLED     0x0004  // window should stay disabled
+#define WF_MODALLOOP        0x0008  // currently in modal loop
+#define WF_CONTINUEMODAL    0x0010  // modal loop should continue running
+#define WF_OLECTLCONTAINER  0x0100  // some descendant is an OLE control
+
+// CWnd::m_nFlags (specific to CFrameWnd)
+#define WF_STAYACTIVE       0x0020  // look active even though not active
+#define WF_NOPOPMSG         0x0040  // ignore WM_POPMESSAGESTRING calls
+#define WF_MODALDISABLE     0x0080  // window is disabled
+#define WF_KEEPMINIACTIVE   0x0200  // stay activate even though you are deactivated
+
+// flags for CWnd::RunModalLoop
+#define MLF_NOIDLEMSG       0x0001  // don't send WM_ENTERIDLE messages
+#define MLF_NOKICKIDLE      0x0002  // don't send WM_KICKIDLE messages
+#define MLF_SHOWONIDLE      0x0004  // show window if not visible at idle time
+
+// extra MFC defined TTF_ flags for TOOLINFO::uFlags
+#define TTF_NOTBUTTON       0x80000000L // no status help on buttondown
+#define TTF_ALWAYSTIP       0x40000000L // always show the tip even if not active
+
+class CWnd : public CCmdTarget
+{
+	DECLARE_DYNCREATE(CWnd)
+protected:
+	static const MSG* PASCAL GetCurrentMessage();
+
+// Attributes
+public:
+	HWND m_hWnd;            // must be first data member
+	operator HWND() const;
+
+	HWND GetSafeHwnd() const;
+	DWORD GetStyle() const;
+	DWORD GetExStyle() const;
+	BOOL ModifyStyle(DWORD dwRemove, DWORD dwAdd, UINT nFlags = 0);
+	BOOL ModifyStyleEx(DWORD dwRemove, DWORD dwAdd, UINT nFlags = 0);
+
+	CWnd* GetOwner() const;
+	void SetOwner(CWnd* pOwnerWnd);
+
+// Constructors and other creation
+	CWnd();
+
+	static CWnd* PASCAL FromHandle(HWND hWnd);
+	static CWnd* PASCAL FromHandlePermanent(HWND hWnd);
+	static void PASCAL DeleteTempMap();
+	BOOL Attach(HWND hWndNew);
+	HWND Detach();
+
+	// subclassing/unsubclassing functions
+	virtual void PreSubclassWindow();
+	BOOL SubclassWindow(HWND hWnd);
+	BOOL SubclassDlgItem(UINT nID, CWnd* pParent);
+	HWND UnsubclassWindow();
+
+	// handling of RT_DLGINIT resource (extension to RT_DIALOG)
+	BOOL ExecuteDlgInit(LPCTSTR lpszResourceName);
+	BOOL ExecuteDlgInit(LPVOID lpResource);
+
+public:
+	// for child windows, views, panes etc
+	virtual BOOL Create(LPCTSTR lpszClassName,
+		LPCTSTR lpszWindowName, DWORD dwStyle,
+		const RECT& rect,
+		CWnd* pParentWnd, UINT nID,
+		CCreateContext* pContext = NULL);
+
+	// advanced creation (allows access to extended styles)
+	BOOL CreateEx(DWORD dwExStyle, LPCTSTR lpszClassName,
+		LPCTSTR lpszWindowName, DWORD dwStyle,
+		int x, int y, int nWidth, int nHeight,
+		HWND hWndParent, HMENU nIDorHMenu, LPVOID lpParam = NULL);
+
+#ifndef _AFX_NO_OCC_SUPPORT
+	// for wrapping OLE controls
+	BOOL CreateControl(REFCLSID clsid, LPCTSTR pszWindowName, DWORD dwStyle,
+		const RECT& rect, CWnd* pParentWnd, UINT nID, CFile* pPersist=NULL,
+		BOOL bStorage=FALSE, BSTR bstrLicKey=NULL);
+
+	BOOL CreateControl(LPCTSTR pszClass, LPCTSTR pszWindowName, DWORD dwStyle,
+		const RECT& rect, CWnd* pParentWnd, UINT nID, CFile* pPersist=NULL,
+		BOOL bStorage=FALSE, BSTR bstrLicKey=NULL);
+
+	LPUNKNOWN GetControlUnknown();
+#endif
+
+	virtual BOOL DestroyWindow();
+
+	// special pre-creation and window rect adjustment hooks
+	virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
+
+	// Advanced: virtual AdjustWindowRect
+	enum AdjustType { adjustBorder = 0, adjustOutside = 1 };
+	virtual void CalcWindowRect(LPRECT lpClientRect,
+		UINT nAdjustType = adjustBorder);
+
+// Window tree access
+	int GetDlgCtrlID() const;
+	int SetDlgCtrlID(int nID);
+		// get and set window ID, for child windows only
+	CWnd* GetDlgItem(int nID) const;
+		// get immediate child with given ID
+	void GetDlgItem(int nID, HWND* phWnd) const;
+		// as above, but returns HWND
+	CWnd* GetDescendantWindow(int nID, BOOL bOnlyPerm = FALSE) const;
+		// like GetDlgItem but recursive
+	void SendMessageToDescendants(UINT message, WPARAM wParam = 0,
+		LPARAM lParam = 0, BOOL bDeep = TRUE, BOOL bOnlyPerm = FALSE);
+	CFrameWnd* GetParentFrame() const;
+	CWnd* GetTopLevelParent() const;
+	CWnd* GetTopLevelOwner() const;
+	CWnd* GetParentOwner() const;
+	CFrameWnd* GetTopLevelFrame() const;
+	static CWnd* PASCAL GetSafeOwner(CWnd* pParent = NULL, HWND* pWndTop = NULL);
+
+// Message Functions
+	LRESULT SendMessage(UINT message, WPARAM wParam = 0, LPARAM lParam = 0);
+	BOOL PostMessage(UINT message, WPARAM wParam = 0, LPARAM lParam = 0);
+
+#ifndef _MAC
+	BOOL SendNotifyMessage(UINT message, WPARAM wParam, LPARAM lParam);
+#endif
+	BOOL SendChildNotifyLastMsg(LRESULT* pResult = NULL);
+
+// Message processing for modeless dialog-like windows
+	BOOL IsDialogMessage(LPMSG lpMsg);
+
+// Window Text Functions
+	void SetWindowText(LPCTSTR lpszString);
+	int GetWindowText(LPTSTR lpszStringBuf, int nMaxCount) const;
+	void GetWindowText(CString& rString) const;
+	int GetWindowTextLength() const;
+	void SetFont(CFont* pFont, BOOL bRedraw = TRUE);
+	CFont* GetFont() const;
+
+// CMenu Functions - non-Child windows only
+	CMenu* GetMenu() const;
+	BOOL SetMenu(CMenu* pMenu);
+	void DrawMenuBar();
+	CMenu* GetSystemMenu(BOOL bRevert) const;
+	BOOL HiliteMenuItem(CMenu* pMenu, UINT nIDHiliteItem, UINT nHilite);
+
+// Window Size and Position Functions
+	BOOL IsIconic() const;
+	BOOL IsZoomed() const;
+	void MoveWindow(int x, int y, int nWidth, int nHeight,
+				BOOL bRepaint = TRUE);
+	void MoveWindow(LPCRECT lpRect, BOOL bRepaint = TRUE);
+
+	static AFX_DATA const CWnd wndTop; // SetWindowPos's pWndInsertAfter
+	static AFX_DATA const CWnd wndBottom; // SetWindowPos's pWndInsertAfter
+	static AFX_DATA const CWnd wndTopMost; // SetWindowPos pWndInsertAfter
+	static AFX_DATA const CWnd wndNoTopMost; // SetWindowPos pWndInsertAfter
+
+	BOOL SetWindowPos(const CWnd* pWndInsertAfter, int x, int y,
+				int cx, int cy, UINT nFlags);
+#ifndef _MAC
+	UINT ArrangeIconicWindows();
+#endif
+	void BringWindowToTop();
+	void GetWindowRect(LPRECT lpRect) const;
+	void GetClientRect(LPRECT lpRect) const;
+
+	BOOL GetWindowPlacement(WINDOWPLACEMENT* lpwndpl) const;
+	BOOL SetWindowPlacement(const WINDOWPLACEMENT* lpwndpl);
+
+// Coordinate Mapping Functions
+	void ClientToScreen(LPPOINT lpPoint) const;
+	void ClientToScreen(LPRECT lpRect) const;
+	void ScreenToClient(LPPOINT lpPoint) const;
+	void ScreenToClient(LPRECT lpRect) const;
+	void MapWindowPoints(CWnd* pwndTo, LPPOINT lpPoint, UINT nCount) const;
+	void MapWindowPoints(CWnd* pwndTo, LPRECT lpRect) const;
+
+// Update/Painting Functions
+	CDC* BeginPaint(LPPAINTSTRUCT lpPaint);
+	void EndPaint(LPPAINTSTRUCT lpPaint);
+	CDC* GetDC();
+	CDC* GetWindowDC();
+	int ReleaseDC(CDC* pDC);
+	void Print(CDC* pDC, DWORD dwFlags) const;
+	void PrintClient(CDC* pDC, DWORD dwFlags) const;
+
+	void UpdateWindow();
+	void SetRedraw(BOOL bRedraw = TRUE);
+	BOOL GetUpdateRect(LPRECT lpRect, BOOL bErase = FALSE);
+	int GetUpdateRgn(CRgn* pRgn, BOOL bErase = FALSE);
+	void Invalidate(BOOL bErase = TRUE);
+	void InvalidateRect(LPCRECT lpRect, BOOL bErase = TRUE);
+	void InvalidateRgn(CRgn* pRgn, BOOL bErase = TRUE);
+	void ValidateRect(LPCRECT lpRect);
+	void ValidateRgn(CRgn* pRgn);
+	BOOL ShowWindow(int nCmdShow);
+	BOOL IsWindowVisible() const;
+	void ShowOwnedPopups(BOOL bShow = TRUE);
+
+	CDC* GetDCEx(CRgn* prgnClip, DWORD flags);
+#ifndef _MAC
+	BOOL LockWindowUpdate();    // for backward compatibility
+	void UnlockWindowUpdate();
+#endif
+	BOOL RedrawWindow(LPCRECT lpRectUpdate = NULL,
+		CRgn* prgnUpdate = NULL,
+		UINT flags = RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE);
+	BOOL EnableScrollBar(int nSBFlags, UINT nArrowFlags = ESB_ENABLE_BOTH);
+
+// Timer Functions
+	UINT SetTimer(UINT nIDEvent, UINT nElapse,
+		void (CALLBACK* lpfnTimer)(HWND, UINT, UINT, DWORD));
+	BOOL KillTimer(int nIDEvent);
+
+// ToolTip Functions
+	BOOL EnableToolTips(BOOL bEnable = TRUE);
+	static void PASCAL CancelToolTips(BOOL bKeys = FALSE);
+	void FilterToolTipMessage(MSG* pMsg);
+
+	// for command hit testing (used for automatic tooltips)
+	virtual int OnToolHitTest(CPoint point, TOOLINFO* pTI) const;
+
+// Window State Functions
+	BOOL IsWindowEnabled() const;
+	BOOL EnableWindow(BOOL bEnable = TRUE);
+
+	// the active window applies only to top-level (frame windows)
+	static CWnd* PASCAL GetActiveWindow();
+	CWnd* SetActiveWindow();
+
+	// the foreground window applies only to top-level windows (frame windows)
+	BOOL SetForegroundWindow();
+	static CWnd* PASCAL GetForegroundWindow();
+
+	// capture and focus apply to all windows
+	static CWnd* PASCAL GetCapture();
+	CWnd* SetCapture();
+	static CWnd* PASCAL GetFocus();
+	CWnd* SetFocus();
+
+	static CWnd* PASCAL GetDesktopWindow();
+
+// Obsolete and non-portable APIs - not recommended for new code
+#ifndef _MAC
+	void CloseWindow();
+	BOOL OpenIcon();
+#endif
+
+// Dialog-Box Item Functions
+// (NOTE: Dialog-Box Items/Controls are not necessarily in dialog boxes!)
+	void CheckDlgButton(int nIDButton, UINT nCheck);
+	void CheckRadioButton(int nIDFirstButton, int nIDLastButton,
+					int nIDCheckButton);
+	int GetCheckedRadioButton(int nIDFirstButton, int nIDLastButton);
+#ifndef _MAC
+	int DlgDirList(LPTSTR lpPathSpec, int nIDListBox,
+					int nIDStaticPath, UINT nFileType);
+	int DlgDirListComboBox(LPTSTR lpPathSpec, int nIDComboBox,
+					int nIDStaticPath, UINT nFileType);
+	BOOL DlgDirSelect(LPTSTR lpString, int nIDListBox);
+	BOOL DlgDirSelectComboBox(LPTSTR lpString, int nIDComboBox);
+#endif
+
+	UINT GetDlgItemInt(int nID, BOOL* lpTrans = NULL,
+					BOOL bSigned = TRUE) const;
+	int GetDlgItemText(int nID, LPTSTR lpStr, int nMaxCount) const;
+	int GetDlgItemText(int nID, CString& rString) const;
+	CWnd* GetNextDlgGroupItem(CWnd* pWndCtl, BOOL bPrevious = FALSE) const;
+
+	CWnd* GetNextDlgTabItem(CWnd* pWndCtl, BOOL bPrevious = FALSE) const;
+	UINT IsDlgButtonChecked(int nIDButton) const;
+	LRESULT SendDlgItemMessage(int nID, UINT message,
+					WPARAM wParam = 0, LPARAM lParam = 0);
+	void SetDlgItemInt(int nID, UINT nValue, BOOL bSigned = TRUE);
+	void SetDlgItemText(int nID, LPCTSTR lpszString);
+
+// Scrolling Functions
+	int GetScrollPos(int nBar) const;
+	void GetScrollRange(int nBar, LPINT lpMinPos, LPINT lpMaxPos) const;
+	void ScrollWindow(int xAmount, int yAmount,
+					LPCRECT lpRect = NULL,
+					LPCRECT lpClipRect = NULL);
+	int SetScrollPos(int nBar, int nPos, BOOL bRedraw = TRUE);
+	void SetScrollRange(int nBar, int nMinPos, int nMaxPos,
+			BOOL bRedraw = TRUE);
+	void ShowScrollBar(UINT nBar, BOOL bShow = TRUE);
+	void EnableScrollBarCtrl(int nBar, BOOL bEnable = TRUE);
+	virtual CScrollBar* GetScrollBarCtrl(int nBar) const;
+			// return sibling scrollbar control (or NULL if none)
+
+	int ScrollWindowEx(int dx, int dy,
+				LPCRECT lpRectScroll, LPCRECT lpRectClip,
+				CRgn* prgnUpdate, LPRECT lpRectUpdate, UINT flags);
+	BOOL SetScrollInfo(int nBar, LPSCROLLINFO lpScrollInfo,
+		BOOL bRedraw = TRUE);
+	BOOL GetScrollInfo(int nBar, LPSCROLLINFO lpScrollInfo, UINT nMask = SIF_ALL);
+	int GetScrollLimit(int nBar);
+
+// Window Access Functions
+	CWnd* ChildWindowFromPoint(POINT point) const;
+#ifndef _MAC
+	CWnd* ChildWindowFromPoint(POINT point, UINT nFlags) const;
+#endif
+	static CWnd* PASCAL FindWindow(LPCTSTR lpszClassName, LPCTSTR lpszWindowName);
+	CWnd* GetNextWindow(UINT nFlag = GW_HWNDNEXT) const;
+	CWnd* GetTopWindow() const;
+
+	CWnd* GetWindow(UINT nCmd) const;
+	CWnd* GetLastActivePopup() const;
+
+	BOOL IsChild(const CWnd* pWnd) const;
+	CWnd* GetParent() const;
+	CWnd* SetParent(CWnd* pWndNewParent);
+	static CWnd* PASCAL WindowFromPoint(POINT point);
+
+// Alert Functions
+	BOOL FlashWindow(BOOL bInvert);
+	int MessageBox(LPCTSTR lpszText, LPCTSTR lpszCaption = NULL,
+			UINT nType = MB_OK);
+
+// Clipboard Functions
+	BOOL ChangeClipboardChain(HWND hWndNext);
+	HWND SetClipboardViewer();
+	BOOL OpenClipboard();
+	static CWnd* PASCAL GetClipboardOwner();
+	static CWnd* PASCAL GetClipboardViewer();
+	static CWnd* PASCAL GetOpenClipboardWindow();
+
+// Caret Functions
+	void CreateCaret(CBitmap* pBitmap);
+	void CreateSolidCaret(int nWidth, int nHeight);
+	void CreateGrayCaret(int nWidth, int nHeight);
+	static CPoint PASCAL GetCaretPos();
+	static void PASCAL SetCaretPos(POINT point);
+	void HideCaret();
+	void ShowCaret();
+
+// Shell Interaction Functions
+	void DragAcceptFiles(BOOL bAccept = TRUE);
+
+// Icon Functions
+	HICON SetIcon(HICON hIcon, BOOL bBigIcon);
+	HICON GetIcon(BOOL bBigIcon) const;
+
+// Context Help Functions
+#ifndef _MAC
+	BOOL SetWindowContextHelpId(DWORD dwContextHelpId);
+	DWORD GetWindowContextHelpId() const;
+
+#endif
+
+// Dialog Data support
+public:
+	BOOL UpdateData(BOOL bSaveAndValidate = TRUE);
+			// data wnd must be same type as this
+
+// Help Command Handlers
+	afx_msg void OnHelp();          // F1 (uses current context)
+	afx_msg void OnHelpIndex();     // ID_HELP_INDEX
+	afx_msg void OnHelpFinder();    // ID_HELP_FINDER, ID_DEFAULT_HELP
+	afx_msg void OnHelpUsing();     // ID_HELP_USING
+	virtual void WinHelp(DWORD dwData, UINT nCmd = HELP_CONTEXT);
+
+// Layout and other functions
+public:
+	enum RepositionFlags
+		{ reposDefault = 0, reposQuery = 1, reposExtra = 2 };
+	void RepositionBars(UINT nIDFirst, UINT nIDLast, UINT nIDLeftOver,
+		UINT nFlag = reposDefault, LPRECT lpRectParam = NULL,
+		LPCRECT lpRectClient = NULL, BOOL bStretch = TRUE);
+
+	// dialog support
+	void UpdateDialogControls(CCmdTarget* pTarget, BOOL bDisableIfNoHndler);
+	void CenterWindow(CWnd* pAlternateOwner = NULL);
+	int RunModalLoop(DWORD dwFlags = 0);
+	virtual BOOL ContinueModal();
+	virtual void EndModalLoop(int nResult);
+
+#ifndef _AFX_NO_OCC_SUPPORT
+// OLE control wrapper functions
+	void AFX_CDECL InvokeHelper(DISPID dwDispID, WORD wFlags,
+		VARTYPE vtRet, void* pvRet, const BYTE* pbParamInfo, ...);
+	void AFX_CDECL SetProperty(DISPID dwDispID, VARTYPE vtProp, ...);
+	void GetProperty(DISPID dwDispID, VARTYPE vtProp, void* pvProp) const;
+#endif
+
+// Window-Management message handler member functions
+protected:
+	virtual BOOL OnCommand(WPARAM wParam, LPARAM lParam);
+	virtual BOOL OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult);
+
+	afx_msg void OnActivate(UINT nState, CWnd* pWndOther, BOOL bMinimized);
+	afx_msg void OnActivateApp(BOOL bActive, HTASK hTask);
+	afx_msg LRESULT OnActivateTopLevel(WPARAM, LPARAM);
+	afx_msg void OnCancelMode();
+	afx_msg void OnChildActivate();
+	afx_msg void OnClose();
+	afx_msg void OnContextMenu(CWnd* pWnd, CPoint pos);
+	afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
+
+	afx_msg HBRUSH OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor);
+
+	afx_msg void OnDestroy();
+	afx_msg void OnEnable(BOOL bEnable);
+	afx_msg void OnEndSession(BOOL bEnding);
+	afx_msg void OnEnterIdle(UINT nWhy, CWnd* pWho);
+	afx_msg BOOL OnEraseBkgnd(CDC* pDC);
+	afx_msg void OnGetMinMaxInfo(MINMAXINFO* lpMMI);
+	afx_msg BOOL OnHelpInfo(HELPINFO* lpHelpInfo);
+	afx_msg void OnIconEraseBkgnd(CDC* pDC);
+	afx_msg void OnKillFocus(CWnd* pNewWnd);
+	afx_msg LRESULT OnMenuChar(UINT nChar, UINT nFlags, CMenu* pMenu);
+	afx_msg void OnMenuSelect(UINT nItemID, UINT nFlags, HMENU hSysMenu);
+	afx_msg void OnMove(int x, int y);
+	afx_msg void OnPaint();
+	afx_msg void OnParentNotify(UINT message, LPARAM lParam);
+	afx_msg HCURSOR OnQueryDragIcon();
+	afx_msg BOOL OnQueryEndSession();
+	afx_msg BOOL OnQueryNewPalette();
+	afx_msg BOOL OnQueryOpen();
+	afx_msg void OnSetFocus(CWnd* pOldWnd);
+	afx_msg void OnShowWindow(BOOL bShow, UINT nStatus);
+	afx_msg void OnSize(UINT nType, int cx, int cy);
+	afx_msg void OnTCard(UINT idAction, DWORD dwActionData);
+	afx_msg void OnWindowPosChanging(WINDOWPOS* lpwndpos);
+	afx_msg void OnWindowPosChanged(WINDOWPOS* lpwndpos);
+
+// Nonclient-Area message handler member functions
+	afx_msg BOOL OnNcActivate(BOOL bActive);
+	afx_msg void OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS* lpncsp);
+	afx_msg BOOL OnNcCreate(LPCREATESTRUCT lpCreateStruct);
+	afx_msg void OnNcDestroy();
+	afx_msg UINT OnNcHitTest(CPoint point);
+	afx_msg void OnNcLButtonDblClk(UINT nHitTest, CPoint point);
+	afx_msg void OnNcLButtonDown(UINT nHitTest, CPoint point);
+	afx_msg void OnNcLButtonUp(UINT nHitTest, CPoint point);
+	afx_msg void OnNcMButtonDblClk(UINT nHitTest, CPoint point);
+	afx_msg void OnNcMButtonDown(UINT nHitTest, CPoint point);
+	afx_msg void OnNcMButtonUp(UINT nHitTest, CPoint point);
+	afx_msg void OnNcMouseMove(UINT nHitTest, CPoint point);
+	afx_msg void OnNcPaint();
+	afx_msg void OnNcRButtonDblClk(UINT nHitTest, CPoint point);
+	afx_msg void OnNcRButtonDown(UINT nHitTest, CPoint point);
+	afx_msg void OnNcRButtonUp(UINT nHitTest, CPoint point);
+
+// System message handler member functions
+	afx_msg void OnDropFiles(HDROP hDropInfo);
+	afx_msg void OnPaletteIsChanging(CWnd* pRealizeWnd);
+	afx_msg void OnSysChar(UINT nChar, UINT nRepCnt, UINT nFlags);
+	afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
+	afx_msg void OnSysDeadChar(UINT nChar, UINT nRepCnt, UINT nFlags);
+	afx_msg void OnSysKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
+	afx_msg void OnSysKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags);
+	afx_msg void OnCompacting(UINT nCpuTime);
+	afx_msg void OnDevModeChange(LPTSTR lpDeviceName);
+	afx_msg void OnFontChange();
+	afx_msg void OnPaletteChanged(CWnd* pFocusWnd);
+	afx_msg void OnSpoolerStatus(UINT nStatus, UINT nJobs);
+	afx_msg void OnSysColorChange();
+	afx_msg void OnTimeChange();
+	afx_msg void OnWinIniChange(LPCTSTR lpszSection);
+
+// Input message handler member functions
+	afx_msg void OnChar(UINT nChar, UINT nRepCnt, UINT nFlags);
+	afx_msg void OnDeadChar(UINT nChar, UINT nRepCnt, UINT nFlags);
+	afx_msg void OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
+	afx_msg void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
+	afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
+	afx_msg void OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags);
+	afx_msg void OnLButtonDblClk(UINT nFlags, CPoint point);
+	afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
+	afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
+	afx_msg void OnMButtonDblClk(UINT nFlags, CPoint point);
+	afx_msg void OnMButtonDown(UINT nFlags, CPoint point);
+	afx_msg void OnMButtonUp(UINT nFlags, CPoint point);
+	afx_msg int OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message);
+	afx_msg void OnMouseMove(UINT nFlags, CPoint point);
+	afx_msg void OnRButtonDblClk(UINT nFlags, CPoint point);
+	afx_msg void OnRButtonDown(UINT nFlags, CPoint point);
+	afx_msg void OnRButtonUp(UINT nFlags, CPoint point);
+	afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
+	afx_msg void OnTimer(UINT nIDEvent);
+
+// Initialization message handler member functions
+	afx_msg void OnInitMenu(CMenu* pMenu);
+	afx_msg void OnInitMenuPopup(CMenu* pPopupMenu, UINT nIndex, BOOL bSysMenu);
+
+// Clipboard message handler member functions
+	afx_msg void OnAskCbFormatName(UINT nMaxCount, LPTSTR lpszString);
+	afx_msg void OnChangeCbChain(HWND hWndRemove, HWND hWndAfter);
+	afx_msg void OnDestroyClipboard();
+	afx_msg void OnDrawClipboard();
+	afx_msg void OnHScrollClipboard(CWnd* pClipAppWnd, UINT nSBCode, UINT nPos);
+	afx_msg void OnPaintClipboard(CWnd* pClipAppWnd, HGLOBAL hPaintStruct);
+	afx_msg void OnRenderAllFormats();
+	afx_msg void OnRenderFormat(UINT nFormat);
+	afx_msg void OnSizeClipboard(CWnd* pClipAppWnd, HGLOBAL hRect);
+	afx_msg void OnVScrollClipboard(CWnd* pClipAppWnd, UINT nSBCode, UINT nPos);
+
+// Control message handler member functions
+	afx_msg int OnCompareItem(int nIDCtl, LPCOMPAREITEMSTRUCT lpCompareItemStruct);
+	afx_msg void OnDeleteItem(int nIDCtl, LPDELETEITEMSTRUCT lpDeleteItemStruct);
+	afx_msg void OnDrawItem(int nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct);
+	afx_msg UINT OnGetDlgCode();
+	afx_msg void OnMeasureItem(int nIDCtl, LPMEASUREITEMSTRUCT lpMeasureItemStruct);
+	afx_msg int OnCharToItem(UINT nChar, CListBox* pListBox, UINT nIndex);
+	afx_msg int OnVKeyToItem(UINT nKey, CListBox* pListBox, UINT nIndex);
+
+// MDI message handler member functions
+	afx_msg void OnMDIActivate(BOOL bActivate,
+		CWnd* pActivateWnd, CWnd* pDeactivateWnd);
+
+// Menu loop notification messages
+	afx_msg void OnEnterMenuLoop(BOOL bIsTrackPopupMenu);
+	afx_msg void OnExitMenuLoop(BOOL bIsTrackPopupMenu);
+
+// Win4 messages
+	afx_msg void OnStyleChanged(int nStyleType, LPSTYLESTRUCT lpStyleStruct);
+	afx_msg void OnStyleChanging(int nStyleType, LPSTYLESTRUCT lpStyleStruct);
+	afx_msg void OnSizing(UINT nSide, LPRECT lpRect);
+	afx_msg void OnMoving(UINT nSide, LPRECT lpRect);
+	afx_msg void OnCaptureChanged(CWnd* pWnd);
+	afx_msg BOOL OnDeviceChange(UINT nEventType, DWORD dwData);
+
+// Overridables and other helpers (for implementation of derived classes)
+protected:
+	// for deriving from a standard control
+	virtual WNDPROC* GetSuperWndProcAddr();
+
+	// for dialog data exchange and validation
+	virtual void DoDataExchange(CDataExchange* pDX);
+
+public:
+	// for modality
+	virtual void BeginModalState();
+	virtual void EndModalState();
+
+	// for translating Windows messages in main message pump
+	virtual BOOL PreTranslateMessage(MSG* pMsg);
+
+#ifndef _AFX_NO_OCC_SUPPORT
+	// for ambient properties exposed to contained OLE controls
+	virtual BOOL OnAmbientProperty(COleControlSite* pSite, DISPID dispid,
+		VARIANT* pvar);
+#endif
+
+protected:
+	// for processing Windows messages
+	virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam);
+	virtual BOOL OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult);
+
+	// for handling default processing
+	LRESULT Default();
+	virtual LRESULT DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam);
+
+	// for custom cleanup after WM_NCDESTROY
+	virtual void PostNcDestroy();
+
+	// for notifications from parent
+	virtual BOOL OnChildNotify(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult);
+		// return TRUE if parent should not process this message
+	BOOL ReflectChildNotify(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult);
+	static BOOL PASCAL ReflectLastMsg(HWND hWndChild, LRESULT* pResult = NULL);
+
+// Implementation
+public:
+	virtual ~CWnd();
+	virtual BOOL CheckAutoCenter();
+#ifdef _DEBUG
+	virtual void AssertValid() const;
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+	// 3D support (these APIs will be obsolete with next version of Windows)
+	BOOL SubclassCtl3d(int nControlType = -1);
+		// see CTL3D.H for list of control types
+	BOOL SubclassDlg3d(DWORD dwMask = 0xFFFF /*CTL3D_ALL*/);
+		// see CTL3D.H for list of mask values
+	static BOOL PASCAL GrayCtlColor(HDC hDC, HWND hWnd, UINT nCtlColor,
+		HBRUSH hbrGray, COLORREF clrText);
+	HBRUSH OnGrayCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor);
+
+	// helper routines for implementation
+	BOOL HandleFloatingSysCommand(UINT nID, LPARAM lParam);
+	BOOL IsTopParentActive() const;
+	void ActivateTopParent();
+	static BOOL PASCAL WalkPreTranslateTree(HWND hWndStop, MSG* pMsg);
+	static CWnd* PASCAL GetDescendantWindow(HWND hWnd, int nID,
+		BOOL bOnlyPerm);
+	static void PASCAL SendMessageToDescendants(HWND hWnd, UINT message,
+		WPARAM wParam, LPARAM lParam, BOOL bDeep, BOOL bOnlyPerm);
+	virtual BOOL IsFrameWnd() const; // IsKindOf(RUNTIME_CLASS(CFrameWnd)))
+	virtual void OnFinalRelease();
+	BOOL PreTranslateInput(LPMSG lpMsg);
+	static BOOL PASCAL ModifyStyle(HWND hWnd, DWORD dwRemove, DWORD dwAdd,
+		UINT nFlags);
+	static BOOL PASCAL ModifyStyleEx(HWND hWnd, DWORD dwRemove, DWORD dwAdd,
+		UINT nFlags);
+	static void PASCAL _FilterToolTipMessage(MSG* pMsg, CWnd* pWnd);
+
+public:
+	HWND m_hWndOwner;   // implementation of SetOwner and GetOwner
+	UINT m_nFlags;      // see WF_ flags above
+
+protected:
+	WNDPROC m_pfnSuper; // for subclassing of controls
+	static const UINT m_nMsgDragList;
+	int m_nModalResult; // for return values from CWnd::RunModalLoop
+
+	COleDropTarget* m_pDropTarget;  // for automatic cleanup of drop target
+	friend class COleDropTarget;
+	friend class CFrameWnd;
+
+	// for creating dialogs and dialog-like windows
+	BOOL CreateDlg(LPCTSTR lpszTemplateName, CWnd* pParentWnd);
+	BOOL CreateDlgIndirect(LPCDLGTEMPLATE lpDialogTemplate, CWnd* pParentWnd);
+	BOOL CreateDlgIndirect(LPCDLGTEMPLATE lpDialogTemplate, CWnd* pParentWnd,
+		HINSTANCE hInst);
+
+#ifndef _AFX_NO_OCC_SUPPORT
+	COleControlContainer* m_pCtrlCont;  // for containing OLE controls
+	COleControlSite* m_pCtrlSite;       // for wrapping an OLE control
+	friend class COccManager;
+	friend class COleControlSite;
+	friend class COleControlContainer;
+	BOOL InitControlContainer();
+	virtual BOOL SetOccDialogInfo(struct _AFX_OCC_DIALOG_INFO* pOccDialogInfo);
+	void AttachControlSite(CHandleMap* pMap);
+public:
+	void AttachControlSite(CWnd* pWndParent);
+#endif
+
+protected:
+	// implementation of message dispatch/hooking
+	friend LRESULT CALLBACK _AfxSendMsgHook(int, WPARAM, LPARAM);
+	friend void AFXAPI _AfxStandardSubclass(HWND);
+	friend LRESULT AFXAPI AfxCallWndProc(CWnd*, HWND, UINT, WPARAM, LPARAM);
+
+	// standard message implementation
+	afx_msg LRESULT OnNTCtlColor(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT OnQuery3dControls(WPARAM, LPARAM);
+	afx_msg LRESULT OnDisplayChange(WPARAM, LPARAM);
+#ifdef _MAC
+	afx_msg LRESULT OnMacintosh(WPARAM wParam, LPARAM lParam);
+#endif
+
+	afx_msg LRESULT OnDragList(WPARAM, LPARAM);
+
+	//{{AFX_MSG(CWnd)
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+
+private:
+	CWnd(HWND hWnd);    // just for special initialization
+};
+
+// helpers for registering your own WNDCLASSes
+LPCTSTR AFXAPI AfxRegisterWndClass(UINT nClassStyle,
+	HCURSOR hCursor = 0, HBRUSH hbrBackground = 0, HICON hIcon = 0);
+
+BOOL AFXAPI AfxRegisterClass(WNDCLASS* lpWndClass);
+
+// Implementation
+LRESULT CALLBACK AfxWndProc(HWND, UINT, WPARAM, LPARAM);
+
+WNDPROC AFXAPI AfxGetAfxWndProc();
+#define AfxWndProc (*AfxGetAfxWndProc())
+
+typedef void (AFX_MSG_CALL CWnd::*AFX_PMSGW)(void);
+	// like 'AFX_PMSG' but for CWnd derived classes only
+
+/////////////////////////////////////////////////////////////////////////////
+// CDialog - a modal or modeless dialog
+
+class CDialog : public CWnd
+{
+	DECLARE_DYNAMIC(CDialog)
+
+	// Modeless construct
+public:
+	CDialog();
+
+	BOOL Create(LPCTSTR lpszTemplateName, CWnd* pParentWnd = NULL);
+	BOOL Create(UINT nIDTemplate, CWnd* pParentWnd = NULL);
+	BOOL CreateIndirect(LPCDLGTEMPLATE lpDialogTemplate, CWnd* pParentWnd = NULL,
+		void* lpDialogInit = NULL);
+	BOOL CreateIndirect(HGLOBAL hDialogTemplate, CWnd* pParentWnd = NULL);
+
+	// Modal construct
+public:
+	CDialog(LPCTSTR lpszTemplateName, CWnd* pParentWnd = NULL);
+	CDialog(UINT nIDTemplate, CWnd* pParentWnd = NULL);
+	BOOL InitModalIndirect(LPCDLGTEMPLATE lpDialogTemplate, CWnd* pParentWnd = NULL,
+		void* lpDialogInit = NULL);
+	BOOL InitModalIndirect(HGLOBAL hDialogTemplate, CWnd* pParentWnd = NULL);
+
+// Attributes
+public:
+	void MapDialogRect(LPRECT lpRect) const;
+	void SetHelpID(UINT nIDR);
+
+// Operations
+public:
+	// modal processing
+	virtual int DoModal();
+
+	// support for passing on tab control - use 'PostMessage' if needed
+	void NextDlgCtrl() const;
+	void PrevDlgCtrl() const;
+	void GotoDlgCtrl(CWnd* pWndCtrl);
+
+	// default button access
+	void SetDefID(UINT nID);
+	DWORD GetDefID() const;
+
+	// termination
+	void EndDialog(int nResult);
+
+// Overridables (special message map entries)
+	virtual BOOL OnInitDialog();
+	virtual void OnSetFont(CFont* pFont);
+protected:
+	virtual void OnOK();
+	virtual void OnCancel();
+
+// Implementation
+public:
+	virtual ~CDialog();
+#ifdef _DEBUG
+	virtual void AssertValid() const;
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+	virtual BOOL PreTranslateMessage(MSG* pMsg);
+	virtual BOOL OnCmdMsg(UINT nID, int nCode, void* pExtra,
+		AFX_CMDHANDLERINFO* pHandlerInfo);
+	virtual BOOL CheckAutoCenter();
+
+protected:
+	UINT m_nIDHelp;                 // Help ID (0 for none, see HID_BASE_RESOURCE)
+
+	// parameters for 'DoModal'
+	LPCTSTR m_lpszTemplateName;     // name or MAKEINTRESOURCE
+	HGLOBAL m_hDialogTemplate;      // indirect (m_lpDialogTemplate == NULL)
+	LPCDLGTEMPLATE m_lpDialogTemplate;  // indirect if (m_lpszTemplateName == NULL)
+	void* m_lpDialogInit;           // DLGINIT resource data
+	CWnd* m_pParentWnd;             // parent/owner window
+	HWND m_hWndTop;                 // top level parent window (may be disabled)
+
+#ifndef _AFX_NO_OCC_SUPPORT
+	_AFX_OCC_DIALOG_INFO* m_pOccDialogInfo;
+	virtual BOOL SetOccDialogInfo(_AFX_OCC_DIALOG_INFO* pOccDialogInfo);
+#endif
+	virtual void PreInitDialog();
+
+	// implementation helpers
+	HWND PreModal();
+	void PostModal();
+
+	BOOL CreateIndirect(LPCDLGTEMPLATE lpDialogTemplate, CWnd* pParentWnd,
+		void* lpDialogInit, HINSTANCE hInst);
+	BOOL CreateIndirect(HGLOBAL hDialogTemplate, CWnd* pParentWnd,
+		HINSTANCE hInst);
+
+protected:
+	//{{AFX_MSG(CDialog)
+	afx_msg HBRUSH OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor);
+	afx_msg LRESULT OnCommandHelp(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT OnHelpHitTest(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT HandleInitDialog(WPARAM, LPARAM);
+	afx_msg LRESULT HandleSetFont(WPARAM, LPARAM);
+	//}}AFX_MSG
+#ifdef _MAC
+	afx_msg void OnSysColorChange();
+#endif
+	DECLARE_MESSAGE_MAP()
+};
+
+// all CModalDialog functionality is now in CDialog
+#define CModalDialog    CDialog
+
+/////////////////////////////////////////////////////////////////////////////
+// Standard Windows controls
+
+class CStatic : public CWnd
+{
+	DECLARE_DYNAMIC(CStatic)
+
+// Constructors
+public:
+	CStatic();
+	BOOL Create(LPCTSTR lpszText, DWORD dwStyle,
+				const RECT& rect, CWnd* pParentWnd, UINT nID = 0xffff);
+
+// Operations
+	HICON SetIcon(HICON hIcon);
+	HICON GetIcon() const;
+
+#if (WINVER >= 0x400)
+	HENHMETAFILE SetEnhMetaFile(HENHMETAFILE hMetaFile);
+	HENHMETAFILE GetEnhMetaFile() const;
+	HBITMAP SetBitmap(HBITMAP hBitmap);
+	HBITMAP GetBitmap() const;
+	HCURSOR SetCursor(HCURSOR hCursor);
+	HCURSOR GetCursor();
+#endif
+
+// Implementation
+public:
+	virtual ~CStatic();
+};
+
+class CButton : public CWnd
+{
+	DECLARE_DYNAMIC(CButton)
+
+// Constructors
+public:
+	CButton();
+	BOOL Create(LPCTSTR lpszCaption, DWORD dwStyle,
+				const RECT& rect, CWnd* pParentWnd, UINT nID);
+
+// Attributes
+	UINT GetState() const;
+	void SetState(BOOL bHighlight);
+	int GetCheck() const;
+	void SetCheck(int nCheck);
+	UINT GetButtonStyle() const;
+	void SetButtonStyle(UINT nStyle, BOOL bRedraw = TRUE);
+
+#if (WINVER >= 0x400)
+	HICON SetIcon(HICON hIcon);
+	HICON GetIcon() const;
+	HBITMAP SetBitmap(HBITMAP hBitmap);
+	HBITMAP GetBitmap() const;
+	HCURSOR SetCursor(HCURSOR hCursor);
+	HCURSOR GetCursor();
+#endif
+
+// Overridables (for owner draw only)
+	virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct);
+
+// Implementation
+public:
+	virtual ~CButton();
+protected:
+	virtual BOOL OnChildNotify(UINT, WPARAM, LPARAM, LRESULT*);
+};
+
+class CListBox : public CWnd
+{
+	DECLARE_DYNAMIC(CListBox)
+
+// Constructors
+public:
+	CListBox();
+	BOOL Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID);
+
+// Attributes
+
+	// for entire listbox
+	int GetCount() const;
+	int GetHorizontalExtent() const;
+	void SetHorizontalExtent(int cxExtent);
+	int GetTopIndex() const;
+	int SetTopIndex(int nIndex);
+	LCID GetLocale() const;
+	LCID SetLocale(LCID nNewLocale);
+#if (WINVER >= 0x400)
+	int InitStorage(int nItems, UINT nBytes);
+	UINT ItemFromPoint(CPoint pt, BOOL& bOutside) const;
+#endif
+	// for single-selection listboxes
+	int GetCurSel() const;
+	int SetCurSel(int nSelect);
+
+	// for multiple-selection listboxes
+	int GetSel(int nIndex) const;           // also works for single-selection
+	int SetSel(int nIndex, BOOL bSelect = TRUE);
+	int GetSelCount() const;
+	int GetSelItems(int nMaxItems, LPINT rgIndex) const;
+	void SetAnchorIndex(int nIndex);
+	int GetAnchorIndex() const;
+
+	// for listbox items
+	DWORD GetItemData(int nIndex) const;
+	int SetItemData(int nIndex, DWORD dwItemData);
+	void* GetItemDataPtr(int nIndex) const;
+	int SetItemDataPtr(int nIndex, void* pData);
+	int GetItemRect(int nIndex, LPRECT lpRect) const;
+	int GetText(int nIndex, LPTSTR lpszBuffer) const;
+	void GetText(int nIndex, CString& rString) const;
+	int GetTextLen(int nIndex) const;
+
+	// Settable only attributes
+	void SetColumnWidth(int cxWidth);
+	BOOL SetTabStops(int nTabStops, LPINT rgTabStops);
+	void SetTabStops();
+	BOOL SetTabStops(const int& cxEachStop);    // takes an 'int'
+
+	int SetItemHeight(int nIndex, UINT cyItemHeight);
+	int GetItemHeight(int nIndex) const;
+	int FindStringExact(int nIndexStart, LPCTSTR lpszFind) const;
+	int GetCaretIndex() const;
+	int SetCaretIndex(int nIndex, BOOL bScroll = TRUE);
+
+// Operations
+	// manipulating listbox items
+	int AddString(LPCTSTR lpszItem);
+	int DeleteString(UINT nIndex);
+	int InsertString(int nIndex, LPCTSTR lpszItem);
+	void ResetContent();
+	int Dir(UINT attr, LPCTSTR lpszWildCard);
+
+	// selection helpers
+	int FindString(int nStartAfter, LPCTSTR lpszItem) const;
+	int SelectString(int nStartAfter, LPCTSTR lpszItem);
+	int SelItemRange(BOOL bSelect, int nFirstItem, int nLastItem);
+
+// Overridables (must override draw, measure and compare for owner draw)
+	virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct);
+	virtual void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct);
+	virtual int CompareItem(LPCOMPAREITEMSTRUCT lpCompareItemStruct);
+	virtual void DeleteItem(LPDELETEITEMSTRUCT lpDeleteItemStruct);
+	virtual int VKeyToItem(UINT nKey, UINT nIndex);
+	virtual int CharToItem(UINT nKey, UINT nIndex);
+
+// Implementation
+public:
+	virtual ~CListBox();
+protected:
+	virtual BOOL OnChildNotify(UINT, WPARAM, LPARAM, LRESULT*);
+};
+
+class CCheckListBox : public CListBox
+{
+	DECLARE_DYNAMIC(CCheckListBox)
+
+// Constructors
+public:
+	CCheckListBox();
+	BOOL Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID);
+
+// Attributes
+	void SetCheckStyle(UINT nStyle);
+	UINT GetCheckStyle();
+	void SetCheck(int nIndex, int nCheck);
+	int GetCheck(int nIndex);
+	void Enable(int nIndex, BOOL bEnabled = TRUE);
+	BOOL IsEnabled(int nIndex);
+
+	virtual CRect OnGetCheckPosition(CRect rectItem, CRect rectCheckBox);
+
+// Overridables (must override draw, measure and compare for owner draw)
+	virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct);
+	virtual void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct);
+
+// Implementation
+protected:
+	void PreDrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct);
+	void PreMeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct);
+	int PreCompareItem(LPCOMPAREITEMSTRUCT lpCompareItemStruct);
+	void PreDeleteItem(LPDELETEITEMSTRUCT lpDeleteItemStruct);
+
+	virtual BOOL OnChildNotify(UINT, WPARAM, LPARAM, LRESULT*);
+
+#ifdef _DEBUG
+	virtual void PreSubclassWindow();
+#endif
+
+	int CalcMinimumItemHeight();
+	void InvalidateCheck(int nIndex);
+	void InvalidateItem(int nIndex);
+
+	int m_cyText;
+	UINT m_nStyle;
+
+	// Message map functions
+protected:
+	//{{AFX_MSG(CCheckListBox)
+	afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
+	afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
+	afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
+	afx_msg void OnLButtonDblClk(UINT nFlags, CPoint point);
+	afx_msg LRESULT OnSetFont(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT OnLBAddString(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT OnLBFindString(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT OnLBFindStringExact(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT OnLBGetItemData(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT OnLBGetText(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT OnLBInsertString(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT OnLBSelectString(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT OnLBSetItemData(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT OnLBSetItemHeight(WPARAM wParam, LPARAM lParam);
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+};
+
+class CComboBox : public CWnd
+{
+	DECLARE_DYNAMIC(CComboBox)
+
+// Constructors
+public:
+	CComboBox();
+	BOOL Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID);
+
+// Attributes
+	// for entire combo box
+	int GetCount() const;
+	int GetCurSel() const;
+	int SetCurSel(int nSelect);
+	LCID GetLocale() const;
+	LCID SetLocale(LCID nNewLocale);
+// Win4
+	int GetTopIndex() const;
+	int SetTopIndex(int nIndex);
+	int InitStorage(int nItems, UINT nBytes);
+	void SetHorizontalExtent(UINT nExtent);
+	UINT GetHorizontalExtent() const;
+	int SetDroppedWidth(UINT nWidth);
+	int GetDroppedWidth() const;
+
+	// for edit control
+	DWORD GetEditSel() const;
+	BOOL LimitText(int nMaxChars);
+	BOOL SetEditSel(int nStartChar, int nEndChar);
+
+	// for combobox item
+	DWORD GetItemData(int nIndex) const;
+	int SetItemData(int nIndex, DWORD dwItemData);
+	void* GetItemDataPtr(int nIndex) const;
+	int SetItemDataPtr(int nIndex, void* pData);
+	int GetLBText(int nIndex, LPTSTR lpszText) const;
+	void GetLBText(int nIndex, CString& rString) const;
+	int GetLBTextLen(int nIndex) const;
+
+	int SetItemHeight(int nIndex, UINT cyItemHeight);
+	int GetItemHeight(int nIndex) const;
+	int FindStringExact(int nIndexStart, LPCTSTR lpszFind) const;
+	int SetExtendedUI(BOOL bExtended = TRUE);
+	BOOL GetExtendedUI() const;
+	void GetDroppedControlRect(LPRECT lprect) const;
+	BOOL GetDroppedState() const;
+
+// Operations
+	// for drop-down combo boxes
+	void ShowDropDown(BOOL bShowIt = TRUE);
+
+	// manipulating listbox items
+	int AddString(LPCTSTR lpszString);
+	int DeleteString(UINT nIndex);
+	int InsertString(int nIndex, LPCTSTR lpszString);
+	void ResetContent();
+	int Dir(UINT attr, LPCTSTR lpszWildCard);
+
+	// selection helpers
+	int FindString(int nStartAfter, LPCTSTR lpszString) const;
+	int SelectString(int nStartAfter, LPCTSTR lpszString);
+
+	// Clipboard operations
+	void Clear();
+	void Copy();
+	void Cut();
+	void Paste();
+
+// Overridables (must override draw, measure and compare for owner draw)
+	virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct);
+	virtual void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct);
+	virtual int CompareItem(LPCOMPAREITEMSTRUCT lpCompareItemStruct);
+	virtual void DeleteItem(LPDELETEITEMSTRUCT lpDeleteItemStruct);
+
+// Implementation
+public:
+	virtual ~CComboBox();
+protected:
+	virtual BOOL OnChildNotify(UINT, WPARAM, LPARAM, LRESULT*);
+};
+
+class CEdit : public CWnd
+{
+	DECLARE_DYNAMIC(CEdit)
+
+// Constructors
+public:
+	CEdit();
+	BOOL Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID);
+
+// Attributes
+	BOOL CanUndo() const;
+	int GetLineCount() const;
+	BOOL GetModify() const;
+	void SetModify(BOOL bModified = TRUE);
+	void GetRect(LPRECT lpRect) const;
+	DWORD GetSel() const;
+	void GetSel(int& nStartChar, int& nEndChar) const;
+	HLOCAL GetHandle() const;
+	void SetHandle(HLOCAL hBuffer);
+#if (WINVER >= 0x400)
+	void SetMargins(UINT nLeft, UINT nRight);
+	DWORD GetMargins() const;
+	void SetLimitText(UINT nMax);
+	UINT GetLimitText() const;
+	CPoint PosFromChar(UINT nChar) const;
+	int CharFromPos(CPoint pt) const;
+#endif
+
+	// NOTE: first word in lpszBuffer must contain the size of the buffer!
+	int GetLine(int nIndex, LPTSTR lpszBuffer) const;
+	int GetLine(int nIndex, LPTSTR lpszBuffer, int nMaxLength) const;
+
+// Operations
+	void EmptyUndoBuffer();
+	BOOL FmtLines(BOOL bAddEOL);
+
+	void LimitText(int nChars = 0);
+	int LineFromChar(int nIndex = -1) const;
+	int LineIndex(int nLine = -1) const;
+	int LineLength(int nLine = -1) const;
+	void LineScroll(int nLines, int nChars = 0);
+	void ReplaceSel(LPCTSTR lpszNewText);
+	void SetPasswordChar(TCHAR ch);
+	void SetRect(LPCRECT lpRect);
+	void SetRectNP(LPCRECT lpRect);
+	void SetSel(DWORD dwSelection, BOOL bNoScroll = FALSE);
+	void SetSel(int nStartChar, int nEndChar, BOOL bNoScroll = FALSE);
+#ifndef _MAC
+	BOOL SetTabStops(int nTabStops, LPINT rgTabStops);
+	void SetTabStops();
+	BOOL SetTabStops(const int& cxEachStop);    // takes an 'int'
+#endif
+
+	// Clipboard operations
+	BOOL Undo();
+	void Clear();
+	void Copy();
+	void Cut();
+	void Paste();
+
+	BOOL SetReadOnly(BOOL bReadOnly = TRUE);
+	int GetFirstVisibleLine() const;
+	TCHAR GetPasswordChar() const;
+
+// Implementation
+public:
+	virtual ~CEdit();
+};
+
+class CScrollBar : public CWnd
+{
+	DECLARE_DYNAMIC(CScrollBar)
+
+// Constructors
+public:
+	CScrollBar();
+	BOOL Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID);
+
+// Attributes
+	int GetScrollPos() const;
+	int SetScrollPos(int nPos, BOOL bRedraw = TRUE);
+	void GetScrollRange(LPINT lpMinPos, LPINT lpMaxPos) const;
+	void SetScrollRange(int nMinPos, int nMaxPos, BOOL bRedraw = TRUE);
+	void ShowScrollBar(BOOL bShow = TRUE);
+
+	BOOL EnableScrollBar(UINT nArrowFlags = ESB_ENABLE_BOTH);
+
+	BOOL SetScrollInfo(LPSCROLLINFO lpScrollInfo, BOOL bRedraw = TRUE);
+	BOOL GetScrollInfo(LPSCROLLINFO lpScrollInfo, UINT nMask = SIF_ALL);
+	int GetScrollLimit();
+
+// Implementation
+public:
+	virtual ~CScrollBar();
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// CFrameWnd - base class for SDI and other frame windows
+
+// Frame window styles
+#define FWS_ADDTOTITLE  0x00008000L // modify title based on content
+#define FWS_PREFIXTITLE 0x00004000L // show document name before app name
+#define FWS_SNAPTOBARS  0x00002000L // snap size to size of contained bars
+
+struct CPrintPreviewState;  // forward reference (see afxext.h)
+class CControlBar;          // forward reference (see afxext.h)
+
+class CDockBar;             // forward reference (see afxpriv.h)
+class CMiniDockFrameWnd;    // forward reference (see afxpriv.h)
+class CDockState;           // forward reference (see afxpriv.h)
+
+class COleFrameHook;        // forward reference (see ..\src\oleimpl.h)
+
+class CFrameWnd : public CWnd
+{
+	DECLARE_DYNCREATE(CFrameWnd)
+
+// Constructors
+public:
+	static AFX_DATA const CRect rectDefault;
+	CFrameWnd();
+
+	BOOL LoadAccelTable(LPCTSTR lpszResourceName);
+	BOOL Create(LPCTSTR lpszClassName,
+				LPCTSTR lpszWindowName,
+				DWORD dwStyle = WS_OVERLAPPEDWINDOW,
+				const RECT& rect = rectDefault,
+				CWnd* pParentWnd = NULL,        // != NULL for popups
+				LPCTSTR lpszMenuName = NULL,
+				DWORD dwExStyle = 0,
+				CCreateContext* pContext = NULL);
+
+	// dynamic creation - load frame and associated resources
+	virtual BOOL LoadFrame(UINT nIDResource,
+				DWORD dwDefaultStyle = WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE,
+				CWnd* pParentWnd = NULL,
+				CCreateContext* pContext = NULL);
+
+	// special helper for view creation
+	CWnd* CreateView(CCreateContext* pContext, UINT nID = AFX_IDW_PANE_FIRST);
+
+// Attributes
+	virtual CDocument* GetActiveDocument();
+
+	// Active child view maintenance
+	CView* GetActiveView() const;           // active view or NULL
+	void SetActiveView(CView* pViewNew, BOOL bNotify = TRUE);
+		// active view or NULL, bNotify == FALSE if focus should not be set
+
+	// Active frame (for frames within frames -- MDI)
+	virtual CFrameWnd* GetActiveFrame();
+
+	// For customizing the default messages on the status bar
+	virtual void GetMessageString(UINT nID, CString& rMessage) const;
+
+	BOOL m_bAutoMenuEnable;
+		// TRUE => menu items without handlers will be disabled
+
+	BOOL IsTracking() const;
+
+// Operations
+	virtual void RecalcLayout(BOOL bNotify = TRUE);
+	virtual void ActivateFrame(int nCmdShow = -1);
+	void InitialUpdateFrame(CDocument* pDoc, BOOL bMakeVisible);
+
+	// to set text of standard status bar
+	void SetMessageText(LPCTSTR lpszText);
+	void SetMessageText(UINT nID);
+
+	// control bar docking
+	void EnableDocking(DWORD dwDockStyle);
+	void DockControlBar(CControlBar* pBar, UINT nDockBarID = 0,
+		LPCRECT lpRect = NULL);
+	void FloatControlBar(CControlBar* pBar, CPoint point,
+		DWORD dwStyle = CBRS_ALIGN_TOP);
+	CControlBar* GetControlBar(UINT nID);
+
+	// frame window based modality
+	virtual void BeginModalState();
+	virtual void EndModalState();
+	BOOL InModalState() const;
+	void ShowOwnedWindows(BOOL bShow);
+
+	// saving and loading control bar state
+	void LoadBarState(LPCTSTR lpszProfileName);
+	void SaveBarState(LPCTSTR lpszProfileName) const;
+	void ShowControlBar(CControlBar* pBar, BOOL bShow, BOOL bDelay);
+	void SetDockState(const CDockState& state);
+	void GetDockState(CDockState& state) const;
+
+// Overridables
+	virtual void OnSetPreviewMode(BOOL bPreview, CPrintPreviewState* pState);
+	virtual CWnd* GetMessageBar();
+
+	// border space negotiation
+	enum BorderCmd
+		{ borderGet = 1, borderRequest = 2, borderSet = 3 };
+	virtual BOOL NegotiateBorderSpace(UINT nBorderCmd, LPRECT lpRectBorder);
+
+protected:
+	virtual BOOL OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext* pContext);
+
+// Command Handlers
+public:
+	afx_msg void OnContextHelp();   // for Shift+F1 help
+	afx_msg void OnUpdateControlBarMenu(CCmdUI* pCmdUI);
+	afx_msg BOOL OnBarCheck(UINT nID);
+
+// Implementation
+public:
+	virtual ~CFrameWnd();
+	int m_nWindow;  // general purpose window number - display as ":n"
+					// -1 => unknown, 0 => only window viewing document
+					// 1 => first of many windows viewing document, 2=> second
+
+	HMENU m_hMenuDefault;       // default menu resource for this frame
+	HACCEL m_hAccelTable;       // accelerator table
+	DWORD m_dwPromptContext;    // current help prompt context for message box
+	BOOL m_bHelpMode;           // if TRUE, then Shift+F1 help mode is active
+	CFrameWnd* m_pNextFrameWnd; // next CFrameWnd in app global list
+	CRect m_rectBorder;         // for OLE border space negotiation
+	COleFrameHook* m_pNotifyHook;
+
+	CPtrList m_listControlBars; // array of all control bars that have this
+								// window as their dock site
+	int m_nShowDelay;           // SW_ command for delay show/hide
+
+	CMiniDockFrameWnd* CreateFloatingFrame(DWORD dwStyle);
+	DWORD CanDock(CRect rect, DWORD dwDockStyle,
+		CDockBar** ppDockBar = NULL); // called by CDockContext
+	void AddControlBar(CControlBar *pBar);
+	void RemoveControlBar(CControlBar *pBar);
+	void DockControlBar(CControlBar* pBar, CDockBar* pDockBar,
+		LPCRECT lpRect = NULL);
+	void ReDockControlBar(CControlBar* pBar, CDockBar* pDockBar,
+		LPCRECT lpRect = NULL);
+	void NotifyFloatingWindows(DWORD dwFlags);
+	void DestroyDockBars();
+
+protected:
+	UINT m_nIDHelp;             // Help ID (0 for none, see HID_BASE_RESOURCE)
+	UINT m_nIDTracking;         // tracking command ID or string IDS
+	UINT m_nIDLastMessage;      // last displayed message string IDS
+	CView* m_pViewActive;       // current active view
+	BOOL (CALLBACK* m_lpfnCloseProc)(CFrameWnd* pFrameWnd);
+	UINT m_cModalStack;         // BeginModalState depth
+	HWND* m_phWndDisable;       // windows disabled because of BeginModalState
+	HMENU m_hMenuAlt;           // menu to update to (NULL means default)
+	CString m_strTitle;         // default title (original)
+	BOOL m_bInRecalcLayout;     // avoid recursion in RecalcLayout
+	CRuntimeClass* m_pFloatingFrameClass;
+	static const DWORD dwDockBarMap[4][2];
+
+public:
+#ifdef _DEBUG
+	virtual void AssertValid() const;
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+	virtual BOOL IsFrameWnd() const;
+	virtual BOOL OnCmdMsg(UINT nID, int nCode, void* pExtra,
+		AFX_CMDHANDLERINFO* pHandlerInfo);
+	virtual void OnUpdateFrameTitle(BOOL bAddToTitle);
+	virtual void OnUpdateFrameMenu(HMENU hMenuAlt);
+	virtual HACCEL GetDefaultAccelerator();
+	virtual BOOL PreTranslateMessage(MSG* pMsg);
+
+	// idle update of frame user interface
+	enum IdleFlags
+		{ idleMenu = 1, idleTitle = 2, idleNotify = 4, idleLayout = 8 };
+	UINT m_nIdleFlags;          // set of bit flags for idle processing
+	virtual void DelayUpdateFrameMenu(HMENU hMenuAlt);
+	void DelayUpdateFrameTitle();
+	void DelayRecalcLayout(BOOL bNotify = TRUE);
+
+	// for Shift+F1 help support
+	BOOL CanEnterHelpMode();
+	virtual void ExitHelpMode();
+
+protected:
+	// implementation helpers
+	LPCTSTR GetIconWndClass(DWORD dwDefaultStyle, UINT nIDResource);
+	void UpdateFrameTitleForDocument(LPCTSTR lpszDocName);
+	virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
+	virtual BOOL OnCommand(WPARAM wParam, LPARAM lParam);
+	virtual void PostNcDestroy();   // default to delete this.
+	int OnCreateHelper(LPCREATESTRUCT lpcs, CCreateContext* pContext);
+	void BringToTop(int nCmdShow);
+		// bring window to top for SW_ commands which affect z-order
+
+	// implementation helpers for Shift+F1 help mode
+	BOOL ProcessHelpMsg(MSG& msg, DWORD* pContext);
+	HWND SetHelpCapture(POINT point, BOOL* pbDescendant);
+
+	// CFrameWnd list management
+	void AddFrameWnd();
+	void RemoveFrameWnd();
+
+	friend class CWnd;  // for access to m_bModalDisable
+
+	//{{AFX_MSG(CFrameWnd)
+	// Windows messages
+	afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
+	afx_msg void OnDestroy();
+	afx_msg void OnClose();
+	afx_msg void OnInitMenuPopup(CMenu*, UINT, BOOL);
+	afx_msg void OnMenuSelect(UINT nItemID, UINT nFlags, HMENU hSysMenu);
+	afx_msg LRESULT OnPopMessageString(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT OnSetMessageString(WPARAM wParam, LPARAM lParam);
+	afx_msg void OnIdleUpdateCmdUI();
+	afx_msg void OnEnterIdle(UINT nWhy, CWnd* pWho);
+	afx_msg void OnSetFocus(CWnd* pOldWnd);
+	afx_msg void OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
+	afx_msg void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
+	afx_msg void OnSize(UINT nType, int cx, int cy);
+	afx_msg BOOL OnEraseBkgnd(CDC* pDC);
+	afx_msg void OnActivate(UINT nState, CWnd* pWndOther, BOOL bMinimized);
+	afx_msg BOOL OnNcActivate(BOOL bActive);
+	afx_msg void OnSysCommand(UINT nID, LONG lParam);
+	afx_msg BOOL OnQueryEndSession();
+	afx_msg void OnEndSession(BOOL bEnding);
+	afx_msg void OnDropFiles(HDROP hDropInfo);
+	afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
+	afx_msg LRESULT OnCommandHelp(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT OnHelpHitTest(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT OnActivateTopLevel(WPARAM wParam, LPARAM lParam);
+	afx_msg void OnEnable(BOOL bEnable);
+	afx_msg void OnPaletteChanged(CWnd* pFocusWnd);
+	afx_msg BOOL OnQueryNewPalette();
+	// standard commands
+	afx_msg BOOL OnToolTipText(UINT nID, NMHDR* pNMHDR, LRESULT* pResult);
+	afx_msg void OnUpdateKeyIndicator(CCmdUI* pCmdUI);
+	afx_msg void OnHelp();
+	afx_msg void OnUpdateContextHelp(CCmdUI* pCmdUI);
+	//}}AFX_MSG
+protected:
+#ifndef _MAC
+	afx_msg LRESULT OnDDEInitiate(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT OnDDEExecute(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT OnDDETerminate(WPARAM wParam, LPARAM lParam);
+#endif
+#ifdef _MAC
+	afx_msg void OnActivateApp(BOOL bActive, HTASK hTask);
+	afx_msg void OnPaint();
+#endif
+	DECLARE_MESSAGE_MAP()
+
+	friend class CWinApp;
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// MDI Support
+
+class CMDIFrameWnd : public CFrameWnd
+{
+	DECLARE_DYNCREATE(CMDIFrameWnd)
+
+public:
+// Constructors
+	CMDIFrameWnd();
+
+// Operations
+	void MDIActivate(CWnd* pWndActivate);
+	CMDIChildWnd* MDIGetActive(BOOL* pbMaximized = NULL) const;
+	void MDIIconArrange();
+	void MDIMaximize(CWnd* pWnd);
+	void MDINext();
+	void MDIRestore(CWnd* pWnd);
+	CMenu* MDISetMenu(CMenu* pFrameMenu, CMenu* pWindowMenu);
+	void MDITile();
+	void MDICascade();
+	void MDITile(int nType);
+	void MDICascade(int nType);
+
+// Overridables
+	// MFC 1.0 backward compatible CreateClient hook (called by OnCreateClient)
+	virtual BOOL CreateClient(LPCREATESTRUCT lpCreateStruct, CMenu* pWindowMenu);
+	// customize if using an 'Window' menu with non-standard IDs
+	virtual HMENU GetWindowMenuPopup(HMENU hMenuBar);
+
+// Implementation
+public:
+	HWND m_hWndMDIClient;       // MDI Client window handle
+
+#ifdef _DEBUG
+	virtual void AssertValid() const;
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+	virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
+	virtual BOOL LoadFrame(UINT nIDResource,
+				DWORD dwDefaultStyle = WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE,
+				CWnd* pParentWnd = NULL,
+				CCreateContext* pContext = NULL);
+	virtual BOOL OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext* pContext);
+	virtual BOOL PreTranslateMessage(MSG* pMsg);
+	virtual void OnUpdateFrameTitle(BOOL bAddToTitle);
+	virtual BOOL OnCmdMsg(UINT nID, int nCode, void* pExtra,
+		AFX_CMDHANDLERINFO* pHandlerInfo);
+	virtual void OnUpdateFrameMenu(HMENU hMenuAlt);
+	virtual void DelayUpdateFrameMenu(HMENU hMenuAlt);
+	virtual CFrameWnd* GetActiveFrame();
+
+protected:
+	virtual LRESULT DefWindowProc(UINT nMsg, WPARAM wParam, LPARAM lParam);
+	virtual BOOL OnCommand(WPARAM wParam, LPARAM lParam);
+
+	//{{AFX_MSG(CMDIFrameWnd)
+	afx_msg void OnDestroy();
+	afx_msg void OnSize(UINT nType, int cx, int cy);
+	afx_msg void OnUpdateMDIWindowCmd(CCmdUI* pCmdUI);
+	afx_msg BOOL OnMDIWindowCmd(UINT nID);
+	afx_msg void OnWindowNew();
+	afx_msg LRESULT OnCommandHelp(WPARAM wParam, LPARAM lParam);
+	afx_msg void OnIdleUpdateCmdUI();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+};
+
+class CMDIChildWnd : public CFrameWnd
+{
+	DECLARE_DYNCREATE(CMDIChildWnd)
+
+// Constructors
+public:
+	CMDIChildWnd();
+
+	virtual BOOL Create(LPCTSTR lpszClassName,
+				LPCTSTR lpszWindowName,
+				DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_OVERLAPPEDWINDOW,
+				const RECT& rect = rectDefault,
+				CMDIFrameWnd* pParentWnd = NULL,
+				CCreateContext* pContext = NULL);
+
+// Attributes
+	CMDIFrameWnd* GetMDIFrame();
+
+// Operations
+	void MDIDestroy();
+	void MDIActivate();
+	void MDIMaximize();
+	void MDIRestore();
+
+// Implementation
+protected:
+	HMENU m_hMenuShared;        // menu when we are active
+
+public:
+#ifdef _DEBUG
+	virtual void AssertValid() const;
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+
+	virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
+	virtual BOOL LoadFrame(UINT nIDResource, DWORD dwDefaultStyle,
+					CWnd* pParentWnd, CCreateContext* pContext = NULL);
+		// 'pParentWnd' parameter is required for MDI Child
+	virtual BOOL DestroyWindow();
+	virtual BOOL PreTranslateMessage(MSG* pMsg);
+	virtual void ActivateFrame(int nCmdShow = -1);
+	virtual void OnUpdateFrameMenu(BOOL bActive, CWnd* pActivateWnd,
+		HMENU hMenuAlt);
+
+	BOOL m_bPseudoInactive;     // TRUE if window is MDI active according to
+								//  windows, but not according to MFC...
+
+protected:
+	virtual CWnd* GetMessageBar();
+	virtual void OnUpdateFrameTitle(BOOL bAddToTitle);
+	virtual LRESULT DefWindowProc(UINT nMsg, WPARAM wParam, LPARAM lParam);
+	BOOL UpdateClientEdge(LPRECT lpRect = NULL);
+
+	//{{AFX_MSG(CMDIChildWnd)
+	afx_msg void OnMDIActivate(BOOL bActivate, CWnd*, CWnd*);
+	afx_msg int OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message);
+	afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
+	afx_msg BOOL OnNcCreate(LPCREATESTRUCT lpCreateStruct);
+	afx_msg void OnSize(UINT nType, int cx, int cy);
+	afx_msg void OnWindowPosChanging(LPWINDOWPOS lpWndPos);
+	afx_msg BOOL OnNcActivate(BOOL bActive);
+	afx_msg void OnDestroy();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// CMiniFrameWnd
+
+// MiniFrame window styles
+#define MFS_SYNCACTIVE      0x00000100L // syncronize activation w/ parent
+#define MFS_4THICKFRAME     0x00000200L // thick frame all around (no tiles)
+#define MFS_THICKFRAME      0x00000400L // use instead of WS_THICKFRAME
+#define MFS_MOVEFRAME       0x00000800L // no sizing, just moving
+#define MFS_BLOCKSYSMENU    0x00001000L // block hit testing on system menu
+
+class CMiniFrameWnd : public CFrameWnd
+{
+	DECLARE_DYNCREATE(CMiniFrameWnd)
+
+// Constructors
+public:
+	CMiniFrameWnd();
+	BOOL Create(LPCTSTR lpClassName, LPCTSTR lpWindowName,
+		DWORD dwStyle, const RECT& rect,
+		CWnd* pParentWnd = NULL, UINT nID = 0);
+	BOOL CreateEx(DWORD dwExStyle, LPCTSTR lpClassName, LPCTSTR lpWindowName,
+		DWORD dwStyle, const RECT& rect,
+		CWnd* pParentWnd = NULL, UINT nID = 0);
+
+// Implementation
+public:
+	~CMiniFrameWnd();
+
+	static void AFX_CDECL Initialize();
+
+	//{{AFX_MSG(CMiniFrameWnd)
+	afx_msg BOOL OnNcActivate(BOOL bActive);
+	afx_msg void OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS* lpParams);
+	afx_msg UINT OnNcHitTest(CPoint point);
+	afx_msg void OnNcPaint();
+	afx_msg void OnNcLButtonDown(UINT nHitTest, CPoint pt );
+	afx_msg void OnLButtonUp(UINT nFlags, CPoint pt );
+	afx_msg void OnMouseMove(UINT nFlags, CPoint pt );
+	afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
+	afx_msg void OnGetMinMaxInfo(MINMAXINFO* pMMI);
+	afx_msg LRESULT OnGetText(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT OnGetTextLength(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT OnSetText(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT OnFloatStatus(WPARAM wParam, LPARAM lParam);
+	afx_msg LRESULT OnQueryCenterWnd(WPARAM wParam, LPARAM lParam);
+	afx_msg BOOL OnNcCreate(LPCREATESTRUCT lpcs);
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+
+public:
+	virtual void CalcWindowRect(LPRECT lpClientRect,
+		UINT nAdjustType = adjustBorder);
+
+	static void AFX_CDECL CalcBorders(LPRECT lpClientRect,
+		DWORD dwStyle = WS_THICKFRAME | WS_CAPTION, DWORD dwExStyle = 0);
+
+protected:
+	virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
+
+protected:
+	BOOL m_bSysTracking;
+	BOOL m_bInSys;
+	BOOL m_bActive;
+	CString m_strCaption;
+
+	void InvertSysMenu();
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// class CView is the client area UI for a document
+
+class CPrintDialog;     // forward reference (see afxdlgs.h)
+class CPreviewView;     // forward reference (see afxpriv.h)
+class CSplitterWnd;     // forward reference (see afxext.h)
+class COleServerDoc;    // forward reference (see afxole.h)
+
+typedef DWORD DROPEFFECT;
+class COleDataObject;   // forward reference (see afxole.h)
+
+class CView : public CWnd
+{
+	DECLARE_DYNAMIC(CView)
+
+// Constructors
+protected:
+	CView();
+
+// Attributes
+public:
+	CDocument* GetDocument() const;
+
+// Operations
+public:
+	// for standard printing setup (override OnPreparePrinting)
+	BOOL DoPreparePrinting(CPrintInfo* pInfo);
+
+// Overridables
+public:
+	virtual BOOL IsSelected(const CObject* pDocItem) const; // support for OLE
+
+	// OLE scrolling support (used for drag/drop as well)
+	virtual BOOL OnScroll(UINT nScrollCode, UINT nPos, BOOL bDoScroll = TRUE);
+	virtual BOOL OnScrollBy(CSize sizeScroll, BOOL bDoScroll = TRUE);
+
+	// OLE drag/drop support
+	virtual DROPEFFECT OnDragEnter(COleDataObject* pDataObject,
+		DWORD dwKeyState, CPoint point);
+	virtual DROPEFFECT OnDragOver(COleDataObject* pDataObject,
+		DWORD dwKeyState, CPoint point);
+	virtual void OnDragLeave();
+	virtual BOOL OnDrop(COleDataObject* pDataObject,
+		DROPEFFECT dropEffect, CPoint point);
+	virtual DROPEFFECT OnDropEx(COleDataObject* pDataObject,
+		DROPEFFECT dropDefault, DROPEFFECT dropList, CPoint point);
+	virtual DROPEFFECT OnDragScroll(DWORD dwKeyState, CPoint point);
+
+	virtual void OnPrepareDC(CDC* pDC, CPrintInfo* pInfo = NULL);
+
+	virtual void OnInitialUpdate(); // called first time after construct
+
+protected:
+	// Activation
+	virtual void OnActivateView(BOOL bActivate, CView* pActivateView,
+					CView* pDeactiveView);
+	virtual void OnActivateFrame(UINT nState, CFrameWnd* pFrameWnd);
+
+	// General drawing/updating
+	virtual void OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint);
+	virtual void OnDraw(CDC* pDC) = 0;
+
+	// Printing support
+	virtual BOOL OnPreparePrinting(CPrintInfo* pInfo);
+		// must override to enable printing and print preview
+
+	virtual void OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo);
+	virtual void OnPrint(CDC* pDC, CPrintInfo* pInfo);
+	virtual void OnEndPrinting(CDC* pDC, CPrintInfo* pInfo);
+
+	// Advanced: end print preview mode, move to point
+	virtual void OnEndPrintPreview(CDC* pDC, CPrintInfo* pInfo, POINT point,
+		CPreviewView* pView);
+
+// Implementation
+public:
+	virtual ~CView();
+#ifdef _DEBUG
+	virtual void Dump(CDumpContext&) const;
+	virtual void AssertValid() const;
+#endif //_DEBUG
+
+	// Advanced: for implementing custom print preview
+	BOOL DoPrintPreview(UINT nIDResource, CView* pPrintView,
+			CRuntimeClass* pPreviewViewClass, CPrintPreviewState* pState);
+
+	virtual void CalcWindowRect(LPRECT lpClientRect,
+		UINT nAdjustType = adjustBorder);
+	virtual CScrollBar* GetScrollBarCtrl(int nBar) const;
+	static CSplitterWnd* PASCAL GetParentSplitter(
+		const CWnd* pWnd, BOOL bAnyState);
+
+protected:
+	CDocument* m_pDocument;
+
+	virtual BOOL OnCmdMsg(UINT nID, int nCode, void* pExtra,
+		AFX_CMDHANDLERINFO* pHandlerInfo);
+	virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
+	virtual void PostNcDestroy();
+
+	// friend classes that call protected CView overridables
+	friend class CDocument;
+	friend class CDocTemplate;
+	friend class CPreviewView;
+	friend class CFrameWnd;
+	friend class CMDIFrameWnd;
+	friend class CMDIChildWnd;
+	friend class CSplitterWnd;
+	friend class COleServerDoc;
+
+	//{{AFX_MSG(CView)
+	afx_msg int OnCreate(LPCREATESTRUCT lpcs);
+	afx_msg void OnDestroy();
+	afx_msg void OnPaint();
+	afx_msg int OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message);
+	// commands
+	afx_msg void OnUpdateSplitCmd(CCmdUI* pCmdUI);
+	afx_msg BOOL OnSplitCmd(UINT nID);
+	afx_msg void OnUpdateNextPaneMenu(CCmdUI* pCmdUI);
+	afx_msg BOOL OnNextPaneCmd(UINT nID);
+
+	// not mapped commands - must be mapped in derived class
+	afx_msg void OnFilePrint();
+	afx_msg void OnFilePrintPreview();
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// class CCtrlView allows almost any control to be a view
+
+class CCtrlView : public CView
+{
+	DECLARE_DYNCREATE(CCtrlView)
+
+public:
+	CCtrlView(LPCTSTR lpszClass, DWORD dwStyle);
+
+// Attributes
+protected:
+	CString m_strClass;
+	DWORD m_dwDefaultStyle;
+
+// Overrides
+	virtual void OnDraw(CDC*);
+	virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
+
+// Implementation
+public:
+#ifdef _DEBUG
+	virtual void Dump(CDumpContext&) const;
+	virtual void AssertValid() const;
+#endif //_DEBUG
+
+protected:
+	afx_msg void OnPaint();
+	DECLARE_MESSAGE_MAP()
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// class CScrollView supports simple scrolling and scaling
+
+class CScrollView : public CView
+{
+	DECLARE_DYNAMIC(CScrollView)
+
+// Constructors
+protected:
+	CScrollView();
+
+public:
+	static AFX_DATA const SIZE sizeDefault;
+		// used to specify default calculated page and line sizes
+
+	// in logical units - call one of the following Set routines
+	void SetScaleToFitSize(SIZE sizeTotal);
+	void SetScrollSizes(int nMapMode, SIZE sizeTotal,
+				const SIZE& sizePage = sizeDefault,
+				const SIZE& sizeLine = sizeDefault);
+
+// Attributes
+public:
+	CPoint GetScrollPosition() const;       // upper corner of scrolling
+	CSize GetTotalSize() const;             // logical size
+
+	// for device units
+	CPoint GetDeviceScrollPosition() const;
+	void GetDeviceScrollSizes(int& nMapMode, SIZE& sizeTotal,
+			SIZE& sizePage, SIZE& sizeLine) const;
+
+// Operations
+public:
+	void ScrollToPosition(POINT pt);    // set upper left position
+	void FillOutsideRect(CDC* pDC, CBrush* pBrush);
+	void ResizeParentToFit(BOOL bShrinkOnly = TRUE);
+
+// Implementation
+protected:
+	int m_nMapMode;
+	CSize m_totalLog;           // total size in logical units (no rounding)
+	CSize m_totalDev;           // total size in device units
+	CSize m_pageDev;            // per page scroll size in device units
+	CSize m_lineDev;            // per line scroll size in device units
+
+	BOOL m_bCenter;             // Center output if larger than total size
+	BOOL m_bInsideUpdate;       // internal state for OnSize callback
+	void CenterOnPoint(CPoint ptCenter);
+	void ScrollToDevicePosition(POINT ptDev); // explicit scrolling no checking
+
+protected:
+	virtual void OnDraw(CDC* pDC) = 0;      // pass on pure virtual
+
+	void UpdateBars();          // adjust scrollbars etc
+	BOOL GetTrueClientSize(CSize& size, CSize& sizeSb);
+		// size with no bars
+	void GetScrollBarSizes(CSize& sizeSb);
+	void GetScrollBarState(CSize sizeClient, CSize& needSb,
+		CSize& sizeRange, CPoint& ptMove, BOOL bInsideClient);
+
+public:
+	virtual ~CScrollView();
+#ifdef _DEBUG
+	virtual void Dump(CDumpContext&) const;
+	virtual void AssertValid() const;
+#endif //_DEBUG
+	virtual void CalcWindowRect(LPRECT lpClientRect,
+		UINT nAdjustType = adjustBorder);
+	virtual void OnPrepareDC(CDC* pDC, CPrintInfo* pInfo = NULL);
+
+	// scrolling implementation support for OLE
+	virtual BOOL OnScroll(UINT nScrollCode, UINT nPos, BOOL bDoScroll = TRUE);
+	virtual BOOL OnScrollBy(CSize sizeScroll, BOOL bDoScroll = TRUE);
+
+	//{{AFX_MSG(CScrollView)
+	afx_msg void OnSize(UINT nType, int cx, int cy);
+	afx_msg void OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
+	afx_msg void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// CWinThread
+
+typedef UINT (AFX_CDECL *AFX_THREADPROC)(LPVOID);
+
+class CWinThread : public CCmdTarget
+{
+	DECLARE_DYNAMIC(CWinThread)
+
+public:
+// Constructors
+	CWinThread();
+	BOOL CreateThread(DWORD dwCreateFlags = 0, UINT nStackSize = 0,
+		LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL);
+
+// Attributes
+	CWnd* m_pMainWnd;       // main window (usually same AfxGetApp()->m_pMainWnd)
+	CWnd* m_pActiveWnd;     // active main window (may not be m_pMainWnd)
+	BOOL m_bAutoDelete;     // enables 'delete this' after thread termination
+
+	// only valid while running
+	HANDLE m_hThread;       // this thread's HANDLE
+	operator HANDLE() const;
+	DWORD m_nThreadID;      // this thread's ID
+
+	int GetThreadPriority();
+	BOOL SetThreadPriority(int nPriority);
+
+// Operations
+	DWORD SuspendThread();
+	DWORD ResumeThread();
+
+// Overridables
+	// thread initialization
+	virtual BOOL InitInstance();
+
+	// running and idle processing
+	virtual int Run();
+	virtual BOOL PreTranslateMessage(MSG* pMsg);
+	virtual BOOL PumpMessage();     // low level message pump
+	virtual BOOL OnIdle(LONG lCount); // return TRUE if more idle processing
+	virtual BOOL IsIdleMessage(MSG* pMsg);  // checks for special messages
+
+	// thread termination
+	virtual int ExitInstance(); // default will 'delete this'
+
+	// Advanced: exception handling
+	virtual LRESULT ProcessWndProcException(CException* e, const MSG* pMsg);
+
+	// Advanced: handling messages sent to message filter hook
+	virtual BOOL ProcessMessageFilter(int code, LPMSG lpMsg);
+
+	// Advanced: virtual access to m_pMainWnd
+	virtual CWnd* GetMainWnd();
+
+// Implementation
+public:
+	virtual ~CWinThread();
+#ifdef _DEBUG
+	virtual void AssertValid() const;
+	virtual void Dump(CDumpContext& dc) const;
+	int m_nDisablePumpCount; // Diagnostic trap to detect illegal re-entrancy
+#endif
+	void CommonConstruct();
+	virtual void Delete();
+		// 'delete this' only if m_bAutoDelete == TRUE
+
+	// message pump for Run
+	MSG m_msgCur;                   // current message
+
+public:
+	// constructor used by implementation of AfxBeginThread
+	CWinThread(AFX_THREADPROC pfnThreadProc, LPVOID pParam);
+
+	// valid after construction
+	LPVOID m_pThreadParams; // generic parameters passed to starting function
+	AFX_THREADPROC m_pfnThreadProc;
+
+protected:
+	CPoint m_ptCursorLast;      // last mouse position
+	UINT m_nMsgLast;            // last mouse message
+};
+
+// global helpers for threads
+
+CWinThread* AFXAPI AfxBeginThread(AFX_THREADPROC pfnThreadProc, LPVOID pParam,
+	int nPriority = THREAD_PRIORITY_NORMAL, UINT nStackSize = 0,
+	DWORD dwCreateFlags = 0, LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL);
+CWinThread* AFXAPI AfxBeginThread(CRuntimeClass* pThreadClass,
+	int nPriority = THREAD_PRIORITY_NORMAL, UINT nStackSize = 0,
+	DWORD dwCreateFlags = 0, LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL);
+
+CWinThread* AFXAPI AfxGetThread();
+void AFXAPI AfxEndThread(UINT nExitCode, BOOL bDelete = TRUE);
+
+void AFXAPI AfxInitThread();
+void AFXAPI AfxTermThread();
+
+/////////////////////////////////////////////////////////////////////////////
+// Global functions for access to the one and only CWinApp
+
+#define afxCurrentWinApp    AfxGetModuleState()->m_pCurrentWinApp
+#define afxCurrentInstanceHandle    AfxGetModuleState()->m_hCurrentInstanceHandle
+#define afxCurrentResourceHandle    AfxGetModuleState()->m_hCurrentResourceHandle
+#define afxCurrentAppName   AfxGetModuleState()->m_lpszCurrentAppName
+#define afxContextIsDLL     AfxGetModuleState()->m_bDLL
+#define afxRegisteredClasses    AfxGetModuleState()->m_fRegisteredClasses
+
+#ifndef _AFX_NO_OCC_SUPPORT
+#define afxOccManager   AfxGetModuleProcessState()->m_pOccManager
+#endif
+
+// Advanced initialization: for overriding default WinMain
+BOOL AFXAPI AfxWinInit(HINSTANCE, HINSTANCE, LPTSTR, int);
+void AFXAPI AfxWinTerm();
+
+// Global Windows state data helper functions (inlines)
+CWinApp* AFXAPI AfxGetApp();
+CWnd* AFXAPI AfxGetMainWnd();
+HINSTANCE AFXAPI AfxGetInstanceHandle();
+HINSTANCE AFXAPI AfxGetResourceHandle();
+void AFXAPI AfxSetResourceHandle(HINSTANCE hInstResource);
+LPCTSTR AFXAPI AfxGetAppName();
+
+// Use instead of PostQuitMessage in OLE server applications
+void AFXAPI AfxPostQuitMessage(int nExitCode);
+
+// Use AfxFindResourceHandle to find resource in chain of extension DLLs
+#ifndef _AFXDLL
+#define AfxFindResourceHandle(lpszResource, lpszType) AfxGetResourceHandle()
+#else
+HINSTANCE AFXAPI AfxFindResourceHandle(LPCTSTR lpszName, LPCTSTR lpszType);
+#endif
+
+class COleMessageFilter;        // forward reference (see afxole.h)
+class CRecentFileList;          // forward reference (see afxpriv.h)
+
+// access to message filter in CWinApp
+COleMessageFilter* AFXAPI AfxOleGetMessageFilter();
+
+/////////////////////////////////////////////////////////////////////////////
+// CCommandLineInfo
+
+class CCommandLineInfo : public CObject
+{
+public:
+	// Sets default values
+	CCommandLineInfo();
+
+	virtual void ParseParam(const char* pszParam, BOOL bFlag, BOOL bLast);
+
+	BOOL m_bShowSplash;
+	BOOL m_bRunEmbedded;
+	BOOL m_bRunAutomated;
+	enum { FileNew, FileOpen, FilePrint, FilePrintTo, FileDDE,
+		FileNothing = -1 } m_nShellCommand;
+
+	// not valid for FileNew
+	CString m_strFileName;
+
+	// valid only for FilePrintTo
+	CString m_strPrinterName;
+	CString m_strDriverName;
+	CString m_strPortName;
+
+	~CCommandLineInfo();
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// CDocManager
+
+class CDocManager : public CObject
+{
+	DECLARE_DYNAMIC(CDocManager)
+public:
+
+// Constructor
+	CDocManager();
+
+	//Document functions
+	virtual void AddDocTemplate(CDocTemplate* pTemplate);
+	virtual POSITION GetFirstDocTemplatePosition() const;
+	virtual CDocTemplate* GetNextDocTemplate(POSITION& pos) const;
+	virtual void RegisterShellFileTypes(BOOL bWin95);
+	virtual CDocument* OpenDocumentFile(LPCTSTR lpszFileName); // open named file
+	virtual BOOL SaveAllModified(); // save before exit
+	virtual void CloseAllDocuments(BOOL bEndSession); // close documents before exiting
+	virtual int GetOpenDocumentCount();
+
+	// helper for standard commdlg dialogs
+	virtual BOOL DoPromptFileName(CString& fileName, UINT nIDSTitle,
+			DWORD lFlags, BOOL bOpenFileDialog, CDocTemplate* pTemplate);
+
+//Commands
+#ifndef _MAC
+	// Advanced: process async DDE request
+	virtual BOOL OnDDECommand(LPTSTR lpszCommand);
+#endif
+	virtual void OnFileNew();
+	virtual void OnFileOpen();
+
+// Implementation
+protected:
+	CPtrList m_templateList;
+
+public:
+	static CPtrList* pStaticList;       // for static CDocTemplate objects
+	static BOOL bStaticInit;            // TRUE during static initialization
+	static CDocManager* pStaticDocManager;  // for static CDocTemplate objects
+
+public:
+	virtual ~CDocManager();
+#ifdef _DEBUG
+	virtual void AssertValid() const;
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// CWinApp - the root of all Windows applications
+
+#define _AFX_MRU_COUNT   4      // default support for 4 entries in file MRU
+#define _AFX_MRU_MAX_COUNT 16   // currently allocated id range supports 16
+
+class CWinApp : public CWinThread
+{
+	DECLARE_DYNAMIC(CWinApp)
+public:
+
+// Constructor
+	CWinApp(LPCTSTR lpszAppName = NULL);     // app name defaults to EXE name
+
+// Attributes
+	// Startup args (do not change)
+	HINSTANCE m_hInstance;
+	HINSTANCE m_hPrevInstance;
+	LPTSTR m_lpCmdLine;
+	int m_nCmdShow;
+
+	// Running args (can be changed in InitInstance)
+	LPCTSTR m_pszAppName;  // human readable name
+								//  (from constructor or AFX_IDS_APP_TITLE)
+	LPCTSTR m_pszRegistryKey;   // used for registry entries
+	CDocManager* m_pDocManager;
+
+	// Support for Shift+F1 help mode.
+	BOOL m_bHelpMode;           // are we in Shift+F1 mode?
+
+#ifdef _MAC
+	// Support for AppleEvent interaction levels
+	enum SaveOption
+	{
+		saveYes,        // always save modified documents
+		saveNo,         // never save modified documents
+		saveAsk         // ask user whether to save modified documents
+	};
+	SaveOption m_nSaveOption;
+#endif
+
+public:  // set in constructor to override default
+	LPCTSTR m_pszExeName;       // executable name (no spaces)
+	LPCTSTR m_pszHelpFilePath;  // default based on module path
+	LPCTSTR m_pszProfileName;   // default based on app name
+
+// Initialization Operations - should be done in InitInstance
+protected:
+	void LoadStdProfileSettings(UINT nMaxMRU = _AFX_MRU_COUNT); // load MRU file list and last preview state
+	void EnableShellOpen();
+
+	void SetDialogBkColor(COLORREF clrCtlBk = RGB(192, 192, 192),
+				COLORREF clrCtlText = RGB(0, 0, 0));
+		// set dialog box and message box background color
+
+	void SetRegistryKey(LPCTSTR lpszRegistryKey);
+	void SetRegistryKey(UINT nIDRegistryKey);
+		// enables app settings in registry instead of INI files
+		//  (registry key is usually a "company name")
+
+#ifdef _MAC
+	friend void CFrameWnd::OnSysColorChange();
+	friend void CDialog::OnSysColorChange();
+#endif
+
+	BOOL Enable3dControls(); // use CTL3D32.DLL for 3D controls in dialogs
+#ifndef _AFXDLL
+	BOOL Enable3dControlsStatic();  // statically link CTL3D.LIB instead
+#endif
+
+	void RegisterShellFileTypes(BOOL bWin95=FALSE);
+		// call after all doc templates are registered
+	void RegisterShellFileTypesCompat();
+		// for backwards compatibility
+
+// Helper Operations - usually done in InitInstance
+public:
+	// Cursors
+	HCURSOR LoadCursor(LPCTSTR lpszResourceName) const;
+	HCURSOR LoadCursor(UINT nIDResource) const;
+	HCURSOR LoadStandardCursor(LPCTSTR lpszCursorName) const; // for IDC_ values
+	HCURSOR LoadOEMCursor(UINT nIDCursor) const;             // for OCR_ values
+
+	// Icons
+	HICON LoadIcon(LPCTSTR lpszResourceName) const;
+	HICON LoadIcon(UINT nIDResource) const;
+	HICON LoadStandardIcon(LPCTSTR lpszIconName) const;       // for IDI_ values
+	HICON LoadOEMIcon(UINT nIDIcon) const;                   // for OIC_ values
+
+	// Profile settings (to the app specific .INI file, or registry)
+	UINT GetProfileInt(LPCTSTR lpszSection, LPCTSTR lpszEntry, int nDefault);
+	BOOL WriteProfileInt(LPCTSTR lpszSection, LPCTSTR lpszEntry, int nValue);
+	CString GetProfileString(LPCTSTR lpszSection, LPCTSTR lpszEntry,
+				LPCTSTR lpszDefault = NULL);
+	BOOL WriteProfileString(LPCTSTR lpszSection, LPCTSTR lpszEntry,
+				LPCTSTR lpszValue);
+	BOOL GetProfileBinary(LPCTSTR lpszSection, LPCTSTR lpszEntry,
+				LPBYTE* ppData, UINT* pBytes);
+	BOOL WriteProfileBinary(LPCTSTR lpszSection, LPCTSTR lpszEntry,
+				LPBYTE pData, UINT nBytes);
+
+// Running Operations - to be done on a running application
+	// Dealing with document templates
+	void AddDocTemplate(CDocTemplate* pTemplate);
+	POSITION GetFirstDocTemplatePosition() const;
+	CDocTemplate* GetNextDocTemplate(POSITION& pos) const;
+
+	// Dealing with files
+	virtual CDocument* OpenDocumentFile(LPCTSTR lpszFileName); // open named file
+	virtual void AddToRecentFileList(LPCTSTR lpszPathName);  // add to MRU
+
+	// Printer DC Setup routine, 'struct tagPD' is a PRINTDLG structure
+	void SelectPrinter(HANDLE hDevNames, HANDLE hDevMode,
+		BOOL bFreeOld = TRUE);
+	BOOL CreatePrinterDC(CDC& dc);
+#ifndef _UNICODE
+	BOOL GetPrinterDeviceDefaults(struct tagPDA* pPrintDlg);
+#else
+	BOOL GetPrinterDeviceDefaults(struct tagPDW* pPrintDlg);
+#endif
+
+	// Command line parsing
+	BOOL RunEmbedded();
+	BOOL RunAutomated();
+	void ParseCommandLine(CCommandLineInfo& rCmdInfo);
+	BOOL ProcessShellCommand(CCommandLineInfo& rCmdInfo);
+
+// Overridables
+	// hooks for your initialization code
+	virtual BOOL InitApplication();
+#ifdef _MAC
+	virtual BOOL CreateInitialDocument();
+#endif
+
+	// exiting
+	virtual BOOL SaveAllModified(); // save before exit
+	void HideApplication();
+	void CloseAllDocuments(BOOL bEndSession); // close documents before exiting
+
+	// Advanced: to override message boxes and other hooks
+	virtual int DoMessageBox(LPCTSTR lpszPrompt, UINT nType, UINT nIDPrompt);
+	virtual void DoWaitCursor(int nCode); // 0 => restore, 1=> begin, -1=> end
+
+#ifndef _MAC
+	// Advanced: process async DDE request
+	virtual BOOL OnDDECommand(LPTSTR lpszCommand);
+#endif
+
+	// Advanced: Help support
+	virtual void WinHelp(DWORD dwData, UINT nCmd = HELP_CONTEXT);
+
+
+// Command Handlers
+protected:
+	// map to the following for file new/open
+	afx_msg void OnFileNew();
+	afx_msg void OnFileOpen();
+
+	// map to the following to enable print setup
+	afx_msg void OnFilePrintSetup();
+
+	// map to the following to enable help
+	afx_msg void OnContextHelp();   // shift-F1
+	afx_msg void OnHelp();          // F1 (uses current context)
+	afx_msg void OnHelpIndex();     // ID_HELP_INDEX
+	afx_msg void OnHelpFinder();    // ID_HELP_FINDER, ID_DEFAULT_HELP
+	afx_msg void OnHelpUsing();     // ID_HELP_USING
+
+// Implementation
+protected:
+	HGLOBAL m_hDevMode;             // printer Dev Mode
+	HGLOBAL m_hDevNames;            // printer Device Names
+	DWORD m_dwPromptContext;        // help context override for message box
+
+	int m_nWaitCursorCount;         // for wait cursor (>0 => waiting)
+	HCURSOR m_hcurWaitCursorRestore; // old cursor to restore after wait cursor
+
+	CRecentFileList* m_pRecentFileList;
+
+	void UpdatePrinterSelection(BOOL bForceDefaults);
+	void SaveStdProfileSettings();  // save options to .INI file
+
+public: // public for implementation access
+	CCommandLineInfo* m_pCmdInfo;
+
+	ATOM m_atomApp, m_atomSystemTopic;   // for DDE open
+	UINT m_nNumPreviewPages;        // number of default printed pages
+
+	size_t  m_nSafetyPoolSize;      // ideal size
+
+	void (AFXAPI* m_lpfnDaoTerm)();
+	void (AFXAPI* m_lpfnOleTermOrFreeLib)(BOOL, BOOL);
+	COleMessageFilter* m_pMessageFilter;
+
+	void DevModeChange(LPTSTR lpDeviceName);
+	void SetCurrentHandles();
+	int GetOpenDocumentCount();
+
+	// helpers for standard commdlg dialogs
+	BOOL DoPromptFileName(CString& fileName, UINT nIDSTitle,
+			DWORD lFlags, BOOL bOpenFileDialog, CDocTemplate* pTemplate);
+	int DoPrintDialog(CPrintDialog* pPD);
+
+	void EnableModeless(BOOL bEnable); // to disable OLE in-place dialogs
+
+	// overrides for implementation
+	virtual BOOL InitInstance();
+	virtual int ExitInstance(); // return app exit code
+	virtual int Run();
+	virtual BOOL OnIdle(LONG lCount); // return TRUE if more idle processing
+	virtual LRESULT ProcessWndProcException(CException* e, const MSG* pMsg);
+
+public:
+	virtual ~CWinApp();
+#ifdef _DEBUG
+	virtual void AssertValid() const;
+	virtual void Dump(CDumpContext& dc) const;
+#endif
+
+#ifndef _MAC
+	// helpers for registration
+	HKEY GetSectionKey(LPCTSTR lpszSection);
+	HKEY GetAppRegistryKey();
+#endif
+
+protected:
+	//{{AFX_MSG(CWinApp)
+	afx_msg void OnAppExit();
+	afx_msg void OnUpdateRecentFileMenu(CCmdUI* pCmdUI);
+	afx_msg BOOL OnOpenRecentFile(UINT nID);
+	//}}AFX_MSG
+	DECLARE_MESSAGE_MAP()
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// class CWaitCursor
+
+class CWaitCursor
+{
+// Construction/Destruction
+public:
+	CWaitCursor();
+	~CWaitCursor();
+
+// Operations
+public:
+	void Restore();
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// class CDocTemplate creates documents
+
+class CDocTemplate : public CCmdTarget
+{
+	DECLARE_DYNAMIC(CDocTemplate)
+
+// Constructors
+protected:
+	CDocTemplate(UINT nIDResource, CRuntimeClass* pDocClass,
+		CRuntimeClass* pFrameClass, CRuntimeClass* pViewClass);
+public:
+	virtual void LoadTemplate();
+
+// Attributes
+public:
+	// setup for OLE containers
+	void SetContainerInfo(UINT nIDOleInPlaceContainer);
+
+	// setup for OLE servers
+	void SetServerInfo(UINT nIDOleEmbedding, UINT nIDOleInPlaceServer = 0,
+		CRuntimeClass* pOleFrameClass = NULL, CRuntimeClass* pOleViewClass = NULL);
+
+	// iterating over open documents
+	virtual POSITION GetFirstDocPosition() const = 0;
+	virtual CDocument* GetNextDoc(POSITION& rPos) const = 0;
+
+// Operations
+public:
+	virtual void AddDocument(CDocument* pDoc);      // must override
+	virtual void RemoveDocument(CDocument* pDoc);   // must override
+
+	enum DocStringIndex
+	{
+		windowTitle,        // default window title
+		docName,            // user visible name for default document
+		fileNewName,        // user visible name for FileNew
+		// for file based documents:
+#ifndef _MAC
+		filterName,         // user visible name for FileOpen
+		filterExt,          // user visible extension for FileOpen
+#else
+		filterWinName,      // user visible name for FileOpen
+		filterWinExt,       // user visible extension for FileOpen
+#endif
+		// for file based documents with Shell open support:
+		regFileTypeId,      // REGEDIT visible registered file type identifier
+		regFileTypeName,    // Shell visible registered file type name
+		// for Macintosh file based documents:
+#ifdef _MAC
+		filterExt,          // Macintosh file type for FileOpen
+		filterName          // user visible name for Macintosh FileOpen
+#else
+		filterMacExt,       // Macintosh file type for FileOpen
+		filterMacName       // user visible name for Macintosh FileOpen
+#endif
+	};
+	virtual BOOL GetDocString(CString& rString,
+		enum DocStringIndex index) const; // get one of the info strings
+	CFrameWnd* CreateOleFrame(CWnd* pParentWnd, CDocument* pDoc,
+		BOOL bCreateView);
+
+// Overridables
+public:
+	enum Confidence
+	{
+		noAttempt,
+		maybeAttemptForeign,
+		maybeAttemptNative,
+		yesAttemptForeign,
+		yesAttemptNative,
+		yesAlreadyOpen
+	};
+#ifndef _MAC
+	virtual Confidence MatchDocType(LPCTSTR lpszPathName,
+					CDocument*& rpDocMatch);
+#else
+	virtual Confidence MatchDocType(LPCTSTR lpszFileName,
+					DWORD dwFileType, CDocument*& rpDocMatch);
+#endif
+	virtual CDocument* CreateNewDocument();
+	virtual CFrameWnd* CreateNewFrame(CDocument* pDoc, CFrameWnd* pOther);
+	virtual void InitialUpdateFrame(CFrameWnd* pFrame, CDocument* pDoc,
+		BOOL bMakeVisible = TRUE);
+	virtual BOOL SaveAllModified();     // for all documents
+	virtual void CloseAllDocuments(BOOL bEndSession);
+	virtual CDocument* OpenDocumentFile(
+		LPCTSTR lpszPathName, BOOL bMakeVisible = TRUE) = 0;
+					// open named file
+					// if lpszPathName == NULL => create new file with this type
+	virtual void SetDefaultTitle(CDocument* pDocument) = 0;
+
+// Implementation
+public:
+	BOOL m_bAutoDelete;
+	virtual ~CDocTemplate();
+
+	// back pointer to OLE or other server (NULL if none or disabled)
+	CObject* m_pAttachedFactory;
+
+	// menu & accelerator resources for in-place container
+	HMENU m_hMenuInPlace;
+	HACCEL m_hAccelInPlace;
+
+	// menu & accelerator resource for server editing embedding
+	HMENU m_hMenuEmbedding;
+	HACCEL m_hAccelEmbedding;
+
+	// menu & accelerator resource for server editing in-place
+	HMENU m_hMenuInPlaceServer;
+	HACCEL m_hAccelInPlaceServer;
+
+#ifdef _DEBUG
+	virtual void Dump(CDumpContext&) const;
+	virtual void AssertValid() const;
+#endif
+	virtual void OnIdle();             // for all documents
+
+protected:
+	UINT m_nIDResource;                 // IDR_ for frame/menu/accel as well
+	UINT m_nIDServerResource;           // IDR_ for OLE inplace frame/menu/accel
+	UINT m_nIDEmbeddingResource;        // IDR_ for OLE open frame/menu/accel
+	UINT m_nIDContainerResource;        // IDR_ for container frame/menu/accel
+
+	CRuntimeClass* m_pDocClass;         // class for creating new documents
+	CRuntimeClass* m_pFrameClass;       // class for creating new frames
+	CRuntimeClass* m_pViewClass;        // class for creating new views
+	CRuntimeClass* m_pOleFrameClass;    // class for creating in-place frame
+	CRuntimeClass* m_pOleViewClass;     // class for creating in-place view
+
+	CString m_strDocStrings;    // '\n' separated names
+		// The document names sub-strings are represented as _one_ string:
+		// windowTitle\ndocName\n ... (see DocStringIndex enum)
+};
+
+// SDI support (1 document only)
+class CSingleDocTemplate : public CDocTemplate
+{
+	DECLARE_DYNAMIC(CSingleDocTemplate)
+
+// Constructors
+public:
+	CSingleDocTemplate(UINT nIDResource, CRuntimeClass* pDocClass,
+		CRuntimeClass* pFrameClass, CRuntimeClass* pViewClass);
+
+// Implementation
+public:
+	virtual ~CSingleDocTemplate();
+	virtual void AddDocument(CDocument* pDoc);
+	virtual void RemoveDocument(CDocument* pDoc);
+	virtual POSITION GetFirstDocPosition() const;
+	virtual CDocument* GetNextDoc(POSITION& rPos) const;
+	virtual CDocument* OpenDocumentFile(
+		LPCTSTR lpszPathName, BOOL bMakeVisible = TRUE);
+	virtual void SetDefaultTitle(CDocument* pDocument);
+
+#ifdef _DEBUG
+	virtual void Dump(CDumpContext&) const;
+	virtual void AssertValid() const;
+#endif //_DEBUG
+
+protected:  // standard implementation
+	CDocument* m_pOnlyDoc;
+};
+
+// MDI support (zero or more documents)
+class CMultiDocTemplate : public CDocTemplate
+{
+	DECLARE_DYNAMIC(CMultiDocTemplate)
+
+// Constructors
+public:
+	CMultiDocTemplate(UINT nIDResource, CRuntimeClass* pDocClass,
+		CRuntimeClass* pFrameClass, CRuntimeClass* pViewClass);
+
+// Implementation
+public:
+	// Menu and accel table for MDI Child windows of this type
+	HMENU m_hMenuShared;
+	HACCEL m_hAccelTable;
+
+	virtual ~CMultiDocTemplate();
+	virtual void LoadTemplate();
+	virtual void AddDocument(CDocument* pDoc);
+	virtual void RemoveDocument(CDocument* pDoc);
+	virtual POSITION GetFirstDocPosition() const;
+	virtual CDocument* GetNextDoc(POSITION& rPos) const;
+	virtual CDocument* OpenDocumentFile(
+		LPCTSTR lpszPathName, BOOL bMakeVisible = TRUE);
+	virtual void SetDefaultTitle(CDocument* pDocument);
+
+#ifdef _DEBUG
+	virtual void Dump(CDumpContext&) const;
+	virtual void AssertValid() const;
+#endif //_DEBUG
+
+protected:  // standard implementation
+	CPtrList m_docList;          // open documents of this type
+	UINT m_nUntitledCount;   // start at 0, for "Document1" title
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// class CDocument is the main document data abstraction
+
+class CDocument : public CCmdTarget
+{
+	DECLARE_DYNAMIC(CDocument)
+
+public:
+// Constructors
+	CDocument();
+
+// Attributes
+public:
+	const CString& GetTitle() const;
+	virtual void SetTitle(LPCTSTR lpszTitle);
+	const CString& GetPathName() const;
+	virtual void SetPathName(LPCTSTR lpszPathName, BOOL bAddToMRU = TRUE);
+
+	CDocTemplate* GetDocTemplate() const;
+	virtual BOOL IsModified();
+	virtual void SetModifiedFlag(BOOL bModified = TRUE);
+
+// Operations
+	void AddView(CView* pView);
+	void RemoveView(CView* pView);
+	virtual POSITION GetFirstViewPosition() const;
+	virtual CView* GetNextView(POSITION& rPosition) const;
+
+	// Update Views (simple update - DAG only)
+	void UpdateAllViews(CView* pSender, LPARAM lHint = 0L,
+		CObject* pHint = NULL);
+
+// Overridables
+	// Special notifications
+	virtual void OnChangedViewList(); // after Add or Remove view
+	virtual void DeleteContents(); // delete doc items etc
+
+	// File helpers
+	virtual BOOL OnNewDocument();
+	virtual BOOL OnOpenDocument(LPCTSTR lpszPathName);
+	virtual BOOL OnSaveDocument(LPCTSTR lpszPathName);
+#ifdef _MAC
+	virtual void RecordDataFileOwner(LPCTSTR lpszPathName, LPCTSTR lpszAppName);
+#endif
+	virtual void OnCloseDocument();
+	virtual void ReportSaveLoadException(LPCTSTR lpszPathName,
+				CException* e, BOOL bSaving, UINT nIDPDefault);
+	virtual CFile* GetFile(LPCTSTR lpszFileName, UINT nOpenFlags,
+		CFileException* pError);
+	virtual void ReleaseFile(CFile* pFile, BOOL bAbort);
+
+	// advanced overridables, closing down frame/doc, etc.
+	virtual BOOL CanCloseFrame(CFrameWnd* pFrame);
+	virtual BOOL SaveModified(); // return TRUE if ok to continue
+	virtual void PreCloseFrame(CFrameWnd* pFrame);
+
+// Implementation
+protected:
+	// default implementation
+	CString m_strTitle;
+	CString m_strPathName;
+	CDocTemplate* m_pDocTemplate;
+	CPtrList m_viewList;                // list of views
+	BOOL m_bModified;                   // changed since last saved
+
+public:
+	BOOL m_bAutoDelete;     // TRUE => delete document when no more views
+	BOOL m_bEmbedded;       // TRUE => document is being created by OLE
+
+#ifdef _DEBUG
+	virtual void Dump(CDumpContext&) const;
+	virtual void AssertValid() const;
+#endif //_DEBUG
+	virtual ~CDocument();
+
+	// implementation helpers
+	virtual BOOL DoSave(LPCTSTR lpszPathName, BOOL bReplace = TRUE);
+	virtual BOOL DoFileSave();
+	virtual void UpdateFrameCounts();
+	void DisconnectViews();
+	void SendInitialUpdate();
+
+	// overridables for implementation
+	virtual HMENU GetDefaultMenu(); // get menu depending on state
+	virtual HACCEL GetDefaultAccelerator();
+	virtual void OnIdle();
+	virtual void OnFinalRelease();
+
+	virtual BOOL OnCmdMsg(UINT nID, int nCode, void* pExtra,
+		AFX_CMDHANDLERINFO* pHandlerInfo);
+	friend class CDocTemplate;
+
+protected:
+	// file menu commands
+	//{{AFX_MSG(CDocument)
+	afx_msg void OnFileClose();
+	afx_msg void OnFileSave();
+	afx_msg void OnFileSaveAs();
+	//}}AFX_MSG
+	// mail enabling
+	afx_msg void OnFileSendMail();
+	afx_msg void OnUpdateFileSendMail(CCmdUI* pCmdUI);
+	DECLARE_MESSAGE_MAP()
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// Extra diagnostic tracing options
+
+#ifdef _DEBUG
+
+extern AFX_DATA UINT afxTraceFlags;
+enum AfxTraceFlags
+{
+	traceMultiApp = 1,      // multi-app debugging
+	traceAppMsg = 2,        // main message pump trace (includes DDE)
+	traceWinMsg = 4,        // Windows message tracing
+	traceCmdRouting = 8,    // Windows command routing trace (set 4+8 for control notifications)
+	traceOle = 16,          // special OLE callback trace
+	traceDatabase = 32      // special database trace
+};
+
+#endif // _DEBUG
+
+//////////////////////////////////////////////////////////////////////////////
+// MessageBox helpers
+
+void AFXAPI AfxFormatString1(CString& rString, UINT nIDS, LPCTSTR lpsz1);
+void AFXAPI AfxFormatString2(CString& rString, UINT nIDS,
+				LPCTSTR lpsz1, LPCTSTR lpsz2);
+int AFXAPI AfxMessageBox(LPCTSTR lpszText, UINT nType = MB_OK,
+				UINT nIDHelp = 0);
+int AFXAPI AfxMessageBox(UINT nIDPrompt, UINT nType = MB_OK,
+				UINT nIDHelp = (UINT)-1);
+
+// Implementation string helpers
+void AFXAPI AfxFormatStrings(CString& rString, UINT nIDS,
+				LPCTSTR const* rglpsz, int nString);
+void AFXAPI AfxFormatStrings(CString& rString, LPCTSTR lpszFormat,
+				LPCTSTR const* rglpsz, int nString);
+BOOL AFXAPI AfxExtractSubString(CString& rString, LPCTSTR lpszFullString,
+				int iSubString, TCHAR chSep = '\n');
+
+/////////////////////////////////////////////////////////////////////////////
+// Special target variant APIs
+
+#ifdef _AFXDLL
+	#include <afxdll_.h>
+#endif
+
+// Windows Version compatibility (obsolete)
+#define AfxEnableWin30Compatibility()
+#define AfxEnableWin31Compatibility()
+#define AfxEnableWin40Compatibility()
+
+// Temporary map management (locks temp map on current thread)
+void AFXAPI AfxLockTempMaps();
+BOOL AFXAPI AfxUnlockTempMaps();
+
+/////////////////////////////////////////////////////////////////////////////
+// Special OLE related functions (see OLELOCK.CPP)
+
+void AFXAPI AfxOleOnReleaseAllObjects();
+BOOL AFXAPI AfxOleCanExitApp();
+void AFXAPI AfxOleLockApp();
+void AFXAPI AfxOleUnlockApp();
+
+void AFXAPI AfxOleSetUserCtrl(BOOL bUserCtrl);
+BOOL AFXAPI AfxOleGetUserCtrl();
+
+#ifndef _AFX_NO_OCC_SUPPORT
+BOOL AFXAPI AfxOleLockControl(REFCLSID clsid);
+BOOL AFXAPI AfxOleUnlockControl(REFCLSID clsid);
+BOOL AFXAPI AfxOleLockControl(LPCTSTR lpszProgID);
+BOOL AFXAPI AfxOleUnlockControl(LPCTSTR lpszProgID);
+void AFXAPI AfxOleUnlockAllControls();
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+// Inline function declarations
+
+#ifdef _AFX_PACKING
+#pragma pack(pop)
+#endif
+
+#ifdef _AFX_ENABLE_INLINES
+#define _AFXWIN_INLINE inline
+#include <afxwin1.inl>
+#include <afxwin2.inl>
+#endif
+
+#undef AFX_DATA
+#define AFX_DATA
+
+#ifdef _AFX_MINREBUILD
+#pragma component(minrebuild, on)
+#endif
+#ifndef _AFX_FULLTYPEINFO
+#pragma component(mintypeinfo, off)
+#endif
+
+/////////////////////////////////////////////////////////////////////////////
+
+#else //RC_INVOKED
+#include <afxres.h>     // standard resource IDs
+#endif //RC_INVOKED
+
+#endif //__AFXWIN_H__
+
+/////////////////////////////////////////////////////////////////////////////