reactos/modules/rosapps/lib/vfdlib/vfdshmenu.cpp

/*
	vfdshmenu.cpp

	Virtual Floppy Drive for Windows
	Driver control library
	COM shell extension class context menu functions

	Copyright (c) 2003-2005 Ken Kato
*/

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <shellapi.h>
#include <shlobj.h>

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

//	class header
#include "vfdshext.h"

//
//	Undocumented windows API to handle shell property sheets
//

typedef BOOL (WINAPI *SHOBJECTPROPERTIES)(
	HWND hwnd, DWORD dwType, LPCWSTR lpObject, LPCWSTR lpPage);

#ifndef SHOP_FILEPATH
#define SHOP_FILEPATH				0x00000002
#endif

#define SHOP_EXPORT_ORDINAL			178

//
//	Context Menu Items
//
enum {
	VFD_CMD_OPEN = 0,
	VFD_CMD_SAVE,
	VFD_CMD_CLOSE,
	VFD_CMD_PROTECT,
	VFD_CMD_DROP,
	VFD_CMD_PROP,
	VFD_CMD_MAX
};

static struct _vfd_menu {
	UINT	textid;			//	menu item text id
	UINT	helpid;			//	menu item help id
#ifndef __REACTOS__
	PCHAR	verbA;			//	ansi verb text
	PWCHAR	verbW;			//	unicode verb text
#else
	LPCSTR	verbA;			//	ansi verb text
	LPCWSTR	verbW;			//	unicode verb text
#endif
}
g_VfdMenu[VFD_CMD_MAX] = {
	{ MSG_MENU_OPEN,	MSG_HELP_OPEN,		"vfdopen",	L"vfdopen"	},
	{ MSG_MENU_SAVE,	MSG_HELP_SAVE,		"vfdsave",	L"vfdsave"	},
	{ MSG_MENU_CLOSE,	MSG_HELP_CLOSE,		"vfdclose",	L"vfdclose"	},
	{ MSG_MENU_PROTECT,	MSG_HELP_PROTECT,	"protect",	L"protect"	},
	{ MSG_MENU_DROP,	MSG_HELP_DROP,		"vfddrop",	L"vfddrop"	},
	{ MSG_MENU_PROP,	MSG_HELP_PROP,		"vfdprop",	L"vfdprop"	},
};

//
//	local functions
//
static void AddMenuItem(
	HMENU			hMenu,
	UINT			uPos,
	UINT			uFlags,
	UINT			uCmd,
	UINT			uText)
{
	PSTR text = ModuleMessage(uText);

	if (text) {
		InsertMenu(hMenu, uPos, uFlags, uCmd, text);
		LocalFree(text);
	}
}


