void MainWnd::OnContextMenu(CWnd* pWnd, CPoint point)
{
winMouseOn();
if(theApp.skin) {
if(theApp.popup == NULL) {
theApp.winAccelMgr.UpdateMenu(theApp.menu);
theApp.popup = CreatePopupMenu();
if(theApp.menu != NULL) {
int count = GetMenuItemCount(theApp.menu);
OSVERSIONINFO info;
info.dwOSVersionInfoSize = sizeof(info);
GetVersionEx(&info);
if(info.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) {
for(int i = 0; i < count; i++) {
char buffer[256];
MENUITEMINFO info;
ZeroMemory(&info, sizeof(info));
info.cbSize = sizeof(info) - sizeof(HBITMAP);
info.fMask = MIIM_STRING | MIIM_SUBMENU;
info.dwTypeData = buffer;
info.cch = 256;
if(!GetMenuItemInfo(theApp.menu, i, MF_BYPOSITION, &info)) {
}
if(!AppendMenu(theApp.popup, MF_POPUP|MF_STRING, (UINT)info.hSubMenu, buffer)) {
}
}
} else {
for(int i = 0; i < count; i++) {
wchar_t buffer[256];
MENUITEMINFOW info;
ZeroMemory(&info, sizeof(info));
info.cbSize = sizeof(info) - sizeof(HBITMAP);
info.fMask = MIIM_STRING | MIIM_SUBMENU;
info.dwTypeData = buffer;
info.cch = 256;
if(!GetMenuItemInfoW(theApp.menu, i, MF_BYPOSITION, &info)) {
}
if(!AppendMenuW(theApp.popup, MF_POPUP|MF_STRING, (UINT)info.hSubMenu, buffer)) {
}
}
}
}
}
int x = point.x;
int y = point.y;
if(x == -1 && y == -1) {
x = (theApp.dest.left + theApp.dest.right) / 2;
y = (theApp.dest.top + theApp.dest.bottom) / 2;
}
if(!TrackPopupMenu(theApp.popup, 0, x, y, 0, m_hWnd, NULL)) {
}
}
}
/// <summary>
/// Retrieve check status of menu item
/// </summary>
/// <param name="hMenu">Handle to menu control</param>
/// <param name="id">Identifier of menu item</param>
/// <param name="checked">Retrieve the check status of menu item</param>
/// <returns>Indicates success or failure</returns>
bool KinectWindow::GetMenuItemCheckStatus(HMENU hMenu, UINT id, bool& checked)
{
MENUITEMINFOW mii = {0};
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_STATE;
if (GetMenuItemInfoW(hMenu, id, FALSE, &mii))
{
checked = (mii.fState & MFS_CHECKED) != FALSE;
return true;
}
return false;
}
/**************************************************************************
* ISvItemCm_fnQueryContextMenu()
*/
static HRESULT WINAPI ISvItemCm_fnQueryContextMenu(
IContextMenu2 *iface,
HMENU hmenu,
UINT indexMenu,
UINT idCmdFirst,
UINT idCmdLast,
UINT uFlags)
{
ItemCmImpl *This = impl_from_IContextMenu2(iface);
INT uIDMax;
TRACE("(%p)->(hmenu=%p indexmenu=%x cmdfirst=%x cmdlast=%x flags=%x )\n",This, hmenu, indexMenu, idCmdFirst, idCmdLast, uFlags);
This->verb_offset=idCmdFirst;
if(!(CMF_DEFAULTONLY & uFlags) && This->cidl>0)
{
HMENU hmenures = LoadMenuW(shell32_hInstance, MAKEINTRESOURCEW(MENU_SHV_FILE));
if(uFlags & CMF_EXPLORE)
RemoveMenu(hmenures, FCIDM_SHVIEW_OPEN, MF_BYCOMMAND);
uIDMax = Shell_MergeMenus(hmenu, GetSubMenu(hmenures, 0), indexMenu, idCmdFirst, idCmdLast, MM_SUBMENUSHAVEIDS);
DestroyMenu(hmenures);
if(This->bAllValues)
{
MENUITEMINFOW mi;
WCHAR str[255];
mi.cbSize = sizeof(mi);
mi.fMask = MIIM_ID | MIIM_STRING | MIIM_FTYPE;
mi.dwTypeData = str;
mi.cch = 255;
GetMenuItemInfoW(hmenu, FCIDM_SHVIEW_EXPLORE, MF_BYCOMMAND, &mi);
RemoveMenu(hmenu, FCIDM_SHVIEW_EXPLORE, MF_BYCOMMAND);
_InsertMenuItemW(hmenu, (uFlags & CMF_EXPLORE) ? 1 : 2, MF_BYPOSITION, FCIDM_SHVIEW_EXPLORE, MFT_STRING, str, MFS_ENABLED);
}
SetMenuDefaultItem(hmenu, 0, MF_BYPOSITION);
if(uFlags & ~CMF_CANRENAME)
RemoveMenu(hmenu, FCIDM_SHVIEW_RENAME, MF_BYCOMMAND);
else
EnableMenuItem(hmenu, FCIDM_SHVIEW_RENAME, MF_BYCOMMAND | ISvItemCm_CanRenameItems(This) ? MFS_ENABLED : MFS_DISABLED);
return MAKE_HRESULT(SEVERITY_SUCCESS, 0, uIDMax-idCmdFirst);
}
return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0);
}
void CAcceleratorManager::UpdateMenu(HMENU menu)
{
int count = GetMenuItemCount(menu);
MENUITEMINFO info;
wchar_t ss[128];
ZeroMemory(&info, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_ID | MIIM_SUBMENU;
for(int i = 0; i < count; i++) {
GetMenuItemInfo(menu, i, TRUE, &info);
if(info.hSubMenu != NULL) {
UpdateMenu(info.hSubMenu);
} else {
if(info.wID != -1) {
MENUITEMINFOW info2;
ZeroMemory(&info2, sizeof(info2));
info2.cbSize = sizeof(info2);
info2.fMask = MIIM_STRING;
info2.dwTypeData = ss;
info2.cch = 128;
GetMenuItemInfoW(menu, i, MF_BYPOSITION, &info2);
CStdStringW str = ss;
int index = str.Find('\t');
if(index != -1)
str = str.Left(index);
CMapWordToCCmdAccelOb::iterator it = m_mapAccelTable.find(info.wID);
if(it != m_mapAccelTable.end()) {
CCmdAccelOb *o = it->second;
if(o->m_Accels.begin() != o->m_Accels.end()) {
std::list<CAccelsOb*>::iterator j = o->m_Accels.begin();
CAccelsOb *accel = *j;
CStdString s;
accel->GetString(s);
str += "\t";
str += s;
}
}
if(str != ss)
ModifyMenuW(menu, i, MF_BYPOSITION | MF_STRING, info.wID, str);
}
}
}
}
static void hugsprim_GetMenuItemInfoW_15(HugsStackPtr hugs_root)
{
HsPtr arg1;
HsWord32 arg2;
HsBool arg3;
HsPtr arg4;
HsBool res1;
arg1 = hugs->getPtr();
arg2 = hugs->getWord32();
arg3 = hugs->getBool();
arg4 = hugs->getPtr();
res1 = GetMenuItemInfoW(arg1, arg2, arg3, arg4);
hugs->putBool(res1);
hugs->returnIO(hugs_root,1);
}
void freeMenubar(HMENU menubar)
{
size_t i;
MENUITEMINFOW mi;
for (i = 0; i < len; i++) {
ZeroMemory(&mi, sizeof (MENUITEMINFOW));
mi.cbSize = sizeof (MENUITEMINFOW);
mi.fMask = MIIM_SUBMENU;
if (GetMenuItemInfoW(menubar, i, TRUE, &mi) == 0)
logLastError(L"error getting menu to delete item references from");
freeMenu(menus[i], mi.hSubMenu);
}
// no need to worry about destroying any menus; destruction of the window they're in will do it for us
}
LRESULT menu_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
switch (msg)
{
case WM_INITMENUPOPUP:
{
HMENU hmenu = (HMENU)wparam;
struct menu_item* item;
MENUINFO mi;
mi.cbSize = sizeof(mi);
mi.fMask = MIM_MENUDATA;
GetMenuInfo(hmenu, &mi);
item = (struct menu_item*)mi.dwMenuData;
if (item)
fill_menu(item);
return 0;
}
break;
case WM_MENUCOMMAND:
{
HMENU hmenu = (HMENU)lparam;
struct menu_item* item;
MENUITEMINFOW mii;
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_DATA|MIIM_ID;
GetMenuItemInfoW(hmenu, wparam, TRUE, &mii);
item = (struct menu_item*)mii.dwItemData;
if (item)
exec_item(item);
else if (mii.wID == MENU_ID_RUN)
run_dialog();
destroy_menus();
return 0;
}
}
return DefWindowProcW(hwnd, msg, wparam, lparam);
}
void __cdecl CBaseDialog::UpdateStatusBarText(__StatusPaneEnum nPos, UINT uidMsg, LPCTSTR szParam1, LPCTSTR szParam2, LPCTSTR szParam3)
{
CString szStatBarString;
// MAPI Load paths take special handling
if (uidMsg >= ID_LOADMAPIMENUMIN && uidMsg <= ID_LOADMAPIMENUMAX)
{
HRESULT hRes = S_OK;
MENUITEMINFOW mii = { 0 };
mii.cbSize = sizeof(MENUITEMINFO);
mii.fMask = MIIM_DATA;
WC_B(GetMenuItemInfoW(
::GetMenu(m_hWnd),
uidMsg,
false,
&mii));
if (mii.dwItemData)
{
LPMENUENTRY lme = (LPMENUENTRY)mii.dwItemData;
szStatBarString.FormatMessage(IDS_LOADMAPISTATUS, lme->m_pName);
}
}
else
{
LPMENUITEM lpAddInMenu = GetAddinMenuItem(m_hWnd, uidMsg);
if (lpAddInMenu && lpAddInMenu->szHelp)
{
szStatBarString.Format(_T("%ws"), lpAddInMenu->szHelp); // STRING_OK
}
else
{
HRESULT hRes = S_OK;
CString szMsg;
WC_B(szMsg.LoadString(uidMsg));
if (FAILED(hRes)) DebugPrintEx(DBGMenu, CLASS, _T("UpdateStatusBarText"), _T("Cannot find menu item 0x%08X\n"), uidMsg);
szStatBarString.FormatMessage(szMsg, szParam1, szParam2, szParam3);
}
}
UpdateStatusBarText(nPos, szStatBarString);
} // CBaseDialog::UpdateStatusBarText
/*************************************************************************
* FileMenu_DeleteItemByCmd [SHELL32.117]
*
*/
BOOL WINAPI FileMenu_DeleteItemByCmd (HMENU hMenu, UINT uID)
{
MENUITEMINFOW mii;
TRACE("%p 0x%08x\n", hMenu, uID);
ZeroMemory ( &mii, sizeof(MENUITEMINFOW));
mii.cbSize = sizeof(MENUITEMINFOW);
mii.fMask = MIIM_SUBMENU;
GetMenuItemInfoW(hMenu, uID, FALSE, &mii );
if ( mii.hSubMenu )
{
/* FIXME: Do what? */
}
DeleteMenu(hMenu, MF_BYCOMMAND, uID);
return TRUE;
}
/*************************************************************************
* _SHIsMenuSeparator (internal)
*/
static BOOL _SHIsMenuSeparator(HMENU hm, int i)
{
MENUITEMINFOW mii;
mii.cbSize = sizeof(MENUITEMINFOW);
mii.fMask = MIIM_TYPE;
mii.cch = 0; /* WARNING: We MUST initialize it to 0*/
if (!GetMenuItemInfoW(hm, i, TRUE, &mii))
{
return(FALSE);
}
if (mii.fType & MFT_SEPARATOR)
{
return(TRUE);
}
return(FALSE);
}
/*************************************************************************
* FileMenu_DeleteItemByIndex [SHELL32.140]
*/
BOOL WINAPI FileMenu_DeleteItemByIndex ( HMENU hMenu, UINT uPos)
{
MENUITEMINFOW mii;
TRACE("%p 0x%08x\n", hMenu, uPos);
ZeroMemory ( &mii, sizeof(MENUITEMINFOW));
mii.cbSize = sizeof(MENUITEMINFOW);
mii.fMask = MIIM_SUBMENU;
GetMenuItemInfoW(hMenu, uPos, TRUE, &mii );
if ( mii.hSubMenu )
{
/* FIXME: Do what? */
}
DeleteMenu(hMenu, MF_BYPOSITION, uPos);
return TRUE;
}
BOOL GetMenuItemInfoUTF8( HMENU hMenu,UINT uItem, BOOL fByPosition, LPMENUITEMINFO lpmii)
{
if (!lpmii) return FALSE;
if ((lpmii->fMask & MIIM_TYPE) && lpmii->dwTypeData && lpmii->cch AND_IS_NOT_WIN9X)
{
MENUITEMINFOW tmp = *(MENUITEMINFOW*)lpmii;
WIDETOMB_ALLOC(wbuf,lpmii->cch);
if (wbuf)
{
BOOL rv;
char *otd=lpmii->dwTypeData;
int osz=lpmii->cbSize;
tmp.cbSize=sizeof(tmp);
tmp.dwTypeData = wbuf;
tmp.cch = (UINT)(wbuf_size/sizeof(WCHAR));
rv=GetMenuItemInfoW(hMenu,uItem,fByPosition,&tmp);
if (rv && (tmp.fType&(MFT_SEPARATOR|MFT_STRING|MFT_BITMAP)) == MFT_STRING)
{
if (!WideCharToMultiByte(CP_UTF8,0,wbuf,-1,lpmii->dwTypeData,lpmii->cch,NULL,NULL) && GetLastError()==ERROR_INSUFFICIENT_BUFFER)
{
lpmii->dwTypeData[lpmii->cch-1]=0;
}
*lpmii = *(MENUITEMINFO*)&tmp; // copy results
lpmii->cbSize=osz; // restore old stuff
lpmii->dwTypeData = otd;
}
else rv=0;
WIDETOMB_FREE(wbuf);
if (rv)return rv;
}
}
return GetMenuItemInfoA(hMenu,uItem,fByPosition,lpmii);
}
void CAcceleratorManager::UpdateMenu(HMENU menu)
{
int count = GetMenuItemCount(menu);
OSVERSIONINFO info = {0};
info.dwOSVersionInfoSize = sizeof(info);
GetVersionEx(&info);
if (info.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
{
MENUITEMINFO info = {0};
info.cbSize = sizeof(info) - sizeof(HBITMAP);
info.fMask = MIIM_ID | MIIM_SUBMENU;
for (int i = 0; i < count; i++)
{
GetMenuItemInfo(menu, i, TRUE, &info);
if (info.hSubMenu != NULL)
{
UpdateMenu(info.hSubMenu);
}
else
{
if (info.wID != (UINT)-1)
{
char ss[128];
MENUITEMINFO info2 = {0};
info2.cbSize = sizeof(info2) - sizeof(HBITMAP); // FIXME: why?
info2.fMask = MIIM_STRING;
info2.dwTypeData = ss;
info2.cch = 128;
GetMenuItemInfo(menu, i, MF_BYPOSITION, &info2);
CString str(ss);
int index = str.Find('\t');
if (index != -1)
str = str.Left(index);
WORD command = info.wID;
CCmdAccelOb *o;
if (m_mapAccelTable.Lookup(command, o))
{
if (o->m_Accels.GetCount())
{
POSITION pos = o->m_Accels.GetHeadPosition();
CAccelsOb *accel = o->m_Accels.GetNext(pos);
CString s;
accel->GetString(s);
str += "\t";
str += s;
}
}
if (str != ss)
ModifyMenu(menu, i, MF_BYPOSITION | MF_STRING, info.wID, str);
}
}
}
}
else
{
MENUITEMINFO info = {0};
info.cbSize = sizeof(info);
info.fMask = MIIM_ID | MIIM_SUBMENU;
for (int i = 0; i < count; i++)
{
GetMenuItemInfo(menu, i, TRUE, &info);
if (info.hSubMenu != NULL)
{
UpdateMenu(info.hSubMenu);
}
else
{
if (info.wID != (WORD)-1)
{
wchar_t ss[128];
wchar_t str[512];
MENUITEMINFOW info2 = {0};
info2.cbSize = sizeof(info2);
info2.fMask = MIIM_STRING;
info2.dwTypeData = ss;
info2.cch = 128;
GetMenuItemInfoW(menu, i, MF_BYPOSITION, &info2);
wcscpy(str, ss);
wchar_t *p = wcschr(str, '\t');
if (p)
*p = 0;
CCmdAccelOb *o;
WORD command = info.wID;
if (m_mapAccelTable.Lookup(command, o))
{
if (o->m_Accels.GetCount())
{
POSITION pos = o->m_Accels.GetHeadPosition();
CAccelsOb *accel = o->m_Accels.GetNext(pos);
CString s;
accel->GetString(s);
wchar_t temp[128];
temp[0] = '\t';
temp[1] = 0;
wcscat(str, temp);
p = temp;
for (const char *sp = s; *sp; sp++)
*p++ = *sp;
*p = 0;
wcscat(str, temp);
}
}
if (wcscmp(str, ss))
ModifyMenuW(menu, i, MF_BYPOSITION | MF_STRING, info.wID, str);
}
}
}
}
}
/* add an individual file or folder to the menu, takes ownership of pidl */
static struct menu_item* add_shell_item(struct menu_item* parent, LPITEMIDLIST pidl)
{
struct menu_item* item;
MENUITEMINFOW mii;
HMENU parent_menu;
int existing_item_count, i;
BOOL match = FALSE;
SFGAOF flags;
item = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct menu_item));
if (parent->pidl == NULL)
{
pidl_to_shellfolder(pidl, &item->displayname, &item->folder);
}
else
{
STRRET strret;
IShellFolder_GetDisplayNameOf(parent->folder, pidl, SHGDN_INFOLDER, &strret);
StrRetToStrW(&strret, NULL, &item->displayname);
flags = SFGAO_FOLDER;
IShellFolder_GetAttributesOf(parent->folder, 1, (LPCITEMIDLIST*)&pidl, &flags);
if (flags & SFGAO_FOLDER)
IShellFolder_BindToObject(parent->folder, pidl, NULL, &IID_IShellFolder, (void *)&item->folder);
}
parent_menu = parent->menuhandle;
item->parent = parent;
item->pidl = pidl;
existing_item_count = GetMenuItemCount(parent_menu);
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_SUBMENU|MIIM_DATA;
/* search for an existing menu item with this name or the spot to insert this item */
if (parent->pidl != NULL)
{
for (i=0; i<existing_item_count; i++)
{
struct menu_item* existing_item;
int cmp;
GetMenuItemInfoW(parent_menu, i, TRUE, &mii);
existing_item = ((struct menu_item*)mii.dwItemData);
if (!existing_item)
continue;
/* folders before files */
if (existing_item->folder && !item->folder)
continue;
if (!existing_item->folder && item->folder)
break;
cmp = CompareStringW(LOCALE_USER_DEFAULT, NORM_IGNORECASE, item->displayname, -1, existing_item->displayname, -1);
if (cmp == CSTR_LESS_THAN)
break;
if (cmp == CSTR_EQUAL)
{
match = TRUE;
break;
}
}
}
else
/* This item manually added to the root menu, so put it at the end */
i = existing_item_count;
if (!match)
{
/* no existing item with the same name; just add it */
mii.fMask = MIIM_STRING|MIIM_DATA;
mii.dwTypeData = item->displayname;
mii.dwItemData = (ULONG_PTR)item;
if (item->folder)
{
MENUINFO mi;
item->menuhandle = CreatePopupMenu();
mii.fMask |= MIIM_SUBMENU;
mii.hSubMenu = item->menuhandle;
mi.cbSize = sizeof(mi);
mi.fMask = MIM_MENUDATA;
mi.dwMenuData = (ULONG_PTR)item;
SetMenuInfo(item->menuhandle, &mi);
}
InsertMenuItemW(parent->menuhandle, i, TRUE, &mii);
list_add_tail(&items, &item->entry);
}
else if (item->folder)
{
/* there is an existing folder with the same name, combine them */
MENUINFO mi;
item->base = (struct menu_item*)mii.dwItemData;
item->menuhandle = item->base->menuhandle;
mii.dwItemData = (ULONG_PTR)item;
SetMenuItemInfoW(parent_menu, i, TRUE, &mii);
mi.cbSize = sizeof(mi);
mi.fMask = MIM_MENUDATA;
mi.dwMenuData = (ULONG_PTR)item;
SetMenuInfo(item->menuhandle, &mi);
list_add_tail(&items, &item->entry);
}
else {
/* duplicate shortcut, do nothing */
HeapFree(GetProcessHeap(), 0, item->displayname);
HeapFree(GetProcessHeap(), 0, item);
CoTaskMemFree(pidl);
item = NULL;
}
return item;
}
bool CMainMenu::ProcessMessage(HWND hWnd, DWORD /*FromAccelerator*/, DWORD MenuID)
{
switch (MenuID) {
case ID_FILE_OPEN_ROM:
{
stdstr File = g_BaseSystem->ChooseFileToOpen(hWnd);
if (File.length() > 0) {
g_BaseSystem->RunFileImage(File.c_str());
}
}
break;
case ID_FILE_ROM_INFO:
{
g_BaseSystem->DisplayRomInfo(hWnd);
}
break;
case ID_FILE_STARTEMULATION:
_Gui->SaveWindowLoc();
//Before we go and create the new system, ensure the previous one has been closed
CN64System::CloseSystem();
//Ok now g_BaseSystem should definitely be clean for initialization
g_BaseSystem = new CN64System(g_Plugins, false);
//Now we have created again, we can start up emulation
g_BaseSystem->StartEmulation(true);
break;
case ID_FILE_ENDEMULATION:
WriteTrace(TraceDebug,__FUNCTION__ ": ID_FILE_ENDEMULATION");
CN64System::CloseSystem();
_Gui->SaveWindowLoc();
break;
case ID_FILE_ROMDIRECTORY:
WriteTrace(TraceDebug,__FUNCTION__ ": ID_FILE_ROMDIRECTORY 1");
_Gui->SelectRomDir();
WriteTrace(TraceDebug,__FUNCTION__ ": ID_FILE_ROMDIRECTORY 2");
_Gui->RefreshMenu();
WriteTrace(TraceDebug,__FUNCTION__ ": ID_FILE_ROMDIRECTORY 3");
break;
case ID_FILE_REFRESHROMLIST: _Gui->RefreshRomBrowser(); break;
case ID_FILE_EXIT: DestroyWindow((HWND)hWnd); break;
case ID_SYSTEM_RESET_SOFT:
WriteTrace(TraceDebug,__FUNCTION__ ": ID_SYSTEM_RESET_SOFT");
g_BaseSystem->ExternalEvent(SysEvent_ResetCPU_Soft);
break;
case ID_SYSTEM_RESET_HARD:
WriteTrace(TraceDebug,__FUNCTION__ ": ID_SYSTEM_RESET_HARD");
g_BaseSystem->ExternalEvent(SysEvent_ResetCPU_Hard);
break;
case ID_SYSTEM_PAUSE:
_Gui->SaveWindowLoc();
WriteTrace(TraceDebug,__FUNCTION__ ": ID_SYSTEM_PAUSE");
if (g_Settings->LoadBool(GameRunning_CPU_Paused))
{
g_BaseSystem->ExternalEvent(SysEvent_ResumeCPU_FromMenu);
} else {
g_BaseSystem->ExternalEvent(SysEvent_PauseCPU_FromMenu);
}
WriteTrace(TraceDebug,__FUNCTION__ ": ID_SYSTEM_PAUSE 1");
break;
case ID_SYSTEM_BITMAP:
{
stdstr Dir(g_Settings->LoadString(Directory_SnapShot));
WriteTraceF(TraceGfxPlugin,__FUNCTION__ ": CaptureScreen(%s): Starting",Dir.c_str());
g_Plugins->Gfx()->CaptureScreen(Dir.c_str());
WriteTrace(TraceGfxPlugin,__FUNCTION__ ": CaptureScreen: Done");
}
break;
case ID_SYSTEM_LIMITFPS:
WriteTrace(TraceDebug,__FUNCTION__ ": ID_SYSTEM_LIMITFPS");
g_Settings->SaveBool(GameRunning_LimitFPS,!g_Settings->LoadBool(GameRunning_LimitFPS));
WriteTrace(TraceDebug,__FUNCTION__ ": ID_SYSTEM_LIMITFPS 1");
break;
case ID_SYSTEM_SAVE:
WriteTrace(TraceDebug,__FUNCTION__ ": ID_SYSTEM_SAVE");
g_BaseSystem->ExternalEvent(SysEvent_SaveMachineState);
break;
case ID_SYSTEM_SAVEAS:
{
char drive[_MAX_DRIVE] ,dir[_MAX_DIR], fname[_MAX_FNAME],ext[_MAX_EXT];
char Directory[255], SaveFile[255];
OPENFILENAME openfilename;
memset(&SaveFile, 0, sizeof(SaveFile));
memset(&openfilename, 0, sizeof(openfilename));
g_Settings->LoadString(Directory_LastSave, Directory,sizeof(Directory));
openfilename.lStructSize = sizeof( openfilename );
openfilename.hwndOwner = (HWND)hWnd;
openfilename.lpstrFilter = "PJ64 Saves (*.zip, *.pj)\0*.pj?;*.pj;*.zip;";
openfilename.lpstrFile = SaveFile;
openfilename.lpstrInitialDir = Directory;
openfilename.nMaxFile = MAX_PATH;
openfilename.Flags = OFN_HIDEREADONLY;
g_BaseSystem->ExternalEvent(SysEvent_PauseCPU_SaveGame);
if (GetSaveFileName (&openfilename))
{
_splitpath( SaveFile, drive, dir, fname, ext );
if (_stricmp(ext, ".pj") == 0 || _stricmp(ext, ".zip") == 0)
{
_makepath( SaveFile, drive, dir, fname, NULL );
_splitpath( SaveFile, drive, dir, fname, ext );
if (_stricmp(ext, ".pj") == 0)
{
_makepath( SaveFile, drive, dir, fname, NULL );
}
}
g_Settings->SaveString(GameRunning_InstantSaveFile, SaveFile);
char SaveDir[MAX_PATH];
_makepath( SaveDir, drive, dir, NULL, NULL );
g_Settings->SaveString(Directory_LastSave,SaveDir);
g_BaseSystem->ExternalEvent(SysEvent_SaveMachineState);
}
g_BaseSystem->ExternalEvent(SysEvent_ResumeCPU_SaveGame);
}
break;
case ID_SYSTEM_RESTORE: WriteTrace(TraceDebug,__FUNCTION__ ": ID_SYSTEM_RESTORE"); g_BaseSystem->ExternalEvent(SysEvent_LoadMachineState); break;
case ID_SYSTEM_LOAD:
{
char Directory[255], SaveFile[255];
OPENFILENAME openfilename;
memset(&SaveFile, 0, sizeof(SaveFile));
memset(&openfilename, 0, sizeof(openfilename));
g_Settings->LoadString(Directory_LastSave, Directory,sizeof(Directory));
openfilename.lStructSize = sizeof( openfilename );
openfilename.hwndOwner = (HWND)hWnd;
openfilename.lpstrFilter = "PJ64 Saves (*.zip, *.pj)\0*.pj?;*.pj;*.zip;";
openfilename.lpstrFile = SaveFile;
openfilename.lpstrInitialDir = Directory;
openfilename.nMaxFile = MAX_PATH;
openfilename.Flags = OFN_HIDEREADONLY;
g_BaseSystem->ExternalEvent(SysEvent_PauseCPU_LoadGame);
if (GetOpenFileName (&openfilename)) {
g_Settings->SaveString(GameRunning_InstantSaveFile,SaveFile);
char SaveDir[MAX_PATH], drive[_MAX_DRIVE] ,dir[_MAX_DIR], fname[_MAX_FNAME],ext[_MAX_EXT];
_splitpath( SaveFile, drive, dir, fname, ext );
_makepath( SaveDir, drive, dir, NULL, NULL );
g_Settings->SaveString(Directory_LastSave,SaveDir);
g_System->LoadState();
}
g_BaseSystem->ExternalEvent(SysEvent_ResumeCPU_LoadGame);
}
break;
case ID_SYSTEM_CHEAT:
{
g_BaseSystem->SelectCheats(hWnd);
}
break;
case ID_SYSTEM_GSBUTTON:
g_BaseSystem->ExternalEvent(SysEvent_GSButtonPressed);
break;
case ID_OPTIONS_DISPLAY_FR:
g_Settings->SaveBool(UserInterface_DisplayFrameRate,!g_Settings->LoadBool(UserInterface_DisplayFrameRate));
break;
case ID_OPTIONS_CHANGE_FR:
switch (g_Settings->LoadDword(UserInterface_FrameDisplayType))
{
case FR_VIs:
g_Settings->SaveDword(UserInterface_FrameDisplayType,FR_DLs);
break;
case FR_DLs:
g_Settings->SaveDword(UserInterface_FrameDisplayType,FR_PERCENT);
break;
default:
g_Settings->SaveDword(UserInterface_FrameDisplayType,FR_VIs);
}
break;
case ID_OPTIONS_INCREASE_SPEED:
g_BaseSystem->IncreaseSpeed();
break;
case ID_OPTIONS_DECREASE_SPEED:
g_BaseSystem->DecreaeSpeed();
break;
case ID_OPTIONS_FULLSCREEN:
g_BaseSystem->ExternalEvent(SysEvent_ChangingFullScreen);
break;
case ID_OPTIONS_FULLSCREEN2:
if (g_Settings->LoadBool(UserInterface_InFullScreen))
{
WriteTrace(TraceDebug,__FUNCTION__ ": ID_OPTIONS_FULLSCREEN a");
_Gui->MakeWindowOnTop(false);
Notify().SetGfxPlugin(NULL);
WriteTrace(TraceGfxPlugin,__FUNCTION__ ": ChangeWindow: Starting");
g_Plugins->Gfx()->ChangeWindow();
WriteTrace(TraceGfxPlugin,__FUNCTION__ ": ChangeWindow: Done");
ShowCursor(true);
_Gui->ShowStatusBar(true);
_Gui->MakeWindowOnTop(g_Settings->LoadBool(UserInterface_AlwaysOnTop));
g_Settings->SaveBool(UserInterface_InFullScreen,(DWORD)false);
} else {
WriteTrace(TraceDebug,__FUNCTION__ ": ID_OPTIONS_FULLSCREEN b");
ShowCursor(false);
WriteTrace(TraceDebug,__FUNCTION__ ": ID_OPTIONS_FULLSCREEN b 1");
_Gui->ShowStatusBar(false);
WriteTrace(TraceDebug,__FUNCTION__ ": ID_OPTIONS_FULLSCREEN b 2");
try {
WriteTrace(TraceGfxPlugin,__FUNCTION__ ": ChangeWindow: Starting");
g_Plugins->Gfx()->ChangeWindow();
WriteTrace(TraceGfxPlugin,__FUNCTION__ ": ChangeWindow: Done");
}
catch (...)
{
WriteTrace(TraceError,__FUNCTION__ ": Exception when going to full screen");
char Message[600];
sprintf(Message,"Exception caught\nFile: %s\nLine: %d",__FILE__,__LINE__);
MessageBox(NULL,Message,"Exception",MB_OK);
}
WriteTrace(TraceDebug,__FUNCTION__ ": ID_OPTIONS_FULLSCREEN b 4");
_Gui->MakeWindowOnTop(false);
WriteTrace(TraceDebug,__FUNCTION__ ": ID_OPTIONS_FULLSCREEN b 5");
Notify().SetGfxPlugin(g_Plugins->Gfx());
WriteTrace(TraceDebug,__FUNCTION__ ": ID_OPTIONS_FULLSCREEN b 3");
g_Settings->SaveBool(UserInterface_InFullScreen,true);
WriteTrace(TraceDebug,__FUNCTION__ ": ID_OPTIONS_FULLSCREEN b 6");
}
WriteTrace(TraceDebug,__FUNCTION__ ": ID_OPTIONS_FULLSCREEN 1");
break;
case ID_OPTIONS_ALWAYSONTOP:
if (g_Settings->LoadDword(UserInterface_AlwaysOnTop)) {
g_Settings->SaveBool(UserInterface_AlwaysOnTop,false);
_Gui->MakeWindowOnTop(false);
} else {
g_Settings->SaveBool(UserInterface_AlwaysOnTop,true);
_Gui->MakeWindowOnTop(g_Settings->LoadBool(GameRunning_CPU_Running));
}
break;
case ID_OPTIONS_CONFIG_RSP: WriteTrace(TraceDebug,__FUNCTION__ ": ID_OPTIONS_CONFIG_RSP"); g_Plugins->ConfigPlugin((DWORD)hWnd,PLUGIN_TYPE_RSP); break;
case ID_OPTIONS_CONFIG_GFX: WriteTrace(TraceDebug,__FUNCTION__ ": ID_OPTIONS_CONFIG_GFX"); g_Plugins->ConfigPlugin((DWORD)hWnd,PLUGIN_TYPE_GFX); break;
case ID_OPTIONS_CONFIG_AUDIO:WriteTrace(TraceDebug,__FUNCTION__ ": ID_OPTIONS_CONFIG_AUDIO"); g_Plugins->ConfigPlugin((DWORD)hWnd,PLUGIN_TYPE_AUDIO); break;
case ID_OPTIONS_CONFIG_CONT: WriteTrace(TraceDebug,__FUNCTION__ ": ID_OPTIONS_CONFIG_CONT"); g_Plugins->ConfigPlugin((DWORD)hWnd,PLUGIN_TYPE_CONTROLLER); break;
case ID_OPTIONS_CPU_USAGE:
WriteTrace(TraceDebug,__FUNCTION__ ": ID_OPTIONS_CPU_USAGE");
if (g_Settings->LoadBool(UserInterface_ShowCPUPer))
{
g_Settings->SaveBool(UserInterface_ShowCPUPer,false);
g_Notify->DisplayMessage(0,L"");
} else {
g_Settings->SaveBool(UserInterface_ShowCPUPer,true);
}
break;
case ID_OPTIONS_SETTINGS:
{
CSettingConfig SettingConfig;
SettingConfig.Display(hWnd);
}
break;
case ID_PROFILE_PROFILE:
g_Settings->SaveBool(Debugger_ProfileCode,!g_Settings->LoadBool(Debugger_ProfileCode));
g_BaseSystem->ExternalEvent(SysEvent_Profile_StartStop);
break;
case ID_PROFILE_RESETCOUNTER: g_BaseSystem->ExternalEvent(SysEvent_Profile_ResetLogs); break;
case ID_PROFILE_GENERATELOG: g_BaseSystem->ExternalEvent(SysEvent_Profile_GenerateLogs); break;
case ID_DEBUG_SHOW_TLB_MISSES:
g_Settings->SaveBool(Debugger_ShowTLBMisses,!g_Settings->LoadBool(Debugger_ShowTLBMisses));
break;
case ID_DEBUG_SHOW_UNHANDLED_MEM:
g_Settings->SaveBool(Debugger_ShowUnhandledMemory,!g_Settings->LoadBool(Debugger_ShowUnhandledMemory));
break;
case ID_DEBUG_SHOW_PIF_ERRORS:
g_Settings->SaveBool(Debugger_ShowPifErrors,!g_Settings->LoadBool(Debugger_ShowPifErrors));
break;
case ID_DEBUG_SHOW_DLIST_COUNT:
g_Notify->DisplayMessage(0,L"");
g_Settings->SaveBool(Debugger_ShowDListAListCount,!g_Settings->LoadBool(Debugger_ShowDListAListCount));
break;
case ID_DEBUG_SHOW_RECOMP_MEM_SIZE:
g_Notify->DisplayMessage(0,L"");
g_Settings->SaveBool(Debugger_ShowRecompMemSize,!g_Settings->LoadBool(Debugger_ShowRecompMemSize));
break;
case ID_DEBUG_SHOW_DIV_BY_ZERO:
g_Settings->SaveBool(Debugger_ShowDivByZero,!g_Settings->LoadBool(Debugger_ShowDivByZero));
break;
case ID_DEBUG_GENERATE_LOG_FILES:
g_Settings->SaveBool(Debugger_GenerateLogFiles,!g_Settings->LoadBool(Debugger_GenerateLogFiles));
break;
case ID_DEBUG_DISABLE_GAMEFIX:
g_Settings->SaveBool(Debugger_DisableGameFixes,!g_Settings->LoadBool(Debugger_DisableGameFixes));
break;
case ID_DEBUGGER_APPLOG_ERRORS:
{
DWORD LogLevel = g_Settings->LoadDword(Debugger_AppLogLevel);
if ((LogLevel & TraceError) != 0)
{
LogLevel &= ~TraceError;
} else {
LogLevel |= TraceError;
}
g_Settings->SaveDword(Debugger_AppLogLevel, LogLevel );
}
break;
case ID_DEBUGGER_APPLOG_SETTINGS:
{
DWORD LogLevel = g_Settings->LoadDword(Debugger_AppLogLevel);
if ((LogLevel & TraceSettings) != 0)
{
LogLevel &= ~TraceSettings;
} else {
LogLevel |= TraceSettings;
}
g_Settings->SaveDword(Debugger_AppLogLevel, LogLevel );
}
break;
case ID_DEBUGGER_APPLOG_RECOMPILER:
{
DWORD LogLevel = g_Settings->LoadDword(Debugger_AppLogLevel);
if ((LogLevel & TraceRecompiler) != 0)
{
LogLevel &= ~TraceRecompiler;
} else {
LogLevel |= TraceRecompiler;
}
g_Settings->SaveDword(Debugger_AppLogLevel, LogLevel );
}
break;
case ID_DEBUGGER_APPLOG_RSP:
{
DWORD LogLevel = g_Settings->LoadDword(Debugger_AppLogLevel);
if ((LogLevel & TraceRSP) != 0)
{
LogLevel &= ~TraceRSP;
} else {
LogLevel |= TraceRSP;
}
g_Settings->SaveDword(Debugger_AppLogLevel, LogLevel );
}
break;
case ID_DEBUGGER_APPLOG_TLB:
{
DWORD LogLevel = g_Settings->LoadDword(Debugger_AppLogLevel);
if ((LogLevel & TraceTLB) != 0)
{
LogLevel &= ~TraceTLB;
} else {
LogLevel |= TraceTLB;
}
g_Settings->SaveDword(Debugger_AppLogLevel, LogLevel );
}
break;
case ID_DEBUGGER_APPLOG_GFX_PLUGIN:
{
DWORD LogLevel = g_Settings->LoadDword(Debugger_AppLogLevel);
if ((LogLevel & TraceGfxPlugin) != 0)
{
LogLevel &= ~TraceGfxPlugin;
} else {
LogLevel |= TraceGfxPlugin;
}
g_Settings->SaveDword(Debugger_AppLogLevel, LogLevel );
}
break;
case ID_DEBUGGER_APPLOG_DEBUG:
{
DWORD LogLevel = g_Settings->LoadDword(Debugger_AppLogLevel);
if ((LogLevel & TraceDebug) != 0)
{
LogLevel &= ~TraceDebug;
} else {
LogLevel |= TraceDebug;
}
g_Settings->SaveDword(Debugger_AppLogLevel, LogLevel );
}
break;
case ID_DEBUGGER_APPLOG_AUDIO_EMU:
{
DWORD LogLevel = g_Settings->LoadDword(Debugger_AppLogLevel);
if ((LogLevel & TraceAudio) != 0)
{
LogLevel &= ~TraceAudio;
} else {
LogLevel |= TraceAudio;
}
g_Settings->SaveDword(Debugger_AppLogLevel, LogLevel );
}
break;
case ID_DEBUGGER_APPLOG_FLUSH:
g_Settings->SaveBool(Debugger_AppLogFlush,!g_Settings->LoadBool(Debugger_AppLogFlush));
break;
case ID_DEBUGGER_LOGOPTIONS: _Gui->EnterLogOptions(); break;
case ID_DEBUGGER_GENERATELOG:
g_Settings->SaveBool(Debugger_GenerateDebugLog,!g_Settings->LoadBool(Debugger_GenerateDebugLog));
break;
case ID_DEBUGGER_DUMPMEMORY:
g_BaseSystem->Debug_ShowMemoryDump();
break;
case ID_DEBUGGER_SEARCHMEMORY: g_BaseSystem->Debug_ShowMemorySearch(); break;
case ID_DEBUGGER_MEMORY: g_BaseSystem->Debug_ShowMemoryWindow(); break;
case ID_DEBUGGER_TLBENTRIES: g_BaseSystem->Debug_ShowTLBWindow(); break;
case ID_DEBUGGER_INTERRUPT_SP: g_BaseSystem->ExternalEvent(SysEvent_Interrupt_SP); break;
case ID_DEBUGGER_INTERRUPT_SI: g_BaseSystem->ExternalEvent(SysEvent_Interrupt_SI); break;
case ID_DEBUGGER_INTERRUPT_AI: g_BaseSystem->ExternalEvent(SysEvent_Interrupt_AI); break;
case ID_DEBUGGER_INTERRUPT_VI: g_BaseSystem->ExternalEvent(SysEvent_Interrupt_VI); break;
case ID_DEBUGGER_INTERRUPT_PI: g_BaseSystem->ExternalEvent(SysEvent_Interrupt_PI); break;
case ID_DEBUGGER_INTERRUPT_DP: g_BaseSystem->ExternalEvent(SysEvent_Interrupt_DP); break;
case ID_CURRENT_SAVE_DEFAULT:
Notify().DisplayMessage(3,L"Save Slot (%s) selected",GetSaveSlotString(MenuID - ID_CURRENT_SAVE_DEFAULT).c_str());
g_Settings->SaveDword(Game_CurrentSaveState,(DWORD)(MenuID - ID_CURRENT_SAVE_DEFAULT));
break;
case ID_CURRENT_SAVE_1:
case ID_CURRENT_SAVE_2:
case ID_CURRENT_SAVE_3:
case ID_CURRENT_SAVE_4:
case ID_CURRENT_SAVE_5:
case ID_CURRENT_SAVE_6:
case ID_CURRENT_SAVE_7:
case ID_CURRENT_SAVE_8:
case ID_CURRENT_SAVE_9:
case ID_CURRENT_SAVE_10:
Notify().DisplayMessage(3,L"Save Slot (%s) selected",GetSaveSlotString((MenuID - ID_CURRENT_SAVE_1) + 1).c_str());
g_Settings->SaveDword(Game_CurrentSaveState,(DWORD)((MenuID - ID_CURRENT_SAVE_1) + 1));
break;
case ID_HELP_SUPPORTFORUM: ShellExecute(NULL, "open", "http://forum.pj64-emu.com/", NULL, NULL, SW_SHOWMAXIMIZED); break;
case ID_HELP_HOMEPAGE: ShellExecute(NULL, "open", "http://www.pj64-emu.com", NULL, NULL, SW_SHOWMAXIMIZED); break;
case ID_HELP_ABOUT: _Gui->AboutBox(); break;
case ID_HELP_ABOUTSETTINGFILES: _Gui->AboutIniBox(); break;
default:
if (MenuID >= ID_RECENT_ROM_START && MenuID < ID_RECENT_ROM_END) {
stdstr FileName;
if (g_Settings->LoadStringIndex(File_RecentGameFileIndex,MenuID - ID_RECENT_ROM_START,FileName) &&
FileName.length() > 0)
{
g_BaseSystem->RunFileImage(FileName.c_str());
}
}
if (MenuID >= ID_RECENT_DIR_START && MenuID < ID_RECENT_DIR_END) {
int Offset = MenuID - ID_RECENT_DIR_START;
stdstr Dir = g_Settings->LoadStringIndex(Directory_RecentGameDirIndex,Offset);
if (Dir.length() > 0) {
g_Settings->SaveString(Directory_Game,Dir.c_str());
g_Notify->AddRecentDir(Dir.c_str());
_Gui->RefreshMenu();
if (_Gui->RomBrowserVisible()) {
_Gui->RefreshRomBrowser();
}
}
}
if (MenuID >= ID_LANG_START && MenuID < ID_LANG_END) {
MENUITEMINFOW menuinfo;
wchar_t String[300];
menuinfo.cbSize = sizeof(MENUITEMINFO);
menuinfo.fMask = MIIM_TYPE;
menuinfo.fType = MFT_STRING;
menuinfo.dwTypeData = String;
menuinfo.cch = sizeof(String);
GetMenuItemInfoW((HMENU)m_MenuHandle,MenuID,FALSE,&menuinfo);
//See if the language has changed, if not do nothing
//Set the language
g_Lang->SetLanguage(String);
_Gui->ResetRomBrowserColomuns();
break;
}
return false;
}
return true;
}
static void test_OleUIAddVerbMenu(void)
{
static const WCHAR cadabraW[] = {'c','a','d','a','b','r','a',0};
HMENU hMenu, verbmenu;
MENUITEMINFOW info;
WCHAR buffW[50];
int count;
BOOL ret;
ret = OleUIAddVerbMenuW(NULL, NULL, NULL, 0, 0, 0, FALSE, 0, NULL);
ok(!ret, "got %d\n", ret);
verbmenu = (HMENU)0xdeadbeef;
ret = OleUIAddVerbMenuW(NULL, NULL, NULL, 0, 0, 0, FALSE, 0, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
g_enumpos = 0;
ret = OleUIAddVerbMenuW(&oleobject, NULL, NULL, 0, 0, 0, FALSE, 0, NULL);
ok(!ret, "got %d\n", ret);
hMenu = CreatePopupMenu();
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
ret = InsertMenuItemW(hMenu, 0, TRUE, &info);
ok(ret, "got %d\n", ret);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
g_enumpos = 0;
ret = OleUIAddVerbMenuW(&oleobject, NULL, hMenu, 0, 0, 0, FALSE, 0, NULL);
ok(!ret, "got %d\n", ret);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
ret = InsertMenuItemW(hMenu, 0, TRUE, &info);
ok(ret, "got %d\n", ret);
count = GetMenuItemCount(hMenu);
ok(count == 2, "got %d\n", count);
verbmenu = (HMENU)0xdeadbeef;
g_enumpos = 0;
ret = OleUIAddVerbMenuW(&oleobject, NULL, hMenu, 1, 0, 0, FALSE, 0, &verbmenu);
ok(ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
count = GetMenuItemCount(hMenu);
ok(count == 2, "got %d\n", count);
/* object doesn't support EnumVerbs() */
g_enumverbsfail = TRUE;
g_enumpos = 0;
verbmenu = (HMENU)0xdeadbeef;
ret = OleUIAddVerbMenuW(&oleobject, NULL, hMenu, 2, 0, 0, FALSE, 0, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
g_enumverbsfail = FALSE;
/* added disabled item */
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STATE|MIIM_SUBMENU;
ret = GetMenuItemInfoW(hMenu, 2, TRUE, &info);
ok(ret, "got %d\n", ret);
ok(info.fState & MFS_DISABLED, "got state 0x%08x\n", info.fState);
ok(info.hSubMenu == NULL, "got submenu %p\n", info.hSubMenu);
count = GetMenuItemCount(hMenu);
ok(count == 3, "got %d\n", count);
/* now without object */
verbmenu = (HMENU)0xdeadbeef;
ret = OleUIAddVerbMenuW(NULL, testW, hMenu, 3, 42, 0, FALSE, 0, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STATE|MIIM_ID|MIIM_STRING|MIIM_SUBMENU;
info.dwTypeData = buffW;
info.cch = sizeof(buffW)/sizeof(WCHAR);
ret = GetMenuItemInfoW(hMenu, 3, TRUE, &info);
ok(ret, "got %d\n", ret);
ok(info.fState == MF_GRAYED, "got state 0x%08x\n", info.fState);
ok(info.wID == 42, "got id %d\n", info.wID);
ok(info.hSubMenu == NULL, "got submenu %p\n", info.hSubMenu);
count = GetMenuItemCount(hMenu);
ok(count == 4, "got %d\n", count);
verbmenu = (HMENU)0xdeadbeef;
g_enumpos = 0;
ret = OleUIAddVerbMenuW(&oleobject, NULL, hMenu, 4, 0, 0, FALSE, 0, &verbmenu);
ok(ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
/* check newly added item */
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STRING|MIIM_STATE|MIIM_SUBMENU;
info.dwTypeData = buffW;
info.cch = sizeof(buffW)/sizeof(WCHAR);
ret = GetMenuItemInfoW(hMenu, 4, TRUE, &info);
ok(ret, "got %d\n", ret);
/* Item string contains verb, usertype and localized string for 'Object' word,
exact format depends on localization. */
ok(strstrW(buffW, verbW) != NULL, "str %s\n", wine_dbgstr_w(buffW));
ok(info.fState == 0, "got state 0x%08x\n", info.fState);
ok(info.hSubMenu == NULL, "got submenu %p\n", info.hSubMenu);
count = GetMenuItemCount(hMenu);
ok(count == 5, "got %d\n", count);
DestroyMenu(hMenu);
/* try to add verb menu repeatedly, with same id */
hMenu = CreatePopupMenu();
count = GetMenuItemCount(hMenu);
ok(count == 0, "got %d\n", count);
verbmenu = NULL;
ret = OleUIAddVerbMenuW(NULL, NULL, hMenu, 0, 5, 10, TRUE, 3, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
verbmenu = NULL;
ret = OleUIAddVerbMenuW(NULL, NULL, hMenu, 0, 5, 10, TRUE, 3, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
/* same position, different id */
verbmenu = NULL;
ret = OleUIAddVerbMenuW(NULL, NULL, hMenu, 0, 6, 10, TRUE, 3, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
/* change added item string and state */
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STRING|MIIM_STATE;
info.fState = MFS_ENABLED;
info.dwTypeData = buffW;
lstrcpyW(buffW, cadabraW);
ret = SetMenuItemInfoW(hMenu, 0, TRUE, &info);
ok(ret, "got %d\n", ret);
buffW[0] = 0;
GetMenuStringW(hMenu, 0, buffW, sizeof(buffW)/sizeof(buffW[0]), MF_BYPOSITION);
ok(!lstrcmpW(buffW, cadabraW), "got %s\n", wine_dbgstr_w(buffW));
verbmenu = NULL;
ret = OleUIAddVerbMenuW(NULL, NULL, hMenu, 0, 5, 10, TRUE, 3, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STRING|MIIM_STATE;
buffW[0] = 0;
info.dwTypeData = buffW;
info.cch = sizeof(buffW)/sizeof(WCHAR);
ret = GetMenuItemInfoW(hMenu, 0, TRUE, &info);
ok(ret, "got %d\n", ret);
ok(lstrcmpW(buffW, cadabraW), "got %s\n", wine_dbgstr_w(buffW));
ok(info.fState == MF_GRAYED, "got state 0x%08x\n", info.fState);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
DestroyMenu(hMenu);
}
static HRESULT WINAPI ItemMenu_QueryContextMenu(
IContextMenu3 *iface,
HMENU hmenu,
UINT indexMenu,
UINT idCmdFirst,
UINT idCmdLast,
UINT uFlags)
{
ContextMenu *This = impl_from_IContextMenu3(iface);
INT uIDMax;
TRACE("(%p)->(%p %d 0x%x 0x%x 0x%x )\n", This, hmenu, indexMenu, idCmdFirst, idCmdLast, uFlags);
if(!(CMF_DEFAULTONLY & uFlags) && This->cidl > 0)
{
HMENU hmenures = LoadMenuW(shell32_hInstance, MAKEINTRESOURCEW(MENU_SHV_FILE));
if(uFlags & CMF_EXPLORE)
RemoveMenu(hmenures, FCIDM_SHVIEW_OPEN, MF_BYCOMMAND);
uIDMax = Shell_MergeMenus(hmenu, GetSubMenu(hmenures, 0), indexMenu, idCmdFirst, idCmdLast, MM_SUBMENUSHAVEIDS);
DestroyMenu(hmenures);
if(This->allvalues)
{
MENUITEMINFOW mi;
WCHAR str[255];
mi.cbSize = sizeof(mi);
mi.fMask = MIIM_ID | MIIM_STRING | MIIM_FTYPE;
mi.dwTypeData = str;
mi.cch = 255;
GetMenuItemInfoW(hmenu, FCIDM_SHVIEW_EXPLORE, MF_BYCOMMAND, &mi);
RemoveMenu(hmenu, FCIDM_SHVIEW_EXPLORE + idCmdFirst, MF_BYCOMMAND);
mi.cbSize = sizeof(mi);
mi.fMask = MIIM_ID | MIIM_TYPE | MIIM_STATE | MIIM_STRING;
mi.dwTypeData = str;
mi.fState = MFS_ENABLED;
mi.wID = FCIDM_SHVIEW_EXPLORE;
mi.fType = MFT_STRING;
InsertMenuItemW(hmenu, (uFlags & CMF_EXPLORE) ? 1 : 2, MF_BYPOSITION, &mi);
}
SetMenuDefaultItem(hmenu, 0, MF_BYPOSITION);
if(uFlags & ~CMF_CANRENAME)
RemoveMenu(hmenu, FCIDM_SHVIEW_RENAME, MF_BYCOMMAND);
else
{
UINT enable = MF_BYCOMMAND;
/* can't rename more than one item at a time*/
if (!This->apidl || This->cidl > 1)
enable |= MFS_DISABLED;
else
{
DWORD attr = SFGAO_CANRENAME;
IShellFolder_GetAttributesOf(This->parent, 1, (LPCITEMIDLIST*)This->apidl, &attr);
enable |= (attr & SFGAO_CANRENAME) ? MFS_ENABLED : MFS_DISABLED;
}
EnableMenuItem(hmenu, FCIDM_SHVIEW_RENAME, enable);
}
return MAKE_HRESULT(SEVERITY_SUCCESS, 0, uIDMax-idCmdFirst);
}
return MAKE_HRESULT(SEVERITY_SUCCESS, 0, 0);
}
static void test_OleUIAddVerbMenu(void)
{
HMENU hMenu, verbmenu;
MENUITEMINFOW info;
WCHAR buffW[50];
int count;
BOOL ret;
ret = OleUIAddVerbMenuW(NULL, NULL, NULL, 0, 0, 0, FALSE, 0, NULL);
ok(!ret, "got %d\n", ret);
verbmenu = (HMENU)0xdeadbeef;
ret = OleUIAddVerbMenuW(NULL, NULL, NULL, 0, 0, 0, FALSE, 0, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
g_enumpos = 0;
ret = OleUIAddVerbMenuW(&oleobject, NULL, NULL, 0, 0, 0, FALSE, 0, NULL);
ok(!ret, "got %d\n", ret);
hMenu = CreatePopupMenu();
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
ret = InsertMenuItemW(hMenu, 0, TRUE, &info);
ok(ret, "got %d\n", ret);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
g_enumpos = 0;
ret = OleUIAddVerbMenuW(&oleobject, NULL, hMenu, 0, 0, 0, FALSE, 0, NULL);
ok(!ret, "got %d\n", ret);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
ret = InsertMenuItemW(hMenu, 0, TRUE, &info);
ok(ret, "got %d\n", ret);
count = GetMenuItemCount(hMenu);
ok(count == 2, "got %d\n", count);
verbmenu = (HMENU)0xdeadbeef;
g_enumpos = 0;
ret = OleUIAddVerbMenuW(&oleobject, NULL, hMenu, 1, 0, 0, FALSE, 0, &verbmenu);
ok(ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
count = GetMenuItemCount(hMenu);
ok(count == 2, "got %d\n", count);
/* object doesn't support EnumVerbs() */
g_enumverbsfail = TRUE;
g_enumpos = 0;
verbmenu = (HMENU)0xdeadbeef;
ret = OleUIAddVerbMenuW(&oleobject, NULL, hMenu, 2, 0, 0, FALSE, 0, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
g_enumverbsfail = FALSE;
/* added disabled item */
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STATE|MIIM_SUBMENU;
ret = GetMenuItemInfoW(hMenu, 2, TRUE, &info);
ok(ret, "got %d\n", ret);
ok(info.fState & MFS_DISABLED, "got state 0x%08x\n", info.fState);
ok(info.hSubMenu == NULL, "got submenu %p\n", info.hSubMenu);
count = GetMenuItemCount(hMenu);
ok(count == 3, "got %d\n", count);
/* now without object */
verbmenu = (HMENU)0xdeadbeef;
ret = OleUIAddVerbMenuW(NULL, testW, hMenu, 3, 42, 0, FALSE, 0, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STATE|MIIM_ID|MIIM_STRING|MIIM_SUBMENU;
info.dwTypeData = buffW;
info.cch = sizeof(buffW)/sizeof(WCHAR);
ret = GetMenuItemInfoW(hMenu, 3, TRUE, &info);
ok(ret, "got %d\n", ret);
ok(info.fState == MF_GRAYED, "got state 0x%08x\n", info.fState);
ok(info.wID == 42, "got id %d\n", info.wID);
ok(info.hSubMenu == NULL, "got submenu %p\n", info.hSubMenu);
count = GetMenuItemCount(hMenu);
ok(count == 4, "got %d\n", count);
verbmenu = (HMENU)0xdeadbeef;
g_enumpos = 0;
ret = OleUIAddVerbMenuW(&oleobject, NULL, hMenu, 4, 0, 0, FALSE, 0, &verbmenu);
ok(ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
/* check newly added item */
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STRING|MIIM_STATE|MIIM_SUBMENU;
info.dwTypeData = buffW;
info.cch = sizeof(buffW)/sizeof(WCHAR);
ret = GetMenuItemInfoW(hMenu, 4, TRUE, &info);
ok(ret, "got %d\n", ret);
/* Item string contains verb, usertype and localized string for 'Object' word,
exact format depends on localization. */
ok(strstrW(buffW, verbW) != NULL, "str %s\n", wine_dbgstr_w(buffW));
ok(info.fState == 0, "got state 0x%08x\n", info.fState);
ok(info.hSubMenu == NULL, "got submenu %p\n", info.hSubMenu);
count = GetMenuItemCount(hMenu);
ok(count == 5, "got %d\n", count);
DestroyMenu(hMenu);
}
/*************************************************************************
* Shell_MergeMenus [SHELL32.67]
*/
HRESULT WINAPI Shell_MergeMenus (HMENU hmDst, HMENU hmSrc, UINT uInsert, UINT uIDAdjust, UINT uIDAdjustMax, ULONG uFlags)
{ int nItem;
HMENU hmSubMenu;
BOOL bAlreadySeparated;
MENUITEMINFOW miiSrc;
WCHAR szName[256];
UINT uTemp, uIDMax = uIDAdjust;
TRACE("hmenu1=%p hmenu2=%p 0x%04x 0x%04x 0x%04x 0x%04x\n",
hmDst, hmSrc, uInsert, uIDAdjust, uIDAdjustMax, uFlags);
if (!hmDst || !hmSrc)
{ return uIDMax;
}
nItem = GetMenuItemCount(hmDst);
if (uInsert >= (UINT)nItem) /* insert position inside menu? */
{
uInsert = (UINT)nItem; /* append on the end */
bAlreadySeparated = TRUE;
}
else
{
bAlreadySeparated = _SHIsMenuSeparator(hmDst, uInsert);
}
if ((uFlags & MM_ADDSEPARATOR) && !bAlreadySeparated)
{
/* Add a separator between the menus */
InsertMenuA(hmDst, uInsert, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
bAlreadySeparated = TRUE;
}
/* Go through the menu items and clone them*/
for (nItem = GetMenuItemCount(hmSrc) - 1; nItem >= 0; nItem--)
{
miiSrc.cbSize = sizeof(MENUITEMINFOW);
miiSrc.fMask = MIIM_STATE | MIIM_ID | MIIM_SUBMENU | MIIM_CHECKMARKS | MIIM_TYPE | MIIM_DATA;
/* We need to reset this every time through the loop in case menus DON'T have IDs*/
miiSrc.fType = MFT_STRING;
miiSrc.dwTypeData = szName;
miiSrc.dwItemData = 0;
miiSrc.cch = sizeof(szName)/sizeof(WCHAR);
if (!GetMenuItemInfoW(hmSrc, nItem, TRUE, &miiSrc))
{
continue;
}
/* TRACE("found menu=0x%04x %s id=0x%04x mask=0x%08x smenu=0x%04x\n", hmSrc, debugstr_a(miiSrc.dwTypeData), miiSrc.wID, miiSrc.fMask, miiSrc.hSubMenu);
*/
if (miiSrc.fType & MFT_SEPARATOR)
{
/* This is a separator; don't put two of them in a row */
if (bAlreadySeparated)
continue;
bAlreadySeparated = TRUE;
}
else if (miiSrc.hSubMenu)
{
if (uFlags & MM_SUBMENUSHAVEIDS)
{
miiSrc.wID += uIDAdjust; /* add uIDAdjust to the ID */
if (miiSrc.wID > uIDAdjustMax) /* skip ID's higher uIDAdjustMax */
continue;
if (uIDMax <= miiSrc.wID) /* remember the highest ID */
uIDMax = miiSrc.wID + 1;
}
else
{
miiSrc.fMask &= ~MIIM_ID; /* Don't set IDs for submenus that didn't have them already */
}
hmSubMenu = miiSrc.hSubMenu;
miiSrc.hSubMenu = CreatePopupMenu();
if (!miiSrc.hSubMenu) return(uIDMax);
uTemp = Shell_MergeMenus(miiSrc.hSubMenu, hmSubMenu, 0, uIDAdjust, uIDAdjustMax, uFlags & MM_SUBMENUSHAVEIDS);
if (uIDMax <= uTemp)
uIDMax = uTemp;
bAlreadySeparated = FALSE;
}
else /* normal menu item */
{
miiSrc.wID += uIDAdjust; /* add uIDAdjust to the ID */
if (miiSrc.wID > uIDAdjustMax) /* skip ID's higher uIDAdjustMax */
continue;
if (uIDMax <= miiSrc.wID) /* remember the highest ID */
uIDMax = miiSrc.wID + 1;
bAlreadySeparated = FALSE;
}
/* TRACE("inserting menu=0x%04x %s id=0x%04x mask=0x%08x smenu=0x%04x\n", hmDst, debugstr_a(miiSrc.dwTypeData), miiSrc.wID, miiSrc.fMask, miiSrc.hSubMenu);
*/
if (!InsertMenuItemW(hmDst, uInsert, TRUE, &miiSrc))
{
return(uIDMax);
}
}
/* Ensure the correct number of separators at the beginning of the
inserted menu items*/
if (uInsert == 0)
{
if (bAlreadySeparated)
{
DeleteMenu(hmDst, uInsert, MF_BYPOSITION);
}
}
else
{
if (_SHIsMenuSeparator(hmDst, uInsert-1))
{
if (bAlreadySeparated)
{
DeleteMenu(hmDst, uInsert, MF_BYPOSITION);
}
}
else
{
if ((uFlags & MM_ADDSEPARATOR) && !bAlreadySeparated)
{
/* Add a separator between the menus*/
InsertMenuW(hmDst, uInsert, MF_BYPOSITION | MF_SEPARATOR, 0, NULL);
}
}
}
return(uIDMax);
}