umandlg.h File Reference

#include <stdlib.h>
#include <windows.h>
#include <commctrl.h>
#include <tlhelp32.h>
#include <windowsx.h>
#include <debug.h>
#include <wchar.h>
#include <strsafe.h>
#include "resource.h"

Include dependency graph for umandlg.h:

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

Go to the source code of this file.

Classes
struct	UTILMAN_GLOBALS
struct	_UTILMAN_STATE
struct	_REGISTRY_SETTINGS
struct	_REGISTRY_DATA

Macros
#define	MAX_BUFFER   256

Typedefs
typedef struct _UTILMAN_STATE	UTILMAN_STATE
typedef struct _UTILMAN_STATE *	PUTILMAN_STATE
typedef struct _REGISTRY_SETTINGS	REGISTRY_SETTINGS
typedef struct _REGISTRY_SETTINGS *	PREGISTRY_SETTINGS
typedef struct _REGISTRY_DATA	REGISTRY_DATA
typedef struct _REGISTRY_DATA *	PREGISTRY_DATA
typedef enum _WRITE_REGISTRY	WRITE_REGISTRY
typedef enum _WRITE_REGISTRY *	PWRITE_REGISTRY

Enumerations
enum	_WRITE_REGISTRY { REGISTRY_ACCESSIBILITY , REGISTRY_UTILMAN }

Functions
VOID	InitUtilsList (IN BOOL bInitGui)
BOOL	DlgInitHandler (IN HWND hDlg)
VOID	ShowAboutDlg (IN HWND hDlgParent)
VOID	GroupBoxUpdateTitle (VOID)
VOID	UpdateUtilityState (IN BOOL bUtilState)
INT_PTR APIENTRY	DlgProc (IN HWND hDlg, IN UINT Msg, IN WPARAM wParam, IN LPARAM lParam)
INT	ListBoxRefreshContents (VOID)
BOOL WINAPI	UManStartDlg (VOID)
DWORD	GetProcessID (IN LPCWSTR lpszProcessName)
BOOL	IsProcessRunning (IN LPCWSTR lpszProcessName)
BOOL	LaunchProcess (IN LPCWSTR lpszProcessName)
BOOL	CloseProcess (IN LPCWSTR lpszProcessName)
BOOL	InitAppRegKey (IN HKEY hPredefinedKey, IN LPCWSTR lpszSubKey, OUT PHKEY phKey, OUT LPDWORD lpdwDisposition)
BOOL	QueryAppSettings (IN HKEY hKey, IN LPCWSTR lpszSubKey, IN LPCWSTR lpszRegValue, OUT PVOID ReturnedData, IN OUT LPDWORD lpdwSizeData)
BOOL	SaveAppSettings (IN HKEY hKey, IN LPCWSTR lpszRegValue, IN DWORD dwRegType, IN PVOID Data, IN DWORD cbSize)

Variables
UTILMAN_GLOBALS	Globals
REGISTRY_SETTINGS	Settings
REGISTRY_DATA	RegData

Macro Definition Documentation

MAX_BUFFER

#define MAX_BUFFER   256

Definition at line 26 of file umandlg.h.

Typedef Documentation

PREGISTRY_DATA

typedef struct _REGISTRY_DATA * PREGISTRY_DATA

PREGISTRY_SETTINGS

typedef struct _REGISTRY_SETTINGS * PREGISTRY_SETTINGS

PUTILMAN_STATE

typedef struct _UTILMAN_STATE * PUTILMAN_STATE

PWRITE_REGISTRY

typedef enum _WRITE_REGISTRY * PWRITE_REGISTRY

REGISTRY_DATA

typedef struct _REGISTRY_DATA REGISTRY_DATA

REGISTRY_SETTINGS

typedef struct _REGISTRY_SETTINGS REGISTRY_SETTINGS

UTILMAN_STATE

typedef struct _UTILMAN_STATE UTILMAN_STATE

WRITE_REGISTRY

typedef enum _WRITE_REGISTRY WRITE_REGISTRY

Enumeration Type Documentation

_WRITE_REGISTRY

enum _WRITE_REGISTRY

Enumerator
REGISTRY_ACCESSIBILITY
REGISTRY_UTILMAN

Definition at line 84 of file umandlg.h.

