winamp/Src/Plugins/Library/ml_pmp/main.cpp

#define PLUGIN_NAME "Nullsoft Portable Music Player Support"
#define PLUGIN_VERSION L"2.25"

#include "main.h"
#include <windows.h>
#include <windowsx.h>
#include <stdio.h>
#include <shlobj.h>
#include <shlwapi.h>
#include "..\..\General\gen_ml/ml.h"
#include "..\..\General\gen_ml/itemlist.h"
#include "../winamp/wa_ipc.h"
#include "nu/ns_wc.h"
#include "..\..\General\gen_hotkeys/wa_hotkeys.h"
#include "resource1.h"
#include "pmp.h"
#include "DeviceView.h"
#include "pluginloader.h"
#include "nu/AutoWide.h"
#include "api__ml_pmp.h"
#include "transcoder_imp.h"
#include <api/service/waservicefactory.h>
#include "config.h"
#include "tataki/export.h"
#include "nu/ServiceWatcher.h"
#include "..\..\General\gen_ml/ml_ipc_0313.h"
#include "mt19937ar.h"
#include "./local_menu.h"
#include "pmpdevice.h"
#include "IconStore.h"
#include "../replicant/nx/nxstring.h"
#include <strsafe.h>
#include "../nu/MediaLibraryInterface.h"
#include <vector>

#define MAINTREEID 5002
#define PROGRESSTIMERID 1

static int init();
static void quit();
static INT_PTR PluginMessageProc(int message_type, INT_PTR param1, INT_PTR param2, INT_PTR param3);

LRESULT CALLBACK DeviceMsgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
extern INT_PTR CALLBACK pmp_devices_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam);
extern void UpdateDevicesListView(bool softupdate);
INT_PTR CALLBACK global_config_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam);
INT_PTR CALLBACK config_dlgproc_plugins(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam);
void UpdateTransfersListView(bool softUpdate, CopyInst * item=NULL);

static void CALLBACK ProgressTimerTickCb(HWND hwnd, UINT uMsg, UINT_PTR eventId, unsigned long elapsed);

extern "C" winampMediaLibraryPlugin plugin = 
{
	MLHDR_VER,
	"nullsoft(ml_pmp.dll)",
	init,
	quit,
	PluginMessageProc,
	0,
	0,
	0,
};

C_ItemList devices;
C_ItemList loadingDevices;
extern HNAVITEM cloudQueueTreeItem;
static HNAVITEM navigationRoot = NULL;
static ATOM	viewAtom = 0;
int groupBtn = 1, customAllowed = 0, enqueuedef = 0;
extern HWND hwndMediaView;
extern DeviceView * currentViewedDevice;
HMENU m_context_menus = NULL, m_context_menus2 = NULL;
int prefsPageLoaded = 0, profile = 0;
prefsDlgRecW prefsPage;
prefsDlgRecW pluginsPrefsPage;
C_Config * global_config;
C_Config * gen_mlconfig;
UINT genhotkeys_add_ipc;
HANDLE hMainThread;
UINT_PTR mainTreeHandle;
extern HINSTANCE cloud_hinst;
extern int IPC_GET_CLOUD_HINST, IPC_LIBRARY_PLAYLISTS_REFRESH;
void deviceConnected(Device * dev);
void deviceDisconnected(Device * dev);
void deviceLoading(pmpDeviceLoading * load);
void deviceNameChanged(Device * dev);

//extern CRITICAL_SECTION listTransfersLock;
CRITICAL_SECTION csenumdrives;

api_playlists       *AGAVE_API_PLAYLISTS       = 0;
api_playlistmanager *AGAVE_API_PLAYLISTMANAGER = 0;
api_mldb            *AGAVE_API_MLDB            = 0;
api_memmgr          *WASABI_API_MEMMGR         = 0;
api_syscb           *WASABI_API_SYSCB          = 0;
api_application     *WASABI_API_APP            = 0;
api_podcasts        *AGAVE_API_PODCASTS        = 0;
api_albumart        *AGAVE_API_ALBUMART        = 0;
api_stats           *AGAVE_API_STATS           = 0;
api_threadpool      *WASABI_API_THREADPOOL     = 0;
api_devicemanager   *AGAVE_API_DEVICEMANAGER   = 0;
api_metadata        *AGAVE_API_METADATA        = 0;
// wasabi based services for localisation support
api_language        *WASABI_API_LNG            = 0;
HINSTANCE            WASABI_API_LNG_HINST      = 0;
HINSTANCE            WASABI_API_ORIG_HINST     = 0;

static const GUID pngLoaderGUID = 
	{ 0x5e04fb28, 0x53f5, 0x4032, { 0xbd, 0x29, 0x3, 0x2b, 0x87, 0xec, 0x37, 0x25 } };

static svc_imageLoader *wasabiPngLoader = NULL;

HWND mainMessageWindow = 0;
static bool classRegistered=0;
HWND CreateDummyWindow()
{
	if (!classRegistered)
	{
		WNDCLASSW wc = {0, };

		wc.style         = 0;
		wc.lpfnWndProc   = DeviceMsgProc;
		wc.hInstance     = plugin.hDllInstance;
		wc.hIcon         = 0;
		wc.hCursor       = NULL;
		wc.lpszClassName = L"ml_pmp_window";

		if (!RegisterClassW(&wc))
			return 0;

		classRegistered = true;
	}
	HWND dummy = CreateWindowW(L"ml_pmp_window", L"ml_pmp_window", 0, 0, 0, 0, 0, NULL, NULL, plugin.hDllInstance, NULL);

	return dummy;
}

genHotkeysAddStruct hksync     = { 0, HKF_UNICODE_NAME, WM_USER,     0, 0, "ml_pmp_sync",     0 };
genHotkeysAddStruct hkautofill = { 0, HKF_UNICODE_NAME, WM_USER + 1, 0, 0, "ml_pmp_autofill", 0 };
genHotkeysAddStruct hkeject    = { 0, HKF_UNICODE_NAME, WM_USER + 2, 0, 0, "ml_pmp_eject",    0 };

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;
}

HNAVITEM NavigationItem_Find(HNAVITEM root, const wchar_t *name, BOOL allow_root = 0)
{
	NAVCTRLFINDPARAMS find;
	HNAVITEM item;

	if (NULL == name)
		return NULL;

	if (NULL == plugin.hwndLibraryParent)
		return NULL;

	find.pszName = (wchar_t*)name;
	find.cchLength = -1;
	find.compFlags = NICF_INVARIANT;
	find.fFullNameSearch = FALSE;

	item = MLNavCtrl_FindItemByName(plugin.hwndLibraryParent, &find);
	if (NULL == item)
		return NULL;

	if (!allow_root)
	{
		// if allowed then we can look for root level items which
		// is really for getting 'cloud' devices to another group
		if (NULL != root && 
			root != MLNavItem_GetParent(plugin.hwndLibraryParent, item))
		{
			item = NULL;
		}
	}

	return item;
}

