#include <Console.h>

Public Types
typedef vector< messageListItem * >	messageListVector

Public Member Functions
	Console (HINSTANCE hInstance)

	~Console ()

void	UpdateConsoleWindow ()

void	DrawMessage (HDC hdc, RECT r, messageListItem *mLI)

void	GetDimensions ()

void	UpdatePosition ()

void	ToggleMaximized ()

void	BlockMessage (char *message)

void	ClearHistory (bool redraw)

Public Attributes
HINSTANCE	hConsoleInstance

HWND	hBlackboxWnd

HWND	hConsoleWnd

HDC	cachedBackground

int	ScreenWidth

int	ScreenHeight

int	ConsoleX

int	ConsoleY

int	ConsoleWidth

int	ConsoleHeight

int	consoleTrueFontHeight

int	lineSpacing

bool	ConsoleHidden

bool	blockMessages

RECT	consoleZoomButtonRect

RECT	consoleLockGlyphRect

messageListVector	messageList

char	messageToBlock [MAX_LINE_LENGTH]

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

Member Typedef Documentation

◆ messageListVector

typedef vector<messageListItem*> Console::messageListVector

Constructor & Destructor Documentation

◆ Console()

Console::Console ( HINSTANCE hInstance )

{
    hConsoleWnd = NULL;
    hBlackboxWnd = GetBBWnd();
    hConsoleInstance = hInstance;
    ZeroMemory(&messageList, sizeof(messageList));
    cachedBackground = CreateCompatibleDC(NULL);
    messageToBlock[0] = '\0';
 
    //====================
 
    // Get size and position for our window...
    GetDimensions();
 
    //====================
 
    // Register window class...
    WNDCLASS wc;
    ZeroMemory(&wc,sizeof(wc));
    wc.hInstance = hConsoleInstance;            // hInstance
    wc.lpfnWndProc = ConsoleWndProc;          // window procedure
    wc.lpszClassName = szConsoleName;          // window class name
    wc.hbrBackground = NULL;                    // no class background brush
    wc.style = CS_DBLCLKS;                      // class styles (e.g. accept doubleclicks)
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);   // always display the regular arrow cursor
 
    if (!RegisterClass(&wc))
    {
        MessageBox(0, "Error registering console window class!", szConsoleName, MB_OK | MB_ICONERROR | MB_TOPMOST);
        Log("Console", "Error registering window class!");
        return;
    }
 
    // Create console window...
    hConsoleWnd = CreateWindowEx(
        WS_EX_TOOLWINDOW | WS_EX_ACCEPTFILES | WS_EX_NOACTIVATE | WS_EX_LAYERED,   // window style
        szConsoleName,                                                             // window class
        NULL,                                                                       // window name
        WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,                               // window parameters
        ConsoleX,                                                                   // x position
        ConsoleY,                                                                   // y position
        ConsoleWidth,                                                               // window width
        ConsoleHeight,                                                             // window height
        NULL, //pDesktop->hDesktopWnd,                                              // owner window
        NULL,                                                                       // no menu
        hConsoleInstance,                                                           // hInstance
        NULL                                                                        // no window creation data
    );
 
    if (!hConsoleWnd)
    {
        UnregisterClass(szConsoleName,hConsoleInstance); // unregister window class
        MessageBox(0, "Error creating console window!", szConsoleName, MB_OK | MB_ICONERROR | MB_TOPMOST);
        Log("Console", "Error creating window!");
        return;
    }
 
    //====================
 
    // Subscribe to Blackbox messages applicable to the console...
    SendMessage(hBlackboxWnd, BB_REGISTERMESSAGE, (WPARAM)hConsoleWnd, (LPARAM)consoleMessageSubscription);
 
    // Make the console window sticky...
    MakeSticky(hConsoleWnd);
    // Set console window z-order position to be right above the desktop...
    SetWindowPos(hConsoleWnd, pDesktop->hDesktopWnd, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE | SWP_NOOWNERZORDER);
 
    // Update the console window...
    ShowWindow(hConsoleWnd, pSettings->consoleHidden ? SW_HIDE : SW_SHOWNOACTIVATE);
    UpdateConsoleWindow();
}

◆ ~Console()

Console::~Console ( )

{
    // Unsubscribe to previously subscribed Blackbox messages...
    SendMessage(hBlackboxWnd, BB_UNREGISTERMESSAGE, (WPARAM)hConsoleWnd, (LPARAM)consoleMessageSubscription);
 
    if (hConsoleWnd) DestroyWindow(hConsoleWnd); // Destroy the console window...
    UnregisterClass(szConsoleName, hConsoleInstance); // Unregister the console window class...
    
    if (cachedBackground) DeleteDC(cachedBackground); // Delete the cached gradient...
 
    ClearHistory(false); // Clear all elements in the messageList...
}

Member Function Documentation

◆ UpdateConsoleWindow()

void Console::UpdateConsoleWindow ( )

