Desktop Class Reference

#include <Desktop.h>

Classes
struct	WallpaperStruct

Public Types
typedef struct Desktop::WallpaperStruct	WallpaperStruct

Public Member Functions
	Desktop (HINSTANCE hInstance)
	~Desktop ()
void	UpdateDesktopWindow ()
void	GetDimensions ()
void	LoadWallpaper (LPSTR imagePath)
void	DrawWallpaper (HDC hdc)
void	CheckWidgetPlacement (Placement *widget)
LRESULT	MouseAndDropHandler (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
bool	GetClockText (bool forceUpdate)
bool	GetGreetingText (bool forceUpdate)
void	ShadeWindow ()
void	WinShade (HWND hwnd, int listIndex, bool maximized)
void	WinUnshade (HWND hwnd, int listIndex, bool maximized)
void	GrowWindowHeight ()
void	GrowWindowWidth ()
void	LowerWindow ()
void	RaiseWindow ()

Public Attributes
HINSTANCE	hDesktopInstance
HWND	hBlackboxWnd
HWND	hDesktopWnd
HDC	cachedBackground
int	DesktopX
int	DesktopY
int	DesktopWidth
int	DesktopHeight
int	DesktopCenterX
int	DesktopCenterY
wchar_t	CurrentTime [32]
wchar_t	CurrentWeekday [32]
wchar_t	CurrentDate [MAX_LINE_LENGTH]
wchar_t	CurrentGreeting [32]
int	displayedMinute
time_t	systemTime
struct tm	localTime
int	currentHour
int	currentMinute
RECT	clockRect
RECT	weekdayRect
RECT	dateRect
RECT	greetingRect
int	numberOfDisplayMonitors
WallpaperStruct	wallpaper

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

Member Typedef Documentation

WallpaperStruct

typedef struct Desktop::WallpaperStruct Desktop::WallpaperStruct

Constructor & Destructor Documentation

Desktop()

Desktop::Desktop

(

HINSTANCE

hInstance

)

{
    hDesktopWnd = NULL;
    hBlackboxWnd = GetBBWnd();
    hDesktopInstance = hInstance;
    cachedBackground = CreateCompatibleDC(NULL);
    wallpaper.bitmap = NULL;
 
    CurrentTime[0] = CurrentWeekday[0] = CurrentDate[0] = CurrentGreeting[0] = '\0';
 
    numberOfDisplayMonitors = GetSystemMetrics(SM_CMONITORS);
 
    //====================
 
    // Get size and position for the desktop window...
    GetDimensions();
    // ...and get the current time for the desktop clock...
    GetClockText(true);
    GetGreetingText(true);
 
    if (!pSettings->underExplorer && pSettings->debugLogging) LoadWallpaper("c:\\Blackbox\\wallpapers\\reddit\\21x0pf6kq5ta1.png"); // EXPERIMENTAL & TEMPORARY :)
 
    //====================
 
    // Register window class...
    WNDCLASS wc;
    ZeroMemory(&wc, sizeof(wc));
    wc.hInstance = hDesktopInstance;            // hInstance
    wc.lpfnWndProc = DesktopWndProc;          // window procedure
    wc.lpszClassName = szDesktopName;          // window class name
    wc.hbrBackground = NULL;                    // no class background brush
    wc.style = CS_DBLCLKS;                      // class styles (e.g. accept doubleclicks)
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);   // always display the regular arrow cursor
 
    if (!RegisterClass(&wc))
    {
        MessageBox(0, "Error registering desktop window class!", szDesktopName, MB_OK | MB_ICONERROR | MB_TOPMOST);
        Log("Desktop: Error registering window class", NULL);
        return;
    }
 
    // Create desktop window...
    hDesktopWnd = CreateWindowEx(
        WS_EX_TOOLWINDOW | WS_EX_ACCEPTFILES | WS_EX_NOACTIVATE | WS_EX_LAYERED,   // window style
        szDesktopName,                                                             // window class
        NULL,                                                                       // window name
        WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,                               // window parameters
        DesktopX,                                                                   // x position
        DesktopY,                                                                   // y position
        DesktopWidth,                                                               // window width
        DesktopHeight,                                                             // window height
        NULL,                                                                       // owner window
        NULL,                                                                       // no menu
        hDesktopInstance,                                                           // hInstance
        NULL                                                                        // no window creation data
    );
 
    if (!hDesktopWnd)
    {
        UnregisterClass(szDesktopName, hDesktopInstance); // unregister window class
        MessageBox(0, "Error creating desktop window!", szDesktopName, MB_OK | MB_ICONERROR | MB_TOPMOST);
        Log("Desktop: Error creating window!", NULL);
        return;
    }
 
    //====================
 
    // Subscribe to Blackbox messages applicable to the desktop...
    SendMessage(hBlackboxWnd, BB_REGISTERMESSAGE, (WPARAM)hDesktopWnd, (LPARAM)desktopMessageSubscription);
 
    // Make the desktop window sticky...
    MakeSticky(hDesktopWnd);
    // Move the desktop window to the bottom of the application z-order... (i.e. just above the Windows desktop in our case)
//  SetWindowPos(hDesktopWnd, GetDesktopWindow(), 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE | SWP_NOSENDCHANGING | SWP_NOOWNERZORDER);
    SetWindowPos(hDesktopWnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE | SWP_NOSENDCHANGING | SWP_NOOWNERZORDER);
 
    // Show+update the desktop window...
    ShowWindow(hDesktopWnd, SW_SHOWNOACTIVATE);
    UpdateDesktopWindow();
 
    // Set timer for the desktop clock update checks... (every 10 seconds, but only updating the desktop/clock if needed)
    if (!SetTimer(hDesktopWnd, DESKTOP_UPDATE_TIMER, 10000, (TIMERPROC)NULL)) CurrentTime[0] = '\0';
}

~Desktop()

Desktop::~Desktop

(

)

{
    KillTimer(hDesktopWnd, DESKTOP_UPDATE_TIMER);
 
    // Unsubscribe to previously subscribed Blackbox messages...
    SendMessage(hBlackboxWnd, BB_UNREGISTERMESSAGE, (WPARAM)hDesktopWnd, (LPARAM)desktopMessageSubscription);
 
    if (hDesktopWnd) DestroyWindow(hDesktopWnd); // Destroy window...
    UnregisterClass(szDesktopName, hDesktopInstance); // Unregister window class...
 
    if (wallpaper.bitmap != NULL) DeleteObject(wallpaper.bitmap); // Delete any cached bitmap...
    if (cachedBackground != NULL) DeleteDC(cachedBackground); // Delete the cached gradient...
}

Member Function Documentation

UpdateDesktopWindow()

void Desktop::UpdateDesktopWindow

(

)

