dockmgr.c

来自「CC386 is a general-purpose 32-bit C comp」· C语言 代码 · 共 2,063 行 · 第 1/5 页

void dmgrAddGrip(CCW_params *p)
{
    grips[gripMax++] = p;
}

//-------------------------------------------------------------------------

void dmgrAddContainer(CCW_params *p)
{
    containers[containerMax++] = p;
}

//-------------------------------------------------------------------------

void dmgrStartMoveClient(CCW_params *p, LPARAM lParam)
{
    RECT r;
    int i;
    CCD_params *d = FindParams(p, 0);
    GetFrameWindowRect(&r);
    ClipCursor(&r);

    movept.x = (long)(short)LOWORD(lParam);
    movept.y = (long)(short)HIWORD(lParam);
    ClientToScreen(p->parent, &movept);

    for (i = 0; i < currentWindows; i++)
    {
        GetWindowRect(cache[i]->parent, &docks[i]->position);
        if (!docks[i]->flags)
            docks[i]->oldsize = docks[i]->position;
    }

    moverect = d->oldsize;
    OffsetRect(&moverect,  - moverect.left,  - moverect.top);
    OffsetRect(&moverect, d->position.left, d->position.top);

    moving = 1, drawnbound = 1;
    DrawBoundingRect(&moverect);
    lastSuggestedDock = d->flags &~DOCK_PRESENT;
}

//-------------------------------------------------------------------------

void dmgrMoveClient(CCW_params *p, LPARAM lParam, int grip)
{
    RECT r = moverect;
    POINT temppt;
    RECT r1;
    POINT adjust;
    int adj;
    int newcurs = 0;
    temppt.x = (long)(short)LOWORD(lParam);
    temppt.y = (long)(short)HIWORD(lParam);
    if (grip)
        ClientToScreen(p->parent, &temppt);
    else
        ClientToScreen(p->self, &temppt);
    OffsetRect(&r, temppt.x - movept.x, temppt.y - movept.y);
    adjust.x = adjust.y = 0;
    GetFrameWindowRect(&r1);

    if (r1.right < r.right)
    {
        adj = r1.right - r.right;
        r.left += adj;
        r.right += adj;
        adjust.x += adj;
        newcurs++;
    }
    else if (r1.left > r.left)
    {
        adj = r1.left - r.left;
        r.left += adj;
        r.right += adj;
        adjust.x += adj;
        newcurs++;
    }
    if (r1.bottom < r.bottom)
    {
        adj = r1.bottom - r.bottom;
        r.top += adj;
        r.bottom += adj;
        adjust.y += adj;
        newcurs++;
    }
    else if (r1.top > r.top)
    {
        adj = r1.top - r.top;
        r.top += adj;
        r.bottom += adj;
        adjust.y += adj;
        newcurs++;
    }

    CalculateMoveableDocks(p, &r, &temppt);
    if (drawnbound)
        DrawBoundingRect(&lastbound);
    DrawBoundingRect(&r);

}

//-------------------------------------------------------------------------

void dmgrStartSizeClient(CCW_params *p, int oncursor, LPARAM lParam)
{
    RECT r;
    GetClientWindowRect(&r);
    ClipCursor(&r);
    movept.x = (long)(short)LOWORD(lParam);
    movept.y = (long)(short)HIWORD(lParam);
    ClientToScreen(p->parent, &movept);
    curstype = oncursor;
    GetWindowRect(p->parent, &moverect);

    sizing = 1, drawnbound = 0;
}

//-------------------------------------------------------------------------

