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

Macros
#define	TUI_TITLE_BOX_CHAR_HEIGHT 5

#define	UL 0xDA /* HORZ and VERT */

#define	UR 0xBF

#define	LL 0xC0

#define	LR 0xD9

#define	D_UL 0xC9 /* D_HORZ and D_VERT */

#define	D_UR 0xBB

#define	D_LL 0xC8

#define	D_LR 0xBC

#define	HD_UL 0xD5 /* D_HORZ and VERT */

#define	HD_UR 0xB8

#define	HD_LL 0xD4

#define	HD_LR 0xBE

#define	VD_UL 0xD6 /* HORZ and D_VERT */

#define	VD_UR 0xB7

#define	VD_LL 0xD3

#define	VD_LR 0xBD

Functions
INT	TuiPrintf (_In_ PCSTR Format,...)

VOID	TuiTruncateStringEllipsis (_Inout_z_ PSTR StringText, _In_ ULONG MaxChars)

BOOLEAN	TuiInitialize (VOID)

VOID	TuiUnInitialize (VOID)

VOID	TuiDrawBackdrop (VOID)

VOID	TuiFillArea (ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, CHAR FillChar, UCHAR Attr)

VOID	TuiDrawShadow (ULONG Left, ULONG Top, ULONG Right, ULONG Bottom)

VOID	TuiDrawBox (_In_ ULONG Left, _In_ ULONG Top, _In_ ULONG Right, _In_ ULONG Bottom, _In_ UCHAR VertStyle, _In_ UCHAR HorzStyle, _In_ BOOLEAN Fill, _In_ BOOLEAN Shadow, _In_ UCHAR Attr)

VOID	TuiDrawBoxTopLine (_In_ ULONG Left, _In_ ULONG Top, _In_ ULONG Right, _In_ UCHAR VertStyle, _In_ UCHAR HorzStyle, _In_ UCHAR Attr)

VOID	TuiDrawBoxBottomLine (_In_ ULONG Left, _In_ ULONG Bottom, _In_ ULONG Right, _In_ UCHAR VertStyle, _In_ UCHAR HorzStyle, _In_ UCHAR Attr)

VOID	TuiDrawText (_In_ ULONG X, _In_ ULONG Y, _In_ PCSTR Text, _In_ UCHAR Attr)

VOID	TuiDrawText2 (_In_ ULONG X, _In_ ULONG Y, _In_opt_ ULONG MaxNumChars, _In_reads_or_z_(MaxNumChars) PCSTR Text, _In_ UCHAR Attr)

VOID	TuiDrawCenteredText (_In_ ULONG Left, _In_ ULONG Top, _In_ ULONG Right, _In_ ULONG Bottom, _In_ PCSTR TextString, _In_ UCHAR Attr)

VOID	TuiDrawStatusText (PCSTR StatusText)

VOID	TuiUpdateDateTime (VOID)

VOID	TuiSaveScreen (PUCHAR Buffer)

VOID	TuiRestoreScreen (PUCHAR Buffer)

VOID	TuiMessageBox (PCSTR MessageText)

VOID	TuiMessageBoxCritical (PCSTR MessageText)

BOOLEAN	TuiEditBox (PCSTR MessageText, PCHAR EditTextBuffer, ULONG Length)

UCHAR	TuiTextToColor (PCSTR ColorText)

UCHAR	TuiTextToFillStyle (PCSTR FillStyleText)

VOID	TuiFadeInBackdrop (VOID)

VOID	TuiFadeOut (VOID)

VOID	TuiDrawMenu (_In_ PUI_MENU_INFO MenuInfo)

VOID	TuiDrawMenuBox (_In_ PUI_MENU_INFO MenuInfo)

VOID	TuiDrawMenuItem (_In_ PUI_MENU_INFO MenuInfo, _In_ ULONG MenuItemNumber)

BOOLEAN	TuiDisplayMenu (IN PCSTR MenuHeader, IN PCSTR MenuFooter OPTIONAL, IN BOOLEAN ShowBootOptions, IN PCSTR MenuItemList[], IN ULONG MenuItemCount, IN ULONG DefaultMenuItem, IN LONG MenuTimeOut, OUT PULONG SelectedMenuItem, IN BOOLEAN CanEscape, IN UiMenuKeyPressFilterCallback KeyPressFilter OPTIONAL, IN PVOID Context OPTIONAL)

Variables
const UIVTBL	TuiVtbl

Macro Definition Documentation

◆ D_LL

#define D_LL 0xC8

Definition at line 155 of file tui.h.

◆ D_LR

#define D_LR 0xBC

Definition at line 156 of file tui.h.

◆ D_UL

#define D_UL 0xC9 /* D_HORZ and D_VERT */

Definition at line 153 of file tui.h.

◆ D_UR

#define D_UR 0xBB

Definition at line 154 of file tui.h.

◆ HD_LL

#define HD_LL 0xD4

Definition at line 160 of file tui.h.

◆ HD_LR

#define HD_LR 0xBE

Definition at line 161 of file tui.h.

◆ HD_UL

#define HD_UL 0xD5 /* D_HORZ and VERT */

Definition at line 158 of file tui.h.

◆ HD_UR

#define HD_UR 0xB8

Definition at line 159 of file tui.h.

◆ LL

#define LL 0xC0

Definition at line 150 of file tui.h.

◆ LR

#define LR 0xD9

Definition at line 151 of file tui.h.

◆ TUI_TITLE_BOX_CHAR_HEIGHT

#define TUI_TITLE_BOX_CHAR_HEIGHT 5

Definition at line 33 of file tui.h.

◆ UL

#define UL 0xDA /* HORZ and VERT */

Definition at line 148 of file tui.h.

◆ UR

#define UR 0xBF

Definition at line 149 of file tui.h.

◆ VD_LL

#define VD_LL 0xD3

Definition at line 165 of file tui.h.

◆ VD_LR

#define VD_LR 0xBD

Definition at line 166 of file tui.h.

◆ VD_UL

#define VD_UL 0xD6 /* HORZ and D_VERT */

Definition at line 163 of file tui.h.

◆ VD_UR

#define VD_UR 0xB7