{
    // Fetch the new size and position parameters for the desktop window...
    GetDimensions();
 
    RECT r;
    SetRect(&r, 0, 0, DesktopWidth, DesktopHeight);
 
    HDC hdc = GetWindowDC(hDesktopWnd);
    HBITMAP bufbmp = CreateCompatibleBitmap(hdc, r.right - r.left, r.bottom - r.top);
    DeleteObject(SelectObject(cachedBackground, bufbmp));
    ReleaseDC(hDesktopWnd, hdc);
 
    //====================
 
    HBRUSH brush = NULL;
 
    if (!pSettings->underExplorer && (wallpaper.bitmap != NULL))
    {
        SetRect(&r, 0, 0, DesktopWidth, DesktopHeight);
        DrawWallpaper(cachedBackground);
        AlphaRect(cachedBackground, r, 255);
    }
    else
    {
        // Draw desktop background...
        HBRUSH brush = CreateSolidBrush(0x000000);
        FillRect(cachedBackground, &r, brush);
        DeleteObject(brush);
 
        // Apply almost full transparency -> The desktop is still there and we can click it etc, but the regular Windows wallpaper can be seen!
        SetRect(&r, 0, 0, DesktopWidth, DesktopHeight);
        if (!pSettings->desktopBorderHidden)
        {
            AlphaRect(cachedBackground, r, 64);
            InflateRect(&r, (-4 * pSettings->scalingFactorHiDPI), (-4 * pSettings->scalingFactorHiDPI));
        }
        AlphaRect(cachedBackground, r, 1);
        // if (!pSettings->desktopBorderHidden) AlphaCorner(cachedBackground, r, CORNER_TOPLEFT | CORNER_TOPRIGHT | CORNER_BOTTOMLEFT | CORNER_BOTTOMRIGHT, 0, 0, 0, 0, 64, 1);
        // AlphaApply(cachedBackground, r);
    }
 
    //====================
 
    if (!pSettings->desktopWorkspaceIndicatorHidden)
    {
        // Draw workspace indicators... (nb. their default position is near top center, but if the toolbar placement is top something we put them near bottom center instead)
        char workspacePlacement[20] = "\0";
        Placement workspaceIndicators;
        workspaceIndicators.width = (pSettings->numberOfWorkspaces * 20 * pSettings->scalingFactorHiDPI) - (4 * pSettings->scalingFactorHiDPI);
        workspaceIndicators.height = (9 * pSettings->scalingFactorHiDPI);
        if (!pSettings->toolbarHidden && (pSettings->ToolbarPlacement.placement == PLACEMENT_TOP_LEFT ||
            pSettings->ToolbarPlacement.placement == PLACEMENT_TOP_CENTER || pSettings->ToolbarPlacement.placement == PLACEMENT_TOP_RIGHT))
        {
            sprintf(workspacePlacement, "Manual xC y-%d", r.top + (9*pSettings->scalingFactorHiDPI));
        }
        else
        {
            sprintf(workspacePlacement, "Manual xC y%d", r.top + (9*pSettings->scalingFactorHiDPI));
        }
        pSettings->ParsePlacement(workspacePlacement, &workspaceIndicators);
        pSettings->PositionFromPlacement(&workspaceIndicators);
//      CheckWidgetPlacement(&workspaceIndicators);
 
        SetRect(&r, workspaceIndicators.x, workspaceIndicators.y, workspaceIndicators.x+(16*pSettings->scalingFactorHiDPI), workspaceIndicators.y+(9*pSettings->scalingFactorHiDPI));
 
//      brush = CreateSolidBrush(0xffffff);
        brush = CreateSolidBrush(pSettings->desktopWidgetColor);
        for (int i=0; i<pSettings->numberOfWorkspaces; i++)
        {
            FillRect(cachedBackground, &r, brush);
            if (i == pSettings->currentWorkspace) AlphaRect(cachedBackground, r, 128);
            else AlphaRect(cachedBackground, r, 64);
            OffsetRect(&r, (20*pSettings->scalingFactorHiDPI), 0);
        }
        DeleteObject(brush);
    }
 
    //====================
 
    // Draw greeting...?
    if (!pSettings->desktopGreetingHidden)
    {
        HFONT font;
        if (pSettings->desktopGreetingFontDefined)
        {
            font = CreateFont((pSettings->desktopGreetingFontHeight * pSettings->scalingFactorHiDPI), 0, 0, 0, pSettings->desktopGreetingFontWeight, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, pSettings->desktopGreetingFont);
        }
        else
        {
            int fontHeight = 30 * pSettings->scalingFactorHiDPI;
            font = CreateFont(fontHeight, 0, 0, 0, FW_NORMAL, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "Segoe UI");
        }
        HGDIOBJ oldfont = SelectObject(cachedBackground, font);
        SetBkMode(cachedBackground, TRANSPARENT);
 
        SIZE size;
        GetTextExtentPoint32W(cachedBackground, CurrentGreeting, wcslen(CurrentGreeting), &size);
        pSettings->desktopGreetingPlacement.width = size.cx;
        pSettings->desktopGreetingPlacement.height = size.cy;
 
        if (pSettings->desktopGreetingPlacement.placement != PLACEMENT_DEFAULT)
        {
            pSettings->PositionFromPlacement(&pSettings->desktopGreetingPlacement);
            CheckWidgetPlacement(&pSettings->desktopGreetingPlacement);
            SetRect(&greetingRect, pSettings->desktopGreetingPlacement.x, pSettings->desktopGreetingPlacement.y, pSettings->desktopGreetingPlacement.x + pSettings->desktopGreetingPlacement.width, pSettings->desktopGreetingPlacement.y + pSettings->desktopGreetingPlacement.height);
        }
        else // PLACEMENT_DEFAULT
        {
            greetingRect.left = DesktopCenterX - (pSettings->desktopGreetingPlacement.width / 2);
            greetingRect.right = greetingRect.left + pSettings->desktopGreetingPlacement.width;
            if (pSettings->desktopGreetingFontDefined) greetingRect.top = 339;
            else greetingRect.top = 320;
            greetingRect.bottom = greetingRect.top + pSettings->desktopGreetingPlacement.height;
        }
 
        COLORREF colorHighAlpha = RGB(pSettings->desktopGreetingTransparencyAlpha, pSettings->desktopGreetingTransparencyAlpha, pSettings->desktopGreetingTransparencyAlpha);
        DrawTextWithEffectsUnicode(cachedBackground, greetingRect, CurrentGreeting, DT_CENTER | DT_TOP | DT_NOPREFIX | DT_SINGLELINE, colorHighAlpha, false, 0, false, 0, 0, 0);
//      DrawTextWithEffectsUnicode(cachedBackground, greetingRect, CurrentGreeting, DT_CENTER | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE, colorHighAlpha, false, 0, false, 0, 0, 0);
 
        DeleteObject(SelectObject(cachedBackground, oldfont));
    }
 
    //====================
 
    // Draw weekday...?
    if (!pSettings->desktopWeekdayHidden)
    {
        HFONT font;
        if (pSettings->desktopWeekdayFontDefined)
        {
            font = CreateFont((pSettings->desktopWeekdayFontHeight * pSettings->scalingFactorHiDPI), 0, 0, 0, pSettings->desktopWeekdayFontWeight, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, pSettings->desktopWeekdayFont);
        }
        else
        {
            int fontHeight = 30 * pSettings->scalingFactorHiDPI;
            font = CreateFont(fontHeight, 0, 0, 0, FW_BOLD, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "Segoe UI");
        }
        HGDIOBJ oldfont = SelectObject(cachedBackground, font);
        SetBkMode(cachedBackground, TRANSPARENT);
 
        SIZE size;
        GetTextExtentPoint32W(cachedBackground, CurrentWeekday, wcslen(CurrentWeekday), &size);
        pSettings->desktopWeekdayPlacement.width = size.cx;
        pSettings->desktopWeekdayPlacement.height = size.cy;
 
        if (pSettings->desktopWeekdayPlacement.placement != PLACEMENT_DEFAULT)
        {
            pSettings->PositionFromPlacement(&pSettings->desktopWeekdayPlacement);
            CheckWidgetPlacement(&pSettings->desktopWeekdayPlacement);
            SetRect(&weekdayRect, pSettings->desktopWeekdayPlacement.x, pSettings->desktopWeekdayPlacement.y, pSettings->desktopWeekdayPlacement.x + pSettings->desktopWeekdayPlacement.width, pSettings->desktopWeekdayPlacement.y + pSettings->desktopWeekdayPlacement.height);
        }
        else // PLACEMENT_DEFAULT
        {
            weekdayRect.left = DesktopCenterX - (pSettings->desktopWeekdayPlacement.width / 2);
            weekdayRect.right = weekdayRect.left + pSettings->desktopWeekdayPlacement.width;
            if (pSettings->desktopWeekdayFontDefined) weekdayRect.top = 139;
            else weekdayRect.top = 120;
            weekdayRect.bottom = weekdayRect.top + pSettings->desktopWeekdayPlacement.height;
        }
 
        COLORREF colorHighAlpha = RGB(pSettings->desktopWeekdayTransparencyAlpha, pSettings->desktopWeekdayTransparencyAlpha, pSettings->desktopWeekdayTransparencyAlpha);
        DrawTextWithEffectsUnicode(cachedBackground, weekdayRect, CurrentWeekday, DT_CENTER | DT_TOP | DT_NOPREFIX | DT_SINGLELINE, colorHighAlpha, false, 0, false, 0, 0, 0);
//      DrawTextWithEffectsUnicode(cachedBackground, weekdayRect, CurrentWeekday, DT_CENTER | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE, colorHighAlpha, false, 0, false, 0, 0, 0);
 
        DeleteObject(SelectObject(cachedBackground, oldfont));
    }
 
    //====================
 
    // Draw date...?
    if (!pSettings->desktopDateHidden)
    {
        HFONT font;
        if (pSettings->desktopDateFontDefined)
        {
            font = CreateFont((pSettings->desktopDateFontHeight * pSettings->scalingFactorHiDPI), 0, 0, 0, pSettings->desktopDateFontWeight, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, pSettings->desktopDateFont);
        }
        else
        {
            int fontHeight = 30 * pSettings->scalingFactorHiDPI;
            font = CreateFont(fontHeight, 0, 0, 0, FW_NORMAL, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "Segoe UI");
        }
        HGDIOBJ oldfont = SelectObject(cachedBackground, font);
        SetBkMode(cachedBackground, TRANSPARENT);
 
        SIZE size;
        GetTextExtentPoint32W(cachedBackground, CurrentDate, wcslen(CurrentDate), &size);
        pSettings->desktopDatePlacement.width = size.cx;
        pSettings->desktopDatePlacement.height = size.cy;
 
        if (pSettings->desktopDatePlacement.placement != PLACEMENT_DEFAULT)
        {
            pSettings->PositionFromPlacement(&pSettings->desktopDatePlacement);
            CheckWidgetPlacement(&pSettings->desktopDatePlacement);
            SetRect(&dateRect, pSettings->desktopDatePlacement.x, pSettings->desktopDatePlacement.y, pSettings->desktopDatePlacement.x + pSettings->desktopDatePlacement.width, pSettings->desktopDatePlacement.y + pSettings->desktopDatePlacement.height);
        }
        else // PLACEMENT_DEFAULT
        {
            dateRect.left = DesktopCenterX - (pSettings->desktopDatePlacement.width / 2);
            dateRect.right = dateRect.left + pSettings->desktopDatePlacement.width;
            if (pSettings->desktopDateFontDefined) dateRect.top = 239;
            else dateRect.top = 220;
            dateRect.bottom = dateRect.top + pSettings->desktopDatePlacement.height;
        }
 
        COLORREF colorHighAlpha = RGB(pSettings->desktopDateTransparencyAlpha, pSettings->desktopDateTransparencyAlpha, pSettings->desktopDateTransparencyAlpha);
//      COLORREF colorMediumAlpha = RGB(pSettings->desktopDateTransparencyAlpha / 2, pSettings->desktopDateTransparencyAlpha / 2, pSettings->desktopDateTransparencyAlpha / 2);
        DrawTextWithEffectsUnicode(cachedBackground, dateRect, CurrentDate, DT_CENTER | DT_TOP | DT_NOPREFIX | DT_SINGLELINE, colorHighAlpha, false, 0, false, 0, 0, 0);
//      DrawTextWithEffectsUnicode(cachedBackground, dateRect, CurrentDate, DT_CENTER | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE, colorHighAlpha, false, 0, false, 0, 0, 0);
 
        DeleteObject(SelectObject(cachedBackground, oldfont));
    }
 
    //====================
 
    bool clockAlphaApplied = false;
 
    // Draw clock...?
    if (!pSettings->desktopClockHidden)
    {
        if (!_stricmp(pSettings->desktopClockType, "Regular")) // -> Regular 24-hour clock (HH:MM)
        {
            HFONT font;
            if (pSettings->desktopClockFontDefined)
            {
                font = CreateFont((pSettings->desktopClockFontHeight * pSettings->scalingFactorHiDPI), 0, 0, 0, pSettings->desktopClockFontWeight, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, pSettings->desktopClockFont);
            }
            else
            {
                int fontHeight = 180 * pSettings->scalingFactorHiDPI;
                font = CreateFont(fontHeight, 0, 0, 0, FW_NORMAL, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "Segoe UI");
            }
            HGDIOBJ oldfont = SelectObject(cachedBackground, font);
            SetBkMode(cachedBackground, TRANSPARENT);
 
            SIZE size;
            GetTextExtentPoint32W(cachedBackground, CurrentTime, wcslen(CurrentTime), &size);
            pSettings->desktopClockPlacement.width = size.cx;
            pSettings->desktopClockPlacement.height = size.cy;
 
            if (pSettings->desktopClockPlacement.placement != PLACEMENT_DEFAULT)
            {
                pSettings->PositionFromPlacement(&pSettings->desktopClockPlacement);
                CheckWidgetPlacement(&pSettings->desktopClockPlacement);
                SetRect(&clockRect, pSettings->desktopClockPlacement.x, pSettings->desktopClockPlacement.y, pSettings->desktopClockPlacement.x + pSettings->desktopClockPlacement.width, pSettings->desktopClockPlacement.y + pSettings->desktopClockPlacement.height);
            }
            else // PLACEMENT_DEFAULT
            {
                clockRect.left = DesktopCenterX - (pSettings->desktopClockPlacement.width / 2);
                clockRect.right = clockRect.left + pSettings->desktopClockPlacement.width;
                if (pSettings->desktopClockFontDefined) clockRect.top = 39;
                else clockRect.top = 20;
                clockRect.bottom = clockRect.top + pSettings->desktopClockPlacement.height;
            }
 
            COLORREF colorHighAlpha = RGB(pSettings->desktopClockTransparencyAlpha, pSettings->desktopClockTransparencyAlpha, pSettings->desktopClockTransparencyAlpha);
            DrawTextWithEffectsUnicode(cachedBackground, clockRect, CurrentTime, DT_CENTER | DT_TOP | DT_NOPREFIX | DT_SINGLELINE, colorHighAlpha, false, 0, false, 0, 0, 0);
//          DrawTextWithEffectsUnicode(cachedBackground, clockRect, CurrentTime, DT_CENTER | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE, colorHighAlpha, false, 0, false, 0, 0, 0);
 
            DeleteObject(SelectObject(cachedBackground, oldfont));
        }
 
        //====================
 
        else if (!_stricmp(pSettings->desktopClockType, "Text")) // -> "Text clock" using simple 12 hour format, e.g. "TWENTY past EIGHT" (regardless of AM/PM)
        {
            HFONT font;
            if (pSettings->desktopClockFontDefined)
            {
                font = CreateFont((pSettings->desktopClockFontHeight * pSettings->scalingFactorHiDPI), 0, 0, 0, pSettings->desktopClockFontWeight, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, pSettings->desktopClockFont);
            }
            else
            {
                int fontHeight = 30 * pSettings->scalingFactorHiDPI;
                font = CreateFont(fontHeight, 0, 0, 0, FW_BOLD, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, "Segoe UI");
            }
            HGDIOBJ oldfont = SelectObject(cachedBackground, font);
            SetBkMode(cachedBackground, TRANSPARENT);
 
            char textMinutes[32] = "", textInBetween[32] = "", textHours[32] = "", textAfter[32] = "", textClock[128] = "";
 
            int relativeMinute = currentMinute;
            if (currentMinute > 30) relativeMinute = 60 - currentMinute;
 
            if (relativeMinute < 30)
            {
                if (relativeMinute >= 20)
                {
                    strcat(textMinutes, "TWENTY");
                    switch (relativeMinute - 20)
                    {
                        case 9: { strcat(textMinutes, " NINE"); break; }
                        case 8: { strcat(textMinutes, " EIGHT"); break; }
                        case 7: { strcat(textMinutes, " SEVEN"); break; }
                        case 6: { strcat(textMinutes, " SIX"); break; }
                        case 5: { strcat(textMinutes, " FIVE"); break; }
                        case 4: { strcat(textMinutes, " FOUR"); break; }
                        case 3: { strcat(textMinutes, " THREE"); break; }
                        case 2: { strcat(textMinutes, " TWO"); break; }
                        case 1: { strcat(textMinutes, " ONE"); break; }
                        case 0: { break; }
                    }
                }
                else if (relativeMinute >= 10)
                {
                    switch (relativeMinute - 10)
                    {
                        case 9: { strcat(textMinutes, "NINETEEN"); break; }
                        case 8: { strcat(textMinutes, "EIGHTEEN"); break; }
                        case 7: { strcat(textMinutes, "SEVENTEEN"); break; }
                        case 6: { strcat(textMinutes, "SIXTEEN"); break; }
                        case 5: { strcat(textMinutes, "QUARTER "); break; }
                        case 4: { strcat(textMinutes, "FOURTEEN"); break; }
                        case 3: { strcat(textMinutes, "THIRTEEN"); break; }
                        case 2: { strcat(textMinutes, "TWELVE"); break; }
                        case 1: { strcat(textMinutes, "ELEVEN"); break; }
                        case 0: { strcat(textMinutes, "TEN"); break; }
                    }
                }
                else if (relativeMinute >= 0)
                {
                    switch (relativeMinute)
                    {
                        case 9: { strcat(textMinutes, "NINE"); break; }
                        case 8: { strcat(textMinutes, "EIGHT"); break; }
                        case 7: { strcat(textMinutes, "SEVEN"); break; }
                        case 6: { strcat(textMinutes, "SIX"); break; }
                        case 5: { strcat(textMinutes, "FIVE"); break; }
                        case 4: { strcat(textMinutes, "FOUR"); break; }
                        case 3: { strcat(textMinutes, "THREE"); break; }
                        case 2: { strcat(textMinutes, "TWO"); break; }
                        case 1: { strcat(textMinutes, "ONE"); break; }
                    }
                }
 
                if (relativeMinute == 1) strcat(textInBetween, " minute ");
                else if ((relativeMinute > 1) && (relativeMinute != 15)) strcat(textInBetween, " minutes ");
 
                if ((currentMinute > 0) && (currentMinute <= 30)) strcat(textInBetween, "past ");
                else if (relativeMinute > 0) strcat(textInBetween, "to ");
            }
            else if (currentMinute == 30)
            {
                strcat(textMinutes, "HALF");
                strcat(textInBetween, " past ");
            }
 
            int relativeHour = currentHour;
            if (currentMinute > 30) relativeHour += 1;
            if (relativeHour >= 24) relativeHour -= 24;
            switch (relativeHour)
            {
                case 12: { strcat(textHours, "NOON"); break; }
                case 11: case 23: { strcat(textHours, "ELEVEN"); break; }
                case 10: case 22: { strcat(textHours, "TEN"); break; }
                case 9: case 21: { strcat(textHours, "NINE"); break; }
                case 8: case 20: { strcat(textHours, "EIGHT"); break; }
                case 7: case 19: { strcat(textHours, "SEVEN"); break; }
                case 6: case 18: { strcat(textHours, "SIX"); break; }
                case 5: case 17: { strcat(textHours, "FIVE"); break; }
                case 4: case 16: { strcat(textHours, "FOUR"); break; }
                case 3: case 15: { strcat(textHours, "THREE"); break; }
                case 2: case 14: { strcat(textHours, "TWO"); break; }
                case 1: case 13: { strcat(textHours, "ONE"); break; }
                case 0: { strcat(textHours, "MIDNIGHT"); break; }
            }
 
            if ((currentMinute == 0) && (currentHour != 0) && (currentHour != 12)) strcat(textAfter, " o'clock");
 
            sprintf(textClock, "%s%s%s%s", textMinutes, textInBetween, textHours, textAfter);
 
            SIZE size;
            GetTextExtentPoint32(cachedBackground, textClock, strlen(textClock), &size);
            pSettings->desktopClockPlacement.width = size.cx;
            pSettings->desktopClockPlacement.height = size.cy;
 
            if (pSettings->desktopClockPlacement.placement != PLACEMENT_DEFAULT)
            {
                pSettings->PositionFromPlacement(&pSettings->desktopClockPlacement);
                CheckWidgetPlacement(&pSettings->desktopClockPlacement);
                SetRect(&clockRect, pSettings->desktopClockPlacement.x, pSettings->desktopClockPlacement.y, pSettings->desktopClockPlacement.x + pSettings->desktopClockPlacement.width, pSettings->desktopClockPlacement.y + pSettings->desktopClockPlacement.height);
            }
            else // PLACEMENT_DEFAULT
            {
                clockRect.left = DesktopCenterX - (pSettings->desktopClockPlacement.width / 2);
                clockRect.right = clockRect.left + pSettings->desktopClockPlacement.width;
//              if (pSettings->doubleScaleHiDPI) clockRect.top = 32;
                if (pSettings->scalingFactorHiDPI > 1) clockRect.top = 32;
                else clockRect.top = 30;
                clockRect.bottom = clockRect.top + pSettings->desktopClockPlacement.height;
 
                pSettings->desktopClockPlacement.x = clockRect.left; // ...we keep a copy of clockRect.left to be able to restore it later... (see below)
            }
 
            COLORREF colorHighAlpha = RGB(pSettings->desktopClockTransparencyAlpha, pSettings->desktopClockTransparencyAlpha, pSettings->desktopClockTransparencyAlpha);
            COLORREF colorMediumAlpha = RGB(pSettings->desktopClockTransparencyAlpha/2, pSettings->desktopClockTransparencyAlpha/2, pSettings->desktopClockTransparencyAlpha/2);
 
            if (strlen(textMinutes) > 0)
            {
                DrawTextWithEffects(cachedBackground, clockRect, textMinutes, DT_LEFT | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE, colorHighAlpha, false, 0, false, 0, 0, 0);
                GetTextExtentPoint32(cachedBackground, textMinutes, strlen(textMinutes), &size);
                clockRect.left += size.cx;
 
                DrawTextWithEffects(cachedBackground, clockRect, textInBetween, DT_LEFT | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE, colorMediumAlpha, false, 0, false, 0, 0, 0);
                GetTextExtentPoint32(cachedBackground, textInBetween, strlen(textInBetween), &size);
                clockRect.left += size.cx;
            }
 
            DrawTextWithEffects(cachedBackground, clockRect, textHours, DT_LEFT | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE, colorHighAlpha, false, 0, false, 0, 0, 0);
 
            if (strlen(textAfter) > 0)
            {
                GetTextExtentPoint32(cachedBackground, textHours, strlen(textHours), &size);
                clockRect.left += size.cx;
                DrawTextWithEffects(cachedBackground, clockRect, textAfter, DT_LEFT | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE, colorMediumAlpha, false, 0, false, 0, 0, 0);
            }
 
            clockRect.left = pSettings->desktopClockPlacement.x;
 
            DeleteObject(SelectObject(cachedBackground, oldfont));
        }
 
        //====================
 
        else if (!_stricmp(pSettings->desktopClockType, "Binary")) // -> Bit clock
        {
            wchar_t temp;
            int currentDigit;
            int mediumTransparencyAlpha = pSettings->desktopClockTransparencyAlpha / 2;
            int lowTransparencyAlpha = pSettings->desktopClockTransparencyAlpha / 8;
 
//          brush = CreateSolidBrush(0xffffff);
            brush = CreateSolidBrush(pSettings->desktopWidgetColor);
 
            if (pSettings->desktopClockPlacement.placement != PLACEMENT_DEFAULT)
            {
                if (pSettings->doubleScaleHiDPI)
                {
                    pSettings->desktopClockPlacement.width = 396;
                    pSettings->desktopClockPlacement.height = 228;
                    pSettings->PositionFromPlacement(&pSettings->desktopClockPlacement);
                    CheckWidgetPlacement(&pSettings->desktopClockPlacement);
                    SetRect(&r, pSettings->desktopClockPlacement.x, pSettings->desktopClockPlacement.y, pSettings->desktopClockPlacement.x + 96, pSettings->desktopClockPlacement.y + 54);
                }
                else
                {
                    pSettings->desktopClockPlacement.width = 204;
                    pSettings->desktopClockPlacement.height = 120;
                    pSettings->PositionFromPlacement(&pSettings->desktopClockPlacement);
                    CheckWidgetPlacement(&pSettings->desktopClockPlacement);
                    SetRect(&r, pSettings->desktopClockPlacement.x, pSettings->desktopClockPlacement.y, pSettings->desktopClockPlacement.x + 48, pSettings->desktopClockPlacement.y + 27);
                }
            }
            else // PLACEMENT_DEFAULT
            {
                if (pSettings->doubleScaleHiDPI) SetRect(&r, DesktopCenterX-198, 49, DesktopCenterX-102, 103);
                else SetRect(&r, DesktopCenterX-102, 49, DesktopCenterX-54, 76);
            }
 
            for (int x=1; x<=4; x++)
            {
                if (x == 1) temp = CurrentTime[0];
                else if (x == 2) temp = CurrentTime[1];
                else if (x == 3) temp = CurrentTime[3];
                else if (x == 4) temp = CurrentTime[4];
                currentDigit = _wtoi(&temp);
 
                for (int y=1; y<=4; y++)
                {
                    FillRect(cachedBackground, &r, brush);
 
                    if ((x == 1) && ((y == 1) || (y == 2))) AlphaRect(cachedBackground, r, lowTransparencyAlpha); // ...because the first digit can only be 0-2...
                    else
                    {
                        if ((y == 1) && (currentDigit & 8)) AlphaRect(cachedBackground, r, pSettings->desktopClockTransparencyAlpha);
                        else if ((y == 2) && (currentDigit & 4)) AlphaRect(cachedBackground, r, pSettings->desktopClockTransparencyAlpha);
                        else if ((y == 3) && (currentDigit & 2)) AlphaRect(cachedBackground, r, pSettings->desktopClockTransparencyAlpha);
                        else if ((y == 4) && (currentDigit & 1)) AlphaRect(cachedBackground, r, pSettings->desktopClockTransparencyAlpha);
                        else AlphaRect(cachedBackground, r, mediumTransparencyAlpha);
                    }
//                  AlphaApply(cachedBackground, r);
 
                    if (pSettings->doubleScaleHiDPI) OffsetRect(&r, 0, 58);
                    else OffsetRect(&r, 0, 31);
                }
 
                if (pSettings->doubleScaleHiDPI) OffsetRect(&r, 100, -232);
                else OffsetRect(&r, 52, -124);
            }
 
            clockAlphaApplied = true;
 
            DeleteObject(brush);
        }
    }
 
    //====================
 
    // Apply per pixel alpha to the clock/weekday/date as applicable, including support for overlapping...
    // (nb. currently at least with a fixed z-order i.e. weekday-date-clock from the bottom up as per the order drawn above)
    RECT tempRect;
    bool overlapWeekdayDate = (bool)(IntersectRect(&tempRect, &weekdayRect, &dateRect) && !pSettings->desktopWeekdayHidden && !pSettings->desktopDateHidden);
    bool overlapWeekdayDateClock = false;
    if (overlapWeekdayDate)
    {
        UnionRect(&tempRect, &weekdayRect, &dateRect);
        overlapWeekdayDateClock = (bool)(IntersectRect(&tempRect, &tempRect, &clockRect) && !pSettings->desktopClockHidden && !clockAlphaApplied);
    }
    bool overlapDateClock = (bool)(IntersectRect(&tempRect, &dateRect, &clockRect) && !pSettings->desktopDateHidden && !pSettings->desktopClockHidden && !clockAlphaApplied);
    bool overlapWeekdayClock = (bool)(IntersectRect(&tempRect, &weekdayRect, &clockRect) && !pSettings->desktopWeekdayHidden && !pSettings->desktopClockHidden && !clockAlphaApplied);
 
    if (overlapWeekdayDateClock) // -> All three of them overlapping
    {
        UnionRect(&tempRect, &weekdayRect, &dateRect);
        UnionRect(&tempRect, &tempRect, &clockRect);
        AlphaFromRGB(cachedBackground, tempRect, 1, 255, true, pSettings->desktopWidgetColor);
    }
    else if (overlapWeekdayDate)
    {
        UnionRect(&tempRect, &weekdayRect, &dateRect);
        AlphaFromRGB(cachedBackground, tempRect, 1, 255, true, pSettings->desktopWidgetColor);
 
        if (!pSettings->desktopClockHidden && !clockAlphaApplied) AlphaFromRGB(cachedBackground, clockRect, 1, 255, true, pSettings->desktopWidgetColor);
    }
    else if (overlapDateClock)
    {
        UnionRect(&tempRect, &dateRect, &clockRect);
        AlphaFromRGB(cachedBackground, tempRect, 1, 255, true, pSettings->desktopWidgetColor);
 
        if (!pSettings->desktopWeekdayHidden) AlphaFromRGB(cachedBackground, weekdayRect, 1, 255, true, pSettings->desktopWidgetColor);
    }
    else if (overlapWeekdayClock)
    {
        UnionRect(&tempRect, &weekdayRect, &clockRect);
        AlphaFromRGB(cachedBackground, tempRect, 1, 255, true, pSettings->desktopWidgetColor);
 
        if (!pSettings->desktopDateHidden) AlphaFromRGB(cachedBackground, dateRect, 1, 255, true, pSettings->desktopWidgetColor);
    }
    else // -> None of them overlapping
    {
//      if (!pSettings->desktopGreetingHidden) AlphaFromRGB(cachedBackground, greetingRect, 1, 255, true, pSettings->desktopWidgetColor);
        if (!pSettings->desktopWeekdayHidden) AlphaFromRGB(cachedBackground, weekdayRect, 1, 255, true, pSettings->desktopWidgetColor);
        if (!pSettings->desktopDateHidden) AlphaFromRGB(cachedBackground, dateRect, 1, 255, true, pSettings->desktopWidgetColor);
        if (!pSettings->desktopClockHidden && !clockAlphaApplied) AlphaFromRGB(cachedBackground, clockRect, 1, 255, true, pSettings->desktopWidgetColor);
    }
 
    if (!pSettings->desktopGreetingHidden) AlphaFromRGB(cachedBackground, greetingRect, 1, 255, true, pSettings->desktopWidgetColor); // TEMPORARY UNTIL OVERLAPPING IS IMPLEMENTED
 
    //====================
 
    SetRect(&r, 0, 0, DesktopWidth, DesktopHeight);
    AlphaApply(cachedBackground, r);
 
    //====================
 
    if (bufbmp) DeleteObject(bufbmp);
 
    POINT pt;
    pt.x = DesktopX, pt.y = DesktopY;
    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 = { DesktopWidth, DesktopHeight };
    BOOL result = UpdateLayeredWindow(hDesktopWnd, NULL, &pt, &windowSize, cachedBackground, &ptSrc, 0, &bf, ULW_ALPHA);
/*
    if (!cachedBackground) SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)"xoblite -> Desktop -> Invalid cachedBackground!");
 
    if (result == 0)
    {
        int error = GetLastError();
        char msg[255];
        sprintf(msg, "xoblite -> Desktop -> UpdateLayeredWindow failed! [error code %d]", error);
        SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_ERROR_MESSAGE, (LPARAM)msg);
    }
    else
*/
    {
        // Finally, we move the desktop window to the bottom of the regular z-order... (i.e. just above the Windows desktop in our case)
        SetWindowPos(hDesktopWnd, GetDesktopWindow(), 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE | SWP_NOSENDCHANGING | SWP_NOOWNERZORDER);
    }
}

