livecd.c File Reference

#include "userinit.h"

Include dependency graph for livecd.c:

Go to the source code of this file.

Classes
struct	_LIVECD_UNATTEND

Typedefs
typedef struct _LIVECD_UNATTEND	LIVECD_UNATTEND

Functions
static VOID	InitLogo (PIMGINFO pImgInfo, HWND hwndDlg)
BOOL	IsMiniNT (VOID)
	Check whether we are running in MiniNT mode (e.g. live medium).
static BOOL CALLBACK	LocalesEnumProc (LPTSTR lpLocale)
static VOID	CreateLanguagesList (HWND hwnd, PSTATE pState)
static BOOL	GetLayoutName (_In_ PCWSTR pszKLID, _Out_writes_z_(NameSize) PWSTR pszName, _In_ SIZE_T NameSize)
static VOID	SetKeyboardLayout (HWND hwnd)
static VOID	SelectKeyboardForLanguage (HWND hwnd, LCID lcid)
static VOID	CreateKeyboardLayoutList (HWND hItemsList)
static VOID	InitializeDefaultUserLocale (PLCID pNewLcid)
VOID	CenterWindow (HWND hWnd)
static VOID	OnDrawItem (LPDRAWITEMSTRUCT lpDrawItem, PSTATE pState, UINT uCtlID)
static INT_PTR CALLBACK	LocaleDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
static INT_PTR CALLBACK	StartDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
static VOID	ParseUnattend (_In_ LPCWSTR UnattendInf, _Out_ LIVECD_UNATTEND *pUnattend)
static BOOL	ExpandInstallerPath (_In_ PCWSTR pInstallerName, _Out_writes_z_(PathSize) PWSTR pInstallerPath, _In_ SIZE_T PathSize)
	Expands the path for the ReactOS Installer "reactos.exe". See also base/setup/welcome/welcome.c!ExpandInstallerPath()
VOID	RunLiveCD (PSTATE pState)

Variables
HWND	hList
HWND	hLocaleList
BOOL	bSpain = FALSE
WCHAR	Installer [MAX_PATH]

Typedef Documentation

LIVECD_UNATTEND

typedef struct _LIVECD_UNATTEND LIVECD_UNATTEND

Function Documentation

CenterWindow()

VOID CenterWindow

(

HWND

hWnd

)

Definition at line 520 of file livecd.c.

{
    HWND hWndParent;
    RECT rcParent;
    RECT rcWindow;
 
    hWndParent = GetParent(hWnd);
    if (hWndParent == NULL)
        hWndParent = GetDesktopWindow();
 
    GetWindowRect(hWndParent, &rcParent);
    GetWindowRect(hWnd, &rcWindow);
 
    SetWindowPos(hWnd,
                 HWND_TOP,
                 ((rcParent.right - rcParent.left) - (rcWindow.right - rcWindow.left)) / 2,
                 ((rcParent.bottom - rcParent.top) - (rcWindow.bottom - rcWindow.top)) / 2,
                 0,
                 0,
                 SWP_NOSIZE);
}

Referenced by LocaleDlgProc(), and StartDlgProc().

CreateKeyboardLayoutList()

static VOID CreateKeyboardLayoutList ( HWND  hItemsList )

static

Definition at line 351 of file livecd.c.

