Dock Class Reference

#include <Dock.h>

Public Member Functions
	Dock (HINSTANCE hInstance)
	~Dock ()
void	UpdateDockWindow ()
void	UpdatePosition ()
void	ReconfigureLock (bool enable)
void	ToggleAlwaysOnTop ()
bool	CheckIfMouseHover ()

Public Attributes
HINSTANCE	hDockInstance
HWND	hDockWnd
HWND	hBlackboxWnd
int	DockX
int	DockY
int	DockWidth
int	DockHeight
HDC	cachedBackground
bool	cachedBackgroundExists
bool	reconfigureLock
bool	positioningInProgress
DockPluginsVector	DockPlugins
vector< dockPluginItem >::iterator	plugin
vector< dockPluginItem >::iterator	member
vector< dockPluginItem >::iterator	firstInGroup
vector< dockPluginItem >::iterator	lastInGroup

Friends
LRESULT CALLBACK	DockWndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)

Constructor & Destructor Documentation

Dock()

Dock::Dock

(

HINSTANCE

hInstance

)

{
    hDockWnd = NULL;
    hBlackboxWnd = GetBBWnd();
    hDockInstance = hInstance;
 
    cachedBackground = CreateCompatibleDC(NULL);
    cachedBackgroundExists = false;
 
    reconfigureLock = positioningInProgress = false;
    DockWidth = DockHeight = DockX = DockY = 10;
 
    //====================
 
    // Register window class...
    WNDCLASS wc;
    ZeroMemory(&wc,sizeof(wc));
    wc.hInstance = hDockInstance;      
    wc.lpfnWndProc = DockWndProc;                // window procedure
    wc.lpszClassName = szDockName;                // window class name
    wc.hbrBackground = NULL;                    // no class background brush
    wc.style = CS_DBLCLKS;                      // class styles (e.g. to accept doubleclicks)
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);   // always display the regular arrow cursor
 
    if (!RegisterClass(&wc))
    {
        MessageBox(0, "Error registering dock window class!", szDockName, MB_OK | MB_ICONERROR | MB_TOPMOST);
        Log("Dock", "Error registering window class!");
        return;
    }
 
    // Create dock window...
    hDockWnd = CreateWindowEx(
        WS_EX_TOOLWINDOW | WS_EX_ACCEPTFILES,           // window style
        szDockName,                                       // window class
        NULL,                                           // window name
        WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,   // window parameters
        DockX,                                         // x position
        DockY,                                         // y position
        0,                                              // window width
        0,                                              // window height
        hBlackboxWnd,                                   // owner window
        NULL,                                           // no menu
        hDockInstance,                                 // hInstance
        NULL                                            // no window creation data
    );
 
    if (!hDockWnd)
    {                          
        UnregisterClass(szDockName, hDockInstance); // unregister window class
        MessageBox(0, "Error creating dock window!", szDockName, MB_OK | MB_ICONERROR | MB_TOPMOST);
        Log("Dock", "Error creating window!");
        return;
    }
 
    //====================
 
    // Subscribe to Blackbox messages applicable to the dock...
    SendMessage(hBlackboxWnd, BB_REGISTERMESSAGE, (WPARAM)hDockWnd, (LPARAM)dockMessageSubscription);
 
    // Make the dock window sticky...
    MakeSticky(hDockWnd);
 
    // After a short locking interval to allow plugins to dock first,
    // we show+update or hide the dock window as applicable...
    // (nb. here this includes setting its z-order, window transparency, etc)
    ReconfigureLock(true);
}

~Dock()

Dock::~Dock

(

)

{
    KillTimer(hDockWnd, DOCK_RECONFIGURE_LOCK_TIMER);
 
    // Unsubscribe to previously subscribed Blackbox messages...
    SendMessage(hBlackboxWnd, BB_UNREGISTERMESSAGE, (WPARAM)hDockWnd, (LPARAM)dockMessageSubscription);
 
    DestroyWindow(hDockWnd); // Destroy window...
    UnregisterClass(szDockName, hDockInstance); // Unregister window class...
 
    DeleteDC(cachedBackground); // Delete cached bitmaps...
}

Member Function Documentation

UpdateDockWindow()

