guiterm.h File Reference

#include "guisettings.h"
#include "conwnd.h"

Include dependency graph for guiterm.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
FORCEINLINE VOID	GetScreenBufferSizeUnits (IN PCONSOLE_SCREEN_BUFFER Buffer, IN PGUI_CONSOLE_DATA GuiData, OUT PUINT WidthUnit, OUT PUINT HeightUnit)
FORCEINLINE VOID	SmallRectToRect (PGUI_CONSOLE_DATA GuiData, PRECT Rect, PSMALL_RECT SmallRect)
VOID	GuiConsoleMoveWindow (PGUI_CONSOLE_DATA GuiData)
BOOL	InitFonts (_Inout_ PGUI_CONSOLE_DATA GuiData, _In_reads_or_z_(LF_FACESIZE) PCWSTR FaceName, _In_ ULONG FontWeight, _In_ ULONG FontFamily, _In_ COORD FontSize, _In_opt_ UINT CodePage, _In_ BOOL UseDefaultFallback)
VOID	DeleteFonts (PGUI_CONSOLE_DATA GuiData)
BOOL	EnterFullScreen (PGUI_CONSOLE_DATA GuiData)
VOID	LeaveFullScreen (PGUI_CONSOLE_DATA GuiData)
VOID	SwitchFullScreen (PGUI_CONSOLE_DATA GuiData, BOOL FullScreen)
VOID	GuiConsoleSwitchFullScreen (PGUI_CONSOLE_DATA GuiData)
VOID	GuiCopyFromGraphicsBuffer (PGRAPHICS_SCREEN_BUFFER Buffer, PGUI_CONSOLE_DATA GuiData)
VOID	GuiPasteToGraphicsBuffer (PGRAPHICS_SCREEN_BUFFER Buffer, PGUI_CONSOLE_DATA GuiData)
VOID	GuiPaintGraphicsBuffer (PGRAPHICS_SCREEN_BUFFER Buffer, PGUI_CONSOLE_DATA GuiData, PRECT rcView, PRECT rcFramebuffer)
VOID	PasteText (IN PCONSRV_CONSOLE Console, IN PWCHAR Buffer, IN SIZE_T cchSize)
VOID	GuiCopyFromTextModeBuffer (PTEXTMODE_SCREEN_BUFFER Buffer, PGUI_CONSOLE_DATA GuiData)
VOID	GuiPasteToTextModeBuffer (PTEXTMODE_SCREEN_BUFFER Buffer, PGUI_CONSOLE_DATA GuiData)
VOID	GuiPaintTextModeBuffer (PTEXTMODE_SCREEN_BUFFER Buffer, PGUI_CONSOLE_DATA GuiData, PRECT rcView, PRECT rcFramebuffer)

Function Documentation

DeleteFonts()

VOID DeleteFonts

(

PGUI_CONSOLE_DATA

GuiData

)

Definition at line 481 of file conwnd.c.

{
    ULONG i;
    for (i = 0; i < ARRAYSIZE(GuiData->Font); ++i)
    {
        if (GuiData->Font[i] != NULL) DeleteObject(GuiData->Font[i]);
        GuiData->Font[i] = NULL;
    }
}

Referenced by InitFonts(), and OnNcDestroy().

EnterFullScreen()

BOOL EnterFullScreen

(

PGUI_CONSOLE_DATA

GuiData

)

Definition at line 21 of file fullscreen.c.

{
    DEVMODEW DevMode;
 
    ZeroMemory(&DevMode, sizeof(DevMode));
    DevMode.dmSize = sizeof(DevMode);
 
    DevMode.dmDisplayFixedOutput = DMDFO_CENTER; // DMDFO_STRETCH // DMDFO_DEFAULT
    // DevMode.dmDisplayFlags = DMDISPLAYFLAGS_TEXTMODE;
    DevMode.dmPelsWidth  = 640; // GuiData->ActiveBuffer->ViewSize.X * GuiData->CharWidth;
    DevMode.dmPelsHeight = 480; // GuiData->ActiveBuffer->ViewSize.Y * GuiData->CharHeight;
    // DevMode.dmBitsPerPel = 32;
    DevMode.dmFields     = DM_DISPLAYFIXEDOUTPUT | /* DM_DISPLAYFLAGS | DM_BITSPERPEL | */ DM_PELSWIDTH | DM_PELSHEIGHT;
 
    return (ChangeDisplaySettingsW(&DevMode, CDS_FULLSCREEN) == DISP_CHANGE_SUCCESSFUL);
}

Referenced by OnActivate(), and SwitchFullScreen().

GetScreenBufferSizeUnits()