{
    HKEY hKey;
    WCHAR szCurrentKLID[KL_NAMELENGTH], szKLID[KL_NAMELENGTH];
    WCHAR KeyName[MAX_PATH];
    DWORD dwIndex;
    DWORD dwSize;
    INT iIndex;
    ULONG ulLayoutId;
 
    if (!GetKeyboardLayoutNameW(szCurrentKLID))
        wcscpy(szCurrentKLID, L"00000409");
 
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                      L"System\\CurrentControlSet\\Control\\Keyboard Layouts",
                      0, KEY_ENUMERATE_SUB_KEYS, &hKey) != ERROR_SUCCESS)
    {
        return;
    }
 
    for (dwIndex = 0; ; ++dwIndex)
    {
        dwSize = ARRAYSIZE(szKLID);
        if (RegEnumKeyExW(hKey, dwIndex, szKLID, &dwSize,
                          NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
        {
            break;
        }
 
        GetLayoutName(szKLID, KeyName, _countof(KeyName));
 
        iIndex = (INT)SendMessageW(hItemsList, CB_ADDSTRING, 0, (LPARAM)KeyName);
 
        ulLayoutId = wcstoul(szKLID, NULL, 16);
        SendMessageW(hItemsList, CB_SETITEMDATA, iIndex, (LPARAM)ulLayoutId);
 
        if (_wcsicmp(szKLID, szCurrentKLID) == 0)
            SendMessageW(hItemsList, CB_SETCURSEL, (WPARAM)iIndex, (LPARAM)0);
    }
 
    RegCloseKey(hKey);
}

Referenced by LocaleDlgProc().

CreateLanguagesList()

static VOID CreateLanguagesList ( HWND  hwnd, PSTATE  pState  )

static

Definition at line 179 of file livecd.c.

{
    WCHAR langSel[255];
    LCID Locale = 0;
 
    hList = hwnd;
    bSpain = FALSE;
    EnumSystemLocalesW(LocalesEnumProc, LCID_SUPPORTED);
 
    if (pState->Unattend->bEnabled)
        Locale = pState->Unattend->LocaleID;
 
    if (!Locale)
    {
        /* Select current locale */
        /* or should it be System and not user? */
        Locale = GetUserDefaultLCID();
    }
    GetLocaleInfoW(Locale, LOCALE_SLANGUAGE, langSel, ARRAYSIZE(langSel));
 
    SendMessageW(hList,
                 CB_SELECTSTRING,
                 -1,
                 (LPARAM)langSel);
}

Referenced by LocaleDlgProc().

ExpandInstallerPath()

static BOOL ExpandInstallerPath ( _In_ PCWSTR  pInstallerName, _Out_writes_z_(PathSize) PWSTR  pInstallerPath, _In_ SIZE_T  PathSize  )

static

Expands the path for the ReactOS Installer "reactos.exe". See also base/setup/welcome/welcome.c!ExpandInstallerPath()

Definition at line 867 of file livecd.c.

{
    SYSTEM_INFO SystemInfo;
    SIZE_T cchInstallerNameLen;
    PWSTR ptr;
    DWORD dwAttribs;
 
    cchInstallerNameLen = wcslen(pInstallerName);
    if (PathSize < cchInstallerNameLen)
    {
        /* The buffer is not large enough to contain the installer file name */
        *pInstallerPath = UNICODE_NULL;
        return FALSE;
    }
 
    /*
     * First, try to find the installer using the default drive, under
     * the directory whose name corresponds to the currently-running
     * CPU architecture.
     */
    GetSystemInfo(&SystemInfo);
 
    *pInstallerPath = UNICODE_NULL;
    /* Alternatively one can use SharedUserData->NtSystemRoot */
    GetSystemWindowsDirectoryW(pInstallerPath, PathSize - cchInstallerNameLen - 1);
    ptr = wcschr(pInstallerPath, L'\\');
    if (ptr)
        *++ptr = UNICODE_NULL;
    else
        *pInstallerPath = UNICODE_NULL;
 
    /* Append the corresponding CPU architecture */
    switch (SystemInfo.wProcessorArchitecture)
    {
        case PROCESSOR_ARCHITECTURE_INTEL:
            StringCchCatW(pInstallerPath, PathSize, L"I386");
            break;
 
        case PROCESSOR_ARCHITECTURE_MIPS:
            StringCchCatW(pInstallerPath, PathSize, L"MIPS");
            break;
 
        case PROCESSOR_ARCHITECTURE_ALPHA:
            StringCchCatW(pInstallerPath, PathSize, L"ALPHA");
            break;
 
        case PROCESSOR_ARCHITECTURE_PPC:
            StringCchCatW(pInstallerPath, PathSize, L"PPC");
            break;
 
        case PROCESSOR_ARCHITECTURE_SHX:
            StringCchCatW(pInstallerPath, PathSize, L"SHX");
            break;
 
        case PROCESSOR_ARCHITECTURE_ARM:
            StringCchCatW(pInstallerPath, PathSize, L"ARM");
            break;
 
        case PROCESSOR_ARCHITECTURE_IA64:
            StringCchCatW(pInstallerPath, PathSize, L"IA64");
            break;
 
        case PROCESSOR_ARCHITECTURE_ALPHA64:
            StringCchCatW(pInstallerPath, PathSize, L"ALPHA64");
            break;
 
        case PROCESSOR_ARCHITECTURE_AMD64:
            StringCchCatW(pInstallerPath, PathSize, L"AMD64");
            break;
 
        // case PROCESSOR_ARCHITECTURE_MSIL: /* .NET CPU-independent code */
        case PROCESSOR_ARCHITECTURE_UNKNOWN:
        default:
            WARN("Unknown processor architecture %lu\n", SystemInfo.wProcessorArchitecture);
            SystemInfo.wProcessorArchitecture = PROCESSOR_ARCHITECTURE_UNKNOWN;
            break;
    }
 
    if (SystemInfo.wProcessorArchitecture != PROCESSOR_ARCHITECTURE_UNKNOWN)
        StringCchCatW(pInstallerPath, PathSize, L"\\");
    StringCchCatW(pInstallerPath, PathSize, pInstallerName);
 
    dwAttribs = GetFileAttributesW(pInstallerPath);
    if ((dwAttribs != INVALID_FILE_ATTRIBUTES) &&
        !(dwAttribs & FILE_ATTRIBUTE_DIRECTORY))
    {
        /* We have found the installer */
        return TRUE;
    }
 
    WARN("Couldn't find the installer '%s', trying alternative.\n", debugstr_w(pInstallerPath));
 
    /*
     * We failed. Try to find the installer from either the current
     * ReactOS installation directory, or from our current directory.
     */
    *pInstallerPath = UNICODE_NULL;
    /* Alternatively one can use SharedUserData->NtSystemRoot */
    if (GetSystemWindowsDirectoryW(pInstallerPath, PathSize - cchInstallerNameLen - 1))
        StringCchCatW(pInstallerPath, PathSize, L"\\");
    StringCchCatW(pInstallerPath, PathSize, pInstallerName);
 
    dwAttribs = GetFileAttributesW(pInstallerPath);
    if ((dwAttribs != INVALID_FILE_ATTRIBUTES) &&
        !(dwAttribs & FILE_ATTRIBUTE_DIRECTORY))
    {
        /* We have found the installer */
        return TRUE;
    }
 
    /* Installer not found */
    ERR("Couldn't find the installer '%s'\n", debugstr_w(pInstallerPath));
    *pInstallerPath = UNICODE_NULL;
    return FALSE;
}

Referenced by RunLiveCD().

GetLayoutName()

static BOOL GetLayoutName ( _In_ PCWSTR  pszKLID, _Out_writes_z_(NameSize) PWSTR  pszName, _In_ SIZE_T  NameSize  )

static

Definition at line 207 of file livecd.c.

{
    HKEY hKey;
    BOOL ret;
    DWORD dwBufLen;
    WCHAR szBuf[1 + MAX_PATH + 2 + 10]; // "@file_path,-resID"
    WCHAR szPath[MAX_PATH];
 
    if (NameSize < sizeof(WCHAR))
        return FALSE;
    *pszName = UNICODE_NULL;
 
    StringCchPrintfW(szBuf, _countof(szBuf), L"SYSTEM\\CurrentControlSet\\Control\\Keyboard Layouts\\%s", pszKLID);
    if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szBuf, 0, KEY_QUERY_VALUE, &hKey) != ERROR_SUCCESS)
        return FALSE;
 
    dwBufLen = sizeof(szBuf);
    if (RegQueryValueExW(hKey, L"Layout Display Name", NULL, NULL, (PBYTE)szBuf, &dwBufLen) == ERROR_SUCCESS)
    {
        if (szBuf[0] == L'@') do
        {
            PWCHAR dllname, index_str;
            INT index;
 
            dllname = szBuf + 1;
            index_str = wcsrchr(szBuf, L',');
            if (!index_str)
                break;
            *index_str++ = UNICODE_NULL;
 
            index = wcstol(index_str, NULL, 10);
            if (index >= 0)
            {
                FIXME("Cannot handle non-negative indices (%d)\n", index);
                break;
            }
            index = -index;
 
            if (ExpandEnvironmentStringsW(dllname, szPath, _countof(szPath)))
            {
                HANDLE hLib = LoadLibraryExW(szPath, NULL, LOAD_LIBRARY_AS_DATAFILE);
                if (hLib)
                {
                    ret = (LoadStringW(hLib, index, szPath, _countof(szPath)) != 0);
                    FreeLibrary(hLib);
                    if (ret)
                    {
                        StringCchCopyW(pszName, NameSize, szPath);
                        goto Quit;
                    }
                }
            }
        } while (0);
    }
 
    dwBufLen = NameSize * sizeof(WCHAR);
    ret = (RegQueryValueExW(hKey, L"Layout Text", NULL, NULL, (PBYTE)pszName, &dwBufLen) == ERROR_SUCCESS);
 
