driverdlg.c

来自「Virtual Floppy Driver」· C语言 代码 · 共 1,037 行 · 第 1/2 页

	}

	if (driver_state == VFD_NOT_INSTALLED) {
		if (!DriverInstall(hDlg)) {
			return;
		}
	}

	//
	//	start the driver
	//
	if (DriverStart(hDlg)) {
		SendMessage(hButton, BM_SETSTYLE, BS_PUSHBUTTON, TRUE);
		SetFocus(GetDlgItem(hDlg, IDC_DRIVER_STOP));
	}
}

//
//	stop button is clicked
//
void OnDriverStop(HWND hDlg, HWND hButton)
{
	DWORD	ret;

	//
	//	ensure that the drive is empty
	//
	ret = VfdGetMediaState();

	if (ret == ERROR_SUCCESS || ret == ERROR_WRITE_PROTECT) {
		ret = EnsureUnmount(
			(ENSURE_CALLBACK)Retry_Callback,
			(ENSURE_CALLBACK)AskForceStop,
			(DWORD)hDlg);

		if (ret != ERROR_SUCCESS && ret != ERROR_NOT_READY) {
			AppendMessage(hDlg, IDS_ERR_IMAGE_UNMOUNT, ret);
			return;
		}
	}
	else if (ret != ERROR_NOT_READY) {
		AppendMessage(hDlg, IDS_ERR_DRIVER_STOP, ret);
		return;
	}

	//
	//	stop the driver
	//
	if (DriverStop(hDlg)) {
		SendMessage(hButton, BM_SETSTYLE, BS_PUSHBUTTON, TRUE);
		SetFocus(GetDlgItem(hDlg, IDC_DRIVER_START));
	}
}

//
//	Mounts an image file
//
BOOL ImageMount(HWND hDlg)
{
	TCHAR	drive_letter[5];
	TCHAR	image_path[MAX_PATH];
	ULONG	image_size;
	BOOL	read_only;
	DWORD	ret;

	//
	//	get dialog data
	//
	if (!GetDlgItemText(hDlg, IDC_IMAGE_PATH, image_path, sizeof(image_path))) {
		ret = GetLastError();
		goto error_exit;
	}

	read_only =	(IsDlgButtonChecked(hDlg, IDC_IMAGE_READONLY) == BST_CHECKED);

	if (IsDlgButtonChecked(hDlg, IDC_IMAGE_720KB) == BST_CHECKED) {
		image_size = VFD_FILESIZE_720KB;
	}
	else if (IsDlgButtonChecked(hDlg, IDC_IMAGE_2P88MB) == BST_CHECKED) {
		image_size = VFD_FILESIZE_2P88MB;
	}
	else {
		image_size = VFD_FILESIZE_1P44MB;
	}

	if (!GetDlgItemText(hDlg, IDC_IMAGE_DRIVE, drive_letter, sizeof(drive_letter))) {
		ret = GetLastError();
		goto error_exit;
	}

	//
	//	assign a drive letter
	//
	if (!isalpha(drive_letter[0])) {
		ret = ERROR_INVALID_DATA;
		goto error_exit;
	}

	if ((ret = VfdSetDriveLetter(drive_letter[0])) != ERROR_SUCCESS) {
		goto error_exit;
	}

	//
	//	mount the image file
	//

	if ((ret = VfdMount(image_path, read_only, image_size)) != ERROR_SUCCESS) {
		goto error_exit;
	}

	return TRUE;

error_exit:
	AppendMessage(hDlg, IDS_ERR_IMAGE_MOUNT, ret);
	return FALSE;
}

//
//	Install the driver
//
BOOL DriverInstall(HWND hDlg)
{
	TCHAR	driver_path[MAX_PATH];
	BOOL	auto_start;
	DWORD	ret;

	//
	//	get dialog data
	//
	if (!GetDlgItemText(hDlg, IDC_DRIVER_PATH, driver_path, sizeof(driver_path))) {
		ret = GetLastError();
		goto error_exit;
	}

	auto_start = (IsDlgButtonChecked(hDlg, IDC_DRIVER_AUTO) == BST_CHECKED);

	//
	//	install the driver
	//
	if ((ret = VfdInstall(driver_path, auto_start)) != ERROR_SUCCESS) {
		goto error_exit;
	}

	return TRUE;

error_exit:
	AppendMessage(hDlg, IDS_ERR_DRIVER_INSTALL, ret);
	return FALSE;
}

