steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/resources/skins/Winamp Modern/scripts/drawer.m

1060 lines
35 KiB
Mathematica
Raw Permalink Normal View History

Initial community commit
2024-09-24 12:54:57 +00:00
// -----------------------------------------------------------------------
// Generic Video/Vis Application Drawer, by Nullsoft.
//
// Please #include this script, and override the appropriate events
// (see end of file), rather than modifying this script into your own
// version.
//
// *You should not have to edit this file*, it's just a bad idea, period.
// If you need something that is not supported in this version, we
// recommend that you contact Nullsoft to suggest the feature.
//
// Satisfying user experience depends on *fully working* scripts, if you
// insist on taking this file and modifying it for yourself, be sure to
// *thoroughly* test its behavior once you are done.
//
// If you do add a feature, please contact us so that your extention can
// be made available to others without each skin developper making its
// own (potentially broken) implementation.
//
// Note: this script requires mc 1.1.2+ to compile, and wa5.8+ to run.
// -----------------------------------------------------------------------
#ifndef included
#error This script can only be compiled as a #include
#endif
#include <lib/std.mi>
#include <lib/config.mi>
#include <lib/winampconfig.mi>
// call these -- the first two are mandatory
Function initDrawer(Layout lay, String id); // call in your onScriptLoaded();
Function shutdownDrawer(); // call in your onScriptUnloading();
Function openDrawer(); // opens the drawer to the last page unless video plays, in which case it opens to it. does animations according to attribs
Function openDrawerForVideo(); // opens the drawer to the video page, does animations according to attribs
Function openDrawerForVis(); // opens the drawer to the vis page, does animations according to attribs
Function openDrawerForNothing(); // opens the drawer without putting anything in it, does animations according to attribs
Function closeDrawer(); // closes the drawer, does animations according to attribs
Function detachVis();
Function attachVis();
Function detachVideo();
Function attachVideo();
Function switchToVis();
Function switchToVideo();
Function Int getDrawerState(); // returns OPEN or CLOSED
Function Int getDrawerContent(); // returns CONTENT_VIDEO, CONTENT_VIS or CONTENT_NOTHING
Function maximizeWindow();
Function restoreWindow();
Function Int isDrawerToTop(); // returns 1 if the drawer will open to the top or will close from the top, rather than the normal to/from bottom
// whenever the main window is resized while its drawer is closed, you should compute a new layout
// height for the next opening of the drawer, this will avoid opening to a gigantic height after
// closing a big video and resizing the player horizontally. return -1 if you do not want this feature
Function Int getDrawerOpenAutoHeight(int layoutwidth);
// implement these -- mandatory
Function WindowHolder getVideoWindowHolder();
Function WindowHolder getVisWindowHolder();
Function Int getDrawerClosedHeight();
Function Int getDefaultDrawerOpenHeight();
// override these -- optional
Function onBeforeOpeningDrawer();
Function onBeforeClosingDrawer();
Function onDoneOpeningDrawer();
Function onDoneClosingDrawer();
Function onShowVis();
Function onHideVis();
Function onShowVideo();
Function onHideVideo();
Function onAttachVideo();
Function onDetachVideo();
Function onAttachVis();
Function onDetachVis();
Function onBeforeMaximize();
Function onAfterMaximize();
Function onBeforeRestore();
Function onAfterRestore();
Function onCancelMaximize();
// bind these -- mandatory (they don't have to be exposed in the menus)
Global ConfigAttribute __drawer_directiontop_attrib;
Global ConfigAttribute __scrolldrawerattrib;
Global ConfigAttribute __drawer_directionbypass_attrib;
Global ConfigAttribute __vis_detach_attrib;
Global ConfigAttribute __video_detach_attrib;
// -----------------------------------------------------------------------
#define VIDEO_GUID "{F0816D7B-FFFC-4343-80F2-E8199AA15CC3}"
#define VIS_GUID "{0000000A-000C-0010-FF7B-01014263450C}"
// this is used to temporarilly disable playback stop on video window close, in case it's set
#define SKINTWEAKS_CFGPAGE "{0542AFA4-48D9-4c9f-8900-5739D52C114F}"
// this is used to handle video auto fullscreen on play when the video window is attached to the drawer
#define VIDEO_CONFIG_GROUP "{2135E318-6919-4bcf-99D2-62BE3FCA8FA6}"
#define DEBUG
#ifdef FALSE
#undef FALSE
#endif
#define FALSE 0
#ifdef TRUE
#undef TRUE
#endif
#define TRUE -1
#define CLOSED 0
#define OPEN 1
#define DIRECTION_NONE 0
#define DIRECTION_OPENING 1
#define DIRECTION_CLOSING 2
#define CONTENT_NOTHING 0
#define CONTENT_VIDEO 1
#define CONTENT_VIS 2
#define DETACHED_VIS 1
#define DETACHED_VIDEO 2
// avoid calling these functions directly. if you do so, be sure to know what
// you're doing, and to test your script thoroughly.
Function drawer_expandWindow(int withdrawer);
Function drawer_reduceWindow(int withdrawer);
Function drawer_showWindowContent();
Function drawer_hideWindowContent();
Function drawer_hideVis();
Function drawer_showVis();
Function drawer_hideVideo();
Function drawer_showVideo();
Function drawer_dc_showVis();
Function drawer_dc_showVideo();
Function drawer_dc_hideVis();
Function drawer_dc_hideVideo();
Function drawer_dc_linkup_showVis();
Function drawer_dc_linkup_showVideo();
Function drawer_doDetachVis();
Function drawer_doAttachVis();
Function drawer_doDetachVideo();
Function drawer_doAttachVideo();
Function drawer_disablePSOVC();
Function drawer_enablePSOVC();
Function drawer_linkup_showVis();
Function drawer_linkup_showVideo();
Function drawer_doMaximizeWindow(int notif);
Global Int __drawer_direction;
Global Timer __callbackTimer;
Global Int __callback_vis_show, __callback_video_show, __callback_vis_hide, __callback_video_hide;
Global Timer __callbackTimer2;
Global Int __callback2_what;
Global Timer __PSOVCTimer;
Global Int __bypasscancel;
Global Int __isinited;
Global Int __play_auto_fs_video;
Global Int __hiding_video, __hiding_vis, __showing_vis, __showing_video;
Global Int __last_forcedbottom, __last_forcedtop;
Global Timer __tempDisable;
Global Layout __main;
Global Container __maincontainer;
Global String __myname;
Global Int __windowshade_openvid;
Global Int __windowshade_openvis;
Global int __maximized;
Global int __oldx,__oldy,__oldw,__oldh;
// -----------------------------------------------------------------------
initDrawer(Layout lay, String name) {
// todo: test all attribs assigned
__isinited = 0;
__play_auto_fs_video = 0;
__main = lay;
__maincontainer = __main.getContainer();
if (name == "") __myname = "Drawer";
else __myname = name;
__drawer_direction = DIRECTION_NONE;
drawer_hideVis();
drawer_hideVideo();
__callbackTimer = new Timer;
__callbackTimer.setDelay(1);
__callbackTimer2 = new Timer;
__callbackTimer2.setDelay(1);
__PSOVCTimer = new Timer;
__PSOVCTimer.setDelay(1000);
__tempDisable = new Timer;
__tempDisable.setDelay(50);
__maximized = getPrivateInt("winamp5", __myname+"Maximized", 0);
if (__maximized) {
onBeforeMaximize();
onAfterMaximize();
}
__oldx=getPrivateInt("winamp5", __myname+"ox", 0);
__oldy=getPrivateInt("winamp5", __myname+"oy", 0);
__oldw=getPrivateInt("winamp5", __myname+"ow", 0);
__oldh=getPrivateInt("winamp5", __myname+"oh", 0);
__last_forcedtop = getPrivateInt("winamp5", __myname+"ForcedTop", 0);
__last_forcedbottom = getPrivateInt("winamp5", __myname+"ForcedBottom", 0);
}
// -----------------------------------------------------------------------
shutdownDrawer() {
delete __callbackTimer;
delete __callbackTimer2;
delete __PSOVCTimer;
delete __tempDisable;
}
// -----------------------------------------------------------------------
Int isDrawerToTop() {
int fromtop = 0;
if (__drawer_directiontop_attrib.getData() =="1") fromtop = 1;
if (__drawer_directionbypass_attrib.getData() == "0") return fromtop;
int curstate = getPrivateInt("winamp5", __myname+"OpenState", CLOSED);
if (curstate != CLOSED) return __last_forcedtop;
int h=getPrivateInt("winamp5", __myname+"Height", getDefaultDrawerOpenHeight());
if (h == getDrawerClosedHeight()) h = getDefaultDrawerOpenHeight();
if (__maximized) h = getViewportHeight()+__main.getSnapAdjustBottom();
__last_forcedbottom = 0;
__last_forcedtop = 0;
// clienttoscreen auto adjusts for render ratio
if (fromtop) {
int y = __main.getGuiY();
int curh = __main.clientToScreenH(__main.getGuiH());
if (y + curh < __main.clientToScreenH(h) + getViewportTop()) {
int offset = __main.getSnapAdjustBottom();
if (!(y + __main.clientToScreenH(h-offset) > getViewPortTop()+getViewPortHeight())) {
__last_forcedbottom = 1;
return 0;
}
}
} else {
int offset = __main.getSnapAdjustBottom();
int y = __main.getGuiY();
if (y + __main.clientToScreenH(h-offset) > getViewPortTop()+getViewPortHeight()) {
int curh = __main.clientToScreenH(__main.getGuiH());
if (!(y + curh < __main.clientToScreenH(h) + getViewportTop())) {
__last_forcedtop = 1;
return 1;
}
}
}
return fromtop;
}
// -----------------------------------------------------------------------
__main.onTargetReached() {
unlockUI();
if (__drawer_directiontop_attrib.getData() =="1") __main.reverseTarget(0);
if (__drawer_direction == DIRECTION_OPENING) {
setPrivateInt("winamp5", __myname+"OpenState", OPEN);
drawer_showWindowContent();
onDoneOpeningDrawer();
} else if (__drawer_direction == DIRECTION_CLOSING) {
setPrivateInt("winamp5", __myname+"OpenState", CLOSED);
onDoneClosingDrawer();
}
__drawer_direction = DIRECTION_NONE;
}
// -----------------------------------------------------------------------
drawer_expandWindow(int withdrawer) {
int curstate = getPrivateInt("winamp5", __myname+"OpenState", CLOSED);
#ifdef DEBUG
debugstring("expand - curstate = " + integertostring(curstate), 0);
#endif
if (curstate == OPEN) {
drawer_showWindowContent();
onBeforeOpeningDrawer();
onDoneOpeningDrawer();
return;
}
int fromtop = isDrawerToTop();
setPrivateInt("winamp5", __myname+"OpenState", OPEN);
int h=getPrivateInt("winamp5", __myname+"Height", getDefaultDrawerOpenHeight());
if (h == getDrawerClosedHeight()) h = getDefaultDrawerOpenHeight();
if (__maximized) h = getViewportHeight()+__main.getSnapAdjustBottom();
int w = __main.getGuiW();
if (h == __main.getHeight()) withdrawer = 0;
onBeforeOpeningDrawer();
int delay = 0;
if (!__main.isLayoutAnimationSafe()) withdrawer = 0;
if (withdrawer && StringToInteger(__scrolldrawerattrib.getData())) delay = 1;
__drawer_direction = DIRECTION_OPENING;
__main.setTargetX(__main.getGuiX());
__main.setTargetY(__main.getGuiY());
__main.setTargetW(w);
__main.setTargetH(h);
__main.reverseTarget(fromtop);
__main.setTargetSpeed(delay);
__main.gotoTarget();
lockUI();
if (!__maximized)
setPrivateInt("winamp5", __myname+"Height", h);
setPrivateInt("winamp5", __myname+"ForcedBottom", __last_forcedBottom);
setPrivateInt("winamp5", __myname+"ForcedTop", __last_forcedtop);
}
// -----------------------------------------------------------------------
drawer_reduceWindow(int withdrawer) {
#ifdef DEBUG
debugstring("reduce", 0);
#endif
drawer_hideVis();
drawer_hideVideo();
setPrivateInt("winamp5", __myname+"OpenState", CLOSED);
if (__drawer_direction == DIRECTION_NONE && !__maximized) { // avoid saving new size if we're currenly opening
int h=__main.getHeight();
setPrivateInt("winamp5", __myname+"Height", h);
}
drawer_hideWindowContent();
onBeforeClosingDrawer();
int fromtop=0;
if (__drawer_directiontop_attrib.getData() =="1") fromtop = 1;
int delay = 0;
if (!__main.isLayoutAnimationSafe()) withdrawer = 0;
if (withdrawer && StringToInteger(__scrolldrawerattrib.getData())) delay = 1;
if (__drawer_directionbypass_attrib.getData() == "1") {
if (__last_forcedtop) fromtop = 1;
if (__last_forcedbottom) fromtop = 0;
}
__drawer_direction = DIRECTION_CLOSING;
__main.setTargetX(__main.getGuiX());
__main.setTargetY(__main.getGuiY());
__main.setTargetW(__main.getGuiW());
__main.setTargetH(getDrawerClosedHeight());
__main.reverseTarget(fromtop);
__main.setTargetSpeed(delay);
__main.gotoTarget();
lockUI();
__last_forcedtop = 0;
__last_forcedbottom = 0;
setPrivateInt("winamp5", __myname+"ForcedBottom", 0);
setPrivateInt("winamp5", __myname+"ForcedTop", 0);
}
// -----------------------------------------------------------------------
openDrawer() {
if (__tempDisable.isRunning()) return;
__tempDisable.start();
int s = getStatus();
if (s == STATUS_PLAYING || s == STATUS_PAUSED) {
if (!isVideo()) {
if (__vis_detach_attrib.getData() == "0") {
openDrawerForVis();
} else if (__video_detach_attrib.getData() == "0") {
openDrawerForVideo();
} else {
openDrawerForNothing();
}
} else {
if (__video_detach_attrib.getData() == "0") {
openDrawerForVideo();
} else if (__vis_detach_attrib.getData() == "0") {
openDrawerForVis();
} else {
openDrawerForNothing();
}
}
} else {
int Window_Content=getPrivateInt("winamp5", __myname+"State", CONTENT_VIS);
if (window_content == CONTENT_VIS && __vis_detach_attrib.getData() == "0") {
openDrawerForVis();
} else if (window_content == CONTENT_VIDEO && __video_detach_attrib.getData() == "0") {
openDrawerForVideo();
} else if (__vis_detach_attrib.getData() == "0") {
openDrawerForVis();
} else if (__video_detach_attrib.getData() == "0") {
openDrawerForVideo();
} else {
openDrawerForNothing();
}
}
}
// -----------------------------------------------------------------------
closeDrawer() {
drawer_reduceWindow(1);
}
// -----------------------------------------------------------------------
System.onPlay() {
// needed to handle video auto fullscreen on play in drawer_showVideo()
WinampConfigGroup vidwcg = WinampConfig.getGroup(VIDEO_CONFIG_GROUP);
boolean auto_fs = vidwcg.getBool("auto_fs");
if (auto_fs && __video_detach_attrib.getData() == "0") __play_auto_fs_video = 1;
else __play_auto_fs_video = 0;
}
System.onTitleChange(String newtitle) {
// needed to handle video auto fullscreen on play in drawer_showVideo()
WinampConfigGroup vidwcg = WinampConfig.getGroup(VIDEO_CONFIG_GROUP);
boolean auto_fs = vidwcg.getBool("auto_fs");
if (auto_fs && __video_detach_attrib.getData() == "0") __play_auto_fs_video = 1;
else __play_auto_fs_video = 0;
}
// -----------------------------------------------------------------------
System.onPause() {
__play_auto_fs_video = 0;
}
// -----------------------------------------------------------------------
System.onResume() {
__play_auto_fs_video = 0;
}
// -----------------------------------------------------------------------
System.onStop() {
__play_auto_fs_video = 0;
}
// -----------------------------------------------------------------------
// The heart of the machine, here we detect when a window wants to open
// or close, and we decide what to do about it. When we return FALSE, the
// window performs what it notified us about. When we return TRUE, the
// showing/hiding of the window is cancelled, and it is now up to us to
// show or hide the window once we're done with our animations.
// To show the window ourselves, we later show a windowholder with the
// autoopen="1" param, and to hide the window, we simply hide the
// windowholder, and its autoclose="1" param will do the rest
// -----------------------------------------------------------------------
System.onGetCancelComponent(String guid, boolean goingvisible) {
#ifdef DEBUG
DebugString("+", 0);
#endif
// fix for when the UI sometimes is locked after switching video file in fullscreen
unlockUI();
// isVideo() hasn't been set yet in System.onPlay and System.onTitleChange, so we check it here instead.
if (__play_auto_fs_video && !isVideo()) __play_auto_fs_video = 0;
if (__bypasscancel) return FALSE;
if (guid == VIDEO_GUID && !goingvisible && __hiding_video) return FALSE;
if (guid == VIS_GUID && !goingvisible && __hiding_vis) return FALSE;
if (guid == VIDEO_GUID && goingvisible && __showing_video) return FALSE;
if (guid == VIS_GUID && goingvisible && __showing_vis) return FALSE;
#ifdef DEBUG
DebugString("--------------- onGetCancelComponent ----------------", 0);
DebugString(" GUID : " + guid, 0);
if (goingvisible) DebugString(" Going Visible", 0); else DebugString(" Going Invisible", 0);
DebugString(" Last Content : " + IntegerToString(getPrivateInt("winamp5", __myname+"State", CONTENT_VIS)), 0);
DebugString(" Drawer State : " + IntegerToString(getPrivateInt("winamp5", __myname+"OpenState", CLOSED)), 0);
DebugString("-----------------------------------------------------", 0);
#endif
if (!__main.isVisible()) return FALSE;
int Window_Content=getPrivateInt("winamp5", __myname+"State", CONTENT_VIS);
int window_status =getPrivateInt("winamp5", __myname+"OpenState", CLOSED);
if (window_status == CLOSED) {
if (guid == VIDEO_GUID) {
if (__video_detach_attrib.getData() == "0") {
if (goingvisible) {
openDrawerForVideo();
return TRUE;
}
}
}
if (guid == VIS_GUID) {
if (__vis_detach_attrib.getData() == "0") {
if (goingvisible) {
openDrawerForVis();
return TRUE;
}
}
}
} else if (window_status == OPEN) {
if (goingvisible) {
if (guid == VIDEO_GUID && window_content == CONTENT_VIS) {
if (__video_detach_attrib.getData() == "0") {
window_content = CONTENT_VIDEO;
drawer_hideVis();
drawer_dc_showVideo();
return TRUE;
}
} else if (guid == VIS_GUID && window_content == CONTENT_VIDEO) {
if (__vis_detach_attrib.getData() == "0") {
window_content = CONTENT_VIS;
drawer_disablePSOVC();
drawer_hideVideo();
drawer_dc_showVis();
return TRUE;
}
}
}
}
if (!goingvisible && window_status == OPEN) {
#ifdef DEBUG
DebugString("closing " + guid, 0);
#endif
if (guid == VIDEO_GUID && window_content == CONTENT_VIDEO) {
drawer_hideVideo();
drawer_reduceWindow(1);
return FALSE;
}
if (guid == VIS_GUID && window_content == CONTENT_VIS) {
drawer_hideVis();
if ((getStatus() == STATUS_PLAYING ||
getStatus() == STATUS_PAUSED) &&
isVideo() &&
__video_detach_attrib.getData() == "0") {
drawer_dc_showVideo();
} else {
drawer_reduceWindow(1);
}
return FALSE;
}
}
#ifdef DEBUG
DebugString("Went thru", 0);
#endif
return FALSE;
}
// -----------------------------------------------------------------------
drawer_showVis() {
#ifdef DEBUG
DebugString("drawer_showVis",0 );
#endif
__showing_vis = 1;
setPrivateInt("winamp5", __myname+"OpenState", OPEN);
setPrivateInt("winamp5", __myname+"State", CONTENT_VIS);
GuiObject o = getVisWindowHolder();
if (o != NULL) { __bypasscancel = 1; o.show(); __bypasscancel = 0; }
#ifdef DEBUG
else DebugString("vis object not provided (show)", 0);
#endif
onShowVis();
__showing_vis = 0;
}
// -----------------------------------------------------------------------
drawer_hideVis() {
__callback_vis_show = 0;
#ifdef DEBUG
DebugString("drawer_hideVis",0 );
#endif
__hiding_vis = 1;
GuiObject o = getVisWindowHolder();
if (o != NULL) { __bypasscancel = 1; o.hide(); __bypasscancel = 0; }
#ifdef DEBUG
else DebugString("video object not found (hide)", 0);
#endif
onHideVis();
__hiding_vis = 0;
}
// -----------------------------------------------------------------------
drawer_showVideo() {
#ifdef DEBUG
DebugString("drawer_showVideo",0 );
#endif
__showing_video = 1;
setPrivateInt("winamp5", __myname+"OpenState", OPEN);
setPrivateInt("winamp5", __myname+"State", CONTENT_VIDEO);
GuiObject o = getVideoWindowHolder();
if (o != NULL) {
__bypasscancel = 1;
// hack to fix bug for auto fullscreen on play
if (__play_auto_fs_video) setVideoFullscreen(FALSE);
o.show();
// hack to fix bug for auto fullscreen on play
if (__play_auto_fs_video) setVideoFullscreen(TRUE);
__bypasscancel = 0;
}
#ifdef DEBUG
else DebugString("vis object not found (show)", 0);
#endif
onShowVideo();
__play_auto_fs_video = 0;
__showing_video = 0;
}
// -----------------------------------------------------------------------
drawer_hideVideo() {
__callback_video_show = 0;
#ifdef DEBUG
DebugString("drawer_hideVideo",0 );
#endif
__hiding_video = 1;
GuiObject o = getVideoWindowHolder();
if (o != NULL) { __bypasscancel = 1; o.hide(); __bypasscancel = 0; }
#ifdef DEBUG
else DebugString("video object not found (hide)", 0);
#endif
onHideVideo();
__hiding_video = 0;
}
// -----------------------------------------------------------------------
__callbackTimer.onTimer() {
stop();
int cvds = __callback_video_show;
int cvss = __callback_vis_show;
int cvdh = __callback_video_hide;
int cvsh = __callback_vis_hide;
__callback_video_show = 0;
__callback_vis_show = 0;
__callback_video_hide = 0;
__callback_vis_hide = 0;
if (cvds == 1) drawer_showVideo();
if (cvss == 1) drawer_showVis();
if (cvsh == 1) drawer_hideVis();
if (cvdh == 1) drawer_hideVideo();
}
// -----------------------------------------------------------------------
drawer_dc_showVideo() {
__callback_video_show = 1;
__callback_video_hide = 0;
__callbackTimer.start();
}
// -----------------------------------------------------------------------
drawer_dc_showVis() {
__callback_vis_show = 1;
__callback_vis_hide = 0;
__callbackTimer.start();
}
// -----------------------------------------------------------------------
drawer_dc_hideVideo() {
__callback_video_show = 0;
__callback_video_hide = 1;
__callbackTimer.start();
}
// -----------------------------------------------------------------------
drawer_dc_hideVis() {
__callback_vis_show = 0;
__callback_vis_hide = 1;
__callbackTimer.start();
}
// -----------------------------------------------------------------------
drawer_showWindowContent() {
int lastWindowContent=getPrivateInt("winamp5", __myname+"State", 2);
#ifdef DEBUG
DebugString("drawer_showWindowContent = " + IntegerToString(lastWindowContent), 0);
#endif
if (lastWindowContent==CONTENT_VIDEO) drawer_dc_showVideo();
if (lastWindowContent==CONTENT_VIS) drawer_dc_showVis();
}
// -----------------------------------------------------------------------
drawer_hideWindowContent() {
int lastWindowContent=getPrivateInt("winamp5", __myname+"State", 2);
#ifdef DEBUG
DebugString("drawer_hideWindowContent = " + IntegerToString(lastWindowContent), 0);
#endif
/*if (lastWindowContent==CONTENT_VIDEO)*/ drawer_hideVideo();
/*if (lastWindowContent==CONTENT_VIS)*/ drawer_hideVis();
}
// -----------------------------------------------------------------------
OpenDrawerForVideo() {
setPrivateInt("winamp5", __myname+"State", CONTENT_VIDEO);
drawer_expandWindow(1);
}
// -----------------------------------------------------------------------
OpenDrawerForVis() {
setPrivateInt("winamp5", __myname+"State", CONTENT_VIS);
drawer_expandWindow(1);
}
// -----------------------------------------------------------------------
OpenDrawerForNothing() {
setPrivateInt("winamp5", __myname+"State", CONTENT_NOTHING);
drawer_expandWindow(1);
}
// -----------------------------------------------------------------------
__main.onResize(int x, int y, int w, int h) {
if (!isGoingToTarget() && !__isinited) {
__isinited = 1;
if (h > getDrawerClosedHeight()) { setPrivateInt("winamp5", __myname+"OpenState", OPEN); drawer_expandWindow(0); }
else setPrivateInt("winamp5", __myname+"OpenState", CLOSED);
}
}
// -----------------------------------------------------------------------
__main.onUserResize(int x, int y, int w, int h) {
int window_status=getPrivateInt("winamp5", __myname+"OpenState", CLOSED);
if (window_status == OPEN) {
int h = getHeight();
if (h != getDrawerClosedHeight()) {
#ifdef DEBUG
DebugString("h = "+integerTostring(h), 0);
#endif
if (!__maximized)
setPrivateInt("winamp5", __myname+"Height", h);
}
} else if (window_status == CLOSED) {
int h = getDrawerOpenAutoHeight(w);
if (h != -1) {
setPrivateInt("winamp5", __myname+"Height", h);
}
}
if (__maximized) {
__maximized = 0;
setPrivateInt("winamp5", __myname+"Maximized", 0);
onCancelMaximize();
}
}
// -----------------------------------------------------------------------
switchToVideo() {
if (__callbackTimer.isRunning()) return;
if (__callbackTimer2.isRunning()) return;
if (__tempDisable.isRunning()) return;
__tempDisable.start();
drawer_hideVis();
drawer_showVideo();
}
// -----------------------------------------------------------------------
switchToVis() {
if (__callbackTimer.isRunning()) return;
if (__callbackTimer2.isRunning()) return;
if (__tempDisable.isRunning()) return;
__tempDisable.start();
drawer_disablePSOVC();
drawer_hideVideo();
drawer_showVis();
}
// -----------------------------------------------------------------------
__tempDisable.onTimer() {
stop();
}
// -----------------------------------------------------------------------
detachVis() {
if (__tempDisable.isRunning()) return;
__tempDisable.start();
__vis_detach_attrib.setData("1");
}
// -----------------------------------------------------------------------
detachVideo() {
if (__tempDisable.isRunning()) return;
__tempDisable.start();
__video_detach_attrib.setData("1");
}
// -----------------------------------------------------------------------
attachVis() {
if (__tempDisable.isRunning()) return;
__tempDisable.start();
__vis_detach_attrib.setData("0");
}
// -----------------------------------------------------------------------
attachVideo() {
if (__tempDisable.isRunning()) return;
__tempDisable.start();
__video_detach_attrib.setData("0");
}
// -----------------------------------------------------------------------
__video_detach_attrib.onDataChanged() {
#ifdef DEBUG
DebugString("detach video changed", 0);
#endif
if (getData() == "1") {
drawer_doDetachVideo();
onDetachVideo();
} else {
if (getData() == "0") {
drawer_doAttachVideo();
onAttachVideo();
}
}
}
// -----------------------------------------------------------------------
__vis_detach_attrib.onDataChanged() {
#ifdef DEBUG
DebugString("detach vis changed", 0);
#endif
if (getData() == "1") {
drawer_doDetachVis();
onDetachVis();
} else {
if (getData() == "0") {
drawer_doAttachVis();
onAttachVis();
}
}
}
// -----------------------------------------------------------------------
drawer_doDetachVideo() {
int wasvisible = isNamedWindowVisible(VIDEO_GUID);
int lastWindowContent=getPrivateInt("winamp5", __myname+"State", 2);
int window_status =getPrivateInt("winamp5", __myname+"OpenState", CLOSED);
if (!wasvisible) return;
if (lastWindowContent != CONTENT_VIDEO) return;
if (window_status == OPEN) {
drawer_disablePSOVC();
drawer_reduceWindow(1);
}
drawer_dc_linkup_showVideo();
}
// -----------------------------------------------------------------------
drawer_doDetachVis() {
int lastWindowContent=getPrivateInt("winamp5", __myname+"State", 2);
int window_status =getPrivateInt("winamp5", __myname+"OpenState", CLOSED);
if (lastWindowContent != CONTENT_VIS) return;
int wasvisible = isNamedWindowVisible(VIS_GUID);
if (!wasvisible) return;
if (window_status == OPEN) {
drawer_hideVis();
if ((getStatus() == STATUS_PLAYING ||
getStatus() == STATUS_PAUSED) && isVideo() &&
__video_detach_attrib.getData() == "0") {
setPrivateInt("winamp5", __myname+"State", CONTENT_VIDEO);
drawer_dc_showVideo();
} else {
drawer_reduceWindow(1);
}
}
drawer_dc_linkup_showVis();
}
// -----------------------------------------------------------------------
drawer_doAttachVideo() {
drawer_disablePSOVC();
int wasvisible = isNamedWindowVisible(VIDEO_GUID);
if (wasvisible) {
hideNamedWindow(VIDEO_GUID);
int window_status =getPrivateInt("winamp5", __myname+"OpenState", CLOSED);
int window_content=getPrivateInt("winamp5", __myname+"State", 2);
if (window_content == CONTENT_VIS) drawer_hideVis();
if (window_status == CLOSED) openDrawerForVideo();
else drawer_dc_showVideo();
}
}
// -----------------------------------------------------------------------
drawer_doAttachVis() {
drawer_disablePSOVC();
int wasvisible = isNamedWindowVisible(VIS_GUID);
if (wasvisible) {
hideNamedWindow(VIS_GUID);
int window_status =getPrivateInt("winamp5", __myname+"OpenState", CLOSED);
int window_content=getPrivateInt("winamp5", __myname+"State", 2);
if (window_content == CONTENT_VIDEO) drawer_hideVideo();
if (window_status == CLOSED) openDrawerForVis();
else drawer_dc_showVis();
}
}
// -----------------------------------------------------------------------
__callbackTimer2.onTimer() {
stop();
if (__callback2_what == DETACHED_VIDEO) drawer_linkup_showVideo();
if (__callback2_what == DETACHED_VIS) drawer_linkup_showVis();
}
// -----------------------------------------------------------------------
drawer_dc_linkup_showVis() {
__callback2_what = DETACHED_VIS;
__callbackTimer2.start();
}
// -----------------------------------------------------------------------
drawer_dc_linkup_showVideo() {
__callback2_what = DETACHED_VIDEO;
__callbackTimer2.start();
}
// -----------------------------------------------------------------------
drawer_linkup_showVis() {
#ifdef DEBUG
DebugString("show detached vis",0 );
#endif
showWindow(VIS_GUID, "", 0);
}
// -----------------------------------------------------------------------
drawer_linkup_showVideo() {
#ifdef DEBUG
DebugString("show detached video",0 );
#endif
showWindow(VIDEO_GUID, "", 0);
drawer_enablePSOVC();
}
// -----------------------------------------------------------------------
drawer_disablePSOVC() {
#ifdef DEBUG
DebugString("disabling stop on video close",0 );
#endif
ConfigItem item = Config.getItem(SKINTWEAKS_CFGPAGE);
if (item) {
ConfigAttribute attr = item.getAttribute("Prevent video playback Stop on video window Close");
if (attr) attr.setData("1");
}
__PSOVCTimer.start();
}
// -----------------------------------------------------------------------
drawer_enablePSOVC() {
#ifdef DEBUG
DebugString("enabling stop on video close",0 );
#endif
__PSOVCTimer.stop();
ConfigItem item = Config.getItem(SKINTWEAKS_CFGPAGE);
if (item) {
ConfigAttribute attr = item.getAttribute("Prevent video playback Stop on video window Close");
if (attr) attr.setData("0");
}
}
// -----------------------------------------------------------------------
__PSOVCTimer.onTimer() {
drawer_enablePSOVC();
}
// -----------------------------------------------------------------------
__maincontainer.onBeforeSwitchToLayout(Layout oldl, Layout newl) {
int window_status =getPrivateInt("winamp5", __myname+"OpenState", CLOSED);
int window_content=getPrivateInt("winamp5", __myname+"State", 2);
if (oldl == __main && window_status == OPEN && window_content == CONTENT_VIDEO && getStatus() == STATUS_PLAYING && isVideo()) {
drawer_disablePSOVC();
__windowshade_openvid = 1;
}
if (oldl == __main && window_status == OPEN && window_content == CONTENT_VIS) {
__windowshade_openvis = 1;
}
}
// -----------------------------------------------------------------------
__maincontainer.onSwitchToLayout(Layout newl) {
// these do not call drawer_doDetachVis or drawer_doDetachVideo but showDetachVis and showDetachVideo so that the change is temporary
if (__windowshade_openvid) {
__windowshade_openvid = 0;
drawer_linkup_showVideo();
}
if (__windowshade_openvis) {
__windowshade_openvis = 0;
drawer_linkup_showVis();
}
}
// -----------------------------------------------------------------------
Int getDrawerState() {
return getPrivateInt("winamp5", __myname+"OpenState", CLOSED);
}
// -----------------------------------------------------------------------
Int getDrawerContent() {
return getPrivateInt("winamp5", __myname+"State", CONTENT_VIS);
}
// -----------------------------------------------------------------------
maximizeWindow() {
__oldx=__main.getGuiX();
__oldy=__main.getGuiY();
__oldw=__main.getGuiW();
__oldh=__main.getGuiH();
setPrivateInt("winamp5", __myname+"ox", __oldx);
setPrivateInt("winamp5", __myname+"oy", __oldy);
setPrivateInt("winamp5", __myname+"ow", __oldw);
setPrivateInt("winamp5", __myname+"oh", __oldh);
drawer_doMaximizeWindow(1);
}
// -----------------------------------------------------------------------
drawer_doMaximizeWindow(int notif) {
int vx=getViewportLeft();
int vy=getViewportTop();
int vw=getViewportWidth();
int vh=getViewportHeight();
if (notif) onBeforeMaximize();
__maximized = 1;
setPrivateInt("winamp5", __myname+"Maximized", 1);
__main.resize(vx, vy, vw, vh+__main.getSnapAdjustBottom());
if (notif) onAfterMaximize();
}
// -----------------------------------------------------------------------
__main.onSnapAdjustChanged() {
if (__maximized)
drawer_doMaximizeWindow(0);
}
// -----------------------------------------------------------------------
restoreWindow() {
onBeforeRestore();
__maximized = 0;
setPrivateInt("winamp5", __myname+"Maximized", 0);
__main.resize(__oldx, __oldy, __oldw, __oldh);
onAfterRestore();
}
// -----------------------------------------------------------------------
// default events implementations - override them in your script
// -----------------------------------------------------------------------
onBeforeOpeningDrawer() {}
onBeforeClosingDrawer() {}
onDoneOpeningDrawer() {}
onDoneClosingDrawer() {}
onShowVis() {}
onHideVis() {}
onShowVideo() {}
onHideVideo() {}
onAttachVideo() {}
onDetachVideo() {}
onAttachVis() {}
onDetachVis() {}
onBeforeMaximize() {}
onBeforeRestore() {}
onAfterMaximize() {}
onAfterRestore() {}
onCancelMaximize() {}