umandlg.c File Reference

#include "umandlg.h"

Include dependency graph for umandlg.c:

Go to the source code of this file.

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	ListBoxRefreshContents (VOID)
INT_PTR APIENTRY	DlgProc (IN HWND hDlg, IN UINT Msg, IN WPARAM wParam, IN LPARAM lParam)
BOOL WINAPI	UManStartDlg (VOID)
BOOL WINAPI	DllMain (IN HINSTANCE hDllInstance, IN DWORD fdwReason, IN LPVOID lpvReserved)

Variables
UTILMAN_GLOBALS	Globals
UTILMAN_STATE	EntriesList []

Function Documentation

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;
}

DllMain()

BOOL WINAPI DllMain	(	IN HINSTANCE	hDllInstance,
		IN DWORD	fdwReason,
		IN LPVOID	lpvReserved
	)

@DllMain

Core routine of the Utility Manager's library.

Parameters

[in]	hDllInstance	The entry point instance of the library.
[in]	fdwReason	The reason argument to indicate the motive DllMain is being called.
[in]	lpvReserved	Reserved.

Returns

Returns TRUE when main call initialization has succeeded, FALSE otherwise.

Definition at line 457 of file umandlg.c.

{
    switch (fdwReason)
    {
        case DLL_PROCESS_ATTACH:
        {
            /* We don't care for DLL_THREAD_ATTACH and DLL_THREAD_DETACH notifications */
            DisableThreadLibraryCalls(hDllInstance);
 
            /* Initialize the globals */
            ZeroMemory(&Globals, sizeof(Globals));
            Globals.hInstance = hDllInstance;
            break;
        }
 
        case DLL_PROCESS_DETACH:
            break;
    }
 
    return TRUE;
}

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().

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().

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().

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

EntriesList

UTILMAN_STATE EntriesList[]

Initial value:

=
{
    {L"magnify.exe", IDS_MAGNIFIER, L"", FALSE},
    {L"osk.exe", IDS_OSK, L"", FALSE}
}

Definition at line 19 of file umandlg.c.

Referenced by DlgProc(), GroupBoxUpdateTitle(), InitUtilsList(), and ListBoxRefreshContents().

Globals

UTILMAN_GLOBALS Globals

Definition at line 15 of file umandlg.c.

Referenced by DlgInitHandler(), DlgProc(), DllMain(), GroupBoxUpdateTitle(), InitUtilsList(), ListBoxRefreshContents(), ShowAboutDlg(), UManStartDlg(), and UpdateUtilityState().