1060 lines
35 KiB
Objective-C
1060 lines
35 KiB
Objective-C
// -----------------------------------------------------------------------
|
|
// 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() {}
|