{
    REGISTRY_ACCESSIBILITY,
    REGISTRY_UTILMAN
} WRITE_REGISTRY, *PWRITE_REGISTRY;

Function Documentation

CloseProcess()

BOOL CloseProcess

(

IN LPCWSTR

lpszProcessName

)

@CloseProcess

Closes a process.

Parameters

[in]

lpszProcessName

The name of the executable process.

Returns

Returns TRUE if the process has been terminated successfully, FALSE otherwise.

Definition at line 192 of file process.c.

{
    HANDLE hProcess;
    DWORD dwProcessID;
 
    /* Get the process ID */
    dwProcessID = GetProcessID(lpszProcessName);
    if (dwProcessID == 0)
    {
        return FALSE;
    }
 
    /* Make sure that the given process ID is not ours, the parent process, so that we do not kill ourselves */
    if (dwProcessID == GetCurrentProcessId())
    {
        return FALSE;
    }
 
    /* Open the process so that we can terminate it */
    hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, dwProcessID);
    if (!hProcess)
    {
        DPRINT("CloseProcess(): Failed to open the process for termination! (Error: %lu)\n", GetLastError());
        return FALSE;
    }
 
    /* Terminate it */
    TerminateProcess(hProcess, 0);
    CloseHandle(hProcess);
    return TRUE;
}

Referenced by DlgProc().

DlgInitHandler()

BOOL DlgInitHandler

(

IN HWND

hDlg

)

@DlgInitHandler

Function which processes several operations for WM_INITDIALOG.

Parameters

[in]

hDlg

The handle object of the dialog.

Returns

TRUE to inform the system that WM_INITDIALOG has been processed and that it should set the keyboard focus to the control.

Definition at line 97 of file umandlg.c.

