/*
 * CLASSLIB.H
 * Sample Code Class Libraries
 *
 * Master include file for our own Class Library containing:
 *  CStringTable    Class that manages a stringtable.
 *  CHourglass      Class to manage the hourglass.
 *
 *  CWindow         Basic window class for most other classes in here
 *  CGizmoBar       Wrapper for GizmoBar control
 *  CStatStrip      Wrapper for StatStrip control
 *
 *  CFrame          Frame window
 *  CClient         Client window with a uniform interface for
 *                  MDI and SDI frames.
 *  CDocument       Document window, also with a uniform interface
 *                  for MDI and SDI.
 *
 *  CDocumentAdviseSink Object implemented in the frame that the
 *                      document notifies of important events.
 *
 * Copyright (c)1993-1996 Microsoft Corporation, All Rights Reserved
 *
 * Kraig Brockschmidt, Software Design Engineer
 * Microsoft Systems Developer Relations
 *
 * Internet  :  kraigb@microsoft.com
 * Compuserve:  >INTERNET:kraigb@microsoft.com
 */


#ifndef _CLASSLIB_H_
#define _CLASSLIB_H_

#include <book1632.h>

//Get default resource definitions
#include "classres.h"


class CStringTable;
class CHourglass;
class CGizmoBar;
class CStatStrip;
class CWindow;
class CFrame;
class CClient;
class CDocument;
class CDocumentAdviseSink;
class CHatchWin;


/**
 ** CStringTable providing string table management for anyone.
 **/

class CStringTable
    {
    protected:
        HINSTANCE       m_hInst;
        UINT            m_idsMin;
        UINT            m_idsMax;
        USHORT          m_cStrings;
        LPTSTR          m_pszStrings;
        LPTSTR         *m_ppszTable;

    public:
        CStringTable(HINSTANCE);
        ~CStringTable(void);

        BOOL FInit(UINT, UINT);

        //Function to resolve an ID into a string pointer.
        const LPTSTR operator [](const UINT) const;
    };


typedef CStringTable *PCStringTable;

/*
 * Typical classes that initialize a stringtable should have an m_pST
 * member, then they can use this macro conveniently.
 */

#define PSZ(i) ((*m_pST)[i])
#define CCHSTRINGMAX            256


/**
 ** CHourglass:  Manages the hourglass and mouse capture
 **/

class CHourglass
    {
    protected:
        HWND            m_hWndCapture;      //Window with capture
        HCURSOR         m_hCur;             //Cursor held.

    public:
        CHourglass(void);
        CHourglass(HWND);
        ~CHourglass(void);
    };

typedef CHourglass *PCHourglass;



/**
 ** CWindow:  Our basic window class.
 **/

class CWindow
    {
    protected:
        HINSTANCE   m_hInst;            //Task instance
        HWND        m_hWnd;             //Window handle of the window

    public:
        //Standard Class Functions
        CWindow(HINSTANCE);
        ~CWindow(void);

        //Just returns m_hWnd.  No need to modify
        HWND Window(void);
    };


typedef CWindow * PCWindow;




/**
 ** CGizmoBar encapculates a GizmoBar control
 **/

#include <bttncur.h>
#include <gizmobar.h>


class CGizmoBar : public CWindow
    {
    protected:
        UINT            m_cyBar;

    public:
        CGizmoBar(HINSTANCE);
        ~CGizmoBar(void);

        BOOL FInit(HWND, UINT, UINT);

        //Window message wrappers
        void   OnSize(HWND);
        void   FontSet(HFONT, BOOL);
        HFONT  FontGet(void);
        void   Enable(BOOL);

        //GizmoBar function wrappers
        HWND   HwndAssociateSet(HWND);
        HWND   HwndAssociateGet(void);

        BOOL   Add(UINT, UINT, UINT, UINT, UINT, LPTSTR, HBITMAP
                   , UINT, UINT);
        BOOL   Remove(UINT);

        LONG   SendMessage(UINT, UINT, WPARAM, LPARAM);

        BOOL   Show(UINT, BOOL);
        BOOL   Enable(UINT, BOOL);
        BOOL   Check(UINT, BOOL);
        UINT   FocusSet(UINT);
        BOOL   Exist(UINT);

        int    TypeGet(UINT);

        DWORD  DataSet(UINT, DWORD);
        DWORD  DataGet(UINT);
        BOOL   NotifySet(UINT, BOOL);
        BOOL   NotifyGet(UINT);

        int    TextGet(UINT, LPTSTR, UINT);
        void   TextSet(UINT, LPTSTR);
        UINT   IntGet(UINT, BOOL *, BOOL);
        void   IntSet(UINT, int, BOOL);
    };


