path: root/Src/Plugins/Library/ml_local/Main.cpp

#define PLUGIN_VERSION L"3.36"
#include "main.h"
#include "resource.h"
#include "api__ml_local.h"
#include "..\..\General\gen_ml/config.h"
#include <commctrl.h>
#include ".\ml_local.h"
#include "..\..\General\gen_ml/ml_ipc_0313.h"
#include "../replicant/nu/AutoChar.h"
#include <api/service/waServiceFactory.h>
#include "../playlist/api_playlistmanager.h"
#include "mldbApiFactory.h"
#include "../nu/ServiceWatcher.h"
#include "LocalMediaCOM.h"
#include <tataki/export.h>
#include <strsafe.h>
#if 0
// disabled since not building cloud dlls
#include "../ml_cloud/CloudCallback.h"
#endif

static ServiceWatcher serviceWatcher;
static LocalMediaCOM localMediaCOM;
MLDBAPIFactory mldbApiFactory;
mlAddTreeItemStruct newTree;

#if 0
// disabled since not building cloud dlls
static class CloudCallbacks : public CloudCallback
{
	void OnCloudUploadStart(const wchar_t *filename) {
		SendMessage(m_curview_hwnd, WM_APP + 5, 0, (LPARAM)filename);
	}

	void OnCloudUploadDone(const wchar_t *filename, int code) {
		SendMessage(m_curview_hwnd, WM_APP + 5, MAKEWPARAM(code, 1), (LPARAM)filename);
	}
} cloudCallback;
#endif

LRESULT ML_IPC_MENUFUCKER_BUILD = -1, ML_IPC_MENUFUCKER_RESULT = -1;
int IPC_CLOUD_ENABLED = -1;

int CreateView(int treeItem, HWND parent);

static int Init();
static void Quit();
static INT_PTR MessageProc(int message_type, INT_PTR param1, INT_PTR param2, INT_PTR param3);

void SaveAll();

prefsDlgRecW preferences;

static wchar_t preferencesName[64] = {0};

int winampVersion = 0;
int substantives = 0;
int play_enq_rnd_alt = 0;

// Delay load library control << begin >>
#include <delayimp.h>
#pragma comment(lib, "delayimp")

bool nde_error = false;

FARPROC WINAPI FailHook(unsigned dliNotify, DelayLoadInfo *dli)
{
	nde_error = true;
	return 0;
}

/*
extern "C"
{
	PfnDliHook __pfnDliFailureHook2 = FailHook;
}
// Delay load library control << end >>
*/

#define CBCLASS PLCallBackW
START_DISPATCH;
VCB(IFC_PLAYLISTLOADERCALLBACK_ONFILE, OnFile)
END_DISPATCH;
#undef CBCLASS

