bool
MenuOperator::add_item(const Menu& submenu)
{
MENUITEMINFO menu_item_info;
menu_item_info.cbSize = sizeof(MENUITEMINFO);
menu_item_info.fMask = MIIM_SUBMENU | MIIM_TYPE;
menu_item_info.fType = MFT_STRING;
menu_item_info.hSubMenu = submenu.handle();
menu_item_info.dwTypeData = const_cast<char*>(submenu.label().c_str());
menu_item_info.cch = submenu.label().length();
InsertMenuItem(handle(), 0xffff, TRUE, &menu_item_info);
return true;
}
void sysmenu_init_topmost(HWND hWnd, HMENU hMenu)
{
MENUITEMINFO mii;
memset(&mii, 0, sizeof(mii));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_CHECKMARKS;
mii.fType = MFT_STRING;
mii.wID = IDM_TOPMOST;
mii.dwTypeData = (LPWSTR)L"TopMost (&T)";
mii.cch = (UINT) wcslen(mii.dwTypeData);
InsertMenuItem(hMenu, SC_CLOSE, FALSE, &mii);
changeStateTopMostMenu(hWnd,hMenu);
}
bool
MenuOperator::add_item(const MenuItem& item)
{
MENUITEMINFO menu_item_info;
menu_item_info.cbSize = sizeof(MENUITEMINFO);
menu_item_info.fMask = MIIM_ID | MIIM_TYPE;
menu_item_info.fType = MFT_STRING;
menu_item_info.wID = item.id();
menu_item_info.dwTypeData = const_cast<char*>(item.label().c_str());
menu_item_info.cch = item.label().length();
InsertMenuItem(handle(), 0xffff, TRUE, &menu_item_info);
return true;
}
static void menuhook(const char* menustr, HMENU hMenu, int flag)
{
if (flag == 1)
{
// Delete all related project entries and regenerate
int iFirstPos;
hMenu = FindMenuItem(hMenu, g_projMgrCmdTable[g_iORPCmdIndex].accel.accel.cmd, &iFirstPos);
if (hMenu)
{
int iSlot = 0;
int iPos;
while (true)
{
int iCmd = GetLoadCommandID(iSlot, false);
if (iCmd)
{
if (FindMenuItem(hMenu, iCmd, &iPos))
DeleteMenu(hMenu, iPos, MF_BYPOSITION);
else
break;
}
else
break;
iSlot++;
}
if (!g_relatedProjects.Get()->GetSize())
{
MENUITEMINFO mi={sizeof(MENUITEMINFO),};
mi.fMask = MIIM_TYPE | MIIM_STATE | MIIM_ID;
mi.fType = MFT_STRING;
mi.fState = MFS_GRAYED;
mi.dwTypeData = (char *)__localizeFunc(g_projMgrCmdTable[g_iORPCmdIndex].menuText,"sws_menu",0);
mi.wID = g_projMgrCmdTable[g_iORPCmdIndex].accel.accel.cmd;
InsertMenuItem(hMenu, iFirstPos, true, &mi);
}
else
{
for (int i = 0; i < g_relatedProjects.Get()->GetSize(); i++)
AddToMenu(hMenu, g_relatedProjects.Get()->Get(i)->Get(), GetLoadCommandID(i, true), iFirstPos++, true, MFS_UNCHECKED);
}
}
}
}
void Explorerplusplus::AddMenuEntries(LPITEMIDLIST pidlParent,
const std::list<LPITEMIDLIST> &pidlItemList,DWORD_PTR dwData,HMENU hMenu)
{
assert(dwData != NULL);
FileContextMenuInfo_t *pfcmi = reinterpret_cast<FileContextMenuInfo_t *>(dwData);
bool AddNewTabMenuItem = false;
if(pfcmi->uFrom == FROM_LISTVIEW)
{
if(pidlItemList.size() == 1)
{
SFGAOF FileAttributes = SFGAO_FOLDER;
LPITEMIDLIST pidlComplete = ILCombine(pidlParent,pidlItemList.front());
GetItemAttributes(pidlComplete,&FileAttributes);
CoTaskMemFree(pidlComplete);
if(FileAttributes & SFGAO_FOLDER)
{
AddNewTabMenuItem = true;
}
}
}
else if(pfcmi->uFrom == FROM_TREEVIEW)
{
/* The treeview only contains folders,
so the new tab menu item will always
be shown. */
AddNewTabMenuItem = true;
}
if(AddNewTabMenuItem)
{
MENUITEMINFO mii;
TCHAR szTemp[64];
LoadString(m_hLanguageModule,IDS_GENERAL_OPEN_IN_NEW_TAB,szTemp,SIZEOF_ARRAY(szTemp));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_STRING|MIIM_ID;
mii.wID = MENU_OPEN_IN_NEW_TAB;
mii.dwTypeData = szTemp;
InsertMenuItem(hMenu,1,TRUE,&mii);
}
}
static HMENU createpmenusettings (void)
{
HMENU hmnu;
MENUITEMINFO mii;
memset (&mii, 0, sizeof(MENUITEMINFO));
mii.type = MFT_STRING;
mii.id = 0;
mii.typedata = (DWORD)SM_ST_SET;
hmnu = CreatePopupMenu (&mii);
mii.type = MFT_STRING ;
mii.state = 0;
mii.id = IDM_PREF;
mii.typedata = (DWORD)SM_ST_PREF;
InsertMenuItem(hmnu, 0, TRUE, &mii);
return hmnu;
}
void CGitExtensionsShellEx::AddMenuItem(HMENU hMenu, LPSTR text, int resource, int firstId, int id, UINT position)
{
MENUITEMINFO mii;
memset(&mii, 0, sizeof(mii));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_STRING | MIIM_ID;
if (resource)
{
mii.fMask |= MIIM_BITMAP;
mii.hbmpItem = IsVistaOrLater() ? IconToBitmapPARGB32(resource) : HBMMENU_CALLBACK;
myIDMap[id] = resource;
myIDMap[firstId + id] = resource;
}
mii.wID = firstId + id;
mii.dwTypeData = text;
InsertMenuItem(hMenu, position, TRUE, &mii);
}
bool MyInsertMenu(HMENU hMenu, int pos, UINT id, const LPCTSTR szTitle, HBITMAP bm = NULL)
{
MENUITEMINFO MenuItem;
MenuItem.cbSize = sizeof(MenuItem);
if (szTitle)
MenuItem.fType = MFT_STRING;
else
MenuItem.fType = MFT_SEPARATOR;
MenuItem.fMask = MIIM_TYPE | MIIM_ID | MIIM_DATA;
if (bm)
MenuItem.fMask |= MIIM_CHECKMARKS;
MenuItem.wID = id;
MenuItem.hbmpChecked = bm;
MenuItem.hbmpUnchecked = bm;
MenuItem.dwTypeData = (LPWSTR)szTitle;
return InsertMenuItem(hMenu, pos, TRUE, &MenuItem) != 0;
}
void CMainWindow::CreateDebugMenu()
{
HMENU hMenu = CreatePopupMenu();
InsertMenu(hMenu, 0, MF_STRING, ID_MAIN_DEBUG_SHOWDEBUG, _T("Show Debugger"));
InsertMenu(hMenu, 1, MF_SEPARATOR, 0, nullptr);
InsertMenu(hMenu, 2, MF_STRING, ID_MAIN_DEBUG_DUMPFRAME, _T("Dump Next Frame\tF11"));
InsertMenu(hMenu, 3, MF_STRING, ID_MAIN_DEBUG_SHOWFRAMEDEBUG, _T("Show Frame Debugger"));
InsertMenu(hMenu, 4, MF_STRING | MF_CHECKED, ID_MAIN_DEBUG_ENABLEGSDRAW, _T("GS Draw Enabled"));
MENUITEMINFO ItemInfo;
memset(&ItemInfo, 0, sizeof(MENUITEMINFO));
ItemInfo.cbSize = sizeof(MENUITEMINFO);
ItemInfo.fMask = MIIM_STRING | MIIM_SUBMENU;
ItemInfo.dwTypeData = _T("Debug");
ItemInfo.hSubMenu = hMenu;
InsertMenuItem(GetMenu(m_hWnd), 3, TRUE, &ItemInfo);
}
bool
CUpgradrToolbar::OnDisableDropdown(LPNMTOOLBAR data)
{
RECT rect;
m_kToolbar.SendMessage(TB_GETRECT, data->iItem, reinterpret_cast<LPARAM>(&rect));
m_kToolbar.MapWindowPoints(HWND_DESKTOP, reinterpret_cast<LPPOINT>(&rect), 2);
TPMPARAMS tpm;
tpm.cbSize = sizeof(tpm);
tpm.rcExclude = rect;
CMenu menu;
menu.LoadMenu(MAKEINTRESOURCE(IDR_DISABLEMENU));
if (menu.IsNull()) throw CUpgradrWindowsError(GetLastError());
ScriptManagerLock scriptManager;
MENUITEMINFO mii = { sizeof(MENUITEMINFO) };
UINT pos = 0;
UINT uID = 1000;
CMenuHandle popupMenu = menu.GetSubMenu(0);
if (popupMenu.IsNull()) throw CUpgradrWindowsError(GetLastError());
CScriptManager::iterator i = scriptManager->begin();
while (i!=scriptManager->end())
{
CScript* script = i->second;
memset(&mii, 0, sizeof(MENUITEMINFO));
mii.cbSize = sizeof(MENUITEMINFO);
mii.fMask = MIIM_STATE | MIIM_STRING | MIIM_ID | MIIM_DATA;
mii.wID = uID++;
mii.fState = MFS_CHECKED;
mii.dwItemData = i->first;
TCHAR buf[1024];
_tcscpy_s(buf, 1024, script->Name());
mii.dwTypeData = buf;
InsertMenuItem(popupMenu, pos++, TRUE, &mii);
++i;
}
TrackPopupMenuEx(popupMenu, TPM_LEFTALIGN|TPM_LEFTBUTTON|TPM_VERTICAL, rect.left, rect.bottom, m_kToolbar, &tpm);
return true;
}
void BundlePane::OnTreeEndDrag(wxTreeEvent& event) {
if (!m_draggedItem.IsOk()) return;
const wxTreeItemId itemSrc = m_draggedItem;
const wxTreeItemId itemDst = event.GetItem();
m_draggedItem = wxTreeItemId();
if (!itemDst.IsOk()) return; // Invalid destintion
if (itemSrc == itemDst) return; // Can't drag to self
if (IsTreeItemParentOf(itemSrc, itemDst)) return; // Can't drag to one of your own children
wxLogDebug(wxT("Ending Drag over item: %s"), m_bundleTree->GetItemText(itemDst).c_str());
const BundleItemData* srcData = (BundleItemData*)m_bundleTree->GetItemData(itemSrc);
const BundleItemData* dstData = (BundleItemData*)m_bundleTree->GetItemData(itemDst);
if (!dstData->IsMenuItem()) return; // You can only drag items to menu
if (dstData->m_bundleId != srcData->m_bundleId) return; // Items can only be dragged within same bundle
// We have to cache uuid of submenus
const wxString subUuid = (srcData->m_type == BUNDLE_SUBDIR) ? srcData->m_uuid : wxString(wxEmptyString);
const unsigned int bundleId = srcData->m_bundleId;
PListDict infoDict = GetEditableMenuPlist(bundleId);
// Insert the item
Freeze();
const wxString name = m_bundleTree->GetItemText(itemSrc);
const wxTreeItemId insertedItem = InsertMenuItem(itemDst, name, new BundleItemData(*srcData), infoDict);
if (srcData->m_type == BUNDLE_SUBDIR) {
CopySubItems(itemSrc, insertedItem);
}
// Delete source ref
if (srcData->IsMenuItem()) RemoveMenuItem(itemSrc, false, infoDict);
Thaw();
// Save the modified plist
m_plistHandler.SaveBundle(bundleId);
// Update menu in editorFrame
m_syntaxHandler.ReParseBundles(true/*onlyMenu*/);
}
static void InsertMenuItemWithSeparators(HMENU hMenu, int uItem, MENUITEMINFO *lpmii)
{
TMO_IntMenuItem *pimi = MO_GetIntMenuItem((HGENMENU)lpmii->dwItemData), *p;
if (pimi == NULL)
return;
// check for separator before
if (uItem) {
UINT fType = GetMenuItemTypeData(hMenu, uItem - 1, p);
if (p != NULL && fType != MFT_SEPARATOR) {
if ((p->mi.position / SEPARATORPOSITIONINTERVAL) != (pimi->mi.position / SEPARATORPOSITIONINTERVAL)) {
// but might be supposed to be after the next one instead
if (!(uItem < GetMenuItemCount(hMenu) && GetMenuItemType(hMenu, uItem) == MFT_SEPARATOR))
InsertSeparator(hMenu, uItem);
uItem++;
}
}
}
// check for separator after
if (uItem < GetMenuItemCount(hMenu)) {
UINT fType = GetMenuItemTypeData(hMenu, uItem, p);
if (p != NULL && fType != MFT_SEPARATOR)
if ((p->mi.position / SEPARATORPOSITIONINTERVAL) != (pimi->mi.position / SEPARATORPOSITIONINTERVAL))
InsertSeparator(hMenu, uItem);
}
// create local copy *lpmii so we can change some flags
MENUITEMINFO mii = *lpmii;
int count = GetMenuItemCount(hMenu);
if (count != 0 && (count % 33) == 0 && pimi->mi.root != NULL) {
if (!(mii.fMask & MIIM_FTYPE))
mii.fType = 0;
mii.fMask |= MIIM_FTYPE;
mii.fType |= MFT_MENUBARBREAK;
}
if (!pimi->CustomName)
mii.dwTypeData = GetMenuItemText(pimi);
InsertMenuItem(hMenu, uItem, TRUE, &mii);
}
bool LiferayNativityContextMenus::_InsertMenu(HMENU hMenu, int location, int command, const wchar_t* text, bool enabled)
{
MENUITEMINFO menuItem = { sizeof(menuItem) };
menuItem.fMask = MIIM_STRING | MIIM_ID | MIIM_STATE;
menuItem.dwTypeData = (LPWSTR)text;
menuItem.wID = command;
menuItem.fState = enabled ? MFS_ENABLED : MFS_GRAYED;
if (!InsertMenuItem(hMenu, location, TRUE, &menuItem))
{
return false;
}
return true;
}
BOOL menuitem_add(HMENU hmenu, TCHAR* lpstr, UINT index, UINT id)
{
MENUITEMINFO mi;
mi.cbSize = sizeof(MENUITEMINFO);
mi.fMask = MIIM_STATE | MIIM_TYPE | MIIM_ID;
if (lpstr)
{
mi.fType = MFT_STRING;
mi.dwTypeData = lpstr;
mi.cch = strlen(lpstr);
}
else
{
mi.fType = MFT_SEPARATOR;
}
mi.fState = MFS_ENABLED;
mi.wID = id;
return InsertMenuItem(hmenu, index, FALSE, &mi);
}
BOOL CIconMenu::AppendMenuIcon(UINT_PTR nIDNewItem, LPCTSTR lpszNewItem, UINT uIcon /* = 0 */)
{
TCHAR menutextbuffer[255] = {0};
wcscpy_s(menutextbuffer, lpszNewItem);
if ((uIcon == 0)||(!bShowIcons))
return CMenu::AppendMenu(MF_STRING | MF_ENABLED, nIDNewItem, menutextbuffer);
MENUITEMINFO info = {0};
info.cbSize = sizeof(info);
info.fMask = MIIM_STRING | MIIM_FTYPE | MIIM_ID | MIIM_BITMAP;
info.fType = MFT_STRING;
info.wID = (UINT)nIDNewItem;
info.dwTypeData = menutextbuffer;
info.hbmpItem = bitmapUtils.IconToBitmapPARGB32(AfxGetResourceHandle(), uIcon);
icons[nIDNewItem] = uIcon;
return InsertMenuItem((UINT)nIDNewItem, &info);
}
void WinGui::Window::CreateMenu(){
menuID = CreatePopupMenu();
MENUITEMINFO mii;
mii.cbSize = sizeof(MENUITEMINFO);
mii.fMask = MIIM_STATE | MIIM_TYPE | MIIM_SUBMENU | MIIM_ID;
mii.fType = MFT_STRING;
mii.fState = MFS_ENABLED;
mii.dwTypeData = "Menu Item!";
mii.cch = strlen("Menu Item!");
mii.wID = PMENU;
mii.hSubMenu = NULL;
bool t = InsertMenuItem(menuID, 1, false, &mii);
int xy = GetMessagePos();
TrackPopupMenu(menuID,
TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_TOPALIGN,
LOWORD(xy), HIWORD(xy),
NULL, hWnd, NULL);
}
STDMETHODIMP CGitExtensionsShellEx::QueryContextMenu (
HMENU hmenu, UINT uMenuIndex, UINT uidFirstCmd,
UINT uidLastCmd, UINT uFlags )
{
// If the flags include CMF_DEFAULTONLY then we shouldn't do anything.
if ( uFlags & CMF_DEFAULTONLY )
return MAKE_HRESULT ( SEVERITY_SUCCESS, FACILITY_NULL, 0 );
//InsertMenu (hmenu, uMenuIndex, MF_BYPOSITION, uidFirstCmd, _T("GitEx") );
int id = 0;
CString szCascadeContextMenu = GetRegistryValue(HKEY_CURRENT_USER, "SOFTWARE\\GitExtensions\\GitExtensions", "ShellCascadeContextMenu");
CascadeContextMenu = !(szCascadeContextMenu == "False");
if (CascadeContextMenu)
{
// show context menu cascaded in submenu
HMENU popupMenu = CreateMenu();
id = PopulateMenu(popupMenu, uidFirstCmd + id, true);
//InsertMenu(hmenu, uMenuIndex++, MF_STRING | MF_BYPOSITION | MF_POPUP, (int)popupMenu, "Git Extensions");
MENUITEMINFO info;
info.cbSize = sizeof( MENUITEMINFO );
info.fMask = MIIM_ID | MIIM_TYPE | MIIM_SUBMENU;
info.fType = MFT_STRING;
info.wID = uidFirstCmd + 1;
info.dwTypeData = _T("Git Extensions");
info.hSubMenu = popupMenu;
InsertMenuItem(hmenu, 0, true, &info);
}
else
{
// show menu items directly
id = PopulateMenu(hmenu, uidFirstCmd + id, false);
}
return MAKE_HRESULT ( SEVERITY_SUCCESS, FACILITY_NULL, id-uidFirstCmd );
}
bool VirtualDimension::CreateLangMenu()
{
LocalesIterator it;
int count = 0;
// languageCode from registry
int currentLanguageCode = Locale::GetInstance().GetLanguage();
//Create the menu
m_pLangMenu = CreatePopupMenu();
//Add the entries
while(m_pLangMenu && it.GetNext())
{
String name;
HICON hicon;
name = it.GetLanguage(&hicon, NULL);
if (!name.empty())
{
MENUITEMINFO iteminfo;
int code = it.GetLanguageCode();
count++;
iteminfo.cbSize = sizeof(MENUITEMINFO);
iteminfo.fMask = MIIM_DATA|MIIM_STRING|MIIM_FTYPE|MIIM_BITMAP|MIIM_ID;
iteminfo.dwTypeData = (LPTSTR)name.c_str();
iteminfo.fType = MFT_STRING;
iteminfo.dwItemData = (ULONG_PTR)hicon;
iteminfo.hbmpItem = HBMMENU_CALLBACK;
iteminfo.wID = WM_VD_LANGUAGE+code; // in order to get WM_COMMAND msg
InsertMenuItem(m_pLangMenu, WM_VD_LANGUAGE+code, FALSE, &iteminfo);
if (code == currentLanguageCode)
CheckMenuItem(m_pLangMenu,(UINT)code+WM_VD_LANGUAGE,MF_BYCOMMAND|MF_CHECKED);
// then we connect any menu to the window proc
SetCommandHandler(WM_VD_LANGUAGE+code, this, &VirtualDimension::OnCmdLanguageChange);
SetSysCommandHandler(WM_VD_LANGUAGE+code, this, &VirtualDimension::OnCmdLanguageChange);
}
}
return count > 1;
}
/*static*/
void MenuWin::InsertItemIntoNativeMenu(
MenuItemWin* item, HMENU nativeMenu, bool registerNative, int position)
{
// A -1 value means to stick the new item at the end
if (position == -1) {
position = GetMenuItemCount(nativeMenu);
if (position == 0) position = 1;
}
MENUITEMINFO itemInfo;
item->CreateNative(&itemInfo, nativeMenu, registerNative);
BOOL success = InsertMenuItem(nativeMenu, position, TRUE, &itemInfo);
if (!success) {
string error = Win32Utils::QuickFormatMessage(GetLastError());
throw ValueException::FromString("Could not insert native item: " + error);
}
}
void ShowContextMenu(HWND hWnd)
{
MENUITEMINFO separatorBtn = {0};
separatorBtn.cbSize = sizeof(MENUITEMINFO);
separatorBtn.fMask = MIIM_FTYPE;
separatorBtn.fType = MFT_SEPARATOR;
HMENU hMenu = CreatePopupMenu();
if(hMenu != NULL)
{
InsertMenu(hMenu, -1, MF_BYPOSITION, ID_FILE_OPTIONS, GString(IDS_MENU_OPTIONS).c_str());
InsertMenuItem(hMenu, -1, FALSE, &separatorBtn);
InsertMenu(hMenu, -1, MF_BYPOSITION, IDM_EXIT, GString(IDS_MENU_EXIT).c_str());
POINT pt;
GetCursorPos(&pt);
SetForegroundWindow(hWnd);
TrackPopupMenu(hMenu, TPM_RIGHTBUTTON, pt.x, pt.y, 0, hWnd, NULL);
DestroyMenu(hMenu);
PostMessage(hWnd, WM_NULL, 0, 0);
}
}
void OMenu::InsertSeparator(UINT uItem, BOOL byPosition, const tstring& caption, bool accels /*= false*/) {
OMenuItem* mi = new OMenuItem();
mi->text = caption;
tstring::size_type i = 0;
if (!accels)
while ((i = mi->text.find('&')) != tstring::npos)
mi->text.erase(i, i+1);
if(mi->text.length() > 25) {
// mi->text = mi->text.substr(0, 25) + _T("..."); // !SMT!-UI
}
mi->parent = this;
items.push_back(mi);
MENUITEMINFO mii = {0};
mii.cbSize = sizeof(MENUITEMINFO);
mii.fMask = MIIM_FTYPE | MIIM_DATA;
mii.fType = MFT_OWNERDRAW | MFT_SEPARATOR;
mii.dwItemData = (ULONG_PTR)mi;
InsertMenuItem(uItem, byPosition, &mii);
}
void Menu_InsertMenuItem(HMENU hMenu, UINT uID, BOOL fByPosition, LPMENUITEMEX lpmix)
{
MENUITEMINFO mii;
LPMENUITEMEX lpmixSet = (LPMENUITEMEX)Mem_Alloc(sizeof(MENUITEMEX));
*lpmixSet = *lpmix;
lpmixSet->pszText = String_Duplicate(lpmix->pszText);
INITSTRUCT(mii, TRUE);
mii.fMask = MIIM_TYPE | MIIM_DATA | MIIM_ID;
mii.fType = MFT_OWNERDRAW; // | lpmix->fType;
mii.dwItemData = (DWORD)lpmixSet;
mii.wID = lpmix->wID;
if (lpmix->iImageIndex == IDP_TOOLBAR)
if (Menu_GetIconFromProcess != NULL)
Menu_GetIconFromProcess(lpmix->wID);
InsertMenuItem(hMenu, uID, fByPosition, &mii);
}
HMENU ProcessSubMenu(iteminfo *info, UINT idCmdFirst)
{
HMENU hSubmenu = CreatePopupMenu();
int i = 0;
while (info[i].id != -1)
{
MENUITEMINFO mii = { sizeof(MENUITEMINFO) };
mii.fMask = MIIM_STRING | MIIM_ID;
mii.wID = info[i].id + idCmdFirst;
mii.dwTypeData = info[i].text;
if (info[i].subitems != nullptr)
{
mii.fMask |= MIIM_SUBMENU;
mii.hSubMenu = ProcessSubMenu(info[i].subitems, idCmdFirst);
}
InsertMenuItem(hSubmenu, i++, TRUE, &mii);
}
return hSubmenu;
}
STDMETHODIMP CGitExtensionsShellEx::QueryContextMenu (
HMENU hmenu, UINT uMenuIndex, UINT uidFirstCmd,
UINT uidLastCmd, UINT uFlags )
{
// If the flags include CMF_DEFAULTONLY then we shouldn't do anything.
if ( uFlags & CMF_DEFAULTONLY )
return MAKE_HRESULT ( SEVERITY_SUCCESS, FACILITY_NULL, 0 );
int id = 0;
CString szCascadeContextMenu = GetRegistryValue(HKEY_CURRENT_USER, "SOFTWARE\\GitExtensions\\GitExtensions", "ShellCascadeContextMenu");
CascadeContextMenu = !(szCascadeContextMenu == "False");
if (CascadeContextMenu)
{
// show context menu cascaded in submenu
HMENU popupMenu = CreateMenu();
id = PopulateMenu(popupMenu, uidFirstCmd, id, true);
MENUITEMINFO info;
info.cbSize = sizeof( MENUITEMINFO );
info.fMask = MIIM_STRING | MIIM_ID | MIIM_BITMAP | MIIM_SUBMENU;
info.wID = uidFirstCmd + 1;
info.hbmpItem = IsVistaOrLater() ? IconToBitmapPARGB32(IDI_GITEXTENSIONS) : HBMMENU_CALLBACK;
myIDMap[1] = IDI_GITEXTENSIONS;
myIDMap[uidFirstCmd + 1] = IDI_GITEXTENSIONS;
info.dwTypeData = _T("Git Extensions");
info.hSubMenu = popupMenu;
InsertMenuItem(hmenu, 0, true, &info);
}
else
{
// show menu items directly
id = PopulateMenu(hmenu, uidFirstCmd, id, false);
}
return MAKE_HRESULT ( SEVERITY_SUCCESS, FACILITY_NULL, id );
}
LRESULT CALLBACK winproc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
sprintf(tmp, "%d (%d, %d)", uMsg, wParam, lParam);
//logger.Debug("winproc()", message);
// Make sure we are dealing with the correct menu.
// We do this by checking the first menu item in the menu.
// If it is a well-known one we go further. Otherwise we skip.
if (uMsg == WM_INITMENUPOPUP) {
MENUITEMINFO mii;
mii.cbSize = sizeof(MENUITEMINFO);
mii.fMask = MIIM_ID;
GetMenuItemInfo((HMENU) wParam, 0, TRUE, &mii);
if (mii.wID == kMLMenuFirstItem) {
sprintf(tmp, "adding menu item: %s", kMLOrgMenuText);
logger.Debug("ml_org::winproc()", tmp);
// Delete the menu item first (the call is ignored if it does not exist)
DeleteMenu((HMENU) wParam, kMLOrgMenuID, MF_BYCOMMAND);
// Create a menu item in the Library button popupmenu
mii.cbSize = sizeof(MENUITEMINFO);
mii.fMask = MIIM_TYPE|MIIM_ID;
mii.wID = kMLOrgMenuID;
mii.fType = MFT_STRING;
mii.dwTypeData = kMLOrgMenuText;
// Make the actual call to insert it
InsertMenuItem((HMENU) wParam, 0, FALSE, &mii);
}
}
// Catch click on menu item here
if ((uMsg == WM_COMMAND)
&& (HIWORD(wParam) == 0)
&& (LOWORD(wParam) == kMLOrgMenuID)) {
organizeML();
}
// Call the default window proc to handle the message as well.
return CallWindowProc(mlWndproc, hwnd, uMsg, wParam, lParam);
}
IFACEMETHODIMP CContextMenu::QueryContextMenu(HMENU hMenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags)
{
// If uFlags include CMF_DEFAULTONLY then we should not do anything.
if (CMF_DEFAULTONLY & uFlags)
return MAKE_HRESULT(SEVERITY_SUCCESS, 0, USHORT(0));
MENUITEMINFO mii = { sizeof(mii) };
mii.fMask = MIIM_STRING | MIIM_ID | MIIM_SUBMENU;
mii.wID = idCmdFirst + curid;
mii.dwTypeData = L"KENSSharp";
mii.hSubMenu = ProcessSubMenu(rootmenu, idCmdFirst);
if (!InsertMenuItem(hMenu, indexMenu, TRUE, &mii))
{
return HRESULT_FROM_WIN32(GetLastError());
}
// Return an HRESULT value with the severity set to SEVERITY_SUCCESS.
// Set the code value to the offset of the largest command identifier
// that was assigned, plus one (1).
return MAKE_HRESULT(SEVERITY_SUCCESS, 0, USHORT(curid + 1));
}
bool ContextMenuExt::MenuItemInitDelete(UINT pos, UINT cmdId)
{
MENUITEMINFO mii = { sizeof(mii) };
mii.fMask = MIIM_STRING | MIIM_FTYPE | MIIM_ID | MIIM_STATE;
mii.fType = MFT_STRING;
mii.fState = MFS_GRAYED;
// need folders or files
if (m_selectionHasFiles || m_selectionHasFolders) {
mii.fState = MFS_ENABLED;
}
mii.wID = cmdId;
mii.dwTypeData = &commandInfoMap[CMD_DELETE].menuText[0];
LoadAndSetBitmapByIcon(&mii, CMD_DELETE);
if (!InsertMenuItem(m_hSubMenu, pos, TRUE, &mii))
{
return false;
}
m_cmdIdToCommand[cmdId] = CommandId::CMD_DELETE;
return true;
}
bool ContextMenuExt::MenuItemInitShare(UINT pos, UINT cmdId)
{
MENUITEMINFO mii = { sizeof(mii) };
mii.fMask = MIIM_STRING | MIIM_FTYPE | MIIM_ID | MIIM_STATE;
mii.fType = MFT_STRING;
mii.fState = MFS_GRAYED;
// enable only for single folder
if (m_selectionOnlyOne && m_selectionHasFolders && !m_selectionHasFiles) {
mii.fState = MFS_ENABLED;
}
mii.wID = cmdId;
mii.dwTypeData = &commandInfoMap[CMD_SHARE].menuText[0];
LoadAndSetBitmapByIcon(&mii, CMD_SHARE);
if (!InsertMenuItem(m_hSubMenu, pos, TRUE, &mii))
{
return false;
}
m_cmdIdToCommand[cmdId] = CommandId::CMD_SHARE;
return true;
}
void SWELL_InsertMenu(HMENU menu, int pos, int flag, UINT_PTR idx, const char *str)
{
MENUITEMINFO mi={sizeof(mi),MIIM_ID|MIIM_STATE|MIIM_TYPE,MFT_STRING,
(flag & ~MF_BYPOSITION),(flag&MF_POPUP) ? 0 : (int)idx,NULL,NULL,NULL,0,(char *)str};
if (flag&MF_POPUP)
{
mi.hSubMenu = (HMENU)idx;
mi.fMask |= MIIM_SUBMENU;
mi.fState &= ~MF_POPUP;
}
if (flag&MF_SEPARATOR)
{
mi.fMask=MIIM_TYPE;
mi.fType=MFT_SEPARATOR;
mi.fState &= ~MF_SEPARATOR;
}
InsertMenuItem(menu,pos,(flag&MF_BYPOSITION) ? TRUE : FALSE, &mi);
}
// copied from swell-menu.mm, can have a common impl someday
int SWELL_GenerateMenuFromList(HMENU hMenu, const void *_list, int listsz)
{
SWELL_MenuGen_Entry *list = (SWELL_MenuGen_Entry *)_list;
const int l1=strlen(SWELL_MENUGEN_POPUP_PREFIX);
while (listsz>0)
{
int cnt=1;
if (!list->name) SWELL_Menu_AddMenuItem(hMenu,NULL,-1,0);
else if (!strcmp(list->name,SWELL_MENUGEN_ENDPOPUP)) return list + 1 - (SWELL_MenuGen_Entry *)_list;
else if (!strncmp(list->name,SWELL_MENUGEN_POPUP_PREFIX,l1))
{
MENUITEMINFO mi={sizeof(mi),MIIM_SUBMENU|MIIM_STATE|MIIM_TYPE,MFT_STRING,0,0,CreatePopupMenuEx(list->name+l1),NULL,NULL,0,(char *)list->name+l1};
cnt += SWELL_GenerateMenuFromList(mi.hSubMenu,list+1,listsz-1);
InsertMenuItem(hMenu,GetMenuItemCount(hMenu),TRUE,&mi);
}
else SWELL_Menu_AddMenuItem(hMenu,list->name,list->idx,list->flags);
list+=cnt;
listsz -= cnt;
}
}