Esempio n. 1
0
MIR_CORE_DLL(void) TranslateMenu_LP(HMENU hMenu, int _hLangpack)
{
	MUUID *uuid = Langpack_LookupUuid(_hLangpack);

	MENUITEMINFO mii = { 0 };
	mii.cbSize = sizeof(mii);

	for (int i = GetMenuItemCount(hMenu) - 1; i >= 0; i--) {
		TCHAR str[256];
		mii.fMask = MIIM_TYPE | MIIM_SUBMENU;
		mii.dwTypeData = (TCHAR*)str;
		mii.cch = _countof(str);
		GetMenuItemInfo(hMenu, i, TRUE, &mii);

		if (mii.cch && mii.dwTypeData) {
			TCHAR *result = (TCHAR*)LangPackTranslateString(uuid, (const char*)mii.dwTypeData, TRUE);
			if (result != mii.dwTypeData) {
				mii.dwTypeData = result;
				mii.fMask = MIIM_TYPE;
				SetMenuItemInfo(hMenu, i, TRUE, &mii);
			}
		}

		if (mii.hSubMenu != NULL)
			TranslateMenu_LP(mii.hSubMenu, _hLangpack);
	}
}
Esempio n. 2
0
void add_or_update_menu_item(int menuId, wchar_t* title, wchar_t* tooltip, short disabled, short checked) {
    // todo(thomasf),, should title and tooltip be freeed?
    MENUITEMINFO menuItemInfo;
    menuItemInfo.cbSize = sizeof(MENUITEMINFO);
    menuItemInfo.fMask = MIIM_FTYPE | MIIM_STRING | MIIM_DATA | MIIM_STATE;
    menuItemInfo.fType = MFT_STRING;
    menuItemInfo.dwTypeData = title;
    menuItemInfo.cch = wcslen(title) + 1;
    menuItemInfo.dwItemData = (ULONG_PTR)menuId;
    menuItemInfo.fState = 0;
    if (disabled == 1) {
        menuItemInfo.fState |= MFS_DISABLED;
    }
    if (checked == 1) {
        menuItemInfo.fState |= MFS_CHECKED;
    }

    int itemCount = GetMenuItemCount(hTrayMenu);
    int i;
    for (i = 0; i < itemCount; i++) {
        int id = GetMenuItemId(i);
        if (-1 == id) {
            continue;
        }
        if (menuId == id) {
            SetMenuItemInfo(hTrayMenu, i, TRUE, &menuItemInfo);
            break;
        }
    }
    if (i == itemCount) {
        InsertMenuItem(hTrayMenu, -1, TRUE, &menuItemInfo);
    }
}
Esempio n. 3
0
value
external_start (void)
{

/* Disable close button on console */
#if defined(__MINGW32__)
  char *buf = "[MLDonkey TitleSearch]\0"; /* if multiple instances */
  SetConsoleTitle((LPCTSTR)buf);
  myHWND = FindWindowEx(NULL, NULL, NULL, (LPCTSTR)buf);

  if (myHWND != NULL) {
    HMENU hmenu = GetSystemMenu(myHWND, FALSE);
    MENUITEMINFO CloseItem;
    CloseItem.cbSize = sizeof(MENUITEMINFO);
    CloseItem.fMask = MIIM_ID;
    CloseItem.wID = SC_MINIMIZE+1;
    EnableMenuItem(hmenu, SC_CLOSE, MF_BYCOMMAND | MF_GRAYED);
    SetMenuItemInfo(hmenu, SC_CLOSE, FALSE, &CloseItem);
    DrawMenuBar(myHWND);
  }
#endif  /* defined(__MINGW32__) */

#if defined(HAVE_PTHREAD) && defined(PTW32_STATIC_LIB)
	pthread_win32_process_attach_np();
#endif
	return Val_unit;

}
Esempio n. 4
0
LRESULT CMainWindow::OnIsNotSpam(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
	m_Dummy.Create(m_hWnd);
	m_Dummy.ShowWindow(SW_SHOW);

	m_ProgressDlg.CreateDialogInThread(false, m_hWnd);
	UINT nTotalMessages = 0;
	if (m_OETricks.SendSelectedMessagesToMC(false, nTotalMessages))
	{
		m_ProgressDlg.SetTotalMessages(nTotalMessages);
		m_nStyle = GetWindowLong(GWL_STYLE);
		SetWindowLong(GWL_STYLE, m_nStyle & ~(WS_MAXIMIZEBOX|WS_MINIMIZEBOX));
		
		HMENU hSysMenu = GetSystemMenu(FALSE);
		if (hSysMenu)
		{
			MENUITEMINFO mii;
			mii.cbSize = sizeof(MENUITEMINFO);
			mii.fMask = MIIM_STATE;
			mii.fState = MFS_GRAYED;
			
			SetMenuItemInfo(hSysMenu, SC_CLOSE, FALSE, &mii);
		}
	}

	return S_OK;
}
Esempio n. 5
0
BOOL CUIMenu::DeleteMenu(UINT nPosition, UINT nFlags)
{
	BOOL bByPosition;
	UI_MENU_ITEM_INFO * lpUIMenuItemInfo;

	bByPosition = nFlags & MF_BYPOSITION;
	lpUIMenuItemInfo = GetMenuItemInfo(nPosition, bByPosition);
	if (lpUIMenuItemInfo != NULL && UI_MENU_MAGIC == lpUIMenuItemInfo->nMagic)
	{
		if (lpUIMenuItemInfo->hSubMenu != NULL)
		{
			CUIMenu SubMenu(lpUIMenuItemInfo->hSubMenu);
			SubMenu.DeleteMenu(nPosition, nFlags);
		}

		//CUIManager::GetInstance()->ReleaseImage(lpUIMenuItemInfo->lpIconImgN);
		//CUIManager::GetInstance()->ReleaseImage(lpUIMenuItemInfo->lpIconImgH);

		delete lpUIMenuItemInfo;

		SetMenuItemInfo(nPosition, nFlags, NULL);
	}

	return ::DeleteMenu(m_hMenu, nPosition, nFlags);
}
void PlayerMenuItemWin::setTitle(const std::string &title)
{
    if (title.length() == 0)
    {
        CCLOG("MenuServiceWin::setTitle() - can not set menu title to empty, menu id (%s)", _menuId.c_str());
        return;
    }

    MENUITEMINFO menuitem;
    menuitem.cbSize = sizeof(menuitem);
    menuitem.fMask = MIIM_FTYPE | MIIM_STRING;
    menuitem.fType = (title.compare("-") == 0) ? MFT_SEPARATOR : MFT_STRING;
    std::u16string u16title;
    cocos2d::StringUtils::UTF8ToUTF16(title, u16title);
    menuitem.dwTypeData = (LPTSTR)u16title.c_str();
    if (SetMenuItemInfo(_parent->_hmenu, _commandId, MF_BYCOMMAND, &menuitem))
    {
        _title = title;
    }
    else
    {
        DWORD err = GetLastError();
        CCLOG("MenuServiceWin::setTitle() - set menu title failed, menu id (%s). error code = %u", _menuId.c_str(), err);
    }
}
Esempio n. 7
0
BOOL CUIMenu::RemoveMenu(UINT nPosition, UINT nFlags)
{
	BOOL bByPosition;
	UI_MENU_ITEM_INFO * lpUIMenuItemInfo;
	MENUITEMINFO stMenuItemInfo = { 0 };
	WCHAR cText[256] = { 0 };

	bByPosition = nFlags & MF_BYPOSITION ? TRUE : FALSE;
	lpUIMenuItemInfo = GetMenuItemInfo(nPosition, bByPosition);
	if (lpUIMenuItemInfo != NULL && UI_MENU_MAGIC == lpUIMenuItemInfo->nMagic)
	{
		if (lpUIMenuItemInfo->hSubMenu != NULL)
		{
			CUIMenu SubMenu(lpUIMenuItemInfo->hSubMenu);
			SubMenu.RemoveMenu(nPosition, nFlags);
		}

		//CUIManager::GetInstance()->ReleaseImage(lpUIMenuItemInfo->lpIconImgN);
		//CUIManager::GetInstance()->ReleaseImage(lpUIMenuItemInfo->lpIconImgH);

		delete lpUIMenuItemInfo;

		SetMenuItemInfo(nPosition, bByPosition, NULL);
	}

	return ::RemoveMenu(m_hMenu, nPosition, nFlags);
}
Esempio n. 8
0
void SetDefaultMenuItem(HMENU p_menu,unsigned p_id) {
	MENUITEMINFO info = {sizeof(info)};
	info.fMask = MIIM_STATE;
	GetMenuItemInfo(p_menu,p_id,FALSE,&info);
	info.fState |= MFS_DEFAULT;
	SetMenuItemInfo(p_menu,p_id,FALSE,&info);
}
Esempio n. 9
0
void LocalizeMenu(HMENU hMenu) {
	if (Localization == NULL)
		return;

	MENUITEMINFO mii;
	mii.cbSize = sizeof(mii);
	mii.fMask = MIIM_ID | MIIM_TYPE | MIIM_DATA;

	UINT idx = 0;
	while (GetMenuItemInfo(hMenu, idx, TRUE, &mii)) {
		if (mii.fType == MFT_STRING) {
			TCHAR *str = Localization->GetStr(mii.wID);
			if (str != NULL) {
				mii.cbSize = sizeof(mii);
				mii.fMask = MIIM_TYPE;
				mii.dwTypeData = (LPTSTR) str;
				mii.cch = wcslen(str);
				SetMenuItemInfo(hMenu, idx, TRUE, &mii);
			}
		}

		idx++;

		mii.cbSize = sizeof(mii);
		mii.fMask = MIIM_ID | MIIM_TYPE | MIIM_DATA;
	}
}
Esempio n. 10
0
static int winItemSetTitleAttrib(Ihandle* ih, const char* value)
{
  char *str;
  MENUITEMINFO menuiteminfo;

  if (ih->handle == (InativeHandle*)-1) /* check if submenu is actually created */
    return 1;

  if (!value)
  {
    str = "     ";
    value = str;
  }
  else
    str = iupMenuProcessTitle(ih, value);

  menuiteminfo.cbSize = sizeof(MENUITEMINFO); 
  menuiteminfo.fMask = MIIM_TYPE;
  menuiteminfo.fType = MFT_STRING;
  menuiteminfo.dwTypeData = str;
  menuiteminfo.cch = strlen(str);

  SetMenuItemInfo((HMENU)ih->handle, (UINT)ih->serial, FALSE, &menuiteminfo);

  if (str != value) free(str);

  winMenuUpdateBar(ih);

  return 1;
}
Esempio n. 11
0
void CDownloadMonitorDlg::OnContextMenu(CWnd* /*pWnd*/, CPoint point)
{
	CMainWnd* pMainWnd = (CMainWnd*)AfxGetMainWnd();
	if ( ! pMainWnd || ! IsWindow( pMainWnd->m_hWnd ) ) return;

	CDownloadsWnd* pDownWnd = (CDownloadsWnd*)pMainWnd->m_pWindows.Find( RUNTIME_CLASS(CDownloadsWnd) );
	if ( ! pDownWnd ) return;

	if ( ! pDownWnd->Select( m_pDownload ) ) return;

	CMenu* pPopup = ::Skin.GetMenu( _T("CDownloadsWnd.Download") );
	if ( ! pPopup ) return;

	MENUITEMINFO pInfo;
	pInfo.cbSize	= sizeof(pInfo);
	pInfo.fMask		= MIIM_STATE;
	GetMenuItemInfo( pPopup->GetSafeHmenu(), m_pDownload->IsCompleted() ?
		ID_DOWNLOADS_LAUNCH_COMPLETE : ID_DOWNLOADS_LAUNCH_COPY, FALSE, &pInfo );
	pInfo.fState	|= MFS_DEFAULT;
	SetMenuItemInfo( pPopup->GetSafeHmenu(), m_pDownload->IsCompleted() ?
		ID_DOWNLOADS_LAUNCH_COMPLETE : ID_DOWNLOADS_LAUNCH_COPY, FALSE, &pInfo );

	CoolMenu.AddMenu( pPopup, TRUE );

	UINT nID = pPopup->TrackPopupMenu( TPM_LEFTALIGN|TPM_LEFTBUTTON|TPM_RIGHTBUTTON|TPM_RETURNCMD,
		point.x, point.y, pDownWnd );

	if ( nID && pDownWnd->Select( m_pDownload ) )
	{
		pDownWnd->SendMessage( WM_COMMAND, nID );
	}
}
Esempio n. 12
0
/*
    Update menu string if text is non-null
    Update enable / disable if "enable" is non-zero. Positive will enable. Negative will disable.
    Update checked status if "check" is non-zero. Positive will enable, negative will disable.
 */