HNAVITEM GetNavigationRoot(BOOL forceCreate)
{
	if (NULL == navigationRoot && 
		FALSE !=  forceCreate)
	{
		NAVINSERTSTRUCT nis = {0};
		wchar_t buffer[512] = {0};

		WASABI_API_LNGSTRINGW_BUF(IDS_PORTABLES, buffer, ARRAYSIZE(buffer));

		nis.hParent = NULL;
		nis.hInsertAfter = NCI_LAST;
		nis.item.cbSize = sizeof(NAVITEM);
		nis.item.mask = NIMF_TEXT | NIMF_TEXTINVARIANT | NIMF_STYLE | NIMF_ITEMID | NIMF_PARAM;
		nis.item.id = MAINTREEID;
		nis.item.pszInvariant = L"Portables";
		nis.item.style = NIS_HASCHILDREN;
		nis.item.pszText = buffer;
		nis.item.lParam = -1;

		navigationRoot = MLNavCtrl_InsertItem(plugin.hwndLibraryParent, &nis);
		if (NULL != navigationRoot)
		{
			SetTimer(mainMessageWindow, PROGRESSTIMERID, 250, ProgressTimerTickCb);
		}
	}

	return navigationRoot;
}


static HNAVITEM GetNavigationItemFromMessage(int msg, INT_PTR param)
{
	return (msg < ML_MSG_NAVIGATION_FIRST) ? 
			MLNavCtrl_FindItemById(plugin.hwndLibraryParent, param) : 
			(HNAVITEM)param;
}

void Menu_ConvertRatingMenuStar(HMENU menu, UINT menu_id)
{
MENUITEMINFOW mi = {sizeof(mi), MIIM_DATA | MIIM_TYPE, MFT_STRING};
wchar_t rateBuf[32], *rateStr = rateBuf;
	mi.dwTypeData = rateBuf;
	mi.cch = 32;
	if(GetMenuItemInfoW(menu, menu_id, FALSE, &mi))
	{
		while(rateStr && *rateStr)
		{
			if(*rateStr == L'*') *rateStr = L'\u2605';
			rateStr=CharNextW(rateStr);
		}
		SetMenuItemInfoW(menu, menu_id, FALSE, &mi);
	}
}

static ServiceWatcher serviceWatcher;

static int init()
{
	// if there are no pmp_*.dll then no reason to load
	if (!testForDevPlugins())
		return ML_INIT_FAILURE;

	genrand_int31 = (int (*)())SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GET_RANDFUNC);

	if (0 == viewAtom)
	{
		viewAtom = GlobalAddAtomW(L"WinampPortableMediaView");
		if (0 == viewAtom)
			return 2;
	}

	TranscoderImp::init();
	InitializeCriticalSection(&csenumdrives);
	
	Tataki::Init(plugin.service);
	ServiceBuild( AGAVE_API_PLAYLISTS,       api_playlistsGUID );
	ServiceBuild( AGAVE_API_PLAYLISTMANAGER, api_playlistmanagerGUID );
	ServiceBuild( WASABI_API_SYSCB,          syscbApiServiceGuid );
	ServiceBuild( WASABI_API_APP,            applicationApiServiceGuid );
	ServiceBuild( AGAVE_API_STATS,           AnonymousStatsGUID );
	ServiceBuild( WASABI_API_THREADPOOL,     ThreadPoolGUID );
	ServiceBuild( AGAVE_API_DEVICEMANAGER,   DeviceManagerGUID );
	ServiceBuild( AGAVE_API_ALBUMART,        albumArtGUID );
	ServiceBuild( AGAVE_API_METADATA,        api_metadataGUID );

	// loader so that we can get the localisation service api for use
	ServiceBuild( WASABI_API_LNG,            languageApiGUID );
	ServiceBuild( WASABI_API_MEMMGR,         memMgrApiServiceGuid );

	// no guarantee that AGAVE_API_MLDB will be available yet, so we'll start a watcher for it
	serviceWatcher.WatchWith( plugin.service );
	serviceWatcher.WatchFor( &AGAVE_API_MLDB,     mldbApiGuid );
	serviceWatcher.WatchFor( &AGAVE_API_PODCASTS, api_podcastsGUID );

	WASABI_API_SYSCB->syscb_registerCallback( &serviceWatcher );


	mediaLibrary.library  = plugin.hwndLibraryParent;
	mediaLibrary.winamp   = plugin.hwndWinampParent;
	mediaLibrary.instance = plugin.hDllInstance;

	mediaLibrary.GetIniDirectory();
	mediaLibrary.GetIniDirectoryW();

	// need to have this initialised before we try to do anything with localisation features
	WASABI_API_START_LANG(plugin.hDllInstance,MlPMPLangGUID);
	
	static wchar_t szDescription[256];
	StringCbPrintfW(szDescription, ARRAYSIZE(szDescription), WASABI_API_LNGSTRINGW(IDS_NULLSOFT_PMP_SUPPORT), PLUGIN_VERSION);
	plugin.description = (char*)szDescription;

	hMainThread      = GetCurrentThread();
	//InitializeCriticalSection(&listTransfersLock);
	global_config    = new C_Config( (wchar_t *)mediaLibrary.GetWinampIniW() );
	profile          = global_config->ReadInt( L"profile", 0, L"Winamp" );

	gen_mlconfig     = new C_Config( (wchar_t *)SendMessage( plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GETMLINIFILEW ), L"gen_ml_config" );

	m_context_menus  = WASABI_API_LOADMENU( IDR_CONTEXTMENUS );
	m_context_menus2 = WASABI_API_LOADMENU( IDR_CONTEXTMENUS );


	HMENU rate_hmenu = GetSubMenu(GetSubMenu(m_context_menus,0),7);
	Menu_ConvertRatingMenuStar(rate_hmenu, ID_RATE_5);
	Menu_ConvertRatingMenuStar(rate_hmenu, ID_RATE_4);
	Menu_ConvertRatingMenuStar(rate_hmenu, ID_RATE_3);
	Menu_ConvertRatingMenuStar(rate_hmenu, ID_RATE_2);
	Menu_ConvertRatingMenuStar(rate_hmenu, ID_RATE_1);

	rate_hmenu = GetSubMenu(GetSubMenu(m_context_menus,1),4);
	Menu_ConvertRatingMenuStar(rate_hmenu, ID_RATE_5);
	Menu_ConvertRatingMenuStar(rate_hmenu, ID_RATE_4);
	Menu_ConvertRatingMenuStar(rate_hmenu, ID_RATE_3);
	Menu_ConvertRatingMenuStar(rate_hmenu, ID_RATE_2);
	Menu_ConvertRatingMenuStar(rate_hmenu, ID_RATE_1);

	rate_hmenu = GetSubMenu(GetSubMenu(m_context_menus,2),7);
	Menu_ConvertRatingMenuStar(rate_hmenu, ID_RATE_5);
	Menu_ConvertRatingMenuStar(rate_hmenu, ID_RATE_4);
	Menu_ConvertRatingMenuStar(rate_hmenu, ID_RATE_3);
	Menu_ConvertRatingMenuStar(rate_hmenu, ID_RATE_2);
	Menu_ConvertRatingMenuStar(rate_hmenu, ID_RATE_1);

	rate_hmenu = GetSubMenu(GetSubMenu(m_context_menus,7),5);
	Menu_ConvertRatingMenuStar(rate_hmenu, ID_RATE_5);
	Menu_ConvertRatingMenuStar(rate_hmenu, ID_RATE_4);
	Menu_ConvertRatingMenuStar(rate_hmenu, ID_RATE_3);
	Menu_ConvertRatingMenuStar(rate_hmenu, ID_RATE_2);
	Menu_ConvertRatingMenuStar(rate_hmenu, ID_RATE_1);

	//subclass winamp window
	mainMessageWindow = CreateDummyWindow();

	prefsPage.hInst = WASABI_API_LNG_HINST;
	prefsPage.dlgID = IDD_CONFIG_GLOBAL;
	prefsPage.name  = _wcsdup( WASABI_API_LNGSTRINGW( IDS_PORTABLES ) );
	prefsPage.where = 6;
	prefsPage.proc  = global_config_dlgproc;

	pluginsPrefsPage.hInst = WASABI_API_LNG_HINST;
	pluginsPrefsPage.dlgID = IDD_CONFIG_PLUGINS;
	pluginsPrefsPage.name  = prefsPage.name;
	pluginsPrefsPage.where = 1;
	pluginsPrefsPage.proc  = config_dlgproc_plugins;

	// only insert the portables page if we've actually loaded a pmp_*.dll
	int count = 0;
	if(loadDevPlugins(&count) && count > 0)
	{
		SendMessage(plugin.hwndWinampParent,WM_WA_IPC,(intptr_t)&pluginsPrefsPage,IPC_ADD_PREFS_DLGW);
	}
	else if (!count)
	{
		// and if there are none, then cleanup and also notify ml_devices.dll to
		// shut-down as no need for it to keep running if there's not going to be
		// anything else running (as unlikely we'd have use for it without ml_pmp
		quit();

		winampMediaLibraryPlugin *(*gp)();
		gp = (winampMediaLibraryPlugin * (__cdecl *)(void))GetProcAddress(GetModuleHandleW(L"ml_devices.dll"), "winampGetMediaLibraryPlugin");
		if (gp)
		{
			winampMediaLibraryPlugin *mlplugin = gp();
			if (mlplugin && (mlplugin->version >= MLHDR_VER_OLD && mlplugin->version <= MLHDR_VER))
			{
				mlplugin->quit();
			}
		}

		return ML_INIT_FAILURE;
	}

	// we've got pmp_*.dll to load, so lets start the fun...
	Devices_Init();
	if (AGAVE_API_DEVICEMANAGER)
	{
		SetTimer(mainMessageWindow, PROGRESSTIMERID, 250, ProgressTimerTickCb);
	}
	else if (!global_config->ReadInt(L"HideRoot",0))
	{
		GetNavigationRoot(TRUE);
	}

	SetTimer(mainMessageWindow,COMMITTIMERID,5000,NULL);

	IPC_LIBRARY_PLAYLISTS_REFRESH = SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&"ml_playlist_refresh", IPC_REGISTER_WINAMP_IPCMESSAGE);
	IPC_GET_CLOUD_HINST = (INT)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&"WinampCloud", IPC_REGISTER_WINAMP_IPCMESSAGE);
	cloud_hinst = (HINSTANCE)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GET_CLOUD_HINST);

	// set up hotkeys...
	genhotkeys_add_ipc = SendMessage(plugin.hwndWinampParent,WM_WA_IPC,(WPARAM)&"GenHotkeysAdd",IPC_REGISTER_WINAMP_IPCMESSAGE);
	hksync.wnd = hkautofill.wnd = hkeject.wnd = mainMessageWindow;
	hksync.name = (char*)_wcsdup(WASABI_API_LNGSTRINGW(IDS_GHK_SYNC_PORTABLE_DEVICE));
	PostMessage(plugin.hwndWinampParent,WM_WA_IPC,(WPARAM)&hksync,genhotkeys_add_ipc);
	hkautofill.name = (char*)_wcsdup(WASABI_API_LNGSTRINGW(IDS_GHK_AUTOFILL_PORTABLE_DEVICE));
	PostMessage(plugin.hwndWinampParent,WM_WA_IPC,(WPARAM)&hkautofill,genhotkeys_add_ipc);
	hkeject.name = (char*)_wcsdup(WASABI_API_LNGSTRINGW(IDS_GHK_EJECT_PORTABLE_DEVICE));
	PostMessage(plugin.hwndWinampParent,WM_WA_IPC,(WPARAM)&hkeject,genhotkeys_add_ipc);
	return ML_INIT_SUCCESS;
}