Definition at line 164 of file tui.h.

Function Documentation

◆ TuiDisplayMenu()

BOOLEAN TuiDisplayMenu	(	IN PCSTR	MenuHeader,
		IN PCSTR MenuFooter	OPTIONAL,
		IN BOOLEAN	ShowBootOptions,
		IN PCSTR	MenuItemList[],
		IN ULONG	MenuItemCount,
		IN ULONG	DefaultMenuItem,
		IN LONG	MenuTimeOut,
		OUT PULONG	SelectedMenuItem,
		IN BOOLEAN	CanEscape,
		IN UiMenuKeyPressFilterCallback KeyPressFilter	OPTIONAL,
		IN PVOID Context	OPTIONAL
	)

Definition at line 30 of file tuimenu.c.

{
    UI_MENU_INFO MenuInformation;
    ULONG LastClockSecond;
    ULONG CurrentClockSecond;
    ULONG KeyPress;
 
    /*
     * Before taking any default action if there is no timeout,
     * check whether the supplied key filter callback function
     * may handle a specific user keypress. If it does, the
     * timeout is cancelled.
     */
    if (!MenuTimeOut && KeyPressFilter && MachConsKbHit())
    {
        /* Get the key (get the extended key if needed) */
        KeyPress = MachConsGetCh();
        if (KeyPress == KEY_EXTENDED)
            KeyPress = MachConsGetCh();
 
        /*
         * Call the supplied key filter callback function to see
         * if it is going to handle this keypress.
         */
        if (KeyPressFilter(KeyPress, DefaultMenuItem, Context))
        {
            /* It processed the key character, cancel the timeout */
            MenuTimeOut = -1;
        }
    }
 
    /* Check if there is no timeout */
    if (!MenuTimeOut)
    {
        /* Return the default selected item */
        if (SelectedMenuItem) *SelectedMenuItem = DefaultMenuItem;
        return TRUE;
    }
 
    /* Setup the MENU_INFO structure */
    MenuInformation.MenuHeader = MenuHeader;
    MenuInformation.MenuFooter = MenuFooter;
    MenuInformation.ShowBootOptions = ShowBootOptions;
    MenuInformation.MenuItemList = MenuItemList;
    MenuInformation.MenuItemCount = MenuItemCount;
    MenuInformation.MenuTimeRemaining = MenuTimeOut;
    MenuInformation.SelectedMenuItem = DefaultMenuItem;
    MenuInformation.Context = Context;
 
    /* Calculate the size of the menu box */
    TuiCalcMenuBoxSize(&MenuInformation);
 
    /* Draw the menu */
    UiVtbl.DrawMenu(&MenuInformation);
 
    /* Get the current second of time */
    LastClockSecond = ArcGetTime()->Second;
 
    /* Process keys */
    while (TRUE)
    {
        /* Process key presses */
        KeyPress = TuiProcessMenuKeyboardEvent(&MenuInformation, KeyPressFilter);
 
        /* Check for ENTER or ESC */
        if (KeyPress == KEY_ENTER) break;
        if (CanEscape && KeyPress == KEY_ESC) return FALSE;
 
        /* Get the updated time, and check if more than a second has elapsed */
        CurrentClockSecond = ArcGetTime()->Second;
        if (CurrentClockSecond != LastClockSecond)
        {
            /* Update the time information */
            LastClockSecond = CurrentClockSecond;
 
            // FIXME: Theme-specific
            /* Update the date & time */
            TuiUpdateDateTime();
 
            /* If there is a countdown, update it */
            if (MenuInformation.MenuTimeRemaining > 0)
            {
                MenuInformation.MenuTimeRemaining--;
                TuiDrawMenuTimeout(&MenuInformation);
            }
            else if (MenuInformation.MenuTimeRemaining == 0)
            {
                /* A timeout occurred, exit this loop and return selection */
                VideoCopyOffScreenBufferToVRAM();
                break;
            }
            VideoCopyOffScreenBufferToVRAM();
        }
 
        MachHwIdle();
    }
 
    /* Return the selected item */
    if (SelectedMenuItem) *SelectedMenuItem = MenuInformation.SelectedMenuItem;
    return TRUE;
}

◆ TuiDrawBackdrop()

VOID TuiDrawBackdrop ( VOID )

Definition at line 264 of file tui.c.

{
    /* Fill in the background (excluding title box & status bar) */
    TuiFillArea(0,
                TUI_TITLE_BOX_CHAR_HEIGHT,
                UiScreenWidth - 1,
                UiScreenHeight - 2,
                UiBackdropFillStyle,
                ATTR(UiBackdropFgColor, UiBackdropBgColor));
 
    /* Draw the title box */
    TuiDrawBox(0,
               0,
               UiScreenWidth - 1,
               TUI_TITLE_BOX_CHAR_HEIGHT - 1,
               D_VERT,
               D_HORZ,
               TRUE,
               FALSE,
               ATTR(UiTitleBoxFgColor, UiTitleBoxBgColor));
 
    /* Draw version text */
    TuiDrawText(2,
                1,
                FrLdrVersionString,
                ATTR(UiTitleBoxFgColor, UiTitleBoxBgColor));
 
    /* Draw copyright */
    TuiDrawText(2,
                2,
                BY_AUTHOR,
                ATTR(UiTitleBoxFgColor, UiTitleBoxBgColor));
    TuiDrawText(2,
                3,
                AUTHOR_EMAIL,
                ATTR(UiTitleBoxFgColor, UiTitleBoxBgColor));
 
    /* Draw help text */
    TuiDrawText(UiScreenWidth - 16, 3,
                /*"F1 for Help"*/ "F8 for Options",
                ATTR(UiTitleBoxFgColor, UiTitleBoxBgColor));
 
    /* Draw title text */
    TuiDrawText((UiScreenWidth - (ULONG)strlen(UiTitleBoxTitleText)) / 2,
                2,
                UiTitleBoxTitleText,
                ATTR(UiTitleBoxFgColor, UiTitleBoxBgColor));
 
    /* Update the date & time */
    TuiUpdateDateTime();
    VideoCopyOffScreenBufferToVRAM();
}

Referenced by TuiFadeInBackdrop().

