tui.h File Reference

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

Go to the source code of this file.

Macros
#define	TUI_TITLE_BOX_CHAR_HEIGHT   5
#define	UL   (0xda)
#define	UR   (0xbf) /* HORZ and VERT */
#define	LL   (0xc0)
#define	LR   (0xd9)
#define	D_UL   (0xc9)
#define	D_UR   (0xbb) /* D_HORZ and D_VERT */
#define	D_LL   (0xc8)
#define	D_LR   (0xbc)
#define	HD_UL   (0xd5)
#define	HD_UR   (0xb8) /* D_HORZ and VERT */
#define	HD_LL   (0xd4)
#define	HD_LR   (0xbe)
#define	VD_UL   (0xd6)
#define	VD_UR   (0xb7) /* HORZ and D_VERT */
#define	VD_LL   (0xd3)
#define	VD_LR   (0xbd)

Functions
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 (ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, UCHAR VertStyle, UCHAR HorzStyle, BOOLEAN Fill, BOOLEAN Shadow, UCHAR Attr)
VOID	TuiDrawText (ULONG X, ULONG Y, PCSTR Text, UCHAR Attr)
VOID	TuiDrawText2 (ULONG X, ULONG Y, ULONG MaxNumChars, PCSTR Text, UCHAR Attr)
VOID	TuiDrawCenteredText (ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, PCSTR TextString, 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)
VOID	TuiDrawProgressBarCenter (ULONG Position, ULONG Range, PCHAR ProgressText)
VOID	TuiDrawProgressBar (ULONG Left, ULONG Top, ULONG Right, ULONG Bottom, ULONG Position, ULONG Range, PCHAR ProgressText)
BOOLEAN	TuiEditBox (PCSTR MessageText, PCHAR EditTextBuffer, ULONG Length)
int	TuiPrintf (const char *format,...)
UCHAR	TuiTextToColor (PCSTR ColorText)
UCHAR	TuiTextToFillStyle (PCSTR FillStyleText)
VOID	TuiFadeInBackdrop (VOID)
VOID	TuiFadeOut (VOID)
VOID	TuiCalcMenuBoxSize (PUI_MENU_INFO MenuInfo)
VOID	TuiDrawMenu (PUI_MENU_INFO MenuInfo)
VOID	TuiDrawMenuBox (PUI_MENU_INFO MenuInfo)
VOID	TuiDrawMenuItem (PUI_MENU_INFO MenuInfo, ULONG MenuItemNumber)
ULONG	TuiProcessMenuKeyboardEvent (PUI_MENU_INFO MenuInfo, UiMenuKeyPressFilterCallback KeyPressFilter)
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 89 of file tui.h.

D_LR

#define D_LR   (0xbc)

Definition at line 90 of file tui.h.

D_UL

#define D_UL   (0xc9)

Definition at line 87 of file tui.h.

D_UR

#define D_UR   (0xbb) /* D_HORZ and D_VERT */

Definition at line 88 of file tui.h.

HD_LL

#define HD_LL   (0xd4)

Definition at line 94 of file tui.h.

HD_LR

#define HD_LR   (0xbe)

Definition at line 95 of file tui.h.

HD_UL

#define HD_UL   (0xd5)

Definition at line 92 of file tui.h.

HD_UR

#define HD_UR   (0xb8) /* D_HORZ and VERT */

Definition at line 93 of file tui.h.

LL

#define LL   (0xc0)

Definition at line 84 of file tui.h.

LR

#define LR   (0xd9)

Definition at line 85 of file tui.h.

TUI_TITLE_BOX_CHAR_HEIGHT

#define TUI_TITLE_BOX_CHAR_HEIGHT   5

Definition at line 22 of file tui.h.

UL

#define UL   (0xda)

Definition at line 82 of file tui.h.

UR

#define UR   (0xbf) /* HORZ and VERT */

Definition at line 83 of file tui.h.

VD_LL

#define VD_LL   (0xd3)

Definition at line 99 of file tui.h.

VD_LR

