mirror of
https://github.com/reactos/reactos.git
synced 2024-08-19 18:02:55 +00:00
848 lines
21 KiB
C
848 lines
21 KiB
C
/*
|
|
* PROJECT: shell32
|
|
* LICENSE: GPL - See COPYING in the top level directory
|
|
* FILE: dll/win32/shell32/shv_item_new.c
|
|
* PURPOSE: provides new shell item service
|
|
* PROGRAMMERS: Johannes Anderwald (janderwald@reactos.org)
|
|
*/
|
|
|
|
#include <precomp.h>
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(shell);
|
|
|
|
typedef enum
|
|
{
|
|
SHELLNEW_TYPE_COMMAND = 1,
|
|
SHELLNEW_TYPE_DATA = 2,
|
|
SHELLNEW_TYPE_FILENAME = 4,
|
|
SHELLNEW_TYPE_NULLFILE = 8
|
|
}SHELLNEW_TYPE;
|
|
|
|
|
|
typedef struct __SHELLNEW_ITEM__
|
|
{
|
|
SHELLNEW_TYPE Type;
|
|
LPWSTR szExt;
|
|
LPWSTR szTarget;
|
|
LPWSTR szDesc;
|
|
LPWSTR szIcon;
|
|
struct __SHELLNEW_ITEM__ * Next;
|
|
}SHELLNEW_ITEM, *PSHELLNEW_ITEM;
|
|
|
|
typedef struct
|
|
{
|
|
const IContextMenu2Vtbl *lpVtblContextMenu;
|
|
const IShellExtInitVtbl *lpvtblShellExtInit;
|
|
LPWSTR szPath;
|
|
IShellFolder *pSFParent;
|
|
PSHELLNEW_ITEM s_SnHead;
|
|
}INewMenuImpl, *LPINewMenuImpl;
|
|
|
|
//static const IContextMenu2Vtbl cmvt;
|
|
//static const IShellExtInitVtbl sei;
|
|
static WCHAR szNew[MAX_PATH];
|
|
|
|
|
|
static
|
|
BOOL
|
|
GetKeyDescription(LPWSTR szKeyName, LPWSTR szResult)
|
|
{
|
|
HKEY hKey;
|
|
DWORD dwDesc, dwError;
|
|
WCHAR szDesc[100];
|
|
|
|
static const WCHAR szFriendlyTypeName[] = { '\\','F','r','i','e','n','d','l','y','T','y','p','e','N','a','m','e',0 };
|
|
|
|
TRACE("GetKeyDescription: keyname %s\n", debugstr_w(szKeyName));
|
|
|
|
if (RegOpenKeyExW(HKEY_CLASSES_ROOT,szKeyName,0, KEY_READ | KEY_QUERY_VALUE,&hKey) != ERROR_SUCCESS)
|
|
return FALSE;
|
|
|
|
if (RegLoadMUIStringW(hKey,szFriendlyTypeName,szResult,MAX_PATH,&dwDesc,0,NULL) == ERROR_SUCCESS)
|
|
{
|
|
TRACE("result %s\n", debugstr_w(szResult));
|
|
RegCloseKey(hKey);
|
|
return TRUE;
|
|
}
|
|
/* fetch default value */
|
|
dwDesc = sizeof(szDesc);
|
|
dwError = RegGetValueW(hKey,NULL,NULL, RRF_RT_REG_SZ,NULL,szDesc,&dwDesc);
|
|
if(dwError == ERROR_SUCCESS)
|
|
{
|
|
if (wcsncmp(szKeyName, szDesc, dwDesc / sizeof(WCHAR)))
|
|
{
|
|
/* recurse for to a linked key */
|
|
if (!GetKeyDescription(szDesc, szResult))
|
|
{
|
|
/* use description */
|
|
wcscpy(szResult, szDesc);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* use default value as description */
|
|
wcscpy(szResult, szDesc);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* registry key w/o default key?? */
|
|
TRACE("RegGetValue failed with %x\n", dwError);
|
|
wcscpy(szResult, szKeyName);
|
|
}
|
|
|
|
RegCloseKey(hKey);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
PSHELLNEW_ITEM LoadItem(LPWSTR szKeyName)
|
|
{
|
|
HKEY hKey;
|
|
DWORD dwIndex;
|
|
WCHAR szName[MAX_PATH];
|
|
WCHAR szCommand[MAX_PATH];
|
|
WCHAR szDesc[MAX_PATH] = {0};
|
|
WCHAR szIcon[MAX_PATH] = {0};
|
|
DWORD dwName, dwCommand;
|
|
LONG result;
|
|
PSHELLNEW_ITEM pNewItem;
|
|
|
|
static const WCHAR szShellNew[] = { '\\','S','h','e','l','l','N','e','w',0 };
|
|
static const WCHAR szCmd[] = { 'C','o','m','m','a','n','d',0 };
|
|
static const WCHAR szData[] = { 'D','a','t','a',0 };
|
|
static const WCHAR szFileName[] = { 'F','i','l','e','N','a','m','e', 0 };
|
|
static const WCHAR szNullFile[] = { 'N','u','l','l','F','i','l','e', 0 };
|
|
|
|
|
|
wcscpy(szName, szKeyName);
|
|
GetKeyDescription(szKeyName, szDesc);
|
|
wcscat(szName, szShellNew);
|
|
result = RegOpenKeyExW(HKEY_CLASSES_ROOT,szName,0,KEY_READ,&hKey);
|
|
|
|
//TRACE("LoadItem dwName %d keyname %s szName %s szDesc %s szIcon %s\n", dwName, debugstr_w(szKeyName), debugstr_w(szName), debugstr_w(szDesc), debugstr_w(szIcon));
|
|
|
|
if (result != ERROR_SUCCESS)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
dwIndex = 0;
|
|
pNewItem = NULL;
|
|
|
|
do
|
|
{
|
|
dwName = MAX_PATH;
|
|
dwCommand = MAX_PATH;
|
|
result = RegEnumValueW(hKey,dwIndex,szName,&dwName,NULL,NULL,(LPBYTE)szCommand, &dwCommand);
|
|
if (result == ERROR_SUCCESS)
|
|
{
|
|
long type = -1;
|
|
LPWSTR szTarget = szCommand;
|
|
//TRACE("szName %s szCommand %s\n", debugstr_w(szName), debugstr_w(szCommand));
|
|
if (!wcsicmp(szName, szCmd))
|
|
{
|
|
type = SHELLNEW_TYPE_COMMAND;
|
|
}else if (!wcsicmp(szName, szData))
|
|
{
|
|
type = SHELLNEW_TYPE_DATA;
|
|
}
|
|
else if (!wcsicmp(szName, szFileName))
|
|
{
|
|
type = SHELLNEW_TYPE_FILENAME;
|
|
}
|
|
else if (!wcsicmp(szName, szNullFile))
|
|
{
|
|
type = SHELLNEW_TYPE_NULLFILE;
|
|
szTarget = NULL;
|
|
}
|
|
if (type != -1)
|
|
{
|
|
pNewItem = HeapAlloc(GetProcessHeap(), 0, sizeof(SHELLNEW_ITEM));
|
|
pNewItem->Type = type;
|
|
if (szTarget)
|
|
pNewItem->szTarget = _wcsdup(szTarget);
|
|
else
|
|
pNewItem->szTarget = NULL;
|
|
|
|
pNewItem->szDesc = _wcsdup(szDesc);
|
|
pNewItem->szIcon = _wcsdup(szIcon);
|
|
pNewItem->szExt = _wcsdup(szKeyName);
|
|
pNewItem->Next = NULL;
|
|
break;
|
|
}
|
|
}
|
|
dwIndex++;
|
|
}while(result != ERROR_NO_MORE_ITEMS);
|
|
RegCloseKey(hKey);
|
|
return pNewItem;
|
|
}
|
|
|
|
|
|
BOOL
|
|
LoadShellNewItems(INewMenuImpl * This)
|
|
{
|
|
DWORD dwIndex;
|
|
WCHAR szName[MAX_PATH];
|
|
LONG result;
|
|
PSHELLNEW_ITEM pNewItem;
|
|
PSHELLNEW_ITEM pCurItem = NULL;
|
|
static WCHAR szLnk[] = { '.','l','n','k',0 };
|
|
|
|
/* insert do new folder action */
|
|
if (!LoadStringW(shell32_hInstance, FCIDM_SHVIEW_NEW, szNew, sizeof(szNew) / sizeof(WCHAR)))
|
|
szNew[0] = 0;
|
|
szNew[MAX_PATH-1] = 0;
|
|
|
|
dwIndex = 0;
|
|
do
|
|
{
|
|
result = RegEnumKeyW(HKEY_CLASSES_ROOT,dwIndex,szName,MAX_PATH);
|
|
if (result == ERROR_SUCCESS)
|
|
{
|
|
pNewItem = LoadItem(szName);
|
|
if (pNewItem)
|
|
{
|
|
if (!wcsicmp(pNewItem->szExt, szLnk))
|
|
{
|
|
if (This->s_SnHead)
|
|
{
|
|
pNewItem->Next = This->s_SnHead;
|
|
This->s_SnHead = pNewItem;
|
|
}
|
|
else
|
|
{
|
|
This->s_SnHead = pCurItem = pNewItem;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (pCurItem)
|
|
{
|
|
pCurItem->Next = pNewItem;
|
|
pCurItem = pNewItem;
|
|
}
|
|
else
|
|
{
|
|
pCurItem = This->s_SnHead = pNewItem;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
dwIndex++;
|
|
}while(result != ERROR_NO_MORE_ITEMS);
|
|
|
|
if (This->s_SnHead == NULL)
|
|
return FALSE;
|
|
else
|
|
return TRUE;
|
|
}
|
|
|
|
UINT
|
|
InsertShellNewItems(HMENU hMenu, UINT idFirst, UINT idMenu, INewMenuImpl * This)
|
|
{
|
|
MENUITEMINFOW mii;
|
|
PSHELLNEW_ITEM pCurItem;
|
|
UINT i;
|
|
WCHAR szBuffer[MAX_PATH];
|
|
|
|
if (This->s_SnHead == NULL)
|
|
{
|
|
if (!LoadShellNewItems(This))
|
|
return 0;
|
|
}
|
|
|
|
ZeroMemory(&mii, sizeof(mii));
|
|
mii.cbSize = sizeof(mii);
|
|
|
|
/* insert do new shortcut action */
|
|
if (!LoadStringW(shell32_hInstance, FCIDM_SHVIEW_NEWFOLDER, szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0])))
|
|
szBuffer[0] = 0;
|
|
szBuffer[MAX_PATH-1] = 0;
|
|
mii.fMask = MIIM_ID | MIIM_TYPE | MIIM_STATE | MIIM_DATA;
|
|
mii.fType = MFT_STRING;
|
|
mii.dwTypeData = szBuffer;
|
|
mii.cch = wcslen(mii.dwTypeData);
|
|
mii.wID = idFirst++;
|
|
InsertMenuItemW(hMenu, idMenu++, TRUE, &mii);
|
|
|
|
/* insert do new shortcut action */
|
|
if (!LoadStringW(shell32_hInstance, FCIDM_SHVIEW_NEWLINK, szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0])))
|
|
szBuffer[0] = 0;
|
|
szBuffer[MAX_PATH-1] = 0;
|
|
mii.dwTypeData = szBuffer;
|
|
mii.cch = wcslen(mii.dwTypeData);
|
|
mii.wID = idFirst++;
|
|
InsertMenuItemW(hMenu, idMenu++, TRUE, &mii);
|
|
|
|
/* insert seperator for custom new action */
|
|
mii.fMask = MIIM_TYPE | MIIM_ID;
|
|
mii.fType = MFT_SEPARATOR;
|
|
mii.wID = -1;
|
|
InsertMenuItemW(hMenu, idMenu++, TRUE, &mii);
|
|
|
|
mii.fMask = MIIM_ID | MIIM_TYPE | MIIM_STATE | MIIM_DATA;
|
|
/*
|
|
* FIXME
|
|
* implement loading of icons
|
|
* and using MFT_OWNERDRAWN
|
|
*/
|
|
mii.fType = MFT_STRING;
|
|
mii.fState = MFS_ENABLED;
|
|
|
|
pCurItem = This->s_SnHead;
|
|
i = 0;
|
|
|
|
while(pCurItem)
|
|
{
|
|
if (i >= 1)
|
|
{
|
|
TRACE("szDesc %s\n", debugstr_w(pCurItem->szDesc));
|
|
mii.dwTypeData = pCurItem->szDesc;
|
|
mii.cch = wcslen(mii.dwTypeData);
|
|
mii.wID = idFirst++;
|
|
InsertMenuItemW(hMenu, idMenu++, TRUE, &mii);
|
|
}
|
|
pCurItem = pCurItem->Next;
|
|
i++;
|
|
}
|
|
return (i+2);
|
|
}
|
|
|
|
HRESULT
|
|
DoShellNewCmd(INewMenuImpl * This, LPCMINVOKECOMMANDINFO lpcmi)
|
|
{
|
|
PSHELLNEW_ITEM pCurItem = This->s_SnHead;
|
|
IPersistFolder3 * psf;
|
|
LPITEMIDLIST pidl;
|
|
STRRET strTemp;
|
|
WCHAR szTemp[MAX_PATH];
|
|
WCHAR szBuffer[MAX_PATH];
|
|
WCHAR szPath[MAX_PATH];
|
|
STARTUPINFOW sInfo;
|
|
PROCESS_INFORMATION pi;
|
|
UINT i, target;
|
|
HANDLE hFile;
|
|
DWORD dwWritten, dwError;
|
|
|
|
static const WCHAR szP1[] = { '%', '1', 0 };
|
|
static const WCHAR szFormat[] = {'%','s',' ','(','%','d',')','%','s',0 };
|
|
|
|
i = 1;
|
|
target = LOWORD(lpcmi->lpVerb);
|
|
|
|
while(pCurItem)
|
|
{
|
|
if (i == target)
|
|
break;
|
|
|
|
pCurItem = pCurItem->Next;
|
|
i++;
|
|
}
|
|
|
|
if (!pCurItem)
|
|
return E_UNEXPECTED;
|
|
|
|
if (IShellFolder2_QueryInterface(This->pSFParent, &IID_IPersistFolder2, (LPVOID*)&psf) != S_OK)
|
|
{
|
|
ERR("Failed to get interface IID_IPersistFolder2\n");
|
|
return E_FAIL;
|
|
}
|
|
if (IPersistFolder2_GetCurFolder(psf, &pidl) != S_OK)
|
|
{
|
|
ERR("IPersistFolder2_GetCurFolder failed\n");
|
|
return E_FAIL;
|
|
}
|
|
|
|
if (IShellFolder2_GetDisplayNameOf(This->pSFParent, pidl, SHGDN_FORPARSING, &strTemp) != S_OK)
|
|
{
|
|
ERR("IShellFolder_GetDisplayNameOf failed\n");
|
|
return E_FAIL;
|
|
}
|
|
StrRetToBufW(&strTemp, pidl, szPath, MAX_PATH);
|
|
|
|
switch(pCurItem->Type)
|
|
{
|
|
case SHELLNEW_TYPE_COMMAND:
|
|
{
|
|
LPWSTR ptr;
|
|
LPWSTR szCmd;
|
|
|
|
if (!ExpandEnvironmentStringsW(pCurItem->szTarget, szBuffer, MAX_PATH))
|
|
{
|
|
TRACE("ExpandEnvironmentStrings failed\n");
|
|
break;
|
|
}
|
|
|
|
ptr = wcsstr(szBuffer, szP1);
|
|
if (ptr)
|
|
{
|
|
ptr[1] = 's';
|
|
swprintf(szTemp, szBuffer, szPath);
|
|
ptr = szTemp;
|
|
}
|
|
else
|
|
{
|
|
ptr = szBuffer;
|
|
}
|
|
|
|
ZeroMemory(&sInfo, sizeof(sInfo));
|
|
sInfo.cb = sizeof(sizeof(sInfo));
|
|
szCmd = _wcsdup(ptr);
|
|
if (!szCmd)
|
|
break;
|
|
if (CreateProcessW(NULL, szCmd, NULL, NULL,FALSE,0,NULL,NULL,&sInfo, &pi))
|
|
{
|
|
CloseHandle( pi.hProcess );
|
|
CloseHandle( pi.hThread );
|
|
}
|
|
free(szCmd);
|
|
break;
|
|
}
|
|
case SHELLNEW_TYPE_DATA:
|
|
case SHELLNEW_TYPE_FILENAME:
|
|
case SHELLNEW_TYPE_NULLFILE:
|
|
{
|
|
i = 2;
|
|
|
|
PathAddBackslashW(szPath);
|
|
wcscat(szPath, szNew);
|
|
wcscat(szPath, L" ");
|
|
wcscat(szPath, pCurItem->szDesc);
|
|
wcscpy(szBuffer, szPath);
|
|
wcscat(szBuffer, pCurItem->szExt);
|
|
do
|
|
{
|
|
hFile = CreateFileW(szBuffer, GENERIC_WRITE, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (hFile != INVALID_HANDLE_VALUE)
|
|
break;
|
|
dwError = GetLastError();
|
|
|
|
TRACE("FileName %s szBuffer %s i %u error %x\n", debugstr_w(szBuffer), debugstr_w(szPath), i, dwError);
|
|
swprintf(szBuffer, szFormat, szPath, i, pCurItem->szExt);
|
|
i++;
|
|
}while(hFile == INVALID_HANDLE_VALUE && dwError == ERROR_FILE_EXISTS);
|
|
|
|
if (hFile == INVALID_HANDLE_VALUE)
|
|
return E_FAIL;
|
|
|
|
if (pCurItem->Type == SHELLNEW_TYPE_DATA)
|
|
{
|
|
i = WideCharToMultiByte(CP_ACP, 0, pCurItem->szTarget, -1, (LPSTR)szTemp, MAX_PATH*2, NULL, NULL);
|
|
if (i)
|
|
{
|
|
WriteFile(hFile, (LPCVOID)szTemp, i, &dwWritten, NULL);
|
|
}
|
|
}
|
|
CloseHandle(hFile);
|
|
if (pCurItem->Type == SHELLNEW_TYPE_FILENAME)
|
|
{
|
|
if (!CopyFileW(pCurItem->szTarget, szBuffer, FALSE))
|
|
break;
|
|
}
|
|
TRACE("Notifying fs %s\n", debugstr_w(szBuffer));
|
|
SHChangeNotify(SHCNE_CREATE, SHCNF_PATHW, (LPCVOID)szBuffer, NULL);
|
|
break;
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
/**************************************************************************
|
|
* DoMeasureItem
|
|
*/
|
|
HRESULT
|
|
DoMeasureItem(INewMenuImpl *This, HWND hWnd, MEASUREITEMSTRUCT * lpmis)
|
|
{
|
|
PSHELLNEW_ITEM pCurItem;
|
|
PSHELLNEW_ITEM pItem;
|
|
UINT i;
|
|
HDC hDC;
|
|
SIZE size;
|
|
|
|
TRACE("DoMeasureItem entered with id %x\n", lpmis->itemID);
|
|
|
|
pCurItem = This->s_SnHead;
|
|
|
|
i = 1;
|
|
pItem = NULL;
|
|
while(pCurItem)
|
|
{
|
|
if (i == lpmis->itemID)
|
|
{
|
|
pItem = pCurItem;
|
|
break;
|
|
}
|
|
pCurItem = pCurItem->Next;
|
|
i++;
|
|
}
|
|
|
|
if (!pItem)
|
|
{
|
|
TRACE("DoMeasureItem no item found\n");
|
|
return E_FAIL;
|
|
}
|
|
hDC = GetDC(hWnd);
|
|
GetTextExtentPoint32W(hDC, pCurItem->szDesc, wcslen(pCurItem->szDesc), &size);
|
|
lpmis->itemWidth = size.cx + 32;
|
|
lpmis->itemHeight = max(size.cy, 20);
|
|
ReleaseDC (hWnd, hDC);
|
|
return S_OK;
|
|
}
|
|
/**************************************************************************
|
|
* DoDrawItem
|
|
*/
|
|
HRESULT
|
|
DoDrawItem(INewMenuImpl *This, HWND hWnd, DRAWITEMSTRUCT * drawItem)
|
|
{
|
|
PSHELLNEW_ITEM pCurItem;
|
|
PSHELLNEW_ITEM pItem;
|
|
UINT i;
|
|
pCurItem = This->s_SnHead;
|
|
|
|
TRACE("DoDrawItem entered with id %x\n", drawItem->itemID);
|
|
|
|
i = 1;
|
|
pItem = NULL;
|
|
while(pCurItem)
|
|
{
|
|
if (i == drawItem->itemID)
|
|
{
|
|
pItem = pCurItem;
|
|
break;
|
|
}
|
|
pCurItem = pCurItem->Next;
|
|
i++;
|
|
}
|
|
|
|
if (!pItem)
|
|
return E_FAIL;
|
|
|
|
drawItem->rcItem.left += 20;
|
|
|
|
DrawTextW(drawItem->hDC, pCurItem->szDesc, wcslen(pCurItem->szDesc), &drawItem->rcItem, 0);
|
|
return S_OK;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* DoNewFolder
|
|
*/
|
|
static void DoNewFolder(
|
|
INewMenuImpl *This,
|
|
IShellView *psv)
|
|
{
|
|
ISFHelper * psfhlp;
|
|
WCHAR wszName[MAX_PATH];
|
|
|
|
IShellFolder_QueryInterface(This->pSFParent, &IID_ISFHelper, (LPVOID*)&psfhlp);
|
|
if (psfhlp)
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
|
|
if (ISFHelper_GetUniqueName(psfhlp, wszName, MAX_PATH) != S_OK)
|
|
return;
|
|
if (ISFHelper_AddFolder(psfhlp, 0, wszName, &pidl) != S_OK)
|
|
return;
|
|
|
|
if(psv)
|
|
{
|
|
IShellView_Refresh(psv);
|
|
/* if we are in a shellview do labeledit */
|
|
IShellView_SelectItem(psv,
|
|
pidl,(SVSI_DESELECTOTHERS | SVSI_EDIT | SVSI_ENSUREVISIBLE
|
|
|SVSI_FOCUSED|SVSI_SELECT));
|
|
IShellView_Refresh(psv);
|
|
}
|
|
SHFree(pidl);
|
|
|
|
ISFHelper_Release(psfhlp);
|
|
}
|
|
}
|
|
|
|
|
|
static LPINewMenuImpl __inline impl_from_IShellExtInit( IShellExtInit *iface )
|
|
{
|
|
return (INewMenuImpl *)((char*)iface - FIELD_OFFSET(INewMenuImpl, lpvtblShellExtInit));
|
|
}
|
|
|
|
static LPINewMenuImpl __inline impl_from_IContextMenu( IContextMenu2 *iface )
|
|
{
|
|
return (INewMenuImpl *)((char*)iface - FIELD_OFFSET(INewMenuImpl, lpVtblContextMenu));
|
|
}
|
|
|
|
static HRESULT WINAPI INewItem_fnQueryInterface(INewMenuImpl * This, REFIID riid, LPVOID *ppvObj)
|
|
{
|
|
TRACE("(%p)->(\n\tIID:\t%s,%p)\n",This,debugstr_guid(riid),ppvObj);
|
|
|
|
*ppvObj = NULL;
|
|
|
|
if(IsEqualIID(riid, &IID_IUnknown) ||
|
|
IsEqualIID(riid, &IID_IContextMenu) ||
|
|
IsEqualIID(riid, &IID_IContextMenu2))
|
|
{
|
|
*ppvObj = (void *)&This->lpVtblContextMenu;
|
|
}
|
|
else if(IsEqualIID(riid, &IID_IShellExtInit))
|
|
{
|
|
*ppvObj = (void *)&This->lpvtblShellExtInit;
|
|
}
|
|
|
|
|
|
if(*ppvObj)
|
|
{
|
|
IUnknown_AddRef((IUnknown*)*ppvObj);
|
|
TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
|
|
return S_OK;
|
|
}
|
|
TRACE("-- Interface: E_NOINTERFACE\n");
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
static ULONG WINAPI INewItem_fnAddRef(INewMenuImpl *iface)
|
|
{
|
|
/* INewItem service is singleton */
|
|
return 2;
|
|
}
|
|
|
|
static ULONG WINAPI INewItem_fnRelease(INewMenuImpl *This)
|
|
{
|
|
/* INewItem service is singleton */
|
|
return 1;
|
|
}
|
|
|
|
static
|
|
HRESULT
|
|
WINAPI
|
|
INewItem_IContextMenu_fnQueryInterface( IContextMenu2* iface, REFIID riid, void** ppvObject )
|
|
{
|
|
INewMenuImpl *This = impl_from_IContextMenu(iface);
|
|
return INewItem_fnQueryInterface(This, riid, ppvObject);
|
|
}
|
|
|
|
static
|
|
ULONG
|
|
WINAPI
|
|
INewItem_IContextMenu_fnAddRef(IContextMenu2 *iface)
|
|
{
|
|
INewMenuImpl *This = impl_from_IContextMenu(iface);
|
|
return INewItem_fnAddRef(This);
|
|
}
|
|
|
|
static
|
|
ULONG
|
|
WINAPI
|
|
INewItem_IContextMenu_fnRelease(IContextMenu2 *iface)
|
|
{
|
|
INewMenuImpl *This = impl_from_IContextMenu(iface);
|
|
return INewItem_fnRelease(This);
|
|
}
|
|
|
|
static
|
|
HRESULT
|
|
WINAPI
|
|
INewItem_IContextMenu_fnQueryContextMenu(IContextMenu2 *iface,
|
|
HMENU hmenu,
|
|
UINT indexMenu,
|
|
UINT idCmdFirst,
|
|
UINT idCmdLast,
|
|
UINT uFlags)
|
|
{
|
|
WCHAR szBuffer[200];
|
|
MENUITEMINFOW mii;
|
|
HMENU hSubMenu;
|
|
int id = 1;
|
|
INewMenuImpl *This = impl_from_IContextMenu(iface);
|
|
|
|
TRACE("%p %p %u %u %u %u\n", This,
|
|
hmenu, indexMenu, idCmdFirst, idCmdLast, uFlags );
|
|
|
|
if (!LoadStringW(shell32_hInstance, FCIDM_SHVIEW_NEW, szBuffer, 200))
|
|
{
|
|
szBuffer[0] = 0;
|
|
}
|
|
szBuffer[199] = 0;
|
|
|
|
hSubMenu = CreateMenu();
|
|
memset( &mii, 0, sizeof(mii) );
|
|
mii.cbSize = sizeof (mii);
|
|
mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE;
|
|
mii.fType = MFT_STRING;
|
|
mii.wID = idCmdFirst + id++;
|
|
mii.dwTypeData = szBuffer;
|
|
mii.cch = wcslen( mii.dwTypeData );
|
|
mii.fState = MFS_ENABLED;
|
|
|
|
if (hSubMenu)
|
|
{
|
|
id += InsertShellNewItems( hSubMenu, idCmdFirst, 0, This);
|
|
mii.fMask |= MIIM_SUBMENU;
|
|
mii.hSubMenu = hSubMenu;
|
|
}
|
|
|
|
|
|
if (!InsertMenuItemW( hmenu, indexMenu, TRUE, &mii ))
|
|
return E_FAIL;
|
|
|
|
return MAKE_HRESULT( SEVERITY_SUCCESS, 0, id );
|
|
}
|
|
|
|
static
|
|
HRESULT
|
|
WINAPI
|
|
INewItem_IContextMenu_fnInvokeCommand( IContextMenu2* iface,
|
|
LPCMINVOKECOMMANDINFO lpici )
|
|
{
|
|
LPSHELLBROWSER lpSB;
|
|
LPSHELLVIEW lpSV = NULL;
|
|
HRESULT hr;
|
|
INewMenuImpl *This = impl_from_IContextMenu(iface);
|
|
|
|
if((lpSB = (LPSHELLBROWSER)SendMessageA(lpici->hwnd, CWM_GETISHELLBROWSER,0,0)))
|
|
{
|
|
IShellBrowser_QueryActiveShellView(lpSB, &lpSV);
|
|
}
|
|
|
|
if (LOWORD(lpici->lpVerb) == 0)
|
|
{
|
|
DoNewFolder(This, lpSV);
|
|
return S_OK;
|
|
}
|
|
|
|
hr = DoShellNewCmd(This, lpici);
|
|
if (SUCCEEDED(hr) && lpSV)
|
|
{
|
|
IShellView_Refresh(lpSV);
|
|
}
|
|
|
|
TRACE("INewItem_IContextMenu_fnInvokeCommand %x\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
static
|
|
HRESULT
|
|
WINAPI
|
|
INewItem_IContextMenu_fnGetCommandString( IContextMenu2* iface,
|
|
UINT_PTR idCmd,
|
|
UINT uType,
|
|
UINT* pwReserved,
|
|
LPSTR pszName,
|
|
UINT cchMax )
|
|
{
|
|
INewMenuImpl *This = impl_from_IContextMenu(iface);
|
|
|
|
FIXME("%p %lu %u %p %p %u\n", This,
|
|
idCmd, uType, pwReserved, pszName, cchMax );
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static
|
|
HRESULT
|
|
WINAPI
|
|
INewItem_IContextMenu_fnHandleMenuMsg(IContextMenu2 *iface,
|
|
UINT uMsg,
|
|
WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
INewMenuImpl *This = impl_from_IContextMenu(iface);
|
|
DRAWITEMSTRUCT * lpids = (DRAWITEMSTRUCT*) lParam;
|
|
MEASUREITEMSTRUCT *lpmis = (MEASUREITEMSTRUCT*) lParam;
|
|
|
|
TRACE("INewItem_IContextMenu_fnHandleMenuMsg (%p)->(msg=%x wp=%lx lp=%lx)\n",This, uMsg, wParam, lParam);
|
|
|
|
|
|
switch(uMsg)
|
|
{
|
|
case WM_MEASUREITEM:
|
|
return DoMeasureItem(This, (HWND)wParam, lpmis);
|
|
break;
|
|
case WM_DRAWITEM:
|
|
return DoDrawItem(This, (HWND)wParam, lpids);
|
|
break;
|
|
}
|
|
return S_OK;
|
|
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
static const IContextMenu2Vtbl cmvt =
|
|
{
|
|
INewItem_IContextMenu_fnQueryInterface,
|
|
INewItem_IContextMenu_fnAddRef,
|
|
INewItem_IContextMenu_fnRelease,
|
|
INewItem_IContextMenu_fnQueryContextMenu,
|
|
INewItem_IContextMenu_fnInvokeCommand,
|
|
INewItem_IContextMenu_fnGetCommandString,
|
|
INewItem_IContextMenu_fnHandleMenuMsg
|
|
};
|
|
|
|
static HRESULT WINAPI
|
|
INewItem_ExtInit_fnQueryInterface( IShellExtInit* iface, REFIID riid, void** ppvObject )
|
|
{
|
|
return INewItem_fnQueryInterface(impl_from_IShellExtInit(iface), riid, ppvObject);
|
|
}
|
|
|
|
static ULONG WINAPI
|
|
INewItem_ExtInit_AddRef( IShellExtInit* iface )
|
|
{
|
|
return INewItem_fnAddRef(impl_from_IShellExtInit(iface));
|
|
}
|
|
|
|
static ULONG WINAPI
|
|
INewItem_ExtInit_Release( IShellExtInit* iface )
|
|
{
|
|
return INewItem_fnRelease(impl_from_IShellExtInit(iface));
|
|
}
|
|
|
|
static HRESULT WINAPI
|
|
INewItem_ExtInit_Initialize( IShellExtInit* iface, LPCITEMIDLIST pidlFolder,
|
|
IDataObject *pdtobj, HKEY hkeyProgID )
|
|
{
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static const IShellExtInitVtbl sei =
|
|
{
|
|
INewItem_ExtInit_fnQueryInterface,
|
|
INewItem_ExtInit_AddRef,
|
|
INewItem_ExtInit_Release,
|
|
INewItem_ExtInit_Initialize
|
|
};
|
|
static INewMenuImpl *cached_ow = NULL;
|
|
|
|
VOID
|
|
INewItem_SetCurrentShellFolder(IShellFolder * psfParent)
|
|
{
|
|
if (cached_ow)
|
|
cached_ow->pSFParent = psfParent;
|
|
}
|
|
|
|
HRESULT WINAPI INewItem_Constructor(IUnknown * pUnkOuter, REFIID riid, LPVOID *ppv)
|
|
{
|
|
INewMenuImpl * ow;
|
|
HRESULT res;
|
|
|
|
if (!cached_ow)
|
|
{
|
|
ow = LocalAlloc(LMEM_ZEROINIT, sizeof(INewMenuImpl));
|
|
if (!ow)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
ow->lpVtblContextMenu = &cmvt;
|
|
ow->lpvtblShellExtInit = &sei;
|
|
ow->s_SnHead = NULL;
|
|
ow->szPath = NULL;
|
|
|
|
if (InterlockedCompareExchangePointer((void *)&cached_ow, ow, NULL) != NULL)
|
|
{
|
|
/* some other thread already been here */
|
|
LocalFree( ow );
|
|
}
|
|
}
|
|
|
|
res = INewItem_fnQueryInterface( cached_ow, riid, ppv );
|
|
return res;
|
|
}
|