window.c

在ｅｃｏｓ 下mingui 的移植开发

    if (fGetDC)
        ReleaseDC (hdc);
}

// this function is CONTROL safe.
static void wndDrawNCFrame(MAINWIN* pWin, HDC hdc, const RECT* prcInvalid)
{
    BOOL fGetDC = FALSE;
    
    if (hdc == 0) {
        hdc = GetDC ((HWND)pWin);
        fGetDC = TRUE;
    }
        
    if (prcInvalid)
        ClipRectIntersect (hdc, prcInvalid);

    wndDrawNCArea (pWin, hdc);

    wndDrawScrollBar (pWin, hdc);

    if (pWin->WinType == TYPE_MAINWIN) {
        wndDrawCaption (pWin, hdc, !(pWin->dwStyle & WS_DISABLED) 
            && (GetActiveWindow() == (HWND)pWin));
        DrawMenuBarHelper (pWin, hdc, prcInvalid);
    }
    else {
        wndDrawCaption (pWin, hdc, !(pWin->dwStyle & WS_DISABLED) && 
                ((PCONTROL)pWin)->pParent->active == (PCONTROL)pWin);
    }

    if (fGetDC)
        ReleaseDC (hdc);
}

// this function is CONTROL safe.
static void wndActiveMainWindow (PMAINWIN pWin, BOOL fActive)
{
    HDC hdc;

    hdc = GetDC ((HWND)pWin);

    wndDrawCaption (pWin, hdc, fActive);
        
    ReleaseDC (hdc);
}

static void OnShowWindow (PMAINWIN pWin, int iShowCmd)
{
    PCONTROL pCtrl;
    
    if (iShowCmd != SW_HIDE) {
        
        pCtrl = (PCONTROL)(pWin->hFirstChild);

        while (pCtrl) {
            ShowWindow ((HWND)pCtrl, iShowCmd);

            pCtrl = pCtrl->next;
        }
    }
}

static int DefaultPaintMsgHandler(PMAINWIN pWin, int message,
                           WPARAM wParam, LPARAM lParam)
{
    switch( message )
    {
        case MSG_SHOWWINDOW:
            OnShowWindow (pWin, (int)wParam);
        break;
        
        case MSG_NCPAINT:
            wndDrawNCFrame (pWin, (HDC)wParam, (const RECT*)lParam);
        break;

        case MSG_ERASEBKGND:
            wndEraseBackground (pWin, (HDC)wParam, (const RECT*)lParam);
        break;

        case MSG_NCACTIVATE:
            wndActiveMainWindow (pWin, (BOOL)wParam);
        break;

        case MSG_SYNCPAINT:
            wndActiveMainWindow (pWin, (BOOL)wParam);
            PostMessage ((HWND)pWin, MSG_NCPAINT, 0, 0);
            PostMessage ((HWND)pWin, MSG_ERASEBKGND, 0, 0);
        break;

        case MSG_PAINT:
        {
            PINVRGN pInvRgn;

            pInvRgn = &pWin->InvRgn;

            pthread_mutex_lock (&pInvRgn->lock);
            EmptyClipRgn (&pInvRgn->rgn);
            pthread_mutex_unlock (&pInvRgn->lock);
        }

        break;

    }

    return 0;
}

static int DefaultControlMsgHandler(PMAINWIN pWin, int message,
                           WPARAM wParam, LPARAM lParam)
{
    HDC hdc;

    switch( message )
    {
        case MSG_ENABLE:
            if ( (!(pWin->dwStyle & WS_DISABLED) && !wParam)
                    || ((pWin->dwStyle & WS_DISABLED) && wParam) ) {
                if (wParam)
                    pWin->dwStyle &= ~WS_DISABLED;
                else
                    pWin->dwStyle |=  WS_DISABLED;
            }
        break;
        
        case MSG_SYSCOMMAND:
            if (wParam == SC_CLOSE)
                SendNotifyMessage ((HWND)pWin, MSG_CLOSE, 0, 0);
        break;

        case MSG_GETTEXTLENGTH:
            if (pWin->spCaption)
                return strlen (pWin->spCaption);
            else
                return 0;

        case MSG_GETTEXT:
            if (pWin->spCaption) {
                int len;
                char* buffer = (char*)lParam;

                len = min (strlen (pWin->spCaption), wParam);
                memcpy (buffer, pWin->spCaption, len);
                buffer [len] = '\0';
                return len;
            }
            else
                return 0;
        break;

        case MSG_SETTEXT:
//
// NOTE:
// this message is only implemented for main window.
// for CONTROL, must handle this message and should NOT 
// call default window procedure
// when handle MSG_SETTEXT.
//
            if (pWin->WinType == TYPE_CONTROL)
                return 0;

            FreeFixStr (pWin->spCaption);
            pWin->spCaption = FixStrAlloc (strlen ((char*)lParam));
            strcpy (pWin->spCaption, (char*)lParam);

            hdc = GetDC ((HWND)pWin);
            wndDrawCaption(pWin, hdc, GetForegroundWindow () == (HWND)pWin);
            ReleaseDC (hdc);
        break;
    }

    return 0;
}