{
    // Fetch the new size and position parameters for our window...
//  GetDimensions();
 
    RECT r;
    SetRect(&r, 0, 0, ConsoleWidth, ConsoleHeight);
 
    HDC hdc = GetWindowDC(hConsoleWnd);
    HBITMAP bufbmp = CreateCompatibleBitmap(hdc, r.right-r.left, r.bottom-r.top);
    DeleteObject(SelectObject(cachedBackground, bufbmp));
    ReleaseDC(hConsoleWnd, hdc);
 
    //====================
 
    // Draw console background...
    HBRUSH brush;
    if (pSettings->consoleDesktopMode) brush = CreateSolidBrush(0x000000);
    else brush = CreateSolidBrush(pSettings->Console->Color);
    FillRect(cachedBackground, &r, brush);
    DeleteObject(brush);
 
    //====================
 
    if (!pSettings->consoleDesktopMode)
    {
        // Draw maximize/restore button background...
        brush = CreateSolidBrush(pSettings->Console->PicColor);
        FillRect(cachedBackground, &consoleZoomButtonRect, brush);
        DeleteObject(brush);
 
        // Draw maximize/restore button glyph...
        HPEN zoomPen = CreatePen(PS_SOLID, 1, pSettings->Console->Color);
        HPEN oldPen = (HPEN) SelectObject(cachedBackground, zoomPen);
 
        int offsetY = consoleZoomButtonRect.top + 7;
        int offsetX = consoleZoomButtonRect.left + 7;
 
        if (pSettings->consoleMaximized)
        {
            MoveToEx(cachedBackground, offsetX-4, offsetY-1, NULL);
            LineTo(cachedBackground, offsetX+1, offsetY-1);
            LineTo(cachedBackground, offsetX+1, offsetY+4);
            LineTo(cachedBackground, offsetX-4, offsetY+4);
            LineTo(cachedBackground, offsetX-4, offsetY-1);
            MoveToEx(cachedBackground, offsetX-4, offsetY, NULL);
            LineTo(cachedBackground, offsetX+1, offsetY);
 
            MoveToEx(cachedBackground, offsetX-1, offsetY-4, NULL);
            LineTo(cachedBackground, offsetX+4, offsetY-4);
            LineTo(cachedBackground, offsetX+4, offsetY+1);
            LineTo(cachedBackground, offsetX+1, offsetY+1);
            MoveToEx(cachedBackground, offsetX-1, offsetY, NULL);
            LineTo(cachedBackground, offsetX-1, offsetY-4);
            MoveToEx(cachedBackground, offsetX-1, offsetY-3, NULL);
            LineTo(cachedBackground, offsetX+4, offsetY-3);
        }
        else
        {
            MoveToEx(cachedBackground, offsetX-4, offsetY-4, NULL);
            LineTo(cachedBackground, offsetX+4, offsetY-4);
            LineTo(cachedBackground, offsetX+4, offsetY+4);
            LineTo(cachedBackground, offsetX-4, offsetY+4);
            LineTo(cachedBackground, offsetX-4, offsetY-4);
            MoveToEx(cachedBackground, offsetX-4, offsetY-3, NULL);
            LineTo(cachedBackground, offsetX+4, offsetY-3);
        }
 
//      if (pSettings->doubleScaleHiDPI) StretchBlt(cachedBackground, consoleZoomButtonRect.left, consoleZoomButtonRect.top, 30, 30, cachedBackground, consoleZoomButtonRect.left, consoleZoomButtonRect.top, 15, 15, SRCCOPY);
        StretchBlt(cachedBackground, consoleZoomButtonRect.left, consoleZoomButtonRect.top, (15 * pSettings->scalingFactorHiDPI), (15 * pSettings->scalingFactorHiDPI), cachedBackground, consoleZoomButtonRect.left, consoleZoomButtonRect.top, 15, 15, SRCCOPY);
 
        SelectObject(cachedBackground, oldPen);
        DeleteObject(zoomPen);
 
        //====================
 
        // Draw "lock" indicator if write protection is enabled...
        if (pSettings->writeProtection)
        {
            // Draw "lock" background...
            brush = CreateSolidBrush(pSettings->Console->PicColor); //0x000066
            FillRect(cachedBackground, &consoleLockGlyphRect, brush);
            DeleteObject(brush);
 
            // Draw "lock" glyph...
            HPEN protectPen = CreatePen(PS_SOLID, 1, pSettings->Console->Color);
            HPEN oldPen = (HPEN) SelectObject(cachedBackground, protectPen);
 
            MoveToEx(cachedBackground, consoleLockGlyphRect.left+4, consoleLockGlyphRect.top+7, NULL);
            LineTo(cachedBackground, consoleLockGlyphRect.left+11, consoleLockGlyphRect.top+7);
            MoveToEx(cachedBackground, consoleLockGlyphRect.left+4, consoleLockGlyphRect.top+8, NULL);
            LineTo(cachedBackground, consoleLockGlyphRect.left+11, consoleLockGlyphRect.top+8);
            MoveToEx(cachedBackground, consoleLockGlyphRect.left+4, consoleLockGlyphRect.top+9, NULL);
            LineTo(cachedBackground, consoleLockGlyphRect.left+11, consoleLockGlyphRect.top+9);
            MoveToEx(cachedBackground, consoleLockGlyphRect.left + 4, consoleLockGlyphRect.top + 10, NULL);
            LineTo(cachedBackground, consoleLockGlyphRect.left + 11, consoleLockGlyphRect.top + 10);
            MoveToEx(cachedBackground, consoleLockGlyphRect.left + 4, consoleLockGlyphRect.top + 11, NULL);
            LineTo(cachedBackground, consoleLockGlyphRect.left + 11, consoleLockGlyphRect.top + 11);
 
            MoveToEx(cachedBackground, consoleLockGlyphRect.left + 6, consoleLockGlyphRect.top + 3, NULL);
            LineTo(cachedBackground, consoleLockGlyphRect.left + 9, consoleLockGlyphRect.top + 3);
            MoveToEx(cachedBackground, consoleLockGlyphRect.left + 5, consoleLockGlyphRect.top + 4, NULL);
            LineTo(cachedBackground, consoleLockGlyphRect.left + 5, consoleLockGlyphRect.top + 7);
            MoveToEx(cachedBackground, consoleLockGlyphRect.left + 9, consoleLockGlyphRect.top + 4, NULL);
            LineTo(cachedBackground, consoleLockGlyphRect.left + 9, consoleLockGlyphRect.top + 7);
 
            if (pSettings->scalingFactorHiDPI >= 2)
            {
                StretchBlt(cachedBackground, consoleLockGlyphRect.left, consoleLockGlyphRect.top, 30, 30, cachedBackground, consoleLockGlyphRect.left, consoleLockGlyphRect.top, 15, 15, SRCCOPY);
                MoveToEx(cachedBackground, consoleLockGlyphRect.left + 8, consoleLockGlyphRect.top + 13, NULL);
                LineTo(cachedBackground, consoleLockGlyphRect.left + 22, consoleLockGlyphRect.top + 13);
                MoveToEx(cachedBackground, consoleLockGlyphRect.left + 11, consoleLockGlyphRect.top + 7, NULL);
                LineTo(cachedBackground, consoleLockGlyphRect.left + 13, consoleLockGlyphRect.top + 9);
                MoveToEx(cachedBackground, consoleLockGlyphRect.left + 18, consoleLockGlyphRect.top + 7, NULL);
                LineTo(cachedBackground, consoleLockGlyphRect.left + 16, consoleLockGlyphRect.top + 9);
 
                if (pSettings->scalingFactorHiDPI > 2)
                {
                    // Temporary lazy solution... (ie. for now just stretching the 2x glyph, with no further pixel fine-tuning like for 2x above)
                    StretchBlt(cachedBackground, consoleLockGlyphRect.left, consoleLockGlyphRect.top, (15 * pSettings->scalingFactorHiDPI), (15 * pSettings->scalingFactorHiDPI), cachedBackground, consoleLockGlyphRect.left, consoleLockGlyphRect.top, 30, 30, SRCCOPY);
                }
            }
 
            SelectObject(cachedBackground, oldPen);
            DeleteObject(protectPen);
        }
    }
 
    //====================
 
    // Draw messages...
    SetRect(&r, 0, 0, ConsoleWidth, ConsoleHeight);
 
    HFONT font = CreateFont(pSettings->Console->FontHeight, 0, 0, 0, pSettings->Console->FontWeight, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH|FF_DONTCARE, pSettings->Console->Font);
    HGDIOBJ oldfont = SelectObject(cachedBackground, font);
    SetBkMode(cachedBackground, TRANSPARENT);
 
    for (int i=0; i < (int)messageList.size(); i++) SetRectEmpty(&messageList[i]->r); // Flush any prior message RECTs to enable detection of clicks on currently visible messages only...
 
    int messagesToDraw;
    if (pSettings->consoleMaximized) messagesToDraw = pSettings->consoleMaximizedMessages;
    else messagesToDraw = pSettings->consoleRestoredMessages;
 
    if (messagesToDraw > 1)
    {
        if (!pSettings->consoleDesktopMode) InflateRect(&r, (-5 * pSettings->scalingFactorHiDPI), (-5 * pSettings->scalingFactorHiDPI));
        r.bottom = r.top + consoleTrueFontHeight;
 
        int i = 0;
        int mlSize = (int)messageList.size();
        if (mlSize > messagesToDraw) i = mlSize - messagesToDraw; // Display latest received messages
        for (i; i < (int)messageList.size(); i++)
        {
            DrawMessage(cachedBackground, r, messageList[i]);
            CopyRect(&messageList[i]->r, &r);
            OffsetRect(&r, 0, lineSpacing);
        }
    }
    else
    {
        if (!pSettings->consoleDesktopMode) InflateRect(&r, (-5 * pSettings->scalingFactorHiDPI), 0);
        r.top = (r.bottom - r.top - consoleTrueFontHeight) / 2;
        r.bottom = r.top + consoleTrueFontHeight;
 
        int latestMsg = (int)messageList.size() - 1;
        if (latestMsg >= 0)
        {
            DrawMessage(cachedBackground, r, messageList[latestMsg]);
            CopyRect(&messageList[latestMsg]->r, &r);
        }
    }
 
    DeleteObject(SelectObject(cachedBackground, oldfont));
 
    //====================
 
    SetRect(&r, 0, 0, ConsoleWidth, ConsoleHeight);
 
    if (!pSettings->consoleDesktopMode)
    {
        // Apply per pixel alpha, selectively per placement, creating nice rounded corners... 8)
        AlphaRect(cachedBackground, r, pSettings->consoleTransparencyAlpha);
 
        if (pSettings->consoleRoundedCorners)
        {
            switch (pSettings->ConsolePlacement.placement)
            {
                /*
                    // Original: Rounding all applicable corners
                    case PLACEMENT_MANUAL: AlphaCorner(cachedBackground, r, CORNER_TOPLEFT | CORNER_TOPRIGHT | CORNER_BOTTOMLEFT | CORNER_BOTTOMRIGHT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha); break;
                    case PLACEMENT_TOP_LEFT: AlphaCorner(cachedBackground, r, CORNER_BOTTOMRIGHT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha); break;
                    case PLACEMENT_CENTER_LEFT: AlphaCorner(cachedBackground, r, CORNER_TOPRIGHT | CORNER_BOTTOMRIGHT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha); break;
                    case PLACEMENT_BOTTOM_LEFT: AlphaCorner(cachedBackground, r, CORNER_TOPRIGHT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha); break;
                    case PLACEMENT_TOP_CENTER: AlphaCorner(cachedBackground, r, CORNER_BOTTOMLEFT | CORNER_BOTTOMRIGHT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha); break;
                    case PLACEMENT_CENTER_CENTER: AlphaCorner(cachedBackground, r, CORNER_TOPLEFT | CORNER_TOPRIGHT | CORNER_BOTTOMLEFT | CORNER_BOTTOMRIGHT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha); break;
                    case PLACEMENT_BOTTOM_CENTER: AlphaCorner(cachedBackground, r, CORNER_TOPLEFT | CORNER_TOPRIGHT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha); break;
                    case PLACEMENT_TOP_RIGHT: AlphaCorner(cachedBackground, r, CORNER_BOTTOMLEFT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha); break;
                    case PLACEMENT_CENTER_RIGHT: AlphaCorner(cachedBackground, r, CORNER_TOPLEFT | CORNER_BOTTOMLEFT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha); break;
                    case PLACEMENT_BOTTOM_RIGHT: AlphaCorner(cachedBackground, r, CORNER_TOPLEFT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha); break;
                    default: AlphaCorner(cachedBackground, r, CORNER_TOPLEFT | CORNER_TOPRIGHT | CORNER_BOTTOMLEFT | CORNER_BOTTOMRIGHT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha);
                */
                // Alternative: Rounding all applicable corners *except* the top right one since that's where the square-sized "window controls" are located
                case PLACEMENT_MANUAL: AlphaCorner(cachedBackground, r, CORNER_TOPLEFT | CORNER_BOTTOMLEFT | CORNER_BOTTOMRIGHT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha); break;
                case PLACEMENT_TOP_LEFT: AlphaCorner(cachedBackground, r, CORNER_BOTTOMRIGHT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha); break;
                case PLACEMENT_CENTER_LEFT: AlphaCorner(cachedBackground, r, CORNER_BOTTOMRIGHT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha); break;
                case PLACEMENT_BOTTOM_LEFT: AlphaCorner(cachedBackground, r, 0, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha); break;
                case PLACEMENT_TOP_CENTER: AlphaCorner(cachedBackground, r, CORNER_BOTTOMLEFT | CORNER_BOTTOMRIGHT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha); break;
                case PLACEMENT_CENTER_CENTER: AlphaCorner(cachedBackground, r, CORNER_TOPLEFT | CORNER_BOTTOMLEFT | CORNER_BOTTOMRIGHT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha); break;
                case PLACEMENT_BOTTOM_CENTER: AlphaCorner(cachedBackground, r, CORNER_TOPLEFT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha); break;
                case PLACEMENT_TOP_RIGHT: AlphaCorner(cachedBackground, r, CORNER_BOTTOMLEFT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha); break;
                case PLACEMENT_CENTER_RIGHT: AlphaCorner(cachedBackground, r, CORNER_TOPLEFT | CORNER_BOTTOMLEFT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha); break;
                case PLACEMENT_BOTTOM_RIGHT: AlphaCorner(cachedBackground, r, CORNER_TOPLEFT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha); break;
                default: AlphaCorner(cachedBackground, r, CORNER_TOPLEFT | CORNER_BOTTOMLEFT | CORNER_BOTTOMRIGHT, 0, 0, 0, pSettings->Toolbar->borderWidth, 0, pSettings->consoleTransparencyAlpha);
            }
        }
    }
    else AlphaFromRGB(cachedBackground, r, 0, pSettings->consoleTransparencyAlpha, true, pSettings->desktopWidgetColor); // Console "desktop mode" -> Fully transparent console background, white text with varying transparency, etc
 
    AlphaApply(cachedBackground, r);
 
    //====================
 
    if (bufbmp) DeleteObject(bufbmp);
 
    POINT pt;
    pt.x = ConsoleX, pt.y = ConsoleY;
    POINT ptSrc;
    ptSrc.x = 0, ptSrc.y = 0;
 
    BLENDFUNCTION bf;
    bf.BlendOp = AC_SRC_OVER;
    bf.BlendFlags = 0;
    bf.AlphaFormat = AC_SRC_ALPHA;
    bf.SourceConstantAlpha = (unsigned char)255;
 
    SIZE windowSize = {ConsoleWidth, ConsoleHeight};
    BOOL result = UpdateLayeredWindow(hConsoleWnd, NULL, &pt, &windowSize, cachedBackground, &ptSrc, 0, &bf, ULW_ALPHA);
/*
    if (!cachedBackground) SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_INFORMATION_MESSAGE, (LPARAM)"xoblite -> Console -> Invalid cachedBackground!");
 
    if (result == 0)
    {
        int error = GetLastError();
        char msg[255];
        sprintf(msg, "xoblite -> Console -> UpdateLayeredWindow failed! [error code %d]", error);
        SendMessage(GetBBWnd(), BB_CONSOLEMESSAGE, (WPARAM)CONSOLE_ERROR_MESSAGE, (LPARAM)msg);
    }
*/
 
    // Finally, we move the console window to be just above the desktop in the z-order...
    if (pDesktop) SetWindowPos(hConsoleWnd, pDesktop->hDesktopWnd, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE | SWP_NOSENDCHANGING | SWP_NOOWNERZORDER);
}

