Toolbar Class Reference

#include <Toolbar.h>

Public Member Functions
	Toolbar (HINSTANCE hInstance)
	~Toolbar ()
void	UpdateToolbarWindow ()
void	DrawWindowLabel (HDC hdc, RECT r, bool backgroundOnly)
void	DrawButtonGlyph (HDC hdc, int glyph, int xcenter, int ycenter)
bool	GetClockText (bool forceUpdate)
void	GetDimensions ()
void	GetPlacement ()
void	UpdatePosition ()
void	MoveToMouse ()
void	ToggleAlwaysOnTop ()
void	ToolbarModeButtonPressed (bool nextMode)
bool	CheckIfMouseHover ()

Public Attributes
HINSTANCE	hToolbarInstance
HWND	hBlackboxWnd
HWND	hToolbarWnd
HBITMAP	tbBitmap
int	ScreenWidth
int	ScreenHeight
int	ToolbarX
int	ToolbarY
int	ToolbarWidth
int	ToolbarHeight
bool	ButtonPressed1
bool	ButtonPressed2
bool	ButtonPressed3
bool	ButtonPressed4
int	tbLabelX
int	tbLabelY
int	tbLabelW
int	tbLabelH
int	tbWinLabelX
int	tbWinLabelY
int	tbWinLabelW
int	tbWinLabelH
int	tbClockX
int	tbClockY
int	tbClockW
int	tbClockH
RECT	labelRect
RECT	winlabelRect
RECT	clockRect
int	tbButtonX1
int	tbButtonX2
int	tbButtonX3
int	tbButtonX4
int	tbButtonY
int	tbButtonWH
RECT	button1Rect
RECT	button2Rect
RECT	button3Rect
RECT	button4Rect
bool	ToolbarPosInProgress
char	ToolbarWorkspaceName [MAX_LINE_LENGTH]
wchar_t	CurrentWindow [MAX_LINE_LENGTH]
wchar_t	CurrentTime [MAX_LINE_LENGTH]
time_t	systemTime
struct tm	localTime
int	currentMinute
int	displayedMinute
int	clockTimerCounter
char	temp [MAX_LINE_LENGTH]
bool	saveWidthAfterDelay
bool	throttlingAddRemoveUpdates
bool	throttlingActivityUpdates
bool	updatesThrottled
bool	toolbarVerticalPeeking
RECT	origDesktopArea
HDC	cachedBackground
HDC	cachedToolbarButton
HDC	cachedToolbarButtonPressed
bool	cachedBitmapsExist
HDC	cachedToolbarWindowLabel
RECT	currentWindowLabelRect
int	currentWindowLabelWidth
int	currentWindowLabelHeight
HTHUMBNAIL	thumbnail

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

Constructor & Destructor Documentation

Toolbar()

Toolbar::Toolbar

(

HINSTANCE

hInstance

)

{
    WNDCLASS wc;
    hToolbarInstance = hInstance;
    hBlackboxWnd = GetBBWnd();
 
    cachedBackground = CreateCompatibleDC(NULL);
    cachedToolbarButton = CreateCompatibleDC(NULL);
    cachedToolbarButtonPressed = CreateCompatibleDC(NULL);
    cachedBitmapsExist = false;
 
    cachedToolbarWindowLabel = CreateCompatibleDC(NULL);
    SetRectEmpty(&currentWindowLabelRect);
 
    ButtonPressed1 = ButtonPressed2 = ButtonPressed3 = ButtonPressed4 = false;
    toolbarVerticalPeeking = ToolbarPosInProgress = false;
    saveWidthAfterDelay = throttlingAddRemoveUpdates = throttlingActivityUpdates = updatesThrottled = false;
    thumbnail = NULL;
 
    CurrentWindow[0] = '\0';
    clockTimerCounter = 0;
 
    // Save original DesktopArea...
//  SystemParametersInfo(SPI_GETWORKAREA, 0, (PVOID)&origDesktopArea, SPIF_SENDCHANGE);
 
    //====================
 
    GetClockText(true); // Note: Get the toolbar clock string first since it is used when calculating the initial window dimensions...
    GetDimensions();
    GetPlacement();
 
    //====================
 
    // Register our window class...
    ZeroMemory(&wc,sizeof(wc));
    wc.hInstance = hToolbarInstance;        
    wc.lpfnWndProc = ToolbarWndProc;          // window procedure
    wc.lpszClassName = szToolbarName;          // 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 toolbar window class!", szToolbarName, MB_OK | MB_ICONERROR | MB_TOPMOST);
        Log("Toolbar: Error registering window class!", NULL);
        return;
    }
 
    hToolbarWnd = CreateWindowEx(
        WS_EX_TOOLWINDOW | WS_EX_ACCEPTFILES | WS_EX_LAYERED,  // window style
        szToolbarName,                                         // window class
        NULL,                                                   // window name
        WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,           // window parameters
        ToolbarX,                                               // x position
        ToolbarY,                                               // y position
        ToolbarWidth,                                           // window width
        ToolbarHeight,                                         // window height
        NULL, // hBlackboxWnd,                                  // owner window
        NULL,                                                   // no menu
        hToolbarInstance,                                       // hInstance
        NULL                                                    // no window creation data
    );
 
    if (!hToolbarWnd)
    {                          
        UnregisterClass(szToolbarName, hToolbarInstance);
        MessageBox(0, "Error creating toolbar window!", szToolbarName, MB_OK | MB_ICONERROR | MB_TOPMOST);
        Log("Toolbar: Error creating window!", NULL);
        return;
    }
 
    //====================
 
    // Subscribe to Blackbox messages applicable to the toolbar...
    SendMessage(hBlackboxWnd, BB_REGISTERMESSAGE, (WPARAM)hToolbarWnd, (LPARAM)toolbarMessageSubscription);
 
    // Make the toolbar window sticky...
    MakeSticky(hToolbarWnd);   
    // Set toolbar window z-order position... (regular or always on top)
//  if (pSettings->toolbarOnTop) SetWindowPos(hToolbarWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE);
    // Update the toolbar window...
    ShowWindow(hToolbarWnd, pSettings->toolbarHidden ? SW_HIDE : SW_SHOWNOACTIVATE);
    UpdatePosition(); // Note: This in turn also calls UpdateToolbarWindow() and sets the basic toolbar window z-order position... (regular or always on top)
 
    // Finally, if not set to be always on top, we move the toolbar window to be placed just above the *box desktop in the z-order...
    if (!pSettings->toolbarOnTop) SetWindowPos(hToolbarWnd, FindWindow("BBDesktop", NULL), 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE | SWP_NOSENDCHANGING | SWP_NOOWNERZORDER);
    else SetForegroundWindow(hToolbarWnd);
 
    //====================
 
    // Update DesktopArea (depending on blackbox.rc fullMaximization setting)...
//  UpdateDesktopArea();
 
    // Set timer for the toolbar clock+windowLabel update checks... (every 250 msecs, but only updating the toolbar if any there have been any changes since the last check etc)
    if (!SetTimer(hToolbarWnd, TOOLBAR_UPDATE_TIMER, 250, (TIMERPROC)NULL))
    {
        MessageBox(0, "Error setting toolbar update timer!", szToolbarName, MB_OK | MB_ICONERROR | MB_TOPMOST);
        Log("Toolbar: Could not set update timer!", NULL);
        return;
    }
 
    //====================
 
    INITCOMMONCONTROLSEX ic;
    ZeroMemory(&ic, sizeof(ic));
    ic.dwSize = sizeof(INITCOMMONCONTROLSEX);
    ic.dwICC = ICC_BAR_CLASSES;
    InitCommonControlsEx(&ic);
 
    //====================
 
    // Initialize the tooltips subsystem for possible later use by the taskbar...
    pTooltips->Initialize(hToolbarInstance, hToolbarWnd);
}

~Toolbar()

Toolbar::~Toolbar

(

)

{
    // Kill timers...
    KillTimer(hToolbarWnd, TOOLBAR_UPDATE_TIMER);
    if (saveWidthAfterDelay && !pSettings->toolbarVertical)
    {
        KillTimer(hToolbarWnd, TOOLBAR_SAVE_WIDTH_TIMER);
        WriteInt(pSettings->xobrcFile, "xoblite.toolbar.horizontal.width:", pSettings->toolbarHorizontalWidth);
    }
    
    // Restore original DesktopArea...
//  SystemParametersInfo(SPI_SETWORKAREA, 0, (PVOID)&origDesktopArea, SPIF_SENDCHANGE);
 
    // Unsubscribe to previously subscribed Blackbox messages...
    SendMessage(hBlackboxWnd, BB_UNREGISTERMESSAGE, (WPARAM)hToolbarWnd, (LPARAM)toolbarMessageSubscription);
 
    // Delete taskbar live preview thumbnail...
    if (thumbnail != NULL) DwmUnregisterThumbnail(thumbnail);
 
    DestroyWindow(hToolbarWnd); // Destroy toolbar window...
    UnregisterClass(szToolbarName, hToolbarInstance); // Unregister toolbar window class...
 
    // Delete cached bitmaps...
    if (cachedToolbarWindowLabel) DeleteDC(cachedToolbarWindowLabel);
    if (cachedToolbarButtonPressed) DeleteDC(cachedToolbarButtonPressed);
    if (cachedToolbarButton) DeleteDC(cachedToolbarButton);
    if (cachedBackground) DeleteDC(cachedBackground);
}

Member Function Documentation

UpdateToolbarWindow()

void Toolbar::UpdateToolbarWindow

(

)