GetDimensions()

void Desktop::GetDimensions

(

)

{
/*
    if (!pSettings->explorerHidden)
    {
        RECT workArea;
        SystemParametersInfo(SPI_GETWORKAREA, 0, (PVOID)&workArea, SPIF_SENDCHANGE);
        DesktopWidth = workArea.right - workArea.left;
        DesktopHeight = workArea.bottom - workArea.top;
        DesktopX = workArea.left;
        DesktopY = workArea.top;
    }
    else
*/
    {
        DesktopWidth = GetSystemMetrics(SM_CXVIRTUALSCREEN);
        DesktopHeight = GetSystemMetrics(SM_CYVIRTUALSCREEN);
        DesktopX = GetSystemMetrics(SM_XVIRTUALSCREEN);
        DesktopY = GetSystemMetrics(SM_YVIRTUALSCREEN);
    }
 
    DesktopCenterX = DesktopX + (DesktopWidth / 2);
    DesktopCenterY = DesktopY + (DesktopHeight / 2);
}

LoadWallpaper()

void Desktop::LoadWallpaper

(

LPSTR

imagePath

)

{
    if (!FileExists(imagePath)) return;
 
    if (wallpaper.bitmap != NULL) DeleteObject(wallpaper.bitmap);
 
    // Load the image using GDI+ to add support for JPG, PNG etc...
    // (nb. regular GDI LoadImage() only supports BMP images. GDI+ startup/shutdown is performed "globally" in Blackbox.cpp.)
    wchar_t imagePathWC[MAX_PATH];
    MultiByteToWideChar(CP_ACP, 0, imagePath, strlen(imagePath) + 1, imagePathWC, MAX_PATH);
    Bitmap* bitmap = new Bitmap(imagePathWC, FALSE);
 
    // ...fetch some of its properties...
    wallpaper.width = bitmap->GetWidth();
    wallpaper.height = bitmap->GetHeight();
    PixelFormat pf = bitmap->GetPixelFormat();
    if ((pf == PixelFormat32bppARGB) || (pf == PixelFormat32bppPARGB) || (pf == PixelFormat64bppARGB) || (pf == PixelFormat64bppPARGB)) wallpaper.argb = true;
    else wallpaper.argb = false;
 
    // ...and finally create our target GDI HBITMAP from the loaded GDI+ Bitmap...
    bitmap->GetHBITMAP(0, &wallpaper.bitmap);
 
    delete bitmap;
}