◆ DrawMessage()

void Console::DrawMessage	(	HDC	hdc,
		RECT	r,
		messageListItem *	mLI )

{
    RECT msgRect, tempRect;
    CopyRect(&msgRect, &r);
 
    if (!pSettings->consoleDesktopMode)
    {
        if (IntersectRect(&tempRect, &msgRect, &consoleZoomButtonRect)) msgRect.right = consoleZoomButtonRect.left - (5 * pSettings->scalingFactorHiDPI);
        if (pSettings->writeProtection && IntersectRect(&tempRect, &msgRect, &consoleLockGlyphRect)) msgRect.right = consoleLockGlyphRect.left - (5 * pSettings->scalingFactorHiDPI);
    }
 
    COLORREF colorHighAlpha, colorMediumAlpha;
    if (pSettings->consoleDesktopMode)
    {
        colorHighAlpha = RGB(pSettings->consoleTransparencyAlpha, pSettings->consoleTransparencyAlpha, pSettings->consoleTransparencyAlpha);
        colorMediumAlpha = RGB(pSettings->consoleTransparencyAlpha/2, pSettings->consoleTransparencyAlpha/2, pSettings->consoleTransparencyAlpha/2);
    }
 
    //====================
 
    if (mLI->type == CONSOLE_SEPARATOR)
    {
        int separatorOffset = (msgRect.bottom - msgRect.top) / 2;
        msgRect.top = msgRect.top + separatorOffset - 1;
        msgRect.bottom = msgRect.top + 2;
        if (pSettings->doubleScaleHiDPI) InflateRect(&msgRect, 0, 1);
        HBRUSH background;
        if (pSettings->consoleDesktopMode) background = CreateSolidBrush(colorMediumAlpha);
//      else background = CreateSolidBrush(pSettings->Console->TextColor);
        else background = CreateSolidBrush(pSettings->MixColors(pSettings->Console->Color, pSettings->Console->TextColor));
        FillRect(hdc, &msgRect, background);
        DeleteObject(background);
    }
 
    //====================
 
    else if (mLI->type == CONSOLE_REGULAR_MESSAGE || mLI->type == CONSOLE_PLAIN_MESSAGE)
    {
        InflateRect(&msgRect, -3, 0);
        if (pSettings->consoleDesktopMode)
        {
            char timestamp[16];
//          strncpy(timestamp, mLI->msg, 12);
            strncpy_s(timestamp, sizeof(timestamp), mLI->msg, 12);
            timestamp[12] = '\0';
            DrawTextWithEffects(hdc, msgRect, mLI->msg, DT_LEFT | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_WORD_ELLIPSIS, colorHighAlpha, false, 0, false, 0, 0, 0);
            DrawTextWithEffects(hdc, msgRect, timestamp, DT_LEFT | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_WORD_ELLIPSIS, colorMediumAlpha, false, 0, false, 0, 0, 0);
        }
        else DrawTextWithEffects(hdc, msgRect, mLI->msg, DT_LEFT | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_WORD_ELLIPSIS, pSettings->Console->TextColor, false, 0, false, 0, 0, 0);
 
        // Highlight clickable URL?
        if (strlen(mLI->url))
        {
            char msgWithoutURL[sizeof(mLI->msg)];
            strcpy(msgWithoutURL, mLI->msg);
            char* msgPtr = msgWithoutURL;
            char* urlPtr = StrStrI(msgWithoutURL, "http://");
            if (urlPtr == NULL) urlPtr = StrStrI(msgWithoutURL, "https://");
            if (urlPtr == NULL) urlPtr = StrStrI(msgWithoutURL, "file://");
            if (urlPtr != NULL)
            {
                int n = urlPtr - msgPtr;
                msgWithoutURL[n] = '\0';
 
                SIZE sizeMsg, sizeURL, sizeSpace;
                HDC fonthdc = CreateDC("DISPLAY", NULL, NULL, NULL);
                HFONT tempFont = CreateFont(pSettings->Console->FontHeight, 0, 0, 0, pSettings->Console->FontWeight, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH|FF_DONTCARE, pSettings->Console->Font);
                HGDIOBJ oldFont = SelectObject(fonthdc, tempFont);
                GetTextExtentPoint32(fonthdc, msgWithoutURL, strlen(msgWithoutURL), &sizeMsg);
                GetTextExtentPoint32(fonthdc, mLI->url, strlen(mLI->url), &sizeURL);
                GetTextExtentPoint32(fonthdc, " ", 1, &sizeSpace);
                if (sizeSpace.cx & 1) sizeSpace.cx += 1; // Note: Even number of pixels -> Extra URL background width always divideable by two (see below)
                if (sizeSpace.cx < 4) sizeSpace.cx = 4;
                DeleteObject(SelectObject(fonthdc, oldFont));
                DeleteDC(fonthdc);
 
                msgRect.left = msgRect.left + sizeMsg.cx - (sizeSpace.cx/2);
                msgRect.right = msgRect.left + sizeURL.cx + sizeSpace.cx;
 
                // URLs are drawn with inverted colours...
                HBRUSH background;
                if (pSettings->consoleDesktopMode) background = CreateSolidBrush(colorHighAlpha);
                else background = CreateSolidBrush(pSettings->Console->TextColor);
                FillRect(hdc, &msgRect, background);
                DeleteObject(background);
                if (pSettings->consoleDesktopMode) DrawTextWithEffects(hdc, msgRect, mLI->url, DT_CENTER | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_WORD_ELLIPSIS, 0x000000, false, 0, false, 0, 0, 0);
                else DrawTextWithEffects(hdc, msgRect, mLI->url, DT_CENTER | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_WORD_ELLIPSIS, pSettings->Console->Color, false, 0, false, 0, 0, 0);
            }
        }
    }
 
    //====================
 
    else
    {
        int msgHeight = msgRect.bottom - msgRect.top;
        int iconSize = msgHeight - 2;
//      if (iconSize > 16) iconSize = 16;
        if (iconSize > 32) iconSize = 32;
//      else if (iconSize > 16) iconSize = 16;
 
        // Draw message icon...
        RECT iconRect;
        if (mLI->type != CONSOLE_INDENTED_MESSAGE)
        {
            iconRect.left = msgRect.left + 4;
            iconRect.top = msgRect.top + (msgHeight/2) - (iconSize/2);
            iconRect.right = iconRect.left + iconSize;
            iconRect.bottom = iconRect.top + iconSize;
//          HICON bIcon = LoadIcon(NULL, mLI->icon);
//          DrawIconEx(hdc, iconRect.left, iconRect.top, bIcon, iconSize, iconSize, 0, NULL, DI_NORMAL);
//          DeleteObject(bIcon);
            DrawIconEx(hdc, iconRect.left, iconRect.top, mLI->icon, iconSize, iconSize, 0, NULL, DI_NORMAL);
        }
        else if (mLI->type == CONSOLE_INDENTED_MESSAGE) iconRect.right = msgRect.left + (iconSize/2) + 1;
 
        // Draw message text...
        msgRect.left = iconRect.right + 3;
        if (pSettings->doubleScaleHiDPI) msgRect.left += 3;
        msgRect.right -= 2;
        if (pSettings->consoleDesktopMode) DrawTextWithEffects(hdc, msgRect, mLI->msg, DT_LEFT | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_EXPANDTABS | DT_WORD_ELLIPSIS, colorHighAlpha, false, 0, false, 0, 0, 0);
        else DrawTextWithEffects(hdc, msgRect, mLI->msg, DT_LEFT | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_EXPANDTABS | DT_WORD_ELLIPSIS, pSettings->Console->TextColor, false, 0, false, 0, 0, 0);
    }
}

