tooldock.c

来自「一个类似windows」· C语言 代码 · 共 1,141 行 · 第 1/3 页

    if ((rbi->fMask & (RBBIM_CHILDSIZE | RBBIM_SIZE)) == (RBBIM_CHILDSIZE | RBBIM_SIZE))
    {
        RECT rcWnd;
        static const DWORD dwStyle = WS_POPUPWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_DLGFRAME;
        static const DWORD dwExStyle = WS_EX_TOOLWINDOW;

        rcWnd.left = pt.x - GetSystemMetrics(SM_CXFIXEDFRAME) - (GetSystemMetrics(SM_CYSMCAPTION) / 2);
        rcWnd.top = pt.y + GetSystemMetrics(SM_CYFIXEDFRAME) + (GetSystemMetrics(SM_CYSMCAPTION) / 2);
        rcWnd.right = rcWnd.left + rbi->cx;
        rcWnd.bottom = rcWnd.top + rbi->cyMinChild;

        if (AdjustWindowRectEx(&rcWnd,
                               dwStyle,
                               FALSE,
                               dwExStyle))
        {
            hToolbar = CreateWindowEx(dwExStyle,
                                      szToolDockWndClass,
                                      lpCaption,
                                      dwStyle,
                                      rcWnd.left,
                                      rcWnd.top,
                                      rcWnd.right - rcWnd.left,
                                      rcWnd.bottom - rcWnd.top,
                                      TbDocks->hParent,
                                      NULL,
                                      hInstance,
                                      &Init);
            if (hToolbar != NULL)
            {
                RECT rcClient;

                if (uBand != (UINT)-1)
                {
                    /* delete the band before showing the client window,
                       otherwise deleting the band will cause the client
                       window to be hidden, regardless of whether the band
                       was hidden before being deleted or not */
                    SendMessage(hRebar,
                                RB_DELETEBAND,
                                (WPARAM)uBand,
                                0);
                }

                if (Item->hWndClient != NULL)
                {
                    GetClientRect(hToolbar,
                                  &rcClient);

                    SetParent(Item->hWndClient,
                              hToolbar);

                    SetWindowPos(Item->hWndClient,
                                 NULL,
                                 0,
                                 0,
                                 rcClient.right,
                                 rcClient.bottom,
                                 SWP_NOZORDER);

                    SetWindowPos(Item->hWndClient,
                                 HWND_TOP,
                                 0,
                                 0,
                                 0,
                                 0,
                                 SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
                }

                SetWindowPos(hToolbar,
                             HWND_TOP,
                             0,
                             0,
                             0,
                             0,
                             SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);

                if (Drag)
                {
                    SetCursor(LoadCursor(NULL,
                                         MAKEINTRESOURCE(IDC_ARROW)));
                    SendMessage(hToolbar,
                                WM_NCLBUTTONDOWN,
                                HTCAPTION,
                                MAKELPARAM(pt.x,
                                           pt.y));
                }

                return TRUE;
            }
        }
    }

    return FALSE;
}

static BOOL
TdbInsertToolbar(PTOOLBAR_DOCKS TbDocks,
                 PDOCKBAR_ITEM Item,
                 DOCK_POSITION Position)
{
    LPTSTR lpCaption = NULL;
    REBARBANDINFO rbi = {0};
    BOOL Ret = FALSE;

    rbi.cbSize = sizeof(rbi);
    rbi.fMask = RBBIM_ID | RBBIM_STYLE | RBBIM_LPARAM;
    rbi.wID = Item->DockBar.BarId;
    rbi.fStyle = RBBS_GRIPPERALWAYS;
    rbi.lParam = (LPARAM)Item;

    if (Item->DockBar.DisplayTextId != 0)
    {
        if (AllocAndLoadString(&lpCaption,
                               hInstance,
                               Item->DockBar.DisplayTextId))
        {
            rbi.fMask |= RBBIM_TEXT;
            rbi.lpText = lpCaption;
        }
    }

    if (Item->hWndClient != NULL)
    {
        rbi.fMask |= RBBIM_CHILD;
        rbi.hwndChild = Item->hWndClient;
    }

    switch (Item->DockBar.Position)
    {
        case NO_DOCK:
        {
            POINT pt = {0};

            /* FIXME - calculate size */
            Ret = TbdCreateToolbarWnd(TbDocks,
                                      Item,
                                      Item->DockBar.Position,
                                      (UINT)-1,
                                      &rbi,
                                      pt,
                                      NULL,
                                      (UINT)-1,
                                      FALSE);
            break;
        }

        default:
        {
            UINT Index = -1;
            BOOL AddBand = TRUE;

            if (Item->Callbacks->InsertBand != NULL)
            {
                AddBand = Item->Callbacks->InsertBand(TbDocks,
                                                      &Item->DockBar,
                                                      Item->Context,
                                                      &Index,
                                                      &rbi);
            }

            if (AddBand)
            {
                Item->Callbacks->DockBand(TbDocks,
                                          &Item->DockBar,
                                          Item->Context,
                                          NO_DOCK,
                                          Item->DockBar.Position,
                                          &rbi);

                if (rbi.fMask & RBBIM_CHILD)
                    Item->hWndClient = rbi.hwndChild;
                else
                    Item->hWndClient = NULL;

                Ret = SendMessage(TbDocks->hRebar[Position],
                                  RB_INSERTBAND,
                                  (WPARAM)Index,
                                  (LPARAM)&rbi) != 0;
                if (Ret)
                {
                    Item->PrevDock = Position;
                    Item->PrevBandIndex = (UINT)SendMessage(TbDocks->hRebar[Position],
                                                            RB_IDTOINDEX,
                                                            (WPARAM)Item->DockBar.BarId,
                                                            0);
                }
            }

            break;
        }
    }

    if (lpCaption != NULL)
    {
        LocalFree((HLOCAL)lpCaption);
    }

    return Ret;
}

