1273 lines
36 KiB
C++
1273 lines
36 KiB
C++
#include "Main.h"
|
|
#include "ReplayGain.h"
|
|
#include "../nu/AutoChar.h"
|
|
#include "../nu/MediaLibraryInterface.h"
|
|
#include "./resource.h"
|
|
#include "./settings.h"
|
|
#include "./copyfiles.h"
|
|
#include "../winamp/wa_ipc.h"
|
|
//#include <primosdk.h>
|
|
#include <shlwapi.h>
|
|
#include <imapi.h>
|
|
#include <imapierror.h>
|
|
#include "../nu/ns_wc.h"
|
|
#include <vector>
|
|
#include <strsafe.h>
|
|
|
|
#define VERSION_MAJOR 2
|
|
#define VERSION_MINOR 0
|
|
|
|
#ifndef ARRAYSIZE
|
|
#define ARRAYSIZE(x) (sizeof(x)/sizeof(*x))
|
|
#endif
|
|
|
|
typedef struct _LISTENER
|
|
{
|
|
HWND hwnd;
|
|
UINT uMsg;
|
|
CHAR cLetter;
|
|
} LISTENER;
|
|
|
|
typedef struct _NAVITEMENUMPARAM
|
|
{
|
|
NAVITEMENUMPROC callback;
|
|
LPARAM param;
|
|
} NAVITEMENUMPARAM;
|
|
|
|
typedef enum _BTNSTATE
|
|
{
|
|
BTNSTATE_NORMAL = 0,
|
|
BTNSTATE_HILITED = 1,
|
|
BTNSTATE_PRESSED = 2,
|
|
BTNSTATE_DISABLED = 3,
|
|
} BTNSTATE;
|
|
|
|
#define ICON_SIZE_CX 14
|
|
#define ICON_SIZE_CY 14
|
|
|
|
#define NAVBUTTON_STATECHECK_DELAY 100
|
|
static int Init();
|
|
static void Quit();
|
|
|
|
HNAVITEM hniMain = NULL;
|
|
static LRESULT delay_ml_startup;
|
|
static HMLIMGLST hmlilIcons = NULL;
|
|
LARGE_INTEGER freq;
|
|
|
|
#define NAVITEM_PREFIX L"_ml_disc_"
|
|
#define NAVITEM_PREFIX_SIZE (sizeof(NAVITEM_PREFIX)/sizeof(wchar_t))
|
|
|
|
#define NCS_EX_SHOWEJECT 0x0100
|
|
|
|
C_Config *g_config, *g_view_metaconf = NULL;
|
|
HMENU g_context_menus;
|
|
|
|
prefsDlgRecW myPrefsItemCD = {0};
|
|
INT_PTR imgIndex = 0;
|
|
wchar_t randb[64] = {0};
|
|
static wchar_t cdrip[64];
|
|
|
|
static DWORD g_navStyle = NCS_FULLROWSELECT | NCS_SHOWICONS;
|
|
static DWORD riphash = 0;
|
|
|
|
static std::vector<LPARAM> driveList;
|
|
|
|
static LISTENER activeListener = { NULL, 0, };
|
|
static WNDPROC oldWinampWndProc = NULL;
|
|
|
|
api_application *WASABI_API_APP = 0;
|
|
api_stats *AGAVE_API_STATS = 0;
|
|
|
|
// wasabi based services for localisation support
|
|
api_language *WASABI_API_LNG = 0;
|
|
HINSTANCE WASABI_API_LNG_HINST = 0, WASABI_API_ORIG_HINST = 0;
|
|
|
|
static UINT uMsgBurnerNotify = 0;
|
|
static UINT uMsgRipperNotify = 0;
|
|
static UINT uMsgNavStyleUpdate = 0;
|
|
static UINT uMsgCopyNotify = 0;
|
|
|
|
static void CALLBACK Invoke_OnDriveManagerNotify(WORD wCode, INT_PTR param);
|
|
static void Plugin_OnMLVisible(BOOL bVisible);
|
|
void ShowHideRipBurnParent(void);
|
|
|
|
|
|
|
|
static void DriveParam_RegisterDrive(DRIVE *drive)
|
|
{
|
|
LPARAM param;
|
|
size_t index;
|
|
|
|
param = (LPARAM)drive;
|
|
if (NULL == param)
|
|
return;
|
|
|
|
index = driveList.size();
|
|
while(index--)
|
|
{
|
|
if(param == driveList[index])
|
|
return;
|
|
}
|
|
|
|
driveList.push_back(param);
|
|
}
|
|
|
|
static void DriveParam_UnregisterDrive(DRIVE *drive)
|
|
{
|
|
LPARAM param;
|
|
size_t index;
|
|
|
|
param = (LPARAM)drive;
|
|
if (NULL == param)
|
|
return;
|
|
|
|
index = driveList.size();
|
|
while(index--)
|
|
{
|
|
if(param == driveList[index])
|
|
{
|
|
driveList.erase(driveList.begin() + index);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
static BOOL DriveParam_IsValid(LPARAM param)
|
|
{
|
|
if (param > 0x0000FFFF)
|
|
{
|
|
size_t index = driveList.size();
|
|
while(index--)
|
|
{
|
|
if(param == driveList[index])
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
DRIVE *Plugin_GetDriveFromNavItem(HNAVITEM hItem)
|
|
{
|
|
NAVITEM item;
|
|
|
|
if (!hItem) return NULL;
|
|
|
|
item.cbSize = sizeof(NAVITEM);
|
|
item.mask = NIMF_PARAM;
|
|
item.hItem = hItem;
|
|
|
|
return (MLNavItem_GetInfo(plugin.hwndLibraryParent, &item) && DriveParam_IsValid(item.lParam)) ?
|
|
(DRIVE*)item.lParam : NULL;
|
|
}
|
|
|
|
HNAVITEM Plugin_GetNavItemFromLetter(CHAR cLetter)
|
|
{
|
|
NAVCTRLFINDPARAMS fp = {0};
|
|
wchar_t invariant[32] = {0};
|
|
|
|
if (S_OK == StringCchPrintfW(invariant, sizeof(invariant)/sizeof(wchar_t), L"%s%c", NAVITEM_PREFIX, cLetter))
|
|
{
|
|
fp.cchLength = -1;
|
|
fp.pszName = invariant;
|
|
fp.compFlags = NICF_INVARIANT;
|
|
|
|
return MLNavCtrl_FindItemByName(plugin.hwndLibraryParent, &fp);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static BOOL CALLBACK EnumerateNavItemsCB(HNAVITEM hItem, LPARAM param)
|
|
{
|
|
DRIVE *pDrive = Plugin_GetDriveFromNavItem(hItem);
|
|
return (pDrive) ? ((NAVITEMENUMPARAM*)param)->callback(hItem, pDrive, ((NAVITEMENUMPARAM*)param)->param) : TRUE;
|
|
}
|
|
|
|
BOOL Plugin_EnumerateNavItems(NAVITEMENUMPROC callback, LPARAM param)
|
|
{
|
|
NAVITEMENUMPARAM pluginenum;
|
|
NAVCTRLENUMPARAMS navenum;
|
|
if (!callback) return FALSE;
|
|
|
|
pluginenum.callback = callback;
|
|
pluginenum.param = param;
|
|
|
|
navenum.hItemStart = hniMain;
|
|
navenum.lParam = (LPARAM)&pluginenum;
|
|
navenum.enumProc = EnumerateNavItemsCB;
|
|
|
|
return MLNavCtrl_EnumItems(plugin.hwndLibraryParent, &navenum);
|
|
}
|
|
|
|
void Plugin_RegisterListener(HWND hwnd, UINT uMsg, CHAR cLetter)
|
|
{
|
|
activeListener.hwnd = hwnd;
|
|
activeListener.uMsg = uMsg;
|
|
activeListener.cLetter = cLetter;
|
|
}
|
|
|
|
void Plugin_UnregisterListener(HWND hwnd)
|
|
{
|
|
ZeroMemory(&activeListener, sizeof(LISTENER));
|
|
}
|
|
|
|
static BOOL CALLBACK EnumNavItems_OnUIChangeCB(HNAVITEM hItem, DRIVE *pDrive, LPARAM param)
|
|
{
|
|
if (pDrive) pDrive->textSize = 0;
|
|
return TRUE;
|
|
}
|
|
|
|
static void UpdatedNavStyles(void)
|
|
{
|
|
g_navStyle = MLNavCtrl_GetStyle(plugin.hwndLibraryParent);
|
|
if (0 != g_view_metaconf->ReadInt(TEXT("showeject"), 1)) g_navStyle |= NCS_EX_SHOWEJECT;
|
|
}
|
|
|
|
static BOOL CALLBACK EnumerateNavItemsRemoveCB(HNAVITEM hItem, DRIVE *pDrive, LPARAM param)
|
|
{
|
|
if(pDrive)
|
|
{
|
|
MLNavCtrl_DeleteItem(plugin.hwndLibraryParent,hItem);
|
|
Plugin_EnumerateNavItems(EnumerateNavItemsRemoveCB, 0);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL Plugin_QueryOkToQuit()
|
|
{
|
|
CHAR szLetters[24] = {0};
|
|
INT c = DriveManager_GetDriveList(szLetters, ARRAYSIZE(szLetters));
|
|
while(c-- > 0)
|
|
{
|
|
INT msgId;
|
|
if (cdrip_isextracting(szLetters[c])) msgId = IDS_YOU_ARE_CURRENTLY_RIPPING_AUDIO_CD_MUST_CANCEL_TO_CLOSE_WINAMP;
|
|
else if (MLDisc_IsDiscCopying(szLetters[c])) msgId = IDS_YOU_ARE_CURRENTLY_COPYING_DATA_CD_MUST_CANCEL_TO_CLOSE_WINAMP;
|
|
else msgId = 0;
|
|
if (msgId)
|
|
{
|
|
wchar_t buffer[512] = {0};
|
|
StringCchPrintfW(buffer, 512, WASABI_API_LNGSTRINGW(msgId), szLetters[c]);
|
|
MessageBoxW(plugin.hwndWinampParent, buffer, WASABI_API_LNGSTRINGW(IDS_NOTIFICATION),
|
|
MB_OK | MB_ICONINFORMATION | MB_SETFOREGROUND | MB_TOPMOST);
|
|
return FALSE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
LRESULT CALLBACK WinampWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
if(uMsgNavStyleUpdate == uMsg)
|
|
{
|
|
if(!wParam)
|
|
{
|
|
UpdatedNavStyles();
|
|
Plugin_EnumerateNavItems(EnumNavItems_OnUIChangeCB, 0);
|
|
}
|
|
else
|
|
{
|
|
Plugin_EnumerateNavItems(EnumerateNavItemsRemoveCB, 0);
|
|
ShowHideRipBurnParent();
|
|
DriveManager_Uninitialize(0);
|
|
DriveManager_Initialize(Invoke_OnDriveManagerNotify, TRUE);
|
|
Plugin_OnMLVisible((BOOL)SENDMLIPC(plugin.hwndLibraryParent, ML_IPC_IS_VISIBLE, 0));
|
|
}
|
|
}
|
|
else if (uMsgBurnerNotify == uMsg) // burner broadcast message LOWORD(wParam) = drive letter, lParam = (BOOL)bStarted. if bStarted = TRUE - burning started, otherwise burning finished
|
|
{
|
|
if (0 == HIWORD(wParam))
|
|
{
|
|
DriveManager_SetDriveMode((CHAR)LOWORD(wParam), (0 != lParam) ? DM_MODE_BURNING : DM_MODE_READY);
|
|
}
|
|
}
|
|
else if (uMsgRipperNotify == uMsg)
|
|
{
|
|
if (HIWORD(wParam)) // another instance of winamp quering
|
|
{
|
|
if (LOWORD(wParam) && cdrip_isextracting((CHAR)LOWORD(wParam))) SendNotifyMessage((HWND)lParam, uMsgRipperNotify, LOWORD(wParam), (LPARAM)TRUE);
|
|
else
|
|
{
|
|
CHAR cLetter;
|
|
cLetter = (CHAR)cdrip_isextracting(-1);
|
|
if (cLetter) SendNotifyMessage((HWND)lParam, uMsgRipperNotify, cLetter, (LPARAM)TRUE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DriveManager_SetDriveMode((CHAR)LOWORD(wParam), (0 != lParam) ? DM_MODE_RIPPING : DM_MODE_READY);
|
|
}
|
|
}
|
|
else if (uMsgCopyNotify == uMsg)
|
|
{
|
|
if (HIWORD(wParam))
|
|
{
|
|
if (LOWORD(wParam) && MLDisc_IsDiscCopying((CHAR)LOWORD(wParam))) SendNotifyMessage((HWND)lParam, uMsgCopyNotify, LOWORD(wParam), (LPARAM)TRUE);
|
|
else
|
|
{
|
|
CHAR szLetters[24] = {0};
|
|
INT c = DriveManager_GetDriveList(szLetters, ARRAYSIZE(szLetters));
|
|
while(c-- > 0)
|
|
{
|
|
if (MLDisc_IsDiscCopying(szLetters[c]))
|
|
SendNotifyMessage((HWND)lParam, uMsgCopyNotify, szLetters[c], (LPARAM)TRUE);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DriveManager_SetDriveMode((CHAR)LOWORD(wParam), (0 != lParam) ? DM_MODE_COPYING : DM_MODE_READY);
|
|
}
|
|
}
|
|
else if (WM_WA_IPC == uMsg)
|
|
{
|
|
switch(lParam)
|
|
{
|
|
case IPC_SKIN_CHANGED:
|
|
case IPC_CB_RESETFONT:
|
|
UpdatedNavStyles();
|
|
Plugin_EnumerateNavItems(EnumNavItems_OnUIChangeCB, 0);
|
|
break;
|
|
case IPC_FILE_TAG_MAY_HAVE_UPDATED:
|
|
case IPC_FILE_TAG_MAY_HAVE_UPDATEDW:
|
|
if (activeListener.hwnd) SendMessageW(activeListener.hwnd, activeListener.uMsg, (WPARAM)lParam, (LPARAM)wParam);
|
|
break;
|
|
}
|
|
if(lParam == delay_ml_startup)
|
|
{
|
|
if(!wParam)
|
|
{
|
|
PostMessage(plugin.hwndWinampParent, WM_WA_IPC, 1, delay_ml_startup);
|
|
}
|
|
else if(wParam == 1)
|
|
{
|
|
// TODO: benski> temp-hack fix for now -- if (SENDMLIPC(plugin.hwndLibraryParent, ML_IPC_IS_VISIBLE, 0))
|
|
{
|
|
DriveManager_Initialize(Invoke_OnDriveManagerNotify, TRUE);
|
|
MLDisc_InitializeCopyData();
|
|
|
|
DriveManager_Resume(TRUE);
|
|
SendNotifyMessage(HWND_BROADCAST, uMsgBurnerNotify, MAKEWPARAM(0, 0xffff), (LPARAM)plugin.hwndWinampParent);
|
|
SendNotifyMessage(HWND_BROADCAST, uMsgRipperNotify, MAKEWPARAM(0, 0xffff), (LPARAM)plugin.hwndWinampParent);
|
|
SendNotifyMessage(HWND_BROADCAST, uMsgCopyNotify, MAKEWPARAM(0, 0xffff), (LPARAM)plugin.hwndWinampParent);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return (oldWinampWndProc) ? CallWindowProcW(oldWinampWndProc, hwnd, uMsg, wParam, lParam) : DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
static DM_UNITINFO2_PARAM unitinfo;
|
|
static char szDesc[1024];
|
|
static DWORD szTypes[64];
|
|
|
|
static void CALLBACK FreeParam(DM_NOTIFY_PARAM *phdr)
|
|
{
|
|
if (!phdr) return;
|
|
switch(phdr->opCode)
|
|
{
|
|
case DMOP_TITLE:
|
|
if (((DM_TITLE_PARAM*)phdr)->pszTitle) free(((DM_TITLE_PARAM*)phdr)->pszTitle);
|
|
break;
|
|
}
|
|
free(phdr);
|
|
}
|
|
static void RegisterIcons()
|
|
{
|
|
MLIMAGELISTCREATE mlilCreate;
|
|
MLIMAGESOURCE mlis;
|
|
MLIMAGELISTITEM mlilItem;
|
|
|
|
if (hmlilIcons) return;
|
|
|
|
mlilCreate.cx = ICON_SIZE_CX;
|
|
mlilCreate.cy = ICON_SIZE_CY;
|
|
mlilCreate.cInitial = 5;
|
|
mlilCreate.cGrow = 1;
|
|
mlilCreate.cCacheSize = 3;
|
|
mlilCreate.flags = MLILC_COLOR24;
|
|
|
|
hmlilIcons = MLImageList_Create(plugin.hwndLibraryParent, &mlilCreate);
|
|
if (!hmlilIcons) return;
|
|
|
|
ZeroMemory(&mlilItem, sizeof(MLIMAGELISTITEM));
|
|
mlilItem.cbSize = sizeof(MLIMAGELISTITEM);
|
|
mlilItem.hmlil = hmlilIcons;
|
|
mlilItem.filterUID = MLIF_FILTER1_UID;
|
|
mlilItem.pmlImgSource = &mlis;
|
|
|
|
ZeroMemory(&mlis, sizeof(MLIMAGESOURCE));
|
|
mlis.cbSize = sizeof(MLIMAGESOURCE);
|
|
mlis.type = SRC_TYPE_PNG;
|
|
mlis.hInst = plugin.hDllInstance;
|
|
|
|
mlis.lpszName = MAKEINTRESOURCEW(IDB_NAVITEM_CDROM);
|
|
MLImageList_Add(plugin.hwndLibraryParent, &mlilItem);
|
|
|
|
mlis.lpszName = MAKEINTRESOURCEW(IDB_EJECT_NORMAL);
|
|
MLImageList_Add(plugin.hwndLibraryParent, &mlilItem);
|
|
|
|
mlis.lpszName = MAKEINTRESOURCEW(IDB_EJECT_HILITED);
|
|
MLImageList_Add(plugin.hwndLibraryParent, &mlilItem);
|
|
|
|
mlis.lpszName = MAKEINTRESOURCEW(IDB_EJECT_PRESSED);
|
|
MLImageList_Add(plugin.hwndLibraryParent, &mlilItem);
|
|
|
|
mlis.lpszName = MAKEINTRESOURCEW(IDB_EJECT_DISABLED);
|
|
MLImageList_Add(plugin.hwndLibraryParent, &mlilItem);
|
|
|
|
}
|
|
|
|
|
|
static BOOL UpdateTitle(CHAR cLetter, LPCWSTR pszTitle)
|
|
{
|
|
HNAVITEM hItem;
|
|
NAVITEM item;
|
|
DRIVE *pDrive;
|
|
|
|
hItem = Plugin_GetNavItemFromLetter(cLetter);
|
|
if (!hItem) return FALSE;
|
|
|
|
pDrive = Plugin_GetDriveFromNavItem(hItem);
|
|
if (!pDrive) return FALSE;
|
|
|
|
if (S_OK != StringCchCopyW(pDrive->szTitle, sizeof(pDrive->szTitle)/sizeof(wchar_t), (pszTitle) ? pszTitle : L"")) return FALSE;
|
|
|
|
pDrive->textSize = 0;
|
|
|
|
item.cbSize = sizeof(NAVITEM);
|
|
item.mask = NIMF_TEXT;
|
|
item.hItem = hItem;
|
|
item.pszText = pDrive->szTitle;
|
|
|
|
return MLNavItem_SetInfo(plugin.hwndLibraryParent, &item);
|
|
|
|
}
|
|
static void QueryTitle(CHAR cLetter)
|
|
{
|
|
DM_TITLE_PARAM *pdtp;
|
|
|
|
pdtp = (DM_TITLE_PARAM*)calloc(4, sizeof(DM_TITLE_PARAM));
|
|
if (pdtp)
|
|
{
|
|
pdtp->header.callback = (INT_PTR)Invoke_OnDriveManagerNotify;
|
|
pdtp->header.cLetter = cLetter;
|
|
pdtp->header.uMsg = NULL;
|
|
pdtp->header.fnFree = FreeParam;
|
|
pdtp->cchTitle = 256;
|
|
pdtp->pszTitle = (wchar_t*)calloc(pdtp->cchTitle, sizeof(wchar_t));
|
|
|
|
DriveManager_QueryTitle(pdtp);
|
|
}
|
|
}
|
|
static void Drive_OnAdded(CHAR cLetter)
|
|
{
|
|
wchar_t szInvariant[32] = {0};
|
|
|
|
DRIVE *pDrive;
|
|
NAVINSERTSTRUCT nis = {0};
|
|
wchar_t szDriveType[32] = {0}, szDriveCap[64] = {0};
|
|
|
|
pDrive = (DRIVE*)calloc(1, sizeof(DRIVE));
|
|
if (!pDrive) return;
|
|
|
|
StringCchPrintfW(szInvariant, sizeof(szInvariant)/sizeof(wchar_t), L"%s%c", NAVITEM_PREFIX, cLetter);
|
|
|
|
pDrive->cLetter = cLetter;
|
|
pDrive->cMode = DriveManager_GetDriveMode(cLetter);
|
|
|
|
WASABI_API_LNGSTRINGW_BUF(IDS_CD, szDriveType, sizeof(szDriveType)/sizeof(wchar_t));
|
|
WASABI_API_LNGSTRINGW_BUF(IDS_DRIVE_CAP, szDriveCap, sizeof(szDriveCap)/sizeof(wchar_t));
|
|
StringCchPrintfW(pDrive->szTitle, sizeof(pDrive->szTitle)/sizeof(wchar_t), L"%s %s (%C:)", szDriveType, szDriveCap, (WCHAR)cLetter);
|
|
|
|
if (NULL == hmlilIcons) RegisterIcons();
|
|
|
|
ZeroMemory(&nis, sizeof(NAVINSERTSTRUCT));
|
|
nis.hParent = hniMain;
|
|
nis.item.cbSize = sizeof(NAVITEM);
|
|
nis.item.pszText = pDrive->szTitle;
|
|
nis.item.pszInvariant = szInvariant;
|
|
nis.item.mask = NIMF_TEXT | NIMF_TEXTINVARIANT | NIMF_PARAM | NIMF_STYLE;
|
|
nis.item.style = NIS_CUSTOMDRAW | NIS_WANTSETCURSOR | NIS_WANTHITTEST;
|
|
nis.item.styleMask = nis.item.style;
|
|
nis.item.lParam = (LPARAM)pDrive;
|
|
|
|
if (NULL != MLNavCtrl_InsertItem(plugin.hwndLibraryParent, &nis))
|
|
{
|
|
DriveParam_RegisterDrive(pDrive);
|
|
}
|
|
}
|
|
|
|
static void Drive_OnChanged(CHAR cLetter)
|
|
{
|
|
QueryTitle(cLetter);
|
|
}
|
|
|
|
static void Drive_OnRemoved(CHAR cLetter)
|
|
{
|
|
HNAVITEM hItem;
|
|
hItem = Plugin_GetNavItemFromLetter(cLetter);
|
|
if (hItem) MLNavCtrl_DeleteItem(plugin.hwndLibraryParent, hItem);
|
|
if (riphash && (0xFF & (riphash >> 24)) == (UCHAR)cLetter) riphash = 0;
|
|
}
|
|
|
|
static void Drive_OnModeChanged(CHAR cLetter, CHAR cMode)
|
|
{
|
|
HNAVITEM hItem;
|
|
DRIVE *pDrive;
|
|
|
|
hItem = Plugin_GetNavItemFromLetter(cLetter);
|
|
if (!hItem) return;
|
|
|
|
pDrive = Plugin_GetDriveFromNavItem(hItem);
|
|
if (pDrive)
|
|
{
|
|
NAVITEMINAVLIDATE inv;
|
|
|
|
pDrive->cMode = cMode;
|
|
|
|
inv.fErase = FALSE;
|
|
inv.hItem = hItem;
|
|
inv.prc = NULL;
|
|
MLNavItem_Invalidate(plugin.hwndLibraryParent, &inv);
|
|
}
|
|
}
|
|
|
|
static void Medium_OnAdded(CHAR cLetter)
|
|
{
|
|
if (riphash && (0xFF & (riphash >> 24)) == (UCHAR)cLetter) riphash = 0;
|
|
QueryTitle(cLetter);
|
|
}
|
|
|
|
static void Medium_OnRemoved(CHAR cLetter)
|
|
{
|
|
if (riphash && (0xFF & (riphash >> 24)) == (UCHAR)cLetter) riphash = 0;
|
|
QueryTitle(cLetter);
|
|
}
|
|
|
|
static void OnDriveMangerOpCompleted(DM_NOTIFY_PARAM *phdr)
|
|
{
|
|
switch(phdr->opCode)
|
|
{
|
|
case DMOP_TITLE:
|
|
if (S_OK == phdr->result) UpdateTitle(phdr->cLetter, ((DM_TITLE_PARAM*)phdr)->pszTitle);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void CALLBACK OnDriveManagerNotify(ULONG_PTR param)
|
|
{
|
|
WORD code;
|
|
CHAR cLetter;
|
|
|
|
code = LOWORD(param);
|
|
cLetter = (CHAR)(0xFF & HIWORD(param));
|
|
|
|
switch(code)
|
|
{
|
|
case DMW_DRIVEADDED: Drive_OnAdded(cLetter); break;
|
|
case DMW_DRIVEREMOVED: Drive_OnRemoved(cLetter); break;
|
|
case DMW_DRIVECHANGED: Drive_OnChanged(cLetter); break;
|
|
case DMW_MEDIUMARRIVED: Medium_OnAdded(cLetter); break;
|
|
case DMW_MEDIUMREMOVED: Medium_OnRemoved(cLetter); break;
|
|
case DMW_MODECHANGED: Drive_OnModeChanged(cLetter, ((CHAR)(HIWORD(param)>>8))); break;
|
|
|
|
}
|
|
if (activeListener.hwnd && (0 == activeListener.cLetter || cLetter == activeListener.cLetter))
|
|
PostMessageW(activeListener.hwnd, activeListener.uMsg, (WPARAM)code, (LPARAM)HIWORD(param));
|
|
}
|
|
|
|
static void CALLBACK Invoke_OnDriveManagerNotify(WORD wCode, INT_PTR param)
|
|
{
|
|
switch(wCode)
|
|
{
|
|
case DMW_DRIVEADDED:
|
|
case DMW_DRIVEREMOVED:
|
|
case DMW_DRIVECHANGED:
|
|
case DMW_MEDIUMARRIVED:
|
|
case DMW_MEDIUMREMOVED:
|
|
case DMW_MODECHANGED:
|
|
if (GetCurrentThreadId() != GetWindowThreadProcessId(plugin.hwndLibraryParent, NULL))
|
|
{
|
|
HANDLE htWA = (WASABI_API_APP) ? WASABI_API_APP->main_getMainThreadHandle() : NULL;
|
|
if (htWA)
|
|
{
|
|
QueueUserAPC(OnDriveManagerNotify, htWA, MAKELONG(wCode, (WORD)(param)));
|
|
CloseHandle(htWA);
|
|
}
|
|
}
|
|
else OnDriveManagerNotify(MAKELONG(wCode, (WORD)(param)));
|
|
break;
|
|
case DMW_OPCOMPLETED: OnDriveMangerOpCompleted((DM_NOTIFY_PARAM*)param); break;
|
|
}
|
|
}
|
|
|
|
void ShowHideRipBurnParent(void)
|
|
{
|
|
BOOL bVal;
|
|
if (S_OK == Settings_GetBool(C_GLOBAL, GF_SHOWPARENT, &bVal) && bVal)
|
|
{
|
|
if(!hniMain)
|
|
{
|
|
NAVINSERTSTRUCT nis;
|
|
ZeroMemory(&nis, sizeof(NAVITEM));
|
|
nis.item.cbSize = sizeof(NAVITEM);
|
|
nis.item.pszText = WASABI_API_LNGSTRINGW_BUF(IDS_RIP_AND_BURN, randb,64);
|
|
nis.item.pszInvariant = NAVITEM_PREFIX L"main";
|
|
nis.item.mask = NIMF_TEXT | NIMF_STYLE | NIMF_TEXTINVARIANT | NIMF_PARAM;
|
|
nis.item.style = NIS_HASCHILDREN;
|
|
nis.item.styleMask = nis.item.style;
|
|
nis.item.lParam = 0L;
|
|
hniMain = MLNavCtrl_InsertItem(plugin.hwndLibraryParent, &nis);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(hniMain)
|
|
{
|
|
MLNavCtrl_DeleteItem(plugin.hwndLibraryParent,hniMain);
|
|
}
|
|
hniMain = NULL;
|
|
}
|
|
}
|
|
|
|
int Init()
|
|
{
|
|
QueryPerformanceFrequency(&freq);
|
|
|
|
// get the Application service
|
|
waServiceFactory *sf = plugin.service->service_getServiceByGuid(applicationApiServiceGuid);
|
|
if (sf) WASABI_API_APP = (api_application *)sf->getInterface();
|
|
|
|
// loader so that we can get the localisation service api for use
|
|
sf = plugin.service->service_getServiceByGuid(languageApiGUID);
|
|
if (sf) WASABI_API_LNG = reinterpret_cast<api_language*>(sf->getInterface());
|
|
|
|
sf = plugin.service->service_getServiceByGuid(AnonymousStatsGUID);
|
|
if (sf) AGAVE_API_STATS = reinterpret_cast<api_stats*>(sf->getInterface());
|
|
|
|
// need to have this initialised before we try to do anything with localisation features
|
|
WASABI_API_START_LANG(plugin.hDllInstance,MlDiscLangGUID);
|
|
|
|
mediaLibrary.library = plugin.hwndLibraryParent;
|
|
mediaLibrary.winamp = plugin.hwndWinampParent;
|
|
mediaLibrary.instance = plugin.hDllInstance;
|
|
|
|
static wchar_t szDescription[256];
|
|
StringCchPrintf(szDescription, ARRAYSIZE(szDescription),
|
|
WASABI_API_LNGSTRINGW(IDS_NULLSOFT_RIP_AND_BURN), VERSION_MAJOR, VERSION_MINOR);
|
|
plugin.description = (char*)szDescription;
|
|
|
|
// add to Winamp preferences
|
|
myPrefsItemCD.dlgID = IDD_PREFSCDRIPFR;
|
|
myPrefsItemCD.name = WASABI_API_LNGSTRINGW_BUF(IDS_CD_RIPPING,cdrip,64);
|
|
myPrefsItemCD.proc = (void*)CDRipPrefsProc;
|
|
myPrefsItemCD.hInst = WASABI_API_LNG_HINST;
|
|
myPrefsItemCD.where = 6; // media library
|
|
SENDWAIPC(plugin.hwndWinampParent, IPC_ADD_PREFS_DLGW, (WPARAM)&myPrefsItemCD);
|
|
|
|
wchar_t szIniFile[MAX_PATH],
|
|
*INI_DIR = (wchar_t*)SENDWAIPC(plugin.hwndWinampParent, IPC_GETINIDIRECTORYW, 0);
|
|
|
|
PathCombine(szIniFile, INI_DIR, TEXT("Plugins\\gen_ml.ini"));
|
|
g_config = new C_Config(szIniFile);
|
|
|
|
PathCombine(szIniFile, INI_DIR, TEXT("Plugins\\ml\\cdrom.vmd"));
|
|
g_view_metaconf = new C_Config(szIniFile);
|
|
|
|
g_context_menus = WASABI_API_LOADMENU(IDR_CONTEXTMENUS);
|
|
|
|
oldWinampWndProc = (WNDPROC)(LONG_PTR)SetWindowLongPtrW(plugin.hwndWinampParent, GWLP_WNDPROC, (LONG)(LONG_PTR)WinampWndProc);
|
|
|
|
if (!uMsgBurnerNotify) uMsgBurnerNotify = RegisterWindowMessageA("WABURNER_BROADCAST_MSG");
|
|
if (!uMsgRipperNotify) uMsgRipperNotify = RegisterWindowMessageA("WARIPPER_BROADCAST_MSG");
|
|
if (!uMsgCopyNotify) uMsgCopyNotify = RegisterWindowMessageA("WACOPY_BROADCAST_MSG");
|
|
if (!uMsgNavStyleUpdate) uMsgNavStyleUpdate = RegisterWindowMessageW(L"ripburn_nav_update");
|
|
|
|
UpdatedNavStyles();
|
|
ShowHideRipBurnParent();
|
|
|
|
delay_ml_startup = SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&"ml_disc_delay", IPC_REGISTER_WINAMP_IPCMESSAGE);
|
|
PostMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, delay_ml_startup);
|
|
return ML_INIT_SUCCESS;
|
|
}
|
|
|
|
void Quit()
|
|
{
|
|
DriveManager_Uninitialize(4000); // allow to wait for 4 sec.
|
|
MLDisc_ReleaseCopyData();
|
|
delete(g_view_metaconf);
|
|
g_view_metaconf = 0;
|
|
|
|
delete(g_config);
|
|
g_config = NULL;
|
|
|
|
if (rgThread)
|
|
{
|
|
QueueUserAPC(QuitThread, rgThread, 0);
|
|
WaitForSingleObject(rgThread, INFINITE);
|
|
CloseHandle(rgThread);
|
|
rgThread = 0;
|
|
}
|
|
|
|
waServiceFactory *sf = plugin.service->service_getServiceByGuid(AnonymousStatsGUID);
|
|
if (sf) sf->releaseInterface(AGAVE_API_STATS);
|
|
}
|
|
|
|
int getFileInfo(const char *filename, const char *metadata, char *dest, int len)
|
|
{
|
|
dest[0] = 0;
|
|
extendedFileInfoStruct efis = { filename, metadata, dest, len, };
|
|
return (int)(INT_PTR)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM) & efis, IPC_GET_EXTENDED_FILE_INFO); //will return 1 if wa2 supports this IPC call
|
|
}
|
|
|
|
int getFileInfoW(const wchar_t *filename, const wchar_t *metadata, wchar_t *dest, int len)
|
|
{
|
|
if (dest && len)
|
|
dest[0] = 0;
|
|
extendedFileInfoStructW efis = { filename, metadata, dest, len, };
|
|
return (int)(INT_PTR)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&efis, IPC_GET_EXTENDED_FILE_INFOW); //will return 1 if wa2 supports this IPC call
|
|
}
|
|
|
|
|
|
void Plugin_ShowRippingPreferences(void)
|
|
{
|
|
SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&myPrefsItemCD, IPC_OPENPREFSTOPAGE);
|
|
}
|
|
BOOL Plugin_IsExtractScheduled(CHAR cLetter)
|
|
{
|
|
BOOL result;
|
|
if (riphash && (0xFF & (riphash >> 24)) == (UCHAR)cLetter)
|
|
{
|
|
DWORD mediumSN;
|
|
char devname[] = "X:\\";
|
|
devname[0] = cLetter;
|
|
result = (GetVolumeInformationA(devname, NULL, 0, &mediumSN, NULL, NULL, NULL, 0) && (0x00FFFFFF & riphash) == mediumSN);
|
|
riphash = 0;
|
|
}
|
|
else result = FALSE;
|
|
return result;
|
|
}
|
|
|
|
|
|
static int Root_OnContextMenu(HNAVITEM hItem, HWND hHost, POINTS pts)
|
|
{
|
|
HMENU hMenu = GetSubMenu(g_context_menus, 7);
|
|
if (!hMenu) return 0;
|
|
|
|
POINT pt;
|
|
POINTSTOPOINT(pt, pts);
|
|
if (-1 == pt.x || -1 == pt.y)
|
|
{
|
|
NAVITEMGETRECT itemRect;
|
|
itemRect.fItem = FALSE;
|
|
itemRect.hItem = hItem;
|
|
if (MLNavItem_GetRect(plugin.hwndLibraryParent, &itemRect))
|
|
{
|
|
MapWindowPoints(hHost, HWND_DESKTOP, (POINT*)&itemRect.rc, 2);
|
|
pt.x = itemRect.rc.left + 2;
|
|
pt.y = itemRect.rc.top + 2;
|
|
}
|
|
}
|
|
|
|
int r = Menu_TrackPopup(plugin.hwndLibraryParent, hMenu,
|
|
TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTBUTTON | TPM_NONOTIFY,
|
|
pt.x, pt.y, hHost, NULL);
|
|
switch (r)
|
|
{
|
|
case ID_NAVIGATION_PREFERENCES: Plugin_ShowRippingPreferences(); return 1;
|
|
case ID_NAVIGATION_HELP: SENDWAIPC(plugin.hwndWinampParent, IPC_OPEN_URL, L"https://help.winamp.com/hc/articles/8111574760468-CD-Ripping-with-Winamp"); return 1;
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int Plugin_OnContextMenu(HNAVITEM hItem, HWND hHost, POINTS pts, CHAR cLetter)
|
|
{
|
|
HMENU hMenu = GetSubMenu(g_context_menus, 2);
|
|
if (!hMenu) return 0;
|
|
|
|
MENUITEMINFO mii = { sizeof(MENUITEMINFO), };
|
|
mii.fMask = MIIM_STATE;
|
|
if (GetMenuItemInfo(hMenu, ID_CDROMMENU_EJECTCD, FALSE, &mii))
|
|
{
|
|
mii.fState &= ~(MFS_ENABLED | MFS_DISABLED);
|
|
mii.fState |= ((DM_MODE_READY == DriveManager_GetDriveMode(cLetter)) ? MFS_ENABLED : MFS_DISABLED);
|
|
SetMenuItemInfo(hMenu, ID_CDROMMENU_EJECTCD, FALSE, &mii);
|
|
}
|
|
|
|
POINT pt;
|
|
POINTSTOPOINT(pt, pts);
|
|
if (-1 == pt.x || -1 == pt.y)
|
|
{
|
|
NAVITEMGETRECT itemRect;
|
|
itemRect.fItem = FALSE;
|
|
itemRect.hItem = hItem;
|
|
if (MLNavItem_GetRect(plugin.hwndLibraryParent, &itemRect))
|
|
{
|
|
MapWindowPoints(hHost, HWND_DESKTOP, (POINT*)&itemRect.rc, 2);
|
|
pt.x = itemRect.rc.left + 2;
|
|
pt.y = itemRect.rc.top + 2;
|
|
}
|
|
}
|
|
|
|
int r = Menu_TrackPopup(plugin.hwndLibraryParent, hMenu,
|
|
TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTBUTTON | TPM_NONOTIFY,
|
|
pt.x, pt.y, hHost, NULL);
|
|
switch (r)
|
|
{
|
|
case ID_CDROMMENU_EXTRACT_CONFIGURE: Plugin_ShowRippingPreferences(); return 1;
|
|
case ID_CDROMMENU_EXTRACT_HELP: SENDWAIPC(plugin.hwndWinampParent, IPC_OPEN_URL, L"https://help.winamp.com/hc/articles/8111574760468-CD-Ripping-with-Winamp"); return 1;
|
|
case ID_CDROMMENU_PLAYALL:
|
|
case ID_CDROMMENU_ENQUEUEALL:
|
|
{
|
|
int enq = r == ID_CDROMMENU_ENQUEUEALL;
|
|
itemRecordList obj = {0, };
|
|
saveCDToItemRecordList(cLetter, &obj, NULL);
|
|
mlSendToWinampStruct p;
|
|
p.type = ML_TYPE_CDTRACKS;
|
|
p.enqueue = enq | 2;
|
|
p.data = &obj;
|
|
SENDMLIPC(plugin.hwndLibraryParent, ML_IPC_SENDTOWINAMP, (WPARAM)&p);
|
|
freeRecordList(&obj);
|
|
}
|
|
break;
|
|
case ID_CDROMMENU_EXTRACT_EXTRACTALL:
|
|
riphash = 0;
|
|
if (hItem)
|
|
{
|
|
if (hItem == MLNavCtrl_GetSelection(plugin.hwndLibraryParent))
|
|
{
|
|
HWND hwnd = (HWND)SENDMLIPC(plugin.hwndLibraryParent, ML_IPC_GETCURRENTVIEW, 0);
|
|
if (hwnd && SendMessageW(hwnd, WM_EXTRACTDISC, cLetter, 0)) break;
|
|
}
|
|
|
|
char devname[] = "X:\\";
|
|
devname[0] = cLetter;
|
|
if (!GetVolumeInformationA(devname, NULL, 0, &riphash, NULL, NULL, NULL, 0)) riphash = 0;
|
|
if (riphash) riphash = ((0x00FFFFFF & riphash) | (cLetter << 24));
|
|
MLNavItem_Select(plugin.hwndLibraryParent, hItem);
|
|
}
|
|
break;
|
|
case ID_CDROMMENU_EJECTCD:
|
|
{
|
|
CHAR cMode;
|
|
cMode = DriveManager_GetDriveMode(cLetter);
|
|
if (DM_MODE_READY != cMode)
|
|
{
|
|
wchar_t title[32] = {0};
|
|
MessageBox(plugin.hwndLibraryParent,
|
|
WASABI_API_LNGSTRINGW((DM_MODE_RIPPING == cMode) ? IDS_ERROR_CD_RIP_IN_PROGRESS : IDS_ERROR_CD_BURN_IN_PROGRESS),
|
|
WASABI_API_LNGSTRINGW_BUF(IDS_CD_EJECT,title,32), 0);
|
|
return FALSE;
|
|
}
|
|
else DriveManager_Eject(cLetter, DM_EJECT_REMOVE);
|
|
}
|
|
break;
|
|
}
|
|
Sleep(100);
|
|
MSG msg;
|
|
while (PeekMessageW(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE)); //eat return
|
|
return 0;
|
|
}
|
|
|
|
static DWORD resumeTick = 0; // this is cheating
|
|
static void Plugin_OnMLVisible(BOOL bVisible)
|
|
{
|
|
if (bVisible)
|
|
{
|
|
DriveManager_Resume(TRUE);
|
|
resumeTick = GetTickCount();
|
|
SendNotifyMessage(HWND_BROADCAST, uMsgBurnerNotify, MAKEWPARAM(0, 0xffff), (LPARAM)plugin.hwndWinampParent);
|
|
SendNotifyMessage(HWND_BROADCAST, uMsgRipperNotify, MAKEWPARAM(0, 0xffff), (LPARAM)plugin.hwndWinampParent);
|
|
SendNotifyMessage(HWND_BROADCAST, uMsgCopyNotify, MAKEWPARAM(0, 0xffff), (LPARAM)plugin.hwndWinampParent);
|
|
return;
|
|
}
|
|
else DriveManager_Suspend();
|
|
}
|
|
|
|
static HWND Plugin_OnViewCreate(HNAVITEM hItem, HWND hwndParent)
|
|
{
|
|
if (hItem == hniMain)
|
|
{
|
|
return WASABI_API_CREATEDIALOGW(IDD_VIEW_RIPBURN, hwndParent, view_ripburnDialogProc);
|
|
}
|
|
else
|
|
{
|
|
DRIVE *pDrive = Plugin_GetDriveFromNavItem(hItem);
|
|
if (pDrive) return CreateContainerWindow(hwndParent, pDrive->cLetter, ((GetTickCount() - resumeTick) > 100));
|
|
resumeTick = 0;
|
|
}
|
|
return NULL;
|
|
}
|
|
static BOOL Plugin_OnNavItemDelete(HNAVITEM hItem)
|
|
{
|
|
DRIVE *pDrive = Plugin_GetDriveFromNavItem(hItem);
|
|
if (!pDrive) return FALSE;
|
|
DriveParam_UnregisterDrive(pDrive);
|
|
free(pDrive);
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL Plugin_OnNavItemClick(HNAVITEM hItem, UINT nAction, HWND hwndParent)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
static INT Plugin_OnNavCustomDraw(HNAVITEM hItem, NAVITEMDRAW *pnicd, LPARAM lParam)
|
|
{
|
|
static INT indent = 0;
|
|
DRIVE *pDrive;
|
|
|
|
if (FALSE == DriveParam_IsValid(lParam))
|
|
return FALSE;
|
|
|
|
pDrive = (DRIVE*)lParam;
|
|
|
|
if (0 == indent) indent = MLNavCtrl_GetIndent(plugin.hwndLibraryParent);
|
|
switch(pnicd->drawStage)
|
|
{
|
|
case NIDS_PREPAINT:
|
|
if (pnicd->prc->bottom > 0 && pnicd->prc->bottom > pnicd->prc->top)
|
|
{
|
|
HIMAGELIST himl;
|
|
INT realIndex, l, t, r;
|
|
MLIMAGELISTREALINDEX mlilRealIndex;
|
|
|
|
himl = MLImageList_GetRealList(plugin.hwndLibraryParent, hmlilIcons);
|
|
|
|
mlilRealIndex.cbSize = sizeof(MLIMAGELISTREALINDEX);
|
|
mlilRealIndex.hmlil = hmlilIcons;
|
|
mlilRealIndex.rgbBk = GetBkColor(pnicd->hdc);
|
|
mlilRealIndex.rgbFg = GetTextColor(pnicd->hdc);
|
|
|
|
t = pnicd->prc->top + (pnicd->prc->bottom - pnicd->prc->top - ICON_SIZE_CY)/2;
|
|
l = pnicd->prc->left + (indent*pnicd->iLevel) + 3;
|
|
r = pnicd->prc->right;
|
|
|
|
mlilRealIndex.mlilIndex = 0;
|
|
realIndex = ((NCS_SHOWICONS & g_navStyle) && himl && l < pnicd->prc->right) ?
|
|
MLImageList_GetRealIndex(plugin.hwndLibraryParent, &mlilRealIndex) : -1;
|
|
if (-1 != realIndex) // draw icon
|
|
{
|
|
if (ImageList_Draw(himl, realIndex, pnicd->hdc, l, t, ILD_NORMAL))
|
|
{
|
|
ExcludeClipRect(pnicd->hdc, l, t, l + ICON_SIZE_CX, t + ICON_SIZE_CY);
|
|
l += (ICON_SIZE_CX + 5);
|
|
}
|
|
}
|
|
|
|
pDrive->bEjectVisible = FALSE;
|
|
mlilRealIndex.mlilIndex = 1 + ((DM_MODE_READY == pDrive->cMode) ? pDrive->nBtnState : BTNSTATE_DISABLED);
|
|
realIndex = ((NCS_EX_SHOWEJECT & g_navStyle) && himl && (r - l) > (24 + 6 + ICON_SIZE_CX)) ?
|
|
MLImageList_GetRealIndex(plugin.hwndLibraryParent, &mlilRealIndex) : -1;
|
|
if (-1 != realIndex)
|
|
{
|
|
if (ImageList_Draw(himl, realIndex, pnicd->hdc, r - (ICON_SIZE_CX + 2), t, ILD_NORMAL))
|
|
{
|
|
r -= (ICON_SIZE_CX + 2);
|
|
ExcludeClipRect(pnicd->hdc, r, t, r + ICON_SIZE_CX, t + ICON_SIZE_CY);
|
|
r -= 4;
|
|
pDrive->bEjectVisible = TRUE;
|
|
}
|
|
}
|
|
|
|
if (*pDrive->szTitle && l < r)
|
|
{
|
|
RECT rt;
|
|
INT textH, textW;
|
|
COLORREF rgbOld(0), rgbBkOld(0);
|
|
|
|
if (!pDrive->textSize || (pDrive->textOrigWidth > r-l-3 && pDrive->itemWidth > (pnicd->prc->right - pnicd->prc->left)) ||
|
|
(LOWORD(pDrive->textSize) != pDrive->textOrigWidth && pDrive->itemWidth < (pnicd->prc->right - pnicd->prc->left)))
|
|
{
|
|
NAVITEM item;
|
|
item.cbSize = sizeof(NAVITEM);
|
|
item.mask = NIMF_TEXT;
|
|
item.hItem = hItem;
|
|
item.cchTextMax = sizeof(pDrive->szTitle)/sizeof(wchar_t);
|
|
item.pszText = pDrive->szTitle;
|
|
MLNavItem_GetInfo(plugin.hwndLibraryParent, &item);
|
|
{
|
|
if (pDrive->szTitle != item.pszText)
|
|
{
|
|
StringCchCopyW(pDrive->szTitle, sizeof(pDrive->szTitle)/sizeof(wchar_t), item.pszText);
|
|
}
|
|
if (!pDrive->textSize)
|
|
{
|
|
SetRect(&rt, 0, 0, 1, 1);
|
|
DrawTextW(pnicd->hdc, pDrive->szTitle, -1, &rt, DT_SINGLELINE | DT_CALCRECT);
|
|
pDrive->textOrigWidth = rt.right - rt.left;
|
|
}
|
|
SetRect(&rt, 0, 0, r - l - 3, 1);
|
|
textH = DrawTextW(pnicd->hdc, pDrive->szTitle, -1, &rt, DT_SINGLELINE|DT_CALCRECT|DT_END_ELLIPSIS|DT_MODIFYSTRING);
|
|
textW = rt.right - rt.left;
|
|
pDrive->textSize = (DWORD)MAKELONG(textW, textH);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
textW = LOWORD(pDrive->textSize);
|
|
textH = HIWORD(pDrive->textSize);
|
|
}
|
|
|
|
if (0 == (NCS_FULLROWSELECT & g_navStyle) && ((NIS_SELECTED | NIS_DROPHILITED) & pnicd->itemState))
|
|
{
|
|
rgbOld = SetTextColor(pnicd->hdc, pnicd->clrText);
|
|
rgbBkOld = SetBkColor(pnicd->hdc, pnicd->clrTextBk);
|
|
}
|
|
|
|
if (r > (l + textW + 7)) r = l + textW + 7;
|
|
|
|
SetRect(&rt, l, pnicd->prc->top, r, pnicd->prc->bottom);
|
|
|
|
t = pnicd->prc->top + (pnicd->prc->bottom - pnicd->prc->top - textH)/2;
|
|
ExtTextOutW(pnicd->hdc, rt.left + 2, t, ETO_CLIPPED | ETO_OPAQUE, &rt, pDrive->szTitle, lstrlenW(pDrive->szTitle), 0);
|
|
if (0 == (NCS_FULLROWSELECT & g_navStyle) && (NIS_FOCUSED & pnicd->itemState) &&
|
|
0 == (0x1 /*UISF_HIDEFOCUS*/ & (INT)SendMessageW(MLNavCtrl_GetHWND(plugin.hwndLibraryParent), 0x129 /*WM_QUERYUISTATE*/, 0, 0L)))
|
|
{
|
|
DrawFocusRect(pnicd->hdc, &rt);
|
|
}
|
|
ExcludeClipRect(pnicd->hdc, rt.left, rt.top, rt.right, rt.bottom);
|
|
|
|
|
|
if (0 == (NCS_FULLROWSELECT & g_navStyle) && ((NIS_SELECTED | NIS_DROPHILITED) & pnicd->itemState))
|
|
{
|
|
if (rgbOld != pnicd->clrText) SetTextColor(pnicd->hdc, rgbOld);
|
|
if (rgbBkOld != pnicd->clrTextBk) SetBkColor(pnicd->hdc, rgbBkOld);
|
|
}
|
|
}
|
|
|
|
pDrive->itemWidth = (WORD)(pnicd->prc->right - pnicd->prc->left);
|
|
|
|
if (NCS_FULLROWSELECT & g_navStyle)
|
|
{
|
|
ExtTextOutW(pnicd->hdc, 0, 0, ETO_OPAQUE, pnicd->prc, L"", 0, 0);
|
|
return NICDRF_SKIPDEFAULT;
|
|
}
|
|
else ExcludeClipRect(pnicd->hdc, pnicd->prc->left, pnicd->prc->top, pnicd->prc->right, pnicd->prc->bottom);
|
|
}
|
|
break;
|
|
case NIDS_POSTPAINT:
|
|
break;
|
|
}
|
|
return NICDRF_DODEFAULT;
|
|
}
|
|
|
|
static HNAVITEM hItemActive = NULL;
|
|
|
|
static BOOL GetEjectBtnRect(HNAVITEM hItem, RECT *prc)
|
|
{
|
|
NAVITEMGETRECT navRect;
|
|
navRect.fItem = FALSE;
|
|
navRect.hItem = hItem;
|
|
|
|
if (!hItem || !prc || !MLNavItem_GetRect(plugin.hwndLibraryParent, &navRect)) return FALSE;
|
|
|
|
navRect.rc.right -= 2;
|
|
navRect.rc.left = navRect.rc.right - ICON_SIZE_CX;
|
|
navRect.rc.top += (navRect.rc.bottom - navRect.rc.top - ICON_SIZE_CY)/2;
|
|
navRect.rc.bottom = navRect.rc.top + ICON_SIZE_CY;
|
|
|
|
CopyRect(prc, &navRect.rc);
|
|
return TRUE;
|
|
}
|
|
|
|
static INT_PTR Plugin_OnNavHitTest(HNAVITEM hItem, NAVHITTEST *pnavHitTest, LPARAM lParam)
|
|
{
|
|
DRIVE *pDrive;
|
|
|
|
if (FALSE == DriveParam_IsValid(lParam))
|
|
return FALSE;
|
|
|
|
pDrive = (DRIVE*)lParam;
|
|
|
|
if ((NAVHT_ONITEMRIGHT | NAVHT_ONITEM) & pnavHitTest->flags)
|
|
{
|
|
RECT rb;
|
|
|
|
if (pDrive->bEjectVisible && GetEjectBtnRect(hItem, &rb) &&
|
|
pnavHitTest->pt.x >= rb.left && pnavHitTest->pt.x <= rb.right &&
|
|
pnavHitTest->pt.y >= rb.top && pnavHitTest->pt.y <= rb.bottom)
|
|
{
|
|
pnavHitTest->flags = NAVHT_NOWHERE;
|
|
pnavHitTest->hItem = NULL;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static void CALLBACK NavButton_TimerProc(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
|
|
{
|
|
DRIVE *pDrive;
|
|
POINT pt;
|
|
RECT rb;
|
|
|
|
pDrive = (hItemActive) ? Plugin_GetDriveFromNavItem(hItemActive) : NULL;
|
|
if (!pDrive || (BYTE)BTNSTATE_NORMAL == pDrive->nBtnState || !pDrive->bEjectVisible || !GetEjectBtnRect(hItemActive, &rb))
|
|
{
|
|
KillTimer(NULL, idEvent);
|
|
return;
|
|
}
|
|
|
|
GetCursorPos(&pt);
|
|
MapWindowPoints(HWND_DESKTOP, MLNavCtrl_GetHWND(plugin.hwndLibraryParent), &pt, 1);
|
|
|
|
|
|
if (pt.x < rb.left || pt.x > rb.right || pt.y < rb.top || pt.y > rb.bottom)
|
|
{
|
|
NAVITEMINAVLIDATE inv;
|
|
|
|
KillTimer(NULL, idEvent);
|
|
|
|
inv.fErase = FALSE;
|
|
inv.hItem = hItemActive;
|
|
inv.prc = &rb;
|
|
|
|
hItemActive = NULL;
|
|
pDrive->nBtnState = BTNSTATE_NORMAL;
|
|
|
|
MLNavItem_Invalidate(plugin.hwndLibraryParent, &inv);
|
|
}
|
|
}
|
|
|
|
static INT_PTR Plugin_OnNavSetCursor(HNAVITEM hItem, LPARAM lParam)
|
|
{
|
|
POINT pt;
|
|
DRIVE *pDrive;
|
|
BYTE state;
|
|
RECT rb;
|
|
|
|
if (FALSE == DriveParam_IsValid(lParam))
|
|
return FALSE;
|
|
|
|
pDrive = (DRIVE*)lParam;
|
|
|
|
if (DM_MODE_READY != pDrive->cMode || !pDrive->bEjectVisible || !GetEjectBtnRect(hItem, &rb)) return -1;
|
|
|
|
GetCursorPos(&pt);
|
|
|
|
MapWindowPoints(HWND_DESKTOP, MLNavCtrl_GetHWND(plugin.hwndLibraryParent), &pt, 1);
|
|
if (pt.x >= rb.left && pt.x <= rb.right && pt.y >= rb.top && pt.y <= rb.bottom)
|
|
{
|
|
state = (BYTE)((0x8000 & GetAsyncKeyState( GetSystemMetrics(SM_SWAPBUTTON) ? VK_RBUTTON : VK_LBUTTON)) ?
|
|
BTNSTATE_PRESSED : BTNSTATE_HILITED);
|
|
}
|
|
else state = BTNSTATE_NORMAL;
|
|
|
|
if (pDrive->nBtnState != state)
|
|
{
|
|
|
|
NAVITEMINAVLIDATE inv;
|
|
|
|
if ((BYTE)BTNSTATE_PRESSED == pDrive->nBtnState && BTNSTATE_HILITED == state)
|
|
{
|
|
DriveManager_Eject(pDrive->cLetter, DM_EJECT_CHANGE);
|
|
}
|
|
|
|
if (pDrive->timerId)
|
|
{
|
|
KillTimer(NULL, pDrive->timerId);
|
|
pDrive->timerId = 0;
|
|
}
|
|
if (hItemActive)
|
|
{
|
|
DRIVE *pDriveOld = Plugin_GetDriveFromNavItem(hItemActive);
|
|
if (pDriveOld)
|
|
{
|
|
RECT rb2;
|
|
if (pDriveOld->timerId)
|
|
{
|
|
KillTimer(NULL, pDriveOld->timerId);
|
|
pDriveOld->timerId = NULL;
|
|
}
|
|
if ((BYTE)BTNSTATE_NORMAL != pDriveOld->nBtnState && GetEjectBtnRect(hItemActive, &rb2))
|
|
{
|
|
pDriveOld->nBtnState = BTNSTATE_NORMAL;
|
|
inv.fErase = FALSE;
|
|
inv.hItem = hItemActive;
|
|
inv.prc = &rb2;
|
|
MLNavItem_Invalidate(plugin.hwndLibraryParent, &inv);
|
|
}
|
|
hItemActive = NULL;
|
|
}
|
|
}
|
|
|
|
if (BTNSTATE_NORMAL != state)
|
|
{
|
|
hItemActive = hItem;
|
|
pDrive->timerId = SetTimer(NULL, 0, NAVBUTTON_STATECHECK_DELAY, NavButton_TimerProc);
|
|
}
|
|
|
|
pDrive->nBtnState = state;
|
|
|
|
inv.fErase = FALSE;
|
|
inv.hItem = hItem;
|
|
inv.prc = &rb;
|
|
MLNavItem_Invalidate(plugin.hwndLibraryParent, &inv);
|
|
|
|
}
|
|
|
|
|
|
return -1;
|
|
}
|
|
|
|
static BOOL Plugin_OnConfig(void)
|
|
{
|
|
SendMessageW(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&myPrefsItemCD, IPC_OPENPREFSTOPAGE);
|
|
return TRUE;
|
|
}
|
|
|
|
static INT_PTR pluginMessageProc(int msg, INT_PTR param1, INT_PTR param2, INT_PTR param3)
|
|
{
|
|
HNAVITEM hItem;
|
|
|
|
if (msg >= ML_MSG_TREE_BEGIN && msg <= ML_MSG_TREE_END)
|
|
{
|
|
hItem = (msg < ML_MSG_NAVIGATION_FIRST) ? MLNavCtrl_FindItemById(plugin.hwndLibraryParent, param1) : (HNAVITEM)param1;
|
|
if (!hItem) return 0;
|
|
} else hItem = NULL;
|
|
|
|
switch (msg)
|
|
{
|
|
case ML_MSG_TREE_ONCREATEVIEW: return (INT_PTR)Plugin_OnViewCreate(hItem, (HWND)param2);
|
|
case ML_MSG_NAVIGATION_ONDELETE: return (INT_PTR)Plugin_OnNavItemDelete(hItem);
|
|
case ML_MSG_NAVIGATION_ONCUSTOMDRAW: return (INT_PTR)Plugin_OnNavCustomDraw(hItem, (NAVITEMDRAW*)param2, (LPARAM)param3);
|
|
case ML_MSG_NAVIGATION_ONHITTEST: return (INT_PTR)Plugin_OnNavHitTest(hItem, (NAVHITTEST*)param2, (LPARAM)param3);
|
|
case ML_MSG_NAVIGATION_ONSETCURSOR: return (INT_PTR)Plugin_OnNavSetCursor(hItem, (LPARAM)param3);
|
|
case ML_MSG_NAVIGATION_CONTEXTMENU:
|
|
{
|
|
DRIVE *pDrive;
|
|
if (hniMain && (hItem == hniMain))
|
|
return Root_OnContextMenu(hItem, (HWND)param2, MAKEPOINTS(param3));
|
|
|
|
//Plugin Item
|
|
pDrive = Plugin_GetDriveFromNavItem(hItem);
|
|
if (pDrive)
|
|
return Plugin_OnContextMenu(hItem, (HWND)param2, MAKEPOINTS(param3), pDrive->cLetter);
|
|
|
|
return 0;
|
|
}
|
|
case ML_MSG_TREE_ONCLICK: return (INT_PTR)Plugin_OnNavItemClick(hItem, (UINT)param2, (HWND)param3);
|
|
case ML_MSG_CONFIG: return (INT_PTR)Plugin_OnConfig();
|
|
case ML_MSG_MLVISIBLE: Plugin_OnMLVisible((BOOL)param1); break;
|
|
case ML_MSG_NOTOKTOQUIT: if (!Plugin_QueryOkToQuit()) { return TRUE; } break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
extern "C" winampMediaLibraryPlugin plugin =
|
|
{
|
|
MLHDR_VER,
|
|
"nullsoft(ml_disc.dll)",
|
|
Init,
|
|
Quit,
|
|
pluginMessageProc,
|
|
0,
|
|
0,
|
|
0,
|
|
};
|
|
|
|
extern "C" __declspec(dllexport) winampMediaLibraryPlugin *winampGetMediaLibraryPlugin()
|
|
{
|
|
return &plugin;
|
|
} |