tuimenu.c

Go to the documentation of this file.

/*
 * COPYRIGHT:       See COPYING in the top level directory
 * PROJECT:         FreeLoader
 * FILE:            boot/freeldr/freeldr/ui/tuimenu.c
 * PURPOSE:         Text UI Menu Functions
 * PROGRAMMERS:     Alex Ionescu (alex@relsoft.net)
 *                  Brian Palmer (brianp@sginet.com)
 */
 
/* INCLUDES ******************************************************************/
 
#include <freeldr.h>
 
/* FUNCTIONS *****************************************************************/
 
static VOID
TuiCalcMenuBoxSize(
    _In_ PUI_MENU_INFO MenuInfo);
 
static ULONG
TuiProcessMenuKeyboardEvent(
    _In_ PUI_MENU_INFO MenuInfo,
    _In_ UiMenuKeyPressFilterCallback KeyPressFilter);
 
static VOID
TuiDrawMenuTimeout(
    _In_ PUI_MENU_INFO MenuInfo);
 
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)
{
    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 */
#ifdef _M_ARM
    UiDrawMenu(&MenuInformation);
#else
    UiVtbl.DrawMenu(&MenuInformation);
#endif
 
    /* 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;
 
#ifndef _M_ARM // FIXME: Theme-specific
            /* Update the date & time */
            TuiUpdateDateTime();
#endif
 
            /* 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 */
#ifndef _M_ARM
                VideoCopyOffScreenBufferToVRAM();
#endif
                break;
            }
#ifndef _M_ARM
            VideoCopyOffScreenBufferToVRAM();
#endif
        }
 
#ifndef _M_ARM
        MachHwIdle();
#endif
    }
 
    /* Return the selected item */
    if (SelectedMenuItem) *SelectedMenuItem = MenuInformation.SelectedMenuItem;
    return TRUE;
}
 
static VOID
TuiCalcMenuBoxSize(
    _In_ PUI_MENU_INFO MenuInfo)
{
    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;
 
#ifndef _M_ARM
    /* 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
#endif
    {
        /* 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;
}
 
VOID
TuiDrawMenu(
    _In_ PUI_MENU_INFO MenuInfo)
{
    ULONG i;
 
#ifndef _M_ARM // FIXME: Theme-specific
    /* Draw the backdrop */
    UiDrawBackdrop();
#else
 
    /* No GUI status bar text, just minimal text. Show the menu header. */
    if (MenuInfo->MenuHeader)
    {
        UiDrawText(0,
                   MenuInfo->Top - 2,
                   MenuInfo->MenuHeader,
                   ATTR(UiMenuFgColor, UiMenuBgColor));
    }
 
#endif
 
    /* Draw the menu box */
    TuiDrawMenuBox(MenuInfo);
 
    /* Draw each line of the menu */
    for (i = 0; i < MenuInfo->MenuItemCount; ++i)
    {
        TuiDrawMenuItem(MenuInfo, i);
    }
 
#ifndef _M_ARM // FIXME: Theme-specific
 
    /* Update the status bar */
    UiVtbl.DrawStatusText("Use \x18 and \x19 to select, then press ENTER.");
 
#else
 
    /* Now tell the user how to choose */
    UiDrawText(0,
               MenuInfo->Bottom + 1,
               "Use \x18 and \x19 to move the highlight to your choice.",
               ATTR(UiMenuFgColor, UiMenuBgColor));
    UiDrawText(0,
               MenuInfo->Bottom + 2,
               "Press ENTER to choose.",
               ATTR(UiMenuFgColor, UiMenuBgColor));
 
    /* And show the menu footer */
    if (MenuInfo->MenuFooter)
    {
        UiDrawText(0,
                   UiScreenHeight - 4,
                   MenuInfo->MenuFooter,
                   ATTR(UiMenuFgColor, UiMenuBgColor));
    }
 
#endif
 
    /* Display the boot options if needed */
    if (MenuInfo->ShowBootOptions)
    {
        DisplayBootTimeOptions();
    }
 
#ifndef _M_ARM
    VideoCopyOffScreenBufferToVRAM();
#endif
}
 