static int DefaultSessionMsgHandler(PMAINWIN pWin, int message,
                           WPARAM wParam, LPARAM lParam)
{

// NOTE:
// Currently does nothing, should handle fowllowing messages:
//
// MSG_QUERYENDSESSION:
// MSG_ENDSESSION:
    
    return 0;
}

static int DefaultSystemMsgHandler(PMAINWIN pWin, int message, 
                           WPARAM wParam, LPARAM lParam)
{

// NOTE:
// Currently does nothing, should handle following messages:
//
// MSG_IDLE, MSG_CARETBLINK:

    if (message == MSG_IDLE) {
        if (pWin == GetMainWindow (sg_repeat_msg.hwnd))
            SendNotifyMessage (sg_repeat_msg.hwnd, 
                    sg_repeat_msg.message, sg_repeat_msg.wParam, sg_repeat_msg.lParam);
    }
    else if (message == MSG_CARETBLINK) {
        BlinkCaret ((HWND)pWin);
    }
    
    return 0;
}

// NOTE:
// This default main window call-back procedure
// also implemented for control.
int DefaultMainWinProc(HWND hWnd, int message, WPARAM wParam, LPARAM lParam)
{
    PMAINWIN pWin = (PMAINWIN)hWnd;

    if (message >= MSG_FIRSTMOUSEMSG && message <= MSG_NCMOUSEOFF)
        return DefaultMouseMsgHandler(pWin, message, 
            wParam, LOWORD (lParam), HIWORD (lParam));
    else if (message > MSG_NCMOUSEOFF && message <= MSG_LASTMOUSEMSG)
        return DefaultNCMouseMsgHandler(pWin, message, 
            (int)wParam, LOWORD (lParam), HIWORD (lParam));
    else if (message >= MSG_FIRSTKEYMSG && message <= MSG_LASTKEYMSG)
        return DefaultKeyMsgHandler(pWin, message, wParam, lParam);
    else if (message >= MSG_FIRSTPOSTMSG && message <= MSG_LASTPOSTMSG)
        return DefaultPostMsgHandler(pWin, message, wParam, lParam);
    else if (message >= MSG_FIRSTCREATEMSG && message <= MSG_LASTCREATEMSG) 
        return DefaultCreateMsgHandler(pWin, message, wParam, lParam);
    else if (message >= MSG_FIRSTPAINTMSG && message <= MSG_LASTPAINTMSG) 
        return DefaultPaintMsgHandler(pWin, message, wParam, lParam);
    else if (message >= MSG_FIRSTSESSIONMSG && message <= MSG_LASTSESSIONMSG) 
        return DefaultSessionMsgHandler(pWin, message, wParam, lParam);
    else if (message >= MSG_FIRSTCONTROLMSG && message <= MSG_LASTCONTROLMSG) 
        return DefaultControlMsgHandler(pWin, message, wParam, lParam);
    else if (message >= MSG_FIRSTSYSTEMMSG && message <= MSG_LASTSYSTEMMSG) 
        return DefaultSystemMsgHandler(pWin, message, wParam, lParam);

    return 0;
}

int DefaultControlProc (HWND hWnd, int message, WPARAM wParam, LPARAM lParam)
{
    if (message == MSG_SETTEXT)
        return 0;
    else if (message == MSG_SETCURSOR) {
        if (GetWindowExStyle (hWnd) & WS_EX_USEPARENTCURSOR)
            return 0;

        SetCursor (GetWindowCursor (hWnd));
        return 0;
    }
    else if (message == MSG_NCSETCURSOR) {
        SetCursor (GetSystemCursor (IDC_ARROW));
        return 0;
    }

    return DefaultMainWinProc (hWnd, message, wParam, lParam);
}

/************************* GUI calls support ********************************/

HWND GUIAPI SetFocus (HWND hWnd)
{
    PMAINWIN pWin;
    PMAINWIN pActiveMain;
    HWND hOldActive;
    
    if (IsMainWindow (hWnd))
        return SetActiveWindow (hWnd);

    pWin = GetMainWindow (hWnd);
    if (pWin->hActiveChild != hWnd) {
        pActiveMain = (PMAINWIN)GetActiveWindow ();

        if (pActiveMain == pWin) {
        
            hOldActive =  pWin->hActiveChild;
            
            if (hOldActive)
                SendMessage (hOldActive, MSG_KILLFOCUS, 0, 0);
                
            pWin->hActiveChild = hWnd;
            SendMessage (hWnd, MSG_SETFOCUS, 0, 0);

            return hOldActive;
        }
        else {
            hOldActive =  pWin->hActiveChild;
            pWin->hActiveChild = hWnd;
            return hOldActive;
        }
    }
    
    return HWND_DESKTOP;
}

HWND GUIAPI GetFocus(void)
{
    HWND hActiveMainWin;
    PMAINWIN pActiveMainWin;

    hActiveMainWin = GetActiveWindow ();

    if (hActiveMainWin != HWND_DESKTOP) {
        pActiveMainWin = (PMAINWIN)hActiveMainWin;

        if (pActiveMainWin->hActiveChild)
            return pActiveMainWin->hActiveChild;

        return hActiveMainWin;
    }
        
    return HWND_DESKTOP; 
}

