precomp.h File Reference

#include <stdarg.h>
#include <ntstatus.h>
#include <windef.h>
#include <winbase.h>
#include <winreg.h>
#include <wingdi.h>
#include <wincon.h>
#include <windowsx.h>
#include <tchar.h>
#include <shellapi.h>
#include <shlobj.h>
#include <shlwapi.h>
#include <setupapi.h>
#include <cpl.h>
#include <strsafe.h>
#include "resource.h"

Include dependency graph for precomp.h:

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

Go to the source code of this file.

Classes
struct	_APPLET

Macros
#define	_INC_WINDOWS
#define	COM_NO_WINDOWS_H
#define	WIN32_NO_STATUS
#define	NUM_APPLETS   (1)
#define	MAX_STR_LENGTH   256

Typedefs
typedef struct _APPLET	APPLET
typedef struct _APPLET *	PAPPLET

Functions
void	ShowLastWin32Error (HWND hWndOwner)
INT_PTR CALLBACK	GeneralPageProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR CALLBACK	HardwarePageProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR CALLBACK	AdvancedPageProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR CALLBACK	HardProfDlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
INT_PTR CALLBACK	UserProfileDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR CALLBACK	EnvironmentDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR CALLBACK	StartRecDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR CALLBACK	VirtMemDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR CALLBACK	LicenceDlgProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
BOOL	GetSystemName (PWSTR pBuf, SIZE_T cchBuf)
INT __cdecl	ResourceMessageBox (_In_opt_ HINSTANCE hInstance, _In_opt_ HWND hwnd, _In_ UINT uType, _In_ UINT uCaption, _In_ UINT uText,...)

Variables
HINSTANCE	hApplet

Macro Definition Documentation

_INC_WINDOWS

#define _INC_WINDOWS

Definition at line 6 of file precomp.h.

COM_NO_WINDOWS_H

#define COM_NO_WINDOWS_H

Definition at line 7 of file precomp.h.

MAX_STR_LENGTH

#define MAX_STR_LENGTH   256

Definition at line 58 of file precomp.h.

NUM_APPLETS

#define NUM_APPLETS   (1)

Definition at line 28 of file precomp.h.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 10 of file precomp.h.

Typedef Documentation

APPLET

typedef struct _APPLET APPLET

PAPPLET

typedef struct _APPLET * PAPPLET

Function Documentation

AdvancedPageProc()

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

Definition at line 422 of file advanced.c.

{
    PGLOBALDATA pGlobalData;
 
    pGlobalData = (PGLOBALDATA)GetWindowLongPtr(hwndDlg, DWLP_USER);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
            pGlobalData = (PGLOBALDATA)((LPPROPSHEETPAGE)lParam)->lParam;
            SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pGlobalData);
 
            InitLanguagesList(hwndDlg, pGlobalData);
            InitCodePagesList(hwndDlg);
            break;
 
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_LANGUAGE_COMBO:
                    if (HIWORD(wParam) == CBN_SELCHANGE)
                    {
                        LCID lcid;
                        INT iIndex;
 
                        iIndex = SendMessage(hLangList, CB_GETCURSEL, 0, 0);
                        if (iIndex == CB_ERR)
                            break;
 
                        lcid = SendMessage(hLangList, CB_GETITEMDATA, iIndex, 0);
                        if (lcid == (LCID)CB_ERR)
                            break;
 
                        pGlobalData->SystemLCID = lcid;
 
                        PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
                    }
                    break;
 
                case IDC_APPLY_CUR_USER_DEF_PROFILE:
                    if (HIWORD(wParam) == BN_CLICKED)
                    {
                        if (SendDlgItemMessageW(hwndDlg, IDC_APPLY_CUR_USER_DEF_PROFILE, BM_GETCHECK, 0, 0))
                        {
                            ResourceMessageBox(hwndDlg,
                                               MB_OK | MB_ICONWARNING,
                                               IDS_APPLY_DEFAULT_TITLE,
                                               IDS_APPLY_DEFAULT_TEXT);
                            pGlobalData->bApplyToDefaultUser = TRUE;
                        }
                        else
                        {
                            pGlobalData->bApplyToDefaultUser = FALSE;
                        }
 
                        PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
                    }
                    break;
            }
            break;
 
        case WM_NOTIFY:
            if (((LPNMHDR)lParam)->code == PSN_APPLY)
            {
                PropSheet_UnChanged(GetParent(hwndDlg), hwndDlg);
 
                SaveSystemSettings(pGlobalData);
                SaveFontSubstitutionSettings(hwndDlg, pGlobalData);
                SaveFontLinkingSettings(hwndDlg, pGlobalData);
            }
            else if (((LPNMHDR)lParam)->idFrom == IDC_CONV_TABLES &&
                     ((LPNMHDR)lParam)->code == NM_CUSTOMDRAW)
            {
                SetWindowLongPtr(hwndDlg,
                                 DWLP_MSGRESULT,
                                 (LONG_PTR)ListViewCustomDraw(lParam));
                return TRUE;
            }
            break;
    }
 
    return FALSE;
}

Referenced by Applet(), MainPageProc(), and SystemApplet().

EnvironmentDlgProc()

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

Definition at line 1823 of file environment.c.

