window.c

rtCell 实时微内核－具有下列功能： 1. 完全抢占的实时微内核结构

        if ((pWin->Status & WIN_FOCUSSED) == 0) {
            pWin->Status |= WIN_FOCUSSED;
            SetFocussedView(pMsg->pView);
            UpdateViewRect(pMsg->pView, &r);
        } 
        InformView(pWin->pClientView, pMsg);
        return (true);
    case VMSG_LOSTFOCUS:
        pWin->Status &= ~(WIN_FOCUSSED|WIN_MOUSE_CATCH);
        InformView(pWin->pClientView, pMsg);
        UpdateViewRect(pMsg->pView, &r);
        return (true);
    case MSM_MS_ENTER:
        pWin->Status |= WIN_MOUSE_ENTER;
        UpdateViewRect(pMsg->pView, &r);
        return (true);
    case MSM_MS_LEAVE:
        pWin->Status &= ~WIN_MOUSE_ENTER;
        UpdateViewRect(pMsg->pView, &r);
        return (true);
    case MSM_LB_DOWN:
        if (pWin->Status & WIN_FOCUSSED) {
            pWin->Status |= (WIN_MOUSE_CATCH|WIN_MOUSE_ENTER);
            pWin->ptCatch.x = pMsg->pt.x;
            pWin->ptCatch.y = pMsg->pt.y;
        }
        return (true);
    case MSM_LB_UP:
        pWin->Status &= ~(WIN_MOUSE_CATCH|WIN_SIZE|WIN_MOVE);
        return (true);
    case MSM_MS_MOVE:
        if (pWin->Status & WIN_MOUSE_CATCH) {
            int dx = pMsg->pt.x-pWin->ptCatch.x;
            int dy = pMsg->pt.y-pWin->ptCatch.y;

            if (pWin->Status & WIN_SIZE) {
                if (pWin != WIN_FROM_CLIENTVIEW(pWin->pClientView))
                    return (-1);

                if ((pWin->Status & WIN_RESIZABLE) &&
                    ((pWin->Status & WIN_MIN_SIZE) == 0) &&
                    ((pWin->Status & WIN_MAX_SIZE) == 0)) {
                    DoResizeWindow(pWin, &(pMsg->pt), dx, dy);
                }
            } else if (pWin->Status & WIN_MOVE) {
                if ((pWin->Status & WIN_MAX_SIZE) == 0) {
                    pWin->ptCatch.x = pMsg->pt.x;
                    pWin->ptCatch.y = pMsg->pt.y;
                    MoveWindow(pWin, dx, dy);  
                }
            }
                
            if ((pWin->Status & (WIN_MIN_SIZE|WIN_MAX_SIZE)) == 0)
                pWin->WinRect = pMsg->pView->viewRect;
        } else {
            pWin->Status &= ~(WIN_SIZE|WIN_MOVE);
            if (IsInRect(pMsg->pt.x, pMsg->pt.y, &r) == true) {
                pWin->Status |= WIN_MOVE;
                SetMouseCursor(MOVE);
            } else {
                CWORD Status;
                
                v = pWin->pMainView->viewRect;
                l = v; l.right = l.left+WIN_RESIZE_ZONE; /* left   */
                t = v; t.bottom = t.top+WIN_RESIZE_ZONE; /* top    */
                r = v; r.left = r.right-WIN_RESIZE_ZONE; /* right  */
                b = v; b.top = b.bottom-WIN_RESIZE_ZONE; /* bottom */

                if (IsInRect(pMsg->pt.x, pMsg->pt.y, &t) == true)
                    pWin->Status |= WIN_SIZE_TOP;
                if (IsInRect(pMsg->pt.x, pMsg->pt.y, &b) == true)
                    pWin->Status |= WIN_SIZE_BOTTOM;
                if (IsInRect(pMsg->pt.x, pMsg->pt.y, &l) == true)
                    pWin->Status |= WIN_SIZE_LEFT;
                if (IsInRect(pMsg->pt.x, pMsg->pt.y, &r) == true)
                    pWin->Status |= WIN_SIZE_RIGHT;

                Status = (pWin->Status & WIN_SIZE);
                if (Status == (WIN_SIZE_LEFT|WIN_SIZE_TOP) ||
                    Status == (WIN_SIZE_RIGHT|WIN_SIZE_BOTTOM)) {
                    SetMouseCursor(SIZE_HV135);
                } else if (Status == (WIN_SIZE_LEFT|WIN_SIZE_BOTTOM) ||
                           Status == (WIN_SIZE_RIGHT|WIN_SIZE_TOP)) {
                    SetMouseCursor(SIZE_HV45);
                } else if (Status == WIN_SIZE_LEFT ||
                           Status == WIN_SIZE_RIGHT) {
                    SetMouseCursor(SIZE_H);
                } else if (Status == WIN_SIZE_TOP ||
                           Status == WIN_SIZE_BOTTOM) {
                    SetMouseCursor(SIZE_V);
                } else {
                    SetMouseCursor(ARROW);
                }
            }
        }

        return (true);
    default:
        return (false);
    }
}