#define VD_LR   (0xbd)

Definition at line 100 of file tui.h.

VD_UL

#define VD_UL   (0xd6)

Definition at line 97 of file tui.h.

VD_UR

#define VD_UR   (0xb7) /* HORZ and D_VERT */

Definition at line 98 of file tui.h.

Function Documentation

TuiCalcMenuBoxSize()

VOID TuiCalcMenuBoxSize

(

PUI_MENU_INFO

MenuInfo

)

Definition at line 171 of file tuimenu.c.

{
    ULONG i;
    ULONG Width = 0;
    ULONG Height;
    ULONG Length;

    //
    // Height is the menu item count plus 2 (top border & bottom border)
    //
    Height = MenuInfo->MenuItemCount + 2;
    Height -= 1; // Height is zero-based

    //
    // Loop every item
    //
    for(i = 0; i < MenuInfo->MenuItemCount; i++)
    {
        //
        // Get the string length and make it become the new width if necessary
        //
        if (MenuInfo->MenuItemList[i])
        {
            Length = (ULONG)strlen(MenuInfo->MenuItemList[i]);
            if (Length > Width) Width = Length;
        }
    }

    //
    // Allow room for left & right borders, plus 8 spaces on each side
    //
    Width += 18;

    //
    // Check if we're drawing a centered menu
    //
    if (UiCenterMenu)
    {
        //
        // Calculate the menu box area for a centered menu
        //
        MenuInfo->Left = (UiScreenWidth - Width) / 2;
        MenuInfo->Top = (((UiScreenHeight - TUI_TITLE_BOX_CHAR_HEIGHT) -
                          Height) / 2) + TUI_TITLE_BOX_CHAR_HEIGHT;
    }
    else
    {
        //
        // Put the menu in the default left-corner position
        //
        MenuInfo->Left = -1;
        MenuInfo->Top = 4;
    }

    //
    // The other margins are the same
    //
    MenuInfo->Right = (MenuInfo->Left) + Width;
    MenuInfo->Bottom = (MenuInfo->Top) + Height;
}

Referenced by TuiDisplayMenu().

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 17 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's 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;

        //
        // Update the date & time
        //
        TuiUpdateDateTime();
        VideoCopyOffScreenBufferToVRAM();

        //
        // Check if there is a countdown
        //
        if (MenuInformation.MenuTimeRemaining > 0)
        {
            //
            // Get the updated time, seconds only
            //
            CurrentClockSecond = ArcGetTime()->Second;

            //
            // Check if more then a second has now elapsed
            //
            if (CurrentClockSecond != LastClockSecond)
            {
                //
                // Update the time information
                //
                LastClockSecond = CurrentClockSecond;
                MenuInformation.MenuTimeRemaining--;

                //
                // Update the menu
                //
                TuiDrawMenuBox(&MenuInformation);
                VideoCopyOffScreenBufferToVRAM();
            }
        }
        else if (MenuInformation.MenuTimeRemaining == 0)
        {
            //
            // A time out occurred, exit this loop and return default OS
            //
            break;
        }

        MachHwIdle();
    }

    //
    // Return the selected item
    //
    if (SelectedMenuItem) *SelectedMenuItem = MenuInformation.SelectedMenuItem;
    return TRUE;
}

TuiDrawBackdrop()

VOID TuiDrawBackdrop

(

VOID

)

Definition at line 83 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	(	ULONG	Left,
		ULONG	Top,
		ULONG	Right,
		ULONG	Bottom,
		UCHAR	VertStyle,
		UCHAR	HorzStyle,
		BOOLEAN	Fill,
		BOOLEAN	Shadow,
		UCHAR	Attr
	)

Definition at line 248 of file tui.c.

