desktop-comm.c

在ADS环境下MiniGUI的源码

                                message, (WPARAM)scancode, (LPARAM)status) == HOOK_GOON)
            PostMessage (__mg_ime_wnd, 
                            message, (WPARAM)scancode, (LPARAM)status);
        return 0;
    }

#else
    else if (__mg_ime_wnd && __mg_active_mainwnd) {
        if (dskHandleKeyHooks (__mg_ime_wnd, 
                                    message, (WPARAM)scancode, (LPARAM)status) == HOOK_GOON)
            PostMessage (__mg_ime_wnd, 
                                message, (WPARAM)scancode, (LPARAM)status);

        return 0;
    }
#endif

    if (__mg_active_mainwnd) {
        if (dskHandleKeyHooks ((HWND)__mg_active_mainwnd, 
                                message, (WPARAM)scancode, (LPARAM)status) == HOOK_GOON)
            PostMessage ((HWND)__mg_active_mainwnd, message, 
                (WPARAM)scancode, (LPARAM)status);
    }
    else {
        if (dskHandleKeyHooks (HWND_DESKTOP, message, 
                (WPARAM)scancode, (LPARAM)status) == HOOK_GOON)
            SendMessage (HWND_DESKTOP, MSG_DT_KEYOFF + message,
                (WPARAM)scancode, (LPARAM)status);
    }

    return 0;
}

static PMAINWIN __mgs_old_under_pointer = NULL;
static PMAINWIN __mgs_captured_main_win = (void*)HWND_INVALID;

/* defined in ../gui/window.c */
extern void __mg_reset_mainwin_capture_info (PCONTROL ctrl);

void __mg_reset_desktop_capture_info (PMAINWIN pWin)
{
    if (pWin == __mgs_old_under_pointer)
        __mgs_old_under_pointer = NULL;
    if (pWin == __mgs_captured_main_win)
        __mgs_captured_main_win = (void*)HWND_INVALID;
    if ((HWND)pWin == __mg_capture_wnd)
        __mg_capture_wnd = HWND_DESKTOP;

    __mg_reset_mainwin_capture_info ((PCONTROL)pWin);
}