DrawWallpaper()

void Desktop::DrawWallpaper

(

HDC

hdc

)

{
    if (wallpaper.bitmap == NULL) return;
 
    HDC buf = CreateCompatibleDC(hdc);
    DeleteObject(SelectObject(buf, wallpaper.bitmap));
    SetStretchBltMode(hdc, HALFTONE);
    StretchBlt(hdc, 0, 0, DesktopWidth, DesktopHeight, buf, 0, 0, wallpaper.width, wallpaper.height, SRCCOPY);
 
    DeleteDC(buf);
}

CheckWidgetPlacement()

void Desktop::CheckWidgetPlacement

(

Placement *

widget

)

{
    // Adjust from screen relative to desktop relative coordinates...
    // (cf. e.g. Explorer taskbar along left or top screen edges)
    widget->x -= DesktopX;
    widget->y -= DesktopY;
 
    // Adjust for the semi-transparent desktop border... (if visible)
    if (pSettings->desktopBorderHidden) return;
 
    if ((widget->placement == PLACEMENT_TOP_LEFT)
     || (widget->placement == PLACEMENT_CENTER_LEFT)
     || (widget->placement == PLACEMENT_BOTTOM_LEFT))
    {
        widget->x += 20;
    }
 
    if ((widget->placement == PLACEMENT_TOP_RIGHT)
     || (widget->placement == PLACEMENT_CENTER_RIGHT)
     || (widget->placement == PLACEMENT_BOTTOM_RIGHT))
    {
        widget->x -= 20;
    }
 
    if ((widget->placement == PLACEMENT_TOP_LEFT)
     || (widget->placement == PLACEMENT_TOP_RIGHT))
    {
        widget->y += 20;
    }
 
    if ((widget->placement == PLACEMENT_TOP_CENTER) && !pSettings->desktopWorkspaceIndicatorHidden)
    {
        // Stay clear of the workspace indicators if they're visible...
        widget->y += 39;
    }
 
    if ((widget->placement == PLACEMENT_BOTTOM_LEFT)
     || (widget->placement == PLACEMENT_BOTTOM_CENTER)
     || (widget->placement == PLACEMENT_BOTTOM_RIGHT))
    {
        widget->y -= 20;
    }
}