{
    INT PosX, PosY;
    RECT rc;
    WCHAR szAboutDlg[MAX_BUFFER];
    WCHAR szAppPath[MAX_BUFFER];
    HMENU hSysMenu;
 
    /* Save the dialog handle */
    Globals.hMainDlg = hDlg;
 
    /* Center the dialog on the screen */
    GetWindowRect(hDlg, &rc);
    PosX = (GetSystemMetrics(SM_CXSCREEN) - rc.right) / 2;
    PosY = (GetSystemMetrics(SM_CYSCREEN) - rc.bottom) / 2;
    SetWindowPos(hDlg, 0, PosX, PosY, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
 
    /* Extract the icon resource from the executable process */
    GetModuleFileNameW(NULL, szAppPath, _countof(szAppPath));
    Globals.hIcon = ExtractIconW(Globals.hInstance, szAppPath, 0);
 
    /* Set the icon within the dialog's title bar */
    if (Globals.hIcon)
    {
        SendMessageW(hDlg, WM_SETICON, ICON_SMALL, (LPARAM)Globals.hIcon);
    }
 
    /* Retrieve the system menu and append the "About" menu item onto it */
    hSysMenu = GetSystemMenu(hDlg, FALSE);
    if (hSysMenu != NULL)
    {
        if (LoadStringW(Globals.hInstance, IDM_ABOUT, szAboutDlg, _countof(szAboutDlg)))
        {
            AppendMenuW(hSysMenu, MF_SEPARATOR, 0, NULL);
            AppendMenuW(hSysMenu, MF_STRING, IDM_ABOUT, szAboutDlg);
        }
    }
 
    /* Get the dialog items, specifically the dialog list box, the Start and Stop buttons */
    Globals.hListDlg = GetDlgItem(hDlg, IDC_LISTBOX);
    Globals.hDlgCtlStart = GetDlgItem(hDlg, IDC_START);
    Globals.hDlgCtlStop = GetDlgItem(hDlg, IDC_STOP);
 
    /* Initialize the GUI listbox */
    InitUtilsList(TRUE);
 
    /* Set the selection to the first item */
    Globals.iSelectedIndex = 0;
 
    /* Refresh the list */
    ListBoxRefreshContents();
 
    /* Create a timer, we'll use it to control the state of our items in the listbox */
    Globals.iTimer = SetTimer(hDlg, 0, 400, NULL);
 
    return TRUE;
}

Referenced by DlgProc().

DlgProc()

INT_PTR APIENTRY DlgProc	(	IN HWND	hDlg,
		IN UINT	Msg,
		IN WPARAM	wParam,
		IN LPARAM	lParam
	)

@DlgProc

Main dialog application procedure function.

Parameters

[in]	hDlg	The handle object of the dialog.
[in]	Msg	Message events (in unsigned int).
[in]	wParam	Message parameter (in UINT_PTR).
[in]	lParam	Message parameter (in LONG_PTR).

Returns

Returns 0 to inform the system that the procedure has been handled.

Definition at line 292 of file umandlg.c.

{
    switch (Msg)
    {
        case WM_INITDIALOG:
            DlgInitHandler(hDlg);
            return TRUE;
 
        case WM_CLOSE:
            KillTimer(hDlg, Globals.iTimer);
            DestroyIcon(Globals.hIcon);
            EndDialog(hDlg, FALSE);
            break;
 
        case WM_COMMAND:
        {
            switch (LOWORD(wParam))
            {
                case IDC_OK:
                case IDC_CANCEL:
                    EndDialog(hDlg, FALSE);
                    break;
 
                case IDC_LISTBOX:
                {
                    switch (HIWORD(wParam))
                    {
                        case LBN_SELCHANGE:
                        {
                            /* Retrieve the index of the current selected item */
                            INT iIndex = SendMessageW(Globals.hListDlg, LB_GETCURSEL, 0, 0);
                            if ((iIndex == LB_ERR) || (iIndex >= _countof(EntriesList)))
                                break;
 
                            /* Assign the selected index and check the utility's state */
                            Globals.iSelectedIndex = iIndex;
                            UpdateUtilityState(EntriesList[Globals.iSelectedIndex].bState);
                            break;
                        }
                        break;
                    }
                    break;
                }
 
                case IDC_START:
                    LaunchProcess(EntriesList[Globals.iSelectedIndex].lpszProgram);
                    break;
 
                case IDC_STOP:
                    CloseProcess(EntriesList[Globals.iSelectedIndex].lpszProgram);
                    break;
 
                default:
                    break;
            }
            break;
        }
 
        case WM_TIMER:
            ListBoxRefreshContents();
            return 0;
 
        case WM_SYSCOMMAND:
        {
            switch (LOWORD(wParam))
            {
                case IDM_ABOUT:
                    ShowAboutDlg(hDlg);
                    break;
            }
            break;
        }
    }
 
    return 0;
}

GetProcessID()

DWORD GetProcessID

(

IN LPCWSTR

lpszProcessName

)

@GetProcessID

Returns the process executable ID based on the given executable name.

Parameters

[in]

lpszProcessName

The name of the executable process.

Returns

Returns the ID number of the process, otherwise 0.

Definition at line 26 of file process.c.

{
    PROCESSENTRY32W Process;
 
    /* Create a snapshot and check if the given process name matches with the one from the process entry structure */
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
 
    if (hSnapshot == INVALID_HANDLE_VALUE)
        return 0;
 
    /* Get the whole size of the structure */
    Process.dwSize = sizeof(Process);
 
    /* Enumerate the processes */
    if (Process32FirstW(hSnapshot, &Process))
    {
        do
        {
            if (_wcsicmp(Process.szExeFile, lpszProcessName) == 0)
            {
                /* The names match, return the process ID we're interested */
                CloseHandle(hSnapshot);
                return Process.th32ProcessID;
            }
        }
        while (Process32NextW(hSnapshot, &Process));
    }
 
    CloseHandle(hSnapshot);
    return 0;
}

Referenced by CloseProcess(), and IsProcessRunning().

GroupBoxUpdateTitle()

VOID GroupBoxUpdateTitle

(

VOID

)

@GroupBoxUpdateTitle

Updates the title of the groupbox.

Returns

Nothing.

Definition at line 187 of file umandlg.c.

{
    WCHAR szFormat[MAX_BUFFER];
 
    /* Format the string with the utility's name and set it to the listbox's title */
    StringCchPrintfW(szFormat, _countof(szFormat), Globals.szGrpBoxTitle, EntriesList[Globals.iSelectedIndex].szResource);
    SetWindowTextW(GetDlgItem(Globals.hMainDlg, IDC_GROUPBOX), szFormat);
}

Referenced by UpdateUtilityState().

InitAppRegKey()

BOOL InitAppRegKey	(	IN HKEY	hPredefinedKey,
		IN LPCWSTR	lpszSubKey,
		OUT PHKEY	phKey,
		OUT LPDWORD	lpdwDisposition
	)

@InitAppRegKey

Initialize a key. The function may not necessarily create it but open the key if it already exists. The disposition pointed lpdwDisposition determines that. This is a function helper.

Parameters

[in]	hPredefinedKey	The predefined key (e.g. HKEY_CLASSES_ROOT).
[in]	lpszSubKey	The path to the sub key to be created.
[out]	phKey	A pointer that receives a handle to the key given by the function.
[out]	lpdwDisposition	A pointer that receives the disposition given by the function.

Returns

Returns TRUE if the function successfully created a key (or opened it), FALSE otherwise for failure.

Definition at line 50 of file registry.c.

{
    LONG lResult;
 
    lResult = RegCreateKeyExW(hPredefinedKey,
                              lpszSubKey,
                              0,
                              NULL,
                              0,
                              KEY_WRITE,
                              NULL,
                              phKey,
                              lpdwDisposition);
    if (lResult != ERROR_SUCCESS)
    {
        DPRINT("InitAppRegKey(): Failed to create the following key (or open the key) of path \"%S\". The error code is \"%li\".\n", lpszSubKey, lResult);
        return FALSE;
    }
 
    return TRUE;
}

InitUtilsList()

VOID InitUtilsList

(

IN BOOL

bInitGui

)

@InitUtilsList

Initializes the list of accessibility utilities.

Parameters

[in]

bInitGui

Whether we are initializing the UI list (TRUE) or the internal array (FALSE).

Returns

Nothing.

Definition at line 38 of file umandlg.c.

{
    UINT i;
 
    if (!bInitGui)
    {
        // TODO: Load the list dynamically from the registry key
        // hklm\software\microsoft\windows nt\currentversion\accessibility
 
        /* Initialize the resource utility strings only once */
        for (i = 0; i < _countof(EntriesList); ++i)
        {
            LoadStringW(Globals.hInstance, EntriesList[i].uNameId,
                        EntriesList[i].szResource, _countof(EntriesList[i].szResource));
 
            EntriesList[i].bState = FALSE;
        }
    }
    else
    {
        INT iItem;
        BOOL bIsRunning;
        WCHAR szFormat[MAX_BUFFER];
 
        /* Reset the listbox */
        SendMessageW(Globals.hListDlg, LB_RESETCONTENT, 0, 0);
 
        /* Add the utilities in the listbox */
        for (i = 0; i < _countof(EntriesList); ++i)
        {
            bIsRunning = IsProcessRunning(EntriesList[i].lpszProgram);
            EntriesList[i].bState = bIsRunning;
 
            /* Load the string and append the utility's name to the format */
            StringCchPrintfW(szFormat, _countof(szFormat),
                             (bIsRunning ? Globals.szRunning : Globals.szNotRunning),
                             EntriesList[i].szResource);
 
            /* Add the item in the listbox */
            iItem = (INT)SendMessageW(Globals.hListDlg, LB_ADDSTRING, 0, (LPARAM)szFormat);
            if (iItem != LB_ERR)
                SendMessageW(Globals.hListDlg, LB_SETITEMDATA, iItem, (LPARAM)&EntriesList[i]);
        }
    }
}

Referenced by DlgInitHandler(), and UManStartDlg().

IsProcessRunning()

BOOL IsProcessRunning

(

IN LPCWSTR

lpszProcessName

)

@IsProcessRunning

Checks if a process is running.

Parameters

[in]

lpszProcessName

The name of the executable process.

Returns

Returns TRUE if the given process' name is running, FALSE otherwise.

Definition at line 71 of file process.c.

{
    DWORD dwReturn, dwProcessID;
    HANDLE hProcess;
 
    /* Get the process ID */
    dwProcessID = GetProcessID(lpszProcessName);
    if (dwProcessID == 0)
    {
        return FALSE;
    }
 
    /* Synchronize the process to get its signaling state */
    hProcess = OpenProcess(SYNCHRONIZE, FALSE, dwProcessID);
    if (!hProcess)
    {
        DPRINT("IsProcessRunning(): Failed to open the process! (Error: %lu)\n", GetLastError());
        return FALSE;
    }
 
    /* Wait for the process */
    dwReturn = WaitForSingleObject(hProcess, 0);
    if (dwReturn == WAIT_TIMEOUT)
    {
        /* The process is still running */
        CloseHandle(hProcess);
        return TRUE;
    }
 
    CloseHandle(hProcess);
    return FALSE;
}

Referenced by InitUtilsList(), and ListBoxRefreshContents().

LaunchProcess()

BOOL LaunchProcess

(

IN LPCWSTR

lpszProcessName

)

@LaunchProcess

Executes a process.

Parameters

[in]

lpProcessName

The name of the executable process.

Returns

Returns TRUE if the process has been launched successfully, FALSE otherwise.

Definition at line 117 of file process.c.

{
    STARTUPINFOW si;
    PROCESS_INFORMATION pi;
    HANDLE hUserToken, hProcessToken;
    BOOL bSuccess;
    WCHAR ExpandedCmdLine[MAX_PATH];
 
    /* Expand the process path string */
    ExpandEnvironmentStringsW(lpszProcessName, ExpandedCmdLine, ARRAYSIZE(ExpandedCmdLine));
 
    ZeroMemory(&pi, sizeof(pi));
    ZeroMemory(&si, sizeof(si));
    si.cb = sizeof(si);
    si.dwFlags = STARTF_USESHOWWINDOW;
    si.wShowWindow = SW_SHOWNORMAL;
 
    /* Get the token of the parent (current) process of the application */
    bSuccess = OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY | TOKEN_DUPLICATE, &hUserToken);
    if (!bSuccess)
    {
        DPRINT("OpenProcessToken() failed with error -> %lu\n", GetLastError());
        return FALSE;
    }
 
    /* Duplicate a new token so that we can use it to create our process */
    bSuccess = DuplicateTokenEx(hUserToken, TOKEN_ALL_ACCESS, NULL, SecurityIdentification, TokenPrimary, &hProcessToken);
    if (!bSuccess)
    {
        DPRINT("DuplicateTokenEx() failed with error -> %lu\n", GetLastError());
        CloseHandle(hUserToken);
        return FALSE;
    }
 
    /* Finally create the process */
    bSuccess = CreateProcessAsUserW(hProcessToken,
                                    NULL,
                                    ExpandedCmdLine,
                                    NULL,
                                    NULL,
                                    FALSE,
                                    0, // DETACHED_PROCESS, NORMAL_PRIORITY_CLASS
                                    NULL,
                                    NULL,
                                    &si,
                                    &pi);
 
    if (!bSuccess)
    {
        DPRINT("CreateProcessAsUserW() failed with error -> %lu\n", GetLastError());
        CloseHandle(hUserToken);
        CloseHandle(hProcessToken);
        return FALSE;
    }
 
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);
    CloseHandle(hUserToken);
    CloseHandle(hProcessToken);
    return TRUE;
}

