reactos/modules/rosapps/lib/vfdlib/vfdguiopen.c

/*
	vfdguiopen.c

	Virtual Floppy Drive for Windows
	Driver control library
	Open image GUI utility function

	Copyright (c) 2003-2005 Ken Kato
*/

#ifdef __cplusplus
#pragma message(__FILE__": Compiled as C++ for testing purpose.")
#endif	// __cplusplus

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#if !defined(__REACTOS__) || defined(_MSC_VER)
#pragma warning(push,3)
#endif
#include <commdlg.h>
#if !defined(__REACTOS__) || defined(_MSC_VER)
#pragma warning(pop)
#endif

#include "vfdtypes.h"
#include "vfdapi.h"
#include "vfdlib.h"
#ifndef __REACTOS__
#include "vfdmsg.h"
#else
#include "vfdmsg_lib.h"
#endif
#include "vfdguirc.h"

//
//	String constants
//

#define FALLBACK_IMAGE_FILTER	\
	"Common image files (bin,dat,fdd,flp,ima,img,vfd)\0" \
	"*.bin;*.dat;*.fdd;*.flp;*.ima;*.img;*.vfd\0" \
	"Zip compressed image (imz,zip)\0*.imz;*.zip\0" \
	"All files (*.*)\0*.*\0"

#define FALLBACK_IMAGE_TITLE	"Open Virtual Floppy Image"

