Tricks of the Windows Gam…ming Gurus (2nd Edition)/Disc2.iso/vc98/mfc/include/afxpriv.h

C/C++ Source or Header | 1998-06-16 | 24.8 KB | 782 lines

// This is a part of the Microsoft Foundation Classes C++ library.
// Copyright (C) 1992-1998 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.

// Note: This header file contains useful classes that are documented only
//  in the MFC Technical Notes.  These classes may change from version to
//  version, so be prepared to change your code accordingly if you utilize
//  this header.  In the future, commonly used portions of this header
//  may be moved and officially documented.

#ifndef __AFXPRIV_H__
#define __AFXPRIV_H__

#ifndef __AFXADV_H__
    #include <afxadv.h>
#endif

#ifndef _INC_MALLOC
    #include <malloc.h>
#endif

#ifndef __AFXEXT_H__
    #include <afxext.h>
#endif

#ifdef _AFX_MINREBUILD
#pragma component(minrebuild, off)
#endif
#ifndef _AFX_FULLTYPEINFO
#pragma component(mintypeinfo, on)
#endif

#ifdef _AFX_PACKING
#pragma pack(push, _AFX_PACKING)
#endif

/////////////////////////////////////////////////////////////////////////////
// AFXPRIV - MFC Private Classes

// Implementation structures
struct AFX_SIZEPARENTPARAMS;    // Control bar implementation
struct AFX_CMDHANDLERINFO;      // Command routing implementation

// Classes declared in this file

    //CDC
        class CPreviewDC;               // Virtual DC for print preview

    //CCmdTarget
        //CWnd
            //CView
                class CPreviewView;     // Print preview view
        //CFrameWnd
            class COleCntrFrameWnd;
            //CMiniFrameWnd
                class CMiniDockFrameWnd;

class CDockContext;                     // for dragging control bars

/////////////////////////////////////////////////////////////////////////////

#undef AFX_DATA
#define AFX_DATA AFX_CORE_DATA

/////////////////////////////////////////////////////////////////////////////
// Global ID ranges (see Technical note TN020 for more details)

// 8000 -> FFFF command IDs (used for menu items, accelerators and controls)
#define IS_COMMAND_ID(nID)  ((nID) & 0x8000)

// 8000 -> DFFF : user commands
// E000 -> EFFF : AFX commands and other things
// F000 -> FFFF : standard windows commands and other things etc
    // E000 -> E7FF standard commands
    // E800 -> E8FF control bars (first 32 are special)
    // E900 -> EEFF standard window controls/components
    // EF00 -> EFFF SC_ menu help
    // F000 -> FFFF standard strings
#define ID_COMMAND_FROM_SC(sc)  (((sc - 0xF000) >> 4) + AFX_IDS_SCFIRST)

// 0000 -> 7FFF IDR range
// 0000 -> 6FFF : user resources
// 7000 -> 7FFF : AFX (and standard windows) resources
// IDR ranges (NOTE: IDR_ values must be <32768)
#define ASSERT_VALID_IDR(nIDR) ASSERT((nIDR) != 0 && (nIDR) < 0x8000)

/////////////////////////////////////////////////////////////////////////////
// Context sensitive help support (see Technical note TN028 for more details)

// Help ID bases
#define HID_BASE_COMMAND    0x00010000UL        // ID and IDM
#define HID_BASE_RESOURCE   0x00020000UL        // IDR and IDD
#define HID_BASE_PROMPT     0x00030000UL        // IDP
#define HID_BASE_NCAREAS    0x00040000UL
#define HID_BASE_CONTROL    0x00050000UL        // IDC
#define HID_BASE_DISPATCH   0x00060000UL        // IDispatch help codes

/////////////////////////////////////////////////////////////////////////////
// Internal AFX Windows messages (see Technical note TN024 for more details)
// (0x0360 - 0x037F are reserved for MFC)

#define WM_QUERYAFXWNDPROC  0x0360  // lResult = 1 if processed by AfxWndProc
#define WM_SIZEPARENT       0x0361  // lParam = &AFX_SIZEPARENTPARAMS
#define WM_SETMESSAGESTRING 0x0362  // wParam = nIDS (or 0),
                                    // lParam = lpszOther (or NULL)
