Initial community commit

1 files changed, 2714 insertions, 0 deletions

diff --git a/Src/Plugins/Library/ml_pmp/DeviceView.cpp b/Src/Plugins/Library/ml_pmp/DeviceView.cpp
new file mode 100644
index 00000000..6f2b8644
--- /dev/null
+++ b/Src/Plugins/Library/ml_pmp/DeviceView.cpp
@@ -0,0 +1,2714 @@
+//#define _WIN32_WINNT 0x0400
+#include "../Winamp/buildType.h"
+#include "main.h"
+#include "DeviceView.h"
+
+//#include <commctrl.h>
+#include "nu/AutoWide.h"
+#include "nu/AutoChar.h"
+#include "../nu/AutoUrl.h"
+#include "SkinnedListView.h"
+#include "../playlist/api_playlistmanager.h"
+#include "../playlist/ifc_playlistdirectorycallback.h"
+#include "../playlist/ifc_playlistloadercallback.h"
+#include "api__ml_pmp.h"
+#include <shlwapi.h>
+#include <time.h>
+#include "metadata_utils.h"
+#include "../ml_wire/ifc_podcast.h"
+#include "./local_menu.h"
+#include "IconStore.h"
+#include "../devices/ifc_deviceevent.h"
+#include "metadata_utils.h"
+#include "../nu/sort.h"
+#include "resource1.h"
+#include <strsafe.h>
+#include "../nu/MediaLibraryInterface.h"
+
+extern C_ItemList devices;
+extern C_Config * global_config;
+
+extern INT_PTR CALLBACK pmp_artistalbum_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam);
+extern INT_PTR CALLBACK pmp_playlist_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam);
+
+int IPC_GET_CLOUD_HINST = -1, IPC_LIBRARY_PLAYLISTS_REFRESH = -1;
+HINSTANCE cloud_hinst = 0;
+int currentViewedPlaylist=0;
+HNAVITEM cloudQueueTreeItem=NULL;
+LinkedQueue cloudTransferQueue, cloudFinishedTransfers;
+int cloudTransferProgress = 0;
+DeviceView * currentViewedDevice=NULL;
+
+volatile size_t TransferContext::paused_all = 0;
+
+extern void UpdateTransfersListView(bool softUpdate, CopyInst * item=NULL);
+extern void UpdateDevicesListView(bool softUpdate);
+extern INT_PTR CALLBACK config_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam);
+extern HWND mainMessageWindow;
+extern prefsDlgRecW prefsPage;
+extern int prefsPageLoaded;
+static int thread_id;
+
+static bool copySettings(wchar_t * ssrc, wchar_t * sdest);
+static __int64 fileSize(wchar_t * filename);
+static void removebadchars(wchar_t *s);
+
+extern ThreadID *transfer_thread;
+int TransferThreadPoolFunc(HANDLE handle, void *user_data, intptr_t id);
+
+INT_PTR CALLBACK pmp_queue_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam);
+INT_PTR CALLBACK pmp_video_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam);
+
+DeviceView::DeviceView(Device *dev) 
+	: activityRunning(FALSE), navigationItemCreated(FALSE), usedSpace(0), totalSpace(0)
+{
+	memset(name, 0, sizeof(name));
+	queueActiveIcon = isCloudDevice = 0;
+	treeItem = videoTreeItem = queueTreeItem = 0;
+	connection_type = "USB";
+	display_type = "Portable Media Player";
+	metadata_fields = (int)dev->extraActions(DEVICE_SUPPORTED_METADATA,0,0,0);
+	if(!metadata_fields)
+		metadata_fields = -1;
+	dev->extraActions(DEVICE_GET_CONNECTION_TYPE, (intptr_t)&connection_type, 0, 0);
+	isCloudDevice = (!lstrcmpiA(connection_type, "cloud"));
+	dev->extraActions(DEVICE_GET_DISPLAY_TYPE, (intptr_t)&display_type, 0, 0);
+	ref_count = 1;
+	if (dev->extraActions(DEVICE_GET_UNIQUE_ID, (intptr_t)name, sizeof(name), 0) == 0)
+	{
+		// fallback
+		GUID name_guid;
+		CoCreateGuid(&name_guid);
+		StringCbPrintfA(name, sizeof(name), "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
+			(int)name_guid.Data1, (int)name_guid.Data2, (int)name_guid.Data3,
+			(int)name_guid.Data4[0], (int)name_guid.Data4[1],
+			(int)name_guid.Data4[2], (int)name_guid.Data4[3],
+			(int)name_guid.Data4[4], (int)name_guid.Data4[5],
+			(int)name_guid.Data4[6], (int)name_guid.Data4[7] );
+	}
+
+	wchar_t inifile[MAX_PATH] = {0};
+	dev->extraActions(DEVICE_GET_INI_FILE,(intptr_t)inifile,0,0);
+	if(!inifile[0])
+	{
+		wchar_t name[256] = {0};
+		dev->getPlaylistName(0,name,256);
+		removebadchars(name);
+		// build this slow so we make sure each directory exists
+		PathCombine(inifile, WASABI_API_APP->path_getUserSettingsPath(), L"Plugins");
+		CreateDirectory(inifile, NULL);
+		PathAppend(inifile, L"ml");
+		CreateDirectory(inifile, NULL);
+		wchar_t ini_filespec[MAX_PATH] = {0};
+		StringCchPrintf(ini_filespec, MAX_PATH, L"ml_pmp_device_%s.ini",name);
+		PathAppend(inifile, ini_filespec);
+	}
+
+	if(fileSize(inifile) <= 0) copySettings(global_config->GetIniFile(),inifile); //  import old settings
+	config = new C_Config(inifile,L"ml_pmp",global_config);
+
+	currentTransferProgress = 0;
+	transferRate=0;
+	commitNeeded=false;
+	this->dev = dev;
+	wchar_t deviceName[256]=L"";
+	dev->getPlaylistName(0,deviceName,sizeof(deviceName)/sizeof(wchar_t));
+
+	if (!isCloudDevice) videoView = config->ReadInt(L"showVideoView",dev->extraActions(DEVICE_SUPPORTS_VIDEO,0,0,0));
+	else videoView = 0;
+
+	prefsDlgRecW *parentPrefs = (prefsDlgRecW *)dev->extraActions(DEVICE_GET_PREFS_PARENT, 0, 0, 0);
+	if (!parentPrefs)
+	{
+		// only add it when we're using our own root page, otherwise skip this
+		if (!prefsPageLoaded)
+		{
+			SendMessage(plugin.hwndWinampParent,WM_WA_IPC,(intptr_t)&prefsPage,IPC_ADD_PREFS_DLGW);
+		}
+		prefsPageLoaded+=1;
+	}
+
+	if (lstrcmpi(deviceName, L"all_sources"))
+	{
+		devPrefsPage.hInst=WASABI_API_LNG_HINST;
+		devPrefsPage.where=(parentPrefs ? (intptr_t)parentPrefs : (intptr_t)&prefsPage);
+		devPrefsPage.dlgID=IDD_CONFIG;
+		devPrefsPage.name=_wcsdup(deviceName);
+		devPrefsPage.proc=config_dlgproc;
+		SendMessage(plugin.hwndWinampParent,WM_WA_IPC,(intptr_t)&devPrefsPage,IPC_ADD_PREFS_DLGW);
+	}
+	else
+	{
+		memset(&devPrefsPage, 0, sizeof(prefsDlgRecW));
+	}
+
+	UpdateSpaceInfo(TRUE, FALSE);
+
+	threadKillswitch = 0;
+	transferContext.transfer_thread = WASABI_API_THREADPOOL->ReserveThread(api_threadpool::FLAG_LONG_EXECUTION);
+	transferContext.dev = this;
+	WASABI_API_THREADPOOL->AddHandle(transferContext.transfer_thread, transferContext.notifier, TransferThreadPoolFunc, &transferContext, thread_id, api_threadpool::FLAG_LONG_EXECUTION);
+	thread_id++;
+
+	if (AGAVE_API_DEVICEMANAGER)
+	{
+		ifc_device *registered_device = this;
+		AGAVE_API_DEVICEMANAGER->DeviceRegister(&registered_device, 1);
+	}
+	//hTransferThread = CreateThread(NULL, 0, ThreadFunc_Transfer, (LPVOID)this, 0, &dwThreadId);
+	/*
+	if(dev->getDeviceCapacityTotal() > L3000000000) SyncConnectionDefault=1;
+	else SyncConnectionDefault=2;
+	*/
+	SyncConnectionDefault=0; // default off for now.
+	if (!isCloudDevice)
+	{
+		// ok all started. Now do any "on connect" actions...
+		time_t lastSync = (time_t)config->ReadInt(L"syncOnConnect_time",0);
+		time_t now = time(NULL);
+		//int diff = now - lastSync;
+		double diff = difftime(now,lastSync);
+		config->WriteInt(L"syncOnConnect_time",(int)now);
+		if(diff > config->ReadInt(L"syncOnConnect_hours",12)*3600)
+		{
+			switch(config->ReadInt(L"syncOnConnect",SyncConnectionDefault))
+			{
+				case 1:
+				{
+					if (!isCloudDevice) Sync(true);
+					//else CloudSync(true);
+				}
+				break;
+				case 2: Autofill(); break;
+			}
+		}
+	}
+	if (!AGAVE_API_DEVICEMANAGER)
+		RegisterViews(0);
+}
+HNAVITEM GetNavigationRoot(BOOL forceCreate);
+HNAVITEM NavigationItem_Find(HNAVITEM root, const wchar_t *name, BOOL allow_root = 0);
+
+void DeviceView::RegisterViews(HNAVITEM parent)
+{
+	NAVINSERTSTRUCT nis = {0};
+	NAVITEM *item = 0;
+	wchar_t buffer[128] = {0};
+
+	item = &nis.item;
+
+	if(!parent)
+	{
+		MLTREEIMAGE devIcon;
+		wchar_t deviceName[256]=L"";
+
+		devIcon.resourceId = IDR_DEVICE_ICON;
+		devIcon.hinst = plugin.hDllInstance;
+		dev->extraActions(DEVICE_SET_ICON,(intptr_t)&devIcon,0,0);
+
+		dev->getPlaylistName(0,deviceName,sizeof(deviceName)/sizeof(wchar_t));
+
+		nis.hParent = GetNavigationRoot(TRUE);
+		nis.hInsertAfter = NCI_LAST;
+		item->cbSize = sizeof(NAVITEM);
+		item->mask = NIMF_TEXT | NIMF_TEXTINVARIANT | NIMF_STYLE | NIMF_IMAGE | NIMF_IMAGESEL;
+
+		item->pszText = deviceName;
+		item->pszInvariant = nis.item.pszText;
+		item->style = NIS_HASCHILDREN;
+		item->styleMask = item->style,
+		item->iImage = icon_store.GetResourceIcon(devIcon.hinst, MAKEINTRESOURCE(devIcon.resourceId));
+		item->iSelectedImage = item->iImage;
+
+		treeItem = parent = MLNavCtrl_InsertItem(plugin.hwndLibraryParent, &nis);
+
+		navigationItemCreated = TRUE;
+	}
+	else
+	{
+		treeItem = parent;
+		navigationItemCreated = FALSE;
+
+		item->cbSize = sizeof(NAVITEM);
+		item->mask = NIMF_STYLE;
+		item->hItem = treeItem;
+		item->style = NIS_HASCHILDREN;
+		item->styleMask = NIS_HASCHILDREN;
+
+		MLNavItem_SetInfo(plugin.hwndLibraryParent, item);
+
+		/* create transfer view */
+		// TODO: create this view dynamically
+		HNAVITEM cloud = 0;
+		if (isCloudDevice)
+		{
+			cloud = NavigationItem_Find(0, L"cloud_sources", TRUE);
+			if (cloud != NULL) parent = cloud;
+		}
+
+#if 0
+		int mode = gen_mlconfig->ReadInt(L"txviewpos", 0);
+		if (mode == 1)
+		{
+			nis.hParent = cloud;//parent;
+			nis.hInsertAfter = NCI_FIRST;
+		}
+		else if (mode == 2)
+		{
+			nis.hParent = NavigationItem_Find(0, L"ml_devices_root", TRUE);
+			nis.hInsertAfter = NCI_FIRST;
+		}
+#else
+		nis.hParent = parent;
+#endif
+
+		item->cbSize = sizeof(NAVITEM);
+		item->mask = NIMF_TEXT | NIMF_TEXTINVARIANT | NIMF_IMAGE | NIMF_IMAGESEL;
+		item->pszText = WASABI_API_LNGSTRINGW_BUF(IDS_TRANSFERS, buffer, 128);
+		item->pszInvariant = (isCloudDevice ? L"cloud_transfers" : L"transfers");
+		item->iImage = icon_store.GetQueueIcon();
+		item->iSelectedImage = nis.item.iImage;
+
+#if 0
+		if (!cloudQueueTreeItem && isCloudDevice)
+		{
+			NAVINSERTSTRUCT nis2 = {0};
+			nis2.item.cbSize = sizeof(NAVITEM);
+			nis2.item.pszText = WASABI_API_LNGSTRINGW(IDS_ADD_SOURCE);
+			nis2.item.pszInvariant = L"cloud_add_sources";
+			nis2.item.mask = NIMF_TEXT | NIMF_TEXTINVARIANT | NIMF_IMAGE | NIMF_IMAGESEL | NIMF_STYLE;
+			nis2.item.iImage = nis2.item.iSelectedImage = mediaLibrary.AddTreeImageBmp(IDB_TREEITEM_CLOUD_ADD_SOURCE);
+			nis2.hParent = parent;
+			nis2.hInsertAfter = NCI_FIRST;
+			HNAVITEM item = MLNavCtrl_InsertItem(plugin.hwndLibraryParent, &nis2);
+			if (mode == 1) nis.hInsertAfter = item;
+			queueTreeItem = cloudQueueTreeItem = MLNavCtrl_InsertItem(plugin.hwndLibraryParent, &nis);
+
+#if 0
+			nis2.item.pszText = L"BYOS";//WASABI_API_LNGSTRINGW(IDS_ADD_SOURCE);
+			nis2.item.pszInvariant = L"cloud_byos";
+			nis2.item.mask = NIMF_TEXT | NIMF_TEXTINVARIANT | NIMF_IMAGE | NIMF_IMAGESEL | NIMF_STYLE;
+			nis2.item.iImage = nis2.item.iSelectedImage = mediaLibrary.AddTreeImageBmp(IDB_TREEITEM_CLOUD_ADD_BYOS);
+			nis2.hParent = parent;
+			nis2.hInsertAfter = nis.hInsertAfter;
+			MLNavCtrl_InsertItem(plugin.hwndLibraryParent, &nis2);
+#endif
+		}
+		else
+			queueTreeItem = cloudQueueTreeItem;
+#endif
+			queueTreeItem = MLNavCtrl_InsertItem(plugin.hwndLibraryParent, &nis);
+	}
+
+	/* create video view */
+	if (videoView)
+	{
+		nis.hParent = parent;
+		nis.hInsertAfter = NCI_LAST;
+		item->cbSize = sizeof(NAVITEM);
+		item->mask = NIMF_TEXT | NIMF_TEXTINVARIANT | NIMF_IMAGE | NIMF_IMAGESEL;
+		item->pszText =  WASABI_API_LNGSTRINGW_BUF(IDS_VIDEO, buffer, 128);
+		item->pszInvariant = L"video";
+		item->iImage = icon_store.GetVideoIcon();
+		item->iSelectedImage = nis.item.iImage;
+	
+		videoTreeItem = MLNavCtrl_InsertItem(plugin.hwndLibraryParent, &nis);
+	}
+	else
+		videoTreeItem = 0;
+
+	/* create playlists */
+	int l = (dev ? dev->getPlaylistCount() : 0);
+	for(int i=1; i<l; i++)
+	{
+		AddPlaylistNode(i);
+	}
+}
+
+DeviceView::~DeviceView()
+{
+	if(configDevice == this) SendMessage(plugin.hwndWinampParent,WM_WA_IPC,(intptr_t)&prefsPage,IPC_OPENPREFSTOPAGE);
+
+	// remove it when we're removed what we added
+	int lastPrefsPageLoaded = prefsPageLoaded;
+	prefsPageLoaded-=1;
+	if(lastPrefsPageLoaded == 1)
+	{
+		SendMessage(plugin.hwndWinampParent,WM_WA_IPC,(intptr_t)&prefsPage,IPC_REMOVE_PREFS_DLG);
+	}
+
+	//OutputDebugString(L"device unloading started");
+	// get rid of the transfer thread
+	threadKillswitch=1;
+	transferContext.WaitForKill();
+	if(threadKillswitch != 100)
+	{
+		/*OutputDebugString(L"FUCKO");*/
+	}
+
+	SendMessage(plugin.hwndWinampParent,WM_WA_IPC,(intptr_t)&devPrefsPage,IPC_REMOVE_PREFS_DLG);
+	free(devPrefsPage.name);
+	//OutputDebugString(L"device unloading finished");
+	delete config;
+}
+
+void DeviceView::SetVideoView(BOOL enabled)
+{
+	videoView=enabled;
+	config->WriteInt(L"showVideoView",videoView);
+	if(videoView)
+	{
+		/* add video before the playlists */
+		wchar_t buffer[128] = {0};
+		NAVINSERTSTRUCT nis = {0};
+		nis.item.cbSize = sizeof(NAVITEM);
+		nis.item.pszText =  WASABI_API_LNGSTRINGW_BUF(IDS_VIDEO, buffer, 128);
+		nis.item.pszInvariant = L"video";
+		nis.item.mask = NIMF_TEXT | NIMF_TEXTINVARIANT | NIMF_IMAGE | NIMF_IMAGESEL;
+		nis.hParent = treeItem;
+		nis.hInsertAfter = NCI_FIRST;
+		nis.item.iImage = icon_store.GetVideoIcon();
+		nis.item.iSelectedImage = nis.item.iImage;
+		videoTreeItem = MLNavCtrl_InsertItem(plugin.hwndLibraryParent, &nis);
+	}
+	else
+	{
+		MLNavCtrl_DeleteItem(plugin.hwndLibraryParent, videoTreeItem);
+		videoTreeItem = 0;
+	}
+}
+
+static void removebadchars(wchar_t *s)
+{
+	while (s && *s)
+	{
+		if (*s == L'?' || *s == L'/' || *s == L'\\' || *s == L':' || *s == L'*' || *s == L'\"' || *s == L'<' || *s == L'>' || *s == L'|') 
+			*s = L'_';
+		s = CharNextW(s);
+	}
+}
+
+static __int64 fileSize(wchar_t * filename)
+{
+	WIN32_FIND_DATA f= {0};
+	HANDLE h = FindFirstFileW(filename,&f);
+	if(h == INVALID_HANDLE_VALUE) return -1;
+	FindClose(h);
+	ULARGE_INTEGER i;
+	i.HighPart = f.nFileSizeHigh;
+	i.LowPart = f.nFileSizeLow;
+	return i.QuadPart;
+}
+
+static bool copySettings(wchar_t * ssrc, wchar_t * sdest)
+{
+	FILE * src, * dest;
+	src=_wfopen(ssrc,L"rt");
+	if(!src) return false;
+	dest=_wfopen(sdest,L"wt");
+	if(!dest)
+	{
+		fclose(src); return false;
+	}
+	wchar_t buf[1024]=L"";
+	bool insection=false;
+	while(fgetws(buf,1024,src))
+	{
+		if(buf[0]==L'[' && wcslen(buf)>1) if(buf[wcslen(buf)-2]==L']') insection=false;
+		if(wcscmp(&buf[0],L"[ml_pmp]\n")==0) insection=true;
+		if(insection) fputws(&buf[0],dest);
+	}
+	fclose(src);
+	fclose(dest);
+	return true;
+}
+
+HNAVITEM DeviceView::AddPlaylistNode(int id)
+{
+	NAVINSERTSTRUCT nis = {0};
+	wchar_t title[256] = {0}, name[128] = {0};
+
+	dev->getPlaylistName(id, title , ARRAYSIZE(title));
+
+	StringCchPrintf(name, ARRAYSIZE(name), L"ml_pmp_playlist_%d", id);
+	
+	nis.hParent = treeItem;
+	nis.hInsertAfter = NCI_LAST;
+
+	memset(&nis.item, 0, sizeof(nis.item));
+	nis.item.cbSize = sizeof(NAVITEM);
+	nis.item.pszText = title;
+	nis.item.pszInvariant = name;
+	nis.item.mask = NIMF_TEXT | NIMF_TEXTINVARIANT | NIMF_IMAGE | NIMF_IMAGESEL | NIMF_STYLE;
+	nis.item.iImage = icon_store.GetPlaylistIcon();
+	nis.item.iSelectedImage = nis.item.iImage;
+	nis.item.style = NIS_ALLOWEDIT;
+	nis.item.styleMask = nis.item.style;
+	
+	HNAVITEM item = MLNavCtrl_InsertItem(plugin.hwndLibraryParent, &nis);
+	playlistTreeItems.push_back(item);
+
+	return item;
+}
+
+int DeviceView::CreatePlaylist(wchar_t * name, bool silent)
+{
+	HNAVITEM item;
+	int playlistId;
+	
+	if (NULL == name)
+	{
+		int count, slot, length;
+		wchar_t buffer[512] = {0}, buffer2[ARRAYSIZE(buffer)] = {0};
+		BOOL foundMatch;
+
+		name = WASABI_API_LNGSTRINGW_BUF(IDS_NEW_PLAYLIST, buffer, ARRAYSIZE(buffer));
+
+		count = dev->getPlaylistCount();
+		slot = 1;
+		length = -1;
+
+		do
+		{
+			foundMatch = FALSE;
+			for (int i = 1; i < count; i++)
+			{
+				
+				dev->getPlaylistName(i, buffer2, ARRAYSIZE(buffer2));
+				if (CSTR_EQUAL == CompareString(LOCALE_USER_DEFAULT, NORM_IGNORECASE, buffer2, -1, name, -1))
+				{
+					foundMatch = TRUE;
+					
+					if(name != buffer)
+					{
+						if (FAILED(StringCchCopy(buffer, ARRAYSIZE(buffer), name)))
+							return -1;
+					}
+
+					if (-1 == length)
+					{
+						wchar_t *end;
+						length = lstrlen(buffer);
+						end = buffer + length;
+						
+						if(length > 2 && L')' == *(--end))
+						{			
+							unsigned short charType;
+
+							for(wchar_t *begin = --end; begin != buffer; begin--)
+							{
+								if (L'(' == *begin)
+								{
+									if (begin > buffer && L' ' == *(--begin))
+									{
+										length = (int)(intptr_t)(begin - buffer);
+										slot = 0;
+									}
+									break;
+								}
+								else if (FALSE == GetStringTypeW(CT_CTYPE1, begin, 1, &charType) ||
+									0 == (C1_DIGIT & charType))
+								{
+									break;
+								}
+							}
+						}
+					}
+					
+					slot++;
+
+					if (1 == slot)
+						buffer[length] = L'\0';
+					else if (FAILED(StringCchPrintf(buffer + length, ARRAYSIZE(buffer) - length, L" (%d)", slot)))
+						return false;
+					
+					break;
+				}
+			}
+		} while(FALSE != foundMatch);
+	}
+
+	playlistId = dev->newPlaylist(name);
+	if(playlistId == -1) 
+		return -1; // failed
+	
+	item = AddPlaylistNode(playlistId);
+	if (NULL == item)
+	{
+		dev->deletePlaylist(playlistId);
+		return -1;
+	}
+
+	DevicePropertiesChanges();
+
+	if(!silent)
+		MLNavItem_EditTitle(plugin.hwndLibraryParent, item);
+		
+	return playlistId;
+}
+
+void DeviceView::RenamePlaylist(int playlistId)
+{
+	HNAVITEM item;
+
+	item = NULL;
+
+	if (0 == playlistId)
+	{
+		if (0 != dev->extraActions(DEVICE_CAN_RENAME_DEVICE,0,0,0))
+			item = treeItem;
+	}
+	else
+	{
+		if (playlistId > 0 && playlistId <= (int)playlistTreeItems.size())
+			item = playlistTreeItems[playlistId - 1];
+	}
+	
+	if (NULL != item)
+		MLNavItem_EditTitle(plugin.hwndLibraryParent, item);
+}
+
+size_t DeviceView::GetPlaylistName(wchar_t *buffer, size_t bufferSize, int playlistId, 
+								const wchar_t *defaultName, BOOL quoteSpaces)
+{
+	size_t length;
+
+	if (NULL == buffer || 0 == bufferSize)
+		return 0;
+
+	buffer[0] = L'\0';
+	if (NULL != dev)
+		dev->getPlaylistName(playlistId, buffer, bufferSize);
+
+	if (FAILED(StringCchLength(buffer, bufferSize, &length)))
+		return 0;
+	
+	if (0 == length)
+	{
+		if (NULL != defaultName)
+		{
+			if (FALSE != IS_INTRESOURCE(defaultName))
+				WASABI_API_LNGSTRINGW_BUF((int)(intptr_t)defaultName, buffer, bufferSize);
+			else
+			{
+				if (FAILED(StringCchCopy(buffer, bufferSize, defaultName)))
+					return 0;
+			}
+
+			if (FAILED(StringCchLength(buffer, bufferSize, &length)))
+				return 0;
+		}
+	}
+	else
+	{
+		if (FALSE != quoteSpaces &&	
+			(L' ' == buffer[0] || L' ' == buffer[length-1]) &&
+			(bufferSize - length) > 2)
+		{
+			memmove(buffer + 1, buffer, sizeof(wchar_t) * length);
+			buffer[0] = L'\"';
+			buffer[length++] = L'\"';
+			buffer[length] = L'\0';
+		}
+	}
+	return length;
+}
+
+bool DeviceView::DeletePlaylist(int playlistId, bool deleteFiles, bool verbal)
+{
+	int index;
+	C_ItemList delList;
+	
+	if(playlistId < 1) 
+		return false;
+
+	index = playlistId - 1;
+	
+	if (false != deleteFiles)
+	{
+		int length;
+
+		length = dev->getPlaylistLength(playlistId);
+		for(int i = 0; i < length; i++) 
+		{
+			delList.Add((void*)dev->getPlaylistTrack(playlistId, i));
+		}
+	}
+
+	if (false != verbal)
+	{
+		wchar_t message[1024] = {0}, title[1024] = {0}, playlistName[256] = {0}, deviceName[256] = {0};
+
+		GetPlaylistName(playlistName, ARRAYSIZE(playlistName), playlistId, NULL, FALSE);
+		GetPlaylistName(deviceName, ARRAYSIZE(deviceName), 0, MAKEINTRESOURCE(IDS_DEVICE_LOWERCASE), TRUE);
+
+		if (0 != delList.GetSize())
+		{
+			WASABI_API_LNGSTRINGW_BUF(IDS_PHYSICALLY_REMOVE_X_TRACKS, title, ARRAYSIZE(title));
+			StringCchPrintf(message, ARRAYSIZE(message), title, delList.GetSize(), playlistName);
+
+			WASABI_API_LNGSTRINGW_BUF(IDS_DELETE_PLAYLIST_TITLE, title, ARRAYSIZE(title));
+		}
+		else
+		{
+			WASABI_API_LNGSTRINGW_BUF(IDS_DELETE_PLAYLIST, title, ARRAYSIZE(title));
+			StringCchPrintf(message, ARRAYSIZE(message), title, playlistName, deviceName);
+
+			WASABI_API_LNGSTRINGW_BUF(IDS_DELETE_PLAYLIST_TITLE, title, ARRAYSIZE(title));
+		}
+		
+		if(IDYES != MessageBox(plugin.hwndLibraryParent, message, title, 
+						MB_YESNO | MB_ICONWARNING))
+		{
+			return false;
+		}
+	}
+
+	if (0 != delList.GetSize())
+	{
+		int result;
+		result = DeleteTracks(&delList, CENTER_OVER_ML_VIEW);
+		if (IDABORT == result) /* user abort */
+			return false;
+
+		if (IDOK != result) /* error */
+		{
+			
+		}
+
+	}
+	
+	HNAVITEM item = playlistTreeItems[index];
+	playlistTreeItems.erase(playlistTreeItems.begin() + index);
+
+	MLNavCtrl_DeleteItem(plugin.hwndLibraryParent, item);
+	
+	dev->deletePlaylist(playlistId);
+	DevicePropertiesChanges();
+
+	return true;
+}
+
+bool DeviceView::GetTransferFromMlSupported(int dataType)
+{
+	switch(dataType)
+	{
+		case ML_TYPE_ITEMRECORDLISTW:
+		case ML_TYPE_ITEMRECORDLIST:
+		case ML_TYPE_PLAYLIST:
+		case ML_TYPE_PLAYLISTS:
+		case ML_TYPE_FILENAMES:
+		case ML_TYPE_FILENAMESW:
+			return true;
+	}
+	return false;
+}
+intptr_t DeviceView::TransferFromML(int type, void* data, int unsupportedReturn, int supportedReturn, int playlist)
+{
+	int r;
+
+	if (AGAVE_API_STATS)
+	{
+		wchar_t device_name[128] = {0};
+		if(dev->extraActions(DEVICE_GET_MODEL, (intptr_t)device_name, 128, 0) == 1 && device_name[0])
+		{
+			AGAVE_API_STATS->SetString("pmp", device_name);
+		}
+	}
+
+	if(type == ML_TYPE_ITEMRECORDLISTW)
+	{
+		r=AddItemListToTransferQueue((itemRecordListW*)data,playlist);
+	}
+	else if(type == ML_TYPE_ITEMRECORDLIST)
+	{
+		itemRecordListW list= {0};
+		convertRecordList(&list,(itemRecordList*)data);
+		r=AddItemListToTransferQueue(&list,playlist);
+		freeRecordList(&list);
+	}
+	else if(type == ML_TYPE_FILENAMES)
+	{
+		C_ItemList fileList;
+		char * filenames = (char *)data;
+		while(filenames && *filenames)
+		{
+			fileList.Add(filenames);
+			filenames+=strlen(filenames)+1;
+		}
+		r=AddFileListToTransferQueue((char**)fileList.GetAll(),fileList.GetSize(),playlist);
+	}
+	else if(type == ML_TYPE_FILENAMESW)
+	{
+		C_ItemList fileList;
+		wchar_t * filenames = (wchar_t *)data;
+		while(filenames && *filenames)
+		{
+			fileList.Add(filenames);
+			filenames+=wcslen(filenames)+1;
+		}
+		r=AddFileListToTransferQueue((wchar_t**)fileList.GetAll(),fileList.GetSize(),playlist);
+	}
+	else if(type == ML_TYPE_PLAYLIST)
+	{
+		mlPlaylist * pl = (mlPlaylist *)data;
+		TransferPlaylist((wchar_t*)pl->filename,(wchar_t*)pl->title);
+		r=0;
+	}
+	else if(type == ML_TYPE_PLAYLISTS)
+	{
+		mlPlaylist **playlists = (mlPlaylist **)data;
+		while(playlists && *playlists)
+		{
+			mlPlaylist *pl = *playlists;
+			TransferPlaylist((wchar_t*)pl->filename,(wchar_t*)pl->title);
+			playlists++;
+		}
+		r=0;
+	}
+	else return unsupportedReturn;
+
+	wchar_t errStr[32] = {0};
+	if(r==-1)
+		MessageBox(plugin.hwndLibraryParent,
+		           WASABI_API_LNGSTRINGW(IDS_DEVICE_OUT_OF_SPACE),
+		           WASABI_API_LNGSTRINGW_BUF(IDS_ERROR,errStr,32),0);
+	else if(r==-2)
+		MessageBox(plugin.hwndLibraryParent,
+		           WASABI_API_LNGSTRINGW(IDS_INCOMPATABLE_FORMAT_NO_TX),
+		           WASABI_API_LNGSTRINGW_BUF(IDS_ERROR,errStr,32),0);
+
+	return supportedReturn;
+}
+
+
+class ItemListRefLoader : public ifc_playlistloadercallback
+{
+public:
+	ItemListRefLoader(C_ItemList &itemList, C_ItemList &playlistItemList) : fileList(itemList), playlistList(playlistItemList)
+	{
+	}
+	void OnFile(const wchar_t *filename, const wchar_t *title, int lengthInMS, ifc_plentryinfo *info)
+	{
+		if(playlistManager->CanLoad(filename))
+			playlistList.Add(_wcsdup(filename));
+		else
+			fileList.Add(_wcsdup(filename));
+	}
+
+	C_ItemList &fileList, &playlistList;
+protected:
+	RECVS_DISPATCH;
+};
+
+#define CBCLASS ItemListRefLoader
+START_DISPATCH;
+VCB( IFC_PLAYLISTLOADERCALLBACK_ONFILE, OnFile )
+END_DISPATCH;
+#undef CBCLASS
+
+
+class PlaylistDirectoryCallback : public ifc_playlistdirectorycallback
+{
+public:
+	PlaylistDirectoryCallback(const wchar_t *_extlist) : extlist(_extlist)
+	{
+	}
+
+	bool ShouldRecurse(const wchar_t *path)
+	{
+		// TODO: check for recursion?
+		return true;
+	}
+
+	bool ShouldLoad(const wchar_t *filename)
+	{
+		if(playlistManager->CanLoad(filename))
+			return true;
+		const wchar_t *ext = PathFindExtensionW(filename);
+		if(!*ext)
+			return false;
+
+		ext++;
+
+		const wchar_t *a = extlist;
+		while(a && *a)
+		{
+			if(!_wcsicmp(a, ext))
+				return true;
+			a += wcslen(a) + 1;
+		}
+		return false;
+	}
+
+	const wchar_t *extlist;
+
+protected:
+	RECVS_DISPATCH;
+};
+
+#define CBCLASS PlaylistDirectoryCallback
+START_DISPATCH;
+CB(IFC_PLAYLISTDIRECTORYCALLBACK_SHOULDRECURSE, ShouldRecurse)
+CB(IFC_PLAYLISTDIRECTORYCALLBACK_SHOULDLOAD, ShouldLoad)
+END_DISPATCH;
+#undef CBCLASS
+
+intptr_t DeviceView::TransferFromDrop(HDROP hDrop, int playlist)
+{
+	// benski> ugh. memory allocation hell.  oh well
+	C_ItemList fileList;
+	C_ItemList playlistList;
+	const wchar_t *extListW = (const wchar_t *)SendMessageW(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GET_EXTLISTW);
+	PlaylistDirectoryCallback dirCB(extListW);
+	wchar_t temp[2048] = {0};
+	int y = DragQueryFileW(hDrop, 0xffffffff, temp, 2048);
+
+	for(int x = 0; x < y; x ++)
+	{
+		DragQueryFileW(hDrop, x, temp, 2048);
+		// see if it's a directory
+		bool isDir=false;
+		if(!PathIsURLW(temp) && !PathIsNetworkPathW(temp))
+		{
+			HANDLE h;
+			WIN32_FIND_DATAW d;
+
+			h = FindFirstFileW(temp, &d);
+			if(h != INVALID_HANDLE_VALUE)
+			{
+				FindClose(h);
+				if(d.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+				{
+					ItemListRefLoader fileListCB(fileList, playlistList);
+					playlistManager->LoadDirectory(temp, &fileListCB, &dirCB);
+					isDir=true;
+				}
+			}
+		}
+
+		if(!isDir)
+		{
+			if(playlistManager->CanLoad(temp))
+				playlistList.Add(_wcsdup(temp));
+			else
+				fileList.Add(_wcsdup(temp));
+		}
+	}
+
+	int r=0, r2=0;
+	if(fileList.GetSize())
+		r=AddFileListToTransferQueue((wchar_t**)fileList.GetAll(),fileList.GetSize(),playlist);
+#if 0
+	if(playlistList.GetSize())
+		r2=AddFileListToTransferQueue((wchar_t**)playlistList.GetAll(), playlistList.GetSize(),1/*playlists*/);
+#endif
+	wchar_t errStr[32] = {0};
+	if(r==-1 || r2==-1)
+		MessageBox(plugin.hwndLibraryParent,
+		           WASABI_API_LNGSTRINGW(IDS_DEVICE_OUT_OF_SPACE),
+		           WASABI_API_LNGSTRINGW_BUF(IDS_ERROR,errStr,32),0);
+	if(r==-2 || r2 == -2)
+		MessageBox(plugin.hwndLibraryParent,
+		           WASABI_API_LNGSTRINGW(IDS_INCOMPATABLE_FORMAT_NO_TX),
+		           WASABI_API_LNGSTRINGW_BUF(IDS_ERROR,errStr,32),0);
+
+	// benski> my CS301 professor would be proud!
+	fileList.for_all(free);
+	playlistList.for_all(free);
+
+	GlobalFree((HGLOBAL)extListW);
+	return 0;
+}
+
+HWND DeviceView::CreateView(HWND parent)
+{
+	currentViewedDevice=this;
+	currentViewedPlaylist=0;
+
+	if (currentViewedDevice->config->ReadInt(L"media_numfilters", 2) == 1)
+		return WASABI_API_CREATEDIALOGPARAMW((isCloudDevice ? IDD_VIEW_CLOUD_SIMPLE : IDD_VIEW_PMP_VIDEO),
+											 parent, pmp_video_dlgproc, (currentViewedDevice->isCloudDevice ? 1 : 2));
+	else
+		return WASABI_API_CREATEDIALOGPARAMW((isCloudDevice ? IDD_VIEW_CLOUD_ARTISTALBUM : IDD_VIEW_PMP_ARTISTALBUM),
+											 parent, pmp_artistalbum_dlgproc, 0);
+}
+
+BOOL DeviceView::DisplayDeviceContextMenu(HNAVITEM item, HWND hostWindow, POINT pt)
+{
+	HMENU menu = GetSubMenu(m_context_menus,3);
+	if (NULL == menu)
+		return FALSE;
+
+	if(dev->extraActions(DEVICE_CAN_RENAME_DEVICE,0,0,0))
+		AppendMenu(menu,0,ID_TREEPLAYLIST_RENAMEPLAYLIST,WASABI_API_LNGSTRINGW(IDS_RENAME_DEVICE));
+
+	int r = Menu_TrackSkinnedPopup(menu, TPM_RETURNCMD|TPM_RIGHTBUTTON|TPM_LEFTBUTTON|TPM_NONOTIFY,
+								   pt.x, pt.y, plugin.hwndLibraryParent, NULL);
+
+	if(dev->extraActions(DEVICE_CAN_RENAME_DEVICE,0,0,0))
+		DeleteMenu(menu,ID_TREEPLAYLIST_RENAMEPLAYLIST,MF_BYCOMMAND);
+
+	switch(r)
+	{
+		case ID_TREEDEVICE_NEWPLAYLIST:
+			CreatePlaylist();
+			break;
+		case ID_TREEDEVICE_EJECTDEVICE:
+			Eject();
+			break;
+		case ID_TREEPLAYLIST_RENAMEPLAYLIST:
+			MLNavItem_EditTitle(plugin.hwndLibraryParent, item);
+			//RenamePlaylist(0);
+			break;
+	}
+
+	return TRUE;
+}
+
+BOOL DeviceView::DisplayPlaylistContextMenu(int playlistId, HNAVITEM item, HWND hostWindow, POINT pt)
+{
+	HMENU menu = GetSubMenu(m_context_menus,4);
+	if (NULL == menu)
+		return FALSE;
+							
+	EnableMenuItem(menu,ID_TREEPLAYLIST_COPYPLAYLISTTOLOCALMEDIA, 
+			MF_BYCOMMAND | (dev->copyToHardDriveSupported()? MF_ENABLED : (MF_DISABLED | MF_GRAYED)));
+
+	int r = Menu_TrackSkinnedPopup(menu,TPM_RETURNCMD|TPM_RIGHTBUTTON|TPM_LEFTBUTTON|TPM_NONOTIFY,
+								   pt.x, pt.y, plugin.hwndLibraryParent, NULL);
+	switch(r)
+	{
+		case ID_TREEPLAYLIST_RENAMEPLAYLIST:
+			MLNavItem_EditTitle(plugin.hwndLibraryParent, item);
+			break;
+		case ID_TREEPLAYLIST_REMOVEPLAYLISTANDFILES:
+			DeletePlaylist(playlistId, true, true);
+			break;
+		case ID_TREEPLAYLIST_REMOVEPLAYLIST:
+			DeletePlaylist(playlistId, false, true);
+			break;
+		case ID_TREEPLAYLIST_COPYPLAYLISTTOLOCALMEDIA:
+			CopyPlaylistToLibrary(playlistId);
+			break;
+	}
+
+	return TRUE;
+}
+static HNAVITEM Navigation_GetItemFromMessage(INT msg, INT_PTR param)
+{
+	return (msg < ML_MSG_NAVIGATION_FIRST) ? 
+			MLNavCtrl_FindItemById(plugin.hwndLibraryParent, param) : 
+			(HNAVITEM)param;
+}
+
+BOOL DeviceView::Navigation_IsPlaylistItem(HNAVITEM item, int *playlistId)
+{
+	for(size_t i=0; i < playlistTreeItems.size(); i++)
+	{
+		if(item == playlistTreeItems[i])
+		{
+			if (NULL != playlistId)
+				*playlistId = (i + 1);
+
+			return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+
+HWND DeviceView::Navigation_CreateViewCb(HNAVITEM item, HWND parentWindow)
+{
+	if(item == treeItem)
+	{
+		if (FALSE != navigationItemCreated)
+		{
+			currentViewedDevice = this;
+			currentViewedPlaylist = 0;
+			return WASABI_API_CREATEDIALOGW((currentViewedDevice->isCloudDevice ? IDD_VIEW_CLOUD_ARTISTALBUM : IDD_VIEW_PMP_ARTISTALBUM), parentWindow, pmp_artistalbum_dlgproc);
+		}
+	}
+	else if (item == queueTreeItem)
+	{
+		currentViewedDevice = this;
+		currentViewedPlaylist = 0;
+		return WASABI_API_CREATEDIALOGPARAMW((currentViewedDevice->isCloudDevice ? IDD_VIEW_CLOUD_QUEUE : IDD_VIEW_PMP_QUEUE), parentWindow, pmp_queue_dlgproc, (LPARAM)this);
+	}
+	else if(item == videoTreeItem)
+	{
+		currentViewedDevice = this;
+		currentViewedPlaylist = 0;
+		return WASABI_API_CREATEDIALOGPARAMW(IDD_VIEW_PMP_VIDEO, parentWindow, pmp_video_dlgproc, 0);
+	}
+	else
+	{
+		if (FALSE != Navigation_IsPlaylistItem(item, &currentViewedPlaylist))
+		{
+			currentViewedDevice = this;
+			return WASABI_API_CREATEDIALOGW(IDD_VIEW_PMP_PLAYLIST, parentWindow, pmp_playlist_dlgproc);
+		}
+	}
+
+	return NULL;
+}
+
+BOOL DeviceView::Navigation_ShowContextMenuCb(HNAVITEM item, HWND hostWindow, POINT pt)
+{
+	if (item == treeItem)
+	{
+		if (FALSE != navigationItemCreated)
+			return DisplayDeviceContextMenu(item, hostWindow, pt);
+	}
+	else
+	{
+		int playlistId;
+		if (FALSE != Navigation_IsPlaylistItem(item, &playlistId))
+			return DisplayPlaylistContextMenu(playlistId, item, hostWindow, pt);
+	}
+
+	return FALSE;
+}
+BOOL DeviceView::Navigation_ClickCb(HNAVITEM item, int actionType, HWND hostWindow)
+{
+	int playlistId;
+
+	switch(actionType)
+	{
+		case ML_ACTION_DBLCLICK:
+		case ML_ACTION_ENTER:
+			if (FALSE != Navigation_IsPlaylistItem(item, &playlistId))
+			{	
+				PlayPlaylist(playlistId, false, true, hostWindow);
+				return TRUE;
+			}
+			break;
+	}
+	
+	return FALSE;
+}
+
+int DeviceView::Navigation_DropTargetCb(HNAVITEM item, unsigned int dataType, void *data)
+{
+	if (item == treeItem)
+	{
+		if (FALSE != navigationItemCreated)
+		{
+			if(NULL == data)
+				return (false != GetTransferFromMlSupported(dataType)) ? 1 : -1;
+				
+			return TransferFromML(dataType, data, -1, 1);
+		}
+	}
+	else
+	{
+		int playlistId;
+		if (FALSE != Navigation_IsPlaylistItem(item, &playlistId))
+		{
+			if(NULL == data)
+				return (false != GetTransferFromMlSupported(dataType)) ? 1 : -1;
+				
+			return TransferFromML(dataType, data, -1, 1, playlistId);
+		}
+	}
+
+	return FALSE;
+}
+
+BOOL DeviceView::Navigation_TitleEditBeginCb(HNAVITEM item)
+{
+	if (item == treeItem)
+	{
+		if (FALSE != navigationItemCreated && 
+			FALSE == dev->extraActions(DEVICE_CAN_RENAME_DEVICE,0,0,0))
+		{
+			return TRUE;
+		}
+	}
+	
+	return FALSE;
+}
+BOOL DeviceView::Navigation_TitleEditEndCb(HNAVITEM item, const wchar_t *title)
+{
+	int playlistId = 0;
+	wchar_t buffer[512] = {0};
+
+	if (item == treeItem)
+	{
+		if (FALSE == navigationItemCreated)
+			return FALSE;
+
+		playlistId = 0;
+	}
+	else
+	{		
+		if (FALSE == Navigation_IsPlaylistItem(item, &playlistId))
+			return FALSE;
+	}
+
+	if (NULL == title)
+		return TRUE;
+
+	buffer[0] = L'\0';
+	dev->getPlaylistName(playlistId, buffer, ARRAYSIZE(buffer));
+			
+	if (CSTR_EQUAL == CompareString(LOCALE_USER_DEFAULT, 0, buffer, -1, title, -1))
+		return TRUE;
+
+	dev->setPlaylistName(playlistId, title);
+	DevicePropertiesChanges();
+
+	buffer[0] = L'\0';
+	dev->getPlaylistName(playlistId, buffer, ARRAYSIZE(buffer));
+
+	if (0 == playlistId)
+	{
+		free(devPrefsPage.name);
+		devPrefsPage.name = _wcsdup(buffer);
+
+		UpdateDevicesListView(false);
+		OnNameChanged(buffer);
+	}
+
+	if (CSTR_EQUAL == CompareString(LOCALE_USER_DEFAULT, 0, buffer, -1, title, -1))
+		return TRUE;
+
+	NAVITEM itemInfo;
+	itemInfo.cbSize = sizeof(itemInfo);
+	itemInfo.pszText = buffer;
+	itemInfo.hItem = item;
+	itemInfo.mask = NIMF_TEXT;
+	MLNavItem_SetInfo(plugin.hwndLibraryParent, &itemInfo);
+
+	return FALSE;
+}
+
+BOOL DeviceView::Navigation_KeyDownCb(HNAVITEM item, NMTVKEYDOWN *keyData, HWND hwnd)
+{
+	int playlistId;
+	if (item == treeItem)
+	{
+		if (FALSE == navigationItemCreated)
+			return FALSE;
+
+		switch(keyData->wVKey)
+		{
+			case VK_F2:
+				MLNavItem_EditTitle(plugin.hwndLibraryParent, item);
+				break;
+		}
+		return TRUE;
+	}
+
+	if (FALSE != Navigation_IsPlaylistItem(item, &playlistId))
+	{
+		switch(keyData->wVKey)
+		{
+			case VK_F2:
+				MLNavItem_EditTitle(plugin.hwndLibraryParent, item);
+				break;
+
+			case VK_DELETE:
+				DeletePlaylist(playlistId, false, true);
+				break;
+		}
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+intptr_t DeviceView::MessageProc(int message_type, intptr_t param1, intptr_t param2, intptr_t param3)
+{
+	if(message_type >= ML_MSG_TREE_BEGIN && message_type <= ML_MSG_TREE_END)
+	{		
+		HNAVITEM item;
+
+		switch(message_type)
+		{
+			case ML_MSG_TREE_ONCREATEVIEW: 
+				item = Navigation_GetItemFromMessage(message_type, param1);
+				return (INT_PTR)Navigation_CreateViewCb(item, (HWND)param2);
+			case ML_MSG_NAVIGATION_CONTEXTMENU:
+			{
+				POINT pt;
+				POINTSTOPOINT(pt, MAKEPOINTS(param3));
+				item = Navigation_GetItemFromMessage(message_type, param1);
+				return (INT_PTR)Navigation_ShowContextMenuCb(item, (HWND)param2, pt);
+			}
+			case ML_MSG_TREE_ONCLICK:
+				item = Navigation_GetItemFromMessage(message_type, param1);
+				return (INT_PTR)Navigation_ClickCb(item, (int)param2, (HWND)param3);
+			case ML_MSG_TREE_ONDROPTARGET:
+				item = Navigation_GetItemFromMessage(message_type, param1);
+				return (INT_PTR)Navigation_DropTargetCb(item, (unsigned int)param2, (void*)param3);
+			case ML_MSG_NAVIGATION_ONBEGINTITLEEDIT:
+				item = Navigation_GetItemFromMessage(message_type, param1);
+				return (INT_PTR)Navigation_TitleEditBeginCb(item);
+			case ML_MSG_NAVIGATION_ONENDTITLEEDIT:
+				item = Navigation_GetItemFromMessage(message_type, param1);
+				return (INT_PTR)Navigation_TitleEditEndCb(item, (const wchar_t*)param2);
+			case ML_MSG_TREE_ONKEYDOWN:
+				item = Navigation_GetItemFromMessage(message_type, param1);
+				return (INT_PTR)Navigation_KeyDownCb(item, (NMTVKEYDOWN*)param2, (HWND)param3);
+		}
+	}
+	else if(message_type == ML_MSG_ONSENDTOBUILD)
+	{
+		if (!gen_mlconfig->ReadInt(L"pmp_send_to", DEFAULT_PMP_SEND_TO))
+		{
+			if (param1 == ML_TYPE_ITEMRECORDLIST || param1 == ML_TYPE_ITEMRECORDLISTW ||
+				param1 == ML_TYPE_FILENAMES || param1 == ML_TYPE_FILENAMESW ||
+				param1 == ML_TYPE_PLAYLIST || param1 == ML_TYPE_PLAYLISTS)
+			{
+				if (dev->extraActions(DEVICE_SENDTO_UNSUPPORTED, 0, 0, 0) == 0)
+				{
+					wchar_t buffer[128] = {0};
+					dev->getPlaylistName(0, buffer, 128);
+					mediaLibrary.AddToSendTo(buffer, param2, reinterpret_cast<INT_PTR>(this));
+				}
+			}
+		}
+	}
+	else if(message_type == ML_MSG_ONSENDTOSELECT && param2 && param3 == (intptr_t)this)
+	{
+		// TODO!!!
+		// if we get a playlist or playlist list and we can match it to a cloud device then
+		// we check for 'hss' and if so then process as a cloud playlist else do as before
+		if (this->isCloudDevice && (param1 == ML_TYPE_PLAYLIST || param1 == ML_TYPE_PLAYLISTS))
+		{
+			char name[128] = {0};
+			if (dev->extraActions(DEVICE_GET_UNIQUE_ID, (intptr_t)name, sizeof(name), 0))
+			{
+				if (!strcmp(name, "hss"/*HSS_CLIENT*/))
+				{
+					if(param1 == ML_TYPE_PLAYLIST)
+					{
+						mlPlaylist * pl = (mlPlaylist *)param2;
+						TransferAddCloudPlaylist((wchar_t*)pl->filename, (wchar_t*)pl->title);
+					}
+					else if(param1 == ML_TYPE_PLAYLISTS)
+					{
+						mlPlaylist **playlists = (mlPlaylist **)param2;
+						while(playlists && *playlists)
+						{
+							mlPlaylist *pl = *playlists;
+							TransferAddCloudPlaylist((wchar_t*)pl->filename, (wchar_t*)pl->title);
+							playlists++;
+						}
+					}
+					return 1;
+				}
+			}
+		}
+
+		UpdateActivityState();
+		return TransferFromML(param1,(void*)param2,0,1);
+	}
+	return 0;
+}
+
+void DeviceView::DevicePropertiesChanges()
+{
+	commitNeeded=true;
+	SetEvent(transferContext.notifier);
+}
+
+void DeviceView::Eject()
+{
+	LinkedQueue * txQueue = getTransferQueue(this);
+	if(txQueue && txQueue->GetSize() == 0)
+	{
+		dev->Eject();
+	}
+	else
+	{
+		wchar_t titleStr[32] = {0};
+		MessageBox(plugin.hwndLibraryParent,WASABI_API_LNGSTRINGW(IDS_SYNC_IS_IN_PROGRESS),
+		           WASABI_API_LNGSTRINGW_BUF(IDS_CANNOT_EJECT,titleStr,32),0);
+	}
+}
+
+Device * deleteTrackDev;
+C_ItemList * deleteTracks;
+extern HWND hwndMediaView;
+
+static INT_PTR CALLBACK pmp_delete_progress_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam)
+{
+	static int i;
+	static songid_t s;
+	switch(uMsg)
+	{
+		case WM_INITDIALOG:
+			i=0;
+			s=0;
+			SetWindowText(hwndDlg,WASABI_API_LNGSTRINGW((!currentViewedDevice || currentViewedDevice && !currentViewedDevice->isCloudDevice ? IDS_DELETING_TRACKS : IDS_REMOVING_TRACKS)));
+			SendDlgItemMessage(hwndDlg,IDC_PROGRESS,PBM_SETRANGE,0,MAKELPARAM(0, (!deleteTracks ? 0 : deleteTracks->GetSize())));
+			SetTimer(hwndDlg,0,5,NULL);
+
+			if (FALSE != CenterWindow(hwndDlg, (HWND)lParam))
+				SendMessage(hwndDlg, DM_REPOSITION, 0, 0L);
+
+			break;
+		case WM_TIMER:
+			if(wParam == 1)
+			{
+				KillTimer(hwndDlg,wParam);
+				SendDlgItemMessage(hwndDlg,IDC_PROGRESS,PBM_SETPOS,i,0);
+				if(i < deleteTracks->GetSize())
+				{
+					songid_t s2 = (songid_t)deleteTracks->Get(i++);
+					if(s != s2)
+					{
+						if(hwndMediaView) SendMessage(hwndMediaView,WM_USER+1,(WPARAM)s2,0);
+						deleteTrackDev->deleteTrack(s2);
+						s=s2;
+					}
+					SetTimer(hwndDlg,1,5,NULL);
+				}
+				else EndDialog(hwndDlg, IDOK);
+			}
+			else if(wParam == 0)
+			{
+				KillTimer(hwndDlg,0);
+				int s = deleteTracks->GetSize();
+				for(int i=0; i<s; i++)
+				{
+					void * p = deleteTracks->Get(i);
+					for(int j=i+1; j<s; j++)
+					{
+						if(p == deleteTracks->Get(j))
+						{
+							deleteTracks->Del(j--); s--;
+						}
+					}
+				}
+				SetTimer(hwndDlg,1,5,NULL);
+			}
+			break;
+		case WM_COMMAND:
+			if(LOWORD(wParam) == IDC_ABORT)
+				EndDialog(hwndDlg, IDABORT);
+			break;
+	}
+	return 0;
+}
+int DeviceView::DeleteTracks(C_ItemList * tracks, HWND centerWindow)
+{
+	LinkedQueue * txQueue = getTransferQueue(this);
+	if(txQueue && txQueue->GetSize() > 0)
+	{
+		wchar_t sorry[32] = {0};
+		MessageBox(plugin.hwndLibraryParent,WASABI_API_LNGSTRINGW(IDS_CANNOT_REMOVE_TRACKS_WHILE_TRANSFERING),
+		           WASABI_API_LNGSTRINGW_BUF(IDS_SORRY,sorry,32),0);
+		return -1;
+	}
+	if (dev && tracks)
+	{
+		deleteTrackDev = dev;
+		deleteTracks = tracks;
+		return WASABI_API_DIALOGBOXPARAMW(IDD_PROGRESS, plugin.hwndLibraryParent, pmp_delete_progress_dlgproc, (LPARAM)centerWindow);
+	}
+	return IDABORT;
+}
+
+int DeviceView::AddFileListToTransferQueue(char ** files, int num, int playlist)
+{
+	wchar_t ** filesW = (wchar_t**)calloc(num, sizeof(wchar_t*));
+	for(int i=0; i<num; i++)
+	{
+		filesW[i] = AutoWideDup(files[i]);
+	}
+	int r = AddFileListToTransferQueue(filesW,num,playlist);
+	for(int i=0; i<num; i++)
+	{
+		free(filesW[i]);
+	}
+	free(filesW);
+	return r;
+}
+
+int DeviceView::AddFileListToTransferQueue(wchar_t ** files, int num, int playlist)
+{
+	C_ItemList * irs = fileListToItemRecords(files,num, CENTER_OVER_ML_VIEW);
+	int r = AddItemListToTransferQueue(irs,playlist);
+	for(int i=0; i < irs->GetSize(); i++)
+	{
+		itemRecordW * it = (itemRecordW *)irs->Get(i);
+		freeRecord(it);
+		free(it);
+	}
+	delete irs;
+	return r;
+}
+
+void TransfersListPushPopItem(CopyInst * item, DeviceView *view);
+int DeviceView::AddItemListToTransferQueue(C_ItemList * items, int playlist)
+{
+	if(playlist == 0)
+	{
+		if (!isCloudDevice)
+		{
+			int r=0;
+			C_ItemList toSend, haveSent;
+			ProcessDatabaseDifferences(dev,items,&haveSent,&toSend,NULL,NULL);
+			LinkedQueue * txQueue = getTransferQueue(this);
+			if (txQueue)
+			{
+				txQueue->lock();
+
+				for(int i = 0; i < toSend.GetSize(); i++)
+				{
+					if((r = this->AddTrackToTransferQueue(this, (itemRecordW*)toSend.Get(i), true)) == -1) break;
+				}
+	
+				txQueue->unlock();
+			}
+			return r;
+		}
+		else
+		{
+			int r=0;
+			LinkedQueue * txQueue = getTransferQueue(this);
+			if (txQueue)
+			{
+				txQueue->lock();
+	
+				for(int i = 0; i < items->GetSize(); i++)
+				{
+					if((r = this->AddTrackToTransferQueue(this, (itemRecordW*)items->Get(i), true)) == -1) break;
+				}
+	
+				txQueue->unlock();
+			}
+			return r;
+		}
+	}
+	else
+	{
+		return TransferTracksToPlaylist(items,playlist);
+	}
+}
+
+int DeviceView::AddItemListToTransferQueue(itemRecordListW * items, int playlist)
+{
+	if(playlist == 0)
+	{
+		if (!isCloudDevice)
+		{
+			int r=0;
+			C_ItemList toSend;
+			ProcessDatabaseDifferences(dev,items,NULL,&toSend,NULL,NULL);
+			LinkedQueue * txQueue = getTransferQueue(this);
+			if (txQueue)
+			{
+				txQueue->lock();
+				for (int i = 0; i < toSend.GetSize(); i++)
+					if((r = this->AddTrackToTransferQueue(this, (itemRecordW*)toSend.Get(i), true)) == -1) break;
+				txQueue->unlock();
+			}
+			return r;
+		}
+		else
+		{
+			int r=0;
+			LinkedQueue * txQueue = getTransferQueue(this);
+			if (txQueue)
+			{
+				txQueue->lock();
+				for (int i = 0; i < items->Size; i++)
+					if((r = this->AddTrackToTransferQueue(this, &items->Items[i], true)) == -1) break;
+				txQueue->unlock();
+			}
+			return r;
+		}
+	}
+	else
+	{
+		C_ItemList itemRecords;
+		for (int i = 0; i < items->Size; i++) itemRecords.Add(&items->Items[i]);
+		return TransferTracksToPlaylist(&itemRecords,playlist);
+	}
+}
+
+class ItemListLoader : public ifc_playlistloadercallback
+{
+public:
+	void OnFile(const wchar_t *filename, const wchar_t *title, int lengthInMS, ifc_plentryinfo *info)
+	{
+		fileList.Add(_wcsdup(filename));
+	}
+
+	void FreeAll()
+	{
+		fileList.for_all(free);
+	}
+	C_ItemList fileList;
+protected:
+	RECVS_DISPATCH;
+};
+
+#define CBCLASS ItemListLoader
+START_DISPATCH;
+VCB( IFC_PLAYLISTLOADERCALLBACK_ONFILE, OnFile )
+END_DISPATCH;
+#undef CBCLASS
+
+void DeviceView::TransferPlaylist(wchar_t * file, wchar_t * name0)
+{
+	// first sort the name out
+	if(!file) return;
+	wchar_t name[256] = {0};
+	if(!name0)
+	{
+		wchar_t * s = wcsrchr(file,L'\\');
+		if(!s) s = wcsrchr(file,L'/');
+		if(!s) s = file;
+		else s++;
+		if(wcslen(s) >= 255) s[255]=0;
+		StringCchCopy(name,256, s);
+		wchar_t * e = wcsrchr(name,L'.');
+		if(e) *e=0;
+	}
+	else lstrcpyn(name,name0,255);
+	name[255]=0;
+	// name sorted, parse m3u
+
+	ItemListLoader fileList;
+	playlistManager->Load(file, &fileList);
+	C_ItemList *itemRecords = fileListToItemRecords(&fileList.fileList, CENTER_OVER_ML_VIEW);
+	fileList.FreeAll();
+
+	// now we have a list of itemRecords, lets try and add this playlist to the device!
+	int plid = CreatePlaylist(name,true);
+	if(plid != -1)
+		TransferTracksToPlaylist(itemRecords,plid);
+	delete itemRecords;
+}
+
+int DeviceView::TransferTracksToPlaylist(C_ItemList *itemRecords, int plid)
+{
+	wchar_t name[256] = {0};
+	dev->getPlaylistName(plid,name,256);
+	int i;
+	for(i=0; i<itemRecords->GetSize(); i++)
+	{
+		itemRecordW * ice = (itemRecordW *)itemRecords->Get(i);
+		wchar_t num[12] = {0};
+		StringCchPrintf(num, 12, L"%x",i);
+		setRecordExtendedItem(ice,L"PLN",num);
+	}
+	C_ItemList irAlreadyOn, siAlreadyOn;
+	ProcessDatabaseDifferences(dev,itemRecords,&irAlreadyOn,NULL,&siAlreadyOn,NULL);
+	// itemRecords_sort, irAlreadyOn, irTransfer and siAlreadyOn will NOT be in playlist order
+	// we must get them into playlist order. In O(n) :/
+	int l = itemRecords->GetSize();
+	PlaylistAddItem * pl = (PlaylistAddItem*)calloc(l,sizeof(PlaylistAddItem));
+	int on=0;
+	for(i=0; i < l; i++)
+	{
+		itemRecordW * ice = (itemRecordW *)itemRecords->Get(i);
+		int n;
+		swscanf(getRecordExtendedItem(ice,L"PLN"),L"%x",&n);
+		if(n >= l)
+		{
+			continue;
+		}
+		pl[n].item = ice;
+		if(on < irAlreadyOn.GetSize()) if((itemRecordW*)irAlreadyOn.Get(on) == ice)   // this track is on the device!
+			{
+				pl[n].songid = (songid_t)siAlreadyOn.Get(on);
+				on++;
+			}
+	}
+
+	// awesome! pl now contains our playlist in proper order with the "songid" fields set if the track is on the device.
+	C_ItemList * directAdd = new C_ItemList;
+	int m = 0;
+	LinkedQueue * txQueue = getTransferQueue(this);
+	if (txQueue)
+	{
+		PlaylistCopyInst * inst = NULL;
+		txQueue->lock();
+		for(i=0; i < l; i++)
+		{
+			if(pl[i].songid)
+			{
+				directAdd->Add((void*)pl[i].songid);
+			}
+			else
+			{
+				int r = dev->trackAddedToTransferQueue(pl[i].item);
+				if(r)
+				{
+					m |= (-r);
+					freeRecord(pl[i].item);
+					continue;
+				}
+				if(!inst)
+				{
+					if(plid != -1) for(int i=0; i<directAdd->GetSize(); i++)
+							dev->addTrackToPlaylist(plid,(songid_t)directAdd->Get(i));
+					delete directAdd;
+				}
+				else
+				{
+					inst->plAddSongs = directAdd;
+					AddTrackToTransferQueue(inst);
+				}
+				directAdd = new C_ItemList;
+				inst = new PlaylistCopyInst(this,pl[i].item,name,plid);
+			}
+			freeRecord(pl[i].item);
+		}
+		if(inst)
+		{
+			inst->plAddSongs = directAdd;
+			AddTrackToTransferQueue(inst);
+		}
+		else     // NULL inst means no transfers!
+		{
+			if(plid != -1) for(int i=0; i<directAdd->GetSize(); i++)
+					dev->addTrackToPlaylist(plid,(songid_t)directAdd->Get(i));
+			delete directAdd;
+		}
+		txQueue->unlock();
+	}
+	if (pl) free(pl);
+
+	wchar_t warnStr[32] = {0};
+	WASABI_API_LNGSTRINGW_BUF(IDS_WARNING,warnStr,32);
+	if(m == 1) MessageBox(plugin.hwndLibraryParent,WASABI_API_LNGSTRINGW(IDS_NATS_DEVICE_MAYBE_FULL),warnStr,0);
+	else if(m == 2) MessageBox(plugin.hwndLibraryParent,WASABI_API_LNGSTRINGW(IDS_NATS_SOME_OF_INCOMPATABLE_FORMAT),warnStr,0);
+	else if(m == 3) MessageBox(plugin.hwndLibraryParent,WASABI_API_LNGSTRINGW(IDS_NATS_MAYBE_FULL_AND_INCOMPATABLE_FORMAT),warnStr,0);
+	return 0;
+}
+
+void DeviceView::TransferAddCloudPlaylist(wchar_t * file, wchar_t * name0)
+{
+	if (!file) return;
+
+	AGAVE_API_PLAYLISTS->Lock();
+	for (size_t index = 0; index < AGAVE_API_PLAYLISTS->GetCount(); index++)
+	{
+		const wchar_t* filename = AGAVE_API_PLAYLISTS->GetFilename(index);
+		if (!lstrcmpiW(filename, file))
+		{
+			int cloud = 1;
+			if (AGAVE_API_PLAYLISTS->GetInfo(index, api_playlists_cloud, &cloud, sizeof(cloud)) == API_PLAYLISTS_SUCCESS)
+			{
+				// not set as a cloud playlist so we need to set and then announce
+				if (!cloud)
+				{
+					cloud = 1;
+					AGAVE_API_PLAYLISTS->SetInfo(index, api_playlists_cloud, &cloud, sizeof(cloud));
+					AGAVE_API_PLAYLISTS->Flush();
+				}
+
+				if (!cloud_hinst) cloud_hinst = (HINSTANCE)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GET_CLOUD_HINST);
+				if (cloud_hinst && cloud_hinst != (HINSTANCE)1)
+				{
+					winampMediaLibraryPlugin *(*gp)();
+					gp = (winampMediaLibraryPlugin * (__cdecl *)(void))GetProcAddress(cloud_hinst, "winampGetMediaLibraryPlugin");
+					if (gp)
+					{
+						winampMediaLibraryPlugin *mlplugin = gp();
+						if (mlplugin && (mlplugin->version >= MLHDR_VER_OLD && mlplugin->version <= MLHDR_VER))
+						{
+							mlplugin->MessageProc(0x406, index, 0, 0);
+						}
+					}
+				}
+				PostMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_LIBRARY_PLAYLISTS_REFRESH);
+			}
+			else
+			{
+			}
+			break;
+		}
+	}
+	AGAVE_API_PLAYLISTS->Unlock();
+}
+
+extern MLTREEITEMW mainTreeItem;
+
+HWND hwndToolTips=NULL;
+
+int DeviceView::AddTrackToTransferQueue(CopyInst * inst)
+{
+	LinkedQueue * txQueue = getTransferQueue(this);
+	if (txQueue)
+	{
+		txQueue->Offer(inst);
+		if(txQueue->GetSize() == 1)
+			SetEvent(transferContext.notifier);
+		device_update_map[0] = true;
+		device_update_map[inst->dev] = true;
+	}
+	return 0;
+}
+
+int DeviceView::AddTrackToTransferQueue(DeviceView * device, itemRecordW * item, bool dupeCheck, bool forceDupe)
+{
+	SongCopyInst * inst = new SongCopyInst(device, item);
+
+	if (dupeCheck)
+	{
+		LinkedQueue * txQueue = getTransferQueue(this);
+		if (txQueue)
+		{
+			txQueue->lock();
+			// current queue dupe check
+			for(int i = 0; i < txQueue->GetSize(); i++)
+			{
+				if(((CopyInst *)txQueue->Get(i))->Equals(inst))
+				{
+					delete inst;
+					txQueue->unlock();
+					return 0;
+				}
+			}
+			txQueue->unlock();
+		}
+	}
+
+	if (!forceDupe)
+	{
+		int r = dev->trackAddedToTransferQueue(&inst->song);
+		if (r)
+		{
+			if (r == 2)
+			{
+				inst->status = STATUS_DONE;
+				inst->res = 2;
+				AddTrackToTransferQueue(inst);
+				return 0;
+			}
+			else
+			{
+				delete inst;
+			}
+		}
+		else AddTrackToTransferQueue(inst);
+		return r;
+	}
+	else
+	{
+		inst->res = 2;
+		AddTrackToTransferQueue(inst);
+		return 0;
+	}
+}
+
+class SyncItemListLoader : public ifc_playlistloadercallback
+{
+public:
+	void OnFile(const wchar_t *filename, const wchar_t *title, int lengthInMS, ifc_plentryinfo *info)
+	{
+		if(pos < len)
+		{
+			songs[pos].filename = _wcsdup(filename);
+			metaToGet->Add(&songs[pos].map);
+			songMaps->Add(&songs[pos].pladd);
+		}
+		pos++;
+	}
+	int pos,len;
+	songMapping * songs;
+	C_ItemList * metaToGet, * songMaps;
+protected:
+	RECVS_DISPATCH;
+};
+
+#define CBCLASS SyncItemListLoader
+START_DISPATCH;
+VCB(IFC_PLAYLISTLOADERCALLBACK_ONFILE, OnFile)
+END_DISPATCH;
+#undef CBCLASS
+
+typedef struct
+{
+	mlPlaylistInfo info;
+	songMapping * songs;
+} SyncPlaylist;
+
+void TransfersListUpdateItem(CopyInst * item);
+void TransfersListUpdateItem(CopyInst * item, DeviceView *view);
+/*
+static int setPlaylistTrack(Device * dev, int pl, int n, int len, songid_t song) {
+if(n >= len) { while(n >= len) { dev->addTrackToPlaylist(pl,song); len++; } return len; }
+else {
+dev->addTrackToPlaylist(pl,song);
+dev->playlistSwapItems(pl,len,n);
+dev->removeTrackFromPlaylist(pl,len);
+}
+return len;
+}
+*/
+class PlaylistSyncCopyInst : public CopyInst
+{
+public:
+	bool memFreed;
+	C_ItemList *songMaps;
+	C_ItemList * playlists;
+	PlaylistSyncCopyInst(DeviceView *dev, C_ItemList *songMaps, C_ItemList * playlists) : songMaps(songMaps), playlists(playlists)
+	{
+		usesPreCopy = false;
+		usesPostCopy = true;
+		this->dev = dev;
+		equalsType = -1;
+		status=STATUS_WAITING;
+		// status caption
+		WASABI_API_LNGSTRINGW_BUF(IDS_WAITING,statusCaption,sizeof(statusCaption)/sizeof(wchar_t));
+		// track caption
+		WASABI_API_LNGSTRINGW_BUF(IDS_PLAYLIST_SYNCRONIZATION,trackCaption,sizeof(trackCaption)/sizeof(wchar_t));
+		// type caption
+		WASABI_API_LNGSTRINGW_BUF(IDS_OTHER,typeCaption,sizeof(typeCaption)/sizeof(wchar_t));
+		memFreed=false;
+	}
+
+	virtual ~PlaylistSyncCopyInst()
+	{
+		freeMemory();
+	}
+
+	virtual bool CopyAction()
+	{
+		return false;
+	}
+
+	virtual void PostCopyAction()
+	{
+		SyncPlaylists(); freeMemory();
+	}
+	virtual void Cancelled()
+	{
+		freeMemory();
+	}
+	virtual bool Equals(CopyInst * b)
+	{
+		return false;
+	}
+	void freeMemory()
+	{
+		if(memFreed) return;
+		memFreed=true;
+		if(songMaps) delete songMaps;
+		songMaps = NULL;
+		if(playlists)
+		{
+			int l = playlists->GetSize();
+			for(int i=0; i<l; i++)
+			{
+				SyncPlaylist * playlist = (SyncPlaylist *)playlists->Get(i);
+				if(playlist)
+				{
+					if(playlist->songs)
+					{
+						for(int j=0; j<playlist->info.numItems; j++)
+						{
+							if(playlist->songs[j].ice)
+							{
+								freeRecord(playlist->songs[j].ice);
+								free(playlist->songs[j].ice);
+							}
+							if(playlist->songs[j].filename)
+								free(playlist->songs[j].filename);
+						}
+						free(playlist->songs);
+					}
+					free(playlist);
+				}
+			}
+			delete playlists;
+			playlists = NULL;
+		}
+	}
+	void SyncPlaylists()
+	{
+		if(memFreed)
+			return;
+		WASABI_API_LNGSTRINGW_BUF(IDS_WORKING,statusCaption,sizeof(statusCaption)/sizeof(wchar_t));
+		TransfersListUpdateItem(this);
+		TransfersListUpdateItem(this, dev);
+		MapItemRecordsToSongs(dev->dev,(PlaylistAddItem **)songMaps->GetAll(),songMaps->GetSize());
+		int numPlaylists = playlists->GetSize();
+		for(int i=0; i<numPlaylists; i++)
+		{
+			SyncPlaylist * playlist = (SyncPlaylist *)playlists->Get(i);
+			int plnum = -1;
+			bool done = false;
+			int l = dev->dev->getPlaylistCount();
+			int j;
+			for(j=0; j < l; j++)
+			{
+				wchar_t buf[128] = {0};
+				dev->dev->getPlaylistName(j,buf,128);
+				if(wcscmp(buf,playlist->info.playlistName)) continue;
+				int plen = dev->dev->getPlaylistLength(j);
+				if(plen != playlist->info.numItems)
+				{
+					plnum = j;
+					break;
+				}
+				for(int k=0; k<plen; k++)
+				{
+					if(playlist->songs[k].song != dev->dev->getPlaylistTrack(j,k))
+					{
+						plnum = j;
+						break;
+					}
+				}
+				if(plnum == -1)
+				{
+					done = true;
+					break;
+				}
+			}
+			if(done) continue;
+			if(plnum == -1)
+			{
+				plnum = dev->CreatePlaylist(playlist->info.playlistName,true);
+				if(plnum == -1) continue;
+			}
+			int plen = dev->dev->getPlaylistLength(plnum);
+			while(plen && ((plen % 4) != 1)) dev->dev->removeTrackFromPlaylist(plnum,--plen); // avoid granulation boundarys
+			int n=0;
+			for(j=0; j<playlist->info.numItems; j++)
+			{
+				songid_t s = playlist->songs[j].song;
+				if(s && (n>=plen || s != dev->dev->getPlaylistTrack(plnum,n)))
+				{
+					// begin set item code...
+					if(n >= plen) while(n >= plen)
+						{
+							dev->dev->addTrackToPlaylist(plnum,s);
+							plen++;
+						}
+					else
+					{
+						dev->dev->addTrackToPlaylist(plnum,s);
+						dev->dev->playlistSwapItems(plnum,plen,n);
+						dev->dev->removeTrackFromPlaylist(plnum,plen);
+					}
+					// end set item code
+				}
+				if(s) n++;
+			}
+			plen = dev->dev->getPlaylistLength(plnum);
+			while(plen > n) dev->dev->removeTrackFromPlaylist(plnum,--plen);
+
+			if(_wcsicmp(playlist->info.playlistName,L"Podcasts")==0)
+			{
+				wchar_t *name=NULL;
+				for(int j=playlist->info.numItems-1; j>=0; j--)
+				{
+					wchar_t *n = getRecordExtendedItem(playlist->songs[j].ice,L"podcastchannel");
+					if(!name) name=n;
+					if(name && n)
+					{
+						if(_wcsicmp(name,n))
+						{
+							dev->dev->extraActions(DEVICE_ADDPODCASTGROUP,plnum,j+1,(intptr_t)name);
+							name=n;
+						}
+						if(j==0) dev->dev->extraActions(DEVICE_ADDPODCASTGROUP,plnum,0,(intptr_t)name);
+					}
+				}
+				dev->dev->extraActions(DEVICE_ADDPODCASTGROUP_FINISH,plnum,0,0);
+			}
+		}
+		dev->DevicePropertiesChanges();
+		freeMemory();
+		WASABI_API_LNGSTRINGW_BUF(IDS_DONE,statusCaption,sizeof(statusCaption)/sizeof(wchar_t));
+		TransfersListUpdateItem(this);
+		TransfersListUpdateItem(this, dev);
+	}
+};
+
+static bool shouldSyncPlaylist(wchar_t * name, C_Config * config)
+{
+	wchar_t buf[150] = {0};
+	StringCchPrintf(buf,150, L"sync-%s",name);
+	return config->ReadInt(buf,0) == config->ReadInt(L"plsyncwhitelist",1);
+}
+
+static int sortfunc_podcastpubdate(const void *elem1, const void *elem2)
+{
+	itemRecordW *ar = (itemRecordW *)elem1;
+	itemRecordW *br = (itemRecordW *)elem2;
+	wchar_t *a = getRecordExtendedItem(ar,L"podcastpubdate");
+	wchar_t *b = getRecordExtendedItem(br,L"podcastpubdate");
+	if(!a) a = L"0";
+	if(!b) b = L"0";
+	return _wtoi(b) - _wtoi(a);
+}
+
+void DeviceView::OnActivityStarted()
+{
+	for ( ifc_deviceevent *l_event_handler : event_handlers )
+		l_event_handler->ActivityStarted( this, this );
+}
+
+void DeviceView::OnActivityChanged()
+{
+	for ( ifc_deviceevent *l_event_handler : event_handlers )
+		l_event_handler->ActivityChanged( this, this );
+}
+
+void DeviceView::OnActivityFinished()
+{
+	for ( ifc_deviceevent *l_event_handler : event_handlers )
+		l_event_handler->ActivityFinished( this, this );
+}
+
+void DeviceView::UpdateActivityState()
+{
+	LinkedQueue * txQueue = getTransferQueue(this);
+	if (txQueue && FALSE == activityRunning)
+	{
+		if (0 != txQueue->GetSize())
+		{
+			activityRunning = TRUE;
+
+			if (FAILED(GetProgress(&currentProgress)))
+				currentProgress = 0;
+			 
+			OnActivityStarted();
+		}
+	}
+	else
+	{
+		if (txQueue && 0 == txQueue->GetSize())
+		{
+			activityRunning = FALSE;
+			OnActivityFinished();
+		}
+		else
+		{
+			unsigned int percent;
+			if (FAILED(GetProgress(&percent)) || 
+				percent != currentProgress)
+			{
+				currentProgress = percent;
+				OnActivityChanged();
+			}
+		}
+	}
+}
+
+void DeviceView::UpdateSpaceInfo(BOOL updateUsedSpace, BOOL notifyChanges)
+{
+	uint64_t total, used;
+	unsigned int changes;
+
+	changes = 0;
+
+	total = dev->getDeviceCapacityTotal();
+	if (total != totalSpace)
+	{
+		totalSpace = total;
+		changes |= (1 << 0);	
+	}
+
+	if (FALSE != updateUsedSpace)
+	{
+		used = dev->getDeviceCapacityAvailable();
+		if (used > total)
+			used = total;
+
+		used = total - used;
+
+		if (used != usedSpace)
+		{
+			usedSpace = used;
+			changes |= (1 << 1);
+		}
+	}
+
+	if (0 != changes && FALSE != notifyChanges)
+	{
+		for ( ifc_deviceevent *l_event_handler : event_handlers )
+		{
+			if (0 != ((1 << 0) & changes))
+				l_event_handler->TotalSpaceChanged(this, totalSpace);
+			if (0 != ((1 << 1) & changes))
+				l_event_handler->TotalSpaceChanged(this, usedSpace);
+		}
+	}
+}
+
+
+void DeviceView::OnNameChanged(const wchar_t *new_name)
+{
+	for ( ifc_deviceevent *l_event_handler : event_handlers )
+		l_event_handler->DisplayNameChanged( this, new_name );
+}
+
+void DeviceView::Sync(bool silent)
+{
+	// sync configuration settings....
+	bool syncAllLibrary = config->ReadInt(L"syncAllLibrary",1)!=0;
+
+	if (AGAVE_API_STATS)
+	{
+		wchar_t device_name[128] = {0};
+		device_name[0] = 0;
+		if(dev->extraActions(DEVICE_GET_MODEL, (intptr_t)device_name, 128, 0) == 1 && device_name[0])
+		{
+			AGAVE_API_STATS->SetString("pmp", device_name);
+		}
+	}
+
+	HWND centerWindow = CENTER_OVER_ML_VIEW;
+	UpdateActivityState();
+
+	C_ItemList mllist;
+	wchar_t * querystring=0;
+	itemRecordListW *results = 0;
+	if(syncAllLibrary)
+	{
+		querystring = _wcsdup(config->ReadString(L"SyncQuery",L"type=0"));
+		results = (AGAVE_API_MLDB ? AGAVE_API_MLDB->Query(querystring) : NULL);
+		if (results)
+			for(int i = 0; i < results->Size; i++) mllist.Add(&results->Items[i]);
+	}
+
+	// read playlists/views and find out what else needs to be added
+	PlaylistSyncCopyInst * sync = NULL;
+	C_ItemList filenameMaps;
+	C_ItemList *songMaps = new C_ItemList;
+	C_ItemList * playlists = new C_ItemList;
+
+	// first collect playlists without metadata
+	SyncItemListLoader list;
+	list.metaToGet = &filenameMaps;
+	list.songMaps = songMaps;
+	int playlistsnum = SendMessage(plugin.hwndLibraryParent, WM_ML_IPC, 0, ML_IPC_PLAYLIST_COUNT);
+	for(int i=0; i<playlistsnum; i++)
+	{
+		SyncPlaylist* playlist = (SyncPlaylist*)calloc(sizeof(SyncPlaylist),1);
+		playlist->info.size = sizeof(mlPlaylistInfo);
+		playlist->info.playlistNum = i;
+		SendMessage(plugin.hwndLibraryParent, WM_ML_IPC, (WPARAM)&playlist->info, ML_IPC_PLAYLIST_INFO);
+		if(shouldSyncPlaylist(playlist->info.playlistName, config))
+		{
+			playlists->Add(playlist);
+		}
+		else
+		{
+			free(playlist);
+			playlist = 0;
+			continue;
+		}
+		//if(playlist->info.numItems <= 1)
+		{
+			list.pos = list.len = 0;
+			playlistManager->Load(playlist->info.filename, &list);
+			playlist->info.numItems = list.pos;
+		}
+		list.pos = 0;
+		list.len=playlist->info.numItems;
+		list.songs = playlist->songs = (songMapping*)calloc(sizeof(songMapping), list.len);
+		playlistManager->Load(playlist->info.filename, &list);
+	}
+	mapFilesToItemRecords((filenameMap **)filenameMaps.GetAll(), filenameMaps.GetSize(), centerWindow); // get metadata
+
+	// now sync podcasts...
+	if (dev->extraActions(DEVICE_SUPPORTS_PODCASTS, 0, 0, 0) == 0)
+	{
+		int podcasteps = config->ReadInt(L"podcast-sync_episodes",0);
+		int podcastsnum = AGAVE_API_PODCASTS ? AGAVE_API_PODCASTS->GetNumPodcasts() : 0;
+		if(podcasteps && podcastsnum > 0)
+		{
+			// if we want to sync podcasts and we have podcasts to sync
+			bool all = !!config->ReadInt(L"podcast-sync_all", 1);
+			SyncPlaylist * s = (SyncPlaylist *)calloc(sizeof(SyncPlaylist),1);
+			lstrcpyn(s->info.playlistName, L"Podcasts", 128); //set the name of the playlist containing our podcasts
+			int n = 0, alloc = 512;
+			s->songs = (songMapping*)calloc(alloc, sizeof(songMapping));
+			for(int i = 0; i < podcastsnum; i++)
+			{
+				ifc_podcast *podcast = AGAVE_API_PODCASTS->EnumPodcast(i);
+				if(podcast)
+				{
+					wchar_t podcast_name[256] = {0};
+					if(podcast->GetTitle(podcast_name, 256) == 0)
+					{
+						wchar_t buf[300] = {0};
+						StringCchPrintf(buf, 300, L"podcast-sync-%s", podcast_name);
+						if(podcast_name[0] && (all || config->ReadInt(buf,0)))   // if we have a podcast and we want to sync it
+						{
+							wchar_t query[300] = {0};
+							StringCchPrintf(query, 300, L"podcastchannel = \"%s\"", podcast_name);
+							itemRecordListW *podcasts = AGAVE_API_MLDB->Query(query);
+							if(podcasts)
+							{
+								qsort(podcasts->Items,podcasts->Size,sizeof(itemRecordW),sortfunc_podcastpubdate); // sort the podcasts into publish date order
+								for(int j=0; j<podcasts->Size && (podcasteps == -1 || j < podcasteps); j++)
+								{
+									// add podcast to playlist
+									if(n >= alloc)
+									{
+										size_t old_alloc = alloc;
+										alloc += 512;
+										songMapping* new_songs = (songMapping*)realloc(s->songs,sizeof(songMapping) * alloc);
+										if (new_songs)
+										{
+											s->songs = new_songs;
+										}
+										else
+										{
+											new_songs = (songMapping*)malloc(sizeof(songMapping) * alloc);
+											if (new_songs)
+											{
+												memcpy(new_songs, s->songs, sizeof(songMapping) * old_alloc);
+												free(s->songs);
+												s->songs = new_songs;
+											}
+											else
+											{
+												alloc = old_alloc;
+												continue;
+											}
+										}
+									}
+									ZeroMemory(&s->songs[n],sizeof(songMapping));
+									s->songs[n].ice = (itemRecordW*)calloc(sizeof(itemRecordW), 1);
+									copyRecord(s->songs[n].ice,&podcasts->Items[j]);
+									mllist.Add(s->songs[n].ice);
+									songMaps->Add(&s->songs[n].pladd);
+									n++;
+								}
+								if(podcasts)
+									AGAVE_API_MLDB->FreeRecordList(podcasts);
+							}
+						}
+					}
+				}
+			}
+			s->info.numItems = n;
+			if(n)
+				playlists->Add(s);
+			else
+			{
+				free(s->songs);
+				free(s);
+			}
+		}
+	}
+	// now collect playlists with metadata (i.e, smart views)
+	// except the new ml_local isn't ready.
+	// calloc a new SyncPlaylist, fill in playlist->info.numItems, playlist->info.playlistName and playlist->songs[].ice then add to playlists.
+
+	// add tracks to be sync'd
+	for(int i=0; i<filenameMaps.GetSize(); i++)
+	{
+		filenameMap* f = (filenameMap*)filenameMaps.Get(i);
+		if(f->ice)
+			mllist.Add(f->ice);
+	}
+	// prepare sync
+	if(playlists->GetSize())
+		sync = new PlaylistSyncCopyInst(this, songMaps, playlists);
+	else
+	{
+		delete playlists;
+		delete songMaps;
+	}
+
+	// work out the tracks to be sent and deleted...
+	C_ItemList synclist,dellist;
+
+	ProcessDatabaseDifferences(dev, &mllist, NULL, &synclist, NULL, &dellist);
+
+	if(!synclist.GetSize() && !dellist.GetSize())
+	{
+		// nothing to do
+		if(sync)
+		{
+			sync->SyncPlaylists();
+			delete sync;
+		}
+		if(!silent)
+		{
+			wchar_t titleStr[32] = {0};
+			MessageBox(plugin.hwndLibraryParent,
+			           WASABI_API_LNGSTRINGW(IDS_NOTHING_TO_SYNC_UP_TO_DATE),
+			           WASABI_API_LNGSTRINGW_BUF(IDS_SYNC, titleStr, 32),0);
+		}
+	}
+	else
+	{
+		// need to sync some tracks
+		if(IDOK == SyncDialog_Show(centerWindow, this, &synclist, &dellist, FALSE))
+		{
+			config->WriteInt(L"syncOnConnect_time",(int)time(NULL));
+			if(dellist.GetSize())
+			{
+				switch(config->ReadInt(L"TrueSync",0))
+				{
+					case 1: this->DeleteTracks(&dellist, centerWindow); break;
+					case 2: this->CopyTracksToHardDrive(&dellist); break;
+				}
+			}
+
+			int i = 0, l = 0;
+			LinkedQueue * txQueue = getTransferQueue(this);
+			if (txQueue)
+			{
+				l = synclist.GetSize();
+				txQueue->lock();
+				for(i = 0; i < l; i++) if(AddTrackToTransferQueue(this, (itemRecordW*)synclist.Get(i), false) == -1) break;
+				if(sync) AddTrackToTransferQueue(sync);
+				txQueue->unlock();
+			}
+
+			if(i != l)
+			{
+				wchar_t titleStr[128] = {0};
+				MessageBox(plugin.hwndLibraryParent,
+				           WASABI_API_LNGSTRINGW(IDS_THERE_IS_NOT_ENOUGH_SPACE_ON_THE_DEVICE),
+				           WASABI_API_LNGSTRINGW_BUF(IDS_NOT_ENOUGH_SPACE, titleStr, ARRAYSIZE(titleStr)),
+						   MB_OK | MB_ICONWARNING);
+			}
+		}
+		else
+		{
+			if(sync) delete sync;
+		}
+	}
+
+	if(syncAllLibrary)
+	{
+		if(results)
+			AGAVE_API_MLDB->FreeRecordList(results);
+		free(querystring);
+	}
+}
+
+void DeviceView::CloudSync(bool silent)
+{
+	if (AGAVE_API_STATS)
+	{
+		wchar_t device_name[128] = {0};
+		if(dev->extraActions(DEVICE_GET_MODEL, (intptr_t)device_name, 128, 0) == 1 && device_name[0])
+		{
+			AGAVE_API_STATS->SetString("pmp", device_name);
+		}
+	}
+
+	UpdateActivityState();
+
+	// work out the tracks to be sent...
+	C_ItemList *filenameMaps2 = new C_ItemList, synclist;
+	DeviceView * hss = 0, * local = 0;
+
+	if (!cloud_hinst) cloud_hinst = (HINSTANCE)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GET_CLOUD_HINST);
+	if (cloud_hinst && cloud_hinst != (HINSTANCE)1)
+	{
+		winampMediaLibraryPlugin *(*gp)();
+		gp = (winampMediaLibraryPlugin * (__cdecl *)(void))GetProcAddress(cloud_hinst, "winampGetMediaLibraryPlugin");
+		if (gp)
+		{
+			winampMediaLibraryPlugin *mlplugin = gp();
+			if (mlplugin && (mlplugin->version >= MLHDR_VER_OLD && mlplugin->version <= MLHDR_VER))
+			{
+				// determine the cloud device and alter the device
+				// to be checked with as needed by the action done
+				for(int i = 0; i < devices.GetSize(); i++) 
+				{
+					DeviceView * d = (DeviceView *)devices.Get(i);
+
+					if (d->isCloudDevice)
+					{
+						char name[128] = {0};
+						if (d->dev->extraActions(DEVICE_GET_UNIQUE_ID, (intptr_t)name, sizeof(name), 0))
+						{
+							if (!strcmp(name, "hss"/*HSS_CLIENT*/))
+								hss = d;
+							else if (!strcmp(name, "local_desktop"))
+								local = d;
+						}
+					}
+				}
+
+				if (local && hss && local->dev == dev)
+				{
+					// just use the local library as the source to compare against
+					mlplugin->MessageProc(0x403, /*source*/-1, /*dest*/hss->dev->extraActions(DEVICE_GET_CLOUD_DEVICE_ID,0,0,0), (INT_PTR)filenameMaps2);
+				}
+				else
+				{
+					// just use the local library as the source to compare against
+					mlplugin->MessageProc(0x403, /*source*/-1, /*dest*/dev->extraActions(DEVICE_GET_CLOUD_DEVICE_ID,0,0,0), (INT_PTR)filenameMaps2);
+				}
+			}
+		}
+	}
+
+	synclist = *fileListToItemRecords(filenameMaps2, CENTER_OVER_ML_VIEW);
+	nu::qsort(synclist.GetAll(), synclist.GetSize(), sizeof(void*), dev, compareSongs);
+
+	if(!synclist.GetSize())
+	{
+		if(!silent)
+		{
+			wchar_t titleStr[32] = {0};
+			MessageBox(plugin.hwndLibraryParent,
+			           WASABI_API_LNGSTRINGW(IDS_NOTHING_TO_SYNC_UP_TO_DATE),
+			           WASABI_API_LNGSTRINGW_BUF(IDS_SYNC,titleStr,32),0);
+		}
+	}
+	else
+	{
+		DeviceView * destDevice = (local && hss && local->dev == dev ? hss : this);
+		// need to sync some tracks
+		if(IDOK == SyncCloudDialog_Show(CENTER_OVER_ML_VIEW, destDevice, &synclist))
+		{
+			int l = synclist.GetSize();
+			cloudTransferQueue.lock();
+			int i = 0;
+			for (; i < l; i++) if (AddTrackToTransferQueue(destDevice, (itemRecordW*)synclist.Get(i), false) == -1) break;
+			cloudTransferQueue.unlock();
+
+			if(i != l)
+			{
+				wchar_t titleStr[128] = {0};
+				MessageBox(plugin.hwndLibraryParent,
+				           WASABI_API_LNGSTRINGW(IDS_THERE_IS_NOT_ENOUGH_SPACE_ON_THE_DEVICE),
+				           WASABI_API_LNGSTRINGW_BUF(IDS_NOT_ENOUGH_SPACE, titleStr, ARRAYSIZE(titleStr)),
+						   MB_OK | MB_ICONWARNING);
+			}
+		}
+	}
+}
+
+extern itemRecordListW * generateAutoFillList(DeviceView * dev, C_Config * config); // from autofill.cpp
+
+void DeviceView::Autofill()
+{
+	HWND centerWindow;
+
+	centerWindow = CENTER_OVER_ML_VIEW;
+
+	if (AGAVE_API_STATS)
+	{
+		wchar_t device_name[128] = {0};
+		if(dev->extraActions(DEVICE_GET_MODEL, (intptr_t)device_name, 128, 0) == 1 && device_name[0])
+		{
+			AGAVE_API_STATS->SetString("pmp", device_name);
+		}
+	}
+
+	UpdateActivityState();
+
+	C_ItemList delList,sendList;
+
+	itemRecordListW * autofillList = generateAutoFillList(this,config);
+	ProcessDatabaseDifferences(dev,autofillList,NULL,&sendList,NULL,&delList);
+	
+	if(IDOK == SyncDialog_Show(centerWindow, this, &sendList, &delList, TRUE))
+	{
+		config->WriteInt(L"syncOnConnect_time", (int)time(NULL));
+		// delete all tracks in delList
+		if(IDOK == DeleteTracks(&delList, centerWindow))
+		{
+			// not aborted
+			// send all tracks in sendList
+			LinkedQueue * txQueue = getTransferQueue(this);
+			if (txQueue)
+			{
+				txQueue->lock();
+				for(int i = 0; i < sendList.GetSize(); i++) AddTrackToTransferQueue(this, (itemRecordW*)sendList.Get(i), false);
+				txQueue->unlock();
+			}
+		}
+	}
+	if(autofillList)
+		freeRecordList(autofillList);
+}
+
+extern int serverPort;
+
+bool DeviceView::PlayTracks(C_ItemList * tracks, int startPlaybackAt, bool enqueue, bool msgIfImpossible, HWND parent)
+{
+	if(tracks->GetSize() == 0) return true;
+	// direct playback?
+	if(dev->playTracks((songid_t*)tracks->GetAll(),tracks->GetSize(),startPlaybackAt,enqueue))
+		return true;
+	if(serverPort>0 && dev->copyToHardDriveSupported())
+	{
+		// indirect playback?
+		if(!enqueue)
+		{
+			//clear playlist
+			SendMessage(plugin.hwndWinampParent,WM_WA_IPC,0,IPC_DELETE);
+		}
+
+		wchar_t buf[2048] = {0};
+		dev->getPlaylistName(0,buf,128);
+		AutoUrl device(buf);
+		for(int i=0; i<tracks->GetSize(); i++)
+		{
+			songid_t s = (songid_t)tracks->Get(i);
+			//encode fields to url format
+			wchar_t metadata[2048] = {0};
+			dev->getTrackArtist(s,metadata,2048);
+			AutoUrl artist(metadata);
+			dev->getTrackAlbum(s,metadata,2048);
+			AutoUrl album(metadata);
+			dev->getTrackTitle(s,metadata,2048);
+			AutoUrl title(metadata);
+
+			// construct URL
+			wchar_t ext[10]=L"";
+			dev->getTrackExtraInfo(s,L"ext",ext,10);
+			char buf[8192] = {0};
+			StringCchPrintfA(buf,8192, "http://127.0.0.1:%d/?a=%s&l=%s&t=%s&d=%s%s%s",serverPort,artist,album,title,device,*ext?";.":"",(char*)AutoChar(ext));
+			// get title
+			AutoWide wideUrl(buf);
+
+			wchar_t buf2[4096] = {0};
+			getTitle(dev,s,wideUrl,buf2,4096);
+			// enqueue file
+			enqueueFileWithMetaStructW ef = { wideUrl, buf2, NULL, dev->getTrackLength( s ) / 1000 };
+			SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&ef, IPC_PLAYFILEW);
+		}
+		if(!enqueue)   //play item startPlaybackAt
+		{
+			SendMessage(plugin.hwndWinampParent,WM_WA_IPC,startPlaybackAt,IPC_SETPLAYLISTPOS);
+			SendMessage(plugin.hwndWinampParent,WM_COMMAND,40047,0); //stop
+			SendMessage(plugin.hwndWinampParent,WM_COMMAND,40045,0); //play
+		}
+		return true;
+	}
+	if(msgIfImpossible)
+	{
+		wchar_t titleStr[32] = {0};
+		MessageBox(parent,WASABI_API_LNGSTRINGW(IDS_DOES_NOT_SUPPORT_DIRECT_PLAYBACK),
+		           WASABI_API_LNGSTRINGW_BUF(IDS_UNSUPPORTED,titleStr,32),0);
+	}
+	return false;
+}
+
+bool DeviceView::PlayPlaylist(int playlistId, bool enqueue, bool msgIfImpossible, HWND parent)
+{
+	int l = dev->getPlaylistLength(playlistId);
+	C_ItemList tracks;
+	for(int j=0; j<l; j++) 
+		tracks.Add((void*)dev->getPlaylistTrack(playlistId,j));
+	return PlayTracks(&tracks, 0, enqueue, msgIfImpossible, parent);
+}
+
+void DeviceView::CopyTracksToHardDrive(C_ItemList * tracks)
+{
+	CopyTracksToHardDrive((songid_t*)tracks->GetAll(),tracks->GetSize());
+}
+
+static void getReverseCopyFilenameFormat(wchar_t* filepath, wchar_t* format, int len, BOOL * uppercaseext)
+{
+	wchar_t m_def_extract_path[MAX_PATH] = L"C:\\My Music";
+	wchar_t m_def_filename_fmt[MAX_PATH] = L"<Artist> - <Album>\\## - <Trackartist> - <Title>";
+	GetDefaultSaveToFolder(m_def_extract_path);
+	bool cdrip = !!global_config->ReadInt(L"extractusecdrip", 1);
+	const wchar_t *mlinifile = (const wchar_t*)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GETMLINIFILEW);
+
+	wchar_t buf[2048] = {0};
+	if(cdrip) GetPrivateProfileString(L"gen_ml_config",L"extractpath",m_def_extract_path,buf,2048,mlinifile);
+	else lstrcpyn(buf,global_config->ReadString(L"extractpath",m_def_extract_path),2048);
+	lstrcpyn(filepath,buf,len);
+	int l = wcslen(filepath);
+	if(*(filepath+l-1) != L'\\')
+	{
+		*(filepath+l) = L'\\';
+		*(filepath+l+1)=0;
+		l++;
+	}
+	if(cdrip) GetPrivateProfileString(L"gen_ml_config",L"extractfmt2",m_def_filename_fmt,buf,2048,mlinifile);
+	else lstrcpyn(buf,global_config->ReadString(L"extractfmt2",m_def_filename_fmt),2048);
+	if(l < len) lstrcpyn(format/*+l*/,buf,len - l);
+	if(cdrip) *uppercaseext = GetPrivateProfileInt(L"gen_ml_config",L"extractucext",0,mlinifile);
+	else *uppercaseext = global_config->ReadInt(L"extractucext",0);
+}
+
+void DeviceView::CopyTracksToHardDrive(songid_t * tracks, int numTracks)
+{
+	if(!dev->copyToHardDriveSupported()) return;
+	BOOL uppercaseext=FALSE;
+	wchar_t filepath[MAX_PATH] = {0}, format[2048] = {0};
+	getReverseCopyFilenameFormat(filepath,format,2048,&uppercaseext);
+
+	LinkedQueue * txQueue = getTransferQueue(this);
+	if (txQueue)
+	{
+		txQueue->lock();
+		for(int i=0; i<numTracks; i++)
+		{
+			AddTrackToTransferQueue(new ReverseCopyInst(this,filepath,format,tracks[i],true,!!uppercaseext));
+		}
+		txQueue->unlock();
+	}
+}
+
+void DeviceView::CopyPlaylistToLibrary(int plnum)
+{
+	if(plnum==0) return;
+	wchar_t name[128] = {0};
+	dev->getPlaylistName(plnum,name,128);
+	wchar_t filename[MAX_PATH] = {0};
+	wchar_t dir[MAX_PATH] = {0};
+
+	GetTempPath(MAX_PATH,dir);
+	GetTempFileName(dir,L"pmppl",0,filename);
+	_wunlink(filename);
+	{
+		wchar_t * ext = wcsrchr(filename,L'.');
+		if(ext) *ext=0;
+		StringCchCat(filename,MAX_PATH,L".m3u");
+	}
+	FILE * f = _wfopen(filename,L"wt"); if(f)
+	{
+		fputws(L"#EXTM3U\n",f);
+		fclose(f);
+	}
+	/*
+	mlMakePlaylistV2 a = {sizeof(mlMakePlaylistV2),name,ML_TYPE_FILENAMES,"\0\0",PL_FLAG_SHOW | PL_FLAG_FILL_FILENAME};
+	SendMessage(plugin.hwndLibraryParent,WM_ML_IPC,(WPARAM)&a,ML_IPC_PLAYLIST_MAKE);
+	*/
+
+	wchar_t filepath[MAX_PATH] = {0}, format[2048] = {0};
+	BOOL uppercaseext=FALSE;
+	getReverseCopyFilenameFormat(filepath,format,2048,&uppercaseext);
+	int l = dev->getPlaylistLength(plnum);
+
+	LinkedQueue * txQueue = getTransferQueue(this);
+	if (txQueue)
+	{
+		txQueue->lock();
+		for(int i=0; i<l; i++)
+			AddTrackToTransferQueue(new ReversePlaylistCopyInst(this,filepath,format,dev->getPlaylistTrack(plnum,i),filename,name,i==l-1,true));
+		txQueue->unlock();
+	}
+}
+
+void DeviceView::Unregister()
+{
+	for(size_t i=0; i < playlistTreeItems.size(); i++)
+	{
+		HNAVITEM item = playlistTreeItems[i];
+		// TODO: free memory associated with the text for item
+		MLNavCtrl_DeleteItem(plugin.hwndLibraryParent, item);
+	}
+	playlistTreeItems.clear();
+
+	if (videoTreeItem)
+		MLNavCtrl_DeleteItem(plugin.hwndLibraryParent, videoTreeItem);
+	videoTreeItem=0;
+
+	if (AGAVE_API_DEVICEMANAGER)
+		AGAVE_API_DEVICEMANAGER->DeviceUnregister(name);
+	if (treeItem)
+		MLNavCtrl_DeleteItem(plugin.hwndLibraryParent, treeItem);
+	treeItem=0;
+}
\ No newline at end of file