◆ GetDimensions()

void Console::GetDimensions ( )

{
    if (!pSettings->explorerHidden)
    {
        RECT workArea;
        SystemParametersInfo(SPI_GETWORKAREA, 0, (PVOID)&workArea, SPIF_SENDCHANGE);
        ScreenWidth = workArea.right - workArea.left;
        ScreenHeight = workArea.bottom - workArea.top;
    }
    else
    {
        ScreenWidth = GetSystemMetrics(SM_CXVIRTUALSCREEN);
        ScreenHeight = GetSystemMetrics(SM_CYVIRTUALSCREEN);
    }
 
    //====================
 
    // First we need to check the *real* size of the font as some style
    // authors use non-matching font heights with bitmap fonts just to
    // tweak the appearance of the toolbar (e.g. to shrink its size)
    SIZE size;
    HDC fonthdc = CreateDC("DISPLAY", NULL, NULL, NULL);
    HFONT tempFont = CreateFont(pSettings->Console->FontHeight, 0, 0, 0, pSettings->Console->FontWeight, false, false, false, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH|FF_DONTCARE, pSettings->Console->Font);
    HGDIOBJ oldFont = SelectObject(fonthdc, tempFont);
    GetTextExtentPoint32(fonthdc, "TQkgfp/", 8, &size);
    consoleTrueFontHeight = size.cy + 1;
    if (consoleTrueFontHeight < pSettings->Console->FontHeight) consoleTrueFontHeight = pSettings->Console->FontHeight;
    DeleteObject(SelectObject(fonthdc, oldFont));
    DeleteDC(fonthdc);
 
    lineSpacing = consoleTrueFontHeight + 2;
//  if (pSettings->doubleScaleHiDPI) lineSpacing += 2;
    lineSpacing += (2 * pSettings->scalingFactorHiDPI);
 
    //====================
 
    if (pSettings->consoleMaximized) // Console window size "maximized" (nb. each state's #rows etc fully configurable though)
    {
        if (pSettings->consoleMaximizedWidth > 0)
        {
            if (pSettings->consoleMaximizedWidth > 100) ConsoleWidth = pSettings->consoleMaximizedWidth;
            else ConsoleWidth = (ScreenWidth * pSettings->consoleMaximizedWidth) / 100;
        }
        else if (pSettings->consoleMaximizedWidth < 0) ConsoleWidth = ScreenWidth + pSettings->consoleMaximizedWidth;
        else ConsoleWidth = ScreenWidth - 10; // Default used when consoleMaximizedWidth == 0
 
        if (pSettings->consoleMaximizedMessages == 1)
        {
            if (!pSettings->consoleDesktopMode)
            {
/*
                ConsoleHeight = consoleTrueFontHeight + 10;
                if (pSettings->doubleScaleHiDPI)
                {
                    ConsoleHeight += 10;
                    if (ConsoleHeight & 1) ConsoleHeight++;
                }
                else
                {
                    ConsoleHeight = ConsoleHeight | 1;
                    if (ConsoleHeight < 25) ConsoleHeight = 25;
                }
*/
                ConsoleHeight = consoleTrueFontHeight + (10 * pSettings->scalingFactorHiDPI);
                if ((pSettings->scalingFactorHiDPI == 2) || (pSettings->scalingFactorHiDPI == 4))
                {
                    if (ConsoleHeight & 1) ConsoleHeight++;
                }
                else // if ((pSettings->scalingFactorHiDPI == 1) || (pSettings->scalingFactorHiDPI == 3))
                {
                    ConsoleHeight = ConsoleHeight | 1;
                    if (ConsoleHeight < 25) ConsoleHeight = 25;
                }
            }
            else ConsoleHeight = consoleTrueFontHeight;
        }
        else
        {
            if (!pSettings->consoleDesktopMode)
            {
//              ConsoleHeight = (lineSpacing * pSettings->consoleMaximizedMessages) + 8 + pSettings->consolePadding; // Padding 5+5 pixels minus 2 pixels from lineSpacing
//              if (pSettings->doubleScaleHiDPI) ConsoleHeight += 8;  // Padding 10+10 pixels minus 4 pixels from lineSpacing
                ConsoleHeight = (lineSpacing * pSettings->consoleMaximizedMessages) + (10 * pSettings->scalingFactorHiDPI) + pSettings->consolePadding - (2 * pSettings->scalingFactorHiDPI);;
            }
            else
            {
                ConsoleHeight = (lineSpacing * pSettings->consoleMaximizedMessages);
//              if (pSettings->doubleScaleHiDPI) ConsoleHeight -= 4; // No padding and minus 4 pixels from lineSpacing
//              else ConsoleHeight -= 2; // No padding and minus 2 pixels from lineSpacing
                ConsoleHeight -= (2 * pSettings->scalingFactorHiDPI);
            }
        }
    }
    else // Console window size "restored" (nb. each state's #rows etc fully configurable though)
    {
        if (pSettings->consoleRestoredWidth > 0)
        {
            if (pSettings->consoleRestoredWidth > 100) ConsoleWidth = pSettings->consoleRestoredWidth;
            else ConsoleWidth = (ScreenWidth * pSettings->consoleRestoredWidth) / 100;
        }
        else if (pSettings->consoleRestoredWidth < 0) ConsoleWidth = ScreenWidth + pSettings->consoleRestoredWidth;
        else ConsoleWidth = ScreenWidth / 3; // Default used when consoleRestoredWidth == 0
 
        if (pSettings->consoleRestoredMessages == 1)
        {
            if (!pSettings->consoleDesktopMode)
            {
/*
                ConsoleHeight = consoleTrueFontHeight + 10;
                if (pSettings->doubleScaleHiDPI)
                {
                    ConsoleHeight += 10;
                    if (ConsoleHeight & 1) ConsoleHeight++;
                }
                else
                {
                    ConsoleHeight = ConsoleHeight | 1;
                    if (ConsoleHeight < 25) ConsoleHeight = 25;
                }
*/
                ConsoleHeight = consoleTrueFontHeight + (10 * pSettings->scalingFactorHiDPI);
                if ((pSettings->scalingFactorHiDPI == 2) || (pSettings->scalingFactorHiDPI == 4))
                {
                    if (ConsoleHeight & 1) ConsoleHeight++;
                }
                else // if ((pSettings->scalingFactorHiDPI == 1) || (pSettings->scalingFactorHiDPI == 3))
                {
                    ConsoleHeight = ConsoleHeight | 1;
                    if (ConsoleHeight < 25) ConsoleHeight = 25;
                }
            }
            else ConsoleHeight = consoleTrueFontHeight;
        }
        else
        {
            if (!pSettings->consoleDesktopMode)
            {
//              ConsoleHeight = (lineSpacing * pSettings->consoleRestoredMessages) + 8 + pSettings->consolePadding; // Padding 5+5 pixels minus 2 pixels padding from last lineSpacing
//              if (pSettings->doubleScaleHiDPI) ConsoleHeight += 8;  // Padding 10+10 pixels minus 4 pixels padding from last lineSpacing
                ConsoleHeight = (lineSpacing * pSettings->consoleRestoredMessages) + (10 * pSettings->scalingFactorHiDPI) + pSettings->consolePadding - (2 * pSettings->scalingFactorHiDPI);;
            }
            else
            {
                ConsoleHeight = (lineSpacing * pSettings->consoleRestoredMessages);
//              if (pSettings->doubleScaleHiDPI) ConsoleHeight -= 4; // No padding and minus 4 pixels from lineSpacing
//              else ConsoleHeight -= 2; // No padding and minus 2 pixels from lineSpacing
                ConsoleHeight -= (2 * pSettings->scalingFactorHiDPI);
            }
        }
    }
 
    if (ConsoleWidth < 300) ConsoleWidth = 300; // Minimum console width is 300 pixels
 
    //====================
 
    if ((pSettings->consoleMaximized && (pSettings->consoleMaximizedMessages > 1)) || (!pSettings->consoleMaximized && (pSettings->consoleRestoredMessages > 1)))
    {
        SetRect(&consoleZoomButtonRect, ConsoleWidth - (20 * pSettings->scalingFactorHiDPI), (5 * pSettings->scalingFactorHiDPI), ConsoleWidth - (5 * pSettings->scalingFactorHiDPI), (20 * pSettings->scalingFactorHiDPI));
    }
    else
    {
        int padding = ((ConsoleHeight - (15 * pSettings->scalingFactorHiDPI)) / 2);
        SetRect(&consoleZoomButtonRect, ConsoleWidth - (20 * pSettings->scalingFactorHiDPI), padding, ConsoleWidth - (5 * pSettings->scalingFactorHiDPI), padding + (15 * pSettings->scalingFactorHiDPI));
    }
 
    CopyRect(&consoleLockGlyphRect, &consoleZoomButtonRect);
    OffsetRect(&consoleLockGlyphRect, (-20 * pSettings->scalingFactorHiDPI), 0);
 
    //====================
 
    pSettings->ConsolePlacement.width = ConsoleWidth;
    pSettings->ConsolePlacement.height = ConsoleHeight;
 
    pSettings->PositionFromPlacement(&pSettings->ConsolePlacement);
 
    ConsoleX = pSettings->ConsolePlacement.x;
    ConsoleY = pSettings->ConsolePlacement.y;
}