#define WM_IDLEUPDATECMDUI  0x0363  // wParam == bDisableIfNoHandler
#define WM_INITIALUPDATE    0x0364  // (params unused) - sent to children
#define WM_COMMANDHELP      0x0365  // lResult = TRUE/FALSE,
                                    // lParam = dwContext
#define WM_HELPHITTEST      0x0366  // lResult = dwContext,
                                    // lParam = MAKELONG(x,y)
#define WM_EXITHELPMODE     0x0367  // (params unused)
#define WM_RECALCPARENT     0x0368  // force RecalcLayout on frame window
                                    //  (only for inplace frame windows)
#define WM_SIZECHILD        0x0369  // special notify from COleResizeBar
                                    // wParam = ID of child window
                                    // lParam = lpRectNew (new position/size)
#define WM_KICKIDLE         0x036A  // (params unused) causes idles to kick in
#define WM_QUERYCENTERWND   0x036B  // lParam = HWND to use as centering parent
#define WM_DISABLEMODAL     0x036C  // lResult = 0, disable during modal state
                                    // lResult = 1, don't disable
#define WM_FLOATSTATUS      0x036D  // wParam combination of FS_* flags below

// WM_ACTIVATETOPLEVEL is like WM_ACTIVATEAPP but works with hierarchies
//   of mixed processes (as is the case with OLE in-place activation)
#define WM_ACTIVATETOPLEVEL 0x036E  // wParam = nState (like WM_ACTIVATE)
                                    // lParam = pointer to HWND[2]
                                    //  lParam[0] = hWnd getting WM_ACTIVATE
                                    //  lParam[1] = hWndOther

#define WM_QUERY3DCONTROLS  0x036F  // lResult != 0 if 3D controls wanted

// Note: Messages 0x0370, 0x0371, and 0x372 were incorrectly used by
//  some versions of Windows.  To remain compatible, MFC does not
//  use messages in that range.
#define WM_RESERVED_0370    0x0370
#define WM_RESERVED_0371    0x0371
#define WM_RESERVED_0372    0x0372

// WM_SOCKET_NOTIFY and WM_SOCKET_DEAD are used internally by MFC's
// Windows sockets implementation.  For more information, see sockcore.cpp
#define WM_SOCKET_NOTIFY    0x0373
#define WM_SOCKET_DEAD      0x0374

// same as WM_SETMESSAGESTRING except not popped if IsTracking()
#define WM_POPMESSAGESTRING 0x0375

// WM_HELPPROMPTADDR is used internally to get the address of
//  m_dwPromptContext from the associated frame window. This is used
//  during message boxes to setup for F1 help while that msg box is
//  displayed. lResult is the address of m_dwPromptContext.
#define WM_HELPPROMPTADDR   0x0376

// Constants used in DLGINIT resources for OLE control containers
// NOTE: These are NOT real Windows messages they are simply tags
// used in the control resource and are never used as 'messages'
#define WM_OCC_LOADFROMSTREAM           0x0376
#define WM_OCC_LOADFROMSTORAGE          0x0377
#define WM_OCC_INITNEW                  0x0378
#define WM_OCC_LOADFROMSTREAM_EX        0x037A
#define WM_OCC_LOADFROMSTORAGE_EX       0x037B

// Marker used while rearranging the message queue
#define WM_QUEUE_SENTINEL   0x0379

// Note: Messages 0x037C - 0x37E reserved for future MFC use.
#define WM_RESERVED_037C    0x037C
#define WM_RESERVED_037D    0x037D
#define WM_RESERVED_037E    0x037E

// WM_FORWARDMSG - used by ATL to forward a message to another window for processing
//  WPARAM - DWORD dwUserData - defined by user
//  LPARAM - LPMSG pMsg - a pointer to the MSG structure
//  return value - 0 if the message was not processed, nonzero if it was
#define WM_FORWARDMSG       0x037F

// like ON_MESSAGE but no return value
#define ON_MESSAGE_VOID(message, memberFxn) \
    { message, 0, 0, 0, AfxSig_vv, \
        (AFX_PMSG)(AFX_PMSGW)(void (AFX_MSG_CALL CWnd::*)(void))&memberFxn },

// special struct for WM_SIZEPARENT
struct AFX_SIZEPARENTPARAMS
{
    HDWP hDWP;       // handle for DeferWindowPos
    RECT rect;       // parent client rectangle (trim as appropriate)
    SIZE sizeTotal;  // total size on each side as layout proceeds
    BOOL bStretch;   // should stretch to fill all space
};

