Taskbar Class Reference

#include <Taskbar.h>

Public Member Functions
	Taskbar ()
	~Taskbar ()
void	InitializeTaskList ()
void	AddTask (HWND newWindow)
void	RemoveTask (HWND oldWindow)
int	FindTask (HWND window)
void	CheckTaskListIntegrity ()
void	SetActiveTask (HWND activeWindow)
int	GetActiveTask ()
HWND	GetActiveWindow ()
void	RedrawTask (HWND window)
void	ActivateShellWindow ()
void	MinimizeAllWindows ()
void	RestoreAllWindows ()
int	DropFiles (HWND hwnd, WPARAM wParam, bool checkTaskbarDrop)
bool	MouseButtonOnTaskbar (HWND hwnd, unsigned int message, WPARAM wParam, LPARAM lParam)
void	DrawTaskbar (HDC hdc, int iconPos, RECT taskbarRect)
int	DrawTaskButtons (HDC hdc)
void	ChangeTaskbarMode (int mode)
void	ToggleCurrentOnly ()
bool	OnCurrentWorkspace (HWND window)
int	GetTaskButtonsToDraw ()
int	GetTaskbarScrollIndicatorSizes (int *leftTopPadding, int *rightBottomPadding)
bool	CheckCloakedWindow (HWND hwnd)
int	FindFirstVisible ()
int	FindLastVisible (int offset)
void	NextTask (bool currentWorkspaceOnly, bool visibleOnly)
void	PreviousTask (bool currentWorkspaceOnly, bool visibleOnly)
void	SortTaskbarItems (int mode)
void	TileWindow (int placement)

Static Public Member Functions
static bool	CompareTaskbarItemsByLastUsed (taskListItem *t1, taskListItem *t2)

Public Attributes
HWND	hBlackboxWnd
HDC	cachedTaskButtonActive
HDC	cachedTaskButtonInactive
bool	cachedTaskButtonsExist
RECT	TaskbarRect
bool	activeTaskAvailable
RECT	ActiveTaskRect
RECT	currentTaskButton
HWND	currentTaskButtonWnd
HICON	currentTaskButtonIcon
int	iconSize
RECT	iconRect
RECT	textRect
int	taskButtonWidth
int	taskButtonWidthMinusPadding
int	taskButtonHeight
int	taskButtonHeightMinusPadding
int	taskButtonsToDraw
int	taskButtonsOffset
HWND	flashingHwnd
vector< taskListItem * >	taskList
bool	enumeratingTasks
bool	blockNextMouseClick

Friends
BOOL CALLBACK	TaskEnumerator (HWND window, LPARAM main)

Constructor & Destructor Documentation

Taskbar()

Taskbar::Taskbar

(

)

{
    ZeroMemory(this, sizeof(Taskbar));
    ZeroMemory(&taskList, sizeof(taskList));
 
    hBlackboxWnd = GetBBWnd();
 
    cachedTaskButtonActive = CreateCompatibleDC(NULL);
    cachedTaskButtonInactive = CreateCompatibleDC(NULL);
    cachedTaskButtonsExist = false;
 
    taskButtonsToDraw = taskButtonsOffset = 0;
    taskButtonWidth = taskButtonHeight = taskButtonWidthMinusPadding = taskButtonHeightMinusPadding = 0;
 
    blockNextMouseClick = false;
    enumeratingTasks = false;
}

~Taskbar()

Taskbar::~Taskbar

(

)

{
    // Clear all elements in the taskList...
    for (int i=0; i < (int)taskList.size(); i++)
    {
//      DestroyIcon(taskList[i]->icon);
        delete taskList[i];
        taskList.erase(taskList.begin() + i);
    }
    taskList.clear();
 
    // Delete cached bitmaps...
    DeleteDC(cachedTaskButtonActive);
    DeleteDC(cachedTaskButtonInactive);
}

Member Function Documentation

InitializeTaskList()

void Taskbar::InitializeTaskList

(

)

{
    enumeratingTasks = true;
//  if (pSettings->debugLogging) Log("==================== TASKBAR WINDOW ENUMERATION STARTING ====================", "");
    EnumWindows(TaskEnumerator, 0);
//  if (pSettings->debugLogging) Log("==================== TASKBAR WINDOW ENUMERATION FINISHED ====================", "");
    enumeratingTasks = false;
    CheckTaskListIntegrity();
    SendMessage(hBlackboxWnd, BB_TASKSUPDATE, NULL, (LPARAM)TASKITEM_ADDED);
}

AddTask()

void Taskbar::AddTask

(

HWND

newWindow

)

{
    if (!IsAppWindow(window)) return;
 
    // Check if the task is already present in the taskList...
    int i = FindTask(window);
    // ...and whether the task is a DWM cloaked window...
    bool cloaked = CheckCloakedWindow(window);
 
    if (i != -1) // -> This is an *existing* task item, but check if any of its parameters need updating...
    {
        if (pSettings->debugLogging)
        {
            if (taskList[i]->hidden != cloaked)
            {
                char msg[MAX_LINE_LENGTH], windowText[MAX_LINE_LENGTH];
                GetWindowText(window, windowText, sizeof(windowText));
                if (cloaked) sprintf(msg, "DEBUG -> Taskbar::AddTask -> Window cloaking! -> %s", windowText);
                else sprintf(msg, "DEBUG -> Taskbar::AddTask -> Window uncloaking! -> %s", windowText);
                SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)msg);
                Log(msg, "");
            }
        }
        taskList[i]->hidden = cloaked;
    }
    else // -> This is a *new* task item, so let's add it to the taskList...
    {
        // ...but first, let's also check for various other types of rogue windows that don't belong on the taskbar...
        char newWindowTemp[MAX_LINE_LENGTH];
        GetClassName(window, newWindowTemp, MAX_LINE_LENGTH);
        if (strlen(newWindowTemp) == 0) return;
        if (!_stricmp(newWindowTemp, "AcrobatOffscreenDocumentWnd")) return; // Check for Adobe Acrobat 7.0 offscreen windows...
        bool isAppPlugin = (!_strnicmp(newWindowTemp, "BBAppPlugin", 11)); // Allow specific "application-like" plugins to show up on the taskbar...
 
        GetWindowText(window, newWindowTemp, sizeof(newWindowTemp));
        if (strlen(newWindowTemp) == 0) return;
        // Check for Microsoft Powerpoint non-document windows...
        // "Microsoft Powerpoint - [" or "Microsoft Office PowerPoint - ["
        //  if (IsInString(newWindowTemp, " Powerpoint - [")) return;
 
        if (pSettings->debugLogging && !enumeratingTasks)
        {
            char msg[MAX_LINE_LENGTH], windowText[MAX_LINE_LENGTH];
            GetWindowText(window, windowText, sizeof(windowText));
            if (cloaked) sprintf(msg, "DEBUG -> Taskbar::AddTask -> Cloaked window found! -> %s", windowText);
            else sprintf(msg, "DEBUG -> Taskbar::AddTask -> Uncloaked window found! -> %s", windowText);
            SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)msg);
            Log(msg, "");
        }
 
        // Increase the "last used" counter for all other taskbar items...
        for (int i = 0; i < (int)taskList.size(); i++) taskList[i]->lastUsed++;
 
        // -> All checks passed, so now we can create the new taskList item! :)
        taskListItem *newTask = new taskListItem;
        newTask->hwnd = window;
        newTask->active = false;
//      if (IsIconic(window)) newTask->workspace = 255;
//      else newTask->workspace = pSettings->currentWorkspace;
        newTask->workspace = pSettings->currentWorkspace;
        if (cloaked) newTask->hidden = true;
        else newTask->hidden = false;
//      newTask->hidden = false;
        newTask->isAppPlugin = isAppPlugin;
        GetWindowText(window, newTask->captionANSI, 255); // -> ANSI representation
        GetWindowTextW(window, newTask->captionUnicode, 255); // -> Unicode representation
        newTask->lastUsed = 0; // ...because the new task is automatically also the most recently active task...
        newTask->priorityClass = 0;
        newTask->dimensions.placement = PLACEMENT_DEFAULT; // All windows start in the default non-tiled state
 
        DWORD pid = 0;
        GetWindowThreadProcessId(window, &pid);
        HANDLE windowProcessHandle = OpenProcess((PROCESS_QUERY_INFORMATION), FALSE, pid);
        if (windowProcessHandle != NULL)
        {
            GetModuleFileNameEx(windowProcessHandle, NULL, newTask->path, sizeof(newTask->path));
            CloseHandle(windowProcessHandle);
        }
        else newTask->path[0] = '\0';
 
        taskList.push_back(newTask);
    }
 
    CheckTaskListIntegrity();
 
    //====================
 
    // Redraw the taskbar...
    if (!enumeratingTasks)
    {
        if (i != -1) SendMessage(hBlackboxWnd, BB_TASKSUPDATE, NULL, (LPARAM)TASKITEM_REFRESH);
        else SendMessage(hBlackboxWnd, BB_TASKSUPDATE, (WPARAM)window, (LPARAM)TASKITEM_ADDED);
    }
}

RemoveTask()

void Taskbar::RemoveTask

(

HWND

oldWindow

)

{
    int i = FindTask(oldWindow);
    if (i != -1)
    {
        // Task found in taskList, let's remove it + any associated tooltips...
 
        if (pSettings->debugLogging)
        {
            char msg[MAX_LINE_LENGTH], windowText[MAX_LINE_LENGTH];
            GetWindowText(oldWindow, windowText, sizeof(windowText));
            sprintf(msg, "DEBUG -> Taskbar::RemoveTask -> %s", windowText);
            SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)msg);
            Log(msg, "");
        }
 
        if (pSettings->taskbarTooltips) pTooltips->DeleteToolTip((UINT)oldWindow, TOOLTIP_TYPE_TASK);
 
//      DestroyIcon(taskList[i]->icon);
        delete taskList[i];
        taskList.erase(taskList.begin() + i);
 
        CheckTaskListIntegrity();
 
        // Adjust the visible taskbar items if one of them was removed and we're at the *end* of
        // the task list... (i.e. leave no gap at the end, adjust the offset backwards instead)
        while ((FindLastVisible(FindFirstVisible()) < 0) && (taskButtonsOffset > 0)) taskButtonsOffset--;
 
        // Redraw the taskbar...
        SendMessage(hBlackboxWnd, BB_TASKSUPDATE, (WPARAM)oldWindow, (LPARAM)TASKITEM_REMOVED);
    }
}

FindTask()

int Taskbar::FindTask

(

HWND

window

)

{
    for (int i=0; i < (int)taskList.size(); i++)
    {
        if (taskList[i]->hwnd == window) return i;
    }
 
    return -1;
}

CheckTaskListIntegrity()

void Taskbar::CheckTaskListIntegrity

(

)

{
    // Look for zombie items in the taskList...
    for (int i=0; i < (int)taskList.size(); i++)
    {
        if (!IsWindow(taskList[i]->hwnd))
        {
            if (pSettings->taskbarTooltips) pTooltips->DeleteToolTip((UINT)taskList[i]->hwnd, TOOLTIP_TYPE_TASK);
 
//          DestroyIcon(taskList[i]->icon);
            delete taskList[i];
            taskList.erase(taskList.begin() + i);
        }
    }
 
//  GetTaskButtonsToDraw();
}

SetActiveTask()

void Taskbar::SetActiveTask

(

HWND

activeWindow

)