static void updateMenu(int id, char *text, int enable, int check)
{
    MENUITEMINFO    menuInfo;
    int             rc;

    if (text) {
        memset(&menuInfo, 0, sizeof(menuInfo));
        menuInfo.fMask = MIIM_STRING;
        menuInfo.cbSize = sizeof(menuInfo);
        menuInfo.fType = MFT_STRING;
        menuInfo.dwTypeData = NULL;
        menuInfo.fMask = MIIM_STRING;
        menuInfo.dwTypeData = text;
        menuInfo.cch = (uint) slen(text) + 1;
        rc = SetMenuItemInfo(app->subMenu, id, FALSE, &menuInfo);
    }
    if (enable > 0) {
        rc = EnableMenuItem(app->subMenu, id, MF_BYCOMMAND | MF_ENABLED);
    } else if (enable < 0) {
        rc = EnableMenuItem(app->subMenu, id, MF_BYCOMMAND | MF_GRAYED);
    }
    if (check > 0) {
        rc = CheckMenuItem(app->subMenu, id, MF_BYCOMMAND | MF_CHECKED);
    } else if (check < 0) {
        rc = CheckMenuItem(app->subMenu, id, MF_BYCOMMAND | MF_UNCHECKED);
    }
    rc = DrawMenuBar(app->appHwnd);
}
Esempio n. 13
0
void CDebugger::UpdateLoggingMenu()
{
	HMENU hMenu = GetMenu(m_hWnd);

	hMenu = GetSubMenu(hMenu, 2);

	const int stateCount = 8;
	bool nState[stateCount];
	memset(nState, 0, sizeof(nState));
//	nState[0] = m_virtualMachine.m_Logging.GetGSLoggingStatus();
//	nState[1] = m_virtualMachine.m_Logging.GetDMACLoggingStatus();
//	nState[2] = m_virtualMachine.m_Logging.GetIPULoggingStatus();
//	nState[3] = m_virtualMachine.m_Logging.GetOSLoggingStatus();
//	nState[4] = m_virtualMachine.m_Logging.GetOSRecordingStatus();
//	nState[5] = m_virtualMachine.m_Logging.GetSIFLoggingStatus();
//	nState[6] = m_virtualMachine.m_Logging.GetIOPLoggingStatus();
	for(unsigned int i = 0; i < stateCount; i++)
	{
		MENUITEMINFO mii;

		memset(&mii, 0, sizeof(MENUITEMINFO));
		mii.cbSize		= sizeof(MENUITEMINFO);
		mii.fMask		= MIIM_STATE;
		mii.fState		= nState[i] ? MFS_CHECKED : 0;

		SetMenuItemInfo(hMenu, i, TRUE, &mii);
	}
}
Esempio n. 14
0
void ContextMenu::ChangeSkinIndex(HMENU menu, int index)
{
	if (index > 0)
	{
		const int count = GetMenuItemCount(menu);
		for (int i = 0; i < count; ++i)
		{
			HMENU subMenu = GetSubMenu(menu, i);
			if (subMenu)
			{
				ChangeSkinIndex(subMenu, index);
			}
			else
			{
				MENUITEMINFO mii = {sizeof(MENUITEMINFO)};
				mii.fMask = MIIM_FTYPE | MIIM_ID;
				GetMenuItemInfo(menu, i, TRUE, &mii);
				if ((mii.fType & MFT_SEPARATOR) == 0)
				{
					mii.wID |= (index << 16);
					mii.fMask = MIIM_ID;
					SetMenuItemInfo(menu, i, TRUE, &mii);
				}
			}
		}
	}
}
Esempio n. 15
0
BOOL CCustomMenu::SetMenuItemInfo(CMenu *pMenu, BOOL Toped)
{
	if (pMenu != NULL)
	{
		int MenuCount = pMenu->GetMenuItemCount();
		for (int i=0;i<MenuCount;i++)
		{
			pMenu->GetMenuString(i,m_MenuList[m_Index].m_MenuText,MF_BYPOSITION);
			UINT MenuID = pMenu->GetMenuItemID(i);

			if ((MenuID==-1 || MenuID==65535) && Toped==TRUE)	//MenuID = -1 Toped = false 表示弹出式菜单
			{
				MenuID = -2; //顶层菜单
			};	
			m_MenuList[m_Index].m_MenuType = MenuID;		
			pMenu->ModifyMenu(i,MF_OWNERDRAW|MF_BYPOSITION |MF_STRING,m_MenuList[m_Index].m_MenuType,(LPSTR)&(m_MenuList[m_Index]));
			m_Index += 1;
			CMenu* pSubMenu = pMenu->GetSubMenu(i);
			if (pSubMenu)
			{
				SetMenuItemInfo(pSubMenu,FALSE);
			}
		}
	}
	return TRUE;
}
Esempio n. 16
0
static int winItemSetTitleAttrib(Ihandle* ih, const char* value)
{
  char *str;

  /* check if the submenu handle was created in winSubmenuAddToParent */
  if (ih->handle == (InativeHandle*)-1)
    return 1;

  if (!value)
  {
    str = "     ";
    value = str;
  }
  else
    str = iupMenuProcessTitle(ih, value);

  {
    TCHAR* tstr = iupwinStrToSystem(str);
    int len = lstrlen(tstr);
    MENUITEMINFO menuiteminfo;
    menuiteminfo.cbSize = sizeof(MENUITEMINFO); 
    menuiteminfo.fMask = MIIM_TYPE;
    menuiteminfo.fType = MFT_STRING;
    menuiteminfo.dwTypeData = tstr;
    menuiteminfo.cch = len;

    SetMenuItemInfo((HMENU)ih->handle, (UINT)ih->serial, FALSE, &menuiteminfo);
  }

  if (str != value) free(str);

  winMenuUpdateBar(ih);

  return 1;
}
Esempio n. 17
0
void InitalizeMenus() {
	MENUITEMINFO mii;
	int i;
	hMenu_main          = CreateMenu();
	hMenu_main_popup    = CreatePopupMenu();
	hMenu_windows_popup = CreatePopupMenu();
	hMenu_open_popup    = CreatePopupMenu();
	hMenu_rtf           = CreatePopupMenu();
	hMenu_lvw           = CreatePopupMenu();
	hMenu_client        = CreatePopupMenu();
	hMenu_lvwColumns    = CreatePopupMenu();
	hMenu_lvwBots       = CreatePopupMenu();
	hMenu_txtExt        = CreatePopupMenu();
	hMenu_lvwClan       = CreatePopupMenu();
	menus[0].id         = (int)hMenu_main_popup;
	menus[3].id         = (int)hMenu_windows_popup;
	menus[4].id         = (int)hMenu_open_popup;
	menus[27].id        = (int)hMenu_txtExt;
	for (i = 0; i != NUM_MENUITEMS; i++)
		AppendMenu(*menus[i].lphMenu, menus[i].type, menus[i].id, menus[i].title);
	SetMenu(hWnd_main, hMenu_main);	
	mii.cbSize = sizeof(MENUITEMINFO);
	mii.fMask = MIIM_STATE;
	mii.fState = MFS_CHECKED;
	for (i = 10080; i != 10085; i++)
		SetMenuItemInfo(hMenu_lvwColumns, i, false, &mii);
}
Esempio n. 18
0
void Menu::updateSeparator( HMENU hmenu, int& index, ItemPtr item, const MENUITEMINFO& info )
{
    if( ( info.fType & MFT_SEPARATOR ) == 0 )
    {
        MENUITEMINFO info = { sizeof( info ), MIIM_FTYPE, MFT_SEPARATOR };
        SetMenuItemInfo( hmenu, index, TRUE, &info );
    }
}
Esempio n. 19
0
void TrayIcon::SetMenuItemText(HMENU hMenu, UINT nID, LPCWSTR pszText)
{
	wchar_t szText[128];
	MENUITEMINFO mi = {sizeof(MENUITEMINFO)};
	mi.fMask = MIIM_STRING;
	lstrcpyn(szText, pszText, countof(szText));
	mi.dwTypeData = szText;
	SetMenuItemInfo(hMenu, nID, FALSE, &mi);
}
Esempio n. 20
0
void SetMenuName (HMENU menu, UINT pos, BOOL bypos, LPCTSTR name) {
MENUITEMINFO mii;
mii.cbSize = sizeof(MENUITEMINFO);
mii.fMask = MIIM_DATA;
if (!GetMenuItemInfo(menu, pos, bypos, &mii)) return;
if (mii.dwItemData) free((void*)(mii.dwItemData));
mii.dwItemData = name? (ULONG_PTR)tstrdup(name) :NULL;
SetMenuItemInfo(menu, pos, bypos, &mii);
}
Esempio n. 21
0
bool CBaseMenu::AddMenu(MENU_HANDLE hMenu, MenuItemList Items ) {
	if (Items.begin() == Items.end()) { return false; }

	UINT ItemID, uFlags;
	stdstr Text;
	stdstr String;
	for (MenuItemList::iterator MenuItem = Items.begin(); MenuItem != Items.end(); MenuItem++) {
		ItemID = MenuItem->ID;
		uFlags = MF_STRING;
		Text = _Lang->GetString(MenuItem->Title).c_str();

		if (MenuItem->Title == EMPTY_STRING && MenuItem->ManualString.length() > 0) {
			Text = MenuItem->ManualString;
		}
		if (ItemID == SPLITER) {
			uFlags |= MF_SEPARATOR;
		}
		if (MenuItem->ItemTicked) {
			uFlags |= MFS_CHECKED;
		}
		if (MenuItem->ItemEnabled) {
			uFlags |= MFS_ENABLED;
		} else {
			uFlags |= MFS_DISABLED;
		}
			
		MenuItemList * SubMenu = (MenuItemList *)MenuItem->SubMenu;
		if (ItemID == SUB_MENU && HIWORD(SubMenu) != 0 && (SubMenu->begin() != SubMenu->end())) {
			ItemID = (UINT)CreatePopupMenu();
			uFlags |= MF_POPUP;

			AddMenu((MENU_HANDLE)ItemID,*SubMenu);
		}
		
		if (ItemID == ID_PLUGIN_MENU)
		{
			ItemID = (UINT)MenuItem->SubMenu;
			uFlags |= MF_POPUP;
			MENUITEMINFO lpmii;
	
			lpmii.cbSize = sizeof(MENUITEMINFO);
			lpmii.fMask = MIIM_STATE;
			lpmii.fState = 0;
			SetMenuItemInfo((HMENU)ItemID, (DWORD)MenuItem->SubMenu, FALSE,&lpmii);
		}
		
		if (MenuItem->ShotCut.empty() == false) {
			String = Text;
			String += "\t";
			String += MenuItem->ShotCut;
			Text = String;
		}
		AppendMenu((HMENU)hMenu,uFlags,ItemID,Text.c_str());
	}
		
	return true;
}
Esempio n. 22
0
BOOL SetMenuName (HMENU hm, int n, const char* name) {
MENUITEMINFO mii;
mii.cbSize = sizeof(MENUITEMINFO);
mii.fMask = MIIM_DATA;
if (!GetMenuItemInfo(hm, n, TRUE, &mii)) return FALSE;
if (mii.dwItemData) free(mii.dwItemData);
mii.dwItemData = strdup(name);
return !!SetMenuItemInfo(hm, n, TRUE, &mii);
}
Esempio n. 23
0
static int mh_newindex (lua_State* l) {
menu* m = lua_touserdata(l,1);
const char* nm = luaL_checkstring(l,2);
if (streq(nm, "checked")) { 
if (m->sub) luaL_error(l, "unsupported operation");
int flags = MF_BYCOMMAND | (luaL_checkboolean(l,3)? MF_CHECKED : MF_UNCHECKED);
CheckMenuItem(m->parent, m->command, flags);
}
else if (streq(nm, "enabled")) {
if (m->sub) luaL_error(l, "unsupported operation");
int flags = MF_BYCOMMAND | (luaL_checkboolean(l,3)? MF_ENABLED : MF_DISABLED);
EnableMenuItem(m->parent, m->command, flags);
}
else if (streq(nm, "name")) SetMenuName(m->parent, m->position, luaL_checkstring(l,3));
else if (streq(nm, "text")) {
const char* str = luaL_checkstring(l,3);
const wchar_t* wstr = strcvt(str, CP_UTF8, CP_UTF16, NULL);
mh_updateLabel(m, wstr, -1, -1);
free(wstr);
}
else if (streq(nm, "onAction")) {
if (m->sub || m->command<IDM_CUSTOMCOMMAND) luaL_error(l, "unsupported operation");
if (!lua_isfunction(l,2)) luaL_typerror(l, 2, "function");
lua_pushlightuserdata(l, m->command);
lua_pushvalue(l,3);
lua_rawset(l, LUA_REGISTRYINDEX);
void** p = getCustomCommand(m->command - IDM_CUSTOMCOMMAND);
*p = lua_topointer(l,3);
}
else if (streq(nm, "accelerator")) {
const char* str = NULL;
if (!lua_isnil(l,3)) str = luaL_checkstring(l,3);
int f, k;
if (!(m->sub) && str && parseKeyName(str, &f, &k)) {
BOOL b = removeAccelerator(m->command);
addAccelerator(f, k, m->command);
mh_updateLabel(m, NULL, f, k);
}
else if (!str) {
BOOL b = removeAccelerator(m->command);
mh_updateLabel(m, NULL, 0, 0);
}}
else if (streq(nm, "radio")) {
BOOL b = luaL_checkboolean(l,3);
MENUITEMINFO mii;
mii.cbSize = sizeof(MENUITEMINFO);
mii.fMask = MIIM_FTYPE;
if (!GetMenuItemInfo(m->parent, m->command, FALSE, &mii)) return 0;
if (b) mii.fType|=MFT_RADIOCHECK;
else mii.fType&=~MFT_RADIOCHECK;
if (!SetMenuItemInfo(m->parent, m->command, FALSE, &mii)) return 0;
return 1;
}
// SUITE
else luaL_argerror(l, 2, "unknown property");
return 0;
}
Esempio n. 24
0
void NgineSlackBrowser::UpdateStartup()
{
	MENUITEMINFO mii;
	ZeroMemory(&mii, sizeof(mii));
	mii.cbSize = sizeof(mii);
	mii.fMask = MIIM_STATE;
	mii.fState = Util::IsStartup() ? MFS_CHECKED : 0;
	SetMenuItemInfo(m_hTrayMenu, ID_TRAY_CONTEXTMENU_STARTUP, FALSE, &mii);
}
Esempio n. 25
0
void wxMenuBar::SetLabelTop(size_t pos, const wxString& label)
{
    wxCHECK_RET( pos < GetMenuCount(), wxT("invalid menu index") );

    m_titles[pos] = label;

    if ( !IsAttached() )
    {
        return;
    }
    //else: have to modify the existing menu

    int mswpos = MSWPositionForWxMenu(GetMenu(pos),pos);

    UINT id;
    UINT flagsOld = ::GetMenuState((HMENU)m_hMenu, mswpos, MF_BYPOSITION);
    if ( flagsOld == 0xFFFFFFFF )
    {
        wxLogLastError(wxT("GetMenuState"));

        return;
    }

    if ( flagsOld & MF_POPUP )
    {
        // HIBYTE contains the number of items in the submenu in this case
        flagsOld &= 0xff;
        id = (UINT)::GetSubMenu((HMENU)m_hMenu, mswpos);
    }
    else
    {
        id = pos;
    }

#ifdef __WXWINCE__
    MENUITEMINFO info;
    wxZeroMemory(info);
    info.cbSize = sizeof(info);
    info.fMask = MIIM_TYPE;
    info.fType = MFT_STRING;
    info.cch = label.Length();
    info.dwTypeData = (LPTSTR) label.c_str();
    if ( !SetMenuItemInfo(GetHmenu(), id, TRUE, & info) )
    {
        wxLogLastError(wxT("SetMenuItemInfo"));
    }

#else
    if ( ::ModifyMenu(GetHmenu(), mswpos, MF_BYPOSITION | MF_STRING | flagsOld,
        id, label) == (int)0xFFFFFFFF )
    {
        wxLogLastError(wxT("ModifyMenu"));
    }
#endif

    Refresh();
}
Esempio n. 26
0
BOOL CIconMenu::SetMenuItemData(UINT_PTR nIDNewItem, LONG_PTR data)
{
	MENUITEMINFO menuinfo ={0};
	menuinfo.cbSize = sizeof(menuinfo);
	GetMenuItemInfo((UINT)nIDNewItem, &menuinfo);
	menuinfo.dwItemData =data;
	menuinfo.fMask |= MIIM_DATA;
	return SetMenuItemInfo((UINT)nIDNewItem ,&menuinfo);
}
Esempio n. 27
0
BOOL CUIMenu::AppendMenu(UINT nFlags, UINT_PTR nIDNewItem/* = 0*/,
	LPCTSTR lpszNewItem/* = NULL*/)
{
	UI_MENU_ITEM_INFO * lpUIMenuItemInfo;
	int nCount;
	BOOL bRet;

	nFlags |= MF_OWNERDRAW;
	bRet = ::AppendMenu(m_hMenu, nFlags, nIDNewItem, lpszNewItem);
	if (bRet)
	{
		lpUIMenuItemInfo = new UI_MENU_ITEM_INFO;
		if (lpUIMenuItemInfo != NULL)
		{
			memset(lpUIMenuItemInfo, 0, sizeof(UI_MENU_ITEM_INFO));

			lpUIMenuItemInfo->nMagic = UI_MENU_MAGIC;

			if (nFlags & MF_POPUP)				// 弹出菜单
			{
				lpUIMenuItemInfo->hSubMenu = (HMENU)nIDNewItem;
				if (lpszNewItem != NULL && _tcslen(lpszNewItem) > 0)
				{
					lpUIMenuItemInfo->szText = string_t(lpszNewItem);
					//_tcsncpy_s(lpUIMenuItemInfo->szText, lpszNewItem,
					//	sizeof(lpUIMenuItemInfo->szText) / sizeof(TCHAR));
				}
				
				bRet = EnableOwnerDraw(lpUIMenuItemInfo->hSubMenu, TRUE);
			}
			else
			{
				if (nFlags & MF_SEPARATOR)		// 分隔符
				{
					lpUIMenuItemInfo->nID = 0;
					lpUIMenuItemInfo->nType = MFT_SEPARATOR;
				}
				else							// 菜单项
				{
					lpUIMenuItemInfo->nID = nIDNewItem;
					if (lpszNewItem != NULL && _tcslen(lpszNewItem) > 0)
					{
						lpUIMenuItemInfo->szText = string_t(lpszNewItem);
						//_tcsncpy_s(lpUIMenuItemInfo->szText, lpszNewItem,
						//	sizeof(lpUIMenuItemInfo->szText) / sizeof(TCHAR));
					}
				}
			}

			nCount = ::GetMenuItemCount(m_hMenu);
			bRet = SetMenuItemInfo(nCount - 1, TRUE, lpUIMenuItemInfo);
		}
	}

	return bRet;
}
Esempio n. 28
0
BOOL CUIMenu::InsertMenu(UINT nPosition, UINT nFlags,
	UINT_PTR nIDNewItem/* = 0*/, LPCTSTR lpszNewItem/* = NULL*/)
{
	BOOL bByPosition;
	UI_MENU_ITEM_INFO * lpUIMenuItemInfo;
	BOOL bRet;

	bByPosition = nFlags & MF_BYPOSITION ? TRUE : FALSE;

	nFlags |= MF_OWNERDRAW;
	bRet = ::InsertMenu(m_hMenu, nPosition, nFlags, nIDNewItem, lpszNewItem);
	if (bRet)
	{
		lpUIMenuItemInfo = new UI_MENU_ITEM_INFO;
		if (lpUIMenuItemInfo != NULL)
		{
			memset(lpUIMenuItemInfo, 0, sizeof(UI_MENU_ITEM_INFO));

			lpUIMenuItemInfo->nMagic = UI_MENU_MAGIC;
			if (nFlags & MF_POPUP)				// 弹出菜单
			{
				lpUIMenuItemInfo->hSubMenu = (HMENU)nIDNewItem;
				if (lpszNewItem != NULL && _tcslen(lpszNewItem) > 0)
				{
					lpUIMenuItemInfo->szText = string_t(lpszNewItem);
					//_tcsncpy_s(lpUIMenuItemInfo->szText, lpszNewItem,
					//	sizeof(lpUIMenuItemInfo->szText) / sizeof(TCHAR));
				}

				bRet = EnableOwnerDraw(lpUIMenuItemInfo->hSubMenu, TRUE);
			}
			else
			{
				if (nFlags & MF_SEPARATOR)		// 分隔符
				{
					lpUIMenuItemInfo->nID = 0;
					lpUIMenuItemInfo->nType = MFT_SEPARATOR;
				}
				else if (nFlags & MF_STRING)	// 菜单项
				{
					lpUIMenuItemInfo->nID = nIDNewItem;
					if (lpszNewItem != NULL && _tcslen(lpszNewItem) > 0)
					{
						lpUIMenuItemInfo->szText = string_t(lpszNewItem);
						//_tcsncpy_s(lpUIMenuItemInfo->szText, lpszNewItem,
						//	sizeof(lpUIMenuItemInfo->szText) / sizeof(TCHAR));
					}
				}
			}

			bRet = SetMenuItemInfo(nPosition, bByPosition, lpUIMenuItemInfo);
		}
	}

	return bRet;
}
void SetText(HMENU m, UINT id, WCHAR *s)
{
    MENUITEMINFO mii = { 0 };
    mii.cbSize = sizeof(mii);
    mii.fMask = MIIM_STRING;
    mii.fType = MFT_STRING;
    mii.dwTypeData = s;
    mii.cch = (UINT)str::Len(s);
    SetMenuItemInfo(m, id, FALSE, &mii);
}
Esempio n. 30
0
void SetMenuCheckedState(HMENU menu, int did, int id)
{
    MENUITEMINFO info;
    info.cbSize = sizeof(MENUITEMINFO);
    info.fMask = MIIM_STATE;
    GetMenuItemInfo(menu, id, MF_BYCOMMAND, &info);
    info.fState = (info.fState &~MFS_CHECKED) | (GetWindowIndex(did) == -1 ? 0 :
        MFS_CHECKED);
    SetMenuItemInfo(menu, id, MF_BYCOMMAND, &info);
}