{
    // Fetch the new size and position parameters for the toolbar window...
//  GetDimensions();
 
//  if (pSettings->debugLogging) SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)"Toolbar -> UpdateToolbarWindow()");
 
    RECT r;
    SetRect(&r, 0, 0, ToolbarWidth, ToolbarHeight);
 
    HDC hdc = GetWindowDC(hToolbarWnd);
    HBITMAP bufbmp = CreateCompatibleBitmap(hdc, r.right - r.left, r.bottom - r.top);
    DeleteObject(SelectObject(cachedBackground, bufbmp));
    ReleaseDC(hToolbarWnd, hdc);
 
    //====================
 
    // Draw toolbar background...
    SetRect(&r, 0, 0, ToolbarWidth, ToolbarHeight);
    if (pSettings->Toolbar->type == B_IMAGEFROMFILE) DrawImageIntoRect(cachedBackground, r, pSettings->Toolbar, false, true);
    else MakeGradientSuper(cachedBackground, r, pSettings->Toolbar->type, pSettings->Toolbar->Color1, pSettings->Toolbar->Color2, pSettings->Toolbar->Color3, pSettings->Toolbar->Color4, pSettings->Toolbar->Color5, pSettings->Toolbar->Color6, pSettings->Toolbar->Color7, pSettings->Toolbar->Color8, pSettings->Toolbar->interlaced, pSettings->Toolbar->bevelstyle, pSettings->Toolbar->bevelposition, pSettings->bevelWidth, pSettings->Toolbar->borderColor, pSettings->Toolbar->borderWidth);
 
    if (!pSettings->ToolbarBorder->parentRelative && (pSettings->Toolbar->borderWidth > 0))
    {
        CreateBorderSuper(cachedBackground, r, pSettings->ToolbarBorder->type, pSettings->ToolbarBorder->Color1, pSettings->ToolbarBorder->Color2, pSettings->ToolbarBorder->Color3, pSettings->ToolbarBorder->Color4, pSettings->ToolbarBorder->Color5, pSettings->ToolbarBorder->Color6, pSettings->ToolbarBorder->Color7, pSettings->ToolbarBorder->Color8, pSettings->Toolbar->borderWidth);
    }
 
    //====================
 
    // Should any toolbar corners be rounded off? If so, we need to perform some pixel re-shuffling
    // *before* any subsequent per pixel alpha operations... (because these in turn affect pixel data)
    int corners = 0;
    if (pSettings->toolbarRoundedCorners)
    {
        switch (pSettings->ToolbarPlacement.placement)
        {
            case PLACEMENT_TOP_LEFT: { corners = CORNER_BOTTOMRIGHT; break; }
            case PLACEMENT_CENTER_LEFT: { corners = CORNER_TOPRIGHT | CORNER_BOTTOMRIGHT; break; }
            case PLACEMENT_BOTTOM_LEFT: { corners = CORNER_TOPRIGHT; break; }
            case PLACEMENT_TOP_CENTER: { corners = CORNER_BOTTOMLEFT | CORNER_BOTTOMRIGHT; break; }
            case PLACEMENT_BOTTOM_CENTER: { corners = CORNER_TOPLEFT | CORNER_TOPRIGHT; break; }
            case PLACEMENT_TOP_RIGHT: { corners = CORNER_BOTTOMLEFT; break; }
            case PLACEMENT_CENTER_RIGHT: { corners = CORNER_TOPLEFT | CORNER_BOTTOMLEFT; break; }
            case PLACEMENT_BOTTOM_RIGHT: { corners = CORNER_TOPLEFT; break; }
            default: { corners = CORNER_TOPLEFT | CORNER_TOPRIGHT | CORNER_BOTTOMLEFT | CORNER_BOTTOMRIGHT; break; }
        }
 
        PrepareCorner(cachedBackground, r, corners, pSettings->Toolbar->bevelstyle, pSettings->Toolbar->bevelposition, 1, pSettings->Toolbar->borderWidth);
    }
 
    //====================
 
    if (!pSettings->toolbarLabelHidden && !pSettings->ToolbarLabel->parentRelative && (pSettings->numberOfWorkspaces > 1))
    {
        // Paint workspace label background...
        if (pSettings->ToolbarLabel->type == B_IMAGEFROMFILE) DrawImageIntoRect(cachedBackground, labelRect, pSettings->ToolbarLabel, false, true);
        else MakeGradientSuper(cachedBackground, labelRect, pSettings->ToolbarLabel->type, pSettings->ToolbarLabel->Color1, pSettings->ToolbarLabel->Color2, pSettings->ToolbarLabel->Color3, pSettings->ToolbarLabel->Color4, pSettings->ToolbarLabel->Color5, pSettings->ToolbarLabel->Color6, pSettings->ToolbarLabel->Color7, pSettings->ToolbarLabel->Color8, pSettings->ToolbarLabel->interlaced, pSettings->ToolbarLabel->bevelstyle, pSettings->ToolbarLabel->bevelposition, pSettings->bevelWidth, pSettings->ToolbarLabel->borderColor, pSettings->ToolbarLabel->borderWidth);
    }
 
    if (!pSettings->toolbarClockHidden && !pSettings->ToolbarClock->parentRelative)
    {
        // Paint clock background...
        if (pSettings->ToolbarClock->type == B_IMAGEFROMFILE) DrawImageIntoRect(cachedBackground, clockRect, pSettings->ToolbarClock, false, true);
        else MakeGradientSuper(cachedBackground, clockRect, pSettings->ToolbarClock->type, pSettings->ToolbarClock->Color1, pSettings->ToolbarClock->Color2, pSettings->ToolbarClock->Color3, pSettings->ToolbarClock->Color4, pSettings->ToolbarClock->Color5, pSettings->ToolbarClock->Color6, pSettings->ToolbarClock->Color7, pSettings->ToolbarClock->Color8, pSettings->ToolbarClock->interlaced, pSettings->ToolbarClock->bevelstyle, pSettings->ToolbarClock->bevelposition, pSettings->bevelWidth, pSettings->ToolbarClock->borderColor, pSettings->ToolbarClock->borderWidth);
    }
 
    //====================
 
//  HBITMAP tempBitmap, oldBitmap;
 
/*
    // If we have not yet created cached bitmaps, let's do that...
    if (!cachedBitmapsExist)
    {
        HBITMAP tempBitmap, oldBitmap;
 
        // Create a temporary bitmap...
        tempBitmap = CreateCompatibleBitmap(hdc, ToolbarWidth, ToolbarHeight);
        // Delete the previously cached gradient...
        oldBitmap = (HBITMAP)SelectObject(cachedBackground, tempBitmap);
        DeleteObject(oldBitmap);
        // Paint background + border... (now using MakeGradient instead of CreateBorder + DrawGradient)
        GetClientRect(hToolbarWnd, &r);
        //              MakeGradient(cachedBackground, r, pSettings->Toolbar->type, pSettings->Toolbar->Color, pSettings->Toolbar->ColorTo, pSettings->Toolbar->interlaced, pSettings->Toolbar->bevelstyle, pSettings->Toolbar->bevelposition, pSettings->bevelWidth, pSettings->Toolbar->borderColor, pSettings->Toolbar->borderWidth);
        MakeGradientEx(cachedBackground, r, pSettings->Toolbar->type, pSettings->Toolbar->Color, pSettings->Toolbar->ColorTo, pSettings->Toolbar->Color3, pSettings->Toolbar->Color4, pSettings->Toolbar->interlaced, pSettings->Toolbar->bevelstyle, pSettings->Toolbar->bevelposition, pSettings->bevelWidth, pSettings->Toolbar->borderColor, pSettings->Toolbar->borderWidth);
 
        //====================
 
        if (!pSettings->ToolbarLabel->parentRelative && pSettings->numberOfWorkspaces > 1)
        {
            // Paint workspaces background...
//                  MakeGradient(cachedBackground, labelRect, pSettings->ToolbarLabel->type, pSettings->ToolbarLabel->Color, pSettings->ToolbarLabel->ColorTo, pSettings->ToolbarLabel->interlaced, pSettings->ToolbarLabel->bevelstyle, pSettings->ToolbarLabel->bevelposition, pSettings->bevelWidth, pSettings->ToolbarLabel->borderColor, pSettings->ToolbarLabel->borderWidth);
            MakeGradientEx(cachedBackground, labelRect, pSettings->ToolbarLabel->type, pSettings->ToolbarLabel->Color, pSettings->ToolbarLabel->ColorTo, pSettings->ToolbarLabel->Color3, pSettings->ToolbarLabel->Color4, pSettings->ToolbarLabel->interlaced, pSettings->ToolbarLabel->bevelstyle, pSettings->ToolbarLabel->bevelposition, pSettings->bevelWidth, pSettings->ToolbarLabel->borderColor, pSettings->ToolbarLabel->borderWidth);
        }
 
        //====================
 
        if (!pSettings->ToolbarClock->parentRelative)
        {
            // Paint clock background...
//                  MakeGradient(cachedBackground, clockRect, pSettings->ToolbarClock->type, pSettings->ToolbarClock->Color, pSettings->ToolbarClock->ColorTo, pSettings->ToolbarClock->interlaced, pSettings->ToolbarClock->bevelstyle, pSettings->ToolbarClock->bevelposition, pSettings->bevelWidth, pSettings->ToolbarClock->borderColor, pSettings->ToolbarClock->borderWidth);
            MakeGradientEx(cachedBackground, clockRect, pSettings->ToolbarClock->type, pSettings->ToolbarClock->Color, pSettings->ToolbarClock->ColorTo, pSettings->ToolbarClock->Color3, pSettings->ToolbarClock->Color4, pSettings->ToolbarClock->interlaced, pSettings->ToolbarClock->bevelstyle, pSettings->ToolbarClock->bevelposition, pSettings->bevelWidth, pSettings->ToolbarClock->borderColor, pSettings->ToolbarClock->borderWidth);
        }
 
        //====================
 
        // Clean up - delete the temporary bitmap...
        DeleteObject(tempBitmap);
*/
        //====================
/*
        if (!pSettings->ToolbarButton->parentRelative)
        {
            // Create a temporary bitmap...
            tempBitmap = CreateCompatibleBitmap(hdc, tbButtonWH, tbButtonWH);
            // Delete the previously cached gradient...
            oldBitmap = (HBITMAP)SelectObject(cachedToolbarButton, tempBitmap);
            DeleteObject(oldBitmap);
            // Paint button background...
            r.left = 0; r.top = 0;  r.right = tbButtonWH; r.bottom = tbButtonWH;
            //                  MakeGradient(cachedToolbarButton, r, pSettings->ToolbarButton->type, pSettings->ToolbarButton->Color, pSettings->ToolbarButton->ColorTo, pSettings->ToolbarButton->interlaced, pSettings->ToolbarButton->bevelstyle, pSettings->ToolbarButton->bevelposition, pSettings->bevelWidth, pSettings->ToolbarButton->borderColor, pSettings->ToolbarButton->borderWidth);
            MakeGradientEx(cachedToolbarButton, r, pSettings->ToolbarButton->type, pSettings->ToolbarButton->Color, pSettings->ToolbarButton->ColorTo, pSettings->ToolbarButton->Color3, pSettings->ToolbarButton->Color4, pSettings->ToolbarButton->interlaced, pSettings->ToolbarButton->bevelstyle, pSettings->ToolbarButton->bevelposition, pSettings->bevelWidth, pSettings->ToolbarButton->borderColor, pSettings->ToolbarButton->borderWidth);
            // Clean up - delete the temporary bitmap...
            DeleteObject(tempBitmap);
        }
*/
        //====================
 
        if (!pSettings->ToolbarButton->parentRelative)
        {
            // Paint unpressed workspace/task buttons...
            if (!pSettings->toolbarDownUpButtonsHidden && (pSettings->numberOfWorkspaces > 1))
            {
////            BitBlt(cachedBackground, button1Rect.left, button1Rect.top, tbButtonWH, tbButtonWH, cachedToolbarButton, 0, 0, SRCCOPY);
////            BitBlt(cachedBackground, button2Rect.left, button2Rect.top, tbButtonWH, tbButtonWH, cachedToolbarButton, 0, 0, SRCCOPY);
                if (!ButtonPressed1)
                {
                    if (pSettings->ToolbarButton->type == B_IMAGEFROMFILE) DrawImageIntoRect(cachedBackground, button1Rect, pSettings->ToolbarButton, true, true);
                    else MakeGradientSuper(cachedBackground, button1Rect, pSettings->ToolbarButton->type, pSettings->ToolbarButton->Color1, pSettings->ToolbarButton->Color2, pSettings->ToolbarButton->Color3, pSettings->ToolbarButton->Color4, pSettings->ToolbarButton->Color5, pSettings->ToolbarButton->Color6, pSettings->ToolbarButton->Color7, pSettings->ToolbarButton->Color8, pSettings->ToolbarButton->interlaced, pSettings->ToolbarButton->bevelstyle, pSettings->ToolbarButton->bevelposition, pSettings->bevelWidth, pSettings->ToolbarButton->borderColor, pSettings->ToolbarButton->borderWidth);
                }
                if (!ButtonPressed2)
                {
                    if (pSettings->ToolbarButton->type == B_IMAGEFROMFILE) DrawImageIntoRect(cachedBackground, button2Rect, pSettings->ToolbarButton, true, true);
                    else MakeGradientSuper(cachedBackground, button2Rect, pSettings->ToolbarButton->type, pSettings->ToolbarButton->Color1, pSettings->ToolbarButton->Color2, pSettings->ToolbarButton->Color3, pSettings->ToolbarButton->Color4, pSettings->ToolbarButton->Color5, pSettings->ToolbarButton->Color6, pSettings->ToolbarButton->Color7, pSettings->ToolbarButton->Color8, pSettings->ToolbarButton->interlaced, pSettings->ToolbarButton->bevelstyle, pSettings->ToolbarButton->bevelposition, pSettings->bevelWidth, pSettings->ToolbarButton->borderColor, pSettings->ToolbarButton->borderWidth);
                }
            }
 
            if (!pSettings->toolbarLeftRightButtonsHidden)
            {
////            BitBlt(cachedBackground, button3Rect.left, button3Rect.top, tbButtonWH, tbButtonWH, cachedToolbarButton, 0, 0, SRCCOPY);
////            BitBlt(cachedBackground, button4Rect.left, button4Rect.top, tbButtonWH, tbButtonWH, cachedToolbarButton, 0, 0, SRCCOPY);
                if (!ButtonPressed3)
                {
                    if (pSettings->ToolbarButton->type == B_IMAGEFROMFILE) DrawImageIntoRect(cachedBackground, button3Rect, pSettings->ToolbarButton, true, true);
                    else MakeGradientSuper(cachedBackground, button3Rect, pSettings->ToolbarButton->type, pSettings->ToolbarButton->Color1, pSettings->ToolbarButton->Color2, pSettings->ToolbarButton->Color3, pSettings->ToolbarButton->Color4, pSettings->ToolbarButton->Color5, pSettings->ToolbarButton->Color6, pSettings->ToolbarButton->Color7, pSettings->ToolbarButton->Color8, pSettings->ToolbarButton->interlaced, pSettings->ToolbarButton->bevelstyle, pSettings->ToolbarButton->bevelposition, pSettings->bevelWidth, pSettings->ToolbarButton->borderColor, pSettings->ToolbarButton->borderWidth);
                }
                if (!ButtonPressed4)
                {
                    if (pSettings->ToolbarButton->type == B_IMAGEFROMFILE) DrawImageIntoRect(cachedBackground, button4Rect, pSettings->ToolbarButton, true, true);
                    else MakeGradientSuper(cachedBackground, button4Rect, pSettings->ToolbarButton->type, pSettings->ToolbarButton->Color1, pSettings->ToolbarButton->Color2, pSettings->ToolbarButton->Color3, pSettings->ToolbarButton->Color4, pSettings->ToolbarButton->Color5, pSettings->ToolbarButton->Color6, pSettings->ToolbarButton->Color7, pSettings->ToolbarButton->Color8, pSettings->ToolbarButton->interlaced, pSettings->ToolbarButton->bevelstyle, pSettings->ToolbarButton->bevelposition, pSettings->bevelWidth, pSettings->ToolbarButton->borderColor, pSettings->ToolbarButton->borderWidth);
                }
            }
        }
 
        //====================
/*
        // Set the "cached bitmaps created" indicator...
        cachedBitmapsExist = true;
    }
*/
    //====================
 
    // Copy the cached bitmap into the temporary buffer...
//  BitBlt(buf, ps.rcPaint.left, ps.rcPaint.top, updateRectWidth, updateRectHeight, cachedBackground, ps.rcPaint.left, ps.rcPaint.top, SRCCOPY);
 
    //====================
 
    // Paint windowlabel background+text or taskbar buttons?
    if (pSettings->taskbarMode != TASKBAR_MODE_HIDDEN) pTaskbar->DrawTaskbar(cachedBackground, 0, winlabelRect);
    else DrawWindowLabel(cachedBackground, winlabelRect, false); // TOOLBAR_MODE_WINDOWLABEL
 
    //====================
/*
    if (!pSettings->ToolbarButtonPressed->parentRelative && (ButtonPressed1 || ButtonPressed2 || ButtonPressed3 || ButtonPressed4))
    {
        // Paint pressed workspace/task buttons...
        // (not cached since they are not normally visible)
        HDC src = CreateCompatibleDC(NULL);
        HBITMAP srcbmp = CreateCompatibleBitmap(hdc, tbButtonWH, tbButtonWH);
        HBITMAP oldsrc = (HBITMAP)SelectObject(src, srcbmp);
 
        r.left = 0; r.top = 0;  r.right = tbButtonWH; r.bottom = tbButtonWH;
        // MakeGradient(src, r, pSettings->ToolbarButtonPressed->type, pSettings->ToolbarButtonPressed->Color, pSettings->ToolbarButtonPressed->ColorTo, pSettings->ToolbarButtonPressed->interlaced, pSettings->ToolbarButtonPressed->bevelstyle, pSettings->ToolbarButtonPressed->bevelposition, pSettings->bevelWidth, pSettings->ToolbarButtonPressed->borderColor, pSettings->ToolbarButtonPressed->borderWidth);
        MakeGradientEx(src, r, pSettings->ToolbarButtonPressed->type, pSettings->ToolbarButtonPressed->Color, pSettings->ToolbarButtonPressed->ColorTo, pSettings->ToolbarButtonPressed->Color3, pSettings->ToolbarButtonPressed->Color4, pSettings->ToolbarButtonPressed->interlaced, pSettings->ToolbarButtonPressed->bevelstyle, pSettings->ToolbarButtonPressed->bevelposition, pSettings->bevelWidth, pSettings->ToolbarButtonPressed->borderColor, pSettings->ToolbarButtonPressed->borderWidth);
 
        if (!pSettings->toolbarDownUpButtonsHidden && (pSettings->numberOfWorkspaces > 1))
        {
            if (ButtonPressed1) BitBlt(cachedBackground, button1Rect.left, button1Rect.top, tbButtonWH, tbButtonWH, src, 0, 0, SRCCOPY);
            if (ButtonPressed2) BitBlt(cachedBackground, button2Rect.left, button2Rect.top, tbButtonWH, tbButtonWH, src, 0, 0, SRCCOPY);
        }
 
        if (!pSettings->toolbarLeftRightButtonsHidden)
        {
            if (ButtonPressed3) BitBlt(cachedBackground, button3Rect.left, button3Rect.top, tbButtonWH, tbButtonWH, src, 0, 0, SRCCOPY);
            if (ButtonPressed4) BitBlt(cachedBackground, button4Rect.left, button4Rect.top, tbButtonWH, tbButtonWH, src, 0, 0, SRCCOPY);
        }
 
        SelectObject(src, oldsrc);
        DeleteDC(src);
        DeleteObject(srcbmp);
        DeleteObject(oldsrc);
    }
*/
    if (!pSettings->ToolbarButtonPressed->parentRelative)
    {
        if (!pSettings->toolbarDownUpButtonsHidden && (pSettings->numberOfWorkspaces > 1))
        {
            if (ButtonPressed1)
            {
                if (pSettings->ToolbarButtonPressed->type == B_IMAGEFROMFILE) DrawImageIntoRect(cachedBackground, button1Rect, pSettings->ToolbarButtonPressed, true, true);
                else MakeGradientSuper(cachedBackground, button1Rect, pSettings->ToolbarButtonPressed->type, pSettings->ToolbarButtonPressed->Color1, pSettings->ToolbarButtonPressed->Color2, pSettings->ToolbarButtonPressed->Color3, pSettings->ToolbarButtonPressed->Color4, pSettings->ToolbarButtonPressed->Color5, pSettings->ToolbarButtonPressed->Color6, pSettings->ToolbarButtonPressed->Color7, pSettings->ToolbarButtonPressed->Color8, pSettings->ToolbarButtonPressed->interlaced, pSettings->ToolbarButtonPressed->bevelstyle, pSettings->ToolbarButtonPressed->bevelposition, pSettings->bevelWidth, pSettings->ToolbarButtonPressed->borderColor, pSettings->ToolbarButtonPressed->borderWidth);
            }
            if (ButtonPressed2)
            {
                if (pSettings->ToolbarButtonPressed->type == B_IMAGEFROMFILE) DrawImageIntoRect(cachedBackground, button2Rect, pSettings->ToolbarButtonPressed, true, true);
                else MakeGradientSuper(cachedBackground, button2Rect, pSettings->ToolbarButtonPressed->type, pSettings->ToolbarButtonPressed->Color1, pSettings->ToolbarButtonPressed->Color2, pSettings->ToolbarButtonPressed->Color3, pSettings->ToolbarButtonPressed->Color4, pSettings->ToolbarButtonPressed->Color5, pSettings->ToolbarButtonPressed->Color6, pSettings->ToolbarButtonPressed->Color7, pSettings->ToolbarButtonPressed->Color8, pSettings->ToolbarButtonPressed->interlaced, pSettings->ToolbarButtonPressed->bevelstyle, pSettings->ToolbarButtonPressed->bevelposition, pSettings->bevelWidth, pSettings->ToolbarButtonPressed->borderColor, pSettings->ToolbarButtonPressed->borderWidth);
            }
        }
 
        if (!pSettings->toolbarLeftRightButtonsHidden)
        {
            if (ButtonPressed3)
            {
                if (pSettings->ToolbarButtonPressed->type == B_IMAGEFROMFILE) DrawImageIntoRect(cachedBackground, button3Rect, pSettings->ToolbarButtonPressed, true, true);
                else MakeGradientSuper(cachedBackground, button3Rect, pSettings->ToolbarButtonPressed->type, pSettings->ToolbarButtonPressed->Color1, pSettings->ToolbarButtonPressed->Color2, pSettings->ToolbarButtonPressed->Color3, pSettings->ToolbarButtonPressed->Color4, pSettings->ToolbarButtonPressed->Color5, pSettings->ToolbarButtonPressed->Color6, pSettings->ToolbarButtonPressed->Color7, pSettings->ToolbarButtonPressed->Color8, pSettings->ToolbarButtonPressed->interlaced, pSettings->ToolbarButtonPressed->bevelstyle, pSettings->ToolbarButtonPressed->bevelposition, pSettings->bevelWidth, pSettings->ToolbarButtonPressed->borderColor, pSettings->ToolbarButtonPressed->borderWidth);
            }
            if (ButtonPressed4)
            {
                if (pSettings->ToolbarButtonPressed->type == B_IMAGEFROMFILE) DrawImageIntoRect(cachedBackground, button4Rect, pSettings->ToolbarButtonPressed, true, true);
                else MakeGradientSuper(cachedBackground, button4Rect, pSettings->ToolbarButtonPressed->type, pSettings->ToolbarButtonPressed->Color1, pSettings->ToolbarButtonPressed->Color2, pSettings->ToolbarButtonPressed->Color3, pSettings->ToolbarButtonPressed->Color4, pSettings->ToolbarButtonPressed->Color5, pSettings->ToolbarButtonPressed->Color6, pSettings->ToolbarButtonPressed->Color7, pSettings->ToolbarButtonPressed->Color8, pSettings->ToolbarButtonPressed->interlaced, pSettings->ToolbarButtonPressed->bevelstyle, pSettings->ToolbarButtonPressed->bevelposition, pSettings->bevelWidth, pSettings->ToolbarButtonPressed->borderColor, pSettings->ToolbarButtonPressed->borderWidth);
            }
        }
    }
 
    //====================
 
    unsigned int format;
    HFONT font;
    HGDIOBJ oldfont;
 
    if (!pSettings->toolbarLabelHidden && (pSettings->numberOfWorkspaces > 1))
    {
        // Draw workspace label...
        if (pWorkspaces) strcpy(ToolbarWorkspaceName, (LPSTR)pWorkspaces->workspaceNames[pSettings->currentWorkspace].c_str());
        font = CreateFont(pSettings->ToolbarLabel->FontHeight, 0, 0, 0, pSettings->ToolbarLabel->FontWeight, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, pSettings->ToolbarLabel->Font);
        oldfont = SelectObject(cachedBackground, font);
        SetBkMode(cachedBackground, TRANSPARENT);
        format = pSettings->ToolbarLabel->Justify | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_WORD_ELLIPSIS;
        CopyRect(&r, &labelRect);
        r.left = r.left + pSettings->ToolbarLabel->marginWidth + 2;
        r.right = r.right - pSettings->ToolbarLabel->marginWidth - 2;
 
        char ToolbarWorkspaceNameANSI[MAX_LINE_LENGTH];
        strcpy(ToolbarWorkspaceNameANSI, ToolbarWorkspaceName);
        strcat(ToolbarWorkspaceNameANSI, "\0"); // Just in case...
        wchar_t ToolbarWorkspaceNameUnicode[MAX_LINE_LENGTH];
        MultiByteToWideChar(CP_UTF8, 0, ToolbarWorkspaceNameANSI, strlen(ToolbarWorkspaceNameANSI)+1, ToolbarWorkspaceNameUnicode, MAX_LINE_LENGTH);
 
        DrawTextWithEffectsUnicode(cachedBackground, r, ToolbarWorkspaceNameUnicode, format, pSettings->ToolbarLabel->TextColor, pSettings->ToolbarLabel->FontOutline, pSettings->ToolbarLabel->OutlineColor, pSettings->ToolbarLabel->FontShadow, pSettings->ToolbarLabel->ShadowColor, pSettings->ToolbarLabel->ShadowX, pSettings->ToolbarLabel->ShadowY);
 
        DeleteObject(SelectObject(cachedBackground, oldfont));
    }
 
    if (!pSettings->toolbarClockHidden)
    {
        // Draw clock...
        font = CreateFont(pSettings->ToolbarClock->FontHeight, 0, 0, 0, pSettings->ToolbarClock->FontWeight, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, pSettings->ToolbarClock->Font);
        oldfont = SelectObject(cachedBackground, font);
        SetBkMode(cachedBackground, TRANSPARENT);
        format = pSettings->ToolbarClock->Justify | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_WORD_ELLIPSIS;
        SetTextColor(cachedBackground, pSettings->ToolbarClock->TextColor);
        CopyRect(&r, &clockRect);
        r.left = r.left + pSettings->ToolbarClock->marginWidth + 2;
        r.right = r.right - pSettings->ToolbarClock->marginWidth - 2;
 
        DrawTextWithEffectsUnicode(cachedBackground, r, CurrentTime, format, pSettings->ToolbarClock->TextColor, pSettings->ToolbarClock->FontOutline, pSettings->ToolbarClock->OutlineColor, pSettings->ToolbarClock->FontShadow, pSettings->ToolbarClock->ShadowColor, pSettings->ToolbarClock->ShadowX, pSettings->ToolbarClock->ShadowY);
 
        DeleteObject(SelectObject(cachedBackground, oldfont));
    }
 
    //====================
 
    if (!pSettings->toolbarDownUpButtonsHidden || !pSettings->toolbarLeftRightButtonsHidden)
    {
        // Draw arrows on workspace/task buttons (nb. there is limited gain from
        // caching these since the button itself can be parentrelative)...
        HPEN activePen, inactivePen, oldPen;
 
        activePen = CreatePen(PS_SOLID, 1, pSettings->ToolbarButtonPressed->PicColor);
        inactivePen = CreatePen(PS_SOLID, 1, pSettings->ToolbarButton->PicColor);
 
        oldPen = (HPEN)SelectObject(cachedBackground, inactivePen);
 
        int xcenter;
        int xoffset = tbButtonWH / 2;
        int ycenter = button1Rect.top + tbButtonWH / 2;
 
        if (!pSettings->toolbarDownUpButtonsHidden && (pSettings->numberOfWorkspaces > 1))
        {
            xcenter = button1Rect.left + xoffset;
            if (ButtonPressed1) SelectObject(cachedBackground, activePen);
            DrawButtonGlyph(cachedBackground, TOOLBAR_BUTTON_GLYPH_DOWN, xcenter, ycenter);
            if (ButtonPressed1) SelectObject(cachedBackground, inactivePen);
 
            xcenter = button2Rect.left + xoffset;
            if (ButtonPressed2) SelectObject(cachedBackground, activePen);
            DrawButtonGlyph(cachedBackground, TOOLBAR_BUTTON_GLYPH_UP, xcenter, ycenter);
            if (ButtonPressed2) SelectObject(cachedBackground, inactivePen);
        }
 
        if (!pSettings->toolbarLeftRightButtonsHidden)
        {
            xcenter = button3Rect.left + xoffset;
            if (ButtonPressed3) SelectObject(cachedBackground, activePen);
            DrawButtonGlyph(cachedBackground, TOOLBAR_BUTTON_GLYPH_LEFT, xcenter, ycenter);
            if (ButtonPressed3) SelectObject(cachedBackground, inactivePen);
 
            xcenter = button4Rect.left + xoffset;
            if (ButtonPressed4) SelectObject(cachedBackground, activePen);
            DrawButtonGlyph(cachedBackground, TOOLBAR_BUTTON_GLYPH_RIGHT, xcenter, ycenter);
            if (ButtonPressed4) SelectObject(cachedBackground, inactivePen);
        }
 
        SelectObject(cachedBackground, oldPen);
        DeleteObject(inactivePen);
        DeleteObject(activePen);
    }
 
    //====================
 
    // Apply per pixel alpha, selectively per toolbar element... 8)
    SetRect(&r, 0, 0, ToolbarWidth, ToolbarHeight);
    AlphaRect(cachedBackground, r, pSettings->toolbarTransparencyAlpha);
 
    if (pSettings->numberOfWorkspaces > 1)
    {
        if (!pSettings->toolbarLabelHidden && (pSettings->toolbarLabelTransparencyAlpha != pSettings->toolbarTransparencyAlpha)) AlphaRect(cachedBackground, labelRect, pSettings->toolbarLabelTransparencyAlpha);
 
        if (!pSettings->toolbarDownUpButtonsHidden && !pSettings->ToolbarButton->parentRelative && (pSettings->toolbarButtonTransparencyAlpha != pSettings->toolbarTransparencyAlpha))
        {
            AlphaRect(cachedBackground, button1Rect, pSettings->toolbarButtonTransparencyAlpha);
            AlphaRect(cachedBackground, button2Rect, pSettings->toolbarButtonTransparencyAlpha);
        }
    }
 
    if (pSettings->taskbarMode == TASKBAR_MODE_HIDDEN) // -> Taskbar hidden, showing WindowLabel
    {
        if (pSettings->toolbarWindowLabelTransparencyAlpha != pSettings->toolbarTransparencyAlpha) AlphaRect(cachedBackground, winlabelRect, pSettings->toolbarWindowLabelTransparencyAlpha);
    }
 
    if (!pSettings->toolbarClockHidden && (pSettings->toolbarClockTransparencyAlpha != pSettings->toolbarTransparencyAlpha)) AlphaRect(cachedBackground, clockRect, pSettings->toolbarClockTransparencyAlpha);
 
    if (!pSettings->toolbarLeftRightButtonsHidden && !pSettings->ToolbarButton->parentRelative && (pSettings->toolbarButtonTransparencyAlpha != pSettings->toolbarTransparencyAlpha))
    {
        AlphaRect(cachedBackground, button3Rect, pSettings->toolbarButtonTransparencyAlpha);
        AlphaRect(cachedBackground, button4Rect, pSettings->toolbarButtonTransparencyAlpha);
    }
 
    if ((pSettings->taskbarMode != TASKBAR_MODE_HIDDEN) && pTaskbar->activeTaskAvailable) AlphaRect(cachedBackground, pTaskbar->ActiveTaskRect, pSettings->taskbarActiveTransparencyAlpha);
 
    if (pSettings->toolbarRoundedCorners)
    {
        int corners = 0;
        switch (pSettings->ToolbarPlacement.placement)
        {
            case PLACEMENT_TOP_LEFT: { corners = CORNER_BOTTOMRIGHT; break; }
            case PLACEMENT_CENTER_LEFT: { corners = CORNER_TOPRIGHT | CORNER_BOTTOMRIGHT; break; }
            case PLACEMENT_BOTTOM_LEFT: { corners = CORNER_TOPRIGHT; break; }
            case PLACEMENT_TOP_CENTER: { corners = CORNER_BOTTOMLEFT | CORNER_BOTTOMRIGHT; break; }
            case PLACEMENT_BOTTOM_CENTER: { corners = CORNER_TOPLEFT | CORNER_TOPRIGHT; break; }
            case PLACEMENT_TOP_RIGHT: { corners = CORNER_BOTTOMLEFT; break; }
            case PLACEMENT_CENTER_RIGHT: { corners = CORNER_TOPLEFT | CORNER_BOTTOMLEFT; break; }
            case PLACEMENT_BOTTOM_RIGHT: { corners = CORNER_TOPLEFT; break; }
            default: { corners = CORNER_TOPLEFT | CORNER_TOPRIGHT | CORNER_BOTTOMLEFT | CORNER_BOTTOMRIGHT; break; }
        }
 
        // Apply rounded corners to the toolbar itself...
        AlphaCorner(cachedBackground, r, corners, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->toolbarTransparencyAlpha);
 
        // Apply rounded "outer" corners (i.e. left/right corners respectively if horizontally oriented,
        // top/bottom corners respectively if vertically oriented) also to the toolbar label+clock if they are parentRelative...
        if (pSettings->toolbarVertical)
        {
            if (!pSettings->toolbarLabelHidden && pSettings->ToolbarLabel->parentRelative) AlphaCorner(cachedBackground, labelRect, (corners & (CORNER_TOPLEFT | CORNER_TOPRIGHT)), 0, 0, 0, pSettings->Toolbar->borderWidth, pSettings->toolbarTransparencyAlpha, pSettings->toolbarLabelTransparencyAlpha);
            if (!pSettings->toolbarClockHidden && pSettings->ToolbarClock->parentRelative) AlphaCorner(cachedBackground, clockRect, (corners & (CORNER_BOTTOMLEFT | CORNER_BOTTOMRIGHT)), 0, 0, 0, pSettings->Toolbar->borderWidth, pSettings->toolbarTransparencyAlpha, pSettings->toolbarClockTransparencyAlpha);
        }
        else
        {
            if (!pSettings->toolbarLabelHidden && pSettings->ToolbarLabel->parentRelative) AlphaCorner(cachedBackground, labelRect, (corners & (CORNER_TOPLEFT | CORNER_BOTTOMLEFT)), 0, 0, 0, pSettings->Toolbar->borderWidth, pSettings->toolbarTransparencyAlpha, pSettings->toolbarLabelTransparencyAlpha);
            if (!pSettings->toolbarClockHidden && pSettings->ToolbarClock->parentRelative) AlphaCorner(cachedBackground, clockRect, (corners & (CORNER_TOPRIGHT | CORNER_BOTTOMRIGHT)), 0, 0, 0, pSettings->Toolbar->borderWidth, pSettings->toolbarTransparencyAlpha, pSettings->toolbarClockTransparencyAlpha);
        }
    }
 
    AlphaApply(cachedBackground, r);
 
    //====================
 
    if (bufbmp) DeleteObject(bufbmp);
 
    POINT pt;
    pt.x = ToolbarX, pt.y = ToolbarY;
    POINT ptSrc;
    ptSrc.x = 0, ptSrc.y = 0;
 
    BLENDFUNCTION bf;
    bf.BlendOp = AC_SRC_OVER;
    bf.BlendFlags = 0;
    bf.AlphaFormat = AC_SRC_ALPHA;
    bf.SourceConstantAlpha = (unsigned char)255;
 
    SIZE windowSize = { ToolbarWidth, ToolbarHeight };
    BOOL result = UpdateLayeredWindow(hToolbarWnd, NULL, &pt, &windowSize, cachedBackground, &ptSrc, 0, &bf, ULW_ALPHA);
/*
    if (!cachedBackground) SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)"xoblite -> Toolbar -> Invalid cachedBackground!");
 
    if (result == 0)
    {
        int error = GetLastError();
        char msg[255];
        sprintf(msg, "xoblite -> Toolbar -> UpdateLayeredWindow failed! [error code %d]", error);
        SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_ERROR_MESSAGE, (LPARAM)msg);
    }
*/
}