{
    PENVIRONMENT_DIALOG_DATA DlgData;
    DlgData = (PENVIRONMENT_DIALOG_DATA)GetWindowLongPtr(hwndDlg, DWLP_USER);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            RECT rect;
 
            DlgData = GlobalAlloc(GPTR, sizeof(ENVIRONMENT_DIALOG_DATA));
            if (!DlgData)
            {
                EndDialog(hwndDlg, 0);
                return (INT_PTR)TRUE;
            }
            SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)DlgData);
 
            GetClientRect(hwndDlg, &rect);
            DlgData->cxOld = rect.right - rect.left;
            DlgData->cyOld = rect.bottom - rect.top;
 
            GetWindowRect(hwndDlg, &rect);
            DlgData->cxMin = rect.right - rect.left;
            DlgData->cyMin = rect.bottom - rect.top;
 
            OnInitEnvironmentDialog(hwndDlg);
            break;
        }
 
        case WM_SIZE:
        {
            OnEnvironmentDlgResize(hwndDlg, DlgData, LOWORD(lParam), HIWORD(lParam));
            SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, 0);
            return TRUE;
        }
 
        case WM_SIZING:
        {
            /* Forbid resizing the dialog smaller than its minimal size */
            PRECT pRect = (PRECT)lParam;
 
            if ((wParam == WMSZ_LEFT) || (wParam == WMSZ_TOPLEFT) || (wParam == WMSZ_BOTTOMLEFT))
            {
                if (pRect->right - pRect->left < DlgData->cxMin)
                    pRect->left = pRect->right - DlgData->cxMin;
            }
            else
            if ((wParam == WMSZ_RIGHT) || (wParam == WMSZ_TOPRIGHT) || (wParam == WMSZ_BOTTOMRIGHT))
            {
                if (pRect->right - pRect->left < DlgData->cxMin)
                    pRect->right = pRect->left + DlgData->cxMin;
            }
 
            if ((wParam == WMSZ_TOP) || (wParam == WMSZ_TOPLEFT) || (wParam == WMSZ_TOPRIGHT))
            {
                if (pRect->bottom - pRect->top < DlgData->cyMin)
                    pRect->top = pRect->bottom - DlgData->cyMin;
            }
            else
            if ((wParam == WMSZ_BOTTOM) || (wParam == WMSZ_BOTTOMLEFT) || (wParam == WMSZ_BOTTOMRIGHT))
            {
                if (pRect->bottom - pRect->top < DlgData->cyMin)
                    pRect->bottom = pRect->top + DlgData->cyMin;
            }
 
            SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE);
            return TRUE;
        }
 
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_USER_VARIABLE_NEW:
                    OnNewVariable(hwndDlg, IDC_USER_VARIABLE_LIST);
                    return TRUE;
 
                case IDC_USER_VARIABLE_EDIT:
                    OnEditVariable(hwndDlg, IDC_USER_VARIABLE_LIST);
                    return TRUE;
 
                case IDC_USER_VARIABLE_DELETE:
                    OnDeleteVariable(hwndDlg, IDC_USER_VARIABLE_LIST);
                    return TRUE;
 
                case IDC_SYSTEM_VARIABLE_NEW:
                    OnNewVariable(hwndDlg, IDC_SYSTEM_VARIABLE_LIST);
                    return TRUE;
 
                case IDC_SYSTEM_VARIABLE_EDIT:
                    OnEditVariable(hwndDlg, IDC_SYSTEM_VARIABLE_LIST);
                    return TRUE;
 
                case IDC_SYSTEM_VARIABLE_DELETE:
                    OnDeleteVariable(hwndDlg, IDC_SYSTEM_VARIABLE_LIST);
                    return TRUE;
 
                case IDOK:
                    SetAllVars(hwndDlg, IDC_USER_VARIABLE_LIST);
                    SetAllVars(hwndDlg, IDC_SYSTEM_VARIABLE_LIST);
                    SendMessage(HWND_BROADCAST, WM_WININICHANGE,
                                0, (LPARAM)_T("Environment"));
                    EndDialog(hwndDlg, 0);
                    return TRUE;
 
                case IDCANCEL:
                    EndDialog(hwndDlg, 0);
                    return TRUE;
            }
            break;
 
        case WM_DESTROY:
            ReleaseListViewItems(hwndDlg, IDC_USER_VARIABLE_LIST);
            ReleaseListViewItems(hwndDlg, IDC_SYSTEM_VARIABLE_LIST);
            GlobalFree(DlgData);
            break;
 
        case WM_NOTIFY:
            return OnNotify(hwndDlg, (NMHDR*)lParam);
    }
 
    return FALSE;
}

Referenced by AdvancedPageProc().

GeneralPageProc()

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

Definition at line 327 of file propsheet_general.c.

