#include "usetup.h"
#include "muilanguages.h"
#include <debug.h>

Include dependency graph for mui.c:

Macros
#define	NDEBUG

Functions
static ULONG	FindLanguageIndex (VOID)

static const MUI_ENTRY *	FindMUIEntriesOfPage (IN ULONG PageNumber)

static const MUI_ERROR *	FindMUIErrorEntries (VOID)

static const MUI_STRING *	FindMUIStringEntries (VOID)

VOID	MUIClearPage (IN ULONG page)

VOID	MUIDisplayPage (IN ULONG page)

VOID	MUIDisplayErrorV (IN ULONG ErrorNum, OUT PINPUT_RECORD Ir, IN ULONG WaitEvent, IN va_list args)

VOID __cdecl	MUIDisplayError (IN ULONG ErrorNum, OUT PINPUT_RECORD Ir, IN ULONG WaitEvent,...)

PCSTR	MUIGetString (ULONG Number)

const MUI_ENTRY *	MUIGetEntry (IN ULONG Page, IN INT TextID)

VOID	MUIClearText (IN ULONG Page, IN INT TextID)

VOID	MUIClearStyledText (IN ULONG Page, IN INT TextID, IN INT Flags)

VOID	MUISetText (IN ULONG Page, IN INT TextID)

VOID	MUISetStyledText (IN ULONG Page, IN INT TextID, IN INT Flags)

VOID	SetConsoleCodePage (VOID)

Variables
CHAR	CharBullet = 0x07

CHAR	CharBlock = 0xDB

CHAR	CharHalfBlock = 0xDD

CHAR	CharUpArrow = 0x18

CHAR	CharDownArrow = 0x19

CHAR	CharHorizontalLine = 0xC4

CHAR	CharVerticalLine = 0xB3

CHAR	CharUpperLeftCorner = 0xDA

CHAR	CharUpperRightCorner = 0xBF

CHAR	CharLowerLeftCorner = 0xC0

CHAR	CharLowerRightCorner = 0xD9

CHAR	CharVertLineAndRightHorizLine = 0xC3

CHAR	CharLeftHorizLineAndVertLine = 0xB4

CHAR	CharDoubleHorizontalLine = 0xCD

CHAR	CharDoubleVerticalLine = 0xBA

CHAR	CharDoubleUpperLeftCorner = 0xC9

CHAR	CharDoubleUpperRightCorner = 0xBB

CHAR	CharDoubleLowerLeftCorner = 0xC8

CHAR	CharDoubleLowerRightCorner = 0xBC

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 30 of file mui.c.

Function Documentation

◆ FindLanguageIndex()

static ULONG FindLanguageIndex ( VOID )

static

Definition at line 56 of file mui.c.

{
    ULONG lngIndex = 0;
 
    if (SelectedLanguageId == NULL)
    {
        /* Default to en-US */
        return 0;   // FIXME!!
        // SelectedLanguageId = L"00000409";
    }
 
    while (ResourceList[lngIndex].MuiPages != NULL)
    {
        if (_wcsicmp(ResourceList[lngIndex].LanguageID, SelectedLanguageId) == 0)
        {
            return lngIndex;
        }
 
        lngIndex++;
    }
 
    return 0;
}

◆ FindMUIEntriesOfPage()

static const MUI_ENTRY * FindMUIEntriesOfPage ( IN ULONG PageNumber )

static

Definition at line 103 of file mui.c.

{
    ULONG muiIndex = 0;
    ULONG lngIndex;
    const MUI_PAGE * Pages = NULL;
 
    lngIndex = max(FindLanguageIndex(), 0);
    Pages = ResourceList[lngIndex].MuiPages;
 
    while (Pages[muiIndex].MuiEntry != NULL)
    {
        if (Pages[muiIndex].Number == PageNumber)
            return Pages[muiIndex].MuiEntry;
 
        muiIndex++;
    }
 
    return NULL;
}

Referenced by MUIClearPage(), MUIDisplayPage(), and MUIGetEntry().