{
    bool cloakingChanged = false;
 
    int i = FindTask(window);
 
    if (i != -1) // -> Focus has moved to an item shown on the taskbar...
    {
        // First, we hide any open and non-pinned menus as focus has moved to another application...
        if (pMenuCommon) pMenuCommon->Hide();
 
        bool cloaked = CheckCloakedWindow(window);
 
        // Increase the "last used" counter for all other taskbar items...
        for (int i = 0; i < (int)taskList.size(); i++) taskList[i]->lastUsed++; // (yes, I know this could in *theory* wrap around, but... ;))
 
        // Find the new active task... (and set all other tasks to inactive)
        for (int i=0; i < (int)taskList.size(); i++)
        {
            if (taskList[i]->hwnd == window)
            {
                taskList[i]->active = true;
                taskList[i]->lastUsed = 0; // Reset the "last used" counter for the new active item...
/*
                if (pSettings->debugLogging)
                {
                    if (taskList[i]->hidden != cloaked)
                    {
                        char msg[MAX_LINE_LENGTH], windowText[MAX_LINE_LENGTH];
                        GetWindowText(window, windowText, sizeof(windowText));
                        if (cloaked) sprintf(msg, "DEBUG -> Taskbar::SetActiveTask -> Window cloaking! -> %s", windowText);
                        else sprintf(msg, "DEBUG -> Taskbar::SetActiveTask -> Window uncloaking! -> %s", windowText);
                        // SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)msg);
                        Log(msg, "");
                    }
                }
*/
                if (taskList[i]->hidden != cloaked) cloakingChanged = true;
//              taskList[i]->hidden = cloaked;
                taskList[i]->hidden = false; // Note: Necessary because some apps go active *before* they uncloak... (i.e. avoiding related taskbar update race conditions)
            }
            else taskList[i]->active = false;
        }
 
        // Should we update the visible section of the taskbar to follow the newly active task?
        if (pSettings->taskbarSorting == TASKBAR_SORT_FOLLOW_ACTIVE)
        {
            GetTaskButtonsToDraw();
            int firstButton = FindFirstVisible();
            int lastButton = FindLastVisible(firstButton);
            if (lastButton < 0) lastButton = (int)taskList.size() - 1; // Failsafe
 
            if (i < firstButton)
            {
                while ((i < firstButton) && (taskButtonsOffset > 0))
                {
                    taskButtonsOffset--;
                    firstButton = FindFirstVisible();
                }
            }
            else if (i > lastButton)
            {
                while ((i > lastButton) && (taskButtonsOffset < ((int)taskList.size() - 1)))
                {
                    taskButtonsOffset++;
                    lastButton = FindLastVisible(FindFirstVisible());
                }
                if (lastButton < 0) taskButtonsOffset = 0; // Failsafe
            }
        }
        else if (pSettings->taskbarSorting == TASKBAR_SORT_BY_LAST_USED)
        {
//          int i = FindFirstVisible();
//          int centerX = taskList[i]->r.left + ((taskList[i]->r.right - taskList[i]->r.left) / 2);
//          int centerY = taskList[i]->r.top + ((taskList[i]->r.bottom - taskList[i]->r.top) / 2);
//          POINT pt = { centerX, centerY };
//          ClientToScreen(pToolbar->hToolbarWnd, &pt);
//          SetCursorPos(pt.x, pt.y);
 
            SortTaskbarItems(TASKBAR_SORT_BY_LAST_USED);
            taskButtonsOffset = 0;
        }
        // else if (pSettings->taskbarSorting == TASKBAR_SORT_BY_NAME) SortTaskbarItems(TASKBAR_SORT_BY_NAME); // ...in the end not that attractive given that task titles may change over time... (kept only for future reference)
 
        // Since one task has become active and the others non-active
        // we need to refresh all task buttons -> use NULL as WPARAM
//      if (cloakingChanged) SendMessage(hBlackboxWnd, BB_TASKSUPDATE, NULL, (LPARAM)TASKITEM_REFRESH);
//      else SendMessage(hBlackboxWnd, BB_TASKSUPDATE, (WPARAM)window, (LPARAM)TASKITEM_ACTIVATED);
        SendMessage(hBlackboxWnd, BB_TASKSUPDATE, (WPARAM)window, (LPARAM)TASKITEM_ACTIVATED);
    }
    else // -> Focus has moved to something not shown on the taskbar... (e.g. *box UI element)
    {
        bool foundActive = false;
 
        for (int i=0; i < (int)taskList.size(); i++)
        {
            if (taskList[i]->active) foundActive = true;
            taskList[i]->active = false;
        }
 
        if (foundActive) SendMessage(hBlackboxWnd, BB_TASKSUPDATE, NULL, (LPARAM)TASKITEM_ACTIVATED);
    }
}

GetActiveTask()

int Taskbar::GetActiveTask

(

)

{
    // Find the currently active task...
    for (int i=0; i < (int)taskList.size(); i++)
    {
        if (taskList[i]->active) return i;
    }
 
    return NULL;
}

GetActiveWindow()

HWND Taskbar::GetActiveWindow

(

)

{
    // Find the currently active window...
    for (int i=0; i < (int)taskList.size(); i++)
    {
        if (taskList[i]->active) return taskList[i]->hwnd;
    }
 
    return NULL;
}

RedrawTask()

void Taskbar::RedrawTask

(

HWND

window

)

{
    int i = FindTask(window);
    if (i != -1)
    {
        bool cloaked = CheckCloakedWindow(window);
 
        bool cloakingChanged = false;
        if (taskList[i]->hidden != cloaked) cloakingChanged = true;
        taskList[i]->hidden = cloaked;
 
        if (pSettings->debugLogging && cloakingChanged)
        {
            char msg[MAX_LINE_LENGTH], windowText[MAX_LINE_LENGTH];
            GetWindowText(window, windowText, sizeof(windowText));
            if (cloaked) sprintf(msg, "DEBUG -> Taskbar::RedrawTask -> Window cloaking! -> %s", windowText);
            else sprintf(msg, "DEBUG -> Taskbar::RedrawTask -> Window uncloaking! -> %s", windowText);
            SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)msg);
            Log(msg, "");
        }
 
        // if ((pSettings->taskbarMode != TASKBAR_MODE_HIDDEN) && pToolbar) InvalidateRect(pToolbar->hToolbarWnd, &taskList[i]->r, false);
 
        if (cloakingChanged) SendMessage(hBlackboxWnd, BB_TASKSUPDATE, NULL, (LPARAM)TASKITEM_REFRESH);
        else if (!cloaked)
        {
            GetWindowText(taskList[i]->hwnd, taskList[i]->captionANSI, 255); // -> ANSI representation
            GetWindowTextW(taskList[i]->hwnd, taskList[i]->captionUnicode, 255); // -> Unicode representation
 
            if (flashingHwnd != 0) SendMessage(hBlackboxWnd, BB_TASKSUPDATE, (WPARAM)taskList[i]->hwnd, (LPARAM)TASKITEM_FLASHED);
            else SendMessage(hBlackboxWnd, BB_TASKSUPDATE, (WPARAM)taskList[i]->hwnd, (LPARAM)TASKITEM_MODIFIED);
        }
    }
    else
    {
/*
        if (pSettings->debugLogging)
        {
            char msg[MAX_LINE_LENGTH], windowText[MAX_LINE_LENGTH];
            GetWindowText(window, windowText, sizeof(windowText));
            sprintf(msg, "DEBUG -> Taskbar::RedrawTask -> Task not found, redirecting to AddTask... -> %s", windowText);
            // SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)msg);
            Log(msg, "");
        }
*/
        // The task to be redrawn wasn't present in the taskList for some reason, so let's add it... (nb. AddTask will perform IsAppWindow() etc checks itself)
        AddTask(window);
    }
}

ActivateShellWindow()

void Taskbar::ActivateShellWindow

(

)

{
    for (int i=0; i < (int)taskList.size(); i++)
    {
        taskList[i]->active = false;
    }
 
//  SetForegroundWindow(hBlackboxWnd);
 
    // Since all tasks have become non-active we need
    // to refresh all task buttons -> use NULL as WPARAM
    SendMessage(hBlackboxWnd, BB_TASKSUPDATE, NULL, (LPARAM)TASKITEM_ACTIVATED);
}

MinimizeAllWindows()

void Taskbar::MinimizeAllWindows

(

)

{
    // Minimize all windows...
    for (int i=0; i < (int)taskList.size(); i++)
    {
//      if (!IsIconic(taskList[i]->hwnd)) ShowWindow(taskList[i]->hwnd, SW_MINIMIZE);
        ShowWindow(taskList[i]->hwnd, SW_MINIMIZE);
//      if (taskList[i]->isAppPlugin) SendMessage(taskList[i]->hwnd, BB_BROADCAST, 0, (LPARAM)"@AppPlugin Hide");
//      else ShowWindow(taskList[i]->hwnd, SW_MINIMIZE);
        taskList[i]->active = false;
    }
 
    // Since all tasks have become non-active we need
    // to refresh all task buttons -> use NULL as WPARAM
    SendMessage(hBlackboxWnd, BB_TASKSUPDATE, NULL, (LPARAM)TASKITEM_ACTIVATED);
 
    // Finally, we trigger the "minimize" message...
    SendMessage(hBlackboxWnd, BB_WINDOWMINIMIZE, 0, (LPARAM)taskList[0]->hwnd);
    PlaySoundFX(SFX_TASKBAR_MINIMIZE);
}

RestoreAllWindows()

void Taskbar::RestoreAllWindows

(

)

{
    // Find the currently active window so we can
    // focus it again after restoring all windows...
    HWND activeWindow = GetActiveWindow();
 
    //====================
 
    // Restore all windows... (except DWM cloaked ones)
    for (int i=0; i < (int)taskList.size(); i++)
    {
//      if (IsIconic(taskList[i]->hwnd) && !CheckCloakedWindow(taskList[i]->hwnd))
        if (IsIconic(taskList[i]->hwnd) && !taskList[i]->hidden)
        {
            if (taskList[i]->isAppPlugin) SendMessage(taskList[i]->hwnd, BB_BROADCAST, 0, (LPARAM)"@AppPlugin Show");
            else ShowWindow(taskList[i]->hwnd, SW_RESTORE);
        }
    }
 
    //====================
 
    // If we had an active window to begin with we now focus it again...
    if (activeWindow != NULL)
    {
        SetForegroundWindow(activeWindow);
        SendMessage(hBlackboxWnd, BB_BRINGTOFRONT, 0, (LPARAM)activeWindow);
    }
 
    PlaySoundFX(SFX_TASKBAR_RESTORE);
}

DropFiles()

int Taskbar::DropFiles	(	HWND	hwnd,
		WPARAM	wParam,
		bool	checkTaskbarDrop )

{
    if (checkTaskbarDrop)
    {
        if (MouseButtonOnTaskbar(hwnd, WM_DROPFILES, wParam, NULL)) return 0;
    }
 
    return ParseDropFiles(hwnd, wParam);
}

MouseButtonOnTaskbar()

bool Taskbar::MouseButtonOnTaskbar	(	HWND	hwnd,
		unsigned int	message,
		WPARAM	wParam,
		LPARAM	lParam )