Quit:
    RegCloseKey(hKey);
    return ret;
}

Referenced by CreateKeyboardLayoutList().

InitializeDefaultUserLocale()

static VOID InitializeDefaultUserLocale ( PLCID  pNewLcid )

static

Definition at line 397 of file livecd.c.

{
    WCHAR szBuffer[80];
    PWSTR ptr;
    HKEY hLocaleKey;
    DWORD ret;
    DWORD dwSize;
    LCID lcid;
    INT i;
 
    struct {LCTYPE LCType; PWSTR pValue;} LocaleData[] = {
        /* Number */
        {LOCALE_SDECIMAL, L"sDecimal"},
        {LOCALE_STHOUSAND, L"sThousand"},
        {LOCALE_SNEGATIVESIGN, L"sNegativeSign"},
        {LOCALE_SPOSITIVESIGN, L"sPositiveSign"},
        {LOCALE_SGROUPING, L"sGrouping"},
        {LOCALE_SLIST, L"sList"},
        {LOCALE_SNATIVEDIGITS, L"sNativeDigits"},
        {LOCALE_INEGNUMBER, L"iNegNumber"},
        {LOCALE_IDIGITS, L"iDigits"},
        {LOCALE_ILZERO, L"iLZero"},
        {LOCALE_IMEASURE, L"iMeasure"},
        {LOCALE_IDIGITSUBSTITUTION, L"NumShape"},
 
        /* Currency */
        {LOCALE_SCURRENCY, L"sCurrency"},
        {LOCALE_SMONDECIMALSEP, L"sMonDecimalSep"},
        {LOCALE_SMONTHOUSANDSEP, L"sMonThousandSep"},
        {LOCALE_SMONGROUPING, L"sMonGrouping"},
        {LOCALE_ICURRENCY, L"iCurrency"},
        {LOCALE_INEGCURR, L"iNegCurr"},
        {LOCALE_ICURRDIGITS, L"iCurrDigits"},
 
        /* Time */
        {LOCALE_STIMEFORMAT, L"sTimeFormat"},
        {LOCALE_STIME, L"sTime"},
        {LOCALE_S1159, L"s1159"},
        {LOCALE_S2359, L"s2359"},
        {LOCALE_ITIME, L"iTime"},
        {LOCALE_ITIMEMARKPOSN, L"iTimePrefix"},
        {LOCALE_ITLZERO, L"iTLZero"},
 
        /* Date */
        {LOCALE_SLONGDATE, L"sLongDate"},
        {LOCALE_SSHORTDATE, L"sShortDate"},
        {LOCALE_SDATE, L"sDate"},
        {LOCALE_IFIRSTDAYOFWEEK, L"iFirstDayOfWeek"},
        {LOCALE_IFIRSTWEEKOFYEAR, L"iFirstWeekOfYear"},
        {LOCALE_IDATE, L"iDate"},
        {LOCALE_ICALENDARTYPE, L"iCalendarType"},
 
        /* Misc */
        {LOCALE_SCOUNTRY, L"sCountry"},
        {LOCALE_SABBREVLANGNAME, L"sLanguage"},
        {LOCALE_ICOUNTRY, L"iCountry"},
        {0, NULL}};
 
    ret = RegOpenKeyExW(HKEY_USERS,
                        L".DEFAULT\\Control Panel\\International",
                        0,
                        KEY_READ | KEY_WRITE,
                        &hLocaleKey);
    if (ret != ERROR_SUCCESS)
    {
        return;
    }
 
    if (pNewLcid == NULL)
    {
        dwSize = 9 * sizeof(WCHAR);
        ret = RegQueryValueExW(hLocaleKey,
                               L"Locale",
                               NULL,
                               NULL,
                               (PBYTE)szBuffer,
                               &dwSize);
        if (ret != ERROR_SUCCESS)
            goto done;
 
        lcid = (LCID)wcstoul(szBuffer, &ptr, 16);
        if (lcid == 0)
            goto done;
    }
    else
    {
        lcid = *pNewLcid;
 
        _swprintf(szBuffer, L"%08lx", lcid);
        RegSetValueExW(hLocaleKey,
                       L"Locale",
                       0,
                       REG_SZ,
                       (PBYTE)szBuffer,
                       (wcslen(szBuffer) + 1) * sizeof(WCHAR));
    }
 
    i = 0;
    while (LocaleData[i].pValue != NULL)
    {
        if (GetLocaleInfoW(lcid,
                           LocaleData[i].LCType | LOCALE_NOUSEROVERRIDE,
                           szBuffer,
                           ARRAYSIZE(szBuffer)))
        {
            RegSetValueExW(hLocaleKey,
                           LocaleData[i].pValue,
                           0,
                           REG_SZ,
                           (PBYTE)szBuffer,
                           (wcslen(szBuffer) + 1) * sizeof(WCHAR));
        }
 
        i++;
    }
 
done:
    RegCloseKey(hLocaleKey);
}

