desktop.c

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

        return dskChangActiveWindow (pWin);
    else
        return pActiveMainWnd;
}

static void recalc_windows_under_this (ZORDERINFO* zorder, PMAINWIN pWin, RECT* rcWin)
{
    PZORDERNODE pNode, pAffected;
    RECT rcTemp, rcInv;
    PMAINWIN pTemp;

    // where is the hidding main window?
    pNode = zorder->pTopMost;
    while (pNode->hWnd != (HWND)pWin)
        pNode = pNode->pNext;
    pAffected = pNode->pNext;

    while (pAffected){
        pTemp = (PMAINWIN)(pAffected->hWnd);

        if (pTemp->dwStyle & WS_VISIBLE) {

            dskGetWindowRectInScreen (pTemp, &rcTemp);
            start_clip_window (pTemp);
            reset_window (pTemp, &rcTemp);
            if (zorder != &TopMostWinZOrder) {
                clip_by_windows (&TopMostWinZOrder, pTemp);
                clip_by_all_above_this (&MainWinZOrder, pTemp);
            }
            else
                clip_by_all_above_this (&TopMostWinZOrder, pTemp);
            end_clip_window (pTemp);

            if (IntersectRect (&rcTemp, rcWin, &rcTemp)) {
                dskScreenToWindow (pTemp, &rcTemp, &rcInv);
                SendAsyncMessage ((HWND)pTemp, MSG_NCPAINT, 0, (LPARAM)(&rcInv));
                dskScreenToClient (pTemp, &rcTemp, &rcInv);
                InvalidateRect ((HWND)pTemp, &rcInv, TRUE);
            }
        }

        pAffected = pAffected->pNext;
    }
}

static void recalc_windows (ZORDERINFO* zorder, RECT* rcWin)
{
    PZORDERNODE pAffected;
    RECT rcTemp, rcInv;
    PMAINWIN pTemp;

    pAffected = zorder->pTopMost;
    while (pAffected){
        pTemp = (PMAINWIN)(pAffected->hWnd);

        if (pTemp->dwStyle & WS_VISIBLE) {

            dskGetWindowRectInScreen (pTemp, &rcTemp);
            start_clip_window (pTemp);
            reset_window (pTemp, &rcTemp);
            clip_by_windows (&TopMostWinZOrder, pTemp);
            clip_by_all_above_this (&MainWinZOrder, pTemp);
            end_clip_window (pTemp);

            if (IntersectRect (&rcTemp, rcWin, &rcTemp)) {
                dskScreenToWindow (pTemp, &rcTemp, &rcInv);
                SendAsyncMessage ((HWND)pTemp, MSG_NCPAINT, 0, (LPARAM)(&rcInv));
                dskScreenToClient (pTemp, &rcTemp, &rcInv);
                InvalidateRect ((HWND)pTemp, &rcInv, TRUE);
            }
        }

        pAffected = pAffected->pNext;
    }
}

static void recalc_desktop (PTRACKMENUINFO ptmi)
{
    PZORDERNODE pNode;
    RECT rcTemp;
    PMAINWIN pTemp;

    // update desktop's global clip region.
    pthread_mutex_lock (&sg_ScrGCRInfo.lock);
    SetClipRgn (&sg_ScrGCRInfo.crgn, &g_rcScr);
    
    pNode = TopMostWinZOrder.pTopMost;
    while (pNode) {
    
        pTemp = (PMAINWIN)(pNode->hWnd);
        if (pTemp->dwStyle & WS_VISIBLE) {
            dskGetWindowRectInScreen (pTemp, &rcTemp);
            SubtractClipRect (&sg_ScrGCRInfo.crgn, &rcTemp);
        }

        pNode = pNode->pNext;
    }
    
    pNode = MainWinZOrder.pTopMost;
    while (pNode) {
    
        pTemp = (PMAINWIN)(pNode->hWnd);
        if (pTemp->dwStyle & WS_VISIBLE) {
            dskGetWindowRectInScreen (pTemp, &rcTemp);
            SubtractClipRect (&sg_ScrGCRInfo.crgn, &rcTemp);
        }

        pNode = pNode->pNext;
    }

    while (ptmi) {
        SubtractClipRect (&sg_ScrGCRInfo.crgn, &ptmi->rc);
        ptmi = ptmi->next;
    }

    sg_ScrGCRInfo.age ++;
    pthread_mutex_unlock (&sg_ScrGCRInfo.lock);
}