{
    UCHAR    ULCorner, URCorner, LLCorner, LRCorner;

    // Calculate the corner values
    if (HorzStyle == HORZ)
    {
        if (VertStyle == VERT)
        {
            ULCorner = UL;
            URCorner = UR;
            LLCorner = LL;
            LRCorner = LR;
        }
        else // VertStyle == D_VERT
        {
            ULCorner = VD_UL;
            URCorner = VD_UR;
            LLCorner = VD_LL;
            LRCorner = VD_LR;
        }
    }
    else // HorzStyle == D_HORZ
    {
        if (VertStyle == VERT)
        {
            ULCorner = HD_UL;
            URCorner = HD_UR;
            LLCorner = HD_LL;
            LRCorner = HD_LR;
        }
        else // VertStyle == D_VERT
        {
            ULCorner = D_UL;
            URCorner = D_UR;
            LLCorner = D_LL;
            LRCorner = D_LR;
        }
    }

    // Fill in box background
    if (Fill)
    {
        TuiFillArea(Left, Top, Right, Bottom, ' ', Attr);
    }

    // Fill in corners
    TuiFillArea(Left, Top, Left, Top, ULCorner, Attr);
    TuiFillArea(Right, Top, Right, Top, URCorner, Attr);
    TuiFillArea(Left, Bottom, Left, Bottom, LLCorner, Attr);
    TuiFillArea(Right, Bottom, Right, Bottom, LRCorner, Attr);

    // Fill in left line
    TuiFillArea(Left, Top+1, Left, Bottom-1, VertStyle, Attr);
    // Fill in top line
    TuiFillArea(Left+1, Top, Right-1, Top, HorzStyle, Attr);
    // Fill in right line
    TuiFillArea(Right, Top+1, Right, Bottom-1, VertStyle, Attr);
    // Fill in bottom line
    TuiFillArea(Left+1, Bottom, Right-1, Bottom, HorzStyle, Attr);

    // Draw the shadow
    if (Shadow)
    {
        TuiDrawShadow(Left, Top, Right, Bottom);
    }
}

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

TuiDrawCenteredText()

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

Definition at line 352 of file tui.c.

{
    SIZE_T    TextLength;
    ULONG    BoxWidth;
    ULONG    BoxHeight;
    ULONG    LineBreakCount;
    SIZE_T    Index;
    SIZE_T    LastIndex;
    ULONG    RealLeft;
    ULONG    RealTop;
    ULONG    X;
    ULONG    Y;
    CHAR    Temp[2];

    TextLength = strlen(TextString);

    // Count the new lines and the box width
    LineBreakCount = 0;
    BoxWidth = 0;
    LastIndex = 0;
    for (Index=0; Index<TextLength; Index++)
    {
        if (TextString[Index] == '\n')
        {
            LastIndex = Index;
            LineBreakCount++;
        }
        else
        {
            if ((Index - LastIndex) > BoxWidth)
            {
                BoxWidth = (ULONG)(Index - LastIndex);
            }
        }
    }

    BoxHeight = LineBreakCount + 1;

    RealLeft = (((Right - Left) - BoxWidth) / 2) + Left;
    RealTop = (((Bottom - Top) - BoxHeight) / 2) + Top;

    LastIndex = 0;
    for (Index=0; Index<TextLength; Index++)
    {
        if (TextString[Index] == '\n')
        {
            RealTop++;
            LastIndex = 0;
        }
        else
        {
            X = (ULONG)(RealLeft + LastIndex);
            Y = RealTop;
            LastIndex++;
            Temp[0] = TextString[Index];
            Temp[1] = 0;
            TuiDrawText(X, Y, Temp, Attr);
        }
    }
}

Referenced by MiniTuiDrawProgressBar(), and TuiDrawProgressBar().

TuiDrawMenu()

VOID TuiDrawMenu

(

PUI_MENU_INFO

MenuInfo

)

Definition at line 233 of file tuimenu.c.

{
    ULONG i;

    //
    // Draw the backdrop
    //
    UiDrawBackdrop();

    //
    // Update the status bar
    //
    UiVtbl.DrawStatusText("Use \x18 and \x19 to select, then press ENTER.");

    //
    // Draw the menu box
    //
    TuiDrawMenuBox(MenuInfo);

    //
    // Draw each line of the menu
    //
    for (i = 0; i < MenuInfo->MenuItemCount; i++)
    {
        TuiDrawMenuItem(MenuInfo, i);
    }

    /* Display the boot options if needed */
    if (MenuInfo->ShowBootOptions)
    {
        DisplayBootTimeOptions();
    }

    VideoCopyOffScreenBufferToVRAM();
}