//
//	FUNCTION: CVfdShExt::QueryContextMenu(HMENU, UINT, UINT, UINT, UINT)
//
//	PURPOSE: Called by the shell just before the context menu is displayed.
//			 This is where you add your specific menu items.
//
//	PARAMETERS:
//	  hMenu		 - Handle to the context menu
//	  indexMenu	 - Index of where to begin inserting menu items
//	  idCmdFirst - Lowest value for new menu ID's
//	  idCmtLast	 - Highest value for new menu ID's
//	  uFlags	 - Specifies the context of the menu event
//
STDMETHODIMP CVfdShExt::QueryContextMenu(
	HMENU			hMenu,
	UINT			indexMenu,
	UINT			idCmdFirst,
	UINT			idCmdLast,
	UINT			uFlags)
{
	UNREFERENCED_PARAMETER(idCmdLast);
	VFDTRACE(0, ("CVfdShExt::QueryContextMenu()\n"));

	//
	//	Check if menu items should be added
	//
	if ((CMF_DEFAULTONLY & uFlags) ||
		!m_pDataObj || m_nDevice == (ULONG)-1) {

		VFDTRACE(0, ("Don't add any items.\n"));
		return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0);
	}

	//
	//	Drag & Drop handler?
	//
	if (m_bDragDrop) {

		VFDTRACE(0, ("Invoked as the Drop handler.\n"));

		if (GetFileAttributes(m_sTarget) & FILE_ATTRIBUTE_DIRECTORY) {

			// if the dropped item is a directory, nothing to do here
			VFDTRACE(0, ("Dropped object is a directory.\n"));

			return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0);
		}

		//	Add a drop context menu item
		AddMenuItem(
			hMenu,
			indexMenu,
			MF_BYPOSITION | MF_STRING,
			idCmdFirst + VFD_CMD_DROP,
			g_VfdMenu[VFD_CMD_DROP].textid);

		return MAKE_HRESULT(SEVERITY_SUCCESS, 0, VFD_CMD_DROP + 1);
	}

	//
	//	Context menu handler
	//
	VFDTRACE(0, ("Invoked as the context menu handler.\n"));

	//
	//	Get the VFD media state
	//
	HANDLE hDevice = VfdOpenDevice(m_nDevice);

	if (hDevice == INVALID_HANDLE_VALUE) {
		VFDTRACE(0, ("device open failed.\n"));
		return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0);
	}

	DWORD status = VfdGetMediaState(hDevice);

	CloseHandle(hDevice);

	//
	//	Add context menu items
	//

	InsertMenu(hMenu, indexMenu++,
		MF_BYPOSITION | MF_SEPARATOR, 0, NULL);

	if (status == ERROR_SUCCESS ||
		status == ERROR_WRITE_PROTECT) {

		//	An image is opened

		//	insert the "save" menu item

		AddMenuItem(
			hMenu,
			indexMenu++,
			MF_BYPOSITION | MF_STRING,
			idCmdFirst + VFD_CMD_SAVE,
			g_VfdMenu[VFD_CMD_SAVE].textid);

		//	insert the "close" menu item

		AddMenuItem(
			hMenu,
			indexMenu++,
			MF_BYPOSITION | MF_STRING,
			idCmdFirst + VFD_CMD_CLOSE,
			g_VfdMenu[VFD_CMD_CLOSE].textid);

		//	insert the "protect" menu item

		AddMenuItem(
			hMenu,
			indexMenu++,
			MF_BYPOSITION | MF_STRING,
			idCmdFirst + VFD_CMD_PROTECT,
			g_VfdMenu[VFD_CMD_PROTECT].textid);

		//	check "protect" menu item

		if (status == ERROR_WRITE_PROTECT) {
			CheckMenuItem(hMenu, indexMenu - 1,
				MF_BYPOSITION | MF_CHECKED);
		}
	}
	else {
		//	The drive is empty

		//	insert the "open" menu item

		AddMenuItem(
			hMenu,
			indexMenu++,
			MF_BYPOSITION | MF_STRING,
			idCmdFirst + VFD_CMD_OPEN,
			g_VfdMenu[VFD_CMD_OPEN].textid);
	}

	//	Insert the "proterty" menu item

	AddMenuItem(
		hMenu,
		indexMenu++,
		MF_BYPOSITION | MF_STRING,
		idCmdFirst + VFD_CMD_PROP,
		g_VfdMenu[VFD_CMD_PROP].textid);

	//	Insert a separator

	InsertMenu(hMenu, indexMenu,
		MF_BYPOSITION | MF_SEPARATOR, 0, NULL);

	return MAKE_HRESULT(SEVERITY_SUCCESS, 0, VFD_CMD_PROP + 1);
}

//
//	FUNCTION: CVfdShExt::GetCommandString(LPCMINVOKECOMMANDINFO)
//
//	PURPOSE:	Retrieves information about a shortcut menu command,
//				including the Help string and the language-independent,
//				or canonical, name for the command.
//
//	PARAMETERS:
//		idCmd -		Menu command identifier offset.
//		uFlags -	Flags specifying the information to return.
//					This parameter can have one of the following values.
//					GCS_HELPTEXTA  Sets pszName to an ANSI string containing the Help text for the command.
//					GCS_HELPTEXTW  Sets pszName to a Unicode string containing the Help text for the command.
//					GCS_VALIDATEA  Returns S_OK if the menu item exists, or S_FALSE otherwise.
//					GCS_VALIDATEW Returns S_OK if the menu item exists, or S_FALSE otherwise.
//					GCS_VERBA Sets pszName to an ANSI string containing the language-independent command name for the menu item.
//					GCS_VERBW Sets pszName to a Unicode string containing the language-independent command name for the menu item.
//		pwReserved - Reserved. Applications must specify NULL when calling this method, and handlers must ignore this parameter when called.
//		pszName -	Address of the buffer to receive the null-terminated string being retrieved.
//		cchMax -	Size of the buffer to receive the null-terminated string.
//