DrawWindowLabel()

void Toolbar::DrawWindowLabel	(	HDC	hdc,
		RECT	r,
		bool	backgroundOnly )

{
    // Delete any existing taskbar tooltips... (just in case)
    if (pSettings->taskbarTooltips) pTooltips->DeleteAllTooltips();
 
    //====================
 
    RECT wlRect, wlTextRect;
    CopyRect(&wlRect, &r);
//  if (pSettings->toolbarVertical && (pSettings->taskbarMode == TASKBAR_MODE_HIDDEN)) wlRect.bottom -= pSettings->Toolbar->marginWidth;
    CopyRect(&wlTextRect, &wlRect);
 
    //====================
 
    // Has the windowLabel bounding rect changed since we last
    // cached it? If so, let's create a new cached bitmap...
    if (!EqualRect(&currentWindowLabelRect, &wlRect))
    {
        CopyRect(&currentWindowLabelRect, &wlRect);
        currentWindowLabelWidth = wlRect.right - wlRect.left;
        currentWindowLabelHeight = wlRect.bottom - wlRect.top;
 
        if (!pSettings->ToolbarWindowLabel->parentRelative)
        {
            // Create a temporary bitmap...
            HBITMAP tempBitmap = CreateCompatibleBitmap(hdc, currentWindowLabelWidth, currentWindowLabelHeight);
            // Delete the previously cached gradient...
            HBITMAP oldBitmap = (HBITMAP)SelectObject(cachedToolbarWindowLabel, tempBitmap);
            DeleteObject(oldBitmap);
            // Paint the windowLabel background...
            r.left = 0; r.top = 0;  r.right = currentWindowLabelWidth; r.bottom = currentWindowLabelHeight;
            if (pSettings->ToolbarWindowLabel->type == B_IMAGEFROMFILE) DrawImageIntoRect(cachedToolbarWindowLabel, r, pSettings->ToolbarWindowLabel, false, true);
            else MakeGradientSuper(cachedToolbarWindowLabel, r, pSettings->ToolbarWindowLabel->type, pSettings->ToolbarWindowLabel->Color1, pSettings->ToolbarWindowLabel->Color2, pSettings->ToolbarWindowLabel->Color3, pSettings->ToolbarWindowLabel->Color4, pSettings->ToolbarWindowLabel->Color5, pSettings->ToolbarWindowLabel->Color6, pSettings->ToolbarWindowLabel->Color7, pSettings->ToolbarWindowLabel->Color8, pSettings->ToolbarWindowLabel->interlaced, pSettings->ToolbarWindowLabel->bevelstyle, pSettings->ToolbarWindowLabel->bevelposition, pSettings->bevelWidth, pSettings->ToolbarWindowLabel->borderColor, pSettings->ToolbarWindowLabel->borderWidth);
            // Clean up - delete the temporary bitmap...
            DeleteObject(tempBitmap);
        }
    }
 
    //====================
 
    if (!pSettings->ToolbarWindowLabel->parentRelative)
    {
        // Copy the cached bitmap into the temporary buffer...
        BitBlt(hdc, wlRect.left, wlRect.top, currentWindowLabelWidth, currentWindowLabelHeight, cachedToolbarWindowLabel, 0, 0, SRCCOPY);
 
        // Below: Simple placeholder hack to allow image alpha for the otherwise pre-cached ToolbarWindowLabel too...
//      if (pSettings->ToolbarWindowLabel->type == B_IMAGEFROMFILE) DrawImageIntoRect(hdc, wlRect, pSettings->ToolbarWindowLabel, false, true);
//      else BitBlt(hdc, wlRect.left, wlRect.top, currentWindowLabelWidth, currentWindowLabelHeight, cachedToolbarWindowLabel, 0, 0, SRCCOPY);
    }
 
    //====================
 
    if (!backgroundOnly)
    {
        // Draw window label...
 
        HFONT font = CreateFont(pSettings->ToolbarWindowLabel->FontHeight, 0, 0, 0, pSettings->ToolbarWindowLabel->FontWeight, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH|FF_DONTCARE, pSettings->ToolbarWindowLabel->Font);
        HGDIOBJ oldfont = SelectObject(hdc, font);
        SetBkMode(hdc, TRANSPARENT);
 
//      wlTextRect.left = wlTextRect.left + 3;
//      wlTextRect.right = wlTextRect.right - 3;
        // Using the same padding as for the taskbar... (-> looks better, unified look =] )
        int windowLabelHeight = wlTextRect.bottom - wlTextRect.top;
        int iconSize = 11;
        if (windowLabelHeight > 20) iconSize = 16;
        int padding = ((windowLabelHeight - iconSize) / 2);
        InflateRect(&wlTextRect, -padding, 0);
 
        unsigned int format = pSettings->ToolbarWindowLabel->Justify | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_WORD_ELLIPSIS;
 
        if (wcslen(CurrentWindow)) DrawTextWithEffectsUnicode(hdc, wlTextRect, CurrentWindow, format, pSettings->ToolbarWindowLabel->TextColor, pSettings->ToolbarWindowLabel->FontOutline, pSettings->ToolbarWindowLabel->OutlineColor, pSettings->ToolbarWindowLabel->FontShadow, pSettings->ToolbarWindowLabel->ShadowColor, pSettings->ToolbarWindowLabel->ShadowX, pSettings->ToolbarWindowLabel->ShadowY);
        else DrawTextWithEffects(hdc, wlTextRect, "Welcome to xoblite.", format, pSettings->ToolbarWindowLabel->TextColor, pSettings->ToolbarWindowLabel->FontOutline, pSettings->ToolbarWindowLabel->OutlineColor, pSettings->ToolbarWindowLabel->FontShadow, pSettings->ToolbarWindowLabel->ShadowColor, pSettings->ToolbarWindowLabel->ShadowX, pSettings->ToolbarWindowLabel->ShadowY);
 
        DeleteObject(SelectObject(hdc, oldfont));
    }
}

