desktop.c

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

        PostMessage (HWND_DESKTOP, MSG_MOUSEMOVE, 0, MAKELONG (x, y));
        return 0;
    }
    
    dskHandleMouseHooks (HWND_DESKTOP, message, flags, MAKELONG (x, y));
    
    if (hCaptureWnd)  {
        PostMessage (hCaptureWnd, message, flags | KS_CAPTURED, MAKELONG (x, y));
        return 0;
    }

    if (pCaptured != (void*)HWND_INVALID && pCaptured != NULL) {
        CapHitCode = SendAsyncMessage((HWND)pCaptured, MSG_HITTEST,
                                        (WPARAM)x, (LPARAM)y);
    }
    
    pCtrlPtrIn = GetWinUnderPointer (x, y);
    if (pCtrlPtrIn && pCtrlPtrIn->WinType == TYPE_CONTROL) {
        pUnderPointer = pCtrlPtrIn->pMainWin;
        UndHitCode = HT_CLIENT;
        cx = x - pUnderPointer->cl;
        cy = y - pUnderPointer->ct;
    }
    else {
        pUnderPointer = pCtrlPtrIn;
        pCtrlPtrIn = NULL;
        if (pUnderPointer) {
            UndHitCode = SendAsyncMessage((HWND)pUnderPointer, MSG_HITTEST, 
                                        (WPARAM)x, (LPARAM)y);
            cx = x - pUnderPointer->cl;
            cy = y - pUnderPointer->ct;
        }
    }

    switch (message)
    {
        case MSG_MOUSEMOVE:
            if (pCaptured != (void *)HWND_INVALID) {
                if (pCaptured)
                    PostMessage((HWND)pCaptured, MSG_NCMOUSEMOVE, 
                                CapHitCode, MAKELONG (x, y));
                else
                    PostMessage(HWND_DESKTOP, MSG_DT_MOUSEMOVE,
                                pUnderPointer == NULL, MAKELONG (x, y));
                break;
            }

            if (pUnderPointer == NULL) {
                if (pOldUnderPointer) {
                    PostMessage ((HWND)pOldUnderPointer,
                        MSG_MOUSEMOVEIN, FALSE, 0);
                    PostMessage ((HWND)pOldUnderPointer,
                        MSG_NCMOUSEMOVE, HT_OUT, MAKELONG (x, y));
                }
                SetCursor (GetSystemCursor (IDC_ARROW));
                pOldUnderPointer = NULL;
            }
            else {
                HCURSOR def_cursor = GetDefaultCursor ();
                if (pOldUnderPointer != pUnderPointer) {
                    if (pOldUnderPointer) {
                        PostMessage ((HWND)pOldUnderPointer,
                            MSG_MOUSEMOVEIN, FALSE, (LPARAM)pUnderPointer);
                        PostMessage ((HWND)pOldUnderPointer,
                            MSG_NCMOUSEMOVE, HT_OUT, MAKELONG (x, y));
                    }
                    PostMessage ((HWND)pUnderPointer,
                        MSG_MOUSEMOVEIN, TRUE, (LPARAM)pOldUnderPointer);

                    pOldUnderPointer = pUnderPointer;
                }

                if (pUnderPointer->dwStyle & WS_DISABLED) {
                    if (def_cursor)
                        SetCursor (def_cursor);
                    break;
                }

                if (UndHitCode == HT_CLIENT) {
                    if (def_cursor)
                        SetCursor (def_cursor);
                    PostMessage ((HWND)pUnderPointer, MSG_SETCURSOR, 
                            UndHitCode, MAKELONG (cx, cy));
                    PostMessage((HWND)pUnderPointer, MSG_NCMOUSEMOVE, 
                            UndHitCode, MAKELONG (x, y));
                    PostMessage((HWND)pUnderPointer, MSG_MOUSEMOVE, 
                            flags, MAKELONG (cx, cy));
                }
                else {
                    if (def_cursor)
                        SetCursor (def_cursor);
                    PostMessage ((HWND)pUnderPointer, MSG_NCSETCURSOR, 
                            UndHitCode, MAKELONG (x, y));
                    PostMessage((HWND)pUnderPointer, MSG_NCMOUSEMOVE, 
                            UndHitCode, MAKELONG (x, y));
                }
            }
        break;

        case MSG_LBUTTONDOWN:
        case MSG_RBUTTONDOWN:
            if (pUnderPointer) {
                if (sg_ptmi)
                    dskForceCloseMenu ();

                if (pUnderPointer->dwStyle & WS_DISABLED) {
                    Ping ();
                    break;
                }

                if (pCtrlPtrIn == NULL) {
                    if (!dskIsTopMost (pUnderPointer))
                        dskMoveToTopMost (pUnderPointer, TRUE);
                
                    if (pUnderPointer != dskChangActiveWindow (pUnderPointer))
                        PostMessage ((HWND) pUnderPointer,
                                MSG_MOUSEACTIVE, UndHitCode, 0);
                }
                
                if (UndHitCode != HT_CLIENT) {
                    if (UndHitCode & HT_NEEDCAPTURE)
                        pCaptured = pUnderPointer;
                    else
                        pCaptured = (void*)HWND_INVALID;

                    PostMessage ((HWND)pUnderPointer, message + MSG_NCMOUSEOFF,
                            UndHitCode, MAKELONG (x, y));
                }
                else {
                    PostMessage((HWND)pUnderPointer, message, 
                        flags, MAKELONG(cx, cy));
                    pCaptured = (void*)HWND_INVALID;
                }
            }
            else {
                dskChangActiveWindow (NULL);
                pCaptured = NULL;
                PostMessage (HWND_DESKTOP, message + MSG_DT_MOUSEOFF,
                            pUnderPointer == NULL, MAKELONG (x, y));
            }
        break;

        case MSG_LBUTTONUP:
        case MSG_RBUTTONUP:
            if (pCaptured != (void*)HWND_INVALID) {
                if (pCaptured)
                    PostMessage ((HWND)pCaptured, message + MSG_NCMOUSEOFF,
                        CapHitCode, MAKELONG (x, y));
                else
                    PostMessage (HWND_DESKTOP, message + MSG_DT_MOUSEOFF,
                        pUnderPointer == NULL, MAKELONG (x, y));
                
                pCaptured = (void*)HWND_INVALID;
                break;
            }
            else {
                if (pUnderPointer) {
                    if (pUnderPointer->dwStyle & WS_DISABLED) {
                        break;
                    }
                    
                    if(UndHitCode == HT_CLIENT)
                    {
                        PostMessage((HWND)pUnderPointer, message, 
                            flags, MAKELONG (cx, cy));
                    }
                    else
                    {
                        PostMessage((HWND)pUnderPointer, 
                            message + MSG_NCMOUSEOFF, 
                            UndHitCode, MAKELONG (x, y));
                    }
                }
                else
                    PostMessage (HWND_DESKTOP, message + MSG_DT_MOUSEOFF,
                        pUnderPointer == NULL, MAKELONG (x, y));
            }
        break;
        
        case MSG_LBUTTONDBLCLK:
        case MSG_RBUTTONDBLCLK:
            if (pUnderPointer)
            {
                if (pUnderPointer->dwStyle & WS_DISABLED) {
                    Ping ();
                    break;
                }

                if(UndHitCode == HT_CLIENT)
                    PostMessage((HWND)pUnderPointer, message, 
                        flags, MAKELONG(cx, cy));
                else
                    PostMessage((HWND)pUnderPointer, message + MSG_NCMOUSEOFF, 
                        UndHitCode, MAKELONG (x, y));
            }
            else {
                PostMessage(HWND_DESKTOP, message + MSG_DT_MOUSEOFF, 
                        TRUE, MAKELONG (x, y));
            }
        break;

    }

    return 0;
}

