window.cpp

Go to the documentation of this file.

/*
        Copyright 2003 Joseph Alvis

    This file is part of Aswang.

    Aswang is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Aswang is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with Aswang.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "window.h"

using namespace aswang;

window::wmap_type window::wmap;
HINSTANCE window::hInstance;

void window::Add() {
        wmap[hWnd] = this;
}

void window::Erase() {
        wmap_type::iterator it = wmap.find(hWnd);
        if(it != wmap.end())
                it=wmap.erase(it);
}

void window::Create(int x,int y,int width,int height) {
        hWnd=CreateWindow(GetClassName(),TEXT(""),style,x,y,width,height,(mParent!=NULL?mParent->hWnd:NULL),NULL,hInstance,NULL);
}

void window::Show(int showCommand) {
        ShowWindow(hWnd,showCommand);
}

void window::Transparent(bool t) const {
        if(hWnd!=NULL) {
                UINT style = GetWindowLong(hWnd,GWL_EXSTYLE);
                if(t)
                        style &= WS_EX_TRANSPARENT;
                else
                        style |= ~WS_EX_TRANSPARENT;
                SetWindowLong(hWnd,GWL_EXSTYLE,style);
        }
}

window *window::GetWindow(HWND h) {
        wmap_type::iterator it = wmap.find(h);
        if(it != wmap.end())
                return it->second;
        return NULL;
}

AswangStr window::GetText() const {
        AswangStr str;
        if(hWnd) {
                unsigned long len = GetWindowTextLength(hWnd)+1;
                _TCHAR *s=new _TCHAR[len];
                GetWindowText(hWnd,s,len);
                str=s;
                delete[] s;
        }
        return str;
}

void window::SetText(AswangStr s) const {
        if(hWnd) {
                SetWindowText(hWnd,s.c_str());
        }
}

long window::GetWindowX() const {
        if(hWnd != NULL) {
                RECT r;
                GetWindowRect(hWnd,&r);
                return r.left;
        }
        return 0;
}

long window::GetWindowY() const {
        if(hWnd != NULL) {
                RECT r;
                GetWindowRect(hWnd,&r);
                return r.top;
        }
        return 0;
}

long window::GetWindowWidth() const {
        if(hWnd != NULL) {
                RECT r;
                GetWindowRect(hWnd,&r);
                return (r.right-r.left);
        }
        return 0;
}

long window::GetWindowHeight() const {
        if(hWnd != NULL) {
                RECT r;
                GetWindowRect(hWnd,&r);
                return (r.bottom-r.top);
        }
        return 0;
}

long window::GetClientWidth() const {
        if(hWnd != NULL) {
                RECT r;
                GetClientRect(hWnd,&r);
                return (r.right-r.left);
        }
        return 0;
}

long window::GetClientHeight() const {
        if(hWnd != NULL) {
                RECT r;
                GetClientRect(hWnd,&r);
                return (r.bottom-r.top);
        }
        return 0;
}

void window::Center() const {
        if(hWnd) {
                HWND ph = ::GetParent(hWnd);
                if(ph==NULL)
                        ph=GetDesktopWindow();
                RECT pr,tr;
                GetClientRect(ph,&pr);
                GetWindowRect(hWnd,&tr);
                SetWindowPos(hWnd,NULL,
                        (((pr.right-pr.left)/2)-((tr.right-tr.left)/2)),
                        (((pr.bottom-pr.top)/2)-((tr.bottom-tr.top)/2)),
                        0,0,SWP_NOSIZE|SWP_NOZORDER);
        }
}

void window::SetAlignment(Alignment a) {
        if(hWnd!=NULL) {
                long style = GetWindowLong(hWnd,GWL_STYLE);
                style &= ~(ES_LEFT|ES_RIGHT|ES_CENTER);
                switch(a) {
                        case ALIGN_LEFT:
                                style |= ES_LEFT;
                                break;
                        case ALIGN_RIGHT:
                                style |= ES_RIGHT;
                                break;
                        case ALIGN_CENTER:
                                style |= ES_CENTER;
                                break;
                }
                SetWindowLong(hWnd,GWL_STYLE,style);
        }
}

void window::Invalidate() {
        if(hWnd!=NULL) {
                RECT r;
                GetClientRect(hWnd,&r);
                InvalidateRect(hWnd,&r,true);
        }
}

void window::Update() {
        if(hWnd!=NULL) {
                UpdateWindow(hWnd);
        }
}

void window::Move(int x,int y) {
        if(hWnd!=NULL) {
                SetWindowPos(hWnd,NULL,x,y,0,0,SWP_NOZORDER|SWP_NOSIZE);
        }
}

void window::Resize(int width,int height) {
        if(hWnd!=NULL) {
                SetWindowPos(hWnd,NULL,0,0,width,height,SWP_NOZORDER|SWP_NOMOVE);
        }
}

void window::SetStyle(unsigned long s) {
        style=s;
        if(hWnd!=NULL)
                SetWindowLong(hWnd,GWL_STYLE,s);
}

unsigned long window::GetStyle() {
        if(hWnd!=NULL)
                style = GetWindowLong(hWnd,GWL_STYLE);
        return style;
}

LRESULT CALLBACK window::WProc(HWND h,UINT msg,WPARAM wParam,LPARAM lParam) {
        window *w = GetWindow(h);
        if(w != NULL) {
                callbackMap_type::iterator cit;
                if(!w->callbackMap.empty() && (cit=w->callbackMap.find(msg)) != w->callbackMap.end()) {
                        window *p = (cit->second.first?GetWindow(cit->second.first):w);
                        if(p)
                                return (p->*(cit->second.second))(w,msg,lParam,wParam);
                        else
                                w->RemoveCallback(msg);
                }
                switch(msg) {
                        case WM_CAPTURECHANGED:
                                return w->OnMouseOut((HWND)lParam);
                        case WM_CHAR:
                                return w->OnChar((TCHAR)wParam,(LONG)lParam);
                        case WM_CLOSE:
                                return w->OnClose();
                        case WM_COMMAND:
                                return w->OnCommand((HWND)lParam,HIWORD(wParam),LOWORD(wParam));
                        case WM_CTLCOLORBTN:
                                return w->OnButtonColor((HDC)wParam,(HWND)lParam);
                        case WM_CTLCOLORDLG:
                                return w->OnDialogColor((HDC)wParam,(HWND)lParam);
                        case WM_CTLCOLORSTATIC:
                                return w->OnStaticColor((HDC)wParam,(HWND)lParam);
                        case WM_DESTROY:
                                return w->OnDestroy(h);
                        case WM_DRAWITEM:
                                return w->OnDrawItem((LONG)wParam,(DRAWITEMSTRUCT *)lParam);
                        case WM_ERASEBKGND:
                                return w->OnEraseBG((HDC)wParam);
                        case WM_GETDLGCODE:
                                return w->OnGetDlgCode((LONG)wParam,(MSG *)lParam);
                        case WM_INITDIALOG:
                                return w->OnInitDialog((HWND)wParam,(LONG)lParam);
                        case WM_KEYDOWN:
                                return w->OnKeyDown((LONG)wParam,(LONG)lParam);
                        case WM_KEYUP:
                                return w->OnKeyUp((LONG)wParam,(LONG)lParam);
                        case WM_LBUTTONDBLCLK:
                                return w->OnLDClick((LONG)wParam,MAKEPOINTS(lParam));
                        case WM_LBUTTONDOWN:
                                return w->OnLDown((LONG)wParam,MAKEPOINTS(lParam));
                        case WM_LBUTTONUP:
                                return w->OnLUp((LONG)wParam,MAKEPOINTS(lParam));
                        case WM_MEASUREITEM:
                                return w->OnMeasureItem((LONG)wParam,(LPMEASUREITEMSTRUCT)lParam);
                        case WM_MOUSEMOVE:
                                return w->OnMouseOver((LONG)wParam,MAKEPOINTS(lParam));
                        case WM_MOVE:
                                return w->OnMove((LONG)wParam,(LONG)lParam);
                        case WM_NCPAINT:
                                return w->OnNCPaint((HRGN)wParam);
                        case WM_NCHITTEST:
                                return w->OnNCHitTest(MAKEPOINTS(lParam));
                        case WM_NOTIFY:
                                return w->OnNotify((LONG)wParam,(NMHDR *)lParam);
                        case WM_PAINT:
                                return w->OnPaint();
                        case WM_PARENTNOTIFY:
                                if(LOWORD(wParam) == WM_CREATE || LOWORD(wParam) == WM_DESTROY)
                                        return w->OnParentNotifyCreate(LOWORD(wParam),HIWORD(wParam),(HWND)lParam);
                                else
                                        return w->OnParentNotifyClick(LOWORD(wParam),LOWORD(lParam),HIWORD(lParam));
                        case WM_RBUTTONDBLCLK:
                                return w->OnRDClick((LONG)wParam,MAKEPOINTS(lParam));
                        case WM_RBUTTONDOWN:
                                return w->OnRDown((LONG)wParam,MAKEPOINTS(lParam));
                        case WM_RBUTTONUP:
                                return w->OnRUp((LONG)wParam,MAKEPOINTS(lParam));
                        case WM_SHOWWINDOW:
                                return w->OnShow((wParam==1),(LONG)lParam);
                        case WM_SIZE:
                                return w->OnSize((LONG)wParam,LOWORD(lParam),HIWORD(lParam));
                        case WM_SIZING:
                                return w->OnSizing((LONG)wParam,(RECT *)lParam);
                        case WM_TIMER:
                                return w->OnTimer((LONG)wParam,(TIMERPROC)lParam);
                        case WM_WINDOWPOSCHANGED:
                                return w->OnPosChanged((WINDOWPOS *)lParam);
                        default:
                                return w->OnFail(msg,wParam,lParam);
                }
        }
        else if(msg == WM_CREATE) {
                CREATESTRUCT *cs = (LPCREATESTRUCT) lParam;
                if(cs->lpCreateParams != NULL) {
                        w=(window *)cs->lpCreateParams;
                        w->hWnd=h;
                        w->Add();
                        callbackMap_type::iterator cit;
                        if(!w->callbackMap.empty() && (cit=w->callbackMap.find(msg)) != w->callbackMap.end()) {
                                window *p = (cit->second.first?GetWindow(cit->second.first):w);
                                if(p)
                                        return (p->*(cit->second.second))(w,msg,lParam,wParam);
                                else
                                        w->RemoveCallback(msg);
                        }
                }
        }
        else if(msg == WM_INITDIALOG && lParam!=NULL) {
                w=(window *)lParam;
                if(w) {
                        w->hWnd=h;
                        w->Add();
                        callbackMap_type::iterator cit;
                        if(!w->callbackMap.empty() && (cit=w->callbackMap.find(msg)) != w->callbackMap.end()) {
                                window *p = (cit->second.first?GetWindow(cit->second.first):w);
                                if(p)
                                        return (p->*(cit->second.second))(w,msg,lParam,wParam);
                                else
                                        w->RemoveCallback(msg);
                        }
                        return w->OnInitDialog((HWND)wParam,(LONG)lParam);
                }
        }
        return DefWindowProc(h,msg,wParam,lParam);
}

int window::Loop() {
        MSG msg;
        while(GetMessage(&msg,NULL,0,0) > 0) {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
        }
        return (int)msg.wParam;
}

LRESULT window::OnClose() {
        if(mParent == NULL) {
                PostQuitMessage(0);
                return 0;
        }
        return OnFail(WM_CLOSE,0,0);
}

LRESULT window::OnPaint() {
        return OnFail(WM_PAINT,0,0);
}

LRESULT window::OnLDown(unsigned int flags,POINTS p) {
        return OnFail(WM_LBUTTONDOWN,flags,(LPARAM)&p);
}

LRESULT window::OnLUp(unsigned int flags,POINTS p) {
        return OnFail(WM_LBUTTONUP,flags,(LPARAM)&p);
}

LRESULT window::OnLDClick(unsigned int flags,POINTS p) {
        return OnFail(WM_LBUTTONDBLCLK,flags,(LPARAM)&p);
}

LRESULT window::OnRDown(unsigned int flags,POINTS p) {
        return OnFail(WM_RBUTTONDOWN,flags,(LPARAM)&p);
}

LRESULT window::OnRUp(unsigned int flags,POINTS p) {
        return OnFail(WM_RBUTTONUP,flags,(LPARAM)&p);
}

LRESULT window::OnRDClick(unsigned int flags,POINTS p) {
        return OnFail(WM_RBUTTONDBLCLK,flags,(LPARAM)&p);
}

LRESULT window::OnMouseOut(HWND NewWindow) {
        return OnFail(WM_CAPTURECHANGED,0,(LPARAM)NewWindow);
}

LRESULT window::OnMouseOver(unsigned int flags,POINTS p) {
        return OnFail(WM_MOUSEMOVE,flags,(LPARAM)&p);
}

LRESULT window::OnCommand(HWND win,unsigned short Notify,unsigned short wID) {
        WPARAM wParam=MAKELONG(wID,Notify);
        return OnFail(WM_COMMAND,wParam,(LPARAM)win);
}

LRESULT window::OnButtonColor(HDC dc,HWND btn) {
        if(hWnd != btn) {
                window *w = GetWindow(btn);
                if(w != NULL)
                        return w->OnButtonColor(dc,btn);
        }
        return OnFail(WM_CTLCOLORBTN,(WPARAM)dc,(LPARAM)btn);
}

LRESULT window::OnStaticColor(HDC dc,HWND sttc) {
        if(hWnd != sttc) {
                window *w = GetWindow(sttc);
                if(w != NULL)
                        return w->OnStaticColor(dc,sttc);
        }
        return OnFail(WM_CTLCOLORSTATIC,(WPARAM)dc,(LPARAM)sttc);
}

LRESULT window::OnDialogColor(HDC dc,HWND dlg) {
        if(hWnd != dlg) {
                window *w = GetWindow(dlg);
                if(w != NULL)
                        return w->OnDialogColor(dc,dlg);
        }
        return OnFail(WM_CTLCOLORDLG,(WPARAM)dc,(LPARAM)dlg);
}

LRESULT window::OnShow(bool show,long Status) {
        return OnFail(WM_SHOWWINDOW,show,Status);
}

LRESULT window::OnGetDlgCode(long VirtKey,MSG *m) {
        return OnFail(WM_GETDLGCODE,VirtKey,(LPARAM)m);
}

LRESULT window::OnKeyUp(long VirtKey,long flags) {
        return OnFail(WM_KEYUP,VirtKey,flags);
}

LRESULT window::OnKeyDown(long VirtKey,long flags) {
        return OnFail(WM_KEYDOWN,VirtKey,flags);
}

LRESULT window::OnChar(TCHAR c,long flags) {
        return OnFail(WM_CHAR,c,flags);
}

LRESULT window::OnSize(unsigned long flag,unsigned short NewWidth,unsigned short NewHeight) {
        return OnFail(WM_SIZE,flag,MAKELONG(NewWidth,NewHeight));
}

LRESULT window::OnSizing(unsigned long side,RECT *r) {
        return OnFail(WM_SIZING,side,(LPARAM)r);
}

LRESULT window::OnNotify(unsigned long ID,NMHDR *nmh) {
        return OnFail(WM_NOTIFY,ID,(LPARAM)nmh);
}

LRESULT window::OnInitDialog(HWND win,unsigned long param) {
        return OnFail(WM_INITDIALOG,(LPARAM)win,param);
}

LRESULT window::OnDrawItem(unsigned long ID,DRAWITEMSTRUCT *dis) {
        return OnFail(WM_DRAWITEM,ID,(LPARAM)dis);
}

LRESULT window::OnMove(unsigned long NewX,unsigned long NewY) {
        return OnFail(WM_MOVE,NewX,NewY);
}

LRESULT window::OnNCPaint(HRGN region) {
        return OnFail(WM_NCPAINT,(LPARAM)region,0);
}

LRESULT window::OnPosChanged(WINDOWPOS *wpos) {
        return OnFail(WM_WINDOWPOSCHANGED,0,(LPARAM)wpos);
}

LRESULT window::OnEraseBG(HDC dc) {
        if((bool)bg) {
                RECT r;
                GetClientRect(hWnd,&r);
                FillRect(dc,&r,bg.GetBrush());
                return 1;
        }
        return OnFail(WM_ERASEBKGND,(LPARAM)dc,0);
}

LRESULT window::OnNCHitTest(POINTS pos) {
        return OnFail(WM_NCHITTEST,0,MAKELONG(pos.x,pos.y));
}

LRESULT window::OnTimer(unsigned long id,TIMERPROC tproc) {
        return OnFail(WM_TIMER,id,(LPARAM)tproc);
}

LRESULT window::OnDestroy(HWND win) {
        return OnFail(WM_DESTROY,NULL,NULL);
}

LRESULT window::OnParentNotifyCreate(unsigned short event,unsigned short wID,HWND win) {
        return OnFail(WM_PARENTNOTIFY,MAKEWPARAM(event,wID),(LPARAM)win);
}

LRESULT window::OnParentNotifyClick(unsigned short event,short x,short y) {
        return OnFail(WM_PARENTNOTIFY,MAKEWPARAM(event,0),MAKELPARAM(x,y));
}

LRESULT window::OnMeasureItem(long ctlID,MEASUREITEMSTRUCT *mis) {
        return OnFail(WM_MEASUREITEM,ctlID,(LPARAM)mis);
}

LRESULT window::OnFail(UINT msg,WPARAM wParam,LPARAM lParam) {
        return DefWindowProc(hWnd,msg,wParam,lParam);
}