◆ TuiDrawBox()

VOID TuiDrawBox	(	_In_ ULONG	Left,
		_In_ ULONG	Top,
		_In_ ULONG	Right,
		_In_ ULONG	Bottom,
		_In_ UCHAR	VertStyle,
		_In_ UCHAR	HorzStyle,
		_In_ BOOLEAN	Fill,
		_In_ BOOLEAN	Shadow,
		_In_ UCHAR	Attr
	)

Definition at line 496 of file tui.c.

{
    /* Fill in the box background */
    if (Fill)
        TuiFillArea(Left, Top, Right, Bottom, ' ', Attr);
 
    /* Fill in the top horizontal line */
    TuiDrawBoxTopLine(Left, Top, Right, VertStyle, HorzStyle, Attr);
 
    /* Fill in the vertical left and right lines */
    TuiFillArea(Left, Top+1, Left, Bottom-1, VertStyle, Attr);
    TuiFillArea(Right, Top+1, Right, Bottom-1, VertStyle, Attr);
 
    /* Fill in the bottom horizontal line */
    TuiDrawBoxBottomLine(Left, Bottom, Right, VertStyle, HorzStyle, Attr);
 
    /* Draw the shadow */
    if (Shadow)
        TuiDrawShadow(Left, Top, Right, Bottom);
}

Referenced by TuiDrawBackdrop(), TuiDrawProgressBar(), TuiEditBox(), and TuiMessageBoxCritical().

◆ TuiDrawBoxBottomLine()

VOID TuiDrawBoxBottomLine	(	_In_ ULONG	Left,
		_In_ ULONG	Bottom,
		_In_ ULONG	Right,
		_In_ UCHAR	VertStyle,
		_In_ UCHAR	HorzStyle,
		_In_ UCHAR	Attr
	)

Definition at line 452 of file tui.c.

{
    UCHAR LLCorner, LRCorner;
 
    /* Calculate the corner values */
    if (HorzStyle == HORZ)
    {
        if (VertStyle == VERT)
        {
            LLCorner = LL;
            LRCorner = LR;
        }
        else // VertStyle == D_VERT
        {
            LLCorner = VD_LL;
            LRCorner = VD_LR;
        }
    }
    else // HorzStyle == D_HORZ
    {
        if (VertStyle == VERT)
        {
            LLCorner = HD_LL;
            LRCorner = HD_LR;
        }
        else // VertStyle == D_VERT
        {
            LLCorner = D_LL;
            LRCorner = D_LR;
        }
    }
 
    TuiFillArea(Left, Bottom, Left, Bottom, LLCorner, Attr);
    TuiFillArea(Left+1, Bottom, Right-1, Bottom, HorzStyle, Attr);
    TuiFillArea(Right, Bottom, Right, Bottom, LRCorner, Attr);
}

Referenced by TuiDrawBox(), and TuiDrawMenuTimeout().

◆ TuiDrawBoxTopLine()

VOID TuiDrawBoxTopLine	(	_In_ ULONG	Left,
		_In_ ULONG	Top,
		_In_ ULONG	Right,
		_In_ UCHAR	VertStyle,
		_In_ UCHAR	HorzStyle,
		_In_ UCHAR	Attr
	)

Definition at line 408 of file tui.c.

{
    UCHAR ULCorner, URCorner;
 
    /* Calculate the corner values */
    if (HorzStyle == HORZ)
    {
        if (VertStyle == VERT)
        {
            ULCorner = UL;
            URCorner = UR;
        }
        else // VertStyle == D_VERT
        {
            ULCorner = VD_UL;
            URCorner = VD_UR;
        }
    }
    else // HorzStyle == D_HORZ
    {
        if (VertStyle == VERT)
        {
            ULCorner = HD_UL;
            URCorner = HD_UR;
        }
        else // VertStyle == D_VERT
        {
            ULCorner = D_UL;
            URCorner = D_UR;
        }
    }
 
    TuiFillArea(Left, Top, Left, Top, ULCorner, Attr);
    TuiFillArea(Left+1, Top, Right-1, Top, HorzStyle, Attr);
    TuiFillArea(Right, Top, Right, Top, URCorner, Attr);
}

Referenced by TuiDrawBox().

◆ TuiDrawCenteredText()

VOID TuiDrawCenteredText	(	_In_ ULONG	Left,
		_In_ ULONG	Top,
		_In_ ULONG	Right,
		_In_ ULONG	Bottom,
		_In_ PCSTR	TextString,
		_In_ UCHAR	Attr
	)

Definition at line 110 of file tui.c.

{
    SIZE_T TextLength;
    SIZE_T Index, LastIndex;
    ULONG  LineBreakCount;
    ULONG  BoxWidth, BoxHeight;
    ULONG  RealLeft, RealTop;
    ULONG  X, Y;
    CHAR   Temp[2];
 
    /* Query text length */
    TextLength = strlen(TextString);
 
    /* Count the new lines and the box width */
    LineBreakCount = 0;
    BoxWidth = 0;
    LastIndex = 0;
    for (Index = 0; Index < TextLength; Index++)
    {
        /* Scan for new lines */
        if (TextString[Index] == '\n')
        {
            /* Remember the new line */
            LastIndex = Index;
            LineBreakCount++;
        }
        else
        {
            /* Check for new larger box width */
            if ((Index - LastIndex) > BoxWidth)
            {
                /* Update it */
                BoxWidth = (ULONG)(Index - LastIndex);
            }
        }
    }
 
    /* Base the box height on the number of lines */
    BoxHeight = LineBreakCount + 1;
 
    /*
     * Create the centered coordinates.
     * Here, the Left/Top/Right/Bottom rectangle is a hint, around
     * which we center the "real" text rectangle RealLeft/RealTop.
     */
    RealLeft = (Left + Right - BoxWidth + 1) / 2;
    RealTop  = (Top + Bottom - BoxHeight + 1) / 2;
 
    /* Now go for a second scan */
    LastIndex = 0;
    for (Index = 0; Index < TextLength; Index++)
    {
        /* Look for new lines again */
        if (TextString[Index] == '\n')
        {
            /* Update where the text should start */
            RealTop++;
            LastIndex = 0;
        }
        else
        {
            /* We've got a line of text to print, do it */
            X = (ULONG)(RealLeft + LastIndex);
            Y = RealTop;
            LastIndex++;
            Temp[0] = TextString[Index];
            Temp[1] = 0;
            TuiDrawText(X, Y, Temp, Attr);
        }
    }
}