// When hide a main win, all main win which is covered by
// this hidding main win will be regenerated.
//
// Functions which lead to call this function:
//  ShowWindow: hide a visible window with SW_HIDE parameters.
//  DestroyWindow: destroy a visible window.
//
static void dskUpdateGCRInfoOnHideMainWin (MAINWIN* pWin)
{
    RECT rcWin, rcTemp;

    pWin->dwStyle &= ~WS_VISIBLE;
    dskGetWindowRectInScreen (pWin, &rcWin);
    recalc_windows_under_this (&MainWinZOrder, pWin, &rcWin);
    recalc_desktop (NULL);

    IntersectRect (&rcTemp, &rcWin, &g_rcScr);
    DesktopProc (HWND_DESKTOP, MSG_ERASEDESKTOP, 0, (LPARAM)(&rcTemp));
}

// this is a top most window
static void dskUpdateGCRInfoOnHideMainWinEx(MAINWIN* pWin)
{
    RECT rcWin, rcTemp;
    
    pWin->dwStyle &= ~WS_VISIBLE;
    dskGetWindowRectInScreen (pWin, &rcWin);
    recalc_windows_under_this (&TopMostWinZOrder, pWin, &rcWin);
    recalc_windows (&MainWinZOrder, &rcWin);
    recalc_desktop (NULL);

    IntersectRect (&rcTemp, &rcWin, &g_rcScr);
    DesktopProc (HWND_DESKTOP, MSG_ERASEDESKTOP, 0, (LPARAM)(&rcTemp));
}

static PMAINWIN dskGetFirstVisibleWindow (void)
{
    PZORDERNODE pNode;
    PMAINWIN pTemp;

    pNode = MainWinZOrder.pTopMost;
    while (pNode) {
    
        pTemp = (PMAINWIN)(pNode->hWnd);

        if ((pTemp->WinType != TYPE_CONTROL)
                && (pTemp->dwStyle & WS_VISIBLE))
            return pTemp;

        pNode = pNode->pNext;
    }
    
    pNode = TopMostWinZOrder.pTopMost;
    while (pNode) {
    
        pTemp = (PMAINWIN)(pNode->hWnd);

        if ((pTemp->WinType != TYPE_CONTROL)
                && (pTemp->dwStyle & WS_VISIBLE))
            return pTemp;

        pNode = pNode->pNext;
    }

    return NULL;
    
}

static PMAINWIN dskGetNextVisibleMainWindow (PMAINWIN pWin)
{
    PZORDERNODE pNode;
    PMAINWIN pTemp;

    if (pWin)
        pNode = pWin->pZOrderNode->pNext;
    else
        pNode = MainWinZOrder.pTopMost;

    while (pNode) {

        pTemp = (PMAINWIN)(pNode->hWnd);

        if ((pTemp->WinType != TYPE_CONTROL)
                && (pTemp->dwStyle & WS_VISIBLE) 
                && !(pTemp->dwStyle & WS_DISABLED))
            return pTemp;

        pNode = pNode->pNext;
    }
    
    return NULL;
}

static PMAINWIN dskHideMainWindow (PMAINWIN pWin)
{
    if (!(pWin->dwStyle & WS_VISIBLE))
        return NULL;

    // Update all affected windows' GCR info.
    if (pWin->dwExStyle & WS_EX_TOPMOST)
        dskUpdateGCRInfoOnHideMainWinEx (pWin);
    else
        dskUpdateGCRInfoOnHideMainWin (pWin);

    // if this is the avtive window,
    // must choose another window as the active one. 
    if (pActiveMainWnd == pWin)
        dskChangActiveWindow (dskGetFirstVisibleWindow ());

    return pActiveMainWnd;
}

