Ving vgl::gui & vgl::frame(曲折到只是想贴下代码而已..)

嗯嗯- -b  rt.

/**/ /*  frame.h :os::frame */

#ifndef APPFRAME__

#define  APPFRAME__

#include  < windows.h >
#include  < tchar.h >
#include  < stdio.h >

#include  " axiom.h "
#include  " string.h "
#include  " geo.h "
#include  " runtime.h "

#include  " vector.h "



namespace  gui
{
    class component
    {
    public:
        arith::point pos;/**//*position*/
        int isvis;/**//*is visible*/
        double getx();
        double gety();
        arith::point getpos();

    };

    class gtext:public component
    {
        adt::ustring text;
    public:
        gtext(adt::ustring _t,int x,int y,int isv=1);

    };
    class gbutton:public component
    {
    public:
        geo::polygon figure;
        adt::ustring text;
        COLORREF bklist[5];
        gbutton(int _x,int _y);

        int isIn(int _x,int _y);


    };
    class compoList
    {
    public:
        int i;
        adt::vector<gbutton*> buttonList;
        adt::vector<gtext*> textList;
    };

}

namespace  appinfo
{

    static const int max_form=500;

    static int iCmdShow,regNum,listIndex;
    static HINSTANCE hInstance;
    static HINSTANCE hPrevInstance;
    static PSTR szCmdLine;
    static MSG  msg;
    /**//* register windowclass-name */
    static TCHAR regList[max_form][4];

    static void decform();
    static void incform();
    static void setListIndex(int & reg_index,LPCWSTR & wc_name);
    static gui::compoList controlList[appinfo::max_form];


}
namespace  frame
{


    using adt::ustring;

    using adt::vector;
    using arith::point;
    using geo::polygon;



    class compoList;
    class form;
    //using namespace adt;

    
    namespace api
    {

        class def
        {
        public:
            static const int nil =0;
            static const int sm_x = 0;
            static const int sm_y = 1;
            static const int wm_create=WM_CREATE;
            static const int wm_paint=WM_PAINT;
            static const int wm_destroy=WM_DESTROY;
            static const int wm_mousemove=WM_MOUSEMOVE;
            static const int wm_lbuttondown=WM_LBUTTONDOWN;
            static const int wm_lbuttonup=WM_LBUTTONUP;
            static const int wm_lbuttondblclk=WM_LBUTTONDBLCLK;

            static const unsigned int cs_default= CS_HREDRAW | CS_VREDRAW ;
        };
        namespace type
        {
            typedef HDC__* hdc;
            typedef HWND hwnd;
            typedef ustring string;
            typedef UINT uint;
            typedef RECT rect;
            typedef LPRECT lprc;
            typedef WPARAM wp;
            typedef LPCWSTR lpcwstr;
            typedef LPARAM lp;
            typedef PAINTSTRUCT ps;
            typedef LPPAINTSTRUCT lpps;
            typedef BYTE byte;
            typedef LONG_PTR result;
            typedef WNDCLASS wndclass;
            typedef HICON hicon;
            typedef HCURSOR hcursor;
            typedef HBRUSH__* hbrush;
            typedef HINSTANCE hinstance;
            typedef PSTR  pstr;
            typedef MSG msg;
            typedef TCHAR tchar;
            typedef BOOL state;
            typedef POINT point;
        }
        namespace handle
        {
            type::hicon icon(int i=0);
            type::hcursor cursor(int i=0);
            type::hbrush brush(int i=WHITE_BRUSH);

        }
        class paint
        {
        public:
            type::hdc hdc;
            type::rect rect;
            type::hwnd hwnd;
            type::ps ps;
            bool ready;
            paint():ready(false){}
            ~paint();
            type::hdc begin(type::hwnd & hwnd);
            int end();
            int text(type::string & tx);
            type::state polygon(type::point *apt,int i,int m=WHITE_BRUSH);
            type::state rectangle(int x,int y,int w,int h);
            type::state line(int x,int y,int x_,int y_);



        };
        class mouse
        {
        public:
            static double x(type::lp & lp);
            static double y(type::lp & lp);

        };
        class sm
        {
        public:
            static int screeny();
            static int screenx();

        };
        class message
        {
        public:
        };
        class proc
        {
        public:
            type::hwnd hwnd;
            type::uint msg;
            type::wp wp;
            type::lp lp;

            proc(){}
            proc(type::hwnd &hwnd_t,type::uint &msg_t,type::wp &wp_t,type::lp &lp_t);
            void update(type::hwnd &hwnd_t,type::uint &msg_t,type::wp &wp_t,type::lp &lp_t);
            type::result defproc();
            void postquit(int exitCode_t=0);
        };
        class bitmap
        {
        public:
         HBITMAP hBitmap ;
        