{
    POINT pt;
 
    if (message == WM_DROPFILES)
    {
        // Drag'n'drop of files onto a task button...
        GetCursorPos(&pt);
        ScreenToClient(hwnd, &pt);
    }
    else
    {
        // Regular mouse clicks on a task button...
        pt.x = LOWORD(lParam);
        pt.y = HIWORD(lParam);
    }
 
    if (!PtInRect(&TaskbarRect, pt)) return false;
 
    //====================
 
    HWND window;
 
    for (int i = FindFirstVisible(); i < (int)taskList.size(); i++)
    {
        // Should we exclude tasks not on the current workspace? (-> user configurable "current workspace only" taskbar setting)
        if (!OnCurrentWorkspace(taskList[i]->hwnd)) continue;
 
        //====================
 
        if (PtInRect(&taskList[i]->r, pt))
        {
            switch (message)
            {
                //====================
 
                case WM_LBUTTONDOWN:
                {
                    if (pMenuCommon) pMenuCommon->Hide();
 
                    if (GetAsyncKeyState(VK_CONTROL) & 0x8000) // -> Ctrl+Left click on the task button
                    {
                        // Toggle the window's stickiness... (i.e. whether it should be visible on all workspaces or not)
                        if (!CheckSticky(taskList[i]->hwnd))
                        {
                            MakeSticky(taskList[i]->hwnd);
                            taskList[i]->workspace = 254; // -> Visible on all workspaces! ("sticky")
                        }
                        else
                        {
                            RemoveSticky(taskList[i]->hwnd);
                            taskList[i]->workspace = pSettings->currentWorkspace; // -> Visible only on the current workspace! ("non-sticky")
                        }
/*
                        window = taskList[i]->hwnd;
                        if (IsIconic(window))
                        {
                            if (taskList[i]->isAppPlugin) SendMessage(window, BB_BROADCAST, 0, (LPARAM)"@AppPlugin Show");
                            else ShowWindow(window, SW_RESTORE);
                            if (!CheckSticky(taskList[i]->hwnd)) taskList[i]->workspace = pSettings->currentWorkspace;
                        }
                        SetForegroundWindow(window);
                        SendMessage(hBlackboxWnd, BB_BRINGTOFRONT, 0, (LPARAM)window);
*/
/*
                        if (pSettings->debugLogging)
                        {
                            char msg[MAX_LINE_LENGTH];
                            if (CheckSticky(window)) sprintf(msg, "Taskbar -> %s -> Sticky! (on all workspaces)", taskList[i]->captionANSI);
                            else sprintf(msg, "Taskbar -> %s -> Located on workspace #%d", taskList[i]->captionANSI, taskList[i]->workspace+1);
                            SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)msg);
                        }
*/
                        PlaySoundFX(SFX_TOGGLE_ELEMENT);
                    }
 
                    // First we show and focus the window in question...
                    window = taskList[i]->hwnd;
                    if (IsIconic(window)) ShowWindow(window, SW_RESTORE);
//                  if (taskList[i]->isAppPlugin) SendMessage(window, BB_BROADCAST, 0, (LPARAM)"@AppPlugin Show");
//                  else if (IsIconic(window)) ShowWindow(window, SW_RESTORE);
                    SetForegroundWindow(window);
                    SendMessage(hBlackboxWnd, BB_BRINGTOFRONT, 0, (LPARAM)window);
/*
                    if (GetAsyncKeyState(VK_MENU) & 0x8000)
                    {
 
                        if (GetAsyncKeyState(VK_SHIFT) & 0x8000)
                        {
                            window = taskList[i]->hwnd;
                            if (taskList[i]->isAppPlugin) SendMessage(window, BB_BROADCAST, 0, (LPARAM)"@AppPlugin Show");
                            else if (IsIconic(window)) ShowWindow(window, SW_RESTORE);
                            SetForegroundWindow(window);
                            SendMessage(hBlackboxWnd, BB_BRINGTOFRONT, 0, (LPARAM)window);
                            PostMessage(window, WM_SYSCOMMAND, SC_MOVE, 0);
                        }
                        else RestoreAllWindows();
                    }
*/
                    if (GetAsyncKeyState(VK_MENU) & 0x8000) // -> Alt+Left click on the task button
                    {
                        if (!CheckSticky(taskList[i]->hwnd))
                        {
                            // Move the window to the next workspace...
                            SendMessage(hBlackboxWnd, BB_BRINGTOFRONT, 0, (LPARAM)window);
                            MakeSticky(window);
                            pWorkspaces->NextWorkspace();
                            RemoveSticky(window);
                            taskList[i]->workspace = pSettings->currentWorkspace;
                        }
 
                        PlaySoundFX(SFX_TOGGLE_ELEMENT);
                    }
                    else if (GetAsyncKeyState(VK_SHIFT) & 0x8000) // -> Shift+Left click on the task button
                    {
                        // Toggle the priority class of the window's parent process... (Default<->High)
                        DWORD pid = 0;
                        GetWindowThreadProcessId(taskList[i]->hwnd, &pid);
                        HANDLE h = OpenProcess((PROCESS_QUERY_INFORMATION | PROCESS_SET_INFORMATION), TRUE, pid);
                        if (taskList[i]->priorityClass == 0)
                        {
                            taskList[i]->priorityClass = GetPriorityClass(h);
                            SetPriorityClass(h, HIGH_PRIORITY_CLASS);
                        }
                        else
                        {
                            SetPriorityClass(h, taskList[i]->priorityClass);
                            taskList[i]->priorityClass = 0;
                        }
                        CloseHandle(h);
 
                        PlaySoundFX(SFX_TOGGLE_ELEMENT);
                    }
                    else // -> Left click on the task button (no keyboard modifiers)
                    {
                        // ...no specific action needed here, as we've already made the window visible above...
 
                        PlaySoundFX(SFX_TASKBAR_RESTORE);
                    }
 
                    return true;
                }
                break;
 
                //====================
 
                case WM_LBUTTONUP:
                case WM_LBUTTONDBLCLK:
                {
                    return true;
                }
                break;
 
                //====================
 
                case WM_RBUTTONDOWN:   // -> Minimize window...
                {
                    if (GetAsyncKeyState(VK_MENU) & 0x8000) // -> Alt+Right click on the task button
                    {
                        MinimizeAllWindows();
                        PlaySoundFX(SFX_TASKBAR_MINIMIZE);
                    }
/*
                    {
                        if (GetAsyncKeyState(VK_SHIFT) & 0x8000)
                        {
                            window = taskList[i]->hwnd;
                            if (taskList[i]->isAppPlugin) SendMessage(window, BB_BROADCAST, 0, (LPARAM)"@AppPlugin Show");
                            else if (IsIconic(window)) ShowWindow(window, SW_RESTORE);
                            SetForegroundWindow(window);
                            SendMessage(hBlackboxWnd, BB_BRINGTOFRONT, 0, (LPARAM)window);
                            PostMessage(window, WM_SYSCOMMAND, SC_SIZE, 0);
                        }
                        else MinimizeAllWindows();
                    }
*/
                    else if (GetAsyncKeyState(VK_CONTROL) & 0x8000) // -> Ctrl+Right click on the task button
                    {
                        return true; // Unassigned (for now at least)
                    }
                    else if (GetAsyncKeyState(VK_SHIFT) & 0x8000) // -> Shift+Right click on the task button
                    {
                        return true; // Pass through -> Show the configuration menu on RBUTTONUP, see below!
                    }
                    else // -> Right click on the task button (no keyboard modifiers)
                    {
                        if ((message == WM_RBUTTONDOWN) && pSettings->taskbarCurrentOnly && (taskButtonsToDraw == 1)) blockNextMouseClick = true;
 
                        // Minimize the window...
                        window = taskList[i]->hwnd;
                        if (!IsIconic(window)) ShowWindow(window, SW_MINIMIZE);
//                      if (taskList[i]->isAppPlugin) SendMessage(window, BB_BROADCAST, 0, (LPARAM)"@AppPlugin Hide");
//                      else if (!IsIconic(window)) ShowWindow(window, SW_MINIMIZE);
                        taskList[i]->active = false;
//                      taskList[i]->workspace = 255;
                        SendMessage(hBlackboxWnd, BB_WINDOWMINIMIZE, 0, (LPARAM)window);
 
//                      if ((pSettings->taskbarMode != TASKBAR_MODE_HIDDEN) && pToolbar) InvalidateRect(pToolbar->hToolbarWnd, &pTaskbar->taskList[i]->r, false);
                        if (pSettings->taskbarMode != TASKBAR_MODE_HIDDEN) SendMessage(hBlackboxWnd, BB_TASKSUPDATE, (WPARAM)taskList[i]->hwnd, (LPARAM)TASKITEM_MODIFIED);
 
                        PlaySoundFX(SFX_TASKBAR_MINIMIZE);
                    }
 
                    return true;
                }
                break;
 
                //====================
 
                case WM_RBUTTONUP: // Only show menus on RButtonUp...
                {
                    if (GetAsyncKeyState(VK_SHIFT) & 0x8000) SendMessage(GetBBWnd(), BB_MENU, 2, 0);
                    return true;
                }
                break;
 
                //====================
 
                case WM_MBUTTONDOWN:
                {
                    if (pMenuCommon) pMenuCommon->Hide();
 
                    // First we show and focus the window in question...
                    window = taskList[i]->hwnd;
                    if (taskList[i]->isAppPlugin) SendMessage(window, BB_BROADCAST, 0, (LPARAM)"@AppPlugin Show");
                    else if (IsIconic(window)) ShowWindow(window, SW_RESTORE);
                    SetForegroundWindow(window);
                    SendMessage(hBlackboxWnd, BB_BRINGTOFRONT, 0, (LPARAM)window);
 
                    if (GetAsyncKeyState(VK_CONTROL) & 0x8000) // -> Ctrl+Mid click on the task button
                    {
                        SendMessage(hBlackboxWnd, BB_BROADCAST, 0, (LPARAM)"@xoblite Window Tile Left");
                    }
                    else if (GetAsyncKeyState(VK_MENU) & 0x8000) // -> Alt+Mid click on the task button
                    {
                        SendMessage(hBlackboxWnd, BB_BROADCAST, 0, (LPARAM)"@xoblite Window Tile Right");
                    }
/*
                    if (GetAsyncKeyState(VK_MENU) & 0x8000) // -> Alt+Mid click on the task button
                    {
                        // Shade/unshade the window...
                        if (taskList[i]->isAppPlugin) SendMessage(window, BB_BROADCAST, 0, (LPARAM)"@AppPlugin ToggleShaded");
                        else if (pDesktop) pDesktop->ShadeWindow();
                        PlaySoundFX(SFX_TASKBAR_ZOOM); // ...assign a unique SFX later? (TBD)
                    }
                    else if (GetAsyncKeyState(VK_CONTROL) & 0x8000) // -> Ctrl+Mid click on the task button
                    {
                        if (GetAsyncKeyState(VK_SHIFT) & 0x8000)
                        {
                            if (!CheckSticky(taskList[i]->hwnd))
                            {
                                MakeSticky(taskList[i]->hwnd);
                                taskList[i]->workspace = 254; // Visible on all workspaces
                            }
                            else
                            {
                                RemoveSticky(taskList[i]->hwnd);
                                taskList[i]->workspace = pSettings->currentWorkspace;
                            }
                        }
                        else if (!CheckSticky(taskList[i]->hwnd))
                        {
                            // Move the window to the next/previous workspace...
                            SendMessage(hBlackboxWnd, BB_BRINGTOFRONT, 0, (LPARAM)window);
                            MakeSticky(window);
                            if (GetAsyncKeyState(VK_MENU) & 0x8000) pWorkspaces->PreviousWorkspace();
                            else pWorkspaces->NextWorkspace();
                            RemoveSticky(window);
                            taskList[i]->workspace = pSettings->currentWorkspace;
 
//                          if (GetAsyncKeyState(VK_MENU) & 0x8000) pWorkspaces->MoveWindowToPreviousWorkspace(window);
//                          else pWorkspaces->MoveWindowToNextWorkspace(window);
                        }
 
                        SendMessage(hBlackboxWnd, BB_BROADCAST, 0, (LPARAM)"@xoblite Window Tile Left"); // Temporary (for now at least)
                        return true; // Unassigned (for now at least)
                    }
                    else if (GetAsyncKeyState(VK_SHIFT) & 0x8000) // -> Shift+Mid click on the task button
                    {
/*
                        if (!taskList[i]->isAppPlugin)
                        {
                            // Close the application...
                            window = taskList[i]->hwnd;
                            if (IsIconic(window)) ShowWindow(window, SW_RESTORE);
                            SetForegroundWindow(window);
                            PostMessage(window, WM_SYSCOMMAND, SC_CLOSE, 0);
                        }
 
                        SendMessage(hBlackboxWnd, BB_BROADCAST, 0, (LPARAM)"@xoblite Window Tile Right"); // Temporary (for now at least)
                        return true; // Unassigned (for now at least)
                    }
*/
                    else // -> Mid click on the task button (no keyboard modifiers)
                    {
                        // Toggle the window maximized/restored... (i.e. equivalent to clicking the window's "zoom" button)
 
                        if (taskList[i]->dimensions.placement != PLACEMENT_DEFAULT)
                        {
                            pTaskbar->TileWindow(PLACEMENT_DEFAULT);
                            PlaySoundFX(SFX_TASKBAR_TILE);
                        }
                        else
                        {
                            if (taskList[i]->isAppPlugin)
                            {
                                SendMessage(window, BB_BROADCAST, 0, (LPARAM)"@AppPlugin ToggleMaximized");
                            }
                            else if (IsZoomed(window))
                            {
                                ShowWindow(window, SW_RESTORE);
/*
                                if (pSettings->desktopAreaDefined) // ...JUST TESTING SOME STUFF... ;)
                                {
                                    RECT workArea;
                                    SystemParametersInfo(SPI_GETWORKAREA, 0, (PVOID)&workArea, SPIF_SENDCHANGE);
                                    int newWindowX = workArea.left + pSettings->desktopArea.left;
                                    int newWindowY = workArea.top + pSettings->desktopArea.top;
                                    int newWindowWidth = (workArea.right - workArea.left) - pSettings->desktopArea.left - pSettings->desktopArea.right;
                                    int newWindowHeight = (workArea.bottom - workArea.top) - pSettings->desktopArea.top - pSettings->desktopArea.bottom;
                                    SetWindowPos(window, NULL, newWindowX, newWindowY, newWindowWidth, newWindowHeight, SWP_SHOWWINDOW | SWP_NOZORDER);
                                }
*/
                            }
                            else ShowWindow(window, SW_MAXIMIZE);
 
                            PlaySoundFX(SFX_TASKBAR_ZOOM);
                        }
                    }
 
                    return true;
                }
                break;
 
                //====================
 
                case WM_MBUTTONUP: 
                {
                    return true;
                }
                break;
 
                //====================
 
                case WM_XBUTTONDOWN:
                {
                    if (pMenuCommon) pMenuCommon->Hide();
 
                    // First we show and focus the window in question...
                    window = taskList[i]->hwnd;
                    if (taskList[i]->isAppPlugin) SendMessage(window, BB_BROADCAST, 0, (LPARAM)"@AppPlugin Show");
                    else if (IsIconic(window)) ShowWindow(window, SW_RESTORE);
                    SetForegroundWindow(window);
                    SendMessage(hBlackboxWnd, BB_BRINGTOFRONT, 0, (LPARAM)window);
 
                    if (HIWORD(wParam) == XBUTTON1)
                    {
                        if (GetAsyncKeyState(VK_MENU) & 0x8000) // -> Alt+X1 click on the task button
                        {
                            SendMessage(hBlackboxWnd, BB_BROADCAST, 0, (LPARAM)"@xoblite Window Tile Right"); // Temporary (for now at least)
                        }
                        else // -> X1 click on the task button (no keyboard modifiers)
                        {
                            if (!CheckSticky(taskList[i]->hwnd))
                            {
                                // Move the window to the *previous* workspace...
                                MakeSticky(window);
                                pWorkspaces->PreviousWorkspace();
                                RemoveSticky(window);
                                taskList[i]->workspace = pSettings->currentWorkspace;
                            }
                        }
                    }
                    else if (HIWORD(wParam) == XBUTTON2)
                    {
                        if (GetAsyncKeyState(VK_MENU) & 0x8000) // -> Alt+X2 click on the task button
                        {
                            SendMessage(hBlackboxWnd, BB_BROADCAST, 0, (LPARAM)"@xoblite Window Tile Left"); // Temporary (for now at least)
                        }
                        else // -> X2 click on the task button (no keyboard modifiers)
                        {
                            if (!CheckSticky(taskList[i]->hwnd))
                            {
                                // Move the window to the *next* workspace...
                                MakeSticky(window);
                                pWorkspaces->NextWorkspace();
                                RemoveSticky(window);
                                taskList[i]->workspace = pSettings->currentWorkspace;
                            }
                        }
                    }
 
                    return true;
                }
                break;
 
                case WM_XBUTTONUP: { } break;
 
                //====================
 
                case WM_DROPFILES:
                {
                    // Drag'n'drop of file(s) onto the task button:
                    // -> Forward the drag'n'drop information to the window in question...
                    window = taskList[i]->hwnd;
                    if (taskList[i]->isAppPlugin) SendMessage(window, BB_BROADCAST, 0, (LPARAM)"@AppPlugin Show");
                    else if (IsIconic(window)) ShowWindow(window, SW_RESTORE);
                    SetForegroundWindow(window);
                    SendMessage(hBlackboxWnd, BB_BRINGTOFRONT, 0, (LPARAM)window);
 
                    PostMessage(window, WM_DROPFILES, wParam, lParam);
 
                    return true;
                }
                break;
 
                //====================
            }
        }
    }
 
    return false;
}