{
    PPAGEDATA pPageData;
 
    /* Get the window context */
    pPageData = (PPAGEDATA)GetWindowLongPtr(hwndDlg,
                                            GWLP_USERDATA);
    if (pPageData == NULL && uMsg != WM_INITDIALOG)
    {
        return FALSE;
    }
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
            pPageData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PAGEDATA));
            if (pPageData != NULL)
            {
                SetWindowLongPtr(hwndDlg,
                                 GWLP_USERDATA,
                                 (LONG_PTR)pPageData);
 
                pPageData->dlgInfo = (PSERVICEPROPSHEET)(((LPPROPSHEETPAGE)lParam)->lParam);
                if (pPageData->dlgInfo != NULL)
                {
                    InitGeneralPage(pPageData->dlgInfo, hwndDlg);
                    SetButtonStates(pPageData->dlgInfo, hwndDlg);
                }
            }
            break;
 
        case WM_DESTROY:
            HeapFree(GetProcessHeap(), 0, pPageData);
            break;
 
        case WM_COMMAND:
            switch(LOWORD(wParam))
            {
                case IDC_START_TYPE:
                    if (HIWORD(wParam) == CBN_SELCHANGE)
                    {
                        pPageData->bStartTypeChanged = TRUE;
                        PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
                    }
                    break;
 
                case IDC_DISP_NAME:
                    if (HIWORD(wParam) == EN_CHANGE)
                    {
                        pPageData->bDisplayNameChanged = TRUE;
                        PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
                    }
                    break;
 
                case IDC_DESCRIPTION:
                    if (HIWORD(wParam) == EN_CHANGE)
                    {
                        pPageData->bDescriptionChanged = TRUE;
                        PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
                    }
                    break;
 
                case IDC_EXEPATH:
                    if (HIWORD(wParam) == EN_CHANGE)
                    {
                        pPageData->bBinaryPathChanged = TRUE;
                        PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
                    }
                    break;
 
                case IDC_START:
                {
                    WCHAR szStartParams[256];
                    LPWSTR lpStartParams = NULL;
 
                    if (GetDlgItemText(hwndDlg, IDC_START_PARAM, szStartParams, 256) > 0)
                        lpStartParams = szStartParams;
 
                    EnableWindow(GetDlgItem(hwndDlg, IDC_START_PARAM), FALSE);
 
                    RunActionWithProgress(hwndDlg,
                                          pPageData->dlgInfo->pService->lpServiceName,
                                          pPageData->dlgInfo->pService->lpDisplayName,
                                          ACTION_START,
                                          lpStartParams);
 
                    UpdateServiceStatus(pPageData->dlgInfo->pService);
                    ChangeListViewText(pPageData->dlgInfo->Info, pPageData->dlgInfo->pService, LVSTATUS);
                    SetButtonStates(pPageData->dlgInfo, hwndDlg);
                    SetServiceStatusText(pPageData->dlgInfo, hwndDlg);
                    break;
                }
 
                case IDC_STOP:
                    RunActionWithProgress(hwndDlg,
                                          pPageData->dlgInfo->pService->lpServiceName,
                                          pPageData->dlgInfo->pService->lpDisplayName,
                                          ACTION_STOP,
                                          NULL);
 
                    UpdateServiceStatus(pPageData->dlgInfo->pService);
                    ChangeListViewText(pPageData->dlgInfo->Info, pPageData->dlgInfo->pService, LVSTATUS);
                    SetButtonStates(pPageData->dlgInfo, hwndDlg);
                    SetServiceStatusText(pPageData->dlgInfo, hwndDlg);
                    break;
 
                case IDC_PAUSE:
                    RunActionWithProgress(hwndDlg,
                                          pPageData->dlgInfo->pService->lpServiceName,
                                          pPageData->dlgInfo->pService->lpDisplayName,
                                          ACTION_PAUSE,
                                          NULL);
 
                    UpdateServiceStatus(pPageData->dlgInfo->pService);
                    ChangeListViewText(pPageData->dlgInfo->Info, pPageData->dlgInfo->pService, LVSTATUS);
                    SetButtonStates(pPageData->dlgInfo, hwndDlg);
                    SetServiceStatusText(pPageData->dlgInfo, hwndDlg);
                    break;
 
                case IDC_RESUME:
                    RunActionWithProgress(hwndDlg,
                                          pPageData->dlgInfo->pService->lpServiceName,
                                          pPageData->dlgInfo->pService->lpDisplayName,
                                          ACTION_RESUME,
                                          NULL);
 
                    UpdateServiceStatus(pPageData->dlgInfo->pService);
                    ChangeListViewText(pPageData->dlgInfo->Info, pPageData->dlgInfo->pService, LVSTATUS);
                    SetButtonStates(pPageData->dlgInfo, hwndDlg);
                    SetServiceStatusText(pPageData->dlgInfo, hwndDlg);
                    break;
 
                case IDC_EDIT:
                    SendDlgItemMessage(hwndDlg, IDC_DISP_NAME, EM_SETREADONLY, FALSE, 0);
                    SendDlgItemMessage(hwndDlg, IDC_DESCRIPTION, EM_SETREADONLY, FALSE, 0);
                    SendDlgItemMessage(hwndDlg, IDC_EXEPATH, EM_SETREADONLY, FALSE, 0);
                    EnableWindow(GetDlgItem(hwndDlg, IDC_EDIT), FALSE);
                    break;
            }
            break;
 
        case WM_NOTIFY:
            switch (((LPNMHDR)lParam)->code)
            {
                case PSN_APPLY:
                    if (pPageData->bDisplayNameChanged ||
                        pPageData->bDescriptionChanged ||
                        pPageData->bBinaryPathChanged ||
                        pPageData->bStartTypeChanged)
                    {
                        SaveDlgInfo(pPageData, hwndDlg);
                        SetButtonStates(pPageData->dlgInfo, hwndDlg);
                        pPageData->bDisplayNameChanged = FALSE;
                        pPageData->bDescriptionChanged = FALSE;
                        pPageData->bBinaryPathChanged = FALSE;
                        pPageData->bStartTypeChanged = FALSE;
                    }
                    break;
            }
            break;
    }
 
    return FALSE;
}

GetSystemName()

BOOL GetSystemName	(	PWSTR	pBuf,
		SIZE_T	cchBuf
	)

Definition at line 490 of file smbios.c.