bool quitting=false;
static void quit() 
{
	// trigger transfer kill
	int i = devices.GetSize();
	if (i > 0)
	{
		while(i-- > 0)
		{
			DeviceView * device = ((DeviceView*)devices.Get(i));
			if (device) device->threadKillswitch = 1;
		}
	}

	quitting = true;
	KillTimer(mainMessageWindow, COMMITTIMERID);
	DeviceMsgProc(NULL, WM_TIMER, COMMITTIMERID, 0);

	i = devices.GetSize();
	if (i > 0)
	{
		while(i-- > 0)
		{
			DeviceView * device = ((DeviceView*)devices.Get(i));
			if (device) device->dev->Close();
		}
	}
	unloadDevPlugins();

	stopServer();
	HWND f = mainMessageWindow;
	mainMessageWindow = 0;
	DestroyWindow(f);
	delete global_config;

	WASABI_API_SYSCB->syscb_deregisterCallback(&serviceWatcher);
	serviceWatcher.Clear();

	ServiceRelease( AGAVE_API_PLAYLISTS,       api_playlistsGUID );
	ServiceRelease( AGAVE_API_PLAYLISTMANAGER, api_playlistmanagerGUID );
	ServiceRelease( WASABI_API_SYSCB,          syscbApiServiceGuid );
	ServiceRelease( WASABI_API_APP,            applicationApiServiceGuid );
	ServiceRelease( WASABI_API_LNG,            languageApiGUID );
	ServiceRelease( WASABI_API_MEMMGR,         memMgrApiServiceGuid );
	ServiceRelease( AGAVE_API_MLDB,            mldbApiGuid );
	ServiceRelease( AGAVE_API_PODCASTS,        api_podcastsGUID );
	ServiceRelease( AGAVE_API_STATS,           AnonymousStatsGUID );
	ServiceRelease( AGAVE_API_DEVICEMANAGER,   DeviceManagerGUID );
	ServiceRelease( AGAVE_API_ALBUMART,        albumArtGUID );
	ServiceRelease( AGAVE_API_METADATA,        api_metadataGUID );

	if (NULL != wasabiPngLoader)
	{
		ServiceRelease(wasabiPngLoader, pngLoaderGUID);
		wasabiPngLoader = NULL;
	}

	DeleteCriticalSection(&csenumdrives);
	TranscoderImp::quit();

	delete gen_mlconfig;
	Tataki::Quit();	
	ServiceRelease(WASABI_API_THREADPOOL, ThreadPoolGUID);

	if (0 != viewAtom)
	{
		GlobalDeleteAtom(viewAtom);
		viewAtom = 0;
	}
}