static int WindowMessageHandler(int message, PMAINWIN pWin, LPARAM lParam)
{
    PMAINWIN pTemp;
    POINT mousePos;
    int iRet = 0;

    switch (message)
    {
        case MSG_ADDNEWMAINWIN:
            if (sg_ptmi)
                dskForceCloseMenu ();
            pWin->pGCRInfo = &pWin->GCRInfo;
            iRet = (int)dskAddNewMainWindow(pWin, (PZORDERNODE)lParam);
        break;

        case MSG_REMOVEMAINWIN:
            if (sg_ptmi)
                dskForceCloseMenu ();
            iRet = (int)dskRemoveMainWindow(pWin);
        break;

        case MSG_MOVETOTOPMOST:
            if (sg_ptmi)
                dskForceCloseMenu ();
            pTemp = dskMoveToTopMost(pWin, TRUE);
        break;

        case MSG_SHOWMAINWIN:
            if (sg_ptmi)
                dskForceCloseMenu ();
            iRet = (int)dskShowMainWindow(pWin, TRUE);

            if ((HWND)pWin == sg_hIMEWnd)
                return iRet;
        break;

        case MSG_HIDEMAINWIN:
            if (sg_ptmi)
                dskForceCloseMenu ();
            iRet = (int)dskHideMainWindow(pWin);

            if ((HWND)pWin == sg_hIMEWnd)
                return iRet;
        break;

        case MSG_MOVEMAINWIN:
            dskMoveToTopMost(pWin, TRUE);
            dskMoveMainWindow (pWin, (const RECT*)lParam);
        return 0;

        case MSG_GETACTIVEMAIN:
            return (int)pActiveMainWnd;
        break;
        
        case MSG_SETACTIVEMAIN:
            return (int)dskChangActiveWindow (pWin);
        break;

        case MSG_GETCAPTURE:
            return (int)hCaptureWnd;
        break;
        
        case MSG_SETCAPTURE:
            return (int)DesktopSetCapture ((HWND)pWin);
        break;
        
        case MSG_TRACKPOPUPMENU:
            return dskTrackPopupMenu((PTRACKMENUINFO)lParam);
        break;

        case MSG_ENDTRACKMENU:
            return dskEndTrackMenu((PTRACKMENUINFO)lParam);
        break;

        case MSG_CLOSEMENU:
            if (!dskForceCloseMenu ()) return 0;

            if (!lParam) return 0;
        break;

        case MSG_SCROLLMAINWIN:
            return dskScrollMainWindow (pWin, (PSCROLLWINDOWINFO)lParam);
        break;

        case MSG_CARET_CREATE:
            sg_hCaretWnd = (HWND)pWin;
            sg_uCaretBTime = pWin->pCaretInfo->uTime;
            return 0;

        case MSG_CARET_DESTROY:
            sg_hCaretWnd = HWND_DESKTOP;
            return 0;

        case MSG_ENABLEMAINWIN:
            iRet = !(pWin->dwStyle & WS_DISABLED);

            if ( (!(pWin->dwStyle & WS_DISABLED) && !lParam)
                    || ((pWin->dwStyle & WS_DISABLED) && lParam) ) {
                if (lParam)
                    pWin->dwStyle &= ~WS_DISABLED;
                else
                    pWin->dwStyle |=  WS_DISABLED;

                if (pWin->dwStyle & WS_DISABLED) {
                
                    if (hCaptureWnd && GetMainWindow (hCaptureWnd) == pWin) 
                        hCaptureWnd = HWND_DESKTOP;

                    if (pActiveMainWnd == pWin) {
                        dskChangActiveWindow (NULL);
                        break;
                    }
                }

                SendAsyncMessage ((HWND)pWin, MSG_NCPAINT, 0, 0);
            }
            break;
        
        case MSG_ISENABLED:
            return !(pWin->dwStyle & WS_DISABLED);
        
        case MSG_SETWINCURSOR:
        {
            HCURSOR old = pWin->hCursor;

            pWin->hCursor = (HCURSOR)lParam;
            return old;
            break;
        }

        case MSG_SHOWGLOBALCTRL:
            if (sg_ptmi)
                dskForceCloseMenu ();
            dskMoveToTopMost (pWin, FALSE);
            break;

        case MSG_HIDEGLOBALCTRL:
            if (sg_ptmi)
                dskForceCloseMenu ();
            dskHideMainWindow (pWin);
            break;
   }

   GetCursorPos (&mousePos);
   MouseMessageHandler (MSG_WINDOWCHANGED, 0, mousePos.x, mousePos.y);

   return iRet;
}

