Settings Class Reference

#include <Settings.h>

Classes
struct	Statistics

Public Member Functions
	Settings ()
	~Settings ()
void	InitStyleItems ()
void	InitStyleItem (StyleItem *styleItem)
void	DestroyStyleItems ()
void	DestroyStyleItem (StyleItem *styleItem)
LPSTR	CreateFileCache (LPSTR path)
void	DestroyFileCache (LPSTR cachedFilePtr)
void	ReadConfiguration ()
void	WriteDefaultRCSettings ()
void	WriteDefaultMenu ()
void	ReadStyle ()
bool	ReadStyleElement (LPSTR styleBuffer, StyleItem *styleItem, LPSTR paramString, bool readFont)
void	DeriveTaskbarStyle ()
COLORREF	CreateShadowColor (StyleItem *styleItem, COLORREF color, COLORREF colorTo, COLORREF textColor)
COLORREF	InvertColor (COLORREF color)
COLORREF	MixColors (COLORREF colorA, COLORREF colorB)
void	GetShellFolders ()
bool	GetBool (LPCSTR fp, LPSTR buffer, LPCSTR szString, bool szDefault)
int	GetInt (LPCSTR fp, LPSTR buffer, LPCSTR szString, int szDefault)
LPSTR	GetString (LPCSTR fp, LPSTR buffer, LPCSTR szString, LPSTR szDefault)
COLORREF	GetColor (LPCSTR fp, LPSTR buffer, LPCSTR szString, LPCSTR szDefault, COLORREF szDefaultRef, bool useDefaultRef)
LPSTR	GetValueFromCache (LPSTR cachedFilePtr, LPCSTR szString)
bool	CheckForComment (LPSTR cachedFilePtr, LPSTR ptr)
void	UpdateAppearanceString (StyleItem *styleItem)
LPSTR	GetAlignmentAsString (StyleItem *styleItem)
void	ParsePlacement (LPSTR inputString, Placement *outputPlacement)
void	PositionFromPlacement (Placement *inputPlacement)
void	WritePlacement (Placement *inputPlacement)
void	WriteStyle ()
void	WriteStyleElement (HANDLE file, StyleItem *styleItem)

Public Attributes
char	menuFile [MAX_LINE_LENGTH]
bool	menuSeparators
bool	menuRoundedCorners
BYTE	menuTransparencyAlpha
BYTE	menuTitleTransparencyAlpha
BYTE	menuFrameTransparencyAlpha
BYTE	menuGripTransparencyAlpha
BYTE	menuActiveTransparencyAlpha
int	submenuGap
int	submenuDelay
bool	toolbarHidden
Placement	ToolbarPlacement
char	toolbarPlacementString [MAX_LINE_LENGTH]
bool	toolbarVertical
int	toolbarHorizontalWidth
int	toolbarVerticalWidth
bool	toolbarSnapToEdges
BYTE	toolbarTransparencyAlpha
BYTE	toolbarLabelTransparencyAlpha
BYTE	toolbarWindowLabelTransparencyAlpha
BYTE	toolbarClockTransparencyAlpha
BYTE	toolbarButtonTransparencyAlpha
bool	toolbarRoundedCorners
bool	toolbarOnTop
char	toolbarClockFormat [MAX_LINE_LENGTH]
bool	toolbarLabelHidden
bool	toolbarDownUpButtonsHidden
bool	toolbarLeftRightButtonsHidden
bool	toolbarClockHidden
bool	toolbarAllowAsymmetry
char	toolbarDownButtonOverride [MAX_LINE_LENGTH]
char	toolbarUpButtonOverride [MAX_LINE_LENGTH]
char	toolbarLeftButtonOverride [MAX_LINE_LENGTH]
char	toolbarRightButtonOverride [MAX_LINE_LENGTH]
int	taskbarMode
int	taskbarMaxItems
int	taskbarSorting
bool	taskbarShowTaskWorkspace
bool	taskbarCurrentOnly
bool	taskbarFlashing
unsigned int	taskbarSaturationValue
unsigned int	taskbarHueIntensity
bool	taskbarActiveSatHue
BYTE	taskbarActiveTransparencyAlpha
bool	taskbarActiveLivePreview
bool	taskbarInactiveBackground
bool	taskbarTooltips
bool	dockHidden
Placement	DockPlacement
char	dockPlacementString [MAX_LINE_LENGTH]
char	dockDirection [MAX_LINE_LENGTH]
bool	dockVertical
bool	dockPuzzlePositioning
bool	dockOnTop
bool	dockSnapToEdges
BYTE	dockTransparencyAlpha
bool	consoleHidden
Placement	ConsolePlacement
bool	consoleMaximized
int	consoleMaximizedWidth
int	consoleMaximizedMessages
int	consoleRestoredWidth
int	consoleRestoredMessages
BYTE	consoleTransparencyAlpha
bool	consoleDesktopMode
bool	consoleRoundedCorners
int	consolePadding
bool	desktopClockHidden
char	desktopClockType [MAX_LINE_LENGTH]
Placement	desktopClockPlacement
BYTE	desktopClockTransparencyAlpha
bool	desktopClockFontDefined
char	desktopClockFont [128]
int	desktopClockFontHeight
int	desktopClockFontWeight
bool	desktopWeekdayHidden
Placement	desktopWeekdayPlacement
BYTE	desktopWeekdayTransparencyAlpha
bool	desktopWeekdayFontDefined
char	desktopWeekdayFont [128]
int	desktopWeekdayFontHeight
int	desktopWeekdayFontWeight
bool	desktopDateHidden
char	desktopDateFormat [MAX_LINE_LENGTH]
Placement	desktopDatePlacement
BYTE	desktopDateTransparencyAlpha
bool	desktopDateFontDefined
char	desktopDateFont [128]
int	desktopDateFontHeight
int	desktopDateFontWeight
bool	desktopGreetingHidden
Placement	desktopGreetingPlacement
BYTE	desktopGreetingTransparencyAlpha
bool	desktopGreetingFontDefined
char	desktopGreetingFont [128]
int	desktopGreetingFontHeight
int	desktopGreetingFontWeight
bool	desktopWorkspaceIndicatorHidden
bool	desktopBorderHidden
COLORREF	desktopWidgetColor
char	desktopRClickOverride [MAX_LINE_LENGTH]
char	desktopMClickOverride [MAX_LINE_LENGTH]
char	desktopX1ClickOverride [MAX_LINE_LENGTH]
char	desktopX2ClickOverride [MAX_LINE_LENGTH]
char	hotkeysFile [MAX_LINE_LENGTH]
int	numberOfWorkspaces
char	workspaceNames [MAX_LINE_LENGTH]
bool	mousewheelChanging
bool	followActive
bool	wallpaperPerWorkspace
bool	wallpaperPerWorkspaceSemaphore
char	pluginsFile [MAX_LINE_LENGTH]
bool	pluginsHidden
char	pluginsRepository [MAX_LINE_LENGTH]
char	themesFolder [MAX_PATH]
char	stylesFolder [MAX_PATH]
char	wallpapersFolder [MAX_PATH]
char	soundsFolder [MAX_PATH]
char	selectedTheme [MAX_PATH]
char	styleFile [MAX_LINE_LENGTH]
bool	doubleScaleHiDPI
int	scalingFactorHiDPI
bool	multimonPlacements
bool	enableSoundFX
bool	designerModeEnabled
bool	writeProtection
bool	disableRootCommands
bool	disableThemeFonts
bool	disableScriptSupport
bool	disableUnicodeParsing
bool	explorerHidden
char	timeDateLocale [MAX_LINE_LENGTH]
char	preferredEditor [MAX_LINE_LENGTH]
char	checkedForUpdates [20]
int	edgeSnapThreshold
bool	debugLogging
USHORT	machineArchitecture
int	operatingSystemVersion
BOOL	runningUnderWOW64
bool	underExplorer
bool	accessLock
int	currentWorkspace
int	lastWorkspace
char	SF_blackboxPath [MAX_PATH]
char	SF_startMenu [MAX_PATH]
char	SF_commonStartMenu [MAX_PATH]
char	SF_programFiles [MAX_PATH]
char	SF_desktop [MAX_PATH]
char	SF_userAppData [MAX_PATH]
char	SF_userProfile [MAX_PATH]
char	SF_currentThemePath [MAX_PATH]
bool	usingDefaultTheme
bool	menuEditboxAlreadyActive
MenuItem *	menuEditboxStringItemPtr
bool	checkingForUpdates
struct Settings::Statistics	Statistics
char	bbrcFile [MAX_LINE_LENGTH]
char	xobrcFile [MAX_LINE_LENGTH]
char	xobrcDefaultFile [MAX_LINE_LENGTH]
char *	bbrcCache
char *	xobrcCache
char *	xobrcDefaultCache
char *	styleCache
StyleItem *	Wildcard
StyleItem *	Toolbar
StyleItem *	ToolbarLabel
StyleItem *	ToolbarWindowLabel
StyleItem *	ToolbarClock
StyleItem *	ToolbarButton
StyleItem *	ToolbarButtonPressed
StyleItem *	ToolbarBorder
StyleItem *	MenuTitle
StyleItem *	MenuFrame
StyleItem *	MenuActive
StyleItem *	MenuGrip
StyleItem *	MenuFrameBullet
StyleItem *	MenuActiveBullet
StyleItem *	MenuIndicator
StyleItem *	MenuSeparator
StyleItem *	MenuFrameBorder
StyleItem *	Dock
StyleItem *	DockBorder
StyleItem *	ActiveTask
StyleItem *	InactiveTask
StyleItem *	FlashingTask
StyleItem *	Console
StyleItem *	WindowTitleFocus
StyleItem *	WindowTitleUnfocus
StyleItem *	WindowLabelFocus
StyleItem *	WindowLabelUnfocus
StyleItem *	WindowButtonFocus
StyleItem *	WindowButtonUnfocus
StyleItem *	WindowButtonPressed
StyleItem *	WindowGripFocus
StyleItem *	WindowGripUnfocus
StyleItem *	WindowHandleFocus
StyleItem *	WindowHandleUnfocus
StyleItem *	ExternalHardware
StyleItem *	selectedElement
char	wildcardToolbarFont [255]
char	wildcardMenuFont [255]
char	wildcardWindowFont [255]
char	wildcard [MAX_LINE_LENGTH]
char	toolbar [MAX_LINE_LENGTH]
char	toolbarLabel [MAX_LINE_LENGTH]
char	toolbarWindowLabel [MAX_LINE_LENGTH]
char	toolbarClock [MAX_LINE_LENGTH]
char	toolbarButton [MAX_LINE_LENGTH]
char	toolbarButtonPressed [MAX_LINE_LENGTH]
char	toolbarBorder [MAX_LINE_LENGTH]
char	menuTitle [MAX_LINE_LENGTH]
char	menuFrame [MAX_LINE_LENGTH]
char	menuActive [MAX_LINE_LENGTH]
char	menuGrip [MAX_LINE_LENGTH]
char	menuIndicator [MAX_LINE_LENGTH]
char	menuSeparator [MAX_LINE_LENGTH]
char	menuFrameBorder [MAX_LINE_LENGTH]
char	dock [MAX_LINE_LENGTH]
char	dockBorder [MAX_LINE_LENGTH]
char	console [MAX_LINE_LENGTH]
char	windowTitleFocus [MAX_LINE_LENGTH]
char	windowTitleUnfocus [MAX_LINE_LENGTH]
char	windowLabelFocus [MAX_LINE_LENGTH]
char	windowLabelUnfocus [MAX_LINE_LENGTH]
char	windowButtonFocus [MAX_LINE_LENGTH]
char	windowButtonUnfocus [MAX_LINE_LENGTH]
char	windowButtonPressed [MAX_LINE_LENGTH]
char	windowGripFocus [MAX_LINE_LENGTH]
char	windowGripUnfocus [MAX_LINE_LENGTH]
char	windowHandleFocus [MAX_LINE_LENGTH]
char	windowHandleUnfocus [MAX_LINE_LENGTH]
char	externalHardware [MAX_LINE_LENGTH]
LPSTR	appearancePointer
int	menuBullet
char	menuFrameBulletAsString [MAX_LINE_LENGTH]
char	menuActiveBulletAsString [MAX_LINE_LENGTH]
char	menuBulletPosition [MAX_LINE_LENGTH]
bool	consoleFontDefined
char	consoleFont [128]
int	consoleFontHeight
int	consoleFontWeight
bool	globalFontOverride
char	globalFont [128]
int	globalFontHeight
int	borderWidth
int	menuBorderWidth
COLORREF	borderColor
COLORREF	menuBorderColor
int	bevelWidth
int	marginWidth
int	handleHeight
int	frameWidth
char	rootCommand [MAX_LINE_LENGTH]
int	ScreenWidth
int	ScreenHeight
int	ScreenX
int	ScreenY
BYTE	red
BYTE	green
BYTE	blue

Constructor & Destructor Documentation

Settings()

Settings::Settings

(

)

{
    Wildcard = new StyleItem;
 
    Toolbar = new StyleItem;
    ToolbarLabel = new StyleItem;
    ToolbarWindowLabel = new StyleItem;
    ToolbarClock = new StyleItem;
    ToolbarButton = new StyleItem;
    ToolbarButtonPressed = new StyleItem;
    ToolbarBorder = new StyleItem;
 
    MenuTitle = new StyleItem;
    MenuFrame = new StyleItem;
    MenuActive = new StyleItem;
    MenuGrip = new StyleItem;
    MenuFrameBullet = new StyleItem;
    MenuActiveBullet = new StyleItem;
    MenuIndicator = new StyleItem;
    MenuSeparator = new StyleItem;
    MenuFrameBorder = new StyleItem;
 
    Dock = new StyleItem;
    DockBorder = new StyleItem;
 
    ActiveTask = new StyleItem;
    InactiveTask = new StyleItem;
    FlashingTask = new StyleItem;
 
    Console = new StyleItem;
 
    WindowTitleFocus = new StyleItem;
    WindowTitleUnfocus = new StyleItem;
    WindowLabelFocus = new StyleItem;
    WindowLabelUnfocus = new StyleItem;
    WindowButtonFocus = new StyleItem;
    WindowButtonUnfocus = new StyleItem;
    WindowButtonPressed = new StyleItem;
    WindowGripFocus = new StyleItem;
    WindowGripUnfocus = new StyleItem;
    WindowHandleFocus = new StyleItem;
    WindowHandleUnfocus = new StyleItem;
 
    ExternalHardware = new StyleItem;
 
    InitStyleItems();
 
    //====================
 
    borderWidth = 0;
    borderColor = 0;
 
    bevelWidth = 0;
    handleHeight = 0;
    frameWidth = 0;
 
    //====================
 
    bbrcFile[0] = 0;
    xobrcFile[0] = 0;
    xobrcDefaultFile[0] = 0;
 
    styleFile[0] = 0;
    menuFile[0] = 0;
    hotkeysFile[0] = 0;
    pluginsFile[0] = 0;
 
    //====================
 
    designerModeEnabled = false;
    selectedElement = Toolbar;
    wallpaperPerWorkspaceSemaphore = false;
 
    currentWorkspace = lastWorkspace = 0;
 
    //====================
 
    ZeroMemory(&Statistics, sizeof(Statistics));
}

~Settings()

Settings::~Settings

(

)

{
    DestroyStyleItems();
}

Member Function Documentation

InitStyleItems()

void Settings::InitStyleItems

(

)

{
//  if (debugLogging) SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)"Entering InitStyleItems() ...");
 
    InitStyleItem(Wildcard);
 
    InitStyleItem(Toolbar);
    InitStyleItem(ToolbarLabel);
    InitStyleItem(ToolbarWindowLabel);
    InitStyleItem(ToolbarClock);
    InitStyleItem(ToolbarButton);
    InitStyleItem(ToolbarButtonPressed);
    InitStyleItem(ToolbarBorder);
 
    InitStyleItem(MenuTitle);
    InitStyleItem(MenuFrame);
    InitStyleItem(MenuActive);
    InitStyleItem(MenuGrip);
    InitStyleItem(MenuFrameBullet);
    InitStyleItem(MenuActiveBullet);
    InitStyleItem(MenuIndicator);
    InitStyleItem(MenuSeparator);
    InitStyleItem(MenuFrameBorder);
 
    InitStyleItem(Dock);
    InitStyleItem(DockBorder);
 
    InitStyleItem(ActiveTask);
    InitStyleItem(InactiveTask);
    InitStyleItem(FlashingTask);
 
    InitStyleItem(Console);
 
    InitStyleItem(WindowTitleFocus);
    InitStyleItem(WindowTitleUnfocus);
    InitStyleItem(WindowLabelFocus);
    InitStyleItem(WindowLabelUnfocus);
    InitStyleItem(WindowButtonFocus);
    InitStyleItem(WindowButtonUnfocus);
    InitStyleItem(WindowButtonPressed);
    InitStyleItem(WindowGripFocus);
    InitStyleItem(WindowGripUnfocus);
    InitStyleItem(WindowHandleFocus);
    InitStyleItem(WindowHandleUnfocus);
 
    InitStyleItem(ExternalHardware);
}

InitStyleItem()

void Settings::InitStyleItem

(

StyleItem *

styleItem

)

{
    // ##################################################################################
    // Below: COLOR_UNDEFINED is later used e.g. by ReadStyleElement() to detect if
    // these colours have been read or calculated before... (i.e. inherited or otherwise)
    // ##################################################################################
 
    if (styleItem->Image.bitmap)
    {
//      if (debugLogging) SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_ERROR_MESSAGE, (LPARAM)styleItem->Image.path);
        DeleteObject(styleItem->Image.bitmap); // Note: We need to do this *before* we ZeroMemory as part of a re-initialization... :)
    }
 
    ZeroMemory(styleItem, sizeof(StyleItem));
 
    styleItem->parentRelative = false;
    styleItem->type = B_SOLID;
    styleItem->bevelstyle = BEVEL_FLAT;
    styleItem->bevelposition = BEVEL1;
    styleItem->interlaced = false;
 
    styleItem->Color1 = styleItem->Color2 = 0x000000;
    styleItem->Color3 = styleItem->Color4 = 0x000000;
    styleItem->Color5 = styleItem->Color6 = styleItem->Color7 = styleItem->Color8 = 0x000000;
 
    styleItem->TextColor = styleItem->foregroundColor = 0xffffff;
    styleItem->disabledColor = 0x888888;
 
    styleItem->ShadowColor = styleItem->OutlineColor = COLOR_UNDEFINED; // -> Not pre-defined, not yet calculated, not yet defined.
    styleItem->FontOutline = styleItem->FontShadow = false;
    
    strcpy(styleItem->Font, "Segoe UI");
    styleItem->FontHeight = 15;
    styleItem->FontWeight = FW_NORMAL;
    styleItem->Justify = DT_CENTER;
 
    styleItem->marginWidth = 0;
 
    styleItem->borderColor = 0x000000;
    styleItem->borderWidth = 0;
    styleItem->bordered = false;
 
    styleItem->Image.path[0] = '\0';
    styleItem->Image.mode = 0;
    styleItem->Image.width = styleItem->Image.height = styleItem->Image.left = styleItem->Image.top = styleItem->Image.right = styleItem->Image.bottom = 0;
 
    styleItem->nVersion = CORE_SHELL_STYLEITEM; // -> "This StyleItem belongs to the core shell" (see also BBApi.cpp/h)
}

DestroyStyleItems()

void Settings::DestroyStyleItems

(

)

{
    DestroyStyleItem(Wildcard);
 
    DestroyStyleItem(Toolbar);
    DestroyStyleItem(ToolbarLabel);
    DestroyStyleItem(ToolbarWindowLabel);
    DestroyStyleItem(ToolbarClock);
    DestroyStyleItem(ToolbarButton);
    DestroyStyleItem(ToolbarButtonPressed);
    DestroyStyleItem(ToolbarBorder);
 
    DestroyStyleItem(MenuTitle);
    DestroyStyleItem(MenuFrame);
    DestroyStyleItem(MenuActive);
    DestroyStyleItem(MenuGrip);
    DestroyStyleItem(MenuFrameBullet);
    DestroyStyleItem(MenuActiveBullet);
    DestroyStyleItem(MenuIndicator);
    DestroyStyleItem(MenuSeparator);
    DestroyStyleItem(MenuFrameBorder);
 
    DestroyStyleItem(Dock);
    DestroyStyleItem(DockBorder);
 
    DestroyStyleItem(ActiveTask);
    DestroyStyleItem(InactiveTask);
    DestroyStyleItem(FlashingTask);
 
    DestroyStyleItem(Console);
 
    DestroyStyleItem(WindowTitleFocus);
    DestroyStyleItem(WindowTitleUnfocus);
    DestroyStyleItem(WindowLabelFocus);
    DestroyStyleItem(WindowLabelUnfocus);
    DestroyStyleItem(WindowButtonFocus);
    DestroyStyleItem(WindowButtonUnfocus);
    DestroyStyleItem(WindowButtonPressed);
    DestroyStyleItem(WindowGripFocus);
    DestroyStyleItem(WindowGripUnfocus);
    DestroyStyleItem(WindowHandleFocus);
    DestroyStyleItem(WindowHandleUnfocus);
 
    DestroyStyleItem(ExternalHardware);
}

DestroyStyleItem()

void Settings::DestroyStyleItem

(

StyleItem *

styleItem

)

{
    if (styleItem)
    {
        if (styleItem->Image.bitmap) DeleteObject(styleItem->Image.bitmap);
        delete styleItem;
    }
}

CreateFileCache()

LPSTR Settings::CreateFileCache

(

LPSTR

path

)

{
    char* cachedFilePtr;
 
//  FILE* f = fopen(path, "r");
    FILE* f = NULL;
    fopen_s(&f, path, "r");
 
    if (f)
    {
        // Allocate memory for the file cache...
        fseek(f, 0, SEEK_END);
        long nLen = ftell(f);
        cachedFilePtr = (char*)malloc(nLen+2);
        if (cachedFilePtr != NULL)
        {
            // Copy the contents of the file to the file cache...
            fseek (f, 0, SEEK_SET);
            int readLen = fread (cachedFilePtr, 1, nLen, f);
            cachedFilePtr[readLen] = '\0';
            cachedFilePtr[readLen+1] = EOF;
        }
        fclose(f);
    }
    else
    {
        // Create a dummy cache if the requested file does not exist...
        cachedFilePtr = (char*)malloc(2);
        if (cachedFilePtr != NULL)
        {
            cachedFilePtr[0] = '\0';
            cachedFilePtr[1] = EOF;
        }
    }
 
    return cachedFilePtr;
}

DestroyFileCache()

void Settings::DestroyFileCache

(

LPSTR

cachedFilePtr

)

{
    if (cachedFilePtr) free(cachedFilePtr);
    cachedFilePtr = NULL;
}

ReadConfiguration()

void Settings::ReadConfiguration

(

)