Referenced by LocaleDlgProc().

InitLogo()

static VOID InitLogo ( PIMGINFO  pImgInfo, HWND  hwndDlg  )

static

Definition at line 27 of file livecd.c.

{
    BITMAP logoBitmap;
    BITMAP maskBitmap;
    BITMAPINFO bmpi;
    HDC hDC, hDCLogo, hDCMask;
    HBITMAP hMask = NULL, hLogo = NULL;
    HBITMAP hAlphaLogo = NULL;
    COLORREF *pBits;
    INT line, column;
 
    hDC = GetDC(hwndDlg);
    hDCLogo = CreateCompatibleDC(NULL);
    hDCMask = CreateCompatibleDC(NULL);
 
    if (hDC == NULL || hDCLogo == NULL || hDCMask == NULL)
        goto Cleanup;
 
    ZeroMemory(pImgInfo, sizeof(*pImgInfo));
    ZeroMemory(&bmpi, sizeof(bmpi));
 
    hLogo = (HBITMAP)LoadImageW(hInstance, MAKEINTRESOURCEW(IDB_ROSLOGO), IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR);
    hMask = (HBITMAP)LoadImageW(hInstance, MAKEINTRESOURCEW(IDB_ROSMASK), IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR);
 
    if (hLogo == NULL || hMask == NULL)
        goto Cleanup;
 
    GetObject(hLogo, sizeof(logoBitmap), &logoBitmap);
    GetObject(hMask, sizeof(maskBitmap), &maskBitmap);
 
    if (logoBitmap.bmHeight != maskBitmap.bmHeight || logoBitmap.bmWidth != maskBitmap.bmWidth)
        goto Cleanup;
 
    bmpi.bmiHeader.biSize = sizeof(BITMAPINFO);
    bmpi.bmiHeader.biWidth = logoBitmap.bmWidth;
    bmpi.bmiHeader.biHeight = logoBitmap.bmHeight;
    bmpi.bmiHeader.biPlanes = 1;
    bmpi.bmiHeader.biBitCount = 32;
    bmpi.bmiHeader.biCompression = BI_RGB;
    bmpi.bmiHeader.biSizeImage = 4 * logoBitmap.bmWidth * logoBitmap.bmHeight;
 
    /* Create a premultiplied bitmap */
    hAlphaLogo = CreateDIBSection(hDC, &bmpi, DIB_RGB_COLORS, (PVOID*)&pBits, 0, 0);
    if (!hAlphaLogo)
        goto Cleanup;
 
    SelectObject(hDCLogo, hLogo);
    SelectObject(hDCMask, hMask);
 
    for (line = logoBitmap.bmHeight - 1; line >= 0; line--)
    {
        for (column = 0; column < logoBitmap.bmWidth; column++)
        {
            COLORREF alpha = GetPixel(hDCMask, column, line) & 0xFF;
            COLORREF Color = GetPixel(hDCLogo, column, line);
            DWORD r, g, b;
 
            r = GetRValue(Color) * alpha / 255;
            g = GetGValue(Color) * alpha / 255;
            b = GetBValue(Color) * alpha / 255;
 
            *pBits++ = b | (g << 8) | (r << 16) | (alpha << 24);
        }
    }
 
    pImgInfo->hBitmap = hAlphaLogo;
    pImgInfo->cxSource = logoBitmap.bmWidth;
    pImgInfo->cySource = logoBitmap.bmHeight;
    pImgInfo->iBits = logoBitmap.bmBitsPixel;
    pImgInfo->iPlanes = logoBitmap.bmPlanes;
 
Cleanup:
    if (hMask != NULL) DeleteObject(hMask);
    if (hLogo != NULL) DeleteObject(hLogo);
    if (hDCMask != NULL) DeleteDC(hDCMask);
    if (hDCLogo != NULL) DeleteDC(hDCLogo);
    if (hDC != NULL) ReleaseDC(hwndDlg, hDC);
}