DrawButtonGlyph()

void Toolbar::DrawButtonGlyph	(	HDC	hdc,
		int	glyph,
		int	xcenter,
		int	ycenter )

{
    switch (glyph)
    {
        case TOOLBAR_BUTTON_GLYPH_DOWN:
        {
            if (pSettings->doubleScaleHiDPI)
            {
                MoveToEx(hdc, xcenter, ycenter+2, NULL);
                LineTo(hdc, xcenter+1, ycenter+2);
                MoveToEx(hdc, xcenter-1, ycenter+1, NULL);
                LineTo(hdc, xcenter+2, ycenter+1);
                MoveToEx(hdc, xcenter-2, ycenter, NULL);
                LineTo(hdc, xcenter+3, ycenter);
                MoveToEx(hdc, xcenter-3, ycenter-1, NULL);
                LineTo(hdc, xcenter+4, ycenter-1);
                MoveToEx(hdc, xcenter-4, ycenter-2, NULL);
                LineTo(hdc, xcenter+5, ycenter-2);
            }
            else
            {
                MoveToEx(hdc, xcenter, ycenter+1, NULL);
                LineTo(hdc, xcenter+1, ycenter+1);
                MoveToEx(hdc, xcenter-1, ycenter, NULL);
                LineTo(hdc, xcenter+2, ycenter);
                MoveToEx(hdc, xcenter-2, ycenter-1, NULL);
                LineTo(hdc, xcenter+3, ycenter-1);
            }
 
            return;
        }
 
        //====================
 
        case TOOLBAR_BUTTON_GLYPH_UP:
        {
            if (pSettings->doubleScaleHiDPI)
            {
                MoveToEx(hdc, xcenter, ycenter-2, NULL);
                LineTo(hdc, xcenter+1, ycenter-2);
                MoveToEx(hdc, xcenter-1, ycenter-1, NULL);
                LineTo(hdc, xcenter+2, ycenter-1);
                MoveToEx(hdc, xcenter-2, ycenter, NULL);
                LineTo(hdc, xcenter+3, ycenter);
                MoveToEx(hdc, xcenter-3, ycenter+1, NULL);
                LineTo(hdc, xcenter+4, ycenter+1);
                MoveToEx(hdc, xcenter-4, ycenter+2, NULL);
                LineTo(hdc, xcenter+5, ycenter+2);
            }
            else
            {
                MoveToEx(hdc, xcenter, ycenter-1, NULL);
                LineTo(hdc, xcenter+1, ycenter-1);
                MoveToEx(hdc, xcenter-1, ycenter, NULL);
                LineTo(hdc, xcenter+2, ycenter);
                MoveToEx(hdc, xcenter-2, ycenter+1, NULL);
                LineTo(hdc, xcenter+3, ycenter+1);
            }
 
            return;
        }
 
        //====================
 
        case TOOLBAR_BUTTON_GLYPH_LEFT:
        {
            if (pSettings->doubleScaleHiDPI)
            {
                MoveToEx(hdc, xcenter-2, ycenter, NULL);
                LineTo(hdc, xcenter-2, ycenter+1);
                MoveToEx(hdc, xcenter-1, ycenter-1, NULL);
                LineTo(hdc, xcenter-1, ycenter+2);
                MoveToEx(hdc, xcenter, ycenter-2, NULL);
                LineTo(hdc, xcenter, ycenter+3);
                MoveToEx(hdc, xcenter+1, ycenter-3, NULL);
                LineTo(hdc, xcenter+1, ycenter+4);
                MoveToEx(hdc, xcenter+2, ycenter-4, NULL);
                LineTo(hdc, xcenter+2, ycenter+5);
            }
            else
            {
                MoveToEx(hdc, xcenter-1, ycenter, NULL);
                LineTo(hdc, xcenter-1, ycenter+1);
                MoveToEx(hdc, xcenter, ycenter-1, NULL);
                LineTo(hdc, xcenter, ycenter+2);
                MoveToEx(hdc, xcenter+1, ycenter-2, NULL);
                LineTo(hdc, xcenter+1, ycenter+3);
            }
 
            return;
        }
 
        //====================
 
        case TOOLBAR_BUTTON_GLYPH_RIGHT:
        {
            if (pSettings->doubleScaleHiDPI)
            {
                MoveToEx(hdc, xcenter-2, ycenter-4, NULL);
                LineTo(hdc, xcenter-2, ycenter+5);
                MoveToEx(hdc, xcenter-1, ycenter-3, NULL);
                LineTo(hdc, xcenter-1, ycenter+4);
                MoveToEx(hdc, xcenter, ycenter-2, NULL);
                LineTo(hdc, xcenter, ycenter+3);
                MoveToEx(hdc, xcenter+1, ycenter-1, NULL);
                LineTo(hdc, xcenter+1, ycenter+2);
                MoveToEx(hdc, xcenter+2, ycenter, NULL);
                LineTo(hdc, xcenter+2, ycenter+1);
            }
            else
            {
                MoveToEx(hdc, xcenter-1, ycenter-2, NULL);
                LineTo(hdc, xcenter-1, ycenter+3);
                MoveToEx(hdc, xcenter, ycenter-1, NULL);
                LineTo(hdc, xcenter, ycenter+2);
                MoveToEx(hdc, xcenter+1, ycenter, NULL);
                LineTo(hdc, xcenter+1, ycenter+1);
            }
 
            return;
        }
    }
}

GetClockText()

bool Toolbar::GetClockText

(

bool

forceUpdate

)