template <class api_T>
void ServiceBuild(api_T *&api_t, GUID factoryGUID_t)
{
	if (plugin.service)
	{
		waServiceFactory *factory = plugin.service->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 (plugin.service && api_t)
	{
		waServiceFactory *factory = plugin.service->service_getServiceByGuid(factoryGUID_t);
		if (factory)
			factory->releaseInterface(api_t);
	}
	api_t = NULL;
}

extern WORD waMenuID;
DEFINE_EXTERNAL_SERVICE(api_application,         WASABI_API_APP);
DEFINE_EXTERNAL_SERVICE(api_explorerfindfile,    WASABI_API_EXPLORERFINDFILE);
DEFINE_EXTERNAL_SERVICE(api_language,            WASABI_API_LNG);
DEFINE_EXTERNAL_SERVICE(api_syscb,               WASABI_API_SYSCB);
DEFINE_EXTERNAL_SERVICE(api_memmgr,              WASABI_API_MEMMGR);
DEFINE_EXTERNAL_SERVICE(api_albumart,            AGAVE_API_ALBUMART);
DEFINE_EXTERNAL_SERVICE(api_metadata,            AGAVE_API_METADATA);
DEFINE_EXTERNAL_SERVICE(api_playlistmanager,     AGAVE_API_PLAYLISTMANAGER);
DEFINE_EXTERNAL_SERVICE(api_itunes_importer,     AGAVE_API_ITUNES_IMPORTER);
DEFINE_EXTERNAL_SERVICE(api_playlist_generator,  AGAVE_API_PLAYLIST_GENERATOR);
DEFINE_EXTERNAL_SERVICE(api_threadpool,          WASABI_API_THREADPOOL);
HINSTANCE WASABI_API_LNG_HINST = 0, WASABI_API_ORIG_HINST = 0;

int sse_flag;
int Init()
{
#ifdef _M_IX86
	int flags_edx;
	_asm 
	{
		mov eax, 1
			cpuid
			mov flags_edx, edx
	}

	sse_flag = flags_edx & 0x02000000;
#else
	sse_flag=1; // always supported on amd64
#endif
	InitializeCriticalSection(&g_db_cs);

	waMenuID = (WORD)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_REGISTER_LOWORD_COMMAND);

	Tataki::Init(plugin.service);

	plugin.service->service_register(&mldbApiFactory);

	ServiceBuild(WASABI_API_APP, applicationApiServiceGuid);
	ServiceBuild(WASABI_API_LNG, languageApiGUID);
	ServiceBuild(WASABI_API_EXPLORERFINDFILE, ExplorerFindFileApiGUID);
	ServiceBuild(AGAVE_API_ALBUMART, albumArtGUID);
	ServiceBuild(AGAVE_API_METADATA, api_metadataGUID);
	ServiceBuild(WASABI_API_MEMMGR, memMgrApiServiceGuid);
	ServiceBuild(WASABI_API_SYSCB, syscbApiServiceGuid);
	ServiceBuild(AGAVE_API_PLAYLISTMANAGER, api_playlistmanagerGUID);
	ServiceBuild(WASABI_API_THREADPOOL, ThreadPoolGUID);
	//ServiceBuild(AGAVE_API_PLAYLIST_GENERATOR, api_playlist_generator::getServiceGuid());

	serviceWatcher.WatchWith(plugin.service);
	serviceWatcher.WatchFor(&AGAVE_API_ITUNES_IMPORTER, api_itunes_importer::getServiceGuid());
	serviceWatcher.WatchFor(&AGAVE_API_PLAYLIST_GENERATOR, api_playlist_generator::getServiceGuid());
	WASABI_API_SYSCB->syscb_registerCallback(&serviceWatcher);
	#if 0
	// disabled since not building cloud dlls
	WASABI_API_SYSCB->syscb_registerCallback(&cloudCallback);
	#endif

	// need to have this initialised before we try to do anything with localisation features
	WASABI_API_START_LANG(plugin.hDllInstance,MlLocalLangGUID);

	wchar_t buf[2] = {0};
	if(LoadString(WASABI_API_LNG_HINST,IDS_SUBSTANTIVES,buf,2)){
		substantives = 1;
	}

	// this is used to load alternative play/enqueue random strings where
	// the default implementation will cause pluralisation issue eg de-de
	buf[0] = 0;
	if(LoadString(WASABI_API_LNG_HINST,IDS_PLAY_ENQ_RND_ALTERNATIVE,buf,2)){
		play_enq_rnd_alt = 1;
	}

	static wchar_t szDescription[256];
	StringCchPrintfW(szDescription, ARRAYSIZE(szDescription),
					 WASABI_API_LNGSTRINGW(IDS_NULLSOFT_LOCAL_MEDIA), PLUGIN_VERSION);
	plugin.description = (char*)szDescription;

	ML_IPC_MENUFUCKER_BUILD = (int)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&"menufucker_build", IPC_REGISTER_WINAMP_IPCMESSAGE);
	ML_IPC_MENUFUCKER_RESULT = (int)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&"menufucker_result", IPC_REGISTER_WINAMP_IPCMESSAGE);
	IPC_CLOUD_ENABLED = SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&"WinampCloudEnabled", IPC_REGISTER_WINAMP_IPCMESSAGE);

	mediaLibrary.library = plugin.hwndLibraryParent;
	mediaLibrary.winamp = plugin.hwndWinampParent;
	mediaLibrary.instance = plugin.hDllInstance;
	winampVersion = mediaLibrary.GetWinampVersion();

	mediaLibrary.AddDispatch(L"LocalMedia", &localMediaCOM);

	// this may look unused, but we want to get this here since mediaLibrary will cache the inidir
	// and then we don't run into weird multithreaded SendMessage issues
	mediaLibrary.GetIniDirectory();
	mediaLibrary.GetIniDirectoryW();

	preferences.hInst = WASABI_API_LNG_HINST;
	preferences.dlgID = IDD_PREFSFR;
	preferences.proc = (void *)PrefsProc;
	preferences.name = WASABI_API_LNGSTRINGW_BUF(IDS_LOCAL_MEDIA,preferencesName,64);
	preferences.where = 6; // 0;
	mediaLibrary.AddPreferences(preferences);

	mediaLibrary.AddTreeImage(IDB_TREEITEM_AUDIO, TREE_IMAGE_LOCAL_AUDIO, (BMPFILTERPROC)FILTER_DEFAULT1);
	mediaLibrary.AddTreeImage(IDB_TREEITEM_MOSTPLAYED, TREE_IMAGE_LOCAL_MOSTPLAYED, (BMPFILTERPROC)FILTER_DEFAULT1);
	mediaLibrary.AddTreeImage(IDB_TREEITEM_NEVERPLAYED, TREE_IMAGE_LOCAL_NEVERPLAYED, (BMPFILTERPROC)FILTER_DEFAULT1);
	mediaLibrary.AddTreeImage(IDB_TREEITEM_RECENTLYPLAYED, TREE_IMAGE_LOCAL_RECENTLYPLAYED, (BMPFILTERPROC)FILTER_DEFAULT1);
	mediaLibrary.AddTreeImage(IDB_TREEITEM_RECENTLYADDED, TREE_IMAGE_LOCAL_RECENTLYADDED, (BMPFILTERPROC)FILTER_DEFAULT1);
	mediaLibrary.AddTreeImage(IDB_TREEITEM_TOPRATED, TREE_IMAGE_LOCAL_TOPRATED, (BMPFILTERPROC)FILTER_DEFAULT1);
	mediaLibrary.AddTreeImage(IDB_TREEITEM_VIDEO, TREE_IMAGE_LOCAL_VIDEO, (BMPFILTERPROC)FILTER_DEFAULT1);
	mediaLibrary.AddTreeImage(IDB_TREEITEM_PODCASTS, TREE_IMAGE_LOCAL_PODCASTS, (BMPFILTERPROC)FILTER_DEFAULT1);
	mediaLibrary.AddTreeImage(IDB_TREEITEM_RECENTLYMODIFIED, TREE_IMAGE_LOCAL_RECENTLYMODIFIED, (BMPFILTERPROC)FILTER_DEFAULT1);

	int ret = init();
	if (ret) return ret;

	NAVINSERTSTRUCT nis = {0};
	nis.item.cbSize = sizeof(NAVITEM);
	nis.item.pszText = WASABI_API_LNGSTRINGW(IDS_LOCAL_MEDIA);
	nis.item.pszInvariant = L"Local Media";
	nis.item.style = NIS_HASCHILDREN;
	nis.item.id = 1000;  // benski> use the old ID for backwards compatability
	nis.item.mask = NIMF_TEXT | NIMF_TEXTINVARIANT | NIMF_STYLE | NIMF_ITEMID;

	// map to item id (will probably have to change but is a quick port to support invariant item naming)
	NAVITEM nvItem = {sizeof(NAVITEM),0,NIMF_ITEMID,};
	nvItem.hItem = MLNavCtrl_InsertItem(plugin.hwndLibraryParent, &nis);
	MLNavItem_GetInfo(plugin.hwndLibraryParent, &nvItem);
	m_query_tree = nvItem.id;

	loadQueryTree();

	m_query_mode = 0;
	m_query_metafile = L"default.vmd";

	return ret;
}