//
//	Remove the driver
//
BOOL DriverRemove(HWND hDlg)
{
	DWORD ret;

	ret = VfdRemove();

	if (ret == ERROR_SUCCESS) {
		return TRUE;
	}
	else {
		DEBUG_TRACE1("DriverRemove: VfdRemove - %s", ErrMsg(ret));
		AppendMessage(hDlg, IDS_ERR_DRIVER_REMOVE, ret);
		return FALSE;
	}
}

//
//	start the driver
//
BOOL DriverStart(HWND hDlg)
{
	DWORD ret;

	if ((ret = VfdStart(NULL)) == ERROR_SUCCESS) {
		return TRUE;
	}
	else {
		DEBUG_TRACE1("DriverStart: VfdStart - %s", ErrMsg(ret));
		AppendMessage(hDlg, IDS_ERR_DRIVER_START, ret);
		return FALSE;
	}
}

//
//	stop the driver
//
BOOL DriverStop(HWND hDlg)
{
	DWORD ret;

	ret = VfdStop(NULL);

	if (ret == ERROR_SUCCESS) {
		return TRUE;
	}
	else {
		DEBUG_TRACE1("DriverStop: VfdStop - %s", ErrMsg(ret));
		AppendMessage(hDlg, IDS_ERR_DRIVER_STOP, ret);
		return FALSE;
	}
}