static void ClientViewPaint(VIEW *pView)
{
    WINDOW* pWin = WIN_FROM_CLIENTVIEW(pView);
    
    FillRect(&(pView->viewRect), pWin->ClientColor);
}

static CBOOL _cdecl_ ClientViewProc(VMSG *pMsg)
{     
    WINDOW* pWin = WIN_FROM_CLIENTVIEW(pMsg->pView);
    RECT r;
    
    switch (pMsg->MsgID) {
    case VMSG_PAINT: 
        ClientViewPaint(pMsg->pView);
        return (true);
    case VMSG_GETFOCUS:
        if ((pWin->Status & WIN_FOCUSSED) == 0) {
            SetFocussedView(pWin->pMainView);
            pWin->Status |= WIN_FOCUSSED;
            r.left = pWin->pMainView->viewRect.left+BAR_XOFF;
            r.top = pWin->pMainView->viewRect.top+BAR_YOFF;
            r.right = pWin->pMainView->viewRect.right-BAR_XOFF;
            r.bottom = r.top+BAR_HEIGHT-1;
            UpdateViewRect(pWin->pMainView, &r);
        }
    case VMSG_LOSTFOCUS:
    case TIMERM_OUT:
    case KEYM_KEY_DOWN:
        if (pWin->pFocussedView != NULL) {
            InformView(pWin->pFocussedView, pMsg);
        }
        return (true);
    case MSM_MS_ENTER:
        SetMouseCursor(ARROW);
        return (true);
    default:
        if (pWin->pWinProc != NULL) {
            (*(pWin->pWinProc))(pMsg);
        }
        return (true);
    } 
}