DrawTaskbar()

void Taskbar::DrawTaskbar	(	HDC	hdc,
		int	iconPos,
		RECT	taskbarRect )

{
    CopyRect(&TaskbarRect, &taskbarRect);
    activeTaskAvailable = false;
 
    // Reset flash indicator if flashing is disabled...
    if (!pSettings->taskbarFlashing) flashingHwnd = 0;
 
    //====================
 
    if (!pSettings->toolbarVertical)
    {
        // Failsafe: Abort if the taskbar is not wide enough to fit all the task buttons... (nb. quite simplistic implementation at the moment)
        if ((TaskbarRect.right - TaskbarRect.left) < (taskButtonsToDraw*16)) return;
    }
 
    //====================
 
    // Get the number of task buttons to draw...
    GetTaskButtonsToDraw();
 
    if ((taskButtonsToDraw == 0) && (pSettings->taskbarMode != TASKBAR_MODE_HIDDEN))
    {
        HFONT font = CreateFont(pSettings->Toolbar->FontHeight, 0, 0, 0, pSettings->Toolbar->FontWeight, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH|FF_DONTCARE, pSettings->Toolbar->Font);
        HGDIOBJ oldfont = SelectObject(hdc, font);
        SetBkMode(hdc, TRANSPARENT);
 
        SetTextColor(hdc, pSettings->Toolbar->TextColor);
 
        unsigned int format = DT_CENTER | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_WORD_ELLIPSIS;
 
        int totalNumberOfTasks = 0;
        if (pSettings->taskbarCurrentOnly)
        {
            for (int i = 0; i < (int)taskList.size(); i++)
            {
                if (!taskList[i]->hidden) totalNumberOfTasks++;
            }
        }
 
        if (pSettings->taskbarCurrentOnly && (totalNumberOfTasks > 0))
        {
            // -> There are no tasks on the current workspace, but there are on other workspaces...
//          DrawText(hdc, "(No tasks on this workspace)", strlen("(No tasks on this workspace)"), &TaskbarRect, DT_CENTER | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_WORD_ELLIPSIS);
            DrawTextWithEffects(hdc, TaskbarRect, "(No tasks on this workspace)", format, pSettings->Toolbar->TextColor, pSettings->Toolbar->FontOutline, pSettings->Toolbar->OutlineColor, pSettings->Toolbar->FontShadow, pSettings->Toolbar->ShadowColor, pSettings->Toolbar->ShadowX, pSettings->Toolbar->ShadowY);
        }
        else
        {
            // -> There are no tasks on the current or any other workspace, so let's advertise the shell instead... ;)
//          DrawText(hdc, "xoblite", strlen("xoblite"), &TaskbarRect, DT_CENTER | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_WORD_ELLIPSIS);
//          DrawText(hdc, "Welcome to xoblite.", strlen("Welcome to xoblite."), &TaskbarRect, DT_CENTER | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_WORD_ELLIPSIS);
            DrawTextWithEffects(hdc, TaskbarRect, "Welcome to xoblite.", format, pSettings->Toolbar->TextColor, pSettings->Toolbar->FontOutline, pSettings->Toolbar->OutlineColor, pSettings->Toolbar->FontShadow, pSettings->Toolbar->ShadowColor, pSettings->Toolbar->ShadowX, pSettings->Toolbar->ShadowY);
 
/*
            int width = TaskbarRect.right - TaskbarRect.left;x
            int iconSize = height;
            if (iconSize > 16) iconSize = 16;
            int xpos = TaskbarRect.left + ((width - iconSize) / 2);
            int ypos = TaskbarRect.top + ((height - iconSize) / 2);
            RECT iconRect;
            SetRect(&iconRect, xpos, ypos, xpos+iconSize, ypos+iconSize);
 
            HICON xobIcon = LoadIcon(pToolbar->hToolbarInstance, MAKEINTRESOURCE(IDI_XOBLITE));
            DrawSatHueIcon(hdc, iconRect, xobIcon, iconSize, 255, 0);
            DeleteObject(xobIcon);
*/
        }
 
        DeleteObject(SelectObject(hdc, oldfont));
    }
    else DrawTaskButtons(hdc);
}

DrawTaskButtons()

int Taskbar::DrawTaskButtons

(

HDC

hdc

)