void Quit()
{
	serviceWatcher.StopWatching();
	serviceWatcher.Clear();

	// deregister this first, otherwise people might try to use it after we shut down the database!
	plugin.service->service_deregister(&mldbApiFactory);

	UnhookPlaylistEditor();

	Scan_Kill();

	closeDb();

	delete(g_view_metaconf);
	g_view_metaconf = 0;

	delete g_config;
	g_config = NULL;

	KillArtThread();

	for (QueryList::iterator i = m_query_list.begin();i != m_query_list.end();i++)
	{
		queryItem *item = i->second;
		if (item)
		{
			free(item->metafn);
			free(item->name);
			free(item->query);
		}
		free(item);
	}
	m_query_list.clear();
	DeleteCriticalSection(&g_db_cs);

	ServiceRelease(WASABI_API_APP, applicationApiServiceGuid);
	ServiceRelease(WASABI_API_LNG, languageApiGUID);
	ServiceRelease(AGAVE_API_ALBUMART, albumArtGUID);
	ServiceRelease(WASABI_API_MEMMGR, memMgrApiServiceGuid);
	ServiceRelease(AGAVE_API_METADATA, api_metadataGUID);
	ServiceRelease(WASABI_API_SYSCB, syscbApiServiceGuid);
	ServiceRelease(AGAVE_API_PLAYLISTMANAGER, api_playlistmanagerGUID);
	ServiceRelease(AGAVE_API_ITUNES_IMPORTER, api_itunes_importer::getServiceGuid());
	ServiceRelease(WASABI_API_THREADPOOL, ThreadPoolGUID);
	ServiceRelease(AGAVE_API_PLAYLIST_GENERATOR, api_playlist_generator::getServiceGuid());

	Tataki::Quit();
}