{
    time(&systemTime);
    localtime_s(&localTime, &systemTime);
    currentMinute = localTime.tm_min;
 
    // Only update the toolbar clock if the current minute has changed...
    if ((currentMinute != displayedMinute) || forceUpdate)
    {
        // Format the toolbar clock string based on the related xoblite.rc setting... (nb. we need to convert the format string from ANSI to Unicode first)
        wchar_t toolbarClockFormatInUnicode[MAX_LINE_LENGTH];
        MultiByteToWideChar(CP_UTF8, 0, pSettings->toolbarClockFormat, strlen(pSettings->toolbarClockFormat)+1, toolbarClockFormatInUnicode, MAX_LINE_LENGTH);
        wcsftime(CurrentTime, sizeof(CurrentTime), toolbarClockFormatInUnicode, &localTime);
 
        // Remember minute shown in display, now wait until minute changes before updating again...
        displayedMinute = currentMinute;
 
        return true;
    }
    else return false;
}

GetDimensions()

void Toolbar::GetDimensions

(

)

{
//  ScreenWidth = GetSystemMetrics(SM_CXSCREEN);
//  ScreenHeight = GetSystemMetrics(SM_CYSCREEN);
 
    int ScreenLeft, ScreenTop;
 
    if (!pSettings->explorerHidden)
    {
        RECT workArea;
        SystemParametersInfo(SPI_GETWORKAREA, 0, (PVOID)&workArea, SPIF_SENDCHANGE);
        ScreenLeft = workArea.left;
        ScreenTop = workArea.top;
        ScreenWidth = workArea.right - workArea.left;
        ScreenHeight = workArea.bottom - workArea.top;
    }
    else
    {
        ScreenLeft = GetSystemMetrics(SM_XVIRTUALSCREEN);
        ScreenTop = GetSystemMetrics(SM_YVIRTUALSCREEN);
        ScreenWidth = GetSystemMetrics(SM_CXVIRTUALSCREEN);
        ScreenHeight = GetSystemMetrics(SM_CYVIRTUALSCREEN);
    }
 
    //====================
 
    // Calculate element heights...
 
    int toolbarMarginPlusBorder = pSettings->Toolbar->marginWidth + pSettings->Toolbar->borderWidth;
 
    tbLabelH = pSettings->ToolbarLabel->FontHeight + (2 * pSettings->ToolbarLabel->marginWidth) + (2 * pSettings->ToolbarLabel->borderWidth);
    tbWinLabelH = pSettings->ToolbarWindowLabel->FontHeight + (2 * pSettings->ToolbarWindowLabel->marginWidth) + (2 * pSettings->ToolbarWindowLabel->borderWidth);
    tbClockH = pSettings->ToolbarClock->FontHeight + (2 * pSettings->ToolbarClock->marginWidth) + (2 * pSettings->ToolbarClock->borderWidth);
 
    int glyphSize = 7;
    if (pSettings->doubleScaleHiDPI) glyphSize += 4;
    tbButtonWH = glyphSize + (2 * pSettings->ToolbarButton->marginWidth) + (2 * pSettings->ToolbarButton->borderWidth);
    tbButtonWH = tbButtonWH | 1; // Force odd sized buttons for glyphs to be centered...
 
    int maxHeight = 15; // Minimum height 15 pixels
    if (tbLabelH > maxHeight) maxHeight = tbLabelH;
    if (tbWinLabelH > maxHeight) maxHeight = tbWinLabelH;
    if (tbClockH > maxHeight) maxHeight = tbClockH;
    if (tbButtonWH > maxHeight) maxHeight = tbButtonWH;
    maxHeight = maxHeight | 1; // Force odd size for buttons/glyphs to be centered...
 
    tbLabelH = tbWinLabelH = tbClockH = maxHeight;
 
    int extraButtonPadding = (maxHeight - tbButtonWH) / 2;
 
    //====================
 
    // Calculate the toolbar workspace label and clock widths...
 
    SIZE size;
    HDC fonthdc = CreateDC("DISPLAY", NULL, NULL, NULL);
 
    // Get the width of the toolbar workspace label...
    HFONT tempfont = CreateFont(pSettings->ToolbarLabel->FontHeight, 0, 0, 0, pSettings->ToolbarLabel->FontWeight, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH|FF_DONTCARE, pSettings->ToolbarLabel->Font);
    HGDIOBJ oldtempfont = SelectObject(fonthdc, tempfont);
    if (pWorkspaces) strcpy(ToolbarWorkspaceName, (LPSTR)pWorkspaces->workspaceNames[pSettings->currentWorkspace].c_str());
    GetTextExtentPoint32(fonthdc, ToolbarWorkspaceName, strlen(ToolbarWorkspaceName), &size);
//  tbLabelW = size.cx + 6 + (2 * pSettings->ToolbarLabel->marginWidth) + (2 * pSettings->ToolbarLabel->borderWidth);
    tbLabelW = size.cx + (2 * (tbLabelH - pSettings->ToolbarLabel->FontHeight)) + (2 * pSettings->ToolbarLabel->marginWidth) + (2 * pSettings->ToolbarLabel->borderWidth);
 
    // Get the width of the toolbar clock...
    DeleteObject(SelectObject(fonthdc, oldtempfont));
    tempfont = CreateFont(pSettings->ToolbarClock->FontHeight, 0, 0, 0, pSettings->ToolbarClock->FontWeight, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH|FF_DONTCARE, pSettings->ToolbarClock->Font);
    oldtempfont = SelectObject(fonthdc, tempfont);
    GetTextExtentPoint32W(fonthdc, CurrentTime, wcslen(CurrentTime), &size);
//  tbClockW = size.cx + 6 + (2 * pSettings->ToolbarClock->marginWidth) + (2 * pSettings->ToolbarClock->borderWidth);
    tbClockW = size.cx + (2 * (tbClockH - pSettings->ToolbarClock->FontHeight)) + (2 * pSettings->ToolbarClock->marginWidth) + (2 * pSettings->ToolbarClock->borderWidth);
 
    if ((pSettings->toolbarLabelHidden || (pSettings->numberOfWorkspaces < 2)) && pSettings->toolbarClockHidden)
    {
        // Both the workspace label and the clock are hidden...
        tbLabelW = tbLabelH = tbClockW = tbClockH = 0;
    }
    else if (pSettings->toolbarLabelHidden || (pSettings->numberOfWorkspaces < 2))
    {
        // Only the workspace label is hidden...
        tbLabelW = tbLabelH = 0;
    }
    else if (pSettings->toolbarClockHidden)
    {
        // Only the toolbar clock is hidden...
        tbClockW = tbClockH = 0;
    }
    else if (!pSettings->toolbarAllowAsymmetry || pSettings->toolbarVertical)
    {
        // Both the workspace label and the clock are visible, so unless we're using horizontal orientation
        // *and* asymmetry between the two is configured allowed, the widest of the two sets the width...
        if (tbClockW > tbLabelW) tbLabelW = tbClockW;
        else tbClockW = tbLabelW;
    }
 
    DeleteObject(SelectObject(fonthdc, oldtempfont));
    DeleteDC(fonthdc);
 
    //====================
 
    // Get number of taskbar buttons to draw... (nb. this also honours any configured maximum number of taskbar items)
    pTaskbar->GetTaskButtonsToDraw();
 
    //====================
 
    // ##### Horizontal toolbar orientation (default) #####
 
    if (!pSettings->toolbarVertical)
    {
        // If the toolbar width is configured as <= 100 this defines its width as a percentage of the screen width,
        // and if configured as > 100 this defines its width in number of pixels...
        if (pSettings->toolbarHorizontalWidth <= 100)
        {
            ToolbarWidth = (ScreenWidth * pSettings->toolbarHorizontalWidth) / 100;
        }
        else ToolbarWidth = pSettings->toolbarHorizontalWidth;
 
        //====================
 
        // The toolbar height must be a minimum 17 pixels for the taskbar buttons to
        // look decent, so if it is not we need to adjust the element heights accordingly...
 
        ToolbarHeight = maxHeight + (2 * toolbarMarginPlusBorder);
 
        if (ToolbarHeight < 17)
        {
            int diffHeight = 17 - ToolbarHeight;
            ToolbarHeight = 17;
            maxHeight += diffHeight;
            extraButtonPadding = (maxHeight - tbButtonWH) / 2;
            tbLabelH = tbWinLabelH = tbClockH = maxHeight;
            tbLabelW = tbClockW += (2*diffHeight);
 
            if (pSettings->numberOfWorkspaces < 2) tbLabelW = tbLabelH = 0;
        }
 
        //====================
 
        // Adaptively calculate each toolbar element's position depending on the visibility of the other toolbar elements...
 
        int offsetLeftX = toolbarMarginPlusBorder;
        int offsetRightX = ToolbarWidth - toolbarMarginPlusBorder;
        int offsetY = toolbarMarginPlusBorder;
 
        if (!pSettings->toolbarLabelHidden && (pSettings->numberOfWorkspaces > 1))
        {
            tbLabelX = offsetLeftX;
            tbLabelY = offsetY;
            offsetLeftX += (tbLabelW + pSettings->Toolbar->marginWidth);
        }
 
        if (!pSettings->toolbarDownUpButtonsHidden && (pSettings->numberOfWorkspaces > 1))
        {
            tbButtonX1 = offsetLeftX + extraButtonPadding;
            tbButtonX2 = tbButtonX1 + tbButtonWH + extraButtonPadding + pSettings->Toolbar->marginWidth;
            offsetLeftX += ((2*tbButtonWH) + (3*extraButtonPadding) + (2*pSettings->Toolbar->marginWidth));
        }
 
        if (!pSettings->toolbarClockHidden)
        {
            tbClockX = offsetRightX - tbClockW;
            tbClockY = offsetY;
            offsetRightX -= (tbClockW + pSettings->Toolbar->marginWidth);
        }
 
        if (!pSettings->toolbarLeftRightButtonsHidden)
        {
            tbButtonX4 = offsetRightX - extraButtonPadding - tbButtonWH;
            tbButtonX3 = tbButtonX4 - extraButtonPadding - pSettings->Toolbar->marginWidth - tbButtonWH;
            offsetRightX -= ((2*tbButtonWH) + (3*extraButtonPadding) + (2*pSettings->Toolbar->marginWidth));
        }
 
        tbButtonY = (ToolbarHeight - tbButtonWH) / 2;
 
        tbWinLabelX = offsetLeftX;
        tbWinLabelY = offsetY;
        tbWinLabelW = offsetRightX - offsetLeftX;
        if (tbWinLabelW < 0) tbWinLabelW = 0; // Make sure windowlabel width is acceptable; could be < 0 if toolbar width (percentage) is too small!
 
/*
        tbLabelX = toolbarMarginPlusBorder;
        tbLabelY = tbLabelX;
 
        tbClockX = ToolbarWidth - tbClockW - toolbarMarginPlusBorder;
        tbClockY = tbLabelY;
 
        if (pSettings->numberOfWorkspaces > 1)
        {
            tbWinLabelX = tbLabelX + tbLabelW + (2*tbButtonWH) + (3*pSettings->Toolbar->marginWidth) + (3*extraButtonPadding);
            tbWinLabelY = tbLabelY;
            tbWinLabelW = ToolbarWidth - (2*tbWinLabelX);
        }
        else
        {
            tbWinLabelX = tbLabelX;
            tbWinLabelY = tbLabelY;
            tbWinLabelW = ToolbarWidth - (2*tbLabelX) - tbClockW - (2*tbButtonWH) - (3*pSettings->Toolbar->marginWidth) - (3*extraButtonPadding);
        }
 
        // Make sure windowlabel width is acceptable, could be < 0 if toolbar width (percentage) is too small!
        if (tbWinLabelW < 0) tbWinLabelW = 0;
 
        tbButtonX1 = tbLabelX + tbLabelW + pSettings->Toolbar->marginWidth + extraButtonPadding;
        tbButtonX2 = tbButtonX1 + tbButtonWH + pSettings->Toolbar->marginWidth + extraButtonPadding;
        tbButtonX3 = tbWinLabelX + tbWinLabelW + pSettings->Toolbar->marginWidth + extraButtonPadding;
        tbButtonX4 = tbButtonX3 + tbButtonWH + pSettings->Toolbar->marginWidth + extraButtonPadding;
 
//      tbButtonWH = maxHeight;
//      tbButtonY = toolbarMarginPlusBorder;
        tbButtonY = (ToolbarHeight - tbButtonWH) / 2;
*/
    }
 
    //====================
 
    // ##### Vertical toolbar orientation #####
 
    else
    {
        // In vertical mode the windowlabel width == the clock width, or the minimum width defined in xoblite.rc...
 
        if (toolbarVerticalPeeking) tbWinLabelW = (ScreenWidth / 2) - (2 * toolbarMarginPlusBorder);
        else if (pSettings->toolbarVerticalWidth >= 70) // Minimum safeguard width is 70 pixels, otherwise fallback to automatic width
        {
            tbWinLabelW = pSettings->toolbarVerticalWidth - (2 * toolbarMarginPlusBorder);
            if (pSettings->doubleScaleHiDPI) tbWinLabelW += pSettings->toolbarVerticalWidth; // -> "HiDPI 2x"
        }
        else if (tbClockW > 0) tbWinLabelW = tbClockW;
        else if (tbLabelW > 0) tbWinLabelW = tbLabelW;
        else tbWinLabelW = (ScreenWidth / 10); // Failsafe
 
        tbLabelW = tbClockW = tbWinLabelW;
 
        //====================
 
        ToolbarWidth = tbWinLabelW + (toolbarMarginPlusBorder * 2);
 
        // Simple failsafe: Perform an additional width check in case the toolbar buttons are *unusually* large...
        // (i.e. using very large toolbar.button.marginwidth's *cough* Pitkon *cough* ;) )
        if (!pSettings->toolbarDownUpButtonsHidden || !pSettings->toolbarLeftRightButtonsHidden)
        {
            int buttonsCheckWidth;
            if (pSettings->numberOfWorkspaces > 1) buttonsCheckWidth = (tbButtonWH * 4) + (pSettings->Toolbar->marginWidth * 10) + (toolbarMarginPlusBorder * 2);
            else buttonsCheckWidth = (tbButtonWH * 2) + (pSettings->Toolbar->marginWidth * 4) + (toolbarMarginPlusBorder * 2);
            if (ToolbarWidth < buttonsCheckWidth)
            {
                ToolbarWidth = buttonsCheckWidth;
                tbWinLabelW = tbClockW = ToolbarWidth - (toolbarMarginPlusBorder * 2);
                if (tbLabelW > 0) tbLabelW = tbWinLabelW;
            }
        }
 
        //====================
 
        // Adaptively calculate each toolbar element's position depending on the visibility of the other toolbar elements...
 
        int offsetX = toolbarMarginPlusBorder;
        int offsetY = toolbarMarginPlusBorder;
 
        if (!pSettings->toolbarLabelHidden && (pSettings->numberOfWorkspaces > 1))
        {
            tbLabelX = offsetX;
            tbLabelY = offsetY;
            offsetY += (tbLabelH + pSettings->Toolbar->marginWidth);
        }
 
        tbWinLabelX = offsetX;
        tbWinLabelY = offsetY;
        if ((pSettings->taskbarMode != TASKBAR_MODE_HIDDEN) && (pTaskbar->taskButtonsToDraw > 0))
        {
            tbWinLabelH = tbWinLabelH * pTaskbar->taskButtonsToDraw;
//          tbWinLabelH -= pSettings->Toolbar->marginWidth; // ...because we only add extra padding in between the task buttons... (i.e. remove last added padding)
 
            // If applicable, add some room vertically for taskbar scrolling indicators at *both* ends of the taskbar...
            // (nb. we need to do this because we do *not* recalculate the toolbar height upon taskbar scrolling only, i.e. no or either or both indicator(s) may be visible)
            int leftTopPadding = 0, rightBottomPadding = 0;
            int taskbarScrollIndicatorSize = pTaskbar->GetTaskbarScrollIndicatorSizes(&leftTopPadding, &rightBottomPadding);
            if ((leftTopPadding > 0) || (rightBottomPadding > 0)) tbWinLabelH += (taskbarScrollIndicatorSize * 2);
        }
        offsetY += tbWinLabelH;
 
        if ((!pSettings->toolbarDownUpButtonsHidden && (pSettings->numberOfWorkspaces > 1)) || !pSettings->toolbarLeftRightButtonsHidden)
        {
            if ((!pSettings->toolbarDownUpButtonsHidden && (pSettings->numberOfWorkspaces > 1)) && !pSettings->toolbarLeftRightButtonsHidden)
            {
                tbButtonX1 = offsetX + (extraButtonPadding*2);
                tbButtonX2 = tbButtonX1 + tbButtonWH + pSettings->Toolbar->marginWidth + extraButtonPadding;
                tbButtonX3 = ToolbarWidth - tbButtonX2 - tbButtonWH;
                tbButtonX4 = ToolbarWidth - tbButtonX1 - tbButtonWH;
            }
            else if (!pSettings->toolbarDownUpButtonsHidden && (pSettings->numberOfWorkspaces > 1))
            {
                tbButtonX1 = (ToolbarWidth/2) - (pSettings->Toolbar->marginWidth/2) - (extraButtonPadding/2) - tbButtonWH;
                tbButtonX2 = tbButtonX1 + tbButtonWH + pSettings->Toolbar->marginWidth + extraButtonPadding;
            }
            else if (!pSettings->toolbarLeftRightButtonsHidden)
            {
                tbButtonX3 = (ToolbarWidth/2) - (pSettings->Toolbar->marginWidth/2) - (extraButtonPadding/2) - tbButtonWH;
                tbButtonX4 = tbButtonX3 + tbButtonWH + pSettings->Toolbar->marginWidth + extraButtonPadding;
            }
 
            tbButtonY = offsetY + pSettings->Toolbar->marginWidth + extraButtonPadding;
            offsetY += (pSettings->Toolbar->marginWidth + tbButtonWH + (extraButtonPadding * 2));
        }
 
        if (!pSettings->toolbarClockHidden)
        {
            tbClockX = offsetX;
            tbClockY = offsetY + pSettings->Toolbar->marginWidth;
            offsetY += (pSettings->Toolbar->marginWidth + tbClockH);
        }
 
        ToolbarHeight = offsetY + toolbarMarginPlusBorder;
 
 
 
 
 
 
 
/*
        if (pSettings->numberOfWorkspaces > 1)
        {
            tbWinLabelY = tbLabelY + tbLabelH + pSettings->Toolbar->marginWidth;
        }
        else tbWinLabelY = toolbarMarginPlusBorder;
 
        tbButtonX1 = tbWinLabelX + (extraButtonPadding*2);
        tbButtonX2 = tbButtonX1 + tbButtonWH + pSettings->Toolbar->marginWidth + extraButtonPadding;
        if (pSettings->numberOfWorkspaces > 1)
        {
            tbButtonX3 = ToolbarWidth - tbButtonX2 - tbButtonWH;
            tbButtonX4 = ToolbarWidth - tbButtonX1 - tbButtonWH;
        }
        else
        {
            int twoButtonsWidth = tbButtonX2 + tbButtonWH - tbButtonX1;
            tbButtonX3 = (ToolbarWidth/2) - (twoButtonsWidth/2);
            tbButtonX4 = tbButtonX3 + tbButtonWH + pSettings->Toolbar->marginWidth + extraButtonPadding;
        }
        tbButtonY = tbWinLabelY + tbWinLabelH + extraButtonPadding;
 
        tbClockY = tbButtonY + tbButtonWH + extraButtonPadding + pSettings->Toolbar->marginWidth;
 
//      tbButtonY = tbLabelY + tbLabelH + pSettings->Toolbar->marginWidth + extraButtonPadding;
//      tbWinLabelY = tbButtonY + tbButtonWH + extraButtonPadding + pSettings->Toolbar->marginWidth;
//      tbClockY = tbWinLabelY + tbWinLabelH;
 
        ToolbarHeight = tbClockY + tbClockH + toolbarMarginPlusBorder;
*/
    }
 
    //====================
 
    // Save the element rect's so we can later on e.g. check if a specific element has been clicked...
    SetRect(&labelRect, tbLabelX, tbLabelY, tbLabelX+tbLabelW, tbLabelY+tbLabelH);
    SetRect(&winlabelRect, tbWinLabelX, tbWinLabelY, tbWinLabelX+tbWinLabelW, tbWinLabelY+tbWinLabelH);
    SetRect(&clockRect, tbClockX, tbClockY, tbClockX+tbClockW, tbClockY+tbClockH);
 
    SetRect(&button1Rect, tbButtonX1, tbButtonY, tbButtonX1+tbButtonWH, tbButtonY+tbButtonWH);
    SetRect(&button2Rect, tbButtonX2, tbButtonY, tbButtonX2+tbButtonWH, tbButtonY+tbButtonWH);
    SetRect(&button3Rect, tbButtonX3, tbButtonY, tbButtonX3+tbButtonWH, tbButtonY+tbButtonWH);
    SetRect(&button4Rect, tbButtonX4, tbButtonY, tbButtonX4+tbButtonWH, tbButtonY+tbButtonWH);
}