        HDC            hdcMem ;    
        int           cxBitmap, cyBitmap;

        public:
            int begin(HWND hwnd);
            void setPixel(int x,int y,COLORREF cl=RGB(100,0,0));
            int paint(HWND hwnd,int cxClient,int cyClient);
            int end();
            void getLargestDisplayMode (int *pcxBitmap, int * pcyBitmap);
    

        };
        static void d2s(wchar_t s[],double d,int p=2);
    


        class wndclass
        {
        public:
            type::hwnd   hwnd ;
            type::hwnd   parenthwnd;
            type::string  title;
            type::wndclass wc;/**//* wndclass info */
            int regIndex;/**//* self-wndclass index in regList */


            static type::result __stdcall wndproc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);
            void init();
            wndclass();
            ~wndclass();
            void setStyle(UINT style);
            void setIcon(HICON hIcon);
            void setCursor(HCURSOR hCursor);
            void setBackground(HBRUSH hbr);
            int renew();
            void setTitle(wchar_t  _title[]);
    
        };
    }
    class form
    {
        api::wndclass tf;
    public:

        form();
        ~form();
        form(wchar_t *title);
        int add(gui::gtext & control_gtext);
        int show();
    
    };
}
int  cpp();
int  WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,PSTR szCmdLine,  int  iCmdShow);



#endif

实现部分:

/**/ /* frame.cpp os::frame*/

#include  " appframe.h "


namespace  gui
{
    double component::getx()
    {
        return pos.x_;
    }
    double component::gety()
    {
        return pos.y_;
    }
    arith::point component::getpos()
    {
        return pos;
    }
    gtext::gtext(adt::ustring _t,int x,int y,int isv)
    {
        pos.set(x,y);
        isvis=isv;
        text=_t;
    }
    gbutton::gbutton(int _x,int _y)
    {
        pos.x_=_x;
        pos.y_=_y;
        figure.push(0,0);
        figure.push(0,50);
        figure.push(100,50);
        figure.push(100,0);
        figure.add(_x,_y);
        text<<"Button";
        bklist[0]=RGB(12,0,0);
        bklist[1]=RGB(41,12,44);
        bklist[2]=RGB(111,111,111);
    }
    int gbutton::isIn(int _x,int _y)
    {
        return figure.isIn(_x,_y);
    }
}

namespace  appinfo
{
    void decform()
    {
        --regNum;
    }    
    void incform()
    {
        ++regNum;
    }
    void setListIndex(int & reg_index,LPCWSTR & wc_name)
    {
        reg_index=listIndex;
        regList[listIndex][0]=1;
        regList[listIndex][1]=reg_index;
        regList[listIndex][2]=0;
        wc_name=regList[listIndex];
        ++listIndex;
        ++regNum;
    }
}
namespace  frame
{


    namespace api
    {

        type::hicon handle::icon(int i)
        {
            return  LoadIcon (NULL, IDI_APPLICATION);
        }
        type::hcursor handle::cursor(int i)
        {
            return  LoadCursor (NULL, IDC_ARROW);
        }
        type::hbrush handle::brush(int i)
        {
            return (type::hbrush) GetStockObject (i);
        }
        paint::~paint()
        {
            if(ready!=false)
                end();
            ready=false;
        }
        type::hdc paint::begin(type::hwnd & hwnd)
        {                
            ready=true;
            hdc = BeginPaint(hwnd,&ps);
            GetClientRect (hwnd, &rect);

            return (hdc );
        }
        int paint::end()
        {
            ready=false;
            return EndPaint(hwnd,&ps);
        }
        int paint::text(type::string & tx)
        {
            if(ready)
                return DrawTextW (hdc, tx(), -1, &rect,
                DT_SINGLELINE | DT_CENTER | DT_VCENTER) ;
            else return 0;
        }
        type::state paint::rectangle(int x,int y,int w,int h)
        {
            int sx=sm::screenx();
            int sy=sm::screeny();
            return Rectangle (hdc,x,y,x+w, y+h) ;
        }
        type::state paint::polygon(type::point *apt,int i,int m)
        {
            SelectObject(hdc,GetStockObject(m));
            return Polygon(hdc,apt,i) ;
        }
        type::state paint::line(int x,int y,int x_,int y_)
        {
            MoveToEx (hdc, x, y, NULL) ;

            return LineTo (hdc, x_, y_) ;

        }
        double mouse::x(type::lp & lp)
        {
            return LOWORD(lp) ;
        }
        double mouse::y(type::lp & lp)
        {
            return HIWORD(lp) ;

        }
        int sm::screenx()
        {
            return GetSystemMetrics(def::sm_x); 
        }
        int sm::screeny()
        {
            return GetSystemMetrics(def::sm_y); 
        }
        proc::proc(type::hwnd &hwnd_t,type::uint &msg_t,type::wp &wp_t,type::lp &lp_t)
        {
            update(hwnd_t,msg_t,wp_t,lp_t);
        }
        void proc::update(type::hwnd &hwnd_t,type::uint &msg_t,type::wp &wp_t,type::lp &lp_t)
        {
            hwnd=hwnd_t;
            msg=msg_t;
            wp=wp_t;
            lp=lp_t;
        }
        type::result proc::defproc()
        {
            return DefWindowProcW (hwnd, msg, wp, lp); 
        }