Referenced by MiniTuiSetProgressBarText(), and TuiSetProgressBarText().

◆ TuiDrawMenu()

VOID TuiDrawMenu ( _In_ PUI_MENU_INFO MenuInfo )

Definition at line 191 of file tuimenu.c.

{
    ULONG i;
 
    // FIXME: Theme-specific
    /* Draw the backdrop */
    UiDrawBackdrop();
 
    /* Draw the menu box */
    TuiDrawMenuBox(MenuInfo);
 
    /* Draw each line of the menu */
    for (i = 0; i < MenuInfo->MenuItemCount; ++i)
    {
        TuiDrawMenuItem(MenuInfo, i);
    }
 
    // FIXME: Theme-specific
    /* Update the status bar */
    UiVtbl.DrawStatusText("Use \x18 and \x19 to select, then press ENTER.");
 
    /* Display the boot options if needed */
    if (MenuInfo->ShowBootOptions)
    {
        DisplayBootTimeOptions();
    }
 
    VideoCopyOffScreenBufferToVRAM();
}

◆ TuiDrawMenuBox()

VOID TuiDrawMenuBox ( _In_ PUI_MENU_INFO MenuInfo )

Definition at line 342 of file tuimenu.c.

{
    // FIXME: Theme-specific
    /* Draw the menu box if requested */
    if (UiMenuBox)
    {
        UiDrawBox(MenuInfo->Left,
                  MenuInfo->Top,
                  MenuInfo->Right,
                  MenuInfo->Bottom,
                  D_VERT,
                  D_HORZ,
                  FALSE,    // Filled
                  TRUE,     // Shadow
                  ATTR(UiMenuFgColor, UiMenuBgColor));
    }
 
    /* Update the date & time */
    TuiUpdateDateTime();
    TuiDrawMenuTimeout(MenuInfo);
}

Referenced by MiniTuiDrawMenu(), and TuiDrawMenu().

◆ TuiDrawMenuItem()

VOID TuiDrawMenuItem	(	_In_ PUI_MENU_INFO	MenuInfo,
		_In_ ULONG	MenuItemNumber
	)

Definition at line 366 of file tuimenu.c.

{
    ULONG SpaceLeft;
    ULONG SpaceRight;
    UCHAR Attribute;
    CHAR MenuLineText[80];
 
    /* If this is a separator */
    if (MenuInfo->MenuItemList[MenuItemNumber] == NULL)
    {
        // FIXME: Theme-specific
        /* Draw its left box corner */
        if (UiMenuBox)
        {
            UiDrawText(MenuInfo->Left,
                       MenuInfo->Top + 1 + MenuItemNumber,
                       "\xC7",
                       ATTR(UiMenuFgColor, UiMenuBgColor));
        }
 
        /* Make it a separator line and use menu colors */
        RtlZeroMemory(MenuLineText, sizeof(MenuLineText));
        RtlFillMemory(MenuLineText,
                      min(sizeof(MenuLineText), (MenuInfo->Right - MenuInfo->Left - 1)),
                      0xC4);
 
        /* Draw the item */
        UiDrawText(MenuInfo->Left + 1,
                   MenuInfo->Top + 1 + MenuItemNumber,
                   MenuLineText,
                   ATTR(UiMenuFgColor, UiMenuBgColor));
 
        // FIXME: Theme-specific
        /* Draw its right box corner */
        if (UiMenuBox)
        {
            UiDrawText(MenuInfo->Right,
                       MenuInfo->Top + 1 + MenuItemNumber,
                       "\xB6",
                       ATTR(UiMenuFgColor, UiMenuBgColor));
        }
 
        /* We are done */
        return;
    }
 
    /* This is not a separator */
    ASSERT(MenuInfo->MenuItemList[MenuItemNumber]);
 
    /* Check if using centered menu */
    if (UiCenterMenu)
    {
        /*
         * We will want the string centered so calculate
         * how many spaces will be to the left and right.
         */
        ULONG SpaceTotal =
            (MenuInfo->Right - MenuInfo->Left - 2) -
            (ULONG)strlen(MenuInfo->MenuItemList[MenuItemNumber]);
        SpaceLeft  = (SpaceTotal / 2) + 1;
        SpaceRight = (SpaceTotal - SpaceLeft) + 1;
    }
    else
    {
        /* Simply left-align it */
        SpaceLeft  = 4;
        SpaceRight = 0;
    }
 
    /* Format the item text string */
    RtlStringCbPrintfA(MenuLineText, sizeof(MenuLineText),
                       "%*s%s%*s",
                       SpaceLeft, "",   // Left padding
                       MenuInfo->MenuItemList[MenuItemNumber],
                       SpaceRight, ""); // Right padding
 
    if (MenuItemNumber == MenuInfo->SelectedMenuItem)
    {
        /* If this is the selected item, use the selected colors */
        Attribute = ATTR(UiSelectedTextColor, UiSelectedTextBgColor);
    }
    else
    {
        /* Normal item colors */
        Attribute = ATTR(UiTextColor, UiMenuBgColor);
    }
 
    /* Draw the item */
    UiDrawText(MenuInfo->Left + 1,
               MenuInfo->Top + 1 + MenuItemNumber,
               MenuLineText,
               Attribute);
}

Referenced by MiniTuiDrawMenu(), TuiDrawMenu(), and TuiProcessMenuKeyboardEvent().

◆ TuiDrawShadow()

VOID TuiDrawShadow	(	ULONG	Left,
		ULONG	Top,
		ULONG	Right,
		ULONG	Bottom
	)

Definition at line 351 of file tui.c.