INT_PTR MessageProc(int message_type, INT_PTR param1, INT_PTR param2, INT_PTR param3)
{
	switch (message_type)
	{
	case ML_MSG_TREE_ONCREATEVIEW:       // param1 = param of tree item, param2 is HWND of parent. return HWND if it is us
		if (param1 == m_query_tree || m_query_list[param1])
			return (INT_PTR)onTreeViewSelectChange((HWND)param2);
		else
			return 0;

	case ML_MSG_NAVIGATION_CONTEXTMENU:
	{
		HNAVITEM hItem = (HNAVITEM)param1;
		HNAVITEM myItem = MLNavCtrl_FindItemById(plugin.hwndLibraryParent, m_query_tree);
		if (hItem == myItem)
		{
			queriesContextMenu(param1, (HWND)param2, MAKEPOINTS(param3));
			return 1;
		}
		else
		{
			NAVITEM nvItem = {sizeof(NAVITEM),hItem,NIMF_ITEMID,};
			MLNavItem_GetInfo(plugin.hwndLibraryParent, &nvItem);
			if (m_query_list[nvItem.id])
			{
				view_queryContextMenu(param1, (HWND)param2, MAKEPOINTS(param3), nvItem.id);
				return 1;
			}
		}
		return 0;
	}

	case ML_MSG_TREE_ONCLICK:
		if (param1 == m_query_tree)
			return OnLocalMediaClick(param2, (HWND)param3);
		else if (m_query_list[param1])
			return OnLocalMediaItemClick(param2, param1, (HWND)param3);
		else
			return 0;

	case ML_MSG_TREE_ONDRAG:
		if (m_query_list[param1])
		{
			int *type = reinterpret_cast<int *>(param3);
			*type = ML_TYPE_ITEMRECORDLIST;
			return 1;
		}
		return 0;

	case ML_MSG_TREE_ONDROP:
		if (param3 != NULL && param1 != NULL)  // here we go - finishing moving view
		{
			if (m_query_list[param1])
			{
				if (param3 == m_query_tree || m_query_list[param3])
				{
					QueryList::iterator src = m_query_list.find(param1);
					mediaLibrary.RemoveTreeItem(src->first);
					MLTREEITEMW srcItem = {sizeof(MLTREEITEMW), };

					srcItem.title = src->second->name;
					srcItem.hasChildren = 0;
					srcItem.parentId = m_query_tree;
					srcItem.id = param3;
					srcItem.imageIndex = src->second->imgIndex;
					mediaLibrary.InsertTreeItem(srcItem);

					auto item = src->second;
					m_query_list.erase(param1);
					m_query_list.insert({ srcItem.id, item });

					saveQueryTree();
					mediaLibrary.SelectTreeItem(srcItem.id);
					return 1;
				}
			}
		}
		else if (m_query_list[param1])
		{
			mlDropItemStruct m = {0};
			m.type = ML_TYPE_ITEMRECORDLISTW;
			m.p = *(POINT *)param2;
			m.flags = ML_HANDLEDRAG_FLAG_NOCURSOR | ML_HANDLEDRAG_FLAG_NAME;

			// build an itemRecordList
			queryItem *item = m_query_list[param1];
			wchar_t configDir[MAX_PATH] = {0};
			PathCombineW(configDir, g_viewsDir, item->metafn);
			C_Config viewconf(configDir);

			EnterCriticalSection(&g_db_cs);
			nde_scanner_t s = NDE_Table_CreateScanner(g_table);
			NDE_Scanner_Query(s, item->query);
			itemRecordListW obj = {0, };
			saveQueryToListW(&viewconf, s, &obj, 0, 0, (resultsniff_funcW)-1);
			NDE_Table_DestroyScanner(g_table, s);
			LeaveCriticalSection(&g_db_cs);
			m.data = (void *) & obj;
			AutoChar whatsThisNameUsedForAnyway(item->name);
			m.name = whatsThisNameUsedForAnyway;

			pluginHandleIpcMessage(ML_IPC_HANDLEDROP, (WPARAM)&m);
			if (m.result < 1)
			{
				m.result = 0;
				m.type = ML_TYPE_ITEMRECORDLIST;
				itemRecordList objA={0,};
				convertRecordList(&objA, &obj);
				m.data = (void*)&objA;
				pluginHandleIpcMessage(ML_IPC_HANDLEDRAG, (WPARAM)&m);
				freeRecordList(&objA);
			}
			freeRecordList(&obj);
		}
		return 0;

	case ML_MSG_CONFIG:
		mediaLibrary.GoToPreferences(preferences._id);
		return TRUE;

	case ML_MSG_VIEW_PLAY_ENQUEUE_CHANGE:
		enqueuedef = param1;
		groupBtn = param2;
		PostMessage(m_curview_hwnd, WM_APP + 104, param1, param2);
		return 0;

	case ML_MSG_ONSENDTOBUILD:
		if (param1 == ML_TYPE_ITEMRECORDLISTW || param1 == ML_TYPE_ITEMRECORDLIST ||
		    param1 == ML_TYPE_FILENAMES  || param1 == ML_TYPE_FILENAMESW)
		{
			if (!myMenu) mediaLibrary.AddToSendTo(WASABI_API_LNGSTRINGW(IDS_ADD_TO_LOCAL_MEDIA), param2, (INT_PTR)MessageProc);
		}
		break;

	case ML_MSG_ONSENDTOSELECT:
	case ML_MSG_TREE_ONDROPTARGET:      // return -1 if not allowed, 1 if allowed, or 0 if not our tree item
		// set with droptarget defaults =)
		INT_PTR type, data;

		if (message_type == ML_MSG_ONSENDTOSELECT)
		{
			if (param3 != (INT_PTR)MessageProc) return 0;

			type = param1;
			data = param2;
		}
		else
		{
			if (param1 != m_query_tree && !m_query_list[param1]) return 0;

			type = param2;
			data = param3;

			if (!data)
			{
				return (type ==  ML_TYPE_ITEMRECORDLISTW || type ==  ML_TYPE_ITEMRECORDLIST ||
				        type == ML_TYPE_FILENAMES || type == ML_TYPE_FILENAMESW ||
				        type == ML_TYPE_PLAYLIST) ? 1 : -1;
			}
		}

		if (data)
		{
			if (type == ML_TYPE_ITEMRECORDLIST)
			{
				itemRecordList *p = (itemRecordList*)data;
				for (int x = 0; x < p->Size; x ++)
					mediaLibrary.AddToMediaLibrary(p->Items[x].filename);

				return 1;
			}
			else if (type == ML_TYPE_ITEMRECORDLISTW)
			{
				itemRecordListW *p = (itemRecordListW*)data;
				for (int x = 0; x < p->Size; x ++)
					mediaLibrary.AddToMediaLibrary(p->Items[x].filename);

				return 1;
			}
			else if (type == ML_TYPE_PLAYLIST)
			{
				mlPlaylist * pl = (mlPlaylist *)data;
				PLCallBackW plCB;
				if (AGAVE_API_PLAYLISTMANAGER && PLAYLISTMANAGER_SUCCESS != AGAVE_API_PLAYLISTMANAGER->Load(pl->filename, &plCB))
				{
					mediaLibrary.AddToMediaLibrary(pl->filename);
				}
				return 1;
			}
			else if (type == ML_TYPE_FILENAMES)
			{
				const char *p = (const char*)data;
				while (p && *p)
				{
					PLCallBackW plCB;
					if (AGAVE_API_PLAYLISTMANAGER && PLAYLISTMANAGER_SUCCESS != AGAVE_API_PLAYLISTMANAGER->Load(AutoWide(p), &plCB))
					{
						mediaLibrary.AddToMediaLibrary(p);
					}
					p += strlen(p) + 1;
				}
				return 1;
			}
			else if (type == ML_TYPE_FILENAMESW)
			{
				const wchar_t *p = (const wchar_t*)data;
				while (p && *p)
				{
					PLCallBackW plCB;
					if (AGAVE_API_PLAYLISTMANAGER && PLAYLISTMANAGER_SUCCESS != AGAVE_API_PLAYLISTMANAGER->Load(p, &plCB))
					{
						mediaLibrary.AddToMediaLibrary(p);
					}
					p += wcslen(p) + 1;
				}
				return 1;
			}
		}
		break;

	case ML_MSG_TREE_ONKEYDOWN:
	{
		NMTVKEYDOWN *p = (NMTVKEYDOWN*)param2;
		int ctrl = (GetAsyncKeyState(VK_CONTROL)&0x8000);
		int shift = (GetAsyncKeyState(VK_SHIFT)&0x8000);

		if (p->wVKey == VK_INSERT && !shift)
		{
			if (!ctrl)
				addNewQuery(plugin.hwndLibraryParent);
			else
				if (!g_bgscan_scanning) SendMessage(plugin.hwndLibraryParent, WM_USER + 575, 0xffff00dd, 0);

			PostMessageW(plugin.hwndLibraryParent, WM_NEXTDLGCTL, (WPARAM)param3, (LPARAM)TRUE);
			return 1;
		}
		else if (m_query_list[param1])
		{
			if (p->wVKey == VK_F2 && !shift && !ctrl)
			{
				queryEditItem(param1);
			}
			else if (p->wVKey == VK_DELETE && !shift && !ctrl)
			{
				queryDeleteItem(plugin.hwndLibraryParent, param1);
			}
			else
				break;

			PostMessageW(plugin.hwndLibraryParent, WM_NEXTDLGCTL, (WPARAM)param3, (LPARAM)TRUE);
			return 1;
		}
		return 0;
	}

	case ML_IPC_HOOKEXTINFO:
		if (IPC_HookExtInfo(param1)) return 1;
		break;

	case ML_IPC_HOOKEXTINFOW:
		if (IPC_HookExtInfoW(param1)) return 1;
		break;

	case ML_IPC_HOOKTITLEW:
		if (IPC_HookTitleInfo(param1)) return 1;
		break;

	case ML_MSG_PLAYING_FILE:
		if (param1) onStartPlayFileTrack((const wchar_t *)param1, false);
		break;
	}
	return 0;
}


/////////////////////////////////////////////////////////////////////////////////////////////////////////
extern "C" winampMediaLibraryPlugin plugin = 
{ 
	MLHDR_VER, 
	"nullsoft(ml_local.dll)", 
	Init, 
	Quit, 
	MessageProc, 
	0, 
	0, 
	0,
};

extern "C" __declspec(dllexport) winampMediaLibraryPlugin *winampGetMediaLibraryPlugin()
{
	return &plugin;
}