Referenced by RunLiveCD().

IsMiniNT()

BOOL IsMiniNT

(

VOID

)

Check whether we are running in MiniNT mode (e.g. live medium).

Definition at line 110 of file livecd.c.

{
    HKEY hKey;
    LONG rc;
 
    /* Check for the presence of the "MiniNT" registry key */
    rc = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                       L"SYSTEM\\CurrentControlSet\\Control\\MiniNT",
                       0,
                       KEY_QUERY_VALUE,
                       &hKey);
    if (rc == ERROR_SUCCESS)
        RegCloseKey(hKey);
 
    return (rc == ERROR_SUCCESS);
}

LocaleDlgProc()

static INT_PTR CALLBACK LocaleDlgProc ( HWND  hwndDlg, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 582 of file livecd.c.

{
    PSTATE pState;
 
    /* Retrieve pointer to the state */
    pState = (PSTATE)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            /* Save pointer to the state */
            pState = (PSTATE)lParam;
            SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pState);
 
            /* Center the dialog window */
            CenterWindow(hwndDlg);
 
            /* Fill the language and keyboard layout lists */
            CreateLanguagesList(GetDlgItem(hwndDlg, IDC_LANGUAGELIST), pState);
            CreateKeyboardLayoutList(GetDlgItem(hwndDlg, IDC_LAYOUTLIST));
 
            /* In unattended mode, advance to the next page */
            if (pState->Unattend->bEnabled)
                SendMessageW(hwndDlg, WM_COMMAND, MAKEWPARAM(IDOK, BN_CLICKED), 0);
            return TRUE;
        }
 
        case WM_DRAWITEM:
            OnDrawItem((LPDRAWITEMSTRUCT)lParam, pState, IDC_LOCALELOGO);
            return TRUE;
 
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_LANGUAGELIST:
                    if (HIWORD(wParam) == CBN_SELCHANGE)
                    {
                        LCID NewLcid;
                        INT iCurSel;
 
                        iCurSel = SendDlgItemMessageW(hwndDlg,
                                                     IDC_LANGUAGELIST,
                                                     CB_GETCURSEL,
                                                     0,
                                                     0);
                        if (iCurSel == CB_ERR)
                            break;
 
                        NewLcid = SendDlgItemMessageW(hwndDlg,
                                                      IDC_LANGUAGELIST,
                                                      CB_GETITEMDATA,
                                                      iCurSel,
                                                      0);
                        if (NewLcid == (LCID)CB_ERR)
                            break;
 
                        TRACE("LCID: 0x%08lx\n", NewLcid);
                        SelectKeyboardForLanguage(GetDlgItem(hwndDlg, IDC_LAYOUTLIST),
                                                  NewLcid);
                    }
                    break;
 
                case IDOK:
                    if (HIWORD(wParam) == BN_CLICKED)
                    {
                        LCID NewLcid;
                        INT iCurSel;
 
                        iCurSel = SendDlgItemMessageW(hwndDlg,
                                                     IDC_LANGUAGELIST,
                                                     CB_GETCURSEL,
                                                     0,
                                                     0);
                        if (iCurSel == CB_ERR)
                            break;
 
                        NewLcid = SendDlgItemMessageW(hwndDlg,
                                                      IDC_LANGUAGELIST,
                                                      CB_GETITEMDATA,
                                                      iCurSel,
                                                      0);
                        if (NewLcid == (LCID)CB_ERR)
                            break;
 
                        /* Set the locale for the current thread */
                        NtSetDefaultLocale(TRUE, NewLcid);
 
                        /* Store the locale settings in the registry */
                        InitializeDefaultUserLocale(&NewLcid);
 
                        /* Set UI language for this thread */
                        SetThreadLocale(NewLcid);
 
                        SetKeyboardLayout(GetDlgItem(hwndDlg, IDC_LAYOUTLIST));
 
                        pState->NextPage = STARTPAGE;
                        EndDialog(hwndDlg, LOWORD(wParam));
                    }
                    break;
 
                case IDCANCEL:
                    if (HIWORD(wParam) == BN_CLICKED)
                    {
                        static WCHAR szMsg[RC_STRING_MAX_SIZE];
                        INT ret;
                        LoadStringW(GetModuleHandle(NULL), IDS_CANCEL_CONFIRM, szMsg, ARRAYSIZE(szMsg));
                        ret = MessageBoxW(hwndDlg, szMsg, L"ReactOS LiveCD", MB_ICONWARNING | MB_YESNO | MB_DEFBUTTON2);
                        if (ret == IDOK || ret == IDYES)
                        {
                            pState->NextPage = DONE;
                            pState->Run = REBOOT;
                            EndDialog(hwndDlg, LOWORD(wParam));
                        }
                    }
                    break;
 
                default:
                    break;
            }
            break;
 
        default:
            break;
    }
 
    return FALSE;
}