typedef CGizmoBar *PCGizmoBar;





/**
 ** CStatStrip encapsulates a StatStrip control.
 **/

#include <stastrip.h>


class CStatStrip : public CWindow
    {
    protected:
        UINT        m_cy;           //Control height

    public:
        CStatStrip(HINSTANCE);
        ~CStatStrip(void);

        BOOL FInit(HWND, UINT, UINT);

        void  OnSize(HWND);
        void  MessageSet(LPTSTR);
        UINT  MessageGet(LPTSTR, UINT);
        UINT  MessageGetLength(void);
        void  FontSet(HFONT, BOOL);
        HFONT FontGet(void);
        void  Enable(BOOL);

        BOOL  MessageMap(HWND, HINSTANCE, UINT, UINT, UINT, UINT
                  , UINT, UINT, UINT, UINT, UINT);
        void  MenuSelect(WPARAM, LPARAM);
        void  MessageDisplay(UINT);
    };

typedef CStatStrip *PCStatStrip;





/**
 ** CFrame encapsulates a main application window
 **/

//FRAMEWIN.CPP:  Standard window procedure and AboutProc
LRESULT APIENTRY FrameWndProc(HWND, UINT, WPARAM, LPARAM);
BOOL    APIENTRY AboutProc(HWND, UINT, WPARAM, LPARAM);

#define CBFRAMEWNDEXTRA     sizeof(LONG)
#define FRAMEWL_STRUCTURE   0


/*
 * Structure containing resource ranges for initialization of
 * a CFrame object through its FInit member.
 */

typedef struct tagFRAMEINIT
    {
    UINT    idsMin;         //Stringtable start and end
    UINT    idsMax;

    UINT    idsStatMin;     //StatStrip stringtable start and end
    UINT    idsStatMax;

    UINT    idStatMenuMin;  //Start and end IDs for StatStrip
    UINT    idStatMenuMax;  //popup menu IDs

    UINT    iPosWindowMenu; //Position of the Window menu (MDI init)
    UINT    cMenus;         //Number of popup menus we have.

    int     x;              //Window positioning.
    int     y;
    int     cx;
    int     cy;
    } FRAMEINIT, *PFRAMEINIT;



//FRAME.CPP:  Frame object that creates a main window

class CFrame : public CWindow
    {
    //Let our window procedure look in our private variables.
    friend LRESULT APIENTRY FrameWndProc(HWND, UINT, WPARAM, LPARAM);
    friend class CDocumentAdviseSink;

    protected:
        HINSTANCE       m_hInstPrev;        //WinMain parameters
        LPTSTR          m_pszCmdLine;
        int             m_nCmdShow;

        BOOL            m_fInit;            //Initializing or closing
        BOOL            m_fSizing;          //Inside WM_SIZE
        BOOL            m_fClosing;         //In WM_CLOSE

        BOOL            m_fLastEnable;      //Toolbar enable state
        BOOL            m_fLastPaste;

        HMENU          *m_phMenu;           //Popup menu handles
        HMENU           m_hMenuWindow;      //"Window" menu

        HACCEL          m_hAccel;           //Accelerators
        HBITMAP         m_hBmp;             //Gizmobar images
        UINT            m_cyBar;            //Gizmobar height
        UINT            m_dxB;              //Gizmobar button sizes
        UINT            m_dyB;

        PCGizmoBar      m_pGB;              //GizmoBar
        PCStatStrip     m_pSS;              //StatStrip

        PCStringTable   m_pST;              //Stringtable.
        CClient        *m_pCL;              //SDI/MDI client window

        CDocumentAdviseSink *m_pAdv;    //Sink for document codes

    protected:
        virtual CClient *CreateCClient(void);

        virtual BOOL     FRegisterAllClasses(void);
        virtual BOOL     FPreShowInit(void);
        virtual void     ParseCommandLine(void);
        virtual UINT     CreateGizmos(void);

        virtual BOOL     FMessageHook(HWND, UINT, WPARAM, LPARAM
                             , LRESULT *);
        virtual LRESULT  OnCommand(HWND, WPARAM, LPARAM);
        virtual void     OnDocumentDataChange(CDocument *);
        virtual void     OnDocumentActivate(CDocument *);

        virtual BOOL     FSaveOpenDialog(LPTSTR, UINT, UINT, BOOL
                             , UINT *);
        virtual UINT     ReplaceCharWithNull(LPTSTR, int);
        virtual LPTSTR   PszWhiteSpaceScan(LPTSTR, BOOL);

    public:
        CFrame(HINSTANCE, HINSTANCE, LPSTR, int);
        virtual ~CFrame(void);

        virtual BOOL     FInit(PFRAMEINIT);

        virtual WPARAM   MessageLoop(void);
        virtual BOOL     FAskAndSave(LPTSTR);
        virtual void     UpdateMenus(HMENU, UINT);
        virtual void     UpdateGizmos(void);
        virtual void     WindowTitleSet(CDocument *, BOOL);

        virtual PCStatStrip inline GetStatusControl(void);
    };