typedef struct { ULONG_PTR param; void * proc; int state; CRITICAL_SECTION lock;} spc ;

static VOID CALLBACK spc_caller(ULONG_PTR dwParam) {
	spc * s = (spc*)dwParam;
	if(!s) return;
	EnterCriticalSection(&s->lock);
	if(s->state == -1) { LeaveCriticalSection(&s->lock); DeleteCriticalSection(&s->lock); free(s); return; }
	s->state = 2;
	void (CALLBACK *p)(ULONG_PTR dwParam);
	p = (void (CALLBACK *)(ULONG_PTR dwParam))s->proc;
	if(p) p(s->param);
	s->state=1;
	LeaveCriticalSection(&s->lock); 
}

static int spc_GetState(spc *s)
{
	EnterCriticalSection(&s->lock);
	int state = s->state;
	LeaveCriticalSection(&s->lock);
	return state;
}

// p must be of type void (CALLBACK *)(ULONG_PTR dwParam). Returns 0 for success.
int SynchronousProcedureCall(void * p, ULONG_PTR dwParam) {
	if(!p) return 1;
	spc * s = (spc*)calloc(1, sizeof(spc));
	InitializeCriticalSection(&s->lock);
	s->param = dwParam;
	s->proc = p;
	s->state = 0;
#if 1 // _WIN32_WINNT >= 0x0400
	if(!QueueUserAPC(spc_caller,hMainThread,(ULONG_PTR)s)) { DeleteCriticalSection(&s->lock); free(s); return 1; } //failed
#else
	if(!mainMessageWindow) { DeleteCriticalSection(&s->lock); free(s); return 1; } else PostMessage(mainMessageWindow,WM_USER+3,(WPARAM)spc_caller,(LPARAM)s);
#endif
	int i=0;
	while (spc_GetState(s) != 1)
	{
		if (SleepEx(10,TRUE) == 0)
			i++;
		if(i >= 100) 
		{
			EnterCriticalSection(&s->lock);
			s->state = -1;
			LeaveCriticalSection(&s->lock);
			return 1;
		}
	}
	DeleteCriticalSection(&s->lock);
	free(s);
	return 0;
}

static VOID CALLBACK getTranscoder(ULONG_PTR dwParam)
{
	C_Config * conf = global_config;
	for(int i=0; i<devices.GetSize(); i++)
	{
		DeviceView * d = (DeviceView *)devices.Get(i);
		if(d->dev == *(Device **)dwParam) { conf = d->config; break; }
	}
	Transcoder ** t = (Transcoder**)dwParam;
	*t = new TranscoderImp(plugin.hwndWinampParent,plugin.hDllInstance,conf, *(Device **)dwParam);
}

static void CALLBACK ProgressTimerTickCb(HWND hwnd, UINT uMsg, UINT_PTR eventId, unsigned long elapsed)
{
	wchar_t *buf = (wchar_t*)calloc(sizeof(wchar_t), 256);
	NAVITEM itemInfo = {0};
	HNAVITEM rootItem = GetNavigationRoot(FALSE);
	if (!AGAVE_API_DEVICEMANAGER && NULL == rootItem)
	{
		KillTimer(hwnd, eventId);
		if (buf) free(buf);
		return;
	}

	// TODO need to get this working for a merged instance...
	int num = 0,total = 0, percent = 0;
	for(int i=0; i<devices.GetSize(); i++)
	{
		DeviceView * dev = (DeviceView*)devices.Get(i);
		LinkedQueue * txQueue = getTransferQueue(dev);
		LinkedQueue * finishedTX = getFinishedTransferQueue(dev);
		int txProgress = getTransferProgress(dev);
		int size = (txQueue ? txQueue->GetSize() : 0);
		int device_num = (100 * size) - txProgress;
		num += device_num;
		int device_total = 100 * size + 100 * (finishedTX ? finishedTX->GetSize() : 0);
		total += device_total;
		percent = (0 != device_total) ? (((device_total - device_num) * 100) / device_total) : -1;
		// TODO need to do something to handle it sticking on 100%
		if (dev->queueTreeItem)
		{
			itemInfo.cbSize = sizeof(itemInfo);
			itemInfo.hItem = dev->queueTreeItem;
			itemInfo.mask = NIMF_PARAM;

			if (MLNavItem_GetInfo(plugin.hwndLibraryParent, &itemInfo) && itemInfo.lParam != percent)
			{
				if (-1 == percent)
					WASABI_API_LNGSTRINGW_BUF(IDS_TRANSFERS,buf, 256);
				else
					StringCbPrintfW(buf, 256, WASABI_API_LNGSTRINGW(IDS_TRANSFERS_PERCENT), percent); 

				itemInfo.mask |= NIMF_TEXT;
				itemInfo.pszText = buf;
				itemInfo.lParam = percent;
				itemInfo.cchTextMax = -1;

				MLNavItem_SetInfo(plugin.hwndLibraryParent, &itemInfo);
			}
		}

		dev->UpdateActivityState();
	}

	if (!rootItem)
	{
		if (buf) free(buf);
		return;
	}

	percent = (0 != total) ? (((total-num)*100)/total) : -1;

	itemInfo.cbSize = sizeof(itemInfo);
	itemInfo.hItem = rootItem;
	itemInfo.mask = NIMF_PARAM;

	if (FALSE == MLNavItem_GetInfo(plugin.hwndLibraryParent, &itemInfo))
	{
		if (buf) free(buf);
		return;
	}

	if (itemInfo.lParam != percent)
	{
		if (-1 == percent)
			WASABI_API_LNGSTRINGW_BUF(IDS_PORTABLES,buf,256);
		else
			StringCbPrintfW(buf, sizeof(buf), WASABI_API_LNGSTRINGW(IDS_PORTABLES_PERCENT),percent);
	
		itemInfo.mask |= NIMF_TEXT;
		itemInfo.pszText = buf;
		itemInfo.lParam = percent;
		itemInfo.cchTextMax = -1;

		MLNavItem_SetInfo(plugin.hwndLibraryParent, &itemInfo);
	}
	if (buf) free(buf);
}

extern LRESULT CALLBACK TranscodeMsgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
static void EnumDrives(ENUM_DRIVES_CALLBACK callback)
{
	DWORD drives=GetLogicalDrives();
	wchar_t drivestr[4] = L"X:\\";
	for(int i=2;i<25;i++) if(drives&(1<<i))
	{
		EnterCriticalSection(&csenumdrives);
		UINT olderrmode=SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
		drivestr[0] = L'A'+i;
		callback(drivestr[0],GetDriveTypeW(drivestr));
		SetErrorMode(olderrmode);
		LeaveCriticalSection(&csenumdrives);
	}
}

