/*  Copyright (C) Chris Johns (ccj@acm.org)  MicroWindows C++ Wrappers. */#if !defined (_MWOBJECTS_H_)#define _MWOBJECTS_H_extern "C" {  #include "windows.h"#include "wintern.h"#include "graph3d.h"};#include <set>#include <iostream>namespace MicroWindowsObjects{  class FileDescriptor;  //  // Manage Window Classes. Notice you do not need to specify  // a Window Procedure function pointer. This is handled for   // you.  //  class WindowClass  {  public:        WindowClass ();    WindowClass (LPCSTR    lpszClassName,                 UINT      style = CS_DBLCLKS | CS_VREDRAW | CS_HREDRAW,                 int       cbClsExtra = 0,                 int       cbWndExtra = 0,                 HINSTANCE hInstance = 0,                 HICON     hIcon = 0,                 HCURSOR   hCursor = 0,                 HBRUSH    hbrBackground = 0,                 LPCSTR    lpszMenuName = 0);        void set_style (UINT style)      { wclass.style = style; }    void set_class_extra (int cbClsExtra)      { wclass.cbClsExtra = cbClsExtra; }    void set_window_extra (int cbWndExtra)      { wclass.cbWndExtra = cbWndExtra; }    void set_instance (HINSTANCE hInstance)      { wclass.hInstance = hInstance; }    void set_icon (HICON hIcon)      { wclass.hIcon = hIcon; }    void set_cursor (HCURSOR hCursor)      { wclass.hCursor = hCursor; }    void set_background (HBRUSH hbrBackground)      { wclass.hbrBackground = hbrBackground; }    void set_menu_name (LPCSTR lpszMenuName)      { wclass.lpszMenuName = lpszMenuName; }        ATOM register_class ();      private:    //    // This variable is a local copy which is     // registered. After that is class does little.    //    WNDCLASS wclass;  };    class Window  {    friend WindowClass;      public:    Window ();    Window (DWORD     dwExStyle,            LPCSTR    lpClassName,            LPCSTR    lpWindowName,            DWORD     dwStyle,            int       x,             int       y,            int       nWidth,            int       nHeight,            HWND      hwndParent,            HMENU     hMenu,            HINSTANCE hInstance,            LPVOID    lpParam);    virtual ~Window ();        HWND create (DWORD     dwExStyle,                 LPCSTR    lpClassName,                 LPCSTR    lpWindowName,                 DWORD     dwStyle,                 int       x,                  int       y,                 int       nWidth,                 int       nHeight,                 HWND      hwndParent,                 HMENU     hMenu,                 HINSTANCE hInstance,                 LPVOID    lpParam);    BOOL destory ();    HWND get_handle () const      { return hwnd; }    operator HWND () const      { return get_handle (); }            BOOL is_visible ()      { return IsWindowVisible (hwnd); }    BOOL show (int nCmdShow)      { return ::ShowWindow (hwnd, nCmdShow); }    BOOL update ()      { return ::UpdateWindow (hwnd); }    BOOL invalidate_rect (CONST RECT *lpRect, BOOL bErase)      { return ::InvalidateRect (hwnd, lpRect, bErase); }    HWND get_focus ()      { return ::GetFocus (); }    HWND set_focus ()      { return ::SetFocus (hwnd); }    BOOL move (int x, int y, int nWidth, int nHeight, BOOL bRepaint)      { return MoveWindow (hwnd, x, y, nWidth, nHeight, bRepaint); }    // FIXME: Should these be here ?    BOOL client_to_screen (LPPOINT lpPoint)      { return ::ClientToScreen (hwnd, lpPoint); }    BOOL screen_to_client (LPPOINT lpPoint)      { return ::ClientToScreen (hwnd, lpPoint); }    LONG get_long (int nIndex)      { return ::GetWindowLong (hwnd, nIndex); }    LONG set_long (int nIndex, LONG wNewLong)      { return ::SetWindowWord (hwnd, nIndex, wNewLong); }    WORD get_word (int nIndex)      { return ::GetWindowWord (hwnd, nIndex); }    WORD set_word (int nIndex, WORD wNewWord)      { return ::SetWindowWord (hwnd, nIndex, wNewWord); }    DWORD get_class_long (int nIndex)      { return ::GetClassLong (hwnd, nIndex); }    int get_text (LPSTR lpString, int nMaxCount)      { return GetWindowText (hwnd, lpString, nMaxCount); }    BOOL set_text (LPCSTR lpString)      { return SetWindowText (hwnd, lpString); }    //    // File Descriptor handlers.    //    virtual bool attach (const int fd, FileDescriptor& file_descriptor);    virtual bool detach (FileDescriptor& file_descriptor);  protected:    //    // The message handler. Insure you call this class's default    // handler for default message handling so any special    // filtering can occur.    //    virtual LRESULT message_handler (UINT   msg,                                     WPARAM wParam,                                     LPARAM lParam);  private:    //    // We only need one WndProc.    //    static LRESULT CALLBACK WndProc (HWND hwnd, UINT msg, WPARAM wp, LPARAM lp);    HWND   hwnd;    LPVOID lpCreateParams;        //    // Set of FileDescriptor objects    //    struct ltint     {      bool operator() (const FileDescriptor* f1, const FileDescriptor* f2) const;    };    set<FileDescriptor*, ltint> file_descriptors;      };    class Rect  {  public:    Rect ()       { empty (); }    Rect (int xLeft, int yTop, int xRight, int yBottom)       { set (xLeft, yTop, xRight, yBottom); }    Rect (HWND hwnd)      { get_window (hwnd); }            BOOL get_window (HWND hwnd)       { return GetWindowRect (hwnd, &rect); }    BOOL get_client (HWND hwnd)       { return GetClientRect (hwnd, &rect); }    BOOL set (int xLeft, int yTop, int xRight, int yBottom)      { return ::SetRect (&rect, xLeft, yTop, xRight, yBottom); }    BOOL empty ()       { return ::SetRectEmpty (&rect); }    Rect& operator= (const Rect& other)      { CopyRect (&rect, &other.rect); return *this; }    operator bool () const      { return ::IsRectEmpty (&rect); }    operator RECT* ()      { return &rect; }            BOOL copy (LPRECT lpRectDst)      { return ::CopyRect (lpRectDst, &rect); }    BOOL inflate (int dx, int dy)       { return ::InflateRect (&rect, dx, dy); }    BOOL offset (int dx, int dy)      { return ::OffsetRect (&rect, dx, dy); }    BOOL point_inside (POINT Point)      { return PtInRect (&rect, Point); }    MWCOORD left () const      { return rect.left; }    MWCOORD top () const      { return rect.top; }    MWCOORD right () const      { return rect.right; }    MWCOORD bottom () const      { return rect.bottom; }          private:    RECT rect;  };  inline ostream& operator<< (ostream& s, const Rect& r) {    s << "rect"      << "(l=" << r.left ()  << ",t=" << r.top ()      << ",r=" << r.right () << ",b=" << r.bottom ()      << ")";    return s;  }  //  // Generic Paint class. Try to help the paint message.  //  class Paint  {  public:    enum { TEXT_BUF_SIZE = 512 };        Paint (HWND hwnd);    Paint (HWND hwnd, LPARAM lpParam);    virtual ~Paint ();        //    // These begin and end a paint session.    //    void begin (bool init_3d = false, bool draw_3d_in_memory = false);    void end ();        //    // Aspects of the client paint area under our control.    //    operator HWND ()       { return hwnd; }    operator RECT* ()      { return r; }    operator HDC ()       { return hdc; }    operator PAINTSTRUCT* ()       { return &ps; }    operator POINT* ()       { return &pt; }    GDICOORD get_point_x () const      { return pt.x; }    GDICOORD get_point_y () const      { return pt.y; }        MWCOORD left () const      { return r.left (); }    MWCOORD top () const      { return r.top (); }    MWCOORD right () const      { return r.right (); }    MWCOORD bottom () const      { return r.bottom (); }        //    // Colour Control.    //    DWORD get_system_colour (int nIndex)      { return ::GetSysColor (nIndex); }        //    // Pixel, line and rectange draw support.    //    COLORREF set_pixel (int x, int y, COLORREF crColour)      { return ::SetPixel (hdc, x, y, crColour); }    BOOL move_to (int x, int y)      { return ::MoveToEx (hdc, x, y, 0); }    BOOL line_to (int x, int y)      { return ::LineTo (hdc, x, y); }    BOOL line_to (int x1, int y1, int x2, int y2)      { if (!move_to (x1, y1)) return FALSE;        return line_to (x2, y2); }    BOOL rectangle (int x1, int y1, int x2, int y2)      { return ::Rectangle (hdc, x1, y1, x2, y2); }    BOOL fill_rectangle (int x1, int y1, int x2, int y2, HBRUSH hbr)      { Rect r (x1, y1, x2, y2);        return ::FillRect (hdc, r, hbr); }        //    // Paint any 3d objects.    //    void initialise_3d (bool draw_3d_in_mem)       { if (!draw_3d) {         draw_3d = true; ::init3 (hdc, draw_3d_in_mem ? hwnd : 0); } }    void paint_3d ()      { if (draw_3d) { ::paint3 (hdc); draw_3d = false; } }            //    // Text Output.    //    void set_text_fromat (UINT uFormat)        { text_format = uFormat; }         int text_out (int x, int y, const char *format, ...);  private:    HWND        hwnd;    bool        draw_3d;    bool        drawing;    Rect        r;    HDC         hdc;    PAINTSTRUCT ps;    POINT       pt;    UINT        text_format;        char        format_buf[TEXT_BUF_SIZE];      };  //  // FileDescriptor handles fd event from the  User Registered File   // Descriptor support.  //  class FileDescriptor  {    friend class Window;      public:    FileDescriptor ();    virtual ~FileDescriptor ();    //    // Enable/disable controls.    //    bool enable_read ();    bool disable_read ();    bool read_enabled () const      { return read_is_enabled; }        bool enable_write ();    bool disable_write ();    bool write_enabled () const      { return write_is_enabled; }        bool enable_except ();    bool disable_except ();    bool except_enabled () const      { return except_is_enabled; }        int fd () const      { return file_desc; }        operator int () const      { return fd (); }        const Window *get_window () const      { return window; }      protected:    //    // These are called in responce to user fd messages to the window.    //    virtual LRESULT read ();    virtual LRESULT write ();    virtual LRESULT except ();      private:    int    file_desc;    bool   read_is_enabled;    bool   write_is_enabled;    bool   except_is_enabled;    Window *window;      };    class Application  {  public:      Application ();    Application (MWIMAGEHDR& background);    virtual ~Application ();        HINSTANCE instance () const      { return app_instance; }        HINSTANCE prev_instance () const      { return app_prev_instance; }    LPSTR cmd_line () const      { return app_cmd_line; }    int show_cmd ()      { return app_show_cmd; }            //    // This is called the public C linkage WinMain. Do not call.    //    static int WINAPI WinMain (HINSTANCE hInstance,                                HINSTANCE hPrevInstance,                                LPSTR     lpCmdLine,                               int       nShowCmd);  protected:        virtual int initialise ();    virtual int shutdown ();  private:        MWIMAGEHDR  *background;    HINSTANCE app_instance;    HINSTANCE app_prev_instance;    LPSTR     app_cmd_line;    int       app_show_cmd;  };}#endif