typedef CFrame *PCFrame;


//Other Miscellaneous CFrame definitions

//GizmoBar and StatStrip IDs used in this frame
#define ID_GIZMOBAR         11
#define ID_STATSTRIP        12

//Classname
#define SZCLASSFRAME        TEXT("Frame")





/**
 ** CClient encapsulates an MDI or SDI client window
 **/


//CLIENT.CPP
LRESULT APIENTRY SDIClientWndProc(HWND, UINT, WPARAM, LPARAM);



#define CBCLIENTWNDEXTRA    sizeof(LONG)
#define CLIENTWL_HWNDDOC    0


class CClient : public CWindow
    {
    friend LRESULT APIENTRY SDIClientWndProc(HWND, UINT, WPARAM
        , LPARAM);

    protected:
        PCFrame         m_pFR;          //Frame window information
        UINT            m_cDoc;         //Count of open documents
        CDocument *     m_pDocLast;     //Last created document

    private:
        //This non-overridable sets m_pDocLast
        CDocument         * CreateDoc(void);

    protected:
        //Overridable for creating a new CDocument
        virtual CDocument * CreateCDocument(void);

    public:
        CClient(HINSTANCE);
        virtual ~CClient(void);

        virtual BOOL            FInit(HMENU, LPRECT, PCFrame);

        virtual BOOL            TranslateAccelerator(LPMSG);
        virtual LRESULT         DefaultFrameProc(HWND, UINT, WPARAM
                                    , LPARAM);
        virtual void            OnWindowCommand(UINT, UINT);
        virtual void            OnSize(UINT, UINT, UINT, UINT);

        virtual CDocument *     NewDocument(BOOL
                                    , CDocumentAdviseSink *);
        virtual CDocument *     ActiveDocument(void);
        virtual BOOL            ShowDocument(CDocument *, BOOL);
        virtual BOOL            SDIVerify(void);
        virtual UINT            CloseDocument(CDocument *);
        virtual BOOL            QueryCloseAllDocuments(BOOL);
        virtual BOOL            FCleanVerify(CDocument *);
    };


typedef CClient *PCClient;


//Other Miscellaneous CFrame definitions

//Document window identifiers
#define ID_DOCUMENT         999     //Internal ID for all documents
#define ID_MDICHILDMIN      1000    //Starting point for MDI doc IDs

#define SZCLASSSDICLIENT    TEXT("SDIClient")




/**
 ** CDocument encapsulates an MDI or SDI child window
 **/


//DOCWIN.CPP
LRESULT APIENTRY DocumentWndProc(HWND, UINT, WPARAM, LPARAM);


//DOCUMENT.CPP
//File-related string lengths.
#define CCHPATHMAX          256
#define CCHFILENAMEMAX      15


//Window extra bytes and offsets
#define CBDOCUMENTWNDEXTRA  sizeof(LONG)
#define DOCWL_STRUCTURE     0


//Error codes from Load and Save functions
#define DOCERR_NONE                     0
#define DOCERR_NOFILE                   1
#define DOCERR_COULDNOTOPEN             2
#define DOCERR_READFAILURE              3
#define DOCERR_UNSUPPORTEDVERSION       4
#define DOCERR_WRITEFAILURE             5
#define DOCERR_CANCELLED                6
#define DOCERR_STDMAX                   6




/*
 * Structure containing resource ranges and other data for
 * initialization of a CDocument object through its FInit member.
 */