void dmgrSizeClient(CCW_params *p, LPARAM lParam)
{
    POINT temppt;
    RECT r = moverect;
    temppt.x = (long)(short)LOWORD(lParam);
    temppt.y = (long)(short)HIWORD(lParam);
    ClientToScreen(p->self, &temppt);
    switch (curstype)
    {
        case HTRIGHT:
            r.right += temppt.x - movept.x;
            if (r.right - r.left < MIN_WIDTH)
                r.right = r.left + MIN_WIDTH;
            break;
        case HTLEFT:
            r.left += temppt.x - movept.x;
            if (r.right - r.left < MIN_WIDTH)
                r.left = r.right - MIN_WIDTH;
            break;
        case HTTOP:
            r.top += temppt.y - movept.y;
            if (r.bottom - r.top < MIN_WIDTH)
                r.top = r.bottom - MIN_WIDTH;
            break;
        case HTBOTTOM:
            r.bottom += temppt.y - movept.y;
            if (r.bottom - r.top < MIN_WIDTH)
                r.bottom = r.top + MIN_WIDTH;
            break;
        case HTTOPRIGHT:
            r.top += temppt.y - movept.y;
            if (r.bottom - r.top < MIN_WIDTH)
                r.top = r.bottom - MIN_WIDTH;
            r.right += temppt.x - movept.x;
            if (r.right - r.left < MIN_WIDTH)
                r.right = r.left + MIN_WIDTH;
            break;
        case HTTOPLEFT:
            r.top += temppt.y - movept.y;
            if (r.bottom - r.top < MIN_WIDTH)
                r.bottom = r.top + MIN_WIDTH;
            r.left += temppt.x - movept.x;
            if (r.right - r.left < MIN_WIDTH)
                r.left = r.right - MIN_WIDTH;
            break;
        case HTBOTTOMRIGHT:
            r.bottom += temppt.y - movept.y;
            if (r.bottom - r.top < MIN_WIDTH)
                r.top = r.bottom - MIN_WIDTH;
            r.right += temppt.x - movept.x;
            if (r.right - r.left < MIN_WIDTH)
                r.right = r.left + MIN_WIDTH;
            break;
        case HTBOTTOMLEFT:
            r.bottom += temppt.y - movept.y;
            if (r.bottom - r.top < MIN_WIDTH)
                r.bottom = r.top + MIN_WIDTH;
            r.left += temppt.x - movept.x;
            if (r.right - r.left < MIN_WIDTH)
                r.left = r.right - MIN_WIDTH;
            break;
    }

    if (drawnbound)
        DrawBoundingRect(&lastbound);
    DrawBoundingRect(&r);
}

//-------------------------------------------------------------------------

void dmgrEndMoveSizeClient(CCW_params *p, LPARAM lParam)
{
    int i;
    if (sizing == 0 && moving == 0)
        return ;
    if (drawnbound)
    {
        DrawBoundingRect(&lastbound);
        if (moving)
        {
            DoDocks(p);
            PostMessage(hwndSourceTab, WM_RESETTABS, 0, 0);
        }
        else
            PutWindow(p->parent, &lastbound);
    }
    moving = sizing = 0;
    ClipCursor(0);
}

//-------------------------------------------------------------------------

int dmgrStartMoveGrip(CCW_params *p, LPARAM lParam)
{
    CCW_params *p1 = (CCW_params*)GetWindowLong(p->u.gp.child, 0);
    dmgrStartMoveClient(p1, lParam);
    dmgrMoveClient(p1, lParam, TRUE);
}

//-------------------------------------------------------------------------

int dmgrMoveGrip(CCW_params *p, LPARAM lParam)
{
    CCW_params *p1 = (CCW_params*)GetWindowLong(p->u.gp.child, 0);
    dmgrMoveClient(p1, lParam, TRUE);
}

//-------------------------------------------------------------------------

int dmgrEndMoveGrip(CCW_params *p, LPARAM lParam)
{
    CCW_params *p1 = (CCW_params*)GetWindowLong(p->u.gp.child, 0);
    dmgrEndMoveSizeClient(p1, lParam);
}

//-------------------------------------------------------------------------

int dmgrDocked(CCW_params *p)
{
    CCD_params *d = FindParams(p, 0);
    if (d)
    {
        return !!(d->flags &DOCK_PRESENT);
    }
    return FALSE;
}

//-------------------------------------------------------------------------

int dmgrSizeBarStartMove(CFW_params *p, LPARAM lParam)
{
    int i;
    RECT r;
    GetWindowRect(p->self, &moverect);
    movept.x = (long)(short)LOWORD(lParam);
    movept.y = (long)(short)HIWORD(lParam);
    ClientToScreen(p->self, &movept);
    drawnbound = FALSE;
    for (i = 0; i < frameCount; i++)
    {
        GetWindowRect(frames[i]->self, &frames[i]->position);
    }
    for (i = 0; i < currentWindows; i++)
    {
        GetWindowRect(cache[i]->parent, &docks[i]->position);
    }
    CalculateSizebarBounds(p, &r);
    ClipCursor(&r);
    drawnbound = 1;
    DrawBoundingRect(&p->position);
}