static VOID
TuiDrawMenuTimeout(
    _In_ PUI_MENU_INFO MenuInfo)
{
    ULONG Length;
    CHAR MenuLineText[80];
 
    /* If there is a timeout, draw the time remaining */
    if (MenuInfo->MenuTimeRemaining >= 0)
    {
        /* Find whether the time text string is escaped
         * with %d for specific countdown insertion. */
        PCHAR ptr = UiTimeText;
        while ((ptr = strchr(ptr, '%')) && (ptr[1] != 'd'))
        {
            /* Ignore any following character (including a following
             * '%' that would be escaped), thus skip two characters.
             * If this is the last character, ignore it and stop. */
            if (*++ptr)
                ++ptr;
        }
        ASSERT(!ptr || (ptr[0] == '%' && ptr[1] == 'd'));
 
        if (ptr)
        {
            /* Copy the time text string up to the '%d' insertion point and
             * skip it, add the remaining time and the rest of the string. */
            RtlStringCbPrintfA(MenuLineText, sizeof(MenuLineText),
                               "%.*s%d%s",
                               ptr - UiTimeText, UiTimeText,
                               MenuInfo->MenuTimeRemaining,
                               ptr + 2);
        }
        else
        {
            /* Copy the time text string, append a separating blank,
             * and add the remaining time. */
            RtlStringCbPrintfA(MenuLineText, sizeof(MenuLineText),
                               "%s %d",
                               UiTimeText,
                               MenuInfo->MenuTimeRemaining);
        }
 
        Length = (ULONG)strlen(MenuLineText);
    }
    else
    {
        /* Erase the timeout with blanks */
        Length = 0;
    }
 
#ifndef _M_ARM
    if (UiCenterMenu)
    {
        /* In boxed menu mode, pad on the left with blanks and box border,
         * otherwise, pad over all the box length until its right edge. */
        TuiFillArea(0,
                    MenuInfo->Bottom,
                    UiMenuBox
                        ? MenuInfo->Left - 1 /* Left side of the box bottom */
                        : MenuInfo->Right,   /* Left side + all box length  */
                    MenuInfo->Bottom,
                    UiBackdropFillStyle,
                    ATTR(UiBackdropFgColor, UiBackdropBgColor));
 
        if (UiMenuBox)
        {
            /* Fill with box bottom border */
            TuiDrawBoxBottomLine(MenuInfo->Left,
                                 MenuInfo->Bottom,
                                 MenuInfo->Right,
                                 D_VERT,
                                 D_HORZ,
                                 ATTR(UiMenuFgColor, UiMenuBgColor));
 
            /* In centered boxed menu mode, the timeout string
             * does not go past the right border, in principle... */
        }
 
        if (Length > 0)
        {
            /* Display the timeout at the bottom-right part of the menu */
            UiDrawText(MenuInfo->Right - Length - 1,
                       MenuInfo->Bottom,
                       MenuLineText,
                       ATTR(UiMenuFgColor, UiMenuBgColor));
        }
    }
    else
#endif
    {
        if (Length > 0)
        {
            /* Display the timeout under the menu directly */
            UiDrawText(0,
                       MenuInfo->Bottom + 4,
                       MenuLineText,
                       ATTR(UiMenuFgColor, UiMenuBgColor));
        }
 
        /* Pad on the right with blanks, to erase
         * characters when the string length decreases. */
        TuiFillArea(Length,
                    MenuInfo->Bottom + 4,
                    Length ? (Length + 1) : (UiScreenWidth - 1),
                    MenuInfo->Bottom + 4,
#ifndef _M_ARM
                    UiBackdropFillStyle,
                    ATTR(UiBackdropFgColor, UiBackdropBgColor)
#else
                    0, // ' '
                    ATTR(UiTextColor, COLOR_BLACK) // UiMenuBgColor
#endif
                    );
    }
}
 
VOID
TuiDrawMenuBox(
    _In_ PUI_MENU_INFO MenuInfo)
{
#ifndef _M_ARM // 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();
#endif
 
    TuiDrawMenuTimeout(MenuInfo);
}
 
VOID
TuiDrawMenuItem(
    _In_ PUI_MENU_INFO MenuInfo,
    _In_ ULONG MenuItemNumber)
{
    ULONG SpaceLeft;
    ULONG SpaceRight;
    UCHAR Attribute;
    CHAR MenuLineText[80];
 
    /* If this is a separator */
    if (MenuInfo->MenuItemList[MenuItemNumber] == NULL)
    {
#ifndef _M_ARM // FIXME: Theme-specific
        /* Draw its left box corner */
        if (UiMenuBox)
        {
            UiDrawText(MenuInfo->Left,
                       MenuInfo->Top + 1 + MenuItemNumber,
                       "\xC7",
                       ATTR(UiMenuFgColor, UiMenuBgColor));
        }
#endif
 
        /* 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));
 
#ifndef _M_ARM // FIXME: Theme-specific
        /* Draw its right box corner */
        if (UiMenuBox)
        {
            UiDrawText(MenuInfo->Right,
                       MenuInfo->Top + 1 + MenuItemNumber,
                       "\xB6",
                       ATTR(UiMenuFgColor, UiMenuBgColor));
        }
#endif
 
        /* We are done */
        return;
    }
 
    /* This is not a separator */
    ASSERT(MenuInfo->MenuItemList[MenuItemNumber]);
 
#ifndef _M_ARM
    /* 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
#endif
    {
        /* 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);
}
 
static ULONG
TuiProcessMenuKeyboardEvent(
    _In_ PUI_MENU_INFO MenuInfo,
    _In_ UiMenuKeyPressFilterCallback KeyPressFilter)
{
    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;
        TuiDrawMenuTimeout(MenuInfo);
    }
 
    /* 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 */
#ifdef _M_ARM
        UiDrawMenu(MenuInfo);
#else
        UiVtbl.DrawMenu(MenuInfo);
#endif
        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);
#ifndef _M_ARM
        VideoCopyOffScreenBufferToVRAM();
#endif
    }
 
    /* Return the pressed key */
    return KeyEvent;
}