MouseAndDropHandler()

LRESULT Desktop::MouseAndDropHandler	(	HWND	hWnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam )

{
    switch (uMsg)
    {
        //====================
 
        case WM_LBUTTONUP:
        {
            if (pMenuCommon)
            {
//              if (GetAsyncKeyState(VK_MENU) & 0x8000)
//              {
//                  SendMessage(GetBBWnd(), BB_MENU, 0, 0); // Alt+LeftClick -> Main menu
//                  PlaySoundFX(SFX_MENU_SHOW);
//              }
//              else
                {
                    // First we set focus to the toolbar to prevent the focus from going back to the previous task after the menu is closed...
//                  if (pSettings->followActive) SetForegroundWindow(pToolbar->hToolbarWnd);
//                  if (pSettings->followActive) SetForegroundWindow(hDesktopWnd);
                    // Move the desktop window to the bottom of the application z-order... (i.e. just above the Windows desktop in our case)
//                  SetWindowPos(hDesktopWnd, GetDesktopWindow(), 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE | SWP_NOSENDCHANGING | SWP_NOOWNERZORDER);
                    SetWindowPos(hDesktopWnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE | SWP_NOSENDCHANGING | SWP_NOOWNERZORDER);
 
                    if (pMenuCommon) pMenuCommon->Hide();
                }
            }
        }
        break;
 
        case WM_LBUTTONDOWN: { } break;
 
            //====================
 
        case WM_RBUTTONUP:
        {
            // Has the user defined an Right Click command override?
            if (strlen(pSettings->desktopRClickOverride) > 0)
            {
                if (GetAsyncKeyState(VK_MENU) & 0x8000)
                {
                    SendMessage(GetBBWnd(), BB_MENU, 0, 0); // Alt+Right Click -> Main menu
                    PlaySoundFX(SFX_MENU_SHOW);
                }
                else BBSmartExecute(pSettings->desktopRClickOverride); // Right Click without modifiers -> User defined command override
            }
 
            // We otherwise provide a couple of Right Click + key modifier actions for people with only a *2* button mouse...
            else if (GetAsyncKeyState(VK_MENU) & 0x8000)
            {
                if ((GetAsyncKeyState(VK_CONTROL) & 0x8000) && (GetAsyncKeyState(VK_SHIFT) & 0x8000))
                {
                    SendMessage(GetBBWnd(), BB_MENU, 2, 0); // Ctrl+Alt+Shift+RightClick -> Configuration menu
                    PlaySoundFX(SFX_MENU_SHOW);
                }
                else if (GetAsyncKeyState(VK_CONTROL) & 0x8000) BBSmartExecute("@xoblite Random Wallpaper"); // Ctrl+Alt+RightClick -> Apply random wallpaper (note: matching Modifier+MidClick)
                else if (GetAsyncKeyState(VK_SHIFT) & 0x8000) BBSmartExecute("@xoblite Random Style"); // Shift+Alt+RightClick -> Apply random style (note: matching Modifier+MidClick)
                else
                {
                    SendMessage(GetBBWnd(), BB_MENU, 5, 0); // Alt+RightClick -> Styles menu
                    PlaySoundFX(SFX_MENU_SHOW);
                }
            }
            else if (GetAsyncKeyState(VK_CONTROL) & 0x8000)
            {
                SendMessage(GetBBWnd(), BB_MENU, 6, 0); // Ctrl+RightClick -> Themes menu
                PlaySoundFX(SFX_MENU_SHOW);
            }
            else if (GetAsyncKeyState(VK_SHIFT) & 0x8000)
            {
                SendMessage(GetBBWnd(), BB_MENU, 1, 0); // Shift+RightClick -> Workspaces menu
                PlaySoundFX(SFX_MENU_SHOW);
//              BBSmartExecute("@xoblite Random Wallpaper"); // Shift+RightClick -> Apply random wallpaper
            }
            else
            {
                SendMessage(GetBBWnd(), BB_MENU, 0, 0); // RightClick without modifiers -> Main menu
                PlaySoundFX(SFX_MENU_SHOW);
            }
        }
        break;
 
        case WM_RBUTTONDOWN: { } break;
 
            //====================
 
        case WM_MBUTTONUP:
        {
            // Has the user defined an Mid Click command override?
            if (strlen(pSettings->desktopMClickOverride) > 0)
            {
                if (GetAsyncKeyState(VK_MENU) & 0x8000)
                {
                    SendMessage(GetBBWnd(), BB_MENU, 5, 0); // Alt+Mid Click -> Styles menu
                    PlaySoundFX(SFX_MENU_SHOW);
                }
                else BBSmartExecute(pSettings->desktopMClickOverride); // Mid Click without modifiers -> User defined command override
            }
 
            // We otherwise provide a couple of Mid Click + key modifier actions for people with only a *3* button mouse...
            else if (GetAsyncKeyState(VK_MENU) & 0x8000)
            {
                if (GetAsyncKeyState(VK_CONTROL) & 0x8000) BBSmartExecute("@xoblite Random Wallpaper"); // Ctrl+Alt+MidClick -> Apply random wallpaper (note: matching Modifier+RightClick)
                else if (GetAsyncKeyState(VK_SHIFT) & 0x8000) BBSmartExecute("@xoblite Random Style"); // Shift+Alt+MidClick -> Apply random style (note: matching Modifier+RightClick)
                else
                {
                    SendMessage(GetBBWnd(), BB_MENU, 6, 0); // Alt+MidClick -> Themes menu
                    PlaySoundFX(SFX_MENU_SHOW);
                }
            }
            else
            {
                if (GetAsyncKeyState(VK_CONTROL) & 0x8000) SendMessage(GetBBWnd(), BB_MENU, 1, 0); // Ctrl+MidClick -> Workspaces menu
                else if (GetAsyncKeyState(VK_SHIFT) & 0x8000) SendMessage(GetBBWnd(), BB_MENU, 2, 0); // Shift+MidClick -> Configuration menu
                else SendMessage(GetBBWnd(), BB_MENU, 5, 0); // MidClick without modifiers -> Styles menu
                PlaySoundFX(SFX_MENU_SHOW);
            }
        }
        break;
 
        case WM_MBUTTONDOWN: { } break;
 
        //====================
 
        case WM_XBUTTONDOWN:
        {
            if (HIWORD(wParam) == XBUTTON1)
            {
                if (strlen(pSettings->desktopX1ClickOverride) > 0) // Has the user defined an X1 click command override?
                {
                    if (GetAsyncKeyState(VK_MENU) & 0x8000)
                    {
                        SendMessage(GetBBWnd(), BB_MENU, 6, 0); // Alt+X1 Click -> Themes menu
                        PlaySoundFX(SFX_MENU_SHOW);
                    }
                    else BBSmartExecute(pSettings->desktopX1ClickOverride); // X1 Click without modifiers -> User defined command override
                }
                else if (GetAsyncKeyState(VK_MENU) & 0x8000) BBSmartExecute("@xoblite Random Wallpaper"); // Alt+X1 Click -> Apply random wallpaper
                else
                {
                    // if (GetAsyncKeyState(VK_CONTROL) & 0x8000) BBSmartExecute("@xoblite About"); // Placeholder, possibly for use defined command?
                    if (GetAsyncKeyState(VK_SHIFT) & 0x8000) SendMessage(GetBBWnd(), BB_MENU, 2, 0); // Shift+X1 Click -> Configuration menu
                    else SendMessage(GetBBWnd(), BB_MENU, 6, 0); // X1 Click without modifiers -> Themes menu
                    PlaySoundFX(SFX_MENU_SHOW);
                }
            }
            else if (HIWORD(wParam) == XBUTTON2)
            {
                if (strlen(pSettings->desktopX2ClickOverride) > 0) // Has the user defined an X2 click command override?
                {
                    if (GetAsyncKeyState(VK_MENU) & 0x8000)
                    {
                        SendMessage(GetBBWnd(), BB_MENU, 1, 0); // Alt+X2 Click -> Workspaces menu
                        PlaySoundFX(SFX_MENU_SHOW);
                    }
                    else BBSmartExecute(pSettings->desktopX2ClickOverride); // X2 Click without modifiers -> User defined command override
                }
                else if (GetAsyncKeyState(VK_MENU) & 0x8000) BBSmartExecute("@xoblite Random Style"); // Alt+X2 Click -> Apply random style
                else
                {
                    // if (GetAsyncKeyState(VK_CONTROL) & 0x8000) BBSmartExecute("@xoblite About"); // Placeholder, possibly for use defined command?
                    if (GetAsyncKeyState(VK_SHIFT) & 0x8000) SendMessage(GetBBWnd(), BB_MENU, 2, 0); // Shift+X2 Click -> Configuration menu
                    else SendMessage(GetBBWnd(), BB_MENU, 1, 0); // X2 Click without modifiers -> Workspaces menu
                    PlaySoundFX(SFX_MENU_SHOW);
                }
            }
        }
        break;
 
        case WM_XBUTTONUP: { } break;
 
        //====================
 
        case WM_MOUSEWHEEL:
        {
            if (pSettings->mousewheelChanging)
            {
                if (GET_WHEEL_DELTA_WPARAM(wParam) < 0) pWorkspaces->NextWorkspace(); // Mousewheel down -> Move to the next workspace...
                else pWorkspaces->PreviousWorkspace(); // Mousewheel up -> Move to the previous workspace...
            }
        }
        break;
 
        // case WM_MOUSEHWHEEL: { } break;
 
        //====================
 
        case WM_DROPFILES:
        {
            return ParseDropFiles(hWnd, wParam);
        }
        break;
 
        //====================
 
        default:
            return DefWindowProc(hWnd, uMsg, wParam, lParam);
 
        //====================
    }
    return 0;
}

