winamp/Src/omBrowser/mlNavigationHelper.cpp

599 lines
14 KiB
C++
Raw Permalink Normal View History

2024-09-24 12:54:57 +00:00
#include "main.h"
#include "./mlNavigationHelper.h"
#include "./ifc_omcachemanager.h"
#include "./ifc_omcachegroup.h"
#include "./ifc_omcacherecord.h"
#include "./ifc_mlnavigationcallback.h"
#include "./resource.h"
#include "./ifc_wasabihelper.h"
#include "../Plugins/General/gen_ml/ml.h"
#define _ML_HEADER_IMPMLEMENT
#include "../Plugins/General/gen_ml/ml_ipc_0313.h"
#undef _ML_HEADER_IMPMLEMENT
#include <shlwapi.h>
#include <strsafe.h>
#include <algorithm>
MlNavigationHelper::MlNavigationHelper(HWND hLibraryWnd, ifc_omcachegroup *cacheGroup)
: ref(1), hLibrary(hLibraryWnd), defaultIndex(-1), cacheGroup(cacheGroup), lastCookie(0)
{
InitializeCriticalSection(&lock);
if (NULL != cacheGroup)
cacheGroup->AddRef();
}
MlNavigationHelper::~MlNavigationHelper()
{
EnterCriticalSection(&lock);
for(CallbackMap::iterator iter = callbackMap.begin(); iter != callbackMap.end(); iter++)
{
ifc_mlnavigationcallback *callback = iter->second;
if (NULL != callback) callback->Release();
}
size_t index = recordList.size();
while(index--)
{
Plugin_FreeString(recordList[index].name);
}
if (NULL != cacheGroup)
cacheGroup->Release();
LeaveCriticalSection(&lock);
DeleteCriticalSection(&lock);
}
HRESULT MlNavigationHelper::CreateInstance(HWND hLibrary, ifc_omcachemanager *cacheManager, MlNavigationHelper **instance)
{
if (NULL == instance) return E_POINTER;
if (NULL == hLibrary || FALSE == IsWindow(hLibrary) || NULL == cacheManager)
{
*instance = NULL;
return E_INVALIDARG;
}
ifc_omcachegroup *group = NULL;
HRESULT hr = cacheManager->Find(L"icons", TRUE, &group, NULL);
if (SUCCEEDED(hr) && group != NULL)
{
*instance = new MlNavigationHelper(hLibrary, group);
if (NULL == *instance)
{
hr = E_OUTOFMEMORY;
}
group->Release();
}
return hr;
}
size_t MlNavigationHelper::AddRef()
{
return InterlockedIncrement((LONG*)&ref);
}
size_t MlNavigationHelper::Release()
{
if (0 == ref)
return ref;
LONG r = InterlockedDecrement((LONG*)&ref);
if (0 == r)
delete(this);
return r;
}
int MlNavigationHelper::QueryInterface(GUID interface_guid, void **object)
{
if (NULL == object) return E_POINTER;
if (IsEqualIID(interface_guid, IFC_MlNavigationHelper))
*object = static_cast<ifc_mlnavigationhelper*>(this);
else
{
*object = NULL;
return E_NOINTERFACE;
}
if (NULL == *object)
return E_UNEXPECTED;
AddRef();
return S_OK;
}
HRESULT MlNavigationHelper::GetDefaultIndex(int *index)
{
if (NULL == index)
return E_POINTER;
EnterCriticalSection(&lock);
if (-1 == defaultIndex)
{
WCHAR szPath[MAX_PATH] = {0};
HRESULT hr = Plugin_MakeResourcePath(szPath, ARRAYSIZE(szPath), Plugin_GetInstance(),
RT_RCDATA, MAKEINTRESOURCE(IDR_SERVICEICON_IMAGE), RESPATH_COMPACT);
if (SUCCEEDED(hr))
{
UpdateImageList(szPath, &defaultIndex);
}
}
*index = defaultIndex;
LeaveCriticalSection(&lock);
return S_OK;
}
HRESULT MlNavigationHelper::UpdateImageList(LPCWSTR address, INT *index)
{
if (NULL == address || NULL == index)
{
if (NULL != index) *index = -1;
return E_INVALIDARG;
}
HMLIMGLST hmlil = MLNavCtrl_GetImageList(hLibrary);
if (NULL == hmlil) return E_UNEXPECTED;
MLIMAGESOURCE source = {0};
source.cbSize = sizeof(source);
source.lpszName = address;
source.type = SRC_TYPE_PNG;
source.bpp = 24;
source.flags = ISF_LOADFROMFILE | ISF_FORCE_BPP | ISF_PREMULTIPLY;
MLIMAGELISTIMAGESIZE imageSize = {0};
imageSize.hmlil = hmlil;
if (FALSE != MLImageList_GetImageSize(hLibrary, &imageSize))
{
source.cxDst = imageSize.cx;
source.cyDst = imageSize.cy;
source.flags |= ISF_FORCE_SIZE | ISF_SCALE;
}
if (FALSE == MLImageLoader_CheckExist(hLibrary, &source))
return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
MLIMAGELISTITEM item = {0};
item.cbSize = sizeof(item);
item.hmlil = hmlil;
item.filterUID = MLIF_FILTER3_UID;
item.pmlImgSource = &source;
HRESULT hr = S_OK;
INT iImage = *index;
if (iImage >= 0)
{
INT imageCount = MLImageList_GetImageCount(hLibrary, item.hmlil);
if (iImage >= imageCount) iImage = -1;
}
if (iImage >=0)
{
item.mlilIndex = iImage;
if (FALSE == MLImageList_Replace(hLibrary, &item))
hr = E_FAIL;
}
else
{
iImage = MLImageList_Add(hLibrary, &item);
if (-1 == iImage) hr = E_FAIL;
}
*index = iImage;
return hr;
}
HRESULT MlNavigationHelper::ImageLocator(LPCWSTR address, INT *index)
{
if (NULL == address) return E_INVALIDARG;
HRESULT hr;
BOOL runtimeOnly = TRUE;
if (PathIsURL(address) &&
CSTR_EQUAL != CompareString(CSTR_INVARIANT, NORM_IGNORECASE, address, 6, L"res://", -1))
{
runtimeOnly = FALSE;
}
else
{
hr = UpdateImageList(address, index);
if (HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) != hr)
return hr;
}
BOOL fCreated = FALSE;
ifc_omcacherecord *cacheRecord = NULL;
hr = cacheGroup->Find(address, TRUE, &cacheRecord, &fCreated);
if (SUCCEEDED(hr) && cacheRecord != NULL)
{
cacheRecord->RegisterCallback(this);
if (FALSE != fCreated && FALSE != runtimeOnly)
{
cacheRecord->SetFlags(ifc_omcacherecord::flagNoStore, ifc_omcacherecord::flagNoStore);
}
WCHAR szBuffer[MAX_PATH * 2] = {0};
if (SUCCEEDED(cacheRecord->GetPath(szBuffer, ARRAYSIZE(szBuffer))))
{
hr = UpdateImageList(szBuffer, index);
}
cacheRecord->Release();
}
return hr;
}
HRESULT MlNavigationHelper::QueryIndex(LPCWSTR pszName, INT *index, BOOL *defaultUsed)
{
if (NULL == cacheGroup)
return E_UNEXPECTED;
if (NULL == index)
{
if (NULL != defaultUsed) *defaultUsed = FALSE;
return E_POINTER;
}
if (NULL == pszName || L'\0' == *pszName)
{
if (SUCCEEDED(GetDefaultIndex(index)))
{
if (NULL != defaultUsed) *defaultUsed = TRUE;
}
else
{
*index = 0;
if (NULL != defaultUsed) *defaultUsed = FALSE;
}
return S_OK;
}
EnterCriticalSection(&lock);
RECORD *record = Find(pszName);
if (NULL == record)
{ // create new
RECORD rec = {0};
size_t index = recycledList.size();
if (0 != index)
{
rec.index = recycledList[index - 1];
recycledList.pop_back();
}
else
{
rec.index = -1;
}
rec.ref = 1;
rec.name = Plugin_CopyString(pszName);
recordList.push_back(rec);
Sort();
// locate record again;
record = Find(pszName);
ImageLocator(record->name, &record->index);
}
else
{
record->ref++;
if (-1 == record->index)
ImageLocator(record->name, &record->index);
}
if(-1 == record->index)
{
if (SUCCEEDED(GetDefaultIndex(index)) && NULL != defaultUsed)
*defaultUsed = TRUE;
}
else
{
*index = record->index;
}
LeaveCriticalSection(&lock);
return S_OK;
}
HRESULT MlNavigationHelper::ReleaseIndex(LPCWSTR pszName)
{
if(NULL == pszName || L'\0' == *pszName)
return E_INVALIDARG;
EnterCriticalSection(&lock);
RECORD *record = Find(pszName);
if (NULL != record)
{
record->ref--;
if (0 == record->ref)
{
if (-1 != record->index)
recycledList.push_back(record->index);
Plugin_FreeString(record->name);
record->name = NULL;
size_t index = recordList.size();
while(index--)
{
if (&recordList[index] == record)
{
recordList.erase(recordList.begin() + index);
break;
}
}
}
}
LeaveCriticalSection(&lock);
return (NULL != record) ? S_OK : S_FALSE;
}
HRESULT MlNavigationHelper::RegisterAlias(LPCWSTR pszName, LPCWSTR pszAddress)
{
if (NULL == cacheGroup)
return E_UNEXPECTED;
BOOL fCreated = FALSE;
ifc_omcacherecord *record = NULL;
HRESULT hr = cacheGroup->Find(pszName, TRUE, &record, &fCreated);
if (SUCCEEDED(hr) && record != NULL)
{
if (FALSE != fCreated)
{
record->SetFlags(ifc_omcacherecord::flagNoStore, ifc_omcacherecord::flagNoStore);
}
hr = record->SetPath(pszAddress);
record->RegisterCallback(this);
record->Release();
}
return hr;
}
HWND MlNavigationHelper::GetLibrary()
{
return hLibrary;
}
typedef struct __CACHECHANGEAPCPARAM
{
MlNavigationHelper *instance;
ifc_omcacherecord *record;
} CACHECHANGEAPCPARAM;
static void CALLBACK MlNavigationHelper_CacheRecordPathChangedApc(ULONG_PTR data)
{
CACHECHANGEAPCPARAM *param = (CACHECHANGEAPCPARAM*)data;
if (NULL != param)
{
if (NULL != param->instance)
{
param->instance->CacheRecordPathChangedApc(param->record);
param->instance->Release();
}
if (NULL != param->record)
param->record->Release();
free(param);
}
}
void MlNavigationHelper::CacheRecordPathChanged(ifc_omcacherecord *cacheRecord)
{
if (NULL == cacheRecord)
return;
HRESULT hr = E_FAIL;
CACHECHANGEAPCPARAM *param = (CACHECHANGEAPCPARAM*)calloc(1, sizeof(CACHECHANGEAPCPARAM));
if (NULL != param)
{
param->instance = this;
param->instance->AddRef();
param->record = cacheRecord;
param->record->AddRef();
ifc_wasabihelper *wasabi = NULL;
if (SUCCEEDED(Plugin_GetWasabiHelper(&wasabi)) && wasabi != NULL)
{
api_application *application = NULL;
if (SUCCEEDED(wasabi->GetApplicationApi(&application)) && application != NULL)
{
HANDLE hThread = application->main_getMainThreadHandle();
if (NULL != hThread &&
0 != QueueUserAPC(MlNavigationHelper_CacheRecordPathChangedApc, hThread, (ULONG_PTR)param))
{
hr = S_OK;
}
application->Release();
}
wasabi->Release();
}
if (FAILED(hr))
{
if (NULL != param->instance) param->instance->Release();
if (NULL != param->record) param->record->Release();
free(param);
param = NULL;
}
}
}
void MlNavigationHelper::CacheRecordPathChangedApc(ifc_omcacherecord *cacheRecord)
{
if (NULL == cacheRecord)
return;
WCHAR szBuffer[1024] = {0};
if (FAILED(cacheRecord->GetName(szBuffer, ARRAYSIZE(szBuffer))))
return;
EnterCriticalSection(&lock);
RECORD *record = Find(szBuffer);
if (NULL != record &&
SUCCEEDED(cacheRecord->GetPath(szBuffer, ARRAYSIZE(szBuffer))) &&
SUCCEEDED(UpdateImageList(szBuffer, &record->index)))
{
for(CallbackMap::iterator iter = callbackMap.begin(); iter != callbackMap.end(); iter++)
{
ifc_mlnavigationcallback *callback = iter->second;
callback->ImageChanged(record->name, record->index);
}
}
LeaveCriticalSection(&lock);
}
HRESULT MlNavigationHelper::RegisterCallback(ifc_mlnavigationcallback *callback, UINT *cookie)
{
if (NULL == cookie) return E_POINTER;
*cookie = 0;
if (NULL == callback)
return E_INVALIDARG;
EnterCriticalSection(&lock);
*cookie = ++lastCookie;
callbackMap.insert({ *cookie, callback });
callback->AddRef();
LeaveCriticalSection(&lock);
return S_OK;
}
HRESULT MlNavigationHelper::UnregisterCallback(UINT cookie)
{
if (0 == cookie) return E_INVALIDARG;
ifc_mlnavigationcallback *callback = NULL;
EnterCriticalSection(&lock);
for(CallbackMap::iterator iter = callbackMap.begin(); iter != callbackMap.end(); iter++)
{
if (cookie == iter->first)
{
callback = iter->second;
callbackMap.erase(iter);
break;
}
}
LeaveCriticalSection(&lock);
if (NULL != callback)
{
callback->Release();
return S_OK;
}
return S_FALSE;
}
__inline static int __cdecl MlNavigationHelper_RecordComparer(const void *elem1, const void *elem2)
{
LPCWSTR s1 = ((MlNavigationHelper::RECORD*)elem1)->name;
LPCWSTR s2 = ((MlNavigationHelper::RECORD*)elem2)->name;
if (NULL == s1 || NULL == s2) return ((INT)(ULONG_PTR)(s1 - s2));
return CompareString(CSTR_INVARIANT, NORM_IGNORECASE, s1, -1, s2, -1) - 2;
}
__inline static int __cdecl MlNavigationHelper_RecordComparer_V2(const void* elem1, const void* elem2)
{
return MlNavigationHelper_RecordComparer(elem1, elem2) < 0;
}
__inline static int __cdecl MlNavigationHelper_RecordSearch(const void *elem1, const void *elem2)
{
LPCWSTR s1 = (LPCWSTR)elem1;
LPCWSTR s2 = ((MlNavigationHelper::RECORD*)elem2)->name;
if (NULL == s1 || NULL == s2) return ((INT)(ULONG_PTR)(s1 - s2));
INT r = CompareString(CSTR_INVARIANT, NORM_IGNORECASE, s1, -1, s2, -1) - 2;
return r;
}
HRESULT MlNavigationHelper::Sort()
{
HRESULT hr;
if (recordList.size() < 2)
{
hr = S_FALSE;
}
else
{
//qsort(recordList.begin(), recordList.size(), sizeof(RECORD), MlNavigationHelper_RecordComparer);
std::sort(recordList.begin(), recordList.end(),
[&](RECORD lhs, RECORD rhs) -> bool
{
return MlNavigationHelper_RecordComparer_V2(&lhs, &rhs);
}
);
hr = S_OK;
}
return hr;
}
MlNavigationHelper::RECORD *MlNavigationHelper::Find(LPCWSTR pszName)
{
if (0 == recordList.size())
return NULL;
//return (RECORD*)bsearch(pszName, recordList.begin(), recordList.size(),
// sizeof(RECORD), MlNavigationHelper_RecordSearch);
auto it = std::find_if(recordList.begin(), recordList.end(),
[&](RECORD upT) -> bool
{
return MlNavigationHelper_RecordSearch(pszName, &upT) == 0;
}
);
if (it == recordList.end())
{
return NULL;
}
return &(* it);
}
#define CBCLASS MlNavigationHelper
START_MULTIPATCH;
START_PATCH(MPIID_MLNAVIGATIONHELPER)
M_CB(MPIID_MLNAVIGATIONHELPER, ifc_mlnavigationhelper, ADDREF, AddRef);
M_CB(MPIID_MLNAVIGATIONHELPER, ifc_mlnavigationhelper, RELEASE, Release);
M_CB(MPIID_MLNAVIGATIONHELPER, ifc_mlnavigationhelper, QUERYINTERFACE, QueryInterface);
M_CB(MPIID_MLNAVIGATIONHELPER, ifc_mlnavigationhelper, API_GETDEFAULTINDEX, GetDefaultIndex);
M_CB(MPIID_MLNAVIGATIONHELPER, ifc_mlnavigationhelper, API_QUERYINDEX, QueryIndex);
M_CB(MPIID_MLNAVIGATIONHELPER, ifc_mlnavigationhelper, API_RELEASEINDEX, ReleaseIndex);
M_CB(MPIID_MLNAVIGATIONHELPER, ifc_mlnavigationhelper, API_REGISTERALIAS, RegisterAlias);
M_CB(MPIID_MLNAVIGATIONHELPER, ifc_mlnavigationhelper, API_REGISTERCALLBACK, RegisterCallback);
M_CB(MPIID_MLNAVIGATIONHELPER, ifc_mlnavigationhelper, API_UNREGISTERCALLBACK, UnregisterCallback);
NEXT_PATCH(MPIID_OMCACHECALLBACK)
M_CB(MPIID_OMCACHECALLBACK, ifc_omcachecallback, ADDREF, AddRef);
M_CB(MPIID_OMCACHECALLBACK, ifc_omcachecallback, RELEASE, Release);
M_CB(MPIID_OMCACHECALLBACK, ifc_omcachecallback, QUERYINTERFACE, QueryInterface);
M_VCB(MPIID_OMCACHECALLBACK, ifc_omcachecallback, API_PATHCHANGED, CacheRecordPathChanged);
END_PATCH
END_MULTIPATCH;
#undef CBCLASS