mirrors/winamp
Archived
1
0
Fork 0
Code
This repository has been archived on 2024-10-17. You can view files and clone it, but cannot push or open issues or pull requests.
5b91e3f697
winamp/Src/Plugins/General/gen_ml/main.cpp

1173 lines
34 KiB
C++
Raw Normal View History

Initial community commit
2024-09-24 12:54:57 +00:00
#include "main.h"
#include <windowsx.h>
#include <time.h>
#include <rpc.h>
#include "../winamp/gen.h"
#include "resource.h"
#include "childwnd.h"
#include "config.h"
#include "../winamp/ipc_pe.h"
#include "../winamp/wa_dlg.h"
#include "../winamp/strutil.h"
#include "ml.h"
#include "ml_ipc.h"
#include "./folderbrowser.h"
#include "./mldwm.h"
#ifndef _ML_HEADER_IMPMLEMENT
#define _ML_HEADER_IMPMLEMENT
#endif // _ML_HEADER_IMPMLEMENT
#include "ml_ipc_0313.h"
#undef _ML_HEADER_IMPMLEMENT
#include "sendto.h"
#include "../gen_hotkeys/wa_hotkeys.h"
#include "MediaLibraryCOM.h"
#include "../nu/CCVersion.h"
#include "../nu/AutoWideFn.h"
#include "../nu/htmlcontainer2.h"
#include <shlwapi.h>
#include "api__gen_ml.h"
#include <api/service/waServiceFactory.h>
#include "./navigation.h"
//#include "./skinnedwnd.h"
#include "./skinning.h"
#include "../nu/ServiceWatcher.h"
#include "MusicID.h"
#include <tataki/export.h>
#include <strsafe.h>
#include "../Winamp/wasabicfg.h"
// {6B0EDF80-C9A5-11d3-9F26-00C04F39FFC6}
static const GUID library_guid =
{ 0x6b0edf80, 0xc9a5, 0x11d3, { 0x9f, 0x26, 0x0, 0xc0, 0x4f, 0x39, 0xff, 0xc6 } };
int m_calling_getfileinfo;
int IPC_GETMLWINDOW, IPC_LIBRARY_SENDTOMENU, IPC_GET_ML_HMENU;
int config_use_ff_scrollbars=1, config_use_alternate_colors=0;
LARGE_INTEGER freq;
C_Config *g_config;
embedWindowState myWindowState;
prefsDlgRecW myPrefsItem, myPrefsItemPlug;
DEFINE_EXTERNAL_SERVICE(api_service, WASABI_API_SVC);
DEFINE_EXTERNAL_SERVICE(api_application, WASABI_API_APP);
DEFINE_EXTERNAL_SERVICE(api_language, WASABI_API_LNG);
DEFINE_EXTERNAL_SERVICE(obj_ombrowser, AGAVE_OBJ_BROWSER);
DEFINE_EXTERNAL_SERVICE(api_mldb, AGAVE_API_MLDB);
DEFINE_EXTERNAL_SERVICE(api_syscb, WASABI_API_SYSCB);
DEFINE_EXTERNAL_SERVICE(api_threadpool, AGAVE_API_THREADPOOL);
DEFINE_EXTERNAL_SERVICE(api_decodefile, AGAVE_API_DECODE);
DEFINE_EXTERNAL_SERVICE(wnd_api, WASABI_API_WND);
DEFINE_EXTERNAL_SERVICE(api_skin, WASABI_API_SKIN);
DEFINE_EXTERNAL_SERVICE(api_config, AGAVE_API_CONFIG);
DEFINE_EXTERNAL_SERVICE(api_palette, WASABI_API_PALETTE);
#ifndef IGNORE_API_GRACENOTE
DEFINE_EXTERNAL_SERVICE(api_gracenote, AGAVE_API_GRACENOTE);
#endif
DEFINE_EXTERNAL_SERVICE(JSAPI2::api_security, AGAVE_API_JSAPI2_SECURITY);
ifc_configitem *ieDisableSEH = 0;
// wasabi based services for localisation support
HINSTANCE WASABI_API_LNG_HINST = 0, WASABI_API_ORIG_HINST = 0;
static ServiceWatcher serviceWatcher;
#ifndef IGNORE_API_GRACENOTE
MusicIDCOM musicIDCOM;
#endif
void config();
void quit();
int init();
BOOL init2(void);
extern "C"
{
HWND g_hwnd, g_ownerwnd;
extern winampGeneralPurposePlugin plugin =
{
GPPHDR_VER_U,
"nullsoft(gen_ml.dll)",
init,
config,
quit,
};
};
HWND g_PEWindow;
HMENU wa_main_menu = NULL;
HMENU wa_windows_menu = NULL;
HMENU wa_playlists_cmdmenu = NULL;
HMENU last_playlistsmenu = NULL;
HMENU last_viewmenu = NULL;
int last_viewmenu_insert = 0;
int g_safeMode = 0, sneak = 0;
HCURSOR hDragNDropCursor;
int profile = 0;
wchar_t pluginPath[MAX_PATH] = {0};
static wchar_t preferencesName[128];
HMENU g_context_menus;
extern C_ItemList m_plugins;
extern HNAVCTRL hNavigation;
//xp theme disabling shit
static HMODULE m_uxdll;
HRESULT (__stdcall *SetWindowTheme)(HWND hwnd, LPCWSTR pszSubAppName, LPCWSTR pszSubIdList);
BOOL (__stdcall *IsAppThemed)(void);
template <class api_T>
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>
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;
}
bool IsVisible()
{
return g_hwnd && IsWindowVisible(g_ownerwnd);
}
void MLVisibleChanged(BOOL fVisible)
{
static BOOL visible = FALSE;
if (fVisible != visible)
{
visible = fVisible;
plugin_SendMessage(ML_MSG_MLVISIBLE, visible, 0, 0);
}
}
BOOL MlWindow_SetMinimizedMode(BOOL fMinimized)
{
if (FALSE != fMinimized)
return SetPropW(g_ownerwnd, L"MLWindow_MinimizedMode", (HANDLE)1);
RemovePropW(g_ownerwnd, L"MLWindow_MinimizedMode");
return TRUE;
}
BOOL MlWindow_IsMinimizedMode(void)
{
return (0 != GetPropW(g_ownerwnd, L"MLWindow_MinimizedMode"));
}
void toggleVisible(int closecb)
{
BOOL fVisible, fMinimized;
HWND rootWindow;
fVisible = (0 != (WS_VISIBLE & GetWindowLongPtrW(g_ownerwnd, GWL_STYLE)));//IsWindowVisible(g_ownerwnd);
rootWindow = GetAncestor(g_ownerwnd, GA_ROOT);
if (NULL == rootWindow || rootWindow == g_ownerwnd)
{
rootWindow = (HWND)(HWND)SENDWAIPC(plugin.hwndParent, IPC_GETDIALOGBOXPARENT, 0);
if (NULL == rootWindow)
rootWindow = plugin.hwndParent;
}
fMinimized = IsIconic(rootWindow);
if (FALSE != fVisible || 1 == closecb)
{
if (FALSE == fMinimized && FALSE != fVisible)
{
HWND hwndFocus = GetFocus();
if (hwndFocus == g_ownerwnd || IsChild(g_ownerwnd, hwndFocus))
SendMessageW(plugin.hwndParent, WM_COMMAND, WINAMP_NEXT_WINDOW, 0);
ShowWindow(g_ownerwnd, SW_HIDE);
}
}
else
{
if (init2() && FALSE == fMinimized && FALSE == fVisible)
{
ShowWindow(g_ownerwnd, SW_SHOWNORMAL);
// make sure that we focus the tree to work around some modern skin quirks
if(closecb != 2)
{
SetFocus(NavCtrlI_GetHWND(hNavigation));
}
else
{
// delay the focusing on loading as some machines are too fast and
// may cause the wrong view to the selected (root instead of child)
PostMessage(g_ownerwnd,WM_ML_IPC,0,ML_IPC_FOCUS_TREE);
}
}
}
if (FALSE != fMinimized && 1 != closecb)
{
MlWindow_SetMinimizedMode(TRUE);
if (NULL != g_config)
g_config->WriteInt(L"visible", (FALSE == fVisible));
UINT menuFlags = (FALSE == fVisible) ? MF_CHECKED : MF_UNCHECKED;
menuFlags |= MF_BYCOMMAND;
INT szMenu[] = { 0, 4, };
for (INT i = 0; i < ARRAYSIZE(szMenu); i++)
{
HMENU hMenu = (HMENU)SendMessage(plugin.hwndParent, WM_WA_IPC, szMenu[i], IPC_GET_HMENU);
if (NULL != hMenu)
CheckMenuItem(hMenu, WA_MENUITEM_ID, menuFlags);
}
}
}
static WNDPROC wa_oldWndProc;
static BOOL Winamp_OnIPC(HWND hwnd, UINT uMsg, INT_PTR param, LRESULT *pResult)
{
if (IPC_GETMLWINDOW == uMsg && IPC_GETMLWINDOW > 65536)
{
if (param == -1 && !g_hwnd) init2();
*pResult = (LRESULT)g_hwnd;
return TRUE;
}
else if (IPC_LIBRARY_SENDTOMENU == uMsg && IPC_LIBRARY_SENDTOMENU > 65536)
{
librarySendToMenuStruct *s = (librarySendToMenuStruct*)param;
if (!s || s->mode == 0)
{
*pResult = 0xFFFFFFFF;
return TRUE;
}
if (s->mode == 1)
{
if (!s->ctx[0])
{
if (!g_hwnd) init2();
SendToMenu *stm = new SendToMenu();
if (s->build_start_id && s->build_end_id)
{
stm->buildmenu(s->build_hMenu, s->data_type, s->ctx[1], s->ctx[2], s->build_start_id, s->build_end_id);
}
else
{
stm->buildmenu(s->build_hMenu, s->data_type, s->ctx[1], s->ctx[2]);
}
s->ctx[0] = (intptr_t)stm;
*pResult = 0xFFFFFFFF;
return TRUE;
}
}
else if (s->mode == 2)
{
SendToMenu *stm = (SendToMenu *)s->ctx[0];
if (stm && stm->isourcmd(s->menu_id))
{
*pResult = 0xFFFFFFFF;
return TRUE;
}
}
else if (s->mode == 3)
{
SendToMenu *stm = (SendToMenu *)s->ctx[0];
if (stm)
{
*pResult = stm->handlecmd(s->hwnd, s->menu_id, s->data_type, s->data);
return TRUE;
}
}
else if (s->mode == 4)
{
delete (SendToMenu *)s->ctx[0];
s->ctx[0] = 0;
}
*pResult = TRUE;
return TRUE;
}
else if (IPC_GET_ML_HMENU == uMsg && IPC_GET_ML_HMENU > 65536)
{
*pResult = (LRESULT)g_context_menus;
return TRUE;
}
switch(uMsg)
{
case IPC_CB_RESETFONT:
PostMessageW(g_hwnd, WM_DISPLAYCHANGE, 0, 0);
break;
case IPC_CB_GETTOOLTIPW:
if (param == 16 && g_config->ReadInt(L"attachlbolt", 0))
{
static wchar_t tlStr[64];
*pResult = (LRESULT)WASABI_API_LNGSTRINGW_BUF(IDS_TOGGLE_LIBRARY,tlStr,64);
return TRUE;
}
break;
case IPC_GET_EXTENDED_FILE_INFO_HOOKABLE:
if (!m_calling_getfileinfo)
{
extendedFileInfoStruct *extendedInfo;
extendedInfo = (extendedFileInfoStruct*)param;
if (NULL != extendedInfo &&
NULL != extendedInfo->filename &&
NULL != extendedInfo->metadata)
{
if (plugin_SendMessage(ML_IPC_HOOKEXTINFO, param, 0, 0))
{
*pResult = 1;
return TRUE;
}
}
}
break;
case IPC_GET_EXTENDED_FILE_INFOW_HOOKABLE:
if (!m_calling_getfileinfo)
{
extendedFileInfoStructW *extendedInfo;
extendedInfo = (extendedFileInfoStructW*)param;
if (NULL != extendedInfo &&
NULL != extendedInfo->filename &&
NULL != extendedInfo->metadata)
{
if (plugin_SendMessage(ML_IPC_HOOKEXTINFOW, param, 0, 0))
{
*pResult = 1;
return TRUE;
}
}
}
break;
case IPC_HOOK_TITLES:
if (NULL != param)
{
waHookTitleStruct *hookTitle;
hookTitle = (waHookTitleStruct*)param;
if (NULL != hookTitle->filename &&
plugin_SendMessage(ML_IPC_HOOKTITLE, param, 0, 0))
{
*pResult = 1;
return TRUE;
}
}
break;
case IPC_HOOK_TITLESW:
if (NULL != param)
{
waHookTitleStructW *hookTitle;
hookTitle = (waHookTitleStructW*)param;
if (NULL != hookTitle->filename &&
plugin_SendMessage(ML_IPC_HOOKTITLEW, param, 0, 0))
{
*pResult = 1;
return TRUE;
}
}
break;
case IPC_ADD_PREFS_DLG:
case IPC_ADD_PREFS_DLGW:
if (param && !((prefsDlgRec*)param)->where)
{
prefsDlgRec *p = (prefsDlgRec *)param;
// we use the dialog proc for the preferences to determine the hinstance of the module and
// use that to then determine if we set it as a child of the media library preference node
// it also handles localised versions of the preference pages as the dialog proceedure is
// going to be in the true plug-in dll and so can be matched to the main ml plugins list!
MEMORY_BASIC_INFORMATION mbi = {0};
if(VirtualQuery(p->proc, &mbi, sizeof(mbi)))
{
int i = m_plugins.GetSize();
while (i-- > 0)
{
winampMediaLibraryPlugin *mlplugin = (winampMediaLibraryPlugin *)m_plugins.Get(i);
if (mlplugin->hDllInstance == (HINSTANCE)mbi.AllocationBase)
{
p->where = (intptr_t)(INT_PTR)&myPrefsItem;
break;
}
}
}
}
break;
case IPC_CB_ONSHOWWND:
if ((HWND)param == g_ownerwnd) MLVisibleChanged(TRUE);
break;
case IPC_HOOK_OKTOQUIT:
{
if (plugin_SendMessage(ML_MSG_NOTOKTOQUIT, 0, 0, 0))
{
*pResult = 0;
return TRUE;
}
}
break;
case IPC_PLAYING_FILEW:
plugin_SendMessage(ML_MSG_PLAYING_FILE, param, 0, 0);
break;
case IPC_WRITECONFIG:
plugin_SendMessage(ML_MSG_WRITE_CONFIG, param, 0, 0);
break;
}
return FALSE;
}
static LRESULT WINAPI wa_newWndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
// far from ideal fix but deals with differing plugin load orders (mainly from FAT32 drives)
// and not being able to unload/clean up properly the scrollbar bitmaps used - DRO 29/09/07
case WM_CLOSE:
SkinnedScrollWnd_Quit();
break;
case WM_WA_IPC:
{
LRESULT result = 0;
if (Winamp_OnIPC(hwndDlg, (UINT)lParam, (INT_PTR)wParam, &result)) return result;
break;
}
case WM_SIZE:
if (wParam == SIZE_RESTORED)
{
if (FALSE != MlWindow_IsMinimizedMode())
{
MlWindow_SetMinimizedMode(FALSE);
int showCommand = (0 != g_config->ReadInt(L"visible", 1)) ? SW_SHOWNA : SW_HIDE;
ShowWindow(g_ownerwnd, showCommand);
}
}
break;
case WM_COMMAND:
case WM_SYSCOMMAND:
{
WORD lowP = LOWORD(wParam);
if (lowP == WA_MENUITEM_ID || lowP == WINAMP_LIGHTNING_CLICK)
{
if (lowP != WINAMP_LIGHTNING_CLICK || g_config->ReadInt(L"attachlbolt", 0))
{
toggleVisible();
return 0;
}
}
#if 0 // no radio - don't delete yet - tag will need to do this in ml_online
else if (lowP == WINAMP_VIDEO_TVBUTTON) // && g_config->ReadInt("attachtv",1))
{
if (!g_hwnd || !IsWindowVisible(g_ownerwnd)) toggleVisible();
PostMessage(g_ownerwnd, WM_NEXTDLGCTL, (WPARAM)g_hwnd, TRUE);
HWND hwndTree = GetTreeHWND(g_hwnd);
HTREEITEM hti = findByParam(hwndTree, TREE_INTERNET_VIDEO, TVI_ROOT);
if (hti)
{
TreeView_SelectItem(hwndTree, hti);
return 0;
}
}
#endif
// done like this since ml_online can't really subclass winamp to get the notification
else if (lowP == WINAMP_VIDEO_TVBUTTON)
{
if (!g_hwnd || !IsWindowVisible(g_ownerwnd)) toggleVisible();
HNAVITEM hDefItem = NavCtrlI_FindItemByName(hNavigation, LOCALE_USER_DEFAULT, NICF_INVARIANT_I | NICF_DISPLAY_I | NICF_IGNORECASE_I, L"Shoutcast TV", -1);
if(!hDefItem)
{
// work with the localised version of the Online Services root (if there...)
wchar_t OSName[64] = {L"Online Services"};
WASABI_API_LNG->GetStringFromGUIDW(MlOnlineLangGUID,WASABI_API_ORIG_HINST,1,OSName,64);
// just incase the localised dll was there but the file was missing the translation
if(!lstrcmpiW(OSName,L"Error loading string"))
lstrcpynW(OSName,L"Online Services",64);
hDefItem = NavCtrlI_FindItemByName(hNavigation, LOCALE_USER_DEFAULT, NICF_INVARIANT_I | NICF_DISPLAY_I | NICF_IGNORECASE_I, OSName, -1);
}
if (hDefItem)
{
NavItemI_Select(hDefItem);
NavCtrlI_Show(hNavigation, SW_SHOWNA);
}
else
{
wchar_t titleStr[128] = {0};
MessageBoxW(hwndDlg,WASABI_API_LNGSTRINGW(IDS_ONLINE_SERVICES_NOT_PRESENT),
WASABI_API_LNGSTRINGW_BUF(IDS_ERROR_SWITCHING_TO_VIEW,titleStr,128),0);
}
return 0;
}
if (lowP == WINAMP_SHOWLIBRARY)
{
if (!g_hwnd || !IsWindowVisible(g_hwnd))
toggleVisible((2 == HIWORD(wParam) ? 2 : 0));
}
else if (lowP == WINAMP_CLOSELIBRARY)
{
if (g_hwnd && IsWindowVisible(g_ownerwnd)) toggleVisible();
}
}
break;
case WM_DWMCOMPOSITIONCHANGED:
if (IsWindow(g_hwnd)) PostMessageW(g_hwnd, WM_DWMCOMPOSITIONCHANGED, 0, 0L);
break;
}
return CallWindowProcW(wa_oldWndProc, hwndDlg, uMsg, wParam, lParam);
}
INT_PTR CALLBACK dialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
BOOL init2(void)
{
if (!g_hwnd)
{
WADlg_init(plugin.hwndParent);
//xp theme disabling shit
m_uxdll = LoadLibraryA("uxtheme.dll");
if (m_uxdll)
{
IsAppThemed = (BOOL (__stdcall *)(void))GetProcAddress(m_uxdll, "IsAppThemed");
SetWindowTheme = (HRESULT (__stdcall *)(struct HWND__ *, LPCWSTR , LPCWSTR ))GetProcAddress(m_uxdll, "SetWindowTheme");
}
else
{
IsAppThemed = NULL;
SetWindowTheme = NULL;
}
g_context_menus = WASABI_API_LOADMENU(IDR_CONTEXTMENUS);
// 02/11/08 DrO
// defaults were 100,100,500,400 and not visible but these now make it align when opened under
// a clean install starting with a classic skin and is also visible on start now as with modern
myWindowState.r.left = g_config->ReadInt(L"mw_xpos", 301);
myWindowState.r.top = g_config->ReadInt(L"mw_ypos", 29);
myWindowState.r.right = myWindowState.r.left + g_config->ReadInt(L"mw_width", 500);
myWindowState.r.bottom = myWindowState.r.top + g_config->ReadInt(L"mw_height", 348);
SET_EMBED_GUID((&myWindowState), library_guid);
g_ownerwnd = (HWND)SendMessage(plugin.hwndParent, WM_WA_IPC, (LPARAM) & myWindowState, IPC_GET_EMBEDIF);
if (!g_ownerwnd) return FALSE;
if (NULL != WASABI_API_APP) WASABI_API_APP->app_registerGlobalWindow(g_ownerwnd);
SetWindowTextW(g_ownerwnd, WASABI_API_LNGSTRINGW(IDS_WINAMP_LIBRARY));
g_hwnd = WASABI_API_CREATEDIALOGW(IDD_MAIN, g_ownerwnd, dialogProc);
if (!g_hwnd)
{
DestroyWindow(g_ownerwnd);
g_ownerwnd = NULL;
return FALSE;
}
}
return TRUE;
}
wchar_t WINAMP_INI[MAX_PATH] = {0}, WINAMP_INI_DIR[MAX_PATH] = {0};
MediaLibraryCOM mediaLibraryCOM;
IDispatch *winampExternal = 0;
void TAG_FMT_EXT(const wchar_t *filename, void *f, void *ff, void *p, wchar_t *out, int out_len, int extended)
{
waFormatTitleExtended fmt;
fmt.filename=filename;
fmt.useExtendedInfo=extended;
fmt.out = out;
fmt.out_len = out_len;
fmt.p = p;
fmt.spec = 0;
*(void **)&fmt.TAGFUNC = f;
*(void **)&fmt.TAGFREEFUNC = ff;
*out = 0;
int oldCallingGetFileInfo=m_calling_getfileinfo;
m_calling_getfileinfo=1;
SendMessage(plugin.hwndParent, WM_WA_IPC, (WPARAM)&fmt, IPC_FORMAT_TITLE_EXTENDED);
m_calling_getfileinfo=oldCallingGetFileInfo;
}
wchar_t *itemrecordTagFunc(wchar_t *tag, void * p) //return 0 if not found
{
itemRecord *t = (itemRecord *)p;
char buf[128] = {0};
char *value = NULL;
if (!_wcsicmp(tag, L"artist")) value = t->artist;
else if (!_wcsicmp(tag, L"album")) value = t->album;
else if (!_wcsicmp(tag, L"filename")) value = t->filename;
else if (!_wcsicmp(tag, L"title")) value = t->title;
else if ( !_wcsicmp( tag, L"ext" ) ) value = t->ext;
else if (!_wcsicmp(tag, L"year"))
{
if (t->year > 0)
{
StringCchPrintfA(buf, 128, "%04d", t->year);
value = buf;
}
}
else if (!_wcsicmp(tag, L"genre")) value = t->genre;
else if (!_wcsicmp(tag, L"comment")) value = t->comment;
else if (!_wcsicmp(tag, L"tracknumber") || !_wcsicmp(tag, L"track"))
{
if (t->track > 0)
{
StringCchPrintfA(buf, 128, "%02d", t->track);
value = buf;
}
}
else if (!_wcsicmp(tag, L"rating")) value = getRecordExtendedItem(t, "RATING");
else if (!_wcsicmp(tag, L"playcount")) value = getRecordExtendedItem(t, "PLAYCOUNT");
else if (!_wcsicmp(tag, L"bitrate")) value = getRecordExtendedItem(t, "BITRATE");
else
return 0;
if (!value) return reinterpret_cast<wchar_t *>(-1);
else return AutoWideDup(value);
}
wchar_t *itemrecordWTagFunc(wchar_t *tag, void * p) //return 0 if not found
{
itemRecordW *t = (itemRecordW *)p;
wchar_t buf[128] = {0};
wchar_t *value = NULL;
// TODO: more fields
if (!_wcsicmp(tag, L"artist")) value = t->artist;
else if (!_wcsicmp(tag, L"album")) value = t->album;
else if (!_wcsicmp(tag, L"albumartist")) value = t->albumartist;
else if (!_wcsicmp(tag, L"category")) value = t->category;
else if (!_wcsicmp(tag, L"comment")) value = t->comment;
else if (!_wcsicmp(tag, L"composer")) value = t->composer;
else if (!_wcsicmp(tag, L"publisher")) value = t->publisher;
else if (!_wcsicmp(tag, L"filename")) value = t->filename;
else if (!_wcsicmp(tag, L"title")) value = t->title;
else if (!_wcsicmp(tag, L"year"))
{
if (t->year > 0)
{
StringCchPrintfW(buf, 128, L"%04d", t->year);
value = buf;
}
}
else if (!_wcsicmp(tag, L"genre")) value = t->genre;
else if (!_wcsicmp(tag, L"comment")) value = t->comment;
else if (!_wcsicmp(tag, L"tracknumber") || !_wcsicmp(tag, L"track"))
{
if (t->track > 0)
{
StringCchPrintfW(buf, 128, L"%02d", t->track);
value = buf;
}
}
else if (!_wcsicmp(tag, L"rating"))
{
if (t->rating > 0)
{
StringCchPrintfW(buf, 128, L"%d", t->rating);
value = buf;
}
}
else if (!_wcsicmp(tag, L"playcount"))
{
if (t->playcount > 0)
{
StringCchPrintfW(buf, 128, L"%d", t->playcount);
value = buf;
}
}
else if (!_wcsicmp(tag, L"bitrate"))
{
if (t->bitrate > 0)
{
StringCchPrintfW(buf, 128, L"%d", t->bitrate);
value = buf;
}
}
else
return 0;
if (!value) return reinterpret_cast<wchar_t *>(-1);
else return _wcsdup(value);
}
void fieldTagFuncFree(wchar_t * tag, void * p)
{
free(tag);
}
void main_playItemRecordList(itemRecordList *obj, int enqueue, int startplaying)
{
if (obj->Size && !enqueue) SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_DELETE);
int x;
wchar_t title[2048]=L"";
for (x = 0; x < obj->Size; x ++)
{
if (obj->Items[x].filename && *obj->Items[x].filename)
{
AutoWideFn wfn( obj->Items[ x ].filename );
TAG_FMT_EXT(wfn, itemrecordTagFunc, fieldTagFuncFree, (void*)&obj->Items[x], title, 2048, 1);
{
enqueueFileWithMetaStructW s;
s.filename = wfn;
s.title = title;
s.ext = NULL;
s.length = obj->Items[x].length;
SendMessage(plugin.hwndParent, WM_WA_IPC, (WPARAM)&s, IPC_PLAYFILEW);
}
}
}
if (obj->Size && !enqueue && startplaying) SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_STARTPLAY);
}
void main_playItemRecordListW(itemRecordListW *obj, int enqueue, int startplaying)
{
if (obj->Size && !enqueue) SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_DELETE);
int x;
wchar_t title[2048]=L"";
for (x = 0; x < obj->Size; x ++)
{
if (obj->Items[x].filename && *obj->Items[x].filename)
{
TAG_FMT_EXT(obj->Items[x].filename, itemrecordWTagFunc, fieldTagFuncFree, (void*)&obj->Items[x], title, 2048, 1);
{
enqueueFileWithMetaStructW s;
s.filename = obj->Items[x].filename;
s.title = title;
s.ext = NULL;
s.length = obj->Items[x].length;
SendMessage(plugin.hwndParent, WM_WA_IPC, (WPARAM)&s, IPC_PLAYFILEW);
}
}
}
if (obj->Size && !enqueue && startplaying) SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_STARTPLAY);
}
void OpenMediaLibraryPreferences()
{
SendMessage(plugin.hwndParent, WM_WA_IPC, (WPARAM)&myPrefsItem, IPC_OPENPREFSTOPAGE);
}
int AddTreeImageBmp(int resourceId)
{
HMLIMGLST hmlilNavigation = MLNavCtrl_GetImageList(g_hwnd);
MLIMAGESOURCE mlis = {sizeof(MLIMAGESOURCE),0};
MLIMAGELISTITEM item = {0};
item.cbSize = sizeof(MLIMAGELISTITEM);
item.hmlil = hmlilNavigation;
item.filterUID = MLIF_FILTER1_UID;
item.pmlImgSource = &mlis;
mlis.hInst = WASABI_API_ORIG_HINST;
mlis.bpp = 24;
mlis.lpszName = MAKEINTRESOURCEW(resourceId);
mlis.type = SRC_TYPE_BMP;
mlis.flags = ISF_FORCE_BPP;
return MLImageList_Add(g_hwnd, &item);
}
void SkinnedScrollWnd_Init();
void SkinnedScrollWnd_Quit();
int init()
{
wchar_t g_path[MAX_PATH] = {0};
QueryPerformanceFrequency(&freq);
WASABI_API_SVC = (api_service*)SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_GET_API_SERVICE);
if (!WASABI_API_SVC || WASABI_API_SVC == (api_service *)1)
return GEN_INIT_FAILURE;
HTMLContainer2_Initialize();
Tataki::Init(WASABI_API_SVC);
// loader so that we can get the localisation service api for use
ServiceBuild(WASABI_API_LNG, languageApiGUID);
ServiceBuild(WASABI_API_SYSCB, syscbApiServiceGuid);
ServiceBuild(AGAVE_API_DECODE, decodeFileGUID);
ServiceBuild(AGAVE_API_JSAPI2_SECURITY, JSAPI2::api_securityGUID);
ServiceBuild(AGAVE_OBJ_BROWSER, OBJ_OmBrowser);
#ifndef IGNORE_API_GRACENOTE
ServiceBuild(AGAVE_API_GRACENOTE, gracenoteApiGUID);
#endif
ServiceBuild(WASABI_API_APP, applicationApiServiceGuid);
ServiceBuild(AGAVE_API_CONFIG, AgaveConfigGUID);
ServiceBuild(WASABI_API_PALETTE, PaletteManagerGUID);
ServiceBuild(AGAVE_API_THREADPOOL, ThreadPoolGUID);
// no guarantee that AGAVE_API_MLDB will be available yet, so we'll start a watcher for it
serviceWatcher.WatchWith(WASABI_API_SVC);
serviceWatcher.WatchFor(&AGAVE_API_MLDB, mldbApiGuid);
serviceWatcher.WatchFor(&WASABI_API_SKIN, skinApiServiceGuid);
serviceWatcher.WatchFor(&WASABI_API_WND,wndApiServiceGuid);
WASABI_API_SYSCB->syscb_registerCallback(&serviceWatcher);
SkinnedScrollWnd_Init();
// need to have this initialised before we try to do anything with localisation features
WASABI_API_START_LANG(plugin.hDllInstance,GenMlLangGUID);
// Build plugin description string...
static wchar_t szDescription[256];
StringCchPrintfW(szDescription, ARRAYSIZE(szDescription),
WASABI_API_LNGSTRINGW(IDS_NULLSOFT_ML_STR),
LOWORD(PLUGIN_VERSION) >> 8,
PLUGIN_VERSION & 0xFF);
plugin.description = (char*)szDescription;
DispatchInfo dispatchInfo;
dispatchInfo.name = L"MediaLibrary";
dispatchInfo.dispatch = &mediaLibraryCOM;
SendMessage(plugin.hwndParent, WM_WA_IPC, (WPARAM)&dispatchInfo, IPC_ADD_DISPATCH_OBJECT);
#ifndef IGNORE_API_GRACENOTE
dispatchInfo.name = L"MusicID";
dispatchInfo.dispatch = &musicIDCOM;
SendMessage(plugin.hwndParent, WM_WA_IPC, (WPARAM)&dispatchInfo, IPC_ADD_DISPATCH_OBJECT);
#endif
IPC_LIBRARY_SENDTOMENU = (INT)SendMessage(plugin.hwndParent, WM_WA_IPC, (WPARAM)&"LibrarySendToMenu", IPC_REGISTER_WINAMP_IPCMESSAGE);
IPC_GETMLWINDOW = (INT)SendMessage(plugin.hwndParent, WM_WA_IPC, (WPARAM)&"LibraryGetWnd", IPC_REGISTER_WINAMP_IPCMESSAGE);
IPC_GET_ML_HMENU = (INT)SendMessage(plugin.hwndParent, WM_WA_IPC, (WPARAM)&"LibraryGetHmenu", IPC_REGISTER_WINAMP_IPCMESSAGE);
lstrcpynW(WINAMP_INI, (wchar_t*)SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_GETINIFILEW), MAX_PATH);
lstrcpynW(WINAMP_INI_DIR, (wchar_t*)SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_GETINIDIRECTORYW), MAX_PATH);
PathCombineW(g_path, WINAMP_INI_DIR, L"Plugins");
CreateDirectoryW(g_path, NULL);
wchar_t *dir = (wchar_t*)SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_GETPLUGINDIRECTORYW);
if (dir == (wchar_t *)1 || dir == 0)
lstrcpynW(pluginPath, g_path, MAX_PATH);
else
lstrcpynW(pluginPath, dir, MAX_PATH);
hDragNDropCursor = LoadCursor(plugin.hDllInstance, MAKEINTRESOURCE(ML_IDC_DRAGDROP));
profile = GetPrivateProfileIntW(L"winamp", L"profile", 0, WINAMP_INI);
wchar_t configName[1024 + 32] = {0};
StringCchPrintfW(configName, 1024 + 32, L"%s\\gen_ml.ini", g_path);
g_config = new C_Config(configName);
config_use_ff_scrollbars = g_config->ReadInt(L"ffsb", 1);
config_use_alternate_colors = g_config->ReadInt(L"alternate_items", 1);
int vis = g_config->ReadInt(L"visible", 1);
wa_main_menu = (HMENU)SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_GET_HMENU);
wa_windows_menu = (HMENU)SendMessage(plugin.hwndParent, WM_WA_IPC, 4, IPC_GET_HMENU);
wa_playlists_cmdmenu = NULL;
if (wa_main_menu || wa_windows_menu)
{
if (wa_main_menu)
{
MENUITEMINFOW i = {sizeof(i), MIIM_ID | MIIM_STATE | MIIM_TYPE, MFT_STRING, vis ? (UINT)MFS_CHECKED : 0, WA_MENUITEM_ID};
int prior_item = GetMenuItemID(wa_main_menu,9);
if(prior_item <= 0) prior_item = GetMenuItemID(wa_main_menu,8);
i.dwTypeData = WASABI_API_LNGSTRINGW(IDS_ML_ALT_L_SHORTCUT);
// append before the video menu entry (more reliable than inserting into position '9' in the menu
InsertMenuItemW(wa_main_menu, prior_item, FALSE, &i);
SendMessage(plugin.hwndParent, WM_WA_IPC, 1, IPC_ADJUST_OPTIONSMENUPOS);
}
if (wa_windows_menu)
{
MENUITEMINFOW i = {sizeof(i), MIIM_ID | MIIM_STATE | MIIM_TYPE, MFT_STRING, vis ? (UINT)MFS_CHECKED : 0, WA_MENUITEM_ID};
int prior_item = GetMenuItemID(wa_windows_menu,3);
if(prior_item <= 0) prior_item = GetMenuItemID(wa_windows_menu,2);
i.dwTypeData = WASABI_API_LNGSTRINGW(IDS_ML_ALT_L_SHORTCUT);
InsertMenuItemW(wa_windows_menu, prior_item, FALSE, &i);
SendMessage(plugin.hwndParent, WM_WA_IPC, 1, IPC_ADJUST_FFWINDOWSMENUPOS);
}
}
// subclass the winamp window to get our leet menu item to work
wa_oldWndProc = (WNDPROC)(LONG_PTR)SetWindowLongPtrW(plugin.hwndParent, GWLP_WNDPROC, (LONGX86)(LONG_PTR)wa_newWndProc);
myPrefsItem.dlgID = IDD_PREFSFR;
myPrefsItem.name = WASABI_API_LNGSTRINGW_BUF(IDS_MEDIA_LIBRARY,preferencesName,128);
myPrefsItem.proc = (void*)PrefsProc;
myPrefsItem.hInst = WASABI_API_LNG_HINST;
myPrefsItem.where = -6; // to become root based item
SendMessage(plugin.hwndParent, WM_WA_IPC, (WPARAM)&myPrefsItem, IPC_ADD_PREFS_DLGW);
myPrefsItemPlug.dlgID = IDD_MLPLUGINS;
myPrefsItemPlug.name = preferencesName;
myPrefsItemPlug.proc = (void*)PluginsProc;
myPrefsItemPlug.hInst = WASABI_API_LNG_HINST;
myPrefsItemPlug.where = 1;
SendMessage(plugin.hwndParent, WM_WA_IPC, (WPARAM)&myPrefsItemPlug, IPC_ADD_PREFS_DLGW);
g_PEWindow = (HWND)SendMessage(plugin.hwndParent, WM_WA_IPC, IPC_GETWND_PE, IPC_GETWND);
g_safeMode = SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_IS_SAFEMODE);
// we're gonna go ahead and make this directory just to be safe.
// if a plugin tries to use it as an INI directory but it doesn't exist, things go wrong
wchar_t mldir[MAX_PATH] = {0};
PathCombineW(mldir, g_path, L"ml");
CreateDirectoryW(mldir, NULL);
PathCombineW(mldir, mldir, L"views");
CreateDirectoryW(mldir, NULL);
//add general hotkey
int m_genhotkeys_add_ipc = (INT)SendMessage(plugin.hwndParent, WM_WA_IPC, (WPARAM)&"GenHotkeysAdd", IPC_REGISTER_WINAMP_IPCMESSAGE);
static genHotkeysAddStruct ghas = {
(char*)_wcsdup(WASABI_API_LNGSTRINGW(IDS_ML_GHK_STR)),
HKF_BRING_TO_FRONT|HKF_UNICODE_NAME,
WM_COMMAND,
WA_MENUITEM_ID,
0,
// specifically set the id str now so that it'll work correctly with whatever lngpack is in use
"ML: Show/Hide Media Library"
};
if (m_genhotkeys_add_ipc > 65536) PostMessage(plugin.hwndParent, WM_WA_IPC, (WPARAM)&ghas, m_genhotkeys_add_ipc); //post so gen_hotkeys will catch it if not inited yet
init2();
// register the art view window classes
{
extern void InitSmoothScrollList();
extern void InitHeaderIconList();
InitSmoothScrollList();
InitHeaderIconList();
RegisterFolderBrowserControl(plugin.hDllInstance);
}
NavCtrlI_BeginUpdate(hNavigation, NUF_LOCK_NONE_I);
loadMlPlugins();
#if 0
#ifdef _DEBUG
#define BETA
#endif
#ifdef BETA
sneak = GetPrivateProfileIntW(L"winamp", L"sneak", 0, WINAMP_INI);
if (!(sneak & 1))
{
NAVINSERTSTRUCT nis = {0};
nis.item.cbSize = sizeof(NAVITEM);
nis.item.pszText = L"Winamp Labs";
nis.item.pszInvariant = L"winamp_labs";
nis.item.mask = NIMF_TEXT | NIMF_TEXTINVARIANT | NIMF_IMAGE | NIMF_IMAGESEL | NIMF_STYLE;
nis.item.iImage = nis.item.iSelectedImage = AddTreeImageBmp(IDB_TREEITEM_LABS);
nis.item.style = NIS_BOLD;
nis.hInsertAfter = NCI_FIRST;
NAVITEM nvItem = {sizeof(NAVITEM),0,NIMF_ITEMID,};
nvItem.hItem = MLNavCtrl_InsertItem(g_hwnd, &nis);
}
#endif
#endif
NavCtrlI_EndUpdate(hNavigation);
if (SW_SHOWMINIMIZED == SENDWAIPC(plugin.hwndParent, IPC_INITIAL_SHOW_STATE, 0))
{
MlWindow_SetMinimizedMode(TRUE);
}
else if (0 != vis)
{
PostMessageW(plugin.hwndParent, WM_COMMAND, MAKEWPARAM(WINAMP_SHOWLIBRARY, 2), 0L);
}
return GEN_INIT_SUCCESS;
}
void quit()
{
serviceWatcher.StopWatching();
serviceWatcher.Clear();
MlWindow_SetMinimizedMode(FALSE);
if (g_ownerwnd)
{
g_config->WriteInt(L"mw_xpos", myWindowState.r.left);
g_config->WriteInt(L"mw_ypos", myWindowState.r.top);
g_config->WriteInt(L"mw_width", myWindowState.r.right - myWindowState.r.left);
g_config->WriteInt(L"mw_height", myWindowState.r.bottom - myWindowState.r.top);
if (NULL != WASABI_API_APP) WASABI_API_APP->app_unregisterGlobalWindow(g_ownerwnd);
DestroyWindow(g_ownerwnd);
g_ownerwnd = NULL;
}
// unload any services from ml_ plugins before unloading the plugins
ServiceRelease(AGAVE_API_MLDB, mldbApiGuid);
#ifndef IGNORE_API_GRACENOTE
musicIDCOM.Quit();
#endif
unloadMlPlugins();
WADlg_close();
if (g_config)
{
delete g_config;
g_config = NULL;
}
if (m_uxdll)
{
FreeLibrary(m_uxdll);
m_uxdll = NULL;
}
SkinnedScrollWnd_Quit();
#ifndef IGNORE_API_GRACENOTE
ServiceRelease(AGAVE_API_GRACENOTE, gracenoteApiGUID);
#endif
ServiceRelease(WASABI_API_SYSCB, syscbApiServiceGuid);
ServiceRelease(AGAVE_API_DECODE, decodeFileGUID);
ServiceRelease(AGAVE_API_JSAPI2_SECURITY, JSAPI2::api_securityGUID);
ServiceRelease(AGAVE_OBJ_BROWSER, OBJ_OmBrowser);
ServiceRelease(WASABI_API_LNG, languageApiGUID);
ServiceRelease(WASABI_API_WND, wndApiServiceGuid);
ServiceRelease(WASABI_API_SKIN, skinApiServiceGuid);
ServiceRelease(WASABI_API_APP, applicationApiServiceGuid);
ServiceRelease(AGAVE_API_CONFIG, AgaveConfigGUID);
ServiceRelease(WASABI_API_PALETTE, PaletteManagerGUID);
Tataki::Quit();
HTMLContainer2_Uninitialize();
ServiceRelease(AGAVE_API_THREADPOOL, ThreadPoolGUID);
}
void config()
{
OpenMediaLibraryPreferences();
}
INT MediaLibrary_TrackPopupEx(HMENU hMenu, UINT fuFlags, INT x, INT y, HWND hwnd, LPTPMPARAMS lptpm, HMLIMGLST hmlil,
INT width, UINT skinStyle, MENUCUSTOMIZEPROC customProc, ULONG_PTR customParam)
{
if (NULL == hMenu)
return NULL;
return IsSkinnedPopupEnabled(FALSE) ?
TrackSkinnedPopupMenuEx(hMenu, fuFlags, x, y, hwnd, lptpm, hmlil, width, skinStyle, customProc, customParam) :
TrackPopupMenuEx(hMenu, fuFlags, x, y, hwnd, lptpm);
}
INT MediaLibrary_TrackPopup(HMENU hMenu, UINT fuFlags, INT x, INT y, HWND hwnd)
{
return MediaLibrary_TrackPopupEx(hMenu, fuFlags, x, y, hwnd, NULL, NULL, 0, SMS_USESKINFONT, NULL, NULL);
}
HANDLE MediaLibrary_InitSkinnedPopupHook(HWND hwnd, HMLIMGLST hmlil, INT width, UINT skinStyle, MENUCUSTOMIZEPROC customProc, ULONG_PTR customParam)
{
if (FALSE == IsSkinnedPopupEnabled(FALSE))
return FALSE;
return InitSkinnedPopupHook(hwnd, hmlil, width, skinStyle, customProc, customParam);
}
BOOL
MediaLibrary_OpenUrl(HWND ownerWindow, const wchar_t *url, BOOL forceExternal)
{
BOOL result;
HCURSOR cursor;
cursor = LoadCursor(NULL, IDC_APPSTARTING);
if (NULL != cursor)
cursor = SetCursor(cursor);
if (FALSE != forceExternal)
{
HINSTANCE instance;
if (NULL == ownerWindow)
ownerWindow = (HWND)SENDWAIPC(plugin.hwndParent, IPC_GETDIALOGBOXPARENT, 0);
instance = ShellExecuteW(ownerWindow, L"open", url, NULL, NULL, SW_SHOWNORMAL);
result = ((INT_PTR)instance > 32) ? TRUE: FALSE;
}
else
{
SENDWAIPC(plugin.hwndParent, IPC_OPEN_URL, url);
result = TRUE;
}
if (NULL != cursor)
SetCursor(cursor);
return result;
}
BOOL
MediaLibrary_OpenHelpUrl(const wchar_t *helpUrl)
{
HWND ownerWindow;
ownerWindow = (HWND)SENDWAIPC(plugin.hwndParent, IPC_GETDIALOGBOXPARENT, 0);
return MediaLibrary_OpenUrl(ownerWindow, helpUrl, FALSE);
}
extern "C"
{
int getFileInfo(const char *filename, const char *metadata, char *dest, int len)
{
m_calling_getfileinfo = 1;
dest[0] = 0;
extendedFileInfoStruct efis = {
filename,
metadata,
dest,
(size_t)len,
};
int r = (INT)SendMessage(plugin.hwndParent, WM_WA_IPC, (WPARAM) & efis, IPC_GET_EXTENDED_FILE_INFO); //will return 1 if wa2 supports this IPC call
m_calling_getfileinfo = 0;
return r;
}
__declspec(dllexport) winampGeneralPurposePlugin *winampGetGeneralPurposePlugin()
{
return &plugin;
}
};
Copy Permalink