1721 lines
38 KiB
C++
1721 lines
38 KiB
C++
#include <precomp.h>
|
|
#include <api/wnd/api_window.h>
|
|
#include <api/locales/xlatstr.h>
|
|
|
|
#ifndef WASABI_WANT_FF_POPUP
|
|
|
|
#include "popup.h"
|
|
#ifdef _WIN32
|
|
#include "../../../Plugins/General/gen_ff/wa2frontend.h"
|
|
extern HINSTANCE hInstance;
|
|
#endif
|
|
PopupMenu::PopupMenu()
|
|
{
|
|
hmenu = NULL;
|
|
parent = NULL;
|
|
}
|
|
|
|
PopupMenu::PopupMenu(ifc_window *_parent)
|
|
{
|
|
hmenu = NULL;
|
|
parent = _parent;
|
|
}
|
|
|
|
PopupMenu::PopupMenu(PopupMenu *_parent)
|
|
{
|
|
hmenu = NULL;
|
|
parent = _parent->getParent();
|
|
}
|
|
|
|
PopupMenu::~PopupMenu()
|
|
{
|
|
invalidateMenu();
|
|
entries.deleteAll();
|
|
sortedentries.removeAll();
|
|
}
|
|
|
|
void PopupMenu::addSubMenu(PopupMenu *menu, const wchar_t *text, int disabled)
|
|
{
|
|
invalidateMenu();
|
|
PopupMenuEntry *e = new PopupMenuEntry(text, -1, menu, 0, disabled);
|
|
entries.addItem(e);
|
|
sortedentries.addItem(e);
|
|
}
|
|
|
|
void PopupMenu::addSubMenuCallback(const wchar_t *text, PopupMenuCallback *cb, int param)
|
|
{
|
|
invalidateMenu();
|
|
PopupMenuEntry *e = new PopupMenuEntry(text, -1, NULL, 0, 0, cb, param);
|
|
entries.addItem(e);
|
|
sortedentries.addItem(e);
|
|
}
|
|
|
|
void PopupMenu::addCommand(const wchar_t *text, int command, int checked, int disabled, int addpos)
|
|
{
|
|
invalidateMenu();
|
|
PopupMenuEntry *e = new PopupMenuEntry(text, command, NULL, checked, disabled);
|
|
entries.addItem(e);
|
|
sortedentries.addItem(e, addpos);
|
|
}
|
|
|
|
void PopupMenu::addSeparator(int addpos)
|
|
{
|
|
invalidateMenu();
|
|
PopupMenuEntry *e = new PopupMenuEntry(NULL, -1, NULL, 0, 0);
|
|
entries.addItem(e);
|
|
sortedentries.addItem(e, addpos);
|
|
};
|
|
|
|
void PopupMenu::checkCommand(int cmd, int check)
|
|
{
|
|
invalidateMenu();
|
|
PopupMenuEntry *e = sortedentries.findItem((const wchar_t *) & cmd);
|
|
if (e) e->setChecked(check);
|
|
}
|
|
|
|
void PopupMenu::disableCommand(int cmd, int disable)
|
|
{
|
|
invalidateMenu();
|
|
PopupMenuEntry *e = sortedentries.findItem((const wchar_t *) & cmd);
|
|
if (e) e->setDisabled(disable);
|
|
}
|
|
|
|
int PopupMenu::popAtXY(int x, int y, int native)
|
|
{
|
|
rebuildMenu();
|
|
#ifdef _WIN32
|
|
if (!native)
|
|
return DoTrackPopup(getOSMenuHandle(), TPM_LEFTALIGN | TPM_TOPALIGN | TPM_NONOTIFY | TPM_RETURNCMD | TPM_LEFTBUTTON | TPM_RIGHTBUTTON, x, y, (parent ? parent->gethWnd() : WASABI_API_WND->main_getRootWnd()->gethWnd())) - 1;
|
|
else
|
|
return TrackPopupMenuEx(getOSMenuHandle(), TPM_LEFTALIGN | TPM_TOPALIGN | TPM_NONOTIFY | TPM_RETURNCMD | TPM_LEFTBUTTON | TPM_RIGHTBUTTON, x, y, (parent ? parent->gethWnd() : WASABI_API_WND->main_getRootWnd()->gethWnd()), NULL) - 1;
|
|
#elif defined(__APPLE__)
|
|
return PopUpMenuSelect(getOSMenuHandle(), x, y, 0);
|
|
#endif
|
|
}
|
|
|
|
int PopupMenu::popAnchored(int type)
|
|
{ // dropped off the sourceWnd given above
|
|
#ifdef _WIN32
|
|
int flag = 0;
|
|
switch (type)
|
|
{
|
|
case POPUP_ANCHOR_UL: flag |= TPM_LEFTALIGN | TPM_TOPALIGN; break;
|
|
case POPUP_ANCHOR_LL: flag |= TPM_LEFTALIGN | TPM_BOTTOMALIGN; break;
|
|
case POPUP_ANCHOR_UR: flag |= TPM_RIGHTALIGN | TPM_TOPALIGN; break;
|
|
case POPUP_ANCHOR_LR: flag |= TPM_RIGHTALIGN | TPM_BOTTOMALIGN; break;
|
|
}
|
|
#endif
|
|
rebuildMenu();
|
|
int x, y;
|
|
Wasabi::Std::getMousePos(&x, &y);
|
|
#ifdef _WIN32
|
|
return DoTrackPopup(getOSMenuHandle(), flag | TPM_NONOTIFY | TPM_RETURNCMD | TPM_LEFTBUTTON | TPM_RIGHTBUTTON, x, y, (parent ? parent->gethWnd() : WASABI_API_WND->main_getRootWnd()->gethWnd())) - 1;
|
|
#elif defined(__APPLE__)
|
|
return PopUpMenuSelect(getOSMenuHandle(), x, y, 0);
|
|
#endif
|
|
}
|
|
|
|
int PopupMenu::popAtMouse()
|
|
{
|
|
rebuildMenu();
|
|
int x, y;
|
|
Wasabi::Std::getMousePos(&x, &y);
|
|
#ifdef _WIN32
|
|
return DoTrackPopup(getOSMenuHandle(), TPM_LEFTALIGN | TPM_TOPALIGN | TPM_NONOTIFY | TPM_RETURNCMD | TPM_LEFTBUTTON | TPM_RIGHTBUTTON, x, y, (parent ? parent->gethWnd() : WASABI_API_WND->main_getRootWnd()->gethWnd())) - 1;
|
|
#elif defined(__APPLE__)
|
|
return PopUpMenuSelect(getOSMenuHandle(), x, y, 0);
|
|
#endif
|
|
}
|
|
|
|
int PopupMenu::getNumCommands()
|
|
{
|
|
return entries.getNumItems();
|
|
}
|
|
|
|
const wchar_t *PopupMenu::getCommandText(int command)
|
|
{
|
|
PopupMenuEntry *e = sortedentries.findItem((const wchar_t *) &command);
|
|
if (e) return e->getText();
|
|
return NULL;
|
|
}
|
|
|
|
OSMENUHANDLE PopupMenu::getOSMenuHandle()
|
|
{
|
|
rebuildMenu();
|
|
return hmenu;
|
|
}
|
|
|
|
void PopupMenu::rebuildMenu()
|
|
{
|
|
#ifdef WIN32
|
|
if (hmenu != NULL) return ;
|
|
hmenu = CreatePopupMenu();
|
|
int i = 0;
|
|
foreach(entries)
|
|
PopupMenuEntry *e = entries.getfor();
|
|
OSMENUHANDLE submenu = NULL;
|
|
if (e->getCallback())
|
|
{
|
|
PopupMenu *m = e->getCallback()->popupMenuCallback(this, e->getCallbackParam());
|
|
if (m) submenu = m->getOSMenuHandle();
|
|
}
|
|
else if (e->isSubmenu())
|
|
{
|
|
submenu = e->getSubmenu()->getOSMenuHandle();
|
|
}
|
|
InsertMenuW(hmenu, i++, MF_BYPOSITION | (e->getChecked() ? MF_CHECKED : MF_UNCHECKED) | (e->getDisabled() ? MF_GRAYED : 0) | (e->isSeparator() ? MF_SEPARATOR : (e->isSubmenu() ? MF_POPUP : 0) | (e->getText() ? MF_STRING : 0)), e->isSubmenu() ? (UINT_PTR)submenu : e->getCommand() + 1, e->getText());
|
|
endfor;
|
|
#else
|
|
if (hmenu != NULL) return ;
|
|
CreateNewMenu(0, 0, &hmenu);
|
|
|
|
foreach(entries)
|
|
PopupMenuEntry *e = entries.getfor();
|
|
OSMENUHANDLE submenu = NULL;
|
|
if (e->getCallback())
|
|
{
|
|
PopupMenu *m = e->getCallback()->popupMenuCallback(this, e->getCallbackParam());
|
|
if (m) submenu = m->getOSMenuHandle();
|
|
}
|
|
else if (e->isSubmenu())
|
|
{
|
|
submenu = e->getSubmenu()->getOSMenuHandle();
|
|
}
|
|
|
|
const wchar_t *name = e->getText();
|
|
CFStringRef menuStr = CFStringCreateWithBytes(kCFAllocatorDefault, (UInt8 *)name, wcslen(name)*sizeof(wchar_t), kCFStringEncodingUTF32, false);
|
|
MenuItemIndex newMenuItem;
|
|
MenuItemAttributes menuAttr = kMenuItemAttrIgnoreMeta;
|
|
if (e->getDisabled())
|
|
menuAttr|=kMenuItemAttrDisabled;
|
|
if (e->isSeparator())
|
|
menuAttr|=kMenuItemAttrSeparator;
|
|
|
|
AppendMenuItemTextWithCFString(hmenu, menuStr, menuAttr, e->getCommand(), &newMenuItem);
|
|
if (submenu)
|
|
SetMenuItemHierarchicalMenu(hmenu, newMenuItem, submenu);
|
|
|
|
if (e->getChecked())
|
|
CheckMenuItem(hmenu, newMenuItem, true);
|
|
|
|
CFRelease(menuStr);
|
|
endfor;
|
|
#endif
|
|
}
|
|
|
|
void PopupMenu::invalidateMenu()
|
|
{
|
|
#ifdef WIN32
|
|
if (hmenu) DestroyMenu(hmenu);
|
|
#elif defined(__APPLE__)
|
|
if (hmenu) DisposeMenu(hmenu);
|
|
#endif
|
|
hmenu = NULL;
|
|
}
|
|
|
|
void PopupMenu::abort()
|
|
{
|
|
#ifdef WIN32
|
|
HWND w = (parent ? parent->gethWnd() : WASABI_API_WND->main_getRootWnd()->gethWnd());
|
|
|
|
PostMessage(w, WM_LBUTTONDOWN, 0, 0xdeadc0de);
|
|
PostMessage(w, WM_LBUTTONUP, 0, 0xdeadc0de);
|
|
|
|
#elif defined(__APPLE__)
|
|
CancelMenuTracking(hmenu, true, 0);
|
|
#endif
|
|
}
|
|
|
|
#else // WASABI_WANT_FF_POPUP
|
|
|
|
#include <bfc/api/api_wnd.h>
|
|
#include <bfc/api/api_syscb.h>
|
|
#include "popup.h"
|
|
#include <bfc/notifmsg.h>
|
|
|
|
#include <studio/assert.h>
|
|
#include <studio/api.h>
|
|
|
|
#include <bfc/wasabi_std.h>
|
|
#include <common/xlatstr.h>
|
|
#include <bfc/wnds/buttwnd.h>
|
|
|
|
#include <bfc/util/pathparse.h>
|
|
#include <bfc/attribs/cfgitem.h>
|
|
|
|
#include <common/script/c_script/c_guiobject.h>
|
|
#include <common/script/c_script/c_menubutton.h>
|
|
#include <common/script/scriptguid.h>
|
|
#include <common/menusurface.h>
|
|
|
|
#ifndef WANT_NEW_POPUPMENU
|
|
#define SELMARGIN 1
|
|
|
|
// todo:
|
|
// check marks
|
|
// more?
|
|
|
|
PopupMenu::PopupMenu(ifc_window *sourceWnd)
|
|
{
|
|
ASSERT(sourceWnd != NULL);
|
|
setStartHidden(1);
|
|
setRenderRatio(1.0);
|
|
parentRootWnd = sourceWnd;
|
|
parentWnd = sourceWnd->getOsWindowHandle();
|
|
reverse_side = 0;
|
|
kbdhooked = 0;
|
|
keyctrl = 0;
|
|
toplevelmenu = 0;
|
|
chainmenu = NULL;
|
|
lastxy.x = lastxy.y = -1;
|
|
WASABI_API_WND->appdeactivation_push_disallow(this);
|
|
init(sourceWnd->getOsModuleHandle(), parentWnd, TRUE);
|
|
WASABI_API_WND->appdeactivation_pop_disallow(this);
|
|
}
|
|
|
|
PopupMenu::PopupMenu()
|
|
{
|
|
setStartHidden(1);
|
|
setRenderRatio(1.0);
|
|
parentRootWnd = NULL;
|
|
parentWnd = INVALIDOSWINDOWHANDLE;
|
|
chainmenu = NULL;
|
|
reverse_side = 0;
|
|
kbdhooked = 0;
|
|
toplevelmenu = 0;
|
|
keyctrl = 0;
|
|
lastxy.x = lastxy.y = -1;
|
|
WASABI_API_WND->appdeactivation_push_disallow(this);
|
|
init(hInstance, WASABI_API_WND->main_getRootWnd()->gethWnd(), TRUE);
|
|
WASABI_API_WND->appdeactivation_pop_disallow(this);
|
|
}
|
|
|
|
PopupMenu::PopupMenu(HWND sourceWnd)
|
|
{
|
|
parentRootWnd = NULL;
|
|
parentWnd = sourceWnd;
|
|
setStartHidden(1);
|
|
setRenderRatio(1.0);
|
|
reverse_side = 0;
|
|
kbdhooked = 0;
|
|
toplevelmenu = 0;
|
|
keyctrl = 0;
|
|
chainmenu = NULL;
|
|
lastxy.x = lastxy.y = -1;
|
|
WASABI_API_WND->appdeactivation_push_disallow(this);
|
|
init(hInstance, sourceWnd, TRUE);
|
|
WASABI_API_WND->appdeactivation_pop_disallow(this);
|
|
}
|
|
|
|
PopupMenu::PopupMenu(PopupMenu *sourceWnd)
|
|
{
|
|
parentRootWnd = sourceWnd;
|
|
parentWnd = sourceWnd->gethWnd();
|
|
setStartHidden(1);
|
|
setRenderRatio(1.0);
|
|
reverse_side = 0;
|
|
kbdhooked = 0;
|
|
toplevelmenu = 0;
|
|
chainmenu = NULL;
|
|
keyctrl = 0;
|
|
lastxy.x = lastxy.y = -1;
|
|
WASABI_API_WND->appdeactivation_push_disallow(this);
|
|
init(sourceWnd, TRUE);
|
|
WASABI_API_WND->appdeactivation_pop_disallow(this);
|
|
}
|
|
|
|
int PopupMenu::onInit()
|
|
{
|
|
POPUPMENU_PARENT::onInit();
|
|
bdown = 0;
|
|
lastitem = -1;
|
|
rcp = 0;
|
|
openmenuid = -1;
|
|
timerset = 0;
|
|
timeritem = -1;
|
|
rcode = -1;
|
|
toplevelmenu = 0;
|
|
disable_autopop = 0;
|
|
popupdelay = 250; //TODO: Config
|
|
#ifdef WASABI_COMPILE_CONFIG
|
|
// {9149C445-3C30-4e04-8433-5A518ED0FDDE}
|
|
const GUID uioptions_guid =
|
|
{ 0x9149c445, 0x3c30, 0x4e04, { 0x84, 0x33, 0x5a, 0x51, 0x8e, 0xd0, 0xfd, 0xde } };
|
|
setTransparency(_intVal(WASABI_API_CONFIG->config_getCfgItemByGuid(uioptions_guid), "Popup menu alpha", 255));
|
|
#else
|
|
setTransparency(255);
|
|
#endif
|
|
|
|
tex = "wasabi.popup.menu.background";
|
|
ful = "wasabi.popup.menu.border.topLeft";
|
|
fur = "wasabi.popup.menu.border.topRight";
|
|
fll = "wasabi.popup.menu.border.bottomLeft";
|
|
flr = "wasabi.popup.menu.border.bottomRight";
|
|
fl = "wasabi.popup.menu.border.left";
|
|
fr = "wasabi.popup.menu.border.right";
|
|
ft = "wasabi.popup.menu.border.top";
|
|
fb = "wasabi.popup.menu.border.bottom";
|
|
sl = "wasabi.popup.menu.selection.left";
|
|
sr = "wasabi.popup.menu.selection.right";
|
|
sc = "wasabi.popup.menu.selection.center";
|
|
|
|
return 1;
|
|
}
|
|
|
|
PopupMenu::~PopupMenu()
|
|
{
|
|
if (kbdhooked)
|
|
{
|
|
WASABI_API_WND->unhookKeyboard(this);
|
|
kbdhooked = 0;
|
|
}
|
|
int x, n;
|
|
n = items.getNumItems();
|
|
for (x = 0; x < n; x ++)
|
|
{
|
|
if (items[x])
|
|
{
|
|
if (items[x]->butt) delete items[x]->butt;
|
|
if (items[x]->menu) delete items[x]->menu;
|
|
delete items[x];
|
|
}
|
|
}
|
|
}
|
|
|
|
void PopupMenu::addSubMenu(PopupMenu *menu, const wchar_t *text, int disabled)
|
|
{
|
|
ASSERT(text != NULL);
|
|
ButtonWnd *b = new ButtonWnd();
|
|
b->init(this);
|
|
b->setParent(this);
|
|
b->setNotifyId( -1);
|
|
b->setButtonText(translateButtonText(text), 14);
|
|
// b->setTextJustification(BUTTONJUSTIFY_LEFT);
|
|
b->setTextAlign(TEXTALIGN_LEFT);
|
|
b->setColors("wasabi.popup.text", "wasabi.popup.hiliteText", "wasabi.button.dimmedText");
|
|
if (disabled) b->enableButton(FALSE);
|
|
ItemT *t = new ItemT;
|
|
t->issep = 0;
|
|
t->butt = b;
|
|
t->menu = menu;
|
|
t->cmd = -1;
|
|
t->cb = NULL;
|
|
items.addItem(t);
|
|
}
|
|
|
|
void PopupMenu::addSubMenuImage(PopupMenu *menu, const char *bitmap, const char *pushedbitmap, const char *highlightbitmap)
|
|
{
|
|
ButtonWnd *b = new ButtonWnd();
|
|
b->init(this);
|
|
b->setParent(this);
|
|
b->setBitmaps(bitmap, pushedbitmap, highlightbitmap);
|
|
b->setBitmapCenter(1);
|
|
b->setNotifyId( -1);
|
|
b->setAutoDim(1);
|
|
b->setColors("wasabi.popup.text", "wasabi.popup.hiliteText", "wasabi.button.dimmedText");
|
|
ItemT *t = new ItemT;
|
|
t->issep = 0;
|
|
t->butt = b;
|
|
t->menu = menu;
|
|
t->cb = NULL;
|
|
t->cmd = -1;
|
|
items.addItem(t);
|
|
}
|
|
|
|
void PopupMenu::addSubMenuCallback(const wchar_t *text, PopupMenuCallback *cb, int param)
|
|
{
|
|
ASSERT(text != NULL);
|
|
ASSERT(cb != NULL);
|
|
ButtonWnd *b = new ButtonWnd();
|
|
b->init(this);
|
|
b->setParent(this);
|
|
b->setNotifyId( -1);
|
|
b->setButtonText(translateButtonText(text), 14);
|
|
// b->setTextJustification(BUTTONJUSTIFY_LEFT);
|
|
b->setTextAlign(TEXTALIGN_LEFT);
|
|
b->setColors("wasabi.popup.text", "wasabi.popup.hiliteText", "wasabi.button.dimmedText");
|
|
ItemT *t = new ItemT;
|
|
t->issep = 0;
|
|
t->butt = b;
|
|
t->menu = 0;
|
|
t->cb = cb;
|
|
t->cbparam = param;
|
|
t->cmd = -1;
|
|
items.addItem(t);
|
|
}
|
|
|
|
void PopupMenu::addSeparator(int addpos)
|
|
{
|
|
ButtonWnd *b = new ButtonWnd();
|
|
b->init(this);
|
|
b->setParent(this);
|
|
b->setNotifyId( -1);
|
|
b->setBitmaps("wasabi.popup.menu.seperator");
|
|
b->setBitmapCenter(0);
|
|
b->enableButton(0);
|
|
b->setColors("wasabi.popup.text", "wasabi.popup.hiliteText", "wasabi.button.dimmedText");
|
|
ItemT *t = new ItemT;
|
|
t->issep = 1;
|
|
t->butt = b;
|
|
t->menu = 0;
|
|
t->cb = NULL;
|
|
t->cmd = -1;
|
|
items.addItem(t, addpos);
|
|
}
|
|
|
|
void PopupMenu::addCommandImage(const char *bitmap, const char *pushedbitmap, const char *highlightbitmap, int command, int checked, int disabled, int addpos)
|
|
{
|
|
ButtonWnd *b = new ButtonWnd();
|
|
b->init(this);
|
|
b->setParent(this);
|
|
b->setBitmaps(bitmap, pushedbitmap, highlightbitmap);
|
|
b->setBitmapCenter(1);
|
|
b->setNotifyId(command);
|
|
b->enableButton(disabled ? 0 : 1);
|
|
b->setChecked(checked ? 1 : 0);
|
|
b->setAutoDim(1);
|
|
b->setColors("wasabi.popup.text", "wasabi.popup.hiliteText", "wasabi.button.dimmedText");
|
|
ItemT *t = new ItemT;
|
|
t->issep = 0;
|
|
t->butt = b;
|
|
t->menu = 0;
|
|
t->cb = NULL;
|
|
t->cmd = -1;
|
|
items.addItem(t);
|
|
}
|
|
|
|
void PopupMenu::addCommand(const wchar_t *_txt, int command, int checked, int disabled, int addpos)
|
|
{
|
|
if (!_txt)
|
|
{
|
|
addSeparator();
|
|
return ;
|
|
}
|
|
String txt = translateButtonText(_txt);
|
|
ButtonWnd *b = new ButtonWnd();
|
|
b->init(this);
|
|
b->setParent(this);
|
|
b->setNotifyId(disabled ? -1 : command);
|
|
|
|
#ifdef WASABI_COMPILE_LOCALES
|
|
const wchar_t *bind = (command != 0) ? WASABI_API_LOCALE->locales_getBindFromAction(command) : NULL;
|
|
if (bind) txt += StringPrintfW(L"\t%s", bind);
|
|
#endif
|
|
|
|
b->setButtonText(txt);
|
|
|
|
// b->setTextJustification(BUTTONJUSTIFY_LEFT);
|
|
b->setTextAlign(TEXTALIGN_LEFT);
|
|
b->enableButton(disabled ? 0 : 1);
|
|
b->setChecked(checked);
|
|
if (checked == 2) b->setAlpha(128);
|
|
b->setColors("wasabi.popup.text", "wasabi.popup.hiliteText", "wasabi.button.dimmedText");
|
|
ItemT *t = new ItemT;
|
|
t->issep = 0;
|
|
t->butt = b;
|
|
t->menu = 0;
|
|
t->cmd = command;
|
|
t->cb = NULL;
|
|
ASSERT(PTRLIST_POS_LAST == -1); //BU
|
|
items.addItem(t, addpos);
|
|
}
|
|
|
|
void PopupMenu::disableCommand(int cmd, int disable)
|
|
{
|
|
for (int i = 0;i < items.getNumItems();i++)
|
|
if (items.enumItem(i)->cmd == cmd)
|
|
{
|
|
if (items.enumItem(i)->butt)
|
|
items.enumItem(i)->butt->enableButton(!!!disable);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void PopupMenu::checkCommand(int cmd, int check)
|
|
{
|
|
for (int i = 0;i < items.getNumItems();i++)
|
|
if (items.enumItem(i)->cmd == cmd)
|
|
{
|
|
if (items.enumItem(i)->butt)
|
|
items.enumItem(i)->butt->setChecked(check);
|
|
break;
|
|
}
|
|
}
|
|
|
|
const wchar_t *PopupMenu::getCommandText(int command)
|
|
{
|
|
for (int i = 0;i < items.getNumItems();i++)
|
|
if (items.enumItem(i)->cmd == command && items.enumItem(i)->butt)
|
|
return items.enumItem(i)->butt->getName();
|
|
return NULL;
|
|
}
|
|
|
|
int PopupMenu::popAtXY(int x, int y)
|
|
{
|
|
toplevelmenu = 1;
|
|
rcode = -1;
|
|
if (items.getNumItems())
|
|
{
|
|
POINT pt = {x, y};
|
|
|
|
#ifdef WIN32
|
|
HWND oldcw = GetCapture(); // nonportable
|
|
ifc_window *oldcrw = (ifc_window*)GetWindowLong(oldcw, GWL_USERDATA);
|
|
if (oldcrw != NULL) oldcrw->cancelCapture();
|
|
#endif
|
|
|
|
WASABI_API_SYSCB->syscb_registerCallback(static_cast<SkinCallbackI*>(this));
|
|
|
|
showAtXY(x, y, &rcode);
|
|
beginCapture();
|
|
|
|
MSG msg;
|
|
|
|
#ifdef WIN32
|
|
SetCursor(LoadCursor(NULL, IDC_ARROW)); // NONPORTABLE
|
|
#endif
|
|
while (rcode == -1 && GetMessage( &msg, INVALIDOSWINDOWHANDLE, 0, 0 ))
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
|
|
endCapture();
|
|
hide();
|
|
|
|
// if (hadcapture && under) under->beginCapture();
|
|
|
|
#ifdef WIN32
|
|
if (rcode == -2 || rcode == -3)
|
|
{
|
|
DWORD p = GetMessagePos();
|
|
POINT pt;
|
|
pt.x = (signed short)LOWORD(p);
|
|
pt.y = (signed short)HIWORD(p);
|
|
HWND w = WindowFromPoint(pt);
|
|
ScreenToClient(w, &pt);
|
|
p = (pt.x & 0xFFFF) | (pt.y << 16);
|
|
//if (under) under->getRootParent()->wndProc(under->getRootParent()->gethWnd(), WM_MOUSEMOVE, 0, p);
|
|
//PostMessage(w, (rcode == -2) ? WM_MOUSEMOVE : WM_RBUTTONDOWN, 0, p);
|
|
//PostMessage(w, (rcode == -2) ? WM_LBUTTONDOWN : WM_RBUTTONDOWN, 0, p);
|
|
}
|
|
#else
|
|
DebugString("portme: popup.cpp pass on click");
|
|
#endif
|
|
|
|
}
|
|
|
|
WASABI_API_SYSCB->syscb_deregisterCallback(static_cast<SkinCallbackI*>(this));
|
|
|
|
//DebugString("appdeactivation_pop_disallow\n");
|
|
WASABI_API_WND->appdeactivation_pop_disallow(this);
|
|
|
|
onPostPop(rcode);
|
|
|
|
#ifdef WASABI_COMPILE_SKIN
|
|
if (!switchskinto.isempty())
|
|
{
|
|
WASABI_API_SKIN->skin_switchSkin(switchskinto.getNonConstVal());
|
|
switchskinto = "";
|
|
}
|
|
#endif
|
|
|
|
return rcode;
|
|
}
|
|
|
|
void PopupMenu::showAtXY(int x, int y, int *rc, int revside, int parentW)
|
|
{
|
|
int i, n;
|
|
int w = 0, h = 0;
|
|
lastitem = -1;
|
|
rcp = rc;
|
|
n = items.getNumItems();
|
|
for (i = 0; i < n; i ++)
|
|
{
|
|
if (items[i]->menu || items[i]->cb)
|
|
items[i]->butt->setRightBitmap("wasabi.popup.menu.submenu");
|
|
if (!items[i]->butt->getChecked()) items[i]->butt->setChecked( -1);
|
|
h += items[i]->butt->getHeight();
|
|
items[i]->butt->setUseBaseTexture(0);
|
|
items[i]->butt->setBorders(0);
|
|
int tw = items[i]->butt->getWidth();
|
|
if (w < tw)w = tw;
|
|
}
|
|
int neww = w + 6 + fl.getWidth() + fr.getWidth();
|
|
int newh = h + 6 + ft.getHeight() + fb.getHeight();
|
|
|
|
POINT p = {x, y};
|
|
RECT vp;
|
|
Std::getViewport(&vp, &p);
|
|
|
|
// maintain parent's reversal state
|
|
reverse_side = revside;
|
|
int savx = x;
|
|
if (reverse_side) x -= (neww + parentW);
|
|
if (x + neww > vp.right || x < 0)
|
|
{
|
|
reverse_side = !reverse_side;
|
|
x = savx;
|
|
if (reverse_side) x -= (neww + parentW);
|
|
}
|
|
|
|
if (y + newh > vp.bottom) y -= newh;
|
|
if (x < vp.left) x = vp.left;
|
|
if (y < vp.top) y = vp.top;
|
|
|
|
resize(x, y, neww, newh);
|
|
|
|
h = 0;
|
|
for (i = 0; i < n; i ++)
|
|
{
|
|
int lh = h;
|
|
h += items[i]->butt->getHeight();
|
|
items[i]->butt->resize(3 + fl.getWidth(), 3 + lh + ft.getHeight(), w, h - lh);
|
|
items[i]->butt->setHilite(0);
|
|
items[i]->butt->setPushed(0);
|
|
}
|
|
|
|
WASABI_API_WND->appdeactivation_push_disallow(this);
|
|
#ifdef WIN32
|
|
SetWindowPos(gethWnd(), HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
|
|
#elif defined(LINUX)
|
|
Atom NET_STATE = XInternAtom( Linux::getDisplay(), "_NET_WM_STATE", True );
|
|
Atom state[2];
|
|
state[0] = XInternAtom( Linux::getDisplay(), "_NET_WM_STATE_SKIP_TASKBAR", True );
|
|
state[1] = XInternAtom( Linux::getDisplay(), "_NET_WM_STATE_ABOVE", True );
|
|
|
|
if ( NET_STATE && state[0] && state[1] )
|
|
{
|
|
XChangeProperty( Linux::getDisplay(), gethWnd(), NET_STATE, XA_ATOM, 32,
|
|
PropModeReplace, (unsigned char *)state, 2 );
|
|
}
|
|
#endif
|
|
WASABI_API_WND->appdeactivation_pop_disallow(this);
|
|
setVisible(1);
|
|
}
|
|
|
|
void PopupMenu::onSetVisible(int v)
|
|
{
|
|
POPUPMENU_PARENT::onSetVisible(v);
|
|
if (v && !kbdhooked)
|
|
{
|
|
WASABI_API_WND->hookKeyboard(this);
|
|
kbdhooked = 1;
|
|
}
|
|
else if (!v && kbdhooked)
|
|
{
|
|
WASABI_API_WND->unhookKeyboard(this);
|
|
kbdhooked = 0;
|
|
}
|
|
|
|
}
|
|
|
|
void PopupMenu::hide()
|
|
{
|
|
if (lastitem >= 0 && items[lastitem]->menu)
|
|
{
|
|
items[lastitem]->menu->hide();
|
|
lastitem = -1;
|
|
}
|
|
setVisible(0);
|
|
}
|
|
|
|
int PopupMenu::popAnchored(int type)
|
|
{
|
|
RECT wr;
|
|
if (parentRootWnd != NULL)
|
|
{
|
|
parentRootWnd->getWindowRect(&wr);
|
|
}
|
|
else if (parentWnd != INVALIDOSWINDOWHANDLE)
|
|
{
|
|
#ifdef WIN32
|
|
GetWindowRect(parentWnd, &wr);
|
|
#else
|
|
DebugString("portme PopupMenu::popAnchored\n");
|
|
#endif
|
|
|
|
}
|
|
else
|
|
{
|
|
ASSERTALWAYS("can't call popAnchored without instantiating with a parent window");
|
|
}
|
|
switch (type)
|
|
{
|
|
case POPUP_ANCHOR_UL: return popAtXY(wr.left, wr.top);
|
|
case POPUP_ANCHOR_LL: return popAtXY(wr.left, wr.bottom);
|
|
case POPUP_ANCHOR_UR: return popAtXY(wr.right, wr.top);
|
|
case POPUP_ANCHOR_LR: return popAtXY(wr.right, wr.bottom);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int PopupMenu::popAtMouse()
|
|
{
|
|
int x, y;
|
|
Std::getMousePos(&x, &y);
|
|
return popAtXY(x, y);
|
|
}
|
|
|
|
int PopupMenu::childNotify(ifc_window *child, int msg, intptr_t p1, intptr_t p2)
|
|
{
|
|
if (msg == ChildNotify::BUTTON_LEFTPUSH || msg == ChildNotify::BUTTON_RIGHTPUSH)
|
|
{
|
|
for (int i = 0;i < items.getNumItems();i++)
|
|
{
|
|
if (child == items[i]->butt && (items[i]->menu || items[i]->cb))
|
|
{
|
|
if (!items[i]->butt->getEnabled()) continue;
|
|
if (items[i]->cb) initMenuCallback(i);
|
|
if (!items[i]->menu) continue;
|
|
if (openmenuid == i) continue;
|
|
RECT r;
|
|
if (openmenuid >= 0)
|
|
{
|
|
items[openmenuid]->menu->hide();
|
|
openmenuid = -1;
|
|
}
|
|
items[i]->butt->getWindowRect(&r);
|
|
PopupMenu *p = items[i]->menu;
|
|
p->showAtXY(r.right, r.top, rcp, reverse_side, r.right - r.left);
|
|
if (p1)
|
|
{
|
|
p->selectFirst();
|
|
}
|
|
openmenuid = i;
|
|
}
|
|
}
|
|
// mig: changed this to call getNotifyId();
|
|
// *rcp=p1;
|
|
*rcp = child->getNotifyId();
|
|
return 0;
|
|
}
|
|
if (msg == ChildNotify::POPUP_SUBMENUCLOSE)
|
|
{
|
|
for (int i = 0;i < items.getNumItems();i++)
|
|
{
|
|
if (child == items[i]->menu)
|
|
{
|
|
if (openmenuid != i) continue;
|
|
items[openmenuid]->menu->hide();
|
|
openmenuid = -1;
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
return POPUPMENU_PARENT::childNotify(child, msg, p1, p2);
|
|
}
|
|
|
|
void PopupMenu::selectFirst()
|
|
{
|
|
ButtonWnd *b = NULL;
|
|
int i;
|
|
for (i = 0; i < items.getNumItems(); i++)
|
|
{
|
|
b = items.enumItem(i)->butt;
|
|
if (b != NULL) break;
|
|
}
|
|
if (b == NULL) return ;
|
|
lastitem = i;
|
|
b->setHilite(1);
|
|
invalidate();
|
|
}
|
|
|
|
int PopupMenu::getWhichItem(POINT &p)
|
|
{
|
|
int x, n;
|
|
RECT r2;
|
|
getWindowRect(&r2);
|
|
n = items.getNumItems();
|
|
for (x = 0; x < n; x ++)
|
|
{
|
|
RECT r;
|
|
items[x]->butt->getWindowRect(&r);
|
|
r.right = r2.right;
|
|
r.left = r2.left;
|
|
if (Std::pointInRect(r, p))
|
|
{
|
|
return x;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int PopupMenu::isMine(int x, int y)
|
|
{
|
|
RECT r;
|
|
getWindowRect(&r);
|
|
POINT p = {x, y};
|
|
if (Std::pointInRect(r, p)) return 1;
|
|
if (lastitem >= 0 && items[lastitem]->menu && items[lastitem]->menu->isMine(x, y)) return 1;
|
|
return 0;
|
|
}
|
|
|
|
void PopupMenu::setFriendlyId(const char *id)
|
|
{
|
|
friendid = id;
|
|
}
|
|
|
|
int PopupMenu::onLeftButtonDown(int x, int y)
|
|
{
|
|
clientToScreen(&x, &y);
|
|
onButtonDown(1, x, y);
|
|
return 0;
|
|
}
|
|
|
|
int PopupMenu::onRightButtonDown(int x, int y)
|
|
{
|
|
clientToScreen(&x, &y);
|
|
onButtonDown(2, x, y);
|
|
return 0;
|
|
}
|
|
|
|
int PopupMenu::onMouseMove(int x, int y)
|
|
{
|
|
POPUPMENU_PARENT::onMouseMove(x, y);
|
|
POINT pnt = {x, y};
|
|
clientToScreen(&pnt);
|
|
|
|
if (keyctrl && lastxy.x == pnt.x && lastxy.y == pnt.y) return 1;
|
|
keyctrl = 0;
|
|
lastxy = pnt;
|
|
|
|
if (lastitem >= 0)
|
|
{
|
|
if (openmenuid >= 0 && items[openmenuid]->menu && items[openmenuid]->menu->isMine(pnt.x, pnt.y))
|
|
{
|
|
if (lastitem != openmenuid)
|
|
{
|
|
items[lastitem]->butt->setHilite(0);
|
|
items[lastitem]->butt->setPushed(0);
|
|
items[openmenuid]->butt->setHilite(1);
|
|
items[openmenuid]->butt->setPushed(1);
|
|
invalidateItem(lastitem);
|
|
lastitem = openmenuid;
|
|
invalidateItem(lastitem);
|
|
}
|
|
resetTimer( -1);
|
|
items[openmenuid]->menu->screenToClient(&pnt);
|
|
items[openmenuid]->menu->onMouseMove(pnt.x, pnt.y);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int p = getWhichItem(pnt);
|
|
if (p >= 0)
|
|
{
|
|
ItemT *it = items[p];
|
|
if (!it->issep)
|
|
{
|
|
if (p != lastitem)
|
|
{
|
|
if (lastitem >= 0)
|
|
{
|
|
/* if (items[lastitem]->menu)
|
|
{
|
|
items[lastitem]->menu->hide();
|
|
}*/
|
|
items[lastitem]->butt->setHilite(0);
|
|
items[lastitem]->butt->setPushed(0);
|
|
invalidateItem(lastitem);
|
|
}
|
|
invalidateItem(lastitem);
|
|
lastitem = p;
|
|
invalidateItem(lastitem);
|
|
items[p]->butt->setHilite(1);
|
|
if (bdown) items[p]->butt->setPushed(1);
|
|
/* if (items[p]->menu) {
|
|
RECT r;
|
|
items[p]->butt->getWindowRect(&r);
|
|
items[p]->menu->showAtXY(r.right,r.top,rcp);
|
|
}*/
|
|
resetTimer(p);
|
|
invalidateItem(lastitem);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
RECT _r;
|
|
getClientRect(&_r);
|
|
int inside = (x >= 0 && y >= 0 && x <= _r.right - _r.left && y <= _r.bottom - _r.top);
|
|
if (lastitem >= 0 && !inside)
|
|
{
|
|
items[lastitem]->butt->setHilite(0);
|
|
items[lastitem]->butt->setPushed(0);
|
|
invalidateItem(lastitem);
|
|
lastitem = -1;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!friendid.isempty())
|
|
{
|
|
ifc_window *w = WASABI_API_WND->rootWndFromPoint(&pnt);
|
|
if (w != NULL)
|
|
{
|
|
MenuButtonSurface *s = static_cast<MenuButtonSurface *>(w->getInterface(menuButtonSurfaceGuid));
|
|
if (s != NULL)
|
|
{
|
|
if (s->getParentWnd() != parentRootWnd)
|
|
{
|
|
const char *str = s->getParentMenuId();
|
|
if (STRCASEEQLSAFE(str, friendid))
|
|
{
|
|
abort();
|
|
rcode = -4;
|
|
chainmenu = s;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void PopupMenu::resetTimer(int p)
|
|
{
|
|
if (timerset)
|
|
{
|
|
killTimer(POPUP_TIMERID);
|
|
timeritem = -1;
|
|
}
|
|
if (p >= 0 && !disable_autopop)
|
|
{
|
|
setTimer(POPUP_TIMERID, popupdelay);
|
|
timeritem = p;
|
|
timerset = 1;
|
|
}
|
|
}
|
|
|
|
void PopupMenu::timerCallback(int id)
|
|
{
|
|
switch (id)
|
|
{
|
|
case POPUP_TIMERID:
|
|
killTimer(POPUP_TIMERID);
|
|
timerset = 0;
|
|
if (timeritem == openmenuid)
|
|
{
|
|
timeritem = -1;
|
|
break;
|
|
}
|
|
if (openmenuid >= 0 && items[openmenuid]->menu)
|
|
{
|
|
items[openmenuid]->menu->hide();
|
|
openmenuid = -1;
|
|
}
|
|
if (timeritem >= 0)
|
|
{
|
|
if (items[timeritem]->cb) initMenuCallback(timeritem);
|
|
if (items[timeritem]->butt->getEnabled() && items[timeritem]->menu)
|
|
{
|
|
RECT r;
|
|
items[timeritem]->butt->getWindowRect(&r);
|
|
items[timeritem]->menu->showAtXY(r.right, r.top, rcp, reverse_side, r.right - r.left);
|
|
openmenuid = timeritem;
|
|
}
|
|
timeritem = -1;
|
|
}
|
|
break;
|
|
default:
|
|
POPUPMENU_PARENT::timerCallback(id);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void PopupMenu::initMenuCallback(int item)
|
|
{
|
|
int a = rcode;
|
|
rcode = 0;
|
|
PopupMenu *p = items[item]->cb->popupMenuCallback(this, items[item]->cbparam);
|
|
rcode = a;
|
|
if (p)
|
|
{
|
|
items[item]->cb = NULL;
|
|
items[item]->menu = p;
|
|
}
|
|
}
|
|
|
|
int PopupMenu::onLeftButtonUp(int x, int y)
|
|
{
|
|
clientToScreen(&x, &y);
|
|
onButtonUp(1, x, y);
|
|
return 0;
|
|
}
|
|
|
|
int PopupMenu::onRightButtonUp(int x, int y)
|
|
{
|
|
clientToScreen(&x, &y);
|
|
onButtonUp(2, x, y);
|
|
return 0;
|
|
}
|
|
|
|
void PopupMenu::onButtonDown(int wb, int x, int y)
|
|
{
|
|
POINT pos = {x, y};
|
|
RECT r;
|
|
bdown |= wb;
|
|
if (lastitem >= 0)
|
|
{
|
|
if (items[lastitem]->menu && items[lastitem]->menu->isMine(pos.x, pos.y))
|
|
{
|
|
items[lastitem]->menu->onButtonDown(wb, x, y);
|
|
return ;
|
|
}
|
|
}
|
|
getWindowRect(&r);
|
|
if (!Std::pointInRect(r, pos))
|
|
{
|
|
rcode = (wb == 1) ? -2 : -3;
|
|
}
|
|
else
|
|
{
|
|
int item = getWhichItem(pos);
|
|
if (item >= 0) items[item]->butt->setPushed(1);
|
|
}
|
|
}
|
|
|
|
void PopupMenu::onButtonUp(int wb, int x, int y)
|
|
{
|
|
if (lastitem >= 0)
|
|
{
|
|
POINT pos = {x, y};
|
|
if (items[lastitem]->menu && items[lastitem]->menu->isMine(pos.x, pos.y))
|
|
{
|
|
items[lastitem]->menu->onButtonUp(wb, x, y);
|
|
return ;
|
|
}
|
|
}
|
|
if (bdown & wb)
|
|
{
|
|
bdown &= ~wb;
|
|
POINT pnt = {x, y};
|
|
int p = getWhichItem(pnt);
|
|
if (p >= 0)
|
|
{
|
|
items[p]->butt->onLeftPush(x, y);
|
|
if (!bdown)
|
|
{
|
|
items[p]->butt->setPushed(0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int PopupMenu::onKillFocus()
|
|
{
|
|
#ifndef LINUX
|
|
if (rcode == -1) rcode = -2;
|
|
#endif
|
|
return POPUPMENU_PARENT::onKillFocus();
|
|
}
|
|
|
|
// only translates the text, not the optional accelerator
|
|
String PopupMenu::translateButtonText(const wchar_t *text)
|
|
{
|
|
PathParser pp(text, "\t");
|
|
String ret;
|
|
for (int i = 0; i < pp.getNumStrings(); i++)
|
|
{
|
|
if (i == 0) ret += _(pp.enumString(i)); // translate first
|
|
else ret += pp.enumString(i);
|
|
if (i != pp.getNumStrings() - 1) ret += "\t";
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int PopupMenu::onPaint(Canvas *canvas)
|
|
{
|
|
PaintBltCanvas paintcanvas;
|
|
if (canvas == NULL)
|
|
{
|
|
if (!paintcanvas.beginPaint(this)) return 0;
|
|
canvas = &paintcanvas;
|
|
}
|
|
POPUPMENU_PARENT::onPaint(canvas);
|
|
|
|
RECT r, r2;
|
|
|
|
getClientRect(&r);
|
|
tex.getBitmap()->blitTile(canvas, &r);
|
|
|
|
// left side
|
|
ful.getBitmap()->blitAlpha(canvas, 0, 0);
|
|
|
|
r2.left = 0;
|
|
r2.right = fl.getWidth();
|
|
r2.top = ful.getHeight();
|
|
r2.bottom = r.bottom - fll.getHeight();
|
|
fl.getBitmap()->stretchToRectAlpha(canvas, &r2);
|
|
|
|
fll.getBitmap()->blitAlpha(canvas, 0, r.bottom - fll.getHeight());
|
|
|
|
// right side
|
|
fur.getBitmap()->blitAlpha(canvas, r.right - fur.getWidth(), 0);
|
|
|
|
r2.left = r.right - fr.getWidth();
|
|
r2.right = r.right;
|
|
r2.top = fur.getHeight();
|
|
r2.bottom = r.bottom - flr.getHeight();
|
|
fr.getBitmap()->stretchToRectAlpha(canvas, &r2);
|
|
|
|
flr.getBitmap()->blitAlpha(canvas, r.right - flr.getWidth(), r.bottom - flr.getHeight());
|
|
|
|
// top
|
|
r2.left = ful.getWidth();
|
|
r2.right = r.right - fur.getWidth();
|
|
r2.top = 0;
|
|
r2.bottom = ft.getHeight();
|
|
ft.getBitmap()->stretchToRectAlpha(canvas, &r2);
|
|
|
|
// bottom
|
|
r2.left = fll.getWidth();
|
|
r2.right = r.right - flr.getWidth();
|
|
r2.top = r.bottom - fb.getHeight();
|
|
r2.bottom = r.bottom;
|
|
fb.getBitmap()->stretchToRectAlpha(canvas, &r2);
|
|
|
|
// selection bar
|
|
|
|
if (lastitem != -1)
|
|
{
|
|
ItemT *it = items[lastitem];
|
|
RECT r3, c;
|
|
|
|
it->butt->getClientRect(&r3);
|
|
|
|
// left
|
|
r2.left = r.left + fl.getWidth() + SELMARGIN;
|
|
r2.top = r.top + r3.top;
|
|
r2.right = r2.left + sl.getWidth();
|
|
r2.bottom = r2.top + (r3.bottom - r3.top);
|
|
sl.getBitmap()->stretchToRectAlpha(canvas, &r2);
|
|
|
|
c = r2;
|
|
c.left = c.right - 1;
|
|
|
|
// right
|
|
r2.right = r.right - fr.getWidth() - SELMARGIN;
|
|
r2.left = r2.right - sr.getWidth();
|
|
sr.getBitmap()->stretchToRectAlpha(canvas, &r2);
|
|
|
|
c.right = r2.left;
|
|
|
|
// center
|
|
sc.getBitmap()->stretchToRectAlpha(canvas, &c);
|
|
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
void PopupMenu::invalidateItem(int i)
|
|
{
|
|
if (i < 0 || i >= items.getNumItems()) return ;
|
|
RECT r, r2, r3;
|
|
getClientRect(&r);
|
|
|
|
ItemT *it = items[i];
|
|
it->butt->getClientRect(&r3);
|
|
|
|
r2.left = r.left + fl.getWidth();
|
|
r2.top = r.top + r3.top;
|
|
r2.right = r.right - fl.getWidth();
|
|
r2.bottom = r2.top + (r3.bottom - r3.top);
|
|
invalidateRect(&r2);
|
|
}
|
|
|
|
int PopupMenu::getNumCommands()
|
|
{
|
|
return items.getNumItems();
|
|
}
|
|
|
|
#ifdef WASABI_COMPILE_SKIN
|
|
int PopupMenu::skincb_onCheckPreventSwitch(const char *skinname)
|
|
{
|
|
switchskinto = skinname;
|
|
rcode = -2;
|
|
return 1;
|
|
}
|
|
#endif
|
|
|
|
int PopupMenu::onSysKeyDown(int code, int d)
|
|
{
|
|
int a = POPUPMENU_PARENT::onSysKeyDown(code, d);
|
|
/* if (d & (1<<29)) {
|
|
//ALT key pressed, abort menu (mimics win32 popup behavior)
|
|
abort();
|
|
if(getParent()) SendMessageW(getParent()->gethWnd(),WM_SYSKEYDOWN,code,d);
|
|
return 0;
|
|
}*/
|
|
if (a == 0)
|
|
return onKeyDown(code);
|
|
return 0;
|
|
}
|
|
|
|
int PopupMenu::onKeyDown(int code)
|
|
{
|
|
if (POPUPMENU_PARENT::onKeyDown(code)) return 1;
|
|
switch (code)
|
|
{
|
|
case STDKEY_DOWN:
|
|
navigate(1);
|
|
return 1;
|
|
case STDKEY_UP:
|
|
navigate( -1);
|
|
return 1;
|
|
case STDKEY_RETURN:
|
|
navigate(0, 1);
|
|
return 1;
|
|
case STDKEY_RIGHT:
|
|
navigate(0, 0);
|
|
return 1;
|
|
case VK_LEFT:
|
|
if (!toplevelmenu)
|
|
notifyParent(ChildNotify::POPUP_SUBMENUCLOSE);
|
|
return 1;
|
|
case VK_ESCAPE:
|
|
abort();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void PopupMenu::abort()
|
|
{
|
|
if (toplevelmenu)
|
|
rcode = -2;
|
|
else
|
|
notifyParent(ChildNotify::POPUP_SUBMENUCLOSE);
|
|
}
|
|
|
|
void PopupMenu::navigate(int p, int f)
|
|
{
|
|
keyctrl = 1;
|
|
int i = lastitem;
|
|
|
|
ItemT *t = NULL;
|
|
|
|
if (p == 0)
|
|
{
|
|
|
|
if (lastitem >= 0)
|
|
{
|
|
ItemT *t = items.enumItem(lastitem);
|
|
if (f || t->menu || t->cb)
|
|
{
|
|
t->butt->setHilite(1);
|
|
t->butt->setPushed(1);
|
|
childNotify(t->butt, ChildNotify::BUTTON_LEFTPUSH, 1, 0);
|
|
}
|
|
}
|
|
return ;
|
|
}
|
|
|
|
while (!t || t->issep)
|
|
{
|
|
i += p;
|
|
i %= items.getNumItems();
|
|
if (i == -1) i = items.getNumItems() - 1;
|
|
if (i >= items.getNumItems()) return ;
|
|
t = items.enumItem(i);
|
|
}
|
|
|
|
if (t->butt)
|
|
{
|
|
int i;
|
|
i = items.searchItem(t);
|
|
t->butt->setHilite(1);
|
|
if (lastitem != -1)
|
|
{
|
|
ItemT *s = items.enumItem(lastitem);
|
|
if (s->butt)
|
|
{
|
|
s->butt->setPushed(0);
|
|
s->butt->setHilite(0);
|
|
}
|
|
}
|
|
lastitem = i;
|
|
invalidate();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
#else
|
|
|
|
//------------------------------------------------------------------------------------------------------------------------------------------
|
|
//------------------------------------------------------------------------------------------------------------------------------------------
|
|
//------------------------------------------------------------------------------------------------------------------------------------------
|
|
// 3rd level popup menu, yay
|
|
|
|
#include "script/c_script/c_text.h"
|
|
#include "script/c_script/c_rootobj.h"
|
|
#include "script/c_script/c_button.h"
|
|
#include "script/c_script/c_group.h"
|
|
|
|
|
|
PopupMenu::PopupMenu(ifc_window *sourceWnd)
|
|
{
|
|
ASSERT(sourceWnd != NULL);
|
|
myInit();
|
|
setParent(sourceWnd);
|
|
sourceWnd->setAllowDeactivation(0);
|
|
init(HINSTANCEfromHWND(getParent()->gethWnd()), sourceWnd->gethWnd(), TRUE);
|
|
sourceWnd->setAllowDeactivation(1);
|
|
}
|
|
|
|
PopupMenu::PopupMenu()
|
|
{
|
|
myInit();
|
|
setParent(WASABI_API_WND->main_getRootWnd());
|
|
WASABI_API_WND->main_getRootWnd()->setAllowDeactivation(0);
|
|
init(hInstance, WASABI_API_WND->main_getRootWnd()->gethWnd(), TRUE);
|
|
WASABI_API_WND->main_getRootWnd()->setAllowDeactivation(1);
|
|
}
|
|
|
|
PopupMenu::PopupMenu(PopupMenu *sourceWnd)
|
|
{
|
|
myInit();
|
|
setParent(sourceWnd);
|
|
sourceWnd->setAllowDeactivation(0);
|
|
init(GetModuleHandle(NULL), sourceWnd->gethWnd(), TRUE);
|
|
sourceWnd->setAllowDeactivation(1);
|
|
}
|
|
|
|
void PopupMenu::myInit()
|
|
{
|
|
setVirtual(0);
|
|
setStartHidden(1);
|
|
setRenderRatio(1.0);
|
|
reverse_side = 0;
|
|
rcode = 0;
|
|
submenus = 0;
|
|
c_grouplist = NULL;
|
|
WASABI_API_WND->popupexit_register(this, this);
|
|
}
|
|
|
|
PopupMenu::~PopupMenu()
|
|
{
|
|
WASABI_API_WND->popupexit_deregister(this);
|
|
delete c_grouplist;
|
|
}
|
|
|
|
int PopupMenu::onInit()
|
|
{
|
|
POPUPMENU_PARENT::onInit();
|
|
#ifdef WASABI_COMPILE_CONFIG
|
|
// {9149C445-3C30-4e04-8433-5A518ED0FDDE}
|
|
const GUID uioptions_guid =
|
|
{ 0x9149c445, 0x3c30, 0x4e04, { 0x84, 0x33, 0x5a, 0x51, 0x8e, 0xd0, 0xfd, 0xde } };
|
|
setTransparency(_intVal(WASABI_API_CONFIG->config_getCfgItemByGuid(uioptions_guid), "Popup menu alpha", 255));
|
|
#else
|
|
setTransparency(255);
|
|
#endif
|
|
|
|
|
|
|
|
setContent("wasabi.popup.main.group");
|
|
|
|
return 1;
|
|
}
|
|
|
|
int PopupMenu::popAtXY(int x, int y)
|
|
{
|
|
rcode = -1;
|
|
if (1 /*items.getNumItems()*/)
|
|
{
|
|
POINT pt = {x, y};
|
|
|
|
//DebugString("appdeactivation_push_disallow\n");
|
|
WASABI_API_WND->appdeactivation_push_disallow(this);
|
|
|
|
showAtXY(x, y, &rcode);
|
|
|
|
//MSG msg;
|
|
/*while (rcode == -1 && GetMessage( &msg, NULL, 0, 0 )) {
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}*/
|
|
|
|
SetCursor(LoadCursor(NULL, IDC_ARROW)); // NONPORTABLE
|
|
|
|
int quit = 0;
|
|
while (!quit)
|
|
{
|
|
rcode = getGuiObject()->guiobject_runModal();
|
|
if (rcode & 0x40000000 && rcode != -2 && rcode != -1)
|
|
{
|
|
int submenuentry = rcode & ~0x40000000;
|
|
ItemT *t = items.enumItem(submenuentry);
|
|
if (t->cb != NULL)
|
|
initMenuCallback(submenuentry);
|
|
if (t->menu != NULL)
|
|
{
|
|
setAllowDeactivation(0);
|
|
t->menu->showAtXY(0, 0, NULL, 0, 0);
|
|
setAllowDeactivation(1);
|
|
}
|
|
}
|
|
else
|
|
quit = 1;
|
|
}
|
|
|
|
setVisible(0);
|
|
}
|
|
|
|
//DebugString("appdeactivation_pop_disallow\n");
|
|
WASABI_API_WND->appdeactivation_pop_disallow(this);
|
|
|
|
onPostPop(rcode);
|
|
|
|
return rcode;
|
|
}
|
|
|
|
void PopupMenu::showAtXY(int x, int y, int *rc, int revside /* =0 */, int parentW /* =0 */)
|
|
{
|
|
fillContent();
|
|
int neww = getPreferences(SUGGESTED_W);
|
|
int newh = getPreferences(SUGGESTED_H);;
|
|
|
|
POINT p = {x, y};
|
|
RECT vp;
|
|
Std::getViewport(&vp, &p);
|
|
|
|
// maintain parent's reversal state
|
|
reverse_side = revside;
|
|
int savx = x;
|
|
if (reverse_side) x -= (neww + parentW);
|
|
if (x + neww > vp.right || x < 0)
|
|
{
|
|
reverse_side = !reverse_side;
|
|
x = savx;
|
|
if (reverse_side) x -= (neww + parentW);
|
|
}
|
|
|
|
if (y + newh > vp.bottom) y -= newh;
|
|
if (x < vp.left) x = vp.left;
|
|
if (y < vp.top) y = vp.top;
|
|
|
|
resize(x, y, neww, newh);
|
|
|
|
WASABI_API_WND->appdeactivation_push_disallow(this);
|
|
#ifdef WIN32
|
|
SetWindowPos(gethWnd(), HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
|
|
#else
|
|
Atom NET_STATE = XInternAtom( Linux::getDisplay(), "_NET_WM_STATE", True );
|
|
Atom state[2];
|
|
state[0] = XInternAtom( Linux::getDisplay(), "_NET_WM_STATE_SKIP_TASKBAR", True );
|
|
state[1] = XInternAtom( Linux::getDisplay(), "_NET_WM_STATE_ABOVE", True );
|
|
|
|
if ( NET_STATE && state[0] && state[1] )
|
|
{
|
|
XChangeProperty( Linux::getDisplay(), gethWnd(), NET_STATE, XA_ATOM, 32,
|
|
PropModeReplace, (unsigned char *)state, 2 );
|
|
}
|
|
#endif
|
|
WASABI_API_WND->appdeactivation_pop_disallow(this);
|
|
setVisible(1);
|
|
}
|
|
|
|
int PopupMenu::popAnchored(int type)
|
|
{
|
|
RECT wr;
|
|
getParent()->getWindowRect(&wr);
|
|
switch (type)
|
|
{
|
|
case POPUP_ANCHOR_UL: return popAtXY(wr.left, wr.top);
|
|
case POPUP_ANCHOR_LL: return popAtXY(wr.left, wr.bottom);
|
|
case POPUP_ANCHOR_UR: return popAtXY(wr.right, wr.top);
|
|
case POPUP_ANCHOR_LR: return popAtXY(wr.right, wr.bottom);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int PopupMenu::popAtMouse()
|
|
{
|
|
int x, y;
|
|
Std::getMousePos(&x, &y);
|
|
return popAtXY(x, y);
|
|
}
|
|
|
|
void PopupMenu::onNewContent()
|
|
{
|
|
POPUPMENU_PARENT::onNewContent();
|
|
if (isVisible())
|
|
fillContent();
|
|
}
|
|
|
|
void PopupMenu::fillContent()
|
|
{
|
|
GuiObject *grouplist = findObject("popup.content");
|
|
if (grouplist != NULL)
|
|
{
|
|
|
|
delete c_grouplist;
|
|
|
|
c_grouplist = new C_GroupList(*grouplist);
|
|
c_grouplist->removeAll();
|
|
c_grouplist->setRedraw(0);
|
|
|
|
for (int i = 0;i < items.getNumItems();i++)
|
|
{
|
|
addItem(items.enumItem(i));
|
|
}
|
|
|
|
c_grouplist->setRedraw(1);
|
|
}
|
|
}
|
|
|
|
void PopupMenu::addItem(ItemT *i)
|
|
{
|
|
if (c_grouplist == NULL) return ;
|
|
switch (i->type)
|
|
{
|
|
|
|
case POPUPITEM_TYPE_TEXT:
|
|
{
|
|
c_grouplist->instantiate("wasabi.popup.text.item", 1);
|
|
ScriptObject *o = c_grouplist->enumItem(c_grouplist->getNumItems() - 1);
|
|
if (o != NULL)
|
|
{
|
|
C_Group grp(o);
|
|
|
|
C_RootObject g(o);
|
|
g.notify("arrow", StringPrintfW(L"%d", (submenus) ? 1 : 0), 0, 0);
|
|
g.notify("checkmark", StringPrintfW(L"%d", menuchecks ? 1 : 0), 0, 0);
|
|
g.notify("id", StringPrintfW(L"%d", i->cmd), 0, 0);
|
|
|
|
ScriptObject *check = grp.getObject("popup.item.checkmark");
|
|
if (check != NULL)
|
|
{
|
|
C_Button toggle(check);
|
|
toggle.setActivated(i->checked);
|
|
}
|
|
|
|
ScriptObject *arrow = grp.getObject("popup.item.submenuarrow");
|
|
if (check != NULL)
|
|
{
|
|
C_Button sub(arrow);
|
|
sub.setActivated((i->menu != NULL || i->cb != NULL));
|
|
}
|
|
|
|
ScriptObject *txt = grp.getObject("popup.item.text");
|
|
if (txt != NULL)
|
|
{
|
|
C_Text itemtxt(txt);
|
|
itemtxt.setText(i->txt);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case POPUPITEM_TYPE_IMAGE:
|
|
c_grouplist->instantiate("wasabi.popup.image.item", 1);
|
|
break;
|
|
|
|
case POPUPITEM_TYPE_SEPARATOR:
|
|
c_grouplist->instantiate("wasabi.popup.separator.item", 1);
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
String PopupMenu::translateButtonText(const wchar_t *text)
|
|
{
|
|
PathParser pp(text, "\t");
|
|
String ret;
|
|
for (int i = 0; i < pp.getNumStrings(); i++)
|
|
{
|
|
if (i == 0) ret += _(pp.enumString(i)); // translate first
|
|
else ret += pp.enumString(i);
|
|
if (i != pp.getNumStrings() - 1) ret += "\t";
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void PopupMenu::addCommand(const wchar_t *_txt, int command, int checked, int disabled, int addpos)
|
|
{
|
|
if (!_txt)
|
|
{
|
|
addSeparator();
|
|
return ;
|
|
}
|
|
|
|
String txt = translateButtonText(_txt);
|
|
#ifdef WASABI_COMPILE_LOCALES
|
|
const char *bind = WASABI_API_LOCALE->locales_getBindFromAction(command);
|
|
if (bind) txt += StringPrintfW(L"\t%s", bind);
|
|
#endif
|
|
ItemT *t = new ItemT;
|
|
t->type = POPUPITEM_TYPE_TEXT;
|
|
t->cmd = command;
|
|
t->txt = txt;
|
|
t->checked = checked;
|
|
t->menu = NULL;
|
|
t->cb = NULL;
|
|
t->cmd = -1;
|
|
ASSERT(PTRLIST_POS_LAST == -1); //BU
|
|
items.addItem(t, addpos);
|
|
}
|
|
|
|
int PopupMenu::popupexitcb_onExitPopup()
|
|
{
|
|
getGuiObject()->guiobject_endModal( -2);
|
|
return 1;
|
|
}
|
|
|
|
void PopupMenu::addSubMenu(PopupMenu *menu, const wchar_t *text)
|
|
{
|
|
ASSERT(text != NULL);
|
|
submenus = 1;
|
|
ItemT *t = new ItemT;
|
|
t->type = POPUPITEM_TYPE_TEXT;
|
|
t->cmd = items.getNumItems() | 0x40000000;
|
|
t->txt = translateButtonText(text);
|
|
t->checked = 0;
|
|
t->menu = menu;
|
|
t->cb = NULL;
|
|
t->cmd = -1;
|
|
t->cmd = -1;
|
|
items.addItem(t);
|
|
}
|
|
|
|
void PopupMenu::addSubMenuCallback(const wchar_t *text, PopupMenuCallback *cb, int param)
|
|
{
|
|
ASSERT(text != NULL);
|
|
ASSERT(cb != NULL);
|
|
ItemT *t = new ItemT;
|
|
submenus = 1;
|
|
t->type = POPUPITEM_TYPE_TEXT;
|
|
t->checked = 0;
|
|
t->cmd = items.getNumItems() | 0x40000000;
|
|
t->menu = NULL;
|
|
t->cb = cb;
|
|
t->cbparam = param;
|
|
t->txt = translateButtonText(text);
|
|
t->cmd = -1;
|
|
items.addItem(t);
|
|
}
|
|
|
|
void PopupMenu::initMenuCallback(int item)
|
|
{
|
|
int a = rcode;
|
|
rcode = 0;
|
|
PopupMenu *p = items[item]->cb->popupMenuCallback(this, items[item]->cbparam);
|
|
rcode = a;
|
|
if (p)
|
|
{
|
|
items[item]->cb = NULL;
|
|
items[item]->menu = p;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
#endif //WASABI_WANT_FF_POPUP
|