STDMETHODIMP CVfdShExt::GetCommandString(
#ifndef __REACTOS__
	UINT			idCmd,
#else
    UINT_PTR		idCmd,
#endif
	UINT			uFlags,
	UINT			*reserved,
	LPSTR			pszName,
	UINT			cchMax)
{
	VFDTRACE(0,
		("CVfdShExt::GetCommandString(%u,...)\n", idCmd));

	UNREFERENCED_PARAMETER(reserved);

	if (idCmd >= sizeof(g_VfdMenu) / sizeof(g_VfdMenu[0])) {
		return S_FALSE;
	}

	switch (uFlags) {
	case GCS_HELPTEXTA:
		FormatMessageA(
			FORMAT_MESSAGE_FROM_HMODULE |
			FORMAT_MESSAGE_IGNORE_INSERTS,
			g_hDllModule, g_VfdMenu[idCmd].helpid,
			0, pszName, cchMax, NULL);

		VFDTRACE(0, ("HELPTEXTA: %s\n", pszName));
		break;

	case GCS_HELPTEXTW:
		FormatMessageW(
			FORMAT_MESSAGE_FROM_HMODULE |
			FORMAT_MESSAGE_IGNORE_INSERTS,
			g_hDllModule, g_VfdMenu[idCmd].helpid,
			0, (LPWSTR)pszName, cchMax, NULL);

		VFDTRACE(0, ("HELPTEXTW: %ws\n", pszName));
		break;

	case GCS_VERBA:
		lstrcpynA(pszName, g_VfdMenu[idCmd].verbA, cchMax);
		break;

	case GCS_VERBW:
		lstrcpynW((LPWSTR)pszName, g_VfdMenu[idCmd].verbW, cchMax);
		break;
	}

	return NOERROR;
}

//
//	FUNCTION: CVfdShExt::InvokeCommand(LPCMINVOKECOMMANDINFO)
//
//	PURPOSE: Called by the shell after the user has selected on of the
//			 menu items that was added in QueryContextMenu().
//
//	PARAMETERS:
//	  lpcmi - Pointer to an CMINVOKECOMMANDINFO structure
//

STDMETHODIMP CVfdShExt::InvokeCommand(
	LPCMINVOKECOMMANDINFO	lpcmi)
{
	VFDTRACE(0, ("CVfdShExt::InvokeCommand()\n"));

	BOOL	unicode = FALSE;
	UINT	id;
	DWORD	ret;
	CMINVOKECOMMANDINFOEX *excmi = (CMINVOKECOMMANDINFOEX *)lpcmi;

	if (lpcmi->cbSize >= sizeof(CMINVOKECOMMANDINFOEX) &&
		(lpcmi->fMask & CMIC_MASK_UNICODE)) {

		unicode = TRUE;
	}


	if (!unicode && HIWORD(lpcmi->lpVerb)) {

		VFDTRACE(0, ("ANSI: %s\n", lpcmi->lpVerb));

		// ANSI verb
		for (id = 0; id < sizeof(g_VfdMenu) / sizeof(g_VfdMenu[0]); id++) {
			if (!lstrcmpi(lpcmi->lpVerb, g_VfdMenu[id].verbA)) {
				break;
			}
		}
	}
	else if (unicode && HIWORD(excmi->lpVerbW)) {

		VFDTRACE(0, ("UNICODE: %ws\n", excmi->lpVerbW));

		// UNICODE verb
		for (id = 0; id < sizeof(g_VfdMenu) / sizeof(g_VfdMenu[0]); id++) {
			if (!lstrcmpiW(excmi->lpVerbW, g_VfdMenu[id].verbW)) {
				break;
			}
		}
	}
	else {

		VFDTRACE(0, ("Command: %u\n", LOWORD(lpcmi->lpVerb)));

		// Command ID
		id = LOWORD(lpcmi->lpVerb);
	}

	VFDTRACE(0, ("MenuItem: %u\n", id));

	switch (id) {
	case VFD_CMD_OPEN:
		ret = DoVfdOpen(lpcmi->hwnd);

		if (ret == ERROR_SUCCESS) {
			VfdImageTip(lpcmi->hwnd, m_nDevice);
		}
		break;

	case VFD_CMD_SAVE:
		ret = DoVfdSave(lpcmi->hwnd);
		break;

	case VFD_CMD_CLOSE:
		ret = DoVfdClose(lpcmi->hwnd);
		break;

	case VFD_CMD_PROTECT:
		ret = DoVfdProtect(lpcmi->hwnd);

		if (ret == ERROR_SUCCESS) {
			VfdImageTip(lpcmi->hwnd, m_nDevice);
		}
		else if (ret == ERROR_WRITE_PROTECT) {
			VfdImageTip(lpcmi->hwnd, m_nDevice);
			ret = ERROR_SUCCESS;
		}
		break;

	case VFD_CMD_DROP:
		ret = DoVfdDrop(lpcmi->hwnd);

		if (ret == ERROR_SUCCESS) {
			VfdImageTip(lpcmi->hwnd, m_nDevice);
		}
		break;

	case VFD_CMD_PROP:
		{
			SHOBJECTPROPERTIES pSHObjectProperties;
			WCHAR path[4] = L" :\\";

			pSHObjectProperties = (SHOBJECTPROPERTIES)GetProcAddress(
				LoadLibrary("shell32"), "SHObjectProperties");

			if (!pSHObjectProperties) {
				pSHObjectProperties = (SHOBJECTPROPERTIES)GetProcAddress(
					LoadLibrary("shell32"), (LPCSTR)SHOP_EXPORT_ORDINAL);
			}

			if (pSHObjectProperties) {
				path[0] = m_sTarget[0];

				pSHObjectProperties(lpcmi->hwnd,
					SHOP_FILEPATH, path, L"VFD");
			}
		}
		ret = ERROR_SUCCESS;
		break;

	default:
		return E_INVALIDARG;
	}

	if (ret != ERROR_SUCCESS &&
		ret != ERROR_CANCELLED) {

		MessageBox(lpcmi->hwnd,
			SystemMessage(ret), VFD_MSGBOX_TITLE, MB_ICONSTOP);
	}

	return NOERROR;
}