{
    PUCHAR ScreenMemory = (PUCHAR)TextVideoBuffer;
    ULONG  Idx;
 
    /* Shade the bottom of the area */
    if (Bottom < (UiScreenHeight - 1))
    {
        if (UiScreenHeight < 34)
            Idx = Left + 2;
        else
            Idx = Left + 1;
 
        for (; Idx <= Right; ++Idx)
        {
            ScreenMemory[(((Bottom+1)*2)*UiScreenWidth)+(Idx*2)+1] = ATTR(COLOR_GRAY, COLOR_BLACK);
        }
    }
 
    /* Shade the right of the area */
    if (Right < (UiScreenWidth - 1))
    {
        for (Idx=Top+1; Idx<=Bottom; Idx++)
        {
            ScreenMemory[((Idx*2)*UiScreenWidth)+((Right+1)*2)+1] = ATTR(COLOR_GRAY, COLOR_BLACK);
        }
    }
    if (UiScreenHeight < 34)
    {
        if ((Right + 1) < (UiScreenWidth - 1))
        {
            for (Idx=Top+1; Idx<=Bottom; Idx++)
            {
                ScreenMemory[((Idx*2)*UiScreenWidth)+((Right+2)*2)+1] = ATTR(COLOR_GRAY, COLOR_BLACK);
            }
        }
    }
 
    /* Shade the bottom right corner */
    if ((Right < (UiScreenWidth - 1)) && (Bottom < (UiScreenHeight - 1)))
    {
        ScreenMemory[(((Bottom+1)*2)*UiScreenWidth)+((Right+1)*2)+1] = ATTR(COLOR_GRAY, COLOR_BLACK);
    }
    if (UiScreenHeight < 34)
    {
        if (((Right + 1) < (UiScreenWidth - 1)) && (Bottom < (UiScreenHeight - 1)))
        {
            ScreenMemory[(((Bottom+1)*2)*UiScreenWidth)+((Right+2)*2)+1] = ATTR(COLOR_GRAY, COLOR_BLACK);
        }
    }
}

Referenced by TuiDrawBox().

◆ TuiDrawStatusText()

VOID TuiDrawStatusText ( PCSTR StatusText )

Definition at line 526 of file tui.c.

{
    SIZE_T    i;
 
    TuiDrawText(0, UiScreenHeight-1, " ", ATTR(UiStatusBarFgColor, UiStatusBarBgColor));
    TuiDrawText(1, UiScreenHeight-1, StatusText, ATTR(UiStatusBarFgColor, UiStatusBarBgColor));
 
    for (i=strlen(StatusText)+1; i<UiScreenWidth; i++)
    {
        TuiDrawText((ULONG)i, UiScreenHeight-1, " ", ATTR(UiStatusBarFgColor, UiStatusBarBgColor));
    }
 
    VideoCopyOffScreenBufferToVRAM();
}

◆ TuiDrawText()

VOID TuiDrawText	(	_In_ ULONG	X,
		_In_ ULONG	Y,
		_In_ PCSTR	Text,
		_In_ UCHAR	Attr
	)

Definition at line 70 of file tui.c.

{
    TuiDrawText2(X, Y, 0 /*(ULONG)strlen(Text)*/, Text, Attr);
}

Referenced by TuiDrawBackdrop(), TuiDrawCenteredText(), TuiDrawStatusText(), and TuiUpdateDateTime().

◆ TuiDrawText2()

VOID TuiDrawText2	(	_In_ ULONG	X,
		_In_ ULONG	Y,
		_In_opt_ ULONG	MaxNumChars,
		_In_reads_or_z_(MaxNumChars) PCSTR	Text,
		_In_ UCHAR	Attr
	)

Definition at line 87 of file tui.c.

{
    PUCHAR ScreenMemory = (PUCHAR)TextVideoBuffer;
    ULONG i, j;
 
    /* Don't display anything if we are out of the screen */
    if ((X >= UiScreenWidth) || (Y >= UiScreenHeight))
        return;
 
    /* Draw the text, not exceeding the width */
    for (i = X, j = 0; Text[j] && i < UiScreenWidth && (MaxNumChars > 0 ? j < MaxNumChars : TRUE); i++, j++)
    {
        ScreenMemory[((Y*2)*UiScreenWidth)+(i*2)]   = (UCHAR)Text[j];
        ScreenMemory[((Y*2)*UiScreenWidth)+(i*2)+1] = Attr;
    }
}

Referenced by TuiDrawText().

◆ TuiEditBox()

BOOLEAN TuiEditBox	(	PCSTR	MessageText,
		PCHAR	EditTextBuffer,
		ULONG	Length
	)

Definition at line 971 of file tui.c.