{
    static const VENDOR_LONG_NAME LongNames[] =
    {
        { L"ASUSTeK", L"ASUS" },
        { L"First International Computer", L"FIC" },
        { L"Hewlett-Packard", L"HP" },
        { L"MICRO-STAR", L"MSI" },
        { L"SGI.COM", L"SGI" },
        { L"Silicon Graphics International", L"SGI" },
        { L"Intel(R) Client Systems", L"Intel" },
        { L"InformationComputerSystems", L"ICS" },
        { L"Bernecker + Rainer  Industrie-Elektronik", L"Bernecker & Rainer" },
        { L"CHUWI INNOVATION AND TECHNOLOGY", L"CHUWI" },
        { L"CHUWI INNOVATION LIMITED", L"CHUWI" },
        { L"CHUWI  INNOVATION  LIMITED", L"CHUWI" },
        { L"http://www.abit.com.tw/", L"ABIT" },
        { L"http:\\\\www.abit.com.tw", L"ABIT" },
        { L"www.abit.com.tw", L"ABIT" },
        { L"CASPER BILGISAYAR SISTEMLERI A.S", L"Casper" },
        { L"Colorful Technology And Development", L"Colorful" },
        { L"Colorful Yu Gong Technology And Development", L"Colorful Yu Gong" },
        { L"HaierComputer", L"Haier" },
        { L"Haier Information Technology (Shen Zhen)", L"Haier" },
        { L"HASEECOMPUTERS", L"Hasee" },
        { L"HELIOS BUSINESS COMPUTER", L"HELIOS" },
        { L"Shanghai Zongzhi InfoTech", L"Zongzhi" },
        { L"TSING HUA TONGFANG CO.,LTD", L"TSINGHUA TONGFANG" },
        { L"Yeston Digital Technology Co.,LTD", L"Yeston" },
    };
    static const REDUNDANT_WORD RedundantWords[] =
    {
        { L"Corporation", FALSE },
        { L"Communication", FALSE },
        { L"Computer", FALSE },
        { L"Computers", FALSE },
        { L"Group", FALSE },
        { L"Cloud", FALSE },
        { L"Center", FALSE },
        { L"Systems", FALSE },
        { L"Microsystems", FALSE },
        { L"Infosystems", FALSE },
        { L"Digital", FALSE },
        { L"Electronics", FALSE },
        { L"Electric", FALSE },
        { L"Elektronik", FALSE },
        { L"Software", FALSE },
        { L"Foundation", FALSE },
        { L"International", FALSE },
        { L"Interantonal", FALSE }, // on purpose (some MSI boards)
        { L"INTERANTIONAL", FALSE }, // on purpose (some MSI boards)
        { L"Industrial", FALSE },
        { L"Industrie", FALSE },
        { L"Information", FALSE },
        { L"Informatica", FALSE },
        { L"Produkte", FALSE },
        { L"Technology", FALSE },
        { L"Tecohnology", FALSE }, // on purpose (some Gigabyte boards)
        { L"Technologies", FALSE },
        { L"Tecnologia", FALSE },
        { L"Limited", FALSE },
        { L"Int", FALSE },
        { L"Inc", FALSE },
        { L"Co", FALSE },
        { L"Corp", FALSE },
        { L"Crop", FALSE },
        { L"LLC", FALSE },
        { L"Ltd", FALSE },
        { L"LTDA", FALSE },
        { L"GmbH", FALSE },
        { L"S.p.A", FALSE },
        { L"A.S.", FALSE },
        { L"S.A", FALSE },
        { L"S.A.S", FALSE },
        { L"S/A", FALSE },
        { L"SA", FALSE },
        { L"SAS", FALSE },
        { L"BV", FALSE },
        { L"AG", FALSE },
        { L"OOO", TRUE },
        { L"CJSC", FALSE },
        { L"INT'L", FALSE },
        { L"INTL", FALSE },
        { L"plc", FALSE },
    };
    PVOID SMBiosBuf;
    PCHAR DmiStrings[ID_STRINGS_MAX] = { 0 };
    WCHAR ven[512], dev[512];
    CHAR tmpstr[512];
    BOOL bTrimProduct, bTrimFamily, bGenericName, bRemove;
    UINT i;
    PWCHAR j;
 
    SMBiosBuf = LoadSMBiosData(DmiStrings);
    if (!SMBiosBuf)
    {
        return FALSE;
    }
 
    TrimNonPrintable(DmiStrings[SYS_VENDOR]);
    bTrimProduct = TrimNonPrintableProd(DmiStrings[SYS_PRODUCT]);
    TrimNonPrintable(DmiStrings[SYS_VERSION]);
    bTrimFamily = TrimNonPrintable(DmiStrings[SYS_FAMILY]);
    TrimNonPrintable(DmiStrings[BOARD_VENDOR]);
    TrimNonPrintable(DmiStrings[BOARD_NAME]);
    TrimNonPrintable(DmiStrings[BOARD_VERSION]);
 
    if (bTrimProduct)
    {
        if (DmiStrings[SYS_FAMILY] && !bTrimFamily)
        {
            DmiStrings[SYS_PRODUCT] = DmiStrings[SYS_FAMILY];
            bTrimProduct = FALSE;
        }
    }
 
    GetSMBiosStringW(DmiStrings[SYS_VENDOR], ven, _countof(ven), TRUE);
    GetSMBiosStringW(DmiStrings[SYS_PRODUCT], dev, _countof(dev), TRUE);
    bGenericName = IsGenericSystemName(ven, dev, NULL) || bTrimProduct;
 
    if (wcslen(dev) == 0 ||
        !wcscmp(dev, ven) ||
        bGenericName)
    {
        BOOL bGenericVen = FALSE, bRemoveVen = FALSE, bGenericDev = (wcslen(dev) == 0 || !wcscmp(dev, ven) || bTrimProduct);
 
        if (bGenericName && IsGenericSystemName(ven, NULL, &bRemove))
        {
            if (bRemove)
            {
                *ven = 0;
            }
            bGenericVen = TRUE;
            bRemoveVen = bRemove;
        }
        if (bGenericName && IsGenericSystemName(NULL, dev, &bRemove))
        {
            if (bRemove)
            {
                *dev = 0;
            }
            bGenericDev = TRUE;
        }
        // system strings are unusable, use board strings
        if (DmiStrings[BOARD_VENDOR] != NULL || !bGenericName)
        {
            if ((DmiStrings[BOARD_VENDOR] &&
                strlen(DmiStrings[BOARD_VENDOR]) >= 2 &&
                strstr(DmiStrings[BOARD_VENDOR], "  ") != DmiStrings[BOARD_VENDOR]) ||
                bGenericVen)
            {
                GetSMBiosStringW(DmiStrings[BOARD_VENDOR], ven, _countof(ven), TRUE);
            }
            GetSMBiosStringW(DmiStrings[BOARD_NAME], dev, _countof(dev), TRUE);
 
            if (IsGenericSystemName(ven, NULL, &bRemove) && bRemove)
            {
                *ven = 0;
 
                if (bGenericVen && !bRemoveVen)
                {
                    GetSMBiosStringW(DmiStrings[SYS_VENDOR], ven, _countof(ven), TRUE);
                }
            }
            if (IsGenericSystemName(NULL, dev, &bRemove) && bRemove)
            {
                *dev = 0;
 
                if (!bGenericDev)
                {
                    GetSMBiosStringW(DmiStrings[SYS_PRODUCT], dev, _countof(dev), TRUE);
                }
            }
            if (wcslen(dev) == 0 &&
                DmiStrings[SYS_VERSION] != NULL)
            {
                GetSMBiosStringW(DmiStrings[SYS_VERSION], dev, _countof(dev), TRUE);
 
                if (IsGenericSystemName(NULL, dev, &bRemove) && bRemove)
                {
                    *dev = 0;
                }
            }
            if (wcslen(dev) == 0 &&
                DmiStrings[BOARD_VERSION] != NULL)
            {
                GetSMBiosStringW(DmiStrings[BOARD_VERSION], dev, _countof(dev), TRUE);
 
                if (IsGenericSystemName(NULL, dev, &bRemove) && bRemove)
                {
                    *dev = 0;
                }
            }
        }
        else if (DmiStrings[BOARD_NAME] != NULL)
        {
            GetSMBiosStringW(DmiStrings[BOARD_NAME], dev, _countof(dev), TRUE);
 
            if (IsGenericSystemName(NULL, dev, &bRemove) && bRemove)
            {
                *dev = 0;
            }
        }
 
        if (wcslen(ven) == 0 && wcslen(dev) == 0)
        {
            // board strings are empty, use BIOS vendor string
            GetSMBiosStringW(DmiStrings[BIOS_VENDOR], ven, _countof(ven), TRUE);
        }
    }
    else
    {
        if (wcslen(ven) < 2)
        {
            GetSMBiosStringW(DmiStrings[BOARD_VENDOR], ven, _countof(ven), TRUE);
 
            if (IsGenericSystemName(ven, NULL, &bRemove) && bRemove)
            {
                *ven = 0;
            }
        }
    }
 
    // workaround for LORD ELECTRONICS
    if (((j = wcsstr(ven, L" ")) != NULL) && (j - ven > 2))
    {
        i = j - ven;
        if (!wcsncmp(ven + wcslen(ven) - i, ven, i))
        {
            ven[wcslen(ven) - i] = L'\0';
        }
    }
 
    // make vendor strings shorter
    for (i = 0; i < _countof(LongNames); i++)
    {
        if (wcsstr(dev, LongNames[i].pwLongName) == dev)
        {
            // swap ven and dev
            StringCchCopyW(pBuf, cchBuf, ven);
            StringCchCopyW(ven, _countof(ven), dev);
            StringCchCopyW(dev, _countof(dev), pBuf);
        }
        wcsrep(ven, LongNames[i].pwLongName, LongNames[i].pwShortName, TRUE);
    }
 
    // remove redundant words
    for (i = 0; i < _countof(RedundantWords); i++)
    {
        wcsrep(ven, RedundantWords[i].pwStr, L"", RedundantWords[i].bReplaceFirstWord);
    }
    for (i = 0; i < _countof(RedundantWords); i++)
    {
        StringCchCopyW(pBuf, cchBuf, RedundantWords[i].pwStr);
        StringCchCatW(pBuf, cchBuf, L".");
        wcsrep(ven, pBuf, L"", RedundantWords[i].bReplaceFirstWord);
    }
 
    // workaround for LENOVO notebooks
    if (!wcsicmp(ven, L"LENOVO"))
    {
        StringCchCopyW(ven, _countof(ven), L"Lenovo");
 
        if (DmiStrings[SYS_VERSION] != NULL)
        {
            if (!strncmp(DmiStrings[SYS_VERSION], "ThinkPad   ", 11))
            {
                DmiStrings[SYS_VERSION][8] = L'\0';
            }
            if (wcslen(dev) > 0 &&
                (!strcmp(DmiStrings[SYS_VERSION], "IdeaCentre") ||
                !strcmp(DmiStrings[SYS_VERSION], "ThinkPad")))
            {
                DmiStrings[SYS_FAMILY] = DmiStrings[SYS_VERSION];
                DmiStrings[SYS_VERSION] = NULL;
            }
            else
            {
                StringCchCopyA(tmpstr, _countof(tmpstr), DmiStrings[SYS_VERSION]);
                _strupr(tmpstr);
            }
        }
 
        if (DmiStrings[SYS_VERSION] != NULL &&
            strcmp(tmpstr, " ") &&
            strcmp(tmpstr, "LENOVO") &&
            strstr(tmpstr, "LENOVO   ") == NULL &&
            strstr(tmpstr, "LENOVO PRODUCT") == NULL &&
            strstr(tmpstr, "LENOVOPRODUCT") == NULL &&
            strstr(tmpstr, "INVALID") == NULL &&
            strncmp(tmpstr, "   ", 3) &&
            (strlen(tmpstr) >= 3 || !IsDigitStrA(tmpstr)) &&
            strstr(DmiStrings[SYS_VERSION], "Rev ") == NULL &&
            strstr(DmiStrings[SYS_VERSION], "1.") == NULL &&
            wcsistr(dev, L"System ") == NULL && // includes System x and ThinkSystem
            wcsistr(dev, L"IdeaPad ") == NULL &&
            wcsistr(dev, L"ThinkServer ") == NULL)
        {
            GetSMBiosStringW(DmiStrings[SYS_VERSION], dev, _countof(dev), TRUE);
        }
 
        if (wcsstr(dev, L"Lenovo-") == dev)
        {
            // replace "-" with space
            dev[6] = L' ';
        }
 
        if (!wcscmp(dev, L"Lenovo"))
        {
            GetSMBiosStringW(DmiStrings[BOARD_NAME], dev, _countof(dev), TRUE);
        }
    }
    if (!wcscmp(ven, L"IBM") &&
        DmiStrings[SYS_VERSION] != NULL &&
        (strstr(DmiStrings[SYS_VERSION], "ThinkPad ") != NULL ||
         strstr(DmiStrings[SYS_VERSION], "ThinkCentre ") != NULL))
    {
        GetSMBiosStringW(DmiStrings[SYS_VERSION], dev, _countof(dev), TRUE);
    }
 
    // workaround for DEXP
    if (!wcscmp(ven, L"DEXP"))
    {
        if (DmiStrings[SYS_PRODUCT] != NULL &&
            DmiStrings[SYS_VERSION] != NULL &&
            (!stricmp(DmiStrings[SYS_PRODUCT], "Tablet PC") ||
             !stricmp(DmiStrings[SYS_PRODUCT], "Notebook") ||
             !stricmp(DmiStrings[SYS_PRODUCT], "Decktop")))
        {
            GetSMBiosStringW(DmiStrings[SYS_VERSION], dev, _countof(dev), TRUE);
        }
    }
 
    // workaround for Razer Blade
    if (!wcscmp(ven, L"Razer") && !wcscmp(dev, L"Blade"))
    {
        if (DmiStrings[SYS_VERSION] != NULL)
        {
            StringCchCopyW(ven, _countof(ven), L"Razer Blade");
            GetSMBiosStringW(DmiStrings[SYS_VERSION], dev, _countof(dev), TRUE);
        }
    }
 
    // workaround for MSI motherboards
    if (!wcscmp(ven, L"MSI") &&
        wcsstr(dev, L"MS-") != NULL &&
        DmiStrings[BOARD_NAME] != NULL &&
        strstr(DmiStrings[BOARD_NAME], "(MS-") != NULL)
    {
        GetSMBiosStringW(DmiStrings[BOARD_NAME], dev, _countof(dev), TRUE);
    }
    if (wcslen(ven) == 0 &&
        wcsstr(dev, L"MS-") == dev)
    {
        StringCchCopyW(ven, _countof(ven), L"MSI");
    }
 
    // trim redundant characters
    TrimPunctuation(ven);
    TrimPunctuation(dev);
 
    if (wcsistr(dev, ven) == dev ||
        (!wcscmp(ven, L"ASUS") && wcsstr(dev, L"ASUS") != NULL) ||
        (!wcscmp(ven, L"HP") && wcsstr(dev, L" by HP") != NULL) ||
        (!wcscmp(ven, L"INTEL") && wcsstr(dev, L" INTEL") != NULL))
    {
        // device string contains vendor string, use second only
        StringCchCopyW(pBuf, cchBuf, dev);
    }
    else
    {
        if (wcslen(ven) > 0 && wcslen(dev) > 0 && (j = wcschr(dev, L' ')))
        {
            // check if vendor string ends with first word of device string
            i = j - dev;
            if (wcslen(ven) > i && !_wcsnicmp(ven + wcslen(ven) - i, dev, i))
            {
                ven[wcslen(ven) - i] = L'\0';
                TrimPunctuation(ven);
            }
        }
        StringCchCopyW(pBuf, cchBuf, ven);
        AppendSystemFamily(pBuf, cchBuf, DmiStrings, dev);
        if (wcslen(pBuf) > 0 && wcslen(dev) > 0)
        {
            StringCchCatW(pBuf, cchBuf, L" ");
        }
        StringCchCatW(pBuf, cchBuf, dev);
    }
 
    FreeSMBiosData(SMBiosBuf);
 
    return (wcslen(pBuf) > 0);
}