{
    char temp[MAX_LINE_LENGTH];
 
    // ======================================================================
    // First, let's read any *legacy* syntax blackbox.rc settings,
    // so we can use them as possible fallbacks later...
    // ======================================================================
 
    bbrcCache = CreateFileCache(bbrcFile);
 
    strcpy(styleFile, GetString(NULL, bbrcCache, "session.styleFile:", ""));
    strcpy(menuFile, GetString(NULL, bbrcCache, "session.menuFile:", "$Blackbox$\\menu.rc"));
 
    strcpy(toolbarPlacementString, GetString(NULL, bbrcCache, "session.screen0.toolbar.placement:", "BottomCenter"));
    toolbarHorizontalWidth = GetInt(NULL, bbrcCache, "session.screen0.toolbar.widthPercent:", 75);
    toolbarOnTop = GetBool(NULL, bbrcCache, "session.screen0.toolbar.onTop:", true);
    strcpy(toolbarClockFormat, GetString(NULL, bbrcCache, "session.screen0.strftimeFormat:", "%H:%M | %a %#d %b"));
 
    strcpy(dockPlacementString, GetString(NULL, bbrcCache, "session.screen0.slit.placement:", "Manual xC y50"));
    strcpy(dockDirection, GetString(NULL, bbrcCache, "session.screen0.slit.direction:", "Horizontal"));
    dockOnTop = GetBool(NULL, bbrcCache, "session.screen0.slit.onTop:", false);
 
    numberOfWorkspaces = GetInt(NULL, bbrcCache, "session.screen0.workspaces:", 4);
    strcpy(workspaceNames, GetString(NULL, bbrcCache, "session.screen0.workspaceNames:", "")); // Nowadays automatically named "Workspace #1" etc if not specified (the old default used to be alpha,beta,gamma,delta)
 
    // focusLastWindow = GetBool(NULL, bbrcCache, "session.screen0.focusLastWindow:", false);
    // strcpy(windowPlacement, GetString(NULL, bbrcCache, "session.screen0.windowPlacement:", "ColSmartPlacement"));
    // strcpy(colPlacementDirection, GetString(NULL, bbrcCache, "session.screen0.colPlacementDirection:", "TopToBottom"));
    // focusNewWindows = GetBool(NULL, bbrcCache, "session.screen0.focusNewWindows:", false);
    // strcpy(rowPlacementDirection, GetString(NULL, bbrcCache, "session.screen0.rowPlacementDirection:", "LeftToRight"));
 
    // strcpy(focusModel, GetString(NULL, bbrcCache, "session.screen0.focusModel:", "ClickToFocus"));
    // opaqueMove = GetBool(NULL, bbrcCache, "session.opaqueMove:", false);
    // fullMaximization = GetBool(NULL, bbrcCache, "session.screen0.fullMaximization:", true);
 
    edgeSnapThreshold = GetInt(NULL, bbrcCache, "session.screen0.edgeSnapThreshold:", 10);
    // doubleClickInterval = GetInt(NULL, bbrcCache, "session.doubleClickInterval:", 250);
    // autoRaiseDelay = GetInt(NULL, bbrcCache, "session.autoRaiseDelay:", 250);
 
    DestroyFileCache(bbrcCache);
 
    // ======================================================================
 
    // ##### Next, we read all xoblite syntax settings from xoblite.rc! #####
    // Please note that a parameter may be read from the *default* xoblite.rc file
    // (xobrcDefaultCache below) or the *current theme* xoblite.rc file (xobrcCache below)
    // depending on the purpose of the parameter, i.e. theme related parameters are
    // read from the current theme's xoblite.rc file while universal parameters
    // (e.g. preferred editor) are read from the default theme's xoblite.rc file
 
    // ======================================================================
    //========== THEME SPECIFIC SETTINGS ====================================
    // ======================================================================
 
    xobrcCache = CreateFileCache(xobrcFile); // -> The current theme's xoblite.rc!
 
    //====================
 
    strcpy(styleFile, GetString(NULL, bbrcCache, "xoblite.styleFile:", styleFile));
    if (strchr(styleFile, '\"')) StrRemoveEncap(styleFile);
    if (strchr(styleFile, '$')) ReplaceShellFolders(styleFile);
    if (strchr(styleFile, '%')) ReplaceEnvVars(styleFile);
 
    //====================
 
    menuSeparators = GetBool(NULL, xobrcCache, "xoblite.menu.separators:", true);
    menuRoundedCorners = GetBool(NULL, xobrcCache, "xoblite.menu.rounded:", false);
    menuTransparencyAlpha = (BYTE)GetInt(NULL, xobrcCache, "xoblite.menu.transparency.alpha:", 255);
    menuTitleTransparencyAlpha = (BYTE)GetInt(NULL, xobrcCache, "xoblite.menu.title.transparency.alpha:", menuTransparencyAlpha);
    menuFrameTransparencyAlpha = (BYTE)GetInt(NULL, xobrcCache, "xoblite.menu.frame.transparency.alpha:", menuTransparencyAlpha);
    menuActiveTransparencyAlpha = (BYTE)GetInt(NULL, xobrcCache, "xoblite.menu.active.transparency.alpha:", menuTransparencyAlpha);
    menuGripTransparencyAlpha = (BYTE)GetInt(NULL, xobrcCache, "xoblite.menu.grip.transparency.alpha:", menuTransparencyAlpha);
 
    //====================
 
    toolbarHidden = GetBool(NULL, xobrcCache, "xoblite.toolbar.hidden:", false);
    strcpy(temp, GetString(NULL, xobrcCache, "xoblite.toolbar.placement:", toolbarPlacementString));
    ParsePlacement(temp, &ToolbarPlacement);
    toolbarVertical = GetBool(NULL, xobrcCache, "xoblite.toolbar.vertical:", false);
    toolbarHorizontalWidth = GetInt(NULL, xobrcCache, "xoblite.toolbar.widthPercent:", toolbarHorizontalWidth); // -> Used prior to xoblite bb5, cf. width only as percentage in legacy *box...
    toolbarHorizontalWidth = GetInt(NULL, xobrcCache, "xoblite.toolbar.horizontal.width:", toolbarHorizontalWidth); // -> Used by xoblite bb5 onwards, cf. adaptive parsing of width <> 100 etc...
    if (toolbarHorizontalWidth < 30) toolbarHorizontalWidth = 30;
    toolbarVerticalWidth = GetInt(NULL, xobrcCache, "xoblite.toolbar.vertical.width:", 0); // (If not specified, the vertical toolbar width is set automatically by xoblite.)
    toolbarTransparencyAlpha = (BYTE)GetInt(NULL, xobrcCache, "xoblite.toolbar.transparency.alpha:", 255);
    toolbarLabelTransparencyAlpha = (BYTE)GetInt(NULL, xobrcCache, "xoblite.toolbar.label.transparency.alpha:", toolbarTransparencyAlpha);
    toolbarWindowLabelTransparencyAlpha = (BYTE)GetInt(NULL, xobrcCache, "xoblite.toolbar.windowlabel.transparency.alpha:", toolbarTransparencyAlpha);
    toolbarClockTransparencyAlpha = (BYTE)GetInt(NULL, xobrcCache, "xoblite.toolbar.clock.transparency.alpha:", toolbarTransparencyAlpha);
    toolbarButtonTransparencyAlpha = (BYTE)GetInt(NULL, xobrcCache, "xoblite.toolbar.button.transparency.alpha:", toolbarTransparencyAlpha);
    toolbarRoundedCorners = GetBool(NULL, xobrcCache, "xoblite.toolbar.rounded:", false);
    toolbarOnTop = GetBool(NULL, xobrcCache, "xoblite.toolbar.onTop:", toolbarOnTop);
    toolbarSnapToEdges = GetBool(NULL, xobrcCache, "xoblite.toolbar.snapToEdges:", false);
 
    toolbarLabelHidden = GetBool(NULL, xobrcCache, "xoblite.toolbar.label.hidden:", false);
    toolbarDownUpButtonsHidden = GetBool(NULL, xobrcCache, "xoblite.toolbar.downup.buttons.hidden:", false);
    toolbarLeftRightButtonsHidden = GetBool(NULL, xobrcCache, "xoblite.toolbar.leftright.buttons.hidden:", false);
    toolbarClockHidden = GetBool(NULL, xobrcCache, "xoblite.toolbar.clock.hidden:", false);
    toolbarAllowAsymmetry = GetBool(NULL, xobrcCache, "xoblite.toolbar.allow.asymmetry:", false);
 
    strcpy(toolbarDownButtonOverride, GetString(NULL, xobrcCache, "xoblite.toolbar.downbutton.override:", ""));
    strcpy(toolbarUpButtonOverride, GetString(NULL, xobrcCache, "xoblite.toolbar.upbutton.override:", ""));
    strcpy(toolbarLeftButtonOverride, GetString(NULL, xobrcCache, "xoblite.toolbar.leftbutton.override:", ""));
    strcpy(toolbarRightButtonOverride, GetString(NULL, xobrcCache, "xoblite.toolbar.rightbutton.override:", ""));
 
    //====================
 
    strcpy(temp, GetString(NULL, xobrcCache, "xoblite.taskbar.mode:", "Bars+Icons"));
    {
        if (!_stricmp(temp, "Bars")) taskbarMode = TASKBAR_MODE_BARS;
        else if (!_stricmp(temp, "Bars+Icons")) taskbarMode = TASKBAR_MODE_BARSICONS;
        else if (!_stricmp(temp, "Icons")) taskbarMode = TASKBAR_MODE_ICONS;
        else taskbarMode = TASKBAR_MODE_HIDDEN; // -> Hide the taskbar, show the toolbar windowLabel instead...
    }
    taskbarMaxItems = GetInt(NULL, xobrcCache, "xoblite.taskbar.max.items:", 10); // ...no maximum if set to 0...
    strcpy(temp, GetString(NULL, xobrcCache, "xoblite.taskbar.sorting:", "FollowActive"));
    {
        if (!_stricmp(temp, "LastUsed")) taskbarSorting = TASKBAR_SORT_BY_LAST_USED;
        else if (!_stricmp(temp, "FollowActive")) taskbarSorting = TASKBAR_SORT_FOLLOW_ACTIVE;
        else taskbarSorting = TASKBAR_SORT_DISABLED;
    }
    taskbarShowTaskWorkspace = GetBool(NULL, xobrcCache, "xoblite.taskbar.show.task.workspace:", true);
    taskbarCurrentOnly = GetBool(NULL, xobrcCache, "xoblite.taskbar.currentOnly:", false);
    taskbarFlashing = GetBool(NULL, xobrcCache, "xoblite.taskbar.flashing:", true);
    taskbarSaturationValue = GetInt(NULL, xobrcCache, "xoblite.taskbar.saturation:", 30);
    taskbarHueIntensity = GetInt(NULL, xobrcCache, "xoblite.taskbar.hue:", 100);
    taskbarActiveSatHue = GetBool(NULL, xobrcCache, "xoblite.taskbar.active.SatHue:", false);
    taskbarActiveTransparencyAlpha = (BYTE)GetInt(NULL, xobrcCache, "xoblite.taskbar.active.transparency.alpha:", toolbarTransparencyAlpha);
    taskbarActiveLivePreview = GetBool(NULL, xobrcCache, "xoblite.taskbar.active.live.preview:", true);
    taskbarInactiveBackground = GetBool(NULL, xobrcCache, "xoblite.taskbar.inactive.background:", false);
    bool tempTooltips = GetBool(NULL, xobrcCache, "xoblite.toolbar.tooltips.disable:", false); // -> Used prior to xoblite bb5, parsed for backwards compatibility only...
    taskbarTooltips = GetBool(NULL, xobrcCache, "xoblite.taskbar.tooltips:", !tempTooltips); // -> Used by xoblite bb5 onwards (cf. now used only by the taskbar, the systray has been removed, etc)
 
    //====================
 
    dockHidden = GetBool(NULL, xobrcCache, "xoblite.dock.hidden:", false);
    strcpy(temp, GetString(NULL, xobrcCache, "xoblite.dock.placement:", dockPlacementString));
    ParsePlacement(temp, &DockPlacement);
    strcpy(temp, GetString(NULL, xobrcCache, "xoblite.dock.direction:", dockDirection)); // -> Used prior to xoblite bb5, parsed for backwards compatibility only...
    {
        if (!_stricmp(temp, "Vertical")) dockVertical = true;
        else dockVertical = false;
    }
    dockVertical = GetBool(NULL, xobrcCache, "xoblite.dock.vertical:", dockVertical);
 
    dockSnapToEdges = GetBool(NULL, xobrcCache, "xoblite.dock.snapToEdges:", false);
    dockTransparencyAlpha = (BYTE)GetInt(NULL, xobrcCache, "xoblite.dock.transparency.alpha:", 255);
 
    strcpy(temp, GetString(NULL, xobrcCache, "xoblite.dock.positioning:", "")); // -> Used prior to xoblite bb5, parsed for backwards compatibility only...
    if (!_stricmp(temp, "SideBySide")) dockPuzzlePositioning = false;
    else dockPuzzlePositioning = true;
    dockPuzzlePositioning = GetBool(NULL, xobrcCache, "xoblite.dock.puzzle.positioning:", dockPuzzlePositioning);
 
    dockOnTop = GetBool(NULL, xobrcCache, "xoblite.dock.onTop:", dockOnTop);
 
    //====================
 
    consoleHidden = GetBool(NULL, xobrcCache, "xoblite.console.hidden:", true);
    strcpy(temp, GetString(NULL, xobrcCache, "xoblite.console.placement:", "Default"));
    ParsePlacement(temp, &ConsolePlacement);
    consoleMaximized = GetBool(NULL, xobrcCache, "xoblite.console.maximized:", true);
    consoleMaximizedWidth = GetInt(NULL, xobrcCache, "xoblite.console.maximized.width:", 0);
    consoleMaximizedMessages = GetInt(NULL, xobrcCache, "xoblite.console.maximized.messages:", 10);
    if (consoleMaximizedMessages < 1) consoleMaximizedMessages = 1;
    consoleRestoredWidth = GetInt(NULL, xobrcCache, "xoblite.console.restored.width:", 0);
    consoleRestoredMessages = GetInt(NULL, xobrcCache, "xoblite.console.restored.messages:", 1);
    if (consoleRestoredMessages < 1) consoleMaximizedMessages = 1;
    consoleTransparencyAlpha = (BYTE)GetInt(NULL, xobrcCache, "xoblite.console.transparency.alpha:", 85);
    consoleDesktopMode = GetBool(NULL, xobrcCache, "xoblite.console.desktop.mode:", false);
    consoleRoundedCorners = GetBool(NULL, xobrcCache, "xoblite.console.rounded:", true);
    consolePadding = GetInt(NULL, xobrcCache, "xoblite.console.padding:", 0);
 
    StyleItem tempStyleItem;
    ZeroMemory(&tempStyleItem, sizeof(StyleItem));
    strcpy(temp, GetString(NULL, xobrcCache, "xoblite.console.font:", ""));
    ParseFontString(temp, &tempStyleItem);
    if (strlen(tempStyleItem.Font))
    {
        strcpy(consoleFont, tempStyleItem.Font);
        consoleFontHeight = tempStyleItem.FontHeight;
        consoleFontWeight = tempStyleItem.FontWeight;
        consoleFontDefined = true;
    }
    else consoleFontDefined = false;
 
    //====================
 
    desktopClockHidden = GetBool(NULL, xobrcCache, "xoblite.desktop.clock.hidden:", true);
    strcpy(desktopClockType, GetString(NULL, xobrcCache, "xoblite.desktop.clock.type:", "Regular"));
    strcpy(temp, GetString(NULL, xobrcCache, "xoblite.desktop.clock.placement:", "Default"));
    ParsePlacement(temp, &desktopClockPlacement);
    desktopClockTransparencyAlpha = (BYTE)GetInt(NULL, xobrcCache, "xoblite.desktop.clock.transparency.alpha:", 210);
 
    desktopWeekdayHidden = GetBool(NULL, xobrcCache, "xoblite.desktop.weekday.hidden:", true);
    strcpy(temp, GetString(NULL, xobrcCache, "xoblite.desktop.weekday.placement:", "Manual x-50 y-100"));
    ParsePlacement(temp, &desktopWeekdayPlacement);
    desktopWeekdayTransparencyAlpha = (BYTE)GetInt(NULL, xobrcCache, "xoblite.desktop.weekday.transparency.alpha:", 210);
 
    desktopDateHidden = GetBool(NULL, xobrcCache, "xoblite.desktop.date.hidden:", true);
    strcpy(desktopDateFormat, GetString(NULL, xobrcCache, "xoblite.desktop.date.format:", "%B %#d %Y"));
    strcpy(temp, GetString(NULL, xobrcCache, "xoblite.desktop.date.placement:", "Manual x-50 y-50"));
    ParsePlacement(temp, &desktopDatePlacement);
    desktopDateTransparencyAlpha = (BYTE)GetInt(NULL, xobrcCache, "xoblite.desktop.date.transparency.alpha:", 105);
 
    desktopGreetingHidden = GetBool(NULL, xobrcCache, "xoblite.desktop.greeting.hidden:", true);
    strcpy(temp, GetString(NULL, xobrcCache, "xoblite.desktop.greeting.placement:", "Manual x-50 y-50"));
    ParsePlacement(temp, &desktopGreetingPlacement);
    desktopGreetingTransparencyAlpha = (BYTE)GetInt(NULL, xobrcCache, "xoblite.desktop.greeting.transparency.alpha:", 60);
 
    desktopWorkspaceIndicatorHidden = GetBool(NULL, xobrcCache, "xoblite.desktop.indicator.hidden:", false);
 
    desktopBorderHidden = GetBool(NULL, xobrcCache, "xoblite.desktop.border.hidden:", true);
 
    strcpy(temp, GetString(NULL, xobrcCache, "xoblite.desktop.clock.font:", ""));
    ParseFontString(temp, &tempStyleItem);
    if (strlen(tempStyleItem.Font))
    {
        strcpy(desktopClockFont, tempStyleItem.Font);
        desktopClockFontHeight = tempStyleItem.FontHeight;
        desktopClockFontWeight = tempStyleItem.FontWeight;
        desktopClockFontDefined = true;
    }
    else desktopClockFontDefined = false;
    strcpy(temp, GetString(NULL, xobrcCache, "xoblite.desktop.weekday.font:", temp)); // -> Inherits desktop clock font if not specified
    ParseFontString(temp, &tempStyleItem);
    if (strlen(tempStyleItem.Font))
    {
        strcpy(desktopWeekdayFont, tempStyleItem.Font);
        desktopWeekdayFontHeight = tempStyleItem.FontHeight;
        desktopWeekdayFontWeight = tempStyleItem.FontWeight;
        desktopWeekdayFontDefined = true;
    }
    else desktopWeekdayFontDefined = false;
    strcpy(temp, GetString(NULL, xobrcCache, "xoblite.desktop.date.font:", temp)); // -> Inherits desktop weekday font if not specified
    ParseFontString(temp, &tempStyleItem);
    if (strlen(tempStyleItem.Font))
    {
        strcpy(desktopDateFont, tempStyleItem.Font);
        desktopDateFontHeight = tempStyleItem.FontHeight;
        desktopDateFontWeight = tempStyleItem.FontWeight;
        desktopDateFontDefined = true;
    }
    else desktopDateFontDefined = false;
    strcpy(temp, GetString(NULL, xobrcCache, "xoblite.desktop.greeting.font:", temp)); // -> Inherits desktop date font if not specified
    ParseFontString(temp, &tempStyleItem);
    if (strlen(tempStyleItem.Font))
    {
        strcpy(desktopGreetingFont, tempStyleItem.Font);
        desktopGreetingFontHeight = tempStyleItem.FontHeight;
        desktopGreetingFontWeight = tempStyleItem.FontWeight;
        desktopGreetingFontDefined = true;
    }
    else desktopGreetingFontDefined = false;
 
    desktopWidgetColor = GetColor(NULL, xobrcCache, "xoblite.desktop.widget.color:", NULL, 0xffffff, true);
 
    strcpy(desktopRClickOverride, GetString(NULL, xobrcCache, "xoblite.desktop.rclick.override:", ""));
    strcpy(desktopMClickOverride, GetString(NULL, xobrcCache, "xoblite.desktop.mclick.override:", ""));
    strcpy(desktopX1ClickOverride, GetString(NULL, xobrcCache, "xoblite.desktop.x1click.override:", ""));
    strcpy(desktopX2ClickOverride, GetString(NULL, xobrcCache, "xoblite.desktop.x2click.override:", ""));
/*
    strcpy(temp, GetString(NULL, xobrcCache, "xoblite.desktop.area:", ""));
    if (strlen(temp) > 0)
    {
        desktopAreaDefined = true;
 
        char left[10], top[10], right[10], bottom[10];
        LPSTR tokens[4];
        tokens[0] = left;
        tokens[1] = top;
        tokens[2] = right;
        tokens[3] = bottom;
 
        left[0] = top[0] = right[0] = bottom[0] = '\0';
        BBTokenize(temp, tokens, 3, bottom);
 
        desktopArea.left = atoi(left);
        desktopArea.top = atoi(top);
        desktopArea.right = atoi(right);
        desktopArea.bottom = atoi(bottom);
    }
    else desktopAreaDefined = false;
*/
    //====================
 
    pluginsHidden = GetBool(NULL, xobrcCache, "xoblite.plugins.hidden:", false);
 
    //====================
 
    writeProtection = GetBool(NULL, xobrcCache, "xoblite.write.protection:", false);
 
    //====================
 
    DestroyFileCache(xobrcCache);
 
    // ======================================================================
    //========== UNIVERSAL SETTINGS =========================================
    // ======================================================================
 
    xobrcDefaultCache = CreateFileCache(xobrcDefaultFile); // -> The default xoblite.rc!
 
    //====================
 
    strcpy(stylesFolder, GetString(NULL, xobrcDefaultCache, "xoblite.stylesFolder:", "$Blackbox$\\styles"));
    if (strchr(stylesFolder, '\"')) StrRemoveEncap(stylesFolder);
    if (strchr(stylesFolder, '$')) ReplaceShellFolders(stylesFolder);
    if (strchr(stylesFolder, '%')) ReplaceEnvVars(stylesFolder);
 
    strcpy(themesFolder, GetString(NULL, xobrcDefaultCache, "xoblite.themesFolder:", "$Blackbox$\\themes"));
    if (strchr(themesFolder, '\"')) StrRemoveEncap(themesFolder);
    if (strchr(themesFolder, '$')) ReplaceShellFolders(themesFolder);
    if (strchr(themesFolder, '%')) ReplaceEnvVars(themesFolder);
 
    strcpy(wallpapersFolder, GetString(NULL, xobrcDefaultCache, "xoblite.wallpapersFolder:", "$Blackbox$\\wallpapers"));
    if (strchr(wallpapersFolder, '\"')) StrRemoveEncap(wallpapersFolder);
    if (strchr(wallpapersFolder, '$')) ReplaceShellFolders(wallpapersFolder);
    if (strchr(wallpapersFolder, '%')) ReplaceEnvVars(wallpapersFolder);
 
    enableSoundFX = GetBool(NULL, xobrcDefaultCache, "xoblite.sound.effects:", true);
    strcpy(soundsFolder, GetString(NULL, xobrcDefaultCache, "xoblite.soundsFolder:", "$Blackbox$\\sounds"));
    if (strchr(soundsFolder, '\"')) StrRemoveEncap(soundsFolder);
    if (strchr(soundsFolder, '$')) ReplaceShellFolders(soundsFolder);
    if (strchr(soundsFolder, '%')) ReplaceEnvVars(soundsFolder);
 
    strcpy(hotkeysFile, GetString(NULL, xobrcDefaultCache, "xoblite.hotkeysFile:", "$Blackbox$\\hotkeys.rc"));
    if (strchr(hotkeysFile, '\"')) StrRemoveEncap(hotkeysFile);
    if (strchr(hotkeysFile, '$')) ReplaceShellFolders(hotkeysFile);
    if (strchr(hotkeysFile, '%')) ReplaceEnvVars(hotkeysFile);
 
    strcpy(pluginsFile, GetString(NULL, xobrcDefaultCache, "xoblite.pluginsFile:", "$Blackbox$\\plugins.rc"));
    if (strchr(pluginsFile, '\"')) StrRemoveEncap(pluginsFile);
    if (strchr(pluginsFile, '$')) ReplaceShellFolders(pluginsFile);
    if (strchr(pluginsFile, '%')) ReplaceEnvVars(pluginsFile);
 
    strcpy(selectedTheme, GetString(NULL, xobrcDefaultCache, "xoblite.selected.theme:", "[Default]"));
    if (!_stricmp(selectedTheme, "<Default>")) strcpy(selectedTheme, "[Default]"); // (changed to avoid similarity to editable string/integer menu items, as it is also shown in the Themes menu)
 
    //====================
 
    strcpy(toolbarClockFormat, GetString(NULL, xobrcDefaultCache, "xoblite.toolbar.strftimeFormat:", toolbarClockFormat));
 
    strcpy(menuFile, GetString(NULL, xobrcDefaultCache, "xoblite.menuFile:", menuFile));
    if (strchr(menuFile, '\"')) StrRemoveEncap(menuFile);
    if (strchr(menuFile, '$')) ReplaceShellFolders(menuFile);
    if (strchr(menuFile, '%')) ReplaceEnvVars(menuFile);
    if (!FileExists(menuFile))
    {
        // Check for menu.rc in the Blackbox and $UserAppData$\Blackbox directories...
        strcpy(menuFile, ConfigFileExists("menu.rc", NULL));
        if (!_stricmp(menuFile, ""))
        {
            // If not found, check for menurc in the same directories...
            strcpy(menuFile, ConfigFileExists("menurc", NULL));
            if (!_stricmp(menuFile, ""))
            {
                // If still not found, create the default
                // menu.rc in the Blackbox directory...
                WriteDefaultMenu();
            }
        }
 
        // Finally, we save the newly configured menu.rc path...
        menuPath(menuFile);
    }
    submenuDelay = GetInt(NULL, xobrcDefaultCache, "xoblite.submenu.delay:", 40);
//  scrollSpeed = GetInt(NULL, xobrcDefaultCache, "xoblite.menu.scrollSpeed:", 10);
//  wheelSpeed = GetInt(NULL, xobrcDefaultCache, "xoblite.menu.wheelSpeed:", 50);
 
    //====================
 
    numberOfWorkspaces = GetInt(NULL, xobrcDefaultCache, "xoblite.workspaces:", numberOfWorkspaces);
    strcpy(workspaceNames, GetString(NULL, xobrcDefaultCache, "xoblite.workspaces.names:", workspaceNames));
    mousewheelChanging = GetBool(NULL, xobrcDefaultCache, "xoblite.workspaces.mousewheel.changing:", false);
    followActive = GetBool(NULL, xobrcDefaultCache, "xoblite.workspaces.followActive:", true);
    wallpaperPerWorkspace = GetBool(NULL, xobrcDefaultCache, "xoblite.workspaces.wallpapers:", true);
 
    //====================
 
    strcpy(pluginsRepository, GetString(NULL, xobrcDefaultCache, "xoblite.plugins.repository:", "http://xoblite.net/plugins.txt"));
 
    //====================
 
    doubleScaleHiDPI = GetBool(NULL, xobrcDefaultCache, "xoblite.double.scale:", true); // <- Deprecated, kept for backwards compatibility only, remapped to new integer scaling factor.
    int legacyScalingFactor = 1;
    if (doubleScaleHiDPI) legacyScalingFactor = 2;
    scalingFactorHiDPI = GetInt(NULL, xobrcDefaultCache, "xoblite.hidpi.scaling.factor:", legacyScalingFactor); // <- New integer HiDPI scaling factor (1x-6x) for further flexibililty wrt ultra-high res screens
    if (scalingFactorHiDPI < 1) scalingFactorHiDPI = 1; // Safeguard
    if (scalingFactorHiDPI > 4) scalingFactorHiDPI = 4; // Safeguard
 
    multimonPlacements = GetBool(NULL, xobrcDefaultCache, "xoblite.multimonitor.placements:", false);
 
    disableRootCommands = GetBool(NULL, xobrcDefaultCache, "xoblite.disable.rootCommands:", false);
    disableThemeFonts = GetBool(NULL, xobrcDefaultCache, "xoblite.disable.theme.fonts:", true);
    disableScriptSupport = GetBool(NULL, xobrcDefaultCache, "xoblite.disable.script.support:", false);
 
    disableUnicodeParsing = GetBool(NULL, xobrcDefaultCache, "xoblite.disable.unicode.parsing:", false); // PRELIMINARY
 
    explorerHidden = GetBool(NULL, xobrcDefaultCache, "xoblite.explorer.hidden:", false);
 
    strcpy(timeDateLocale, GetString(NULL, xobrcDefaultCache, "xoblite.toolbar.locale:", "")); // Old syntax (when used by the toolbar only)
    strcpy(timeDateLocale, GetString(NULL, xobrcDefaultCache, "xoblite.timedate.locale:", timeDateLocale)); // New syntax (when used by both toolbar and desktop)
 
    strcpy(preferredEditor, GetString(NULL, xobrcDefaultCache, "xoblite.editor:", "\"notepad.exe\""));
    if (strchr(preferredEditor, '$')) ReplaceShellFolders(preferredEditor);
    if (strchr(preferredEditor, '%')) ReplaceEnvVars(preferredEditor);
 
    strcpy(checkedForUpdates, GetString(NULL, xobrcDefaultCache, "xoblite.checked.for.updates:", "#001 / 2006-01-01"));
 
    //====================
 
    // fullMaximization = GetBool(NULL, xobrcDefaultCache, "xoblite.fullMaximization:", fullMaximization);
    edgeSnapThreshold = GetInt(NULL, xobrcDefaultCache, "xoblite.edgeSnapThreshold:", edgeSnapThreshold);
    // strcpy(focusModel, GetString(NULL, xobrcDefaultCache, "xoblite.focusModel:", focusModel));
 
    // opaqueMove = GetBool(NULL, xobrcDefaultCache, "xoblite.opaqueMove:", opaqueMove);
    // doubleClickInterval = GetInt(NULL, xobrcDefaultCache, "xoblite.doubleClickInterval:", doubleClickInterval);
    // autoRaiseDelay = GetInt(NULL, xobrcDefaultCache, "xoblite.autoRaiseDelay:", autoRaiseDelay);
 
    //====================
 
    debugLogging = GetBool(NULL, xobrcDefaultCache, "xoblite.debug:", false);
 
    //====================
 
    DestroyFileCache(xobrcDefaultCache);
 
    // ======================================================================
    // ======================================================================
    // ======================================================================
/*
    // Apply a few settings directly... (read: no better place to do it so we might as well do it here... ;))
    SystemParametersInfo(SPI_SETACTIVEWNDTRKTIMEOUT, 0, (PVOID)autoRaiseDelay, SPIF_SENDCHANGE);
 
    if (!_stricmp(focusModel, "ClickToFocus"))
    {
        SystemParametersInfo(SPI_SETACTIVEWINDOWTRACKING, 0, (PVOID)false, SPIF_SENDCHANGE);
        SystemParametersInfo(SPI_SETACTIVEWNDTRKZORDER, 0, (PVOID)false, SPIF_SENDCHANGE);
    }
    else if (!_stricmp(focusModel, "AutoRaiseSloppyFocus"))
    {
        SystemParametersInfo(SPI_SETACTIVEWINDOWTRACKING, 0, (PVOID)true, SPIF_SENDCHANGE);
        SystemParametersInfo(SPI_SETACTIVEWNDTRKZORDER, 0, (PVOID)true, SPIF_SENDCHANGE);
    }
    else if (!_stricmp(focusModel, "SloppyFocus"))
    {
        SystemParametersInfo(SPI_SETACTIVEWINDOWTRACKING, 0, (PVOID)true, SPIF_SENDCHANGE);
        SystemParametersInfo(SPI_SETACTIVEWNDTRKZORDER, 0, (PVOID)false, SPIF_SENDCHANGE);
    }
 
    SystemParametersInfo(SPI_SETDOUBLECLICKTIME, doubleClickInterval, NULL, SPIF_SENDCHANGE);
    SystemParametersInfo(SPI_SETDRAGFULLWINDOWS, opaqueMove, NULL, SPIF_SENDCHANGE);
*/
}

WriteDefaultRCSettings()

void Settings::WriteDefaultRCSettings

(

)