//
//	Refresh the Drive dialog
//
void OnDriveRefresh	(HWND hDlg, WPARAM reason, DWORD driver_state)
{
	BOOL	install, remove, start, stop, mount, unmount;
	DWORD	media_state = ERROR_NOT_READY;
	DWORD	ret;

	//
	//	Get driver and image information
	//
	if (driver_state == 0) {
		ret = VfdGetDriverState(&driver_state);

		if (ret != ERROR_SUCCESS) {
			DEBUG_TRACE1("OnVfdRefresh : VfdGetDriverState - %s", ErrMsg(ret));
			return;
		}
	}

	if (driver_state != VFD_NOT_INSTALLED) {
		TCHAR	driver_path[MAX_PATH];
		DWORD	start_type;

		//	controls for installing will be disabled and
		//	controls for removing will be enabled
		install	= FALSE;
		remove	= TRUE;

		//	get driver configuration
		ret = VfdGetDriverConfig(driver_path, &start_type);

		if (ret == ERROR_SUCCESS) {
			//	set driver path edit
			SetDlgItemText(hDlg, IDC_DRIVER_PATH, driver_path);

			//	set start type radio button
			switch (start_type) {
			case SERVICE_AUTO_START:
				CheckRadioButton(hDlg, IDC_DRIVER_MANUAL, IDC_DRIVER_AUTO, IDC_DRIVER_AUTO);
				break;

			case SERVICE_DEMAND_START:
				CheckRadioButton(hDlg, IDC_DRIVER_MANUAL, IDC_DRIVER_AUTO, IDC_DRIVER_MANUAL);
				break;
			}
		}
		else {
			DEBUG_TRACE1("OnDriveRefresh: VfdGetDriverConfig - %s", ErrMsg(ret));
		}

		if (driver_state == SERVICE_RUNNING) {
			//	start control will be disabled and stop control will be enabled
			start	= FALSE;
			stop	= TRUE;

			//	get current media state
			media_state = VfdGetMediaState();

			if (media_state == ERROR_SUCCESS || media_state == ERROR_WRITE_PROTECT) {
				TCHAR	drive_letter[]	= " :";
				TCHAR	image_path[MAX_PATH];
				ULONG	image_size;
				BOOL	read_only;

				//	controls for mounting will be disabled and
				//	controls for unmounting will be enabled
				mount	= FALSE;
				unmount = TRUE;

				//	get current drive letter
				ret = VfdGetDriveLetter(&drive_letter[0]);

				if (ret == ERROR_SUCCESS) {
					//	set drive letter combo
					SendDlgItemMessage(hDlg, IDC_IMAGE_DRIVE,
						CB_SELECTSTRING, 0, (LPARAM)drive_letter);
				}
				else {
					DEBUG_TRACE1("OnDriveRefresh: VfdGetDriveLetter - %s", ErrMsg(ret));
				}

				//	get current image info
				ret = VfdGetFileInfo(image_path, &image_size, &read_only);

				if (ret == ERROR_SUCCESS) {
					//	set image path edit
					SetDlgItemText(hDlg, IDC_IMAGE_PATH, image_path);

					//	set read-only check button
					CheckDlgButton(hDlg, IDC_IMAGE_READONLY, read_only ? BST_CHECKED : BST_UNCHECKED);

					//	set image size radio button
					switch(image_size) {
					case VFD_FILESIZE_720KB:
						CheckRadioButton(hDlg, IDC_IMAGE_720KB, IDC_IMAGE_2P88MB, IDC_IMAGE_720KB);
						break;

					case VFD_FILESIZE_1P44MB:
						CheckRadioButton(hDlg, IDC_IMAGE_720KB, IDC_IMAGE_2P88MB, IDC_IMAGE_1P44MB);
						break;

					case VFD_FILESIZE_2P88MB:
						CheckRadioButton(hDlg, IDC_IMAGE_720KB, IDC_IMAGE_2P88MB, IDC_IMAGE_2P88MB);
						break;
					}
				}
				else {
					DEBUG_TRACE1("OnDriveRefresh: VfdGetFileInfo - %s", ErrMsg(ret));
				}

			}
			else {
				mount	= TRUE;
				unmount	= FALSE;
			}
		}
		else if (driver_state == SERVICE_STOPPED ||
			driver_state == SERVICE_PAUSED) {
			//	The driver is not running and can be started
			start	= TRUE;
			stop	= FALSE;
			mount	= TRUE;
			unmount	= FALSE;
		}
		else {
			//	The driver is in pending state - cannot be started nor stopped
			start	= FALSE;
			stop	= FALSE;
			mount	= FALSE;
			unmount	= FALSE;
		}
	}
	else {
		//	The driver is not installed
		install	= TRUE;
		remove	= FALSE;
		start	= TRUE;
		stop	= FALSE;
		mount	= TRUE;
		unmount	= FALSE;
	}

	//
	//	enable / disable controls according to current state
	//
	SendDlgItemMessage(hDlg, IDC_IMAGE_PATH, EM_SETREADONLY, !mount, 0);
	EnableWindow(GetDlgItem(hDlg, IDC_IMAGE_BROWSE),	mount);
	EnableWindow(GetDlgItem(hDlg, IDC_IMAGE_READONLY),	mount);
	EnableWindow(GetDlgItem(hDlg, IDC_IMAGE_720KB),		mount);
	EnableWindow(GetDlgItem(hDlg, IDC_IMAGE_1P44MB),	mount);
	EnableWindow(GetDlgItem(hDlg, IDC_IMAGE_2P88MB),	mount);
	EnableWindow(GetDlgItem(hDlg, IDC_IMAGE_DRIVE),		mount);

	EnableWindow(GetDlgItem(hDlg, IDC_IMAGE_MOUNT),
		mount && GetWindowTextLength(GetDlgItem(hDlg, IDC_IMAGE_PATH)));

	EnableWindow(GetDlgItem(hDlg, IDC_IMAGE_UNMOUNT),	unmount);

	SendDlgItemMessage(hDlg, IDC_DRIVER_PATH, EM_SETREADONLY, !install, 0);
	EnableWindow(GetDlgItem(hDlg, IDC_DRIVER_BROWSE),	install);
	EnableWindow(GetDlgItem(hDlg, IDC_DRIVER_MANUAL),	install);
	EnableWindow(GetDlgItem(hDlg, IDC_DRIVER_AUTO),		install);
	EnableWindow(GetDlgItem(hDlg, IDC_DRIVER_INSTALL),
		install && GetWindowTextLength(GetDlgItem(hDlg, IDC_DRIVER_PATH)));

	EnableWindow(GetDlgItem(hDlg, IDC_DRIVER_START),	start);
	EnableWindow(GetDlgItem(hDlg, IDC_DRIVER_STOP),		stop);
	EnableWindow(GetDlgItem(hDlg, IDC_DRIVER_REMOVE),	remove);

	//
	//	Show reason of refresh
	//
	if (reason) {
		UINT	msg = 0;

		switch (reason) {
		case VFD_OPERATION_INSTALL:
			if (driver_state != VFD_NOT_INSTALLED) {
				msg = IDS_MSG_DRIVER_INSTALLED;
			}
			break;

		case VFD_OPERATION_REMOVE:
			if (driver_state == VFD_NOT_INSTALLED) {
				msg = IDS_MSG_DRIVER_REMOVED;
			}
			break;

		case VFD_OPERATION_START:
			if (driver_state == SERVICE_RUNNING) {
				msg = IDS_MSG_DRIVER_STARTED;
			}
			break;

		case VFD_OPERATION_STOP:
			if (driver_state == SERVICE_STOPPED || driver_state == VFD_NOT_INSTALLED) {
				msg = IDS_MSG_DRIVER_STOPPED;
			}
			break;

		case VFD_OPERATION_MOUNT:
			if (media_state == ERROR_SUCCESS || media_state == ERROR_WRITE_PROTECT) {
				msg = IDS_MSG_IMAGE_MOUNTED;
			}
			break;

		case VFD_OPERATION_UMOUNT:
			if (media_state != ERROR_SUCCESS && media_state != ERROR_WRITE_PROTECT) {
				msg = IDS_MSG_IMAGE_UNMOUNTED;
			}
			break;
		}

		if (msg) {
			AppendMessage(hDlg, msg, 0);
		}
	}

	return;
}