Referenced by GetSystemInformation().

HardProfDlgProc()

INT_PTR CALLBACK HardProfDlgProc	(	HWND	hDlg,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 740 of file hardprof.c.

{
    PPROFILEDATA pProfileData;
 
    UNREFERENCED_PARAMETER(lParam);
    UNREFERENCED_PARAMETER(wParam);
    UNREFERENCED_PARAMETER(hwndDlg);
 
    pProfileData = (PPROFILEDATA)GetWindowLongPtr(hwndDlg, DWLP_USER);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
            return OnInitHardProfDialog(hwndDlg);
 
        case WM_DESTROY:
            if (pProfileData != NULL)
            {
                if (pProfileData->pProfiles != NULL)
                    HeapFree(GetProcessHeap(), 0, pProfileData->pProfiles);
                HeapFree(GetProcessHeap(), 0, pProfileData);
            }
            break;
 
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_HRDPROFPROP:
                    HardwareProfileProperties(hwndDlg, pProfileData);
                    break;
 
                case IDC_HRDPROFCOPY:
                    CopyHardwareProfile(hwndDlg, pProfileData);
                    break;
 
                case IDC_HRDPROFRENAME:
                    RenameHardwareProfile(hwndDlg, pProfileData);
                    break;
 
                case IDC_HRDPROFDEL:
                    DeleteHardwareProfile(hwndDlg, pProfileData);
                    break;
 
                case IDC_HRDPROFUP:
                    MoveHardwareProfile(hwndDlg, pProfileData, TRUE);
                    break;
 
                case IDC_HRDPROFDWN:
                    MoveHardwareProfile(hwndDlg, pProfileData, FALSE);
                    break;
 
                case IDC_HRDPROFWAIT:
                    EnableWindow(GetDlgItem(hwndDlg, IDC_HRDPROFEDIT), FALSE);
                    return TRUE;
 
                case IDC_HRDPROFSELECT:
                    EnableWindow(GetDlgItem(hwndDlg, IDC_HRDPROFEDIT), TRUE);
                    return TRUE;
 
                case IDC_HRDPROFLSTBOX:
                    if (HIWORD(wParam) == LBN_SELCHANGE)
                    {
                        pProfileData->dwSelectedProfileIndex = (DWORD)SendDlgItemMessage(hwndDlg, IDC_HRDPROFLSTBOX, LB_GETCURSEL, 0, 0);
                        UpdateButtons(hwndDlg, pProfileData);
                    }
                    return TRUE;
 
                case IDOK:
                    OnOk(hwndDlg);
 
                case IDCANCEL:
                    EndDialog(hwndDlg, LOWORD(wParam));
                    return TRUE;
            }
            break;
    }
 
    return FALSE;
}