#define IDM_REDRAWBG    MINID_RESERVED
#define IDM_CLOSEALLWIN (MINID_RESERVED + 1)
#define IDM_ENDSESSION  (MINID_RESERVED + 2)

#define IDM_FIRSTWINDOW (MINID_RESERVED + 101)

const char* SysText [] =
{
    "Windows...",               // 0
    "Start...",                 // 1
    "Refresh Background",       // 2
    "Close All Windows",        // 3
    "End Session",              // 4
    "Operations...",            // 5
    "Minimize",                 // 6
    "Maximize",                 // 7
    "Restore",                  // 8
    "Close",                    // 9
    "OK",                       // 10
    "Next",                     // 11
    "Cancel",                   // 12
    "Previous",                 // 13
    "Yes",                      // 14
    "No",                       // 15
    "Abort",                    // 16
    "Retry",                    // 17
    "Ignore",                   // 18
    "About MiniGUI...",         // 19
    NULL
};

static HMENU dskCreateWindowSubMenu (void)
{
    HMENU hmnu;
    MENUITEMINFO mii;

    memset (&mii, 0, sizeof(MENUITEMINFO));
    mii.type        = MFT_STRING;
    mii.id          = 0;
    mii.typedata    = (DWORD)GetSysText(SysText [0]);

    hmnu = CreatePopupMenu (&mii);
    return hmnu;
}