static int MouseMessageHandler (int message, WPARAM flags, int x, int y)
{
    PMAINWIN pUnderPointer;
    PMAINWIN pCtrlPtrIn;
    int CapHitCode = HT_UNKNOWN;
    int UndHitCode = HT_UNKNOWN;
    int cx = 0, cy = 0;

    if (__mg_capture_wnd) {
        PostMessage (__mg_capture_wnd, message, flags | KS_CAPTURED, MAKELONG (x, y));
        return 0;
    }

    if (__mgs_captured_main_win != (void*)HWND_INVALID && __mgs_captured_main_win != NULL) {
        CapHitCode = SendAsyncMessage((HWND)__mgs_captured_main_win, MSG_HITTEST,
                                        (WPARAM)x, (LPARAM)y);
    }
    
    pCtrlPtrIn = GetMainWindowPtrUnderPoint (x, y);

    if (dskHandleMouseHooks ((HWND)pCtrlPtrIn, 
                            message, flags, MAKELONG (x, y)) == HOOK_STOP)
        return 0;
    
    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 (__mgs_captured_main_win != (void *)HWND_INVALID) {
                if (__mgs_captured_main_win)
                    PostMessage((HWND)__mgs_captured_main_win, MSG_NCMOUSEMOVE, 
                                CapHitCode, MAKELONG (x, y));
                else
                    PostMessage(HWND_DESKTOP, MSG_DT_MOUSEMOVE,
                                pUnderPointer == NULL, MAKELONG (x, y));
                break;
            }

            if (pUnderPointer == NULL) {
                if (__mgs_old_under_pointer) {
                    PostMessage ((HWND)__mgs_old_under_pointer,
                        MSG_MOUSEMOVEIN, FALSE, 0);
                    PostMessage ((HWND)__mgs_old_under_pointer,
                        MSG_NCMOUSEMOVE, HT_OUT, MAKELONG (x, y));
                }
#if defined(_LITE_VERSION) && !defined(_STAND_ALONE)
                if (!mgIsServer)
#endif
                    SetCursor (GetSystemCursor (IDC_ARROW));
                __mgs_old_under_pointer = NULL;
            }
            else {
                HCURSOR def_cursor = GetDefaultCursor ();
                if (__mgs_old_under_pointer != pUnderPointer) {
                    if (__mgs_old_under_pointer) {
                        PostMessage ((HWND)__mgs_old_under_pointer,
                            MSG_MOUSEMOVEIN, FALSE, (LPARAM)pUnderPointer);
                        PostMessage ((HWND)__mgs_old_under_pointer,
                            MSG_NCMOUSEMOVE, HT_OUT, MAKELONG (x, y));
                    }
                    PostMessage ((HWND)pUnderPointer,
                        MSG_MOUSEMOVEIN, TRUE, (LPARAM)__mgs_old_under_pointer);

                    __mgs_old_under_pointer = 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 (__mg_ptmi)
                    dskForceCloseMenu ();

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

                if (pCtrlPtrIn == NULL) {
                    if (!dskIsTopMost (pUnderPointer)) {
                        dskMoveToTopMost (pUnderPointer, RCTM_CLICK, MAKELONG (x, y));
                    }
                
                    if (pUnderPointer != dskChangActiveWindow (pUnderPointer))
                        PostMessage ((HWND) pUnderPointer,
                                MSG_MOUSEACTIVE, UndHitCode, 0);
                }
                
                if (UndHitCode != HT_CLIENT) {
                    if (UndHitCode & HT_NEEDCAPTURE)
                        __mgs_captured_main_win = pUnderPointer;
                    else
                        __mgs_captured_main_win = (void*)HWND_INVALID;

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

        case MSG_LBUTTONUP:
        case MSG_RBUTTONUP:
            if (__mgs_captured_main_win != (void*)HWND_INVALID) {
                if (__mgs_captured_main_win)
                    PostMessage ((HWND)__mgs_captured_main_win, message + MSG_NCMOUSEOFF,
                        CapHitCode, MAKELONG (x, y));
                else if (!pUnderPointer)
                    PostMessage (HWND_DESKTOP, message + MSG_DT_MOUSEOFF,
                        flags, MAKELONG (x, y));
                
                __mgs_captured_main_win = (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,
                        flags, 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, 
                        flags, MAKELONG (x, y));
            }
        break;

    }

    return 0;
}

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

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

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

        case MSG_MOVETOTOPMOST:
            if (__mg_ptmi)
                dskForceCloseMenu ();
            pTemp = dskMoveToTopMost(pWin, RCTM_MESSAGE, 0);
        break;

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

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

        case MSG_HIDEMAINWIN:
            if (__mg_ptmi)
                dskForceCloseMenu ();
            iRet = (int)dskHideMainWindow(pWin);
            __mg_reset_desktop_capture_info (pWin);
            if ((HWND)pWin == __mg_ime_wnd)
                return iRet;
        break;

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

        case MSG_GETACTIVEMAIN:
            return (int)__mg_active_mainwnd;
        
        case MSG_SETACTIVEMAIN:
            iRet = (int)dskChangActiveWindow (pWin);
            return iRet;

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

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

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

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

        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 (__mg_capture_wnd && GetMainWindowPtrOfControl (__mg_capture_wnd) == pWin) 
                        __mg_capture_wnd = HWND_DESKTOP;

                    if (__mg_active_mainwnd == 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;
        }

        case MSG_GETNEXTMAINWIN:
        {
            PZORDERNODE pNode;

            if (pWin) {
                pNode = pWin->pZOrderNode->pNext;
                if (pNode)
                    return pNode->hWnd;
                else if (pWin->dwExStyle & WS_EX_TOPMOST)
                    return sg_MainWinZOrder.pTopMost->hWnd;
            }
            else {
                if (sg_TopMostWinZOrder.pTopMost->hWnd)
                    return sg_TopMostWinZOrder.pTopMost->hWnd;
                else
                    return sg_MainWinZOrder.pTopMost->hWnd;
            }
            break;
        }

        case MSG_SHOWGLOBALCTRL:
            if (__mg_ptmi)
                dskForceCloseMenu ();
            dskMoveToTopMost (pWin, RCTM_SHOWCTRL, 0);
            dskSetPrimitiveChildren (pWin, TRUE);
            break;

        case MSG_HIDEGLOBALCTRL:
            if (__mg_ptmi)
                dskForceCloseMenu ();
            dskHideMainWindow (pWin);
            dskSetPrimitiveChildren (pWin, FALSE);
            break;
   }

   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",