//
//	local functions
//
#ifndef __REACTOS__
static INT CALLBACK OpenDialogProc(
#else
static INT_PTR CALLBACK OpenDialogProc(
#endif
	HWND			hDlg,
	UINT			uMsg,
	WPARAM			wParam,
	LPARAM			lParam);

static void OnInit(HWND hDlg, ULONG nDevice);
static void OnImage(HWND hDlg, HWND hEdit);
static void OnBrowse(HWND hDlg);
static void OnDiskType(HWND hDlg, HWND hRadio);
static void OnMediaType(HWND hDlg, HWND hCombo);
static void OnProtect(HWND hDlg, HWND hCheck);
static DWORD OnOK(HWND hDlg);

//
//	Show Open Image dialog box
//
DWORD WINAPI VfdGuiOpen(
	HWND			hParent,
	ULONG			nDevice)
{
	switch (DialogBoxParam(
		g_hDllModule,
		MAKEINTRESOURCE(IDD_OPENDIALOG),
		hParent,
		OpenDialogProc,
		nDevice))
	{
	case IDOK:
		return ERROR_SUCCESS;

	case IDCANCEL:
		return ERROR_CANCELLED;

	default:
		return GetLastError();
	}
}

//
// Open image dialog procedure
//
#ifndef __REACTOS__
INT CALLBACK OpenDialogProc(
#else
INT_PTR CALLBACK OpenDialogProc(
#endif
	HWND			hDlg,
	UINT			uMsg,
	WPARAM			wParam,
	LPARAM			lParam)
{
	switch (uMsg) {
	case WM_INITDIALOG:
		OnInit(hDlg, lParam);
		return TRUE;

	case WM_COMMAND:
		switch (wParam) {
		case MAKELONG(IDC_IMAGEFILE, EN_CHANGE):
			OnImage(hDlg, (HWND)lParam);
			return TRUE;

		case IDC_BROWSE:
			OnBrowse(hDlg);
			return TRUE;

		case IDC_DISKTYPE_FILE:
		case IDC_DISKTYPE_RAM:
			OnDiskType(hDlg, (HWND)lParam);
			return TRUE;

		case MAKELONG(IDC_MEDIATYPE, CBN_SELCHANGE):
			OnMediaType(hDlg, (HWND)lParam);
			return TRUE;

		case IDC_OPEN_PROTECTED:
			OnProtect(hDlg, (HWND)lParam);
			return TRUE;

		case IDOK:
			if (OnOK(hDlg) == ERROR_SUCCESS) {
				EndDialog(hDlg, IDOK);
			}
			return TRUE;

		case IDCANCEL:
			EndDialog(hDlg, IDCANCEL);
			return TRUE;
		}
		break;

	case WM_CONTEXTMENU:
		ShowContextMenu(hDlg, (HWND)wParam, lParam);
		break;

	case WM_HELP:
		{
			LPHELPINFO info = (LPHELPINFO)lParam;

			if (info->iContextType == HELPINFO_WINDOW) {
				ShowHelpWindow(hDlg, info->iCtrlId);
			}
		}
		return TRUE;
	}

	return FALSE;
}

//
//	Initialize the Open Image dialog
//
void OnInit(
	HWND			hDlg,
	ULONG			nDevice)
{
	VFD_MEDIA i;

	//	Store the device number

	SetWindowLong(hDlg, GWL_USERDATA, nDevice);

	//	Store default file size

	SetWindowLong(hDlg, DWL_USER, INVALID_FILE_SIZE);

	// Set dialog window title

	SetControlText(hDlg, 0, MSG_OPEN_TITLE);

	// Set control captions

	SetControlText(hDlg, IDC_IMAGEFILE_LABEL,	MSG_IMAGEFILE_ACCEL);
	SetControlText(hDlg, IDC_IMAGEDESC_LABEL,	MSG_DESCRIPTION_LABEL);
	SetControlText(hDlg, IDC_BROWSE,			MSG_BROWSE_BUTTON);
	SetControlText(hDlg, IDC_DISKTYPE_LABEL,	MSG_DISKTYPE_LABEL);
	SetControlText(hDlg, IDC_MEDIATYPE_LABEL,	MSG_MEDIATYPE_ACCEL);
	SetControlText(hDlg, IDC_OPEN_PROTECTED,	MSG_MENU_PROTECT);
	SetControlText(hDlg, IDOK,					MSG_CREATE_BUTTON);
	SetControlText(hDlg, IDCANCEL,				MSG_CANCEL_BUTTON);

	//	select RAM disk as default

	CheckRadioButton(hDlg, IDC_DISKTYPE_FILE,
		IDC_DISKTYPE_RAM, IDC_DISKTYPE_RAM);

	//	setup media type combo list

	for (i = 1; i < VFD_MEDIA_MAX; i++) {
		SendDlgItemMessage(hDlg, IDC_MEDIATYPE,
			CB_ADDSTRING, 0, (LPARAM)VfdMediaTypeName(i));
	}

	//	select 1.44MB as the default

	SendDlgItemMessage(hDlg, IDC_MEDIATYPE, CB_SELECTSTRING,
		(WPARAM)-1, (LPARAM)VfdMediaTypeName(VFD_MEDIA_F3_1P4));

	//	set up other controls

	OnImage(hDlg, GetDlgItem(hDlg, IDC_IMAGEFILE));
}

//
//	Path is changed -- check if the file exists
//
void OnImage(
	HWND			hDlg,
	HWND			hEdit)
{
	CHAR			buf[MAX_PATH];
	DWORD			file_attr;
	ULONG			image_size;
	VFD_FILETYPE	file_type;
	VFD_MEDIA		media_type;

	DWORD			ret = ERROR_SUCCESS;

	//	Store default file size

	SetWindowLong(hDlg, DWL_USER, INVALID_FILE_SIZE);

	//	get currently selected media type

	media_type = (VFD_MEDIA)(SendDlgItemMessage(
		hDlg, IDC_MEDIATYPE, CB_GETCURSEL, 0, 0) + 1);

	//	clear hint and description text

	SetDlgItemText(hDlg, IDC_IMAGEFILE_DESC, NULL);
	SetDlgItemText(hDlg, IDC_IMAGEFILE_HINT, NULL);

	//	get file name and file information

	if (GetWindowText(hEdit, buf, sizeof(buf))) {

		ret = VfdCheckImageFile(
			buf, &file_attr, &file_type, &image_size);

		if (ret == ERROR_SUCCESS) {

			//	use media type from image size

			media_type = VfdLookupMedia(image_size);
		}
		else if (ret == ERROR_FILE_NOT_FOUND) {

			//	new file
			//	use the parent directory attributes

			PSTR p;

			if ((p = strrchr(buf, '\\')) != NULL) {
				*p = '\0';
			}

			file_attr	= GetFileAttributes(buf);

			if (file_attr == INVALID_FILE_ATTRIBUTES) {
				//	directory access error
				EnableWindow(GetDlgItem(hDlg, IDOK), FALSE);
				SetDlgItemText(hDlg, IDC_IMAGEFILE_DESC, SystemMessage(ret));
				return;
			}

			file_attr	&= ~(FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_DIRECTORY);
			image_size	= INVALID_FILE_SIZE;
			file_type	= VFD_FILETYPE_RAW;
		}
		else {
			//	file access error
			EnableWindow(GetDlgItem(hDlg, IDOK), FALSE);
			SetDlgItemText(hDlg, IDC_IMAGEFILE_DESC, SystemMessage(ret));
			return;
		}

		//	make file description text

		VfdMakeFileDesc(buf, sizeof(buf),
			file_type, image_size, file_attr);

		//	set file description

		SetDlgItemText(hDlg, IDC_IMAGEFILE_DESC, buf);
	}
	else {

		//	filename is empty - RAM disk

		file_attr	= 0;
		image_size	= INVALID_FILE_SIZE;
		file_type	= VFD_FILETYPE_NONE;

		SetDlgItemText(hDlg, IDC_IMAGEFILE_DESC, "RAM");
	}

	//	store the image size

	SetWindowLong(hDlg, DWL_USER, image_size);

	//	setup disktype controls

	if (file_type != VFD_FILETYPE_RAW ||
		(file_attr & (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_COMPRESSED | FILE_ATTRIBUTE_ENCRYPTED))) {

		//	file cannot be opened directly -- RAM mode is forced

		CheckRadioButton(hDlg, IDC_DISKTYPE_FILE,
			IDC_DISKTYPE_RAM, IDC_DISKTYPE_RAM);

		EnableWindow(GetDlgItem(hDlg, IDC_DISKTYPE_FILE),	FALSE);
	}
	else {
		EnableWindow(GetDlgItem(hDlg, IDC_DISKTYPE_FILE),	TRUE);
	}

	//	set OK button text

	if (image_size == INVALID_FILE_SIZE) {
		//	file does not exist - OK button is "Create"

		SetControlText(hDlg, IDOK, MSG_CREATE_BUTTON);
	}
	else {
		//	file exists - OK button is "Open"

		SetControlText(hDlg, IDOK, MSG_OPEN_BUTTON);
	}

	//	select media type

	SendDlgItemMessage(hDlg, IDC_MEDIATYPE,
		CB_SETCURSEL, media_type - 1, 0);

	OnMediaType(hDlg, GetDlgItem(hDlg, IDC_MEDIATYPE));
}

//
//	Show open file dialog box
//
void OnBrowse(
	HWND			hDlg)
{
	OPENFILENAME	ofn;
	PSTR			title;
	PSTR			filter;
	CHAR			file[MAX_PATH];
	CHAR			dir[MAX_PATH];
	DWORD			len;

	//	prepare title and filter text

	title = ModuleMessage(MSG_OPEN_TITLE);

	filter = ModuleMessage(MSG_OPEN_FILTER);

	if (filter) {
		PSTR p = filter;

		do {
			if (*p == '|') {
				*p = '\0';
			}
		}
		while (*(++p));
	}

	//	get current file name from the control

	ZeroMemory(file, sizeof(file));
	ZeroMemory(dir, sizeof(dir));

	len = GetDlgItemText(hDlg, IDC_IMAGEFILE, file, sizeof(file));

	if (len && file[len - 1] == '\\') {
		strcpy(dir, file);
		ZeroMemory(file, sizeof(file));
	}

	// prepare OPENFILENAME structure

	ZeroMemory(&ofn, sizeof(ofn));

	ofn.lStructSize = IS_WINDOWS_NT() ?
		OPENFILENAME_SIZE_VERSION_400 : sizeof(ofn);

	ofn.hwndOwner	= hDlg;
	ofn.lpstrFilter = filter ? filter : FALLBACK_IMAGE_FILTER;
	ofn.lpstrFile	= file;
	ofn.nMaxFile	= sizeof(file);
	ofn.lpstrInitialDir = dir;
	ofn.lpstrTitle	= title ? title : FALLBACK_IMAGE_TITLE;
#ifndef __REACTOS__
	ofn.Flags		= OFN_ENABLESIZING | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST;
#else
	ofn.Flags		= OFN_EXPLORER | OFN_ENABLESIZING | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST;
#endif

	//	show the open file dialog box

	if (GetOpenFileName(&ofn)) {
		SetDlgItemText(hDlg, IDC_IMAGEFILE, file);
		SetFocus(GetDlgItem(hDlg, IDC_IMAGEFILE));
	}

	//	release text buffers

	if (filter) {
		LocalFree(filter);
	}

	if (title) {
		LocalFree(title);
	}
}

//
//	Disk type is changed
//
void OnDiskType(
	HWND			hDlg,
	HWND			hRadio)
{
	UNREFERENCED_PARAMETER(hDlg);
	UNREFERENCED_PARAMETER(hRadio);
}

//
//	Media type is changed
//
void OnMediaType(
	HWND			hDlg,
	HWND			hCombo)
{
	VFD_MEDIA		media_type;
	ULONG			media_size;
	ULONG			image_size;

	image_size = GetWindowLong(hDlg, DWL_USER);

	if (image_size == INVALID_FILE_SIZE) {
		return;
	}

	media_type = (VFD_MEDIA)(SendMessage(
		hCombo, CB_GETCURSEL, 0, 0) + 1);

	if (media_type == 0) {
		return;
	}

	media_size = VfdGetMediaSize(media_type);

	if (media_size > image_size) {
		//	selected media is too large
		SetControlText(hDlg, IDC_IMAGEFILE_HINT, MSG_FILE_TOO_SMALL);
		EnableWindow(GetDlgItem(hDlg, IDOK), FALSE);
		return;
	}
	else if (media_size < image_size) {
		SetControlText(hDlg, IDC_IMAGEFILE_HINT, MSG_SIZE_MISMATCH);
	}
	else {
		SetDlgItemText(hDlg, IDC_IMAGEFILE_HINT, NULL);
	}

	EnableWindow(GetDlgItem(hDlg, IDOK), TRUE);
}

//
//	Write Protect check box is clicked
//
void OnProtect(
	HWND			hDlg,
	HWND			hCheck)
{
	UNREFERENCED_PARAMETER(hDlg);
	UNREFERENCED_PARAMETER(hCheck);
}

//
//	Create / open an image
//
DWORD OnOK(
	HWND			hDlg)
{
	CHAR			file_name[MAX_PATH];
	VFD_DISKTYPE	disk_type;
	VFD_MEDIA		media_type;
	VFD_FLAGS		image_flags;
	HANDLE			hDevice;
	DWORD			ret;

	//	get the disk type

	if (IsDlgButtonChecked(hDlg, IDC_DISKTYPE_FILE) == BST_CHECKED) {
		disk_type = VFD_DISKTYPE_FILE;
	}
	else {
		disk_type = VFD_DISKTYPE_RAM;
	}

	//	get the media type

	media_type = (VFD_MEDIA)(SendDlgItemMessage(
		hDlg, IDC_MEDIATYPE, CB_GETCURSEL, 0, 0) + 1);

	//	get the protect flag

	if (IsDlgButtonChecked(hDlg, IDC_OPEN_PROTECTED) == BST_CHECKED) {
		image_flags = VFD_FLAG_WRITE_PROTECTED;
	}
	else {
		image_flags = 0;
	}

	//	get the image name to create

	if (GetDlgItemText(hDlg, IDC_IMAGEFILE, file_name, sizeof(file_name))) {

		//	file is specified

		if (GetWindowLong(hDlg, DWL_USER) == INVALID_FILE_SIZE) {

			//	create a new image

			ret = VfdCreateImageFile(
				file_name, media_type, VFD_FILETYPE_RAW, FALSE);

			if (ret != ERROR_SUCCESS) {
				goto exit_func;
			}
		}
	}

	//	open the image

	hDevice = VfdOpenDevice(GetWindowLong(hDlg, GWL_USERDATA));

	if (hDevice == INVALID_HANDLE_VALUE) {
		ret = GetLastError();
		goto exit_func;
	}

	ret = VfdOpenImage(
		hDevice, file_name, disk_type, media_type, image_flags);

	CloseHandle(hDevice);

exit_func:
	if (ret != ERROR_SUCCESS) {

		//	show error message

		MessageBox(hDlg, SystemMessage(ret),
			VFD_MSGBOX_TITLE, MB_ICONSTOP);
	}

	return ret;
}