TuiDrawMenuBox()

VOID TuiDrawMenuBox

(

PUI_MENU_INFO

MenuInfo

)

Definition at line 270 of file tuimenu.c.

{
    CHAR MenuLineText[80], TempString[80];
    ULONG i;

    //
    // 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));
    }

    //
    // If there is a timeout draw the time remaining
    //
    if (MenuInfo->MenuTimeRemaining >= 0)
    {
        //
        // Copy the integral time text string, and remove the last 2 chars
        //
        strcpy(TempString, UiTimeText);
        i = (ULONG)strlen(TempString);
        TempString[i - 2] = 0;

        //
        // Display the first part of the string and the remaining time
        //
        strcpy(MenuLineText, TempString);
        _itoa(MenuInfo->MenuTimeRemaining, TempString, 10);
        strcat(MenuLineText, TempString);

        //
        // Add the last 2 chars
        //
        strcat(MenuLineText, &UiTimeText[i - 2]);

        //
        // Check if this is a centered menu
        //
        if (UiCenterMenu)
        {
            //
            // Display it in the center of the menu
            //
            UiDrawText(MenuInfo->Right - (ULONG)strlen(MenuLineText) - 1,
                       MenuInfo->Bottom,
                       MenuLineText,
                       ATTR(UiMenuFgColor, UiMenuBgColor));
        }
        else
        {
            //
            // Display under the menu directly
            //
            UiDrawText(0,
                       MenuInfo->Bottom + 4,
                       MenuLineText,
                       ATTR(UiMenuFgColor, UiMenuBgColor));
        }
    }
    else
    {
        //
        // Erase the timeout string with spaces, and 0-terminate for sure
        //
        for (i=0; i<sizeof(MenuLineText)-1; i++)
        {
            MenuLineText[i] = ' ';
        }
        MenuLineText[sizeof(MenuLineText)-1] = 0;

        //
        // Draw this "empty" string to erase
        //
        if (UiCenterMenu)
        {
            UiDrawText(MenuInfo->Right - (ULONG)strlen(MenuLineText) - 1,
                       MenuInfo->Bottom,
                       MenuLineText,
                       ATTR(UiMenuFgColor, UiMenuBgColor));
        }
        else
        {
            UiDrawText(0,
                       MenuInfo->Bottom + 4,
                       MenuLineText,
                       ATTR(UiMenuFgColor, UiMenuBgColor));
        }
    }

    //
    // Loop each item
    //
    for (i = 0; i < MenuInfo->MenuItemCount; i++)
    {
        //
        // Check if it's a separator
        //
        if (MenuInfo->MenuItemList[i] == NULL)
        {
            //
            // Draw the separator line
            //
            UiDrawText(MenuInfo->Left,
                       MenuInfo->Top + i + 1,
                       "\xC7",
                       ATTR(UiMenuFgColor, UiMenuBgColor));
            UiDrawText(MenuInfo->Right,
                       MenuInfo->Top + i + 1,
                       "\xB6",
                       ATTR(UiMenuFgColor, UiMenuBgColor));
        }
    }
}

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

TuiDrawMenuItem()

VOID TuiDrawMenuItem	(	PUI_MENU_INFO	MenuInfo,
		ULONG	MenuItemNumber
	)

Definition at line 395 of file tuimenu.c.