{
    RECT TaskbarButtonsRect;
    CopyRect(&TaskbarButtonsRect, &TaskbarRect);
 
    int taskbarScrollIndicatorSize;
    if (pSettings->Toolbar->marginWidth > 0) taskbarScrollIndicatorSize = pSettings->Toolbar->marginWidth;
    else if (pSettings->Toolbar->borderWidth > 0) taskbarScrollIndicatorSize = pSettings->Toolbar->borderWidth;
    taskbarScrollIndicatorSize = 2 * pSettings->scalingFactorHiDPI;
 
    // Get the number of task buttons to draw...
//  GetTaskButtonsToDraw();
 
    // Get the range (first<->last) of currently visible taskbar items, if so applicable...
    int firstButton = FindFirstVisible();
    int lastButton = FindLastVisible(firstButton);
    if (lastButton < 0) lastButton = (int)taskList.size()-1; // Failsafe
 
    // Is the taskbar scrollable to the left/up? If so, make room for indicator...
    if (taskButtonsOffset > 0)
    {
        if (pSettings->toolbarVertical) TaskbarButtonsRect.top += taskbarScrollIndicatorSize;
        else TaskbarButtonsRect.left += taskbarScrollIndicatorSize;
    }
 
    // Is the taskbar scrollable to the right/down? If so, make room for indicator...
    for (int i = (lastButton+1); i < (int)taskList.size(); i++)
    {
        if (!OnCurrentWorkspace(taskList[i]->hwnd) || taskList[i]->hidden) continue;
        else
        {
            if (pSettings->toolbarVertical) TaskbarButtonsRect.bottom -= taskbarScrollIndicatorSize;
            else TaskbarButtonsRect.right -= taskbarScrollIndicatorSize;
            break;
        }
    }
 
    // For the vertical toolbar we only allow Bars or Bars+Icons mode... (at least for the time being)
    int drawTaskbarMode = pSettings->taskbarMode;
    if (pSettings->toolbarVertical && (pSettings->taskbarMode == TASKBAR_MODE_ICONS)) drawTaskbarMode = TASKBAR_MODE_BARSICONS;
 
    //====================
 
    // Calculate task button and icon dimensions...
 
    int oldButtonHeight = taskButtonHeightMinusPadding;
    taskButtonHeight = TaskbarButtonsRect.bottom - TaskbarButtonsRect.top;
    if (pSettings->toolbarVertical)
    {
        if (taskButtonsToDraw > 0) taskButtonHeight = taskButtonHeight / taskButtonsToDraw;
        // ##### EXPERIMENTAL SAFEGUARD #####
        // Just after startup the height of the vertical toolbar may
        // not yet have been set to match the number of task buttons...
        if (taskButtonHeight < pSettings->Toolbar->FontHeight) return 0;
        // ##################################
        taskButtonHeightMinusPadding = taskButtonHeight;;// -pSettings->Toolbar->marginWidth;
    }
    else
    {
        taskButtonHeightMinusPadding = taskButtonHeight;
    }
 
    if (taskButtonHeightMinusPadding != oldButtonHeight) cachedTaskButtonsExist = false;
 
    // Choose icon size depending on the height of the task button...
//  iconSize = 11;
//  if (taskButtonHeight > 20) iconSize = 16;
//  if (taskButtonHeight > 36) iconSize = 32;
    if (taskButtonHeight < 20) iconSize = taskButtonHeight - 4;
    else iconSize = 16;
    if (iconSize < 11) iconSize = 11;
 
/*
    if (drawTaskbarMode != TASKBAR_MODE_ICONS) // -> Bars or Bars+Icons mode...
    {
        taskButtonWidth = TaskbarButtonsRect.right - TaskbarButtonsRect.left;
        if (pSettings->toolbarVertical)
        {
            taskButtonWidthMinusPadding = taskButtonWidth;
        }
        else
        {
            if (taskButtonsToDraw > 0) taskButtonWidth = taskButtonWidth / taskButtonsToDraw;
            taskButtonWidthMinusPadding = taskButtonWidth - 2; // Padding 2 pixels between task buttons...
//          taskButtonWidthMinusPadding = taskButtonWidth + pSettings->InactiveTask->borderWidth; // No padding between task buttons...
        }
    }
    else // TASKBAR_MODE_ICONS -> Icons mode
    {
        taskButtonWidth = iconSize + 7;
        taskButtonWidthMinusPadding = taskButtonWidth - 1; // Padding 1 pixel between task buttons...
//      taskButtonWidth = iconSize + 5;
//      taskButtonWidthMinusPadding = taskButtonWidth + pSettings->InactiveTask->borderWidth; // No padding between task buttons...
    }
*/
 
    int oldButtonWidth = taskButtonWidthMinusPadding;
    taskButtonWidth = TaskbarButtonsRect.right - TaskbarButtonsRect.left;
    if (pSettings->toolbarVertical)
    {
        taskButtonWidthMinusPadding = taskButtonWidth;
    }
    else
    {
        if (taskButtonsToDraw > 0) taskButtonWidth = taskButtonWidth / taskButtonsToDraw;
        taskButtonWidthMinusPadding = taskButtonWidth - 2; // Padding 2 pixels between task buttons...
//      taskButtonWidthMinusPadding = taskButtonWidth + pSettings->InactiveTask->borderWidth; // No padding between task buttons...
    }
 
    if (taskButtonWidthMinusPadding != oldButtonWidth) cachedTaskButtonsExist = false;
 
    //====================
 
    // If we have not yet created any cached task buttons, or they need to be updated for other reasons, let's do that...
    if (!cachedTaskButtonsExist)
    {
/*
        if (cachedTaskButtonActive) DeleteDC(cachedTaskButtonActive);
        if (cachedTaskButtonInactive) DeleteDC(cachedTaskButtonInactive);
        cachedTaskButtonActive = CreateCompatibleDC(NULL);
        cachedTaskButtonInactive = CreateCompatibleDC(NULL);
*/
        RECT r = {0, 0, taskButtonWidthMinusPadding, taskButtonHeightMinusPadding};
 
        HBITMAP tempBitmapActive = CreateCompatibleBitmap(hdc, taskButtonWidthMinusPadding, taskButtonHeightMinusPadding);
        HBITMAP oldBitmapActive = (HBITMAP)SelectObject(cachedTaskButtonActive, tempBitmapActive);
        DeleteObject(oldBitmapActive);
        MakeGradientSuper(cachedTaskButtonActive, r, pSettings->ActiveTask->type, pSettings->ActiveTask->Color1, pSettings->ActiveTask->Color2, pSettings->ActiveTask->Color3, pSettings->ActiveTask->Color4, pSettings->ActiveTask->Color5, pSettings->ActiveTask->Color6, pSettings->ActiveTask->Color7, pSettings->ActiveTask->Color8, pSettings->ActiveTask->interlaced, pSettings->ActiveTask->bevelstyle, pSettings->ActiveTask->bevelposition, pSettings->bevelWidth, pSettings->ActiveTask->borderColor, pSettings->ActiveTask->borderWidth);
        DeleteObject(tempBitmapActive);
 
        HBITMAP tempBitmapInactive = CreateCompatibleBitmap(hdc, taskButtonWidthMinusPadding, taskButtonHeightMinusPadding);
        HBITMAP oldBitmapInactive = (HBITMAP)SelectObject(cachedTaskButtonInactive, tempBitmapInactive);
        DeleteObject(oldBitmapInactive);
        MakeGradientSuper(cachedTaskButtonInactive, r, pSettings->InactiveTask->type, pSettings->InactiveTask->Color1, pSettings->InactiveTask->Color2, pSettings->InactiveTask->Color3, pSettings->InactiveTask->Color4, pSettings->InactiveTask->Color5, pSettings->InactiveTask->Color6, pSettings->InactiveTask->Color7, pSettings->InactiveTask->Color8, pSettings->InactiveTask->interlaced, pSettings->InactiveTask->bevelstyle, pSettings->InactiveTask->bevelposition, pSettings->bevelWidth, pSettings->InactiveTask->borderColor, pSettings->InactiveTask->borderWidth);
        DeleteObject(tempBitmapInactive);
 
        // Set the "cached task buttons created" indicator...
        cachedTaskButtonsExist = true;
    }
 
    //====================
 
    // Delete any existing taskbar tooltips... (nb. because a full flush is much easier+safer than delta updates)
    if (pSettings->taskbarTooltips) pTooltips->DeleteAllTooltips();
 
    // ...and taskbar thumbnails...
    if (pToolbar->thumbnail != NULL)
    {
        DwmUnregisterThumbnail(pToolbar->thumbnail);
        pToolbar->thumbnail = NULL;
    }
 
    //====================
 
    // Draw the taskbar buttons...
    int drawnTasks = 0;
 
    for (int i = firstButton; i <= lastButton; i++)
    {
        if (drawnTasks >= taskButtonsToDraw) break;
 
        // Exclude tasks not on the current workspace?
        if (!OnCurrentWorkspace(taskList[i]->hwnd)) continue;
        // Exclude hidden/cloaked tasks...
        if (taskList[i]->hidden) continue;
 
        //====================
 
        // Calculate the bounding rect of the current task button, and save it for later use...
 
        CopyRect(&currentTaskButton, &TaskbarButtonsRect);
 
        if (pSettings->toolbarVertical)
        {
            currentTaskButton.top = TaskbarButtonsRect.top + (drawnTasks * taskButtonHeight);
            currentTaskButton.bottom = currentTaskButton.top + taskButtonHeightMinusPadding;
 
            // Extend the bottommost button to fit the bottom border of the taskbar...
            if (drawnTasks == (taskButtonsToDraw-1)) currentTaskButton.bottom = TaskbarButtonsRect.bottom;
 
            if (currentTaskButton.bottom > TaskbarButtonsRect.bottom) break; // Failsafe
        }
        else
        {
            currentTaskButton.left = TaskbarButtonsRect.left + (drawnTasks * taskButtonWidth);
            currentTaskButton.right = currentTaskButton.left + taskButtonWidthMinusPadding;
 
            if (drawTaskbarMode != TASKBAR_MODE_ICONS) // Bars or Bars+Icons mode
            {
                // Extend the rightmost button to fit the right border of the taskbar...
                if (drawnTasks == (taskButtonsToDraw-1)) currentTaskButton.right = TaskbarButtonsRect.right;
            }
 
            if (currentTaskButton.right > TaskbarButtonsRect.right) break; // Failsafe
        }
 
        CopyRect(&taskList[i]->r, &currentTaskButton);
 
        //====================
 
        // Have we previously increased the process priority class for this task? If so, let's indicate that...
        if ((taskList[i]->priorityClass != 0) || CheckSticky(taskList[i]->hwnd))
        {
            int highPrioIndicatorSize = 1 * pSettings->scalingFactorHiDPI;
 
            RECT r;
            SetRect(&r, currentTaskButton.left, currentTaskButton.top, currentTaskButton.right, currentTaskButton.top+highPrioIndicatorSize);
 
            COLORREF priorityIndicatorColor = 0x0000ff; // Show a smoothly faded in/out *RED* gradient indicator for high priority tasks!
            COLORREF stickyIndicatorColor = 0x008888;   // Show a smoothly faded in/out *YELLOW* gradient indicator for stickied tasks!
                                                        // ...or if both high priority *and* stickied, a top yellow / bottom red gradient indicator.
 
            if (CheckSticky(taskList[i]->hwnd)) MakeGradientSuper(hdc, r, B_SPLITHORIZONTAL, GetPixel(hdc, r.left, r.top), stickyIndicatorColor, stickyIndicatorColor, GetPixel(hdc, r.right - 1, r.top), 0, 0, 0, 0, false, BEVEL_FLAT, BEVEL1, 0, 0, 0);
            else MakeGradientSuper(hdc, r, B_SPLITHORIZONTAL, GetPixel(hdc, r.left, r.top), priorityIndicatorColor, priorityIndicatorColor, GetPixel(hdc, r.right-1, r.top), 0, 0, 0, 0, false, BEVEL_FLAT, BEVEL1, 0, 0, 0);
 
            SetRect(&r, currentTaskButton.left, currentTaskButton.bottom-highPrioIndicatorSize, currentTaskButton.right, currentTaskButton.bottom);
            if (taskList[i]->priorityClass != 0) MakeGradientSuper(hdc, r, B_SPLITHORIZONTAL, GetPixel(hdc, r.left, r.bottom-1), priorityIndicatorColor, priorityIndicatorColor, GetPixel(hdc, r.right-1, r.bottom-1), 0, 0, 0, 0, false, BEVEL_FLAT, BEVEL1, 0, 0, 0);
            else MakeGradientSuper(hdc, r, B_SPLITHORIZONTAL, GetPixel(hdc, r.left, r.bottom-1), stickyIndicatorColor, stickyIndicatorColor, GetPixel(hdc, r.right-1, r.bottom-1), 0, 0, 0, 0, false, BEVEL_FLAT, BEVEL1, 0, 0, 0);
 
            CopyRect(&r, &currentTaskButton);
            InflateRect(&r, 0, -(highPrioIndicatorSize*2));
            if (taskList[i]->active) MakeGradientSuper(hdc, r, pSettings->ActiveTask->type, pSettings->ActiveTask->Color1, pSettings->ActiveTask->Color2, pSettings->ActiveTask->Color3, pSettings->ActiveTask->Color4, pSettings->ActiveTask->Color5, pSettings->ActiveTask->Color6, pSettings->ActiveTask->Color7, pSettings->ActiveTask->Color8, pSettings->ActiveTask->interlaced, pSettings->ActiveTask->bevelstyle, pSettings->ActiveTask->bevelposition, pSettings->bevelWidth, pSettings->ActiveTask->borderColor, pSettings->ActiveTask->borderWidth);
            else if (pSettings->taskbarInactiveBackground) MakeGradientSuper(hdc, r, pSettings->InactiveTask->type, pSettings->InactiveTask->Color1, pSettings->InactiveTask->Color2, pSettings->InactiveTask->Color3, pSettings->InactiveTask->Color4, pSettings->InactiveTask->Color5, pSettings->InactiveTask->Color6, pSettings->InactiveTask->Color7, pSettings->InactiveTask->Color8, pSettings->InactiveTask->interlaced, pSettings->InactiveTask->bevelstyle, pSettings->InactiveTask->bevelposition, pSettings->bevelWidth, pSettings->InactiveTask->borderColor, pSettings->InactiveTask->borderWidth);
        }
        else if (taskList[i]->hwnd == flashingHwnd) // Flashing task button?
        {
            // Paint border+background for this flashed taskbar button...
            MakeGradientSuper(hdc, currentTaskButton, pSettings->ActiveTask->type, pSettings->FlashingTask->Color1, pSettings->FlashingTask->Color2, pSettings->FlashingTask->Color3, pSettings->FlashingTask->Color4, pSettings->FlashingTask->Color5, pSettings->FlashingTask->Color6, pSettings->FlashingTask->Color7, pSettings->FlashingTask->Color8, pSettings->InactiveTask->interlaced, pSettings->ActiveTask->bevelstyle, pSettings->ActiveTask->bevelposition, pSettings->bevelWidth, pSettings->FlashingTask->borderColor, pSettings->ActiveTask->borderWidth);
        }
//      else if ((drawnTasks == (taskButtonsToDraw-1)) && (drawTaskbarMode != TASKBAR_MODE_ICONS) && !pSettings->toolbarVertical) // Rightmost button on a horizontal taskbar?
        else if (drawnTasks == (taskButtonsToDraw-1))
        {
            // Manually paint the border+background for the last visible task button... (i.e. don't use the fixed size cached
            // task button bitmap, in order to allow this button's size to be adjusted to perfectly fit the remaining space available)
            if (taskList[i]->active) MakeGradientSuper(hdc, currentTaskButton, pSettings->ActiveTask->type, pSettings->ActiveTask->Color1, pSettings->ActiveTask->Color2, pSettings->ActiveTask->Color3, pSettings->ActiveTask->Color4, pSettings->ActiveTask->Color5, pSettings->ActiveTask->Color6, pSettings->ActiveTask->Color7, pSettings->ActiveTask->Color8, pSettings->ActiveTask->interlaced, pSettings->ActiveTask->bevelstyle, pSettings->ActiveTask->bevelposition, pSettings->bevelWidth, pSettings->ActiveTask->borderColor, pSettings->ActiveTask->borderWidth);
            else if (pSettings->taskbarInactiveBackground) MakeGradientSuper(hdc, currentTaskButton, pSettings->InactiveTask->type, pSettings->InactiveTask->Color1, pSettings->InactiveTask->Color2, pSettings->InactiveTask->Color3, pSettings->InactiveTask->Color4, pSettings->InactiveTask->Color5, pSettings->InactiveTask->Color6, pSettings->InactiveTask->Color7, pSettings->InactiveTask->Color8, pSettings->InactiveTask->interlaced, pSettings->InactiveTask->bevelstyle, pSettings->InactiveTask->bevelposition, pSettings->bevelWidth, pSettings->InactiveTask->borderColor, pSettings->InactiveTask->borderWidth);
        }
        else
        {
            // Copy the cached task button bitmap into the temporary buffer...
            if (taskList[i]->active) BitBlt(hdc, currentTaskButton.left, currentTaskButton.top, taskButtonWidthMinusPadding, taskButtonHeightMinusPadding, cachedTaskButtonActive, 0, 0, SRCCOPY);
            else if (pSettings->taskbarInactiveBackground) BitBlt(hdc, currentTaskButton.left, currentTaskButton.top, taskButtonWidthMinusPadding, taskButtonHeightMinusPadding, cachedTaskButtonInactive, 0, 0, SRCCOPY);
        }
 
        //====================
 
        if (taskList[i]->active)
        {
            // Store the active task RECT for possible later use by the toolbar... (i.e. active task alpha transparency etc)
            CopyRect(&ActiveTaskRect, &currentTaskButton);
            activeTaskAvailable = true;
        }
 
        //====================
 
        int padding = ((currentTaskButton.bottom - currentTaskButton.top - iconSize) / 2);
 
        // Should we draw an icon on the task button? (-> all taskbar modes except "Bars" mode)
        if (drawTaskbarMode != TASKBAR_MODE_BARS)
        {
            // Fetch the window icon...
            currentTaskButtonWnd = taskList[i]->hwnd;
            if (currentTaskButtonIcon) DeleteObject(currentTaskButtonIcon);
            currentTaskButtonIcon = NULL;
 
            if (taskList[i]->isAppPlugin) // -> "Application-like" plugins get a xoblite icon for their task buttons...
            {
                currentTaskButtonIcon = LoadIcon(pToolbar->hToolbarInstance, MAKEINTRESOURCE(IDI_XOBLITE));
            }
            else
            {
                if (iconSize <= 16) // -> Use small size (ICON_SMALL) source icon when applicable...
                {
                    SendMessageTimeout(currentTaskButtonWnd, WM_GETICON, ICON_SMALL, 0, SMTO_ABORTIFHUNG|SMTO_BLOCK, 200, (PDWORD_PTR)&currentTaskButtonIcon);
                    if (!currentTaskButtonIcon) currentTaskButtonIcon = (HICON)GetClassLongPtr(currentTaskButtonWnd, GCLP_HICONSM);
                }
                if (!currentTaskButtonIcon) SendMessageTimeout(currentTaskButtonWnd, WM_GETICON, ICON_BIG, 0, SMTO_ABORTIFHUNG|SMTO_BLOCK, 200, (PDWORD_PTR)&currentTaskButtonIcon);
                if (!currentTaskButtonIcon) currentTaskButtonIcon = (HICON)GetClassLongPtr(currentTaskButtonWnd, GCLP_HICON);
            }
 
            // Calculate icon position...
            if (drawTaskbarMode == TASKBAR_MODE_BARSICONS)
            {
                // Bars+Icons mode -> Left adjusted icons...
                CopyRect(&iconRect, &currentTaskButton);
                InflateRect(&iconRect, -padding, 0);
            }
            else // TASKBAR_MODE_ICONS
            {
                // Icons mode -> Centered icons...
                iconRect.left = currentTaskButton.left + (((currentTaskButton.right - currentTaskButton.left) - iconSize) / 2);
            }
 
            iconRect.top = currentTaskButton.top + (taskButtonHeightMinusPadding/2) - (iconSize/2);
            iconRect.right = iconRect.left + iconSize;
            iconRect.bottom = iconRect.top + iconSize;
 
            // Draw the icon...
            if (currentTaskButtonIcon)
            {
                if (taskList[i]->active && !pSettings->taskbarActiveSatHue) DrawIconEx(hdc, iconRect.left, iconRect.top, currentTaskButtonIcon, iconSize, iconSize, 0, NULL, DI_NORMAL);
                else DrawSatHueIcon(hdc, iconRect, currentTaskButtonIcon, iconSize, pSettings->taskbarSaturationValue, pSettings->taskbarHueIntensity);
            }
 
            if (currentTaskButtonIcon) DeleteObject(currentTaskButtonIcon);
        }
 
        //====================
 
        // Copy the current task's window label, i.e. its titlebar text...
        // (note: this may later be used for the task button as well as its associated tooltip, so we should not add anything here.)
        GetWindowText(taskList[i]->hwnd, taskList[i]->captionANSI, 255); // -> ANSI representation
        GetWindowTextW(taskList[i]->hwnd, taskList[i]->captionUnicode, 255); // -> Unicode representation
 
        // Should we draw the window label on the task button?
        if (drawTaskbarMode != TASKBAR_MODE_ICONS) // -> Bars or Bars+Icons mode
        {
            HFONT font = CreateFont(pSettings->Toolbar->FontHeight, 0, 0, 0, pSettings->Toolbar->FontWeight, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH|FF_DONTCARE, pSettings->Toolbar->Font);
            HGDIOBJ oldfont = SelectObject(hdc, font);
            SetBkMode(hdc, TRANSPARENT);
 
            CopyRect(&textRect, &currentTaskButton);
            InflateRect(&textRect, -padding, 0);
            if (drawTaskbarMode == TASKBAR_MODE_BARSICONS)
            {
                // ...adjust text to the already drawn icon...
                textRect.left = iconRect.right + padding;
                if (textRect.left > currentTaskButton.right) textRect.left = currentTaskButton.left; // "Failsafe"
            }
 
            // Added support for Unicode for the task button labels...
            wchar_t currentTaskButtonCaption[275];
            if (pSettings->taskbarShowTaskWorkspace)
            {
                if (IsIconic(taskList[i]->hwnd)) // -> The task is minimized (workspace==255)
                {
//                  taskList[i]->workspace = 255; // ...just in case the task's workspace tag is not up-to-date for some reason...
                    wcscpy(currentTaskButtonCaption, L"[_] ");
                }
                else if (CheckSticky(taskList[i]->hwnd)) // -> The task is "sticky" i.e. visible on all workspaces (sticky)
                {
                    taskList[i]->workspace = 254; // ...just in case the task's workspace tag is not up-to-date for some reason...
                    wcscpy(currentTaskButtonCaption, L"[*] ");
                }
                else // -> The task is visible and located on a single workspace
                {
                    if (taskList[i]->workspace >= 254) taskList[i]->workspace = pSettings->currentWorkspace; // ...just in case the task's workspace tag is not up-to-date for some reason...
                    swprintf(currentTaskButtonCaption, sizeof(currentTaskButtonCaption), L"[%d] ", taskList[i]->workspace + 1);
                }
                wcscat(currentTaskButtonCaption, taskList[i]->captionUnicode);
            }
            else wcscpy(currentTaskButtonCaption, taskList[i]->captionUnicode);
 
            unsigned int flags = DT_CENTER | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_WORD_ELLIPSIS;
            if (taskList[i]->hwnd == flashingHwnd) DrawTextWithEffectsUnicode(hdc, textRect, currentTaskButtonCaption, flags, pSettings->FlashingTask->TextColor, pSettings->ActiveTask->FontOutline, pSettings->FlashingTask->OutlineColor, pSettings->ActiveTask->FontShadow, pSettings->FlashingTask->ShadowColor, pSettings->ActiveTask->ShadowX, pSettings->ActiveTask->ShadowY);
            else if (taskList[i]->active) DrawTextWithEffectsUnicode(hdc, textRect, currentTaskButtonCaption, flags, pSettings->ActiveTask->TextColor, pSettings->ActiveTask->FontOutline, pSettings->ActiveTask->OutlineColor, pSettings->ActiveTask->FontShadow, pSettings->ActiveTask->ShadowColor, pSettings->ActiveTask->ShadowX, pSettings->ActiveTask->ShadowY);
            else DrawTextWithEffectsUnicode(hdc, textRect, currentTaskButtonCaption, flags, pSettings->InactiveTask->TextColor, pSettings->InactiveTask->FontOutline, pSettings->InactiveTask->OutlineColor, pSettings->InactiveTask->FontShadow, pSettings->InactiveTask->ShadowColor, pSettings->InactiveTask->ShadowX, pSettings->InactiveTask->ShadowY);
 
            DeleteObject(SelectObject(hdc, oldfont));
 
            // Should we display a live preview thumbnail for the currently active task?
            if (taskList[i]->active && pSettings->taskbarActiveLivePreview)
            {
                HRESULT hr = DwmRegisterThumbnail(pToolbar->hToolbarWnd, taskList[i]->hwnd, &pToolbar->thumbnail);
                if (SUCCEEDED(hr))
                {
//                  RECT windowRect;
//                  GetWindowRect(taskList[i]->hwnd, &windowRect);
 
                    RECT thumbnailRect;
                    CopyRect(&thumbnailRect, &textRect);
                    InflateRect(&thumbnailRect, 0, -(padding/2));
/*
                    double windowRatio = (windowRect.right - windowRect.left) / (windowRect.bottom - windowRect.top);
                    double thumbnailRatio = (thumbnailRect.right - thumbnailRect.left) / (thumbnailRect.bottom - thumbnailRect.top);
 
                    if (thumbnailRatio > windowRatio)
                    {
                        int thumbnailWidth = (thumbnailRect.right - thumbnailRect.left) / windowRatio;
                        int thumbnailPadding = ((thumbnailRect.right - thumbnailRect.left) - thumbnailWidth) / 2;
                        InflateRect(&thumbnailRect, -thumbnailPadding, 0);
                    }
                    else if (windowRatio > thumbnailRatio)
                    {
                        int thumbnailWidth = (thumbnailRect.right - thumbnailRect.left) / windowRatio;
                        int thumbnailPadding = ((thumbnailRect.right - thumbnailRect.left) - thumbnailWidth) / 2;
                        InflateRect(&thumbnailRect, -thumbnailPadding, 0);
                    }
*/
                    DWM_THUMBNAIL_PROPERTIES dskThumbProps;
                    dskThumbProps.dwFlags = DWM_TNP_RECTDESTINATION | DWM_TNP_OPACITY | DWM_TNP_VISIBLE | DWM_TNP_SOURCECLIENTAREAONLY;
                    dskThumbProps.rcDestination = thumbnailRect;
                    dskThumbProps.opacity = 255;
                    dskThumbProps.fVisible = TRUE;
                    dskThumbProps.fSourceClientAreaOnly = FALSE;
                    DwmUpdateThumbnailProperties(pToolbar->thumbnail, &dskThumbProps);
                }
            }
        }
 
        //====================
 
        if (taskList[i]->hwnd == flashingHwnd) flashingHwnd = 0; // Reset flash indicator...
 
        // Should we create a tooltip for the task button?
        if (pSettings->taskbarTooltips) pTooltips->CreateToolTip((UINT)pTaskbar->taskList[i]->hwnd, pTaskbar->taskList[i]->r, pTaskbar->taskList[i]->captionANSI, TOOLTIP_TYPE_TASK);
 
        drawnTasks++;
    }
 
    //====================
 
    // Finally, we draw "scroll for more" indicators at the left/top (-> more items to the left, or above on a vertical toolbar)
    // and/or right/bottom (-> more items to the right, or below on a vertical toolbar) respectively if so applicable...
 
    if (taskButtonsOffset > 0)
    {
        RECT r;
        if (pSettings->toolbarVertical) SetRect(&r, TaskbarRect.left, TaskbarRect.top, TaskbarRect.right, TaskbarRect.top + taskbarScrollIndicatorSize);
        else SetRect(&r, TaskbarRect.left, TaskbarRect.top, TaskbarRect.left + taskbarScrollIndicatorSize, TaskbarRect.bottom);
 
        COLORREF beginIndicatorColor = GetPixel(hdc, r.left, r.top);
        COLORREF endIndicatorColor = GetPixel(hdc, r.right-1, r.bottom-1);
 
        int centerX = r.left + ((r.right - r.left) / 2);
        int centerY = r.top + ((r.bottom - r.top) / 2);
        COLORREF scrollIndicatorColor = pSettings->MixColors(GetPixel(hdc, centerX, centerY), pSettings->Toolbar->TextColor);
 
        if (pSettings->toolbarVertical) MakeGradientSuper(hdc, r, B_SPLITHORIZONTAL, beginIndicatorColor, scrollIndicatorColor, scrollIndicatorColor, endIndicatorColor, 0, 0, 0, 0, false, BEVEL_FLAT, BEVEL1, 0, 0, 0);
        else MakeGradientSuper(hdc, r, B_SPLITVERTICAL, beginIndicatorColor, scrollIndicatorColor, scrollIndicatorColor, endIndicatorColor, 0, 0, 0, 0, false, BEVEL_FLAT, BEVEL1, 0, 0, 0);
    }
 
    for (int i = (lastButton+1); i < (int)taskList.size(); i++)
    {
        if (!OnCurrentWorkspace(taskList[i]->hwnd) || taskList[i]->hidden) continue;
        else
        {
            RECT r;
            if (pSettings->toolbarVertical) SetRect(&r, TaskbarRect.left, TaskbarRect.bottom - taskbarScrollIndicatorSize, TaskbarRect.right, TaskbarRect.bottom);
            else SetRect(&r, TaskbarRect.right - taskbarScrollIndicatorSize, TaskbarRect.top, TaskbarRect.right, TaskbarRect.bottom);
 
            COLORREF beginIndicatorColor = GetPixel(hdc, r.left, r.top);
            COLORREF endIndicatorColor = GetPixel(hdc, r.right-1, r.bottom-1);
 
            int centerX = r.left + ((r.right - r.left) / 2);
            int centerY = r.top + ((r.bottom - r.top) / 2);
            COLORREF scrollIndicatorColor = pSettings->MixColors(GetPixel(hdc, centerX, centerY), pSettings->Toolbar->TextColor);
 
            if (pSettings->toolbarVertical) MakeGradientSuper(hdc, r, B_SPLITHORIZONTAL, beginIndicatorColor, scrollIndicatorColor, scrollIndicatorColor, endIndicatorColor, 0, 0, 0, 0, false, BEVEL_FLAT, BEVEL1, 0, 0, 0);
            else MakeGradientSuper(hdc, r, B_SPLITVERTICAL, beginIndicatorColor, scrollIndicatorColor, scrollIndicatorColor, endIndicatorColor, 0, 0, 0, 0, false, BEVEL_FLAT, BEVEL1, 0, 0, 0);
 
            break;
        }
    }
 
    return 1;
}