Referenced by HardwarePageProc().

HardwarePageProc()

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

Definition at line 68 of file hardware.c.

{
    UNREFERENCED_PARAMETER(lParam);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
            break;
 
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDC_HARDWARE_DEVICE_MANAGER:
                    if (!LaunchDeviceManager(hwndDlg))
                    {
                        /* FIXME */
                    }
                    return TRUE;
 
                case IDC_HARDWARE_WIZARD:
                    LaunchHardwareWizard(hwndDlg);
                    return TRUE;
 
                case IDC_HARDWARE_PROFILE:
                    DialogBox(hApplet,
                              MAKEINTRESOURCE(IDD_HARDWAREPROFILES),
                              hwndDlg,
                              HardProfDlgProc);
                    return TRUE;
            }
            break;
    }
 
    return FALSE;
}

Referenced by SystemApplet().

LicenceDlgProc()

INT_PTR CALLBACK LicenceDlgProc	(	HWND	hDlg,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 68 of file licence.c.

{
    PLIC_CONTEXT pLicInfo;
 
    UNREFERENCED_PARAMETER(lParam);
 
    pLicInfo = (PLIC_CONTEXT)GetWindowLongPtr(hDlg, DWLP_USER);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
            pLicInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(LIC_CONTEXT));
            if (pLicInfo == NULL)
            {
                EndDialog(hDlg, 0);
                return FALSE;
            }
            SetWindowLongPtr(hDlg, DWLP_USER, (LONG_PTR)pLicInfo);
            return OnInitDialog(hDlg, pLicInfo);
 
        case WM_DESTROY:
            if (pLicInfo)
            {
                if (pLicInfo->hIconSm)
                    DestroyIcon(pLicInfo->hIconSm);
 
                if (pLicInfo->hIcon)
                    DestroyIcon(pLicInfo->hIcon);
                    
                HeapFree(GetProcessHeap(), 0, pLicInfo);
            }
            break;
 
        case WM_COMMAND:
            if ((LOWORD(wParam) == IDOK) || (LOWORD(wParam) == IDCANCEL))
            {
                EndDialog(hDlg,
                          LOWORD(wParam));
                return TRUE;
            }
            break;
    }
 
    return FALSE;
}