// flags for wParam in the WM_FLOATSTATUS message
enum {  FS_SHOW = 0x01, FS_HIDE = 0x02,
        FS_ACTIVATE = 0x04, FS_DEACTIVATE = 0x08,
        FS_ENABLE = 0x10, FS_DISABLE = 0x20,
        FS_SYNCACTIVE = 0x40 };

void AFXAPI AfxRepositionWindow(AFX_SIZEPARENTPARAMS* lpLayout,
    HWND hWnd, LPCRECT lpRect);

/////////////////////////////////////////////////////////////////////////////
// Implementation of command routing

struct AFX_CMDHANDLERINFO
{
    CCmdTarget* pTarget;
    void (AFX_MSG_CALL CCmdTarget::*pmf)(void);
};

/////////////////////////////////////////////////////////////////////////////
// Robust file save support
// opens a temp file if modeCreate specified and enough free space
// renaming, etc occurs automatically if everything succeeds

class CMirrorFile : public CFile
{
// Implementation
public:
    virtual void Abort();
    virtual void Close();
    virtual BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags,
        CFileException* pError = NULL);
    static CString GetTempName(LPCTSTR pstrOriginalFile, BOOL bCreate);

protected:
    CString m_strMirrorName;
};

/////////////////////////////////////////////////////////////////////////////
// Implementation of PrintPreview

class CPreviewDC : public CDC
{
    DECLARE_DYNAMIC(CPreviewDC)

public:
    virtual void SetAttribDC(HDC hDC);  // Set the Attribute DC
    virtual void SetOutputDC(HDC hDC);

    virtual void ReleaseOutputDC();

// Constructors
    CPreviewDC();

// Implementation
public:
    virtual ~CPreviewDC();
#ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
#endif

    void SetScaleRatio(int nNumerator, int nDenominator);
    void SetTopLeftOffset(CSize TopLeft);
    void ClipToPage();

    // These conversion functions can be used without an output DC

    void PrinterDPtoScreenDP(LPPOINT lpPoint) const;

// Device-Context Functions
    virtual int SaveDC();
    virtual BOOL RestoreDC(int nSavedDC);

public:
    virtual CGdiObject* SelectStockObject(int nIndex);
    virtual CFont* SelectObject(CFont* pFont);

// Drawing-Attribute Functions
    virtual COLORREF SetBkColor(COLORREF crColor);
    virtual COLORREF SetTextColor(COLORREF crColor);

// Mapping Functions
    virtual int SetMapMode(int nMapMode);
    virtual CPoint SetViewportOrg(int x, int y);
    virtual CPoint OffsetViewportOrg(int nWidth, int nHeight);
    virtual CSize SetViewportExt(int x, int y);
    virtual CSize ScaleViewportExt(int xNum, int xDenom, int yNum, int yDenom);
    virtual CSize SetWindowExt(int x, int y);
    virtual CSize ScaleWindowExt(int xNum, int xDenom, int yNum, int yDenom);

// Text Functions
    virtual BOOL TextOut(int x, int y, LPCTSTR lpszString, int nCount);
    virtual BOOL ExtTextOut(int x, int y, UINT nOptions, LPCRECT lpRect,
                LPCTSTR lpszString, UINT nCount, LPINT lpDxWidths);
    virtual CSize TabbedTextOut(int x, int y, LPCTSTR lpszString, int nCount,
                int nTabPositions, LPINT lpnTabStopPositions, int nTabOrigin);
    virtual int DrawText(LPCTSTR lpszString, int nCount, LPRECT lpRect,
                UINT nFormat);
    virtual BOOL GrayString(CBrush* pBrush,
                BOOL (CALLBACK* lpfnOutput)(HDC, LPARAM, int),
                    LPARAM lpData, int nCount,
                    int x, int y, int nWidth, int nHeight);

// Printer Escape Functions
    virtual int Escape(int nEscape, int nCount, LPCSTR lpszInData, LPVOID lpOutData);

// Implementation
protected:
    void MirrorMappingMode(BOOL bCompute);
    void MirrorViewportOrg();
    void MirrorFont();
    void MirrorAttributes();