{
    INT        width = 8;
    ULONG    height = 1;
    INT        curline = 0;
    INT        k;
    size_t    i , j;
    INT        x1, x2, y1, y2;
    CHAR    temp[260];
    CHAR    key;
    BOOLEAN    Extended;
    INT        EditBoxLine;
    ULONG    EditBoxStartX, EditBoxEndX;
    INT        EditBoxCursorX;
    ULONG    EditBoxTextLength, EditBoxTextPosition;
    INT        EditBoxTextDisplayIndex;
    BOOLEAN    ReturnCode;
    PVOID    ScreenBuffer;
 
    // Save the screen contents
    ScreenBuffer = FrLdrTempAlloc(UiScreenWidth * UiScreenHeight * 2,
                                  TAG_TUI_SCREENBUFFER);
    TuiSaveScreen(ScreenBuffer);
 
    // Find the height
    for (i=0; i<strlen(MessageText); i++)
    {
        if (MessageText[i] == '\n')
            height++;
    }
 
    // Find the width
    for (i=0,j=0,k=0; i<height; i++)
    {
        while ((MessageText[j] != '\n') && (MessageText[j] != 0))
        {
            j++;
            k++;
        }
 
        if (k > width)
            width = k;
 
        k = 0;
        j++;
    }
 
    // Calculate box area
    x1 = (UiScreenWidth - (width+2))/2;
    x2 = x1 + width + 3;
    y1 = ((UiScreenHeight - height - 2)/2) + 1;
    y2 = y1 + height + 4;
 
    // Draw the box
    TuiDrawBox(x1, y1, x2, y2, D_VERT, D_HORZ, TRUE, TRUE, ATTR(UiMessageBoxFgColor, UiMessageBoxBgColor));
 
    // Draw the text
    for (i=0,j=0; i<strlen(MessageText)+1; i++)
    {
        if ((MessageText[i] == '\n') || (MessageText[i] == 0))
        {
            temp[j] = 0;
            j = 0;
            UiDrawText(x1+2, y1+1+curline, temp, ATTR(UiMessageBoxFgColor, UiMessageBoxBgColor));
            curline++;
        }
        else
            temp[j++] = MessageText[i];
    }
 
    EditBoxTextLength = (ULONG)strlen(EditTextBuffer);
    EditBoxTextLength = min(EditBoxTextLength, Length - 1);
    EditBoxTextPosition = 0;
    EditBoxLine = y2 - 2;
    EditBoxStartX = x1 + 3;
    EditBoxEndX = x2 - 3;
 
    // Draw the edit box background and the text
    UiFillArea(EditBoxStartX, EditBoxLine, EditBoxEndX, EditBoxLine, ' ', ATTR(UiEditBoxTextColor, UiEditBoxBgColor));
    UiDrawText2(EditBoxStartX, EditBoxLine, EditBoxEndX - EditBoxStartX + 1, EditTextBuffer, ATTR(UiEditBoxTextColor, UiEditBoxBgColor));
 
    // Show the cursor
    EditBoxCursorX = EditBoxStartX;
    MachVideoSetTextCursorPosition(EditBoxCursorX, EditBoxLine);
    MachVideoHideShowTextCursor(TRUE);
 
    // Draw status text
    UiDrawStatusText("Press ENTER to continue, or ESC to cancel");
 
    VideoCopyOffScreenBufferToVRAM();
 
    //
    // Enter the text. Please keep in mind that the default input mode
    // of the edit boxes is in insertion mode, that is, you can insert
    // text without erasing the existing one.
    //
    for (;;)
    {
        if (MachConsKbHit())
        {
            Extended = FALSE;
            key = MachConsGetCh();
            if (key == KEY_EXTENDED)
            {
                Extended = TRUE;
                key = MachConsGetCh();
            }
 
            if (key == KEY_ENTER)
            {
                ReturnCode = TRUE;
                break;
            }
            else if (key == KEY_ESC)
            {
                ReturnCode = FALSE;
                break;
            }
            else if (key == KEY_BACKSPACE) // Remove a character
            {
                if ( (EditBoxTextLength > 0) && (EditBoxTextPosition > 0) &&
                     (EditBoxTextPosition <= EditBoxTextLength) )
                {
                    EditBoxTextPosition--;
                    memmove(EditTextBuffer + EditBoxTextPosition,
                            EditTextBuffer + EditBoxTextPosition + 1,
                            EditBoxTextLength - EditBoxTextPosition);
                    EditBoxTextLength--;
                    EditTextBuffer[EditBoxTextLength] = 0;
                }
                else
                {
                    MachBeep();
                }
            }
            else if (Extended && key == KEY_DELETE) // Remove a character
            {
                if ( (EditBoxTextLength > 0) &&
                     (EditBoxTextPosition < EditBoxTextLength) )
                {
                    memmove(EditTextBuffer + EditBoxTextPosition,
                            EditTextBuffer + EditBoxTextPosition + 1,
                            EditBoxTextLength - EditBoxTextPosition);
                    EditBoxTextLength--;
                    EditTextBuffer[EditBoxTextLength] = 0;
                }
                else
                {
                    MachBeep();
                }
            }
            else if (Extended && key == KEY_HOME) // Go to the start of the buffer
            {
                EditBoxTextPosition = 0;
            }
            else if (Extended && key == KEY_END) // Go to the end of the buffer
            {
                EditBoxTextPosition = EditBoxTextLength;
            }
            else if (Extended && key == KEY_RIGHT) // Go right
            {
                if (EditBoxTextPosition < EditBoxTextLength)
                    EditBoxTextPosition++;
                else
                    MachBeep();
            }
            else if (Extended && key == KEY_LEFT) // Go left
            {
                if (EditBoxTextPosition > 0)
                    EditBoxTextPosition--;
                else
                    MachBeep();
            }
            else if (!Extended) // Add this key to the buffer
            {
                if ( (EditBoxTextLength   < Length - 1) &&
                     (EditBoxTextPosition < Length - 1) )
                {
                    memmove(EditTextBuffer + EditBoxTextPosition + 1,
                            EditTextBuffer + EditBoxTextPosition,
                            EditBoxTextLength - EditBoxTextPosition);
                    EditTextBuffer[EditBoxTextPosition] = key;
                    EditBoxTextPosition++;
                    EditBoxTextLength++;
                    EditTextBuffer[EditBoxTextLength] = 0;
                }
                else
                {
                    MachBeep();
                }
            }
            else
            {
                MachBeep();
            }
        }
 
        // Draw the edit box background
        UiFillArea(EditBoxStartX, EditBoxLine, EditBoxEndX, EditBoxLine, ' ', ATTR(UiEditBoxTextColor, UiEditBoxBgColor));
 
        // Fill the text in
        if (EditBoxTextPosition > (EditBoxEndX - EditBoxStartX))
        {
            EditBoxTextDisplayIndex = EditBoxTextPosition - (EditBoxEndX - EditBoxStartX);
            EditBoxCursorX = EditBoxEndX;
        }
        else
        {
            EditBoxTextDisplayIndex = 0;
            EditBoxCursorX = EditBoxStartX + EditBoxTextPosition;
        }
        UiDrawText2(EditBoxStartX, EditBoxLine, EditBoxEndX - EditBoxStartX + 1, &EditTextBuffer[EditBoxTextDisplayIndex], ATTR(UiEditBoxTextColor, UiEditBoxBgColor));
 
        // Move the cursor
        MachVideoSetTextCursorPosition(EditBoxCursorX, EditBoxLine);
 
        TuiUpdateDateTime();
 
        VideoCopyOffScreenBufferToVRAM();
 
        MachHwIdle();
    }
 
    // Hide the cursor again
    MachVideoHideShowTextCursor(FALSE);
 
    // Restore the screen contents
    TuiRestoreScreen(ScreenBuffer);
    FrLdrTempFree(ScreenBuffer, TAG_TUI_SCREENBUFFER);
 
    return ReturnCode;
}