◆ FindMUIErrorEntries()

static const MUI_ERROR * FindMUIErrorEntries ( VOID )

static

Definition at line 126 of file mui.c.

{
    ULONG lngIndex = max(FindLanguageIndex(), 0);
    return ResourceList[lngIndex].MuiErrors;
}

Referenced by MUIDisplayErrorV().

◆ FindMUIStringEntries()

static const MUI_STRING * FindMUIStringEntries ( VOID )

static

Definition at line 134 of file mui.c.

{
    ULONG lngIndex = max(FindLanguageIndex(), 0);
    return ResourceList[lngIndex].MuiStrings;
}

Referenced by MUIGetString().

◆ MUIClearPage()

VOID MUIClearPage ( IN ULONG page )

Definition at line 142 of file mui.c.

{
    const MUI_ENTRY * entry;
    ULONG index;
 
    entry = FindMUIEntriesOfPage(page);
    if (!entry)
    {
        PopupError("Error: Failed to find translated page",
                   NULL,
                   NULL,
                   POPUP_WAIT_NONE);
        return;
    }
 
    index = 0;
    while (entry[index].Buffer != NULL)
    {
        CONSOLE_ClearStyledText(entry[index].X,
                                entry[index].Y,
                                entry[index].Flags,
                                (USHORT)strlen(entry[index].Buffer));
        index++;
    }
}

Referenced by LanguagePage().

◆ MUIClearStyledText()

VOID MUIClearStyledText	(	IN ULONG	Page,
		IN INT	TextID,
		IN INT	Flags
	)

@MUIClearStyledText

Clears a portion of text from the console output, given the actual state style flag of the text.

Parameters

[in]	Page	The MUI (Multilingual User Interface) entry page number, as a unsigned long integer.
[in]	TextID	The text identification number (ID), as an integer. The parameter is used to identify its MUI properties like the coordinates, text style flag and its buffer content.
[in]	Flags	The text style flag, as an integer. The flag determines the style of the text, such as being highlighted, underlined, high padding and so on.

Returns: Nothing.

Definition at line 399 of file mui.c.

{
    const MUI_ENTRY * entry;
    ULONG Index = 0;
 
    /* Get the MUI entry */
    entry = MUIGetEntry(Page, TextID);
 
    if (!entry)
        return;
 
    /* Ensure that the text string given by the text ID and page is not NULL */
    while (entry[Index].Buffer != NULL)
    {
        /* If text ID is not correct, skip the entry */
        if (entry[Index].TextID != TextID)
        {
            Index++;
            continue;
        }
 
        /* Now, begin removing the text by calling CONSOLE_ClearStyledText() */
        CONSOLE_ClearStyledText(
            entry[Index].X,
            entry[Index].Y,
            Flags,
            (USHORT)strlen(entry[Index].Buffer));
 
        /* Increment the index and loop over next entires with the same ID */
        Index++;
    }
}

Referenced by FormatPartitionPage().

◆ MUIClearText()

VOID MUIClearText	(	IN ULONG	Page,
		IN INT	TextID
	)

@MUIClearText

Clears a portion of text from the console output.

Parameters

[in]	Page	The MUI (Multilingual User Interface) entry page number, as a unsigned long integer.
[in]	TextID	The text identification number (ID), as an integer. The parameter is used to identify its MUI properties like the coordinates, text style flag and its buffer content.

Returns: Nothing.

Definition at line 344 of file mui.c.

{
    const MUI_ENTRY * entry;
    ULONG Index = 0;
 
    /* Get the MUI entry */
    entry = MUIGetEntry(Page, TextID);
 
    if (!entry)
        return;
 
    /* Ensure that the text string given by the text ID and page is not NULL */
    while (entry[Index].Buffer != NULL)
    {
        /* If text ID is not correct, skip the entry */
        if (entry[Index].TextID != TextID)
        {
            Index++;
            continue;
        }
 
        /* Remove the text by using CONSOLE_ClearTextXY() */
        CONSOLE_ClearTextXY(
            entry[Index].X,
            entry[Index].Y,
            (USHORT)strlen(entry[Index].Buffer));
 
        /* Increment the index and loop over next entires with the same ID */
        Index++;
    }
}