GetPlacement()

void Toolbar::GetPlacement

(

)

{
    pSettings->ToolbarPlacement.width = ToolbarWidth;
    pSettings->ToolbarPlacement.height = ToolbarHeight;
 
    // If toolbar width is defined in pixels (i.e. > 100) or if the toolbar
    // is vertically oriented we treat the position as relative to the entire
    // virtual screen, i.e. with multi monitor support...
//  if (pSettings->toolbarVertical || (pSettings->toolbarHorizontalWidth > 100)) pSettings->PositionFromPlacement(&pSettings->ToolbarPlacement, true);
    // ...and if toolbar is defined as a percentage of the screen width
    // (i.e. <= 100) we treat the position as relative to the main screen/monitor...
//  else pSettings->PositionFromPlacement(&pSettings->ToolbarPlacement, false);
 
//  if (pSettings->ToolbarPlacement.placement == PLACEMENT_MANUAL) pSettings->PositionFromPlacement(&pSettings->ToolbarPlacement, true);
//  else pSettings->PositionFromPlacement(&pSettings->ToolbarPlacement, false);
    pSettings->PositionFromPlacement(&pSettings->ToolbarPlacement);
 
    ToolbarX = pSettings->ToolbarPlacement.x;
    ToolbarY = pSettings->ToolbarPlacement.y;
}

UpdatePosition()

void Toolbar::UpdatePosition

(

)

{
//  if (pSettings->debugLogging) SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)"Toolbar -> UpdatePosition()");
 
    // Fetch the new size and position parameters for our window...
    GetDimensions();
    GetPlacement();
 
    // Force re-rendering of the background, windowLabel and task button bitmaps...
    cachedBitmapsExist = false;
    if (pSettings->taskbarMode != TASKBAR_MODE_HIDDEN) pTaskbar->cachedTaskButtonsExist = false;
    else SetRectEmpty(&currentWindowLabelRect);
 
    // Update the toolbar window...
    UpdateToolbarWindow();
 
    // Update the always on top setting for the toolbar window...
    if (pSettings->toolbarOnTop) SetWindowPos(hToolbarWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE);
    else SetWindowPos(hToolbarWnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE);
 
    // Update the desktop area...
//  UpdateDesktopArea();
 
    // Save placement to xoblite.rc...
//  pSettings->WritePlacement(&pSettings->ToolbarPlacement);
}

MoveToMouse()

void Toolbar::MoveToMouse

(

)

{
    POINT pos;
    GetCursorPos(&pos);
    ToolbarX = pos.x - (ToolbarWidth / 2);
    ToolbarY = pos.y - (ToolbarHeight / 2);
 
    SetWindowPos(hToolbarWnd, HWND_TOP, ToolbarX, ToolbarY, 0, 0, SWP_NOSIZE | SWP_NOREDRAW);
    SetForegroundWindow(hToolbarWnd);
}

ToggleAlwaysOnTop()

void Toolbar::ToggleAlwaysOnTop

(

)

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

ToolbarModeButtonPressed()

void Toolbar::ToolbarModeButtonPressed

(

bool

nextMode

)

{
    if (nextMode) // -> Next toolbar mode
    {
        if (pSettings->taskbarMode == TASKBAR_MODE_HIDDEN) pSettings->taskbarMode = TASKBAR_MODE_BARS;
        else if (pSettings->taskbarMode == TASKBAR_MODE_BARS) pSettings->taskbarMode = TASKBAR_MODE_BARSICONS;
        else if (pSettings->taskbarMode == TASKBAR_MODE_BARSICONS)
        {
            if (!pSettings->toolbarVertical) pSettings->taskbarMode = TASKBAR_MODE_ICONS;
            else pSettings->taskbarMode = TASKBAR_MODE_HIDDEN;
        }
        else pSettings->taskbarMode = TASKBAR_MODE_HIDDEN;
    }
    else // -> Previous toolbar mode
    {
        if (pSettings->taskbarMode == TASKBAR_MODE_BARS) pSettings->taskbarMode = TASKBAR_MODE_HIDDEN;
        else if (pSettings->taskbarMode == TASKBAR_MODE_BARSICONS) pSettings->taskbarMode = TASKBAR_MODE_BARS;
        else if (pSettings->taskbarMode == TASKBAR_MODE_ICONS) pSettings->taskbarMode = TASKBAR_MODE_BARSICONS;
        else // if (pSettings->taskbarMode == TASKBAR_MODE_HIDDEN)
        {
            if (!pSettings->toolbarVertical) pSettings->taskbarMode = TASKBAR_MODE_ICONS;
            else pSettings->taskbarMode = TASKBAR_MODE_BARSICONS;
        }
    }
 
    if ((pSettings->taskbarMode == TASKBAR_MODE_HIDDEN) && pSettings->taskbarTooltips) pTooltips->DeleteAllTooltips();
 
    UpdatePosition(); // -> Refreshes the toolbar including the change of modes
    PlaySoundFX(SFX_TOGGLE_ELEMENT);
 
    // Save the taskbar mode change to xoblite.rc... (or legacy supported extensions.rc)
    if (pSettings->taskbarMode == TASKBAR_MODE_BARS) WriteString(pSettings->xobrcFile, "xoblite.taskbar.mode:", "Bars");
    else if (pSettings->taskbarMode == TASKBAR_MODE_BARSICONS) WriteString(pSettings->xobrcFile, "xoblite.taskbar.mode:", "Bars+Icons");
    else if (pSettings->taskbarMode == TASKBAR_MODE_ICONS) WriteString(pSettings->xobrcFile, "xoblite.taskbar.mode:", "Icons");
    else WriteString(pSettings->xobrcFile, "xoblite.taskbar.mode:", "Hidden");
}

CheckIfMouseHover()

bool Toolbar::CheckIfMouseHover

(

)

{
    POINT mousepos;
    GetCursorPos(&mousepos);
    if (mousepos.x >= ToolbarX && mousepos.x <= (ToolbarX + ToolbarWidth))
    {
        if (mousepos.y >= ToolbarY && mousepos.y <= (ToolbarY + ToolbarHeight)) return true;
    }
 
    return false;
}

Friends And Related Symbol Documentation

ToolbarWndProc

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

friend