Referenced by DlgProc().

ListBoxRefreshContents()

INT ListBoxRefreshContents

(

VOID

)

@ListBoxRefreshContents

Handle the tasks on a periodic cycle. This function handles WM_TIMER message.

Returns

Returns 0 to inform the system that WM_TIMER has been processed.

Definition at line 226 of file umandlg.c.

{
    UINT i;
    INT iItem;
    BOOL bIsRunning;
    WCHAR szFormat[MAX_BUFFER];
 
    /* Disable listbox redraw */
    SendMessageW(Globals.hListDlg, WM_SETREDRAW, FALSE, 0);
 
    for (i = 0; i < _countof(EntriesList); ++i)
    {
        /* Check the utility's state */
        bIsRunning = IsProcessRunning(EntriesList[i].lpszProgram);
        if (bIsRunning != EntriesList[i].bState)
        {
            /* The utility's state has changed, save it */
            EntriesList[i].bState = bIsRunning;
 
            /* Update the corresponding item in the listbox */
            StringCchPrintfW(szFormat, _countof(szFormat),
                             (bIsRunning ? Globals.szRunning : Globals.szNotRunning),
                             EntriesList[i].szResource);
 
            SendMessageW(Globals.hListDlg, LB_DELETESTRING, (LPARAM)i, 0);
            iItem = SendMessageW(Globals.hListDlg, LB_INSERTSTRING, (LPARAM)i, (LPARAM)szFormat);
            if (iItem != LB_ERR)
                SendMessageW(Globals.hListDlg, LB_SETITEMDATA, iItem, (LPARAM)&EntriesList[i]);
        }
    }
 
    /* Re-enable listbox redraw */
    SendMessageW(Globals.hListDlg, WM_SETREDRAW, TRUE, 0);
 
    /*
     * Check the previously selected item. This will help us determine what
     * item has been selected and set its focus selection back. Furthermore, check
     * the state of each accessibility tool and enable/disable the buttons.
     */
    SendMessageW(Globals.hListDlg, LB_SETCURSEL, (WPARAM)Globals.iSelectedIndex, 0);
    UpdateUtilityState(EntriesList[Globals.iSelectedIndex].bState);
 
    return 0;
}

