static int onLButtonUp(HWND hwnd, int x, int y, UINT)
{
bDrag = false;
if (nVidFullscreen) {
if (hwnd != hScrnWnd) {
return 1;
}
if (useDialogs()) {
RECT clientRect;
GetWindowRect(hwnd, &clientRect);
int clientx = clientRect.left + x;
int clienty = clientRect.top + y;
TrackPopupMenuEx(hMenuPopup, TPM_LEFTALIGN | TPM_TOPALIGN, clientx, clienty, hwnd, NULL);
return 0;
}
} else {
if (!bMenuEnabled) {
RECT clientRect;
GetWindowRect(hwnd, &clientRect);
int clientx = clientRect.left + x;
int clienty = clientRect.top + y;
if ((nLeftButtonX - clientx) < nDragX && (nLeftButtonX - clientx) > -nDragX
&& (nLeftButtonY - clienty) < nDragY && (nLeftButtonY - clienty) > -nDragY) {
TrackPopupMenuEx(hMenuPopup, TPM_LEFTALIGN | TPM_TOPALIGN, clientx, clienty, hwnd, NULL);
return 0;
}
}
}
return 1;
}
void CtrlBreakpointList::showBreakpointMenu(int itemIndex, const POINT &pt)
{
POINT screenPt(pt);
ClientToScreen(wnd, &screenPt);
bool isMemory;
int index = getBreakpointIndex(itemIndex, isMemory);
if (index == -1)
{
HMENU subMenu = GetSubMenu(g_hPopupMenus, POPUP_SUBMENU_ID_NEWBREAKPOINT);
switch (TrackPopupMenuEx(subMenu, TPM_RIGHTBUTTON | TPM_RETURNCMD, screenPt.x, screenPt.y, wnd, 0))
{
case ID_DISASM_ADDNEWBREAKPOINT:
{
BreakpointWindow bpw(wnd,cpu);
if (bpw.exec()) bpw.addBreakpoint();
}
break;
}
} else {
MemCheck mcPrev;
BreakPoint bpPrev;
if (isMemory) {
mcPrev = displayedMemChecks_[index];
} else {
bpPrev = displayedBreakPoints_[index];
}
HMENU subMenu = GetSubMenu(g_hPopupMenus, POPUP_SUBMENU_ID_BREAKPOINTLIST);
if (isMemory) {
CheckMenuItem(subMenu, ID_DISASM_DISABLEBREAKPOINT, MF_BYCOMMAND | (mcPrev.result & MEMCHECK_BREAK ? MF_CHECKED : MF_UNCHECKED));
} else {
CheckMenuItem(subMenu, ID_DISASM_DISABLEBREAKPOINT, MF_BYCOMMAND | (bpPrev.enabled ? MF_CHECKED : MF_UNCHECKED));
}
switch (TrackPopupMenuEx(subMenu, TPM_RIGHTBUTTON | TPM_RETURNCMD, screenPt.x, screenPt.y, wnd, 0))
{
case ID_DISASM_DISABLEBREAKPOINT:
if (isMemory) {
CBreakPoints::ChangeMemCheck(mcPrev.start, mcPrev.end, mcPrev.cond, MemCheckResult(mcPrev.result ^ MEMCHECK_BREAK));
} else {
CBreakPoints::ChangeBreakPoint(bpPrev.addr, !bpPrev.enabled);
}
break;
case ID_DISASM_EDITBREAKPOINT:
editBreakpoint(index);
break;
case ID_DISASM_ADDNEWBREAKPOINT:
{
BreakpointWindow bpw(wnd,cpu);
if (bpw.exec()) bpw.addBreakpoint();
}
break;
}
}
}
int PopUpMenu(const MenuVec &menu_items, int selected_index, const void *hwnd)
{
HMENU menu = CreatePopupMenu();
if(menu)
{
for(int i=0; i < menu_items.size(); i++)
{
std::string label = menu_items[i];
UINT flags = (i == selected_index ? (MF_STRING | MF_CHECKED) : MF_STRING);
if(label == "(-")
{
flags |= MF_SEPARATOR;
}
else if(label == "$OCIO")
{
char *file = std::getenv("OCIO");
if(file == NULL)
flags |= MF_GRAYED;
}
else if(label == "(nada)")
{
flags |= MF_GRAYED;
char appdata_path[MAX_PATH];
HRESULT result = SHGetFolderPath(NULL, CSIDL_COMMON_APPDATA, NULL,
SHGFP_TYPE_CURRENT, appdata_path);
if(result == S_OK)
{
label = "No configs in " + std::string(appdata_path) + "\\OpenColorIO\\";
}
}
AppendMenu(menu, flags, i + 1, label.c_str());
}
POINT pos;
GetCursorPos(&pos);
int result = TrackPopupMenuEx(menu,
(TPM_NONOTIFY | TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RETURNCMD),
pos.x, pos.y, (HWND)hwnd, NULL);
DestroyMenu(menu);
if(result == 0)
{
// means the user clicked off the menu
return selected_index;
}
else
return result - 1;
}
else
return selected_index;
}
void CtrlMemView::onMouseUp(WPARAM wParam, LPARAM lParam, int button)
{
if (button==2)
{
//popup menu?
POINT pt;
GetCursorPos(&pt);
switch (TrackPopupMenuEx(GetSubMenu(g_hPopupMenus,0),TPM_RIGHTBUTTON|TPM_RETURNCMD,pt.x,pt.y,wnd,0))
{
case ID_MEMVIEW_DUMP:
MessageBox(wnd,"This feature has not been implemented.","Sorry",0);
break;
case ID_MEMVIEW_COPYVALUE:
{
char temp[24];
sprintf(temp,"%08x",Memory::ReadUnchecked_U32(selection));
W32Util::CopyTextToClipboard(wnd,temp);
}
break;
}
return;
}
int x = LOWORD(lParam);
int y = HIWORD(lParam);
if (x>16)
{
curAddress=yToAddress(y);
selecting=false;
ReleaseCapture();
redraw();
}
}
void ShowTrayMenu(HWND hwnd)
{
POINT pt;
GetCursorPos(&pt);
HMENU hMenu;
hMenu = CreatePopupMenu();
if(hMenu)
{
if( IsWindowVisible(hwnd) )
InsertMenu(hMenu, -1, MF_BYPOSITION, SWM_HIDE, TEXT("Hide"));
else
InsertMenu(hMenu, -1, MF_BYPOSITION, SWM_SHOW, TEXT("Show"));
if (state == READY)
InsertMenu(hMenu, -1, MF_BYPOSITION, SWM_CONN, TEXT("Connect"));
else
InsertMenu(hMenu, -1, MF_BYPOSITION, SWM_LOGOFF, TEXT("Log Off"));
InsertMenu(hMenu, -1, MF_BYPOSITION, SWM_EXIT, TEXT("Exit"));
// note: must set window to the foreground or the
// menu won't disappear when it should
SetForegroundWindow(hwnd);
TrackPopupMenuEx(hMenu, TPM_BOTTOMALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON,
pt.x, pt.y, hwnd, NULL );
DestroyMenu(hMenu);
}
}
// Windows procedure override.
LRESULT Brainchild::WindowProc( UINT uMsg, WPARAM wParam, LPARAM lParam )
{
// Evaluate the message...
switch ( uMsg )
{
case WM_KEYDOWN:
/*if (wParam == 13) // Return key
m_pOwner->m_pFrame->SendMessage(WM_COMMAND, IDM_OPEN_SELECTED_PATH);*/
// Pass on all keys except the Context menu key.
if ( wParam != 0x5D )
break;
case WM_RBUTTONUP:
{
// Open the context menu at the cursor position.
ClsPoint pt;
GetCursorPos( pt );
TrackPopupMenuEx( m_pOwner->m_pFrame->m_ContextMenu, TPM_LEFTBUTTON | TPM_RIGHTBUTTON, pt.X(), pt.Y(), *m_pOwner->m_pFrame, NULL );
// If we got here because of a Context menu key
// we return so that the brainchild control does
// not get a chance to process it.
if ( uMsg == WM_KEYDOWN && wParam == 0x5D ) return 0;
break;
}
}
return ClsBrainchild::WindowProc( uMsg, wParam, lParam );
}
void ShowContextMenu(HWND hwnd, POINT pt)
{
HMENU hMenu = LoadMenu(g_hInst, MAKEINTRESOURCE(IDC_CONTEXTMENU));
if (hMenu)
{
HMENU hSubMenu = GetSubMenu(hMenu, 0);
if (hSubMenu)
{
// our window must be foreground before calling TrackPopupMenu or the menu will not disappear when the user clicks away
SetForegroundWindow(hwnd);
// respect menu drop alignment
UINT uFlags = TPM_RIGHTBUTTON;
if (GetSystemMetrics(SM_MENUDROPALIGNMENT) != 0)
{
uFlags |= TPM_RIGHTALIGN;
}
else
{
uFlags |= TPM_LEFTALIGN;
}
TrackPopupMenuEx(hSubMenu, uFlags, pt.x, pt.y, hwnd, NULL);
}
DestroyMenu(hMenu);
}
}
//----------------------------------------------------------------------------------------------
// ShowRightPopupMenu
//----------------------------------------------------------------------------------------------
VOID CStatusAreaIcon::ShowRightPopupMenu()
{
// プロパティ シートの状態を取得する
BOOL PropertySheetOpened = PropertySheet->IsOpened();
// ポップアップ メニューを作成する
HMENU Menu = LoadMenu( Instance, MAKEINTRESOURCE( IDR_MENU ) );
HMENU PopupMenu = GetSubMenu( Menu, 0 );
// 「プロパティ」をデフォルトにする
MENUITEMINFO ItemInfo;
ZeroMemory( &ItemInfo, sizeof( ItemInfo ) );
ItemInfo.cbSize = sizeof( ItemInfo );
GetMenuItemInfo( PopupMenu, IDM_PROPERTY, FALSE, &ItemInfo );
ItemInfo.fMask = MIIM_STATE;
ItemInfo.fState = MFS_ENABLED | MFS_DEFAULT;
if( PropertySheetOpened == TRUE )
{
ItemInfo.fState |= MFS_DISABLED;
}
SetMenuItemInfo( PopupMenu, IDM_PROPERTY, FALSE, &ItemInfo );
// 「設定の自動切換え」のチェックを設定する
GetMenuItemInfo( PopupMenu, IDM_AUTO_SETTING_CHANGE, FALSE, &ItemInfo );
ItemInfo.fMask = MIIM_STATE;
ItemInfo.fState = MFS_ENABLED;
if( Setting->AutoSettingChange == TRUE )
{
ItemInfo.fState |= MFS_CHECKED;
}
if( PropertySheetOpened == TRUE )
{
ItemInfo.fState |= MFS_DISABLED;
}
SetMenuItemInfo( PopupMenu, IDM_AUTO_SETTING_CHANGE, FALSE, &ItemInfo );
// 「終了」の有効・無効を設定する
GetMenuItemInfo( PopupMenu, IDM_EXIT, FALSE, &ItemInfo );
ItemInfo.fMask = MIIM_STATE;
ItemInfo.fState = MFS_ENABLED;
if( PropertySheetOpened == TRUE )
{
ItemInfo.fState |= MFS_DISABLED;
}
SetMenuItemInfo( PopupMenu, IDM_EXIT, FALSE, &ItemInfo );
// ポップアップ メニューを表示する
SetForegroundWindow( Wnd );
POINT CursorPos;
GetCursorPos( &CursorPos );
TrackPopupMenuEx(
PopupMenu
,TPM_LEFTALIGN | TPM_RIGHTBUTTON
,CursorPos.x
,CursorPos.y
,Wnd
,NULL );
DestroyMenu( Menu );
PostMessage( Wnd, WM_NULL, 0, 0 );
}
/**
* name: OnMenuPopup
* class: CAnnivEditCtrl
* desc: is called to show a popup menu for all anniversaries of a contact
* param: none
* return: nothing
**/
void CAnnivEditCtrl::OnMenuPopup()
{
POINT pt = { 0, 0 };
RECT rc;
HMENU hMenu;
WORD i;
if (hMenu = CreatePopupMenu()) {
SetFocus(_hBtnMenu);
MENUITEMINFO mii = { 0 };
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_ID|MIIM_STRING|MIIM_STATE;
// insert the items
for (i = 0; i < _numDates; i++) {
mii.fState = _pDates[i]->IsValid() ? MFS_CHECKED : MFS_UNCHECKED;
mii.dwTypeData = (LPTSTR)_pDates[i]->Description();
mii.wID = WM_USER + i;
if (!InsertMenuItem(hMenu, i, TRUE, &mii)) {
DestroyMenu(hMenu);
return;
}
}
ClientToScreen(_hBtnMenu, &pt);
GetClientRect(_hBtnMenu, &rc);
i = TrackPopupMenuEx(hMenu, TPM_RIGHTALIGN|TPM_RETURNCMD, pt.x + rc.right, pt.y + rc.bottom, _hwndDlg, NULL);
DestroyMenu(hMenu);
SendMessage(_hBtnMenu, BM_SETCHECK, NULL, NULL);
if (i >= WM_USER) SetCurSel(i - WM_USER);
}
}
bool notify_handler_rclick(const std::map<int, std::string>& menu, HWND hwnd, int id, LPNMHDR lpNMHdr, is_enable_cb fn)
{
if (id != listview_id) {
return false;
}
LVITEM lvi;
LPNMITEMACTIVATE lpnmitem = (LPNMITEMACTIVATE)lpNMHdr;
POINT point = {lpnmitem->ptAction.x, lpnmitem->ptAction.y};
MapWindowPoints(lpNMHdr->hwndFrom, NULL, &point, 1);
lvi.iItem = lpnmitem->iItem;
lvi.mask = LVIF_PARAM;
lvi.iSubItem = 0;
ListView_GetItem(lpNMHdr->hwndFrom, &lvi);
HMENU hpopup_candidate = CreatePopupMenu();
for (std::map<int, std::string>::const_iterator it = menu.begin(); it != menu.end(); ++ it) {
AppendMenu(hpopup_candidate, MF_STRING, it->first, utf8_2_ansi(it->second.c_str()));
if (lpnmitem->iItem < 0 || (fn && !fn(hwnd, it->first, lvi.lParam))) {
EnableMenuItem(hpopup_candidate, it->first, MF_BYCOMMAND | MF_GRAYED);
}
}
TrackPopupMenuEx(hpopup_candidate, 0,
point.x,
point.y,
hwnd,
NULL);
DestroyMenu(hpopup_candidate);
lParam = lvi.lParam;
return true;
}
//-----------------------------------------------------------------------------
// Name: OnRightButtonUp()
// Desc: Pop up a context menu.
//-----------------------------------------------------------------------------
VOID OnRightButtonUp( HWND hWnd )
{
// Place a popup menu where the mouse curent is
POINT pt;
pt.x = g_x;
pt.y = g_y;
ClientToScreen( hWnd, &pt );
HMENU hMenuPopup = GetSystemMenu( hWnd, FALSE );
// Hide the cursor while moving it so you don't get annoying flicker.
ShowCursor( FALSE );
InvalidateCursorRect( hWnd );
// Unacquire the devices so the user can interact with the menu.
g_bActive = FALSE;
SetAcquire();
// Put the Windows cursor at the same location as our virtual cursor.
SetCursorPos( pt.x, pt.y );
// Show the cursor now that it is moved
ShowCursor( TRUE );
InvalidateCursorRect( hWnd );
// Track the popup menu and return the menu item selected
UINT iMenuID = TrackPopupMenuEx( hMenuPopup, TPM_RIGHTBUTTON|TPM_RETURNCMD,
pt.x, pt.y, hWnd, 0 );
if( 0 != iMenuID ) // If a menu item was selected
PostMessage( hWnd, WM_SYSCOMMAND, iMenuID, 0L );
}
void TrayIcon::showMenu(POINT pos) {
// Create the pop-up menu for the icon.
HMENU menu = CreatePopupMenu();
if (!menu) {
return;
}
// Populate the pop-up menu.
AppendMenu(menu, (isEnabled() ? MF_CHECKED : 0) | MF_ENABLED | MF_STRING, IDM_ENABLE, _T("En&able Taekwindow"));
AppendMenu(menu, MF_ENABLED | MF_STRING, IDM_CONFIGURE, _T("&Preferences..."));
AppendMenu(menu, MF_SEPARATOR, 0, NULL);
AppendMenu(menu, MF_ENABLED | MF_STRING, IDM_EXIT, _T("&Exit"));
// Show the pop-up menu.
// Set the foreground window, so that the menu will be closed when the user clicks elsewhere.
// Post a dummy message to get it to show up the next time (I don't see this problem myself, but the KB says it).
// See Microsoft KB article 135788: "PRB: Menus for Notification Icons Do Not Work Correctly".
SetForegroundWindow(d_window.handle());
TrackPopupMenuEx(menu,
TPM_RIGHTBUTTON | (GetSystemMetrics(SM_MENUDROPALIGNMENT) ? TPM_RIGHTALIGN : TPM_LEFTALIGN),
pos.x, pos.y, d_window.handle(), NULL);
PostMessage(d_window.handle(), WM_NULL, 0, 0);
DestroyMenu(menu);
}
void FileBrowseMenu(int x, int y, HWND hwndToolbar)
{
if (fileBrowseInfo)
{
FILEBROWSE *p = fileBrowseInfo;
HMENU popup = CreatePopupMenu();
int i = 0, j;
memset(ordered, 0, sizeof(ordered));
while (p && i < MAX_BROWSE)
{
ordered[i++] = p;
p = p->next;
}
qsort(ordered, i, sizeof(FILEBROWSE *), fbcomp);
for (j=0; j < i;)
{
FILEBROWSE *cur = ordered[j];
HMENU internalPop = CreatePopupMenu();
for ( ;j < i && cur->info == ordered[j]->info; j++)
{
InsertMenu(internalPop, -1, MF_BYPOSITION | MF_STRING, j + ID_FILEBROWSE_LIST, GetName(j));
}
InsertMenu(popup, -1, MF_BYPOSITION | MF_POPUP | MF_STRING, (UINT_PTR)internalPop, cur->info->dwTitle);
}
InsertBitmapsInMenu(popup);
TrackPopupMenuEx(popup, TPM_TOPALIGN | TPM_LEFTBUTTON, x, y, hwndFrame, NULL);
DestroyMenu(popup);
}
}
bool OsShell::openShellContextMenuForObjects(const std::vector<std::wstring>& objects, int xPos, int yPos, void * parentWindow)
{
ComInitializer comInitializer;
IContextMenu * imenu = 0;
HMENU hMenu = NULL;
if (!prepareContextMenuForObjects(objects, parentWindow, hMenu, imenu) || !hMenu || !imenu)
return false;
CComInterfaceReleaser menuReleaser(imenu);
const int iCmd = TrackPopupMenuEx(hMenu, TPM_RETURNCMD, xPos, yPos, (HWND)parentWindow, NULL);
if (iCmd > 0)
{
CMINVOKECOMMANDINFO info = { 0 };
info.cbSize = sizeof(info);
info.hwnd = (HWND)parentWindow;
info.lpVerb = MAKEINTRESOURCEA(iCmd - 1);
info.nShow = SW_SHOWNORMAL;
imenu->InvokeCommand((LPCMINVOKECOMMANDINFO)&info);
}
DestroyMenu(hMenu);
return true;
}
static VOID
OnContext(PMAIN_WND_INFO Info,
LPARAM lParam)
{
HTREEITEM hSelected;
POINT pt;
RECT rc;
INT xPos = GET_X_LPARAM(lParam);
INT yPos = GET_Y_LPARAM(lParam);
hSelected = TreeView_GetSelection(Info->hTreeView);
if (TreeView_GetItemRect(Info->hTreeView,
hSelected,
&rc,
TRUE))
{
if (GetCursorPos(&pt) &&
ScreenToClient(Info->hTreeView, &pt) &&
PtInRect(&rc, pt))
{
TrackPopupMenuEx(Info->hShortcutMenu,
TPM_RIGHTBUTTON,
xPos,
yPos,
Info->hMainWnd,
NULL);
}
}
}
/*------------------------------------------------
when the clock is right-clicked
show pop-up menu
--------------------------------------------------*/
void OnContextMenu(HWND hwnd, HWND hwndClicked, int xPos, int yPos)
{
WIN32_FIND_DATA fd;
HANDLE hfind;
TPMPARAMS tpmp;
LPTPMPARAMS lptpmp = NULL;
SendOnContextMenu();
if(m_tcmenutxt[0] == 0 || !IsFile(m_tcmenutxt))
{
// common/tclang.c
FindFileWithLangCode(m_tcmenutxt, GetUserDefaultLangID(), TCMENUTXT);
}
hfind = FindFirstFile(m_tcmenutxt, &fd);
if(hfind != INVALID_HANDLE_VALUE)
{
FindClose(hfind);
if(m_lasttime != fd.ftLastWriteTime.dwLowDateTime)
{
EndContextMenu();
m_lasttime = fd.ftLastWriteTime.dwLowDateTime;
}
}
else m_lasttime = 0;
// create popup menu and append items from tcmenu.txt
if(!m_hMenu)
{
m_hMenu = CreatePopupMenu();
if(hfind != INVALID_HANDLE_VALUE)
LoadMenuFromText(m_hMenu, m_tcmenutxt, &fd);
else
LoadMenuFromText(m_hMenu, NULL, NULL);
}
CheckMenu(m_hMenu);
// get keyboard input
SetFocusTClockMain(hwnd);
// APP key
if((xPos == -1) && (yPos == -1))
{
tpmp.cbSize = sizeof(tpmp);
lptpmp = &tpmp;
GetWindowRect(g_hwndClock, &tpmp.rcExclude);
xPos = tpmp.rcExclude.right;
yPos = tpmp.rcExclude.top;
}
// open popup menu
TrackPopupMenuEx(m_hMenu, TPM_LEFTALIGN|TPM_RIGHTBUTTON,
xPos, yPos, hwnd, lptpmp);
PostMessage(hwnd, WM_NULL, 0, 0);
}
void formation_notify_handler_rclick(HWND hdlgP, int DlgItem, LPNMHDR lpNMHdr)
{
LVITEM lvi;
LPNMITEMACTIVATE lpnmitem;
int icount;
if (lpNMHdr->idFrom != IDC_TV_FORMATION_EXPLORER) {
return;
}
// NM_表示对通用控件都通用,范围丛(0, 99)
// TVN_表示只能TreeView通用,范围丛(400, 499)
lpnmitem = (LPNMITEMACTIVATE)lpNMHdr;
// 如果单击到的是复选框位置,把复选框状态置反
// 当前定义的图标大小是16x16. ptAction反回的(x,y)是整个列表视图内的坐标,因而y值不大好判断
// 认为如果x是小于16的就认为是击中复选框
POINT point = {lpnmitem->ptAction.x, lpnmitem->ptAction.y};
MapWindowPoints(lpNMHdr->hwndFrom, NULL, &point, 1);
lvi.iItem = lpnmitem->iItem;
lvi.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
lvi.iSubItem = 0;
lvi.pszText = gdmgr._menu_text;
lvi.cchTextMax = _MAX_PATH;
ListView_GetItem(lpNMHdr->hwndFrom, &lvi);
icount = ListView_GetItemCount(lpNMHdr->hwndFrom);
if (lpNMHdr->idFrom == IDC_TV_FORMATION_EXPLORER) {
EnableMenuItem(gdmgr._hpopup_editor, IDM_ADD, MF_BYCOMMAND);
if (lpnmitem->iItem < 0) {
EnableMenuItem(gdmgr._hpopup_editor, IDM_EDIT, MF_BYCOMMAND | MF_GRAYED);
EnableMenuItem(gdmgr._hpopup_editor, IDM_DELETE, MF_BYCOMMAND | MF_GRAYED);
}
TrackPopupMenuEx(gdmgr._hpopup_editor, 0,
point.x,
point.y,
hdlgP,
NULL);
EnableMenuItem(gdmgr._hpopup_editor, IDM_ADD, MF_BYCOMMAND | MF_ENABLED);
EnableMenuItem(gdmgr._hpopup_editor, IDM_EDIT, MF_BYCOMMAND | MF_ENABLED);
EnableMenuItem(gdmgr._hpopup_editor, IDM_DELETE, MF_BYCOMMAND | MF_ENABLED);
if (lpnmitem->iItem >= 0) {
ns::clicked_formation = lpnmitem->iItem;
}
return;
}
ns::type = DlgItem;
ns::clicked_hero = lvi.lParam;
return;
}
LRESULT CWindow::OnRButtonUp(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
POINT pt = { LOWORD(lParam), HIWORD(lParam) };
ClientToScreen(hWnd, &pt);
TrackPopupMenuEx(m_hMenuPopup, 0, pt.x, pt.y, hWnd, NULL);
return ERROR_SUCCESS;
}
void CtrlMemView::onMouseUp(WPARAM wParam, LPARAM lParam, int button)
{
if (button==2)
{
//popup menu?
POINT pt;
GetCursorPos(&pt);
switch (TrackPopupMenuEx(GetSubMenu(g_hPopupMenus,0),TPM_RIGHTBUTTON|TPM_RETURNCMD,pt.x,pt.y,wnd,0))
{
case ID_MEMVIEW_DUMP:
if (!Core_IsStepping()) // If emulator isn't paused
{
MessageBox(wnd,L"You have to pause the emulator first",0,0);
break;
}
else
{
DumpMemoryWindow dump(wnd,debugger);
dump.exec();
break;
}
case ID_MEMVIEW_COPYVALUE:
{
char temp[24];
// it's admittedly not really useful like this
if (asciiSelected)
{
unsigned char c = Memory::IsValidAddress(curAddress) ? Memory::ReadUnchecked_U8(curAddress) : '.';
if (c < 32|| c >= 128) c = '.';
sprintf(temp,"%c",c);
} else {
sprintf(temp,"%02X",Memory::IsValidAddress(curAddress) ? Memory::ReadUnchecked_U8(curAddress) : 0xFF);
}
W32Util::CopyTextToClipboard(wnd,temp);
}
break;
case ID_MEMVIEW_COPYADDRESS:
{
char temp[24];
sprintf(temp,"0x%08X",curAddress);
W32Util::CopyTextToClipboard(wnd,temp);
}
break;
}
return;
}
int x = LOWORD(lParam);
int y = HIWORD(lParam);
ReleaseCapture();
gotoPoint(x,y);
}
void CAppWindow::ShowContextMenu()
{
if (!AllowContextMenu())
{
return;
}
if (CPopupWindow::Instance() != NULL)
{
CPopupWindow::Instance()->CancelAll();
}
if (m_hPopupMenus != NULL)
{
DestroyMenu(m_hPopupMenus);
}
m_hPopupMenus = LoadMenu(CApp::Instance()->GetInstance(), MAKEINTRESOURCE(IDR_POPUP_MENUS));
HMENU hSubMenu = GetSubMenu(m_hPopupMenus, 0);
if (m_lpSession->GetState() == WSS_ONLINE || m_lpSession->GetState() == WSS_RECONNECTING)
{
DeleteMenu(hSubMenu, ID_TRAYICON_LOGIN, MF_BYCOMMAND);
}
else
{
DeleteMenu(hSubMenu, ID_TRAYICON_SIGNOUT, MF_BYCOMMAND);
EnableMenuItem(hSubMenu, ID_TRAYICON_INBOX, MF_GRAYED | MF_BYCOMMAND);
EnableMenuItem(hSubMenu, ID_TRAYICON_CHECKWAVESNOW, MF_GRAYED | MF_BYCOMMAND);
}
if (CVersion::Instance()->GetState() != VS_NONE)
{
EnableMenuItem(hSubMenu, ID_TRAYICON_CHECKFORUPDATESNOW, MF_GRAYED | MF_BYCOMMAND);
}
POINT p;
GetCursorPos(&p);
SetForegroundWindow(GetHandle());
TrackPopupMenuEx(
hSubMenu,
TPM_VERTICAL | TPM_RIGHTALIGN,
p.x,
p.y,
GetHandle(),
NULL);
PostMessage(WM_NULL);
}
/*************************************************************************
* FileMenu_TrackPopupMenuEx [SHELL32.116]
*/
BOOL WINAPI FileMenu_TrackPopupMenuEx (
HMENU hMenu,
UINT uFlags,
int x,
int y,
HWND hWnd,
LPTPMPARAMS lptpm)
{
TRACE("%p 0x%08x 0x%x 0x%x %p %p\n",
hMenu, uFlags, x, y, hWnd, lptpm);
return TrackPopupMenuEx(hMenu, uFlags, x, y, hWnd, lptpm);
}
void feature_notify_handler_rclick(HWND hdlgP, int DlgItem, LPNMHDR lpNMHdr)
{
LVITEM lvi;
LPNMITEMACTIVATE lpnmitem;
if (lpNMHdr->idFrom != IDC_LV_FEATURE_COMPLEX) {
return;
}
// NM_表示对通用控件都通用,范围丛(0, 99)
// TVN_表示只能TreeView通用,范围丛(400, 499)
lpnmitem = (LPNMITEMACTIVATE)lpNMHdr;
// 如果单击到的是复选框位置,把复选框状态置反
// 当前定义的图标大小是16x16. ptAction反回的(x,y)是整个列表视图内的坐标,因而y值不大好判断
// 认为如果x是小于16的就认为是击中复选框
POINT point = {lpnmitem->ptAction.x, lpnmitem->ptAction.y};
MapWindowPoints(lpNMHdr->hwndFrom, NULL, &point, 1);
lvi.iItem = lpnmitem->iItem;
lvi.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
lvi.iSubItem = 0;
lvi.pszText = gdmgr._menu_text;
lvi.cchTextMax = _MAX_PATH;
ListView_GetItem(lpNMHdr->hwndFrom, &lvi);
HMENU hpopup = CreatePopupMenu();
if (lpNMHdr->idFrom == IDC_LV_FEATURE_COMPLEX) {
AppendMenu(hpopup, MF_STRING, IDM_ADD, utf8_2_ansi(_("Append after it")));
AppendMenu(hpopup, MF_STRING, IDM_EDIT, utf8_2_ansi(_("Edit...")));
AppendMenu(hpopup, MF_STRING, IDM_DELETE, utf8_2_ansi(_("Delete...")));
if (lpnmitem->iItem < 0) {
EnableMenuItem(hpopup, IDM_ADD, MF_BYCOMMAND | MF_GRAYED);
EnableMenuItem(hpopup, IDM_EDIT, MF_BYCOMMAND | MF_GRAYED);
EnableMenuItem(hpopup, IDM_DELETE, MF_BYCOMMAND | MF_GRAYED);
}
}
TrackPopupMenuEx(hpopup, 0,
point.x,
point.y,
hdlgP,
NULL);
DestroyMenu(hpopup);
ns::type = DlgItem;
ns::clicked_feature = lpnmitem->iItem;
return;
}
static void
on_right_click(NMITEMACTIVATE *note)
{
enum MenuOption {
PRIVATE_CHAT = 1,
IGNORE_USER,
ALIAS
};
HMENU menu;
LVITEM item;
User *user;
enum MenuOption menu_option;
if (note->iItem < 0)
return;
item.mask = LVIF_PARAM;
item.iItem = note->iItem;
SendMessage(note->hdr.hwndFrom, LVM_GETITEM, 0, (intptr_t)&item);
user = (User *)item.lParam;
menu = CreatePopupMenu();
AppendMenu(menu, 0, PRIVATE_CHAT, L"Private chat");
AppendMenu(menu, user->ignore ? MF_CHECKED : 0, IGNORE_USER, L"Ignore");
AppendMenu(menu, 0, ALIAS, L"Set alias");
SetMenuDefaultItem(menu, 1, 0);
ClientToScreen(note->hdr.hwndFrom, ¬e->ptAction);
menu_option = TrackPopupMenuEx(menu, TPM_RETURNCMD, note->ptAction.x,
note->ptAction.y, GetParent(note->hdr.hwndFrom), NULL);
DestroyMenu(menu);
switch (menu_option) {
case PRIVATE_CHAT:
ChatTab_focus_private(user);
return;
case IGNORE_USER:
user->ignore = !user->ignore;
return;
case ALIAS: {
char title[128];
char buf[MAX_NAME_LENGTH_NUL];
sprintf(title, "Set alias for %s", user->name);
if (!GetTextDialog_create(title, strcpy(buf, UNTAGGED_NAME(user->name)), MAX_NAME_LENGTH_NUL))
strcpy(user->alias, buf);
return;
}
}
}
static VOID CALLBACK sttMenuThread(PVOID param)
{
HMENU hMenu = (HMENU)CallService(MS_CLIST_MENUBUILDCONTACT, (WPARAM)param, 0);
TPMPARAMS tpmp = { 0 };
tpmp.cbSize = sizeof(tpmp);
BOOL menuRet = TrackPopupMenuEx(hMenu, TPM_RETURNCMD, menuMousePoint.x, menuMousePoint.y, (HWND)CallService(MS_CLUI_GETHWND, 0, 0), &tpmp);
CallService(MS_CLIST_MENUPROCESSCOMMAND, MAKEWPARAM(LOWORD(menuRet), MPCF_CONTACTMENU), (LPARAM)param);
DestroyMenu(hMenu);
}
void OnPopup(UINT uMsg, long x, long y)
{
if(m_MessageLookup.ContainsKey(uMsg))
{
if(m_MessageLookup[uMsg]->m_MenuHandle)
{
SetForegroundWindow(m_HWND);
TrackPopupMenuEx(m_MessageLookup[uMsg]->m_MenuHandle,
TPM_RIGHTBUTTON | TPM_VERNEGANIMATION, x, y, m_HWND, 0);
}
}
}
//----------------------------------------------------------------------------------------------
// ShowLeftPopupMenu
//----------------------------------------------------------------------------------------------
VOID CStatusAreaIcon::ShowLeftPopupMenu()
{
// プロパティ シートの状態を取得する
BOOL PropertySheetOpened = PropertySheet->IsOpened();
// ポップアップ メニューを作成する
HMENU PopupMenu = CreatePopupMenu();
// コントローラーの設定を表示する
for( LONG Index = 0; Index < Setting->SettingCount; Index ++ )
{
MENUITEMINFO ItemInfo;
ZeroMemory( &ItemInfo, sizeof( ItemInfo ) );
ItemInfo.cbSize = sizeof( ItemInfo );
ItemInfo.fMask = MIIM_TYPE | MIIM_STATE | MIIM_ID;
ItemInfo.fType = MFT_STRING;
ItemInfo.fState = MFS_ENABLED;
if( PropertySheetOpened == TRUE )
{
ItemInfo.fState |= MFS_DISABLED;
}
ItemInfo.wID = IDM_SETTING + Index;
if( Setting->CurrentSettingIndex == Index )
{
ItemInfo.fState |= MFS_CHECKED;
}
WCHAR SettingName[MAX_PATH * 2];
wcscpy_s( SettingName, Setting->SettingName[Index] );
// 変更済みフラグが上がっていれば「（変更済み）」を設定する
if( Setting->ModifiedFlag == TRUE && Setting->CurrentSettingIndex == Index )
{
WCHAR Modified[MAX_PATH];
LoadString( Instance, IDS_MODIFIED, Modified, MAX_PATH );
wcscat_s( SettingName, Modified );
}
ItemInfo.dwTypeData = SettingName;
InsertMenuItem( PopupMenu, Index, TRUE, &ItemInfo );
}
// ポップアップ メニューを表示する
SetForegroundWindow( Wnd );
POINT CursorPos;
GetCursorPos( &CursorPos );
TrackPopupMenuEx(
PopupMenu
,TPM_LEFTALIGN | TPM_RIGHTBUTTON
,CursorPos.x
,CursorPos.y
,Wnd
,NULL );
DestroyMenu( PopupMenu );
PostMessage( Wnd, WM_NULL, 0, 0 );
}
void CtrlRegisterList::onMouseUp(WPARAM wParam, LPARAM lParam, int button)
{
if (button==2)
{
//popup menu?
int cat = category;
int reg = selection;
if (selection >= cpu->GetNumRegsInCategory(cat))
return;
POINT pt;
GetCursorPos(&pt);
u32 val = cpu->GetRegValue(cat,reg);
switch(TrackPopupMenuEx(GetSubMenu(g_hPopupMenus,3),TPM_RIGHTBUTTON|TPM_RETURNCMD,pt.x,pt.y,wnd,0))
{
case ID_REGLIST_GOTOINMEMORYVIEW:
for (int i=0; i<numCPUs; i++)
if (memoryWindow[i])
memoryWindow[i]->Goto(val);
break;
case ID_REGLIST_GOTOINDISASM:
for (int i=0; i<numCPUs; i++)
if (disasmWindow[i])
disasmWindow[i]->Goto(val);
break;
case ID_REGLIST_COPYVALUE:
{
char temp[24];
sprintf(temp,"%08x",val);
W32Util::CopyTextToClipboard(wnd,temp);
}
break;
case ID_REGLIST_CHANGE:
{
if (InputBox_GetHex(GetModuleHandle(NULL),wnd,"Set new value",val,val))
{
cpu->SetRegValue(cat,reg,val);
redraw();
}
}
break;
}
return;
}
int x = LOWORD(lParam);
int y = HIWORD(lParam);
if (x>16)
{
selection=yToIndex(y);
selecting=false;
ReleaseCapture();
redraw();
}
}
LRESULT MFTreeView::OnRClick(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled)
{
HMENU ctxMenu = CreatePopupMenu();
WTL::CTreeItem item = GetDropHilightItem();
if (item.IsNull())
{
item = GetSelectedItem();
}
MFTreeViewItem* pItem = (MFTreeViewItem*)item.GetData();
if (pItem == NULL)
{
DestroyMenu(ctxMenu);
return 0;
}
unsigned int nextID = pItem->AppendMenuCmd(ctxMenu, 1, item);
if (GetMenuItemCount(ctxMenu) > 0)
{
AppendMenu(ctxMenu, MF_SEPARATOR, 0, NULL);
}
unsigned int refreshID = nextID++;
nextID = AppendMenu(ctxMenu, MF_STRING, refreshID, _T("Refresh"));
if (GetMenuItemCount(ctxMenu) == 0)
{
DestroyMenu(ctxMenu);
return 0;
}
POINT pos;
GetCursorPos(&pos);
int command = TrackPopupMenuEx(ctxMenu, TPM_NONOTIFY | TPM_RETURNCMD, pos.x, pos.y, pnmh->hwndFrom, NULL);
if (!pItem->HandleMenuCmd(command, item))
{
if (command == refreshID)
{
WTL::CTreeItem parent = item.GetParent();
parent.Expand(TVE_COLLAPSE | TVE_COLLAPSERESET);
parent.Expand();
}
}
DestroyMenu(ctxMenu);
return 1;
}
static void
menubar_perform_dropdown(menubar_t* mb)
{
int item;
DWORD btn_state;
TPMPARAMS pmparams = {0};
MENUBAR_TRACE("menubar_perform_dropdown(%p)", mb);
pmparams.cbSize = sizeof(TPMPARAMS);
mb->is_dropdown_active = TRUE;
menubar_ht_enable(mb);
SetFocus(mb->win);
while(mb->pressed_item >= 0) {
item = mb->pressed_item;
if(mb->select_from_keyboard) {
keybd_event(VK_DOWN, 0, 0, 0);
keybd_event(VK_DOWN, 0, KEYEVENTF_KEYUP, 0);
}
mb->select_from_keyboard = FALSE;
mb->continue_hot_track = FALSE;
MENUBAR_SENDMSG(mb->win, TB_SETHOTITEM, item, 0);
btn_state = MENUBAR_SENDMSG(mb->win, TB_GETSTATE, item, 0);
MENUBAR_SENDMSG(mb->win, TB_SETSTATE, item,
MAKELONG(btn_state | TBSTATE_PRESSED, 0));
MENUBAR_SENDMSG(mb->win, TB_GETITEMRECT, item, &pmparams.rcExclude);
MapWindowPoints(mb->win, HWND_DESKTOP, (POINT*)&pmparams.rcExclude, 2);
MENUBAR_TRACE("menubar_perform_dropdown: ENTER TrackPopupMenuEx()");
TrackPopupMenuEx(GetSubMenu(mb->menu, item),
TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_VERTICAL,
pmparams.rcExclude.left, pmparams.rcExclude.bottom,
mb->win, &pmparams);
MENUBAR_TRACE("menubar_perform_dropdown: LEAVE TrackPopupMenuEx()");
MENUBAR_SENDMSG(mb->win, TB_SETSTATE, item, MAKELONG(btn_state, 0));
if(!mb->continue_hot_track)
mb->pressed_item = -1;
}
menubar_reset_hot_item(mb);
menubar_ht_disable(mb);
mb->is_dropdown_active = FALSE;
SetFocus(mb->old_focus);
}
LRESULT CExtractDlg::OnNMClickLinkMolCount(int idCtrl, LPNMHDR pNMHDR, BOOL& bHandled)
{
PNMLINK link = (PNMLINK) pNMHDR;
switch(link->item.iLink)
{
case 0: // Extract Count
DisplayGroup(1);
break;
case 1: // Select Output Directory
if(!SUCCEEDED(Utils::DoFolderDialog(m_hWnd, _T("Extract Molecules to Folder..."),
m_params.folderPath, m_params.folderPath)))
{
//TODO: log
}
break;
case 3: // File Format
DisplayGroup(2);
break;
case 2:
case 4:
POINT point;
if(GetCursorPos(&point))
{
HMENU hMenu = LoadMenu(_AtlBaseModule.m_hInst, MAKEINTRESOURCE(IDR_EXTRACTMENU));
if(hMenu)
{
int subMenuId = (link->item.iLink == 2) ? 0 : 1;
HMENU hSubMenu = GetSubMenu(hMenu, subMenuId);
//WORKAROUND: To be removed when provider issues with RXN -> CML, CDXML are fixed
// disable CML,CDXML if source is reaction to avoid crash due to provider issue
if((m_params.exportFormat == fmtRXNV2) || (m_params.exportFormat == fmtRXNV3))
{
EnableMenuItem(hSubMenu, ID_EXTRACTFORMAT_CML, MF_DISABLED);
EnableMenuItem(hSubMenu, ID_EXTRACTFORMAT_CDXML, MF_DISABLED);
}
TrackPopupMenuEx(hSubMenu, TPM_LEFTALIGN, point.x, point.y, m_hWnd, NULL);
DestroyMenu(hMenu);
}
}
break;
}
UpdateLinkText();
return 0;
}