Referenced by GeneralPageProc().

ResourceMessageBox()

INT __cdecl ResourceMessageBox	(	_In_opt_ HINSTANCE	hInstance,
		_In_opt_ HWND	hwnd,
		_In_ UINT	uType,
		_In_ UINT	uCaption,
		_In_ UINT	uText,
			...
	)

Definition at line 27 of file sysdm.c.

{
    va_list args;
    WCHAR szCaption[MAX_STR_LENGTH];
    WCHAR szText[MAX_STR_LENGTH];
    WCHAR szCookedText[2*MAX_STR_LENGTH];
 
    LoadStringW(hInstance, uCaption, szCaption, _countof(szCaption));
    LoadStringW(hInstance, uText, szText, _countof(szText));
 
    va_start(args, uText);
    StringCchVPrintfW(szCookedText, _countof(szCookedText),
                      szText, args);
    va_end(args);
 
    return MessageBoxW(hwnd,
                       szCookedText,
                       szCaption,
                       uType);
}

ShowLastWin32Error()

void ShowLastWin32Error

(

HWND

hWndOwner

)

Definition at line 11 of file winutils.c.

{
    DWORD dwError;
    LPWSTR lpMsgBuf = NULL;
 
    dwError = GetLastError();
    if (dwError == ERROR_SUCCESS)
        return;
 
    if (!FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                        FORMAT_MESSAGE_FROM_SYSTEM |
                        FORMAT_MESSAGE_IGNORE_INSERTS,
                        NULL,
                        dwError,
                        LANG_USER_DEFAULT,
                        (LPWSTR)&lpMsgBuf,
                        0, NULL))
    {
        return;
    }
 
    MessageBoxW(hwndParent, lpMsgBuf, NULL, MB_OK | MB_ICONERROR);
    LocalFree(lpMsgBuf);
}

Referenced by DeleteClipboardContent(), LoadClipboardDataFromFile(), LoadRecoveryOptions(), OnInitDialog(), ReadClipboardFile(), ReadPageFileSettings(), SaveClipboardToFile(), WriteClipboardFile(), WritePageFileSettings(), WriteStartupRecoveryOptions(), and wWinMain().

StartRecDlgProc()

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

Definition at line 695 of file startrec.c.

