diff options
Diffstat (limited to 'Src/Plugins/General/gen_ff/main.cpp')
| -rw-r--r-- | Src/Plugins/General/gen_ff/main.cpp | 3527 |
1 files changed, 3527 insertions, 0 deletions
diff --git a/Src/Plugins/General/gen_ff/main.cpp b/Src/Plugins/General/gen_ff/main.cpp new file mode 100644 index 00000000..728d99a4 --- /dev/null +++ b/Src/Plugins/General/gen_ff/main.cpp @@ -0,0 +1,3527 @@ +#include "precomp__gen_ff.h" +#include <windows.h> +#include <commctrl.h> + +#include "main.h" +#include "resource.h" +#include "prefs.h" +#include "wa2frontend.h" +#include "wa2groupdefs.h" +#include "wa2wndembed.h" +#include "wa2cfgitems.h" +#include "wa2coreactions.h" +#include "wa2pledit.h" +#include "embedwndguid.h" +#include "gen_ff_ipc.h" +#include "fsmonitor.h" +#include <api/wnd/wndclass/foreignwnd.h> +#include "../winamp/wa_ipc.h" +#include "../gen_hotkeys/wa_hotkeys.h" +#include <api/script/objects/c_script/c_group.h> +#include <api/script/objects/c_script/c_text.h> + +#include <api/apiinit.h> +#include <api/wnd/rootwnd.h> +#include <api/script/objects/guiobject.h> +#include <api/core/coreactions.h> +#include "menuactions.h" +#include <api/wnd/wndclass/oswndhost.h> +#include <api/script/scriptobj.h> +#include <api/service/svcs/svc_wndcreate.h> +#include <bfc/reentryfilter.h> +#include <api/skin/skinparse.h> +#include <api/wndmgr/skinembed.h> +#include <api/skin/widgets/xuiwndholder.h> +#include <api/skin/widgets/text.h> +#include <api/script/scriptmgr.h> +#include <api/wac/compon.h> +#include <api/application/version.h> +#include <bfc/parse/pathparse.h> +#include <tataki/blending/blending.h> +#include "skininfo.h" +#include <api/skin/guitree.h> + +#include <bfc/wasabi_std_wnd.h> + +#include "wa2core.h" +#include <api/locales/xlatstr.h> + +#include <api/wndmgr/gc.h> +#include <api/syscb/callbacks/gccb.h> +#include <api/script/vcpu.h> +#include <tataki/canvas/bltcanvas.h> + +#include "../nu/AutoWide.h" +#include <shlwapi.h> +#include <windowsx.h> +//wtf? +#define _WAFE_H_ +#define ___HOTAMP3_H___ +#include "../gen_hotkeys/hotkey.h" + +int embedCreateProc(embedWindowState *p, embedEnumStruct *parms); + +DECLARE_MODULE_SVCMGR; + +#define VERSION L"1.55" +//#define VIDDEBUG +//#define DEBUG_CAPTURES + +#include "../gen_ml/ml_ipc.h" +librarySendToMenuStruct mainSendTo; + +#include "../Agave/Language/api_language.h" +// wasabi based services for localisation support +api_language *WASABI_API_LNG = 0; +HINSTANCE WASABI_API_LNG_HINST = 0, WASABI_API_ORIG_HINST; +static wchar_t szDescription[256]; + +//----------------------------------------------------------------------------------------------- +#define GET_X_LPARAM(lp) ((int)(short)LOWORD(lp)) +#define GET_Y_LPARAM(lp) ((int)(short)HIWORD(lp)) + +#define ID_FILE_SHOWLIBRARY 40379 +#define WINAMP_OPTIONS_PREFS 40012 +#define WINAMP_HELP_ABOUT 40041 +#define WINAMP_LIGHTNING_CLICK 40339 +#define WINAMP +#define UPDATE_EGG 0xC0DE+2 +#define VIEWPORT 0xC0DE+3 +static int DEFERREDCALLBACKMSG; +static int UPDATEDIALOGBOXPARENTMSG; + +//----------------------------------------------------------------------------------------------- +void config(); +void quit(); +int init(); +void quit_inst(); +void init_inst(); +void ToggleLayout(const wchar_t *containerName); +void RestoreClassicWinamp(int was_loaded); +extern "C" winampGeneralPurposePlugin plugin = +{ + GPPHDR_VER_U, + "nullsoft(gen_ff.dll)", + init, + config, + quit, +}; + +//----------------------------------------------------------------------------------------------- + +int wantContainerInMenu(Container *cont) +{ + wchar_t tmpBuf[96] = {0}; + GUID g = cont->getGUID(); + if (WCSCASEEQLSAFE(cont->getId(), L"main")) return 0; + if (cont->getNoMenu()) return 0; + if (g == pleditWndGuid) return 0; + if (g == videoWndGuid) return 0; + if (g == avs_guid) return 0; + if (g == library_guid) return 0; + if (WCSCASEEQLSAFE(cont->getName(), L":componenttitle")) return 0; + if (WCSCASEEQLSAFE(cont->getName(), L"Playlist Editor") || WCSCASEEQLSAFE(cont->getName(), L"Playlist") || WCSCASEEQLSAFE(cont->getId(), L"pledit")) return 0; + if (WCSCASEEQLSAFE(cont->getName(), L"Video Window") || WCSCASEEQLSAFE(cont->getName(), L"Video") || WCSCASEEQLSAFE(cont->getId(), L"Video")) return 0; + if (WCSCASEEQLSAFE(cont->getName(), WASABI_API_LNG->GetStringFromGUIDW(GenMlLangGUID,plugin.hDllInstance,18)) || + WCSCASEEQLSAFE(cont->getName(), L"Media Library") || + WCSCASEEQLSAFE(cont->getId(), L"Library") || + WCSCASEEQLSAFE(cont->getName(),WASABI_API_LNGSTRINGW_BUF(IDS_MEDIA_LIBRARY,tmpBuf,96))) return 0; + if (WCSCASEEQLSAFE(cont->getName(), L"AVS") || WCSCASEEQLSAFE(cont->getName(), WASABI_API_LNGSTRINGW(IDS_VISUALIZATIONS)) || WCSCASEEQLSAFE(cont->getName(), L"Vis") || WCSCASEEQLSAFE(cont->getId(), L"Avs") || WCSCASEEQLSAFE(cont->getId(), L"Vis")) return 0; + return 1; +} + + +//----------------------------------------------------------------------------------------------- + +api_playlists *AGAVE_API_PLAYLISTS = 0; +api_playlistmanager *AGAVE_API_PLAYLISTMANAGER = 0; +api_albumart *AGAVE_API_ALBUMART = 0; +api_downloadManager *WAC_API_DOWNLOADMANAGER = 0; +api_colorthemes *WASABI_API_COLORTHEMES = 0; +api_palette *WASABI_API_PALETTE = 0; +api_threadpool *WASABI_API_THREADPOOL = 0; + +StringW m_lastskin_nam, m_lastskin_dir; + +inline int lumidiff(int a, int b) { + int r1 = (a & 0xFF0000) >> 16; + int r2 = (b & 0xFF0000) >> 16; + int g1 = (a & 0xFF00) >> 8; + int g2 = (b & 0xFF00) >> 8; + int b1 = a & 0xFF; + int b2 = b & 0xFF; + return MIN((ABS(r1 - r2), ABS(g1 - g2)), ABS(b1 - b2)); +} + +static void doplaylistcolors() +{ + int interpolate = 0; + if (SkinParser::getSkinVersion()*10 < 10) interpolate = 1; + + // update colors + int buf[6] = {0}; + waSetPlColorsStruct s = {0, }; + extern COLORREF getWindowBackground(COLORREF *); + COLORREF windowbackground; + buf[5] = getWindowBackground(&windowbackground); // auto inverted + + int need_cols = 1, need_bms = 1; + + if (!m_lastskin_dir.isempty()) + { + StringPathCombine bitmapfilename(m_lastskin_dir, L"pledit.bmp"); + HANDLE h = CreateFileW(bitmapfilename, 0, 0, 0, OPEN_EXISTING, 0, 0); + if (h != INVALID_HANDLE_VALUE) + { + CloseHandle(h); + need_bms = 0; + } + + bitmapfilename = StringPathCombine(m_lastskin_dir, L"pledit.txt"); + h = CreateFileW(bitmapfilename, 0, 0, 0, OPEN_EXISTING, 0, 0); + if (h != INVALID_HANDLE_VALUE) + { + CloseHandle(h); + need_cols = 0; + } + } + + if (need_cols) + { + s.numElems = 6; + s.elems = buf; + + // list background + if (WASABI_API_SKIN->skin_getColorElementRef(L"wasabi.list.background")) + buf[2] = SkinColor(L"wasabi.list.background") & 0xFFFFFF; + else + buf[2] = RGBTOBGR(WASABI_API_SKIN->skin_getBitmapColor(L"wasabi.list.background")) & 0xFFFFFF; // inverted coz coming from bitmap + + // normal text + if (WASABI_API_SKIN->skin_getColorElementRef(L"wasabi.list.text")) + buf[0] = SkinColor(L"wasabi.list.text") & 0xFFFFFF; + else + buf[0] = SkinColor(L"wasabi.edit.text") & 0xFFFFFF; + + if (interpolate) + { + int c = buf[0]; + c = lumidiff(c, buf[2]) < 0x1F ? Blenders::BLEND_AVG(buf[0], 0xFF7F7F7F) : c; + c = lumidiff(c, buf[2]) < 0x1F ? Blenders::BLEND_AVG(buf[0], 0xFF101010) : c; + buf[0] = c & 0xFFFFFF; + } + + COLORREF selected; + + // selected items background + if (WASABI_API_SKIN->skin_getColorElementRef(L"wasabi.list.text.selected.background")) + { + selected = SkinColor(L"wasabi.list.text.selected.background"); + buf[3] = selected; + } + else + { + // inverted twice, see bellow + if (WASABI_API_SKIN->skin_getColorElementRef(L"wasabi.list.item.selected")) + selected = RGBTOBGR(SkinColor(L"wasabi.list.item.selected")); + else + selected = RGBTOBGR(SkinColor(SKINCOLOR_TREE_SELITEMBKG)); + + COLORREF col = RGBTOBGR(SkinColor(SKINCOLOR_LIST_COLUMNBKG)); + int a = MAX((col & 0xFF0000) >> 16, MAX((col & 0xFF00) >> 8, col & 0xFF)); + col = a < 0x1F ? Blenders::BLEND_AVG(windowbackground, 0xFF000000) : col; + int listbkg = RGBTOBGR(buf[2]); + selected = lumidiff(selected, listbkg) < 0x2F ? Blenders::BLEND_AVG(windowbackground, 0xFF7F7F7F) : selected; + selected = lumidiff(selected, listbkg) < 0x2F ? Blenders::BLEND_AVG(listbkg, 0xFF7F7F7F) : selected; + selected = lumidiff(selected, listbkg) < 0x2F ? Blenders::BLEND_AVG(windowbackground, 0xFFF0F0F0) : selected; + selected = lumidiff(selected, listbkg) < 0x2F ? Blenders::BLEND_AVG(listbkg, 0xFFF0F0F0) : selected; + selected = lumidiff(selected, listbkg) < 0x2F ? Blenders::BLEND_AVG(col, 0xFFF0F0F0) : selected; + selected = lumidiff(selected, listbkg) < 0x2F ? Blenders::BLEND_AVG(col, 0xFF101010) : selected; + selected = lumidiff(selected, RGBTOBGR(buf[0])) < 0x1F ? Blenders::BLEND_AVG(selected, 0xFF101010) : selected; + selected = lumidiff(selected, RGBTOBGR(buf[0])) < 0x1F ? Blenders::BLEND_AVG(selected, 0xFFF0F0F0) : selected; + selected &= 0xFFFFFF; + buf[3] = RGBTOBGR(selected); + } + + // active text + if (WASABI_API_SKIN->skin_getColorElementRef(L"wasabi.list.text.current")) + buf[1] = SkinColor(L"wasabi.list.text.current"); + else + { + COLORREF act = Blenders::BLEND_AVG(selected, buf[0]); + act = (lumidiff(act, buf[0]) < 0x3F || lumidiff(act, buf[2]) < 0x2F) ? Blenders::BLEND_AVG(buf[2], 0xFFFFFFFF) : act; + act = (lumidiff(act, buf[0]) < 0x3F || lumidiff(act, buf[2]) < 0x2F) ? Blenders::BLEND_AVG(buf[2], 0xFF101010) : act; + act = (lumidiff(act, buf[0]) < 0x3F || lumidiff(act, buf[2]) < 0x2F) ? Blenders::BLEND_AVG(selected, buf[0]) : act; + act = (lumidiff(act, buf[0]) < 0x3F || lumidiff(act, buf[2]) < 0x2F) ? Blenders::BLEND_AVG(selected, buf[2]) : act; + act = (lumidiff(act, buf[0]) < 0x3F || lumidiff(act, buf[2]) < 0x2F) ? Blenders::BLEND_AVG(buf[0], buf[2]) : act; + buf[1] = act & 0xFFFFFF; + } + } + + if (need_bms) + { + BltCanvas c(280, 186); + + c.fillBits(windowbackground); // already inverted + + void blitButtonToCanvas(int w, int h, int state, const wchar_t *overlayelement, int xpos, int ypos, BltCanvas *c); + + blitButtonToCanvas(8, 18, 0, L"wasabi.scrollbar.vertical.grip", 52, 53, &c); + blitButtonToCanvas(8, 18, 1, L"wasabi.scrollbar.vertical.grip", 61, 53, &c); + + int xpos, ypos; + //w=8,h=29 + int cols[2]; + int *fb = (int*)c.getBits() + 280 * 42; + + // inverted colors because going into bitmap + + if (WASABI_API_SKIN->skin_getColorElementRef(L"wasabi.scrollbar.background.inverted")) + cols[0] = RGBTOBGR(SkinColor(L"wasabi.scrollbar.background.inverted")); + else + { + if (WASABI_API_SKIN->skin_getColorElementRef(L"wasabi.list.column.empty")) + cols[0] = RGBTOBGR(SkinColor(L"wasabi.list.column.empty")); + else + { + COLORREF col = SkinColor(SKINCOLOR_LIST_COLUMNBKG); + int a = MAX((col & 0xFF0000) >> 16, MAX((col & 0xFF00) >> 8, col & 0xFF)); + col = a < 0x1F ? Blenders::BLEND_AVG(windowbackground, 0xFF000000) : col; + cols[0] = RGBTOBGR(Blenders::BLEND_AVG(col, 0xFF000000)); + } + } + + if (WASABI_API_SKIN->skin_getColorElementRef(L"wasabi.border.sunken")) + cols[1] = RGBTOBGR(SkinColor(L"wasabi.border.sunken")); + else + { + int a = MAX((windowbackground & 0xFF0000) >> 16, MAX((windowbackground & 0xFF00) >> 8, windowbackground & 0xFF)); + cols[1] = Blenders::BLEND_AVG(windowbackground, a > 0xE0 ? 0xFF000000 : 0xFFFFFFFF); + } + + for (ypos = 42;ypos < 42 + 29; ypos ++) + { + for (xpos = 36; xpos < 36 + 8; xpos ++) + { + fb[xpos] = cols[(xpos == 36 || xpos == 36 + 8 - 1)]; + } + fb += 280; + } + + extern HBITMAP CreateBitmapDIB(int w, int h, int planes, int bpp, void *data); + s.bm = CreateBitmapDIB(280, 186, 1, 32, c.getBits()); + } + if (s.bm || s.elems) SendMessageW(wa2.getMainWindow(), WM_WA_IPC, (WPARAM)&s, IPC_SETPLEDITCOLORS); +} + +static prefsDlgRecW ffPrefsItem; + +//----------------------------------------------------------------------------------------------- + +// a guid for our app : {4BE592C7-6937-426a-A388-ACF0EBC88E93} +static const GUID GEN_FREEFORM = + { 0x4be592c7, 0x6937, 0x426a, { 0xa3, 0x88, 0xac, 0xf0, 0xeb, 0xc8, 0x8e, 0x93 } }; + +Wa2Groupdefs *groups; +static WNDPROC wa_oldWndProc; + +Wa2CfgItems *cfgitems=0; + +HINSTANCE hInstance = NULL; +HWND last_dlg_parent = NULL; +void populateWindowsMenus(); +void unpopulateWindowsMenus(); +void addWindowOptionsToContextMenu(ifc_window *w); +void removeWindowOptionsFromContextMenu(); +void controlOpacity(int v); +void controlScaling(double v); +void customScaling(); +void customOpacity(); +void autoOpacifyHover(); +void autoOpacifyFocus(); +ifc_window *g_controlMenuTarget = NULL; +HMENU controlmenu = NULL; +void lockScaling(int lock); +int ffwindowsitempos = -1; +int ffoptionstop = -1; +int ffwoptionstop = -1; +int ffwindowstop = -1; +int ffwindowsitempos2 = -1; +int eqremoved = 0; +void removeEq(); +void restoreEq(); +int g_timedisplaymode = 0; +ifc_window *lastFocused = NULL; +int before_startup_callback = 0; +void loadExtraColorThemes(); +extern _int last_page; +int gothrueqmsg = 0; +void unhookOutputIPC(); +int we_have_ml = 0; +void checkMlPresent(); +char eggstr[9] = {0}; +int eggstat = 0; +int eggfallout = 0; +void initEgg(); +void toggleEgg(); +Layout *lastlayoutegg = NULL; +int disable_send_visrandom = 0; +void registerGlobalHotkeys(); +int processGenericHotkey(const char *hk); +const char *getSkinInfo(); +const wchar_t *getSkinInfoW(); +void controlAppBar(int side); +void controlAppBarAOT(); +void controlAppBarAH(); +void updateAppBarMenu(ifc_window *w); +void startFSMonitor(); +void stopFSMonitor(); +void onGoFullscreen(); +void onCancelFullscreen(); +FullScreenMonitor *g_fsmonitor = NULL; +class Wa5FSCallback : public FSCallback +{ +public: + virtual void onGoFullscreen() + { + ::onGoFullscreen(); + } + virtual void onCancelFullscreen() + { + ::onCancelFullscreen(); + } +}; +Wa5FSCallback *g_fscallback = NULL; +int getAOTTempDisable() +{ + return g_fsmonitor->isFullScreen(); +} + +LRESULT CallWinampWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) +{ + return CallWindowProcW(wa_oldWndProc, hwnd, msg, wParam, lParam); +} + +//----------------------------------------------------------------------------------------------- +BOOL WINAPI dll_main_raw_fn(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) +{ + hInstance = hinstDLL; + Wasabi::Std::Initialize(); + return TRUE; +} + +extern "C" +{ + void *_pRawDllMain = &dll_main_raw_fn; +}; + +__declspec(dllexport) BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) +{ + hInstance = hinstDLL; + return TRUE; +} + +//----------------------------------------------------------------------------------------------- +// core actions implement "play", "stop", etc. wndEmbedded embed wa2 windows into GUID-based wnds +//----------------------------------------------------------------------------------------------- +BEGIN_SERVICES(Winamp2_Svcs); +DECLARE_SERVICETSINGLE(svc_action, CoreActions); +DECLARE_SERVICETSINGLE(svc_action, MenuActions); +DECLARE_SERVICETSINGLE(svc_windowCreate, Wa2WndEmbed); +END_SERVICES(Winamp2_Svcs, _Winamp2_Svcs); + +//----------------------------------------------------------------------------------------------- +// functions called by the overriden windowproc to create and destroy wndembedders +//----------------------------------------------------------------------------------------------- +ifc_window *plWnd = NULL; +#ifdef MINIBROWSER_SUPPORT +ifc_window *mbWnd = NULL; +#endif +ifc_window *vidWnd = NULL; +TList<HWND> forcedoffwnds; + +int going_freeform = 0; +int going_fixedform = 0; + +wchar_t *INI_FILE = 0, *INI_DIR = 0; + +void ToggleLayout(const wchar_t *containerName) +{ + Container *c = SkinParser::getContainer(containerName); + if (c) + { + int numLayouts = c->getNumLayouts(); + + for (int i = 0;i < numLayouts;i++) + { + if (c->enumLayout(i) == c->getCurrentLayout()) + { + int nextLayout = (i + 1) % numLayouts; + Layout *layout = c->enumLayout(nextLayout); + c->switchToLayout(layout->getId()); + return ; + } + } + } +} + +int updatePl() +{ + // find out if this GUID is already shown. + WindowHolder *wh = skinEmbedder->getSuitableWindowHolder(pleditWndGuid, NULL, NULL, NULL, 1, -1, 0, 1, -1); + if (wh != NULL) + { + wh->cancelDeferredRemove(); + GuiObject *go = wh->getRootWndPtr()->getGuiObject(); + if (go) + { + Layout *l = go->guiobject_getParentLayout(); + if (l) + { + Container *c = l->getParentContainer(); + if (c) + { + DebugStringW(L"Container is %s\n", c->getId()); + SkinEmbedder::cancelDestroyContainer(c); + } + } + } + plWnd = wh->getRootWndPtr(); //->getDesktopParent(); + return 1; + } + return 0; +} + +int createPl() +{ + if (updatePl()) + { + ShowWindow(wa2.getWnd(IPC_GETWND_PE), SW_SHOWNA); + return 1; + } + ReentryFilter f(&wndMsgFilter, IPC_GETWND_PE); + if (f.mustLeave()) return 1; + plWnd = WASABI_API_WNDMGR->skinwnd_createByGuid(pleditWndGuid, L"resizable_status"); + if (plWnd != NULL) + { + plWnd->setVisible(1); + } + return plWnd != NULL; +} + +static ifc_window *updateEmb(GUID thisguid, embedWindowState *ws) +{ + WindowHolder *wh = skinEmbedder->getSuitableWindowHolder(thisguid, NULL, NULL, NULL, 1, -1, 0, 1, -1); + if (wh != NULL && !(ws->flags & EMBED_FLAGS_LEGACY_WND)) + { + ifc_window *p = wh->getRootWndPtr(); //->getDesktopParent(); + + // p->getGuiScriptObject()->vcpu_setInterface(embeddedWndStateGuid, ws, INTERFACE_GENERICVOIDPTR); + ws->extra_data[EMBED_STATE_EXTRA_FFROOTWND] = (intptr_t)p; + return p; + } + return 0; +} + +static ifc_window *createEmb(embedWindowState *ws, bool startHidden) +{ + GUID thisguid = EmbedWndGuid(ws).getGuid(); + if (thisguid == INVALID_GUID || (ws->flags & EMBED_FLAGS_LEGACY_WND)) + return 0; + + //thisguid.Data1 = (int)ws->me; + ifc_window *update = updateEmb(thisguid, ws); + if (update) + return update; + + ReentryFilter f(&wndMsgFilter, (intptr_t)ws); + if (f.mustLeave()) + return 0; + + RECT r; + if (!GetWindowRect(ws->me, &r)) + SetRectEmpty(&r); + + ifc_window *p = NULL; + if (ws->flags & EMBED_FLAGS_NORESIZE) + p = WASABI_API_WNDMGR->skinwnd_createByGuid(thisguid, L"static", 0, NULL, 0, startHidden, NULL); + else + p = WASABI_API_WNDMGR->skinwnd_createByGuid(thisguid, L"resizable_nostatus", 0, NULL, 0, startHidden, NULL); + + ws->extra_data[EMBED_STATE_EXTRA_FFROOTWND] = (intptr_t) p; + if (p != NULL) + { + // p->getGuiScriptObject()->vcpu_setInterface(embeddedWndStateGuid, ws, INTERFACE_GENERICVOIDPTR); + if (NULL != WASABI_API_APP) + WASABI_API_APP->app_unregisterGlobalWindow(p->getDesktopParent()->gethWnd()); + + if (!startHidden) + p->setVisible(1); + + GuiObject *go = p->getGuiObject(); + if (go) + { + Layout *l = go->guiobject_getParentLayout(); + if (l) + { + Container *c = l->getParentContainer(); + if (c) + { + if (ws->flags & EMBED_FLAGS_NOWINDOWMENU) + c->setXmlParam(L"nomenu", L"1"); + else + c->setXmlParam(L"nomenu", L"0"); + } + } + } + } + if (p == NULL) + { + RECT r; + GetWindowRect(ws->me, &r); + //////SetWindowPos( ws->me, NULL, r.left - 20000, r.top - 20000, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOREDRAW | SWP_NOSENDCHANGING | SWP_NOZORDER | SWP_NOCOPYBITS ); + SetWindowPos( ws->me, NULL, r.left, r.top, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOREDRAW | SWP_NOSENDCHANGING | SWP_NOZORDER | SWP_NOCOPYBITS ); + forcedoffwnds.addItem(ws->me); + //if (0 != (WS_VISIBLE & windowStyle)) + //RedrawWindow(GetDesktopWindow(), &r, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_UPDATENOW | RDW_NOERASE); + } + + RedrawWindow(GetDesktopWindow(), &r, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_UPDATENOW | RDW_NOERASE); + return p; +} + +#ifdef MINIBROWSER_SUPPORT +int updateMb() +{ + WindowHolder *wh = skinEmbedder->getSuitableWindowHolder(minibrowserWndGuid, NULL, NULL, NULL, 1, -1, 0, 1, -1); + if (wh != NULL) + { + mbWnd = wh->getRootWndPtr(); //->getDesktopParent(); + ShowWindow(wa2.getWnd(IPC_GETWND_MB), SW_SHOWNA); + return 1; + } + return 0; +} + +int createMb() +{ + // see cratePl() + if (updateMb()) return 1; + ReentryFilter f(&wndMsgFilter, IPC_GETWND_MB); + if (f.mustLeave()) return 1; + mbWnd = WASABI_API_WNDMGR->skinwnd_createByGuid(minibrowserWndGuid, "resizable_status"); + if (mbWnd != NULL) mbWnd->setVisible(1); + return mbWnd != NULL; +} +#endif + +static HWND oldVideoWnd; +static WNDPROC oldVideoWndProc; +static DWORD WINAPI newVideoWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + if (uMsg == WM_USER + 0x100 && wParam == 1 && lParam) + return 0; + + return CallWindowProc(oldVideoWndProc, hwnd, uMsg, wParam, lParam); +} + +int updateVid() +{ + WindowHolder *wh = skinEmbedder->getSuitableWindowHolder(videoWndGuid, NULL, NULL, NULL, 1, -1, 0, 1, -1); + if (wh != NULL) + { +#ifdef VIDDEBUG + DebugString("Video : Host already exists and window already shown in it\n"); +#endif + wh->cancelDeferredRemove(); + GuiObject *go = wh->getRootWndPtr()->getGuiObject(); + if (go) + { + Layout *l = go->guiobject_getParentLayout(); + if (l) + { + Container *c = l->getParentContainer(); + if (c) + { + DebugStringW(L"Container is %s\n", c->getId()); + SkinEmbedder::cancelDestroyContainer(c); + } + } + } + vidWnd = wh->getRootWndPtr(); //->getDesktopParent(); + return 1; + } + return 0; +} + +int createVid() +{ + ShowWindow(WASABI_API_WND->main_getRootWnd()->gethWnd(), SW_RESTORE); + SetForegroundWindow(WASABI_API_WND->main_getRootWnd()->gethWnd()); + + if (updateVid()) + { + ShowWindow(wa2.getWnd(IPC_GETWND_VIDEO), SW_SHOWNA); + return 1; + } + + if (vidWnd == NULL) + { + ReentryFilter f(&wndMsgFilter, IPC_GETWND_VIDEO); + if (f.mustLeave()) return 1; +#ifdef VIDDEBUG + DebugString("Video : Trying to find a host or creating it if needed\n"); +#endif + vidWnd = WASABI_API_WNDMGR->skinwnd_createByGuid(videoWndGuid, L"resizable_status"); + } + + if (vidWnd != NULL) + { + vidWnd->setVisible(1); + } + return vidWnd != NULL; +} + +int destroyPl(HWND hwndDlg, int uMsg, WPARAM wParam, LPARAM lParam) +{ + ReentryFilter f(&wndMsgFilter, IPC_GETWND_PE); + int r = CallWinampWndProc(hwndDlg, uMsg, wParam, lParam); + if (f.mustLeave()) return r; + if (plWnd != NULL && WASABI_API_WND->rootwndIsValid(plWnd)) + { + WASABI_API_WNDMGR->skinwnd_destroy(plWnd); + r = !WASABI_API_WND->rootwndIsValid(plWnd); + } + else + r = !SOM::checkAbortShowHideWindow(pleditWndGuid, 0); + if (r) + plWnd = NULL; + return r; +} + +int destroyEmb(HWND hwndDlg, int uMsg, WPARAM wParam, LPARAM lParam, embedWindowState *ws) +{ + ReentryFilter f(&wndMsgFilter, (intptr_t)ws); + int r = CallWinampWndProc(hwndDlg, uMsg, wParam, lParam); + if (f.mustLeave() || (ws->flags & EMBED_FLAGS_LEGACY_WND)) return r; + if (ws->extra_data[EMBED_STATE_EXTRA_FFROOTWND] == NULL) return r; + if (ws->extra_data[EMBED_STATE_EXTRA_REPARENTING] == 1) return r; + ifc_window *w = (ifc_window*)ws->extra_data[EMBED_STATE_EXTRA_FFROOTWND]; +#if 1 + if (WASABI_API_WND->rootwndIsValid(w)) + { + WASABI_API_WNDMGR->skinwnd_destroy(w); + r = !WASABI_API_WND->rootwndIsValid(w); + } + else + { + r = !SOM::checkAbortShowHideWindow(embedWndGuidMgr.getGuid(ws), 0); + } + if (r) + ws->extra_data[EMBED_STATE_EXTRA_FFROOTWND] = NULL; +#else + if (WASABI_API_WND->rootwndIsValid(w)) WASABI_API_WNDMGR->skinwnd_destroy(w); + else SOM::checkAbortShowHideWindow(embedWndGuidMgr.getGuid(ws), 0); + ws->extra_data[EMBED_STATE_EXTRA_FFROOTWND] = NULL; +#endif + return r; +} + +#ifdef MINIBROWSER_SUPPORT +int destroyMb(HWND hwndDlg, int uMsg, WPARAM wParam, LPARAM lParam) +{ + ReentryFilter f(&wndMsgFilter, IPC_GETWND_MB); + int r = CallWinampWndProc(hwndDlg, uMsg, wParam, lParam); + if (f.mustLeave()) return r; + + if (mbWnd != NULL && WASABI_API_WND->rootwndIsValid(mbWnd)) WASABI_API_WNDMGR->skinwnd_destroy(mbWnd); + else SOM::checkAbortShowHideWindow(minibrowserWndGuid, 0); + mbWnd = NULL; + return r; +} +#endif + +int destroyVid(HWND hwndDlg, int uMsg, WPARAM wParam, LPARAM lParam) +{ + ReentryFilter f(&wndMsgFilter, IPC_GETWND_VIDEO); + int r = CallWinampWndProc(hwndDlg, uMsg, wParam, lParam); + + if (f.mustLeave()) return r; + + if (vidWnd != NULL && WASABI_API_WND->rootwndIsValid(vidWnd)) + { + WASABI_API_WNDMGR->skinwnd_destroy(vidWnd); + r = !WASABI_API_WND->rootwndIsValid(vidWnd); + } + else + r = !SOM::checkAbortShowHideWindow(videoWndGuid, 0); + + if (r) + vidWnd = NULL; + + return r; +} + + +int m_loading_at_startup; +int m_are_we_loaded; + +#define WINAMP_REFRESHSKIN 40291 +#define WINAMP_OPTIONS_EQ 40036 +#define WINAMP_OPTIONS_DSIZE 40165 +#define WINAMP_OPTIONS_ELAPSED 40037 +#define WINAMP_OPTIONS_REMAINING 40038 + +//----------------------------------------------------------------------------------------------- +class MainLayoutMonitor : public H_Layout +{ + public: + MainLayoutMonitor(HWND _w, ScriptObject *o) : H_Layout(o) { hwnd= _w; } + void hook_onResize(int x, int y, int w, int h); + HWND hwnd; +}; + +void MainLayoutMonitor::hook_onResize(int x, int y, int w, int h) +{ + PostMessage(wa2.getMainWindow(), WM_WA_IPC, (WPARAM)hwnd, UPDATEDIALOGBOXPARENTMSG); +} + +//----------------------------------------------------------------------------------------------- +// must be called after switching to a new freeform skin +// should also be called when the main container changes its visible layout +//----------------------------------------------------------------------------------------------- +Layout *GetMainLayout() +{ + Container *container = SkinParser::getContainer(L"main"); + if (container != NULL) + { + return container->getCurrentLayout(); + } + return 0; +} + +HWND GetMainContainerHWND() +{ + Layout *l = GetMainLayout(); + if (l != NULL) + return l->gethWnd(); + + return 0; +} +static MainLayoutMonitor *mainLayoutMonitor = 0; +void setDialogBoxesParent() +{ + Layout *l = GetMainLayout(); + if (l != NULL) + { + HWND hwnd = l->gethWnd(); + delete mainLayoutMonitor; + mainLayoutMonitor = new MainLayoutMonitor(hwnd, l->getScriptObject()); + wa2.setDialogBoxParent(hwnd); + PostMessage(wa2.getMainWindow(), WM_WA_IPC, (WPARAM)hwnd, UPDATEDIALOGBOXPARENTMSG); + lastFocused = l; + } +} + +static void removeSkinExtension(StringW &skinname) +{ + int x = skinname.len() - 4; + if (x > 0) + { + const wchar_t *p = ((const wchar_t *)skinname) + x; + if (!_wcsicmp(p, L".zip") || !_wcsicmp(p, L".wal") || !_wcsicmp(p, L".wsz")) + skinname.trunc(x); + } +} + +extern HWND subWnd, tabwnd; +extern int subWndId; +extern int toggle_from_wa2; +int switching_skin = 0; +void shutdownFFApi(); + + +/*----------------------------------------------------------------------------------------------- +* Winamp2 message processor +*/ + +static void RerouteMessage(MSG *pMsg, ifc_window *wnd) +{ + if (NULL == wnd) + return; + + HWND hReroute = NULL; + if (pMsg->hwnd == GetMainContainerHWND()) + { + hReroute = WASABI_API_WND->main_getRootWnd()->gethWnd(); + if (NULL != hReroute) + { + pMsg->hwnd = hReroute; + } + return; + } + if (wnd->gethWnd() != pMsg->hwnd) + return; + + ifc_window *parent = wnd->getRootParent(); + if (NULL == parent) + return; + + Layout *l = static_cast<Layout *>(parent->getInterface(layoutGuid)); + if (NULL == l) + return; + + Container *c = l->getParentContainer(); + if (NULL == c) + return; + + GUID g = c->getDefaultContent(); + if (INVALID_GUID == g) + return; + + if (g == playerWndGuid) + hReroute = wa2.getMainWindow(); + else if (g == pleditWndGuid) + hReroute = wa2.getWnd(IPC_GETWND_PE); + else if (g == videoWndGuid) + hReroute = wa2.getWnd(IPC_GETWND_VIDEO); + else + { + embedWindowState *ews = embedWndGuidMgr.getEmbedWindowState(g); + if (ews) + hReroute = ews->me; + } + + if (NULL != hReroute) + pMsg->hwnd = hReroute; +} + +class WaMessageProccessor : public ifc_messageprocessor +{ +public: + WaMessageProccessor() {} + ~WaMessageProccessor(void) {} + +public: + bool ProcessMessage(MSG *pMsg) + { + if (WM_KEYDOWN == pMsg->message || + WM_KEYUP == pMsg->message || + WM_SYSKEYDOWN == pMsg->message || + WM_SYSKEYUP == pMsg->message) + { + + ifc_window *wnd; + HWND h = pMsg->hwnd; + do + { + wnd = WASABI_API_WND->rootWndFromOSHandle(h); + + } while (!wnd && NULL!= (h = GetAncestor(h, GA_PARENT))); + + if (wnd) + { + if (!wnd->isVirtual()) + { + while (wnd) + { + const wchar_t *pid = wnd->getId(); + if (pid && *pid) break; + wnd = wnd->getParent(); + } + } + if (wnd && wnd->getCurVirtualChildFocus()) + wnd = wnd->getCurVirtualChildFocus(); + } + + if (wnd) + DebugStringW(L"target wnd 0x%08X, id: %s", wnd, wnd->getId()); + + INT keyMsg = -1; + switch(pMsg->message) + { + case WM_KEYDOWN: + static int pos; + if (toupper((int)pMsg->wParam) == eggstr[pos]) + { + if (!eggstr[++pos]) + { + toggleEgg(); + pos = 0; + } + } + else pos = 0; + keyMsg = (0 != WASABI_API_WND->forwardOnKeyDown(wnd, (int)pMsg->wParam, pMsg->lParam)); + break; + case WM_KEYUP: keyMsg = (wnd && 0 != WASABI_API_WND->forwardOnKeyUp(wnd, (int)pMsg->wParam, pMsg->lParam)); break; + case WM_SYSKEYDOWN: keyMsg = ( 0 != WASABI_API_WND->forwardOnSysKeyDown(wnd, (int)pMsg->wParam, pMsg->lParam)); break; + case WM_SYSKEYUP: keyMsg = (wnd && 0 != WASABI_API_WND->forwardOnSysKeyUp(wnd, (int)pMsg->wParam, pMsg->lParam)); break; + + } + if (-1 != keyMsg) + { + if (keyMsg > 0) + return true; + + RerouteMessage(pMsg, wnd); + } + } + return false; + } + +protected: + RECVS_DISPATCH; +}; + +#define CBCLASS WaMessageProccessor +START_DISPATCH; +CB(IFC_MESSAGEPROCESSOR_PROCESS_MESSAGE, ProcessMessage) +END_DISPATCH; +#undef CBCLASS + +static WaMessageProccessor waMessageProcessor; + +#define TabCtrl_InsertItemW(hwnd, iItem, pitem) \ + (int)SNDMSG((hwnd), TCM_INSERTITEMW, (WPARAM)(int)(iItem), (LPARAM)(const TC_ITEMW *)(pitem)) + +//----------------------------------------------------------------------------------------------- +void onSkinSwitch() +{ + switching_skin = 1; + int lastloaded = m_are_we_loaded; + + Wa2WndEmbed::rememberVisibleWindows(); + + // get skin name + wchar_t buf[MAX_PATH] = {0}; + wchar_t *p = (wchar_t *) SendMessageW(plugin.hwndParent, WM_WA_IPC, (WPARAM)buf, IPC_GETSKINW); + { + m_lastskin_nam.setValue(p); + m_lastskin_dir.setValue(buf); + + StringPathCombine t(m_lastskin_dir, L"skin.xml"); + + if (!m_lastskin_nam.isempty() + && _waccess(t.getValue(), 0)) + { + t.setValue(m_lastskin_dir); + StringW n = m_lastskin_nam; + removeSkinExtension(n); + t.AppendPath(n); + t.AppendPath(L"skin.xml"); + if (!_waccess(t.getValue(), 0)) + m_lastskin_dir.AppendPath(n); + } + + if (!_waccess(t.getValue(), 0)) + { + if (!m_are_we_loaded) init_inst(); + else + { + // load new skin + StringW skinname = m_lastskin_nam; + + removeSkinExtension(skinname); + + before_startup_callback = 1; + WASABI_API_SKIN->skin_switchSkin(skinname, m_lastskin_dir); + + if (DEFERREDCALLBACKMSG > 65536) + PostMessage(wa2.getMainWindow(), WM_WA_IPC, 2, DEFERREDCALLBACKMSG); + //embedEnumStruct cs = { embedCreateProc, 0 }; + //SendMessageW(plugin.hwndParent, WM_WA_IPC, (WPARAM)&cs, IPC_EMBED_ENUM); + + doplaylistcolors(); + setDialogBoxesParent(); + populateWindowsMenus(); + } + } + else + { + going_fixedform = 1; + quit_inst(); + } + } + if (subWnd != NULL && IsWindow(subWnd)) SendMessageW(subWnd, WM_INITDIALOG, 0, 0); + + if (IsWindow(tabwnd)) + { + if (!m_are_we_loaded) + { + if (subWndId == 5) + { + DestroyWindow(subWnd); + TabCtrl_SetCurSel(tabwnd,0); + _dosetsel(GetParent(tabwnd)); + } + + if (TabCtrl_GetItemCount(tabwnd) == 5) + { + TabCtrl_DeleteItem(tabwnd,4); + TabCtrl_DeleteItem(tabwnd,3); + } + } + else + { + if (TabCtrl_GetItemCount(tabwnd) == 3) + { + TCITEMW item = {0}; + item.mask=TCIF_TEXT; + item.pszText=WASABI_API_LNGSTRINGW(IDS_COLOR_THEMES); + TabCtrl_InsertItemW(tabwnd,3,&item); + item.pszText=WASABI_API_LNGSTRINGW(IDS_CURRENT_SKIN); + TabCtrl_InsertItemW(tabwnd,4,&item); + } + } + } + + if (m_are_we_loaded || lastloaded) // dont call this if going from classic->classic + Wa2WndEmbed::restoreVisibleWindows(); + + if (m_are_we_loaded && WASABI_API_SYSCB) + WASABI_API_SYSCB->syscb_issueCallback(SysCallback::GC, GarbageCollectCallback::GARBAGECOLLECT); + + if (WASABI_API_APP) + { + if (m_are_we_loaded) WASABI_API_APP->app_addMessageProcessor(&waMessageProcessor); + else WASABI_API_APP->app_removeMessageProcessor(&waMessageProcessor); + } + + /* TODO: benski> want to add this, but it's causing a weird crash + if (going_fixedform) + shutdownFFApi(); + */ + switching_skin = 0; + going_fixedform = 0; + before_startup_callback = 0; +} + +static int embedUpdateColorProc(embedWindowState *p, embedEnumStruct *parms) +{ + SendMessageW(p->me, WM_DISPLAYCHANGE, 0, 0); + return 0; +} + +int embedCreateProc(embedWindowState *ws, embedEnumStruct *parms) +{ + ifc_window *rw = reinterpret_cast<ifc_window*>(ws->extra_data[EMBED_STATE_EXTRA_FFROOTWND]); + + if (!rw && IsWindow(ws->me) && IsWindowVisible(ws->me) && !(ws->flags & EMBED_FLAGS_LEGACY_WND)) + { + ifc_window *windowParent = createEmb(ws, true); + if (NULL != windowParent) + { + GuiObject *uiObject = windowParent->getGuiObject(); + if (NULL != uiObject) + { + if (0 != (EMBED_FLAGS_FFCALLBACK & ws->flags) && + NULL != ws->callback) + { + ws->callback(ws, FFC_CREATEEMBED, (LPARAM)windowParent); + } + + Layout *layout = uiObject->guiobject_getParentLayout(); + if (NULL != layout) + { + Container *container = layout->getParentContainer(); + if (NULL != container) container->setVisible(1); + else layout->setVisible(1); + windowParent->setVisible(1); + } + } + } + + if (NULL == windowParent) + ShowWindow(ws->me, SW_HIDE); + } + + return 0; +} + +//----------------------------------------------------------------------------------------------- +void syncDoubleSize(int loading = 0) +{ + if (!cfg_uioptions_uselocks.getValueAsInt()) return ; + int isdsize = wa2.isDoubleSize(); + int i; + for (i = 0;i < SkinParser::getNumContainers();i++) + { + Container *c = SkinParser::enumContainer(i); + if (c != NULL) + { + int j; + for (j = 0;j < c->getNumLayouts();j++) + { + Layout *l = c->enumLayout(j); + if (l != NULL) + { + if (l->isScaleLocked()) continue; + l->setRenderRatio(isdsize ? 2.0f : 1.0f); + } + } + } + } +} + +//----------------------------------------------------------------------------------------------- +class syncDisplayModeEnumerator : public FindObjectCallbackI +{ +public: + int findobjectcb_matchObject(ifc_window *object) + { + ScriptObject *s = NULL; + GuiObject *g = object->getGuiObject(); + if (g) + { + ScriptObject *_s = g->guiobject_getScriptObject(); + if (_s) + { + void *v = _s->vcpu_getInterfaceObject(textGuid, &s); + if (v && !s) + { + (static_cast<Text*>(v))->setTimeDisplayMode(g_timedisplaymode); + } + } + } + return 0; + } +}; + +//----------------------------------------------------------------------------------------------- +void syncDisplayMode() +{ + if (switching_skin) return ; + g_timedisplaymode = wa2.getTimeDisplayMode(); + int i; + syncDisplayModeEnumerator enumerator; + for (i = 0;i < SkinParser::getNumContainers();i++) + { + Container *c = SkinParser::enumContainer(i); + if (c != NULL) + { + int j; + for (j = 0;j < c->getNumLayouts();j++) + { + Layout *l = c->enumLayout(j); + if (!WASABI_API_WND->rootwndIsValid(l)) continue; + l->findWindowByCallback(&enumerator); + } + } + } +} + +static POINT viewPort; +VOID CALLBACK ViewPortChanged(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime) +{ + KillTimer(hwnd, idEvent); + if (viewPort.x && viewPort.y) + { + SystemObject::onViewPortChanged(viewPort.x, viewPort.y); + } +} + +//----------------------------------------------------------------------------------------------- +// Winamp2 main window subclass +//----------------------------------------------------------------------------------------------- +static LRESULT WINAPI wa_newWndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + static int m_in_skinrefresh; + + if (uMsg == WM_COMMAND && LOWORD(wParam) == WINAMP_REFRESHSKIN) + { + HWND prefs = wa2.getPreferencesWindow(); + RECT prefrect = {0}; + if (prefs) + { + GetWindowRect(prefs, &prefrect); + HWND hOwner = (HWND)(LONG_PTR)GetWindowLongPtrW(prefs, GWLP_HWNDPARENT); + if (NULL != hOwner && hOwner != hwndDlg) + SetWindowLongPtrW(prefs, GWLP_HWNDPARENT, (LONG_PTR)hwndDlg); + } + m_in_skinrefresh++; + DWORD b = CallWinampWndProc(hwndDlg, uMsg, wParam, lParam); + onSkinSwitch(); + if (m_are_we_loaded) doplaylistcolors(); + m_in_skinrefresh--; + if (prefs && !wa2.getPreferencesWindow()) + { + SendMessageW(wa2.getMainWindow(), WM_COMMAND, WINAMP_OPTIONS_PREFS, 0); + SetWindowPos(wa2.getPreferencesWindow(), NULL, prefrect.left, prefrect.top, prefrect.right - prefrect.left, prefrect.bottom - prefrect.top, SWP_NOZORDER | SWP_NOACTIVATE | SWP_DEFERERASE); + } + + return b; + } + if (g_Core) + { + if (uMsg == WM_WA_IPC && lParam == IPC_CB_MISC) g_Core->gotCallback(wParam); +#define WINAMP_FILE_REPEAT 40022 +#define WINAMP_FILE_SHUFFLE 40023 +#define WINAMP_FILE_MANUALPLADVANCE 40395 +#define UPDATE_DISPLAY_TIMER 38 + if (uMsg == WM_TIMER) + { + if (LOWORD(wParam) == UPDATE_EGG) + { + for (int i = 0;i < SkinParser::getNumContainers();i++) + { + Container *cont = SkinParser::enumContainer(i); + if (cont->isMainContainer()) + { + Layout *l = cont->getCurrentLayout(); + if (lastlayoutegg && l != lastlayoutegg) + { + if (WASABI_API_WND->rootwndIsValid(lastlayoutegg)) + { + lastlayoutegg->updateTransparency(); + lastlayoutegg->setTransparencyOverride(-1); + } + } + lastlayoutegg = l; + int v = (WASABI_API_MEDIACORE->core_getLeftVuMeter(0) + WASABI_API_MEDIACORE->core_getRightVuMeter(0)) / 4; + eggfallout -= 4; + if (v > eggfallout) eggfallout = v; + lastlayoutegg->setTransparencyOverride(255 - eggfallout); + break; + } + } + return 0; + } + if (LOWORD(wParam) == UPDATE_DISPLAY_TIMER + 4) + { + syncDisplayMode(); + } + if (LOWORD(wParam) == 0xC0DE) + { + if (!wa2.isVisRunning()) + { + KillTimer(wa2.getMainWindow(), 0xC0DE); + KillTimer(wa2.getMainWindow(), 0xC0DE + 1); + wa2.toggleVis(); + } + } + if (LOWORD(wParam) == 0xC0DE + 1) + { + KillTimer(wa2.getMainWindow(), 0xC0DE); + KillTimer(wa2.getMainWindow(), 0xC0DE + 1); + } + } + if (!my_set && (uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND) && LOWORD(wParam) == WINAMP_FILE_SHUFFLE) + { + DWORD v = CallWinampWndProc(hwndDlg, uMsg, wParam, lParam); + int shuf = wa2.getShuffle(); + if (!shuffle.getValueAsInt() != !shuf) shuffle.setValueAsInt(shuf); + return v; + } + if (!my_set && (uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND) && + (LOWORD(wParam) == WINAMP_FILE_REPEAT) || + (LOWORD(wParam) == WINAMP_FILE_MANUALPLADVANCE)) + { + DWORD v = CallWinampWndProc(hwndDlg, uMsg, wParam, lParam); + int rep = wa2.getRepeat(); + int manadv = wa2.getManualPlaylistAdvance(); + int _v = (rep && manadv) ? -1 : rep; + if (repeat.getValueAsInt() != _v) repeat.setValueAsInt(_v); + return v; + } + if ((uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND) && LOWORD(wParam) == WINAMP_OPTIONS_DSIZE) + { + int v = CallWinampWndProc(hwndDlg, uMsg, wParam, lParam); + syncDoubleSize(); + return v; + } + if ((uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND) && (LOWORD(wParam) == WINAMP_OPTIONS_ELAPSED || LOWORD(wParam) == WINAMP_OPTIONS_REMAINING)) + { + int v = CallWinampWndProc(hwndDlg, uMsg, wParam, lParam); + syncDisplayMode(); + return v; + } + } + if (m_are_we_loaded) + { + if (uMsg == WM_COMMAND && LOWORD(wParam) == 40266) + { + ToggleLayout(L"pledit"); + return 0; + } + else if (uMsg == WM_COMMAND && LOWORD(wParam) == 40064) + { + ToggleLayout(L"main"); + return 0; + } + else if (uMsg == WM_CLOSE && wParam == 0xDEADBEEF && lParam == 0xDEADF00D) + { + //if (/*todo: configurable */ 1) + { + uMsg = WM_COMMAND; + wParam = WINAMP_MAIN_WINDOW; + } + } + else if (uMsg == WM_SETTINGCHANGE) + { + // used to track viewport changes so we can update + // e.g. when removing Win8's side-by-side app mode + if (wParam == SPI_SETWORKAREA) + { + KillTimer(wa2.getMainWindow(), VIEWPORT); + viewPort.x = -1; + viewPort.y = -1; + SetTimer(wa2.getMainWindow(), VIEWPORT, 100, ViewPortChanged); + } + } + else if (uMsg == WM_DISPLAYCHANGE) + { + DWORD b = CallWinampWndProc(hwndDlg, uMsg, wParam, lParam); + if (!m_in_skinrefresh) doplaylistcolors(); + + // filter out our internal skin updates + if (wParam && lParam) + { + KillTimer(wa2.getMainWindow(), VIEWPORT); + viewPort.x = LOWORD(lParam); + viewPort.y = HIWORD(lParam); + SetTimer(wa2.getMainWindow(), VIEWPORT, 100, ViewPortChanged); + } + + return b; + } + else if (uMsg == WM_INITMENUPOPUP) + { + HMENU hmenuPopup = (HMENU) wParam; + + if (hmenuPopup && hmenuPopup == mainSendTo.build_hMenu && mainSendTo.mode == 1) + { + int IPC_LIBRARY_SENDTOMENU = SendMessageW(plugin.hwndParent, WM_WA_IPC, (WPARAM)&"LibrarySendToMenu", IPC_REGISTER_WINAMP_IPCMESSAGE); + if (IPC_LIBRARY_SENDTOMENU > 65536 && SendMessageW(plugin.hwndParent, WM_WA_IPC, (WPARAM)&mainSendTo, IPC_LIBRARY_SENDTOMENU) == 0xffffffff) + mainSendTo.mode = 2; + } + + if(hmenuPopup == wa2.getMenuBarMenu(Winamp2FrontEnd::WA2_MAINMENUBAR_PLAY)) + { + CheckMenuItem((HMENU)wParam, WINAMP_FILE_SHUFFLE, wa2.getShuffle() ? MF_CHECKED : MF_UNCHECKED); + CheckMenuItem((HMENU)wParam, WINAMP_FILE_REPEAT, wa2.getRepeat() ? MF_CHECKED : MF_UNCHECKED); + } + + if (hmenuPopup == wa2.getPopupMenu() || + hmenuPopup == wa2.getMenuBarMenu(Winamp2FrontEnd::WA2_MAINMENUBAR_OPTIONS) || + hmenuPopup == wa2.getMenuBarMenu(Winamp2FrontEnd::WA2_MAINMENUBAR_WINDOWS)) + { + if (hmenuPopup == wa2.getMenuBarMenu(Winamp2FrontEnd::WA2_MAINMENUBAR_OPTIONS)) { + EnableMenuItem(hmenuPopup, WINAMP_OPTIONS_DSIZE, + MF_BYCOMMAND | (cfg_uioptions_uselocks.getValueAsInt() ? MF_ENABLED : MF_GRAYED)); + } + if (hmenuPopup == wa2.getPopupMenu()){ + EnableMenuItem(GetSubMenu(hmenuPopup, 11 + wa2.adjustOptionsPopupMenu(0)), WINAMP_OPTIONS_DSIZE, + MF_BYCOMMAND | (cfg_uioptions_uselocks.getValueAsInt() ? MF_ENABLED : MF_GRAYED)); + } + + populateWindowsMenus(); + + if ((HMENU)wParam == wa2.getPopupMenu()) + { + for (int i = 0;i < SkinParser::getNumContainers();i++) + { + Container *cont = SkinParser::enumContainer(i); + if (!_wcsicmp(cont->getId(), L"main")) + { + CheckMenuItem((HMENU)wParam, WINAMP_MAIN_WINDOW, cont->isVisible() ? MF_CHECKED : MF_UNCHECKED); + break; + } + } + } + } + } + else if (uMsg == WM_SETFOCUS) + { + if (m_are_we_loaded && !switching_skin) + { + Container *c = SkinParser::getContainer(L"main"); + if (c) + { + Layout *l = c->enumLayout(0); + if (l) l->setFocus(); + } + return 1; + } + } + else if (uMsg == WM_WA_IPC) + { + if (lParam == DEFERREDCALLBACKMSG && DEFERREDCALLBACKMSG > 65536) + { + if (wParam == 1) + { + setDialogBoxesParent(); + return 1; + } + else if (wParam == 2) + { + // embed the windows that are currently visible because at the time the window were originally shown, + // we hadn't been loaded yet + // but then again, we might if it's only a switch skin and not a app load, so let's check anyway + + populateWindowsMenus(); + + doplaylistcolors(); + + if (plWnd == NULL && wa2.isWindowVisible(IPC_GETWND_PE)) + if (!createPl()) wa2.setWindowVisible(IPC_GETWND_PE, 0); + +#ifdef MINIBROWSER_SUPPORT + if (mbWnd == NULL && wa2.isWindowVisible(IPC_GETWND_MB)) + if (!createMb()) wa2.setWindowVisible(IPC_GETWND_MB, 0); +#endif + if (vidWnd == NULL && wa2.isWindowVisible(IPC_GETWND_VIDEO)) + if (!createVid()) wa2.setWindowVisible(IPC_GETWND_VIDEO, 0); + + embedEnumStruct cs = { embedCreateProc, 0 }; + SendMessageW(hwndDlg, WM_WA_IPC, (WPARAM)&cs, IPC_EMBED_ENUM); + + for (int i = 0;i < SkinParser::getNumContainers();i++) + { + Container *cont = SkinParser::enumContainer(i); + if (!_wcsicmp(cont->getId(), L"main")) + { + for (int j = 0;j < cont->getNumLayouts();j++) + { + Layout *l = cont->enumLayout(j); + if (l && l->isVisible()) + { + SetFocus(l->gethWnd()); + break; + } + } + } + } + + Crossfader::onOutputChanged(); + + extern int make_sure_library_is_here_at_startup; + if (make_sure_library_is_here_at_startup) + SendMessageW(wa2.getMainWindow(), WM_COMMAND, ID_FILE_SHOWLIBRARY, 0); + make_sure_library_is_here_at_startup = 0; + + before_startup_callback = 0; + + registerGlobalHotkeys(); + + // force a title update since it's not always correct + // if gen_ml hasn't loaded fully when we're loading + if (wa2.isPlaying()) + g_Core->gotCallback(IPC_CB_MISC_TITLE, 2); + return 1; + } + } + else if (lParam == UPDATEDIALOGBOXPARENTMSG && UPDATEDIALOGBOXPARENTMSG > 65536) + { + wa2.updateDialogBoxParent((HWND)wParam); + } + else switch (lParam) + { + case IPC_GETSKININFO: + return (LRESULT)getSkinInfo(); + case IPC_GETSKININFOW: + return (LRESULT)getSkinInfoW(); + case IPC_SHOW_NOTIFICATION: + return SystemObject::onShowNotification(); + case IPC_CB_VISRANDOM: + { + int v = wParam; + extern _bool visrandom; + if (!!v == !!visrandom.getValueAsInt()) break; + disable_send_visrandom = 1; + visrandom.setValueAsInt(v); + disable_send_visrandom = 0; + break; + } + case IPC_CB_OUTPUTCHANGED: + Crossfader::onOutputChanged(); + break; + + case IPC_CB_ONTOGGLEAOT: + { + if ((WPARAM)cfg_options_alwaysontop.getValueAsInt() != wParam) + cfg_options_alwaysontop.setValueAsInt(wParam); + break; + } + + case IPC_SETIDEALVIDEOSIZE: + { + wa2.setIdealVideoSize(HIWORD(wParam), LOWORD(wParam)); + break; + } + // this is where we detect that wa2 wants to open one of its windows (thru popup menu, button, whatever) + // when this happens, we create a freeform wndembedder if one doesn't already exist. that embedder will + // reparent and resize the wa2 window on its own. when we return, winamp then shows the HWND inside our frame + // as it would show the HWND as a popup normally. + case IPC_CB_ONSHOWWND: + switch (wParam) + { + case IPC_CB_WND_PE: + if (!createPl()) return 0; + break; +#ifdef MINIBROWSER_SUPPORT + case IPC_CB_WND_MB: + if (!createMb()) return 0; + break; +#endif + case IPC_CB_WND_VIDEO: +#ifdef VIDDEBUG + DebugString("Video : Got IPC_ONSHOW\n"); +#endif + if (!createVid()) + { +#ifdef VIDDEBUG + DebugString("Video : SHOW was cancelled by script\n"); +#endif + return 0; + } + break; + default: + DebugStringW(L"embedWnd : Got IPC_ONSHOW\n"); + if (IsWindow((HWND)wParam)) + { + HWND hTarget = (HWND)wParam; + embedWindowState *ws = (embedWindowState*)GetWindowLongPtrW(hTarget, GWLP_USERDATA); + if (ws && ws->me == hTarget) + { + GUID thisguid = EmbedWndGuid(ws).getGuid(); + if (INVALID_GUID == thisguid || NULL == updateEmb(thisguid, ws)) + { + ifc_window *windowParent = createEmb(ws, true); + if (NULL != windowParent) + { + GuiObject *uiObject = windowParent->getGuiObject(); + if (NULL != uiObject) + { + if (0 != (EMBED_FLAGS_FFCALLBACK & ws->flags) && + NULL != ws->callback) + { + ws->callback(ws, FFC_CREATEEMBED, (LPARAM)windowParent); + } + + Layout *layout = uiObject->guiobject_getParentLayout(); + if (NULL != layout) + { + Container *container = layout->getParentContainer(); + if (NULL != container) container->setVisible(1); + else layout->setVisible(1); + windowParent->setVisible(1); + } + } + + } + return (NULL != windowParent); + } + } + } + break; + } + break; + // here we do the reverse, we detect that wa2 wants to close one of its windows, so we destroy our window + // embedder (it will reparent the wa2 window back to its former parent and resize it back to where it was + // on its own). when we return, winamp then hides the window. + + // NOTE! because of this, there might be a split second where the window is seen on the screen as a popup + // after you closed the window (this won't happen for static containers [ie: pledit/video in mmd3] since + // they are hidden rather than destroyed). this can be fixed in the future + case IPC_CB_ONHIDEWND: + switch (wParam) + { + case IPC_CB_WND_PE: + destroyPl(hwndDlg, uMsg, wParam, lParam); + break; +#ifdef MINIBROWSER_SUPPORT + case IPC_CB_WND_MB: + return destroyMb(hwndDlg, uMsg, wParam, lParam); +#endif + case IPC_CB_WND_VIDEO: +#ifdef VIDDEBUG + DebugString("Video : Got IPC_ONHIDE\n"); +#endif + return destroyVid(hwndDlg, uMsg, wParam, lParam); + default: + DebugStringW(L"embedWnd : Got IPC_ONHIDE\n"); + if (IsWindow((HWND)wParam)) + { + HWND h = (HWND)wParam; + embedWindowState *ws = (embedWindowState *)GetWindowLongPtrW(h, GWLP_USERDATA); + if (ws) return destroyEmb(hwndDlg, uMsg, wParam, lParam, ws); + } + break; + } + break; + case IPC_FF_ISMAINWND: + { + for (int i = 0;i < SkinParser::getNumContainers();i++) + { + Container *cont = SkinParser::enumContainer(i); + if (!_wcsicmp(cont->getId(), L"main")) + { + for (int j = 0;j < cont->getNumLayouts();j++) + { + if (cont->enumLayout(j)->gethWnd() == (HWND)wParam) return 1; + } + break; + } + } + return 0; + } + case IPC_FF_GETCONTENTWND: + return (LRESULT)ff_ipc_getContentWnd((HWND)wParam); + case IPC_FF_GETSKINCOLOR: + ff_ipc_getSkinColor((ff_skincolor*)wParam); + return 1; + case IPC_FF_GENSKINBITMAP: + ff_ipc_genSkinBitmap((ff_skinbitmap*)wParam); + return 1; + case IPC_FF_NOTIFYHOTKEY: + if (processGenericHotkey((const char *)wParam)) return 0; // prevent gen_hotkey from processing the hotkey + return 1; // let gen_hotkey process the hotkey + case IPC_GET_GENSKINBITMAP: + if (m_are_we_loaded) + { + if (wParam == 0) + { + if (m_lastskin_dir[0]) + { + HBITMAP bm; + wchar_t bitmapfilename[MAX_PATH] = {0}; + PathCombineW(bitmapfilename, m_lastskin_dir, L"genex.bmp"); + bm = (HBITMAP)LoadImageW(NULL, bitmapfilename, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION | LR_LOADFROMFILE); + if (bm) return (LRESULT)bm; + } + return (LRESULT)ff_genwa2skinbitmap(); + } + else if (wParam == 4) + { + // TODO need to make sure we're covering everything needed for all of this!! + int buf[6] = {0}; + // active text + if (WASABI_API_SKIN->skin_getColorElementRef(L"wasabi.list.text.current")) + buf[1] = SkinColor(L"wasabi.list.text.current"); + /*else + { + COLORREF act = Blenders::BLEND_AVG(selected, buf[0]); + act = (lumidiff(act, buf[0]) < 0x3F || lumidiff(act, buf[2]) < 0x2F) ? Blenders::BLEND_AVG(buf[2], 0xFFFFFFFF) : act; + act = (lumidiff(act, buf[0]) < 0x3F || lumidiff(act, buf[2]) < 0x2F) ? Blenders::BLEND_AVG(buf[2], 0xFF101010) : act; + act = (lumidiff(act, buf[0]) < 0x3F || lumidiff(act, buf[2]) < 0x2F) ? Blenders::BLEND_AVG(selected, buf[0]) : act; + act = (lumidiff(act, buf[0]) < 0x3F || lumidiff(act, buf[2]) < 0x2F) ? Blenders::BLEND_AVG(selected, buf[2]) : act; + act = (lumidiff(act, buf[0]) < 0x3F || lumidiff(act, buf[2]) < 0x2F) ? Blenders::BLEND_AVG(buf[0], buf[2]) : act; + buf[1] = act & 0xFFFFFF; + }*/ + return buf[1]; + } + } + break; + case IPC_FF_ONCOLORTHEMECHANGED: + { + embedEnumStruct cs = { embedUpdateColorProc, 0 }; + SendMessageW(hwndDlg, WM_WA_IPC, (WPARAM)&cs, IPC_EMBED_ENUM); + if (wParam != 0xf00d) doplaylistcolors(); + } + break; + case IPC_PLAYLIST_MODIFIED: + { + Wa2PlaylistEditor::_onPlaylistModified(); + } + break; + } + } + else if (uMsg == WM_COMMAND && (LOWORD(wParam) == 40144 || LOWORD(wParam) == 40148)) + { + // seek left/right, we need to disable them if we are in a menu, because this is a + // plugin (ie: milkdrop) sending us the command manually as a forward rather than + // sending us the WM_KEY* directly + if (WASABI_API_WND->isKeyboardLocked()) return 0; + } + else if ((uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND) && LOWORD(wParam) >= 43000 && LOWORD(wParam) < ffwindowstop) + { + int id = LOWORD(wParam) - 43000; + + int n = SkinParser::getNumContainers(); + if (id < n) + { + Container *cont = SkinParser::enumContainer(id); + if (cont) cont->toggle(); + return 1; + } + id -= n; + + n = WASABI_API_WNDMGR->autopopup_getNumGuids(); + if (id < n) + { + GUID guid = WASABI_API_WNDMGR->autopopup_enumGuid(id); + if (guid != INVALID_GUID) + WASABI_API_WNDMGR->skinwnd_toggleByGuid(guid); + return 1; + } + id -= n; + + n = WASABI_API_WNDMGR->autopopup_getNumGroups(); + if (id < n) + { + const wchar_t *gid = WASABI_API_WNDMGR->autopopup_enumGroup(id); + if (gid && *gid) + WASABI_API_WNDMGR->skinwnd_toggleByGroupId(gid); + return 1; + } + + /* for (int c=0;c<SkinParser::getNumContainers();c++) { + Container *cont = SkinParser::enumContainer(c); + if (cont && wantContainerInMenu(cont)) { + if (cont->getName() == NULL) continue; + if (id == 0) { + if (cont) + cont->toggle(); + return 1; + } + id--; + } + } + int n = WASABI_API_WNDMGR->autopopup_getNumGuids(); + for (c=0;c<n;c++) { + GUID guid = WASABI_API_WNDMGR->autopopup_enumGuid(c); + const char *groupdesc = WASABI_API_WNDMGR->autopopup_enumGuidDescription(c); + if (guid != INVALID_GUID && groupdesc && *groupdesc) { + if (id == 0) { + WASABI_API_WNDMGR->skinwnd_toggleByGuid(guid); + return 1; + } + id--; + } + } + n = WASABI_API_WNDMGR->autopopup_getNumGroups(); + for (c=0;c<n;c++) { + const char *gid = WASABI_API_WNDMGR->autopopup_enumGroup(c); + const char *groupdesc = WASABI_API_WNDMGR->autopopup_enumGroupDescription(c); + if (id && groupdesc && *gid && *groupdesc) { + if (id == 0) { + WASABI_API_WNDMGR->skinwnd_toggleByGroupId(gid); + return 1; + } + id--; + } + }*/ + return 0; + } + else if ((uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND) && LOWORD(wParam) >= 44000 && LOWORD(wParam) < ffoptionstop) + { + int id = LOWORD(wParam); + MenuActions::toggleOption(id - 44000); + } + else if ((uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND) && LOWORD(wParam) >= 44500 && LOWORD(wParam) < 45000) + { + int id = LOWORD(wParam) - 44500; + WASABI_API_SKIN->colortheme_setColorSet(WASABI_API_SKIN->colortheme_enumColorSet(id)); + } + else if ((uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND) && LOWORD(wParam) >= 42000 && LOWORD(wParam) < ffwoptionstop) + { + int id = LOWORD(wParam); + MenuActions::toggleWindowOption(id - 42000); + } + else if ((uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND) && LOWORD(wParam) == WINAMP_MAIN_WINDOW) + { + for (int i = 0;i < SkinParser::getNumContainers();i++) + { + Container *cont = SkinParser::enumContainer(i); + if (!_wcsicmp(cont->getId(), L"main")) + { + cont->toggle(); + return 1; + } + } + } + else if ((uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND) && LOWORD(wParam) == WINAMP_OPTIONS_EQ) + { + if (!gothrueqmsg) + return 0; + } + else if ((uMsg == WM_COMMAND || uMsg == WM_SYSCOMMAND)) + { + switch (LOWORD(wParam)) + { + case ID_CONTROLMENU_OPACITY_10: controlOpacity(10); return 0; + case ID_CONTROLMENU_OPACITY_20: controlOpacity(20); return 0; + case ID_CONTROLMENU_OPACITY_30: controlOpacity(30); return 0; + case ID_CONTROLMENU_OPACITY_40: controlOpacity(40); return 0; + case ID_CONTROLMENU_OPACITY_50: controlOpacity(50); return 0; + case ID_CONTROLMENU_OPACITY_60: controlOpacity(60); return 0; + case ID_CONTROLMENU_OPACITY_70: controlOpacity(70); return 0; + case ID_CONTROLMENU_OPACITY_80: controlOpacity(80); return 0; + case ID_CONTROLMENU_OPACITY_90: controlOpacity(90); return 0; + case ID_CONTROLMENU_OPACITY_100: controlOpacity(100); return 0; + case ID_CONTROLMENU_SCALING_50: controlScaling(0.5); return 0; + case ID_CONTROLMENU_SCALING_75: controlScaling(0.75); return 0; + case ID_CONTROLMENU_SCALING_100: controlScaling(1.0); return 0; + case ID_CONTROLMENU_SCALING_125: controlScaling(1.25); return 0; + case ID_CONTROLMENU_SCALING_150: controlScaling(1.5); return 0; + case ID_CONTROLMENU_SCALING_200: controlScaling(2.0); return 0; + case ID_CONTROLMENU_SCALING_250: controlScaling(2.5); return 0; + case ID_CONTROLMENU_SCALING_300: controlScaling(3.0); return 0; + case ID_CONTROLMENU_SCALING_LOCKED: lockScaling(1); return 0; + case ID_CONTROLMENU_SCALING_FOLLOWDOUBLESIZE: lockScaling(0); return 0; + case ID_CONTROLMENU_SCALING_CUSTOM: customScaling(); return 0; + case ID_CONTROLMENU_OPACITY_CUSTOM: customOpacity(); return 0; + case ID_CONTROLMENU_OPACITY_AUTO100_HOVER: autoOpacifyHover(); return 0; + case ID_CONTROLMENU_OPACITY_AUTO100_FOCUS: autoOpacifyFocus(); return 0; + case SC_MOVE: + { + Layout *l = SkinParser::getMainLayout(); + if (l != NULL) + { + Container *c = l->getParentContainer(); + if (c) + { + Layout *ll = c->getCurrentLayout(); + if (ll) l = ll; + if (l) + { + if (!l->isVisible()) l->setVisible(1); + return SendMessageW(l->gethWnd(), WM_SYSCOMMAND, wParam, lParam); + } + } + } + break; + } + case ID_CONTROLMENU_TOOLBAR_DISABLED: controlAppBar(APPBAR_NOTDOCKED); break; + case ID_CONTROLMENU_TOOLBAR_TOP: controlAppBar(APPBAR_TOP); break; + case ID_CONTROLMENU_TOOLBAR_LEFT: controlAppBar(APPBAR_LEFT); break; + case ID_CONTROLMENU_TOOLBAR_RIGHT: controlAppBar(APPBAR_RIGHT); break; + case ID_CONTROLMENU_TOOLBAR_BOTTOM: controlAppBar(APPBAR_BOTTOM); break; + case ID_CONTROLMENU_TOOLBAR_ALWAYSONTOP: controlAppBarAOT(); break; + case ID_CONTROLMENU_TOOLBAR_AUTOHIDE: controlAppBarAH(); break; + case ID_CONTROLMENU_TOOLBAR_AUTODOCKONDRAG: cfg_options_appbarondrag = !cfg_options_appbarondrag; break; + } + } + } + + return CallWinampWndProc(hwndDlg, uMsg, wParam, lParam); +} + +void onLayoutChanged() +{ + if (DEFERREDCALLBACKMSG > 65536) + PostMessage(wa2.getMainWindow(), WM_WA_IPC, 1, DEFERREDCALLBACKMSG); +} + +#ifdef DEBUG_CAPTURES +int tid = 0; + +VOID TimerProc(HWND hwnd, UINT uMsg, UINT idEvent, DWORD time) +{ + DebugString("Capture belongs to %x (foregroundwnd = %x)\n", GetCapture(), GetForegroundWindow()); +} +#endif + +template <class api_T> +static void ServiceBuild(api_T *&api_t, GUID factoryGUID_t) +{ + if (WASABI_API_SVC) + { + waServiceFactory *factory = WASABI_API_SVC->service_getServiceByGuid(factoryGUID_t); + if (factory) + api_t = reinterpret_cast<api_T *>( factory->getInterface() ); + } +} + +template <class api_T> +static void ServiceRelease(api_T *api_t, GUID factoryGUID_t) +{ + if (WASABI_API_SVC && api_t) + { + waServiceFactory *factory = WASABI_API_SVC->service_getServiceByGuid(factoryGUID_t); + if (factory) + factory->releaseInterface(api_t); + } + api_t = NULL; +} + +//----------------------------------------------------------------------------------------------- +// initializes freeform library +//----------------------------------------------------------------------------------------------- +int m_loaded_at_all = 0; +StringW g_resourcepath; + +void initFFApi() +{ + if ( !m_loaded_at_all ) + { + m_loaded_at_all = 1; + api_service *svc = (api_service *)SendMessageW( wa2.getMainWindow(), WM_WA_IPC, 0, IPC_GET_API_SERVICE ); + + ServiceBuild( AGAVE_API_PLAYLISTS, api_playlistsGUID ); + ServiceBuild( AGAVE_API_ALBUMART, albumArtGUID ); + ServiceBuild( AGAVE_API_PLAYLISTMANAGER, api_playlistmanagerGUID ); + ServiceBuild( WAC_API_DOWNLOADMANAGER, DownloadManagerGUID ); + ServiceBuild( WASABI_API_COLORTHEMES, ColorThemesAPIGUID ); + ServiceBuild( WASABI_API_PALETTE, PaletteManagerGUID ); + ServiceBuild( WASABI_API_THREADPOOL, ThreadPoolGUID ); + + ApiInit::init( hInstance, wa2.getMainWindow(), svc ); + cfgitems = new Wa2CfgItems(); + +#ifdef DEBUG_CAPTURES + tid = SetTimer( NULL, 0x159, 50, (TIMERPROC)TimerProc ); +#endif + + wchar_t filename[ WA_MAX_PATH ] = { 0 }; + GetModuleFileNameW( hInstance, filename, WA_MAX_PATH ); + PathParserW pp( filename ); + StringW path; + for ( int i = 0; i < pp.getNumStrings() - 1; i++ ) + { + path.AppendPath( pp.enumString( i ) ); + } + path.AppendPath( L"freeform" ); + path.AppendFolder( L"wacs" ); + + // we can load a somewhat restricted version of the wac format + + ComponentManager::loadAll( path ); + ComponentManager::postLoad(); + + ApiInit::widgets->loadResources(); + + startFSMonitor(); + } + cfg_options_alwaysontop.setValueAsInt( wa2.isOnTop() ); +} + +//----------------------------------------------------------------------------------------------- +// shutdown ff lib +//----------------------------------------------------------------------------------------------- +void shutdownFFApi() +{ + if (m_loaded_at_all) + { + ServiceRelease( AGAVE_API_PLAYLISTS, api_playlistsGUID); + ServiceRelease( AGAVE_API_ALBUMART, albumArtGUID); + ServiceRelease( AGAVE_API_PLAYLISTMANAGER, api_playlistmanagerGUID); + ServiceRelease( WAC_API_DOWNLOADMANAGER, DownloadManagerGUID); + ServiceRelease( WASABI_API_COLORTHEMES, ColorThemesAPIGUID); + ServiceRelease( WASABI_API_PALETTE, PaletteManagerGUID); + ServiceRelease( WASABI_API_THREADPOOL, ThreadPoolGUID); + + stopFSMonitor(); + + // shutdown the library +#ifdef DEBUG_CAPTURES + KillTimer(NULL, tid); +#endif + + delete cfgitems; cfgitems = NULL; + ApiInit::shutdown(); +ComponentManager::unloadAll(); + + m_loaded_at_all = 0; + } +} + +static void MakeControlMenu() +{ + if (controlmenu) + return ; + + controlmenu = WASABI_API_LOADMENU(IDR_CONTROLMENU); + + if (!Wasabi::Std::Wnd::isDesktopAlphaAvailable()) + EnableMenuItem(controlmenu, 0, MF_BYPOSITION | MF_GRAYED); +} + +//----------------------------------------------------------------------------------------------- +// go freeform +//----------------------------------------------------------------------------------------------- +void init_inst() +{ + if ( m_are_we_loaded ) + return; + + // set the classic main window to be transparent + // so we can move it around the screen to allow + // certain Windows 8 modes as well as improving + // where it is placed for some multi-mon setups + Wasabi::Std::Wnd::setLayeredWnd( wa2.getMainWindow(), 1 ); + Wasabi::Std::Wnd::setLayeredAlpha( wa2.getMainWindow(), 0 ); + + initEgg(); + + wa2.setDrawBorders( 0 ); + wa2.disableSkinnedCursors( 1 ); + + int wasminimized = IsIconic( wa2.getMainWindow() ); + if ( wasminimized ) + ShowWindow( wa2.getMainWindow(), SW_RESTORE ); + + MakeControlMenu(); + + going_freeform = 1; + + Wa2WndEmbed::rememberVisibleWindows(); + + if ( wa2.isWindowVisible( IPC_GETWND_PE ) ) + { + if ( !m_loading_at_startup ) WritePrivateProfileStringW( L"gen_ff", L"classicpe", L"1", INI_FILE ); + } + else + if ( !m_loading_at_startup ) WritePrivateProfileStringW( L"gen_ff", L"classicpe", L"0", INI_FILE ); + + if ( wa2.isWindowVisible( IPC_GETWND_EQ ) ) + { + gothrueqmsg = 1; + SendMessageW( plugin.hwndParent, WM_COMMAND, WINAMP_OPTIONS_EQ, 0 ); + gothrueqmsg = 0; + if ( !m_loading_at_startup ) WritePrivateProfileStringW( L"gen_ff", L"classiceq", L"1", INI_FILE ); + } + else + if ( !m_loading_at_startup ) WritePrivateProfileStringW( L"gen_ff", L"classiceq", L"0", INI_FILE ); + + removeEq(); + + if ( SendMessageW( plugin.hwndParent, WM_WA_IPC, 0, IPC_ISMAINWNDVISIBLE ) ) + { + SendMessageW( plugin.hwndParent, WM_COMMAND, WINAMP_MAIN_WINDOW, 0 ); + if ( !m_loading_at_startup ) WritePrivateProfileStringW( L"gen_ff", L"classicmw", L"1", INI_FILE ); + } + else + if ( !m_loading_at_startup ) WritePrivateProfileStringW( L"gen_ff", L"classicmw", L"0", INI_FILE ); + + m_are_we_loaded = 1; + + initFFApi(); + + // redirect drag and drop to winamp2 by default + WASABI_API_WND->setDefaultDropTarget( (void *)wa2.getDropTarget() ); + + // this installs a bunch of predefined groups to map wa3 to wa2 functionnality + groups = new Wa2Groupdefs(); + + // now load a skin ! the path to the skin is extracted and temporarilly becomes the official skins directory + + StringW skinname = m_lastskin_nam; + + removeSkinExtension( skinname ); + + before_startup_callback = 1; + WASABI_API_SKIN->skin_switchSkin( skinname, m_lastskin_dir ); + + /* // if we wanted to have drag&drop support for just the main window, we'd do it this way :-) + Container *maincontainer = SkinParser::getContainer("main"); + if (maincontainer != NULL) { + for (int i=0;i<maincontainer->getNumLayouts();i++) { + Layout *layout = maincontainer->enumLayout(i); + if (layout != NULL) { + layout->setDropTarget((void *)wa2.getDropTarget()); + } + } + }*/ + + // send event for dialog parent + onLayoutChanged(); + + if ( wa2.export_sa_setreq ) + wa2.export_sa_setreq( 1 ); + + shuffle.setValueAsInt( wa2.getShuffle() ); + + int rep = wa2.getRepeat(); + int manadv = wa2.getManualPlaylistAdvance(); + + disable_set_wa2_repeat = 1; + repeat.setValueAsInt( ( rep && manadv ) ? -1 : rep ); + disable_set_wa2_repeat = 0; + + if ( DEFERREDCALLBACKMSG > 65536 ) + PostMessage( wa2.getMainWindow(), WM_WA_IPC, 2, DEFERREDCALLBACKMSG ); + + // so if some embedwindows are already visible, they update their look + PostMessage( wa2.getMainWindow(), WM_WA_IPC, 0xf00d, IPC_FF_ONCOLORTHEMECHANGED ); + + // monitor color theme + colorThemeMonitor = new ColorThemeMonitor(); + + syncDoubleSize( 1 ); + syncDisplayMode(); + + going_freeform = 0; + + if ( wa2.getWnd( IPC_GETWND_VIDEO ) ) + { + oldVideoWnd = wa2.getWnd( IPC_GETWND_VIDEO ); + if ( !oldVideoWndProc ) + oldVideoWndProc = (WNDPROC)SetWindowLongPtrW( oldVideoWnd, GWLP_WNDPROC, (LONG_PTR)newVideoWndProc ); + } + + if ( wasminimized ) + ShowWindow( wa2.getMainWindow(), SW_MINIMIZE ); + + if ( eggstat ) + SetTimer( wa2.getMainWindow(), UPDATE_EGG, 25, NULL ); +} + +void quit_inst() +{ + if (!m_are_we_loaded) return ; + + KillTimer(wa2.getMainWindow(), UPDATE_EGG); + + wa2.setDrawBorders(1); + wa2.disableSkinnedCursors(0); + + KillTimer(wa2.getMainWindow(), 0xC0DE); + KillTimer(wa2.getMainWindow(), 0xC0DE + 1); + + EnableMenuItem(wa2.getMenuBarMenu(Winamp2FrontEnd::WA2_MAINMENUBAR_OPTIONS), WINAMP_OPTIONS_DSIZE, MF_ENABLED); + EnableMenuItem(GetSubMenu(wa2.getPopupMenu(), 11 + wa2.adjustOptionsPopupMenu(0)), WINAMP_OPTIONS_DSIZE, MF_ENABLED); + + if (oldVideoWnd && oldVideoWndProc) + SetWindowLongPtrW(oldVideoWnd, GWLP_WNDPROC, (LONG_PTR)oldVideoWndProc); + oldVideoWndProc = 0; + oldVideoWnd = 0; + + removeWindowOptionsFromContextMenu(); + + delete mainLayoutMonitor; + mainLayoutMonitor=0; + + wa2.setDialogBoxParent(NULL); + unpopulateWindowsMenus(); + restoreEq(); + + // unload the skin -- skinspath is restored to default + WASABI_API_SKIN->skin_unloadSkin(); + + // delete predefined groups service + delete groups; groups = NULL; + + // delete options + delete ffoptions; ffoptions = NULL; + + // stop monitoring color theme + delete colorThemeMonitor; colorThemeMonitor = NULL; + + if (wa2.export_sa_setreq) wa2.export_sa_setreq(0); + + m_are_we_loaded = 0; + + int classicmw = GetPrivateProfileIntW(L"gen_ff", L"classicmw", 1, INI_FILE); + if (classicmw && !SendMessageW(plugin.hwndParent, WM_WA_IPC, 0, IPC_ISMAINWNDVISIBLE)) + SendMessageW(plugin.hwndParent, WM_COMMAND, WINAMP_MAIN_WINDOW, 0); + + CheckMenuItem(wa2.getPopupMenu(), WINAMP_MAIN_WINDOW, classicmw ? MF_CHECKED : MF_UNCHECKED); + + if (GetPrivateProfileIntW(L"gen_ff", L"classiceq", 1, INI_FILE) && !wa2.isWindowVisible(IPC_GETWND_EQ)) + { + gothrueqmsg = 1; + SendMessageW(plugin.hwndParent, WM_COMMAND, WINAMP_OPTIONS_EQ, 0); + gothrueqmsg = 0; + } + + if (GetPrivateProfileIntW(L"gen_ff", L"classicpe", 1, INI_FILE) && !wa2.isWindowVisible(IPC_GETWND_PE)) + { + SendMessageW(plugin.hwndParent, WM_COMMAND, WINAMP_OPTIONS_PLEDIT, 0); + } + + // restore the classic main window to be solid + Wasabi::Std::Wnd::setLayeredWnd(wa2.getMainWindow(), 0); +} + +//----------------------------------------------------------------------------------------------- +// init (from Winamp2) +//----------------------------------------------------------------------------------------------- +int init() +{ + // loader so that we can get the localisation service api for use + WASABI_API_SVC = (api_service*) SendMessageW(plugin.hwndParent, WM_WA_IPC, 0, IPC_GET_API_SERVICE); + if (WASABI_API_SVC == (api_service*)1) WASABI_API_SVC = NULL; + if (!WASABI_API_SVC || WASABI_API_SVC == (api_service *)1) + return GEN_INIT_FAILURE; + + static wchar_t modskin[128]; + INI_FILE = (wchar_t*) SendMessageW(plugin.hwndParent, WM_WA_IPC, 0, IPC_GETINIFILEW); + INI_DIR = (wchar_t*) SendMessageW(plugin.hwndParent, WM_WA_IPC, 0, IPC_GETINIDIRECTORYW); + + waServiceFactory *sf = WASABI_API_SVC->service_getServiceByGuid(languageApiGUID); + if (sf) WASABI_API_LNG = reinterpret_cast<api_language*>(sf->getInterface()); + + // need to have this initialised before we try to do anything with localisation features + WASABI_API_START_LANG(plugin.hDllInstance,GenFFLangGUID); + + swprintf(szDescription, ARRAYSIZE(szDescription), + WASABI_API_LNGSTRINGW(IDS_NULLSOFT_MODERN_SKINS), VERSION); + plugin.description = (char*)szDescription; + + wa2.init(plugin.hwndParent); + + DEFERREDCALLBACKMSG = SendMessageW(plugin.hwndParent, WM_WA_IPC, (WPARAM)"gen_ff_deferred", IPC_REGISTER_WINAMP_IPCMESSAGE); + UPDATEDIALOGBOXPARENTMSG = SendMessageW(plugin.hwndParent, WM_WA_IPC, (WPARAM)"gen_ff_update", IPC_REGISTER_WINAMP_IPCMESSAGE); + + // subclass the Winamp2 main window to receive our callbacks + wa_oldWndProc = (WNDPROC) SetWindowLongPtrW(wa2.getMainWindow(), GWLP_WNDPROC, (LONG_PTR)wa_newWndProc); + + ffPrefsItem.dlgID = IDD_PREFS; + ffPrefsItem.name = WASABI_API_LNGSTRINGW_BUF(IDS_MODERN_SKINS,modskin,128); + ffPrefsItem.proc = (void*)ffPrefsProc; + ffPrefsItem.hInst = WASABI_API_LNG_HINST; + ffPrefsItem.where = 2; //skins subtreeitem + SendMessageW(plugin.hwndParent, WM_WA_IPC, (WPARAM)&ffPrefsItem, IPC_ADD_PREFS_DLGW); + + checkMlPresent(); + + m_loading_at_startup = 1; + onSkinSwitch(); + m_loading_at_startup = 0; + return 0; +} + +void RestoreClassicWinamp(int was_loaded) +{ + // JF> my proposed fix to the problems :) + // investigating doing this from winamp.exe on startup, gotta figure it out + if (INI_FILE && was_loaded) // restore winamp.ini to about what it shoulda been + { + int classicpews = GetPrivateProfileIntW(L"gen_ff", L"classicplws", 0, INI_FILE); + int classicwidth = GetPrivateProfileIntW(L"gen_ff", L"classicplwidth", 275, INI_FILE); + int classicheight = GetPrivateProfileIntW(L"gen_ff", L"classicplheight", 145, INI_FILE); + int classicmw = GetPrivateProfileIntW(L"gen_ff", L"classicmw", 1, INI_FILE); + int classiceq = GetPrivateProfileIntW(L"gen_ff", L"classiceq", 1, INI_FILE); + wchar_t buf[64] = {0}; + + wsprintfW(buf, L"%d", classicheight); + if (classicpews) + { + WritePrivateProfileStringW(L"winamp", L"pe_height", L"14", INI_FILE); + WritePrivateProfileStringW(L"winamp", L"pe_height_ws", buf, INI_FILE); + } + else + { + WritePrivateProfileStringW(L"winamp", L"pe_height", buf, INI_FILE); + WritePrivateProfileStringW(L"winamp", L"pe_height_ws", L"", INI_FILE); + } + wsprintfW(buf, L"%d", classicwidth); + WritePrivateProfileStringW(L"winamp", L"pe_width", buf, INI_FILE); + + WritePrivateProfileStringW(L"winamp", L"eq_open", classiceq ? L"1" : L"0", INI_FILE); + WritePrivateProfileStringW(L"winamp", L"mw_open", classicmw ? L"1" : L"0", INI_FILE); + } +} + +//----------------------------------------------------------------------------------------------- +// quit (from Winamp 2) +//----------------------------------------------------------------------------------------------- +void quit() +{ + int was_loaded = m_are_we_loaded; + quit_inst(); + + RestoreClassicWinamp(was_loaded); + // restore wa2's windowproc + //SetWindowLong(wa2.getMainWindow(), GWL_WNDPROC, (LONG)wa_oldWndProc); + shutdownFFApi(); +} + +//----------------------------------------------------------------------------------------------- +// About box wndproc +//----------------------------------------------------------------------------------------------- +ifc_window *about_group = NULL; +StringW oldrenderer; +BOOL CALLBACK aboutProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + switch (uMsg) + { + case WM_INITDIALOG: + { + oldrenderer = cfg_options_fontrenderer.getValue(); + if (!WCSCASEEQLSAFE(cfg_options_fontrenderer.getValue(), L"FreeType")) + cfg_options_fontrenderer.setValue(L"FreeType"); + about_group = WASABI_API_SKIN->group_create(L"wasabi.gen_ff.about"); + about_group->setVirtual(0); + HWND w = GetDlgItem(hwndDlg, IDC_STATIC_GROUP); + about_group->setStartHidden(1); + about_group->init(WASABI_API_WND->main_getRootWnd(), 1); + SetWindowLong(about_group->gethWnd(), GWL_STYLE, GetWindowLong(about_group->gethWnd(), GWL_STYLE) | WS_CHILD); + SetParent(about_group->gethWnd(), w); + SetWindowLong(w, GWL_STYLE, GetWindowLong(w, GWL_STYLE) | WS_CLIPCHILDREN); + RECT r; + GetClientRect(w, &r); + about_group->resize(r.left + 1, r.top + 1, r.right - r.left - 2, r.bottom - r.top - 2); + about_group->setVisible(1); + C_Group g(about_group->getGuiObject()->guiobject_getScriptObject()); + ScriptObject *ver = g.findObject(L"version"); + if (ver) + { + C_Text t(ver); + t.setText(StringPrintfW(L". © 2003-2023 Winamp SA %s", VERSION)); + } + ShowWindow(about_group->gethWnd(), SW_NORMAL); + return 1; + } + case WM_DESTROY: + WASABI_API_SKIN->group_destroy(about_group); + about_group = NULL; + break; + case WM_COMMAND: + switch (LOWORD(wParam)) + { + case IDOK: case IDCANCEL: + if (!WCSCASEEQLSAFE(cfg_options_fontrenderer.getValue(), oldrenderer)) + cfg_options_fontrenderer.setValue(oldrenderer); + EndDialog(hwndDlg, 0); + return 0; + } + return 0; + } + return 0; +} + +//----------------------------------------------------------------------------------------------- +// configure plugin (from Winamp 2) +//----------------------------------------------------------------------------------------------- +void config() +{ + if (m_loaded_at_all) + { + StringW skin = WASABI_API_SKIN->getSkinName(); + wchar_t _skName[64] = {0}; + WASABI_API_LNGSTRINGW_BUF(IDS_NO_SKIN_LOADED_,_skName,64); + + if ((!skin.iscaseequal(_skName)) || guiTree->getNumObject() > 0) + { + WASABI_API_DIALOGBOXW(IDD_ABOUT, wa2.getPreferencesWindow(), aboutProc); + return ; + } + } + + MSGBOXPARAMSW msgbx = {sizeof(MSGBOXPARAMS),0}; + msgbx.lpszText = WASABI_API_LNGSTRINGW(IDS_MODERN_SKIN_SUPPORT_CLASSIC); + msgbx.lpszCaption = szDescription; + msgbx.lpszIcon = MAKEINTRESOURCEW(102); + msgbx.hInstance = GetModuleHandle(0); + msgbx.dwStyle = MB_USERICON; + MessageBoxIndirectW(&msgbx); +} + +//----------------------------------------------------------------------------------------------- +// expose the genpurp plugin interface to dll +//----------------------------------------------------------------------------------------------- +extern "C" __declspec(dllexport) winampGeneralPurposePlugin * winampGetGeneralPurposePlugin() { return &plugin; } + +//----------------------------------------------------------------------------------------------- +// a window was right clicked where there was no custom context menu available, spawn Wa2's menu +//----------------------------------------------------------------------------------------------- +void appContextMenu(ifc_window *w) +{ + if (!WASABI_API_WND->rootwndIsValid(w)) return ; + WASABI_API_WND->appdeactivation_setbypass(1); + SetCursor(LoadCursor(NULL, IDC_ARROW)); + w->setFocus(); + DWORD p = GetMessagePos(); + int x = GET_X_LPARAM(p); + int y = GET_Y_LPARAM(p); + addWindowOptionsToContextMenu(w); + wa2.triggerPopupMenu(x, y); + WASABI_API_WND->appdeactivation_setbypass(0); +} + +//----------------------------------------------------------------------------------------------- +void updateControlMenu(ifc_window *w) +{ + int curalpha = 255; + double curratio = 1.; + int opacitysafe = 0; + int scalelocked = 0; + int auto100_hover = 0; + int auto100_focus = 0; + + if (g_controlMenuTarget == NULL) return ; + + if (w) + { + ifc_window *rootparent = g_controlMenuTarget->getDesktopParent(); + if (rootparent && rootparent->getInterface(layoutGuid)) + { + Layout *l = static_cast<Layout*>(rootparent); + opacitysafe = l->isTransparencySafe(); + scalelocked = l->isScaleLocked(); + curratio = w->getRenderRatio(); + if (!cfg_uioptions_linkallalpha.getValueAsInt()) + { + auto100_hover = l->getAutoOpacify() == 1; + auto100_focus = l->getAutoOpacify() == 2; + curalpha = l->getAlpha(); + } + else + { + auto100_hover = l->getAlphaMgr()->getAutoOpacify() == 1; + auto100_focus = l->getAlphaMgr()->getAutoOpacify() == 2; + curalpha = l->getAlphaMgr()->getGlobalAlpha(); + } + } + } + + HMENU ctrlmenu = GetSubMenu(controlmenu, 0); + EnableMenuItem(ctrlmenu, 0, MF_BYPOSITION | (opacitysafe ? MF_ENABLED : MF_GRAYED)); + HMENU scalemenu = GetSubMenu(ctrlmenu, 1); + HMENU alphamenu = GetSubMenu(ctrlmenu, 0); + int uselocks = cfg_uioptions_uselocks.getValueAsInt(); + CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_LOCKED, MF_BYCOMMAND | ((scalelocked || !uselocks) ? MF_CHECKED : MF_UNCHECKED)); + EnableMenuItem(scalemenu, ID_CONTROLMENU_SCALING_LOCKED, MF_BYCOMMAND | (uselocks ? MF_ENABLED : MF_GRAYED)); + CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_FOLLOWDOUBLESIZE, MF_BYCOMMAND | (scalelocked || !uselocks ? MF_UNCHECKED : MF_CHECKED)); + EnableMenuItem(scalemenu, ID_CONTROLMENU_SCALING_FOLLOWDOUBLESIZE, MF_BYCOMMAND | (uselocks ? MF_ENABLED : MF_GRAYED)); + CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_AUTO100_HOVER, MF_BYCOMMAND | (auto100_hover ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_AUTO100_FOCUS, MF_BYCOMMAND | (auto100_focus ? MF_CHECKED : MF_UNCHECKED)); + + int v = (int)((curalpha / 255.0f * 100.0f) + 0.5f); + int u = (int)((curratio * 100.0f) + 0.5f); + + CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_10, MF_BYCOMMAND | (v == 10 ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_20, MF_BYCOMMAND | (v == 20 ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_30, MF_BYCOMMAND | (v == 30 ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_40, MF_BYCOMMAND | (v == 40 ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_50, MF_BYCOMMAND | (v == 50 ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_60, MF_BYCOMMAND | (v == 60 ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_70, MF_BYCOMMAND | (v == 70 ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_80, MF_BYCOMMAND | (v == 80 ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_90, MF_BYCOMMAND | (v == 90 ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_100, MF_BYCOMMAND | (v == 100 ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_50, MF_BYCOMMAND | (u == 50 ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_75, MF_BYCOMMAND | (u == 75 ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_100, MF_BYCOMMAND | (u == 100 ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_125, MF_BYCOMMAND | (u == 125 ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_150, MF_BYCOMMAND | (u == 150 ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_200, MF_BYCOMMAND | (u == 200 ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_250, MF_BYCOMMAND | (u == 250 ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_300, MF_BYCOMMAND | (u == 300 ? MF_CHECKED : MF_UNCHECKED)); + + if (u != 50 && u != 75 && u != 100 && u != 125 && u != 150 && u != 200 && u != 250 && u != 300) + { + ModifyMenuW(scalemenu, ID_CONTROLMENU_SCALING_CUSTOM, MF_BYCOMMAND | MF_STRING, ID_CONTROLMENU_SCALING_CUSTOM, StringPrintfW(WASABI_API_LNGSTRINGW(IDS_CUSTOM_X_PERCENT), u)); + CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_CUSTOM, MF_BYCOMMAND | MF_CHECKED); + } + else + { + ModifyMenuW(scalemenu, ID_CONTROLMENU_SCALING_CUSTOM, MF_BYCOMMAND | MF_STRING, ID_CONTROLMENU_SCALING_CUSTOM, WASABI_API_LNGSTRINGW(IDS_CUSTOM)); + CheckMenuItem(scalemenu, ID_CONTROLMENU_SCALING_CUSTOM, MF_BYCOMMAND | MF_UNCHECKED); + } + if (((float)v / 10.0) - (v / 10) != 0.0) + { + ModifyMenuW(alphamenu, ID_CONTROLMENU_OPACITY_CUSTOM, MF_BYCOMMAND | MF_STRING, ID_CONTROLMENU_OPACITY_CUSTOM, StringPrintfW(WASABI_API_LNGSTRINGW(IDS_CUSTOM_X_PERCENT), v)); + CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_CUSTOM, MF_BYCOMMAND | MF_CHECKED); + } + else + { + ModifyMenuW(alphamenu, ID_CONTROLMENU_OPACITY_CUSTOM, MF_BYCOMMAND | MF_STRING, ID_CONTROLMENU_OPACITY_CUSTOM, WASABI_API_LNGSTRINGW(IDS_CUSTOM)); + CheckMenuItem(alphamenu, ID_CONTROLMENU_OPACITY_CUSTOM, MF_BYCOMMAND | MF_UNCHECKED); + } +} + +//----------------------------------------------------------------------------------------------- +// a window has triggered the control menu (control scale & alpha) +//----------------------------------------------------------------------------------------------- +void appControlMenu(ifc_window *w) +{ + WASABI_API_WND->appdeactivation_setbypass(1); + int x, y; + if (w) + { + Wasabi::Std::getMousePos(&x, &y); + g_controlMenuTarget = w; + updateControlMenu(w); + updateAppBarMenu(w); + HMENU ctrlmenu = GetSubMenu(controlmenu, 0); + DoTrackPopup(ctrlmenu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_LEFTBUTTON, x, y, wa2.getMainWindow()); + } + WASABI_API_WND->appdeactivation_setbypass(0); +} + +//----------------------------------------------------------------------------------------------- +// a close application button was clicked +//----------------------------------------------------------------------------------------------- +void appQuit() +{ + if (!wa2.isExitEnabled()) return ; + wa2.quit(); // this is in fact *posting* a quit message +} + + +//----------------------------------------------------------------------------------------------- +// a fatal skin error occured, we should revert to the wa2 skin (deferred) +//----------------------------------------------------------------------------------------------- +#define DCB_UNLOADSKIN 64 + +class deferredUnloadSkin : public TimerClientDI +{ +public: + deferredUnloadSkin() + { + timerclient_postDeferredCallback(DCB_UNLOADSKIN, 0); + } + + virtual int timerclient_onDeferredCallback(intptr_t param1, intptr_t param2) + { + if (param1 == DCB_UNLOADSKIN) + { + quit_inst(); + delete this; + return 1; + } + else return TimerClientDI::timerclient_onDeferredCallback(param1, param2); + } +}; + +//----------------------------------------------------------------------------------------------- +// this is the actual event for skin fata errors, it is called when a try/except block failed +// upon calling a skin operation which should not be able to fail (ie: calling a script function pointer) +//----------------------------------------------------------------------------------------------- +void onFatalSkinError() +{ + new deferredUnloadSkin(); +} + + +//----------------------------------------------------------------------------------------------- +// map a GUID to the toggling of a window for which there is no permanent wndCreationService, +// ie: library, prefs, avs +//----------------------------------------------------------------------------------------------- + +// called by a skinwnd_toggle call when the guid isn't found in the wndcreation services +int onCreateExternalWindowGuid(GUID g) +{ + if (g == library_guid) + { + SendMessageW(wa2.getMainWindow(), WM_COMMAND, ID_FILE_SHOWLIBRARY, 0); + return 1; + } + else if (g == preferences_guid) + { + SendMessageW(wa2.getMainWindow(), WM_COMMAND, WINAMP_OPTIONS_PREFS, 0); + return 1; + } + else if (g == about_guid) + { + SendMessageW(wa2.getMainWindow(), WM_COMMAND, WINAMP_HELP_ABOUT, 0); + return 1; + } + else if (g == lightning_bolt_guid) + { + SendMessageW(wa2.getMainWindow(), WM_COMMAND, WINAMP_LIGHTNING_CLICK, 0); + return 1; + } + else if (g == colorthemes_guid) + { + last_page.setData(L"3"); + SendMessageW(plugin.hwndParent, WM_WA_IPC, (WPARAM)&ffPrefsItem, IPC_OPENPREFSTOPAGE); + return 1; + } + else if (g == avs_guid) + { + if (wa2.isVisRunning()) + { + SetTimer(wa2.getMainWindow(), 0xC0DE, 50, NULL); + SetTimer(wa2.getMainWindow(), 0xC0DE + 1, 5000, NULL); + } + else + wa2.toggleVis(); + return 1; + } + return 0; +} + +//----------------------------------------------------------------------------------------------- +void onToggleDesktopAlpha(int v) +{ + if (!toggle_from_wa2 && subWndId == 0 && IsWindow(subWnd)) SendMessageW(subWnd, WM_INITDIALOG, 0, 0); +} + + +//----------------------------------------------------------------------------------------------- +// changes the name of a container so that static containers with the wrong name don't load the config +// values off the wrong name. this should match the WindowText of the embededwindow. note: this is only +// necessary for static containers holding an internal embedwnd (ie: library, avs, but not third party wnds +// as they can't be refered to by GUID anyway [if they can't be refered to by GUID, you can't make a static +// container for them]) +//----------------------------------------------------------------------------------------------- + +const wchar_t *onTweakContainerNameW(const wchar_t *name) +{ + static wchar_t tweaked[96]; + ZERO(tweaked); + if (!_wcsicmp(name, WASABI_API_LNG->GetStringFromGUIDW(GenMlLangGUID, plugin.hDllInstance, 18, tweaked, sizeof(tweaked)/sizeof(wchar_t))) || + !_wcsicmp(name, L"Media Library") || + !_wcsicmp(name, L"Winamp Library") || + !_wcsicmp(name, L"Library")) + { + return WASABI_API_LNGSTRINGW_BUF(IDS_MEDIA_LIBRARY,tweaked, sizeof(tweaked)/sizeof(wchar_t)); + } + if (!_wcsicmp(name, L"Avs")) return WASABI_API_LNGSTRINGW_BUF(IDS_VISUALIZATIONS,tweaked, sizeof(tweaked)/sizeof(wchar_t)); + return name; +} + +const wchar_t *GetMenuItemString(HMENU menu, int id, int bypos) +{ + static StringW rtn; + rtn.trunc(0); + MENUITEMINFOW info = {sizeof(info), MIIM_DATA | MIIM_TYPE | MIIM_STATE | MIIM_ID, MFT_STRING, }; + GetMenuItemInfoW(menu, id, bypos, &info); + if (info.cch > 0) + { + info.dwTypeData = WMALLOC(++info.cch + 1); + GetMenuItemInfoW(menu, id, bypos, &info); + info.dwTypeData[info.cch] = 0; + rtn = info.dwTypeData; + FREE(info.dwTypeData); + } + return rtn; +} + +StringW eqmenustring; + +//----------------------------------------------------------------------------------------------- +void removeEq() +{ + if (eqremoved) return ; + eqremoved = 1; + eqmenustring = GetMenuItemString(wa2.getPopupMenu(), WINAMP_OPTIONS_EQ, FALSE); + RemoveMenu(wa2.getPopupMenu(), WINAMP_OPTIONS_EQ, MF_BYCOMMAND); + wa2.adjustOptionsPopupMenu(-1); +} + +//----------------------------------------------------------------------------------------------- +void restoreEq() +{ + if (!eqremoved) return ; + MENUITEMINFOW i = {sizeof(i), MIIM_ID | MIIM_STATE | MIIM_TYPE, MFT_STRING, wa2.isWindowVisible(IPC_GETWND_EQ) ? MFS_CHECKED : 0, WINAMP_OPTIONS_EQ}; + i.dwTypeData = eqmenustring.getNonConstVal(); + InsertMenuItemW(wa2.getPopupMenu(), 8, TRUE, &i); + wa2.adjustOptionsPopupMenu(1); + eqremoved = 0; +} + +//----------------------------------------------------------------------------------------------- +void unpopulateWindowsMenus() +{ + if (ffwindowsitempos == -1) return ; + + HMENU menuBarMenu = wa2.getMenuBarMenu(Winamp2FrontEnd::WA2_MAINMENUBAR_WINDOWS); + for(int i = GetMenuItemCount(menuBarMenu)-1; i >= 0; i--) + { + MENUITEMINFOW info = {sizeof(info), MIIM_DATA, 0, }; + if(GetMenuItemInfoW(menuBarMenu,i,TRUE,&info)) + { + if(info.dwItemData == 0xD01){ + RemoveMenu(menuBarMenu,i,MF_BYPOSITION); + wa2.adjustFFWindowsMenu(-1); + } + } + } + + HMENU menuPopupMenu = wa2.getPopupMenu(); + for(int i = GetMenuItemCount(menuPopupMenu)-1; i >= 0; i--) + { + MENUITEMINFOW info = {sizeof(info), MIIM_DATA, 0, }; + if(GetMenuItemInfoW(menuPopupMenu,i,TRUE,&info)) + { + if(info.dwItemData == 0xD01){ + RemoveMenu(menuPopupMenu,i,MF_BYPOSITION); + wa2.adjustOptionsPopupMenu(-1); + } + } + } + + ffwindowsitempos = -1; + ffwindowsitempos2 = -1; + + MenuActions::removeSkinWindowOptions(); + MenuActions::removeSkinOptions(); +} + +//----------------------------------------------------------------------------------------------- +void populateWindowsMenus() +{ + if (ffwindowsitempos != -1) unpopulateWindowsMenus(); + MenuActions::installSkinOptions(); + MenuActions::installSkinWindowOptions(); + + ffwindowsitempos = wa2.adjustFFWindowsMenu(0) + NUMSTATICWINDOWS; + ffwindowsitempos2 = wa2.adjustOptionsPopupMenu(0) + 6 + NUMSTATICWINDOWS + 1; + + MENUITEMINFOW i = {sizeof(i), }; + i.fMask = MIIM_TYPE | MIIM_DATA | MIIM_ID | MIIM_STATE; + i.fType = MFT_STRING; + i.wID = 43000; + i.dwItemData = 0xD01; // use this as a check so we're only removing the correct items!! + int pos = ffwindowsitempos; + int pos2 = ffwindowsitempos2; + PtrListQuickSorted<StringW, StringWComparator> items; + + HMENU hMenu = wa2.getMenuBarMenu(Winamp2FrontEnd::WA2_MAINMENUBAR_WINDOWS); + HMENU hMenu2 = wa2.getPopupMenu(); + for (int c = 0;c < SkinParser::getNumContainers();c++) + { + Container *cont = SkinParser::enumContainer(c); + if (cont && wantContainerInMenu(cont)) + { + i.dwTypeData = const_cast<wchar_t *>(cont->getName()); + if (i.dwTypeData != NULL) + { + if (!items.findItem(i.dwTypeData)) + { + items.addItem(new StringW(i.dwTypeData)); + i.cch = wcslen(i.dwTypeData); + i.fState = cont->isVisible() ? MFS_CHECKED : 0; + InsertMenuItemW(hMenu, pos++, TRUE, &i); + wa2.adjustFFWindowsMenu(1); + InsertMenuItemW(hMenu2, pos2++, TRUE, &i); + wa2.adjustOptionsPopupMenu(1); + } + } + } + i.wID++; + } + + int n = WASABI_API_WNDMGR->autopopup_getNumGuids(); + for (int c = 0;c < n;c++) + { + GUID guid = WASABI_API_WNDMGR->autopopup_enumGuid(c); + const wchar_t *groupdesc = WASABI_API_WNDMGR->autopopup_enumGuidDescription(c); + if (guid != INVALID_GUID && groupdesc && *groupdesc) + { + i.dwTypeData = const_cast<wchar_t *>(groupdesc); + if (!items.findItem(i.dwTypeData)) + { + items.addItem(new StringW(i.dwTypeData)); + i.cch = wcslen(i.dwTypeData); + i.fState = WASABI_API_WNDMGR->skinwnd_getNumByGuid(guid) ? MFS_CHECKED : 0; + InsertMenuItemW(hMenu, pos++, TRUE, &i); + wa2.adjustFFWindowsMenu(1); + InsertMenuItemW(hMenu2, pos2++, TRUE, &i); + wa2.adjustOptionsPopupMenu(1); + } + } + i.wID++; + } + + n = WASABI_API_WNDMGR->autopopup_getNumGroups(); + for (int c = 0;c < n;c++) + { + const wchar_t *id = WASABI_API_WNDMGR->autopopup_enumGroup(c); + const wchar_t *groupdesc = WASABI_API_WNDMGR->autopopup_enumGroupDescription(c); + if (id && groupdesc && *id && *groupdesc) + { + i.dwTypeData = const_cast<wchar_t *>(groupdesc); + // allow localisation of the color editor menu item + i.dwTypeData = const_cast<wchar_t *>(MenuActions::localizeSkinWindowName(i.dwTypeData)); + if (!items.findItem(i.dwTypeData)) + { + items.addItem(new StringW(i.dwTypeData)); + i.cch = wcslen(i.dwTypeData); + i.fState = WASABI_API_WNDMGR->skinwnd_getNumByGroupId(id) ? MFS_CHECKED : 0; + InsertMenuItemW(hMenu, pos++, TRUE, &i); + wa2.adjustFFWindowsMenu(1); + InsertMenuItemW(hMenu2, pos2++, TRUE, &i); + wa2.adjustOptionsPopupMenu(1); + } + } + i.wID++; + } + + items.deleteAll(); + ffwindowstop = i.wID; +} + +//----------------------------------------------------------------------------------------------- +void switchSkin(const wchar_t *skinname) +{ + wa2.switchSkin(skinname); +} + +//----------------------------------------------------------------------------------------------- +void addWindowOptionsToContextMenu(ifc_window *w) +{ + if (g_controlMenuTarget != NULL) + removeWindowOptionsFromContextMenu(); + if (w == NULL && WASABI_API_WND->rootwndIsValid(lastFocused)) + w = lastFocused; + g_controlMenuTarget = w; + + if (g_controlMenuTarget == NULL) return ; + + /*int opacitysafe = 1; + int scalelocked = 0; + + ifc_window *rootparent = g_controlMenuTarget->getDesktopParent(); + if (rootparent && rootparent->getInterface(layoutGuid)) + { + Layout *l = static_cast<Layout*>(rootparent); + opacitysafe = l->isTransparencySafe(); + scalelocked = l->isScaleLocked(); + }*/ + + updateControlMenu(w); + updateAppBarMenu(w); + + HMENU menu = wa2.getPopupMenu(); + HMENU ctrlmenu = GetSubMenu(controlmenu, 0); + + // JF> Francis, made this use command IDs (inserts it right before the help ID in the main menu). + // does this look OK? if you want, revert back to the old one. I just thought this seemed a tiny + // bit cleaner... :) +#define ID_HELP_HELPTOPICS 40347 + InsertMenuW(menu, ID_HELP_HELPTOPICS, MF_BYCOMMAND | MF_POPUP, (UINT_PTR)ctrlmenu, WASABI_API_LNGSTRINGW(IDS_WINDOW_SETTINGS)); + InsertMenu(menu, ID_HELP_HELPTOPICS, MF_BYCOMMAND | MF_SEPARATOR, 0, NULL); + +} + +//----------------------------------------------------------------------------------------------- +void removeWindowOptionsFromContextMenu() +{ + if (g_controlMenuTarget == NULL) return ; + g_controlMenuTarget = NULL; + HMENU menu = wa2.getPopupMenu(); + HMENU ctrlmenu = GetSubMenu(controlmenu, 0); + if (ctrlmenu) + { + int l = GetMenuItemCount(menu); + while (l-- > 0 && GetSubMenu(menu, l) != ctrlmenu); + if (l >= 0) + { + RemoveMenu(menu, l, MF_BYPOSITION); + RemoveMenu(menu, l, MF_BYPOSITION); // remove sep + } + } +} + +//----------------------------------------------------------------------------------------------- +void controlOpacity(int v) +{ + if (!g_controlMenuTarget) return ; + if (!WASABI_API_WND->rootwndIsValid(g_controlMenuTarget)) return ; + v = (int)(((float)v / 100.0f) * 255.0f + 0.5f); + ifc_window *rootparent = g_controlMenuTarget->getDesktopParent(); + if (rootparent && rootparent->getInterface(layoutGuid)) + { + Layout *l = static_cast<Layout*>(rootparent); + if (!cfg_uioptions_linkallalpha.getValueAsInt()) + { + l->setAlpha(v); + } + else + { + cfg_uioptions_linkedalpha.setValueAsInt(v); + } + } +} + +//----------------------------------------------------------------------------------------------- +void controlScaling(double v) +{ + if (!g_controlMenuTarget) return ; + if (!WASABI_API_WND->rootwndIsValid(g_controlMenuTarget)) return ; + ifc_window *rootparent = g_controlMenuTarget->getDesktopParent(); + if (rootparent) rootparent->setRenderRatio(v); +} + +//----------------------------------------------------------------------------------------------- +void lockScaling(int lock) +{ + ifc_window *rootparent = g_controlMenuTarget->getDesktopParent(); + if (!WASABI_API_WND->rootwndIsValid(g_controlMenuTarget)) return ; + if (rootparent && rootparent->getInterface(layoutGuid)) + { + Layout *l = static_cast<Layout*>(rootparent); + l->lockScale(lock); + } +} + +//----------------------------------------------------------------------------------------------- +void controlAppBar(int side) +{ + ifc_window *rootparent = g_controlMenuTarget->getDesktopParent(); + if (rootparent) + { + AppBar *ab = (AppBar *)rootparent->getInterface(appBarGuid); + if (ab) + { + ab->appbar_dock(side); + } + } +} + +//----------------------------------------------------------------------------------------------- +void controlAppBarAOT() +{ + ifc_window *rootparent = g_controlMenuTarget->getDesktopParent(); + if (rootparent) + { + Layout *l = (Layout *)rootparent->getInterface(layoutGuid); + if (l) + { + int curaot = l->getAppBarAlwaysOnTop(); + l->setAppBarAlwaysOnTop(!curaot); + } + } +} + +//----------------------------------------------------------------------------------------------- +void controlAppBarAH() +{ + ifc_window *rootparent = g_controlMenuTarget->getDesktopParent(); + if (rootparent) + { + Layout *l = (Layout *)rootparent->getInterface(layoutGuid); + if (l) + { + int curah = l->getAppBarAutoHide(); + l->setAppBarAutoHide(!curah); + } + } +} + +//----------------------------------------------------------------------------------------------- +void updateAppBarMenu(ifc_window *w) +{ + if (g_controlMenuTarget == NULL) return ; + ifc_window *rootparent = g_controlMenuTarget->getDesktopParent(); + if (rootparent) + { + Layout *l = (Layout *)rootparent->getInterface(layoutGuid); + if (l) + { + HMENU ctrlmenu = GetSubMenu(controlmenu, 0); + HMENU appbarmenu = GetSubMenu(ctrlmenu, 2); + if (l->appbar_getEnabledSides() == 0) + { + EnableMenuItem(ctrlmenu, 2, MF_BYPOSITION | MF_GRAYED); + return ; + } + else + EnableMenuItem(ctrlmenu, 2, MF_BYPOSITION | MF_ENABLED); + int docked = l->appbar_isDocked(); + int side = l->appbar_getSide(); + CheckMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_ALWAYSONTOP, MF_BYCOMMAND | (l->appbar_wantAlwaysOnTop() ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_AUTOHIDE, MF_BYCOMMAND | (l->appbar_wantAutoHide() ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_LEFT, MF_BYCOMMAND | ((docked && side == APPBAR_LEFT) ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_TOP, MF_BYCOMMAND | ((docked && side == APPBAR_TOP) ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_RIGHT, MF_BYCOMMAND | ((docked && side == APPBAR_RIGHT) ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_BOTTOM, MF_BYCOMMAND | ((docked && side == APPBAR_BOTTOM) ? MF_CHECKED : MF_UNCHECKED)); + CheckMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_DISABLED, MF_BYCOMMAND | (!docked ? MF_CHECKED : MF_UNCHECKED)); + EnableMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_AUTOHIDE, MF_BYCOMMAND | ((!docked || l->appbar_isSideAutoHideSafe(side)) ? MF_ENABLED : MF_GRAYED)); + EnableMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_LEFT, MF_BYCOMMAND | (l->appbar_isSideEnabled(APPBAR_LEFT) ? MF_ENABLED : MF_GRAYED)); + EnableMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_TOP, MF_BYCOMMAND | (l->appbar_isSideEnabled(APPBAR_TOP) ? MF_ENABLED : MF_GRAYED)); + EnableMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_RIGHT, MF_BYCOMMAND | (l->appbar_isSideEnabled(APPBAR_RIGHT) ? MF_ENABLED : MF_GRAYED)); + EnableMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_BOTTOM, MF_BYCOMMAND | (l->appbar_isSideEnabled(APPBAR_BOTTOM) ? MF_ENABLED : MF_GRAYED)); + CheckMenuItem(appbarmenu, ID_CONTROLMENU_TOOLBAR_AUTODOCKONDRAG, MF_BYCOMMAND | (cfg_options_appbarondrag ? MF_CHECKED : MF_UNCHECKED)); + } + } +} + +//----------------------------------------------------------------------------------------------- +double onTweakRenderRatio(double v) +{ + if (!cfg_uioptions_uselocks.getValueAsInt()) + return v; + return wa2.isDoubleSize() ? 2.0 : 1.0; +} + +//----------------------------------------------------------------------------------------------- +void onCustomAltF4() +{ + SendMessageW(wa2.getMainWindow(), WM_CLOSE, 0, 0); +} + +int isSkinStillLoading() +{ + return before_startup_callback; +} + +//----------------------------------------------------------------------------------------------- +void loadExtraColorThemes() +{ + wchar_t filename[WA_MAX_PATH] = {0}; + GetModuleFileNameW(hInstance, filename, WA_MAX_PATH); + PathParserW pp(filename); + StringW path; + for (int i = 0;i < pp.getNumStrings() - 1;i++) + { + path.AppendPath(pp.enumString(i)); + } + StringW file = path; + file.AppendPath(L"ColorThemes"); + file.AppendPath(WASABI_API_SKIN->getSkinName()); + file.AppendPath(L"*.xml"); + WASABI_API_SKIN->loadSkinFile(file); +} + +double oldscale = 1.; + +//----------------------------------------------------------------------------------------------- +static BOOL CALLBACK customScaleProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + switch (uMsg) + { + case WM_INITDIALOG: + { + //CUT: double curratio=1.; + ifc_window *rootparent = g_controlMenuTarget->getDesktopParent(); + if (!rootparent || !WASABI_API_WND->rootwndIsValid(rootparent)) + { + g_controlMenuTarget = NULL; return TRUE; + } + + oldscale = rootparent->getRenderRatio(); + + int u = (int)((oldscale * 100.0f) + 0.5f); + + SendMessageW(GetDlgItem(hwndDlg, IDC_SLIDER_CUSTOMSCALE), TBM_SETRANGEMAX, 0, 300); + SendMessageW(GetDlgItem(hwndDlg, IDC_SLIDER_CUSTOMSCALE), TBM_SETRANGEMIN, 0, 10); + SendMessageW(GetDlgItem(hwndDlg, IDC_SLIDER_CUSTOMSCALE), TBM_SETPOS, 1, u); + SetDlgItemTextW(hwndDlg, IDC_STATIC_SCALE, StringPrintfW(WASABI_API_LNGSTRINGW(IDS_SCALE_X_PERCENT), u)); + return TRUE; + } + case WM_HSCROLL: + { + int t = (int)SendMessageW((HWND) lParam, TBM_GETPOS, 0, 0); + if ((HWND) lParam == GetDlgItem(hwndDlg, IDC_SLIDER_CUSTOMSCALE)) + { + SetDlgItemTextW(hwndDlg, IDC_STATIC_SCALE, StringPrintfW(WASABI_API_LNGSTRINGW(IDS_SCALE_X_PERCENT), t)); + controlScaling((double)t / 100.0); + if (g_controlMenuTarget) + { + ifc_window *w = g_controlMenuTarget->getDesktopParent(); + UpdateWindow(w->gethWnd()); + } + } + break; + } + case WM_COMMAND: + switch (LOWORD(wParam)) + { + case IDOK: + EndDialog(hwndDlg, IDOK); + return 0; + case IDCANCEL: + EndDialog(hwndDlg, IDCANCEL); + return 0; + } + break; + } + return FALSE; +} + +double oldalpha = 255.; + +//----------------------------------------------------------------------------------------------- +static BOOL CALLBACK customAlphaProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + switch (uMsg) + { + case WM_INITDIALOG: + { + ifc_window *rootparent = g_controlMenuTarget->getDesktopParent(); + if (!rootparent || !WASABI_API_WND->rootwndIsValid(rootparent)) + { + g_controlMenuTarget = NULL; return TRUE; + } + + int v = 100; + if (!cfg_uioptions_linkallalpha.getValueAsInt()) + { + Layout *l = static_cast<Layout *>(rootparent); + if (l != NULL) + oldalpha = static_cast<double>(l->getAlpha()); + } + else + { + oldalpha = static_cast<double>(cfg_uioptions_linkedalpha.getValueAsInt()); + } + v = (int)((oldalpha / 255.0f * 100.0f) + 0.5f); + SendMessageW(GetDlgItem(hwndDlg, IDC_SLIDER_CUSTOMALPHA), TBM_SETRANGEMAX, 0, 100); + SendMessageW(GetDlgItem(hwndDlg, IDC_SLIDER_CUSTOMALPHA), TBM_SETRANGEMIN, 0, 10); + SendMessageW(GetDlgItem(hwndDlg, IDC_SLIDER_CUSTOMALPHA), TBM_SETPOS, 1, v); + SetDlgItemTextW(hwndDlg, IDC_STATIC_ALPHA, StringPrintfW(WASABI_API_LNGSTRINGW(IDS_OPACITY_X_PERCENT), v)); + return TRUE; + } + case WM_HSCROLL: + { + int t = (int)SendMessageW((HWND) lParam, TBM_GETPOS, 0, 0); + if ((HWND) lParam == GetDlgItem(hwndDlg, IDC_SLIDER_CUSTOMALPHA)) + { + SetDlgItemTextW(hwndDlg, IDC_STATIC_ALPHA, StringPrintfW(WASABI_API_LNGSTRINGW(IDS_OPACITY_X_PERCENT), t)); + controlOpacity(t); + } + break; + } + case WM_COMMAND: + switch (LOWORD(wParam)) + { + case IDOK: + EndDialog(hwndDlg, IDOK); + return 0; + case IDCANCEL: + EndDialog(hwndDlg, IDCANCEL); + return 0; + } + break; + } + return FALSE; +} + +void customScaling() +{ + if (!g_controlMenuTarget) return ; + if (!WASABI_API_WND->rootwndIsValid(g_controlMenuTarget)) return ; + ifc_window *w = g_controlMenuTarget->getDesktopParent(); + if (!w || !WASABI_API_WND->rootwndIsValid(w)) return ; + int r = WASABI_API_DIALOGBOXW(IDD_CUSTOMSCALE, w->gethWnd(), customScaleProc); + if (r != IDOK) + controlScaling(oldscale); +} + +void customOpacity() +{ + if (!g_controlMenuTarget) return ; + if (!WASABI_API_WND->rootwndIsValid(g_controlMenuTarget)) return ; + ifc_window *w = g_controlMenuTarget->getDesktopParent(); + if (!w || !WASABI_API_WND->rootwndIsValid(w)) return ; + int r = WASABI_API_DIALOGBOXW(IDD_CUSTOMALPHA, w->gethWnd(), customAlphaProc); + if (r != IDOK) + controlOpacity((int)((oldalpha / 255.0f * 100.0f) + 0.5f)); +} + +void autoOpacifyHover() +{ + if (!g_controlMenuTarget) return ; + if (!WASABI_API_WND->rootwndIsValid(g_controlMenuTarget)) return ; + ifc_window *w = g_controlMenuTarget->getDesktopParent(); + Layout *l = static_cast<Layout*>(w->getInterface(layoutGuid)); + if (l) + { + if (!cfg_uioptions_linkallalpha.getValueAsInt()) + { + int a = l->getAutoOpacify(); + if (a == 2) a = 1; + else a = !a; + l->setAutoOpacify(a); + } + else + { + int a = cfg_uioptions_autoopacitylinked.getValueAsInt(); + if (a == 2) a = 1; + else a = !a; + cfg_uioptions_autoopacitylinked.setValueAsInt(a); + } + } +} + +void autoOpacifyFocus() +{ + if (!g_controlMenuTarget) return ; + if (!WASABI_API_WND->rootwndIsValid(g_controlMenuTarget)) return ; + ifc_window *w = g_controlMenuTarget->getDesktopParent(); + Layout *l = static_cast<Layout*>(w->getInterface(layoutGuid)); + if (l) + { + if (!cfg_uioptions_linkallalpha.getValueAsInt()) + { + int a = l->getAutoOpacify(); + if (a == 1) a = 2; + else if (a == 0) a = 2; + else if (a == 2) a = 0; + l->setAutoOpacify(a); + } + else + { + int a = cfg_uioptions_autoopacitylinked.getValueAsInt(); + if (a == 1) a = 2; + else if (a == 0) a = 2; + else if (a == 2) a = 0; + cfg_uioptions_autoopacitylinked.setValueAsInt(a); + } + } +} + +StringW langpackfilename; + +const wchar_t *localesCustomGetFile() +{ + const wchar_t *langDir = WASABI_API_LNG->GetLanguageFolder(); + if (!langDir || !*langDir) + return NULL; + + langpackfilename = StringPathCombine(langDir, L"freeform"); + return langpackfilename; +#if 0 // old code + wchar_t buf[256] = L""; + GetPrivateProfileStringW(L"Winamp", L"langpack", L"", buf, 256, AutoWide(INI_FILE)); // TODO: maybe we should change all ini file stuff to W versions + if (*buf == 0) + return NULL; + wchar_t *p = wcschr(buf, '.'); + if (p) + *p = 0; + + wchar_t filename[WA_MAX_PATH] = {0}; + GetModuleFileNameW(hInstance, filename, WA_MAX_PATH); + PathParserW pp(filename); + langpackfilename = L""; + + for (int i = 0;i < pp.getNumStrings() - 1;i++) + { + langpackfilename.AppendPath(pp.enumString(i)); + } + langpackfilename.AppendPath(L"freeform"); + langpackfilename.AppendPath(L"langpacks"); + langpackfilename.AppendPath(StringPrintfW(L"%s.xml", buf)); + + return langpackfilename; +#endif +} + +const wchar_t *getCustomVar(const wchar_t *var) +{ + static StringW ret; + if (WCSCASEEQLSAFE(var, L"@HAVE_LIBRARY@")) + { + ret = StringPrintfW(L"%d", we_have_ml); + return ret; + } + return NULL; +} + +void checkMlPresent() +{ + wchar_t filename[WA_MAX_PATH] = {0}; + GetModuleFileNameW(hInstance, filename, WA_MAX_PATH); + PathParserW pp(filename); + StringW path; + for (int i = 0;i < pp.getNumStrings() - 1;i++) + { + path.AppendPath(pp.enumString(i)); + } + path.AppendPath(L"gen_ml.dll"); + we_have_ml = !WACCESS(path, 0); +} + +void initEgg() +{ + eggstr[0] = ~'N'; + eggstr[1] = ~'U'; + eggstr[2] = ~'L'; + eggstr[3] = ~'L'; + eggstr[4] = ~'S'; + eggstr[5] = ~'O'; + eggstr[6] = ~'F'; + eggstr[7] = ~'T'; + eggstr[8] = 0; + + { + int x; + for (x = 0; x < 8; x ++) eggstr[x] ^= 255; + } +} + +void toggleEgg() +{ + eggstat = !eggstat; + if (!eggstat) + { + KillTimer(wa2.getMainWindow(), UPDATE_EGG); + if (lastlayoutegg && WASABI_API_WND->rootwndIsValid(lastlayoutegg)) lastlayoutegg->setTransparencyOverride(-1); + lastlayoutegg = NULL; + } + else SetTimer(wa2.getMainWindow(), UPDATE_EGG, 25, NULL); +} + +void getCustomMetaData(const wchar_t *field, wchar_t *buf, int len) +{ + StringW curfile = WASABI_API_MEDIACORE->core_getCurrent(0); + if (curfile.isempty()) + { + buf[0] = 0; + return ; + } + if (!_wcsnicmp(curfile, L"file://", 7)) + curfile = StringW(curfile.getValue() + 7); + buf[0] = 0; + + if (WCSCASEEQLSAFE(field, L"filename")) + { + WCSCPYN(buf, curfile, len); + } + else + { + wa2.getMetaData(curfile, field, buf, len); + } +} + +void registerGlobalHotkeys() +{ + static int registered = 0; + if (!registered) + { + static wchar_t ghkStr[96]; + wa2.registerGlobalHotkey((char*)WASABI_API_LNGSTRINGW_BUF(IDS_GHK_SHOW_NOTIFICATION,ghkStr,96), WM_WA_IPC, 0, IPC_SHOW_NOTIFICATION, HKF_UNICODE_NAME, "genff shn"); + registered = 1; + } +} + +const wchar_t *getSongInfoText() +{ + return Core::getSongInfoText(); +} + +const wchar_t *getSongInfoTextTranslated() +{ + return Core::getSongInfoTextTranslated(); +} + +OSWINDOWHANDLE getKeyboardForwardWnd(GUID g) +{ + if (g != INVALID_GUID) + { + if (g == playerWndGuid) + return wa2.getMainWindow(); + else if (g == pleditWndGuid) + return wa2.getWnd(IPC_GETWND_PE); + else if (g == videoWndGuid) + return wa2.getWnd(IPC_GETWND_VIDEO); + else + { + embedWindowState *ews = embedWndGuidMgr.getEmbedWindowState(g); + if (ews && wa2.isValidEmbedWndState(ews)) return ews->me; + } + } + return WASABI_API_WND->main_getRootWnd()->gethWnd(); +} + +void onAppBarDockChanged(ifc_window *w) +{ + setDialogBoxesParent(); +} + +void onMainLayoutMove(HWND w) +{ + // for Winamp to appear on the correct taskbar on Windows 8 + // its necessary to set the classic main window to appear on + // that monitor and to be on-screen (but hidden) otherwise + // Windows will ignore it and it then makes us look buggy. + RECT r; + Wasabi::Std::getViewport(&r, w, 1); + SetWindowPos(wa2.getMainWindow(), NULL, r.left, r.bottom - 1, 0, 0, SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOREDRAW); +} + +void updateAll() +{ + updatePl(); +#ifdef MINIBROWSER_SUPPORT + updateMb(); +#endif + updateVid(); + int n = embedWndGuidMgr.getNumWindowStates(); + for (int i = 0;i < n;i++) + { + embedWindowState *ws = NULL; + GUID g = embedWndGuidMgr.enumWindowState(i, &ws); + if (g != INVALID_GUID) + { + updateEmb(g, ws); + } + } +} + +void onReParent(HWND wnd) +{ + updateAll(); +} + +void onReInit(HWND wnd) +{ + updateAll(); +} + +void startFSMonitor() +{ + g_fsmonitor = new FullScreenMonitor(); + g_fscallback = new Wa5FSCallback(); + g_fsmonitor->registerCallback(g_fscallback); +} + +void stopFSMonitor() +{ + delete g_fsmonitor; + g_fsmonitor = NULL; + delete g_fscallback; + g_fscallback = NULL; +} + +void updateParentlessOnTop() +{ + int i; + for (i = 0;i < SkinParser::getNumContainers();i++) + { + Container *c = SkinParser::enumContainer(i); + if (c != NULL) + { + int j; + for (j = 0;j < c->getNumLayouts();j++) + { + Layout *l = c->enumLayout(j); + if (l != NULL) + { + // skip windows owned by winamp + // skip appbars, they take care of themselves + if (l->getNoParent() && !l->appbar_isDocked()) + { + l->updateOnTop(); + } + } + } + } + } +} + +void onGoFullscreen() +{ + // hidden windows will not receive APPBAR_CALLBACK, so forward it to winamp's main + SendMessageW(wa2.getMainWindow(), APPBAR_CALLBACK, ABN_FULLSCREENAPP, 1); + // update ontop flag for windows that are not parented to winamp + updateParentlessOnTop(); +} + +void onCancelFullscreen() +{ + // hidden windows will not receive APPBAR_CALLBACK, so forward it to winamp's main + SendMessageW(wa2.getMainWindow(), APPBAR_CALLBACK, ABN_FULLSCREENAPP, 0); + // update ontop flag for windows that are not owned by winamp + updateParentlessOnTop(); +} + +int processGenericHotkey(const char *hk) +{ + if (!m_are_we_loaded) return 0; + + SystemObject::onKeyDown(AutoWide(StringPrintf("HOTKEY: %s", hk))); + if (VCPU::getComplete()) + { + DebugStringW(L"HOTKEY: %s trapped by script\n", hk); + return 1; + } + return 0; +} + +int canExitWinamp() +{ + return wa2.isExitEnabled(); +} + +int fsMonitorIsFS() +{ + return g_fsmonitor->isFullScreen(); +} + +void modalPush() +{ + wa2.pushExitDisabled(); +} + +void modalPop() +{ + wa2.popExitDisabled(); +}
\ No newline at end of file |