Referenced by DlgInitHandler(), and DlgProc().

QueryAppSettings()

BOOL QueryAppSettings	(	IN HKEY	hKey,
		IN LPCWSTR	lpszSubKey,
		IN LPCWSTR	lpszRegValue,
		OUT PVOID	ReturnedData,
		IN OUT LPDWORD	lpdwSizeData
	)

@QueryAppSettings

Query the setting from the application's key. This is a function helper.

Parameters

[in]	hKey	A handle to a key.
[in]	lpszSubKey	The path to a sub-key.
[in]	lpszRegValue	The registry value where we need to get the data from.
[out]	ReturnedData	An arbitrary pointer that receives the returned data. Being arbitrary, the data can be of any type.
[in,out]	lpdwSizeData	A pointer to the returned data pointed by ReturnedData parameter that retrieves the size of the aforementioned data, in bytes.

Returns

Returns TRUE if the function successfully loaded the value we wanted, FALSE otherwise for failure.

Definition at line 102 of file registry.c.

{
    LONG lResult;
    HKEY hKeyQueryValue;
 
    lResult = RegOpenKeyExW(hKey,
                            lpszSubKey,
                            0,
                            KEY_READ,
                            &hKeyQueryValue);
    if (lResult != ERROR_SUCCESS)
    {
        DPRINT("QueryAppSettings(): Failed to open the key of path \"%S\". The error code is \"%li\".\n", lpszSubKey, lResult);
        return FALSE;
    }
 
    lResult = RegQueryValueExW(hKeyQueryValue,
                               lpszRegValue,
                               NULL,
                               NULL,
                               (LPBYTE)&ReturnedData,
                               lpdwSizeData);
    if (lResult != ERROR_SUCCESS)
    {
        DPRINT("QueryAppSettings(): Failed to query the data from value \"%S\". The error code is \"%li\".\n", lpszRegValue, lResult);
        RegCloseKey(hKeyQueryValue);
        return FALSE;
    }
 
    RegCloseKey(hKeyQueryValue);
    return TRUE;
}