typedef struct tagDOCUMENTINIT
    {
    UINT        idsMin;    //Stringtable start and end
    UINT        idsMax;
    HWND        hWndDoc;   //HWND of this document, created in client

    CDocumentAdviseSink * pAdv;
    } DOCUMENTINIT, *PDOCUMENTINIT;



class CDocument : public CWindow
    {
    friend LRESULT APIENTRY DocumentWndProc(HWND, UINT, WPARAM
        , LPARAM);

    protected:
        PCFrame         m_pFR;                //Back pointer
        UINT            m_cf;                 //Clipboard format
        BOOL            m_fDirty;             //Is file dirty?
        BOOL            m_fNoDirty;           //Don't touch dirty flag
        BOOL            m_fNoSize;            //Prevent sizing
        BOOL            m_fFileKnown;         //File/Save allowed?
        TCHAR           m_szFile[CCHPATHMAX]; //Filename for Save

        PCStringTable   m_pST;                //Document strings

        /*
         * If someone above us wants information, they'll
         * give us this object.
         */
        class CDocumentAdviseSink * m_pAdv;

    protected:
        virtual BOOL     FMessageHook(HWND, UINT, WPARAM, LPARAM
                             , LRESULT *);

    public:
        CDocument(HINSTANCE, PCFrame);
        virtual ~CDocument(void);

        virtual BOOL     FInit(PDOCUMENTINIT);

        virtual BOOL     FDirtySet(BOOL);
        virtual BOOL     FDirtyGet(void);
        virtual void     Clear(void);

        virtual UINT     ULoad(BOOL, LPTSTR);
        virtual UINT     USave(UINT, LPTSTR);
        virtual void     ErrorMessage(UINT);

        virtual BOOL     FClip(HWND, BOOL);
        virtual HGLOBAL  RenderFormat(UINT);
        virtual BOOL     FQueryPaste(void);
        virtual BOOL     FPaste(HWND);
        virtual void     Undo(void);

        virtual BOOL     FQuerySave(void);
        virtual void     Rename(LPTSTR);
        virtual UINT     FilenameGet(LPTSTR, UINT);
        virtual PCFrame  FrameGet(void);
    };

typedef CDocument *PCDocument;


//Classname for documents, not localized
#define SZCLASSDOCUMENT     TEXT("document")


//Macro that isolates us from MDI or SDI Def procs
#ifdef MDI
#define DEFDOCUMENTPROC     DefMDIChildProc
#else
#define DEFDOCUMENTPROC     DefWindowProc
#endif


//Message to get PCDocument from hWnd
#define DOCM_PDOCUMENT      (WM_USER+0)


/**
 ** CDocumentAdviseSink through which a document notifies the
 ** frame or important events.
 **/

class CDocumentAdviseSink
    {
    protected:
        LPVOID      m_pv;               //Customizable structure

    public:
        CDocumentAdviseSink(LPVOID);

        virtual void OnDataChange(PCDocument);
        virtual void OnCloseRequest(PCDocument);
        virtual void OnSizeChange(PCDocument, LPRECT);
        virtual void OnCaptionChange(PCDocument);
        virtual void OnActivate(PCDocument);
    };

typedef CDocumentAdviseSink *PCDocumentAdviseSink;


/**
 ** CHatchWin when used as a parent window creates a thin
 ** hatch border around the child window.
 **/

BOOL FHatchWindowRegister(HINSTANCE);

//Classname
#define SZCLASSHATCHWIN                 TEXT("hatchwin")

//Window extra bytes and offsets
#define CBHATCHWNDEXTRA                 (sizeof(LONG))
#define HWWL_STRUCTURE                  0

//Notification codes for WM_COMMAND messages
#define HWN_BORDERDOUBLECLICKED         1

//Width of the border
#define HATCHWIN_BORDERWIDTHDEFAULT     4


class CHatchWin : public CWindow
    {
    friend LRESULT APIENTRY HatchWndProc(HWND, UINT, WPARAM, LPARAM);

    public:
        int         m_dBorder;
        UINT        m_uID;
        HWND        m_hWndKid;
        HWND        m_hWndAssociate;

    public:
        CHatchWin(HINSTANCE);
        ~CHatchWin(void);

        BOOL      FInit(HWND, UINT, HWND);

        HWND      HwndAssociateSet(HWND);
        HWND      HwndAssociateGet(void);

        void      RectsSet(LPRECT, LPRECT);
        void      ChildSet(HWND);
    };

typedef CHatchWin *PCHatchWin;


#endif //_CLASSLIB_H_