◆ MUIDisplayError()

VOID __cdecl MUIDisplayError	(	IN ULONG	ErrorNum,
		OUT PINPUT_RECORD	Ir,
		IN ULONG	WaitEvent,
			...
	)

Definition at line 237 of file mui.c.

{
    va_list arg_ptr;
 
    va_start(arg_ptr, WaitEvent);
    MUIDisplayErrorV(ErrorNum, Ir, WaitEvent, arg_ptr);
    va_end(arg_ptr);
}

Referenced by BootLoaderFloppyPage(), BootLoaderInstallationPage(), ConfirmQuit(), DeviceSettingsPage(), FormatPartitionPage(), InstallDirectoryPage(), RegistryPage(), SelectFileSystemPage(), SelectPartitionPage(), SetupStartPage(), and UpgradeRepairPage().

◆ MUIDisplayErrorV()

VOID MUIDisplayErrorV	(	IN ULONG	ErrorNum,
		OUT PINPUT_RECORD	Ir,
		IN ULONG	WaitEvent,
		IN va_list	args
	)

Definition at line 199 of file mui.c.

{
    const MUI_ERROR* entry;
    CHAR Buffer[2048];
 
    if (ErrorNum >= ERROR_LAST_ERROR_CODE)
    {
        PopupError("Invalid error number provided",
                   "Press ENTER to continue",
                   Ir,
                   POPUP_WAIT_ENTER);
        return;
    }
 
    entry = FindMUIErrorEntries();
    if (!entry)
    {
        PopupError("Error: Failed to find translated error message",
                   NULL,
                   NULL,
                   POPUP_WAIT_NONE);
        return;
    }
 
    vsprintf(Buffer, entry[ErrorNum].ErrorText, args);
 
    PopupError(Buffer,
               entry[ErrorNum].ErrorStatus,
               Ir,
               WaitEvent);
}

Referenced by MUIDisplayError(), and USetupErrorRoutine().

◆ MUIDisplayPage()

VOID MUIDisplayPage ( IN ULONG page )

Definition at line 170 of file mui.c.

{
    const MUI_ENTRY * entry;
    ULONG index;
 
    entry = FindMUIEntriesOfPage(page);
    if (!entry)
    {
        PopupError("Error: Failed to find translated page",
                   NULL,
                   NULL,
                   POPUP_WAIT_NONE);
        return;
    }
 
    index = 0;
    while (entry[index].Buffer != NULL)
    {
        CONSOLE_SetStyledText(entry[index].X,
                              entry[index].Y,
                              entry[index].Flags,
                              entry[index].Buffer);
 
        index++;
    }
}

Referenced by BootLoaderFloppyPage(), BootLoaderInstallationPage(), BootLoaderPage(), CheckFileSystemPage(), ComputerSettingsPage(), ConfirmDeleteSystemPartitionPage(), DeletePartitionPage(), DeviceSettingsPage(), DisplaySettingsPage(), FileCopyPage(), FlushPage(), FormatPartitionPage(), InstallDirectoryPage(), InstallIntroPage(), KeyboardSettingsPage(), LanguagePage(), LayoutSettingsPage(), LicensePage(), PrepareCopyPage(), QuitPage(), RegistryPage(), RepairIntroPage(), SelectFileSystemPage(), SelectPartitionPage(), SetupStartPage(), SuccessPage(), UpgradeRepairPage(), and WelcomePage().

◆ MUIGetEntry()

const MUI_ENTRY * MUIGetEntry	(	IN ULONG	Page,
		IN INT	TextID
	)

@MUIGetEntry

Retrieves a MUI entry of a page, given the page number and the text ID.

Parameters

[in]	Page	The MUI (Multilingual User Interface) entry page number, as a unsigned long integer.
[in]	TextID	The text identification number (ID), as a unsigned integer. The parameter is used to identify its MUI properties like the coordinates, text style flag and its buffer content.

