diff options
Diffstat (limited to 'Src/Plugins/Library/ml_disc/cdburn.cpp')
| -rw-r--r-- | Src/Plugins/Library/ml_disc/cdburn.cpp | 2155 |
1 files changed, 2155 insertions, 0 deletions
diff --git a/Src/Plugins/Library/ml_disc/cdburn.cpp b/Src/Plugins/Library/ml_disc/cdburn.cpp new file mode 100644 index 00000000..6f05d06a --- /dev/null +++ b/Src/Plugins/Library/ml_disc/cdburn.cpp @@ -0,0 +1,2155 @@ +#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; +} |