GetClockText()

bool Desktop::GetClockText

(

bool

forceUpdate

)

{
    time(&systemTime);
    localtime_s(&localTime, &systemTime);
    currentHour = localTime.tm_hour;
    currentMinute = localTime.tm_min;
 
    // Only update the desktop clock if the current minute has changed...
    if ((currentMinute != displayedMinute) || forceUpdate)
    {
        // Get the time string for the regular clock...
        if (IsInString(pSettings->toolbarClockFormat, "%I")) wcsftime(CurrentTime, sizeof(CurrentTime), L"%I:%M %p", &localTime); // 12-hour format including AM/PM indicator
        else wcsftime(CurrentTime, sizeof(CurrentTime), L"%H:%M", &localTime); // 24-hour format
        // Remember minute shown in display, now wait until minute changes before updating again...
        displayedMinute = currentMinute;
 
        // Get the weekday string...
        wcsftime(CurrentWeekday, sizeof(CurrentWeekday), L"%A", &localTime); // Day of the week as per the current locale (e.g. "Saturday")
 
        // Get the configurable date string... (nb. we need to convert the format string from ANSI to Unicode first)
        wchar_t desktopDateFormatInUnicode[MAX_LINE_LENGTH];
        MultiByteToWideChar(CP_UTF8, 0, pSettings->desktopDateFormat, strlen(pSettings->desktopDateFormat)+1, desktopDateFormatInUnicode, MAX_LINE_LENGTH);
        wcsftime(CurrentDate, sizeof(CurrentDate), desktopDateFormatInUnicode, &localTime); // Configurable date string (cf. the toolbar clock's format string and related options)
 
        if (!forceUpdate)
        {
            if (currentMinute == 0) PlaySoundFX(SFX_CLOCK_HOUR);
            else if (currentMinute == 30) PlaySoundFX(SFX_CLOCK_HALFHOUR);
        }
 
        return true;
    }
    else return false;
}