HWND GUIAPI GetFocusChild (HWND hMainWnd)
{
    PMAINWIN pWin;
    
    pWin = GetMainWindow (hMainWnd);
    if (pWin)
        return pWin->hActiveChild;
    
    return 0;
}

HWND GUIAPI SetCapture(HWND hWnd)
{
    return (HWND) SendMessage (HWND_DESKTOP, MSG_SETCAPTURE, (WPARAM)hWnd, 0);
}


HWND GUIAPI GetCapture(void)
{
    return (HWND) SendMessage (HWND_DESKTOP, MSG_GETCAPTURE, 0, 0);
}

void GUIAPI ReleaseCapture(void)
{
    SendMessage (HWND_DESKTOP, MSG_SETCAPTURE, 0, 0);
}

// NOTE: this function support ONLY main window.
HWND GUIAPI SetActiveWindow(HWND hMainWnd)
{
    HWND hOld;
    
    if (!IsMainWindow (hMainWnd))
        return HWND_INVALID;

    hOld = (HWND) SendMessage (HWND_DESKTOP, MSG_SETACTIVEMAIN,
                (WPARAM)hMainWnd, 0);

    SendMessage (hMainWnd, MSG_NCACTIVATE, TRUE, 0);

    if (hOld)
        SendMessage (hOld, MSG_NCACTIVATE, FALSE, 0);

    return hOld;
}

// NOTE: this function support ONLY main window.
HWND GUIAPI GetActiveWindow(void)
{
    return (HWND)SendMessage (HWND_DESKTOP, MSG_GETACTIVEMAIN, 0, 0);
}

int WinMainMetrics[MWM_ITEM_NUMBER];

void InitMainWinMetrics()
{
    WinMainMetrics[MWM_MINWIDTH] = 50;
    WinMainMetrics[MWM_MINHEIGHT] = 50;
    WinMainMetrics[MWM_BORDER] = 2;
    WinMainMetrics[MWM_THICKFRAME] = 2;
    WinMainMetrics[MWM_THINFRAME] = 1;
    WinMainMetrics[MWM_CAPTIONY] = GetSysCharHeight() + 4;
    WinMainMetrics[MWM_ICONX] = 16;
    WinMainMetrics[MWM_ICONY] = 16;
    WinMainMetrics[MWM_MENUBARY] = GetSysCharHeight();
    WinMainMetrics[MWM_MENUBAROFFX] = 8;
    WinMainMetrics[MWM_MENUBAROFFY] = 5;
    WinMainMetrics[MWM_MENUITEMY] = GetSysCharHeight();
    WinMainMetrics[MWM_INTERMENUITEMX] = GetSysCharWidth() << 1;
    WinMainMetrics[MWM_INTERMENUITEMY] = 2;
    WinMainMetrics[MWM_MENUITEMOFFX] = 18;
    WinMainMetrics[MWM_MENUTOPMARGIN] = 4;
    WinMainMetrics[MWM_MENUBOTTOMMARGIN] = 4;
    WinMainMetrics[MWM_MENULEFTMARGIN] = 4;
    WinMainMetrics[MWM_MENURIGHTMARGIN] = 4;
    WinMainMetrics[MWM_MENUITEMMINX] = 64;
    WinMainMetrics[MWM_MENUSEPARATORY] = 4;
    WinMainMetrics[MWM_MENUSEPARATORX] = 4;
    WinMainMetrics[MWM_SB_WIDTH] = 16;
    WinMainMetrics[MWM_SB_HEIGHT] = 14;
    WinMainMetrics[MWM_SB_INTERX] = 2;
    WinMainMetrics[MWM_CXVSCROLL] = GetSysCCharWidth();
    WinMainMetrics[MWM_CYVSCROLL] = GetSysCCharWidth();
    WinMainMetrics[MWM_CXHSCROLL] = GetSysCCharWidth();
    WinMainMetrics[MWM_CYHSCROLL] = GetSysCCharWidth();
    WinMainMetrics[MWM_MINBARLEN] = 8;
    WinMainMetrics[MWM_DEFBARLEN] = 18;

}

/*************************** Main window and thread **************************/
BOOL GUIAPI IsWindow (HWND hWnd)
{
    PCONTROL pWin;

    pWin = (PCONTROL) hWnd;
    if (hWnd == HWND_DESKTOP || pWin->DataType != TYPE_HWND)
        return FALSE;

    return TRUE;
}

BOOL GUIAPI IsMainWindow(HWND hWnd)
{
    PCONTROL pChildWin;

    pChildWin = (PCONTROL)hWnd;
    if(pChildWin->DataType != TYPE_HWND) return FALSE;
    if(pChildWin->WinType == TYPE_MAINWIN) return TRUE;

    return FALSE;
}

BOOL GUIAPI IsControl(HWND hWnd)
{
    PCONTROL pChildWin;

    pChildWin = (PCONTROL)hWnd;
    if(pChildWin->DataType != TYPE_HWND) return FALSE;
    if(pChildWin->WinType == TYPE_CONTR