Returns: Returns a constant MUI entry.

Definition at line 297 of file mui.c.

{
    const MUI_ENTRY * entry;
    ULONG index;
 
    /* Retrieve the entries of a MUI page */
    entry = FindMUIEntriesOfPage(Page);
    if (!entry)
    {
        DPRINT("MUIGetEntryData(): Failed to get the translated entry page!\n");
        return NULL;
    }
 
    /* Loop over the ID entries and check if it matches with one of them */
    for (index = 0; entry[index].Buffer != NULL; index++)
    {
        if (entry[index].TextID == TextID)
        {
            /* They match so return the MUI entry */
            return &entry[index];
        }
    }
 
    /* Page number or ID are incorrect so in this case bail out */
    DPRINT("Couldn't get the MUI entry field from the page!\n");
    return NULL;
}

Referenced by MUIClearStyledText(), MUIClearText(), MUISetStyledText(), and MUISetText().

◆ MUIGetString()

PCSTR MUIGetString ( ULONG Number )

Definition at line 251 of file mui.c.

{
    ULONG i;
    const MUI_STRING * entry;
    CHAR szErr[128];
 
    entry = FindMUIStringEntries();
    if (entry)
    {
        for (i = 0; entry[i].Number != 0; i++)
        {
            if (entry[i].Number == Number)
            {
                return entry[i].String;
            }
        }
    }
 
    sprintf(szErr, "Error: failed find string id %lu for language index %lu\n", Number, FindLanguageIndex());
 
    PopupError(szErr,
               NULL,
               NULL,
               POPUP_WAIT_NONE);
 
    return "<nostring>";
}

Referenced by BootLoaderPage(), CheckFileSystemPage(), CreateExtendedPartitionPage(), CreateLogicalPartitionPage(), CreatePrimaryPartitionPage(), DeletePartitionPage(), DiskDescription(), DoChkdsk(), DoFormat(), DrawFileSystemList(), FileCopyCallback(), FileCopyPage(), FormatPartitionPage(), GetPartitionTypeString(), PartitionDescription(), PrettifySize1(), PrettifySize2(), ProgressCountdown(), QuitPage(), RegistryPage(), RegistryStatus(), RunUSetup(), SelectFileSystemPage(), SelectPartitionPage(), and ShowPartitionSizeInputBox().

◆ MUISetStyledText()

VOID MUISetStyledText	(	IN ULONG	Page,
		IN INT	TextID,
		IN INT	Flags
	)

@MUISetStyledText

Prints a text to the console output, with a style for it.

Parameters

[in]	Page	The MUI (Multilingual User Interface) entry page number, as a unsigned long integer.
[in]	TextID	The text identification number (ID), as an integer. The parameter is used to identify its MUI properties like the coordinates, text style flag and its buffer content.
[in]	Flags	The text style flag, as an integer. The flag determines the style of the text, such as being highlighted, underlined, high padding and so on.

Returns: Nothing.

Definition at line 504 of file mui.c.

{
    const MUI_ENTRY * entry;
    ULONG Index = 0;
 
    /* Get the MUI entry */
    entry = MUIGetEntry(Page, TextID);
 
    if (!entry)
        return;
 
    /* Ensure that the text string given by the text ID and page is not NULL */
    while (entry[Index].Buffer != NULL)
    {
        /* If text ID is not correct, skip the entry */
        if (entry[Index].TextID != TextID)
        {
            Index++;
            continue;
        }
 
        /* Print the text to the console output by calling CONSOLE_SetStyledText() */
        CONSOLE_SetStyledText(entry[Index].X, entry[Index].Y, Flags, entry[Index].Buffer);
 
        /* Increment the index and loop over next entires with the same ID */
        Index++;
    }
}

◆ MUISetText()

VOID MUISetText	(	IN ULONG	Page,
		IN INT	TextID
	)

@MUISetText

Prints a text to the console output.

Parameters