LRESULT CALLBACK DeviceMsgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	if(uMsg == WM_WA_IPC && hwnd != mainMessageWindow) return TranscodeMsgProc(hwnd,uMsg,wParam,lParam);
		switch(uMsg)
		{
			case WM_USER:   // hotkey: sync
				if(devices.GetSize() > 0)
				{
					if (!((DeviceView *)devices.Get(0))->isCloudDevice)
						((DeviceView *)devices.Get(0))->Sync();
					else
						((DeviceView *)devices.Get(0))->CloudSync();
				}
				break;
			case WM_USER+1: // hotkey: autofill
				if(devices.GetSize() > 0)
					((DeviceView *)devices.Get(0))->Autofill();
				break;
			case WM_USER+2: // hotkey: eject
				if(devices.GetSize() > 0)
					((DeviceView *)devices.Get(0))->Eject();
				break;
			case WM_USER+3:
				{
					void (CALLBACK *p)(ULONG_PTR dwParam);
					p =  (void (CALLBACK *)(ULONG_PTR dwParam))wParam;
					p((ULONG_PTR)lParam);
				}
				break;
			case WM_USER+4: // refreshes cloud views (re-checks if we've moved away)
				if (IsWindow(hwndMediaView) && currentViewedDevice && currentViewedDevice->isCloudDevice)
				{
					PostMessage(plugin.hwndLibraryParent, WM_USER + 30, 0, 0);
				}
				break;
			case WM_USER+5:	// removes cloud devices from a cloud sources logout...
			{
				for (int i = devices.GetSize() - 1; i > -1; --i)
				{
					DeviceView * dev = (DeviceView *)devices.Get(i);
					if (dev->isCloudDevice)
						dev->dev->Close();
				}
				break;
			}
			case WM_PMP_IPC:
			{
				switch(lParam)
				{
					case PMP_IPC_DEVICECONNECTED:
						deviceConnected((Device*)wParam);
						break;
					case PMP_IPC_DEVICEDISCONNECTED:
						deviceDisconnected((Device*)wParam);
						break;
					case PMP_IPC_DEVICELOADING:
						deviceLoading((pmpDeviceLoading *)wParam);
						break;
					case PMP_IPC_DEVICENAMECHANGED:
						deviceNameChanged((Device*)wParam);
						break;
					case PMP_IPC_DEVICECLOUDTRANSFER:
					{
						int ret = 0;							
						cloudDeviceTransfer * transfer = (cloudDeviceTransfer *)wParam;
						if (transfer)
						{
							for (int i = 0; i < devices.GetSize(); i++)
							{
								DeviceView * dev = (DeviceView *)devices.Get(i);
								if (dev->dev->extraActions(DEVICE_IS_CLOUD_TX_DEVICE, (intptr_t)transfer->device_token, 0, 0))
								{
									ret = dev->TransferFromML(ML_TYPE_FILENAMESW, (void *)transfer->filenames, 0, 1);
								}
							}
						}
						return ret;
					}
					case PMP_IPC_GETCLOUDTRANSFERS:
					{
						typedef std::vector<wchar_t*> CloudFiles;
						CloudFiles *pending = (CloudFiles *)wParam;
						if (pending)
						{
							cloudTransferQueue.lock();
							// TODO de-dupe incase going to multiple devices...
							for(int i = 0; i < cloudTransferQueue.GetSize(); i++)
							{
								pending->push_back(((CopyInst *)cloudTransferQueue.Get(i))->sourceFile);
							}
							cloudTransferQueue.unlock();

							return pending->size();
						}
						return 0;
					}
					case PMP_IPC_GET_TRANSCODER:
					{
						void * t = (void*)wParam;
						getTranscoder((ULONG_PTR)&t);
						if (t == (void*)wParam) return 0;
						return (LRESULT)t;
					}
					case PMP_IPC_RELEASE_TRANSCODER:
						delete ((TranscoderImp *)wParam);
						break;
					case PMP_IPC_ENUM_ACTIVE_DRIVES:
						{
							if (wParam == 0)
								return (LRESULT)EnumDrives;
							else
								EnumDrives((ENUM_DRIVES_CALLBACK)wParam);
						}
						break;
					case PMP_IPC_GET_INI_FILE:
						for (int i = 0; i < devices.GetSize(); i++)
						{
							DeviceView * dev = (DeviceView *)devices.Get(i);
							if(dev->dev == (Device*)wParam) return (intptr_t)dev->config->GetIniFile();
						}
						break;
					case PMP_IPC_GET_PREFS_VIEW:
					{
						pmpDevicePrefsView *view = (pmpDevicePrefsView *)wParam;
						if (view)
						{
							for (int i = 0; i < devices.GetSize(); i++)
							{
								DeviceView * dev = (DeviceView *)devices.Get(i);
								if (!lstrcmpA(dev->GetName(), view->dev_name))
								{
									return (LRESULT)OnSelChanged(view->parent, view->parent, dev);
								}
							}
						}
						return 0;
					}
				}
			}
		break;
	case WM_DEVICECHANGE:
		{
			int r = wmDeviceChange(wParam,lParam);
			if (r) return r;
		}
		break;
	case WM_TIMER:
		switch(wParam)
		{
			case COMMITTIMERID:
				{
					for(int i=0; i<devices.GetSize(); i++)
					{
						DeviceView * d = (DeviceView *)devices.Get(i);
						LinkedQueue * txQueue = getTransferQueue(d);
						if (txQueue)
						{
							if(d->commitNeeded && !txQueue->GetSize())
							{
								d->commitNeeded = false;
								d->dev->commitChanges();
							}
						}
					}
				}
				break;
		}
		break;
	}
	return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

void UpdateLoadingCaption(wchar_t * caption, void * context)
{
	NAVITEM itemInfo = {0};

	itemInfo.hItem = (HNAVITEM)context;
	if (NULL == itemInfo.hItem)
		return;

	itemInfo.cbSize = sizeof(itemInfo);
	itemInfo.pszText = caption;
	itemInfo.cchTextMax = -1;
	itemInfo.mask = NIMF_TEXT;

	MLNavItem_SetInfo(plugin.hwndLibraryParent, &itemInfo);
}

void deviceLoading(pmpDeviceLoading * load)
{
	if (!AGAVE_API_DEVICEMANAGER)
	{
		wchar_t buffer[256] = {0};
		NAVINSERTSTRUCT nis = {0};
		MLTREEIMAGE devIcon;

		devIcon.resourceId = IDR_DEVICE_ICON;
		devIcon.hinst = plugin.hDllInstance;
		if(load->dev)
			load->dev->extraActions(DEVICE_SET_ICON,(intptr_t)&devIcon,0,0);

		nis.hParent = GetNavigationRoot(TRUE);
		nis.hInsertAfter = NCI_LAST;
		nis.item.cbSize = sizeof(NAVITEM);
		nis.item.mask = NIMF_TEXT | NIMF_TEXTINVARIANT | NIMF_STYLE | NIMF_IMAGE | NIMF_IMAGESEL;
		nis.item.pszText = WASABI_API_LNGSTRINGW_BUF(IDS_LOADING, buffer, ARRAYSIZE(buffer));
		nis.item.pszInvariant = L"device_loading";
		nis.item.style = NIS_ITALIC;
		nis.item.iImage = icon_store.GetResourceIcon(devIcon.hinst, (LPCWSTR)MAKEINTRESOURCE(devIcon.resourceId));
		nis.item.iSelectedImage = nis.item.iImage;
		load->context = MLNavCtrl_InsertItem(plugin.hwndLibraryParent, &nis);
		load->UpdateCaption = UpdateLoadingCaption;
		loadingDevices.Add(load);
	}
}