{
    ULONG i;
    CHAR MenuLineText[80];
    ULONG SpaceTotal;
    ULONG SpaceLeft;
    ULONG SpaceRight = 0;
    UCHAR Attribute = ATTR(UiTextColor, UiMenuBgColor);

    //
    // 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
        //
        SpaceTotal = (MenuInfo->Right - MenuInfo->Left - 2) -
                     (ULONG)(MenuInfo->MenuItemList[MenuItemNumber] ?
                             strlen(MenuInfo->MenuItemList[MenuItemNumber]) : 0);
        SpaceLeft = (SpaceTotal / 2) + 1;
        SpaceRight = (SpaceTotal - SpaceLeft) + 1;

        //
        // Insert the spaces on the left
        //
        for (i = 0; i < SpaceLeft; i++) MenuLineText[i] = ' ';
        MenuLineText[i] = '\0';
    }
    else
    {
        //
        // Simply left-align it
        //
        MenuLineText[0] = '\0';
        strcat(MenuLineText, "    ");
    }

    //
    // Now append the text string
    //
    if (MenuInfo->MenuItemList[MenuItemNumber])
        strcat(MenuLineText, MenuInfo->MenuItemList[MenuItemNumber]);

    //
    // Check if using centered menu, and add spaces on the right if so
    //
    if (UiCenterMenu) for (i=0; i < SpaceRight; i++) strcat(MenuLineText, " ");

    //
    // If it is a separator
    //
    if (MenuInfo->MenuItemList[MenuItemNumber] == NULL)
    {
        //
        // Make it a separator line and use menu colors
        //
        memset(MenuLineText, 0, 80);
        memset(MenuLineText, 0xC4, (MenuInfo->Right - MenuInfo->Left - 1));
        Attribute = ATTR(UiMenuFgColor, UiMenuBgColor);
    }
    else if (MenuItemNumber == MenuInfo->SelectedMenuItem)
    {
        //
        // If this is the selected item, use the selected colors
        //
        Attribute = ATTR(UiSelectedTextColor, UiSelectedTextBgColor);
    }

    //
    // Draw the item
    //
    UiDrawText(MenuInfo->Left + 1,
               MenuInfo->Top + 1 + MenuItemNumber,
               MenuLineText,
               Attribute);
}

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

TuiDrawProgressBar()

VOID TuiDrawProgressBar	(	ULONG	Left,
		ULONG	Top,
		ULONG	Right,
		ULONG	Bottom,
		ULONG	Position,
		ULONG	Range,
		PCHAR	ProgressText
	)

Definition at line 663 of file tui.c.

{
    ULONG    i;
    ULONG    ProgressBarWidth = (Right - Left) - 3;

    // First make sure the progress bar text fits
    UiTruncateStringEllipsis(ProgressText, ProgressBarWidth - 4);

    if (Position > Range)
    {
        Position = Range;
    }

    // Draw the box
    TuiDrawBox(Left, Top, Right, Bottom, VERT, HORZ, TRUE, TRUE, ATTR(UiMenuFgColor, UiMenuBgColor));

    //
    //  Draw the "Loading..." text
    //
    TuiDrawCenteredText(Left + 2, Top + 2, Right - 2, Top + 2, ProgressText, ATTR(UiTextColor, UiMenuBgColor));

    // Draw the percent complete
    for (i=0; i<(Position*ProgressBarWidth)/Range; i++)
    {
        TuiDrawText(Left+2+i, Top+2, "\xDB", ATTR(UiTextColor, UiMenuBgColor));
    }

    // Draw the shadow
    for (; i<ProgressBarWidth; i++)
    {
        TuiDrawText(Left+2+i, Top+2, "\xB2", ATTR(UiTextColor, UiMenuBgColor));
    }

    TuiUpdateDateTime();
    VideoCopyOffScreenBufferToVRAM();
}

Referenced by TuiDrawProgressBarCenter().

TuiDrawProgressBarCenter()

VOID TuiDrawProgressBarCenter	(	ULONG	Position,
		ULONG	Range,
		PCHAR	ProgressText
	)

Definition at line 648 of file tui.c.

{
    ULONG    Left, Top, Right, Bottom;
    ULONG    Width = 50; // Allow for 50 "bars"
    ULONG    Height = 2;

    Left = (UiScreenWidth - Width - 4) / 2;
    Right = Left + Width + 3;
    Top = (UiScreenHeight - Height - 2) / 2;
    Top += 2;
    Bottom = Top + Height + 1;

    TuiDrawProgressBar(Left, Top, Right, Bottom, Position, Range, ProgressText);
}