// When destroy a main win, all main win which is covered by
// this destroying main win will be redraw.
//
// Functions which lead to call this function:
//  DestroyWindow: destroy a visible window.
//
// return: the new active window.
static PMAINWIN dskRemoveMainWindow (PMAINWIN pWin)
{
    // Handle main window hosting.
    if (pWin->pHosting)
        dskRemoveHostedMainWindow (pWin->pHosting, pWin);
        
    // Update all affected windows' GCR info.
    if (pWin->dwStyle & WS_VISIBLE) {
        if (pWin->dwExStyle & WS_EX_TOPMOST)
            dskUpdateGCRInfoOnHideMainWinEx (pWin);
        else
            dskUpdateGCRInfoOnHideMainWin (pWin);

        if (pActiveMainWnd == pWin)
            dskChangActiveWindow (dskGetFirstVisibleWindow ());

        if (pActiveMainWnd == pWin)
            pActiveMainWnd = NULL;
    }

    // Update window Z order list.
    if (pWin->dwExStyle & WS_EX_TOPMOST)
        remove_window (&TopMostWinZOrder, pWin);
    else
        remove_window (&MainWinZOrder, pWin);

    return pActiveMainWnd;
}

static void dskUpdateAllGCRInfoOnShowMenu (RECT* prc)
{
    clip_windows (&TopMostWinZOrder, prc);
    clip_windows (&MainWinZOrder, prc);

    clip_desktop (prc);
}

static void dskUpdateAllGCRInfoOnHideMenu (void)
{
    PZORDERNODE pAffected;
    RECT     rcTemp;
    PMAINWIN pTemp;
    PTRACKMENUINFO ptmi;
    
    pAffected = TopMostWinZOrder.pTopMost;
    while (pAffected){

        pTemp = (PMAINWIN)(pAffected->hWnd);
        if (pTemp->dwStyle & WS_VISIBLE) {

            dskGetWindowRectInScreen (pTemp, &rcTemp);
            start_clip_window (pTemp);
            reset_window (pTemp, &rcTemp);
            clip_by_all_above_this (&TopMostWinZOrder, pTemp);

            ptmi = sg_ptmi;
            while (ptmi) {
                SubtractClipRect (&pTemp->pGCRInfo->crgn, &ptmi->rc);
                ptmi = ptmi->next;
            }

            end_clip_window (pTemp);
        }

       pAffected = pAffected->pNext;
    }
    
    pAffected = MainWinZOrder.pTopMost;
    while (pAffected){

        pTemp = (PMAINWIN)(pAffected->hWnd);
        if (pTemp->dwStyle & WS_VISIBLE) {

            dskGetWindowRectInScreen (pTemp, &rcTemp);
            start_clip_window (pTemp);
            reset_window (pTemp, &rcTemp);
            clip_by_windows (&TopMostWinZOrder, pTemp);
            clip_by_all_above_this (&MainWinZOrder, pTemp);

            ptmi = sg_ptmi;
            while (ptmi) {
                SubtractClipRect (&pTemp->pGCRInfo->crgn, &ptmi->rc);
                ptmi = ptmi->next;
            }

            end_clip_window (pTemp);
        }
        pAffected = pAffected->pNext;
    }

    recalc_desktop (sg_ptmi);
}

// call back proc of tracking menu.
// defined in Menu module.
int PopupMenuTrackProc (PTRACKMENUINFO ptmi,
    int message, WPARAM wParam, LPARAM lParam);

static int dskTrackPopupMenu(PTRACKMENUINFO ptmi)
{
    PTRACKMENUINFO plast;
    
    if (sg_ptmi) {
        plast = sg_ptmi;
        while (plast->next) {
            plast = plast->next;
        }

        plast->next = ptmi;
        ptmi->prev = plast;
        ptmi->next = NULL;
    }
    else {
        sg_ptmi = ptmi;
        ptmi->next = NULL;
        ptmi->prev = NULL;
    }

    PopupMenuTrackProc (ptmi, MSG_INITMENU, 0, 0);

    // Update all main windows' GCR info.
    dskUpdateAllGCRInfoOnShowMenu (&ptmi->rc);

    PopupMenuTrackProc (ptmi, MSG_SHOWMENU, 0, 0);

    return 0;
}

