2586 lines
63 KiB
C++
2586 lines
63 KiB
C++
#include <precomp.h>
|
|
#include <api/skin/widgets/mb/scriptbrowser.h>
|
|
#include <tataki/bitmap/bitmap.h>
|
|
#include <api/wnd/popup.h>
|
|
#include <api/wndmgr/msgbox.h>
|
|
#include <api/skin/widgets/group.h>
|
|
#include "layout.h"
|
|
#include <api/skin/skinparse.h>
|
|
#include <api/skin/widgets/button.h>
|
|
#include <api/core/buttons.h>
|
|
#include <api/wnd/wndtrack.h>
|
|
//#include <api/wac/main.h> //CUT!
|
|
#include <api/skin/widgets/compbuck2.h>
|
|
#include <api/wac/compon.h>
|
|
#include <api/skin/skin.h>
|
|
#include <api/wnd/notifmsg.h>
|
|
#include <api/config/items/intarray.h>
|
|
#include <api/config/items/cfgitem.h>
|
|
#include <api/config/options.h>
|
|
#include <api/script/script.h>
|
|
#include <api/script/scriptmgr.h>
|
|
#include <bfc/parse/pathparse.h>
|
|
#include <api/skin/groupmgr.h>
|
|
#include <api/wndmgr/skinembed.h>
|
|
#include <api/skin/skinparse.h>
|
|
#include <api/service/svcs/svc_action.h>
|
|
#include <api/config/items/attrbool.h>
|
|
#include <api/config/items/attrint.h>
|
|
#include <api/wndmgr/alphamgr.h>
|
|
#include <bfc/wasabi_std_wnd.h>
|
|
#include <api/wnd/PaintCanvas.h>
|
|
#ifdef _WIN32
|
|
#include <windowsx.h> // for SetWindowRedraw
|
|
#endif
|
|
|
|
#ifdef WASABINOMAINAPI
|
|
#include <api/wndmgr/gc.h>
|
|
#include <api/syscb/callbacks/gccb.h>
|
|
#endif
|
|
|
|
#ifndef WM_MOUSEWHEEL
|
|
#define WM_MOUSEWHEEL 0x20A
|
|
#endif
|
|
|
|
#define TIMER_SETTINGCHANGED 0x8791
|
|
#define TIMER_AUTOOPACIFY 0x8792
|
|
#define TIMER_AUTOOPACIFY2 0x8793
|
|
#define TIMER_OFFSCREENCHECK 0x8794
|
|
#define TIMER_TRANSPARENCY_AUTOON 0x8795
|
|
#define TIMER_SAVE_POSITION 0x8796
|
|
#define TIMER_SAVE_ALL_POSITIONS 0x8797
|
|
|
|
#ifdef WASABI_COMPILE_CONFIG
|
|
extern _bool cfg_uioptions_linkallalpha;
|
|
extern _bool cfg_uioptions_linkallratio;
|
|
extern _int cfg_uioptions_autoopacitylinked;
|
|
extern _int cfg_uioptions_autoopacitytime;
|
|
extern _int cfg_uioptions_extendautoopacity;
|
|
extern _int cfg_uioptions_autoopacityfadein;
|
|
extern _int cfg_uioptions_autoopacityfadeout;
|
|
extern _int cfg_uioptions_linkedalpha;
|
|
extern _bool cfg_options_appbarondrag;
|
|
#endif
|
|
|
|
AlphaMgr *alphaMgr = NULL;
|
|
XMLParamPair Layout::params[] =
|
|
{
|
|
{LAYOUT_SETALPHA, L"ALPHA"},
|
|
{LAYOUT_SETALPHABACKGROUND, L"ALPHABACKGROUND"},
|
|
{LAYOUT_SETDESKTOPALPHA, L"DESKTOPALPHA"},
|
|
{LAYOUT_FORCEALPHA, L"FORCEALPHA"},
|
|
{LAYOUT_SETINDESKTOP, L"INDESKTOP"},
|
|
{LAYOUT_SETLINKHEIGHT, L"LINKHEIGHT"},
|
|
{LAYOUT_SETLINKWIDTH, L"LINKWIDTH"},
|
|
{LAYOUT_SETLOCKTO, L"LOCKTO"},
|
|
{LAYOUT_SETNOACTIVATION, L"NOACTIVATION"},
|
|
{LAYOUT_NODOCK, L"NODOCK"},
|
|
{LAYOUT_NOOFFSCREENCHECK, L"NOOFFSCREENCHECK"},
|
|
{LAYOUT_NOPARENT, L"NOPARENT"},
|
|
{LAYOUT_SETONTOP, L"ONTOP"},
|
|
{LAYOUT_SETOSFRAME, L"OSFRAME"},
|
|
{LAYOUT_SETOWNER, L"OWNER"},
|
|
{LAYOUT_SNAPADJUSTBOTTOM, L"SNAPADJUSTBOTTOM"},
|
|
{LAYOUT_SNAPADJUSTLEFT, L"SNAPADJUSTLEFT"},
|
|
{LAYOUT_SNAPADJUSTRIGHT, L"SNAPADJUSTRIGHT"},
|
|
{LAYOUT_SNAPADJUSTTOP, L"SNAPADJUSTTOP"},
|
|
{LAYOUT_UNLINKED, L"UNLINKED"},
|
|
{LAYOUT_RESIZABLE, L"RESIZABLE"},
|
|
{LAYOUT_SCALABLE, L"SCALABLE"},
|
|
};
|
|
|
|
Layout::Layout()
|
|
{
|
|
getScriptObject()->vcpu_setInterface(layoutGuid, (void *)static_cast<Layout *>(this));
|
|
getScriptObject()->vcpu_setInterface(guiResizableGuid, (void *)static_cast<GuiResizable *>(this));
|
|
getScriptObject()->vcpu_setClassName(L"Layout");
|
|
getScriptObject()->vcpu_setController(layoutController);
|
|
#ifdef _WIN32
|
|
forwardMsgWnd = INVALIDOSWINDOWHANDLE;
|
|
#endif
|
|
transparency_reenabled_at = 0;
|
|
transparency_autooff = 0;
|
|
captured = 0; resizing = 0;
|
|
m_forceunlink = 0;
|
|
inresize = 0;
|
|
autoopacify = 0;
|
|
x = 0; y = 0;
|
|
#ifdef USEAPPBAR
|
|
appbar_want_autohide = 1;
|
|
appbar_want_alwaysontop = 1;
|
|
m_allowsavedock = 0;
|
|
#endif
|
|
size_w = 0; size_h = 0;
|
|
reg = NULL;
|
|
//subregionlayers = new PtrList<Layer>;
|
|
setStartHidden(TRUE);
|
|
moving = 0;
|
|
setVirtual(0);
|
|
indesktop = 0;
|
|
p_container = NULL;
|
|
alpha = 255;
|
|
linkedheight = NULL;
|
|
linkedwidth = NULL;
|
|
inlinkwidth = 0;
|
|
inlinkheight = 0;
|
|
wantactiv = 1;
|
|
wantdesktopalpha = 0;
|
|
alllayouts.addItem(this);
|
|
galphadisabled = 0;
|
|
lockedto = NULL;
|
|
osframe = 0;
|
|
scalelocked = 0;
|
|
initontop = 0;
|
|
wantredrawonresize = 1;
|
|
getGuiObject()->guiobject_setMover(1);
|
|
snap_adjust_left = snap_adjust_right = snap_adjust_top = snap_adjust_bottom = 0;
|
|
disable_auto_alpha = 0;
|
|
unlinked = 0;
|
|
scaling = 0;
|
|
transparencyoverride = -1;
|
|
noparent = 0;
|
|
forcealpha = 0;
|
|
nodock = 0;
|
|
resizable = 1;
|
|
scalable = 1;
|
|
nooffscreencheck = 0;
|
|
m_w = m_h = m_endmovesize = 0;
|
|
|
|
xuihandle = newXuiHandle();
|
|
CreateXMLParameters(xuihandle);
|
|
|
|
if (!alphaMgr)
|
|
{
|
|
alphaMgr = new AlphaMgr();
|
|
#ifdef WASABI_COMPILE_CONFIG
|
|
alphaMgr->setAllLinked(cfg_uioptions_linkallalpha.getValueAsInt());
|
|
alphaMgr->setAutoOpacify(cfg_uioptions_autoopacitylinked.getValueAsInt());
|
|
alphaMgr->setGlobalAlpha(cfg_uioptions_linkedalpha.getValueAsInt());
|
|
alphaMgr->setHoldTime(cfg_uioptions_autoopacitytime.getValueAsInt());
|
|
alphaMgr->setFadeInTime(cfg_uioptions_autoopacityfadein.getValueAsInt());
|
|
alphaMgr->setFadeOutTime(cfg_uioptions_autoopacityfadeout.getValueAsInt());
|
|
alphaMgr->setExtendAutoOpacity(cfg_uioptions_extendautoopacity.getValueAsInt());
|
|
#endif
|
|
}
|
|
alphaMgr->addLayout(this);
|
|
}
|
|
|
|
void Layout::CreateXMLParameters(int master_handle)
|
|
{
|
|
//LAYOUT_SCRIPTPARENT::CreateXMLParameters(master_handle);
|
|
int numParams = sizeof(params) / sizeof(params[0]);
|
|
hintNumberOfParams(xuihandle, numParams);
|
|
for (int i = 0;i < numParams;i++)
|
|
addParam(xuihandle, params[i], XUI_ATTRIBUTE_IMPLIED);
|
|
}
|
|
|
|
Layout::~Layout()
|
|
{
|
|
if (transparency_reenabled_at) killTimer(TIMER_TRANSPARENCY_AUTOON);
|
|
alphaMgr->removeLayout(this);
|
|
killTimer(TIMER_OFFSCREENCHECK);
|
|
if (lockedto) lockedto->removeLockedLayout(this);
|
|
WASABI_API_WNDMGR->wndTrackRemove(this);
|
|
if (reg) delete reg;
|
|
alllayouts.removeItem(this);
|
|
}
|
|
|
|
int Layout::setXuiParam(int _xuihandle, int attrid, const wchar_t *paramname, const wchar_t *strvalue)
|
|
{
|
|
if (xuihandle != _xuihandle) return LAYOUT_PARENT::setXuiParam(_xuihandle, attrid, paramname, strvalue);
|
|
switch (attrid)
|
|
{
|
|
case LAYOUT_SETDESKTOPALPHA:
|
|
setWantDesktopAlpha(WTOI(strvalue));
|
|
break;
|
|
case LAYOUT_SETINDESKTOP:
|
|
setInDesktop(WTOI(strvalue));
|
|
break;
|
|
case LAYOUT_SETALPHA:
|
|
setAlpha(WTOI(strvalue));
|
|
break;
|
|
case LAYOUT_SETLINKWIDTH:
|
|
setLinkWidth(strvalue);
|
|
if (*strvalue && isPostOnInit() && isVisible()) onResize();
|
|
break;
|
|
case LAYOUT_SETLINKHEIGHT:
|
|
setLinkHeight(strvalue);
|
|
if (*strvalue && isPostOnInit() && isVisible()) onResize();
|
|
break;
|
|
case LAYOUT_SETOWNER:
|
|
owner = strvalue;
|
|
break;
|
|
case LAYOUT_NOPARENT:
|
|
setNoParent(WTOI(strvalue));
|
|
break;
|
|
case LAYOUT_FORCEALPHA:
|
|
forcealpha = WTOI(strvalue);
|
|
break;
|
|
case LAYOUT_SETLOCKTO:
|
|
lockto = strvalue;
|
|
break;
|
|
case LAYOUT_SETOSFRAME:
|
|
osframe = WTOI(strvalue);
|
|
break;
|
|
case LAYOUT_SETALPHABACKGROUND:
|
|
setAlphaBackground(strvalue);
|
|
setWantDesktopAlpha(1);
|
|
setDrawBackground(1);
|
|
break;
|
|
case LAYOUT_SETNOACTIVATION:
|
|
wantactiv = WTOI(strvalue) ? 0 : 1;
|
|
break;
|
|
case LAYOUT_SETONTOP:
|
|
initontop = WTOI(strvalue);
|
|
if (isPostOnInit()) updateOnTop();
|
|
break;
|
|
case LAYOUT_SNAPADJUSTLEFT:
|
|
snap_adjust_left = WTOI(strvalue);
|
|
script_vcpu_onSnapAdjustChanged(SCRIPT_CALL, getScriptObject());
|
|
#ifdef USEAPPBAR
|
|
if (appbar_isDocked()) appbar_posChanged();
|
|
#endif
|
|
break;
|
|
case LAYOUT_SNAPADJUSTTOP:
|
|
snap_adjust_top = WTOI(strvalue);
|
|
script_vcpu_onSnapAdjustChanged(SCRIPT_CALL, getScriptObject());
|
|
#ifdef USEAPPBAR
|
|
if (appbar_isDocked()) appbar_posChanged();
|
|
#endif
|
|
break;
|
|
case LAYOUT_SNAPADJUSTRIGHT:
|
|
snap_adjust_right = WTOI(strvalue);
|
|
script_vcpu_onSnapAdjustChanged(SCRIPT_CALL, getScriptObject());
|
|
#ifdef USEAPPBAR
|
|
if (appbar_isDocked()) appbar_posChanged();
|
|
#endif
|
|
break;
|
|
case LAYOUT_SNAPADJUSTBOTTOM:
|
|
snap_adjust_bottom = WTOI(strvalue);
|
|
script_vcpu_onSnapAdjustChanged(SCRIPT_CALL, getScriptObject());
|
|
#ifdef USEAPPBAR
|
|
if (appbar_isDocked()) appbar_posChanged();
|
|
#endif
|
|
break;
|
|
case LAYOUT_UNLINKED:
|
|
unlinked = WTOI(strvalue);
|
|
if (!unlinked && isPostOnInit() && isVisible()) onResize();
|
|
break;
|
|
case LAYOUT_NODOCK:
|
|
setNoDock(WTOI(strvalue));
|
|
break;
|
|
case LAYOUT_NOOFFSCREENCHECK:
|
|
setNoOffscreenCheck(WTOI(strvalue));
|
|
break;
|
|
case LAYOUT_RESIZABLE:
|
|
resizable = WTOI(strvalue);
|
|
break;
|
|
case LAYOUT_SCALABLE:
|
|
scalable = WTOI(strvalue);
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void Layout::setLinkHeight(const wchar_t *layoutid)
|
|
{
|
|
linkedheight = layoutid;
|
|
}
|
|
|
|
void Layout::setLinkWidth(const wchar_t *layoutid)
|
|
{
|
|
linkedwidth = layoutid;
|
|
}
|
|
|
|
int Layout::onPostedMove()
|
|
{
|
|
updateLockedLayouts();
|
|
int r = LAYOUT_PARENT::onPostedMove();
|
|
Container *c = getParentContainer();
|
|
if (isVisible() && c && c->isMainContainer())
|
|
{
|
|
#ifdef WASABI_ON_MAIN_MOVE
|
|
WASABI_ON_MAIN_MOVE(gethWnd());
|
|
#endif
|
|
|
|
}
|
|
return r;
|
|
}
|
|
|
|
void Layout::cancelCapture()
|
|
{
|
|
if (getCapture())
|
|
endCapture();
|
|
captured = 0;
|
|
}
|
|
|
|
int Layout::isOffscreen(ifc_window *w)
|
|
{
|
|
if (!w->isVisible()) return 0;
|
|
if (nooffscreencheck) return 0;
|
|
#ifdef USEAPPBAR
|
|
if (appbar_isDocked()) return 0;
|
|
#endif
|
|
if (lockedto) return 0;
|
|
RECT wr;
|
|
w->getWindowRect(&wr);
|
|
windowTracker->snapAdjustWindowRect(w, &wr);
|
|
RECT r;
|
|
|
|
int isontop = 0;
|
|
if (w->getGuiObject())
|
|
{
|
|
isontop = WTOI(w->getGuiObject()->guiobject_getXmlParam(L"ontop"));
|
|
#ifndef EXPERIMENTAL_INDEPENDENT_AOT
|
|
if (WTOI(w->getGuiObject()->guiobject_getXmlParam(L"noparent")) == 0)
|
|
isontop = 0;
|
|
#endif
|
|
|
|
}
|
|
if (!isontop)
|
|
{
|
|
#ifdef WASABI_COMPILE_CONFIG
|
|
extern _bool cfg_options_alwaysontop;
|
|
isontop |= cfg_options_alwaysontop.getValueAsInt();
|
|
#endif
|
|
}
|
|
Wasabi::Std::getViewport(&r, NULL, &wr, NULL, isontop);
|
|
if (wr.right < r.left + 10 ||
|
|
wr.bottom < r.top + 10 ||
|
|
wr.left > r.right - 10 ||
|
|
wr.top > r.bottom - 10)
|
|
{
|
|
return 1;
|
|
} //////TO CONTINUE
|
|
return 0;
|
|
}
|
|
|
|
void Layout::offscreenCheck()
|
|
{
|
|
int disabled = 0;
|
|
#ifdef WASABI_CHECK_OFFSCREENCHECK_DISABLE
|
|
WASABI_CHECK_OFFSCREENCHECK_DISABLE(disabled);
|
|
#endif
|
|
if (disabled) return ;
|
|
if (!isVisible()) return ;
|
|
if (moving || scaling || resizing) return ;
|
|
if (isOffscreen(this))
|
|
{
|
|
windowTracker->startCooperativeMove(this);
|
|
for (int i = 0;i < windowTracker->getNumDocked();i++)
|
|
{
|
|
ifc_window *w = windowTracker->enumDocked(i);
|
|
Layout *l = static_cast<Layout*>(w->getInterface(layoutGuid));
|
|
if (l != NULL)
|
|
{
|
|
if (l->getParentContainer() && l->getParentContainer()->isMainContainer())
|
|
{
|
|
if (!isOffscreen(l))
|
|
{
|
|
windowTracker->endCooperativeMove();
|
|
return ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
windowTracker->endCooperativeMove();
|
|
RECT wr;
|
|
getWindowRect(&wr);
|
|
RECT nr = windowTracker->findOpenRect(wr);
|
|
move(nr.left, nr.top);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This one only prevents UI resizings from layers!
|
|
*/
|
|
int Layout::getResizable ()
|
|
{
|
|
return this->resizable;
|
|
}
|
|
|
|
/**
|
|
* This one only prevents UI scalings from layers!
|
|
*/
|
|
int Layout::getScalable ()
|
|
{
|
|
return this->scalable;
|
|
}
|
|
|
|
void Layout::setTransparencyOverride(int v)
|
|
{
|
|
transparencyoverride = v;
|
|
if (v != -1) setTransparency(v); else updateTransparency();
|
|
}
|
|
|
|
#ifndef PI
|
|
#define PI 3.1415926536
|
|
#endif
|
|
|
|
void Layout::timerCallback(int id)
|
|
{
|
|
if (id == TIMER_TRANSPARENCY_AUTOON)
|
|
{
|
|
if (!isTransparencySafe(1))
|
|
{
|
|
transparency_reenabled_at = 0;
|
|
return ;
|
|
}
|
|
int n = Wasabi::Std::getTickCount() - transparency_reenabled_at;
|
|
if (n < 1000) return ;
|
|
else
|
|
{
|
|
killTimer(TIMER_TRANSPARENCY_AUTOON);
|
|
transparency_autooff = 0;
|
|
updateTransparency();
|
|
transparency_reenabled_at = 0;
|
|
}
|
|
return ;
|
|
}
|
|
else if (id == TIMER_OFFSCREENCHECK)
|
|
{
|
|
offscreenCheck();
|
|
return ;
|
|
}
|
|
else if (id == TIMER_SETTINGCHANGED)
|
|
{
|
|
killTimer(TIMER_SETTINGCHANGED);
|
|
#ifdef _WIN32
|
|
HWND parent;
|
|
webserver = INVALIDOSWINDOWHANDLE;
|
|
listview = INVALIDOSWINDOWHANDLE;
|
|
getExplorerWindows(&parent, &listview, &webserver);
|
|
if (!webserver) // active desktop now off, reposition this window zorder otherwise it will be behind the icons
|
|
#ifdef WIN32
|
|
SetWindowPos(gethWnd(), HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_DEFERERASE);
|
|
#else
|
|
bringToFront();
|
|
#endif
|
|
#endif
|
|
}
|
|
else if (id == TIMER_SAVE_ALL_POSITIONS)
|
|
{
|
|
killTimer(TIMER_SAVE_ALL_POSITIONS);
|
|
saveAllPositions();
|
|
// TODO: benski> not 100% sure we want to call into the script on the timer (maybe do it in endMove)
|
|
//script_vcpu_onEndMove(SCRIPT_CALL, getScriptObject());
|
|
return;
|
|
}
|
|
else if (id == TIMER_SAVE_POSITION)
|
|
{
|
|
killTimer(TIMER_SAVE_POSITION);
|
|
savePosition();
|
|
// TODO: benski> not 100% sure we want to call into the script on the timer (maybe do it in endMove)
|
|
//script_vcpu_onEndMove(SCRIPT_CALL, getScriptObject());
|
|
return;
|
|
}
|
|
else LAYOUT_PARENT::timerCallback(id);
|
|
}
|
|
|
|
void Layout::onMouseEnterLayout()
|
|
{
|
|
script_vcpu_onMouseEnterLayout(SCRIPT_CALL, getScriptObject());
|
|
}
|
|
|
|
void Layout::onMouseLeaveLayout()
|
|
{
|
|
script_vcpu_onMouseLeaveLayout(SCRIPT_CALL, getScriptObject());
|
|
}
|
|
|
|
void Layout::beginMove()
|
|
{
|
|
moving = 1;
|
|
}
|
|
|
|
void Layout::beginScale()
|
|
{
|
|
scaling = 1;
|
|
}
|
|
|
|
void Layout::beginResize()
|
|
{
|
|
resizing = 1;
|
|
}
|
|
|
|
void Layout::endMove()
|
|
{
|
|
if (m_endmovesize)
|
|
{
|
|
m_endmovesize = 0;
|
|
RECT r;
|
|
guiresizable_getRootWnd()->getWindowRect(&r);
|
|
r.right = r.left + m_w;
|
|
r.bottom = r.top + m_h;
|
|
guiresizable_getRootWnd()->resizeToRect(&r);
|
|
}
|
|
moving = 0;
|
|
// TODO: benski> do this on a resetable timer so it doesn't go so slowly
|
|
if (WASABI_API_WNDMGR->wndTrackWasCooperative())
|
|
setTimer(TIMER_SAVE_ALL_POSITIONS, 1000);
|
|
// saveAllPositions();
|
|
else
|
|
setTimer(TIMER_SAVE_POSITION, 1000);
|
|
//savePosition();
|
|
// TODO: benski> not 100% sure we want to call into the script on the timer (maybe do it in endMove)
|
|
script_vcpu_onEndMove(SCRIPT_CALL, getScriptObject());
|
|
}
|
|
|
|
void Layout::endScale()
|
|
{
|
|
scaling = 0;
|
|
savePosition();
|
|
fixPosition();
|
|
}
|
|
|
|
void Layout::endResize()
|
|
{
|
|
resizing = 0;
|
|
RECT r;
|
|
getClientRect(&r);
|
|
RECT wr;
|
|
getWindowRect(&wr);
|
|
script_vcpu_onUserResize(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_INT(wr.left), MAKE_SCRIPT_INT(wr.top), MAKE_SCRIPT_INT(r.right - r.left), MAKE_SCRIPT_INT(r.bottom - r.top));
|
|
savePosition();
|
|
}
|
|
|
|
void Layout::onMove()
|
|
{
|
|
script_vcpu_onMove(SCRIPT_CALL, getScriptObject());
|
|
}
|
|
|
|
void Layout::setAutoOpacify(int a)
|
|
{
|
|
if (autoopacify == a) return ;
|
|
autoopacify = a != -1 ? a : autoopacify;
|
|
if (getParentContainer() && !getParentContainer()->isTranscient())
|
|
{
|
|
StringW tmp;
|
|
tmp.printf(L"Skin:%s/Container:%s/Layout:%s/autoopacify", WASABI_API_SKIN->getSkinName(), getParentContainer()->getDescriptor(), getGuiObject()->guiobject_getId());
|
|
IntArray::write(tmp, autoopacify);
|
|
}
|
|
updateTransparency();
|
|
}
|
|
|
|
void Layout::controlMenu()
|
|
{
|
|
PopupMenu pop;
|
|
int x = 1;
|
|
#ifdef WASABI_CHECK_CAN_EXIT
|
|
WASABI_CHECK_CAN_EXIT(x)
|
|
#endif
|
|
if (getParentContainer() && getParentContainer()->isMainContainer())
|
|
{
|
|
if (x)
|
|
{
|
|
pop.addCommand(StringPrintfW(L"Exit %s", WASABI_API_APP->main_getAppName()), ACTION_CLOSE);
|
|
pop.addSeparator();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!getParentContainer() || getParentContainer()->canClose())
|
|
{
|
|
pop.addCommand(L"Close window", ACTION_CLOSE_WINDOW);
|
|
pop.addSeparator();
|
|
}
|
|
}
|
|
PopupMenu *scalemenu = new PopupMenu();
|
|
scalemenu->addCommand(L"50%", ACTION_SCALE_50);
|
|
scalemenu->addCommand(L"75%", ACTION_SCALE_75, FALSE, FALSE);
|
|
scalemenu->addCommand(L"100%", ACTION_SCALE_100);
|
|
scalemenu->addCommand(L"125%", ACTION_SCALE_125);
|
|
scalemenu->addCommand(L"150%", ACTION_SCALE_150);
|
|
scalemenu->addCommand(L"200%", ACTION_SCALE_200);
|
|
scalemenu->addCommand(L"400%", ACTION_SCALE_400, FALSE, FALSE);
|
|
pop.addSubMenu(scalemenu, L"Scale");
|
|
|
|
PopupMenu *opaqmenu = new PopupMenu();
|
|
opaqmenu->addCommand(L"Auto-fade", ACTION_AUTOOPACIFY, getAutoOpacify(), FALSE);
|
|
opaqmenu->addSeparator();
|
|
opaqmenu->addCommand(L"100%", ACTION_ALPHA_100, FALSE, FALSE);
|
|
opaqmenu->addCommand(L"90%", ACTION_ALPHA_90, FALSE, FALSE);
|
|
opaqmenu->addCommand(L"80%", ACTION_ALPHA_80, FALSE, FALSE);
|
|
opaqmenu->addCommand(L"70%", ACTION_ALPHA_70, FALSE, FALSE);
|
|
opaqmenu->addCommand(L"60%", ACTION_ALPHA_60, FALSE, FALSE);
|
|
opaqmenu->addCommand(L"50%", ACTION_ALPHA_50, FALSE, FALSE);
|
|
opaqmenu->addCommand(L"40%", ACTION_ALPHA_40, FALSE, FALSE);
|
|
opaqmenu->addCommand(L"30%", ACTION_ALPHA_30, FALSE, FALSE);
|
|
opaqmenu->addCommand(L"20%", ACTION_ALPHA_20, FALSE, FALSE);
|
|
opaqmenu->addCommand(L"10%", ACTION_ALPHA_10, FALSE, FALSE);
|
|
|
|
pop.addSubMenu(opaqmenu, L"Opacity", !isTransparencySafe());
|
|
|
|
#ifdef EXPERIMENTAL_INDEPENDENT_AOT
|
|
pop.addCommand(L"Always on top", ACTION_AOT, getAlwaysOnTop());
|
|
#endif
|
|
|
|
int r = pop.popAtMouse();
|
|
if (r < 0) return ;
|
|
onActionNotify(r, 0);
|
|
}
|
|
|
|
void Layout::fixPosition()
|
|
{
|
|
RECT r;
|
|
getWindowRect(&r);
|
|
RECT orig_r = r;
|
|
|
|
RECT vr;
|
|
RegionI reg;
|
|
|
|
int i = 0;
|
|
while (Wasabi::Std::enumViewports(i, &vr))
|
|
{
|
|
reg.addRect(&vr);
|
|
i++;
|
|
}
|
|
|
|
RECT full;
|
|
reg.getBox(&full);
|
|
|
|
|
|
int dif = r.bottom - full.bottom;
|
|
if (dif > 0) r.top -= dif;
|
|
dif = r.right - full.right;
|
|
if (dif > 0) r.left -= dif;
|
|
dif = full.top - r.top;
|
|
if (dif > 0) r.top += dif;
|
|
dif = full.left - r.left;
|
|
if (dif > 0) r.left += dif;
|
|
|
|
if (orig_r.left != r.left || orig_r.top != r.top)
|
|
resize(r.left, r.top, NOCHANGE, NOCHANGE);
|
|
}
|
|
|
|
void Layout::saveAllPositions()
|
|
{
|
|
// The positions are saved from the lastest to the first one
|
|
// The 'Player' windows and the 'Main' windows are using the same prefix
|
|
// In saving in decreasing order we are sure the lastest saved is the one for the Player
|
|
|
|
for (int i = 0;i < SkinParser::script_getNumContainers();i++)
|
|
{
|
|
Container *c = SkinParser::script_enumContainer(i);
|
|
for (int j = c->getNumLayouts() - 1;j >= 0 ;--j)
|
|
{
|
|
Layout *l = c->enumLayout(j);
|
|
l->savePosition();
|
|
}
|
|
}
|
|
}
|
|
|
|
int Layout::forceTransparencyFlag()
|
|
{
|
|
return alphaMgr->needForcedTransparencyFlag(this);
|
|
}
|
|
|
|
void Layout::savePosition()
|
|
{
|
|
#ifdef WASABI_COMPILE_CONFIG
|
|
if (!getParentContainer() || getParentContainer()->isTranscient())
|
|
return ;
|
|
|
|
if (!Wasabi::Std::Wnd::isValidWnd(getOsWindowHandle()))
|
|
return ;
|
|
|
|
|
|
StringW prefix = MakePrefix();
|
|
StringPrintfW tmp( L"%s/odim", prefix.v() );
|
|
|
|
SkinBitmap *baseTexture = getBaseTexture();
|
|
|
|
if ( baseTexture )
|
|
{
|
|
IntArray::write( tmp, baseTexture->getWidth(), baseTexture->getHeight() );
|
|
}
|
|
else
|
|
{
|
|
IntArray::write( tmp, -2, -2 );
|
|
}
|
|
|
|
RECT r, rs;
|
|
getClientRect(&r); // unscaled
|
|
//DebugStringW( L"\nLayout::savePosition() - x = %d, y = %d, w = %d, h = %d \n", r.left, r.top, r.right - r.left, r.bottom - r.top );
|
|
|
|
if (r.left == 0 && r.top == 0 && r.right == 0 && r.bottom == 0)
|
|
return ;
|
|
|
|
getWindowRect(&rs); // screen scaled (for x/y)
|
|
tmp.printf(L"%s/rect", prefix.v());
|
|
IntArray::write(tmp, rs.left, rs.top, r.right - r.left, r.bottom - r.top);
|
|
//DebugStringW( L"Layout::savePosition() rect - x = %d, y = %d, w = %d, h = %d \n", rs.left, rs.top, r.right - r.left, r.bottom - r.top );
|
|
|
|
getRestoredRect(&rs);
|
|
tmp.printf(L"%s/restoredrect", prefix.v());
|
|
IntArray::write(tmp, rs.left, rs.top, rs.right - rs.left, rs.bottom - rs.top);
|
|
|
|
//DebugStringW( L"Layout::savePosition() restoredrect - x = %d, y = %d, w = %d, h = %d \n", rs.left, rs.top, rs.right - rs.left, rs.bottom - rs.top );
|
|
|
|
tmp.printf(L"%s/maximized", prefix.v());
|
|
// DebugString("isMaximized = %d\n", isMaximized());
|
|
WASABI_API_CONFIG->setIntPrivate(tmp, isMaximized());
|
|
|
|
tmp.printf(L"%s/r", prefix.v());
|
|
WASABI_API_CONFIG->setStringPrivate(tmp, StringPrintfW(getRenderRatio()));
|
|
|
|
tmp.printf(L"%s/sm", prefix.v());
|
|
TextInfoCanvas textInfoCanvas(this);
|
|
WASABI_API_CONFIG->setStringPrivate(tmp, StringPrintfW(textInfoCanvas.getSystemFontScale()));
|
|
|
|
tmp.printf(L"%s/sl", prefix.v());
|
|
WASABI_API_CONFIG->setStringPrivate(tmp, StringPrintfW(scalelocked));
|
|
|
|
tmp.printf(L"%s/autoopacify", prefix.v());
|
|
IntArray::write(tmp, autoopacify);
|
|
|
|
#ifdef USEAPPBAR
|
|
saveAppBarPosition();
|
|
#endif
|
|
|
|
#endif
|
|
}
|
|
#ifdef USEAPPBAR
|
|
void Layout::saveAppBarPosition()
|
|
{
|
|
if (m_allowsavedock)
|
|
{
|
|
StringW prefix = MakePrefix();
|
|
StringW wtmp = StringPrintfW(L"%s/appbar", prefix.v());
|
|
WASABI_API_CONFIG->setIntPrivate(wtmp, appbar_getSide());
|
|
wtmp.printf(L"%s/appbarontop", prefix.v());
|
|
WASABI_API_CONFIG->setIntPrivate(wtmp, appbar_wantAlwaysOnTop());
|
|
wtmp.printf(L"%s/appbarhidden", prefix.v());
|
|
WASABI_API_CONFIG->setIntPrivate(wtmp, appbar_isHiding());
|
|
wtmp.printf(L"%s/appbarisautohide", prefix.v());
|
|
WASABI_API_CONFIG->setIntPrivate(wtmp, appbar_isAutoHiding());
|
|
wtmp.printf(L"%s/appbarwantautohide", prefix.v());
|
|
WASABI_API_CONFIG->setIntPrivate(wtmp, appbar_wantAutoHide());
|
|
}
|
|
}
|
|
#endif
|
|
void Layout::lockScale(int locked)
|
|
{
|
|
scalelocked = locked;
|
|
StringW tmp;
|
|
StringW prefix = MakePrefix();
|
|
tmp.printf(L"%s/sl", prefix.v());
|
|
WASABI_API_CONFIG->setStringPrivate(tmp, StringPrintfW(scalelocked));
|
|
}
|
|
|
|
void Layout::resize(int x, int y, int w, int h, int wantcb)
|
|
{
|
|
if (inresize) return ;
|
|
inresize = 1;
|
|
LAYOUT_PARENT::resize(x, y, w, h, wantcb);
|
|
if (!lockedto)
|
|
getGuiObject()->guiobject_setGuiPosition(&x, &y, &w, &h, NULL, NULL, NULL, NULL);
|
|
inresize = 0;
|
|
}
|
|
|
|
void Layout::move(int x, int y)
|
|
{
|
|
//DebugStringW( L"Layout::move( x = %d, y = %d )\n", x, y );
|
|
|
|
LAYOUT_PARENT::move(x, y);
|
|
getGuiObject()->guiobject_setGuiPosition(&x, &y, NULL, NULL, NULL, NULL, NULL, NULL);
|
|
}
|
|
|
|
#define DC_CHECKLASTRESIZE 0x109
|
|
#ifdef USEAPPBAR
|
|
#define DC_LOADSAVEDDOCK 0x10A
|
|
#endif
|
|
#define DC_INVALIDATE 0x10B
|
|
|
|
int Layout::onResize()
|
|
{
|
|
LAYOUT_PARENT::onResize();
|
|
if (!abortSaving()) savePosition();
|
|
RECT r;
|
|
getClientRect(&r);
|
|
if (!linkedwidth.isempty())
|
|
{
|
|
if (!inlinkwidth)
|
|
{
|
|
inlinkwidth = 1;
|
|
RECT cr;
|
|
Layout *l = getParentContainer() ? getParentContainer()->getLayout(linkedwidth) : NULL;
|
|
if (l)
|
|
{
|
|
int _unlinked = l->isUnlinked();
|
|
_unlinked |= isUnlinked();
|
|
if (!_unlinked)
|
|
{
|
|
l->getClientRect(&cr);
|
|
POINT pt;
|
|
l->getPosition(&pt);
|
|
l->resize(pt.x, pt.y, r.right - r.left, cr.bottom - cr.top);
|
|
}
|
|
}
|
|
inlinkwidth = 0;
|
|
}
|
|
}
|
|
if (!linkedheight.isempty())
|
|
{
|
|
if (!inlinkheight)
|
|
{
|
|
inlinkheight = 1;
|
|
RECT cr;
|
|
Layout *l = getParentContainer() ? getParentContainer()->getLayout(linkedheight) : NULL;
|
|
if (l)
|
|
{
|
|
int _unlinked = l->isUnlinked();
|
|
_unlinked |= isUnlinked();
|
|
if (!_unlinked)
|
|
{
|
|
l->getClientRect(&cr);
|
|
POINT pt;
|
|
l->getPosition(&pt);
|
|
l->resize(pt.x, pt.y, cr.right - cr.left, r.bottom - r.top);
|
|
}
|
|
}
|
|
}
|
|
inlinkheight = 0;
|
|
}
|
|
updateLockedLayouts();
|
|
|
|
postDeferredCallback(DC_CHECKLASTRESIZE);
|
|
|
|
return 1;
|
|
}
|
|
|
|
int Layout::onDeferredCallback(intptr_t p1, intptr_t p2)
|
|
{
|
|
/* if (p1 == DC_CHECKLASTRESIZE) {
|
|
RECT vr;
|
|
RECT r;
|
|
RECT wr;
|
|
Std::getViewport(&vr, NULL, NULL, gethWnd(), 1);
|
|
if (renderRatioActive())
|
|
divRatio(&vr);
|
|
getClientRect(&r);
|
|
r.bottom -= snap_adjust_bottom;
|
|
r.top += snap_adjust_top;
|
|
r.right -= snap_adjust_right;
|
|
r.left += snap_adjust_left;
|
|
getWindowRect(&wr);
|
|
int n = 0;
|
|
if (r.right-r.left > vr.right-vr.left) { r.right = r.left + vr.right-vr.left; n++; }
|
|
if (r.bottom-r.top > vr.bottom-vr.top) { r.bottom = r.top + vr.bottom-vr.top; n++; }
|
|
if (n) resize(wr.left, wr.top, r.right-r.left+snap_adjust_left+snap_adjust_right, r.bottom-r.top+snap_adjust_top+snap_adjust_bottom);
|
|
} else */
|
|
#ifdef USEAPPBAR
|
|
if (p1 == DC_LOADSAVEDDOCK)
|
|
{}
|
|
#endif
|
|
|
|
if (p1 == DC_INVALIDATE)
|
|
{
|
|
invalidate();
|
|
}
|
|
return LAYOUT_PARENT::onDeferredCallback(p1, p2);
|
|
// return 1;
|
|
}
|
|
|
|
void Layout::updateLockedLayouts()
|
|
{
|
|
for (int i = 0;i < getNumLockedLayouts();i++)
|
|
{
|
|
Layout *l = enumLockedLayout(i);
|
|
|
|
if (l->getRenderRatio() != getRenderRatio())
|
|
l->setRenderRatio(getRenderRatio());
|
|
|
|
int x, y, w, h;
|
|
l->getGuiObject()->guiobject_getGuiPosition(&x, &y, &w, &h, NULL, NULL, NULL, NULL);
|
|
RECT r;
|
|
l->getClientRect(&r);
|
|
if (w == AUTOWH) w = r.right - r.left;
|
|
if (h == AUTOWH) h = r.bottom - r.top;
|
|
POINT pt;
|
|
l->getPosition(&pt);
|
|
if (x == AUTOWH) x = pt.x; else clientToScreen(&x, NULL);
|
|
if (y == AUTOWH) y = pt.y; else clientToScreen(NULL, &y);
|
|
RECT cr;
|
|
l->getWindowRect(&cr);
|
|
if (cr.left != x || cr.top != y || cr.right != cr.left + w || cr.bottom != cr.top + h)
|
|
l->Group::resize(x, y, w, h);
|
|
}
|
|
}
|
|
|
|
int Layout::isClickThrough()
|
|
{
|
|
return 0;
|
|
}
|
|
#ifdef _WIN32
|
|
LRESULT Layout::wndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
|
|
#ifdef ON_CUSTOM_ALTF4
|
|
if (uMsg == WM_KEYDOWN || uMsg == WM_SYSKEYDOWN)
|
|
if (wParam == VK_F4)
|
|
if (GetAsyncKeyState(VK_MENU)&0x8000) ON_CUSTOM_ALTF4;
|
|
#endif
|
|
|
|
if (uMsg == WM_KILLFOCUS || uMsg == WM_SETFOCUS)
|
|
{
|
|
alphaMgr->hoverCheck(this);
|
|
}
|
|
|
|
if (forwardMsgWnd != INVALIDOSWINDOWHANDLE)
|
|
{
|
|
switch (uMsg)
|
|
{
|
|
case WM_MOUSEWHEEL:
|
|
return (SendMessageW(forwardMsgWnd, uMsg, wParam, 0x31337)); // 0x31337 avoid main window callback
|
|
//case WM_DESTROY: //FG> commented out, makes wa quit when layout is destroyed
|
|
case WM_CLOSE:
|
|
return (SendMessageW(forwardMsgWnd, uMsg, wParam, lParam));
|
|
|
|
case WM_SETTINGCHANGE:
|
|
{
|
|
if (!indesktop) break;
|
|
setTimer(TIMER_SETTINGCHANGED, 1000);
|
|
}
|
|
break; //BU think this should be here eh
|
|
|
|
#ifdef WIN32
|
|
case 0x0319:
|
|
{ // hehe --BU
|
|
if (lParam & 0x20000)
|
|
FireAction(L"NEXT", NULL, 0, 0, NULL, 0, NULL, FALSE);
|
|
else
|
|
FireAction(L"PREV", NULL, 0, 0, NULL, 0, NULL, FALSE);
|
|
}
|
|
break;
|
|
#endif
|
|
/*
|
|
WIP: This won't work anymore. What should we do about it? -- mig
|
|
|
|
childNotify(NULL, CHILD_NOTIFY_LEFTPUSH, ACTION_NEXT);
|
|
break;
|
|
*/
|
|
}
|
|
}
|
|
return LAYOUT_PARENT::wndProc(hWnd, uMsg, wParam, lParam);
|
|
}
|
|
#else
|
|
OSStatus Layout::eventHandler(EventHandlerCallRef inHandlerCallRef, EventRef inEvent, void *inUserData)
|
|
{
|
|
return LAYOUT_PARENT::eventHandler(inHandlerCallRef, inEvent, inUserData);
|
|
}
|
|
#warning port me
|
|
#endif
|
|
|
|
/*int Layout::onRightButtonDown(int x, int y) {
|
|
LAYOUT_PARENT::onRightButtonDown(x, y);
|
|
// Main::appContextMenu(this, TRUE, isTransparencySafe());
|
|
return 1;
|
|
}*/
|
|
|
|
ifc_window *Layout::getCustomOwner()
|
|
{
|
|
if (noparent) return NULL;
|
|
if (owner.isempty()) return NULL;
|
|
return SkinParser::getLayout(owner);
|
|
}
|
|
|
|
void Layout::addLockedLayout(Layout *l)
|
|
{
|
|
locked.addItem(l);
|
|
updateLockedLayouts();
|
|
}
|
|
|
|
void Layout::removeLockedLayout(Layout *l)
|
|
{
|
|
locked.removeItem(l);
|
|
}
|
|
|
|
int Layout::getNumLockedLayouts()
|
|
{
|
|
return locked.getNumItems();
|
|
}
|
|
|
|
Layout *Layout::enumLockedLayout(int n)
|
|
{
|
|
return locked.enumItem(n);
|
|
}
|
|
|
|
int Layout::isLocked()
|
|
{
|
|
return (!lockto.isempty()
|
|
#ifdef USEAPPBAR
|
|
|| cfg_options_appbarondrag == 0 && appbar_isDocked()
|
|
#endif
|
|
);
|
|
}
|
|
|
|
void Layout::lockTo(Layout *t)
|
|
{
|
|
if (t == NULL) return ;
|
|
if (lockedto) lockedto->removeLockedLayout(this);
|
|
lockedto = t;
|
|
t->addLockedLayout(this);
|
|
}
|
|
|
|
Layout *Layout::getLockedTo()
|
|
{
|
|
return lockedto;
|
|
}
|
|
|
|
int Layout::reinit(OSMODULEHANDLE inst, OSWINDOWHANDLE parent, int nochild)
|
|
{
|
|
StringW osname = getOSWndName();
|
|
ASSERTPR(!indesktop, "in desktop reinit failed");
|
|
if (noparent)
|
|
parent = NULL;
|
|
int r = LAYOUT_PARENT::reinit(inst, parent, nochild);
|
|
setOSWndName(osname);
|
|
return r;
|
|
}
|
|
|
|
int Layout::init(OSMODULEHANDLE inst, OSWINDOWHANDLE parent, int nochild)
|
|
{
|
|
if (noparent) parent = NULL;
|
|
if (!indesktop) return LAYOUT_PARENT::init(inst, parent, nochild);
|
|
|
|
#ifdef _WIN32
|
|
webserver = INVALIDOSWINDOWHANDLE;
|
|
listview = INVALIDOSWINDOWHANDLE;
|
|
|
|
getExplorerWindows(&parent, &listview, &webserver);
|
|
|
|
if (!parent)
|
|
{
|
|
indesktop = 0;
|
|
return LAYOUT_PARENT::init(inst, parent, nochild);
|
|
}
|
|
#endif
|
|
nochild = 0;
|
|
|
|
#ifdef _WIN32
|
|
// if active desktop is off, that's all we can do, we'll be on top of the icons
|
|
// if active desktop is on, but listview is not, we'll be on top of active desktop
|
|
if (!webserver || !listview) return LAYOUT_PARENT::init(inst, parent, nochild);
|
|
#endif
|
|
|
|
#ifdef WIN32
|
|
// find who we're gonna sit on top of
|
|
HWND behind = listview;
|
|
if (GetWindow(listview, GW_HWNDPREV))
|
|
behind = GetWindow(listview, GW_HWNDPREV);
|
|
#else
|
|
DebugString( "portme -- Layout::init\n" );
|
|
#endif
|
|
|
|
int r = LAYOUT_PARENT::init(inst, parent, nochild);
|
|
#ifdef WIN32
|
|
SetWindowPos(gethWnd(), behind, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_DEFERERASE);
|
|
#endif
|
|
|
|
return r;
|
|
}
|
|
|
|
#ifdef WIN32
|
|
void Layout::getExplorerWindows(OSWINDOWHANDLE *parent, OSWINDOWHANDLE *listview, OSWINDOWHANDLE *webserver)
|
|
{
|
|
*parent = NULL;
|
|
*listview = NULL;
|
|
*webserver = NULL;
|
|
|
|
char classname[256] = "";
|
|
HWND w;
|
|
|
|
// find explorer window. todo: litestep support ?
|
|
*parent = FindWindowA(NULL, "Program Manager");
|
|
if (!*parent) return ;
|
|
|
|
// find its first child for parenting
|
|
*parent = GetWindow(*parent, GW_CHILD);
|
|
if (!*parent) return ;
|
|
|
|
// find the children
|
|
w = GetWindow(*parent, GW_CHILD);
|
|
|
|
while (w)
|
|
{
|
|
GetClassNameA(w, classname, 255);
|
|
if (!*webserver && STRCASEEQL("Internet Explorer_Server", classname))
|
|
*webserver = w;
|
|
if (!*listview && STRCASEEQL("SysListView32", classname))
|
|
*listview = w;
|
|
w = GetWindow(w, GW_HWNDNEXT);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
int Layout::onInit()
|
|
{
|
|
LAYOUT_PARENT::onInit();
|
|
|
|
Container *c = getParentContainer();
|
|
if (c != NULL)
|
|
{
|
|
const wchar_t *s = c->getName();
|
|
if (s != NULL)
|
|
{
|
|
setOSWndName(s);
|
|
}
|
|
}
|
|
|
|
loadSavedState();
|
|
|
|
#ifdef WA3COMPATIBILITY
|
|
setIcon(WASABI_API_APP->main_getIcon(TRUE), TRUE);
|
|
setIcon(WASABI_API_APP->main_getIcon(FALSE), FALSE);
|
|
#endif
|
|
|
|
WASABI_API_WNDMGR->wndTrackAdd(this);
|
|
|
|
if (wantDesktopAlpha() && isDesktopAlphaSafe())
|
|
desktopAlpha_autoTurnOn();
|
|
|
|
if (getBaseTexture())
|
|
{
|
|
//RECT r = {0, 0, getBaseTexture()->getWidth(), getBaseTexture()->getHeight()};
|
|
delete reg;
|
|
#ifdef _WIN32
|
|
reg = new RegionI(getBaseTexture(), NULL, 0, 0, 0, 0, 0, 0, getDesktopAlpha() ? 1 : 255);
|
|
setRegion(reg);
|
|
#else
|
|
#warning port me
|
|
#endif
|
|
}
|
|
|
|
SystemObject::onCreateLayout(this);
|
|
|
|
if (!lockto.isempty()) lockTo(SkinParser::getLayout(lockto));
|
|
|
|
updateOnTop();
|
|
|
|
setNoOffscreenCheck( -1);
|
|
|
|
return 1;
|
|
}
|
|
|
|
void Layout::updateOnTop()
|
|
{
|
|
#ifdef USEAPPBAR
|
|
if (!appbar_isDocked())
|
|
#endif
|
|
{
|
|
#ifdef EXPERIMENTAL_INDEPENDENT_AOT
|
|
setAlwaysOnTop(initontop);
|
|
#else
|
|
if (noparent)
|
|
{
|
|
int disable = 0;
|
|
#ifdef WASABI_GET_TEMPDISABLE_AOT
|
|
WASABI_GET_TEMPDISABLE_AOT(disable);
|
|
#endif
|
|
#ifdef _WIN32
|
|
if (initontop && !disable) SetWindowPos(getOsWindowHandle(), HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOOWNERZORDER | SWP_NOACTIVATE);
|
|
else SetWindowPos(getOsWindowHandle(), HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOOWNERZORDER | SWP_NOACTIVATE);
|
|
#else
|
|
#warning port me
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
}
|
|
}
|
|
|
|
void Layout::loadSavedState()
|
|
{
|
|
#ifdef WASABI_COMPILE_CONFIG
|
|
StringW tmp;
|
|
#endif
|
|
wchar_t t[64] = L"";
|
|
|
|
int ow = -1;
|
|
int oh = -1;
|
|
int ra = -1;
|
|
|
|
#ifdef WASABI_COMPILE_CONFIG
|
|
if (getParentContainer() && !getParentContainer()->isTranscient())
|
|
{
|
|
StringW prefix = MakePrefix();
|
|
tmp.printf(L"%s/odim", prefix.v());
|
|
IntArray::read(tmp, &ow, &oh);
|
|
|
|
tmp.printf(L"%s/alpha", prefix.v());
|
|
IntArray::read(tmp, &ra);
|
|
|
|
tmp.printf(L"%s/autoopacify", prefix.v());
|
|
IntArray::read(tmp, &autoopacify);
|
|
|
|
}
|
|
#endif
|
|
|
|
int from_scratch = 0;
|
|
if (Std::keyModifier(STDKEY_SHIFT) && Std::keyModifier(STDKEY_ALT) && Std::keyModifier(STDKEY_CONTROL)) from_scratch = 1;
|
|
#ifdef WASABI_COMPILE_CONFIG
|
|
if (getParentContainer() && !getParentContainer()->isTranscient())
|
|
{
|
|
StringW prefix = MakePrefix();
|
|
tmp.printf(L"%s/sl", prefix.v());
|
|
WASABI_API_CONFIG->getStringPrivate(tmp, t, 63, L"0");
|
|
lockScale(WTOI(t));
|
|
}
|
|
#endif
|
|
|
|
*t = 0;
|
|
#ifdef WASABI_COMPILE_CONFIG
|
|
if (getParentContainer() && !getParentContainer()->isTranscient())
|
|
{
|
|
StringW prefix = MakePrefix();
|
|
tmp.printf(L"%s/sm", prefix.v());
|
|
}
|
|
|
|
WASABI_API_CONFIG->getStringPrivate(tmp, t, 63, L"1.");
|
|
//double sm = (float)WTOF(t);
|
|
#else
|
|
//double sm = 1.0;
|
|
#endif
|
|
/*if (ABS(sm - Canvas::getSystemFontScale()) > 0.001)
|
|
from_scratch = 1;*/
|
|
|
|
if (Group::getBaseTexture() && alphabackground.getBitmap() != NULL)
|
|
{
|
|
if (Group::getBaseTexture()->getWidth() != alphabackground.getWidth() || Group::getBaseTexture()->getHeight() != alphabackground.getHeight())
|
|
{
|
|
ASSERTPR(0, StringPrintf("layout %S should have same size for background and alphabackground", getGuiObject()->guiobject_getParentLayout()->getGuiObject()->guiobject_getId()));
|
|
}
|
|
}
|
|
|
|
if ((ow != -2 && oh != -2) && (ow == -1 || oh == -1 || (getBaseTexture() && (ow != getBaseTexture()->getWidth() || oh != getBaseTexture()->getHeight()))))
|
|
from_scratch = 1;
|
|
|
|
int w = 0, h = 0;
|
|
int findrect = 0;
|
|
|
|
if (from_scratch || (getParentContainer() && getParentContainer()->isTranscient()))
|
|
{
|
|
if (getParentContainer())
|
|
{
|
|
int _x = getParentContainer()->getDefaultPositionX();
|
|
int _y = getParentContainer()->getDefaultPositionY();
|
|
x = _x == -1 ? x : _x;
|
|
y = _y == -1 ? y : _y;
|
|
if (x == -1 && y == -1) findrect = 1;
|
|
}
|
|
else
|
|
{
|
|
int _x, _y;
|
|
getGuiObject()->guiobject_getGuiPosition(&_x, &_y, NULL, NULL, NULL, NULL, NULL, NULL);
|
|
if (_x != AUTOWH && _x != NOCHANGE) x = _x;
|
|
if (_y != AUTOWH && _y != NOCHANGE) y = _y;
|
|
}
|
|
getGuiObject()->guiobject_getGuiPosition(NULL, NULL, &w, &h, NULL, NULL, NULL, NULL);
|
|
if (w == AUTOWH || h == AUTOWH)
|
|
{
|
|
w = getPreferences(SUGGESTED_W);
|
|
h = getPreferences(SUGGESTED_H);
|
|
int _minx = getPreferences(MINIMUM_W);
|
|
int _maxx = getPreferences(MAXIMUM_W);
|
|
int _miny = getPreferences(MINIMUM_H);
|
|
int _maxy = getPreferences(MAXIMUM_H);
|
|
if (_minx != AUTOWH && _maxx != AUTOWH && _minx > _maxx) _minx = _maxx;
|
|
if (_miny != AUTOWH && _maxy != AUTOWH && _miny > _maxy) _miny = _maxy;
|
|
if (w == AUTOWH && _minx != AUTOWH) w = _minx;
|
|
if (h == AUTOWH && _miny != AUTOWH) h = _miny;
|
|
TextInfoCanvas textInfoCanvas(this);
|
|
double fontScale = textInfoCanvas.getSystemFontScale();
|
|
if (w != AUTOWH && getGuiObject()->guiobject_getAutoSysMetricsW())
|
|
w = (int)((float)w * fontScale);
|
|
if (h != AUTOWH && getGuiObject()->guiobject_getAutoSysMetricsH())
|
|
h = (int)((float)h * fontScale);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (getParentContainer())
|
|
{
|
|
|
|
if (getParentContainer()->isMainContainer()) //FG> could be a new component installed
|
|
SkinParser::noCenterSkin();
|
|
|
|
#ifdef WASABI_COMPILE_CONFIG
|
|
StringW prefix = MakePrefix();
|
|
|
|
tmp.printf(L"%s/rect", prefix.v());
|
|
IntArray::read(tmp, &x, &y, &w, &h);
|
|
|
|
RECT rr;
|
|
tmp.printf(L"%s/restoredrect", prefix.v());
|
|
IntArray::read(tmp, (int*)&rr.left, (int*)&rr.top, (int*)&rr.right, (int*)&rr.bottom);
|
|
rr.right += rr.left;
|
|
rr.bottom += rr.top;
|
|
|
|
tmp.printf(L"%s/maximized", prefix.v());
|
|
if (WASABI_API_CONFIG->getIntPrivate(tmp, 0)) setRestoredRect(&rr);
|
|
|
|
#endif
|
|
|
|
}
|
|
}
|
|
|
|
*t = 0;
|
|
double ratio = 1.0;
|
|
|
|
if (!from_scratch)
|
|
{
|
|
if (getParentContainer())
|
|
{
|
|
#ifdef WASABI_COMPILE_CONFIG
|
|
StringW prefix = MakePrefix();
|
|
tmp.printf(L"%s/r", prefix.v());
|
|
|
|
WASABI_API_CONFIG->getStringPrivate(tmp, t, 63, L"1.");
|
|
ratio = WTOF(t);
|
|
#else
|
|
ratio = 1.0f;
|
|
#endif
|
|
|
|
}
|
|
}
|
|
|
|
#ifdef ON_TWEAK_RENDER_RATIO
|
|
if (!scalelocked) ON_TWEAK_RENDER_RATIO(ratio);
|
|
#endif
|
|
|
|
if (w == 0 || h == 0 || from_scratch)
|
|
{
|
|
int _w = getPreferences(SUGGESTED_W);
|
|
w = _w == AUTOWH ? w : _w;
|
|
int _h = getPreferences(SUGGESTED_H);
|
|
h = _h == AUTOWH ? h : _h;
|
|
|
|
TextInfoCanvas textInfoCanvas(this);
|
|
double fontScale = textInfoCanvas.getSystemFontScale();
|
|
|
|
if (getGuiObject()->guiobject_getAutoSysMetricsW())
|
|
w = (int)((float)w * fontScale);
|
|
if (getGuiObject()->guiobject_getAutoSysMetricsH())
|
|
h = (int)((float)h * fontScale);
|
|
if (w == 0 || h == 0)
|
|
{
|
|
w = getBaseTexture()->getWidth();
|
|
h = getBaseTexture()->getHeight();
|
|
}
|
|
RECT sr = {x, y, x + w, y + h};
|
|
if (findrect)
|
|
sr = windowTracker->findOpenRect(Wasabi::Std::makeRect(0, 0, (int)((float)w * getRenderRatio()), (int)((float)h * getRenderRatio())), this);
|
|
sr.right = sr.left + w;
|
|
sr.bottom = sr.top + h;
|
|
BaseWnd::resize(&sr);
|
|
}
|
|
else
|
|
{
|
|
RECT cr;
|
|
getClientRect(&cr);
|
|
RECT r = {x, y, x + w, y + h};
|
|
BaseWnd::resize(&r);
|
|
}
|
|
|
|
setAlpha(from_scratch || ra == -1 ? alpha : ((ra < 254) ? ra : 255));
|
|
|
|
Layout *main = SkinParser::getMainLayout();
|
|
if (main != this && main
|
|
#ifdef WASABI_COMPILE_CONFIG
|
|
&& cfg_uioptions_linkallratio.getValueAsInt()
|
|
#endif
|
|
&& !noparent)
|
|
{
|
|
setRenderRatio(main->getRenderRatio());
|
|
}
|
|
else setRenderRatio(ratio);
|
|
|
|
setAutoOpacify(autoopacify);
|
|
|
|
#ifdef USEAPPBAR
|
|
postDeferredCallback(DC_LOADSAVEDDOCK);
|
|
|
|
if (getParentContainer() && !getParentContainer()->isTranscient())
|
|
{
|
|
StringW prefix = MakePrefix();
|
|
StringW tmp = StringPrintfW(L"%s/appbar", prefix.v());
|
|
int side = WASABI_API_CONFIG->getIntPrivate(tmp, APPBAR_NOTDOCKED);
|
|
tmp.printf(L"%s/appbarisautohide", prefix.v());
|
|
int is_autohide = WASABI_API_CONFIG->getIntPrivate(tmp, 0);
|
|
tmp.printf(L"%s/appbarwantautohide", prefix.v());
|
|
appbar_want_autohide = is_autohide || WASABI_API_CONFIG->getIntPrivate(tmp, 1);
|
|
tmp.printf(L"%s/appbarontop", prefix.v());
|
|
appbar_want_alwaysontop = WASABI_API_CONFIG->getIntPrivate(tmp, 1);
|
|
tmp.printf(L"%s/appbarhidden",prefix.v());
|
|
int curside = appbar_getSide();
|
|
if (side != curside)
|
|
{
|
|
if (side == APPBAR_NOTDOCKED)
|
|
// starting up docked ??
|
|
appbar_dock(side);
|
|
else
|
|
{
|
|
setNoParent(2);
|
|
BaseWnd::reinit();
|
|
appbar_dock(side);
|
|
}
|
|
}
|
|
}
|
|
m_allowsavedock = 1;
|
|
|
|
#endif
|
|
}
|
|
|
|
void Layout::setBaseTexture(const wchar_t *b, int regis)
|
|
{
|
|
LAYOUT_PARENT::setBaseTexture(b, 0); // 0, not regis!
|
|
if (!getDesktopAlpha() || ((wantDesktopAlpha()) && alphabackground.getBitmap() == NULL))
|
|
{
|
|
if (regis) WASABI_API_WND->skin_unregisterBaseTextureWindow(this);
|
|
if (getBaseTexture())
|
|
{
|
|
//RECT r = {0, 0, getBaseTexture()->getWidth(), getBaseTexture()->getHeight()};
|
|
delete reg;
|
|
#ifdef _WIN32
|
|
reg = new RegionI(getBaseTexture(), NULL, 0, 0, 0, 0, 0, 0, getDesktopAlpha() ? 1 : 255);
|
|
setRegion(reg);
|
|
#else
|
|
#warning port me
|
|
#endif
|
|
}
|
|
if (regis)
|
|
WASABI_API_WND->skin_registerBaseTextureWindow(this, getBackgroundStr());
|
|
}
|
|
}
|
|
|
|
void Layout::setWantDesktopAlpha(int want)
|
|
{
|
|
if (want && !Wasabi::Std::Wnd::isDesktopAlphaAvailable())
|
|
{
|
|
// WASABI_API_WNDMGR->messageBox("Desktop Alpha Blending is only available for Win2000/WinXP and above", "Sorry", MSGBOX_OK, NULL, NULL);
|
|
return ;
|
|
}
|
|
wantdesktopalpha = want;
|
|
if (wantdesktopalpha && isInited() && isDesktopAlphaSafe())
|
|
desktopAlpha_autoTurnOn();
|
|
else if (!wantdesktopalpha && getDesktopAlpha())
|
|
desktopAlpha_autoTurnOff();
|
|
}
|
|
|
|
int Layout::wantDesktopAlpha()
|
|
{
|
|
return wantdesktopalpha;
|
|
}
|
|
|
|
int Layout::handleDesktopAlpha()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
void Layout::onGuiObjectSetVisible(GuiObject *o, int visible)
|
|
{
|
|
if (disable_auto_alpha) return ;
|
|
if (!o || !o->guiobject_getRootWnd()) return ;
|
|
if (visible)
|
|
{
|
|
if (getDesktopAlpha())
|
|
{
|
|
if (!o->guiobject_getRootWnd()->handleDesktopAlpha())
|
|
{
|
|
desktopAlpha_autoTurnOff();
|
|
}
|
|
}
|
|
if (!transparency_autooff)
|
|
{
|
|
if (!o->guiobject_getRootWnd()->handleTransparency())
|
|
{
|
|
transparency_autoTurnOff();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{ // !visible
|
|
if (!getDesktopAlpha() && wantDesktopAlpha())
|
|
{
|
|
if (isDesktopAlphaSafe())
|
|
desktopAlpha_autoTurnOn();
|
|
}
|
|
if (transparency_autooff)
|
|
{
|
|
if (isTransparencySafe(1))
|
|
transparency_autoTurnOn();
|
|
}
|
|
}
|
|
}
|
|
|
|
void Layout::desktopAlpha_autoTurnOn()
|
|
{
|
|
|
|
setDesktopAlpha(1);
|
|
|
|
WASABI_API_WND->skin_unregisterBaseTextureWindow(this);
|
|
|
|
if (getBaseTexture())
|
|
{
|
|
//RECT r = {0, 0, getBaseTexture()->getWidth(), getBaseTexture()->getHeight()};
|
|
delete reg;
|
|
#ifdef _WIN32
|
|
reg = new RegionI(getBaseTexture(), NULL, 0, 0, 0, 0, 0, 0, 1);
|
|
setRegion(reg);
|
|
#else
|
|
#warning port me
|
|
#endif
|
|
}
|
|
|
|
WASABI_API_WND->skin_registerBaseTextureWindow(this, alphabackground.getBitmap() ? alphabackgroundstr.getValue() : getBackgroundStr());
|
|
|
|
invalidate();
|
|
}
|
|
|
|
void Layout::desktopAlpha_autoTurnOff()
|
|
{
|
|
#ifdef WIN32
|
|
SetWindowRedraw(gethWnd(), FALSE);//LockWindowUpdate(gethWnd());
|
|
setDesktopAlpha(0);
|
|
|
|
WASABI_API_WND->skin_unregisterBaseTextureWindow(this);
|
|
|
|
if (getBaseTexture())
|
|
{
|
|
//RECT r = {0, 0, getBaseTexture()->getWidth(), getBaseTexture()->getHeight()};
|
|
delete reg;
|
|
reg = new RegionI(getBaseTexture(), NULL, 0, 0, 0, 0, 0, 0, 255);
|
|
setRegion(reg);
|
|
}
|
|
|
|
WASABI_API_WND->skin_registerBaseTextureWindow(this, getBackgroundStr());
|
|
SetWindowRedraw(gethWnd(), TRUE);//LockWindowUpdate(NULL);
|
|
|
|
invalidate();
|
|
#else
|
|
DebugString( "portme -- Layout::init\n" );
|
|
#endif
|
|
}
|
|
|
|
void Layout::transparency_autoTurnOn()
|
|
{
|
|
transparency_reenabled_at = Wasabi::Std::getTickCount();
|
|
setTimer(TIMER_TRANSPARENCY_AUTOON, 500);
|
|
}
|
|
|
|
void Layout::transparency_autoTurnOff()
|
|
{
|
|
transparency_autooff = 1;
|
|
killTimer(TIMER_TRANSPARENCY_AUTOON);
|
|
updateTransparency();
|
|
}
|
|
|
|
void Layout::onGlobalEnableDesktopAlpha(int enabled)
|
|
{
|
|
foreach(alllayouts)
|
|
alllayouts.getfor()->globalEnableDesktopAlpha(enabled);
|
|
endfor
|
|
#ifdef ON_TOGGLE_DESKTOPALPHA
|
|
ON_TOGGLE_DESKTOPALPHA(enabled);
|
|
#endif
|
|
}
|
|
|
|
void Layout::globalEnableDesktopAlpha(int enabled)
|
|
{
|
|
if (enabled)
|
|
{
|
|
galphadisabled = 0;
|
|
setWantDesktopAlpha(wantdesktopalpha);
|
|
}
|
|
else
|
|
{
|
|
galphadisabled = 1;
|
|
if (getDesktopAlpha())
|
|
desktopAlpha_autoTurnOff();
|
|
}
|
|
}
|
|
|
|
void Layout::setWantRedrawOnResize(int v)
|
|
{
|
|
if (wantredrawonresize == v) return ;
|
|
wantredrawonresize = v;
|
|
}
|
|
|
|
PtrList<Layout> Layout::alllayouts;
|
|
|
|
int Layout::onPaint(Canvas *canvas)
|
|
{
|
|
PaintCanvas paintcanvas;
|
|
if (canvas == NULL)
|
|
{
|
|
if (!paintcanvas.beginPaint(this)) return 0;
|
|
canvas = &paintcanvas;
|
|
}
|
|
|
|
RECT r;
|
|
|
|
if (!canvas->getClipBox(&r))
|
|
getClientRect(&r);
|
|
|
|
canvas->fillRect(&r, 0);
|
|
|
|
LAYOUT_PARENT::onPaint(canvas);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*WndHolder *Layout::getHolder() {
|
|
return this;
|
|
}*/
|
|
|
|
SkinBitmap *Layout::getBaseTexture()
|
|
{
|
|
#ifdef WASABI_COMPILE_CONFIG
|
|
// {9149C445-3C30-4e04-8433-5A518ED0FDDE}
|
|
const GUID uioptions_guid =
|
|
{ 0x9149c445, 0x3c30, 0x4e04, { 0x84, 0x33, 0x5a, 0x51, 0x8e, 0xd0, 0xfd, 0xde } };
|
|
int alphaenabled = _intVal(WASABI_API_CONFIG->config_getCfgItemByGuid(uioptions_guid), L"Enable desktop alpha");
|
|
#else
|
|
int alphaenabled = WASABI_WNDMGR_DESKTOPALPHA;
|
|
#endif
|
|
if (!alphabackground.getBitmap() || !getDesktopAlpha() || !alphaenabled) return LAYOUT_PARENT::getBaseTexture();
|
|
return alphabackground.getBitmap();
|
|
}
|
|
|
|
int Layout::runAction(int actionid, const wchar_t *param)
|
|
{
|
|
switch (actionid)
|
|
{
|
|
case ACTION_SWITCH:
|
|
if (getParentContainer())
|
|
{
|
|
getParentContainer()->switchToLayout(param);
|
|
}
|
|
break;
|
|
case ACTION_TOGGLE:
|
|
SkinParser::toggleContainer(param);
|
|
break;
|
|
#ifdef WA3COMPATIBILITY
|
|
case ACTION_MENU:
|
|
Main::doMenu(param);
|
|
break;
|
|
#endif
|
|
case ACTION_ENDMODAL:
|
|
endModal(WTOI(param));
|
|
break;
|
|
case ACTION_CLOSE:
|
|
onActionNotify(ACTION_CLOSE);
|
|
break;
|
|
#ifdef WA3COMPATIBILITY
|
|
default:
|
|
if (actionid != 0)
|
|
Main::doAction(actionid);
|
|
break;
|
|
#else
|
|
case ACTION_MINIMIZE:
|
|
#ifdef _WIN32
|
|
ShowWindow(WASABI_API_WND->main_getRootWnd()->gethWnd(), SW_MINIMIZE);
|
|
#endif
|
|
break;
|
|
#endif
|
|
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int Layout::childNotify(ifc_window *child, int msg, intptr_t param1, intptr_t param2)
|
|
{
|
|
if (msg == ACTION_ENFORCEMINMAX)
|
|
{
|
|
loadSavedState();
|
|
return 0;
|
|
}
|
|
if (child != NULL)
|
|
{
|
|
int objId = child->getNotifyId();
|
|
if (msg == ChildNotify::BUTTON_LEFTPUSH)
|
|
{
|
|
switch (objId)
|
|
{
|
|
case ACTION_SWITCH:
|
|
case ACTION_TOGGLE:
|
|
case ACTION_MENU:
|
|
runAction(objId, ((Wasabi::Button *)child)->getParam());
|
|
break;
|
|
case ACTION_ENDMODAL:
|
|
{
|
|
StringPrintfW s(L"%d", (static_cast<ButtonWnd *>(child))->getModalRetCode());
|
|
runAction(ACTION_ENDMODAL, s);
|
|
}
|
|
break;
|
|
case ACTION_CLOSE:
|
|
runAction(ACTION_CLOSE);
|
|
break;
|
|
/*
|
|
#ifdef WA3COMPATIBILITY
|
|
case ACTION_EJECT:
|
|
runAction(ACTION_EJECT, "0");
|
|
break;
|
|
#endif
|
|
*/
|
|
default:
|
|
runAction(objId);
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
if (msg == ChildNotify::BUTTON_RIGHTPUSH)
|
|
{
|
|
//FUCKO child->abortTip();
|
|
// POINT pt;
|
|
// Std::getMousePos(&pt);
|
|
// screenToClient(&pt);
|
|
// onRightButtonDown(pt.x, pt.y);
|
|
#pragma warning (disable: 4060)
|
|
switch (objId)
|
|
{
|
|
/*
|
|
#ifdef WA3COMPATIBILITY
|
|
case ACTION_EJECT: {
|
|
runAction(ACTION_EJECT, "1");
|
|
}
|
|
break;
|
|
#endif
|
|
*/
|
|
}
|
|
#pragma warning (default: 4060)
|
|
return 0;
|
|
}
|
|
}
|
|
return LAYOUT_PARENT::childNotify(child, msg, param1, param2);
|
|
}
|
|
|
|
int Layout::onActionNotify(int action, intptr_t param)
|
|
{
|
|
switch (action)
|
|
{
|
|
#ifdef WA3COMPATIBILITY
|
|
case ACTION_SYSMENU:
|
|
Main::appContextMenu(this, TRUE, isDesktopAlphaSafe());
|
|
break;
|
|
case ACTION_CONTROLMENU:
|
|
controlMenu();
|
|
break;
|
|
case ACTION_WINDOWMENU:
|
|
Main::thingerContextMenu(this);
|
|
break;
|
|
#elif defined(WASABI_CUSTOM_CONTEXTMENUS)
|
|
case ACTION_SYSMENU:
|
|
extern void appContextMenu(ifc_window *w);
|
|
appContextMenu(this);
|
|
break;
|
|
case ACTION_CONTROLMENU:
|
|
extern void appControlMenu(ifc_window *w);
|
|
appControlMenu(this);
|
|
break;
|
|
#endif
|
|
case ACTION_SCALE_50: scaleTo(50); break;
|
|
case ACTION_SCALE_75: scaleTo(75); break;
|
|
case ACTION_SCALE_100: scaleTo(100); break;
|
|
case ACTION_SCALE_125: scaleTo(125); break;
|
|
case ACTION_SCALE_150: scaleTo(150); break;
|
|
case ACTION_SCALE_200: scaleTo(200); break;
|
|
case ACTION_SCALE_400: scaleTo(400); break;
|
|
case ACTION_ALPHA_10: setAlpha(25); break;
|
|
case ACTION_ALPHA_20: setAlpha(51); break;
|
|
case ACTION_ALPHA_30: setAlpha(76); break;
|
|
case ACTION_ALPHA_40: setAlpha(102); break;
|
|
case ACTION_ALPHA_50: setAlpha(127); break;
|
|
case ACTION_ALPHA_60: setAlpha(153); break;
|
|
case ACTION_ALPHA_70: setAlpha(178); break;
|
|
case ACTION_ALPHA_80: setAlpha(204); break;
|
|
case ACTION_ALPHA_90: setAlpha(229); break;
|
|
case ACTION_ALPHA_100: setAlpha(255); break;
|
|
case ACTION_AUTOOPACIFY: setAutoOpacify(!getAutoOpacify()); break;
|
|
#ifdef EXPERIMENTAL_INDEPENDENT_AOT
|
|
case ACTION_AOT: setAlwaysOnTop(!getAlwaysOnTop()); break;
|
|
#endif
|
|
case ACTION_CLOSE_WINDOW:
|
|
case ACTION_CLOSE:
|
|
if (getParentContainer() && getParentContainer()->isMainContainer())
|
|
{
|
|
int x = 1;
|
|
#ifdef WASABI_CHECK_CAN_EXIT
|
|
WASABI_CHECK_CAN_EXIT(x)
|
|
#endif
|
|
if (x)
|
|
{
|
|
WASABI_API_APP->main_shutdown();
|
|
}
|
|
}
|
|
else if (WASABI_API_WNDMGR->getModalWnd() != this)
|
|
{
|
|
if (!getParentContainer() || !getParentContainer()->isDynamic() || !getParentContainer()->canClose())
|
|
if (getParentContainer()) getParentContainer()->setVisible(FALSE); else setVisible(FALSE);
|
|
else
|
|
skinEmbedder->destroyContainer(getParentContainer());
|
|
}
|
|
else
|
|
{
|
|
endModal(MSGBOX_ABORTED);
|
|
}
|
|
break;
|
|
default: return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void Layout::containerToggled(const wchar_t *id, int visible)
|
|
{
|
|
#ifdef _WIN32
|
|
sendNotifyToAllChildren(WM_WA_CONTAINER_TOGGLED, (intptr_t)id, visible);
|
|
#else
|
|
#warning port me
|
|
#endif
|
|
}
|
|
|
|
void Layout::componentToggled(GUID *guid, int visible)
|
|
{
|
|
#ifdef _WIN32
|
|
sendNotifyToAllChildren(WM_WA_COMPONENT_TOGGLED, (intptr_t)guid, visible);
|
|
#else
|
|
#warning port me
|
|
#endif
|
|
}
|
|
|
|
void Layout::setAlphaBackground(const wchar_t *b)
|
|
{
|
|
alphabackgroundstr = b;
|
|
alphabackground.setBitmap(b);
|
|
#ifdef _WIN32
|
|
RegionI r(alphabackground.getBitmap());
|
|
setRegion(&r);
|
|
#else
|
|
#warning port me
|
|
#endif
|
|
}
|
|
|
|
/*void Layout::setWindowRegion(api_region *reg) {
|
|
LAYOUT_PARENT::setWindowRegion(reg);
|
|
if (getDesktopAlpha()) {
|
|
SetWindowRgn(gethWnd(), NULL, FALSE);
|
|
return;
|
|
}
|
|
if (!isInited()) return;
|
|
api_region *_r = getRegion();
|
|
if (getRenderRatio() != 1.0 && reg) {
|
|
api_region *clone = _r->clone();
|
|
clone->scale(getRenderRatio());
|
|
SetWindowRgn(gethWnd(), clone->makeWindowRegion(), TRUE);
|
|
_r->disposeClone(clone);
|
|
} else {
|
|
SetWindowRgn(gethWnd(), _r ? _r->makeWindowRegion() : NULL, TRUE);
|
|
}
|
|
}*/
|
|
|
|
void Layout::onSetDesktopAlpha(int a)
|
|
{
|
|
invalidateWindowRegion();
|
|
}
|
|
|
|
void Layout::onShow(void)
|
|
{
|
|
savePosition();
|
|
if (!WASABI_API_MAKI->vcpu_getComplete()) SystemObject::onShowLayout(this);
|
|
}
|
|
|
|
void Layout::onHide(void)
|
|
{
|
|
savePosition();
|
|
if (!WASABI_API_MAKI->vcpu_getComplete()) SystemObject::onHideLayout(this);
|
|
#ifndef WASABINOMAINAPI
|
|
api->hintGarbageCollect();
|
|
#else
|
|
WASABI_API_SYSCB->syscb_issueCallback(SysCallback::GC, GarbageCollectCallback::GARBAGECOLLECT);
|
|
#endif
|
|
if (getParentContainer() && getParentContainer()->wantRefocusApp()) SkinParser::focusFirst();
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
LPARAM Layout::wndHolder_getParentParam(int i)
|
|
{
|
|
switch (i)
|
|
{
|
|
case 0: return (LPARAM)gethWnd();
|
|
case 1: return (LPARAM)static_cast<BaseWnd*>(this);
|
|
}
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
void Layout::onSetVisible( int show )
|
|
{
|
|
disable_auto_alpha = 1;
|
|
LAYOUT_PARENT::onSetVisible( show );
|
|
|
|
if ( show )
|
|
onShow();
|
|
else
|
|
onHide();
|
|
|
|
Container *p = getParentContainer();
|
|
|
|
if ( p )
|
|
p->onChildSetLayoutVisible( this, show );
|
|
|
|
disable_auto_alpha = 0;
|
|
|
|
if ( wantDesktopAlpha() && isDesktopAlphaSafe() )
|
|
desktopAlpha_autoTurnOn();
|
|
}
|
|
|
|
void Layout::scaleTo(int s)
|
|
{
|
|
beginScale();
|
|
setRenderRatio((double)s / 100.0);
|
|
endScale();
|
|
}
|
|
|
|
void Layout::setRenderRatio(double s)
|
|
{
|
|
if (isPostOnInit()
|
|
#ifdef WASABI_COMPILE_CONFIG
|
|
&& cfg_uioptions_linkallratio.getValueAsInt() == 1
|
|
#endif
|
|
&& !broadcasting)
|
|
{
|
|
broadcasting = 1;
|
|
SkinParser::setAllLayoutsRatio(s);
|
|
broadcasting = 0;
|
|
return ;
|
|
}
|
|
if (getRenderRatio() == s) return ;
|
|
LAYOUT_PARENT::setRenderRatio(s);
|
|
if (reg) invalidateWindowRegion();
|
|
invalidate();
|
|
foreach(locked)
|
|
locked.getfor()->setRenderRatio(s);
|
|
endfor;
|
|
if (lockedto && lockedto->getRenderRatio() != getRenderRatio())
|
|
lockedto->setRenderRatio(getRenderRatio());
|
|
script_vcpu_onScale(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_DOUBLE(s));
|
|
if (!abortSaving()) savePosition();
|
|
}
|
|
|
|
void Layout::setAlpha(int a)
|
|
{
|
|
int old = alpha;
|
|
alpha = a;
|
|
updateTransparency();
|
|
#ifdef WASABI_COMPILE_CONFIG
|
|
if (old != alpha && getParentContainer())
|
|
{
|
|
StringPrintfW tmp(L"Skin:%s/Container:%s/Layout:%s/alpha", WASABI_API_SKIN->getSkinName(), getParentContainer()->getDescriptor(), getGuiObject()->guiobject_getId());
|
|
IntArray::write(tmp, alpha);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
int Layout::getAlpha()
|
|
{
|
|
return alpha;
|
|
}
|
|
|
|
void Layout::setPaintingAlpha(int activealpha, int inactivealpha)
|
|
{ // from basewnd, called by gui object
|
|
LAYOUT_PARENT::setAlpha(activealpha, inactivealpha);
|
|
updateTransparency();
|
|
}
|
|
|
|
int Layout::getPaintingAlpha()
|
|
{ // from basewnd, called by gui object
|
|
return getAlpha();
|
|
}
|
|
|
|
int Layout::onActivate()
|
|
{
|
|
LAYOUT_PARENT::onActivate();
|
|
// activateChildren(1);
|
|
updateTransparency();
|
|
return 1;
|
|
}
|
|
|
|
int Layout::onKillFocus()
|
|
{
|
|
alphaMgr->hoverCheck(this);
|
|
int r = LAYOUT_PARENT::onKillFocus();
|
|
return r;
|
|
}
|
|
|
|
int Layout::onGetFocus()
|
|
{
|
|
alphaMgr->hoverCheck(this);
|
|
int r = LAYOUT_PARENT::onGetFocus();
|
|
return r;
|
|
}
|
|
|
|
int Layout::onDeactivate()
|
|
{
|
|
LAYOUT_PARENT::onDeactivate();
|
|
// activateChildren(0);
|
|
updateTransparency();
|
|
return 1;
|
|
}
|
|
|
|
void Layout::updateTransparency()
|
|
{
|
|
alphaMgr->updateTransparency(this);
|
|
}
|
|
|
|
/*
|
|
void Layout::activateChildren(int act) {
|
|
for (int i=0;i<gui_objects.getNumItems();i++) {
|
|
GuiObject *o = gui_objects.enumItem(i);
|
|
BaseWnd *b = NULL;
|
|
if (o)
|
|
b = o->getBaseWnd();
|
|
else
|
|
ASSERT(0);
|
|
if (b) {
|
|
if (act)
|
|
b->onActivate();
|
|
else
|
|
b->onDeactivate();
|
|
}
|
|
}
|
|
}*/
|
|
|
|
void Layout::center()
|
|
{
|
|
RECT r;
|
|
getNonClientRect(&r);
|
|
RECT vw;
|
|
Wasabi::Std::getViewport(&vw, NULL, NULL, gethWnd());
|
|
int x = ((vw.right - vw.left) - (r.right - r.left)) / 2;
|
|
int y = ((vw.bottom - vw.top) - (r.bottom - r.top)) / 2;
|
|
move(x, y);
|
|
}
|
|
|
|
void Layout::setParentContainer(Container *c)
|
|
{
|
|
p_container = c;
|
|
}
|
|
|
|
Container *Layout::getParentContainer()
|
|
{
|
|
return p_container;
|
|
}
|
|
|
|
int Layout::isLayout()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
void Layout::setInDesktop(int a)
|
|
{
|
|
ASSERTPR(!isInited(), "cannot change indesktop after init");
|
|
indesktop = a;
|
|
}
|
|
|
|
int Layout::getInDesktop()
|
|
{
|
|
return indesktop;
|
|
}
|
|
|
|
int Layout::isDesktopAlphaSafe()
|
|
{
|
|
#ifdef WASABI_COMPILE_CONFIG
|
|
if (galphadisabled) return 0;
|
|
// {9149C445-3C30-4e04-8433-5A518ED0FDDE}
|
|
const GUID uioptions_guid =
|
|
{ 0x9149c445, 0x3c30, 0x4e04, { 0x84, 0x33, 0x5a, 0x51, 0x8e, 0xd0, 0xfd, 0xde } };
|
|
if (!_intVal(WASABI_API_CONFIG->config_getCfgItemByGuid(uioptions_guid), L"Enable desktop alpha")) return 0;
|
|
#else
|
|
if (!WASABI_WNDMGR_DESKTOPALPHA) return 0;
|
|
#endif
|
|
return LAYOUT_PARENT::isDesktopAlphaSafe();
|
|
}
|
|
|
|
void Layout::setStatusText(const wchar_t *txt, int overlay)
|
|
{
|
|
foreach(statuscbs)
|
|
statuscbs.getfor()->onSetStatusText(txt, overlay);
|
|
endfor;
|
|
}
|
|
|
|
void Layout::addAppCmds(AppCmds *commands)
|
|
{
|
|
foreach(statuscbs)
|
|
statuscbs.getfor()->onAddAppCmds(commands);
|
|
endfor;
|
|
}
|
|
|
|
void Layout::removeAppCmds(AppCmds *commands)
|
|
{
|
|
foreach(statuscbs)
|
|
statuscbs.getfor()->onRemoveAppCmds(commands);
|
|
endfor;
|
|
}
|
|
|
|
void Layout::pushCompleted(int max)
|
|
{
|
|
foreach(statuscbs)
|
|
statuscbs.getfor()->pushCompleted(max);
|
|
endfor;
|
|
}
|
|
void Layout::incCompleted(int add)
|
|
{
|
|
foreach(statuscbs)
|
|
statuscbs.getfor()->incCompleted(add);
|
|
endfor;
|
|
}
|
|
void Layout::setCompleted(int pos)
|
|
{
|
|
foreach(statuscbs)
|
|
statuscbs.getfor()->setCompleted(pos);
|
|
endfor;
|
|
}
|
|
void Layout::popCompleted()
|
|
{
|
|
foreach(statuscbs)
|
|
statuscbs.getfor()->popCompleted();
|
|
endfor;
|
|
}
|
|
|
|
void Layout::registerStatusCallback(GuiStatusCallback *lcb)
|
|
{
|
|
statuscbs.addItem(lcb);
|
|
viewer_addViewItem(lcb->status_getDependencyPtr());
|
|
}
|
|
|
|
int Layout::viewer_onItemDeleted(api_dependent *item)
|
|
{
|
|
for (int i = 0;i < statuscbs.getNumItems();i++)
|
|
if (statuscbs.enumItem(i)->status_getDependencyPtr() == item)
|
|
{
|
|
statuscbs.removeByPos(i--);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void Layout::snapAdjust(int left, int right, int top, int bottom)
|
|
{
|
|
snap_adjust_left = left;
|
|
snap_adjust_top = top;
|
|
snap_adjust_right = right;
|
|
snap_adjust_bottom = bottom;
|
|
script_vcpu_onSnapAdjustChanged(SCRIPT_CALL, getScriptObject());
|
|
#ifdef USEAPPBAR
|
|
if (appbar_isDocked()) appbar_posChanged();
|
|
#endif
|
|
if (forceTransparencyFlag() || getAlpha() < 255) postDeferredCallback(DC_INVALIDATE);
|
|
}
|
|
|
|
void Layout::getSnapAdjust(RECT *r)
|
|
{
|
|
if (!r) return ;
|
|
r->left = snap_adjust_left;
|
|
r->top = snap_adjust_top;
|
|
r->right = snap_adjust_right;
|
|
r->bottom = snap_adjust_bottom;
|
|
}
|
|
|
|
int Layout::abortSaving()
|
|
{
|
|
GuiObject *o = getGuiObject();
|
|
if (o->guiobject_movingToTarget()) return 1;
|
|
return 0;
|
|
}
|
|
|
|
void Layout::setNoOffscreenCheck(int nocheck)
|
|
{
|
|
killTimer(TIMER_OFFSCREENCHECK);
|
|
|
|
if (nocheck != -1) nooffscreencheck = nocheck;
|
|
|
|
setTimer(TIMER_OFFSCREENCHECK, 2500);
|
|
}
|
|
|
|
#ifdef USEAPPBAR
|
|
|
|
void Layout::onDock(int side)
|
|
{
|
|
script_vcpu_onDock(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_INT(side));
|
|
}
|
|
|
|
void Layout::onUnDock()
|
|
{
|
|
script_vcpu_onUndock(SCRIPT_CALL, getScriptObject());
|
|
}
|
|
|
|
void Layout::appbar_onDock(int side)
|
|
{
|
|
onDock(side);
|
|
savePosition();
|
|
}
|
|
|
|
void Layout::appbar_onUnDock()
|
|
{
|
|
onUnDock();
|
|
savePosition();
|
|
}
|
|
|
|
void Layout::appbar_onSlide()
|
|
{
|
|
savePosition();
|
|
}
|
|
|
|
int Layout::getAppBarAutoHide()
|
|
{
|
|
return appbar_want_autohide;
|
|
}
|
|
|
|
void Layout::setAppBarAutoHide(int ah)
|
|
{
|
|
appbar_want_autohide = ah;
|
|
if (appbar_isDocked()) appbar_updateAutoHide();
|
|
savePosition();
|
|
}
|
|
|
|
int Layout::getAppBarAlwaysOnTop()
|
|
{
|
|
return appbar_want_alwaysontop;
|
|
}
|
|
|
|
void Layout::setAppBarAlwaysOnTop(int aot)
|
|
{
|
|
appbar_want_alwaysontop = aot;
|
|
if (appbar_isDocked()) appbar_updateAlwaysOnTop();
|
|
savePosition();
|
|
}
|
|
#endif
|
|
|
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
LayoutScriptController _layoutController;
|
|
LayoutScriptController *layoutController = &_layoutController;
|
|
|
|
// -- Functions table -------------------------------------
|
|
function_descriptor_struct LayoutScriptController::exportedFunction[] = {
|
|
{L"onDock", 1, (void*)Layout::script_vcpu_onDock },
|
|
{L"onUndock", 0, (void*)Layout::script_vcpu_onUndock },
|
|
{L"getScale", 0, (void*)Layout::script_vcpu_getScale },
|
|
{L"setScale", 1, (void*)Layout::script_vcpu_setScale },
|
|
{L"onScale", 1, (void*)Layout::script_vcpu_onScale },
|
|
{L"setDesktopAlpha", 1, (void*)Layout::script_vcpu_setDesktopAlpha },
|
|
{L"getDesktopAlpha", 0, (void*)Layout::script_vcpu_getDesktopAlpha },
|
|
{L"isTransparencySafe", 0, (void*)Layout::script_vcpu_isTransparencySafe},
|
|
{L"isLayoutAnimationSafe", 0, (void*)Layout::script_vcpu_isLayoutAnimationSafe},
|
|
{L"getContainer", 0, (void*)Layout::script_vcpu_getContainer },
|
|
{L"center", 0, (void*)Layout::script_vcpu_center},
|
|
{L"onMove", 0, (void*)Layout::script_vcpu_onMove},
|
|
{L"onEndMove", 0, (void*)Layout::script_vcpu_onEndMove},
|
|
{L"snapAdjust", 4, (void*)Layout::script_vcpu_snapAdjust},
|
|
{L"getSnapAdjustTop", 0, (void*)Layout::script_vcpu_getSnapAdjustTop},
|
|
{L"getSnapAdjustLeft", 0, (void*)Layout::script_vcpu_getSnapAdjustLeft},
|
|
{L"getSnapAdjustRight", 0, (void*)Layout::script_vcpu_getSnapAdjustRight},
|
|
{L"getSnapAdjustBottom", 0, (void*)Layout::script_vcpu_getSnapAdjustBottom},
|
|
{L"onUserResize", 4, (void*)Layout::script_vcpu_onUserResize},
|
|
{L"setRedrawOnResize", 1, (void*)Layout::script_vcpu_setRedrawOnResize},
|
|
{L"beforeRedock", 0, (void*)Layout::script_vcpu_beforeRedock},
|
|
{L"redock", 0, (void*)Layout::script_vcpu_redock},
|
|
{L"onMouseEnterLayout", 0, (void*)Layout::script_vcpu_onMouseEnterLayout},
|
|
{L"onMouseLeaveLayout", 0, (void*)Layout::script_vcpu_onMouseLeaveLayout},
|
|
{L"onSnapAdjustChanged", 0, (void*)Layout::script_vcpu_onSnapAdjustChanged},
|
|
};
|
|
// --------------------------------------------------------
|
|
|
|
|
|
const wchar_t *LayoutScriptController::getClassName()
|
|
{
|
|
return L"Layout";
|
|
}
|
|
|
|
const wchar_t *LayoutScriptController::getAncestorClassName()
|
|
{
|
|
return L"Group";
|
|
}
|
|
|
|
int LayoutScriptController::getInstantiable()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
ScriptObject *LayoutScriptController::instantiate()
|
|
{
|
|
Layout *l = new Layout;
|
|
return l->getScriptObject();
|
|
}
|
|
|
|
void LayoutScriptController::destroy(ScriptObject *o)
|
|
{
|
|
Group *g = static_cast<Group *>(o->vcpu_getInterface(groupGuid));
|
|
if (g && GroupMgr::hasGroup(g))
|
|
{
|
|
GroupMgr::destroy(g);
|
|
return ;
|
|
}
|
|
ASSERTALWAYS("you cannot destroy a static layout");
|
|
}
|
|
|
|
void *LayoutScriptController::encapsulate(ScriptObject *o)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
void LayoutScriptController::deencapsulate(void *o)
|
|
{}
|
|
|
|
int LayoutScriptController::getNumFunctions()
|
|
{
|
|
return sizeof(exportedFunction) / sizeof(function_descriptor_struct);
|
|
}
|
|
|
|
const function_descriptor_struct *LayoutScriptController::getExportedFunctions()
|
|
{
|
|
return exportedFunction;
|
|
}
|
|
|
|
GUID LayoutScriptController::getClassGuid()
|
|
{
|
|
return layoutGuid;
|
|
}
|
|
|
|
// -------------------------------------------------------------------------
|
|
|
|
scriptVar Layout::script_vcpu_onDock(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar side)
|
|
{
|
|
SCRIPT_FUNCTION_INIT;
|
|
PROCESS_HOOKS1(o, layoutController, side);
|
|
SCRIPT_FUNCTION_CHECKABORTEVENT;
|
|
SCRIPT_EXEC_EVENT1(o, side);
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_onUndock(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
|
|
{
|
|
SCRIPT_FUNCTION_INIT;
|
|
PROCESS_HOOKS0(o, layoutController);
|
|
SCRIPT_FUNCTION_CHECKABORTEVENT;
|
|
SCRIPT_EXEC_EVENT0(o);
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_getScale(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
|
|
{
|
|
SCRIPT_FUNCTION_INIT
|
|
double r = 0;
|
|
Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
|
|
if (l) r = l->getRenderRatio();
|
|
return MAKE_SCRIPT_DOUBLE(r);
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_setScale(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar s)
|
|
{
|
|
SCRIPT_FUNCTION_INIT
|
|
double a = GET_SCRIPT_DOUBLE(s);
|
|
Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
|
|
if (l) l->setRenderRatio(a);
|
|
RETURN_SCRIPT_VOID;
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_onScale(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar s)
|
|
{
|
|
SCRIPT_FUNCTION_INIT;
|
|
PROCESS_HOOKS1(o, layoutController, s);
|
|
SCRIPT_FUNCTION_CHECKABORTEVENT;
|
|
SCRIPT_EXEC_EVENT1(o, s);
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_setDesktopAlpha(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar s)
|
|
{
|
|
SCRIPT_FUNCTION_INIT
|
|
bool a = GET_SCRIPT_BOOLEAN(s);
|
|
Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
|
|
if (l) l->setWantDesktopAlpha(a);
|
|
RETURN_SCRIPT_VOID;
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_getDesktopAlpha(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
|
|
{
|
|
SCRIPT_FUNCTION_INIT
|
|
Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
|
|
if (l) return MAKE_SCRIPT_BOOLEAN(l->wantDesktopAlpha() && l->isDesktopAlphaSafe());
|
|
RETURN_SCRIPT_ZERO;
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_isTransparencySafe(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
|
|
{
|
|
SCRIPT_FUNCTION_INIT
|
|
Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
|
|
if (l) return MAKE_SCRIPT_BOOLEAN(l->isTransparencySafe());
|
|
RETURN_SCRIPT_ZERO;
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_isLayoutAnimationSafe(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
|
|
{
|
|
SCRIPT_FUNCTION_INIT
|
|
Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
|
|
if (l) return MAKE_SCRIPT_BOOLEAN(!l->forceTransparencyFlag() && (l->getAlphaMgr()->getAlpha(l) == 255));
|
|
RETURN_SCRIPT_ZERO;
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_getContainer(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
|
|
{
|
|
SCRIPT_FUNCTION_INIT
|
|
Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
|
|
if (l)
|
|
{
|
|
Container *c = l->getParentContainer();
|
|
return MAKE_SCRIPT_OBJECT(c ? c->getScriptObject() : NULL);
|
|
}
|
|
return MAKE_SCRIPT_OBJECT(NULL);
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_center(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
|
|
{
|
|
SCRIPT_FUNCTION_INIT
|
|
Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
|
|
if (l) l->center();
|
|
RETURN_SCRIPT_VOID;
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_setRedrawOnResize(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar v)
|
|
{
|
|
SCRIPT_FUNCTION_INIT
|
|
Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
|
|
if (l) l->setWantRedrawOnResize(GET_SCRIPT_INT(v));
|
|
RETURN_SCRIPT_VOID;
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_beforeRedock(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
|
|
{
|
|
SCRIPT_FUNCTION_INIT
|
|
Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
|
|
if (l) windowTracker->beforeRedock(l, &l->redock);
|
|
RETURN_SCRIPT_VOID;
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_redock(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
|
|
{
|
|
SCRIPT_FUNCTION_INIT
|
|
Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
|
|
if (l) windowTracker->afterRedock(l, &l->redock);
|
|
RETURN_SCRIPT_VOID;
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_onEndMove(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
|
|
{
|
|
SCRIPT_FUNCTION_INIT;
|
|
PROCESS_HOOKS0(o, layoutController);
|
|
SCRIPT_FUNCTION_CHECKABORTEVENT;
|
|
SCRIPT_EXEC_EVENT0(o);
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_onMouseEnterLayout(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
|
|
{
|
|
SCRIPT_FUNCTION_INIT;
|
|
PROCESS_HOOKS0(o, layoutController);
|
|
SCRIPT_FUNCTION_CHECKABORTEVENT;
|
|
SCRIPT_EXEC_EVENT0(o);
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_onMouseLeaveLayout(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
|
|
{
|
|
SCRIPT_FUNCTION_INIT;
|
|
PROCESS_HOOKS0(o, layoutController);
|
|
SCRIPT_FUNCTION_CHECKABORTEVENT;
|
|
SCRIPT_EXEC_EVENT0(o);
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_onSnapAdjustChanged(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
|
|
{
|
|
SCRIPT_FUNCTION_INIT;
|
|
PROCESS_HOOKS0(o, layoutController);
|
|
SCRIPT_FUNCTION_CHECKABORTEVENT;
|
|
SCRIPT_EXEC_EVENT0(o);
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_onUserResize(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar x, scriptVar y, scriptVar w, scriptVar h)
|
|
{
|
|
SCRIPT_FUNCTION_INIT;
|
|
PROCESS_HOOKS4(o, layoutController, x, y, w, h);
|
|
SCRIPT_FUNCTION_CHECKABORTEVENT;
|
|
SCRIPT_EXEC_EVENT4(o, x, y, w, h);
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_onMove(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
|
|
{
|
|
SCRIPT_FUNCTION_INIT;
|
|
PROCESS_HOOKS0(o, layoutController);
|
|
SCRIPT_FUNCTION_CHECKABORTEVENT;
|
|
SCRIPT_EXEC_EVENT0(o);
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_snapAdjust(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar left, scriptVar top, scriptVar right, scriptVar bottom)
|
|
{
|
|
SCRIPT_FUNCTION_INIT
|
|
Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
|
|
if (l) l->snapAdjust(GET_SCRIPT_INT(left), GET_SCRIPT_INT(top), GET_SCRIPT_INT(right), GET_SCRIPT_INT(bottom));
|
|
RETURN_SCRIPT_VOID;
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_getSnapAdjustLeft(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
|
|
{
|
|
SCRIPT_FUNCTION_INIT
|
|
Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
|
|
if (l)
|
|
{
|
|
RECT r;
|
|
l->getSnapAdjust(&r);
|
|
return MAKE_SCRIPT_INT(r.left);
|
|
}
|
|
RETURN_SCRIPT_VOID;
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_getSnapAdjustTop(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
|
|
{
|
|
SCRIPT_FUNCTION_INIT
|
|
Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
|
|
if (l)
|
|
{
|
|
RECT r;
|
|
l->getSnapAdjust(&r);
|
|
return MAKE_SCRIPT_INT(r.top);
|
|
}
|
|
RETURN_SCRIPT_VOID;
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_getSnapAdjustRight(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
|
|
{
|
|
SCRIPT_FUNCTION_INIT
|
|
Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
|
|
if (l)
|
|
{
|
|
RECT r;
|
|
l->getSnapAdjust(&r);
|
|
return MAKE_SCRIPT_INT(r.right);
|
|
}
|
|
RETURN_SCRIPT_VOID;
|
|
}
|
|
|
|
scriptVar Layout::script_vcpu_getSnapAdjustBottom(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
|
|
{
|
|
SCRIPT_FUNCTION_INIT
|
|
Layout *l = static_cast<Layout *>(o->vcpu_getInterface(layoutGuid));
|
|
if (l)
|
|
{
|
|
RECT r;
|
|
l->getSnapAdjust(&r);
|
|
return MAKE_SCRIPT_INT(r.bottom);
|
|
}
|
|
RETURN_SCRIPT_VOID;
|
|
}
|
|
|
|
int Layout::broadcasting = 0;
|
|
|
|
StringW Layout::MakePrefix()
|
|
{
|
|
return StringPrintfW(L"Skin:%s/Container:%s/Layout:%s", WASABI_API_SKIN->getSkinName(), getParentContainer()->getDescriptor(), getGuiObject()->guiobject_getId());
|
|
} |