        void proc::postquit(int exitCode_t)
        {
            if(appinfo::regNum==1)
            {

                --appinfo::regNum;
                PostQuitMessage(exitCode_t);
            }else
            {
                --appinfo::regNum;
            }
        }
        int bitmap::begin(HWND hwnd)
        {
            getLargestDisplayMode (&cxBitmap, &cyBitmap) ;


            HDC  hdc = GetDC (hwnd) ;

            hBitmap = CreateCompatibleBitmap (hdc, cxBitmap, cyBitmap) ;

            hdcMem  = CreateCompatibleDC (hdc) ;

            ReleaseDC (hwnd, hdc) ;


            if (!hBitmap)                                // no memory for bitmap

            {

                DeleteDC (hdcMem) ;

                return -1 ;

            }


            SelectObject (hdcMem, hBitmap) ;

            PatBlt (hdcMem, 0, 0, cxBitmap, cyBitmap, WHITENESS) ;
            return 0 ;
        }

        void bitmap::setPixel(int x,int y,COLORREF cl)
        {
            SetPixel(hdcMem,x,y,cl);

        }
        int bitmap::paint(HWND hwnd,int cxClient,int cyClient)
        {

            PAINTSTRUCT ps;
            HDC hdc = BeginPaint (hwnd, &ps) ;

            BitBlt (hdc, 0, 0, cxClient, cyClient, hdcMem, 0, 0, SRCCOPY) ;

            EndPaint (hwnd, &ps) ;
            return 1;
        }
        int bitmap::end()
        {
            DeleteDC (hdcMem) ;

            DeleteObject (hBitmap) ;
            return 1;
        }
        void bitmap::getLargestDisplayMode (int *pcxBitmap, int * pcyBitmap)
        {

            DEVMODE       devmode ;

            int           iModeNum = 0 ;


            * pcxBitmap =  *pcyBitmap = 0 ;


            ZeroMemory (&devmode, sizeof (DEVMODE)) ;

            devmode.dmSize = sizeof (DEVMODE) ;



            while (EnumDisplaySettings (NULL, iModeNum++, &devmode))

            {

                *pcxBitmap = max ( *pcxBitmap, (int) devmode.dmPelsWidth) ;

                *pcyBitmap = max ( *pcyBitmap, (int) devmode.dmPelsHeight) ;

            }

        }
        static void d2s(wchar_t s[],double d,int p)
        {


            int i,a;
            for(int j=0;s[j]!=0;j++)
                if(s[j]=='.')
                {
                    i=1;
                }
                if(p==0)
                {
                    a=d;
                    for(i=0;a/10.0>0.0;i++)
                    {

                        s[i]=(wchar_t)(10*(a/10.0-(int)(a/10))+48);
                        a/=10;
                    }

                }else
                {
                    a=(int)(d*pow(10.0,p));
                    for(i=0;i!=p;i++)
                    {
                        s[i]=(wchar_t)(10*(a/10.0-(int)(a/10))+48);
                        a/=10;
                    }
                    s[p]=(wchar_t)'.';

                    for(i=p+1;a/10.0>0.0;i++)
                    {
                        s[i]=(wchar_t)(10*(a/10.0-(int)(a/10))+48);
                        a/=10;
                    }
                }
                s[i]=0;
                a=i-1;
                i=0;
                char t;
                for(;i<a;i++,a--)
                {
                    t=s[i];
                    s[i]=s[a];
                    s[a]=t;
                }
        }
        type::result __stdcall  wndclass::wndproc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
        {

            static proc proc;
            static paint pt;


            using geo::polygon;
            static polygon plg;

            static int temp=0;
            static int cxClient, cyClient, x, y;

            static POINT apt[6];

            static gui::gbutton button(100,100);

            static bitmap bm;

            static wchar_t buf[20];

            proc.update(hwnd,message,wParam,lParam);



            switch (message)
            {

            case   WM_SIZE:


                cxClient = LOWORD (lParam) ;

                cyClient = HIWORD (lParam) ;

                for(int y=0;y!=cyClient;y++)
                {
                    for(int x=0;x!=cxClient;x++)
                    {
                        bm.setPixel(x,y,RGB(111,0,4));
                    }
                }
                InvalidateRect(hwnd,0,TRUE); 
                return 0;
            case WM_TIMER:

                return 0;
            case api::def::wm_lbuttondown:
                x=mouse::x(lParam),y=mouse::y(lParam);



                InvalidateRect(hwnd,NULL,TRUE); 
                return 0;
            case api::def::wm_create:

                bm.begin(hwnd);

                return 0 ;
            case api::def::wm_mousemove:

                x=mouse::x(lParam),y=mouse::y(lParam);


                return 0;

            case api::def::wm_paint:



                bm.paint(hwnd,cxClient,cyClient);
                return 0;

            case api::def::wm_destroy:
                bm.end();
                proc.postquit();
                return 0 ;

            }
            return proc.defproc();
        }
        void wndclass::init()
        {
            wc.style         = def::cs_default;
            wc.lpfnWndProc   = wndproc ;
            wc.cbClsExtra    = def::nil ;
            wc.cbWndExtra    = def::nil ;
            wc.hInstance     = appinfo::hInstance ;
            wc.hIcon         = handle::icon() ;
            wc.hCursor       = handle::cursor();
            wc.hbrBackground = handle::brush();
            wc.lpszMenuName  = def::nil;

            appinfo::setListIndex(regIndex,wc.lpszClassName);

            if (!RegisterClassW (&wc))
                return ;
        }
        wndclass::wndclass()
        {

            init();
        }
        wndclass::~wndclass()
        {
            appinfo::decform();
        }
        void wndclass::setStyle(UINT style)
        {
            wc.style = style;
        }
        void wndclass::setIcon(HICON hIcon)
        {
            wc.hIcon = hIcon;
        }
        void wndclass::setCursor(HCURSOR hCursor)
        {
            wc.hCursor = hCursor;
        }
        void wndclass::setBackground(HBRUSH hbr)
        {
            wc.hbrBackground = hbr;
        }
        int wndclass::renew()
        {
            hwnd = CreateWindowW(appinfo::regList[regIndex],      // window class name
                title(),   // window caption
                WS_OVERLAPPEDWINDOW,  // window style
                CW_USEDEFAULT,// initial x position
                CW_USEDEFAULT,// initial y position
                CW_USEDEFAULT,// initial x size
                CW_USEDEFAULT,// initial y size
                NULL,                 // parent window handle
                NULL,            // window menu handle
                appinfo::hInstance,   // program instance handle
                NULL) ;      // creation parameters
            return 1;

        }
        void wndclass::setTitle(wchar_t  _title[])
        {
            title.set(_title);
        }
    }
    form::form()
    {


        tf.setTitle(TEXT("ving"));
        tf.init();
        tf.renew();
    }
    form::~form()
    {
    }
    form::form(wchar_t *title)
    {
        tf.setTitle(title);
        tf.init();
        tf.renew();
    }