GetGreetingText()

bool Desktop::GetGreetingText

(

bool

forceUpdate

)

{
    time(&systemTime);
    localtime_s(&localTime, &systemTime);
 
    if (localTime.tm_hour < 6) wcscpy_s(CurrentGreeting, 32, L"Good night");            // 00-06 -> "Good night"
    else if (localTime.tm_hour < 12) wcscpy_s(CurrentGreeting, 32, L"Good morning");    // 06-12 -> "Good morning"
    else if (localTime.tm_hour < 18) wcscpy_s(CurrentGreeting, 32, L"Good afternoon");  // 12-18 -> "Good afternoon"
    else wcscpy_s(CurrentGreeting, 32, L"Good evening");                             // 18-24 -> "Good evening"
 
    return true;
}

ShadeWindow()

void Desktop::ShadeWindow

(

)

{
    HWND currentWnd = pTaskbar->GetActiveWindow();
    BOOL isMaximized = IsZoomed(currentWnd);
 
    RECT r;
    GetWindowRect(currentWnd, &r);
    int titleBarHeight = GetSystemMetrics(SM_CYMIN);
    bool isUnshaded = (r.bottom-r.top > titleBarHeight);
 
//  i = IsFlaggedShaded(currentWnd);
    int i = (int)(GetProp(currentWnd, "BBNormalHeight") != NULL);
 
    if (isMaximized)
    {
        if (isUnshaded) WinShade(currentWnd, -1, isMaximized);
        else WinUnshade(currentWnd, -1, isMaximized);
    }
    else
    {
        if (i != -1) // Was the window found in our list?
        {
            if (isUnshaded) // Shade the window...
            {
                RemoveProp(currentWnd, "BBNormalHeight");
                WinShade(currentWnd, -1, isMaximized);
            }
            else // Unshade the window...
            {
                WinUnshade(currentWnd, i, isMaximized);
            }
        }
        else WinShade(currentWnd, i, isMaximized);
    }
}

WinShade()

void Desktop::WinShade	(	HWND	hwnd,
		int	listIndex,
		bool	maximized )

{
    if (listIndex != -1) return;
 
    RECT r;
    SetForegroundWindow(hwnd);
    GetWindowRect(hwnd, &r);
 
    // Remember the window's original height...
    if (!maximized) SetProp(hwnd, "BBNormalHeight", (HANDLE)(r.bottom - r.top));
    // ...and then shrink it vertically to only show its titlebar...
    SetWindowPos(hwnd, HWND_TOP, r.left, r.top, r.right-r.left, GetSystemMetrics(SM_CYMIN), SWP_NOOWNERZORDER | SWP_NOSENDCHANGING);
}

WinUnshade()

void Desktop::WinUnshade	(	HWND	hwnd,
		int	listIndex,
		bool	maximized )

{
    if (listIndex == -1 && !maximized) return;
 
    RECT r;
    int height;
    SetForegroundWindow(hwnd);
 
    if (maximized)
    {
        // This is a maximized window, so its restored height should be the height of the screen's work area...
        RECT workArea;
        SystemParametersInfo(SPI_GETWORKAREA, 0, (PVOID)&workArea, SPIF_SENDCHANGE);
        height = workArea.bottom - workArea.top;
    }
    else
    {
        // This is a non-maximized window, so we restore it to the original height previously saved...
        height = (long)GetProp(hwnd, "BBNormalHeight");
        RemoveProp(hwnd, "BBNormalHeight");
    }
 
    if (height == 0) return;
 
    GetWindowRect(hwnd, &r);
    MoveWindow(hwnd, r.left, r.top, r.right-r.left, height, true);
    InvalidateRect(hwnd, NULL, false);
}

GrowWindowHeight()

void Desktop::GrowWindowHeight

(

)

{
    HWND currentWnd = pTaskbar->GetActiveWindow();
    RECT r, workArea;
    GetWindowRect(currentWnd, &r);
    SystemParametersInfo(SPI_GETWORKAREA, 0, (PVOID)&workArea, SPIF_SENDCHANGE);
    MoveWindow(currentWnd, r.left, 0, r.right-r.left, workArea.bottom-workArea.top, true);
    InvalidateRect(currentWnd, NULL, false);
    SetForegroundWindow(currentWnd);
}

GrowWindowWidth()

void Desktop::GrowWindowWidth

(

)

{
    HWND currentWnd = pTaskbar->GetActiveWindow();
    RECT r, workArea;
    GetWindowRect(currentWnd, &r);
    SystemParametersInfo(SPI_GETWORKAREA, 0, (PVOID)&workArea, SPIF_SENDCHANGE);
    MoveWindow(currentWnd, 0, r.top, workArea.right-workArea.left, r.bottom-r.top, true);
    GetWindowRect(currentWnd, &r);
    SetForegroundWindow(currentWnd);
}

LowerWindow()

void Desktop::LowerWindow

(

)