    CSize ComputeDeltas(int& x, LPCTSTR lpszString, UINT& nCount, BOOL bTabbed,
                    UINT nTabStops, LPINT lpnTabStops, int nTabOrigin,
                    LPTSTR lpszOutputString, int* pnDxWidths, int& nRightFixup);

protected:
    int m_nScaleNum;    // Scale ratio Numerator
    int m_nScaleDen;    // Scale ratio Denominator
    int m_nSaveDCIndex; // DC Save index when Screen DC Attached
    int m_nSaveDCDelta; // delta between Attrib and output restore indices
    CSize m_sizeTopLeft;// Offset for top left corner of page
    HFONT m_hFont;      // Font selected into the screen DC (NULL if none)
    HFONT m_hPrinterFont; // Font selected into the print DC

    CSize m_sizeWinExt; // cached window extents computed for screen
    CSize m_sizeVpExt;  // cached viewport extents computed for screen
};

/////////////////////////////////////////////////////////////////////////////
// CPreviewView

class CDialogBar;

class CPreviewView : public CScrollView
{
    DECLARE_DYNCREATE(CPreviewView)

// Constructors
public:
    CPreviewView();
    BOOL SetPrintView(CView* pPrintView);

// Attributes
protected:
    CView* m_pOrigView;
    CView* m_pPrintView;
    CPreviewDC* m_pPreviewDC;  // Output and attrib DCs Set, not created
    CDC m_dcPrint;             // Actual printer DC

// Operations
    void SetZoomState(UINT nNewState, UINT nPage, CPoint point);
    void SetCurrentPage(UINT nPage, BOOL bClearRatios);

    // Returns TRUE if in a page rect. Returns the page index
    // in nPage and the point converted to 1:1 screen device coordinates
    BOOL FindPageRect(CPoint& point, UINT& nPage);


// Overridables
    virtual void OnActivateView(BOOL bActivate,
            CView* pActivateView, CView* pDeactiveView);

    // Returns .cx/.cy as the numerator/denominator pair for the ratio
    // using CSize for convenience
    virtual CSize CalcScaleRatio(CSize windowSize, CSize actualSize);

    virtual void PositionPage(UINT nPage);
    virtual void OnDisplayPageNumber(UINT nPage, UINT nPagesDisplayed);

// Implementation
public:
    virtual ~CPreviewView();
    virtual void OnPrepareDC(CDC* pDC, CPrintInfo* pInfo = NULL);
#ifdef _DEBUG
    void AssertValid() const;
    void Dump(CDumpContext& dc) const;
#endif

protected:
    //{{AFX_MSG(CPreviewView)
    afx_msg void OnPreviewClose();
    afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
    afx_msg void OnSize(UINT nType, int cx, int cy);
    afx_msg void OnDraw(CDC* pDC);
    afx_msg void OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
    afx_msg void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
    afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
    afx_msg BOOL OnEraseBkgnd(CDC* pDC);
    afx_msg void OnNumPageChange();
    afx_msg void OnNextPage();
    afx_msg void OnPrevPage();
    afx_msg void OnPreviewPrint();
    afx_msg void OnZoomIn();
    afx_msg void OnZoomOut();
    afx_msg void OnUpdateNumPageChange(CCmdUI* pCmdUI);
    afx_msg void OnUpdateNextPage(CCmdUI* pCmdUI);
    afx_msg void OnUpdatePrevPage(CCmdUI* pCmdUI);
    afx_msg void OnUpdateZoomIn(CCmdUI* pCmdUI);
    afx_msg void OnUpdateZoomOut(CCmdUI* pCmdUI);
    afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
    //}}AFX_MSG

    void DoZoom(UINT nPage, CPoint point);
    void SetScaledSize(UINT nPage);
    CSize CalcPageDisplaySize();

    CPrintPreviewState* m_pPreviewState; // State to restore
    CDialogBar* m_pToolBar; // Toolbar for preview

    struct PAGE_INFO
    {
        PAGE_INFO();
        CRect rectScreen; // screen rect (screen device units)
        CSize sizeUnscaled; // unscaled screen rect (screen device units)
        CSize sizeScaleRatio; // scale ratio (cx/cy)
        CSize sizeZoomOutRatio; // scale ratio when zoomed out (cx/cy)
    };