void finishDeviceLoading(Device * dev)
{
	for(int i=0; i < loadingDevices.GetSize(); i++)
	{
		pmpDeviceLoading * l = (pmpDeviceLoading *)loadingDevices.Get(i);
		if(l->dev == dev) {
			loadingDevices.Del(i);
			HNAVITEM treeItem = (HNAVITEM)l->context;
			MLNavCtrl_DeleteItem(plugin.hwndLibraryParent,treeItem); 
			return;
		}
	}
}

void deviceConnected(Device * dev)
{
	if (!AGAVE_API_DEVICEMANAGER)
		GetNavigationRoot(TRUE);

	Device * oldDev = dev;

	finishDeviceLoading(oldDev);
	if(!devices.GetSize()) startServer();

	DeviceView *pmp_device = new DeviceView(dev);
	devices.Add(pmp_device);
	UpdateDevicesListView(false);
}

void deviceDisconnected(Device * dev)
{
	finishDeviceLoading(dev);
	int cloud_count = 0;
	for(int i = 0; i < devices.GetSize(); i++) 
	{
		DeviceView * d = (DeviceView *)devices.Get(i);
		if(d->dev == dev)
		{
			d->threadKillswitch = 1;
			d->transferContext.WaitForKill();
			devices.Del(i);
			d->Unregister();
			d->Release();
		}
		else
		{
			// to keep the 'cloud library' node on the correct expanded state
			// we need to adjust the cloud sources count due to 'all sources'
			if (_strnicmp(d->GetName(), "all_sources", 11) && d->isCloudDevice)
			{
				cloud_count += 1;
			}
		}
	}

	// if we're only showing a single device, then we can just disable everything else
	if (cloud_count == 0)
	{
		HNAVITEM cloud_transfers = NavigationItem_Find(0, L"cloud_transfers", TRUE);
		if (cloud_transfers != NULL)
		{
			MLNavCtrl_DeleteItem(plugin.hwndLibraryParent, cloud_transfers);
			cloudQueueTreeItem = NULL;
		}

		cloud_transfers = NavigationItem_Find(0, L"cloud_add_sources", TRUE);
		if (cloud_transfers != NULL)
		{
			MLNavCtrl_DeleteItem(plugin.hwndLibraryParent, cloud_transfers);
		}

		cloud_transfers = NavigationItem_Find(0, L"cloud_byos", TRUE);
		if (cloud_transfers != NULL)
		{
			MLNavCtrl_DeleteItem(plugin.hwndLibraryParent, cloud_transfers);
		}

		HNAVITEM cloud = NavigationItem_Find(0, L"cloud_sources", TRUE);
		if (cloud != NULL)
		{
			NAVITEM item = {0};
			item.cbSize = sizeof(NAVITEM);
			item.mask = NIMF_IMAGE | NIMF_IMAGESEL;
			item.hItem = cloud;
			item.iImage = item.iSelectedImage = mediaLibrary.AddTreeImageBmp(IDB_TREEITEM_CLOUD);
			MLNavItem_SetInfo(plugin.hwndLibraryParent, &item);
		}
	}

	UpdateDevicesListView(false);
	if(!devices.GetSize() && !loadingDevices.GetSize() && global_config->ReadInt(L"HideRoot",0))
	{
	    HNAVITEM rootItem = GetNavigationRoot(FALSE);
		if (NULL != rootItem)
			MLNavCtrl_DeleteItem(plugin.hwndLibraryParent, rootItem);
	}
	if(!devices.GetSize()) stopServer();
}

void deviceNameChanged(Device * dev)
{
	finishDeviceLoading(dev);
	for(int i=0; i < devices.GetSize(); i++) 
	{
		DeviceView * d = (DeviceView *)devices.Get(i);
		if(d->dev == dev)
		{
			wchar_t *buffer = (wchar_t*)calloc(sizeof(wchar_t),128);
			if (buffer)
			{
				dev->getPlaylistName(0, buffer, 128);
				UpdateLoadingCaption(buffer, d->treeItem);
				d->SetDisplayName(buffer, 1);
				free(buffer);
			}
			break;
		}
	}
}

svc_imageLoader *GetPngLoaderService()
{
	if (NULL == wasabiPngLoader)
	{
		if (NULL == WASABI_API_MEMMGR)
			return NULL;

		ServiceBuild(wasabiPngLoader, pngLoaderGUID);
	}

	return wasabiPngLoader;
}

BOOL FormatResProtocol(const wchar_t *resourceName, const wchar_t *resourceType, wchar_t *buffer, size_t bufferMax)
{
	unsigned long filenameLength;

	if (NULL == resourceName)
		return FALSE;

	if (FAILED(StringCchCopyExW(buffer, bufferMax, L"res://", &buffer, &bufferMax, 0)))
		return FALSE;

	filenameLength = GetModuleFileNameW(plugin.hDllInstance, buffer, bufferMax);
	if (0 == filenameLength || bufferMax == filenameLength)
		return FALSE;

	buffer += filenameLength;
	bufferMax -= filenameLength;

	if (NULL != resourceType)
	{
		if (FALSE != IS_INTRESOURCE(resourceType))
		{
			if (FAILED(StringCchPrintfExW(buffer, bufferMax, &buffer, &bufferMax, 0, L"/#%d", (int)(INT_PTR)resourceType)))
				return FALSE;
		}
		else
		{
			if (FAILED(StringCchPrintfExW(buffer, bufferMax, &buffer, &bufferMax, 0, L"/%s", resourceType)))
				return FALSE;
		}
	}

	if (FALSE != IS_INTRESOURCE(resourceName))
	{
		if (FAILED(StringCchPrintfExW(buffer, bufferMax, &buffer, &bufferMax, 0, L"/#%d", (int)(INT_PTR)resourceName)))
			return FALSE;
	}
	else
	{
		if (FAILED(StringCchPrintfExW(buffer, bufferMax, &buffer, &bufferMax, 0, L"/%s", resourceName)))
			return FALSE;
	}

	return TRUE;
}