TuiDrawShadow()

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

Definition at line 188 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 413 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	(	ULONG	X,
		ULONG	Y,
		PCSTR	Text,
		UCHAR	Attr
	)

Definition at line 320 of file tui.c.

{
    PUCHAR    ScreenMemory = (PUCHAR)TextVideoBuffer;
    ULONG    i, j;

    // Draw the text
    for (i = X, j = 0; Text[j] && i < UiScreenWidth; i++, j++)
    {
        ScreenMemory[((Y*2)*UiScreenWidth)+(i*2)] = (UCHAR)Text[j];
        ScreenMemory[((Y*2)*UiScreenWidth)+(i*2)+1] = Attr;
    }
}

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

TuiDrawText2()

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

Definition at line 339 of file tui.c.

{
    PUCHAR    ScreenMemory = (PUCHAR)TextVideoBuffer;
    ULONG    i, j;

    // Draw the text
    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;
    }
}

TuiEditBox()

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

Definition at line 815 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 759 of file tui.c.

{
    PPALETTE_ENTRY TuiFadePalette = NULL;

    if (UiUseSpecialEffects && ! MachVideoIsPaletteFixed())
    {
        TuiFadePalette = (PPALETTE_ENTRY)FrLdrTempAlloc(sizeof(PALETTE_ENTRY) * 64,
                                                        TAG_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_TAG_TUI_PALETTE);
    }
}

TuiFadeOut()

VOID TuiFadeOut

(

VOID

)

Definition at line 785 of file tui.c.

{
    PPALETTE_ENTRY TuiFadePalette = NULL;

    if (UiUseSpecialEffects && ! MachVideoIsPaletteFixed())
    {
        TuiFadePalette = (PPALETTE_ENTRY)FrLdrTempAlloc(sizeof(PALETTE_ENTRY) * 64,
                                                        TAG_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_TAG_TUI_PALETTE);
    }

}

Referenced by TuiUnInitialize().

TuiFillArea()

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