ChangeTaskbarMode()

void Taskbar::ChangeTaskbarMode

(

int

mode

)

{
    char setting[MAX_LINE_LENGTH];
 
    if (mode == TASKBAR_MODE_BARS)
    {
        pSettings->taskbarMode = TASKBAR_MODE_BARS;
        strcpy(setting, "Bars");
    }
    else if (mode == TASKBAR_MODE_BARSICONS)
    {
        pSettings->taskbarMode = TASKBAR_MODE_BARSICONS;
        strcpy(setting, "Bars+Icons");
    }
    else if (mode == TASKBAR_MODE_ICONS)
    {
        pSettings->taskbarMode = TASKBAR_MODE_ICONS;
        strcpy(setting, "Icons");
    }
    else // TASKBAR_MODE_HIDDEN
    {
        pSettings->taskbarMode = TASKBAR_MODE_HIDDEN;
        strcpy(setting, "Hidden");
    }
 
    if ((pSettings->taskbarMode == TASKBAR_MODE_HIDDEN) && pSettings->taskbarTooltips) pTooltips->DeleteAllTooltips();
 
    pToolbar->UpdatePosition(); // -> Refreshes the toolbar including the change of modes...
    PlaySoundFX(SFX_TOGGLE_ELEMENT);
 
    WriteString(pSettings->xobrcFile, "xoblite.taskbar.mode:", setting);
}