◆ UpdatePosition()

void Console::UpdatePosition ( )

{
    // Get the new size and position for our window...
    GetDimensions();
    // Update the console window...
    UpdateConsoleWindow();
}

◆ ToggleMaximized()

void Console::ToggleMaximized ( )

{
    if (pSettings->consoleMaximized) pSettings->consoleMaximized = false;
    else pSettings->consoleMaximized = true;
 
    // Resize the console window... (restored<->maximized)
    UpdatePosition();
    PlaySoundFX(SFX_TOGGLE_ELEMENT);
 
    // Save setting to xoblite.rc...
    WriteBool(pSettings->xobrcFile, "xoblite.console.maximized:", pSettings->consoleMaximized);
}

◆ BlockMessage()

void Console::BlockMessage ( char * message )

{
    strcpy(messageToBlock, message);
}

◆ ClearHistory()

void Console::ClearHistory ( bool redraw )

{
    // Clear all elements in the messageList...
    for (int i=0; i<(int)messageList.size(); i++)
    {
        if (messageList[i]->icon != NULL) DeleteObject(&messageList[i]->icon);
        delete messageList[i];
    }
    messageList.clear();
//  ZeroMemory(&messageList, sizeof(messageList));
 
    // Update the console window...
    if (redraw) UpdatePosition();
}