//	Ask if proceed to stop the driver when the current image
//	cannot be unmounted

BOOL AskForceStop(HWND hWnd)
{
	TCHAR msg[200];

	if (!LoadString(hAppInstance, IDS_MSG_FORCE_STOP, msg, sizeof(msg))) {
		DEBUG_TRACE1(
			"AskForceStop: LoadString(IDS_MSG_FORCE_STOP) - %s",
			ErrMsg(GetLastError()));

		strcpy(msg, FALLBACK_FORCE_STOP);
	}

	return (MessageBox(hWnd, msg, VFD_APP_NAME, MB_ICONQUESTION | MB_YESNO) == IDYES);
}

//	Ask if proceed to remove the driver when the driver cannot be stopped

BOOL AskForceRemove(HWND hDlg)
{
	TCHAR msg[200];

	if (!LoadString(hAppInstance, IDS_MSG_FORCE_REMOVE, msg, sizeof(msg))) {
		DEBUG_TRACE1(
			"AskForceRemove: LoadString(IDS_MSG_FORCE_REMOVE) - %s",
			ErrMsg(GetLastError()));

		strcpy(msg, FALLBACK_FORCE_REMOVE);
	}

	return (MessageBox(hDlg, msg, VFD_APP_NAME, MB_ICONQUESTION | MB_YESNO) == IDYES);
}

//
//	append a text string to the message control
//
void AppendMessage(HWND hDlg, UINT msg, DWORD err)
{
	static TCHAR buf[512];
	HWND	hEdit;
	int		len;
	int		line;
	int		top;

	len = strlen(buf);

	if (len >= sizeof(buf) - 1) {
		return;
	}

	if (msg) {
		len += LoadString(hAppInstance, msg, buf + len, sizeof(buf) - len);

		if (len < sizeof(buf) - 3) {
			strcat(buf, "\r\n");
			len += 2;
		}
	}

	if (err) {
		len += VfdErrorMessage(err, buf + len, sizeof(buf) - len);
	}

	if ((hEdit = GetDlgItem(hDlg, IDC_DRIVER_MESSAGE)) == NULL) {
		DEBUG_TRACE1(
			"AppendMessage : GetDlgItem - %s", ErrMsg(GetLastError()));
		return;
	}

	if (!SetWindowText(hEdit, buf)) {
		DEBUG_TRACE1(
			"AppendMessage : SetWindowText - %s", ErrMsg(GetLastError()));
		return;
	}

	SendMessage(hEdit, EM_SETSEL, 0, -1);
	SendMessage(hEdit, EM_SCROLLCARET, 0, 0);

	line = SendMessage(hEdit, EM_GETFIRSTVISIBLELINE, 0, 0);
	top = SendMessage(hEdit, EM_LINEINDEX, line, 0);

	if (top) {
		len -= top;
		memmove(buf, buf + top, len + 1);
	}
}