2714 lines
72 KiB
C++
2714 lines
72 KiB
C++
|
//#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(®istered_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, ¤tViewedPlaylist))
|
||
|
|
{
|
||
|
|
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(¤tProgress)))
|
||
|
|
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;
|
||
|
|
}
|