    int form::add(gui::gtext & control_gtext)
    {
    
        appinfo::controlList[tf.regIndex].textList.push(&control_gtext);
        return 1;
    }
    int form::show()
    {
        tf.renew();
        int scx=api::sm::screenx(); 
        int scy=api::sm::screeny(); 
        SetWindowPos(tf.hwnd,NULL,scx/3 ,scx/3 ,scx/3,scy/3,SWP_HIDEWINDOW);
        ShowWindow (tf.hwnd, appinfo::iCmdShow) ;
        UpdateWindow (tf.hwnd) ;
        return 1;
    }

}


int  WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,PSTR szCmdLine,  int  iCmdShow)
{

    appinfo::regNum=0;
    appinfo::listIndex=0;
    appinfo::hInstance=hInstance;
    appinfo::hPrevInstance=hPrevInstance;
    appinfo::szCmdLine=szCmdLine;
    appinfo::iCmdShow=iCmdShow;

    cpp();

    while (GetMessageW(&appinfo::msg, NULL, 0, 0))
    {
        TranslateMessage (&appinfo::msg) ;
        DispatchMessage (&appinfo::msg) ;
    }
    return (int)appinfo::msg.wParam ;
}

史上最短小的demo:

/**/ /**/ /**/ /* init.h  */

#include  " appframe.h "
// #include "component.h"

int  cpp()
{
    
    using frame::form;
    using gui::gtext;
    form f;
    

    adt::ustring s(L"ving");
    gtext text(s,100,150);
    f.add(text);
    
    f.show();
    return 0;
}

睡觉....zzzZZzz。