Referenced by RunLiveCD().

LocalesEnumProc()

static BOOL CALLBACK LocalesEnumProc ( LPTSTR  lpLocale )

static

Definition at line 129 of file livecd.c.

{
    LCID lcid;
    WCHAR lang[255];
    INT index;
    BOOL bNoShow = FALSE;
 
    lcid = wcstoul(lpLocale, NULL, 16);
 
    /* Display only languages with installed support */
    if (!IsValidLocale(lcid, LCID_INSTALLED))
        return TRUE;
 
    // See http://archives.miloush.net/michkap/archive/2006/09/23/768178.html for why we handle spain differently
    if (lcid == MAKELCID(MAKELANGID(LANG_SPANISH, SUBLANG_SPANISH), SORT_DEFAULT) ||
        lcid == MAKELCID(MAKELANGID(LANG_SPANISH, SUBLANG_SPANISH_MODERN), SORT_DEFAULT))
    {
        if (bSpain == FALSE)
        {
            LoadStringW(hInstance, IDS_SPAIN, lang, ARRAYSIZE(lang));
            bSpain = TRUE;
        }
        else
        {
            bNoShow = TRUE;
        }
    }
    else
    {
        GetLocaleInfoW(lcid, LOCALE_SLANGUAGE, lang, ARRAYSIZE(lang));
    }
 
    if (bNoShow == FALSE)
    {
        index = SendMessageW(hList,
                             CB_ADDSTRING,
                             0,
                             (LPARAM)lang);
 
        SendMessageW(hList,
                     CB_SETITEMDATA,
                     index,
                     (LPARAM)lcid);
    }
 
    return TRUE;
}

Referenced by CreateLanguagesList().

OnDrawItem()

static VOID OnDrawItem ( LPDRAWITEMSTRUCT  lpDrawItem, PSTATE  pState, UINT  uCtlID  )

static

Definition at line 544 of file livecd.c.

{
    HDC hdcMem;
    LONG left;
 
    if (lpDrawItem->CtlID == uCtlID)
    {
        /* Position image in centre of dialog */
        left = (lpDrawItem->rcItem.right - pState->ImageInfo.cxSource) / 2;
 
        hdcMem = CreateCompatibleDC(lpDrawItem->hDC);
        if (hdcMem != NULL)
        {
            static BLENDFUNCTION BlendFunc = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA};
 
            SelectObject(hdcMem, pState->ImageInfo.hBitmap);
            GdiAlphaBlend(lpDrawItem->hDC,
                          left,
                          lpDrawItem->rcItem.top,
                          pState->ImageInfo.cxSource,
                          pState->ImageInfo.cySource,
                          hdcMem,
                          0, 0,
                          pState->ImageInfo.cxSource,
                          pState->ImageInfo.cySource,
                          BlendFunc);
            DeleteDC(hdcMem);
        }
    }
}

Referenced by LocaleDlgProc(), and StartDlgProc().

ParseUnattend()

static VOID ParseUnattend ( _In_ LPCWSTR  UnattendInf, _Out_ LIVECD_UNATTEND *  pUnattend  )

static

Definition at line 813 of file livecd.c.

{
    WCHAR Buffer[MAX_PATH];
 
    pUnattend->bEnabled = FALSE;
 
    if (!GetPrivateProfileStringW(L"Unattend", L"Signature", L"", Buffer, _countof(Buffer), UnattendInf))
    {
        ERR("Unable to parse Signature\n");
        return;
    }
 
    if (_wcsicmp(Buffer, L"$ReactOS$") && _wcsicmp(Buffer, L"$Windows NT$"))
    {
        TRACE("Unknown signature: %S\n", Buffer);
        return;
    }
 
    if (!GetPrivateProfileStringW(L"Unattend", L"UnattendSetupEnabled", L"", Buffer, _countof(Buffer), UnattendInf))
    {
        ERR("Unable to parse UnattendSetupEnabled\n");
        return;
    }
 
    if (_wcsicmp(Buffer, L"yes") != 0)
    {
        TRACE("Unattended setup is not enabled\n");
        return;
    }
    /* If the user presses Ctrl+Shift+F10, disable unattended setup */
    if ((GetKeyState(VK_CONTROL) & GetKeyState(VK_SHIFT) & GetKeyState(VK_F10)) < 0)
    {
        WARN("Unattended setup is disabled by keypress\n");
        return;
    }
 
    pUnattend->bEnabled = TRUE;
    pUnattend->LocaleID = 0;
 
    if (GetPrivateProfileStringW(L"Unattend", L"LocaleID", L"", Buffer, _countof(Buffer), UnattendInf) && Buffer[0])
    {
        pUnattend->LocaleID = wcstol(Buffer, NULL, 16);
    }
}

Referenced by RunLiveCD().

RunLiveCD()

