mirror/winamp
1
0
Fork 0
mirror of https://github.com/WinampDesktop/winamp.git synced 2024-09-24 15:54:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
winamp/Src/Plugins/Library/ml_disc/cdburn.cpp

2156 lines
64 KiB
C++
Raw Normal View History

Initial community commit
2024-09-24 12:54:57 +00:00
#include "main.h"
#include <stdio.h>
#include "../nu/ns_wc.h"
#include "resource.h"
#include "../nu/listview.h"
#include "../nu/DialogSkinner.h"
#include "../nu/ChildSizer.h"
#include "config.h"
#include "../../General/gen_ml/gaystring.h"
#include "../Winamp/burn.h"
#include "../Winamp/strutil.h"
#include <std::vector>
#include "../nu/AutoChar.h"
#include "../nu/AutoWide.h"
#include <api/service/waServiceFactory.h>
#include "../playlist/ifc_playlistloadercallback.h"
#include "../playlist/api_playlistmanager.h"
#include <imapi.h>
#include <imapierror.h>
#include <shlwapi.h>
#include <strsafe.h>
//shit to finish:
//-erase CDRWs
//-cache the veritas handle
//-recurse add folders
//-check for available space on HD before burning
//-the resampling in convert
#define WM_EX_OPCOMPLETED (WM_USER + 0x100)
class PLCallBack : ifc_playlistloadercallback
{
public:
PLCallBack(void) : fileList(0) {};
~PLCallBack(void) {};
public:
void OnFile(const wchar_t *filename, const wchar_t *title, int lengthInMS, ifc_plentryinfo *info)
{
fileList->push_back(new GayString(AutoChar(filename)));
}
RECVS_DISPATCH;
public:
std::vector<GayString*> *fileList;
};
#define CBCLASS PLCallBack
START_DISPATCH;
VCB(IFC_PLAYLISTLOADERCALLBACK_ONFILE, OnFile)
END_DISPATCH;
#undef CBCLASS
class PLCallBackW : ifc_playlistloadercallback
{
public:
PLCallBackW(void) : fileList(0) {};
~PLCallBackW(void) {};
public:
void OnFile(const wchar_t *filename, const wchar_t *title, int lengthInMS, ifc_plentryinfo *info)
{
fileList->push_back(new GayStringW(filename));
}
RECVS_DISPATCH;
public:
std::vector<GayStringW*> *fileList;
};
#define CBCLASS PLCallBackW
START_DISPATCH;
VCB(IFC_PLAYLISTLOADERCALLBACK_ONFILE, OnFile)
END_DISPATCH;
#undef CBCLASS
static INT_PTR WINAPI DlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
#include "../burnlib/burnlib.h"
static W_ListView m_statuslist;
static HWND m_hwndstatus;
static char m_cdrom;
static int m_is_cdrw, m_availsecs;
static int m_max_speed;
static int m_dragging, m_drag_item;
static HWND prevWnd = NULL;
itemRecordListW itemCache[100] = {0};
static int percentCompleted = 0;
static DWORD pidBurner = 0;
static HFONT hPLFont = NULL;
static int LETTERTOINDEX(char c)
{
c = (char)toupper(c);
if (c < 'A') c = 'A';
if (c > 'Z') c = 'Z';
return c -'A';
}
#include "../winamp/wa_ipc.h"
#define TIMER_NOTIFYINFO_ID 1985
#define TIMER_NOTIFYINFO_DELAY 200
static ChildWndResizeItem burnwnd_rlist[] =
{
{IDC_LIST2, 0x0011},
{IDC_CDINFO, 0x0010},
{IDC_ADD, 0x0101},
{IDC_BURN, 0x0101},
{IDC_CLEAR, 0x0101},
{IDC_BURN_OPTS, 0x0101},
{IDC_CANCEL_BURN, 0x0101},
{IDC_LOGO, 0x1010},
{IDC_BTN_SHOWINFO, 0x1111},
};
static _inline void code(long* v, long* k)
{
unsigned long y = v[0], z = v[1], sum = 0, /* set up */
delta = 0x9e3779b9, n = 32 ; /* key schedule constant*/
while (n-- > 0)
{ /* basic cycle start */
sum += delta;
y += ((z << 4) + k[0]) ^(z + sum) ^((z >> 5) + k[1]);
z += ((y << 4) + k[2]) ^(y + sum) ^((y >> 5) + k[3]); /* end cycle */
}
v[0] = y; v[1] = z;
}
static void startBurn(HWND hwndDlg, char driveletter)
{
g_config->WriteInt(L"cdburnmaxspeed", m_max_speed);
//write the temp playlist to disk
FILE *fp;
char filename[MAX_PATH] = {0}, tp[MAX_PATH] = {0};
pidBurner = 0;
if (!GetTempPathA(sizeof(tp), tp)) lstrcpynA(tp, ".", MAX_PATH);
if (GetTempFileNameA(tp, "BRN", 0, filename))
{
unlink(filename);
StringCchCatA(filename, MAX_PATH, ".m3u8");
}
else lstrcpynA(filename, "brn_tmp.m3u8", MAX_PATH);
fp = fopen(filename, "wt");
if (!fp)
{
wchar_t title[16] = {0};
MessageBox(hwndDlg, WASABI_API_LNGSTRINGW(IDS_ERROR_WRITING_TEMP_BURN_LIST),
WASABI_API_LNGSTRINGW_BUF(IDS_ERROR,title,16), MB_OK);
return ;
}
int idx = LETTERTOINDEX(driveletter);
fprintf(fp, "#EXTM3U\n");
for (int i = 0;i < itemCache[idx].Size;i++)
{
fprintf(fp, "#EXTINF:%d,%s\n", itemCache[idx].Items[i].length, (char *)AutoChar(itemCache[idx].Items[i].title, CP_UTF8));
fprintf(fp, "%s\n", (char *)AutoChar(itemCache[idx].Items[i].filename, CP_UTF8));
}
fclose(fp);
burnCDStruct bcds =
{
m_cdrom,
filename,
hwndDlg,
"",
};
pidBurner = (DWORD)(INT_PTR)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM) & bcds, IPC_BURN_CD);
if (!pidBurner)
{
wchar_t title[16] = {0};
unlink(filename);
MessageBox(hwndDlg, AutoWide(bcds.error), WASABI_API_LNGSTRINGW_BUF(IDS_ERROR,title,16), MB_OK);
}
}
static void link_handledraw(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if (uMsg == WM_DRAWITEM)
{
DRAWITEMSTRUCT *di = (DRAWITEMSTRUCT *)lParam;
if (di->CtlType == ODT_BUTTON)
{
wchar_t wt[123] = {0};
int y;
RECT r;
HPEN hPen, hOldPen;
GetDlgItemText(hwndDlg, (int)wParam, wt, 123);
// draw text
SetTextColor(di->hDC, (di->itemState & ODS_SELECTED) ? RGB(220, 0, 0) : RGB(0, 0, 220));
r = di->rcItem;
r.left += 2;
DrawText(di->hDC, wt, -1, &r, DT_VCENTER | DT_SINGLELINE);
memset(&r, 0, sizeof(r));
DrawText(di->hDC, wt, -1, &r, DT_SINGLELINE | DT_CALCRECT);
// draw underline
y = di->rcItem.bottom - ((di->rcItem.bottom - di->rcItem.top) - (r.bottom - r.top)) / 2 - 1;
hPen = CreatePen(PS_SOLID, 0, (di->itemState & ODS_SELECTED) ? RGB(220, 0, 0) : RGB(0, 0, 220));
hOldPen = (HPEN) SelectObject(di->hDC, hPen);
MoveToEx(di->hDC, di->rcItem.left + 2, y, NULL);
LineTo(di->hDC, di->rcItem.right + 2 - ((di->rcItem.right - di->rcItem.left) - (r.right - r.left)), y);
SelectObject(di->hDC, hOldPen);
DeleteObject(hPen);
}
}
}
static void refreshList()
{
if (!m_hwndstatus) return ;
ListView_SetItemCount(m_statuslist.getwnd(), 0);
int idx = LETTERTOINDEX(m_cdrom);
ListView_SetItemCount(m_statuslist.getwnd(), itemCache[idx].Size);
if (itemCache[idx].Size > 0) ListView_RedrawItems(m_statuslist.getwnd(), 0, itemCache[idx].Size - 1);
}
static int m_last_trackpos;
typedef struct _MEDIAINFO
{
CHAR cLetter;
BOOL bInserted;
BOOL bRecordable;
BOOL bRewritable;
BOOL bBlank;
ULONG nSectorsFree;
ULONG nSectorsUsed;
} MEDIAINFO;
static HRESULT GetMediaInfoFromSonic(MEDIAINFO *pmi)
{
HRESULT hr;
hr = S_OK;
char name[]= "cda://X.cda";
char buf2[64] = "";
char buf3[64] = "";
name[6] = pmi->cLetter;
pmi->bInserted = FALSE;
pmi->bRewritable = FALSE;
pmi->nSectorsFree = 0;
pmi->nSectorsUsed = 0;
pmi->bRecordable = TRUE;
getFileInfo(name, "cdtype", buf3, sizeof(buf3));
if (buf3[0] && 0 == lstrcmpA(buf3, "CDRW")) pmi->bRewritable = TRUE;
getFileInfo(name, "cdlengths", buf2, sizeof(buf2));
if (buf2[0])
{
pmi->bInserted = TRUE;
pmi->nSectorsFree = atoi(buf2);
}
return hr;
}
static void CALLBACK FreeAsyncParam(DM_NOTIFY_PARAM *phdr)
{
switch(phdr->opCode)
{
case DMOP_IMAPIINFO:
break;
}
free(phdr);
}
static void FinishSetStatus(HWND hwndDlg, MEDIAINFO *pmi)
{
int freesecs;
if(pmi->bInserted)
{
freesecs = (pmi->nSectorsFree * 2048) / (150 * 1024); //150kb/s as its considered DATA CD at this point in veritas
}
else
{
freesecs = 74 * 60; //Default to 74mns CDR
}
m_availsecs = freesecs;
int idx = LETTERTOINDEX(m_cdrom);
int usedlen = 0;
int truncpos = 0;
for (int i = 0;i < itemCache[idx].Size;i++)
{
usedlen += itemCache[idx].Items[i].length;
if (usedlen > m_availsecs)
truncpos++;
}
m_availsecs -= usedlen;
wchar_t status[256] = {0};
if (!pmi->bInserted)
WASABI_API_LNGSTRINGW_BUF(IDS_NO_BLANK_CDR_IN_DRIVE,status,512);
else
{
StringCchPrintf(status, 512, WASABI_API_LNGSTRINGW(IDS_X_CAPACITY_DETAILS),
(pmi->bRewritable) ? L"CD-RW" : L"CD-R" , freesecs / 60, freesecs % 60);
}
wchar_t temp[16] = {0};
StringCchPrintf(status + wcslen(status), 256,
WASABI_API_LNGSTRINGW(IDS_USED_X_X_TRACKS),
usedlen / 60,
usedlen % 60,
itemCache[idx].Size,
WASABI_API_LNGSTRINGW_BUF(itemCache[idx].Size == 1 ? IDS_TRACK : IDS_TRACKS,temp,16));
if (freesecs && pmi->bInserted)
{
if (m_availsecs >= 0) StringCchPrintf(status + wcslen(status), 256, WASABI_API_LNGSTRINGW(IDS_AVAILABLE_X_X),
m_availsecs / 60, m_availsecs % 60);
else StringCchPrintf(status + wcslen(status), 256, WASABI_API_LNGSTRINGW(IDS_X_OVER_CAPACITY_REMOVE_X_TRACKS),
-m_availsecs / 60, -m_availsecs % 60, truncpos);
}
SetDlgItemText(hwndDlg, IDC_CDINFO, status);
m_last_trackpos = -1;
m_is_cdrw = pmi->bRewritable;
ListView_RedrawItems(m_statuslist.getwnd(), 0, itemCache[idx].Size - 1);
}
static void SetStatus(HWND hwndDlg, CHAR cLetter)
{
if (DM_MODE_BURNING == DriveManager_GetDriveMode(cLetter) &&
NULL != (m_burning_other_wnd = cdburn_FindBurningHWND(cLetter)))
{
prevWnd = (HWND)SendMessage(m_burning_other_wnd, WM_BURNUPDATEOWNER, 0, (LPARAM)hwndDlg);
if (prevWnd == hwndDlg) prevWnd = NULL;
DWORD state = (DWORD)(INT_PTR)SendMessage(m_burning_other_wnd, WM_BURNGETSTATUS, BURNSTATUS_STATE, 0);
if (state)
{
SetDlgItemText(hwndDlg, IDC_CDINFO, WASABI_API_LNGSTRINGW(IDS_BURNING));
ShowWindow(GetDlgItem(hwndDlg, IDC_CLEAR), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg, IDC_ADD), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg, IDC_BURN), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg, IDC_BURN_OPTS), SW_SHOWNA);
ShowWindow(GetDlgItem(hwndDlg, IDC_CANCEL_BURN), SW_SHOWNA);
SetDlgItemText(hwndDlg, IDC_CANCEL_BURN, WASABI_API_LNGSTRINGW(IDS_CANCEL_BURN));
m_availsecs = 0;
m_last_trackpos = -1;
m_is_cdrw = 0;
percentCompleted = 0;
UpdateWindow(hwndDlg);
}
SendMessage(hwndDlg, WM_BURNNOTIFY, BURN_STATECHANGED, state);
ShowWindow(m_burning_other_wnd, g_config->ReadInt(L"cdburnstatuswnd", 1) ? SW_SHOWNA : SW_HIDE);
PostMessage(m_burning_other_wnd, WM_BURNCONFIGCHANGED, BURNCFG_HIDEVIEW, !g_config->ReadInt(L"cdburnstatuswnd", 1));
PostMessage(m_burning_other_wnd, WM_BURNCONFIGCHANGED, BURNCFG_AUTOEJECT, g_config->ReadInt(L"cdburnautoeject", 1));
PostMessage(m_burning_other_wnd, WM_BURNCONFIGCHANGED, BURNCFG_ADDTODB, g_config->ReadInt(L"cdburnautoadddb", 0));
PostMessage(m_burning_other_wnd, WM_BURNCONFIGCHANGED, BURNCFG_AUTOCLOSE, g_config->ReadInt(L"cdburnautoclose", 0));
}
else
{
BOOL br;
ShowWindow(GetDlgItem(hwndDlg, IDC_CLEAR), SW_SHOWNA);
ShowWindow(GetDlgItem(hwndDlg, IDC_ADD), SW_SHOWNA);
ShowWindow(GetDlgItem(hwndDlg, IDC_BURN), SW_SHOWNA);
ShowWindow(GetDlgItem(hwndDlg, IDC_BURN_OPTS), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg, IDC_CANCEL_BURN), SW_HIDE);
SetDlgItemText(hwndDlg, IDC_CDINFO, WASABI_API_LNGSTRINGW(IDS_CALCULATING));
UpdateWindow(hwndDlg);
DM_IMAPI_PARAM *pIMAPI = (DM_IMAPI_PARAM*)calloc(1, sizeof(DM_IMAPI_PARAM));
if (pIMAPI)
{
pIMAPI->header.cLetter = cLetter;
pIMAPI->header.callback = (INT_PTR)hwndDlg;
pIMAPI->header.uMsg = WM_EX_OPCOMPLETED;
pIMAPI->header.fnFree = FreeAsyncParam;
pIMAPI->header.fFlags = DMF_QUERYMEDIATYPE | DMF_QUERYMEDIAINFO;
br = DriveManager_GetIMAPIInfo(pIMAPI);
}
else br = FALSE;
if (!br) SetDlgItemText(hwndDlg, IDC_CDINFO, WASABI_API_LNGSTRINGW(IDS_DISC_READ_ERROR));
}
}
static void deleteSelectedItems(HWND hwndDlg, CHAR cLetter)
{
int idx = LETTERTOINDEX(cLetter);
for (int i = itemCache[idx].Size - 1;i >= 0;i--)
{
if (m_statuslist.GetSelected(i))
{
freeRecord(&itemCache[idx].Items[i]);
int l = itemCache[idx].Size - i - 1;
if (l > 0) memcpy(&itemCache[idx].Items[i], &itemCache[idx].Items[i + 1], sizeof(itemRecordW)*l);
itemCache[idx].Size--;
}
}
SetStatus(hwndDlg, cLetter);
refreshList();
}
static void selectAll()
{
int l = m_statuslist.GetCount();
for (int i = 0;i < l;i++) m_statuslist.SetSelected(i);
}
static void playSelectedItems(HWND hwndDlg, int enqueue)
{
int idx = LETTERTOINDEX(m_cdrom);
if (!enqueue) SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_DELETE);
for (int i = 0;i < itemCache[idx].Size;i++)
{
if (!m_statuslist.GetSelected(i)) continue;
//send the file to winamp
COPYDATASTRUCT cds;
cds.dwData = IPC_PLAYFILEW;
cds.lpData = (void *)itemCache[idx].Items[i].filename;
cds.cbData = (DWORD)(sizeof(wchar_t *) * (wcslen(itemCache[idx].Items[i].filename) + 1)); // include space for null char
SendMessageW(plugin.hwndWinampParent, WM_COPYDATA, (WPARAM)NULL, (LPARAM)&cds);
}
if (!enqueue) SendMessageW(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_STARTPLAY);
}
BOOL CALLBACK CantBurnProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_INITDIALOG:
{
wchar_t *message = (wchar_t *)lParam;
// due to quirks with the more common resource editors, is easier to just store the string
// internally only with \n and post-process to be \r\n (as here) so it will appear correctly
// on new lines as is wanted (silly multiline edit controls)
wchar_t tmp2[1024] = {0}, *t2 = tmp2;
while(message && *message && (t2 - tmp2 < 1024))
{
if(*message == L'\n')
{
*t2 = L'\r';
t2 = CharNextW(t2);
}
*t2 = *message;
message = CharNextW(message);
t2 = CharNextW(t2);
}
SetDlgItemText(hwnd, IDC_MESSAGE2, tmp2);
}
return 0;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDOK:
EndDialog(hwnd, 0);
break;
case IDCANCEL:
EndDialog(hwnd, -1);
break;
}
}
return 0;
}
HRESULT ResolveShortCut(HWND hwnd, LPCSTR pszShortcutFile, LPSTR pszPath)
{
HRESULT hres;
IShellLinkA* psl;
WIN32_FIND_DATAA wfd;
*pszPath = 0; // assume failure
hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
IID_IShellLinkA, (void **) & psl);
if (SUCCEEDED(hres))
{
IPersistFile* ppf;
hres = psl->QueryInterface(IID_IPersistFile, (void **) & ppf); // OLE 2! Yay! --YO
if (SUCCEEDED(hres))
{
wchar_t wsz[MAX_PATH] = {0};
MultiByteToWideCharSZ(CP_ACP, 0, pszShortcutFile, -1, wsz, MAX_PATH);
hres = ppf->Load(wsz, STGM_READ);
if (SUCCEEDED(hres))
{
hres = psl->Resolve(hwnd, SLR_ANY_MATCH);
if (SUCCEEDED(hres))
{
char szGotPath[MAX_PATH] = {0};
lstrcpynA(szGotPath, pszShortcutFile, MAX_PATH);
hres = psl->GetPath(szGotPath, MAX_PATH, (WIN32_FIND_DATAA *) & wfd,
SLGP_SHORTPATH);
lstrcpynA(pszPath, szGotPath, MAX_PATH);
}
}
ppf->Release();
}
psl->Release();
}
return SUCCEEDED(hres);
}
HRESULT ResolveShortCut(HWND hwnd, LPCWSTR pszShortcutFile, LPWSTR pszPath)
{
HRESULT hres;
IShellLinkW* psl;
WIN32_FIND_DATAW wfd;
*pszPath = 0; // assume failure
hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
IID_IShellLinkW, (void **) & psl);
if (SUCCEEDED(hres))
{
IPersistFile* ppf;
hres = psl->QueryInterface(IID_IPersistFile, (void **) & ppf); // OLE 2! Yay! --YO
if (SUCCEEDED(hres))
{
/*wchar_t wsz[MAX_PATH] = {0};
MultiByteToWideCharSZ(CP_ACP, 0, pszShortcutFile, -1, wsz, MAX_PATH);*/
hres = ppf->Load(pszShortcutFile/*wsz*/, STGM_READ);
if (SUCCEEDED(hres))
{
hres = psl->Resolve(hwnd, SLR_ANY_MATCH);
if (SUCCEEDED(hres))
{
wchar_t szGotPath[MAX_PATH] = {0};
wcsncpy(szGotPath, pszShortcutFile, MAX_PATH);
hres = psl->GetPath(szGotPath, MAX_PATH, (WIN32_FIND_DATAW *) & wfd,
SLGP_SHORTPATH);
wcsncpy(pszPath, szGotPath, MAX_PATH);
}
}
ppf->Release();
}
psl->Release();
}
return SUCCEEDED(hres);
}
static int checkFile(const char *file)
{
//check if the file is supported by winamp
const char *ext = extension(file);
if (!ext || !ext[0]) return 0;
if (strstr(file, "://") && !strstr(file, "cda://")) return 0;
#if 0 // benski> this would be neat to have, but will fail with unicode filenames (which in_mp3 can open anyway)... TODO: make it workable later
HANDLE hFile = CreateFile(file, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (INVALID_HANDLE_VALUE == hFile && GetLastError() != ERROR_FILE_NOT_FOUND)
{
wchar_t message[1024] = {0};
StringCchPrintfW(message, 1024, WASABI_API_LNGSTRINGW(IDS_FILE_X_CANNOT_BE_BURNED_REASON_NOT_FOUND), AutoWide(file), AutoWide(ext));
return WASABI_API_DIALOGBOXPARAM(IDD_NOBURN, g_hwnd, CantBurnProc, (LPARAM)message);
}
CloseHandle(hFile);
#endif
char *m_extlist = (char*)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GET_EXTLIST);
{
int found = 0;
char *a = m_extlist;
while (a && *a)
{
if (!lstrcmpiA(a, ext))
{
found = 1;
break;
}
a += lstrlenA(a) + 1;
}
GlobalFree((HGLOBAL)m_extlist);
if (!found)
{
wchar_t message[1024] = {0};
StringCchPrintfW(message, 1024, WASABI_API_LNGSTRINGW(IDS_FILE_X_CANNOT_BE_BURNED_REASON_FILETYPE_NOT_REGISTERED), AutoWide(file), AutoWide(ext));
return (int)(INT_PTR)WASABI_API_DIALOGBOXPARAM(IDD_NOBURN, plugin.hwndLibraryParent, CantBurnProc, (LPARAM)message);
}
}
//check for type
char tmp[64] = {0, };
getFileInfo(file, "type", tmp, sizeof(tmp) - 1);
if (tmp[0] && tmp[0] != '0')
{
wchar_t message[1024], temp[128] = {0};
StringCchPrintfW(message, 1024, WASABI_API_LNGSTRINGW(IDS_FILE_X_CANNOT_BE_BURNED_REASON_X),AutoWide(file),
WASABI_API_LNGSTRINGW_BUF((tmp[0] == '1' ? IDS_VIDEO_FILES_CANNOT_BE_BURNED : IDS_NOT_AN_AUDIO_FILE),temp,128));
return (int)(INT_PTR)WASABI_API_DIALOGBOXPARAM(IDD_NOBURN, plugin.hwndLibraryParent, CantBurnProc, (LPARAM)message);
}
// note: this check is NOT meant as any sort of protection.. It simply saves the user the hassle of an error later
if (getFileInfo(file, "burnable", tmp, 64) // most plugins don't support this extended file info, so failure is OK
&& tmp[0] == '0') // if it does support it, then we can check whether or not it's burnable
{
wchar_t message[1024] = {0};
StringCchPrintfW(message, 1024, WASABI_API_LNGSTRINGW(IDS_FILE_CANNOT_BE_BURNED), AutoWide(file));
if (getFileInfo(file, "noburnreason", tmp, 64))
{
StringCchPrintfW(message, 1024,
WASABI_API_LNGSTRINGW(IDS_FILE_X_CANNOT_BE_BURNED_REASON_X),
AutoWide(file), AutoWide(tmp));
}
return (int)(INT_PTR)WASABI_API_DIALOGBOXPARAM(IDD_NOBURN, plugin.hwndLibraryParent, CantBurnProc, (LPARAM)message);
}
return 1;
}
static int checkFile(const wchar_t *file)
{
//check if the file is supported by winamp
const wchar_t *ext = PathFindExtension(file);
if (!ext || !ext[0]) return 0;
ext++;
if (wcsstr(file, L"://") && !wcsstr(file, L"cda://")) return 0;
#if 0 // benski> this would be neat to have, but will fail with unicode filenames (which in_mp3 can open anyway)... TODO: make it workable later
HANDLE hFile = CreateFile(file, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (INVALID_HANDLE_VALUE == hFile && GetLastError() == ERROR_FILE_NOT_FOUND)
{
wchar_t message[1024] = {0};
StringCchPrintfW(message, 1024, WASABI_API_LNGSTRINGW(IDS_FILE_X_CANNOT_BE_BURNED_REASON_NOT_FOUND), file, ext);
return WASABI_API_DIALOGBOXPARAM(IDD_NOBURN, g_hwnd, CantBurnProc, (LPARAM)message);
}
CloseHandle(hFile);
#endif
wchar_t *m_extlist = (wchar_t*)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GET_EXTLISTW);
{
int found = 0;
wchar_t *a = m_extlist;
while (a && *a)
{
if (!lstrcmpiW(a, ext))
{
found = 1;
break;
}
a += lstrlenW(a) + 1;
}
GlobalFree((HGLOBAL)m_extlist);
if (!found)
{
wchar_t message[1024] = {0};
StringCchPrintfW(message, 1024, WASABI_API_LNGSTRINGW(IDS_FILE_X_CANNOT_BE_BURNED_REASON_FILETYPE_NOT_REGISTERED), file, ext);
return (int)(INT_PTR)WASABI_API_DIALOGBOXPARAM(IDD_NOBURN, plugin.hwndLibraryParent, CantBurnProc, (LPARAM)message);
}
}
//check for type
wchar_t tmp[64] = {0, };
getFileInfoW(file, L"type", tmp, 64);
if (tmp[0] && tmp[0] != '0')
{
wchar_t message[1024] = {0}, temp[128] = {0};
StringCchPrintfW(message, 1024, WASABI_API_LNGSTRINGW(IDS_FILE_X_CANNOT_BE_BURNED_REASON_X), file,
WASABI_API_LNGSTRINGW_BUF((tmp[0] == '1' ? IDS_VIDEO_FILES_CANNOT_BE_BURNED : IDS_NOT_AN_AUDIO_FILE),temp,128));
return (int)(INT_PTR)WASABI_API_DIALOGBOXPARAM(IDD_NOBURN, plugin.hwndLibraryParent, CantBurnProc, (LPARAM)message);
}
// note: this check is NOT meant as any sort of protection.. It simply saves the user the hassle of an error later
if (getFileInfoW(file, L"burnable", tmp, 64) // most plugins don't support this extended file info, so failure is OK
&& tmp[0] == '0') // if it does support it, then we can check whether or not it's burnable
{
wchar_t message[1024] = {0};
StringCchPrintfW(message, 1024, WASABI_API_LNGSTRINGW(IDS_FILE_CANNOT_BE_BURNED), file);
if (getFileInfoW(file, L"noburnreason", tmp, 64))
{
StringCchPrintfW(message, 1024,
WASABI_API_LNGSTRINGW(IDS_FILE_X_CANNOT_BE_BURNED_REASON_X),
file, tmp);
}
return (int)(INT_PTR)WASABI_API_DIALOGBOXPARAM(IDD_NOBURN, plugin.hwndLibraryParent, CantBurnProc, (LPARAM)message);
}
return 1;
}
void cdburn_clearBurner(char driveletter)
{
emptyRecordList(&itemCache[LETTERTOINDEX(driveletter)]);
}
void cdburn_addfile(char* file, std::vector<GayString*> *files, api_playlistmanager* plManager, ifc_playlistloadercallback *plCB);
void cdburn_addfile(wchar_t* file, std::vector<GayStringW*> *files, api_playlistmanager* plManager, ifc_playlistloadercallback *plCB);
void cdburn_addfolder(const char* folder, std::vector<GayString*> *files, api_playlistmanager* plManager, ifc_playlistloadercallback *plCB);
void cdburn_addfolder(const wchar_t* folder, std::vector<GayStringW*> *files, api_playlistmanager* plManager, ifc_playlistloadercallback *plCB);
void cdburn_appendFile(char *file, char cLetter)
{
std::vector<GayString*> files;
waServiceFactory *plmFactory = plugin.service->service_getServiceByGuid(api_playlistmanagerGUID);
api_playlistmanager *plManager = (plmFactory) ? (api_playlistmanager*)plmFactory->getInterface() : NULL;
int idx = LETTERTOINDEX(cLetter);
int validFile = 1;
if (itemCache[idx].Size > 255) return;
itemRecordListW newItems = {0, 0, 0};
PLCallBack plCB;
plCB.fileList = &files;
cdburn_addfile(file, &files, (api_playlistmanager*)plManager, (ifc_playlistloadercallback*)&plCB);
size_t x;
for (x = 0; x < files.size(); x ++) // temp record . replace it !!!
{
char *fn = files.at(x)->Get();
validFile = checkFile(fn);
// can't use switch here cause break won't work
if (validFile == -1) // bad file and user cancelled
break;
if (validFile) // bad file, user skipped
{
allocRecordList(&newItems, newItems.Size + 1);
if (!newItems.Alloc) break;
char title[2048] = {0};
basicFileInfoStruct bfis = {fn, 0, 0, title, sizeof(title) - 1,};
SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&bfis, IPC_GET_BASIC_FILE_INFO);
if (bfis.length > 0)
{
memset((void *)&(newItems.Items[newItems.Size]), 0, sizeof(itemRecordW));
newItems.Items[newItems.Size].filename = AutoWideDup(fn);
newItems.Items[newItems.Size].title = AutoWideDup(title);
newItems.Items[newItems.Size].length = bfis.length;
newItems.Size++;
}
}
delete(files.at(x)->Get());
}
if (validFile != -1)
copyRecordList(&itemCache[idx], &newItems);
refreshList();
if (m_hwndstatus) SetStatus(m_hwndstatus, cLetter);
if (plManager) plmFactory->releaseInterface(plManager);
}
void cdburn_appendFile(wchar_t *file, char cLetter)
{
std::vector<GayStringW*> files;
waServiceFactory *plmFactory = plugin.service->service_getServiceByGuid(api_playlistmanagerGUID);
api_playlistmanager *plManager = (plmFactory) ? (api_playlistmanager*)plmFactory->getInterface() : NULL;
int idx = LETTERTOINDEX(cLetter);
int validFile = 1;
if (itemCache[idx].Size > 255) return;
itemRecordListW newItems = {0, 0, 0};
PLCallBackW plCB;
plCB.fileList = &files;
cdburn_addfile(file, &files, (api_playlistmanager*)plManager, (ifc_playlistloadercallback*)&plCB);
size_t x;
for (x = 0; x < files.size(); x ++) // temp record . replace it !!!
{
const wchar_t *fn = files.at(x)->Get();
validFile = checkFile(fn);
// can't use switch here cause break won't work
if (validFile == -1) // bad file and user cancelled
break;
if (validFile) // bad file, user skipped
{
allocRecordList(&newItems, newItems.Size + 1);
if (!newItems.Alloc) break;
wchar_t title[2048] = {0};
basicFileInfoStructW bfis = {fn, 0, 0, title, ARRAYSIZE(title) - 1,};
SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&bfis, IPC_GET_BASIC_FILE_INFOW);
if (bfis.length > 0)
{
memset((void *)&(newItems.Items[newItems.Size]), 0, sizeof(itemRecordW));
newItems.Items[newItems.Size].filename = _wcsdup(fn);
newItems.Items[newItems.Size].title = _wcsdup(title);
newItems.Items[newItems.Size].length = bfis.length;
newItems.Size++;
}
}
delete(files.at(x)->Get());
}
if (validFile != -1)
copyRecordList(&itemCache[idx], &newItems);
refreshList();
if (m_hwndstatus) SetStatus(m_hwndstatus, cLetter);
if (plManager) plmFactory->releaseInterface(plManager);
}
void cdburn_addfile(char* file, std::vector<GayString*> *files, api_playlistmanager* plManager, ifc_playlistloadercallback *plCB)
{
if (!_stricmp(extension(file), "lnk"))
{
char temp2[MAX_PATH] = {0};
if (ResolveShortCut(plugin.hwndLibraryParent, file, temp2)) lstrcpynA(file, temp2, MAX_PATH);
else return;
}
if (!_strnicmp(file, "cda://", 6))
{
if (strlen(file) == 7)
{
int n = 0;
char buf2[32] = {0};
getFileInfo(file, "ntracks", buf2, sizeof(buf2));
n = atoi(buf2);
if (n > 0 && n < 256)
{
for (int x = 0; x < n; x ++)
{
char s[64] = {0};
StringCchPrintfA(s, 64, "%s,%d.cda", file, x + 1);
files->push_back(new GayString(s));
}
}
}
else files->push_back(new GayString(file));
}
else if (strstr(file, "://"))
{
if (plManager && PLAYLISTMANAGER_SUCCESS != plManager->Load(AutoWide(file), plCB))
{
files->push_back(new GayString(file));
}
}
else if (!lstrcmpA(file + 1, ":\\"))
{
cdburn_addfolder(file, files, plManager, plCB);
}
else
{
WIN32_FIND_DATAA d = {0};
HANDLE h = FindFirstFileA(file, &d);
if (h != INVALID_HANDLE_VALUE)
{
FindClose(h);
if (d.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
cdburn_addfolder(file, files, plManager, plCB);
}
if (plManager && PLAYLISTMANAGER_SUCCESS != plManager->Load(AutoWide(file), plCB))
{
files->push_back(new GayString(file));
}
}
else files->push_back(new GayString(file));
}
}
void cdburn_addfile(wchar_t* file, std::vector<GayStringW*> *files, api_playlistmanager* plManager, ifc_playlistloadercallback *plCB)
{
if (!_wcsicmp(extensionW(file), L"lnk"))
{
wchar_t temp2[MAX_PATH] = {0};
if (ResolveShortCut(plugin.hwndLibraryParent, file, temp2)) lstrcpyn(file, temp2, MAX_PATH);
else return;
}
if (!_wcsnicmp(file, L"cda://", 6))
{
if (wcslen(file) == 7)
{
int n = 0;
wchar_t buf2[32] = {0};
getFileInfoW(file, L"ntracks", buf2, sizeof(buf2));
n = _wtoi(buf2);
if (n > 0 && n < 256)
{
for (int x = 0; x < n; x ++)
{
wchar_t s[64] = {0};
StringCchPrintfW(s, 64, L"%s,%d.cda", file, x + 1);
files->push_back(new GayStringW(s));
}
}
}
else files->push_back(new GayStringW(file));
}
else if (wcsstr(file, L"://"))
{
if (plManager && PLAYLISTMANAGER_SUCCESS != plManager->Load(file, plCB))
{
files->push_back(new GayStringW(file));
}
}
else if (!lstrcmpW(file + 1, L":\\"))
{
cdburn_addfolder(file, files, plManager, plCB);
}
else
{
WIN32_FIND_DATAW d = {0};
HANDLE h = FindFirstFileW(file, &d);
if (h != INVALID_HANDLE_VALUE)
{
FindClose(h);
if (d.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
cdburn_addfolder(file, files, plManager, plCB);
}
if (plManager && PLAYLISTMANAGER_SUCCESS != plManager->Load(file, plCB))
{
files->push_back(new GayStringW(file));
}
}
else files->push_back(new GayStringW(file));
}
}
void cdburn_addfolder(const char* folder, std::vector<GayString*> *files, api_playlistmanager* plManager, ifc_playlistloadercallback *plCB)
{
WIN32_FIND_DATAA d = {0};
char path[MAX_PATH] = {0};
PathCombineA(path, folder, "*");
HANDLE h = FindFirstFileA(path, &d);
if (h == INVALID_HANDLE_VALUE) return;
do
{
if (d.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
if (0 == lstrcmpA(d.cFileName, ".") || 0 == lstrcmpA(d.cFileName, "..")) continue;
GayString pathNew(folder);
pathNew.Append("\\");
pathNew.Append(d.cFileName);
cdburn_addfolder(pathNew.Get(), files, plManager, plCB);
}
else
{
GayString file(folder);
file.Append("\\");
file.Append(d.cFileName);
cdburn_addfile(file.Get(), files, plManager, plCB);
}
}
while (FindNextFileA(h, &d));
FindClose(h);
}
void cdburn_addfolder(const wchar_t* folder, std::vector<GayStringW*> *files, api_playlistmanager* plManager, ifc_playlistloadercallback *plCB)
{
WIN32_FIND_DATAW d = {0};
wchar_t path[MAX_PATH] = {0};
PathCombineW(path, folder, L"*");
HANDLE h = FindFirstFileW(path, &d);
if (h == INVALID_HANDLE_VALUE) return;
do
{
if (d.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
if (0 == lstrcmpW(d.cFileName, L".") || 0 == lstrcmpW(d.cFileName, L"..")) continue;
GayStringW pathNew(folder);
pathNew.Append(L"\\");
pathNew.Append(d.cFileName);
cdburn_addfolder(pathNew.Get(), files, plManager, plCB);
}
else
{
GayStringW file(folder);
file.Append(L"\\");
file.Append(d.cFileName);
cdburn_addfile((wchar_t*)file.Get(), files, plManager, plCB);
}
}
while (FindNextFileW(h, &d));
FindClose(h);
}
void cdburn_appendItemRecord(itemRecordList *obj, char cLetter)
{
int idx = LETTERTOINDEX(cLetter);
int validFile = 1;
itemRecordListW newItems = {0, 0, 0};
BurnAddStatus_Create(obj->Size);
for (int i = 0;i < obj->Size;i++)
{
validFile = checkFile(obj->Items[i].filename);
if (validFile == -1)
break;
if (validFile)
{
if (newItems.Size > 255) break;
allocRecordList(&newItems, newItems.Size + 1);
if (!newItems.Alloc) return ;
memset((void *)&(newItems.Items[newItems.Size]), 0, sizeof(itemRecordW));
newItems.Items[newItems.Size].filename = AutoWideDup(obj->Items[i].filename);
GayString title;
if (obj->Items[i].artist) title.Append(obj->Items[i].artist);
if (title.Get() && title.Get()[0] && obj->Items[i].title && obj->Items[i].title[0])
title.Append(" - ");
if (obj->Items[i].title) title.Append(obj->Items[i].title);
newItems.Items[newItems.Size].title = AutoWideDup(title.Get());
newItems.Items[newItems.Size].length = obj->Items[i].length;
newItems.Size++;
BurnAddStatus_Step(&newItems);
}
}
BurnAddStatus_Done();
if (validFile != -1)
copyRecordList(&itemCache[idx], &newItems);
refreshList();
if (m_hwndstatus) SetStatus(m_hwndstatus, cLetter);
}
void cdburn_appendItemRecord(itemRecordListW *obj, char cLetter)
{
int idx = LETTERTOINDEX(cLetter);
int validFile = 1;
itemRecordListW newItems = {0, 0, 0};
BurnAddStatus_Create(obj->Size);
for (int i = 0;i < obj->Size;i++)
{
validFile = checkFile(obj->Items[i].filename);
if (validFile == -1)
break;
if (validFile)
{
if (newItems.Size > 255) break;
allocRecordList(&newItems, newItems.Size + 1);
if (!newItems.Alloc) return ;
memset((void *)&(newItems.Items[newItems.Size]), 0, sizeof(itemRecordW));
newItems.Items[newItems.Size].filename = _wcsdup(obj->Items[i].filename);
GayStringW title;
if (obj->Items[i].artist) title.Append(obj->Items[i].artist);
if (title.Get() && title.Get()[0] && obj->Items[i].title && obj->Items[i].title[0])
title.Append(L" - ");
if (obj->Items[i].title) title.Append(obj->Items[i].title);
newItems.Items[newItems.Size].title = _wcsdup(title.Get());
newItems.Items[newItems.Size].length = obj->Items[i].length;
newItems.Size++;
BurnAddStatus_Step(&newItems);
}
}
BurnAddStatus_Done();
if (validFile != -1)
copyRecordList(&itemCache[idx], &newItems);
refreshList();
if (m_hwndstatus) SetStatus(m_hwndstatus, cLetter);
}
static void Shell_Free(void *p)
{
IMalloc *m;
SHGetMalloc(&m);
m->Free(p);
}
HWND cdburn_FindBurningHWND(char cLetter)
{
HWND h = 0;
while (NULL != (h = FindWindowExW(NULL, h, L"#32770", NULL)))
{
if (!GetPropW(h, L"WABURNER")) continue;
if (((char)(INT_PTR)GetPropW(h, L"DRIVE")) == cLetter) return h;
}
return NULL;
}
CHAR cdburn_IsMeBurning(void)
{
if (pidBurner)
{
HWND h = NULL;
DWORD pid;
while (NULL != (h = FindWindowExW(NULL, h, L"#32770", NULL)))
{
if (GetPropW(h, L"WABURNER") && GetWindowThreadProcessId(h, &pid) && pid == pidBurner)
return (CHAR)(INT_PTR)GetPropW(h, L"DRIVE");
}
}
return 0;
}
static void NotifyInfoWindow(HWND hwnd, LPCWSTR pszFileName, BOOL bForceRefresh)
{
HWND hwndParent;
hwndParent = GetParent(hwnd);
if (hwndParent) SendMessageW(hwndParent, WM_SHOWFILEINFO,
(WPARAM)((bForceRefresh) ? WISF_FORCE : WISF_NORMAL),
(LPARAM)pszFileName);
}
static void moveSelItemsUp()
{
if (DM_MODE_BURNING == DriveManager_GetDriveMode(m_cdrom)) return;
int idx = LETTERTOINDEX(m_cdrom);
for (int i = 0;i < itemCache[idx].Size;i++)
{
if (m_statuslist.GetSelected(i))
{
//swap the 2 items
if (i > 0)
{
itemRecordW tmp = itemCache[idx].Items[i];
itemCache[idx].Items[i] = itemCache[idx].Items[i - 1];
itemCache[idx].Items[i - 1] = tmp;
ListView_SetItemState(m_statuslist.getwnd(), i - 1, LVIS_SELECTED, LVIS_SELECTED);
ListView_SetItemState(m_statuslist.getwnd(), i, 0, LVIS_SELECTED);
ListView_RedrawItems(m_statuslist.getwnd(), i - 1, i);
if (ListView_GetItemState(m_statuslist.getwnd(), i, LVIS_FOCUSED))
{
ListView_SetItemState(m_statuslist.getwnd(), i - 1, LVIS_FOCUSED, LVIS_FOCUSED);
}
}
}
}
}
static void moveSelItemsDown()
{
if (DM_MODE_BURNING == DriveManager_GetDriveMode(m_cdrom)) return ;
int idx = LETTERTOINDEX(m_cdrom);
for (int i = itemCache[idx].Size - 1;i >= 0;i--)
{
if (m_statuslist.GetSelected(i))
{
//swap the 2 items
if (i < (itemCache[idx].Size - 1))
{
itemRecordW tmp = itemCache[idx].Items[i];
itemCache[idx].Items[i] = itemCache[idx].Items[i + 1];
itemCache[idx].Items[i + 1] = tmp;
ListView_SetItemState(m_statuslist.getwnd(), i + 1, LVIS_SELECTED, LVIS_SELECTED);
ListView_SetItemState(m_statuslist.getwnd(), i, 0, LVIS_SELECTED);
ListView_RedrawItems(m_statuslist.getwnd(), i, i + 1);
if (ListView_GetItemState(m_statuslist.getwnd(), i, LVIS_FOCUSED))
{
ListView_SetItemState(m_statuslist.getwnd(), i + 1, LVIS_FOCUSED, LVIS_FOCUSED);
}
}
}
}
}
int g_burn_hack_startburn;
void OnBurnDlgInit(HWND hwndDlg, LPARAM lParam)
{
m_hwndstatus = hwndDlg;
m_is_cdrw = 0;
m_dragging = 0;
m_cdrom = (char)lParam;
SendMessageW(GetParent(hwndDlg), WM_COMMAND, MAKEWPARAM(IDC_BTN_SHOWINFO, BN_EX_GETTEXT), (LPARAM)GetDlgItem(hwndDlg, IDC_BTN_SHOWINFO));
m_statuslist.setwnd(GetDlgItem(hwndDlg, IDC_LIST2));
m_statuslist.AddCol(WASABI_API_LNGSTRINGW(IDS_TRACK_NUMBER), g_view_metaconf->ReadInt(L"col_track", 60));
m_statuslist.AddCol(WASABI_API_LNGSTRINGW(IDS_TITLE), g_view_metaconf->ReadInt(L"col_title", 200));
m_statuslist.AddCol(WASABI_API_LNGSTRINGW(IDS_LENGTH), g_view_metaconf->ReadInt(L"col_len", 80));
m_statuslist.AddCol(WASABI_API_LNGSTRINGW(IDS_STATUS), g_view_metaconf->ReadInt(L"col_status", 200));
childSizer.Init(hwndDlg, burnwnd_rlist, sizeof(burnwnd_rlist) / sizeof(burnwnd_rlist[0]));
if(m_statuslist.getwnd())
{
MLSKINWINDOW sw;
sw.hwndToSkin = m_statuslist.getwnd();
sw.skinType = SKINNEDWND_TYPE_LISTVIEW;
sw.style = SWLVS_FULLROWSELECT | SWLVS_DOUBLEBUFFER | SWLVS_ALTERNATEITEMS | SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS;
MLSkinWindow(plugin.hwndLibraryParent, &sw);
}
refreshList();
// this will make sure that we've got the cddb logo shown even when using a localised version
HANDLE hPrev = (HANDLE) SendDlgItemMessage(hwndDlg,IDC_LOGO,STM_SETIMAGE,IMAGE_BITMAP,
(LPARAM)LoadImage(plugin.hDllInstance,MAKEINTRESOURCE(IDB_LISTITEM_CDDRIVE),
IMAGE_BITMAP,0,0, 0));
if (hPrev) DeleteObject(hPrev);
NotifyInfoWindow(hwndDlg, NULL, TRUE); // ignore cache
SetStatus(hwndDlg, m_cdrom);
if (g_burn_hack_startburn)
{
g_burn_hack_startburn = 0;
PostMessage(hwndDlg, WM_COMMAND, IDC_BURN, 0);
}
}
void OnBurnNotify(HWND hwndDlg, DWORD notification, DWORD param)
{
switch (notification)
{
case BURN_READY:
SetStatus(hwndDlg, m_cdrom);
break;
case BURN_STATECHANGED:
{
wchar_t title[512] = {0};
const wchar_t *buf = NULL;
switch (param)
{
case BURNERPLAYLIST_BURNCANCELING:
SetDlgItemText(hwndDlg, IDC_CANCEL_BURN, WASABI_API_LNGSTRINGW(IDS_CANCELLING));
buf = WASABI_API_LNGSTRINGW_BUF(IDS_BURNING_AUDIO_CANCELLING,title,512);
break;
case BURNERPLAYLIST_BURNFINISHING:
buf = WASABI_API_LNGSTRINGW_BUF(IDS_BURNING_AUDIO_FINISHING,title,512);
break;
case BURNERPLAYLIST_DECODEFINISHED:
buf = WASABI_API_LNGSTRINGW_BUF(IDS_BURNING_AUDIO_DATA_PREP_FINISHED,title,512);
break;
case BURNERPLAYLIST_LICENSINGSTARTING:
buf = WASABI_API_LNGSTRINGW_BUF(IDS_BURNING_AUDIO_VERIFYING_FILES,title,512);
break;
case BURNERPLAYLIST_LICENSINGFINISHED:
buf = WASABI_API_LNGSTRINGW_BUF(IDS_BURNING_AUDIO_VERIFICATION_COMPLETED,title,512);
break;
case BURNERPLAYLIST_BURNPROGRESS:
wchar_t buf2[256] = {0};
switch (SendMessage(m_burning_other_wnd, WM_BURNGETSTATUS, BURNSTATUS_ERROR, 0))
{
case BURNERPLAYLIST_WRITELEADIN:
buf = WASABI_API_LNGSTRINGW_BUF(IDS_OPENING_DISC_WRITING_LEAD_IN,buf2,256);
break;
case BURNERPLAYLIST_WRITELEADOUT:
buf = WASABI_API_LNGSTRINGW_BUF(IDS_CLOSING_DISC_WRITING_LEAD_OUT,buf2,256);
break;
default: break;
}
if (buf)
{
int percent = (int)(INT_PTR)SendMessage(m_burning_other_wnd, WM_BURNGETSTATUS, BURNSTATUS_PROGRESS, 0);
percentCompleted = max(percent, percentCompleted);
StringCchPrintf(title, 512, WASABI_API_LNGSTRINGW(IDS_BURNING_AUDIO_CURRENT_OPERATION), percentCompleted, buf);
}
break;
}
if (buf) SetDlgItemText(hwndDlg, IDC_CDINFO, title);
}
break;
case BURN_ITEMSTATECHANGED:
ListView_RedrawItems(m_statuslist.getwnd(), param, param);
break;
case BURN_ITEMDECODEPROGRESS:
ListView_RedrawItems(m_statuslist.getwnd(), param, param);
{
wchar_t title[512] = {0};
int percent = (int)(INT_PTR)SendMessage(m_burning_other_wnd, WM_BURNGETSTATUS, BURNSTATUS_PROGRESS, 0);
percentCompleted = max(percent, percentCompleted);
StringCchPrintf(title, 512, WASABI_API_LNGSTRINGW(IDS_BURNING_AUDIO_CD_PREP_DATA), percentCompleted);
SetDlgItemText(hwndDlg, IDC_CDINFO, title);
}
break;
case BURN_ITEMBURNPROGRESS:
ListView_RedrawItems(m_statuslist.getwnd(), param, param);
{
wchar_t title[512] = {0};
int percent = (int)(INT_PTR)SendMessage(m_burning_other_wnd, WM_BURNGETSTATUS, BURNSTATUS_PROGRESS, 0);
percentCompleted = max(percent, percentCompleted);
StringCchPrintf(title, 512, WASABI_API_LNGSTRINGW(IDS_BURNING_AUDIO_BURNING_DATA), percentCompleted);
SetDlgItemText(hwndDlg, IDC_CDINFO, title);
}
break;
case BURN_WORKING:
ListView_RedrawItems(m_statuslist.getwnd(), 0, ListView_GetItemCount(m_statuslist.getwnd()));
break;
case BURN_FINISHED:
{
wchar_t buf1[128] = {0}, closeStr[16] = {0};
GetDlgItemText(hwndDlg, IDC_CANCEL_BURN, buf1, ARRAYSIZE(buf1));
if (lstrcmpi(buf1, WASABI_API_LNGSTRINGW_BUF(IDS_CLOSE,closeStr,16)))
SetDlgItemText(hwndDlg, IDC_CANCEL_BURN, closeStr);
wchar_t buf[128] = {0};
switch (param)
{
case BURNERPLAYLIST_SUCCESS:
WASABI_API_LNGSTRINGW_BUF(IDS_AUDIO_CD_BURNED_SUCCESSFULLY,buf,128);
break;
case BURNERPLAYLIST_ABORTED:
WASABI_API_LNGSTRINGW_BUF(IDS_BURN_ABORTED_BY_USER,buf,128);
break;
default:
WASABI_API_LNGSTRINGW_BUF(IDS_BURNING_FAILED,buf,128);
break;
}
StringCchPrintf(buf1, 128, WASABI_API_LNGSTRINGW(IDS_BURNING_COMPLETED_STATUS_X), buf);
SetDlgItemText(hwndDlg, IDC_CDINFO, buf1);
EnableWindow(GetDlgItem(hwndDlg, IDC_BURN), TRUE);
EnableWindow(GetDlgItem(hwndDlg, IDC_CANCEL_BURN), TRUE);
}
break;
case BURN_DESTROYED:
EnableWindow(GetDlgItem(hwndDlg, IDC_BURN), TRUE);
EnableWindow(GetDlgItem(hwndDlg, IDC_CANCEL_BURN), TRUE);
m_burning_other_wnd = NULL;
SetStatus(hwndDlg, m_cdrom);
break;
case BURN_CONFIGCHANGED:
switch (LOWORD(param))
{
case BURNCFG_AUTOCLOSE:
g_config->WriteInt(L"cdburnautoclose", HIWORD(param));
break;
case BURNCFG_AUTOEJECT:
g_config->WriteInt(L"cdburnautoeject", HIWORD(param));
break;
case BURNCFG_ADDTODB:
g_config->WriteInt(L"cdburnautoadddb", HIWORD(param));
break;
case BURNCFG_HIDEVIEW:
g_config->WriteInt(L"cdburnstatuswnd", !HIWORD(param));
break;
}
break;
}
}
static int CALLBACK WINAPI BrowseCallbackProc(HWND hwnd, UINT uMsg, LPARAM lParam, LPARAM lpData)
{
switch (uMsg)
{
case BFFM_INITIALIZED:
{
SendMessageW(hwnd, BFFM_SETSELECTIONW, 1, (LPARAM)WASABI_API_APP->path_getWorkingPath());
// this is not nice but it fixes the selection not working correctly on all OSes
EnumChildWindows(hwnd, browseEnumProc, 0);
}
}
return 0;
}
wchar_t* BuildFilterList(void)
{
static wchar_t fileExtensionsString[128] = {L"*.*"}; // "All files\0*.*\0\0"
wchar_t *temp=fileExtensionsString+lstrlenW(fileExtensionsString) +1;
lstrcpynW(temp, WASABI_API_LNGSTRINGW(IDS_ALL_FILES), 128);
*(temp = temp + lstrlenW(temp) + 1) = 0;
return fileExtensionsString;
}
static void CALLBACK Window_TimerProc(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
{
HWND hwndList;
int index, driveIdx;
wchar_t *pszFileName;
switch(idEvent)
{
case TIMER_NOTIFYINFO_ID:
KillTimer(hwnd, TIMER_NOTIFYINFO_ID);
hwndList = GetDlgItem(hwnd, IDC_LIST2);
driveIdx = LETTERTOINDEX(m_cdrom);
index = (hwndList) ? (INT)SendMessage(hwndList, LVM_GETNEXTITEM, (WPARAM)-1, (LPARAM)LVNI_FOCUSED) : -1;
pszFileName = (index >= 0 && index < itemCache[driveIdx].Size) ? itemCache[driveIdx].Items[index].filename : NULL;
NotifyInfoWindow(hwnd, pszFileName, FALSE);
break;
}
}
static void ListView_OnItemChanged(HWND hwndDlg, NMLISTVIEW *pnmv)
{
if (LVIF_STATE & pnmv->uChanged)
{
if ((LVIS_FOCUSED & pnmv->uOldState) != (LVIS_FOCUSED & pnmv->uNewState))
{
KillTimer(hwndDlg, TIMER_NOTIFYINFO_ID);
SetTimer(hwndDlg, TIMER_NOTIFYINFO_ID, TIMER_NOTIFYINFO_DELAY, Window_TimerProc);
}
}
}
static void Window_OnQueryInfo(HWND hwnd)
{
KillTimer(hwnd, TIMER_NOTIFYINFO_ID);
NotifyInfoWindow(hwnd, NULL, TRUE);
SetTimer(hwnd, TIMER_NOTIFYINFO_ID, TIMER_NOTIFYINFO_DELAY, Window_TimerProc);
}
static void Window_OnOperationCompleted(HWND hwnd, DM_NOTIFY_PARAM *phdr)
{
MEDIAINFO mediaInfo;
if (phdr->cLetter != m_cdrom) return;
ZeroMemory(&mediaInfo, sizeof(MEDIAINFO));
mediaInfo.cLetter = m_cdrom;
switch(phdr->opCode)
{
case DMOP_IMAPIINFO:
if (S_OK == phdr->result)
{
DM_IMAPI_PARAM *pIMAPI = (DM_IMAPI_PARAM*)phdr;
if ((0 != pIMAPI->fMediaType && 0 != pIMAPI->fMediaFlags))
{
mediaInfo.bInserted = TRUE;
if (MEDIA_WRITABLE & pIMAPI->fMediaFlags) mediaInfo.bRecordable = TRUE;
if (MEDIA_RW & pIMAPI->fMediaFlags) mediaInfo.bRewritable = TRUE;
if (MEDIA_BLANK & pIMAPI->fMediaFlags) mediaInfo.bBlank = TRUE;
mediaInfo.nSectorsFree = pIMAPI->ulFreeBlocks;
mediaInfo.nSectorsUsed = pIMAPI->ulNextWritable;
}
}
else GetMediaInfoFromSonic(&mediaInfo);
FinishSetStatus(hwnd, &mediaInfo);
return;
}
}
static INT_PTR CALLBACK DlgProc(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_SIZE:
if (wParam != SIZE_MINIMIZED)
{
childSizer.Resize(hwndDlg, burnwnd_rlist, sizeof(burnwnd_rlist) / sizeof(burnwnd_rlist[0]));
}
break;
case WM_BURNNOTIFY:
OnBurnNotify(hwndDlg, (DWORD)wParam, (DWORD)lParam);
PostMessage(prevWnd, uMsg, wParam, lParam);
break;
case WM_INITDIALOG: OnBurnDlgInit(hwndDlg, lParam); return 0;
case WM_COMMAND:
switch (LOWORD(wParam))
{
// link is dead so disabling for the time being
/*case IDC_LOGO:
if (HIWORD(wParam) == BN_CLICKED)
ShellExecute(hwndDlg, L"open", L"http://estore.sonic.com/redirect.asp?id=spaol110103", NULL, L".", 0);
break;*/
case IDC_BURN_OPTS:
{
RECT r;
HMENU menu = GetSubMenu(g_context_menus, 6);
GetWindowRect((HWND)lParam, &r);
CheckMenuItem(menu, ID_RIPOPTIONS_RIPPINGSTATUSWINDOW, g_config->ReadInt(L"cdburnstatuswnd", 0) ? MF_CHECKED : MF_UNCHECKED);
CheckMenuItem(menu, ID_RIPOPTIONS_EJECTCDWHENCOMPLETED, g_config->ReadInt(L"cdburnautoeject", 1) ? MF_CHECKED : MF_UNCHECKED);
CheckMenuItem(menu, ID_BURNOPTIONS_ADDCDTITLESTOLOCALCDDBCACHE, g_config->ReadInt(L"cdburnautoadddb", 1) ? MF_CHECKED : MF_UNCHECKED);
CheckMenuItem(menu, ID_RIPOPTIONS_CLOSEVIEWWHENCOMPLETE, g_config->ReadInt(L"cdburnautoclose", 0) ? MF_CHECKED : MF_UNCHECKED);
int x = Menu_TrackPopup(plugin.hwndLibraryParent, menu,
TPM_RIGHTBUTTON | TPM_LEFTBUTTON | TPM_BOTTOMALIGN |
TPM_LEFTALIGN | TPM_NONOTIFY | TPM_RETURNCMD,
r.left, r.top, hwndDlg, NULL);
int val = 0, msgid;
switch (x)
{
case ID_RIPOPTIONS_RIPPINGSTATUSWINDOW:
val = g_config->ReadInt(L"cdburnstatuswnd", 0);
g_config->WriteInt(L"cdburnstatuswnd", !val);
msgid = BURNCFG_HIDEVIEW;
break;
case ID_RIPOPTIONS_EJECTCDWHENCOMPLETED:
val = !g_config->ReadInt(L"cdburnautoeject", 1);
g_config->WriteInt(L"cdburnautoeject", val);
msgid = BURNCFG_AUTOEJECT;
break;
case ID_BURNOPTIONS_ADDCDTITLESTOLOCALCDDBCACHE:
val = !g_config->ReadInt(L"cdburnautoadddb", 0);
g_config->WriteInt(L"cdburnautoadddb", val);
msgid = BURNCFG_ADDTODB;
break;
case ID_RIPOPTIONS_CLOSEVIEWWHENCOMPLETE:
val = !g_config->ReadInt(L"cdburnautoclose", 0);
g_config->WriteInt(L"cdburnautoclose", val);
msgid = BURNCFG_AUTOCLOSE;
break;
default: msgid = 0; break;
}
if (msgid)
{
HWND h;
h = cdburn_FindBurningHWND(m_cdrom);
if (h)
{
PostMessage(h, WM_BURNCONFIGCHANGED, msgid, val);
if (BURNCFG_HIDEVIEW == msgid) ShowWindow(h, val ? SW_HIDE : SW_SHOW);
}
}
Sleep(100);
MSG msg;
while (PeekMessage(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE)); //eat return
}
return 0;
case IDC_ADD:
if (DM_MODE_BURNING != DriveManager_GetDriveMode(m_cdrom))
{
RECT r;
GetWindowRect((HWND)lParam, &r);
int x = Menu_TrackPopup(plugin.hwndLibraryParent, GetSubMenu(g_context_menus, 3),
TPM_RIGHTBUTTON | TPM_LEFTBUTTON | TPM_BOTTOMALIGN |
TPM_LEFTALIGN | TPM_NONOTIFY | TPM_RETURNCMD,
r.left, r.top, hwndDlg, NULL);
switch (x)
{
case ID_BURNADDMENU_FILES:
{
OPENFILENAMEW l = {sizeof(l), };
wchar_t *temp;
const int len = 256 * 1024 - 128;
wchar_t *m_extlist = 0;
m_extlist = (wchar_t*)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 1, IPC_GET_EXTLISTW);
if ((int)(INT_PTR)m_extlist == 1) m_extlist = 0;
temp = (wchar_t *)GlobalAlloc(GPTR, len);
l.hwndOwner = hwndDlg;
l.lpstrFilter = m_extlist ? m_extlist : BuildFilterList();
l.lpstrFile = temp;
l.nMaxFile = len - 1;
l.lpstrTitle = WASABI_API_LNGSTRINGW(IDS_ADD_FILES_TO_BURNING_LIST);
l.lpstrDefExt = L"";
l.lpstrInitialDir = WASABI_API_APP->path_getWorkingPath();
l.Flags = OFN_HIDEREADONLY | OFN_EXPLORER | OFN_ALLOWMULTISELECT;
if (GetOpenFileNameW(&l))
{
wchar_t newCurPath[MAX_PATH] = {0};
GetCurrentDirectoryW(MAX_PATH, newCurPath);
WASABI_API_APP->path_setWorkingPath(newCurPath);
if (temp[wcslen(temp) + 1])
{
wchar_t buf[MAX_PATH] = {0};
wchar_t *p = temp;
wchar_t *path = p;
p += wcslen(p) + 1;
while (p && *p)
{
if (*path)
StringCchPrintfW(buf, MAX_PATH, L"%s%s%s", path, path[wcslen(path) - 1] == '\\' ? L"" : L"\\" , p);
else
StringCchPrintfW(buf, MAX_PATH, L"%s", p);
cdburn_appendFile(buf, m_cdrom);
p += wcslen(p) + 1;
}
}
else
cdburn_appendFile(temp, m_cdrom);
}
GlobalFree(temp);
if (m_extlist) GlobalFree((HGLOBAL)m_extlist);
SetStatus(hwndDlg, m_cdrom);
}
break;
case ID_BURNADDMENU_FOLDER:
{
BROWSEINFOW bi = {0};
wchar_t name[MAX_PATH] = {0};
bi.hwndOwner = hwndDlg;
bi.pszDisplayName = name;
bi.lpszTitle = WASABI_API_LNGSTRINGW(IDS_CHOOSE_A_FOLDER_TO_ADD_TO_BURNING_LIST);
bi.ulFlags = BIF_RETURNONLYFSDIRS | BIF_NEWDIALOGSTYLE;
bi.lpfn = BrowseCallbackProc;
ITEMIDLIST *idlist = SHBrowseForFolderW(&bi);
if (idlist)
{
wchar_t path[MAX_PATH] = {0};
SHGetPathFromIDListW(idlist, path);
Shell_Free(idlist);
cdburn_appendFile(path, m_cdrom);
SetStatus(hwndDlg, m_cdrom);
}
}
break;
case ID_BURNADDMENU_CURRENTPLAYLIST:
{
int plsize = (int)(INT_PTR)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GETLISTLENGTH);
for (int i = 0;i < plsize;i++)
{
wchar_t *name = (wchar_t *)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, i, IPC_GETPLAYLISTFILEW);
cdburn_appendFile(name, m_cdrom);
}
SetStatus(hwndDlg, m_cdrom);
}
break;
}
Sleep(100);
MSG msg;
while (PeekMessage(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE)); //eat return
}
break;
case IDC_CLEAR:
if (DM_MODE_BURNING != DriveManager_GetDriveMode(m_cdrom))
{
wchar_t title[32] = {0};
if (MessageBox(hwndDlg, WASABI_API_LNGSTRINGW(IDS_SURE_YOU_WANT_TO_CLEAR_BURNING_LIST),
WASABI_API_LNGSTRINGW_BUF(IDS_CONFIRMATION,title,32), MB_YESNO) != IDYES)
break;
emptyRecordList(&itemCache[LETTERTOINDEX(m_cdrom)]);
SetStatus(hwndDlg, m_cdrom);
refreshList();
}
break;
case IDC_CANCEL_BURN:
case IDC_BURN:
{
HWND h;
if (NULL != (h = cdburn_FindBurningHWND(m_cdrom)))
{
PostMessage(h, WM_COMMAND, MAKEWPARAM(IDCANCEL, BN_CLICKED), 0);
EnableWindow(GetDlgItem(hwndDlg, IDC_BURN), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_CANCEL_BURN), FALSE);
}
else doBurnDialog(hwndDlg);
}
break;
case IDC_BTN_SHOWINFO:
switch(HIWORD(wParam))
{
case BN_CLICKED: SendMessageW(GetParent(hwndDlg), WM_COMMAND, wParam, lParam); break;
}
break;
}
break;
case WM_CONTEXTMENU:
{
if (DM_MODE_BURNING == DriveManager_GetDriveMode(m_cdrom) || m_statuslist.GetCount() == 0) return 0;
HMENU menu = GetSubMenu(g_context_menus, 4);
POINT pt = {GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
if (pt.x == -1 || pt.y == -1) // x and y are -1 if the user invoked a shift-f10 popup menu
{
RECT itemRect = {0};
int selected = m_statuslist.GetNextSelected();
if (selected != -1) // if something is selected we'll drop the menu from there
{
m_statuslist.GetItemRect(selected, &itemRect);
ClientToScreen(m_statuslist.getwnd(), (POINT *)&itemRect);
}
else // otherwise we'll drop it from the top-left corner of the listview, adjusting for the header location
{
GetWindowRect(m_statuslist.getwnd(), &itemRect);
HWND hHeader = (HWND)SNDMSG((HWND)wParam, LVM_GETHEADER, 0, 0L);
RECT headerRect;
if ((WS_VISIBLE & GetWindowLongPtr(hHeader, GWL_STYLE)) && GetWindowRect(hHeader, &headerRect))
{
itemRect.top += (headerRect.bottom - headerRect.top);
}
}
pt.x = itemRect.left;
pt.y = itemRect.top;
}
HWND hHeader = (HWND)SNDMSG((HWND)wParam, 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 0;
}
int r = Menu_TrackPopup(plugin.hwndLibraryParent, menu,
TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTBUTTON | TPM_NONOTIFY,
pt.x, pt.y, hwndDlg, NULL);
switch (r)
{
case ID_BURNCONTEXTMENU_PLAYSELECTEDITEMS:
playSelectedItems(hwndDlg, 0);
break;
case ID_BURNCONTEXTMENU_ENQUEUESELECTEDITEMS:
playSelectedItems(hwndDlg, 1);
break;
case ID_BURNCONTEXTMENU_SELECTALL:
selectAll();
break;
case ID_BURNCONTEXTMENU_REMOVESELECTEDITEMS:
if (DM_MODE_BURNING != DriveManager_GetDriveMode(m_cdrom)) deleteSelectedItems(hwndDlg, m_cdrom);
break;
case ID_BURNCONTEXTMENU_BURN:
doBurnDialog(hwndDlg);
break;
case ID_BURNCONTEXTMENU_MOVESELECTEDITEMSUP:
moveSelItemsUp();
break;
case ID_BURNCONTEXTMENU_MOVESELECTEDITEMSDOWN:
moveSelItemsDown();
break;
}
Sleep(100);
MSG msg;
while (PeekMessage(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE)); //eat return
return 1;
}
case WM_NOTIFY:
{
LPNMHDR l = (LPNMHDR)lParam;
if (l->idFrom == IDC_LIST2)
{
if (l->code == LVN_KEYDOWN)
{
LPNMLVKEYDOWN pnkd = (LPNMLVKEYDOWN) lParam;
switch (pnkd->wVKey)
{
case 38: //up
if (GetAsyncKeyState(VK_LMENU))
{
moveSelItemsUp();
return 1;
}
break;
case 40: //down
if (GetAsyncKeyState(VK_LMENU))
{
moveSelItemsDown();
return 1;
}
break;
case 46: //delete
if (DM_MODE_BURNING != DriveManager_GetDriveMode(m_cdrom)) deleteSelectedItems(hwndDlg, m_cdrom);
break;
case 'A':
if (GetAsyncKeyState(VK_CONTROL))
selectAll();
break;
}
}
else if (l->code == NM_DBLCLK)
{
if (DM_MODE_BURNING == DriveManager_GetDriveMode(m_cdrom)) return 0;
playSelectedItems(hwndDlg, (!!g_config->ReadInt(L"enqueuedef", 0)) ^(!!(GetAsyncKeyState(VK_SHIFT)&0x8000)));
}
else if (l->code == NM_RETURN)
{
if (DM_MODE_BURNING == DriveManager_GetDriveMode(m_cdrom)) return 0;
playSelectedItems(hwndDlg, 0 ^(!!(GetAsyncKeyState(VK_SHIFT)&0x8000)));
}
else if (l->code == LVN_GETDISPINFO)
{
NMLVDISPINFO *lpdi = (NMLVDISPINFO*) lParam;
int item = lpdi->item.iItem;
int idx = LETTERTOINDEX(m_cdrom);
if (item < 0 || item >= itemCache[idx].Size) return 0;
itemRecordW *thisitem = itemCache[idx].Items + item;
if (lpdi->item.mask & (LVIF_TEXT | /*LVIF_IMAGE*/0)) // we can always do images too :)
{
if (lpdi->item.mask & LVIF_TEXT)
{
wchar_t tmpbuf[128] = {0};
wchar_t *nameptr = 0;
switch (lpdi->item.iSubItem)
{
case 0:
//track #
StringCchPrintfW(tmpbuf, 128, L"%d", item + 1);
nameptr = tmpbuf;
break;
case 1:
//title
lstrcpynW(tmpbuf, thisitem->title, 128);
nameptr = tmpbuf;
break;
case 2:
//length
StringCchPrintfW(tmpbuf, 128, L"%01d:%02d", thisitem->length / 60, thisitem->length % 60);
nameptr = tmpbuf;
break;
case 3:
DWORD state = (DWORD) SendMessage(m_burning_other_wnd, WM_BURNGETITEMSTATUS, BURNSTATUS_STATE, (LPARAM)item);
switch (state)
{
case BURNERITEM_BURNING:
case BURNERITEM_DECODING:
StringCchPrintfW(tmpbuf, 128, L"%s (%d%%)",
WASABI_API_LNGSTRINGW((BURNERITEM_BURNING == state) ? IDS_BURNING_ : IDS_PREPARING),
(DWORD)SendMessage(m_burning_other_wnd, WM_BURNGETITEMSTATUS, BURNSTATUS_PROGRESS, (LPARAM)item));
nameptr = tmpbuf;
break;
case BURNERITEM_SUCCESS: break;
case BURNERITEM_BURNED:
nameptr = WASABI_API_LNGSTRINGW_BUF(IDS_FINISHED,tmpbuf,128);
break;
case BURNERITEM_DECODED:
nameptr = WASABI_API_LNGSTRINGW_BUF(IDS_PREPARED,tmpbuf,128);
break;
case BURNERITEM_SKIPPED:
nameptr = WASABI_API_LNGSTRINGW_BUF(IDS_SKIPPED,tmpbuf,128);
break;
case BURNERITEM_READY:
nameptr = WASABI_API_LNGSTRINGW_BUF(IDS_SCHEDULED,tmpbuf,128);
break;
case BURNERITEM_LICENSING:
nameptr = WASABI_API_LNGSTRINGW_BUF(IDS_CHECKING_LICENSE,tmpbuf,128);
break;
case BURNERITEM_LICENSED:
nameptr = WASABI_API_LNGSTRINGW_BUF(IDS_LICENSED,tmpbuf,128);
break;
case BURNERITEM_ABORTED:
nameptr = WASABI_API_LNGSTRINGW_BUF(IDS_CANCELLED,tmpbuf,128);
break;
case BURNERITEM_FAILED:
nameptr = WASABI_API_LNGSTRINGW_BUF(IDS_FAILED,tmpbuf,128);
break;
case BURNERITEM_CANCELING:
nameptr = WASABI_API_LNGSTRINGW_BUF(IDS_CANCELLING,tmpbuf,128);
break;
case BURNERITEM_BADFILENAME:
nameptr = WASABI_API_LNGSTRINGW_BUF(IDS_BAD_FILENAME,tmpbuf,128);
break;
case BURNERITEM_UNABLEOPENFILE:
nameptr = WASABI_API_LNGSTRINGW_BUF(IDS_UNABLE_TO_OPEN_FILE,tmpbuf,128);
break;
case BURNERITEM_WRITEERROR:
nameptr = WASABI_API_LNGSTRINGW_BUF(IDS_CACHE_WRITE_FAILED,tmpbuf,128);
break;
case BURNERITEM_DECODEERROR:
nameptr = WASABI_API_LNGSTRINGW_BUF(IDS_UNABLE_TO_FIND_DECODER,tmpbuf,128);
break;
case BURNERITEM_ADDSTREAMFAILED:
nameptr = WASABI_API_LNGSTRINGW_BUF(IDS_CANNOT_ADD_TO_THE_DISC,tmpbuf,128);
break;
case BURNERITEM_READSTREAMERROR:
nameptr = WASABI_API_LNGSTRINGW_BUF(IDS_CACHE_READ_FAILED,tmpbuf,128);
break;
default:
nameptr = WASABI_API_LNGSTRINGW_BUF(IDS_UNKNOWN_ERROR,tmpbuf,128);
break;
}
//status
break;
}
if (nameptr)
lstrcpynW(lpdi->item.pszText, nameptr, lpdi->item.cchTextMax);
else
lpdi->item.pszText[0] = 0;
}
}
return 0;
}
else if (l->code == LVN_BEGINDRAG)
{
SetCapture(hwndDlg);
m_dragging = 1;
LPNMLISTVIEW nlv = (LPNMLISTVIEW)lParam;
m_drag_item = nlv->iItem;
}
else if (l->code == LVN_ITEMCHANGED) ListView_OnItemChanged(hwndDlg, (NMLISTVIEW*)l);
}
}
break;
case WM_MOUSEMOVE:
if (m_dragging)
{
POINT p;
p.x = GET_X_LPARAM(lParam);
p.y = GET_Y_LPARAM(lParam);
ClientToScreen(hwndDlg, &p);
ScreenToClient(m_statuslist.getwnd(), &p);
int i = m_statuslist.FindItemByPoint(p.x, p.y);
if (i != -1 && i != m_drag_item)
{
if (i > m_drag_item)
{
for (int j = 0;j < (i - m_drag_item);j++)
moveSelItemsDown();
}
else
{
for (int j = 0;j < (m_drag_item - i);j++)
moveSelItemsUp();
}
m_drag_item = i;
}
}
break;
case WM_LBUTTONUP:
if (GetCapture() == hwndDlg)
{
ReleaseCapture();
m_dragging = 0;
}
break;
case WM_DESTROY:
if (m_statuslist.getwnd())
{
g_view_metaconf->WriteInt(L"col_track", m_statuslist.GetColumnWidth(0));
g_view_metaconf->WriteInt(L"col_title", m_statuslist.GetColumnWidth(1));
g_view_metaconf->WriteInt(L"col_len", m_statuslist.GetColumnWidth(2));
g_view_metaconf->WriteInt(L"col_status", m_statuslist.GetColumnWidth(3));
}
if (m_burning_other_wnd && IsWindow(m_burning_other_wnd))
{
PostMessage(m_burning_other_wnd, WM_BURNUPDATEOWNER, 0, (LPARAM)prevWnd);
prevWnd = NULL;
}
m_hwndstatus = 0;
if (hPLFont)
{
DeleteObject(hPLFont);
hPLFont = NULL;
}
{
HANDLE hPrev = (HANDLE) SendDlgItemMessage(hwndDlg,IDC_LOGO,STM_SETIMAGE,IMAGE_BITMAP, 0L);
if (hPrev) DeleteObject(hPrev);
}
return 0;
case WM_ML_CHILDIPC:
if (lParam == ML_CHILDIPC_DROPITEM && wParam)
{
mlDropItemStruct *dis = (mlDropItemStruct *)wParam;
if (DM_MODE_BURNING == DriveManager_GetDriveMode(m_cdrom))
{
dis->result = -1;
return 0;
}
if (dis->type != ML_TYPE_ITEMRECORDLISTW && dis->type != ML_TYPE_ITEMRECORDLIST &&
dis->type != ML_TYPE_FILENAMES && dis->type != ML_TYPE_FILENAMESW)
{
dis->result = -1;
}
else
{
if (dis->data)
{
dis->result = 1;
if (dis->type == ML_TYPE_ITEMRECORDLIST)
{
itemRecordList *obj = (itemRecordList *)dis->data;
cdburn_appendItemRecord(obj, m_cdrom);
}
else if (dis->type == ML_TYPE_ITEMRECORDLISTW)
{
itemRecordListW *obj = (itemRecordListW *)dis->data;
cdburn_appendItemRecord(obj, m_cdrom);
}
else if (dis->type == ML_TYPE_FILENAMES) // playlist
{
char *p = (char*)dis->data;
while (p && *p)
{
cdburn_appendFile(p, m_cdrom);
p += strlen(p) + 1;
}
}
else if (dis->type == ML_TYPE_FILENAMESW)
{
wchar_t *p = (wchar_t*)dis->data;
while (p && *p)
{
cdburn_appendFile(p, m_cdrom);
p += wcslen(p) + 1;
}
}
}
}
}
return 0;
case WM_DROPFILES:
{
char temp[2048] = {0};
HDROP h = (HDROP) wParam;
int y = DragQueryFileA(h, 0xffffffff, temp, sizeof(temp));
if (DM_MODE_BURNING == DriveManager_GetDriveMode(m_cdrom))
{
// MessageBoxA(hwndDlg,"Cannot add files while burning","CD Burner",MB_OK);
}
else for (int x = 0; x < y; x ++)
{
DragQueryFileA(h, x, temp, sizeof(temp));
cdburn_appendFile(temp, m_cdrom);
}
DragFinish(h);
}
return 0;
case WM_PAINT:
{
int tab[] = { IDC_LIST2 | DCW_SUNKENBORDER, IDC_LOGO | DCW_SUNKENBORDER};
dialogSkinner.Draw(hwndDlg, tab, 2);
}
return 0;
case WM_ERASEBKGND: return 1; //handled by WADlg_DrawChildWindowBorders in WM_PAINT
case WM_QUERYFILEINFO: Window_OnQueryInfo(hwndDlg); break;
case WM_EX_OPCOMPLETED: Window_OnOperationCompleted(hwndDlg, (DM_NOTIFY_PARAM*)lParam);
}
return FALSE;
}
static HWND BurnAddStatus_wnd;
static BOOL CALLBACK BurnAddStatus_proc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if (uMsg == WM_CLOSE)
DestroyWindow(hwndDlg);
return 0;
}
void BurnAddStatus_Create(int num)
{
if (BurnAddStatus_wnd && IsWindow(BurnAddStatus_wnd)) DestroyWindow(BurnAddStatus_wnd);
BurnAddStatus_wnd = WASABI_API_CREATEDIALOGW(IDD_BURN_ADD_STATUS, plugin.hwndLibraryParent, BurnAddStatus_proc);
if (!BurnAddStatus_wnd) return ;
SetTimer(BurnAddStatus_wnd, 1, 100, NULL);
SendDlgItemMessage(BurnAddStatus_wnd, IDC_PROGRESS1, PBM_SETRANGE, 0, MAKELPARAM(0, num));
unsigned int start_t = GetTickCount();
if (start_t >= 0xffffff00) start_t = 0;
MSG msg;
while (GetTickCount() < start_t + 100 && GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
void BurnAddStatus_Step(itemRecordListW *items)
{
if (!BurnAddStatus_wnd || !items || items && !items->Size || items && !items->Items) return ;
SendDlgItemMessage(BurnAddStatus_wnd, IDC_PROGRESS1, PBM_DELTAPOS, 1, 0);
int l = 0;
for (int i = 0;i < items->Size;i++)
{
l += items->Items[i].length;
}
wchar_t buf[512] = {0};
StringCchPrintf(buf, 512, WASABI_API_LNGSTRINGW(IDS_ADDING_TRACKS_TO_BURNER_TOTAL_LENGTH_X), l / 60, l % 60);
SetDlgItemText(BurnAddStatus_wnd, IDC_STAT, buf);
}
void BurnAddStatus_Done()
{
if (!BurnAddStatus_wnd) return ;
unsigned int start_t = GetTickCount();
if (start_t >= 0xffffff00) start_t = 0;
MSG msg;
while (GetTickCount() < start_t + 1000 && IsWindow(BurnAddStatus_wnd) && GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
DestroyWindow(BurnAddStatus_wnd);
BurnAddStatus_wnd = 0;
}
static bool cdrFound(char letter)
{
wchar_t name[]= L"cda://X.cda";
wchar_t info[16] = L"";
name[6] = letter;
getFileInfoW(name, L"cdtype", info, sizeof(info)/sizeof(wchar_t));
return !lstrcmpW(info, L"CDR") || !lstrcmpW(info, L"CDRW");
}
static char m_burnwait_letter;
static BOOL CALLBACK BurnWaitProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
case WM_INITDIALOG:
SetTimer(hwndDlg, 1, 2000, NULL);
{
wchar_t buf[512] = {0};
StringCchPrintf(buf, 512, WASABI_API_LNGSTRINGW(IDS_PLEASE_INSERT_BLANK_RECORDABLE_CD), toupper(m_burnwait_letter));
SetDlgItemText(hwndDlg, IDC_TEXT, buf);
}
return 0;
case WM_COMMAND:
if (LOWORD(wParam) == IDCANCEL) EndDialog(hwndDlg, 1);
return 0;
case WM_TIMER:
if (cdrFound(m_burnwait_letter)) EndDialog(hwndDlg, 0);
return 0;
}
return 0;
}
int Burn_WaitForCDR(HWND hwndParent, char driveletter) // returns 0 on CD-R found, 1 on cancel
{
CHAR cMode;
if (!driveletter) return 1;
cMode = DriveManager_GetDriveMode(driveletter);
if (DM_MODE_BURNING == cMode || DM_MODE_RIPPING == cMode)
{
return 1; // if burning or ripping, don't fuck with it
}
if (cdrFound(driveletter)) return 0;
if (m_burnwait_letter) return 1;
m_burnwait_letter = (char)toupper(driveletter);
int x = (int)(INT_PTR)WASABI_API_DIALOGBOXW(IDD_WAITFORCDR, hwndParent, BurnWaitProc);
m_burnwait_letter = 0;
return x;
}
Reference in a new issue Copy permalink