{
    PSTARTINFO pStartInfo;
    PBOOTRECORD pRecord;
    int iTimeout;
    LRESULT lResult;
    WCHAR szTimeout[10];
 
    UNREFERENCED_PARAMETER(lParam);
 
    pStartInfo = (PSTARTINFO)GetWindowLongPtr(hwndDlg, DWLP_USER);
 
    switch(uMsg)
    {
        case WM_INITDIALOG:
            pStartInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(STARTINFO));
            SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pStartInfo);
 
            LoadRecoveryOptions(hwndDlg, pStartInfo);
            SetRecoveryTimeout(hwndDlg, 0);
            return LoadOSList(hwndDlg, pStartInfo);
 
        case WM_DESTROY:
            DeleteBootRecords(hwndDlg);
            HeapFree(GetProcessHeap(), 0, pStartInfo);
            break;
 
        case WM_COMMAND:
            switch(LOWORD(wParam))
            {
                case IDC_STRRECEDIT:
                    ShellExecuteW(0, L"open", L"notepad", pStartInfo->szFreeldrIni, NULL, SW_SHOWNORMAL);
                    // FIXME: Use CreateProcess and wait untill finished
                    //  DeleteBootRecords(hwndDlg);
                    //  LoadOSList(hwndDlg);
                    break;
 
                case IDOK:
                    /* Save timeout */
                    if (SendDlgItemMessage(hwndDlg, IDC_STRECLIST, BM_GETCHECK, (WPARAM)0, (LPARAM)0) == BST_CHECKED)
                        iTimeout = SendDlgItemMessage(hwndDlg, IDC_STRRECLISTUPDWN, UDM_GETPOS, (WPARAM)0, (LPARAM)0);
                    else
                        iTimeout = 0;
                    swprintf(szTimeout, L"%i", iTimeout);
 
                    lResult = SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
                    if (lResult == CB_ERR)
                    {
                        /* ? */
                        DeleteBootRecords(hwndDlg);
                        return TRUE;
                    }
 
                    pRecord = (PBOOTRECORD) SendDlgItemMessage(hwndDlg, IDC_STRECOSCOMBO, CB_GETITEMDATA, (WPARAM)lResult, (LPARAM)0);
 
                    if ((INT_PTR)pRecord != CB_ERR)
                    {
                        if (pStartInfo->iFreeLdrIni == 1) // FreeLdrIni style
                        {
                            /* Set default timeout */
                            WritePrivateProfileStringW(L"FREELOADER",
                                                      L"TimeOut",
                                                      szTimeout,
                                                      pStartInfo->szFreeldrIni);
                            /* Set default OS */
                            WritePrivateProfileStringW(L"FREELOADER",
                                                      L"DefaultOS",
                                                      pRecord->szSectionName,
                                                      pStartInfo->szFreeldrIni);
 
                        }
                        else if (pStartInfo->iFreeLdrIni == 2) // BootIni style
                        {
                            /* Set default timeout */
                            WritePrivateProfileStringW(L"boot loader",
                                                      L"timeout",
                                                      szTimeout,
                                                      pStartInfo->szFreeldrIni);
                            /* Set default OS */
                            WritePrivateProfileStringW(L"boot loader",
                                                      L"default",
                                                      pRecord->szBootPath,
                                                      pStartInfo->szFreeldrIni);
 
                        }
                    }
 
                    if (SaveRecoveryOptions)
                    {
                        WriteStartupRecoveryOptions(hwndDlg, pStartInfo);
                    }
 
                    EndDialog(hwndDlg,
                              LOWORD(wParam));
                    return TRUE;
 
                case IDCANCEL:
                    EndDialog(hwndDlg,
                              LOWORD(wParam));
                    return TRUE;
 
                case IDC_STRECLIST:
                    if (SendDlgItemMessage(hwndDlg, IDC_STRECLIST, BM_GETCHECK, (WPARAM)0, (LPARAM)0) == BST_CHECKED)
                        SetTimeout(hwndDlg, 30);
                    else
                        SetTimeout(hwndDlg, 0);
                    break;
 
                case IDC_STRRECREC:
                    if (SendDlgItemMessage(hwndDlg, IDC_STRRECREC, BM_GETCHECK, (WPARAM)0, (LPARAM)0) == BST_CHECKED)
                        SetRecoveryTimeout(hwndDlg, 30);
                    else
                        SetRecoveryTimeout(hwndDlg, 0);
                    break;
 
                case IDC_STRRECDEBUGCOMBO:
                    if (HIWORD(wParam) == CBN_SELCHANGE)
                    {
                        LRESULT lResult;
 
                        lResult = SendDlgItemMessage(hwndDlg, IDC_STRRECDEBUGCOMBO, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
                        if (lResult != CB_ERR && lResult != (LRESULT)pStartInfo->dwCrashDumpEnabled)
                        {
                            if (pStartInfo->dwCrashDumpEnabled == 1 || pStartInfo->dwCrashDumpEnabled == 2)
                            {
                                SendDlgItemMessageW(hwndDlg, IDC_STRRECDUMPFILE, WM_GETTEXT, (WPARAM)sizeof(pStartInfo->szDumpFile) / sizeof(WCHAR), (LPARAM)pStartInfo->szDumpFile);
                            }
                            else if (pStartInfo->dwCrashDumpEnabled == 3)
                            {
                                SendDlgItemMessageW(hwndDlg, IDC_STRRECDUMPFILE, WM_GETTEXT, (WPARAM)sizeof(pStartInfo->szMinidumpDir) / sizeof(WCHAR), (LPARAM)pStartInfo->szMinidumpDir);
                            }
 
                            pStartInfo->dwCrashDumpEnabled = (DWORD)lResult;
                            SetCrashDlgItems(hwndDlg, pStartInfo);
                        }
                    }
                    break;
            }
            break;
    }
 
    return FALSE;
}

Referenced by AdvancedPageProc().

UserProfileDlgProc()

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

Definition at line 810 of file userprofile.c.

{
    switch (uMsg)
    {
        case WM_INITDIALOG:
            OnInitUserProfileDialog(hwndDlg);
            return TRUE;
 
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDOK:
                case IDCANCEL:
                    EndDialog(hwndDlg,
                              LOWORD(wParam));
                    return TRUE;
 
                case IDC_USERPROFILE_CHANGE:
                    ChangeUserProfileType(hwndDlg);
                    break;
 
                case IDC_USERPROFILE_DELETE:
                    DeleteUserProfile(hwndDlg);
                    break;
 
                case IDC_USERPROFILE_COPY:
                    CopyUserProfile(hwndDlg);
                    break;
            }
            break;
 
        case WM_NOTIFY:
            OnNotify(hwndDlg, (NMHDR *)lParam);
            break;
    }
 
    return FALSE;
}

Referenced by AdvancedPageProc().

VirtMemDlgProc()

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

Definition at line 821 of file virtmem.c.

{
    PVIRTMEM pVirtMem;
 
    UNREFERENCED_PARAMETER(lParam);
 
    pVirtMem = (PVIRTMEM)GetWindowLongPtr(hwndDlg, DWLP_USER);
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            pVirtMem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(VIRTMEM));
            if (pVirtMem == NULL)
            {
                EndDialog(hwndDlg, 0);
                return FALSE;
            }
 
            SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pVirtMem);
 
            OnInitVirtMemDialog(hwndDlg, pVirtMem);
            break;
        }
 
        case WM_DESTROY:
            OnDestroy(pVirtMem);
            break;
 
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case IDCANCEL:
                    EndDialog(hwndDlg, 0);
                    return TRUE;
 
                case IDOK:
                    OnVirtMemDialogOk(pVirtMem);
                    EndDialog(hwndDlg, pVirtMem->bModified);
                    return TRUE;
 
                case IDC_NOPAGEFILE:
                    OnNoPagingFile(pVirtMem);
                    return TRUE;
 
                case IDC_SYSMANSIZE:
                    OnSysManSize(pVirtMem);
                    return TRUE;
 
                case IDC_CUSTOM:
                    OnCustom(pVirtMem);
                    return TRUE;
 
                case IDC_SET:
                    OnSet(pVirtMem);
                    return TRUE;
 
                case IDC_PAGEFILELIST:
                    switch (HIWORD(wParam))
                    {
                        case LBN_SELCHANGE:
                            OnSelChange(pVirtMem);
                            return TRUE;
                    }
                    break;
            }
            break;
    }
 
    return FALSE;
}

Referenced by AdvancedPageProc().

Variable Documentation

hApplet

HINSTANCE hApplet

extern

Definition at line 17 of file access.c.