◆ TuiFadeInBackdrop()

VOID TuiFadeInBackdrop ( VOID )

Definition at line 915 of file tui.c.

{
    PPALETTE_ENTRY TuiFadePalette = NULL;
 
    if (UiUseSpecialEffects && ! MachVideoIsPaletteFixed())
    {
        TuiFadePalette = (PPALETTE_ENTRY)FrLdrTempAlloc(sizeof(PALETTE_ENTRY) * 64,
                                                        TAG_TUI_PALETTE);
 
        if (TuiFadePalette != NULL)
        {
            VideoSavePaletteState(TuiFadePalette, 64);
            VideoSetAllColorsToBlack(64);
        }
    }
 
    // Draw the backdrop and title box
    TuiDrawBackdrop();
 
    if (UiUseSpecialEffects && ! MachVideoIsPaletteFixed() && TuiFadePalette != NULL)
    {
        VideoFadeIn(TuiFadePalette, 64);
        FrLdrTempFree(TuiFadePalette, TAG_TUI_PALETTE);
    }
}

◆ TuiFadeOut()

VOID TuiFadeOut ( VOID )

Definition at line 941 of file tui.c.

{
    PPALETTE_ENTRY TuiFadePalette = NULL;
 
    if (UiUseSpecialEffects && ! MachVideoIsPaletteFixed())
    {
        TuiFadePalette = (PPALETTE_ENTRY)FrLdrTempAlloc(sizeof(PALETTE_ENTRY) * 64,
                                                        TAG_TUI_PALETTE);
 
        if (TuiFadePalette != NULL)
        {
            VideoSavePaletteState(TuiFadePalette, 64);
        }
    }
 
    if (UiUseSpecialEffects && ! MachVideoIsPaletteFixed() && TuiFadePalette != NULL)
    {
        VideoFadeOut(64);
    }
 
    MachVideoSetDisplayMode(NULL, FALSE);
 
    if (UiUseSpecialEffects && ! MachVideoIsPaletteFixed() && TuiFadePalette != NULL)
    {
        VideoRestorePaletteState(TuiFadePalette, 64);
        FrLdrTempFree(TuiFadePalette, TAG_TUI_PALETTE);
    }
 
}

Referenced by TuiUnInitialize().

◆ TuiFillArea()

VOID TuiFillArea	(	ULONG	Left,
		ULONG	Top,
		ULONG	Right,
		ULONG	Bottom,
		CHAR	FillChar,
		UCHAR	Attr
	)

Definition at line 321 of file tui.c.

{
    PUCHAR ScreenMemory = (PUCHAR)TextVideoBuffer;
    ULONG  i, j;
 
    /* Clip the area to the screen */
    if ((Left >= UiScreenWidth) || (Top >= UiScreenHeight))
    {
        return;
    }
    if (Right >= UiScreenWidth)
        Right = UiScreenWidth - 1;
    if (Bottom >= UiScreenHeight)
        Bottom = UiScreenHeight - 1;
 
    /* Loop through each line and column and fill it in */
    for (i = Top; i <= Bottom; ++i)
    {
        for (j = Left; j <= Right; ++j)
        {
            ScreenMemory[((i*2)*UiScreenWidth)+(j*2)] = (UCHAR)FillChar;
            ScreenMemory[((i*2)*UiScreenWidth)+(j*2)+1] = Attr;
        }
    }
}

Referenced by MiniTuiDrawBackdrop(), MiniTuiSetProgressBarText(), MiniTuiTickProgressBar(), TuiDrawBackdrop(), TuiDrawBox(), TuiDrawBoxBottomLine(), TuiDrawBoxTopLine(), TuiDrawMenuTimeout(), TuiSetProgressBarText(), and TuiTickProgressBar().

◆ TuiInitialize()

BOOLEAN TuiInitialize ( VOID )

Definition at line 195 of file tui.c.

{
    MachVideoHideShowTextCursor(FALSE);
    MachVideoSetTextCursorPosition(0, 0);
    MachVideoClearScreen(ATTR(COLOR_GRAY, COLOR_BLACK));
 
    TextVideoBuffer = VideoAllocateOffScreenBuffer();
    if (TextVideoBuffer == NULL)
    {
        return FALSE;
    }
 
    /* Load default settings with "Full" TUI Theme */
 
    UiStatusBarFgColor    = COLOR_BLACK;
    UiStatusBarBgColor    = COLOR_CYAN;
    UiBackdropFgColor     = COLOR_WHITE;
    UiBackdropBgColor     = COLOR_BLUE;
    UiBackdropFillStyle   = MEDIUM_FILL;
    UiTitleBoxFgColor     = COLOR_WHITE;
    UiTitleBoxBgColor     = COLOR_RED;
    UiMessageBoxFgColor   = COLOR_WHITE;
    UiMessageBoxBgColor   = COLOR_BLUE;
    UiMenuFgColor         = COLOR_WHITE;
    UiMenuBgColor         = COLOR_BLUE;
    UiTextColor           = COLOR_YELLOW;
    UiSelectedTextColor   = COLOR_BLACK;
    UiSelectedTextBgColor = COLOR_GRAY;
    UiEditBoxTextColor    = COLOR_WHITE;
    UiEditBoxBgColor      = COLOR_BLACK;
 
    UiShowTime          = TRUE;
    UiMenuBox           = TRUE;
    UiCenterMenu        = TRUE;
    UiUseSpecialEffects = FALSE;
 
    // TODO: Have a boolean to show/hide title box?
    RtlStringCbCopyA(UiTitleBoxTitleText, sizeof(UiTitleBoxTitleText),
                     "Boot Menu");
 
    RtlStringCbCopyA(UiTimeText, sizeof(UiTimeText),
                     "[Time Remaining: %d]");
 
    return TRUE;
}

Referenced by MiniTuiInitialize().

◆ TuiMessageBox()

VOID TuiMessageBox ( PCSTR MessageText )

Definition at line 631 of file tui.c.