BOOL
TbdAddToolbar(PTOOLBAR_DOCKS TbDocks,
              const DOCKBAR *Dockbar,
              PVOID Context,
              const DOCKBAR_ITEM_CALLBACKS *Callbacks)
{
    PDOCKBAR_ITEM Item;
    HWND hRebar;

    hRebar = TbDocks->hRebar[Dockbar->Position];
    if (hRebar != NULL)
    {
        Item = HeapAlloc(ProcessHeap,
                         0,
                         sizeof(DOCKBAR_ITEM));
        if (Item != NULL)
        {
            /* Initialize the item */
            Item->DockBar = *Dockbar;
            Item->Context = Context;
            Item->hWndTool = NULL;
            Item->PrevDock = Dockbar->Position;

            Item->Callbacks = Callbacks;

            /* Create the client control */
            if (Callbacks->CreateClient != NULL &&
                !Callbacks->CreateClient(TbDocks,
                                         &Item->DockBar,
                                         Context,
                                         hRebar,
                                         &Item->hWndClient))
            {
                HeapFree(ProcessHeap,
                         0,
                         Item);

                return FALSE;
            }

            /* Insert the item into the list */
            Item->Next = TbDocks->Items;
            TbDocks->Items = Item;

            return TdbInsertToolbar(TbDocks,
                                    Item,
                                    Dockbar->Position);
        }
    }

    return FALSE;
}

#define GWLP_TBDOCKS    0
#define GWLP_DOCKITEM   (GWLP_TBDOCKS + sizeof(PTOOLBAR_DOCKS))
#define TD_EXTRA_BYTES  (GWLP_DOCKITEM + sizeof(PDOCKBAR_ITEM))

static LRESULT CALLBACK
ToolDockWndProc(HWND hwnd,
                UINT uMsg,
                WPARAM wParam,
                LPARAM lParam)
{
    PTOOLBAR_DOCKS TbDocks;
    PDOCKBAR_ITEM Item;
    LRESULT Ret = 0;

    /* Get the window context */
    TbDocks = (PTOOLBAR_DOCKS)GetWindowLongPtr(hwnd,
                                               GWLP_TBDOCKS);
    Item = (PDOCKBAR_ITEM)GetWindowLongPtr(hwnd,
                                           GWLP_DOCKITEM);

    if ((TbDocks == NULL || Item == NULL) && uMsg != WM_CREATE)
    {
        goto HandleDefaultMessage;
    }

    switch (uMsg)
    {
        case WM_NCACTIVATE:
        {
            TbdHandleActivation(TbDocks,
                                hwnd,
                                &wParam,
                                &lParam);
            goto HandleDefaultMessage;
        }

        case WM_CREATE:
        {
            TbDocks = ((PTOOLDOCKWND_INIT)(((LPCREATESTRUCT)lParam)->lpCreateParams))->TbDocks;
            Item = ((PTOOLDOCKWND_INIT)(((LPCREATESTRUCT)lParam)->lpCreateParams))->Item;
            Item->hWndTool = hwnd;

            SetWindowLongPtr(hwnd,
                             GWLP_TBDOCKS,
                             (LONG_PTR)TbDocks);
            SetWindowLongPtr(hwnd,
                             GWLP_DOCKITEM,
                             (LONG_PTR)Item);

            Ret = TRUE;
            break;
        }

        case WM_DESTROY:
        {
            Item->hWndTool = NULL;

            SetWindowLongPtr(hwnd,
                             GWLP_USERDATA,
                             0);
            SetWindowLongPtr(hwnd,
                             GWLP_DOCKITEM,
                             0);
            break;
        }

        default:
        {
HandleDefaultMessage:
            Ret = DefWindowProc(hwnd,
                                uMsg,
                                wParam,
                                lParam);
            break;
        }
    }

    return Ret;
}

static LRESULT CALLBACK
RebarSubclassProc(HWND hWnd,
                  UINT uMsg,
                  WPARAM wParam,
                  LPARAM lParam,
                  UINT_PTR uIdSubclass,
                  DWORD_PTR dwRefData)
{
    LRESULT Ret;

    Ret = DefSubclassProc(hWnd,
                          uMsg,
                          wParam,
                          lParam);

    if (uMsg == WM_MOUSEMOVE && (wParam & MK_LBUTTON))
    {
        DOCK_POSITION Position, DragTo = NO_DOCK;
        RECT rcClient;
        POINT pt;
        PTOOLBAR_DOCKS TbDocks = (PTOOLBAR_DOCKS)dwRefData;
        SIZE szTearOff;

        szTearOff.cx = GetSystemMetrics(SM_CXCURSOR);
        szTearOff.cy = GetSystemMetrics(SM_CYCURSOR);

        /*
         * Check if we're dragging and if it's time to remove the band
         */
        if (TbDocks->Dragging != NULL && GetCapture() == hWnd)
        {
            GetClientRect(hWnd,
                          &rcClient);
            InflateRect(&rcClient,
                        szTearOff.cx,
                        szTearOff.cy);

            pt.x = GET_X_LPARAM(lParam);
            pt.y = GET_Y_LPARAM(lParam);

            if (!PtInRect(&rcClient,
                          pt))
            {
                REBARBANDINFO rbi;
                UINT uBand;