desktop-comm.c

运行于嵌入式linux的数控系统图形界面

        else {
            mg_altdown = 0;
            if (mg_modal == 1) {
                mg_modal = 0;
                return 0;
            }
        }
    }

    if (mg_altdown) {
        if (message == MSG_KEYDOWN) {
            if( scancode == SCANCODE_TAB) {
            
                mg_modal = 1;
                
                if (__mg_ptmi)
                    dskForceCloseMenu ();

                pNextWin = dskGetNextVisibleMainWindow (__mg_active_mainwnd);
                dskMoveToTopMost (pNextWin, RCTM_KEY, 0);
                dskChangActiveWindow (pNextWin);
                return 0;
            }
            else if (scancode == SCANCODE_ESCAPE) {

                mg_modal = 1;

                if (__mg_active_mainwnd) {
#ifdef  _DEBUG
                    fprintf (stderr, "Will be Closed: %p.\n", __mg_active_mainwnd);
#endif
                    PostMessage ((HWND)__mg_active_mainwnd, MSG_CLOSE, 0, 0);
                    return 0;
                }
            }
        }
        else if (mg_modal == 1)
            return 0;
    }
    
    if (scancode == SCANCODE_LEFTALT
             || scancode == SCANCODE_RIGHTALT || mg_altdown) {
        if (message == MSG_KEYDOWN)
            message = MSG_SYSKEYDOWN;
        else {
            message = MSG_SYSKEYUP;
            mg_altdown = 0;
        }
    }
#ifdef _LITE_VERSION
    if (__mg_ime_wnd) {
        if (dskHandleKeyHooks (__mg_ime_wnd, 
                                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 int MouseMessageHandler (int message, WPARAM flags, int x, int y)
{
    static PMAINWIN pOldUnderPointer = NULL;
    static PMAINWIN pCaptured = (void*)HWND_INVALID;
    PMAINWIN pUnderPointer;
    PMAINWIN pCtrlPtrIn;
    int CapHitCode = HT_UNKNOWN;
    int UndHitCode = HT_UNKNOWN;
    int cx = 0, cy = 0;

    if (message == MSG_WINDOWCHANGED) {
        pCaptured = (void*) HWND_INVALID;
        CapHitCode = HT_UNKNOWN;

        pOldUnderPointer = NULL;

        PostMessage (HWND_DESKTOP, MSG_MOUSEMOVE, 0, MAKELONG (x, y));
        return 0;
    }
    
    if (__mg_capture_wnd) {
        PostMessage (__mg_capture_wnd, 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 = 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 (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));
                }
#if defined(_LITE_VERSION) && !defined(_STAND_ALONE)
                if (!mgIsServer)
#endif
                    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 (__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)
                        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,
                            flags, 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 if (!pUnderPointer)
                    PostMessage (HWND_DESKTOP, message + MSG_DT_MOUSEOFF,
                        flags, 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,
                        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;
    POINT mousePos;
    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);
        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);

            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;
        break;
        
        case MSG_SETACTIVEMAIN:
            return (int)dskChangActiveWindow (pWin);
        break;

        case MSG_GETCAPTURE:
            return (int)__mg_capture_wnd;
        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 (__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;
   }

   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
};

#if defined(_GB_SUPPORT) | defined (_GBK_SUPPORT) | defined (_GB18030_SUPPORT)
static const char* SysText_GB [] =
{
    "窗口...",              // 0
    "开始...",              // 1
    "刷新背景",             // 2
    "关闭所有窗口",         // 3
    "结束会话",             // 4
    "窗口操作...",          // 5
    "最小化",               // 6
    "最大化",               // 7
    "恢复",                 // 8
    "关闭",                 // 9
    "确定",                 // 10
    "下一步",               // 11
    "取消",                 // 12
    "上一步",               // 13
    "是(Y)",                // 14
    "否(N)",                // 15
    "终止(A)",              // 16
    "重试(R)",              // 17
    "忽略(I)",              // 18
    "关于 MiniGUI..."       // 19
};
#endif

#ifdef _BIG5_SUPPORT
static const char* SysText_BIG5 [] =
{
    "怠