BOOL
CenterWindow(HWND window, HWND centerWindow)
{
	RECT centerRect, windowRect;
	long x, y;

	if (NULL == window ||
		FALSE == GetWindowRect(window, &windowRect))
	{
		return FALSE;
	}

	if (CENTER_OVER_ML_VIEW == centerWindow)
	{
		centerWindow = (HWND)SENDMLIPC(plugin.hwndLibraryParent, ML_IPC_GETCURRENTVIEW, 0);
		if (NULL == centerWindow || FALSE == IsWindowVisible(centerWindow))
			centerWindow = CENTER_OVER_ML;
	}

	if (CENTER_OVER_ML == centerWindow)
	{
		centerWindow = plugin.hwndLibraryParent;
		if (NULL == centerWindow || FALSE == IsWindowVisible(centerWindow))
			centerWindow = CENTER_OVER_WINAMP;
	}
	
	if (CENTER_OVER_WINAMP == centerWindow)
	{
		centerWindow = (HWND)SENDWAIPC(plugin.hwndWinampParent, IPC_GETDIALOGBOXPARENT, 0);
		if (FALSE == IsChild(centerWindow, plugin.hwndLibraryParent))
			centerWindow = NULL;
	}
		
	if (NULL == centerWindow || 
		FALSE == IsWindowVisible(centerWindow) ||
		FALSE == GetWindowRect(centerWindow, &centerRect))
	{
		HMONITOR monitor;
		MONITORINFO monitorInfo;

		monitor = MonitorFromWindow(plugin.hwndWinampParent, MONITOR_DEFAULTTONEAREST);
		
		monitorInfo.cbSize = sizeof(monitorInfo);

		if (NULL == monitor ||
			FALSE == GetMonitorInfo(monitor, &monitorInfo) ||
			FALSE == CopyRect(&centerRect, &monitorInfo.rcWork))
		{
			CopyRect(&centerRect, &windowRect);
		}
	}

	x = centerRect.left + ((centerRect.right - centerRect.left)- (windowRect.right - windowRect.left))/2;
	y = centerRect.top + ((centerRect.bottom - centerRect.top)- (windowRect.bottom - windowRect.top))/2;

	if (x == windowRect.left && y == windowRect.top)
		return FALSE;

	return SetWindowPos(window, NULL, x, y, 0, 0, SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSIZE);
}
ATOM
GetViewAtom()
{
	return viewAtom;
}

void *
GetViewData(HWND hwnd)
{
	return GetPropW(hwnd, (const wchar_t*)MAKEINTATOM(viewAtom));
}

BOOL
SetViewData(HWND hwnd, void *data)
{
	return SetPropW(hwnd, (const wchar_t*)MAKEINTATOM(viewAtom), data);
}

void *
RemoveViewData(HWND hwnd)
{
	return RemovePropW(hwnd, (const wchar_t*)MAKEINTATOM(viewAtom));
}

static void URL_GetParameter(const wchar_t *param_start, char *dest, size_t dest_len)
{
	if (!param_start)
	{
		dest[0]=0;
		return;
	}

	while (param_start && *param_start++ != '=');

	while (param_start && *param_start && dest_len > 1 && *param_start != L'&')
	{
		if (*param_start == '+') 
    {
      param_start++;
      *dest++=' ';
    }
	  else if (*param_start == L'%' && param_start[1] != L'%' && param_start[1])
	  {
		  int a=0;
		  int b=0;
		  for ( b = 0; b < 2; b ++)
		  {
			  int r=param_start[1+b];
			  if (r>='0'&&r<='9') r-='0';
			  else if (r>='a'&&r<='z') r-='a'-10;
			  else if (r>='A'&&r<='Z') r-='A'-10;
			  else break;
			  a*=16;
			  a+=r;
		  }
		  if (b < 2) 
			{
				*dest++=(char)*param_start++;
			}
		  else 
			{
				*dest++=a; 
				param_start += 3;}
	  }
	  else
		{
			*dest++=(char)*param_start++;
		}
	  dest_len--;
	}
	*dest = 0;
}