Definition at line 153 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 fill it in
    for (i=Top; i<=Bottom; i++)
    {
        // Loop through each character (column) in the line and fill it in
        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(), TuiDrawBackdrop(), and TuiDrawBox().

TuiInitialize()

BOOLEAN TuiInitialize

(

VOID

)

Definition at line 52 of file tui.c.

{
    MachVideoHideShowTextCursor(FALSE);
    MachVideoSetTextCursorPosition(0, 0);
    MachVideoClearScreen(ATTR(COLOR_GRAY, COLOR_BLACK));

    TextVideoBuffer = VideoAllocateOffScreenBuffer();
    if (TextVideoBuffer == NULL)
    {
        return FALSE;
    }

    return TRUE;
}

TuiMessageBox()

VOID TuiMessageBox

(

PCSTR

MessageText

)

Definition at line 545 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 562 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	(	const char *	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 = sizeof(Buffer);

    for (i = 0; i < Length; i++)
    {
        MachConsPutChar(Buffer[i]);
    }

    return Length;
}

Referenced by MachInit().

TuiProcessMenuKeyboardEvent()

ULONG TuiProcessMenuKeyboardEvent	(	PUI_MENU_INFO	MenuInfo,
		UiMenuKeyPressFilterCallback	KeyPressFilter
	)

Definition at line 476 of file tuimenu.c.

{
    ULONG KeyEvent = 0;
    ULONG Selected, Count;

    //
    // Check for a keypress
    //
    if (!MachConsKbHit())
        return 0; // None, bail out

    //
    // Check if the timeout is not already complete
    //
    if (MenuInfo->MenuTimeRemaining != -1)
    {
        //
        // Cancel it and remove it
        //
        MenuInfo->MenuTimeRemaining = -1;
        TuiDrawMenuBox(MenuInfo); // FIXME: Remove for minimal UI too
    }

    //
    // Get the key (get the extended key if needed)
    //
    KeyEvent = MachConsGetCh();
    if (KeyEvent == KEY_EXTENDED)
        KeyEvent = MachConsGetCh();

    //
    // Call the supplied key filter callback function to see
    // if it is going to handle this keypress.
    //
    if (KeyPressFilter &&
        KeyPressFilter(KeyEvent, MenuInfo->SelectedMenuItem, MenuInfo->Context))
    {
        //
        // It processed the key character, so redraw and exit
        //
        UiVtbl.DrawMenu(MenuInfo);
        return 0;
    }

    //
    // Process the key
    //
    if ((KeyEvent == KEY_UP  ) || (KeyEvent == KEY_DOWN) ||
        (KeyEvent == KEY_HOME) || (KeyEvent == KEY_END ))
    {
        //
        // Get the current selected item and count
        //
        Selected = MenuInfo->SelectedMenuItem;
        Count = MenuInfo->MenuItemCount - 1;

        //
        // Check the key and change the selected menu item
        //
        if ((KeyEvent == KEY_UP) && (Selected > 0))
        {
            //
            // Deselect previous item and go up
            //
            MenuInfo->SelectedMenuItem--;
            TuiDrawMenuItem(MenuInfo, Selected);
            Selected--;

            // Skip past any separators
            if ((Selected > 0) &&
                (MenuInfo->MenuItemList[Selected] == NULL))
            {
                MenuInfo->SelectedMenuItem--;
            }
        }
        else if ( ((KeyEvent == KEY_UP) && (Selected == 0)) ||
                   (KeyEvent == KEY_END) )
        {
            //
            // Go to the end
            //
            MenuInfo->SelectedMenuItem = Count;
            TuiDrawMenuItem(MenuInfo, Selected);
        }
        else if ((KeyEvent == KEY_DOWN) && (Selected < Count))
        {
            //
            // Deselect previous item and go down
            //
            MenuInfo->SelectedMenuItem++;
            TuiDrawMenuItem(MenuInfo, Selected);
            Selected++;

            // Skip past any separators
            if ((Selected < Count) &&
                (MenuInfo->MenuItemList[Selected] == NULL))
            {
                MenuInfo->SelectedMenuItem++;
            }
        }
        else if ( ((KeyEvent == KEY_DOWN) && (Selected == Count)) ||
                   (KeyEvent == KEY_HOME) )
        {
            //
            // Go to the beginning
            //
            MenuInfo->SelectedMenuItem = 0;
            TuiDrawMenuItem(MenuInfo, Selected);
        }

        //
        // Select new item and update video buffer
        //
        TuiDrawMenuItem(MenuInfo, MenuInfo->SelectedMenuItem);
        VideoCopyOffScreenBufferToVRAM();
    }

    //
    // Return the pressed key
    //
    return KeyEvent;
}

Referenced by TuiDisplayMenu().

TuiRestoreScreen()

VOID TuiRestoreScreen

(

PUCHAR

Buffer

)

Definition at line 534 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 523 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 700 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;

    for (i = 0; i < sizeof(Colors)/sizeof(Colors[0]); ++i)
    {
        if (_stricmp(ColorText, Colors[i].ColorName) == 0)
            return Colors[i].ColorValue;
    }

    return COLOR_BLACK;
}

TuiTextToFillStyle()

UCHAR TuiTextToFillStyle

(

PCSTR

FillStyleText

)

Definition at line 736 of file tui.c.

{
    static const struct
    {
        PCSTR FillStyleName;
        UCHAR FillStyleValue;
    } FillStyles[] =
    {
        {"Light" , LIGHT_FILL },
        {"Medium", MEDIUM_FILL},
        {"Dark"  , DARK_FILL  },
    };
    ULONG i;

    for (i = 0; i < sizeof(FillStyles)/sizeof(FillStyles[0]); ++i)
    {
        if (_stricmp(FillStyleText, FillStyles[i].FillStyleName) == 0)
            return FillStyles[i].FillStyleValue;
    }

    return LIGHT_FILL;
}