    PAGE_INFO* m_pPageInfo; // Array of page info structures
    PAGE_INFO m_pageInfoArray[2]; // Embedded array for the default implementation

    BOOL m_bPageNumDisplayed;// Flags whether or not page number has yet
                                // been displayed on status line
    UINT m_nZoomOutPages; // number of pages when zoomed out
    UINT m_nZoomState;
    UINT m_nMaxPages; // for sanity checks
    UINT m_nCurrentPage;
    UINT m_nPages;
    int m_nSecondPageOffset; // used to shift second page position

    HCURSOR m_hMagnifyCursor;

    CSize m_sizePrinterPPI; // printer pixels per inch
    CPoint m_ptCenterPoint;
    CPrintInfo* m_pPreviewInfo;

    DECLARE_MESSAGE_MAP()

    friend class CView;
    friend BOOL CALLBACK _AfxPreviewCloseProc(CFrameWnd* pFrameWnd);
};

// Zoom States
#define ZOOM_OUT    0
#define ZOOM_MIDDLE 1
#define ZOOM_IN     2

/////////////////////////////////////////////////////////////////////////////
// mirroring support

//WINBUG: some mirroring stuff will be in wingdi.h someday
#ifndef LAYOUT_RTL
#define LAYOUT_LTR                               0x00000000
#define LAYOUT_RTL                         0x00000001
#define NOMIRRORBITMAP                     0x80000000
#endif

//WINBUG: some mirroring stuff will be in winuser.h someday
#ifndef WS_EX_LAYOUTRTL
#define WS_EX_LAYOUTRTL                    0x00400000L
#endif


/////////////////////////////////////////////////////////////////////////////
// toolbar docking support

class CDockContext
{
public:
// Construction
    CDockContext(CControlBar* pBar);

// Attributes
    CPoint m_ptLast;            // last mouse position during drag
    CRect m_rectLast;
    CSize m_sizeLast;
    BOOL m_bDitherLast;

    // Rectangles used during dragging or resizing
    CRect m_rectDragHorz;
    CRect m_rectDragVert;
    CRect m_rectFrameDragHorz;
    CRect m_rectFrameDragVert;

    CControlBar* m_pBar;        // the toolbar that created this context
    CFrameWnd* m_pDockSite;     // the controlling frame of the CControlBar
    DWORD m_dwDockStyle;        // allowable dock styles for bar
    DWORD m_dwOverDockStyle;    // style of dock that rect is over
    DWORD m_dwStyle;            // style of control bar
    BOOL m_bFlip;               // if shift key is down
    BOOL m_bForceFrame;         // if ctrl key is down

    CDC* m_pDC;                 // where to draw during drag
    BOOL m_bDragging;
    int m_nHitTest;

    UINT m_uMRUDockID;
    CRect m_rectMRUDockPos;

    DWORD m_dwMRUFloatStyle;
    CPoint m_ptMRUFloatPos;

// Drag Operations
    virtual void StartDrag(CPoint pt);
    void Move(CPoint pt);       // called when mouse has moved
    void EndDrag();             // drop
    void OnKey(int nChar, BOOL bDown);

// Resize Operations
    virtual void StartResize(int nHitTest, CPoint pt);
    void Stretch(CPoint pt);
    void EndResize();

// Double Click Operations
    virtual void ToggleDocking();

// Operations
    void InitLoop();
    void CancelLoop();

// Implementation
public:
    ~CDockContext();
    BOOL Track();
    void DrawFocusRect(BOOL bRemoveRect = FALSE);
        // draws the correct outline
    void UpdateState(BOOL* pFlag, BOOL bNewValue);
    DWORD CanDock();
    CDockBar* GetDockBar(DWORD dwOverDockStyle);
};

/////////////////////////////////////////////////////////////////////////////
// CControlBarInfo - used for docking serialization

class CControlBarInfo
{
public:
// Implementation
    CControlBarInfo();

// Attributes
    UINT m_nBarID;      // ID of this bar
    BOOL m_bVisible;    // visibility of this bar
    BOOL m_bFloating;   // whether floating or not
    BOOL m_bHorz;       // orientation of floating dockbar
    BOOL m_bDockBar;    // TRUE if a dockbar
    CPoint m_pointPos;  // topleft point of window