FORCEINLINE VOID GetScreenBufferSizeUnits	(	IN PCONSOLE_SCREEN_BUFFER	Buffer,
		IN PGUI_CONSOLE_DATA	GuiData,
		OUT PUINT	WidthUnit,
		OUT PUINT	HeightUnit
	)

Definition at line 22 of file guiterm.h.

{
    ASSERT(Buffer && GuiData && WidthUnit && HeightUnit);
 
    if (GetType(Buffer) == TEXTMODE_BUFFER)
    {
        *WidthUnit  = GuiData->CharWidth ;
        *HeightUnit = GuiData->CharHeight;
    }
    else /* if (GetType(Buffer) == GRAPHICS_BUFFER) */
    {
        *WidthUnit  = 1;
        *HeightUnit = 1;
    }
}

Referenced by ConWndProc(), GuiGetLargestConsoleWindowSize(), OnGetMinMaxInfo(), OnScroll(), OnSize(), PointToCoord(), and SmallRectToRect().

GuiConsoleMoveWindow()

VOID GuiConsoleMoveWindow

(

PGUI_CONSOLE_DATA

GuiData

)

Definition at line 61 of file guiterm.c.

{
    /* Move the window if needed (not positioned by the system) */
    if (!GuiData->GuiInfo.AutoPosition)
    {
        SetWindowPos(GuiData->hWindow,
                     NULL,
                     GuiData->GuiInfo.WindowOrigin.x,
                     GuiData->GuiInfo.WindowOrigin.y,
                     0, 0,
                     SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
    }
}

Referenced by GuiApplyUserSettings(), and GuiConsoleInputThread().

GuiConsoleSwitchFullScreen()

VOID GuiConsoleSwitchFullScreen

(

PGUI_CONSOLE_DATA

GuiData

)

Definition at line 175 of file fullscreen.c.

{
    PCONSRV_CONSOLE Console = GuiData->Console;
    BOOL FullScreen;
 
    if (!ConDrvValidateConsoleUnsafe((PCONSOLE)Console, CONSOLE_RUNNING, TRUE)) return;
 
    /* Switch to full-screen or to windowed mode */
    FullScreen = !GuiData->GuiInfo.FullScreen;
    DPRINT("GuiConsoleSwitchFullScreen - Switch to %s ...\n",
            (FullScreen ? "full-screen" : "windowed mode"));
 
    SwitchFullScreen(GuiData, FullScreen);
 
    LeaveCriticalSection(&Console->Lock);
}

Referenced by ConWndProc().

GuiCopyFromGraphicsBuffer()

VOID GuiCopyFromGraphicsBuffer	(	PGRAPHICS_SCREEN_BUFFER	Buffer,
		PGUI_CONSOLE_DATA	GuiData
	)

Definition at line 21 of file graphics.c.

{
    /*
     * This function supposes that the system clipboard was opened.
     */
 
    HDC hMemDC;
    HBITMAP  hBitmapTarget, hBitmapOld;
    HPALETTE hPalette, hPaletteOld;
    ULONG selWidth, selHeight;
 
    if (Buffer->BitMap == NULL) return;
 
    selWidth  = ConioRectWidth(&GuiData->Selection.srSelection);
    selHeight = ConioRectHeight(&GuiData->Selection.srSelection);
    DPRINT("Selection is (%d|%d) to (%d|%d)\n",
           GuiData->Selection.srSelection.Left,
           GuiData->Selection.srSelection.Top,
           GuiData->Selection.srSelection.Right,
           GuiData->Selection.srSelection.Bottom);
 
    hMemDC = CreateCompatibleDC(GuiData->hMemDC);
    if (hMemDC == NULL) return;
 
    /* Allocate a bitmap to be given to the clipboard, so it will not be freed here */
    hBitmapTarget = CreateCompatibleBitmap(GuiData->hMemDC, selWidth, selHeight);
    if (hBitmapTarget == NULL)
    {
        DeleteDC(hMemDC);
        return;
    }
 
    /* Select the new bitmap */
    hBitmapOld = SelectObject(hMemDC, hBitmapTarget);
 
    /* Change the palette in hMemDC if the current palette does exist */
    if (Buffer->PaletteHandle == NULL)
        hPalette = GuiData->hSysPalette;
    else
        hPalette = Buffer->PaletteHandle;
 
    if (hPalette) hPaletteOld = SelectPalette(hMemDC, hPalette, FALSE);
 
    /* Grab the mutex */
    NtWaitForSingleObject(Buffer->Mutex, FALSE, NULL);
 
    // The equivalent of a SetDIBitsToDevice call...
    // It seems to be broken: it does not copy the tail of the bitmap.
    // http://wiki.allegro.cc/index.php?title=StretchDIBits
#if 0
    StretchDIBits(hMemDC,
                  0, 0,
                  selWidth, selHeight,
                  GuiData->Selection.srSelection.Left,
                  GuiData->Selection.srSelection.Top,
                  selWidth, selHeight,
                  Buffer->BitMap,
                  Buffer->BitMapInfo,
                  Buffer->BitMapUsage,
                  SRCCOPY);
#else
    SetDIBitsToDevice(hMemDC,
                      /* Coordinates / size of the repainted rectangle, in the framebuffer's frame */
                      0, 0,
                      selWidth, selHeight,
                      /* Coordinates / size of the corresponding image portion, in the graphics screen-buffer's frame */
                      GuiData->Selection.srSelection.Left,
                      GuiData->Selection.srSelection.Top,
                      0,
                      Buffer->ScreenBufferSize.Y, // == Buffer->BitMapInfo->bmiHeader.biHeight
                      Buffer->BitMap,
                      Buffer->BitMapInfo,
                      Buffer->BitMapUsage);
#endif
 
    /* Release the mutex */
    NtReleaseMutant(Buffer->Mutex, NULL);
 
    /* Restore the palette and the old bitmap */
    if (hPalette) SelectPalette(hMemDC, hPaletteOld, FALSE);
    SelectObject(hMemDC, hBitmapOld);
 
    EmptyClipboard();
    SetClipboardData(CF_BITMAP, hBitmapTarget);
 
    DeleteDC(hMemDC);
}

Referenced by Copy().

GuiCopyFromTextModeBuffer()

VOID GuiCopyFromTextModeBuffer	(	PTEXTMODE_SCREEN_BUFFER	Buffer,
		PGUI_CONSOLE_DATA	GuiData
	)

Definition at line 306 of file text.c.

{
    /*
     * This function supposes that the system clipboard was opened.
     */
 
    BOOL LineSelection = GuiData->LineSelection;
 
    DPRINT("Selection is (%d|%d) to (%d|%d) in %s mode\n",
           GuiData->Selection.srSelection.Left,
           GuiData->Selection.srSelection.Top,
           GuiData->Selection.srSelection.Right,
           GuiData->Selection.srSelection.Bottom,
           (LineSelection ? "line" : "block"));
 
    if (!LineSelection)
    {
        CopyBlock(Buffer, &GuiData->Selection.srSelection);
    }
    else
    {
        COORD Begin, End;
 
        GetSelectionBeginEnd(&Begin, &End,
                             &GuiData->Selection.dwSelectionAnchor,
                             &GuiData->Selection.srSelection);
 
        CopyLines(Buffer, &Begin, &End);
    }
}

Referenced by Copy().

GuiPaintGraphicsBuffer()

VOID GuiPaintGraphicsBuffer	(	PGRAPHICS_SCREEN_BUFFER	Buffer,
		PGUI_CONSOLE_DATA	GuiData,
		PRECT	rcView,
		PRECT	rcFramebuffer
	)

Definition at line 124 of file graphics.c.

{
    PCONSRV_CONSOLE Console = (PCONSRV_CONSOLE)Buffer->Header.Console;
    // ASSERT(Console == GuiData->Console);
 
    ConioInitLongRect(rcFramebuffer, 0, 0, 0, 0);
 
    if (Buffer->BitMap == NULL)
        return;
 
    if (!ConDrvValidateConsoleUnsafe((PCONSOLE)Console, CONSOLE_RUNNING, TRUE))
        return;
 
    ConioInitLongRect(rcFramebuffer,
                      Buffer->ViewOrigin.Y * 1 + rcView->top,
                      Buffer->ViewOrigin.X * 1 + rcView->left,
                      Buffer->ViewOrigin.Y * 1 + rcView->bottom,
                      Buffer->ViewOrigin.X * 1 + rcView->right);
 
    /* Grab the mutex */
    NtWaitForSingleObject(Buffer->Mutex, FALSE, NULL);
 
    /*
     * The seventh parameter (YSrc) of SetDIBitsToDevice always designates
     * the Y-coordinate of the "lower-left corner" of the image, be the DIB
     * in bottom-up or top-down mode.
     */
    SetDIBitsToDevice(GuiData->hMemDC,
                      /* Coordinates / size of the repainted rectangle, in the framebuffer's frame */
                      rcFramebuffer->left,
                      rcFramebuffer->top,
                      rcFramebuffer->right  - rcFramebuffer->left,
                      rcFramebuffer->bottom - rcFramebuffer->top,
                      /* Coordinates / size of the corresponding image portion, in the graphics screen-buffer's frame */
                      rcFramebuffer->left,
                      rcFramebuffer->top,
                      0,
                      Buffer->ScreenBufferSize.Y, // == Buffer->BitMapInfo->bmiHeader.biHeight
                      Buffer->BitMap,
                      Buffer->BitMapInfo,
                      Buffer->BitMapUsage);
 
    /* Release the mutex */
    NtReleaseMutant(Buffer->Mutex, NULL);
 
    LeaveCriticalSection(&Console->Lock);
}

Referenced by OnPaint().

GuiPaintTextModeBuffer()

VOID GuiPaintTextModeBuffer	(	PTEXTMODE_SCREEN_BUFFER	Buffer,
		PGUI_CONSOLE_DATA	GuiData,
		PRECT	rcView,
		PRECT	rcFramebuffer
	)

Definition at line 433 of file text.c.

{
    PCONSRV_CONSOLE Console = (PCONSRV_CONSOLE)Buffer->Header.Console;
    ULONG TopLine, BottomLine, LeftColumn, RightColumn;
    ULONG Line, Char, Start;
    PCHAR_INFO From;
    PWCHAR To;
    WORD LastAttribute, Attribute;
    HFONT OldFont, NewFont;
    BOOLEAN IsUnderline;
 
    // ASSERT(Console == GuiData->Console);
 
    ConioInitLongRect(rcFramebuffer, 0, 0, 0, 0);
 
    if (Buffer->Buffer == NULL)
        return;
 
    if (!ConDrvValidateConsoleUnsafe((PCONSOLE)Console, CONSOLE_RUNNING, TRUE))
        return;
 
    ConioInitLongRect(rcFramebuffer,
                      Buffer->ViewOrigin.Y * GuiData->CharHeight + rcView->top,
                      Buffer->ViewOrigin.X * GuiData->CharWidth  + rcView->left,
                      Buffer->ViewOrigin.Y * GuiData->CharHeight + rcView->bottom,
                      Buffer->ViewOrigin.X * GuiData->CharWidth  + rcView->right);
 
    LeftColumn  = rcFramebuffer->left  / GuiData->CharWidth;
    RightColumn = rcFramebuffer->right / GuiData->CharWidth;
    if (RightColumn >= (ULONG)Buffer->ScreenBufferSize.X)
        RightColumn  = Buffer->ScreenBufferSize.X - 1;
 
    TopLine    = rcFramebuffer->top    / GuiData->CharHeight;
    BottomLine = rcFramebuffer->bottom / GuiData->CharHeight;
    if (BottomLine >= (ULONG)Buffer->ScreenBufferSize.Y)
        BottomLine  = Buffer->ScreenBufferSize.Y - 1;
 
    LastAttribute = ConioCoordToPointer(Buffer, LeftColumn, TopLine)->Attributes;
 
    SetTextColor(GuiData->hMemDC, PaletteRGBFromAttrib(Console, TextAttribFromAttrib(LastAttribute)));
    SetBkColor(GuiData->hMemDC, PaletteRGBFromAttrib(Console, BkgdAttribFromAttrib(LastAttribute)));
 
    /* We use the underscore flag as a underline flag */
    IsUnderline = !!(LastAttribute & COMMON_LVB_UNDERSCORE);
    /* Select the new font */
    NewFont = GuiData->Font[IsUnderline ? FONT_BOLD : FONT_NORMAL];
    OldFont = SelectObject(GuiData->hMemDC, NewFont);
 
    if (Console->IsCJK)
    {
        for (Line = TopLine; Line <= BottomLine; Line++)
        {
            for (Char = LeftColumn; Char <= RightColumn; Char++)
            {
                From = ConioCoordToPointer(Buffer, Char, Line);
                Attribute = From->Attributes;
                SetTextColor(GuiData->hMemDC, PaletteRGBFromAttrib(Console, TextAttribFromAttrib(Attribute)));
                SetBkColor(GuiData->hMemDC, PaletteRGBFromAttrib(Console, BkgdAttribFromAttrib(Attribute)));
 
                /* Change underline state if needed */
                if (!!(Attribute & COMMON_LVB_UNDERSCORE) != IsUnderline)
                {
                    IsUnderline = !!(Attribute & COMMON_LVB_UNDERSCORE);
 
                    /* Select the new font */
                    NewFont = GuiData->Font[IsUnderline ? FONT_BOLD : FONT_NORMAL];
                    SelectObject(GuiData->hMemDC, NewFont);
                }
 
                if (Attribute & COMMON_LVB_TRAILING_BYTE)
                    continue;
 
                TextOutW(GuiData->hMemDC,
                         Char * GuiData->CharWidth,
                         Line * GuiData->CharHeight,
                         &From->Char.UnicodeChar, 1);
            }
        }
    }
    else
    {
        for (Line = TopLine; Line <= BottomLine; Line++)
        {
            WCHAR LineBuffer[80];   // Buffer containing a part or all the line to be displayed
            From  = ConioCoordToPointer(Buffer, LeftColumn, Line);  // Get the first code of the line
            Start = LeftColumn;
            To    = LineBuffer;
 
            for (Char = LeftColumn; Char <= RightColumn; Char++)
            {
                /*
                 * We flush the buffer if the new attribute is different
                 * from the current one, or if the buffer is full.
                 */
                if (From->Attributes != LastAttribute || (Char - Start == sizeof(LineBuffer) / sizeof(WCHAR)))
                {
                    TextOutW(GuiData->hMemDC,
                             Start * GuiData->CharWidth,
                             Line  * GuiData->CharHeight,
                             LineBuffer,
                             Char - Start);
                    Start = Char;
                    To    = LineBuffer;
                    Attribute = From->Attributes;
                    if (Attribute != LastAttribute)
                    {
                        LastAttribute = Attribute;
                        SetTextColor(GuiData->hMemDC, PaletteRGBFromAttrib(Console, TextAttribFromAttrib(LastAttribute)));
                        SetBkColor(GuiData->hMemDC, PaletteRGBFromAttrib(Console, BkgdAttribFromAttrib(LastAttribute)));
 
                        /* Change underline state if needed */
                        if (!!(LastAttribute & COMMON_LVB_UNDERSCORE) != IsUnderline)
                        {
                            IsUnderline = !!(LastAttribute & COMMON_LVB_UNDERSCORE);
                            /* Select the new font */
                            NewFont = GuiData->Font[IsUnderline ? FONT_BOLD : FONT_NORMAL];
                            SelectObject(GuiData->hMemDC, NewFont);
                        }
                    }
                }
 
                *(To++) = (From++)->Char.UnicodeChar;
            }
 
            TextOutW(GuiData->hMemDC,
                     Start * GuiData->CharWidth,
                     Line  * GuiData->CharHeight,
                     LineBuffer,
                     RightColumn - Start + 1);
        }
    }
 
    /* Restore the old font */
    SelectObject(GuiData->hMemDC, OldFont);
 
    /* Draw the caret */
    GuiPaintCaret(Buffer, GuiData, TopLine, BottomLine, LeftColumn, RightColumn);
 
    LeaveCriticalSection(&Console->Lock);
}

Referenced by OnPaint().

GuiPasteToGraphicsBuffer()

VOID GuiPasteToGraphicsBuffer	(	PGRAPHICS_SCREEN_BUFFER	Buffer,
		PGUI_CONSOLE_DATA	GuiData
	)

Definition at line 111 of file graphics.c.

{
    /*
     * This function supposes that the system clipboard was opened.
     */
 
    // PCONSRV_CONSOLE Console = Buffer->Header.Console;
 
    UNIMPLEMENTED;
}

Referenced by Paste().

GuiPasteToTextModeBuffer()

VOID GuiPasteToTextModeBuffer	(	PTEXTMODE_SCREEN_BUFFER	Buffer,
		PGUI_CONSOLE_DATA	GuiData
	)

Definition at line 339 of file text.c.

{
    /*
     * This function supposes that the system clipboard was opened.
     */
 
    PCONSRV_CONSOLE Console = (PCONSRV_CONSOLE)Buffer->Header.Console;
 
    HANDLE hData;
    LPWSTR pszText;
 
    hData = GetClipboardData(CF_UNICODETEXT);
    if (hData == NULL) return;
 
    pszText = GlobalLock(hData);
    if (pszText == NULL) return;
 
    DPRINT("Got data <%S> from clipboard\n", pszText);
    PasteText(Console, pszText, wcslen(pszText));
 
    GlobalUnlock(hData);
}

Referenced by Paste().

InitFonts()

BOOL InitFonts	(	_Inout_ PGUI_CONSOLE_DATA	GuiData,
		_In_reads_or_z_(LF_FACESIZE) PCWSTR	FaceName,
		_In_ ULONG	FontWeight,
		_In_ ULONG	FontFamily,
		_In_ COORD	FontSize,
		_In_opt_ UINT	CodePage,
		_In_ BOOL	UseDefaultFallback
	)

Definition at line 521 of file conwnd.c.

{
    HDC hDC;
    HFONT hFont;
    FONT_DATA FontData;
    UINT OldCharWidth  = GuiData->CharWidth;
    UINT OldCharHeight = GuiData->CharHeight;
    COORD OldFontSize  = GuiData->GuiInfo.FontSize;
    WCHAR NewFaceName[LF_FACESIZE];
 
    /* Default to current code page if none has been provided */
    if (!CodePage)
        CodePage = GuiData->Console->OutputCodePage;
 
    /*
     * Initialize a new NORMAL font.
     */
 
    /* Copy the requested face name into the local buffer.
     * It will be modified in output by CreateConsoleFontEx()
     * to hold a possible fallback font face name. */
    StringCchCopyNW(NewFaceName, ARRAYSIZE(NewFaceName),
                    FaceName, LF_FACESIZE);
 
    /* NOTE: FontSize is always in cell height/width units (pixels) */
    hFont = CreateConsoleFontEx((LONG)(ULONG)FontSize.Y,
                                (LONG)(ULONG)FontSize.X,
                                NewFaceName,
                                FontWeight,
                                FontFamily,
                                CodePage,
                                UseDefaultFallback,
                                &FontData);
    if (!hFont)
    {
        DPRINT1("InitFonts: CreateConsoleFontEx('%S') failed\n", NewFaceName);
        return FALSE;
    }
 
    /* Retrieve its character cell size */
    hDC = GetDC(GuiData->hWindow);
    if (!GetFontCellSize(hDC, hFont, &GuiData->CharHeight, &GuiData->CharWidth))
    {
        DPRINT1("InitFonts: GetFontCellSize failed\n");
        ReleaseDC(GuiData->hWindow, hDC);
        DeleteObject(hFont);
        return FALSE;
    }
    ReleaseDC(GuiData->hWindow, hDC);
 
    /*
     * Initialization succeeded.
     */
    // Delete all the old fonts first.
    DeleteFonts(GuiData);
    GuiData->Font[FONT_NORMAL] = hFont;
 
    /*
     * Now build the optional fonts (bold, underlined, mixed).
     * Do not error in case they fail to be created.
     */
    GuiData->Font[FONT_BOLD] =
        CreateDerivedFont(GuiData->Font[FONT_NORMAL],
                          max(FW_BOLD, FontData.Weight),
                          FALSE,
                          FALSE);
    GuiData->Font[FONT_UNDERLINE] =
        CreateDerivedFont(GuiData->Font[FONT_NORMAL],
                          FontData.Weight,
                          TRUE,
                          FALSE);
    GuiData->Font[FONT_BOLD | FONT_UNDERLINE] =
        CreateDerivedFont(GuiData->Font[FONT_NORMAL],
                          max(FW_BOLD, FontData.Weight),
                          TRUE,
                          FALSE);
 
    /*
     * Save the new font characteristics.
     */
    StringCchCopyNW(GuiData->GuiInfo.FaceName,
                    ARRAYSIZE(GuiData->GuiInfo.FaceName),
                    NewFaceName, ARRAYSIZE(NewFaceName));
    GuiData->GuiInfo.FontWeight = FontData.Weight;
    GuiData->GuiInfo.FontFamily = FontData.Family;
    GuiData->GuiInfo.FontSize   = FontData.Size;
 
    /* Resize the terminal, in case the new font has a different size */
    if ((OldCharWidth  != GuiData->CharWidth)  ||
        (OldCharHeight != GuiData->CharHeight) ||
        (OldFontSize.X != FontData.Size.X ||
         OldFontSize.Y != FontData.Size.Y))
    {
        TermResizeTerminal(GuiData->Console);
    }
 
    return TRUE;
}

Referenced by GuiApplyUserSettings(), GuiSetCodePage(), and OnNcCreate().

LeaveFullScreen()

VOID LeaveFullScreen

(

PGUI_CONSOLE_DATA

GuiData

)

Definition at line 39 of file fullscreen.c.

{
    ChangeDisplaySettingsW(NULL, CDS_RESET);
}

Referenced by OnActivate(), and SwitchFullScreen().

PasteText()

VOID PasteText	(	IN PCONSRV_CONSOLE	Console,
		IN PWCHAR	Buffer,
		IN SIZE_T	cchSize
	)

Definition at line 238 of file text.c.

{
    USHORT VkKey; // MAKEWORD(low = vkey_code, high = shift_state);
    INPUT_RECORD er;
    WCHAR CurChar = 0;
 
    /* Do nothing if we have nothing to paste */
    if (!Buffer || (cchSize <= 0))
        return;
 
    er.EventType = KEY_EVENT;
    er.Event.KeyEvent.wRepeatCount = 1;
    while (cchSize--)
    {
        /* \r or \n characters. Go to the line only if we get "\r\n" sequence. */
        if (CurChar == L'\r' && *Buffer == L'\n')
        {
            ++Buffer;
            continue;
        }
        CurChar = *Buffer++;
 
        /* Get the key code (+ shift state) corresponding to the character */
        VkKey = VkKeyScanW(CurChar);
        if (VkKey == 0xFFFF)
        {
            DPRINT1("FIXME: TODO: VkKeyScanW failed - Should simulate the key!\n");
            /*
             * We don't really need the scan/key code because we actually only
             * use the UnicodeChar for output purposes. It may pose few problems
             * later on but it's not of big importance. One trick would be to
             * convert the character to OEM / multibyte and use MapVirtualKey()
             * on each byte (simulating an Alt-0xxx OEM keyboard press).
             */
        }
 
        /* Pressing some control keys */
 
        /* Pressing the character key, with the control keys maintained pressed */
        er.Event.KeyEvent.bKeyDown = TRUE;
        er.Event.KeyEvent.wVirtualKeyCode = LOBYTE(VkKey);
        er.Event.KeyEvent.wVirtualScanCode = MapVirtualKeyW(LOBYTE(VkKey), MAPVK_VK_TO_VSC);
        er.Event.KeyEvent.uChar.UnicodeChar = CurChar;
        er.Event.KeyEvent.dwControlKeyState = 0;
        if (HIBYTE(VkKey) & 1)
            er.Event.KeyEvent.dwControlKeyState |= SHIFT_PRESSED;
        if (HIBYTE(VkKey) & 2)
            er.Event.KeyEvent.dwControlKeyState |= LEFT_CTRL_PRESSED; // RIGHT_CTRL_PRESSED;
        if (HIBYTE(VkKey) & 4)
            er.Event.KeyEvent.dwControlKeyState |= LEFT_ALT_PRESSED; // RIGHT_ALT_PRESSED;
 
        ConioProcessInputEvent(Console, &er);
 
        /* Up all the character and control keys */
        er.Event.KeyEvent.bKeyDown = FALSE;
        ConioProcessInputEvent(Console, &er);
    }
}

Referenced by GuiPasteToTextModeBuffer(), and OnDropFiles().

SmallRectToRect()

FORCEINLINE VOID SmallRectToRect	(	PGUI_CONSOLE_DATA	GuiData,
		PRECT	Rect,
		PSMALL_RECT	SmallRect
	)

Definition at line 43 of file guiterm.h.

{
    PCONSOLE_SCREEN_BUFFER Buffer = GuiData->ActiveBuffer;
    UINT WidthUnit, HeightUnit;
 
    GetScreenBufferSizeUnits(Buffer, GuiData, &WidthUnit, &HeightUnit);
 
    Rect->left   = (SmallRect->Left       - Buffer->ViewOrigin.X) * WidthUnit ;
    Rect->top    = (SmallRect->Top        - Buffer->ViewOrigin.Y) * HeightUnit;
    Rect->right  = (SmallRect->Right  + 1 - Buffer->ViewOrigin.X) * WidthUnit ;
    Rect->bottom = (SmallRect->Bottom + 1 - Buffer->ViewOrigin.Y) * HeightUnit;
}

Referenced by CreateSelectionRgn(), and DrawRegion().

SwitchFullScreen()

VOID SwitchFullScreen	(	PGUI_CONSOLE_DATA	GuiData,
		BOOL	FullScreen
	)

Definition at line 49 of file fullscreen.c.

{
    PCONSRV_CONSOLE Console = GuiData->Console;
 
    /*
     * See:
     * http://stackoverflow.com/questions/2382464/win32-full-screen-and-hiding-taskbar
     * http://stackoverflow.com/questions/3549148/fullscreen-management-with-winapi
     * https://devblogs.microsoft.com/oldnewthing/20100412-00/?p=14353
     * https://devblogs.microsoft.com/oldnewthing/20050505-04/?p=35703
     * http://stackoverflow.com/questions/1400654/how-do-i-put-my-opengl-app-into-fullscreen-mode
     * https://web.archive.org/web/20180210071518/http://nehe.gamedev.net/tutorial/creating_an_opengl_window_win32/13001/
     * https://web.archive.org/web/20121001015230/http://www.reocities.com/pcgpe/dibs.html
     */
 
    /* If we are already in the given state, just bail out */
    if (FullScreen == GuiData->GuiInfo.FullScreen) return;
 
    /* Save the current window state if we are not already full-screen */
    if (!GuiData->GuiInfo.FullScreen)
    {
        GuiData->IsWndMax = IsZoomed(GuiData->hWindow);
        if (GuiData->IsWndMax)
            SendMessageW(GuiData->hWindow, WM_SYSCOMMAND, SC_RESTORE, 0);
 
        /* Save its old position and size and show state */
        GuiData->WndPl.length = sizeof(WINDOWPLACEMENT);
        GetWindowPlacement(GuiData->hWindow, &GuiData->WndPl);
 
        /* Save the old window styles */
        GuiData->WndStyle   = GetWindowLongPtr(GuiData->hWindow, GWL_STYLE  );
        GuiData->WndStyleEx = GetWindowLongPtr(GuiData->hWindow, GWL_EXSTYLE);
    }
 
    if (FullScreen)
    {
        SendMessageW(GuiData->hWindow, WM_SYSCOMMAND, SC_MINIMIZE, 0);
 
        /* Switch to full screen */
        if (EnterFullScreen(GuiData))
        {
            /* Save the new state */
            Console->FixedSize = TRUE;
            GuiData->GuiInfo.FullScreen = TRUE;
 
            GuiData->ActiveBuffer->OldViewSize = GuiData->ActiveBuffer->ViewSize;
            // GuiData->ActiveBuffer->OldScreenBufferSize = GuiData->ActiveBuffer->ScreenBufferSize;
 
            /* Change the window styles */
            SetWindowLongPtr(GuiData->hWindow, GWL_STYLE,
                             WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN);
            SetWindowLongPtr(GuiData->hWindow, GWL_EXSTYLE,
                             WS_EX_APPWINDOW);
            // SetWindowPos(GuiData->hWindow, NULL, 0, 0, 0, 0,
                         // SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
                         // SWP_FRAMECHANGED | SWP_SHOWWINDOW);
 
            /* Reposition the window to the upper-left corner */
            SetWindowPos(GuiData->hWindow, HWND_TOPMOST, 0, 0, 0, 0,
                         SWP_NOSIZE | SWP_FRAMECHANGED | SWP_SHOWWINDOW);
 
            /* Make it the foreground window */
            SetForegroundWindow(GuiData->hWindow);
 
            /* Resize it */
            // // GuiConsoleResizeWindow(GuiData);
            // GuiConsoleResize(GuiData, SIZE_RESTORED, MAKELPARAM(640, 480));
 
            PostMessageW(GuiData->hWindow, WM_SYSCOMMAND, SC_MAXIMIZE, 0);
            // SendMessageW(GuiData->hWindow, WM_SYSCOMMAND, SC_MAXIMIZE, 0);
        }
 
        PostMessageW(GuiData->hWindow, WM_SYSCOMMAND,
                     GuiData->GuiInfo.FullScreen || GuiData->IsWndMax
                        ? SC_MAXIMIZE : SC_RESTORE,
                     0);
        // ShowWindowAsync(GuiData->hWindow, SW_RESTORE);
    }
    else
    {
        SendMessageW(GuiData->hWindow, WM_SYSCOMMAND, SC_MINIMIZE, 0);
 
        /* Restore windowing mode */
        LeaveFullScreen(GuiData);
 
        /* Save the new state */
        GuiData->GuiInfo.FullScreen = FALSE;
        Console->FixedSize = FALSE;
 
        /*
         * Restore possible saved dimensions
         * of the active screen buffer view.
         */
        GuiData->ActiveBuffer->ViewSize = GuiData->ActiveBuffer->OldViewSize;
        // GuiData->ActiveBuffer->ScreenBufferSize = GuiData->ActiveBuffer->OldScreenBufferSize;
 
        /* Restore the window styles */
        SetWindowLongPtr(GuiData->hWindow, GWL_STYLE,
                         GuiData->WndStyle);
        SetWindowLongPtr(GuiData->hWindow, GWL_EXSTYLE,
                         GuiData->WndStyleEx);
        SetWindowPos(GuiData->hWindow, NULL, 0, 0, 0, 0,
                     SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
                     SWP_FRAMECHANGED /*| SWP_SHOWWINDOW*/);
 
 
        /* Restore the window to its original position */
        SetWindowPlacement(GuiData->hWindow, &GuiData->WndPl);
 
        PostMessageW(GuiData->hWindow, WM_SYSCOMMAND,
                     GuiData->IsWndMax ? SC_MAXIMIZE : SC_RESTORE,
                     0);
        // ShowWindowAsync(GuiData->hWindow, SW_RESTORE);
 
        /* Make it the foreground window */
        SetForegroundWindow(GuiData->hWindow);
 
        /* Resize it */
        // GuiConsoleResizeWindow(GuiData);
 
        // PostMessageW(GuiData->hWindow, WM_SYSCOMMAND, SC_RESTORE, 0);
        // // ShowWindowAsync(GuiData->hWindow, SW_RESTORE);
    }
}

Referenced by GuiApplyUserSettings(), GuiConsoleInputThread(), GuiConsoleSwitchFullScreen(), and GuiSetDisplayMode().