static HMENU dskCreateDesktopMenu (void)
{
    HMENU hmnu;
    MENUITEMINFO mii;

    memset (&mii, 0, sizeof(MENUITEMINFO));
    mii.type        = MFT_STRING;
    mii.id          = 0;
    mii.typedata    = (DWORD)GetSysText(SysText [1]);

    hmnu = CreatePopupMenu (&mii);

    memset (&mii, 0, sizeof(MENUITEMINFO));
    mii.type        = MFT_STRING;
    mii.id          = IDM_REDRAWBG;
    mii.typedata    = (DWORD)GetSysText(SysText [2]); 
    InsertMenuItem (hmnu, 0, TRUE, &mii);

    mii.type        = MFT_STRING;
    mii.id          = IDM_CLOSEALLWIN;
    mii.typedata    = (DWORD)GetSysText(SysText [3]); 
    InsertMenuItem (hmnu, 1, TRUE, &mii);
    
    mii.type        = MFT_STRING;
    mii.id          = IDM_ENDSESSION;
    mii.typedata    = (DWORD)GetSysText(SysText [4]);
    InsertMenuItem (hmnu, 2, TRUE, &mii);

    mii.type        = MFT_STRING;
    mii.id          = 0;
    mii.typedata    = (DWORD)GetSysText(SysText [0]);
    mii.hsubmenu     = dskCreateWindowSubMenu();
    InsertMenuItem (hmnu, 3, TRUE, &mii);
                        
    mii.type        = MFT_SEPARATOR;
    mii.id          = 0;
    mii.typedata    = 0;
    mii.hsubmenu    = 0;
    InsertMenuItem(hmnu, 4, TRUE, &mii);

    return hmnu;
}

static void dskUpdateDesktopMenu (HMENU hDesktopMenu)
{
    MENUITEMINFO mii;
    HMENU hWinMenu;
    int nCount, iPos;
    PZORDERNODE pNode;
    PMAINWIN    pWin;
    int id;

    hWinMenu = GetSubMenu (hDesktopMenu, 3);

    nCount = GetMenuItemCount (hWinMenu);

    for (iPos = nCount; iPos > 0; iPos --)
        DeleteMenu (hWinMenu, iPos - 1, MF_BYPOSITION);
    
    memset (&mii, 0, sizeof(MENUITEMINFO));
    mii.type = MFT_STRING;

    id = IDM_FIRSTWINDOW;
    iPos = 0;
    
    pNode = TopMostWinZOrder.pTopMost;