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_playlists/view_pl.cpp

2885 lines
79 KiB
C++
Raw Permalink Blame History

#include <strsafe.h>
#include <shlobj.h>
#include <direct.h>
#include <atomic>
#include "main.h"
#include "Playlist.h"
#include "resource.h"
#include "nu/listview.h"
#include "CurrentPlaylist.h"
#include "nu/AutoCharFn.h"
#include "../../General/gen_ml/ml.h"
#include "../../General/gen_ml/ml_ipc.h"
#include "SendTo.h"
#include "PlaylistView.h"
#include "PlaylistDirectoryCallback.h"
#include "api__ml_playlists.h"
#include "../../General/gen_ml/menufucker.h"
#include "nu/menushortcuts.h"
#include "../../General/gen_ml/ml_ipc_0313.h"
#include "ml_local/api_mldb.h"
#include "ml_pmp/pmp.h"
#include "replicant/nswasabi/ReferenceCounted.h"
#include "replicant/nx/win/nxstring.h"
#include "playlist/plstring.h"
#include "../nu/AutoChar.h"
#include "../nu/AutoWide.h"
#include "../nu/AutoLock.h"
#include "../replicant/nu/AutoLock.h"
#include "../../../WAT/wa_logger.h"
#include <iostream>
#include <fstream>
#include "../../../Components/wac_network/wac_network_http_receiver_api.h"
#include "../../../Components/wac_downloadManager/wac_downloadManager_api.h"
//#include "../replicant/replicant/metadata/metadata.h"
using namespace Nullsoft::Utility;
#define SIMULTANEOUS_DOWNLOADS 1
#define PLAYLIST_DOWNLOAD_SUBFOLDER "\\Winamp_Library\\"
#define WINAMP_REDIRECT_LINK_PROXY_FILE L"http://client.winamp.com/fileproxy?destination="
std::vector<DownloadToken> plDownloads;
LockGuard itemsPlaylistQueueLock;
Playlist currentPlaylist;
wchar_t currentPlaylistFilename[FILENAME_SIZE] = {0};
wchar_t currentPlaylistTitle[FILETITLE_SIZE] = {0};
wchar_t current_playing[FILENAME_SIZE] = {0};
W_ListView playlist_list;
static GUID playlist_guid = INVALID_GUID;
int IPC_LIBRARY_SENDTOMENU;
int we_are_drag_and_dropping = 0;
static void AutoSizePlaylistColumns();
static SendToMenu sendTo;
viewButtons view = {0};
typedef enum
{
SCROLLDIR_NONE = 0,
SCROLLDIR_UP = 1,
SCROLLDIR_DOWN = -1,
} SCROLLDIR;
#define SCROLLTIMER_ID 100
static INT scrollDelay = 0;
static INT scrollTimerElapse = 0;
static int scrollDirection = SCROLLDIR_NONE;
void UpdatePlaylistTime(HWND hwndDlg);
static bool opened = false;
static bool changed = false;
static bool loaded = false;
HWND activeHWND = 0;
HWND saveHWND = 0;
int groupBtn = 1;
int customAllowed = 0;
int enqueuedef = 0;
void Changed( bool _changed = true )
{
changed = _changed;
EnableWindow( saveHWND, changed );
}
void SyncPlaylist()
{
if ( opened )
{
playlist_list.SetVirtualCount( (INT)currentPlaylist.GetNumItems() );
playlist_list.RefreshAll();
UpdatePlaylistTime( GetParent( playlist_list.getwnd() ) );
if ( !current_playing[ 0 ] )
lstrcpynW( current_playing, (wchar_t *)SendMessage( plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GET_PLAYING_FILENAME ), FILENAME_SIZE );
PostMessage( activeHWND, WM_APP + 103, (WPARAM)current_playing, 1 );
}
}
void SyncMenuWithAccelerators( HWND hwndDlg, HMENU menu )
{
HACCEL szAccel[ 24 ] = { 0 };
INT c = WASABI_API_APP->app_getAccelerators( hwndDlg, szAccel, sizeof( szAccel ) / sizeof( szAccel[ 0 ] ), FALSE );
AppendMenuShortcuts( menu, szAccel, c, MSF_REPLACE );
}
void UpdateMenuItems( HWND hwndDlg, HMENU menu )
{
bool swapPlayEnqueue = false;
if ( g_config->ReadInt( L"enqueuedef", 0 ) == 1 )
{
SwapPlayEnqueueInMenu( menu );
swapPlayEnqueue = true;
}
SyncMenuWithAccelerators( hwndDlg, menu );
if ( swapPlayEnqueue )
SwapPlayEnqueueInMenu( menu );
}
void TagEditor( HWND hwnd )
{
wchar_t fn[ 1024 ] = { 0 };
wchar_t ft[ 1024 ] = { 0 };
int v = playlist_list.GetCount();
for ( int x = 0; x < v; x++ )
{
if ( playlist_list.GetSelected( x ) )
{
currentPlaylist.GetItem( x, fn, 1024 );
infoBoxParamW p;
p.filename = fn;
p.parent = hwnd;
if ( SendMessage( plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&p, IPC_INFOBOXW ) )
break;
int length = -1;
mediaLibrary.GetFileInfo( fn, ft, 1024, &length );
currentPlaylist.SetItemTitle( x, ft );
currentPlaylist.SetItemLengthMilliseconds( x, length * 1000 );
playlist_list.RefreshItem( x );
Changed();
}
}
MSG msg;
while ( PeekMessage( &msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE ) ); //eat return
}
void myOpenURL(HWND hwnd, wchar_t *loc);
void Playlist_GenerateHtmlPlaylist(void)
{
FILE *fp = 0;
wchar_t filename[MAX_PATH], tp[MAX_PATH] = {0};
if (!GetTempPathW(MAX_PATH,tp))
StringCchCopyW(tp, MAX_PATH, L".");
if ( GetTempFileNameW( tp, L"WHT", 0, filename ) )
{
DeleteFileW( filename );
StringCchCatW( filename, MAX_PATH, L".html" );
}
else
StringCchCopyW(filename, MAX_PATH, L"wahtml_tmp.html");
fp = _wfopen(filename, L"wt");
if ( !fp )
{
//MessageBox(activeHWND, IDS_HTML_ERROR_WRITE, IDS_ERROR, MB_OK | MB_ICONWARNING);
return;
}
fprintf(fp, "<!DOCTYPE html>\n"
"<html><head>\n"
"<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">\n"
"<meta name=\"generator\" content=\"Winamp 5.9\">\n"
"<style type=\"text/css\">body{background:#000040;font-family:arial,helvetica;font-size:9pt;font-weight:normal;}"
".name{margin-top:-1em;margin-left:15px;font-size:40pt;color:#004080;text-align:left;font-weight:900;}"
".name-small{margin-top:-3em;margin-left:140px;font-size:22pt;color:#E1E1E1;text-align:left;}"
"table{font-size:9pt;color:#004080;text-align:left;border-width:0px;padding:0px;letter-spacing:normal;}"
"hr{border:0;background-color:#FFBF00;height:1px;}"
"ol{color:#FFFFFF;font-size:11pt;}"
"table{margin-left:15px;color:#409FFF;border-width:0px;}"
".val{color:#FFBF00;}"
".header{color:#FFBF00;font-size:14pt;}"
"</style>\n"
"<title>Winamp Generated PlayList</title></head>\n"
"<body>"
"<div>"
"<div class=\"name\"><p>WINAMP</p></div>"
"<div class=\"name-small\"><p>playlist</p></div>"
"</div>"
"<hr><div>\n"
"<table><tr><td>\n");
int x, t = playlist_list.GetCount(), t_in_pl = 0, n_un = 0;
for ( x = 0; x < t; x++ )
{
int a = currentPlaylist.GetItemLengthMilliseconds( x );
if ( a >= 0 )
t_in_pl += ( a / 1000 );
else
n_un++;
}
if ( t != n_un )
{
int old_t_in_pl = t_in_pl;
t_in_pl += ( n_un * t_in_pl ) / ( t - n_un );
fprintf( fp, "<span class=\"val\">%d</span> track%s in playlist, ", t, t == 1 ? "" : "s" );
fprintf( fp, "average track length: <span class=\"val\">%d:%02d", old_t_in_pl / ( t - n_un ) / 60, ( old_t_in_pl / ( t - n_un ) ) % 60 );
fprintf( fp, "</span><br>%slaylist length: ", n_un ? "Estimated p" : "P" );
if ( t_in_pl / 3600 )
{
fprintf( fp, "<span class=\"val\">%d</span> hour%s ", t_in_pl / 3600, t_in_pl / 3600 == 1 ? "" : "s" );
t_in_pl %= 3600;
}
if ( t_in_pl / 60 )
{
fprintf( fp, "<span class=\"val\">%d</span> minute%s ", t_in_pl / 60, t_in_pl / 60 == 1 ? "" : "s" );
t_in_pl %= 60;
}
fprintf( fp, "<span class=\"val\">%d</span> second%s %s", t_in_pl, t_in_pl == 1 ? "" : "s", n_un ? "<br>(" : "" );
if ( n_un )
fprintf( fp, "<span class=\"val\">%d</span> track%s of unknown length)", n_un, n_un == 1 ? "" : "s" );
fprintf( fp,
"<br>Right-click <a href=\"file://%s\">here</a> to save this HTML file."
"</td></tr>",
(char *)AutoChar( filename, CP_UTF8 ) );
}
else
{
fprintf( fp, "There are no tracks in the current playlist.<br>" );
}
fprintf(fp, "</table></div>\n");
if ( t > 0 )
{
fprintf( fp, "<blockquote><span class=\"header\">Playlist files:</span><ol>" );
for ( x = 0; x < t; x++ )
{
wchar_t ft[ FILETITLE_SIZE ] = { 0 };
currentPlaylist.GetItemTitle( x, ft, FILENAME_SIZE );
AutoChar narrowFt( ft, CP_UTF8 );
char *p = narrowFt;
int l = currentPlaylist.GetItemLengthMilliseconds( x );
if ( l > 0 )
l /= 1000;
fprintf( fp, "<li>" );
while ( p && *p )
{
if ( *p == '&' )
fprintf( fp, "&amp;" );
else if ( *p == '<' )
fprintf( fp, "&lt;" );
else if ( *p == '>' )
fprintf( fp, "&gt;" );
else if ( *p == '\'' )
fprintf( fp, "&#39;" );
else if ( *p == '"' )
fprintf( fp, "&quot;" );
else
fputc( *p, fp );
p++;
}
if ( l > 0 )
fprintf( fp, " (%d:%02d) \n", l / 60, l % 60 );
else
fprintf( fp, " \n" );
}
fprintf( fp, "</ol></blockquote>" );
}
fprintf(fp, "<hr><br></body></html>");
fclose(fp);
myOpenURL(activeHWND, filename);
}
void Playlist_ResetSelected()
{
int i = playlist_list.GetCount();
while ( i-- )
{
if ( playlist_list.GetSelected( i ) )
currentPlaylist.ClearCache( i );
}
Changed();
SyncPlaylist();
}
void Playlist_FindSelected()
{
if ( playlist_list.GetSelectionMark() >= 0 )
{
int l = playlist_list.GetCount();
for ( int i = 0; i < l; i++ )
{
if ( playlist_list.GetSelected( i ) )
WASABI_API_EXPLORERFINDFILE->AddFile( (wchar_t *)currentPlaylist.ItemName( i ) );
}
WASABI_API_EXPLORERFINDFILE->ShowFiles();
}
}
void Playlist_DeleteSelected( int selected )
{
selected = !!selected; // convert to 0 or 1
int i = playlist_list.GetCount();
while ( i-- )
{
if ( !( playlist_list.GetSelected( i ) ^ selected ) )
{
currentPlaylist.Remove( i );
playlist_list.Unselect( i );
}
}
Changed();
SyncPlaylist();
}
void Playlist_RecycleSelected( HWND hwndDlg, int selected )
{
SHFILEOPSTRUCTW fileOp;
fileOp.hwnd = hwndDlg;
fileOp.wFunc = FO_DELETE;
fileOp.pFrom = 0;
fileOp.pTo = 0;
fileOp.fFlags = SendMessage( plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_USES_RECYCLEBIN ) ? FOF_ALLOWUNDO : 0;
fileOp.fAnyOperationsAborted = 0;
fileOp.hNameMappings = 0;
fileOp.lpszProgressTitle = 0;
selected = !!selected; // convert to 0 or 1
int i = playlist_list.GetCount();
wchar_t *files = new wchar_t[ i * ( MAX_PATH + 1 ) + 1 ]; // need room for each file name, null terminated. then have to null terminate the whole list
if ( files )
{
wchar_t *curFile = files;
for ( int x = 0; x < i; x++ )
{
if ( !( playlist_list.GetSelected( x ) ^ selected ) )
{
lstrcpynW( curFile, currentPlaylist.ItemName( x ), MAX_PATH );
curFile += wcslen( currentPlaylist.ItemName( x ) ) + 1;
}
}
if ( curFile != files )
{
curFile[ 0 ] = 0; // null terminate
fileOp.pFrom = files;
if ( SHFileOperationW( &fileOp ) )
{
wchar_t titleStr[ 32 ] = { 0 };
MessageBox( hwndDlg, WASABI_API_LNGSTRINGW( IDS_ERROR_DELETING_FILES ), WASABI_API_LNGSTRINGW_BUF( IDS_ERROR, titleStr, 32 ), MB_OK );
}
else if ( !fileOp.fAnyOperationsAborted )
{
while ( i-- )
{
if ( !( playlist_list.GetSelected( i ) ^ selected ) )
{
currentPlaylist.Remove( i );
playlist_list.Unselect( i );
}
}
}
}
delete[] files;
}
else // if malloc failed ... maybe because there'l_enqueue_file too many items.
{
while ( i-- )
{
if ( !( playlist_list.GetSelected( i ) ^ selected ) )
{
fileOp.pFrom = currentPlaylist.ItemName( i );
if ( SHFileOperationW( &fileOp ) )
continue;
if ( fileOp.fAnyOperationsAborted )
break;
currentPlaylist.Remove( i );
playlist_list.Unselect( i );
}
}
}
Changed();
SyncPlaylist();
}
int GetSelectedLength()
{
int length = 0;
int selected = -1;
while ( ( selected = playlist_list.GetNextSelected( selected ) ) != -1 )
{
int thisLen = currentPlaylist.GetItemLengthMilliseconds( selected );
if ( thisLen > 0 )
length += thisLen / 1000;
}
return length;
}
int GetTotalLength()
{
int length = 0;
int len = playlist_list.GetCount();
for ( int i = 0; i < len; i++ )
{
int thisLen = currentPlaylist.GetItemLengthMilliseconds( i );
if ( thisLen > 0 )
length += thisLen / 1000;
}
return length;
}
void FormatLength( wchar_t *str, int length, int buf_len )
{
if ( !length )
lstrcpynW( str, L"0:00", buf_len );
else if ( length < 60 * 60 )
StringCchPrintfW( str, buf_len, L"%d:%02d", length / 60, length % 60 );
else
{
int total_days = length / ( 60 * 60 * 24 );
if ( total_days )
{
length -= total_days * 60 * 60 * 24;
StringCchPrintfW( str, buf_len, L"%d %s+%d:%02d:%02d", total_days, WASABI_API_LNGSTRINGW( ( total_days == 1 ? IDS_DAY : IDS_DAYS ) ), length / 60 / 60, ( length / 60 ) % 60, length % 60 );
}
else
StringCchPrintfW( str, buf_len, L"%d:%02d:%02d", length / 60 / 60, ( length / 60 ) % 60, length % 60 );
}
}
void UpdatePlaylistTime(HWND hwndDlg)
{
wchar_t str[64] = {0}, str2[32] = {0};
int selitems = playlist_list.GetSelectedCount();
int seltime = GetSelectedLength(), ttime = GetTotalLength();
FormatLength(str, seltime, 64);
FormatLength(str2, ttime, 32);
wchar_t buf2[128] = {0}, sStr[16] = {0};
if ( selitems )
StringCchPrintf( buf2, 128, WASABI_API_LNGSTRINGW( IDS_X_OF_X_SELECTED ), selitems, playlist_list.GetCount(), WASABI_API_LNGSTRINGW_BUF( playlist_list.GetCount() == 1 ? IDS_ITEM : IDS_ITEMS_LOWER, sStr, 16 ), str, str2 );
else
StringCchPrintf( buf2, 128, WASABI_API_LNGSTRINGW( IDS_X_SELECTED ), playlist_list.GetCount(), WASABI_API_LNGSTRINGW_BUF( playlist_list.GetCount() == 1 ? IDS_ITEM : IDS_ITEMS_LOWER, sStr, 16 ), str2 );
SetDlgItemText(hwndDlg, IDC_PLSTATUS, buf2);
}
static wchar_t *BuildFilenameList( int is_all )
{
wchar_t filename[ MAX_PATH ] = { 0 };
size_t len = MAX_PATH;
wchar_t *str = (wchar_t *)calloc( len, sizeof( wchar_t ) );
size_t sofar = 0;
int numTracks = playlist_list.GetCount();
for ( int i = 0; i < numTracks; i++ )
{
if ( is_all || playlist_list.GetSelected( i ) )
{
if ( currentPlaylist.GetItem( i, filename, MAX_PATH ) )
{
int filenameLen = lstrlen( filename ) + 1;
if ( ( filenameLen + sofar ) > len )
{
int newLen = sofar * 2; // add some cushion
wchar_t *newStr = (wchar_t *)realloc( str, newLen * sizeof( wchar_t ) );
if ( !newStr )
{
newLen = sofar + filenameLen;
// try the minimum possible size to get this to work
newStr = (wchar_t *)realloc( str, newLen * sizeof( wchar_t ) );
if ( !newStr )
{
free( str );
return 0;
}
}
str = newStr;
}
lstrcpyn( str + sofar, filename, filenameLen );
sofar += filenameLen;
}
}
}
*( str + sofar ) = 0;
return str;
}
void PlaySelection( int enqueue, int is_all )
{
if ( !enqueue )
SendMessage( plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_DELETE );
int numTracks = playlist_list.GetCount();
for ( int i = 0; i < numTracks; i++ )
{
if ( is_all || playlist_list.GetSelected( i ) )
{
const wchar_t *filename = currentPlaylist.ItemName( i );
if ( filename )
{
enqueueFileWithMetaStructW l_enqueue_file;
std::map<std::wstring, std::wstring> &l_extended_infos = currentPlaylist.entries[ i ]->_extended_infos;
wa::strings::wa_string l_original_filename( filename );
if ( !currentPlaylist.entries[ i ]->isLocal() && !l_extended_infos.empty() && l_extended_infos.count( L"ext" ) == 1 && l_original_filename.contains( "://" ) )
{
wa::strings::wa_string l_ext( "." );
l_ext.append( ( *l_extended_infos.find( L"ext" ) ).second );
l_ext.toUpper();
wa::strings::wa_string l_filename( WINAMP_REDIRECT_LINK_PROXY_FILE );
l_filename.append( filename );
wa::strings::wa_string l_upper_case_filename( filename );
l_upper_case_filename.toUpper();
if ( !l_upper_case_filename.contains( l_ext.GetW() ) )
{
if ( !l_original_filename.contains( "?" ) )
l_filename.append( "?" );
else
l_filename.append( "&" );
l_filename.append( "ext=" );
l_filename.append( l_ext );
}
l_enqueue_file.filename = _wcsdup( l_filename.GetW().c_str() );
l_enqueue_file.ext = _wcsdup( ( *l_extended_infos.find( L"ext" ) ).second.c_str() );
}
else
{
l_enqueue_file.filename = filename;
l_enqueue_file.ext = NULL;
}
wa::strings::wa_string l_filename( l_enqueue_file.filename );
if ( l_filename.contains( "://" ) )
{
wsprintfW( _log_message_w, L"The link '%s' will be played!", l_filename.GetW().c_str() );
LOG_DEBUG( _log_message_w );
}
if ( currentPlaylist.IsCached( i ) )
{
l_enqueue_file.title = currentPlaylist.ItemTitle( i );
plstring_retain( (wchar_t *)l_enqueue_file.title );
l_enqueue_file.length = currentPlaylist.GetItemLengthMilliseconds( i ) / 1000;
}
else
{
l_enqueue_file.title = 0;
l_enqueue_file.length = 0;
}
plstring_retain( (wchar_t *)l_enqueue_file.filename );
SendMessage( plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&l_enqueue_file, IPC_PLAYFILEW_NDE_TITLE );
}
}
}
if ( !enqueue )
{
if ( is_all )
{
int pos = playlist_list.GetNextSelected( -1 );
if ( pos != -1 )
{
SendMessage( plugin.hwndWinampParent, WM_WA_IPC, pos, IPC_SETPLAYLISTPOS );
SendMessage( plugin.hwndWinampParent, WM_COMMAND, 40047, 0 ); // stop button, literally
SendMessage( plugin.hwndWinampParent, WM_COMMAND, 40045, 0 ); // play button, literally
return;
}
}
SendMessage( plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_STARTPLAY );
}
}
int playlist_Load( const wchar_t *playlistFileName )
{
currentPlaylist.Clear();
return AGAVE_API_PLAYLISTMANAGER->Load( playlistFileName, &currentPlaylist );
}
LRESULT playlist_cloud_listview( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
if ( uMsg == WM_NOTIFY )
{
LPNMHDR l = (LPNMHDR)lParam;
switch ( l->code )
{
case TTN_SHOW:
{
LVHITTESTINFO lvh = {0};
GetCursorPos(&lvh.pt);
ScreenToClient(hwnd, &lvh.pt);
ListView_SubItemHitTest(hwnd, &lvh);
if ( cloud_avail && lvh.iItem != -1 && lvh.iSubItem == 1 )
{
LPTOOLTIPTEXTW tt = (LPTOOLTIPTEXTW)lParam;
RECT r = { 0 };
if ( lvh.iSubItem )
ListView_GetSubItemRect( hwnd, lvh.iItem, lvh.iSubItem, LVIR_BOUNDS, &r );
else
{
ListView_GetItemRect( hwnd, lvh.iItem, &r, LVIR_BOUNDS );
r.right = r.left + ListView_GetColumnWidth( hwnd, 1 );
}
MapWindowPoints( hwnd, HWND_DESKTOP, (LPPOINT)&r, 2 );
SetWindowPos( tt->hdr.hwndFrom, HWND_TOPMOST, r.right, r.top + 2, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE );
return 1;
}
}
break;
case TTN_NEEDTEXTW:
{
LVHITTESTINFO lvh = {0};
GetCursorPos(&lvh.pt);
ScreenToClient(hwnd, &lvh.pt);
ListView_SubItemHitTest(hwnd, &lvh);
static wchar_t tt_buf2[256] = {L""};
if ( cloud_avail && lvh.iItem != -1 && lvh.iSubItem == 1 )
{
LPNMTTDISPINFO lpnmtdi = (LPNMTTDISPINFO)lParam;
static int last_item2 = -1;
if ( last_item2 == lvh.iItem )
{
lpnmtdi->lpszText = tt_buf2;
return 0;
}
wchar_t info[ 16 ] = { 0 };
currentPlaylist.GetItemExtendedInfo( lvh.iItem, L"cloud_status", info, 16 );
int status = _wtoi( info );
if ( status == 4 )
{
WASABI_API_LNGSTRINGW_BUF( IDS_UPLOAD_TO_SOURCE, tt_buf2, ARRAYSIZE( tt_buf2 ) );
}
else
{
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 ) )
{
// TODO handle case when not in a device
WASABI_API_LNGSTRINGW_BUF( IDS_TRACK_AVAILABLE, tt_buf2, ARRAYSIZE( tt_buf2 ) );
wchar_t filepath[ 1024 ] = { 0 };
currentPlaylist.GetItem( lvh.iItem, filepath, 1024 );
nx_string_t *out_devicenames = 0;
size_t num_names = mlplugin->MessageProc( 0x405, (INT_PTR)&filepath, (INT_PTR)&out_devicenames, 0 );
if ( num_names > 0 )
{
for ( size_t i = 0; i < num_names; i++ )
{
if ( i > 0 )
StringCchCatW( tt_buf2, ARRAYSIZE( tt_buf2 ), L", " );
StringCchCatW( tt_buf2, ARRAYSIZE( tt_buf2 ), out_devicenames[ i ]->string );
}
}
else
{
WASABI_API_LNGSTRINGW_BUF( IDS_UPLOAD_TO_SOURCE, tt_buf2, ARRAYSIZE( tt_buf2 ) );
}
if ( out_devicenames )
free( out_devicenames );
}
}
}
last_item2 = lvh.iItem;
lpnmtdi->lpszText = tt_buf2;
// bit of a fiddle but it allows for multi-line tooltips
//SendMessage(l->hwndFrom, TTM_SETMAXTIPWIDTH, 0, 0);
}
else
return CallWindowProcW((WNDPROC)GetPropW(hwnd, L"cloud_list_proc"), hwnd, uMsg, wParam, lParam);
}
return 0;
}
}
return CallWindowProcW((WNDPROC)GetPropW(hwnd, L"cloud_list_proc"), hwnd, uMsg, wParam, lParam);
}
void playlist_UpdateButtonText( HWND hwndDlg, int _enqueuedef )
{
if ( groupBtn )
{
switch ( _enqueuedef )
{
case 1:
SetDlgItemTextW( hwndDlg, IDC_PLAY, view.enqueue );
customAllowed = FALSE;
break;
default:
// v5.66+ - re-use the old predixis parts so the button can be used functionally via ml_enqplay
// pass the hwnd, button id and plug-in id so the ml plug-in can check things as needed
pluginMessage p = { ML_MSG_VIEW_BUTTON_HOOK_IN_USE, (INT_PTR)_enqueuedef, 0, 0 };
wchar_t *pszTextW = (wchar_t *)SENDMLIPC( plugin.hwndLibraryParent, ML_IPC_SEND_PLUGIN_MESSAGE, (WPARAM)&p );
if ( pszTextW && pszTextW[ 0 ] != 0 )
{
// set this to be a bit different so we can just use one button and not the
// mixable one as well (leaving that to prevent messing with the resources)
SetDlgItemTextW( hwndDlg, IDC_PLAY, pszTextW );
customAllowed = TRUE;
}
else
{
SetDlgItemTextW( hwndDlg, IDC_PLAY, view.play );
customAllowed = FALSE;
}
break;
}
}
}
static void playlist_Init( HWND hwndDlg, LPARAM lParam )
{
HACCEL accel = WASABI_API_LOADACCELERATORSW( IDR_VIEW_PL_ACCELERATORS );
if ( accel )
WASABI_API_APP->app_addAccelerators( hwndDlg, &accel, 1, TRANSLATE_MODE_CHILD );
if ( !view.play )
SENDMLIPC( plugin.hwndLibraryParent, ML_IPC_GET_VIEW_BUTTON_TEXT, (WPARAM)&view );
opened = true;
loaded = false;
activeHWND = hwndDlg;
saveHWND = GetDlgItem(hwndDlg, IDC_SAVE_PL);
Changed( false );
cloud_avail = playlists_CloudAvailable();
groupBtn = g_config->ReadInt( L"groupbtn", 1 );
enqueuedef = ( g_config->ReadInt( L"enqueuedef", 0 ) == 1 );
// force create this as it helps resolve some quirks with play / enqueue handling and
// we cannot guarantee the button being on the dialog resource due to old lang packs.
if ( !IsWindow( GetDlgItem( hwndDlg, IDC_ENQUEUE ) ) )
{
HWND newnd = CreateWindowEx( WS_EX_NOPARENTNOTIFY, L"button", view.enqueue, WS_CHILD | WS_TABSTOP | BS_OWNERDRAW, 0, 0, 0, 0, hwndDlg, (HMENU)IDC_ENQUEUE, plugin.hDllInstance, 0 );
// make sure we're using an appropriate font for the display (may need to review this...)
SendMessage( newnd, WM_SETFONT, (WPARAM)SendDlgItemMessage( hwndDlg, IDC_PLAY, WM_GETFONT, 0, 0 ), 0 );
SetWindowPos( newnd, GetDlgItem( hwndDlg, IDC_PLAY ), 0, 0, 0, 0, SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOSIZE | SWP_SHOWWINDOW );
}
// v5.66+ - re-use the old predixis parts so the button can be used functionally via ml_enqplay
// pass the hwnd, button id and plug-in id so the ml plug-in can check things as needed
pluginMessage p = { ML_MSG_VIEW_BUTTON_HOOK, (INT_PTR)hwndDlg, (INT_PTR)MAKELONG( IDC_CUSTOM, IDC_ENQUEUE ), (INT_PTR)L"ml_playlists" };
wchar_t *pszTextW = (wchar_t *)SENDMLIPC( plugin.hwndLibraryParent, ML_IPC_SEND_PLUGIN_MESSAGE, (WPARAM)&p );
if ( pszTextW && pszTextW[ 0 ] != 0 )
{
// set this to be a bit different so we can just use one button and not the
// mixable one as well (leaving that to prevent messing with the resources)
customAllowed = TRUE;
SetDlgItemTextW( hwndDlg, IDC_CUSTOM, pszTextW );
}
else
{
customAllowed = FALSE;
}
// override the button text to save a bit more space
if ( !g_config->ReadInt( L"pltextbuttons", 0 ) )
{
SetDlgItemText( hwndDlg, IDC_ADD, L"+" );
SetDlgItemText( hwndDlg, IDC_REM, L"\u2212" );
}
/* skin dialog */
MLSKINWINDOW sw = {0};
sw.skinType = SKINNEDWND_TYPE_DIALOG;
sw.style = SWS_USESKINCOLORS | SWS_USESKINCURSORS | SWS_USESKINFONT;
sw.hwndToSkin = hwndDlg;
MLSkinWindow( plugin.hwndLibraryParent, &sw );
/* skin status bar */
sw.hwndToSkin = GetDlgItem( hwndDlg, IDC_PLSTATUS );
sw.skinType = SKINNEDWND_TYPE_STATIC;
sw.style = SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS;
MLSkinWindow( plugin.hwndLibraryParent, &sw );
/* skin listview */
HWND list = sw.hwndToSkin = GetDlgItem(hwndDlg, IDC_PLAYLIST_EDITOR);
sw.skinType = SKINNEDWND_TYPE_LISTVIEW;
sw.style = SWLVS_FULLROWSELECT | SWLVS_DOUBLEBUFFER | SWLVS_ALTERNATEITEMS | SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS;
MLSkinWindow( plugin.hwndLibraryParent, &sw );
MLSkinnedScrollWnd_ShowHorzBar( sw.hwndToSkin, FALSE );
/* skin buttons */
sw.skinType = SKINNEDWND_TYPE_BUTTON;
sw.style = SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS | ( groupBtn ? SWBS_SPLITBUTTON : 0 );
const int buttonidz[] = { IDC_PLAY, IDC_ENQUEUE, IDC_CUSTOM };
for ( size_t i = 0; i != sizeof( buttonidz ) / sizeof( buttonidz[ 0 ] ); i++ )
{
sw.hwndToSkin = GetDlgItem( hwndDlg, buttonidz[ i ] );
if ( IsWindow( sw.hwndToSkin ) )
MLSkinWindow( plugin.hwndLibraryParent, &sw );
}
/* skin dropdown buttons */
sw.style = SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS | SWBS_DROPDOWNBUTTON;
const int buttonids[] = {IDC_BURN, IDC_ADD, IDC_REM, IDC_SEL, IDC_MISC, IDC_LIST};
for ( size_t i = 0; i != sizeof( buttonids ) / sizeof( buttonids[ 0 ] ); i++ )
{
sw.hwndToSkin = GetDlgItem( hwndDlg, buttonids[ i ] );
if ( IsWindow( sw.hwndToSkin ) )
MLSkinWindow( plugin.hwndLibraryParent, &sw );
}
sw.style -= SWBS_DROPDOWNBUTTON;
sw.hwndToSkin = GetDlgItem( hwndDlg, IDC_SAVE_PL );
MLSkinWindow( plugin.hwndLibraryParent, &sw );
// REVIEW: it'd be really nice to pass in a pointer to an ifc_playlist instead...
// at this point, the main issue is how to delete/release it when we're done
playlist_guid = tree_to_guid_map[ lParam ];
{ // scope for lock
AutoLockT<api_playlists> lock( AGAVE_API_PLAYLISTS );
PlaylistInfo info( playlist_guid );
if ( info.Valid() )
{
// will check if the playlist file exists and update the view as needed
const wchar_t *filename = info.GetFilename();
if ( !PathFileExistsW( filename ) )
{
opened = false;
RECT r = { 0 };
HWND status = GetDlgItem( hwndDlg, IDC_PLSTATUS );
GetWindowRect( hwndDlg, &r );
MoveWindow( status, 20, 0, r.right - r.left - 40, r.bottom - r.top, FALSE );
const int ids[] = { IDC_PLAYLIST_EDITOR, IDC_PLAY, IDC_BURN, IDC_ADD, IDC_REM, IDC_SEL, IDC_MISC, IDC_LIST, IDC_SAVE_PL };
for ( size_t i = 0; i < sizeof( ids ) / sizeof( ids[ 0 ] ); i++ )
ShowWindow( GetDlgItem( hwndDlg, ids[ i ] ), FALSE );
// adjust the styles without needing extra resources, etc
DWORD style = GetWindowLongPtr( status, GWL_STYLE );
if ( style & SS_ENDELLIPSIS )
style -= SS_ENDELLIPSIS;
if ( style & SS_CENTERIMAGE )
style -= SS_CENTERIMAGE;
SetWindowLongPtr( status, GWL_STYLE, style | SS_CENTER | 0x2000 );
wchar_t buf[ 1024 ] = { 0 };
StringCchPrintfW( buf, 1024, WASABI_API_LNGSTRINGW( IDS_SOURCE_PL_MISSING ), filename );
SetWindowTextW( status, buf );
}
lstrcpynW( currentPlaylistFilename, filename, MAX_PATH );
playlist_Load( currentPlaylistFilename );
lstrcpynW( currentPlaylistTitle, info.GetName(), FILETITLE_SIZE );
}
}
SetPropW( hwndDlg, L"TITLE", currentPlaylistTitle );
playlist_list.setwnd( list );
playlist_list.AddCol( WASABI_API_LNGSTRINGW( IDS_TITLE ), 400 );
int width = 27;
MLCloudColumn_GetWidth( plugin.hwndLibraryParent, &width );
playlist_list.AddCol( L"", ( cloud_avail ? width : 0 ) );
playlist_list.AddAutoCol( WASABI_API_LNGSTRINGW( IDS_TIME ) );
playlist_list.JustifyColumn( 2, LVCFMT_RIGHT );
MLSkinnedHeader_SetCloudColumn( ListView_GetHeader( playlist_list.getwnd() ), ( cloud_avail ? 1 : -1 ) );
if (!GetPropW(list, L"cloud_list_proc"))
SetPropW( list, L"cloud_list_proc", (HANDLE)SetWindowLongPtrW( list, GWLP_WNDPROC, (LONG_PTR)playlist_cloud_listview ) );
playlist_UpdateButtonText( hwndDlg, enqueuedef == 1 );
SyncPlaylist();
SetWindowRedraw( playlist_list.getwnd(), FALSE );
}
static void playlist_Paint( HWND hwndDlg )
{
int tab[] = { IDC_PLAYLIST_EDITOR | DCW_SUNKENBORDER };
dialogSkinner.Draw( hwndDlg, tab, ( opened ? 1 : 0 ) );
}
static void AutoSizePlaylistColumns()
{
playlist_list.AutoSizeColumn( 2 );
RECT channelRect;
GetClientRect( playlist_list.getwnd(), &channelRect );
ListView_SetColumnWidth( playlist_list.getwnd(), 0, channelRect.right - playlist_list.GetColumnWidth( 1 ) - playlist_list.GetColumnWidth( 2 ) );
}
enum
{
BPM_ECHO_WM_COMMAND = 0x1, // send WM_COMMAND and return value
BPM_WM_COMMAND = 0x2, // just send WM_COMMAND
};
BOOL playlist_ButtonPopupMenu( HWND hwndDlg, int buttonId, HMENU menu, int flags = 0 )
{
RECT r;
HWND buttonHWND = GetDlgItem( hwndDlg, buttonId );
GetWindowRect( buttonHWND, &r );
UpdateMenuItems( hwndDlg, menu );
MLSkinnedButton_SetDropDownState( buttonHWND, TRUE );
UINT tpmFlags = TPM_RIGHTBUTTON | TPM_LEFTBUTTON | TPM_BOTTOMALIGN | TPM_LEFTALIGN;
if ( !( flags & BPM_WM_COMMAND ) )
tpmFlags |= TPM_RETURNCMD;
int x = Menu_TrackPopup( plugin.hwndLibraryParent, menu, tpmFlags, r.left, r.top, hwndDlg, NULL );
if ( ( flags & BPM_ECHO_WM_COMMAND ) && x )
SendMessage( hwndDlg, WM_COMMAND, MAKEWPARAM( x, 0 ), 0 );
MLSkinnedButton_SetDropDownState( buttonHWND, FALSE );
return x;
}
static void playlist_Burn( HWND hwndDlg )
{
HMENU blah = CreatePopupMenu();
sendToIgnoreID = lastActiveID;
sendTo.AddHere( hwndDlg, blah, ML_TYPE_FILENAMES );
int x = playlist_ButtonPopupMenu( hwndDlg, IDC_BURN, blah );
if ( sendTo.WasClicked( x ) )
{
int is_all = playlist_list.GetSelectedCount() == 0;
wchar_t *names = BuildFilenameList( is_all );
sendTo.SendFilenames( names );
free( names );
}
sendTo.Cleanup();
sendToIgnoreID = 0;
}
static void playlist_Play( HWND hwndDlg, HWND from, UINT idFrom )
{
HMENU listMenu = GetSubMenu( g_context_menus2, 0 );
int count = GetMenuItemCount( listMenu );
if ( count > 2 )
{
for ( int i = 2; i < count; i++ )
DeleteMenu( listMenu, 2, MF_BYPOSITION );
}
playlist_ButtonPopupMenu( hwndDlg, idFrom, listMenu, BPM_WM_COMMAND );
UpdatePlaylistTime( hwndDlg );
}
static void playlist_Sel( HWND hwndDlg, HWND from )
{
HMENU listMenu = GetSubMenu( GetSubMenu( g_context_menus, 3 ), 1 );
UINT menuStatus;
if ( playlist_list.GetNextSelected( -1 ) == -1 )
menuStatus = MF_BYCOMMAND | MF_GRAYED;
else
menuStatus = MF_BYCOMMAND | MF_ENABLED;
EnableMenuItem( listMenu, IDC_PLAYLIST_INVERT_SELECTION, menuStatus );
if ( playlist_list.GetCount() > 0 )
menuStatus = MF_BYCOMMAND | MF_ENABLED;
else
menuStatus = MF_BYCOMMAND | MF_GRAYED;
EnableMenuItem( listMenu, IDC_PLAYLIST_SELECT_ALL, menuStatus );
playlist_ButtonPopupMenu( hwndDlg, IDC_SEL, listMenu, BPM_WM_COMMAND );
UpdatePlaylistTime( hwndDlg );
}
static void playlist_Rem( HWND hwndDlg, HWND from )
{
HMENU listMenu = GetSubMenu( GetSubMenu( g_context_menus, 3 ), 2 );
UINT menuStatus;
if ( playlist_list.GetNextSelected( -1 ) == -1 )
menuStatus = MF_BYCOMMAND | MF_GRAYED;
else
menuStatus = MF_BYCOMMAND | MF_ENABLED;
EnableMenuItem( listMenu, IDC_DELETE, menuStatus );
EnableMenuItem( listMenu, IDC_CROP, menuStatus );
if ( playlist_list.GetCount() > 0 )
menuStatus = MF_BYCOMMAND | MF_ENABLED;
else
menuStatus = MF_BYCOMMAND | MF_GRAYED;
EnableMenuItem( listMenu, IDC_PLAYLIST_REMOVE_DEAD, menuStatus );
EnableMenuItem( listMenu, IDC_PLAYLIST_REMOVE_ALL, menuStatus );
playlist_ButtonPopupMenu( hwndDlg, IDC_REM, listMenu, BPM_WM_COMMAND );
UpdatePlaylistTime( hwndDlg );
}
static void playlist_Add( HWND hwndDlg, HWND from )
{
HMENU listMenu = GetSubMenu( GetSubMenu( g_context_menus, 3 ), 3 );
playlist_ButtonPopupMenu( hwndDlg, IDC_ADD, listMenu, BPM_WM_COMMAND );
UpdatePlaylistTime( hwndDlg );
}
static void playlist_Misc( HWND hwndDlg, HWND from )
{
HMENU listMenu = GetSubMenu( GetSubMenu( g_context_menus, 3 ), 4 );
UINT menuStatus;
if ( playlist_list.GetCount() > 0 )
menuStatus = MF_BYCOMMAND | MF_ENABLED;
else
menuStatus = MF_BYCOMMAND | MF_GRAYED;
EnableMenuItem( listMenu, IDC_PLAYLIST_RANDOMIZE, menuStatus );
EnableMenuItem( listMenu, IDC_PLAYLIST_REVERSE, menuStatus );
EnableMenuItem( listMenu, IDC_PLAYLIST_SORT_PATH, menuStatus );
EnableMenuItem( listMenu, IDC_PLAYLIST_SORT_FILENAME, menuStatus );
EnableMenuItem( listMenu, IDC_PLAYLIST_SORT_TITLE, menuStatus );
EnableMenuItem( listMenu, IDC_PLAYLIST_RESET_CACHE, menuStatus );
playlist_ButtonPopupMenu( hwndDlg, IDC_MISC, listMenu, BPM_WM_COMMAND );
UpdatePlaylistTime( hwndDlg );
}
static void playlist_List( HWND hwndDlg, HWND from )
{
sendToIgnoreID = lastActiveID;
HMENU listMenu = GetSubMenu( GetSubMenu( g_context_menus, 3 ), 5 );
sendTo.AddHere( hwndDlg, GetSubMenu( listMenu, 1 ), ML_TYPE_FILENAMES );
int x = playlist_ButtonPopupMenu( hwndDlg, IDC_LIST, listMenu, BPM_ECHO_WM_COMMAND );
if ( sendTo.WasClicked( x ) )
{
wchar_t *names = BuildFilenameList( 1 );
sendTo.SendFilenames( names );
free( names );
}
sendTo.Cleanup();
UpdatePlaylistTime( hwndDlg );
sendToIgnoreID = 0;
}
static void playlist_Command( HWND hwndDlg, WPARAM wParam, LPARAM lParam )
{
switch ( LOWORD( wParam ) )
{
case IDC_BURN:
playlist_Burn( hwndDlg );
break;
case IDC_PLAY:
case IDC_ENQUEUE:
{
if ( HIWORD( wParam ) == MLBN_DROPDOWN )
{
playlist_Play( hwndDlg, (HWND)lParam, LOWORD( wParam ) );
break;
}
else
{
// if it'l_enqueue_file from an accelerator, use the appropriate setting
int action;
if ( LOWORD( wParam ) == IDC_PLAY )
action = ( HIWORD( wParam ) == 1 ) ? g_config->ReadInt( L"enqueuedef", 0 ) == 1 : 0;
else
action = ( HIWORD( wParam ) == 1 ) ? g_config->ReadInt( L"enqueuedef", 0 ) != 1 : 1;
PlaySelection( action, playlist_list.GetSelectedCount() == 0 );
}
}
break;
case IDC_SEL:
playlist_Sel( hwndDlg, (HWND)lParam );
break;
case IDC_REM:
playlist_Rem( hwndDlg, (HWND)lParam );
break;
case IDC_ADD:
playlist_Add( hwndDlg, (HWND)lParam );
break;
case IDC_MISC:
playlist_Misc( hwndDlg, (HWND)lParam );
break;
case IDC_LIST:
playlist_List( hwndDlg, (HWND)lParam );
break;
case IDC_DELETE:
Playlist_DeleteSelected( 1 );
break;
case IDC_CROP:
Playlist_DeleteSelected( 0 );
break;
case IDC_PLAYLIST_EXPLOREITEMFOLDER:
Playlist_FindSelected();
break;
case IDC_PLAYLIST_VIEW_FILE_INFO:
TagEditor( hwndDlg );
break;
case IDC_PLAYLIST_EDIT_ENTRY:
EditEntry( hwndDlg );
break;
case IDC_PLAYLIST_DOWNLOAD_ENTRY:
DownloadSelectedEntries( hwndDlg );
break;
case IDC_PLAYLIST_RANDOMIZE:
AGAVE_API_PLAYLISTMANAGER->Randomize( &currentPlaylist );
playlist_list.RefreshAll();
Changed();
break;
case IDC_PLAYLIST_REVERSE:
AGAVE_API_PLAYLISTMANAGER->Reverse( &currentPlaylist );
playlist_list.RefreshAll();
Changed();
break;
case IDC_PLAYLIST_RESET_CACHE:
Playlist_ResetSelected();
break;
case IDC_PLAYLIST_INVERT_SELECTION:
playlist_list.InvertSelection();
break;
case IDC_PLAYLIST_SELECT_ALL:
playlist_list.SelectAll();
break;
case IDC_ADD_FILES:
if ( CurrentPlaylist_AddFiles( hwndDlg ) ) Changed();
SyncPlaylist();
break;
case IDC_ADD_DIRECTORY:
if ( CurrentPlaylist_AddDirectory( hwndDlg ) ) Changed();
SyncPlaylist();
break;
case IDC_ADD_LOCATION:
if ( CurrentPlaylist_AddLocation( hwndDlg ) ) Changed();
SyncPlaylist();
break;
case IDC_PLAYLIST_SELECT_NONE:
playlist_list.UnselectAll();
break;
case IDC_PLAYLIST_REMOVE_DEAD:
if ( CurrentPlaylist_DeleteMissing() ) Changed();
SyncPlaylist();
break;
case IDC_PLAYLIST_REMOVE_ALL:
currentPlaylist.Clear();
Changed();
SyncPlaylist();
break;
case IDC_PLAYLIST_RECYCLE_SELECTED:
Playlist_RecycleSelected( hwndDlg, 1 );
break;
case IDC_PLAYLIST_SORT_PATH:
currentPlaylist.SortByDirectory();
Changed();
playlist_list.RefreshAll();
break;
case IDC_PLAYLIST_SORT_FILENAME:
currentPlaylist.SortByFilename();
Changed();
playlist_list.RefreshAll();
break;
case IDC_PLAYLIST_SORT_TITLE:
currentPlaylist.SortByTitle();
Changed();
playlist_list.RefreshAll();
break;
case IDC_EXPORT_PLAYLIST:
CurrentPlaylist_Export(hwndDlg);
break;
case IDC_IMPORT_PLAYLIST_FROM_FILE:
if ( currentPlaylist_ImportFromDisk( hwndDlg ) )
Changed();
SyncPlaylist();
break;
case IDC_IMPORT_WINAMP_PLAYLIST:
if ( currentPlaylist_ImportFromWinamp( hwndDlg ) ) Changed();
SyncPlaylist();
break;
case ID_PLAYLIST_GENERATE_HTML:
Playlist_GenerateHtmlPlaylist();
break;
case IDC_SAVE_PL:
if ( changed )
{
playlist_Save( hwndDlg );
Changed( false );
}
break;
}
}
void playlist_Save( HWND hwndDlg )
{
if ( opened )
{
if ( currentPlaylistFilename[ 0 ] )
{
if ( AGAVE_API_PLAYLISTMANAGER->Save( currentPlaylistFilename, &currentPlaylist ) == PLAYLISTMANAGER_FAILED )
{
wchar_t msg[ 512 ] = { 0 };
MessageBox( hwndDlg, WASABI_API_LNGSTRINGW_BUF( IDS_PLAYLIST_ERROR, msg, 512 ), WASABI_API_LNGSTRINGW( IDS_PLAYLIST_ERROR_TITLE ), MB_OK | MB_ICONWARNING );
}
}
PlaylistInfo info( playlist_guid );
info.SetSize( currentPlaylist.GetNumItems() );
info.SetLength( GetTotalLength() );
info.IssueSaveCallback();
}
}
void playlist_SaveGUID( GUID _guid )
{
if ( playlist_guid == _guid )
{
if ( currentPlaylistFilename[ 0 ] )
AGAVE_API_PLAYLISTMANAGER->Save( currentPlaylistFilename, &currentPlaylist );
PlaylistInfo info( playlist_guid );
info.SetSize( currentPlaylist.GetNumItems() );
info.SetLength( GetTotalLength() );
info.IssueSaveCallback();
}
}
void playlist_Destroy( HWND hwndDlg )
{
WASABI_API_APP->app_removeAccelerators( hwndDlg );
if ( changed )
playlist_Save( hwndDlg );
current_playing[ 0 ] = 0;
currentPlaylistFilename[ 0 ] = 0;
currentPlaylist.Clear();
playlist_list.setwnd( NULL );
RemovePropW( hwndDlg, L"TITLE" );
opened = false;
activeHWND = 0;
}
void SwapPlayEnqueueInMenu( HMENU listMenu )
{
int playPos = -1, enqueuePos = -1;
MENUITEMINFOW playItem = { sizeof( MENUITEMINFOW ), 0, }, enqueueItem = { sizeof( MENUITEMINFOW ), 0, };
int numItems = GetMenuItemCount( listMenu );
for ( int i = 0; i < numItems; i++ )
{
UINT id = GetMenuItemID( listMenu, i );
if ( id == IDC_PLAY )
{
playItem.fMask = MIIM_ID;
playPos = i;
GetMenuItemInfoW( listMenu, i, TRUE, &playItem );
}
else if ( id == IDC_ENQUEUE )
{
enqueueItem.fMask = MIIM_ID;
enqueuePos = i;
GetMenuItemInfoW( listMenu, i, TRUE, &enqueueItem );
}
}
playItem.wID = IDC_ENQUEUE;
enqueueItem.wID = IDC_PLAY;
SetMenuItemInfoW( listMenu, playPos, TRUE, &playItem );
SetMenuItemInfoW( listMenu, enqueuePos, TRUE, &enqueueItem );
}
void playlist_ContextMenu( HWND hwndDlg, HWND from, int x, int y )
{
if ( from != playlist_list.getwnd() )
return;
POINT pt = { x,y };
if ( x == -1 || y == -1 ) // x and y are -1 if the user invoked a shift-f10 popup menu
{
RECT channelRect = { 0 };
int selected = playlist_list.GetNextSelected();
if ( selected != -1 ) // if something is selected we'll drop the menu from there
{
playlist_list.GetItemRect( selected, &channelRect );
ClientToScreen( hwndDlg, (POINT *)&channelRect );
}
else // otherwise we'll drop it from the top-left corner of the listview, adjusting for the header location
{
GetWindowRect( hwndDlg, &channelRect );
HWND hHeader = (HWND)SNDMSG( from, LVM_GETHEADER, 0, 0L );
RECT headerRect;
if ( ( WS_VISIBLE & GetWindowLongPtr( hHeader, GWL_STYLE ) ) && GetWindowRect( hHeader, &headerRect ) )
channelRect.top += ( headerRect.bottom - headerRect.top );
}
x = channelRect.left;
y = channelRect.top;
}
HWND hHeader = (HWND)SNDMSG(from, LVM_GETHEADER, 0, 0L);
RECT headerRect;
if ( 0 == ( WS_VISIBLE & GetWindowLongPtr( hHeader, GWL_STYLE ) ) || FALSE == GetWindowRect( hHeader, &headerRect ) )
SetRectEmpty( &headerRect );
if ( FALSE != PtInRect( &headerRect, pt ) )
return;
sendToIgnoreID = lastActiveID;
HMENU listMenu = GetSubMenu( GetSubMenu( g_context_menus, 3 ), 0 );
menufucker_t mf = { sizeof( mf ),MENU_MLPLAYLIST,listMenu,0x3000,0x4000,0 };
UINT menuStatus, do_mf = 0;
if ( playlist_list.GetNextSelected( -1 ) == -1 )
{
menuStatus = MF_BYCOMMAND | MF_GRAYED;
EnableMenuItem( listMenu, 2, MF_BYPOSITION | MF_GRAYED );
}
else
{
menuStatus = MF_BYCOMMAND | MF_ENABLED;
EnableMenuItem( listMenu, 2, MF_BYPOSITION | MF_ENABLED );
sendTo.AddHere( hwndDlg, GetSubMenu( listMenu, 2 ), ML_TYPE_FILENAMES, 1 );
mf.extinf.mlplaylist.pl = &currentPlaylist;
mf.extinf.mlplaylist.list = playlist_list.getwnd();
pluginMessage message_build = { SendMessage( plugin.hwndWinampParent, WM_WA_IPC, ( WPARAM ) & "menufucker_build", IPC_REGISTER_WINAMP_IPCMESSAGE ),(intptr_t)&mf,0 };
SendMessage( plugin.hwndLibraryParent, WM_ML_IPC, (WPARAM)&message_build, ML_IPC_SEND_PLUGIN_MESSAGE );
do_mf = 1;
}
EnableMenuItem( listMenu, IDC_PLAYLIST_EXPLOREITEMFOLDER, menuStatus );
EnableMenuItem( listMenu, IDC_PLAYLIST_VIEW_FILE_INFO, menuStatus );
EnableMenuItem( listMenu, IDC_PLAYLIST_EDIT_ENTRY, menuStatus );
int l_mark = playlist_list.GetSelectionMark();
if ( l_mark != -1 && !currentPlaylist.entries[ l_mark ]->isLocal() )
EnableMenuItem( listMenu, IDC_PLAYLIST_DOWNLOAD_ENTRY, menuStatus );
else
EnableMenuItem( listMenu, IDC_PLAYLIST_DOWNLOAD_ENTRY, MF_BYCOMMAND | MF_GRAYED );
EnableMenuItem( listMenu, IDC_DELETE, menuStatus );
EnableMenuItem( listMenu, IDC_CROP, menuStatus );
HMENU cloud_hmenu = 0;
if ( playlists_CloudAvailable() )
{
int mark = playlist_list.GetSelectionMark();
if ( mark != -1 )
{
wchar_t filename[ 1024 ] = { 0 };
currentPlaylist.entries[ mark ]->GetFilename( filename, 1024 );
cloud_hmenu = CreatePopupMenu();
WASABI_API_SYSCB->syscb_issueCallback( api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_GET_CLOUD_STATUS, (intptr_t)&filename, (intptr_t)&cloud_hmenu );
if ( cloud_hmenu )
{
MENUITEMINFOW m = { sizeof( m ), MIIM_TYPE | MIIM_ID | MIIM_SUBMENU, MFT_SEPARATOR, 0 };
m.wID = CLOUD_SOURCE_MENUS - 1;
InsertMenuItemW( listMenu, 3, TRUE, &m );
wchar_t a[ 100 ] = { 0 };
m.fType = MFT_STRING;
m.dwTypeData = WASABI_API_LNGSTRINGW_BUF( IDS_CLOUD_SOURCES, a, 100 );
m.wID = CLOUD_SOURCE_MENUS;
m.hSubMenu = cloud_hmenu;
InsertMenuItemW( listMenu, 4, TRUE, &m );
}
}
}
UpdateMenuItems(hwndDlg, listMenu);
int r = Menu_TrackPopup( plugin.hwndLibraryParent, listMenu, TPM_RIGHTBUTTON | TPM_LEFTBUTTON | TPM_LEFTALIGN | TPM_RETURNCMD, x, y, hwndDlg, NULL );
if ( r )
SendMessage( hwndDlg, WM_COMMAND, MAKEWPARAM( r, 0 ), 0 );
if ( do_mf )
{
pluginMessage message_result = { SendMessage( plugin.hwndWinampParent, WM_WA_IPC, ( WPARAM ) & "menufucker_result", IPC_REGISTER_WINAMP_IPCMESSAGE ), (intptr_t)&mf, r, 0 };
SendMessage( plugin.hwndLibraryParent, WM_ML_IPC, (WPARAM)&message_result, ML_IPC_SEND_PLUGIN_MESSAGE );
}
switch ( r )
{
case 0:
break;
case IDC_PLAYLIST_EXPLOREITEMFOLDER:
case IDC_PLAYLIST_VIEW_FILE_INFO:
case IDC_PLAYLIST_EDIT_ENTRY:
SendMessage( hwndDlg, WM_NEXTDLGCTL, (WPARAM)from, (LPARAM)TRUE );
break;
case IDC_PLAYLIST_DOWNLOAD_ENTRY:
break;
default:
if ( !( menuStatus & MF_GRAYED ) && sendTo.WasClicked( r ) )
{
wchar_t *names = BuildFilenameList( 0 );
sendTo.SendFilenames( names );
free( names );
}
else
{
if ( r >= CLOUD_SOURCE_MENUS && r < CLOUD_SOURCE_MENUS_PL_UPPER ) // deals with cloud specific menus
{
// 0 = no change
// 1 = adding to cloud
// 2 = added locally
// 4 = removed
int mode = 0; // deals with cloud specific menus
WASABI_API_SYSCB->syscb_issueCallback( api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_PROCESS_CLOUD_STATUS, (intptr_t)r, (intptr_t)&mode );
// TODO
/*switch (mode)
{
case 1:
setCloudValue(&itemCache.Items[pnmitem->iItem], L"5");
break;
case 2:
setCloudValue(&itemCache.Items[pnmitem->iItem], L"4");
break;
case 4:
setCloudValue(&itemCache.Items[pnmitem->iItem], L"4");
break;
}
InvalidateRect(resultlist.getwnd(), NULL, TRUE);*/
}
}
break;
}
if (!(menuStatus & MF_GRAYED))
sendTo.Cleanup();
sendToIgnoreID = 0;
if ( cloud_hmenu )
{
DeleteMenu( listMenu, CLOUD_SOURCE_MENUS - 1, MF_BYCOMMAND );
DeleteMenu( listMenu, CLOUD_SOURCE_MENUS, MF_BYCOMMAND );
DestroyMenu( cloud_hmenu );
}
}
static void playlist_LeftButtonUp( HWND hwndDlg, WPARAM wParam, POINTS pts )
{
if ( SCROLLDIR_NONE != scrollDirection )
{
KillTimer( hwndDlg, SCROLLTIMER_ID );
scrollDirection = SCROLLDIR_NONE;
}
if ( we_are_drag_and_dropping && GetCapture() == hwndDlg )
{
ReleaseCapture();
BOOL handled = FALSE;
POINT pt;
POINTSTOPOINT( pt, pts );
MapWindowPoints( hwndDlg, HWND_DESKTOP, &pt, 1 );
HWND hTarget = WindowFromPoint( pt );
if ( hTarget == playlist_list.getwnd() )
{
LVHITTESTINFO hitTest = { 0 };
POINTSTOPOINT( hitTest.pt, pts );
MapWindowPoints( hwndDlg, playlist_list.getwnd(), &hitTest.pt, 1 );
ListView_HitTest( playlist_list.getwnd(), &hitTest );
size_t position = hitTest.iItem;
if ( ( hitTest.flags & ( LVHT_ONITEM ) ) );
else if ( hitTest.flags & LVHT_ABOVE )
position = 0;
else if ( hitTest.flags & ( LVHT_BELOW | LVHT_NOWHERE ) )
position = playlist_list.GetCount();
if ( position != -1 )
{
RECT itemRect;
playlist_list.GetItemRect( position, &itemRect );
if ( hitTest.pt.y > ( itemRect.bottom + ( itemRect.top - itemRect.bottom ) / 2 ) )
position++;
Playlist tempList;
size_t selected = -1, numDeleted = 0;
// first, make a temporary list with all the selected items
// being careful to deal with the discrepancy between the listview and the real playlist
// as we remove items
while ( ( selected = playlist_list.GetNextSelected( selected ) ) != -1 )
{
tempList.entries.push_back(currentPlaylist.entries.at(selected - numDeleted));
currentPlaylist.entries.erase(currentPlaylist.entries.begin() + (selected - numDeleted));
if ((selected - numDeleted) < position)
position--;
numDeleted++;
}
playlist_list.UnselectAll();
// if dragging to the end of the playlist, handle things a bit differently from normal
if ( position > currentPlaylist.entries.size() )
{
position--;
while ( numDeleted-- )
{
currentPlaylist.entries.insert(currentPlaylist.entries.end(), tempList.entries.at(0));
playlist_list.SetSelected(position++); // we want the same filenames to be selected
tempList.entries.erase(tempList.entries.begin());
}
}
else
{
while ( numDeleted-- )
{
playlist_list.SetSelected(position); // we want the same filenames to be selected
currentPlaylist.entries.insert(currentPlaylist.entries.begin() + position, tempList.entries.at(0));
position++;
tempList.entries.erase(tempList.entries.begin());
}
}
Changed();
SyncPlaylist();
handled = TRUE;
}
}
we_are_drag_and_dropping = 0;
if ( !handled )
{
mlDropItemStruct m = { 0 };
m.type = ML_TYPE_FILENAMESW;
m.p = pt;
pluginHandleIpcMessage( ML_IPC_HANDLEDRAG, (WPARAM)&m );
if ( m.result > 0 )
{
wchar_t *names = BuildFilenameList( 0 );
m.flags = 0;
m.result = 0;
m.data = (void *)names;
pluginHandleIpcMessage( ML_IPC_HANDLEDROP, (WPARAM)&m );
free( names );
}
}
}
}
static void CALLBACK playlist_OnScrollTimer( HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime )
{
HWND hList = GetDlgItem( hwnd, IDC_PLAYLIST_EDITOR );
if ( SCROLLDIR_NONE == scrollDirection || NULL == hList )
{
KillTimer( hwnd, idEvent );
return;
}
RECT rc;
rc.left = LVIR_BOUNDS;
if ( SendMessage( hList, LVM_GETITEMRECT, (WPARAM)0, (LPARAM)&rc ) )
{
INT height = rc.bottom - rc.top;
if ( SCROLLDIR_UP == scrollDirection )
height = -height;
SendMessage( hList, LVM_SCROLL, 0, (LPARAM)height );
}
if ( scrollTimerElapse == scrollDelay )
{
static INT scrollInterval = 0;
if ( 0 == scrollInterval )
scrollInterval = GetProfileInt( TEXT( "windows" ), TEXT( "DragScrollInterval" ), DD_DEFSCROLLINTERVAL );
if ( 0 != scrollInterval )
SetTimer( hwnd, idEvent, scrollTimerElapse, playlist_OnScrollTimer );
else
KillTimer( hwnd, idEvent );
}
}
static INT playlist_GetScrollDirection( HWND hList, POINT pt )
{
static INT scrollZone = 0;
if ( 0 == scrollZone )
scrollZone = GetProfileInt( TEXT( "windows" ), TEXT( "DragScrollInset" ), DD_DEFSCROLLINSET );
RECT rc, rcTest;
if ( 0 == scrollZone || !GetClientRect( playlist_list.getwnd(), &rc ) )
return SCROLLDIR_NONE;
CopyRect( &rcTest, &rc );
rcTest.top = rcTest.bottom - scrollZone;
if ( PtInRect( &rcTest, pt ) )
return SCROLLDIR_DOWN;
rcTest.top = rc.top;
rcTest.bottom = rcTest.top + scrollZone;
if ( 0 == ( LVS_NOCOLUMNHEADER & GetWindowLongPtr( hList, GWL_STYLE ) ) )
{
HWND hHeader = (HWND)SendMessage( hList, LVM_GETHEADER, 0, 0L );
if ( NULL != hHeader && 0 != ( WS_VISIBLE & GetWindowLongPtr( hHeader, GWL_STYLE ) ) )
{
RECT rcHeader;
if ( GetWindowRect( hHeader, &rcHeader ) )
{
MapWindowPoints( HWND_DESKTOP, hList, ( (POINT *)&rcHeader ) + 1, 1 );
INT offset = rcHeader.bottom - rc.top;
if ( 0 != offset )
OffsetRect( &rcTest, 0, offset );
}
}
}
if ( PtInRect( &rcTest, pt ) )
return SCROLLDIR_UP;
return SCROLLDIR_NONE;
}
static void playlist_MouseMove( HWND hwndDlg, POINTS pts )
{
if ( we_are_drag_and_dropping && GetCapture() == hwndDlg )
{
BOOL handled = FALSE;
POINT pt;
POINTSTOPOINT( pt, pts );
MapWindowPoints( hwndDlg, HWND_DESKTOP, &pt, 1 );
HWND hTarget = WindowFromPoint( pt );
INT scroll = SCROLLDIR_NONE;
if ( hTarget == playlist_list.getwnd() )
{
LVHITTESTINFO hitTest = { 0 };
POINTSTOPOINT( hitTest.pt, pts );
MapWindowPoints( hwndDlg, playlist_list.getwnd(), &hitTest.pt, 1 );
int position = ListView_HitTest( playlist_list.getwnd(), &hitTest );
if ( position != -1 )
{
scroll = playlist_GetScrollDirection( playlist_list.getwnd(), hitTest.pt );
handled = TRUE;
}
}
if ( scroll != scrollDirection )
{
if ( SCROLLDIR_NONE == scroll )
{
KillTimer( hwndDlg, SCROLLTIMER_ID );
}
else
{
if ( SCROLLDIR_NONE == scrollDirection )
{
if ( 0 == scrollDelay )
scrollDelay = GetProfileInt( TEXT( "windows" ), TEXT( "DragScrollDelay" ), DD_DEFSCROLLDELAY );
if ( 0 != scrollDelay )
{
scrollTimerElapse = scrollDelay;
SetTimer( hwndDlg, SCROLLTIMER_ID, scrollTimerElapse, playlist_OnScrollTimer );
}
}
}
scrollDirection = scroll;
}
if ( !handled )
{
mlDropItemStruct m = { 0 };
m.type = ML_TYPE_FILENAMES;
m.p = pt;
m.flags = 0; //ML_HANDLEDRAG_FLAG_NOCURSOR;
pluginHandleIpcMessage( ML_IPC_HANDLEDRAG, (WPARAM)&m );
}
else
SetCursor( hDragNDropCursor );
}
}
void playlist_Reload( bool forced )
{
if ( opened || forced )
{
if ( !opened && forced )
{
PostMessage( plugin.hwndLibraryParent, WM_USER + 30, 0, 0 );
return;
}
playlist_Load( currentPlaylistFilename );
// reverted back to known state so any
// of our current changes are now gone
Changed( false );
SyncPlaylist();
}
}
void playlist_ReloadGUID( GUID _guid )
{
if ( playlist_guid == _guid )
playlist_Reload( true );
}
void playlist_Unload( HWND hwndDlg )
{
currentPlaylist.Clear();
currentPlaylistFilename[ 0 ] = 0x0000;
ListView_SetItemCount( playlist_list.getwnd(), 0 );
ListView_RedrawItems( playlist_list.getwnd(), 0, 0 );
UpdatePlaylistTime( hwndDlg );
}
void playlist_DropFiles( HDROP hDrop )
{
wchar_t temp[ 2048 ] = { 0 };
int x;
int y = DragQueryFileW( hDrop, 0xffffffff, temp, 2048 );
Playlist newPlaylist;
for ( x = 0; x < y; x++ )
{
DragQueryFileW( hDrop, x, temp, 2048 );
if ( PathIsDirectory( temp ) )
{
PlaylistDirectoryCallback dirCallback( mediaLibrary.GetExtensionList() );
AGAVE_API_PLAYLISTMANAGER->LoadDirectory( temp, &newPlaylist, &dirCallback );
}
else
{
if ( AGAVE_API_PLAYLISTMANAGER->Load( temp, &newPlaylist ) != PLAYLISTMANAGER_SUCCESS )
{
//wchar_t title[400];
//int length;
//mediaLibrary.GetFileInfo(temp, title, 400, &length);
//newPlaylist.AppendWithInfo(temp, title, length*1000);
newPlaylist.AppendWithInfo( temp, 0, 0 ); // add with NULL info, will be fetched as needed
}
}
}
LVHITTESTINFO hitTest;
DragQueryPoint( hDrop, &hitTest.pt );
ListView_HitTest( playlist_list.getwnd(), &hitTest );
if ( hitTest.iItem != -1 )
{
RECT itemRect;
playlist_list.GetItemRect( hitTest.iItem, &itemRect );
if ( hitTest.pt.y > ( itemRect.bottom + ( itemRect.top - itemRect.bottom ) / 2 ) )
{
hitTest.iItem++;
if ( hitTest.iItem >= playlist_list.GetCount() )
hitTest.iItem = -1;
}
}
if ( hitTest.flags & LVHT_BELOW || hitTest.iItem == -1 )
currentPlaylist.AppendPlaylist( newPlaylist );
else
currentPlaylist.InsertPlaylist( newPlaylist, hitTest.iItem );
DragFinish( hDrop );
Changed();
SyncPlaylist();
}
static HRGN g_rgnUpdate = NULL;
static int offsetX = 0, offsetY = 0;
typedef struct _LAYOUT
{
INT id;
HWND hwnd;
INT x;
INT y;
INT cx;
INT cy;
DWORD flags;
HRGN rgn;
}
LAYOUT, PLAYOUT;
#define SETLAYOUTPOS(_layout, _x, _y, _cx, _cy) { _layout->x=_x; _layout->y=_y;_layout->cx=_cx;_layout->cy=_cy;_layout->rgn=NULL; }
#define SETLAYOUTFLAGS(_layout, _r) \
{ \
BOOL fVis; \
fVis = (WS_VISIBLE & (LONG)GetWindowLongPtr(_layout->hwnd, GWL_STYLE)); \
if (_layout->x == _r.left && _layout->y == _r.top) _layout->flags |= SWP_NOMOVE; \
if (_layout->cx == (_r.right - _r.left) && _layout->cy == (_r.bottom - _r.top)) _layout->flags |= SWP_NOSIZE; \
if ((SWP_HIDEWINDOW & _layout->flags) && !fVis) _layout->flags &= ~SWP_HIDEWINDOW; \
if ((SWP_SHOWWINDOW & _layout->flags) && fVis) _layout->flags &= ~SWP_SHOWWINDOW; \
}
#define LAYOUTNEEEDUPDATE(_layout) ((SWP_NOMOVE | SWP_NOSIZE) != ((SWP_NOMOVE | SWP_NOSIZE | SWP_HIDEWINDOW | SWP_SHOWWINDOW) & _layout->flags))
#define GROUP_MIN 0x1
#define GROUP_MAX 0x2
#define GROUP_STATUSBAR 0x1
#define GROUP_MAIN 0x2
static void LayoutWindows( HWND hwnd, BOOL fRedraw, BOOL fUpdateAll = FALSE )
{
static INT controls[] =
{
GROUP_STATUSBAR, IDC_PLAY, IDC_ENQUEUE, IDC_CUSTOM, IDC_BURN, IDC_ADD, IDC_REM, IDC_SEL, IDC_MISC, IDC_LIST, IDC_SAVE_PL, IDC_PLSTATUS,
GROUP_MAIN, IDC_PLAYLIST_EDITOR
};
INT index;
RECT rc, rg, ri;
LAYOUT layout[ sizeof( controls ) / sizeof( controls[ 0 ] ) ], *pl;
BOOL skipgroup;
HRGN rgn = NULL;
GetClientRect( hwnd, &rc );
if ( rc.right == rc.left || rc.bottom == rc.top )
return;
if ( rc.right > WASABI_API_APP->getScaleX( 4 ) )
rc.right -= WASABI_API_APP->getScaleX( 4 );
SetRect( &rg, rc.left, rc.top, rc.right, rc.top );
pl = layout;
skipgroup = FALSE;
InvalidateRect( hwnd, NULL, TRUE );
for ( index = 0; index < sizeof( controls ) / sizeof( *controls ); index++ )
{
if ( controls[ index ] >= GROUP_MIN && controls[ index ] <= GROUP_MAX ) // group id
{
skipgroup = FALSE;
switch ( controls[ index ] )
{
case GROUP_STATUSBAR:
if ( opened )
{
wchar_t buffer[ 128 ] = { 0 };
GetDlgItemTextW( hwnd, IDC_PLAY, buffer, ARRAYSIZE( buffer ) );
LRESULT idealSize = MLSkinnedButton_GetIdealSize( GetDlgItem( hwnd, IDC_PLAY ), buffer );
SetRect( &rg, rc.left + WASABI_API_APP->getScaleX( 1 ), rc.bottom - WASABI_API_APP->getScaleY( HIWORD( idealSize ) ), rc.right, rc.bottom );
rc.bottom = rg.top - WASABI_API_APP->getScaleY( 3 );
}
else
{
SetRect( &rg, rc.left, rc.top, rc.right, rc.bottom );
}
break;
case GROUP_MAIN:
if ( opened )
SetRect( &rg, rc.left + WASABI_API_APP->getScaleX( 1 ), rc.top, rc.right, rc.bottom );
else
skipgroup = TRUE;
break;
}
continue;
}
if (skipgroup)
continue;
pl->id = controls[index];
pl->hwnd = GetDlgItem(hwnd, pl->id);
if ( !pl->hwnd )
continue;
GetWindowRect( pl->hwnd, &ri );
MapWindowPoints( HWND_DESKTOP, hwnd, (LPPOINT)&ri, 2 );
pl->flags = SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREDRAW | SWP_NOCOPYBITS;
switch ( pl->id )
{
case IDC_PLAY:
case IDC_ENQUEUE:
case IDC_CUSTOM:
case IDC_BURN:
case IDC_ADD:
case IDC_SEL:
case IDC_REM:
case IDC_MISC:
case IDC_LIST:
case IDC_SAVE_PL:
if ( opened && ( IDC_CUSTOM != pl->id || customAllowed ) )
{
if ( groupBtn && pl->id == IDC_PLAY && enqueuedef == 1 )
{
pl->flags |= SWP_HIDEWINDOW;
break;
}
if ( groupBtn && pl->id == IDC_ENQUEUE && enqueuedef != 1 )
{
pl->flags |= SWP_HIDEWINDOW;
break;
}
wchar_t buffer[ 128 ] = { 0 };
GetWindowText( pl->hwnd, buffer, ARRAYSIZE( buffer ) );
LRESULT idealSize = MLSkinnedButton_GetIdealSize( pl->hwnd, buffer );
LONG width = LOWORD( idealSize ) + ( pl->id == IDC_PLAY || pl->id == IDC_ENQUEUE || pl->id == IDC_CUSTOM || pl->id == IDC_SAVE_PL ? WASABI_API_APP->getScaleX( 6 ) : 0 );
SETLAYOUTPOS( pl, rg.left, rg.bottom - WASABI_API_APP->getScaleY( HIWORD( idealSize ) ), width, WASABI_API_APP->getScaleY( HIWORD( idealSize ) ) );
pl->flags |= ( ( rg.right - rg.left ) > width ) ? SWP_SHOWWINDOW : SWP_HIDEWINDOW;
if ( SWP_SHOWWINDOW & pl->flags )
rg.left += ( pl->cx + WASABI_API_APP->getScaleX( 4 ) );
}
else
{
pl->flags |= SWP_HIDEWINDOW;
}
break;
case IDC_PLSTATUS:
if ( opened )
{
wchar_t buffer[ 128 ] = { 0 };
GetWindowTextW( pl->hwnd, buffer, ARRAYSIZE( buffer ) );
LRESULT idealSize = MLSkinnedStatic_GetIdealSize( pl->hwnd, buffer );
SETLAYOUTPOS( pl, rg.left, rg.bottom - WASABI_API_APP->getScaleY( HIWORD( idealSize ) ), rg.right - rg.left, WASABI_API_APP->getScaleY( HIWORD( idealSize ) ) );
if ( SWP_SHOWWINDOW & pl->flags )
rg.top = ( pl->y + pl->cy + WASABI_API_APP->getScaleY( 1 ) );
}
else
{
SETLAYOUTPOS( pl, rg.left + WASABI_API_APP->getScaleY( 20 ),
rg.top + WASABI_API_APP->getScaleY( 1 ),
rg.right - rg.left - WASABI_API_APP->getScaleY( 40 ),
rg.bottom - WASABI_API_APP->getScaleY( 2 ) );
}
break;
case IDC_PLAYLIST_EDITOR:
if ( opened )
{
pl->flags |= ( rg.top < rg.bottom ) ? SWP_SHOWWINDOW : SWP_HIDEWINDOW;
SETLAYOUTPOS( pl, rg.left, rg.top + WASABI_API_APP->getScaleY( 1 ), rg.right - rg.left + WASABI_API_APP->getScaleY( 1 ), ( rg.bottom - rg.top ) - WASABI_API_APP->getScaleY( 2 ) );
}
else
{
pl->flags |= SWP_HIDEWINDOW;
}
break;
}
SETLAYOUTFLAGS( pl, ri );
if ( LAYOUTNEEEDUPDATE( pl ) )
{
if ( SWP_NOSIZE == ( ( SWP_HIDEWINDOW | SWP_SHOWWINDOW | SWP_NOSIZE ) & pl->flags ) && ri.left == ( pl->x + offsetX ) && ri.top == ( pl->y + offsetY ) && IsWindowVisible( pl->hwnd ) )
{
SetRect( &ri, pl->x, pl->y, pl->cx + pl->x, pl->y + pl->cy );
ValidateRect( hwnd, &ri );
}
pl++;
}
else if ( ( fRedraw || ( !offsetX && !offsetY ) ) && IsWindowVisible( pl->hwnd ) )
{
ValidateRect( hwnd, &ri );
if ( GetUpdateRect( pl->hwnd, NULL, FALSE ) )
{
if ( !rgn )
rgn = CreateRectRgn( 0, 0, 0, 0 );
GetUpdateRgn( pl->hwnd, rgn, FALSE );
OffsetRgn( rgn, pl->x, pl->y );
InvalidateRgn( hwnd, rgn, FALSE );
}
}
}
if ( pl != layout )
{
LAYOUT *pc;
HDWP hdwp = BeginDeferWindowPos( (INT)( pl - layout ) );
for ( pc = layout; pc < pl && hdwp; pc++ )
hdwp = DeferWindowPos( hdwp, pc->hwnd, NULL, pc->x, pc->y, pc->cx, pc->cy, pc->flags );
if ( hdwp )
EndDeferWindowPos( hdwp );
if ( !rgn )
rgn = CreateRectRgn( 0, 0, 0, 0 );
for ( pc = layout; pc < pl && hdwp; pc++ )
{
switch ( pc->id )
{
case IDC_PLAYLIST_EDITOR:
PostMessage( hwnd, WM_APP + 100, 0, 0 );
break;
}
}
if ( fRedraw )
{
GetUpdateRgn( hwnd, rgn, FALSE );
for ( pc = layout; pc < pl && hdwp; pc++ )
{
if ( pc->rgn )
{
OffsetRgn( pc->rgn, pc->x, pc->y );
CombineRgn( rgn, rgn, pc->rgn, RGN_OR );
}
}
RedrawWindow( hwnd, NULL, rgn, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASENOW | RDW_ALLCHILDREN );
}
if ( g_rgnUpdate )
{
GetUpdateRgn( hwnd, g_rgnUpdate, FALSE );
for ( pc = layout; pc < pl && hdwp; pc++ )
{
if ( pc->rgn )
{
OffsetRgn( pc->rgn, pc->x, pc->y );
CombineRgn( g_rgnUpdate, g_rgnUpdate, pc->rgn, RGN_OR );
}
}
}
for ( pc = layout; pc < pl && hdwp; pc++ )
{
if ( pc->rgn )
DeleteObject( pc->rgn );
}
}
if ( rgn )
DeleteObject( rgn );
ValidateRgn( hwnd, NULL );
}
INT_PTR CALLBACK view_playlistDialogProc( HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
INT_PTR a = dialogSkinner.Handle( hwndDlg, uMsg, wParam, lParam );
if ( a )
return a;
switch (uMsg)
{
case WM_INITMENUPOPUP:
sendTo.InitPopupMenu( wParam );
return 0;
case WM_MOUSEMOVE:
playlist_MouseMove( hwndDlg, MAKEPOINTS( lParam ) );
return 0;
case WM_LBUTTONUP:
playlist_LeftButtonUp( hwndDlg, wParam, MAKEPOINTS( lParam ) );
return 0;
case WM_PAINT:
playlist_Paint( hwndDlg );
return 0;
case WM_INITDIALOG:
playlist_Init( hwndDlg, lParam );
return TRUE;
case WM_DESTROY:
playlist_Destroy( hwndDlg );
return 0;
case WM_COMMAND:
playlist_Command( hwndDlg, wParam, lParam );
return 0;
case WM_NOTIFY:
return playlist_Notify( hwndDlg, wParam, lParam );
case WM_CONTEXTMENU:
playlist_ContextMenu( hwndDlg, (HWND)wParam, GET_X_LPARAM( lParam ), GET_Y_LPARAM( lParam ) );
return 0;
case WM_ERASEBKGND:
return 1; //handled by WADlg_DrawChildWindowBorders in WM_PAINT
case WM_PLAYLIST_RELOAD:
playlist_Reload();
return 0;
case WM_PLAYLIST_UNLOAD:
playlist_Unload( hwndDlg );
return 0;
case WM_DISPLAYCHANGE:
LayoutWindows( hwndDlg, TRUE );
return 0;
case WM_APP + 104:
{
playlist_UpdateButtonText( hwndDlg, wParam );
LayoutWindows( hwndDlg, TRUE );
return 0;
}
case WM_APP + 103:
{
int current = -1;
if ( wParam )
{
// TODO need to get this done in the background so as not to lock up the ui on large playlists
wchar_t fn[ 1024 ] = { 0 };
int v = playlist_list.GetCount();
for ( int x = 0; x < v; x++ )
{
currentPlaylist.GetItem( x, fn, 1024 );
if ( !lstrcmpi( fn, ( !lParam ? (LPWSTR)wParam : current_playing ) ) )
{
current = x;
break;
}
}
}
PostMessage( playlist_list.getwnd(), WM_ML_IPC, current, ML_IPC_SKINNEDLISTVIEW_SETCURRENT );
}
return 0;
case WM_DROPFILES: playlist_DropFiles((HDROP)wParam); return 0;
case WM_APP+102:
{
if ( cloud_avail )
{
int width = 27;
MLCloudColumn_GetWidth( plugin.hwndLibraryParent, &width );
playlist_list.SetColumnWidth( 1, width );
MLSkinnedHeader_SetCloudColumn( ListView_GetHeader( playlist_list.getwnd() ), 1 );
}
}
case WM_APP+100:
AutoSizePlaylistColumns();
if ( !loaded )
{
loaded = true;
SetWindowRedraw( playlist_list.getwnd(), TRUE );
}
return 0;
case WM_WINDOWPOSCHANGED:
if ( ( SWP_NOSIZE | SWP_NOMOVE ) != ( ( SWP_NOSIZE | SWP_NOMOVE ) & ( (WINDOWPOS *)lParam )->flags ) || ( SWP_FRAMECHANGED & ( (WINDOWPOS *)lParam )->flags ) )
{
LayoutWindows( hwndDlg, !( SWP_NOREDRAW & ( (WINDOWPOS *)lParam )->flags ) );
}
return 0;
case WM_USER + 0x200:
SetWindowLongPtr( hwndDlg, DWLP_MSGRESULT, 1 ); // yes, we support no - redraw resize
return TRUE;
case WM_USER + 0x201:
offsetX = (short)LOWORD( wParam );
offsetY = (short)HIWORD( wParam );
g_rgnUpdate = (HRGN)lParam;
return TRUE;
case WM_ML_CHILDIPC:
{
if ( lParam == ML_CHILDIPC_DROPITEM && wParam )
{
mlDropItemStruct *dis = (mlDropItemStruct *)wParam;
if ( dis )
{
switch ( dis->type )
{
case ML_TYPE_FILENAMES:
case ML_TYPE_STREAMNAMES:
case ML_TYPE_FILENAMESW:
case ML_TYPE_STREAMNAMESW:
case ML_TYPE_ITEMRECORDLIST:
case ML_TYPE_ITEMRECORDLISTW:
case ML_TYPE_CDTRACKS:
dis->result = 1;
break;
default:
dis->result = -1;
break;
}
}
return 0;
}
}
}
return 0;
}
static wchar_t entryFN[ FILENAME_SIZE ];
static wchar_t titleFN[ FILETITLE_SIZE ];
static INT_PTR CALLBACK entryProc( HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
switch ( uMsg )
{
case WM_INITDIALOG:
{
SendDlgItemMessage( hwndDlg, IDC_OLD, EM_SETLIMITTEXT, FILENAME_SIZE, 0 );
SendDlgItemMessage( hwndDlg, IDC_NEW, EM_SETLIMITTEXT, FILENAME_SIZE, 0 );
SendDlgItemMessage( hwndDlg, IDC_OLD_TITLE, EM_SETLIMITTEXT, FILETITLE_SIZE, 0 );
SendDlgItemMessage( hwndDlg, IDC_NEW_TITLE, EM_SETLIMITTEXT, FILETITLE_SIZE, 0 );
SetDlgItemTextW( hwndDlg, IDC_OLD, entryFN );
SetDlgItemTextW( hwndDlg, IDC_OLD_TITLE, titleFN );
SetDlgItemTextW( hwndDlg, IDC_NEW, entryFN );
SetDlgItemTextW( hwndDlg, IDC_NEW_TITLE, titleFN );
return TRUE;
}
case WM_COMMAND:
switch ( LOWORD( wParam ) )
{
case IDOK:
GetDlgItemTextW( hwndDlg, IDC_NEW, entryFN, FILENAME_SIZE );
GetDlgItemTextW( hwndDlg, IDC_NEW_TITLE, titleFN, FILETITLE_SIZE );
EndDialog( hwndDlg, 1 );
return 0;
case IDCANCEL:
EndDialog( hwndDlg, 0 );
return 0;
case IDC_PLAYLIST_EDIT_ENTRY_BROWSE:
{
wchar_t buf[ FILENAME_SIZE ] = { 0 };
UINT len = GetDlgItemTextW( hwndDlg, IDC_NEW, buf, FILENAME_SIZE ) + 1;
OPENFILENAME of = { 0 };
of.lStructSize = sizeof( OPENFILENAME );
of.hwndOwner = hwndDlg;
of.nMaxFileTitle = 32;
of.lpstrFilter = (wchar_t *)SendMessage( plugin.hwndWinampParent, WM_WA_IPC, 1, IPC_GET_EXTLISTW );
of.nMaxCustFilter = 1024;
of.lpstrFile = buf;
of.nMaxFile = FILENAME_SIZE;
of.lpstrTitle = WASABI_API_LNGSTRINGW( IDS_BROWSE_FOR_PLEDIT_ENTRY );
of.Flags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT | OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_ENABLESIZING;
if ( GetOpenFileName( &of ) )
{
wchar_t title[ FILETITLE_SIZE ] = { 0 };
mediaLibrary.GetFileInfo( buf, title, FILETITLE_SIZE, NULL );
SetDlgItemTextW( hwndDlg, IDC_NEW_TITLE, title );
SetDlgItemTextW( hwndDlg, IDC_NEW, buf );
}
GlobalFree( (void *)of.lpstrFilter );
break;
}
}
return 0;
}
return 0;
}
void EditEntry( HWND parent )
{
int i = playlist_list.GetCount();
while ( i-- )
{
if ( playlist_list.GetSelected( i ) )
{
currentPlaylist.GetItem( i, entryFN, FILENAME_SIZE );
currentPlaylist.GetItemTitle( i, titleFN, FILETITLE_SIZE );
INT_PTR res = WASABI_API_DIALOGBOXW( IDD_EDIT_FN, parent, entryProc );
if ( res == 1 )
{
// if the file has changed, force an update of the item'l_enqueue_file file time since we're not
// going to allow the view to automatically do such things since with the changes to
// support editing the title the automatic title lookup after an edit was disabled
wchar_t filepath[ FILENAME_SIZE ] = { 0 };
currentPlaylist.GetItem( i, filepath, FILENAME_SIZE );
if ( lstrcmpi( filepath, entryFN ) )
{
int length = -1;
mediaLibrary.GetFileInfo( entryFN, NULL, NULL, &length );
currentPlaylist.SetItemLengthMilliseconds( i, length * 1000 );
}
currentPlaylist.SetItemFilename( i, entryFN );
currentPlaylist.SetItemTitle( i, titleFN );
Changed();
}
else
break;
}
}
SyncPlaylist();
}
class DownloadEntry : public ifc_downloadManagerCallback
{
public:
DownloadEntry( const wchar_t *p_url, const wchar_t *p_destination_filepath, const wchar_t *p_title, const wchar_t *p_source )
{
this->_url = _wcsdup( p_url );
this->_destination_filepath = _wcsdup( p_destination_filepath );
this->_title = _wcsdup( p_title );
this->_source = _wcsdup( p_source );
}
void OnInit( DownloadToken p_token )
{
api_httpreceiver *l_http = WAC_API_DOWNLOADMANAGER->GetReceiver( p_token );
if ( l_http )
{
l_http->AllowCompression();
l_http->addheader( "Accept: */*" );
}
}
void OnConnect( DownloadToken p_token )
{
// ---- create file handle
_hFile = CreateFileW( _destination_filepath.c_str(), GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if ( _hFile == INVALID_HANDLE_VALUE )
this->cancelDownload( p_token );
this->getContentLength( p_token );
}
void OnTick( DownloadToken p_token )
{
static bool l_was_renamed = false;
const char* l_file_extention = WAC_API_DOWNLOADMANAGER->GetExtention(p_token);
if (l_file_extention && *l_file_extention)
{
wa::strings::wa_string l_destination_filepath_old( _destination_filepath );
wa::strings::wa_string l_destination_filepath_new( _destination_filepath );
if ( !l_destination_filepath_new.contains(l_file_extention) )
{
l_destination_filepath_new.append( "." );
l_destination_filepath_new.append(l_file_extention);
if ( wa::files::file_exists( _destination_filepath.c_str() ) )
{
if ( _hFile != INVALID_HANDLE_VALUE )
CloseHandle( _hFile );
}
if ( std::rename( l_destination_filepath_old.GetA().c_str(), l_destination_filepath_new.GetA().c_str() ) )
{
_destination_filepath = l_destination_filepath_new.GetW();
_hFile = CreateFileW( _destination_filepath.c_str(), FILE_APPEND_DATA, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
}
}
}
}
void OnData( DownloadToken p_token, void *p_data, size_t p_data_size )
{
this->getContentLength( p_token );
if ( _hFile == INVALID_HANDLE_VALUE )
{
// ---- get the file extention
const char* l_file_extention = WAC_API_DOWNLOADMANAGER->GetExtention(p_token);
bool l_extension_found = false;
wa::strings::wa_string l_destination_filepath_old( _destination_filepath );
wa::strings::wa_string l_destination_filepath_new( _destination_filepath );
if ( l_file_extention && *l_file_extention )
{
if ( !l_destination_filepath_new.contains( l_file_extention ) )
{
l_destination_filepath_new.append( "." );
l_destination_filepath_new.append( l_file_extention );
l_extension_found = true;
}
}
else
{
std::string l_filepath(l_file_extention);
int l_position = l_filepath.find_first_of( "." );
if ( l_filepath.size() - l_position > 5 )
{
std::string l_url( WAC_API_DOWNLOADMANAGER->GetUrl( p_token ) );
l_position = l_url.find_last_of( "." );
if ( l_url.size() - l_position < 5 )
{
l_destination_filepath_new.append( "." );
l_destination_filepath_new.append( l_url.substr( l_position + 1 ) );
l_extension_found = true;
}
}
}
if ( l_extension_found )
{
if ( wa::files::file_exists( _destination_filepath.c_str() ) )
{
if ( _hFile != INVALID_HANDLE_VALUE )
CloseHandle( _hFile );
}
if ( std::rename( l_destination_filepath_old.GetA().c_str(), l_destination_filepath_new.GetA().c_str() ) )
{
_destination_filepath = l_destination_filepath_new.GetW();
}
}
// ---- create file handle
_hFile = CreateFileW( _destination_filepath.c_str(), GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
// ---- OnConnect to be removed once dlmgr is fixed
}
// ---- OnData
// ---- if file handle is invalid, then cancel download
if ( _hFile == INVALID_HANDLE_VALUE )
{
this->cancelDownload( p_token );
return;
}
this->_downloaded = (size_t)WAC_API_DOWNLOADMANAGER->GetBytesDownloaded( p_token );
if ( p_data_size > 0 )
{
// ---- hFile is valid handle, and write to disk
DWORD numWritten = 0;
WriteFile( _hFile, p_data, (DWORD)p_data_size, &numWritten, FALSE );
// ---- failed writing the number of datalen characters, cancel download
if ( numWritten != p_data_size )
{
this->cancelDownload( p_token );
return;
}
}
}
void OnCancel( DownloadToken p_token )
{
if ( _hFile != INVALID_HANDLE_VALUE )
{
CloseHandle( _hFile );
DeleteFileW( _destination_filepath.c_str() );
}
this->resumeNextPendingDownload( p_token );
this->Release();
}
void OnError( DownloadToken p_token, int p_error )
{
wsprintfW( _log_message_w, L"An error occurs when downloading the file '%s' ( %d ) !", WAC_API_DOWNLOADMANAGER->GetTitle( p_token ), p_error );
LOG_ERROR( _log_message_w );
if ( _hFile != INVALID_HANDLE_VALUE )
{
CloseHandle( _hFile );
DeleteFileW( _destination_filepath.c_str() );
}
this->resumeNextPendingDownload( p_token );
this->Release();
}
void OnFinish( DownloadToken p_token )
{
if ( _hFile != INVALID_HANDLE_VALUE )
{
CloseHandle( _hFile );
_hFile = INVALID_HANDLE_VALUE;
}
// Update the playlist with the local path
const wchar_t *l_file_location = WAC_API_DOWNLOADMANAGER->GetLocation( p_token );
wa::strings::wa_string l_new_filename( l_file_location );
l_new_filename.append( "." );
l_new_filename.append( WAC_API_DOWNLOADMANAGER->GetExtention( p_token ) );
WAC_API_DOWNLOADMANAGER->SetLocation( p_token, l_new_filename.GetW().c_str() );
for ( pl_entry *l_pl_entry : currentPlaylist.entries )
{
if ( wcscmp( l_pl_entry->filetitle, WAC_API_DOWNLOADMANAGER->GetTitle( p_token ) ) == 0 )
{
l_pl_entry->SetFilename( l_file_location );
if ( AGAVE_API_PLAYLISTMANAGER->Save( currentPlaylistFilename, &currentPlaylist ) != PLAYLISTMANAGER_FAILED )
playlist_list.RefreshAll();
break;
}
}
this->resumeNextPendingDownload( p_token );
this->Release();
}
int GetSource( wchar_t *source, size_t source_cch )
{
if ( !this->_source.empty() )
return wcscpy_s( source, source_cch, this->_source.c_str() );
else
return 1;
}
int GetTitle( wchar_t *title, size_t title_cch )
{
return wcscpy_s( title, title_cch, _title.c_str() );
}
int GetLocation( wchar_t *location, size_t location_cch )
{
return wcscpy_s( location, location_cch, this->_destination_filepath.c_str() );
}
size_t AddRef()
{
return _ref_count.fetch_add( 1 );
}
size_t Release()
{
if ( _ref_count.load() == 0 )
return _ref_count.load();
std::size_t r = _ref_count.fetch_sub( 1 );
if ( r == 0 )
delete( this );
return r;
}
protected:
RECVS_DISPATCH;
private:
inline void resumeNextPendingDownload( DownloadToken p_token )
{
{
AutoLock lock( itemsPlaylistQueueLock );
size_t l_index = 0;
for ( DownloadToken &l_download_token : plDownloads )
{
if ( l_download_token == p_token )
{
plDownloads.erase( plDownloads.begin() + l_index );
break;
}
++l_index;
}
}
for ( DownloadToken &l_download_token : plDownloads )
{
if ( WAC_API_DOWNLOADMANAGER->IsPending( l_download_token ) )
{
WAC_API_DOWNLOADMANAGER->ResumePendingDownload( l_download_token );
break;
}
}
}
inline void cancelDownload( DownloadToken p_token )
{
wsprintfW( _log_message_w, L"The file '%s' was cancelled !", WAC_API_DOWNLOADMANAGER->GetTitle( p_token ) );
LOG_ERROR( _log_message_w );
WAC_API_DOWNLOADMANAGER->CancelDownload( p_token );
this->resumeNextPendingDownload( p_token );
}
inline void getContentLength( DownloadToken p_token )
{
if ( p_token == NULL )
return;
// ---- retrieve total size
api_httpreceiver* l_http = WAC_API_DOWNLOADMANAGER->GetReceiver(p_token);
if ( l_http )
this->_totalSize = l_http->content_length();
}
std::wstring _url;
std::wstring _destination_filepath;
std::wstring _title;
std::wstring _source;
HANDLE _hFile = INVALID_HANDLE_VALUE;
size_t _totalSize = 0;
size_t _downloaded = 0;
std::atomic<std::size_t> _ref_count = 1;
};
#define CBCLASS DownloadEntry
START_DISPATCH;
VCB( IFC_DOWNLOADMANAGERCALLBACK_ONINIT, OnInit )
VCB( IFC_DOWNLOADMANAGERCALLBACK_ONCONNECT, OnConnect )
VCB( IFC_DOWNLOADMANAGERCALLBACK_ONTICK, OnTick )
VCB( IFC_DOWNLOADMANAGERCALLBACK_ONDATA, OnData )
VCB( IFC_DOWNLOADMANAGERCALLBACK_ONCANCEL, OnCancel )
VCB( IFC_DOWNLOADMANAGERCALLBACK_ONFINISH, OnFinish )
VCB( IFC_DOWNLOADMANAGERCALLBACK_ONERROR, OnError )
CB( IFC_DOWNLOADMANAGERCALLBACK_GETSOURCE, GetSource )
CB( IFC_DOWNLOADMANAGERCALLBACK_GETTITLE, GetTitle )
CB( IFC_DOWNLOADMANAGERCALLBACK_GETLOCATION, GetLocation )
CB( ADDREF, AddRef )
CB( RELEASE, Release )
END_DISPATCH;
#undef CBCLASS
void DownloadSelectedEntries( HWND parent )
{
int l_count = playlist_list.GetCount();
pl_entry *l_pl_entry = NULL;
for ( int i = 0; i < l_count; ++i )
{
if ( playlist_list.GetSelected( i ) )
{
if ( !currentPlaylist.IsLocal( i ) )
{
currentPlaylist.GetItem( i, entryFN, FILENAME_SIZE );
currentPlaylist.GetItemTitle( i, titleFN, FILETITLE_SIZE );
if ( WAC_API_DOWNLOADMANAGER )
{
wa::strings::wa_string l_url( entryFN );
TCHAR szPath[ MAX_PATH ];
if ( SUCCEEDED( SHGetFolderPath( NULL, CSIDL_MYMUSIC, NULL, 0, szPath ) ) )
{
l_pl_entry = currentPlaylist.entries[ i ];
bool l_ext_is_find = false;
std::string l_s_url( l_url.GetA() );
wa::strings::wa_string l_full_local_filename( szPath );
l_full_local_filename.append( PLAYLIST_DOWNLOAD_SUBFOLDER );
if ( !wa::files::folder_exists( l_full_local_filename.GetA().c_str() ) )
_mkdir( l_full_local_filename.GetA().c_str() );
wa::strings::wa_string l_title_filename( titleFN );
l_title_filename.replaceAll( "/", "_" );
l_title_filename.replaceAll( "\\", "_" );
l_title_filename.replaceAll( ":", "_" );
l_title_filename.replaceAll( "*", "_" );
l_title_filename.replaceAll( "?", "_" );
l_title_filename.replaceAll( "\"", "_" );
l_title_filename.replaceAll( "<", "_" );
l_title_filename.replaceAll( ">", "_" );
l_title_filename.replaceAll( "|", "_" );
l_full_local_filename.append( l_title_filename.GetW() );
l_ext_is_find = ( l_pl_entry->_extended_infos.count( L"ext" ) == 1 );
if ( l_ext_is_find )
{
wa::strings::wa_string l_file_to_verify( l_full_local_filename.GetW() );
l_file_to_verify.append( "." );
l_file_to_verify.append( (*l_pl_entry->_extended_infos.find(L"ext")).second );
if ( wa::files::file_exists( l_file_to_verify.GetW().c_str() ) )
{
l_pl_entry->SetFilename( l_file_to_verify.GetW().c_str() );
if ( AGAVE_API_PLAYLISTMANAGER->Save( currentPlaylistFilename, &currentPlaylist ) != PLAYLISTMANAGER_FAILED )
playlist_list.RefreshAll();
return;
}
}
wa::strings::wa_string l_source( l_s_url );
l_source.replace( "http://", "" );
l_source.replace( "https://", "" );
l_source = l_source.mid( 0, l_source.findFirst( "/" ) );
wa::strings::wa_string l_redirect_url( WINAMP_REDIRECT_LINK_PROXY_FILE );
l_redirect_url.append( l_url.GetW() );
if ( !l_ext_is_find )
l_redirect_url = l_url.GetW();
DownloadEntry *_downloadEntry = new DownloadEntry( l_redirect_url.GetW().c_str(), l_full_local_filename.GetW().c_str(), titleFN, l_source.GetW().c_str() );
if ( plDownloads.size() < SIMULTANEOUS_DOWNLOADS )
{
DownloadToken dt = WAC_API_DOWNLOADMANAGER->DownloadEx( l_redirect_url.GetA().c_str(), _downloadEntry, api_downloadManager::DOWNLOADEX_CALLBACK | api_downloadManager::DOWNLOADEX_UI );
plDownloads.push_back( dt );
}
else
{
DownloadToken dt = WAC_API_DOWNLOADMANAGER->DownloadEx( l_redirect_url.GetA().c_str(), _downloadEntry, api_downloadManager::DOWNLOADEX_CALLBACK | api_downloadManager::DOWNLOADEX_PENDING | api_downloadManager::DOWNLOADEX_UI );
plDownloads.push_back( dt );
}
}
}
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink