progress.c File Reference

#include "precomp.h"
#include <process.h>

Include dependency graph for progress.c:

Go to the source code of this file.

Classes
struct	_PROGRESS_DATA

Macros
#define	PROGRESS_RANGE   20
#define	PROGRESS_STEP_MAX   15

Typedefs
typedef struct _PROGRESS_DATA	PROGRESS_DATA
typedef struct _PROGRESS_DATA *	PPROGRESS_DATA

Functions
VOID	ShowError (DWORD dwLastError)
static VOID	ResetProgressDialog (HWND hDlg, LPWSTR ServiceName, ULONG LabelId)
unsigned int __stdcall	ActionThread (void *Param)
static BOOL	InitProgressDialog (HWND hDlg, UINT Message, WPARAM wParam, LPARAM lParam)
INT_PTR CALLBACK	ProgressDialogProc (HWND hDlg, UINT Message, WPARAM wParam, LPARAM lParam)
VOID	CompleteProgressBar (HANDLE hProgress)
VOID	IncrementProgressBar (HANDLE hProgress, UINT Step)
BOOL	RunActionWithProgress (HWND hParent, LPWSTR ServiceName, LPWSTR DisplayName, UINT Action, PVOID Param)

Macro Definition Documentation

PROGRESS_RANGE

#define PROGRESS_RANGE   20

Definition at line 14 of file progress.c.

PROGRESS_STEP_MAX

#define PROGRESS_STEP_MAX   15

Definition at line 15 of file progress.c.

Typedef Documentation

PPROGRESS_DATA

typedef struct _PROGRESS_DATA * PPROGRESS_DATA

PROGRESS_DATA

typedef struct _PROGRESS_DATA PROGRESS_DATA

Function Documentation

ActionThread()

unsigned int __stdcall ActionThread

(

void *

Param

)

Definition at line 86 of file progress.c.

{
    PPROGRESS_DATA ProgressData = (PPROGRESS_DATA)Param;
    DWORD dwResult;
 
    if (ProgressData->Action == ACTION_START)
    {
        /* Setup the progress dialog for this action */
        ResetProgressDialog(ProgressData->hDlg,
                            ProgressData->ServiceName,
                            IDS_PROGRESS_INFO_START);
 
        /* Start the service */
        dwResult = DoStartService(ProgressData->ServiceName,
                                  ProgressData->hProgress,
                                  ProgressData->Param);
        if (dwResult == ERROR_SUCCESS)
        {
            /* We're done, slide the progress bar up to the top */
            CompleteProgressBar(ProgressData->hProgress);
        }
        else
        {
            ShowError(dwResult);
        }
    }
    else if (ProgressData->Action == ACTION_STOP || ProgressData->Action == ACTION_RESTART)
    {
        /* Check if there are and dependants to stop */
        if (ProgressData->StopDepends && ProgressData->ServiceList)
        {
            LPWSTR lpStr = ProgressData->ServiceList;
 
            /* Loop through all the services in the list */
            for (;;)
            {
                /* Break when we hit the double null */
                if (*lpStr == L'\0' && *(lpStr + 1) == L'\0')
                    break;
 
                /* If this isn't our first time in the loop we'll
                have been left on a null char */
                if (*lpStr == L'\0')
                    lpStr++;
 
                ResetProgressDialog(ProgressData->hDlg,
                                    lpStr,
                                    IDS_PROGRESS_INFO_STOP);
 
                /* Stop the requested service */
                dwResult = DoStopService(ProgressData->ServiceName,
                                         ProgressData->hProgress);
                if (dwResult == ERROR_SUCCESS)
                {
                    CompleteProgressBar(ProgressData->hProgress);
                }
                else
                {
                    ShowError(dwResult);
                }
 
                /* Move onto the next string */
                while (*lpStr != L'\0')
                    lpStr++;
            }
        }
 
        ResetProgressDialog(ProgressData->hDlg,
                            ProgressData->ServiceName,
                            IDS_PROGRESS_INFO_STOP);
 
        dwResult = DoStopService(ProgressData->ServiceName,
                                 ProgressData->hProgress);
        if (dwResult == ERROR_SUCCESS)
        {
            CompleteProgressBar(ProgressData->hProgress);
        }
        else
        {
            ShowError(dwResult);
        }
 
 
        /* If this was a restart, we'll need to start the service back up */
        if (ProgressData->Action == ACTION_RESTART)
        {
            /* Setup the progress dialog for this action */
            ResetProgressDialog(ProgressData->hDlg,
                                ProgressData->ServiceName,
                                IDS_PROGRESS_INFO_START);
 
            /* Start the service */
            dwResult = DoStartService(ProgressData->ServiceName,
                                      ProgressData->hProgress,
                                      NULL);
            if (dwResult == ERROR_SUCCESS)
            {
                /* We're done, slide the progress bar up to the top */
                CompleteProgressBar(ProgressData->hProgress);
            }
            else
            {
                ShowError(dwResult);
            }
        }
    }
    else if (ProgressData->Action == ACTION_PAUSE)
    {
        /* Setup the progress dialog for this action */
        ResetProgressDialog(ProgressData->hDlg,
                            ProgressData->ServiceName,
                            IDS_PROGRESS_INFO_PAUSE);
 
        /* Pause the service */
        dwResult = DoControlService(ProgressData->ServiceName,
                                    ProgressData->hProgress,
                                    SERVICE_CONTROL_PAUSE);
        if (dwResult == ERROR_SUCCESS)
        {
            /* We're done, slide the progress bar up to the top */
            CompleteProgressBar(ProgressData->hProgress);
        }
        else
        {
            ShowError(dwResult);
        }
    }
    else if (ProgressData->Action == ACTION_RESUME)
    {
        /* Setup the progress dialog for this action */
        ResetProgressDialog(ProgressData->hDlg,
                            ProgressData->ServiceName,
                            IDS_PROGRESS_INFO_RESUME);
 
        /* resume the service */
        dwResult = DoControlService(ProgressData->ServiceName,
                                    ProgressData->hProgress,
                                    SERVICE_CONTROL_CONTINUE);
        if (dwResult == ERROR_SUCCESS)
        {
            /* We're done, slide the progress bar up to the top */
            CompleteProgressBar(ProgressData->hProgress);
        }
        else
        {
            ShowError(dwResult);
        }
    }
 
 
    EndDialog(ProgressData->hDlg, IDOK);
 
    _endthreadex(0);
    return 0;
}

Referenced by InitProgressDialog().

CompleteProgressBar()

VOID CompleteProgressBar

(

HANDLE

hProgress

)

Definition at line 311 of file progress.c.

{
    HWND hProgBar = (HWND)hProgress;
    UINT Pos = 0;
 
    /* Get the current position */
    Pos = SendMessageW(hProgBar,
                       PBM_GETPOS,
                       0,
                       0);
 
    /* Loop until we hit the max */
    while (Pos <= PROGRESS_RANGE)
    {
        /* Increment the progress bar */
        SendMessageW(hProgBar,
                     PBM_DELTAPOS,
                     Pos,
                     0);
 
        /* Wait for 15ms to give it a smooth feel */
        Sleep(15);
        Pos++;
    }
}

Referenced by ActionThread().

IncrementProgressBar()

VOID IncrementProgressBar	(	HANDLE	hProgress,
		UINT	Step
	)

Definition at line 338 of file progress.c.

{
    HWND hProgBar = (HWND)hProgress;
    UINT Position;
 
    /* Don't allow the progress to reach to complete*/
    Position = SendMessageW(hProgBar,
                            PBM_GETPOS,
                            0,
                            0);
    if (Position < PROGRESS_STEP_MAX)
    {
        /* Do we want to increment the default amount? */
        if (Step == DEFAULT_STEP)
        {
            /* Use the step value we set on create */
            SendMessageW(hProgBar,
                         PBM_STEPIT,
                         0,
                         0);
        }
        else
        {
            /* Use the value passed */
            SendMessageW(hProgBar,
                         PBM_SETPOS,
                         Step,
                         0);
        }
    }
}

Referenced by DoControlService(), DoStartService(), and DoStopService().

InitProgressDialog()