SaveAppSettings()

BOOL SaveAppSettings	(	IN HKEY	hKey,
		IN LPCWSTR	lpszRegValue,
		IN DWORD	dwRegType,
		IN PVOID	Data,
		IN DWORD	cbSize
	)

@SaveAppSettings

Save an application's setting data to the Registry. This is a function helper.

Parameters

[in]	hKey	A handle to a key.
[in]	lpszRegValue	The path to the sub key where the value needs to be created.
[out]	dwRegType	The type of registry value to be created (e.g. a REG_DWORD).
[in]	Data	A pointer to an arbitrary data for the value to be set. Being arbitrary, the data can be of any type (in conformity with the registry type pointed by dwRegType) otherwise the function might lead to a undefined behaviour.
[in]	cbSize	The size of the buffer data pointed by Data parameter, in bytes.

Returns

Returns TRUE if the function successfully saved the application's setting, FALSE otherwise for failure.

Definition at line 166 of file registry.c.

{
    LONG lResult;
    HKEY hKeySetValue;
 
    lResult = RegOpenKeyExW(hKey,
                            NULL,
                            0,
                            KEY_SET_VALUE,
                            &hKeySetValue);
    if (lResult != ERROR_SUCCESS)
    {
        DPRINT("SaveAppSettings(): Failed to open the key, the error code is \"%li\"!\n", lResult);
        return FALSE;
    }
 
    lResult = RegSetValueExW(hKeySetValue,
                             lpszRegValue,
                             0,
                             dwRegType,
                             (LPBYTE)&Data,
                             cbSize);
    if (lResult != ERROR_SUCCESS)
    {
        DPRINT("SaveAppSettings(): Failed to set the \"%S\" value with data, the error code is \"%li\"!\n", lpszRegValue, lResult);
        RegCloseKey(hKeySetValue);
        return FALSE;
    }
 
    RegCloseKey(hKeySetValue);
    return TRUE;
}