//-------------------------------------------------------------------------

int dmgrSizeBarMove(CFW_params *p, LPARAM lParam)
{
    POINT temp;
    RECT r = moverect;
    temp.x = (long)(short)LOWORD(lParam);
    temp.y = (long)(short)HIWORD(lParam);
    ClientToScreen(p->self, &temp);

    if (!p->vertical)
        OffsetRect(&r, 0, temp.y - movept.y);
    else
        OffsetRect(&r, temp.x - movept.x, 0);
    if (drawnbound)
        DrawBoundingRect(&lastbound);
    DrawBoundingRect(&r);
}

//-------------------------------------------------------------------------

int dmgrSizeBarEndMove(CFW_params *p)
{
    ClipCursor(0);

    Resize(p, &lastbound);
    if (drawnbound)
        DrawBoundingRect(&lastbound);
    drawnbound = 0;
}

//-------------------------------------------------------------------------

int dmgrFlex(CCW_params *p)
{
    int index;
    CCD_params *d;
    d = FindParams(p, &index);
    d->flexparams |= p->u.cw.flexed ? FLEX_UNREQ : FLEX_REQ;
    CalculateLayout( - 1, 0);
}

//-------------------------------------------------------------------------

int dmgrSizeFrame(void)
{
    int i;
    for (i = 0; i < currentWindows; i++)
    {
        GetWindowRect(cache[i]->parent, &docks[i]->position);
    }
    CalculateLayout( - 1, 0);
}

//-------------------------------------------------------------------------

int dmgrGetHiddenState(int id)
{
    int i;
    for (i = 0; i < currentWindows; i++)
        if (cache[i]->id == id)
            return docks[i]->hidden;
    return FALSE;
}

//-------------------------------------------------------------------------

int dmgrHideWindow(int id, int state)
{

    int oldstate = 0;
    CCW_params *p = 0;
    CCD_params *d = 0;
    int i, index;
    for (i = 0; i < currentWindows; i++)
    {
        if (cache[i]->id == id)
        {
            p = cache[i];
            d = docks[i];
            index = i;
            break;
        }
    }
    if (p)
    {
        oldstate = !d->hidden;
        if (state != d->hidden)
        {
            d->hidden = state;
            if (d->flags)
                CalculateHidden(d, index, state);
            ShowWindow(p->parent, state ? SW_HIDE : SW_SHOW);
            if (d->flags)
                CalculateLayout( - 1, 0);
            SendMessage(hwndSourceTab, WM_RESETTABS, 0, 0);
        }
        if (!state)
            SetFocus(p->parent);
    }
    return oldstate;
}

//-------------------------------------------------------------------------

void PutWindow(HWND hwnd, RECT *r)
{
    RECT r1, r2 =  *r;
    if (GetParent(hwnd) == hwndClient)
        GetWindowRect(hwndClient, &r1);
    else
        GetFrameWindowRect(&r1);
    OffsetRect(&r2,  - r1.left,  - r1.top);
    InvalidateRect(hwnd, 0, 0);
    MoveWindow(hwnd, r2.left, r2.top, r2.right - r2.left, r2.bottom - r2.top, 1)
        ;
}

//-------------------------------------------------------------------------

#define HYSTER(x,y) ((x)-(y) < 10 && (x)-(y) > -10)
void CalculateMoveableDocks(CCW_params *p, RECT *r, POINT *cursor)
{
    int i, fit =  - 1, fitwidth = 0, index, j;
    CCD_params *d = FindParams(p, &index);
    RECT r1, r2, r3;
    GetFrameWindowRect(&r3);
    GetClientWindowRect(&r1);
    suggestedDock = 0;

    if (HYSTER(cursor->x, r1.left))
    {
        r->top = r1.top;
        r->left = r1.left;
        if (p->type == LSTOOLBAR)
        {
            r->bottom = r->top + p->u.tb.vsize.cy + GRIPWIDTH;
            r->right = r->left + p->u.tb.vsize.cx;
        }
        else