VOID RunLiveCD

(

PSTATE

pState

)

Definition at line 987 of file livecd.c.

{
    LIVECD_UNATTEND Unattend = {0};
    WCHAR UnattendInf[MAX_PATH];
 
    /* Try to locate the ReactOS Installer */
    if (!ExpandInstallerPath(L"reactos.exe", Installer, _countof(Installer)))
        *Installer = UNICODE_NULL;
    if (*Installer)
        TRACE("ReactOS Installer: '%S'\n", Installer);
    else
        WARN("Could not find the ReactOS Installer\n");
 
    /* If the ReactOS Installer was located, use its path for the
     * unattended file; otherwise, use the current ReactOS directory. */
    StringCchCopyW(UnattendInf, _countof(UnattendInf), Installer);
    if (*UnattendInf)
    {
        /* Find the last path separator and truncate the path there.
         * If there is none, NUL the path. */
        PWCHAR ptr = wcsrchr(UnattendInf, L'\\');
        if (!ptr)
            ptr = UnattendInf;
        *ptr = UNICODE_NULL;
    }
    if (!*UnattendInf)
    {
        /* No actual path was found, fall back to the ReactOS directory */
        GetWindowsDirectoryW(UnattendInf, _countof(UnattendInf));
    }
    StringCchCatW(UnattendInf, _countof(UnattendInf), L"\\unattend.inf");
    ParseUnattend(UnattendInf, &Unattend);
    pState->Unattend = &Unattend;
 
    InitLogo(&pState->ImageInfo, NULL);
 
    while (pState->NextPage != DONE)
    {
        switch (pState->NextPage)
        {
            case LOCALEPAGE:
                DialogBoxParamW(hInstance,
                                MAKEINTRESOURCEW(IDD_LOCALEPAGE),
                                NULL,
                                LocaleDlgProc,
                                (LPARAM)pState);
                break;
 
            case STARTPAGE:
                DialogBoxParamW(hInstance,
                                MAKEINTRESOURCEW(IDD_STARTPAGE),
                                NULL,
                                StartDlgProc,
                                (LPARAM)pState);
                break;
 
            default:
                break;
        }
    }
 
    DeleteObject(pState->ImageInfo.hBitmap);
}

Referenced by wWinMain().

SelectKeyboardForLanguage()

static VOID SelectKeyboardForLanguage ( HWND  hwnd, LCID  lcid  )

static

Definition at line 299 of file livecd.c.

{
    INT i, nCount;
    ULONG ulLayoutId;
 
    TRACE("LCID: %08lx, LangID: %04lx\n", lcid, LANGIDFROMLCID(lcid));
 
    nCount = SendMessageW(hwnd, CB_GETCOUNT, 0, 0);
 
    for (i = 0; i < nCount; i++)
    {
        ulLayoutId = (ULONG)SendMessageW(hwnd, CB_GETITEMDATA, i, 0);
        TRACE("Layout: %08lx\n", ulLayoutId);
 
        if (LANGIDFROMLCID(ulLayoutId) == LANGIDFROMLCID(lcid))
        {
            TRACE("Found 1: %08lx --> %08lx\n", ulLayoutId, lcid);
            SendMessageW(hwnd, CB_SETCURSEL, i, 0);
            return;
        }
    }
 
    for (i = 0; i < nCount; i++)
    {
        ulLayoutId = (ULONG)SendMessageW(hwnd, CB_GETITEMDATA, i, 0);
        TRACE("Layout: %08lx\n", ulLayoutId);
 
        if (PRIMARYLANGID(ulLayoutId) == PRIMARYLANGID(lcid))
        {
            TRACE("Found 2: %08lx --> %08lx\n", ulLayoutId, lcid);
            SendMessageW(hwnd, CB_SETCURSEL, i, 0);
            return;
        }
    }
 
    TRACE("No match found!\n");
    /* No match found, try selecting English (United States) */
    for (i = 0; i < nCount; i++)
    {
        ulLayoutId = (DWORD)SendMessageW(hwnd, CB_GETITEMDATA, i, 0);
        if (ulLayoutId == 0x00000409)
        {
            SendMessageW(hwnd, CB_SETCURSEL, i, 0);
            return;
        }
    }
}

Referenced by LocaleDlgProc().

SetKeyboardLayout()

static VOID SetKeyboardLayout ( HWND  hwnd )

static

Definition at line 275 of file livecd.c.

{
    INT iCurSel;
    ULONG ulLayoutId;
    HKL hKl;
    WCHAR szKLID[KL_NAMELENGTH];
 
    iCurSel = SendMessageW(hwnd, CB_GETCURSEL, 0, 0);
    if (iCurSel == CB_ERR)
        return;
 
    ulLayoutId = (ULONG)SendMessageW(hwnd, CB_GETITEMDATA, iCurSel, 0);
    if (ulLayoutId == (ULONG)CB_ERR)
        return;
 
    _swprintf(szKLID, L"%08lx", ulLayoutId);
 
    hKl = LoadKeyboardLayoutW(szKLID, KLF_ACTIVATE | KLF_REPLACELANG | KLF_SETFORPROCESS);
    SystemParametersInfoW(SPI_SETDEFAULTINPUTLANG, 0, &hKl, SPIF_SENDCHANGE);
}

Referenced by LocaleDlgProc().