{
    PVOID    ScreenBuffer;
 
    // Save the screen contents
    ScreenBuffer = FrLdrTempAlloc(UiScreenWidth * UiScreenHeight * 2,
                                  TAG_TUI_SCREENBUFFER);
    TuiSaveScreen(ScreenBuffer);
 
    // Display the message box
    TuiMessageBoxCritical(MessageText);
 
    // Restore the screen contents
    TuiRestoreScreen(ScreenBuffer);
    FrLdrTempFree(ScreenBuffer, TAG_TUI_SCREENBUFFER);
}

◆ TuiMessageBoxCritical()

VOID TuiMessageBoxCritical ( PCSTR MessageText )

Definition at line 648 of file tui.c.

{
    int        width = 8;
    unsigned int    height = 1;
    int        curline = 0;
    int        k;
    size_t        i , j;
    int        x1, x2, y1, y2;
    char    temp[260];
    char    key;
 
    // Find the height
    for (i=0; i<strlen(MessageText); i++)
    {
        if (MessageText[i] == '\n')
            height++;
    }
 
    // Find the width
    for (i=0,j=0,k=0; i<height; i++)
    {
        while ((MessageText[j] != '\n') && (MessageText[j] != 0))
        {
            j++;
            k++;
        }
 
        if (k > width)
            width = k;
 
        k = 0;
        j++;
    }
 
    // Calculate box area
    x1 = (UiScreenWidth - (width+2))/2;
    x2 = x1 + width + 3;
    y1 = ((UiScreenHeight - height - 2)/2) + 1;
    y2 = y1 + height + 4;
 
    // Draw the box
    TuiDrawBox(x1, y1, x2, y2, D_VERT, D_HORZ, TRUE, TRUE, ATTR(UiMessageBoxFgColor, UiMessageBoxBgColor));
 
    // Draw the text
    for (i=0,j=0; i<strlen(MessageText)+1; i++)
    {
        if ((MessageText[i] == '\n') || (MessageText[i] == 0))
        {
            temp[j] = 0;
            j = 0;
            UiDrawText(x1+2, y1+1+curline, temp, ATTR(UiMessageBoxFgColor, UiMessageBoxBgColor));
            curline++;
        }
        else
            temp[j++] = MessageText[i];
    }
 
    // Draw OK button
    strcpy(temp, "   OK   ");
    UiDrawText(x1+((x2-x1)/2)-3, y2-2, temp, ATTR(COLOR_BLACK, COLOR_GRAY));
 
    // Draw status text
    UiDrawStatusText("Press ENTER to continue");
 
    VideoCopyOffScreenBufferToVRAM();
 
    for (;;)
    {
        if (MachConsKbHit())
        {
            key = MachConsGetCh();
            if (key == KEY_EXTENDED)
                key = MachConsGetCh();
 
            if ((key == KEY_ENTER) || (key == KEY_SPACE) || (key == KEY_ESC))
                break;
        }
 
        TuiUpdateDateTime();
 
        VideoCopyOffScreenBufferToVRAM();
 
        MachHwIdle();
    }
}

Referenced by TuiMessageBox().

◆ TuiPrintf()

INT TuiPrintf	(	_In_ PCSTR	Format,
			...
	)

Definition at line 31 of file tui.c.

{
    INT i;
    INT Length;
    va_list ap;
    CHAR Buffer[512];
 
    va_start(ap, Format);
    Length = _vsnprintf(Buffer, sizeof(Buffer), Format, ap);
    va_end(ap);
 
    if (Length == -1)
        Length = (INT)sizeof(Buffer);
 
    for (i = 0; i < Length; i++)
    {
        MachConsPutChar(Buffer[i]);
    }
 
    return Length;
}

Referenced by MachInit().

◆ TuiRestoreScreen()

VOID TuiRestoreScreen ( PUCHAR Buffer )

Definition at line 620 of file tui.c.

{
    PUCHAR    ScreenMemory = (PUCHAR)TextVideoBuffer;
    ULONG    i;
 
    for (i=0; i < (UiScreenWidth * UiScreenHeight * 2); i++)
    {
        ScreenMemory[i] = Buffer[i];
    }
}

Referenced by TuiEditBox(), and TuiMessageBox().

◆ TuiSaveScreen()

VOID TuiSaveScreen ( PUCHAR Buffer )

Definition at line 609 of file tui.c.

{
    PUCHAR    ScreenMemory = (PUCHAR)TextVideoBuffer;
    ULONG    i;
 
    for (i=0; i < (UiScreenWidth * UiScreenHeight * 2); i++)
    {
        Buffer[i] = ScreenMemory[i];
    }
}

Referenced by TuiEditBox(), and TuiMessageBox().

◆ TuiTextToColor()

UCHAR TuiTextToColor ( PCSTR ColorText )

Definition at line 852 of file tui.c.

{
    static const struct
    {
        PCSTR ColorName;
        UCHAR ColorValue;
    } Colors[] =
    {
        {"Black"  , COLOR_BLACK  },
        {"Blue"   , COLOR_BLUE   },
        {"Green"  , COLOR_GREEN  },
        {"Cyan"   , COLOR_CYAN   },
        {"Red"    , COLOR_RED    },
        {"Magenta", COLOR_MAGENTA},
        {"Brown"  , COLOR_BROWN  },
        {"Gray"   , COLOR_GRAY   },
        {"DarkGray"    , COLOR_DARKGRAY    },
        {"LightBlue"   , COLOR_LIGHTBLUE   },
        {"LightGreen"  , COLOR_LIGHTGREEN  },
        {"LightCyan"   , COLOR_LIGHTCYAN   },
        {"LightRed"    , COLOR_LIGHTRED    },
        {"LightMagenta", COLOR_LIGHTMAGENTA},
        {"Yellow"      , COLOR_YELLOW      },
        {"White"       , COLOR_WHITE       },
    };
    ULONG i;
 
    if (_stricmp(ColorText, "Default") == 0)
        return MachDefaultTextColor;
 
    for (i = 0; i < RTL_NUMBER_OF(Colors); ++i)
    {
        if (_stricmp(ColorText, Colors[i].ColorName) == 0)
            return Colors[i].ColorValue;
    }
 
    return COLOR_BLACK;
}