[in]	Page	The MUI (Multilingual User Interface) entry page number, as a unsigned long integer.
[in]	TextID	The text identification number (ID), as an integer. The parameter is used to identify its MUI properties like the coordinates, text style flag and its buffer content.

Returns: Nothing.

Definition at line 452 of file mui.c.

{
    const MUI_ENTRY * entry;
    ULONG Index = 0;
 
    /* Get the MUI entry */
    entry = MUIGetEntry(Page, TextID);
 
    if (!entry)
        return;
 
    /* Ensure that the text string given by the text ID and page is not NULL */
    while (entry[Index].Buffer != NULL)
    {
        /* If text ID is not correct, skip the entry */
        if (entry[Index].TextID != TextID)
        {
            Index++;
            continue;
        }
 
        /* Print the text to the console output by calling CONSOLE_SetTextXY() */
        CONSOLE_SetTextXY(entry[Index].X, entry[Index].Y, entry[Index].Buffer);
 
        /* Increment the index and loop over next entires with the same ID */
        Index++;
    }
}

◆ SetConsoleCodePage()

VOID SetConsoleCodePage ( VOID )

Definition at line 537 of file mui.c.

{
    UINT wCodePage;
 
#if 0
    ULONG lngIndex = 0;
 
    while (ResourceList[lngIndex].MuiPages != NULL)
    {
        if (_wcsicmp(ResourceList[lngIndex].LanguageID, SelectedLanguageId) == 0)
        {
            wCodePage = (UINT) wcstoul(ResourceList[lngIndex].OEMCPage, NULL, 10);
            SetConsoleOutputCP(wCodePage);
            return;
        }
 
        lngIndex++;
    }
#else
    wCodePage = (UINT)wcstoul(MUIGetOEMCodePage(SelectedLanguageId), NULL, 10);
    SetConsoleOutputCP(wCodePage);
#endif
 
    switch (wCodePage)
    {
        case 28606: /* Romanian */
        case 932: /* Japanese */
            /* Set special characters */
            CharBullet = 0x07;
            CharBlock = 0x01;
            CharHalfBlock = 0x02;
            CharUpArrow = 0x03;
            CharDownArrow = 0x04;
            CharHorizontalLine = 0x05;
            CharVerticalLine = 0x06;
            CharUpperLeftCorner = 0x08;
            CharUpperRightCorner = 0x09;
            CharLowerLeftCorner = 0x0B;
            CharLowerRightCorner = 0x0C;
            CharVertLineAndRightHorizLine = 0x0E;
            CharLeftHorizLineAndVertLine = 0x0F;
            CharDoubleHorizontalLine = 0x10;
            CharDoubleVerticalLine = 0x11;
            CharDoubleUpperLeftCorner = 0x12;
            CharDoubleUpperRightCorner = 0x13;
            CharDoubleLowerLeftCorner = 0x14;
            CharDoubleLowerRightCorner = 0x15;
 
            /* FIXME: Enter 640x400 video mode */
            break;
 
        default: /* Other codepages */
            /* Set special characters */
            CharBullet = 0x07;
            CharBlock = 0xDB;
            CharHalfBlock = 0xDD;
            CharUpArrow = 0x18;
            CharDownArrow = 0x19;
            CharHorizontalLine = 0xC4;
            CharVerticalLine = 0xB3;
            CharUpperLeftCorner = 0xDA;
            CharUpperRightCorner = 0xBF;
            CharLowerLeftCorner = 0xC0;
            CharLowerRightCorner = 0xD9;
            CharVertLineAndRightHorizLine = 0xC3;
            CharLeftHorizLineAndVertLine = 0xB4;
            CharDoubleHorizontalLine = 0xCD;
            CharDoubleVerticalLine = 0xBA;
            CharDoubleUpperLeftCorner = 0xC9;
            CharDoubleUpperRightCorner = 0xBB;
            CharDoubleLowerLeftCorner = 0xC8;
            CharDoubleLowerRightCorner = 0xBC;
 
            /* FIXME: Enter 720x400 video mode */
            break;
    }
}