WINDOW* CreateWindowEx(int left, int top, int width, int height, VIEW* pParent,
                       BYTE* pCaption, PCREATE pOnCreate, WORD Style)
{
    VIEW   *pView, *pClientView;
    WINDOW *pWin;
    int     yOff; 
    WORD    sysBtnXoff, viewStatus; 

    viewStatus = (VS_MOVABLE|VS_RESIZABLE|VS_FORMVIEW);
    if (Style & WIN_HASTRANS)  viewStatus |= VS_HASTRANS;
    if (Style & WIN_STAYONTOP) viewStatus |= VS_STAYONTOP;
    
    if (pParent == NULL) {
        pView = CreateView(left, top, width, height, viewStatus,
                           MainViewProc, sizeof(WINDOW));
    } else {
        pView = CreateControl(left, top, width, height, pParent, viewStatus,
                              MainViewProc, sizeof(WINDOW));
    }

    if (pView == NULL) return (NULL);
    
    pWin = OBJ_FROM_VIEW(pView);
    pWin->pMainView = pView;
    pWin->pClientView = NULL;
    pWin->BarColor[0] = WindowBarColor[0];
    pWin->BarColor[1] = WindowBarColor[1];
    pWin->CaptionColor = CaptionColor;
    pWin->pWinProc = NULL;
    pWin->ptCatch.x = 0; pWin->ptCatch.y = 0;
    pWin->ClientColor = ClientColor;
    pWin->pCaption = pCaption;
    pWin->pFocussedChild = NULL;
    pWin->Status = (Style & WIN_3D_CLIENT)? WIN_CLIENT_RECT : 0;
    pWin->WinRect = pView->viewRect;
    pWin->pCloseBtn = NULL;
    pWin->pMaxBtn = NULL;
    pWin->pMinBtn = NULL;
    pWin->pFocussedView = NULL;
    pWin->Styles = Style;

    if (Style & WIN_RESIZE) pWin->Status |= WIN_RESIZABLE;
    if (pWin->Status & WIN_CLIENT_RECT) yOff = 2;
    else yOff = 0;

    if (pWin->Styles & WIN_CLIENT) {
        pClientView = CreateSubView(CLIENT_XOFF, CLIENT_YOFF+yOff, width-CLIENT_XOFF*2,
                                    height-CLIENT_YOFF-CLIENT_XOFF-yOff, pView,
                                    (VS_MOVABLE|VS_RESIZABLE), ClientViewProc, 0);
        if (pClientView == NULL) {
            GUIFree(pView);
            return (NULL);
        }
        pWin->pClientView = pClientView;
    }
    
    sysBtnXoff = width-SYSBTN_YOFF-SYSBTN_WIDTH;
    if (Style & WIN_CLOSE_BTN) {
        pWin->pCloseBtn = CreateSysBtn(sysBtnXoff, SYSBTN_YOFF, SYSBTN_WIDTH,
                                       SYSBTN_HEIGHT, pWin->pMainView);
        pWin->pCloseBtn->Status |= SYSBTN_CLOSE_BTN;
        sysBtnXoff -= (SYSBTN_XOFF+SYSBTN_WIDTH);
    }
    if (Style & WIN_MAX_BTN) {
        pWin->pMaxBtn = CreateSysBtn(sysBtnXoff, SYSBTN_YOFF, SYSBTN_WIDTH,
                                     SYSBTN_HEIGHT, pWin->pMainView);
        pWin->pMaxBtn->Status |= SYSBTN_MAX_BTN;
        sysBtnXoff -= (SYSBTN_WIDTH);
    }
    if (Style & WIN_MIN_BTN) {
        pWin->pMinBtn = CreateSysBtn(sysBtnXoff, SYSBTN_YOFF, SYSBTN_WIDTH,
                                     SYSBTN_HEIGHT, pWin->pMainView);
        pWin->pMinBtn->Status |= SYSBTN_MIN_BTN;    
    }

    if (pWin->Styles & WIN_SCROLL) {
        pWin->pVScrolbar = CreateScrollbar(pWin->pMainView, OnWinScroll, CTRL_ALIGN_VCENTER);
        if (pWin->pVScrolbar == NULL) {
            DeleteWindow(pWin);
            return (NULL);
        }
        pWin->pHScrolbar = CreateScrollbar(pWin->pMainView, OnWinScroll, CTRL_ALIGN_HCENTER);
        if (pWin->pHScrolbar == NULL) {
            DeleteWindow(pWin);
            return (NULL);
        }
    
        SetWinScrollBar(pWin);
    }

    if (pWin->Styles & WIN_CLIENT) {
        if (pOnCreate != NULL) (*pOnCreate)(pWin->pClientView); 
        ShowView(pWin->pClientView);
    }

    ShowView(pWin->pMainView);

    return (pWin);
}

WINDOW* CreateWindow(int left, int top, int width, int height, VIEW* pParent,
                     BYTE* pCaption, PCREATE pOnCreate, WORD Style)
{
    return CreateWindowEx(left, top, width, height, pParent, pCaption,
                          pOnCreate, Style|WIN_CLIENT|WIN_SCROLL|WIN_CLOSE_BTN);
}

void SetWinMainViewFun(WINDOW *pWin, PVIEWFUN pFun)
{
    if (pWin != NULL && pFun != NULL)
        pWin->pMainView->pViewProc = pFun;
}

void DeleteWindow(WINDOW *pWin)
{
    if (pWin == NULL) return;
    DeleteView(pWin->pMainView);
}

void SetWindowProc(WINDOW *pWin, PVIEWFUN pWinProc)
{
    if (pWin == NULL) return;
    pWin->pWinProc = pWinProc;
}

void SetWindowVisible(WINDOW *pWin, const CBOOL setVisible)
{
    if (setVisible == true) ShowView(pWin->pMainView);
    else if (setVisible == false) HideView(pWin->pMainView);
}

void SetWindowStayOnTop(WINDOW *pWin, const CBOOL setStayOnTop)
{
    SetViewStayOnTop(pWin->pMainView, setStayOnTop);
    if (IsViewVisible(pWin->pMainView) == true)
        RepaintRect(&(pWin->pMainView->viewRect));
}

void SetWindowTrans(WINDOW *pWin, const CBOOL setTrans)
{
    SetViewTrans(pWin->pMainView, setTrans);
    UpdateView(pWin->pMainView);
}

/*
 *******************************************************************************
 *                                                                             *
 *******************************************************************************
 */