    UINT m_nMRUWidth;   // MRUWidth for Dynamic Toolbars
    BOOL m_bDocking;    // TRUE if this bar has a DockContext
    UINT m_uMRUDockID;  // most recent docked dockbar
    CRect m_rectMRUDockPos; // most recent docked position
    DWORD m_dwMRUFloatStyle; // most recent floating orientation
    CPoint m_ptMRUFloatPos; // most recent floating position

    CPtrArray m_arrBarID;   // bar IDs for bars contained within this one
    CControlBar* m_pBar;    // bar which this refers to (transient)

    void Serialize(CArchive& ar, CDockState* pDockState);
    BOOL LoadState(LPCTSTR lpszProfileName, int nIndex, CDockState* pDockState);
    BOOL SaveState(LPCTSTR lpszProfileName, int nIndex);
};

/////////////////////////////////////////////////////////////////////////////
// CDockBar - used for docking

class CDockBar : public CControlBar
{
    DECLARE_DYNAMIC(CDockBar)

// Construction
public:
    CDockBar(BOOL bFloating = FALSE);   // TRUE if attached to CMiniDockFrameWnd
    BOOL Create(CWnd* pParentWnd, DWORD dwStyle, UINT nID);

// Attributes
    BOOL m_bFloating;

    virtual BOOL IsDockBar() const;
    int GetDockedCount() const;
    virtual int GetDockedVisibleCount() const;

// Operations
    void DockControlBar(CControlBar* pBar, LPCRECT lpRect = NULL);
    void ReDockControlBar(CControlBar* pBar, LPCRECT lpRect = NULL);
    BOOL RemoveControlBar(CControlBar*, int nPosExclude = -1, int nAddPlaceHolder = 0);
    void RemovePlaceHolder(CControlBar* pBar);

// Implementation
public:
    virtual ~CDockBar();
#ifdef _DEBUG
    virtual void AssertValid() const;
    virtual void Dump(CDumpContext& dc) const;
#endif
    virtual CSize CalcFixedLayout(BOOL bStretch, BOOL bHorz);
    virtual void DoPaint(CDC* pDC);

    // public implementation helpers
    void GetBarInfo(CControlBarInfo* pInfo);
    void SetBarInfo(CControlBarInfo* pInfo, CFrameWnd* pFrameWnd);
    int FindBar(CControlBar* pBar, int nPosExclude = -1);
    void ShowAll(BOOL bShow);

    CPtrArray m_arrBars;    // each element is a CControlBar
protected:
    BOOL m_bLayoutQuery;
    CRect m_rectLayout;

    CControlBar* GetDockedControlBar(int nPos) const;

    // implementation helpers
    int Insert(CControlBar* pBar, CRect rect, CPoint ptMid);
    virtual void OnUpdateCmdUI(CFrameWnd* pTarget, BOOL bDisableIfNoHndler);

    //{{AFX_MSG(CDockBar)
    afx_msg void OnNcCalcSize(BOOL bCalcValidRects, NCCALCSIZE_PARAMS* lpncsp);
    afx_msg void OnNcPaint();
    afx_msg void OnWindowPosChanging(LPWINDOWPOS lpWndPos);
    afx_msg void OnPaint();
    afx_msg LRESULT OnSizeParent(WPARAM, LPARAM);
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()

    friend class CMiniDockFrameWnd;
};

class CMiniDockFrameWnd : public CMiniFrameWnd
{
    DECLARE_DYNCREATE(CMiniDockFrameWnd)

public:
// Construction
    CMiniDockFrameWnd();
    virtual BOOL Create(CWnd* pParent, DWORD dwBarStyle);

// Operations
    virtual void RecalcLayout(BOOL bNotify = TRUE);

// Implementation
public:
    CDockBar m_wndDockBar;

    //{{AFX_MSG(CMiniFrameWnd)
    afx_msg void OnClose();
    afx_msg void OnNcLButtonDown(UINT nHitTest, CPoint point);
    afx_msg void OnNcLButtonDblClk(UINT nHitTest, CPoint point);
    //}}AFX_MSG
    afx_msg int OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message);
    DECLARE_MESSAGE_MAP()
};

/////////////////////////////////////////////////////////////////////////////
// COleCntrFrameWnd

class COleIPFrameWnd;