//=====================================
//	perform VFD menu operation
//=====================================

DWORD CVfdShExt::DoVfdOpen(
	HWND			hParent)
{
	DWORD ret = VfdGuiOpen(hParent, m_nDevice);

	if (ret != ERROR_SUCCESS && ret != ERROR_CANCELLED) {
		MessageBox(hParent, SystemMessage(ret),
			VFD_MSGBOX_TITLE, MB_ICONSTOP);
	}

	return ret;
}

//
//	Save the VFD image
//
DWORD CVfdShExt::DoVfdSave(
	HWND			hParent)
{
	return VfdGuiSave(hParent, m_nDevice);
}

//
//	Close current VFD image
//
DWORD CVfdShExt::DoVfdClose(
	HWND			hParent)
{
	return VfdGuiClose(hParent, m_nDevice);
}

//
//	Enable/disable media write protection
//
DWORD CVfdShExt::DoVfdProtect(
	HWND			hParent)
{
	HANDLE			hDevice;
	DWORD			ret;

	UNREFERENCED_PARAMETER(hParent);
	VFDTRACE(0, ("CVfdShExt::DoVfdProtect()\n"));

	hDevice = VfdOpenDevice(m_nDevice);

	if (hDevice == INVALID_HANDLE_VALUE) {
		return GetLastError();
	}

	ret = VfdGetMediaState(hDevice);

	if (ret == ERROR_SUCCESS) {
		ret = VfdWriteProtect(hDevice, TRUE);
	}
	else if (ret == ERROR_WRITE_PROTECT) {
		ret = VfdWriteProtect(hDevice, FALSE);
	}

	if (ret == ERROR_SUCCESS) {
		ret = VfdGetMediaState(hDevice);
	}

	CloseHandle(hDevice);

	return ret;
}

//
//	Open dropped file with VFD
//
DWORD CVfdShExt::DoVfdDrop(
	HWND			hParent)
{
	HANDLE			hDevice;
	DWORD			file_attr;
	ULONG			file_size;
	VFD_FILETYPE	file_type;

	VFD_DISKTYPE	disk_type;
	VFD_MEDIA		media_type;

	DWORD			ret;

	VFDTRACE(0, ("CVfdShExt::DoVfdDropOpen()\n"));

	//	check if dropped file is a valid image

	ret = VfdCheckImageFile(
		m_sTarget, &file_attr, &file_type, &file_size);

	if (ret != ERROR_SUCCESS) {
		return ret;
	}

	//	check file size
	media_type = VfdLookupMedia(file_size);

	if (!media_type) {
		PSTR msg = ModuleMessage(MSG_FILE_TOO_SMALL);

		MessageBox(hParent, msg ? msg : "Bad size",
			VFD_MSGBOX_TITLE, MB_ICONSTOP);

		if (msg) {
			LocalFree(msg);
		}

		return ERROR_CANCELLED;
	}

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

		disk_type = VFD_DISKTYPE_RAM;
	}
	else {
		disk_type = VFD_DISKTYPE_FILE;
	}

	//	close current image (if opened)

	ret = DoVfdClose(hParent);

	if (ret != ERROR_SUCCESS &&
		ret != ERROR_NOT_READY) {
		return ret;
	}

	//	open dropped file

	hDevice = VfdOpenDevice(m_nDevice);

	if (hDevice == INVALID_HANDLE_VALUE) {
		return GetLastError();
	}

	ret = VfdOpenImage(
		hDevice, m_sTarget, disk_type, media_type, FALSE);

	CloseHandle(hDevice);

	return ret;
}