{
    switch (message)
    {
        //====================
 
        case BB_TASKSUPDATE:
        {
            if ((pSettings->taskbarMode != TASKBAR_MODE_HIDDEN) && pTaskbar)
            {
//              if (pSettings->debugLogging) SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)"Toolbar -> BB_TASKSUPDATE (taskbar visible)");
 
                if (lParam == TASKITEM_ADDED || lParam == TASKITEM_REMOVED || lParam == TASKITEM_REFRESH)
                {
                    if (!pToolbar->throttlingAddRemoveUpdates)
                    {
                        // Wait at least 200 msec between add/remove related UI updates to avoid
                        // excessive toolbar updating when e.g. launching many-multi-window apps...
                        if (pToolbar->throttlingActivityUpdates) KillTimer(pToolbar->hToolbarWnd, TOOLBAR_THROTTLE_UPDATES_TIMER);
                        pToolbar->throttlingAddRemoveUpdates = true;
                        if (!SetTimer(pToolbar->hToolbarWnd, TOOLBAR_THROTTLE_UPDATES_TIMER, 200, (TIMERPROC)NULL)) pToolbar->throttlingAddRemoveUpdates = false;
 
                        pTaskbar->cachedTaskButtonsExist = false;
                        pToolbar->UpdatePosition();
/*
                        if (pSettings->debugLogging)
                        {
                            if (lParam == TASKITEM_ADDED) SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)"Toolbar -> TASKITEM_ADDED");
                            else if (lParam == TASKITEM_REMOVED) SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)"Toolbar -> TASKITEM_REMOVED");
                            else if (lParam == TASKITEM_REFRESH) SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)"Toolbar -> TASKITEM_REFRESH");
                        }
*/
                    }
                    else pToolbar->updatesThrottled = true;
                }
 
                //====================
 
                else if (lParam == TASKITEM_MODIFIED || lParam == TASKITEM_FLASHED)
                {
                    if (wParam != NULL)
                    {
                        int i = pTaskbar->FindTask((HWND)wParam);
                        pToolbar->UpdateToolbarWindow();
/*
                        if (pSettings->debugLogging)
                        {
                            if (lParam == TASKITEM_MODIFIED) SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)"Toolbar -> TASKITEM_MODIFIED");
                            else if (lParam == TASKITEM_FLASHED) SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)"Toolbar -> TASKITEM_FLASHED");
                        }
*/
                    }
                }
 
                //====================
 
                else if (lParam == TASKITEM_ACTIVATED)
                {
                    if (pTaskbar->FindTask((HWND)wParam) >= 0)
                    {
                        if (!pToolbar->throttlingActivityUpdates || !pToolbar->throttlingAddRemoveUpdates)
                        {
                            // Wait at least 100 msec between activity related UI updates to
                            // suppress e.g. active task flipping when operating the menu...
                            pToolbar->throttlingActivityUpdates = true;
                            if (!SetTimer(pToolbar->hToolbarWnd, TOOLBAR_THROTTLE_UPDATES_TIMER, 100, (TIMERPROC)NULL)) pToolbar->throttlingActivityUpdates = false;
                            pToolbar->UpdateToolbarWindow();
                        }
                        else pToolbar->updatesThrottled = true;
 
//                      if (pSettings->debugLogging) SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)"Toolbar -> TASKITEM_ACTIVATED -> Taskbar item activated...");
                    }
                    else
                    {
//                      if (pSettings->debugLogging) SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)"Toolbar -> TASKITEM_ACTIVATED -> Non-taskbar item activated...");
                        pToolbar->UpdateToolbarWindow();
                    }
                }
            }
        }
        break;
 
        //====================
 
        case BB_ADDTASK:
        {
            pTaskbar->AddTask((HWND)wParam);
        }
        break;
 
        case BB_REMOVETASK:
        {
            pTaskbar->RemoveTask((HWND)wParam);
        }
        break;
 
        case BB_ACTIVETASK:
        {
            pTaskbar->SetActiveTask((HWND)wParam);
        }
        break;
 
        case BB_REDRAW:
        {
            pTaskbar->RedrawTask((HWND)wParam);
        }
        break;
 
        case BB_ACTIVATESHELLWINDOW:
        {
            pTaskbar->ActivateShellWindow();
        }
        break;
 
        //====================
 
        case WM_TIMER:
        {
            if (wParam == TOOLBAR_THROTTLE_UPDATES_TIMER)
            {
                KillTimer(pToolbar->hToolbarWnd, TOOLBAR_THROTTLE_UPDATES_TIMER);
 
                if (pToolbar->updatesThrottled)
                {
                    if (pToolbar->throttlingAddRemoveUpdates)
                    {
                        pTaskbar->cachedTaskButtonsExist = false;
                        pToolbar->UpdatePosition();
 
                        // if (pSettings->debugLogging) SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)"Toolbar -> throttlingAddRemoveUpdates ended.");
                    }
                    else // if (pToolbar->throttlingActivityUpdates)
                    {
                        pToolbar->UpdateToolbarWindow();
 
                        // if (pSettings->debugLogging) SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)"Toolbar -> throttlingActivityUpdates ended.");
                    }
                }
 
                pToolbar->throttlingAddRemoveUpdates = pToolbar->throttlingActivityUpdates = pToolbar->updatesThrottled = false;
 
                return 0;
            }
 
            //====================
 
            else if (wParam == TOOLBAR_SAVE_WIDTH_TIMER)
            {
                KillTimer(pToolbar->hToolbarWnd, TOOLBAR_SAVE_WIDTH_TIMER);
                if (pToolbar->saveWidthAfterDelay && !pSettings->toolbarVertical)
                {
                    WriteInt(pSettings->xobrcFile, "xoblite.toolbar.horizontal.width:", pSettings->toolbarHorizontalWidth);
                    pToolbar->saveWidthAfterDelay = false;
                }
                return 0;
            }
 
            //====================
 
            else // TOOLBAR_UPDATE_TIMER
            {
                bool updateToolbar = false;
 
                // Should we update the toolbar clock? (nb. every 40x250 msec == 10 seconds; same as the Desktop clock)
                if (pToolbar->clockTimerCounter < 40) pToolbar->clockTimerCounter++;
                else
                {
                    if (pToolbar->GetClockText(false)) updateToolbar = true;
                    pToolbar->clockTimerCounter = 0;
                }
 
                // Should we update the toolbar windowLabel? (nb. only applicable if the taskbar is hidden)
                if (pSettings->taskbarMode == TASKBAR_MODE_HIDDEN)
                {
                    int i = pTaskbar->GetActiveTask();
                    if (i >= 0)
                    {
                        if (pTaskbar->taskList[i]->hidden || IsIconic(pTaskbar->taskList[i]->hwnd))
                        {
                            if (wcslen(pToolbar->CurrentWindow) > 0)
                            {
                                pToolbar->CurrentWindow[0] = '\0'; // -> Display "xoblite" as the toolbar windowLabel instead...
                                updateToolbar = true;
                            }
                        }
                        else if (_wcsicmp(pToolbar->CurrentWindow, pTaskbar->taskList[i]->captionUnicode)) // Has the active task's window title text changed?
                        {
                            wcscpy(pToolbar->CurrentWindow, pTaskbar->taskList[i]->captionUnicode);
                            updateToolbar = true;
                        }
 
                        // if (updateToolbar && pSettings->debugLogging) SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)"Toolbar -> TOOLBAR_UPDATE_TIMER -> WindowLabel updated.");
                    }
                }
 
                // Has the number of visible task buttons on the taskbar changed? (nb. this should normally happen automatically,
                // but every now and then the toolbar and taskbar may fall out of sync drawing so let's add a failsafe... :) )
//              if (pTaskbar->GetTaskButtonsToDraw() != pTaskbar->taskButtonsLastDrawn) updateToolbar = true;
                
                if (updateToolbar) pToolbar->UpdateToolbarWindow();
 
                return 0;
            }
        }
        break;
 
        //====================
 
        case WM_DROPFILES:
        {
            return pTaskbar->DropFiles(hwnd, wParam, (pSettings->taskbarMode != TASKBAR_MODE_HIDDEN));
        }
        break;
 
        //====================
 
        case BB_RECONFIGURE:
        {
            SetRectEmpty(&pToolbar->currentWindowLabelRect);
            pToolbar->UpdatePosition(); // Gets new settings and resizes window if needed...
 
            if (pSettings->taskbarTooltips)
            {
                // Update the tooltips colours (background+text), matching the current toolbar style colors...
//              SendMessage(pTooltips->hToolTipsWnd, TTM_SETTIPBKCOLOR, (WPARAM)pSettings->Toolbar->TextColor, 0);
//              SendMessage(pTooltips->hToolTipsWnd, TTM_SETTIPTEXTCOLOR, (WPARAM)pSettings->Toolbar->Color, 0);
//              SendMessage(pTooltips->hToolTipsWnd, TTM_SETTIPBKCOLOR, (WPARAM)pSettings->ToolbarWindowLabel->Color, 0);
//              SendMessage(pTooltips->hToolTipsWnd, TTM_SETTIPTEXTCOLOR, (WPARAM)pSettings->ToolbarWindowLabel->TextColor, 0);
            }
        }
        break;
 
        //====================
 
        case BB_TOGGLETOOLBAR:
        {
            if (!pSettings->toolbarHidden) pSettings->toolbarHidden = true;
            else pSettings->toolbarHidden = false;
 
            if (!pSettings->toolbarHidden) pToolbar->UpdatePosition();
            ShowWindow(pToolbar->hToolbarWnd, pSettings->toolbarHidden ? SW_HIDE : SW_SHOWNOACTIVATE);
 
            if (pDesktop) pDesktop->UpdateDesktopWindow(); // In case e.g. the workspace indicators need to be moved given the new toolbar placement
 
            PlaySoundFX(SFX_TOGGLE_ELEMENT);
 
            WriteBool(pSettings->xobrcFile, "xoblite.toolbar.hidden:", pSettings->toolbarHidden);
        }
        break;
 
        //====================
 
        case BB_TOGGLESYSTEMBAR:
        {
            pToolbar->ToolbarModeButtonPressed(true);
        }
        break;
 
        //====================
 
        case WM_CLOSE:
            return 0;
 
        //====================
 
        case WM_DISPLAYCHANGE:
        {
            if (pSettings->toolbarHidden) break;
            pToolbar->UpdatePosition();
        }
        break;
 
        case WM_SETTINGCHANGE:
        {
            // Update the toolbar's position (and maybe also dimensions) if the work area changes...
            // (e.g. if the Explorer taskbar is moved to another screen edge)
            if (pSettings->toolbarHidden) break;
            if (wParam == SPI_SETWORKAREA) pToolbar->UpdatePosition();
            return 0;
        }
 
        //====================
/*
        case WM_MOUSEACTIVATE:
            return MA_NOACTIVATE;
        
        case WM_ACTIVATE:
            if (LOWORD(wParam) == WA_ACTIVE || LOWORD(wParam) == WA_CLICKACTIVE) SetActiveWindow(hwnd);
        return 0;
*/
        //====================
 
        case WM_EXITSIZEMOVE:
        {
            if (pToolbar->ToolbarPosInProgress)
            {
                pToolbar->ToolbarPosInProgress = false;
 
                RECT r;
                GetWindowRect(pToolbar->hToolbarWnd, &r);
                pSettings->ToolbarPlacement.placement = PLACEMENT_MANUAL;
                pSettings->ToolbarPlacement.rcx = pToolbar->ToolbarX = r.left;
                pSettings->ToolbarPlacement.rcy = pToolbar->ToolbarY = r.top;
 
//              pToolbar->UpdatePosition();
                pToolbar->UpdateToolbarWindow();
 
                KillTimer(pToolbar->hToolbarWnd, TOOLBAR_SAVE_WIDTH_TIMER);
                pToolbar->saveWidthAfterDelay = true;
                SetTimer(pToolbar->hToolbarWnd, TOOLBAR_SAVE_WIDTH_TIMER, 1000, (TIMERPROC)NULL);
            }
 
            return 0;
        }
 
        //====================
 
        // Allow window to move if control key is being held down,
        // holding down the shift key and left clicking moves the window
        // back to the default position...
        case WM_NCHITTEST:
        {
            if ((GetAsyncKeyState(VK_CONTROL) & 0x8000))
            {
                POINT pt;
                pt.x = GET_X_LPARAM(lParam);
                pt.y = GET_Y_LPARAM(lParam);
                ScreenToClient(hwnd, &pt);
 
                if ((pSettings->taskbarMode != TASKBAR_MODE_HIDDEN) && PtInRect(&pToolbar->winlabelRect, pt)) return HTCLIENT;
                else
                {
                    pToolbar->ToolbarPosInProgress = true;
                    return HTCAPTION;
                }
            }
            else return HTCLIENT;
        }
        break;
 
        //====================
 
        case WM_LBUTTONDBLCLK:
        {
            if (GetAsyncKeyState(VK_MENU) & 0x8000)
            {
                if (pSettings->toolbarVertical)
                {
                    if (pToolbar->toolbarVerticalPeeking) pToolbar->toolbarVerticalPeeking = false;
                    else pToolbar->toolbarVerticalPeeking = true;
                    pToolbar->UpdatePosition();
                }
            }
            else
            {
                POINT pt = {LOWORD(lParam), HIWORD(lParam)};
                // Doubleclick on the workspace label -> edit current workspace name
                if (!pSettings->toolbarLabelHidden && (pSettings->numberOfWorkspaces > 1) && PtInRect(&pToolbar->labelRect, pt)) BBExecute(GetDesktopWindow(), NULL, pSettings->preferredEditor, pSettings->xobrcDefaultFile, NULL, SW_SHOWNORMAL, false);
                // Doubleclick on the clock -> open date/time properties
                else if (!pSettings->toolbarClockHidden && PtInRect(&pToolbar->clockRect, pt)) BBExecute(GetDesktopWindow(), NULL, "control.exe", "timedate.cpl", NULL, SW_SHOWNORMAL, false);
            }
        }
        break;
 
        //====================
 
        case WM_LBUTTONDOWN:
        case WM_LBUTTONUP:
        case WM_RBUTTONDOWN:
        case WM_RBUTTONUP:
        case WM_MBUTTONDOWN:
        case WM_MBUTTONUP:
        case WM_XBUTTONDOWN:
        case WM_XBUTTONUP:
        {
            if (pSettings->taskbarMode != TASKBAR_MODE_HIDDEN)
            {
                if (pTaskbar->MouseButtonOnTaskbar(hwnd, message, wParam, lParam))
                {
                    return DefWindowProc(hwnd, message, wParam, lParam);
                }
            }
 
            //====================
 
            if (message == WM_LBUTTONDOWN)
            {
                TRACKMOUSEEVENT track;
                ZeroMemory(&track,sizeof(track));
                track.cbSize = sizeof(track);
                track.dwFlags = TME_LEAVE;
                track.dwHoverTime = HOVER_DEFAULT;
                track.hwndTrack = pToolbar->hToolbarWnd;
                _TrackMouseEvent(&track);
 
                POINT pt = {LOWORD(lParam), HIWORD(lParam)};
 
                if (!pSettings->toolbarDownUpButtonsHidden && (pSettings->numberOfWorkspaces > 1))
                {
                    if (PtInRect(&pToolbar->button1Rect, pt))
                    {
                        pToolbar->ButtonPressed1 = true;
                        // InvalidateRect(pToolbar->hToolbarWnd, &pToolbar->button1Rect, false);
                        pToolbar->UpdateToolbarWindow();
                    }
                    else if (PtInRect(&pToolbar->button2Rect, pt))
                    {
                        pToolbar->ButtonPressed2 = true;
                        // InvalidateRect(pToolbar->hToolbarWnd, &pToolbar->button2Rect, false);
                        pToolbar->UpdateToolbarWindow();
                    }
                }
 
                if (!pSettings->toolbarLeftRightButtonsHidden)
                {
                    if (PtInRect(&pToolbar->button3Rect, pt))
                    {
                        pToolbar->ButtonPressed3 = true;
                        // InvalidateRect(pToolbar->hToolbarWnd, &pToolbar->button3Rect, false);
                        pToolbar->UpdateToolbarWindow();
                    }
                    else if (PtInRect(&pToolbar->button4Rect, pt))
                    {
                        pToolbar->ButtonPressed4 = true;
                        // InvalidateRect(pToolbar->hToolbarWnd, &pToolbar->button4Rect, false);
                        pToolbar->UpdateToolbarWindow();
                    }
                }
 
                if (pMenuCommon) pMenuCommon->Hide();
            }
 
            //====================
 
            else if (message == WM_LBUTTONUP)
            {
                if (pToolbar->ButtonPressed1) // Toolbar "down" button
                {
                    if ((strlen(pSettings->toolbarDownButtonOverride) > 0) && !(GetAsyncKeyState(VK_MENU) & 0x8000))
                    {
                        BBSmartExecute(pSettings->toolbarDownButtonOverride); // -> User configured override command for the "down" button
                    }
                    else SendMessage(pToolbar->hBlackboxWnd, BB_WORKSPACE, 0, 0); // -> Previous workspace ("DeskLeft")
                }
                else if (pToolbar->ButtonPressed2) // Toolbar "up" button
                {
                    if ((strlen(pSettings->toolbarUpButtonOverride) > 0) && !(GetAsyncKeyState(VK_MENU) & 0x8000))
                    {
                        BBSmartExecute(pSettings->toolbarUpButtonOverride); // -> User configured override command for the "up" button
                    }
                    else SendMessage(pToolbar->hBlackboxWnd, BB_WORKSPACE, 1, 0); // -> Next workspace ("DeskRight")
                }
                else if (pToolbar->ButtonPressed3) // Toolbar "left" button
                {
                    if ((strlen(pSettings->toolbarLeftButtonOverride) > 0) && !(GetAsyncKeyState(VK_MENU) & 0x8000))
                    {
                        BBSmartExecute(pSettings->toolbarLeftButtonOverride); // -> User configured override command for the "left" button
                    }
                    else pToolbar->ToolbarModeButtonPressed(false); // -> Previous toolbar mode
                }
                else if (pToolbar->ButtonPressed4) // Toolbar "right" button
                {
                    if ((strlen(pSettings->toolbarRightButtonOverride) > 0) && !(GetAsyncKeyState(VK_MENU) & 0x8000))
                    {
                        BBSmartExecute(pSettings->toolbarRightButtonOverride); // -> User configured override command for the "right" button
                    }
                    else pToolbar->ToolbarModeButtonPressed(true); // -> Next toolbar mode
                }
 
                pToolbar->ButtonPressed1 = pToolbar->ButtonPressed2 = pToolbar->ButtonPressed3 = pToolbar->ButtonPressed4 = false;
                pToolbar->UpdateToolbarWindow();
            }
 
            //====================
 
            else if (message == WM_RBUTTONUP)
            {
                if (GetAsyncKeyState(VK_MENU) & 0x8000) SendMessage(GetBBWnd(), BB_MENU, 0, 0); // -> Main menu
                else
                {
                    POINT pt = {LOWORD(lParam), HIWORD(lParam)};
//                  if (!pSettings->toolbarLabelHidden && (pSettings->numberOfWorkspaces > 1) && PtInRect(&pToolbar->labelRect, pt)) SendMessage(GetBBWnd(), BB_MENU, 1, 0); // -> Workspaces menu
//                  else if (!pSettings->toolbarClockHidden && PtInRect(&pToolbar->clockRect, pt)) SendMessage(GetBBWnd(), BB_MENU, 2, 0); // -> Configuration menu
//                  else SendMessage(GetBBWnd(), BB_MENU, 0, 0); // -> Main menu
                    if (!pSettings->toolbarClockHidden && PtInRect(&pToolbar->clockRect, pt)) SendMessage(GetBBWnd(), BB_MENU, 2, 0); // -> Configuration menu
                    else SendMessage(GetBBWnd(), BB_MENU, 0, 0); // -> Main menu
                }
            }
 
            //====================
 
            else if (message == WM_MBUTTONUP)
            {
                if (GetAsyncKeyState(VK_MENU) & 0x8000) PostMessage(GetBBWnd(), BB_TOGGLEDOCK, 0, 0); // -> Toggle dock
                else if (GetAsyncKeyState(VK_SHIFT) & 0x8000) PostMessage(GetBBWnd(), BB_TOGGLEPLUGINS, 0, 0); // -> Toggle plugins
                else
                {
                    POINT pt = {LOWORD(lParam), HIWORD(lParam)};
                    if ((pSettings->taskbarMode != TASKBAR_MODE_HIDDEN) || !PtInRect(&pToolbar->winlabelRect, pt)) pToolbar->ToolbarModeButtonPressed(true); // -> Next toolbar mode
                }
            }
 
            //====================
 
            else if (message == WM_XBUTTONDOWN)
            {
                if (HIWORD(wParam) == XBUTTON1)
                {
                    if (GetAsyncKeyState(VK_MENU) & 0x8000)
                    {
                        if (pSettings->toolbarVertical)
                        {
                            if (pToolbar->toolbarVerticalPeeking) pToolbar->toolbarVerticalPeeking = false;
                            else pToolbar->toolbarVerticalPeeking = true;
                            pToolbar->UpdatePosition();
                            PlaySoundFX(SFX_TOGGLE_ELEMENT);
                        }
                    }
//                  else if (GetAsyncKeyState(VK_SHIFT) & 0x8000) BBExecute(GetDesktopWindow(), NULL, "control.exe", "desk.cpl,,3", NULL, SW_SHOWNORMAL, false);
                    else
                    {
                        // Toggle toolbar orientation... (horizontal<->vertical)
                        if (pSettings->toolbarVertical) pSettings->toolbarVertical = false;
                        else pSettings->toolbarVertical = true;
 
                        pToolbar->UpdatePosition();
                        PlaySoundFX(SFX_TOGGLE_ELEMENT);
 
                        WriteBool(pSettings->xobrcFile, "xoblite.toolbar.vertical:", pSettings->toolbarVertical);
                    }
                }
                else if (HIWORD(wParam) == XBUTTON2)
                {
                    if (pSettings->toolbarVertical)
                    {
                        // Toggle toolbar peeking if already in vertical orientation...
                        if (pToolbar->toolbarVerticalPeeking) pToolbar->toolbarVerticalPeeking = false;
                        else pToolbar->toolbarVerticalPeeking = true;
                    }
                    else
                    {
                        // Change to vertical toolbar orientation and enable peeking directly...
                        pSettings->toolbarVertical = true;
                        pToolbar->toolbarVerticalPeeking = true;
//                      WriteBool(pSettings->xobrcFile, "xoblite.toolbar.vertical:", pSettings->toolbarVertical);
                    }
 
                    pToolbar->UpdatePosition();
                    PlaySoundFX(SFX_TOGGLE_ELEMENT);
                }
            }
        }
        break;
 
        //====================
 
        case WM_MOUSEWHEEL: // -> Regular vertical mouse scroll wheel i.e. up/down movement
        case WM_MOUSEHWHEEL: // -> Horizontal mouse scroll wheel (or more commonly, a touchpad) i.e. left/right movement
        {
            // Only allow mousewheel resizing when the control key is held down...
            if ((message == WM_MOUSEWHEEL) && (GetAsyncKeyState(VK_CONTROL) & 0x8000))
            {
                // ...when the toolbar width is defined as a percentage of the screen size...
                if (pSettings->toolbarHorizontalWidth > 100) break;
                // ...and the toolbar is horizontally oriented...
                if (pSettings->toolbarVertical) break;
 
                bool sizechanged = false;
 
                if (GET_WHEEL_DELTA_WPARAM(wParam) < 0)
                {
                    if (pSettings->toolbarHorizontalWidth > 30)
                    {
                        pSettings->toolbarHorizontalWidth--;
                        sizechanged = true;
                    }
                }
                else
                {
                    if (pSettings->toolbarHorizontalWidth < 100)
                    {
                        pSettings->toolbarHorizontalWidth++;
                        sizechanged = true;
                    }
                }
 
                if (sizechanged)
                {
                    pToolbar->GetDimensions();
                    pToolbar->GetPlacement();
 
                    // Force re-rendering of the background and task button bitmaps...
                    pToolbar->cachedBitmapsExist = false;
                    if (pSettings->taskbarMode != TASKBAR_MODE_HIDDEN) pTaskbar->cachedTaskButtonsExist = false;
                    pToolbar->UpdateToolbarWindow();
 
                    if (pSettings->toolbarOnTop) SetWindowPos(pToolbar->hToolbarWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE);
                    else SetWindowPos(pToolbar->hToolbarWnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE);
 
                    // Due to the number of repeated updates when using the mousewheel to change the toolbar width,
                    // we wait a second before saving the width to xoblite.rc, in case we're not done resizing yet...
                    KillTimer(pToolbar->hToolbarWnd, TOOLBAR_SAVE_WIDTH_TIMER);
                    pToolbar->saveWidthAfterDelay = true;
                    SetTimer(pToolbar->hToolbarWnd, TOOLBAR_SAVE_WIDTH_TIMER, 1000, (TIMERPROC)NULL);
                }
            }
 
            //====================
 
            // ...otherwise the mousewheel controls the visible span of taskbar items, if the total
            // number of taskbar items is > than the configured maximum simultaneously visible...
            else if (pSettings->taskbarMode != TASKBAR_MODE_HIDDEN)
            {
                if (((message == WM_MOUSEWHEEL) && (GET_WHEEL_DELTA_WPARAM(wParam) < 0)) || ((message == WM_MOUSEHWHEEL) && (GET_WHEEL_DELTA_WPARAM(wParam) > 0)))
                {
                    pTaskbar->taskButtonsOffset++;
                    int firstButton = pTaskbar->FindFirstVisible();
                    if (pTaskbar->FindLastVisible(firstButton) < 0) pTaskbar->taskButtonsOffset--; // Couldn't scroll further down/right...
                    else pToolbar->UpdateToolbarWindow();
                }
                else if (pTaskbar->taskButtonsOffset > 0)
                {
                    pTaskbar->taskButtonsOffset--;
                    pToolbar->UpdateToolbarWindow();
                }
            }
        }
        break;
 
        //====================
/*
        case WM_MOUSEMOVE:
        {
        }
        break;
*/
        //====================
/*
        case WM_MOUSEHOVER:
        case WM_NCMOUSEHOVER:
        {
            // Do something?
//          pSettings->toolbarTransparencyAlpha = 255;
            pToolbar->UpdateToolbarWindow();
            break;
        }
*/
        case WM_MOUSELEAVE:
        case WM_NCMOUSELEAVE:
        {
            pToolbar->ButtonPressed1 = pToolbar->ButtonPressed2 = pToolbar->ButtonPressed3 = pToolbar->ButtonPressed4 = false;
            pToolbar->UpdateToolbarWindow();
        }
        break;
 
        //====================
 
        // If moved, snap window to screen edges...
        case WM_WINDOWPOSCHANGING:
        {
            // Snap window to screen edges when in manual positioning mode?
            if ((pSettings->ToolbarPlacement.placement == PLACEMENT_MANUAL) && pSettings->toolbarSnapToEdges)
            {
                if (pToolbar)
                {
                    if (IsWindowVisible(hwnd)) SnapWindowToEdge((WINDOWPOS*)lParam, pSettings->edgeSnapThreshold, true);
                }
            }
        }
        return 0;
 
        //====================
 
        default:
            return DefWindowProc(hwnd,message,wParam,lParam);
 
    //====================
    }
    return 0;
}