void Dock::UpdateDockWindow

(

)

{
    if (reconfigureLock) return; // Is the reconfigure lock enabled?
 
    //====================
 
    if (pSettings->dockHidden) // The dock is currently hidden, so no need to update its window...
    {
        DockWidth = DockHeight = 10; // Safeguard
        ShowWindow(hDockWnd, SW_HIDE);
    }
 
    //====================
 
    else // The dock is currently visible, so we need to update its window...
    {
        if (DockPlugins.size() > 0) // Any plugins currently docked?
        {
            RECT r = {0, 0, 0, 0};
            int maxwidth = 0, maxheight = 0;
 
            //====================
 
            // Scan through the plugin list and calculate
            // the maximum plugin width and height...
            for (plugin = DockPlugins.begin(); plugin != DockPlugins.end(); plugin++)
            {
                if (IsWindow(plugin->hwndPlugin)) // Check if the window is valid...
                {
                    GetWindowRect(plugin->hwndPlugin, &r);
 
                    plugin->width = r.right - r.left;
                    plugin->height = r.bottom - r.top;
 
                    if (plugin->width > maxwidth) maxwidth = plugin->width;
                    if (plugin->height > maxheight) maxheight = plugin->height;
                }
                else // ...if not, we remove it from the list...
                {
                    DockPlugins.erase(plugin);
                    plugin--;
                }
            }
 
            //====================
 
            int padding = pSettings->Dock->marginWidth;
            if (padding < 2) padding = 2;
            int xpad, ypad;
            int offset = pSettings->Dock->borderWidth + padding + 1;
            int tempX = offset;
            int tempY = offset;
            int totalGroupWidth = 0, totalGroupHeight = 0;
            int maxwidthWithPadding = maxwidth + padding;
            int maxheightWithPadding = maxheight + padding;
            int maxwidthInGroup = 0, maxheightInGroup = 0;
 
            //====================
 
            // "Puzzle positioning" == Automatic positioning of plugins within the dock...
            if (pSettings->dockPuzzlePositioning)
            {
                firstInGroup = lastInGroup = DockPlugins.begin();
 
                for (plugin = DockPlugins.begin(); plugin != DockPlugins.end(); plugin++)
                {
                    if (pSettings->dockVertical) // Vertical dock alignment
                    {
                        totalGroupWidth = tempX + plugin->width + padding;
 
                        if (totalGroupWidth > maxwidthWithPadding)
                        {
                            if (firstInGroup->width != maxwidth)
                            {
                                xpad = ((maxwidth - tempX) / 2) + pSettings->Dock->borderWidth + padding;
 
                                for (member = firstInGroup; member <= lastInGroup; member++)
                                {
                                    if (member->height == maxheightInGroup) ypad = 0;
                                    else ypad = (maxheightInGroup - member->height) / 2;
 
                                    member->x += xpad;
                                    member->y += ypad;
                                }
                            }
 
                            tempX = offset;
                            if (plugin != DockPlugins.begin()) tempY = tempY + maxheightInGroup + padding;
                            totalGroupWidth = offset + plugin->width + padding;
                            totalGroupHeight = offset + plugin->height + padding;
 
                            maxwidthInGroup = maxheightInGroup = 0;
                            firstInGroup = plugin;
                        }
                    }
                    else // Horizontal dock alignment
                    {
                        totalGroupHeight = tempY + plugin->height + padding;
 
                        if (totalGroupHeight > maxheightWithPadding)
                        {
                            if (firstInGroup->height != maxheight)
                            {
                                ypad = ((maxheight - tempY) / 2) + pSettings->Dock->borderWidth + padding;
 
                                for (member = firstInGroup; member <= lastInGroup; member++)
                                {
                                    if (member->width == maxwidthInGroup) xpad = 0;
                                    else xpad = (maxwidthInGroup - member->width) / 2;
 
                                    member->x += xpad;
                                    member->y += ypad;
                                }
                            }
 
                            if (plugin != DockPlugins.begin()) tempX = tempX + maxwidthInGroup + padding;
                            tempY = offset;
                            totalGroupWidth = offset + plugin->width + padding;
                            totalGroupHeight = offset + plugin->height + padding;
 
                            maxwidthInGroup = maxheightInGroup = 0;
                            firstInGroup = plugin;
                        }
                    }
 
                    plugin->x = tempX;
                    plugin->y = tempY;
                    lastInGroup = plugin;
                    if (plugin->width > maxwidthInGroup) maxwidthInGroup = plugin->width;
                    if (plugin->height > maxheightInGroup) maxheightInGroup = plugin->height;
 
                    if (pSettings->dockVertical) tempX = tempX + plugin->width + padding;
                    else tempY = tempY + plugin->height + padding;
                }
 
                // Finish alignment for the last group...
                if (pSettings->dockVertical)
                {
                    xpad = (maxwidth - tempX) / 2 + pSettings->Dock->borderWidth + padding;
 
                    for (member = firstInGroup; member <= lastInGroup; member++)
                    {
                        if (member->height == maxheightInGroup) ypad = 0;
                        else ypad = (maxheightInGroup - member->height) / 2;
 
                        if (member->width != maxwidth) member->x += xpad;
                        member->y += ypad;
                    }
                }
                else
                {
                    ypad = (maxheight - tempY) / 2 + pSettings->Dock->borderWidth + padding;
 
                    for (member = firstInGroup; member <= lastInGroup; member++)
                    {
                        if (member->width == maxwidthInGroup) xpad = 0;
                        else xpad = (maxwidthInGroup - member->width) / 2;
 
                        member->x += xpad;
                        if (member->height != maxheight) member->y += ypad;
                    }
                }
 
                // Finally, we re-position the plugins...
                for (plugin = DockPlugins.begin(); plugin != DockPlugins.end(); plugin++)
                {
                    SetWindowPos(plugin->hwndPlugin, NULL, plugin->x, plugin->y, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
                }
            }
 
            //====================
            
            // Normal positioning == Plugins are placed in a single horizontal row / vertical column...
            else
            {
                for (plugin = DockPlugins.begin(); plugin != DockPlugins.end(); plugin++)
                {
                    if (pSettings->dockVertical)
                    {
                        // Calculate necessary padding to get a centered x position...
                        if (plugin->width == maxwidth) xpad = 0;
                        else xpad = (maxwidth - plugin->width) / 2;
                        SetWindowPos(plugin->hwndPlugin, NULL, (tempX + xpad), tempY, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
                        tempY = tempY + plugin->height + padding;
                    }
                    else
                    {
                        // Calculate necessary padding to get a centered y position...
                        if (plugin->height == maxheight) ypad = 0;
                        else ypad = (maxheight - plugin->height) / 2;
                        SetWindowPos(plugin->hwndPlugin, NULL, tempX, (tempY + ypad), 0, 0, SWP_NOZORDER | SWP_NOSIZE);
                        tempX = tempX + plugin->width + padding;
                    }
                }
            }
 
            //====================
 
            // Finally, we resize the dimensions of the dock to fit all the plugins...
            if (pSettings->dockVertical)
            {
                DockWidth = maxwidth + (offset * 2);
                if (pSettings->dockPuzzlePositioning) DockHeight = tempY + maxheightInGroup + offset;
                else DockHeight = tempY - padding + offset;
            }
            else
            {
                if (pSettings->dockPuzzlePositioning) DockWidth = tempX + maxwidthInGroup + offset;
                else DockWidth = tempX - padding + offset;
                DockHeight = maxheight + (offset * 2);
            }
        }
 
        //====================
 
        else // No plugins are currently docked, so we'll display a <Dock> tag instead; let's make room for it...
        {
            SIZE size;
            HDC fonthdc = CreateDC("DISPLAY", NULL, NULL, NULL);
            HFONT font = CreateFont(pSettings->Dock->FontHeight, 0, 0, 0, pSettings->Dock->FontWeight, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, pSettings->Dock->Font);
            HGDIOBJ oldfont = SelectObject(fonthdc, font);
            GetTextExtentPoint32(fonthdc, "---", strlen("---"), &size);
            DockWidth = size.cx + pSettings->Dock->FontHeight + (pSettings->Dock->marginWidth * 2) + (pSettings->Dock->borderWidth * 2);
            DockHeight = size.cy + (pSettings->Dock->marginWidth * 2) + (pSettings->Dock->borderWidth * 2);
            DeleteObject(SelectObject(fonthdc, oldfont));
            DeleteDC(fonthdc);
        }
 
        //====================
 
        ShowWindow(hDockWnd, SW_SHOWNOACTIVATE);
        UpdatePosition();
    }
}

UpdatePosition()

void Dock::UpdatePosition

(

)

{
    // Update the dock window position...
    pSettings->DockPlacement.width = DockWidth;
    pSettings->DockPlacement.height = DockHeight;
    pSettings->PositionFromPlacement(&pSettings->DockPlacement);
    DockX = pSettings->DockPlacement.x;
    DockY = pSettings->DockPlacement.y;
 
    // Force re-rendering of the background bitmap...
    cachedBackgroundExists = false;
 
    // Resize the dock window, move it to its new position, and request a WM_PAINT repaint...
    // (nb. the dock window is *not* a DWM layered window like most other xoblite core windows)
    MoveWindow(hDockWnd, DockX, DockY, DockWidth, DockHeight, false);
    InvalidateRect(hDockWnd, NULL, false);
 
    // Set the dock window transparency... (nb. the dock window is *not* a DWM layered window and hence only supports window transparency, not per pixel alpha etc)
//  SetTransparency(hDockWnd, pSettings->dockTransparencyAlpha);
    if (DockPlugins.size() > 0) SetTransparency(hDockWnd, pSettings->dockTransparencyAlpha);
    else SetTransparency(hDockWnd, (pSettings->dockTransparencyAlpha / 4));
 
    // Set the dock window z-order position... (regular or always on top)
    if (pSettings->dockOnTop) SetWindowPos(hDockWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE);
    else SetWindowPos(hDockWnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE);
 
    // Finally, we ask all docked plugins to repaint their windows (i.e. the child windows of the dock window) too...
    for (plugin = DockPlugins.begin(); plugin != DockPlugins.end(); plugin++)
    {
        if (IsWindow(plugin->hwndPlugin)) InvalidateRect(plugin->hwndPlugin, NULL, false);
    }
}

ReconfigureLock()

void Dock::ReconfigureLock

(

bool

enable

)

{
    if (enable)
    {
        if (!SetTimer(hDockWnd, DOCK_RECONFIGURE_LOCK_TIMER, 300, (TIMERPROC)NULL))
        {
            MessageBox(GetBBWnd(), "Error creating reconfigure lock timer!", szDockName, MB_OK | MB_ICONERROR | MB_TOPMOST);
            Log("Dock", "Error creating reconfigure lock timer!");
            return;
        }
        reconfigureLock = true;
        ShowWindow(hDockWnd, SW_HIDE); // Hide the window to "hide" any display artifacts while updating all plugins...
    }
    else
    {
        KillTimer(pDock->hDockWnd, DOCK_RECONFIGURE_LOCK_TIMER);
        pDock->reconfigureLock = false;
        pDock->UpdateDockWindow();
    }
}

ToggleAlwaysOnTop()

void Dock::ToggleAlwaysOnTop

(

)

{
    if (!pSettings->dockOnTop)
    {
        pSettings->dockOnTop = true;
        SetWindowPos(hDockWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE);
    }
    else
    {
        pSettings->dockOnTop = false;
        SetWindowPos(hDockWnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE);
    }
 
    WriteBool(pSettings->xobrcFile, "xoblite.dock.onTop:", pSettings->dockOnTop);
}

CheckIfMouseHover()

bool Dock::CheckIfMouseHover

(

)

{
    POINT mousepos;
    GetCursorPos(&mousepos);
    if (mousepos.x >= DockX && mousepos.x <= (DockX + DockWidth))
    {
        if (mousepos.y >= DockY && mousepos.y <= (DockY + DockHeight)) return true;
    }
 
    return false;
}

Friends And Related Symbol Documentation

DockWndProc

LRESULT CALLBACK DockWndProc ( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )

friend

{
    switch (message)
    {
        //====================
 
        case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(pDock->hDockWnd, &ps);
 
            // If we have not yet created a cached background, let's do that...
            if (!pDock->cachedBackgroundExists)
            {
 
                HBITMAP tempBitmap = CreateCompatibleBitmap(hdc, pDock->DockWidth, pDock->DockHeight);
                DeleteObject(SelectObject(pDock->cachedBackground, tempBitmap));
 
                // Draw dock background... (nb. as per the current style+settings if the dock is not empty, highly transparent black with white --- tag if the dock is empty)
                RECT r;
                GetClientRect(hwnd, &r);
                if (pDock->DockPlugins.size() > 0)
                {
                    if (pSettings->Dock->type == B_IMAGEFROMFILE) DrawImageIntoRect(pDock->cachedBackground, r, pSettings->Dock, false, true);
                    else MakeGradientSuper(pDock->cachedBackground, r, pSettings->Dock->type, pSettings->Dock->Color1, pSettings->Dock->Color2, pSettings->Dock->Color3, pSettings->Dock->Color4, pSettings->Dock->Color5, pSettings->Dock->Color6, pSettings->Dock->Color7, pSettings->Dock->Color8, pSettings->Dock->interlaced, pSettings->Dock->bevelstyle, pSettings->Dock->bevelposition, pSettings->bevelWidth, pSettings->Dock->borderColor, pSettings->Dock->borderWidth);
 
                    if (!pSettings->DockBorder->parentRelative && (pSettings->Dock->borderWidth > 0))
                    {
                        CreateBorderSuper(pDock->cachedBackground, r, pSettings->DockBorder->type, pSettings->DockBorder->Color1, pSettings->DockBorder->Color2, pSettings->DockBorder->Color3, pSettings->DockBorder->Color4, pSettings->DockBorder->Color5, pSettings->DockBorder->Color6, pSettings->DockBorder->Color7, pSettings->DockBorder->Color8, pSettings->Dock->borderWidth);
                    }
                }
                else
                {
                    MakeGradientSuper(pDock->cachedBackground, r, B_SOLID, 0x000000, 0, 0, 0, 0, 0, 0, 0, false, BEVEL_FLAT, 0, 0, 0, 0);
                    HFONT font = CreateFont(pSettings->Dock->FontHeight, 0, 0, 0, pSettings->Dock->FontWeight, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, pSettings->Dock->Font);
                    HGDIOBJ oldfont = SelectObject(pDock->cachedBackground, font);
                    SetBkMode(pDock->cachedBackground, TRANSPARENT);
                    DrawTextWithEffects(pDock->cachedBackground, r, "---", DT_CENTER | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_WORD_ELLIPSIS, 0xffffff, false, 0, false, 0, 0, 0);
                    DeleteObject(SelectObject(pDock->cachedBackground, oldfont));
                }
 
                DeleteObject(tempBitmap);
 
                // Set the "cached background created" indicator...
                pDock->cachedBackgroundExists = true;
            }
 
            // Copy the cached background into the dock window HDC...
            BitBlt(hdc, ps.rcPaint.left, ps.rcPaint.top, (ps.rcPaint.right - ps.rcPaint.left), (ps.rcPaint.bottom - ps.rcPaint.top), pDock->cachedBackground, ps.rcPaint.left, ps.rcPaint.top, SRCCOPY);
 
            EndPaint(pDock->hDockWnd, &ps);
        }
        break;
 
        //====================
 
        case WM_CLOSE:
            return 0;
 
        //====================
 
        case BB_RECONFIGURE:
        {
            // NOTE: When only need to do this if the dock is *empty*, since any docked plugins
            // will send SLIT_UPDATE which will in turn invalidate the parent dock window...
            if (pDock->DockPlugins.size() == 0) pDock->UpdateDockWindow();
        }
        break;
 
        //====================
 
        case WM_DISPLAYCHANGE:
        {
            // Update the dock's position if the screen resolution changes...
            pDock->UpdatePosition();
        }
        break;
 
        case WM_SETTINGCHANGE:
        {
            // Update the dock's position if the work area changes...
            // (e.g. if the Explorer taskbar is moved to another screen edge)
            if (wParam == SPI_SETWORKAREA) pDock->UpdatePosition();
            return 0;
        }
 
        //====================
 
        case DOCK_ADD: // -> A plugin is being docked... (added to the dock)
        {
            if (IsWindow((HWND)lParam))
            {
                dockPluginItem plugin;
                plugin.hwndPlugin = (HWND)lParam;
                pDock->DockPlugins.push_back(plugin);
 
                SetWindowLongPtr((HWND)lParam, GWL_STYLE, (GetWindowLongPtr((HWND)lParam, GWL_STYLE) & ~WS_POPUP) | WS_CHILD);
                SetParent((HWND)lParam, pDock->hDockWnd);
            }
 
            pDock->UpdateDockWindow();
        }
        break;
 
        //====================
 
        case DOCK_REMOVE: // -> A plugin is being undocked... (removed from the dock)
        {
            vector<dockPluginItem>::iterator dockPlugin;
 
            for (dockPlugin = pDock->DockPlugins.begin(); dockPlugin != pDock->DockPlugins.end(); dockPlugin++)
            {
                if (dockPlugin->hwndPlugin == (HWND)lParam)
                {
                    if (IsWindow((HWND)lParam))
                    {
                        SetWindowLongPtr((HWND)lParam, GWL_STYLE, (GetWindowLongPtr((HWND)lParam, GWL_STYLE) & ~WS_CHILD) | WS_POPUP);
                        SetParent((HWND)lParam, NULL);
                    }
 
                    pDock->DockPlugins.erase(dockPlugin);
 
                    break;
                }
            }
 
            pDock->UpdateDockWindow();
        }
        break;
 
        //====================
 
        case DOCK_UPDATE: // -> Update the dock window...
        {
            pDock->UpdateDockWindow();
        }
        break;
 
        //====================
 
        case BB_TOGGLEDOCK: // -> Toggle the dock shown/hidden...
        {
            if (!pSettings->dockHidden) pSettings->dockHidden = true;
            else pSettings->dockHidden = false;
            pDock->UpdateDockWindow();
            PlaySoundFX(SFX_TOGGLE_ELEMENT);
            WriteBool(pSettings->xobrcFile, "xoblite.dock.hidden:", pSettings->dockHidden);
        }
        break;
 
        //====================
 
        case WM_NCHITTEST:
        {
            POINT p;
            GetCursorPos(&p);
            RECT r;
            GetWindowRect(pDock->hDockWnd, &r);
            pDock->DockX = r.left;
            pDock->DockY = r.top;
 
            p.x = p.x - pDock->DockX;
            p.y = p.y - pDock->DockY;
 
            // Allow mouse drag manual positioning if we're not hovering over
            // a child (plugin) window, and the control key is being held down...
            if (ChildWindowFromPoint(pDock->hDockWnd, p) == pDock->hDockWnd)
            {
                if (GetAsyncKeyState(VK_CONTROL) & 0x8000)
                {
                    pDock->positioningInProgress = true;
                    return HTCAPTION;
                }
            }
 
            return HTCLIENT;
        }
 
        //====================
 
        case WM_LBUTTONUP:
        {
            if (pMenuCommon) pMenuCommon->Hide();
            return 0;
        }
 
        case WM_LBUTTONDOWN: {} break;
 
        //====================
 
        case WM_RBUTTONUP:
        case WM_NCRBUTTONUP:
        {
            if (GetAsyncKeyState(VK_CONTROL) & 0x8000) SendMessage(GetBBWnd(), BB_MENU, 0, 0); // Ctrl+RightClick -> Main menu
            else if (GetAsyncKeyState(VK_MENU) & 0x8000) SendMessage(GetBBWnd(), BB_MENU, 0, 0); // Alt+RightClick -> Main menu
            else SendMessage(GetBBWnd(), BB_MENU, 2, 0); // RightClick without modifiers -> Configuration menu
            return 0;
        }
 
        case WM_RBUTTONDOWN:
        case WM_NCRBUTTONDOWN: {} break;
 
        //====================
 
        case WM_MBUTTONUP:
        case WM_NCMBUTTONUP:
        {
            if (GetAsyncKeyState(VK_CONTROL) & 0x8000) PostMessage(GetBBWnd(), BB_TOGGLEPLUGINS, 0, 0); // Ctrl+MidClick -> Toggle plugins
            else if (GetAsyncKeyState(VK_MENU) & 0x8000) PostMessage(GetBBWnd(), BB_TOGGLEPLUGINS, 0, 0); // Alt+MidClick -> Toggle plugins
            else PostMessage(GetBBWnd(), BB_TOGGLETOOLBAR, 0, 0); // MidClick without modifiers -> Toggle toolbar
        }
        break;
 
        case WM_MBUTTONDOWN:
        case WM_NCMBUTTONDOWN: {} break;
 
        //====================
 
        case WM_XBUTTONDOWN:
        {
            if (HIWORD(wParam) == XBUTTON1) // X1 Click without modifiers -> Toggle dock orientation (horizontal/vertical)
            {
                if (pSettings->dockVertical) pSettings->dockVertical = false;
                else pSettings->dockVertical = true;
                pDock->UpdateDockWindow();
                WriteBool(pSettings->xobrcFile, "xoblite.dock.vertical:", pSettings->dockVertical);
            }
        }
        break;
 
        //====================
 
        case WM_MOUSEWHEEL:
        case WM_MOUSEHWHEEL:
        {
            // Forward any mousewheel messages to the
            // child plugin window beneath the mouse cursor...
            POINT p;
            GetCursorPos(&p);
            p.x = p.x - pDock->DockX;
            p.y = p.y - pDock->DockY;
            HWND pluginWnd = ChildWindowFromPoint(pDock->hDockWnd, p);
            if ((pluginWnd != NULL) && (pluginWnd != pDock->hDockWnd)) PostMessage(pluginWnd, message, (WPARAM)wParam, (LPARAM)lParam);
        }
        break;
 
        //====================
 
        case WM_DROPFILES:
        {
            return ParseDropFiles(hwnd, wParam); // -> Common handling of drag'n'drop events for all core UI elements
        }
        break;
 
        //====================
 
        case WM_WINDOWPOSCHANGING:
        {
            if (pDock->positioningInProgress)
            {
                // Snap window to screen edges when in manual positioning mode?
                if ((pSettings->DockPlacement.placement == PLACEMENT_MANUAL) && pSettings->dockSnapToEdges)
                {
                    if (IsWindowVisible(hwnd)) SnapWindowToEdge((WINDOWPOS*)lParam, pSettings->edgeSnapThreshold, true);
                }
            }
            return 0;
        }
 
        //====================
 
        case WM_EXITSIZEMOVE:
        {
            if (pDock->positioningInProgress)
            {
                pDock->positioningInProgress = false;
 
                RECT r;
                GetWindowRect(pDock->hDockWnd, &r);
                pSettings->DockPlacement.placement = PLACEMENT_MANUAL;
                pSettings->DockPlacement.rcx = pDock->DockX = r.left;
                pSettings->DockPlacement.rcy = pDock->DockY = r.top;
 
                pSettings->WritePlacement(&pSettings->DockPlacement);
            }
 
            return 0;
        }
 
        //====================
 
        case WM_TIMER:
        {
            if (wParam == DOCK_RECONFIGURE_LOCK_TIMER)
            {
                pDock->ReconfigureLock(false);
                return 0;
            }
        }
        break;
 
        //====================
 
        default:
            return DefWindowProc(hwnd,message,wParam,lParam);
 
    //====================
    }
    return 0;
}

Member Data Documentation

hDockInstance

HINSTANCE Dock::hDockInstance

hDockWnd

HWND Dock::hDockWnd

hBlackboxWnd

HWND Dock::hBlackboxWnd

DockX

int Dock::DockX

DockY

int Dock::DockY

DockWidth

int Dock::DockWidth

DockHeight

int Dock::DockHeight

cachedBackground

HDC Dock::cachedBackground

cachedBackgroundExists

bool Dock::cachedBackgroundExists

reconfigureLock

bool Dock::reconfigureLock

positioningInProgress

bool Dock::positioningInProgress

DockPlugins

DockPluginsVector Dock::DockPlugins

plugin

vector<dockPluginItem>::iterator Dock::plugin

member

vector<dockPluginItem>::iterator Dock::member

firstInGroup

vector<dockPluginItem>::iterator Dock::firstInGroup

lastInGroup

vector<dockPluginItem>::iterator Dock::lastInGroup