TuiUnInitialize()

VOID TuiUnInitialize

(

VOID

)

Definition at line 67 of file tui.c.

{
    if (UiUseSpecialEffects)
    {
        TuiFadeOut();
    }
    else
    {
        MachVideoSetDisplayMode(NULL, FALSE);
    }

    MachVideoClearScreen(ATTR(COLOR_GRAY, COLOR_BLACK));
    MachVideoSetTextCursorPosition(0, 0);
    MachVideoHideShowTextCursor(TRUE);
}

TuiUpdateDateTime()

VOID TuiUpdateDateTime

(

VOID

)

Definition at line 428 of file tui.c.

{
    TIMEINFO*    TimeInfo;
    char    DateString[40];
    CHAR    TimeString[40];
    CHAR    TempString[20];
    BOOLEAN    PMHour = FALSE;

    /* Don't draw the time if this has been disabled */
    if (!UiDrawTime) return;

    TimeInfo = ArcGetTime();
    if (TimeInfo->Year < 1 || 9999 < TimeInfo->Year ||
        TimeInfo->Month < 1 || 12 < TimeInfo->Month ||
        TimeInfo->Day < 1 || 31 < TimeInfo->Day ||
        23 < TimeInfo->Hour ||
        59 < TimeInfo->Minute ||
        59 < TimeInfo->Second)
    {
        /* This happens on QEmu sometimes. We just skip updating */
        return;
    }
    // Get the month name
    strcpy(DateString, UiMonthNames[TimeInfo->Month - 1]);
    // Get the day
    _itoa(TimeInfo->Day, TempString, 10);
    // Get the day postfix
    if (1 == TimeInfo->Day || 21 == TimeInfo->Day || 31 == TimeInfo->Day)
    {
        strcat(TempString, "st");
    }
    else if (2 == TimeInfo->Day || 22 == TimeInfo->Day)
    {
        strcat(TempString, "nd");
    }
    else if (3 == TimeInfo->Day || 23 == TimeInfo->Day)
    {
        strcat(TempString, "rd");
    }
    else
    {
        strcat(TempString, "th");
    }

    // Add the day to the date
    strcat(DateString, TempString);
    strcat(DateString, " ");

    // Get the year and add it to the date
    _itoa(TimeInfo->Year, TempString, 10);
    strcat(DateString, TempString);

    // Draw the date
    TuiDrawText(UiScreenWidth-(ULONG)strlen(DateString)-2, 1, DateString, ATTR(UiTitleBoxFgColor, UiTitleBoxBgColor));

    // Get the hour and change from 24-hour mode to 12-hour
    if (TimeInfo->Hour > 12)
    {
        TimeInfo->Hour -= 12;
        PMHour = TRUE;
    }
    if (TimeInfo->Hour == 0)
    {
        TimeInfo->Hour = 12;
    }
    _itoa(TimeInfo->Hour, TempString, 10);
    strcpy(TimeString, "    ");
    strcat(TimeString, TempString);
    strcat(TimeString, ":");
    _itoa(TimeInfo->Minute, TempString, 10);
    if (TimeInfo->Minute < 10)
    {
        strcat(TimeString, "0");
    }
    strcat(TimeString, TempString);
    strcat(TimeString, ":");
    _itoa(TimeInfo->Second, TempString, 10);
    if (TimeInfo->Second < 10)
    {
        strcat(TimeString, "0");
    }
    strcat(TimeString, TempString);
    if (PMHour)
    {
        strcat(TimeString, " PM");
    }
    else
    {
        strcat(TimeString, " AM");
    }

    // Draw the time
    TuiDrawText(UiScreenWidth-(ULONG)strlen(TimeString)-2, 2, TimeString, ATTR(UiTitleBoxFgColor, UiTitleBoxBgColor));
}

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

Variable Documentation

TuiVtbl

const UIVTBL TuiVtbl

Definition at line 1048 of file tui.c.

Referenced by UiInitialize().