// this only works for one-character parameters
static const wchar_t *GetParameterStart(const wchar_t *url, wchar_t param)
{
	wchar_t lookup[4] = { L'&', param, L'=', 0 };
	lookup[1] = param;
	const wchar_t *val = wcsstr(url, lookup);
	if (!val)
	{
		lookup[0] = L'?';
		val = wcsstr(url, lookup);
	}
	return val;
}
extern int serverPort;
static INT_PTR PluginMessageProc(int message_type, INT_PTR param1, INT_PTR param2, INT_PTR param3)
{
	int i;
	if (message_type == ML_IPC_HOOKEXTINFOW)
	{
		extendedFileInfoStructW *hookMetadata = (extendedFileInfoStructW *)param1;
		if (hookMetadata->filename && !wcsncmp(hookMetadata->filename, L"http://127.0.0.1:", 17) && _wtoi(hookMetadata->filename + 17) == serverPort)
		{
			if (!_wcsicmp(hookMetadata->metadata, L"artist"))
			{
				char metadata[1024] = {0};
				URL_GetParameter(GetParameterStart(hookMetadata->filename, 'a'), metadata, 1024);
				MultiByteToWideCharSZ(CP_UTF8, 0, metadata, -1, hookMetadata->ret, hookMetadata->retlen);
				return 1;
			}
			else if (!_wcsicmp(hookMetadata->metadata, L"album"))
			{
				char metadata[1024] = {0};
				URL_GetParameter(GetParameterStart(hookMetadata->filename, 'l'), metadata, 1024);
				MultiByteToWideCharSZ(CP_UTF8, 0, metadata, -1, hookMetadata->ret, hookMetadata->retlen);
				return 1;
			}
			else if (!_wcsicmp(hookMetadata->metadata, L"title"))
			{
				char metadata[1024] = {0};
				URL_GetParameter(GetParameterStart(hookMetadata->filename, 't'), metadata, 1024);
				MultiByteToWideCharSZ(CP_UTF8, 0, metadata, -1, hookMetadata->ret, hookMetadata->retlen);
				return 1;
			}
		}
	}

	for(i=0; i < devices.GetSize(); i++)
	{
		DeviceView *deviceView;
		deviceView = (DeviceView *)devices.Get(i);
		if (NULL != deviceView)
		{
			INT_PTR a= deviceView->MessageProc(message_type,param1,param2,param3); 
			if(0 != a) 
				return a;
		}
	}

	
	if (message_type >= ML_MSG_TREE_BEGIN && 
		message_type <= ML_MSG_TREE_END)
	{
		HNAVITEM item, rootItem;
		item = GetNavigationItemFromMessage(message_type, param1);
		rootItem = GetNavigationRoot(FALSE);
		
		if(message_type == ML_MSG_TREE_ONCREATEVIEW)
		{
			for(i=0; i < loadingDevices.GetSize(); i++)
			{
				pmpDeviceLoading * l = (pmpDeviceLoading *)loadingDevices.Get(i);
				if(NULL != l->context)
				{					
					if (((HNAVITEM)l->context) == item)
					{
						HNAVITEM parentItem;
						parentItem = MLNavItem_GetParent(plugin.hwndLibraryParent, item);
						if (NULL == parentItem)
							parentItem = rootItem;

						PostMessage(plugin.hwndLibraryParent, WM_ML_IPC, (WPARAM)parentItem, ML_IPC_NAVITEM_SELECT);
						return 0;
					}
				}
			}
		}

		if(NULL != item && item == rootItem) 
		{
			switch (message_type)
			{
				case ML_MSG_TREE_ONCREATEVIEW:
					return (INT_PTR)WASABI_API_CREATEDIALOGW(IDD_VIEW_PMP_DEVICES,(HWND)param2,pmp_devices_dlgproc);
				case ML_MSG_TREE_ONCLICK:
					switch(param2)
					{
						case ML_ACTION_RCLICK:
							{
								HMENU menu = GetSubMenu(m_context_menus,6);
								int hideRoot = global_config->ReadInt(L"HideRoot",0);
								CheckMenuItem(menu,ID_MAINTREEROOT_AUTOHIDEROOT,hideRoot?MF_CHECKED:MF_UNCHECKED);
								POINT p;
								GetCursorPos(&p);
								int r = Menu_TrackSkinnedPopup(menu,TPM_RETURNCMD|TPM_RIGHTBUTTON|TPM_LEFTBUTTON|TPM_NONOTIFY,p.x,p.y,plugin.hwndLibraryParent,NULL);
								switch(r)
								{
									case ID_MAINTREEROOT_AUTOHIDEROOT:
										hideRoot = hideRoot?0:1;
										global_config->WriteInt(L"HideRoot",hideRoot);
										if(hideRoot && devices.GetSize() == 0)
										{
											MLNavCtrl_DeleteItem(plugin.hwndLibraryParent, rootItem);
										}
										break;
									case ID_MAINTREEROOT_PREFERENCES:
										SENDWAIPC(plugin.hwndWinampParent, IPC_OPENPREFSTOPAGE, &pluginsPrefsPage);
										break;
									case ID_MAINTREEROOT_HELP:
										SENDWAIPC(plugin.hwndWinampParent, IPC_OPEN_URL, L"https://help.winamp.com/hc/articles/8106455294612-Winamp-Portables-Guide");
										break;
								}
							}
							break;
						case ML_ACTION_DBLCLICK:
							break;
						case ML_ACTION_ENTER:
							break;
					}
					break;
				case ML_MSG_TREE_ONDROPTARGET:
					break;
				case ML_MSG_TREE_ONDRAG:
					break;
				case ML_MSG_TREE_ONDROP:
					break;
				case ML_MSG_NAVIGATION_ONDELETE:
					navigationRoot = NULL;
					KillTimer(mainMessageWindow, PROGRESSTIMERID);
					return TRUE;
			}
		}
	}
	else if (message_type == ML_MSG_NO_CONFIG)
	{
		if(prefsPage._id == 0)
			return TRUE;
	}
	else if (message_type == ML_MSG_CONFIG)
	{
		if(prefsPage._id == 0) return 0;
		SendMessage(plugin.hwndWinampParent, WM_WA_IPC, prefsPage._id, IPC_OPENPREFSTOPAGE);
	}
	else if (message_type == ML_MSG_NOTOKTOQUIT)
	{
		// see if we have any transfers in progress and if so then prompt on what to do...
		bool transfers = false;
		for (int i = 0; i < devices.GetSize(); i++)
		{
			DeviceView * d = (DeviceView *)devices.Get(i);
			LinkedQueue * txQueue = getTransferQueue(d);
			if(txQueue && txQueue->GetSize() > 0)
			{
				transfers = true;
				break;
			}
		}

		if (transfers)
		{
			wchar_t titleStr[32] = {0};
			if (MessageBoxW(plugin.hwndLibraryParent, WASABI_API_LNGSTRINGW(IDS_CANCEL_TRANSFERS_AND_QUIT),
				WASABI_API_LNGSTRINGW_BUF(IDS_CONFIRM_QUIT,titleStr,32), MB_YESNO | MB_ICONQUESTION) == IDNO)
				return TRUE;
		}
		return FALSE;
	}
	else if(message_type == ML_MSG_ONSENDTOBUILD)
	{
		if (param1 == ML_TYPE_ITEMRECORDLIST || param1 == ML_TYPE_ITEMRECORDLISTW ||
			param1 == ML_TYPE_FILENAMES || param1 == ML_TYPE_FILENAMESW ||
			param1 == ML_TYPE_PLAYLISTS || param1 == ML_TYPE_PLAYLIST)
		{
			if (gen_mlconfig->ReadInt(L"pmp_send_to", DEFAULT_PMP_SEND_TO))
			{
				for(int m = 0, mode = 0; m < 2; m++, mode++)
				{
					int added = 0;
					for(i = 0; i < devices.GetSize(); i++)
					{
						DeviceView *deviceView;
						deviceView = (DeviceView *)devices.Get(i);
						if (NULL != deviceView)
						{
							if (deviceView->dev->extraActions(DEVICE_SENDTO_UNSUPPORTED, 0, 0, 0) == 0)
							{
								wchar_t buffer[128] = {0};
								deviceView->dev->getPlaylistName(0, buffer, 128);
								if (buffer[0])
								{
									// TODO - this is to block true playlists from appearing on the sendto
									//		for cloud playlists handling - remove this when we can do more
									//		than just uploading the playlist blob without the actual files
									if (deviceView->isCloudDevice && param3 == ML_TYPE_PLAYLIST) continue;

									if (!deviceView->isCloudDevice == mode)
									{
										if (!added)
										{
											mediaLibrary.BranchSendTo(param2);
											added = 1;
										}
										mediaLibrary.AddToBranchSendTo(buffer, param2, reinterpret_cast<INT_PTR>(deviceView));
									}
								}
							}
						}
					}

					if (added)
					{
						mediaLibrary.EndBranchSendTo(WASABI_API_LNGSTRINGW((!m ? IDS_SENDTO_CLOUD : IDS_SENDTO_DEVICES)), param2);
					}
				}
			}
		}
	}

	else if (message_type == ML_MSG_VIEW_PLAY_ENQUEUE_CHANGE)
	{
		enqueuedef = param1;
		groupBtn = param2;
		if (IsWindow(hwndMediaView))
			PostMessage(hwndMediaView, WM_APP + 104, param1, param2);
		return 0;
	}

	return 0;
}

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

	__declspec( dllexport ) int winampUninstallPlugin(HINSTANCE hDllInst, HWND hwndDlg, int param) {
		// cleanup the ml tree so the portables root isn't left

		HNAVITEM rootItem = GetNavigationRoot(FALSE);
		if(NULL != rootItem)
			MLNavCtrl_DeleteItem(plugin.hwndLibraryParent, rootItem);
		
		// prompt to remove our settings with default as no (just incase)
		wchar_t title[256] = {0};
		StringCbPrintfW(title, ARRAYSIZE(title), WASABI_API_LNGSTRINGW(IDS_NULLSOFT_PMP_SUPPORT), PLUGIN_VERSION);
		if(MessageBoxW(hwndDlg,WASABI_API_LNGSTRINGW(IDS_DO_YOU_ALSO_WANT_TO_REMOVE_SETTINGS),
					  title,MB_YESNO|MB_DEFBUTTON2) == IDYES)
		{
			global_config->WriteString(0,0);
		}

		SendMessage(plugin.hwndWinampParent,WM_WA_IPC,(intptr_t)&pluginsPrefsPage,IPC_REMOVE_PREFS_DLG);

		// allow an on-the-fly removal (since we've got to be with a compatible client build)
		return ML_PLUGIN_UNINSTALL_NOW;
	}
};