{
    HWND currentWnd = pTaskbar->GetActiveWindow();
 
    // First we fetch the bottom window...
    HWND bottomWnd = GetWindow(hBlackboxWnd, GW_HWNDLAST);
    HWND hProgManWnd = FindWindow("Progman", "Program Manager");
    if (bottomWnd == hProgManWnd) bottomWnd = GetWindow(bottomWnd, GW_HWNDPREV);
 
    while (!IsWindowVisible(bottomWnd) || IsIconic(bottomWnd) || (GetWindowTextLength(bottomWnd) == 0))
    {
        bottomWnd = GetWindow(bottomWnd, GW_HWNDPREV);
        if (bottomWnd == hProgManWnd) bottomWnd = GetWindow(bottomWnd, GW_HWNDPREV);
    }
 
    // ...and then we put the current window behind that...
    if (IsWindow(currentWnd) && IsWindow(bottomWnd))
    {
        SetWindowPos(currentWnd, bottomWnd, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE | SWP_NOSENDCHANGING);
    }
}

RaiseWindow()

void Desktop::RaiseWindow

(

)

{
    HWND currentWnd = pTaskbar->GetActiveWindow();
    // Raise the current window to the top...
    SetWindowPos(currentWnd, HWND_TOP, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE | SWP_NOSENDCHANGING);
}

Friends And Related Symbol Documentation

DesktopWndProc

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

friend

{
 
    switch (message)
    {
        //====================
 
        case BB_RECONFIGURE:
        case WM_DISPLAYCHANGE:
        {
            // Update the desktop's dimensions if the screen resolution changes...
            pDesktop->GetClockText(true);
            pDesktop->GetGreetingText(true);
            pDesktop->UpdateDesktopWindow();
 
            if (message == BB_RECONFIGURE) PlaySoundFX(SFX_RECONFIGURE);
            else if (message == WM_DISPLAYCHANGE)
            {
                int tempMonitors = GetSystemMetrics(SM_CMONITORS);
                if (pDesktop->numberOfDisplayMonitors != tempMonitors)
                {
                    char msg[255];
                    if (tempMonitors > pDesktop->numberOfDisplayMonitors) strcpy(msg, "System -> Display monitor attached.");
                    else if (tempMonitors < pDesktop->numberOfDisplayMonitors) strcpy(msg, "System -> Display monitor removed.");
                    SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_REGULAR_MESSAGE, (LPARAM)msg);
 
                    pDesktop->numberOfDisplayMonitors = tempMonitors;
                }
            }
            break;
        }
 
        case WM_SETTINGCHANGE:
        {
            if (wParam == SPI_SETWORKAREA)
            {
                // Update the desktop's dimensions and position if the work area changes...
                // (e.g. if the Explorer taskbar is moved to another screen edge)
                pDesktop->UpdateDesktopWindow();
 
                // ...and notify plugins that the desktop work area has changed...
                SendMessage(GetBBWnd(), BB_REDRAWGUI, BBRG_DESKTOP, 0);
            }
            return 0;
        }
/*
        case WM_WINDOWPOSCHANGED:
        {
            // Move the desktop window back to the bottom of the z-order if its place in it changes...
//          SetWindowPos(pDesktop->hDesktopWnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOREDRAW | SWP_NOACTIVATE | SWP_NOSENDCHANGING);
//          SetWindowPos(pDesktop->hDesktopWnd, GetDesktopWindow(), 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOREDRAW | SWP_NOACTIVATE | SWP_NOSENDCHANGING);
//          SetWindowPos(pDesktop->hDesktopWnd, GetDesktopWindow(), pDesktop->DesktopX, pDesktop->DesktopX, pDesktop->DesktopWidth, pDesktop->DesktopHeight, SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOSENDCHANGING);
//          SetWindowPos(pDesktop->hDesktopWnd, GetDesktopWindow(), 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE | SWP_NOREDRAW | SWP_NOSENDCHANGING | SWP_NOOWNERZORDER);
            if (pSettings->debugLogging) SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_REGULAR_MESSAGE, (LPARAM)"WM_WINDOWPOSCHANGED");
//          if (pSettings->debugLogging) Log("Desktop: WM_WINDOWPOSCHANGED", "");
            return 0;
        }
*/
/*
        case WM_GETMINMAXINFO:
        {
            // Not sure if this is really needed since we don't allow the desktop window to be moved/resized anyway, but just in case... ;)
            MINMAXINFO* mmi = (MINMAXINFO*)lParam;
            mmi->ptMaxPosition.x = pDesktop->DesktopX;
            mmi->ptMaxPosition.y = pDesktop->DesktopY;
            mmi->ptMaxSize.x = pDesktop->DesktopWidth;
            mmi->ptMaxSize.y = pDesktop->DesktopHeight;
            return 0;
        }
*/
        //====================
 
        case WM_TIMER:
        {
            // Is it time to update the desktop clock/weekday/date?
            if (!pSettings->desktopClockHidden || !pSettings->desktopWeekdayHidden || !pSettings->desktopDateHidden || !pSettings->desktopGreetingHidden)
            {
                if (pDesktop->GetClockText(false))
                {
                    // Clock timestamp has changed; update the other widgets too, then the Desktop...
                    pDesktop->GetGreetingText(true);
                    pDesktop->UpdateDesktopWindow();
                }
            }
            return 0;
        }
 
        //====================
 
        case WM_CLOSE:
            return 0;
 
        //====================
 
        case WM_MOUSEACTIVATE:
            return MA_NOACTIVATE;
/*
        case WM_ACTIVATE:
        {
            if (LOWORD(wParam) == WA_ACTIVE || LOWORD(wParam) == WA_CLICKACTIVE) SetActiveWindow(hwnd);
            return 0;
        }
        break;
*/
        //====================
 
        case WM_NCHITTEST:
            return HTCLIENT;
 
        case WM_LBUTTONDOWN:
        case WM_LBUTTONUP:
//      case WM_LBUTTONDBLCLK:
        case WM_RBUTTONDOWN:
        case WM_RBUTTONUP:
        case WM_MBUTTONDOWN:
        case WM_MBUTTONUP:
        case WM_XBUTTONDOWN:
        case WM_XBUTTONUP:
        case WM_MOUSEWHEEL:
        case WM_MOUSEHWHEEL:
        case WM_DROPFILES:
        {
            // First we set focus to the main Blackbox window, in order to prevent the
            // focus from going back to the previous task after e.g. the menu is closed...
            SetForegroundWindow(GetBBWnd());
            pDesktop->MouseAndDropHandler(pDesktop->hDesktopWnd, message, wParam, lParam);
            return 0;
        }
        break;
 
        //====================
 
        case BB_WINDOWSHADE:
            pDesktop->ShadeWindow();
            break;
        case BB_WINDOWGROWHEIGHT:
            pDesktop->GrowWindowHeight();
            break;
        case BB_WINDOWGROWWIDTH:
            pDesktop->GrowWindowWidth();
            break;
        case BB_WINDOWLOWER:
            pDesktop->LowerWindow();
            break;
        case BB_WINDOWRAISE:
            pDesktop->RaiseWindow();
            break;
 
        //====================
 
        default:
            return DefWindowProc(hwnd, message, wParam, lParam);
 
        //====================
    }
 
    return 0;
}

Member Data Documentation

hDesktopInstance

HINSTANCE Desktop::hDesktopInstance

hBlackboxWnd

HWND Desktop::hBlackboxWnd

hDesktopWnd

HWND Desktop::hDesktopWnd

cachedBackground

HDC Desktop::cachedBackground

DesktopX

int Desktop::DesktopX

DesktopY

int Desktop::DesktopY

DesktopWidth

int Desktop::DesktopWidth

DesktopHeight

int Desktop::DesktopHeight

DesktopCenterX

int Desktop::DesktopCenterX

DesktopCenterY

int Desktop::DesktopCenterY

CurrentTime

wchar_t Desktop::CurrentTime[32]

CurrentWeekday

wchar_t Desktop::CurrentWeekday[32]

CurrentDate

wchar_t Desktop::CurrentDate[MAX_LINE_LENGTH]

CurrentGreeting

wchar_t Desktop::CurrentGreeting[32]

displayedMinute

int Desktop::displayedMinute

systemTime

time_t Desktop::systemTime

localTime

struct tm Desktop::localTime

currentHour

int Desktop::currentHour

currentMinute

int Desktop::currentMinute

clockRect

RECT Desktop::clockRect

weekdayRect

RECT Desktop::weekdayRect

dateRect

RECT Desktop::dateRect

greetingRect

RECT Desktop::greetingRect

numberOfDisplayMonitors

int Desktop::numberOfDisplayMonitors

wallpaper

WallpaperStruct Desktop::wallpaper