Friends And Related Symbol Documentation

◆ ConsoleWndProc

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

friend

{
    switch (message)
    {
        //====================
 
        case BB_CONSOLEMESSAGE:
        {
            if (strlen(pConsole->messageToBlock) > 0)
            {
                if (!_stricmp((LPCSTR)lParam, pConsole->messageToBlock))
                {
                    // This message (typically a bro@m part of an @Script) should not be echoed in the console...
                    pConsole->messageToBlock[0] = '\0';
                    break;
                }
            }
 
            //====================
 
            if ((int)pConsole->messageList.size() >= 50)
            {
                // We already have the maximum 50 messages in the list, remove the oldest...
                if (pConsole->messageList[0]->icon != NULL) DeleteObject(&pConsole->messageList[0]->icon);
                delete pConsole->messageList[0];
                pConsole->messageList.erase(pConsole->messageList.begin());
            }
 
            //====================
 
            messageListItem *newMessage = new messageListItem;
 
            newMessage->type = (int)wParam;
 
            //====================
 
            if (newMessage->type == CONSOLE_INFORMATION_MESSAGE) newMessage->icon = LoadIcon(NULL, IDI_INFORMATION);
            else if (newMessage->type == CONSOLE_WARNING_MESSAGE) newMessage->icon = LoadIcon(NULL, IDI_WARNING);
            else if (newMessage->type == CONSOLE_ERROR_MESSAGE) newMessage->icon = LoadIcon(NULL, IDI_ERROR);
            else if (newMessage->type == CONSOLE_SHELL_MESSAGE) newMessage->icon = LoadIcon(pConsole->hConsoleInstance, MAKEINTRESOURCE(IDI_XOBLITE));
            else newMessage->icon = NULL; // CONSOLE_REGULAR_MESSAGE, CONSOLE_PLAIN_MESSAGE, CONSOLE_INDENTED_MESSAGE, CONSOLE_SEPARATOR
 
            //====================
 
            if (newMessage->type != CONSOLE_SEPARATOR)
            {
                char message[MAX_LINE_LENGTH];
                if (newMessage->type == CONSOLE_REGULAR_MESSAGE)
                {
                    // Add a timestamp to regular messages...
                    _strtime(message);
                    strncat_s(message, sizeof(message), " -> ", _TRUNCATE);
                    strncat_s(message, sizeof(message), (LPCSTR)lParam, _TRUNCATE);
                }
                else strncpy_s(message, sizeof(message), (LPCSTR)lParam, _TRUNCATE);
                message[sizeof(message)-1] = '\0'; // Failsafe
 
                // Replace any \r\n in the string with a single space character...
                LPSTR ptr;
                while (ptr = strchr(message, '\r'))
                {
//                  int nLen = strlen(ptr);
//                  memmove(ptr+3, ptr, nLen);
//                  strncpy(ptr, " -> ", 4);
                    ptr[0] = ' ';
                }
                while (ptr = strchr(message, '\n'))
                {
                    int nLen = strlen(ptr);
                    memmove(ptr, ptr+1, nLen);
                }
 
//              strncpy(newMessage->msg, message, sizeof(newMessage->msg));
                strncpy_s(newMessage->msg, sizeof(newMessage->msg), message, _TRUNCATE);
                newMessage->msg[sizeof(newMessage->msg)-1] = '\0';
 
                //====================
 
                // Detect any URL in the message and if found make it clickable...
                char* url = StrStrI(newMessage->msg, "http://");
                if (url == NULL) url = StrStrI(newMessage->msg, "https://");
                if (url == NULL) url = StrStrI(newMessage->msg, "file://");
                if (url == NULL) newMessage->url[0] = '\0';
                else
                {
                    strncpy_s(newMessage->url, sizeof(newMessage->url), url, _TRUNCATE);
                    newMessage->url[sizeof(newMessage->url)-1] = '\0';
 
                    // Check whether the URL is part of an @Script, and if so perform some additional operations on the two strings... (URL+message)
                    if (IsInString(newMessage->msg, "@Script"))
                    {
                        char* first = newMessage->url;
                        char* pipe = StrStrI(newMessage->url, "|");
                        if (pipe != NULL) newMessage->url[pipe-first] = '\0';
                        else if (newMessage->url[strlen(newMessage->url)-1] == ']') newMessage->url[strlen(newMessage->url)-1] = '\0';
 
                        char updatedMsg[350];
                        updatedMsg[sizeof(updatedMsg) - 1] = '\0';
                        int n = url - newMessage->msg;
                        strncpy_s(updatedMsg, sizeof(updatedMsg), newMessage->msg, n);
                        strcat_s(updatedMsg, " "); // ...to avoid the later URL highlighting covering the character immediately *before* the URL...
                        strcat_s(updatedMsg, newMessage->url);
                        strcat_s(updatedMsg, "  "); // ...to avoid the later URL highlighting covering the character immediately *after* the URL...
                        strcat_s(updatedMsg, &url[strlen(newMessage->url)]);
                        strncpy_s(newMessage->msg, sizeof(newMessage->msg), updatedMsg, _TRUNCATE);
                        newMessage->msg[sizeof(newMessage->msg)-1] = '\0';
                    }
 
                    // If not part of an @Script, we remove everything else after the URL (using blank space as delimiter) including any ending parantheses and commas...
                    else if (strchr(newMessage->url, ' '))
                    {
                        char temp[sizeof(newMessage->url)];
                        Tokenize(newMessage->url, temp, " ");
                        strcpy(newMessage->url, temp);
                        switch(newMessage->url[strlen(newMessage->url)-1])
                        {
                            case ')':
                            case '>':
                            case ',':
                            {
                                newMessage->url[strlen(newMessage->url)-1] = '\0';
                            }
                        }
                    }
                }
            }
 
            //====================
 
            pConsole->messageList.push_back(newMessage);
 
            //====================
 
            if (!pSettings->consoleHidden)
            {
                pConsole->UpdateConsoleWindow();
 
/*
                if (!SetTimer(pConsole->hConsoleWnd, CONSOLE_SETLABEL_TIMER, 4000, (TIMERPROC)NULL))
                {
                    MessageBox(0, "Error creating console timer!", szConsoleName, MB_OK | MB_ICONERROR | MB_TOPMOST);
                    Log("Could not create console timer!", NULL);
                    return 0;
                }
*/
            }
        }
        break;
 
        //===========================================================================
/*
        case WM_TIMER:
        {
            if (wParam == CONSOLE_SETLABEL_TIMER)
            {
                KillTimer(pConsole->hConsoleWnd, CONSOLE_SETLABEL_TIMER);
                if (pSettings->consoleHidden) ShowWindow(pConsole->hConsoleWnd, SW_HIDE);
            }
 
            return 0;
        }
        break;
*/
        //====================
 
        case BB_RECONFIGURE:
        case WM_DISPLAYCHANGE:
        {
            pConsole->UpdatePosition();
        }
        break;
 
        case WM_SETTINGCHANGE:
        {
            // Update the console's position (and maybe also dimensions) if the work area changes...
            // (e.g. if the Explorer taskbar is moved to another screen edge)
            if (wParam == SPI_SETWORKAREA) pConsole->UpdatePosition();
            return 0;
        }
 
        //====================
 
        case BB_TOGGLECONSOLE:
        {
            if (pSettings->consoleHidden)
            {
                // Show window and force update...
                pSettings->consoleHidden = false;
                ShowWindow(pConsole->hConsoleWnd, SW_SHOWNOACTIVATE);
                pConsole->UpdateConsoleWindow();
            }
            else
            {
                // Hide window...
                pSettings->consoleHidden = true;
                ShowWindow(pConsole->hConsoleWnd, SW_HIDE);
            }
 
            PlaySoundFX(SFX_TOGGLE_ELEMENT);
 
            WriteBool(pSettings->xobrcFile, "xoblite.console.hidden:", pSettings->consoleHidden);
        }
        break;
 
        //====================
/*
        case WM_WINDOWPOSCHANGING:
        {
            // ##### FOR SOME REASON THIS WILL CRASH THE SHELL...? #####
            if (pDesktop) SetWindowPos(pConsole->hConsoleWnd, pDesktop->hDesktopWnd, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE | SWP_NOSENDCHANGING | SWP_NOOWNERZORDER);
            return 0;
        }
*/
        //====================
 
        case WM_GETMINMAXINFO:
        {
            MINMAXINFO *mmi = (MINMAXINFO*)lParam;
            mmi->ptMaxSize.y = pConsole->ConsoleHeight;
            return 0;
        }
 
        //====================
 
        case WM_CLOSE:
            return 0;
 
        //====================
 
        case WM_MOUSEACTIVATE:
            return MA_NOACTIVATE;
 
//      case WM_ACTIVATE:
//          if (LOWORD(wParam) == WA_ACTIVE || LOWORD(wParam) == WA_CLICKACTIVE) SetActiveWindow(hwnd);
//      return 0;
 
        //====================
 
        case WM_NCHITTEST:
        {
            if ((GetAsyncKeyState(VK_CONTROL) & 0x8000)) return HTCAPTION;
            else return HTCLIENT;
        }
        break;
 
        //====================
 
        case WM_LBUTTONDBLCLK:
        {
            // Check which message was clicked...
            POINT pt;
            pt.x = LOWORD(lParam);
            pt.y = HIWORD(lParam);
 
            int i = 0;
            for (i; i < (int)pConsole->messageList.size(); i++)
            {
                if (PtInRect(&pConsole->messageList[i]->r, pt)) break;
            }
            if (i == (int)pConsole->messageList.size()) break; // No message clicked
 
            //====================
 
            if (strlen(pConsole->messageList[i]->url) > 0) // Message including a clickable URL...
            {
                BBExecute(GetDesktopWindow(), NULL, pConsole->messageList[i]->url, NULL, NULL, SW_SHOWNORMAL, true);
            }
            else
            {
                // Relay all mouse actions and drag'n'dropped files to the desktop...
//              SendMessage(pDesktop->hDesktopWnd, message, wParam, lParam);
            }
        }
        break;
 
 
        //====================
 
        case WM_LBUTTONDOWN:
        case WM_LBUTTONUP:
        case WM_RBUTTONDOWN:
        case WM_RBUTTONUP:
        case WM_MBUTTONDOWN:
        case WM_MBUTTONUP:
        case WM_XBUTTONDOWN:
        case WM_XBUTTONUP:
        case WM_MOUSEWHEEL:
        case WM_MOUSEHWHEEL:
        case WM_DROPFILES:
        {
            if (message == WM_LBUTTONUP)
            {
                POINT pt;
                pt.x = LOWORD(lParam);
                pt.y = HIWORD(lParam);
 
                // Did the user click the maximize/restore button?
                if (PtInRect(&pConsole->consoleZoomButtonRect, pt))
                {
                    pConsole->ToggleMaximized();
                    break;
                }
            }
 
            // If not, we relay all mouse actions and drag'n'dropped files to the desktop...
            pDesktop->MouseAndDropHandler(pDesktop->hDesktopWnd, message, wParam, lParam);
        }
        break;
 
        //====================
 
        default:
            return DefWindowProc(hwnd,message,wParam,lParam);
 
    //====================
    }
    return 0;
}

Member Data Documentation

◆ hConsoleInstance

HINSTANCE Console::hConsoleInstance

◆ hBlackboxWnd

HWND Console::hBlackboxWnd

◆ hConsoleWnd

HWND Console::hConsoleWnd

◆ cachedBackground

HDC Console::cachedBackground

◆ ScreenWidth

int Console::ScreenWidth

◆ ScreenHeight

int Console::ScreenHeight

◆ ConsoleX

int Console::ConsoleX

◆ ConsoleY

int Console::ConsoleY

◆ ConsoleWidth

int Console::ConsoleWidth

◆ ConsoleHeight

int Console::ConsoleHeight

◆ consoleTrueFontHeight

int Console::consoleTrueFontHeight

◆ lineSpacing

int Console::lineSpacing

◆ ConsoleHidden

bool Console::ConsoleHidden

◆ blockMessages

bool Console::blockMessages

◆ consoleZoomButtonRect

RECT Console::consoleZoomButtonRect

◆ consoleLockGlyphRect

RECT Console::consoleLockGlyphRect

◆ messageList

messageListVector Console::messageList

◆ messageToBlock

char Console::messageToBlock[MAX_LINE_LENGTH]

Public Types

Public Member Functions

Public Attributes

Friends