StartDlgProc()

static INT_PTR CALLBACK StartDlgProc ( HWND  hwndDlg, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 718 of file livecd.c.

{
    PSTATE pState;
 
    /* Retrieve pointer to the state */
    pState = (PSTATE)GetWindowLongPtrW(hwndDlg, GWLP_USERDATA);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            /* Save pointer to the state */
            pState = (PSTATE)lParam;
            SetWindowLongPtrW(hwndDlg, GWLP_USERDATA, (DWORD_PTR)pState);
 
            /* Center the dialog window */
            CenterWindow(hwndDlg);
 
            /* If the ReactOS Installer could not be located, directly start
             * the LiveCD. Otherwise, directly start the installer if we are
             * in unattended mode. */
            if (!*Installer)
            {
                /* Disable the "Install" button and click on "Run LiveCD" */
                EnableWindow(GetDlgItem(hwndDlg, IDC_INSTALL), FALSE);
                SendMessageW(hwndDlg, WM_COMMAND, MAKEWPARAM(IDC_RUN, BN_CLICKED), 0);
            }
            else if (pState->Unattend->bEnabled)
            {
                /* Click on "Install" */
                SendMessageW(hwndDlg, WM_COMMAND, MAKEWPARAM(IDC_INSTALL, BN_CLICKED), 0);
            }
            return TRUE;
        }
 
        case WM_DRAWITEM:
            OnDrawItem((LPDRAWITEMSTRUCT)lParam, pState, IDC_STARTLOGO);
            return TRUE;
 
        case WM_COMMAND:
            if (HIWORD(wParam) == BN_CLICKED)
            {
                switch (LOWORD(wParam))
                {
                    case IDC_RUN:
                        pState->NextPage = DONE;
                        pState->Run = SHELL;
                        EndDialog(hwndDlg, LOWORD(wParam));
                        break;
 
                    case IDC_INSTALL:
                        pState->NextPage = DONE;
                        pState->Run = INSTALLER;
                        EndDialog(hwndDlg, LOWORD(wParam));
                        break;
 
                    case IDOK:
                        pState->NextPage = LOCALEPAGE;
                        EndDialog(hwndDlg, LOWORD(wParam));
                        break;
 
                    case IDCANCEL:
                        if (HIWORD(wParam) == BN_CLICKED)
                        {
                            static WCHAR szMsg[RC_STRING_MAX_SIZE];
                            INT ret;
                            LoadStringW(GetModuleHandle(NULL), IDS_CANCEL_CONFIRM, szMsg, ARRAYSIZE(szMsg));
                            ret = MessageBoxW(hwndDlg, szMsg, L"ReactOS LiveCD", MB_ICONWARNING | MB_YESNO | MB_DEFBUTTON2);
                            if (ret == IDOK || ret == IDYES)
                            {
                                pState->NextPage = DONE;
                                pState->Run = REBOOT;
                                EndDialog(hwndDlg, LOWORD(wParam));
                            }
                        }
                        break;
 
                    default:
                        break;
                }
            }
            break;
 
        default:
            break;
    }
 
    return FALSE;
}

Referenced by RunLiveCD().

Variable Documentation

bSpain

BOOL bSpain = FALSE

Definition at line 12 of file livecd.c.

Referenced by CreateLanguagesList(), and LocalesEnumProc().

hList

HWND hList

Definition at line 10 of file livecd.c.

Referenced by COpenWithList::AddAppToMRUList(), AddColumns(), AddMRUData(), AddMRUStringA(), AddMRUStringW(), FxPkgFdo::CreateDefaultDeviceList(), CreateDragImage(), CreateLanguagesList(), CreateNTPServerList(), DelMRUString(), DelScheme(), DeviceDlgProc(), DoCreatePartition(), DoDeletePartition(), DriveDlgProc(), EnumAudioDeviceInterfaces(), EnumerateDrivers(), EnumMRUListA(), EnumMRUListW(), FindMRUData(), FindMRUStringA(), FindMRUStringW(), get_comboexlist_selection(), CApplicationView::GetRestoreListSelectionData(), GetSelectedLayout(), InitCodePagesList(), InitHardWareTypesPage(), FxPkgFdo::Initialize(), InitProbeListPage(), KsOpenDefaultDevice(), CKsProxy::Load(), COpenWithList::LoadMRUList(), LocalesEnumProc(), NewDocSelDlgProc(), PipeReadThread(), SelectInstallPartition(), SetNTPServer(), SetStartupType(), ShowSoundScheme(), StartApplication(), test_combo_dropdown_size(), test_combo_WS_VSCROLL(), test_comboex_WM_LBUTTONDOWN(), test_create(), test_itemfrompoint(), test_listbox_height(), test_listbox_item_data(), test_listbox_LB_DIR(), test_listbox_size(), test_WM_LBUTTONDOWN(), test_WS_VSCROLL(), UpdateData(), and UpgradeRepairDlgProc().

hLocaleList

HWND hLocaleList

Definition at line 11 of file livecd.c.

Installer

WCHAR Installer[MAX_PATH]

Definition at line 14 of file livecd.c.

Referenced by GetInstallerTypeFromString(), GetSilentInstallParameters(), GuessInstallerType(), RunLiveCD(), StartDlgProc(), StartInstaller(), and uuid().