steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/Plugins/Library/ml_pmp/DeviceView.cpp

2714 lines
72 KiB
C++
Raw Blame History

//#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;
}
Reference in New Issue View Git Blame Copy Permalink