ToggleCurrentOnly()

void Taskbar::ToggleCurrentOnly

(

)

{
    if (!pSettings->taskbarCurrentOnly) pSettings->taskbarCurrentOnly = true;
    else pSettings->taskbarCurrentOnly = false;
 
    SendMessage(hBlackboxWnd, BB_TASKSUPDATE, NULL, (LPARAM)TASKITEM_REFRESH);
 
    WriteBool(pSettings->xobrcFile, "xoblite.taskbar.currentOnly:", pSettings->taskbarCurrentOnly);
}

OnCurrentWorkspace()

bool Taskbar::OnCurrentWorkspace

(

HWND

window

)

{
    if (!pSettings->taskbarCurrentOnly) return true;
 
//  int TaskOnWorkspaceNumber = pWorkspaces->GetWorkspaceByWindow(window);
//  if ((TaskOnWorkspaceNumber == pSettings->currentWorkspace) || (TaskOnWorkspaceNumber == 254) || (TaskOnWorkspaceNumber == 255)) return true;
//  else return false;
 
    int i = FindTask(window);
    if (i >= 0)
    {
        if ((taskList[i]->workspace == pSettings->currentWorkspace) || (taskList[i]->workspace == 254)) return true;
    }
 
    return false;
}

GetTaskButtonsToDraw()

int Taskbar::GetTaskButtonsToDraw

(

)

{
    taskButtonsToDraw = 0;
 
    for (int i=0; i < (int)taskList.size(); i++)
    {
        if (pSettings->taskbarCurrentOnly && !OnCurrentWorkspace(taskList[i]->hwnd)) continue;
        if (!taskList[i]->hidden) taskButtonsToDraw++;
    }
 
    if ((pSettings->taskbarMaxItems > 0) && (taskButtonsToDraw > pSettings->taskbarMaxItems)) taskButtonsToDraw = pSettings->taskbarMaxItems;
 
    return taskButtonsToDraw;
}

GetTaskbarScrollIndicatorSizes()

int Taskbar::GetTaskbarScrollIndicatorSizes	(	int *	leftTopPadding,
		int *	rightBottomPadding )

{
    int taskbarScrollIndicatorSize;
    if (pSettings->Toolbar->marginWidth > 0) taskbarScrollIndicatorSize = pSettings->Toolbar->marginWidth;
    else if (pSettings->Toolbar->borderWidth > 0) taskbarScrollIndicatorSize = pSettings->Toolbar->borderWidth;
    taskbarScrollIndicatorSize = 2 * pSettings->scalingFactorHiDPI;
 
    GetTaskButtonsToDraw();
    int firstButton = FindFirstVisible();
    int lastButton = FindLastVisible(firstButton);
    if (lastButton < 0) lastButton = (int)taskList.size()-1; // Failsafe
 
    if (taskButtonsOffset > 0) *leftTopPadding = taskbarScrollIndicatorSize; // -> Left/top taskbar scroll indicator to be drawn!
    else *leftTopPadding = 0;
 
    for (int i = (lastButton+1); i < (int)taskList.size(); i++)
    {
        if (!OnCurrentWorkspace(taskList[i]->hwnd) || taskList[i]->hidden) continue;
        else
        {
            *rightBottomPadding = taskbarScrollIndicatorSize; // -> Right/bottom taskbar scroll indicator to be drawn!
            return taskbarScrollIndicatorSize;
        }
    }
 
    *rightBottomPadding = 0;
 
    return taskbarScrollIndicatorSize;
}

CheckCloakedWindow()

bool Taskbar::CheckCloakedWindow

(

HWND

hwnd

)

{
    // Check for DWM cloaked windows... (e.g. preloading Windows 10 apps like Microsoft Edge etc)
    int cloaked = 0;
    HRESULT hr = DwmGetWindowAttribute(hwnd, DWMWA_CLOAKED, &cloaked, 4);
    if (hr != S_OK) return false;
 
    if (cloaked > 0)
    {
/*
        if (pSettings->debugLogging)
        {
            char msg[MAX_LINE_LENGTH], windowText[MAX_LINE_LENGTH];
            GetWindowText(hwnd, windowText, sizeof(windowText));
            if (cloaked == DWM_CLOAKED_APP) sprintf(msg, "DEBUG -> Taskbar::CheckCloakedWindow -> Cloaked window found! (DWM_CLOAKED_APP) -> %s", windowText);
            else if (cloaked == DWM_CLOAKED_SHELL) sprintf(msg, "DEBUG -> Taskbar::CheckCloakedWindow -> Cloaked window found! (DWM_CLOAKED_SHELL) -> %s", windowText);
            else if (cloaked == DWM_CLOAKED_INHERITED) sprintf(msg, "DEBUG -> Taskbar::CheckCloakedWindow -> Cloaked window found! (DWM_CLOAKED_INHERITED) -> %s", windowText);
            else sprintf(msg, "DEBUG -> Taskbar::CheckCloakedWindow -> Cloaked window found! (unknown DWMWA_CLOAKED value) -> %s", windowText);
            SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)msg);
            Log(msg, "");
        }
*/
        return true;
    }
    else
    {
/*
        if (pSettings->debugLogging)
        {
            char msg[MAX_LINE_LENGTH], windowText[MAX_LINE_LENGTH];
            GetWindowText(hwnd, windowText, sizeof(windowText));
            sprintf(msg, "DEBUG -> Taskbar::CheckCloakedWindow -> This window is uncloaked... -> %s", windowText);
            SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)msg);
            Log(msg, "");
        }
*/
        return false;
    }
}

FindFirstVisible()

int Taskbar::FindFirstVisible

(

)

{
    int visibleItemsFound = 0;
 
    for (int i = 0; i < (int)taskList.size(); i++)
    {
        if (!OnCurrentWorkspace(taskList[i]->hwnd) || taskList[i]->hidden) continue;
        else
        {
            if (visibleItemsFound == taskButtonsOffset) return i; // -> Requested offset found!
            visibleItemsFound++;
        }
    }
 
    return 0; // -> Failsafe (requested offset not found)
}

FindLastVisible()

int Taskbar::FindLastVisible

(

int

offset

)

{
    int visibleItemsFound = 0;
 
    for (int i = offset; i < (int)taskList.size(); i++)
    {
        if (!OnCurrentWorkspace(taskList[i]->hwnd) || taskList[i]->hidden) continue;
        else
        {
            visibleItemsFound++;
            if (visibleItemsFound == pSettings->taskbarMaxItems) return i;
        }
    }
 
    return -1; // -> Fewer than the maximum number of simultaneously visible items left in the taskbar list...
}

NextTask()

void Taskbar::NextTask	(	bool	currentWorkspaceOnly,
		bool	visibleOnly )

{
    if ((int)taskList.size() == 0) return;
 
    HWND nextWindow = NULL;
    bool isAppPlugin = false;
 
    int offset = GetActiveTask();
    if (offset == NULL) offset = 0;
    else
    {
        offset++;
        if (offset >= (int)taskList.size()) offset = 0;
    }
 
    for (int i = offset; i < (int)taskList.size(); i++)
    {
        if (taskList[i]->active || taskList[i]->hidden) continue;
        else if (visibleOnly && IsIconic(taskList[i]->hwnd)) continue;
        else if (currentWorkspaceOnly && !OnCurrentWorkspace(taskList[i]->hwnd)) continue;
        else
        {
            nextWindow = taskList[i]->hwnd;
            if (taskList[i]->isAppPlugin) isAppPlugin = true;
            break;
        }
    }
 
    if ((offset > 0) && (nextWindow == NULL))
    {
        for (int i = 0; i < offset; i++)
        {
            if (taskList[i]->active || taskList[i]->hidden) continue;
            else if (visibleOnly && IsIconic(taskList[i]->hwnd)) continue;
            else if (currentWorkspaceOnly && !OnCurrentWorkspace(taskList[i]->hwnd)) continue;
            else
            {
                nextWindow = taskList[i]->hwnd;
                if (taskList[i]->isAppPlugin) isAppPlugin = true;
                break;
            }
        }
    }
 
    if (nextWindow != NULL)
    {
        SetForegroundWindow(pToolbar->hToolbarWnd);
        SendMessage(hBlackboxWnd, BB_BRINGTOFRONT, 0, (LPARAM)nextWindow);
        SetActiveTask(nextWindow);
        if (isAppPlugin) SendMessage(nextWindow, BB_BROADCAST, 0, (LPARAM)"@AppPlugin Show");
        else if (IsIconic(nextWindow)) ShowWindow(nextWindow, SW_RESTORE);
        SetForegroundWindow(nextWindow);
        SetWindowPos(nextWindow, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);
        PlaySoundFX(SFX_TASKBAR_RESTORE);
    }
}