class COleCntrFrameWnd : public CFrameWnd
{
// Constructor
public:
    COleCntrFrameWnd(COleIPFrameWnd* pInPlaceFrame);

// Implementation
protected:
    COleIPFrameWnd* m_pInPlaceFrame;
    virtual void PostNcDestroy();

public:
    virtual ~COleCntrFrameWnd();
    virtual void RecalcLayout(BOOL bNotify = TRUE);
    void OnIdleUpdateCmdUI();
    virtual BOOL OnCmdMsg(UINT nID, int nCode, void* pExtra,
        AFX_CMDHANDLERINFO* pHandlerInfo);
#ifdef _DEBUG
    void AssertValid() const;
#endif
};

/////////////////////////////////////////////////////////////////////////////
// CDialogTemplate

class CDialogTemplate
{
// Constructors
public:
    CDialogTemplate(const DLGTEMPLATE* pTemplate = NULL);
    CDialogTemplate(HGLOBAL hGlobal);

// Attributes
    BOOL HasFont() const;
    BOOL SetFont(LPCTSTR lpFaceName, WORD nFontSize);
    BOOL SetSystemFont(WORD nFontSize = 0);
    BOOL GetFont(CString& strFaceName, WORD& nFontSize) const;
    void GetSizeInDialogUnits(SIZE* pSize) const;
    void GetSizeInPixels(SIZE* pSize) const;

    static BOOL AFX_CDECL GetFont(const DLGTEMPLATE* pTemplate,
        CString& strFaceName, WORD& nFontSize);

// Operations
    BOOL Load(LPCTSTR lpDialogTemplateID);
    HGLOBAL Detach();

// Implementation
public:
    ~CDialogTemplate();

    HGLOBAL m_hTemplate;
    DWORD m_dwTemplateSize;
    BOOL m_bSystemFont;

protected:
    static BYTE* AFX_CDECL GetFontSizeField(const DLGTEMPLATE* pTemplate);
    static UINT AFX_CDECL GetTemplateSize(const DLGTEMPLATE* pTemplate);
    BOOL SetTemplate(const DLGTEMPLATE* pTemplate, UINT cb);
};

/////////////////////////////////////////////////////////////////////////////
// WM_NOTIFY support

struct AFX_NOTIFY
{
    LRESULT* pResult;
    NMHDR* pNMHDR;
};

/////////////////////////////////////////////////////////////////////////////
// Global implementation helpers

// window creation hooking
void AFXAPI AfxHookWindowCreate(CWnd* pWnd);
BOOL AFXAPI AfxUnhookWindowCreate();
void AFXAPI AfxResetMsgCache();

// for backward compatibility to previous versions
#define _AfxHookWindowCreate    AfxHookWindowCreate
#define _AfxUnhookWindowCreate  AfxUnhookWindowCreate

// string helpers
void AFXAPI AfxSetWindowText(HWND hWndCtrl, LPCTSTR lpszNew);
int AFXAPI AfxLoadString(UINT nIDS, LPTSTR lpszBuf, UINT nMaxBuf = 256);

HDC AFXAPI AfxCreateDC(HGLOBAL hDevNames, HGLOBAL hDevMode);

void AFXAPI AfxGetModuleShortFileName(HINSTANCE hInst, CString& strShortName);

// Failure dialog helpers
void AFXAPI AfxFailMaxChars(CDataExchange* pDX, int nChars);
void AFXAPI AfxFailRadio(CDataExchange* pDX);

// DLL load helpers
HINSTANCE AFXAPI AfxLoadDll(HINSTANCE* volatile hInst, LPCSTR lpszDLL);
HINSTANCE AFXAPI AfxLoadDll(HINSTANCE* volatile hInst, LPCSTR lpszDLL,
    FARPROC* pProcPtrs, LPCSTR lpszProcName);

#ifndef __AFXCONV_H__
#include <afxconv.h>
#endif

/////////////////////////////////////////////////////////////////////////////

#ifdef _AFX_PACKING
#pragma pack(pop)
#endif

#undef AFX_DATA
#define AFX_DATA

#ifdef _AFX_MINREBUILD
#pragma component(minrebuild, on)
#endif
#ifndef _AFX_FULLTYPEINFO
#pragma component(mintypeinfo, off)
#endif

#endif // __AFXPRIV_H__

/////////////////////////////////////////////////////////////////////////////

#ifndef __AFXPRIV2_H__
#include <afxpriv2.h>
#endif