{
    DWORD retLength=0;
    char path[MAX_LINE_LENGTH], szTemp[MAX_LINE_LENGTH];
    GetBlackboxPath(path, sizeof(path));
    strcat(path, "xoblite.rc");
 
    if (FileExists(path)) return;
    else
    {
        // Try to download the latest default xoblite.rc available online...
        bool downloadSuccessful = DownloadFile("http://xoblite.net/defaults/xoblite.rc", path);
        if (downloadSuccessful)
        {
            // ...and double-check that the downloaded file wasn't actually a 404 message... :)
            strcpy(szTemp, ReadString(path, "404 Not Found", ""));
            if (strlen(szTemp) > 0) downloadSuccessful = false;
        }
 
        if (!downloadSuccessful)
        {
            // If the downloading above wasn't successful, we create a "fallback" non-populated xoblite.rc as a last resort...
            HANDLE f = CreateFile(path, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
            if (f)
            {
                strcpy(szTemp,
                    "! =========================================================================================\r\n"
                    "! Note: This \"fallback\" blank configuration file will be dynamically populated over time...\r\n"
                    "! =========================================================================================\r\n\r\n");
                WriteFile(f, szTemp, strlen(szTemp), &retLength, NULL);
            }
            CloseHandle(f);
        }
 
        strcpy(bbrcFile, path); // Legacy blackbox.rc (for backwards compatibility)
        strcpy(xobrcDefaultFile, path); // Default xoblite.rc (for universal settings)
    }
}

WriteDefaultMenu()

void Settings::WriteDefaultMenu

(

)

{
    DWORD retLength=0;
    char temp[MAX_LINE_LENGTH];
 
    HANDLE f = CreateFile(menuFile, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
    if (f)
    {
        strcpy(temp,
            "[begin] ()\r\n"
            "\t[exec] (Explorer) {explorer.exe /e,%SystemDrive%}\r\n"
            "\t[submenu] (Start menu)\r\n"
                "\t\t[path] (Current user) {\"$StartMenu$\"}\r\n"
                "\t\t[path] (All users) {\"$CommonStartMenu$\"}\r\n"
            "\t[end]\r\n"
            "\t[submenu] (Shutdown menu)\r\n"
                "\t\t[lockworkstation] (Lock workstation)\r\n"
                "\t\t[separator]\r\n"
                "\t\t[standby] (Standby [sleep])\r\n"
                "\t\t[hibernate] (Hibernate [suspend])\r\n"
                "\t\t[separator]\r\n"
                "\t\t[logoff] (Log off)\r\n"
                "\t\t[reboot] (Restart [reboot])\r\n"
                "\t\t[shutdown] (Shutdown)\r\n"
            "\t[end]\r\n"
            "\t[separator]\r\n"
            "\t[configuration] (xoblite)\r\n"
            "[end] ()\r\n");
        WriteFile(f, temp, strlen(temp), &retLength, NULL);
    }
 
    CloseHandle(f);
 
    GetBlackboxPath(menuFile, sizeof(menuFile));
    strcat(menuFile, "menu.rc");
}

ReadStyle()

void Settings::ReadStyle

(

)

{
    // ##################################################################################
    // Sidenote: The ~messy inheritance between style elements, old wildcarding etc below
    // is not an ideal situation, but legacy dependencies are tough to get rid of, so...
    // ##################################################################################
 
    styleCache = CreateFileCache(styleFile);
    if (styleCache == NULL) return;
 
    //====================
 
    char temp[MAX_LINE_LENGTH];
    COLORREF tempColor;
    bool bb4nix070syntax = false;
    InitStyleItems(); // -> Resets all StyleItems back to a default state (including any applicable destroy/delete's)
 
    //====================
 
    // First, a few miscellaneous "style-wide" parameters...
 
    borderWidth = GetInt(NULL, styleCache, "borderWidth:", 0); // "For all parent elements" [?]
    borderColor = GetColor(NULL, styleCache, "borderColor:", NULL, 0x000000, true);
 
    marginWidth = GetInt(NULL, styleCache, "marginWidth:", 0);
    bevelWidth = GetInt(NULL, styleCache, "bevelWidth:", 1);
 
    handleHeight = GetInt(NULL, styleCache, "handleWidth:", 5); // ...often used?...
    handleHeight = GetInt(NULL, styleCache, "handleHeight:", handleHeight); // ...more recent?... (and makes more sense of course!)
    handleHeight = GetInt(NULL, styleCache, "window.handleHeight:", handleHeight); // ...bb4nix 0.70 syntax... (see https://raw.githubusercontent.com/bradleythughes/blackbox/master/data/README.style )
 
    // Width of the window frame (old parameter from bb4nix version 0.61+;
    // when not specified, frameWidth defaults to the value of bevelWidth)
    frameWidth = GetInt(NULL, styleCache, "frameWidth:", bevelWidth);
 
    // The "rootCommand" is executed whenever the style is selected,
    // typically setting a wallpaper... (e.g. using bsetbg or bsetroot)
    strcpy(rootCommand, GetString(NULL, styleCache, "rootCommand:", ""));
    if (strchr(rootCommand, '$')) ReplaceShellFolders(rootCommand);
 
    //====================
 
    // Wildcard settings... (nb. only a rudimentary top level implementation
    // due to the fact I *really* dislike the use of wildcards in styles... <sigh>)
    strcpy(wildcard, "Flat Solid");
    appearancePointer = wildcard;
 
    // First we fetch a few of the more common "non-dot" wildcards, e.g. *textColor...
    Wildcard->TextColor = GetColor(NULL, styleCache, "*textColor:", NULL, Wildcard->TextColor, true);
 
    strcpy(Wildcard->Font, GetString(NULL, styleCache, "*font:", Wildcard->Font));
    CheckFontSubstitution(Wildcard->Font);
    Wildcard->FontHeight = GetInt(NULL, styleCache, "*fontHeight:", Wildcard->FontHeight);
 
    strcpy(temp, GetString(NULL, styleCache, "*alignment:", "Center"));
    strcpy(temp, GetString(NULL, styleCache, "*justify:", temp));
    if (IsInString(temp, "Left")) Wildcard->Justify = DT_LEFT;
    else if (IsInString(temp, "Right")) Wildcard->Justify = DT_RIGHT;
    else Wildcard->Justify = DT_CENTER;
 
    Wildcard->borderWidth = GetInt(NULL, styleCache, "*borderWidth:", borderWidth); // "For all non-parent elements" [?]
    Wildcard->borderColor = GetColor(NULL, styleCache, "*borderColor:", NULL, borderColor, true);
    Wildcard->marginWidth = GetInt(NULL, styleCache, "*marginWidth:", marginWidth);
 
    // ...and use these as defaults for all "dotted" wildcards, e.g. *.textColor...
    ReadStyleElement(styleCache, Wildcard, "*", true);
 
    // Finally, a few odd birds thrown in just because I'm in a good mood... ;)
    strcpy(wildcardToolbarFont, GetString(NULL, styleCache, "toolbar*font:", Wildcard->Font));
    strcpy(wildcardMenuFont, GetString(NULL, styleCache, "menu*font:", Wildcard->Font));
    strcpy(wildcardWindowFont, GetString(NULL, styleCache, "window*font:", Wildcard->Font));
 
    //====================
 
    // Toolbar background
    strcpy(toolbar, "Flat Solid");
    appearancePointer = toolbar;
    CopyMemory(Toolbar, Wildcard, sizeof(StyleItem));
    Toolbar->Color = 0x000000;
    Toolbar->TextColor = 0xffffff;
    Toolbar->FontOutline = Toolbar->FontShadow = false;
    Toolbar->marginWidth = 1;
    Toolbar->borderWidth = borderWidth;
    strcpy(Toolbar->Font, wildcardToolbarFont);
    ReadStyleElement(styleCache, Toolbar, "toolbar", true);
 
    // If a console font is not defined in xoblite.rc, use the toolbar font as default...
    if (!consoleFontDefined)
    {
        strcpy(consoleFont, Toolbar->Font);
        consoleFontHeight = Toolbar->FontHeight;
        consoleFontWeight = Toolbar->FontWeight;
    }
 
    if (Toolbar->ShadowY > Toolbar->marginWidth) Toolbar->ShadowY = Toolbar->marginWidth;
 
    //====================
 
    // Toolbar workspace label
    strcpy(toolbarLabel, "ParentRelative");
    appearancePointer = toolbarLabel;
    CopyMemory(ToolbarLabel, Toolbar, sizeof(StyleItem));
    ToolbarLabel->FontOutline = ToolbarLabel->FontShadow = false;
    ToolbarLabel->borderWidth = Wildcard->borderWidth;
    ReadStyleElement(styleCache, ToolbarLabel, "toolbar.label", true);
 
    if (ToolbarLabel->ShadowY > ToolbarLabel->marginWidth) ToolbarLabel->ShadowY = ToolbarLabel->marginWidth;
 
    //====================
 
    // Toolbar window label
    strcpy(temp, GetString(NULL, styleCache, "toolbar.windowLabel.appearance:", ""));
    if (!strlen(temp)) strcpy(temp, GetString(NULL, styleCache, "toolbar.windowLabel:", ""));
 
    if (strlen(temp))
    {
        strcpy(toolbarWindowLabel, "Flat Solid");
        appearancePointer = toolbarWindowLabel;
        CopyMemory(ToolbarWindowLabel, Toolbar, sizeof(StyleItem));
        ToolbarWindowLabel->FontOutline = ToolbarWindowLabel->FontShadow = false;
        ToolbarWindowLabel->borderWidth = Wildcard->borderWidth;
        ToolbarWindowLabel->marginWidth = ToolbarLabel->marginWidth;
        ReadStyleElement(styleCache, ToolbarWindowLabel, "toolbar.windowLabel", true);
    }
    else
    {
        // Use workspace label settings if window label isn't defined... (applicable to some old 0.5x styles)
        strcpy(toolbarWindowLabel, toolbarLabel);
        CopyMemory(ToolbarWindowLabel, ToolbarLabel, sizeof(StyleItem));
    }
 
    if (ToolbarWindowLabel->ShadowY > ToolbarWindowLabel->marginWidth) ToolbarWindowLabel->ShadowY = ToolbarWindowLabel->marginWidth;
 
    //====================
 
    // Toolbar clock
    strcpy(toolbarClock, "ParentRelative");
    appearancePointer = toolbarClock;
    CopyMemory(ToolbarClock, Toolbar, sizeof(StyleItem));
    ToolbarClock->FontOutline = ToolbarClock->FontShadow = false;
    ToolbarClock->marginWidth = ToolbarLabel->marginWidth;
    ToolbarClock->borderWidth = Wildcard->borderWidth;
    ReadStyleElement(styleCache, ToolbarClock, "toolbar.clock", true);
 
    if (ToolbarClock->ShadowY > ToolbarClock->marginWidth) ToolbarClock->ShadowY = ToolbarClock->marginWidth;
 
    //====================
 
    // Toolbar text
    if (!strlen(GetString(NULL, styleCache, "toolbar.textColor:", "")))
    {
        if (!strlen(GetString(NULL, styleCache, "*textColor:", "")))
        {
            if (ToolbarWindowLabel->parentRelative) Toolbar->TextColor = ToolbarWindowLabel->TextColor;
            else if (ToolbarLabel->parentRelative) Toolbar->TextColor = ToolbarLabel->TextColor;
            else if (ToolbarClock->parentRelative) Toolbar->TextColor = ToolbarClock->TextColor;
            else Toolbar->TextColor = ToolbarWindowLabel->TextColor;
        }
        else Toolbar->TextColor = GetColor(NULL, styleCache, "*textColor:", NULL, Wildcard->TextColor, true);
    }
    else Toolbar->TextColor = GetColor(NULL, styleCache, "toolbar.textColor:", NULL, Wildcard->TextColor, true);
 
//  if (toolbarFontHeight > 12) Toolbar->FontHeight = toolbarFontHeight = 12;
 
    //====================
 
    // Toolbar buttons in non-pressed state...
    strcpy(toolbarButton, "Flat Solid");
    appearancePointer = toolbarButton;
    ToolbarButton->Color = 0x444444;
    ToolbarButton->PicColor = Toolbar->TextColor;
    ToolbarButton->borderColor = Toolbar->borderColor;
    ToolbarButton->borderWidth = Wildcard->borderWidth;
    ToolbarButton->marginWidth = 2;
    bb4nix070syntax = ReadStyleElement(styleCache, ToolbarButton, "toolbar.button", false);
 
//  tempColor = GetColor(NULL, styleCache, "toolbar.button.foregroundColor:", NULL, Toolbar->TextColor, true);
//  ToolbarButton->PicColor = GetColor(NULL, styleCache, "toolbar.button.picColor:", NULL, tempColor, true);
 
    //====================
 
    // Toolbar buttons in pressed state...
    strcpy(toolbarButtonPressed, "Flat Solid");
    appearancePointer = toolbarButtonPressed;
    CopyMemory(ToolbarButtonPressed, ToolbarButton, sizeof(StyleItem));
    ToolbarButtonPressed->Color = 0x222222;
    ToolbarButtonPressed->borderColor = Toolbar->borderColor;
    ToolbarButtonPressed->borderWidth = Wildcard->borderWidth;
    ToolbarButtonPressed->marginWidth = 2;
    bb4nix070syntax = ReadStyleElement(styleCache, ToolbarButtonPressed, "toolbar.button.pressed", false);
 
//  tempColor = GetColor(NULL, styleCache, "toolbar.button.pressed.foregroundColor:", NULL, ToolbarButton->PicColor, true);
//  ToolbarButtonPressed->PicColor = GetColor(NULL, styleCache, "toolbar.button.pressed.picColor:", NULL, tempColor, true);
 
    //====================
 
    // Toolbar gradient-style borders... (experimental from xoblite bb5 RC4)
    if (strlen(GetString(NULL, styleCache, "toolbar.border.", ""))) // toolbar.border defined?
    {
        strcpy(toolbarBorder, "");
        appearancePointer = toolbarBorder;
        ReadStyleElement(styleCache, ToolbarBorder, "toolbar.border", false);
    }
    else ToolbarBorder->parentRelative = true; // Disable toolbar gradient-style borders...
 
    //====================
 
    menuBorderColor = GetColor(NULL, styleCache, "menu.borderColor:", NULL, Wildcard->borderColor, true);
    menuBorderWidth = GetInt(NULL, styleCache, "menu.borderWidth:", borderWidth);
 
    // Menu title...
    strcpy(menuTitle, "Flat Solid");
    appearancePointer = menuTitle;
    CopyMemory(MenuTitle, Wildcard, sizeof(StyleItem));
    MenuTitle->Color = 0x000000;
    MenuTitle->TextColor = Wildcard->TextColor;
    MenuTitle->borderColor = menuBorderColor;
    MenuTitle->borderWidth = menuBorderWidth;
    MenuTitle->marginWidth = marginWidth;
    strcpy(MenuTitle->Font, wildcardMenuFont);
    MenuTitle->FontOutline = MenuTitle->FontShadow = false;
    ReadStyleElement(styleCache, MenuTitle, "menu.title", true);
 
    if (MenuTitle->ShadowY > MenuTitle->marginWidth) MenuTitle->ShadowY = MenuTitle->marginWidth;
 
    //====================
 
    // Menu frame...
    strcpy(menuFrame, "Flat Solid");
    appearancePointer = menuFrame;
    CopyMemory(MenuFrame, MenuTitle, sizeof(StyleItem));
    MenuFrame->Color = 0x000000;
    MenuFrame->TextColor = Wildcard->TextColor;
    MenuFrame->borderColor = menuBorderColor;
    MenuFrame->borderWidth = menuBorderWidth;
    MenuFrame->marginWidth = marginWidth;
    strcpy(MenuFrame->Font, wildcardMenuFont);
    MenuFrame->FontHeight = Wildcard->FontHeight;
    MenuFrame->Justify = Wildcard->Justify;
    MenuFrame->FontOutline = MenuFrame->FontShadow = false;
    ReadStyleElement(styleCache, MenuFrame, "menu.frame", true);
 
    tempColor = GetColor(NULL, styleCache, "menu.frame.foregroundColor:", NULL, MenuFrame->TextColor, true);
    MenuFrame->BulletColor = GetColor(NULL, styleCache, "menu.frame.bulletColor:", NULL, tempColor, true);
 
    // Optional menu frame gradient-style borders... (experimental from xoblite bb5 RC4)
    if (strlen(GetString(NULL, styleCache, "menu.frame.border.", ""))) // menu.border defined?
    {
        strcpy(menuFrameBorder, "");
        appearancePointer = menuFrameBorder;
        ReadStyleElement(styleCache, MenuFrameBorder, "menu.frame.border", false);
    }
    else MenuFrameBorder->parentRelative = true; // Disable menu gradient-style borders...
 
    //====================
 
    // Highlighted/active menu items
    // (first parse any menu.hilite [classic syntax] settings, then any menu.active [0.70 syntax] settings,
    // i.e. the latter having priority if a parameter has been defined twice using both syntaxes...)
    strcpy(menuActive, "Flat Solid");
    appearancePointer = menuActive;
    CopyMemory(MenuActive, MenuFrame, sizeof(StyleItem));
    MenuActive->Color = MenuFrame->TextColor;
    MenuActive->TextColor = MenuFrame->Color;
    MenuActive->borderWidth = Wildcard->borderWidth;
    MenuActive->marginWidth = marginWidth;
    MenuActive->FontOutline = MenuActive->FontShadow = false;
//  strcpy(temp, GetString(NULL, styleCache, "menu.active", ""));
//  if (strlen(temp)) bb4nix070syntax = ReadStyleElement(styleCache, MenuActive, "menu.active", true);
//  else bb4nix070syntax = ReadStyleElement(styleCache, MenuActive, "menu.hilite", true);
    bb4nix070syntax = ReadStyleElement(styleCache, MenuActive, "menu.hilite", true); // Try looking for menu.hilite parameters first...
    bb4nix070syntax = ReadStyleElement(styleCache, MenuActive, "menu.active", true); // ...then overload menu.active on top of menu.hilite to allow for accidentally mixed syntax parameters... (yeah it does happen every now and then ;))
 
    MenuActive->BulletColor = GetColor(NULL, styleCache, "menu.hilite.bulletColor:", NULL, MenuActive->TextColor, true);
    tempColor = GetColor(NULL, styleCache, "menu.active.foregroundColor:", NULL, MenuActive->BulletColor, true);
    MenuActive->BulletColor = GetColor(NULL, styleCache, "menu.active.bulletColor:", NULL, tempColor, true);
 
    if (MenuActive->parentRelative)
    {
        MenuActive->type = B_PARENTRELATIVE;
        MenuActive->Color = MenuFrame->Color;
        MenuActive->ColorTo = MenuFrame->ColorTo;
    }
 
    if (MenuActive->ShadowY > MenuActive->marginWidth) MenuActive->ShadowY = MenuActive->marginWidth;
 
    //====================
 
    // Submenu bullet style+position for menu.frame and menu.active folder items... (nb. non-image bullet colours are parsed above for both of them)
    strcpy(temp, GetString(NULL, styleCache, "menu.bullet:", "Triangle")); // -> Legacy style syntax (for backwards compatibility)
    strcpy(menuFrameBulletAsString, GetString(NULL, styleCache, "menu.frame.bullet:", temp)); // -> Modern style syntax (for more flexibility)
 
    if (strchr(menuFrameBulletAsString, '.') || strchr(menuFrameBulletAsString, '\\')) // -> We detect whether a menu bullet image path has been specified by checking for an "only-in-a-path" character (. or \‍) in the style parameter string...
    {
        menuBullet = MENU_BULLET_IMAGE;
 
        if (strchr(menuFrameBulletAsString, '\"')) StrRemoveEncap(menuFrameBulletAsString);
        if (strchr(menuFrameBulletAsString, '$')) ReplaceShellFolders(menuFrameBulletAsString);
        if (strchr(menuFrameBulletAsString, '%')) ReplaceEnvVars(menuFrameBulletAsString);
        if (FileExists(menuFrameBulletAsString))
        {
//          strncpy(MenuFrameBullet->Image.path, menuFrameBulletAsString, MAX_PATH);
            strncpy_s(MenuFrameBullet->Image.path, sizeof(MenuFrameBullet->Image.path), menuFrameBulletAsString, _TRUNCATE);
            CreateElementImage(MenuFrameBullet);
        }
 
        // Below: A separate menu.active bullet image is optional, i.e. if not defined
        // the menu.bullet/menu.frame.bullet one is used also for menu.active bullets...
        strcpy(menuActiveBulletAsString, GetString(NULL, styleCache, "menu.active.bullet:", menuFrameBulletAsString));
        if (strchr(menuActiveBulletAsString, '\"')) StrRemoveEncap(menuActiveBulletAsString);
        if (strchr(menuActiveBulletAsString, '$')) ReplaceShellFolders(menuActiveBulletAsString);
        if (strchr(menuActiveBulletAsString, '%')) ReplaceEnvVars(menuActiveBulletAsString);
        if (FileExists(menuActiveBulletAsString))
        {
//          strncpy(MenuActiveBullet->Image.path, menuActiveBulletAsString, MAX_PATH);
            strncpy_s(MenuActiveBullet->Image.path, sizeof(MenuActiveBullet->Image.path), menuActiveBulletAsString, _TRUNCATE);
            CreateElementImage(MenuActiveBullet);
        }
    }
    else if ((!_stricmp(menuFrameBulletAsString, "triangle")) || (!_stricmp(temp, "arrow"))) menuBullet = MENU_BULLET_TRIANGLE;
    else if (!_stricmp(menuFrameBulletAsString, "square")) menuBullet = MENU_BULLET_SQUARE;
    else if (!_stricmp(menuFrameBulletAsString, "diamond")) menuBullet = MENU_BULLET_DIAMOND;
    else if (!_stricmp(menuFrameBulletAsString, "circle")) menuBullet = MENU_BULLET_CIRCLE;
    else if (!_stricmp(menuFrameBulletAsString, "triple")) menuBullet = MENU_BULLET_TRIPLE;
    else if (!_stricmp(menuFrameBulletAsString, "comment")) menuBullet = MENU_BULLET_COMMENT;
    else if (!_stricmp(menuFrameBulletAsString, "grid")) menuBullet = MENU_BULLET_GRID;
    else if (!_stricmp(menuFrameBulletAsString, "quad")) menuBullet = MENU_BULLET_QUAD;
    else if (!_stricmp(menuFrameBulletAsString, "bitmap"))
    {
        // Unsupported: bbLean used to allow small bitmaps to be used as simple one-colour menu bullet "masks",
        // while xoblite nowadays support much more flexible ARGB images as frame/active bullets, see above.
        menuBullet = MENU_BULLET_TRIANGLE; // -> Fallback to triangle bullets...
    }
    else menuBullet = MENU_BULLET_EMPTY;
 
    strcpy(menuBulletPosition, GetString(NULL, styleCache, "menu.bullet.position:", "Right"));
 
    // Menu "indicators" for boolean items... (introduced in xoblite bb1)
    if (MenuActive->parentRelative)
    {
        CopyMemory(MenuIndicator, MenuTitle, sizeof(StyleItem));
        strcpy(menuIndicator, menuTitle);
    }
    else
    {
        CopyMemory(MenuIndicator, MenuActive, sizeof(StyleItem));
        strcpy(menuIndicator, menuActive);
    }
    appearancePointer = menuIndicator;
    ReadStyleElement(styleCache, MenuIndicator, "menu.indicator", false);
 
    // Menu separators... (originally introduced in xoblite bb2, later evolved further)
//  tempColor = GetColor(NULL, styleCache, "menu.separator.foregroundColor:", NULL, MenuFrame->TextColor, true);
//  MenuSeparator->Color = GetColor(NULL, styleCache, "menu.separator.color:", NULL, tempColor, true);
 
    strcpy(menuSeparator, "Flat Gradient MirrorHorizontal");
    appearancePointer = menuSeparator;
    CopyMemory(MenuSeparator, MenuFrame, sizeof(StyleItem));
    MenuSeparator->type = B_MIRRORHORIZONTAL;
    MenuSeparator->bevelstyle = BEVEL_FLAT;
    MenuSeparator->marginWidth = 1;
 
    if (!strlen(GetString(NULL, styleCache, "menu.separator.appearance:", ""))) // No separator appearance defined -> Legacy separators mode
    {
        if (strlen(GetString(NULL, styleCache, "menu.separator.shadowColor:", "")))
        {
            MenuSeparator->FontShadow = true;
            MenuSeparator->Color1 = MenuFrame->Color1;
            MenuSeparator->Color2 = GetColor(NULL, styleCache, "menu.separator.color:", NULL, MenuFrame->TextColor, true);
            MenuSeparator->ShadowColor = GetColor(NULL, styleCache, "menu.separator.shadowColor:", NULL, MenuFrame->Color, true);
            MenuSeparator->ShadowX = GetInt(NULL, styleCache, "menu.separator.shadowX:", 1);
            MenuSeparator->ShadowY = GetInt(NULL, styleCache, "menu.separator.shadowY:", 1);
        }
        else
        {
            MenuSeparator->Color1 = MenuFrame->Color1;
            tempColor = GetColor(NULL, styleCache, "menu.separator.foregroundColor:", NULL, MenuFrame->TextColor, true);
            MenuSeparator->Color2 = GetColor(NULL, styleCache, "menu.separator.color:", NULL, tempColor, true);
        }
    }
    else // Separator appearance defined -> Advanced separators mode (e.g. up to 8 colours etc)
    {
        MenuSeparator->Color1 = GetColor(NULL, styleCache, "menu.separator.foregroundColor:", NULL, MenuFrame->TextColor, true);
        MenuSeparator->Color2 = MenuSeparator->Color3 = MenuSeparator->Color4 = MenuSeparator->Color5 = MenuSeparator->Color6 = MenuSeparator->Color7 = MenuSeparator->Color8 = MenuSeparator->Color1;
//      ReadStyleElement(styleCache, MenuSeparator, "menu.separator", false);
        ReadStyleElement(styleCache, MenuSeparator, "menu.separator", true); // Note: Boolean true only in order to read shadowColor etc (normally part of the font related parsing)
 
        switch (MenuSeparator->type)
        {
            case B_SUPERHORIZONTAL:
            case B_SPLITHORIZONTAL:
            case B_MIRRORHORIZONTAL:
            case B_HORIZONTAL:
            case B_SOLID:
            case B_SPLITSOLID:
            {
                break;
            }
 
            case B_SUPERVERTICAL: { MenuSeparator->type = B_SUPERHORIZONTAL; break; }
            case B_SPLITVERTICAL: { MenuSeparator->type = B_SPLITHORIZONTAL; break; }
            case B_VERTICAL: { MenuSeparator->type = B_HORIZONTAL; break; }
 
            default: { MenuSeparator->type = B_MIRRORHORIZONTAL; break; }
        }
    }
 
    if (MenuSeparator->ShadowX > 3) MenuSeparator->ShadowX = 3;
    else if (MenuSeparator->ShadowX < -3) MenuSeparator->ShadowX = -3;
    if (MenuSeparator->ShadowY > 3) MenuSeparator->ShadowY = 3;
    else if (MenuSeparator->ShadowY < -3) MenuSeparator->ShadowY = -3;
 
    //====================
 
    // Menu grip... (introduced in xoblite bb4 RC4)
    if (strlen(GetString(NULL, styleCache, "menu.grip", ""))) // menu.grip defined?
    {
        strcpy(menuGrip, "");
        appearancePointer = menuGrip;
        CopyMemory(MenuGrip, MenuTitle, sizeof(StyleItem));
        MenuGrip->marginWidth = MenuGrip->FontHeight = 0;
        MenuGrip->FontOutline = MenuGrip->FontShadow = false;
        ReadStyleElement(styleCache, MenuGrip, "menu.grip", true);
 
//      MenuGrip->parentRelative = false; // Enable menu grips...
        if (MenuGrip->ShadowY > MenuGrip->marginWidth) MenuGrip->ShadowY = MenuGrip->marginWidth;
    }
    else MenuGrip->parentRelative = true; // Disable menu grips...
 
    //====================
 
    // Dock...
    strcpy(dock, toolbar); // Default dock styling == Inherit toolbar styling
    appearancePointer = dock;
    CopyMemory(Dock, Toolbar, sizeof(StyleItem));
    ReadStyleElement(styleCache, Dock, "slit", false); // -> Backwards compatible with old slit.* style entries
    ReadStyleElement(styleCache, Dock, "dock", false);
 
    // Dock gradient-style borders... (experimental from xoblite bb5 RC4)
    if (strlen(GetString(NULL, styleCache, "dock.border.", ""))) // dock.border defined?
    {
        strcpy(dockBorder, "");
        appearancePointer = dockBorder;
        ReadStyleElement(styleCache, DockBorder, "dock.border", false);
    }
    else DockBorder->parentRelative = true; // Disable dock gradient-style borders...
 
    //====================
 
    // Taskbar active, non-active and flashing task buttons... (-> derived from other style elements, so also need to be updated dynamically on Designer Mode changes, hence the separate function)
    DeriveTaskbarStyle();
 
    //====================
 
    // Console...
    strcpy(console, toolbar);
    appearancePointer = console;
    CopyMemory(Console, Toolbar, sizeof(StyleItem));
    Console->Color = 0x000000;
    Console->TextColor = 0xffffff;
    strcpy(Console->Font, consoleFont);
    CheckFontSubstitution(Console->Font);
    Console->FontHeight = consoleFontHeight;
    Console->FontWeight = consoleFontWeight;
    Console->FontOutline = Console->FontShadow = false;
    ReadStyleElement(styleCache, Console, "console", true);
 
    Console->PicColor = GetColor(NULL, styleCache, "console.buttonColor:", NULL, Console->TextColor, true);
 
    //====================
 
    // Window title...
    strcpy(windowTitleFocus, toolbar);
    appearancePointer = windowTitleFocus;
    CopyMemory(WindowTitleFocus, Toolbar, sizeof(StyleItem));
    if (!ToolbarBorder->parentRelative) WindowTitleFocus->borderColor = ToolbarBorder->Color1; // -> Toolbar uses gradient borders, which are not (yet?) supported for WindowTitles, so let's use an approximation as default-if-not-defined borderColor...
    ReadStyleElement(styleCache, WindowTitleFocus, "window.title.focus", false);
 
    strcpy(windowTitleUnfocus, windowTitleFocus);
    appearancePointer = windowTitleUnfocus;
    CopyMemory(WindowTitleUnfocus, WindowTitleFocus, sizeof(StyleItem));
    ReadStyleElement(styleCache, WindowTitleUnfocus, "window.title.unfocus", false);
 
    // Window label...
    strcpy(windowLabelFocus, toolbarWindowLabel);
    appearancePointer = windowLabelFocus;
    CopyMemory(WindowLabelFocus, ToolbarWindowLabel, sizeof(StyleItem));
    strcpy(WindowLabelFocus->Font, wildcardWindowFont);
    ReadStyleElement(styleCache, WindowLabelFocus, "window.label.focus", true);
 
    strcpy(windowLabelUnfocus, windowLabelFocus);
    appearancePointer = windowLabelUnfocus;
    CopyMemory(WindowLabelUnfocus, WindowLabelFocus, sizeof(StyleItem));
    ReadStyleElement(styleCache, WindowLabelUnfocus, "window.label.unfocus", true);
 
    // Window buttons...
    strcpy(windowButtonFocus, toolbarButton);
    appearancePointer = windowButtonFocus;
    CopyMemory(WindowButtonFocus, ToolbarButton, sizeof(StyleItem));
    strcpy(WindowButtonFocus->Font, WindowLabelFocus->Font); // Since it can be of interest to have further "window" options, we create a hybrid of WindowButtonFocus colours etc and WindowLabelFocus font settings here...
//  CheckFontSubstitution(WindowButtonFocus->Font);
    WindowButtonFocus->FontHeight = WindowLabelFocus->FontHeight;
    WindowButtonFocus->FontWeight = WindowLabelFocus->FontWeight;
    WindowButtonFocus->TextColor = WindowButtonFocus->PicColor;
    WindowButtonFocus->FontOutline = WindowButtonFocus->FontShadow = false;
    ReadStyleElement(styleCache, WindowButtonFocus, "window.button.focus", false);
 
    strcpy(windowButtonUnfocus, windowButtonFocus);
    appearancePointer = windowButtonUnfocus;
    CopyMemory(WindowButtonUnfocus, WindowButtonFocus, sizeof(StyleItem));
    strcpy(WindowButtonUnfocus->Font, WindowLabelUnfocus->Font); // ...ditto above...
//  CheckFontSubstitution(WindowButtonUnfocus->Font);
    WindowButtonUnfocus->FontHeight = WindowLabelUnfocus->FontHeight;
    WindowButtonUnfocus->FontWeight = WindowLabelUnfocus->FontWeight;
    WindowButtonUnfocus->TextColor = WindowButtonUnfocus->PicColor;
    WindowButtonUnfocus->FontOutline = WindowButtonUnfocus->FontShadow = false;
    ReadStyleElement(styleCache, WindowButtonUnfocus, "window.button.unfocus", false);
 
    strcpy(windowButtonPressed, toolbarButtonPressed);
    appearancePointer = windowButtonPressed;
    CopyMemory(WindowButtonPressed, ToolbarButtonPressed, sizeof(StyleItem));
    strcpy(WindowButtonPressed->Font, WindowButtonFocus->Font); // ...ditto above...
//  CheckFontSubstitution(WindowButtonPressed->Font);
    WindowButtonPressed->FontHeight = WindowButtonFocus->FontHeight;
    WindowButtonPressed->FontWeight = WindowButtonFocus->FontWeight;
    WindowButtonPressed->TextColor = WindowButtonPressed->PicColor;
    WindowButtonPressed->FontOutline = WindowButtonPressed->FontShadow = false;
    ReadStyleElement(styleCache, WindowButtonPressed, "window.button.pressed", false);
 
    // Window grips...
    strcpy(windowGripFocus, windowTitleFocus);
    appearancePointer = windowGripFocus;
    CopyMemory(WindowGripFocus, WindowTitleFocus, sizeof(StyleItem));
    ReadStyleElement(styleCache, WindowGripFocus, "window.grip.focus", false);
 
    strcpy(windowGripUnfocus, windowGripFocus);
    appearancePointer = windowGripUnfocus;
    CopyMemory(WindowGripUnfocus, WindowGripFocus, sizeof(StyleItem));
    ReadStyleElement(styleCache, WindowGripUnfocus, "window.grip.unfocus", false);
 
    // Window handle...
    strcpy(windowHandleFocus, windowTitleFocus);
    appearancePointer = windowHandleFocus;
    CopyMemory(WindowHandleFocus, WindowTitleFocus, sizeof(StyleItem));
    ReadStyleElement(styleCache, WindowHandleFocus, "window.handle.focus", false);
 
    strcpy(windowHandleUnfocus, windowHandleFocus);
    appearancePointer = windowHandleUnfocus;
    CopyMemory(WindowHandleUnfocus, WindowHandleFocus, sizeof(StyleItem));
    ReadStyleElement(styleCache, WindowHandleUnfocus, "window.handle.unfocus", false);
 
    //====================
 
    // External RGB hardware... (used e.g. by plugins like xControlRGB-Corsair, xControlRGB-LIFX, etc)
    strcpy(externalHardware, toolbarWindowLabel);
    appearancePointer = externalHardware;
    CopyMemory(ExternalHardware, ToolbarWindowLabel, sizeof(StyleItem));
    ReadStyleElement(styleCache, ExternalHardware, "hardware", false);
 
    //====================
 
    // Text shadows (introduced in xoblite bb2)
/*
    if (ToolbarLabel->parentRelative) toolbarLabelShadowColor = CreateShadowColor(Toolbar, Toolbar->Color, Toolbar->ColorTo, ToolbarLabel->TextColor);
    else toolbarLabelShadowColor = CreateShadowColor(ToolbarLabel, ToolbarLabel->Color, ToolbarLabel->ColorTo, ToolbarLabel->TextColor);
    if (ToolbarWindowLabel->parentRelative) toolbarWindowLabelShadowColor = CreateShadowColor(Toolbar, Toolbar->Color, Toolbar->ColorTo, ToolbarWindowLabel->TextColor);
    else toolbarWindowLabelShadowColor = CreateShadowColor(ToolbarWindowLabel, ToolbarWindowLabel->Color, ToolbarWindowLabel->ColorTo, ToolbarWindowLabel->TextColor);
    if (ToolbarClock->parentRelative) toolbarClockShadowColor = CreateShadowColor(Toolbar, Toolbar->Color, Toolbar->ColorTo, ToolbarClock->TextColor);
    else toolbarClockShadowColor = CreateShadowColor(ToolbarClock, ToolbarClock->Color, ToolbarClock->ColorTo, ToolbarClock->TextColor);
 
    menuTitleShadowColor = CreateShadowColor(MenuTitle, MenuTitle->Color, MenuTitle->ColorTo, MenuTitle->TextColor);
    menuFrameShadowColor = CreateShadowColor(MenuFrame, MenuFrame->Color, MenuFrame->ColorTo, MenuFrame->TextColor);
    if (MenuActive->parentRelative) menuActiveShadowColor = CreateShadowColor(MenuFrame, MenuFrame->Color, MenuFrame->ColorTo, MenuActive->TextColor);
    else menuActiveShadowColor = CreateShadowColor(MenuActive, MenuActive->Color, MenuActive->ColorTo, MenuActive->TextColor);
*/
    //====================
 
    // Finally, a few really old style settings... (nb. for legacy compatibility only -> not intended for general use today -> "pending removal at any time")
 
    if (strlen(GetString(NULL, styleCache, "titleFont:", "")))
    {
        strcpy(MenuTitle->Font, GetString(NULL, styleCache, "titleFont:", MenuTitle->Font));
        CheckFontSubstitution(MenuTitle->Font);
    }
 
    if (strlen(GetString(NULL, styleCache, "menuFont:", "")))
    {
        strcpy(MenuFrame->Font, GetString(NULL, styleCache, "menuFont:", MenuFrame->Font));
        CheckFontSubstitution(MenuFrame->Font);
    }
 
    if (strlen(GetString(NULL, styleCache, "titleJustify:", "")))
    {
        strcpy(temp, GetString(NULL, styleCache, "titleJustify:", ""));
        if (IsInString(temp, "Left")) MenuTitle->Justify = DT_LEFT;
        else if (IsInString(temp, "Right")) MenuTitle->Justify = DT_RIGHT;
        else if (IsInString(temp, "Center")) MenuTitle->Justify = DT_CENTER;
    }
 
    if (strlen(GetString(NULL, styleCache, "menuJustify:", "")))
    {
        strcpy(temp, GetString(NULL, styleCache, "menuJustify:", ""));
        if (IsInString(temp, "Left")) MenuFrame->Justify = DT_LEFT;
        else if (IsInString(temp, "Right")) MenuFrame->Justify = DT_RIGHT;
        else if (IsInString(temp, "Center")) MenuFrame->Justify = DT_CENTER;
    }
 
    if (strlen(GetString(NULL, styleCache, "menu.frame.highlightColor:", "")))
    {
        MenuActive->Color = GetColor(NULL, styleCache, "menu.frame.highlightColor:", "#303030", NULL, false);
        MenuActive->ColorTo = MenuActive->Color;
    }
 
    if (strlen(GetString(NULL, styleCache, "menu.frame.hiTextColor:", "")))
        MenuActive->TextColor = GetColor(NULL, styleCache, "menu.frame.hiTextColor:", NULL, Wildcard->TextColor, true);
 
    if (strlen(GetString(NULL, styleCache, "menu.bulletStyle:", "")))
        strcpy(menuFrameBulletAsString, GetString(NULL, styleCache, "menu.bulletStyle:", menuFrameBulletAsString));
 
    if (strlen(GetString(NULL, styleCache, "menu.bulletPosition:", "")))
        strcpy(menuBulletPosition, GetString(NULL, styleCache, "menu.bulletPosition:", menuBulletPosition));
 
    //====================
 
    // ###########################################################################################
    // ##### Below: xoblite bb5 introduces support for UI scaling for *HiDPI* displays!!! :D #####
    // ##### (i.e. user configurable "Regular scale" Non-HiDPI 1x / "Double scale" HiDPI 2x) #####
    // ###########################################################################################
 
    if (scalingFactorHiDPI > 1)
    {
        borderWidth *= scalingFactorHiDPI;
        menuBorderWidth *= scalingFactorHiDPI;
        bevelWidth *= scalingFactorHiDPI;
        marginWidth *= scalingFactorHiDPI;
        handleHeight *= scalingFactorHiDPI;
        frameWidth *= scalingFactorHiDPI;
 
        if (MenuTitle->FontHeight >= 2) MenuTitle->FontHeight *= scalingFactorHiDPI;
        MenuFrame->FontHeight *= scalingFactorHiDPI;
        MenuActive->FontHeight *= scalingFactorHiDPI;
        if (MenuGrip->FontHeight >= 2) MenuGrip->FontHeight *= scalingFactorHiDPI;
        Toolbar->FontHeight *= scalingFactorHiDPI;
        ToolbarLabel->FontHeight *= scalingFactorHiDPI;
        ToolbarWindowLabel->FontHeight *= scalingFactorHiDPI;
        ToolbarClock->FontHeight *= scalingFactorHiDPI;
        Console->FontHeight *= scalingFactorHiDPI;
        Dock->FontHeight *= scalingFactorHiDPI;
        WindowLabelFocus->FontHeight *= scalingFactorHiDPI;
        WindowLabelUnfocus->FontHeight *= scalingFactorHiDPI;
 
        if (MenuTitle->borderWidth > 0) MenuTitle->borderWidth *= scalingFactorHiDPI;
        if (MenuFrame->borderWidth > 0) MenuFrame->borderWidth *= scalingFactorHiDPI;
        if (MenuActive->borderWidth > 0) MenuActive->borderWidth *= scalingFactorHiDPI;
        if (MenuGrip->borderWidth > 0) MenuGrip->borderWidth *= scalingFactorHiDPI;
        if (MenuSeparator->borderWidth > 0) MenuSeparator->borderWidth *= scalingFactorHiDPI; // TBD
        if (Toolbar->borderWidth > 0) Toolbar->borderWidth *= scalingFactorHiDPI;
        if (ToolbarLabel->borderWidth > 0) ToolbarLabel->borderWidth *= scalingFactorHiDPI;
        if (ToolbarWindowLabel->borderWidth > 0) ToolbarWindowLabel->borderWidth *= scalingFactorHiDPI;
        if (ToolbarClock->borderWidth > 0) ToolbarClock->borderWidth *= scalingFactorHiDPI;
        if (ToolbarButton->borderWidth > 0) ToolbarButton->borderWidth *= scalingFactorHiDPI;
        if (ToolbarButtonPressed->borderWidth > 0) ToolbarButtonPressed->borderWidth *= scalingFactorHiDPI;
        if (Dock->borderWidth > 0) Dock->borderWidth *= scalingFactorHiDPI;
        if (WindowTitleFocus->borderWidth > 0) WindowTitleFocus->borderWidth *= scalingFactorHiDPI;
        if (WindowTitleUnfocus->borderWidth > 0) WindowTitleUnfocus->borderWidth *= scalingFactorHiDPI;
        if (WindowLabelFocus->borderWidth > 0) WindowLabelFocus->borderWidth *= scalingFactorHiDPI;
        if (WindowLabelUnfocus->borderWidth > 0) WindowLabelUnfocus->borderWidth *= scalingFactorHiDPI;
        if (WindowButtonFocus->borderWidth > 0) WindowButtonFocus->borderWidth *= scalingFactorHiDPI;
        if (WindowButtonUnfocus->borderWidth > 0) WindowButtonUnfocus->borderWidth *= scalingFactorHiDPI;
        if (WindowButtonPressed->borderWidth > 0) WindowButtonPressed->borderWidth *= scalingFactorHiDPI;
        if (WindowGripFocus->borderWidth > 0) WindowGripFocus->borderWidth *= scalingFactorHiDPI;
        if (WindowGripUnfocus->borderWidth > 0) WindowGripUnfocus->borderWidth *= scalingFactorHiDPI;
        if (WindowHandleFocus->borderWidth > 0) WindowHandleFocus->borderWidth *= scalingFactorHiDPI;
        if (WindowHandleUnfocus->borderWidth > 0) WindowHandleUnfocus->borderWidth *= scalingFactorHiDPI;
 
        if (MenuTitle->marginWidth > 0) MenuTitle->marginWidth *= scalingFactorHiDPI;
        if (MenuFrame->marginWidth > 0) MenuFrame->marginWidth *= scalingFactorHiDPI;
        if (MenuActive->marginWidth > 0) MenuActive->marginWidth *= scalingFactorHiDPI;
        if (MenuGrip->marginWidth > 0) MenuGrip->marginWidth *= scalingFactorHiDPI;
        if (MenuSeparator->marginWidth > 0) MenuSeparator->marginWidth *= scalingFactorHiDPI; // TBD
        if (Toolbar->marginWidth > 0) Toolbar->marginWidth *= scalingFactorHiDPI;
        if (ToolbarLabel->marginWidth > 0) ToolbarLabel->marginWidth *= scalingFactorHiDPI;
        if (ToolbarWindowLabel->marginWidth > 0) ToolbarWindowLabel->marginWidth *= scalingFactorHiDPI;
        if (ToolbarClock->marginWidth > 0) ToolbarClock->marginWidth *= scalingFactorHiDPI;
        if (ToolbarButton->marginWidth > 0) ToolbarButton->marginWidth *= scalingFactorHiDPI;
        if (ToolbarButtonPressed->marginWidth > 0) ToolbarButtonPressed->marginWidth *= scalingFactorHiDPI;
        if (Dock->marginWidth > 0) Dock->marginWidth *= scalingFactorHiDPI;
        if (WindowTitleFocus->marginWidth > 0) WindowTitleFocus->marginWidth *= scalingFactorHiDPI;
        if (WindowTitleUnfocus->marginWidth > 0) WindowTitleUnfocus->marginWidth *= scalingFactorHiDPI;
        if (WindowLabelFocus->marginWidth > 0) WindowLabelFocus->marginWidth *= scalingFactorHiDPI;
        if (WindowLabelUnfocus->marginWidth > 0) WindowLabelUnfocus->marginWidth *= scalingFactorHiDPI;
        if (WindowButtonFocus->marginWidth > 0) WindowButtonFocus->marginWidth *= scalingFactorHiDPI;
        if (WindowButtonUnfocus->marginWidth > 0) WindowButtonUnfocus->marginWidth *= scalingFactorHiDPI;
        if (WindowButtonPressed->marginWidth > 0) WindowButtonPressed->marginWidth *= scalingFactorHiDPI;
        if (WindowGripFocus->marginWidth > 0) WindowGripFocus->marginWidth *= scalingFactorHiDPI;
        if (WindowGripUnfocus->marginWidth > 0) WindowGripUnfocus->marginWidth *= scalingFactorHiDPI;
        if (WindowHandleFocus->marginWidth > 0) WindowHandleFocus->marginWidth *= scalingFactorHiDPI;
        if (WindowHandleUnfocus->marginWidth > 0) WindowHandleUnfocus->marginWidth *= scalingFactorHiDPI;
 
        // Note: ShadowX+ShadowY offsets are re-calculated adaptively in BBApi.cpp DrawTextWithEffects() instead!
    }
 
    //====================
 
    // ### 20210521: Moved to MenuCommon::Configure(), kept here just for short term reference... (to be deleted) ###
 
    // Calculate submenu gap for rounded corner menus...
    // (nb. dependence toward the HiDPI adjustments calculated above, so order is important)
//  if (MenuFrame->borderWidth > 0) submenuGap = (MenuFrame->borderWidth * 2); // Note: Use borderWidth*2 due to how menu borders overlap for non-rounded menus!
//  else if (MenuFrame->marginWidth > 0) submenuGap = MenuFrame->marginWidth;
//  else if (scalingFactorHiDPI > 1) submenuGap = scalingFactorHiDPI * 2;
//  else submenuGap = 2;
 
    //====================
/*
    if (debugLogging)
    {
        if (Toolbar->FontShadow) Log("Toolbar shadows enabled!", "");
        else if (ToolbarLabel->FontShadow) Log("ToolbarLabel shadows enabled!", "");
        else if (ToolbarWindowLabel->FontShadow) Log("ToolbarWindowLabel shadows enabled!", "");
        else if (ToolbarClock->FontShadow) Log("ToolbarClock shadows enabled!", "");
        else if (MenuTitle->FontShadow) Log("MenuTitle shadows enabled!", "");
 
        if (Toolbar->FontOutline) Log("Toolbar outlines enabled!", "");
        else if (ToolbarLabel->FontOutline) Log("ToolbarLabel outlines enabled!", "");
        else if (ToolbarWindowLabel->FontOutline) Log("ToolbarWindowLabel outlines enabled!", "");
        else if (ToolbarClock->FontOutline) Log("ToolbarClock outlines enabled!", "");
        else if (MenuTitle->FontOutline) Log("MenuTitle outlines enabled!", "");
    }
*/
    //====================
 
    // Free memory allocated for the style buffer...
    DestroyFileCache(styleCache);
}

ReadStyleElement()

bool Settings::ReadStyleElement	(	LPSTR	styleBuffer,
		StyleItem *	styleItem,
		LPSTR	paramString,
		bool	readFont )

{
    char temp[MAX_LINE_LENGTH], param[MAX_LINE_LENGTH];
    bool bb4nix070syntax = false;
 
    strcpy(param, paramString);
    int nLen = strlen(param);
 
    //====================
 
    // Appearance... (i.e. flat/raised/sunken, solid/gradient, bevel type, etc)
    // (Note: The appearance *string* is later used also by the style memory caching mechanism;
    // hence we need to save it for later here even if not further used by the StyleItem parser below.)
    strcpy_s(&param[nLen], (sizeof(param)-nLen), ".appearance:");
    if (strlen(GetString(NULL, styleCache, param, ""))) bb4nix070syntax = true;
    strcpy(temp, GetString(NULL, styleCache, param, appearancePointer));
    strcpy_s(&param[nLen], (sizeof(param)-nLen), ":");
    strcpy_s(appearancePointer, MAX_LINE_LENGTH, GetString(NULL, styleCache, param, temp));
    ParseItem(appearancePointer, styleItem);
 
    //====================
 
    // Below: Any previously existing bitmap for this particular element have already been destroyed through a prior call to InitStyleItems() from ReadStyle() above,
    // but we may have inherited a pointer to another element's bitmap as part of a CopyMemory of its StyleItem information, and hence it's OK to set it back to NULL here.
    styleItem->Image.bitmap = NULL;
 
    // Is an image to be used instead of a regular *box gradient? (nb. we perform this check first to be able to fallback to the latter if needed)
    if (styleItem->type == B_IMAGEFROMFILE)
    {
        if (strchr(appearancePointer, '\\'))
        {
            // -> Image path specified directly in .appearance... (nb. the backslash character is not otherwise used in regular *box style .appearance strings)
//          strncpy(styleItem->Image.path, appearancePointer, MAX_PATH);
            strncpy_s(styleItem->Image.path, sizeof(styleItem->Image.path), appearancePointer, _TRUNCATE);
        }
        else
        {
            // -> Image path specified in separate .image parameter...
            strcpy_s(&param[nLen], (sizeof(param)-nLen), ".image:");
//          strncpy(styleItem->Image.path, GetString(NULL, styleCache, param, ""), MAX_PATH);
            strncpy_s(styleItem->Image.path, sizeof(styleItem->Image.path), GetString(NULL, styleCache, param, ""), _TRUNCATE);
 
//          if (strchr(appearancePointer, '/'))
//          {
//              SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)strchr(appearancePointer, '/'));
//          }
        }
        styleItem->Image.path[sizeof(styleItem->Image.path)-1] = '\0'; // Failsafe
 
        if (strchr(styleItem->Image.path, '\"')) StrRemoveEncap((LPSTR)styleItem->Image.path);
        if (strchr(styleItem->Image.path, '$')) ReplaceShellFolders((LPSTR)styleItem->Image.path);
        if (strchr(styleItem->Image.path, '%')) ReplaceEnvVars((LPSTR)styleItem->Image.path);
 
        styleItem->Image.width = styleItem->Image.height = styleItem->Image.left = styleItem->Image.top = styleItem->Image.right = styleItem->Image.bottom = 0; // ### TEMPORARY HERE, TO BE MOVED INTO IF() BELOW ###
 
        // ...if so, let's check if the image file exists.. (and if not, fallback to a solid background)
        if (FileExists(styleItem->Image.path))
        {
//          if (debugLogging) SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_WARNING_MESSAGE, (LPARAM)styleItem->Image.path);
            CreateElementImage(styleItem);
/*
            // 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 elsewhere here in MenuCommon.)
            wchar_t imagePathWC[MAX_PATH];
            MultiByteToWideChar(CP_ACP, 0, styleItem->Image.path, strlen(styleItem->Image.path)+1, imagePathWC, MAX_PATH);
            Bitmap* bitmap = new Bitmap(imagePathWC, FALSE);
            styleItem->Image.width = bitmap->GetWidth();
            styleItem->Image.height = bitmap->GetHeight();
//          SetRect(&menuImage->edges, 0, 0, 0, 0);
            if ((pf == PixelFormat32bppARGB) || (pf == PixelFormat32bppPARGB) || (pf == PixelFormat64bppARGB) || (pf == PixelFormat64bppPARGB)) styleItem->Image.argb = true;
            else styleItem->Image.argb = false;
            bitmap->GetHBITMAP(0, &styleItem->Image.bitmap); // Create our target GDI HBITMAP from the loaded GDI+ Bitmap...
            delete bitmap;
*/
        }
        else styleItem->type = B_SOLID; // Fallback
    }
 
    //====================
 
    // Border...
    strcpy_s(&param[nLen], (sizeof(param)-nLen), ".borderColor:");
    styleItem->borderColor = GetColor(NULL, styleCache, param, NULL, styleItem->borderColor, true);
    strcpy_s(&param[nLen], (sizeof(param)-nLen), ".borderWidth:");
    styleItem->borderWidth = GetInt(NULL, styleCache, param, styleItem->borderWidth);
 
    if (bb4nix070syntax)
    {
        if (IsInString(appearancePointer, "border")) // If the border tag is set we always draw the border, regardless of whether borderWidth was explicitly defined or inherited...
        {
            styleItem->bordered = true;
        }
        else
        {
            strcpy_s(&param[nLen], (sizeof(param)-nLen), ".borderWidth:");
            if (strlen(GetString(NULL, styleCache, param, ""))) // If borderWidth was explicitly defined for this element we disregard the border tag... (i.e. "forgiving" parsing)
            {
                styleItem->bordered = true;
            }
//          else // Do not draw the border if borderWidth was inherited and the border tag was not set...
//          {
//              styleItem->bordered = false;
//              styleItem->borderWidth = 0;
//          }
        }
    }
    else
    {
        if (styleItem->borderWidth > 0) styleItem->bordered = true;
//      else styleItem->bordered = false;
    }
 
//  if (IsInString(appearancePointer, "border")) styleItem->bordered = true;
//  else if (strlen(GetString(NULL, styleCache, param, ""))) styleItem->bordered = true;
 
    //====================
 
    // Margin...
    strcpy_s(&param[nLen], (sizeof(param)-nLen), ".marginWidth:");
    styleItem->marginWidth = GetInt(NULL, styleCache, param, styleItem->marginWidth);
 
    //====================
 
    // Colours...
 
    COLORREF tempColor;
 
    if (!strchr(appearancePointer, '\\') && IsInString(appearancePointer, "auto"))
    {
        COLORREF colorAutoPicked;
        int randomPixelX, randomPixelY;
        // srand((unsigned int)time(NULL)); // Provide a seed for pseudorandom number generation... (nb. this is already done in Blackbox.cpp, so not needed here!)
 
        RECT workArea;
        SystemParametersInfo(SPI_GETWORKAREA, 0, (PVOID)&workArea, SPIF_SENDCHANGE); // Get the dimensions of the screen's work area...
        int workAreaWidth = workArea.right - workArea.left;
        int workAreaHeight = workArea.bottom - workArea.top;
 
        HDC hdc = GetDC(GetDesktopWindow()); // Get the HDC of the Windows desktop window...
 
        for (int n = 1; n <= 8; n++)
        {
            randomPixelX = (rand() % workAreaWidth); // Select a random X position across the screen's work area width...
            randomPixelY = (rand() % workAreaHeight); // ..and a random Y position across the screen's work area height...
            colorAutoPicked = GetPixel(hdc, workArea.left+randomPixelX, workArea.top+randomPixelY); // Pick the colour of the pixel at the random X/Y position...
            if (colorAutoPicked == CLR_INVALID) continue; // Failsafe
 
            switch (n)
            {
                // ...for each of the up to 8 colours per style element...
                case 1: {styleItem->Color1 = colorAutoPicked; break; }
                case 2: {styleItem->Color2 = colorAutoPicked; break; }
                case 3: {styleItem->Color3 = colorAutoPicked; break; }
                case 4: {styleItem->Color4 = colorAutoPicked; break; }
                case 5: {styleItem->Color5 = colorAutoPicked; break; }
                case 6: {styleItem->Color6 = colorAutoPicked; break; }
                case 7: {styleItem->Color7 = colorAutoPicked; break; }
                case 8: {styleItem->Color8 = colorAutoPicked; break; }
            }
        }
 
        ReleaseDC(NULL, hdc);
        DeleteDC(hdc);
    }
    else
    {
        strcpy_s(&param[nLen], (sizeof(param)-nLen), ".backgroundColor:");
        tempColor = GetColor(NULL, styleCache, param, NULL, styleItem->Color1, true);
        strcpy_s(&param[nLen], (sizeof(param)-nLen), ".color1:");
        tempColor = GetColor(NULL, styleCache, param, NULL, tempColor, true);
        strcpy_s(&param[nLen], (sizeof(param)-nLen), ".color:");
        styleItem->Color1 = GetColor(NULL, styleCache, param, NULL, tempColor, true);
 
        if (styleItem->type == B_SOLID) styleItem->Color2 = styleItem->Color1; // (...just in case, cf. legacy 2-colour API aspects?)
        else
        {
            strcpy_s(&param[nLen], (sizeof(param)-nLen), ".color2:");
            tempColor = GetColor(NULL, styleCache, param, NULL, styleItem->Color2, true);
            strcpy_s(&param[nLen], (sizeof(param)-nLen), ".colorTo:");
            styleItem->Color2 = GetColor(NULL, styleCache, param, NULL, tempColor, true);
        }
 
        if ((styleItem->type >= B_SPLITHORIZONTAL) && (styleItem->type < B_MIRRORHORIZONTAL)) // 4-colour split or 8-colour super gradient being used?
        {
            strcpy_s(&param[nLen], (sizeof(param)-nLen), ".color.splitTo:");
            if (((styleItem->type == B_SPLITHORIZONTAL) || (styleItem->type == B_SPLITVERTICAL)) && strlen(GetString(NULL, styleCache, param, "")))
            {
                // -> The style is using the fugly old
                // 4-colour split gradient ".splitTo" syntax... :(
 
                styleItem->Color3 = styleItem->Color2;
                styleItem->Color2 = styleItem->Color1;
 
                int sr, sg, sb;
 
                sr = GetRValue(styleItem->Color2);
                sg = GetGValue(styleItem->Color2);
                sb = GetBValue(styleItem->Color2);
                sr += sr >> 2;
                sg += sg >> 2;
                sb += sb >> 2;
                if (sr>0xff) sr = 0xff;
                if (sg>0xff) sg = 0xff;
                if (sb>0xff) sb = 0xff;
                styleItem->Color1 = RGB(sr,sg,sb);
 
                sr  = GetRValue(styleItem->Color3);
                sg = GetGValue(styleItem->Color3);
                sb = GetBValue(styleItem->Color3);
                sr += sr >> 4;
                sg += sg >> 4;
                sb += sb >> 4;
                if (sr>0xff) sr = 0xff;
                if (sg>0xff) sg = 0xff;
                if (sb>0xff) sb = 0xff;
                styleItem->Color4 = RGB(sr,sg,sb);
 
                strcpy_s(&param[nLen], (sizeof(param)-nLen), ".color.splitTo:");
                styleItem->Color1 = GetColor(NULL, styleCache, param, NULL, styleItem->Color1, true);
                strcpy_s(&param[nLen], (sizeof(param)-nLen), ".colorTo.splitTo:");
                styleItem->Color4 = GetColor(NULL, styleCache, param, NULL, styleItem->Color4, true);
            }
            else
            {
                // -> The style is using the more flexible newer .color1-4/8 syntax... :D
 
                strcpy_s(&param[nLen], (sizeof(param)-nLen), ".color3:");
                styleItem->Color3 = GetColor(NULL, styleCache, param, NULL, styleItem->Color3, true);
                strcpy_s(&param[nLen], (sizeof(param)-nLen), ".color4:");
                styleItem->Color4 = GetColor(NULL, styleCache, param, NULL, styleItem->Color4, true);
 
                if (styleItem->type >= B_SUPERHORIZONTAL) // 8-colour super gradient being used...
                {
                    strcpy_s(&param[nLen], (sizeof(param)-nLen), ".color5:");
                    styleItem->Color5 = GetColor(NULL, styleCache, param, NULL, styleItem->Color5, true);
                    strcpy_s(&param[nLen], (sizeof(param)-nLen), ".color6:");
                    styleItem->Color6 = GetColor(NULL, styleCache, param, NULL, styleItem->Color6, true);
                    strcpy_s(&param[nLen], (sizeof(param)-nLen), ".color7:");
                    styleItem->Color7 = GetColor(NULL, styleCache, param, NULL, styleItem->Color7, true);
                    strcpy_s(&param[nLen], (sizeof(param)-nLen), ".color8:");
                    styleItem->Color8 = GetColor(NULL, styleCache, param, NULL, styleItem->Color8, true);
                }
    /*
                if (styleItem->type < B_SUPERHORIZONTAL) // 4-colour split gradient being used...
                {
                    // Re-order the colours from "1234" to "2314"
                    // to allow for limited forward compatibility
                    // for MakeGradient (i.e. even if MakeGradient
                    // does not support 4 input colours it will
                    // fall back to a 2 input colour split gradient)
 
                    tempColor = styleItem->Color3;
                    styleItem->Color3 = styleItem->Color1;
                    styleItem->Color1 = styleItem->Color2;
                    styleItem->Color2 = tempColor;
                }
                else // 8-colour super gradient being used...
                {
                    // ...for now, I won't bother trying to squeeze forward compatibility
                    // for MakeGradient into the mix in here as well... (at some point it just becomes ugly)
                }
    */
            }
        }
    }
 
    strcpy_s(&param[nLen], (sizeof(param)-nLen), ".textColor:");
    styleItem->TextColor = GetColor(NULL, styleCache, param, NULL, styleItem->TextColor, true);
 
/*
    // #########################################################################
    // As the following colour parameters are (1) only used by a few StyleItems,
    // and (2) sometimes overloaded (menu.active/hilite), we do *not* parse them
    // here but manually in ReadStyle() for applicable items intstead, see above
    // #########################################################################
    // The following colour parameters are used interchangeably for similar things so let's parse them together...
    strcpy_s(&param[nLen], (sizeof(param)-nLen), ".foregroundColor:");
    if (styleItem->foregroundColor == COLOR_UNDEFINED) tempColor = GetColor(NULL, styleCache, param, NULL, styleItem->TextColor, true); // First read: Default value -> Same as TextColor
    else tempColor = GetColor(NULL, styleCache, param, NULL, styleItem->foregroundColor, true); // Subsequent reads: Default value -> Inherited value from previous set/read action
    strcpy_s(&param[nLen], (sizeof(param)-nLen), ".bulletColor:");
    tempColor = GetColor(NULL, styleCache, param, NULL, tempColor, true);
    strcpy_s(&param[nLen], (sizeof(param)-nLen), ".picColor:");
    styleItem->foregroundColor = GetColor(NULL, styleCache, param, NULL, tempColor, true);
*/
    if (styleItem == MenuFrame)
    {
        // menu.frame.disabledColor -> Disabled text color (i.e. menu [nop] items)
        strcpy_s(&param[nLen], (sizeof(param)-nLen), ".disabledColor:");
        styleItem->disabledColor = GetColor(NULL, styleCache, param, NULL, styleItem->TextColor, true);
    }
 
    if ((styleItem == ToolbarButton) || (styleItem == ToolbarButtonPressed) ||
        (styleItem == WindowButtonFocus) || (styleItem == WindowButtonUnfocus) || (styleItem == WindowButtonPressed))
    {
        strcpy_s(&param[nLen], (sizeof(param)-nLen), ".foregroundColor:");
        tempColor = GetColor(NULL, styleCache, param, NULL, styleItem->PicColor, true);
        strcpy_s(&param[nLen], (sizeof(param)-nLen), ".picColor:");
        styleItem->PicColor = GetColor(NULL, styleCache, param, NULL, tempColor, true);
    }
 
    //====================
 
    // Font...
    if (readFont)
    {
        strcpy_s(&param[nLen], (sizeof(param)-nLen), ".font:");
        strcpy(temp, GetString(NULL, styleCache, param, styleItem->Font));
 
        if (strchr(temp, '/')) // -> The font was defined using a single .font: Font/Size/WeightFlags property, e.g. "Segoe UI/15/BoldShadow"
        {
            // ParseFontString(temp, styleItem); // Note: We can *not* use this BBAPI function here as it does not allow for the multi-pass parsing we may require here in Settings.
 
            // Extract the font...
            strcpy(temp, Tokenize(temp, styleItem->Font, "/"));
            CheckFontSubstitution(styleItem->Font);
 
            if (strlen(temp))
            {
                // Extract the font size...
                char height[MAX_LINE_LENGTH];
                strcpy(temp, Tokenize(temp, height, "/"));
                if (atoi(height) > 0) styleItem->FontHeight = atoi(height);
 
                if (strlen(temp))
                {
                    // Extract the font weight + any outline and/or shadow flags...
                    if (IsInString(temp, "Normal")) styleItem->FontWeight = FW_NORMAL;
                    if (IsInString(temp, "Bold")) styleItem->FontWeight = FW_BOLD;
                    if (IsInString(temp, "Outline")) styleItem->FontOutline = true;
                    if (IsInString(temp, "Shadow")) styleItem->FontShadow = true;
                }
            }
        }
        else // -> The font was defined using separate properties, i.e. .font, .fontHeight, .fontWeight
        {
            CheckFontSubstitution(temp);
            strcpy(styleItem->Font, temp);
 
            strcpy_s(&param[nLen], (sizeof(param)-nLen), ".fontHeight:");
            styleItem->FontHeight = GetInt(NULL, styleCache, param, styleItem->FontHeight);
 
            strcpy_s(&param[nLen], (sizeof(param)-nLen), ".fontWeight:");
            strcpy(temp, GetString(NULL, styleCache, param, "Normal"));
            if (IsInString(temp, "Bold")) styleItem->FontWeight = FW_BOLD;
            else styleItem->FontWeight = FW_NORMAL;
 
            if (IsInString(temp, "Outline")) styleItem->FontOutline = true;
            if (IsInString(temp, "Shadow")) styleItem->FontShadow = true;
        }
/*
        if (globalFontOverride)
        {
            // ##### Q: SHOULD WE ALSO ADD THE OPTION OF HAVING A GLOBAL FONT OVERRIDE? (READ: JUST AN IDEA, TO BE DECIDED...) #####
            strcpy(styleItem->Font, globalFont);
            styleItem->FontHeight = globalFontHeight;
            // Note: We still allow style-defined font *weights* even if font+size override is used!
        }
*/
        //====================
 
        // Text alignment/justify...
        strcpy_s(&param[nLen], (sizeof(param)-nLen), ".alignment:");
        strcpy(temp, GetString(NULL, styleCache, param, ""));
        strcpy_s(&param[nLen], (sizeof(param)-nLen), ".justify:");
        strcpy(temp, GetString(NULL, styleCache, param, temp));
 
        if (IsInString(temp, "Left")) styleItem->Justify = DT_LEFT;
        else if (IsInString(temp, "Right")) styleItem->Justify = DT_RIGHT;
        else if (IsInString(temp, "Center")) styleItem->Justify = DT_CENTER;
        // -> else use inherited alignment...
 
        //====================
 
        // Note#1: Font outlines and shadows can be automatically enabled using either the "Outline" and "Shadow" font tags respectively (see above),
        // or manually enabled and configured by specifying .outlineColor and/or .shadowColor for the given element.
        // Note#2: ...and due to this dependency, we also need to check for the latter *AFTER* having parsed the font properties above!
 
        // Font outlines...
        strcpy_s(&param[nLen], (sizeof(param)-nLen), ".outlineColor:");
        if (strlen(GetString(NULL, styleCache, param, "")))
        {
            // An outline colour *has* been specified and outlines should therefore be enabled...
            styleItem->FontOutline = true;
            styleItem->OutlineColor = GetColor(NULL, styleCache, param, NULL, styleItem->OutlineColor, true);
        }
        else if (styleItem->FontOutline && (styleItem->OutlineColor == COLOR_UNDEFINED))
        {
            // An outline colour has *not* been specified but the "Outline" font tag has been set, so let's calculate a default outline colour instead...
            styleItem->OutlineColor = CreateShadowColor(styleItem, styleItem->Color1, styleItem->Color2, styleItem->TextColor);
        }
 
        // Font shadows...
        strcpy_s(&param[nLen], (sizeof(param)-nLen), ".shadowColor:");
        if (strlen(GetString(NULL, styleCache, param, "")))
        {
            // A shadow colour *has* been specified and shadows should therefore be enabled...
            styleItem->FontShadow = true;
            styleItem->ShadowColor = GetColor(NULL, styleCache, param, NULL, styleItem->ShadowColor, true);
        }
        else if (styleItem->FontShadow && (styleItem->ShadowColor == COLOR_UNDEFINED))
        {
            // A shadow colour has *not* been specified but the "Shadow" font tag has been set, so let's calculate a default shadow colour instead...
            if (styleItem->FontOutline) styleItem->ShadowColor = CreateShadowColor(styleItem, styleItem->Color1, styleItem->Color2, styleItem->OutlineColor);
            else styleItem->ShadowColor = CreateShadowColor(styleItem, styleItem->Color1, styleItem->Color2, styleItem->TextColor);
        }
 
        // Default text shadow offsets at non-HiDPI is 1 pixels to the right and below the text itself...
        strcpy_s(&param[nLen], (sizeof(param)-nLen), ".shadowX:");
        styleItem->ShadowX = GetInt(NULL, styleCache, param, 1);
//      if (styleItem->ShadowX > 2) styleItem->ShadowX = 2;
//      if (styleItem->ShadowX < -2) styleItem->ShadowX = -2;
        strcpy_s(&param[nLen], (sizeof(param)-nLen), ".shadowY:");
        styleItem->ShadowY = GetInt(NULL, styleCache, param, 1);
//      if (styleItem->ShadowY > 2) styleItem->ShadowY = 2;
//      if (styleItem->ShadowY < -2) styleItem->ShadowY = -2;
    }
 
    //====================
 
    return bb4nix070syntax;
}

DeriveTaskbarStyle()

void Settings::DeriveTaskbarStyle

(

)

{
    // Taskbar active task button... (-> derived from other style elements)
 
    if (!ToolbarWindowLabel->parentRelative)
    {
        CopyMemory(ActiveTask, ToolbarWindowLabel, sizeof(StyleItem));
        if (ActiveTask->type == B_ELLIPTIC) ActiveTask->ShadowColor = CreateShadowColor(ToolbarWindowLabel, ToolbarWindowLabel->ColorTo, ToolbarWindowLabel->Color, ToolbarWindowLabel->TextColor);
//      else ActiveTask->ShadowColor = CreateShadowColor(ToolbarWindowLabel, ToolbarWindowLabel->Color, ToolbarWindowLabel->ColorTo, ToolbarWindowLabel->TextColor);
    }
    else if (!ToolbarLabel->parentRelative)
    {
        CopyMemory(ActiveTask, ToolbarLabel, sizeof(StyleItem));
        if (ActiveTask->type == B_ELLIPTIC) ActiveTask->ShadowColor = CreateShadowColor(ToolbarLabel, ToolbarLabel->ColorTo, ToolbarLabel->Color, ToolbarLabel->TextColor);
//      else ActiveTask->ShadowColor = CreateShadowColor(ToolbarLabel, ToolbarLabel->Color, ToolbarLabel->ColorTo, ToolbarLabel->TextColor);
    }
    else if (!ToolbarClock->parentRelative)
    {
        CopyMemory(ActiveTask, ToolbarClock, sizeof(StyleItem));
        if (ActiveTask->type == B_ELLIPTIC) ActiveTask->ShadowColor = CreateShadowColor(ToolbarClock, ToolbarClock->ColorTo, ToolbarClock->Color, ToolbarClock->TextColor);
//      else ActiveTask->ShadowColor = CreateShadowColor(ToolbarClock, ToolbarClock->Color, ToolbarClock->ColorTo, ToolbarClock->TextColor);
    }
    else
    {
        CopyMemory(ActiveTask, Toolbar, sizeof(StyleItem));
        ActiveTask->TextColor = ToolbarWindowLabel->TextColor;
//      ActiveTask->FontShadow = ToolbarWindowLabel->FontShadow;
        if (ActiveTask->type == B_ELLIPTIC) ActiveTask->ShadowColor = CreateShadowColor(Toolbar, Toolbar->ColorTo, Toolbar->Color, ToolbarWindowLabel->TextColor);
        else ActiveTask->ShadowColor = CreateShadowColor(Toolbar, Toolbar->Color, Toolbar->ColorTo, ToolbarWindowLabel->TextColor);
//      ActiveTask->FontOutline = ToolbarWindowLabel->FontOutline;
//      ActiveTask->OutlineColor = ToolbarWindowLabel->OutlineColor;
    }
 
    if (ActiveTask->borderWidth > 1) ActiveTask->borderWidth = 1;
 
    //====================
 
    // Taskbar non-active task buttons... (-> derived from other style elements)
 
    CopyMemory(InactiveTask, Toolbar, sizeof(StyleItem));
 
    if (ToolbarWindowLabel->parentRelative)
    {
        InactiveTask->TextColor = ToolbarWindowLabel->TextColor;
        InactiveTask->ShadowColor = CreateShadowColor(Toolbar, Toolbar->Color, Toolbar->ColorTo, ToolbarWindowLabel->TextColor);
    }
    else if (ToolbarLabel->parentRelative)
    {
        InactiveTask->TextColor = ToolbarLabel->TextColor;
        InactiveTask->ShadowColor = CreateShadowColor(Toolbar, Toolbar->Color, Toolbar->ColorTo, ToolbarLabel->TextColor);
    }
    else if (ToolbarClock->parentRelative)
    {
        InactiveTask->TextColor = ToolbarClock->TextColor;
        InactiveTask->ShadowColor = CreateShadowColor(Toolbar, Toolbar->Color, Toolbar->ColorTo, ToolbarClock->TextColor);
    }
    else if (ToolbarButton->parentRelative)
    {
        InactiveTask->TextColor = ToolbarButton->PicColor;
        InactiveTask->ShadowColor = CreateShadowColor(Toolbar, Toolbar->Color, Toolbar->ColorTo, ToolbarButton->PicColor);
    }
    else
    {
        InactiveTask->TextColor = Toolbar->TextColor;
        InactiveTask->ShadowColor = CreateShadowColor(Toolbar, Toolbar->Color, Toolbar->ColorTo, Toolbar->TextColor);
    }
 
    if (InactiveTask->borderWidth > 1) InactiveTask->borderWidth = 1;
 
    //====================
 
    // Flashing task buttons... (-> inverted variations of the active task button colours)
    FlashingTask->Color = InvertColor(ActiveTask->ColorTo);
    FlashingTask->ColorTo = InvertColor(ActiveTask->Color);
    FlashingTask->Color3 = InvertColor(ActiveTask->Color4);
    FlashingTask->Color4 = InvertColor(ActiveTask->Color3);
    FlashingTask->TextColor = InvertColor(ActiveTask->TextColor);
    FlashingTask->ShadowColor = InvertColor(ActiveTask->ShadowColor);
    FlashingTask->OutlineColor = InvertColor(ActiveTask->OutlineColor);
    FlashingTask->borderColor = InvertColor(ActiveTask->borderColor);
}

CreateShadowColor()

COLORREF Settings::CreateShadowColor	(	StyleItem *	styleItem,
		COLORREF	color,
		COLORREF	colorTo,
		COLORREF	textColor )

{
    BYTE r = GetRValue(color);
    BYTE g = GetGValue(color);
    BYTE b = GetBValue(color);
    BYTE rto = GetRValue(colorTo);
    BYTE gto = GetGValue(colorTo);
    BYTE bto = GetBValue(colorTo);
 
    int rav, gav, bav;
    
    if (styleItem->type != B_SOLID)
    {
        rav = (r+rto) / 2;
        gav = (g+gto) / 2;
        bav = (b+bto) / 2;
    }
    else
    {
        rav = r;
        gav = g;
        bav = b;
    }
 
    if (rav < 0x10) rav = 0;
    else rav -= 0x10;
    if (gav < 0x10) gav = 0;
    else gav -= 0x10;
    if (bav < 0x10) bav = 0;
    else bav -= 0x10;
 
    return RGB((BYTE)rav, (BYTE)gav, (BYTE)bav);
}

InvertColor()

COLORREF Settings::InvertColor

(

COLORREF

color

)

{
    red = 0xff - GetRValue(color);
    green = 0xff - GetGValue(color);
    blue = 0xff - GetBValue(color);
    return RGB((BYTE)blue, (BYTE)green, (BYTE)red);
}

MixColors()

COLORREF Settings::MixColors	(	COLORREF	colorA,
		COLORREF	colorB )

{
    BYTE rt = GetRValue(colorA);
    BYTE gt = GetGValue(colorA);
    BYTE bt = GetBValue(colorA);
    BYTE rb = GetRValue(colorB);
    BYTE gb = GetGValue(colorB);
    BYTE bb = GetBValue(colorB);
 
    int rav = (rt + rb) / 2;
    int gav = (gt + gb) / 2;
    int bav = (bt + bb) / 2;
 
    return RGB((BYTE)rav, (BYTE)gav, (BYTE)bav);
}

GetShellFolders()

void Settings::GetShellFolders

(

)

{
    // Get the Blackbox folder path...
    GetBlackboxPath(SF_blackboxPath, MAX_PATH);
    // ...and remove the "\" at the end to be consistent with what SHGetFolderPath returns...
    SF_blackboxPath[strlen(SF_blackboxPath)-1] = 0;
 
    SHGetSpecialFolderPath(NULL, SF_startMenu, CSIDL_PROGRAMS, 0);
    SHGetSpecialFolderPath(NULL, SF_commonStartMenu, CSIDL_COMMON_PROGRAMS, 0);
    SHGetSpecialFolderPath(NULL, SF_programFiles, CSIDL_PROGRAM_FILES, 0);
    SHGetSpecialFolderPath(NULL, SF_desktop, CSIDL_DESKTOPDIRECTORY, 0);
    SHGetSpecialFolderPath(NULL, SF_userProfile, CSIDL_PROFILE, 0);
//  SHGetSpecialFolderPath(NULL, SF_userAppData, CSIDL_APPDATA, 0);
    strcpy(SF_userAppData, SF_userProfile);
    strcat(SF_userAppData, "\\AppData");
 
    // Store the default theme path...
    strcpy(SF_currentThemePath, SF_blackboxPath); // Default theme
    usingDefaultTheme = true;
 
    // Find and store the path to the default xoblite.rc file (some settings should always
    // be read from this file, e.g. preferred editor and AutoUpdate last checked date)
    bbrcPath();
    extensionsrcPath();
    strcpy(xobrcDefaultFile, xobrcFile);
}

GetBool()

bool Settings::GetBool	(	LPCSTR	fp,
		LPSTR	buffer,
		LPCSTR	szString,
		bool	szDefault )

{
    // NULL/empty filepointers are not supported for ReadBool,
    // but since it is the only Read* function that does not
    // support them I have added a safeguard here to prevent
    // a borked plugin from crashing the core... <g>
    if (!cachedFilePtr && (!fp || !_stricmp(fp, ""))) return szDefault;
 
    //====================
 
    LPSTR buffer;
    if (cachedFilePtr && !fp)
    {
        // Look for the value in the file cache...
        buffer = GetValueFromCache(cachedFilePtr, szString);
    }
    else
    {
        // If we can not find the value in the cache, we fetch it from the file...
        buffer = ReadValue(fp, szString, 0);
    }
 
    if (buffer)
    {
        if (!_stricmp(buffer, "true")) return true;
        else if (!_stricmp(buffer, "false")) return false;
    }
 
    return szDefault;
}

GetInt()

int Settings::GetInt	(	LPCSTR	fp,
		LPSTR	buffer,
		LPCSTR	szString,
		int	szDefault )

{
    if (!cachedFilePtr && (!fp || !_stricmp(fp, "") || !_stricmp(fp, styleFile)))
    {
        if (!_strnicmp(szString, "toolbar.", 8))
        {
            if (szString[8] == 'l') // toolbar label items
            {
                if (!_stricmp(&szString[13], ".borderWidth:")) return ToolbarLabel->borderWidth;
                else if (!_stricmp(&szString[13], ".marginWidth:")) return ToolbarLabel->marginWidth;
                else if (!_stricmp(&szString[13], ".fontHeight:")) return ToolbarLabel->FontHeight;
            }
            else if (szString[8] == 'w') // toolbar windowLabel items
            {
                if (!_stricmp(&szString[19], ".borderWidth:")) return ToolbarWindowLabel->borderWidth;
                else if (!_stricmp(&szString[19], ".marginWidth:")) return ToolbarWindowLabel->marginWidth;
                else if (!_stricmp(&szString[19], ".fontHeight:")) return ToolbarWindowLabel->FontHeight;
            }
            else if (szString[8] == 'c') // toolbar clock items
            {
                if (!_stricmp(&szString[13], ".borderWidth:")) return ToolbarClock->borderWidth;
                else if (!_stricmp(&szString[13], ".marginWidth:")) return ToolbarClock->marginWidth;
                else if (!_stricmp(&szString[13], ".fontHeight:")) return ToolbarClock->FontHeight;
            }
            else // toolbar main items
            {
                if (!_stricmp(&szString[7], ".borderWidth:")) return Toolbar->borderWidth;
                else if (!_stricmp(&szString[7], ".marginWidth:")) return Toolbar->marginWidth;
                else if (!_stricmp(&szString[7], ".fontHeight:")) return Toolbar->FontHeight;
            }
        }
 
        //====================
 
        else if (!_strnicmp(szString, "menu.", 5))
        {
            if (szString[5] == 't') // menu title items
            {
                if (!_stricmp(&szString[10], ".borderWidth:")) return MenuTitle->borderWidth;
                else if (!_stricmp(&szString[10], ".marginWidth:")) return MenuTitle->marginWidth;
                else if (!_stricmp(&szString[10], ".fontHeight:")) return MenuTitle->FontHeight;
            }
            else if (szString[5] == 'f') // menu frame items
            {
                if (!_stricmp(&szString[10], ".borderWidth:")) return MenuFrame->borderWidth;
                else if (!_stricmp(&szString[10], ".marginWidth:")) return MenuFrame->marginWidth;
                else if (!_stricmp(&szString[10], ".fontHeight:")) return MenuFrame->FontHeight;
            }
            else if (szString[5] == 'h' || szString[5] == 'a') // menu hilite/active items
            {
                if (!_stricmp(&szString[11], ".borderWidth:")) return MenuActive->borderWidth;
                else if (!_stricmp(&szString[11], ".marginWidth:")) return MenuActive->marginWidth;
                else if (!_stricmp(&szString[11], ".fontHeight:")) return MenuActive->FontHeight;
            }
            else if (szString[5] == 'g') // menu grip items
            {
                if (!_stricmp(&szString[9], ".borderWidth:")) return MenuGrip->borderWidth;
                else if (!_stricmp(&szString[9], ".marginWidth:")) return MenuGrip->marginWidth;
                else if (!_stricmp(&szString[9], ".fontHeight:")) return MenuGrip->FontHeight;
            }
            else if (!_stricmp(&szString[4], ".borderWidth:")) return menuBorderWidth;
        }
 
        //====================
 
        else if (!_strnicmp(szString, "dock.", 5) || !_strnicmp(szString, "slit.", 5))
        {
            if (!_stricmp(&szString[5], ".borderWidth:")) return Dock->borderWidth;
            else if (!_stricmp(&szString[5], ".marginWidth:")) return Dock->marginWidth;
        }
 
        //====================
 
        else if (!_strnicmp(szString, "window.", 7))
        {
            if (szString[7] == 't')
            {
                if (szString[13] == 'f') // window title focus items
                {
                    if (!_stricmp(&szString[18], ".borderWidth:")) return WindowTitleFocus->borderWidth;
                    else if (!_stricmp(&szString[18], ".marginWidth:")) return WindowTitleFocus->marginWidth;
                }
                else if (szString[13] == 'u') // window title unfocus items
                {
                    if (!_stricmp(&szString[20], ".borderWidth:")) return WindowTitleUnfocus->borderWidth;
                    else if (!_stricmp(&szString[20], ".marginWidth:")) return WindowTitleUnfocus->marginWidth;
                }
            }
            else if (szString[7] == 'l')
            {
                if (szString[13] == 'f') // window label focus items
                {
                    if (!_stricmp(&szString[18], ".borderWidth:")) return WindowLabelFocus->borderWidth;
                    else if (!_stricmp(&szString[18], ".marginWidth:")) return WindowLabelFocus->marginWidth;
                    else if (!_stricmp(&szString[18], ".fontHeight:")) return WindowLabelFocus->FontHeight;
                }
                else if (szString[13] == 'u') // window label unfocus items
                {
                    if (!_stricmp(&szString[20], ".borderWidth:")) return WindowLabelUnfocus->borderWidth;
                    else if (!_stricmp(&szString[20], ".marginWidth:")) return WindowLabelUnfocus->marginWidth;
                    else if (!_stricmp(&szString[20], ".fontHeight:")) return WindowLabelUnfocus->FontHeight;
                }
            }
            else if (szString[7] == 'b')
            {
                if (szString[14] == 'f') // window button focus items
                {
                    if (!_stricmp(&szString[19], ".borderWidth:")) return WindowButtonFocus->borderWidth;
                    else if (!_stricmp(&szString[19], ".marginWidth:")) return WindowButtonFocus->marginWidth;
                }
                else if (szString[14] == 'u') // window button unfocus items
                {
                    if (!_stricmp(&szString[21], ".borderWidth:")) return WindowButtonUnfocus->borderWidth;
                    else if (!_stricmp(&szString[21], ".marginWidth:")) return WindowButtonUnfocus->marginWidth;
                }
                else if (szString[14] == 'p') // window button pressed items
                {
                    if (!_stricmp(&szString[21], ".borderWidth:")) return WindowButtonPressed->borderWidth;
                    else if (!_stricmp(&szString[21], ".marginWidth:")) return WindowButtonPressed->marginWidth;
                }
            }
            else if (szString[7] == 'g')
            {
                if (szString[12] == 'f') // window grip focus items
                {
                    if (!_stricmp(&szString[17], ".borderWidth:")) return WindowGripFocus->borderWidth;
                    else if (!_stricmp(&szString[17], ".marginWidth:")) return WindowGripFocus->marginWidth;
                }
                else if (szString[12] == 'u') // window grip unfocus items
                {
                    if (!_stricmp(&szString[19], ".borderWidth:")) return WindowGripUnfocus->borderWidth;
                    else if (!_stricmp(&szString[19], ".marginWidth:")) return WindowGripUnfocus->marginWidth;
                }
            }
            else if (szString[7] == 'h')
            {
                if (!_stricmp(&szString[6], ".handleHeight:")) return handleHeight; // window handle height (special non-StyleItem parameter)
                else if (szString[14] == 'f') // window handle focus items
                {
                    if (!_stricmp(&szString[19], ".borderWidth:")) return WindowHandleFocus->borderWidth;
                    else if (!_stricmp(&szString[19], ".marginWidth:")) return WindowHandleFocus->marginWidth;
                }
                else if (szString[14] == 'u') // window handle unfocus items
                {
                    if (!_stricmp(&szString[21], ".borderWidth:")) return WindowHandleUnfocus->borderWidth;
                    else if (!_stricmp(&szString[21], ".marginWidth:")) return WindowHandleUnfocus->marginWidth;
                }
            }
        }
 
        //====================
 
        else if (!_stricmp(szString, "borderWidth:")) return borderWidth;
        else if (!_stricmp(szString, "bevelWidth:")) return bevelWidth;
        else if (!_stricmp(szString, "handleHeight:") || !_stricmp(szString, "handleWidth:")) return handleHeight;
        else if (!_stricmp(szString, "frameWidth:")) return frameWidth;
 
        else if (!_stricmp(szString, "dpi.scaling.factor:") || !_stricmp(szString, "hidpi.scaling.factor:")) return scalingFactorHiDPI;
    }
 
    //====================
 
    LPSTR buffer;
    if (cachedFilePtr && !fp)
    {
        // Look for the value in the buffered style file...
        buffer = GetValueFromCache(cachedFilePtr, szString);
    }
//  else if (!cachedFilePtr && !_stricmp(fp, "."))
//  {
        // ##### PROOF OF CONCEPT ONLY, HAVE NOT YET DECIDED IF THIS REALLY A GOOD IDEA... (read: there's value in separation of concerns as well!) #####
//      // Look for the value in the xoblite.rc file for the current theme... (== fp shortcut to allow plugins to read their settings from there for ease of use, easier portability, etc)
//      buffer = ReadValue(xobrcFile, szString, 0);
//  }
    else
    {
        // If we can not find the value in the buffer, we fetch it from the specified file... (== this could be any file)
        buffer = ReadValue(fp, szString, 0);
    }
 
    if (buffer)
    {
        int value = 0;
        value = atoi(buffer);
        return value;
    }
    
    return szDefault;
}

GetString()

LPSTR Settings::GetString	(	LPCSTR	fp,
		LPSTR	buffer,
		LPCSTR	szString,
		LPSTR	szDefault )

{
    if (!cachedFilePtr && (!fp || !_stricmp(fp, "") || !_stricmp(fp, styleFile)))
    {
        //====================
 
        if (strchr(szString, '*')) // wildcard items
        {
            if (!_stricmp(szString, "*font:")) return Wildcard->Font;
            else if (!_stricmp(szString, "toolbar*font:")) return wildcardToolbarFont;
            else if (!_stricmp(szString, "menu*font:")) return wildcardMenuFont;
            else if (!_stricmp(szString, "window*font:")) return wildcardWindowFont;
            else if (!_stricmp(szString, "*justify:") || !_stricmp(szString, "*alignment:")) return GetAlignmentAsString(Wildcard);
 
            else if (!_stricmp(szString, "*.font:")) return Wildcard->Font;
            else if (!_stricmp(szString, "*.justify:") || !_stricmp(szString, "*.alignment:")) return GetAlignmentAsString(Wildcard);
        }
 
        //====================
 
        else if (!_strnicmp(szString, "toolbar", 7)) // toolbar items
        {
            if (IsInString(szString, ".appearance:"))
            {
                if (!_stricmp(&szString[7], ".appearance:")) return toolbar;
                else if (!_stricmp(&szString[7], ".label.appearance:")) return toolbarLabel;
                else if (!_stricmp(&szString[7], ".windowLabel.appearance:")) return toolbarWindowLabel;
                else if (!_stricmp(&szString[7], ".clock.appearance:")) return toolbarClock;
                else if (!_stricmp(&szString[7], ".button.appearance:")) return toolbarButton;
                else if (!_stricmp(&szString[7], ".button.pressed.appearance:")) return toolbarButtonPressed;
            }
            else
            {
                if (!_stricmp(&szString[7], ":")) return toolbar;
                else if (!_stricmp(&szString[7], ".label:")) return toolbarLabel;
                else if (!_stricmp(&szString[7], ".windowLabel:")) return toolbarWindowLabel;
                else if (!_stricmp(&szString[7], ".clock:")) return toolbarClock;
                else if (!_stricmp(&szString[7], ".button:")) return toolbarButton;
                else if (!_stricmp(&szString[7], ".button.pressed:")) return toolbarButtonPressed;
 
                else if (!_stricmp(&szString[7], ".font:")) return Toolbar->Font;
                else if (!_stricmp(&szString[7], ".label.font:")) return ToolbarLabel->Font;
                else if (!_stricmp(&szString[7], ".windowLabel.font:")) return ToolbarWindowLabel->Font;
                else if (!_stricmp(&szString[7], ".clock.font:")) return ToolbarClock->Font;
 
                else if (!_stricmp(&szString[7], ".alignment:") || !_stricmp(&szString[7], ".justify:")) return GetAlignmentAsString(Toolbar);
                else if (!_stricmp(&szString[7], ".label.alignment:") || !_stricmp(&szString[7], ".label.justify:")) return GetAlignmentAsString(ToolbarLabel);
                else if (!_stricmp(&szString[7], ".windowLabel.alignment:") || !_stricmp(&szString[7], ".windowLabel.justify:")) return GetAlignmentAsString(ToolbarWindowLabel);
                else if (!_stricmp(&szString[7], ".clock.alignment:") || !_stricmp(&szString[7], ".clock.justify:")) return GetAlignmentAsString(ToolbarClock);
            }
        }
 
        //====================
 
        else if (!_strnicmp(szString, "menu.", 5))
        {
            if (szString[5] == 't') // menu title items
            {
                if (!_stricmp(&szString[10], ":") || !_stricmp(&szString[10], ".appearance:")) return menuTitle;
                else if (!_stricmp(&szString[10], ".font:")) return MenuTitle->Font;
                else if (!_stricmp(&szString[10], ".alignment:") || !_stricmp(&szString[10], ".justify:")) return GetAlignmentAsString(MenuTitle);
            }
            else if (szString[5] == 'f') // menu frame items
            {
                if (!_stricmp(&szString[10], ":") || !_stricmp(&szString[10], ".appearance:")) return menuFrame;
                else if (!_stricmp(&szString[10], ".font:")) return MenuFrame->Font;
                else if (!_stricmp(&szString[10], ".alignment:") || !_stricmp(&szString[10], ".justify:")) return GetAlignmentAsString(MenuFrame);
            }
            else if (szString[5] == 'b') // menu bullet items
            {
                if (!_stricmp(&szString[11], ":") || !_stricmp(&szString[11], ".appearance:")) return menuFrameBulletAsString;
                else if (!_stricmp(&szString[11], ".position:")) return menuBulletPosition;
            }
            else if (!_stricmp(&szString[4], ".active.appearance:") || !_stricmp(&szString[4], ".hilite:") || !_stricmp(&szString[4], ".active:")) return menuActive; // menu active/hilite items
            else if (!_stricmp(&szString[4], ".grip.appearance:") || !_stricmp(&szString[4], ".grip:")) return menuGrip; // menu grip items
            else if (!_stricmp(&szString[4], ".indicator.appearance:") || !_stricmp(&szString[4], ".indicator:")) return menuIndicator; // menu indicator items
        }
 
        //====================
 
        else if (!_strnicmp(szString, "dock", 4) || !_strnicmp(szString, "slit", 4))
        {
            if (!_stricmp(&szString[4], ":") || !_stricmp(&szString[4], ".appearance:")) return dock;
        }
 
        //====================
 
        else if (!_strnicmp(szString, "window.", 7))
        {
            if (szString[7] == 't')
            {
                if (szString[13] == 'f') // window title focus items
                {
                    if (!_stricmp(&szString[18], ":") || !_stricmp(&szString[18], ".appearance:")) return windowTitleFocus;
                }
                else if (szString[13] == 'u') // window title unfocus items
                {
                    if (!_stricmp(&szString[20], ":") || !_stricmp(&szString[20], ".appearance:")) return windowTitleUnfocus;
                }
            }
            else if (szString[7] == 'l')
            {
                if (szString[13] == 'f') // window label focus items
                {
                    if (!_stricmp(&szString[18], ":") || !_stricmp(&szString[18], ".appearance:")) return windowLabelFocus;
                    else if (!_stricmp(&szString[18], ".font:")) return WindowLabelFocus->Font;
                    else if (!_stricmp(&szString[18], ".alignment:") || !_stricmp(&szString[18], ".justify:")) return GetAlignmentAsString(WindowLabelFocus);
                }
                else if (szString[13] == 'u') // window label unfocus items
                {
                    if (!_stricmp(&szString[20], ":") || !_stricmp(&szString[20], ".appearance:")) return windowLabelUnfocus;
                    else if (!_stricmp(&szString[20], ".font:")) return WindowLabelUnfocus->Font;
                    else if (!_stricmp(&szString[20], ".alignment:") || !_stricmp(&szString[20], ".justify:")) return GetAlignmentAsString(WindowLabelUnfocus);
                }
            }
            else if (szString[7] == 'b')
            {
                if (szString[14] == 'f') // window button focus items
                {
                    if (!_stricmp(&szString[19], ":") || !_stricmp(&szString[19], ".appearance:")) return windowButtonFocus;
                }
                else if (szString[14] == 'u') // window button unfocus items
                {
                    if (!_stricmp(&szString[21], ":") || !_stricmp(&szString[21], ".appearance:")) return windowButtonUnfocus;
                }
                else if (szString[14] == 'p') // window button pressed items
                {
                    if (!_stricmp(&szString[21], ":") || !_stricmp(&szString[21], ".appearance:")) return windowButtonPressed;
                }
            }
            else if (szString[7] == 'g')
            {
                if (szString[12] == 'f') // window grip focus items
                {
                    if (!_stricmp(&szString[17], ":") || !_stricmp(&szString[17], ".appearance:")) return windowGripFocus;
                }
                else if (szString[12] == 'u') // window grip unfocus items
                {
                    if (!_stricmp(&szString[19], ":") || !_stricmp(&szString[19], ".appearance:")) return windowGripUnfocus;
                }
            }
            else if (szString[7] == 'h')
            {
                if (szString[14] == 'f') // window handle focus items
                {
                    if (!_stricmp(&szString[19], ":") || !_stricmp(&szString[19], ".appearance:")) return windowHandleFocus;
                }
                else if (szString[14] == 'u') // window handle unfocus items
                {
                    if (!_stricmp(&szString[21], ":") || !_stricmp(&szString[21], ".appearance:")) return windowHandleUnfocus;
                }
            }
        }
 
        //====================
 
        else if (!_strnicmp(szString, "hardware", 8))
        {
            if (!_stricmp(&szString[8], ":") || !_stricmp(&szString[8], ".appearance:")) return externalHardware;
        }
    }
 
    //====================
 
    LPSTR buffer;
    if (cachedFilePtr && !fp)
    {
        // Look for the value in the buffered style file...
        buffer = GetValueFromCache(cachedFilePtr, szString);
    }
    else
    {
        // If we can not find the value in the buffer, we fetch it from the file...
        buffer = ReadValue(fp, szString, 0);
    }
 
    if (buffer) return buffer;
    
    return szDefault;
}

GetColor()

COLORREF Settings::GetColor	(	LPCSTR	fp,
		LPSTR	buffer,
		LPCSTR	szString,
		LPCSTR	szDefault,
		COLORREF	szDefaultRef,
		bool	useDefaultRef )

{
    if (!cachedFilePtr)
    {
        if (!fp || !_stricmp(fp, "") || !_stricmp(fp, styleFile))
        {
            char* ptr = NULL;
            StyleItem* si = NULL;
 
            //====================
 
            if (strchr(szString, '*')) // wildcard items
            {
                if (!_stricmp(szString, "*.textColor:") || !_stricmp(szString, "*textColor:")) return Wildcard->TextColor;
            }
 
            //====================
 
            else if (!_strnicmp(szString, "toolbar", 7))
            {
                if (!_strnicmp(&szString[7], ".clock", 6)) // toolbar clock items
                {
                    ptr = (char*)&szString[13];
                    si = ToolbarClock;
                }
                else if (!_strnicmp(&szString[7], ".label", 6)) // toolbar label items
                {
                    ptr = (char*)&szString[13];
                    si = ToolbarLabel;
                }
                else if (!_strnicmp(&szString[7], ".windowLabel", 12)) // toolbar windowLabel items
                {
                    ptr = (char*)&szString[19];
                    si = ToolbarWindowLabel;
                }
                else if (!_strnicmp(&szString[7], ".button.pressed", 15)) // toolbar pressed button items
                {
                    ptr = (char*)&szString[22];
                    si = ToolbarButtonPressed;
                }
                else if (!_strnicmp(&szString[7], ".button", 7)) // toolbar button items
                {
                    ptr = (char*)&szString[14];
                    si = ToolbarButton;
                }
                else // toolbar items
                {
                    ptr = (char*)&szString[7];
                    si = Toolbar;
                }
            }
 
            //====================
 
            else if (!_strnicmp(szString, "menu", 4))
            {
                if (!_strnicmp(&szString[4], ".title", 6)) // menu title items
                {
                    ptr = (char*)&szString[10];
                    si = MenuTitle;
                }
                else if (!_strnicmp(&szString[4], ".frame", 6)) // menu frame items
                {
                    if (!_stricmp(&szString[10], ".bulletColor:")) return MenuFrame->BulletColor;
                    else if (!_stricmp(&szString[10], ".disableColor:")) return MenuFrame->disabledColor;
                    ptr = (char*)&szString[10];
                    si = MenuFrame;
                }
                else if (!_strnicmp(&szString[4], ".hilite", 7) || !_strnicmp(&szString[4], ".active", 7)) // menu hilite/active items
                {
                    if (!_stricmp(&szString[11], ".bulletColor:")) return MenuActive->BulletColor;
                    ptr = (char*)&szString[11];
                    si = MenuActive;
                }
                else if (!_strnicmp(&szString[4], ".indicator", 10)) // menu indicator
                {
                    ptr = (char*)&szString[14];
                    si = MenuIndicator;
                }
                // menu separator items + menu border
                else if (!_stricmp(&szString[4], ".separator.color:")) return MenuSeparator->Color;
                else if (!_stricmp(&szString[4], ".borderColor:")) return menuBorderColor;
            }
 
            //====================
 
            else if (!_strnicmp(szString, "dock", 4) || !_strnicmp(szString, "slit", 4)) // dock items
            {
                ptr = (char*)&szString[4];
                si = Dock;
            }
 
            //====================
 
            else if (!_strnicmp(szString, "window", 6))
            {
                if (!_strnicmp(&szString[6], ".title", 6))
                {
                    if (!_strnicmp(&szString[12], ".focus", 6)) // window title focus items
                    {
                        ptr = (char*)&szString[18];
                        si = WindowTitleFocus;
                    }
                    else if (!_strnicmp(&szString[12], ".unfocus", 8)) // window title unfocus items
                    {
                        ptr = (char*)&szString[20];
                        si = WindowTitleUnfocus;
                    }
                }
                else if (!_strnicmp(&szString[6], ".label", 6))
                {
                    if (!_strnicmp(&szString[12], ".focus", 6)) // window label focus items
                    {
                        ptr = (char*)&szString[18];
                        si = WindowLabelFocus;
                    }
                    else if (!_strnicmp(&szString[12], ".unfocus", 8)) // window label unfocus items
                    {
                        ptr = (char*)&szString[20];
                        si = WindowLabelUnfocus;
                    }
                }
                else if (!_strnicmp(&szString[6], ".button", 7))
                {
                    if (!_strnicmp(&szString[13], ".focus", 6)) // window button focus items
                    {
                        ptr = (char*)&szString[19];
                        si = WindowButtonFocus;
                    }
                    else if (!_strnicmp(&szString[13], ".unfocus", 8)) // window button unfocus items
                    {
                        ptr = (char*)&szString[21];
                        si = WindowButtonUnfocus;
                    }
                    else if (!_strnicmp(&szString[13], ".pressed", 8)) // window button pressed items
                    {
                        ptr = (char*)&szString[21];
                        si = WindowButtonPressed;
                    }
                }
                else if (!_strnicmp(&szString[6], ".grip", 5))
                {
                    if (!_strnicmp(&szString[11], ".focus", 6)) // window grip focus items
                    {
                        ptr = (char*)&szString[17];
                        si = WindowGripFocus;
                    }
                    else if (!_strnicmp(&szString[11], ".unfocus", 8)) // window grip unfocus items
                    {
                        ptr = (char*)&szString[19];
                        si = WindowGripUnfocus;
                    }
                }
                else if (!_strnicmp(&szString[6], ".handle", 7))
                {
                    if (!_strnicmp(&szString[13], ".focus", 6)) // window handle focus items
                    {
                        ptr = (char*)&szString[19];
                        si = WindowHandleFocus;
                    }
                    else if (!_strnicmp(&szString[13], ".unfocus", 8)) // window handle unfocus items
                    {
                        ptr = (char*)&szString[21];
                        si = WindowHandleUnfocus;
                    }
                }
            }
 
            //====================
 
            else if (!_strnicmp(szString, "hardware", 8)) // hardware items
            {
                ptr = (char*)&szString[8];
                si = ExternalHardware;
            }
 
            //====================
 
            if (ptr != NULL)
            {
                if (!_stricmp(ptr, ".color:") || !_stricmp(ptr, ".color1:") || !_stricmp(ptr, ".backgroundColor:")) return si->Color;
                else if (!_stricmp(ptr, ".colorTo:") || !_stricmp(ptr, ".color2:")) return si->ColorTo;
                else if (!_stricmp(ptr, ".color3:")) return si->Color3;
                else if (!_stricmp(ptr, ".color4:")) return si->Color4;
                else if (!_stricmp(ptr, ".color5:")) return si->Color5;
                else if (!_stricmp(ptr, ".color6:")) return si->Color6;
                else if (!_stricmp(ptr, ".color7:")) return si->Color7;
                else if (!_stricmp(ptr, ".color8:")) return si->Color8;
//              else if (!_stricmp(ptr, ".textColor:") || !_stricmp(ptr, ".foregroundColor:")) return si->TextColor;
                else if (!_stricmp(ptr, ".textColor:")) return si->TextColor;
                else if (!_stricmp(ptr, ".borderColor:")) return si->borderColor;
//              else if (!_stricmp(ptr, ".picColor:")) return si->PicColor;
                else if (!_stricmp(ptr, ".picColor:") || !_stricmp(ptr, ".bulletColor:") || !_stricmp(ptr, ".foregroundColor:")) return si->foregroundColor;
            }
 
            //====================
 
            else if (!_stricmp(szString, "borderColor:")) return borderColor;
        }
    }
 
    //====================
 
    // If we could not find the value in
    // the buffer, we fetch it from the file...
    COLORREF value;
    char colorString[MAX_LINE_LENGTH];
    char tempString[MAX_LINE_LENGTH];
    char cr[4], cg[4], cb[4];
 
    //====================
 
    LPSTR buffer;
    if (cachedFilePtr && !fp)
    {
        // Look for the value in the buffered style file...
        buffer = GetValueFromCache(cachedFilePtr, szString);
    }
    else
    {
        // If we can not find the value in the buffer, we fetch it from the file...
        if (!fp || !_stricmp(fp, "")) buffer = ReadValue(styleFile, szString, 0);
        else buffer = ReadValue(fp, szString, 0);
    }
 
    if (buffer) strcpy(colorString, buffer);
    else
    {
        // If the requested parameter could not be
        // found in the file we use the default value...
        if (useDefaultRef) return szDefaultRef;
        else strcpy(colorString, szDefault);
    }
 
    //====================
 
    // Check if its a #RRGGBB type string...
    if (*colorString == '#') memmove(colorString, colorString+1, strlen(colorString));
 
    // Check if its an "rgb:12/ee/4c" type string...
    else if (colorString[3]== ':')
//  else if (strchr(colorString, ':'))
    {
        strcpy(tempString, Tokenize(colorString, colorString, ":"));
        strcpy(tempString, Tokenize(tempString, cr, "/"));
        strcpy(tempString, Tokenize(tempString, cg, "/"));
        strcpy(cb, tempString);
 
        strcpy(colorString, cr);
        if (strlen(cr)==1) strcat(colorString, cr);
        strcat(colorString, cg);
        if (strlen(cg)==1) strcat(colorString, cg);
        strcat(colorString, cb);
        if (strlen(cb)==1) strcat(colorString, cb);
    }
 
    // Check if its a pre-defined colour (e.g. "black")...
    else if (isalpha(*colorString))
    {
        value = ParseLiteralColor(colorString);
        if (value) return value;
    }
 
    //====================
 
    value = strtol(colorString, NULL, 16);
    value = RGB(GetBValue(value), GetGValue(value), GetRValue(value));// Have to switch the R and B values around due to the anal way of handling #000000 colors (this is below near the RGB())
 
    return value;
}

GetValueFromCache()

LPSTR Settings::GetValueFromCache	(	LPSTR	cachedFilePtr,
		LPCSTR	szString )

{
    char* ptr = cachedFilePtr;
    char* ptr2 = cachedFilePtr;
 
    // Look for the requested keyword in the memory cache...
    for (;;)
    {
        ptr = StrStrI(ptr2, szString); // -> Case insensitive strstr (Win32 shlwapi.lib)
        if (ptr == NULL) return NULL;
        else if (!CheckForComment(cachedFilePtr, ptr)) break;
        ptr2 = ptr+1;
    }
 
    // We're only interested in the string after the keyword...
    ptr += strlen(szString);
    // Remove any initial space characters or tabs...
    ptr += strspn(ptr, " \t");
    // Copy the string while checking for end of line, end of file, or MS-DOS Ctrl-Z...
    ptr2 = ptr;
    for (int i=0; i<MAX_LINE_LENGTH; i++)
    {
        if ((ptr2[0] == '\n') || (ptr2[0] == EOF) || (ptr2[0] == 26))
        {
            valueFromCache[i] = '\0';
            break;
        }
        else
        {
            valueFromCache[i] = ptr2[0];
            ptr2++;
        }
    }
 
    valueFromCache[MAX_LINE_LENGTH-1] = '\0'; // Failsafe (in case the line is longer than the allowed maximum 4096 bytes)
 
    int nLen = strlen(valueFromCache);
    if (nLen == 0) return NULL;
 
    // Remove any trailing space characters...
    while (nLen >0 && valueFromCache[nLen-1] == ' ') nLen--;
    valueFromCache[nLen] = '\0';
 
    return valueFromCache;
}

CheckForComment()

bool Settings::CheckForComment	(	LPSTR	cachedFilePtr,
		LPSTR	ptr )

{
    LPSTR ptr2 = ptr - 1;
    if (ptr2[0] == '.') return true; // Safeguard for e.g. "borderColor:" vs "toolbar.borderColor:"
    for (;;)
    {
        if ((ptr2[0] == '\n') || (ptr2[0] == EOF) || (ptr2[0] == 26)) return false;
        else if ((ptr2[0] == '!') || (ptr2[0] == '#')) return true;
        else if (ptr2 == cachedFilePtr) return false;
        else ptr2--;
    }
}

UpdateAppearanceString()

void Settings::UpdateAppearanceString

(

StyleItem *

styleItem

)

{
    if (styleItem->type == B_IMAGEFROMFILE) return;
 
    //====================
 
    // Update the cached appearance *string* for the specified element...
    // (nb. not included in the StyleItem definition but potentially used by
    //  e.g. plugins calling ReadString, so needs to reflect the latest changes
    // applied while using the style Designer Mode (see Broams.cpp)
 
    if (styleItem == Toolbar) appearancePointer = toolbar;
    else if (styleItem == ToolbarLabel) appearancePointer = toolbarLabel;
    else if (styleItem == ToolbarWindowLabel) appearancePointer = toolbarWindowLabel;
    else if (styleItem == ToolbarClock) appearancePointer = toolbarClock;
    else if (styleItem == ToolbarButton) appearancePointer = toolbarButton;
    else if (styleItem == ToolbarButtonPressed) appearancePointer = toolbarButtonPressed;
    else if (styleItem == MenuTitle) appearancePointer = menuTitle;
    else if (styleItem == MenuFrame) appearancePointer = menuFrame;
    else if (styleItem == MenuActive) appearancePointer = menuActive;
    else if (styleItem == MenuGrip) appearancePointer = menuGrip;
    else if (styleItem == MenuIndicator) appearancePointer = menuIndicator;
    else if (styleItem == Dock) appearancePointer = dock;
    else if (styleItem == Console) appearancePointer = console;
    else if (styleItem == WindowTitleFocus) appearancePointer = windowTitleFocus;
    else if (styleItem == WindowTitleUnfocus) appearancePointer = windowTitleUnfocus;
    else if (styleItem == WindowLabelFocus) appearancePointer = windowLabelFocus;
    else if (styleItem == WindowLabelUnfocus) appearancePointer = windowLabelUnfocus;
    else if (styleItem == WindowButtonFocus) appearancePointer = windowButtonFocus;
    else if (styleItem == WindowButtonUnfocus) appearancePointer = windowButtonUnfocus;
    else if (styleItem == WindowButtonPressed) appearancePointer = windowButtonPressed;
    else if (styleItem == WindowGripFocus) appearancePointer = windowGripFocus;
    else if (styleItem == WindowGripUnfocus) appearancePointer = windowGripUnfocus;
    else if (styleItem == WindowHandleFocus) appearancePointer = windowHandleFocus;
    else if (styleItem == WindowHandleUnfocus) appearancePointer = windowHandleUnfocus;
    else if (styleItem == ExternalHardware) appearancePointer = externalHardware;
    else return; // Failsafe
 
    //====================
 
    appearancePointer[0] = '\0';
 
    if (styleItem->type == B_PARENTRELATIVE || styleItem->parentRelative) strcat_s(appearancePointer, MAX_LINE_LENGTH, "ParentRelative");
    else
    {
        if (styleItem->bevelstyle == BEVEL_RAISED) strcat_s(appearancePointer, MAX_LINE_LENGTH, "Raised");
        else if (styleItem->bevelstyle == BEVEL_SUNKEN) strcat_s(appearancePointer, MAX_LINE_LENGTH, "Sunken");
        else strcat_s(appearancePointer, MAX_LINE_LENGTH, "Flat");
 
        if (styleItem->type == B_SOLID) strcat_s(appearancePointer, MAX_LINE_LENGTH, " Solid");
        else
        {
            strcat_s(appearancePointer, MAX_LINE_LENGTH, " Gradient");
            switch (styleItem->type)
            {
                case B_HORIZONTAL: { strcat_s(appearancePointer, MAX_LINE_LENGTH, " Horizontal"); break; }
                case B_VERTICAL: { strcat_s(appearancePointer, MAX_LINE_LENGTH, " Vertical"); break; }
                case B_DIAGONAL: { strcat_s(appearancePointer, MAX_LINE_LENGTH, " Diagonal"); break; }
                case B_CROSSDIAGONAL: { strcat_s(appearancePointer, MAX_LINE_LENGTH, " CrossDiagonal"); break; }
                case B_PIPECROSS: { strcat_s(appearancePointer, MAX_LINE_LENGTH, " Pipecross"); break; }
                case B_ELLIPTIC: { strcat_s(appearancePointer, MAX_LINE_LENGTH, " Elliptic"); break; }
                case B_RECTANGLE: { strcat_s(appearancePointer, MAX_LINE_LENGTH, " Rectangle"); break; }
                case B_PYRAMID: { strcat_s(appearancePointer, MAX_LINE_LENGTH, " Pyramid"); break; }
                case B_MIRRORHORIZONTAL: { strcat_s(appearancePointer, MAX_LINE_LENGTH, " MirrorHorizontal"); break; }
                case B_MIRRORVERTICAL: { strcat_s(appearancePointer, MAX_LINE_LENGTH, " MirrorVertical"); break; }
                case B_SPLITSOLID: { strcat_s(appearancePointer, MAX_LINE_LENGTH, " SplitSolid"); break; }
                case B_SPLITHORIZONTAL: { strcat_s(appearancePointer, MAX_LINE_LENGTH, " SplitHorizontal"); break; }
                case B_SPLITVERTICAL: { strcat_s(appearancePointer, MAX_LINE_LENGTH, " SplitVertical"); break; }
                case B_SUPERHORIZONTAL: { strcat_s(appearancePointer, MAX_LINE_LENGTH, " SuperHorizontal"); break; }
                case B_SUPERVERTICAL: { strcat_s(appearancePointer, MAX_LINE_LENGTH, " SuperVertical"); break; }
                default: break;
            }
        }
 
        if (styleItem->bevelstyle != BEVEL_FLAT)
        {
            if (styleItem->bevelposition == BEVEL2) strcat_s(appearancePointer, MAX_LINE_LENGTH, " Bevel2");
            else strcat_s(appearancePointer, MAX_LINE_LENGTH, " Bevel1");
        }
 
        if (styleItem->interlaced) strcat_s(appearancePointer, MAX_LINE_LENGTH, " Interlaced");
    }
}

GetAlignmentAsString()

LPSTR Settings::GetAlignmentAsString

(

StyleItem *

styleItem

)

{
    if (styleItem->Justify == DT_LEFT) return justifyLeft;
    else if (styleItem->Justify == DT_RIGHT) return justifyRight;
    else return justifyCenter;
}

ParsePlacement()

void Settings::ParsePlacement	(	LPSTR	inputString,
		Placement *	outputPlacement )

{
//  strncpy(outputPlacement->rcString, inputString, sizeof(outputPlacement->rcString)); // Save the .rc placement string, we might need it later...
    strncpy_s(outputPlacement->rcString, sizeof(outputPlacement->rcString), inputString, _TRUNCATE); // Save the .rc placement string, we might need it later...
    outputPlacement->rcString[sizeof(outputPlacement->rcString)-1] = '\0';
 
    //====================
 
    if (inputString[0] == 'M' || inputString[0] == 'm') // Manual positioning
    {
        char tempPlacement[MAX_LINE_LENGTH];
        strcpy(tempPlacement, inputString);
 
        char token1[MAX_LINE_LENGTH], token2[MAX_LINE_LENGTH], token3[MAX_LINE_LENGTH];
        LPSTR tokens[2];
        tokens[0] = token1;
        tokens[1] = token2;
 
        token1[0] = token2[0] = token3[0] = '\0';
        BBTokenize (tempPlacement, tokens, 2, token3);
 
        outputPlacement->placement = PLACEMENT_MANUAL;
 
        if (token2[1] == 'C') // "xC" -> Use centered x positioning (nb. regardless of Manual y positioning, see below)
        {
            outputPlacement->centeredx = true;
            if (strlen(token2) > 2) outputPlacement->rcx = atoi(&token2[2]); // Any +/- offset from the centered position? (i.e. input string is longer than "xC")
            else outputPlacement->rcx = 0;
        }
        else
        {
            outputPlacement->centeredx = false;
            outputPlacement->rcx = atoi(&token2[1]); // E.g. "x10" (-> left relative positioning) or "x-10" (-> right relative positioning)
        }
 
        if (token3[1] == 'C') // "yC" -> Use centered y positioning (nb. regardless of Manual x positioning, see above)
        {
            outputPlacement->centeredy = true;
            if (strlen(token3) > 2) outputPlacement->rcy = atoi(&token3[2]); // Any +/- offset from the centered position? (i.e. input string is longer than "yC")
            else outputPlacement->rcy = 0;
        }
        else
        {
            outputPlacement->centeredy = false;
            outputPlacement->rcy = atoi(&token3[1]); // E.g. "y10" (-> top relative positioning) or "y-10" (-> bottom relative positioning)
        }
 
        return;
    }
 
    //====================
 
    if (inputString[0] == 'T' || inputString[0] == 't') // Vertical Top
    {
        if (inputString[3] == 'L') outputPlacement->placement = PLACEMENT_TOP_LEFT;
        else if (inputString[3] == 'C') outputPlacement->placement = PLACEMENT_TOP_CENTER;
        else if (inputString[3] == 'R') outputPlacement->placement = PLACEMENT_TOP_RIGHT;
    }
 
    //====================
 
    else if (inputString[0] == 'C' || inputString[0] == 'c') // Vertical Center
    {
        if (inputString[6] == 'L') outputPlacement->placement = PLACEMENT_CENTER_LEFT;
        if (inputString[6] == 'C') outputPlacement->placement = PLACEMENT_CENTER_CENTER;
        else if (inputString[6] == 'R') outputPlacement->placement = PLACEMENT_CENTER_RIGHT;
    }
 
    //====================
 
    else if (inputString[0] == 'B' || inputString[0] == 'b') // Vertical Bottom
    {
        if (inputString[6] == 'L') outputPlacement->placement = PLACEMENT_BOTTOM_LEFT;
        else if (inputString[6] == 'C') outputPlacement->placement = PLACEMENT_BOTTOM_CENTER;
        else if (inputString[6] == 'R') outputPlacement->placement = PLACEMENT_BOTTOM_RIGHT;
    }
 
    //====================
 
    else if (inputString[0] == 'D' || inputString[0] == 'd') // Default (used by the console)
    {
        outputPlacement->placement = PLACEMENT_DEFAULT;
    }
 
    //====================
 
    else if (inputString[0] == 'O' || inputString[0] == 'o') // OppositeToolbar (used by the dock)
    {
        outputPlacement->placement = PLACEMENT_OPPOSITE_TOOLBAR;
    }
 
    //====================
 
    else if (inputString[0] == 'N' || inputString[0] == 'n') // Next (used by e.g the toolbar broams)
    {
        if (outputPlacement->placement >= PLACEMENT_TOP_LEFT && outputPlacement->placement < PLACEMENT_BOTTOM_RIGHT) outputPlacement->placement++;
        else outputPlacement->placement = PLACEMENT_TOP_LEFT;
    }
    else if (inputString[0] == 'P' || inputString[0] == 'p') // Previous (used by e.g the toolbar broams)
    {
        if (outputPlacement->placement <= PLACEMENT_BOTTOM_RIGHT && outputPlacement->placement > PLACEMENT_TOP_LEFT) outputPlacement->placement--;
        else outputPlacement->placement = PLACEMENT_BOTTOM_RIGHT;
    }
 
    //====================
 
    else if (outputPlacement->placement < PLACEMENT_MANUAL || outputPlacement->placement > PLACEMENT_OPPOSITE_TOOLBAR)
    {
        // "Sanity check" failed, use default value...
        outputPlacement->placement = PLACEMENT_BOTTOM_CENTER;
    }
}

PositionFromPlacement()

void Settings::PositionFromPlacement

(

Placement *

inputPlacement

)

{
    if (!multimonPlacements || (GetSystemMetrics(SM_CMONITORS) == 1)) // -> Multi-monitor placements disabled, or only one display monitor connected...
    {
        if (explorerHidden)
        {
            ScreenWidth = GetSystemMetrics(SM_CXSCREEN);
            ScreenHeight = GetSystemMetrics(SM_CYSCREEN);
            ScreenX = 0; // GetSystemMetrics(SM_XVIRTUALSCREEN);
            ScreenY = 0; // GetSystemMetrics(SM_YVIRTUALSCREEN);
        }
        else
        {
            RECT workArea;
            SystemParametersInfo(SPI_GETWORKAREA, 0, (PVOID)&workArea, SPIF_SENDCHANGE);
            ScreenWidth = workArea.right - workArea.left;
            ScreenHeight = workArea.bottom - workArea.top;
            ScreenX = workArea.left;
            ScreenY = workArea.top;
        }
    }
    else // -> Multi-monitor placements enabled, and more than one display monitor connected...
    {
        ScreenWidth = GetSystemMetrics(SM_CXVIRTUALSCREEN);
        ScreenHeight = GetSystemMetrics(SM_CYVIRTUALSCREEN);
        ScreenX = GetSystemMetrics(SM_XVIRTUALSCREEN);
        ScreenY = GetSystemMetrics(SM_YVIRTUALSCREEN);
    }
 
    //====================
 
    int tempPlacement = inputPlacement->placement;
 
    //====================
 
     // OppositeToolbar placement?
 
    if (tempPlacement == PLACEMENT_OPPOSITE_TOOLBAR)
    {
        switch (ToolbarPlacement.placement)
        {
            case PLACEMENT_TOP_LEFT:
            tempPlacement = PLACEMENT_BOTTOM_LEFT;
            break;
            case PLACEMENT_TOP_CENTER:
            tempPlacement = PLACEMENT_BOTTOM_CENTER;
            break;
            case PLACEMENT_TOP_RIGHT:
            tempPlacement = PLACEMENT_BOTTOM_RIGHT;
            break;
 
            case PLACEMENT_CENTER_LEFT:
            tempPlacement = PLACEMENT_CENTER_RIGHT;
            break;
            case PLACEMENT_CENTER_RIGHT:
            tempPlacement = PLACEMENT_CENTER_LEFT;
            break;
 
            case PLACEMENT_BOTTOM_LEFT:
            tempPlacement = PLACEMENT_TOP_LEFT;
            break;
            case PLACEMENT_BOTTOM_CENTER:
            tempPlacement = PLACEMENT_TOP_CENTER;
            break;
            case PLACEMENT_BOTTOM_RIGHT:
            tempPlacement = PLACEMENT_TOP_RIGHT;
            break;
 
            default:
            tempPlacement = PLACEMENT_CENTER_RIGHT;
        }
    }
 
    //====================
 
    switch (tempPlacement)
    {
        //====================
 
        case PLACEMENT_MANUAL:
        {
            // Centered placement for x or y requested?
            // (optionally with +/- offset from centered position through input rcx/rcy values, see ParsePlacement() above)
            if (inputPlacement->centeredx) inputPlacement->x = inputPlacement->rcx + (ScreenWidth - inputPlacement->width) / 2;
            else inputPlacement->x = inputPlacement->rcx;
            if (inputPlacement->centeredy) inputPlacement->y = inputPlacement->rcy + (ScreenHeight - inputPlacement->height) / 2;
            else inputPlacement->y = inputPlacement->rcy;
 
            // Negative coordinates -> Offset from the bottom right corner of the screen,
            // relative to bottom right corner of the window...
            if (inputPlacement->x < 0) inputPlacement->x = ScreenWidth + inputPlacement->x - inputPlacement->width;
            if (inputPlacement->y < 0) inputPlacement->y = ScreenHeight + inputPlacement->y - inputPlacement->height;
 
            // Make sure the window is inside the visible screen...
            int xmax = ScreenWidth - inputPlacement->width;
            int ymax = ScreenHeight - inputPlacement->height;
            if (inputPlacement->x < 0) inputPlacement->x = 0;
            if (inputPlacement->y < 0) inputPlacement->y = 0;
            if (inputPlacement->x > xmax) inputPlacement->x = xmax;
            if (inputPlacement->y > ymax) inputPlacement->y = ymax;
        }
        break;
 
        //====================
 
        case PLACEMENT_TOP_LEFT:
        {
            inputPlacement->x = 0;
            inputPlacement->y = 0;
        }
        break;
 
        //====================
 
        case PLACEMENT_TOP_CENTER:
        {
            inputPlacement->x = (ScreenWidth - inputPlacement->width) / 2;
            inputPlacement->y = 0;
        }
        break;
 
        //====================
 
        case PLACEMENT_TOP_RIGHT:
        {
            inputPlacement->x = ScreenWidth - inputPlacement->width;
            inputPlacement->y = 0;
        }
        break;
 
        //====================
 
        case PLACEMENT_BOTTOM_LEFT:
        {
            inputPlacement->x = 0;
            inputPlacement->y = ScreenHeight - inputPlacement->height;
        }
        break;
 
        //====================
 
        case PLACEMENT_BOTTOM_CENTER:
        {
            inputPlacement->x = (ScreenWidth - inputPlacement->width) / 2;
            inputPlacement->y = ScreenHeight - inputPlacement->height;
        }
        break;
 
        //====================
 
        case PLACEMENT_BOTTOM_RIGHT:
        {
            inputPlacement->x = ScreenWidth - inputPlacement->width;
            inputPlacement->y = ScreenHeight - inputPlacement->height;
        }
        break;
 
        //====================
 
        case PLACEMENT_CENTER_LEFT:
        {
            inputPlacement->x = 0;
            inputPlacement->y = (ScreenHeight - inputPlacement->height) / 2;
        }
        break;
 
        //====================
 
        case PLACEMENT_CENTER_CENTER:
        {
            inputPlacement->x = (ScreenWidth - inputPlacement->width) / 2;
            inputPlacement->y = (ScreenHeight - inputPlacement->height) / 2;
        }
        break;
 
        //====================
 
        case PLACEMENT_DEFAULT: // (used by the console)
        {
            inputPlacement->x = (ScreenWidth - inputPlacement->width) / 2;
//          inputPlacement->y = ScreenHeight - desktopArea.bottom - inputPlacement->height - inputPlacement->x;
            inputPlacement->y = ScreenHeight - inputPlacement->height - inputPlacement->x;
        }
        break;
 
        //====================
 
        default: // PLACEMENT_CENTER_RIGHT
        {
            inputPlacement->x = ScreenWidth - inputPlacement->width;
            inputPlacement->y = (ScreenHeight - inputPlacement->height) / 2;
        }
    }
 
    inputPlacement->x += ScreenX;
    inputPlacement->y += ScreenY;
}

WritePlacement()

void Settings::WritePlacement

(

Placement *

inputPlacement

)

{
    char outputString[255], outputX[5], outputY[5];
 
    switch (inputPlacement->placement)
    {
        //====================
 
        case PLACEMENT_MANUAL:
        {
            if (inputPlacement->centeredx) // -> Center relative x positioning
            {
                if (inputPlacement->rcx != 0) sprintf(outputX, "xC%d", inputPlacement->rcx);
                else strcpy(outputX, "xC");
            }
            else sprintf(outputX, "x%d", inputPlacement->rcx); // -> Left/Right relative x positioning
 
            if (inputPlacement->centeredy) // -> Center relative y positioning
            {
                if (inputPlacement->rcy != 0) sprintf(outputY, "yC%d", inputPlacement->rcy);
                else strcpy(outputY, "yC");
            }
            else sprintf(outputY, "y%d", inputPlacement->rcy); // -> Top/Bottom relative y positioning
 
            sprintf(outputString, "Manual %s %s", outputX, outputY);
            break;
        }
 
        //====================
 
        case PLACEMENT_TOP_LEFT:          { strcpy(outputString, "TopLeft"); break; }
        case PLACEMENT_TOP_CENTER:          { strcpy(outputString, "TopCenter"); break; }
        case PLACEMENT_TOP_RIGHT:            { strcpy(outputString, "TopRight"); break; }
 
        case PLACEMENT_CENTER_LEFT:            { strcpy(outputString, "CenterLeft"); break; }
        case PLACEMENT_CENTER_CENTER:        { strcpy(outputString, "CenterCenter"); break; }
        case PLACEMENT_CENTER_RIGHT:      { strcpy(outputString, "CenterRight"); break; }
 
        case PLACEMENT_BOTTOM_LEFT:            { strcpy(outputString, "BottomLeft"); break; }
        case PLACEMENT_BOTTOM_CENTER:        { strcpy(outputString, "BottomCenter"); break; }
        case PLACEMENT_BOTTOM_RIGHT:      { strcpy(outputString, "BottomRight"); break; }
 
        case PLACEMENT_OPPOSITE_TOOLBAR:  { strcpy(outputString, "OppositeToolbar"); break; }
 
        case PLACEMENT_DEFAULT:                { strcpy(outputString, "Default"); break; }
 
        //====================
 
        default:
        return;
    }
 
//  strncpy(inputPlacement->rcString, outputString, sizeof(inputPlacement->rcString)); // Save the new .rc placement string, we might need it later...
    strncpy_s(inputPlacement->rcString, sizeof(inputPlacement->rcString), outputString, _TRUNCATE); // Save the new .rc placement string, we might need it later...
 
    if (inputPlacement == &ToolbarPlacement) WriteString(xobrcFile, "xoblite.toolbar.placement:", outputString);
    else if (inputPlacement == &DockPlacement) WriteString(xobrcFile, "xoblite.dock.placement:", outputString);
    else if (inputPlacement == &ConsolePlacement) WriteString(xobrcFile, "xoblite.console.placement:", outputString);
    else if (inputPlacement == &desktopClockPlacement) WriteString(xobrcFile, "xoblite.desktop.clock.placement:", outputString);
    else if (inputPlacement == &desktopWeekdayPlacement) WriteString(xobrcFile, "xoblite.desktop.weekday.placement:", outputString);
    else if (inputPlacement == &desktopDatePlacement) WriteString(xobrcFile, "xoblite.desktop.date.placement:", outputString);
    else if (inputPlacement == &desktopGreetingPlacement) WriteString(xobrcFile, "xoblite.desktop.greeting.placement:", outputString);
}

WriteStyle()

void Settings::WriteStyle

(

)

{
    time_t systemTime;
    struct tm localTime;
    time(&systemTime);
    localtime_s(&localTime, &systemTime);
 
    char filename[MAX_PATH], path[MAX_PATH];
    _locale_t timestampLocale = _create_locale(LC_TIME, "en-US"); // -> Always use en-US format for the saved style filename timestamp...
    _strftime_l(filename, MAX_PATH, "\\xDesigner_%Y_%m_%d_%H%M%S.style", &localTime, timestampLocale);
    _free_locale(timestampLocale);
    strcpy(path, stylesFolder);
    strcat(path, filename);
 
    if (FileExists(path)) return;
    else
    {
        HANDLE file = CreateFile(path, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        if (file)
        {
            char szTemp[MAX_LINE_LENGTH];
            DWORD retLength = 0;
 
            strcpy(szTemp, "! --------------------------------------------------\r\n\r\n");
            WriteFile(file, szTemp, strlen(szTemp), &retLength, NULL);
 
            strcpy(szTemp, "style.name: <Auto-generated>\r\nstyle.author: <xoblite Designer mode>\r\nstyle.date: \r\nstyle.credits: \r\nstyle.comments: \r\nstyle.wallpaper: \r\n\r\n");
            WriteFile(file, szTemp, strlen(szTemp), &retLength, NULL);
 
            strcpy(szTemp, "! ----------------------------- wallpaper ----------\r\n\r\n");
            WriteFile(file, szTemp, strlen(szTemp), &retLength, NULL);
 
            sprintf(szTemp, "rootCommand: %s\r\n\r\n", rootCommand);
            WriteFile(file, szTemp, strlen(szTemp), &retLength, NULL);
 
            strcpy(szTemp, "! ------------------------------- toolbar ----------\r\n\r\n");
            WriteFile(file, szTemp, strlen(szTemp), &retLength, NULL);
 
            WriteStyleElement(file, Toolbar);
            if (!ToolbarBorder->parentRelative) WriteStyleElement(file, ToolbarBorder);
            WriteStyleElement(file, ToolbarLabel);
            WriteStyleElement(file, ToolbarWindowLabel);
            WriteStyleElement(file, ToolbarClock);
            WriteStyleElement(file, ToolbarButton);
            WriteStyleElement(file, ToolbarButtonPressed);
 
            strcpy(szTemp, "! ---------------------------------- menu ----------\r\n\r\n");
            WriteFile(file, szTemp, strlen(szTemp), &retLength, NULL);
 
            WriteStyleElement(file, MenuTitle);
            WriteStyleElement(file, MenuFrame);
            if (!MenuFrameBorder->parentRelative) WriteStyleElement(file, MenuFrameBorder);
            WriteStyleElement(file, MenuActive);
            WriteStyleElement(file, MenuGrip);
            WriteStyleElement(file, MenuIndicator);
            WriteStyleElement(file, MenuSeparator);
//          sprintf(szTemp, "menu.separator.color: #%02x%02x%02x\r\n\r\n", GetRValue(MenuSeparator->Color), GetGValue(MenuSeparator->Color), GetBValue(MenuSeparator->Color));
            WriteFile(file, szTemp, strlen(szTemp), &retLength, NULL);
 
            strcpy(szTemp, "menu.bullet: ");
            switch (menuBullet)
            {
                case MENU_BULLET_TRIANGLE: { strcat(szTemp, "Triangle\r\n"); break; }
                case MENU_BULLET_SQUARE: { strcat(szTemp, "Square\r\n"); break; }
                case MENU_BULLET_DIAMOND: { strcat(szTemp, "Diamond\r\n"); break; }
                case MENU_BULLET_CIRCLE: { strcat(szTemp, "Circle\r\n"); break; }
                case MENU_BULLET_TRIPLE: { strcat(szTemp, "Triple\r\n"); break; }
                case MENU_BULLET_COMMENT: { strcat(szTemp, "Comment\r\n"); break; }
                case MENU_BULLET_GRID: { strcat(szTemp, "Grid\r\n"); break; }
                case MENU_BULLET_QUAD: { strcat(szTemp, "Quad\r\n"); break; }
                default: { strcat(szTemp, "Empty\r\n"); break; }
            }
            WriteFile(file, szTemp, strlen(szTemp), &retLength, NULL);
 
            if (!_stricmp(menuBulletPosition, "right")) strcpy(szTemp, "menu.bullet.position: Right\r\n\r\n");
            else strcpy(szTemp, "menu.bullet.position: Left\r\n\r\n");
            WriteFile(file, szTemp, strlen(szTemp), &retLength, NULL);
 
            strcpy(szTemp, "! ---------------------------------- dock ----------\r\n\r\n");
            WriteFile(file, szTemp, strlen(szTemp), &retLength, NULL);
 
            WriteStyleElement(file, Dock);
            if (!DockBorder->parentRelative) WriteStyleElement(file, DockBorder);
 
            strcpy(szTemp, "! ------------------------------- console ----------\r\n\r\n");
            WriteFile(file, szTemp, strlen(szTemp), &retLength, NULL);
 
            sprintf(szTemp, "console.color: #%02x%02x%02x\r\n", GetRValue(Console->Color), GetGValue(Console->Color), GetBValue(Console->Color));
            WriteFile(file, szTemp, strlen(szTemp), &retLength, NULL);
            sprintf(szTemp, "console.textColor: #%02x%02x%02x\r\n", GetRValue(Console->TextColor), GetGValue(Console->TextColor), GetBValue(Console->TextColor));
            WriteFile(file, szTemp, strlen(szTemp), &retLength, NULL);
            sprintf(szTemp, "console.buttonColor: #%02x%02x%02x\r\n", GetRValue(Console->PicColor), GetGValue(Console->PicColor), GetBValue(Console->PicColor));
            WriteFile(file, szTemp, strlen(szTemp), &retLength, NULL);
 
            if ((scalingFactorHiDPI > 1) && (Console->FontHeight > 0)) sprintf(szTemp, "console.font: %s/%d/", Console->Font, (Console->FontHeight / scalingFactorHiDPI));
            else sprintf(szTemp, "console.font: %s/%d/", Console->Font, Console->FontHeight);
            if (Console->FontWeight == FW_BOLD) strcat(szTemp, "Bold\r\n\r\n");
            else strcat(szTemp, "Normal\r\n\r\n");
            WriteFile(file, szTemp, strlen(szTemp), &retLength, NULL);
 
            strcpy(szTemp, "! -------------------------------- window ----------\r\n\r\n");
            WriteFile(file, szTemp, strlen(szTemp), &retLength, NULL);
 
            WriteStyleElement(file, WindowTitleFocus);
            WriteStyleElement(file, WindowTitleUnfocus);
            WriteStyleElement(file, WindowLabelFocus);
            WriteStyleElement(file, WindowLabelUnfocus);
            WriteStyleElement(file, WindowButtonFocus);
            WriteStyleElement(file, WindowButtonUnfocus);
            WriteStyleElement(file, WindowButtonPressed);
            WriteStyleElement(file, WindowGripFocus);
            WriteStyleElement(file, WindowGripUnfocus);
            WriteStyleElement(file, WindowHandleFocus);
            WriteStyleElement(file, WindowHandleUnfocus);
 
//          sprintf(szTemp, "window.handleHeight: %d\r\n\r\n", (handleHeight/2));
//          WriteFile(file, szTemp, strlen(szTemp), &retLength, NULL);
 
//          strcpy(szTemp, "! --------------------------------------------------\r\n\r\n");
//          WriteFile(file, szTemp, strlen(szTemp), &retLength, NULL);
 
//          WriteStyleElement(file, ExternalHardware);
 
            strcpy(szTemp, "! --------------------------------------------------\r\n");
            WriteFile(file, szTemp, strlen(szTemp), &retLength, NULL);
        }
        CloseHandle(file);
    }
 
    char msg[MAX_LINE_LENGTH];
    sprintf(msg, "... style settings saved to %s .", path);
    SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_REGULAR_MESSAGE, (LPARAM)msg);
}

WriteStyleElement()

void Settings::WriteStyleElement	(	HANDLE	file,
		StyleItem *	styleItem )

{
    char styleElement[32], writeBuffer[MAX_LINE_LENGTH];
    DWORD retLength = 0;
 
    if (styleItem == Toolbar) strcpy(styleElement, "toolbar");
    else if (styleItem == ToolbarBorder) strcpy(styleElement, "toolbar.border");
    else if (styleItem == ToolbarLabel) strcpy(styleElement, "toolbar.label");
    else if (styleItem == ToolbarWindowLabel) strcpy(styleElement, "toolbar.windowLabel");
    else if (styleItem == ToolbarClock) strcpy(styleElement, "toolbar.clock");
    else if (styleItem == ToolbarButton) strcpy(styleElement, "toolbar.button");
    else if (styleItem == ToolbarButtonPressed) strcpy(styleElement, "toolbar.button.pressed");
    else if (styleItem == MenuTitle) strcpy(styleElement, "menu.title");
    else if (styleItem == MenuFrame) strcpy(styleElement, "menu.frame");
    else if (styleItem == MenuFrameBorder) strcpy(styleElement, "menu.frame.border");
    else if (styleItem == MenuActive) strcpy(styleElement, "menu.active");
    else if (styleItem == MenuGrip) strcpy(styleElement, "menu.grip");
    else if (styleItem == MenuIndicator) strcpy(styleElement, "menu.indicator");
    else if (styleItem == MenuSeparator) strcpy(styleElement, "menu.separator");
    // else if (styleItem == Dock) strcpy(styleElement, "slit");
    else if (styleItem == Dock) strcpy(styleElement, "dock");
    else if (styleItem == DockBorder) strcpy(styleElement, "dock.border");
    else if (styleItem == WindowTitleFocus) strcpy(styleElement, "window.title.focus");
    else if (styleItem == WindowTitleUnfocus) strcpy(styleElement, "window.title.unfocus");
    else if (styleItem == WindowLabelFocus) strcpy(styleElement, "window.label.focus");
    else if (styleItem == WindowLabelUnfocus) strcpy(styleElement, "window.label.unfocus");
    else if (styleItem == WindowButtonFocus) strcpy(styleElement, "window.button.focus");
    else if (styleItem == WindowButtonUnfocus) strcpy(styleElement, "window.button.unfocus");
    else if (styleItem == WindowButtonPressed) strcpy(styleElement, "window.button.pressed");
    else if (styleItem == WindowGripFocus) strcpy(styleElement, "window.grip.focus");
    else if (styleItem == WindowGripUnfocus) strcpy(styleElement, "window.grip.unfocus");
    else if (styleItem == WindowHandleFocus) strcpy(styleElement, "window.handle.focus");
    else if (styleItem == WindowHandleUnfocus) strcpy(styleElement, "window.handle.unfocus");
    else if (styleItem == ExternalHardware) strcpy(styleElement, "hardware");
    else return;
 
    //====================
 
    strcpy(writeBuffer, styleElement);
    strcat(writeBuffer, ".appearance:");
    if (styleItem->type == B_PARENTRELATIVE || styleItem->parentRelative) strcat(writeBuffer, " ParentRelative");
    else
    {
        if ((styleItem != ToolbarBorder) && (styleItem != MenuFrameBorder) && (styleItem != DockBorder) && (styleItem != ExternalHardware))
        {
            if (styleItem->bevelstyle == BEVEL_RAISED) strcat(writeBuffer, " Raised");
            else if (styleItem->bevelstyle == BEVEL_SUNKEN) strcat(writeBuffer, " Sunken");
            else strcat(writeBuffer, " Flat");
        }
 
        if (styleItem->type == B_SOLID) strcat(writeBuffer, " Solid");
        else
        {
            if ((styleItem != ToolbarBorder) && (styleItem != MenuFrameBorder) && (styleItem != DockBorder) && (styleItem != ExternalHardware))
            {
                strcat(writeBuffer, " Gradient");
            }
 
            switch (styleItem->type)
            {
                case B_HORIZONTAL: { strcat(writeBuffer, " Horizontal"); break; }
                case B_VERTICAL: { strcat(writeBuffer, " Vertical"); break; }
                case B_DIAGONAL: { strcat(writeBuffer, " Diagonal"); break; }
                case B_CROSSDIAGONAL: { strcat(writeBuffer, " CrossDiagonal"); break; }
                case B_PIPECROSS: { strcat(writeBuffer, " Pipecross"); break; }
                case B_ELLIPTIC: { strcat(writeBuffer, " Elliptic"); break; }
                case B_RECTANGLE: { strcat(writeBuffer, " Rectangle"); break; }
                case B_PYRAMID: { strcat(writeBuffer, " Pyramid"); break; }
                case B_MIRRORHORIZONTAL: { strcat(writeBuffer, " MirrorHorizontal"); break; }
                case B_MIRRORVERTICAL: { strcat(writeBuffer, " MirrorVertical"); break; }
                case B_SPLITSOLID: { strcat(writeBuffer, " SplitSolid"); break; }
                case B_SPLITHORIZONTAL: { strcat(writeBuffer, " SplitHorizontal"); break; }
                case B_SPLITVERTICAL: { strcat(writeBuffer, " SplitVertical"); break; }
                case B_SUPERHORIZONTAL: { strcat(writeBuffer, " SuperHorizontal"); break; }
                case B_SUPERVERTICAL: { strcat(writeBuffer, " SuperVertical"); break; }
                default: break;
            }
        }
 
        if ((styleItem != ToolbarBorder) && (styleItem != MenuFrameBorder) && (styleItem != DockBorder) && (styleItem != ExternalHardware))
        {
            if (styleItem->bevelstyle != BEVEL_FLAT)
            {
                if (styleItem->bevelposition == BEVEL2) strcat(writeBuffer, " Bevel2");
                else strcat(writeBuffer, " Bevel1");
            }
 
            if (styleItem->interlaced) strcat(writeBuffer, " Interlaced");
        }
    }
    strcat(writeBuffer, "\r\n");
    WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
 
    //====================
 
    char colorString[10];
 
    if (styleItem->type != B_PARENTRELATIVE && !styleItem->parentRelative)
    {
        strcpy(writeBuffer, styleElement);
        if (styleItem->type == B_SOLID) strcat(writeBuffer, ".color:");
        else strcat(writeBuffer, ".color1:");
        sprintf(colorString, " #%02x%02x%02x\r\n", GetRValue(styleItem->Color1), GetGValue(styleItem->Color1), GetBValue(styleItem->Color1));
        strcat(writeBuffer, colorString);
        WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
 
        if (styleItem->type != B_SOLID)
        {
            strcpy(writeBuffer, styleElement);
            strcat(writeBuffer, ".color2:");
            sprintf(colorString, " #%02x%02x%02x\r\n", GetRValue(styleItem->Color2), GetGValue(styleItem->Color2), GetBValue(styleItem->Color2));
            strcat(writeBuffer, colorString);
            WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
 
            if (styleItem->type == B_SPLITHORIZONTAL || styleItem->type == B_SPLITVERTICAL || styleItem->type == B_SUPERHORIZONTAL || styleItem->type == B_SUPERVERTICAL)
            {
                strcpy(writeBuffer, styleElement);
                strcat(writeBuffer, ".color3:");
                sprintf(colorString, " #%02x%02x%02x\r\n", GetRValue(styleItem->Color3), GetGValue(styleItem->Color3), GetBValue(styleItem->Color3));
                strcat(writeBuffer, colorString);
                WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
 
                strcpy(writeBuffer, styleElement);
                strcat(writeBuffer, ".color4:");
                sprintf(colorString, " #%02x%02x%02x\r\n", GetRValue(styleItem->Color4), GetGValue(styleItem->Color4), GetBValue(styleItem->Color4));
                strcat(writeBuffer, colorString);
                WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
 
                if (styleItem->type == B_SUPERHORIZONTAL || styleItem->type == B_SUPERVERTICAL)
                {
                    strcpy(writeBuffer, styleElement);
                    strcat(writeBuffer, ".color5:");
                    sprintf(colorString, " #%02x%02x%02x\r\n", GetRValue(styleItem->Color5), GetGValue(styleItem->Color5), GetBValue(styleItem->Color5));
                    strcat(writeBuffer, colorString);
                    WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
 
                    strcpy(writeBuffer, styleElement);
                    strcat(writeBuffer, ".color6:");
                    sprintf(colorString, " #%02x%02x%02x\r\n", GetRValue(styleItem->Color6), GetGValue(styleItem->Color6), GetBValue(styleItem->Color6));
                    strcat(writeBuffer, colorString);
                    WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
 
                    strcpy(writeBuffer, styleElement);
                    strcat(writeBuffer, ".color7:");
                    sprintf(colorString, " #%02x%02x%02x\r\n", GetRValue(styleItem->Color7), GetGValue(styleItem->Color7), GetBValue(styleItem->Color7));
                    strcat(writeBuffer, colorString);
                    WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
 
                    strcpy(writeBuffer, styleElement);
                    strcat(writeBuffer, ".color8:");
                    sprintf(colorString, " #%02x%02x%02x\r\n", GetRValue(styleItem->Color8), GetGValue(styleItem->Color8), GetBValue(styleItem->Color8));
                    strcat(writeBuffer, colorString);
                    WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
                }
            }
        }
    }
 
    //====================
 
    if ((styleItem != ToolbarButton) && (styleItem != ToolbarButtonPressed) && (styleItem != MenuActive) && (styleItem != MenuIndicator) && (styleItem != MenuSeparator) && (styleItem != Dock) && 
        (styleItem != ToolbarBorder) && (styleItem != MenuFrameBorder) && (styleItem != DockBorder) &&
        (styleItem != WindowTitleFocus) && (styleItem != WindowButtonFocus) && (styleItem != WindowGripFocus) && (styleItem != WindowHandleFocus) && (styleItem != WindowButtonPressed) &&
        (styleItem != WindowTitleUnfocus) && (styleItem != WindowButtonUnfocus) && (styleItem != WindowGripUnfocus) && (styleItem != WindowHandleUnfocus) &&
        (styleItem != ExternalHardware))
    {
        if ((scalingFactorHiDPI > 1) && (styleItem->FontHeight > 0)) sprintf(writeBuffer, "%s.font: %s/%d/", styleElement, styleItem->Font, (styleItem->FontHeight / scalingFactorHiDPI));
        else sprintf(writeBuffer, "%s.font: %s/%d/", styleElement, styleItem->Font, styleItem->FontHeight);
        if (styleItem->FontWeight == FW_BOLD) strcat(writeBuffer, "Bold\r\n");
        else strcat(writeBuffer, "Normal\r\n");
        WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
 
        strcpy(writeBuffer, styleElement);
        strcat(writeBuffer, ".alignment: ");
        if (styleItem->Justify == DT_LEFT) strcat(writeBuffer, "Left\r\n");
        else if (styleItem->Justify == DT_RIGHT) strcat(writeBuffer, "Right\r\n");
        else strcat(writeBuffer, "Center\r\n");
        WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
    }
 
    if ((styleItem != ToolbarButton) && (styleItem != ToolbarButtonPressed) && (styleItem != MenuIndicator) && (styleItem != MenuSeparator) && (styleItem != Dock) &&
        (styleItem != ToolbarBorder) && (styleItem != MenuFrameBorder) && (styleItem != DockBorder) &&
        (styleItem != WindowTitleFocus) && (styleItem != WindowButtonFocus) && (styleItem != WindowGripFocus) && (styleItem != WindowHandleFocus) && (styleItem != WindowButtonPressed) &&
        (styleItem != WindowTitleUnfocus) && (styleItem != WindowButtonUnfocus) && (styleItem != WindowGripUnfocus) && (styleItem != WindowHandleUnfocus) &&
        (styleItem != ExternalHardware))
    {
        strcpy(writeBuffer, styleElement);
        strcat(writeBuffer, ".textColor:");
        sprintf(colorString, " #%02x%02x%02x\r\n", GetRValue(styleItem->TextColor), GetGValue(styleItem->TextColor), GetBValue(styleItem->TextColor));
        strcat(writeBuffer, colorString);
        WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
 
        if (styleItem->FontOutline)
        {
            strcpy(writeBuffer, styleElement);
            strcat(writeBuffer, ".outlineColor:");
            sprintf(colorString, " #%02x%02x%02x\r\n", GetRValue(styleItem->OutlineColor), GetGValue(styleItem->OutlineColor), GetBValue(styleItem->OutlineColor));
            strcat(writeBuffer, colorString);
            WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
        }
 
        if (styleItem->FontShadow)
        {
            strcpy(writeBuffer, styleElement);
            strcat(writeBuffer, ".shadowColor:");
            sprintf(colorString, " #%02x%02x%02x\r\n", GetRValue(styleItem->ShadowColor), GetGValue(styleItem->ShadowColor), GetBValue(styleItem->ShadowColor));
            strcat(writeBuffer, colorString);
            WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
        }
    }
 
//  if ((styleItem == MenuFrame) || (styleItem == MenuActive))
    if (styleItem == MenuFrame)
    {
        strcpy(writeBuffer, styleElement);
        strcat(writeBuffer, ".disabledColor:");
        sprintf(colorString, " #%02x%02x%02x\r\n", GetRValue(styleItem->disabledColor), GetGValue(styleItem->disabledColor), GetBValue(styleItem->disabledColor));
        strcat(writeBuffer, colorString);
        WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
    }
 
    //====================
 
    if ((styleItem == ToolbarButton) || (styleItem == ToolbarButtonPressed) || (styleItem == WindowButtonFocus) || (styleItem == WindowButtonUnfocus) || (styleItem == WindowButtonPressed))
    {
        strcpy(writeBuffer, styleElement);
        strcat(writeBuffer, ".picColor:");
        sprintf(colorString, " #%02x%02x%02x\r\n", GetRValue(styleItem->PicColor), GetGValue(styleItem->PicColor), GetBValue(styleItem->PicColor));
        strcat(writeBuffer, colorString);
        WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
    }
 
    if ((styleItem == MenuFrame) || (styleItem == MenuActive))
    {
        strcpy(writeBuffer, styleElement);
        strcat(writeBuffer, ".bulletColor:");
        sprintf(colorString, " #%02x%02x%02x\r\n", GetRValue(styleItem->BulletColor), GetGValue(styleItem->BulletColor), GetBValue(styleItem->BulletColor));
        strcat(writeBuffer, colorString);
        WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
    }
 
    //====================
 
    if ((styleItem != MenuSeparator) && (styleItem != ToolbarBorder) && (styleItem != MenuFrameBorder) && (styleItem != DockBorder) && (styleItem != ExternalHardware))
    {
        if ((scalingFactorHiDPI > 1) && (styleItem->marginWidth > 0)) sprintf(writeBuffer, "%s.marginWidth: %d\r\n", styleElement, (styleItem->marginWidth / scalingFactorHiDPI));
        else sprintf(writeBuffer, "%s.marginWidth: %d\r\n", styleElement, styleItem->marginWidth);
        WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
 
        if (styleItem->type != B_PARENTRELATIVE && !styleItem->parentRelative)
        {
            if ((scalingFactorHiDPI > 1) && (styleItem->borderWidth > 0)) sprintf(writeBuffer, "%s.borderWidth: %d\r\n", styleElement, (styleItem->borderWidth / scalingFactorHiDPI));
            else sprintf(writeBuffer, "%s.borderWidth: %d\r\n", styleElement, styleItem->borderWidth);
            WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
 
            if (styleItem->borderWidth > 0)
            {
                strcpy(writeBuffer, styleElement);
                strcat(writeBuffer, ".borderColor:");
                sprintf(colorString, " #%02x%02x%02x\r\n", GetRValue(styleItem->borderColor), GetGValue(styleItem->borderColor), GetBValue(styleItem->borderColor));
                strcat(writeBuffer, colorString);
                WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
            }
        }
    }
 
    //====================
 
    strcpy(writeBuffer, "\r\n");
    WriteFile(file, writeBuffer, strlen(writeBuffer), &retLength, NULL);
}

Member Data Documentation

menuFile

char Settings::menuFile[MAX_LINE_LENGTH]

menuSeparators

bool Settings::menuSeparators

menuRoundedCorners

bool Settings::menuRoundedCorners

menuTransparencyAlpha

BYTE Settings::menuTransparencyAlpha

menuTitleTransparencyAlpha

BYTE Settings::menuTitleTransparencyAlpha

menuFrameTransparencyAlpha

BYTE Settings::menuFrameTransparencyAlpha

menuGripTransparencyAlpha

BYTE Settings::menuGripTransparencyAlpha

menuActiveTransparencyAlpha

BYTE Settings::menuActiveTransparencyAlpha

submenuGap

int Settings::submenuGap

submenuDelay

int Settings::submenuDelay

toolbarHidden

bool Settings::toolbarHidden

ToolbarPlacement

Placement Settings::ToolbarPlacement

toolbarPlacementString

char Settings::toolbarPlacementString[MAX_LINE_LENGTH]

toolbarVertical

bool Settings::toolbarVertical

toolbarHorizontalWidth

int Settings::toolbarHorizontalWidth

toolbarVerticalWidth

int Settings::toolbarVerticalWidth

toolbarSnapToEdges

bool Settings::toolbarSnapToEdges

toolbarTransparencyAlpha

BYTE Settings::toolbarTransparencyAlpha

toolbarLabelTransparencyAlpha

BYTE Settings::toolbarLabelTransparencyAlpha

toolbarWindowLabelTransparencyAlpha

BYTE Settings::toolbarWindowLabelTransparencyAlpha

toolbarClockTransparencyAlpha

BYTE Settings::toolbarClockTransparencyAlpha

toolbarButtonTransparencyAlpha

BYTE Settings::toolbarButtonTransparencyAlpha

toolbarRoundedCorners

bool Settings::toolbarRoundedCorners

toolbarOnTop

bool Settings::toolbarOnTop

toolbarClockFormat

char Settings::toolbarClockFormat[MAX_LINE_LENGTH]

toolbarLabelHidden

bool Settings::toolbarLabelHidden

toolbarDownUpButtonsHidden

bool Settings::toolbarDownUpButtonsHidden

toolbarLeftRightButtonsHidden

bool Settings::toolbarLeftRightButtonsHidden

toolbarClockHidden

bool Settings::toolbarClockHidden

toolbarAllowAsymmetry

bool Settings::toolbarAllowAsymmetry

toolbarDownButtonOverride

char Settings::toolbarDownButtonOverride[MAX_LINE_LENGTH]

toolbarUpButtonOverride

char Settings::toolbarUpButtonOverride[MAX_LINE_LENGTH]

toolbarLeftButtonOverride

char Settings::toolbarLeftButtonOverride[MAX_LINE_LENGTH]

toolbarRightButtonOverride

char Settings::toolbarRightButtonOverride[MAX_LINE_LENGTH]

taskbarMode

int Settings::taskbarMode

taskbarMaxItems

int Settings::taskbarMaxItems

taskbarSorting

int Settings::taskbarSorting

taskbarShowTaskWorkspace

bool Settings::taskbarShowTaskWorkspace

taskbarCurrentOnly

bool Settings::taskbarCurrentOnly

taskbarFlashing

bool Settings::taskbarFlashing

taskbarSaturationValue

unsigned int Settings::taskbarSaturationValue

taskbarHueIntensity

unsigned int Settings::taskbarHueIntensity

taskbarActiveSatHue

bool Settings::taskbarActiveSatHue

taskbarActiveTransparencyAlpha

BYTE Settings::taskbarActiveTransparencyAlpha

taskbarActiveLivePreview

bool Settings::taskbarActiveLivePreview

taskbarInactiveBackground

bool Settings::taskbarInactiveBackground

taskbarTooltips

bool Settings::taskbarTooltips

dockHidden

bool Settings::dockHidden

DockPlacement

Placement Settings::DockPlacement

dockPlacementString

char Settings::dockPlacementString[MAX_LINE_LENGTH]

dockDirection

char Settings::dockDirection[MAX_LINE_LENGTH]

dockVertical

bool Settings::dockVertical

dockPuzzlePositioning

bool Settings::dockPuzzlePositioning

dockOnTop

bool Settings::dockOnTop

dockSnapToEdges

bool Settings::dockSnapToEdges

dockTransparencyAlpha

BYTE Settings::dockTransparencyAlpha

consoleHidden

bool Settings::consoleHidden

ConsolePlacement

Placement Settings::ConsolePlacement

consoleMaximized

bool Settings::consoleMaximized

consoleMaximizedWidth

int Settings::consoleMaximizedWidth

consoleMaximizedMessages

int Settings::consoleMaximizedMessages

consoleRestoredWidth

int Settings::consoleRestoredWidth

consoleRestoredMessages

int Settings::consoleRestoredMessages

consoleTransparencyAlpha

BYTE Settings::consoleTransparencyAlpha

consoleDesktopMode

bool Settings::consoleDesktopMode

consoleRoundedCorners

bool Settings::consoleRoundedCorners

consolePadding

int Settings::consolePadding

desktopClockHidden

bool Settings::desktopClockHidden

desktopClockType

char Settings::desktopClockType[MAX_LINE_LENGTH]

desktopClockPlacement

Placement Settings::desktopClockPlacement

desktopClockTransparencyAlpha

BYTE Settings::desktopClockTransparencyAlpha

desktopClockFontDefined

bool Settings::desktopClockFontDefined

desktopClockFont

char Settings::desktopClockFont[128]

desktopClockFontHeight

int Settings::desktopClockFontHeight

desktopClockFontWeight

int Settings::desktopClockFontWeight

desktopWeekdayHidden

bool Settings::desktopWeekdayHidden

desktopWeekdayPlacement

Placement Settings::desktopWeekdayPlacement

desktopWeekdayTransparencyAlpha

BYTE Settings::desktopWeekdayTransparencyAlpha

desktopWeekdayFontDefined

bool Settings::desktopWeekdayFontDefined

desktopWeekdayFont

char Settings::desktopWeekdayFont[128]

desktopWeekdayFontHeight

int Settings::desktopWeekdayFontHeight

desktopWeekdayFontWeight

int Settings::desktopWeekdayFontWeight

desktopDateHidden

bool Settings::desktopDateHidden

desktopDateFormat

char Settings::desktopDateFormat[MAX_LINE_LENGTH]

desktopDatePlacement

Placement Settings::desktopDatePlacement

desktopDateTransparencyAlpha

BYTE Settings::desktopDateTransparencyAlpha

desktopDateFontDefined

bool Settings::desktopDateFontDefined

desktopDateFont

char Settings::desktopDateFont[128]

desktopDateFontHeight

int Settings::desktopDateFontHeight

desktopDateFontWeight

int Settings::desktopDateFontWeight

desktopGreetingHidden

bool Settings::desktopGreetingHidden

desktopGreetingPlacement

Placement Settings::desktopGreetingPlacement

desktopGreetingTransparencyAlpha

BYTE Settings::desktopGreetingTransparencyAlpha

desktopGreetingFontDefined

bool Settings::desktopGreetingFontDefined

desktopGreetingFont

char Settings::desktopGreetingFont[128]

desktopGreetingFontHeight

int Settings::desktopGreetingFontHeight

desktopGreetingFontWeight

int Settings::desktopGreetingFontWeight

desktopWorkspaceIndicatorHidden

bool Settings::desktopWorkspaceIndicatorHidden

desktopBorderHidden

bool Settings::desktopBorderHidden

desktopWidgetColor

COLORREF Settings::desktopWidgetColor

desktopRClickOverride

char Settings::desktopRClickOverride[MAX_LINE_LENGTH]

desktopMClickOverride

char Settings::desktopMClickOverride[MAX_LINE_LENGTH]

desktopX1ClickOverride

char Settings::desktopX1ClickOverride[MAX_LINE_LENGTH]

desktopX2ClickOverride

char Settings::desktopX2ClickOverride[MAX_LINE_LENGTH]

hotkeysFile

char Settings::hotkeysFile[MAX_LINE_LENGTH]

numberOfWorkspaces

int Settings::numberOfWorkspaces

workspaceNames

char Settings::workspaceNames[MAX_LINE_LENGTH]

mousewheelChanging

bool Settings::mousewheelChanging

followActive

bool Settings::followActive

wallpaperPerWorkspace

bool Settings::wallpaperPerWorkspace

wallpaperPerWorkspaceSemaphore

bool Settings::wallpaperPerWorkspaceSemaphore

pluginsFile

char Settings::pluginsFile[MAX_LINE_LENGTH]

pluginsHidden

bool Settings::pluginsHidden

pluginsRepository

char Settings::pluginsRepository[MAX_LINE_LENGTH]

themesFolder

char Settings::themesFolder[MAX_PATH]

stylesFolder

char Settings::stylesFolder[MAX_PATH]

wallpapersFolder

char Settings::wallpapersFolder[MAX_PATH]

soundsFolder

char Settings::soundsFolder[MAX_PATH]

selectedTheme

char Settings::selectedTheme[MAX_PATH]

styleFile

char Settings::styleFile[MAX_LINE_LENGTH]

doubleScaleHiDPI

bool Settings::doubleScaleHiDPI

scalingFactorHiDPI

int Settings::scalingFactorHiDPI

multimonPlacements

bool Settings::multimonPlacements

enableSoundFX

bool Settings::enableSoundFX

designerModeEnabled

bool Settings::designerModeEnabled

writeProtection

bool Settings::writeProtection

disableRootCommands

bool Settings::disableRootCommands

disableThemeFonts

bool Settings::disableThemeFonts

disableScriptSupport

bool Settings::disableScriptSupport

disableUnicodeParsing

bool Settings::disableUnicodeParsing

explorerHidden

bool Settings::explorerHidden

timeDateLocale

char Settings::timeDateLocale[MAX_LINE_LENGTH]

preferredEditor

char Settings::preferredEditor[MAX_LINE_LENGTH]

checkedForUpdates

char Settings::checkedForUpdates[20]

edgeSnapThreshold

int Settings::edgeSnapThreshold

debugLogging

bool Settings::debugLogging

machineArchitecture

USHORT Settings::machineArchitecture

operatingSystemVersion

int Settings::operatingSystemVersion

runningUnderWOW64

BOOL Settings::runningUnderWOW64

underExplorer

bool Settings::underExplorer

accessLock

bool Settings::accessLock

currentWorkspace

int Settings::currentWorkspace

lastWorkspace

int Settings::lastWorkspace

SF_blackboxPath

char Settings::SF_blackboxPath[MAX_PATH]

SF_startMenu

char Settings::SF_startMenu[MAX_PATH]

SF_commonStartMenu

char Settings::SF_commonStartMenu[MAX_PATH]

SF_programFiles

char Settings::SF_programFiles[MAX_PATH]

SF_desktop

char Settings::SF_desktop[MAX_PATH]

SF_userAppData

char Settings::SF_userAppData[MAX_PATH]

SF_userProfile

char Settings::SF_userProfile[MAX_PATH]

SF_currentThemePath

char Settings::SF_currentThemePath[MAX_PATH]

usingDefaultTheme

bool Settings::usingDefaultTheme

menuEditboxAlreadyActive

bool Settings::menuEditboxAlreadyActive

menuEditboxStringItemPtr

MenuItem* Settings::menuEditboxStringItemPtr

checkingForUpdates

bool Settings::checkingForUpdates

Statistics

struct Settings::Statistics Settings::Statistics

bbrcFile

char Settings::bbrcFile[MAX_LINE_LENGTH]

xobrcFile

char Settings::xobrcFile[MAX_LINE_LENGTH]

xobrcDefaultFile

char Settings::xobrcDefaultFile[MAX_LINE_LENGTH]

bbrcCache

char* Settings::bbrcCache

xobrcCache

char* Settings::xobrcCache

xobrcDefaultCache

char* Settings::xobrcDefaultCache

styleCache

char* Settings::styleCache

Wildcard

StyleItem* Settings::Wildcard

Toolbar

StyleItem* Settings::Toolbar

ToolbarLabel

StyleItem* Settings::ToolbarLabel

ToolbarWindowLabel

StyleItem* Settings::ToolbarWindowLabel

ToolbarClock

StyleItem* Settings::ToolbarClock

ToolbarButton

StyleItem* Settings::ToolbarButton

ToolbarButtonPressed

StyleItem* Settings::ToolbarButtonPressed

ToolbarBorder

StyleItem* Settings::ToolbarBorder

MenuTitle

StyleItem* Settings::MenuTitle

MenuFrame

StyleItem* Settings::MenuFrame

MenuActive

StyleItem* Settings::MenuActive

MenuGrip

StyleItem* Settings::MenuGrip

MenuFrameBullet

StyleItem* Settings::MenuFrameBullet

MenuActiveBullet

StyleItem* Settings::MenuActiveBullet

MenuIndicator

StyleItem* Settings::MenuIndicator

MenuSeparator

StyleItem* Settings::MenuSeparator

MenuFrameBorder

StyleItem* Settings::MenuFrameBorder

Dock

StyleItem* Settings::Dock

DockBorder

StyleItem* Settings::DockBorder

ActiveTask

StyleItem* Settings::ActiveTask

InactiveTask

StyleItem* Settings::InactiveTask

FlashingTask

StyleItem* Settings::FlashingTask

Console

StyleItem* Settings::Console

WindowTitleFocus

StyleItem* Settings::WindowTitleFocus

WindowTitleUnfocus

StyleItem* Settings::WindowTitleUnfocus

WindowLabelFocus

StyleItem* Settings::WindowLabelFocus

WindowLabelUnfocus

StyleItem* Settings::WindowLabelUnfocus

WindowButtonFocus

StyleItem* Settings::WindowButtonFocus

WindowButtonUnfocus

StyleItem* Settings::WindowButtonUnfocus

WindowButtonPressed

StyleItem* Settings::WindowButtonPressed

WindowGripFocus

StyleItem* Settings::WindowGripFocus

WindowGripUnfocus

StyleItem* Settings::WindowGripUnfocus

WindowHandleFocus

StyleItem* Settings::WindowHandleFocus

WindowHandleUnfocus

StyleItem* Settings::WindowHandleUnfocus

ExternalHardware

StyleItem* Settings::ExternalHardware

selectedElement

StyleItem* Settings::selectedElement

wildcardToolbarFont

char Settings::wildcardToolbarFont[255]

wildcardMenuFont

char Settings::wildcardMenuFont[255]

wildcardWindowFont

char Settings::wildcardWindowFont[255]

wildcard

char Settings::wildcard[MAX_LINE_LENGTH]

toolbar

char Settings::toolbar[MAX_LINE_LENGTH]

toolbarLabel

char Settings::toolbarLabel[MAX_LINE_LENGTH]

toolbarWindowLabel

char Settings::toolbarWindowLabel[MAX_LINE_LENGTH]

toolbarClock

char Settings::toolbarClock[MAX_LINE_LENGTH]

toolbarButton

char Settings::toolbarButton[MAX_LINE_LENGTH]

toolbarButtonPressed

char Settings::toolbarButtonPressed[MAX_LINE_LENGTH]

toolbarBorder

char Settings::toolbarBorder[MAX_LINE_LENGTH]

menuTitle

char Settings::menuTitle[MAX_LINE_LENGTH]

menuFrame

char Settings::menuFrame[MAX_LINE_LENGTH]

menuActive

char Settings::menuActive[MAX_LINE_LENGTH]

menuGrip

char Settings::menuGrip[MAX_LINE_LENGTH]

menuIndicator

char Settings::menuIndicator[MAX_LINE_LENGTH]

menuSeparator

char Settings::menuSeparator[MAX_LINE_LENGTH]

menuFrameBorder

char Settings::menuFrameBorder[MAX_LINE_LENGTH]

dock

char Settings::dock[MAX_LINE_LENGTH]

dockBorder

char Settings::dockBorder[MAX_LINE_LENGTH]

console

char Settings::console[MAX_LINE_LENGTH]

windowTitleFocus

char Settings::windowTitleFocus[MAX_LINE_LENGTH]

windowTitleUnfocus

char Settings::windowTitleUnfocus[MAX_LINE_LENGTH]

windowLabelFocus

char Settings::windowLabelFocus[MAX_LINE_LENGTH]

windowLabelUnfocus

char Settings::windowLabelUnfocus[MAX_LINE_LENGTH]

windowButtonFocus

char Settings::windowButtonFocus[MAX_LINE_LENGTH]

windowButtonUnfocus

char Settings::windowButtonUnfocus[MAX_LINE_LENGTH]

windowButtonPressed

char Settings::windowButtonPressed[MAX_LINE_LENGTH]

windowGripFocus

char Settings::windowGripFocus[MAX_LINE_LENGTH]

windowGripUnfocus

char Settings::windowGripUnfocus[MAX_LINE_LENGTH]

windowHandleFocus

char Settings::windowHandleFocus[MAX_LINE_LENGTH]

windowHandleUnfocus

char Settings::windowHandleUnfocus[MAX_LINE_LENGTH]

externalHardware

char Settings::externalHardware[MAX_LINE_LENGTH]

appearancePointer

LPSTR Settings::appearancePointer

menuBullet

int Settings::menuBullet

menuFrameBulletAsString

char Settings::menuFrameBulletAsString[MAX_LINE_LENGTH]

menuActiveBulletAsString

char Settings::menuActiveBulletAsString[MAX_LINE_LENGTH]

menuBulletPosition

char Settings::menuBulletPosition[MAX_LINE_LENGTH]

consoleFontDefined

bool Settings::consoleFontDefined

consoleFont

char Settings::consoleFont[128]

consoleFontHeight

int Settings::consoleFontHeight

consoleFontWeight

int Settings::consoleFontWeight

globalFontOverride

bool Settings::globalFontOverride

globalFont

char Settings::globalFont[128]

globalFontHeight

int Settings::globalFontHeight

borderWidth

int Settings::borderWidth

menuBorderWidth

int Settings::menuBorderWidth

borderColor

COLORREF Settings::borderColor

menuBorderColor

COLORREF Settings::menuBorderColor

bevelWidth

int Settings::bevelWidth

marginWidth

int Settings::marginWidth

handleHeight

int Settings::handleHeight

frameWidth

int Settings::frameWidth

rootCommand

char Settings::rootCommand[MAX_LINE_LENGTH]

ScreenWidth

int Settings::ScreenWidth

ScreenHeight

int Settings::ScreenHeight

ScreenX

int Settings::ScreenX

ScreenY

int Settings::ScreenY

red

BYTE Settings::red

green

BYTE Settings::green

blue

BYTE Settings::blue