Member Data Documentation

hToolbarInstance

HINSTANCE Toolbar::hToolbarInstance

hBlackboxWnd

HWND Toolbar::hBlackboxWnd

hToolbarWnd

HWND Toolbar::hToolbarWnd

tbBitmap

HBITMAP Toolbar::tbBitmap

ScreenWidth

int Toolbar::ScreenWidth

ScreenHeight

int Toolbar::ScreenHeight

ToolbarX

int Toolbar::ToolbarX

ToolbarY

int Toolbar::ToolbarY

ToolbarWidth

int Toolbar::ToolbarWidth

ToolbarHeight

int Toolbar::ToolbarHeight

ButtonPressed1

bool Toolbar::ButtonPressed1

ButtonPressed2

bool Toolbar::ButtonPressed2

ButtonPressed3

bool Toolbar::ButtonPressed3

ButtonPressed4

bool Toolbar::ButtonPressed4

tbLabelX

int Toolbar::tbLabelX

tbLabelY

int Toolbar::tbLabelY

tbLabelW

int Toolbar::tbLabelW

tbLabelH

int Toolbar::tbLabelH

tbWinLabelX

int Toolbar::tbWinLabelX

tbWinLabelY

int Toolbar::tbWinLabelY

tbWinLabelW

int Toolbar::tbWinLabelW

tbWinLabelH

int Toolbar::tbWinLabelH

tbClockX

int Toolbar::tbClockX

tbClockY

int Toolbar::tbClockY

tbClockW

int Toolbar::tbClockW

tbClockH

int Toolbar::tbClockH

labelRect

RECT Toolbar::labelRect

winlabelRect

RECT Toolbar::winlabelRect

clockRect

RECT Toolbar::clockRect

tbButtonX1

int Toolbar::tbButtonX1

tbButtonX2

int Toolbar::tbButtonX2

tbButtonX3

int Toolbar::tbButtonX3

tbButtonX4

int Toolbar::tbButtonX4

tbButtonY

int Toolbar::tbButtonY

tbButtonWH

int Toolbar::tbButtonWH

button1Rect

RECT Toolbar::button1Rect

button2Rect

RECT Toolbar::button2Rect

button3Rect

RECT Toolbar::button3Rect

button4Rect

RECT Toolbar::button4Rect

ToolbarPosInProgress

bool Toolbar::ToolbarPosInProgress

ToolbarWorkspaceName

char Toolbar::ToolbarWorkspaceName[MAX_LINE_LENGTH]

CurrentWindow

wchar_t Toolbar::CurrentWindow[MAX_LINE_LENGTH]

CurrentTime

wchar_t Toolbar::CurrentTime[MAX_LINE_LENGTH]

systemTime

time_t Toolbar::systemTime

localTime

struct tm Toolbar::localTime

currentMinute

int Toolbar::currentMinute

displayedMinute

int Toolbar::displayedMinute

clockTimerCounter

int Toolbar::clockTimerCounter

temp

char Toolbar::temp[MAX_LINE_LENGTH]

saveWidthAfterDelay

bool Toolbar::saveWidthAfterDelay

throttlingAddRemoveUpdates

bool Toolbar::throttlingAddRemoveUpdates

throttlingActivityUpdates

bool Toolbar::throttlingActivityUpdates

updatesThrottled

bool Toolbar::updatesThrottled

toolbarVerticalPeeking

bool Toolbar::toolbarVerticalPeeking

origDesktopArea

RECT Toolbar::origDesktopArea

cachedBackground

HDC Toolbar::cachedBackground

cachedToolbarButton

HDC Toolbar::cachedToolbarButton

cachedToolbarButtonPressed

HDC Toolbar::cachedToolbarButtonPressed

cachedBitmapsExist

bool Toolbar::cachedBitmapsExist

cachedToolbarWindowLabel

HDC Toolbar::cachedToolbarWindowLabel

currentWindowLabelRect

RECT Toolbar::currentWindowLabelRect

currentWindowLabelWidth

int Toolbar::currentWindowLabelWidth

currentWindowLabelHeight

int Toolbar::currentWindowLabelHeight

thumbnail

HTHUMBNAIL Toolbar::thumbnail