static BOOL InitProgressDialog ( HWND  hDlg, UINT  Message, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 243 of file progress.c.

{
    PPROGRESS_DATA ProgressData = (PPROGRESS_DATA)lParam;
    HANDLE hThread;
 
    ProgressData->hDlg = hDlg;
 
    /* Get a handle to the progress bar */
    ProgressData->hProgress = GetDlgItem(hDlg,
                                         IDC_SERVCON_PROGRESS);
    if (!ProgressData->hProgress)
        return FALSE;
 
    /* Set the progress bar range */
    SendMessageW(ProgressData->hProgress,
                 PBM_SETRANGE,
                 0,
                 MAKELPARAM(0, PROGRESS_RANGE));
 
    /* Set the progress bar step */
    SendMessageW(ProgressData->hProgress,
                 PBM_SETSTEP,
                 (WPARAM)1,
                 0);
 
    /* Create a thread to handle the service control */
    hThread = (HANDLE)_beginthreadex(NULL, 0, &ActionThread, ProgressData, 0, NULL);
    if (!hThread) return FALSE;
 
    CloseHandle(hThread);
 
    return TRUE;
}

Referenced by ProgressDialogProc().

ProgressDialogProc()

INT_PTR CALLBACK ProgressDialogProc	(	HWND	hDlg,
		UINT	Message,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 281 of file progress.c.

{
    switch(Message)
    {
        case WM_INITDIALOG:
        {
            return InitProgressDialog(hDlg, Message, wParam, lParam);
        }
 
        case WM_COMMAND:
            switch(LOWORD(wParam))
            {
                case IDOK:
                    EndDialog(hDlg, wParam);
                    break;
 
            }
            break;
 
        default:
            return FALSE;
    }
 
    return TRUE;
}

Referenced by RunActionWithProgress().

ResetProgressDialog()

static VOID ResetProgressDialog ( HWND  hDlg, LPWSTR  ServiceName, ULONG  LabelId  )

static

Definition at line 50 of file progress.c.

{
    LPWSTR lpProgStr;
 
    /* Load the label Id */
    if (AllocAndLoadString(&lpProgStr,
                           hInstance,
                           LabelId))
    {
        /* Write it to the dialog */
        SendDlgItemMessageW(hDlg,
                            IDC_SERVCON_INFO,
                            WM_SETTEXT,
                            0,
                            (LPARAM)lpProgStr);
 
        LocalFree(lpProgStr);
    }
 
    /* Write the service name to the dialog */
    SendDlgItemMessageW(hDlg,
                        IDC_SERVCON_NAME,
                        WM_SETTEXT,
                        0,
                        (LPARAM)ServiceName);
 
    /* Set the progress bar to the start */
    SendDlgItemMessageW(hDlg,
                        IDC_SERVCON_PROGRESS,
                        PBM_SETPOS,
                        0,
                        0);
}

Referenced by ActionThread().

RunActionWithProgress()

BOOL RunActionWithProgress	(	HWND	hParent,
		LPWSTR	ServiceName,
		LPWSTR	DisplayName,
		UINT	Action,
		PVOID	Param
	)

Definition at line 372 of file progress.c.

{
    PROGRESS_DATA ProgressData;
    LPWSTR ServiceList;
    BOOL StopDepends;
    INT_PTR Result;
 
    StopDepends = FALSE;
    ServiceList = NULL;
 
 
    /* Check if we'll be stopping the service */
    if (Action == ACTION_STOP || Action == ACTION_RESTART)
    {
        /* Does the service have any dependent services which need stopping first */
        ServiceList = GetListOfServicesToStop(ServiceName);
        if (ServiceList)
        {
            /* Ask the user if they want to stop the dependants */
            StopDepends = CreateStopDependsDialog(hParent,
                                                  ServiceName,
                                                  DisplayName,
                                                  ServiceList);
 
            /* Exit early if the user decided not to stop the dependants */
            if (StopDepends == FALSE)
            {
                HeapFree(GetProcessHeap(), 0, ServiceList);
                return FALSE;
            }
        }
    }
 
    ProgressData.hDlg = NULL;
    ProgressData.ServiceName = ServiceName;
    ProgressData.Action = Action;
    ProgressData.StopDepends = StopDepends;
    ProgressData.ServiceList = ServiceList;
    ProgressData.Param = Param;
 
    Result = DialogBoxParamW(hInstance,
                             MAKEINTRESOURCEW(IDD_DLG_PROGRESS),
                             hParent,
                             ProgressDialogProc,
                             (LPARAM)&ProgressData);
 
    if (ServiceList)
        HeapFree(GetProcessHeap(), 0, ServiceList);
 
    return (Result == IDOK);
}

Referenced by GeneralPageProc(), and MainWndCommand().

ShowError()

VOID ShowError

(

DWORD

dwLastError

)

Definition at line 29 of file progress.c.

{
    LPWSTR lpMsg;
 
    if (!FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                        FORMAT_MESSAGE_FROM_SYSTEM |
                        FORMAT_MESSAGE_IGNORE_INSERTS,
                        NULL,
                        dwLastError,
                        LANG_USER_DEFAULT,
                        (LPWSTR)&lpMsg,
                        0, NULL))
    {
        return;
    }
 
    MessageBoxW(NULL, lpMsg, NULL, MB_OK | MB_ICONERROR);
    LocalFree(lpMsg);
}

Referenced by ActionThread(), DoLoadImageFile(), CMainWindow::OnCommand(), and SaveDIBToFile().