ShowAboutDlg()

VOID ShowAboutDlg

(

IN HWND

hDlgParent

)

@ShowAboutDlg

Displays the Shell "About" dialog box.

Parameters

[in]

hDlgParent

A handle to the parent dialog window.

Returns

Nothing.

Definition at line 167 of file umandlg.c.

{
    WCHAR szApp[MAX_BUFFER];
    WCHAR szAuthors[MAX_BUFFER];
 
    LoadStringW(Globals.hInstance, IDS_APP_NAME, szApp, _countof(szApp));
    LoadStringW(Globals.hInstance, IDS_AUTHORS, szAuthors, _countof(szAuthors));
 
    ShellAboutW(hDlgParent, szApp, szAuthors, Globals.hIcon);
}

Referenced by DlgProc().

UManStartDlg()

BOOL WINAPI UManStartDlg

(

VOID

)

@UManStartDlg

Executes the dialog initialization mechanism and starts Utility Manager. The function is exported for use by the main process.

Returns

Returns TRUE when the operation has succeeded, FALSE otherwise.

Definition at line 383 of file umandlg.c.

{
    HANDLE hMutex;
    DWORD dwError;
    INITCOMMONCONTROLSEX iccex;
 
    /* Create a mutant object for the program. */
    hMutex = CreateMutexW(NULL, FALSE, L"Utilman");
    if (hMutex)
    {
        /* Check if there's already a mutex for the program */
        dwError = GetLastError();
        if (dwError == ERROR_ALREADY_EXISTS)
        {
            /*
                The program's instance is already here. That means
                the program is running and we should not set a new instance
                and mutex object.
            */
            CloseHandle(hMutex);
            return FALSE;
        }
    }
 
    /* Load the common controls for the program */
    iccex.dwSize = sizeof(INITCOMMONCONTROLSEX);
    iccex.dwICC = ICC_STANDARD_CLASSES | ICC_WIN95_CLASSES;
    InitCommonControlsEx(&iccex);
 
    LoadStringW(Globals.hInstance, IDS_RUNNING,
                Globals.szRunning, _countof(Globals.szRunning));
    LoadStringW(Globals.hInstance, IDS_NOTRUNNING,
                Globals.szNotRunning, _countof(Globals.szNotRunning));
    LoadStringW(Globals.hInstance, IDS_GROUPBOX_OPTIONS_TITLE,
                Globals.szGrpBoxTitle, _countof(Globals.szGrpBoxTitle));
 
    /* Initialize the list of accessibility utilities */
    InitUtilsList(FALSE);
 
    /* Create the dialog box of the program */
    DialogBoxW(Globals.hInstance,
               MAKEINTRESOURCEW(IDD_MAIN_DIALOG),
               GetDesktopWindow(),
               DlgProc);
 
    /* Delete the mutex */
    if (hMutex)
    {
        CloseHandle(hMutex);
    }
 
    return TRUE;
}

Referenced by wWinMain().

UpdateUtilityState()

VOID UpdateUtilityState

(

IN BOOL

bUtilState

)

@UpdateUtilityState

Checks the state of the given accessibility tool.

Parameters

[in]

bUtilState

State condition (boolean TRUE: started / FALSE: stopped).

Returns

Nothing.

Definition at line 208 of file umandlg.c.

{
    Button_Enable(Globals.hDlgCtlStart, !bUtilState);
    Button_Enable(Globals.hDlgCtlStop,   bUtilState);
 
    /* Update the groupbox's title based on the selected utility item */
    GroupBoxUpdateTitle();
}

Referenced by DlgProc(), and ListBoxRefreshContents().

Variable Documentation

Globals

UTILMAN_GLOBALS Globals

extern

Definition at line 13 of file clipbrd.c.

RegData

REGISTRY_DATA RegData

extern

Definition at line 14 of file registry.c.

Settings

REGISTRY_SETTINGS Settings

extern

Definition at line 25 of file charmap.c.