static int dskEndTrackMenu (PTRACKMENUINFO ptmi)
{
    PZORDERNODE pNode;
    PMAINWIN pTemp;
    PTRACKMENUINFO plast;
    RECT rcInvalid, rcTemp;
    
    if (sg_ptmi == ptmi)
        sg_ptmi = NULL;
    else {
        plast = sg_ptmi;
        while (plast->next) {
            plast = plast->next;
        }
        plast->prev->next = NULL;
    }

    // Update all main windows' GCR info.
    dskUpdateAllGCRInfoOnHideMenu ();

    PopupMenuTrackProc (ptmi, MSG_HIDEMENU, 0, 0);

    // Invalidate rect of affected main window.
    pNode = TopMostWinZOrder.pTopMost;
    while (pNode) {

        pTemp = (PMAINWIN)(pNode->hWnd);
        if (pTemp->dwStyle & WS_VISIBLE) {
            
            dskGetWindowRectInScreen (pTemp, &rcTemp);
            if (IntersectRect (&rcInvalid, &ptmi->rc, &rcTemp)) {
                dskScreenToClient (pTemp, &rcInvalid, &rcInvalid);
                InvalidateRect ((HWND)pTemp, &rcInvalid, FALSE);
            }
        }

        pNode = pNode->pNext;
    }
    pNode = MainWinZOrder.pTopMost;
    while (pNode) {
    
        pTemp = (PMAINWIN)(pNode->hWnd);

        pTemp = (PMAINWIN)(pNode->hWnd);
        if (pTemp->dwStyle & WS_VISIBLE) {

            dskGetWindowRectInScreen (pTemp, &rcTemp);
            if (IntersectRect (&rcInvalid, &ptmi->rc, &rcTemp)) {
                dskScreenToClient (pTemp, &rcInvalid, &rcInvalid);
                InvalidateRect ((HWND)pTemp, &rcInvalid, FALSE);
            }
        }

        pNode = pNode->pNext;
    }


    PopupMenuTrackProc (ptmi, MSG_ENDTRACKMENU, 0, 0);

    return sg_ptmi == ptmi;
}

static BOOL dskForceCloseMenu (void)
{
    if (sg_ptmi == NULL) return FALSE;

    SendNotifyMessage (sg_ptmi->hwnd, MSG_DEACTIVEMENU, 
                       (WPARAM)sg_ptmi->pmb, (LPARAM)sg_ptmi->pmi);
                       
    PopupMenuTrackProc (sg_ptmi, MSG_CLOSEMENU, 0, 0);

    sg_ptmi = NULL;

    // Update all main windows' GCR info.
    dskUpdateAllGCRInfoOnHideMenu ();

    return TRUE;
}

static BOOL dskUpdateOldMainWindow (PMAINWIN pWin, 
        const RECT* prcInv, const RECT* prcWin, const RECT* prcClient)
{
    RECT rcInter;

    if (IntersectRect (&rcInter, prcInv, prcWin)) {

        rcInter.left -= prcWin->left;
        rcInter.top  -= prcWin->top;
        rcInter.right -= prcWin->left;
        rcInter.bottom -= prcWin->top;
        SendAsyncMessage ((HWND)pWin, MSG_NCPAINT, 0, (LPARAM)(&rcInter));

        if (IntersectRect (&rcInter, prcInv, prcClient)) {
            rcInter.left -= prcClient->left;
            rcInter.top  -= prcClient->top;
            rcInter.right -= prcClient->left;
            rcInter.bottom -= prcClient->top;
            InvalidateRect ((HWND)pWin, &rcInter, TRUE);

            return TRUE;
        }
    }

    return FALSE;