PreviousTask()

void Taskbar::PreviousTask	(	bool	currentWorkspaceOnly,
		bool	visibleOnly )

{
    if ((int)taskList.size() == 0) return;
 
    HWND previousWindow = NULL;
    bool isAppPlugin = false;
 
    int offset = GetActiveTask();
    if (offset == NULL) offset = 0;
    else if (offset > 0) offset--;
 
    for (int i = offset; i >= 0; i--)
    {
        if (taskList[i]->active || taskList[i]->hidden) continue;
        else if (visibleOnly && IsIconic(taskList[i]->hwnd)) continue;
        else if (currentWorkspaceOnly && !OnCurrentWorkspace(taskList[i]->hwnd)) continue;
        else
        {
            previousWindow = taskList[i]->hwnd;
            if (taskList[i]->isAppPlugin) isAppPlugin = true;
            break;
        }
    }
 
    if (previousWindow == NULL)
    {
        for (int i = ((int)taskList.size()-1); i > offset; i--)
        {
            if (taskList[i]->active || taskList[i]->hidden) continue;
            else if (visibleOnly && IsIconic(taskList[i]->hwnd)) continue;
            else if (currentWorkspaceOnly && !OnCurrentWorkspace(taskList[i]->hwnd)) continue;
            else
            {
                previousWindow = taskList[i]->hwnd;
                if (taskList[i]->isAppPlugin) isAppPlugin = true;
                break;
            }
        }
    }
 
    if (previousWindow != NULL)
    {
        SetForegroundWindow(pToolbar->hToolbarWnd);
        SendMessage(hBlackboxWnd, BB_BRINGTOFRONT, 0, (LPARAM)previousWindow);
        SetActiveTask(previousWindow);
        if (isAppPlugin) SendMessage(previousWindow, BB_BROADCAST, 0, (LPARAM)"@AppPlugin Show");
        else if (IsIconic(previousWindow)) ShowWindow(previousWindow, SW_RESTORE);
        SetForegroundWindow(previousWindow);
        SetWindowPos(previousWindow, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);
        PlaySoundFX(SFX_TASKBAR_RESTORE);
    }
}

SortTaskbarItems()

void Taskbar::SortTaskbarItems

(

int

mode

)

{
    if (mode == TASKBAR_SORT_BY_LAST_USED) sort(taskList.begin(), taskList.end(), Taskbar::CompareTaskbarItemsByLastUsed);
//  else if (mode == TASKBAR_SORT_BY_NAME) sort(taskList.begin(), taskList.end(), Taskbar::CompareTaskbarItemsByName);
}

CompareTaskbarItemsByLastUsed()

bool Taskbar::CompareTaskbarItemsByLastUsed ( taskListItem * t1, taskListItem * t2 )

static

{
    return t1->lastUsed < t2->lastUsed;
}

TileWindow()

void Taskbar::TileWindow

(

int

placement

)

{
    // Find the currently active task...
    int i = GetActiveTask();
    if (i == -1) return;
    if (taskList[i]->dimensions.placement == placement) return;
 
    HWND currentWnd = taskList[i]->hwnd;
 
    RECT workArea;
    SystemParametersInfo(SPI_GETWORKAREA, 0, (PVOID)&workArea, SPIF_SENDCHANGE);
    int screenWidth = (workArea.right - workArea.left);
    int screenHeight = (workArea.bottom - workArea.top);
    int halfScreenWidth = screenWidth / 2;
    int halfScreenHeight = screenHeight / 2;
    int quarterScreenWidth = screenWidth / 4;
    int quarterScreenHeight = screenHeight / 4;
    int thirdScreenWidth = screenWidth / 3;
    
    if (taskList[i]->dimensions.placement == PLACEMENT_DEFAULT)
    {
        // Save the position and dimensions of a non-tiled window before tiling it,
        // so we can go back to this non-tiled state later on...
        if (IsZoomed(currentWnd))
        {
            taskList[i]->dimensions.centeredx = taskList[i]->dimensions.centeredy = true; // For now we re-use these placement bools to save the maximized/restored state of the window
            ShowWindow(currentWnd, SW_RESTORE);
        }
        else taskList[i]->dimensions.centeredx = taskList[i]->dimensions.centeredy = false;
 
        RECT r;
        GetWindowRect(currentWnd, &r);
        taskList[i]->dimensions.x = r.left;
        taskList[i]->dimensions.y = r.top;
        taskList[i]->dimensions.width = r.right - r.left;
        taskList[i]->dimensions.height = r.bottom - r.top;
    }
 
    taskList[i]->dimensions.placement = placement; // Save the new window placement
    
    switch (placement)
    {
        // ###################################
        // ##### Default non-tiled state #####
        // ###################################
 
        case PLACEMENT_DEFAULT:
        {
            MoveWindow(currentWnd, taskList[i]->dimensions.x, taskList[i]->dimensions.y, taskList[i]->dimensions.width, taskList[i]->dimensions.height, true);
            if (taskList[i]->dimensions.centeredx && taskList[i]->dimensions.centeredy) ShowWindow(currentWnd, SW_MAXIMIZE);
            break;
        }
 
        // #######################################
        // ##### Centered at 2/3 screen size #####
        // #######################################
 
        case PLACEMENT_CENTERED:
        {
            MoveWindow(currentWnd, workArea.left + (quarterScreenWidth / 2), workArea.top + (quarterScreenHeight / 2), (halfScreenWidth + quarterScreenWidth), (halfScreenHeight + quarterScreenHeight), true);
            break;
        }
 
        // ###########################################
        // ##### Half screen size tiling options #####
        // ###########################################
 
        case PLACEMENT_LEFT_HALF:
        {
            MoveWindow(currentWnd, workArea.left, workArea.top, halfScreenWidth, screenHeight, true);
            break;
        }
 
        case PLACEMENT_RIGHT_HALF:
        {
            MoveWindow(currentWnd, workArea.left + halfScreenWidth, workArea.top, halfScreenWidth, screenHeight, true);
            break;
        }
 
        case PLACEMENT_TOP_HALF:
        {
            MoveWindow(currentWnd, workArea.left, workArea.top, screenWidth, halfScreenHeight, true);
            break;
        }
 
        case PLACEMENT_BOTTOM_HALF:
        {
            MoveWindow(currentWnd, workArea.left, workArea.top + halfScreenHeight, screenWidth, halfScreenHeight, true);
            break;
        }
 
        // ################################################
        // ##### One third screen size tiling options #####
        // ################################################
 
        case PLACEMENT_CENTER_LEFT:
        {
            MoveWindow(currentWnd, workArea.left, workArea.top, thirdScreenWidth, screenHeight, true);
            break;
        }
 
        case PLACEMENT_CENTER_CENTER:
        {
            MoveWindow(currentWnd, workArea.left + thirdScreenWidth, workArea.top, thirdScreenWidth, screenHeight, true);
            break;
        }
 
        case PLACEMENT_CENTER_RIGHT:
        {
            MoveWindow(currentWnd, workArea.right - thirdScreenWidth, workArea.top, thirdScreenWidth, screenHeight, true);
            break;
        }
 
        // ##################################################
        // ##### One quarter screen size tiling options #####
        // ##################################################
 
        case PLACEMENT_TOP_LEFT:
        {
            MoveWindow(currentWnd, workArea.left, workArea.top, halfScreenWidth, halfScreenHeight, true);
            break;
        }
 
        case PLACEMENT_BOTTOM_LEFT:
        {
            MoveWindow(currentWnd, workArea.left, workArea.bottom - halfScreenHeight, halfScreenWidth, halfScreenHeight, true);
            break;
        }
 
        case PLACEMENT_TOP_RIGHT:
        {
            MoveWindow(currentWnd, workArea.left + halfScreenWidth, workArea.top, halfScreenWidth, halfScreenHeight, true);
            break;
        }
 
        case PLACEMENT_BOTTOM_RIGHT:
        {
            MoveWindow(currentWnd, workArea.left + halfScreenWidth, workArea.top + halfScreenHeight, halfScreenWidth, halfScreenHeight, true);
            break;
        }
 
        // ##################################################
        // #####  One sixth screen size tiling options  #####
        // ##### (i.e. matches one third options above) #####
        // ##################################################
 
        case PLACEMENT_TOP_CENTER:
        {
            MoveWindow(currentWnd, workArea.left + thirdScreenWidth, workArea.top, thirdScreenWidth, halfScreenHeight, true);
            break;
        }
 
        case PLACEMENT_BOTTOM_CENTER:
        {
            MoveWindow(currentWnd, workArea.left + thirdScreenWidth, workArea.top + halfScreenHeight, thirdScreenWidth, halfScreenHeight, true);
            break;
        }
 
        default: { break; }
    }
 
    InvalidateRect(currentWnd, NULL, false);
    SetForegroundWindow(currentWnd);
    PlaySoundFX(SFX_TASKBAR_TILE);
}

Friends And Related Symbol Documentation

TaskEnumerator

BOOL CALLBACK TaskEnumerator ( HWND window, LPARAM main )

friend

{
/*
    if (pSettings->debugLogging)
    {
        char msg[MAX_LINE_LENGTH], windowText[MAX_LINE_LENGTH], windowClass[MAX_LINE_LENGTH];
        GetWindowText(window, windowText, sizeof(windowText));
        if (!strlen(windowText)) strcpy(windowText, "NULL");
        GetClassName(window, windowClass, sizeof(windowClass));
        if (!strlen(windowClass)) strcpy(windowClass, "NULL");
        sprintf(msg, "DEBUG -> Taskbar::TaskEnumerator -> %s | %s", windowText, windowClass);
        Log(msg, "");
    }
*/
    pTaskbar->AddTask(window);
 
    return 1;
}

Member Data Documentation

hBlackboxWnd

HWND Taskbar::hBlackboxWnd

cachedTaskButtonActive

HDC Taskbar::cachedTaskButtonActive

cachedTaskButtonInactive

HDC Taskbar::cachedTaskButtonInactive

cachedTaskButtonsExist

bool Taskbar::cachedTaskButtonsExist

TaskbarRect

RECT Taskbar::TaskbarRect

activeTaskAvailable

bool Taskbar::activeTaskAvailable

ActiveTaskRect

RECT Taskbar::ActiveTaskRect

currentTaskButton

RECT Taskbar::currentTaskButton

currentTaskButtonWnd

HWND Taskbar::currentTaskButtonWnd

currentTaskButtonIcon

HICON Taskbar::currentTaskButtonIcon

iconSize

int Taskbar::iconSize

iconRect

RECT Taskbar::iconRect

textRect

RECT Taskbar::textRect

taskButtonWidth

int Taskbar::taskButtonWidth

taskButtonWidthMinusPadding

int Taskbar::taskButtonWidthMinusPadding

taskButtonHeight

int Taskbar::taskButtonHeight

taskButtonHeightMinusPadding

int Taskbar::taskButtonHeightMinusPadding

taskButtonsToDraw

int Taskbar::taskButtonsToDraw

taskButtonsOffset

int Taskbar::taskButtonsOffset

flashingHwnd

HWND Taskbar::flashingHwnd

taskList

vector<taskListItem*> Taskbar::taskList

enumeratingTasks

bool Taskbar::enumeratingTasks

blockNextMouseClick

bool Taskbar::blockNextMouseClick