diff options
Diffstat (limited to 'Src/Plugins/Library/ml_local')
91 files changed, 29441 insertions, 0 deletions
diff --git a/Src/Plugins/Library/ml_local/AlbumArtCache.cpp b/Src/Plugins/Library/ml_local/AlbumArtCache.cpp new file mode 100644 index 00000000..6478c009 --- /dev/null +++ b/Src/Plugins/Library/ml_local/AlbumArtCache.cpp @@ -0,0 +1,508 @@ +#include "main.h" +#include <nde/nde_c.h> +#include "../nu/threadname.h" +#include "AlbumArtContainer.h" +#include <tataki/bitmap/bitmap.h> +#include "MD5.h" +#include "../replicant/nu/AutoLock.h" +#include <strsafe.h> +#include <map> +#include <deque> + +static bool GetArtFromCache(const wchar_t *filename, int size, ARGB32 **bits); +static bool SetArtCache(const wchar_t *filename, int size, const ARGB32 *bits, uint8_t hash[16]); +static void CloseArtCache(); +static HANDLE artWake=0; +static HANDLE mainThread=0; + +struct CreateCacheParameters +{ + AlbumArtContainer *container; + int w; + int h; + SkinBitmap *cache; + AlbumArtContainer::CacheStatus status; +}; + +static std::deque<CreateCacheParameters*> artQueue; +static nu::LockGuard queueGuard; + +static void Adjust(int bmpw, int bmph, int &x, int &y, int &w, int &h) +{ + // maintain 'square' stretching + double aspX = (double)(w)/(double)bmpw; + double aspY = (double)(h)/(double)bmph; + double asp = min(aspX, aspY); + int newW = (int)(bmpw*asp); + int newH = (int)(bmph*asp); + x = (w - newW)/2; + y = (h - newH)/2; + w = newW; + h = newH; +} + +static void CALLBACK CreateCacheCallbackAPC(ULONG_PTR parameter) +{ + CreateCacheParameters *parameters = (CreateCacheParameters *)parameter; + parameters->container->SetCache(parameters->cache, parameters->status); + parameters->container->Release(); + WASABI_API_MEMMGR->sysFree(parameters); +} + +static void CreateCache(CreateCacheParameters *parameters) +{ + // let's hope this doesn't overflow the stack + const wchar_t *filename = parameters->container->filename; + + if ((unsigned int)(ULONG_PTR)filename < 65536) + { + parameters->cache = 0; + parameters->status = AlbumArtContainer::CACHE_NOTFOUND; + QueueUserAPC(CreateCacheCallbackAPC, mainThread, (ULONG_PTR)parameters); + return; + } + + int w = parameters->w, h = parameters->h; + + ARGB32 *cacheBits = 0; + if (GetArtFromCache(filename, w, &cacheBits)) + { + SkinBitmap *cache = new SkinBitmap(cacheBits, w, h, true); + parameters->cache = cache; + parameters->status = AlbumArtContainer::CACHE_CACHED; + } + else + { + int artsize = w; + int bmp_w = 0, bmp_h = 0; + ARGB32 *bits = 0; + + if (AGAVE_API_ALBUMART && AGAVE_API_ALBUMART->GetAlbumArt(filename, L"Cover", &bmp_w, &bmp_h, &bits) == ALBUMART_SUCCESS) + { + uint8_t hash[16] = {0}; + MD5_CTX hashCtx; + MD5Init(&hashCtx); + MD5Update(&hashCtx, (uint8_t *)bits, bmp_w*bmp_h*sizeof(ARGB32)); + MD5Final(hash, &hashCtx); + + BltCanvas canvas(w,h); + HQSkinBitmap temp(bits, bmp_w,bmp_h); // wrap into a SkinBitmap (no copying involved) + int x = 0, y = 0; + Adjust(bmp_w, bmp_h, x,y,w,h); + temp.stretch(&canvas,x,y,w,h); + SkinBitmap *cache = new SkinBitmap(&canvas); + parameters->cache = cache; + SetArtCache(filename, artsize, (ARGB32 *)canvas.getBits(), hash); + WASABI_API_MEMMGR->sysFree(bits); + parameters->status = AlbumArtContainer::CACHE_CACHED; + } + else + { + parameters->cache = 0; + parameters->status = AlbumArtContainer::CACHE_NOTFOUND; + } + } + QueueUserAPC(CreateCacheCallbackAPC, mainThread, (ULONG_PTR)parameters); + return; +} + +static int ArtLoadThread(HANDLE handle, void *user_data, intptr_t id) +{ + // TODO? SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_IDLE); + + queueGuard.Lock(); + if (artQueue.empty()) + { + queueGuard.Unlock(); + return 0; + } + + CreateCacheParameters *parameters = artQueue.front(); + artQueue.pop_front(); + queueGuard.Unlock(); + CreateCache(parameters); + return 0; +} + +enum +{ + ARTHASH_FILENAME = 0, + ARTHASH_HASH = 1, + + ARTTABLE_HASH = 0, + ARTTABLE_ARGB32 = 1, +}; + +typedef std::map<int, nde_table_t> ArtCache; +static ArtCache artcache; +static nde_database_t art_db = 0; +static nde_table_t artHashes = 0; + +static ThreadID *artThread=0; +static void InitArtThread() +{ + if (!artThread) + { + artWake = CreateSemaphore(0, 0, 65536, 0); + mainThread = WASABI_API_APP->main_getMainThreadHandle(); + artThread = WASABI_API_THREADPOOL->ReserveThread(0); + WASABI_API_THREADPOOL->AddHandle(artThread, artWake, ArtLoadThread, 0, 0, 0); + } +} + +static int ArtKillThreadPoolFunc(HANDLE handle, void *user_data, intptr_t id) +{ + WASABI_API_THREADPOOL->RemoveHandle(artThread, artWake); + CloseArtCache(); + SetEvent((HANDLE)user_data); + return 0; +} + +void KillArtThread() +{ + if (artThread) + { + HANDLE artKill = CreateEvent(0, FALSE, FALSE, 0); + WASABI_API_THREADPOOL->RunFunction(artThread, ArtKillThreadPoolFunc, (void *)artKill, 0, 0); + WaitForSingleObject(artKill, INFINITE); + CloseHandle(mainThread); mainThread = 0; + CloseHandle(artKill); artKill = 0; + CloseHandle(artWake); artWake = 0; + WASABI_API_THREADPOOL->ReleaseThread(artThread); + } +} + +void MigrateArtCache() +{ + int size[] = {0, 60, 90, 120, 180}; + + for (int i = 0; i < sizeof(size)/sizeof(size[0]); i++) + { + if (!size[i]) + { + const wchar_t *inidir = WASABI_API_APP->path_getUserSettingsPath(); + art_db = NDE_CreateDatabase(plugin.hDllInstance); + wchar_t tableName[MAX_PATH] = {0}, oldTableName[MAX_PATH] = {0}, indexName[MAX_PATH] = {0}, oldIndexName[MAX_PATH] = {0}; + PathCombineW(oldIndexName, inidir, L"Plugins\\ml"); + PathCombineW(indexName, inidir, L"Plugins\\ml\\art"); + CreateDirectoryW(indexName, NULL); + PathCombineW(tableName, indexName, L"art.dat"); + PathCombineW(oldTableName, oldIndexName, L"art.dat"); + PathAppendW(indexName, L"art.idx"); + PathAppendW(oldIndexName, L"art.idx"); + + // migrate files to their own 'art' sub-folder + if (PathFileExistsW(oldIndexName) && !PathFileExistsW(indexName)) + { + MoveFileW(oldIndexName, indexName); + MoveFileW(oldTableName, tableName); + } + } + else if (size[i]) + { + const wchar_t *inidir = WASABI_API_APP->path_getUserSettingsPath(); + wchar_t temp[MAX_PATH] = {0}, tableName[MAX_PATH] = {0}, oldTableName[MAX_PATH] = {0}, indexName[MAX_PATH] = {0}, oldIndexName[MAX_PATH] = {0}; + PathCombineW(temp, inidir, L"Plugins\\ml"); + StringCchPrintfW(tableName, MAX_PATH, L"%s\\art\\art_%d.dat", temp, size[i]); + StringCchPrintfW(oldTableName, MAX_PATH, L"%s\\art_%d.dat", temp, size[i]); + StringCchPrintfW(indexName, MAX_PATH, L"%s\\art\\art_%d.idx", temp, size[i]); + StringCchPrintfW(oldIndexName, MAX_PATH, L"%s\\art_%d.idx", temp, size[i]); + + // migrate files to their own 'art' sub-folder + if (PathFileExistsW(oldIndexName) && !PathFileExistsW(indexName)) + { + MoveFileW(oldIndexName, indexName); + MoveFileW(oldTableName, tableName); + } + } + } +} + +static bool InitArtCache(int size) +{ + if (!art_db) + { + const wchar_t *inidir = WASABI_API_APP->path_getUserSettingsPath(); + art_db = NDE_CreateDatabase(plugin.hDllInstance); + wchar_t tableName[MAX_PATH] = {0}, indexName[MAX_PATH] = {0}; + PathCombineW(indexName, inidir, L"Plugins\\ml\\art"); + PathCombineW(tableName, indexName, L"art.dat"); + PathAppendW(indexName, L"art.idx"); + + artHashes = NDE_Database_OpenTable(art_db, tableName, indexName, NDE_OPEN_ALWAYS, NDE_CACHE); + NDE_Table_NewColumnW(artHashes, ARTHASH_FILENAME, DB_FIELDNAME_filename, FIELD_FILENAME); + NDE_Table_NewColumnW(artHashes, ARTHASH_HASH, L"hash", FIELD_INT128); + NDE_Table_PostColumns(artHashes); + NDE_Table_AddIndexByIDW( artHashes, ARTHASH_FILENAME, DB_FIELDNAME_filename ); + } + + if (size && !artcache[size]) + { + const wchar_t *inidir = WASABI_API_APP->path_getUserSettingsPath(); + wchar_t temp[MAX_PATH] = {0}, tableName[MAX_PATH] = {0}, indexName[MAX_PATH] = {0}; + PathCombineW(temp, inidir, L"Plugins\\ml"); + StringCchPrintfW(tableName, MAX_PATH, L"%s\\art\\art_%d.dat", temp, size); + StringCchPrintfW(indexName, MAX_PATH, L"%s\\art\\art_%d.idx", temp, size); + + nde_table_t artTable = NDE_Database_OpenTable(art_db, tableName, indexName, NDE_OPEN_ALWAYS, NDE_NOCACHE); + NDE_Table_NewColumnW(artTable, ARTTABLE_HASH, L"hash", FIELD_INT128); + NDE_Table_NewColumnW(artTable, ARTTABLE_ARGB32, L"art", FIELD_BINARY32); + NDE_Table_PostColumns(artTable); + NDE_Table_AddIndexByIDW(artTable, ARTTABLE_HASH, L"hash"); + artcache[size] = artTable; + } + else + return artHashes != 0; + + return artcache[size] != 0; +} +static void CloseArtHashes() +{ + __try + { + if (artHashes) + { + NDE_Database_CloseTable(art_db, artHashes); + } + artHashes = 0; + + NDE_DestroyDatabase(art_db); + art_db = 0; + } + __except (EXCEPTION_EXECUTE_HANDLER) + { + artHashes = 0; + art_db = 0; + } +} +static void CloseArtCache() +{ + ArtCache::iterator itr; + for (itr = artcache.begin(); itr != artcache.end(); itr++) + { + if (itr->second) + NDE_Database_CloseTable(art_db, itr->second); + itr->second = 0; + } + artcache.clear(); + + CloseArtHashes(); +} +/* +@param size = art dimensions. e.g. size==120 is for 120x120 album art +@param bits better be allocated to size*size*sizeof(ARGB32) or you're in for a world of hurt +*/ +static bool GetArtFromCache(const wchar_t *filename, int size, ARGB32 **bits) +{ + if (InitArtCache(size)) + { + nde_scanner_t hashscanner = NDE_Table_CreateScanner(artHashes); + if (NDE_Scanner_LocateFilename(hashscanner, ARTHASH_FILENAME, FIRST_RECORD, filename)) + { + nde_field_t field = NDE_Scanner_GetFieldByID(hashscanner, ARTHASH_HASH); + if (field) + { + nde_scanner_t artscanner = NDE_Table_CreateScanner(artcache[size]); + if (NDE_Scanner_LocateField(artscanner, ARTTABLE_HASH, FIRST_RECORD, field)) + { + nde_field_t field = NDE_Scanner_GetFieldByID(artscanner, ARTTABLE_ARGB32); + if (field) + { + size_t len = 0; + void *data = NDE_BinaryField_GetData(field, &len); + if (data && len == size*size*sizeof(ARGB32)) + { + *bits = (ARGB32 *)WASABI_API_MEMMGR->sysMalloc(len); + memcpy(*bits, data, len); + NDE_Table_DestroyScanner(artcache[size], artscanner); + NDE_Table_DestroyScanner(artHashes, hashscanner); + return true; + } + } + } + NDE_Table_DestroyScanner(artcache[size], artscanner); + } + } + NDE_Table_DestroyScanner(artHashes, hashscanner); + } + return false; +} + +static bool SetArtCache(const wchar_t *filename, int size, const ARGB32 *bits, uint8_t hash[16]) +{ + if (InitArtCache(size)) + { + nde_scanner_t hashscanner = NDE_Table_CreateScanner(artHashes); + if (!NDE_Scanner_LocateFilename(hashscanner, ARTHASH_FILENAME, FIRST_RECORD, filename)) + { + NDE_Scanner_New(hashscanner); + db_setFieldStringW(hashscanner, ARTHASH_FILENAME, filename); + } + else + NDE_Scanner_Edit(hashscanner); + + nde_field_t field = NDE_Scanner_GetFieldByID(hashscanner, ARTHASH_HASH); + if (!field) + field = NDE_Scanner_NewFieldByID(hashscanner, ARTHASH_HASH); + NDE_Int128Field_SetValue(field, hash); + + NDE_Scanner_Post(hashscanner); + + nde_scanner_t artscanner = NDE_Table_CreateScanner(artcache[size]); + if (!NDE_Scanner_LocateField(artscanner, ARTTABLE_HASH, FIRST_RECORD, field)) + { + NDE_Scanner_New(artscanner); + field = NDE_Scanner_NewFieldByID(artscanner, ARTTABLE_HASH); + NDE_Int128Field_SetValue(field, hash); + field = NDE_Scanner_NewFieldByID(artscanner, ARTTABLE_ARGB32); + // TODO when size is possibly zero, this is causing a crash in nde.dll + if (size > 0) NDE_BinaryField_SetData(field, bits, size*size*sizeof(ARGB32)); + NDE_Scanner_Post(artscanner); + NDE_Table_DestroyScanner(artcache[size], artscanner); + NDE_Table_DestroyScanner(artHashes, hashscanner); + NDE_Table_Sync(artHashes); + return true; + } + NDE_Table_DestroyScanner(artcache[size], artscanner); + NDE_Table_DestroyScanner(artHashes, hashscanner); + NDE_Table_Sync(artHashes); + } + + return false; +} + +size_t maxCache = 65536/*100*/; +void HintCacheSize(int _cachesize) +{ + maxCache = _cachesize; +} + +void CreateCache(AlbumArtContainer *container, int w, int h) +{ + InitArtThread(); + assert(artThread); + container->AddRef(); + CreateCacheParameters *parameters = (CreateCacheParameters *)WASABI_API_MEMMGR->sysMalloc(sizeof(CreateCacheParameters)); + parameters->container = container; + parameters->w = w; + parameters->h = h; + parameters->status = AlbumArtContainer::CACHE_UNKNOWN; + nu::AutoLock lock(queueGuard); + if (artQueue.size() > maxCache) + { + CreateCacheParameters *kill = artQueue.back(); + artQueue.pop_back(); + kill->cache = 0; + kill->status = AlbumArtContainer::CACHE_UNKNOWN; + QueueUserAPC(CreateCacheCallbackAPC, mainThread, (ULONG_PTR)kill); + } + artQueue.push_front(parameters); + ReleaseSemaphore(artWake, 1, 0); +} + +void FlushCache() +{ + nu::AutoLock lock(queueGuard); + while (!artQueue.empty()) + { + CreateCacheParameters *kill = artQueue.front(); + kill->container->SetCache(0, AlbumArtContainer::CACHE_UNKNOWN); + artQueue.pop_front(); + WASABI_API_MEMMGR->sysFree(kill); + } +} + +void ResumeCache() +{ +} + +static int ClearFilenameCacheAPC(HANDLE handle, void *param, intptr_t id) +{ + wchar_t *filename = (wchar_t *)param; + + if (InitArtCache(0)) + { + nde_scanner_t hashscanner = NDE_Table_CreateScanner(artHashes); + if (NDE_Scanner_LocateNDEFilename(hashscanner, ARTHASH_FILENAME, FIRST_RECORD, filename)) + { + nde_field_t field = NDE_Scanner_GetFieldByID(hashscanner, ARTHASH_HASH); + if (field) + { + nde_scanner_t deleteAllScanner = NDE_Table_CreateScanner(artHashes); + while (NDE_Scanner_LocateField(deleteAllScanner, ARTHASH_HASH, FIRST_RECORD, field)) + { + NDE_Scanner_Delete(deleteAllScanner); + NDE_Scanner_Post(deleteAllScanner); + } + NDE_Table_DestroyScanner(artHashes, deleteAllScanner); + NDE_Table_Sync(artHashes); + + /* delete it from the art table as well, but we'll just + use the already-opened ones */ + for (ArtCache::iterator itr=artcache.begin();itr!=artcache.end();itr++) + { + nde_table_t table = itr->second; + if (table) + { + nde_scanner_t s= NDE_Table_CreateScanner(table); + while (NDE_Scanner_LocateField(s, ARTTABLE_HASH, FIRST_RECORD, field)) + { + NDE_Scanner_Delete(s); + NDE_Scanner_Post(s); + } + NDE_Table_DestroyScanner(table, s); + NDE_Table_Sync(table); + } + } + } + } + NDE_Table_DestroyScanner(artHashes, hashscanner); + } + ndestring_release(filename); + return 0; +} + +static int DeleteDatabaseAPC(HANDLE handle, void *user_data, intptr_t id) +{ + CloseArtCache(); + + wchar_t search_mask[MAX_PATH] = {0}; + StringCchPrintfW(search_mask, MAX_PATH, L"%s\\art_*.*", g_tableDir); + + wchar_t fn[MAX_PATH] = {0}; + StringCchPrintfW(fn, MAX_PATH, L"%s\\art.idx", g_tableDir); + DeleteFileW(fn); + StringCchPrintfW(fn, MAX_PATH, L"%s\\art.dat", g_tableDir); + DeleteFileW(fn); + + WIN32_FIND_DATAW findData; + HANDLE hFind = FindFirstFileW(search_mask, &findData); + if (hFind != INVALID_HANDLE_VALUE) + { + do + { + if (!_wcsnicmp(findData.cFileName, L"art_", 4)) + { + StringCchPrintfW(fn, MAX_PATH, L"%s\\%s", g_tableDir, findData.cFileName); + DeleteFileW(fn); + } + } + while (FindNextFileW(hFind, &findData)); + FindClose(hFind); + } + return 0; +} + +void DumpArtCache() +{ + InitArtThread(); + assert(artThread); + WASABI_API_THREADPOOL->RunFunction(artThread, DeleteDatabaseAPC, 0, 0, 0); +} + +void ClearCache(const wchar_t *filename) +{ + InitArtThread(); + assert(artThread); + WASABI_API_THREADPOOL->RunFunction(artThread, ClearFilenameCacheAPC, ndestring_wcsdup(filename), 0, 0); +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/AlbumArtCache.h b/Src/Plugins/Library/ml_local/AlbumArtCache.h new file mode 100644 index 00000000..c413e0ee --- /dev/null +++ b/Src/Plugins/Library/ml_local/AlbumArtCache.h @@ -0,0 +1,14 @@ +#ifndef NULLSOFT_ML_LOCAL_ALBUMARTCACHE_H +#define NULLSOFT_ML_LOCAL_ALBUMARTCACHE_H + +#include "AlbumArtContainer.h" +void KillArtThread(); +void CreateCache(AlbumArtContainer *container, int w, int h); +void FlushCache(); +void ResumeCache(); + +void HintCacheSize(int _cachesize); + +void ClearCache(const wchar_t *filename); +void DumpArtCache(); +#endif
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/AlbumArtContainer.cpp b/Src/Plugins/Library/ml_local/AlbumArtContainer.cpp new file mode 100644 index 00000000..9b06b288 --- /dev/null +++ b/Src/Plugins/Library/ml_local/AlbumArtContainer.cpp @@ -0,0 +1,80 @@ +#include "AlbumArtContainer.h" +#include "api__ml_local.h" +#include <tataki/bitmap/bitmap.h> +#include <tataki/canvas/canvas.h> +#include <assert.h> +#include "AlbumArtCache.h" +#include "../nde/nde.h" +#include <commctrl.h> + +AlbumArtContainer::AlbumArtContainer() :filename(0) +{ + references = 1; + cached = CACHE_UNKNOWN; + cache = 0; + updateMsg.hwnd = NULL; +} + +void AlbumArtContainer::AddRef() +{ + references++; +} + +void AlbumArtContainer::Release() +{ + if (--references == 0) + delete this; +} + +AlbumArtContainer::~AlbumArtContainer() +{ + ndestring_release(filename); + if (cache) cache->Release(); +} + +void AlbumArtContainer::Reset() +{ + if (cache) + cache->Release(); + cache = 0; + cached = AlbumArtContainer::CACHE_UNKNOWN; +} + +void AlbumArtContainer::SetCache(SkinBitmap *bitmap, CacheStatus status) +{ + if (cache) + cache->Release(); + cache = bitmap; + cached = status; + + // lets post the update message + if(updateMsg.hwnd && (CACHE_CACHED == cached || CACHE_UNKNOWN == cached)) PostMessageW(updateMsg.hwnd,updateMsg.message,updateMsg.wParam,updateMsg.lParam); +} + +int AlbumArtContainer::drawArt(DCCanvas *pCanvas, RECT *prcDst) +{ + switch (cached) + { + case CACHE_NOTFOUND: + return DRAW_NOART; + case CACHE_LOADING: + return DRAW_LOADING; + case CACHE_UNKNOWN: + cached = CACHE_LOADING; + CreateCache(this, prcDst->right - prcDst->left, prcDst->bottom - prcDst->top); + return DRAW_LOADING; + case CACHE_CACHED: + { + if (cache->getWidth() != (prcDst->right - prcDst->left) || cache->getHeight() != (prcDst->bottom - prcDst->top)) + { + cached = CACHE_LOADING; + CreateCache(this, prcDst->right - prcDst->left, prcDst->bottom - prcDst->top); + return DRAW_LOADING; + } + if (pCanvas) cache->blitAlpha(pCanvas, prcDst->left, prcDst->top); + return DRAW_SUCCESS; + } + default: + return DRAW_NOART; // shouldn't reach this; + } +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/AlbumArtContainer.h b/Src/Plugins/Library/ml_local/AlbumArtContainer.h new file mode 100644 index 00000000..988721ff --- /dev/null +++ b/Src/Plugins/Library/ml_local/AlbumArtContainer.h @@ -0,0 +1,43 @@ +#ifndef NULLSOFT_ML_LOCAL_ALBUMARTCONTAINER_H +#define NULLSOFT_ML_LOCAL_ALBUMARTCONTAINER_H + +#include <windows.h> // for HDC +#include <tataki/canvas/bltcanvas.h> + +class AlbumArtContainer +{ +public: + enum CacheStatus + { + CACHE_UNKNOWN, + CACHE_CACHED, + CACHE_NOTFOUND, + CACHE_LOADING, + }; + + AlbumArtContainer(); + enum + { + DRAW_SUCCESS, + DRAW_NOART, + DRAW_LOADING, + }; + int drawArt(DCCanvas *pCanvas, RECT *prcDst); + // benski> this definition is just temporary to get things going + + void AddRef(); + void Release(); + wchar_t *filename; // actually an NDE reference counted string + MSG updateMsg; + void SetCache(SkinBitmap *bitmap, CacheStatus status); + void Reset(); +private: + ~AlbumArtContainer(); + SkinBitmap * volatile cache; + + volatile CacheStatus cached; + size_t references; + +}; + +#endif
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/AlbumArtFilter.cpp b/Src/Plugins/Library/ml_local/AlbumArtFilter.cpp new file mode 100644 index 00000000..d7295571 --- /dev/null +++ b/Src/Plugins/Library/ml_local/AlbumArtFilter.cpp @@ -0,0 +1,1258 @@ +#include "main.h" +#include "api__ml_local.h" +#include "../nu/sort.h" +#include "AlbumArtFilter.h" +#include "resource.h" +#include "../nu/AutoUrl.h" +#include <shlwapi.h> +#include "..\..\General\gen_ml/ml_ipc_0313.h" +#include "AlbumArtContainer.h" +#include <tataki/canvas/canvas.h> +#include <tataki/bitmap/autobitmap.h> +#include <api/service/waServiceFactory.h> +#include <api/service/svcs/svc_imgload.h> + +static size_t m_sort_by, m_sort_dir, m_sort_which; + +void emptyQueryListObject(queryListObject *obj); +int reallocQueryListObject(queryListObject *obj); +void freeQueryListObject(queryListObject *obj); +extern C_Config *g_config; +int config_use_alternate_colors=1; + +#define WM_EX_GETREALLIST (WM_USER + 0x01) +#define WM_EX_GETCOUNTPERPAGE (WM_USER + 0x04) +#define LVN_EX_SIZECHANGED (LVN_LAST) + +AlbumArtFilter::AlbumArtFilter(HWND hwndDlg, int dlgitem, C_Config *c) : hwndDlg(hwndDlg), dlgitem(dlgitem), + notfound(L"winamp.cover.notfound"), notfound60(L"winamp.cover.notfound.60"), notfound90(L"winamp.cover.notfound.90"), + hbmpNames(NULL), ratingHotItem((DWORD)-1), bgBrush(NULL) +{ + mode = c->ReadInt(L"albumartviewmode",1); + icons_only = c->ReadInt(L"albumarticonmode",0); + ZeroMemory(classicnotfound, sizeof(classicnotfound)); + DialogProc(hwndDlg,WM_INITDIALOG,0,0); +} + +AlbumArtFilter::~AlbumArtFilter() +{ + if (hbmpNames) DeleteObject(hbmpNames); + if (bgBrush) DeleteBrush(bgBrush); +} + +static COLORREF GetWAColor(INT index) +{ + static int (*wad_getColor)(int idx) = NULL; + if (!wad_getColor) *(void **)&wad_getColor=(void*)SendMessage(plugin.hwndLibraryParent,WM_ML_IPC,1,ML_IPC_SKIN_WADLG_GETFUNC); + return (wad_getColor) ? wad_getColor(index) : 0xFF00FF; +} + +static void getImgSize(int mode, int &w, int &h) +{ + switch (mode) + { + case 0: w=h=60; break; + case 1: w=h=90; break; + case 2: w=h=120; break; + case 3: w=h=60; break; + case 4: w=h=90; break; + case 5: w=h=120; break; + case 6: w=h=180; break; + } +} + +static bool isDetailsMode(int mode) +{ + return mode == 0 || mode == 1 || mode == 2; +} + +void DrawRect(HDC dc, int x, int y, int w, int h) +{ + w-=1; + h-=1; + MoveToEx(dc,x,y,NULL); + LineTo(dc,x,y+h); + MoveToEx(dc,x,y+h,NULL); + LineTo(dc,x+w,y+h); + MoveToEx(dc,x+w,y+h,NULL); + LineTo(dc,x+w,y); + MoveToEx(dc,x+w,y,NULL); + LineTo(dc,x,y); +} + +static int getStrExtent(HDC dc, const wchar_t * s) +{ + int ret=0; + while (s && *s) + { + int f; + GetCharWidth32(dc,*s,*s,&f); + s++; + ret+=f; + } + return int(ret); +} + +ARGB32 * loadImg(const void * data, int len, int *w, int *h, bool ldata=false) +{ + FOURCC imgload = svc_imageLoader::getServiceType(); + int n = plugin.service->service_getNumServices(imgload); + for (int i=0; i<n; i++) + { + waServiceFactory *sf = plugin.service->service_enumService(imgload,i); + if (sf) + { + svc_imageLoader * l = (svc_imageLoader*)sf->getInterface(); + if (l) + { + if (l->testData(data,len)) + { + ARGB32* ret; + if (ldata) ret = l->loadImageData(data,len,w,h); + else ret = l->loadImage(data,len,w,h); + sf->releaseInterface(l); + return ret; + } + sf->releaseInterface(l); + } + } + } + return NULL; +} + +ARGB32 * loadRrc(int id, char * sec, int *w, int *h, bool data=false) +{ + DWORD size = 0; + // as a nice little treat, allow lang packs to contain a custom IDR_IMAGE_NOTFOUND file + HGLOBAL resourceHandle = WASABI_API_LOADRESFROMFILEA((LPCSTR)sec, MAKEINTRESOURCEA(id), &size); + if(resourceHandle) + { + ARGB32* ret = loadImg(resourceHandle,size,w,h,data); + UnlockResource(resourceHandle); + return ret; + } + return NULL; +} + +void adjustbmp(ARGB32 * p, int len, COLORREF fg) +{ + ARGB32 * end = p+len; + while (p < end) + { + int a = (*p>>24)&0xff ; + int b = a*((*p&0xff) * (fg&0xff)) / (0xff*0xff); + int g = a*(((*p>>8)&0xff) * ((fg>>8)&0xff)) / (0xff*0xff); + int r = a*(((*p>>16)&0xff) * ((fg>>16)&0xff)) / (0xff*0xff); + *p = (a<<24) | (r&0xff) | ((g&0xff)<<8) | ((b&0xff)<<16); + p++; + } +} + +void AlbumArtFilter::drawArt(AlbumArtContainer *art, DCCanvas *pCanvas, RECT *prcDst, int itemid, int imageIndex) +{ + int res = AlbumArtContainer::DRAW_NOART; + if (art) + { + art->updateMsg.hwnd = hwndRealList; + art->updateMsg.message = LVM_REDRAWITEMS; + art->updateMsg.lParam = itemid; + art->updateMsg.wParam = itemid; + res = art->drawArt(pCanvas, prcDst); + } + + if (res != AlbumArtContainer::DRAW_SUCCESS) + { + SkinBitmap *noart; + + // Martin> This will just work for Modern Skins, but looks definitly better + int h = prcDst->right - prcDst->left; + if (h == 60) + noart = notfound60.getBitmap(); + else if (h == 90) + noart = notfound90.getBitmap(); + else + noart = notfound.getBitmap(); + + if (!noart || noart->isInvalid()) + { + if(classicnotfound[imageIndex]) + SkinBitmap(classicnotfound[imageIndex],classicnotfoundW,classicnotfoundH).stretchToRectAlpha(pCanvas, prcDst); + else + { + int w = prcDst->right - prcDst->left; + int h = prcDst->bottom - prcDst->top; + DrawRect(pCanvas->getHDC(), prcDst->left, prcDst->top, w, h); + wchar_t str1[32] = {0}, str2[32] = {0}; + WASABI_API_LNGSTRINGW_BUF(IDS_NO_IMAGE,str1,32); + WASABI_API_LNGSTRINGW_BUF(IDS_AVAILABLE,str2,32); + ExtTextOutW(pCanvas->getHDC(), w/2 - 22 + prcDst->left, w/2 - 14 + prcDst->top, 0,NULL,str1,wcslen(str1),0); + ExtTextOutW(pCanvas->getHDC(), w/2 - 22 + prcDst->left, w/2 + 1 + prcDst->top, 0,NULL,str2,wcslen(str2),0); + } + } + else + noart->stretchToRectAlpha(pCanvas, prcDst); + } +} + +// icon view +BOOL AlbumArtFilter::DrawItemIcon(NMLVCUSTOMDRAW *plvcd, DCCanvas *pCanvas, UINT itemState, RECT *prcClip, BOOL bWndActive) +{ + HDC hdc = plvcd->nmcd.hdc; + RECT ri, re, rcText; + int w=0, h=0, imageIndex=0; + getImgSize(mode,w,h); + + SetBkColor(hdc, plvcd->clrTextBk); + SetTextColor(hdc, plvcd->clrText); + SetRect(&rcText, plvcd->nmcd.rc.left, (plvcd->nmcd.rc.bottom - textHeight), + plvcd->nmcd.rc.right, plvcd->nmcd.rc.bottom - (icons_only ? textHeight : 4)); + + // background + SetRect(&re, plvcd->nmcd.rc.left, plvcd->nmcd.rc.top, plvcd->nmcd.rc.right, (icons_only ? (plvcd->nmcd.rc.bottom - textHeight - 5) : rcText.top)); + + if (IntersectRect(&ri, &re, prcClip)) + ExtTextOutW(hdc,0, 0, ETO_OPAQUE, &ri, L"", 0, 0); + + if (LVIS_SELECTED & itemState) + imageIndex = (bWndActive) ? 1 : 2; + + INT of = ((plvcd->nmcd.rc.right - plvcd->nmcd.rc.left) - w)/2; + SetRect(&re, plvcd->nmcd.rc.left + of, plvcd->nmcd.rc.top + 2, plvcd->nmcd.rc.left + of + w, plvcd->nmcd.rc.top + 2 + h); + if (IntersectRect(&ri, &re, prcClip)) + { + AlbumArtContainer *art = GetArt(plvcd->nmcd.dwItemSpec+1); + drawArt(art, pCanvas, &re, plvcd->nmcd.dwItemSpec, imageIndex); + } + + if (IntersectRect(&ri, &rcText, prcClip)) + { + ExtTextOutW(hdc,0, 0, ETO_OPAQUE, &ri, L"", 0, 0); + + const wchar_t *p = GetText(plvcd->nmcd.dwItemSpec); + if (p && *p) + { + SetRect(&ri, rcText.left + of, rcText.top - (textHeight/2) - 1, rcText.right - of, rcText.top + textHeight); + DrawTextW(hdc, p, -1, &ri, DT_CENTER | DT_VCENTER | DT_SINGLELINE | DT_WORD_ELLIPSIS | DT_NOPREFIX); + } + } + + if ((LVIS_FOCUSED & itemState) && bWndActive) + { + if (hwndRealList && 0 == (0x01/*UISF_HIDEFOCUS*/ & SendMessageW(hwndRealList, 0x0129/*WM_QUERYUISTATE*/, 0, 0L))) + { + /*SetTextColor(hdc, GetSysColor(COLOR_WINDOWTEXT)); + SetBkColor(hdc, GetSysColor(COLOR_WINDOW));*/ + SetBkColor(hdc, GetWAColor(WADLG_ITEMBG)); + + if (icons_only) + { + InflateRect(&re, 2, 2); + } + else + plvcd->nmcd.rc.bottom -= 4; + + DrawFocusRect(hdc, (icons_only ? &re : &plvcd->nmcd.rc)); + } + } + + return TRUE; +} + +//detail view +BOOL AlbumArtFilter::PrepareDetails(HDC hdc) +{ + INT width(0), height, len; + HFONT hFont,hFontBold, hOldFont; + HDC hdcTmp; + HBITMAP hbmpOld; + LOGFONT l={0}; + RECT ri; + wchar_t ratingstr[100] = {0}, buf[100] = {0}; + + hdcTmp = CreateCompatibleDC(hdc); + if (!hdcTmp) return FALSE; + + hFont = (HFONT)GetCurrentObject(hdc, OBJ_FONT); + GetObject(hFont, sizeof(LOGFONT), &l); + l.lfWeight = FW_BOLD; + hFontBold = CreateFontIndirect(&l); + + hOldFont = (HFONT)SelectObject(hdcTmp, hFontBold); + + int bypassColumnCount = 0; + + for ( ListField *l_showcolumn : showncolumns ) + { + if ( l_showcolumn->field == ALBUMFILTER_COLUMN_LASTUPD) // let's hide last updated from details view + { + bypassColumnCount++; + continue; + } + int of = getStrExtent(hdcTmp, l_showcolumn->name); + if (of > width) width = of; + } + if (width) width += 20; + + height = (showncolumns.size()-bypassColumnCount) * textHeight; + hbmpNames = CreateCompatibleBitmap(hdc, width * 4, height); + hbmpOld = (HBITMAP)SelectObject(hdcTmp, hbmpNames); + + SetRect(&ri, 0, 0, width, height); + + WASABI_API_LNGSTRINGW_BUF(IDS_RATING,ratingstr,100); + INT clrText[4] = { WADLG_ITEMFG, WADLG_SELBAR_FGCOLOR, WADLG_INACT_SELBAR_FGCOLOR, WADLG_ITEMFG2, }; + INT clrBk[4] = { WADLG_ITEMBG, WADLG_SELBAR_BGCOLOR, WADLG_INACT_SELBAR_BGCOLOR, WADLG_ITEMBG2, }; + + for (int j = 0; j < 4; j++) + { + SetTextColor(hdcTmp, GetWAColor(clrText[j])); + SetBkColor(hdcTmp, GetWAColor(clrBk[j])); + + ExtTextOutW(hdcTmp,0, 0, ETO_OPAQUE, &ri, L"", 0, 0); + + for (size_t i=0, top = 0; i < showncolumns.size(); i++, top += textHeight) + { + if (showncolumns[i]->field == ALBUMFILTER_COLUMN_LASTUPD) // let's hide last updated from details view + { + top -= textHeight; + continue; + } + if (-1 == ratingrow && 0 == lstrcmpW(showncolumns[i]->name, ratingstr)) ratingrow = i; + StringCchCopyW(buf, 100, (showncolumns[i]->name) ? showncolumns[i]->name : L""); + len = wcslen(buf); + if (len > 0 && len < 99) { buf[len] = L':'; len ++; } + ExtTextOutW(hdcTmp, ri.left + 1, top, ETO_CLIPPED, &ri, buf, len, NULL); + } + OffsetRect(&ri, width, 0); + } + + SelectObject(hdcTmp, hbmpOld); + SelectObject(hdcTmp, hOldFont); + DeleteObject(hFontBold); + DeleteDC(hdcTmp); + return TRUE; +} + +BOOL AlbumArtFilter::DrawItemDetail(NMLVCUSTOMDRAW *plvcd, DCCanvas *pCanvas, UINT itemState, RECT *prcClip, BOOL bWndActive, HDC hdcNames, INT namesWidth) +{ + RECT ri, re; + INT imageIndex = 0; + HDC hdc = plvcd->nmcd.hdc; + + SetTextColor(hdc, plvcd->clrText); + SetBkColor(hdc, plvcd->clrTextBk); + + // background + SetRect(&re, plvcd->nmcd.rc.left + 4, plvcd->nmcd.rc.top, plvcd->nmcd.rc.right, plvcd->nmcd.rc.bottom - 5); + if (IntersectRect(&ri, &re, prcClip)) ExtTextOutW(hdc,0, 0, ETO_OPAQUE, &ri, L"", 0, 0); + if (LVIS_SELECTED & itemState) { imageIndex = (bWndActive) ? 1 : 2; } + + int w, h; + getImgSize(mode, w, h); + SetRect(&re, 6+plvcd->nmcd.rc.left, 3+plvcd->nmcd.rc.top, 6+ plvcd->nmcd.rc.left + w, 3+ plvcd->nmcd.rc.top + h); + if (IntersectRect(&ri, &re, prcClip)) + { + AlbumArtContainer *art = GetArt(plvcd->nmcd.dwItemSpec + 1); + drawArt(art, pCanvas, &re, plvcd->nmcd.dwItemSpec, imageIndex); + } + + // text + int limCY, limCX; + + //select 4th bitmap for alternate coloring + if (g_config->ReadInt(L"alternate_items", config_use_alternate_colors) && imageIndex==0 && plvcd->nmcd.dwItemSpec%2) + imageIndex=3; + + limCY = plvcd->nmcd.rc.bottom; + if (prcClip->bottom < plvcd->nmcd.rc.bottom) limCY = prcClip->bottom; + limCX = plvcd->nmcd.rc.right -1; + if (prcClip->right < plvcd->nmcd.rc.right) limCX = prcClip->right; + + SetRect(&ri, w+16+plvcd->nmcd.rc.left, 3+plvcd->nmcd.rc.top, limCX, limCY); + + if (hdcNames && ri.left < ri.right) + { + BitBlt(hdc, ri.left, ri.top, min(ri.right - ri.left, namesWidth), ri.bottom - ri.top, hdcNames, namesWidth*imageIndex, 0, SRCCOPY); + ri.left += namesWidth; + } + + ri.bottom = ri.top; + + if (ri.left < ri.right) + { + for (size_t i=0; i < showncolumns.size() && ri.top < limCY; i++, ri.top += textHeight) + { + if (showncolumns[i]->field == ALBUMFILTER_COLUMN_LASTUPD) // let's hide last updated from details view + { + ri.top -= textHeight; + continue; + } + + wchar_t buf[100] = {0}; + const wchar_t *p = CopyText2(plvcd->nmcd.dwItemSpec,i,buf,100); + ri.bottom += textHeight; + if (ri.bottom > limCY) ri.bottom = limCY; + + if ((INT)i == ratingrow) // this is the ratings column, so draw graphical stars + { + int rating = wcslen(buf); + RATINGDRAWPARAMS p = {sizeof(RATINGDRAWPARAMS),hdc, + {ri.left, ri.top + ratingTop, ri.right,ri.bottom}, + rating,5,0,RDS_SHOWEMPTY,NULL,0}; + if(ratingHotItem == plvcd->nmcd.dwItemSpec) { p.fStyle |= RDS_HOT; p.trackingValue = ratingHotValue; } + MLRating_Draw(plugin.hwndLibraryParent,&p); + } + else { + //ri.left = re.left; + ri.right = plvcd->nmcd.rc.right; + DrawTextW(hdc, p, wcslen(p), &ri, DT_SINGLELINE | DT_WORD_ELLIPSIS | DT_NOCLIP | DT_NOPREFIX); + } + } + } + + // bottom line + MoveToEx(hdc,plvcd->nmcd.rc.left + 4,plvcd->nmcd.rc.bottom - 3,NULL); + LineTo(hdc,plvcd->nmcd.rc.right, plvcd->nmcd.rc.bottom - 3); + + // focus rect + SetRect(&ri, plvcd->nmcd.rc.left + 4, plvcd->nmcd.rc.top, plvcd->nmcd.rc.right, plvcd->nmcd.rc.bottom - 5); + if ((LVIS_FOCUSED & itemState) && bWndActive) + { + if (hwndRealList && 0 == (0x01/*UISF_HIDEFOCUS*/ & SendMessageW(hwndRealList, 0x0129/*WM_QUERYUISTATE*/, 0, 0L))) + { + /*SetTextColor(hdc, GetSysColor(COLOR_WINDOWTEXT)); + SetBkColor(hdc, GetSysColor(COLOR_WINDOW));*/ + SetBkColor(hdc, GetWAColor(WADLG_ITEMBG)); + DrawFocusRect(hdc, &ri); + } + } + + return TRUE; +} + +static HWND CreateSmoothScrollList(HWND parent, int x, int y, int cx, int cy, int dlgid) { + DWORD flags = WS_CHILD | WS_VSCROLL | DS_CONTROL | WS_CLIPSIBLINGS | WS_CLIPCHILDREN; + HWND h = CreateWindowExW(WS_EX_CONTROLPARENT, L"SmoothScrollList", L"",flags, x, y, cx, cy, parent,(HMENU)dlgid, NULL, (LPVOID)0); + SendMessage(h,WM_INITDIALOG,0,0); + return h; +} + +static HWND CreateHeaderIconList(HWND parent, int x, int y, int cx, int cy, int dlgid) { + DWORD flags = WS_CHILD | WS_VSCROLL | DS_CONTROL | WS_CLIPSIBLINGS | WS_CLIPCHILDREN; + HWND h = CreateWindowExW(WS_EX_CONTROLPARENT, L"HeaderIconList", L"",flags, x, y, cx, cy, parent,(HMENU)dlgid, NULL, (LPVOID)0); + SendMessage(h,WM_INITDIALOG,0,0); + return h; +} + +BOOL AlbumArtFilter::OnKeyDown(NMLVKEYDOWN *plvkd) +{ + switch (plvkd->wVKey) + { + case 'A': + if (GetAsyncKeyState(VK_CONTROL)) + { + LVITEM item; + item.state = LVIS_SELECTED; + item.stateMask = LVIS_SELECTED; + SendMessageW(plvkd->hdr.hwndFrom, LVM_SETITEMSTATE, (WPARAM)-1, (LPARAM)&item); + return TRUE; + } + break; + } + return FALSE; +} + +BOOL AlbumArtFilter::OnCustomDrawIcon(NMLVCUSTOMDRAW *plvcd, LRESULT *pResult) +{ + static RECT rcClip; + static BOOL bActive; + static DCCanvas activeCanvas; + + *pResult = CDRF_DODEFAULT; + switch(plvcd->nmcd.dwDrawStage) + { + case CDDS_PREPAINT: + if (0 == plvcd->nmcd.rc.bottom && 0 == plvcd->nmcd.rc.right) + { + *pResult = CDRF_SKIPDEFAULT; + return TRUE; + } + CopyRect(&rcClip, &plvcd->nmcd.rc); + bActive = (GetFocus() == hwndRealList); + activeCanvas.cloneDC(plvcd->nmcd.hdc, NULL); + *pResult = CDRF_NOTIFYITEMDRAW | CDRF_NOTIFYPOSTPAINT; + return TRUE; + + case CDDS_ITEMPREPAINT: + { + UINT itemState = SendMessageW(plvcd->nmcd.hdr.hwndFrom, LVM_GETITEMSTATE, plvcd->nmcd.dwItemSpec, + LVIS_FOCUSED | LVIS_SELECTED | LVIS_DROPHILITED | LVIS_CUT); + + plvcd->nmcd.rc.left = LVIR_BOUNDS; + SendMessageW(plvcd->nmcd.hdr.hwndFrom, LVM_GETITEMRECT, plvcd->nmcd.dwItemSpec, (LPARAM)&plvcd->nmcd.rc); + + if (rcClip.left < plvcd->nmcd.rc.right) + { + DrawItemIcon(plvcd, &activeCanvas, itemState, &rcClip, bActive); + *pResult = CDRF_SKIPDEFAULT; + } + } + return TRUE; + + case CDDS_POSTPAINT: + return TRUE; + } + return FALSE; +} + +BOOL AlbumArtFilter::OnCustomDrawDetails(NMLVCUSTOMDRAW *plvcd, LRESULT *pResult) +{ + static RECT rcClip; + static BOOL bActive; + static HDC hdcNames; + static HBITMAP hbmpOld; + static HPEN penOld; + static DCCanvas activeCanvas; + + *pResult = CDRF_DODEFAULT; + switch(plvcd->nmcd.dwDrawStage) + { + case CDDS_PREPAINT: + { + if (0 == plvcd->nmcd.rc.bottom && 0 == plvcd->nmcd.rc.right) + { + *pResult = CDRF_SKIPDEFAULT; + return TRUE; + } + CopyRect(&rcClip, &plvcd->nmcd.rc); + FillRect(plvcd->nmcd.hdc,&plvcd->nmcd.rc,bgBrush); + + if (!hbmpNames) PrepareDetails(plvcd->nmcd.hdc); + if (hbmpNames) + { + BITMAP bi; + GetObject(hbmpNames, sizeof(BITMAP), &bi); + namesWidth = bi.bmWidth/4; + hdcNames = CreateCompatibleDC(plvcd->nmcd.hdc); + hbmpOld = (hdcNames) ? (HBITMAP)SelectObject(hdcNames, hbmpNames) : NULL; + } + else + { + hdcNames = NULL; + namesWidth = 0; + } + bActive = (GetFocus() == hwndRealList); + + penOld = (HPEN)SelectObject(plvcd->nmcd.hdc, CreatePen(PS_SOLID,1, GetWAColor(WADLG_HILITE))); + activeCanvas.cloneDC(plvcd->nmcd.hdc, NULL); + *pResult = CDRF_NOTIFYITEMDRAW | CDRF_NOTIFYPOSTPAINT; + return TRUE; + } + + case CDDS_ITEMPREPAINT: + { + UINT itemState = SendMessageW(plvcd->nmcd.hdr.hwndFrom, LVM_GETITEMSTATE, plvcd->nmcd.dwItemSpec, + LVIS_FOCUSED | LVIS_SELECTED | LVIS_DROPHILITED | LVIS_CUT); + + plvcd->nmcd.rc.left = LVIR_BOUNDS; + SendMessageW(plvcd->nmcd.hdr.hwndFrom, LVM_GETITEMRECT, plvcd->nmcd.dwItemSpec, (LPARAM)&plvcd->nmcd.rc); + + if (rcClip.left < plvcd->nmcd.rc.right) + { + DrawItemDetail(plvcd, &activeCanvas, itemState, &rcClip, bActive, hdcNames, namesWidth); + *pResult = CDRF_SKIPDEFAULT; + } + } + return TRUE; + + case CDDS_POSTPAINT: + if (hdcNames) + { + SelectObject(hdcNames, hbmpOld); + DeleteDC(hdcNames); + } + if (penOld) + { + HPEN pen = (HPEN)SelectObject(plvcd->nmcd.hdc, penOld); + if (pen) DeleteObject(pen); + penOld = NULL; + } + return TRUE; + } + return FALSE; +} + +BOOL AlbumArtFilter::CalcuateItemHeight(void) +{ + HDC hdc; + int w, h; + HWND hwndList; + TEXTMETRIC tm = {0}; + + getImgSize(mode, w, h); + + hwndList = GetDlgItem(hwndDlg, dlgitem); + + textHeight = 0; + + hdc = GetDC(hwndDlg); + if (hdc) + { + HFONT hFont = (HFONT)SendMessageW(hwndList, WM_GETFONT, 0, 0L); + if (!hFont) hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT); + HFONT hFontOld = (HFONT)SelectObject(hdc, hFont); + + GetTextMetrics(hdc, &tm); + textHeight = tm.tmHeight; + SelectObject(hdc, hFontOld); + ReleaseDC(hwndDlg, hdc); + } + + if (isDetailsMode(mode)) + { + if (textHeight < 14) textHeight = 14; + RECT r; + MLRating_CalcRect(plugin.hwndLibraryParent, NULL, 5, &r); + r.bottom -= r.top; + + if ( r.bottom >= textHeight ) ratingTop = 0; + else + { + if (tm.tmAscent > (r.bottom + (r.bottom/2))) ratingTop = tm.tmAscent - r.bottom; + else ratingTop = (textHeight - r.bottom)/2 + 1; + } + + int bypassColumnCount = 0; + for ( ListField *l_showcolumn : showncolumns ) + { + if ( l_showcolumn->field == ALBUMFILTER_COLUMN_LASTUPD) // let's hide last updated from details view + { + bypassColumnCount++; + continue; + } + } + + int newHeight = max(h, textHeight * ((INT)showncolumns.size() - bypassColumnCount)) + 12; + if (newHeight != itemHeight) + { + itemHeight = newHeight; + RECT rw; + GetWindowRect(hwndList, &rw); + SetWindowPos(hwndList, NULL, 0, 0, rw.right - rw.left - 1, rw.bottom - rw.top, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOREDRAW); + SetWindowPos(hwndList, NULL, 0, 0, rw.right - rw.left, rw.bottom - rw.top, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER); + } + } + else + { + HIMAGELIST hIL = (HIMAGELIST)SendMessageW(hwndList, LVM_GETIMAGELIST, 0, 0L); + if (!hIL || !ImageList_GetIconSize(hIL, &w, &h)) { h += 4; w+= 4; } + SendMessageW(hwndList, LVM_SETICONSPACING, 0, MAKELPARAM(w, h + (icons_only ? 0 : textHeight))); + if (!tm.tmAveCharWidth) tm.tmAveCharWidth = 2; + itemHeight = w / tm.tmAveCharWidth; + } + return TRUE; +} + +INT_PTR AlbumArtFilter::DialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam) +{ + switch (uMsg) + { + case WM_INITDIALOG: + { + HWND hwnd = GetDlgItem(hwndDlg,dlgitem); + RECT r; + if (hwnd) + { + GetWindowRect(hwnd,&r); + MapWindowPoints(HWND_DESKTOP, hwndDlg, (POINT*)&r, 2); + DestroyWindow(hwnd); + } + else SetRect(&r, 0, 0, 1, 1); + + if (isDetailsMode(mode)) + { + hwnd = CreateSmoothScrollList(hwndDlg, r.left, r.top, r.right - r.left, r.bottom - r.top, dlgitem); + } + else + { + hwnd = CreateHeaderIconList(hwndDlg, r.left, r.top, r.right - r.left, r.bottom - r.top, dlgitem); + int w=0,h=0; + getImgSize(mode,w,h); + HIMAGELIST il = ImageList_Create(w + 4,h + 4,ILC_COLOR24,0,1); // add borders + ListView_SetImageList(hwnd,il,LVSIL_NORMAL); + } + + hwndRealList = (HWND)SendMessageW(hwnd, WM_EX_GETREALLIST, 0, 0L); + + MLSKINWINDOW skin = {0}; + skin.hwndToSkin = hwndDlg; + skin.skinType = SKINNEDWND_TYPE_AUTO; + skin.style = SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS | SWLVS_FULLROWSELECT | SWLVS_DOUBLEBUFFER; + MLSkinWindow(plugin.hwndLibraryParent, &skin); + + if (isDetailsMode(mode) && NULL != hwndRealList) + MLSkinnedWnd_SetStyle(hwndRealList, MLSkinnedWnd_GetStyle(hwndRealList) | SWLVS_ALTERNATEITEMS); + } + + case WM_DISPLAYCHANGE: + { + if (hbmpNames) + DeleteObject(hbmpNames); + + hbmpNames = NULL; + ratingrow = -1; + + if(bgBrush) + DeleteBrush(bgBrush); + + bgBrush = CreateSolidBrush(GetWAColor(WADLG_ITEMBG)); + CalcuateItemHeight(); + + //TODO + //config_use_alternate_colors = g_config->ReadInt("alternate_items", 1); + + int rw,rh; + ARGB32 * bmp = loadRrc(IDR_IMAGE_NOTFOUND,"PNG",&rw,&rh,true); + classicnotfoundW = rw; + classicnotfoundH = rh; + INT color[] = { WADLG_ITEMFG, WADLG_SELBAR_FGCOLOR, WADLG_INACT_SELBAR_FGCOLOR, }; + + for (int i = sizeof(classicnotfound)/sizeof(classicnotfound[0]) -1; i > -1; i--) + { + if(classicnotfound[i]) WASABI_API_MEMMGR->sysFree(classicnotfound[i]); + classicnotfound[i] = NULL; + + if(bmp) + { + if (0 != i) + { + classicnotfound[i] = (ARGB32*)WASABI_API_MEMMGR->sysMalloc(sizeof(ARGB32)*rw*rh); + CopyMemory(classicnotfound[i], bmp, sizeof(ARGB32)*rw*rh); + } + else + classicnotfound[i] = bmp; + + adjustbmp(classicnotfound[i],rw*rh, GetWAColor(color[i])); + } + } + + if(WM_DISPLAYCHANGE == uMsg) + PostMessageW(GetDlgItem(hwndDlg,dlgitem),uMsg,wParam,lParam); + else + ShowWindow(GetDlgItem(hwndDlg,dlgitem), SW_SHOWNORMAL); + } + break; + + case WM_DESTROY: + for (int i = sizeof(classicnotfound)/sizeof(classicnotfound[0]) -1; i > -1; i--) + { + if(classicnotfound[i]) + WASABI_API_MEMMGR->sysFree(classicnotfound[i]); + + classicnotfound[i] = NULL; + } + break; + + case WM_MEASUREITEM: + if (wParam == (WPARAM)dlgitem) + { + ((MEASUREITEMSTRUCT*)lParam)->itemHeight = itemHeight; + SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, TRUE); + return TRUE; + } + break; + + case WM_USER+600: + AppendMenuW((HMENU)wParam,MF_SEPARATOR,lParam++,0); + // disabled 30 May 2012 as per email from Tejas w.r.t. to Rovi deal ending + //AppendMenuW((HMENU)wParam,MF_STRING,lParam++,WASABI_API_LNGSTRINGW(IDS_GET_ALBUM_ART)); + AppendMenuW((HMENU)wParam,MF_STRING,lParam++,WASABI_API_LNGSTRINGW(IDS_REFRESH_ALBUM_ART)); + AppendMenuW((HMENU)wParam,MF_STRING,lParam++,WASABI_API_LNGSTRINGW(IDS_OPEN_FOLDER)); + AppendMenuW((HMENU)wParam,MF_STRING,lParam++,WASABI_API_LNGSTRINGW(IDS_MORE_ARTIST_INFO)); + break; + + case WM_USER+601: + RemoveMenu((HMENU)wParam,lParam++,MF_BYCOMMAND); + // disabled 30 May 2012 as per email from Tejas w.r.t. to Rovi deal ending + //RemoveMenu((HMENU)wParam,lParam++,MF_BYCOMMAND); + RemoveMenu((HMENU)wParam,lParam++,MF_BYCOMMAND); + RemoveMenu((HMENU)wParam,lParam++,MF_BYCOMMAND); + RemoveMenu((HMENU)wParam,lParam++,MF_BYCOMMAND); + break; + + case WM_USER+602: + // disabled 30 May 2012 as per email from Tejas w.r.t. to Rovi deal ending + #if 0 + if (lParam == 1) + { + int c = list->GetCount(); + for (int x = 0; x < c; x ++) + { + if(list->GetSelected(x) && albumList.Items[x+1].art) + { + artFetchData d = {sizeof(d),hwndDlg,albumList.Items[x+1].artist,albumList.Items[x+1].name,0}; + d.gracenoteFileId = albumList.Items[x+1].gracenoteFileId; + d.showCancelAll = 1; + int r = (int)SendMessage(plugin.hwndWinampParent,WM_WA_IPC,(LPARAM)&d,IPC_FETCH_ALBUMART); + if(r == -2) break; // cancel all was pressed + if(r == 0 && d.imgData && d.imgDataLen) // success, save art in correct location + { + AGAVE_API_ALBUMART->SetAlbumArt(albumList.Items[x+1].art->filename,L"cover",0,0,d.imgData,d.imgDataLen,d.type); + WASABI_API_MEMMGR->sysFree(d.imgData); + // clear the cache... + ClearCache(albumList.Items[x+1].art->filename); + albumList.Items[x+1].art->updateMsg.hwnd=0; + albumList.Items[x+1].art->Reset(); + SendMessage(GetDlgItem(hwndDlg,dlgitem),LVM_REDRAWITEMS,x,x); + } + } + } + } + else + #endif + if(lParam == 1) + { + int c = list->GetCount(); + for (int x = 0; x < c; x ++) + { + if(list->GetSelected(x) && albumList.Items[x+1].art) + { + ClearCache(albumList.Items[x+1].art->filename); + albumList.Items[x+1].art->updateMsg.hwnd=0; + albumList.Items[x+1].art->Reset(); + SendMessage(GetDlgItem(hwndDlg,dlgitem),LVM_REDRAWITEMS,x,x); + } + } + } + else if(lParam == 2) + { + int opened=0; + int c = list->GetCount(); + for (int x = 0; x < c; x ++) + { + if((ListView_GetItemState(list->getwnd(), x, LVIS_FOCUSED)&LVIS_FOCUSED) && albumList.Items[x+1].art) + { + // TODO change to use the explorer api + if(opened++ >= 10) break; // that's enough! Opening 400 exploerer windows may seem like fun, but windows _hates_ it. + wchar_t fn[MAX_PATH] = {0}; + lstrcpynW(fn,albumList.Items[x+1].art->filename,MAX_PATH); + PathRemoveFileSpecW(fn); + ShellExecuteW(NULL,L"open",fn,NULL,NULL,SW_SHOW); + } + } + } + else if (lParam == 3) + { + int sel = list->GetNextSelected(); + if (sel != LB_ERR) + { + char url[1024] = {0}; + StringCchPrintfA(url, 1024, "http://client.winamp.com/nowplaying/artist?artistName=%s&icid=localmediagetartistinfo", AutoUrl(albumList.Items[sel+1].artist)); + SendMessage(plugin.hwndWinampParent,WM_WA_IPC,(LPARAM)url,IPC_OPEN_URL); + } + } + break; + + case WM_USER+700: // hit-info + { + DWORD hotold = ratingHotItem; + int hotoldval = ratingHotValue; + ratingHotItem = (DWORD)-1; + + typedef struct { + int x,y,item; + HWND hwnd; + UINT msg; + } hitinfo; + + hitinfo * info = (hitinfo *)wParam; + if(mode && info->hwnd == hwndRealList && info->item >= 0 && info->item < albumList.Size) + { + int w = 0, h = 0; + getImgSize(mode,w,h); + RATINGHITTESTPARAMS ratingHitTest = {sizeof(ratingHitTest),{info->x,info->y},{16+w+namesWidth,3+textHeight*ratingrow,0,0},5,RDS_NORMAL,NULL,-1,(UINT)-1}; + ratingHitTest.rc.bottom = ratingHitTest.rc.top + textHeight; + ratingHitTest.rc.right = ratingHitTest.rc.left + 200; + + LONG hitVal = MLRating_HitTest(plugin.hwndLibraryParent,&ratingHitTest); + + ratingHitTest.rc.left -= 10; //this 10px is the area in which you can click to set a zero rating (see the PtInRect call below) + + if(!hitVal && !PtInRect(&ratingHitTest.rc, ratingHitTest.pt)) + { + if(hotold >=0) { ReleaseCapture(); ListView_RedrawItems(hwndRealList,hotold,hotold); } + break; + } + + if(info->msg == WM_MOUSEMOVE) + { + ratingHotValue = hitVal; + ratingHotItem = info->item; + if(hotold != ratingHotItem || hotoldval != ratingHotValue) + { + ListView_RedrawItems(hwndRealList,info->item,info->item); + if(hotold >=0 && hotold != ratingHotItem) + ListView_RedrawItems(hwndRealList,hotold,hotold); + + SetCapture(hwndRealList); + } + } + else if(info->msg == WM_LBUTTONDOWN) + { + /* + This is a slight race condition. We are part of the WM_MOUSEMOVE message in the listview. Selection state hasn't changed yet. + By doing a PostMessage, we're betting that by the time that the message gets processed, selections state HAS changed. + Haven't managed to make it misbehave yet though. + (Passing the this pointer is not dangerous, because we check it on the other side :) + */ + PostMessage(hwndDlg,WM_USER+710,hitVal,(LPARAM)this); + ReleaseCapture(); + } + else if(hotold >=0) { ReleaseCapture(); ListView_RedrawItems(hwndRealList,hotold,hotold); } + } + else if(hotold >=0) { ReleaseCapture(); ListView_RedrawItems(hwndRealList,hotold,hotold); } + } + break; + + case WM_NOTIFY: + if (wParam == (WPARAM)dlgitem) + { + BOOL bProcessed(FALSE); + LRESULT result(0); + switch (((NMHDR*)lParam)->code) + { + case LVN_KEYDOWN: bProcessed = OnKeyDown((NMLVKEYDOWN*)lParam); break; + case NM_CUSTOMDRAW: + bProcessed = (isDetailsMode(mode)) ? OnCustomDrawDetails((NMLVCUSTOMDRAW*)lParam, &result) : OnCustomDrawIcon((NMLVCUSTOMDRAW*)lParam, &result); + break; + case LVN_GETDISPINFOW: + return TRUE; + case LVN_GETINFOTIPW: + { + const wchar_t *p = GetText(((NMLVGETINFOTIPW*)lParam)->iItem); + if (p && *p && lstrlenW(p) > itemHeight) // we use itemHeight to write number of average characters that fits label in icon mode + { + StringCchCopyW(((NMLVGETINFOTIPW*)lParam)->pszText, ((NMLVGETINFOTIPW*)lParam)->cchTextMax, p); + } + return TRUE; + } + case LVN_EX_SIZECHANGED: + { + INT hint = (INT)SendMessageW(((NMHDR*)lParam)->hwndFrom, WM_EX_GETCOUNTPERPAGE, 0, 0L); + if (hint > 0) HintCacheSize(hint); + } + return TRUE; + } + + if (bProcessed) SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, (LONG_PTR)result); + return bProcessed; + } + break; + } + return 0; +} + +static int getWidth(int def, int col) +{ + wchar_t buf[100] = {0}; + char * name = AlbumFilter::getColConfig(col); + StringCchPrintfW(buf, ARRAYSIZE(buf), L"av_art_col_%hs", name); + return g_view_metaconf->ReadInt(buf, def); +} + +void AlbumArtFilter::AddColumns2() +{ + showncolumns.push_back(new ListField(7,getWidth(90,7),IDS_ARTIST,g_view_metaconf,"",false,false,false,0)); + showncolumns.push_back(new ListField(0,getWidth(90,0),IDS_ALBUM,g_view_metaconf,"",false,false,false,1)); + showncolumns.push_back(new ListField(3,getWidth(50,3),IDS_TRACKS_MENU,g_view_metaconf,"",false,false,false,2)); + showncolumns.push_back(new ListField(1,getWidth(50,1),IDS_YEAR,g_view_metaconf,"",false,false,false,3)); + if (mode != 0 && mode != 3) + { + showncolumns.push_back(new ListField(8,getWidth(50,8),IDS_GENRE,g_view_metaconf,"",false,false,false,4)); + showncolumns.push_back(new ListField(9,getWidth(50,9),IDS_RATING,g_view_metaconf,"",false,false,false,5)); + if (mode != 1 && mode != 4) + { + showncolumns.push_back(new ListField(6,getWidth(50,6),IDS_LENGTH,g_view_metaconf,"",false,false,false,6)); + showncolumns.push_back(new ListField(5,getWidth(50,5),IDS_SIZE,g_view_metaconf,"",false,false,false,7)); + } + } + showncolumns.push_back(new ListField(10,getWidth(90,10),IDS_LAST_UPDATED,g_view_metaconf,"",false,false,false,8)); +} + +static const wchar_t* getArtist(const itemRecordW *p) +{ + if (p->albumartist) return p->albumartist; + else if (p->artist) return p->artist; + return L""; +} + +static wchar_t* retainArtist(itemRecordW *p) +{ + if (p->albumartist) + { + ndestring_retain(p->albumartist); + return p->albumartist; + } + else if (p->artist) + { + ndestring_retain(p->artist); + return p->artist; + } + return emptyQueryListString; +} + +int AlbumArtFilter::MyBuildSortFunc(const void *elem1, const void *elem2, const void *context) +{ + AlbumArtFilter *sortFilter = (AlbumArtFilter *)context; + itemRecordW *a = (itemRecordW *)elem1; + itemRecordW *b = (itemRecordW *)elem2; + int v=WCSCMP_NULLOK(getArtist(a),getArtist(b)); + if (v) + return v; + v=WCSCMP_NULLOK(a->album,b->album); + if (v) + return v; + if (sortFilter->nextFilter) + { + wchar_t ab[100] = {0}, bb[100] = {0}; + v = WCSCMP_NULLOK(sortFilter->nextFilter->GroupText(a,ab,100),sortFilter->nextFilter->GroupText(b,bb,100)); + if (v) + return v; + } + v = a->track - b->track; + if (v) + return v; + return WCSCMP_NULLOK(a->filename,b->filename); +} + +void AlbumArtFilter::Fill(itemRecordW *items, int numitems, int *killswitch, int numitems2) +{ + if (numitems > 1) + qsort_itemRecord(items,numitems,this, MyBuildSortFunc); + + if (killswitch && *killswitch) return; + + emptyQueryListObject(&albumList); + reallocQueryListObject(&albumList); + + itemRecordW *p = items; + int n = numitems; + int numalbumstotal = 0; + wchar_t *lastartist = 0; + wchar_t *lastalbum = 0; + const wchar_t *lastalb=0; + wchar_t albbuf[100] = {0}, albbuf2[100] = {0}; + ZeroMemory(&albumList.Items[0],sizeof(queryListItem)); + int isbl = 0; + while (n--) + { + if (killswitch && *killswitch) return; + if ((!lastartist || WCSCMP_NULLOK(lastartist, getArtist(p))) || (!lastalbum || WCSCMP_NULLOK(lastalbum, p->album))) + { + albumList.Size++; + if (reallocQueryListObject(&albumList)) break; + wchar_t *albumGain = p->replaygain_album_gain; + ndestring_retain(albumGain); + wchar_t *gracenoteFileId = getRecordExtendedItem_fast(p, extended_fields.GracenoteFileID); + ZeroMemory(&albumList.Items[albumList.Size],sizeof(queryListItem)); + albumList.Items[albumList.Size].albumGain = albumGain; + albumList.Items[albumList.Size].gracenoteFileId = gracenoteFileId; + ndestring_retain(gracenoteFileId); + + lastartist = albumList.Items[albumList.Size].artist = retainArtist(p); + if (p->album) + { + ndestring_retain(p->album); + lastalbum = albumList.Items[albumList.Size].name = p->album; + } + else + lastalbum = albumList.Items[albumList.Size].name = emptyQueryListString; + + lastalb=0; + SKIP_THE_AND_WHITESPACEW(lastalbum) // optimization technique + SKIP_THE_AND_WHITESPACEW(lastartist) // optimization technique + + albumList.Items[albumList.Size].art = new AlbumArtContainer(); + ndestring_retain(p->filename); + albumList.Items[albumList.Size].art->filename = p->filename; + + if (*lastalbum) numalbumstotal++; + } + if (p->year>0) + { + int y = albumList.Items[albumList.Size].ifields[2]; + if (y == 0) y = MAKELONG((short)p->year,(short)p->year); + else if (p->year > (short)LOWORD(y)) y = MAKELONG((short)p->year,(short)HIWORD(y)); + else if (p->year < (short)HIWORD(y)) y = MAKELONG((short)LOWORD(y),(short)p->year); + albumList.Items[albumList.Size].ifields[2] = y; + } + + if (!albumList.Items[albumList.Size].genre && p->genre) + { + wchar_t *genre = p->genre; + ndestring_retain(genre); + albumList.Items[albumList.Size].genre = genre; + } + + if (p->rating > 0) albumList.Items[albumList.Size].rating += p->rating; + + if (p->lastupd > albumList.Items[albumList.Size].lastupd) albumList.Items[albumList.Size].lastupd = p->lastupd; + + if (!p->album || !*p->album) isbl++; + if (albumList.Size) + { + albumList.Items[albumList.Size].ifields[1]++; + if (p->length>0) albumList.Items[albumList.Size].length += p->length; + if (p->filesize>0) albumList.Items[albumList.Size].size += p->filesize; + } + if (nextFilter && (!lastalb || WCSCMP_NULLOK(lastalb,nextFilter->GroupText(p,albbuf2,100)))) + { + lastalb = nextFilter->GroupText(p,albbuf,100); + if (lastalb && *lastalb) albumList.Items[albumList.Size].ifields[0]++; + if (lastalb) SKIP_THE_AND_WHITESPACEW(lastalb) // optimization technique + } + p++; + } + wchar_t buf[64] = {0}, sStr[16] = {0}, langBuf[64] = {0}; + if (isbl) + { + wsprintfW(buf, WASABI_API_LNGSTRINGW_BUF(IDS_ALL_X_ALBUMS_X_WITHOUT_ALBUM, langBuf, 64), albumList.Size - 1, WASABI_API_LNGSTRINGW_BUF(albumList.Size == 2 ? IDS_ALBUM : IDS_ALBUMS,sStr,16), isbl); + } + else + { + wsprintfW(buf, WASABI_API_LNGSTRINGW_BUF(IDS_ALL_X_ALBUMS, langBuf, 64), albumList.Size, WASABI_API_LNGSTRINGW_BUF(albumList.Size == 1 ? IDS_ALBUM : IDS_ALBUMS,sStr,16)); + } + albumList.Items[0].name = ndestring_wcsdup(buf); + albumList.Items[0].ifields[1] = numitems; + albumList.Items[0].ifields[0] = numitems2; + albumList.Size++; + numGroups = numalbumstotal; +} + +bool AlbumArtFilter::MakeFilterQuery(int x, GayStringW *query) +{ + queryListItem * l = &albumList.Items[x+1]; + // this mess appends this query: + // (album="l->album" && ((albumartist isempty && artist="l->artist") || (albumartist isnotempty && albumartist="l->artist"))) + query->Append(L"(album=\""); + GayStringW escaped; + queryStrEscape(l->name, escaped); + query->Append(escaped.Get()); + escaped.Set(L""); + query->Append(L"\" && ((albumartist isempty && artist LIKE \""); + queryStrEscape(l->artist, escaped); + query->Append(escaped.Get()); + query->Append(L"\") || (albumartist isnotempty && albumartist LIKE \""); + query->Append(escaped.Get()); + query->Append(L"\")))"); + return true; +} + +HMENU AlbumArtFilter::GetMenu(bool isFilter, int filterNum, C_Config *c, HMENU themenu) +{ + HMENU menu = GetSubMenu(themenu, 6); + + int checked=0; + switch (mode) + { + case 0: checked=ID_ARTHEADERWND_SMALLDETAILS; break; + case 1: checked=ID_ARTHEADERWND_MEDIUMDETAILS; break; + case 2: checked=ID_ARTHEADERWND_LARGEDETAILS; break; + case 3: checked=ID_ARTHEADERWND_SMALLICON; break; + case 4: checked=ID_ARTHEADERWND_MEDIUMICON; break; + case 5: checked=ID_ARTHEADERWND_LARGEICON; break; + case 6: checked=ID_ARTHEADERWND_EXTRALARGEICON; break; + } + CheckMenuItem(menu,checked,MF_CHECKED | MF_BYCOMMAND); + CheckMenuItem(menu,ID_ARTHEADERWND_SHOWTEXT,(icons_only ? MF_UNCHECKED : MF_CHECKED) | MF_BYCOMMAND); + + if (isFilter) + { + MENUITEMINFO m={sizeof(m),MIIM_ID,0}; + int i=0; + while (GetMenuItemInfo(menu,i,TRUE,&m)) + { + m.wID |= (1+filterNum) << 16; + SetMenuItemInfo(menu,i,TRUE,&m); + i++; + } + } + return menu; +} + +void AlbumArtFilter::ProcessMenuResult(int r, bool isFilter, int filterNum, C_Config *c, HWND parent) +{ + int mid = (r >> 16), newMode; + BOOL updateChache = FALSE; + BOOL iconsOnly = FALSE; + if (!isFilter && mid) return; + if (isFilter && mid-1 != filterNum) return; + + switch (LOWORD(r)) + { + case ID_ARTHEADERWND_SMALLDETAILS: newMode=0; break; + case ID_ARTHEADERWND_MEDIUMDETAILS: newMode=1; break; + case ID_ARTHEADERWND_LARGEDETAILS: newMode=2; break; + case ID_ARTHEADERWND_SMALLICON: newMode=3; break; + case ID_ARTHEADERWND_MEDIUMICON: newMode=4; break; + case ID_ARTHEADERWND_LARGEICON: newMode=5; break; + case ID_ARTHEADERWND_EXTRALARGEICON:newMode=6; break; + case ID_ARTHEADERWND_SHOWTEXT: + { + newMode = mode; + icons_only = !icons_only; + // only update view if in icon view + if (!isDetailsMode(mode)) { + iconsOnly = TRUE; + } + } + break; + default: return; + } + + if (mode == newMode && iconsOnly == FALSE) return; + + if (!iconsOnly) { + int w1, w2, h1, h2; + getImgSize(mode, w1, h1); + getImgSize(newMode, w2, h2); + updateChache = (w1 != w2 || h1 != h2); + mode = newMode; + } + + c->WriteInt(L"albumartviewmode",mode); + c->WriteInt(L"albumarticonmode",icons_only); + SaveColumnWidths(); + while (ListView_DeleteColumn(list->getwnd(), 0)); + if (updateChache) FlushCache(); + + for (int i=0;i!=albumList.Size;i++) + { + if (albumList.Items[i].art) + { + albumList.Items[i].art->Reset(); + albumList.Items[i].art->updateMsg.hwnd=0; + } + } + + DialogProc(parent,WM_INITDIALOG,0,0); + if (updateChache) ResumeCache(); + HWND hwndList = GetDlgItem(parent,dlgitem); + if (hwndList) + { + MLSkinnedWnd_SkinChanged(hwndList, TRUE, TRUE); + list->setwnd(hwndList); + AddColumns(); + CalcuateItemHeight(); + ListView_SetItemCount(hwndList, Size()); + } +} + +void AlbumArtFilter::MetaUpdate(int r, const wchar_t *metaItem, const wchar_t *value) +{ + if(_wcsicmp(metaItem, DB_FIELDNAME_rating )==0) + albumList.Items[r+1].rating = _wtoi(value) * albumList.Items[r+1].ifields[1]; + + SendMessage(GetDlgItem(hwndDlg,dlgitem),LVM_REDRAWITEMS,r,r); + UpdateWindow(GetDlgItem(hwndDlg,dlgitem)); +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/AlbumArtFilter.h b/Src/Plugins/Library/ml_local/AlbumArtFilter.h new file mode 100644 index 00000000..b3a1439c --- /dev/null +++ b/Src/Plugins/Library/ml_local/AlbumArtFilter.h @@ -0,0 +1,64 @@ +#ifndef NULLSOFT_ML_LOCAL_ALBUMART_FILTER_H_ +#define NULLSOFT_ML_LOCAL_ALBUMART_FILTER_H_ + +#include "AlbumFilter.h" +#include <tataki/bitmap/autobitmap.h> + +class AlbumArtFilter : public AlbumFilter +{ +public: + AlbumArtFilter(HWND hwndDlg, int dlgitem, C_Config *c); + virtual ~AlbumArtFilter(); + virtual char * GetConfigId(){return "av_art";} + virtual int Size() { return albumList.Size - 1; } + virtual const wchar_t *GetText(int row) { return AlbumFilter::GetText(row+1); } + virtual void CopyText(int row, size_t column, wchar_t *dest, int destCch) { return AlbumFilter::CopyText(row+1,column,dest,destCch); } + virtual const wchar_t *CopyText2(int row, size_t column, wchar_t *dest, int destCch) { return AlbumFilter::CopyText2(row+1,column,dest,destCch); } + + virtual INT_PTR DialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam); + AlbumArtContainer * GetArt(int row) { return albumList.Items[row].art; } + + BOOL DrawItemIcon(NMLVCUSTOMDRAW *plvcd, DCCanvas *pCanvas, UINT itemState, RECT *prcClip, BOOL bWndActive); + BOOL PrepareDetails(HDC hdc); + BOOL DrawItemDetail(NMLVCUSTOMDRAW *plvcd, DCCanvas *pCanvas, UINT itemState, RECT *prcClip, BOOL bWndActive, HDC hdcNaes, INT namesWidth); + void drawArt(AlbumArtContainer *art, DCCanvas *pCanvas, RECT *prcDst, int itemid, int imageIndex); + + void AddColumns2(); + void Fill(itemRecordW *items, int numitems, int *killswitch, int numitems2); + virtual bool HasTopItem() {return false;} + static int __fastcall MyBuildSortFunc(const void *elem1, const void *elem2, const void *context); + virtual bool MakeFilterQuery(int x, GayStringW *query); + + virtual HMENU GetMenu(bool isFilter, int filterNum, C_Config *c, HMENU themenu); + virtual void ProcessMenuResult(int r, bool isFilter, int filterNum, C_Config *c, HWND parent); + + virtual void MetaUpdate(int r, const wchar_t *metaItem, const wchar_t *value); + +protected: + BOOL OnCustomDrawDetails(NMLVCUSTOMDRAW *plvcd, LRESULT *pResult); + BOOL OnCustomDrawIcon(NMLVCUSTOMDRAW *plvcd, LRESULT *pResult); + BOOL OnKeyDown(NMLVKEYDOWN *plvkd); + BOOL CalcuateItemHeight(void); +protected: + DWORD ratingHotItem; + int ratingHotValue; + int dlgitem; + HWND hwndDlg; + HWND hwndRealList; + int mode; + int icons_only; + AutoSkinBitmap notfound; + AutoSkinBitmap notfound60; + AutoSkinBitmap notfound90; + ARGB32 * classicnotfound[3]; + int classicnotfoundW,classicnotfoundH; + INT ratingrow; + HBITMAP hbmpNames; + INT itemHeight; + INT textHeight; + INT ratingTop; + INT namesWidth; + HBRUSH bgBrush; +}; + +#endif // NULLSOFT_ML_LOCAL_ALBUMART_FILTER_H_
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/AlbumFilter.cpp b/Src/Plugins/Library/ml_local/AlbumFilter.cpp new file mode 100644 index 00000000..af414d2d --- /dev/null +++ b/Src/Plugins/Library/ml_local/AlbumFilter.cpp @@ -0,0 +1,496 @@ +#include "main.h" +#include "api__ml_local.h" +#include "../nu/sort.h" +#include "AlbumFilter.h" +#include "resource.h" +#include <shlwapi.h> + +static size_t m_sort_by, m_sort_dir, m_sort_which; + +void emptyQueryListObject(queryListObject *obj); +int reallocQueryListObject(queryListObject *obj); +void freeQueryListObject(queryListObject *obj); + + +int AlbumFilter::AlbumSortFunc(const void *elem1, const void *elem2) +{ + const queryListItem *a = (const queryListItem*)elem1; + const queryListItem *b = (const queryListItem*)elem2; + int use_by = m_sort_by; + int use_dir = m_sort_dir; +#define RETIFNZ(v) if ((v)<0) return use_dir?1:-1; if ((v)>0) return use_dir?-1:1; + if (use_by == ALBUMFILTER_COLUMN_NAME) + { + int v = WCSCMP_NULLOK(a->name, b->name); + RETIFNZ(v) + v = b->ifields[2] - a->ifields[2]; + RETIFNZ(v) + v = b->ifields[1] - a->ifields[1]; + return v; + } + if (use_by == ALBUMFILTER_COLUMN_YEAR) + { + int v = a->ifields[2] - b->ifields[2]; + RETIFNZ(v) + return WCSCMP_NULLOK(a->name, b->name); + } + if (use_by == ALBUMFILTER_COLUMN_ALBUMS) + { + int v = a->ifields[0] - b->ifields[0]; + RETIFNZ(v) + return WCSCMP_NULLOK(a->name, b->name); + } + if (use_by == ALBUMFILTER_COLUMN_TRACKS) + { + int v = a->ifields[1] - b->ifields[1]; + RETIFNZ(v) + return WCSCMP_NULLOK(a->name, b->name); + } + + if (use_by == ALBUMFILTER_COLUMN_REPLAYGAIN) + { + int v = FLOATWCMP_NULLOK(a->albumGain, b->albumGain); + RETIFNZ(v) + return WCSCMP_NULLOK(a->name, b->name); + } + + if(use_by == ALBUMFILTER_COLUMN_SIZE) + { + __int64 v = a->size - b->size; + RETIFNZ(v) + return WCSCMP_NULLOK(a->name, b->name); + } + + if(use_by == ALBUMFILTER_COLUMN_LENGTH) + { + int v = a->length - b->length; + RETIFNZ(v) + return WCSCMP_NULLOK(a->name, b->name); + } + if(use_by == ALBUMFILTER_COLUMN_RATING) { + int ar = 0; + if(a->ifields[1]) ar = a->rating/a->ifields[1]; + int br = 0; + if(b->ifields[1]) br = b->rating/b->ifields[1]; + int v = ar - br; + RETIFNZ(v) + } + if(use_by == ALBUMFILTER_COLUMN_ARTIST || use_by == ALBUMFILTER_COLUMN_RATING) { + int v = WCSCMP_NULLOK(a->artist, b->artist); + RETIFNZ(v) + v = WCSCMP_NULLOK(a->name, b->name); + RETIFNZ(v) + } + else if(use_by == ALBUMFILTER_COLUMN_GENRE) { + int v = WCSCMP_NULLOK(a->genre, b->genre); + RETIFNZ(v) + v = WCSCMP_NULLOK(a->artist, b->artist); + RETIFNZ(v) + v = WCSCMP_NULLOK(a->name, b->name); + RETIFNZ(v) + } + if(use_by == ALBUMFILTER_COLUMN_LASTUPD) + { + int v = (int)(b->lastupd - a->lastupd); + RETIFNZ(v) + return WCSCMP_NULLOK(a->name, b->name); + } + +#undef RETIFNZ + return 0; +} + +void AlbumFilter::SortResults(C_Config *viewconf, int which, int isfirst) // sorts the results based on the current sort mode +{ + if (viewconf) + { + wchar_t buf[64] = {0}; + StringCchPrintfW(buf, ARRAYSIZE(buf), L"%hs_sort_by_%d", GetConfigId(), which); + m_sort_by = viewconf->ReadInt(buf, 0); + StringCchPrintfW(buf, ARRAYSIZE(buf), L"%hs_sort_dir_%d", GetConfigId(), which); + m_sort_dir = viewconf->ReadInt(buf, 0); + m_sort_which = which; + + if(showncolumns.size()>m_sort_by && m_sort_by>=0) m_sort_by = showncolumns[m_sort_by]->field; + + if (m_sort_dir == 0 && m_sort_by == 0 && isfirst) return; + + if (albumList.Size > 2) qsort(albumList.Items+1,albumList.Size-1,sizeof(queryListItem),AlbumSortFunc); + } +} + +void AlbumFilter::Fill(itemRecordW *items, int numitems, int *killswitch, int numitems2) +{ + if (numitems > 1) + qsort_itemRecord(items,numitems, this, BuildSortFunc); + + if (killswitch && *killswitch) return; + + emptyQueryListObject(&albumList); + reallocQueryListObject(&albumList); + + itemRecordW *p = items; + int n = numitems; + int numalbumstotal = 0; + wchar_t *lastname = 0; + const wchar_t *lastalb=0; + wchar_t albbuf[100] = {0}, albbuf2[100] = {0}; + ZeroMemory(&albumList.Items[0],sizeof(queryListItem)); + int isbl = 0; + while (n--) + { + if (killswitch && *killswitch) return; + if (!lastname || WCSCMP_NULLOK(lastname, p->album)) + { + albumList.Size++; + if (reallocQueryListObject(&albumList)) break; + wchar_t *albumGain = p->replaygain_album_gain; + ndestring_retain(albumGain); + wchar_t *gracenoteFileId = getRecordExtendedItem_fast(p, extended_fields.GracenoteFileID); + ZeroMemory(&albumList.Items[albumList.Size],sizeof(queryListItem)); + albumList.Items[albumList.Size].albumGain = albumGain; + albumList.Items[albumList.Size].gracenoteFileId = gracenoteFileId; + ndestring_retain(gracenoteFileId); + + if (p->album) + { + ndestring_retain(p->album); + lastname = albumList.Items[albumList.Size].name = p->album; + } + else + lastname = albumList.Items[albumList.Size].name = emptyQueryListString; + + lastalb=0; + SKIP_THE_AND_WHITESPACEW(lastname) // optimization technique + if(*lastname) numalbumstotal++; + } + if(p->year>0) { + int y = albumList.Items[albumList.Size].ifields[2]; + if(y == 0) y = MAKELONG((short)p->year,(short)p->year); + else if(p->year > (short)LOWORD(y)) y = MAKELONG((short)p->year,(short)HIWORD(y)); + else if(p->year < (short)HIWORD(y)) y = MAKELONG((short)LOWORD(y),(short)p->year); + albumList.Items[albumList.Size].ifields[2] = y; + } + + if (!p->album || !*p->album) isbl++; + if (albumList.Size) { + albumList.Items[albumList.Size].ifields[1]++; + if(p->length>0) albumList.Items[albumList.Size].length += p->length; + if(p->filesize>0) albumList.Items[albumList.Size].size += p->filesize; + } + if (nextFilter && (!lastalb || WCSCMP_NULLOK(lastalb,nextFilter->GroupText(p,albbuf2,100)))) + { + lastalb = nextFilter->GroupText(p,albbuf,100); + if(lastalb && *lastalb) albumList.Items[albumList.Size].ifields[0]++; + if (lastalb) SKIP_THE_AND_WHITESPACEW(lastalb) // optimization technique + } + p++; + } + wchar_t buf[64] = {0}, sStr[16] = {0}, langBuf[64] = {0}; + if (isbl) + { + wsprintfW(buf, WASABI_API_LNGSTRINGW_BUF(IDS_ALL_X_ALBUMS_X_WITHOUT_ALBUM, langBuf, 64), albumList.Size - 1, WASABI_API_LNGSTRINGW_BUF(albumList.Size == 2 ? IDS_ALBUM : IDS_ALBUMS,sStr,16), isbl); + } + else + { + wsprintfW(buf, WASABI_API_LNGSTRINGW_BUF(IDS_ALL_X_ALBUMS, langBuf, 64), albumList.Size, WASABI_API_LNGSTRINGW_BUF(albumList.Size == 1 ? IDS_ALBUM : IDS_ALBUMS,sStr,16)); + } + + // for some languages a lowercased first word is invalid so need to prevent this from happening + process_substantives(buf); + + albumList.Items[0].name = ndestring_wcsdup(buf); + albumList.Items[0].ifields[1] = numitems; + albumList.Items[0].ifields[0] = numitems2; + albumList.Size++; + numGroups = numalbumstotal; +} + +int AlbumFilter::Size() +{ + return albumList.Size; +} + +const wchar_t *AlbumFilter::GetText(int row) // gets main text (first column) +{ + return (row < albumList.Size) ? albumList.Items[row].name : NULL; +} + +void AlbumFilter::Empty() +{ + freeQueryListObject(&albumList); +} + + +void AlbumFilter::CopyText(int row, size_t column, wchar_t *dest, int destCch) +{ + if(column >= showncolumns.size()) return; + column = showncolumns[column]->field; + if (row>=albumList.Size) + return ; + switch(column) + { + case ALBUMFILTER_COLUMN_NAME: // name + if (albumList.Items[row].name && *albumList.Items[row].name) + lstrcpynW(dest,albumList.Items[row].name,destCch); + else + WASABI_API_LNGSTRINGW_BUF(IDS_NO_ALBUM,dest,destCch); + break; + case ALBUMFILTER_COLUMN_YEAR: // year + if (HIWORD(albumList.Items[row].ifields[2]) < 1) + dest[0] = 0; + else { + int y = albumList.Items[row].ifields[2]; + if(HIWORD(y) == LOWORD(y)) StringCchPrintfW(dest, destCch, L"%d", HIWORD(y)); + else if(HIWORD(y)/100 == LOWORD(y)/100) StringCchPrintfW(dest, destCch, L"%d-%02d", HIWORD(y),LOWORD(y)%100); + else StringCchPrintfW(dest, destCch, L"%d-%d", HIWORD(y),LOWORD(y)); + } + break; + case ALBUMFILTER_COLUMN_ALBUMS: // albums + StringCchPrintfW(dest, destCch,L"%d",albumList.Items[row].ifields[0]); + break; + case ALBUMFILTER_COLUMN_TRACKS: // tracks + StringCchPrintfW(dest, destCch,L"%d",albumList.Items[row].ifields[1]); + break; + case ALBUMFILTER_COLUMN_REPLAYGAIN: // album replay gain + if (albumList.Items[row].albumGain) + lstrcpynW(dest, albumList.Items[row].albumGain, destCch); + else + dest[0] = 0; + break; + case ALBUMFILTER_COLUMN_SIZE: // size + if(row && albumList.Items[row].size) { + WASABI_API_LNG->FormattedSizeString(dest, destCch, albumList.Items[row].size); + } else dest[0]=0; + break; + case ALBUMFILTER_COLUMN_LENGTH: // length + if(row && albumList.Items[row].length) + StringCchPrintfW(dest, destCch,L"%d:%02d", albumList.Items[row].length / 60, albumList.Items[row].length % 60); + else dest[0]=0; + break; + case ALBUMFILTER_COLUMN_ARTIST: // artist + if(row && albumList.Items[row].artist) + lstrcpynW(dest,albumList.Items[row].artist,destCch); + else + WASABI_API_LNGSTRINGW_BUF(IDS_NO_ARTIST,dest,destCch); + break; + case ALBUMFILTER_COLUMN_GENRE: // genre + if(row && albumList.Items[row].genre) + lstrcpynW(dest,albumList.Items[row].genre,destCch); + else + WASABI_API_LNGSTRINGW_BUF(IDS_NO_GENRE,dest,destCch); + break; + case ALBUMFILTER_COLUMN_RATING: // rating + dest[0]=0; + if(row && albumList.Items[row].rating > 0 && albumList.Items[row].ifields[1]) { + int r = albumList.Items[row].rating / albumList.Items[row].ifields[1]; + if(r >=0 && r<=5) { + wchar_t ra[]=L"*****"; + ra[r]=0; + StringCchPrintfW(dest, destCch,L"%d",ra); + } + } + break; + case ALBUMFILTER_COLUMN_LASTUPD: // last updated + dest[0]=0; + if(row && albumList.Items[row].lastupd) + { + StringCchPrintfW(dest, destCch,L"%d", albumList.Items[row].lastupd); + } + else dest[0]=0; + break; + } +} +const wchar_t *AlbumFilter::CopyText2(int row, size_t column, wchar_t *dest, int destCch) +{ + const wchar_t *cdest=dest; + if(column >= showncolumns.size()) return NULL; + column = showncolumns[column]->field; + if (row>=albumList.Size) + return NULL; + switch(column) + { + case ALBUMFILTER_COLUMN_NAME: // name + if (albumList.Items[row].name && *albumList.Items[row].name) + cdest = albumList.Items[row].name; + else + WASABI_API_LNGSTRINGW_BUF(IDS_NO_ALBUM,dest,destCch); + break; + case ALBUMFILTER_COLUMN_YEAR: // year + if (HIWORD(albumList.Items[row].ifields[2]) < 1) + dest[0] = 0; + else { + int y = albumList.Items[row].ifields[2]; + if(HIWORD(y) == LOWORD(y)) StringCchPrintfW(dest, destCch, L"%d", HIWORD(y)); + else if(HIWORD(y)/100 == LOWORD(y)/100) StringCchPrintfW(dest, destCch, L"%d-%02d", HIWORD(y),LOWORD(y)%100); + else StringCchPrintfW(dest, destCch, L"%d-%d", HIWORD(y),LOWORD(y)); + } + break; + case ALBUMFILTER_COLUMN_ALBUMS: // albums + StringCchPrintfW(dest, destCch,L"%d",albumList.Items[row].ifields[0]); + break; + case ALBUMFILTER_COLUMN_TRACKS: // tracks + StringCchPrintfW(dest, destCch,L"%d",albumList.Items[row].ifields[1]); + break; + case ALBUMFILTER_COLUMN_REPLAYGAIN: // album replay gain + if (albumList.Items[row].albumGain) + cdest = albumList.Items[row].albumGain; + else + dest[0] = 0; + break; + case ALBUMFILTER_COLUMN_SIZE: // size + if(row && albumList.Items[row].size) { + WASABI_API_LNG->FormattedSizeString(dest, destCch, albumList.Items[row].size); + } else dest[0]=0; + break; + case ALBUMFILTER_COLUMN_LENGTH: // length + if(row && albumList.Items[row].length) + StringCchPrintfW(dest, destCch,L"%d:%02d", albumList.Items[row].length / 60, albumList.Items[row].length % 60); + else dest[0]=0; + break; + case ALBUMFILTER_COLUMN_ARTIST: // artist + if(row && albumList.Items[row].artist) + cdest = albumList.Items[row].artist; + else + WASABI_API_LNGSTRINGW_BUF(IDS_NO_ARTIST,dest,destCch); + break; + case ALBUMFILTER_COLUMN_GENRE: // genre + if(row && albumList.Items[row].genre) + cdest = albumList.Items[row].genre; + else + WASABI_API_LNGSTRINGW_BUF(IDS_NO_GENRE,dest,destCch); + break; + case ALBUMFILTER_COLUMN_RATING: // rating + dest[0]=0; + if(row && albumList.Items[row].rating > 0 && albumList.Items[row].ifields[1]) { + double d = double(albumList.Items[row].rating) / double(albumList.Items[row].ifields[1]); + int r = int(d); + if(d - double(r) >= 0.5 && r<5) r++; + if(r >=0 && r<=5) { + wchar_t ra[]=L"*****"; + ra[r]=0; + StringCchPrintfW(dest, destCch,L"%s",ra); + } + } + break; + case ALBUMFILTER_COLUMN_LASTUPD: // last updated + dest[0]=0; + if(row && albumList.Items[row].lastupd) + { + StringCchPrintfW(dest, destCch,L"%d", albumList.Items[row].lastupd); + } + else dest[0]=0; + break; + } + return cdest; +} +const wchar_t *AlbumFilter::GetField() +{ + return DB_FIELDNAME_album; +} + +const wchar_t *AlbumFilter::GetName() +{ + return WASABI_API_LNGSTRINGW_BUF(IDS_ALBUMS,name,64); +} + +const wchar_t *AlbumFilter::GetNameSingular() +{ + return WASABI_API_LNGSTRINGW_BUF(IDS_ALBUM,sing_name,64); +} + +const wchar_t *AlbumFilter::GetNameSingularAlt(int mode) +{ + return WASABI_API_LNGSTRINGW_BUF((!mode?IDS_ALBUM_ALT:(mode==1?2064:2080)),sing_name_alt,64); +} + +char * AlbumFilter::getColConfig(int i) { + switch (i) { + case 0: return "album"; + case 1: return "year"; + case 2: return "nf"; + case 3: return "tracks"; + case 4: return "albumgain"; + case 5: return "size"; + case 6: return "length"; + case 7: return "artist"; + case 8: return "genre"; + case 9: return "rating"; + case 10: return "lastupd"; + } + return ""; +} + +static void readConf(C_Config * c, int col, int * width, int * pos, bool * hidden, int defwidth, int defpos, bool defhidden, char * confid) { + char * name = AlbumFilter::getColConfig(col); + wchar_t buf[100] = {0}; + StringCchPrintfW(buf, ARRAYSIZE(buf), L"%hs_col_%hs", confid, name); + *width = c->ReadInt(buf, defwidth); + StringCchPrintfW(buf, ARRAYSIZE(buf), L"%hs_col_%hs_pos", confid, name); + *pos = c->ReadInt(buf, defpos); + StringCchPrintfW(buf, ARRAYSIZE(buf), L"%hs_col_%hs_hidden", confid, name); + *hidden = !!c->ReadInt(buf, defhidden); +} + +static void saveConf(C_Config * c, int col, int defwidth, int defpos, bool defhidden, bool exists, char * confid) { + char * name = AlbumFilter::getColConfig(col); + wchar_t buf[100] = {0}; + if(exists) { + StringCchPrintfW(buf, ARRAYSIZE(buf), L"%hs_col_%hs", confid, name); + c->WriteInt(buf, defwidth); + StringCchPrintfW(buf, ARRAYSIZE(buf), L"%hs_col_%hs_pos", confid, name); + c->WriteInt(buf, defpos); + } + StringCchPrintfW(buf, ARRAYSIZE(buf), L"%hs_col_%hs_hidden", confid, name); + c->WriteInt(buf, defhidden); +} + +void AlbumFilter::AddColumns2() { + int width, pos; + bool hidden; + char * config = GetConfigId(); + readConf(g_view_metaconf,0,&width,&pos,&hidden,155,0,false,config); + showncolumns.push_back(new ListField(0,width,IDS_ALBUM,g_view_metaconf,"",hidden,false,false,pos)); + readConf(g_view_metaconf,1,&width,&pos,&hidden,47,1,false,config); + showncolumns.push_back(new ListField(1,width,IDS_YEAR,g_view_metaconf,"",hidden,false,false,pos)); + readConf(g_view_metaconf,2,&width,&pos,&hidden,48,2,false,config); + if(nextFilter) + showncolumns.push_back(new ListField(2,width,nextFilter->GetName(),g_view_metaconf,"",hidden,false,false,pos)); + readConf(g_view_metaconf,3,&width,&pos,&hidden,47,3,false,config); + showncolumns.push_back(new ListField(3,width,IDS_TRACKS_MENU,g_view_metaconf,"",hidden,false,false,pos)); + + readConf(g_view_metaconf,4,&width,&pos,&hidden,77,4,!g_config->ReadInt(L"show_albumgain", 0),config); + showncolumns.push_back(new ListField(4,width,IDS_ALBUM_GAIN,g_view_metaconf,"",hidden,true,false,pos)); + + readConf(g_view_metaconf,5,&width,&pos,&hidden,45,5,true,config); + showncolumns.push_back(new ListField(5,width,IDS_SIZE,g_view_metaconf,"",hidden,true,false,pos)); + readConf(g_view_metaconf,6,&width,&pos,&hidden,45,6,true,config); + showncolumns.push_back(new ListField(6,width,IDS_LENGTH,g_view_metaconf,"",hidden,true,false,pos)); +} + + +void AlbumFilter::SaveColumnWidths() +{ + char *config = GetConfigId(); + for ( size_t i = 0; i < showncolumns.size(); i++ ) + { + int field = showncolumns[ i ]->field; + saveConf( g_view_metaconf, field, list->GetColumnWidth( i ), i, 0, list->ColumnExists( i ), config ); + } + for ( size_t i = 0; i < hiddencolumns.size(); i++ ) + { + int field = hiddencolumns[ i ]->field; + saveConf( g_view_metaconf, field, 0, 0, true, false, config ); + } +} + +const wchar_t * AlbumFilter::GroupText(itemRecordW * item, wchar_t * buf, int len) { + return item->album; +} + +void AlbumFilter::CustomizeColumns(HWND parent, BOOL showmenu) { + ViewFilter::CustomizeColumns(parent,showmenu); + int v = 0; + for (size_t i = 0;i < showncolumns.size();i++) if(showncolumns[i]->field == 4) { v=1; break; } + g_config->WriteInt(L"show_albumgain", v); +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/AlbumFilter.h b/Src/Plugins/Library/ml_local/AlbumFilter.h new file mode 100644 index 00000000..371ee111 --- /dev/null +++ b/Src/Plugins/Library/ml_local/AlbumFilter.h @@ -0,0 +1,49 @@ +#ifndef NULLSOFT_ML_LOCAL_ALBUMFILTER_H +#define NULLSOFT_ML_LOCAL_ALBUMFILTER_H + +#include "ViewFilter.h" + +class AlbumFilter : public ViewFilter +{ +public: + static int AlbumSortFunc(const void *elem1, const void *elem2); + void SortResults(C_Config *viewconf, int which=0, int isfirst=0); + void Fill(itemRecordW *items, int numitems, int *killswitch, int numitems2); + virtual int Size(); + virtual const wchar_t *GetText(int row); + virtual void CopyText(int row, size_t column, wchar_t *dest, int destCch); + virtual const wchar_t *CopyText2(int row, size_t column, wchar_t *dest, int destCch); + void Empty(); + const wchar_t *GetField(); + const wchar_t *GetName(); + const wchar_t *GetNameSingular(); + const wchar_t *GetNameSingularAlt(int mode); + void AddColumns2(); + virtual const wchar_t * GroupText(itemRecordW * item, wchar_t * buf, int len); + virtual void SaveColumnWidths(); + virtual void CustomizeColumns(HWND parent, BOOL showmenu); + virtual char * GetConfigId(){return "av2";} + static char * getColConfig(int i); + wchar_t name[64]; + wchar_t sing_name[64]; + wchar_t sing_name_alt[64]; +protected: + queryListObject albumList; + + enum + { + ALBUMFILTER_COLUMN_NAME = 0, + ALBUMFILTER_COLUMN_YEAR = 1, + ALBUMFILTER_COLUMN_ALBUMS = 2, + ALBUMFILTER_COLUMN_TRACKS = 3, + ALBUMFILTER_COLUMN_REPLAYGAIN = 4, + ALBUMFILTER_COLUMN_SIZE = 5, + ALBUMFILTER_COLUMN_LENGTH = 6, + ALBUMFILTER_COLUMN_ARTIST = 7, + ALBUMFILTER_COLUMN_GENRE = 8, + ALBUMFILTER_COLUMN_RATING = 9, + ALBUMFILTER_COLUMN_LASTUPD = 10, + }; +}; + +#endif
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/DBitemrecord.cpp b/Src/Plugins/Library/ml_local/DBitemrecord.cpp new file mode 100644 index 00000000..d301ec14 --- /dev/null +++ b/Src/Plugins/Library/ml_local/DBitemrecord.cpp @@ -0,0 +1,173 @@ +#include "main.h" +#include "ml_local.h" + +#ifdef _M_IX86 +const size_t convert_max_characters = 16; // it's actually 11, but this probably causes less memory fragmentation +#elif defined(_M_X64) +const size_t convert_max_characters = 20; +#endif + +bool compat_mode = false; + +typedef void (__fastcall *FieldFunc)(itemRecordW *obj, nde_field_t f); +#define FIELD_FUNC(field) field ## Func +#define STRINGFIELD_FUNC(item) static void __fastcall FIELD_FUNC(item)(itemRecordW *obj, nde_field_t f) { obj-> ## item = NDE_StringField_GetString(f); ndestring_retain(obj-> ## item); } +#define INTFIELD_FUNC(item) static void __fastcall FIELD_FUNC(item)(itemRecordW *obj, nde_field_t f) { obj-> ## item = NDE_IntegerField_GetValue(f); } +#define EXT_STRINGFIELD_FUNC(field) static void __fastcall FIELD_FUNC(field)(itemRecordW *obj, nde_field_t f) { setRecordExtendedItem_fast(obj, extended_fields.field, NDE_StringField_GetString(f)); } +#define EXT_INTFIELD_FUNC(field) static void __fastcall FIELD_FUNC(field)(itemRecordW *obj, nde_field_t f) { wchar_t *temp = ndestring_malloc(convert_max_characters*sizeof(wchar_t)); unsigned int v = NDE_IntegerField_GetValue(f); wsprintfW(temp, L"%u", v); setRecordExtendedItem_fast(obj, extended_fields.field, temp); ndestring_release(temp); } +#define REALSIZE_INTFIELD_FUNC(field) static void __fastcall FIELD_FUNC(field)(itemRecordW *obj, nde_field_t f) {\ + wchar_t *temp = ndestring_malloc(convert_max_characters*sizeof(wchar_t));\ + __int64 v = NDE_Int64Field_GetValue(f);\ + obj-> ## field = (v > 0 ? ((int)(compat_mode ? v >> 10 : v)) : 0);\ + wsprintfW(temp, L"%ld", v);\ + setRecordExtendedItem_fast(obj, extended_fields.realsize, temp);\ + ndestring_release(temp);\ +} +STRINGFIELD_FUNC(title); +STRINGFIELD_FUNC(artist); +STRINGFIELD_FUNC(album); +INTFIELD_FUNC(year); +STRINGFIELD_FUNC(genre); +STRINGFIELD_FUNC(comment); +INTFIELD_FUNC(track); +INTFIELD_FUNC(length); +INTFIELD_FUNC(type); +INTFIELD_FUNC(lastupd); +INTFIELD_FUNC(lastplay); +INTFIELD_FUNC(rating); +INTFIELD_FUNC(playcount); +INTFIELD_FUNC(filetime); +// use a custom version to set 'filesize' and 'realsize' to ensure compatibility +REALSIZE_INTFIELD_FUNC(filesize); +INTFIELD_FUNC(bitrate); +INTFIELD_FUNC(disc); +STRINGFIELD_FUNC(albumartist); +STRINGFIELD_FUNC(replaygain_album_gain); +STRINGFIELD_FUNC(replaygain_track_gain); +STRINGFIELD_FUNC(publisher); +STRINGFIELD_FUNC(composer); +INTFIELD_FUNC(bpm); +INTFIELD_FUNC(discs); +INTFIELD_FUNC(tracks); +EXT_INTFIELD_FUNC(ispodcast); +EXT_STRINGFIELD_FUNC(podcastchannel); +EXT_INTFIELD_FUNC(podcastpubdate); +EXT_STRINGFIELD_FUNC(GracenoteFileID); +EXT_STRINGFIELD_FUNC(GracenoteExtData); +EXT_INTFIELD_FUNC(lossless); +STRINGFIELD_FUNC(category); +EXT_STRINGFIELD_FUNC(codec); +EXT_STRINGFIELD_FUNC(director); +EXT_STRINGFIELD_FUNC(producer); +EXT_INTFIELD_FUNC(width); +EXT_INTFIELD_FUNC(height); +EXT_STRINGFIELD_FUNC(mimetype); +EXT_INTFIELD_FUNC(dateadded); + +static void __fastcall NullFieldFunction(itemRecordW *obj, nde_field_t f) {} +static FieldFunc field_functions[] = +{ + NullFieldFunction, // filename + FIELD_FUNC(title), + FIELD_FUNC(artist), + FIELD_FUNC(album), + FIELD_FUNC(year), + FIELD_FUNC(genre), + FIELD_FUNC(comment), + FIELD_FUNC(track), + FIELD_FUNC(length), + FIELD_FUNC(type), + FIELD_FUNC(lastupd), + FIELD_FUNC(lastplay), + FIELD_FUNC(rating), + NullFieldFunction, // skip lucky number 13 + NullFieldFunction, // gracenote ID + FIELD_FUNC(playcount), + FIELD_FUNC(filetime), + FIELD_FUNC(filesize), + FIELD_FUNC(bitrate), + FIELD_FUNC(disc), + FIELD_FUNC(albumartist), + FIELD_FUNC(replaygain_album_gain), + FIELD_FUNC(replaygain_track_gain), + FIELD_FUNC(publisher), + FIELD_FUNC(composer), + FIELD_FUNC(bpm), + FIELD_FUNC(discs), + FIELD_FUNC(tracks), + FIELD_FUNC(ispodcast), + FIELD_FUNC(podcastchannel), + FIELD_FUNC(podcastpubdate), + FIELD_FUNC(GracenoteFileID), + FIELD_FUNC(GracenoteExtData), + FIELD_FUNC(lossless), + FIELD_FUNC(category), + FIELD_FUNC(codec), + FIELD_FUNC(director), + FIELD_FUNC(producer), + FIELD_FUNC(width), + FIELD_FUNC(height), + FIELD_FUNC(mimetype), + FIELD_FUNC(dateadded), +}; + +static int StoreField(void *record, nde_field_t field, void *context) +{ + unsigned char id = NDE_Field_GetID(field); + if (id < sizeof(field_functions)/sizeof(*field_functions)) + { + FieldFunc field_function = field_functions[id]; + field_function((itemRecordW *)context, field); + } + return 1; +} + +static void initRecord(itemRecordW *p) +{ + if (p) + { + p->title=0; + p->album=0; + p->artist=0; + p->comment=0; + p->genre=0; + p->albumartist=0; + p->replaygain_album_gain=0; + p->replaygain_track_gain=0; + p->publisher=0; + p->composer=0; + p->year=-1; + p->track=-1; + p->tracks=-1; + p->length=-1; + p->rating=-1; + p->playcount=-1; + p->lastplay=-1; + p->lastupd=-1; + p->filetime=-1; + p->filesize=-1; + p->bitrate=-1; + p->type=-1; + p->disc=-1; + p->discs=-1; + p->bpm=-1; + p->extended_info=0; + p->category=0; + } +} + +__int64 ScannerRefToObjCacheNFNW(nde_scanner_t s, itemRecordW *obj, bool compat) +{ + initRecord(obj); + compat_mode = compat; + NDE_Scanner_WalkFields(s, StoreField, obj); + return obj->filesize; +} + +__int64 ScannerRefToObjCacheNFNW(nde_scanner_t s, itemRecordListW *obj, bool compat) +{ + compat_mode = compat; + __int64 retval = ScannerRefToObjCacheNFNW(s, &obj->Items[obj->Size], compat); + obj->Size++; + return retval; +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/FolderBrowseEx.cpp b/Src/Plugins/Library/ml_local/FolderBrowseEx.cpp new file mode 100644 index 00000000..2c1b0de1 --- /dev/null +++ b/Src/Plugins/Library/ml_local/FolderBrowseEx.cpp @@ -0,0 +1,239 @@ +#include "main.h" +#include "./folderbrowseex.h" +#include "../nu/CGlobalAtom.h" +#include <shobjidl.h> +#include "../replicant/nu/AutoWide.h" + +static CGlobalAtom CLSPROP(L"FBEXDLG"); + +#ifdef _WIN64 +#define LONGPTR_CAST LONG_PTR +#else +#define LONGPTR_CAST LONG +#endif + +#define PATHTYPE_PIDL FALSE +#define PATHTYPE_STRING TRUE + +BOOL CALLBACK browseEnumProc(HWND hwnd, LPARAM lParam) +{ + wchar_t cl[32] = {0}; + GetClassName(hwnd, cl, ARRAYSIZE(cl)); + if (!lstrcmpi(cl, WC_TREEVIEW)) + { + PostMessage(hwnd, TVM_ENSUREVISIBLE, 0, (LPARAM)TreeView_GetSelection(hwnd)); + return FALSE; + } + + return TRUE; +} + +static int WINAPI BrowseCallback_Helper(HWND hwnd, UINT uMsg, LPARAM lParam, LPARAM lpData) +{ + FolderBrowseEx *lpfbex = reinterpret_cast<FolderBrowseEx*>(lpData); + if (!lpfbex) return 0; + + switch (uMsg) + { + case BFFM_INITIALIZED: + lpfbex->hwnd = hwnd; + if(SetPropW(hwnd, CLSPROP, (void*)lpData)) + { + lpfbex->oldProc = (LONG_PTR) ((IsWindowUnicode(hwnd)) ? SetWindowLongPtrW(hwnd, DWLP_DLGPROC, (LONGPTR_CAST)WindowProc_Helper) : SetWindowLongPtrA(hwnd, DWLP_DLGPROC, (LONGPTR_CAST)WindowProc_Helper)); + if (NULL == lpfbex->oldProc) RemovePropW(hwnd, CLSPROP); + } + + // this is not nice but it fixes the selection not working correctly on all OSes + EnumChildWindows(hwnd, browseEnumProc, 0); + break; + } + return lpfbex->BrowseCallback(uMsg, lParam); +} + +static LRESULT WINAPI WindowProc_Helper(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + FolderBrowseEx *lpfbex = static_cast<FolderBrowseEx*>(GetPropW(hwnd, CLSPROP)); + if (!lpfbex) return 0; + + switch(uMsg) + { + case WM_NCDESTROY: + lpfbex->DialogProc(uMsg, wParam, lParam); + if (IsWindowUnicode(hwnd)) SetWindowLongPtrW(hwnd, DWLP_DLGPROC, (LONGPTR_CAST)lpfbex->oldProc); + else SetWindowLongPtrA(hwnd, DWLP_DLGPROC, (LONGPTR_CAST)lpfbex->oldProc); + RemovePropW(hwnd, CLSPROP); + lpfbex->oldProc = NULL; + lpfbex->hwnd = NULL; + return 0; + } + return lpfbex->DialogProc(uMsg, wParam, lParam); +} + +static void Initialize(FolderBrowseEx *lpfbx, LPCITEMIDLIST pidlRoot, UINT ulFlags, LPCWSTR lpszCaption, LPCWSTR lpszTitle) +{ + lpfbx->pidlRoot = pidlRoot; + lpfbx->ulFlags = ulFlags; + + lpfbx->lpszCaption = NULL; + lpfbx->lpszTitle = NULL; + lpfbx->image = -1; + lpfbx->pidl = NULL; + lpfbx->hwnd = NULL; + lpfbx->oldProc = NULL; + + CoInitialize(NULL); + + lpfbx->pathExpanded.empty = TRUE; + lpfbx->pathSelection.empty = TRUE; + + if (lpszCaption) lpfbx->SetCaption(lpszCaption); + if (lpszTitle) lpfbx->SetTitle(lpszTitle); +} + +FolderBrowseEx::FolderBrowseEx(LPCITEMIDLIST pidlRoot, UINT ulFlags, LPCWSTR lpszCaption, LPCWSTR lpszTitle) +{ + Initialize(this, pidlRoot, ulFlags, lpszCaption, lpszTitle); +} + +FolderBrowseEx::FolderBrowseEx(UINT ulFlags, LPCWSTR lpszCaption, LPCWSTR lpszTitle) +{ + Initialize(this, NULL, ulFlags, lpszCaption, lpszTitle); +} + +FolderBrowseEx::FolderBrowseEx(UINT ulFlags, LPCWSTR lpszTitle) +{ + Initialize(this, NULL, ulFlags, L"", lpszTitle); +} + +FolderBrowseEx::FolderBrowseEx(void) +{ + Initialize(this, NULL, 0, L"", L""); +} + +FolderBrowseEx::~FolderBrowseEx(void) +{ + if (pidl) CoTaskMemFree(pidl); + if (lpszTitle) free(lpszTitle); + if (lpszCaption) free(lpszCaption); + CoUninitialize(); +} + +HRESULT FolderBrowseEx::ParseDisplayName(LPCWSTR lpszPath, IBindCtx *pbc, LPITEMIDLIST *ppidl, SFGAOF sfgaoIn, SFGAOF *psfgaoOut) +{ + IShellFolder *isf = NULL; + HRESULT result; + SFGAOF attrib; + + if (NOERROR != (result = SHGetDesktopFolder(&isf))) return result; + attrib = sfgaoIn; + result = isf->ParseDisplayName(NULL, pbc, (LPWSTR)lpszPath, NULL, ppidl, &attrib); + isf->Release(); + + if (S_OK != result) *ppidl = NULL; + else if (psfgaoOut) *psfgaoOut = attrib; + return result; +} + +void FolderBrowseEx::SetExpanded(LPCITEMIDLIST pidlExpand) +{ + pathExpanded.empty = FALSE; + pathExpanded.type = PATHTYPE_PIDL; + pathExpanded.value = (void*)pidlExpand; + if (hwnd) SendMessage(BFFM_SETEXPANDED, pathExpanded.type, (LPARAM)pathExpanded.value); +} + +void FolderBrowseEx::SetExpanded(LPCWSTR lpszExpand) +{ + pathExpanded.empty = FALSE; + pathExpanded.type = PATHTYPE_STRING; + pathExpanded.value = (void*)lpszExpand; + if (hwnd) SendMessage(BFFM_SETEXPANDED, pathExpanded.type, (LPARAM)pathExpanded.value); +} + +void FolderBrowseEx::SetSelection(LPCITEMIDLIST pidlSelect) +{ + pathSelection.empty = FALSE; + pathSelection.type = PATHTYPE_PIDL; + pathSelection.value = (void*)pidlSelect; + if (hwnd) SendMessage(BFFM_SETSELECTIONW, pathSelection.type, (LPARAM)pathSelection.value); +} + +void FolderBrowseEx::SetSelection(LPCWSTR lpszSelect) +{ + pathSelection.empty = FALSE; + pathSelection.type = PATHTYPE_STRING; + pathSelection.value = (void*)lpszSelect; + if (hwnd) SendMessage(BFFM_SETSELECTIONW, pathSelection.type, (LPARAM)pathSelection.value); +} + +void FolderBrowseEx::SetCaption(LPCWSTR lpszCaption) +{ + if (this->lpszCaption) free(this->lpszCaption); + this->lpszCaption = _wcsdup((lpszCaption) ? lpszCaption : L""); + if (hwnd) SetWindowText(lpszCaption); +} + +void FolderBrowseEx::SetTitle(LPCWSTR lpszTitle) +{ + if (this->lpszTitle) free(this->lpszTitle); + this->lpszTitle = _wcsdup((lpszTitle) ? lpszTitle : L""); +} + +LPITEMIDLIST FolderBrowseEx::Browse(HWND hwndOwner) +{ + BROWSEINFOW bi = {0}; + bi.hwndOwner = hwndOwner; + bi.pidlRoot = pidlRoot; + bi.pszDisplayName = pszDisplayName; + bi.lpszTitle = lpszTitle; + bi.ulFlags = ulFlags; + bi.lpfn = BrowseCallback_Helper; + bi.lParam = (LPARAM)this; + + pidl = SHBrowseForFolderW(&bi); + if (pidl) OnSelectionDone(pidl); + + image = (pidl) ? bi.iImage : -1; + + return pidl; +} + +INT FolderBrowseEx::BrowseCallback(UINT uMsg, LPARAM lParam) +{ + switch(uMsg) + { + case BFFM_INITIALIZED: OnInitialized(); break; + case BFFM_IUNKNOWN: OnIUnknown((IUnknown*)lParam); break; + case BFFM_SELCHANGED: OnSelectionChanged((LPCITEMIDLIST)lParam); break; + case BFFM_VALIDATEFAILEDA: return OnValidateFailed(AutoWide((LPCSTR)lParam)); + case BFFM_VALIDATEFAILEDW: return OnValidateFailed((LPCWSTR)lParam); + } + return 0; +} + +void FolderBrowseEx::OnInitialized(void) +{ + if (!pathSelection.empty) SendMessage(BFFM_SETSELECTIONW, pathSelection.type, (LPARAM)pathSelection.value); + if (!pathExpanded.empty) SendMessage(BFFM_SETEXPANDED, pathExpanded.type, (LPARAM)pathExpanded.value); + SetWindowText(lpszCaption); +} + +void FolderBrowseEx::OnSelectionChanged(LPCITEMIDLIST pidl) +{ +} + +INT_PTR FolderBrowseEx::DialogProc(UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + return CallWindowProc(uMsg, wParam, lParam); +} + +INT_PTR FolderBrowseEx::CallWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + return (IsWindowUnicode(hwnd)) ? ::CallWindowProcW((WNDPROC)oldProc, hwnd, uMsg, wParam, lParam) + : ::CallWindowProcA((WNDPROC)oldProc, hwnd, uMsg, wParam, lParam); +} + +void FolderBrowseEx::SetDialogResult(LRESULT result) +{ + SetWindowLongPtr(hwnd, DWLP_MSGRESULT, (LONG)(LONG_PTR)result); +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/FolderBrowseEx.h b/Src/Plugins/Library/ml_local/FolderBrowseEx.h new file mode 100644 index 00000000..746d186d --- /dev/null +++ b/Src/Plugins/Library/ml_local/FolderBrowseEx.h @@ -0,0 +1,97 @@ +#ifndef NULLSOFT_FOLDERBROWSE_EXTENDED_DIALOG_HEADER +#define NULLSOFT_FOLDERBROWSE_EXTENDED_DIALOG_HEADER + +#include <windows.h> +#include <shlobj.h> + +/// Standart controls +#define IDC_TV_FOLDERS 0x3741 +#define IDC_SB_GRIPPER 0x3747 +#define IDC_LBL_FOLDER 0x3748 +#define IDC_LBL_CAPTION 0x3742 +#define IDC_EDT_PATH 0x3744 + + +typedef struct _BFPATH +{ + int empty; + int type; + void *value; +}BFPATH; + +class FolderBrowseEx +{ +public: + FolderBrowseEx(LPCITEMIDLIST pidlRoot, UINT ulFlags, LPCWSTR lpszCaption, LPCWSTR lpszTitle); + FolderBrowseEx(UINT ulFlags, LPCWSTR lpszCaption, LPCWSTR lpszTitle); + FolderBrowseEx(UINT ulFlags, LPCWSTR lpszTitle); + FolderBrowseEx(void); + virtual ~FolderBrowseEx(void); + +public: + virtual LPITEMIDLIST Browse(HWND hwndOwner); + + LPITEMIDLIST GetPIDL(void) { return pidl; } + INT GetImage(void) { return image; } + LPCWSTR GetDislpayName(void) { return pszDisplayName; } + HRESULT ParseDisplayName(LPCWSTR lpszPath, IBindCtx *pbc, LPITEMIDLIST *ppidl, SFGAOF sfgaoIn, SFGAOF *psfgaoOut); + HWND GetDlgItem(int nIDDlgItem) { return ::GetDlgItem(hwnd, nIDDlgItem); } + + void SetRoot(LPCITEMIDLIST pidlRoot) { this->pidlRoot = pidlRoot; } + void SetFlags(UINT ulFlags) { this->ulFlags = ulFlags; } + void SetSelection(LPCITEMIDLIST pidlSelect); + void SetSelection(LPCWSTR lpszSelect); + void SetExpanded(LPCITEMIDLIST pidlExpand); + void SetExpanded(LPCWSTR lpszExpand); + void SetCaption(LPCWSTR lpszCaption); + void SetTitle(LPCWSTR lpszTitle); + + +protected: + HWND GetHandle(void) { return hwnd; } + INT_PTR CallWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam); + void SetDialogResult(LRESULT result); + LRESULT SendMessage(UINT uMsg, WPARAM wParam, LPARAM lParam) { return ::SendMessageW(hwnd, uMsg, wParam, lParam); } + void SetWindowText(LPCWSTR lpText) { ::SetWindowTextW(hwnd, lpText); } + + void EnableOK(BOOL enable) { SendMessage(BFFM_ENABLEOK, 0, (LPARAM)enable); } + void SetOKText(LPCWSTR lpText) { SendMessage(BFFM_SETOKTEXT, 0, (LPARAM)lpText); } + void SetStatusText(LPCWSTR lpText) { SendMessage(BFFM_SETSTATUSTEXTW, 0, (LPARAM)lpText); } + + virtual void OnInitialized(void); + virtual void OnIUnknown(IUnknown *lpiu) {} + virtual void OnSelectionChanged(LPCITEMIDLIST pidl); + virtual BOOL OnValidateFailed(LPCWSTR lpName) { return FALSE; } + virtual void OnSelectionDone(LPCITEMIDLIST pidl) { } + + virtual INT BrowseCallback(UINT uMsg, LPARAM lParam); + virtual INT_PTR DialogProc(UINT uMsg, WPARAM wParam, LPARAM lParam); + +protected: + LPCITEMIDLIST pidlRoot; + + BFPATH pathSelection; + BFPATH pathExpanded; + + LPWSTR lpszCaption; + LPWSTR lpszTitle; + UINT ulFlags; + INT image; + WCHAR pszDisplayName[MAX_PATH]; + BOOL expand; + LPITEMIDLIST pidl; + + +private: + HWND hwnd; + LONG_PTR oldProc; + + + + friend static int WINAPI BrowseCallback_Helper(HWND hwnd, UINT uMsg, LPARAM lParam, LPARAM lpData); + friend static LRESULT WINAPI WindowProc_Helper(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); + friend static void Initialize(FolderBrowseEx *lpfbx, LPCITEMIDLIST pidlRoot, UINT ulFlags, LPCWSTR lpszCaption, LPCWSTR lpszTitle); + +}; + +#endif //NULLSOFT_FOLDERBROWSE_EXTENDED_DIALOG_HEADER
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/LocalMediaCOM.cpp b/Src/Plugins/Library/ml_local/LocalMediaCOM.cpp new file mode 100644 index 00000000..3600b349 --- /dev/null +++ b/Src/Plugins/Library/ml_local/LocalMediaCOM.cpp @@ -0,0 +1,307 @@ +#include "main.h" +#include "LocalMediaCOM.h" + + +void sortResults(int column, int dir, itemRecordListW *obj); + +static void saveQueryToList(nde_scanner_t s, itemRecordListW *obj, int sortColumn, int sortDir) +{ + emptyRecordList(obj); + + EnterCriticalSection(&g_db_cs); + NDE_Scanner_First(s); + + int r; + do + { + nde_field_t f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_FILENAME); + if (f) + { + allocRecordList(obj, obj->Size + 1); + if (!obj->Alloc) break; + + obj->Items[obj->Size].filename = NDE_StringField_GetString(f); + ndestring_retain(obj->Items[obj->Size].filename); + ScannerRefToObjCacheNFNW(s, obj, true); + } + + r = NDE_Scanner_Next(s); + } + while (r && !NDE_Scanner_EOF(s)); + + if (((Table *)g_table)->HasErrors()) // TODO: don't use C++ NDE API + { + wchar_t *last_query = NULL; + if (m_media_scanner) + { + const wchar_t *lq = NDE_Scanner_GetLastQuery(m_media_scanner); + if (lq) last_query = _wcsdup(lq); + NDE_Table_DestroyScanner(g_table, m_media_scanner); + } + NDE_Table_Compact(g_table); + if (m_media_scanner) + { + m_media_scanner = NDE_Table_CreateScanner(g_table); + if (last_query != NULL) + { + NDE_Scanner_Query(m_media_scanner, last_query); + free(last_query); + } + } + } + LeaveCriticalSection(&g_db_cs); + + compactRecordList(obj); + + sortResults(sortColumn, sortDir, obj); +} + +void WriteEscaped(FILE *fp, const wchar_t *str) +{ + // TODO: for speed optimization, + // we should wait until we hit a special character + // and write out everything else so before it, + // like how ASX loader does it + while (str && *str) + { + switch(*str) + { + case L'&': + fputws(L"&", fp); + break; + case L'>': + fputws(L">", fp); + break; + case L'<': + fputws(L"<", fp); + break; + case L'\'': + fputws(L"'", fp); + break; + case L'\"': + fputws(L""", fp); + break; + default: + fputwc(*str, fp); + break; + } + // write out the whole character + wchar_t *next = CharNextW(str); + while (++str != next) + fputwc(*str, fp); + + } +} + +bool SaveListToXML(const itemRecordListW *const obj, const wchar_t *filename, int limit) +{ + int i=0; + FILE *fp = _wfopen(filename, L"wb"); + if (!fp) + return false; + wchar_t BOM = 0xFEFF; + fwrite(&BOM, sizeof(BOM), 1, fp); + fwprintf(fp, L"<?xml version=\"1.0\" encoding=\"UTF-16\"?>"); + fputws(L"<itemlist>\r\n", fp); + + while (i < obj->Size) + { + fputws(L"<item ", fp); + + if (obj->Items[i].filename) + { + fputws(L"filename=\"", fp); + WriteEscaped(fp, obj->Items[i].filename); + fputws(L"\" ", fp); + } + + if (obj->Items[i].title) + { + fputws(L"title=\"", fp); + WriteEscaped(fp, obj->Items[i].title); + fputws(L"\" ", fp); + } + + if (obj->Items[i].album) + { + fputws(L"album=\"", fp); + WriteEscaped(fp, obj->Items[i].album); + fputws(L"\" ", fp); + } + + if (obj->Items[i].artist) + { + fputws(L"artist=\"", fp); + WriteEscaped(fp, obj->Items[i].artist); + fputws(L"\" ", fp); + } + + if (obj->Items[i].comment) + { + fputws(L"comment=\"", fp); + WriteEscaped(fp, obj->Items[i].comment); + fputws(L"\" ", fp); + } + + if (obj->Items[i].genre) + { + fputws(L"genre=\"", fp); + WriteEscaped(fp, obj->Items[i].genre); + fputws(L"\" ", fp); + } + + if (obj->Items[i].year > 0) + fwprintf(fp, L"year=\"%d\" ",obj->Items[i].year); + + if (obj->Items[i].track > 0) + fwprintf(fp, L"track=\"%d\" ",obj->Items[i].track); + + if (obj->Items[i].length > 0) + fwprintf(fp, L"length=\"%d\" ",obj->Items[i].length); + + // TODO: extended info fields + fputws(L"/>", fp); + if (++i == limit) + break; + } + fputws(L"</itemlist>", fp); + fclose(fp); + + return true; +} + +enum +{ + DISP_LOCALMEDIA_XMLQUERY = 777, + +}; + +#define CHECK_ID(str, id) if (_wcsicmp(rgszNames[i], L##str) == 0) { rgdispid[i] = id; continue; } +HRESULT LocalMediaCOM::GetIDsOfNames(REFIID riid, OLECHAR FAR* FAR* rgszNames, unsigned int cNames, LCID lcid, DISPID FAR* rgdispid) +{ + bool unknowns = false; + for (unsigned int i = 0;i != cNames;i++) + { + CHECK_ID("XMLQuery", DISP_LOCALMEDIA_XMLQUERY) + rgdispid[i] = DISPID_UNKNOWN; + unknowns = true; + } + if (unknowns) + return DISP_E_UNKNOWNNAME; + else + return S_OK; +} + +HRESULT LocalMediaCOM::GetTypeInfo(unsigned int itinfo, LCID lcid, ITypeInfo FAR* FAR* pptinfo) +{ + return E_NOTIMPL; +} + +HRESULT LocalMediaCOM::GetTypeInfoCount(unsigned int FAR * pctinfo) +{ + return E_NOTIMPL; +} + +void Bookmark_WriteAsXML(const wchar_t *filename, int max); + +HRESULT LocalMediaCOM::Invoke(DISPID dispid, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS FAR *pdispparams, VARIANT FAR *pvarResult, EXCEPINFO FAR * pexecinfo, unsigned int FAR *puArgErr) +{ + switch (dispid) + { + case DISP_LOCALMEDIA_XMLQUERY: + if (pdispparams->cArgs == 4) + { + openDb(); + int max,dir,column; + + // Strict-ish type checking + if ( pdispparams->rgvarg[0].vt == VT_BSTR ) + max = _wtoi(pdispparams->rgvarg[0].bstrVal); + else + max = pdispparams->rgvarg[0].uiVal; + + if ( pdispparams->rgvarg[1].vt == VT_BSTR ) + dir = _wtoi(pdispparams->rgvarg[2].bstrVal); + else + dir = pdispparams->rgvarg[1].uiVal; + + if ( pdispparams->rgvarg[2].vt == VT_BSTR ) + column = _wtoi(pdispparams->rgvarg[2].bstrVal); + else + column = pdispparams->rgvarg[2].uiVal; + + // run query + EnterCriticalSection(&g_db_cs); + nde_scanner_t s=NDE_Table_CreateScanner(g_table); + NDE_Scanner_Query(s, pdispparams->rgvarg[3].bstrVal); + +// create itemRecordList (necessary because NDE doesn't sort) + itemRecordListW obj; + obj.Alloc = 0; + obj.Items = NULL; + obj.Size = 0; + saveQueryToList(s, &obj, column, dir); + NDE_Table_DestroyScanner(g_table, s); + LeaveCriticalSection(&g_db_cs); + + // write to a temporary XML file + wchar_t tempPath[MAX_PATH] = {0}; + GetTempPathW(MAX_PATH, tempPath); + wchar_t tempFile[MAX_PATH] = {0}; + GetTempFileNameW(tempPath, L"lmx", 0, tempFile); + SaveListToXML(&obj, tempFile, max); + freeRecordList(&obj); + + // open the resultant file to read into a buffer + // (we're basically using the filesystem as an automatically growing buffer) + HANDLE plFile = CreateFileW(tempFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0); + size_t flen = SetFilePointer(plFile, 0, NULL, FILE_END); + SetFilePointer(plFile, 0, NULL, FILE_BEGIN); + + SAFEARRAY *bufferArray=SafeArrayCreateVector(VT_UI1, 0, flen); + void *data; + SafeArrayAccessData(bufferArray, &data); + DWORD bytesRead = 0; + ReadFile(plFile, data, flen, &bytesRead, 0); + SafeArrayUnaccessData(bufferArray); + CloseHandle(plFile); + VariantInit(pvarResult); + V_VT(pvarResult) = VT_ARRAY|VT_UI1; + V_ARRAY(pvarResult) = bufferArray; + DeleteFileW(tempFile); + } + return S_OK; + } + return DISP_E_MEMBERNOTFOUND; +} + + +STDMETHODIMP LocalMediaCOM::QueryInterface(REFIID riid, PVOID *ppvObject) +{ + if (!ppvObject) + return E_POINTER; + + else if (IsEqualIID(riid, IID_IDispatch)) + *ppvObject = (IDispatch *)this; + else if (IsEqualIID(riid, IID_IUnknown)) + *ppvObject = this; + else + { + *ppvObject = NULL; + return E_NOINTERFACE; + } + + AddRef(); + return S_OK; +} + +ULONG LocalMediaCOM::AddRef(void) +{ + return 0; +} + + +ULONG LocalMediaCOM::Release(void) +{ + return 0; +} diff --git a/Src/Plugins/Library/ml_local/LocalMediaCOM.h b/Src/Plugins/Library/ml_local/LocalMediaCOM.h new file mode 100644 index 00000000..02138a06 --- /dev/null +++ b/Src/Plugins/Library/ml_local/LocalMediaCOM.h @@ -0,0 +1,21 @@ +#ifndef NULLSOFT_BOOKMARKSCOM_H +#define NULLSOFT_BOOKMARKSCOM_H + +#include <ocidl.h> + +class LocalMediaCOM : public IDispatch +{ +public: + STDMETHOD(QueryInterface)(REFIID riid, PVOID *ppvObject); + STDMETHOD_(ULONG, AddRef)(void); + STDMETHOD_(ULONG, Release)(void); + + // *** IDispatch Methods *** + STDMETHOD (GetIDsOfNames)(REFIID riid, OLECHAR FAR* FAR* rgszNames, unsigned int cNames, LCID lcid, DISPID FAR* rgdispid); + STDMETHOD (GetTypeInfo)(unsigned int itinfo, LCID lcid, ITypeInfo FAR* FAR* pptinfo); + STDMETHOD (GetTypeInfoCount)(unsigned int FAR * pctinfo); + STDMETHOD (Invoke)(DISPID dispid, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS FAR *pdispparams, VARIANT FAR *pvarResult, EXCEPINFO FAR * pexecinfo, unsigned int FAR *puArgErr); +}; + + +#endif
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/MD5.cpp b/Src/Plugins/Library/ml_local/MD5.cpp new file mode 100644 index 00000000..4ce5396d --- /dev/null +++ b/Src/Plugins/Library/ml_local/MD5.cpp @@ -0,0 +1,294 @@ +#include "MD5.h" + +/* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm + */ + +/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All + rights reserved. + + License to copy and use this software is granted provided that it + is identified as the "RSA Data Security, Inc. MD5 Message-Digest + Algorithm" in all material mentioning or referencing this software + or this function. + + License is also granted to make and use derivative works provided + that such works are identified as "derived from the RSA Data + Security, Inc. MD5 Message-Digest Algorithm" in all material + mentioning or referencing the derived work. + + RSA Data Security, Inc. makes no representations concerning either + the merchantability of this software or the suitability of this + software for any particular purpose. It is provided "as is" + without express or implied warranty of any kind. + + These notices must be retained in any copies of any part of this + documentation and/or software. + */ + + + +/* Constants for MD5Transform routine. + */ +#define S11 7 +#define S12 12 +#define S13 17 +#define S14 22 +#define S21 5 +#define S22 9 +#define S23 14 +#define S24 20 +#define S31 4 +#define S32 11 +#define S33 16 +#define S34 23 +#define S41 6 +#define S42 10 +#define S43 15 +#define S44 21 + +static void MD5Transform(uint32_t [4], unsigned char [64]); +static void Encode(unsigned char *, uint32_t *, unsigned int); +static void Decode(uint32_t *, unsigned char *, unsigned int); + +static unsigned char PADDING[64] = +{ + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +/* F, G, H and I are basic MD5 functions. + */ +#define F(x, y, z) (((x) & (y)) | ((~x) & (z))) +#define G(x, y, z) (((x) & (z)) | ((y) & (~z))) +#define H(x, y, z) ((x) ^ (y) ^ (z)) +#define I(x, y, z) ((y) ^ ((x) | (~z))) + +/* ROTATE_LEFT rotates x left n bits. + */ +#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) + +/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. + Rotation is separate from addition to prevent recomputation. + */ +#define FF(a, b, c, d, x, s, ac) { \ + (a) += F ((b), (c), (d)) + (x) + (uint32_t)(ac); \ + (a) = ROTATE_LEFT ((a), (s)); \ + (a) += (b); \ + } +#define GG(a, b, c, d, x, s, ac) { \ + (a) += G ((b), (c), (d)) + (x) + (uint32_t)(ac); \ + (a) = ROTATE_LEFT ((a), (s)); \ + (a) += (b); \ + } +#define HH(a, b, c, d, x, s, ac) { \ + (a) += H ((b), (c), (d)) + (x) + (uint32_t)(ac); \ + (a) = ROTATE_LEFT ((a), (s)); \ + (a) += (b); \ + } +#define II(a, b, c, d, x, s, ac) { \ + (a) += I ((b), (c), (d)) + (x) + (uint32_t)(ac); \ + (a) = ROTATE_LEFT ((a), (s)); \ + (a) += (b); \ + } + +/* MD5 initialization. Begins an MD5 operation, writing a new context. + */ +void MD5Init(MD5_CTX *context) +{ + context->count[0] = context->count[1] = 0; + + /* Load magic initialization constants. + */ + context->state[0] = 0x67452301; + context->state[1] = 0xefcdab89; + context->state[2] = 0x98badcfe; + context->state[3] = 0x10325476; +} + +/* MD5 block update operation. Continues an MD5 message-digest + operation, processing another message block, and updating the + context. + */ +void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int inputLen) +{ + unsigned int i, index, partLen; + + /* Compute number of bytes mod 64 */ + index = (unsigned int)((context->count[0] >> 3) & 0x3F); + + /* Update number of bits */ + if ((context->count[0] += ((uint32_t)inputLen << 3)) + < ((uint32_t)inputLen << 3)) + context->count[1]++; + context->count[1] += ((uint32_t)inputLen >> 29); + + partLen = 64 - index; + + /* Transform as many times as possible. + */ + if (inputLen >= partLen) + { + memcpy + ((void *)&context->buffer[index], (void *)input, partLen); + MD5Transform(context->state, context->buffer); + + for (i = partLen; i + 63 < inputLen; i += 64) + MD5Transform(context->state, &input[i]); + + index = 0; + } + else + i = 0; + + /* Buffer remaining input */ + memcpy + ((void *)&context->buffer[index], (void *)&input[i], + inputLen-i); +} + +/* MD5 finalization. Ends an MD5 message-digest operation, writing the + the message digest and zeroizing the context. + */ +void MD5Final(uint8_t digest[16], MD5_CTX *context) +{ + uint8_t bits[8] = {0}; + unsigned int index, padLen; + + /* Save number of bits */ + Encode(bits, context->count, 8); + + /* Pad out to 56 mod 64. + */ + index = (unsigned int)((context->count[0] >> 3) & 0x3f); + padLen = (index < 56) ? (56 - index) : (120 - index); + MD5Update(context, PADDING, padLen); + + /* Append length (before padding) */ + MD5Update(context, bits, 8); + + /* Store state in digest */ + Encode(digest, context->state, 16); + + /* Zeroize sensitive information. + */ + memset((void *)context, 0, sizeof(*context)); +} + +/* MD5 basic transformation. Transforms state based on block. + */ +static void MD5Transform(uint32_t state[4], uint8_t block[64]) +{ + uint32_t a = state[0], b = state[1], c = state[2], d = state[3], x[16] = {0}; + + Decode(x, block, 64); + + /* Round 1 */ + FF(a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */ + FF(d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */ + FF(c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */ + FF(b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */ + FF(a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */ + FF(d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */ + FF(c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */ + FF(b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */ + FF(a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */ + FF(d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */ + FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */ + FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */ + FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */ + FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */ + FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */ + FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */ + + /* Round 2 */ + GG(a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */ + GG(d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */ + GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */ + GG(b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */ + GG(a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */ + GG(d, a, b, c, x[10], S22, 0x2441453); /* 22 */ + GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */ + GG(b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */ + GG(a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */ + GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */ + GG(c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */ + GG(b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */ + GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */ + GG(d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */ + GG(c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */ + GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */ + + /* Round 3 */ + HH(a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */ + HH(d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */ + HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */ + HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */ + HH(a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */ + HH(d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */ + HH(c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */ + HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */ + HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */ + HH(d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */ + HH(c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */ + HH(b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */ + HH(a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */ + HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */ + HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */ + HH(b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */ + + /* Round 4 */ + II(a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */ + II(d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */ + II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */ + II(b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */ + II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */ + II(d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */ + II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */ + II(b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */ + II(a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */ + II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */ + II(c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */ + II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */ + II(a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */ + II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */ + II(c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */ + II(b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */ + + state[0] += a; + state[1] += b; + state[2] += c; + state[3] += d; + + /* Zeroize sensitive information. + */ + memset((void *)x, 0, sizeof(x)); +} + +/* Encodes input (uint32_t) into output (unsigned char). Assumes len is + a multiple of 4. + */ +static void Encode(unsigned char *output, uint32_t *input, unsigned int len) +{ + unsigned int i, j; + + for (i = 0, j = 0; j < len; i++, j += 4) + { + output[j] = (unsigned char)(input[i] & 0xff); + output[j+1] = (unsigned char)((input[i] >> 8) & 0xff); + output[j+2] = (unsigned char)((input[i] >> 16) & 0xff); + output[j+3] = (unsigned char)((input[i] >> 24) & 0xff); + } +} + +/* Decodes input (unsigned char) into output (uint32_t). Assumes len is + a multiple of 4. + */ +static void Decode(uint32_t *output, unsigned char *input, unsigned int len) +{ + unsigned int i, j; + + for (i = 0, j = 0; j < len; i++, j += 4) + output[i] = ((uint32_t)input[j]) | (((uint32_t)input[j+1]) << 8) | + (((uint32_t)input[j+2]) << 16) | (((uint32_t)input[j+3]) << 24); +} diff --git a/Src/Plugins/Library/ml_local/MD5.h b/Src/Plugins/Library/ml_local/MD5.h new file mode 100644 index 00000000..74f8f675 --- /dev/null +++ b/Src/Plugins/Library/ml_local/MD5.h @@ -0,0 +1,18 @@ +#ifndef NULLSOFT_ML_LOCAL_MD5_H +#define NULLSOFT_ML_LOCAL_MD5_H + +#include <bfc/platform/types.h> +/* MD5 context. */ +typedef struct +{ + uint32_t state[4]; /* state (ABCD) */ + uint32_t count[2]; /* number of bits, modulo 2^64 (lsb first) */ + uint8_t buffer[64]; /* input buffer */ +} MD5_CTX; + +void MD5Init(MD5_CTX *); +void MD5Update(MD5_CTX *, uint8_t *, unsigned int); +void MD5Final(uint8_t [16], MD5_CTX *); + + +#endif
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/MLDBCallback.h b/Src/Plugins/Library/ml_local/MLDBCallback.h new file mode 100644 index 00000000..4fe48286 --- /dev/null +++ b/Src/Plugins/Library/ml_local/MLDBCallback.h @@ -0,0 +1,76 @@ +#pragma once +#include <api/syscb/callbacks/svccb.h> +#include <api/syscb/api_syscb.h> +#include "../ml_local/api_mldb.h" + +class MLDBCallback : public SysCallback +{ +private: + FOURCC GetEventType() + { + return api_mldb::SYSCALLBACK; + } + + int notify(int msg, intptr_t param1, intptr_t param2) + { + const wchar_t *filename = (const wchar_t *)param1; + + switch (msg) + { + case api_mldb::MLDB_FILE_ADDED: + OnFileAdded(filename); + return 1; + + case api_mldb::MLDB_FILE_REMOVED_PRE: + OnFileRemove_Pre(filename); + return 1; + + case api_mldb::MLDB_FILE_REMOVED_POST: + OnFileRemove_Post(filename); + return 1; + + case api_mldb::MLDB_FILE_UPDATED: + case api_mldb::MLDB_FILE_UPDATED_EXTERNAL: + OnFileUpdated(filename, (msg == api_mldb::MLDB_FILE_UPDATED)); + return 1; + + case api_mldb::MLDB_FILE_PLAYED: + OnFilePlayed(filename, + ((api_mldb::played_info *)param2)->played, + ((api_mldb::played_info *)param2)->count); + return 1; + + case api_mldb::MLDB_CLEARED: + OnCleared((const wchar_t **)param1, param2); + return 1; + + case api_mldb::MLDB_FILE_GET_CLOUD_STATUS: + { + OnGetCloudStatus((const wchar_t *)param1, (HMENU *)param2); + } + return 1; + + case api_mldb::MLDB_FILE_PROCESS_CLOUD_STATUS: + OnProcessCloudStatus(param1, (int *)param2); + return 1; + + default: + return 0; + } + } + virtual void OnFileAdded(const wchar_t *filename) {} + virtual void OnFileRemove_Pre(const wchar_t *filename) {} + virtual void OnFileRemove_Post(const wchar_t *filename) {} + virtual void OnFileUpdated(const wchar_t *filename, bool from_library) {} + virtual void OnFilePlayed(const wchar_t *filename, time_t played, int count) {} + virtual void OnCleared(const wchar_t **filenames, int count) {} + virtual void OnGetCloudStatus(const wchar_t *filename, HMENU *menu) {} + virtual void OnProcessCloudStatus(int menu_item, int *result) {} + +#define CBCLASS MLDBCallback + START_DISPATCH_INLINE; + CB(SYSCALLBACK_GETEVENTTYPE, GetEventType); + CB(SYSCALLBACK_NOTIFY, notify); + END_DISPATCH; +#undef CBCLASS +};
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/MLString.cpp b/Src/Plugins/Library/ml_local/MLString.cpp new file mode 100644 index 00000000..32b8e229 --- /dev/null +++ b/Src/Plugins/Library/ml_local/MLString.cpp @@ -0,0 +1,116 @@ +#include "main.h" +#include ".\MLString.h" +#include <strsafe.h> + +#define ALLOCATION_STEP 16 + +void* MLString::heap = GetProcessHeap(); + +MLString::MLString(void) : buffer(NULL), allocated(0), cchLen(0) +{ +} + +MLString::MLString(const wchar_t* string) : buffer(NULL), allocated(0), cchLen(0) +{ + if (string) Append(string, lstrlenW(string)); +} +MLString::MLString(unsigned int cchBuffer) : buffer(NULL), allocated(0), cchLen(0) +{ + Allocate(cchBuffer); +} + +MLString::MLString(const MLString ©) : buffer(NULL), allocated(0) +{ + cchLen = copy.cchLen; + Allocate(cchLen + 1); + CopyMemory(buffer, copy.buffer, cchLen*sizeof(wchar_t)); +} + +MLString::~MLString(void) +{ + if (buffer) + { + HeapFree(heap, NULL, buffer); + allocated = 0; + cchLen = 0; + buffer = NULL; + } +} + +HRESULT MLString::Append(const wchar_t* string, unsigned int cchLength) +{ + if (allocated <= cchLen + cchLength) + { + do { allocated += ALLOCATION_STEP; } while(allocated < cchLen + cchLength + 1); + buffer = (wchar_t*) ((!buffer) ? HeapAlloc(heap, NULL, allocated*sizeof(wchar_t)) : + HeapReAlloc(heap, NULL, buffer, allocated*sizeof(wchar_t))); + } + if (!buffer) return ERROR_OUTOFMEMORY; + CopyMemory(buffer + cchLen, string, cchLength*sizeof(wchar_t)); + cchLen += cchLength; + buffer[cchLen] = 0x0000; + return S_OK; +} + +HRESULT MLString::Set(const wchar_t* string, unsigned int cchLength) +{ + cchLen = 0; + return Append(string, cchLength); +} + +HRESULT MLString::Allocate(unsigned int cchNewSize) +{ + if (cchNewSize <= cchLen) return ERROR_BAD_LENGTH; + if (allocated >= cchNewSize) return S_OK; + allocated = cchNewSize; + buffer = (wchar_t*) ((!buffer) ? HeapAlloc(heap, NULL, allocated*sizeof(wchar_t)) : + HeapReAlloc(heap, NULL, buffer, allocated*sizeof(wchar_t))); + return (buffer) ? S_OK : ERROR_OUTOFMEMORY; +} + +void MLString::Compact(void) +{ + if (!buffer) return; + if (0 == cchLen) + { + HeapFree(heap, NULL, buffer); + allocated = 0; + cchLen = 0; + buffer = NULL; + } + else + { + allocated = cchLen + 1; + buffer = (wchar_t*)HeapReAlloc(heap, NULL, buffer, allocated*sizeof(wchar_t)); + } +} + +HRESULT MLString::Format(const wchar_t *format, ...) +{ + va_list argList; + va_start(argList, format); + HRESULT retCode; + size_t remaining = 0; + retCode = (allocated) ? StringCchVPrintfExW(buffer, allocated, NULL, &remaining, STRSAFE_NULL_ON_FAILURE, format, argList) : STRSAFE_E_INSUFFICIENT_BUFFER; + while (STRSAFE_E_INSUFFICIENT_BUFFER == retCode) + { + int attempt = 1; + allocated += ALLOCATION_STEP*attempt; + attempt++; + buffer = (wchar_t*) ((!buffer) ? HeapAlloc(heap, NULL, allocated*sizeof(wchar_t)) : + HeapReAlloc(heap, NULL, buffer, allocated*sizeof(wchar_t))); + retCode = StringCchVPrintfExW(buffer, allocated, NULL, &remaining, STRSAFE_NULL_ON_FAILURE, format, argList); + } + va_end(argList); + cchLen = (S_OK == retCode) ? allocated - (unsigned int)remaining : 0; + return retCode; +} + +HRESULT MLString::CopyTo(MLString *destination) +{ + HRESULT retCode = destination->Allocate(allocated); + if (S_OK != retCode) return retCode; + destination->cchLen = cchLen; + CopyMemory(destination->buffer, buffer, cchLen*sizeof(wchar_t)); + return S_OK; +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/MLString.h b/Src/Plugins/Library/ml_local/MLString.h new file mode 100644 index 00000000..ddf98e58 --- /dev/null +++ b/Src/Plugins/Library/ml_local/MLString.h @@ -0,0 +1,54 @@ +#ifndef NULLOSFT_MLSTRING_HEADER +#define NULLOSFT_MLSTRING_HEADER + +#include <windows.h> + +class MLString +{ +public: + MLString(void); + ~MLString(void); + MLString(const wchar_t* string); + MLString(unsigned int cchBuffer); +protected: + MLString(const MLString ©); + + +public: + HRESULT Set(const wchar_t* string, unsigned int cchLength); + HRESULT Append(const wchar_t* string, unsigned int cchLength); + const wchar_t* Get(void) { return (cchLen) ? buffer : NULL; } + void Clear(void) { cchLen = 0; } + unsigned int GetLength(void) { return cchLen; } + HRESULT Format(const wchar_t *format, ...); + HRESULT CopyTo(MLString *destination); + + HRESULT Set(const wchar_t* string) { return Set(string, lstrlenW(string)); } + HRESULT Append(const wchar_t* string) { return Append(string, lstrlenW(string)); } + + // buffer + HRESULT Allocate(unsigned int cchNewSize); + void Compact(void); + wchar_t* GetBuffer(void) { return buffer; } + unsigned int GetBufferLength(void) { return allocated; } + void UpdateBuffer(void) { cchLen = lstrlenW(buffer); } + + operator const wchar_t *() { return buffer; } + operator wchar_t *() { return buffer; } + wchar_t& operator [](unsigned int index) { return buffer[index]; } + MLString& operator = (const wchar_t *source) { (source) ? Set(source, lstrlenW(source)) : Clear(); return *this;} + MLString& operator + (const wchar_t *source) { if (source) Append(source, lstrlenW(source)); return *this;} + MLString& operator += (const wchar_t *source) { if (source) Append(source, lstrlenW(source)); return *this;} + MLString& operator = (MLString *source) { (source) ? source->CopyTo(this) : Clear(); return *this;} + MLString& operator + (MLString *source) { if (source) Append(source->GetBuffer(), source->GetLength()); return *this;} + MLString& operator += (MLString *source) { if (source) Append(source->GetBuffer(), source->GetLength()); return *this;} + +protected: + wchar_t *buffer; + unsigned int cchLen; + unsigned int allocated; + + static void *heap; +}; + +#endif // NULLOSFT_STRING_HEADER
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/Main.cpp b/Src/Plugins/Library/ml_local/Main.cpp new file mode 100644 index 00000000..a8aefced --- /dev/null +++ b/Src/Plugins/Library/ml_local/Main.cpp @@ -0,0 +1,586 @@ +#define PLUGIN_VERSION L"3.36" +#include "main.h" +#include "resource.h" +#include "api__ml_local.h" +#include "..\..\General\gen_ml/config.h" +#include <commctrl.h> +#include ".\ml_local.h" +#include "..\..\General\gen_ml/ml_ipc_0313.h" +#include "../replicant/nu/AutoChar.h" +#include <api/service/waServiceFactory.h> +#include "../playlist/api_playlistmanager.h" +#include "mldbApiFactory.h" +#include "../nu/ServiceWatcher.h" +#include "LocalMediaCOM.h" +#include <tataki/export.h> +#include <strsafe.h> +#if 0 +// disabled since not building cloud dlls +#include "../ml_cloud/CloudCallback.h" +#endif + +static ServiceWatcher serviceWatcher; +static LocalMediaCOM localMediaCOM; +MLDBAPIFactory mldbApiFactory; +mlAddTreeItemStruct newTree; + +#if 0 +// disabled since not building cloud dlls +static class CloudCallbacks : public CloudCallback +{ + void OnCloudUploadStart(const wchar_t *filename) { + SendMessage(m_curview_hwnd, WM_APP + 5, 0, (LPARAM)filename); + } + + void OnCloudUploadDone(const wchar_t *filename, int code) { + SendMessage(m_curview_hwnd, WM_APP + 5, MAKEWPARAM(code, 1), (LPARAM)filename); + } +} cloudCallback; +#endif + +LRESULT ML_IPC_MENUFUCKER_BUILD = -1, ML_IPC_MENUFUCKER_RESULT = -1; +int IPC_CLOUD_ENABLED = -1; + +int CreateView(int treeItem, HWND parent); + +static int Init(); +static void Quit(); +static INT_PTR MessageProc(int message_type, INT_PTR param1, INT_PTR param2, INT_PTR param3); + +void SaveAll(); + +prefsDlgRecW preferences; + +static wchar_t preferencesName[64] = {0}; + +int winampVersion = 0; +int substantives = 0; +int play_enq_rnd_alt = 0; + +// Delay load library control << begin >> +#include <delayimp.h> +#pragma comment(lib, "delayimp") + +bool nde_error = false; + +FARPROC WINAPI FailHook(unsigned dliNotify, DelayLoadInfo *dli) +{ + nde_error = true; + return 0; +} + +/* +extern "C" +{ + PfnDliHook __pfnDliFailureHook2 = FailHook; +} +// Delay load library control << end >> +*/ + +#define CBCLASS PLCallBackW +START_DISPATCH; +VCB(IFC_PLAYLISTLOADERCALLBACK_ONFILE, OnFile) +END_DISPATCH; +#undef CBCLASS + +template <class api_T> +void ServiceBuild(api_T *&api_t, GUID factoryGUID_t) +{ + if (plugin.service) + { + waServiceFactory *factory = plugin.service->service_getServiceByGuid(factoryGUID_t); + if (factory) + api_t = reinterpret_cast<api_T *>( factory->getInterface() ); + } +} + +template <class api_T> +void ServiceRelease(api_T *api_t, GUID factoryGUID_t) +{ + if (plugin.service && api_t) + { + waServiceFactory *factory = plugin.service->service_getServiceByGuid(factoryGUID_t); + if (factory) + factory->releaseInterface(api_t); + } + api_t = NULL; +} + +extern WORD waMenuID; +DEFINE_EXTERNAL_SERVICE(api_application, WASABI_API_APP); +DEFINE_EXTERNAL_SERVICE(api_explorerfindfile, WASABI_API_EXPLORERFINDFILE); +DEFINE_EXTERNAL_SERVICE(api_language, WASABI_API_LNG); +DEFINE_EXTERNAL_SERVICE(api_syscb, WASABI_API_SYSCB); +DEFINE_EXTERNAL_SERVICE(api_memmgr, WASABI_API_MEMMGR); +DEFINE_EXTERNAL_SERVICE(api_albumart, AGAVE_API_ALBUMART); +DEFINE_EXTERNAL_SERVICE(api_metadata, AGAVE_API_METADATA); +DEFINE_EXTERNAL_SERVICE(api_playlistmanager, AGAVE_API_PLAYLISTMANAGER); +DEFINE_EXTERNAL_SERVICE(api_itunes_importer, AGAVE_API_ITUNES_IMPORTER); +DEFINE_EXTERNAL_SERVICE(api_playlist_generator, AGAVE_API_PLAYLIST_GENERATOR); +DEFINE_EXTERNAL_SERVICE(api_threadpool, WASABI_API_THREADPOOL); +HINSTANCE WASABI_API_LNG_HINST = 0, WASABI_API_ORIG_HINST = 0; + +int sse_flag; +int Init() +{ +#ifdef _M_IX86 + int flags_edx; + _asm + { + mov eax, 1 + cpuid + mov flags_edx, edx + } + + sse_flag = flags_edx & 0x02000000; +#else + sse_flag=1; // always supported on amd64 +#endif + InitializeCriticalSection(&g_db_cs); + + waMenuID = (WORD)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_REGISTER_LOWORD_COMMAND); + + Tataki::Init(plugin.service); + + plugin.service->service_register(&mldbApiFactory); + + ServiceBuild(WASABI_API_APP, applicationApiServiceGuid); + ServiceBuild(WASABI_API_LNG, languageApiGUID); + ServiceBuild(WASABI_API_EXPLORERFINDFILE, ExplorerFindFileApiGUID); + ServiceBuild(AGAVE_API_ALBUMART, albumArtGUID); + ServiceBuild(AGAVE_API_METADATA, api_metadataGUID); + ServiceBuild(WASABI_API_MEMMGR, memMgrApiServiceGuid); + ServiceBuild(WASABI_API_SYSCB, syscbApiServiceGuid); + ServiceBuild(AGAVE_API_PLAYLISTMANAGER, api_playlistmanagerGUID); + ServiceBuild(WASABI_API_THREADPOOL, ThreadPoolGUID); + //ServiceBuild(AGAVE_API_PLAYLIST_GENERATOR, api_playlist_generator::getServiceGuid()); + + serviceWatcher.WatchWith(plugin.service); + serviceWatcher.WatchFor(&AGAVE_API_ITUNES_IMPORTER, api_itunes_importer::getServiceGuid()); + serviceWatcher.WatchFor(&AGAVE_API_PLAYLIST_GENERATOR, api_playlist_generator::getServiceGuid()); + WASABI_API_SYSCB->syscb_registerCallback(&serviceWatcher); + #if 0 + // disabled since not building cloud dlls + WASABI_API_SYSCB->syscb_registerCallback(&cloudCallback); + #endif + + // need to have this initialised before we try to do anything with localisation features + WASABI_API_START_LANG(plugin.hDllInstance,MlLocalLangGUID); + + wchar_t buf[2] = {0}; + if(LoadString(WASABI_API_LNG_HINST,IDS_SUBSTANTIVES,buf,2)){ + substantives = 1; + } + + // this is used to load alternative play/enqueue random strings where + // the default implementation will cause pluralisation issue eg de-de + buf[0] = 0; + if(LoadString(WASABI_API_LNG_HINST,IDS_PLAY_ENQ_RND_ALTERNATIVE,buf,2)){ + play_enq_rnd_alt = 1; + } + + static wchar_t szDescription[256]; + StringCchPrintfW(szDescription, ARRAYSIZE(szDescription), + WASABI_API_LNGSTRINGW(IDS_NULLSOFT_LOCAL_MEDIA), PLUGIN_VERSION); + plugin.description = (char*)szDescription; + + ML_IPC_MENUFUCKER_BUILD = (int)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&"menufucker_build", IPC_REGISTER_WINAMP_IPCMESSAGE); + ML_IPC_MENUFUCKER_RESULT = (int)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&"menufucker_result", IPC_REGISTER_WINAMP_IPCMESSAGE); + IPC_CLOUD_ENABLED = SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&"WinampCloudEnabled", IPC_REGISTER_WINAMP_IPCMESSAGE); + + mediaLibrary.library = plugin.hwndLibraryParent; + mediaLibrary.winamp = plugin.hwndWinampParent; + mediaLibrary.instance = plugin.hDllInstance; + winampVersion = mediaLibrary.GetWinampVersion(); + + mediaLibrary.AddDispatch(L"LocalMedia", &localMediaCOM); + + // this may look unused, but we want to get this here since mediaLibrary will cache the inidir + // and then we don't run into weird multithreaded SendMessage issues + mediaLibrary.GetIniDirectory(); + mediaLibrary.GetIniDirectoryW(); + + preferences.hInst = WASABI_API_LNG_HINST; + preferences.dlgID = IDD_PREFSFR; + preferences.proc = (void *)PrefsProc; + preferences.name = WASABI_API_LNGSTRINGW_BUF(IDS_LOCAL_MEDIA,preferencesName,64); + preferences.where = 6; // 0; + mediaLibrary.AddPreferences(preferences); + + mediaLibrary.AddTreeImage(IDB_TREEITEM_AUDIO, TREE_IMAGE_LOCAL_AUDIO, (BMPFILTERPROC)FILTER_DEFAULT1); + mediaLibrary.AddTreeImage(IDB_TREEITEM_MOSTPLAYED, TREE_IMAGE_LOCAL_MOSTPLAYED, (BMPFILTERPROC)FILTER_DEFAULT1); + mediaLibrary.AddTreeImage(IDB_TREEITEM_NEVERPLAYED, TREE_IMAGE_LOCAL_NEVERPLAYED, (BMPFILTERPROC)FILTER_DEFAULT1); + mediaLibrary.AddTreeImage(IDB_TREEITEM_RECENTLYPLAYED, TREE_IMAGE_LOCAL_RECENTLYPLAYED, (BMPFILTERPROC)FILTER_DEFAULT1); + mediaLibrary.AddTreeImage(IDB_TREEITEM_RECENTLYADDED, TREE_IMAGE_LOCAL_RECENTLYADDED, (BMPFILTERPROC)FILTER_DEFAULT1); + mediaLibrary.AddTreeImage(IDB_TREEITEM_TOPRATED, TREE_IMAGE_LOCAL_TOPRATED, (BMPFILTERPROC)FILTER_DEFAULT1); + mediaLibrary.AddTreeImage(IDB_TREEITEM_VIDEO, TREE_IMAGE_LOCAL_VIDEO, (BMPFILTERPROC)FILTER_DEFAULT1); + mediaLibrary.AddTreeImage(IDB_TREEITEM_PODCASTS, TREE_IMAGE_LOCAL_PODCASTS, (BMPFILTERPROC)FILTER_DEFAULT1); + mediaLibrary.AddTreeImage(IDB_TREEITEM_RECENTLYMODIFIED, TREE_IMAGE_LOCAL_RECENTLYMODIFIED, (BMPFILTERPROC)FILTER_DEFAULT1); + + int ret = init(); + if (ret) return ret; + + NAVINSERTSTRUCT nis = {0}; + nis.item.cbSize = sizeof(NAVITEM); + nis.item.pszText = WASABI_API_LNGSTRINGW(IDS_LOCAL_MEDIA); + nis.item.pszInvariant = L"Local Media"; + nis.item.style = NIS_HASCHILDREN; + nis.item.id = 1000; // benski> use the old ID for backwards compatability + nis.item.mask = NIMF_TEXT | NIMF_TEXTINVARIANT | NIMF_STYLE | NIMF_ITEMID; + + // map to item id (will probably have to change but is a quick port to support invariant item naming) + NAVITEM nvItem = {sizeof(NAVITEM),0,NIMF_ITEMID,}; + nvItem.hItem = MLNavCtrl_InsertItem(plugin.hwndLibraryParent, &nis); + MLNavItem_GetInfo(plugin.hwndLibraryParent, &nvItem); + m_query_tree = nvItem.id; + + loadQueryTree(); + + m_query_mode = 0; + m_query_metafile = L"default.vmd"; + + return ret; +} + +void Quit() +{ + serviceWatcher.StopWatching(); + serviceWatcher.Clear(); + + // deregister this first, otherwise people might try to use it after we shut down the database! + plugin.service->service_deregister(&mldbApiFactory); + + UnhookPlaylistEditor(); + + Scan_Kill(); + + closeDb(); + + delete(g_view_metaconf); + g_view_metaconf = 0; + + delete g_config; + g_config = NULL; + + KillArtThread(); + + for (QueryList::iterator i = m_query_list.begin();i != m_query_list.end();i++) + { + queryItem *item = i->second; + if (item) + { + free(item->metafn); + free(item->name); + free(item->query); + } + free(item); + } + m_query_list.clear(); + DeleteCriticalSection(&g_db_cs); + + ServiceRelease(WASABI_API_APP, applicationApiServiceGuid); + ServiceRelease(WASABI_API_LNG, languageApiGUID); + ServiceRelease(AGAVE_API_ALBUMART, albumArtGUID); + ServiceRelease(WASABI_API_MEMMGR, memMgrApiServiceGuid); + ServiceRelease(AGAVE_API_METADATA, api_metadataGUID); + ServiceRelease(WASABI_API_SYSCB, syscbApiServiceGuid); + ServiceRelease(AGAVE_API_PLAYLISTMANAGER, api_playlistmanagerGUID); + ServiceRelease(AGAVE_API_ITUNES_IMPORTER, api_itunes_importer::getServiceGuid()); + ServiceRelease(WASABI_API_THREADPOOL, ThreadPoolGUID); + ServiceRelease(AGAVE_API_PLAYLIST_GENERATOR, api_playlist_generator::getServiceGuid()); + + Tataki::Quit(); +} + +INT_PTR MessageProc(int message_type, INT_PTR param1, INT_PTR param2, INT_PTR param3) +{ + switch (message_type) + { + case ML_MSG_TREE_ONCREATEVIEW: // param1 = param of tree item, param2 is HWND of parent. return HWND if it is us + if (param1 == m_query_tree || m_query_list[param1]) + return (INT_PTR)onTreeViewSelectChange((HWND)param2); + else + return 0; + + case ML_MSG_NAVIGATION_CONTEXTMENU: + { + HNAVITEM hItem = (HNAVITEM)param1; + HNAVITEM myItem = MLNavCtrl_FindItemById(plugin.hwndLibraryParent, m_query_tree); + if (hItem == myItem) + { + queriesContextMenu(param1, (HWND)param2, MAKEPOINTS(param3)); + return 1; + } + else + { + NAVITEM nvItem = {sizeof(NAVITEM),hItem,NIMF_ITEMID,}; + MLNavItem_GetInfo(plugin.hwndLibraryParent, &nvItem); + if (m_query_list[nvItem.id]) + { + view_queryContextMenu(param1, (HWND)param2, MAKEPOINTS(param3), nvItem.id); + return 1; + } + } + return 0; + } + + case ML_MSG_TREE_ONCLICK: + if (param1 == m_query_tree) + return OnLocalMediaClick(param2, (HWND)param3); + else if (m_query_list[param1]) + return OnLocalMediaItemClick(param2, param1, (HWND)param3); + else + return 0; + + case ML_MSG_TREE_ONDRAG: + if (m_query_list[param1]) + { + int *type = reinterpret_cast<int *>(param3); + *type = ML_TYPE_ITEMRECORDLIST; + return 1; + } + return 0; + + case ML_MSG_TREE_ONDROP: + if (param3 != NULL && param1 != NULL) // here we go - finishing moving view + { + if (m_query_list[param1]) + { + if (param3 == m_query_tree || m_query_list[param3]) + { + QueryList::iterator src = m_query_list.find(param1); + mediaLibrary.RemoveTreeItem(src->first); + MLTREEITEMW srcItem = {sizeof(MLTREEITEMW), }; + + srcItem.title = src->second->name; + srcItem.hasChildren = 0; + srcItem.parentId = m_query_tree; + srcItem.id = param3; + srcItem.imageIndex = src->second->imgIndex; + mediaLibrary.InsertTreeItem(srcItem); + + auto item = src->second; + m_query_list.erase(param1); + m_query_list.insert({ srcItem.id, item }); + + saveQueryTree(); + mediaLibrary.SelectTreeItem(srcItem.id); + return 1; + } + } + } + else if (m_query_list[param1]) + { + mlDropItemStruct m = {0}; + m.type = ML_TYPE_ITEMRECORDLISTW; + m.p = *(POINT *)param2; + m.flags = ML_HANDLEDRAG_FLAG_NOCURSOR | ML_HANDLEDRAG_FLAG_NAME; + + // build an itemRecordList + queryItem *item = m_query_list[param1]; + wchar_t configDir[MAX_PATH] = {0}; + PathCombineW(configDir, g_viewsDir, item->metafn); + C_Config viewconf(configDir); + + EnterCriticalSection(&g_db_cs); + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + NDE_Scanner_Query(s, item->query); + itemRecordListW obj = {0, }; + saveQueryToListW(&viewconf, s, &obj, 0, 0, (resultsniff_funcW)-1); + NDE_Table_DestroyScanner(g_table, s); + LeaveCriticalSection(&g_db_cs); + m.data = (void *) & obj; + AutoChar whatsThisNameUsedForAnyway(item->name); + m.name = whatsThisNameUsedForAnyway; + + pluginHandleIpcMessage(ML_IPC_HANDLEDROP, (WPARAM)&m); + if (m.result < 1) + { + m.result = 0; + m.type = ML_TYPE_ITEMRECORDLIST; + itemRecordList objA={0,}; + convertRecordList(&objA, &obj); + m.data = (void*)&objA; + pluginHandleIpcMessage(ML_IPC_HANDLEDRAG, (WPARAM)&m); + freeRecordList(&objA); + } + freeRecordList(&obj); + } + return 0; + + case ML_MSG_CONFIG: + mediaLibrary.GoToPreferences(preferences._id); + return TRUE; + + case ML_MSG_VIEW_PLAY_ENQUEUE_CHANGE: + enqueuedef = param1; + groupBtn = param2; + PostMessage(m_curview_hwnd, WM_APP + 104, param1, param2); + return 0; + + case ML_MSG_ONSENDTOBUILD: + if (param1 == ML_TYPE_ITEMRECORDLISTW || param1 == ML_TYPE_ITEMRECORDLIST || + param1 == ML_TYPE_FILENAMES || param1 == ML_TYPE_FILENAMESW) + { + if (!myMenu) mediaLibrary.AddToSendTo(WASABI_API_LNGSTRINGW(IDS_ADD_TO_LOCAL_MEDIA), param2, (INT_PTR)MessageProc); + } + break; + + case ML_MSG_ONSENDTOSELECT: + case ML_MSG_TREE_ONDROPTARGET: // return -1 if not allowed, 1 if allowed, or 0 if not our tree item + // set with droptarget defaults =) + INT_PTR type, data; + + if (message_type == ML_MSG_ONSENDTOSELECT) + { + if (param3 != (INT_PTR)MessageProc) return 0; + + type = param1; + data = param2; + } + else + { + if (param1 != m_query_tree && !m_query_list[param1]) return 0; + + type = param2; + data = param3; + + if (!data) + { + return (type == ML_TYPE_ITEMRECORDLISTW || type == ML_TYPE_ITEMRECORDLIST || + type == ML_TYPE_FILENAMES || type == ML_TYPE_FILENAMESW || + type == ML_TYPE_PLAYLIST) ? 1 : -1; + } + } + + if (data) + { + if (type == ML_TYPE_ITEMRECORDLIST) + { + itemRecordList *p = (itemRecordList*)data; + for (int x = 0; x < p->Size; x ++) + mediaLibrary.AddToMediaLibrary(p->Items[x].filename); + + return 1; + } + else if (type == ML_TYPE_ITEMRECORDLISTW) + { + itemRecordListW *p = (itemRecordListW*)data; + for (int x = 0; x < p->Size; x ++) + mediaLibrary.AddToMediaLibrary(p->Items[x].filename); + + return 1; + } + else if (type == ML_TYPE_PLAYLIST) + { + mlPlaylist * pl = (mlPlaylist *)data; + PLCallBackW plCB; + if (AGAVE_API_PLAYLISTMANAGER && PLAYLISTMANAGER_SUCCESS != AGAVE_API_PLAYLISTMANAGER->Load(pl->filename, &plCB)) + { + mediaLibrary.AddToMediaLibrary(pl->filename); + } + return 1; + } + else if (type == ML_TYPE_FILENAMES) + { + const char *p = (const char*)data; + while (p && *p) + { + PLCallBackW plCB; + if (AGAVE_API_PLAYLISTMANAGER && PLAYLISTMANAGER_SUCCESS != AGAVE_API_PLAYLISTMANAGER->Load(AutoWide(p), &plCB)) + { + mediaLibrary.AddToMediaLibrary(p); + } + p += strlen(p) + 1; + } + return 1; + } + else if (type == ML_TYPE_FILENAMESW) + { + const wchar_t *p = (const wchar_t*)data; + while (p && *p) + { + PLCallBackW plCB; + if (AGAVE_API_PLAYLISTMANAGER && PLAYLISTMANAGER_SUCCESS != AGAVE_API_PLAYLISTMANAGER->Load(p, &plCB)) + { + mediaLibrary.AddToMediaLibrary(p); + } + p += wcslen(p) + 1; + } + return 1; + } + } + break; + + case ML_MSG_TREE_ONKEYDOWN: + { + NMTVKEYDOWN *p = (NMTVKEYDOWN*)param2; + int ctrl = (GetAsyncKeyState(VK_CONTROL)&0x8000); + int shift = (GetAsyncKeyState(VK_SHIFT)&0x8000); + + if (p->wVKey == VK_INSERT && !shift) + { + if (!ctrl) + addNewQuery(plugin.hwndLibraryParent); + else + if (!g_bgscan_scanning) SendMessage(plugin.hwndLibraryParent, WM_USER + 575, 0xffff00dd, 0); + + PostMessageW(plugin.hwndLibraryParent, WM_NEXTDLGCTL, (WPARAM)param3, (LPARAM)TRUE); + return 1; + } + else if (m_query_list[param1]) + { + if (p->wVKey == VK_F2 && !shift && !ctrl) + { + queryEditItem(param1); + } + else if (p->wVKey == VK_DELETE && !shift && !ctrl) + { + queryDeleteItem(plugin.hwndLibraryParent, param1); + } + else + break; + + PostMessageW(plugin.hwndLibraryParent, WM_NEXTDLGCTL, (WPARAM)param3, (LPARAM)TRUE); + return 1; + } + return 0; + } + + case ML_IPC_HOOKEXTINFO: + if (IPC_HookExtInfo(param1)) return 1; + break; + + case ML_IPC_HOOKEXTINFOW: + if (IPC_HookExtInfoW(param1)) return 1; + break; + + case ML_IPC_HOOKTITLEW: + if (IPC_HookTitleInfo(param1)) return 1; + break; + + case ML_MSG_PLAYING_FILE: + if (param1) onStartPlayFileTrack((const wchar_t *)param1, false); + break; + } + return 0; +} + + +///////////////////////////////////////////////////////////////////////////////////////////////////////// +extern "C" winampMediaLibraryPlugin plugin = +{ + MLHDR_VER, + "nullsoft(ml_local.dll)", + Init, + Quit, + MessageProc, + 0, + 0, + 0, +}; + +extern "C" __declspec(dllexport) winampMediaLibraryPlugin *winampGetMediaLibraryPlugin() +{ + return &plugin; +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/Main.h b/Src/Plugins/Library/ml_local/Main.h new file mode 100644 index 00000000..bde0bc52 --- /dev/null +++ b/Src/Plugins/Library/ml_local/Main.h @@ -0,0 +1,71 @@ +#ifndef NULLSOFT_MAINH +#define NULLSOFT_MAINH + +#include <windows.h> +#include <windowsx.h> +#include <shlwapi.h> +#include "..\..\General\gen_ml/ml.h" +#include "../nu/MediaLibraryInterface.h" +#include "../nu/DialogSkinner.h" +#include "../winamp/wa_ipc.h" +#include "ml_local.h" +#include <shlobj.h> +#include "../nde/nde.h" +#include "../nde/nde_c.h" +#include <time.h> +#include "../Agave/Language/api_language.h" +#include "..\..\General\gen_ml/config.h" +#include "api__ml_local.h" +#include "../replicant/nu/AutoWide.h" +#include "../replicant/nu/AutoChar.h" +#include "AlbumArtCache.h" +#include "./local_menu.h" +#include "../playlist/ifc_playlistloadercallback.h" + +#define WM_QUERYFILEINFO (WM_USER + 65) +#define WM_SHOWFILEINFO (WM_USER + 64) // wParam - bForceUpdate, lParam - pszFileName + +extern winampMediaLibraryPlugin plugin; +extern int winampVersion; +extern int substantives; +extern int play_enq_rnd_alt; +extern bool nde_error; +extern HMENU wa_playlists_cmdmenu; +extern prefsDlgRecW preferences; +extern HWND hwndSearchGlobal; + +void EatKeyboard(); +void HookPlaylistEditor(); +void UnhookPlaylistEditor(); +extern bool skipTitleInfo; +extern wchar_t *recent_fn; + +extern int IPC_GET_CLOUD_HINST, IPC_GET_CLOUD_ACTIVE, IPC_CLOUD_ENABLED; +extern LRESULT ML_IPC_MENUFUCKER_BUILD; +extern LRESULT ML_IPC_MENUFUCKER_RESULT; + +extern int groupBtn, enqueuedef; +extern LARGE_INTEGER freq; + +class PLCallBackW : public ifc_playlistloadercallback +{ +public: + PLCallBackW(void){}; + ~PLCallBackW(void){}; +public: + void OnFile(const wchar_t *filename, const wchar_t *title, int lengthInMS, ifc_plentryinfo *info) + { + mediaLibrary.AddToMediaLibrary(filename); + } + RECVS_DISPATCH; +}; + +extern "C" void qsort_itemRecord(void *base, size_t num, const void *context, +int (__fastcall *comp)(const void *, const void *, const void *)); + +void MigrateArtCache(); +void setCloudValue(itemRecordW *item, const wchar_t* value); + +void onStartPlayFileTrack(const wchar_t *filename, bool resume); + +#endif
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/ReIndexUI.cpp b/Src/Plugins/Library/ml_local/ReIndexUI.cpp new file mode 100644 index 00000000..83e0c968 --- /dev/null +++ b/Src/Plugins/Library/ml_local/ReIndexUI.cpp @@ -0,0 +1,333 @@ +#include "Main.h" +#include "ml_local.h" +#include "resource.h" + +static INT_PTR CALLBACK CompactWndProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam) +{ + switch (msg) + { + case WM_INITDIALOG: + { + SetWindowLongPtr(hwndDlg, GWLP_USERDATA, lParam); + SendDlgItemMessage(hwndDlg, IDC_PROGRESS1, PBM_SETRANGE, 0, MAKELPARAM(0, 400)); + SendDlgItemMessage(hwndDlg, IDC_PROGRESS1, PBM_SETPOS, 0, 0); + + int *progress = (int *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA); + if (progress[1] == -102) + { + progress[1] = -101; + SetWindowTextW(hwndDlg, WASABI_API_LNGSTRINGW(IDS_REFRESH_FILESIZE_DATEADDED)); + } + + SetTimer(hwndDlg, 666, 500, 0); + break; + } + case WM_TIMER: + if (wParam == 666) + { + int *progress = (int *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA); + if (progress[0] == 666) + { + KillTimer(hwndDlg, 666); + EndDialog(hwndDlg, 0); + } + else if (progress[1] != -101) + { + SendDlgItemMessage(hwndDlg, IDC_PROGRESS1, PBM_SETPOS, progress[1] + 300, 0); + } + else + { + SendDlgItemMessage(hwndDlg, IDC_PROGRESS1, PBM_SETPOS, progress[0] + 100, 0); + } + } + break; + } + return 0; +} + +static DWORD CALLBACK CompactThread(LPVOID param) +{ + WASABI_API_DIALOGBOXPARAMW(IDD_REINDEX, NULL, CompactWndProc, (LPARAM)param); + return 0; +} + +static int sortFunc(const void *a, const void *b) +{ + const wchar_t **fn1 = (const wchar_t **)a; + const wchar_t **fn2 = (const wchar_t **)b; + return _wcsicmp(*fn1, *fn2); +} + +void RetypeFilename(nde_table_t table) +{ + int totalRecords = NDE_Table_GetRecordsCount(g_table); + if (totalRecords == 0) // bail out early so we don't flash a dialog + return; + + int progress[2] = {-100, -101}; + DWORD threadId = 0; + HANDLE compactThread = 0; + + nde_scanner_t pruneScanner = NDE_Table_CreateScanner(table); + if (pruneScanner) + { + bool first=true; + int recordNum = 0; + NDE_Scanner_First(pruneScanner); + while (!NDE_Scanner_EOF(pruneScanner)) + { + progress[0] = MulDiv(recordNum, 100, totalRecords)-100; + nde_field_t f = NDE_Scanner_GetFieldByID(pruneScanner, MAINTABLE_ID_FILENAME); + if (f && NDE_Field_GetType(f) == FIELD_STRING) + { + wchar_t *s = NDE_StringField_GetString(f); + ndestring_retain(s); + + NDE_Scanner_DeleteField(pruneScanner, f); + + nde_field_t new_f = NDE_Scanner_NewFieldByID(pruneScanner, MAINTABLE_ID_FILENAME); + NDE_StringField_SetString(new_f, s); + + ndestring_release(s); + NDE_Scanner_Post(pruneScanner); + } + else if (f) + { + first = false; // skips creating the thread + break; + } + + recordNum++; + NDE_Scanner_Next(pruneScanner); + if (first) + { + compactThread = CreateThread(0, 0, CompactThread, progress, 0, &threadId); + DumpArtCache(); // go ahead and dump the album art cache if we had to rebuild this table. ideally we could perform the same logic but this is easier and it's 1 in the morning and i don't feel like doing it :) + } + first=false; + } + + NDE_Table_DestroyScanner(table, pruneScanner); + if (compactThread) + NDE_Table_Sync(table); + } + progress[0] = 666; + if (compactThread) + { + WaitForSingleObject(compactThread, INFINITE); + CloseHandle(compactThread); + } +} + +void RefreshFileSizeAndDateAddedTable(nde_table_t table) +{ + int totalRecords = NDE_Table_GetRecordsCount(g_table); + if (totalRecords == 0) // bail out early so we don't flash a dialog + return; + + int progress[2] = {-100, -102}; + DWORD threadId = 0; + HANDLE compactThread = 0; + + nde_scanner_t scanner = NDE_Table_CreateScanner(table); + if (scanner) + { + bool first=true; + int recordNum = 0; + NDE_Scanner_First(scanner); + while (!NDE_Scanner_EOF(scanner)) + { + progress[0] = MulDiv(recordNum, 400, totalRecords); + + // converts filesize from a int and kb scaled value to the actual filesize as a int64 + nde_field_t f = NDE_Scanner_GetFieldByID(scanner, MAINTABLE_ID_FILESIZE); + if (f && NDE_Field_GetType(f) == FIELD_INTEGER) + { + __int64 size = NDE_IntegerField_GetValue(f); + if (size) size *= 1024; + + NDE_Scanner_DeleteField(scanner, f); + + nde_field_t new_f = NDE_Scanner_NewFieldByType(scanner, FIELD_INT64, MAINTABLE_ID_FILESIZE); + NDE_Int64Field_SetValue(new_f, size); + + NDE_Scanner_Post(scanner); + } + + // takes the lastupd value and applies it to dateadded so we've got something to use + f = NDE_Scanner_GetFieldByID(scanner, MAINTABLE_ID_LASTUPDTIME); + if (f && NDE_Field_GetType(f) == FIELD_DATETIME) + { + int lastupd = NDE_IntegerField_GetValue(f); + nde_field_t new_f = NDE_Scanner_NewFieldByID(scanner, MAINTABLE_ID_DATEADDED); + NDE_IntegerField_SetValue(new_f, lastupd); + + NDE_Scanner_Post(scanner); + } + + NDE_Scanner_Next(scanner); + recordNum++; + if (first) + { + compactThread = CreateThread(0, 0, CompactThread, progress, 0, &threadId); + } + first=false; + } + + NDE_Table_DestroyScanner(table, scanner); + if (compactThread) + NDE_Table_Sync(table); + } + progress[0] = 666; + if (compactThread) + { + WaitForSingleObject(compactThread, INFINITE); + CloseHandle(compactThread); + } +} + +void ReindexTable(nde_table_t table) +{ + int totalRecords = NDE_Table_GetRecordsCount(g_table); + if (totalRecords == 0) // bail out early so we don't flash a dialog + return; + + int progress[2] = {-100, -101}; + DWORD threadId; + HANDLE compactThread = CreateThread(0, 0, CompactThread, progress, 0, &threadId); + + nde_scanner_t pruneScanner = NDE_Table_CreateScanner(table); + if (pruneScanner) + { + int recordNum = 0; + NDE_Scanner_First(pruneScanner); + while (!NDE_Scanner_EOF(pruneScanner)) + { + int total = MulDiv(recordNum, 100, totalRecords); + progress[0] = total - 100; + #ifndef elementsof + #define elementsof(x) (sizeof(x)/sizeof(*x)) + #endif + unsigned char STR_IDS[] = {MAINTABLE_ID_TITLE, MAINTABLE_ID_ARTIST, MAINTABLE_ID_ALBUM, MAINTABLE_ID_GENRE, + MAINTABLE_ID_COMMENT, MAINTABLE_ID_GRACENOTE_ID, MAINTABLE_ID_ALBUMARTIST, + MAINTABLE_ID_TRACKGAIN, MAINTABLE_ID_PUBLISHER, MAINTABLE_ID_COMPOSER, + MAINTABLE_ID_PODCASTCHANNEL, MAINTABLE_ID_GRACENOTEFILEID, MAINTABLE_ID_GRACENOTEEXTDATA, + MAINTABLE_ID_CATEGORY, MAINTABLE_ID_CODEC, MAINTABLE_ID_DIRECTOR, MAINTABLE_ID_PRODUCER + }; + for (size_t i = 0;i != elementsof(STR_IDS);i++) + { + nde_field_t f = NDE_Scanner_GetFieldByID(pruneScanner, STR_IDS[i]); + if (f) + { + const wchar_t *s = NDE_StringField_GetString(f); + if (!s || !*s) + { + NDE_Scanner_DeleteField(pruneScanner, f); + NDE_Scanner_Post(pruneScanner); + } + } + } + + unsigned char INT_IDS_ZEROOK[] = {MAINTABLE_ID_LENGTH, MAINTABLE_ID_PLAYCOUNT, MAINTABLE_ID_FILESIZE, + MAINTABLE_ID_TYPE, MAINTABLE_ID_ISPODCAST, MAINTABLE_ID_LOSSLESS + }; + for (size_t i = 0;i != elementsof(INT_IDS_ZEROOK);i++) + { + nde_field_t f = NDE_Scanner_GetFieldByID(pruneScanner, INT_IDS_ZEROOK[i]); + if (f) + { + int s = NDE_IntegerField_GetValue(f); + if (s < 0) + { + NDE_Scanner_DeleteField(pruneScanner, f); + NDE_Scanner_Post(pruneScanner); + + } + } + } + + unsigned char INT_IDS[] = {MAINTABLE_ID_TRACKNB, MAINTABLE_ID_LASTUPDTIME, MAINTABLE_ID_LASTPLAY, MAINTABLE_ID_RATING, + MAINTABLE_ID_FILETIME, MAINTABLE_ID_BITRATE, MAINTABLE_ID_DISC, MAINTABLE_ID_BPM, MAINTABLE_ID_DISCS, + MAINTABLE_ID_TRACKS, MAINTABLE_ID_PODCASTPUBDATE, MAINTABLE_ID_FILESIZE, MAINTABLE_ID_DATEADDED + }; + for (size_t i = 0;i != elementsof(INT_IDS);i++) + { + nde_field_t f = NDE_Scanner_GetFieldByID(pruneScanner, INT_IDS[i]); + if (f) + { + int s = NDE_IntegerField_GetValue(f); + if (s <= 0) + { + NDE_Scanner_DeleteField(pruneScanner, f); + NDE_Scanner_Post(pruneScanner); + } + } + } + NDE_Scanner_Next(pruneScanner); + recordNum++; + } + + NDE_Table_DestroyScanner(table, pruneScanner); + NDE_Table_Sync(table); + } + + NDE_Table_Compact(table, &progress[0]); + assert(((Table *)table)->CheckIndexing()); + // now remove duplicates + nde_scanner_t dupscanner = NDE_Table_CreateScanner(table); + if (dupscanner) + { + int count = NDE_Scanner_GetRecordsCount(dupscanner); + wchar_t **filenames = new wchar_t *[count]; + int i = 0; + for (NDE_Scanner_First(dupscanner);!NDE_Scanner_EOF(dupscanner);NDE_Scanner_Next(dupscanner)) + { + nde_field_t fileName = NDE_Scanner_GetFieldByID(dupscanner, MAINTABLE_ID_FILENAME); + if (fileName) + { + filenames[i] = NDE_StringField_GetString(fileName); + ndestring_retain(filenames[i]); + i++; + } + } + count = i; + if (count) + { + qsort(filenames, count, sizeof(wchar_t *), sortFunc); + for (int x = 0;x < (count - 1);x++) + { + int total = MulDiv(x, 100, count); + progress[1] = total - 100; + + if (!_wcsicmp(filenames[x], filenames[x+1])) + { + wchar_t query[1024] = {0}; + wnsprintfW(query, 1024, L"filename == \"%s\"", filenames[x]); + + nde_scanner_t scanner = NDE_Table_CreateScanner(table); + NDE_Scanner_Query(scanner, query); + + NDE_Scanner_First(scanner); + NDE_Scanner_Next(scanner); + while (!NDE_Scanner_EOF(scanner)) + { + NDE_Scanner_Delete(scanner); + NDE_Scanner_Post(scanner); + NDE_Scanner_Next(scanner); + } + NDE_Table_DestroyScanner(table, scanner); + } + ndestring_release(filenames[x]); + filenames[x]=0; + } + } + delete[] filenames; + } + NDE_Table_DestroyScanner(table, dupscanner); + NDE_Table_Sync(table); + NDE_Table_Compact(table, &progress[1]); + + progress[0] = 666; + WaitForSingleObject(compactThread, INFINITE); + CloseHandle(compactThread); +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/SaveQuery.cpp b/Src/Plugins/Library/ml_local/SaveQuery.cpp new file mode 100644 index 00000000..35cac30c --- /dev/null +++ b/Src/Plugins/Library/ml_local/SaveQuery.cpp @@ -0,0 +1,406 @@ +#include "main.h" +#include "ml_local.h" +#include <shlwapi.h> +#include <assert.h> +#include "../nu/sort.h" + +/* +#ifdef _M_IX86 +#undef min +static inline int min(int x, int y) +{ + return y+((x-y)>>31)&(x-y); +} +#undef max +static inline int max(int x, int y) +{ + return x-(((x-y)>>(31))&(x-y)); +} + +#elif defined(_WIN64) +#undef min +static inline int min(int x, int y) +{ + return y+((x-y)>>63)&(x-y); +} +#undef max +static inline int max(int x, int y) +{ + return x-(((x-y)>>(63))&(x-y)); +} +#endif +*/ + +#ifdef _M_IX86 +const size_t convert_max_characters = 16; // it's actually 11, but this probably causes less memory fragmentation +#elif defined(_M_X64) +const size_t convert_max_characters = 20; +#endif + +static inline int Compare_Int_NegativeIsNull(int v1, int v2) +{ + v1 = max(v1,0); + v2 = max(v2,0); + return(v1 - v2); +} + +typedef int (__fastcall *SortFunction)(const itemRecordW *a, const itemRecordW *b); +#define SORT(field) SortBy ## field +#define STRING_SORT(field) static int __fastcall SORT(field)(const itemRecordW *a, const itemRecordW *b) { return WCSCMP_NULLOK(a->field, b->field); } +#define EXT_STRING_SORT(field) static int __fastcall SORT(field)(const itemRecordW *a, const itemRecordW *b) { wchar_t *a_field = getRecordExtendedItem_fast(a, extended_fields.field); wchar_t *b_field = getRecordExtendedItem_fast(b, extended_fields.field); return WCSCMP_NULLOK(a_field, b_field);} +#define TIME_SORT(field) static int __fastcall SORT(field)(const itemRecordW *a, const itemRecordW *b) { time_t v1 = (time_t)a->field; time_t v2 = (time_t)b->field; if (v1 == -1) v1 = 0; if (v2 == -1) v2 = 0; return (int)(v1 - v2);} +#define EXT_TIME_SORT(field) static int __fastcall SORT(field)(const itemRecordW *a, const itemRecordW *b) { wchar_t *a_field = getRecordExtendedItem_fast(a, extended_fields.dateadded); wchar_t *b_field = getRecordExtendedItem_fast(b, extended_fields.dateadded); time_t v1 = a_field?_wtoi(a_field):0; time_t v2 = b_field?_wtoi(b_field):0; if (v1 == -1) v1 = 0; if (v2 == -1) v2 = 0; return (int)(v1 - v2);} +#define INT_SORT(field) static int __fastcall SORT(field)(const itemRecordW *a, const itemRecordW *b) { return Compare_Int_NegativeIsNull(a->field, b->field); } +#define EXT_INT_SORT(field) static int __fastcall SORT(field)(const itemRecordW *a, const itemRecordW *b) { wchar_t *a_field = getRecordExtendedItem_fast(a, extended_fields.field); wchar_t *b_field = getRecordExtendedItem_fast(b, extended_fields.field); int v1 = a_field?_wtoi(a_field):0; int v2 = b_field?_wtoi(b_field):0; return (v1-v2);} +#define FLOAT_SORT(field) static int __fastcall SORT(field)(const itemRecordW *a, const itemRecordW *b) { return FLOATWCMP_NULLOK(a->field, b->field); } +STRING_SORT(artist); +STRING_SORT(title); +STRING_SORT(album); +INT_SORT(length); +INT_SORT(track); +STRING_SORT(genre); +INT_SORT(year); +static int __fastcall SORT(filespec)(const itemRecordW *a, const itemRecordW *b) +{ + // remove path before compare... + wchar_t * af = L""; + if (a->filename) + af = PathFindFileNameW(a->filename); + + wchar_t * bf = L""; + if (b->filename) + bf = PathFindFileNameW(b->filename); + + return _wcsicmp(af, bf); +} + +INT_SORT(rating); +INT_SORT(playcount); +TIME_SORT(lastplay); +TIME_SORT(lastupd); +TIME_SORT(filetime); +STRING_SORT(comment); +INT_SORT(filesize); +INT_SORT(bitrate); +INT_SORT(type); +INT_SORT(disc); +STRING_SORT(albumartist); +STRING_SORT(filename); +FLOAT_SORT(replaygain_album_gain); +FLOAT_SORT(replaygain_track_gain); +STRING_SORT(publisher); +STRING_SORT(composer); +static int __fastcall SORT(extension)(const itemRecordW *a, const itemRecordW *b) +{ + wchar_t *extA = PathFindExtensionW(a->filename); + wchar_t *extB = PathFindExtensionW(b->filename); + if (extA && *extA) + extA++; + if (extB && *extB) + extB++; + return WCSCMP_NULLOK(extA, extB); +} +EXT_INT_SORT(ispodcast); +EXT_STRING_SORT(podcastchannel); +EXT_STRING_SORT(podcastpubdate); +INT_SORT(bpm); +STRING_SORT(category); +EXT_STRING_SORT(director); +EXT_STRING_SORT(producer); +EXT_TIME_SORT(dateadded); +EXT_STRING_SORT(cloud); + +static int __fastcall SORT(dimension)(const itemRecordW *a, const itemRecordW *b) +{ + wchar_t *a_width = getRecordExtendedItem_fast(a, extended_fields.width); + wchar_t *b_width = getRecordExtendedItem_fast(b, extended_fields.width); + wchar_t *a_height = getRecordExtendedItem_fast(a, extended_fields.height); + wchar_t *b_height = getRecordExtendedItem_fast(b, extended_fields.height); + int w1 = a_width?_wtoi(a_width):0; + int w2 = b_width?_wtoi(b_width):0; + int h1 = a_height?_wtoi(a_height):0; + int h2 = b_height?_wtoi(b_height):0; + if (w1 != w2) + return (w1-w2); + else + return (h1-h2); +} +// DISABLED FOR 5.62 RELEASE - DRO +//EXT_STRING_SORT(codec); + +#define FORCE_ASCENDING ((SortFunction)-2) +// this is where we define sort orders! +static const SortFunction sortOrder[MEDIAVIEW_COL_NUMS][MEDIAVIEW_COL_NUMS+2] = +{ + {SORT(artist), FORCE_ASCENDING, SORT(album), SORT(disc), SORT(track), SORT(title), 0}, // Artist + {SORT(title), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0}, + {SORT(album), FORCE_ASCENDING, SORT(albumartist), SORT(disc), SORT(track), SORT(title), 0}, + {SORT(length), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0}, + {SORT(track), FORCE_ASCENDING, SORT(title), SORT(artist), SORT(album), SORT(disc), 0}, + {SORT(genre), FORCE_ASCENDING, SORT(albumartist), SORT(artist), SORT(album), SORT(disc), SORT(track), 0}, + {SORT(year), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0}, + {SORT(filespec), SORT(filename),0}, + {SORT(rating), SORT(playcount), SORT(lastplay), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0}, + {SORT(playcount), SORT(lastplay), FORCE_ASCENDING,SORT(artist), SORT(album), SORT(disc), SORT(track), 0}, + {SORT(lastplay), FORCE_ASCENDING,SORT(artist), SORT(album), SORT(disc), SORT(track), 0}, + {SORT(lastupd), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0}, + {SORT(filetime), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0}, + {SORT(comment), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0}, + {SORT(filesize),FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0}, + {SORT(bitrate), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0}, + {SORT(type), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0}, + {SORT(disc), FORCE_ASCENDING, SORT(track), SORT(title), SORT(artist), SORT(album), SORT(disc), 0}, + {SORT(albumartist), FORCE_ASCENDING, SORT(album), SORT(disc), SORT(track), 0}, + {SORT(filename), 0}, + {SORT(replaygain_album_gain), FORCE_ASCENDING, SORT(album), SORT(disc), SORT(track), SORT(title), 0}, + {SORT(replaygain_track_gain), FORCE_ASCENDING, SORT(title), 0}, + {SORT(publisher),FORCE_ASCENDING,SORT(artist), SORT(album), SORT(disc), SORT(track), SORT(title), 0}, + {SORT(composer), FORCE_ASCENDING,SORT(album), SORT(disc), SORT(track), 0}, + {SORT(extension), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0}, + {SORT(ispodcast), FORCE_ASCENDING, SORT(podcastchannel), SORT(title), 0}, + {SORT(podcastchannel), SORT(title), 0}, + {SORT(podcastpubdate), 0}, + {SORT(bpm), 0}, // TODO + {SORT(category),FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), SORT(title), 0}, + {SORT(director),FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), SORT(title), 0}, + {SORT(producer),FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), SORT(title), 0}, + {SORT(dimension), 0}, + // DISABLED FOR 5.62 RELEASE - DRO + //{SORT(codec), 0}, + {SORT(dateadded), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0}, + {SORT(cloud), FORCE_ASCENDING, SORT(artist), SORT(album), SORT(disc), SORT(track), 0}, +}; + +/* ---- */ +struct SortRules +{ + int by; + int dir; +}; +static int __fastcall sortFuncW(const void *elem1, const void *elem2, const void *context) +{ + assert(sizeof(sortOrder) / sizeof(*sortOrder) == MEDIAVIEW_COL_NUMS); + + const itemRecordW *a = (const itemRecordW*)elem1; + const itemRecordW *b = (const itemRecordW*)elem2; + + const SortRules *rules = (SortRules *)context; + int use_by = rules->by; + int use_dir = !!rules->dir; + + int dir_values[] = {-1, 1}; + +#define RETIFNZ(v) if ((v)<0) return dir_values[use_dir]; if ((v)>0) return -dir_values[use_dir]; + + const SortFunction *order =sortOrder[use_by]; + int i=0; + while (order[i]) + { + if (order[i]==FORCE_ASCENDING) + { + use_dir=0; + i++; + continue; + } + int v = order[i](a, b); + RETIFNZ(v); + i++; + } + return 0; +} + +void sortResults(int column, int dir, itemRecordListW *obj) // sorts the results based on the current sort mode +{ + if (obj->Size > 1) + { + SortRules rules = {column, dir}; + qsort_itemRecord(obj->Items, obj->Size, &rules, sortFuncW); + } +} + +void sortResults(C_Config *viewconf, itemRecordListW *obj) // sorts the results based on the current sort mode +{ + if (viewconf) + { + SortRules rules = {viewconf->ReadInt(L"mv_sort_by", MEDIAVIEW_COL_ARTIST), viewconf->ReadInt(L"mv_sort_dir", 0)}; + if (obj->Size > 1) + qsort_itemRecord(obj->Items, obj->Size, &rules, sortFuncW); + } +} + +void setCloudValue(itemRecordW *item, const wchar_t* value) +{ + wchar_t *temp = ndestring_malloc(convert_max_characters*sizeof(wchar_t)); + lstrcpynW(temp, value, convert_max_characters); + setRecordExtendedItem(item, extended_fields.cloud, temp); + ndestring_release(temp); +} + +int saveQueryToListW(C_Config *viewconf, nde_scanner_t s, itemRecordListW *obj, + CloudFiles *uploaded, CloudFiles *uploading, + resultsniff_funcW cb, int user32, int *killswitch, __int64 *total_bytes) +{ + __int64 total_kb = 0; + + emptyRecordList(obj); + + EnterCriticalSection(&g_db_cs); + NDE_Scanner_First(s, killswitch); + if (killswitch && *killswitch) + { + LeaveCriticalSection(&g_db_cs); + return 0; + } + + int r = 0; + unsigned int total_length_s = 0; + unsigned int uncert_cnt = 0; + unsigned int cert_cnt = 0; + int recordCount = NDE_Scanner_GetRecordsCount(s); + allocRecordList(obj, recordCount); + do + { + nde_field_t f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_FILENAME); + if (f) + { + allocRecordList(obj, obj->Size + 1); + if (!obj->Alloc) break; + + obj->Items[obj->Size].filename = NDE_StringField_GetString(f); + ndestring_retain(obj->Items[obj->Size].filename); + total_kb += ScannerRefToObjCacheNFNW(s, obj, (cb == (resultsniff_funcW)-1 ? true : false)); + + // look for any files known to the cloud so the icon can be set accordingly + // TODO possibly need to do more here to better cope with transient states?? + if (uploaded && uploaded->size() > 0) + { + bool found = false; + for(CloudFiles::iterator iter = uploaded->begin(); iter != uploaded->end(); iter++) + { + if (nde_wcsicmp_fn(obj->Items[obj->Size - 1].filename,(*iter)) == 0) + { + bool pending = false; + found = true; + + // catches files being uploaded but not fully known to be in the cloud, etc + if (uploading && uploading->size() > 0) + { + for(CloudFiles::iterator iter2 = uploading->begin(); iter2 != uploading->end(); iter2++) + { + if (nde_wcsicmp_fn(obj->Items[obj->Size - 1].filename,(*iter2)) == 0) + { + pending = true; + setCloudValue(&obj->Items[obj->Size - 1], L"5"); + break; + } + } + } + + if (!pending) + { + setCloudValue(&obj->Items[obj->Size - 1], L"0"); + } + break; + } + } + + if (!found) + { + // catches files being uploaded but not fully known to be in the cloud, etc + if (uploading && uploading->size() > 0) + { + for(CloudFiles::iterator iter = uploading->begin(); iter != uploading->end(); iter++) + { + if (nde_wcsicmp_fn(obj->Items[obj->Size - 1].filename,(*iter)) == 0) + { + found = true; + setCloudValue(&obj->Items[obj->Size - 1], L"5"); + break; + } + } + } + + if (!found) + { + setCloudValue(&obj->Items[obj->Size - 1], L"4"); + } + } + } + + int thisl = obj->Items[obj->Size - 1].length; + + if (thisl > 0) + { + total_length_s += thisl; + cert_cnt++; + } + else + { + uncert_cnt++; + } + } + + r = NDE_Scanner_Next(s, killswitch); + if (killswitch && *killswitch) + { + LeaveCriticalSection(&g_db_cs); + return 0; + } + } + while (r && !NDE_Scanner_EOF(s)); + + if (((Table *)g_table)->HasErrors()) // TODO: don't use C++ NDE API + { + wchar_t *last_query = NULL; + if (m_media_scanner) + { + const wchar_t *lq = NDE_Scanner_GetLastQuery(m_media_scanner); + if (lq) last_query = _wcsdup(lq); + NDE_Table_DestroyScanner(g_table, m_media_scanner); + } + NDE_Table_Compact(g_table); + if (m_media_scanner) + { + m_media_scanner = NDE_Table_CreateScanner(g_table); + if (last_query != NULL) + { + NDE_Scanner_Query(m_media_scanner, last_query); + free(last_query); + } + } + } + LeaveCriticalSection(&g_db_cs); + + if (total_bytes) + { + // maintain compatibility as needed + if (cb == (resultsniff_funcW)-1) + *total_bytes = total_kb * 1024; + else + *total_bytes = total_kb; + } + compactRecordList(obj); + + if (cb && cb != (resultsniff_funcW)-1) + { + cb(obj->Items, obj->Size, user32, killswitch); + } + + if (killswitch && *killswitch) return 0; + + sortResults(viewconf, obj); + + if (killswitch && *killswitch) return 0; + + if (uncert_cnt) + { + if (cert_cnt) + { + __int64 avg_len = (__int64)total_length_s / cert_cnt; + total_length_s += (DWORD)(avg_len * uncert_cnt); + } + total_length_s |= (1 << 31); + } + + return total_length_s; +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/ScanFolderBrowser.cpp b/Src/Plugins/Library/ml_local/ScanFolderBrowser.cpp new file mode 100644 index 00000000..ae49d0a0 --- /dev/null +++ b/Src/Plugins/Library/ml_local/ScanFolderBrowser.cpp @@ -0,0 +1,475 @@ +#include "main.h" +#include "./scanfolderbrowser.h" +#include "resource.h" + +/// New controls +#define IDC_CHK_BGSCAN 0x1980 +#define IDC_TLB_BOOKMARKS 0x1978 +#define TOOLBAR_BTN_STARTID 0x1000 + +#define PATHTYPE_CSIDL 0 +#define PATHTYPE_STRING 1 +#define PATHTYPE_PIDL 2 + +typedef struct __FOLDER +{ + int pathtype; + INT_PTR path; + LPCWSTR caption; // if NULL display name will be used + LPCWSTR tooltip; // if NULL display name will be used +} FOLDER; + +typedef struct _FBUTTON +{ + LPITEMIDLIST pidl; + LPWSTR caption; + LPWSTR tooltip; + INT iImage; +} FBUTTON; + +static const FOLDER BOOKMARKS[] = +{ + {PATHTYPE_STRING, (INT_PTR)L"C:\\Program Files\\Winamp", NULL, NULL }, + {PATHTYPE_CSIDL, CSIDL_MYMUSIC, NULL, NULL }, + {PATHTYPE_CSIDL, CSIDL_MYVIDEO, NULL, NULL }, + {PATHTYPE_CSIDL, CSIDL_PERSONAL, NULL, NULL }, + {PATHTYPE_CSIDL, CSIDL_DESKTOP, NULL, NULL }, + {PATHTYPE_CSIDL, CSIDL_DRIVES, NULL, NULL}, + {PATHTYPE_CSIDL, CSIDL_NETWORK, NULL, NULL }, +}; + +static HIMAGELIST hSysImageList; + +//// XP THEME - BEGIN +typedef HANDLE HTHEME; + +typedef HRESULT (WINAPI *XPT_CLOSETHEMEDATA)(HTHEME); +typedef BOOL (WINAPI *XPT_ISAPPTHEMED)(void); +typedef HTHEME (WINAPI *XPT_OPENTHEMEDATA)(HWND, LPCWSTR); +typedef HRESULT (WINAPI *XPT_GETTHEMECOLOR)(HTHEME, INT, INT, INT, COLORREF*); + +#define GP_BORDER 1 +#define BSS_FLAT 1 +#define TMT_BORDERCOLOR 3801 + +static XPT_CLOSETHEMEDATA xpCloseThemeData; +static XPT_ISAPPTHEMED xpIsAppThemed; +static XPT_OPENTHEMEDATA xpOpenThemeData; +static XPT_GETTHEMECOLOR xpGetThemeColor; + +static HINSTANCE xpThemeDll = NULL; + +static BOOL LoadXPTheme(void); +static void UnloadXPTheme(void); +//// XP THEME - END + +static HBRUSH GetBorderBrush(HWND hwnd); + +static void Initialize(ScanFolderBrowser *browser, BOOL showBckScan, BOOL checkBckScan) +{ + browser->buttonsCount = 0; + browser->buttons = NULL; + browser->bkScanChecked = checkBckScan; + browser->bkScanShow = showBckScan; + browser->pac = NULL; + browser->pacl2 = NULL; + + HRESULT result = CoCreateInstance(CLSID_AutoComplete, NULL, CLSCTX_INPROC_SERVER, IID_IAutoComplete, (LPVOID*)&browser->pac); + if (S_OK == result) + { + IAutoComplete2 *pac2; + if (SUCCEEDED(browser->pac->QueryInterface(IID_IAutoComplete2, (LPVOID*)&pac2))) + { + pac2->SetOptions(ACO_AUTOSUGGEST | ACO_AUTOAPPEND | ACO_USETAB | 0x00000020/*ACF_UPDOWNKEYDROPSLIST*/); + } + result = CoCreateInstance(CLSID_ACListISF, NULL, CLSCTX_INPROC_SERVER, IID_IACList2, (LPVOID*)&browser->pacl2); + if (S_OK == result) browser->pacl2->SetOptions(ACLO_FILESYSDIRS); + else { browser->pac->Release(); browser->pac = NULL; } + } + + lstrcpynW(browser->selectionPath, WASABI_API_APP->path_getWorkingPath(), MAX_PATH); + + browser->SetCaption(WASABI_API_LNGSTRINGW(IDS_ADD_MEDIA_TO_LIBRARY_)); + browser->SetTitle(WASABI_API_LNGSTRINGW(IDS_SELECT_FOLDER_TO_ADD_TO_WINAMP_MEDIA_LIBRARY)); + browser->SetSelection(browser->selectionPath); + browser->SetFlags(BIF_RETURNONLYFSDIRS | BIF_EDITBOX | BIF_VALIDATE | BIF_USENEWUI | BIF_NONEWFOLDERBUTTON | BIF_NEWDIALOGSTYLE); + browser->LoadBookmarks(); +} + +ScanFolderBrowser::ScanFolderBrowser(BOOL showBckScanOption) +{ + Initialize(this, showBckScanOption, FALSE); +} + +ScanFolderBrowser::ScanFolderBrowser(void) +{ + Initialize(this, TRUE, FALSE); +} + +ScanFolderBrowser::~ScanFolderBrowser(void) +{ + if (pacl2) pacl2->Release(); + if (pac) pac->Release(); + FreeBookmarks(); +} + +void ScanFolderBrowser::LoadBookmarks(void) +{ + FreeBookmarks(); + INT count = sizeof(BOOKMARKS)/sizeof(FOLDER); + if (!count) return; + + buttons = (FBUTTON*)calloc(count, sizeof(FBUTTON)); + if (!buttons) return; + buttonsCount = 0; + + for (int i = 0; i < count; i++) + { + const FOLDER *pfolder = &BOOKMARKS[i]; + FBUTTON *pfb = &buttons[buttonsCount]; + switch(BOOKMARKS[i].pathtype) + { + case PATHTYPE_PIDL: + pfb->pidl = ILClone((LPITEMIDLIST)pfolder->path); // need to copy it + break; + case PATHTYPE_CSIDL: + if (S_OK != SHGetSpecialFolderLocation(NULL, (INT)pfolder->path, &pfb->pidl)) pfb->pidl = NULL; + break; + case PATHTYPE_STRING: + if (S_OK != ParseDisplayName((LPCWSTR)pfolder->path, NULL, &pfb->pidl, 0, NULL))pfb->pidl = NULL; + break; + } + if (!buttons[buttonsCount].pidl) + { + continue; + } + + SHFILEINFOW shfi = {0}; + hSysImageList = (HIMAGELIST)SHGetFileInfoW((LPCWSTR)pfb->pidl, 0, &shfi, sizeof(SHFILEINFO), SHGFI_DISPLAYNAME | SHGFI_ICON | SHGFI_LARGEICON | SHGFI_SYSICONINDEX | SHGFI_PIDL); + pfb->caption = _wcsdup((pfolder->caption) ? pfolder->caption : shfi.szDisplayName); + pfb->tooltip = _wcsdup((pfolder->tooltip) ? pfolder->tooltip : shfi.szDisplayName); + pfb->iImage = shfi.iIcon; + buttonsCount++; + } +} + +void ScanFolderBrowser::FreeBookmarks(void) +{ + if (buttons) + { + FBUTTON *pbtn = buttons; + while(buttonsCount--) + { + if (pbtn->caption) { free(pbtn->caption); pbtn->caption = NULL; } + if (pbtn->tooltip) { free(pbtn->tooltip); pbtn->tooltip = NULL; } + if (pbtn->pidl) { ILFree(pbtn->pidl); pbtn->pidl = NULL; } + pbtn++; + } + free(buttons); + } + buttonsCount = 0; +} + +void ScanFolderBrowser::OnInitialized(void) +{ + HWND ctrlWnd; + + if (!FindWindowExW(GetHandle(), NULL,L"SHBrowseForFolder ShellNameSpace Control",NULL)) + { + RECT rw; + int cx; + GetWindowRect(GetHandle(), &rw); + cx = rw.right - rw.left; + SetWindowPos(GetHandle(), NULL, 0, 0, cx, rw.bottom - rw.top, SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED); + GetWindowRect(GetHandle(), &rw); + ShrinkWindows((rw.right - rw.left) - cx); + } + SetOKText(WASABI_API_LNGSTRINGW(IDS_ADD)); + + ShiftWindows(88); + + ctrlWnd = CreateWindowExW(WS_EX_NOPARENTNOTIFY , TOOLBARCLASSNAMEW, NULL, + WS_CHILD | WS_TABSTOP | + CCS_TOP | CCS_NODIVIDER | CCS_NOPARENTALIGN | CCS_NORESIZE | + TBSTYLE_FLAT | TBSTYLE_TRANSPARENT | TBSTYLE_WRAPABLE | TBSTYLE_CUSTOMERASE | TBSTYLE_TOOLTIPS, + 12, 10, 84, 272, GetHandle(), (HMENU)IDC_TLB_BOOKMARKS, NULL, NULL); + if (ctrlWnd) + { + ::SendMessage(ctrlWnd, TB_BUTTONSTRUCTSIZE, (WPARAM)sizeof(TBBUTTON), 0L); + ::SendMessage(ctrlWnd, TB_SETBUTTONSIZE, (WPARAM)0, MAKELPARAM(84, 50)); + ::SendMessage(ctrlWnd, TB_SETBITMAPSIZE, (WPARAM)0, MAKELPARAM(32, 32)); + ::SendMessage(ctrlWnd, TB_SETPADDING, (WPARAM)0, MAKELPARAM(8, 8)); + ::SendMessage(ctrlWnd, TB_SETBUTTONWIDTH, (WPARAM)0, MAKELPARAM(84, 84)); + ::SendMessage(ctrlWnd, TB_SETEXTENDEDSTYLE, (WPARAM)0, 0x0000080 /*TBSTYLE_EX_DOUBLEBUFFER*/); + ::SendMessage(ctrlWnd, TB_SETMAXTEXTROWS, (WPARAM)2, 0L); + ::SendMessage(ctrlWnd, TB_SETIMAGELIST, (WPARAM)0, (LPARAM)hSysImageList); + + LPTBBUTTON ptbb = (LPTBBUTTON)calloc(buttonsCount, sizeof(TBBUTTON)); + for (int i = 0; i < buttonsCount; i++) + { + ptbb[i].fsState = TBSTATE_ENABLED | TBSTATE_WRAP; + ptbb[i].idCommand = TOOLBAR_BTN_STARTID + i; + ptbb[i].fsStyle = TBSTYLE_CHECKGROUP; + ptbb[i].iString = (INT_PTR)buttons[i].caption; + ptbb[i].iBitmap = (INT_PTR) buttons[i].iImage; + } + ::SendMessage(ctrlWnd, TB_ADDBUTTONSW, (WPARAM)buttonsCount,(LPARAM)ptbb); + } + + ctrlWnd = CreateWindowExW(WS_EX_NOPARENTNOTIFY, L"BUTTON", + WASABI_API_LNGSTRINGW(IDS_SCAN_FOLDER_IN_BACKGROUND), + BS_AUTOCHECKBOX | WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_TABSTOP, + 0, 0, 100, 16, GetHandle(), (HMENU)IDC_CHK_BGSCAN, NULL, NULL); + if (ctrlWnd) + { + ::SendMessage(ctrlWnd, WM_SETFONT, (WPARAM)SendMessage(WM_GETFONT, 0, 0), FALSE); + ::SendMessage(ctrlWnd, BM_SETCHECK, (WPARAM) (bkScanChecked) ? BST_CHECKED : BST_UNCHECKED, 0L); + } + + hbBorder = GetBorderBrush(GetHandle()); + RepositionWindows(); + + ShowWindow(GetDlgItem(IDC_TLB_BOOKMARKS), SW_SHOWNORMAL); + if (bkScanShow) ShowWindow(GetDlgItem(IDC_CHK_BGSCAN), SW_SHOWNORMAL); + + // edit box autocomplete chnages + if(pac) pac->Init(GetDlgItem(IDC_EDT_PATH), pacl2, NULL, NULL); + + FolderBrowseEx::OnInitialized(); +} + +void ScanFolderBrowser::OnSelectionChanged(LPCITEMIDLIST pidl) +{ + for(int i =0; i < buttonsCount; i++) + { + ::SendMessage(GetDlgItem(IDC_TLB_BOOKMARKS), TB_CHECKBUTTON, (WPARAM)TOOLBAR_BTN_STARTID + i, ILIsEqual(pidl, buttons[i].pidl)); + } + + FolderBrowseEx::OnSelectionChanged(pidl); +} + +BOOL ScanFolderBrowser::OnValidateFailed(LPCWSTR lpName) +{ + wchar_t buffer[2048] = {0}, titleStr[64] = {0}; + FolderBrowseEx::OnValidateFailed(lpName); + wsprintfW(buffer, WASABI_API_LNGSTRINGW(IDS_FOLDER_NAME_IS_INCORRECT), lpName); + MessageBoxW(GetHandle(), buffer, WASABI_API_LNGSTRINGW_BUF(IDS_INCORRECT_FOLDER_NAME,titleStr,64), MB_OK | MB_ICONERROR | MB_SETFOREGROUND); + return TRUE; +} + +void ScanFolderBrowser::OnSelectionDone(LPCITEMIDLIST pidl) +{ + WCHAR pszPath[MAX_PATH] = {0}; + SHGetPathFromIDListW(pidl, pszPath); + WASABI_API_APP->path_setWorkingPath(pszPath); +} + +void ScanFolderBrowser::ShiftWindows(int cx) +{ + HWND hwnd = GetWindow(GetHandle(), GW_CHILD); + while(hwnd) + { + RECT rw; + UINT ctrlID = GetDlgCtrlID(hwnd); + if (ctrlID != IDOK && ctrlID != IDCANCEL && ctrlID != IDC_SB_GRIPPER) + { + GetWindowRect(hwnd, &rw); + MapWindowPoints(HWND_DESKTOP, GetHandle(), (LPPOINT)&rw, 2); + SetWindowPos(hwnd, NULL, rw.left + cx, rw.top, (rw.right - (rw.left + cx)), rw.bottom - rw.top, SWP_NOACTIVATE | SWP_NOZORDER | ((ctrlID == IDC_LBL_FOLDER) ? SWP_NOSIZE : 0)); + } + hwnd = GetWindow(hwnd, GW_HWNDNEXT); + } +} + +void ScanFolderBrowser::ShrinkWindows(int cx) +{ + HWND hwnd = GetWindow(GetHandle(), GW_CHILD); + while(hwnd) + { + UINT ctrlID = GetDlgCtrlID(hwnd); + if (ctrlID != IDC_LBL_FOLDER) + { + RECT rw; + GetWindowRect(hwnd, &rw); + MapWindowPoints(HWND_DESKTOP, GetHandle(), (LPPOINT)&rw, 2); + SetWindowPos(hwnd, NULL, + rw.left + cx, rw.top, (rw.right - rw.left) + cx, rw.bottom - rw.top, + SWP_NOACTIVATE | SWP_NOZORDER | ((ctrlID == IDOK || ctrlID == IDCANCEL) ? SWP_NOSIZE : SWP_NOMOVE)); + } + hwnd = GetWindow(hwnd, GW_HWNDNEXT); + } +} + +void ScanFolderBrowser::RepositionWindows(void) +{ + RECT rwBtn, rwLV, rwCtrl; + HWND pwnd, ctrlWnd; + + GetWindowRect(GetDlgItem(IDOK), &rwBtn); + pwnd = FindWindowExW(GetHandle(), NULL,L"SHBrowseForFolder ShellNameSpace Control",NULL); + + GetWindowRect((pwnd) ? pwnd : GetDlgItem(IDC_TV_FOLDERS), &rwLV); + ctrlWnd = GetDlgItem(IDC_CHK_BGSCAN); + GetWindowRect(ctrlWnd, &rwCtrl); + SetRect(&rwCtrl, rwLV.left, rwBtn.bottom - (rwCtrl.bottom - rwCtrl.top), rwBtn.left - 4 - rwLV.left, rwCtrl.bottom - rwCtrl.top); + MapWindowPoints(HWND_DESKTOP, GetHandle(), (LPPOINT)&rwCtrl, 1); + SetWindowPos(ctrlWnd, NULL, rwCtrl.left, rwCtrl.top, rwCtrl.right, rwCtrl.bottom, SWP_NOACTIVATE | SWP_NOZORDER); + + ctrlWnd = GetDlgItem(IDC_TLB_BOOKMARKS); + GetWindowRect(ctrlWnd, &rwCtrl); + GetWindowRect(GetDlgItem(IDC_LBL_CAPTION), &rwLV); + SetWindowPos(ctrlWnd, NULL, 0, 0, rwCtrl.right - rwCtrl.left, rwBtn.bottom - rwLV.top, SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOMOVE); +} + +void ScanFolderBrowser::OnSize(UINT nType, int cx, int cy) +{ + FolderBrowseEx::DialogProc(WM_SIZE, nType, MAKELPARAM(cx, cy)); + + RepositionWindows(); +} + +void ScanFolderBrowser::OnWindowPosChanging(WINDOWPOS *lpwp) +{ + if (lpwp->cx < 346 + 88) lpwp->cx = 346 + 88; +} + +BOOL ScanFolderBrowser::OnNotify(UINT idCtrl, LPNMHDR pnmh, LRESULT *result) +{ + switch(pnmh->code) + { + case NM_CUSTOMDRAW: + switch(pnmh->idFrom) + { + case IDC_TLB_BOOKMARKS: + *result = OnToolBarCustomDraw((LPNMTBCUSTOMDRAW)pnmh); + return TRUE; + } + break; + case TTN_GETDISPINFOW: + OnToolTipGetDispInfo((LPNMTTDISPINFOW)pnmh); + break; + } + return FALSE; +} + +BOOL ScanFolderBrowser::OnCommand(UINT idCtrl, UINT idEvnt, HWND hwndCtrl) +{ + int tbid; + tbid = idCtrl - TOOLBAR_BTN_STARTID; + if (tbid >= 0 && tbid < buttonsCount) + { + LPITEMIDLIST pidl1 = buttons[tbid].pidl; + SetExpanded(pidl1); + SetSelection(pidl1); + + wchar_t test_path[MAX_PATH] = {0}; + EnableOK(SHGetPathFromIDListW(pidl1, test_path)); + return TRUE; + } + return FALSE; +} + +LRESULT ScanFolderBrowser::OnToolBarCustomDraw(LPNMTBCUSTOMDRAW pnmcd) +{ + switch(pnmcd->nmcd.dwDrawStage) + { + case CDDS_PREPAINT: + FrameRect(pnmcd->nmcd.hdc, &pnmcd->nmcd.rc, hbBorder); + InflateRect(&pnmcd->nmcd.rc, -1, -1); + IntersectClipRect(pnmcd->nmcd.hdc, pnmcd->nmcd.rc.left, pnmcd->nmcd.rc.top, pnmcd->nmcd.rc.right, pnmcd->nmcd.rc.bottom); + return CDRF_NOTIFYITEMDRAW; + case CDDS_ITEMPREPAINT: + InflateRect(&pnmcd->nmcd.rc, -1, 0); + if (0 == pnmcd->nmcd.rc.top) pnmcd->nmcd.rc.top++; + return CDRF_DODEFAULT; + } + return CDRF_DODEFAULT; +} + +void ScanFolderBrowser::OnToolTipGetDispInfo(LPNMTTDISPINFOW lpnmtdi) +{ + int tbid; + tbid = lpnmtdi->hdr.idFrom - TOOLBAR_BTN_STARTID; + lpnmtdi->lpszText = (tbid >= 0 && tbid < buttonsCount) ? buttons[tbid].tooltip : L""; +} + +INT_PTR ScanFolderBrowser::DialogProc(UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + LRESULT result; + switch(uMsg) + { + case WM_WINDOWPOSCHANGING: OnWindowPosChanging((WINDOWPOS*)lParam); + case WM_SIZE: OnSize(wParam, LOWORD(lParam), HIWORD(lParam)); return 0; + case WM_NOTIFY: + if (OnNotify(wParam, (LPNMHDR)lParam, &result)) + { + SetDialogResult(result); + return TRUE; + } + break; + case WM_COMMAND: + if (OnCommand(LOWORD(wParam), HIWORD(wParam), (HWND)lParam)) return 0; + break; + case WM_DESTROY: + if (hbBorder) DeleteObject(hbBorder); + hbBorder = NULL; + bkScanChecked = (BST_CHECKED == IsDlgButtonChecked(GetHandle(), IDC_CHK_BGSCAN)); + break; + } + return FolderBrowseEx::DialogProc(uMsg, wParam, lParam); +} + +static BOOL LoadXPTheme(void) +{ + xpThemeDll = LoadLibraryW(L"UxTheme.dll"); + if (!xpThemeDll) return FALSE; + + xpCloseThemeData = (XPT_CLOSETHEMEDATA) GetProcAddress(xpThemeDll, "CloseThemeData"); + xpIsAppThemed = (XPT_ISAPPTHEMED) GetProcAddress(xpThemeDll, "IsAppThemed"); + xpOpenThemeData = (XPT_OPENTHEMEDATA) GetProcAddress(xpThemeDll, "OpenThemeData"); + xpGetThemeColor = (XPT_GETTHEMECOLOR) GetProcAddress(xpThemeDll, "GetThemeColor"); + + if (!xpCloseThemeData || !xpIsAppThemed || !xpOpenThemeData || !xpGetThemeColor) UnloadXPTheme(); + return (NULL != xpThemeDll); +} + +static void UnloadXPTheme(void) +{ + xpCloseThemeData = NULL; + xpIsAppThemed = NULL; + xpOpenThemeData = NULL; + xpGetThemeColor = NULL; + if (xpThemeDll) + { + FreeLibrary(xpThemeDll); + xpThemeDll = NULL; + } +} + +static HBRUSH GetBorderBrush(HWND hwnd) +{ + HBRUSH hb; + COLORREF clr; + HRESULT result; + + clr = 0x00000; + result = S_FALSE; + if(LoadXPTheme()) + { + if(xpIsAppThemed()) + { + HTHEME ht; + ht = xpOpenThemeData(GetDlgItem(hwnd, IDC_EDT_PATH), L"Edit"); + if (ht) + { + result = xpGetThemeColor(ht, GP_BORDER, BSS_FLAT, TMT_BORDERCOLOR, &clr); + xpCloseThemeData(ht); + } + } + UnloadXPTheme(); + } + + hb = CreateSolidBrush((S_OK == result) ? clr : GetSysColor(COLOR_WINDOWFRAME)); + + return hb; +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/ScanFolderBrowser.h b/Src/Plugins/Library/ml_local/ScanFolderBrowser.h new file mode 100644 index 00000000..0849779b --- /dev/null +++ b/Src/Plugins/Library/ml_local/ScanFolderBrowser.h @@ -0,0 +1,53 @@ +#ifndef NULLSOFT_FOLDERBROWSE_SCANFILES_DIALOG_HEADER +#define NULLSOFT_FOLDERBROWSE_SCANFILES_DIALOG_HEADER + +#include "./folderbrowseex.h" + +typedef struct _FBUTTON FBUTTON; +class ScanFolderBrowser : public FolderBrowseEx +{ +public: + ScanFolderBrowser(void); + ScanFolderBrowser(BOOL showBckScanOption); + virtual ~ScanFolderBrowser(void); + + void ShowBckScanOption(BOOL show) { bkScanShow = show; } + void SetBckScanChecked(BOOL checked) { bkScanChecked = checked; } + BOOL GetBckScanChecked(void) { return bkScanChecked; } +protected: + virtual void OnInitialized(void); + virtual void OnSelectionChanged(LPCITEMIDLIST pidl); + virtual BOOL OnValidateFailed(LPCWSTR lpName); + virtual void OnSelectionDone(LPCITEMIDLIST pidl); + virtual INT_PTR DialogProc(UINT uMsg, WPARAM wParam, LPARAM lParam); + + void OnWindowPosChanging(WINDOWPOS *lpwp); + void OnSize(UINT nType, int cx, int cy); + BOOL OnNotify(UINT idCtrl, LPNMHDR pnmh, LRESULT *result); + BOOL OnCommand(UINT idCtrl, UINT idEvnt, HWND hwndCtrl); + LRESULT OnToolBarCustomDraw(LPNMTBCUSTOMDRAW pnmcd); + void OnToolTipGetDispInfo(LPNMTTDISPINFOW lpnmtdi); + +private: + void LoadBookmarks(void); + void FreeBookmarks(void); + void ShiftWindows(int cx); + void ShrinkWindows(int cx); + void RepositionWindows(void); + +private: + FBUTTON *buttons; + int buttonsCount; + HBRUSH hbBorder; + BOOL bkScanChecked; + BOOL bkScanShow; + + IAutoComplete *pac; + IACList2 *pacl2; + + wchar_t selectionPath[MAX_PATH]; // this is here only because i'm lazy + + friend static void Initialize(ScanFolderBrowser *browser, BOOL showBckScan, BOOL checkBckScan); +}; + +#endif //NULLSOFT_FOLDERBROWSE_SCANFILES_DIALOG_HEADER
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/SimpleFilter.cpp b/Src/Plugins/Library/ml_local/SimpleFilter.cpp new file mode 100644 index 00000000..64dd1819 --- /dev/null +++ b/Src/Plugins/Library/ml_local/SimpleFilter.cpp @@ -0,0 +1,278 @@ +#include "main.h" +#include "SimpleFilter.h" +#include "../nu/sort.h" +#include "resource.h" +#include <shlwapi.h> +#include <strsafe.h> +static size_t m_sort_by, m_sort_dir, m_sort_which; + +void emptyQueryListObject(queryListObject *obj); +int reallocQueryListObject(queryListObject *obj); +void freeQueryListObject(queryListObject *obj); + + +int SimpleFilter::SimpleSortFunc(const void *elem1, const void *elem2) +{ + queryListItem *a=(queryListItem*)elem1; + queryListItem *b=(queryListItem*)elem2; + int use_by=m_sort_by; + int use_dir=m_sort_dir; +#define RETIFNZ(v) if ((v)<0) return use_dir?1:-1; if ((v)>0) return use_dir?-1:1; + if (use_by == 0) + { + int v=WCSCMP_NULLOK(a->name,b->name); + RETIFNZ(v) + v=b->ifields[0]-a->ifields[0]; + RETIFNZ(v) + v=b->ifields[1]-a->ifields[1]; + return v; + } + if (use_by == 1) + { + int v=a->ifields[0]-b->ifields[0]; + RETIFNZ(v) + + if (m_sort_which == 0) + { + v=b->ifields[1]-a->ifields[1]; + RETIFNZ(v) + } + + return WCSCMP_NULLOK(a->name,b->name); + } + if (use_by == 2) + { + int v=a->ifields[1]-b->ifields[1]; + RETIFNZ(v) + if (m_sort_which == 0) + { + v=b->ifields[0]-a->ifields[0]; + RETIFNZ(v) + } + return WCSCMP_NULLOK(a->name,b->name); + } + + if (use_by == 5) + { + __int64 v = a->size - b->size; + RETIFNZ(v) + return WCSCMP_NULLOK(a->name, b->name); + } + + if (use_by == 6) + { + int v = a->length - b->length; + RETIFNZ(v) + return WCSCMP_NULLOK(a->name, b->name); + } + +#undef RETIFNZ + return 0; +} +void SimpleFilter::SortResults(C_Config *viewconf, int which, int isfirst) // sorts the results based on the current sort mode +{ + if (viewconf) + { + wchar_t buf[64] = {0}; + StringCchPrintfW(buf, ARRAYSIZE(buf), L"%hs_sort_by_%d", GetConfigId(), which); + m_sort_by = viewconf->ReadInt(buf, 0); + StringCchPrintfW(buf, ARRAYSIZE(buf), L"%hs_sort_dir_%d", GetConfigId(), which); + m_sort_dir = viewconf->ReadInt(buf, 0); + m_sort_which = which; + + if (showncolumns.size()>m_sort_by && m_sort_by>=0) m_sort_by = showncolumns[m_sort_by]->field; + + if (m_sort_dir == 0 && m_sort_by == 0 && isfirst) return; + + if (artistList.Size > 2) qsort(artistList.Items+1,artistList.Size-1,sizeof(queryListItem),SimpleSortFunc); + } +} + +void SimpleFilter::Fill(itemRecordW *items, int numitems, int *killswitch, int numitems2) +{ + if (numitems > 1) + qsort_itemRecord(items,numitems, this, BuildSortFunc); + + if (killswitch && *killswitch) return; + + emptyQueryListObject(&artistList); + reallocQueryListObject(&artistList); + ZeroMemory(&artistList.Items[0],sizeof(queryListItem)); + + wchar_t *lastname=0; + const wchar_t *lastalb=0; + wchar_t albbuf[100] = {0}, albbuf2[100] = {0}, albbuf3[100] = {0}; + + itemRecordW *p=items; + int n=numitems; + + int isbl=0; + numGroups = 0; + bool do_wcsdup = !this->uses_nde_strings(); + while (n--) + { + if (killswitch && *killswitch) return; + const wchar_t *name = this->GroupText(p,albbuf3,100); + if (!lastname || WCSCMP_NULLOK(lastname, name)) + { + artistList.Size++; + if (reallocQueryListObject(&artistList)) break; + ZeroMemory(&artistList.Items[artistList.Size],sizeof(queryListItem)); + lastalb=0; + if (name == albbuf3) + lastname = artistList.Items[artistList.Size].name = ndestring_wcsdup(name); + else if (name) + { + if (do_wcsdup) + { + lastname = artistList.Items[artistList.Size].name = ndestring_wcsdup(name); + } + else + { + wchar_t *ndename = (wchar_t *)name; + ndestring_retain(ndename); + lastname = artistList.Items[artistList.Size].name = ndename; + } + } + else + { + lastname = artistList.Items[artistList.Size].name = emptyQueryListString; + } + + SKIP_THE_AND_WHITESPACEW(lastname) // optimization technique + if (*lastname) numGroups++; + } + if (!name || !*name) isbl++; + if (artistList.Size) + { + artistList.Items[artistList.Size].ifields[1]++; + if (p->length>0) artistList.Items[artistList.Size].length += p->length; + if (p->filesize>0) artistList.Items[artistList.Size].size += p->filesize; + } + if (nextFilter && (!lastalb || WCSCMP_NULLOK(lastalb,nextFilter->GroupText(p,albbuf2,100)))) + { + lastalb = nextFilter->GroupText(p,albbuf,100); + if (lastalb && *lastalb) artistList.Items[artistList.Size].ifields[0]++; + if (lastalb) SKIP_THE_AND_WHITESPACEW(lastalb) // optimization technique + } + p++; + } + + if (killswitch && *killswitch) return; + + wchar_t langbuf[2048] = {0}, buf[64] = {0}; + if (isbl) + { + StringCchPrintfW(buf,64,WASABI_API_LNGSTRINGW_BUF(IDS_ALL_X_S, langbuf, 2048),artistList.Size-1,artistList.Size==2?GetNameSingular():GetName()); + } + else + { + StringCchPrintfW(buf,64,WASABI_API_LNGSTRINGW_BUF(IDS_ALL_X_S, langbuf, 2048),artistList.Size,artistList.Size==1?GetNameSingular():GetName()); + } + + // for some languages a lowercased first word is invalid so need to prevent this from happening + process_substantives(buf); + + artistList.Items[0].name=ndestring_wcsdup(buf); + artistList.Items[0].ifields[0]=numitems2; + artistList.Items[0].ifields[1]=numitems; + artistList.Size++; +} + +int SimpleFilter::Size() +{ + return artistList.Size; +} + +const wchar_t *SimpleFilter::GetText(int row) // gets main text (first column) +{ + return artistList.Items[row].name; +} + +void SimpleFilter::Empty() +{ + freeQueryListObject(&artistList); +} + +void SimpleFilter::CopyText(int row, size_t column, wchar_t *dest, int destCch) +{ + if (column >= showncolumns.size()) return; + column = showncolumns[column]->field; + if (row>=artistList.Size) + return ; + switch (column) + { + case 0: // artist name + if (artistList.Items[row].name && *artistList.Items[row].name) + lstrcpynW(dest,artistList.Items[row].name,destCch); + else + { + StringCchPrintfW(dest, destCch, WASABI_API_LNGSTRINGW(IDS_NO_S), GetNameSingular()); + // for some languages a lowercased first word is invalid so need to prevent this from happening + process_substantives(dest); + } + break; + case 1: // albums + StringCchPrintfW(dest,destCch,L"%d",artistList.Items[row].ifields[0]); + break; + case 2: // tracks + StringCchPrintfW(dest,destCch,L"%d",artistList.Items[row].ifields[1]); + break; + case 5: + if (row && artistList.Items[row].size) + WASABI_API_LNG->FormattedSizeString(dest, destCch, artistList.Items[row].size); + else dest[0]=0; + break; + case 6: + if (row && artistList.Items[row].length) + StringCchPrintfW(dest,destCch,L"%d:%02d", artistList.Items[row].length / 60, artistList.Items[row].length % 60); + else dest[0]=0; + break; + } +} + +const wchar_t * SimpleFilter::CopyText2(int row, size_t column, wchar_t *dest, int destCch) +{ + if (column >= showncolumns.size()) return NULL; + column = showncolumns[column]->field; + if (row>=artistList.Size) + return NULL; + switch (column) + { + case 0: // artist name + if (artistList.Items[row].name && *artistList.Items[row].name) + dest = artistList.Items[row].name; + else + { + StringCchPrintfW(dest, destCch, WASABI_API_LNGSTRINGW(IDS_NO_S), GetNameSingular()); + // for some languages a lowercased first word is invalid so need to prevent this from happening + process_substantives(dest); + } + break; + case 1: // albums + StringCchPrintfW(dest,destCch,L"%d",artistList.Items[row].ifields[0]); + break; + case 2: // tracks + StringCchPrintfW(dest,destCch,L"%d",artistList.Items[row].ifields[1]); + break; + case 5: + if (row && artistList.Items[row].size) + WASABI_API_LNG->FormattedSizeString(dest, destCch, artistList.Items[row].size); + else dest[0]=0; + break; + case 6: + if (row && artistList.Items[row].length) + StringCchPrintfW(dest,destCch,L"%d:%02d", artistList.Items[row].length / 60, artistList.Items[row].length % 60); + else dest[0]=0; + break; + } + return dest; +} +void SimpleFilter::AddColumns2() +{ + showncolumns.push_back(new ListField(0,155,GetNameSingular(),g_view_metaconf,GetConfigId())); + if (nextFilter) showncolumns.push_back(new ListField(1,48,nextFilter->GetName(),g_view_metaconf,GetConfigId())); + showncolumns.push_back(new ListField(2,45,IDS_TRACKS,g_view_metaconf,GetConfigId())); + showncolumns.push_back(new ListField(5,45,IDS_SIZE,g_view_metaconf,GetConfigId(),true,true)); + showncolumns.push_back(new ListField(6,45,IDS_LENGTH,g_view_metaconf,GetConfigId(),true,true)); +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/SimpleFilter.h b/Src/Plugins/Library/ml_local/SimpleFilter.h new file mode 100644 index 00000000..aaad01a9 --- /dev/null +++ b/Src/Plugins/Library/ml_local/SimpleFilter.h @@ -0,0 +1,169 @@ +#ifndef NULLSOFT_ML_LOCAL_SIMPLEFILTER_H +#define NULLSOFT_ML_LOCAL_SIMPLEFILTER_H + +#include "ViewFilter.h" +#include "resource.h" + +class SimpleFilter : public ViewFilter +{ +public: + static int SimpleSortFunc(const void *elem1, const void *elem2); + void SortResults(C_Config *viewconf, int which=0, int isfirst=0); + void Fill(itemRecordW *items, int numitems, int *killswitch, int numitems2); + int Size(); + const wchar_t *GetText(int row); + void CopyText(int row, size_t column, wchar_t *dest, int destCch); + virtual const wchar_t *CopyText2(int row, size_t column, wchar_t *dest, int destCch); + void Empty(); + void AddColumns2(); + // override these 4 to make a simple filter + virtual const wchar_t *GetField()=0; + virtual const wchar_t *GetName()=0; + virtual const wchar_t *GetNameSingular()=0; + virtual const wchar_t *GetNameSingularAlt(int mode)=0; + virtual const wchar_t *GroupText(itemRecordW * item, wchar_t * buf, int len)=0; + wchar_t name[64]; + wchar_t sname[64]; + wchar_t saname[64]; + virtual bool uses_nde_strings() { return true; } +private: + queryListObject artistList; +}; + +class AlbumArtistFilter : public SimpleFilter +{ + const wchar_t *GetField(){return DB_FIELDNAME_albumartist;} + const wchar_t *GetName(){return WASABI_API_LNGSTRINGW_BUF(IDS_ALBUM_ARTISTS,name,64);} + const wchar_t *GetNameSingular(){return WASABI_API_LNGSTRINGW_BUF(IDS_ALBUM_ARTIST,sname,64);} + const wchar_t *GetNameSingularAlt(int mode){return WASABI_API_LNGSTRINGW_BUF((!mode?IDS_ALBUM_ARTIST_ALT:(mode==1?2065:2081)),saname,64);} + const wchar_t *GroupText(itemRecordW * item, wchar_t * buf, int len){return item->albumartist;} + char * GetConfigId(){return "av_aa";} +}; + +class ArtistFilter : public SimpleFilter +{ + const wchar_t *GetField(){return DB_FIELDNAME_artist;} + const wchar_t *GetName(){return WASABI_API_LNGSTRINGW_BUF(IDS_ARTIST_S,name,64);} + const wchar_t *GetNameSingular(){return WASABI_API_LNGSTRINGW_BUF(IDS_ARTIST,sname,64);} + const wchar_t *GetNameSingularAlt(int mode){return WASABI_API_LNGSTRINGW_BUF((!mode?IDS_ARTIST_ALT:(mode==1?2066:2082)),saname,64);} + const wchar_t *GroupText(itemRecordW * item, wchar_t * buf, int len){return item->artist;} + char * GetConfigId(){return "av_ar";} +}; + +class ComposerFilter : public SimpleFilter +{ + const wchar_t *GetField(){return DB_FIELDNAME_composer;} + const wchar_t *GetName(){return WASABI_API_LNGSTRINGW_BUF(IDS_COMPOSERS,name,64);} + const wchar_t *GetNameSingular(){return WASABI_API_LNGSTRINGW_BUF(IDS_COMPOSER,sname,64);} + const wchar_t *GetNameSingularAlt(int mode){return WASABI_API_LNGSTRINGW_BUF((!mode?IDS_COMPOSER_ALT:(mode==1?2067:2083)),saname,64);} + const wchar_t *GroupText(itemRecordW * item, wchar_t * buf, int len){return item->composer;} + char * GetConfigId(){return "av_c";} +}; + +class GenreFilter : public SimpleFilter +{ + const wchar_t *GetField(){return DB_FIELDNAME_genre;} + const wchar_t *GetName(){return WASABI_API_LNGSTRINGW_BUF(IDS_GENRES,name,64);} + const wchar_t *GetNameSingular(){return WASABI_API_LNGSTRINGW_BUF(IDS_GENRE,sname,64);} + const wchar_t *GetNameSingularAlt(int mode){return WASABI_API_LNGSTRINGW_BUF((!mode?IDS_GENRE_ALT:(mode==1?2068:2084)),saname,64);} + const wchar_t * GroupText(itemRecordW * item, wchar_t * buf, int len){return item->genre;} + char * GetConfigId(){return "av_g";} +}; + +class PublisherFilter : public SimpleFilter +{ + const wchar_t *GetField(){return DB_FIELDNAME_publisher;} + const wchar_t *GetName(){return WASABI_API_LNGSTRINGW_BUF(IDS_PUBLISHERS,name,64);} + const wchar_t *GetNameSingular(){return WASABI_API_LNGSTRINGW_BUF(IDS_PUBLISHER,sname,64);} + const wchar_t *GetNameSingularAlt(int mode){return WASABI_API_LNGSTRINGW_BUF((!mode?IDS_PUBLISHER_ALT:(mode==1?2069:2085)),saname,64);} + const wchar_t *GroupText(itemRecordW * item, wchar_t * buf, int len){return item->publisher;} + char * GetConfigId(){return "av_p";} +}; + +class YearFilter : public SimpleFilter +{ + const wchar_t *GetComparisonOperator() {return L"==";} + const wchar_t *GetField(){return DB_FIELDNAME_year;} + const wchar_t *GetName(){return WASABI_API_LNGSTRINGW_BUF(IDS_YEARS,name,64);} + const wchar_t *GetNameSingular(){return WASABI_API_LNGSTRINGW_BUF(IDS_YEAR,sname,64);} + const wchar_t *GetNameSingularAlt(int mode){return WASABI_API_LNGSTRINGW_BUF((!mode?IDS_YEAR_ALT:(mode==1?2070:2086)),saname,64);} + const wchar_t *GroupText(itemRecordW * item, wchar_t * buf, int len){if(item->year>0) wsprintfW(buf,L"%d",item->year); else buf[0]=0; return buf;} + char * GetConfigId(){return "av_y";} + virtual bool uses_nde_strings() { return false; } +}; + +static wchar_t getIndex(const wchar_t* str) { + if(!str) return 0; + SKIP_THE_AND_WHITESPACEW(str); + return towupper(*str); +} + +class AlbumArtistIndexFilter : public SimpleFilter +{ + const wchar_t *GetComparisonOperator() {return L"BEGINSLIKE";} + const wchar_t *GetField(){return DB_FIELDNAME_albumartist;} + const wchar_t *GetName(){return WASABI_API_LNGSTRINGW_BUF(IDS_ALBUM_ARTIST_INDEXES,name,64);} + const wchar_t *GetNameSingular(){return WASABI_API_LNGSTRINGW_BUF(IDS_ALBUM_ARTIST_INDEX,sname,64);} + const wchar_t *GetNameSingularAlt(int mode){return WASABI_API_LNGSTRINGW_BUF((!mode?IDS_ALBUM_ARTIST_INDEX_ALT:(mode==1?2071:2087)),saname,64);} + const wchar_t *GroupText(itemRecordW * item, wchar_t * buf, int len) {buf[0]=getIndex(item->albumartist); buf[1]=0; return buf;} + char * GetConfigId(){return "av_aai";} + virtual bool uses_nde_strings() { return false; } +}; + +class ArtistIndexFilter : public SimpleFilter +{ + const wchar_t *GetComparisonOperator() {return L"BEGINSLIKE";} + const wchar_t *GetField(){return DB_FIELDNAME_artist;} + const wchar_t *GetName(){return WASABI_API_LNGSTRINGW_BUF(IDS_ARTIST_INDEXES,name,64);} + const wchar_t *GetNameSingular(){return WASABI_API_LNGSTRINGW_BUF(IDS_ARTIST_INDEX,sname,64);} + const wchar_t *GetNameSingularAlt(int mode){return WASABI_API_LNGSTRINGW_BUF((!mode?IDS_ARTIST_INDEX_ALT:(mode==1?2072:2088)),saname,64);} + const wchar_t *GroupText(itemRecordW * item, wchar_t * buf, int len) {buf[0]=getIndex(item->artist); buf[1]=0; return buf;} + char * GetConfigId(){return "av_ai";} + virtual bool uses_nde_strings() { return false; } +}; + +class PodcastChannelFilter : public SimpleFilter +{ + const wchar_t *GetField(){return DB_FIELDNAME_podcastchannel;} + const wchar_t *GetName(){return WASABI_API_LNGSTRINGW_BUF(IDS_PODCAST_CHANNELS,name,64);} + const wchar_t *GetNameSingular(){return WASABI_API_LNGSTRINGW_BUF(IDS_PODCAST_CHANNEL,sname,64);} + const wchar_t *GetNameSingularAlt(int mode){return WASABI_API_LNGSTRINGW_BUF((!mode?IDS_PODCAST_CHANNEL_ALT:(mode==1?2073:2089)),saname,64);} + const wchar_t *GroupText(itemRecordW * item, wchar_t * buf, int len){return getRecordExtendedItem_fast(item,extended_fields.podcastchannel);} + char * GetConfigId(){return "av_pc";} + virtual bool uses_nde_strings() { return false; } +}; + +class CategoryFilter : public SimpleFilter +{ + const wchar_t *GetField(){return L"category";} + const wchar_t *GetName(){return WASABI_API_LNGSTRINGW_BUF(IDS_CATEGORIES,name,64);} + const wchar_t *GetNameSingular(){return WASABI_API_LNGSTRINGW_BUF(IDS_CATEGORY,sname,64);} + const wchar_t *GetNameSingularAlt(int mode){return WASABI_API_LNGSTRINGW_BUF((!mode?IDS_CATEGORY_ALT:(mode==1?2074:2090)),saname,64);} + const wchar_t *GroupText(itemRecordW * item, wchar_t * buf, int len){return item->category;} + char * GetConfigId(){return "av_cat";} + virtual bool uses_nde_strings() { return false; } +}; + +class DirectorFilter : public SimpleFilter +{ + const wchar_t *GetField(){return DB_FIELDNAME_director;} + const wchar_t *GetName(){return WASABI_API_LNGSTRINGW_BUF(IDS_DIRECTOR,name,64);} + const wchar_t *GetNameSingular(){return WASABI_API_LNGSTRINGW_BUF(IDS_DIRECTOR,sname,64);} + const wchar_t *GetNameSingularAlt(int mode){return WASABI_API_LNGSTRINGW_BUF((!mode?IDS_DIRECTOR_ALT:(mode==1?2075:2091)),saname,64);} + const wchar_t *GroupText(itemRecordW * item, wchar_t * buf, int len){return getRecordExtendedItem_fast(item,extended_fields.director);} + char * GetConfigId(){return "av_drt";} + virtual bool uses_nde_strings() { return false; } +}; + +class ProducerFilter : public SimpleFilter +{ + const wchar_t *GetField(){return L"producer";} + const wchar_t *GetName(){return WASABI_API_LNGSTRINGW_BUF(IDS_PRODUCER,name,64);} + const wchar_t *GetNameSingular(){return WASABI_API_LNGSTRINGW_BUF(IDS_PRODUCER,sname,64);} + const wchar_t *GetNameSingularAlt(int mode){return WASABI_API_LNGSTRINGW_BUF((!mode?IDS_PRODUCER_ALT:(mode==1?2076:2092)),saname,64);} + const wchar_t *GroupText(itemRecordW * item, wchar_t * buf, int len){return getRecordExtendedItem_fast(item,extended_fields.producer);} + char * GetConfigId(){return "av_pdc";} + virtual bool uses_nde_strings() { return false; } +}; + +#endif
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/TitleInfo.cpp b/Src/Plugins/Library/ml_local/TitleInfo.cpp new file mode 100644 index 00000000..3d52a4c1 --- /dev/null +++ b/Src/Plugins/Library/ml_local/TitleInfo.cpp @@ -0,0 +1,321 @@ +#include "main.h" +#include "../replicant/nu/AutoChar.h" +#include "../replicant/nu/ns_wc.h" +#include <shlwapi.h> +#include <malloc.h> // for alloca + +static wchar_t m_lastfn[2048]; +static wchar_t m_lastartist[256], m_lasttitle[256], m_lastalbum[256], m_gracenotefileid[128]; +static int m_lasttrack; +static int m_playcount; +static int m_ispodcast; +static int m_rating; +static int m_db_found; + +void ClearTitleHookCache() +{ + memset(m_lastfn, 0, sizeof(m_lastfn)); +} + +BOOL IPC_HookExtInfoW(INT_PTR param) +{ + if (skipTitleInfo) // we're reading metadata and being asked to skip title hooking (so we can get a valid title for guessing, if need be) + return false; + + extendedFileInfoStructW *p = (extendedFileInfoStructW *)param; + // fill in our own titles from db? not for now, just let it default to hitting the tags? + + if (!g_config->ReadInt(L"newtitle", 1)) + return FALSE; + + if (NULL == p->filename || L'\0' == *p->filename || + NULL == p->metadata || L'\0' == *p->metadata) + { + return FALSE; + } + + int which = 0; + if (!_wcsicmp(p->metadata, DB_FIELDNAME_artist )) which = 1; + else if (!_wcsicmp(p->metadata, DB_FIELDNAME_title )) which = 2; + else if (!_wcsicmp(p->metadata, DB_FIELDNAME_album )) which = 3; + //else if (!_wcsicmp(p->metadata, L"tuid")) which = 4; + else if (!_wcsicmp(p->metadata, DB_FIELDNAME_track )) which = 5; + else if (!_wcsicmp(p->metadata, DB_FIELDNAME_rating )) which = 6; + else if (!_wcsicmp(p->metadata, DB_FIELDNAME_playcount )) which = 7; + else if (!_wcsicmp(p->metadata, DB_FIELDNAME_GracenoteFileID )) which=8; + else if (!_wcsicmp(p->metadata, DB_FIELDNAME_ispodcast )) which=9; + + if (which) + { + if (_wcsicmp(m_lastfn, p->filename)) + { + if (!g_table) openDb(); + if (!g_table) return 0; + + m_lastartist[0] = 0; + m_lasttitle[0] = 0; + m_lastalbum[0] = 0; + m_gracenotefileid[0]=0; + m_lasttrack = 0; + m_rating=-1; + m_playcount=-1; + m_ispodcast=-1; + lstrcpynW(m_lastfn, p->filename, sizeof(m_lastfn)/sizeof(wchar_t)); + + wchar_t filename2[MAX_PATH] = {0}; // full lfn path if set + + EnterCriticalSection(&g_db_cs); + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + int found = FindFileInDatabase(s, MAINTABLE_ID_FILENAME, m_lastfn, filename2); + + if (found == 2) + lstrcpynW(m_lastfn, filename2, sizeof(m_lastfn)/sizeof(m_lastfn)); + + if (found) + { + nde_field_t f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_ARTIST); + if (f) lstrcpynW(m_lastartist, NDE_StringField_GetString(f), sizeof(m_lastartist)/sizeof(wchar_t)); + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_ALBUM); + if (f) lstrcpynW(m_lastalbum, NDE_StringField_GetString(f), sizeof(m_lastalbum)/sizeof(wchar_t)); + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_TITLE); + if (f) lstrcpynW(m_lasttitle, NDE_StringField_GetString(f), sizeof(m_lasttitle)/sizeof(wchar_t)); + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_TRACKNB); + if (f) m_lasttrack = NDE_IntegerField_GetValue(f); + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_PLAYCOUNT); + if (f) m_playcount = NDE_IntegerField_GetValue(f); + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_RATING); + if (f) m_rating = NDE_IntegerField_GetValue(f); + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_ISPODCAST); + if (f) m_ispodcast = NDE_IntegerField_GetValue(f); + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_GRACENOTEFILEID); + if (f) lstrcpynW(m_gracenotefileid, NDE_StringField_GetString(f), sizeof(m_gracenotefileid)/sizeof(wchar_t)); + m_db_found = 1; + } + else m_db_found = 0; + + NDE_Table_DestroyScanner(g_table, s); + LeaveCriticalSection(&g_db_cs); + } + if (m_db_found == 1) + { + switch(which) + { + case 1: + if (m_lastartist[0]) + { + lstrcpynW(p->ret, m_lastartist, p->retlen); + return 1; + } + break; + case 2: + if (m_lasttitle[0]) + { + lstrcpynW(p->ret, m_lasttitle, p->retlen); + return 1; + } + break; + case 3: + if (m_lastalbum[0]) + { + lstrcpynW(p->ret, m_lastalbum, p->retlen); + return 1; + } + break; + case 5: + if (m_lasttrack && m_lasttrack != -1) + { + _snwprintf(p->ret, p->retlen, L"%d", m_lasttrack); + return 1; + } + break; + case 6: + if (m_rating != -1) + { + _snwprintf(p->ret, p->retlen, L"%d", m_rating); + return 1; + } + break; + case 7: + if (m_playcount != -1) + { + _snwprintf(p->ret, p->retlen, L"%d", m_playcount); + return 1; + } + break; + case 8: + if (m_gracenotefileid[0]) + { + lstrcpynW(p->ret, m_gracenotefileid, p->retlen); + return 1; + } + break; + case 9: + if (m_ispodcast != -1) + { + _snwprintf(p->ret, p->retlen, L"%d", m_ispodcast); + return 1; + } + break; + } + } + } + return FALSE; +} + +BOOL IPC_HookExtInfo(INT_PTR param) +{ + extendedFileInfoStruct *p = (extendedFileInfoStruct*)param; + // fill in our own titles from db? not for now, just let it default to hitting the tags? + if (!g_config->ReadInt(L"newtitle", 1)) + return FALSE; + + if (NULL == p->filename || '\0' == *p->filename || + NULL == p->metadata || '\0' == *p->metadata) + { + return FALSE; + } + + extendedFileInfoStructW pW = {0}; + AutoWide wideFn(p->filename), wideMetadata(p->metadata); + pW.filename = wideFn; + pW.metadata = wideMetadata; + pW.retlen = p->retlen; + pW.ret = (wchar_t *)alloca(pW.retlen * sizeof(wchar_t)); + + if (IPC_HookExtInfoW((INT_PTR)&pW)) + { + WideCharToMultiByteSZ(CP_ACP, 0, pW.ret, -1, p->ret, p->retlen, 0, 0); + return 1; + } + return 0; + +} + +BOOL IPC_HookTitleInfo(INT_PTR param) +{ + if (skipTitleInfo) // we're reading metadata and being asked to skip title hooking (so we can get a valid title for guessing, if need be) + return false; + + waHookTitleStructW *hts = (waHookTitleStructW*)param; + + if (NULL != hts->filename && + !StrStrW(hts->filename, L"://") && + g_config->ReadInt(L"newtitle", 1)) + { + if (!g_table) openDb(); + if (!g_table) return 0; + wchar_t filename2[MAX_PATH] = {0}; // full lfn path if set + EnterCriticalSection(&g_db_cs); + + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + int found=FindFileInDatabase(s, MAINTABLE_ID_FILENAME, hts->filename, filename2); + + if (found) + { + nde_field_t length = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_LENGTH); + int l = -1; + if (length) + l = NDE_IntegerField_GetValue(length); + if (l > 0) + hts->length = l; + else hts->length = -1; + + if (hts->title) + { + TAG_FMT_EXT(hts->filename, fieldTagFunc, ndeTagFuncFree, (void*)s, hts->title, 2048, 1); + } + } + + NDE_Table_DestroyScanner(g_table, s); + LeaveCriticalSection(&g_db_cs); + + if (found) return 1; + } // not http:// + return FALSE; +} + +DWORD doGuessProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam ) +{ + // call the old wndproc, and if it produces empty results or no results, try to guess + extendedFileInfoStruct *p = (extendedFileInfoStruct*)wParam; + + LRESULT ret = CallWindowProc(wa_oldWndProc, hwndDlg, uMsg, wParam, lParam); + if (NULL != p && + (!ret || !p->ret[0]) && + g_config->ReadInt(L"guessmode", 0) != 2) + { + int which = 0; + + if (NULL != p->metadata) + { + if (!_stricmp(p->metadata, "artist")) which = 1; + else if (!_stricmp(p->metadata, "title")) which = 2; + else if (!_stricmp(p->metadata, "album")) which = 3; + else if (!_stricmp(p->metadata, "track")) which = 5; + else which = 0; + } + else + which = 0; + + if (which) + { + static char m_lastfn[2048]; + if (NULL != p->filename && _strnicmp(m_lastfn, p->filename, sizeof(m_lastfn))) + { + m_db_found = 2; + m_lastartist[0] = 0; + m_lasttitle[0] = 0; + m_lastalbum[0] = 0; + m_lasttrack = 0; + StringCbCopyA(m_lastfn, sizeof(m_lastfn), p->filename); + + int tn = 0; + wchar_t *artist = 0, *album = 0, *title = 0; + wchar_t *guessbuf = guessTitles(AutoWide(m_lastfn), &tn, &artist, &album, &title); + + if (guessbuf) + { + if (artist) StringCbCopyW(m_lastartist, sizeof(m_lastartist), artist); + if (album) StringCbCopyW(m_lastalbum, sizeof(m_lastalbum), album); + if (title) StringCbCopyW(m_lasttitle, sizeof(m_lasttitle), title); + m_lasttrack = tn; + free(guessbuf); + } + } + if (m_db_found == 2) + { + if (which == 1 && m_lastartist[0]) + { + WideCharToMultiByteSZ(CP_ACP, 0, m_lastartist, -1, p->ret, p->retlen, 0, 0); + return 1; + } + if (which == 2 && m_lasttitle[0]) + { + WideCharToMultiByteSZ(CP_ACP, 0, m_lasttitle, -1, p->ret, p->retlen, 0, 0); + return 1; + } + if (which == 3 && m_lastalbum[0]) + { + WideCharToMultiByteSZ(CP_ACP, 0, m_lastalbum, -1, p->ret, p->retlen, 0, 0); + return 1; + } + if (which == 5 && m_lasttrack) + { + _snprintf(p->ret, p->retlen, "%d", m_lasttrack); + return 1; + } + if (which == 6 && m_rating != -1) + { + _snprintf(p->ret, p->retlen, "%d", m_rating); + return 1; + } + if (which == 7 && m_playcount != -1) + { + _snprintf(p->ret, p->retlen, "%d", m_playcount); + return 1; + } + } + } + } + return (int)ret; +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/ViewFilter.cpp b/Src/Plugins/Library/ml_local/ViewFilter.cpp new file mode 100644 index 00000000..4a0def1d --- /dev/null +++ b/Src/Plugins/Library/ml_local/ViewFilter.cpp @@ -0,0 +1,431 @@ +#include "main.h" +#include "ViewFilter.h" +#include "resource.h" +#include "AlbumArtContainer.h" +#include "..\..\General\gen_ml/ml_ipc_0313.h" +#include <algorithm> + +wchar_t *emptyQueryListString = L""; +void emptyQueryListObject(queryListObject *obj) +{ + queryListItem *p = obj->Items; + while (obj->Size-- > 0) + { + if (p->name && p->name != emptyQueryListString) + ndestring_release(p->name); + ndestring_release(p->albumGain); + ndestring_release(p->gracenoteFileId); + ndestring_release(p->genre); + if (p->artist && p->artist != emptyQueryListString) + ndestring_release(p->artist); + + if(p->art) { p->art->updateMsg.hwnd = 0; p->art->Release(); } + p++; + } + obj->Size = 0; +} + +void freeQueryListObject(queryListObject *obj) +{ + emptyQueryListObject(obj); + free(obj->Items); + obj->Items = 0; + obj->Alloc = obj->Size = 0; +} + +int reallocQueryListObject(queryListObject *obj) // 0 on success +{ + if (obj->Size >= obj->Alloc) + { + size_t old_Alloc = obj->Alloc; + obj->Alloc = obj->Size + 32; + queryListItem *data = (queryListItem*)realloc(obj->Items, sizeof(queryListItem) * obj->Alloc); + if (data) + { + obj->Items = data; + } + else + { + data = (queryListItem*)malloc(sizeof(queryListItem) * obj->Alloc); + if (data) + { + memcpy(data, obj->Items, sizeof(queryListItem) * old_Alloc); + free(obj->Items); + obj->Items = data; + } + else obj->Alloc = old_Alloc; + } + + if (!obj->Items) + { + obj->Alloc = 0; + return -1; + } + } + return 0; +} + +int ViewFilter::BuildSortFunc(const void *elem1, const void *elem2, const void *context) +{ + ViewFilter *sortFilter = (ViewFilter *)context; + itemRecordW *a = (itemRecordW *)elem1; + itemRecordW *b = (itemRecordW *)elem2; + wchar_t ab[100] = {0}, bb[100] = {0}; + int v=WCSCMP_NULLOK(sortFilter->GroupText(a,ab,100),sortFilter->GroupText(b,bb,100)); + if (v) + return v; + if(sortFilter->nextFilter) + return WCSCMP_NULLOK(sortFilter->nextFilter->GroupText(a,ab,100),sortFilter->nextFilter->GroupText(b,bb,100)); + return 0; +} + +static int sortFunc_cols(const void *elem1, const void *elem2) +{ + ListField * a = (ListField *)elem1; + ListField * b = (ListField *)elem2; + return a->pos - b->pos; +} +static bool sortFunc_cols_V2(const void* elem1, const void* elem2) +{ + return sortFunc_cols(elem1, elem2) < 0; +} +void ViewFilter::AddColumns() { + ClearColumns(); + + AddColumns2(); + + for(unsigned int i=0; i<showncolumns.size(); i++){ + ListField *l = showncolumns[i]; + if(l->hidden) { + hiddencolumns.push_back(l); + showncolumns.erase(showncolumns.begin() + i); + i--; + } + } + //qsort(showncolumns.first(),showncolumns.size(),sizeof(void*),sortFunc_cols); + std::sort(showncolumns.begin(), showncolumns.end(), sortFunc_cols_V2); + + for ( ListField *l_column : showncolumns ) + list->AddCol( l_column->name, l_column->width ); +} + +void ViewFilter::ClearColumns() +{ + for ( ListField *l_shown_column : showncolumns ) + delete l_shown_column; + + showncolumns.clear(); + + + for ( ListField *l_hidden_column : hiddencolumns ) + delete l_hidden_column; + + hiddencolumns.clear(); +} + +void ViewFilter::SaveColumnWidths() +{ + char *av = GetConfigId(); + for ( size_t i = 0; i < showncolumns.size(); i++ ) + { + wchar_t configname[ 256 ] = { 0 }; + int field = showncolumns[ i ]->field; + StringCchPrintfW( configname, ARRAYSIZE( configname ), L"%hs_col_%d", av, field ); + g_view_metaconf->WriteInt( configname, list->GetColumnWidth( i ) ); + StringCchPrintfW( configname, ARRAYSIZE( configname ), L"%hs_col_%d_pos", av, field ); + g_view_metaconf->WriteInt( configname, i ); + StringCchPrintfW( configname, ARRAYSIZE( configname ), L"%hs_col_%d_hidden", av, field ); + g_view_metaconf->WriteInt( configname, 0 ); + } + + for ( ListField *l_hidden_column : hiddencolumns ) + { + wchar_t configname[ 256 ] = { 0 }; + StringCchPrintfW( configname, ARRAYSIZE( configname ), L"%hs_col_%d_hidden", av, l_hidden_column->field ); + g_view_metaconf->WriteInt( configname, 1 ); + } +} + +void ViewFilter::ResetColumns() +{ + for ( unsigned int i = 0; i < hiddencolumns.size(); i++ ) + { + showncolumns.push_back( hiddencolumns[ i ] ); + hiddencolumns.erase( hiddencolumns.begin() + i ); + i--; + } + + for ( unsigned int i = 0; i < showncolumns.size(); i++ ) + { + ListField *l = showncolumns[ i ]; + l->ResetPos(); + if ( l->hidden ) + { + hiddencolumns.push_back( l ); + showncolumns.erase( showncolumns.begin() + i ); + i--; + } + } + //qsort(showncolumns.first(),showncolumns.size(),sizeof(void*),sortFunc_cols); + std::sort( showncolumns.begin(), showncolumns.end(), sortFunc_cols_V2 ); + + for ( ListField *l_show_column : showncolumns ) + list->AddCol( l_show_column->name, l_show_column->width ); +} + +ListField::ListField(int field, int width0, const wchar_t * name, C_Config * config,char * av, bool hidden0, bool hiddenDefault, bool readini,int pos):field(field),name(name),hiddenDefault(hiddenDefault),hidden(hidden0),pos(pos),width(width0) { + this->name = _wcsdup(name); + if(readini) { + wchar_t buf[100] = {0}; + StringCchPrintfW(buf, ARRAYSIZE(buf), L"%hs_col_%d", av, field); + this->width = config->ReadInt(buf, width0); + StringCchPrintfW(buf, ARRAYSIZE(buf), L"%hs_col_%d_pos", av, field); + this->pos = config->ReadInt(buf, field); + StringCchPrintfW(buf, ARRAYSIZE(buf), L"%hs_col_%d_hidden", av, field); + this->hidden = config->ReadInt(buf, hidden0 ? 1: 0 ) != 0; + } +} + +ListField::ListField(int field, int width0, int name0, C_Config * config,char * av, bool hidden0, bool hiddenDefault, bool readini,int pos):field(field),name(name),hiddenDefault(hiddenDefault),hidden(hidden0),pos(pos),width(width0) { + this->name = _wcsdup(WASABI_API_LNGSTRINGW(name0)); + if(readini) { + wchar_t buf[100] = {0}; + StringCchPrintfW(buf, ARRAYSIZE(buf), L"%hs_col_%d", av, field); + this->width = config->ReadInt(buf,width0); + StringCchPrintfW(buf, ARRAYSIZE(buf), L"%hs_col_%d_pos", av, field); + this->pos = config->ReadInt(buf,field); + StringCchPrintfW(buf, ARRAYSIZE(buf), L"%hs_col_%d_hidden", av, field); + this->hidden = config->ReadInt(buf,hidden0?1:0)!=0; + } +} + +void ListField::ResetPos() { pos = field; hidden = hiddenDefault;} + +static INT_PTR CALLBACK custColumns_dialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + static HWND m_curlistbox_hwnd, m_availlistbox_hwnd; + static ViewFilter *filter; + + switch (uMsg) { + case WM_INITDIALOG: + m_curlistbox_hwnd = GetDlgItem(hwndDlg, IDC_LIST1); + m_availlistbox_hwnd = GetDlgItem(hwndDlg, IDC_LIST2); + filter = (ViewFilter*)lParam; + + if (NULL != WASABI_API_APP) + { + if (NULL != m_curlistbox_hwnd) + WASABI_API_APP->DirectMouseWheel_EnableConvertToMouseWheel(m_curlistbox_hwnd, TRUE); + if (NULL != m_availlistbox_hwnd) + WASABI_API_APP->DirectMouseWheel_EnableConvertToMouseWheel(m_availlistbox_hwnd, TRUE); + } + case WM_USER + 32: + { + for ( ListField *l : filter->showncolumns ) + { + int r = SendMessageW( m_curlistbox_hwnd, LB_ADDSTRING, 0, (LPARAM)l->name ); + SendMessageW( m_curlistbox_hwnd, LB_SETITEMDATA, r, (LPARAM)l ); + } + + for ( ListField *l : filter->hiddencolumns ) + { + int r = SendMessageW( m_availlistbox_hwnd, LB_ADDSTRING, 0, (LPARAM)l->name ); + SendMessageW( m_availlistbox_hwnd, LB_SETITEMDATA, r, (LPARAM)l ); + } + } + break; + case WM_COMMAND: + switch (LOWORD(wParam)) { + case IDC_DEFS: + SendMessage(m_curlistbox_hwnd, LB_RESETCONTENT, 0, 0); + SendMessage(m_availlistbox_hwnd, LB_RESETCONTENT, 0, 0); + filter->ResetColumns(); + SendMessage(hwndDlg, WM_USER + 32, 0, 0); + break; + case IDC_LIST2: + if (HIWORD(wParam) != LBN_DBLCLK) { + if (HIWORD(wParam) == LBN_SELCHANGE) { + int r = SendMessage(m_availlistbox_hwnd, LB_GETSELCOUNT, 0, 0) > 0; + EnableWindow(GetDlgItem(hwndDlg, IDC_BUTTON2), r); + } + return 0; + } + case IDC_BUTTON2: + //add column + { + for (int i = 0;i < SendMessage(m_availlistbox_hwnd, LB_GETCOUNT, 0, 0);i++) { + if (SendMessage(m_availlistbox_hwnd, LB_GETSEL, i, 0)) { + ListField* c = (ListField*)SendMessage(m_availlistbox_hwnd, LB_GETITEMDATA, i, 0); + if(!c) continue; + SendMessage(m_availlistbox_hwnd, LB_DELETESTRING, i--, 0); + int r = SendMessageW(m_curlistbox_hwnd, LB_ADDSTRING, 0, (LPARAM)c->name); + SendMessageW(m_curlistbox_hwnd, LB_SETITEMDATA, r, (LPARAM)c); + } + } + EnableWindow(GetDlgItem(hwndDlg, IDC_BUTTON2), 0); + } + break; + case IDC_LIST1: + if (HIWORD(wParam) != LBN_DBLCLK) { + if (HIWORD(wParam) == LBN_SELCHANGE) { + int r = SendMessage(m_curlistbox_hwnd, LB_GETSELCOUNT, 0, 0) > 0; + EnableWindow(GetDlgItem(hwndDlg, IDC_BUTTON3), r); + EnableWindow(GetDlgItem(hwndDlg, IDC_BUTTON4), r); + EnableWindow(GetDlgItem(hwndDlg, IDC_BUTTON5), r); + } + return 0; + } + case IDC_BUTTON3: + //remove column + { + for (int i = 0;i < SendMessage(m_curlistbox_hwnd, LB_GETCOUNT, 0, 0);i++) { + if (SendMessage(m_curlistbox_hwnd, LB_GETSEL, i, 0)) { + ListField* c = (ListField*)SendMessage(m_curlistbox_hwnd, LB_GETITEMDATA, i, 0); + if(!c) continue; + SendMessage(m_curlistbox_hwnd, LB_DELETESTRING, i, 0); + i--; + int r = SendMessageW(m_availlistbox_hwnd, LB_ADDSTRING, 0, (LPARAM)c->name); + SendMessageW(m_availlistbox_hwnd, LB_SETITEMDATA, r, (LPARAM)c); + } + } + EnableWindow(GetDlgItem(hwndDlg, IDC_BUTTON3), 0); + EnableWindow(GetDlgItem(hwndDlg, IDC_BUTTON4), 0); + EnableWindow(GetDlgItem(hwndDlg, IDC_BUTTON5), 0); + } + break; + case IDC_BUTTON4: + //move column up + { + for (int i = 0;i < (INT)SendMessage(m_curlistbox_hwnd, LB_GETCOUNT, 0, 0);i++) + { + if (i != 0 && (INT)SendMessage(m_curlistbox_hwnd, LB_GETSEL, i, 0)) + { + ListField* c = (ListField*)SendMessage(m_curlistbox_hwnd, LB_GETITEMDATA, i - 1, 0); + SendMessage(m_curlistbox_hwnd, LB_DELETESTRING, i - 1, 0); + int r = (INT)SendMessageW(m_curlistbox_hwnd, LB_INSERTSTRING, i, (LPARAM)c->name); + SendMessage(m_curlistbox_hwnd, LB_SETITEMDATA, r, (LPARAM)c); + } + } + } + break; + case IDC_BUTTON5: + //move column down + { + int l = SendMessage(m_curlistbox_hwnd, LB_GETCOUNT, 0, 0); + for (int i = l - 2;i >= 0;i--) + { + if (SendMessage(m_curlistbox_hwnd, LB_GETSEL, i, 0)) + { + ListField* c = (ListField*)SendMessage(m_curlistbox_hwnd, LB_GETITEMDATA, i + 1, 0); + SendMessage(m_curlistbox_hwnd, LB_DELETESTRING, i + 1, 0); + int r = (INT)SendMessageW(m_curlistbox_hwnd, LB_INSERTSTRING, i, (LPARAM)c->name); + SendMessage(m_curlistbox_hwnd, LB_SETITEMDATA, r, (LPARAM)c); + } + } + } + break; + case IDOK: + // read and apply changes... + { + filter->showncolumns.clear(); + filter->hiddencolumns.clear(); + int i; + int l = (INT)SendMessage(m_curlistbox_hwnd, LB_GETCOUNT, 0, 0); + for (i = 0;i < l;i++) { + ListField* c = (ListField*)SendMessage(m_curlistbox_hwnd, LB_GETITEMDATA, i, 0); + filter->showncolumns.push_back(c); + c->pos=i; + c->hidden=false; + } + l = (INT)SendMessage(m_availlistbox_hwnd, LB_GETCOUNT, 0, 0); + for (i = 0;i < l;i++) { + ListField* c = (ListField*)SendMessage(m_availlistbox_hwnd, LB_GETITEMDATA, i, 0); + filter->hiddencolumns.push_back(c); + c->hidden=true; + } + filter->SaveColumnWidths(); + } + EndDialog(hwndDlg, 1); + break; + case IDCANCEL: + EndDialog(hwndDlg, 0); + break; + + } + break; + case WM_DESTROY: + if (NULL != WASABI_API_APP) + { + if (NULL != m_curlistbox_hwnd) + WASABI_API_APP->DirectMouseWheel_EnableConvertToMouseWheel(m_curlistbox_hwnd, FALSE); + if (NULL != m_availlistbox_hwnd) + WASABI_API_APP->DirectMouseWheel_EnableConvertToMouseWheel(m_availlistbox_hwnd, FALSE); + } + break; + } + return FALSE; +} + + +void ViewFilter::CustomizeColumns( HWND parent, BOOL showmenu ) +{ + if ( showmenu ) + { + HMENU menu = GetSubMenu( g_context_menus, 4 ); + POINT p; + GetCursorPos( &p ); + int r = TrackPopupMenu( menu, TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTBUTTON, p.x, p.y, 0, parent, NULL ); + if ( r != ID_HEADERWND_CUSTOMIZECOLUMNS ) return; + } + + bool r = !!WASABI_API_DIALOGBOXPARAMW( IDD_CUSTCOLUMNS, parent, custColumns_dialogProc, (LPARAM)this ); + MSG msg; + while ( PeekMessage( &msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE ) ); //eat return + if ( r ) + { + while ( ListView_DeleteColumn( list->getwnd(), 0 ) ); + for ( ListField *l_show_column : showncolumns ) + list->AddCol( l_show_column->name, l_show_column->width ); + } +} + +HMENU ViewFilter::GetMenu(bool isFilter, int filterNum, C_Config *c, HMENU themenu) { + HMENU menu = GetSubMenu(themenu, 5); + wchar_t scrollConf[] = L"av0_hscroll"; + scrollConf[2] = (wchar_t)('0'+filterNum); + BOOL enablescroll = c->ReadInt(scrollConf, 0); + CheckMenuItem(menu,ID_FILTERHEADERWND_SHOWHORIZONTALSCROLLBAR,enablescroll?MF_CHECKED:MF_UNCHECKED); + + if(isFilter) { + MENUITEMINFO m={sizeof(m),MIIM_ID,0}; + int i=0; + while(GetMenuItemInfo(menu,i,TRUE,&m)) { + m.wID |= (1+filterNum) << 16; + SetMenuItemInfo(menu,i,TRUE,&m); + i++; + } + } + return menu; +} + +void ViewFilter::ProcessMenuResult(int r, bool isFilter, int editFilter, C_Config *c, HWND hwndDlg) { + int mid = (r >> 16); + if(!isFilter && mid) return; + if(isFilter && mid-1 != editFilter) return; + r &= 0xFFFF; + + switch(r) { + case ID_HEADERWND_CUSTOMIZECOLUMNS: + CustomizeColumns(hwndDlg, FALSE); + break; + case ID_FILTERHEADERWND_SHOWHORIZONTALSCROLLBAR: + { + wchar_t scrollConf[] = L"av0_hscroll"; + scrollConf[2]=(wchar_t)('0'+editFilter); + BOOL enablescroll = !c->ReadInt(scrollConf,0); + g_view_metaconf->WriteInt(scrollConf,enablescroll); + MLSkinnedScrollWnd_ShowHorzBar(list->getwnd(),enablescroll); + } + break; + } +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/ViewFilter.h b/Src/Plugins/Library/ml_local/ViewFilter.h new file mode 100644 index 00000000..b3c6c610 --- /dev/null +++ b/Src/Plugins/Library/ml_local/ViewFilter.h @@ -0,0 +1,89 @@ +#ifndef NULLSOFT_ML_LOCAL_VIEWFILTER_H +#define NULLSOFT_ML_LOCAL_VIEWFILTER_H + +#include "main.h" +#include "../nu/listview.h" +#include <vector> +class AlbumArtContainer; + +extern wchar_t *emptyQueryListString; +struct queryListItem +{ + queryListItem() : name(0), albumGain(0), length(0), art(0), artist(0), genre(0), + gracenoteFileId(0), rating(0), lastupd(0), size(0) { + ZeroMemory(&ifields,sizeof(ifields)); + } + wchar_t *name; + wchar_t *albumGain; + int length, ifields[3]; + AlbumArtContainer *art; + wchar_t *artist; + wchar_t *genre; + wchar_t *gracenoteFileId; + int rating; + __time64_t lastupd; + __int64 size; +} ; + +struct queryListObject +{ + queryListObject() : Items(0), Size(0), Alloc(0){} + queryListItem *Items; + int Size, Alloc; +} ; + +class ListField { +public: + int field; + int width; + int pos; + const wchar_t * name; + bool hidden, hiddenDefault; + ListField(int field, int width, const wchar_t * name, C_Config * config, char * av, bool hidden=false, bool hiddenDefault=false, bool readini=true, int pos=0); + ListField(int field, int width, int name, C_Config * config, char * av, bool hidden=false, bool hiddenDefault=false, bool readini=true, int pos=0); + ~ListField() { free((void*)name); } + void ResetPos(); +}; + +class ViewFilter +{ +public: + virtual ~ViewFilter(){} + virtual void SortResults(C_Config *viewconf, int which=0, int isfirst=0)=0; + virtual void Fill(itemRecordW *items, int numitems, int *killswitch, int numitems2)=0; + virtual int Size()=0; + virtual const wchar_t *GetText(int row)=0; + virtual void CopyText(int row, size_t column, wchar_t *dest, int destCch)=0; + virtual const wchar_t *CopyText2(int row, size_t column, wchar_t *dest, int destCch)=0; + virtual void Empty()=0; + virtual const wchar_t *GetField()=0; + virtual const wchar_t *GetName()=0; + virtual const wchar_t *GetNameSingular()=0; + virtual const wchar_t *GetNameSingularAlt(int mode)=0; + + virtual const wchar_t *GroupText(itemRecordW * item, wchar_t * buf, int len)=0; + virtual void AddColumns2()=0; + void AddColumns(); + virtual void SaveColumnWidths(); + static int __fastcall BuildSortFunc(const void *elem1, const void *elem2, const void *context); + virtual void CustomizeColumns(HWND parent, BOOL showmenu); + void ResetColumns(); + virtual const wchar_t *GetComparisonOperator() {return L"LIKE";} + virtual char * GetConfigId(){return "av";} + void ClearColumns(); + virtual INT_PTR DialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam){return 0;} + virtual bool HasTopItem() {return true;} + virtual bool MakeFilterQuery(int n, GayStringW *str){return false;} + + virtual HMENU GetMenu(bool isFilter, int filterNum, C_Config *c, HMENU themenu); + virtual void ProcessMenuResult(int r, bool isFilter, int filterNum, C_Config *c, HWND parent); + virtual void MetaUpdate(int r, const wchar_t *metaItem, const wchar_t *value) {} + + std::vector<ListField*> showncolumns; + std::vector<ListField*> hiddencolumns; + ViewFilter *nextFilter; + W_ListView * list; + int numGroups; +}; + +#endif
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/add.cpp b/Src/Plugins/Library/ml_local/add.cpp new file mode 100644 index 00000000..d99c93b8 --- /dev/null +++ b/Src/Plugins/Library/ml_local/add.cpp @@ -0,0 +1,478 @@ +#include "main.h" +#include "ml_local.h" +#include "api_mldb.h" +#include <commctrl.h> +#include "resource.h" +#include "../replicant/nu/ns_wc.h" +#include "../nde/nde.h" +#include "../Agave/Language/api_language.h" +#include "..\..\General\gen_ml/config.h" +#include "..\..\General\gen_ml/gaystring.h" +#include "time.h" +#include "../winamp/in2.h" +#include "../Winamp/strutil.h" +#include <shlwapi.h> +#include <strsafe.h> + + +bool skipTitleInfo=false; + +static int getFileInfoW(const wchar_t *filename, const wchar_t *metadata, wchar_t *dest, size_t len) +{ + dest[0]=0; + return AGAVE_API_METADATA->GetExtendedFileInfo(filename, metadata, dest, len); +} + +static time_t FileTimeToUnixTime(FILETIME *ft) +{ + ULARGE_INTEGER end; + memcpy(&end,ft,sizeof(end)); + end.QuadPart -= 116444736000000000; + end.QuadPart /= 10000000; // 100ns -> seconds + return (time_t)end.QuadPart; +} + +void makeFilename2W(const wchar_t *filename, wchar_t *filename2, int filename2_len) +{ + filename2[0]=0; + GetLongPathNameW(filename, filename2, filename2_len); + if (!_wcsicmp(filename,filename2)) filename2[0]=0; +} + +void makeFilename2(const char *filename, char *filename2, int filename2_len) +{ + filename2[0]=0; + GetLongPathNameA(filename, filename2, filename2_len); + if (!stricmp(filename,filename2)) filename2[0]=0; +} + +static __int64 FileSize64(HANDLE file) +{ + LARGE_INTEGER position; + position.QuadPart=0; + position.LowPart = GetFileSize(file, (LPDWORD)&position.HighPart); + + if (position.LowPart == INVALID_FILE_SIZE && GetLastError() != NO_ERROR) + return INVALID_FILE_SIZE; + else + return position.QuadPart; +} + +static void GetFileSizeAndTime(const wchar_t *filename, __int64 *file_size, time_t *file_time) +{ + WIN32_FILE_ATTRIBUTE_DATA file_data; + if (GetFileAttributesExW(filename, GetFileExInfoStandard, &file_data) == FALSE) + { + // GetFileAttributesEx failed. that sucks, let's try something else + HANDLE hFile=CreateFileW(filename,GENERIC_READ,FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,0,NULL); + if (hFile != INVALID_HANDLE_VALUE) + { + FILETIME lt = {0}; + if (GetFileTime(hFile,NULL,NULL,<)) + { + *file_time=FileTimeToUnixTime(<); + } + *file_size=FileSize64(hFile); + CloseHandle(hFile); + } + } + else + { + // success + *file_time = FileTimeToUnixTime(&file_data.ftLastWriteTime); + LARGE_INTEGER size64; + size64.LowPart = file_data.nFileSizeLow; + size64.HighPart = file_data.nFileSizeHigh; + *file_size = size64.QuadPart; + } +} + +int FindFileInDatabase(nde_scanner_t s, int fieldId, const wchar_t *filename, wchar_t alternate[MAX_PATH]) +{ + alternate[0]=0; + + makeFilename2W(filename,alternate,MAX_PATH); + if (alternate[0]) + { + if (NDE_Scanner_LocateFilename(s, fieldId, FIRST_RECORD, alternate)) + { + return 2; + } + } + if (NDE_Scanner_LocateFilename(s, fieldId, FIRST_RECORD, filename)) + return 1; + + return 0; +} + +static inline void GetOptionalField(nde_scanner_t s, const wchar_t *filename, const wchar_t *field, unsigned char field_id) +{ + wchar_t tmp[1024]={0}; + if (getFileInfoW(filename,field,tmp,sizeof(tmp)/sizeof(wchar_t))) + { + if(tmp[0]) + { + tmp[1023]=0; // just in case + db_setFieldStringW(s, field_id,tmp); + } + else + { + db_removeField(s, field_id); + } + } +} + +static inline void GetOptionalFieldInt(nde_scanner_t s, const wchar_t *filename, const wchar_t *field, unsigned char field_id) +{ + wchar_t tmp[128]={0}; + if (getFileInfoW(filename,field,tmp,sizeof(tmp)/sizeof(wchar_t))) + { + if(tmp[0]) + { + tmp[127]=0; // just in case + db_setFieldInt(s,field_id,_wtoi(tmp)); + } + else + { + db_removeField(s, field_id); + } + } +} + +static inline void GetNonBlankFieldInt(nde_scanner_t s, const wchar_t *filename, const wchar_t *field, unsigned char field_id) +{ + wchar_t tmp[128]={0}; + if (getFileInfoW(filename,field,tmp,sizeof(tmp)/sizeof(wchar_t))) + { + if(tmp[0]) + { + tmp[127]=0; // just in case + db_setFieldInt(s,field_id,_wtoi(tmp)); + } + } +} + + +// return values +// 0 - error +// 1 - success +// -2 - record not found (in update only mode) +int addFileToDb(const wchar_t *filename, int onlyupdate, int use_metadata, int guess_mode, int playcnt, int lastplay, bool force) +{ + if (!_wcsicmp(PathFindExtensionW(filename), L".cda")) + return 0; + + __int64 file_size=INVALID_FILE_SIZE; + time_t file_time=0; + GetFileSizeAndTime(filename, &file_size, &file_time); + if (file_size == INVALID_FILE_SIZE || file_size == 0) + return 0; + + openDb(); // just in case it's not opened yet (this function will return immediately if it's already open) + EnterCriticalSection(&g_db_cs); + + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + + wchar_t filename2[MAX_PATH] = {0}; // full lfn path if set + int found = FindFileInDatabase(s, MAINTABLE_ID_FILENAME, filename, filename2); + + if (found) // For updating + { + // if an update wasn't forced, see if the file's timestamp or filesize have changed + if (!force && NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_FILESIZE)) + { + nde_field_t f=NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_FILETIME); + if (f && file_time <= NDE_IntegerField_GetValue(f)) + { + f=NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_LASTUPDTIME); + if (f && file_time <= NDE_IntegerField_GetValue(f)) + { + NDE_Table_DestroyScanner(g_table, s); + LeaveCriticalSection(&g_db_cs); + return 1; + } + } + } + NDE_Scanner_Edit(s); + if (found == 1 && filename2[0]) db_setFieldStringW(s,MAINTABLE_ID_FILENAME,filename2); // if we have a better filename, update it + nde_field_t f=NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_PLAYCOUNT); + int cnt = f?NDE_IntegerField_GetValue(f):0; + if (!cnt) + db_setFieldInt(s,MAINTABLE_ID_PLAYCOUNT,0); + } + else // Adding an entry from scratch + { + if (onlyupdate) + { + NDE_Table_DestroyScanner(g_table, s); + LeaveCriticalSection(&g_db_cs); + + // Issue a wasabi system callback after we have successfully updated a file in the ml database + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_UPDATED_EXTERNAL, (size_t)filename, 0); + return -2; + } + // new file + NDE_Scanner_New(s); + db_setFieldStringW(s,MAINTABLE_ID_FILENAME,filename2[0]?filename2:filename); + db_setFieldInt(s,MAINTABLE_ID_PLAYCOUNT,playcnt); + if (lastplay) + db_setFieldInt(s,MAINTABLE_ID_LASTPLAY,lastplay); + db_setFieldInt(s,MAINTABLE_ID_DATEADDED, (int)time(NULL)); + } + + int hasttitle=0, hastartist=0, hastalbum=0, hasttrack=0; + int hastyear=0, hastlength=0; + int hasdisc=0, hasalbumartist=0; + int hasttype=0, hasdiscs=0, hastracks=0, hasbitrate=0; + int the_length_sec=0; + wchar_t m_artist[1024] = {0}, tmp[1024] = {0}; + + if(getFileInfoW(filename, DB_FIELDNAME_type, tmp, sizeof(tmp) / sizeof(wchar_t)) ) + { + if(tmp[0]) { int type=_wtoi(tmp); db_setFieldInt(s,MAINTABLE_ID_TYPE,type); hasttype++; } + } + + if (getFileInfoW(filename, DB_FIELDNAME_length,tmp,sizeof(tmp)/sizeof(wchar_t))) + { + if(tmp[0]) { db_setFieldInt(s,MAINTABLE_ID_LENGTH,the_length_sec=(_wtoi(tmp)/1000)); hastlength++; } + } + + if (getFileInfoW(filename, DB_FIELDNAME_bitrate,tmp,sizeof(tmp)/sizeof(wchar_t))) + { + if(tmp[0]) { db_setFieldInt(s,MAINTABLE_ID_BITRATE,_wtoi(tmp)); hasbitrate++; } + } + + if(use_metadata && getFileInfoW(filename, DB_FIELDNAME_title,tmp,sizeof(tmp)/sizeof(wchar_t))) + { + if(tmp[0]) + { + db_setFieldStringW(s,MAINTABLE_ID_TITLE,tmp); + hasttitle++; + } + + getFileInfoW( filename, DB_FIELDNAME_artist, tmp, sizeof( tmp ) / sizeof( wchar_t ) ); + + if(tmp[0]) + { + StringCchCopyW(m_artist, 1024, tmp); + db_setFieldStringW(s,MAINTABLE_ID_ARTIST,tmp); + hastartist++; + } + + getFileInfoW(filename, DB_FIELDNAME_album,tmp,sizeof(tmp)/sizeof(wchar_t)); + + if(tmp[0]) + { + db_setFieldStringW(s,MAINTABLE_ID_ALBUM,tmp); + hastalbum++; + } + + GetOptionalField(s, filename, DB_FIELDNAME_comment, MAINTABLE_ID_COMMENT); + + getFileInfoW(filename, DB_FIELDNAME_year,tmp,sizeof(tmp)/sizeof(wchar_t)); + if(tmp[0] && !wcsstr(tmp,L"__") && !wcsstr(tmp,L"/") && !wcsstr(tmp,L"\\") && !wcsstr(tmp,L".")) { + wchar_t *p=tmp; + while (p && *p) + { + if (*p == L'_') *p=L'0'; + p++; + } + int y=_wtoi(tmp); + if(y!=0) { db_setFieldInt(s,MAINTABLE_ID_YEAR,_wtoi(tmp)); hastyear++; } + } + GetOptionalField(s, filename, DB_FIELDNAME_genre, MAINTABLE_ID_GENRE); + + getFileInfoW(filename, DB_FIELDNAME_track,tmp,sizeof(tmp)/sizeof(wchar_t)); + if(tmp[0]) + { + int track, tracks; + ParseIntSlashInt(tmp, &track, &tracks); + if (track > 0) + { + db_setFieldInt(s,MAINTABLE_ID_TRACKNB,track); + hasttrack++; + } + if (tracks > 0) + { + db_setFieldInt(s,MAINTABLE_ID_TRACKS,tracks); + hastracks++; + } + } + getFileInfoW(filename, DB_FIELDNAME_disc,tmp,sizeof(tmp)/sizeof(wchar_t)); + if(tmp[0]) + { + int disc, discs; + ParseIntSlashInt(tmp, &disc, &discs); + if (disc > 0) + { + db_setFieldInt(s,MAINTABLE_ID_DISC,disc); + hasdisc++; + } + if (discs > 0) + { + db_setFieldInt(s,MAINTABLE_ID_DISCS,discs); + hasdiscs++; + } + } + getFileInfoW(filename, DB_FIELDNAME_albumartist,tmp,sizeof(tmp)/sizeof(wchar_t)); + if(tmp[0]) { db_setFieldStringW(s,MAINTABLE_ID_ALBUMARTIST,tmp); hasalbumartist++; } + GetOptionalField(s, filename, DB_FIELDNAME_publisher, MAINTABLE_ID_PUBLISHER); + GetOptionalField(s, filename, DB_FIELDNAME_composer, MAINTABLE_ID_COMPOSER); + GetOptionalField(s, filename, DB_FIELDNAME_replaygain_album_gain, MAINTABLE_ID_ALBUMGAIN); + GetOptionalField(s, filename, DB_FIELDNAME_replaygain_track_gain, MAINTABLE_ID_TRACKGAIN); + GetOptionalFieldInt(s, filename, DB_FIELDNAME_bpm, MAINTABLE_ID_BPM); + GetOptionalField(s, filename, DB_FIELDNAME_GracenoteFileID, MAINTABLE_ID_GRACENOTEFILEID); + GetOptionalField(s, filename, DB_FIELDNAME_GracenoteExtData, MAINTABLE_ID_GRACENOTEEXTDATA); + GetOptionalFieldInt(s, filename, DB_FIELDNAME_lossless, MAINTABLE_ID_LOSSLESS); + GetOptionalField(s, filename, DB_FIELDNAME_category, MAINTABLE_ID_CATEGORY); + GetOptionalField(s, filename, DB_FIELDNAME_codec, MAINTABLE_ID_CODEC); + GetOptionalField(s, filename, DB_FIELDNAME_director, MAINTABLE_ID_DIRECTOR); + GetOptionalField(s, filename, DB_FIELDNAME_producer, MAINTABLE_ID_PRODUCER); + GetOptionalFieldInt(s, filename, DB_FIELDNAME_width, MAINTABLE_ID_WIDTH); + GetOptionalFieldInt(s, filename, DB_FIELDNAME_height, MAINTABLE_ID_HEIGHT); + if (g_config->ReadInt(L"writeratings", 0)) + GetOptionalFieldInt(s, filename, DB_FIELDNAME_rating, MAINTABLE_ID_RATING); + else + GetNonBlankFieldInt(s, filename, DB_FIELDNAME_rating, MAINTABLE_ID_RATING); + GetOptionalField(s, filename, L"mime", MAINTABLE_ID_MIMETYPE); + } + + int guessmode = guess_mode; + if (guessmode != 2 && ((!hasttitle) + (!hastartist) + (!hastalbum) + (!hasttrack) >= (g_guessifany ? 1 : 4))) + { + int tn = 0; + wchar_t *artist = 0, *album = 0, *title = 0, *guessbuf = 0; + + if (guessmode==1) + { + guessbuf = _wcsdup(filename2[0] ? filename2 : filename); + + wchar_t *p=scanstr_backW(guessbuf, L"\\/.", guessbuf); + if (*p == '.') + { + *p = 0; + p = scanstr_backW(guessbuf, L"\\/", guessbuf); + } + + if (p > guessbuf) + { + *p = 0; + title = p+1; + p=scanstr_backW(guessbuf, L"\\/", guessbuf); + if (p > guessbuf) + { + *p = 0; + album = p+1; + p=scanstr_backW(guessbuf,L"\\/", guessbuf); + if (p > guessbuf) + { + *p = 0; + artist = p+1; + } + } + } + } + else + guessbuf = guessTitles(filename2[0] ? filename2 : filename, &tn, &artist, &album, &title); + + if (guessbuf) + { + if (!hasttitle && title) { hasttitle++; db_setFieldStringW(s,MAINTABLE_ID_TITLE,title); } + if (!hastartist && artist) { hastartist++; db_setFieldStringW(s,MAINTABLE_ID_ARTIST,artist); StringCbCopyW(m_artist, sizeof(m_artist), artist); } + if (!hastalbum && album) { hastalbum++; db_setFieldStringW(s,MAINTABLE_ID_ALBUM,album); } + if (!hasttrack && tn) { hasttrack++; db_setFieldInt(s,MAINTABLE_ID_TRACKNB,tn); } + free(guessbuf); + } + } + + if (!hastlength || !hasttitle) + { + // try to query length and title using older GetFileInfo input plugin API + wchar_t ft[1024] = {0}; + basicFileInfoStructW bi={0}; + bi.filename=filename2[0]?filename2:filename; + bi.length=-1; + bi.title=ft; + bi.titlelen=1024; + skipTitleInfo=true; + LeaveCriticalSection(&g_db_cs); // benski> not actually sure if this is safe, but it prevents a deadlock + SendMessage(plugin.hwndWinampParent,WM_WA_IPC,(WPARAM)&bi,IPC_GET_BASIC_FILE_INFOW); + EnterCriticalSection(&g_db_cs); + skipTitleInfo=false; + if (!hastlength && bi.length >= 0) + { + hastlength=1; + db_setFieldInt(s,MAINTABLE_ID_LENGTH,the_length_sec=bi.length); + } + if (!hasttitle && ft[0]) + { + hasttitle=1; + db_setFieldStringW(s,MAINTABLE_ID_TITLE,ft); + } + } + + // set up default (empty) strings/values + if (!hasttitle) // title=filename + { + wchar_t *p = PathFindFileNameW(filename), *dup = _wcsdup(p); + if (dup) + { + PathRemoveExtensionW(dup); + db_setFieldStringW(s,MAINTABLE_ID_TITLE,dup); + free(dup); + } + } + + if (!hastartist) db_removeField(s,MAINTABLE_ID_ARTIST); + if (!hastalbum) db_removeField(s,MAINTABLE_ID_ALBUM); + if (!hasttrack) db_removeField(s,MAINTABLE_ID_TRACKNB); + if (!hastracks) db_removeField(s,MAINTABLE_ID_TRACKS); + if (!hastyear) db_removeField(s,MAINTABLE_ID_YEAR); + if (!hastlength) db_removeField(s,MAINTABLE_ID_LENGTH); + if (!hasttype) db_setFieldInt(s,MAINTABLE_ID_TYPE,0); //audio + if (!hasdisc) db_removeField(s, MAINTABLE_ID_DISC); + if (!hasdiscs) db_removeField(s, MAINTABLE_ID_DISCS); + if (!hasalbumartist) + { + if (hastartist && g_config->ReadInt(L"artist_as_albumartist", 1)) + db_setFieldStringW(s, MAINTABLE_ID_ALBUMARTIST, m_artist); + else + db_removeField(s, MAINTABLE_ID_ALBUMARTIST); + } + + if (file_size != INVALID_FILE_SIZE) + { + db_setFieldInt64(s,MAINTABLE_ID_FILESIZE, file_size); + } + else db_removeField(s,MAINTABLE_ID_FILESIZE); + + db_setFieldInt(s,MAINTABLE_ID_LASTUPDTIME, (int)time(NULL)); + db_setFieldInt(s,MAINTABLE_ID_FILETIME, (int)file_time); + + if (!hasbitrate && the_length_sec) + { + __int64 br =(file_size*8LL) / (__int64)the_length_sec; + br /= 1000; + db_setFieldInt(s,MAINTABLE_ID_BITRATE,(int)br); + } + + NDE_Scanner_Post(s); + g_table_dirty++; + + NDE_Table_DestroyScanner(g_table, s); + + LeaveCriticalSection(&g_db_cs); + + if (found) + { + // Issue a wasabi system callback after we have successfully updated a file in the ml database + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_UPDATED, (size_t)filename, 0); + } + else + { + // Issue a wasabi system callback after we have successfully added a file in the ml database + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_ADDED, (size_t)filename, 0); + } + + return 1; +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/api__ml_local.h b/Src/Plugins/Library/ml_local/api__ml_local.h new file mode 100644 index 00000000..7c602232 --- /dev/null +++ b/Src/Plugins/Library/ml_local/api__ml_local.h @@ -0,0 +1,15 @@ +#pragma once +#include "../Agave/Agave.h" + +DECLARE_EXTERNAL_SERVICE(api_application, WASABI_API_APP); +DECLARE_EXTERNAL_SERVICE(api_explorerfindfile, WASABI_API_EXPLORERFINDFILE); +DECLARE_EXTERNAL_SERVICE(api_language, WASABI_API_LNG); +DECLARE_EXTERNAL_SERVICE(api_syscb, WASABI_API_SYSCB); +DECLARE_EXTERNAL_SERVICE(api_memmgr, WASABI_API_MEMMGR); +DECLARE_EXTERNAL_SERVICE(api_albumart, AGAVE_API_ALBUMART); +DECLARE_EXTERNAL_SERVICE(api_metadata, AGAVE_API_METADATA); +DECLARE_EXTERNAL_SERVICE(api_playlistmanager, AGAVE_API_PLAYLISTMANAGER); +DECLARE_EXTERNAL_SERVICE(api_itunes_importer, AGAVE_API_ITUNES_IMPORTER); +DECLARE_EXTERNAL_SERVICE(api_playlist_generator, AGAVE_API_PLAYLIST_GENERATOR); +DECLARE_EXTERNAL_SERVICE(api_threadpool, WASABI_API_THREADPOOL); + diff --git a/Src/Plugins/Library/ml_local/api_mldb.cpp b/Src/Plugins/Library/ml_local/api_mldb.cpp new file mode 100644 index 00000000..67220738 --- /dev/null +++ b/Src/Plugins/Library/ml_local/api_mldb.cpp @@ -0,0 +1,3 @@ +#include "api_mldb.h" + +// this file exists solely to ensure that api_mldb.h can be #include'd by itself
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/api_mldb.h b/Src/Plugins/Library/ml_local/api_mldb.h new file mode 100644 index 00000000..ed792573 --- /dev/null +++ b/Src/Plugins/Library/ml_local/api_mldb.h @@ -0,0 +1,166 @@ +#pragma once + +#include <bfc/dispatch.h> +#include "..\..\General\gen_ml/ml.h" + +class api_mldb : public Dispatchable +{ +protected: + api_mldb() {} + ~api_mldb() {} +public: + itemRecordW *GetFile(const wchar_t *filename); + itemRecordW *GetFileIf(const wchar_t *filename, const wchar_t *query); // returns the item record for a filename, but also checks against the passed query + itemRecordListW *GetAlbum(const wchar_t *albumname, const wchar_t *albumartist); + itemRecordListW *Query(const wchar_t *query); + itemRecordListW *QueryLimit(const wchar_t *query, unsigned int limit); + + void SetField(const wchar_t *filename, const char *field, const wchar_t *value); + void SetFieldInteger(const wchar_t *filename, const char *field, int value); + void SetFieldInt128(const wchar_t *filename, const char *field, uint8_t value[16]); + void Sync(); + + void FreeRecord(itemRecordW *record); + void FreeRecordList(itemRecordListW *recordList); + + int AddFile(const wchar_t *filename); + int RemoveFile(const wchar_t *filename); + + /* wrappers around ndestring */ + void RetainString(wchar_t *str); + void ReleaseString(wchar_t *str); + wchar_t *DuplicateString(const wchar_t *str); + + int GetMaxInteger(const char *field, int *max); + + DISPATCH_CODES + { + API_MLDB_GETFILE = 10, + API_MLDB_GETFILEIF = 11, + API_MLDB_GETALBUM = 20, + API_MLDB_QUERY = 30, + API_MLDB_QUERYLIMIT = 31, + API_MLDB_FREERECORD = 40, + API_MLDB_FREERECORDLIST = 50, + API_MLDB_SETFIELD = 60, + API_MLDB_SETFIELDINT = 61, + API_MLDB_SETFIELDINT128 = 62, + API_MLDB_SYNC = 70, + API_MLDB_ADDFILE = 80, + API_MLDB_REMOVEFILE = 90, + API_MLDB_RETAINSTRING = 100, + API_MLDB_RELEASESTRING = 110, + API_MLDB_DUPLICATESTRING = 120, + API_MLDB_GETMAXINTEGER = 130, + }; + + typedef struct + { + time_t played; + int count; + } played_info; + + enum + { + // System callbacks for api_mldb + SYSCALLBACK = MK4CC('m','l','d','b'), // Unique identifier for mldb_api callbacks + MLDB_FILE_ADDED = 10, // param1 = filename, param2 = (not used), Callback event for when a new file is added to the local mldb + MLDB_FILE_REMOVED_PRE = 20, // param1 = filename, param2 = (not used), Callback event for when a file is removed from the local mldb (before it happens) + MLDB_FILE_REMOVED_POST = 25, // param1 = filename, param2 = (not used), Callback event for when a file is removed from the local mldb (after it happens) + MLDB_FILE_UPDATED = 30, // param1 = filename, param2 = (not used), Callback event for when a file is modified in the local mldb + MLDB_FILE_UPDATED_EXTERNAL = 35, // param1 = filename, param2 = (not used), Callback event for when a file is modified and is not in the local mldb + MLDB_CLEARED = 40, // param1 = filenames, param2 = count, Callback event for when the local mldb is cleared (useful so removed is not triggered for all files) + MLDB_FILE_PLAYED = 50, // param1 = filename, param2 = played_info, Callback event for when a file is tracked as playing in the local mldb + MLDB_FILE_GET_CLOUD_STATUS = 60, // param1 = filename, param2 = HMENU*, Callback event for when ml_local needs to show a cloud status menu (returned by the handler in param2) + MLDB_FILE_PROCESS_CLOUD_STATUS = 65, // param1 = menu_item, param2 = int*, Callback event for when ml_local needs to process the result of a cloud status menu + }; +}; + +inline itemRecordW *api_mldb::GetFile(const wchar_t *filename) +{ + return _call(API_MLDB_GETFILE, (itemRecordW *)0, filename); +} + +inline itemRecordW *api_mldb::GetFileIf(const wchar_t *filename, const wchar_t *query) +{ + return _call(API_MLDB_GETFILEIF, (itemRecordW *)0, filename, query); +} + +inline itemRecordListW *api_mldb::GetAlbum(const wchar_t *albumname, const wchar_t *albumartist) +{ + return _call(API_MLDB_GETALBUM, (itemRecordListW *)0, albumname, albumartist); +} + +inline itemRecordListW *api_mldb::Query(const wchar_t *query) +{ + return _call(API_MLDB_QUERY, (itemRecordListW *)0, query); +} + +inline itemRecordListW *api_mldb::QueryLimit(const wchar_t *query, unsigned int limit) +{ + return _call(API_MLDB_QUERYLIMIT, (itemRecordListW *)0, query, limit); +} + +inline void api_mldb::FreeRecord(itemRecordW *record) +{ + _voidcall(API_MLDB_FREERECORD, record); +} + +inline void api_mldb::FreeRecordList(itemRecordListW *recordList) +{ + _voidcall(API_MLDB_FREERECORDLIST, recordList); +} + +inline void api_mldb::SetField(const wchar_t *filename, const char *field, const wchar_t *value) +{ + _voidcall(API_MLDB_SETFIELD, filename, field, value); +} + +inline void api_mldb::SetFieldInteger(const wchar_t *filename, const char *field, int value) +{ + _voidcall(API_MLDB_SETFIELDINT, filename, field, value); +} + +inline void api_mldb::SetFieldInt128(const wchar_t *filename, const char *field, uint8_t value[16]) +{ + _voidcall(API_MLDB_SETFIELDINT128, filename, field, value); +} + +inline void api_mldb::Sync() +{ + _voidcall(API_MLDB_SYNC); +} + +inline int api_mldb::AddFile(const wchar_t *filename) +{ + return _call(API_MLDB_ADDFILE, (int)0, filename); +} + +inline int api_mldb::RemoveFile(const wchar_t *filename) +{ + return _call(API_MLDB_REMOVEFILE, (int)0, filename); +} + +inline void api_mldb::RetainString(wchar_t *str) +{ + _voidcall(API_MLDB_RETAINSTRING, str); +} + +inline void api_mldb::ReleaseString(wchar_t *str) +{ + _voidcall(API_MLDB_RELEASESTRING, str); +} + +inline wchar_t *api_mldb::DuplicateString(const wchar_t *str) +{ + return _call(API_MLDB_DUPLICATESTRING, (wchar_t *)0, str); +} + +inline int api_mldb::GetMaxInteger(const char *field, int *max) +{ + return _call(API_MLDB_GETMAXINTEGER, (int)1, field, max); +} + +// {5A94DABC-E19A-4a12-9AA8-852D8BF06532} +static const GUID mldbApiGuid = +{ 0x5a94dabc, 0xe19a, 0x4a12, { 0x9a, 0xa8, 0x85, 0x2d, 0x8b, 0xf0, 0x65, 0x32 } }; diff --git a/Src/Plugins/Library/ml_local/bgscan.cpp b/Src/Plugins/Library/ml_local/bgscan.cpp new file mode 100644 index 00000000..8b4d9bdc --- /dev/null +++ b/Src/Plugins/Library/ml_local/bgscan.cpp @@ -0,0 +1,940 @@ +#include "main.h" +#include "resource.h" +#include "api_mldb.h" +#include "../Winamp/strutil.h" + +enum { + STATUS_SEARCHING, + STATUS_GETINFO, + STATUS_DONE, +}; + +extern HWND g_bgrescan_status_hwnd; +extern nde_scanner_t m_media_scanner; + +#define MAX_RECURSE_DEPTH 32 +/* Event handles */ +static HANDLE scan_killswitch=0; +static HANDLE scan_cancel=0; +static HANDLE scan_cancel_complete=0; +/* Thread handle */ +static HANDLE scan_thread=0; +/* extension list */ +static wchar_t *scan_extlist=0; + +static void SyncTable() +{ + EnterCriticalSection(&g_db_cs); + NDE_Table_Sync(g_table); + g_table_dirty=0; + LeaveCriticalSection(&g_db_cs); +} + +static bool ScanCancelled(HANDLE *events, int count) +{ + // make sure no one cancelled us + DWORD eventFired=WaitForMultipleObjectsEx(count, events, FALSE, 0, TRUE); + if (eventFired >= WAIT_OBJECT_0 && eventFired < (WAIT_OBJECT_0+count)) + return true; + + return false; +} + +static bool SupportedType(const wchar_t *ext) +{ + if (!scan_extlist) + scan_extlist=(wchar_t*)SendMessage(plugin.hwndWinampParent,WM_WA_IPC,0,IPC_GET_EXTLISTW); + + // dunno how this would happen but should verify + if (!scan_extlist || scan_extlist == (wchar_t *)1) + return false; + + const wchar_t *a = scan_extlist; + while (a && *a) + { + if (CompareStringW(MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT), NORM_IGNORECASE, a, -1, ext, -1) == CSTR_EQUAL) + { + return true; + } + a+=wcslen(a)+1; + } + return false; +} + +static void CountFolder(const wchar_t *folder, int recurse, HANDLE cancelswitch, volatile int *found) +{ + wchar_t filespec[MAX_PATH] = {0}; + PathCombineW(filespec, folder, L"*.*"); + + WIN32_FIND_DATAW findData = {0}; + + HANDLE h = FindFirstFileW(filespec, &findData); + if (h != INVALID_HANDLE_VALUE) + { + if (IsWindow(g_bgrescan_status_hwnd)) + { + wchar_t status[150+MAX_PATH] = {0}; + WASABI_API_LNGSTRINGW_BUF(IDS_SCANNING_DIR, status, 150); + + const wchar_t *p=folder+wcslen(folder); + while (p > folder && *p != '\\') p--; + p--; + while (p >= folder && *p != '\\') p--; + + StringCbCatW(status, sizeof(status), ++p); + + SetWindowTextW(g_bgrescan_status_hwnd,status); + } + + HANDLE events[2] = { scan_killswitch, cancelswitch}; + do + { + // make sure no one cancelled us + if (ScanCancelled(events, 2)) + break; + + /* if it's a directory (And not either of the two special dirs */ + if ((findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) + && lstrcmpiW(findData.cFileName, L".") + && lstrcmpiW(findData.cFileName, L"..")) + { + if (recurse && recurse < MAX_RECURSE_DEPTH) + { + PathCombineW(filespec, folder, findData.cFileName); + CountFolder(filespec, recurse+1, cancelswitch, found); // add 1 so we can verify recurse depth + } + } + + if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) + { + wchar_t *ext=extensionW(findData.cFileName); + if (ext && ext[0] && SupportedType(ext)) + { + PathCombineW(filespec, folder, findData.cFileName); + if (IsWindow(g_bgrescan_status_hwnd)) + { + wchar_t b[150+MAX_PATH] = {0}; + WASABI_API_LNGSTRINGW_BUF(IDS_SCANNING_FILE, b, 150); + StringCbCatW(b, sizeof(b), filespec); + SetWindowTextW(g_bgrescan_status_hwnd,b); + } + if (found) + (*found)++; + } + } + + } while (FindNextFileW(h, &findData)); + FindClose(h); + } + else if (!(GetFileAttributesW(folder) & FILE_ATTRIBUTE_DIRECTORY)) + { + if (IsWindow(g_bgrescan_status_hwnd)) + { + wchar_t b[150+MAX_PATH] = {0}; + WASABI_API_LNGSTRINGW_BUF(IDS_SCANNING_FILE, b, 150); + StringCbCatW(b, sizeof(b), folder); + SetWindowTextW(g_bgrescan_status_hwnd,b); + } + if (found) + (*found)++; + } +} + +static void ScanFolder(const wchar_t *folder, int recurse, int metadata, int guessmode, HANDLE cancelswitch, volatile int *scanned) +{ + if ((unsigned long)folder < 65536) return; + + wchar_t filespec[MAX_PATH] = {0}; + wchar_t status[150+MAX_PATH] = {0}; + PathCombineW(filespec, folder, L"*.*"); + + WIN32_FIND_DATAW findData = {0}; + + HANDLE h = FindFirstFileW(filespec, &findData); + if (h != INVALID_HANDLE_VALUE) + { + if (IsWindow(g_bgrescan_status_hwnd)) + { + WASABI_API_LNGSTRINGW_BUF(IDS_SCANNING_DIR, status, 150); + + const wchar_t *p=folder+wcslen(folder); + while (p > folder && *p != '\\') p--; + p--; + while (p >= folder && *p != '\\') p--; + + StringCbCatW(status, sizeof(status), ++p); + + SetWindowTextW(g_bgrescan_status_hwnd,status); + } + + HANDLE events[2] = { scan_killswitch, cancelswitch}; + do + { + // make sure no one cancelled us + if (ScanCancelled(events, 2)) + break; + + /* if it's a directory (And not either of the two special dirs */ + if ((findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) + && lstrcmpiW(findData.cFileName, L".") + && lstrcmpiW(findData.cFileName, L"..")) + { + if (recurse && recurse < MAX_RECURSE_DEPTH) + { + PathCombineW(filespec, folder, findData.cFileName); + ScanFolder(filespec, recurse+1, metadata, guessmode, cancelswitch, scanned); // add 1 so we can verify recurse depth + } + } + + if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) + { + wchar_t *ext=extensionW(findData.cFileName); + if (ext && ext[0] && SupportedType(ext)) + { + PathCombineW(filespec, folder, findData.cFileName); + if (IsWindow(g_bgrescan_status_hwnd)) + { + WASABI_API_LNGSTRINGW_BUF(IDS_SCANNING_FILE, status, 150); + StringCbCatW(status, sizeof(status), filespec); + SetWindowTextW(g_bgrescan_status_hwnd,status); + } + addFileToDb(filespec, 0, metadata, guessmode); + if (scanned) + (*scanned)++; + } + } + } while (FindNextFileW(h, &findData)); + FindClose(h); + } + else if (!(GetFileAttributesW(folder) & FILE_ATTRIBUTE_DIRECTORY)) + { + if (IsWindow(g_bgrescan_status_hwnd)) + { + WASABI_API_LNGSTRINGW_BUF(IDS_SCANNING_FILE, status, 150); + StringCbCatW(status, sizeof(status), folder); + SetWindowTextW(g_bgrescan_status_hwnd,status); + } + addFileToDb(folder, 0, metadata, guessmode); + if (scanned) + (*scanned)++; + } +} + +static DWORD CALLBACK ScanThreadProc(LPVOID param) +{ + /* sit and run APCs until we get signalled to die */ + HANDLE events[2] = { scan_killswitch, scan_cancel}; + int eventFired; + do + { + eventFired=WaitForMultipleObjectsEx(2, events, FALSE, INFINITE, TRUE); + switch(eventFired) + { + case WAIT_OBJECT_0+1: // cancel event + ResetEvent(scan_cancel); + SetEvent(scan_cancel_complete); + break; + } + } + while (eventFired != WAIT_OBJECT_0); + + if (scan_extlist && scan_extlist != (wchar_t *)1) + GlobalFree((HGLOBAL)scan_extlist); + scan_extlist=0; + return 0; +} + +static bool ScanCreateThread() +{ + if (!scan_thread) + { + /* create events */ + scan_killswitch = CreateEvent(NULL, TRUE, FALSE, NULL); + scan_cancel = CreateEvent(NULL, TRUE, FALSE, NULL); + scan_cancel_complete = CreateEvent(NULL, FALSE, FALSE, NULL); // auto-reset event + + /* start thread */ + scan_thread = CreateThread(NULL, 0, ScanThreadProc, 0, 0, 0); + } + + return !!scan_thread; +} + +void Scan_Cancel() +{ + HWND old = g_bgrescan_status_hwnd; // clear g_bgrescan_status_hwnd so that we don't deadlock when the BG thread calls SetWindowText + g_bgrescan_status_hwnd = 0; + if (scan_cancel) + SignalObjectAndWait(scan_cancel, scan_cancel_complete, INFINITE, FALSE); + g_bgrescan_status_hwnd = old; +} + +void Scan_Kill() +{ + HWND old = g_bgrescan_status_hwnd; // clear g_bgrescan_status_hwnd so that we don't deadlock when the BG thread calls SetWindowText + g_bgrescan_status_hwnd = 0; + if (scan_thread) + SignalObjectAndWait(scan_killswitch, scan_thread, INFINITE, FALSE); + g_bgrescan_status_hwnd = old; +} + +/* --------------- +* Scan_ScanFolder +* --------------- +*/ + +struct ScanFolderParams +{ + ScanFolderParams(const wchar_t *_path, int _guess, int _meta, int _recurse) + { + path = _wcsdup(_path); + guess = _guess >= 0 ? _guess : g_config->ReadInt(L"guessmode",0);; + meta = _meta >= 0 ? _meta : g_config->ReadInt(L"usemetadata",1); + recurse = _recurse; + } + ~ScanFolderParams() + { + free(path); + } + wchar_t *path; + int guess; + int meta; + int recurse; +}; + +static VOID CALLBACK ScanFolderAPC(ULONG_PTR param) +{ + // clear extension list to get latest config + if (scan_extlist && scan_extlist != (wchar_t *)1) + GlobalFree((HGLOBAL)scan_extlist); + scan_extlist = 0; + + ScanFolderParams *params = (ScanFolderParams *)param; + ScanFolder(params->path, params->recurse, params->meta, params->guess, scan_cancel, 0); + SyncTable(); + delete params; +} + +void Scan_ScanFolderBackground(const wchar_t *path, int guess, int meta, int recurse) +{ + if (ScanCreateThread()) + { + ScanFolderParams *params = new ScanFolderParams(path, guess, meta, recurse); + if (QueueUserAPC(ScanFolderAPC, scan_thread, (ULONG_PTR)params) == 0) + delete params; + } +} + +/* --------------- +* Scan_ScanFolders +* --------------- +*/ + +struct ScanFoldersParams +{ + ScanFoldersParams(wchar_t **_path, size_t _count, int *_guess, int *_meta, int *_recurse) + { + path = _path; + count = _count; + guess = _guess; + meta = _meta; + recurse = _recurse; + found = 0; + scanned = 0; + cancel_switch = CreateEvent(NULL, TRUE, FALSE, NULL); + status = STATUS_SEARCHING; + ui = 0; + in_timer = 0; + + } + ~ScanFoldersParams() + { + for (size_t i=0;i!=count;i++) + free(path[i]); + free(path); + free(guess); + free(meta); + free(recurse); + CloseHandle(cancel_switch); + } + wchar_t **path; + size_t count; + int *guess; + int *meta; + int *recurse; + volatile int found; + volatile int scanned; + volatile int status; + int in_timer; + HANDLE cancel_switch; + HWND ui; +}; + +static VOID CALLBACK ScanFoldersAPC(ULONG_PTR param) +{ + // clear extension list to get latest config + if (scan_extlist && scan_extlist != (wchar_t *)1) + GlobalFree((HGLOBAL)scan_extlist); + scan_extlist = 0; + + ScanFoldersParams *params = (ScanFoldersParams *)param; + HANDLE events[2] = { scan_killswitch, params->cancel_switch}; + + for (size_t i=0;i!=params->count;i++) + { + if (ScanCancelled(events, 2)) + break; + + CountFolder(params->path[i], params->recurse[i], params->cancel_switch, ¶ms->found); + } + + params->status = STATUS_GETINFO; + + for (size_t i=0;i!=params->count;i++) + { + if (ScanCancelled(events, 2)) + break; + + int guess = params->guess[i] >= 0 ? params->guess[i] : g_config->ReadInt(L"guessmode",0);; + int meta = params->meta[i] >= 0 ? params->meta[i] : g_config->ReadInt(L"usemetadata",1); + ScanFolder(params->path[i], params->recurse[i], meta, guess, params->cancel_switch, ¶ms->scanned); + } + + params->status = STATUS_DONE; + PostMessage(params->ui, WM_APP, 0, 0); +} + +static INT_PTR CALLBACK ScanFileUI(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam) +{ + switch(uMsg) + { + case WM_INITDIALOG: + { + SetDlgItemTextW(hwndDlg,IDC_STATUS,WASABI_API_LNGSTRINGW(IDS_INITIALIZING)); + + ScanFoldersParams *params = (ScanFoldersParams *)lParam; + params->ui = hwndDlg; + SetWindowLongPtr(hwndDlg, GWLP_USERDATA, lParam); + if (QueueUserAPC(ScanFoldersAPC, scan_thread, (ULONG_PTR)lParam) == 0) + EndDialog(hwndDlg, 0); + else + { + SendDlgItemMessage(hwndDlg,IDC_PROGRESS1,PBM_SETRANGE,0,MAKELPARAM(0, 100)); + SetTimer(hwndDlg,0x123,300,NULL); + } + + // show window and restore last position as applicable + POINT pt = {g_config->ReadInt(L"scan_x", -1), g_config->ReadInt(L"scan_y", -1)}; + if (!windowOffScreen(hwndDlg, pt)) + SetWindowPos(hwndDlg, HWND_TOP, pt.x, pt.y, 0, 0, SWP_NOSIZE | SWP_SHOWWINDOW | SWP_NOSENDCHANGING); + } + break; + + case WM_TIMER: + { + ScanFoldersParams *params = (ScanFoldersParams *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA); + if (params->in_timer) break; + params->in_timer++; + + if(params->status==STATUS_SEARCHING) + { + wchar_t tmp[512] = {0}; + StringCchPrintfW(tmp, 512, WASABI_API_LNGSTRINGW(IDS_SEARCHING_X_FILES_FOUND), params->found); + SetDlgItemTextW(hwndDlg,IDC_STATUS,tmp); + } + else if(params->status==STATUS_GETINFO) + { + wchar_t tmp[512] = {0}; + int perc=params->found?(params->scanned*100/params->found):0; + StringCchPrintfW(tmp, 512, WASABI_API_LNGSTRINGW(IDS_GETTING_INFO_FROM_FILES_PERCENT),perc); + SetDlgItemTextW(hwndDlg,IDC_STATUS,tmp); + SendDlgItemMessage(hwndDlg,IDC_PROGRESS1,PBM_SETPOS,perc,0); + } + params->in_timer--; + } + break; + + case WM_APP: + { + KillTimer(hwndDlg,0x123); + SyncTable(); + EndDialog(hwndDlg,0); + } + break; + + case WM_COMMAND: + if (LOWORD(wParam)==IDCANCEL) + { + ScanFoldersParams *params = (ScanFoldersParams *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA); + SetEvent(params->cancel_switch); + } + break; + + case WM_DESTROY: + { + RECT scan_rect = {0}; + GetWindowRect(hwndDlg, &scan_rect); + g_config->WriteInt(L"scan_x", scan_rect.left); + g_config->WriteInt(L"scan_y", scan_rect.top); + + KillTimer(hwndDlg,0x123); + ScanFoldersParams *params = (ScanFoldersParams *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA); + SetWindowLongPtr(hwndDlg, GWLP_USERDATA, 0); + delete params; + return FALSE; + } + } + return FALSE; +} + +/* When you call this function, it will own the memory and release it with free() */ +void Scan_ScanFolders(HWND parent, size_t count, wchar_t **paths, int *guess, int *meta, int *recurse) +{ + openDb(); + + if (g_table && ScanCreateThread()) + { + ScanFoldersParams *params = new ScanFoldersParams(paths, count, guess, meta, recurse); + WASABI_API_LNG->LDialogBoxParamW(WASABI_API_LNG->FindDllHandleByGUID(WinampLangGUID), + GetModuleHandleW(L"winamp.exe"), IDD_ADDSTUFF, + parent, (DLGPROC)ScanFileUI, (LPARAM)params); + PostMessage(plugin.hwndWinampParent,WM_WA_IPC,NDE_Table_GetRecordsCount(g_table),IPC_STATS_LIBRARY_ITEMCNT); + } + else + { + for (size_t i=0;i!=count;i++) + free(paths[i]); + free(paths); + } +} + +void Scan_ScanFolder(HWND parent, const wchar_t *path, int guess, int meta, int recurse) +{ + // kind of a hack ... + if (ScanCreateThread()) + { + wchar_t **paths = (wchar_t **)calloc(1, sizeof(wchar_t*)); + int *guesses = (int *)calloc(1, sizeof(int)); + int *metas = (int *)calloc(1, sizeof(int)); + int *recs = (int *)calloc(1, sizeof(int)); + *guesses = guess; + *metas = meta; + *recs = recurse; + paths[0] = _wcsdup(path); + Scan_ScanFolders(parent, 1, paths, guesses, metas, recs); + } +} + +static VOID CALLBACK BackgroundScanAPC(ULONG_PTR param) +{ + openDb(); + if (!g_table) + return; + + HANDLE events[2] = { scan_killswitch, scan_cancel}; + + // clear extension list to get latest config + if (scan_extlist && scan_extlist != (wchar_t *)1) + GlobalFree((HGLOBAL)scan_extlist); + scan_extlist = 0; + + // read list from config + UINT codePage = CP_ACP; + char scandirlist[65536] = {0}; + if (!g_config->ReadString("scandirlist", 0, scandirlist, 65536)) + { + g_config->ReadString("scandirlist_utf8","", scandirlist, 65536); + codePage = CP_UTF8; + } + + AutoWide s1(scandirlist, codePage); + size_t len = wcslen(s1)+2; + wchar_t *s =(wchar_t*)calloc(len, sizeof(wchar_t)); + if (s) + { + lstrcpynW(s, s1, len); + s[wcslen(s)+1]=0; + + wchar_t *p=s; + while (p && *p == L'|') p++; + + while ((p=wcsstr(p,L"|"))) + { + *p++=0; + while (p && *p == L'|') p++; + } + p=s; + + // iterate through list + while (p && *p && !ScanCancelled(events, 2)) + { + while (p && *p == L'|') p++; + + int use_metadata=g_config->ReadInt(L"usemetadata",1); + int guess_mode=g_config->ReadInt(L"guessmode",0); + int recurse=1; + if (*p == L'<' && wcsstr(p,L">")) + { + p++; + while (p && *p != L'>') + { + // <MmSs>can prefix directory + // M=metadata use override + // m=no metadata + // S=smart guessing + // s=stupid guessing + if (*p == L'M') use_metadata=1; + else if (*p == L'm') use_metadata=0; + else if (*p == L'S') guess_mode=0; + else if (*p == L's') guess_mode=1; + else if (*p == L'r') recurse=0; + else if (*p == L'g') guess_mode=2; + p++; + } + p++; + } + ScanFolder(p, recurse, use_metadata, guess_mode, scan_cancel, 0); + p+=wcslen(p)+1; + } + + free(s); + } + + /* Remove missing files */ + if (!ScanCancelled(events, 2) && g_config->ReadInt(L"bgrescan_compact",1)) + { + EnterCriticalSection(&g_db_cs); + nde_scanner_t scanner = NDE_Table_CreateScanner(g_table); + NDE_Scanner_Query(scanner, L""); + NDE_Scanner_First(scanner); +again: + nde_field_t f=NDE_Scanner_GetFieldByID(scanner, MAINTABLE_ID_FILENAME); + wchar_t *gs=0; + if (f) + { + gs = NDE_StringField_GetString(f); + ndestring_retain(gs); + if (GetFileAttributesW(gs) != INVALID_FILE_ATTRIBUTES) + { + NDE_Scanner_Next(scanner); + } + else + { + // Issue wasabi callback for pre removal + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_REMOVED_PRE, (size_t)gs, 0); + + NDE_Scanner_Delete(scanner); + NDE_Scanner_Post(scanner); + + // Issue wasabi callback for pre removal + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_REMOVED_POST, (size_t)gs, 0); + } + } + LeaveCriticalSection(&g_db_cs); + + if (f) // done checking for unused files + { + if (IsWindow(g_bgrescan_status_hwnd)) + { + wchar_t b[150+MAX_PATH] = {0}; + WASABI_API_LNGSTRINGW_BUF(IDS_CHECKING_FOR_FILE, b, 150); + StringCbCatW(b, sizeof(b), PathFindFileNameW(gs)); + SetWindowTextW(g_bgrescan_status_hwnd,b); + } + ndestring_release(gs); + gs=0; + if (!ScanCancelled(events, 2)) + { + EnterCriticalSection(&g_db_cs); + goto again; + } + } + + EnterCriticalSection(&g_db_cs); + NDE_Table_DestroyScanner(g_table, scanner); + LeaveCriticalSection(&g_db_cs); + + if (IsWindow(g_bgrescan_status_hwnd)) + { + wchar_t b[150] = {0}; + WASABI_API_LNGSTRINGW_BUF(IDS_COMPACTING, b, 150); + SetWindowTextW(g_bgrescan_status_hwnd,b); + } + } + + // TODO: hmmm, safe to do on separate thread? + EnterCriticalSection(&g_db_cs); + if (!ScanCancelled(events, 2)) + { + wchar_t *last_query = NULL; + if (m_media_scanner) + { + const wchar_t *lq = NDE_Scanner_GetLastQuery(m_media_scanner); + if (lq) last_query = _wcsdup(lq); + NDE_Table_DestroyScanner(g_table, m_media_scanner); + } + NDE_Table_Sync(g_table); // this is currently b0rk3d -- fucko :) + NDE_Table_Compact(g_table); + g_table_dirty=0; + if (m_media_scanner) + { + m_media_scanner=NDE_Table_CreateScanner(g_table); + if (last_query != NULL) + { + NDE_Scanner_Query(m_media_scanner, last_query); + free(last_query); + } + } + + PostMessage(plugin.hwndWinampParent,WM_WA_IPC,NDE_Table_GetRecordsCount(g_table),IPC_STATS_LIBRARY_ITEMCNT); + } + else + { + NDE_Table_Sync(g_table); // this is currently b0rk3d -- fucko :) + g_table_dirty=0; + } + LeaveCriticalSection(&g_db_cs); + if (IsWindow(g_bgrescan_status_hwnd)) + SetWindowTextW(g_bgrescan_status_hwnd,L""); + g_bgscan_last_rescan = time(NULL); + g_bgscan_scanning = 0; +} + +void Scan_BackgroundScan() +{ + if (ScanCreateThread()) + { + g_bgrescan_force = 0; + g_bgscan_last_rescan = time(NULL); + g_bgscan_scanning = 1; + + QueueUserAPC(BackgroundScanAPC, scan_thread, (ULONG_PTR)0); + + } +} + +static void RemoveFiles(HANDLE cancelswitch, volatile int *found, volatile int *count, volatile int *scanned) +{ + // TODO: benski> we might need to keep the database lock the whole time. need to think it thru + EnterCriticalSection(&g_db_cs); + nde_scanner_t myscanner=NDE_Table_CreateScanner(g_table); + NDE_Scanner_Query(myscanner, L""); + NDE_Scanner_First(myscanner); + *found=0; + *scanned=0; + *count=NDE_Table_GetRecordsCount(g_table); + LeaveCriticalSection(&g_db_cs); + + HANDLE events[2] = { scan_killswitch, cancelswitch}; + + bool fileRemoved = false; + wchar_t *filename; + while (!ScanCancelled(events, 2)) + { + EnterCriticalSection(&g_db_cs); + if (!NDE_Scanner_BOF(myscanner) && !NDE_Scanner_EOF(myscanner)) + { + nde_field_t f= NDE_Scanner_GetFieldByID(myscanner, MAINTABLE_ID_FILENAME); + if (f) + { + (*scanned)++; + + filename = (NDE_StringField_GetString(f)); + + if (GetFileAttributesW(NDE_StringField_GetString(f)) != INVALID_FILE_ATTRIBUTES) + { + NDE_Scanner_Next(myscanner); + } + else + { + // Issue wasabi callback for pre removal + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_REMOVED_PRE, (size_t)filename, 0); + + //remove file + NDE_Scanner_Delete(myscanner); + NDE_Scanner_Post(myscanner); + (*found)++; + fileRemoved = true; + } + } + else + { + //remove file + NDE_Scanner_Delete(myscanner); + NDE_Scanner_Post(myscanner); + (*found)++; + fileRemoved = false; + } + } + else // last file + { + LeaveCriticalSection(&g_db_cs); + break; + } + LeaveCriticalSection(&g_db_cs); + + if (fileRemoved) + { + // Issue wasabi callback for pre removal + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_REMOVED_POST, (size_t)filename, 0); + fileRemoved = false; + } + } + EnterCriticalSection(&g_db_cs); + NDE_Table_DestroyScanner(g_table, myscanner); // important that we delete the scanner BEFORE + myscanner=0; + + wchar_t *last_query = NULL; + if (m_media_scanner) + { + const wchar_t *lq = NDE_Scanner_GetLastQuery(m_media_scanner); + if (lq) last_query = _wcsdup(lq); + NDE_Table_DestroyScanner(g_table, m_media_scanner); + } + NDE_Table_Sync(g_table); // this is currently b0rk3d -- fucko :) + NDE_Table_Compact(g_table); + g_table_dirty=0; + if (m_media_scanner) + { + m_media_scanner=NDE_Table_CreateScanner(g_table); + if (last_query != NULL) + { + NDE_Scanner_Query(m_media_scanner, last_query); + free(last_query); + } + } + LeaveCriticalSection(&g_db_cs); +} + +struct RemoveFilesParams +{ + RemoveFilesParams() + { + found = 0; + scanned = 0; + total = 0; + cancel_switch = CreateEvent(NULL, TRUE, FALSE, NULL); + ui = 0; + in_timer = 0; + } + ~RemoveFilesParams() + { + + CloseHandle(cancel_switch); + } + volatile int found; + volatile int scanned; + volatile int total; + + int in_timer; + HANDLE cancel_switch; + HWND ui; +}; + +static VOID CALLBACK RemoveFilesAPC(ULONG_PTR param) +{ + RemoveFilesParams *params = (RemoveFilesParams *)param; + + RemoveFiles(params->cancel_switch, ¶ms->found, ¶ms->total, ¶ms->scanned); + PostMessage(params->ui, WM_APP, 0, 0); +} + +static INT_PTR CALLBACK RemoveFilesUI(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam) +{ + switch(uMsg) + { + case WM_INITDIALOG: + { + SetWindowTextW(hwndDlg,WASABI_API_LNGSTRINGW(IDS_REMOVING_FILES_NOT_EXISTING)); + SetDlgItemTextW(hwndDlg,IDC_STATUS,WASABI_API_LNGSTRINGW(IDS_INITIALIZING)); + + RemoveFilesParams *params = (RemoveFilesParams *)lParam; + params->ui = hwndDlg; + SetWindowLongPtr(hwndDlg, GWLP_USERDATA, lParam); + if (QueueUserAPC(RemoveFilesAPC, scan_thread, (ULONG_PTR)lParam) == 0) + EndDialog(hwndDlg, 0); + else + { + SendDlgItemMessage(hwndDlg,IDC_PROGRESS1,PBM_SETRANGE,0,MAKELPARAM(0, 100)); + SetTimer(hwndDlg,0x123,300,NULL); + } + + // show window and restore last position as applicable + POINT pt = {g_config->ReadInt(L"scan_x", -1), g_config->ReadInt(L"scan_y", -1)}; + if (!windowOffScreen(hwndDlg, pt)) + SetWindowPos(hwndDlg, HWND_TOP, pt.x, pt.y, 0, 0, SWP_NOSIZE | SWP_SHOWWINDOW | SWP_NOSENDCHANGING); + } + break; + + case WM_TIMER: + { + RemoveFilesParams *params = (RemoveFilesParams *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA); + if (params->in_timer) break; + params->in_timer++; + + if(params->total) + { + wchar_t tmp[512] = {0}; + int perc=(params->scanned*100/(params->total?params->total:1)); + StringCchPrintfW(tmp, 512, WASABI_API_LNGSTRINGW(IDS_SCANNING_X_OF_X_X_REMOVED),params->scanned,params->total,params->found); + SetDlgItemTextW(hwndDlg,IDC_STATUS,tmp); + SendDlgItemMessage(hwndDlg,IDC_PROGRESS1,PBM_SETPOS,perc,0); + } + + params->in_timer--; + } + break; + + case WM_APP: + { + RemoveFilesParams *params = (RemoveFilesParams *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA); + KillTimer(hwndDlg,0x123); + + wchar_t tmp[512] = {0}; + int perc=(params->scanned*100/(params->total?params->total:1)); + StringCchPrintfW(tmp, 512, WASABI_API_LNGSTRINGW(IDS_SCANNED_X_FILES_X_REMOVED),params->total,params->found); + SetDlgItemTextW(hwndDlg,IDC_STATUS,tmp); + SendDlgItemMessage(hwndDlg,IDC_PROGRESS1,PBM_SETPOS,perc,0); + + SyncTable(); + EndDialog(hwndDlg,0); + } + break; + + case WM_COMMAND: + if (LOWORD(wParam)==IDCANCEL) + { + RemoveFilesParams *params = (RemoveFilesParams *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA); + SetEvent(params->cancel_switch); + } + break; + + case WM_DESTROY: + { + RECT scan_rect = {0}; + GetWindowRect(hwndDlg, &scan_rect); + g_config->WriteInt(L"scan_x", scan_rect.left); + g_config->WriteInt(L"scan_y", scan_rect.top); + + KillTimer(hwndDlg,0x123); + RemoveFilesParams *params = (RemoveFilesParams *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA); + SetWindowLongPtr(hwndDlg, GWLP_USERDATA, 0); + delete params; + } + return FALSE; + } + return FALSE; +} + +void Scan_RemoveFiles(HWND parent) +{ + openDb(); + if (g_table && ScanCreateThread()) + { + RemoveFilesParams *params = new RemoveFilesParams(); + WASABI_API_LNG->LDialogBoxParamW(WASABI_API_LNG->FindDllHandleByGUID(WinampLangGUID), + GetModuleHandleW(L"winamp.exe"), IDD_ADDSTUFF, + parent, (DLGPROC)RemoveFilesUI, (LPARAM)params); + PostMessage(plugin.hwndWinampParent,WM_WA_IPC,NDE_Table_GetRecordsCount(g_table),IPC_STATS_LIBRARY_ITEMCNT); + } +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/contnr.cpp b/Src/Plugins/Library/ml_local/contnr.cpp new file mode 100644 index 00000000..6306f3f2 --- /dev/null +++ b/Src/Plugins/Library/ml_local/contnr.cpp @@ -0,0 +1,979 @@ +/************************************************************************** + THIS CODE AND INFORMATION IS PROVIDED 'AS IS' WITHOUT WARRANTY OF + ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO + THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A + PARTICULAR PURPOSE. + + Copyright 1998 Microsoft Corporation. All Rights Reserved. +**************************************************************************/ + +/************************************************************************** + + File: contnr.cpp + + Description: This file contains the complete implementation of an + ActiveX control container. This purpose of this container + is to test a single control being hosted. + +**************************************************************************/ + +/************************************************************************** + #include statements +**************************************************************************/ +#include "main.h" +#include <windows.h> +#include <commctrl.h> +#include "contnr.h" + +#include <mshtmdid.h> +#include <shlobj.h> +#include "ml_local.h" + +/************************************************************************** + + CContainer::CContainer() + +**************************************************************************/ +extern IDispatch *winampExternal; + +CContainer::CContainer() +{ + m_cRefs = 1; + m_hwnd = NULL; + m_punk = NULL; + m_scrollbars= 1; + m_allowScripts=1; + m_restrictAlreadySet=0; + m_hwndStatus = 0; + +} + +/************************************************************************** + + CContainer::~CContainer() + +**************************************************************************/ + +CContainer::~CContainer() +{ + if (m_punk) + { + m_punk->Release(); + m_punk=NULL; + } +} + +/************************************************************************** + + CContainer::QueryInterface() + +**************************************************************************/ + +STDMETHODIMP CContainer::QueryInterface(REFIID riid, PVOID *ppvObject) +{ + if (!ppvObject) + return E_POINTER; + + if (IsEqualIID(riid, IID_IOleClientSite)) + *ppvObject = (IOleClientSite *)this; + else if (IsEqualIID(riid, IID_IOleInPlaceSite)) + *ppvObject = (IOleInPlaceSite *)this; + else if (IsEqualIID(riid, IID_IOleInPlaceFrame)) + *ppvObject = (IOleInPlaceFrame *)this; + else if (IsEqualIID(riid, IID_IOleInPlaceUIWindow)) + *ppvObject = (IOleInPlaceUIWindow *)this; + else if (IsEqualIID(riid, IID_IOleControlSite)) + *ppvObject = (IOleControlSite *)this; + else if (IsEqualIID(riid, IID_IOleWindow)) + *ppvObject = this; + else if (IsEqualIID(riid, IID_IDispatch)) + *ppvObject = (IDispatch *)this; + else if (IsEqualIID(riid, IID_IUnknown)) + *ppvObject = this; + else if (IsEqualIID(riid, IID_IDocHostUIHandler)) + *ppvObject = (IDocHostUIHandler *)this; + else + { + *ppvObject = NULL; + return E_NOINTERFACE; + } + + AddRef(); + return S_OK; +} + +/************************************************************************** + + CContainer::AddRef() + +**************************************************************************/ + +ULONG CContainer::AddRef(void) +{ + return ++m_cRefs; +} + +/************************************************************************** + + CContainer::Release() + +**************************************************************************/ + +ULONG CContainer::Release(void) +{ + if (--m_cRefs) + return m_cRefs; + + delete this; + return 0; +} + +/************************************************************************** + + CContainer::SaveObject() + +**************************************************************************/ + +HRESULT CContainer::SaveObject() +{ + return E_NOTIMPL; +} + +/************************************************************************** + + CContainer::GetMoniker() + +**************************************************************************/ + +HRESULT CContainer::GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker, LPMONIKER * ppMk) +{ + return E_NOTIMPL; +} + +/************************************************************************** + + CContainer::GetContainer() + +**************************************************************************/ + +HRESULT CContainer::GetContainer(LPOLECONTAINER * ppContainer) +{ + return E_NOINTERFACE; +} + +/************************************************************************** + + CContainer::ShowObject() + +**************************************************************************/ + +HRESULT CContainer::ShowObject() +{ + return S_OK; +} + +/************************************************************************** + + CContainer::OnShowWindow() + +**************************************************************************/ + +HRESULT CContainer::OnShowWindow(BOOL fShow) +{ + return S_OK; +} + +/************************************************************************** + + CContainer::RequestNewObjectLayout() + +**************************************************************************/ + +HRESULT CContainer::RequestNewObjectLayout() +{ + return E_NOTIMPL; +} + +// *********************************************************************** +// IOleWindow +// *********************************************************************** + +/************************************************************************** + + CContainer::GetWindow() + +**************************************************************************/ + +HRESULT CContainer::GetWindow(HWND * lphwnd) +{ + if (!IsWindow(m_hwnd)) + return S_FALSE; + + *lphwnd = m_hwnd; + return S_OK; +} + +/************************************************************************** + + CContainer::ContextSensitiveHelp() + +**************************************************************************/ + +HRESULT CContainer::ContextSensitiveHelp(BOOL fEnterMode) +{ + return E_NOTIMPL; +} + +// *********************************************************************** +// IOleInPlaceSite +// *********************************************************************** + +/************************************************************************** + + CContainer::CanInPlaceActivate() + +**************************************************************************/ + +HRESULT CContainer::CanInPlaceActivate(void) +{ + return S_OK; +} + +/************************************************************************** + + CContainer::OnInPlaceActivate() + +**************************************************************************/ + +HRESULT CContainer::OnInPlaceActivate(void) +{ + return S_OK; +} + +/************************************************************************** + + CContainer::OnUIActivate() + +**************************************************************************/ + +HRESULT CContainer::OnUIActivate(void) +{ + return S_OK; +} + +/************************************************************************** + + CContainer::GetWindowContext() + +**************************************************************************/ + +HRESULT CContainer::GetWindowContext (IOleInPlaceFrame ** ppFrame, IOleInPlaceUIWindow ** ppIIPUIWin, + LPRECT lprcPosRect, LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo) +{ + *ppFrame = (IOleInPlaceFrame *)this; + *ppIIPUIWin = NULL; + + RECT rect; + GetClientRect(m_hwnd, &rect); + lprcPosRect->left = 0; + lprcPosRect->top = 0; + lprcPosRect->right = rect.right; + lprcPosRect->bottom = rect.bottom; + + CopyRect(lprcClipRect, lprcPosRect); + + lpFrameInfo->cb = sizeof(OLEINPLACEFRAMEINFO); + lpFrameInfo->fMDIApp = FALSE; + lpFrameInfo->hwndFrame = m_hwnd; + lpFrameInfo->haccel = 0; + lpFrameInfo->cAccelEntries = 0; + + (*ppFrame)->AddRef(); + return S_OK; +} + +/************************************************************************** + + CContainer::Scroll() + +**************************************************************************/ + +HRESULT CContainer::Scroll(SIZE scrollExtent) +{ + return E_NOTIMPL; +} + +/************************************************************************** + + CContainer::OnUIDeactivate() + +**************************************************************************/ + +HRESULT CContainer::OnUIDeactivate(BOOL fUndoable) +{ + return S_OK; +} + +/************************************************************************** + + CContainer::OnInPlaceDeactivate() + +**************************************************************************/ + +HRESULT CContainer::OnInPlaceDeactivate(void) +{ + return S_OK; +} + +/************************************************************************** + + CContainer::DiscardUndoState() + +**************************************************************************/ + +HRESULT CContainer::DiscardUndoState(void) +{ + return E_NOTIMPL; +} + +/************************************************************************** + + CContainer::DeactivateAndUndo() + +**************************************************************************/ + +HRESULT CContainer::DeactivateAndUndo(void) +{ + return E_NOTIMPL; +} + +/************************************************************************** + + CContainer::OnPosRectChange() + +**************************************************************************/ + +HRESULT CContainer::OnPosRectChange(LPCRECT lprcPosRect) +{ + HRESULT hr; + IOleInPlaceObject *pipo; + + hr = m_punk->QueryInterface(IID_IOleInPlaceObject, (PVOID *)&pipo); + if (SUCCEEDED(hr)) + { + pipo->SetObjectRects(lprcPosRect, lprcPosRect); + pipo->Release(); + } + return(S_OK); +} + +// *********************************************************************** +// IOleInPlaceUIWindow +// *********************************************************************** + +/************************************************************************** + + CContainer::GetBorder() + +**************************************************************************/ + +HRESULT CContainer::GetBorder(LPRECT lprectBorder) +{ + return E_NOTIMPL; +} + +/************************************************************************** + + CContainer::RequestBorderSpace() + +**************************************************************************/ + +HRESULT CContainer::RequestBorderSpace(LPCBORDERWIDTHS lpborderwidths) +{ + return E_NOTIMPL; +} + +/************************************************************************** + + CContainer::SetBorderSpace() + +**************************************************************************/ + +HRESULT CContainer::SetBorderSpace(LPCBORDERWIDTHS lpborderwidths) +{ + return E_NOTIMPL; +} + +/************************************************************************** + + CContainer::SetActiveObject() + +**************************************************************************/ + +HRESULT CContainer::SetActiveObject(IOleInPlaceActiveObject * pActiveObject, LPCOLESTR lpszObjName) +{ + return S_OK; +} + +// *********************************************************************** +// IOleInPlaceFrame +// *********************************************************************** + +/************************************************************************** + + CContainer::InsertMenus() + +**************************************************************************/ + +HRESULT CContainer::InsertMenus(HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths) +{ + return E_NOTIMPL; +} + +/************************************************************************** + + CContainer::SetMenu() + +**************************************************************************/ + +HRESULT CContainer::SetMenu(HMENU hmenuShared, HOLEMENU holemenu, HWND hwndActiveObject) +{ + return S_OK; +} + +/************************************************************************** + + CContainer::RemoveMenus() + +**************************************************************************/ + +HRESULT CContainer::RemoveMenus(HMENU hmenuShared) +{ + return E_NOTIMPL; +} + +/************************************************************************** + + CContainer::SetStatusText() + +**************************************************************************/ + +HRESULT CContainer::SetStatusText(LPCOLESTR pszStatusText) +{ + char status[MAX_PATH]; // ansi version of status text + + if (NULL == pszStatusText) + return E_POINTER; + + WideCharToMultiByte(CP_ACP, 0, pszStatusText, -1, status, MAX_PATH, NULL, NULL); + + if (IsWindow(m_hwndStatus)) + SendMessage(m_hwndStatus, SB_SETTEXT, (WPARAM)0, (LPARAM)status); + + return (S_OK); +} + +/************************************************************************** + + CContainer::EnableModeless() + +**************************************************************************/ + +HRESULT CContainer::EnableModeless(BOOL fEnable) +{ + return S_OK; +} + +/************************************************************************** + + CContainer::TranslateAccelerator() + +**************************************************************************/ + +HRESULT CContainer::TranslateAccelerator(LPMSG lpmsg, WORD wID) +{ + return E_NOTIMPL; +} + +// *********************************************************************** +// IOleControlSite +// *********************************************************************** + +/************************************************************************** + + CContainer::OnControlInfoChanged() + +**************************************************************************/ + +HRESULT CContainer::OnControlInfoChanged() +{ + return E_NOTIMPL; +} + +/************************************************************************** + + CContainer::LockInPlaceActive() + +**************************************************************************/ + +HRESULT CContainer::LockInPlaceActive(BOOL fLock) +{ + return E_NOTIMPL; +} + +/************************************************************************** + + CContainer::GetExtendedControl() + +**************************************************************************/ + +HRESULT CContainer::GetExtendedControl(IDispatch **ppDisp) +{ + if (ppDisp == NULL) + return E_INVALIDARG; + + *ppDisp = (IDispatch *)this; + (*ppDisp)->AddRef(); + + return S_OK; +} + +/************************************************************************** + + CContainer::TransformCoords() + +**************************************************************************/ + +HRESULT CContainer::TransformCoords(POINTL *pptlHimetric, POINTF *pptfContainer, DWORD dwFlags) +{ + return E_NOTIMPL; +} + +/************************************************************************** + + CContainer::TranslateAccelerator() + +**************************************************************************/ + +HRESULT CContainer::TranslateAccelerator(LPMSG pMsg, DWORD grfModifiers) +{ + return S_FALSE; +} + +/************************************************************************** + + CContainer::OnFocus() + +**************************************************************************/ + +HRESULT CContainer::OnFocus(BOOL fGotFocus) +{ + return E_NOTIMPL; +} + +/************************************************************************** + + CContainer::ShowPropertyFrame() + +**************************************************************************/ + +HRESULT CContainer::ShowPropertyFrame(void) +{ + return E_NOTIMPL; +} + +// *********************************************************************** +// IDispatch +// *********************************************************************** + +/************************************************************************** + + CContainer::GetIDsOfNames() + +**************************************************************************/ + +HRESULT CContainer::GetIDsOfNames(REFIID riid, OLECHAR FAR* FAR* rgszNames, unsigned int cNames, LCID lcid, DISPID FAR* rgdispid) +{ + *rgdispid = DISPID_UNKNOWN; + return DISP_E_UNKNOWNNAME; +} + +/************************************************************************** + + CContainer::GetTypeInfo() + +**************************************************************************/ + +HRESULT CContainer::GetTypeInfo(unsigned int itinfo, LCID lcid, ITypeInfo FAR* FAR* pptinfo) +{ + return E_NOTIMPL; +} + +/************************************************************************** + + CContainer::GetTypeInfoCount() + +**************************************************************************/ + +HRESULT CContainer::GetTypeInfoCount(unsigned int FAR * pctinfo) +{ + return E_NOTIMPL; +} + +/************************************************************************** + + CContainer::Invoke() + +**************************************************************************/ + +HRESULT CContainer::Invoke(DISPID dispid, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS FAR *pdispparams, VARIANT FAR *pvarResult, EXCEPINFO FAR * pexecinfo, unsigned int FAR *puArgErr) +{ + if(dispid==DISPID_AMBIENT_DLCONTROL) + { + m_restrictAlreadySet=1; + if(!m_allowScripts) + { + pvarResult->vt = VT_I4; + pvarResult->lVal = DLCTL_DLIMAGES|DLCTL_NO_SCRIPTS|DLCTL_NO_DLACTIVEXCTLS|DLCTL_NO_RUNACTIVEXCTLS|DLCTL_NO_JAVA; + return S_OK; + } + } + return DISP_E_MEMBERNOTFOUND; +} + +// *********************************************************************** +// Public (non-interface) Methods +// *********************************************************************** + +/************************************************************************** + + CContainer::add() + +**************************************************************************/ + +void CContainer::add(BSTR bstrClsid) +{ + CLSID clsid; // CLSID of the control object + HRESULT hr; // return code + + CLSIDFromString(bstrClsid, &clsid); + CoCreateInstance(clsid, + NULL, + CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER, + IID_IUnknown, + (PVOID *)&m_punk); + + if (!m_punk) + return; + + IOleObject *pioo; + hr = m_punk->QueryInterface(IID_IOleObject, (PVOID *)&pioo); + if (FAILED(hr)) + return; + + pioo->SetClientSite(this); + pioo->Release(); + + IPersistStreamInit *ppsi; + hr = m_punk->QueryInterface(IID_IPersistStreamInit, (PVOID *)&ppsi); + if (SUCCEEDED(hr)) + { + ppsi->InitNew(); + ppsi->Release(); + } +} + +/************************************************************************** + + CContainer::remove() + +**************************************************************************/ + +void CContainer::remove() +{ + if (!m_punk) + return; + + HRESULT hr; + IOleObject *pioo; + IOleInPlaceObject *pipo; + + hr = m_punk->QueryInterface(IID_IOleObject, (PVOID *)&pioo); + if (SUCCEEDED(hr)) + { + pioo->Close(OLECLOSE_NOSAVE); + pioo->SetClientSite(NULL); + pioo->Release(); + } + + hr = m_punk->QueryInterface(IID_IOleInPlaceObject, (PVOID *)&pipo); + if (SUCCEEDED(hr)) + { + pipo->UIDeactivate(); + pipo->InPlaceDeactivate(); + pipo->Release(); + } + + m_punk->Release(); + m_punk = NULL; +} + +/************************************************************************** + + CContainer::setParent() + +**************************************************************************/ + +void CContainer::setParent(HWND hwndParent) +{ + m_hwnd = hwndParent; +} + +/************************************************************************** + + CContainer::setLocation() + +**************************************************************************/ + +void CContainer::setLocation(int x, int y, int width, int height) +{ + RECT rc; + ::SetRect(&rc, x, y, x + width, y + height); + + if (!m_punk) return; + + HRESULT hr; + IOleInPlaceObject *pipo; + + hr = m_punk->QueryInterface(IID_IOleInPlaceObject, (PVOID *)&pipo); + if (FAILED(hr)) + return; + + pipo->SetObjectRects(&rc, &rc); + pipo->Release(); +} + +BOOL CContainer::SetRect(RECT *prc) +{ + HRESULT hr; + IOleInPlaceObject *pipo; + + + if (!m_punk) return FALSE; + + hr = m_punk->QueryInterface(IID_IOleInPlaceObject, (PVOID *)&pipo); + if (SUCCEEDED(hr)) + { + hr = pipo->SetObjectRects(prc, prc); + pipo->Release(); + } + return SUCCEEDED(hr); +} +/************************************************************************** + + CContainer::setVisible() + +**************************************************************************/ + +void CContainer::setVisible(BOOL fVisible) +{ + if (!m_punk) + return; + + HRESULT hr; + IOleObject *pioo; + + hr = m_punk->QueryInterface(IID_IOleObject, (PVOID *)&pioo); + if (FAILED(hr)) + return; + + if (fVisible) + { + + pioo->DoVerb(OLEIVERB_INPLACEACTIVATE, NULL, this, 0, m_hwnd, NULL); + pioo->DoVerb(OLEIVERB_SHOW, NULL, this, 0, m_hwnd, NULL); + } + else + pioo->DoVerb(OLEIVERB_HIDE, NULL, this, 0, m_hwnd, NULL); + + pioo->Release(); +} + +/************************************************************************** + + CContainer::setFocus() + +**************************************************************************/ + +void CContainer::setFocus(BOOL fFocus) +{ + if (!m_punk) + return; + + if (fFocus) + { + IOleObject *pioo; + HRESULT hr = m_punk->QueryInterface(IID_IOleObject, (PVOID *)&pioo); + if (FAILED(hr)) + return; + + pioo->DoVerb(OLEIVERB_UIACTIVATE, NULL, this, 0, m_hwnd, NULL); + pioo->Release(); + } +} + +/************************************************************************** + + CContainer::setStatusWindow() + +**************************************************************************/ + +void CContainer::setStatusWindow(HWND hwndStatus) +{ + m_hwndStatus = hwndStatus; +} + +/************************************************************************** + + CContainer::translateKey() + +**************************************************************************/ + +void CContainer::translateKey(MSG msg) +{ + if (!m_punk) + return; + + HRESULT hr; + IOleInPlaceActiveObject *pao; + + hr = m_punk->QueryInterface(IID_IOleInPlaceActiveObject, (PVOID *)&pao); + if (FAILED(hr)) + return; + + pao->TranslateAccelerator(&msg); + pao->Release(); +} + +/************************************************************************** + + * CContainer::getDispatch() + +**************************************************************************/ + +IDispatch * CContainer::getDispatch() +{ + if (!m_punk) + return NULL; + + IDispatch *pdisp; + m_punk->QueryInterface(IID_IDispatch, (PVOID *)&pdisp); + return pdisp; +} + +/************************************************************************** + + * CContainer::getUnknown() + +**************************************************************************/ + +IUnknown * CContainer::getUnknown() +{ + if (!m_punk) + return NULL; + + m_punk->AddRef(); + return m_punk; +} + +void CContainer::setScrollbars(int scroll) +{ + m_scrollbars=scroll; +} + +// *********************************************************************** +// IDocHostUIHandler +// *********************************************************************** + +HRESULT CContainer::ShowContextMenu(DWORD dwID, POINT __RPC_FAR *ppt, IUnknown __RPC_FAR *pcmdtReserved, IDispatch __RPC_FAR *pdispReserved) +{ + return E_NOTIMPL; +} + +HRESULT CContainer::GetHostInfo(DOCHOSTUIINFO __RPC_FAR *pInfo) +{ + pInfo->dwFlags=0x00200000|(m_scrollbars?0:8); + return S_OK; +} + +HRESULT CContainer::ShowUI(DWORD dwID, IOleInPlaceActiveObject __RPC_FAR *pActiveObject, IOleCommandTarget __RPC_FAR *pCommandTarget, IOleInPlaceFrame __RPC_FAR *pFrame, IOleInPlaceUIWindow __RPC_FAR *pDoc) +{ + return E_NOTIMPL; +} + +HRESULT CContainer::HideUI(void) +{ + return E_NOTIMPL; +} + + +HRESULT CContainer::UpdateUI(void) +{ + return E_NOTIMPL; +} + + +HRESULT CContainer::OnDocWindowActivate(BOOL fActivate) +{ + return E_NOTIMPL; +} + + +HRESULT CContainer::OnFrameWindowActivate(BOOL fActivate) +{ + return E_NOTIMPL; +} + + +HRESULT CContainer::ResizeBorder(LPCRECT prcBorder, IOleInPlaceUIWindow __RPC_FAR *pUIWindow, BOOL fRameWindow) +{ + return E_NOTIMPL; +} + + +HRESULT CContainer::TranslateAccelerator(LPMSG lpMsg, const GUID __RPC_FAR *pguidCmdGroup, DWORD nCmdID) +{ + return E_NOTIMPL; +} + + +HRESULT CContainer::GetOptionKeyPath(LPOLESTR __RPC_FAR *pchKey, DWORD dw) +{ + return E_NOTIMPL; +} + + +HRESULT CContainer::GetDropTarget(IDropTarget __RPC_FAR *pDropTarget, IDropTarget __RPC_FAR *__RPC_FAR *ppDropTarget) +{ + return E_NOTIMPL; +} + + +HRESULT CContainer::GetExternal(IDispatch __RPC_FAR *__RPC_FAR *ppDispatch) +{ + *ppDispatch = winampExternal; + return S_OK; //E_NOTIMPL; +} + + +HRESULT CContainer::TranslateUrl(DWORD dwTranslate, OLECHAR __RPC_FAR *pchURLIn, OLECHAR __RPC_FAR *__RPC_FAR *ppchURLOut) +{ + return E_NOTIMPL; +} + + +HRESULT CContainer::FilterDataObject(IDataObject __RPC_FAR *pDO, IDataObject __RPC_FAR *__RPC_FAR *ppDORet) +{ + return E_NOTIMPL; +} + diff --git a/Src/Plugins/Library/ml_local/contnr.h b/Src/Plugins/Library/ml_local/contnr.h new file mode 100644 index 00000000..aa969591 --- /dev/null +++ b/Src/Plugins/Library/ml_local/contnr.h @@ -0,0 +1,153 @@ +/************************************************************************** + THIS CODE AND INFORMATION IS PROVIDED 'AS IS' WITHOUT WARRANTY OF + ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO + THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A + PARTICULAR PURPOSE. + + Copyright 1998 Microsoft Corporation. All Rights Reserved. +**************************************************************************/ + +/************************************************************************** + + File: contnr.h + + Description: This file contains the complete class specification of an + ActiveX control container. This purpose of this container + is to test a single control being hosted. + +**************************************************************************/ + +#ifndef _CONTAINER_H_ +#define _CONTAINER_H_ + +/************************************************************************** + #include statements +**************************************************************************/ + +#include <ocidl.h> +#include <mshtmhst.h> + +/************************************************************************** + class definitions +**************************************************************************/ + +class CContainer : public IOleClientSite, + public IOleInPlaceSite, + public IOleInPlaceFrame, + public IOleControlSite, + public IDocHostUIHandler, + public IDispatch +{ + private: + ULONG m_cRefs; // ref count + HWND m_hwnd; // window handle of the container + HWND m_hwndStatus; // status window handle + IUnknown *m_punk; // IUnknown of contained object + int m_scrollbars; + + int m_allowScripts, m_restrictAlreadySet; + + public: + CContainer(); + ~CContainer(); + + public: + // *** IUnknown Methods *** + STDMETHOD(QueryInterface)(REFIID riid, PVOID *ppvObject); + STDMETHOD_(ULONG, AddRef)(void); + STDMETHOD_(ULONG, Release)(void); + + // *** IOleClientSite Methods *** + STDMETHOD (SaveObject)(); + STDMETHOD (GetMoniker)(DWORD dwAssign, DWORD dwWhichMoniker, LPMONIKER *ppMk); + STDMETHOD (GetContainer)(LPOLECONTAINER *ppContainer); + STDMETHOD (ShowObject)(); + STDMETHOD (OnShowWindow)(BOOL fShow); + STDMETHOD (RequestNewObjectLayout)(); + + // *** IOleWindow Methods *** + STDMETHOD (GetWindow) (HWND * phwnd); + STDMETHOD (ContextSensitiveHelp) (BOOL fEnterMode); + + // *** IOleInPlaceSite Methods *** + STDMETHOD (CanInPlaceActivate) (void); + STDMETHOD (OnInPlaceActivate) (void); + STDMETHOD (OnUIActivate) (void); + STDMETHOD (GetWindowContext) (IOleInPlaceFrame ** ppFrame, IOleInPlaceUIWindow ** ppDoc, LPRECT lprcPosRect, LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo); + STDMETHOD (Scroll) (SIZE scrollExtent); + STDMETHOD (OnUIDeactivate) (BOOL fUndoable); + STDMETHOD (OnInPlaceDeactivate) (void); + STDMETHOD (DiscardUndoState) (void); + STDMETHOD (DeactivateAndUndo) (void); + STDMETHOD (OnPosRectChange) (LPCRECT lprcPosRect); + + // *** IOleInPlaceUIWindow Methods *** + STDMETHOD (GetBorder)(LPRECT lprectBorder); + STDMETHOD (RequestBorderSpace)(LPCBORDERWIDTHS lpborderwidths); + STDMETHOD (SetBorderSpace)(LPCBORDERWIDTHS lpborderwidths); + STDMETHOD (SetActiveObject)(IOleInPlaceActiveObject * pActiveObject, + LPCOLESTR lpszObjName); + + // *** IOleInPlaceFrame Methods *** + STDMETHOD (InsertMenus)(HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths); + STDMETHOD (SetMenu)(HMENU hmenuShared, HOLEMENU holemenu, HWND hwndActiveObject); + STDMETHOD (RemoveMenus)(HMENU hmenuShared); + STDMETHOD (SetStatusText)(LPCOLESTR pszStatusText); + STDMETHOD (EnableModeless)(BOOL fEnable); + STDMETHOD (TranslateAccelerator)(LPMSG lpmsg, WORD wID); + + // *** IOleControlSite Methods *** + STDMETHOD (OnControlInfoChanged)(void); + STDMETHOD (LockInPlaceActive)(BOOL fLock); + STDMETHOD (GetExtendedControl)(IDispatch **ppDisp); + STDMETHOD (TransformCoords)(POINTL *pptlHimetric, POINTF *pptfContainer, DWORD dwFlags); + STDMETHOD (TranslateAccelerator)(LPMSG pMsg, DWORD grfModifiers); + STDMETHOD (OnFocus)(BOOL fGotFocus); + STDMETHOD (ShowPropertyFrame)(void); + + // *** IDispatch Methods *** + STDMETHOD (GetIDsOfNames)(REFIID riid, OLECHAR FAR* FAR* rgszNames, unsigned int cNames, LCID lcid, DISPID FAR* rgdispid); + STDMETHOD (GetTypeInfo)(unsigned int itinfo, LCID lcid, ITypeInfo FAR* FAR* pptinfo); + STDMETHOD (GetTypeInfoCount)(unsigned int FAR * pctinfo); + STDMETHOD (Invoke)(DISPID dispid, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS FAR *pdispparams, VARIANT FAR *pvarResult, EXCEPINFO FAR * pexecinfo, unsigned int FAR *puArgErr); + + // *** IDocHostUIHandler Methods *** + STDMETHOD (ShowContextMenu)(DWORD dwID, POINT __RPC_FAR *ppt, IUnknown __RPC_FAR *pcmdtReserved, IDispatch __RPC_FAR *pdispReserved); + STDMETHOD (GetHostInfo)(DOCHOSTUIINFO __RPC_FAR *pInfo); + STDMETHOD (ShowUI)(DWORD dwID, IOleInPlaceActiveObject __RPC_FAR *pActiveObject, IOleCommandTarget __RPC_FAR *pCommandTarget, IOleInPlaceFrame __RPC_FAR *pFrame, IOleInPlaceUIWindow __RPC_FAR *pDoc); + STDMETHOD (HideUI)(void); + STDMETHOD (UpdateUI)(void); + STDMETHOD (OnDocWindowActivate)(BOOL fActivate); + STDMETHOD (OnFrameWindowActivate)(BOOL fActivate); + STDMETHOD (ResizeBorder)(LPCRECT prcBorder, IOleInPlaceUIWindow __RPC_FAR *pUIWindow, BOOL fRameWindow); + STDMETHOD (TranslateAccelerator)(LPMSG lpMsg, const GUID __RPC_FAR *pguidCmdGroup, DWORD nCmdID); + STDMETHOD (GetOptionKeyPath)(LPOLESTR __RPC_FAR *pchKey, DWORD dw); + STDMETHOD (GetDropTarget)(IDropTarget __RPC_FAR *pDropTarget, IDropTarget __RPC_FAR *__RPC_FAR *ppDropTarget); + STDMETHOD (GetExternal)(IDispatch __RPC_FAR *__RPC_FAR *ppDispatch); + STDMETHOD (TranslateUrl)(DWORD dwTranslate, OLECHAR __RPC_FAR *pchURLIn, OLECHAR __RPC_FAR *__RPC_FAR *ppchURLOut); + STDMETHOD (FilterDataObject)(IDataObject __RPC_FAR *pDO, IDataObject __RPC_FAR *__RPC_FAR *ppDORet); + + public: + void add(BSTR clsid); + void remove(); + void setParent(HWND hwndParent); + void setLocation(int x, int y, int width, int height); + + void setVisible(BOOL fVisible); + void setFocus(BOOL fFocus); + void setStatusWindow(HWND hwndStatus); + void translateKey(MSG msg); + void setScrollbars(int scroll); + + void setAllowScripts(int s) { m_allowScripts=s; } + int getAllowScripts() { return m_allowScripts; } + + int getRestrictAlreadySet() { return m_restrictAlreadySet; } + + IDispatch *getDispatch(); + IUnknown * getUnknown(); + + BOOL SetRect(RECT *prc); +}; + +#endif
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/db.h b/Src/Plugins/Library/ml_local/db.h new file mode 100644 index 00000000..76b2eca0 --- /dev/null +++ b/Src/Plugins/Library/ml_local/db.h @@ -0,0 +1,64 @@ +#ifndef NULLSOT_LOCALMEDIA_DB_H +#define NULLSOT_LOCALMEDIA_DB_H + +#define MAINTABLE_ID_FILENAME 0 +#define MAINTABLE_ID_TITLE 1 +#define MAINTABLE_ID_ARTIST 2 +#define MAINTABLE_ID_ALBUM 3 +#define MAINTABLE_ID_YEAR 4 +#define MAINTABLE_ID_GENRE 5 +#define MAINTABLE_ID_COMMENT 6 +#define MAINTABLE_ID_TRACKNB 7 +#define MAINTABLE_ID_LENGTH 8 //in seconds +#define MAINTABLE_ID_TYPE 9 //0=audio, 1=video +#define MAINTABLE_ID_LASTUPDTIME 10 // last time (seconds since 1970) of db update of this item +#define MAINTABLE_ID_LASTPLAY 11 // last time (seconds since 1970) of last play +#define MAINTABLE_ID_RATING 12 +#define MAINTABLE_ID_GRACENOTE_ID 14 +#define MAINTABLE_ID_PLAYCOUNT 15 // play count +#define MAINTABLE_ID_FILETIME 16 // file time +#define MAINTABLE_ID_FILESIZE 17 // file size, kilobytes +#define MAINTABLE_ID_BITRATE 18 // file bitratea, kbps + +#include "../nde/nde.h" +#include <map> +#include <string> + +// DataBase manipulations +class DB +{ +// construcotrs +public: + DB(); + ~DB(); + +// methods +public: + int Open(); + int Close(); + int Nuke(); + int AddColumn(char* metaKey, int type); // returns index of the new column or -1 on error +private: + BOOL Discover(void); + void ClearMap(void); + + +// properties +public: + void SetTableDir(const char* tableDir); + const char* GetTableDir(); + int GetColumnsCount(); + int GetColumnId(char *metaKey); // returns index of the column or -1 if can't find + +// fields +private: + char * tableDir; + Database db; + Table *table; + Scanner *sc; + + std::map< std::string, int> columnsMap; + +}; + +#endif //NULLSOT_LOCALMEDIA_DB_H
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/db_error.txt b/Src/Plugins/Library/ml_local/db_error.txt new file mode 100644 index 00000000..055cc656 --- /dev/null +++ b/Src/Plugins/Library/ml_local/db_error.txt @@ -0,0 +1,6 @@ +
+There was an error reading the local database. This could be due to the database becoming corrupted or having been removed.
+
+If the database files (main.dat and main.idx) have become corrupted then unless you have a back up, you will need to reset the database and then re-add any media files required back into the database.
+
+By resetting the database, any custom ratings and play counts not already stored in the media file(s) will be lost which also will have happened if the database was corrupted.
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/editinfo.cpp b/Src/Plugins/Library/ml_local/editinfo.cpp new file mode 100644 index 00000000..4242cbfe --- /dev/null +++ b/Src/Plugins/Library/ml_local/editinfo.cpp @@ -0,0 +1,816 @@ +#include "main.h" +#include "../Agave/Language/api_language.h" +#include "../nu/ListView.h" +#include "../Winamp/strutil.h" +#include "resource.h" +#include <time.h> +#define MAKESAFE(x) ((x)?(x):L"") + +extern W_ListView resultlist; +extern itemRecordListW itemCache; +volatile int no_lv_update = 0; +//////////////// info editor fun + + +// must be one of OUR item records (since we free it) +static void UpdateItemRecordFromDB(itemRecordW *song) +{ + // look in the database for the updated song info + EnterCriticalSection(&g_db_cs); + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + if (NDE_Scanner_LocateNDEFilename(s, MAINTABLE_ID_FILENAME, FIRST_RECORD, song->filename)) + { + // now we can actually update the itemCache itemRecordW from the value in the db + itemRecordW item = {0}; + itemRecordListW obj = {&item, 0, 1}; + ScannerRefToObjCacheNFNW(s, &obj, false); + + item.filename = song->filename; + song->filename = NULL; // set to NULL so freeRecord doesn't delete the filename string + + freeRecord(song); // delete old item + *song = item; // replace with our new (BETTER :) item + } + NDE_Table_DestroyScanner(g_table, s); + LeaveCriticalSection(&g_db_cs); +} + +//physically update metadata in a given file +int updateFileInfo(const wchar_t *filename, const wchar_t *metadata, wchar_t *data) +{ + extendedFileInfoStructW efis = { + filename, + metadata, + data ? data : L"", + data ? wcslen(data) : 0, + }; + return SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&efis, IPC_SET_EXTENDED_FILE_INFOW); +} + +static int m_upd_nb, m_stopped, m_upd_nb_all, m_upd_nb_cur; +static nde_scanner_t m_scanner; + +// sets part and parts to -1 or 0 on fail/missing (e.g. parts will be -1 on "1", but 0 on "1/") +void ParseIntSlashInt(wchar_t *string, int *part, int *parts) +{ + *part = -1; + *parts = -1; + + if (string && string[0]) + { + *part = _wtoi(string); + while (string && *string && *string != '/') + { + string++; + } + if (string && *string == '/') + { + string++; + *parts = _wtoi(string); + } + } +} + +// TODO: benski> can this copy-and-paste code be factored? +static INT_PTR CALLBACK updateFiles_dialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + switch (uMsg) + { + case WM_INITDIALOG: + { + SetWindowTextW(hwndDlg, WASABI_API_LNG->GetStringW(WASABI_API_LNG->FindDllHandleByGUID(WinampLangGUID), + GetModuleHandleW(L"winamp.exe"), IDS_UPDATING_FILES)); + SetWindowLong(GetDlgItem(hwndDlg, IDC_STATUS), GWL_STYLE, (GetWindowLong(GetDlgItem(hwndDlg, IDC_STATUS), GWL_STYLE)&~SS_CENTER) | SS_LEFTNOWORDWRAP); + SetTimer(hwndDlg, 0x123, 30, NULL); + m_upd_nb = 0; + EnterCriticalSection(&g_db_cs); + m_scanner = NDE_Table_CreateScanner(g_table); + m_stopped = 0; + SendDlgItemMessage(hwndDlg, IDC_PROGRESS1, PBM_SETRANGE, 0, MAKELPARAM(0, m_upd_nb_all)); + m_upd_nb_cur = 0; + + // show window and restore last position as applicable + POINT pt = {g_config->ReadInt(L"scan_x", -1), g_config->ReadInt(L"scan_y", -1)}; + if (!windowOffScreen(hwndDlg, pt)) + SetWindowPos(hwndDlg, HWND_TOP, pt.x, pt.y, 0, 0, SWP_NOSIZE | SWP_SHOWWINDOW | SWP_NOSENDCHANGING); + + break; + } + case WM_TIMER: + if (wParam == 0x123 && !m_stopped) + { + unsigned int start_t = GetTickCount(); +again: + { + int l = resultlist.GetCount(); + + while (m_upd_nb < l && !resultlist.GetSelected(m_upd_nb)) + m_upd_nb++; + + if (m_upd_nb >= l) + { + //done + EndDialog(hwndDlg, 1); + break; + } + + int i = m_upd_nb++; + + itemRecordW *song = itemCache.Items + i; + HWND hwndParent = GetParent(hwndDlg); + + wchar_t stattmp[512] = {0}; + wchar_t *p = scanstr_backW(song->filename, L"\\", song->filename - 1) + 1; + wsprintfW(stattmp, WASABI_API_LNG->GetStringW(WASABI_API_LNG->FindDllHandleByGUID(WinampLangGUID), + GetModuleHandleW(L"winamp.exe"), IDS_UPDATING_X), p); + SetDlgItemTextW(hwndDlg, IDC_STATUS, stattmp); + + SendDlgItemMessage(hwndDlg, IDC_PROGRESS1, PBM_SETPOS, m_upd_nb_cur, 0); + m_upd_nb_cur++; + + int updtagz = !!IsDlgButtonChecked(hwndParent, IDC_CHECK1); + if (!NDE_Scanner_LocateNDEFilename(m_scanner, MAINTABLE_ID_FILENAME, FIRST_RECORD, song->filename)) + { + break; + } + + NDE_Scanner_Edit(m_scanner); + +#define CHECK_AND_COPY(IDCHECK, ID, field, item) if (IsDlgButtonChecked(hwndParent, IDCHECK)) {\ + wchar_t blah[2048] = {0}; GetDlgItemTextW(hwndParent, ID, blah, 2048);\ + if (wcscmp(MAKESAFE(item), blah))\ + { if (blah[0]) db_setFieldStringW(m_scanner, field, blah);\ + else db_removeField(m_scanner, field);\ + ndestring_release(item);\ + item = ndestring_wcsdup(blah);}} + + CHECK_AND_COPY(IDC_CHECK_ARTIST, IDC_EDIT_ARTIST, MAINTABLE_ID_ARTIST, song->artist); + CHECK_AND_COPY(IDC_CHECK_TITLE, IDC_EDIT_TITLE, MAINTABLE_ID_TITLE, song->title); + CHECK_AND_COPY(IDC_CHECK_ALBUM, IDC_EDIT_ALBUM, MAINTABLE_ID_ALBUM, song->album); + CHECK_AND_COPY(IDC_CHECK_COMMENT, IDC_EDIT_COMMENT, MAINTABLE_ID_COMMENT, song->comment); + CHECK_AND_COPY(IDC_CHECK_GENRE, IDC_EDIT_GENRE, MAINTABLE_ID_GENRE, song->genre); + CHECK_AND_COPY(IDC_CHECK_ALBUMARTIST, IDC_EDIT_ALBUMARTIST, MAINTABLE_ID_ALBUMARTIST, song->albumartist); + CHECK_AND_COPY(IDC_CHECK_PUBLISHER, IDC_EDIT_PUBLISHER, MAINTABLE_ID_PUBLISHER, song->publisher); + CHECK_AND_COPY(IDC_CHECK_COMPOSER, IDC_EDIT_COMPOSER, MAINTABLE_ID_COMPOSER, song->composer); + CHECK_AND_COPY(IDC_CHECK_CATEGORY, IDC_EDIT_CATEGORY, MAINTABLE_ID_CATEGORY, song->category); + +#define CHECK_AND_COPY_EXTENDED(IDCHECK, ID, field, name) if (IsDlgButtonChecked(hwndParent, IDCHECK)) {\ + wchar_t blah[2048] = {0}; GetDlgItemTextW(hwndParent, ID, blah, 2048);\ + wchar_t *oldData = getRecordExtendedItem_fast(song, name);\ + if (wcscmp(MAKESAFE(oldData), blah))\ + { if (blah[0]) db_setFieldStringW(m_scanner, field, blah);\ + else db_removeField(m_scanner, field);\ + wchar_t *nde_blah = ndestring_wcsdup(blah);\ + setRecordExtendedItem(song, name, nde_blah);\ + ndestring_release(nde_blah);}} + + CHECK_AND_COPY_EXTENDED(IDC_CHECK_DIRECTOR, IDC_EDIT_DIRECTOR, MAINTABLE_ID_DIRECTOR, extended_fields.director); + CHECK_AND_COPY_EXTENDED(IDC_CHECK_PRODUCER, IDC_EDIT_PRODUCER, MAINTABLE_ID_PRODUCER, extended_fields.producer); + CHECK_AND_COPY_EXTENDED(IDC_CHECK_PODCAST_CHANNEL, IDC_EDIT_PODCAST_CHANNEL, MAINTABLE_ID_PODCASTCHANNEL, extended_fields.podcastchannel); + +#define CHECK_AND_COPY_EXTENDED_PC(IDCHECK, field, name) \ + wchar_t blah[2048] = {0}; StringCchPrintfW(blah, 2048, L"%d", (IsDlgButtonChecked(hwndParent, IDCHECK) == BST_CHECKED));\ + wchar_t *oldData = getRecordExtendedItem_fast(song, name);\ + if (wcscmp(MAKESAFE(oldData), blah))\ + { if (blah[0]) db_setFieldInt(m_scanner, field, _wtoi(blah));\ + else db_removeField(m_scanner, field);\ + wchar_t *nde_blah = ndestring_wcsdup(blah);\ + setRecordExtendedItem(song, name, nde_blah);\ + ndestring_release(nde_blah);} + + CHECK_AND_COPY_EXTENDED_PC(IDC_CHECK_PODCAST, MAINTABLE_ID_ISPODCAST, extended_fields.ispodcast); + + if (IsDlgButtonChecked(hwndParent, IDC_CHECK_TRACK)) + { + wchar_t blah[64] = {0}; + GetDlgItemTextW(hwndParent, IDC_EDIT_TRACK, blah, 64); + int track, tracks; + ParseIntSlashInt(blah, &track, &tracks); + if (tracks <= 0) tracks = -1; + if (track <= 0) track = -1; + + if (song->track != track || song->tracks != tracks) + { + if (track>0) db_setFieldInt(m_scanner, MAINTABLE_ID_TRACKNB, track); + else db_removeField(m_scanner, MAINTABLE_ID_TRACKNB); + if (tracks>0) db_setFieldInt(m_scanner, MAINTABLE_ID_TRACKS, tracks); + else db_removeField(m_scanner, MAINTABLE_ID_TRACKS); + song->track = track; + song->tracks = tracks; + } + } + + if (IsDlgButtonChecked(hwndParent, IDC_CHECK_DISC)) + { + wchar_t blah[64] = {0}; + GetDlgItemTextW(hwndParent, IDC_EDIT_DISC, blah, 64); + int disc, discs; + ParseIntSlashInt(blah, &disc, &discs); + if (discs <= 0) discs = -1; + if (disc <= 0) disc = -1; + + if (song->disc != disc || song->discs != discs) + { + if (disc>0) db_setFieldInt(m_scanner, MAINTABLE_ID_DISC, disc); + else db_removeField(m_scanner, MAINTABLE_ID_DISC); + if (discs>0) db_setFieldInt(m_scanner, MAINTABLE_ID_DISCS, discs); + else db_removeField(m_scanner, MAINTABLE_ID_DISCS); + song->disc = disc; + song->discs = discs; + } + } + + if (IsDlgButtonChecked(hwndParent, IDC_CHECK_YEAR)) + { + wchar_t blah[64] = {0}; + GetDlgItemText(hwndParent, IDC_EDIT_YEAR, blah, 64); + int n = _wtoi(blah); + if (n <= 0) n = -1; + if (song->year != n) + { + if (n > 0) db_setFieldInt(m_scanner, MAINTABLE_ID_YEAR, n); + else db_removeField(m_scanner, MAINTABLE_ID_YEAR); + song->year = n; + } + } + + if (IsDlgButtonChecked(hwndParent, IDC_CHECK_BPM)) + { + wchar_t blah[64] = {0}; + GetDlgItemText(hwndParent, IDC_EDIT_BPM, blah, 64); + int n = _wtoi(blah); + if (n <= 0) n = -1; + if (song->bpm != n) + { + if (n > 0) db_setFieldInt(m_scanner, MAINTABLE_ID_BPM, n); + else db_removeField(m_scanner, MAINTABLE_ID_BPM); + song->bpm = n; + } + } + + if (IsDlgButtonChecked(hwndParent, IDC_CHECK_RATING)) + { + int n = SendDlgItemMessage(hwndParent, IDC_COMBO_RATING, CB_GETCURSEL, 0, 0), rating = -1; + if (n != CB_ERR && (n >= 0 && n < 5)) + { + rating = 5 - n; + } + /*int n = atoi(blah); + if (n < 0 || n > 5) n = -1;*/ + if (song->rating != rating) + { + if (rating > 0) db_setFieldInt(m_scanner, MAINTABLE_ID_RATING, n); + else db_removeField(m_scanner, MAINTABLE_ID_RATING); + song->rating = rating; + } + } + + if (updtagz) + { + m_stopped = 1; +retry: + if (updateFileInfo(song->filename, DB_FIELDNAME_title, song->title)) // if this returns 0, then this format doesnt even support extended + { + updateFileInfo(song->filename, DB_FIELDNAME_artist, song->artist); + updateFileInfo(song->filename, DB_FIELDNAME_album, song->album); + updateFileInfo(song->filename, DB_FIELDNAME_comment, song->comment); + updateFileInfo(song->filename, DB_FIELDNAME_genre, song->genre); + + wchar_t buf[32] = {0}; + if (song->track > 0) + { + if (song->tracks > 0) + wsprintfW(buf, L"%d/%d", song->track, song->tracks); + else + wsprintfW(buf, L"%d", song->track); + } + else buf[0] = 0; + updateFileInfo(song->filename, DB_FIELDNAME_track, buf); + + if (song->year > 0) wsprintfW(buf, L"%d", song->year); + else buf[0] = 0; + updateFileInfo(song->filename, DB_FIELDNAME_year, buf); + + if (song->disc > 0) + { + if (song->discs > 0) + wsprintfW(buf, L"%d/%d", song->disc, song->discs); + else + wsprintfW(buf, L"%d", song->disc); + } + else buf[0] = 0; + updateFileInfo(song->filename, DB_FIELDNAME_disc, buf); + + if (song->rating > 0) wsprintfW(buf, L"%d", song->rating); + else buf[0] = 0; + updateFileInfo(song->filename, DB_FIELDNAME_rating, buf); + + if (song->bpm > 0) wsprintfW(buf, L"%d", song->bpm); + else buf[0] = 0; + updateFileInfo(song->filename, DB_FIELDNAME_bpm, buf); + + updateFileInfo(song->filename, DB_FIELDNAME_albumartist, song->albumartist); + updateFileInfo(song->filename, DB_FIELDNAME_publisher, song->publisher); + updateFileInfo(song->filename, DB_FIELDNAME_composer, song->composer); + updateFileInfo(song->filename, DB_FIELDNAME_category, song->category); + updateFileInfo(song->filename, DB_FIELDNAME_director, getRecordExtendedItem_fast(song, extended_fields.director)); + updateFileInfo(song->filename, DB_FIELDNAME_producer, getRecordExtendedItem_fast(song, extended_fields.producer)); + + if (!SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_WRITE_EXTENDED_FILE_INFO)) + { + wchar_t tmp[1024] = {0}; + wsprintfW(tmp, WASABI_API_LNG->GetStringW(WASABI_API_LNG->FindDllHandleByGUID(WinampLangGUID), + GetModuleHandleW(L"winamp.exe"), IDS_ERROR_UPDATING_FILE), song->filename); + int ret = MessageBoxW(hwndDlg, tmp, WASABI_API_LNG->GetStringW(WASABI_API_LNG->FindDllHandleByGUID(WinampLangGUID), + GetModuleHandleW(L"winamp.exe"), IDS_INFO_UPDATING_ERROR), MB_RETRYCANCEL); + if (ret == IDRETRY) goto retry; + if (ret == IDCANCEL) + { + EndDialog(hwndDlg, 0); + break; + } + } + } + m_stopped = 0; + } + + db_setFieldInt(m_scanner, MAINTABLE_ID_LASTUPDTIME, (int)time(NULL)); + db_setFieldInt(m_scanner, MAINTABLE_ID_FILETIME, (int)time(NULL)); + NDE_Scanner_Post(m_scanner); + + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_UPDATED, (size_t)song->filename, 0); + } + if (GetTickCount() - start_t < 30) goto again; + } + break; + case WM_COMMAND: + if (LOWORD(wParam) == IDCANCEL) + { + EndDialog(hwndDlg, 0); + } + break; + case WM_DESTROY: + { + RECT scan_rect = {0}; + GetWindowRect(hwndDlg, &scan_rect); + g_config->WriteInt(L"scan_x", scan_rect.left); + g_config->WriteInt(L"scan_y", scan_rect.top); + + NDE_Table_DestroyScanner(g_table, m_scanner); + NDE_Table_Sync(g_table); + g_table_dirty = 0; + LeaveCriticalSection(&g_db_cs); + break; + } + } + return FALSE; +} + +static int checkEditInfoClick(HWND hwndDlg, POINT p, int item, int check) +{ + RECT r = {0}; + GetWindowRect(GetDlgItem(hwndDlg, item), &r); + ScreenToClient(hwndDlg, (LPPOINT)&r); + ScreenToClient(hwndDlg, (LPPOINT)&r.right); + if (PtInRect(&r, p) && !IsDlgButtonChecked(hwndDlg, check)) + { + CheckDlgButton(hwndDlg, check, TRUE); + if (item == IDC_COMBO_RATING) SendDlgItemMessage(hwndDlg, IDC_COMBO_RATING, CB_SHOWDROPDOWN, TRUE, 0); + EnableWindow(GetDlgItem(hwndDlg, item), TRUE); + EnableWindow(GetDlgItem(hwndDlg, IDOK), TRUE); + PostMessageW(hwndDlg, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hwndDlg, item), (LPARAM)TRUE); + return 1; + } + return 0; +} + +void getViewport(RECT *r, HWND wnd, int full, RECT *sr) +{ + POINT *p = NULL; + if (p || sr || wnd) + { + HMONITOR hm = NULL; + + if (sr) + hm = MonitorFromRect(sr, MONITOR_DEFAULTTONEAREST); + else if (wnd) + hm = MonitorFromWindow(wnd, MONITOR_DEFAULTTONEAREST); + else if (p) + hm = MonitorFromPoint(*p, MONITOR_DEFAULTTONEAREST); + + if (hm) + { + MONITORINFOEXW mi; + memset(&mi, 0, sizeof(mi)); + mi.cbSize = sizeof(mi); + + if (GetMonitorInfoW(hm, &mi)) + { + if (!full) + *r = mi.rcWork; + else + *r = mi.rcMonitor; + return ; + } + } + } + if (full) + { // this might be borked =) + r->top = r->left = 0; + r->right = GetSystemMetrics(SM_CXSCREEN); + r->bottom = GetSystemMetrics(SM_CYSCREEN); + } + else + { + SystemParametersInfoW(SPI_GETWORKAREA, 0, r, 0); + } +} + +BOOL windowOffScreen(HWND hwnd, POINT pt) +{ + RECT r = {0}, wnd = {0}, sr = {0}; + GetWindowRect(hwnd, &wnd); + sr.left = pt.x; + sr.top = pt.y; + sr.right = sr.left + (wnd.right - wnd.left); + sr.bottom = sr.top + (wnd.bottom - wnd.top); + getViewport(&r, hwnd, 0, &sr); + return !PtInRect(&r, pt); +} + +// TODO: benski> can this copy-and-paste code be factored? +static INT_PTR CALLBACK editInfo_dialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + switch (uMsg) + { + case WM_INITDIALOG: + { + wchar_t *last_artist = NULL, *last_title = NULL, *last_album = NULL, *last_genre = NULL, + *last_comment = NULL, *last_albumartist = NULL, *last_composer = NULL, + *last_publisher = NULL, *last_ispodcast = NULL, *last_podcastchannel = NULL; + const wchar_t *last_category = NULL, *last_director = NULL, *last_producer = NULL; + int last_year = -1, last_track = -1, last_disc = -1, last_discs = -1, last_tracks = -1, + last_bpm = -1, last_rating = -1, disable_artist = 0, disable_title = 0, + disable_album = 0, disable_genre = 0, disable_year = 0, disable_track = 0, + disable_comment = 0, disable_disc = 0, disable_albumartist = 0, disable_composer = 0, + disable_publisher = 0, disable_discs = 0, disable_tracks = 0, disable_category = 0, + disable_director = 0, disable_producer = 0, disable_bpm = 0, disable_rating = 0, + disable_ispodcast = 0, disable_podcastchannel = 0, nb = 0; + + if (g_config->ReadInt(L"upd_tagz", 1)) CheckDlgButton(hwndDlg, IDC_CHECK1, BST_CHECKED); + + EnableWindow(GetDlgItem(hwndDlg, IDOK), FALSE); + + SendDlgItemMessageW(hwndDlg, IDC_COMBO_RATING, CB_ADDSTRING, 0, (LPARAM)L"\u2605\u2605\u2605\u2605\u2605"); + SendDlgItemMessageW(hwndDlg, IDC_COMBO_RATING, CB_ADDSTRING, 0, (LPARAM)L"\u2605\u2605\u2605\u2605"); + SendDlgItemMessageW(hwndDlg, IDC_COMBO_RATING, CB_ADDSTRING, 0, (LPARAM)L"\u2605\u2605\u2605"); + SendDlgItemMessageW(hwndDlg, IDC_COMBO_RATING, CB_ADDSTRING, 0, (LPARAM)L"\u2605\u2605"); + SendDlgItemMessageW(hwndDlg, IDC_COMBO_RATING, CB_ADDSTRING, 0, (LPARAM)L"\u2605"); + SendDlgItemMessageW(hwndDlg, IDC_COMBO_RATING, CB_ADDSTRING, 0, + (LPARAM)WASABI_API_LNG->GetStringW(WASABI_API_LNG->FindDllHandleByGUID(WinampLangGUID), + GetModuleHandleW(L"winamp.exe"), IDS_NO_RATING)); + + for (int i = 0; i < resultlist.GetCount(); i++) + { + if (!resultlist.GetSelected(i)) continue; + + itemRecordW *song = itemCache.Items + i; + +#define SAVE_LAST_STR(last, check, disable) if (!disable && check && check[0]) { if (!last) last = check; else if (wcscmp(check, last)) disable = 1; } +#define SAVE_LAST_INT(last, check, disable) if (!disable && check > 0) { if (last == -1) last = check; else if (last != check) disable = 1; } + + SAVE_LAST_STR(last_artist, song->artist, disable_artist); + SAVE_LAST_STR(last_title, song->title, disable_title); + SAVE_LAST_STR(last_album, song->album, disable_album); + SAVE_LAST_STR(last_comment, song->comment, disable_comment); + SAVE_LAST_STR(last_genre, song->genre, disable_genre); + + SAVE_LAST_INT(last_year, song->year, disable_year); + SAVE_LAST_INT(last_track, song->track, disable_track); + SAVE_LAST_INT(last_tracks, song->tracks, disable_tracks); + SAVE_LAST_INT(last_disc, song->disc, disable_disc); + SAVE_LAST_INT(last_discs, song->discs, disable_discs); + SAVE_LAST_INT(last_rating, song->rating, disable_rating); + SAVE_LAST_INT(last_bpm, song->bpm, disable_bpm); + + SAVE_LAST_STR(last_albumartist, song->albumartist, disable_albumartist); + SAVE_LAST_STR(last_composer, song->composer, disable_composer); + SAVE_LAST_STR(last_publisher, song->publisher, disable_publisher); + SAVE_LAST_STR(last_category, song->category, disable_category); + +#define SAVE_LAST_STR_EXTENDED(last, name, disable) if (!disable) { wchar_t *check = getRecordExtendedItem_fast(song, name); if (check && check[0]) { if (!last) last = check; else if (wcscmp(check, last)) disable = 1; }}; + + SAVE_LAST_STR_EXTENDED(last_director, extended_fields.director, disable_director); + SAVE_LAST_STR_EXTENDED(last_producer, extended_fields.producer, disable_producer); + SAVE_LAST_STR_EXTENDED(last_podcastchannel, extended_fields.podcastchannel, disable_podcastchannel); + SAVE_LAST_STR_EXTENDED(last_ispodcast, extended_fields.ispodcast, disable_ispodcast); + nb++; + } + + if (!disable_artist && last_artist) SetDlgItemTextW(hwndDlg, IDC_EDIT_ARTIST, last_artist); + if (!disable_title && last_title) SetDlgItemTextW(hwndDlg, IDC_EDIT_TITLE, last_title); + if (!disable_album && last_album) SetDlgItemTextW(hwndDlg, IDC_EDIT_ALBUM, last_album); + if (!disable_comment && last_comment) SetDlgItemTextW(hwndDlg, IDC_EDIT_COMMENT, last_comment); + if (!disable_albumartist && last_albumartist) SetDlgItemTextW(hwndDlg, IDC_EDIT_ALBUMARTIST, last_albumartist); + if (!disable_composer && last_composer) SetDlgItemTextW(hwndDlg, IDC_EDIT_COMPOSER, last_composer); + if (!disable_publisher && last_publisher) SetDlgItemTextW(hwndDlg, IDC_EDIT_PUBLISHER, last_publisher); + if (!disable_genre && last_genre) SetDlgItemTextW(hwndDlg, IDC_EDIT_GENRE, last_genre); + if (!disable_category && last_category) SetDlgItemTextW(hwndDlg, IDC_EDIT_CATEGORY, last_category); + if (!disable_director && last_director) SetDlgItemTextW(hwndDlg, IDC_EDIT_DIRECTOR, last_director); + if (!disable_producer && last_producer) SetDlgItemTextW(hwndDlg, IDC_EDIT_PRODUCER, last_producer); + if (!disable_podcastchannel && last_podcastchannel) SetDlgItemTextW(hwndDlg, IDC_EDIT_PODCAST_CHANNEL, last_podcastchannel); + if (!disable_ispodcast && last_ispodcast) + { + CheckDlgButton(hwndDlg, IDC_CHECK_PODCAST, (_wtoi(last_ispodcast) == 1 ? BST_CHECKED : BST_UNCHECKED)); + } + if (!disable_year && last_year > 0) + { + wchar_t tmp[64] = {0}; + wsprintfW(tmp, L"%d", last_year); + SetDlgItemTextW(hwndDlg, IDC_EDIT_YEAR, tmp); + } + if (!disable_bpm && last_bpm > 0) + { + wchar_t tmp[64] = {0}; + wsprintfW(tmp, L"%d", last_bpm); + SetDlgItemTextW(hwndDlg, IDC_EDIT_BPM, tmp); + } + if (!disable_rating) + { + if (last_rating > 0 && last_rating <= 5) + { + SendDlgItemMessage(hwndDlg, IDC_COMBO_RATING, CB_SETCURSEL, 5 - last_rating, 0); + } + else SendDlgItemMessage(hwndDlg, IDC_COMBO_RATING, CB_SETCURSEL, 5, 0); + } + if (!disable_track && last_track > 0 && !disable_tracks) + { + wchar_t tmp[64] = {0}; + if (!disable_tracks && last_tracks > 0) + wsprintfW(tmp, L"%d/%d", last_track, last_tracks); + else + wsprintfW(tmp, L"%d", last_track); + SetDlgItemTextW(hwndDlg, IDC_EDIT_TRACK, tmp); + } + if (!disable_disc && last_disc > 0 + && !disable_discs) + { + wchar_t tmp[64] = {0}; + if (!disable_discs && last_discs > 0) + wsprintfW(tmp, L"%d/%d", last_disc, last_discs); + else + wsprintfW(tmp, L"%d", last_disc); + SetDlgItemTextW(hwndDlg, IDC_EDIT_DISC, tmp); + } + wchar_t tmp[512] = {0}; + wsprintfW(tmp, WASABI_API_LNG->GetStringW(WASABI_API_LNG->FindDllHandleByGUID(WinampLangGUID), + GetModuleHandleW(L"winamp.exe"), (nb==1?IDS_X_ITEM_SELECTED:IDS_X_ITEMS_SELECTED)), nb); + SetDlgItemTextW(hwndDlg, IDC_HEADER, tmp); + m_upd_nb_all = nb; + + // show edit info window and restore last position as applicable + POINT pt = {g_config->ReadInt(L"edit_x", -1), g_config->ReadInt(L"edit_y", -1)}; + if (!windowOffScreen(hwndDlg, pt)) + SetWindowPos(hwndDlg, HWND_TOP, pt.x, pt.y, 0, 0, SWP_NOSIZE | SWP_SHOWWINDOW | SWP_NOSENDCHANGING); + } + return 1; + case WM_COMMAND: +#define HANDLE_CONTROL(item, check) { int enabled = IsDlgButtonChecked(hwndDlg, check); EnableWindow(GetDlgItem(hwndDlg, item), enabled); EnableWindow(GetDlgItem(hwndDlg, IDOK), enabled); } + switch (LOWORD(wParam)) + { + case IDC_CHECK_ARTIST: HANDLE_CONTROL(IDC_EDIT_ARTIST, IDC_CHECK_ARTIST); break; + case IDC_CHECK_TITLE: HANDLE_CONTROL(IDC_EDIT_TITLE, IDC_CHECK_TITLE); break; + case IDC_CHECK_ALBUM: HANDLE_CONTROL(IDC_EDIT_ALBUM, IDC_CHECK_ALBUM); break; + case IDC_CHECK_COMMENT: HANDLE_CONTROL(IDC_EDIT_COMMENT, IDC_CHECK_COMMENT); break; + case IDC_CHECK_ALBUMARTIST: HANDLE_CONTROL(IDC_EDIT_ALBUMARTIST, IDC_CHECK_ALBUMARTIST); break; + case IDC_CHECK_COMPOSER: HANDLE_CONTROL(IDC_EDIT_COMPOSER, IDC_CHECK_COMPOSER); break; + case IDC_CHECK_PUBLISHER: HANDLE_CONTROL(IDC_EDIT_PUBLISHER, IDC_CHECK_PUBLISHER); break; + case IDC_CHECK_TRACK: HANDLE_CONTROL(IDC_EDIT_TRACK, IDC_CHECK_TRACK); break; + case IDC_CHECK_DISC: HANDLE_CONTROL(IDC_EDIT_DISC, IDC_CHECK_DISC); break; + case IDC_CHECK_GENRE: HANDLE_CONTROL(IDC_EDIT_GENRE, IDC_CHECK_GENRE); break; + case IDC_CHECK_YEAR: HANDLE_CONTROL(IDC_EDIT_YEAR, IDC_CHECK_YEAR); break; + case IDC_CHECK_CATEGORY: HANDLE_CONTROL(IDC_EDIT_CATEGORY, IDC_CHECK_CATEGORY); break; + case IDC_CHECK_DIRECTOR: HANDLE_CONTROL(IDC_EDIT_DIRECTOR, IDC_CHECK_DIRECTOR); break; + case IDC_CHECK_PRODUCER: HANDLE_CONTROL(IDC_EDIT_PRODUCER, IDC_CHECK_PRODUCER); break; + case IDC_CHECK_PODCAST_CHANNEL: HANDLE_CONTROL(IDC_EDIT_PODCAST_CHANNEL, IDC_CHECK_PODCAST_CHANNEL); break; + case IDC_CHECK_BPM: HANDLE_CONTROL(IDC_EDIT_BPM, IDC_CHECK_BPM); break; + case IDC_CHECK_RATING: HANDLE_CONTROL(IDC_COMBO_RATING, IDC_CHECK_RATING); break; + case IDOK: + { + int updtagz = !!IsDlgButtonChecked(hwndDlg, IDC_CHECK1); + g_config->WriteInt(L"upd_tagz", updtagz); + int ret = WASABI_API_LNG->LDialogBoxParamW(WASABI_API_LNG->FindDllHandleByGUID(WinampLangGUID), + GetModuleHandleW(L"winamp.exe"), IDD_ADDSTUFF, + hwndDlg, (DLGPROC)updateFiles_dialogProc, 0); + ListView_RedrawItems(resultlist.getwnd(), 0, resultlist.GetCount() - 1); + if (!ret) break; + } + case IDCANCEL: + RECT edit_rect = {0}; + GetWindowRect(hwndDlg, &edit_rect); + g_config->WriteInt(L"edit_x", edit_rect.left); + g_config->WriteInt(L"edit_y", edit_rect.top); + EndDialog(hwndDlg, 0); + break; + } + break; + case WM_LBUTTONDOWN: + { + POINTS p = MAKEPOINTS(lParam); + POINT p2 = {p.x, p.y}; + if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_ARTIST, IDC_CHECK_ARTIST)) break; + if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_TITLE, IDC_CHECK_TITLE)) break; + if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_ALBUM, IDC_CHECK_ALBUM)) break; + if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_COMMENT, IDC_CHECK_COMMENT)) break; + if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_ALBUMARTIST, IDC_CHECK_ALBUMARTIST)) break; + if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_COMPOSER, IDC_CHECK_COMPOSER)) break; + if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_PUBLISHER, IDC_CHECK_PUBLISHER)) break; + if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_TRACK, IDC_CHECK_TRACK)) break; + if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_GENRE, IDC_CHECK_GENRE)) break; + if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_YEAR, IDC_CHECK_YEAR)) break; + if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_DISC, IDC_CHECK_DISC)) break; + if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_CATEGORY, IDC_CHECK_CATEGORY)) break; + if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_DIRECTOR, IDC_CHECK_DIRECTOR)) break; + if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_PRODUCER, IDC_CHECK_PRODUCER)) break; + if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_PODCAST_CHANNEL, IDC_CHECK_PODCAST_CHANNEL)) break; + if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_BPM, IDC_CHECK_BPM)) break; + if (checkEditInfoClick(hwndDlg, p2, IDC_COMBO_RATING, IDC_CHECK_RATING)) break; + } + break; + } + return FALSE; +} + +void editInfo(HWND hwndParent) +{ + no_lv_update++; + bgQuery_Stop(); + + WASABI_API_LNG->LDialogBoxParamW(WASABI_API_LNG->FindDllHandleByGUID(WinampLangGUID), + GetModuleHandleW(L"winamp.exe"), IDD_EDIT_INFO, + hwndParent, (DLGPROC)editInfo_dialogProc, 0); + + EatKeyboard(); + no_lv_update--; +} + +#define REFRESHCB_NUMITEMS (WM_USER) +#define REFRESHCB_ITERATE (WM_USER+1) +#define REFRESHCB_FINISH (WM_USER+2) +static bool refreshKill; +static int RefreshMetadataThread(HANDLE handle, void *_callback, intptr_t id) +{ + HWND callback = (HWND)_callback; + int l = resultlist.GetCount(); + PostMessage(callback, REFRESHCB_NUMITEMS, 0, resultlist.GetSelectedCount()); + for (int i = 0; i < l; i++) + { + if (refreshKill) + break; + if (!resultlist.GetSelected(i)) continue; + itemRecordW *song = itemCache.Items + i; + if (!song->filename || !song->filename[0]) continue; + + EnterCriticalSection(&g_db_cs); + int guess = -1, meta = -1, rec = 1; + autoscan_add_directory(song->filename, &guess, &meta, &rec, 1); // use this folder's guess/meta options + if (guess == -1) guess = g_config->ReadInt(L"guessmode", 0); + if (meta == -1) meta = g_config->ReadInt(L"usemetadata", 1); + + addFileToDb(song->filename, TRUE, meta, guess, 0, 0, true); + UpdateItemRecordFromDB(song); + + PostMessage(callback, REFRESHCB_ITERATE, 0, 0); + LeaveCriticalSection(&g_db_cs); + } + + PostMessage(callback, REFRESHCB_FINISH, 0, 0); + return 0; +} + +static void WriteStatus(HWND hwndDlg, int dlgId, int numFiles, int totalFiles) +{ + wchar_t temp[1024] = {0}; + if (numFiles + 1 > totalFiles) + WASABI_API_LNGSTRINGW_BUF(IDS_FINISHED, temp, 1024); + else + StringCchPrintfW(temp, 1024, WASABI_API_LNGSTRINGW(IDS_REFRESH_MESSAGE), numFiles + 1, totalFiles); + SetDlgItemTextW(hwndDlg, dlgId, temp); +} + +static int numFiles, totalFiles; +static INT_PTR WINAPI RefreshDlgProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam) +{ + switch (msg) + { + case WM_INITDIALOG: + { + numFiles = 0; + totalFiles = 0; + refreshKill = false; + WASABI_API_THREADPOOL->RunFunction(0, RefreshMetadataThread, (void *)hwndDlg, 0, api_threadpool::FLAG_LONG_EXECUTION); + + // show refresh info window and restore last position as applicable + POINT pt = {g_config->ReadInt(L"refresh_x", -1), g_config->ReadInt(L"refresh_y", -1)}; + if (!windowOffScreen(hwndDlg, pt)) + SetWindowPos(hwndDlg, HWND_TOP, pt.x, pt.y, 0, 0, SWP_NOSIZE | SWP_SHOWWINDOW | SWP_NOSENDCHANGING); + } + break; + case WM_DESTROY: + { + RECT refresh_rect = {0}; + GetWindowRect(hwndDlg, &refresh_rect); + g_config->WriteInt(L"refresh_x", refresh_rect.left); + g_config->WriteInt(L"refresh_y", refresh_rect.top); + } + break; + case REFRESHCB_NUMITEMS: + totalFiles = lParam; + WriteStatus(hwndDlg, IDC_REFRESHMETADATA_STATUS, numFiles, totalFiles); + break; + case REFRESHCB_ITERATE: + numFiles++; + WriteStatus(hwndDlg, IDC_REFRESHMETADATA_STATUS, numFiles, totalFiles); + break; + case REFRESHCB_FINISH: + EndDialog(hwndDlg, 0); + break; + case WM_COMMAND: + switch (LOWORD(wParam)) + { + case IDCANCEL: + refreshKill = true; + break; + } + break; + } + return 0; +} + +void RefreshMetadata(HWND parent) +{ + bgQuery_Stop(); + + WASABI_API_DIALOGBOXW(IDD_REFRESH_METADATA, parent, RefreshDlgProc); + ListView_RedrawItems(resultlist.getwnd(), 0, resultlist.GetCount() - 1); +} + +// when the rowcache is enabled, the filename pointers should be identical +void UpdateRating_RowCache(const wchar_t *filename, int new_rating) +{ + int itemcount = itemCache.Size; + for (int i = 0; i < itemcount; i++) + { + itemRecordW *song = itemCache.Items + i; + if (!song->filename || !song->filename[0]) continue; + if (song->filename == filename || !nde_wcsicmp_fn(song->filename,filename)) + { + song->rating = new_rating; + ListView_RedrawItems(resultlist.getwnd(), i, i); + break; + } + } +} + +void UpdateLocalResultsCache(const wchar_t *filename) // perhaps just a itemRecordW parm +{ + // Search thru the itemCache looking for the file that was changed + int itemcount = itemCache.Size; + for (int i = 0; i < itemcount; i++) + { + // TODO: linear search, yuck, look at this later + itemRecordW *song = itemCache.Items + i; + if (!song->filename || !song->filename[0]) continue; + if (nde_wcsicmp_fn(song->filename,filename) == 0) + { + UpdateItemRecordFromDB(song); + SetTimer(GetParent(resultlist.getwnd()), UPDATE_RESULT_LIST_TIMER_ID, 500, 0); + break; + } + } +} + +void fileInfoDialogs(HWND hwndParent) +{ + no_lv_update++; // this might block other attempts from going thru but that's OK + bgQuery_Stop(); + int l = resultlist.GetCount(), i; + int needref = 0; + for (i = 0;i < l;i++) + { + if (!resultlist.GetSelected(i)) continue; + itemRecordW *song = itemCache.Items + i; + if (!song->filename || !song->filename[0]) continue; + + infoBoxParamW p; + p.filename = song->filename; + p.parent = hwndParent; + if (SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&p, IPC_INFOBOXW)) break; + + needref = 1; + UpdateItemRecordFromDB(song); + } + EatKeyboard(); + if (needref) ListView_RedrawItems(resultlist.getwnd(), 0, resultlist.GetCount() - 1); + no_lv_update--; +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/editquery.cpp b/Src/Plugins/Library/ml_local/editquery.cpp new file mode 100644 index 00000000..e1d4ca23 --- /dev/null +++ b/Src/Plugins/Library/ml_local/editquery.cpp @@ -0,0 +1,1013 @@ +#include "main.h" +#include "ml_local.h" +#include <windowsx.h> +#include "editquery.h" +#include "../nde/NDE.h" +#include "resource.h" +#include "..\..\General\gen_ml/gaystring.h" +#include "time.h" +#include "../Agave/Language/api_language.h" +#include "../replicant/nu/AutoChar.h" +#define ListBox_GetTextLenW(hwndCtl, index) ((int)(DWORD)SendMessageW((hwndCtl), LB_GETTEXTLEN, (WPARAM)(int)(index), 0L)) +#define ListBox_GetTextW(hwndCtl, index, lpszBuffer) ((int)(DWORD)SendMessageW((hwndCtl), LB_GETTEXT, (WPARAM)(int)(index), (LPARAM)(LPCWSTR)(lpszBuffer))) + +int myatoi(wchar_t *p, int len) { + wchar_t *w = (wchar_t *)calloc((len+1), sizeof(wchar_t)); + if (w) + { + wcsncpy(w, p, len); + w[len] = 0; + int a = _wtoi(w); + free(w); + return a; + } + return 0; +} + +static wchar_t *monthtable[12] = {L"January", L"February", L"March", L"April", L"May", L"June", L"July", L"August", L"September", L"October", L"November", L"December" }; +INT_PTR CALLBACK editQueryDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam); +INT_PTR CALLBACK editDateTimeDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam); +static wchar_t *qe_field = NULL; + +static GayStringW qe_curquery; +static GayStringW qe_curexpr; +static GayStringW qe_origquery; +static GayStringW qe_curorigin; +static GayStringW qe_curdate; + +void qe_freeStuff() { + qe_curquery.Set(L""); + qe_curquery.Compact(); + qe_curexpr.Set(L""); + qe_curexpr.Compact(); + qe_curorigin.Set(L""); + qe_curorigin.Compact(); + qe_origquery.Set(L""); + qe_origquery.Compact(); +} + +static GayStringW te_ret; +static GayStringW te_result; +int te_cur_selected_month=0; + +const wchar_t *editTime(HWND wnd, const wchar_t *curfield) { + te_ret.Set(curfield); + + TimeParse tp; + NDE_Time_ApplyConversion(0, curfield, &tp); + + if (tp.relative_day == -2 || tp.relative_kwday != -1) { + wchar_t titleStr[64] = {0}; + int r = MessageBoxW(wnd, WASABI_API_LNGSTRINGW(IDS_DATE_TIME_IS_TOO_COMPLEX), + WASABI_API_LNGSTRINGW_BUF(IDS_DATE_TIME_EDITOR_QUESTION,titleStr,64), MB_YESNO); + if (r == IDNO) { + return curfield; + } + } + + INT_PTR r = WASABI_API_DIALOGBOXW(IDD_TIMEEDITOR, wnd, editDateTimeDialogProc); + if (r == IDOK) { + te_ret.Set(te_result.Get()); + return te_ret.Get(); + } + + return NULL; +} + +const wchar_t *editQuery(HWND wnd, const wchar_t *curquery, wchar_t *newQuery, size_t len) +{ + qe_field = NULL; + + qe_curquery.Set(curquery); + qe_origquery.Set(curquery); + + INT_PTR r = WASABI_API_DIALOGBOXW(IDD_EDIT_QUERY, wnd, editQueryDialogProc); + + if (qe_field) free(qe_field); + + if (r == IDOK) + { + lstrcpynW(newQuery, qe_curquery.Get(), len); + qe_freeStuff(); + return newQuery; + } + qe_freeStuff(); + return NULL; +} + +static bool FillListProc(Record *record, Field *entry, void *context) +{ + HWND hwndDlg = (HWND)context; + SendMessage(hwndDlg, LB_ADDSTRING, 0, (LPARAM)NDE_ColumnField_GetFieldName((nde_field_t)entry)); + return true; +} + +void qe_fillFieldsList( HWND hwndDlg ) +{ + ListBox_ResetContent( hwndDlg ); + + Record *cr = ( (Table *)g_table )->GetColumns(); // TODO: don't use C++ NDE API + if ( cr ) + { + cr->WalkFields( FillListProc, (void *)hwndDlg ); + } + + int len = ListBox_GetTextLenW( hwndDlg, 0 ); + + if ( qe_field != NULL ) + free( qe_field ); + + qe_field = (wchar_t *)calloc( ( len + 1 ), sizeof( wchar_t ) ); + ListBox_GetTextW( hwndDlg, 0, qe_field ); + + qe_field[ len ] = 0; + ListBox_SetCurSel( hwndDlg, 0 ); +} + +void qe_doEnableDisable( HWND hwndDlg, int *n, int num, int how ) +{ + for ( int i = 0; i < num; i++ ) + EnableWindow( GetDlgItem( hwndDlg, n[ i ] ), how ); +} + +void qe_enableDisableItem( HWND hwndDlg, int id, int tf ) +{ + EnableWindow( GetDlgItem( hwndDlg, id ), tf ); +} + +void qe_fallback( HWND hwndDlg, int disabling, int enabled ) +{ + if ( IsDlgButtonChecked( hwndDlg, disabling ) ) + { + CheckDlgButton( hwndDlg, disabling, BST_UNCHECKED ); + CheckDlgButton( hwndDlg, enabled, BST_CHECKED ); + } +} + +int ctrls_datetime[] = {IDC_STATIC_DATETIME, IDC_EDIT_DATETIME, IDC_BUTTON_EDITDATETIME, IDC_STATIC_CURDATETIME}; +int ctrls_datetime_base[] = {IDC_STATIC_DATETIME, IDC_CHECK_ABSOLUTE, IDC_CHECK_RELATIVE}; +int ctrls_datetime_relative[] = {IDC_CHECK_SELECTIVE, IDC_CHECK_TIMEAGO, IDC_STATIC_QUERYTIME, IDC_STATIC_RESULT}; +int ctrls_datetime_relative_ago[] = {IDC_STATIC_TIMEAGO, IDC_EDIT_TIMEAGO, IDC_RADIO_TIMEAGO_Y, + IDC_RADIO_TIMEAGO_H, IDC_RADIO_TIMEAGO_M, IDC_RADIO_TIMEAGO_MIN, IDC_RADIO_TIMEAGO_W, IDC_RADIO_TIMEAGO_S, + IDC_RADIO_TIMEAGO_D}; +int ctrls_datetime_relative_ago_direction[] = {IDC_STATIC_DIRECTION, IDC_RADIO_AFTER, IDC_RADIO_BEFORE}; +int ctrls_datetime_relative_selective[] = {IDC_STATIC_SELECTIVE, IDC_STATIC_YEAR, IDC_RADIO_THISYEAR, + IDC_RADIO_YEAR, IDC_EDIT_YEAR, IDC_STATIC_MONTH, IDC_RADIO_THISMONTH, IDC_RADIO_MONTH, IDC_BUTTON_MONTH, + IDC_STATIC_DAY, IDC_RADIO_THISDAY, IDC_RADIO_DAY, IDC_EDIT_DAY, IDC_STATIC_TIME, IDC_RADIO_THISTIME, + IDC_RADIO_TIME, IDC_RADIO_NOON, IDC_RADIO_MIDNIGHT, IDC_BUTTON_NOW, IDC_BUTTON_PICK, IDC_DATETIMEPICKER2}; +int ctrls_datetime_absolute[] = {IDC_STATIC_ABSOLUTE, IDC_DATETIMEPICKER, IDC_DATETIMEPICKER1, IDC_STATIC_RELATIVE}; +int ctrls_string_ops[] = {IDC_RADIO_ISLIKE, IDC_RADIO_BEGINS, IDC_RADIO_ENDS, IDC_RADIO_CONTAINS}; + +int ctrls_string[] = {IDC_STATIC_STRING, IDC_EDIT_STRING}; + +void qe_showHideOperators(HWND hwndDlg) { + if (!qe_curquery.Get() || !*qe_curquery.Get()) { + ShowWindow(GetDlgItem(hwndDlg, IDC_BUTTON_AND), SW_HIDE); + ShowWindow(GetDlgItem(hwndDlg, IDC_BUTTON_OR), SW_HIDE); + ShowWindow(GetDlgItem(hwndDlg, ID_BUTTON_SENDTOQUERY), SW_SHOW); + } else { + ShowWindow(GetDlgItem(hwndDlg, IDC_BUTTON_AND), SW_SHOW); + ShowWindow(GetDlgItem(hwndDlg, IDC_BUTTON_OR), SW_SHOW); + ShowWindow(GetDlgItem(hwndDlg, ID_BUTTON_SENDTOQUERY), SW_HIDE); + } +} + +void qe_updateResultingDate(HWND hwndDlg) { + if (IsWindowEnabled(GetDlgItem(hwndDlg, IDC_EDIT_DATETIME)) && !IsDlgButtonChecked(hwndDlg, IDC_RADIO_ISEMPTY)) { + time_t t = NDE_Time_ApplyConversion(0, qe_curdate.Get(), 0); + struct tm *ts = localtime(&t); + wchar_t qe_tempstr[4096] = {0}; + if (ts) + wsprintfW(qe_tempstr, L"%02d/%d/%04d %02d:%02d:%02d", ts->tm_mon+1, ts->tm_mday, ts->tm_year+1900, ts->tm_hour, ts->tm_min, ts->tm_sec); + else + wcsncpy(qe_tempstr, L"DATE_OUTOFRANGE", 4096); + SetDlgItemTextW(hwndDlg, IDC_STATIC_CURDATETIME, qe_tempstr); + } else { + SetDlgItemTextW(hwndDlg, IDC_STATIC_CURDATETIME, L"N/A"); + } +} + +void te_updateResultingDate(HWND hwndDlg) { + if (IsDlgButtonChecked(hwndDlg, IDC_CHECK_RELATIVE)) { + time_t t = NDE_Time_ApplyConversion(0, qe_curorigin.Get(), 0); + struct tm *ts = localtime(&t); + wchar_t qe_tempstr[4096] = {0}; + if (ts) + wsprintfW(qe_tempstr, L"%02d/%d/%04d %02d:%02d:%02d", ts->tm_mon+1, ts->tm_mday, ts->tm_year+1900, ts->tm_hour, ts->tm_min, ts->tm_sec); + else + wcsncpy(qe_tempstr, L"DATE_OUTOFRANGE", 4096); + SetDlgItemTextW(hwndDlg, IDC_STATIC_QUERYTIME, qe_tempstr); + } else { + SetDlgItemTextW(hwndDlg, IDC_STATIC_QUERYTIME, L"N/A"); + } +} + +void qe_enableDisable(HWND hwndDlg) { + if (!*qe_field) return; + nde_field_t field = NDE_Table_GetColumnByName(g_table, AutoChar(qe_field)); + if (!field) return; + int type = NDE_ColumnField_GetDataType(field); + + qe_showHideOperators(hwndDlg); + + switch (type) { + case FIELD_DATETIME: { + qe_fallback(hwndDlg, IDC_RADIO_ISLIKE, IDC_RADIO_EQUAL); + qe_fallback(hwndDlg, IDC_RADIO_BEGINS, IDC_RADIO_EQUAL); + qe_fallback(hwndDlg, IDC_RADIO_ENDS, IDC_RADIO_EQUAL); + qe_fallback(hwndDlg, IDC_RADIO_CONTAINS, IDC_RADIO_EQUAL); + qe_doEnableDisable(hwndDlg, ctrls_string, sizeof(ctrls_string)/sizeof(int), 0); + qe_doEnableDisable(hwndDlg, ctrls_string_ops, sizeof(ctrls_string_ops)/sizeof(int), 0); + SetDlgItemTextW(hwndDlg,IDC_STATIC_STRING,WASABI_API_LNGSTRINGW(IDS_COMPARE_TO_STRING)); + qe_doEnableDisable(hwndDlg, ctrls_datetime, sizeof(ctrls_datetime)/sizeof(int), 1); + SetDlgItemTextW(hwndDlg, IDC_RADIO_ABOVE, WASABI_API_LNGSTRINGW(IDS_AFTER)); + SetDlgItemTextW(hwndDlg, IDC_RADIO_BELOW, WASABI_API_LNGSTRINGW(IDS_BEFORE)); + SetDlgItemTextW(hwndDlg, IDC_RADIO_ABOVEOREQUAL, WASABI_API_LNGSTRINGW(IDS_SINCE)); + SetDlgItemTextW(hwndDlg, IDC_RADIO_BELOWOREQUAL, WASABI_API_LNGSTRINGW(IDS_UNTIL)); + break; + } + case FIELD_LENGTH: { + qe_fallback(hwndDlg, IDC_RADIO_ISLIKE, IDC_RADIO_EQUAL); + qe_fallback(hwndDlg, IDC_RADIO_BEGINS, IDC_RADIO_EQUAL); + qe_fallback(hwndDlg, IDC_RADIO_ENDS, IDC_RADIO_EQUAL); + qe_fallback(hwndDlg, IDC_RADIO_CONTAINS, IDC_RADIO_EQUAL); + qe_doEnableDisable(hwndDlg, ctrls_string, sizeof(ctrls_string)/sizeof(int), 1); + qe_doEnableDisable(hwndDlg, ctrls_string_ops, sizeof(ctrls_string_ops)/sizeof(int), 0); + SetDlgItemTextW(hwndDlg,IDC_STATIC_STRING,WASABI_API_LNGSTRINGW(IDS_COMPARE_TO_LENGTH)); + qe_doEnableDisable(hwndDlg, ctrls_datetime, sizeof(ctrls_datetime)/sizeof(int), 0); + SetDlgItemTextW(hwndDlg, IDC_RADIO_ABOVE, WASABI_API_LNGSTRINGW(IDS_ABOVE)); + SetDlgItemTextW(hwndDlg, IDC_RADIO_BELOW, WASABI_API_LNGSTRINGW(IDS_BELOW)); + SetDlgItemTextW(hwndDlg, IDC_RADIO_ABOVEOREQUAL, WASABI_API_LNGSTRINGW(IDS_ABOVE_OR_EQUAL)); + SetDlgItemTextW(hwndDlg, IDC_RADIO_BELOWOREQUAL, WASABI_API_LNGSTRINGW(IDS_BELOW_OR_EQUAL)); + break; + } + case FIELD_FILENAME: + case FIELD_STRING: { + qe_doEnableDisable(hwndDlg, ctrls_string, sizeof(ctrls_string)/sizeof(int), 1); + qe_doEnableDisable(hwndDlg, ctrls_string_ops, sizeof(ctrls_string_ops)/sizeof(int), 1); + SetDlgItemTextW(hwndDlg,IDC_STATIC_STRING,WASABI_API_LNGSTRINGW(IDS_COMPARE_TO_STRING)); + qe_doEnableDisable(hwndDlg, ctrls_datetime, sizeof(ctrls_datetime)/sizeof(int), 0); + SetDlgItemTextW(hwndDlg, IDC_RADIO_ABOVE, WASABI_API_LNGSTRINGW(IDS_ABOVE)); + SetDlgItemTextW(hwndDlg, IDC_RADIO_BELOW, WASABI_API_LNGSTRINGW(IDS_BELOW)); + SetDlgItemTextW(hwndDlg,IDC_RADIO_ABOVEOREQUAL, WASABI_API_LNGSTRINGW(IDS_ABOVE_OR_EQUAL)); + SetDlgItemTextW(hwndDlg, IDC_RADIO_BELOWOREQUAL, WASABI_API_LNGSTRINGW(IDS_BELOW_OR_EQUAL)); + break; + } + case FIELD_INTEGER: { + qe_fallback(hwndDlg, IDC_RADIO_ISLIKE, IDC_RADIO_EQUAL); + qe_fallback(hwndDlg, IDC_RADIO_BEGINS, IDC_RADIO_EQUAL); + qe_fallback(hwndDlg, IDC_RADIO_ENDS, IDC_RADIO_EQUAL); + qe_fallback(hwndDlg, IDC_RADIO_CONTAINS, IDC_RADIO_EQUAL); + SetDlgItemTextW(hwndDlg,IDC_STATIC_STRING,WASABI_API_LNGSTRINGW(IDS_COMPARE_TO_NUMBER)); + qe_doEnableDisable(hwndDlg, ctrls_string, sizeof(ctrls_string)/sizeof(int), 1); + qe_doEnableDisable(hwndDlg, ctrls_string_ops, sizeof(ctrls_string_ops)/sizeof(int), 0); + qe_doEnableDisable(hwndDlg, ctrls_datetime, sizeof(ctrls_datetime)/sizeof(int), 0); + SetDlgItemTextW(hwndDlg, IDC_RADIO_ABOVE, WASABI_API_LNGSTRINGW(IDS_ABOVE)); + SetDlgItemTextW(hwndDlg, IDC_RADIO_BELOW, WASABI_API_LNGSTRINGW(IDS_BELOW)); + SetDlgItemTextW(hwndDlg, IDC_RADIO_ABOVEOREQUAL, WASABI_API_LNGSTRINGW(IDS_ABOVE_OR_EQUAL)); + SetDlgItemTextW(hwndDlg, IDC_RADIO_BELOWOREQUAL, WASABI_API_LNGSTRINGW(IDS_BELOW_OR_EQUAL)); + break; + } + } + + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_ISEMPTY)) { + qe_doEnableDisable(hwndDlg, ctrls_string, sizeof(ctrls_string)/sizeof(int), 0); + qe_doEnableDisable(hwndDlg, ctrls_datetime, sizeof(ctrls_datetime)/sizeof(int), 0); + return; + } +} + +void te_enableDisable(HWND hwndDlg) { + qe_doEnableDisable(hwndDlg, ctrls_datetime_relative, sizeof(ctrls_datetime_relative)/sizeof(int), IsDlgButtonChecked(hwndDlg, IDC_CHECK_RELATIVE)); + qe_doEnableDisable(hwndDlg, ctrls_datetime_absolute, sizeof(ctrls_datetime_absolute)/sizeof(int), IsDlgButtonChecked(hwndDlg, IDC_CHECK_ABSOLUTE)); + qe_doEnableDisable(hwndDlg, ctrls_datetime_relative_ago, sizeof(ctrls_datetime_relative_ago)/sizeof(int), IsDlgButtonChecked(hwndDlg, IDC_CHECK_RELATIVE) && IsDlgButtonChecked(hwndDlg, IDC_CHECK_TIMEAGO)); + qe_doEnableDisable(hwndDlg, ctrls_datetime_relative_ago_direction, sizeof(ctrls_datetime_relative_ago_direction)/sizeof(int), !IsDlgButtonChecked(hwndDlg, IDC_CHECK_ABSOLUTE) && IsDlgButtonChecked(hwndDlg, IDC_CHECK_SELECTIVE) && IsDlgButtonChecked(hwndDlg, IDC_CHECK_TIMEAGO)); + qe_doEnableDisable(hwndDlg, ctrls_datetime_relative_selective, sizeof(ctrls_datetime_relative_selective)/sizeof(int), IsDlgButtonChecked(hwndDlg, IDC_CHECK_RELATIVE) && IsDlgButtonChecked(hwndDlg, IDC_CHECK_SELECTIVE)); + int origin = IsDlgButtonChecked(hwndDlg, IDC_CHECK_SELECTIVE) && IsDlgButtonChecked(hwndDlg, IDC_CHECK_RELATIVE); + qe_enableDisableItem(hwndDlg, IDC_EDIT_YEAR, origin && IsDlgButtonChecked(hwndDlg, IDC_RADIO_YEAR)); + qe_enableDisableItem(hwndDlg, IDC_BUTTON_MONTH, origin && IsDlgButtonChecked(hwndDlg, IDC_RADIO_MONTH)); + qe_enableDisableItem(hwndDlg, IDC_EDIT_DAY, origin && IsDlgButtonChecked(hwndDlg, IDC_RADIO_DAY)); + qe_enableDisableItem(hwndDlg, IDC_DATETIMEPICKER2, origin && IsDlgButtonChecked(hwndDlg, IDC_RADIO_TIME)); + + SetDlgItemTextW(hwndDlg, IDC_CHECK_TIMEAGO, WASABI_API_LNGSTRINGW((IsDlgButtonChecked(hwndDlg, IDC_CHECK_SELECTIVE) ? IDS_OFFSET_BY : IDS_TIME_AGO))); + SetWindowTextW(GetDlgItem(hwndDlg, IDC_BUTTON_MONTH), monthtable[te_cur_selected_month]); + + InvalidateRect(GetDlgItem(hwndDlg, IDC_CHECK_ABSOLUTE), NULL, TRUE); + InvalidateRect(GetDlgItem(hwndDlg, IDC_CHECK_RELATIVE), NULL, TRUE); + InvalidateRect(GetDlgItem(hwndDlg, IDC_CHECK_TIMEAGO), NULL, TRUE); + InvalidateRect(GetDlgItem(hwndDlg, IDC_CHECK_SELECTIVE), NULL, TRUE); + InvalidateRect(GetDlgItem(hwndDlg, IDC_STATIC_DIRECTION), NULL, TRUE); +} + +const wchar_t *te_getDateTime(HWND hwndDlg) { + static GayStringW str; + wchar_t qe_tempstr[4096] = {0}; + str.Set(L""); + if (IsDlgButtonChecked(hwndDlg, IDC_CHECK_ABSOLUTE)) { + GayStringW sd; + SYSTEMTIME st={0,0,0,0,0,0,0,0}; + DateTime_GetSystemtime(GetDlgItem(hwndDlg, IDC_DATETIMEPICKER), &st); + if (st.wYear != 0) { + wsprintfW(qe_tempstr, L"%02d/%d/%02d", st.wMonth, st.wDay, st.wYear); + sd.Append(qe_tempstr); + } + SYSTEMTIME stt={0,0,0,0,0,0,0,0}; + DateTime_GetSystemtime(GetDlgItem(hwndDlg, IDC_DATETIMEPICKER1), &stt); + if (stt.wYear != 0) { + if (sd.Get() && *sd.Get()) sd.Append(L" "); + wsprintfW(qe_tempstr, L"%02d:%02d:%02d", stt.wHour, stt.wMinute, stt.wSecond); + sd.Append(qe_tempstr); + } + if (sd.Get() && *sd.Get()) { + str.Set(sd.Get()); + return str.Get(); + } + } else if (IsDlgButtonChecked(hwndDlg, IDC_CHECK_RELATIVE)) { + GayStringW sd; + int gotshit = 0; + int gotmonth = 0; + int gotthismonth = 0; + int gotday = 0; + int lgotthistime = 0; + int lgotthisday = 0; + if (IsDlgButtonChecked(hwndDlg, IDC_CHECK_TIMEAGO)) { + int v = GetDlgItemInt(hwndDlg, IDC_EDIT_TIMEAGO, NULL, TRUE); + wsprintfW(qe_tempstr, L"%d", v); + sd.Append(qe_tempstr); + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_TIMEAGO_Y)) { sd.Append(L" year"); if (v > 1) sd.Append(L"s"); } + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_TIMEAGO_M)) { sd.Append(L" month"); if (v > 1) sd.Append(L"s"); } + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_TIMEAGO_W)) { sd.Append(L" week"); if (v > 1) sd.Append(L"s"); } + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_TIMEAGO_D)) { sd.Append(L" day"); if (v > 1) sd.Append(L"s"); } + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_TIMEAGO_H)) sd.Append(L" h"); + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_TIMEAGO_MIN)) sd.Append(L" mn"); + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_TIMEAGO_S)) sd.Append(L" s"); + } + if (IsDlgButtonChecked(hwndDlg, IDC_CHECK_SELECTIVE)) { + if (IsDlgButtonChecked(hwndDlg, IDC_CHECK_TIMEAGO) && IsDlgButtonChecked(hwndDlg, IDC_RADIO_AFTER)) sd.Append(L" after"); + if (IsDlgButtonChecked(hwndDlg, IDC_CHECK_TIMEAGO) && IsDlgButtonChecked(hwndDlg, IDC_RADIO_BEFORE)) sd.Append(L" before"); + if (!IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISDAY) && + IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISMONTH)) { + if (sd.Get() && *sd.Get()) sd.Append(L" "); + int v = GetDlgItemInt(hwndDlg, IDC_EDIT_DAY, NULL, TRUE); + wsprintfW(qe_tempstr, L"%s%d", !gotmonth ? L"the " : L"", v); + int u = (v - ((int)((double)v/10.0)) * 10); + if (v < 1 || v > 31) { + sd.Append(L"DAY_OUTOFRANGE"); + gotshit = 1; + } else { + sd.Append(qe_tempstr); + switch (u) { + case 1: sd.Append(L"st"); gotshit = 1; break; + case 2: sd.Append(L"nd"); gotshit = 1; break; + case 3: sd.Append(L"rd"); gotshit = 1; break; + default: sd.Append(L"th"); gotshit = 1; break; + } + } + if (!gotthismonth && IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISMONTH)) { + sd.Append(L" of this month"); + gotthismonth = 1; + } + gotshit = 1; + gotday = 1; + } + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISYEAR) && + IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISMONTH) && + IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISDAY) && + IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISTIME)) { + if (sd.Get() && *sd.Get()) sd.Append(L" "); + sd.Append(L"now"); + gotshit = 1; + } else { + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISYEAR) && + IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISMONTH) && + IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISDAY)) { + if (gotshit) sd.Append(L","); + if (sd.Get() && *sd.Get()) sd.Append(L" "); + sd.Append(L"this date"); + gotshit = 1; + } else { + if (!gotthismonth && IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISMONTH) && !IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISYEAR)) { + if (gotshit) sd.Append(L","); + if (sd.Get() && *sd.Get()) sd.Append(L" "); + sd.Append(L"this month"); + gotthismonth = 1; + gotshit = 1; + } + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISDAY)) { + if (gotshit) sd.Append(L","); + if (sd.Get() && *sd.Get()) sd.Append(L" "); + sd.Append(L"this day"); + lgotthisday = 1; + gotshit = 1; + } + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISTIME)) { + if (gotshit) sd.Append(L","); + if (sd.Get() && *sd.Get()) sd.Append(L" "); + sd.Append(L"this time"); + lgotthistime = 1; + lgotthisday = 0; + gotshit = 1; + } + } + } + if (!IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISMONTH)) { + if (sd.Get() && *sd.Get()) sd.Append(L" "); + if (lgotthistime) { + if (!IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISDAY)) + sd.Append(L"on "); + else { + sd.Append(L"in "); + } + } else if (lgotthisday) sd.Append(L"of "); + switch (te_cur_selected_month) { + case 0: sd.Append(L"Jan"); gotshit = 1; gotmonth = 1; break; + case 1: sd.Append(L"Feb"); gotshit = 1; gotmonth = 1; break; + case 2: sd.Append(L"Mar"); gotshit = 1; gotmonth = 1; break; + case 3: sd.Append(L"Apr"); gotshit = 1; gotmonth = 1; break; + case 4: sd.Append(L"May"); gotshit = 1; gotmonth = 1; break; + case 5: sd.Append(L"Jun"); gotshit = 1; gotmonth = 1; break; + case 6: sd.Append(L"Jul"); gotshit = 1; gotmonth = 1; break; + case 7: sd.Append(L"Aug"); gotshit = 1; gotmonth = 1; break; + case 8: sd.Append(L"Sep"); gotshit = 1; gotmonth = 1; break; + case 9: sd.Append(L"Oct"); gotshit = 1; gotmonth = 1; break; + case 10: sd.Append(L"Nov"); gotshit = 1; gotmonth = 1; break; + case 11: sd.Append(L"Dec"); gotshit = 1; gotmonth = 1; break; + default: sd.Append(L"MONTH_OUTOFRANGE"); gotshit = 1; gotmonth = 1; break; + } + } + if (!IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISDAY) && + !IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISMONTH)) { + if (sd.Get() && *sd.Get()) sd.Append(L" "); + int v = GetDlgItemInt(hwndDlg, IDC_EDIT_DAY, NULL, TRUE); + wsprintfW(qe_tempstr, L"%s%d", !gotmonth ? L"the " : L"", v); + int u = (v - ((int)((double)v/10.0)) * 10); + if (v < 1 || v > 31) { + sd.Append(L"DAY_OUTOFRANGE"); + gotshit = 1; + } else { + sd.Append(qe_tempstr); + switch (u) { + case 1: sd.Append(L"st"); gotshit = 1; break; + case 2: sd.Append(L"nd"); gotshit = 1; break; + case 3: sd.Append(L"rd"); gotshit = 1; break; + default: sd.Append(L"th"); gotshit = 1; break; + } + } + if (!gotthismonth && IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISMONTH)) { + sd.Append(L" of this month"); + } + gotthismonth = 1; + gotshit = 1; + gotday = 1; + } + if (!IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISYEAR)) { + + if ((gotshit || gotday) && !gotmonth) { + if (sd.Get() && *sd.Get()) sd.Append(L" "); + sd.Append(L"in "); + } else if (gotmonth && gotday) sd.Append(L", "); + else if (sd.Get() && *sd.Get()) sd.Append(L" "); + int v = GetDlgItemInt(hwndDlg, IDC_EDIT_YEAR, NULL, TRUE); + if (v <= 69) v += 2000; + else if (v > 69 && v < 100) v += 1900; + if (v <= 1969 || v >= 2038) + wcsncpy(qe_tempstr, L"YEAR_OUTOFRANGE", 4096); + else + wsprintfW(qe_tempstr, L"%d", v); + sd.Append(qe_tempstr); + gotshit = 1; + } + if (!IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISTIME)) { + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_NOON)) { + if (sd.Get() && *sd.Get()) sd.Append(L" "); + if (gotshit) sd.Append(L"at "); + sd.Append(L"noon"); + } else if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_MIDNIGHT)) { + if (sd.Get() && *sd.Get()) sd.Append(L" "); + if (gotshit) sd.Append(L"at "); + sd.Append(L"midnight"); + } else if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_TIME)) { + if (sd.Get() && *sd.Get()) sd.Append(L" "); + if (gotshit) sd.Append(L"at "); + SYSTEMTIME stt={0,0,0,0,0,0,0,0}; + DateTime_GetSystemtime(GetDlgItem(hwndDlg, IDC_DATETIMEPICKER2), &stt); + wsprintfW(qe_tempstr, L"%02d:%02d:%02d", stt.wHour, stt.wMinute, stt.wSecond); + sd.Append(qe_tempstr); + gotshit = 1; + } + } + } else { + if (IsDlgButtonChecked(hwndDlg, IDC_CHECK_TIMEAGO)) + sd.Append(L" ago"); + } + qe_curorigin.Set(sd.Get()); + if (sd.Get() && *sd.Get()) { + str.Set(sd.Get()); + return str.Get(); + } + } + return NULL; +} + +void qe_updateQuery(HWND hwndDlg) { + if (!*qe_field) return; + wchar_t qe_tempstr[4096] = {0}; + nde_field_t field = NDE_Table_GetColumnByName(g_table, AutoChar(qe_field)); + if (!field) return; + int type =NDE_ColumnField_GetDataType(field); + + *qe_tempstr = NULL; + GayStringW str; + + if (IsDlgButtonChecked(hwndDlg, IDC_CHECK_NOT)) + str.Append(L"!("); + str.Append(qe_field); + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_EQUAL)) + str.Append(L" =="); + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_ABOVE)) + str.Append(L" >"); + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_BELOW)) + str.Append(L" <"); + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_ABOVEOREQUAL)) + str.Append(L" >="); + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_BELOWOREQUAL)) + str.Append(L" <="); + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_ISLIKE)) + str.Append(L" like"); + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_ISEMPTY)) + str.Append(L" isempty"); + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_BEGINS)) + str.Append(L" begins"); + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_ENDS)) + str.Append(L" ends"); + if (IsDlgButtonChecked(hwndDlg, IDC_RADIO_CONTAINS)) + str.Append(L" has"); + + if (!IsDlgButtonChecked(hwndDlg, IDC_RADIO_ISEMPTY)) { + switch(type) { + case FIELD_DATETIME: { + str.Append(L" ["); + GetDlgItemTextW(hwndDlg, IDC_EDIT_DATETIME, qe_tempstr, 4096); + qe_curdate.Set(qe_tempstr); + str.Append(qe_curdate.Get()); + str.Append(L"]"); + } + break; + case FIELD_INTEGER: { + wsprintfW(qe_tempstr, L" %d", GetDlgItemInt(hwndDlg, IDC_EDIT_STRING, NULL, 1)); + str.Append(qe_tempstr); + } + break; + case FIELD_FILENAME: + case FIELD_STRING: { + GetDlgItemTextW(hwndDlg, IDC_EDIT_STRING, qe_tempstr, 4096); + str.Append(L" \""); + GayStringW escaped; + queryStrEscape(qe_tempstr, escaped); + str.Append(escaped.Get()); + str.Append(L"\""); + } + break; + case FIELD_LENGTH: { + GetDlgItemTextW(hwndDlg, IDC_EDIT_STRING, qe_tempstr, 4096); + wchar_t *z = wcschr(qe_tempstr, L':'); + if (z) { + wchar_t *zz = wcschr(z+1, L':'); + int a, b, c=0,v=0; + a = myatoi(qe_tempstr, z-qe_tempstr); + if (zz) { b = myatoi(z+1, zz-(z+1)); c = _wtoi(zz+1); v = a * 3600 + b * 60 + c; } + else { b = _wtoi(z+1); v = a * 60 + b; } + + if (v < 60) + wsprintfW(qe_tempstr,L"%d",v); + else if (v < 60*60) + wsprintfW(qe_tempstr,L"%d:%02d",v/60,v%60); + else + wsprintfW(qe_tempstr,L"%d:%02d:%02d",v/60/60,(v/60)%60,v%60); + + str.Append(qe_tempstr); + } else { + wsprintfW(qe_tempstr, L" %d", GetDlgItemInt(hwndDlg, IDC_EDIT_STRING, NULL, 1)); + str.Append(qe_tempstr); + } + } + break; + } + } + + if (IsDlgButtonChecked(hwndDlg, IDC_CHECK_NOT)) + str.Append(L")"); + + qe_curexpr.Set(str.Get()); + SetDlgItemTextW(hwndDlg, IDC_EDIT_RESULT, str.Get()); + SetDlgItemTextW(hwndDlg, IDC_EDIT_QUERY, qe_curquery.Get()); + + qe_updateResultingDate(hwndDlg); +} + +void qe_update(HWND hwndDlg) { + qe_enableDisable(hwndDlg); + qe_updateQuery(hwndDlg); +} + +void te_updateResult(HWND hwndDlg) { + const wchar_t *s = te_getDateTime(hwndDlg); + te_result.Set(s == NULL ? L"":s); + SetDlgItemTextW(hwndDlg, IDC_EDIT_RESULT, te_result.Get()); +} + +void te_update(HWND hwndDlg) { + te_enableDisable(hwndDlg); + te_updateResult(hwndDlg); +} + +void qe_pushExpression(HWND hwndDlg, const wchar_t *op) { + GayStringW newq; + if (op && qe_curquery.Get() && *qe_curquery.Get()) { + newq.Append(L"("); + newq.Append(qe_curquery.Get()); + newq.Append(L") "); + newq.Append(op); + newq.Append(L" ("); + newq.Append(qe_curexpr.Get()); + newq.Append(L")"); + qe_curquery.Set(newq.Get()); + } else { + qe_curquery.Set(qe_curexpr.Get()); + } + qe_update(hwndDlg); +} + +SYSTEMTIME pickedtime; +SYSTEMTIME pickeddate; + +INT_PTR CALLBACK pickDateTimeDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam) { + switch(uMsg) { + case WM_INITDIALOG: { + return TRUE; + } + case WM_COMMAND: { + switch (LOWORD(wParam)) { + case IDOK: + memset(&pickedtime, 0, sizeof(pickedtime)); + memset(&pickeddate, 0, sizeof(pickeddate)); + DateTime_GetSystemtime(GetDlgItem(hwndDlg, IDC_DATETIMEPICKER), &pickeddate); + DateTime_GetSystemtime(GetDlgItem(hwndDlg, IDC_DATETIMEPICKER1), &pickedtime); + EndDialog(hwndDlg, IDOK); + break; + case IDCANCEL: + EndDialog(hwndDlg, IDCANCEL); + break; + } + } + break; + } + return FALSE; +} + +INT_PTR CALLBACK editDateTimeDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam) { + + switch(uMsg) { + case WM_INITDIALOG: { + const wchar_t *p = te_ret.Get(); + while (p) { + if (*p != L' ') break; + p++; + } + int empty = (p && *p == 0); + TimeParse tp; + NDE_Time_ApplyConversion(0, te_ret.Get(), &tp); + + if (!empty) { + CheckDlgButton(hwndDlg, IDC_RADIO_THISYEAR, tp.relative_year == -1 ? BST_CHECKED : BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_YEAR, tp.relative_year != -1 ? BST_CHECKED : BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_THISMONTH, tp.relative_month == -1 ? BST_CHECKED : BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_MONTH, tp.relative_month != -1 ? BST_CHECKED : BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_THISDAY, tp.relative_day == -1 ? BST_CHECKED : BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_DAY, tp.relative_day != -1 ? BST_CHECKED : BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_THISTIME, tp.relative_hour == -1 ? BST_CHECKED : BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_NOON, (tp.relative_hour == 12 && tp.relative_min == 0 && tp.relative_sec == 0) ? BST_CHECKED : BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_MIDNIGHT, (tp.relative_hour == 0 && tp.relative_min == 0 && tp.relative_sec == 0) ? BST_CHECKED : BST_UNCHECKED); + int timeyet = IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISTIME); + timeyet |= IsDlgButtonChecked(hwndDlg, IDC_RADIO_NOON); + timeyet |= IsDlgButtonChecked(hwndDlg, IDC_RADIO_MIDNIGHT); + CheckDlgButton(hwndDlg, IDC_RADIO_TIME, !timeyet ? BST_CHECKED : BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_CHECK_RELATIVE, tp.is_relative ? BST_CHECKED : BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_CHECK_ABSOLUTE, !tp.is_relative ? BST_CHECKED : BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_BEFORE, tp.offset_whence == 1 ? BST_CHECKED : BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_AFTER, tp.offset_whence == 0 ? BST_CHECKED : BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_CHECK_TIMEAGO, tp.offset_used == 1 ? BST_CHECKED : BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_TIMEAGO_Y, tp.offset_what == 0 ? BST_CHECKED : BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_TIMEAGO_M, tp.offset_what == 1 ? BST_CHECKED : BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_TIMEAGO_W, tp.offset_what == 2 ? BST_CHECKED : BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_TIMEAGO_D, tp.offset_what == 3 ? BST_CHECKED : BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_TIMEAGO_H, tp.offset_what == 4 ? BST_CHECKED : BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_TIMEAGO_MIN, tp.offset_what == 5 ? BST_CHECKED : BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_TIMEAGO_S, tp.offset_what == 6 ? BST_CHECKED : BST_UNCHECKED); + if (tp.is_relative && (tp.relative_year != -1 || tp.relative_month != -1 || tp.relative_day != -1 || tp.relative_hour != -1 || tp.relative_min != -1 || tp.relative_sec != -1)) + CheckDlgButton(hwndDlg, IDC_CHECK_SELECTIVE, BST_CHECKED); + else + CheckDlgButton(hwndDlg, IDC_CHECK_SELECTIVE, BST_UNCHECKED); + } + wchar_t t[64] = {0}; + wsprintfW(t, L"%d", tp.offset_value); + SetDlgItemTextW(hwndDlg, IDC_EDIT_TIMEAGO, t); + SetDlgItemTextW(hwndDlg, IDC_EDIT_RESULT, te_ret.Get()); + { + wchar_t qe_tempstr[4096] = {0}; + time_t now; + time(&now); + struct tm *ts = localtime(&now); + wsprintfW(qe_tempstr, L"%d", tp.relative_year != -1 ? tp.relative_year : ts->tm_year+1900); + SetDlgItemTextW(hwndDlg, IDC_EDIT_YEAR, qe_tempstr); + wsprintfW(qe_tempstr, L"%d", tp.relative_day != -1 ? tp.relative_day : ts->tm_mday); + SetDlgItemTextW(hwndDlg, IDC_EDIT_DAY, qe_tempstr); + te_cur_selected_month = tp.relative_month != -1 ? tp.relative_month : ts->tm_mon; + } + if (!empty && !IsDlgButtonChecked(hwndDlg, IDC_RADIO_THISTIME) && !IsDlgButtonChecked(hwndDlg, IDC_RADIO_NOON) && !IsDlgButtonChecked(hwndDlg, IDC_RADIO_MIDNIGHT)) { + SYSTEMTIME st={0}; + st.wHour = (WORD)tp.relative_hour; + st.wMinute = (WORD)tp.relative_min; + st.wSecond = (WORD)tp.relative_sec; + DateTime_SetSystemtime(GetDlgItem(hwndDlg, IDC_DATETIMEPICKER2), GDT_VALID, &st); + } + if (!empty && !tp.is_relative) { + time_t o = tp.absolute_datetime; + struct tm *t = localtime(&o); + if (t) { + if (!tp.absolute_hasdate) + DateTime_SetSystemtime(GetDlgItem(hwndDlg, IDC_DATETIMEPICKER), GDT_NONE, NULL); + else { + SYSTEMTIME st={0}; + st.wYear = (WORD)t->tm_year; + st.wDay = (WORD)t->tm_mday; + st.wMonth = (WORD)t->tm_mon; + DateTime_SetSystemtime(GetDlgItem(hwndDlg, IDC_DATETIMEPICKER), GDT_VALID, &st); + } + if (!tp.absolute_hastime) + DateTime_SetSystemtime(GetDlgItem(hwndDlg, IDC_DATETIMEPICKER1), GDT_NONE, NULL); + else { + SYSTEMTIME st2={0}; + GetSystemTime(&st2); + st2.wHour = (WORD)t->tm_hour; + st2.wMinute = (WORD)t->tm_min; + st2.wSecond = (WORD)t->tm_sec; + DateTime_SetSystemtime(GetDlgItem(hwndDlg, IDC_DATETIMEPICKER1), GDT_VALID, &st2); + } + } + CheckDlgButton(hwndDlg, IDC_CHECK_TIMEAGO, 1); + CheckDlgButton(hwndDlg, IDC_RADIO_TIMEAGO_W, 1); + SetDlgItemText(hwndDlg, IDC_EDIT_TIMEAGO, L"1"); + CheckDlgButton(hwndDlg, IDC_RADIO_BEFORE, 1); + } else if (!empty) { + if (!IsDlgButtonChecked(hwndDlg, IDC_CHECK_SELECTIVE)) { + CheckDlgButton(hwndDlg, IDC_RADIO_THISYEAR, 1); + CheckDlgButton(hwndDlg, IDC_RADIO_THISMONTH, 1); + CheckDlgButton(hwndDlg, IDC_RADIO_THISDAY, 1); + CheckDlgButton(hwndDlg, IDC_RADIO_THISTIME, 1); + } + } else if (empty) { + CheckDlgButton(hwndDlg, IDC_CHECK_TIMEAGO, 1); + CheckDlgButton(hwndDlg, IDC_RADIO_TIMEAGO_W, 1); + SetDlgItemText(hwndDlg, IDC_EDIT_TIMEAGO, L"1"); + CheckDlgButton(hwndDlg, IDC_RADIO_BEFORE, 1); + CheckDlgButton(hwndDlg, IDC_RADIO_THISYEAR, 1); + CheckDlgButton(hwndDlg, IDC_RADIO_THISMONTH, 1); + CheckDlgButton(hwndDlg, IDC_RADIO_THISDAY, 1); + CheckDlgButton(hwndDlg, IDC_RADIO_THISTIME, 1); + CheckDlgButton(hwndDlg, IDC_CHECK_RELATIVE, 1); + } + te_enableDisable(hwndDlg); + SetTimer(hwndDlg, 0, 1000, NULL); + } + return 1; + case WM_COMMAND: { + switch (LOWORD(wParam)) { + case IDOK: EndDialog(hwndDlg, IDOK); break; + case IDCANCEL: EndDialog(hwndDlg, IDCANCEL); break; + case IDC_EDIT_TIMEAGO: + case IDC_EDIT_YEAR: + case IDC_EDIT_DAY: + if (HIWORD(wParam) != EN_CHANGE) break; + case IDC_CHECK_ABSOLUTE: + case IDC_CHECK_RELATIVE: + case IDC_CHECK_TIMEAGO: + case IDC_CHECK_SELECTIVE: + case IDC_RADIO_THISYEAR: + case IDC_RADIO_THISMONTH: + case IDC_RADIO_THISDAY: + case IDC_RADIO_THISTIME: + case IDC_RADIO_YEAR: + case IDC_RADIO_MONTH: + case IDC_RADIO_DAY: + case IDC_RADIO_TIME: + case IDC_RADIO_NOON: + case IDC_RADIO_MIDNIGHT: + case IDC_RADIO_EQUAL: + case IDC_RADIO_ABOVE: + case IDC_RADIO_ABOVEOREQUAL: + case IDC_RADIO_BELOW: + case IDC_RADIO_BELOWOREQUAL: + case IDC_RADIO_ISLIKE: + case IDC_RADIO_ISEMPTY: + case IDC_RADIO_BEGINS: + case IDC_RADIO_ENDS: + case IDC_RADIO_CONTAINS: + case IDC_CHECK_NOT: + case IDC_RADIO_TIMEAGO_Y: + case IDC_RADIO_TIMEAGO_M: + case IDC_RADIO_TIMEAGO_D: + case IDC_RADIO_TIMEAGO_H: + case IDC_RADIO_TIMEAGO_MIN: + case IDC_RADIO_TIMEAGO_S: + case IDC_RADIO_TIMEAGO_W: + case IDC_RADIO_AFTER: + case IDC_RADIO_BEFORE: + te_update(hwndDlg); + return 0; + case IDC_BUTTON_PICK: { + INT_PTR r = WASABI_API_DIALOGBOXW(IDD_EDIT_QUERY_PICK, hwndDlg, pickDateTimeDialogProc); + if (r == IDOK) { + if (pickeddate.wYear != 0) { + SetDlgItemInt(hwndDlg, IDC_EDIT_YEAR, pickeddate.wYear, 0); + te_cur_selected_month = pickeddate.wMonth-1; + SetDlgItemInt(hwndDlg, IDC_EDIT_DAY, pickeddate.wDay, 0); + CheckDlgButton(hwndDlg, IDC_RADIO_THISYEAR, BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_YEAR, BST_CHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_THISMONTH, BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_MONTH, BST_CHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_THISDAY, BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_DAY, BST_CHECKED); + } + if (pickedtime.wYear != 0) { + DateTime_SetSystemtime(GetDlgItem(hwndDlg, IDC_DATETIMEPICKER2), GDT_VALID, &pickedtime); + CheckDlgButton(hwndDlg, IDC_RADIO_THISTIME, BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_TIME, BST_CHECKED); + } + te_update(hwndDlg); + } + } + break; + case IDC_BUTTON_NOW: + CheckDlgButton(hwndDlg, IDC_RADIO_THISYEAR, BST_CHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_YEAR, BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_THISMONTH, BST_CHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_MONTH, BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_THISDAY, BST_CHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_DAY, BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_THISTIME, BST_CHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_TIME, BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_NOON, BST_UNCHECKED); + CheckDlgButton(hwndDlg, IDC_RADIO_MIDNIGHT, BST_UNCHECKED); + te_update(hwndDlg); + return 0; + case IDC_BUTTON_MONTH: { + HMENU menu = CreatePopupMenu(); + for (int i=0;i<12;i++) + AppendMenuW(menu, MF_STRING|(te_cur_selected_month==i)?MF_CHECKED:MF_UNCHECKED, i+1, monthtable[i]); + POINT pt; + GetCursorPos(&pt); + int r = TrackPopupMenuEx(menu, TPM_LEFTALIGN|TPM_BOTTOMALIGN|TPM_NONOTIFY|TPM_RETURNCMD|TPM_LEFTBUTTON|TPM_RIGHTBUTTON, pt.x, pt.y, hwndDlg, NULL); + if (r) + { + te_cur_selected_month = r-1; + te_update(hwndDlg); + } + break; + } + } + } + case WM_TIMER: { + te_updateResultingDate(hwndDlg); + return 0; + } + case WM_NOTIFY: { + int idCtrl = (int)wParam; + NMHDR *hdr = (NMHDR*)lParam; + switch (idCtrl) { + case IDC_DATETIMEPICKER: + case IDC_DATETIMEPICKER1: + case IDC_DATETIMEPICKER2: + if (hdr->code == DTN_DATETIMECHANGE) + te_update(hwndDlg); + break; + } + } + break; + } + return 0; +} + +INT_PTR CALLBACK editQueryDialogProc( HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam ) +{ + switch ( uMsg ) + { + case WM_INITDIALOG: + { + qe_fillFieldsList( GetDlgItem( hwndDlg, IDC_LIST_FIELDS ) ); + SetDlgItemTextW( hwndDlg, IDC_EDIT_RESULT, qe_curquery.Get() ); + CheckDlgButton( hwndDlg, IDC_RADIO_EQUAL, MF_CHECKED ); + qe_update( hwndDlg ); + SetTimer( hwndDlg, 0, 1000, NULL ); + return 1; + } + case WM_TIMER: + { + qe_updateResultingDate( hwndDlg ); + return 0; + } + case WM_COMMAND: + { + switch ( LOWORD( wParam ) ) + { + case IDOK: + if ( !qe_curquery.Get() || !*qe_curquery.Get() && qe_curexpr.Get() && *qe_curexpr.Get() ) + { + wchar_t titleStr[ 32 ] = { 0 }; + int r = MessageBoxW( hwndDlg, WASABI_API_LNGSTRINGW( IDS_QUERY_FIELD_IS_EMPTY ), + WASABI_API_LNGSTRINGW_BUF( IDS_EMPTY_QUERY, titleStr, 32 ), MB_YESNOCANCEL ); + if ( r == IDYES ) + qe_curquery.Set( qe_curexpr.Get() ); + else if ( r == IDCANCEL ) break; + } + if ( qe_origquery.Get() && *qe_origquery.Get() && qe_curquery.Get() || *qe_curquery.Get() && qe_curexpr.Get() && *qe_curexpr.Get() ) + { + if ( !wcscmp( qe_curquery.Get(), qe_origquery.Get() ) ) + { + wchar_t titleStr[ 32 ] = { 0 }; + int r = MessageBoxW( hwndDlg, WASABI_API_LNGSTRINGW( IDS_NO_CHANGES_MADE_TO_QUERY ), + WASABI_API_LNGSTRINGW_BUF( IDS_QUERY_NOT_CHANGED, titleStr, 32 ), MB_YESNOCANCEL ); + if ( r == IDYES ) + qe_curquery.Set( qe_curexpr.Get() ); + else if ( r == IDCANCEL ) break; + } + } + EndDialog( hwndDlg, IDOK ); + break; + case IDCANCEL: EndDialog( hwndDlg, IDCANCEL ); break; + + case IDC_EDIT_STRING: + case IDC_EDIT_DATETIME: + if ( HIWORD( wParam ) != EN_CHANGE ) break; + case IDC_RADIO_EQUAL: + case IDC_RADIO_ABOVE: + case IDC_RADIO_ABOVEOREQUAL: + case IDC_RADIO_BELOW: + case IDC_RADIO_BELOWOREQUAL: + case IDC_RADIO_ISLIKE: + case IDC_RADIO_ISEMPTY: + case IDC_RADIO_BEGINS: + case IDC_RADIO_ENDS: + case IDC_RADIO_CONTAINS: + case IDC_CHECK_NOT: + qe_update( hwndDlg ); + return 0; + case IDC_LIST_FIELDS: + if ( HIWORD( wParam ) == CBN_SELCHANGE ) + { + HWND wnd = GetDlgItem( hwndDlg, IDC_LIST_FIELDS ); + int idx = ListBox_GetCurSel( wnd ); + int len = ListBox_GetTextLenW( wnd, idx ); + if ( qe_field != NULL ) free( qe_field ); + qe_field = (wchar_t *)calloc( ( len + 1 ), sizeof( wchar_t ) ); + ListBox_GetTextW( wnd, idx, qe_field ); + + qe_field[ len ] = 0; + qe_update( hwndDlg ); + } + break; + case IDC_BUTTON_AND: + qe_pushExpression( hwndDlg, L"AND" ); + break; + case IDC_BUTTON_OR: + qe_pushExpression( hwndDlg, L"OR" ); + break; + case ID_BUTTON_SENDTOQUERY: + qe_pushExpression( hwndDlg, NULL ); + break; + case IDC_BUTTON_EDITDATETIME: + { + const wchar_t *res = editTime( hwndDlg, qe_curdate.Get() ); + if ( res != NULL ) + { + SetDlgItemTextW( hwndDlg, IDC_EDIT_DATETIME, res ); + qe_curdate.Set( res ); + } + qe_update( hwndDlg ); + break; + } + case IDC_EDIT_QUERY: + if ( HIWORD( wParam ) == EN_CHANGE ) + { + wchar_t qe_tempstr[ 4096 ] = { 0 }; + GetDlgItemTextW( hwndDlg, IDC_EDIT_QUERY, qe_tempstr, 4096 ); + qe_curquery.Set( qe_tempstr ); + qe_showHideOperators( hwndDlg ); + } + break; + } + } + break; + } + return FALSE; +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/editquery.h b/Src/Plugins/Library/ml_local/editquery.h new file mode 100644 index 00000000..c5e2a3c0 --- /dev/null +++ b/Src/Plugins/Library/ml_local/editquery.h @@ -0,0 +1,7 @@ +#ifndef _EDITQUERY_H +#define _EDITQUERY_H + +const wchar_t *editQuery(HWND wnd, const wchar_t *curquery, wchar_t *newQuery, size_t len); +extern const wchar_t *editTime(HWND wnd, const wchar_t *curfield); + +#endif diff --git a/Src/Plugins/Library/ml_local/evntsink.cpp b/Src/Plugins/Library/ml_local/evntsink.cpp new file mode 100644 index 00000000..e3301e39 --- /dev/null +++ b/Src/Plugins/Library/ml_local/evntsink.cpp @@ -0,0 +1,239 @@ +/************************************************************************** + THIS CODE AND INFORMATION IS PROVIDED 'AS IS' WITHOUT WARRANTY OF + ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO + THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A + PARTICULAR PURPOSE. + + Copyright 1998 Microsoft Corporation. All Rights Reserved. +**************************************************************************/ + +/************************************************************************** + + File: evntsink.cpp + + Description: This file contains the implementation of the event sink. + +**************************************************************************/ + +/************************************************************************** + #include statements +**************************************************************************/ + +#include "main.h" +#include <windows.h> +#include "evntsink.h" + +/************************************************************************** + function prototypes +**************************************************************************/ + +/************************************************************************** + global variables and definitions +**************************************************************************/ + +/************************************************************************** + + CEventSink::CEventSink() + +**************************************************************************/ + +CEventSink::CEventSink() +{ + m_cRefs = 1; +} + +/************************************************************************** + + CEventSink::QueryInterface() + +**************************************************************************/ + +STDMETHODIMP CEventSink::QueryInterface(REFIID riid, PVOID *ppvObject) +{ + if (!ppvObject) + return E_POINTER; + + if (IsEqualIID(riid, IID_IDispatch)) + *ppvObject = (IDispatch *)this; + else if (IsEqualIID(riid, IID_IUnknown)) + *ppvObject = this; + else + { + *ppvObject = NULL; + return E_NOINTERFACE; + } + + AddRef(); + return S_OK; +} + +/************************************************************************** + + CEventSink::AddRef() + +**************************************************************************/ + +ULONG CEventSink::AddRef(void) +{ + return ++m_cRefs; +} + +/************************************************************************** + + CEventSink::Release() + +**************************************************************************/ + +ULONG CEventSink::Release(void) +{ + if (--m_cRefs) + return m_cRefs; + + delete this; + return 0; +} + +/************************************************************************** + + CEventSink::GetIDsOfNames() + +**************************************************************************/ + +HRESULT CEventSink::GetIDsOfNames(REFIID riid, OLECHAR FAR* FAR* rgszNames, unsigned int cNames, LCID lcid, DISPID FAR* rgdispid) +{ + *rgdispid = DISPID_UNKNOWN; + return DISP_E_UNKNOWNNAME; +} + +/************************************************************************** + + CEventSink::GetTypeInfo() + +**************************************************************************/ + +HRESULT CEventSink::GetTypeInfo(unsigned int itinfo, LCID lcid, ITypeInfo FAR* FAR* pptinfo) +{ + return E_NOTIMPL; +} + +/************************************************************************** + + CEventSink::GetTypeInfoCount() + +**************************************************************************/ + +HRESULT CEventSink::GetTypeInfoCount(unsigned int FAR * pctinfo) +{ + return E_NOTIMPL; +} + +/************************************************************************** + + CEventSink::Invoke() + +**************************************************************************/ + +void main_setStatusText(LPCWSTR txt) +{ + char dest[512]; + dest[0]=0; + WideCharToMultiByte(CP_ACP,0,txt,-1,dest,sizeof(dest),NULL,NULL); + //SetDlgItemText(m_hwnd,IDC_STATUS,dest); +} + +void main_beforeNavigate(LPCWSTR txt) +{ + VARIANT *blah=(VARIANT *)txt; + char dest[512]; + dest[0]=0; + WideCharToMultiByte(CP_ACP,0,blah->bstrVal,-1,dest,sizeof(dest),NULL,NULL); + //SetDlgItemText(m_hwnd,IDC_QUICKSEARCH,dest); +} + +HRESULT CEventSink::Invoke(DISPID dispid, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS FAR *pdispparams, VARIANT FAR *pvarResult, EXCEPINFO FAR * pexecinfo, unsigned int FAR *puArgErr) +{ + switch (dispid) + { + // void StatusTextChange([in] BSTR Text); + case 0x66: + main_setStatusText(pdispparams->rgvarg[0].bstrVal); + //m_pApp->eventStatusTextChange(pdispparams->rgvarg[0].bstrVal); + break; + + // void ProgressChange([in] long Progress, [in] long ProgressMax); + case 0x6c: + break; + + // void CommandStateChange([in] long Command, [in] VARIANT_BOOL Enable); + case 0x69: + //m_pApp->eventCommandStateChange(pdispparams->rgvarg[1].lVal, pdispparams->rgvarg[0].boolVal); + break; + + // void DownloadBegin(); + case 0x6a: + //m_pApp->eventDownloadBegin(); + break; + + // void DownloadComplete(); + case 0x68: + //m_pApp->eventDownloadComplete(); + break; + + // void TitleChange([in] BSTR Text); + case 0x071: + //m_pApp->eventTitleChange(pdispparams->rgvarg[0].bstrVal); + break; + + // void PropertyChange([in] BSTR szProperty); + case 0x70: + //m_pApp->eventPropertyChange(pdispparams->rgvarg[0].bstrVal); + break; + + // void BeforeNavigate2([in] IDispatch* pDisp, [in] VARIANT* URL, [in] VARIANT* Flags, [in] VARIANT* TargetFrameName, [in] VARIANT* PostData, [in] VARIANT* Headers, [in, out] VARIANT_BOOL* Cancel); + case 0xfa: + main_beforeNavigate(pdispparams->rgvarg[5].bstrVal); + break; + + // void NewWindow2([in, out] IDispatch** ppDisp, [in, out] VARIANT_BOOL* Cancel); + case 0xfb: + break; + + // void NavigateComplete2([in] IDispatch* pDisp, [in] VARIANT* URL); + case 0xfc: + break; + + // void DocumentComplete([in] IDispatch* pDisp, [in] VARIANT* URL); + case 0x0103: + break; + + // void OnQuit(); + case 0xfd: + break; + + // void OnVisible([in] VARIANT_BOOL Visible); + case 0xfe: + break; + + // void OnToolBar([in] VARIANT_BOOL ToolBar); + case 0xff: + break; + + // void OnMenuBar([in] VARIANT_BOOL MenuBar); + case 0x0100: + break; + + // void OnStatusBar([in] VARIANT_BOOL StatusBar); + case 0x0101: + break; + + // void OnFullScreen([in] VARIANT_BOOL FullScreen); + case 0x0102: + break; + + // void OnTheaterMode([in] VARIANT_BOOL TheaterMode); + case 0x0104: + break; + } + + return S_OK; +} diff --git a/Src/Plugins/Library/ml_local/evntsink.h b/Src/Plugins/Library/ml_local/evntsink.h new file mode 100644 index 00000000..14eb2ab9 --- /dev/null +++ b/Src/Plugins/Library/ml_local/evntsink.h @@ -0,0 +1,25 @@ +#ifndef _EVNTSINK_H +#define _EVNTSINK_H + +class CEventSink : public IDispatch +{ + private: + ULONG m_cRefs; // ref count + + public: + CEventSink(); + + public: + // *** IUnknown Methods *** + STDMETHOD(QueryInterface)(REFIID riid, PVOID *ppvObject); + STDMETHOD_(ULONG, AddRef)(void); + STDMETHOD_(ULONG, Release)(void); + + // *** IDispatch Methods *** + STDMETHOD (GetIDsOfNames)(REFIID riid, OLECHAR FAR* FAR* rgszNames, unsigned int cNames, LCID lcid, DISPID FAR* rgdispid); + STDMETHOD (GetTypeInfo)(unsigned int itinfo, LCID lcid, ITypeInfo FAR* FAR* pptinfo); + STDMETHOD (GetTypeInfoCount)(unsigned int FAR * pctinfo); + STDMETHOD (Invoke)(DISPID dispid, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS FAR *pdispparams, VARIANT FAR *pvarResult, EXCEPINFO FAR * pexecinfo, unsigned int FAR *puArgErr); +}; + +#endif
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/guess.cpp b/Src/Plugins/Library/ml_local/guess.cpp new file mode 100644 index 00000000..24686ddc --- /dev/null +++ b/Src/Plugins/Library/ml_local/guess.cpp @@ -0,0 +1,122 @@ +#include <string.h> +#include <memory.h> +#include <stdlib.h> +#include <stdio.h> +#include <windows.h> + +wchar_t *guessTitles(const wchar_t *filename, + int *tracknum, + wchar_t **artist, + wchar_t **album, + wchar_t **title) // should free the result of this function after using artist/album/title +{ + *tracknum=0; + *artist=0; + *album=0; + *title=0; + + if (!filename[0]) return 0; + + wchar_t *_artist=NULL; + wchar_t *_album=NULL; + + const wchar_t *f=filename; + while (f && *f) f++; + while (f && (f > filename) && *f != L'/' && *f != L'\\') f--; + + if (f == filename) return 0; + + int dirlen = f-filename; + + wchar_t *fullfn = (wchar_t*)_wcsdup(filename); + fullfn[dirlen]=0; + + wchar_t *n=fullfn+dirlen; + while (n >= fullfn && *n != L'/' && *n != L'\\') n--; + n++; + + // try to guess artist and album from the dirname + if (!wcsstr(n,L"-")) // assume dir name is album name, artist name unknown + { + *album=n; + _album=n; + } + else + { + *artist=_artist=n; + _album=wcsstr(n,L"-")+1; + wchar_t *t=_album-2; + while (t >= n && *t == L' ') t--; + t[1]=0; + + while (_album && *_album == L' ') _album++; + *album=_album; + } + + // get filename shizit + wcsncpy(fullfn+dirlen+1,filename+dirlen+1,wcslen(filename) - (dirlen + 1)); + + n=fullfn+dirlen+1; + while (n && *n) n++; + while (n > fullfn+dirlen+1 && *n != L'.') n--; + if (*n == L'.') *n=0; + n=fullfn+dirlen+1; + + while (n && *n == L' ') n++; + + // detect XX. filename + if (wcsstr(n,L".") && _wtoi(n) && _wtoi(n) < 130) + { + wchar_t *tmp=n; + while (tmp && *tmp >= L'0' && *tmp <= L'9') tmp++; + while (tmp && *tmp == L' ') tmp++; + if (tmp && *tmp == L'.') + { + *tracknum=_wtoi(n); + n=tmp+1; + while (n && *n == L'.') n++; + while (n && *n == L' ') n++; + } + } + + // detect XX- filename + if (!*tracknum && wcsstr(n,L"-") && _wtoi(n) && _wtoi(n) < 130) + { + wchar_t *tmp=n; + while (tmp && *tmp >= L'0' && *tmp <= L'9') tmp++; + while (tmp && *tmp == L' ') tmp++; + if (tmp && *tmp == L'-') + { + *tracknum=_wtoi(n); + n=tmp+1; + while (n && *n == L'-') n++; + while (n && *n == L' ') n++; + } + } + + while (wcsstr(n,L"-")) + { + wchar_t *a=n; + n=wcsstr(n,L"-"); + { + wchar_t *t=n-1; + while (t >= a && *t == L' ') t--; + t[1]=0; + } + *n=0; + n++; + while (n && *n == L'-') n++; + while (n && *n == L' ') n++; + + // a is the next token. + if (!*tracknum && !_wcsnicmp(a,L"Track ",6) && _wtoi(a+6)) *tracknum=_wtoi(a+6); + else if (*artist== _artist) + { + *artist=a; + } + if (*artist != _artist && *tracknum) break; + } + *title=n; + + return fullfn; +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/handleMessage.cpp b/Src/Plugins/Library/ml_local/handleMessage.cpp new file mode 100644 index 00000000..f34aac4a --- /dev/null +++ b/Src/Plugins/Library/ml_local/handleMessage.cpp @@ -0,0 +1,906 @@ +#include "main.h" +#include "ml_local.h" +#include "..\..\General\gen_ml/ml.h" +#include "../replicant/nu/ns_wc.h" +#include "../nde/nde.h" +#include "../replicant/nu/AutoWide.h" +#include "../nu/AutoWideFn.h" +#include "editquery.h" +#include <time.h> + +int queryEditOther(HWND hwnd, const char *query, const char *viewname, int mode); + +extern int m_item_mode; +extern wchar_t m_item_name[256]; +extern wchar_t m_item_query[1024]; + +LRESULT IPC_GetFileRatingW(INT_PTR fileName) +{ + int rating = 0; + const wchar_t *filename = (const wchar_t *)fileName; + if (!filename) return 0; + if (g_table) + { + EnterCriticalSection(&g_db_cs); + + wchar_t filename2[MAX_PATH] = {0}; // full lfn path if set + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + int found=FindFileInDatabase(s, MAINTABLE_ID_FILENAME, filename, filename2); + + if (found) + { + nde_field_t f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_RATING); + if (f && NDE_Field_GetType(f) == FIELD_INTEGER) + { + rating = min(5, max(0, NDE_IntegerField_GetValue(f))); + } + } + + NDE_Table_DestroyScanner(g_table, s); + + LeaveCriticalSection(&g_db_cs); + } + return rating; +} + +LRESULT IPC_SetFileRatingW(INT_PTR file_rating) +{ + const wchar_t *filename; + int rating; + int found = 0; + + file_set_ratingW *data = (file_set_ratingW*)file_rating; + if (!data) return 0; + + filename = data->fileName; + rating = min(5, max(0, data->newRating)); + + if (!filename) return 0; + if (g_table) + { + EnterCriticalSection(&g_db_cs); + wchar_t filename2[MAX_PATH] = {0}; // full lfn path if set + + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + int found=FindFileInDatabase(s, MAINTABLE_ID_FILENAME, filename, filename2); + if (!found) + { + int guess = -1, meta = -1, rec = 1; + autoscan_add_directory(filename, &guess, &meta, &rec, 1); // use this folder's guess/meta options + if (guess == -1) guess = g_config->ReadInt(L"guessmode", 0); + if (meta == -1) meta = g_config->ReadInt(L"usemetadata", 1); + addFileToDb(filename, 0, meta, guess, 1, (int)time(NULL)); + } + if (filename2[0] && !found) + { + if (NDE_Scanner_LocateFilename(s, MAINTABLE_ID_FILENAME, FIRST_RECORD, filename2)) found = 2; + } + if (!found) + { + if (NDE_Scanner_LocateFilename(s, MAINTABLE_ID_FILENAME, FIRST_RECORD, filename)) found = 1; + } + if (found) + { + NDE_Scanner_Edit(s); + db_setFieldInt(s, MAINTABLE_ID_RATING, rating); + NDE_Scanner_Post(s); + if (g_config->ReadInt(L"writeratings", 0)) + { + wchar_t buf[64] = {0}; + if (rating > 0) + { + wsprintfW(buf, L"%d", rating); + } + else + buf[0] = 0; + updateFileInfo(filename, DB_FIELDNAME_rating, buf); + SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_WRITE_EXTENDED_FILE_INFO); + } + } + + NDE_Table_DestroyScanner(g_table, s); + + LeaveCriticalSection(&g_db_cs); + } + return found != 0; +} + + +LRESULT IPC_GetFileRating(INT_PTR fileName) +{ + return IPC_GetFileRatingW((INT_PTR)(wchar_t *)AutoWide((const char *)fileName)); +} + +LRESULT IPC_SetFileRating(INT_PTR file_rating) +{ + file_set_rating *data = (file_set_rating*)file_rating; + if (!data) return 0; + file_set_ratingW dataW; + AutoWide wideFn(data->fileName); + dataW.fileName = wideFn; + dataW.newRating = data->newRating; + return IPC_SetFileRatingW((INT_PTR)&dataW); +} + +int m_calling_getfileinfo; +int getFileInfo(const char *filename, char *metadata, char *dest, int len) +{ + m_calling_getfileinfo=1; + dest[0]=0; + extendedFileInfoStruct efis={ + filename, + metadata, + dest, + len, + }; + int r = SendMessage(plugin.hwndWinampParent,WM_WA_IPC,(WPARAM)&efis,IPC_GET_EXTENDED_FILE_INFO); //will return 1 if wa2 supports this IPC call + m_calling_getfileinfo=0; + return r; +} + +LRESULT IPC_GetFileInfo(INT_PTR param) +{ + if (!param) return 0; + itemRecord *ent = (itemRecord *)param; + if (!ent->filename || ent->filename && !*ent->filename) return 0; + + char filename2[MAX_PATH] = {0}; // full lfn path if set + makeFilename2(ent->filename, filename2, ARRAYSIZE(filename2)); + + if (!g_table) openDb(); + // first, check to see if it's in the db + if (g_table) + { + EnterCriticalSection(&g_db_cs); + + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + + if (NDE_Scanner_LocateFilename(s, MAINTABLE_ID_FILENAME, FIRST_RECORD, (AutoWideFn)(ent->filename)) || + (filename2[0] && NDE_Scanner_LocateFilename(s, MAINTABLE_ID_FILENAME, FIRST_RECORD, (AutoWideFn)(filename2)))) + { + nde_field_t f; + // found it db, yay! + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_TITLE); + if (!ent->title) ent->title = f ? AutoCharDup(NDE_StringField_GetString(f)) : 0; + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_ALBUM); + if (!ent->album) ent->album = f ? AutoCharDup(NDE_StringField_GetString(f)) : 0; + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_ARTIST); + if (!ent->artist) ent->artist = f ? AutoCharDup(NDE_StringField_GetString(f)) : 0; + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_GENRE); + if (!ent->genre) ent->genre = f ? AutoCharDup(NDE_StringField_GetString(f)) : 0; + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_TRACKNB); + if (ent->track <= 0) ent->track = f ? NDE_IntegerField_GetValue(f) : -1; + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_YEAR); + if (ent->year <= 0) ent->year = f ? NDE_IntegerField_GetValue(f) : -1; + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_LENGTH); + if (ent->length <= 0) ent->length = f ? NDE_IntegerField_GetValue(f) : -1; + //ent->extended_info=NULL;//for now + + NDE_Table_DestroyScanner(g_table, s); + LeaveCriticalSection(&g_db_cs); + return 0; + } + NDE_Table_DestroyScanner(g_table, s); + LeaveCriticalSection(&g_db_cs); + } + // if not, run the same shit as if we were adding it to the db! + + char *fnp = filename2[0] ? filename2 : ent->filename; // fnp is the file we will run through the guesswork + + char tmp[1024] = {0, }; + if (getFileInfo(fnp, "title", tmp, ARRAYSIZE(tmp) - 1)) + { + if (tmp[0] && !ent->title) + { + ent->title = _strdup(tmp); + } + if (!ent->artist) + { + getFileInfo(ent->filename, "artist", tmp, ARRAYSIZE(tmp) - 1); + if (tmp[0]) + { + ent->artist = _strdup(tmp); + } + } + if (!ent->album) + { + getFileInfo(ent->filename, "album", tmp, ARRAYSIZE(tmp) - 1); + if (tmp[0]) + { + ent->album = _strdup(tmp); + } + } + if (ent->year <= 0) + { + getFileInfo(ent->filename, "year", tmp, ARRAYSIZE(tmp) - 1); + if (tmp[0] && !strstr(tmp, "__") && !strstr(tmp, "/") && !strstr(tmp, "\\") && !strstr(tmp, ".")) + { + char *p = tmp; + while (p && *p) + { + if (*p == '_') *p = '0'; + p++; + } + int y = atoi(tmp); + if (y != 0) ent->year = y; + } + } + if (!ent->genre) + { + getFileInfo(ent->filename, "genre", tmp, ARRAYSIZE(tmp) - 1); + if (tmp[0]) + { + ent->genre = _strdup(tmp); + } + } + if (ent->track <= 0) + { + getFileInfo(ent->filename, "track", tmp, ARRAYSIZE(tmp) - 1); + if (tmp[0]) + { + ent->track = atoi(tmp); + } + } + if (ent->length <= 0) + { + getFileInfo(ent->filename, "length", tmp, ARRAYSIZE(tmp) - 1); + if (tmp[0]) + { + ent->length = atoi(tmp) / 1000; + } + } + } + if (!ent->title && !ent->artist && !ent->album && !ent->track) + { + int tn = 0; + wchar_t *artist = 0, *album = 0, *title = 0; + wchar_t *guessbuf = guessTitles(AutoWide(filename2[0] ? filename2 : ent->filename), &tn, &artist, &album, &title); + if (guessbuf) + { + if (!ent->title && title) + { + ent->title = AutoCharDup(title); + } + if (!ent->artist && artist) + { + ent->artist = AutoCharDup(artist); + } + if (!ent->album && album) + { + ent->album = AutoCharDup(album); + } + if (ent->track <= 0 && tn) + { + ent->track = tn; + } + free(guessbuf); + } + } + return 0; +} + +int m_calling_getfileinfoW; +static int getFileInfoW(const wchar_t *filename, const wchar_t *metadata, wchar_t *dest, int len) +{ + m_calling_getfileinfoW=1; + dest[0]=0; + extendedFileInfoStructW efis={ + filename, + metadata, + dest, + len, + }; + int r = SendMessage(plugin.hwndWinampParent,WM_WA_IPC,(WPARAM)&efis,IPC_GET_EXTENDED_FILE_INFOW); //will return 1 if wa2 supports this IPC call + m_calling_getfileinfoW=0; + return r; +} + +LRESULT IPC_GetFileInfoW(INT_PTR param) +{ + if (!param) return 0; + itemRecordW *ent = (itemRecordW *)param; + if (!ent->filename || ent->filename && !*ent->filename) return 0; + + wchar_t filename2[MAX_PATH] = {0}; // full lfn path if set + makeFilename2W(ent->filename, filename2, ARRAYSIZE(filename2)); + + if (!g_table) openDb(); + // first, check to see if it's in the db + if (g_table) + { + EnterCriticalSection(&g_db_cs); + + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + + if (NDE_Scanner_LocateFilename(s, MAINTABLE_ID_FILENAME, FIRST_RECORD, ent->filename) || + (filename2[0] && NDE_Scanner_LocateFilename(s, MAINTABLE_ID_FILENAME, FIRST_RECORD, filename2))) + { + nde_field_t f; + // found it db, yay! + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_TITLE); + if (!ent->title) ent->title = f ? NDE_StringField_GetString(f) : 0; + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_ALBUM); + if (!ent->album) ent->album = f ? NDE_StringField_GetString(f) : 0; + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_ARTIST); + if (!ent->artist) ent->artist = f ? NDE_StringField_GetString(f) : 0; + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_GENRE); + if (!ent->genre) ent->genre = f ? NDE_StringField_GetString(f) : 0; + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_TRACKNB); + if (ent->track <= 0) ent->track = f ? NDE_IntegerField_GetValue(f) : -1; + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_YEAR); + if (ent->year <= 0) ent->year = f ? NDE_IntegerField_GetValue(f) : -1; + f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_LENGTH); + if (ent->length <= 0) ent->length = f ? NDE_IntegerField_GetValue(f) : -1; + //ent->extended_info=NULL;//for now + + NDE_Table_DestroyScanner(g_table, s); + LeaveCriticalSection(&g_db_cs); + return 0; + } + NDE_Table_DestroyScanner(g_table, s); + LeaveCriticalSection(&g_db_cs); + } + // if not, run the same shit as if we were adding it to the db! + + wchar_t *fnp = filename2[0] ? filename2 : ent->filename; // fnp is the file we will run through the guesswork + + wchar_t tmp[1024] = {0, }; + if (getFileInfoW(fnp, DB_FIELDNAME_title, tmp, ARRAYSIZE(tmp) - 1)) + { + if (tmp[0] && !ent->title) + { + ent->title = _wcsdup(tmp); + } + if (!ent->artist) + { + getFileInfoW(ent->filename, DB_FIELDNAME_artist, tmp, ARRAYSIZE(tmp) - 1); + if (tmp[0]) + { + ent->artist = _wcsdup(tmp); + } + } + if (!ent->album) + { + getFileInfoW(ent->filename, DB_FIELDNAME_album, tmp, ARRAYSIZE(tmp) - 1); + if (tmp[0]) + { + ent->album = _wcsdup(tmp); + } + } + if (ent->year <= 0) + { + getFileInfoW(ent->filename, DB_FIELDNAME_year, tmp, ARRAYSIZE(tmp) - 1); + if (tmp[0] && !wcsstr(tmp, L"__") && !wcsstr(tmp, L"/") && !wcsstr(tmp, L"\\") && !wcsstr(tmp, L".")) + { + wchar_t *p = tmp; + while (p && *p) + { + if (*p == L'_') *p = L'0'; + p++; + } + int y = _wtoi(tmp); + if (y != 0) ent->year = y; + } + } + if (!ent->genre) + { + getFileInfoW(ent->filename, DB_FIELDNAME_genre, tmp, ARRAYSIZE(tmp) - 1); + if (tmp[0]) + { + ent->genre = _wcsdup(tmp); + } + } + if (ent->track <= 0) + { + getFileInfoW(ent->filename, DB_FIELDNAME_track, tmp, ARRAYSIZE(tmp) - 1); + if (tmp[0]) + { + ent->track = _wtoi(tmp); + } + } + if (ent->length <= 0) + { + getFileInfoW(ent->filename, DB_FIELDNAME_length, tmp, ARRAYSIZE(tmp) - 1); + if (tmp[0]) + { + ent->length = _wtoi(tmp) / 1000; + } + } + } + if (!ent->title && !ent->artist && !ent->album && !ent->track) + { + int tn = 0; + wchar_t *artist = 0, *album = 0, *title = 0; + wchar_t *guessbuf = guessTitles(filename2[0] ? filename2 : ent->filename, &tn, &artist, &album, &title); + if (guessbuf) + { + if (!ent->title && title) + { + ent->title = _wcsdup(title); + } + if (!ent->artist && artist) + { + ent->artist = _wcsdup(artist); + } + if (!ent->album && album) + { + ent->album = _wcsdup(album); + } + if (ent->track <= 0 && tn) + { + ent->track = tn; + } + free(guessbuf); + } + } + return 0; +} + +LRESULT IPC_FreeFileInfo(INT_PTR param) +{ + itemRecord *ent = (itemRecord *)param; + if (!param) return 0; + if (ent->album) + { + free(ent->album); ent->album = NULL; + } + if (ent->artist) + { + free(ent->artist); ent->artist = NULL; + } + if (ent->comment) + { + free(ent->comment); ent->comment = NULL; + } + if (ent->genre) + { + free(ent->genre); ent->genre = NULL; + } + if (ent->title) + { + free(ent->title); ent->title = NULL; + } + //if (ent->extended_info) { free(ent->extended_info); ent->extended_info= NULL; } + + return 0; +} + +LRESULT IPC_FreeFileInfoW(INT_PTR param) +{ + itemRecordW *ent = (itemRecordW *)param; + if (!param) return 0; + if (ent->album) + { + free(ent->album); ent->album = NULL; + } + if (ent->artist) + { + free(ent->artist); ent->artist = NULL; + } + if (ent->comment) + { + free(ent->comment); ent->comment = NULL; + } + if (ent->genre) + { + free(ent->genre); ent->genre = NULL; + } + if (ent->title) + { + free(ent->title); ent->title = NULL; + } + //if (ent->extended_info) { free(ent->extended_info); ent->extended_info= NULL; } + + return 0; +} + +LRESULT IPC_EditView(INT_PTR param) +{ + static char dummyNameChar[256]; + static char dummyQueryChar[1024]; + ml_editview *mev = (ml_editview *)param; + if (mev == NULL) return 0; + if (queryEditOther(mev->dialog_parent, mev->query, mev->name, mev->mode)) + { + mev->mode = m_item_mode; + WideCharToMultiByteSZ(CP_ACP, 0, m_item_name, -1, dummyNameChar, 256, 0, 0); + mev->name = dummyNameChar; + WideCharToMultiByteSZ(CP_ACP, 0, m_item_query, -1, dummyQueryChar, 1024, 0, 0); + mev->query = dummyQueryChar; + } + else + { + mev->dialog_parent = NULL; + mev->mode = -1; + mev->name = NULL; + mev->query = NULL; + return 0; + } + return 1; +} + +LRESULT IPC_EditQuery(INT_PTR param) +{ + static char staticQuery[4096]; + ml_editquery *meq = (ml_editquery *)param; + if (meq == NULL) return 0; + wchar_t querybuf[4096] = {0}; + const wchar_t *newQuery = editQuery(meq->dialog_parent, AutoWide(meq->query), querybuf, 4096); + WideCharToMultiByteSZ(CP_ACP, 0, newQuery, -1, staticQuery, 4096, 0, 0); + meq->query = staticQuery; + return meq->query != NULL; +} + +bool FindFileInDB(nde_scanner_t s, const wchar_t *filename) +{ + wchar_t filename2[MAX_PATH] = {0}; // full lfn path if set + return !!FindFileInDatabase(s, MAINTABLE_ID_FILENAME, filename, filename2); +} + +INT_PTR HandleIpcMessage(INT_PTR msg, INT_PTR param) +{ + switch (msg) + { + /////////////////////// database API + case ML_IPC_DB_RUNQUERYW: + case ML_IPC_DB_RUNQUERY_SEARCHW: + case ML_IPC_DB_RUNQUERY_FILENAMEW: + case ML_IPC_DB_RUNQUERY_INDEXW: + if (!g_table) openDb(); + if (param && g_table) + { + mlQueryStructW *p = (mlQueryStructW *)param; + itemRecordListW *obj = &p->results; + int failed = 0; + + EnterCriticalSection(&g_db_cs); + + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + if (msg == ML_IPC_DB_RUNQUERY_SEARCHW) + { + if (p->query) + { + GayStringW gs; + makeQueryStringFromText(&gs, p->query); + if (gs.Get() && gs.Get()[0]) NDE_Scanner_Query(s, gs.Get()); + } + NDE_Scanner_First(s); + } + else if (msg == ML_IPC_DB_RUNQUERY_INDEXW) + { + failed=1; + } + else if (msg == ML_IPC_DB_RUNQUERY_FILENAMEW) + { + failed = 1; + if (p->query) + { + if (NDE_Scanner_LocateFilename(s, MAINTABLE_ID_FILENAME, FIRST_RECORD, p->query)) + { + failed = 0; + } + } + } + else + { + if (p->query) + NDE_Scanner_Query(s, p->query); + NDE_Scanner_First(s); + } + + if (!failed) + { + int cnt = 0; + do + { + nde_field_t f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_FILENAME); + if (!f) break; + + allocRecordList(obj, obj->Size + 1); + if (!obj->Alloc) break; + + obj->Items[obj->Size].filename = NDE_StringField_GetString(f); + ndestring_retain(obj->Items[obj->Size].filename); + ScannerRefToObjCacheNFNW(s, obj, true); + + // this makes 0 give unlimited results, 1 give 1, and so on. + if (++cnt == p->max_results || msg == ML_IPC_DB_RUNQUERY_FILENAMEW + /*|| msg == ML_IPC_DB_RUNQUERY_INDEX*/) break; + + } + while (NDE_Scanner_Next(s)); + } + + NDE_Table_DestroyScanner(g_table, s); + LeaveCriticalSection(&g_db_cs); + + compactRecordList(obj); + + return failed ? -1 : 1; + } + return -1; + + case ML_IPC_DB_RUNQUERY: + case ML_IPC_DB_RUNQUERY_SEARCH: + case ML_IPC_DB_RUNQUERY_FILENAME: + case ML_IPC_DB_RUNQUERY_INDEX: + { + mlQueryStruct *p = (mlQueryStruct*)param; + mlQueryStructW pW; + AutoWide wideQuery(p->query); + pW.query = wideQuery; + pW.max_results = p->max_results; + memset(&pW.results, 0, sizeof(pW.results)); + INT_PTR res = HandleIpcMessage(msg+0x1000, (INT_PTR)&pW); // convienently the W messages are 0x1000 higher + itemRecordList *obj = &p->results; + // append new results to old results + for (int i=0;i!=pW.results.Size;i++) + { + allocRecordList(obj, obj->Size + 1); + if (!obj->Alloc) break; + convertRecord(&obj->Items[obj->Size++], &pW.results.Items[i]); + } + freeRecordList(&pW.results); + return res; + } + case ML_IPC_DB_FREEQUERYRESULTS: + if (param) + { + mlQueryStruct *p = (mlQueryStruct*)param; + freeRecordList(&p->results); + return 1; + } + return -1; + case ML_IPC_DB_FREEQUERYRESULTSW: + if (param) + { + mlQueryStructW *p = (mlQueryStructW*)param; + freeRecordList(&p->results); + return 1; + } + return -1; + case ML_IPC_DB_REMOVEITEM: + case ML_IPC_DB_REMOVEITEMW: + if (!g_table) openDb(); + if (param && g_table) + { + wchar_t *filename = (((msg == ML_IPC_DB_REMOVEITEMW) ? (wchar_t*)param : AutoWideFn((char*)param))); + int ret = ( RemoveFileFromDB(filename) == 0 ) ? 1 : -2; // Change the return value from the stadard 0 == success, > 0 == fail + return ret; + } + return -1; + case ML_IPC_DB_UPDATEITEMW: + case ML_IPC_DB_ADDORUPDATEITEMW: + if (!g_table) openDb(); + if (param && g_table) + { + int ret = 1; + itemRecordW *item = (itemRecordW*)param; + if (!item->filename) return -1; + + EnterCriticalSection(&g_db_cs); + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + + if (FindFileInDB(s, item->filename)) + { + NDE_Scanner_Edit(s); + } + else + { + if (msg == ML_IPC_DB_UPDATEITEMW) ret = -2; + else + { + // new file + NDE_Scanner_New(s); + db_setFieldStringW(s, MAINTABLE_ID_FILENAME, item->filename); + db_setFieldInt(s, MAINTABLE_ID_DATEADDED, (int)time(NULL)); + } + } + if (ret == 1) + { + // update applicable members + if (item->title) db_setFieldStringW(s, MAINTABLE_ID_TITLE, item->title); + if (item->album) db_setFieldStringW(s, MAINTABLE_ID_ALBUM, item->album); + if (item->artist) db_setFieldStringW(s, MAINTABLE_ID_ARTIST, item->artist); + if (item->comment) db_setFieldStringW(s, MAINTABLE_ID_COMMENT, item->comment); + if (item->genre) db_setFieldStringW(s, MAINTABLE_ID_GENRE, item->genre); + if (item->albumartist) db_setFieldStringW(s, MAINTABLE_ID_ALBUMARTIST, item->albumartist); + if (item->replaygain_album_gain) db_setFieldStringW(s, MAINTABLE_ID_ALBUMGAIN, item->replaygain_album_gain); + if (item->replaygain_track_gain) db_setFieldStringW(s, MAINTABLE_ID_TRACKGAIN, item->replaygain_track_gain); + if (item->publisher) db_setFieldStringW(s, MAINTABLE_ID_PUBLISHER, item->publisher); + if (item->composer) db_setFieldStringW(s, MAINTABLE_ID_COMPOSER, item->composer); + if (item->category) db_setFieldStringW(s, MAINTABLE_ID_CATEGORY, item->category); + if (item->year >= 0) db_setFieldInt(s, MAINTABLE_ID_YEAR, item->year); + if (item->track >= 0) db_setFieldInt(s, MAINTABLE_ID_TRACKNB, item->track); + if (item->tracks >= 0) db_setFieldInt(s, MAINTABLE_ID_TRACKS, item->tracks); + if (item->length >= 0) db_setFieldInt(s, MAINTABLE_ID_LENGTH, item->length); + if (item->rating >= 0) + { + db_setFieldInt(s, MAINTABLE_ID_RATING, item->rating); + if (g_config->ReadInt(L"writeratings", 0)) + { + wchar_t buf[64] = {0}; + if (item->rating > 0) + { + wsprintfW(buf, L"%d", item->rating); + } + else + buf[0] = 0; + updateFileInfo(item->filename, DB_FIELDNAME_rating, buf); + SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_WRITE_EXTENDED_FILE_INFO); + } + } + if (item->lastplay >= 0) db_setFieldInt(s, MAINTABLE_ID_LASTPLAY, (int)item->lastplay); + if (item->lastupd >= 0) db_setFieldInt(s, MAINTABLE_ID_LASTUPDTIME, (int)item->lastupd); + if (item->filetime >= 0) db_setFieldInt(s, MAINTABLE_ID_FILETIME, (int)item->filetime); + if (item->filesize >= 0) + { + // changed in 5.64 to use the 'realsize' if it's available, otherwise map to filesize scaled to bytes (was stored as kb previously) + const wchar_t *realsize = getRecordExtendedItem(item, L"realsize"); + if (realsize) db_setFieldInt64(s, MAINTABLE_ID_FILESIZE, _wtoi64(realsize)); + else db_setFieldInt(s, MAINTABLE_ID_FILESIZE, item->filesize * 1024); + } + if (item->bitrate >= 0) db_setFieldInt(s, MAINTABLE_ID_BITRATE, item->bitrate); + if (item->type >= 0) db_setFieldInt(s, MAINTABLE_ID_TYPE, item->type); + if (item->disc >= 0) db_setFieldInt(s, MAINTABLE_ID_DISC, item->disc); + if (item->discs >= 0) db_setFieldInt(s, MAINTABLE_ID_DISCS, item->discs); + if (item->bpm >= 0) db_setFieldInt(s, MAINTABLE_ID_BPM, item->bpm); + // give a default playcnt of 0 if we're creating a new one and the caller + // didn't specify a playcnt + if (item->playcount >= 0) + db_setFieldInt(s, MAINTABLE_ID_PLAYCOUNT, item->playcount); + else + db_setFieldInt(s, MAINTABLE_ID_PLAYCOUNT, 0); + + for (int x = 0; x < NUM_EXTRA_COLSW; x ++) + { + wchar_t *at = getRecordExtendedItem(item, extra_strsW[x]); // can't use _fast here because it's not our itemRecordW + if (at) + { + switch (extra_idsW[x]) + { + case MAINTABLE_ID_LOSSLESS: + case MAINTABLE_ID_PODCASTPUBDATE: + case MAINTABLE_ID_ISPODCAST: + case MAINTABLE_ID_WIDTH: + case MAINTABLE_ID_HEIGHT: + if (*at) + db_setFieldInt(s, extra_idsW[x], _wtoi(at)); + break; + case MAINTABLE_ID_GRACENOTEFILEID: + case MAINTABLE_ID_GRACENOTEEXTDATA: + case MAINTABLE_ID_PODCASTCHANNEL: + case MAINTABLE_ID_CODEC: + case MAINTABLE_ID_DIRECTOR: + case MAINTABLE_ID_PRODUCER: + db_setFieldStringW(s, extra_idsW[x], at); + break; + } + } + } + + NDE_Scanner_Post(s); + g_table_dirty++; + } + NDE_Table_DestroyScanner(g_table, s); + LeaveCriticalSection(&g_db_cs); + + return ret; + } + return -1; + + case ML_IPC_DB_UPDATEITEM: + case ML_IPC_DB_ADDORUPDATEITEM: + { + itemRecord *item = (itemRecord*)param; + if (!item || !item->filename) + return -1; + itemRecordW wideRecord; + memset(&wideRecord, 0, sizeof(wideRecord)); + convertRecord(&wideRecord, item); + INT_PTR res = HandleIpcMessage(msg+0x1000, (INT_PTR)&wideRecord); // unicode message values are convienantly 0x1000 higher here + freeRecord(&wideRecord); + return res; + } + + case ML_IPC_DB_UPDATEFILEW: + case ML_IPC_DB_ADDORUPDATEFILEW: + if (!g_table) openDb(); + if (param && g_table) + { + LMDB_FILE_ADD_INFOW *fi = (LMDB_FILE_ADD_INFOW *)param; + if (!fi || !fi->fileName) return -1; + + int guess = (fi->gues_mode == -1) ? g_config->ReadInt(L"guessmode", 0) : fi->gues_mode; + int meta = (fi->meta_mode == -1) ? g_config->ReadInt(L"usemetadata", 1) : fi->meta_mode; + return addFileToDb(fi->fileName, msg == ML_IPC_DB_UPDATEFILEW ? 1 : 0, meta, guess); + } + return -1; + case ML_IPC_DB_UPDATEFILE: + case ML_IPC_DB_ADDORUPDATEFILE: + if (!g_table) openDb(); + if (param && g_table) + { + LMDB_FILE_ADD_INFO *fi = (LMDB_FILE_ADD_INFO*)param; + if (!fi || !fi->fileName) return -1; + + int guess = (fi->gues_mode == -1) ? g_config->ReadInt(L"guessmode", 0) : fi->gues_mode; + int meta = (fi->meta_mode == -1) ? g_config->ReadInt(L"usemetadata", 1) : fi->meta_mode; + return addFileToDb(AutoWide(fi->fileName), msg == ML_IPC_DB_UPDATEFILE ? 1 : 0, meta, guess); + } + return -1; + case ML_IPC_DB_SYNCDB: + if (!g_table) openDb(); + if (g_table && g_table_dirty) + { + EnterCriticalSection(&g_db_cs); + g_table_dirty = 0; + NDE_Table_Sync(g_table); + LeaveCriticalSection(&g_db_cs); + return 1; + } + return -1; + + case ML_IPC_GET_FILE_RATINGW: return IPC_GetFileRatingW(param); + case ML_IPC_SET_FILE_RATINGW: return IPC_SetFileRatingW(param); + case ML_IPC_GET_FILE_RATING: return IPC_GetFileRating(param); + case ML_IPC_SET_FILE_RATING: return IPC_SetFileRating(param); + case ML_IPC_FREEFILEINFO: return IPC_FreeFileInfo(param); + case ML_IPC_FREEFILEINFOW: return IPC_FreeFileInfoW(param); + case ML_IPC_GETFILEINFO: return IPC_GetFileInfo(param); + case ML_IPC_GETFILEINFOW: return IPC_GetFileInfoW(param); + case ML_IPC_PLAY_PLAYLIST: + case ML_IPC_LOAD_PLAYLIST: + { + // play/load the playlist passed as param + queryItem *item = m_query_list[param]; + if (item) + { + wchar_t configDir[MAX_PATH] = {0}; + PathCombineW(configDir, g_viewsDir, item->metafn); + C_Config viewconf(configDir); + main_playQuery(&viewconf, item->query, 0, msg == ML_IPC_PLAY_PLAYLIST); + } + } + break; + case ML_IPC_EDITVIEW: return IPC_EditView(param); + case ML_IPC_EDITQUERY: return IPC_EditQuery(param); + case ML_IPC_SMARTVIEW_COUNT: + return m_query_list.size(); + case ML_IPC_SMARTVIEW_INFO: + if (param) + { + mlSmartViewInfo * v = (mlSmartViewInfo *)param; + if (v->size < sizeof(mlSmartViewInfo)) break; + if (v->smartViewNum >= m_query_list.size()) break; + + auto it = m_query_list.begin(); + while (v->smartViewNum--) + { + it++; + } + queryItem* q = it->second; //(m_query_list.begin()+v->smartViewNum)->second; + + if (!q) break; + if (!q->name || !q->query) break; + v->treeItemId = it->first; //(m_query_list.begin()+v->smartViewNum)->first; + v->iconImgIndex = q->imgIndex; + v->mode = q->mode; + lstrcpynW(v->smartViewName,q->name,sizeof(v->smartViewName)/sizeof(wchar_t)); + lstrcpynW(v->smartViewQuery,q->query,sizeof(v->smartViewQuery)/sizeof(wchar_t)); + return 1; + } + break; + case ML_IPC_SMARTVIEW_ADD: + if (param) + { + mlSmartViewInfo * v = (mlSmartViewInfo *)param; + if (v->size < sizeof(mlSmartViewInfo)) break; + v->treeItemId = addQueryItem(v->smartViewName,v->smartViewQuery,v->mode,0,NULL,v->iconImgIndex, v->smartViewNum); + saveQueryTree(); + return 1; + } + break; + } + return 0; +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/local_menu.cpp b/Src/Plugins/Library/ml_local/local_menu.cpp new file mode 100644 index 00000000..0b55496a --- /dev/null +++ b/Src/Plugins/Library/ml_local/local_menu.cpp @@ -0,0 +1,272 @@ +#include "main.h" +#include "./local_menu.h" +#include "./resource.h" +#include "..\..\General\gen_ml/menu.h" +#include "../nu/menushortcuts.h" + +#define RATING_MARKER MAKELONG(MAKEWORD('R','A'),MAKEWORD('T','E')) +#define RATING_MINSPACECX 16 + +#if 0 +static BOOL Menu_IsRatingStar(HMENU hMenu, INT itemId, INT *valueOut) +{ + WCHAR szBuffer[8] = {0}; + INT cchBuffer = GetMenuStringW(hMenu, itemId, szBuffer, ARRAYSIZE(szBuffer), MF_BYCOMMAND); + if (cchBuffer < 1 || cchBuffer > 5) + return FALSE; + + for (INT i = 1; i < cchBuffer; i++) + { + if (szBuffer[i -1] != szBuffer[i]) + return FALSE; + } + + if (NULL != valueOut) + *valueOut = cchBuffer; + + return TRUE; +} + +static BOOL Menu_MeasureRating(HMENU hMenu, HDC hdc, MEASUREITEMSTRUCT *pmis) +{ + if (NULL == hdc || !Menu_IsRatingStar(hMenu, pmis->itemID, NULL)) + return FALSE; + + RECT rect; + if (!MLRating_CalcRect(plugin.hwndLibraryParent, NULL, 5, &rect)) + return FALSE; + + pmis->itemHeight = rect.bottom - rect.top + 6; + + TEXTMETRIC tm = {0}; + if (GetTextMetrics(hdc, &tm) && + (UINT)(tm.tmHeight + 2) > pmis->itemHeight) + { + pmis->itemHeight = tm.tmHeight + 2; + } + + INT spaceCX = (pmis->itemHeight > RATING_MINSPACECX) ? pmis->itemHeight : RATING_MINSPACECX; + pmis->itemWidth = rect.right - rect.left + (2 * spaceCX) - (GetSystemMetrics(SM_CXMENUCHECK) - 1); + return TRUE; +} + +static BOOL Menu_DrawRating(HMENU hMenu, HDC hdc, DRAWITEMSTRUCT *pdis) +{ + INT ratingValue; + if (NULL == hdc || !Menu_IsRatingStar(hMenu, pdis->itemID, &ratingValue)) + return FALSE; + + INT spaceCX = ((pdis->rcItem.bottom - pdis->rcItem.top) > RATING_MINSPACECX) ? + (pdis->rcItem.bottom - pdis->rcItem.top) : + RATING_MINSPACECX; + + RATINGDRAWPARAMS rdp = {0}; + rdp.cbSize = sizeof(RATINGDRAWPARAMS); + rdp.hdcDst = hdc; + rdp.rc = pdis->rcItem; + rdp.rc.left += spaceCX + WASABI_API_APP->getScaleX(13); + rdp.value = ratingValue; + rdp.maxValue = 5; + + UINT menuState = GetMenuState(hMenu, pdis->itemID, MF_BYCOMMAND); + rdp.trackingValue = (0 != (ODS_SELECTED & pdis->itemState) && + 0 == ((MF_DISABLED | MF_GRAYED) & menuState)) ? + rdp.value : + 0; + + rdp.fStyle = RDS_LEFT | RDS_VCENTER | RDS_HOT; + rdp.hMLIL = NULL; + rdp.index = 0; + + return MLRating_Draw(plugin.hwndLibraryParent, &rdp); +} + +static BOOL CALLBACK Menu_CustomDrawProc(INT action, HMENU hMenu, HDC hdc, LPARAM param, ULONG_PTR user) +{ + switch(action) + { + case MLMENU_ACTION_MEASUREITEM: + if (hMenu == (HMENU)user) + return Menu_MeasureRating(hMenu, hdc, (MEASUREITEMSTRUCT*)param); + break; + case MLMENU_ACTION_DRAWITEM: + if (hMenu == (HMENU)user) + return MLMENU_WANT_DRAWPART; + break; + case MLMENU_ACTION_DRAWBACK: + break; + case MLMENU_ACTION_DRAWICON: + break; + case MLMENU_ACTION_DRAWTEXT: + if (hMenu == (HMENU)user) + return Menu_DrawRating(hMenu, hdc, (DRAWITEMSTRUCT*)param); + break; + } + return FALSE; +} +#endif + +static HMENU Menu_FindRatingMenuRecur(HMENU hMenu, MENUINFO *pmi, MENUITEMINFO *pmii) +{ + if (GetMenuInfo(hMenu, pmi) && RATING_MARKER == pmi->dwMenuData) + return hMenu; + + INT count = GetMenuItemCount(hMenu); + for(INT i = 0; i < count; i++) + { + if (GetMenuItemInfo(hMenu, i, TRUE, pmii) && NULL != pmii->hSubMenu) + { + HMENU hRating = Menu_FindRatingMenuRecur(pmii->hSubMenu, pmi, pmii); + if (NULL != hRating) + return hRating; + } + } + return NULL; +} + +HMENU Menu_FindRatingMenu(HMENU hMenu) +{ + if (NULL == hMenu) + return NULL; + + MENUITEMINFO mii = {0}; + mii.cbSize = sizeof(MENUITEMINFO); + mii.fMask = MIIM_SUBMENU; + + MENUINFO mi; + mi.cbSize = sizeof(MENUINFO); + mi.fMask = MIM_MENUDATA; + + return Menu_FindRatingMenuRecur(hMenu, &mi, &mii); +} + +BOOL Menu_SetRatingValue(HMENU ratingMenu, INT ratingValue) +{ + if (NULL == ratingMenu) return FALSE; + + INT ratingList[] = { ID_RATE_0, ID_RATE_1, ID_RATE_2, + ID_RATE_3, ID_RATE_4, ID_RATE_5}; + + /// set rating marker + MENUINFO mi = {0}; + mi.cbSize = sizeof(MENUINFO); + mi.fMask = MIM_MENUDATA; + mi.dwMenuData = RATING_MARKER; + if (!SetMenuInfo(ratingMenu, &mi)) + return FALSE; + + + MENUITEMINFO mii = {0}; + mii.cbSize = sizeof(MENUITEMINFO); + + UINT type, state; + for (INT i = 0; i < ARRAYSIZE(ratingList); i++) + { + mii.fMask = MIIM_STATE | MIIM_FTYPE; + if (GetMenuItemInfo(ratingMenu, ratingList[i], FALSE, &mii)) + { + if (ratingValue == i) + { + type = mii.fType | MFT_RADIOCHECK; + state = mii.fState | MFS_CHECKED; + } + else + { + type = mii.fType & ~MFT_RADIOCHECK; + state = mii.fState & ~MFS_CHECKED; + } + + mii.fMask = 0; + if (type != mii.fType) + { + mii.fType = type; + mii.fMask |= MIIM_FTYPE; + } + + if (state != mii.fState) + { + mii.fState = state; + mii.fMask |= MIIM_STATE; + } + + if (0 != mii.fMask) + SetMenuItemInfo(ratingMenu, ratingList[i], FALSE, &mii); + } + } + return TRUE; +} + + +void SyncMenuWithAccelerators(HWND hwndDlg, HMENU menu) +{ + HACCEL szAccel[24] = {0}; + INT c = WASABI_API_APP->app_getAccelerators(hwndDlg, szAccel, sizeof(szAccel)/sizeof(szAccel[0]), FALSE); + AppendMenuShortcuts(menu, szAccel, c, MSF_REPLACE); +} + +void SwapPlayEnqueueInMenu(HMENU listMenu) +{ + int playPos=-1, enqueuePos=-1; + MENUITEMINFOW playItem={sizeof(MENUITEMINFOW), 0,}, enqueueItem={sizeof(MENUITEMINFOW), 0,}; + + int numItems = GetMenuItemCount(listMenu); + + int alt = 0; + for (int i=0;i<numItems;i++) + { + UINT id = GetMenuItemID(listMenu, i); + if (id == ID_MEDIAWND_PLAYSELECTEDFILES || id == ID_AUDIOWND_PLAYSELECTION || id == ID_QUERYWND_PLAYQUERY) + { + playItem.fMask = MIIM_ID; + playPos = i; + GetMenuItemInfoW(listMenu, i, TRUE, &playItem); + if (id == ID_AUDIOWND_PLAYSELECTION) alt = 1; + else if (id == ID_QUERYWND_PLAYQUERY) alt = 2; + } + else if (id == ID_MEDIAWND_ENQUEUESELECTEDFILES || id == ID_AUDIOWND_ENQUEUESELECTION || id == ID_QUERYWND_ENQUEUEQUERY) + { + enqueueItem.fMask = MIIM_ID; + enqueuePos = i; + GetMenuItemInfoW(listMenu, i, TRUE, &enqueueItem); + if (id == ID_AUDIOWND_ENQUEUESELECTION) alt = 1; + else if (id == ID_QUERYWND_ENQUEUEQUERY) alt = 2; + } + } + + playItem.wID = (alt == 1 ? ID_MEDIAWND_ENQUEUESELECTEDFILES : (alt == 2 ? ID_QUERYWND_ENQUEUEQUERY : ID_AUDIOWND_ENQUEUESELECTION)); + enqueueItem.wID = (alt == 1 ? ID_MEDIAWND_PLAYSELECTEDFILES : (alt == 2 ? ID_QUERYWND_PLAYQUERY : ID_AUDIOWND_PLAYSELECTION)); + SetMenuItemInfoW(listMenu, playPos, TRUE, &playItem); + SetMenuItemInfoW(listMenu, enqueuePos, TRUE, &enqueueItem); +} + +void UpdateMenuItems(HWND hwndDlg, HMENU menu, UINT accel_id) +{ + bool swapPlayEnqueue=false; + if (g_config->ReadInt(L"enqueuedef", 0) == 1) + { + SwapPlayEnqueueInMenu(menu); + swapPlayEnqueue=true; + } + + if(!IsWindow(hwndDlg)) + { + HACCEL accel = WASABI_API_LOADACCELERATORSW(accel_id); + int size = CopyAcceleratorTable(accel,0,0); + AppendMenuShortcuts(menu, &accel, size, MSF_REPLACE); + } + else + { + SyncMenuWithAccelerators(hwndDlg, menu); + } + + if (swapPlayEnqueue) SwapPlayEnqueueInMenu(menu); +} + +INT DoTrackPopup(HMENU hMenu, UINT fuFlags, INT x, INT y, HWND hwnd, LPTPMPARAMS lptpm) +{ + if (NULL == hMenu) + return NULL; + + return Menu_TrackPopupParam(plugin.hwndLibraryParent, hMenu, fuFlags, x, y, + hwnd, lptpm, (ULONG_PTR)Menu_FindRatingMenu(hMenu)); +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/local_menu.h b/Src/Plugins/Library/ml_local/local_menu.h new file mode 100644 index 00000000..08907d70 --- /dev/null +++ b/Src/Plugins/Library/ml_local/local_menu.h @@ -0,0 +1,15 @@ +#ifndef NULLOSFT_LOCALMEDIA_PLUGIN_MENU_HEADER +#define NULLOSFT_LOCALMEDIA_PLUGIN_MENU_HEADER + + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +#include <wtypes.h> + +BOOL Menu_SetRatingValue(HMENU ratingMenu, INT ratingValue); +INT DoTrackPopup(HMENU hMenu, UINT fuFlags, INT x, INT y, HWND hwnd, LPTPMPARAMS lptpm); +void UpdateMenuItems(HWND hwndDlg, HMENU menu, UINT accel_id); + +#endif //NULLOSFT_LOCALMEDIA_PLUGIN_MENU_HEADER
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/metaRecord.h b/Src/Plugins/Library/ml_local/metaRecord.h new file mode 100644 index 00000000..9dba63c2 --- /dev/null +++ b/Src/Plugins/Library/ml_local/metaRecord.h @@ -0,0 +1,44 @@ +#ifndef NULLSOT_LOCALMEDIA_METARECORD_H +#define NULLSOT_LOCALMEDIA_METARECORD_H + +#include <map> +#include <vector> +#include <string> + +// Links db record to the metadata struct +typedef struct +{ + int dbColumnId; + char *recordKey; +} LM_RECORD_LINK; + +// cache size (records count) +#define CACHE_SIZE 100; + +class MetaData +{ + +// construcotrs +public: + MetaData(); + ~MetaData(); + +// methods +private: + // gets record data from db to the cache + int GetDbColumnsCount(); + void GetDBRecordToCache(int64 recordId); + + +public: + // returns pointer to metadata + const char* GetMetaData(const char *metaKey); + +// fields +private: + + +} + + +#endif //NULLSOT_LOCALMEDIA_METARECORD_H
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/ml_local.cpp b/Src/Plugins/Library/ml_local/ml_local.cpp new file mode 100644 index 00000000..b6e0dde7 --- /dev/null +++ b/Src/Plugins/Library/ml_local/ml_local.cpp @@ -0,0 +1,1394 @@ +// needed for handling the nde failed load error catching +#pragma warning(disable:4530) +#include "main.h" +#include "ml_local.h" +#include <windowsx.h> +#include <time.h> +#include <rpc.h> +#include <assert.h> +#include "resource.h" +#include "..\..\General\gen_ml/config.h" +#include "..\..\General\gen_ml/gaystring.h" + +#include "..\..\General\gen_ml/ml.h" +#include "..\..\General\gen_ml/ml_ipc.h" + +#include "../nde/nde.h" +#include "../nde/nde_c.h" + +#include "..\..\General\gen_hotkeys/wa_hotkeys.h" +#include "..\..\General\gen_ml/MediaLibraryCOM.h" +#include "api__ml_local.h" + +#include "../replicant/nu/AutoWide.h" + +#include "./scanfolderbrowser.h" +#include "../replicant/nu/AutoChar.h" + +#include "api_mldb.h" + + +int IPC_GET_ML_HMENU = -1, IPC_GET_CLOUD_HINST = -1, IPC_GET_CLOUD_ACTIVE = -1; + +HMENU wa_playlists_cmdmenu = NULL; +HMENU wa_play_menu = 0; + + +wchar_t *fieldTagFunc(wchar_t * tag, void * p); //return 0 if not found + +#define WA_MENUITEM_ID 23123 + + +WNDPROC wa_oldWndProc; +BOOL myMenu = FALSE; + +HCURSOR hDragNDropCursor; + +C_Config *g_config; + +embedWindowState myWindowState; + +char g_burner_list[32] = ""; + +int asked_for_playcount = 0; +int g_bgrescan_int = 120, g_bgrescan_do = 0, g_bgrescan_force = 0, g_autochannel_do = 0; +int g_guessifany = 0; +int g_querydelay = 250; +int g_viewnotplay = 0; + +wchar_t g_path[MAX_PATH] = {0}; +wchar_t g_tableDir[MAX_PATH] = {0}; +wchar_t g_viewsDir[MAX_PATH] = {0}; + +//DB db; + +nde_database_t g_db=0; +nde_table_t g_table=0; +int g_table_dirty; + +CRITICAL_SECTION g_db_cs; + +HMENU g_context_menus = NULL, g_context_menus2 = NULL; +HWND m_curview_hwnd = NULL; + +wchar_t *m_query = L""; +int m_query_mode; + +C_Config *g_view_metaconf = NULL; + +static int m_query_moving; +static HTREEITEM m_query_moving_dragplace; +static HTREEITEM m_query_moving_item, m_query_moving_lastdest; +static int m_query_moving_dragplaceisbelow; + +int m_query_tree; + +QueryList m_query_list; + +//xp theme disabling shit +static HMODULE m_uxdll; +HRESULT(__stdcall *SetWindowTheme)(HWND hwnd, LPCWSTR pszSubAppName, LPCWSTR pszSubIdList); +HRESULT(__stdcall *IsAppThemed)(void); + +void db_setFieldStringW( nde_scanner_t s, unsigned char id, const wchar_t *data ) +{ + nde_field_t f = NDE_Scanner_GetFieldByID( s, id ); + if ( !f ) + f = NDE_Scanner_NewFieldByID( s, id ); + + NDE_StringField_SetString( f, data ); +} + +void db_setFieldInt( nde_scanner_t s, unsigned char id, int data ) +{ + nde_field_t f = NDE_Scanner_GetFieldByID( s, id ); + if ( !f ) + f = NDE_Scanner_NewFieldByID( s, id ); + + NDE_IntegerField_SetValue( f, data ); +} + +int db_getFieldInt( nde_scanner_t s, unsigned char id, int defaultVal ) +{ + nde_field_t f = NDE_Scanner_GetFieldByID( s, id ); + if ( f ) + return NDE_IntegerField_GetValue( f ); + else + return defaultVal; +} + +void db_setFieldInt64( nde_scanner_t s, unsigned char id, __int64 data ) +{ + nde_field_t f = NDE_Scanner_GetFieldByID( s, id ); + if ( !f ) + f = NDE_Scanner_NewFieldByID( s, id ); + + NDE_Int64Field_SetValue( f, data ); +} + +__int64 db_getFieldInt64( nde_scanner_t s, unsigned char id, __int64 defaultVal ) +{ + nde_field_t f = NDE_Scanner_GetFieldByID( s, id ); + if ( f ) + return NDE_Int64Field_GetValue( f ); + else + return defaultVal; +} + +void db_removeField( nde_scanner_t s, unsigned char id ) +{ + nde_field_t f = NDE_Scanner_GetFieldByID( s, id ); + if ( f ) + { + NDE_Scanner_DeleteField( s, f ); + } +} + +int pluginHandleIpcMessage(int msg, int param) +{ + return SendMessage(plugin.hwndLibraryParent, WM_ML_IPC, param, msg); +} + +void TAG_FMT_EXT(const wchar_t *filename, void *f, void *ff, void *p, wchar_t *out, int out_len, int extended) +{ + waFormatTitleExtended fmt; + fmt.filename = filename; + fmt.useExtendedInfo = extended; + fmt.out = out; + fmt.out_len = out_len; + fmt.p = p; + fmt.spec = 0; + + *(void **)&fmt.TAGFUNC = f; + *(void **)&fmt.TAGFREEFUNC = ff; + + *out = 0; + + int oldCallingGetFileInfo = m_calling_getfileinfo; + m_calling_getfileinfo = 1; + SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&fmt, IPC_FORMAT_TITLE_EXTENDED); + m_calling_getfileinfo = oldCallingGetFileInfo; +} + +void main_playItemRecordList(itemRecordListW *obj, int enqueue, int startplaying) +{ + assert(enqueue != -1); // benski> i'm pretty sure this isn't used anymore + if (obj->Size && !enqueue) + SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_DELETE); + + int x; + for (x = 0; x < obj->Size; x ++) + { + if (obj->Items[x].filename && *obj->Items[x].filename) + { + wchar_t title[2048] = {0}; + TAG_FMT_EXT(obj->Items[x].filename, itemrecordWTagFunc, ndeTagFuncFree, (void*)&obj->Items[x], title, 2047, 0); + + enqueueFileWithMetaStructW s; + s.filename = obj->Items[x].filename; + s.title = title; + s.ext = NULL; + s.length = obj->Items[x].length; +#ifndef _DEBUG + ndestring_retain(obj->Items[x].filename); + SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&s, IPC_PLAYFILEW_NDE); +#else + SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&s, IPC_PLAYFILEW); +#endif + } + } + + if (obj->Size && !enqueue && startplaying) SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_STARTPLAY); +} + +void main_playQuery(C_Config *viewconf, const wchar_t *query, int enqueue, int startplaying) +{ + // if enqueue is -1, we do it to the playlist + if (!g_table) return ; + + EnterCriticalSection(&g_db_cs); + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + NDE_Scanner_Query(s, query); + itemRecordListW obj = {0, }; + // no need to have this provide compatible kb + // based filesizes as we never use the values + saveQueryToListW(viewconf, s, &obj, 0, 0, 0); + NDE_Table_DestroyScanner(g_table, s); + LeaveCriticalSection(&g_db_cs); + + main_playItemRecordList(&obj, enqueue, startplaying); + + freeRecordList(&obj); +} + +time_t g_bgscan_last_rescan; +int g_bgscan_scanning; + +HWND updateCurrentView(HWND hwndDlg) +{ + if (m_curview_hwnd) DestroyWindow(m_curview_hwnd); + m_curview_hwnd = NULL; + + delete g_view_metaconf; + g_view_metaconf = 0; + + int id = -1; + DLGPROC proc = 0; + + if (!g_table) + { + // try to show something better than a blank view + id = IDD_VIEW_DB_ERROR; + proc = view_errorinfoDialogProc; + } + else + { + switch (m_query_mode) + { + case 0: + id = IDD_VIEW_MEDIA; proc = view_mediaDialogProc; + break; + default: + id = IDD_VIEW_AUDIO; proc = view_audioDialogProc; + break; + } + } + + if (id == -1) + proc = NULL; + + if (id != -1) + { + wchar_t configDir[MAX_PATH] = {0}; + PathCombineW(configDir, g_viewsDir, m_query_metafile); + g_view_metaconf = new C_Config(configDir); + + LPARAM lParam = 0; + INT_PTR parms[2] = {0}; + + if (g_config->ReadInt(L"useminiinfo2", 0) && (proc == view_audioDialogProc || proc == view_mediaDialogProc)) + { + parms[0] = (INT_PTR)proc; + parms[1] = (INT_PTR)id; + lParam = (LPARAM) & parms; + + id = IDD_VIEW_MINIINFO; + proc = view_miniinfoDialogProc; + } + + if (proc) + m_curview_hwnd = WASABI_API_CREATEDIALOGPARAMW(id, hwndDlg, proc, lParam); + } + + return m_curview_hwnd; +} + +void makemetafn(wchar_t *filename, wchar_t **out) +{ + int x = 0; + for (;;) + { + GetTempFileNameW(g_viewsDir, L"meta", GetTickCount() + x*4050, filename); + if (wcslen(filename) > 4) wcscpy(filename + wcslen(filename) - 4, L".vmd"); + HANDLE h = CreateFileW(filename, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, CREATE_NEW, 0, 0); + if (h != INVALID_HANDLE_VALUE) + { + CloseHandle(h); + *out = _wcsdup(filename); + PathStripPathW(*out); + return ; + } + if (++x > 4096) + { + *out = _wcsdup(L"meta-error.vmd"); + filename[0] = 0; + return ; + } + } +} + +int ImageGuessFilter( int mode, const wchar_t *val, int index ) +{ + if ( index != -1 ) + return index; + + if ( !lstrcmpiW( val, L"lastupd > [3 days ago]" ) ) + return TREE_IMAGE_LOCAL_RECENTLYMODIFIED; + if ( !lstrcmpiW( val, L"dateadded > [3 days ago]" ) ) + return TREE_IMAGE_LOCAL_RECENTLYADDED; + if ( !lstrcmpiW( val, L"playcount > 0" ) ) + return TREE_IMAGE_LOCAL_MOSTPLAYED; + if ( !lstrcmpiW( val, L"rating >= 3" ) ) + return TREE_IMAGE_LOCAL_TOPRATED; + if ( !lstrcmpiW( val, L"playcount = 0 | playcount isempty" ) ) + return TREE_IMAGE_LOCAL_NEVERPLAYED; + if ( !lstrcmpiW( val, L"lastplay > [2 weeks ago]" ) ) + return TREE_IMAGE_LOCAL_RECENTLYPLAYED; + if ( !lstrcmpiW( val, L"type = 0" ) ) + return TREE_IMAGE_LOCAL_AUDIO; + if ( !lstrcmpiW( val, L"type = 1" ) ) + return TREE_IMAGE_LOCAL_VIDEO; + + return index; +} + +int addQueryItem( const wchar_t *name, const wchar_t *val, int mode, int select, const wchar_t *metafn, int imageIndex, int num ) +{ + MLTREEITEMW newItem = { 0 }; + imageIndex = ImageGuessFilter( mode, val, imageIndex ); + + newItem.size = sizeof( newItem ); + newItem.parentId = m_query_tree; + newItem.title = const_cast<wchar_t *>( name ); + newItem.hasChildren = 0; + newItem.id = 0; + newItem.imageIndex = imageIndex; + + if ( num <= 0 ) + mediaLibrary.AddTreeItem( newItem ); + else + { + for ( QueryList::iterator iter = m_query_list.begin(); iter != m_query_list.end(); iter++ ) + { + if ( iter->second && iter->second->index == num - 1 ) + newItem.id = iter->first; break; + } + + mediaLibrary.InsertTreeItem( newItem ); + } + + queryItem *qi = (queryItem *)calloc( 1, sizeof( queryItem ) ); + qi->name = _wcsdup( name ); + qi->query = _wcsdup( val ); + qi->mode = mode; + qi->imgIndex = imageIndex; + qi->index = m_query_list.size(); + + if ( !metafn || !metafn[ 0 ] ) + { + wchar_t filename[ 1024 + 256 ] = { 0 }; + makemetafn( filename, &qi->metafn ); + } + else qi->metafn = _wcsdup( metafn ); + + m_query_list.insert({ newItem.id, qi }); + + return newItem.id; +} + +void replaceQueryItem(int n, const wchar_t *name, const wchar_t *val, int mode, int imageIndex) +{ + queryItem *qi; + + if ( mode == 32 ) + return; + + qi = m_query_list[n]; + free(qi->name); + qi->name = _wcsdup(name); + + if (val) + { + free(qi->query); + qi->query = _wcsdup(val); + } + + qi->mode = mode; + qi->imgIndex = imageIndex; + + MLTREEITEMW item; + item.hasChildren = 0; + item.id = n; + item.title = const_cast<wchar_t *>(name); + item.parentId = m_query_tree; + item.imageIndex = imageIndex; + + mediaLibrary.SetTreeItem(item); + mediaLibrary.SelectTreeItem(n - 1); + mediaLibrary.SelectTreeItem(n); +} + +wchar_t *def_names[] = { L"Audio", + L"Video", + L"Most Played", + L"Recently Added", + L"Recently Played", + L"Never Played", + L"Top Rated", + L"Recently Modified", }; +int def_str_ids[] = {IDS_AUDIO, IDS_VIDEO, IDS_MOST_PLAYED, IDS_RECENTLY_ADDED, + IDS_RECENTLY_PLAYED, IDS_NEVER_PLAYED, IDS_TOP_RATED, + IDS_RECENTLY_MODIFIED}; + +void loadQueryTree() +{ + int meta_add_dirty = 0; + int nb = g_config->ReadInt(L"query_num", 0); + int fix = g_config->ReadInt(L"query_fix", 0); + int mig = g_config->ReadInt(L"query_mig", 0); + + g_config->WriteInt(L"query_fix", 1); + g_config->WriteInt(L"query_mig", 1); + + // helps to migrate existing vmd files to plugins\ml\views + wchar_t metafnold[MAX_PATH] = {0}, metafnnew[MAX_PATH] = {0}; + if (!mig) + { + PathCombineW(metafnold, g_tableDir, L"default.vmd"); + PathCombineW(metafnnew, g_viewsDir, L"default.vmd"); + if (!PathFileExistsW(metafnnew) && PathFileExistsW(metafnold)) + { + MoveFileW(metafnold, metafnnew); + } + } + + for (int i = 0; i < nb; i++) + { + wchar_t qm[128] = {0}, qbmp[128] = {0}, qmet[128] = {0}; + char qn[128] = {0}, qv[128] = {0}, name[1024] = {0}, val[1024] = {0}; + wsprintfA(qn, "query%i_name", i + 1); + UINT codePage = CP_ACP; + + if (!g_config->ReadString(qn, NULL, name, 1024) || !*name) + { + wsprintfA(qn, "query%i_name_utf8", i + 1); + g_config->ReadString(qn, NULL, name, 1024); + codePage = CP_UTF8; + if (!name) + continue; + } + + wchar_t unicodeNameLoc[256] = {0}; + AutoWide unicodeName(name, codePage); + + wsprintfA(qv, "query%i_val", i + 1); + codePage = CP_ACP; + if (!g_config->ReadString(qv, NULL, val, 1024) || !*val) + { + wsprintfA(qv, "query%i_val_utf8", i + 1); + g_config->ReadString(qv, NULL, val, 1024); + codePage = CP_UTF8; + } + + // this will convert 'lastupd > [3 days ago]' to 'dateadded > [3 days ago]' + // on older client installs so we're making use of the new dateadded column + if (!fix && val[0]) + { + if (!_stricmp("lastupd > [3 days ago]", val)) + { + lstrcpynA(val, "dateadded > [3 days ago]", sizeof(val)); + g_config->WriteString(qv, val); + } + } + + AutoWide unicodeVal(val, codePage); + + wsprintfW(qm, L"query%i_mode", i + 1); + wsprintfW(qmet, L"query%i_meta", i + 1); + wsprintfW(qbmp, L"query%i_image", i + 1); + + int mode = g_config->ReadInt(qm, -1); + if (mode == 32 || mode == -1) + continue; // old playlist or empty + + wchar_t metafn[MAX_PATH] = {0}; + g_config->ReadString(qmet, L"", metafn, MAX_PATH); + + // helps to migrate existing vmd files to plugins\ml\views + if (!mig) + { + metafnold[0] = metafnnew[0] = 0; + PathCombineW(metafnold, g_tableDir, metafn); + PathCombineW(metafnnew, g_viewsDir, metafn); + if (!PathFileExistsW(metafnnew) && PathFileExistsW(metafnold)) + { + MoveFileW(metafnold, metafnnew); + } + } + + // see if we've got a name match to one of the defaults... + for(int j = 0; j < sizeof(def_names)/sizeof(def_names[0]); j++) + { + if(!lstrcmpiW(unicodeName, def_names[j])) + { + WASABI_API_LNGSTRINGW_BUF(def_str_ids[j], unicodeNameLoc, 256); + break; + } + } + + addQueryItem((unicodeNameLoc[0]?unicodeNameLoc:unicodeName), unicodeVal, mode, 0, metafn, max(g_config->ReadInt(qbmp, -1), -1)); + } + + int aapos = g_config->ReadInt(L"view_autoadd_pos", 0); + + if (aapos < 1) + { + if (!nb) // lame defaults added + { + meta_add_dirty = 1; + addQueryItem( WASABI_API_LNGSTRINGW( IDS_AUDIO ), L"type = 0", 1, 0, L"", TREE_IMAGE_LOCAL_AUDIO ); // new defaults + } + + typedef struct + { + int title; + wchar_t *query; + char sort_by; + char sort_dir; + char *columns; //xff terminated list :) + int imageIndex; + } + addstruct; + + addstruct m[] = + { + {IDS_VIDEO, L"type = 1", 10, 0, "\x7\1\5\x1E\6\3\x20\x8\x9\xA\xff", TREE_IMAGE_LOCAL_VIDEO}, + {IDS_MOST_PLAYED, L"playcount > 0", 9, 0, "\x9\0\1\2\3\xA\xff", TREE_IMAGE_LOCAL_MOSTPLAYED}, + {IDS_RECENTLY_ADDED, L"dateadded > [3 days ago]", 33, 0, "\x21\0\1\2\3\xff", TREE_IMAGE_LOCAL_RECENTLYADDED}, + {IDS_RECENTLY_MODIFIED, L"lastupd > [3 days ago]", 11, 0, "\xB\0\1\2\3\xff", TREE_IMAGE_LOCAL_RECENTLYMODIFIED}, + {IDS_RECENTLY_PLAYED, L"lastplay > [2 weeks ago]", 10, 0, "\xA\x9\0\1\2\3\xff", TREE_IMAGE_LOCAL_RECENTLYPLAYED}, + {IDS_NEVER_PLAYED, L"playcount = 0 | playcount isempty", 0, 0, "\0\1\2\3\xff", TREE_IMAGE_LOCAL_NEVERPLAYED}, + {IDS_TOP_RATED, L"rating >= 3", 8, 0, "\x8\x9\0\1\2\3\xff", TREE_IMAGE_LOCAL_TOPRATED}, + }; + if (aapos < 1) + { + int x; + for (x = 0; x < sizeof(m) / sizeof(m[0]); x++) + { + if (!x && nb) continue; + + wchar_t filename[1024 + 256] = {0}, *ptr = 0; + makemetafn(filename, &ptr); + + if (filename[0]) + { + C_Config foo(filename); + foo.WriteInt(L"mv_sort_by", m[x].sort_by); + foo.WriteInt(L"mv_sort_dir", m[x].sort_dir); + int cnt = 0; + while ((unsigned char)m[x].columns[cnt] != 0xff) + { + wchar_t buf[32] = {0}; + StringCchPrintfW(buf, 32, L"column%d", cnt); + foo.WriteInt(buf, (unsigned char)m[x].columns[cnt]); + cnt++; + } + + foo.WriteInt(L"nbcolumns", cnt); + meta_add_dirty = 1; + addQueryItem(WASABI_API_LNGSTRINGW(m[x].title), m[x].query, 0, 0, ptr, m[x].imageIndex); + } + + free(ptr); + } + } + + g_config->WriteInt(L"view_autoadd_pos", 1); + } + + if (meta_add_dirty) + saveQueryTree(); +} + +void saveQueryTree() +{ + int nb = g_config->ReadInt( L"query_num", 0 ); + QueryList::iterator iter; + int i = 1; + wchar_t qm[ 128 ] = { 0 }, qmet[ 128 ] = { 0 }, qbmp[ 128 ] = { 0 }; + char qn[ 128 ] = { 0 }, qv[ 128 ] = { 0 }; + + for ( int curId = mediaLibrary.GetChildId( m_query_tree ); curId != 0; curId = mediaLibrary.GetNextId( curId ), i++ ) + { + iter = m_query_list.find( curId ); + if ( iter == m_query_list.end() ) + continue; + + if ( i <= nb ) + { + do + { + wsprintfW( qm, L"query%i_mode", i ); + } while ( g_config->ReadInt( qm, -1 ) == 32 && i++ ); + } + + wsprintfA( qn, "query%i_name", i ); + wsprintfA( qv, "query%i_val", i ); + g_config->WriteString( qn, 0 ); // erase these old config items + g_config->WriteString( qv, 0 ); // erase these old config items + + wsprintfA( qn, "query%i_name_utf8", i ); + wsprintfA( qv, "query%i_val_utf8", i ); + wsprintfW( qm, L"query%i_mode", i ); + wsprintfW( qmet, L"query%i_meta", i ); + wsprintfW( qbmp, L"query%i_image", i ); + + queryItem *thisitem = iter->second; + if ( thisitem == NULL ) continue; + + wchar_t charNameLoc[ 256 ] = { 0 }; + // see if we've got a name match to one of the defaults... + for ( int j = 0; j < sizeof( def_names ) / sizeof( def_names[ 0 ] ); j++ ) + { + if ( !lstrcmpiW( thisitem->name, WASABI_API_LNGSTRINGW( def_str_ids[ j ] ) ) ) + { + lstrcpyn( charNameLoc, def_names[ j ], ARRAYSIZE( charNameLoc ) ); + break; + } + } + + g_config->WriteString( qn, ( charNameLoc[ 0 ] ? charNameLoc : AutoChar( thisitem->name, CP_UTF8 ) ) ); + g_config->WriteString( qv, AutoChar( thisitem->query, CP_UTF8 ) ); + g_config->WriteInt( qm, thisitem->mode ); + g_config->WriteString( qmet, thisitem->metafn ); + g_config->WriteInt( qbmp, max( thisitem->imgIndex, -1 ) ); + } + + --i; + if ( i < nb ) + { + for ( int k = i + 1; k <= nb; k++ ) + { + wsprintfW( qm, L"query%i_mode", k ); + + int mode = g_config->ReadInt( qm, -1 ); + if ( mode == 32 ) + i++; + else + { + wsprintfA( qn, "query%i_name", k ); + wsprintfA( qv, "query%i_val", k ); + wsprintfW( qm, L"query%i_mode", k ); + wsprintfW( qmet, L"query%i_meta", k ); + wsprintfW( qbmp, L"query%i_image", k ); + + g_config->WriteString( qn, NULL ); + g_config->WriteString( qv, NULL ); + g_config->WriteString( qm, NULL ); + g_config->WriteString( qmet, NULL ); + g_config->WriteString( qbmp, NULL ); + } + } + } + + g_config->WriteInt( L"query_num", i ); +} + +HTREEITEM g_treedrag_lastSel; + +HWND onTreeViewSelectChange(HWND hwnd) +{ + if ( !g_table ) + openDb(); + + bgQuery_Stop(); + + int par = mediaLibrary.GetSelectedTreeItem(); + + // defaults + m_query_mode = par; + m_query = L""; + + m_query_metafile = L""; + m_query_mode = 0; + + if (par == m_query_tree) // set up default media view + { + m_query_metafile = L"default.vmd"; + } + else + { + QueryList::iterator iter; + iter = m_query_list.find(par); + if (iter != m_query_list.end()) + { + m_query = iter->second->query; + m_query_mode = iter->second->mode; + m_query_metafile = iter->second->metafn; + } + else + { + m_query_metafile = L"default.vmd"; + } + } + + return updateCurrentView(hwnd); +} + +void add_pledit_to_library() +{ + SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_WRITEPLAYLIST); + wchar_t *m3udir = (wchar_t *) SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GETM3UDIRECTORYW); + wchar_t filename[MAX_PATH] = {0}; + PathCombineW(filename, m3udir, L"winamp.m3u8"); + + PLCallBackW plCB; + if (AGAVE_API_PLAYLISTMANAGER && PLAYLISTMANAGER_SUCCESS != AGAVE_API_PLAYLISTMANAGER->Load(filename, &plCB)) + { + mediaLibrary.AddToMediaLibrary(filename); + } +} + +void add_to_library(HWND wndparent) +{ + ScanFolderBrowser browser; + browser.SetBckScanChecked(g_config->ReadInt(L"addinbg", 0)); + + if (browser.Browse(wndparent)) + { + wchar_t path[MAX_PATH] = {0}; + g_config->WriteInt(L"addinbg", browser.GetBckScanChecked()); + SHGetPathFromIDListW(browser.GetPIDL(), path); + int guess = -1, meta = -1, rec = 1; + autoscan_add_directory(path, &guess, &meta, &rec, 0); + + if (guess == -1) + guess = g_config->ReadInt(L"guessmode", 0); + + if (meta == -1) + meta = g_config->ReadInt(L"usemetadata", 1); + + if (g_config->ReadInt(L"addinbg", 0)) + { + Scan_ScanFolderBackground(path, guess, meta, rec); // add our dir to scan :) + } + else + { + Scan_ScanFolder(wndparent, path, guess, meta, rec); + + int par = mediaLibrary.GetSelectedTreeItem(); + mediaLibrary.SelectTreeItem(par - 1); + mediaLibrary.SelectTreeItem(par); + + if (IsWindow(m_curview_hwnd)) + SendMessage(m_curview_hwnd, WM_APP + 1, 0, 0); //update current view + } + } +} + +void nukeLibrary(HWND hwndDlg) +{ + wchar_t titleStr[32] = {0}; + if (MessageBoxW(hwndDlg, WASABI_API_LNGSTRINGW(IDS_REMOVE_ALL_ITEMS_IN_LIBRARY), + WASABI_API_LNGSTRINGW_BUF(IDS_CONFIRMATION,titleStr,32), + MB_YESNO | MB_ICONQUESTION) == IDYES) + { + wchar_t *last_query = NULL; + EnterCriticalSection(&g_db_cs); + if (m_media_scanner) + { + const wchar_t *lq = NDE_Scanner_GetLastQuery(m_media_scanner); + if (lq) last_query = _wcsdup(lq); + NDE_Table_DestroyScanner(g_table, m_media_scanner); + } + LeaveCriticalSection(&g_db_cs); + bgQuery_Stop(); + Scan_Cancel(); + + int count = 0; + wchar_t **filenames = 0; + nde_scanner_t clearedScanner = NDE_Table_CreateScanner(g_table); + if (clearedScanner) + { + filenames = new wchar_t * [(count = NDE_Scanner_GetRecordsCount(clearedScanner))]; + int i = 0; + for (NDE_Scanner_First(clearedScanner); !NDE_Scanner_EOF(clearedScanner); NDE_Scanner_Next(clearedScanner)) + { + nde_field_t fileName = NDE_Scanner_GetFieldByID(clearedScanner, MAINTABLE_ID_FILENAME); + if (fileName) + { + filenames[i] = NDE_StringField_GetString(fileName); + ndestring_retain(filenames[i]); + i++; + } + } + } + NDE_Table_DestroyScanner(g_table, clearedScanner); + + closeDb(); + + wchar_t tmp[MAX_PATH] = {0}; + StringCchPrintfW(tmp, MAX_PATH, L"%s\\main.dat", g_tableDir); + DeleteFileW(tmp); + StringCchPrintfW(tmp, MAX_PATH, L"%s\\main.idx", g_tableDir); + DeleteFileW(tmp); + + openDb(); + EnterCriticalSection(&g_db_cs); + if (m_media_scanner) + { + m_media_scanner = NDE_Table_CreateScanner(g_table); + if (last_query != NULL) + { + NDE_Scanner_Query(m_media_scanner, last_query); + free(last_query); + } + } + LeaveCriticalSection(&g_db_cs); + DumpArtCache(); + if (IsWindow(m_curview_hwnd)) + SendMessage(m_curview_hwnd, WM_APP + 1, 0, 0); //update current view + + // Wasabi event callback when the media library is cleared + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_CLEARED, (size_t)filenames, count); + if (filenames) delete[] filenames; + + // trigger a refresh of the current view + PostMessage(plugin.hwndLibraryParent, WM_USER + 30, 0, 0); + } +} + +extern int main_sendto_mode; + +extern HMENU main_sendto_hmenu; + + +wchar_t *itemrecordWTagFunc(wchar_t *tag, void * p) //return 0 if not found +{ + // TODO we can put more tags in here + itemRecordW *t = (itemRecordW *)p; + //bool copy=false; + wchar_t buf[128] = {0}; + wchar_t *value = NULL; + + if ( !_wcsicmp( tag, DB_FIELDNAME_artist ) ) + value = t->artist; + else if ( !_wcsicmp( tag, DB_FIELDNAME_album ) ) + value = t->album; + else if ( !_wcsicmp( tag, DB_FIELDNAME_filename ) ) + value = t->filename; + else if ( !_wcsicmp( tag, DB_FIELDNAME_title ) ) + value = t->title; + else if ( !_wcsicmp( tag, DB_FIELDNAME_year ) ) + { + if ( t->year > 0 ) + { + wsprintfW( buf, L"%04d", t->year ); + value = buf; + } + } + else if ( !_wcsicmp( tag, DB_FIELDNAME_genre ) ) + value = t->genre; + else if ( !_wcsicmp( tag, DB_FIELDNAME_comment ) ) + value = t->comment; + else if ( !_wcsicmp( tag, DB_FIELDNAME_tracknumber ) || !_wcsicmp( tag, DB_FIELDNAME_track ) ) + { + if ( t->track > 0 ) + { + if ( t->tracks > 0 ) + wsprintfW( buf, L"%02d/%02d", t->track, t->tracks ); + else + wsprintfW( buf, L"%02d", t->track ); + value = buf; + } + } + else if ( !_wcsicmp( tag, DB_FIELDNAME_disc ) ) + { + if ( t->disc > 0 ) + { + if ( t->discs > 0 ) + wsprintfW( buf, L"%d/%d", t->disc, t->discs ); + else + wsprintfW( buf, L"%d", t->disc ); + + value = buf; + } + } + else if ( !_wcsicmp( tag, DB_FIELDNAME_rating ) ) + { + if ( t->rating > 0 ) + { + wsprintfW( buf, L"%d", t->rating ); + value = buf; + } + } + else if ( !_wcsicmp( tag, DB_FIELDNAME_playcount ) ) + { + if ( t->playcount > 0 ) + { + wsprintfW( buf, L"%d", t->playcount ); + value = buf; + } + } + else if ( !_wcsicmp( tag, DB_FIELDNAME_bitrate ) ) + { + if ( t->bitrate > 0 ) + { + wsprintfW( buf, L"%d", t->bitrate ); + value = buf; + } + } + else if ( !_wcsicmp( tag, DB_FIELDNAME_bpm ) ) + { + if ( t->bpm > 0 ) + { + wsprintfW( buf, L"%d", t->bpm ); + value = buf; + } + } + else if ( !_wcsicmp( tag, DB_FIELDNAME_albumartist ) ) + value = t->albumartist; + else if ( !_wcsicmp( tag, DB_FIELDNAME_publisher ) ) + value = t->publisher; + else if ( !_wcsicmp( tag, DB_FIELDNAME_composer ) ) + value = t->composer; + else if ( !_wcsicmp( tag, DB_FIELDNAME_replaygain_album_gain ) ) + value = t->replaygain_album_gain; + else if ( !_wcsicmp( tag, DB_FIELDNAME_replaygain_track_gain ) ) + value = t->replaygain_track_gain; + else if ( !_wcsicmp( tag, DB_FIELDNAME_GracenoteFileID ) ) + value = getRecordExtendedItem_fast( t, extended_fields.GracenoteFileID ); + else if ( !_wcsicmp( tag, DB_FIELDNAME_GracenoteExtData ) ) + value = getRecordExtendedItem_fast( t, extended_fields.GracenoteExtData ); + else + return 0; + + if (!value) + return reinterpret_cast<wchar_t *>(-1); + else + { + if (/*copy || */value == buf) + return ndestring_wcsdup(value); + else + { + ndestring_retain(value); + return value; + } + } +} + +static bool TagNameToFieldID(const wchar_t *tag, int *id) +{ + if ( !_wcsicmp( tag, DB_FIELDNAME_artist ) ) + *id = MAINTABLE_ID_ARTIST; + else if ( !_wcsicmp( tag, DB_FIELDNAME_album ) ) + *id = MAINTABLE_ID_ALBUM; + else if ( !_wcsicmp( tag, DB_FIELDNAME_filename ) ) + *id = MAINTABLE_ID_FILENAME; + else if ( !_wcsicmp( tag, DB_FIELDNAME_title ) ) + *id = MAINTABLE_ID_TITLE; + else if ( !_wcsicmp( tag, DB_FIELDNAME_year ) ) + *id = MAINTABLE_ID_YEAR; + else if ( !_wcsicmp( tag, DB_FIELDNAME_genre ) ) + *id = MAINTABLE_ID_GENRE; + else if ( !_wcsicmp( tag, DB_FIELDNAME_comment ) ) + *id = MAINTABLE_ID_COMMENT; + else if ( !_wcsicmp( tag, DB_FIELDNAME_tracknumber ) || !_wcsicmp( tag, DB_FIELDNAME_track ) ) + *id = MAINTABLE_ID_TRACKNB; + else if ( !_wcsicmp( tag, DB_FIELDNAME_rating ) ) + *id = MAINTABLE_ID_RATING; + else if ( !_wcsicmp( tag, DB_FIELDNAME_playcount ) ) + *id = MAINTABLE_ID_PLAYCOUNT; + else if ( !_wcsicmp( tag, DB_FIELDNAME_bitrate ) ) + *id = MAINTABLE_ID_BITRATE; + else if ( !_wcsicmp( tag, DB_FIELDNAME_disc ) ) + *id = MAINTABLE_ID_DISC; + else if ( !_wcsicmp( tag, DB_FIELDNAME_bpm ) ) + *id = MAINTABLE_ID_BPM; + else if ( !_wcsicmp( tag, DB_FIELDNAME_albumartist ) ) + *id = MAINTABLE_ID_ALBUMARTIST; + else if ( !_wcsicmp( tag, DB_FIELDNAME_publisher ) ) + *id = MAINTABLE_ID_PUBLISHER; + else if ( !_wcsicmp( tag, DB_FIELDNAME_composer ) ) + *id = MAINTABLE_ID_COMPOSER; + else if ( !_wcsicmp( tag, DB_FIELDNAME_replaygain_album_gain ) ) + *id = MAINTABLE_ID_ALBUMGAIN; + else if ( !_wcsicmp( tag, DB_FIELDNAME_replaygain_track_gain ) ) + *id = MAINTABLE_ID_TRACKGAIN; + else if ( !_wcsicmp( tag, DB_FIELDNAME_GracenoteFileID ) ) + *id = MAINTABLE_ID_GRACENOTEFILEID; + else if ( !_wcsicmp( tag, DB_FIELDNAME_GracenoteExtData ) ) + *id = MAINTABLE_ID_GRACENOTEEXTDATA; + //else if (!_wcsicmp(tag, DB_FIELDNAME_lossless)) *id = MAINTABLE_ID_LOSSLESS; + else + return false; + + return true; +} + +wchar_t *fieldTagFunc(wchar_t * tag, void * p) //return 0 if not found +{ + nde_scanner_t s = (nde_scanner_t)p; + int id = -1; + + if (!TagNameToFieldID(tag, &id)) + return 0; + + if (id >= 0) + { + nde_field_t f = NDE_Scanner_GetFieldByID(s, id); + if (f) + switch (id) + { + case MAINTABLE_ID_YEAR: + { + wchar_t buf[32] = {0}; + int l = NDE_IntegerField_GetValue(f); + if (l < 0) return reinterpret_cast<wchar_t *>(-1); + wsprintfW(buf, L"%04d", l); + return ndestring_wcsdup(buf); + } + case MAINTABLE_ID_TRACKNB: + { + wchar_t buf[32] = {0}; + int l = NDE_IntegerField_GetValue(f); + if (l < 0) return reinterpret_cast<wchar_t *>(-1); + int tracks = db_getFieldInt(s, MAINTABLE_ID_TRACKS, -1); + if (tracks > 0) + wsprintfW(buf, L"%02d/%02d", l, tracks); + else + wsprintfW(buf, L"%02d", l); + return ndestring_wcsdup(buf); + } + case MAINTABLE_ID_DISC: + { + wchar_t buf[32] = {0}; + int l = NDE_IntegerField_GetValue(f); + if (l < 0) return reinterpret_cast<wchar_t *>(-1); + int discs = db_getFieldInt(s, MAINTABLE_ID_DISCS, -1); + if (discs > 0) + wsprintfW(buf, L"%d/%d", l, discs); + else + wsprintfW(buf, L"%d", l); + + return ndestring_wcsdup(buf); + } + case MAINTABLE_ID_PLAYCOUNT: + asked_for_playcount = 1; + // fall through :) + case MAINTABLE_ID_BPM: + case MAINTABLE_ID_RATING: + case MAINTABLE_ID_BITRATE: + { + wchar_t buf[32] = {0}; + int l = NDE_IntegerField_GetValue(f); + if (l < 0) + return reinterpret_cast<wchar_t *>(-1); + + wsprintfW(buf, L"%d", l); + return ndestring_wcsdup(buf); + } + default: + { + wchar_t *p = NDE_StringField_GetString(f); + if (!p || !*p) + return reinterpret_cast<wchar_t *>(-1);; + + ndestring_retain(p); + return p; + } + } + + } + return 0; +} + +void ndeTagFuncFree(wchar_t * tag, void * p) +{ + ndestring_release(tag); +} + +void RetypeFilename(nde_table_t table); +void RefreshFileSizeAndDateAddedTable(nde_table_t table); +void ReindexTable(nde_table_t table); + +static void CreateFields( nde_table_t table ) +{ + // create defaults + NDE_Table_NewColumnW( table, MAINTABLE_ID_FILENAME, DB_FIELDNAME_filename, FIELD_FILENAME ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_TITLE, DB_FIELDNAME_title, FIELD_STRING ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_ARTIST, DB_FIELDNAME_artist, FIELD_STRING ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_ALBUM, DB_FIELDNAME_album, FIELD_STRING ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_YEAR, DB_FIELDNAME_year, FIELD_INTEGER ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_GENRE, DB_FIELDNAME_genre, FIELD_STRING ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_COMMENT, DB_FIELDNAME_comment, FIELD_STRING ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_TRACKNB, DB_FIELDNAME_trackno, FIELD_INTEGER ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_LENGTH, DB_FIELDNAME_length, FIELD_LENGTH ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_TYPE, DB_FIELDNAME_type, FIELD_INTEGER ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_LASTUPDTIME, DB_FIELDNAME_lastupd, FIELD_DATETIME ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_LASTPLAY, DB_FIELDNAME_lastplay, FIELD_DATETIME ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_RATING, DB_FIELDNAME_rating, FIELD_INTEGER ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_GRACENOTE_ID, DB_FIELDNAME_tuid2, FIELD_STRING ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_PLAYCOUNT, DB_FIELDNAME_playcount, FIELD_INTEGER ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_FILETIME, DB_FIELDNAME_filetime, FIELD_DATETIME ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_FILESIZE, DB_FIELDNAME_filesize, FIELD_INT64 ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_BITRATE, DB_FIELDNAME_bitrate, FIELD_INTEGER ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_DISC, DB_FIELDNAME_disc, FIELD_INTEGER ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_ALBUMARTIST, DB_FIELDNAME_albumartist, FIELD_STRING ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_ALBUMGAIN, DB_FIELDNAME_replaygain_album_gain, FIELD_STRING ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_TRACKGAIN, DB_FIELDNAME_replaygain_track_gain, FIELD_STRING ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_PUBLISHER, DB_FIELDNAME_publisher, FIELD_STRING ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_COMPOSER, DB_FIELDNAME_composer, FIELD_STRING ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_BPM, DB_FIELDNAME_bpm, FIELD_INTEGER ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_DISCS, DB_FIELDNAME_discs, FIELD_INTEGER ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_TRACKS, DB_FIELDNAME_tracks, FIELD_INTEGER ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_ISPODCAST, DB_FIELDNAME_ispodcast, FIELD_INTEGER ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_PODCASTCHANNEL, DB_FIELDNAME_podcastchannel, FIELD_STRING ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_PODCASTPUBDATE, DB_FIELDNAME_podcastpubdate, FIELD_DATETIME ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_GRACENOTEFILEID, DB_FIELDNAME_GracenoteFileID, FIELD_STRING ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_GRACENOTEEXTDATA, DB_FIELDNAME_GracenoteExtData, FIELD_STRING ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_LOSSLESS, DB_FIELDNAME_lossless, FIELD_INTEGER ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_CATEGORY, DB_FIELDNAME_category, FIELD_STRING ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_CODEC, DB_FIELDNAME_codec, FIELD_STRING ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_DIRECTOR, DB_FIELDNAME_director, FIELD_STRING ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_PRODUCER, DB_FIELDNAME_producer, FIELD_STRING ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_WIDTH, DB_FIELDNAME_width, FIELD_INTEGER ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_HEIGHT, DB_FIELDNAME_height, FIELD_INTEGER ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_MIMETYPE, DB_FIELDNAME_mimetype, FIELD_STRING ); + NDE_Table_NewColumnW( table, MAINTABLE_ID_DATEADDED, DB_FIELDNAME_dateadded, FIELD_DATETIME ); + + NDE_Table_PostColumns(table); + NDE_Table_AddIndexByIDW(table, MAINTABLE_ID_FILENAME, DB_FIELDNAME_filename ); +} + +int openDb() +{ + // TODO: fix!! this is a Double-Checked Lock Pattern and can have strange results + // in weird conditions because g_table is assigned before fully initialized + if ( g_table ) + return 0; + + EnterCriticalSection(&g_db_cs); + + // benski> i know this looks redundant, but we might have sat and blocked at the above Critical Section for a while + if (g_table) + { + LeaveCriticalSection(&g_db_cs); + + return 0; + } + + if ( !g_db ) + { + __try + { + g_db = NDE_CreateDatabase( plugin.hDllInstance ); + } + __except ( EXCEPTION_EXECUTE_HANDLER ) + { + g_db = NULL; + LeaveCriticalSection( &g_db_cs ); + + return 0; + } + } + + const wchar_t *inidir = WASABI_API_APP->path_getUserSettingsPath(); + wchar_t tableName[MAX_PATH] = {0}, indexName[MAX_PATH] = {0}; + PathCombineW(indexName, inidir, L"Plugins\\ml"); + PathCombineW(tableName, indexName, L"main.dat"); + PathAppendW(indexName, L"main.idx"); + + g_table = NDE_Database_OpenTable(g_db, tableName, indexName, NDE_OPEN_ALWAYS, NDE_CACHE); + if (g_table) + { + ((Table *)g_table)->EnableRowCache(); // TODO: don't use c++ NDE API + CreateFields(g_table); + RetypeFilename(g_table); + + #define REINDEX_KEY L"reindex_561" + if ( !g_config->ReadInt( REINDEX_KEY, 0 ) ) // do we need to reindex? + ReindexTable( g_table ); + + g_config->WriteInt(REINDEX_KEY, 1); + + #undef REINDEX_KEY + #define REINDEX_KEY L"reindex_564" + if ( g_config->ReadInt( REINDEX_KEY, 0 ) != 2 ) // do we need to update the filesizes and date added? + RefreshFileSizeAndDateAddedTable( g_table ); + + g_config->WriteInt(REINDEX_KEY, 2); + + PostMessage(plugin.hwndWinampParent, WM_WA_IPC, NDE_Table_GetRecordsCount(g_table), IPC_STATS_LIBRARY_ITEMCNT); + } + + LeaveCriticalSection(&g_db_cs); + + return (g_table != 0); +} + +// TODO make sure we're only ever saving if there was an actual change!! +void closeDb() +{ + if ( g_db ) + { + __try + { + if ( g_table ) + { + if ( g_table_dirty ) + NDE_Table_Sync( g_table ); + + NDE_Database_CloseTable( g_db, g_table ); + } + + NDE_DestroyDatabase( g_db ); + } + __except ( EXCEPTION_EXECUTE_HANDLER ) + { + } + } + + g_db = NULL; + g_table = NULL; +} + +LPCWSTR WINAMP_INI = NULL; +WNDPROC ml_oldWndProc = NULL; +LARGE_INTEGER freq; + +int init() +{ + QueryPerformanceFrequency(&freq); + + g_table = NULL; + g_db = NULL; + g_bgscan_last_rescan = time( NULL ); + + LPCWSTR dir = (LPCWSTR )SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GETINIDIRECTORYW); + if ( (INT_PTR)( dir ) < 65536 ) + return 1; + + PathCombineW(g_path, dir, L"Plugins"); + CreateDirectoryW(g_path, NULL); + + WINAMP_INI = (LPCWSTR)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GETINIFILEW); + + wchar_t configName[MAX_PATH] = {0}; + PathCombineW(configName, g_path, L"gen_ml.ini"); + g_config = new C_Config(configName); + + g_bgrescan_int = g_config->ReadInt(L"bgrescan_int", g_bgrescan_int); + g_bgrescan_do = g_config->ReadInt(L"bgrescan_do", g_bgrescan_do); + g_bgrescan_force = g_config->ReadInt(L"bgrescan_startup", 0); // temporarily used + g_guessifany = g_config->ReadInt(L"guessifany", g_guessifany); + g_viewnotplay = g_config->ReadInt(L"viewnotplay", g_viewnotplay); + + // this allows an override of the delay from making a change in the search box + // in the views to when the search will be run - sometimes needs tweaking for + // either older machines or some of the less powerful 'portable' type machines + g_querydelay = g_config->ReadInt(L"querydelay", g_querydelay); + if ( g_querydelay < 1 || g_querydelay > 5000 ) + g_querydelay = 250; + + PathCombineW(g_tableDir, g_path, L"ml"); + PathCombineW(g_viewsDir, g_tableDir, L"views"); + + if (!g_config->ReadInt(L"artdbmig", 0)) + { + MigrateArtCache(); + g_config->WriteInt(L"artdbmig", 1); + } + + wa_oldWndProc = (WNDPROC) SetWindowLongPtrW(plugin.hwndWinampParent, GWLP_WNDPROC, (LONG_PTR)wa_newWndProc); + + if ( g_bgrescan_force || g_config->ReadInt( L"dbloadatstart", 1 ) ) + openDb(); + + HMENU wa_plcontext_menu = GetSubMenu((HMENU)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)-1, IPC_GET_HMENU), 2); + if ( wa_plcontext_menu ) + wa_playlists_cmdmenu = GetSubMenu( wa_plcontext_menu, 4 ); + + wa_play_menu = GetSubMenu((HMENU)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)0, IPC_GET_HMENU), 2); + + // lets extend menu that called on button press + IPC_GET_ML_HMENU = (int)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&"LibraryGetHmenu", IPC_REGISTER_WINAMP_IPCMESSAGE); + g_context_menus = WASABI_API_LOADMENU(IDR_CONTEXTMENUS); + g_context_menus2 = WASABI_API_LOADMENU(IDR_CONTEXTMENUS); + + HMENU rate_hmenu = GetSubMenu(GetSubMenu(g_context_menus,1),4); + ConvertRatingMenuStar(rate_hmenu, ID_RATE_5); + ConvertRatingMenuStar(rate_hmenu, ID_RATE_4); + ConvertRatingMenuStar(rate_hmenu, ID_RATE_3); + ConvertRatingMenuStar(rate_hmenu, ID_RATE_2); + ConvertRatingMenuStar(rate_hmenu, ID_RATE_1); + + HMENU context_menu = (HMENU) SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GET_ML_HMENU); + + if (context_menu) + { + HMENU btnMenu = GetSubMenu(context_menu, 0); + if (btnMenu) + { + MENUITEMINFOW mii = {sizeof(MENUITEMINFOW)}; + + mii.fMask = MIIM_FTYPE; + mii.fType = MFT_SEPARATOR; + mii.fState = MFS_ENABLED; + InsertMenuItemW(btnMenu, 0, TRUE, &mii); + + mii.fMask = MIIM_TYPE | MIIM_ID; + mii.fType = MFT_STRING; + + mii.dwTypeData = WASABI_API_LNGSTRINGW(IDS_NEW_SMART_VIEW); + mii.cch = (unsigned int) wcslen(mii.dwTypeData); + mii.wID = IDM_DOSHITMENU_ADDNEWVIEW; + InsertMenuItemW(btnMenu, 1, TRUE, &mii); + + mii.dwTypeData = WASABI_API_LNGSTRINGW(IDS_RESCAN_WATCH_FOLDERS); + mii.cch = (unsigned int) wcslen(mii.dwTypeData); + mii.wID = IDM_RESCANFOLDERSNOW; + InsertMenuItemW(btnMenu, 0, TRUE, &mii); + + mii.dwTypeData = WASABI_API_LNGSTRINGW(IDS_ADD_PLEDIT_TO_LOCAL_MEDIA); + mii.cch = (unsigned int) wcslen(mii.dwTypeData); + mii.wID = IDM_ADD_PLEDIT; + InsertMenuItemW(btnMenu, 0, TRUE, &mii); + + mii.dwTypeData = WASABI_API_LNGSTRINGW(IDS_ADD_MEDIA_TO_LIBRARY); + mii.cch = (unsigned int) wcslen(mii.dwTypeData); + mii.wID = IDM_ADD_DIRS; + InsertMenuItemW(btnMenu, 0, TRUE, &mii); + + mii.dwTypeData = WASABI_API_LNGSTRINGW(IDS_REMOVE_MISSING_FILES_FROM_ML); + mii.cch = (unsigned int) wcslen(mii.dwTypeData); + mii.wID = IDM_REMOVE_UNUSED_FILES; + InsertMenuItemW(btnMenu, 0, TRUE, &mii); + } + } + + IPC_GET_CLOUD_HINST = (INT)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&"WinampCloud", IPC_REGISTER_WINAMP_IPCMESSAGE); + IPC_GET_CLOUD_ACTIVE = (INT)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&"WinampCloudActive", IPC_REGISTER_WINAMP_IPCMESSAGE); + + ml_oldWndProc = (WNDPROC) SetWindowLongPtrW(plugin.hwndLibraryParent, GWLP_WNDPROC, (LONG_PTR)ml_newWndProc); + + HookPlaylistEditor(); + hDragNDropCursor = LoadCursor(GetModuleHandle(L"gen_ml.dll"), MAKEINTRESOURCE(ML_IDC_DRAGDROP)); + + // rescan timer + SetTimer( plugin.hwndLibraryParent, 200, 1000, NULL ); + + return 0; +} + +int OnLocalMediaItemClick( int action, int item, HWND parent ) +{ + switch ( action ) + { + case ML_ACTION_ENTER: + case ML_ACTION_DBLCLICK: + { + queryItem *qitem = m_query_list[ item ]; + if ( qitem != NULL ) + { + wchar_t configDir[ MAX_PATH ] = { 0 }; + PathCombineW( configDir, g_viewsDir, qitem->metafn ); + C_Config viewconf( configDir ); + main_playQuery( &viewconf, qitem->query, ( ( !!( GetAsyncKeyState( VK_SHIFT ) & 0x8000 ) ) ^ ( !!g_config->ReadInt( L"enqueuedef", 0 ) ) ) ); + } + } + return 1; + } + return 0; +} + +int OnLocalMediaClick(int action, HWND parent) +{ + switch (action) + { + case ML_ACTION_ENTER: + case ML_ACTION_DBLCLICK: + return 1; + } + return 0; +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/ml_local.h b/Src/Plugins/Library/ml_local/ml_local.h new file mode 100644 index 00000000..b607607c --- /dev/null +++ b/Src/Plugins/Library/ml_local/ml_local.h @@ -0,0 +1,403 @@ +#ifndef ML_LOCAL_HEADER +#define ML_LOCAL_HEADER + +#include <windows.h> +#include <commctrl.h> + +#include <iostream> // for std::wstring + +#include "..\..\General\gen_ml/gaystring.h" +#include "..\..\General\gen_ml/config.h" + +#include <map> +#include "../nde/nde_c.h" +#include <vector> + +struct ExtendedFields +{ + const wchar_t *ispodcast; + const wchar_t *podcastchannel; + const wchar_t *podcastpubdate; + const wchar_t *GracenoteFileID; + const wchar_t *GracenoteExtData; + const wchar_t *lossless; + const wchar_t *codec; + const wchar_t *director; + const wchar_t *producer; + const wchar_t *width; + const wchar_t *height; + const wchar_t *mimetype; + const wchar_t *realsize; + const wchar_t *dateadded; + const wchar_t *cloud; +}; +extern const ExtendedFields extended_fields; + +extern const int NUM_EXTRA_COLSW; +extern const unsigned char extra_idsW[]; // defined in view_media.cpp +extern const wchar_t *extra_strsW[]; + +extern HCURSOR hDragNDropCursor; +wchar_t *getRecordExtendedItem_fast(const itemRecordW *item, const wchar_t *name); +void setRecordExtendedItem_fast(itemRecordW *item, const wchar_t *name, const wchar_t *value); + +int OnLocalMediaItemClick(int action, int item, HWND parent); +int OnLocalMediaClick(int action, HWND parent); +BOOL IPC_HookExtInfo(INT_PTR param); +BOOL IPC_HookExtInfoW(INT_PTR param); +BOOL IPC_HookTitleInfo(INT_PTR param); + +#include "../winamp/wa_ipc.h" + + +#define INT_ENTRY_MAX_NUM 20 +#define INT_ENTRY_MAX_PATHSIZE 512 +#define INT_ENTRY_MAX_TEXTSIZE 128 + +#define TREE_IMAGE_LOCAL_AUDIO 101 +#define TREE_IMAGE_LOCAL_VIDEO 102 +#define TREE_IMAGE_LOCAL_MOSTPLAYED 103 +#define TREE_IMAGE_LOCAL_RECENTLYADDED 104 +#define TREE_IMAGE_LOCAL_RECENTLYPLAYED 105 +#define TREE_IMAGE_LOCAL_NEVERPLAYED 106 +#define TREE_IMAGE_LOCAL_TOPRATED 107 +#define TREE_IMAGE_LOCAL_PODCASTS 108 +#define TREE_IMAGE_LOCAL_RECENTLYMODIFIED 109 + + +#define MAINTABLE_ID_FILENAME 0 +#define MAINTABLE_ID_TITLE 1 +#define MAINTABLE_ID_ARTIST 2 +#define MAINTABLE_ID_ALBUM 3 +#define MAINTABLE_ID_YEAR 4 +#define MAINTABLE_ID_GENRE 5 +#define MAINTABLE_ID_COMMENT 6 +#define MAINTABLE_ID_TRACKNB 7 +#define MAINTABLE_ID_LENGTH 8 // in seconds +#define MAINTABLE_ID_TYPE 9 // 0=audio, 1=video +#define MAINTABLE_ID_LASTUPDTIME 10 // last time (seconds since 1970) of db update of this item +#define MAINTABLE_ID_LASTPLAY 11 // last time (seconds since 1970) of last play +#define MAINTABLE_ID_RATING 12 +#define MAINTABLE_ID_GRACENOTE_ID 14 // OLD Gracenote ID's. Don't use this anymore!!! +#define MAINTABLE_ID_PLAYCOUNT 15 // play count +#define MAINTABLE_ID_FILETIME 16 // file time +#define MAINTABLE_ID_FILESIZE 17 // file size, bytes (was kilobytes until 5.7) +#define MAINTABLE_ID_BITRATE 18 // file bitratea, kbps +#define MAINTABLE_ID_DISC 19 // disc # +#define MAINTABLE_ID_ALBUMARTIST 20 // album artist +#define MAINTABLE_ID_ALBUMGAIN 21 // album gain (replaygain) +#define MAINTABLE_ID_TRACKGAIN 22 // track gain (replaygain) +#define MAINTABLE_ID_PUBLISHER 23 // publisher (record label) +#define MAINTABLE_ID_COMPOSER 24 // composer +#define MAINTABLE_ID_BPM 25 // beats per minute (tempo) +#define MAINTABLE_ID_DISCS 26 // number of discs total +#define MAINTABLE_ID_TRACKS 27 // number of tracks total +#define MAINTABLE_ID_ISPODCAST 28 +#define MAINTABLE_ID_PODCASTCHANNEL 29 +#define MAINTABLE_ID_PODCASTPUBDATE 30 +#define MAINTABLE_ID_GRACENOTEFILEID 31 +#define MAINTABLE_ID_GRACENOTEEXTDATA 32 +#define MAINTABLE_ID_LOSSLESS 33 +#define MAINTABLE_ID_CATEGORY 34 +#define MAINTABLE_ID_CODEC 35 +#define MAINTABLE_ID_DIRECTOR 36 +#define MAINTABLE_ID_PRODUCER 37 +#define MAINTABLE_ID_WIDTH 38 +#define MAINTABLE_ID_HEIGHT 39 +#define MAINTABLE_ID_MIMETYPE 40 +#define MAINTABLE_ID_DATEADDED 41 // time file was added to the db + +// menu command id +#define IDM_DOSHITMENU_ADDNEWVIEW 40030 +#define IDM_RESCANFOLDERSNOW 4066 +#define IDM_ADD_DIRS 4067 +#define IDM_REMOVE_UNUSED_FILES 4068 +#define IDM_ADD_PLEDIT 4069 + + + +static const std::wstring _DB_FIELDNAME_tracknumber = L"tracknumber"; static const wchar_t *DB_FIELDNAME_tracknumber = _DB_FIELDNAME_tracknumber.c_str(); +static const std::wstring _DB_FIELDNAME_track = L"track"; static const wchar_t *DB_FIELDNAME_track = _DB_FIELDNAME_track.c_str(); + +static const std::wstring _DB_FIELDNAME_filename = L"filename"; static const wchar_t *DB_FIELDNAME_filename = _DB_FIELDNAME_filename.c_str(); +static const std::wstring _DB_FIELDNAME_title = L"title"; static const wchar_t *DB_FIELDNAME_title = _DB_FIELDNAME_title.c_str(); +static const std::wstring _DB_FIELDNAME_artist = L"artist"; static const wchar_t *DB_FIELDNAME_artist = _DB_FIELDNAME_artist.c_str(); +static const std::wstring _DB_FIELDNAME_album = L"album"; static const wchar_t *DB_FIELDNAME_album = _DB_FIELDNAME_album.c_str(); +static const std::wstring _DB_FIELDNAME_year = L"year"; static const wchar_t *DB_FIELDNAME_year = _DB_FIELDNAME_year.c_str(); +static const std::wstring _DB_FIELDNAME_genre = L"genre"; static const wchar_t *DB_FIELDNAME_genre = _DB_FIELDNAME_genre.c_str(); +static const std::wstring _DB_FIELDNAME_comment = L"comment"; static const wchar_t *DB_FIELDNAME_comment = _DB_FIELDNAME_comment.c_str(); +static const std::wstring _DB_FIELDNAME_trackno = L"trackno"; static const wchar_t *DB_FIELDNAME_trackno = _DB_FIELDNAME_trackno.c_str(); +static const std::wstring _DB_FIELDNAME_length = L"length"; static const wchar_t *DB_FIELDNAME_length = _DB_FIELDNAME_length.c_str(); +static const std::wstring _DB_FIELDNAME_type = L"type"; static const wchar_t *DB_FIELDNAME_type = _DB_FIELDNAME_type.c_str(); +static const std::wstring _DB_FIELDNAME_lastupd = L"lastupd"; static const wchar_t *DB_FIELDNAME_lastupd = _DB_FIELDNAME_lastupd.c_str(); +static const std::wstring _DB_FIELDNAME_lastplay = L"lastplay"; static const wchar_t *DB_FIELDNAME_lastplay = _DB_FIELDNAME_lastplay.c_str(); +static const std::wstring _DB_FIELDNAME_rating = L"rating"; static const wchar_t *DB_FIELDNAME_rating = _DB_FIELDNAME_rating.c_str(); +static const std::wstring _DB_FIELDNAME_tuid2 = L"tuid2"; static const wchar_t *DB_FIELDNAME_tuid2 = _DB_FIELDNAME_tuid2.c_str(); +static const std::wstring _DB_FIELDNAME_playcount = L"playcount"; static const wchar_t *DB_FIELDNAME_playcount = _DB_FIELDNAME_playcount.c_str(); +static const std::wstring _DB_FIELDNAME_filetime = L"filetime"; static const wchar_t *DB_FIELDNAME_filetime = _DB_FIELDNAME_filetime.c_str(); +static const std::wstring _DB_FIELDNAME_filesize = L"filesize"; static const wchar_t *DB_FIELDNAME_filesize = _DB_FIELDNAME_filesize.c_str(); +static const std::wstring _DB_FIELDNAME_bitrate = L"bitrate"; static const wchar_t *DB_FIELDNAME_bitrate = _DB_FIELDNAME_bitrate.c_str(); +static const std::wstring _DB_FIELDNAME_disc = L"disc"; static const wchar_t *DB_FIELDNAME_disc = _DB_FIELDNAME_disc.c_str(); +static const std::wstring _DB_FIELDNAME_albumartist = L"albumartist"; static const wchar_t *DB_FIELDNAME_albumartist = _DB_FIELDNAME_albumartist.c_str(); +static const std::wstring _DB_FIELDNAME_replaygain_album_gain = L"replaygain_album_gain"; static const wchar_t *DB_FIELDNAME_replaygain_album_gain = _DB_FIELDNAME_replaygain_album_gain.c_str(); +static const std::wstring _DB_FIELDNAME_replaygain_track_gain = L"replaygain_track_gain"; static const wchar_t *DB_FIELDNAME_replaygain_track_gain = _DB_FIELDNAME_replaygain_track_gain.c_str(); +static const std::wstring _DB_FIELDNAME_publisher = L"publisher"; static const wchar_t *DB_FIELDNAME_publisher = _DB_FIELDNAME_publisher.c_str(); +static const std::wstring _DB_FIELDNAME_composer = L"composer"; static const wchar_t *DB_FIELDNAME_composer = _DB_FIELDNAME_composer.c_str(); +static const std::wstring _DB_FIELDNAME_bpm = L"bpm"; static const wchar_t *DB_FIELDNAME_bpm = _DB_FIELDNAME_bpm.c_str(); +static const std::wstring _DB_FIELDNAME_discs = L"discs"; static const wchar_t *DB_FIELDNAME_discs = _DB_FIELDNAME_discs.c_str(); +static const std::wstring _DB_FIELDNAME_tracks = L"tracks"; static const wchar_t *DB_FIELDNAME_tracks = _DB_FIELDNAME_tracks.c_str(); +static const std::wstring _DB_FIELDNAME_ispodcast = L"ispodcast"; static const wchar_t *DB_FIELDNAME_ispodcast = _DB_FIELDNAME_ispodcast.c_str(); +static const std::wstring _DB_FIELDNAME_podcastchannel = L"podcastchannel"; static const wchar_t *DB_FIELDNAME_podcastchannel = _DB_FIELDNAME_podcastchannel.c_str(); +static const std::wstring _DB_FIELDNAME_podcastpubdate = L"podcastpubdate"; static const wchar_t *DB_FIELDNAME_podcastpubdate = _DB_FIELDNAME_podcastpubdate.c_str(); +static const std::wstring _DB_FIELDNAME_GracenoteFileID = L"GracenoteFileID"; static const wchar_t *DB_FIELDNAME_GracenoteFileID = _DB_FIELDNAME_GracenoteFileID.c_str(); +static const std::wstring _DB_FIELDNAME_GracenoteExtData = L"GracenoteExtData"; static const wchar_t *DB_FIELDNAME_GracenoteExtData = _DB_FIELDNAME_GracenoteExtData.c_str(); +static const std::wstring _DB_FIELDNAME_lossless = L"lossless"; static const wchar_t *DB_FIELDNAME_lossless = _DB_FIELDNAME_lossless.c_str(); +static const std::wstring _DB_FIELDNAME_category = L"category"; static const wchar_t *DB_FIELDNAME_category = _DB_FIELDNAME_category.c_str(); +static const std::wstring _DB_FIELDNAME_codec = L"codec"; static const wchar_t *DB_FIELDNAME_codec = _DB_FIELDNAME_codec.c_str(); +static const std::wstring _DB_FIELDNAME_director = L"director"; static const wchar_t *DB_FIELDNAME_director = _DB_FIELDNAME_director.c_str(); +static const std::wstring _DB_FIELDNAME_producer = L"producer"; static const wchar_t *DB_FIELDNAME_producer = _DB_FIELDNAME_producer.c_str(); +static const std::wstring _DB_FIELDNAME_width = L"width"; static const wchar_t *DB_FIELDNAME_width = _DB_FIELDNAME_width.c_str(); +static const std::wstring _DB_FIELDNAME_height = L"height"; static const wchar_t *DB_FIELDNAME_height = _DB_FIELDNAME_height.c_str(); +static const std::wstring _DB_FIELDNAME_mimetype = L"mimetype"; static const wchar_t *DB_FIELDNAME_mimetype = _DB_FIELDNAME_mimetype.c_str(); +static const std::wstring _DB_FIELDNAME_dateadded = L"dateadded"; static const wchar_t *DB_FIELDNAME_dateadded = _DB_FIELDNAME_dateadded.c_str(); + + +extern BOOL myMenu; + +int init(void); +void config(void); + +int treeGetParam(HTREEITEM h); + +class Table; +class C_Config; +extern CRITICAL_SECTION g_db_cs; +extern nde_database_t g_db; +extern nde_table_t g_table; +extern int g_table_dirty; +extern const wchar_t *WINAMP_INI; + +extern HWND m_curview_hwnd; + +extern wchar_t g_path[], g_tableDir[], g_viewsDir[]; +extern C_Config *g_config; + +extern HMENU g_context_menus, g_context_menus2; + +typedef struct +{ + wchar_t *name; + wchar_t *query; + wchar_t *metafn; //filename, without path, of meta file + int mode; + int imgIndex; + int index; +} queryItem; + +typedef std::map <int, queryItem*> QueryList; +extern QueryList m_query_list; +extern C_Config *g_view_metaconf; +extern int g_guessifany; +extern int g_querydelay; +extern int g_viewnotplay; + +void loadQueryTree(); +extern int m_query_tree; +extern int m_query_mode; +static wchar_t *m_query_metafile; +HWND onTreeViewSelectChange(HWND hwnd); + +void db_setFieldStringW(nde_scanner_t s, unsigned char id, const wchar_t *data); +void db_setFieldInt(nde_scanner_t s, unsigned char id, int data); +void db_setFieldInt64(nde_scanner_t s, unsigned char id, __int64 data); +int db_getFieldInt(nde_scanner_t s, unsigned char id, int defaultVal); +void db_removeField(nde_scanner_t s, unsigned char id); + +void main_playQuery(C_Config *metaconf, const wchar_t *query, int enqueue, int startplaying=1); // enqueue =-1 sends it to the playlist +void main_playItemRecordList (itemRecordListW *obj, int enqueue, int startplaying=1); +int addQueryItem(const wchar_t *name, const wchar_t *val, int mode, int select, const wchar_t *metafn, int imageIndex, int num=-1); +void replaceQueryItem(int n, const wchar_t *name, const wchar_t *val, int mode, int imageIndex); +void saveQueryTree(); + +int pluginHandleIpcMessage(int msg, int param); + +int openDb(); +void closeDb(); + +void nukeLibrary(HWND hwndDlg); + +//add.cpp +int addFileToDb(const wchar_t *filename, int onlyupdate, int use_metadata, int guess_mode, int playcnt=0, int lastplay=0, bool force=false); // adds a file to the db, gets info, etc. +int RemoveFileFromDB(/*const Table *table, */const wchar_t *filename); // removes a file from the DB +void makeFilename2(const char *filename, char *filename2, int filename2_len); +void makeFilename2W(const wchar_t *filename, wchar_t *filename2, int filename2_len); + +//gracenote.cpp +void gracenoteInit(); +int gracenoteQueryFile(const wchar_t *filename); +void gracenoteCancelRequest(); +int gracenoteDoTimerStuff(); +void gracenoteSetValues(const wchar_t *artist, const wchar_t *album, const wchar_t *title); +const wchar_t *gracenoteGetTuid(); +int gracenoteIsWorking(); + +//guess.cpp +wchar_t *guessTitles(const wchar_t *filename, + int *tracknum, + wchar_t **artist, + wchar_t **album, + wchar_t **title); // should free the result of this function after using artist/album/title + +//prefs.cpp +INT_PTR CALLBACK PrefsProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam); + +int autoscan_add_directory(const wchar_t *path, int *guess, int *meta, int *recurse, int noaddjustcheck);// if we return 1, guess and meta will be filled in +void refreshPrefs(int screen); + +//util.cpp +extern "C" { + void process_substantives(wchar_t* dest); + void ConvertRatingMenuStar(HMENU menu, UINT menu_id); +}; + +//view_audio.cpp +INT_PTR CALLBACK view_audioDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam); + +//view_miniinfo.cpp +INT_PTR CALLBACK view_miniinfoDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam); + +//view_errorinfo.cpp +INT_PTR CALLBACK view_errorinfoDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam); + +/* bgscan.cpp */ +void Scan_ScanFolderBackground(const wchar_t *path, int guess, int meta, int recurse); +void Scan_ScanFolder(HWND parent, const wchar_t *path, int guess, int meta, int recurse); +// When you call Scan_ScanFolders, it will own the memory and release it with free() +void Scan_ScanFolders(HWND parent, size_t count, wchar_t **paths, int *guess, int *meta, int *recurse); +void Scan_BackgroundScan(); +void Scan_Cancel(); +void Scan_Kill(); +// remove missing files +void Scan_RemoveFiles(HWND parent); + +//view_media.cpp +void makeQueryStringFromText(GayStringW *query, wchar_t *text, int nf=8); +inline BOOL WINAPI IsCharSpaceA(char c) { return (c == ' ' || c == '\t'); } +inline BOOL WINAPI IsCharSpaceW(wchar_t c) { return (c == L' ' || c == L'\t'); } +inline bool IsThe(const char *str) { if (str && (str[0] == 't' || str[0] == 'T') && (str[1] == 'h' || str[1] == 'H') && (str[2] == 'e' || str[2] == 'E') && (str[3] == ' ')) return true; else return false; } +__forceinline static bool IsTheW(const wchar_t *str) +{ + if ((str[0] & ~0x20) == L'T' + && (str[1] & ~0x20) == L'H' + && (str[2] & ~0x20) == L'E' + && str[3] == L' ') + return true; + else + return false; +} +#define SKIP_THE_AND_WHITESPACE(x) { char *save##x=(char*)x; while (IsCharSpaceA(*x) && *x) x++; if (IsThe(x)) x+=4; while (IsCharSpaceA(*x)) x++; if (!*x) x=save##x; } +#define SKIP_THE_AND_WHITESPACEW(x) { wchar_t *save##x=(wchar_t*)x; while ((*x == L' ' || *x == L'\t') && *x) x++; if (IsTheW(x)) x+=4; while ((*x == L' ' || *x == L'\t')) x++; if (!*x) x=save##x; } +//wherever this goes is fine + +#define UPDATE_QUERY_TIMER_ID 505 +#define UPDATE_RESULT_LIST_TIMER_ID 506 +INT_PTR CALLBACK view_mediaDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam); +int WCSCMP_NULLOK(const wchar_t *pa, const wchar_t *pb); + +typedef void (*resultsniff_funcW)(itemRecordW *items, int numitems, int user32, int *killswitch); + +void bgQuery_Stop(); +extern nde_scanner_t m_media_scanner; +typedef std::vector<wchar_t*> CloudFiles; + +// returns length in seconds (high bit on means could be much more), or -1 if killed +int saveQueryToListW(C_Config *viewconf, nde_scanner_t s, itemRecordListW *obj, + CloudFiles *uploaded, CloudFiles *uploading, + resultsniff_funcW cb=0, int user32=0, int *killswitch=0, __int64 *total_bytes=0); + +// queries.cpp +void view_queryContextMenu(INT_PTR param1, HWND hHost, POINTS pts, int item); +void queriesContextMenu(INT_PTR param1, HWND hHost, POINTS pts); +void queryEditItem(int n); +void addNewQuery(HWND parent); +void queryDeleteItem(HWND parent, int n); +BOOL windowOffScreen(HWND hwnd, POINT pt); + +// handleMessage.cpp +INT_PTR HandleIpcMessage(INT_PTR msg, INT_PTR param); +extern "C" extern int (*warand)(void); + +extern WNDPROC wa_oldWndProc; + +wchar_t *itemrecordWTagFunc(wchar_t * tag, void * p); +wchar_t *fieldTagFunc(wchar_t * tag, void * p); //return 0 if not found +void ndeTagFuncFree(wchar_t * tag, void * p); // for NDE strings +DWORD doGuessProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam ); +void TAG_FMT_EXT(const wchar_t *filename, void *f, void *ff, void *p, wchar_t *out, int out_len, int extended); +extern int asked_for_playcount; +LRESULT APIENTRY wa_newWndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam); +extern int m_calling_getfileinfo; +extern HMENU wa_play_menu ; +void add_pledit_to_library(); +void add_to_library(HWND wndparent); +extern int g_bgscan_scanning, g_bgrescan_force, g_bgrescan_do, g_bgrescan_int; +extern WNDPROC ml_oldWndProc; +extern time_t g_bgscan_last_rescan; +int runBGscan(int ms); +void compactRecordList(itemRecordListW *obj); + +LRESULT APIENTRY ml_newWndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam); +int FLOATCMP_NULLOK(const char *pa, const char *pb); +int FLOATWCMP_NULLOK(const wchar_t *pa, const wchar_t *pb); +void ClearTitleHookCache(); + +int FindFileInDatabase(nde_scanner_t s, int fieldId, const wchar_t *filename, wchar_t alternate[MAX_PATH]); + +__int64 ScannerRefToObjCacheNFNW(nde_scanner_t s, itemRecordListW *obj, bool compat); +__int64 ScannerRefToObjCacheNFNW(nde_scanner_t s, itemRecordW *obj, bool compat); +int updateFileInfo(const wchar_t *filename, const wchar_t *metadata, wchar_t *data); +void sortResults(C_Config *viewconf, itemRecordListW *obj); +void queryStrEscape(const char *raw, GayString &str); +void queryStrEscape(const wchar_t *raw, GayStringW &str); +void ParseIntSlashInt(wchar_t *string, int *part, int *parts); + +HWND updateCurrentView(HWND hwndDlg); + +#define MEDIAVIEW_COL_ARTIST 0 +#define MEDIAVIEW_COL_TITLE 1 +#define MEDIAVIEW_COL_ALBUM 2 +#define MEDIAVIEW_COL_LENGTH 3 +#define MEDIAVIEW_COL_TRACK 4 +#define MEDIAVIEW_COL_GENRE 5 +#define MEDIAVIEW_COL_YEAR 6 +#define MEDIAVIEW_COL_FILENAME 7 +#define MEDIAVIEW_COL_RATING 8 +#define MEDIAVIEW_COL_PLAYCOUNT 9 +#define MEDIAVIEW_COL_LASTPLAY 10 +#define MEDIAVIEW_COL_LASTUPD 11 +#define MEDIAVIEW_COL_FILETIME 12 +#define MEDIAVIEW_COL_COMMENT 13 +#define MEDIAVIEW_COL_FILESIZE 14 +#define MEDIAVIEW_COL_BITRATE 15 +#define MEDIAVIEW_COL_TYPE 16 +#define MEDIAVIEW_COL_DISC 17 +#define MEDIAVIEW_COL_ALBUMARTIST 18 +#define MEDIAVIEW_COL_FULLPATH 19 +#define MEDIAVIEW_COL_ALBUMGAIN 20 +#define MEDIAVIEW_COL_TRACKGAIN 21 +#define MEDIAVIEW_COL_PUBLISHER 22 +#define MEDIAVIEW_COL_COMPOSER 23 +#define MEDIAVIEW_COL_EXTENSION 24 +#define MEDIAVIEW_COL_ISPODCAST 25 +#define MEDIAVIEW_COL_PODCASTCHANNEL 26 +#define MEDIAVIEW_COL_PODCASTPUBDATE 27 +#define MEDIAVIEW_COL_BPM 28 +#define MEDIAVIEW_COL_CATEGORY 29 +#define MEDIAVIEW_COL_DIRECTOR 30 +#define MEDIAVIEW_COL_PRODUCER 31 +#define MEDIAVIEW_COL_DIMENSION 32 +#define MEDIAVIEW_COL_DATEADDED 33 +#define MEDIAVIEW_COL_CLOUD 34 + +#define MEDIAVIEW_COL_NUMS 35 // number of columns +#endif // ML_LOCAL_HEADER
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/ml_local.rc b/Src/Plugins/Library/ml_local/ml_local.rc new file mode 100644 index 00000000..0391a01a --- /dev/null +++ b/Src/Plugins/Library/ml_local/ml_local.rc @@ -0,0 +1,1244 @@ +// Microsoft Visual C++ generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "afxres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (U.S.) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US +#pragma code_page(1252) +#endif //_WIN32 + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""afxres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE +BEGIN + "#include ""version.rc2""\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog +// + +IDD_VIEW_MEDIA DIALOGEX 0, 0, 289, 274 +STYLE DS_SETFONT | DS_FIXEDSYS | DS_NOFAILCREATE | DS_CONTROL | WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN +EXSTYLE WS_EX_NOPARENTNOTIFY | WS_EX_ACCEPTFILES | WS_EX_CONTROLPARENT +FONT 8, "MS Shell Dlg", 0, 0, 0x0 +BEGIN + LTEXT "Search:",IDC_SEARCHCAPTION,1,2,25,8,SS_CENTERIMAGE + EDITTEXT IDC_QUICKSEARCH,28,1,209,10,ES_AUTOHSCROLL | NOT WS_BORDER + CONTROL "Clear Search",IDC_CLEAR,"Button",BS_OWNERDRAW | WS_TABSTOP,240,0,49,11 + CONTROL "List4",IDC_LIST2,"SysListView32",LVS_REPORT | LVS_SHOWSELALWAYS | LVS_OWNERDATA | WS_TABSTOP,0,14,289,246 + CONTROL "Play",IDC_BUTTON_PLAY,"Button",BS_OWNERDRAW | WS_TABSTOP,0,261,35,11 + CONTROL "Enqueue",IDC_BUTTON_ENQUEUE,"Button",BS_OWNERDRAW | WS_TABSTOP,38,261,35,11 + CONTROL "MusicIP Mix",IDC_BUTTON_MIX,"Button",BS_OWNERDRAW | BS_CENTER | WS_TABSTOP,76,261,47,11 + CONTROL "Generate Playlist",IDC_BUTTON_CREATEPLAYLIST,"Button",BS_OWNERDRAW | WS_TABSTOP,126,261,65,11 + CONTROL "",IDC_MEDIASTATUS,"Static",SS_LEFTNOWORDWRAP | SS_CENTERIMAGE | SS_ENDELLIPSIS | WS_GROUP,187,262,61,8 + CONTROL "",IDC_MIXABLE,"Static",SS_LEFTNOWORDWRAP | WS_GROUP,223,262,25,8 + CONTROL "Show Info",IDC_BUTTON_INFOTOGGLE,"Button",BS_OWNERDRAW | WS_TABSTOP,249,261,40,11 +END + +IDD_VIEW_AUDIO DIALOGEX 0, 0, 291, 279 +STYLE DS_SETFONT | DS_FIXEDSYS | DS_CONTROL | WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN +EXSTYLE WS_EX_NOPARENTNOTIFY | WS_EX_ACCEPTFILES | WS_EX_CONTROLPARENT +FONT 8, "MS Shell Dlg", 0, 0, 0x0 +BEGIN + CONTROL "",IDC_BUTTON_ARTMODE,"Button",BS_OWNERDRAW | WS_TABSTOP,0,1,14,11 + CONTROL "",IDC_BUTTON_VIEWMODE,"Button",BS_OWNERDRAW | WS_TABSTOP,16,1,20,11 + CONTROL "",IDC_BUTTON_COLUMNS,"Button",BS_OWNERDRAW | WS_TABSTOP,37,1,20,11 + EDITTEXT IDC_QUICKSEARCH,92,1,145,10,ES_AUTOHSCROLL | NOT WS_BORDER + CONTROL "Clear Search",IDC_CLEAR,"Button",BS_OWNERDRAW | WS_TABSTOP,240,0,49,11 + CONTROL "List1",IDC_LIST1,"SysListView32",LVS_REPORT | LVS_SHOWSELALWAYS | LVS_OWNERDATA | WS_TABSTOP,0,14,83,89 + CONTROL "List3",IDC_LIST2,"SysListView32",LVS_REPORT | LVS_SHOWSELALWAYS | LVS_OWNERDATA | WS_TABSTOP,89,14,100,89 + CONTROL "",IDC_LIST3,"SysListView32",LVS_REPORT | LVS_SHOWSELALWAYS | LVS_OWNERDATA | WS_TABSTOP,195,14,94,89 + LTEXT "Search:",IDC_SEARCHCAPTION,64,2,25,8 + CONTROL "",IDC_DIV1,"Static",SS_BLACKFRAME | NOT WS_VISIBLE,82,14,6,91 + CONTROL "",IDC_HDELIM,"Static",SS_BLACKFRAME | NOT WS_VISIBLE,0,106,289,6 + CONTROL "",IDC_DIV2,"Static",SS_BLACKFRAME | NOT WS_VISIBLE,188,14,6,91 +END + +IDD_PREFS1 DIALOGEX 0, 0, 260, 226 +STYLE DS_SETFONT | DS_FIXEDSYS | WS_CHILD +EXSTYLE WS_EX_CONTROLPARENT +FONT 8, "MS Shell Dlg", 0, 0, 0x1 +BEGIN + GROUPBOX "Library Display Settings",IDC_STATIC,4,3,256,40 + CONTROL "Display 'Show Info' in media and album views",IDC_CHECK3, + "Button",BS_AUTOCHECKBOX | WS_TABSTOP,10,15,162,10 + CONTROL "Remember search filters in media and album views",IDC_REMEMBER_SEARCH, + "Button",BS_AUTOCHECKBOX | WS_TABSTOP,10,28,178,10 + GROUPBOX "Recently Played",IDC_STATIC,4,46,256,57 + CONTROL "Enable 'Recently Played' in the Library",IDC_CHECK2, + "Button",BS_AUTOCHECKBOX | WS_TABSTOP,10,58,159,10 + PUSHBUTTON "Info...",IDC_BUTTON2,218,58,36,13 + CONTROL "Wait",IDC_CHECK7,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,72,30,8 + EDITTEXT IDC_EDIT2,48,70,24,12,ES_AUTOHSCROLL | ES_NUMBER + LTEXT "seconds before tracking items",IDC_STATIC4,76,72,101,8 + CONTROL "Wait",IDC_CHECK8,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,88,30,8 + EDITTEXT IDC_EDIT3,48,86,24,12,ES_AUTOHSCROLL | ES_NUMBER + LTEXT "percent of playback before tracking items",IDC_STATIC5,76,88,137,8 + GROUPBOX "Advanced Library Preferences",IDC_STATIC,4,107,256,82 + CONTROL "Use Library title information for Playlist Item Formatting",IDC_CHECK_ATF, + "Button",BS_AUTOCHECKBOX | WS_TABSTOP,10,120,193,10 + CONTROL "Display 'Refine' search field in album views",IDC_CHECK5, + "Button",BS_AUTOCHECKBOX | WS_TABSTOP,10,132,151,10 + CONTROL "Do not load the Library database at Winamp start-up",IDC_CHECK6, + "Button",BS_AUTOCHECKBOX | WS_TABSTOP,10,145,206,10 + CONTROL "Use Artist as Album Artist if not available",IDC_ARTIST_AS_ALBUMARTIST, + "Button",BS_AUTOCHECKBOX | WS_TABSTOP,10,158,146,10 + LTEXT "Search query delay:",IDC_STATIC_QUERYDELAY,10,173,71,10 + EDITTEXT IDC_EDIT_QUERYDELAY,78,171,27,13,ES_AUTOHSCROLL | ES_NUMBER + LTEXT "ms (default: 250)",IDC_STATIC,109,173,104,10 + GROUPBOX "Clear Library",IDC_STATIC,4,190,256,35 + LTEXT "Use this to remove all items from your Winamp Library. This will not physically remove any files from disk.",IDC_STATIC,10,202,176,18 + PUSHBUTTON "Clear Library...",IDC_BUTTON1,190,202,64,18 +END + +IDD_VIEW_DB_ERROR DIALOGEX 0, 0, 194, 166 +STYLE DS_SETFONT | DS_FIXEDSYS | DS_CONTROL | WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN +EXSTYLE WS_EX_CONTROLPARENT +FONT 8, "MS Shell Dlg", 0, 0, 0x0 +BEGIN + CTEXT "",IDC_DB_ERROR,10,10,174,129,0x2000 + CONTROL "Reset Database",IDC_RESET_DB_ON_ERROR,"Button",BS_OWNERDRAW | WS_TABSTOP,61,144,70,12 +END + +IDD_PREFSFR DIALOGEX 0, 0, 272, 246 +STYLE DS_SETFONT | DS_FIXEDSYS | WS_CHILD +EXSTYLE WS_EX_CONTROLPARENT +FONT 8, "MS Shell Dlg", 0, 0, 0x1 +BEGIN + CONTROL "Tab1",IDC_TAB1,"SysTabControl32",WS_TABSTOP,0,0,271,246 +END + +IDD_VIEW_MINIINFO DIALOGEX 0, 0, 291, 279 +STYLE DS_SETFONT | DS_FIXEDSYS | DS_CONTROL | WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN +EXSTYLE WS_EX_ACCEPTFILES | WS_EX_CONTROLPARENT +FONT 8, "MS Shell Dlg", 0, 0, 0x0 +BEGIN +END + +IDD_PREFS3 DIALOGEX 0, 0, 260, 226 +STYLE DS_SETFONT | DS_FIXEDSYS | WS_CHILD +EXSTYLE WS_EX_CONTROLPARENT +FONT 8, "MS Shell Dlg", 0, 0, 0x1 +BEGIN + GROUPBOX "Watch Folder Settings",IDC_STATIC,4,3,256,187 + LTEXT "New media found in the following folders will be automatically added to the Library:",IDC_STATIC,10,14,243,16 + CONTROL "List1",IDC_LIST1,"SysListView32",LVS_REPORT | LVS_SHOWSELALWAYS | LVS_NOSORTHEADER | WS_BORDER | WS_TABSTOP,10,34,242,74 + PUSHBUTTON "Add folder...",IDC_BUTTON1,10,111,60,13 + PUSHBUTTON "Edit selected",IDC_BUTTON4,74,111,53,13 + PUSHBUTTON "Remove selected",IDC_BUTTON3,188,111,64,13 + CONTROL "Automatically add played files",IDC_CHECK5,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,10,128,107,10 + CONTROL "Rescan folders at startup",IDC_CHECK3,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,10,140,95,10 + CONTROL "Automatically remove missing files",IDC_CHECK2,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,10,152,119,10 + CONTROL "Rescan folders every",IDC_CHECK4,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,10,164,80,11 + EDITTEXT IDC_EDIT3,92,164,32,12,ES_AUTOHSCROLL | ES_NUMBER + CONTROL "",IDC_SPIN1,"msctls_updown32",UDS_SETBUDDYINT | UDS_ALIGNRIGHT | UDS_AUTOBUDDY | UDS_ARROWKEYS | UDS_NOTHOUSANDS,116,164,7,12 + LTEXT "minutes",IDC_MINUTES,127,165,26,9,SS_CENTERIMAGE + PUSHBUTTON "Rescan now",IDC_RESCAN,188,163,64,13 + CONTROL "",IDC_STATUS,"Static",SS_LEFTNOWORDWRAP | SS_NOPREFIX | SS_PATHELLIPSIS | WS_GROUP,9,177,244,8 + GROUPBOX "Metadata Reading Settings",IDC_STATIC,4,192,256,33 + LTEXT "Click ""Configure"" to modify how title information is read when importing media files",IDC_STATIC,11,203,171,16 + PUSHBUTTON "Configure",IDC_CONFMETA,188,205,64,13 +END + +IDD_EDITDIR DIALOGEX 0, 0, 262, 146 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | DS_CENTER | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Edit folder properties" +FONT 8, "MS Shell Dlg", 0, 0, 0x0 +BEGIN + LTEXT "Folder path:",IDC_STATIC,7,8,38,8 + EDITTEXT IDC_EDIT1,7,17,198,14,ES_AUTOHSCROLL + PUSHBUTTON "Browse...",IDC_BUTTON1,208,17,43,14 + CONTROL "Add subfolders",IDC_CHECK2,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,7,35,63,10 + LTEXT "Metadata / filename detection override options:",IDC_STATIC,7,46,165,8 + CONTROL "Read file metadata tags if available (grey is default)",IDC_CHECK1, + "Button",BS_AUTO3STATE | WS_TABSTOP,24,56,197,10 + GROUPBOX "Filename metadata detection mode (when no tags available):",IDC_STATIC,24,66,231,54 + CONTROL "Default",IDC_RADIO6,"Button",BS_AUTORADIOBUTTON | WS_GROUP | WS_TABSTOP,30,76,39,10 + CONTROL "Smart (Detects ""Artist - Album\\TrackNum - Artist - Title"" etc)",IDC_RADIO1, + "Button",BS_AUTORADIOBUTTON,30,86,207,10 + CONTROL "Simple (Detects ""Artist\\Album\\Title"")",IDC_RADIO2, + "Button",BS_AUTORADIOBUTTON,30,96,137,10 + CONTROL "No guessing (title is filename, other fields empty)",IDC_RADIO8, + "Button",BS_AUTORADIOBUTTON,30,105,165,10 + DEFPUSHBUTTON "OK",IDOK,7,125,50,14 + PUSHBUTTON "Cancel",IDCANCEL,64,125,50,14 +END + +IDD_EDIT_QUERY DIALOGEX 0, 0, 322, 151 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Query Builder" +FONT 8, "MS Shell Dlg", 0, 0, 0x0 +BEGIN + GROUPBOX "Builder",IDC_STATIC_GENERAL,7,7,308,102 + GROUPBOX "Field :",IDC_STATIC,13,16,181,70 + LISTBOX IDC_LIST_FIELDS,20,26,52,55,LBS_SORT | LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP + CONTROL "Equal",IDC_RADIO_EQUAL,"Button",BS_AUTORADIOBUTTON | WS_GROUP | WS_TABSTOP,75,26,34,8 + CONTROL "Above",IDC_RADIO_ABOVE,"Button",BS_AUTORADIOBUTTON | WS_TABSTOP,75,34,37,8 + CONTROL "Below",IDC_RADIO_BELOW,"Button",BS_AUTORADIOBUTTON | WS_TABSTOP,75,42,35,8 + CONTROL "Above or Equal",IDC_RADIO_ABOVEOREQUAL,"Button",BS_AUTORADIOBUTTON | WS_TABSTOP,75,50,61,8 + CONTROL "Below or Equal",IDC_RADIO_BELOWOREQUAL,"Button",BS_AUTORADIOBUTTON | WS_TABSTOP,75,58,61,8 + CONTROL "Is not set",IDC_RADIO_ISEMPTY,"Button",BS_AUTORADIOBUTTON | WS_TABSTOP,141,25,44,8 + CONTROL "Is like",IDC_RADIO_ISLIKE,"Button",BS_AUTORADIOBUTTON | WS_TABSTOP,141,33,34,8 + CONTROL "Begins with",IDC_RADIO_BEGINS,"Button",BS_AUTORADIOBUTTON,141,41,52,8 + CONTROL "Ends in",IDC_RADIO_ENDS,"Button",BS_AUTORADIOBUTTON,141,49,39,8 + CONTROL "Contains",IDC_RADIO_CONTAINS,"Button",BS_AUTORADIOBUTTON,141,57,39,8 + CONTROL "Not",IDC_CHECK_NOT,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,76,71,27,10 + GROUPBOX "Compare to string",IDC_STATIC_STRING,198,16,112,29 + EDITTEXT IDC_EDIT_STRING,202,27,104,13,ES_AUTOHSCROLL + GROUPBOX "Compare to date/time",IDC_STATIC_DATETIME,198,47,112,40 + EDITTEXT IDC_EDIT_DATETIME,202,58,78,13,ES_AUTOHSCROLL + PUSHBUTTON "Edit",IDC_BUTTON_EDITDATETIME,284,58,22,13 + CTEXT "N/A",IDC_STATIC_CURDATETIME,202,74,104,9,SS_SUNKEN + LTEXT "Resulting expression :",IDC_STATIC,14,93,70,8 + EDITTEXT IDC_EDIT_RESULT,85,90,180,14,ES_AUTOHSCROLL | ES_READONLY + PUSHBUTTON ">>",ID_BUTTON_SENDTOQUERY,268,90,41,14 + PUSHBUTTON "AND",IDC_BUTTON_AND,268,90,19,14 + PUSHBUTTON "OR",IDC_BUTTON_OR,290,90,19,14 + LTEXT "Query :",IDC_STATIC_QUERY,7,115,24,8 + EDITTEXT IDC_EDIT_QUERY,33,112,282,14,ES_AUTOHSCROLL + DEFPUSHBUTTON "OK",IDOK,211,130,50,14 + PUSHBUTTON "Cancel",IDCANCEL,265,130,50,14 +END + +IDD_EDIT_QUERY_PICK DIALOGEX 0, 0, 178, 78 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Pick date/time" +FONT 8, "MS Shell Dlg", 0, 0, 0x0 +BEGIN + CONTROL "DateTimePicker2",IDC_DATETIMEPICKER,"SysDateTimePick32",DTS_RIGHTALIGN | DTS_SHOWNONE | DTS_LONGDATEFORMAT | WS_TABSTOP,20,13,145,15 + CONTROL "DateTimePicker1",IDC_DATETIMEPICKER1,"SysDateTimePick32",DTS_RIGHTALIGN | DTS_UPDOWN | DTS_SHOWNONE | WS_TABSTOP | 0x8,43,32,105,15 + DEFPUSHBUTTON "OK",IDOK,67,57,50,14 + PUSHBUTTON "Cancel",IDCANCEL,121,57,50,14 +END + +IDD_CUSTCOLUMNS DIALOGEX 0, 0, 342, 154 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Customize columns" +FONT 8, "MS Shell Dlg", 0, 0, 0x0 +BEGIN + GROUPBOX "Hidden Columns",IDC_STATIC,7,7,126,120 + LISTBOX IDC_LIST2,13,17,114,104,LBS_NOINTEGRALHEIGHT | LBS_EXTENDEDSEL | WS_VSCROLL | WS_TABSTOP + DEFPUSHBUTTON "OK",IDOK,7,133,50,14 + PUSHBUTTON "Cancel",IDCANCEL,62,133,50,14 + PUSHBUTTON "Add -->",IDC_BUTTON2,138,41,66,14,WS_DISABLED + PUSHBUTTON "<-- Remove",IDC_BUTTON3,138,59,66,14,WS_DISABLED + PUSHBUTTON "Restore Defaults",IDC_DEFS,138,107,66,14 + GROUPBOX "Visible Columns",IDC_STATIC,208,7,126,140 + LISTBOX IDC_LIST1,214,17,114,110,LBS_NOINTEGRALHEIGHT | LBS_EXTENDEDSEL | WS_VSCROLL | WS_TABSTOP + PUSHBUTTON "Move up",IDC_BUTTON4,239,130,43,12,WS_DISABLED + PUSHBUTTON "Move down",IDC_BUTTON5,285,130,43,12,WS_DISABLED +END + +#if defined(APSTUDIO_INVOKED) || defined(DISABLED) +#if defined(APSTUDIO_INVOKED) +IDD_NDE_RECOVERY$(DISABLED) DIALOGEX 0, 0, 261, 107 +#else +IDD_NDE_RECOVERY DIALOGEX 0, 0, 261, 107 +#endif +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | DS_CENTER | WS_POPUP | WS_CAPTION +CAPTION "Winamp5 Library Recovery" +FONT 8, "MS Shell Dlg", 0, 0, 0x0 +BEGIN + LTEXT "Inconsistencies were detected while loading your Library database, we are now trying to correct them.",IDC_STATIC,13,8,235,18 + CONTROL "Progress1",IDC_PROGRESS_PERCENT,"msctls_progress32",WS_BORDER,23,32,214,14 + CTEXT "0%",IDC_STATIC_PERCENT,116,47,30,8 + LTEXT "Total number of records:",IDC_STATIC,23,61,78,8 + LTEXT "0",IDC_STATIC_TOTAL,106,61,47,8 + LTEXT "Records recovered:",IDC_STATIC,23,72,64,8 + LTEXT "0",IDC_STATIC_RECOVERED,106,72,47,8 + LTEXT "Records lost:",IDC_STATIC,24,83,42,8 + LTEXT "0",IDC_STATIC_LOST,106,83,47,8 + DEFPUSHBUTTON "OK",IDOK,204,86,50,14 +END +#endif + +IDD_NEEDADDFILES DIALOGEX 0, 0, 201, 105 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | DS_CENTER | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Add Media to Library" +FONT 8, "MS Shell Dlg", 0, 0, 0x0 +BEGIN + LTEXT "You currently have nothing in your library. To add media, select from the options below.",IDC_TEXT,7,7,187,17 + PUSHBUTTON "Add Media to Library",ID_ADD_FILES,52,31,96,14 + PUSHBUTTON "Import from iTunes",IDC_IMPORT_ITUNES,52,49,96,14,WS_DISABLED + CONTROL "Do not show me this again",IDC_CHECK1,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,7,70,99,10 + PUSHBUTTON "Close",IDOK,7,85,50,13 + CONTROL "Learn More About Winamp",IDC_BTN_LINK_PROMO,"Button",BS_OWNERDRAW | BS_RIGHT | BS_BOTTOM | WS_TABSTOP,73,85,121,13 +END + +IDD_SCROLLCHILD DIALOGEX 0, 0, 310, 17 +STYLE DS_SETFONT | DS_FIXEDSYS | DS_CONTROL | WS_CHILD +FONT 8, "MS Shell Dlg", 0, 0, 0x0 +BEGIN + PUSHBUTTON "+",IDC_BUTTON1,1,2,13,11 +END + +IDD_SCROLLCHILDHOST DIALOGEX 0, 0, 310, 101 +STYLE DS_SETFONT | DS_FIXEDSYS | DS_CONTROL | WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL +FONT 8, "MS Shell Dlg", 0, 0, 0x0 +BEGIN +END + +IDD_SCROLLCHILDFILTER DIALOGEX 0, 0, 310, 24 +STYLE DS_SETFONT | DS_FIXEDSYS | DS_CONTROL | WS_CHILD | WS_CLIPCHILDREN +FONT 8, "MS Shell Dlg", 0, 0, 0x0 +BEGIN + PUSHBUTTON "-",IDC_BUTTON1,1,2,13,12 + COMBOBOX IDC_COMBO1,17,2,72,183,CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP + COMBOBOX IDC_COMBO2,92,2,80,172,CBS_DROPDOWNLIST | CBS_SORT | WS_VSCROLL | WS_TABSTOP + EDITTEXT IDC_EDIT1,173,2,128,13,ES_AUTOHSCROLL + PUSHBUTTON "Choose Time",IDC_BUTTON2,251,1,50,12,NOT WS_VISIBLE + PUSHBUTTON "Query Builder",IDC_BUTTON_QUERYBUILD,251,1,50,12,NOT WS_VISIBLE + CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,1,19,12,1 + CONTROL "and",IDC_AND,"Button",BS_AUTORADIOBUTTON,14,15,27,10,WS_EX_TRANSPARENT + CONTROL "or",IDC_OR,"Button",BS_AUTORADIOBUTTON,41,15,23,10,WS_EX_TRANSPARENT + CONTROL "",IDC_STATIC,"Static",SS_ETCHEDHORZ,63,19,240,1 +END + +IDD_TIMEEDITOR DIALOGEX 0, 0, 281, 229 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Choose Time" +FONT 8, "MS Shell Dlg", 0, 0, 0x1 +BEGIN + GROUPBOX "",IDC_STATIC_ABSOLUTE,7,7,267,37 + CONTROL "Absolute",IDC_CHECK_ABSOLUTE,"Button",BS_AUTORADIOBUTTON | WS_TABSTOP,13,7,42,10,WS_EX_TRANSPARENT + CONTROL "DateTimePicker2",IDC_DATETIMEPICKER,"SysDateTimePick32",DTS_RIGHTALIGN | DTS_SHOWNONE | WS_TABSTOP,13,20,145,15 + CONTROL "DateTimePicker1",IDC_DATETIMEPICKER1,"SysDateTimePick32",DTS_RIGHTALIGN | DTS_UPDOWN | DTS_SHOWNONE | WS_TABSTOP | 0x8,164,20,105,15 + GROUPBOX "",IDC_STATIC_RELATIVE,7,46,267,141 + CONTROL "Relative",IDC_CHECK_RELATIVE,"Button",BS_AUTORADIOBUTTON | WS_TABSTOP,13,46,40,8,WS_EX_TRANSPARENT + GROUPBOX "",IDC_STATIC_TIMEAGO,13,55,255,32,WS_GROUP + CONTROL "Time ago",IDC_CHECK_TIMEAGO,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,55,43,10,WS_EX_TRANSPARENT + EDITTEXT IDC_EDIT_TIMEAGO,19,66,29,14,ES_AUTOHSCROLL + CONTROL "Year(s)",IDC_RADIO_TIMEAGO_Y,"Button",BS_AUTORADIOBUTTON | WS_GROUP,53,65,37,8 + CONTROL "Hour(s)",IDC_RADIO_TIMEAGO_H,"Button",BS_AUTORADIOBUTTON,53,74,37,8 + CONTROL "Month(s)",IDC_RADIO_TIMEAGO_M,"Button",BS_AUTORADIOBUTTON,92,65,45,8 + CONTROL "Minute(s)",IDC_RADIO_TIMEAGO_MIN,"Button",BS_AUTORADIOBUTTON,92,74,46,8 + CONTROL "Week(s)",IDC_RADIO_TIMEAGO_W,"Button",BS_AUTORADIOBUTTON,137,65,41,8 + CONTROL "Second(s)",IDC_RADIO_TIMEAGO_S,"Button",BS_AUTORADIOBUTTON,137,74,52,8 + CONTROL "Day(s)",IDC_RADIO_TIMEAGO_D,"Button",BS_AUTORADIOBUTTON,180,65,33,8 + GROUPBOX "From Origin",IDC_STATIC_DIRECTION,215,55,53,32 + CONTROL "After",IDC_RADIO_AFTER,"Button",BS_AUTORADIOBUTTON | WS_GROUP,221,65,31,8 + CONTROL "Before",IDC_RADIO_BEFORE,"Button",BS_AUTORADIOBUTTON,221,74,34,8 + GROUPBOX "",IDC_STATIC_SELECTIVE,13,90,255,79,WS_GROUP + CONTROL "Origin",IDC_CHECK_SELECTIVE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,90,32,10,WS_EX_TRANSPARENT + GROUPBOX "",IDC_STATIC_YEAR,17,98,79,34,WS_GROUP + CONTROL "This year",IDC_RADIO_THISYEAR,"Button",BS_AUTORADIOBUTTON | WS_GROUP,23,106,45,9 + CONTROL "Year :",IDC_RADIO_YEAR,"Button",BS_AUTORADIOBUTTON,23,116,30,10 + EDITTEXT IDC_EDIT_YEAR,56,116,36,12,ES_AUTOHSCROLL + GROUPBOX "",IDC_STATIC_MONTH,98,98,88,34 + CONTROL "This month",IDC_RADIO_THISMONTH,"Button",BS_AUTORADIOBUTTON | WS_GROUP,104,106,51,9 + CONTROL "Month :",IDC_RADIO_MONTH,"Button",BS_AUTORADIOBUTTON,104,116,35,10 + PUSHBUTTON "September",IDC_BUTTON_MONTH,143,116,40,11 + GROUPBOX "",IDC_STATIC_DAY,188,98,75,34,WS_GROUP + CONTROL "This day",IDC_RADIO_THISDAY,"Button",BS_AUTORADIOBUTTON | WS_GROUP,194,106,43,9 + CONTROL "Day :",IDC_RADIO_DAY,"Button",BS_AUTORADIOBUTTON,194,116,28,10 + EDITTEXT IDC_EDIT_DAY,224,116,36,12,ES_AUTOHSCROLL + GROUPBOX "",IDC_STATIC_TIME,17,130,191,34,WS_GROUP + CONTROL "This time",IDC_RADIO_THISTIME,"Button",BS_AUTORADIOBUTTON | WS_GROUP,23,138,45,9 + CONTROL "Noon",IDC_RADIO_NOON,"Button",BS_AUTORADIOBUTTON,23,148,33,10 + CONTROL "Midnight",IDC_RADIO_MIDNIGHT,"Button",BS_AUTORADIOBUTTON,84,138,39,10 + CONTROL "Time :",IDC_RADIO_TIME,"Button",BS_AUTORADIOBUTTON,84,148,32,10 + CONTROL "DateTimePicker1",IDC_DATETIMEPICKER2,"SysDateTimePick32",DTS_RIGHTALIGN | DTS_UPDOWN | WS_TABSTOP | 0x8,131,146,72,13 + PUSHBUTTON "Now",IDC_BUTTON_NOW,212,135,51,13 + PUSHBUTTON "Pick",IDC_BUTTON_PICK,212,150,51,13 + LTEXT "Resulting date/time :",IDC_STATIC_RESULT,14,172,66,8 + CTEXT "N/A",IDC_STATIC_QUERYTIME,85,172,183,10,SS_SUNKEN + LTEXT "Formatted date/time :",IDC_STATIC,7,191,68,8 + EDITTEXT IDC_EDIT_RESULT,77,189,197,12,ES_AUTOHSCROLL | ES_READONLY + DEFPUSHBUTTON "OK",IDOK,169,206,50,14 + PUSHBUTTON "Cancel",IDCANCEL,224,206,50,14 +END + +IDD_PREFS_METADATA DIALOGEX 0, 0, 278, 86 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION +EXSTYLE WS_EX_CONTROLPARENT +CAPTION "Metadata Reading Settings" +FONT 8, "MS Shell Dlg", 0, 0, 0x1 +BEGIN + CONTROL "Read media information on import if available",IDC_CHECK1, + "Button",BS_AUTOCHECKBOX | WS_TABSTOP,7,5,197,10 + LTEXT "Use the following detection logic when",IDC_STATIC1,16,20,122,8 + COMBOBOX IDC_COMBO1,140,18,31,142,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP + LTEXT "media information is missing:",IDC_STATIC2,174,20,97,8 + CONTROL "Smart (Detects ""Artist - Album\\TrackNum - Artist - Title"" etc)",IDC_RADIO1, + "Button",BS_AUTORADIOBUTTON | WS_GROUP | WS_TABSTOP,19,32,217,10 + CONTROL "Simple (Detects ""Artist\\Album\\Title"")",IDC_RADIO2, + "Button",BS_AUTORADIOBUTTON,19,43,189,10 + CONTROL "No guessing (title is filename, other fields empty)",IDC_RADIO3, + "Button",BS_AUTORADIOBUTTON,19,54,211,10 + DEFPUSHBUTTON "OK",IDOK,167,68,50,13 + PUSHBUTTON "Cancel",IDCANCEL,221,68,50,13 +END + +IDD_MONITOR_SMALL DIALOGEX 0, 0, 146, 35 +STYLE DS_SETFONT | DS_SETFOREGROUND | DS_FIXEDSYS | WS_POPUP +EXSTYLE WS_EX_TOOLWINDOW | WS_EX_CONTROLPARENT +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN +END + +IDD_MONITOR_HIDE DIALOGEX 0, 0, 285, 54 +STYLE DS_SETFONT | DS_SETFOREGROUND | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Confirmation Dialog" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + LTEXT "Are you sure you want to hide local media monitor window?\n This will not stop monitor.",IDC_STATIC,7,7,271,22 + DEFPUSHBUTTON "Yes",IDOK,174,34,50,13 + PUSHBUTTON "No",IDCANCEL,228,34,50,13 +END + +IDD_REFRESH_METADATA DIALOGEX 0, 0, 249, 28 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | DS_CENTER | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Reading Metadata" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + LTEXT "Progress:",IDC_STATIC,7,7,32,8 + LTEXT "",IDC_REFRESHMETADATA_STATUS,52,7,133,8 + PUSHBUTTON "Cancel",IDCANCEL,192,7,50,14 +END + +IDD_REINDEX DIALOGEX 0, 0, 269, 30 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | DS_CENTER | WS_POPUP | WS_VISIBLE | WS_CAPTION +CAPTION "Reindexing Library" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + CONTROL "",IDC_PROGRESS1,"msctls_progress32",WS_BORDER,7,7,255,16 +END + +IDD_ADD_VIEW_2 DIALOGEX 0, 0, 332, 255 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "New Smart View" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + LTEXT "Choose a Preset:",IDC_STATIC,5,8,56,9,SS_CENTERIMAGE + COMBOBOX IDC_COMBO_PRESETS,70,7,151,162,CBS_DROPDOWN | WS_VSCROLL | WS_TABSTOP + PUSHBUTTON "Advanced mode >>",IDC_BUTTON_MODE,247,7,80,13 + GROUPBOX "",IDC_STATIC,5,21,322,154 + CONTROL "",IDC_CHILDFRAME,"Static",SS_BLACKRECT | NOT WS_VISIBLE,11,30,310,139 + CONTROL "Don't show me this again",IDC_CHECK_SHOWINFO,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,11,111,95,10 + GROUPBOX "",IDC_STATIC,5,176,322,43 + LTEXT "Filters:",IDC_STATIC_FILTER,17,187,23,9,SS_CENTERIMAGE + CONTROL "",IDC_RADIO_SIMPLE,"Button",BS_AUTORADIOBUTTON | WS_GROUP,46,187,10,10,WS_EX_TRANSPARENT + CONTROL 157,IDC_IMAGE_SIMPLE,"Static",SS_BITMAP | SS_NOTIFY,56,187,11,10,WS_EX_TRANSPARENT + LTEXT "Simple",IDC_STATIC_SIMPLE,69,188,21,8,SS_NOTIFY + CONTROL "",IDC_RADIO_SIMPLEALBUM,"Button",BS_AUTORADIOBUTTON,105,187,10,10,WS_EX_TRANSPARENT + CONTROL 160,IDC_IMAGE_SIMPLEALBUM,"Static",SS_BITMAP | SS_NOTIFY,115,187,11,10 + LTEXT "Simple Album",IDC_STATIC_SIMPLEALBUM,129,188,42,8,SS_NOTIFY + CONTROL "",IDC_RADIO_TWOFILTERS,"Button",BS_AUTORADIOBUTTON,181,187,10,8,WS_EX_TRANSPARENT + CONTROL 159,IDC_IMAGE_TWOFILTERS,"Static",SS_BITMAP | SS_NOTIFY,191,187,11,10 + LTEXT "Two",IDC_STATIC_TWOFILTERS,205,188,14,8,SS_NOTIFY + CONTROL "",IDC_RADIO_THREEFILTERS,"Button",BS_AUTORADIOBUTTON,233,187,10,8,WS_EX_TRANSPARENT + CONTROL 158,IDC_IMAGE_THREEFILTERS,"Static",SS_BITMAP | SS_NOTIFY,243,187,11,10 + LTEXT "Three",IDC_STATIC_THREEFILTERS,257,188,20,8,SS_NOTIFY + COMBOBOX IDC_COMBO_FILTER1,46,200,80,87,CBS_DROPDOWN | WS_VSCROLL | WS_TABSTOP + LTEXT "/",IDC_STATIC_FILTER2,127,202,8,8 + COMBOBOX IDC_COMBO_FILTER2,131,200,80,87,CBS_DROPDOWN | WS_VSCROLL | WS_TABSTOP + LTEXT "/",IDC_STATIC_FILTER3,212,202,8,8 + COMBOBOX IDC_COMBO_FILTER3,216,200,80,87,CBS_DROPDOWN | WS_VSCROLL | WS_TABSTOP + LTEXT "Name:",IDC_STATIC,5,225,19,9,SS_CENTERIMAGE + EDITTEXT IDC_NAME,33,223,130,13,ES_AUTOHSCROLL + CONTROL "Hide extra info pane",IDC_HIDE_EXTINFO,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,240,223,81,10 + PUSHBUTTON "OK",IDOK,223,237,50,13 + PUSHBUTTON "Cancel",IDCANCEL,277,237,50,13 + LTEXT "",IDC_STATIC_INFO,11,30,310,75 +END + +IDD_ADD_VIEW_2_NF DIALOGEX 0, 0, 332, 197 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "New Smart View" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + LTEXT "Choose a Preset:",-1,5,8,56,9,SS_CENTERIMAGE + COMBOBOX IDC_COMBO_PRESETS,70,7,151,162,CBS_DROPDOWN | WS_VSCROLL | WS_TABSTOP + GROUPBOX "",-1,5,21,322,154 + CONTROL "",IDC_CHILDFRAME,"Static",SS_BLACKRECT | NOT WS_VISIBLE,11,30,310,139 + CONTROL "Don't show me this again",IDC_CHECK_SHOWINFO,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,11,111,95,10 + LTEXT "Name:",-1,5,181,25,9,SS_CENTERIMAGE + EDITTEXT IDC_NAME,33,179,130,13,ES_AUTOHSCROLL + PUSHBUTTON "OK",IDOK,223,179,50,13 + PUSHBUTTON "Cancel",IDCANCEL,277,179,50,13 + LTEXT "",IDC_STATIC_INFO,11,30,310,75 + PUSHBUTTON "Advanced mode >>",IDC_BUTTON_MODE,247,7,80,13 +END + +IDD_ADD_VIEW_CHILD_ADVANCED DIALOGEX 0, 0, 310, 138 +STYLE DS_SETFONT | DS_FIXEDSYS | DS_CONTROL | WS_CHILD | WS_VISIBLE | WS_SYSMENU +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + LTEXT "Query:",IDC_STATIC,0,2,22,9,SS_CENTERIMAGE + EDITTEXT IDC_QUERY,25,1,236,12,ES_AUTOHSCROLL + PUSHBUTTON "Query Builder",IDC_EDIT,262,1,47,12 + GROUPBOX "Query Language Documentation",IDC_STATIC,0,17,310,121 + EDITTEXT IDC_EDIT1,6,28,297,104,ES_MULTILINE | ES_READONLY | WS_VSCROLL +END + + +///////////////////////////////////////////////////////////////////////////// +// +// DESIGNINFO +// + +#ifdef APSTUDIO_INVOKED +GUIDELINES DESIGNINFO +BEGIN + IDD_VIEW_AUDIO, DIALOG + BEGIN + RIGHTMARGIN, 289 + END + + IDD_PREFS1, DIALOG + BEGIN + LEFTMARGIN, 4 + RIGHTMARGIN, 259 + END + + IDD_VIEW_DB_ERROR, DIALOG + BEGIN + LEFTMARGIN, 10 + RIGHTMARGIN, 184 + TOPMARGIN, 10 + BOTTOMMARGIN, 156 + END + + IDD_PREFSFR, DIALOG + BEGIN + RIGHTMARGIN, 191 + BOTTOMMARGIN, 191 + END + + IDD_EDITDIR, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 255 + TOPMARGIN, 7 + BOTTOMMARGIN, 139 + END + + IDD_EDIT_QUERY, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 315 + TOPMARGIN, 7 + BOTTOMMARGIN, 144 + END + + IDD_EDIT_QUERY_PICK, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 171 + TOPMARGIN, 7 + BOTTOMMARGIN, 71 + END + + IDD_CUSTCOLUMNS, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 335 + TOPMARGIN, 7 + BOTTOMMARGIN, 147 + END + + "IDD_NDE_RECOVERY$(DISABLED)", DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 254 + TOPMARGIN, 8 + BOTTOMMARGIN, 100 + END + + IDD_NEEDADDFILES, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 194 + TOPMARGIN, 7 + BOTTOMMARGIN, 98 + END + + IDD_SCROLLCHILD, DIALOG + BEGIN + BOTTOMMARGIN, 14 + END + + IDD_SCROLLCHILDHOST, DIALOG + BEGIN + RIGHTMARGIN, 295 + END + + IDD_TIMEEDITOR, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 274 + TOPMARGIN, 7 + BOTTOMMARGIN, 220 + END + + IDD_PREFS_METADATA, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 271 + TOPMARGIN, 5 + BOTTOMMARGIN, 81 + END + + IDD_MONITOR_HIDE, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 278 + TOPMARGIN, 7 + BOTTOMMARGIN, 47 + END + + IDD_REFRESH_METADATA, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 242 + TOPMARGIN, 7 + BOTTOMMARGIN, 21 + END + + IDD_REINDEX, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 262 + TOPMARGIN, 7 + BOTTOMMARGIN, 23 + END + + IDD_ADD_VIEW_2, DIALOG + BEGIN + LEFTMARGIN, 5 + RIGHTMARGIN, 327 + TOPMARGIN, 7 + BOTTOMMARGIN, 250 + END + + IDD_ADD_VIEW_2_NF, DIALOG + BEGIN + LEFTMARGIN, 5 + RIGHTMARGIN, 327 + TOPMARGIN, 7 + BOTTOMMARGIN, 192 + END + + IDD_ADD_VIEW_CHILD_ADVANCED, DIALOG + BEGIN + RIGHTMARGIN, 309 + END +END +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Menu +// + +IDR_CONTEXTMENUS MENU +BEGIN + POPUP "MediaWnd" + BEGIN + MENUITEM "Play selection\tEnter", ID_MEDIAWND_PLAYSELECTEDFILES + MENUITEM "Enqueue selection\tShift+Enter", ID_MEDIAWND_ENQUEUESELECTEDFILES + POPUP "Send to:" + BEGIN + MENUITEM "", ID_MEDIAWND_ADDTOPLAYLIST + END + MENUITEM SEPARATOR + MENUITEM "Select all\tCtrl+A", ID_MEDIAWND_SELECTALL + MENUITEM SEPARATOR + MENUITEM "Edit metadata for selection...\tCtrl+E", ID_EDITITEMINFOS + MENUITEM "View f&ile info...\tAlt+3", ID_PE_ID3 + MENUITEM "Read metadata on selected items\tCtrl+R", IDC_REFRESH_METADATA + POPUP "Rate items" + BEGIN + MENUITEM "*****", ID_RATE_5 + MENUITEM "****", ID_RATE_4 + MENUITEM "***", ID_RATE_3 + MENUITEM "**", ID_RATE_2 + MENUITEM "*", ID_RATE_1 + MENUITEM "No rating", ID_RATE_0 + END + MENUITEM SEPARATOR + MENUITEM "Explore item folder\tCtrl+F", ID_MEDIAWND_EXPLOREFOLDER + MENUITEM SEPARATOR + POPUP "Remove..." + BEGIN + MENUITEM "Remove all dead files", ID_MEDIAWND_REMOVE_REMOVEALLDEADFILES + MENUITEM "Physically remove selected item(s)", ID_MEDIAWND_REMOVE_PHYSICALLYREMOVESELECTEDITEMS + END + MENUITEM "Remove from library\tDel", ID_MEDIAWND_REMOVEFROMLIBRARY + END + POPUP "AudioWnd" + BEGIN + MENUITEM "Play selection\tEnter", ID_AUDIOWND_PLAYSELECTION + MENUITEM "Enqueue selection\tShift+Enter", ID_AUDIOWND_ENQUEUESELECTION + POPUP "Send to:" + BEGIN + MENUITEM "", ID_MEDIAWND_ADDTOPLAYLIST + END + MENUITEM SEPARATOR + POPUP "Rate" + BEGIN + MENUITEM "*****", ID_RATE_5 + MENUITEM "****", ID_RATE_4 + MENUITEM "***", ID_RATE_3 + MENUITEM "**", ID_RATE_2 + MENUITEM "*", ID_RATE_1 + MENUITEM "No rating", ID_RATE_0 + END + MENUITEM SEPARATOR + MENUITEM "Play random item", ID_AUDIOWND_PLAYRANDOMITEM + MENUITEM "Enqueue random item", ID_AUDIOWND_ENQUEUERANDOMITEM + END + POPUP "QueryWnd" + BEGIN + MENUITEM "Play\tEnter", ID_QUERYWND_PLAYQUERY + MENUITEM "Enqueue\tShift+Enter", ID_QUERYWND_ENQUEUEQUERY + POPUP "Send to:" + BEGIN + MENUITEM "", ID_MEDIAWND_ADDTOPLAYLIST + END + MENUITEM SEPARATOR + MENUITEM "Edit View...\tF2", ID_QUERYWND_EDIT + MENUITEM "Add Smart View...\tIns", ID_QUERYMENU_ADDNEWQUERY + MENUITEM SEPARATOR + MENUITEM "Delete View\tDel", ID_QUERYWND_DELETE + END + POPUP "QueryMenu" + BEGIN + MENUITEM "Add Smart View...\tIns", ID_QUERYMENU_ADDNEWQUERY + MENUITEM SEPARATOR + MENUITEM "&Preferences", ID_QUERYMENU_PREFERENCES + MENUITEM SEPARATOR + MENUITEM "Help", ID_QUERYMENU_HELP + END + POPUP "HeaderWnd" + BEGIN + MENUITEM "Customize columns...", ID_HEADERWND_CUSTOMIZECOLUMNS + END + POPUP "FilterHeaderWnd" + BEGIN + MENUITEM "Customize columns...", ID_HEADERWND_CUSTOMIZECOLUMNS + MENUITEM "Show Horizontal Scrollbar", ID_FILTERHEADERWND_SHOWHORIZONTALSCROLLBAR + END + POPUP "ArtHeaderWnd" + BEGIN + MENUITEM "Small Icon", ID_ARTHEADERWND_SMALLICON + MENUITEM "Medium Icon", ID_ARTHEADERWND_MEDIUMICON + MENUITEM "Large Icon", ID_ARTHEADERWND_LARGEICON + MENUITEM "Extra Large Icon", ID_ARTHEADERWND_EXTRALARGEICON + MENUITEM "Show Album Title", ID_ARTHEADERWND_SHOWTEXT + MENUITEM SEPARATOR + MENUITEM "Small Details", ID_ARTHEADERWND_SMALLDETAILS + MENUITEM "Medium Details", ID_ARTHEADERWND_MEDIUMDETAILS + MENUITEM "Large Details", ID_ARTHEADERWND_LARGEDETAILS + END +END + + +///////////////////////////////////////////////////////////////////////////// +// +// Bitmap +// + +IDB_TREEITEM_AUDIO BITMAP "resources\\ti_audio_16x16x16.bmp" +IDB_TREEITEM_MOSTPLAYED BITMAP "resources\\ti_most_played_16x16x16.bmp" +IDB_TREEITEM_NEVERPLAYED BITMAP "resources\\ti_never_played_16x16x16.bmp" +IDB_TREEITEM_RECENTLYADDED BITMAP "resources\\ti_recently_added_16x16x16.bmp" +IDB_TREEITEM_RECENTLYPLAYED BITMAP "resources\\ti_recently_played_16x16x16.bmp" +IDB_TREEITEM_TOPRATED BITMAP "resources\\ti_top_rated_16x16x16.bmp" +IDB_TREEITEM_VIDEO BITMAP "resources\\ti_video_16x16x16.bmp" +IDB_TREEITEM_PODCASTS BITMAP "resources\\ti_podcasts_16x16x16.bmp" +IDB_NEWFILTER_SIMPLE BITMAP "resources\\nf_simple.bmp" +IDB_NEWFILTER_THREEFILTERS BITMAP "resources\\nf_threefilters.bmp" +IDB_NEWFILTER_TWOFILTERS BITMAP "resources\\nf_twofilters.bmp" +IDB_NEWFILTER_SIMPLEALBUM BITMAP "resources\\nf_simplealbum.bmp" +IDB_TOOL_MODE BITMAP "resources\\icn_view_mode.bmp" +IDB_TOOL_ART BITMAP "resources\\icn_alb_art.bmp" +IDB_TOOL_COLS BITMAP "resources\\icn_columns.bmp" +IDB_TREEITEM_RECENTLYMODIFIED BITMAP "resources\\ti_recently_modified_16x16x16.bmp" + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog Info +// + +IDD_ADD_VIEW_2 DLGINIT +BEGIN + IDC_COMBO_PRESETS, 0x403, 7, 0 +0x6473, 0x6466, 0x6673, "\000" + 0 +END + +IDD_ADD_VIEW_2_NF DLGINIT +BEGIN + IDC_COMBO_PRESETS, 0x403, 7, 0 +0x6473, 0x6466, 0x6673, "\000" + 0 +END + + +///////////////////////////////////////////////////////////////////////////// +// +// TEXT +// + +IDR_QUERIES_TEXT TEXT "queries.txt" +IDR_DB_ERROR TEXT "db_error.txt" +IDR_NDE_ERROR TEXT "nde_error.txt" + +///////////////////////////////////////////////////////////////////////////// +// +// Accelerator +// + +IDR_VIEW_ACCELERATORS ACCELERATORS +BEGIN + "3", ID_PE_ID3, VIRTKEY, ALT, NOINVERT + "A", ID_MEDIAWND_SELECTALL, VIRTKEY, CONTROL, NOINVERT + "E", ID_EDITITEMINFOS, VIRTKEY, CONTROL, NOINVERT + "F", ID_MEDIAWND_EXPLOREFOLDER, VIRTKEY, CONTROL, NOINVERT + "R", IDC_REFRESH_METADATA, VIRTKEY, CONTROL, NOINVERT + VK_DELETE, ID_MEDIAWND_REMOVEFROMLIBRARY, VIRTKEY, NOINVERT + VK_RETURN, ID_AUDIOWND_PLAYSELECTION, VIRTKEY, NOINVERT + VK_RETURN, ID_MEDIAWND_PLAYSELECTEDFILES, VIRTKEY, NOINVERT + VK_RETURN, IDC_BUTTON_PLAY, VIRTKEY, NOINVERT + VK_RETURN, ID_AUDIOWND_ENQUEUESELECTION, VIRTKEY, SHIFT, NOINVERT + VK_RETURN, ID_MEDIAWND_ENQUEUESELECTEDFILES, VIRTKEY, SHIFT, NOINVERT + VK_RETURN, IDC_BUTTON_ENQUEUE, VIRTKEY, SHIFT, NOINVERT + VK_RETURN, IDC_BUTTON_MIX, VIRTKEY, SHIFT, CONTROL, NOINVERT +END + +IDR_QUERY_ACCELERATORS ACCELERATORS +BEGIN + VK_INSERT, ID_QUERYMENU_ADDNEWQUERY, VIRTKEY, NOINVERT + VK_DELETE, ID_QUERYWND_DELETE, VIRTKEY, NOINVERT + VK_F2, ID_QUERYWND_EDIT, VIRTKEY, NOINVERT + VK_RETURN, ID_QUERYWND_ENQUEUEQUERY, VIRTKEY, SHIFT, NOINVERT + VK_RETURN, ID_QUERYWND_PLAYQUERY, VIRTKEY, NOINVERT +END + + +///////////////////////////////////////////////////////////////////////////// +// +// PNG +// + +IDR_IMAGE_NOTFOUND PNG "resources\\notfound.png" + +///////////////////////////////////////////////////////////////////////////// +// +// String Table +// + +STRINGTABLE +BEGIN + IDS_NULLSOFT_LOCAL_MEDIA "Nullsoft Library v%s" + 65535 "{06A3F81D-043D-4b5c-B341-590ED7053492}" +END + +STRINGTABLE +BEGIN + IDS_LOCAL_MEDIA "Local Library" + IDS_SEARCHING_X_FILES_FOUND "Searching... (%i files found)" + IDS_GETTING_INFO_FROM_FILES_PERCENT + "Getting information from files... (%i%% done)" + IDS_SCANNING_DIR "Scanning dir: " + IDS_SCANNING_FILE "Scanning file: " + IDS_CHECKING_FOR_FILE "Checking for file: " + IDS_COMPACTING "Compacting" + IDS_REMOVING_FILES_NOT_EXISTING "Removing files that do not exist..." + IDS_INITIALIZING "Initializing..." + IDS_SCANNING_X_OF_X_X_REMOVED "Scanning %d of %d files (%d removed)" + IDS_SCANNED_X_FILES_X_REMOVED + "Scanned %d files (%d removed) - Cleaning up..." +END + +STRINGTABLE +BEGIN + IDS_DATE_TIME_IS_TOO_COMPLEX + "This date/time is too complex for the editor to handle, drop the unsupported keywords?" + IDS_DATE_TIME_EDITOR_QUESTION "Date/Time Editor Question" + IDS_COMPARE_TO_STRING "Compare to string" + IDS_AFTER "After" + IDS_BEFORE "Before" + IDS_SINCE "Since" + IDS_UNTIL "Until" + IDS_COMPARE_TO_LENGTH "Compare to length (HH:MM:SS)" + IDS_ABOVE "Above" + IDS_BELOW "Below" + IDS_ABOVE_OR_EQUAL "Above or Equal" + IDS_BELOW_OR_EQUAL "Below or Equal" + IDS_COMPARE_TO_NUMBER "Compare to number" + IDS_OFFSET_BY "Offset by" + IDS_TIME_AGO "Time ago" +END + +STRINGTABLE +BEGIN + IDS_SPACE_AFTER " after" + IDS_SPACE_BEFORE " before" + IDS_THE "the " + IDS_1ST "st" + IDS_2ND "nd" + IDS_3RD "rd" + IDS_4TH "th" + IDS_OF_THIS_MONTH " of this month" + IDS_NOW "now" + IDS_THIS_DATE "this date" + IDS_THIS_MONTH "this month" + IDS_THIS_DAY "this day" + IDS_THIS_TIME "this time" + IDS_ON_SPACE "on " + IDS_IN_SPACE "in " + IDS_OF_SPACE "of " +END + +STRINGTABLE +BEGIN + IDS_AT_SPACE "at " + IDS_NOON "noon" + IDS_MIDNIGHT "midnight" + IDS_AGO " ago" + IDS_QUERY_FIELD_IS_EMPTY + "The query field is empty, use expression field instead of resetting the query?" + IDS_EMPTY_QUERY "Empty query" + IDS_NO_CHANGES_MADE_TO_QUERY + "You have not made any modification to the query, use the expression field instead of the old query?" + IDS_QUERY_NOT_CHANGED "Query not changed" + IDS_REGISTERED "Registered:%s" + IDS_ADD_PLEDIT_TO_LOCAL_MEDIA "Add current &playlist to Library" + IDS_ERROR "Error" + IDS_ADD_TO_LOCAL_MEDIA "Add to Library" + IDS_AUDIO "Audio" + IDS_VIDEO "Video" + IDS_MOST_PLAYED "Most Played" + IDS_RECENTLY_ADDED "Recently Added" +END + +STRINGTABLE +BEGIN + IDS_RECENTLY_PLAYED "Recently Played" + IDS_NEVER_PLAYED "Never Played" + IDS_TOP_RATED "Top Rated" + IDS_REMOVE_ALL_ITEMS_IN_LIBRARY + "Are you sure you want to remove ALL the items in your Library?" + IDS_CONFIRMATION "Confirmation" + IDS_NEW_SMART_VIEW "New Smart &View...\tInsert" + IDS_RESCAN_WATCH_FOLDERS + "&Rescan Watch Folders (in background)\tCtrl+Insert" + IDS_ADD_MEDIA_TO_LIBRARY "&Add media to Library..." + IDS_REMOVE_MISSING_FILES_FROM_ML "Remove missing files from Library..." + IDS_ANY "Any" + IDS_ALL "All" + IDS_OPTIONS "Options" + IDS_DIRECTORY "Directory" + IDS_STOP_SCAN "Stop scan" + IDS_RESCAN_NOW "Rescan now" + IDS_DEFAULT "Default" +END + +STRINGTABLE +BEGIN + IDS_RESCAN_ABORTED "Rescan aborted" + IDS_WATCH_FOLDERS "Watch Folders" + IDS_EDIT_VIEW "Edit View" + IDS_MY_NEW_VIEW "My New View" + IDS_SIMPLE_VIEW_EDITOR "Simple View Editor" + IDS_ADVANCED_EDITOR "Advanced Editor" + IDS_FILTERS "Filters" + IDS_MUST_ENTER_A_NAME "You must enter a name!" + IDS_DAY "day" + IDS_VIEW_QUERY_MAY_HAVE_ERRORS "This view query may have errors." + IDS_VIEW_QUERY_IS_TOO_COMPLEX "This view query is too complex." + IDS_TEXT_AFTER_THE_FIRST_ERROR "text after the first error" + IDS_SOME_OF_THE_QUERY_LOGIC "some of the query logic" + IDS_VIEW_EDITOR_QUESTION "View Editor Question" + IDS_DELETE_THIS_VIEW "Delete this view?" + IDS_REFINE "Refine:" +END + +STRINGTABLE +BEGIN + IDS_CLEAR_REFINE "Clear refine" + IDS_ARTIST "Artist" + IDS_TITLE "Title" + IDS_ALBUM "Album" + IDS_LENGTH "Length" + IDS_TRACK_NUMBER "Track #" + IDS_GENRE "Genre" + IDS_YEAR "Year" + IDS_FILENAME "Filename" + IDS_RATING "Rating" + IDS_PLAY_COUNT "Play Count" + IDS_PLAYED_LAST "Played Last" + IDS_LAST_UPDATED "Last Updated" + IDS_FILE_TIME "File Time" + IDS_COMMENT "Comment" + IDS_FILE_SIZE "File Size" +END + +STRINGTABLE +BEGIN + IDS_BITRATE "Bitrate" + IDS_TYPE "Type" + IDS_DISC "Disc" + IDS_ALBUM_ARTIST "Album Artist" + IDS_FILE_PATH "File Path" + IDS_ALBUM_GAIN "Album Gain" + IDS_TRACK_GAIN "Track Gain" + IDS_PUBLISHER "Publisher" + IDS_COMPOSER "Composer" + IDS_EXTENSION "Extension" + IDS_IS_PODCAST "Is Podcast" + IDS_PODCAST_CHANNEL "Podcast Channel" + IDS_PODCAST_PUBLISH_DATE "Podcast Publish Date" + IDS_SCANNING "Scanning..." + IDS_ERROR_DELETING_FILES "Error deleting files" + IDS_ERROR_DELETING_X "Error deleting %s" +END + +STRINGTABLE +BEGIN + IDS_SURE_YOU_WANT_TO_REMOVE_SELECTED_FROM_LIBRARY + "Are you sure you want to remove the selected item(s) from the library?" + IDS_HIDE_INFO "Hide Info" + IDS_SHOW_INFO "Show Info" + IDS_THERE_ARE_NOW_X_ITEMS_IN_THE_LIBRARY + "There are now %d items in the library. Click 'Add More' to add more directories, or click Close to continue." + IDS_ADD_MORE "Add More..." + IDS_PLAY_ALL_FILES_BY "Play all files by %s" + IDS_PLAY_ALL_FILES_FROM "Play all files from %s" + IDS_PODCAST "Podcast" + IDS_NON_PODCAST "Non-Podcast" + IDS_MIXABLE "Mixable" + IDS_X_ITEM "%d item%s" + IDS_ALBUM_ART "Album Art" + IDS_LOOKING_UP_MEDIA_INFO "...looking up media info..." + IDS_CLICK_AN_ITEM_TO_GET_ITS_INFO "click an item to get its info" + IDS_PLEASE_CONNECT_TO_THE_INTERNET_TO_USE_THIS_FEATURE + "please connect to the internet to use this feature" +END + +STRINGTABLE +BEGIN + IDS_ALL_X_ALBUMS_X_WITHOUT_ALBUM "All (%d %s, %d without album)" + IDS_ALL_X_ALBUMS "All (%d %s)" + IDS_NO_ALBUM "(no album)" + IDS_OPEN_MEDIA_LIBRARY_VIEW_RESULTS "Open Library &view results" + IDS_MEDIA_LIBRARY_VIEW_RESULTS "Library &view results" + IDS_ADD_MEDIA_TO_LIBRARY_ "Add media to Library" + IDS_SELECT_FOLDER_TO_ADD_TO_WINAMP_MEDIA_LIBRARY + "Select folder to add to the Winamp Library." + IDS_ADD "Add" + IDS_SCAN_FOLDER_IN_BACKGROUND "Scan folder in background" + IDS_FOLDER_NAME_IS_INCORRECT + "Folder Name '%s' is incorrect. Please enter correct folder name or select 'Cancel'." + IDS_INCORRECT_FOLDER_NAME "Incorrect Folder Name" + IDS_WILLS_UBER_STRING "Welcome to the new Smart View creation dialog. It's totally super duper and overhauled to the limit, pretty much.\n\nTo get started, just choose a preset. If you know what you're doing choose the ""Custom"" preset. Even though it isn't really a ""preset"" per se, this is what we decided on! :)\n\nWhen the form appears (filled in with your preset info), tweak it to your liking and once you're done give your smart view a name. Choose to hide the extra info pane if you'd like and hit ""OK"" and you're all set!" + IDS_EDIT_SMART_VIEW "Edit Smart View" + IDS_ADVANCED_MODE "Advanced mode >>" + IDS_SIMPLE_MODE "<< Simple mode" + IDS_DAYS "days" +END + +STRINGTABLE +BEGIN + IDS_LENGTH_DURATION_STRING "[%s%u %s+%u:%02u:%02u]" + IDS_ITEM "item" + IDS_ITEMS "items" + IDS_SCANNING_PLAIN "Scanning" + IDS_ALL_ARTISTS "All Artists" + IDS_ARTIST_INDEX "Artist Index" + IDS_ALBUM_ARTIST_INDEX "Album Artist Index" + IDS_CUSTOM "Custom" + IDS_IS_VIDEO "Is video" + IDS_FILE_SIZE_KB "File size (KB)" + IDS_BITRATE_KBPS "Bitrate (KBPS)" + IDS_DISC_NUMBER "Disc #" + IDS_DISCS "Discs" + IDS_TRACKS "Tracks" + IDS_EQUALS "Equals" + IDS_DOES_NOT_EQUAL "Does not equal" +END + +STRINGTABLE +BEGIN + IDS_CONTAINS "Contains" + IDS_DOES_NOT_CONTAIN "Does not contain" + IDS_IS_ABOVE "Is above" + IDS_IS_BELOW "Is below" + IDS_EQUALS_OR_IS_ABOVE "Equals or is above" + IDS_EQUALS_OR_IS_BELOW "Equals or is below" + IDS_IS_EMPTY "Is empty" + IDS_IS_NOT_EMPTY "Is not empty" + IDS_BEGINS_WITH "Begins with" + IDS_ENDS_WITH "Ends with" + IDS_IS_SIMILAR_TO "Is similar to" + IDS_AT "At" + IDS_NOT_AT "Not at" + IDS_STRING189 "After" + IDS_PODCASTS "Podcasts" + IDS_AUDIO_BY_GENRE "Audio by Genre" +END + +STRINGTABLE +BEGIN + IDS_AUDIO_BY_INDEX "Audio by Index" + IDS_60s_MUSIC "'60s Music" + IDS_70s_MUSIC "'70s Music" + IDS_80s_MUSIC "'80s Music" + IDS_90s_MUSIC "'90s Music" + IDS_00s_MUSIC "'00s Music" + IDS_ROCK_MUSIC "Rock Music" + IDS_CLASSICAL_MUSIC "Classical Music" + IDS_RECORD_LABELS "Record Labels" + IDS_ALBUMS "Albums" + IDS_ALBUM_ARTISTS "Album Artists" + IDS_ARTIST_S "Artists" + IDS_COMPOSERS "Composers" + IDS_GENRES "Genres" + IDS_PUBLISHERS "Publishers" + IDS_YEARS "Years" +END + +STRINGTABLE +BEGIN + IDS_ALBUM_ARTIST_INDEXES "Album Artist Indexes" + IDS_ARTIST_INDEXES "Artist Indexes" + IDS_PODCAST_CHANNELS "Podcast Channels" + IDS_ALL_X_S "All (%d %s)" + IDS_NO_S "(no %s)" + IDS_SIZE "Size" + IDS_NO_IMAGE "No image" + IDS_AVAILABLE "available" + IDS_NO_ARTIST "No Artist" + IDS_NO_GENRE "No Genre" + IDS_OTHER2 "Other..." + IDS_SIMPLE_ALBUM "Simple Album" + IDS_AUDIO_BUTTON_TT1 "Toggle Album Art View" + IDS_AUDIO_BUTTON_TT2 "Select Filters & Panes" + IDS_AUDIO_BUTTON_TT3 "Pane Options" + IDS_GET_ALBUM_ART "Get Album Art" +END + +STRINGTABLE +BEGIN + IDS_REFRESH_ALBUM_ART "Refresh Album Art" + IDS_OPEN_FOLDER "Open Folder" + IDS_BPM "BPM" + IDS_META_STR "Meta" + IDS_SMART_STR "Smart" + IDS_GUESS_STR "Guess" + IDS_RECURSE_STR "Recurse" + IDS_MORE_ARTIST_INFO "Get Artist Information" + IDS_PLAY_RANDOM_ITEM "Play random %s" + IDS_ENQUEUE_RANDOM_ITEM "Enqueue random %s" + IDS_LOSSLESS "Lossless" + IDS_CATEGORY "Category" + IDS_CATEGORIES "Categories" +END + +STRINGTABLE +BEGIN + IDS_GENRE_ALT "genre" + IDS_YEAR_ALT "year" + IDS_ALBUM_ARTIST_ALT "album artist" + IDS_ALBUM_GAIN_ALT "album gain" + IDS_PUBLISHER_ALT "publisher" + IDS_COMPOSER_ALT "composer" + IDS_ARTIST_INDEX_ALT "artist index" + IDS_ALBUM_ARTIST_INDEX_ALT "album artist index" + IDS_PODCAST_CHANNEL_ALT "podcast channel" + IDS_CATEGORY_ALT "category" + IDS_ARTIST_ALT "artist" + IDS_ALBUM_ALT "album" + IDS_KBPS "kbps" + IDS_RECENTLY_PLAYED_TEXT + "When 'Recently Played' is enabled, Winamp will keep track of when\nand how many times items in the Library are played.\n\nNote: When the first match against any of the selected option(s)\nis met then the playing item will be tracked." + IDS_PRODUCER "Producer" +END + +STRINGTABLE +BEGIN + IDS_DIRECTOR "Director" + IDS_PRODUCER_ALT "producer" + IDS_DIRECTOR_ALT "director" + IDS_CODEC "Codec" + IDS_WIDTH "Width" + IDS_HEIGHT "Height" + IDS_DIMENSION "Dimension" + IDS_IN_X_SEC "in %.03f sec." + IDS_TRACKS_MENU "Tracks" + IDS_ERROR_PLG_SELECT_TRACKS + "Please select one or more tracks to use as a seed for the playlist generator." + IDS_NULLSOFT_PLAYLIST_GENERATOR "Nullsoft Playlist Generator" + IDS_VIEW_ALL_FILES_BY "All tracks by artist ""%s""" + IDS_VIEW_ALL_FILES_FROM "All tracks from album ""%s""" +END + +STRINGTABLE +BEGIN + IDS_DATE_ADDED "Date Added" + IDS_REFRESH_FILESIZE_DATEADDED + "Refreshing 'Filesize' & Populating 'Date Added'" + IDS_RECENTLY_MODIFIED "Recently Modified" + IDS_FINISHED "Finished" + IDS_REFRESH_MESSAGE "%u of %u files" + IDS_CLOUD "Cloud" + IDS_CLOUD_SOURCES "Cloud Sources:" + IDS_CLOUD_HIDDEN "Cloud (Hidden)" + IDS_TRACK_AVAILABLE "Track available in " + IDS_UPLOAD_TO_SOURCE "Upload track to source" + IDS_UPLOADING_TO_SOURCE "Uploading track to source" +END + +#endif // English (U.S.) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// +#include "version.rc2" + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/Src/Plugins/Library/ml_local/ml_local.sln b/Src/Plugins/Library/ml_local/ml_local.sln new file mode 100644 index 00000000..b7f892ca --- /dev/null +++ b/Src/Plugins/Library/ml_local/ml_local.sln @@ -0,0 +1,128 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.29509.3 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ml_local", "ml_local.vcxproj", "{D9BD1AC1-9ECB-4399-BC33-E5E8B2A86884}" + ProjectSection(ProjectDependencies) = postProject + {57C90706-B25D-4ACA-9B33-95CDB2427C27} = {57C90706-B25D-4ACA-9B33-95CDB2427C27} + {DABE6307-F8DD-416D-9DAC-673E2DECB73F} = {DABE6307-F8DD-416D-9DAC-673E2DECB73F} + {D0EC862E-DDDD-4F4F-934F-B75DC9062DC1} = {D0EC862E-DDDD-4F4F-934F-B75DC9062DC1} + {44AEBB50-1331-4F2E-8AEC-56C82DE16C11} = {44AEBB50-1331-4F2E-8AEC-56C82DE16C11} + {F1F5CD60-0D5B-4CEA-9EEB-2F87FF9AA915} = {F1F5CD60-0D5B-4CEA-9EEB-2F87FF9AA915} + {E105A0A2-7391-47C5-86AC-718003524C3D} = {E105A0A2-7391-47C5-86AC-718003524C3D} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tataki", "..\tataki\tataki.vcxproj", "{255B68B5-7EF8-45EF-A675-2D6B88147909}" + ProjectSection(ProjectDependencies) = postProject + {DABE6307-F8DD-416D-9DAC-673E2DECB73F} = {DABE6307-F8DD-416D-9DAC-673E2DECB73F} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "bfc", "..\Wasabi\bfc\bfc.vcxproj", "{D0EC862E-DDDD-4F4F-934F-B75DC9062DC1}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "nsutil", "..\nsutil\nsutil.vcxproj", "{DABE6307-F8DD-416D-9DAC-673E2DECB73F}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "nde", "..\nde\nde.vcxproj", "{4D25C321-7F8B-424E-9899-D80A364BAF1A}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "nx", "..\replicant\nx\nx.vcxproj", "{57C90706-B25D-4ACA-9B33-95CDB2427C27}" + ProjectSection(ProjectDependencies) = postProject + {44AEBB50-1331-4F2E-8AEC-56C82DE16C11} = {44AEBB50-1331-4F2E-8AEC-56C82DE16C11} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "nu", "..\replicant\nu\nu.vcxproj", "{F1F5CD60-0D5B-4CEA-9EEB-2F87FF9AA915}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "jnetlib", "..\replicant\jnetlib\jnetlib.vcxproj", "{E105A0A2-7391-47C5-86AC-718003524C3D}" + ProjectSection(ProjectDependencies) = postProject + {44AEBB50-1331-4F2E-8AEC-56C82DE16C11} = {44AEBB50-1331-4F2E-8AEC-56C82DE16C11} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "zlib", "..\replicant\zlib\zlib.vcxproj", "{44AEBB50-1331-4F2E-8AEC-56C82DE16C11}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {D9BD1AC1-9ECB-4399-BC33-E5E8B2A86884}.Debug|Win32.ActiveCfg = Debug|Win32 + {D9BD1AC1-9ECB-4399-BC33-E5E8B2A86884}.Debug|Win32.Build.0 = Debug|Win32 + {D9BD1AC1-9ECB-4399-BC33-E5E8B2A86884}.Debug|x64.ActiveCfg = Debug|x64 + {D9BD1AC1-9ECB-4399-BC33-E5E8B2A86884}.Debug|x64.Build.0 = Debug|x64 + {D9BD1AC1-9ECB-4399-BC33-E5E8B2A86884}.Release|Win32.ActiveCfg = Release|Win32 + {D9BD1AC1-9ECB-4399-BC33-E5E8B2A86884}.Release|Win32.Build.0 = Release|Win32 + {D9BD1AC1-9ECB-4399-BC33-E5E8B2A86884}.Release|x64.ActiveCfg = Release|x64 + {D9BD1AC1-9ECB-4399-BC33-E5E8B2A86884}.Release|x64.Build.0 = Release|x64 + {255B68B5-7EF8-45EF-A675-2D6B88147909}.Debug|Win32.ActiveCfg = Debug|Win32 + {255B68B5-7EF8-45EF-A675-2D6B88147909}.Debug|Win32.Build.0 = Debug|Win32 + {255B68B5-7EF8-45EF-A675-2D6B88147909}.Debug|x64.ActiveCfg = Debug|x64 + {255B68B5-7EF8-45EF-A675-2D6B88147909}.Debug|x64.Build.0 = Debug|x64 + {255B68B5-7EF8-45EF-A675-2D6B88147909}.Release|Win32.ActiveCfg = Release|Win32 + {255B68B5-7EF8-45EF-A675-2D6B88147909}.Release|Win32.Build.0 = Release|Win32 + {255B68B5-7EF8-45EF-A675-2D6B88147909}.Release|x64.ActiveCfg = Release|x64 + {255B68B5-7EF8-45EF-A675-2D6B88147909}.Release|x64.Build.0 = Release|x64 + {D0EC862E-DDDD-4F4F-934F-B75DC9062DC1}.Debug|Win32.ActiveCfg = Debug|Win32 + {D0EC862E-DDDD-4F4F-934F-B75DC9062DC1}.Debug|Win32.Build.0 = Debug|Win32 + {D0EC862E-DDDD-4F4F-934F-B75DC9062DC1}.Debug|x64.ActiveCfg = Debug|x64 + {D0EC862E-DDDD-4F4F-934F-B75DC9062DC1}.Debug|x64.Build.0 = Debug|x64 + {D0EC862E-DDDD-4F4F-934F-B75DC9062DC1}.Release|Win32.ActiveCfg = Release|Win32 + {D0EC862E-DDDD-4F4F-934F-B75DC9062DC1}.Release|Win32.Build.0 = Release|Win32 + {D0EC862E-DDDD-4F4F-934F-B75DC9062DC1}.Release|x64.ActiveCfg = Release|x64 + {D0EC862E-DDDD-4F4F-934F-B75DC9062DC1}.Release|x64.Build.0 = Release|x64 + {DABE6307-F8DD-416D-9DAC-673E2DECB73F}.Debug|Win32.ActiveCfg = Debug|Win32 + {DABE6307-F8DD-416D-9DAC-673E2DECB73F}.Debug|Win32.Build.0 = Debug|Win32 + {DABE6307-F8DD-416D-9DAC-673E2DECB73F}.Debug|x64.ActiveCfg = Debug|x64 + {DABE6307-F8DD-416D-9DAC-673E2DECB73F}.Debug|x64.Build.0 = Debug|x64 + {DABE6307-F8DD-416D-9DAC-673E2DECB73F}.Release|Win32.ActiveCfg = Release|Win32 + {DABE6307-F8DD-416D-9DAC-673E2DECB73F}.Release|Win32.Build.0 = Release|Win32 + {DABE6307-F8DD-416D-9DAC-673E2DECB73F}.Release|x64.ActiveCfg = Release|x64 + {DABE6307-F8DD-416D-9DAC-673E2DECB73F}.Release|x64.Build.0 = Release|x64 + {4D25C321-7F8B-424E-9899-D80A364BAF1A}.Debug|Win32.ActiveCfg = Debug|Win32 + {4D25C321-7F8B-424E-9899-D80A364BAF1A}.Debug|Win32.Build.0 = Debug|Win32 + {4D25C321-7F8B-424E-9899-D80A364BAF1A}.Debug|x64.ActiveCfg = Debug|x64 + {4D25C321-7F8B-424E-9899-D80A364BAF1A}.Debug|x64.Build.0 = Debug|x64 + {4D25C321-7F8B-424E-9899-D80A364BAF1A}.Release|Win32.ActiveCfg = Release|Win32 + {4D25C321-7F8B-424E-9899-D80A364BAF1A}.Release|Win32.Build.0 = Release|Win32 + {4D25C321-7F8B-424E-9899-D80A364BAF1A}.Release|x64.ActiveCfg = Release|x64 + {4D25C321-7F8B-424E-9899-D80A364BAF1A}.Release|x64.Build.0 = Release|x64 + {57C90706-B25D-4ACA-9B33-95CDB2427C27}.Debug|Win32.ActiveCfg = Debug|Win32 + {57C90706-B25D-4ACA-9B33-95CDB2427C27}.Debug|Win32.Build.0 = Debug|Win32 + {57C90706-B25D-4ACA-9B33-95CDB2427C27}.Debug|x64.ActiveCfg = Debug|x64 + {57C90706-B25D-4ACA-9B33-95CDB2427C27}.Debug|x64.Build.0 = Debug|x64 + {57C90706-B25D-4ACA-9B33-95CDB2427C27}.Release|Win32.ActiveCfg = Release|Win32 + {57C90706-B25D-4ACA-9B33-95CDB2427C27}.Release|Win32.Build.0 = Release|Win32 + {57C90706-B25D-4ACA-9B33-95CDB2427C27}.Release|x64.ActiveCfg = Release|x64 + {57C90706-B25D-4ACA-9B33-95CDB2427C27}.Release|x64.Build.0 = Release|x64 + {F1F5CD60-0D5B-4CEA-9EEB-2F87FF9AA915}.Debug|Win32.ActiveCfg = Debug|Win32 + {F1F5CD60-0D5B-4CEA-9EEB-2F87FF9AA915}.Debug|Win32.Build.0 = Debug|Win32 + {F1F5CD60-0D5B-4CEA-9EEB-2F87FF9AA915}.Debug|x64.ActiveCfg = Debug|x64 + {F1F5CD60-0D5B-4CEA-9EEB-2F87FF9AA915}.Debug|x64.Build.0 = Debug|x64 + {F1F5CD60-0D5B-4CEA-9EEB-2F87FF9AA915}.Release|Win32.ActiveCfg = Release|Win32 + {F1F5CD60-0D5B-4CEA-9EEB-2F87FF9AA915}.Release|Win32.Build.0 = Release|Win32 + {F1F5CD60-0D5B-4CEA-9EEB-2F87FF9AA915}.Release|x64.ActiveCfg = Release|x64 + {F1F5CD60-0D5B-4CEA-9EEB-2F87FF9AA915}.Release|x64.Build.0 = Release|x64 + {E105A0A2-7391-47C5-86AC-718003524C3D}.Debug|Win32.ActiveCfg = Debug|Win32 + {E105A0A2-7391-47C5-86AC-718003524C3D}.Debug|Win32.Build.0 = Debug|Win32 + {E105A0A2-7391-47C5-86AC-718003524C3D}.Debug|x64.ActiveCfg = Debug|x64 + {E105A0A2-7391-47C5-86AC-718003524C3D}.Debug|x64.Build.0 = Debug|x64 + {E105A0A2-7391-47C5-86AC-718003524C3D}.Release|Win32.ActiveCfg = Release|Win32 + {E105A0A2-7391-47C5-86AC-718003524C3D}.Release|Win32.Build.0 = Release|Win32 + {E105A0A2-7391-47C5-86AC-718003524C3D}.Release|x64.ActiveCfg = Release|x64 + {E105A0A2-7391-47C5-86AC-718003524C3D}.Release|x64.Build.0 = Release|x64 + {44AEBB50-1331-4F2E-8AEC-56C82DE16C11}.Debug|Win32.ActiveCfg = Debug|Win32 + {44AEBB50-1331-4F2E-8AEC-56C82DE16C11}.Debug|Win32.Build.0 = Debug|Win32 + {44AEBB50-1331-4F2E-8AEC-56C82DE16C11}.Debug|x64.ActiveCfg = Debug|x64 + {44AEBB50-1331-4F2E-8AEC-56C82DE16C11}.Debug|x64.Build.0 = Debug|x64 + {44AEBB50-1331-4F2E-8AEC-56C82DE16C11}.Release|Win32.ActiveCfg = Release|Win32 + {44AEBB50-1331-4F2E-8AEC-56C82DE16C11}.Release|Win32.Build.0 = Release|Win32 + {44AEBB50-1331-4F2E-8AEC-56C82DE16C11}.Release|x64.ActiveCfg = Release|x64 + {44AEBB50-1331-4F2E-8AEC-56C82DE16C11}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {C4E799C1-027B-487B-8E1A-31F2D26A1AFE} + EndGlobalSection +EndGlobal diff --git a/Src/Plugins/Library/ml_local/ml_local.vcxproj b/Src/Plugins/Library/ml_local/ml_local.vcxproj new file mode 100644 index 00000000..847d5b6d --- /dev/null +++ b/Src/Plugins/Library/ml_local/ml_local.vcxproj @@ -0,0 +1,416 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <ItemGroup Label="ProjectConfigurations"> + <ProjectConfiguration Include="Debug|Win32"> + <Configuration>Debug</Configuration> + <Platform>Win32</Platform> + </ProjectConfiguration> + <ProjectConfiguration Include="Debug|x64"> + <Configuration>Debug</Configuration> + <Platform>x64</Platform> + </ProjectConfiguration> + <ProjectConfiguration Include="Release|Win32"> + <Configuration>Release</Configuration> + <Platform>Win32</Platform> + </ProjectConfiguration> + <ProjectConfiguration Include="Release|x64"> + <Configuration>Release</Configuration> + <Platform>x64</Platform> + </ProjectConfiguration> + </ItemGroup> + <PropertyGroup Label="Globals"> + <ProjectGuid>{D9BD1AC1-9ECB-4399-BC33-E5E8B2A86884}</ProjectGuid> + <RootNamespace>ml_local</RootNamespace> + <WindowsTargetPlatformVersion>10.0.19041.0</WindowsTargetPlatformVersion> + </PropertyGroup> + <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" /> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration"> + <ConfigurationType>DynamicLibrary</ConfigurationType> + <PlatformToolset>v142</PlatformToolset> + <CharacterSet>Unicode</CharacterSet> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration"> + <ConfigurationType>DynamicLibrary</ConfigurationType> + <PlatformToolset>v142</PlatformToolset> + <CharacterSet>Unicode</CharacterSet> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration"> + <ConfigurationType>DynamicLibrary</ConfigurationType> + <PlatformToolset>v142</PlatformToolset> + <CharacterSet>Unicode</CharacterSet> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration"> + <ConfigurationType>DynamicLibrary</ConfigurationType> + <PlatformToolset>v142</PlatformToolset> + <CharacterSet>Unicode</CharacterSet> + </PropertyGroup> + <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" /> + <ImportGroup Label="ExtensionSettings"> + </ImportGroup> + <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets"> + <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> + </ImportGroup> + <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets"> + <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> + </ImportGroup> + <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets"> + <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> + </ImportGroup> + <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets"> + <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> + </ImportGroup> + <PropertyGroup Label="UserMacros" /> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> + <LinkIncremental>false</LinkIncremental> + <OutDir>$(PlatformShortName)_$(Configuration)\</OutDir> + <IntDir>$(PlatformShortName)_$(Configuration)\</IntDir> + <IncludePath>$(IncludePath)</IncludePath> + <LibraryPath>$(LibraryPath)</LibraryPath> + <EmbedManifest>true</EmbedManifest> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> + <LinkIncremental>false</LinkIncremental> + <OutDir>$(PlatformShortName)_$(Configuration)\</OutDir> + <IntDir>$(PlatformShortName)_$(Configuration)\</IntDir> + <EmbedManifest>true</EmbedManifest> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> + <LinkIncremental>false</LinkIncremental> + <OutDir>$(PlatformShortName)_$(Configuration)\</OutDir> + <IntDir>$(PlatformShortName)_$(Configuration)\</IntDir> + <IncludePath>$(IncludePath)</IncludePath> + <LibraryPath>$(LibraryPath)</LibraryPath> + <EmbedManifest>true</EmbedManifest> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> + <LinkIncremental>false</LinkIncremental> + <OutDir>$(PlatformShortName)_$(Configuration)\</OutDir> + <IntDir>$(PlatformShortName)_$(Configuration)\</IntDir> + <EmbedManifest>true</EmbedManifest> + </PropertyGroup> + <PropertyGroup Label="Vcpkg"> + <VcpkgEnableManifest>false</VcpkgEnableManifest> + </PropertyGroup> + <PropertyGroup Label="Vcpkg" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> + <VcpkgInstalledDir> + </VcpkgInstalledDir> + <VcpkgUseStatic>false</VcpkgUseStatic> + <VcpkgConfiguration>Debug</VcpkgConfiguration> + <VcpkgTriplet>x86-windows-static-md</VcpkgTriplet> + </PropertyGroup> + <PropertyGroup Label="Vcpkg" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> + <VcpkgInstalledDir> + </VcpkgInstalledDir> + <VcpkgUseStatic>false</VcpkgUseStatic> + <VcpkgTriplet>x86-windows-static-md</VcpkgTriplet> + </PropertyGroup> + <PropertyGroup Label="Vcpkg" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> + <VcpkgInstalledDir> + </VcpkgInstalledDir> + <VcpkgUseStatic>false</VcpkgUseStatic> + <VcpkgTriplet>x86-windows-static-md</VcpkgTriplet> + <VcpkgConfiguration>Debug</VcpkgConfiguration> + </PropertyGroup> + <PropertyGroup Label="Vcpkg" Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> + <VcpkgInstalledDir> + </VcpkgInstalledDir> + <VcpkgUseStatic>false</VcpkgUseStatic> + <VcpkgTriplet>x86-windows-static-md</VcpkgTriplet> + </PropertyGroup> + <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> + <ClCompile> + <Optimization>Disabled</Optimization> + <AdditionalIncludeDirectories>.;..\..\..\Wasabi;..;..\..\..\;..\..\..\replicant;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories> + <PreprocessorDefinitions>_WIN32_WINNT=0x0601;WINVER=0x0601;WIN32;_DEBUG;_WINDOWS;_USRDLL;ML_LOCAL_EXPORTS;_WIN32_IE=0x0A00;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions> + <MinimalRebuild>false</MinimalRebuild> + <MultiProcessorCompilation>true</MultiProcessorCompilation> + <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks> + <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary> + <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType> + <ForceConformanceInForLoopScope>true</ForceConformanceInForLoopScope> + <WarningLevel>Level3</WarningLevel> + <DebugInformationFormat>ProgramDatabase</DebugInformationFormat> + <DisableSpecificWarnings>4100;4201;4838;4996;%(DisableSpecificWarnings)</DisableSpecificWarnings> + <BufferSecurityCheck>true</BufferSecurityCheck> + <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName> + </ClCompile> + <Link> + <AdditionalDependencies>comctl32.lib;Rpcrt4.lib;shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies> + <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile> + <GenerateDebugInformation>true</GenerateDebugInformation> + <ProgramDatabaseFile>$(IntDir)$(TargetName).pdb</ProgramDatabaseFile> + <SubSystem>Windows</SubSystem> + <RandomizedBaseAddress>false</RandomizedBaseAddress> + <ImportLibrary>$(IntDir)$(TargetName).lib</ImportLibrary> + <TargetMachine>MachineX86</TargetMachine> + <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers> + <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> + <MapFileName>$(IntDir)$(TargetName).map</MapFileName> + </Link> + <PostBuildEvent> + <Command>xcopy /Y /D $(OutDir)$(TargetName)$(TargetExt) ..\..\..\..\Build\Winamp_$(PlatformShortName)_$(Configuration)\Plugins\ +xcopy /Y /D $(IntDir)$(TargetName).pdb ..\..\..\..\Build\Winamp_$(PlatformShortName)_$(Configuration)\Plugins\ </Command> + <Message>Post build event: 'xcopy /Y /D $(OutDir)$(TargetName)$(TargetExt) ..\..\..\..\Build\Winamp_$(PlatformShortName)_$(Configuration)\Plugins\'</Message> + </PostBuildEvent> + <ResourceCompile> + <PreprocessorDefinitions>_WIN32_WINNT=0x0601;WINVER=0x0601;_UNICODE;UNICODE;%(PreprocessorDefinitions)</PreprocessorDefinitions> + </ResourceCompile> + <Manifest> + <OutputManifestFile>$(IntDir)$(TargetName)$(TargetExt).intermediate.manifest</OutputManifestFile> + </Manifest> + </ItemDefinitionGroup> + <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> + <ClCompile> + <Optimization>Disabled</Optimization> + <AdditionalIncludeDirectories>.;..\..\..\Wasabi;..;..\..\..\;..\..\..\replicant;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories> + <PreprocessorDefinitions>_WIN32_WINNT=0x0601;WINVER=0x0601;WIN64;_DEBUG;_WINDOWS;_USRDLL;ML_LOCAL_EXPORTS;_WIN32_IE=0x0A00;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions> + <MinimalRebuild>false</MinimalRebuild> + <MultiProcessorCompilation>true</MultiProcessorCompilation> + <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks> + <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary> + <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType> + <ForceConformanceInForLoopScope>true</ForceConformanceInForLoopScope> + <WarningLevel>Level3</WarningLevel> + <DebugInformationFormat>ProgramDatabase</DebugInformationFormat> + <DisableSpecificWarnings>4100;4201;4244;4267;4302;4311;4312;4838;4996;%(DisableSpecificWarnings)</DisableSpecificWarnings> + <BufferSecurityCheck>true</BufferSecurityCheck> + <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName> + </ClCompile> + <Link> + <AdditionalDependencies>comctl32.lib;Rpcrt4.lib;shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies> + <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile> + <GenerateDebugInformation>true</GenerateDebugInformation> + <ProgramDatabaseFile>$(IntDir)$(TargetName).pdb</ProgramDatabaseFile> + <SubSystem>Windows</SubSystem> + <RandomizedBaseAddress>false</RandomizedBaseAddress> + <ImportLibrary>$(IntDir)$(TargetName).lib</ImportLibrary> + <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers> + <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> + <MapFileName>$(IntDir)$(TargetName).map</MapFileName> + </Link> + <PostBuildEvent> + <Command>xcopy /Y /D $(OutDir)$(TargetName)$(TargetExt) ..\..\..\..\Build\Winamp_$(PlatformShortName)_$(Configuration)\Plugins\ +xcopy /Y /D $(IntDir)$(TargetName).pdb ..\..\..\..\Build\Winamp_$(PlatformShortName)_$(Configuration)\Plugins\ </Command> + <Message>Post build event: 'xcopy /Y /D $(OutDir)$(TargetName)$(TargetExt) ..\..\..\..\Build\Winamp_$(PlatformShortName)_$(Configuration)\Plugins\'</Message> + </PostBuildEvent> + <ResourceCompile> + <PreprocessorDefinitions>_WIN32_WINNT=0x0601;WINVER=0x0601;_UNICODE;UNICODE;%(PreprocessorDefinitions)</PreprocessorDefinitions> + </ResourceCompile> + <Manifest> + <OutputManifestFile>$(IntDir)$(TargetName)$(TargetExt).intermediate.manifest</OutputManifestFile> + </Manifest> + </ItemDefinitionGroup> + <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> + <ClCompile> + <Optimization>MinSpace</Optimization> + <IntrinsicFunctions>true</IntrinsicFunctions> + <FavorSizeOrSpeed>Size</FavorSizeOrSpeed> + <AdditionalIncludeDirectories>.;..\..\..\Wasabi;..;..\..\..\;..\..\..\replicant;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories> + <PreprocessorDefinitions>_WIN32_WINNT=0x0601;WINVER=0x0601;WIN32;NDEBUG;_WINDOWS;_USRDLL;ML_LOCAL_EXPORTS;_WIN32_IE=0x0A00;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions> + <StringPooling>true</StringPooling> + <MultiProcessorCompilation>true</MultiProcessorCompilation> + <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary> + <BufferSecurityCheck>true</BufferSecurityCheck> + <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType> + <ForceConformanceInForLoopScope>true</ForceConformanceInForLoopScope> + <WarningLevel>Level3</WarningLevel> + <DebugInformationFormat>None</DebugInformationFormat> + <DisableSpecificWarnings>4100;4201;4838;4996;%(DisableSpecificWarnings)</DisableSpecificWarnings> + <ShowIncludes>false</ShowIncludes> + <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName> + </ClCompile> + <Link> + <AdditionalDependencies>comctl32.lib;Rpcrt4.lib;shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies> + <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile> + <GenerateDebugInformation>false</GenerateDebugInformation> + <ProgramDatabaseFile>$(IntDir)$(TargetName).pdb</ProgramDatabaseFile> + <MapFileName>$(IntDir)$(TargetName).map</MapFileName> + <SubSystem>Windows</SubSystem> + <OptimizeReferences>true</OptimizeReferences> + <EnableCOMDATFolding>true</EnableCOMDATFolding> + <RandomizedBaseAddress>false</RandomizedBaseAddress> + <ImportLibrary>$(IntDir)$(TargetName).lib</ImportLibrary> + <TargetMachine>MachineX86</TargetMachine> + <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> + <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers> + </Link> + <PostBuildEvent> + <Command>xcopy /Y /D $(OutDir)$(TargetName)$(TargetExt) ..\..\..\..\Build\Winamp_$(PlatformShortName)_$(Configuration)\Plugins\ </Command> + <Message>Post build event: 'xcopy /Y /D $(OutDir)$(TargetName)$(TargetExt) ..\..\..\..\Build\Winamp_$(PlatformShortName)_$(Configuration)\Plugins\'</Message> + </PostBuildEvent> + <ResourceCompile> + <PreprocessorDefinitions>_WIN32_WINNT=0x0601;WINVER=0x0601;_UNICODE;UNICODE;%(PreprocessorDefinitions)</PreprocessorDefinitions> + </ResourceCompile> + <Manifest> + <OutputManifestFile>$(IntDir)$(TargetName)$(TargetExt).intermediate.manifest</OutputManifestFile> + </Manifest> + </ItemDefinitionGroup> + <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> + <ClCompile> + <Optimization>MinSpace</Optimization> + <IntrinsicFunctions>true</IntrinsicFunctions> + <FavorSizeOrSpeed>Size</FavorSizeOrSpeed> + <AdditionalIncludeDirectories>.;..\..\..\Wasabi;..;..\..\..\;..\..\..\replicant;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories> + <PreprocessorDefinitions>_WIN32_WINNT=0x0601;WINVER=0x0601;WIN64;NDEBUG;_WINDOWS;_USRDLL;ML_LOCAL_EXPORTS;_WIN32_IE=0x0A00;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions> + <StringPooling>true</StringPooling> + <MultiProcessorCompilation>true</MultiProcessorCompilation> + <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary> + <BufferSecurityCheck>true</BufferSecurityCheck> + <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType> + <ForceConformanceInForLoopScope>true</ForceConformanceInForLoopScope> + <WarningLevel>Level3</WarningLevel> + <DebugInformationFormat>None</DebugInformationFormat> + <DisableSpecificWarnings>4100;4201;4244;4267;4302;4311;4312;4838;4996;%(DisableSpecificWarnings)</DisableSpecificWarnings> + <ShowIncludes>false</ShowIncludes> + <ProgramDataBaseFileName>$(IntDir)$(TargetName).pdb</ProgramDataBaseFileName> + </ClCompile> + <Link> + <AdditionalDependencies>comctl32.lib;Rpcrt4.lib;shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies> + <OutputFile>$(OutDir)$(TargetName)$(TargetExt)</OutputFile> + <GenerateDebugInformation>false</GenerateDebugInformation> + <ProgramDatabaseFile>$(IntDir)$(TargetName).pdb</ProgramDatabaseFile> + <MapFileName>$(IntDir)$(TargetName).map</MapFileName> + <SubSystem>Windows</SubSystem> + <OptimizeReferences>true</OptimizeReferences> + <EnableCOMDATFolding>true</EnableCOMDATFolding> + <RandomizedBaseAddress>false</RandomizedBaseAddress> + <ImportLibrary>$(IntDir)$(TargetName).lib</ImportLibrary> + <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories> + <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers> + </Link> + <PostBuildEvent> + <Command>xcopy /Y /D $(OutDir)$(TargetName)$(TargetExt) ..\..\..\..\Build\Winamp_$(PlatformShortName)_$(Configuration)\Plugins\ </Command> + <Message>Post build event: 'xcopy /Y /D $(OutDir)$(TargetName)$(TargetExt) ..\..\..\..\Build\Winamp_$(PlatformShortName)_$(Configuration)\Plugins\'</Message> + </PostBuildEvent> + <ResourceCompile> + <PreprocessorDefinitions>_WIN32_WINNT=0x0601;WINVER=0x0601;_UNICODE;UNICODE;%(PreprocessorDefinitions)</PreprocessorDefinitions> + </ResourceCompile> + <Manifest> + <OutputManifestFile>$(IntDir)$(TargetName)$(TargetExt).intermediate.manifest</OutputManifestFile> + </Manifest> + </ItemDefinitionGroup> + <ItemGroup> + <ProjectReference Include="..\..\..\nde\nde.vcxproj"> + <Project>{4d25c321-7f8b-424e-9899-d80a364baf1a}</Project> + <CopyLocalSatelliteAssemblies>true</CopyLocalSatelliteAssemblies> + <ReferenceOutputAssembly>true</ReferenceOutputAssembly> + </ProjectReference> + <ProjectReference Include="..\..\..\tataki\tataki.vcxproj"> + <Project>{255b68b5-7ef8-45ef-a675-2d6b88147909}</Project> + <CopyLocalSatelliteAssemblies>true</CopyLocalSatelliteAssemblies> + <ReferenceOutputAssembly>true</ReferenceOutputAssembly> + </ProjectReference> + <ProjectReference Include="..\..\..\Wasabi\Wasabi.vcxproj"> + <Project>{3e0bfa8a-b86a-42e9-a33f-ec294f823f7f}</Project> + </ProjectReference> + </ItemGroup> + <ItemGroup> + <ClCompile Include="..\..\General\gen_ml\config.cpp" /> + <ClCompile Include="..\..\General\gen_ml\gaystring.cpp" /> + <ClCompile Include="..\..\General\gen_ml\menu.cpp" /> + <ClCompile Include="..\..\..\nu\ChildSizer.cpp" /> + <ClCompile Include="..\..\..\nu\DialogSkinner.cpp" /> + <ClCompile Include="..\..\..\nu\listview.cpp" /> + <ClCompile Include="..\..\..\nu\MediaLibraryInterface.cpp" /> + <ClCompile Include="..\..\..\nu\menushortcuts.cpp" /> + <ClCompile Include="..\..\..\nu\ServiceWatcher.cpp" /> + <ClCompile Include="..\..\..\nu\sort.cpp" /> + <ClCompile Include="..\..\..\Winamp\strutil.cpp" /> + <ClCompile Include="add.cpp" /> + <ClCompile Include="AlbumArtCache.cpp" /> + <ClCompile Include="AlbumArtContainer.cpp" /> + <ClCompile Include="AlbumArtFilter.cpp" /> + <ClCompile Include="AlbumFilter.cpp" /> + <ClCompile Include="api_mldb.cpp" /> + <ClCompile Include="bgscan.cpp" /> + <ClCompile Include="DBitemrecord.cpp" /> + <ClCompile Include="editinfo.cpp" /> + <ClCompile Include="editquery.cpp" /> + <ClCompile Include="FolderBrowseEx.cpp" /> + <ClCompile Include="guess.cpp" /> + <ClCompile Include="handleMessage.cpp" /> + <ClCompile Include="LocalMediaCOM.cpp" /> + <ClCompile Include="local_menu.cpp" /> + <ClCompile Include="Main.cpp" /> + <ClCompile Include="MD5.cpp" /> + <ClCompile Include="mldbApi.cpp" /> + <ClCompile Include="mldbApiFactory.cpp" /> + <ClCompile Include="ml_local.cpp" /> + <ClCompile Include="ml_subclass.cpp" /> + <ClCompile Include="nde_itemRecord.cpp" /> + <ClCompile Include="pe_subclass.cpp" /> + <ClCompile Include="prefs.cpp" /> + <ClCompile Include="queries.cpp" /> + <ClCompile Include="ReIndexUI.cpp" /> + <ClCompile Include="remove.cpp" /> + <ClCompile Include="SaveQuery.cpp" /> + <ClCompile Include="ScanFolderBrowser.cpp" /> + <ClCompile Include="SimpleFilter.cpp" /> + <ClCompile Include="TitleInfo.cpp" /> + <ClCompile Include="util.cpp" /> + <ClCompile Include="ViewFilter.cpp" /> + <ClCompile Include="view_audio.cpp" /> + <ClCompile Include="view_errorinfo.cpp" /> + <ClCompile Include="view_media.cpp" /> + <ClCompile Include="view_miniinfo.cpp" /> + <ClCompile Include="wa_subclass.cpp" /> + </ItemGroup> + <ItemGroup> + <ClInclude Include="..\..\General\gen_ml\config.h" /> + <ClInclude Include="..\..\General\gen_ml\gaystring.h" /> + <ClInclude Include="..\..\General\gen_ml\menu.h" /> + <ClInclude Include="..\ml_cloud\CloudCallback.h" /> + <ClInclude Include="..\..\..\replicant\nu\menushortcuts.h" /> + <ClInclude Include="..\..\..\Winamp\strutil.h" /> + <ClInclude Include="AlbumArtCache.h" /> + <ClInclude Include="AlbumArtContainer.h" /> + <ClInclude Include="AlbumArtFilter.h" /> + <ClInclude Include="AlbumFilter.h" /> + <ClInclude Include="api__ml_local.h" /> + <ClInclude Include="api_mldb.h" /> + <ClInclude Include="editquery.h" /> + <ClInclude Include="FolderBrowseEx.h" /> + <ClInclude Include="LocalMediaCOM.h" /> + <ClInclude Include="local_menu.h" /> + <ClInclude Include="Main.h" /> + <ClInclude Include="MD5.h" /> + <ClInclude Include="mldbApi.h" /> + <ClInclude Include="mldbApiFactory.h" /> + <ClInclude Include="MLString.h" /> + <ClInclude Include="ml_local.h" /> + <ClInclude Include="resource.h" /> + <ClInclude Include="ScanFolderBrowser.h" /> + <ClInclude Include="SimpleFilter.h" /> + <ClInclude Include="ViewFilter.h" /> + </ItemGroup> + <ItemGroup> + <Text Include="db_error.txt" /> + <Text Include="nde_error.txt" /> + <Text Include="queries.txt" /> + </ItemGroup> + <ItemGroup> + <Image Include="resources\icn_alb_art.bmp" /> + <Image Include="resources\icn_columns.bmp" /> + <Image Include="resources\icn_view_mode.bmp" /> + <Image Include="resources\nf_simple.bmp" /> + <Image Include="resources\nf_simplealbum.bmp" /> + <Image Include="resources\nf_threefilters.bmp" /> + <Image Include="resources\nf_twofilters.bmp" /> + <Image Include="resources\notfound.png" /> + <Image Include="resources\ti_audio_16x16x16.bmp" /> + <Image Include="resources\ti_most_played_16x16x16.bmp" /> + <Image Include="resources\ti_never_played_16x16x16.bmp" /> + <Image Include="resources\ti_podcasts_16x16x16.bmp" /> + <Image Include="resources\ti_recently_added_16x16x16.bmp" /> + <Image Include="resources\ti_recently_modified_16x16x16.bmp" /> + <Image Include="resources\ti_recently_played_16x16x16.bmp" /> + <Image Include="resources\ti_top_rated_16x16x16.bmp" /> + <Image Include="resources\ti_video_16x16x16.bmp" /> + </ItemGroup> + <ItemGroup> + <ResourceCompile Include="ml_local.rc" /> + </ItemGroup> + <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" /> + <ImportGroup Label="ExtensionTargets"> + </ImportGroup> +</Project>
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/ml_local.vcxproj.filters b/Src/Plugins/Library/ml_local/ml_local.vcxproj.filters new file mode 100644 index 00000000..d5a1349e --- /dev/null +++ b/Src/Plugins/Library/ml_local/ml_local.vcxproj.filters @@ -0,0 +1,328 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <ItemGroup> + <ClCompile Include="add.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="AlbumArtCache.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="AlbumArtContainer.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="AlbumArtFilter.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="AlbumFilter.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="api_mldb.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="bgscan.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="DBitemrecord.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="editinfo.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="editquery.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="FolderBrowseEx.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="guess.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="handleMessage.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="local_menu.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="LocalMediaCOM.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="Main.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="MD5.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="ml_local.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="ml_subclass.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="mldbApi.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="mldbApiFactory.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="nde_itemRecord.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="pe_subclass.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="prefs.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="queries.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="ReIndexUI.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="remove.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="SaveQuery.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="ScanFolderBrowser.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="SimpleFilter.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="wa_subclass.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="ViewFilter.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="view_miniinfo.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="view_media.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="view_errorinfo.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="view_audio.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="util.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="TitleInfo.cpp"> + <Filter>Source Files</Filter> + </ClCompile> + <ClCompile Include="..\..\..\nu\ChildSizer.cpp"> + <Filter>Source Files\nu</Filter> + </ClCompile> + <ClCompile Include="..\..\General\gen_ml\config.cpp"> + <Filter>Source Files\gen_ml</Filter> + </ClCompile> + <ClCompile Include="..\..\..\nu\DialogSkinner.cpp"> + <Filter>Source Files\nu</Filter> + </ClCompile> + <ClCompile Include="..\..\General\gen_ml\gaystring.cpp"> + <Filter>Source Files\gen_ml</Filter> + </ClCompile> + <ClCompile Include="..\..\..\nu\listview.cpp"> + <Filter>Source Files\nu</Filter> + </ClCompile> + <ClCompile Include="..\..\..\nu\MediaLibraryInterface.cpp"> + <Filter>Source Files\nu</Filter> + </ClCompile> + <ClCompile Include="..\..\General\gen_ml\menu.cpp"> + <Filter>Source Files\gen_ml</Filter> + </ClCompile> + <ClCompile Include="..\..\..\nu\menushortcuts.cpp"> + <Filter>Source Files\nu</Filter> + </ClCompile> + <ClCompile Include="..\..\..\nu\ServiceWatcher.cpp"> + <Filter>Source Files\nu</Filter> + </ClCompile> + <ClCompile Include="..\..\..\nu\sort.cpp"> + <Filter>Source Files\nu</Filter> + </ClCompile> + <ClCompile Include="..\..\..\Winamp\strutil.cpp"> + <Filter>Source Files\Winamp</Filter> + </ClCompile> + </ItemGroup> + <ItemGroup> + <ClInclude Include="AlbumArtCache.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="AlbumArtContainer.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="AlbumArtFilter.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="AlbumFilter.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="api__ml_local.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="api_mldb.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="editquery.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="FolderBrowseEx.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="local_menu.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="LocalMediaCOM.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="Main.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="MD5.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="ml_local.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="mldbApi.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="mldbApiFactory.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="MLString.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="ViewFilter.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="SimpleFilter.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="ScanFolderBrowser.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="resource.h"> + <Filter>Header Files</Filter> + </ClInclude> + <ClInclude Include="..\ml_cloud\CloudCallback.h"> + <Filter>Header Files\ml_cloud</Filter> + </ClInclude> + <ClInclude Include="..\..\General\gen_ml\config.h"> + <Filter>Header Files\gen_ml</Filter> + </ClInclude> + <ClInclude Include="..\..\General\gen_ml\gaystring.h"> + <Filter>Header Files\gen_ml</Filter> + </ClInclude> + <ClInclude Include="..\..\General\gen_ml\menu.h"> + <Filter>Header Files\gen_ml</Filter> + </ClInclude> + <ClInclude Include="..\..\..\Winamp\strutil.h"> + <Filter>Header Files\Winamp</Filter> + </ClInclude> + <ClInclude Include="..\..\..\replicant\nu\menushortcuts.h" /> + </ItemGroup> + <ItemGroup> + <Image Include="resources\icn_view_mode.bmp"> + <Filter>Image Files</Filter> + </Image> + <Image Include="resources\icn_columns.bmp"> + <Filter>Image Files</Filter> + </Image> + <Image Include="resources\icn_alb_art.bmp"> + <Filter>Image Files</Filter> + </Image> + <Image Include="resources\nf_simple.bmp"> + <Filter>Image Files</Filter> + </Image> + <Image Include="resources\nf_simplealbum.bmp"> + <Filter>Image Files</Filter> + </Image> + <Image Include="resources\nf_threefilters.bmp"> + <Filter>Image Files</Filter> + </Image> + <Image Include="resources\nf_twofilters.bmp"> + <Filter>Image Files</Filter> + </Image> + <Image Include="resources\notfound.png"> + <Filter>Image Files</Filter> + </Image> + <Image Include="resources\ti_audio_16x16x16.bmp"> + <Filter>Image Files</Filter> + </Image> + <Image Include="resources\ti_most_played_16x16x16.bmp"> + <Filter>Image Files</Filter> + </Image> + <Image Include="resources\ti_never_played_16x16x16.bmp"> + <Filter>Image Files</Filter> + </Image> + <Image Include="resources\ti_podcasts_16x16x16.bmp"> + <Filter>Image Files</Filter> + </Image> + <Image Include="resources\ti_recently_added_16x16x16.bmp"> + <Filter>Image Files</Filter> + </Image> + <Image Include="resources\ti_recently_modified_16x16x16.bmp"> + <Filter>Image Files</Filter> + </Image> + <Image Include="resources\ti_recently_played_16x16x16.bmp"> + <Filter>Image Files</Filter> + </Image> + <Image Include="resources\ti_top_rated_16x16x16.bmp"> + <Filter>Image Files</Filter> + </Image> + <Image Include="resources\ti_video_16x16x16.bmp"> + <Filter>Image Files</Filter> + </Image> + </ItemGroup> + <ItemGroup> + <Text Include="db_error.txt" /> + <Text Include="nde_error.txt" /> + <Text Include="queries.txt" /> + </ItemGroup> + <ItemGroup> + <Filter Include="Header Files"> + <UniqueIdentifier>{f6d09751-2ba8-4112-b488-dc1f0ea05c94}</UniqueIdentifier> + </Filter> + <Filter Include="Ressource Files"> + <UniqueIdentifier>{3c287e55-bc08-4d03-824d-ee4d32647054}</UniqueIdentifier> + </Filter> + <Filter Include="Source Files"> + <UniqueIdentifier>{13873f78-eb7e-495e-beaa-a25de0940e15}</UniqueIdentifier> + </Filter> + <Filter Include="Image Files"> + <UniqueIdentifier>{35f126e7-3751-48fb-b7e5-f4aad512a831}</UniqueIdentifier> + </Filter> + <Filter Include="Source Files\nu"> + <UniqueIdentifier>{d65e9d81-15db-4230-8fa3-a293d35217b3}</UniqueIdentifier> + </Filter> + <Filter Include="Source Files\gen_ml"> + <UniqueIdentifier>{21c5748c-8e27-4395-80cf-865cb7d06a76}</UniqueIdentifier> + </Filter> + <Filter Include="Source Files\Winamp"> + <UniqueIdentifier>{4dd5349f-8664-4615-8297-acc4d62c215f}</UniqueIdentifier> + </Filter> + <Filter Include="Header Files\ml_cloud"> + <UniqueIdentifier>{d3b5c0d1-2830-46e2-a1fe-d83606b83427}</UniqueIdentifier> + </Filter> + <Filter Include="Header Files\gen_ml"> + <UniqueIdentifier>{a811db7d-f845-4bb5-9437-1c7ac6b27f2e}</UniqueIdentifier> + </Filter> + <Filter Include="Header Files\nu"> + <UniqueIdentifier>{e9155744-9138-4cbe-84e6-413d3b07daa4}</UniqueIdentifier> + </Filter> + <Filter Include="Header Files\Winamp"> + <UniqueIdentifier>{aaff6d40-e86b-4dc0-aa3c-02a2046a8d6a}</UniqueIdentifier> + </Filter> + </ItemGroup> + <ItemGroup> + <ResourceCompile Include="ml_local.rc"> + <Filter>Ressource Files</Filter> + </ResourceCompile> + </ItemGroup> +</Project>
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/ml_subclass.cpp b/Src/Plugins/Library/ml_local/ml_subclass.cpp new file mode 100644 index 00000000..4020aeb1 --- /dev/null +++ b/Src/Plugins/Library/ml_local/ml_subclass.cpp @@ -0,0 +1,80 @@ +#include "main.h" +extern void AccessingGracenoteHack(int); +extern HWND subWnd; + +// TODO: benski> a lot of things don't need to be part of gen_ml window - they could easily be done with a hidden window +LRESULT APIENTRY ml_newWndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + switch (uMsg) + { + case WM_USER+641: + { + AccessingGracenoteHack(wParam); + break; + } + case WM_ML_IPC: + { + INT_PTR ret = HandleIpcMessage((INT_PTR)lParam, (INT_PTR)wParam); + if (ret != 0) + { + SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, ret); + return ret; // supposed to return TRUE but thus is not working for me :( + } + } + break; + case WM_COMMAND: + switch (LOWORD(wParam)) + { + case IDM_DOSHITMENU_ADDNEWVIEW: + addNewQuery(hwndDlg); + return 0; + case IDM_ADD_PLEDIT: + add_pledit_to_library(); + return 0; + case IDM_ADD_DIRS: + add_to_library(hwndDlg); + return 0; + case IDM_REMOVE_UNUSED_FILES: + Scan_RemoveFiles(hwndDlg); + if (m_curview_hwnd) SendMessage(m_curview_hwnd, WM_APP + 1, 0, 0); //update current view + return 0; + case IDM_RESCANFOLDERSNOW: + if (!g_bgscan_scanning) SendMessage(hwndDlg, WM_USER + 575, 0xffff00dd, 0); + return 0; + } + break; + case WM_USER + 575: //sent by prefs to start scanning + if (wParam == 0xffff00dd && !lParam) + { + if (!g_bgscan_scanning) + { + Scan_BackgroundScan(); + } + } + break; + case WM_TIMER: + { + static int in_timer; + if (in_timer) return 0; + in_timer = 1; + if (wParam == 200) // decide if it is time to scan yet + { + if (!g_bgscan_scanning) + { + if (g_bgrescan_force || (g_bgrescan_do && (time(NULL) - g_bgscan_last_rescan) > g_bgrescan_int*60)) + { + // send to the prefs page so it'll show the status if it's open + // (makes it easier to see if things are working with the rescan every x option) + if (IsWindow(subWnd)) SendMessage(subWnd, WM_USER+101, 0, 0); + Scan_BackgroundScan(); + } + } + in_timer = 0; + return 0; + } + in_timer = 0; + } + break; + } + return CallWindowProc(ml_oldWndProc, hwndDlg, uMsg, wParam, lParam); +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/mldbApi.cpp b/Src/Plugins/Library/ml_local/mldbApi.cpp new file mode 100644 index 00000000..661c8631 --- /dev/null +++ b/Src/Plugins/Library/ml_local/mldbApi.cpp @@ -0,0 +1,399 @@ +#include "mldbApi.h" +#include "main.h" +#include <strsafe.h> + +itemRecordW *MLDBAPI::GetFile(const wchar_t *filename) +{ + itemRecordW *result = 0; + if (filename) + { + openDb(); // just in case it's not opened yet (this function will return immediately if it's already open) + if (g_table) + { + EnterCriticalSection(&g_db_cs); + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + + if (s) + { + if (NDE_Scanner_LocateFilename(s, MAINTABLE_ID_FILENAME, FIRST_RECORD, filename)) + { + nde_field_t f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_FILENAME); + if (f) + { + result = (itemRecordW *)_aligned_malloc(sizeof(itemRecordW), 16); + if (result) + { + result->filename = NDE_StringField_GetString(f); + ndestring_retain(result->filename); + ScannerRefToObjCacheNFNW(s, result, true); + } + } + } + NDE_Table_DestroyScanner(g_table, s); + } + LeaveCriticalSection(&g_db_cs); + } + } + return result; +} + +itemRecordW *MLDBAPI::GetFileIf(const wchar_t *filename, const wchar_t *query) +{ + itemRecordW *result = 0; + if (filename) + { + openDb(); // just in case it's not opened yet (this function will return immediately if it's already open) + if (g_table) + { + EnterCriticalSection(&g_db_cs); + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + + if (s) + { + NDE_Scanner_Query(s, query); + if (NDE_Scanner_LocateFilename(s, MAINTABLE_ID_FILENAME, FIRST_RECORD, filename)) + { + nde_field_t f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_FILENAME); + if (f) + { + result = (itemRecordW *)_aligned_malloc(sizeof(itemRecordW), 16); + if (result) + { + result->filename = NDE_StringField_GetString(f); + ndestring_retain(result->filename); + ScannerRefToObjCacheNFNW(s, result, true); + } + } + } + NDE_Table_DestroyScanner(g_table, s); + } + LeaveCriticalSection(&g_db_cs); + } + } + return result; +} + +itemRecordListW *MLDBAPI::GetAlbum(const wchar_t *albumname, const wchar_t *albumartist) +{ + wchar_t query[4096] = {0}; // hope it's big enough + if (albumartist && albumname) + { + StringCchPrintfW(query, 4096, L"((albumartist isempty and artist=\"%s\") or albumartist=\"%s\") and album=\"%s\"", albumartist, albumartist, albumname); + return Query(query); + } + else if (albumname) + { + StringCchPrintfW(query, 4096, L"album=\"%s\"", albumname); + return Query(query); + } + return 0; +} + +itemRecordListW *MLDBAPI::Query(const wchar_t *query) +{ + itemRecordListW *result = 0; + + if (query) + { + openDb(); // just in case it's not opened yet (this function will return immediately if it's already open) + if (g_table) + { + EnterCriticalSection(&g_db_cs); + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + if (s) + { + NDE_Scanner_Query(s, query); + NDE_Scanner_First(s); + + do + { + nde_field_t f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_FILENAME); + if (!f) break; + + if (!result) + result = (itemRecordListW *)calloc(1, sizeof(itemRecordListW)); + + if (!result) + break; + + allocRecordList(result, result->Size + 1); + if (!result->Alloc) break; + + result->Items[result->Size].filename = NDE_StringField_GetString(f); + ndestring_retain(result->Items[result->Size].filename); + ScannerRefToObjCacheNFNW(s, result, true); + } + while (NDE_Scanner_Next(s)); + + NDE_Table_DestroyScanner(g_table, s); + } + LeaveCriticalSection(&g_db_cs); + } + } + return result; +} + +itemRecordListW *MLDBAPI::QueryLimit(const wchar_t *query, unsigned int limit) +{ + itemRecordListW *result = 0; + if (limit == 0) + return 0; + if (query) + { + openDb(); // just in case it's not opened yet (this function will return immediately if it's already open) + if (g_table) + { + EnterCriticalSection(&g_db_cs); + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + if (s) + { + NDE_Scanner_Query(s, query); + NDE_Scanner_First(s); + + do + { + nde_field_t f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_FILENAME); + if (!f) break; + + if (!result) + { + result = (itemRecordListW *)calloc(1, sizeof(itemRecordListW)); + if (!result) + break; + + allocRecordList(result, limit); + if (!result->Alloc) + break; + } + + result->Items[result->Size].filename = NDE_StringField_GetString(f); + ndestring_retain(result->Items[result->Size].filename); + ScannerRefToObjCacheNFNW(s, result, true); + } + while (result->Size < (int)limit && NDE_Scanner_Next(s)); + + NDE_Table_DestroyScanner(g_table, s); + } + LeaveCriticalSection(&g_db_cs); + } + } + return result; +} + +void MLDBAPI::FreeRecord(itemRecordW *record) +{ + freeRecord(record); +} + +void MLDBAPI::FreeRecordList(itemRecordListW *recordList) +{ + freeRecordList(recordList); +} + +bool FindFileInDB(nde_scanner_t s, const wchar_t *filename); +void MLDBAPI::SetField(const wchar_t *filename, const char *field, const wchar_t *value) +{ + openDb(); + if (g_table) + { + EnterCriticalSection(&g_db_cs); + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + if (s) + { + if (FindFileInDB(s, filename)) + { + if (value && value[0]) + { + NDE_Scanner_Edit(s); + nde_field_t f = NDE_Scanner_GetFieldByName(s, field); + if (!f) + f=NDE_Scanner_NewFieldByName(s, field); + + if (f) + NDE_StringField_SetString(f, value); + } + else + { + nde_field_t f = NDE_Scanner_GetFieldByName(s, field); + if (f) + NDE_Scanner_DeleteField(s, f); + } + NDE_Scanner_Post(s); + g_table_dirty++; + } + NDE_Table_DestroyScanner(g_table, s); + } + LeaveCriticalSection(&g_db_cs); + } +} + +void MLDBAPI::SetFieldInteger(const wchar_t *filename, const char *field, int value) +{ + openDb(); + if (g_table) + { + EnterCriticalSection(&g_db_cs); + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + if (s) + { + if (FindFileInDB(s, filename)) + { + NDE_Scanner_Edit(s); + nde_field_t f = NDE_Scanner_GetFieldByName(s, field); + if (!f) + f=NDE_Scanner_NewFieldByName(s, field); + + if (f) + NDE_IntegerField_SetValue(f, value); + + NDE_Scanner_Post(s); + g_table_dirty++; + } + NDE_Table_DestroyScanner(g_table, s); + } + LeaveCriticalSection(&g_db_cs); + } +} + +void MLDBAPI::SetFieldInt128(const wchar_t *filename, const char *field, uint8_t value[16]) +{ + openDb(); + if (g_table) + { + EnterCriticalSection(&g_db_cs); + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + if (s) + { + if (FindFileInDB(s, filename)) + { + if (value) + { + NDE_Scanner_Edit(s); + nde_field_t f = NDE_Scanner_GetFieldByName(s, field); + if (!f) + f=NDE_Scanner_NewFieldByName(s, field); + + if (f) + NDE_Int128Field_SetValue(f, value); + } + else + { + nde_field_t f = NDE_Scanner_GetFieldByName(s, field); + if (f) + NDE_Scanner_DeleteField(s, f); + } + NDE_Scanner_Post(s); + g_table_dirty++; + } + NDE_Table_DestroyScanner(g_table, s); + } + LeaveCriticalSection(&g_db_cs); + } +} + +void MLDBAPI::Sync() +{ + openDb(); + if (g_table) + { + EnterCriticalSection(&g_db_cs); + NDE_Table_Sync(g_table); + g_table_dirty=0; + LeaveCriticalSection(&g_db_cs); + } +} + +int MLDBAPI::AddFile(const wchar_t *filename) +{ + int guess = g_config->ReadInt(L"guessmode", 0); + int meta = g_config->ReadInt(L"usemetadata", 1); + return addFileToDb(filename, 0, meta, guess); +} + +int MLDBAPI::RemoveFile(const wchar_t *filename) +{ + return RemoveFileFromDB(filename); +} + +void MLDBAPI::RetainString(wchar_t *str) +{ + ndestring_retain(str); +} + +void MLDBAPI::ReleaseString(wchar_t *str) +{ + ndestring_release(str); +} + +wchar_t *MLDBAPI::DuplicateString(const wchar_t *str) +{ + return ndestring_wcsdup(str); +} + +int MLDBAPI::GetMaxInteger(const char *field, int *max) +{ + openDb(); + if (!g_table) + return 1; + + EnterCriticalSection(&g_db_cs); + nde_field_t f = NDE_Table_GetColumnByName(g_table, field); + if (!f) + { + LeaveCriticalSection(&g_db_cs); + return 1; + } + + unsigned char field_id = NDE_ColumnField_GetFieldID(f); + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + if (s) + { + int maximum_so_far=0; + NDE_Scanner_Query(s, L""); + NDE_Scanner_First(s); + do + { + nde_field_t f = NDE_Scanner_GetFieldByID(s, field_id); + if (f) + { + int this_value = NDE_IntegerField_GetValue(f); + if (this_value > maximum_so_far) + maximum_so_far = this_value; + } + + } while (NDE_Scanner_Next(s) && !NDE_Scanner_EOF(s)); + + NDE_Table_DestroyScanner(g_table, s); + *max=maximum_so_far; + LeaveCriticalSection(&g_db_cs); + return 0; + } + else + { + LeaveCriticalSection(&g_db_cs); + return 1; + } +} + +#define CBCLASS MLDBAPI +START_DISPATCH; +CB(API_MLDB_GETFILE, GetFile) +CB(API_MLDB_GETFILEIF, GetFileIf) +CB(API_MLDB_GETALBUM, GetAlbum) +CB(API_MLDB_QUERY, Query) +CB(API_MLDB_QUERYLIMIT, QueryLimit) +VCB(API_MLDB_FREERECORD, FreeRecord) +VCB(API_MLDB_FREERECORDLIST, FreeRecordList) +VCB(API_MLDB_SETFIELD, SetField) +VCB(API_MLDB_SETFIELDINT, SetFieldInteger) +VCB(API_MLDB_SETFIELDINT128, SetFieldInt128) +VCB(API_MLDB_SYNC, Sync) +CB(API_MLDB_ADDFILE, AddFile) +CB(API_MLDB_REMOVEFILE, RemoveFile) +VCB(API_MLDB_RETAINSTRING, RetainString) +VCB(API_MLDB_RELEASESTRING, ReleaseString) +CB(API_MLDB_DUPLICATESTRING, DuplicateString) +CB(API_MLDB_GETMAXINTEGER, GetMaxInteger) +END_DISPATCH; +#undef CBCLASS + diff --git a/Src/Plugins/Library/ml_local/mldbApi.h b/Src/Plugins/Library/ml_local/mldbApi.h new file mode 100644 index 00000000..3ee0e2f7 --- /dev/null +++ b/Src/Plugins/Library/ml_local/mldbApi.h @@ -0,0 +1,34 @@ +#pragma once + +#include "api_mldb.h" + +class MLDBAPI : public api_mldb +{ +public: + itemRecordW *GetFile(const wchar_t *filename); + itemRecordW *GetFileIf(const wchar_t *filename, const wchar_t *query); + itemRecordListW *GetAlbum(const wchar_t *albumname, const wchar_t *albumartist); + itemRecordListW *Query(const wchar_t *query); + itemRecordListW *QueryLimit(const wchar_t *query, unsigned int limit); + + void SetField(const wchar_t *filename, const char *field, const wchar_t *value); + void SetFieldInteger(const wchar_t *filename, const char *field, int value); + void SetFieldInt128(const wchar_t *filename, const char *field, uint8_t value[16]); + void Sync(); + + int AddFile(const wchar_t *filename); + + void FreeRecord(itemRecordW *record); + void FreeRecordList(itemRecordListW *recordList); + int RemoveFile(const wchar_t *filename); + + /* wrappers around ndestring */ + void RetainString(wchar_t *str); + void ReleaseString(wchar_t *str); + wchar_t *DuplicateString(const wchar_t *str); + + int GetMaxInteger(const char *field, int *max); +protected: + RECVS_DISPATCH; +}; + diff --git a/Src/Plugins/Library/ml_local/mldbApiFactory.cpp b/Src/Plugins/Library/ml_local/mldbApiFactory.cpp new file mode 100644 index 00000000..a2cc2cc9 --- /dev/null +++ b/Src/Plugins/Library/ml_local/mldbApiFactory.cpp @@ -0,0 +1,61 @@ +#include "api__ml_local.h" +#include "mldbApiFactory.h" +#include "mldbApi.h" +MLDBAPI mldbApi; +static const char serviceName[] = "Media Library Database API"; + +FOURCC MLDBAPIFactory::GetServiceType() +{ + return WaSvc::UNIQUE; +} + +const char *MLDBAPIFactory::GetServiceName() +{ + return serviceName; +} + +GUID MLDBAPIFactory::GetGUID() +{ + return mldbApiGuid; +} + +void *MLDBAPIFactory::GetInterface(int global_lock) +{ + return &mldbApi; +// if (global_lock) +// plugin.service->service_lock(this, (void *)ifc); +} + +int MLDBAPIFactory::SupportNonLockingInterface() +{ + return 1; +} + +int MLDBAPIFactory::ReleaseInterface(void *ifc) +{ + //plugin.service->service_unlock(ifc); + return 1; +} + +const char *MLDBAPIFactory::GetTestString() +{ + return NULL; +} + +int MLDBAPIFactory::ServiceNotify(int msg, int param1, int param2) +{ + return 1; +} + +#define CBCLASS MLDBAPIFactory +START_DISPATCH; +CB(WASERVICEFACTORY_GETSERVICETYPE, GetServiceType) +CB(WASERVICEFACTORY_GETSERVICENAME, GetServiceName) +CB(WASERVICEFACTORY_GETGUID, GetGUID) +CB(WASERVICEFACTORY_GETINTERFACE, GetInterface) +CB(WASERVICEFACTORY_SUPPORTNONLOCKINGGETINTERFACE, SupportNonLockingInterface) +CB(WASERVICEFACTORY_RELEASEINTERFACE, ReleaseInterface) +CB(WASERVICEFACTORY_GETTESTSTRING, GetTestString) +CB(WASERVICEFACTORY_SERVICENOTIFY, ServiceNotify) +END_DISPATCH; +#undef CBCLASS diff --git a/Src/Plugins/Library/ml_local/mldbApiFactory.h b/Src/Plugins/Library/ml_local/mldbApiFactory.h new file mode 100644 index 00000000..620b961a --- /dev/null +++ b/Src/Plugins/Library/ml_local/mldbApiFactory.h @@ -0,0 +1,23 @@ +#ifndef NULLSOFT_MLDBFACTORY_H +#define NULLSOFT_MLDBFACTORY_H + +#include <api/service/waservicefactory.h> +#include <api/service/services.h> + +class MLDBAPIFactory: public waServiceFactory +{ +public: + FOURCC GetServiceType(); + const char *GetServiceName(); + GUID GetGUID(); + void *GetInterface(int global_lock); + int SupportNonLockingInterface(); + int ReleaseInterface(void *ifc); + const char *GetTestString(); + int ServiceNotify(int msg, int param1, int param2); + +protected: + RECVS_DISPATCH; +}; + +#endif
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/nde_error.txt b/Src/Plugins/Library/ml_local/nde_error.txt new file mode 100644 index 00000000..e36baa49 --- /dev/null +++ b/Src/Plugins/Library/ml_local/nde_error.txt @@ -0,0 +1,4 @@ +
+There was an error loading 'nde.dll' which is required for all of the local database functions.
+
+This could be due to a failed Winamp update or 'nde.dll' having been removed by mistake.
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/nde_itemRecord.cpp b/Src/Plugins/Library/ml_local/nde_itemRecord.cpp new file mode 100644 index 00000000..7af7f6fc --- /dev/null +++ b/Src/Plugins/Library/ml_local/nde_itemRecord.cpp @@ -0,0 +1,976 @@ +/* +** Copyright © 2003-2014 Winamp SA +** +** This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held +** liable for any damages arising from the use of this software. +** +** Permission is granted to anyone to use this software for any purpose, including commercial applications, and to +** alter it and redistribute it freely, subject to the following restrictions: +** +** 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. +** If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +** +** 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +** +** 3. This notice may not be removed or altered from any source distribution. +** +*/ + +#include <windows.h> +#include "../../General/gen_ml/ml.h" +#include "../nde/nde.h" +#include "../nu/sort.h" + +void freeRecord(itemRecord *p) +{ + if (p) + { + free(p->title); + free( p->artist ); + free( p->ext ); + free(p->comment); + free(p->album); + free(p->genre); + free(p->filename); + if (p->extended_info) + { + for (size_t x = 0; p->extended_info[x]; x ++) + free(p->extended_info[x]); + free(p->extended_info); + p->extended_info = 0; + } + } +} + +void freeRecordList(itemRecordList *obj) +{ + if (obj) + { + emptyRecordList(obj); + _aligned_free(obj->Items); + obj->Items=0; + obj->Alloc=obj->Size=0; + } +} + +void emptyRecordList(itemRecordList *obj) +{ + if (obj) + { + itemRecord *p=obj->Items; + while (obj->Size-->0) + { + freeRecord(p); + p++; + } + obj->Size=0; + } +} + +void allocRecordList(itemRecordList *obj, int newsize, int granularity) +{ + if (newsize < obj->Alloc || newsize < obj->Size) return; + + int old_Alloc = obj->Alloc; + obj->Alloc=newsize+granularity; + + itemRecord *data = (itemRecord*)_aligned_realloc(obj->Items, sizeof(itemRecord) * obj->Alloc, 16); + if (!data) + { + data = (itemRecord*)_aligned_malloc(sizeof(itemRecord) * obj->Alloc, 16); + if (data) + { + memcpy(data, obj->Items, sizeof(itemRecord) * old_Alloc); + _aligned_free(obj->Items); + obj->Items = data; + } + else + obj->Alloc = old_Alloc; + } + else + obj->Items = data; + + if (!obj->Items) obj->Alloc=0; +} + +void compactRecordList(itemRecordListW *obj) +{ + if (obj->Size && obj->Size < obj->Alloc - 1024) + { + size_t old_Alloc = obj->Size; + obj->Alloc = obj->Size; + + itemRecordW *data = (itemRecordW *)_aligned_realloc(obj->Items, sizeof(itemRecordW) * obj->Alloc, 16); + if (!data) + { + data = (itemRecordW *)_aligned_malloc(sizeof(itemRecordW) * obj->Alloc, 16); + if (data) + { + memcpy(data, obj->Items, sizeof(itemRecordW) * old_Alloc); + _aligned_free(obj->Items); + obj->Items = data; + } + else + obj->Alloc = old_Alloc; + } + else + obj->Items = data; + } +} + +void copyRecord(itemRecord *out, const itemRecord *in) +{ +#define COPYSTR(FOO) out->FOO = in->FOO ? _strdup(in->FOO) : 0; + COPYSTR(filename) + COPYSTR(title) + COPYSTR(ext) + COPYSTR(album) + COPYSTR(artist) + COPYSTR(comment) + COPYSTR(genre) + out->year=in->year; + out->track=in->track; + out->length=in->length; +#undef COPYSTR + out->extended_info=0; + + if (in->extended_info) + { + for (int y = 0; in->extended_info[y]; y ++) + { + char *p=in->extended_info[y]; + if (*p) setRecordExtendedItem(out,p,p+strlen(p)+1); + } + } +} + +void copyRecordList(itemRecordList *out, const itemRecordList *in) +{ + allocRecordList(out,out->Size+in->Size,0); + if (!out->Items) return; + for (int x = 0; x < in->Size; x ++) + { + copyRecord(&out->Items[out->Size++],&in->Items[x]); + } +} + +char *getRecordExtendedItem(const itemRecord *item, const char *name) +{ + if (item->extended_info) + { + for (size_t x = 0; item->extended_info[x]; x ++) + { + if (!_stricmp(item->extended_info[x],name)) + return item->extended_info[x]+strlen(name)+1; + } + } + return NULL; +} + +void setRecordExtendedItem(itemRecord *item, const char *name, char *value) +{ + if (!item || !name) return; + + size_t x = 0; + if (item->extended_info) + { + for (x = 0; item->extended_info[x]; x ++) + { + if (!_stricmp(item->extended_info[x],name)) + { + size_t name_len = strlen(name), value_len = strlen(value); + if (value_len>strlen(item->extended_info[x]+name_len+1)) + { + free(item->extended_info[x]); + item->extended_info[x]=(char*)malloc(name_len+value_len+2); + } + strncpy(item->extended_info[x], name, name_len); + strncpy(item->extended_info[x]+strlen(name)+1, value, value_len); + return; + } + } + } + + // x=number of valid items. + char **data = (char**)realloc(item->extended_info,sizeof(char*) * (x+2)); + if (data) + { + // if we could allocate then add, otherwise we'll have to skip + item->extended_info = data; + + size_t name_len = strlen(name), value_len = strlen(value); + item->extended_info[x]=(char*)malloc(name_len+value_len+2); + strncpy(item->extended_info[x], name, name_len); + strncpy(item->extended_info[x]+name_len+1, value, value_len); + + item->extended_info[x+1]=0; + } + else + { + data = (char**)malloc(sizeof(char*) * (x+2)); + if (data) + { + memcpy(data, item->extended_info, sizeof(char*) * x); + free(item->extended_info); + + // if we could allocate then add, otherwise we'll have to skip + item->extended_info = data; + + size_t name_len = strlen(name), value_len = strlen(value); + item->extended_info[x]=(char*)malloc(name_len+value_len+2); + strncpy(item->extended_info[x], name, name_len); + strncpy(item->extended_info[x]+name_len+1, value, value_len); + + item->extended_info[x+1]=0; + } + } +} + +/* +---------------------------------- +wide version starts here +---------------------------------- +*/ +void freeRecord(itemRecordW *p) +{ + if (p) + { + ndestring_release(p->title); + ndestring_release(p->artist); + ndestring_release(p->comment); + ndestring_release(p->album); + ndestring_release(p->genre); + ndestring_release(p->filename); + ndestring_release(p->albumartist); + ndestring_release(p->replaygain_album_gain); + ndestring_release(p->replaygain_track_gain); + ndestring_release(p->publisher); + ndestring_release(p->composer); + if (p->extended_info) + { + for (size_t x = 0; p->extended_info[x].key; x ++) + { + // TODO release 'key' ? +// ndestring_release(p->extended_info[x].key); + ndestring_release(p->extended_info[x].value); + } + free(p->extended_info); + p->extended_info = 0; + } + } +} + +void freeRecordList(itemRecordListW *obj) +{ + if (obj) + { + emptyRecordList(obj); + _aligned_free(obj->Items); + obj->Items=0; + obj->Alloc=obj->Size=0; + } +} + +void emptyRecordList(itemRecordListW *obj) +{ + if (obj) + { + itemRecordW *p=obj->Items; + while (obj->Size-->0) + { + freeRecord(p); + p++; + } + obj->Size=0; + } +} + +void allocRecordList(itemRecordListW *obj, int newsize, int granularity) +{ + if (newsize < obj->Alloc || newsize < obj->Size) return; + + int old_Alloc = obj->Alloc; + obj->Alloc=newsize+granularity; + itemRecordW *data = (itemRecordW*)_aligned_realloc(obj->Items,sizeof(itemRecordW)*obj->Alloc, 16); + if (!data) + { + data = (itemRecordW*)_aligned_malloc(sizeof(itemRecordW) * obj->Alloc, 16); + if (data) + { + memcpy(data, obj->Items, sizeof(itemRecordW) * obj->Alloc); + _aligned_free(obj->Items); + obj->Items = data; + } + else + obj->Alloc = old_Alloc; + } + else + obj->Items = data; + + if (!obj->Items) obj->Alloc=0; +} + +#if 0 // unused, don't re-enable until you verify the TODO below +void copyRecord(itemRecordW *out, const itemRecordW *in) +{ +#define COPYSTR(FOO) out->FOO = in->FOO ? _wcsdup(in->FOO) : 0; +#define COPY(FOO) out->FOO = in->FOO; + /* this is only valid if 'in' is one of our item records! */ + out->filename = in->filename; + NDEString *ndeString = WCHAR_TO_NDESTRING(out->filename); + if (ndeString) ndeString->Retain(); + COPYSTR(title) + COPYSTR(album) + COPYSTR(artist) + COPYSTR(comment) + COPYSTR(genre) + COPYSTR(albumartist); + COPYSTR(replaygain_album_gain); + COPYSTR(replaygain_track_gain); + COPYSTR(publisher); + COPYSTR(composer); + COPY(year); + COPY(track); + COPY(tracks); + COPY(length); + COPY(rating); + COPY(playcount); + COPY(lastplay); + COPY(lastupd); + COPY(filetime); + COPY(filesize); + COPY(bitrate); + COPY(type); + COPY(disc); + COPY(discs); + COPY(bpm); + COPYSTR(category); +#undef COPYSTR + out->extended_info=0; + + if (in->extended_info) + { + for (int y = 0; in->extended_info[y].key; y ++) + { + setRecordExtendedItem(out,in->extended_info[y].key,in->extended_info[y].value); + } + } +} + +void copyRecordList(itemRecordListW *out, const itemRecordListW *in) +{ + allocRecordList(out,out->Size+in->Size,0); + if (!out->Items) return; + for (size_t x = 0; x < in->Size; x ++) + { + copyRecord(&out->Items[out->Size++],&in->Items[x]); + } +} +#endif + +wchar_t *getRecordExtendedItem(const itemRecordW *item, const wchar_t *name) +{ + if (item && item->extended_info && name) + { + for (size_t x = 0; item->extended_info[x].key; x ++) + { + if (!_wcsicmp(item->extended_info[x].key,name)) + return item->extended_info[x].value; + } + } + return NULL; +} + +wchar_t *getRecordExtendedItem_fast(const itemRecordW *item, const wchar_t *name) +{ + if (item && item->extended_info && name) + { + for (size_t x = 0; item->extended_info[x].key; x ++) + { + if (item->extended_info[x].key == name) + return item->extended_info[x].value; + } + } + return NULL; +} + +void setRecordExtendedItem(itemRecordW *item, const wchar_t *name, const wchar_t *value) +{ + if (!item || !name) return; + + size_t x=0; + if (item->extended_info) for (x = 0; item->extended_info[x].key; x ++) + { + if (item->extended_info[x].key == name) + { + ndestring_retain(const_cast<wchar_t *>(value)); + ndestring_release(item->extended_info[x].value); + item->extended_info[x].value = const_cast<wchar_t *>(value); + return; + } + } + + // x=number of valid items. + extendedInfoW *data=(extendedInfoW *)realloc(item->extended_info,sizeof(extendedInfoW) * (x+2)); + if (data) + { + item->extended_info=data; + + item->extended_info[x].key = const_cast<wchar_t *>(name); + ndestring_retain(const_cast<wchar_t *>(value)); + item->extended_info[x].value = const_cast<wchar_t *>(value); + + item->extended_info[x+1].key=0; + item->extended_info[x+1].value=0; + } + else + { + data=(extendedInfoW *)malloc(sizeof(extendedInfoW) * (x+2)); + if (data) + { + item->extended_info=data; + + item->extended_info[x].key = const_cast<wchar_t *>(name); + ndestring_retain(const_cast<wchar_t *>(value)); + item->extended_info[x].value = const_cast<wchar_t *>(value); + + item->extended_info[x+1].key=0; + item->extended_info[x+1].value=0; + } + } +} + +// this version assumes that the 'name' won't already be in the itemRecord +void setRecordExtendedItem_fast(itemRecordW *item, const wchar_t *name, const wchar_t *value) +{ + if (!item || !name) return; + + size_t x = 0; + if (item->extended_info) + { + for (x = 0; item->extended_info[x].key; x++) + { + } + } + + // x=number of valid items. + extendedInfoW *data=(extendedInfoW *)realloc(item->extended_info,sizeof(extendedInfoW) * (x+2)); + if (data) + { + item->extended_info = data; + item->extended_info[x].key = const_cast<wchar_t *>(name); + ndestring_retain(const_cast<wchar_t *>(value)); + item->extended_info[x].value = const_cast<wchar_t *>(value); + + item->extended_info[x+1].key=0; + item->extended_info[x+1].value=0; + } + else + { + data=(extendedInfoW *)malloc(sizeof(extendedInfoW) * (x+2)); + if (data) + { + item->extended_info=data; + + item->extended_info[x].key = const_cast<wchar_t *>(name); + ndestring_retain(const_cast<wchar_t *>(value)); + item->extended_info[x].value = const_cast<wchar_t *>(value); + + item->extended_info[x+1].key=0; + item->extended_info[x+1].value=0; + } + } +} + +// TODO: redo this without AutoChar +#include "../replicant/nu/AutoChar.h" +#include "../nu/AutoCharFn.h" +#define COPY_EXTENDED_STR(field) if (input-> ## field && input-> ## field ## [0]) setRecordExtendedItem(output, #field, AutoChar(input-> ## field)); +#define COPY_EXTENDED_INT(field) if (input->##field > 0) { char temp[64] = {0}; _itoa(input->##field, temp, 10); setRecordExtendedItem(output, #field, temp); } +#define COPY_EXTENDED_INT64(field) if (input->##field > 0) { char temp[64] = {0}; _i64toa(input->##field, temp, 10); setRecordExtendedItem(output, #field, temp); } +#define COPY_EXTENDED_INT0(field) if (input->##field >= 0) { char temp[64] = {0}; _itoa(input->##field, temp, 10); setRecordExtendedItem(output, #field, temp); } +void convertRecord(itemRecord *output, const itemRecordW *input) +{ + output->filename=_strdup(AutoCharFn(input->filename)); + output->title=AutoCharDup(input->title); + output->ext=AutoCharDup(input->ext); + output->album=AutoCharDup(input->album); + output->artist=AutoCharDup(input->artist); + output->comment=AutoCharDup(input->comment); + output->genre=AutoCharDup(input->genre); + output->year=input->year; + output->track=input->track; + output->length=input->length; + output->extended_info=0; + COPY_EXTENDED_STR(albumartist); + COPY_EXTENDED_STR(replaygain_album_gain); + COPY_EXTENDED_STR(replaygain_track_gain); + COPY_EXTENDED_STR(publisher); + COPY_EXTENDED_STR(composer); + COPY_EXTENDED_INT(tracks); + COPY_EXTENDED_INT(rating); + COPY_EXTENDED_INT(playcount); + COPY_EXTENDED_INT64(lastplay); + COPY_EXTENDED_INT64(lastupd); + COPY_EXTENDED_INT64(filetime); + COPY_EXTENDED_INT(filesize); + COPY_EXTENDED_INT(bitrate); + COPY_EXTENDED_INT0(type); + COPY_EXTENDED_INT(disc); + COPY_EXTENDED_INT(discs); + COPY_EXTENDED_INT(bpm); + COPY_EXTENDED_STR(category); + + if (input->extended_info) + { + for (int y = 0; input->extended_info[y].key; y ++) + { + setRecordExtendedItem(output, AutoChar(input->extended_info[y].key), AutoChar(input->extended_info[y].value)); + } + } +} +#undef COPY_EXTENDED_STR +#undef COPY_EXTENDED_INT +#undef COPY_EXTENDED_INT0 + +#include "../replicant/nu/AutoWide.h" +#define COPY_EXTENDED_STR(field) output->##field = ndestring_wcsdup(AutoWideDup(getRecordExtendedItem(input, #field))); +#define COPY_EXTENDED_INT(field) { char *x = getRecordExtendedItem(input, #field); output->##field=x?atoi(x):-1; } + +void convertRecord(itemRecordW *output, const itemRecord *input) +{ + output->filename=ndestring_wcsdup(AutoWideDup(input->filename)); + output->title=ndestring_wcsdup(AutoWideDup(input->title)); + output->ext=ndestring_wcsdup(AutoWideDup(input->ext)); + output->album=ndestring_wcsdup(AutoWideDup(input->album)); + output->artist=ndestring_wcsdup(AutoWideDup(input->artist)); + output->comment=ndestring_wcsdup(AutoWideDup(input->comment)); + output->genre=ndestring_wcsdup(AutoWideDup(input->genre)); + output->year=input->year; + output->track=input->track; + output->length=input->length; + output->extended_info=0; + COPY_EXTENDED_STR(albumartist); + COPY_EXTENDED_STR(replaygain_album_gain); + COPY_EXTENDED_STR(replaygain_track_gain); + COPY_EXTENDED_STR(publisher); + COPY_EXTENDED_STR(composer); + COPY_EXTENDED_INT(tracks); + COPY_EXTENDED_INT(rating); + COPY_EXTENDED_INT(playcount); + COPY_EXTENDED_INT(lastplay); + COPY_EXTENDED_INT(lastupd); + COPY_EXTENDED_INT(filetime); + COPY_EXTENDED_INT(filesize); + COPY_EXTENDED_INT(type); + COPY_EXTENDED_INT(disc); + COPY_EXTENDED_INT(discs); + COPY_EXTENDED_INT(bpm); + COPY_EXTENDED_INT(bitrate); + COPY_EXTENDED_STR(composer); + COPY_EXTENDED_STR(category); + // TODO: copy input's extended fields +} +#undef COPY_EXTENDED_STR +#undef COPY_EXTENDED_INT + +void convertRecordList(itemRecordList *output, const itemRecordListW *input) +{ + output->Alloc = output->Size = input->Size; + output->Items = (itemRecord*)_aligned_malloc(sizeof(itemRecord)*input->Size, 16); + if (output->Items) + { + memset(output->Items, 0, sizeof(itemRecord)*input->Size); + for(int i=0; i < input->Size; i++) + { + convertRecord(&output->Items[i],&input->Items[i]); + } + } + else + output->Alloc = output->Size = 0; +} + +void convertRecordList(itemRecordListW *output, const itemRecordList *input) +{ + output->Alloc = output->Size = input->Size; + output->Items = (itemRecordW*)malloc(sizeof(itemRecordW) * input->Size); + if (output->Items) + { + memset(output->Items, 0, sizeof(itemRecordW) * input->Size); + for(int i=0; i < input->Size; i++) + { + convertRecord(&output->Items[i],&input->Items[i]); + } + } +} + +extern int sse_flag; + +// swaps two 16 byte aligned 128-byte values +#ifdef _M_X64 +#include <emmintrin.h> +#endif +static void __fastcall swap128(uint8_t *_a, uint8_t *_b) +{ + // ECX = a + // EDX = b +#ifdef _M_IX86 + _asm + { + // load first 64 bytes of each + movaps xmm0, XMMWORD PTR [ecx+0] + movaps xmm1, XMMWORD PTR [ecx+16] + movaps xmm2, XMMWORD PTR [ecx+32] + movaps xmm3, XMMWORD PTR [ecx+48] + movaps xmm4, XMMWORD PTR [edx+0] + movaps xmm5, XMMWORD PTR [edx+16] + movaps xmm6, XMMWORD PTR [edx+32] + movaps xmm7, XMMWORD PTR [edx+48] + + // store + movaps XMMWORD PTR [edx+0], xmm0 + movaps XMMWORD PTR [edx+16], xmm1 + movaps XMMWORD PTR [edx+32], xmm2 + movaps XMMWORD PTR [edx+48], xmm3 + movaps XMMWORD PTR [ecx+0], xmm4 + movaps XMMWORD PTR [ecx+16], xmm5 + movaps XMMWORD PTR [ecx+32], xmm6 + movaps XMMWORD PTR [ecx+48], xmm7 + + // load second 64 bytes of each + movaps xmm0, XMMWORD PTR [ecx+64] + movaps xmm1, XMMWORD PTR [ecx+80] + movaps xmm2, XMMWORD PTR [ecx+96] + movaps xmm3, XMMWORD PTR [ecx+112] + movaps xmm4, XMMWORD PTR [edx+64] + movaps xmm5, XMMWORD PTR [edx+80] + movaps xmm6, XMMWORD PTR [edx+96] + movaps xmm7, XMMWORD PTR [edx+112] + + // store + movaps XMMWORD PTR [edx+64], xmm0 + movaps XMMWORD PTR [edx+80], xmm1 + movaps XMMWORD PTR [edx+96], xmm2 + movaps XMMWORD PTR [edx+112], xmm3 + movaps XMMWORD PTR [ecx+64], xmm4 + movaps XMMWORD PTR [ecx+80], xmm5 + movaps XMMWORD PTR [ecx+96], xmm6 + movaps XMMWORD PTR [ecx+112], xmm7 + } +#else + //sizeof(itemRecordW) is 176 on AMD64. that's 11 SSE registers + __m128i b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10; + __m128i a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10; + __m128i *a = (__m128i *)_a; + __m128i *b = (__m128i *)_b; + + a0 = _mm_load_si128(&a[0]); + a1 = _mm_load_si128(&a[1]); + a2 = _mm_load_si128(&a[2]); + a3 = _mm_load_si128(&a[3]); + a4 = _mm_load_si128(&a[4]); + a5 = _mm_load_si128(&a[5]); + a6 = _mm_load_si128(&a[6]); + a7 = _mm_load_si128(&a[7]); + a8 = _mm_load_si128(&a[0]); + a9 = _mm_load_si128(&a[1]); + a10 = _mm_load_si128(&a[2]); + + b0 = _mm_load_si128(&b[0]); + b1 = _mm_load_si128(&b[1]); + b2 = _mm_load_si128(&b[2]); + b3 = _mm_load_si128(&b[3]); + b4 = _mm_load_si128(&b[4]); + b5 = _mm_load_si128(&b[5]); + b6 = _mm_load_si128(&b[6]); + b7 = _mm_load_si128(&b[7]); + b8 = _mm_load_si128(&b[8]); + b9 = _mm_load_si128(&b[9]); + b10 = _mm_load_si128(&b[10]); + + _mm_store_si128(&a[0], b0); + _mm_store_si128(&a[1], b1); + _mm_store_si128(&a[2], b2); + _mm_store_si128(&a[3], b3); + _mm_store_si128(&a[4], b4); + _mm_store_si128(&a[5], b5); + _mm_store_si128(&a[6], b6); + _mm_store_si128(&a[7], b7); + _mm_store_si128(&b[0], a0); + _mm_store_si128(&b[1], a1); + _mm_store_si128(&b[2], a2); + _mm_store_si128(&b[3], a3); + _mm_store_si128(&b[4], a4); + _mm_store_si128(&b[5], a5); + _mm_store_si128(&b[6], a6); + _mm_store_si128(&b[7], a7); + + +#endif +} + +/*** +*shortsort(hi, lo, width, comp) - insertion sort for sorting short arrays +* +*Purpose: +* sorts the sub-array of elements between lo and hi (inclusive) +* side effects: sorts in place +* assumes that lo < hi +* +*Entry: +* char *lo = pointer to low element to sort +* char *hi = pointer to high element to sort +* size_t width = width in bytes of each array element +* int (*comp)() = pointer to function returning analog of strcmp for +* strings, but supplied by user for comparing the array elements. +* it accepts 2 pointers to elements and returns neg if 1<2, 0 if +* 1=2, pos if 1>2. +* +*Exit: +* returns void +* +*Exceptions: +* +*******************************************************************************/ + +static void shortsort_sse(uint8_t *lo, uint8_t *hi, const void *context, + int (__fastcall *comp)(const void *, const void *, const void *)) +{ + const size_t width=sizeof(itemRecordW); + uint8_t *p; + + /* Note: in assertions below, i and j are alway inside original bound of + array to sort. */ + + while (hi > lo) { + /* A[i] <= A[j] for i <= j, j > hi */ + uint8_t *max = lo; + for (p = lo+width; p <= hi; p += width) { + /* A[i] <= A[max] for lo <= i < p */ + if (comp(p, max, context) > 0) { + max = p; + } + /* A[i] <= A[max] for lo <= i <= p */ + } + + /* A[i] <= A[max] for lo <= i <= hi */ + + swap128(max, hi); + + /* A[i] <= A[hi] for i <= hi, so A[i] <= A[j] for i <= j, j >= hi */ + + hi -= width; + + /* A[i] <= A[j] for i <= j, j > hi, loop top condition established */ + } + /* A[i] <= A[j] for i <= j, j > lo, which implies A[i] <= A[j] for i < j, + so array is sorted */ +} + +#define CUTOFF 8 +#define STKSIZ (8*sizeof(void*) - 2) +extern "C" void qsort_itemRecord(void *base, size_t num, const void *context, + int (__fastcall *comp)(const void *, const void *, const void *)) +{ + /* Note: the number of stack entries required is no more than + 1 + log2(num), so 30 is sufficient for any array */ + uint8_t *lo, *hi; /* ends of sub-array currently sorting */ + uint8_t *mid; /* points to middle of subarray */ + uint8_t *loguy, *higuy; /* traveling pointers for partition step */ + size_t size; /* size of the sub-array */ + uint8_t *lostk[STKSIZ], *histk[STKSIZ]; + int stkptr; /* stack for saving sub-array to be processed */ + const size_t width=sizeof(itemRecordW); + +#ifdef _M_IX86 + assert(sizeof(itemRecordW) == 128); +#elif defined (_M_X64) + assert(sizeof(itemRecordW) == 176); +#else +#error not implemented on this processor! +#endif + if (!sse_flag) + { + nu::qsort(base, num, sizeof(itemRecordW), context, comp); + return; + } + + if (num < 2) + return; /* nothing to do */ + + stkptr = 0; /* initialize stack */ + + lo = static_cast<uint8_t *>(base); + hi = (uint8_t *)base + width * (num-1); /* initialize limits */ + + /* this entry point is for pseudo-recursion calling: setting + lo and hi and jumping to here is like recursion, but stkptr is + preserved, locals aren't, so we preserve stuff on the stack */ +recurse: + + size = (hi - lo) / width + 1; /* number of el's to sort */ + + /* below a certain size, it is faster to use a O(n^2) sorting method */ + if (size <= CUTOFF) { + shortsort_sse(lo, hi, context, comp); + } + else { + /* First we pick a partitioning element. The efficiency of the + algorithm demands that we find one that is approximately the median + of the values, but also that we select one fast. We choose the + median of the first, middle, and last elements, to avoid bad + performance in the face of already sorted data, or data that is made + up of multiple sorted runs appended together. Testing shows that a + median-of-three algorithm provides better performance than simply + picking the middle element for the latter case. */ + + mid = lo + (size / 2) * width; /* find middle element */ + + /* Sort the first, middle, last elements into order */ + if (comp(lo, mid, context) > 0) { + swap128(lo, mid); + } + if (comp(lo, hi, context) > 0) { + swap128(lo, hi); + } + if (comp(mid, hi, context) > 0) { + swap128(mid, hi); + } + + /* We now wish to partition the array into three pieces, one consisting + of elements <= partition element, one of elements equal to the + partition element, and one of elements > than it. This is done + below; comments indicate conditions established at every step. */ + + loguy = lo; + higuy = hi; + + /* Note that higuy decreases and loguy increases on every iteration, + so loop must terminate. */ + for (;;) { + /* lo <= loguy < hi, lo < higuy <= hi, + A[i] <= A[mid] for lo <= i <= loguy, + A[i] > A[mid] for higuy <= i < hi, + A[hi] >= A[mid] */ + + /* The doubled loop is to avoid calling comp(mid,mid), since some + existing comparison funcs don't work when passed the same + value for both pointers. */ + + if (mid > loguy) { + do { + loguy += width; + } while (loguy < mid && comp(loguy, mid, context) <= 0); + } + if (mid <= loguy) { + do { + loguy += width; + } while (loguy <= hi && comp(loguy, mid, context) <= 0); + } + + /* lo < loguy <= hi+1, A[i] <= A[mid] for lo <= i < loguy, + either loguy > hi or A[loguy] > A[mid] */ + + do { + higuy -= width; + } while (higuy > mid && comp(higuy, mid, context) > 0); + + /* lo <= higuy < hi, A[i] > A[mid] for higuy < i < hi, + either higuy == lo or A[higuy] <= A[mid] */ + + if (higuy < loguy) + break; + + /* if loguy > hi or higuy == lo, then we would have exited, so + A[loguy] > A[mid], A[higuy] <= A[mid], + loguy <= hi, higuy > lo */ + + swap128(loguy, higuy); + + /* If the partition element was moved, follow it. Only need + to check for mid == higuy, since before the swap, + A[loguy] > A[mid] implies loguy != mid. */ + + if (mid == higuy) + mid = loguy; + + /* A[loguy] <= A[mid], A[higuy] > A[mid]; so condition at top + of loop is re-established */ + } + + /* A[i] <= A[mid] for lo <= i < loguy, + A[i] > A[mid] for higuy < i < hi, + A[hi] >= A[mid] + higuy < loguy + implying: + higuy == loguy-1 + or higuy == hi - 1, loguy == hi + 1, A[hi] == A[mid] */ + + /* Find adjacent elements equal to the partition element. The + doubled loop is to avoid calling comp(mid,mid), since some + existing comparison funcs don't work when passed the same value + for both pointers. */ + + higuy += width; + if (mid < higuy) { + do { + higuy -= width; + } while (higuy > mid && comp(higuy, mid, context) == 0); + } + if (mid >= higuy) { + do { + higuy -= width; + } while (higuy > lo && comp(higuy, mid, context) == 0); + } + + /* OK, now we have the following: + higuy < loguy + lo <= higuy <= hi + A[i] <= A[mid] for lo <= i <= higuy + A[i] == A[mid] for higuy < i < loguy + A[i] > A[mid] for loguy <= i < hi + A[hi] >= A[mid] */ + + /* We've finished the partition, now we want to sort the subarrays + [lo, higuy] and [loguy, hi]. + We do the smaller one first to minimize stack usage. + We only sort arrays of length 2 or more.*/ + + if ( higuy - lo >= hi - loguy ) { + if (lo < higuy) { + lostk[stkptr] = lo; + histk[stkptr] = higuy; + ++stkptr; + } /* save big recursion for later */ + + if (loguy < hi) { + lo = loguy; + goto recurse; /* do small recursion */ + } + } + else { + if (loguy < hi) { + lostk[stkptr] = loguy; + histk[stkptr] = hi; + ++stkptr; /* save big recursion for later */ + } + + if (lo < higuy) { + hi = higuy; + goto recurse; /* do small recursion */ + } + } + } + + /* We have sorted the array, except for any pending sorts on the stack. + Check if there are any, and do them. */ + + --stkptr; + if (stkptr >= 0) { + lo = lostk[stkptr]; + hi = histk[stkptr]; + goto recurse; /* pop subarray from stack */ + } + else + return; /* all subarrays done */ +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/pe_subclass.cpp b/Src/Plugins/Library/ml_local/pe_subclass.cpp new file mode 100644 index 00000000..67de6b1f --- /dev/null +++ b/Src/Plugins/Library/ml_local/pe_subclass.cpp @@ -0,0 +1,76 @@ +#include "main.h" +#include "api__ml_local.h" +#include "resource.h" + +static WNDPROC PE_oldWndProc; +static HMENU last_viewmenu = NULL; +static WORD waCmdMenuID; + +static INT_PTR CALLBACK PE_newWndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + if (uMsg == WM_COMMAND && wParam > 45000 && wParam < 57000) + { + int n = wParam - 45000; + if (m_query_list[n]) + { + queryItem *item = m_query_list[n]; + wchar_t configDir[MAX_PATH] = {0}; + PathCombineW(configDir, g_viewsDir, item->metafn); + C_Config viewconf(configDir); + main_playQuery(&viewconf, item->query, 0, 0); + + return 0; + } + } + else if (uMsg == WM_INITMENUPOPUP) + { + HMENU hmenuPopup = (HMENU) wParam; + if (hmenuPopup == wa_playlists_cmdmenu) + { + if (!waCmdMenuID) + { + waCmdMenuID = (WORD)SendMessage(plugin.hwndWinampParent,WM_WA_IPC,0,IPC_REGISTER_LOWORD_COMMAND); + } + if (last_viewmenu) + { + RemoveMenu(wa_playlists_cmdmenu, waCmdMenuID, MF_BYCOMMAND); + DestroyMenu(last_viewmenu); + last_viewmenu = NULL; + } + + mlGetTreeStruct mgts = { 1000, 45000, -1}; + last_viewmenu = (HMENU)SendMessage(plugin.hwndLibraryParent, WM_ML_IPC, (WPARAM) & mgts, ML_IPC_GETTREE); + if (last_viewmenu) + { + MENUITEMINFOW menuItem = {sizeof(MENUITEMINFOW), MIIM_SUBMENU | MIIM_ID | MIIM_TYPE, MFT_STRING, + MFS_ENABLED, waCmdMenuID, last_viewmenu, NULL, NULL, NULL, + WASABI_API_LNGSTRINGW(IDS_OPEN_MEDIA_LIBRARY_VIEW_RESULTS), 0}; + + if (GetMenuItemCount(last_viewmenu) > 0) + { + InsertMenuItemW(wa_playlists_cmdmenu, 1, TRUE, &menuItem); + } + else + { + DestroyMenu(last_viewmenu); + last_viewmenu=0; + } + } + } + } + return CallWindowProc(PE_oldWndProc, hwndDlg, uMsg, wParam, lParam); +} + +static HWND hwnd_pe = NULL; +void HookPlaylistEditor() +{ + hwnd_pe = (HWND)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, IPC_GETWND_PE, IPC_GETWND); + + if (IsWindow(hwnd_pe)) + PE_oldWndProc = (WNDPROC) SetWindowLongPtrW(hwnd_pe, GWLP_WNDPROC, (LONG_PTR)PE_newWndProc); +} + +void UnhookPlaylistEditor() +{ + SetWindowLongPtrW(hwnd_pe, GWLP_WNDPROC, (LONG_PTR)PE_oldWndProc); +} diff --git a/Src/Plugins/Library/ml_local/prefs.cpp b/Src/Plugins/Library/ml_local/prefs.cpp new file mode 100644 index 00000000..ffeef4da --- /dev/null +++ b/Src/Plugins/Library/ml_local/prefs.cpp @@ -0,0 +1,936 @@ +#include "main.h" +#include "api__ml_local.h" +#include "ml_local.h" +#include <time.h> +#include "..\..\General\gen_ml/config.h" +#include "resource.h" +#include "../nu/listview.h" +#include "..\..\General\gen_ml/gaystring.h" +#include "./scanfolderbrowser.h" +#include "../replicant/nu/AutoChar.h" +#include "../replicant/nu/AutoWide.h" +#include <shlwapi.h> +#include <strsafe.h> + +extern HWND subWnd = 0, prefsWnd = 0; +extern int g_bgrescan_int, g_bgrescan_do, g_autochannel_do; +HWND g_bgrescan_status_hwnd; +static W_ListView *m_dir_lv; + + +static void EnableDisableRecentPlayingControls( HWND hwndDlg, int tracking ) +{ + if ( tracking == -1 ) tracking = !!g_config->ReadInt( L"trackplays", 1 ); + EnableWindow( GetDlgItem( hwndDlg, IDC_CHECK7 ), tracking ); + EnableWindow( GetDlgItem( hwndDlg, IDC_CHECK8 ), tracking ); + EnableWindow( GetDlgItem( hwndDlg, IDC_EDIT2 ), tracking && !!g_config->ReadInt( L"trackplays_wait_secs", 0 ) ); + EnableWindow( GetDlgItem( hwndDlg, IDC_EDIT3 ), tracking && !!g_config->ReadInt( L"trackplays_wait_percent", 0 ) ); + EnableWindow( GetDlgItem( hwndDlg, IDC_STATIC4 ), tracking ); + EnableWindow( GetDlgItem( hwndDlg, IDC_STATIC5 ), tracking ); +} + +// Recently Played +// When 'Recently Played' is enabled, Winamp will keep track of\nwhen and how many times items in the Media Library are played. +static INT_PTR CALLBACK Prefs1Proc( HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam ) +{ + switch ( uMsg ) + { + case WM_INITDIALOG: + { + CheckDlgButton( hwndDlg, IDC_REMEMBER_SEARCH, !!g_config->ReadInt( L"remembersearch", 0 ) ); + CheckDlgButton( hwndDlg, IDC_CHECK3, !!g_config->ReadInt( L"useminiinfo2", 0 ) ); + + CheckDlgButton( hwndDlg, IDC_CHECK_ATF, !!g_config->ReadInt( L"newtitle", 1 ) ); + CheckDlgButton( hwndDlg, IDC_CHECK5, !!g_config->ReadInt( L"audiorefine", 0 ) ); + CheckDlgButton( hwndDlg, IDC_CHECK6, !g_config->ReadInt( L"dbloadatstart", 1 ) ); + + CheckDlgButton( hwndDlg, IDC_ARTIST_AS_ALBUMARTIST, g_config->ReadInt( L"artist_as_albumartist", 1 ) ); + + SetDlgItemInt( hwndDlg, IDC_EDIT_QUERYDELAY, g_config->ReadInt( L"querydelay", 250 ), 0 ); + + int tracking = !!g_config->ReadInt( L"trackplays", 1 ); + CheckDlgButton( hwndDlg, IDC_CHECK2, tracking ); + CheckDlgButton( hwndDlg, IDC_CHECK7, !!g_config->ReadInt( L"trackplays_wait_secs", 0 ) ); + CheckDlgButton( hwndDlg, IDC_CHECK8, !!g_config->ReadInt( L"trackplays_wait_percent", 0 ) ); + SetDlgItemInt( hwndDlg, IDC_EDIT2, g_config->ReadInt( L"trackplays_wait_secs_lim", 5 ), 0 ); + SetDlgItemInt( hwndDlg, IDC_EDIT3, g_config->ReadInt( L"trackplays_wait_percent_lim", 50 ), 0 ); + EnableDisableRecentPlayingControls( hwndDlg, tracking ); + } + break; + case WM_COMMAND: + switch ( LOWORD( wParam ) ) + { + case IDC_CHECK3: + g_config->WriteInt( L"useminiinfo2", !!IsDlgButtonChecked( hwndDlg, IDC_CHECK3 ) ); + PostMessage( plugin.hwndLibraryParent, WM_USER + 30, 0, 0 ); + break; + case IDC_REMEMBER_SEARCH: + g_config->WriteInt( L"remembersearch", !!IsDlgButtonChecked( hwndDlg, IDC_REMEMBER_SEARCH ) ); + break; + case IDC_CHECK_ATF: + g_config->WriteInt( L"newtitle", !!IsDlgButtonChecked( hwndDlg, IDC_CHECK_ATF ) ); + break; + case IDC_CHECK5: + g_config->WriteInt( L"audiorefine", !!IsDlgButtonChecked( hwndDlg, IDC_CHECK5 ) ); + if ( plugin.hwndLibraryParent ) PostMessage( plugin.hwndLibraryParent, WM_USER + 30, 0, 0 ); + break; + case IDC_CHECK6: + g_config->WriteInt( L"dbloadatstart", !IsDlgButtonChecked( hwndDlg, IDC_CHECK6 ) ); + break; + case IDC_CHECK2: + { + int tracking = !!IsDlgButtonChecked( hwndDlg, IDC_CHECK2 ); + g_config->WriteInt( L"trackplays", tracking ); + EnableDisableRecentPlayingControls( hwndDlg, tracking ); + } + break; + case IDC_CHECK7: + { + g_config->WriteInt( L"trackplays_wait_secs", !!IsDlgButtonChecked( hwndDlg, IDC_CHECK7 ) ); + EnableDisableRecentPlayingControls( hwndDlg, -1 ); + } + break; + case IDC_CHECK8: + { + g_config->WriteInt( L"trackplays_wait_percent", !!IsDlgButtonChecked( hwndDlg, IDC_CHECK8 ) ); + EnableDisableRecentPlayingControls( hwndDlg, -1 ); + } + break; + case IDC_BUTTON2: + { + wchar_t title[ 64 ] = { 0 }; + WASABI_API_LNGSTRINGW_BUF( IDS_RECENTLY_PLAYED, title, 64 ); + MessageBoxW( hwndDlg, WASABI_API_LNGSTRINGW( IDS_RECENTLY_PLAYED_TEXT ), title, 0 ); + } + break; + case IDC_ARTIST_AS_ALBUMARTIST: + { + int oldValue = g_config->ReadInt( L"artist_as_albumartist", 1 ); + int newValue = !!IsDlgButtonChecked( hwndDlg, IDC_ARTIST_AS_ALBUMARTIST ); + if ( oldValue != newValue ) + { + // TODO: prompt to re-read metadata on entire library + } + g_config->WriteInt( L"artist_as_albumartist", newValue ); + } + break; + case IDC_EDIT_QUERYDELAY: + { + if ( HIWORD( wParam ) == EN_CHANGE ) + { + BOOL t; + int v = GetDlgItemInt( hwndDlg, IDC_EDIT_QUERYDELAY, &t, FALSE ); + if ( t ) + { + if ( v < 1 ) + { + v = 1; + SetDlgItemInt( hwndDlg, IDC_EDIT_QUERYDELAY, v, 0 ); + } + else if ( v > 5000 ) + { + v = 5000; + SetDlgItemInt( hwndDlg, IDC_EDIT_QUERYDELAY, v, 0 ); + } + g_config->WriteInt( L"querydelay", v ); + g_querydelay = v; + } + } + } + break; + case IDC_BUTTON1: + nukeLibrary( hwndDlg ); + break; + case IDC_EDIT2: + if ( HIWORD( wParam ) == EN_CHANGE ) + { + BOOL t; + int v = GetDlgItemInt( hwndDlg, IDC_EDIT2, &t, FALSE ); + if ( t ) + { + if ( v < 0 ) + { + v = 1; + SetDlgItemInt( hwndDlg, IDC_EDIT2, v, 0 ); + } + g_config->WriteInt( L"trackplays_wait_secs_lim", v ); + } + } + break; + case IDC_EDIT3: + if ( HIWORD( wParam ) == EN_CHANGE ) + { + BOOL t; + int v = GetDlgItemInt( hwndDlg, IDC_EDIT3, &t, FALSE ); + if ( t ) + { + int tweaked = 0; + if ( v > 99 ) + { + v = 99; + tweaked = 1; + } + else if ( v < 1 ) + { + v = 1; + tweaked = 1; + } + if ( tweaked ) + { + SetDlgItemInt( hwndDlg, IDC_EDIT3, v, 0 ); + } + + g_config->WriteInt( L"trackplays_wait_percent_lim", v ); + } + } + break; + } + break; + } + return 0; +} + +static void parseMetaStr( wchar_t *buf2, int *guess, int *meta, int *subdir ) +{ + wchar_t metaPS[ 16 ] = { 0 }, metaMS[ 16 ] = { 0 }, smartPS[ 16 ] = { 0 }, smartMS[ 16 ] = { 0 }, guessS[ 16 ] = { 0 }, recurseS[ 16 ] = { 0 }; + StringCchPrintfW( recurseS, 16, L"-%s", WASABI_API_LNGSTRINGW( IDS_RECURSE_STR ) ); + StringCchPrintfW( guessS, 16, L"-%s", WASABI_API_LNGSTRINGW( IDS_GUESS_STR ) ); + StringCchPrintfW( smartPS, 16, L"+%s", WASABI_API_LNGSTRINGW( IDS_SMART_STR ) ); + StringCchPrintfW( smartMS, 16, L"-%s", WASABI_API_LNGSTRINGW( IDS_SMART_STR ) ); + StringCchPrintfW( metaPS, 16, L"+%s", WASABI_API_LNGSTRINGW( IDS_META_STR ) ); + StringCchPrintfW( metaMS, 16, L"-%s", WASABI_API_LNGSTRINGW( IDS_META_STR ) ); + + if ( wcsstr( buf2, metaPS ) ) + { + *meta = 1; + } + else if ( wcsstr( buf2, metaMS ) ) + { + *meta = 0; + } + else + { + *meta = -1; + } + if ( wcsstr( buf2, smartPS ) ) + { + *guess = 0; + } + else if ( wcsstr( buf2, smartMS ) ) + { + *guess = 1; + } + else if ( wcsstr( buf2, guessS ) ) + { + *guess = 2; + } + else + { + *guess = -1; + } + if ( wcsstr( buf2, recurseS ) ) + { + *subdir = 0; + } + else + { + *subdir = 1; + } +} + +static void makeMetaStr( int guess_mode, int use_metadata, int subdir, wchar_t *buf, int bufLen ) +{ + wchar_t guessstr[ 32 ] = { 0 }, recurseS[ 16 ] = { 0 }; + if ( guess_mode >= 0 ) + { + if ( guess_mode == 1 ) + StringCchPrintfW( guessstr, 32, L"-%s", WASABI_API_LNGSTRINGW( IDS_SMART_STR ) ); + else if ( guess_mode == 2 ) + StringCchPrintfW( guessstr, 32, L"-%s", WASABI_API_LNGSTRINGW( IDS_GUESS_STR ) ); + else + StringCchPrintfW( guessstr, 32, L"+%s", WASABI_API_LNGSTRINGW( IDS_SMART_STR ) ); + } + + if ( use_metadata >= 0 && guess_mode >= 0 ) + { + wchar_t bufS[ 64 ] = { 0 }; + StringCchPrintfW( bufS, 64, L"%%c%s%%s%%s", WASABI_API_LNGSTRINGW( IDS_META_STR ) ); + StringCchPrintfW( recurseS, 16, L"%s%s", subdir ? L"" : L"-", subdir ? L"" : WASABI_API_LNGSTRINGW( IDS_RECURSE_STR ) ); + StringCchPrintfW( buf, bufLen, bufS, use_metadata ? L'+' : L'-', guessstr, recurseS ); + } + else if ( use_metadata >= 0 ) + { + wchar_t metaS[ 16 ] = { 0 }; + StringCchPrintfW( metaS, 16, L"%s%s", use_metadata ? L"+" : L"-", WASABI_API_LNGSTRINGW( IDS_META_STR ) ); + StringCchPrintfW( recurseS, 16, L"%s%s", subdir ? L"" : L"-", subdir ? L"" : WASABI_API_LNGSTRINGW( IDS_RECURSE_STR ) ); + StringCchPrintfW( buf, bufLen, L"%s%s", metaS, recurseS ); + } + else if ( guess_mode >= 0 ) + { + StringCchPrintfW( recurseS, 16, L"%s%s", subdir ? L"" : L"-", subdir ? L"" : WASABI_API_LNGSTRINGW( IDS_RECURSE_STR ) ); + StringCchPrintfW( buf, bufLen, L"%s%s", guessstr, recurseS ); + } + else if ( !subdir ) + { + StringCchPrintfW( buf, bufLen, L"-%s", WASABI_API_LNGSTRINGW( IDS_RECURSE_STR ) ); + } + else + { + StringCchCopyW( buf, bufLen, WASABI_API_LNGSTRINGW( IDS_DEFAULT ) ); + } +} + +static void saveList() +{ + GayStringW gs; + int a = 0; + int x, l = m_dir_lv->GetCount(); + for ( x = 0; x < l; x++ ) + { + wchar_t buf[ 1024 ] = { 0 }, buf2[ 64 ] = { 0 }; + m_dir_lv->GetText( x, 0, buf2, 64 ); + m_dir_lv->GetText( x, 1, buf, 1024 ); + if ( buf[ 0 ] ) + { + if ( a ) + gs.Append( L"|" ); + else + a = 1; + + int meta; + int guess; + int subdir; + parseMetaStr( buf2, &guess, &meta, &subdir ); + + if ( meta >= 0 || guess >= 0 || !subdir ) + { + gs.Append( L"<" ); + if ( guess >= 0 ) + gs.Append( guess == 1 ? L"s" : ( guess == 2 ? L"g" : L"S" ) ); + + if ( meta >= 0 ) + gs.Append( meta ? L"M" : L"m" ); + + if ( !subdir ) + gs.Append( L"r" ); + + gs.Append( L">" ); + } + gs.Append( buf ); + } + } + g_config->WriteString( "scandirlist", 0 ); // erase the old ini value + g_config->WriteString( "scandirlist_utf8", AutoChar( gs.Get(), CP_UTF8 ) ); +} + +int autoscan_add_directory( const wchar_t *path, int *guess, int *meta, int *recurse, int noaddjustcheck ) +{ + char *_s1 = g_config->ReadString( "scandirlist", "" ); + UINT codePage = CP_ACP; + if ( !_s1 || !*_s1 ) + { + _s1 = g_config->ReadString( "scandirlist_utf8", "" ); + codePage = CP_UTF8; + } + + wchar_t *s1 = AutoWideDup( _s1, codePage ); + + int bufLen = 0; + wchar_t *s = (wchar_t *)calloc( ( bufLen = ( wcslen( s1 ) + 2 ) ), sizeof( wchar_t ) ); + if ( s ) + { + wcsncpy( s, s1, bufLen ); + s[ wcslen( s ) + 1 ] = 0; + + wchar_t *p = s; + while ( p && *p == L'|' ) p++; + + while ( ( p = wcsstr( p, L"|" ) ) ) + { + *p++ = 0; + while ( p && *p == L'|' ) p++; + } + p = s; + while ( p && *p ) + { + while ( p && *p == L'|' ) p++; + + int use_meta = -1; + int do_guess = -1; + int do_recurse = 1; + if ( *p == L'<' && wcsstr( p, L">" ) ) + { + p++; + while ( p && *p != L'>' ) + { + // <MmSs>can prefix directory + // M=metadata use override + // m=no metadata + // S=smart guessing + // s=stupid guessing + // g=no guessing + if ( *p == L'M' ) + use_meta = 1; + else if ( *p == L'm' ) + use_meta = 0; + else if ( *p == L'S' ) + do_guess = 0; + else if ( *p == L's' ) + do_guess = 1; + else if ( *p == L'g' ) + do_guess = 2; + else if ( *p == L'r' ) + do_recurse = 0; + + p++; + } + p++; + } + + if ( !_wcsnicmp( p, path, wcslen( p ) ) && ( path[ wcslen( p ) ] == L'\\' || !path[ wcslen( p ) ] ) ) + { + free( s ); // directory already in there + + if ( meta ) + *meta = use_meta; + + if ( guess ) + *guess = do_guess; + + if ( recurse ) + *recurse = do_recurse; + + return 1; + } + p += wcslen( p ) + 1; + } + free( s ); + } + + if ( !noaddjustcheck ) + { + WIN32_FIND_DATAW fd = { 0 }; + int bufLen = 0; + wchar_t *s = (wchar_t *)calloc( ( bufLen = ( wcslen( path ) + 32 ) ), sizeof( wchar_t ) ); + StringCchPrintfW( s, bufLen, L"%s\\*.*", path ); + HANDLE h = FindFirstFileW( s, &fd ); + free( s ); + if ( h != INVALID_HANDLE_VALUE ) + { + FindClose( h ); // we are a directory, yay + GayStringW gs; + gs.Set( s1 ); + + if ( s1[ 0 ] ) + gs.Append( L"|" ); + + gs.Append( path ); + + g_config->WriteString( "scandirlist", 0 ); + g_config->WriteString( "scandirlist_utf8", AutoCharDup( gs.Get(), codePage, 0 ) ); + + if ( m_dir_lv ) + { + int x = m_dir_lv->GetCount(); + m_dir_lv->InsertItem( x, WASABI_API_LNGSTRINGW( IDS_DEFAULT ), 0 ); + m_dir_lv->SetItemText( x, 1, path ); + } + } + } + return 0; +} + +static int m_edit_idx; +static INT_PTR CALLBACK editDirProc( HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam ) +{ + switch ( uMsg ) + { + case WM_INITDIALOG: + { + wchar_t buf[ 1024 ] = { 0 }; + SHAutoComplete( GetDlgItem( hwndDlg, IDC_EDIT1 ), SHACF_AUTOAPPEND_FORCE_ON | SHACF_AUTOSUGGEST_FORCE_ON | /*SHACF_FILESYS_DIRS*/0x020 | 0x010 | SHACF_USETAB ); + m_dir_lv->GetText( m_edit_idx, 1, buf, 1024 ); + SetDlgItemTextW( hwndDlg, IDC_EDIT1, buf ); + m_dir_lv->GetText( m_edit_idx, 0, buf, 1024 ); + int guess, meta, subdir; + parseMetaStr( buf, &guess, &meta, &subdir ); + if ( meta ) + CheckDlgButton( hwndDlg, IDC_CHECK1, meta > 0 ? BST_CHECKED : BST_INDETERMINATE ); + + if ( guess < 0 ) + CheckDlgButton( hwndDlg, IDC_RADIO6, BST_CHECKED ); + else if ( !guess ) + CheckDlgButton( hwndDlg, IDC_RADIO1, BST_CHECKED ); + else if ( guess == 2 ) + CheckDlgButton( hwndDlg, IDC_RADIO8, BST_CHECKED ); + else if ( guess > 0 ) + CheckDlgButton( hwndDlg, IDC_RADIO2, BST_CHECKED ); + + if ( subdir ) CheckDlgButton( hwndDlg, IDC_CHECK2, BST_CHECKED ); + } + return 0; + case WM_COMMAND: + switch ( LOWORD( wParam ) ) + { + case IDOK: + { + //save to m_edit_idx :) + wchar_t buf[ 2048 ] = { 0 }; + GetDlgItemTextW( hwndDlg, IDC_EDIT1, buf, 2048 ); + m_dir_lv->SetItemText( m_edit_idx, 1, buf ); + + int meta = IsDlgButtonChecked( hwndDlg, IDC_CHECK1 ); + if ( meta == BST_CHECKED ) + meta = 1; + else if ( meta == BST_INDETERMINATE ) + meta = -1; + else + meta = 0; + + int guess = -1; + if ( IsDlgButtonChecked( hwndDlg, IDC_RADIO1 ) ) + guess = 0; + else if ( IsDlgButtonChecked( hwndDlg, IDC_RADIO2 ) ) + guess = 1; + else if ( IsDlgButtonChecked( hwndDlg, IDC_RADIO8 ) ) + guess = 2; + + int subdir = 1; + if ( !IsDlgButtonChecked( hwndDlg, IDC_CHECK2 ) ) + subdir = 0; + + makeMetaStr( guess, meta, subdir, buf, 64 ); + m_dir_lv->SetItemText( m_edit_idx, 0, buf ); + EndDialog( hwndDlg, 1 ); + } + return 0; + case IDCANCEL: + EndDialog( hwndDlg, 0 ); + return 0; + case IDC_BUTTON1: + wchar_t path[ MAX_PATH ] = { 0 }; + GetDlgItemTextW( hwndDlg, IDC_EDIT1, path, MAX_PATH ); + ScanFolderBrowser browse( FALSE ); + browse.SetSelection( path ); + if ( browse.Browse( hwndDlg ) ) + { + wchar_t path[ MAX_PATH ] = { 0 }; + SHGetPathFromIDListW( browse.GetPIDL(), path ); + SetDlgItemTextW( hwndDlg, IDC_EDIT1, path ); + } + return 0; + } + return 0; + } + return 0; +} + +void hideShowMetadataRadioboxes( HWND hwndDlg ) +{ + int enabled = IsDlgButtonChecked( hwndDlg, IDC_CHECK1 ); + EnableWindow( GetDlgItem( hwndDlg, IDC_STATIC1 ), enabled ); + EnableWindow( GetDlgItem( hwndDlg, IDC_STATIC2 ), enabled ); + EnableWindow( GetDlgItem( hwndDlg, IDC_COMBO1 ), enabled ); + EnableWindow( GetDlgItem( hwndDlg, IDC_RADIO1 ), enabled ); + EnableWindow( GetDlgItem( hwndDlg, IDC_RADIO2 ), enabled ); + EnableWindow( GetDlgItem( hwndDlg, IDC_RADIO3 ), enabled ); +} + +static INT_PTR CALLBACK confMetaProc( HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam ) +{ + switch ( uMsg ) + { + case WM_INITDIALOG: + { + if ( g_config->ReadInt( L"usemetadata", 1 ) ) CheckDlgButton( hwndDlg, IDC_CHECK1, BST_CHECKED ); + { + int gm = g_config->ReadInt( L"guessmode", 0 ); + CheckDlgButton( hwndDlg, gm == 2 ? IDC_RADIO3 : ( gm == 1 ? IDC_RADIO2 : IDC_RADIO1 ), BST_CHECKED ); + } + + SendDlgItemMessageW( hwndDlg, IDC_COMBO1, CB_ADDSTRING, 0, (LPARAM)WASABI_API_LNGSTRINGW( IDS_ANY ) ); + SendDlgItemMessageW( hwndDlg, IDC_COMBO1, CB_ADDSTRING, 0, (LPARAM)WASABI_API_LNGSTRINGW( IDS_ALL ) ); + SendDlgItemMessage( hwndDlg, IDC_COMBO1, CB_SETCURSEL, g_guessifany ? 0 : 1, 0 ); + hideShowMetadataRadioboxes( hwndDlg ); + } + break; + case WM_COMMAND: + switch ( LOWORD( wParam ) ) + { + case IDOK: + g_config->WriteInt( L"usemetadata", !!IsDlgButtonChecked( hwndDlg, IDC_CHECK1 ) ); + { + int a = SendDlgItemMessage( hwndDlg, IDC_COMBO1, CB_GETCURSEL, 0, 0 ); + g_guessifany = ( a == 0 ); + g_config->WriteInt( L"guessifany", g_guessifany ); + } + + if ( IsDlgButtonChecked( hwndDlg, IDC_RADIO1 ) ) + g_config->WriteInt( L"guessmode", 0 ); + + if ( IsDlgButtonChecked( hwndDlg, IDC_RADIO2 ) ) + g_config->WriteInt( L"guessmode", 1 ); + + if ( IsDlgButtonChecked( hwndDlg, IDC_RADIO3 ) ) + g_config->WriteInt( L"guessmode", 2 ); + + case IDCANCEL: + EndDialog( hwndDlg, 0 ); + break; + case IDC_CHECK1: + hideShowMetadataRadioboxes( hwndDlg ); + break; + } + break; + } + return 0; +} + +static INT_PTR CALLBACK Prefs3Proc( HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam ) +{ + static int m_last_isscanning, m_set_rescan_int; + switch ( uMsg ) + { + case WM_INITDIALOG: + { + m_last_isscanning = -1; + m_set_rescan_int = 0; + + SendMessage( hwndDlg, WM_TIMER, 100, 0 ); + SetTimer( hwndDlg, 100, 1000, NULL ); + g_bgrescan_status_hwnd = GetDlgItem( hwndDlg, IDC_STATUS ); + + CheckDlgButton( hwndDlg, IDC_CHECK4, g_bgrescan_do ? BST_CHECKED : 0 ); + SendMessage( hwndDlg, WM_COMMAND, MAKEWPARAM( IDC_CHECK4, 0 ), 0 ); + CheckDlgButton( hwndDlg, IDC_CHECK3, g_config->ReadInt( L"bgrescan_startup", 0 ) ? BST_CHECKED : 0 ); + CheckDlgButton( hwndDlg, IDC_CHECK2, g_config->ReadInt( L"bgrescan_compact", 1 ) ? BST_CHECKED : 0 ); + CheckDlgButton( hwndDlg, IDC_CHECK5, g_config->ReadInt( L"autoaddplays", 0 ) ? BST_CHECKED : 0 ); + + SendDlgItemMessage( hwndDlg, IDC_SPIN1, UDM_SETRANGE, 0, MAKELONG( 9999, 1 ) ); + SetDlgItemInt( hwndDlg, IDC_EDIT3, g_bgrescan_int, FALSE ); + m_set_rescan_int = 1; + + delete m_dir_lv; + m_dir_lv = new W_ListView; + m_dir_lv->setwnd( GetDlgItem( hwndDlg, IDC_LIST1 ) ); + m_dir_lv->AddCol( WASABI_API_LNGSTRINGW( IDS_OPTIONS ), 120 ); + m_dir_lv->AddCol( WASABI_API_LNGSTRINGW( IDS_DIRECTORY ), 500 ); + char *_s1 = g_config->ReadString( "scandirlist", "" ); + UINT codePage = CP_ACP; + if ( !_s1 || !*_s1 ) + { + _s1 = g_config->ReadString( "scandirlist_utf8", "" ); + codePage = CP_UTF8; + } + wchar_t *s1 = AutoWideDup( _s1, codePage ); + int bufLen = 0; + wchar_t *s = (wchar_t *)calloc( ( bufLen = ( wcslen( s1 ) + 2 ) ), sizeof( wchar_t ) ); + if ( s ) + { + wcsncpy( s, s1, bufLen ); + s[ wcslen( s ) + 1 ] = 0; + + wchar_t *p = s; + while ( p && *p == L'|' ) p++; + + while ( ( p = wcsstr( p, L"|" ) ) ) + { + *p++ = 0; + while ( p && *p == L'|' ) p++; + } + int x = 0; + p = s; + while ( p && *p ) + { + while ( p && *p == L'|' ) p++; + + int guess_mode = -1; + int use_metadata = -1; + int subdir = 1; + if ( *p == L'<' && wcsstr( p, L">" ) ) + { + p++; + while ( p && *p != L'>' ) + { + // <MmSs>can prefix directory + // M=metadata use override + // m=no metadata + // S=smart guessing + // s=stupid guessing + if ( *p == L'M' ) + use_metadata = 1; + else if ( *p == L'm' ) + use_metadata = 0; + else if ( *p == L'S' ) + guess_mode = 0; + else if ( *p == L's' ) + guess_mode = 1; + else if ( *p == L'r' ) + subdir = 0; + else if ( *p == L'g' ) + guess_mode = 2; + + p++; + } + p++; + } + wchar_t buf[ 64 ] = { 0 }; + makeMetaStr( guess_mode, use_metadata, subdir, buf, 64 ); + + m_dir_lv->InsertItem( x, buf, 0 ); + m_dir_lv->SetItemText( x, 1, p ); + x++; + + p += wcslen( p ) + 1; + } + free( s ); + } + + if ( NULL != WASABI_API_APP ) + WASABI_API_APP->DirectMouseWheel_EnableConvertToMouseWheel( m_dir_lv->getwnd(), TRUE ); + } + break; + // process this to update the ui state when a scan is running and we didn't manually run it + case WM_USER + 101: + SendMessage( hwndDlg, WM_TIMER, 100, 0 ); + SetTimer( hwndDlg, 100, 1000, NULL ); + break; + case WM_TIMER: + if ( wParam == 100 ) + { + extern int g_bgscan_scanning; + if ( !!g_bgscan_scanning != !!m_last_isscanning ) + { + m_last_isscanning = !!g_bgscan_scanning; + SetDlgItemTextW( hwndDlg, IDC_RESCAN, WASABI_API_LNGSTRINGW( ( m_last_isscanning ? IDS_STOP_SCAN : IDS_RESCAN_NOW ) ) ); + } + } + break; + case WM_COMMAND: + switch ( LOWORD( wParam ) ) + { + case IDC_CHECK5: + g_config->WriteInt( L"autoaddplays", !!IsDlgButtonChecked( hwndDlg, IDC_CHECK5 ) ); + break; + case IDC_CHECK2: + g_config->WriteInt( L"bgrescan_compact", !!IsDlgButtonChecked( hwndDlg, IDC_CHECK2 ) ); + break; + case IDC_CHECK3: + g_config->WriteInt( L"bgrescan_startup", !!IsDlgButtonChecked( hwndDlg, IDC_CHECK3 ) ); + break; + case IDC_CHECK4: + g_config->WriteInt( L"bgrescan_do", g_bgrescan_do = !!IsDlgButtonChecked( hwndDlg, IDC_CHECK4 ) ); + EnableWindow( GetDlgItem( hwndDlg, IDC_EDIT3 ), g_bgrescan_do ); + EnableWindow( GetDlgItem( hwndDlg, IDC_SPIN1 ), g_bgrescan_do ); + break; + case IDC_EDIT3: + { + if ( HIWORD( wParam ) == EN_CHANGE && m_set_rescan_int ) + { + BOOL t; + int x = GetDlgItemInt( hwndDlg, IDC_EDIT3, &t, FALSE ); + if ( t ) + { + if ( x < 1 ) x = 1; + g_config->WriteInt( L"bgrescan_int", g_bgrescan_int = x ); + extern time_t g_bgscan_last_rescan; + g_bgscan_last_rescan = time( NULL ); + } + } + } + break; + case IDC_BUTTON1: + { + ScanFolderBrowser browse( FALSE ); + if ( browse.Browse( hwndDlg ) ) + { + GayStringW n; + wchar_t path[ MAX_PATH ] = { 0 }; + + SHGetPathFromIDListW( browse.GetPIDL(), path ); + + char *_s1 = g_config->ReadString( "scandirlist", "" ); + UINT codePage = CP_ACP; + if ( !_s1 || !*_s1 ) + { + _s1 = g_config->ReadString( "scandirlist_utf8", "" ); + codePage = CP_UTF8; + } + + wchar_t *scanlist = AutoWide( _s1, codePage ); + n.Set( scanlist ); + + if ( scanlist[ 0 ] ) + n.Append( L"|" ); + + n.Append( path ); + g_config->WriteString( "scandirlist", 0 ); + g_config->WriteString( "scandirlist_utf8", AutoChar( n.Get(), CP_UTF8 ) ); + int x = m_dir_lv->GetCount(); + m_dir_lv->InsertItem( x, WASABI_API_LNGSTRINGW( IDS_DEFAULT ), 0 ); + m_dir_lv->SetItemText( x, 1, path ); + } + } + break; + case IDC_BUTTON4: + { + int x, l = m_dir_lv->GetCount(), s = 0; + for ( x = 0; x < l; x++ ) + { + if ( m_dir_lv->GetSelected( x ) ) + { + m_edit_idx = x; + if ( WASABI_API_DIALOGBOXW( IDD_EDITDIR, hwndDlg, editDirProc ) ) + s = 1; + else + break; + } + } + if ( s ) + { + saveList(); + } + } + break; + case IDC_BUTTON3: + { + int x, l = m_dir_lv->GetCount(); + int s = 0; + for ( x = 0; x < l; x++ ) + { + if ( m_dir_lv->GetSelected( x ) ) + { + s = 1; + m_dir_lv->DeleteItem( x-- ); + l--; + } + } + if ( s ) + { + saveList(); + } + } + break; + case IDC_RESCAN: + extern int g_bgscan_scanning; + extern time_t g_bgscan_last_rescan; + if ( g_bgscan_scanning ) + { + Scan_Cancel(); + SetWindowTextW( g_bgrescan_status_hwnd, WASABI_API_LNGSTRINGW( IDS_RESCAN_ABORTED ) ); + SendMessage( hwndDlg, WM_TIMER, 100, 0 ); + } + else + { + extern int openDb( void ); + openDb(); + if ( plugin.hwndLibraryParent ) SendMessage( plugin.hwndLibraryParent, WM_USER + 575, 0xffff00dd, 0 ); + SendMessage( hwndDlg, WM_TIMER, 100, 0 ); + } + break; + case IDC_CONFMETA: + WASABI_API_DIALOGBOXW( IDD_PREFS_METADATA, hwndDlg, confMetaProc ); + break; + }; + break; + case WM_NOTIFY: + { + LPNMHDR l = (LPNMHDR)lParam; + if ( l->idFrom == IDC_LIST1 && l->code == NM_DBLCLK ) + { + SendMessage( hwndDlg, WM_COMMAND, IDC_BUTTON4, 0 ); + } + } + break; + case WM_DESTROY: + m_set_rescan_int = 0; + g_bgrescan_status_hwnd = 0; + if ( NULL != WASABI_API_APP ) + WASABI_API_APP->DirectMouseWheel_EnableConvertToMouseWheel( m_dir_lv->getwnd(), FALSE ); + delete m_dir_lv; + m_dir_lv = 0; + break; + } + return 0; +} + +static void _dosetsel( HWND hwndDlg ) +{ + HWND tabwnd = GetDlgItem( hwndDlg, IDC_TAB1 ); + int sel = TabCtrl_GetCurSel( tabwnd ); + + if ( sel >= 0 && ( sel != g_config->ReadInt( L"lastprefp", 0 ) || !subWnd ) ) + { + g_config->WriteInt( L"lastprefp", sel ); + if ( subWnd ) + DestroyWindow( subWnd ); + + subWnd = 0; + + UINT t = 0; + DLGPROC p = NULL; + switch ( sel ) + { + case 0: t = IDD_PREFS1; p = Prefs1Proc; break; + case 1: t = IDD_PREFS3; p = Prefs3Proc; break; + } + + if ( t ) subWnd = WASABI_API_CREATEDIALOGW( t, hwndDlg, p ); + + if ( subWnd ) + { + RECT r; + GetClientRect( tabwnd, &r ); + TabCtrl_AdjustRect( tabwnd, FALSE, &r ); + SetWindowPos( subWnd, HWND_TOP, r.left, r.top, r.right - r.left, r.bottom - r.top, SWP_NOACTIVATE ); + ShowWindow( subWnd, SW_SHOWNA ); + } + + if ( !SendMessage( plugin.hwndWinampParent, WM_WA_IPC, IPC_ISWINTHEMEPRESENT, IPC_USE_UXTHEME_FUNC ) ) + { + SendMessage( plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)tabwnd, IPC_USE_UXTHEME_FUNC ); + SendMessage( plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)subWnd, IPC_USE_UXTHEME_FUNC ); + } + } +} + +// frame proc +INT_PTR CALLBACK PrefsProc( HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam ) +{ + switch ( uMsg ) + { + case WM_INITDIALOG: + { + TCITEMW item; + HWND tabwnd = GetDlgItem( hwndDlg, IDC_TAB1 ); + item.mask = TCIF_TEXT; + item.pszText = WASABI_API_LNGSTRINGW( IDS_OPTIONS ); + SendMessageW( tabwnd, TCM_INSERTITEMW, 0, (LPARAM)&item ); + item.pszText = WASABI_API_LNGSTRINGW( IDS_WATCH_FOLDERS ); + SendMessageW( tabwnd, TCM_INSERTITEMW, 1, (LPARAM)&item ); + TabCtrl_SetCurSel( tabwnd, g_config->ReadInt( L"lastprefp", 0 ) ); + _dosetsel( hwndDlg ); + prefsWnd = hwndDlg; + } + return 0; + case WM_NOTIFY: + { + LPNMHDR p = (LPNMHDR)lParam; + if ( p->idFrom == IDC_TAB1 && p->code == TCN_SELCHANGE ) _dosetsel( hwndDlg ); + } + return 0; + case WM_DESTROY: + subWnd = NULL; + prefsWnd = NULL; + return 0; + } + return 0; +} + +void refreshPrefs( int screen ) +{ + if ( subWnd && g_config->ReadInt( L"lastprefp", -1 ) == screen ) + { + if ( screen == 4 ) SendMessage( subWnd, WM_INITDIALOG, 0, 0 ); + } +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/queries.cpp b/Src/Plugins/Library/ml_local/queries.cpp new file mode 100644 index 00000000..6cfe338a --- /dev/null +++ b/Src/Plugins/Library/ml_local/queries.cpp @@ -0,0 +1,1639 @@ +#include "main.h" +#include "ml_local.h" +#include "resource.h" +#include "..\..\General\gen_ml/gaystring.h" +#include "..\..\General\gen_ml/config.h" +#include "..\..\General\gen_ml/ml_ipc.h" +#include "../nde/nde.h" +#include "editquery.h" +#include "../nu/ComboBox.h" +#include "../replicant/nu/AutoWide.h" +#include "../replicant/nu/AutoChar.h" +#include "../replicant/nu/ns_wc.h" +#include "..\..\General\gen_ml/ml_ipc_0313.h" + +const wchar_t *getFilterName(unsigned int filterId, wchar_t *buffer, size_t bufferSize); + +static int m_edit_item; + +void queryStrEscape(const wchar_t *p, GayStringW &str) +{ + if (!p || !*p) return; + size_t l = wcslen(p); + wchar_t *escaped = (wchar_t *)calloc((l*3+1), sizeof(wchar_t)); + wchar_t *d = escaped; + while (p && *p) { + if (*p == L'%') { *d++ = L'%'; *d++ = L'%'; } + else if (*p == L'\"') { *d++ = L'%'; *d++ = L'2'; *d++ = L'2'; } + else if (*p == L'\'') { *d++ = L'%'; *d++ = L'2'; *d++ = L'7'; } + else if (*p == L'[') { *d++ = L'%'; *d++ = L'5'; *d++ = L'B'; } + else if (*p == L']') { *d++ = L'%'; *d++ = L'5'; *d++ = L'D'; } + else if (*p == L'(') { *d++ = L'%'; *d++ = L'2'; *d++ = L'8'; } + else if (*p == L')') { *d++ = L'%'; *d++ = L'2'; *d++ = L'9'; } + else if (*p == L'#') { *d++ = L'%'; *d++ = L'2'; *d++ = L'3'; } + else *d++ = *p; + p++; + } + *d = 0; + str.Set(escaped); + free(escaped); +} + +static INT_PTR CALLBACK scrollChildHostProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam); +static INT_PTR CALLBACK childAdvanced(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam); + +int m_item_mode=0,main_oninitdialog; +int m_item_image = MLTREEIMAGE_DEFAULT; +wchar_t m_item_name[256]=L""; +wchar_t m_item_query[1024]=L""; + +typedef struct { + int title; + wchar_t *query; + char sort_by; + char sort_dir; + char *columns; //xff terminated list :). NULL means default columns + int imageIndex; + int mode; +} smartViewPreset; + +#define ARTIST 0x01 +#define ALBUMARTIST 0x02 +#define GENRE 0x03 +#define PUBLISHER 0x04 +#define COMPOSER 0x05 +#define ALBUM 0x06 +#define YEAR 0x07 +#define ARTISTINDEX 0x08 +#define ALBUMARTISTINDEX 0x09 +#define PODCASTCHANNEL 0x0A +#define ALBUMART 0x0B + +#define MAKEVIEW_3FILTER(a, b, c) (a | (b << 8) | (c << 16)) +#define MAKEVIEW_2FILTER(a, b) (a | (b << 8)) + +static smartViewPreset presets[] = { + {IDS_AUDIO, L"type = 0", 0, 0, NULL, TREE_IMAGE_LOCAL_AUDIO, 1}, + {IDS_VIDEO, L"type = 1", 10, 0, "\x7\1\5\x1E\6\3\x20\x8\x9\xA\xff", TREE_IMAGE_LOCAL_VIDEO,MAKEVIEW_2FILTER(GENRE,YEAR)}, + {IDS_MOST_PLAYED, L"playcount > 0", 9, 0, "\x9\0\1\2\3\xA\xff", TREE_IMAGE_LOCAL_MOSTPLAYED,0}, + {IDS_RECENTLY_ADDED, L"dateadded > [3 days ago]", 33, 0, "\x21\0\1\2\3\xff", TREE_IMAGE_LOCAL_RECENTLYADDED,0}, + {IDS_RECENTLY_MODIFIED, L"lastupd > [3 days ago]", 11, 0, "\xB\0\1\2\3\xff", TREE_IMAGE_LOCAL_RECENTLYMODIFIED,0}, + {IDS_RECENTLY_PLAYED, L"lastplay > [2 weeks ago]", 10, 0, "\xA\x9\0\1\2\3\xff", TREE_IMAGE_LOCAL_RECENTLYPLAYED,0}, + {IDS_NEVER_PLAYED, L"playcount = 0 | playcount isempty", 0, 0, "\0\1\2\3\xff", TREE_IMAGE_LOCAL_NEVERPLAYED,0}, + {IDS_TOP_RATED, L"rating >= 3", 8, 0, "\x8\x9\0\1\2\3\xff", TREE_IMAGE_LOCAL_TOPRATED,0}, + {IDS_PODCASTS,L"ispodcast = 1", 0, 0, 0, TREE_IMAGE_LOCAL_PODCASTS, MAKEVIEW_3FILTER(GENRE,PODCASTCHANNEL,YEAR)}, + {IDS_AUDIO_BY_GENRE, L"type = 0", 0, 0, NULL, TREE_IMAGE_LOCAL_AUDIO, MAKEVIEW_3FILTER(GENRE,ARTIST,ALBUM)}, + {IDS_AUDIO_BY_INDEX, L"type = 0", 0, 0, NULL, TREE_IMAGE_LOCAL_AUDIO, MAKEVIEW_3FILTER(ARTISTINDEX,ARTIST,ALBUM)}, + {IDS_SIMPLE_ALBUM, L"type = 0", 0, 0, NULL, TREE_IMAGE_LOCAL_AUDIO, 0x0100000B}, + {IDS_60s_MUSIC, L"type = 0 and year >= 1960 and year < 1970", 0, 0, NULL, TREE_IMAGE_LOCAL_AUDIO, 1}, + {IDS_70s_MUSIC, L"type = 0 and year >= 1970 and year < 1980", 0, 0, NULL, TREE_IMAGE_LOCAL_AUDIO, 1}, + {IDS_80s_MUSIC, L"type = 0 and year >= 1980 and year < 1990", 0, 0, NULL, TREE_IMAGE_LOCAL_AUDIO, 1}, + {IDS_90s_MUSIC, L"type = 0 and year >= 1990 and year < 2000", 0, 0, NULL, TREE_IMAGE_LOCAL_AUDIO, 1}, + {IDS_00s_MUSIC, L"type = 0 and year >= 2000 and year < 2010", 0, 0, NULL, TREE_IMAGE_LOCAL_AUDIO, 1}, + {IDS_ROCK_MUSIC, L"type = 0 and genre has \"Rock\"", 0, 0, NULL, TREE_IMAGE_LOCAL_AUDIO, 1}, + {IDS_CLASSICAL_MUSIC, L"type = 0 and genre has \"Classical\"", 0, 0, NULL, TREE_IMAGE_LOCAL_AUDIO, MAKEVIEW_2FILTER(COMPOSER,ALBUM)}, + {IDS_RECORD_LABELS, L"type = 0", 0, 0, NULL, TREE_IMAGE_LOCAL_AUDIO, MAKEVIEW_3FILTER(PUBLISHER,ALBUMARTIST,ALBUM)}, + {IDS_CUSTOM, L"", 0, 0, NULL, MLTREEIMAGE_DEFAULT, 0}, +}; + +#define NUM_PRESETS (sizeof(presets) / sizeof(smartViewPreset)) + +void showdlgelements(HWND hwndDlg, int nCmdShow) { + const int dlgelems[] = { + IDC_STATIC_FILTER, + IDC_RADIO_SIMPLE, + IDC_IMAGE_SIMPLE, + IDC_STATIC_SIMPLE, + IDC_RADIO_SIMPLEALBUM, + IDC_IMAGE_SIMPLEALBUM, + IDC_STATIC_SIMPLEALBUM, + IDC_RADIO_TWOFILTERS, + IDC_IMAGE_TWOFILTERS, + IDC_STATIC_TWOFILTERS, + IDC_RADIO_THREEFILTERS, + IDC_IMAGE_THREEFILTERS, + IDC_STATIC_THREEFILTERS, + IDC_COMBO_FILTER1, + IDC_COMBO_FILTER2, + IDC_COMBO_FILTER3, + IDC_STATIC_FILTER2, + IDC_STATIC_FILTER3, + }; + for(int i=0; i < (sizeof(dlgelems)/sizeof(int)); i++) + ShowWindow(GetDlgItem(hwndDlg,dlgelems[i]),nCmdShow); +} + +#define SPL_RemoveAll(hwnd) SendMessage(hwnd,WM_USER+41,0,0) +#define SPL_GetQueryString(hwnd) SendMessage(hwnd,WM_USER+40, 0 ,0) +#define SPL_AddFilter(hwnd, filter) (HWND)scrollChildHostProc(hwnd,WM_USER+32, (WPARAM)filter, (LPARAM)1) +#define SPL_AddBlankFilter(hwnd) (HWND)scrollChildHostProc(hwnd,WM_USER+32, 0, (LPARAM)2) +#define SPL_RemoveFilter(hwnd, filterhwnd) SendMessage(hwnd,WM_USER+34,(WPARAM)filterhwnd,(LPARAM)-1) +#define SPL_UpdateScroll(hwnd) SendMessage(hwnd,WM_USER+33,0,0) + +static int m_simple_dirty; + +void SetStaticItemImage(HWND hwndDlg, UINT ctrl_id, UINT ctrl_img) +{ + SendDlgItemMessage(hwndDlg,ctrl_id,STM_SETIMAGE,IMAGE_BITMAP, + (LPARAM)LoadImage(WASABI_API_ORIG_HINST,MAKEINTRESOURCE(ctrl_img),IMAGE_BITMAP,0,0,LR_SHARED)); +} + +int ResizeComboBoxDropDownW(HWND hwndDlg, UINT id, const wchar_t *str, int width){ + SIZE size = {0}; + HWND control = GetDlgItem(hwndDlg, id); + HDC hdc = GetDC(control); + // get and select parent dialog's font so that it'll calculate things correctly + HFONT font = (HFONT)SendMessage(hwndDlg,WM_GETFONT,0,0), oldfont = (HFONT)SelectObject(hdc,font); + GetTextExtentPoint32W(hdc, str, wcslen(str)+1, &size); + + int ret = width; + if(size.cx > width) + { + SendDlgItemMessage(hwndDlg, id, CB_SETDROPPEDWIDTH, size.cx, 0); + ret = size.cx; + } + + SelectObject(hdc, oldfont); + ReleaseDC(control, hdc); + return ret; +} + +struct FiltersContext +{ + HWND last1, last2; + int mode; + HWND m_scrollchild; + int *error; +}; + +static bool EnumFilters(Scanner *scanner, nde_filter_t filter, void *context_in) +{ + FiltersContext *context = (FiltersContext *)context_in; + + HWND x = SPL_AddFilter(context->m_scrollchild,filter); + if(x) { // we have a filter which talks about a field + context->last2=context->last1; + context->last1=x; + context->mode++; + if(context->mode > 2) + context->error[0]=1; // not in our strict form + } else { // we have an AND, OR or a NOT + int f=NDE_Filter_GetOp(filter); + if(f == FILTER_OR) CheckDlgButton(context->last2,IDC_OR,TRUE); + else if(f == FILTER_AND) CheckDlgButton(context->last2,IDC_AND,TRUE); + else context->error[0]=1; // we can't do FILTER_NOT + context->mode--; + if(context->mode != 1) context->error[0]=1; // not in our strict form + } + return !context->error[0]; +} + +static INT_PTR CALLBACK addQueryFrameDialogProc2(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam) { + static HWND m_scrollchild; + static int m_editting=0; + static C_Config *conf=0; + static wchar_t * m_item_meta; + static int mode; + switch(uMsg) + { + case WM_INITDIALOG: + { + const int filters[] = {IDC_COMBO_FILTER1, IDC_COMBO_FILTER2,IDC_COMBO_FILTER3}; + HWND controlWindow; + int iItem; + wchar_t buffer[512] = {0}; + + mode=0; + m_item_meta=0; + conf=0; + m_simple_dirty=0; + + openDb(); + + CheckDlgButton(hwndDlg,IDC_RADIO_SIMPLE,TRUE); + SetDlgItemTextW(hwndDlg,IDC_STATIC_INFO, WASABI_API_LNGSTRINGW(IDS_WILLS_UBER_STRING)); + EnableWindow(GetDlgItem(hwndDlg,IDC_HIDE_EXTINFO), g_config->ReadInt(L"useminiinfo2", 0)); + // set up presets combo box + { + controlWindow = GetDlgItem(hwndDlg, IDC_COMBO_PRESETS); + if (NULL != controlWindow) + { + int width = 0; + for(size_t i=0; i < NUM_PRESETS; i++) + { + if (NULL != WASABI_API_LNGSTRINGW_BUF(presets[i].title, buffer, ARRAYSIZE(buffer))) + { + iItem = SendMessageW(controlWindow, CB_ADDSTRING, 0, (LPARAM)buffer); + if (CB_ERR != iItem) + { + width = ResizeComboBoxDropDownW(hwndDlg, IDC_COMBO_PRESETS, buffer, width); + SendMessageW(controlWindow, CB_SETITEMDATA,(WPARAM)iItem, (LPARAM)(i + 1)); + } + } + } + } + } + + for(size_t i=0; i < ARRAYSIZE(filters); i++) + { + controlWindow = GetDlgItem(hwndDlg, filters[i]); + if (NULL != controlWindow) + { + int width = 0; + for(unsigned int filterId = 0;; filterId++) + { + if (NULL == getFilterName(filterId, buffer, ARRAYSIZE(buffer))) + break; + + iItem = SendMessageW(controlWindow, CB_ADDSTRING, 0, (LPARAM)buffer); + if (CB_ERR != iItem) + { + width = ResizeComboBoxDropDownW(hwndDlg, filters[i], buffer, width); + SendMessageW(controlWindow, CB_SETITEMDATA,(WPARAM)iItem, (LPARAM)filterId); + } + } + } + } + + if (lParam == 1) + { + if (m_edit_item == -1) + { + // nothing to do, m_item_name, m_item_query & m_item_mode have been set already + } + else + { + lstrcpynW(m_item_name,m_query_list[m_edit_item]->name,sizeof(m_item_name)/sizeof(wchar_t)); + lstrcpynW(m_item_query,m_query_list[m_edit_item]->query,sizeof(m_item_query)/sizeof(wchar_t)); + m_item_mode = m_query_list[m_edit_item]->mode; + m_item_image = m_query_list[m_edit_item]->imgIndex; + + // re-select the preset name if we can get a match to a known preset (looks nicer and all that) + controlWindow = GetDlgItem(hwndDlg, IDC_COMBO_PRESETS); + if (NULL != controlWindow) + { + for(size_t i=0; i < NUM_PRESETS; i++) + { + if(m_item_query[0] && !_wcsicmp(presets[i].query, m_item_query) + && presets[i].mode == m_item_mode) + { + SendMessageW(controlWindow, CB_SETCURSEL, i, 0); + SendMessage(hwndDlg,WM_COMMAND,(WPARAM)MAKEWPARAM(IDC_COMBO_PRESETS,CBN_SELCHANGE),(LPARAM)GetDlgItem(hwndDlg,IDC_COMBO_PRESETS)); + break; + } + } + } + + // config + wchar_t configDir[MAX_PATH] = {0}; + PathCombineW(configDir, g_viewsDir, m_query_list[m_edit_item]->metafn); + conf = new C_Config(configDir); + CheckDlgButton(hwndDlg, IDC_HIDE_EXTINFO, conf->ReadInt(L"midivvis", 1) ? 0 : 1); + } + SetWindowTextW(hwndDlg,WASABI_API_LNGSTRINGW(IDS_EDIT_SMART_VIEW)); + m_editting=1; + } + else + { + m_editting=0; + if (m_item_mode != -1) m_item_mode=0; + m_item_name[0]=0; + m_item_query[0]=0; + m_item_image = MLTREEIMAGE_DEFAULT; + + wchar_t filename[1024 + 256] = {0}; + extern void makemetafn(wchar_t *filename, wchar_t **out); + makemetafn(filename, &m_item_meta); + conf = new C_Config(filename); + } + + if(!mode) m_scrollchild=WASABI_API_CREATEDIALOGW(IDD_SCROLLCHILDHOST,hwndDlg,scrollChildHostProc); + else m_scrollchild=WASABI_API_CREATEDIALOGW(IDD_ADD_VIEW_CHILD_ADVANCED,hwndDlg,childAdvanced); + + // this will make sure that we've got the little images shown in all languages (done for 5.51+) + SetStaticItemImage(hwndDlg,IDC_IMAGE_SIMPLE,IDB_NEWFILTER_SIMPLE); + SetStaticItemImage(hwndDlg,IDC_IMAGE_SIMPLEALBUM,IDB_NEWFILTER_SIMPLEALBUM); + SetStaticItemImage(hwndDlg,IDC_IMAGE_TWOFILTERS,IDB_NEWFILTER_TWOFILTERS); + SetStaticItemImage(hwndDlg,IDC_IMAGE_THREEFILTERS,IDB_NEWFILTER_THREEFILTERS); + + if(m_editting==0 && g_config->ReadInt(L"newfilter_showhelp",1)) + { + showdlgelements(hwndDlg,SW_HIDE); + ShowWindow(hwndDlg,SW_SHOWNA); + EnableWindow(GetParent(hwndDlg),0); + break; // don't run through + } + else + { + ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC_INFO),SW_HIDE); + ShowWindow(GetDlgItem(hwndDlg,IDC_CHECK_SHOWINFO),SW_HIDE); + // run through + } + } + case WM_USER+9: + { // do stuff when we're shown or preset is changed + showdlgelements(hwndDlg,SW_SHOWNA); + ShowWindow(m_scrollchild,SW_SHOWNA); + // set up filter radio buttons and combo boxes + extern int GetFilter(int mode, int n); + extern int GetNumFilters(int mode); + + int numFilters=GetNumFilters(m_item_mode); + int f[3] = {0}; + f[0] = GetFilter(m_item_mode,0); + f[1] = GetFilter(m_item_mode,1); + f[2] = GetFilter(m_item_mode,2); + + if(numFilters==0) CheckRadioButton(hwndDlg,IDC_RADIO_TWOFILTERS,IDC_RADIO_SIMPLEALBUM,IDC_RADIO_SIMPLE); + else if(numFilters==1) CheckRadioButton(hwndDlg,IDC_RADIO_TWOFILTERS,IDC_RADIO_SIMPLEALBUM,IDC_RADIO_SIMPLEALBUM); + else if(numFilters==2) CheckRadioButton(hwndDlg,IDC_RADIO_TWOFILTERS,IDC_RADIO_SIMPLEALBUM,IDC_RADIO_TWOFILTERS); + else if(numFilters==3) CheckRadioButton(hwndDlg,IDC_RADIO_TWOFILTERS,IDC_RADIO_SIMPLEALBUM,IDC_RADIO_THREEFILTERS); + + for(int i=0; i<3; i++) { + ComboBox comboBox(hwndDlg, (i==0)?IDC_COMBO_FILTER1:((i==1)?IDC_COMBO_FILTER2:IDC_COMBO_FILTER3)); + if(f[i]==0) comboBox.SelectItem(i==0?0:5); + else comboBox.SelectItem(f[i]-1); + } + // set up "name" edit control + SetDlgItemTextW(hwndDlg,IDC_NAME,m_item_name); + + // do the query editor thing... + SendMessage(hwndDlg,WM_USER+11,0,0); + } + // run through + case WM_USER+10: + { // enable filter combo boxes based on radio buttons + int numFilters=0; + if(IsDlgButtonChecked(hwndDlg,IDC_RADIO_SIMPLEALBUM)) numFilters=1; + if(IsDlgButtonChecked(hwndDlg,IDC_RADIO_TWOFILTERS)) numFilters=2; + else if(IsDlgButtonChecked(hwndDlg,IDC_RADIO_THREEFILTERS)) numFilters=3; + EnableWindow(GetDlgItem(hwndDlg,IDC_STATIC_FILTER3),numFilters>2); + EnableWindow(GetDlgItem(hwndDlg,IDC_STATIC_FILTER2),numFilters>1); + EnableWindow(GetDlgItem(hwndDlg,IDC_COMBO_FILTER3),numFilters>2); + EnableWindow(GetDlgItem(hwndDlg,IDC_COMBO_FILTER2),numFilters>1); + EnableWindow(GetDlgItem(hwndDlg,IDC_COMBO_FILTER1),numFilters>1); + + if (WM_INITDIALOG == uMsg) + { + // show edit info window and restore last position as applicable + POINT pt = {g_config->ReadInt(L"smart_x", -1), g_config->ReadInt(L"smart_y", -1)}; + if (!windowOffScreen(hwndDlg, pt)) + SetWindowPos(hwndDlg, HWND_TOP, pt.x, pt.y, 0, 0, SWP_NOSIZE | SWP_SHOWWINDOW | SWP_NOSENDCHANGING); + else + ShowWindow(hwndDlg, SW_SHOWNA); + + HWND parentWindow = GetParent(hwndDlg); + if (NULL != parentWindow) + EnableWindow(parentWindow, 0); + } + /*else + ShowWindow(hwndDlg, SW_SHOW);*/ + } + break; + case WM_USER+11: + if(!mode) { + SPL_RemoveAll(m_scrollchild); + + EnterCriticalSection(&g_db_cs); + nde_scanner_t p=NDE_Table_CreateScanner(g_table); + ((Scanner *)p)->disable_date_resolution=1; // TODO: don't use C++ NDE api + + int error=0; // not really an error, just we can't express it properly + + if (m_item_query[0] && !NDE_Scanner_Query(p, m_item_query)) + error=1; // ok, actually an error. + + if (m_item_query[0] && !error) + { + FiltersContext context; + context.error = &error; + context.last1 = 0; + context.last2 = 0; + context.m_scrollchild = m_scrollchild; + context.mode = 0; + ((Scanner *)p)->WalkFilters((Scanner::FilterWalker)EnumFilters, &context); // TODO: don't use C++ NDE api + } + + NDE_Table_DestroyScanner(g_table, p); + LeaveCriticalSection(&g_db_cs); + if(error) { + SPL_RemoveAll(m_scrollchild); + HWND x = SPL_AddBlankFilter(m_scrollchild); + ComboBox c(x,IDC_COMBO1); + int n = c.GetCount(); + for(int i=0; i<n; i++) if(c.GetItemData(i) == 0x1ea7c0de) c.SelectItem(i); + SetDlgItemTextW(x,IDC_EDIT1,m_item_query); + SendMessage(x,WM_COMMAND,(WPARAM)MAKEWPARAM(IDC_COMBO1,CBN_SELCHANGE),(LPARAM)GetDlgItem(x,IDC_COMBO1)); + } + + m_simple_dirty=0; + SPL_UpdateScroll(m_scrollchild); + } + break; + case WM_DESTROY: + if(conf) delete conf; conf=0; + if(m_item_meta) free(m_item_meta); m_item_meta=0; + break; + case WM_COMMAND: + switch(LOWORD(wParam)) { + case IDC_BUTTON_MODE: + if(m_simple_dirty) + SPL_GetQueryString(m_scrollchild); + DestroyWindow(m_scrollchild); + mode = !mode; + if(!mode) m_scrollchild=WASABI_API_CREATEDIALOGW(IDD_SCROLLCHILDHOST,hwndDlg,scrollChildHostProc); + else m_scrollchild=WASABI_API_CREATEDIALOGW(IDD_ADD_VIEW_CHILD_ADVANCED,hwndDlg,childAdvanced); + SendMessage(hwndDlg,WM_USER+11,0,0); + SendMessage(hwndDlg,WM_USER+10,0,0); + ShowWindow(m_scrollchild,SW_SHOWNA); + ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC_INFO),SW_HIDE); + ShowWindow(GetDlgItem(hwndDlg,IDC_CHECK_SHOWINFO),SW_HIDE); + + SetDlgItemTextW(hwndDlg,IDC_BUTTON_MODE,WASABI_API_LNGSTRINGW( !mode ? IDS_ADVANCED_MODE : IDS_SIMPLE_MODE)); + + showdlgelements(hwndDlg,SW_SHOWNA); + break; + case IDC_COMBO_PRESETS: + switch(HIWORD(wParam)) { + case CBN_SELCHANGE: + { + ComboBox combo(hwndDlg,IDC_COMBO_PRESETS); + int n = combo.GetItemData(combo.GetSelection()); + if(n>0 && n<=NUM_PRESETS) { + wchar_t cusStr[16] = {0}; + n--; + // populate with a preset + m_item_mode = presets[n].mode; + m_item_image = presets[n].imageIndex; + if(!_wcsicmp(WASABI_API_LNGSTRINGW_BUF(IDS_CUSTOM,cusStr,16), + WASABI_API_LNGSTRINGW(presets[n].title))) m_item_name[0]=0; + else WASABI_API_LNGSTRINGW_BUF(presets[n].title,m_item_name,256); + lstrcpynW(m_item_query,presets[n].query,sizeof(m_item_query)/sizeof(wchar_t)); + showdlgelements(hwndDlg,SW_SHOWNA); + ShowWindow(m_scrollchild,SW_SHOWNA); + ShowWindow(GetDlgItem(hwndDlg,IDC_STATIC_INFO),SW_HIDE); + ShowWindow(GetDlgItem(hwndDlg,IDC_CHECK_SHOWINFO),SW_HIDE); + SendMessage(hwndDlg,WM_USER+9,0,0); + } + } + break; + } + break; + // filter type radio buttons (simulate clicks on the radio button when the image or static text gets clicked) + case IDC_CHECK_SHOWINFO: + g_config->WriteInt(L"newfilter_showhelp",0); + break; + case IDC_STATIC_SIMPLE: + case IDC_IMAGE_SIMPLE: + SendMessage(GetDlgItem(hwndDlg,IDC_RADIO_SIMPLE),BM_CLICK,0,0); + break; + case IDC_STATIC_SIMPLEALBUM: + case IDC_IMAGE_SIMPLEALBUM: + SendMessage(GetDlgItem(hwndDlg,IDC_RADIO_SIMPLEALBUM),BM_CLICK,0,0); + break; + case IDC_STATIC_TWOFILTERS: + case IDC_IMAGE_TWOFILTERS: + SendMessage(GetDlgItem(hwndDlg,IDC_RADIO_TWOFILTERS),BM_CLICK,0,0); + break; + case IDC_STATIC_THREEFILTERS: + case IDC_IMAGE_THREEFILTERS: + SendMessage(GetDlgItem(hwndDlg,IDC_RADIO_THREEFILTERS),BM_CLICK,0,0); + break; + // enable filter combo boxes based on radio buttons + case IDC_RADIO_SIMPLE: + case IDC_RADIO_SIMPLEALBUM: + case IDC_RADIO_TWOFILTERS: + case IDC_RADIO_THREEFILTERS: + CheckDlgButton(hwndDlg,IDC_RADIO_SIMPLE,0); + CheckDlgButton(hwndDlg,IDC_RADIO_SIMPLEALBUM,0); + CheckDlgButton(hwndDlg,IDC_RADIO_TWOFILTERS,0); + CheckDlgButton(hwndDlg,IDC_RADIO_THREEFILTERS,0); + CheckDlgButton(hwndDlg,LOWORD(wParam),1); + SendMessage(hwndDlg,WM_USER+10,0,0); + break; + // OK and Cancel buttons + case IDOK: + { + //name + GetDlgItemTextW(hwndDlg,IDC_NAME,m_item_name,255); + m_item_name[255]=0; + if(!m_item_name[0]) { + wchar_t title[64] = {0}; + MessageBoxW(hwndDlg,WASABI_API_LNGSTRINGW(IDS_MUST_ENTER_A_NAME), + WASABI_API_LNGSTRINGW_BUF(IDS_ERROR,title,64),MB_OK); + return 0; + } + //query + if (m_simple_dirty) + SPL_GetQueryString(m_scrollchild); + + if(IsDlgButtonChecked(hwndDlg,IDC_RADIO_SIMPLEALBUM)) + { + if(conf) + { + conf->WriteInt(L"adiv2pos",100000); + conf->WriteInt(L"albumartviewmode",2); + } + m_item_mode = 0x0100000B; + } + else + { // mode + int numFilters=3; + if(IsDlgButtonChecked(hwndDlg,IDC_RADIO_SIMPLE)) numFilters=0; + else if(IsDlgButtonChecked(hwndDlg,IDC_RADIO_TWOFILTERS)) numFilters=2; + + int f[3] = {0}; + for(int i=0; i<3; i++) { + ComboBox comboBox(hwndDlg, (i==0)?IDC_COMBO_FILTER1:((i==1)?IDC_COMBO_FILTER2:IDC_COMBO_FILTER3)); + f[i] = (comboBox.GetItemData(comboBox.GetSelection()) + 1) & 0xff; + } + if(f[1] == 6) f[1]=0; + if(numFilters == 2) f[2]=0; + if(numFilters == 0) f[0]=f[1]=f[2]=0; + m_item_mode = f[0] | (f[1] << 8) | (f[2] << 16); + } + + if(conf) { + int v = IsDlgButtonChecked(hwndDlg,IDC_HIDE_EXTINFO)?0:1; + conf->WriteInt(L"midivvis",v); + + ComboBox combo(hwndDlg,IDC_COMBO_PRESETS); + int n = combo.GetItemData(combo.GetSelection()); + if(n>0 && n<=NUM_PRESETS) { + n--; + conf->WriteInt(L"mv_sort_by", presets[n].sort_by); + conf->WriteInt(L"mv_sort_dir", presets[n].sort_dir); + + if(presets[n].columns) { + int cnt = 0; + while ((unsigned char)presets[n].columns[cnt] != 0xff) + { + wchar_t buf[32] = {0}; + StringCchPrintfW(buf, ARRAYSIZE(buf), L"column%d", cnt); + conf->WriteInt(buf, (unsigned char)presets[n].columns[cnt]); + cnt++; + } + conf->WriteInt(L"nbcolumns", cnt); + } + } + } + + if (m_edit_item == -1) { + // nothing to do, return values are m_item_name, m_item_query and m_item_mode + } else { + if(!m_editting) addQueryItem(m_item_name,m_item_query,m_item_mode,1,m_item_meta, m_item_image); + else replaceQueryItem(m_edit_item,m_item_name,m_item_query,m_item_mode, m_item_image); + saveQueryTree(); + } + if(m_editting) PostMessage(plugin.hwndLibraryParent, WM_USER + 30, 0, 0); + } + case IDCANCEL: + { + RECT smart_rect = {0}; + GetWindowRect(hwndDlg, &smart_rect); + g_config->WriteInt(L"smart_x", smart_rect.left); + g_config->WriteInt(L"smart_y", smart_rect.top); + + EndDialog(hwndDlg,(LOWORD(wParam) == IDOK)); + EnableWindow(GetParent(hwndDlg),1); + break; + } + } + break; + } + return 0; +} + +static INT_PTR CALLBACK childAdvanced(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam) { + switch (uMsg) + { + case WM_INITDIALOG: + { + RECT r; + HWND parentWindow, controlWindow; + parentWindow = GetAncestor(hwndDlg, GA_PARENT); + if (NULL != parentWindow && + FALSE != GetWindowRect(GetDlgItem(parentWindow,IDC_CHILDFRAME),&r)) + { + MapWindowPoints(HWND_DESKTOP, parentWindow, (POINT*)&r, 2); + SetWindowPos(hwndDlg,NULL,r.left,r.top,r.right-r.left,r.bottom-r.top,SWP_NOZORDER|SWP_NOACTIVATE); + } + + SetDlgItemTextW(hwndDlg,IDC_QUERY,m_item_query); + + controlWindow = GetDlgItem(hwndDlg, IDC_EDIT1); + if (NULL != controlWindow) + { + SetWindowTextA(controlWindow, (char*)WASABI_API_LOADRESFROMFILEW(L"TEXT", MAKEINTRESOURCEW(IDR_QUERIES_TEXT), 0)); + } + } + return 1; + case WM_USER+40: // get query str + GetDlgItemTextW(hwndDlg,IDC_QUERY,m_item_query,1024); + break; + case WM_COMMAND: + switch(LOWORD(wParam)) { + case IDC_EDIT: + { + wchar_t query[1024] = {0}; + GetDlgItemTextW(hwndDlg,IDC_QUERY,query, 1024); + wchar_t querybuf[4096] = {0}; + const wchar_t *newquery = editQuery(hwndDlg, query, querybuf, 4096); + if (newquery != NULL) { + SetDlgItemTextW(hwndDlg, IDC_QUERY, newquery); + m_simple_dirty=1; + } + } + break; + case IDC_QUERY: + m_simple_dirty=1; + break; + } + break; + } + + const int controls[] = + { + IDC_EDIT1, + }; + if (FALSE != WASABI_API_APP->DirectMouseWheel_ProcessDialogMessage(hwndDlg, uMsg, wParam, lParam, controls, ARRAYSIZE(controls))) + return TRUE; + + return 0; +} + +BOOL IsDirectMouseWheelMessage(const UINT uMsg) +{ + static UINT WINAMP_WM_DIRECT_MOUSE_WHEEL = WM_NULL; + + if (WM_NULL == WINAMP_WM_DIRECT_MOUSE_WHEEL) + { + WINAMP_WM_DIRECT_MOUSE_WHEEL = RegisterWindowMessageW(L"WINAMP_WM_DIRECT_MOUSE_WHEEL"); + if (WM_NULL == WINAMP_WM_DIRECT_MOUSE_WHEEL) + return FALSE; + } + + return (WINAMP_WM_DIRECT_MOUSE_WHEEL == uMsg); +} + +static INT_PTR CALLBACK filterProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam) +{ + switch (uMsg) + { + case WM_INITDIALOG: + // populate comboboxes + { + HWND hwndCB=GetDlgItem(hwndDlg,IDC_COMBO1); + int strs[]= + { + IDS_FILENAME, + IDS_TITLE, + IDS_ARTIST, + IDS_ALBUM, + IDS_YEAR, + IDS_GENRE, + IDS_COMMENT, + IDS_TRACK_NUMBER, + IDS_LENGTH, + IDS_IS_VIDEO, + IDS_LAST_UPDATED, + IDS_PLAYED_LAST, + IDS_RATING, + NULL, // fear the 13 + NULL, // gracenote + IDS_PLAY_COUNT, + IDS_FILE_TIME, + IDS_FILE_SIZE_KB, + IDS_BITRATE_KBPS, + IDS_DISC_NUMBER, + IDS_ALBUM_ARTIST, + IDS_ALBUM_GAIN, + IDS_TRACK_GAIN, + IDS_PUBLISHER, + IDS_COMPOSER, + IDS_BPM, // no bpm + IDS_DISCS, + IDS_TRACKS, + IDS_IS_PODCAST, + IDS_PODCAST_CHANNEL, + IDS_PODCAST_PUBLISH_DATE, + NULL, + NULL, + IDS_LOSSLESS, + IDS_CATEGORY, + IDS_CODEC, + IDS_DIRECTOR, + IDS_PRODUCER, + IDS_WIDTH, + IDS_HEIGHT, + NULL, + IDS_DATE_ADDED, + }; + int x; + int cnt = 0, width = 0; + wchar_t * str; + for (x = 0; x < sizeof(strs)/sizeof(strs[0]); x ++) + { + if (strs[x]) + { + int a=SendMessageW(hwndCB, CB_ADDSTRING,0,(LPARAM)(str = WASABI_API_LNGSTRINGW(strs[x]))); + width = ResizeComboBoxDropDownW(hwndDlg, IDC_COMBO1, str, width); + SendMessage(hwndCB,CB_SETITEMDATA,(WPARAM)a,(LPARAM)x); + cnt++; + } + } + + int a=SendMessageW(hwndCB, CB_ADDSTRING,0,(LPARAM)(str = WASABI_API_LNGSTRINGW(IDS_CUSTOM))); + ResizeComboBoxDropDownW(hwndDlg, IDC_COMBO1, str, width); + SendMessage(hwndCB,CB_SETITEMDATA,(WPARAM)a,(LPARAM)0x1ea7c0de); + cnt++; + if (lParam) + { + nde_filter_t filter=(nde_filter_t)lParam; + int a=NDE_Filter_GetID(filter); + if (a != -1) + { + for (x = 0; x < cnt; x ++) + { + int d = SendMessage(hwndCB,CB_GETITEMDATA,(WPARAM)x,0); + if (d == a) + break; + } + if (x < cnt) + { + SendMessage(hwndCB,CB_SETCURSEL,x,0); + SendMessage(hwndDlg,WM_COMMAND,MAKEWPARAM(IDC_COMBO1,CBN_SELCHANGE),(LPARAM)hwndCB); + int filtop=NDE_Filter_GetOp(filter); + HWND hwndCB2=GetDlgItem(hwndDlg,IDC_COMBO2); + cnt=SendMessage(hwndCB2,CB_GETCOUNT,0,0); + for (x = 0; x < cnt; x ++) + { + if (SendMessage(hwndCB2,CB_GETITEMDATA,(WPARAM)x,0) == filtop) + break; + } + if (x < cnt) + { + SendMessage(hwndCB2,CB_SETCURSEL,x,0); + SendMessage(hwndDlg,WM_COMMAND,MAKEWPARAM(IDC_COMBO2,CBN_SELCHANGE),(LPARAM)hwndCB2); + } + } + } + nde_field_t f=NDE_Filter_GetData(filter); + if (f) + { + int ft=NDE_Field_GetType(f); + //hack cause we never actualy get FIELD_LENGTH here. + if (ft==FIELD_INTEGER && a==MAINTABLE_ID_LENGTH) ft=FIELD_LENGTH; + + switch (ft) + { + case FIELD_FILENAME: + case FIELD_STRING: + SetDlgItemTextW(hwndDlg,IDC_EDIT1,NDE_StringField_GetString(f)); + break; + case FIELD_LENGTH: + { + int v=NDE_IntegerField_GetValue(f); + wchar_t buf[128] = {0}; + if (v < 60) + wsprintf(buf,L"%d",v); + else if (v < 60*60) + wsprintf(buf,L"%d:%02d",v/60,v%60); + else + wsprintf(buf,L"%d:%02d:%02d",v/60/60,(v/60)%60,v%60); + + SetDlgItemText(hwndDlg,IDC_EDIT1,buf); + } + break; + case FIELD_INTEGER: + SetDlgItemInt(hwndDlg,IDC_EDIT1,NDE_IntegerField_GetValue(f),TRUE); + break; + } + } + } + } + return 1; + + case WM_USER+29: + if(IsDlgButtonChecked(hwndDlg,IDC_AND)) return 1; + if(IsDlgButtonChecked(hwndDlg,IDC_OR)) return 0; + CheckDlgButton(hwndDlg,wParam?IDC_AND:IDC_OR,TRUE); + return wParam; + case WM_USER+40: + if (wParam && lParam>0) + { + wchar_t *buf=(wchar_t *)wParam; + size_t buf_len=(size_t)lParam; + // produce expression here + HWND hwndCB=GetDlgItem(hwndDlg,IDC_COMBO1); + HWND hwndCB2=GetDlgItem(hwndDlg,IDC_COMBO2); + int x=SendMessage(hwndCB,CB_GETCURSEL,0,0); + if (x != CB_ERR) + { + int Id=SendMessage(hwndCB,CB_GETITEMDATA,x,0); + if(Id == 0x1ea7c0de) { // custom! + GetDlgItemTextW(hwndDlg,IDC_EDIT1,buf,buf_len); + return 0; + } + x = SendMessage(hwndCB2,CB_GETCURSEL,0,0); + if (x != CB_ERR) + { + int Op=SendMessage(hwndCB2,CB_GETITEMDATA,x,0); + + if (Id != -1 && Op != -1) + { + wchar_t res[256] = {0}; + GetDlgItemTextW(hwndDlg,IDC_EDIT1,res,255); + res[255]=0; + nde_field_t p = NDE_Table_GetColumnByID(g_table, (unsigned char)Id); + if (p) + { + const wchar_t *fn=NDE_ColumnField_GetFieldName(p); + + + wchar_t *opstr=NULL; + switch (Op) + { + case FILTER_EQUALS: opstr=L"="; break; + case FILTER_NOTEQUALS: opstr=L"!="; break; + case FILTER_CONTAINS: opstr=L"HAS"; break; + case FILTER_NOTCONTAINS: opstr=L"NOTHAS"; break; + case FILTER_ABOVE: opstr=L">"; break; + case FILTER_BELOW: opstr=L"<"; break; + case FILTER_ABOVEOREQUAL: opstr=L">="; break; + case FILTER_BELOWOREQUAL: opstr=L"<="; break; + case FILTER_BEGINS: opstr=L"BEGINS"; break; + case FILTER_ENDS: opstr=L"ENDS"; break; + case FILTER_LIKE: opstr=L"LIKE"; break; + case FILTER_ISEMPTY: opstr=L"ISEMPTY"; break; + case FILTER_ISNOTEMPTY: opstr=L"ISNOTEMPTY"; break; + } + if (fn && fn[0] && opstr && opstr[0]) + { + if (Op == FILTER_ISEMPTY || Op == FILTER_ISNOTEMPTY) + wsprintfW(buf, L"%s %s",fn,opstr); + else if (NDE_ColumnField_GetDataType(p) == FIELD_DATETIME) + wsprintfW(buf, L"%s %s [%s]",fn,opstr,res); + else + { + GayStringW escaped; + queryStrEscape(res, escaped); + wsprintfW(buf, L"%s %s \"%s\"",fn,opstr,escaped.Get()); + } + } + } + } + } + } + } + return 0; + case WM_COMMAND: + switch (LOWORD(wParam)) + { + case IDC_BUTTON1: + SendMessage(GetParent(hwndDlg),WM_USER+34,(WPARAM)hwndDlg,-1); + m_simple_dirty=1; + return 0; + case IDC_OR: + case IDC_AND: + m_simple_dirty=1; + break; + case IDC_BUTTON_QUERYBUILD: + { + wchar_t query[1024] = {0}; + GetDlgItemTextW(hwndDlg,IDC_EDIT,query, 1024); + wchar_t querybuf[4096] = {0}; + const wchar_t *newquery = editQuery(hwndDlg, query, querybuf, 4096); + if (newquery != NULL) { + SetDlgItemTextW(hwndDlg, IDC_EDIT, newquery); + m_simple_dirty=1; + } + } + break; + case IDC_BUTTON2: + { + wchar_t query[1024] = {0}; + GetDlgItemTextW(hwndDlg,IDC_EDIT1,query,1024); + + const wchar_t *newquery = editTime(hwndDlg, query); + if (newquery != NULL) SetDlgItemTextW(hwndDlg, IDC_EDIT1, newquery); + } + // todo: date picker + return 0; + case IDC_EDIT1: + if (HIWORD(wParam) == EN_CHANGE) + { + m_simple_dirty=1; + } + return 0; + case IDC_COMBO2: + if (HIWORD(wParam) == CBN_SELCHANGE) + { + m_simple_dirty=1; + HWND hwndCB2=(HWND)lParam; + int x=SendMessage(hwndCB2,CB_GETCURSEL,0,0); + if (x != CB_ERR) + { + int a=SendMessage(hwndCB2,CB_GETITEMDATA,(WPARAM)x,0); + if (a == FILTER_ISEMPTY || a == FILTER_ISNOTEMPTY) + { + EnableWindow(GetDlgItem(hwndDlg,IDC_EDIT1),0); + } + else + { + EnableWindow(GetDlgItem(hwndDlg,IDC_EDIT1),1); + } + } + } + return 0; + case IDC_COMBO1: + if (HIWORD(wParam) == CBN_SELCHANGE) + { + m_simple_dirty=1; + HWND hwndCB=(HWND)lParam; + HWND hwndCB2=GetDlgItem(hwndDlg,IDC_COMBO2); + + int x=SendMessage(hwndCB,CB_GETCURSEL,0,0); +#define GAP 2 + if (x != CB_ERR) + { + int lastsel=SendMessage(hwndCB2,CB_GETCURSEL,0,0); + SendMessage(hwndCB2,CB_RESETCONTENT,0,0); + // populate with proper comparisons for type. give a default, too + int myId = SendMessage(hwndCB,CB_GETITEMDATA,(WPARAM)x,0); + if(myId == 0x1ea7c0de) { // custom! + ShowWindow(GetDlgItem(hwndDlg,IDC_BUTTON_QUERYBUILD),SW_SHOWNA); + ShowWindow(GetDlgItem(hwndDlg,IDC_COMBO2),SW_HIDE); + + RECT r; + GetWindowRect(GetDlgItem(hwndDlg,IDC_BUTTON2),&r); + ScreenToClient(hwndDlg,((LPPOINT)&r)); + + RECT r1; + GetWindowRect(GetDlgItem(hwndDlg,IDC_COMBO1),&r1); + ScreenToClient(hwndDlg,((LPPOINT)&r1)); + ScreenToClient(hwndDlg,((LPPOINT)&r1)+1); + + RECT r2; + GetWindowRect(GetDlgItem(hwndDlg,IDC_EDIT1),&r2); + ScreenToClient(hwndDlg,((LPPOINT)&r2)); + ScreenToClient(hwndDlg,((LPPOINT)&r2)+1); + + SetWindowPos(GetDlgItem(hwndDlg,IDC_EDIT1),0,r1.right+GAP,r1.top,r.left-r1.right-GAP-GAP,r2.bottom-r2.top,/*SWP_NOMOVE|*/SWP_NOACTIVATE|SWP_NOZORDER); + return 0; + } + + ShowWindow(GetDlgItem(hwndDlg,IDC_BUTTON_QUERYBUILD),SW_HIDE); + ShowWindow(GetDlgItem(hwndDlg,IDC_COMBO2),SW_SHOWNA); + + nde_field_t p = (-1 != myId) ? NDE_Table_GetColumnByID(g_table, (unsigned char)myId) : NULL; + if (p) + { + if (NDE_ColumnField_GetDataType(p)==FIELD_DATETIME) + { + //if (!IsWindowVisible(GetDlgItem(hwndDlg,IDC_BUTTON2))) + { + RECT r; + GetWindowRect(GetDlgItem(hwndDlg,IDC_BUTTON2),&r); + ScreenToClient(hwndDlg,((LPPOINT)&r)); + + ShowWindow(GetDlgItem(hwndDlg,IDC_BUTTON2),SW_SHOWNA); + + RECT r1; + GetWindowRect(GetDlgItem(hwndDlg,IDC_COMBO2),&r1); + ScreenToClient(hwndDlg,((LPPOINT)&r1)); + ScreenToClient(hwndDlg,((LPPOINT)&r1)+1); + + RECT r2; + GetWindowRect(GetDlgItem(hwndDlg,IDC_EDIT1),&r2); + ScreenToClient(hwndDlg,((LPPOINT)&r2)); + ScreenToClient(hwndDlg,((LPPOINT)&r2)+1); + SetWindowPos(GetDlgItem(hwndDlg,IDC_EDIT1),0,r1.right+GAP,r1.top,r.left-r1.right-GAP-GAP,r2.bottom-r2.top,/*SWP_NOMOVE|*/SWP_NOACTIVATE|SWP_NOZORDER); + } + } + else + { + //if (IsWindowVisible(GetDlgItem(hwndDlg,IDC_BUTTON2))) + { + RECT r; + GetWindowRect(GetDlgItem(hwndDlg,IDC_BUTTON2),&r); + ScreenToClient(hwndDlg,((LPPOINT)&r) + 1); + + ShowWindow(GetDlgItem(hwndDlg,IDC_BUTTON2),SW_HIDE); + + RECT r1; + GetWindowRect(GetDlgItem(hwndDlg,IDC_COMBO2),&r1); + ScreenToClient(hwndDlg,((LPPOINT)&r1)); + ScreenToClient(hwndDlg,((LPPOINT)&r1)+1); + + RECT r2; + GetWindowRect(GetDlgItem(hwndDlg,IDC_EDIT1),&r2); + ScreenToClient(hwndDlg,((LPPOINT)&r2)); + ScreenToClient(hwndDlg,((LPPOINT)&r2)+1); + SetWindowPos(GetDlgItem(hwndDlg,IDC_EDIT1),0,r1.right+GAP,r1.top,r.right-r1.right-GAP,r2.bottom-r2.top,/*SWP_NOMOVE|*/SWP_NOACTIVATE|SWP_NOZORDER); + } + } +#undef GAP + typedef struct + { + int str; + char id; + } fillT; + + int myfillt_len=0; + fillT *myfillt=NULL; + static fillT foo1[]= + { + {IDS_EQUALS,FILTER_EQUALS}, + {IDS_DOES_NOT_EQUAL,FILTER_NOTEQUALS}, + {IDS_CONTAINS,FILTER_CONTAINS}, + {IDS_DOES_NOT_CONTAIN,FILTER_NOTCONTAINS}, + {IDS_IS_ABOVE,FILTER_ABOVE}, + {IDS_IS_BELOW,FILTER_BELOW}, + {IDS_EQUALS_OR_IS_ABOVE,FILTER_ABOVEOREQUAL}, + {IDS_EQUALS_OR_IS_BELOW,FILTER_BELOWOREQUAL}, + {IDS_IS_EMPTY,FILTER_ISEMPTY}, + {IDS_IS_NOT_EMPTY,FILTER_ISNOTEMPTY}, + {IDS_BEGINS_WITH,FILTER_BEGINS}, + {IDS_ENDS_WITH,FILTER_ENDS}, + {IDS_IS_SIMILAR_TO,FILTER_LIKE}, + }; + static fillT foo2[]= + { + {IDS_AT,FILTER_EQUALS}, + {IDS_NOT_AT,FILTER_NOTEQUALS}, + {IDS_AFTER,FILTER_ABOVE}, + {IDS_BEFORE,FILTER_BELOW}, + {IDS_SINCE,FILTER_ABOVEOREQUAL}, + {IDS_UNTIL,FILTER_BELOWOREQUAL}, + {IDS_IS_EMPTY,FILTER_ISEMPTY}, + {IDS_IS_NOT_EMPTY,FILTER_ISNOTEMPTY}, + }; + switch (NDE_ColumnField_GetDataType(p)) + { + case FIELD_DATETIME: + { + myfillt_len = sizeof(foo2)/sizeof(foo2[0]); + myfillt=foo2; + } + break; + case FIELD_LENGTH: + case FIELD_INTEGER: + { + myfillt_len = sizeof(foo1)/sizeof(foo1[0]) - 3; + myfillt=foo1; + } + break; + case FIELD_FILENAME: + case FIELD_STRING: + { + myfillt_len = sizeof(foo1)/sizeof(foo1[0]); + myfillt=foo1; + } + break; + default: + break; + } + if (myfillt) + { + wchar_t *str; + int width = 0; + while (myfillt_len--) + { + int a=SendMessageW(hwndCB2,CB_ADDSTRING,0,(LPARAM)(str = WASABI_API_LNGSTRINGW(myfillt->str))); + width = ResizeComboBoxDropDownW(hwndDlg, IDC_COMBO2, str, width); + SendMessage(hwndCB2,CB_SETITEMDATA,a,(LPARAM)myfillt->id); + myfillt++; + } + if (lastsel != CB_ERR) + SendMessage(hwndCB2,CB_SETCURSEL,lastsel,0); + } + } + } + } + return 0; + } + return 0; + } + + if (FALSE != IsDirectMouseWheelMessage(uMsg) || + WM_MOUSEWHEEL == uMsg) + { + HWND parentWindow; + parentWindow = GetAncestor(hwndDlg, GA_PARENT); + if (NULL != parentWindow) + { + SendMessageW(parentWindow, WM_MOUSEWHEEL, wParam, lParam); + SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, (long)TRUE); + return TRUE; + } + } + + return 0; +} + + +static INT_PTR CALLBACK scrollChildProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam) +{ + static int osize; + switch (uMsg) + { + case WM_INITDIALOG: + { + RECT r; + GetClientRect(hwndDlg,&r); + osize=r.bottom; + } + return 1; + case WM_COMMAND: + if (LOWORD(wParam) == IDC_BUTTON1) + SPL_AddBlankFilter(hwndDlg); + return 0; + case WM_USER+40: // get query string + if (!lParam) + { + // now we go through our children, asking each one for a string, and combine them. + GayStringW str; + HWND h=GetWindow(hwndDlg,GW_CHILD); + wchar_t * nextop=NULL; + while (h) + { + if (h != GetDlgItem(hwndDlg,IDC_BUTTON1)) + { + wchar_t buf[512] = {0}; + buf[0]=0; + SendMessage(h,WM_USER+40,(WPARAM)buf,(LPARAM)sizeof(buf)/sizeof(*buf)); + if (buf[0]) + { + if(nextop) str.Append(nextop); + nextop = IsDlgButtonChecked(h,IDC_AND) ? L" AND " : L" OR "; + //if (str.Get() && str.Get()[0]) str.Append(isOr ? L" OR " : L" AND "); + str.Append(buf); + } + } + h=GetWindow(h,GW_HWNDNEXT); + } + lstrcpynW(m_item_query,str.Get()?str.Get():L"",sizeof(m_item_query)/sizeof(*m_item_query)); + } + return 0; + case WM_USER+41: // remove all + { + HWND h=GetWindow(hwndDlg,GW_CHILD); + std::vector<void*> w; + while (h) { + if (h != GetDlgItem(hwndDlg,IDC_BUTTON1)) + w.push_back((void*)h); + h=GetWindow(h,GW_HWNDNEXT); + } + for ( void *l_w : w ) + SendMessage( hwndDlg, WM_USER + 34, (WPARAM)(HWND)l_w, -1 ); + } + break; + case WM_USER+34: // remove filter by hwnd + if (wParam && lParam == -1) + { + HWND hwndRemove = (HWND) wParam; + RECT r; + + GetClientRect(hwndRemove,&r); + int lh=r.bottom; // height to remove + + GetWindowRect(hwndRemove,&r); + ScreenToClient(hwndDlg,(LPPOINT)&r); + int ltop=r.top; + + DestroyWindow(hwndRemove); + + HWND h=GetWindow(hwndDlg,GW_CHILD); + while (h) + { + RECT r; + + GetWindowRect(h,&r); + ScreenToClient(hwndDlg,(LPPOINT)&r); + + if (r.top > ltop) + { + SetWindowPos(h,0,r.left,r.top - lh,0,0,SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE); + } + h=GetWindow(h,GW_HWNDNEXT); + } + + GetClientRect(hwndDlg,&r); + r.bottom -= lh; + SetWindowPos(hwndDlg,0,0,0,r.right,r.bottom,SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE); + + SendMessage(GetParent(hwndDlg),WM_USER+33,17,0); + } + return 0; + case WM_USER+32: // add filter. lParam is mode. 1 means add by filter, 2 means add blank + if(lParam == 2) { + BOOL b=0; + HWND h=GetWindow(hwndDlg,GW_CHILD); + while (h) { + if (h != GetDlgItem(hwndDlg,IDC_BUTTON1)) + b = filterProc(h,WM_USER+29,(WPARAM)b,0); + h=GetWindow(h,GW_HWNDNEXT); + } + } + if ((lParam == 1 && wParam) || (lParam == 2 && !wParam)) + { + HWND newChild=0; + nde_filter_t filter=(nde_filter_t)wParam; + if (lParam == 2 || (NULL != NDE_Table_GetColumnByID(g_table, NDE_Filter_GetID(filter)))) + { + newChild=WASABI_API_CREATEDIALOGPARAMW(IDD_SCROLLCHILDFILTER,hwndDlg,filterProc,(LPARAM)filter); + RECT r,r2; + GetClientRect(hwndDlg,&r); + GetClientRect(newChild,&r2); + SetWindowPos(hwndDlg,0,0,0,r.right,r.bottom + r2.bottom,SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE); + SetWindowPos(newChild,0,0,r.bottom - osize,0,0,SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE); + + HWND h = GetDlgItem(hwndDlg,IDC_BUTTON1); + GetWindowRect(h,&r); + ScreenToClient(hwndDlg,(LPPOINT)&r); + SetWindowPos(h,0,r.left,r.top + r2.bottom,0,0,SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE); + ShowWindow(newChild,SW_SHOWNA); + } + if (lParam == 2) { + // update scroll, hugging bottom + SendMessage(GetParent(hwndDlg),WM_USER+33,16,0); + } + return (intptr_t)newChild; + } + return 0; + } + + if (FALSE != IsDirectMouseWheelMessage(uMsg) || + WM_MOUSEWHEEL == uMsg) + { + HWND parentWindow; + parentWindow = GetAncestor(hwndDlg, GA_PARENT); + if (NULL != parentWindow) + { + SendMessageW(parentWindow, WM_MOUSEWHEEL, wParam, lParam); + SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, (long)TRUE); + return TRUE; + } + } + return 0; +} + +static INT_PTR CALLBACK scrollChildHostProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam) +{ + static HWND m_child; + switch (uMsg) + { + case WM_INITDIALOG: + { + RECT r; + GetWindowRect(GetDlgItem(GetParent(hwndDlg),IDC_CHILDFRAME),&r); + ScreenToClient(GetParent(hwndDlg),(LPPOINT)&r); + ScreenToClient(GetParent(hwndDlg),((LPPOINT)&r)+1); + SetWindowPos(hwndDlg,NULL,r.left,r.top,r.right-r.left,r.bottom-r.top,SWP_NOZORDER|SWP_NOACTIVATE); + } + m_child=WASABI_API_CREATEDIALOGW(IDD_SCROLLCHILD,hwndDlg,scrollChildProc); + return 1; + case WM_USER+33: + if (m_child) + { + RECT r; + RECT r2; + GetClientRect(hwndDlg,&r2); + GetClientRect(m_child,&r); + if (r2.bottom < r.bottom) + { + SCROLLINFO si={sizeof(si),SIF_RANGE|SIF_PAGE|SIF_POS,0,r.bottom,r2.bottom,wParam == 16 ? r.bottom : 0,0}; + + if (wParam == 17) + si.fMask &= ~SIF_POS; + + SetScrollInfo(hwndDlg,SB_VERT,&si,TRUE); + + if (wParam != 17) + SetWindowPos(m_child,NULL,0,wParam == 16 ? r2.bottom-r.bottom : 0,0,0,SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE); + } else { + //hide the scrollbar + SetWindowPos(m_child,NULL,0,0,0,0,SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE); + ShowScrollBar(hwndDlg,SB_VERT,FALSE); + } + ShowWindow(m_child,SW_SHOWNA); + } + return 0; + case WM_USER+32: + case WM_USER+41: + case WM_USER+40: + if (m_child) return scrollChildProc(m_child,uMsg,wParam,lParam); + return 0; + case WM_VSCROLL: + { + RECT r; + RECT r2; + GetClientRect(hwndDlg,&r2); + GetClientRect(m_child,&r); + + if (r2.bottom < r.bottom) + { + int v=0; + if (LOWORD(wParam) == SB_THUMBPOSITION || LOWORD(wParam) == SB_THUMBTRACK) + { + SCROLLINFO si={sizeof(si),SIF_TRACKPOS|SIF_POS}; + GetScrollInfo(hwndDlg,SB_VERT,&si); + v=si.nTrackPos; + } + else if (LOWORD(wParam) == SB_TOP) + { + v=0; + } + else if (LOWORD(wParam) == SB_BOTTOM) + { + v=r.bottom-r2.bottom; + } + else if (LOWORD(wParam) == SB_PAGEDOWN || LOWORD(wParam) == SB_LINEDOWN) + { + SCROLLINFO si={sizeof(si),SIF_TRACKPOS|SIF_POS}; + GetScrollInfo(hwndDlg,SB_VERT,&si); + v=si.nPos + r2.bottom; + if (v > r.bottom-r2.bottom) v=r.bottom-r2.bottom; + } + else if (LOWORD(wParam) == SB_PAGEUP || LOWORD(wParam) == SB_LINEUP) + { + SCROLLINFO si={sizeof(si),SIF_TRACKPOS|SIF_POS}; + GetScrollInfo(hwndDlg,SB_VERT,&si); + v=si.nPos - r2.bottom; + if (v < 0) v=0; + } + else return 0; + + SetScrollPos(hwndDlg,SB_VERT,v,!(LOWORD(wParam) == SB_THUMBPOSITION || LOWORD(wParam) == SB_THUMBTRACK)); + SetWindowPos(m_child,NULL,0,0-v,0,0,SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE); + } + else + { + SetScrollPos(hwndDlg,SB_VERT,0,!(LOWORD(wParam) == SB_THUMBPOSITION || LOWORD(wParam) == SB_THUMBTRACK)); + SetWindowPos(m_child,NULL,0,0,0,0,SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE); + } + } + return 0; + } + + if (FALSE != IsDirectMouseWheelMessage(uMsg) || + WM_MOUSEWHEEL == uMsg) + { + WORD scrollCommand; + short delta; + + delta = HIWORD(wParam); + + scrollCommand = (delta > 0) ? SB_LINEUP : SB_LINEDOWN; + + SendMessageW(hwndDlg, WM_VSCROLL, MAKEWPARAM(scrollCommand, 0), 0L); + } + return 0; +} + +void addNewQuery(HWND parent) { + HWND hwnd = WASABI_API_CREATEDIALOGPARAMW(IDD_ADD_VIEW_2, parent, addQueryFrameDialogProc2, 0); + SetActiveWindow(hwnd); +} + +void queryEditItem(int n) +{ + m_edit_item=n; + HWND hwnd = WASABI_API_CREATEDIALOGPARAMW(IDD_ADD_VIEW_2, plugin.hwndLibraryParent, addQueryFrameDialogProc2, 1); + SetActiveWindow(hwnd); +} + +// returns true if edition was validated, false if cancel was clicked +// actual return values are in m_item_query, m_item_name and m_item_mode +int queryEditOther(HWND hwnd, const char *query, const char *viewname, int mode) +{ + int notnew=1; + if (query == NULL || !*query) notnew = 0; + m_edit_item = -1; + if (notnew) + { + MultiByteToWideCharSZ(CP_ACP, 0, viewname, -1, m_item_name, 256); + MultiByteToWideCharSZ(CP_ACP, 0, query, -1, m_item_query, 1024); + } + m_item_mode = mode; + if(mode == -1) + return WASABI_API_DIALOGBOXPARAMW(IDD_ADD_VIEW_2_NF, hwnd, addQueryFrameDialogProc2, notnew); + else + return WASABI_API_DIALOGBOXPARAMW(IDD_ADD_VIEW_2, hwnd, addQueryFrameDialogProc2, notnew); +} + +void queryDeleteItem(HWND parent, int n) +{ + QueryList::iterator iter; + iter = m_query_list.find(n); + if (iter == m_query_list.end()) return; + + wchar_t title[64] = {0}; + queryItem *item = iter->second; + if (MessageBoxW(parent,WASABI_API_LNGSTRINGW(IDS_DELETE_THIS_VIEW), + WASABI_API_LNGSTRINGW_BUF(IDS_CONFIRMATION,title,64), + MB_YESNO|MB_ICONQUESTION) == IDYES) + { + mediaLibrary.RemoveTreeItem(iter->first); + m_query_list.erase(iter->first); + saveQueryTree(); + + // we deleted the item from the tree, which apparently is enough to close the current dialog if it was + // the current dialog. hot. + + for(iter = m_query_list.begin(); iter != m_query_list.end(); iter++) + if(iter->second && iter->second->index > item->index) iter->second->index--; + + wchar_t configDir[MAX_PATH] = {0}; + PathCombineW(configDir, g_viewsDir, item->metafn); + DeleteFileW(configDir); + + free(item->metafn); + free(item->name); + free(item->query); + free(item); + } +} + + + int IPC_LIBRARY_SENDTOMENU; +static librarySendToMenuStruct s_menu; + +static WNDPROC ml_oldWndProc2; +static INT_PTR CALLBACK ml_newWndProc2(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + switch(uMsg) + { + case WM_INITMENUPOPUP: + if (wParam && (HMENU)wParam == s_menu.build_hMenu && s_menu.mode==1) + { + myMenu = TRUE; + if (SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&s_menu, IPC_LIBRARY_SENDTOMENU)==(LRESULT)-1) + s_menu.mode=2; + myMenu = FALSE; + if(ml_oldWndProc2) SetWindowLongPtrW(hwndDlg,GWLP_WNDPROC,(LONG_PTR)ml_oldWndProc2); + ml_oldWndProc2 = NULL; + + } + return 0; + } + if (ml_oldWndProc2) return CallWindowProc(ml_oldWndProc2,hwndDlg,uMsg,wParam,lParam); + return 0; +} + +HMENU main_sendto_hmenu; +int main_sendto_mode; + +void view_queryContextMenu(INT_PTR param1, HWND hHost, POINTS pts, int n) +{ + queryItem *item=m_query_list[n]; + if (item == NULL) return; + + ml_oldWndProc2 = (WNDPROC)SetWindowLongPtrW(hHost, GWLP_WNDPROC, (LONG_PTR)ml_newWndProc2); + + HMENU menu=GetSubMenu(g_context_menus,2); + main_sendto_hmenu=GetSubMenu(menu,2); + + s_menu.mode = 0; + s_menu.hwnd = 0; + s_menu.build_hMenu = 0; + + IPC_LIBRARY_SENDTOMENU = SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&"LibrarySendToMenu", IPC_REGISTER_WINAMP_IPCMESSAGE); + if (IPC_LIBRARY_SENDTOMENU > 65536 && SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)0, IPC_LIBRARY_SENDTOMENU)==(LRESULT)-1) + { + s_menu.mode = 1; + s_menu.hwnd = hHost; + s_menu.data_type = ML_TYPE_ITEMRECORDLIST; + s_menu.ctx[1] = 1; + s_menu.build_hMenu = main_sendto_hmenu; + } + + POINT pt; + POINTSTOPOINT(pt, pts); + if (-1 == pt.x || -1 == pt.y) + { + HNAVITEM hItem = (HNAVITEM)param1; + 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; + } + } + + UpdateMenuItems(NULL, menu, IDR_QUERY_ACCELERATORS); + int r = DoTrackPopup(menu, TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTBUTTON, + pt.x, pt.y, hHost, NULL); + if(ml_oldWndProc2) SetWindowLongPtrW(hHost,GWLP_WNDPROC,(LONG_PTR)ml_oldWndProc2); + switch(r) + { + case ID_QUERYWND_EDIT: + queryEditItem(n); + break; + case ID_QUERYWND_DELETE: + queryDeleteItem(hHost,n); + break; + case ID_QUERYWND_PLAYQUERY: + { + wchar_t configDir[MAX_PATH] = {0}; + PathCombineW(configDir, g_viewsDir, item->metafn); + C_Config viewconf(configDir); + main_playQuery(&viewconf,item->query,0); + } + break; + case ID_QUERYWND_ENQUEUEQUERY: + { + wchar_t configDir[MAX_PATH] = {0}; + PathCombineW(configDir, g_viewsDir, item->metafn); + C_Config viewconf(configDir); + main_playQuery(&viewconf,item->query,1); + } + break; + case ID_QUERYMENU_ADDNEWQUERY: + addNewQuery(hHost); + break; + default: + if (s_menu.mode == 2) + { + s_menu.menu_id = r; + if (SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&s_menu, IPC_LIBRARY_SENDTOMENU) == (LRESULT)-1) + { + // build my data. + s_menu.mode=3; + s_menu.data_type = ML_TYPE_ITEMRECORDLISTW; + wchar_t configDir[MAX_PATH] = {0}; + PathCombineW(configDir, g_viewsDir, item->metafn); + C_Config viewconf(configDir); + + EnterCriticalSection(&g_db_cs); + nde_scanner_t s=NDE_Table_CreateScanner(g_table); + NDE_Scanner_Query(s, item->query); + itemRecordListW obj={0,}; + saveQueryToListW(&viewconf, s, &obj, 0, 0, (resultsniff_funcW)-1); + NDE_Table_DestroyScanner(g_table, s); + LeaveCriticalSection(&g_db_cs); + s_menu.data = (void*)&obj; + + LRESULT result = SendMessage(plugin.hwndWinampParent, WM_WA_IPC,(WPARAM)&s_menu,IPC_LIBRARY_SENDTOMENU); + if (result != 1) + { + s_menu.mode=3; + s_menu.data_type = ML_TYPE_ITEMRECORDLIST; + itemRecordList objA={0,}; + convertRecordList(&objA, &obj); + s_menu.data = (void*)&objA; + SendMessage(plugin.hwndWinampParent, WM_WA_IPC,(WPARAM)&s_menu,IPC_LIBRARY_SENDTOMENU); + freeRecordList(&objA); + } + freeRecordList(&obj); + + } + } + break; + } + if (s_menu.mode) + { + s_menu.mode=4; + SendMessage(plugin.hwndWinampParent, WM_WA_IPC,(WPARAM)&s_menu,IPC_LIBRARY_SENDTOMENU); // cleanup + } + main_sendto_hmenu=0; + EatKeyboard(); +} + +void queriesContextMenu(INT_PTR param1, HWND hHost, POINTS pts) { + POINT pt; + POINTSTOPOINT(pt, pts); + if (-1 == pt.x || -1 == pt.y) + { + HNAVITEM hItem = (HNAVITEM)param1; + 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; + } + } + + HMENU menu=GetSubMenu(g_context_menus,3); + int r = DoTrackPopup(menu, TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTBUTTON | TPM_NONOTIFY, + pt.x, pt.y, hHost, NULL); + switch(r) { + case ID_QUERYMENU_ADDNEWQUERY: + addNewQuery(hHost); + break; + case ID_QUERYMENU_PREFERENCES: + SENDWAIPC(plugin.hwndWinampParent, IPC_OPENPREFSTOPAGE, &preferences); + break; + case ID_QUERYMENU_HELP: + SENDWAIPC(plugin.hwndWinampParent, IPC_OPEN_URL, L"https://help.winamp.com/hc/articles/8105304048660-The-Winamp-Media-Library"); + break; + } + EatKeyboard(); +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/queries.txt b/Src/Plugins/Library/ml_local/queries.txt new file mode 100644 index 00000000..64030f6e --- /dev/null +++ b/Src/Plugins/Library/ml_local/queries.txt @@ -0,0 +1,77 @@ +You can enable more powerful views using the custom query language.
+
+The basic format is:
+
+<field> <comparison> [value] [<logic operator> <field> <comparison> [value] [...]]
+
+Field names:
+ TYPE: 0 for audio files, 1 for video files
+ FILENAME: Full filename (including path)
+ LENGTH: Length, in seconds (or hh:mm:ss)
+ ARTIST: Artist
+ ALBUM: Album
+ ALBUMARTIST: Album Artist
+ TITLE: Title
+ TRACKNO: Track number of file
+ GENRE: Genre
+ YEAR: Year
+ COMMENT: Comment
+ COMPOSER: Composer
+ DISC: Disc number of a CD set
+ FILESIZE: File size, in kilobytes
+ FILETIME: Last known file date/time on disk
+ LASTUPD: Date/time of file imported to library or modified in library
+ LASTPLAY: Date/time of last play
+ RATING: Rating value (1-5, or 0 or empty for unrated)
+ PLAYCOUNT: Number of plays
+ PUBLISHER: Publisher or record label
+ DIRECTOR: Film director (for videos)
+ PRODUCER: Film or Record producer
+ CATEGORY: Category
+ REPLAYGAIN_ALBUM_GAIN: ReplayGain Album Gain
+ REPLAYGAIN_TRACK_GAIN: ReplayGain Track Gain
+ BITRATE: Bitrate (in KBPS)
+ TRACKS: Total number of tracks on the disc
+ DISCS: Total number of discs in the set
+ ISPODCAST: 1 for a podcast episode, 0 otherwise
+ PODCASTCHANNEL: The name of the channel for a podcast
+ PODCASTPUBDATE: Date/time when the podcast was published
+ LOSSLESS: Shows lossless audio formats, e.g. lossless=1
+
+Comparison operators:
+ '=': String or integer equals value
+ '!=': String or integer does not equal value
+ '<': String or integer is less than value
+ '>': String or integer is greater than value
+ '<=': String or integer is less than or equal to value
+ '>=': String or integer is greater than or equal to value
+ HAS: String contains value
+ NOTHAS: String does not contain value
+ LIKE: String is similar to value ("the" and whitespace are ignored)
+ BEGINS: String begins with value
+ BEGINSLIKE: String begins like value
+ ENDS: String ends with value
+ ISEMPTY: (no comparison value required) TRUE if <field> is empty
+ ISNOTEMPTY: (no comparison value required) TRUE if <field> is not empty
+
+Values:
+ "strings with spaces" or strings_without_spaces
+ integers can be "32" or just 32
+ integers for LENGTH can be a plain integer (seconds), or mm:ss or hh:mm:ss
+ date/timestamps should be [datetime data], which can be either an absolute
+ or relative time. i.e.: [3 weeks ago], [18:15], [05/30/2003],
+ [yesterday noon], [3 days ago 5 pm], [now], [5 mn before may 30th], etc.
+
+Logic operators:
+ &&, &, or AND: boolean AND two comparisons
+ ||, |, or OR: boolean OR two comparisons
+ !, or NOT: prefix this to an expression for the boolean NOT of that expression
+
+Examples:
+ all video files: type = 1
+ audio by Air longer than 4 minutes: type = 0 & artist = "air" & length > 4:00
+ all files on drive C: filename BEGINS C:
+ high rated items that haven't been played lately: rating > 3 & lastplay < [1 week ago]
+ newly added items that haven't been played yet: lastupd >= [yesterday] & playcount <= 0
+
+Note that you can also use this syntax in the search field of views. Simply prefix a '?' or 'query:' to your search string
diff --git a/Src/Plugins/Library/ml_local/remove.cpp b/Src/Plugins/Library/ml_local/remove.cpp new file mode 100644 index 00000000..ff24848a --- /dev/null +++ b/Src/Plugins/Library/ml_local/remove.cpp @@ -0,0 +1,31 @@ +#include "main.h" +#include "api_mldb.h" + +// returns 0 on success +// returns 1 on failure of either bad filename or invalid table +int RemoveFileFromDB(const wchar_t *filename) +{ + // From mldbApi + int ret = 1; + if (!g_table) openDb(); + if (filename && g_table) + { + // Issue wasabi callback for pre removal + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_REMOVED_PRE, (size_t)filename, 0); + EnterCriticalSection(&g_db_cs); + + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + if (NDE_Scanner_LocateFilename(s, MAINTABLE_ID_FILENAME, FIRST_RECORD, filename)) + { + NDE_Scanner_Delete(s); + NDE_Scanner_Post(s); + g_table_dirty++; + ret = 0; + } + NDE_Table_DestroyScanner(g_table, s); + LeaveCriticalSection(&g_db_cs); + // Issue wasabi callback for post removal + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_REMOVED_POST, (size_t)filename, 0); + } + return ret; +} diff --git a/Src/Plugins/Library/ml_local/resource.h b/Src/Plugins/Library/ml_local/resource.h new file mode 100644 index 00000000..44f6bb3a --- /dev/null +++ b/Src/Plugins/Library/ml_local/resource.h @@ -0,0 +1,606 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by ml_local.rc +// +#define IDS_LOCAL_MEDIA 1 +#define IDS_SEARCHING_X_FILES_FOUND 2 +#define IDS_GETTING_INFO_FROM_FILES_PERCENT 3 +#define IDR_QUERIES_TEXT 4 +#define IDS_SCANNING_DIR 4 +#define IDS_SCANNING_FILE 5 +#define IDS_CHECKING_FOR_FILE 6 +#define IDS_COMPACTING 7 +#define IDS_REMOVING_FILES_NOT_EXISTING 8 +#define IDS_INITIALIZING 9 +#define IDS_SCANNING_X_OF_X_X_REMOVED 10 +#define IDS_SCANNED_X_FILES_X_REMOVED 11 +#define IDS_DATE_TIME_IS_TOO_COMPLEX 17 +#define IDS_DATE_TIME_EDITOR_QUESTION 18 +#define IDS_COMPARE_TO_STRING 19 +#define IDS_AFTER 20 +#define IDS_BEFORE 21 +#define IDS_SINCE 22 +#define IDS_UNTIL 23 +#define IDS_COMPARE_TO_LENGTH 24 +#define IDS_ABOVE 25 +#define IDS_BELOW 26 +#define IDS_ABOVE_OR_EQUAL 27 +#define IDS_BELOW_OR_EQUAL 28 +#define IDS_COMPARE_TO_NUMBER 29 +#define IDS_OFFSET_BY 30 +#define IDS_TIME_AGO 31 +#define IDS_SPACE_AFTER 32 +#define IDS_SPACE_BEFORE 33 +#define IDS_THE 34 +#define IDS_1ST 35 +#define IDS_2ND 36 +#define IDS_3RD 37 +#define IDS_4TH 38 +#define IDS_OF_THIS_MONTH 39 +#define IDS_NOW 40 +#define IDS_THIS_DATE 41 +#define IDS_THIS_MONTH 42 +#define IDS_THIS_DAY 43 +#define IDS_THIS_TIME 44 +#define IDS_ON_SPACE 45 +#define IDS_IN_SPACE 46 +#define IDS_OF_SPACE 47 +#define IDS_AT_SPACE 48 +#define IDS_NOON 49 +#define IDS_MIDNIGHT 50 +#define IDS_AGO 51 +#define IDS_QUERY_FIELD_IS_EMPTY 52 +#define IDS_EMPTY_QUERY 53 +#define IDS_NO_CHANGES_MADE_TO_QUERY 54 +#define IDS_QUERY_NOT_CHANGED 55 +#define IDS_REGISTERED 56 +#define IDS_ADD_PLEDIT_TO_LOCAL_MEDIA 57 +#define IDS_ERROR 58 +#define IDS_ADD_TO_LOCAL_MEDIA 59 +#define IDS_AUDIO 60 +#define IDS_VIDEO 61 +#define IDS_MOST_PLAYED 62 +#define IDS_RECENTLY_ADDED 63 +#define IDS_RECENTLY_PLAYED 64 +#define IDS_NEVER_PLAYED 65 +#define IDS_TOP_RATED 66 +#define IDS_REMOVE_ALL_ITEMS_IN_LIBRARY 67 +#define IDS_CONFIRMATION 68 +#define IDS_NEW_SMART_VIEW 69 +#define IDS_RESCAN_WATCH_FOLDERS 70 +#define IDS_ADD_MEDIA_TO_LIBRARY 71 +#define IDS_REMOVE_MISSING_FILES_FROM_ML 72 +#define IDS_ANY 73 +#define IDS_ALL 74 +#define IDS_OPTIONS 75 +#define IDS_DIRECTORY 76 +#define IDS_STOP_SCAN 77 +#define IDS_RESCAN_NOW 78 +#define IDS_DEFAULT 79 +#define IDS_RESCAN_ABORTED 80 +#define IDS_WATCH_FOLDERS 81 +#define IDS_EDIT_VIEW 82 +#define IDS_MY_NEW_VIEW 83 +#define IDS_SIMPLE_VIEW_EDITOR 84 +#define IDS_ADVANCED_EDITOR 85 +#define IDS_FILTERS 86 +#define IDS_MUST_ENTER_A_NAME 87 +#define IDS_DISCARD_CHANGES_TO_SIMPLE_EDITOR 88 +#define IDS_DAY 88 +#define IDS_VIEW_QUERY_MAY_HAVE_ERRORS 89 +#define IDS_VIEW_QUERY_IS_TOO_COMPLEX 90 +#define IDS_TEXT_AFTER_THE_FIRST_ERROR 91 +#define IDS_SOME_OF_THE_QUERY_LOGIC 92 +#define IDS_VIEW_EDITOR_QUESTION 93 +#define IDS_DELETE_THIS_VIEW 94 +#define IDS_REFINE 95 +#define IDS_CLEAR_REFINE 96 +#define IDS_ARTISTS 97 +#define IDS_ARTIST 97 +#define IDS_TITLE 98 +#define IDS_ALBUM 99 +#define IDS_LENGTH 100 +#define IDS_TRACK_LENGTH 101 +#define IDS_TRACK_NUMBER 101 +#define IDS_GENRE 102 +#define IDR_CONTEXTMENUS 103 +#define IDS_YEAR 103 +#define IDD_VIEW_MEDIA 104 +#define IDS_FILENAME 104 +#define IDD_VIEW_AUDIO 105 +#define IDS_RATING 105 +#define IDS_PLAY_COUNT 106 +#define IDS_PLAYED_LAST 107 +#define IDD_ADD_VIEW 108 +#define IDS_LAST_UPDATED 108 +#define IDS_FILE_TIME 109 +#define IDS_COMMENT 110 +#define IDS_FILE_SIZE 111 +#define IDS_BITRATE 112 +#define IDS_TYPE 113 +#define IDS_DISC 114 +#define IDS_ALBUM_ARTIST 115 +#define IDS_FILE_PATH 116 +#define IDD_EDITDIR 117 +#define IDS_ALBUM_GAIN 117 +#define IDS_TRACK_GAIN 118 +#define IDS_PUBLISHER 119 +#define IDS_COMPOSER 120 +#define IDS_EXTENSION 121 +#define IDS_IS_PODCAST 122 +#define IDD_EDIT_QUERY 123 +#define IDS_PODCAST_CHANNEL 123 +#define IDS_PODCAST_PUBLISH_DATE 124 +#define IDS_SCANNING 125 +#define IDD_EDIT_QUERY_PICK 126 +#define IDS_ERROR_DELETING_FILES 126 +#define IDD_NDE_RECOVERY 127 +#define IDS_ERROR_DELETING_X 127 +#define IDD_NEEDADDFILES 128 +#define IDS_SURE_YOU_WANT_TO_REMOVE_SELECTED_FROM_LIBRARY 128 +#define IDS_HIDE_INFO 129 +#define IDS_SHOW_INFO 130 +#define IDS_THERE_ARE_NOW_X_ITEMS_IN_THE_LIBRARY 131 +#define IDS_ADD_MORE 132 +#define IDS_PLAY_ALL_FILES_BY 133 +#define IDB_TREEITEM_AUDIO 134 +#define IDS_PLAY_ALL_FILES_FROM 134 +#define IDB_TREEITEM_MOSTPLAYED 135 +#define IDS_PODCAST 135 +#define IDB_TREEITEM_NEVERPLAYED 136 +#define IDS_NON_PODCAST 136 +#define IDS_MIXABLE 137 +#define IDS_X_ITEM 138 +#define IDB_TREEITEM_RECENTLYADDED 139 +#define IDS_ALBUM_ART 139 +#define IDB_TREEITEM_RECENTLYPLAYED 140 +#define IDB_TREEITEM_TOPRATED 141 +#define IDS_LOOKING_UP_MEDIA_INFO 141 +#define IDB_TREEITEM_VIDEO 142 +#define IDS_CLICK_AN_ITEM_TO_GET_ITS_INFO 142 +#define IDD_MONITOR_SMALL 143 +#define IDS_PLEASE_CONNECT_TO_THE_INTERNET_TO_USE_THIS_FEATURE 143 +#define IDD_MONITOR_HIDE 144 +#define IDS_ALL_X_ALBUMS_X_WITHOUT_ALBUM 144 +#define IDD_REFRESH_METADATA 145 +#define IDS_ALL_X_ALBUMS 145 +#define IDD_REINDEX 146 +#define IDS_NO_ALBUM 146 +#define IDS_OPEN_MEDIA_LIBRARY_VIEW_RESULTS 147 +#define IDB_BITMAP1 148 +#define IDS_MEDIA_LIBRARY_VIEW_RESULTS 148 +#define IDB_TREEITEM_PODCASTS 149 +#define IDS_ADD_MEDIA_TO_LIBRARY_ 149 +#define IDS_SELECT_FOLDER_TO_ADD_TO_WINAMP_MEDIA_LIBRARY 150 +#define IDR_TEXT1 150 +#define IDB_TREEITEM_RECENTLYMODIFIED 150 +#define IDS_ADD 151 +#define IDD_ADD_VIEW_2 151 +#define IDS_SCAN_FOLDER_IN_BACKGROUND 152 +#define IDS_FOLDER_NAME_IS_INCORRECT 153 +#define IDS_INCORRECT_FOLDER_NAME 154 +#define IDS_WILLS_UBER_STRING 155 +#define IDS_EDIT_SMART_VIEW 156 +#define IDB_NEWFILTER_SIMPLE 157 +#define IDS_ADVANCED_MODE 157 +#define IDB_NEWFILTER_THREEFILTERS 158 +#define IDS_SIMPLE_MODE 158 +#define IDB_NEWFILTER_TWOFILTERS 159 +#define IDS_DAYS 159 +#define IDB_NEWFILTER_SIMPLEALBUM 160 +#define IDS_LENGTH_DURATION_STRING 160 +#define IDS_ITEM 161 +#define IDD_ADD_VIEW_2_NF 162 +#define IDS_ITEMS 162 +#define IDD_ADD_VIEW_CHILD_ADVANCED 163 +#define IDS_SCANNING_PLAIN 163 +#define IDS_ALL_ARTISTS 164 +#define IDS_ARTIST_INDEX 165 +#define IDB_TOOL_MODE 165 +#define IDS_ALBUM_ARTIST_INDEX 166 +#define IDB_TOOL_ART 166 +#define IDS_CUSTOM 167 +#define IDB_TOOL_COLS 167 +#define IDS_IS_VIDEO 168 +#define IDS_FILE_SIZE_KB 169 +#define IDR_IMAGE_NOTFOUND 169 +#define IDS_BITRATE_KBPS 170 +#define IDS_DISC_NUMBER 171 +#define IDS_DISCS 172 +#define IDS_TRACKS 173 +#define IDS_EQUALS 174 +#define IDS_DOES_NOT_EQUAL 175 +#define IDS_CONTAINS 176 +#define IDS_DOES_NOT_CONTAIN 177 +#define IDS_IS_ABOVE 178 +#define IDS_IS_BELOW 179 +#define IDS_EQUALS_OR_IS_ABOVE 180 +#define IDS_EQUALS_OR_IS_BELOW 181 +#define IDS_IS_EMPTY 182 +#define IDS_IS_NOT_EMPTY 183 +#define IDS_BEGINS_WITH 184 +#define IDS_ENDS_WITH 185 +#define IDS_IS_SIMILAR_TO 186 +#define IDS_AT 187 +#define IDS_NOT_AT 188 +#define IDS_STRING189 189 +#define IDS_PODCASTS 190 +#define IDS_AUDIO_BY_GENRE 191 +#define IDS_AUDIO_BY_INDEX 192 +#define IDS_60s_MUSIC 193 +#define IDS_70s_MUSIC 194 +#define IDS_80s_MUSIC 195 +#define IDS_90s_MUSIC 196 +#define IDS_00s_MUSIC 197 +#define IDS_ROCK_MUSIC 198 +#define IDS_CLASSICAL_MUSIC 199 +#define IDS_RECORD_LABELS 200 +#define IDS_ALBUMS 201 +#define IDS_ALBUM_ARTISTS 202 +#define IDS_ARTIST_S 203 +#define IDS_COMPOSERS 204 +#define IDS_GENRES 205 +#define IDS_PUBLISHERS 206 +#define IDS_YEARS 207 +#define IDS_ALBUM_ARTIST_INDEXES 208 +#define IDS_ARTIST_INDEXES 209 +#define IDS_PODCAST_CHANNELS 210 +#define IDS_ALL_X_S 211 +#define IDS_NO_S 212 +#define IDS_SIZE 213 +#define IDS_INFO_NAVIGATE_ERROR 214 +#define IDS_NO_IMAGE 214 +#define IDS_AVAILABLE 215 +#define IDS_NO_ARTIST 216 +#define IDS_NO_GENRE 217 +#define IDS_OTHER2 218 +#define IDD_PREFS1 219 +#define IDS_STRING219 219 +#define IDS_CREATE_NEW_SMART_VIEW 219 +#define IDS_SIMPLE_ALBUM 219 +#define IDD_VIEW_DB_ERROR 220 +#define IDS_AUDIO_BUTTON_TT1 220 +#define IDS_AUDIO_BUTTON_TT2 221 +#define IDS_AUDIO_BUTTON_TT3 222 +#define IDS_GET_ALBUM_ART 223 +#define IDS_REFRESH_ALBUM_ART 224 +#define IDS_OPEN_FOLDER 225 +#define IDS_BPM 226 +#define IDS_META_STR 227 +#define IDD_PREFSFR 228 +#define IDS_SMART_STR 228 +#define IDS_GUESS_STR 229 +#define IDS_RECURSE_STR 230 +#define IDS_MORE_ARTIST_INFO 234 +#define IDS_PLAY_RANDOM_ITEM 235 +#define IDS_ENQUEUE_RANDOM_ITEM 236 +#define IDS_LOSSLESS 237 +#define IDS_CATEGORY 238 +#define IDD_VIEW_MINIINFO 239 +#define IDS_CATEGORIES 239 +#define IDS_GENRE_ALT 240 +#define IDS_YEAR_ALT 241 +#define IDD_PREFS3 242 +#define IDS_ALBUM_ARTIST_ALT 242 +#define IDS_ALBUM_GAIN_ALT 243 +#define IDS_PUBLISHER_ALT 244 +#define IDS_COMPOSER_ALT 245 +#define IDS_ARTIST_INDEX_ALT 246 +#define IDD_CUSTCOLUMNS 247 +#define IDS_ALBUM_ARTIST_INDEX_ALT 247 +#define IDS_PODCAST_CHANNEL_ALT 248 +#define IDS_CATEGORY_ALT 249 +#define IDD_SCROLLCHILD 250 +#define IDS_ARTIST_ALT 250 +#define IDD_SCROLLCHILDHOST 251 +#define IDS_ALBUM_ALT 251 +#define IDD_SCROLLCHILDFILTER 252 +#define IDS_KBPS 252 +#define IDD_TIMEEDITOR 253 +#define IDS_RECENTLY_PLAYED_TEXT 253 +#define IDS_PRODUCER 255 +#define IDS_DIRECTOR 256 +#define IDS_PRODUCER_ALT 257 +#define IDS_DIRECTOR_ALT 258 +#define IDS_CODEC 259 +#define IDD_PREFS_METADATA 260 +#define IDS_WIDTH 260 +#define IDS_HEIGHT 261 +#define IDS_DIMENSION 262 +#define IDS_IN_X_SEC 263 +#define IDS_TRACKS_MENU 264 +#define IDS_ERROR_PLG_SELECT_TRACKS 267 +#define IDS_NULLSOFT_PLAYLIST_GENERATOR 268 +#define IDS_VIEW_ALL_FILES_BY 269 +#define IDS_VIEW_ALL_FILES_FROM 270 +#define IDR_DB_ERROR 270 +#define IDR_NDE_ERROR 273 +#define IDS_DATE_ADDED 274 +#define IDS_REFRESH_FILESIZE_DATEADDED 275 +#define IDS_RECENTLY_MODIFIED 276 +#define IDS_FINISHED 277 +#define IDS_REFRESH_MESSAGE 278 +#define IDS_CLOUD 279 +#define IDR_VIEW_ACCELERATORS 279 +#define IDS_CLOUD_SOURCES 280 +#define IDR_QUERY_ACCELERATORS 280 +#define IDS_CLOUD_HIDDEN 281 +#define IDS_TRACK_AVAILABLE 282 +#define IDS_UPLOAD_TO_SOURCE 283 +#define IDS_UPLOADING_TO_SOURCE 284 +#define IDS_STRING140 285 +#define IDD_EDIT_INFO 286 +#define IDD_ADDSTUFF 287 +#define IDS_NO_RATING 516 +#define IDS_X_ITEM_SELECTED 517 +#define IDS_X_ITEMS_SELECTED 518 +#define IDS_UPDATING_FILES 519 +#define IDS_UPDATING_X 520 +#define IDS_ERROR_UPDATING_FILE 521 +#define IDS_INFO_UPDATING_ERROR 522 +#define IDC_LIST1 1000 +#define IDC_LIST2 1001 +#define IDC_EDIT_ARTIST 1002 +#define IDC_LIST3 1002 +#define IDC_CHECK_ARTIST 1003 +#define IDC_CHECK_TITLE 1004 +#define IDC_CHECK_ALBUM 1005 +#define IDC_CLEAR 1005 +#define IDC_QUICKSEARCH 1006 +#define IDC_CHECK_TRACK 1006 +#define IDC_PROGRESS1 1007 +#define IDC_CHECK_GENRE 1007 +#define IDC_STATUS 1008 +#define IDC_CHECK_YEAR 1008 +#define IDC_RECT 1009 +#define IDC_EDIT_TITLE 1009 +#define IDC_EDIT_ALBUM 1010 +#define IDC_EDIT_TRACK 1011 +#define IDC_EDIT_GENRE 1012 +#define IDC_HDELIM 1013 +#define IDC_EDIT_YEAR 1013 +#define IDC_CHECK_COMMENT 1014 +#define IDC_MEDIASTATUS 1015 +#define IDC_EDIT_COMMENT 1015 +#define IDC_BUTTON_PLAY 1016 +#define IDC_CHECK_DISC 1016 +#define IDC_BUTTON_ENQUEUE 1017 +#define IDC_EDIT_DISC 1017 +#define IDC_BUTTON_INFOTOGGLE 1018 +#define IDC_CHECK_ALBUMARTIST 1018 +#define IDC_EDIT_ALBUMARTIST 1019 +#define IDC_BUTTON_CREATEPLAYLIST 1019 +#define IDC_SEARCHCAPTION 1020 +#define IDC_CHECK_PUBLISHER 1020 +#define IDC_EDIT_PUBLISHER 1021 +#define IDC_RESCAN 1022 +#define IDC_CHECK_COMPOSER 1022 +#define IDC_NAME 1023 +#define IDC_EDIT_COMPOSER 1023 +#define IDC_QUERY 1024 +#define IDC_CHECK_CATEGORY 1024 +#define IDC_DIV1 1025 +#define IDC_EDIT_COMPOSER2 1025 +#define IDC_EDIT_CATEGORY 1025 +#define IDC_DIV2 1026 +#define IDC_CHECK_BPM 1026 +#define IDC_EDIT_BPM 1027 +#define IDC_CHECK_RATING 1028 +#define IDC_RADIO1 1029 +#define IDC_RADIO2 1030 +#define IDC_RADIO6 1031 +#define IDC_RADIO_TWOFILTERS 1031 +#define IDC_COMBO1 1032 +#define IDC_RADIO8 1032 +#define IDC_COMBO2 1033 +#define IDC_RADIO_THREEFILTERS 1033 +#define IDC_RADIO3 1035 +#define IDC_RADIO_BELOW 1035 +#define IDC_RADIO_ABOVEOREQUAL 1036 +#define IDC_RADIO_BELOWOREQUAL 1037 +#define IDC_COMBO_FILTER1 1046 +#define IDC_COMBO_FILTER2 1047 +#define IDC_COMBO_FILTER3 1048 +#define IDC_RADIO_FILTERS2 1049 +#define IDC_RADIO_FILTERS3 1050 +#define IDC_HEADER 1051 +#define IDC_STATIC_FILTER3 1051 +#define IDC_CHECK1 1052 +#define IDC_REMEMBER_SEARCH 1053 +#define IDC_CHECK2 1054 +#define IDC_CHECK7 1055 +#define IDC_EDIT2 1056 +#define IDC_STATIC4 1060 +#define IDC_CHECK8 1061 +#define IDC_BUTTON1 1062 +#define IDC_BUTTON3 1063 +#define IDC_STATIC5 1063 +#define IDC_BUTTON4 1064 +#define IDC_BUTTON5 1065 +#define IDC_BUTTON_NOW 1065 +#define IDC_BUTTON2 1066 +#define IDC_BUTTON_QUERYBUILD 1067 +#define IDC_EDIT1 1071 +#define IDC_CHECK3 1076 +#define IDC_CHECK4 1077 +#define IDC_CHECK5 1078 +#define IDC_TAB1 1079 +#define IDC_CHECK6 1087 +#define IDC_TEXT 1090 +#define IDC_RADIO_ISEMPTY 1091 +#define IDC_RADIO_TIMEAGO_Y 1094 +#define IDC_RADIO_TIMEAGO_M 1095 +#define IDC_RADIO_TIMEAGO_W 1096 +#define IDC_RADIO_TIMEAGO_D 1097 +#define IDC_RADIO_TIMEAGO_H 1098 +#define IDC_RADIO_TIMEAGO_MIN 1099 +#define IDC_RADIO_TIMEAGO_S 1100 +#define IDC_EDIT3 1106 +#define IDC_MINUTES 1137 +#define IDC_CHECK_RELATIVE 1139 +#define IDC_CHECK_ABSOLUTE 1140 +#define IDC_DATETIMEPICKER2 1141 +#define IDC_CHECK_TIMEAGO 1143 +#define IDC_CHECK_SELECTIVE 1144 +#define IDC_RADIO_THISYEAR 1146 +#define IDC_RADIO_THISMONTH 1147 +#define IDC_RADIO_YEAR 1148 +#define IDC_RADIO_MONTH 1150 +#define IDC_RADIO_THISDAY 1151 +#define IDC_RADIO_DAY 1152 +#define IDC_EDIT_DAY 1153 +#define IDC_RADIO_THISTIME 1154 +#define IDC_RADIO_TIME 1155 +#define IDC_EDIT_RESULT 1164 +#define IDC_EDIT_QUERY 1165 +#define IDC_STATIC_YEAR 1166 +#define IDC_STATIC_MONTH 1167 +#define IDC_STATIC_DAY 1168 +#define IDC_STATIC_TIME 1169 +#define IDC_STATIC_STRING 1173 +#define IDC_STATIC_ABSOLUTE 1174 +#define IDC_STATIC_RELATIVE 1175 +#define IDC_STATIC_TIMEAGO 1176 +#define IDC_STATIC_SELECTIVE 1177 +#define IDC_EDIT 1178 +#define IDC_DATETIMEPICKER1 1179 +#define IDC_LIST_FIELDS 1180 +#define IDC_RADIO_EQUAL 1181 +#define IDC_RADIO_ABOVE 1182 +#define IDC_RADIO_ISLIKE 1183 +#define IDC_CHECK_NOT 1184 +#define IDC_EDIT_STRING 1185 +#define IDC_DATETIMEPICKER 1187 +#define IDC_EDIT_DATETIME 1187 +#define IDC_EDIT_TIMEAGO 1188 +#define IDC_BUTTON_PICK 1189 +#define IDC_BUTTON_MONTH 1190 +#define IDC_BUTTON_AND 1191 +#define IDC_BUTTON_OR 1192 +#define IDC_STATIC_DATETIME 1197 +#define IDC_STATIC_DIRECTION 1198 +#define IDC_RADIO_AFTER 1199 +#define IDC_RADIO_BEFORE 1200 +#define IDC_RADIO_NOON 1201 +#define IDC_RADIO_MIDNIGHT 1202 +#define IDC_STATIC_QUERYTIME 1203 +#define IDC_RADIO_BEGINS 1204 +#define IDC_RADIO_ENDS 1205 +#define IDC_STATIC_RESULT 1206 +#define IDC_STATIC_QUERY 1207 +#define IDC_STATIC_GENERAL 1208 +#define ID_BUTTON_SENDTOQUERY 1209 +#define IDC_RADIO_CONTAINS 1210 +#define IDC_DEFS 1210 +#define IDC_STATIC_TOTAL 1212 +#define IDC_STATIC_PERCENT 1213 +#define IDC_STATIC_RECOVERED 1214 +#define IDC_PROGRESS_PERCENT 1215 +#define IDC_STATIC_LOST 1216 +#define ID_ADD_FILES 1274 +#define IDC_OP 1275 +#define IDC_CHILDFRAME 1277 +#define IDC_BUTTON_EDITDATETIME 1278 +#define IDC_STATIC_CURDATETIME 1279 +#define IDC_CONFMETA 1288 +#define IDC_STATIC1 1293 +#define IDC_STATIC2 1294 +#define IDC_BUTTON_MIX 1304 +#define IDC_MIXABLE 1305 +#define IDC_CHECK_ATF 1311 +#define IDC_COMBO_FILTER 1312 +#define IDC_REFRESHMETADATA_STATUS 1314 +#define IDC_ALBUMGAIN 1315 +#define IDC_ARTIST_AS_ALBUMARTIST 1316 +#define IDC_FILTERS0 1317 +#define IDC_RADIO_FILTERS0 1317 +#define IDC_STATIC_FILTER2 1318 +#define IDC_RADIO_SIMPLE 1320 +#define IDC_IMAGE_SIMPLEALBUM 1321 +#define IDC_IMAGE_TWOFILTERS 1322 +#define IDC_IMAGE_THREEFILTERS 1323 +#define IDC_STATIC_SIMPLE 1324 +#define IDC_STATIC_SIMPLEALBUM 1325 +#define IDC_STATIC_TWOFILTERS 1326 +#define IDC_STATIC_THREEFILTERS 1327 +#define IDC_RADIO_SIMPLEALBUM 1328 +#define IDC_HIDE_EXTINFO 1329 +#define IDC_COMBO_PRESETS 1330 +#define IDC_STATIC_INFO 1331 +#define IDC_CHECK_SHOWINFO 1332 +#define IDC_STATIC_FILTER 1333 +#define IDC_IMAGE_SIMPLE 1334 +#define IDC_AND 1335 +#define IDC_OR 1336 +#define IDC_BUTTON_MODE 1337 +#define IDC_BUTTON_ARTMODE 1338 +#define IDC_BUTTON_VIEWMODE 1339 +#define IDC_BUTTON_COLUMNS 1340 +#define IDC_BTN_LINK_PROMO 1340 +#define IDC_SPIN1 1341 +#define IDC_IMPORT_ITUNES 1342 +#define IDC_CHECK_DIRECTOR 1343 +#define IDC_EDIT_DIRECTOR 1344 +#define IDC_CHECK_PRODUCER 1345 +#define IDC_EDIT_PRODUCER 1346 +#define IDC_STATIC_QUERYDELAY 1347 +#define IDC_CHECK_PODCAST 1347 +#define IDC_EDIT_QUERYDELAY 1348 +#define IDC_EDIT_PODCAST_CHANNEL 1348 +#define IDC_ERROR_1 1349 +#define IDC_CHECK_PODCAST_CHANNEL 1349 +#define IDC_RESET_DB_ON_ERROR 1352 +#define IDC_DB_ERROR 1353 +#define IDC_COMBO_RATING 1354 +#define IDS_SUBSTANTIVES 2048 +#define IDS_PLAY_ENQ_RND_ALTERNATIVE 2049 +#define ID_MEDIAWND_PLAYSELECTEDFILES 40001 +#define ID_MEDIAWND_ENQUEUESELECTEDFILES 40002 +#define ID_MEDIAWND_REMOVEFROMLIBRARY 40003 +#define ID_AUDIOWND_PLAYSELECTION 40004 +#define ID_AUDIOWND_ENQUEUESELECTION 40005 +#define ID_MEDIAWND_SELECTALL 40006 +#define ID_QUERYWND_EDIT 40007 +#define ID_QUERYWND_DELETE 40008 +#define ID_QUERYMENU_ADDNEWQUERY 40009 +#define ID_QUERYWND_PLAYQUERY 40010 +#define ID_QUERYWND_ENQUEUEQUERY 40011 +#define ID_EDITITEMINFOS 40012 +#define ID_MEDIAWND_ADDTOPLAYLIST 40033 +#define ID_MEDIAWND_EXPLOREFOLDER 40037 +#define ID_MEDIAWND_REMOVE_REMOVEALLDEADFILES 40038 +#define ID_MEDIAWND_REMOVE_PHYSICALLYREMOVESELECTEDITEMS 40039 +#define ID_HEADERWND_CUSTOMIZECOLUMNS 40074 +#define ID_RATE_1 40075 +#define ID_RATE_2 40076 +#define ID_RATE_3 40077 +#define ID_RATE_4 40078 +#define ID_RATE_5 40079 +#define ID_RATE_0 40080 +#define IDC_REFRESH_METADATA 40098 +#define ID_FILTERHEADERWND_SHOWHORIZONTALSCROLLBAR 40099 +#define ID_ARTHEADERWND_SMALLICON 40100 +#define ID_ARTHEADERWND_MEDIUMICON 40101 +#define ID_ARTHEADERWND_LARGEICON 40102 +#define ID_ARTHEADERWND_MEDIUMDETAILS 40104 +#define ID_ARTHEADERWND_LARGEDETAILS 40105 +#define ID_ARTHEADERWND_SMALLDETAILS 40106 +#define ID_AUDIOWND_PLAYRANDOMITEM 40108 +#define ID_AUDIOWND_ENQUEUERANDOMITEM 40109 +#define ID_QUERYMENU_PREFERENCES 40110 +#define ID_QUERYMENU_HELP 40111 +#define ID_ARTHEADERWND_EXTRALARGEICON 40112 +#define ID_ARTHEADERWND_SHOWTEXT 40113 +#define ID_PE_ID3 40208 +#define IDS_NULLSOFT_LOCAL_MEDIA 65534 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 281 +#define _APS_NEXT_COMMAND_VALUE 40129 +#define _APS_NEXT_CONTROL_VALUE 1355 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/Src/Plugins/Library/ml_local/resources/icn_alb_art.bmp b/Src/Plugins/Library/ml_local/resources/icn_alb_art.bmp Binary files differnew file mode 100644 index 00000000..2688e2e4 --- /dev/null +++ b/Src/Plugins/Library/ml_local/resources/icn_alb_art.bmp diff --git a/Src/Plugins/Library/ml_local/resources/icn_columns.bmp b/Src/Plugins/Library/ml_local/resources/icn_columns.bmp Binary files differnew file mode 100644 index 00000000..46be6b46 --- /dev/null +++ b/Src/Plugins/Library/ml_local/resources/icn_columns.bmp diff --git a/Src/Plugins/Library/ml_local/resources/icn_view_mode.bmp b/Src/Plugins/Library/ml_local/resources/icn_view_mode.bmp Binary files differnew file mode 100644 index 00000000..60f52169 --- /dev/null +++ b/Src/Plugins/Library/ml_local/resources/icn_view_mode.bmp diff --git a/Src/Plugins/Library/ml_local/resources/nf_simple.bmp b/Src/Plugins/Library/ml_local/resources/nf_simple.bmp Binary files differnew file mode 100644 index 00000000..eaf5b9aa --- /dev/null +++ b/Src/Plugins/Library/ml_local/resources/nf_simple.bmp diff --git a/Src/Plugins/Library/ml_local/resources/nf_simplealbum.bmp b/Src/Plugins/Library/ml_local/resources/nf_simplealbum.bmp Binary files differnew file mode 100644 index 00000000..1d94f00a --- /dev/null +++ b/Src/Plugins/Library/ml_local/resources/nf_simplealbum.bmp diff --git a/Src/Plugins/Library/ml_local/resources/nf_threefilters.bmp b/Src/Plugins/Library/ml_local/resources/nf_threefilters.bmp Binary files differnew file mode 100644 index 00000000..4af1ba08 --- /dev/null +++ b/Src/Plugins/Library/ml_local/resources/nf_threefilters.bmp diff --git a/Src/Plugins/Library/ml_local/resources/nf_twofilters.bmp b/Src/Plugins/Library/ml_local/resources/nf_twofilters.bmp Binary files differnew file mode 100644 index 00000000..2aed6d4f --- /dev/null +++ b/Src/Plugins/Library/ml_local/resources/nf_twofilters.bmp diff --git a/Src/Plugins/Library/ml_local/resources/notfound.png b/Src/Plugins/Library/ml_local/resources/notfound.png Binary files differnew file mode 100644 index 00000000..f76c0516 --- /dev/null +++ b/Src/Plugins/Library/ml_local/resources/notfound.png diff --git a/Src/Plugins/Library/ml_local/resources/ti_audio_16x16x16.bmp b/Src/Plugins/Library/ml_local/resources/ti_audio_16x16x16.bmp Binary files differnew file mode 100644 index 00000000..0fb45741 --- /dev/null +++ b/Src/Plugins/Library/ml_local/resources/ti_audio_16x16x16.bmp diff --git a/Src/Plugins/Library/ml_local/resources/ti_most_played_16x16x16.bmp b/Src/Plugins/Library/ml_local/resources/ti_most_played_16x16x16.bmp Binary files differnew file mode 100644 index 00000000..0d235d66 --- /dev/null +++ b/Src/Plugins/Library/ml_local/resources/ti_most_played_16x16x16.bmp diff --git a/Src/Plugins/Library/ml_local/resources/ti_never_played_16x16x16.bmp b/Src/Plugins/Library/ml_local/resources/ti_never_played_16x16x16.bmp Binary files differnew file mode 100644 index 00000000..d299fda8 --- /dev/null +++ b/Src/Plugins/Library/ml_local/resources/ti_never_played_16x16x16.bmp diff --git a/Src/Plugins/Library/ml_local/resources/ti_podcasts_16x16x16.bmp b/Src/Plugins/Library/ml_local/resources/ti_podcasts_16x16x16.bmp Binary files differnew file mode 100644 index 00000000..428d5b50 --- /dev/null +++ b/Src/Plugins/Library/ml_local/resources/ti_podcasts_16x16x16.bmp diff --git a/Src/Plugins/Library/ml_local/resources/ti_recently_added_16x16x16.bmp b/Src/Plugins/Library/ml_local/resources/ti_recently_added_16x16x16.bmp Binary files differnew file mode 100644 index 00000000..225e45cc --- /dev/null +++ b/Src/Plugins/Library/ml_local/resources/ti_recently_added_16x16x16.bmp diff --git a/Src/Plugins/Library/ml_local/resources/ti_recently_modified_16x16x16.bmp b/Src/Plugins/Library/ml_local/resources/ti_recently_modified_16x16x16.bmp Binary files differnew file mode 100644 index 00000000..4ec00ef0 --- /dev/null +++ b/Src/Plugins/Library/ml_local/resources/ti_recently_modified_16x16x16.bmp diff --git a/Src/Plugins/Library/ml_local/resources/ti_recently_played_16x16x16.bmp b/Src/Plugins/Library/ml_local/resources/ti_recently_played_16x16x16.bmp Binary files differnew file mode 100644 index 00000000..476bde34 --- /dev/null +++ b/Src/Plugins/Library/ml_local/resources/ti_recently_played_16x16x16.bmp diff --git a/Src/Plugins/Library/ml_local/resources/ti_top_rated_16x16x16.bmp b/Src/Plugins/Library/ml_local/resources/ti_top_rated_16x16x16.bmp Binary files differnew file mode 100644 index 00000000..63b5036f --- /dev/null +++ b/Src/Plugins/Library/ml_local/resources/ti_top_rated_16x16x16.bmp diff --git a/Src/Plugins/Library/ml_local/resources/ti_video_16x16x16.bmp b/Src/Plugins/Library/ml_local/resources/ti_video_16x16x16.bmp Binary files differnew file mode 100644 index 00000000..8fccdeef --- /dev/null +++ b/Src/Plugins/Library/ml_local/resources/ti_video_16x16x16.bmp diff --git a/Src/Plugins/Library/ml_local/util.cpp b/Src/Plugins/Library/ml_local/util.cpp new file mode 100644 index 00000000..8ac23b8d --- /dev/null +++ b/Src/Plugins/Library/ml_local/util.cpp @@ -0,0 +1,77 @@ +#include "main.h" +#include "../replicant/nu/ns_wc.h" +#include "ml_local.h" +#include <string.h> +#include <shlobj.h> +#include "..\..\General\gen_ml/config.h" +#include "resource.h" + +extern "C" { + +void process_substantives(wchar_t* dest) +{ + if(!substantives) + { + wchar_t *b = dest; + while (!IsCharSpaceW(*b) && *b) b++; + while (IsCharSpaceW(*b) && *b) b++; + while (!IsCharSpaceW(*b) && *b) b++; + CharLowerW(b); + } +} + +HRESULT ResolveShortCut(HWND hwnd, LPCWSTR pszShortcutFile, LPWSTR pszPath) +{ + IShellLink* psl = 0; + WIN32_FIND_DATA wfd = {0}; + + *pszPath = 0; // assume failure + + HRESULT hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, + IID_IShellLink, (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}; + + hres = ppf->Load(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_DATA *)&wfd, SLGP_SHORTPATH ); + wcsncpy(pszPath, szGotPath, MAX_PATH); + } + } + ppf->Release(); + } + psl->Release(); + } + return SUCCEEDED(hres); +} + +void ConvertRatingMenuStar(HMENU menu, UINT menu_id) +{ + MENUITEMINFOW mi = {sizeof(mi), MIIM_DATA | MIIM_TYPE, MFT_STRING}; + wchar_t rateBuf[32], *rateStr = rateBuf; + mi.dwTypeData = rateBuf; + mi.cch = 32; + if(GetMenuItemInfoW(menu, menu_id, FALSE, &mi)) + { + while(rateStr && *rateStr) + { + if(*rateStr == L'*') *rateStr = L'\u2605'; + rateStr=CharNextW(rateStr); + } + SetMenuItemInfoW(menu, menu_id, FALSE, &mi); + } +} + +};
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/version.rc2 b/Src/Plugins/Library/ml_local/version.rc2 new file mode 100644 index 00000000..104d3186 --- /dev/null +++ b/Src/Plugins/Library/ml_local/version.rc2 @@ -0,0 +1,39 @@ + +///////////////////////////////////////////////////////////////////////////// +// +// Version +// +#include "../../../Winamp/buildType.h" +VS_VERSION_INFO VERSIONINFO + FILEVERSION 3,35,0,0 + PRODUCTVERSION WINAMP_PRODUCTVER + FILEFLAGSMASK 0x17L +#ifdef _DEBUG + FILEFLAGS 0x1L +#else + FILEFLAGS 0x0L +#endif + FILEOS 0x4L + FILETYPE 0x2L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904b0" + BEGIN + VALUE "CompanyName", "Winamp SA" + VALUE "FileDescription", "Winamp Media Library Plug-in" + VALUE "FileVersion", "3,35,0,0" + VALUE "InternalName", "Nullsoft Library" + VALUE "LegalCopyright", "Copyright © 2002-2023 Winamp SA" + VALUE "LegalTrademarks", "Nullsoft and Winamp are trademarks of Winamp SA" + VALUE "OriginalFilename", "ml_local.dll" + VALUE "ProductName", "Winamp" + VALUE "ProductVersion", STR_WINAMP_PRODUCTVER + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END diff --git a/Src/Plugins/Library/ml_local/view_audio.cpp b/Src/Plugins/Library/ml_local/view_audio.cpp new file mode 100644 index 00000000..a2068ffa --- /dev/null +++ b/Src/Plugins/Library/ml_local/view_audio.cpp @@ -0,0 +1,2403 @@ +#include "main.h" +#include "api__ml_local.h" +#include "ml_local.h" +#include <windowsx.h> +#include "../nu/listview.h" +#include "resource.h" +#include "..\..\General\gen_ml/config.h" +#include "..\..\General\gen_ml/ml_ipc.h" +#include "..\..\General\gen_ml/ml_ipc_0313.h" +#include "..\..\General\gen_ml/gaystring.h" +#include "../nde/nde_c.h" +#include <shlwapi.h> +#include "SimpleFilter.h" +#include "AlbumFilter.h" +#include "AlbumArtFilter.h" +#include "../replicant/nu/AutoChar.h" +#include "../replicant/nu/AutoWide.h" +#include "../nu/CGlobalAtom.h" +#include <tataki/export.h> +#include <tataki/bitmap/bitmap.h> +#include <tataki/canvas/bltcanvas.h> + +static CGlobalAtom PROPW_DIVDATA(L"DIVDATA"); +#define DELIMSTR "|" +#define LDELIMSTR L"|" + +#define MAX_FILTERS 3 + +ViewFilter *filter[MAX_FILTERS] = {0}; + +int numFilters = 0; +extern void queryStrEscape(const char *raw, GayString &str); +extern void FixAmps(wchar_t *str, size_t size); +static W_ListView m_list1; +static W_ListView m_list2; +static W_ListView m_list3; +static HWND m_media_hwnd; +static HWND m_hwnd; +GayStringW l_query; +static int IPC_LIBRARY_SENDTOMENU; +static int m_sort_by, m_sort_dir, m_sort_which; +static HRGN g_rgnUpdate = NULL; +static int offsetX = 0, offsetY = 0; + +enum +{ + PLAY=0, + ENQUEUE=1, +}; + +#define ARTIST 0x01 +#define ALBUMARTIST 0x02 +#define GENRE 0x03 +#define PUBLISHER 0x04 +#define COMPOSER 0x05 +#define ALBUM 0x06 +#define YEAR 0x07 +#define ARTISTINDEX 0x08 +#define ALBUMARTISTINDEX 0x09 +#define PODCASTCHANNEL 0x0A +#define ALBUMART 0x0B +#define CATEGORY 0x0C +#define DIRECTOR 0x0D +#define PRODUCER 0x0E + +#define MAKEVIEW_3FILTER(a, b, c) (a | (b << 8) | (c << 16)) +#define MAKEVIEW_2FILTER(a, b) (a | (b << 8)) + +static ViewFilter * getFilter(int n, HWND hwndDlg, int dlgitem, C_Config *c) +{ + switch (n) + { + case 0: return new ArtistFilter(); + case 1: return new AlbumArtistFilter(); + case 2: return new GenreFilter(); + case 3: return new PublisherFilter(); + case 4: return new ComposerFilter(); + case 5: return new AlbumFilter(); + case 6: return new YearFilter(); + case 7: return new ArtistIndexFilter(); + case 8: return new AlbumArtistIndexFilter(); + case 9: return new PodcastChannelFilter(); + case 10: return new AlbumArtFilter(hwndDlg,dlgitem,c); + case 11: return new CategoryFilter(); + case 12: return new DirectorFilter(); + case 13: return new ProducerFilter(); + } + return new ArtistFilter(); +} + +const wchar_t *getFilterName(unsigned int filterId, wchar_t *buffer, size_t bufferSize) // for config +{ + const int filterNames[] = + { + IDS_ARTIST, + IDS_ALBUM_ARTIST, + IDS_GENRE, + IDS_PUBLISHER, + IDS_COMPOSER, + IDS_ALBUM, + IDS_YEAR, + IDS_ARTIST_INDEX, + IDS_ALBUM_ARTIST_INDEX, + IDS_PODCAST_CHANNEL, + IDS_ALBUM_ART, + IDS_CATEGORY, + IDS_DIRECTOR, + IDS_PRODUCER, + }; + + if (filterId >= ARRAYSIZE(filterNames)) + return NULL; + + return WASABI_API_LNGSTRINGW_BUF(filterNames[filterId], buffer, bufferSize); +} + +static void mysearchCallbackAlbumUpdate(itemRecordW *items, int numitems, int user32, int *killswitch) +{ + if (killswitch && *killswitch) return; + + // user32 specifies whether or not to bother with rebuilding artist list + if (user32 == 2 && numFilters == 2) return; + + if (user32 <= 2 && numFilters >= 3) + filter[2]->Fill(items,numitems,killswitch,0); + + if (user32 <= 1 && numFilters >= 2) + filter[1]->Fill(items,numitems,killswitch,numFilters >= 3 ? filter[2]->numGroups : 0); + + if (user32 == 0 && numFilters >= 1) + filter[0]->Fill(items, numitems, killswitch,numFilters >= 2 ? filter[1]->numGroups : 0); + + PostMessage(m_hwnd, WM_APP + 3, 0x69, user32); +} + +static int makeFilterQuery(GayStringW *query, ViewFilter *f) +{ + int ret = 0; + if (!(f->list->GetSelected(0) && f->HasTopItem())) + { + int c = f->list->GetCount(); + int selCount = SendMessageW(f->list->getwnd(), LVM_GETSELECTEDCOUNT, 0, 0L); + + if (selCount && ((f->HasTopItem()) ? selCount < (c - 1) : selCount < c)) + { + int needor = 0, needclose = 0; + for (int x = f->HasTopItem()?1:0; x < c; x ++) + { + if (f->list->GetSelected(x)) + { + if (needor) + query->Append(L"|"); + else + { + if (query->Get()[0]) + query->Append(L"&("); + else + query->Set(L"("); + needclose = 1; + } + if (!f->MakeFilterQuery(x,query)) + { + const wchar_t *val = f->GetText(x); + if (val && *val) + { + query->Append(f->GetField()); + query->Append(L" "); + query->Append(f->GetComparisonOperator()); + query->Append(L" \""); + GayStringW escaped; + queryStrEscape(val, escaped); + query->Append(escaped.Get()); + query->Append(L"\""); + } + else + { + const wchar_t *field = f->GetField(); + query->Append(field); + query->Append(L" = \"\" | "); + query->Append(field); + query->Append(L" ISEMPTY"); + } + } + ret++; + needor = 1; + } + } + if (needclose) query->Append(L")"); + } + } + return ret; +} + +static void getParentPlusSearchQuery(GayStringW *gs) +{ + extern wchar_t* m_query; + wchar_t *parq = m_query; + + if (parq && parq[0]) + { + gs->Set(L"("); + gs->Append(parq); + gs->Append(L")"); + } + else gs->Set(L""); + + GayStringW query; + wchar_t buf[2048] = {0}; + GetWindowTextW(GetDlgItem(m_hwnd, IDC_QUICKSEARCH), buf, ARRAYSIZE(buf)); + if (buf[0]) makeQueryStringFromText(&query, buf); + + if (query.Get() && query.Get()[0]) + { + if (gs->Get()[0]) + { + gs->Append(L" & ("); + gs->Append(query.Get()); + gs->Append(L")"); + } + else gs->Set(query.Get()); + } +} + + +static void playList(int enqueue, int pane) +{ + GayStringW query; + getParentPlusSearchQuery(&query); + + for (int i=0; i<=pane; i++) + makeFilterQuery(&query,filter[i]); + + if (!g_table) return; + + main_playQuery(g_view_metaconf, query.Get(), enqueue); +} + +static void playRandomList(int enqueue, int pane) +{ + static int inited = 0; + if (!inited) + srand((unsigned)(time(0))); + inited = 1; + int n; + n = filter[pane]->list->GetCount() * rand()/RAND_MAX; + // Martin> dunno if we should display the results in ML then? atm we are + filter[pane]->list->UnselectAll(); + filter[pane]->list->SetSelected(n); + filter[pane]->list->ScrollTo(n); + playList(enqueue, pane); +} + +static void buildRecordListW(itemRecordListW *obj, int pane) +{ + GayStringW query; + getParentPlusSearchQuery(&query); + + for (int i=0; i<=pane; i++) + makeFilterQuery(&query,filter[i]); + + if (!g_table) return; + + EnterCriticalSection(&g_db_cs); + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + NDE_Scanner_Query(s, query.Get()); + saveQueryToListW(g_view_metaconf, s, obj, 0, 0, (resultsniff_funcW)-1); + NDE_Table_DestroyScanner(g_table, s); + LeaveCriticalSection(&g_db_cs); +} + +void UpdateRating_RowCache(const wchar_t *filename, int new_rating); +static bool rateList(int rate) +{ + GayStringW query; + getParentPlusSearchQuery(&query); + int valid = 0; + for (int i=0; i<numFilters; i++) + valid += makeFilterQuery(&query,filter[i]); + + if (valid) + { + EnterCriticalSection(&g_db_cs); + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + NDE_Scanner_Query(s, query.Get()); + NDE_Scanner_First(s); + do + { + nde_field_t f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_FILENAME); + if (!f) break; + // get filename here as calling later fails due to the edit for some reason + // as was being called directly in the updateFileInfo(..) call previously.. + wchar_t *filename = NDE_StringField_GetString(f); + if (!filename) break; + // update before, so we can take advantage of row cache pointer equality (sometimes) + UpdateRating_RowCache(filename, rate); + NDE_Scanner_Edit(s); + db_setFieldInt(s, MAINTABLE_ID_RATING, rate); + NDE_Scanner_Post(s); + if (g_config->ReadInt(L"writeratings", 0)) + { + wchar_t buf[64] = {0}; + if (rate > 0) + { + wsprintfW(buf, L"%d", rate); + } + else + buf[0] = 0; + + updateFileInfo(filename, DB_FIELDNAME_rating, buf); + SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_WRITE_EXTENDED_FILE_INFO); + } + + g_table_dirty++; + } + while (NDE_Scanner_Next(s)); + + NDE_Table_DestroyScanner(g_table, s); + if (g_table_dirty) NDE_Table_Sync(g_table); + g_table_dirty = 0; + LeaveCriticalSection(&g_db_cs); + + // refresh media list +// SendMessage(m_media_hwnd, WM_APP + 1, (WPARAM)0, (LPARAM)0); + return true; + } + return false; +} + +static LRESULT CALLBACK div_newWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); +typedef void (WINAPI *DIVIDERMOVED)(HWND, INT, LPARAM); +typedef struct _DIVIDER +{ + BOOL fVertical; + DIVIDERMOVED callback; + LPARAM param; + WNDPROC fnOldProc; + BOOL fUnicode; + INT clickoffs; + +} DIVIDER; + +BOOL AttachDivider(HWND hwnd, BOOL fVertical, DIVIDERMOVED callback, LPARAM param) +{ + if (!hwnd) return FALSE; + + DIVIDER *pd = (DIVIDER*)calloc(1, sizeof(DIVIDER)); + if (!pd) return FALSE; + + pd->fUnicode = IsWindowUnicode(hwnd); + pd->fnOldProc = (WNDPROC)((pd->fUnicode) ? SetWindowLongPtrW(hwnd, GWLP_WNDPROC, (LONG_PTR)div_newWndProc) : + SetWindowLongPtrA(hwnd, GWLP_WNDPROC, (LONG_PTR)div_newWndProc)); + if (!pd->fnOldProc || !SetPropW(hwnd, PROPW_DIVDATA, pd)) + { + free(pd); + return FALSE; + } + pd->fVertical = fVertical; + pd->param = param; + pd->callback = callback; + + return TRUE; +} +#define GET_DIVIDER(hwnd) (DIVIDER*)GetPropW(hwnd, PROPW_DIVDATA) + +static LRESULT CALLBACK div_newWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + DIVIDER *pd; + pd = GET_DIVIDER(hwnd); + if (!pd) return (IsWindowUnicode(hwnd)) ? DefWindowProcW(hwnd, uMsg, wParam, lParam) : DefWindowProcA(hwnd, uMsg, wParam, lParam); + + switch (uMsg) + { + case WM_DESTROY: + RemovePropW(hwnd, PROPW_DIVDATA); + (pd->fUnicode) ? CallWindowProcW(pd->fnOldProc, hwnd, uMsg, wParam, lParam) : CallWindowProcA(pd->fnOldProc, hwnd, uMsg, wParam, lParam); + (pd->fUnicode) ? SetWindowLongPtrW(hwnd, GWLP_WNDPROC, (LONG_PTR)pd->fnOldProc) : SetWindowLongPtrA(hwnd, GWLP_WNDPROC, (LONG_PTR)pd->fnOldProc); + free(pd); + return 0; + case WM_LBUTTONDOWN: + pd->clickoffs = (pd->fVertical) ? LOWORD(lParam) : HIWORD(lParam); + SetCapture(hwnd); + break; + case WM_LBUTTONUP: + ReleaseCapture(); + break; + case WM_SETCURSOR: + SetCursor(LoadCursor(NULL, (pd->fVertical) ? IDC_SIZEWE : IDC_SIZENS)); + return TRUE; + + case WM_MOUSEMOVE: + { + RECT rw; + GetWindowRect(hwnd, &rw); + GetCursorPos(((LPPOINT)&rw) + 1); + (pd->fVertical) ? rw.right -= pd->clickoffs : rw.bottom -= pd->clickoffs; + + if ((pd->fVertical && rw.left != rw.right) || (!pd->fVertical && rw.top != rw.bottom)) + { + MapWindowPoints(HWND_DESKTOP, GetParent(hwnd), ((LPPOINT)&rw) + 1, 1); + if (pd->callback) pd->callback(hwnd, (pd->fVertical) ? rw.right : rw.bottom, pd->param); + } + } + break; + } + + return (pd->fUnicode) ? CallWindowProcW(pd->fnOldProc, hwnd, uMsg, wParam, lParam) : CallWindowProcA(pd->fnOldProc, hwnd, uMsg, wParam, lParam); +} + +static int m_nodrawtopborders; +static int adiv1_nodraw, adiv2_nodraw; + +#define DIVIDER_FILTER 0x1 +#define DIVIDER_FILTER2 0x3 +#define DIVIDER_MEDIA 0x2 + +static int div_filterpos, div_filter2pos, div_mediapos; +static BOOL g_displaysearch = TRUE; + +typedef struct _LAYOUT +{ + INT id; + HWND hwnd; + INT x; + INT y; + INT cx; + INT cy; + DWORD flags; + HRGN rgn; + BOOL *pHidden; +}LAYOUT, PLAYOUT; + +typedef struct _LCTRL +{ + INT id; + BOOL hidden; +} LCTRL; + +#define SETLAYOUTPOS(_layout, _x, _y, _cx, _cy) { _layout->x=_x; _layout->y=_y;_layout->cx=_cx;_layout->cy=_cy;_layout->rgn=NULL; } +#define SETLAYOUTFLAGS(_layout, _r) \ + { \ + BOOL fVis; \ + fVis = (WS_VISIBLE & (LONG)GetWindowLongPtr(_layout->hwnd, GWL_STYLE)); \ + if (_layout->x == _r.left && _layout->y == _r.top) _layout->flags |= SWP_NOMOVE; \ + if (_layout->cx == (_r.right - _r.left) && _layout->cy == (_r.bottom - _r.top)) _layout->flags |= SWP_NOSIZE; \ + if (fVis && (_layout->cx < 1 || _layout->cy < 1)) { _layout->flags |= SWP_HIDEWINDOW; *_layout->pHidden = TRUE; } \ + if (!fVis && *_layout->pHidden && _layout->cx > 0 && _layout->cy > 0) { _layout->flags |= SWP_SHOWWINDOW; *_layout->pHidden = FALSE; } \ + if ((SWP_HIDEWINDOW & _layout->flags) && !fVis) _layout->flags &= ~SWP_HIDEWINDOW; \ + if ((SWP_SHOWWINDOW & _layout->flags) && fVis) _layout->flags &= ~SWP_SHOWWINDOW; \ + } +#define LAYOUTNEEEDUPDATE(_layout) ((SWP_NOMOVE | SWP_NOSIZE) != ((SWP_NOMOVE | SWP_NOSIZE | SWP_HIDEWINDOW | SWP_SHOWWINDOW) & _layout->flags)) + +#define GROUP_MIN 0x1 +#define GROUP_MAX 0x3 +#define GROUP_SEARCH 0x1 +#define GROUP_FILTER 0x2 +#define GROUP_MEDIA 0x3 + +static void LayoutWindows(HWND hwnd, BOOL fRedraw) +{ + static LCTRL controls[] = + { + {GROUP_SEARCH, FALSE}, {IDC_BUTTON_ARTMODE, FALSE}, {IDC_BUTTON_VIEWMODE, FALSE}, {IDC_BUTTON_COLUMNS, FALSE}, {IDC_SEARCHCAPTION, FALSE}, {IDC_CLEAR, FALSE}, {IDC_QUICKSEARCH, FALSE}, + {GROUP_MEDIA, FALSE}, {IDC_HDELIM, FALSE}, {IDD_VIEW_MEDIA, FALSE}, + {GROUP_FILTER, FALSE}, {IDC_LIST1, FALSE}, {IDC_DIV1, FALSE}, {IDC_LIST2, FALSE}, {IDC_DIV2, FALSE}, {IDC_LIST3, FALSE} + }; + + INT index, divY, divX, divX2; + RECT rc, rg, ri; + LAYOUT layout[sizeof(controls)/sizeof(controls[0])], *pl; + BOOL skipgroup; + HRGN rgn = NULL; + + GetClientRect(hwnd, &rc); + if (rc.bottom == rc.top || rc.right == rc.left) return; + + SetRect(&rg, rc.left, rc.top, rc.right, rc.top); + + pl = layout; + skipgroup = FALSE; + + divY = (div_mediapos * (rc.bottom- rc.top)) / 100000; + divX = numFilters==1? rc.right : (div_filterpos * (rc.right- rc.left)) / 100000; + divX2 = numFilters==3? (div_filter2pos * (rc.right- rc.left)) / 100000 : rc.right; + + if (divX > divX2 && numFilters==3) + { + div_filterpos=33333; + div_filter2pos=66667; + divX = (div_filterpos * (rc.right- rc.left)) / 100000; + divX2 = (div_filter2pos * (rc.right- rc.left)) / 100000; + } + + InvalidateRect(hwnd, NULL, TRUE); + + for (index = 0; index < sizeof(controls) / sizeof(LCTRL); index++) + { + if (controls[index].id >= GROUP_MIN && controls[index].id <= GROUP_MAX) // group id + { + skipgroup = FALSE; + switch (controls[index].id) + { + case GROUP_SEARCH: + if (g_displaysearch) + { + wchar_t buffer[128] = {0}; + HWND ctrl = GetDlgItem(hwnd, IDC_CLEAR); + GetWindowTextW(ctrl, buffer, ARRAYSIZE(buffer)); + LRESULT idealSize = MLSkinnedButton_GetIdealSize(ctrl, buffer); + + SetRect(&rg, rc.left + WASABI_API_APP->getScaleX(1), + rc.top + WASABI_API_APP->getScaleY(2), + rc.right - WASABI_API_APP->getScaleX(2), + rc.top + WASABI_API_APP->getScaleY(HIWORD(idealSize)+1)); + rc.top = rg.bottom + WASABI_API_APP->getScaleY(3); + } + skipgroup = !g_displaysearch; + break; + + case GROUP_MEDIA: + m_nodrawtopborders = 0; + if (divY > (rc.bottom - WASABI_API_APP->getScaleY(85))) + { + RECT rw; + GetWindowRect(GetDlgItem(hwnd, IDC_HDELIM), &rw); + divY = rc.bottom - (rw.bottom - rw.top); + } + else if (divY < (rc.top + WASABI_API_APP->getScaleY(24))) + { + divY = rc.top; m_nodrawtopborders = 1; + } + + SetRect(&rg, rc.left, divY, rc.right, rc.bottom); + rc.bottom = rg.top; + break; + + case GROUP_FILTER: + if (divX < (rc.left + WASABI_API_APP->getScaleX(15))) + { + divX = rc.left; + adiv1_nodraw = 1; + } + // fixes moving the dividers over to the far right so that the + // 'docking' is consistant in both the two and three pain view + else if (divX > (rc.right - (WASABI_API_APP->getScaleX(17)*(numFilters-1)+(numFilters==2?WASABI_API_APP->getScaleX(10):0)))) + { + RECT rw; + GetWindowRect(GetDlgItem(hwnd, IDC_DIV1), &rw); + divX = rc.right - (rw.right - rw.left)*(numFilters-1); + adiv1_nodraw = 2; + } + else adiv1_nodraw = 0; + + if (divX2 < (rc.left + WASABI_API_APP->getScaleX(15)*(numFilters-2))) + { + divX2 = rc.left; + adiv2_nodraw = 1; + } + else if (divX2 > (rc.right - WASABI_API_APP->getScaleX(18*2))) + { + RECT rw; + GetWindowRect(GetDlgItem(hwnd, IDC_DIV2), &rw); + divX2 = rc.right - (rw.right - rw.left); + adiv2_nodraw = 2; + } + else adiv2_nodraw = 0; + + SetRect(&rg, rc.left, rc.top, rc.right, rc.bottom); + break; + } + continue; + } + if (skipgroup) continue; + + pl->id = controls[index].id; + pl->hwnd = GetDlgItem(hwnd, pl->id); + pl->pHidden = &controls[index].hidden; + if (!pl->hwnd) continue; + + GetWindowRect(pl->hwnd, &ri); + MapWindowPoints(HWND_DESKTOP, hwnd, (LPPOINT)&ri, 2); + pl->flags = SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREDRAW | SWP_NOCOPYBITS; + + switch (pl->id) + { + case IDC_BUTTON_ARTMODE: + if(numFilters == 1) + { + SETLAYOUTPOS(pl, 0, 0, 0, 0); + break; + } + case IDC_BUTTON_VIEWMODE: + case IDC_BUTTON_COLUMNS: + pl->flags |= (rg.top < rg.bottom) ? SWP_SHOWWINDOW : SWP_HIDEWINDOW; + SETLAYOUTPOS(pl, rg.left, rg.top, (ri.right - ri.left), (rg.bottom - rg.top)); + if (SWP_SHOWWINDOW & pl->flags) rg.left += (pl->cx + WASABI_API_APP->getScaleX(1)); + break; + case IDC_SEARCHCAPTION: + { + wchar_t buffer[128] = {0}; + GetWindowTextW(pl->hwnd, buffer, ARRAYSIZE(buffer)); + LRESULT idealSize = MLSkinnedStatic_GetIdealSize(pl->hwnd, buffer); + + SETLAYOUTPOS(pl, rg.left + WASABI_API_APP->getScaleX(6), + rg.top + WASABI_API_APP->getScaleY(1), + WASABI_API_APP->getScaleX(LOWORD(idealSize)), + (rg.bottom - rg.top)); + rg.left += (pl->cx + WASABI_API_APP->getScaleX(8)); + break; + } + case IDC_CLEAR: + { + wchar_t buffer[128] = {0}; + GetWindowTextW(pl->hwnd, buffer, ARRAYSIZE(buffer)); + LRESULT idealSize = MLSkinnedButton_GetIdealSize(pl->hwnd, buffer); + LONG width = LOWORD(idealSize) + WASABI_API_APP->getScaleX(6); + pl->flags |= (((rg.right - rg.left) - width) > WASABI_API_APP->getScaleX(40)) ? SWP_SHOWWINDOW : SWP_HIDEWINDOW; + SETLAYOUTPOS(pl, rg.right - width, rg.top, width, (rg.bottom - rg.top)); + if (SWP_SHOWWINDOW & pl->flags) rg.right -= (pl->cx + WASABI_API_APP->getScaleX(4)); + break; + } + case IDC_QUICKSEARCH: + pl->flags |= (rg.right > rg.left) ? SWP_SHOWWINDOW : SWP_HIDEWINDOW; + SETLAYOUTPOS(pl, rg.left, rg.top, rg.right - rg.left - WASABI_API_APP->getScaleX(1), + (rg.bottom - rg.top) - WASABI_API_APP->getScaleY(1)); + break; + case IDC_LIST1: + SETLAYOUTPOS(pl, rg.left + WASABI_API_APP->getScaleX(1), + rg.top + WASABI_API_APP->getScaleY(1), + (numFilters == 1 ? rg.right - rg.left - WASABI_API_APP->getScaleX(3) : divX), + (rg.bottom - rg.top) - WASABI_API_APP->getScaleY(1)); + rg.left += pl->cx; + break; + case IDC_DIV1: + SETLAYOUTPOS(pl, rg.left, rg.top + WASABI_API_APP->getScaleY(1), ri.right - ri.left, (rg.bottom - rg.top)); + rg.left += pl->cx; + break; + case IDC_LIST2: + if (numFilters == 3) + { + SETLAYOUTPOS(pl, rg.left, rg.top + WASABI_API_APP->getScaleY(1), divX2 - rg.left, (rg.bottom - rg.top) - WASABI_API_APP->getScaleY(1)); + } + else + { + SETLAYOUTPOS(pl, rg.left, rg.top + WASABI_API_APP->getScaleY(1), (rg.right - rg.left) - WASABI_API_APP->getScaleX(3), (rg.bottom - rg.top) - WASABI_API_APP->getScaleY(1)); + } + rg.left += pl->cx; + break; + case IDC_DIV2: + SETLAYOUTPOS(pl, rg.left, rg.top + WASABI_API_APP->getScaleY(1), ri.right - ri.left, (rg.bottom - rg.top)); + rg.left += pl->cx; + break; + case IDC_LIST3: + SETLAYOUTPOS(pl, rg.left, rg.top + WASABI_API_APP->getScaleY(1), (rg.right - rg.left) - WASABI_API_APP->getScaleX(3), (rg.bottom - rg.top) - WASABI_API_APP->getScaleY(1)); + break; + case IDC_HDELIM: + SETLAYOUTPOS(pl, rg.left, rg.top, rg.right - rg.left - WASABI_API_APP->getScaleX(2), (ri.bottom - ri.top)); + rg.top += pl->cy; + break; + case IDD_VIEW_MEDIA: + pl->flags |= (rg.top < rg.bottom) ? SWP_SHOWWINDOW : SWP_HIDEWINDOW; + if ((SWP_HIDEWINDOW & pl->flags) && !IsWindowVisible(pl->hwnd)) continue; + SETLAYOUTPOS(pl, rg.left, rg.top, rg.right - rg.left, (rg.bottom - rg.top)); + break; + } + + SETLAYOUTFLAGS(pl, ri); + if (LAYOUTNEEEDUPDATE(pl)) + { + if (SWP_NOSIZE == ((SWP_HIDEWINDOW | SWP_SHOWWINDOW | SWP_NOSIZE) & pl->flags) && + ri.left == (pl->x + offsetX) && ri.top == (pl->y + offsetY) && IsWindowVisible(pl->hwnd)) + { + SetRect(&ri, pl->x, pl->y, pl->cx + pl->x, pl->y + pl->cy); + ValidateRect(hwnd, &ri); + } + pl++; + } + else if ((fRedraw || (!offsetX && !offsetY)) && IsWindowVisible(pl->hwnd)) + { + ValidateRect(hwnd, &ri); + if (GetUpdateRect(pl->hwnd, NULL, FALSE)) + { + if (!rgn) rgn = CreateRectRgn(0,0,0,0); + GetUpdateRgn(pl->hwnd, rgn, FALSE); + OffsetRgn(rgn, pl->x, pl->y); + InvalidateRgn(hwnd, rgn, FALSE); + } + } + } + + if (pl != layout) + { + LAYOUT *pc; + HDWP hdwp = BeginDeferWindowPos((INT)(pl - layout)); + for (pc = layout; pc < pl && hdwp; pc++) + { + if (IDD_VIEW_MEDIA == pc->id) + { + SetRect(&ri, pc->x, pc->y, pc->x + pc->cx, pc->y + pc->cy); + ValidateRect(hwnd, &ri); + pc->rgn = CreateRectRgn(0, 0, pc->cx, pc->cy); + GetWindowRect(pc->hwnd, &ri); + MapWindowPoints(HWND_DESKTOP, hwnd, (LPPOINT)&ri, 1); + SendMessage(pc->hwnd, WM_USER + 0x201, MAKEWPARAM(offsetX + (pc->x - ri.left), offsetY + (pc->y - ri.top)), (LPARAM)pc->rgn); + } + hdwp = DeferWindowPos(hdwp, pc->hwnd, NULL, pc->x, pc->y, pc->cx, pc->cy, pc->flags); + } + if (hdwp) EndDeferWindowPos(hdwp); + + if (!rgn) rgn = CreateRectRgn(0,0,0,0); + + for (pc = layout; pc < pl && hdwp; pc++) + { + switch (pc->id) + { + case IDD_VIEW_MEDIA: + SendMessage(pc->hwnd, WM_USER + 0x201, 0, 0L); + break; + } + } + + if (fRedraw) + { + GetUpdateRgn(hwnd, rgn, FALSE); + for (pc = layout; pc < pl && hdwp; pc++) + { + if (pc->rgn) + { + OffsetRgn(pc->rgn, pc->x, pc->y); + CombineRgn(rgn, rgn, pc->rgn, RGN_OR); + } + } + RedrawWindow(hwnd, NULL, rgn, RDW_INVALIDATE | RDW_UPDATENOW | RDW_NOERASE | RDW_NOINTERNALPAINT | RDW_ALLCHILDREN); + } + if (g_rgnUpdate) + { + GetUpdateRgn(hwnd, g_rgnUpdate, FALSE); + for (pc = layout; pc < pl && hdwp; pc++) + { + if (pc->rgn) + { + OffsetRgn(pc->rgn, pc->x, pc->y); + CombineRgn(g_rgnUpdate, g_rgnUpdate, pc->rgn, RGN_OR); + } + } + } + + for (pc = layout; pc < pl && hdwp; pc++) + if (pc->rgn) DeleteObject(pc->rgn); + } + + if (rgn) DeleteObject(rgn); + ValidateRgn(hwnd, NULL); +} + +static void WINAPI OnDividerMoved(HWND hwnd, INT nPos, LPARAM param) +{ + RECT rc; + HWND hwndParent; + hwndParent = GetParent(hwnd); + if (hwndParent) + { + GetClientRect(hwndParent, &rc); + switch ((INT)param) + { + case DIVIDER_FILTER: + div_filterpos = (nPos * 100000) / (rc.right - rc.left); + if (div_filterpos + 500 > div_filter2pos) div_filter2pos = div_filterpos+500; + break; + case DIVIDER_FILTER2: + div_filter2pos = (nPos * 100000) / (rc.right - rc.left); + if (div_filter2pos - 500 < div_filterpos) div_filterpos = div_filter2pos-500; + break; + case DIVIDER_MEDIA: + div_mediapos = (nPos * 100000) / (rc.bottom - rc.top); + break; + } + LayoutWindows(hwndParent, TRUE); + } +} + +static int ignore_selections; + +//returns true if a selection has been set which needs to be propagated to the next pane +static bool UpdateFilterPane(int pane, char* selconfigname) +{ + filter[pane]->SortResults(g_view_metaconf, pane, 0); + + ListView_SetItemCount(filter[pane]->list->getwnd(), filter[pane]->Size()); + InvalidateRect(filter[pane]->list->getwnd(), NULL, TRUE); + + ignore_selections = 1; + char *_selstr = g_config->ReadInt(L"remembersearch", 0) ? g_view_metaconf->ReadString(selconfigname, "") : NULL; + wchar_t * selstr = AutoWide(_selstr, CP_UTF8); + int a = 0; + if (selstr && *selstr) + { + int len = (wcslen(selstr) + 2); + wchar_t *t = (wchar_t*)calloc(len, sizeof(wchar_t)); + wcsncpy(t, selstr, len); + g_view_metaconf->WriteString(selconfigname, ""); + + t[wcslen(t)+1] = 0; + wchar_t *outp = t; + wchar_t *inp = t; + while (inp && *inp) + { + if (*inp == *LDELIMSTR) + { + if (inp[1] == *LDELIMSTR) + { + *outp++ = *LDELIMSTR; // unescape the output + inp += 2; + } + else + { + *outp++ = 0; inp++; + } + } + else *outp++ = *inp++; + } + *outp = 0; + + int x; + for (x = 1; x < filter[pane]->Size(); x ++) + { + wchar_t *p = t; + while (p && *p) + { + if (!lstrcmpiW(filter[pane]->GetText(x), p)) break; + p += wcslen(p) + 1; + } + if (p && *p) + { + if (!a) + { + ListView_SetSelectionMark(filter[pane]->list->getwnd(), x); + ListView_SetItemState(filter[pane]->list->getwnd(), x, LVIS_FOCUSED, LVIS_FOCUSED); + ListView_EnsureVisible(filter[pane]->list->getwnd(), x, NULL); + } + a++; + filter[pane]->list->SetSelected(x); + } + } + free(t); + } + if (a) + { + ignore_selections = 0; + return true; + } + else + { + wchar_t buf[1024] = {0}; + GetDlgItemText(m_media_hwnd, IDC_QUICKSEARCH, buf, sizeof(buf)); + if (buf[0]) + { + ignore_selections = 0; + l_query.Set(L""); // force refresh + } + if(filter[pane]->HasTopItem()) + filter[pane]->list->SetSelected(0); + ignore_selections = 0; + return false; + } +} + +HBITMAP ConvertTo24bpp(HBITMAP bmp, int bpp) +{ + HDC hdcMem, hdcMem2; + HBITMAP hbm24; + BITMAP bm; + + GetObjectW(bmp, sizeof(BITMAP), &bm); + + hdcMem = CreateCompatibleDC(0); + hdcMem2 = CreateCompatibleDC(0); + + void *bits; + BITMAPINFOHEADER bi; + + ZeroMemory(&bi, sizeof(bi)); + bi.biSize = sizeof(bi); + bi.biWidth= bm.bmWidth; + bi.biHeight = -bm.bmHeight; + bi.biPlanes = 1; + bi.biBitCount= (WORD)bpp; + + hbm24 = CreateDIBSection(hdcMem2, (BITMAPINFO *)&bi, DIB_RGB_COLORS, &bits, NULL, NULL); + + HBITMAP oBmp = (HBITMAP)SelectObject(hdcMem, bmp); + HBITMAP oBmp24 = (HBITMAP)SelectObject(hdcMem2, hbm24); + + BitBlt(hdcMem2, 0, 0, bm.bmWidth, bm.bmHeight, hdcMem, 0, 0, SRCCOPY); + + SelectObject(hdcMem, oBmp); + SelectObject(hdcMem2, oBmp24); + + DeleteDC(hdcMem); + DeleteDC(hdcMem2); + + + return hbm24; +} + +static __forceinline BYTE pm(int a, int b) +{ + return (BYTE)((a * b) / 0xff); +} + +void SetToolbarButtonBitmap(HWND hwndDlg, int buttonrc, int bitmaprc, ARGB32 fc) +{ + // benski> we could use this if it wasn't for the lack of WASABI_API_IMGLDR on classic skin + // even though we have the resource loader ... + // SkinBitmap *sbm = new SkinBitmap( bitmaprc); + HBITMAP hbm1 = (HBITMAP)LoadImage(plugin.hDllInstance,MAKEINTRESOURCE(bitmaprc),IMAGE_BITMAP,0,0,LR_VGACOLOR); + HBITMAP hbm = ConvertTo24bpp(hbm1,32); + DeleteObject(hbm1); + BITMAP bm; + GetObjectW(hbm, sizeof(BITMAP), &bm); + int l = bm.bmWidth * bm.bmHeight; + ARGB32 *x = (ARGB32*)bm.bmBits; + ARGB32 *end = x+l; + BYTE r = (BYTE)(fc & 0x00ff0000 >> 16); + BYTE g = (BYTE)(fc & 0x0000ff00 >> 8); + BYTE b = (BYTE)(fc & 0x000000ff); + while (x < end) + { + BYTE a = (BYTE)((~(*x))&0xff); + *(x++) = (a<<24) | (pm(r,a)<<16) | (pm(g,a)<<8) | pm(b,a); + } + + void * mem = malloc(bm.bmWidth*bm.bmHeight*sizeof(ARGB32)); + memcpy(mem,bm.bmBits,bm.bmWidth*bm.bmHeight*sizeof(ARGB32)); + + SkinBitmap *sbm = new SkinBitmap((ARGB32*)mem,bm.bmWidth,bm.bmHeight); + DeleteObject(hbm); + HWND btn = GetDlgItem(hwndDlg,buttonrc); + if (IsWindow(btn)) + { + SkinBitmap* old = (SkinBitmap*)SetWindowLongPtr(btn,GWLP_USERDATA,(LONG_PTR)sbm); + if (old) + { + if (old->getBits()) free(old->getBits()); delete old; + } + InvalidateRect(btn, NULL, TRUE); + } +} + +int GetFilter(int mode, int n) +{ + if (n==0) return ((mode & 0x0000ff)); + if (n==1) + { + int f=((mode & 0x00ff00) >> 8); if (f) return f; return 6; + } // album + if (n==2) return ((mode & 0xff0000) >> 16); + return 0; +} + +int GetNumFilters(int mode) +{ + if (mode == 0) return 0; + if (mode > 0xffffff) return 1; + if (GetFilter(mode,2) == 0) return 2; + return 3; +} + +typedef struct { int id, id2; } hi; + +//extern "C" +//{ +//void __cdecl do_help(HWND hwnd, UINT id, HWND hTooltipWnd); + +void do_help(HWND hwnd, UINT id, HWND hTooltipWnd) +{ + RECT r; + POINT p; + GetWindowRect(GetDlgItem(hwnd, id), &r); + GetCursorPos(&p); + if (p.x >= r.left && p.x < r.right && p.y >= r.top && p.y < r.bottom) + {} + else + { + r.left += r.right; + r.left /= 2; + r.top += r.bottom; + r.top /= 2; + SetCursorPos(r.left, r.top); + } + SendMessage(hTooltipWnd, TTM_SETDELAYTIME, TTDT_INITIAL, 0); + SendMessage(hTooltipWnd, TTM_SETDELAYTIME, TTDT_RESHOW, 0); +} + +#define C_BLAH +#define DO_HELP() \ + static HWND hTooltipWnd; \ + C_BLAH \ + if (uMsg == WM_HELP) { \ + HELPINFO *hi=(HELPINFO *)(lParam); \ + if (hi->iContextType == HELPINFO_WINDOW) { do_help(hwndDlg,hi->iCtrlId,hTooltipWnd);} \ + return TRUE; \ + } \ + if (uMsg == WM_NOTIFY) { LPNMHDR t=(LPNMHDR)lParam; if (t->code == TTN_POP) { SendMessage(hTooltipWnd,TTM_SETDELAYTIME,TTDT_INITIAL,1000); SendMessage(hTooltipWnd,TTM_SETDELAYTIME,TTDT_RESHOW,1000); } } \ + if (uMsg == WM_DESTROY && IsWindow(hTooltipWnd)) { DestroyWindow(hTooltipWnd); hTooltipWnd=NULL; } \ + if (uMsg == WM_INITDIALOG) { \ + int x; \ + hTooltipWnd = CreateWindow(TOOLTIPS_CLASS,(LPCWSTR)NULL,TTS_ALWAYSTIP|TTS_NOPREFIX, \ + CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT, hwndDlg,NULL,GetModuleHandle(NULL),NULL); \ + SendMessage(hTooltipWnd,TTM_SETMAXTIPWIDTH,0,587); \ + SendMessage(hTooltipWnd,TTM_SETDELAYTIME,TTDT_INITIAL,250); \ + SendMessage(hTooltipWnd,TTM_SETDELAYTIME,TTDT_RESHOW,500); \ + for (x = 0; x < sizeof(helpinfo)/sizeof(helpinfo[0]); x ++) { \ + TOOLINFO ti; ti.cbSize = sizeof(ti); ti.uFlags = TTF_SUBCLASS|TTF_IDISHWND; \ + ti.uId=(UINT_PTR)GetDlgItem(hwndDlg,helpinfo[x].id); ti.hwnd=hwndDlg; ti.lpszText=WASABI_API_LNGSTRINGW(helpinfo[x].id2); \ + SendMessage(hTooltipWnd,TTM_ADDTOOL,0,(LPARAM) &ti); \ + } \ + } +//} + +static int refresh; +INT_PTR CALLBACK view_audioDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + static int we_are_drag_and_dropping; + static HMENU sendto_hmenu; + static librarySendToMenuStruct s; + + hi helpinfo[]={ + {IDC_BUTTON_ARTMODE,IDS_AUDIO_BUTTON_TT1}, + {IDC_BUTTON_VIEWMODE,IDS_AUDIO_BUTTON_TT2}, + {IDC_BUTTON_COLUMNS,IDS_AUDIO_BUTTON_TT3}, + }; + DO_HELP(); + + BOOL a = dialogSkinner.Handle(hwndDlg, uMsg, wParam, lParam); if (a) return a; + if (numFilters>=1) + { + a = filter[0]->DialogProc(hwndDlg,uMsg,wParam,lParam); if (a) return a; + } + if (numFilters>=2) + { + a = filter[1]->DialogProc(hwndDlg,uMsg,wParam,lParam); if (a) return a; + } + if (numFilters>=3) + { + a = filter[2]->DialogProc(hwndDlg,uMsg,wParam,lParam); if (a) return a; + } + + switch (uMsg) + { + case WM_INITMENUPOPUP: + if (wParam) + { + if((HMENU)wParam == s.build_hMenu && s.mode == 1) + { + myMenu = TRUE; + if (SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&s, IPC_LIBRARY_SENDTOMENU) == (LRESULT)-1) + s.mode = 2; + myMenu = FALSE; + } + // only populate the average rating when needed otherwise it makes all of the menu slow + else if((HMENU)wParam == GetSubMenu(GetSubMenu(g_context_menus, 1),4)) + { + int ave_rating = 0, valid = 0; + GayStringW query; + getParentPlusSearchQuery(&query); + for (int i=0; i<numFilters; i++) + { + valid += makeFilterQuery(&query,filter[i]); + } + EnterCriticalSection(&g_db_cs); + nde_scanner_t q = NDE_Table_CreateScanner(g_table); + NDE_Scanner_Query(q, query.Get()); + NDE_Scanner_First(q); + int count = 0; + do + { + nde_field_t f = NDE_Scanner_GetFieldByID(q, MAINTABLE_ID_FILENAME); + if (!f) break; + nde_field_t g = NDE_Scanner_GetFieldByID(q, MAINTABLE_ID_RATING); + int nde_rating = NDE_IntegerField_GetValue(g); + if(nde_rating > 0) ave_rating += nde_rating; + count++; + } + while (NDE_Scanner_Next(q)); + + NDE_Table_DestroyScanner(g_table, q); + LeaveCriticalSection(&g_db_cs); + + if(ave_rating > 0) + { + float ave = ave_rating/(count*1.0f); + int diff = ave_rating/count; + int adjust = (ave-diff)>=0.5f; + ave_rating = (int)(ave+adjust); + } + + Menu_SetRatingValue((HMENU)wParam, (valid?ave_rating:-1)); + } + } + return 0; + case WM_DISPLAYCHANGE: + { + ARGB32 fc = dialogSkinner.Color(WADLG_BUTTONFG) & 0x00FFFFFF; + SetToolbarButtonBitmap(hwndDlg,IDC_BUTTON_ARTMODE,IDB_TOOL_ART,fc); + SetToolbarButtonBitmap(hwndDlg,IDC_BUTTON_VIEWMODE,IDB_TOOL_MODE,fc); + SetToolbarButtonBitmap(hwndDlg,IDC_BUTTON_COLUMNS,IDB_TOOL_COLS,fc); + if (IsWindow(m_media_hwnd)) SendNotifyMessageW(m_media_hwnd, WM_DISPLAYCHANGE, wParam, lParam); + UpdateWindow(hwndDlg); + LayoutWindows(hwndDlg, TRUE); + } + return 0; + case WM_INITDIALOG: + { + hwndSearchGlobal = GetDlgItem(hwndDlg, IDC_QUICKSEARCH); // Set the hwnd for the search to a global so we can access it from the media view dialog + ResumeCache(); + int numFilters0=GetNumFilters(m_query_mode); + int f1 = GetFilter(m_query_mode,0); + int f2 = GetFilter(m_query_mode,1); + int f3 = GetFilter(m_query_mode,2); + + filter[0] = getFilter(f1-1,hwndDlg,IDC_LIST1,g_view_metaconf); + filter[0]->list = &m_list1; + filter[0]->nextFilter = NULL; + filter[0]->list->setwnd(GetDlgItem(hwndDlg, IDC_LIST1)); + + if (numFilters0>=2) + { + filter[1] = getFilter(f2-1,hwndDlg,IDC_LIST2,g_view_metaconf); + filter[1]->list = &m_list2; + filter[1]->list->setwnd(GetDlgItem(hwndDlg, IDC_LIST2)); + filter[1]->nextFilter = NULL; + filter[0]->nextFilter = filter[1]; + } + + if (numFilters0>=3) + { + filter[2] = getFilter(f3-1,hwndDlg,IDC_LIST3,g_view_metaconf); + filter[2]->list = &m_list3; + filter[2]->list->setwnd(GetDlgItem(hwndDlg, IDC_LIST3)); + filter[2]->nextFilter = NULL; + filter[1]->nextFilter = filter[2]; + } + numFilters=numFilters0; + + m_hwnd = hwndDlg; + getParentPlusSearchQuery(&l_query); + + for (int j=0; j<numFilters0; j++) + { + filter[j]->list->ForceUnicode(); + filter[j]->AddColumns(); + } + + div_mediapos = g_view_metaconf->ReadInt(L"adiv2pos", 50000); + + if (numFilters == 1) + { + div_filterpos = g_view_metaconf->ReadInt(L"adiv1pos", 100000); + div_filter2pos = -1; + } + else if (numFilters == 2) + { + div_filterpos = g_view_metaconf->ReadInt(L"adiv1pos", 50000); + div_filter2pos = -1; + } + else if (numFilters == 3) + { + div_filterpos = g_view_metaconf->ReadInt(L"adiv1pos", 33333); + div_filter2pos = g_view_metaconf->ReadInt(L"adiv3pos", 66667); + if (div_filterpos + div_filter2pos > 200000) // sanity check? + { + div_filterpos = 33333; + div_filter2pos = 66667; + } + } + + if (numFilters >= 2) AttachDivider(GetDlgItem(hwndDlg, IDC_DIV1), TRUE, OnDividerMoved, DIVIDER_FILTER); + if (numFilters >= 3) AttachDivider(GetDlgItem(hwndDlg, IDC_DIV2), TRUE, OnDividerMoved, DIVIDER_FILTER2); + AttachDivider(GetDlgItem(hwndDlg, IDC_HDELIM), FALSE, OnDividerMoved, DIVIDER_MEDIA); + + m_media_hwnd = WASABI_API_CREATEDIALOGPARAMW(IDD_VIEW_MEDIA, hwndDlg, view_mediaDialogProc, (LPARAM)!g_config->ReadInt(L"audiorefine", 0)); + SetWindowLongPtr(m_media_hwnd, GWLP_ID, IDD_VIEW_MEDIA); + + MLSKINWINDOW m = {0}; + m.skinType = SKINNEDWND_TYPE_LISTVIEW; + m.style = SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS | SWLVS_FULLROWSELECT | SWLVS_DOUBLEBUFFER | SWLVS_ALTERNATEITEMS; + + m.hwndToSkin = m_list1.getwnd(); + MLSkinWindow(plugin.hwndLibraryParent, &m); + m.hwndToSkin = m_list2.getwnd(); + MLSkinWindow(plugin.hwndLibraryParent, &m); + if (numFilters == 3) + { + m.hwndToSkin = m_list3.getwnd(); + MLSkinWindow(plugin.hwndLibraryParent, &m); + } + + if (!g_view_metaconf->ReadInt(L"av0_hscroll",0)) MLSkinnedScrollWnd_ShowHorzBar(m_list1.getwnd(), FALSE); + if (!g_view_metaconf->ReadInt(L"av1_hscroll",0)) MLSkinnedScrollWnd_ShowHorzBar(m_list2.getwnd(), FALSE); + if (!g_view_metaconf->ReadInt(L"av2_hscroll",0) && numFilters == 3) MLSkinnedScrollWnd_ShowHorzBar(m_list3.getwnd(), FALSE); + + FLICKERFIX ff; + ff.mode = FFM_ERASEINPAINT; + m.skinType = SKINNEDWND_TYPE_AUTO; + m.style = SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS; + INT ffcl[] = { IDC_QUICKSEARCH, IDC_SEARCHCAPTION, IDC_CLEAR, IDC_BUTTON_ARTMODE, IDC_BUTTON_VIEWMODE, IDC_BUTTON_COLUMNS}; + for (int i = 0; i < sizeof(ffcl) / sizeof(INT); i++) + { + ff.hwnd = GetDlgItem(hwndDlg, ffcl[i]); + if (IsWindow(ff.hwnd)) + { + SendMessage(mediaLibrary.library, WM_ML_IPC, (WPARAM)&ff, ML_IPC_FLICKERFIX); + if (i < 3) + { + m.hwndToSkin = ff.hwnd; + MLSkinWindow(plugin.hwndLibraryParent, &m); + } + } + } + + SendMessageW(hwndDlg, WM_DISPLAYCHANGE, 0, 0L); + + // clear the media windows refine shit + SetDlgItemText(m_media_hwnd, IDC_QUICKSEARCH, L""); + SetDlgItemText(m_media_hwnd, IDC_SEARCHCAPTION, WASABI_API_LNGSTRINGW(IDS_REFINE)); + SetDlgItemText(m_media_hwnd, IDC_CLEAR, WASABI_API_LNGSTRINGW(IDS_CLEAR_REFINE)); + KillTimer(m_media_hwnd, UPDATE_QUERY_TIMER_ID); // keep it from researching :) + + if (g_config->ReadInt(L"remembersearch", 0)) + { + char *query = g_view_metaconf->ReadString("lastquery_a_utf8", ""); + SetDlgItemText(hwndDlg, IDC_QUICKSEARCH, AutoWide(query, CP_UTF8)); + KillTimer(hwndDlg, 205); + } + for (int j=0; j<numFilters; j++) + filter[j]->SortResults(g_view_metaconf, j, 0); + + { + wchar_t buf[32] = {0}; + for (int i = 0; i < numFilters; i++) + { + int dlgitem = (i==0)?IDC_LIST1:((i==1)?IDC_LIST2:IDC_LIST3); + StringCchPrintfW(buf, ARRAYSIZE(buf), L"%hs_sort_by_%d", filter[i]->GetConfigId(), i); + int l_sc = g_view_metaconf->ReadInt(buf, 0); + StringCchPrintfW(buf, ARRAYSIZE(buf), L"%hs_sort_dir_%d", filter[i]->GetConfigId(), i); + int l_sd = g_view_metaconf->ReadInt(buf, 0); + SendMessage((HWND)SendMessage(GetDlgItem(hwndDlg,dlgitem), LVM_GETHEADER, 0, 0L),WM_ML_IPC,MAKEWPARAM(l_sc,!l_sd),ML_IPC_SKINNEDHEADER_DISPLAYSORT); + } + } + + MLSKINWINDOW skin = {0}; + skin.hwndToSkin = hwndDlg; + skin.skinType = SKINNEDWND_TYPE_AUTO; + skin.style = SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS | SWLVS_FULLROWSELECT | SWLVS_DOUBLEBUFFER | SWLVS_ALTERNATEITEMS; + MLSkinWindow(plugin.hwndLibraryParent, &skin); + return TRUE; + } + case WM_DRAWITEM: + { + DRAWITEMSTRUCT *di = (DRAWITEMSTRUCT *)lParam; + if (di->CtlType == ODT_BUTTON) + { + if (di->CtlID == IDC_BUTTON_ARTMODE || di->CtlID == IDC_BUTTON_VIEWMODE || di->CtlID == IDC_BUTTON_COLUMNS) + { + // draw the toolbar buttons! + SkinBitmap* hbm = (SkinBitmap*)GetWindowLongPtr(GetDlgItem(hwndDlg,di->CtlID),GWLP_USERDATA); + if (hbm && di->rcItem.left != di->rcItem.right && di->rcItem.top != di->rcItem.bottom) + { + DCCanvas dc(di->hDC); + if (di->itemState & ODS_SELECTED) hbm->blitAlpha(&dc,di->rcItem.left+6,di->rcItem.top+5); + else hbm->blitAlpha(&dc,di->rcItem.left+4,di->rcItem.top+3); + } + return TRUE; + } + } + } + break; + case WM_TIMER: + if (wParam == 165) // list3 sel change + { + KillTimer(hwndDlg, 165); + if (numFilters < 3) break; + GayStringW query; + getParentPlusSearchQuery(&query); + int r = makeFilterQuery(&query,filter[0]); + r += makeFilterQuery(&query,filter[1]); + r += makeFilterQuery(&query,filter[2]); + + if (wcscmp(query.Get(), l_query.Get())) + { + bgQuery_Stop(); + l_query.Set(query.Get()); + + wchar_t buf[2048] = {0}; + GetDlgItemTextW(m_media_hwnd, IDC_QUICKSEARCH, buf, ARRAYSIZE(buf)); + if (buf[0]) makeQueryStringFromText(&query, buf); + + if (!refresh) SetDlgItemText(m_media_hwnd, IDC_QUICKSEARCH, L""); + KillTimer(m_media_hwnd, UPDATE_QUERY_TIMER_ID); // keep it from researching :) + + EnterCriticalSection(&g_db_cs); + if (m_media_scanner) NDE_Scanner_Query(m_media_scanner, query.Get()); + LeaveCriticalSection(&g_db_cs); + + if (r > 0) SendMessage(m_media_hwnd, WM_APP + 3, 0x666, 0); // notify the child to use the first item as a media lookup + SendMessage(m_media_hwnd, WM_APP + 1, 0, 0); + } + } + if (wParam == 166) // album sel change + { + KillTimer(hwndDlg, 166); + + GayStringW query; + getParentPlusSearchQuery(&query); + int r = makeFilterQuery(&query,filter[0]); + r += makeFilterQuery(&query,filter[1]); + + if (wcscmp(query.Get(), l_query.Get())) + { + bgQuery_Stop(); + l_query.Set(query.Get()); + + wchar_t buf[2048] = {0}; + GetDlgItemTextW(m_media_hwnd, IDC_QUICKSEARCH, buf, ARRAYSIZE(buf)); + if (buf[0]) makeQueryStringFromText(&query, buf); + + if (!refresh) SetDlgItemText(m_media_hwnd, IDC_QUICKSEARCH, L""); + KillTimer(m_media_hwnd, UPDATE_QUERY_TIMER_ID); // keep it from researching :) + + EnterCriticalSection(&g_db_cs); + if (m_media_scanner) NDE_Scanner_Query(m_media_scanner, query.Get()); + LeaveCriticalSection(&g_db_cs); + if (r > 0) SendMessage(m_media_hwnd, WM_APP + 3, 0x666, 0); // notify the child to use the first item as a media lookup + SendMessage(m_media_hwnd, WM_APP + 1, (WPARAM)mysearchCallbackAlbumUpdate, 2); + } + } + if (wParam == 167) // artist sel change + { + KillTimer(hwndDlg, 167); + + GayStringW query; + getParentPlusSearchQuery(&query); + + int r = makeFilterQuery(&query,filter[0]); + + if (wcscmp(query.Get(), l_query.Get())) + { + bgQuery_Stop(); + l_query.Set(query.Get()); + + if (!refresh) SetDlgItemText(m_media_hwnd, IDC_QUICKSEARCH, L""); + KillTimer(m_media_hwnd, UPDATE_QUERY_TIMER_ID); // keep it from researching :) + + EnterCriticalSection(&g_db_cs); + NDE_Scanner_Query(m_media_scanner, query.Get()); + LeaveCriticalSection(&g_db_cs); + + ListView_SetItemCount(m_list2.getwnd(), 0); + if (r > 0) SendMessage(m_media_hwnd, WM_APP + 3, 0x666, 0); // notify the child to use the first item as a media lookup + SendMessage(m_media_hwnd, WM_APP + 1, (WPARAM)mysearchCallbackAlbumUpdate, (LPARAM)1); // pass a callback for sort + } + } + if (wParam == 205) + { + KillTimer(hwndDlg, 205); + bgQuery_Stop(); + getParentPlusSearchQuery(&l_query); + EnterCriticalSection(&g_db_cs); + NDE_Scanner_Query(m_media_scanner, l_query.Get()); + LeaveCriticalSection(&g_db_cs); + + ignore_selections = 1; + m_list3.SetSelected(0); + m_list2.SetSelected(0); + m_list1.SetSelected(0); + ListView_SetItemCount(m_list1.getwnd(), 0); + ListView_SetItemCount(m_list2.getwnd(), 0); + ListView_SetItemCount(m_list3.getwnd(), 0); + ignore_selections = 0; + if (!refresh) SetDlgItemText(m_media_hwnd, IDC_QUICKSEARCH, L""); + KillTimer(m_media_hwnd, UPDATE_QUERY_TIMER_ID); // keep it from researching :) + SendMessage(m_media_hwnd, WM_APP + 1, (WPARAM)mysearchCallbackAlbumUpdate, (LPARAM)0); + refresh -= 1; + } + break; + case WM_MOUSEMOVE: + if (we_are_drag_and_dropping && GetCapture() == hwndDlg) + { + POINT p; + p.x = GET_X_LPARAM(lParam); + p.y = GET_Y_LPARAM(lParam); + ClientToScreen(hwndDlg, &p); + mlDropItemStruct m; + ZeroMemory(&m, sizeof(mlDropItemStruct)); + m.type = ML_TYPE_ITEMRECORDLIST; + m.p = p; + + pluginHandleIpcMessage(ML_IPC_HANDLEDRAG, (WPARAM)&m); + if (m.result <= 0) + { + ZeroMemory(&m, sizeof(mlDropItemStruct)); + m.type = ML_TYPE_QUERYSTRING; + pluginHandleIpcMessage(ML_IPC_HANDLEDRAG, (WPARAM)&m); + } + + break; + } + break; + + case WM_SETCURSOR: + case WM_LBUTTONDOWN: + { + static INT id[] = { IDC_HDELIM, IDC_DIV1, IDC_DIV2 }; + RECT rw; + POINT pt; + INT count; + + count = numFilters; + if (count > sizeof(id)/sizeof(INT)) count = sizeof(id)/sizeof(INT); + + GetCursorPos(&pt); + for (INT i = 0; i < count; i++) + { + HWND hwndDiv = GetDlgItem(hwndDlg, id[i]); + if (!hwndDiv) continue; + + GetWindowRect(hwndDiv, &rw); + if (PtInRect(&rw, pt)) + { + if (WM_SETCURSOR == uMsg) + { + SetCursor(LoadCursor(NULL, (IDC_HDELIM != id[i]) ? IDC_SIZEWE : IDC_SIZENS)); + return TRUE; + } + else + { + SendMessage(hwndDiv, uMsg, wParam, MAKELPARAM(pt.x - rw.left, pt.y - rw.top)); + return TRUE; + } + } + } + } + break; + + case WM_LBUTTONUP: + if (we_are_drag_and_dropping && GetCapture() == hwndDlg) + { + int whichlist = we_are_drag_and_dropping; + we_are_drag_and_dropping = 0; + ReleaseCapture(); + + POINT p; + p.x = GET_X_LPARAM(lParam); + p.y = GET_Y_LPARAM(lParam); + ClientToScreen(hwndDlg, &p); + mlDropItemStruct m = {0}; + m.type = ML_TYPE_ITEMRECORDLISTW; + m.p = p; + m.flags = ML_HANDLEDRAG_FLAG_NOCURSOR; + + pluginHandleIpcMessage(ML_IPC_HANDLEDRAG, (WPARAM)&m); + itemRecordListW obj = {0, }; + buildRecordListW(&obj, whichlist-1); + + if (m.result > 0) + { + /* + if (whichlist == 1 || m_list2.GetSelectionMark() <= 0) + buildRecordListW(&obj, 0); + else if(whichlist == 2 || m_list3.GetSelectionMark() <= 0 || numFilters < 3) + buildRecordListW(&obj,1); + else + buildRecordListW(&obj,2); + */ + m.flags = 0; + m.result = 0; + m.data = (void*) & obj; + pluginHandleIpcMessage(ML_IPC_HANDLEDROP, (WPARAM)&m); + } + else + { + m.result = 0; + m.type = ML_TYPE_ITEMRECORDLIST; + pluginHandleIpcMessage(ML_IPC_HANDLEDRAG, (WPARAM)&m); + if (m.result > 0) + { + itemRecordList objA = {0, }; + convertRecordList(&objA, &obj); + + /* + if (whichlist == 1 || m_list2.GetSelectionMark() <= 0) + buildRecordList(&obj, 0); + else if(whichlist == 2 || m_list3.GetSelectionMark() <= 0 || numFilters < 3) + buildRecordList(&obj, 1); + else + buildRecordList(&obj, 2); + */ + m.flags = 0; + m.result = 0; + m.data = (void*) & objA; + GayString namebuf; + int wl = whichlist; + ViewFilter * filter1 = filter[wl-1]; + { + int a = filter1->list->GetSelectionMark(); + if (a < 0 || (filter1->HasTopItem() && filter1->list->GetSelected(0))) + { + filter1 = filter[0]; wl--; + } + + if (wl > 0) + { + int x; + int cnt = 0; + for (x = filter1->HasTopItem()?1:0; x < filter1->Size(); x ++) + { + if (filter1->list->GetSelected(x)) + { + if (cnt) namebuf.Append(", "); + if (cnt++ > 2) + { + namebuf.Append("..."); break; + } + namebuf.Append(AutoChar(filter1->GetText(x))); + } + } + } + } + if (namebuf.Get() && namebuf.Get()[0]) m.name = namebuf.Get(); + if (m.name) + m.flags |= ML_HANDLEDRAG_FLAG_NAME; + pluginHandleIpcMessage(ML_IPC_HANDLEDROP, (WPARAM)&m); + freeRecordList(&objA); + } + + else + { + m.result = 0; + m.type = ML_TYPE_QUERYSTRING; + pluginHandleIpcMessage(ML_IPC_HANDLEDRAG, (WPARAM)&m); + if (m.result > 0) + { + GayStringW query; + getParentPlusSearchQuery(&query); + bool allSelected[3] = {false,false,false}; + for (int k=0; k<numFilters; k++) + { + W_ListView &w = k==0?m_list1:(k==1?m_list2:m_list3); + if (filter[k]->HasTopItem()) allSelected[k] = (w.GetSelectionMark() <= 0); + else allSelected[k] = (w.GetSelectionMark() < 0); + } + + if (whichlist == 1 || allSelected[1]) + { + makeFilterQuery(&query,filter[0]); + } + else if (whichlist == 2 || allSelected[2] || numFilters < 3) + { + makeFilterQuery(&query,filter[0]); + makeFilterQuery(&query,filter[1]); + } + else + { + makeFilterQuery(&query,filter[0]); + makeFilterQuery(&query,filter[1]); + makeFilterQuery(&query,filter[2]); + } + + m.data = (void*)query.Get(); + m.result = 0; + GayString namebuf; + int wl = whichlist; + ViewFilter * filter1 = wl==2?filter[1]:filter[0]; + { + int a = filter1->list->GetSelectionMark(); + if (a < 0 || (filter1->HasTopItem() && filter1->list->GetSelected(0))) + { + if (wl==2) + { + filter1 = filter[0]; + } + else m.name = WASABI_API_LNGSTRING(IDS_ALL_ARTISTS); + wl--; + } + if (wl > 0) + { + int x; + int cnt = 0; + for (x = filter1->HasTopItem()?1:0; x < filter1->Size(); x ++) + { + if (filter1->list->GetSelected(x)) + { + if (cnt) namebuf.Append(", "); + if (cnt++ > 2) + { + namebuf.Append("..."); break; + } + namebuf.Append(AutoChar(filter1->GetText(x))); + } + } + } + } + if (namebuf.Get() && namebuf.Get()[0]) + { + m.name = namebuf.Get(); + m.flags |= ML_HANDLEDRAG_FLAG_NAME; + } + pluginHandleIpcMessage(ML_IPC_HANDLEDROP, (WPARAM)&m); + } + } + } + freeRecordList(&obj); + } + break; + case WM_CONTEXTMENU: + { + HWND hwndFrom = (HWND)wParam; + int x = GET_X_LPARAM(lParam), y = GET_Y_LPARAM(lParam); + POINT pt = {x,y}; + int idFrom = GetDlgCtrlID(hwndFrom); + HWND hHeader; + W_ListView m_list; + int editFilter=-1; + + if (idFrom == IDC_LIST1) + { + m_list = m_list1; + hHeader = (HWND)SNDMSG(m_list.getwnd(), LVM_GETHEADER, 0, 0L); + RECT headerRect; + if ((WS_VISIBLE & GetWindowLongPtr(hHeader, GWL_STYLE)) && GetWindowRect(hHeader, &headerRect)) + { + if (FALSE != PtInRect(&headerRect, pt)) + { + editFilter = 0; + } + } + } + else if (idFrom == IDC_LIST2) + { + m_list = m_list2; + hHeader = (HWND)SNDMSG(m_list.getwnd(), LVM_GETHEADER, 0, 0L); + RECT headerRect; + if ((WS_VISIBLE & GetWindowLongPtr(hHeader, GWL_STYLE)) && GetWindowRect(hHeader, &headerRect)) + { + if (FALSE != PtInRect(&headerRect, pt)) + { + editFilter = 1; + } + } + } + else if (idFrom == IDC_LIST3) + { + m_list = m_list3; + hHeader = (HWND)SNDMSG(m_list.getwnd(), LVM_GETHEADER, 0, 0L); + RECT headerRect; + if ((WS_VISIBLE & GetWindowLongPtr(hHeader, GWL_STYLE)) && GetWindowRect(hHeader, &headerRect)) + { + if (FALSE != PtInRect(&headerRect, pt)) + { + editFilter = 2; + } + } + } + else + break; + + if (editFilter != -1) + { + HMENU themenu = WASABI_API_LOADMENU(IDR_CONTEXTMENUS); + HMENU menu = filter[editFilter]->GetMenu(true,editFilter,g_view_metaconf,themenu); + POINT p; + GetCursorPos(&p); + int r = DoTrackPopup(menu, TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTBUTTON, p.x, p.y, hwndDlg, NULL); + DestroyMenu(themenu); + filter[editFilter]->ProcessMenuResult(r,true,editFilter,g_view_metaconf,hwndDlg); + MSG msg; + while (PeekMessage(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE)); //eat return + break; + } + + int pane=0; + if (numFilters > 1) + { + if (idFrom == IDC_LIST2 && m_list2.GetSelectionMark() >= 0) pane=1; + } + if (numFilters > 2) + { + if (idFrom == IDC_LIST3 && m_list3.GetSelectionMark() >= 0) pane=2; + } + + if (x == -1 || y == -1) // x and y are -1 if the user invoked a shift-f10 popup menu + { + RECT itemRect = {0}; + int selected = m_list.GetNextSelected(); + if (selected != -1) // if something is selected we'll drop the menu from there + { + m_list.GetItemRect(selected, &itemRect); + ClientToScreen(m_list.getwnd(), (POINT *)&itemRect); + } + else // otherwise we'll drop it from the top-left corner of the listview, adjusting for the header location + { + GetWindowRect(m_list.getwnd(), &itemRect); + + HWND hHeader = (HWND)SNDMSG(m_list.getwnd(), LVM_GETHEADER, 0, 0L); + RECT headerRect; + if ((WS_VISIBLE & GetWindowLongPtr(hHeader, GWL_STYLE)) && GetWindowRect(hHeader, &headerRect)) + { + itemRect.top += (headerRect.bottom - headerRect.top); + } + } + x = itemRect.left; + y = itemRect.top; + } + + RECT headerRect; + if (0 == (WS_VISIBLE & GetWindowLongPtr(hHeader, GWL_STYLE)) || FALSE == GetWindowRect(hHeader, &headerRect)) + { + SetRectEmpty(&headerRect); + } + + if (FALSE != PtInRect(&headerRect, pt)) + { + break; + } + + HMENU menu = GetSubMenu(g_context_menus, 1); + sendto_hmenu = GetSubMenu(menu, 2); + + s.mode = 0; + s.hwnd = 0; + s.build_hMenu = 0; + + IPC_LIBRARY_SENDTOMENU = SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&"LibrarySendToMenu", IPC_REGISTER_WINAMP_IPCMESSAGE); + if (IPC_LIBRARY_SENDTOMENU > 65536 && SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)0, IPC_LIBRARY_SENDTOMENU) == (LRESULT)-1) + { + s.mode = 1; + s.hwnd = hwndDlg; + s.data_type = ML_TYPE_ITEMRECORDLIST; + s.ctx[1] = 1; + s.build_hMenu = sendto_hmenu; + } + + wchar_t str[128] = {0}; + StringCchPrintfW(str, 128, (!play_enq_rnd_alt?WASABI_API_LNGSTRINGW(IDS_PLAY_RANDOM_ITEM):L"%s"), + filter[pane]->GetNameSingularAlt(play_enq_rnd_alt?1:0)); + FixAmps(str, 128); + MENUITEMINFOW mii = + { + sizeof(MENUITEMINFOW), + MIIM_TYPE | MIIM_ID, + MFT_STRING, + MFS_ENABLED, + ID_AUDIOWND_PLAYRANDOMITEM, + NULL, + NULL, + NULL, + 0, + str, + 0, + }; + SetMenuItemInfoW(menu, ID_AUDIOWND_PLAYRANDOMITEM, false, &mii); + + StringCchPrintfW(str, 128, (!play_enq_rnd_alt?WASABI_API_LNGSTRINGW(IDS_ENQUEUE_RANDOM_ITEM):L"%s"), + filter[pane]->GetNameSingularAlt(play_enq_rnd_alt?2:0)); + FixAmps(str, 128); + mii.wID = ID_AUDIOWND_ENQUEUERANDOMITEM; + SetMenuItemInfoW(menu, ID_AUDIOWND_ENQUEUERANDOMITEM, false, &mii); + + filter[pane]->DialogProc(hwndDlg,WM_USER+600,(WPARAM)menu,0x7000); + UpdateMenuItems(NULL, menu, IDR_VIEW_ACCELERATORS); + int r = DoTrackPopup(menu, TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTBUTTON, x, y, hwndDlg, NULL); + + filter[pane]->DialogProc(hwndDlg,WM_USER+601,(WPARAM)menu,0x7000); + + if(r >= 0x7000 && r <= 0x8000) { + GayStringW query; + getParentPlusSearchQuery(&query); + for (int i=0; i<=pane; i++) + makeFilterQuery(&query,filter[i]); + filter[pane]->DialogProc(hwndDlg,WM_USER+602,(WPARAM)query.Get(),r - 0x7000); + } + + switch (r) + { + case ID_AUDIOWND_PLAYSELECTION: + playList(PLAY,pane); + break; + case ID_AUDIOWND_ENQUEUESELECTION: + playList(ENQUEUE,pane); + break; + case ID_AUDIOWND_PLAYRANDOMITEM: + case ID_AUDIOWND_ENQUEUERANDOMITEM: + playRandomList(r == ID_AUDIOWND_PLAYRANDOMITEM ? PLAY : ENQUEUE, pane); + break; + case ID_RATE_1: + case ID_RATE_2: + case ID_RATE_3: + case ID_RATE_4: + case ID_RATE_5: + case ID_RATE_0: + { + int rate = r - ID_RATE_1 + 1; + if (r == ID_RATE_0) rate = 0; + if(rateList(rate)) + { + wchar_t buf[10] = {0}; + wsprintfW(buf,L"%d",rate); + int s = -1; + while((s = filter[pane]->list->GetNextSelected(s)) != -1) + filter[pane]->MetaUpdate(s, DB_FIELDNAME_rating,buf); + } + PostMessage(hwndDlg, WM_APP + 4, (WPARAM)rate, (LPARAM)0); + } + break; + default: + if (s.mode == 2) + { + s.menu_id = r; + if (SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&s, IPC_LIBRARY_SENDTOMENU) == (LRESULT)-1) + { + // build my data. + s.mode = 3; + s.data_type = ML_TYPE_ITEMRECORDLISTW; + itemRecordListW myObj = {0, }; + buildRecordListW(&myObj, pane); + + s.data = (void*) & myObj; + LRESULT result = SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&s, IPC_LIBRARY_SENDTOMENU); + + if (result != 1) + { + s.mode = 3; + s.data_type = ML_TYPE_ITEMRECORDLIST; + itemRecordList objA = {0, }; + convertRecordList(&objA, &myObj); + + s.data = (void*) & objA; + SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&s, IPC_LIBRARY_SENDTOMENU); + freeRecordList(&objA); + } + freeRecordList(&myObj); + } + } + break; + } + if (s.mode) + { + s.mode = 4; + SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&s, IPC_LIBRARY_SENDTOMENU); // cleanup + } + sendto_hmenu = 0; + EatKeyboard(); + return 0; + } + case WM_NOTIFY: + { + LPNMHDR l = (LPNMHDR)lParam; + + if (l->code == LVN_ODFINDITEMW) + { + ViewFilter * f; + if (l->idFrom == IDC_LIST2) f = filter[1]; + else if (l->idFrom == IDC_LIST3) f = filter[2]; + else f = filter[0]; + + NMLVFINDITEMW *t = (NMLVFINDITEMW *)lParam; + int i = t->iStart; + if (i >= f->Size()) i = 0; + + int cnt = f->Size() - i; + if (t->lvfi.flags & LVFI_WRAP) cnt += i; + + while (cnt-- > 0) + { + const wchar_t *name = f->GetText(i); + SKIP_THE_AND_WHITESPACEW(name) + + if (t->lvfi.flags & (4 | LVFI_PARTIAL)) + { + if (!StrCmpNIW(name, t->lvfi.psz, wcslen(t->lvfi.psz))) + { + SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, i); + return 1; + } + } + else if (t->lvfi.flags & LVFI_STRING) + { + if (!lstrcmpiW(name, t->lvfi.psz)) + { + SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, i); + return 1; + } + } + else + { + SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, -1); + return 1; + } + if (++i == f->Size()) i = 0; + } + SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, -1); + return 1; + } + else if (l->code == LVN_GETDISPINFOW) + { + NMLVDISPINFOW *lpdi = (NMLVDISPINFOW*) lParam; + int item = lpdi->item.iItem; + if (item < 0) return 0; + + if (lpdi->item.mask & LVIF_TEXT) + { + if (l->idFrom == IDC_LIST3 && numFilters == 3) + lpdi->item.pszText = (wchar_t*)filter[2]->CopyText2(item,lpdi->item.iSubItem,lpdi->item.pszText,lpdi->item.cchTextMax); + + if (l->idFrom == IDC_LIST2) + lpdi->item.pszText = (wchar_t*)filter[1]->CopyText2(item,lpdi->item.iSubItem,lpdi->item.pszText,lpdi->item.cchTextMax); + + else if (l->idFrom == IDC_LIST1) + lpdi->item.pszText = (wchar_t*)filter[0]->CopyText2(item, lpdi->item.iSubItem, lpdi->item.pszText, lpdi->item.cchTextMax); + } + return 0; + } + else if (l->code == LVN_COLUMNCLICK) + { + NMLISTVIEW *p = (NMLISTVIEW*)lParam; + int which = l->idFrom == IDC_LIST3 ? 2 : (l->idFrom == IDC_LIST2 ? 1 : 0); + wchar_t buf[32] = {0}, buf2[32] = {0}; + + StringCchPrintfW(buf, ARRAYSIZE(buf), L"%hs_sort_by_%d",filter[which]->GetConfigId(), which); + int l_sc = g_view_metaconf->ReadInt(buf, 0); + + StringCchPrintfW(buf2, ARRAYSIZE(buf2), L"%hs_sort_dir_%d",filter[which]->GetConfigId(), which); + int l_sd = g_view_metaconf->ReadInt(buf2, 0); + if (p->iSubItem == l_sc) l_sd = !l_sd; + else l_sc = p->iSubItem; + + g_view_metaconf->WriteInt(buf, l_sc); + g_view_metaconf->WriteInt(buf2, l_sd); + + int s; + s = filter[which]->Size(); + int dlgitem = (which==0)?IDC_LIST1:((which==1)?IDC_LIST2:IDC_LIST3); + SendMessage((HWND)SendMessage(GetDlgItem(hwndDlg,dlgitem), LVM_GETHEADER, 0, 0L),WM_ML_IPC,MAKEWPARAM(l_sc,!l_sd/* : !l_sd/*!l_sd : l_sd*/),ML_IPC_SKINNEDHEADER_DISPLAYSORT); + filter[which]->SortResults(g_view_metaconf, which); + ListView_SetItemCount(l->hwndFrom, s); + InvalidateRect(l->hwndFrom, NULL, TRUE); + } + else if (l->idFrom == IDC_LIST1 || l->idFrom == IDC_LIST2 || l->idFrom == IDC_LIST3) + { + int pane = 0; + if (l->idFrom == IDC_LIST2) pane = 1; + if (l->idFrom == IDC_LIST3) pane = 2; + + if (l->code == NM_DBLCLK) + { + // allow doubleclick on all, yes + int c = filter[pane]->list->GetCount(), x=0; + for (x = 0; x < c; x ++) if (filter[pane]->list->GetSelected(x)) break; + + if (!x && pane>0 && filter[pane]->HasTopItem()) + playList((!!g_config->ReadInt(L"enqueuedef", PLAY)) ^(!!(GetAsyncKeyState(VK_SHIFT)&0x8000)),pane-1); + else if (x < c) + playList((!!g_config->ReadInt(L"enqueuedef", PLAY)) ^(!!(GetAsyncKeyState(VK_SHIFT)&0x8000)),pane); + } + else if (l->code == LVN_ITEMCHANGED) + { + LPNMLISTVIEW lv = (LPNMLISTVIEW)lParam; + if (ignore_selections || !((lv->uNewState ^ lv->uOldState) & LVIS_SELECTED)) return 0; + int t; + if (pane==0) t=167; + else if (pane==1) t=166; + else t=165; + + KillTimer(hwndDlg, t); + SetTimer(hwndDlg, t, 100, NULL); + } + else if (l->code == LVN_BEGINDRAG) + { + if (pane==0) we_are_drag_and_dropping = 1; + else if (pane==1) we_are_drag_and_dropping = 2; + else we_are_drag_and_dropping = 3; + SetCapture(hwndDlg); + } + } + if (l->code == NM_RETURN) + { + extern void playFiles(int enqueue, int all); + playFiles(((!!g_config->ReadInt(L"enqueuedef", 0)) ^(!!(GetAsyncKeyState(VK_SHIFT)&0x8000))), 1); + } + } + break; + case WM_USER+710: + if(rateList(wParam)) + { + ViewFilter *f = (ViewFilter *)lParam; + + // first check the validity of lParam + bool found=false; + for(int i=0; i<numFilters; i++) + if(filter[i] == f) found=true; + if(!found) break; + + wchar_t buf[10] = {0}; + wsprintfW(buf,L"%d",wParam); + int s = -1; + while((s = f->list->GetNextSelected(s)) != -1) + f->MetaUpdate(s, DB_FIELDNAME_rating,buf); + } + break; + case WM_DROPFILES: + { + extern void Window_OnDropFiles(HWND hwndDlg, HDROP hdrop); + Window_OnDropFiles(hwndDlg, (HDROP)wParam); + break; + } + case WM_COMMAND: + switch (LOWORD(wParam)) + { + case IDC_CLEAR: + SetDlgItemText(hwndDlg, IDC_QUICKSEARCH, L""); + break; + case IDC_QUICKSEARCH: + if (HIWORD(wParam) == EN_CHANGE) + { + KillTimer(hwndDlg, 205); + SetTimer(hwndDlg, 205, g_querydelay, NULL); + } + break; + case IDC_BUTTON_ARTMODE: + { + int changed=0; + int f[3]={0,0,0}; + for (int i=0; i<numFilters; i++) + { + f[i] = GetFilter(m_query_mode,i); + if (f[i] == 6) + { + f[i] = 11; changed=true; + } + else if (f[i] == 11) + { + f[i] = 6; changed=true; + } + } + + if (changed) + { + if (f[1] == 6) f[1]=0; + if (numFilters == 2) f[2]=0; + int m = f[0] | (f[1] << 8) | (f[2] << 16); + + int par = mediaLibrary.GetSelectedTreeItem(); + QueryList::iterator iter; + iter = m_query_list.find(par); + if (iter != m_query_list.end()) + iter->second->mode = m; + saveQueryTree(); + PostMessage(plugin.hwndLibraryParent, WM_USER + 30, 0, 0); + } + } + break; + case IDC_BUTTON_VIEWMODE: + { + int presets[] = + { + MAKEVIEW_2FILTER(ARTIST,ALBUM), + MAKEVIEW_2FILTER(ARTIST,ALBUMART), + MAKEVIEW_2FILTER(ALBUMARTIST,ALBUM), + MAKEVIEW_2FILTER(ALBUMARTIST,ALBUMART), + MAKEVIEW_3FILTER(GENRE,ARTIST,ALBUM), + MAKEVIEW_2FILTER(GENRE,ALBUMART), + MAKEVIEW_3FILTER(YEAR,ARTIST,ALBUM), + MAKEVIEW_2FILTER(COMPOSER,ALBUM), + MAKEVIEW_3FILTER(PUBLISHER,ARTIST,ALBUM), + }; + HMENU menu = CreatePopupMenu(); + bool hasCheck=false; + for (int i=0; i < sizeof(presets)/sizeof(presets[0]); i++) + { + wchar_t buf[350] = {0}, filterName[128] = {0}; + buf[0] = L'\0'; + int l = GetNumFilters(presets[i]); + bool check = (l == GetNumFilters(m_query_mode)); + for (int j=0; j<l; j++) + { + int f = GetFilter(presets[i],j)-1; + wcscat(buf,getFilterName(f, filterName, ARRAYSIZE(filterName))); + if (GetFilter(presets[i],j+1)) wcscat(buf,L"\\"); + if (GetFilter(presets[i],j) != GetFilter(m_query_mode,j)) check=false; + } + AppendMenuW(menu,MF_STRING,i+1,buf); + if(check) + { + CheckMenuItem(menu,i+1,MF_CHECKED); + hasCheck=true; + } + } + AppendMenuW(menu,MF_STRING,0x4000,WASABI_API_LNGSTRINGW(IDS_OTHER2)); + if(!hasCheck) + CheckMenuItem(menu,0x4000,MF_CHECKED); + RECT rc; + GetWindowRect(GetDlgItem(hwndDlg,IDC_BUTTON_VIEWMODE),&rc); + int r = DoTrackPopup(menu, TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTBUTTON | TPM_NONOTIFY, + rc.left, rc.bottom, hwndDlg, NULL); + DestroyMenu(menu); + if (r==0) break; + else if (r == 0x4000) + queryEditItem(mediaLibrary.GetSelectedTreeItem()); + else + { + int par = mediaLibrary.GetSelectedTreeItem(); + QueryList::iterator iter; + iter = m_query_list.find(par); + if (iter != m_query_list.end()) + iter->second->mode = presets[r-1];; + saveQueryTree(); + PostMessage(plugin.hwndLibraryParent, WM_USER + 30, 0, 0); + } + } + break; + case IDC_BUTTON_COLUMNS: + { + HMENU themenu[3] = {0}; + wchar_t *name[3] = {0}, filterName[128] = {0}; + HMENU menu = CreatePopupMenu(); + + MENUITEMINFOW m={sizeof(m),MIIM_TYPE | MIIM_ID | MIIM_SUBMENU,MFT_STRING,0}; + for (int i=0; i<numFilters; i++) + { + m.wID = i; + m.dwTypeData = name[i] = _wcsdup(getFilterName(GetFilter(m_query_mode,i)-1, filterName, ARRAYSIZE(filterName))); + themenu[i] = WASABI_API_LOADMENU(IDR_CONTEXTMENUS); + m.hSubMenu = filter[i]->GetMenu(true,i,g_view_metaconf,themenu[i]); + InsertMenuItemW(menu,i,FALSE,&m); + } + + m.wID = 3; + m.dwTypeData = WASABI_API_LNGSTRINGW(IDS_TRACKS_MENU); + m.hSubMenu = GetSubMenu(themenu[0], 4); + InsertMenuItemW(menu,3,FALSE,&m); + + RECT rc; + GetWindowRect(GetDlgItem(hwndDlg,IDC_BUTTON_COLUMNS),&rc); + int r = DoTrackPopup(menu, TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTBUTTON, rc.left,rc.bottom, hwndDlg, NULL); + + DestroyMenu(menu); + + if (r == ID_HEADERWND_CUSTOMIZECOLUMNS) + { + void customizeColumnsDialog(HWND hwndParent); + customizeColumnsDialog(hwndDlg); + } + + for (int i=0; i<numFilters; i++) + { + filter[i]->ProcessMenuResult(r,true,i,g_view_metaconf,hwndDlg); + DestroyMenu(themenu[i]); + free(name[i]); + } + } + break; + } + break; + case WM_WINDOWPOSCHANGED: + if ((SWP_NOSIZE | SWP_NOMOVE) != ((SWP_NOSIZE | SWP_NOMOVE) & ((WINDOWPOS*)lParam)->flags) || + (SWP_FRAMECHANGED & ((WINDOWPOS*)lParam)->flags)) + { + LayoutWindows(hwndDlg, !(SWP_NOREDRAW & ((WINDOWPOS*)lParam)->flags)); + } + return TRUE; + case WM_APP + 1: //sent by parent for resizing window + bgQuery_Stop(); + getParentPlusSearchQuery(&l_query); + + EnterCriticalSection(&g_db_cs); + NDE_Scanner_Query(m_media_scanner, l_query.Get()); + LeaveCriticalSection(&g_db_cs); + + ignore_selections = 1; + for (int i=0; i<numFilters; i++) + { + filter[i]->list->SetSelected(0); + ListView_SetItemCount(filter[i]->list->getwnd(), 0); + } + ignore_selections = 0; + if (!refresh) SetDlgItemText(m_media_hwnd, IDC_QUICKSEARCH, L""); + KillTimer(m_media_hwnd, UPDATE_QUERY_TIMER_ID); // keep it from researching :) + SendMessage(m_media_hwnd, WM_APP + 1, (WPARAM)mysearchCallbackAlbumUpdate, (LPARAM)0); + refresh -= 1; + break; + case WM_QUERYFILEINFO: if (m_media_hwnd) PostMessageW(m_media_hwnd, uMsg, wParam, lParam); break; + case WM_SHOWFILEINFO: + SendMessageW(GetParent(hwndDlg), uMsg, wParam, lParam); break; + case WM_USER + 66: + SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, SendMessage(GetParent(hwndDlg), uMsg, wParam, lParam)); + return TRUE; + case WM_APP + 2: //sent by media child to get current query + if (lParam) *((const wchar_t **)(lParam)) = l_query.Get(); + break; + case WM_APP + 3: // sent by bg thread to update our shit + if (wParam == 0x69) + { + if (lParam == 0 && numFilters >= 1) + { + if (UpdateFilterPane(0,"artist_sel_utf8")) + { + PostMessage(hwndDlg,WM_TIMER,167,0); + break; + } + } + + if (lParam <= 1 && numFilters >= 2) + { + if (UpdateFilterPane(1,"album_sel_utf8")) + { + PostMessage(hwndDlg,WM_TIMER,166,0); + break; + } + } + + if (numFilters >= 3) + { + if (UpdateFilterPane(2,"list3_sel_utf8")) + { + PostMessage(hwndDlg,WM_TIMER,165,0); + } + } + } + break; + // used for working around some quirks with the ratings so it'll update on-the-fly(ish) + case WM_APP + 4: + { + if(!lParam) + { + wchar_t buf[64] = {0}; + StringCchPrintfW(buf,64,L"%d",wParam); + for(int i=0; i<numFilters; i++) + { + int s = -1; + while((s = filter[i]->list->GetNextSelected(s)) != -1) + { + filter[i]->MetaUpdate(s, DB_FIELDNAME_rating, buf); + SendMessage(filter[i]->list->getwnd(),LVM_REDRAWITEMS,s,s); + } + } + } + else + { + PostMessage(m_media_hwnd, WM_APP + 1, (WPARAM)mysearchCallbackAlbumUpdate, (LPARAM)1); + } + } + break; + case WM_APP + 5: + // TODO + break; + case WM_APP + 6: // handles the ml_cloud 'first pull' announces so we + { // can then show the cloud column & update the cache + SendMessage(m_media_hwnd, WM_APP + 6, wParam, lParam); + break; + } + case WM_DESTROY: + FlushCache(); + + if (numFilters >= 2) g_view_metaconf->WriteInt(L"adiv1pos", div_filterpos); + if (numFilters >= 3) g_view_metaconf->WriteInt(L"adiv3pos", div_filter2pos); + + g_view_metaconf->WriteInt(L"adiv2pos", div_mediapos); + // save a list of selected artists and albums + for (int i=0; i<numFilters; i++) + { + GayStringW gs; + if (!(filter[i]->list->GetSelected(0) && filter[i]->HasTopItem())) + { + int c = filter[i]->list->GetCount(), delim = 0; + for (int x = filter[i]->HasTopItem()?1:0; x < c; x ++) + { + if (filter[i]->list->GetSelected(x)) + { + if (delim) gs.Append(LDELIMSTR); + const wchar_t *p = filter[i]->GetText(x); + while (p && *p) + { + if (*p == *LDELIMSTR) gs.Append(LDELIMSTR LDELIMSTR); + else + { + wchar_t buf[2] = {*p, 0}; + gs.Append(buf); + } + p++; + } + delim = 1; + } + } + } + char *confname = "artist_sel_utf8"; + if (i==1) confname = "album_sel_utf8"; + if (i==2) confname = "list3_sel_utf8"; + g_view_metaconf->WriteString(confname, AutoChar(gs.Get(), CP_UTF8)); + } + { + wchar_t buf[2048] = {0}; + GetDlgItemTextW(hwndDlg, IDC_QUICKSEARCH, buf, ARRAYSIZE(buf)); + g_view_metaconf->WriteString("lastquery_a_utf8", AutoChar(buf, CP_UTF8)); + } + + bgQuery_Stop(); + + for (int i=0; i<numFilters; i++) + { + filter[i]->SaveColumnWidths(); + filter[i]->Empty(); + filter[i]->ClearColumns(); + delete filter[i]; + } + numFilters=0; + { + SkinBitmap *s = (SkinBitmap*)GetWindowLongPtr(GetDlgItem(hwndDlg,IDC_BUTTON_ARTMODE),GWLP_USERDATA); + if (s) + { + void *bits = s->getBits(); + if (bits) free(bits); delete s; + SetWindowLongPtr(GetDlgItem(hwndDlg,IDC_BUTTON_ARTMODE),GWLP_USERDATA, 0); + } + s = (SkinBitmap*)GetWindowLongPtr(GetDlgItem(hwndDlg,IDC_BUTTON_VIEWMODE),GWLP_USERDATA); + if (s) + { + void *bits = s->getBits(); + if (bits) free(bits); delete s; + SetWindowLongPtr(GetDlgItem(hwndDlg,IDC_BUTTON_VIEWMODE),GWLP_USERDATA, 0); + } + s = (SkinBitmap*)GetWindowLongPtr(GetDlgItem(hwndDlg,IDC_BUTTON_COLUMNS),GWLP_USERDATA); + if (s) + { + void *bits = s->getBits(); + if (bits) free(bits); delete s; + SetWindowLongPtr(GetDlgItem(hwndDlg,IDC_BUTTON_COLUMNS),GWLP_USERDATA, 0); + } + } + break; + case WM_PAINT: + { + int tab[] = + { + IDC_HDELIM | DCW_DIVIDER, // 0 + IDC_QUICKSEARCH | DCW_SUNKENBORDER, // 1 + IDC_DIV1 | DCW_DIVIDER, // 2 + IDC_LIST1 | DCW_SUNKENBORDER, //3 + IDC_LIST2 | DCW_SUNKENBORDER, //4 + IDC_LIST3 | DCW_SUNKENBORDER, //5 + IDC_DIV2 | DCW_DIVIDER, //6 + }; + int size = 5; + if (numFilters == 3) size = 7; + + if (m_nodrawtopborders) size = 2; + else + { + if (numFilters == 3) + { + if (adiv1_nodraw == 2) tab[4]=0; + if (adiv1_nodraw == 1) tab[3]=0; + if (adiv2_nodraw == 2) tab[5]=0; + if (adiv2_nodraw == 1) tab[4]=0; + } + else + { + if (adiv1_nodraw == 2) size = 4; + if (adiv1_nodraw == 1) + { + size = 4; tab[3] = tab[4]; + } + } + } + dialogSkinner.Draw(hwndDlg, tab, size); + } + break; + + case WM_ERASEBKGND: + return 1; //handled by WADlg_DrawChildWindowBorders in WM_PAINT + + case WM_USER + 0x201: + offsetX = (short)LOWORD(wParam); + offsetY = (short)HIWORD(wParam); + g_rgnUpdate = (HRGN)lParam; + return TRUE; + + case WM_ML_CHILDIPC: + switch (lParam) + { + case ML_CHILDIPC_GO_TO_SEARCHBAR: + SendDlgItemMessage(hwndDlg, IDC_QUICKSEARCH, EM_SETSEL, 0, -1); + SetFocus(GetDlgItem(hwndDlg, IDC_QUICKSEARCH)); + break; + case ML_CHILDIPC_REFRESH_SEARCH: + refresh = (1 + numFilters); + PostMessage(hwndDlg, WM_COMMAND, MAKEWPARAM(IDC_QUICKSEARCH, EN_CHANGE), (LPARAM)GetDlgItem(hwndDlg, IDC_QUICKSEARCH)); + break; + } + break; + + } + return FALSE; +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/view_errorinfo.cpp b/Src/Plugins/Library/ml_local/view_errorinfo.cpp new file mode 100644 index 00000000..5f7e71ec --- /dev/null +++ b/Src/Plugins/Library/ml_local/view_errorinfo.cpp @@ -0,0 +1,119 @@ +#include "main.h" +#include "api__ml_local.h" +#include "..\..\General\gen_ml/config.h" +#include "resource.h" +#include "..\..\General\gen_ml/ml_ipc_0313.h" + +static HRGN g_rgnUpdate = NULL; +static int offsetX = 0, offsetY = 0; + +static void LayoutWindows(HWND hwnd, BOOL fRedraw) +{ + RECT rc, rg; + HRGN rgn; + + GetClientRect(hwnd, &rc); + SetRect(&rg, 0, 0, 0, 0); + + rc.top += 2; + rc.right -=2; + + if (rc.bottom <= rc.top || rc.right <= rc.left) return; + + rgn = NULL; + + HWND temp = GetDlgItem(hwnd, IDC_DB_ERROR); + GetWindowRect(temp, &rg); + SetWindowPos(temp, NULL, WASABI_API_APP->getScaleX(20), WASABI_API_APP->getScaleY(20), + rc.right - rc.left - WASABI_API_APP->getScaleX(40), + rc.bottom - rc.top - WASABI_API_APP->getScaleY(45), + SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOCOPYBITS | SWP_NOREDRAW); + + temp = GetDlgItem(hwnd, IDC_RESET_DB_ON_ERROR); + GetWindowRect(temp, &rg); + SetWindowPos(temp, NULL, ((rc.right - rc.left) - (rg.right - rg.left)) / 2, + rc.bottom - (rg.bottom - rg.top), + rg.right - rg.left, rg.bottom - rg.top, + SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOCOPYBITS | SWP_NOREDRAW); + + InvalidateRect(hwnd, NULL, TRUE); + + if (fRedraw) + { + UpdateWindow(hwnd); + } + if (g_rgnUpdate) + { + GetUpdateRgn(hwnd, g_rgnUpdate, FALSE); + if (rgn) + { + OffsetRgn(rgn, rc.left, rc.top); + CombineRgn(g_rgnUpdate, g_rgnUpdate, rgn, RGN_OR); + } + } + ValidateRgn(hwnd, NULL); + if (rgn) DeleteObject(rgn); +} + +INT_PTR CALLBACK view_errorinfoDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam) +{ + BOOL a=dialogSkinner.Handle(hwndDlg,uMsg,wParam,lParam); if (a) return a; + switch(uMsg) + { + case WM_INITDIALOG: + { + SetWindowText(GetDlgItem(hwndDlg, IDC_DB_ERROR),(LPCWSTR)WASABI_API_LOADRESFROMFILEW(L"TEXT", MAKEINTRESOURCE((nde_error ? IDR_NDE_ERROR : IDR_DB_ERROR)), 0)); + if (nde_error) + DestroyWindow(GetDlgItem(hwndDlg, IDC_RESET_DB_ON_ERROR)); + + MLSKINWINDOW m = {0}; + m.skinType = SKINNEDWND_TYPE_DIALOG; + m.hwndToSkin = hwndDlg; + m.style = SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS; + MLSkinWindow(plugin.hwndLibraryParent, &m); + } + return TRUE; + + case WM_COMMAND: + if(LOWORD(wParam) == IDC_RESET_DB_ON_ERROR) + { + nukeLibrary(hwndDlg); + } + break; + + case WM_WINDOWPOSCHANGED: + if ((SWP_NOSIZE | SWP_NOMOVE) != ((SWP_NOSIZE | SWP_NOMOVE) & ((WINDOWPOS*)lParam)->flags) || + (SWP_FRAMECHANGED & ((WINDOWPOS*)lParam)->flags)) + { + LayoutWindows(hwndDlg, !(SWP_NOREDRAW & ((WINDOWPOS*)lParam)->flags)); + } + return 0; + + case WM_USER+66: + if (wParam == -1) + { + LayoutWindows(hwndDlg, TRUE); + } + return TRUE; + + case WM_USER + 0x200: + SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, 1); // yes, we support no - redraw resize + return TRUE; + + case WM_USER + 0x201: + offsetX = (short)LOWORD(wParam); + offsetY = (short)HIWORD(wParam); + g_rgnUpdate = (HRGN)lParam; + return TRUE; + + case WM_PAINT: + { + dialogSkinner.Draw(hwndDlg, 0, 0); + } + return 0; + + case WM_ERASEBKGND: + return 1; //handled by WADlg_DrawChildWindowBorders in WM_PAINT + } + return FALSE; +} diff --git a/Src/Plugins/Library/ml_local/view_media.cpp b/Src/Plugins/Library/ml_local/view_media.cpp new file mode 100644 index 00000000..7c8aa07e --- /dev/null +++ b/Src/Plugins/Library/ml_local/view_media.cpp @@ -0,0 +1,4051 @@ +#include "main.h" +#include "ml_local.h" +#include <windowsx.h> +#include "../nu/listview.h" +#include "..\..\General\gen_ml/config.h" +#include "resource.h" +#include <time.h> +#include "..\..\General\gen_ml/ml_ipc.h" +#include "../ml_pmp/pmp.h" +#include "..\..\General\gen_ml/gaystring.h" +#include "../nde/nde.h" +#include "../replicant/nu/AutoWide.h" +#include "../replicant/nu/AutoChar.h" +#include "..\..\General\gen_ml/ml_ipc_0313.h" +#include <math.h> +#include <shlwapi.h> +#include <strsafe.h> +#include "..\..\General\gen_ml/menufucker.h" +#include "api_mldb.h" +#include "../replicant/foundation/error.h" + +static wchar_t oldText[4096]; + +static int IPC_LIBRARY_SENDTOMENU; +static HINSTANCE cloud_hinst; +const int ML_MSG_PDXS_STATUS = 0x1001; +const int ML_MSG_PDXS_MIX = 0x1002; +void RefreshMetadata(HWND parent); + +static HRGN g_rgnUpdate = NULL; +static int offsetX, offsetY, customAllowed; +int groupBtn = 1, enqueuedef = 0; +static viewButtons view; +HWND hwndSearchGlobal = 0; + +//timers +#define TIMER_RATINGAUTOUNHOVER_ID 65520 +#define TIMER_RATINGAUTOUNHOVER_DELAY 200 + +void FixAmps(wchar_t *str, size_t len) +{ + size_t realSize = 0; + size_t extra = 0; + wchar_t *itr = str; + while (itr && *itr) + { + if (itr && *itr == L'&') + extra++; + itr++; + realSize++; + } + + extra = min(len - (realSize + 1), extra); + + while (extra) + { + str[extra+realSize] = str[realSize]; + if (str[realSize] == L'&') + { + extra--; + str[extra+realSize] = L'&'; + } + realSize--; + } +} + +void MakeDateString(__time64_t convertTime, wchar_t *dest, size_t destlen) +{ + SYSTEMTIME sysTime; + tm *newtime = _localtime64(&convertTime); + if (newtime) + { + sysTime.wYear = (WORD)(newtime->tm_year + 1900); + sysTime.wMonth = (WORD)(newtime->tm_mon + 1); + sysTime.wDayOfWeek = (WORD)newtime->tm_wday; + sysTime.wDay = (WORD)newtime->tm_mday; + sysTime.wHour = (WORD)newtime->tm_hour; + sysTime.wMinute = (WORD)newtime->tm_min; + sysTime.wSecond = (WORD)newtime->tm_sec; + sysTime.wMilliseconds = 0; + + GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &sysTime, NULL, dest, destlen); + + size_t dateSize = lstrlenW(dest); + dest += dateSize; + destlen -= dateSize; + if (destlen) + { + *dest++ = L' '; + destlen--; + } + + GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &sysTime, NULL, dest, destlen); + + //wcsftime(expire_time, 63, L"%b %d, %Y", _localtime64(&convertTime)); + } + else + dest[0] = 0; +} + +#define MAINTABLE_ID_CLOUD (unsigned char)-1 +const unsigned char extra_idsW[] = +{ + MAINTABLE_ID_ISPODCAST, + MAINTABLE_ID_PODCASTCHANNEL, + MAINTABLE_ID_PODCASTPUBDATE, + MAINTABLE_ID_GRACENOTEFILEID, + MAINTABLE_ID_GRACENOTEEXTDATA, + MAINTABLE_ID_LOSSLESS, + MAINTABLE_ID_CODEC, + MAINTABLE_ID_DIRECTOR, + MAINTABLE_ID_PRODUCER, + MAINTABLE_ID_WIDTH, + MAINTABLE_ID_HEIGHT, + MAINTABLE_ID_MIMETYPE, + 0, + MAINTABLE_ID_DATEADDED, + MAINTABLE_ID_CLOUD, +}; + +const ExtendedFields extended_fields = +{ + L"ispodcast", + L"podcastchannel", + L"podcastpubdate", + L"GracenoteFileID", + L"GracenoteExtData", + L"lossless", + L"codec", + L"director", + L"producer", + L"width", + L"height", + L"mime", + L"realsize", + L"dateadded", + L"cloud", +}; + +const wchar_t *extra_strsW[] = +{ + extended_fields.ispodcast, + extended_fields.podcastchannel, + extended_fields.podcastpubdate, + extended_fields.GracenoteFileID, + extended_fields.GracenoteExtData, + extended_fields.lossless, + extended_fields.codec, + extended_fields.director, + extended_fields.producer, + extended_fields.width, + extended_fields.height, + extended_fields.mimetype, + extended_fields.realsize, + extended_fields.dateadded, + extended_fields.cloud, +}; + +const int NUM_EXTRA_COLSW = sizeof(extra_idsW) / sizeof(*extra_idsW); + +bool isMixable(itemRecordW &song); +static int predixisExist; + +static BOOL g_displaysearch = TRUE; +static BOOL g_displaycontrols = TRUE; + +nde_scanner_t m_media_scanner = 0; + +W_ListView resultlist; +static int resultSkin; + +void fileInfoDialogs(HWND hwndParent); +void editInfo(HWND hwndParent); +void customizeColumnsDialog(HWND hwndParent); + +static HWND m_hwnd; + +itemRecordListW itemCache; +static int bgThread_Kill = 0; +static HANDLE bgThread_Handle; +static bool isMixablePresent = true; + +CloudFiles cloudFiles, cloudUploading; + +typedef struct +{ + UINT column_id; + char *config_name; + WORD defWidth; + WORD minWidth; + WORD maxWidth; +} +headerColumn; + +#define UNLIMITED_WIDTH ((WORD)-1) + +#define COLUMN_DEFMINWIDTH 12 +#define COLUMN_DEFMAXWIDTH UNLIMITED_WIDTH + +#define MAX_COLUMN_ORDER (MEDIAVIEW_COL_NUMS+1) + +static headerColumn columnList[MAX_COLUMN_ORDER - 1] = +{ + {IDS_ARTIST, "mv_col_artist", 140, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_TITLE, "mv_col_title", 140, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_ALBUM, "mv_col_album", 140, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_LENGTH, "mv_col_length", 55, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_TRACK_NUMBER, "mv_col_track", 55, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_GENRE, "mv_col_genre", 75, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_YEAR, "mv_col_year", 55, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_FILENAME, "mv_col_fn", 140, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_RATING, "mv_col_rating", 65, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_PLAY_COUNT, "mv_col_playcount", 70, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_PLAYED_LAST, "mv_col_lastplay", 115, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_LAST_UPDATED, "mv_col_lastupd", 115, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_FILE_TIME, "mv_col_filetime", 115, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_COMMENT, "mv_col_comment", 140, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_FILE_SIZE, "mb_col_filesize", 100, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_BITRATE, "mb_col_bitrate", 100, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_TYPE, "mb_col_type", 100, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_DISC, "mb_col_disc", 55, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_ALBUM_ARTIST, "mb_col_albumartist", 100, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_FILE_PATH, "mb_col_filepath", 140, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_ALBUM_GAIN, "mb_col_albumgain", 100, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_TRACK_GAIN, "mb_col_trackgain", 100, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_PUBLISHER, "mb_col_publisher", 100, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_COMPOSER, "mb_col_composer", 100, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_EXTENSION, "mb_col_extension", 55, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_IS_PODCAST, "mb_col_ispodcast", 100, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_PODCAST_CHANNEL, "mb_col_podcastchannel", 100, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_PODCAST_PUBLISH_DATE, "mb_col_podcastpubdate", 115, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_BPM, "mb_col_bpm", 55, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_CATEGORY, "mb_col_category", 75, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_DIRECTOR, "mb_col_director", 100, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_PRODUCER, "mb_col_producer", 100, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_DIMENSION, "mb_col_dimension", 100, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_DATE_ADDED, "mb_col_dateadded", 115, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, + {IDS_CLOUD, "mv_col_cloud", 27, COLUMN_DEFMINWIDTH, COLUMN_DEFMAXWIDTH}, +}; + +//default column order +static signed char defColumnOrderCloud[MAX_COLUMN_ORDER] = +{ + MEDIAVIEW_COL_ARTIST, + MEDIAVIEW_COL_ALBUM, + MEDIAVIEW_COL_TRACK, + MEDIAVIEW_COL_CLOUD, + MEDIAVIEW_COL_TITLE, + MEDIAVIEW_COL_LENGTH, + MEDIAVIEW_COL_GENRE, + MEDIAVIEW_COL_RATING, + MEDIAVIEW_COL_PLAYCOUNT, + MEDIAVIEW_COL_LASTPLAY, + MEDIAVIEW_COL_YEAR, + -1 +}; +static signed char defColumnOrder[MAX_COLUMN_ORDER] = +{ + MEDIAVIEW_COL_ARTIST, + MEDIAVIEW_COL_ALBUM, + MEDIAVIEW_COL_TRACK, + MEDIAVIEW_COL_TITLE, + MEDIAVIEW_COL_LENGTH, + MEDIAVIEW_COL_GENRE, + MEDIAVIEW_COL_RATING, + MEDIAVIEW_COL_PLAYCOUNT, + MEDIAVIEW_COL_LASTPLAY, + MEDIAVIEW_COL_YEAR, + -1 +}; +static signed char columnOrder[MAX_COLUMN_ORDER]; + + +int WCSCMP_NULLOK(const wchar_t *pa, const wchar_t *pb) +{ + if (!pa) pa = L""; + else SKIP_THE_AND_WHITESPACEW(pa) + + if (!pb) pb = L""; + else SKIP_THE_AND_WHITESPACEW(pb) + + return CompareStringW(LOCALE_USER_DEFAULT, NORM_IGNORECASE /*| NORM_IGNORENONSPACE*/, pa, -1, pb, -1) - 2; +// return lstrcmpi(pa, pb); +} + + +int FLOATWCMP_NULLOK(const wchar_t *pa, const wchar_t *pb) +{ + if (pa) SKIP_THE_AND_WHITESPACEW(pa) + + if (pb) SKIP_THE_AND_WHITESPACEW(pb) + + if ((!pa || !*pa) && (!pb || !*pb)) + return 0; + if (!pa || !*pa) + return 1; + if (!pb || !*pb) + return -1; + + _locale_t C_locale = WASABI_API_LNG->Get_C_NumericLocale(); + float a = (float)_wtof_l(pa,C_locale); + float b = (float)_wtof_l(pb,C_locale); + + if (a > b) + return 1; + else if (a < b) + return -1; + else + return 0; +} + + +typedef struct +{ + resultsniff_funcW cb; + int user32; +} +bgThreadParms; + +static int bg_total_len_s; +static __int64 bg_total_len_bytes; +static LARGE_INTEGER querytime; + +static HMENU rate_hmenu = NULL; +static HMENU cloud_hmenu = NULL; +static HMENU sendto_hmenu = NULL; +static librarySendToMenuStruct s; + +static RATINGCOLUMN ratingColumn; +static WCHAR ratingBackText[128]; + +#define IDC_LIST2HEADER 2001 // WM_INITDIALOG assign this is to the IDC_LIST2 header + +// internal messages +#define IM_SYNCHEADERORDER (WM_USER + 0xFFF0) + +static DWORD WINAPI bgThreadQueryProc(void *tmp) +{ + bgThreadParms *p = (bgThreadParms*)tmp; + bg_total_len_s = 0; + bg_total_len_bytes = 0; + LARGE_INTEGER starttime, endtime; + QueryPerformanceCounter(&starttime); + + bg_total_len_s = saveQueryToListW(g_view_metaconf, m_media_scanner, &itemCache, + &cloudFiles, &cloudUploading, p->cb, p->user32, + &bgThread_Kill, &bg_total_len_bytes); + QueryPerformanceCounter(&endtime); + querytime.QuadPart = endtime.QuadPart - starttime.QuadPart; + + if (!bgThread_Kill) PostMessage(m_hwnd, WM_APP + 3, 0x69, 0); + + return 0; +} + +void bgQuery_Stop() // exported for other people to call since it is useful (eventually +// we should have bgQuery pass the new query info along but I'll do that soon) +{ + if (bgThread_Handle) + { + bgThread_Kill = 1; + WaitForSingleObject(bgThread_Handle, INFINITE); + CloseHandle(bgThread_Handle); + bgThread_Handle = 0; + } + KillTimer(m_hwnd, 123); +} + +static void bgQuery(resultsniff_funcW cb = 0, int user32 = 0) // only internal used +{ + bgQuery_Stop(); + SetDlgItemTextW(m_hwnd, IDC_MEDIASTATUS, WASABI_API_LNGSTRINGW(IDS_SCANNING)); + StringCchCopyW(oldText, 4096, WASABI_API_LNGSTRINGW(IDS_SCANNING)); + + SetTimer(m_hwnd, 123, 200, NULL); + + DWORD id; + static bgThreadParms parms; + parms.cb = cb; + parms.user32 = user32; + bgThread_Kill = 0; + bgThread_Handle = CreateThread(NULL, 0, bgThreadQueryProc, (LPVOID) & parms, 0, &id); +} + +// this thing does not produce a fully valid itemRecordList. be afraid. +static void copyFilesToItemCacheW(itemRecordListW *obj) +{ + if (bgThread_Handle) return ; + + int cnt = itemCache.Size; + int i, l = cnt; + cnt = 0; + for (i = 0;i < l;i++) + { + if (resultlist.GetSelected(i)) cnt++; + } + obj->Alloc = obj->Size = 0; + + if (!cnt) return ; + + allocRecordList(obj, cnt, 0); + if (!obj->Items) + { + obj->Size = obj->Alloc = 0; + return ; + } + + for (i = 0; i < itemCache.Size; i ++) + { + if (resultlist.GetSelected(i)) + { + obj->Items[obj->Size++] = itemCache.Items[i]; + // makes sure that we are providing filesize in kb as + // per spec even if we store it as __int64 internally + obj->Items[obj->Size-1].filesize /= 1024; + } + } +} + +void playFiles(int enqueue, int all) +{ + if (bgThread_Handle) return ; + + int cnt = 0; + int l = itemCache.Size; + + int foo_all = 0; // all but play the only selected + int foo_selected = -1; + + if (!enqueue && !all && g_config->ReadInt(L"viewplaymode", 1)) + { + int selcnt = 0; + for (int i = 0;i < l;i++) + { + if (resultlist.GetSelected(i)) selcnt++; + } + if (selcnt == 1) + { + foo_all = -1; + } + } + + for (int i = 0;i < l;i++) + { + if (foo_all || all || resultlist.GetSelected(i)) + { + if (foo_all && foo_selected < 0 && resultlist.GetSelected(i)) foo_selected = i; + + if (!cnt) + { + if (!enqueue) SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_DELETE); + cnt++; + } + + wchar_t title[2048] = {0}; + TAG_FMT_EXT(itemCache.Items[i].filename, itemrecordWTagFunc, ndeTagFuncFree, (void*)&itemCache.Items[i], title, 2048, 0); + + enqueueFileWithMetaStructW s; + s.filename = itemCache.Items[i].filename; + s.title = title; + s.ext = NULL; + s.length = itemCache.Items[i].length; +#ifndef _DEBUG + ndestring_retain(itemCache.Items[i].filename); + SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&s, IPC_PLAYFILEW_NDE); +#else + SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&s, IPC_PLAYFILEW); +#endif + } + } + if (cnt) + { + if (foo_selected >= 0) + { + SendMessage(plugin.hwndWinampParent, WM_WA_IPC, foo_selected, IPC_SETPLAYLISTPOS); + SendMessage(plugin.hwndWinampParent, WM_COMMAND, 40047, 0); // stop button, literally + SendMessage(plugin.hwndWinampParent, WM_COMMAND, 40045, 0); // play button, literally + } + else if (!enqueue) SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_STARTPLAY); + } +} + +// out can never be bigger than in+1 +static void parsequicksearch(wchar_t *out, wchar_t *in) // parses a list into a list of terms that we are searching for +{ + int inquotes = 0, neednull = 0; + while (in && *in) + { + wchar_t c = *in++; + if (c != ' ' && c != '\t' && c != '\"') + { + neednull = 1; + *out++ = c; + } + else if (c == '\"') + { + inquotes = !inquotes; + if (!inquotes) + { + *out++ = 0; + neednull = 0; + } + } + else + { + if (inquotes) *out++ = c; + else if (neednull) + { + *out++ = 0; + neednull = 0; + } + } + } + *out++ = 0; + *out++ = 0; +} + +void makeQueryStringFromText(GayStringW *query, wchar_t *text, int nf) +{ + int ispar = 0; + if (query->Get()[0]) + { + ispar = 1; + query->Append(L"&("); + } + + if (!_wcsnicmp(text, L"query:", 6)) + query->Append(text + 6); // copy the query as is + else if (text[0] == L'?') + query->Append(text + 1); + else + { + int isAny = 0; + if (*text == L'*' && text[1] == L' ') + { + isAny = 1; + text += 2; + } + wchar_t tmpbuf[2048 + 32] = {0}; + parsequicksearch(tmpbuf, text); + + int x; + wchar_t *fields[] = + { + L"filename", + L"title", + L"artist", + L"album", + L"genre", + L"albumartist", + L"publisher", + L"composer", + }; + wchar_t *p = tmpbuf; + while (p && *p) + { + size_t lenp = wcslen(p); + + if (p == tmpbuf) query->Append(L"("); + else if (isAny) query->Append(L")|("); + else query->Append(L")&("); + if (p[0] == L'<' && p[wcslen(p) - 1] == L'>' && wcslen(p) > 2) + { + wchar_t *op = p; + while (op && *op) + { + if (*op == L'\'') *op = L'\"'; + op++; + } + + p[lenp - 1] = 0; // remove > + query->Append(p + 1); + } + else + { + for (x = 0; x < (int)min(sizeof(fields) / sizeof(fields[0]), nf); x ++) + { + wchar_t *field = fields[x]; + if (x) query->Append(L"|"); + query->Append(field); + query->Append(L" HAS \""); + GayStringW escaped; + queryStrEscape(p, escaped); + query->Append(escaped.Get()); + query->Append(L"\""); + } + } + p += lenp + 1; + } + query->Append(L")"); + } + if (ispar) query->Append(L")"); +} + +static void doQuery(HWND hwndDlg, wchar_t *text, int dobg = 1) +{ + bgQuery_Stop(); + + GayStringW query; + if (text[0]) makeQueryStringFromText(&query, text); + + wchar_t *parent_query = NULL; + extern wchar_t* m_query; + parent_query = m_query; + SendMessage(GetParent(hwndDlg), WM_APP + 2, 0, (LPARAM)&parent_query); + GayStringW q; + + if (parent_query && parent_query[0]) + { + q.Set(L"("); + q.Append(parent_query); + q.Append(L")"); + } + if (query.Get() && query.Get()[0]) + { + if (q.Get()[0]) + { + q.Append(L" & ("); + q.Append(query.Get()); + q.Append(L")"); + } + else q.Set(query.Get()); + } + + EnterCriticalSection(&g_db_cs); + NDE_Scanner_Query(m_media_scanner, q.Get()); + LeaveCriticalSection(&g_db_cs); + if (dobg) bgQuery(); +} + +static void RecycleSelectedItems() +{ + int totalItems = resultlist.GetSelectedCount(); + + if (!totalItems) + return ; + + SHFILEOPSTRUCTW fileOp; + fileOp.hwnd = m_hwnd; + fileOp.wFunc = FO_DELETE; + fileOp.pFrom = 0; + fileOp.pTo = 0; + fileOp.fFlags = SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_USES_RECYCLEBIN) ? FOF_ALLOWUNDO : 0; + fileOp.fAnyOperationsAborted = 0; + fileOp.hNameMappings = 0; + fileOp.lpszProgressTitle = 0; + + EnterCriticalSection(&g_db_cs); + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + + int cchLen = totalItems * (MAX_PATH + 1) + 1; + wchar_t *files = new wchar_t[cchLen]; // need room for each file name, null terminated. then have to null terminate the whole list + + if (files) // if malloc succeeded + { + wchar_t *curFile = files; + for (int i = 0; i < itemCache.Size; i++) + { + if (resultlist.GetSelected(i)) + { + if (NDE_Scanner_LocateNDEFilename(s, MAINTABLE_ID_FILENAME, FIRST_RECORD, itemCache.Items[i].filename)) + { + StringCchCopyW(curFile, cchLen, itemCache.Items[i].filename); + curFile += wcslen(itemCache.Items[i].filename) + 1; + } + } + } + if (curFile != files) + { + curFile[0] = 0; // null terminate + + fileOp.pFrom = files; + fileOp.fAnyOperationsAborted = 0; + if (SHFileOperationW(&fileOp)) + { + wchar_t title[64] = {0}; + MessageBoxW(m_hwnd, WASABI_API_LNGSTRINGW(IDS_ERROR_DELETING_FILES), + WASABI_API_LNGSTRINGW_BUF(IDS_ERROR,title,64), MB_OK); + } + else + { + // only remove items if deletion was allowed + if (!fileOp.fAnyOperationsAborted) + { + for (int j = 0; j < itemCache.Size; j++) + { + if (resultlist.GetSelected(j)) + { + if (NDE_Scanner_LocateNDEFilename(s, MAINTABLE_ID_FILENAME, FIRST_RECORD, itemCache.Items[j].filename)) + { + // Wasabi callback event for pre remove + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_REMOVED_PRE, (size_t)itemCache.Items[j].filename, 0); + + NDE_Scanner_Delete(s); + NDE_Scanner_Post(s); + g_table_dirty++; + + // Wasabi callback event for post remove + // ToDo: (BigG) Move outside of critical section somehow + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_REMOVED_POST, (size_t)itemCache.Items[j].filename, 0); + + } + } + } + } + } + } + + delete [] files; + } + else // if malloc failed ... maybe because there's too many items. + { + files = new wchar_t[MAX_PATH + 1 + 1]; // double null termination + if (!files) // if this malloc failed, just bail out + { + NDE_Table_DestroyScanner(g_table, s); + LeaveCriticalSection(&g_db_cs); + return ; + } + + fileOp.pFrom = files; + + for (int i = 0;i < itemCache.Size;i++) + { + if (resultlist.GetSelected(i)) + { + if (NDE_Scanner_LocateNDEFilename(s, MAINTABLE_ID_FILENAME, FIRST_RECORD, itemCache.Items[i].filename)) + { + StringCchCopyW(files, MAX_PATH + 1 + 1, itemCache.Items[i].filename); + files[wcslen(itemCache.Items[i].filename) + 1] = 0; // double null terminate + fileOp.fAnyOperationsAborted = 0; + if (SHFileOperationW(&fileOp)) + { + wchar_t mes[4096] = {0}; + StringCchPrintfW(mes, 4096, WASABI_API_LNGSTRINGW(IDS_ERROR_DELETING_X), files); + MessageBoxW(m_hwnd, mes, WASABI_API_LNGSTRINGW(IDS_ERROR), MB_OK); + continue; + } + if (!fileOp.fAnyOperationsAborted) + { + // Wasabi callback event for pre remove + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_REMOVED_PRE, (size_t)itemCache.Items[i].filename, 0); + + NDE_Scanner_Delete(s); + NDE_Scanner_Post(s); + g_table_dirty++; + + // Wasabi callback event for post remove + // ToDo: (BigG) Move outside of critical section somehow + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_REMOVED_POST, (size_t)itemCache.Items[i].filename, 0); + } + } + } + delete files; + } + } + NDE_Table_DestroyScanner(g_table, s); + if (g_table_dirty) NDE_Table_Sync(g_table); + g_table_dirty = 0; + LeaveCriticalSection(&g_db_cs); + + resultlist.Clear(); + emptyRecordList(&itemCache); + + // this might be gay, refreshing it completely (i.e. the cursor pos gets put back to normal, etc), + // but really it is necessary for the view to be accurate. + + SendMessage(m_hwnd, WM_APP + 1, 0, 0); //refresh current view +} + +static void removeSelectedItems(int physical) +{ + if (physical) + { + RecycleSelectedItems(); + return ; + } + + int hasdel = 0; + + EnterCriticalSection(&g_db_cs); + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + + for (int i = 0;i < itemCache.Size;i++) + { + if (resultlist.GetSelected(i)) + { + if (NDE_Scanner_LocateNDEFilename(s, MAINTABLE_ID_FILENAME, FIRST_RECORD, itemCache.Items[i].filename)) + { + wchar_t conf[32] = {0}; + if (!hasdel && MessageBoxW(m_hwnd, WASABI_API_LNGSTRINGW(IDS_SURE_YOU_WANT_TO_REMOVE_SELECTED_FROM_LIBRARY), + WASABI_API_LNGSTRINGW_BUF(IDS_CONFIRMATION,conf,32), MB_YESNO | MB_ICONQUESTION) != IDYES) + { + NDE_Table_DestroyScanner(g_table, s); + LeaveCriticalSection(&g_db_cs); + return ; + //FUCKO> need to eat the RETURN msg + //MSG msg; + //while(PeekMessage(&msg,m_hwnd,WM_COMMAND,WM_COMMAND,1)); + } + if (!hasdel) // stop any background queries + { + bgQuery_Stop(); + } + // Wasabi callback event for pre remove + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_REMOVED_PRE, (size_t)itemCache.Items[i].filename, 0); + + hasdel = 1; + NDE_Scanner_Delete(s); + NDE_Scanner_Post(s); + g_table_dirty++; + + // Wasabi callback event for post remove + // ToDo: (BigG) Move this outside of the critical section + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_REMOVED_POST, (size_t)itemCache.Items[i].filename, 0); + } + } + } + + NDE_Table_DestroyScanner(g_table, s); + if (g_table_dirty) NDE_Table_Sync(g_table); + g_table_dirty = 0; + LeaveCriticalSection(&g_db_cs); + + if (!hasdel) return ; + + resultlist.Clear(); + emptyRecordList(&itemCache); + + // this might be gay, refreshing it completely (i.e. the cursor pos gets put back to normal, etc), + // but really it is necessary for the view to be accurate. + + SendMessage(m_hwnd, WM_APP + 1, 0, 0); //refresh current view +} + +static void exploreItemFolder(HWND hwndDlg) +{ + if (resultlist.GetSelectionMark() >= 0) + { + int l=resultlist.GetCount(); + for(int i=0;i<l;i++) + { + if (resultlist.GetSelected(i)) + { + WASABI_API_EXPLORERFINDFILE->AddFile(itemCache.Items[i].filename); + } + } + WASABI_API_EXPLORERFINDFILE->ShowFiles(); + } +} + +static void removeDeadFiles(HWND hwndDlg) +{ + Scan_RemoveFiles(hwndDlg); + + // this might be gay, refreshing it completely (i.e. the cursor pos gets put back to normal, etc), + // but really it is necessary for the view to be accurate. + SendMessage(m_hwnd, WM_APP + 1, 0, 0); //refresh current view +} + +static WNDPROC search_oldWndProc; +static DWORD WINAPI search_newWndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + if (uMsg == WM_KEYDOWN && wParam == VK_DOWN) + { + PostMessageW(GetParent(hwndDlg), WM_NEXTDLGCTL, (WPARAM)resultlist.getwnd(), (LPARAM)TRUE); + ListView_SetItemState(resultlist.getwnd(), 0, LVIS_FOCUSED | LVIS_SELECTED, LVIS_FOCUSED | LVIS_SELECTED); + } + return CallWindowProcW(search_oldWndProc, hwndDlg, uMsg, wParam, lParam); +} + +typedef struct _LAYOUT +{ + INT id; + HWND hwnd; + INT x; + INT y; + INT cx; + INT cy; + DWORD flags; + HRGN rgn; +} +LAYOUT, PLAYOUT; + +#define SETLAYOUTPOS(_layout, _x, _y, _cx, _cy) { _layout->x=_x; _layout->y=_y;_layout->cx=_cx;_layout->cy=_cy;_layout->rgn=NULL; } +#define SETLAYOUTFLAGS(_layout, _r) \ + { \ + BOOL fVis; \ + fVis = (WS_VISIBLE & (LONG)GetWindowLongPtr(_layout->hwnd, GWL_STYLE)); \ + if (_layout->x == _r.left && _layout->y == _r.top) _layout->flags |= SWP_NOMOVE; \ + if (_layout->cx == (_r.right - _r.left) && _layout->cy == (_r.bottom - _r.top)) _layout->flags |= SWP_NOSIZE; \ + if ((SWP_HIDEWINDOW & _layout->flags) && !fVis) _layout->flags &= ~SWP_HIDEWINDOW; \ + if ((SWP_SHOWWINDOW & _layout->flags) && fVis) _layout->flags &= ~SWP_SHOWWINDOW; \ + } + +#define LAYOUTNEEEDUPDATE(_layout) ((SWP_NOMOVE | SWP_NOSIZE) != ((SWP_NOMOVE | SWP_NOSIZE | SWP_HIDEWINDOW | SWP_SHOWWINDOW) & _layout->flags)) + +#define GROUP_MIN 0x1 +#define GROUP_MAX 0x3 +#define GROUP_SEARCH 0x1 +#define GROUP_STATUSBAR 0x2 +#define GROUP_MAIN 0x3 + + +static void LayoutWindows(HWND hwnd, BOOL fRedraw, BOOL fUpdateAll = FALSE) +{ + static INT controls[] = + { + GROUP_SEARCH, IDC_SEARCHCAPTION, IDC_CLEAR, IDC_QUICKSEARCH, + GROUP_STATUSBAR, IDC_BUTTON_PLAY, IDC_BUTTON_ENQUEUE, IDC_BUTTON_MIX, IDC_BUTTON_CREATEPLAYLIST, IDC_BUTTON_INFOTOGGLE, IDC_MIXABLE, IDC_MEDIASTATUS, + GROUP_MAIN, IDC_LIST2 + }; + + INT index; + RECT rc, rg, ri; + LAYOUT layout[sizeof(controls)/sizeof(controls[0])], *pl; + BOOL skipgroup; + HRGN rgn = NULL; + + GetClientRect(hwnd, &rc); + if (rc.bottom == rc.top || rc.right == rc.left) return; + + SetRect(&rg, rc.left, rc.top, rc.right, rc.bottom); + + pl = layout; + skipgroup = FALSE; + + InvalidateRect(hwnd, NULL, TRUE); + + for (index = 0; index < sizeof(controls) / sizeof(*controls); index++) + { + if (controls[index] >= GROUP_MIN && controls[index] <= GROUP_MAX) // group id + { + skipgroup = FALSE; + switch (controls[index]) + { + case GROUP_SEARCH: + if (g_displaysearch) + { + wchar_t buffer[128] = {0}; + HWND ctrl = GetDlgItem(hwnd, IDC_CLEAR); + GetWindowTextW(ctrl, buffer, ARRAYSIZE(buffer)); + LRESULT idealSize = MLSkinnedButton_GetIdealSize(ctrl, buffer); + + SetRect(&rg, rc.left, + rc.top + WASABI_API_APP->getScaleY(2), + rc.right - WASABI_API_APP->getScaleX(2), + rc.top + WASABI_API_APP->getScaleY(HIWORD(idealSize)+1)); + rc.top = rg.bottom + WASABI_API_APP->getScaleY(3); + } + skipgroup = !g_displaysearch; + break; + case GROUP_STATUSBAR: + if (g_displaycontrols) + { + wchar_t buffer[128] = {0}; + HWND ctrl = GetDlgItem(hwnd, IDC_BUTTON_PLAY); + GetWindowTextW(ctrl, buffer, ARRAYSIZE(buffer)); + LRESULT idealSize = MLSkinnedButton_GetIdealSize(ctrl, buffer); + + SetRect(&rg, rc.left + WASABI_API_APP->getScaleX(1), + rc.bottom - WASABI_API_APP->getScaleY(HIWORD(idealSize)), + rc.right, rc.bottom); + rc.bottom = rg.top - WASABI_API_APP->getScaleY(3); + } + skipgroup = !g_displaycontrols; + break; + case GROUP_MAIN: + SetRect(&rg, rc.left + WASABI_API_APP->getScaleX(1), rc.top, rc.right, rc.bottom); + break; + } + continue; + } + if (skipgroup) continue; + + pl->id = controls[index]; + pl->hwnd = GetDlgItem(hwnd, pl->id); + if (!pl->hwnd) continue; + + GetWindowRect(pl->hwnd, &ri); + MapWindowPoints(HWND_DESKTOP, hwnd, (LPPOINT)&ri, 2); + pl->flags = SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOREDRAW | SWP_NOCOPYBITS; + + switch (pl->id) + { + case IDC_SEARCHCAPTION: + { + wchar_t buffer[128] = {0}; + GetWindowTextW(pl->hwnd, buffer, ARRAYSIZE(buffer)); + LRESULT idealSize = MLSkinnedStatic_GetIdealSize(pl->hwnd, buffer); + + SETLAYOUTPOS(pl, rg.left + WASABI_API_APP->getScaleX(2), + rg.top + WASABI_API_APP->getScaleY(1), + WASABI_API_APP->getScaleX(LOWORD(idealSize)), + (rg.bottom - rg.top)); + rg.left += (pl->cx + WASABI_API_APP->getScaleX(4)); + break; + } + case IDC_CLEAR: + { + wchar_t buffer[128] = {0}; + GetWindowTextW(pl->hwnd, buffer, ARRAYSIZE(buffer)); + LRESULT idealSize = MLSkinnedButton_GetIdealSize(pl->hwnd, buffer); + LONG width = LOWORD(idealSize) + WASABI_API_APP->getScaleX(6); + pl->flags |= (((rg.right - rg.left) - width) > WASABI_API_APP->getScaleX(40)) ? SWP_SHOWWINDOW : SWP_HIDEWINDOW ; + SETLAYOUTPOS(pl, rg.right - width, rg.top, width, rg.bottom - rg.top); + if (SWP_SHOWWINDOW & pl->flags) rg.right -= (pl->cx + WASABI_API_APP->getScaleX(4)); + break; + } + case IDC_QUICKSEARCH: + pl->flags |= (rg.right > rg.left) ? SWP_SHOWWINDOW : SWP_HIDEWINDOW; + SETLAYOUTPOS(pl, rg.left, rg.top, rg.right - rg.left - WASABI_API_APP->getScaleX(1), + (rg.bottom - rg.top) - WASABI_API_APP->getScaleY(1)); + break; + case IDC_BUTTON_PLAY: + case IDC_BUTTON_ENQUEUE: + case IDC_BUTTON_MIX: + case IDC_BUTTON_CREATEPLAYLIST: + if (IDC_BUTTON_MIX != pl->id || customAllowed) + { + if (groupBtn && pl->id == IDC_BUTTON_PLAY && enqueuedef == 1) + { + pl->flags |= SWP_HIDEWINDOW; + break; + } + + if (groupBtn && pl->id == IDC_BUTTON_ENQUEUE && enqueuedef != 1) + { + pl->flags |= SWP_HIDEWINDOW; + break; + } + + if (groupBtn && (pl->id == IDC_BUTTON_PLAY || pl->id == IDC_BUTTON_ENQUEUE) && customAllowed) + { + pl->flags |= SWP_HIDEWINDOW; + break; + } + + if (pl->id == IDC_BUTTON_CREATEPLAYLIST && !AGAVE_API_PLAYLIST_GENERATOR) + { + pl->flags |= SWP_HIDEWINDOW; + break; + } + + wchar_t buffer[128] = {0}; + GetWindowTextW(pl->hwnd, buffer, ARRAYSIZE(buffer)); + LRESULT idealSize = MLSkinnedButton_GetIdealSize(pl->hwnd, buffer); + LONG width = LOWORD(idealSize) + WASABI_API_APP->getScaleX(6); + SETLAYOUTPOS(pl, rg.left, rg.bottom - WASABI_API_APP->getScaleY(HIWORD(idealSize)), + width, WASABI_API_APP->getScaleY(HIWORD(idealSize))); + pl->flags |= ((rg.right - rg.left) > width) ? SWP_SHOWWINDOW : SWP_HIDEWINDOW; + if (SWP_SHOWWINDOW & pl->flags) rg.left += (pl->cx + WASABI_API_APP->getScaleX(4)); + } + else + pl->flags |= SWP_HIDEWINDOW; + break; + case IDC_BUTTON_INFOTOGGLE: + switch (SendMessage(GetParent(hwnd), WM_USER + 66, 0, 0)) + { + case 0xFF: + case 0xF0: + { + wchar_t buffer[128] = {0}; + GetWindowTextW(pl->hwnd, buffer, ARRAYSIZE(buffer)); + LRESULT idealSize = MLSkinnedButton_GetIdealSize(pl->hwnd, buffer); + LONG width = LOWORD(idealSize) + WASABI_API_APP->getScaleX(6); + + pl->flags |= (((rg.right - rg.left) - (ri.right - ri.left)) > WASABI_API_APP->getScaleX(60)) ? SWP_SHOWWINDOW : SWP_HIDEWINDOW ; + SETLAYOUTPOS(pl, rg.right - width - WASABI_API_APP->getScaleX(2), + rg.top, width, (rg.bottom - rg.top)); + if (SWP_SHOWWINDOW & pl->flags) rg.right -= (pl->cx + WASABI_API_APP->getScaleX(4)); + break; + } + } + break; + case IDC_MIXABLE: + if (predixisExist & 1) + { + SETLAYOUTPOS(pl, rg.right - (ri.right - ri.left), rg.top, (ri.right - ri.left), (rg.bottom - rg.top)); + pl->flags |= ((rg.right - rg.left) - (ri.right - ri.left) > WASABI_API_APP->getScaleX(60)) ? SWP_SHOWWINDOW : SWP_HIDEWINDOW; + if (SWP_SHOWWINDOW & pl->flags) rg.right -= (pl->cx + WASABI_API_APP->getScaleX(4)); + } + break; + case IDC_MEDIASTATUS: + SETLAYOUTPOS(pl, rg.left, rg.top, rg.right - rg.left, (rg.bottom - rg.top)); + pl->flags |= (pl->cx > WASABI_API_APP->getScaleX(16)) ? SWP_SHOWWINDOW : SWP_HIDEWINDOW; + break; + case IDC_LIST2: + SETLAYOUTPOS(pl, rg.left, rg.top + 1, (rg.right - rg.left) - WASABI_API_APP->getScaleX(3), (rg.bottom - rg.top) - WASABI_API_APP->getScaleY(2)); + break; + } + + SETLAYOUTFLAGS(pl, ri); + if (LAYOUTNEEEDUPDATE(pl)) + { + if (SWP_NOSIZE == ((SWP_HIDEWINDOW | SWP_SHOWWINDOW | SWP_NOSIZE) & pl->flags) && + ri.left == (pl->x + offsetX) && ri.top == (pl->y + offsetY) && !fUpdateAll && IsWindowVisible(pl->hwnd)) + { + SetRect(&ri, pl->x, pl->y, pl->cx + pl->x, pl->y + pl->cy); + ValidateRect(hwnd, &ri); + } + + pl++; + } + else if (!fUpdateAll && (fRedraw || (!offsetX && !offsetY)) && IsWindowVisible(pl->hwnd)) + { + ValidateRect(hwnd, &ri); + if (GetUpdateRect(pl->hwnd, NULL, FALSE)) + { + if (!rgn) rgn = CreateRectRgn(0,0,0,0); + GetUpdateRgn(pl->hwnd, rgn, FALSE); + OffsetRgn(rgn, pl->x, pl->y); + InvalidateRgn(hwnd, rgn, FALSE); + } + } + } + + if (pl != layout) + { + LAYOUT *pc; + HDWP hdwp = BeginDeferWindowPos((INT)(pl - layout)); + for (pc = layout; pc < pl && hdwp; pc++) + { + hdwp = DeferWindowPos(hdwp, pc->hwnd, NULL, pc->x, pc->y, pc->cx, pc->cy, pc->flags); + } + if (hdwp) EndDeferWindowPos(hdwp); + + if (!rgn) rgn = CreateRectRgn(0, 0, 0, 0); + + if (fRedraw) + { + GetUpdateRgn(hwnd, rgn, FALSE); + for (pc = layout; pc < pl && hdwp; pc++) + { + if (pc->rgn) + { + OffsetRgn(pc->rgn, pc->x, pc->y); + CombineRgn(rgn, rgn, pc->rgn, RGN_OR); + } + } + RedrawWindow(hwnd, NULL, rgn, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASENOW | RDW_ALLCHILDREN); + } + + if (g_rgnUpdate) + { + GetUpdateRgn(hwnd, g_rgnUpdate, FALSE); + for (pc = layout; pc < pl && hdwp; pc++) + { + if (pc->rgn) + { + OffsetRgn(pc->rgn, pc->x, pc->y); + CombineRgn(g_rgnUpdate, g_rgnUpdate, pc->rgn, RGN_OR); + } + } + } + + for (pc = layout; pc < pl && hdwp; pc++) + if (pc->rgn) DeleteObject(pc->rgn); + } + if (rgn) DeleteObject(rgn); + ValidateRgn(hwnd, NULL); +} + +static void updateInfoText(HWND hwndDlg, bool x = false) +{ + int a = SendMessage(GetParent(hwndDlg), WM_USER + 66, x ? -1 : 0, 0); + if (a == 0xff) + SetDlgItemTextW(hwndDlg, IDC_BUTTON_INFOTOGGLE, WASABI_API_LNGSTRINGW(IDS_HIDE_INFO)); + else if (a == 0xf0) + SetDlgItemTextW(hwndDlg, IDC_BUTTON_INFOTOGGLE, WASABI_API_LNGSTRINGW(IDS_SHOW_INFO)); + else ShowWindow(GetDlgItem(hwndDlg, IDC_BUTTON_INFOTOGGLE), SW_HIDE); +} + +static void initColumnsHeader(HWND hwndList) +{ + INT index, sortby; + LVCOLUMNW lvc = {0, }; + if (!hwndList || !IsWindow(hwndList)) return; + + SendMessageW(hwndList, WM_SETREDRAW, FALSE, 0L); + + while (SendMessageW(hwndList, LVM_DELETECOLUMN, 0, 0L)); + + sortby = g_view_metaconf->ReadInt(L"mv_sort_by", 1); + + lvc.mask = LVCF_TEXT | LVCF_WIDTH; + lvc.pszText = L""; + lvc.cx = 30; + SendMessageW(hwndList, LVM_INSERTCOLUMNW, 0, (LPARAM)&lvc); // create dummy column + + // TODO set to a zero width if not available + MLSkinnedHeader_SetCloudColumn(ListView_GetHeader(hwndList), -1); // reset the cloud status column so it'll be correctly removed + SetPropW(hwndList, L"pmp_list_info", (HANDLE)-1); + + for (index = 0; columnOrder[index] != -1; index++) + { + headerColumn *cl = &columnList[columnOrder[index]]; + lvc.pszText = WASABI_API_LNGSTRINGW(cl->column_id); + + lvc.cx = g_view_metaconf->ReadInt(AutoWide(cl->config_name), cl->defWidth); + if (lvc.cx < cl->minWidth) lvc.cx = cl->minWidth; + + // update position of the cloud column icon + if (columnOrder[index] == MEDIAVIEW_COL_CLOUD) + { + if (!cloud_hinst || cloud_hinst == (HINSTANCE)1 || + !SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GET_CLOUD_ACTIVE)) + { + MLSkinnedHeader_SetCloudColumn(ListView_GetHeader(hwndList), -1); + SetPropW(hwndList, L"pmp_list_info", (HANDLE)-1); + lvc.cx = 0; + } + else + { + MLSkinnedHeader_SetCloudColumn(ListView_GetHeader(hwndList), index); + SetPropW(hwndList, L"pmp_list_info", (HANDLE)index); + lvc.cx = 27; + MLCloudColumn_GetWidth(plugin.hwndLibraryParent, &lvc.cx); + } + } + + SendMessageW(hwndList, LVM_INSERTCOLUMNW, 0xFFFF, (LPARAM)&lvc); + + if (sortby == columnOrder[index]) MLSkinnedListView_DisplaySort(hwndList, index, !g_view_metaconf->ReadInt(L"mv_sort_dir", 0)); + } + SendMessageW(hwndList, LVM_DELETECOLUMN, 0, 0L); // Delete dummy column + + for (index = 0; -1 != columnOrder[index] && MEDIAVIEW_COL_RATING != columnOrder[index]/* && MEDIAVIEW_COL_CLOUD != columnOrder[index]*/; index++); + if (-1 != index) SendMessageW(hwndList, LVM_SETCOLUMNWIDTH, index, (LPARAM)SendMessageW(hwndList, LVM_GETCOLUMNWIDTH, index, 0L)); + + SendMessageW(hwndList, WM_SETREDRAW, TRUE, 0L); +} + +static int m_last_selitem = -1; +static int m_bgupdinfoviewerflag; + +extern void add_to_library(HWND wndparent); + +static INT_PTR CALLBACK needAddFilesProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + switch (uMsg) + { + case WM_INITDIALOG: + if (AGAVE_API_ITUNES_IMPORTER && AGAVE_API_ITUNES_IMPORTER->iTunesExists()) + EnableWindow(GetDlgItem(hwndDlg, IDC_IMPORT_ITUNES), TRUE); + else + EnableWindow(GetDlgItem(hwndDlg, IDC_IMPORT_ITUNES), FALSE); + + SetTimer(hwndDlg, 1, 1000, NULL); + return 1; + case WM_COMMAND: + switch(LOWORD(wParam)) + { + case IDOK: + case IDCANCEL: + if (BN_CLICKED == HIWORD(wParam)) + { + if (IsDlgButtonChecked(hwndDlg, IDC_CHECK1)) g_config->WriteInt(L"noshowadddlg", 1); + EndDialog(hwndDlg, 0); + } + break; + case ID_ADD_FILES: + if (BN_CLICKED == HIWORD(wParam)) + { + add_to_library(hwndDlg); + PostMessage(hwndDlg, WM_TIMER, 1, 0); + } + break; + case IDC_IMPORT_ITUNES: + if (BN_CLICKED == HIWORD(wParam)) + { + if (AGAVE_API_ITUNES_IMPORTER) + AGAVE_API_ITUNES_IMPORTER->ImportFromiTunes(hwndDlg); + + PostMessage(hwndDlg, WM_TIMER, 1, 0); + if (m_curview_hwnd) PostMessage(m_curview_hwnd, WM_APP + 1, 0, 0); //update current view + } + break; + case IDC_BTN_LINK_PROMO: + if (BN_CLICKED == HIWORD(wParam)) ShellExecuteA(plugin.hwndWinampParent, "open", "https://help.winamp.com/hc/articles/8105244490772-Player-Overview", NULL, ".", 0); + break; + } + break; + case WM_TIMER: + if (g_table && NDE_Table_GetRecordsCount(g_table)) + { + wchar_t buf[512] = {0}; + StringCchPrintfW(buf, 512, WASABI_API_LNGSTRINGW(IDS_THERE_ARE_NOW_X_ITEMS_IN_THE_LIBRARY), NDE_Table_GetRecordsCount(g_table)); + SetDlgItemTextW(hwndDlg, IDC_TEXT, buf); + SetDlgItemTextW(hwndDlg, ID_ADD_FILES, WASABI_API_LNGSTRINGW(IDS_ADD_MORE)); + } + break; + case WM_DRAWITEM: + { + DRAWITEMSTRUCT *di = (DRAWITEMSTRUCT *)lParam; + if (di->CtlType == ODT_BUTTON) + { + wchar_t wt[123] = {0}; + int y; + RECT r; + HPEN hPen, hOldPen; + DWORD style; + GetDlgItemText(hwndDlg, (INT)wParam, wt, ARRAYSIZE(wt)); + + style = (DWORD)GetWindowLongPtrW(di->hwndItem, GWL_STYLE); + // draw text + SetTextColor(di->hDC, (di->itemState & ODS_SELECTED) ? RGB(220, 0, 0) : RGB(0, 0, 220)); + + memset(&r, 0, sizeof(r)); + DrawText(di->hDC, wt, -1, &r, DT_SINGLELINE | DT_CALCRECT); + + + if (BS_RIGHT & style) r.left = max(di->rcItem.left+ 2, di->rcItem.right - r.right - 2); + else if (BS_LEFT & style) r.left = di->rcItem.left+ 2; + else r.left = ((di->rcItem.right - di->rcItem.left - 4) - r.right) / 2; + + if (r.left < di->rcItem.left + 2) + { + r.left = di->rcItem.left + 2; + r.right = di->rcItem.right - 2; + } + else r.right += r.left; + if (r.right > di->rcItem.right - 2) r.right = di->rcItem.right - 2; + + + if (BS_TOP & style) r.top = di->rcItem.top; + else if(BS_VCENTER & style) r.top = ((di->rcItem.bottom - di->rcItem.top - 2) - r.bottom) /2; + else r.top = di->rcItem.bottom - 2 - r.bottom; + + if (r.top < di->rcItem.top) + { + r.top = di->rcItem.top; + r.bottom = di->rcItem.bottom - 2; + } + else r.bottom += r.top; + if (r.bottom > di->rcItem.bottom - 2) r.bottom = di->rcItem.bottom - 2; + + DrawText(di->hDC, wt, -1, &r, DT_SINGLELINE | DT_WORD_ELLIPSIS); + + // draw underline + y = min(di->rcItem.bottom, r.bottom + 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, r.left, y, NULL); + LineTo(di->hDC, r.right, y); + SelectObject(di->hDC, hOldPen); + DeleteObject(hPen); + } + } + } + + return 0; + +}; + +static void SetStatusText(HWND hwndStatus, LPCWSTR *ppsz, INT count) +{ + WCHAR buffer[4096] = {0}; + if (0 == count || !ppsz) + { + SetWindowText(hwndStatus, L""); + return; + } + buffer[0] = 0x00; + for (int i = 0; i < count; i++) + { + StringCchCatW(buffer, 4096, ppsz[i]); + StringCchCatW(buffer, 4096, L" "); + } + SetWindowTextW(hwndStatus, buffer); + + StringCchCopyW(oldText, 4096, buffer); +} + +static void SetRating(UINT iItem, INT newRating, HWND hwndList) +{ + if (0 == newRating) newRating = -1; + if (iItem < (UINT)itemCache.Size) + { + if (g_table && newRating != itemCache.Items[iItem].rating) + { + EnterCriticalSection(&g_db_cs); + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + + if (NDE_Scanner_LocateNDEFilename(s, MAINTABLE_ID_FILENAME, FIRST_RECORD, itemCache.Items[iItem].filename)) + { + NDE_Scanner_Edit(s); + db_setFieldInt(s, MAINTABLE_ID_RATING, newRating); + NDE_Scanner_Post(s); + itemCache.Items[iItem].rating = newRating; + if (g_config->ReadInt(L"writeratings", 0)) + { + wchar_t buf[64] = {0}; + if (newRating > 0) + { + wsprintfW(buf, L"%d", newRating); + } + else + buf[0] = 0; + updateFileInfo(itemCache.Items[iItem].filename, DB_FIELDNAME_rating, buf); + SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_WRITE_EXTENDED_FILE_INFO); + } + } + NDE_Table_DestroyScanner(g_table, s); + + if (g_table_dirty) + { + g_table_dirty = 0; + NDE_Table_Sync(g_table); + } + LeaveCriticalSection(&g_db_cs); + } + if (newRating == itemCache.Items[iItem].rating && hwndList) + { + ratingColumn.hwndList = hwndList; + ratingColumn.iItem = iItem; + ratingColumn.iSubItem = 600; + MLRatingColumn_Animate(plugin.hwndLibraryParent, &ratingColumn); + ListView_RedrawItems(resultlist.getwnd(), iItem, iItem); + // TODO: benski> update the top panes w/o refreshing, if possible + // CUT: PostMessage(GetParent(GetParent(hwndList)), WM_APP + 4, (WPARAM)newRating, (LPARAM)1); + } + } +} + +/////////// Header Messages / Notifications +static BOOL Header_OnItemChanging(HWND hwndDlg, NMHEADERW *phdr, LRESULT *pResult, UINT uMsg) +{ + if (phdr->pitem && (HDI_WIDTH & phdr->pitem->mask)) + { + INT test; + test = columnList[columnOrder[phdr->iItem]].minWidth; + if (phdr->pitem->cxy < test) phdr->pitem->cxy = test; + test = columnList[columnOrder[phdr->iItem]].maxWidth; + if (test != UNLIMITED_WIDTH && phdr->pitem->cxy > test) phdr->pitem->cxy = test; + + if (MEDIAVIEW_COL_RATING == columnOrder[phdr->iItem]) + { + RATINGWIDTH rw; + + rw.fStyle = RCS_DEFAULT; + rw.width = phdr->pitem->cxy; + if (MLRatingColumn_GetWidth(plugin.hwndLibraryParent, &rw)) phdr->pitem->cxy = rw.width; + if (0 == phdr->iItem) + { + RATINGBACKTEXT rbt; + rbt.pszText = ratingBackText; + rbt.cchTextMax = sizeof(ratingBackText)/sizeof(WCHAR); + rbt.nColumnWidth = phdr->pitem->cxy; + rbt.fStyle = RCS_DEFAULT; + MLRatingColumn_FillBackString(plugin.hwndLibraryParent, &rbt); + } + else ratingBackText[0] = 0x00; + } + else if (MEDIAVIEW_COL_CLOUD == columnOrder[phdr->iItem]) + { + if (!cloud_hinst || cloud_hinst == (HINSTANCE)1 || + !SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GET_CLOUD_ACTIVE)) + phdr->pitem->cxy = 0; + else + { + INT width = phdr->pitem->cxy; + if (MLCloudColumn_GetWidth(plugin.hwndLibraryParent, &width)) + { + phdr->pitem->cxy = width; + } + } + } + } + return FALSE; +} + +static BOOL Header_OnEndDrag(HWND hwndDlg, NMHEADERW *phdr, LRESULT *pResult) +{ + PostMessageW(hwndDlg, IM_SYNCHEADERORDER, 0, (LPARAM)phdr->hdr.hwndFrom); + return FALSE; +} + +static BOOL Header_OnRightClick(HWND hwndDlg, NMHDR *pnmh, LRESULT *pResult) +{ + HMENU menu = GetSubMenu(g_context_menus, 4); + POINT p; + GetCursorPos(&p); + int r = DoTrackPopup(menu, TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTBUTTON, p.x, p.y, hwndDlg, NULL); + switch (r) + { + case ID_HEADERWND_CUSTOMIZECOLUMNS: + customizeColumnsDialog(hwndDlg); + break; + } + return FALSE; +} + +/////////// ListView Messages / Notifications +static BOOL ListView_OnItemChanged(HWND hwndDlg, NMLISTVIEW *pnmv) +{ + if (pnmv->uNewState & LVIS_SELECTED) + { + //if (GetFocus()==resultlist.getwnd()) + { + m_last_selitem = pnmv->iItem; + KillTimer(hwndDlg, 6600); + SetTimer(hwndDlg, 6600, 250, NULL); + } + } + else + { + if (isMixablePresent) + { + SetDlgItemText(hwndDlg, IDC_MIXABLE, L""); + isMixablePresent = false; + } + } + return FALSE; +} + +static BOOL ListView_OnDoubleClick(HWND hwndDlg, NMITEMACTIVATE *pnmitem) +{ + playFiles((!!g_config->ReadInt(L"enqueuedef", 0)) ^(!!(GetAsyncKeyState(VK_SHIFT)&0x8000)), 0); + return FALSE; +} + +void EatKeyboard() +{ + Sleep(100); + MSG msg; + while (PeekMessage(&msg, NULL, WM_KEYFIRST, WM_KEYLAST, PM_REMOVE)); //eat return +} + +static void Dialog_OnContextMenu(HWND hwndDlg, HWND hwndFrom, int x, int y) +{ + if (hwndFrom != resultlist.getwnd()) + return; + + POINT pt = {x,y}; + + if (x == -1 || y == -1) // x and y are -1 if the user invoked a shift-f10 popup menu + { + RECT itemRect = {0}; + int selected = resultlist.GetNextSelected(); + if (selected != -1) // if something is selected we'll drop the menu from there + { + resultlist.GetItemRect(selected, &itemRect); + ClientToScreen(resultlist.getwnd(), (POINT *)&itemRect); + } + else // otherwise we'll drop it from the top-left corner of the listview, adjusting for the header location + { + GetWindowRect(resultlist.getwnd(), &itemRect); + + HWND hHeader = (HWND)SNDMSG(resultlist.getwnd(), LVM_GETHEADER, 0, 0L); + RECT headerRect; + if ((WS_VISIBLE & GetWindowLongPtr(hHeader, GWL_STYLE)) && GetWindowRect(hHeader, &headerRect)) + { + itemRect.top += (headerRect.bottom - headerRect.top); + } + } + x = itemRect.left; + y = itemRect.top; + } + + HWND hHeader = (HWND)SNDMSG(resultlist.getwnd(), 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; + } + + HMENU globmenu = WASABI_API_LOADMENU(IDR_CONTEXTMENUS); + HMENU menu = GetSubMenu(globmenu, 0); + int rate_idx = 9; + sendto_hmenu = GetSubMenu(menu, 2); + rate_hmenu = GetSubMenu(menu, rate_idx); + + ConvertRatingMenuStar(rate_hmenu, ID_RATE_5); + ConvertRatingMenuStar(rate_hmenu, ID_RATE_4); + ConvertRatingMenuStar(rate_hmenu, ID_RATE_3); + ConvertRatingMenuStar(rate_hmenu, ID_RATE_2); + ConvertRatingMenuStar(rate_hmenu, ID_RATE_1); + + s.mode = 0; + s.hwnd = 0; + s.build_hMenu = 0; + + IPC_LIBRARY_SENDTOMENU = SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&"LibrarySendToMenu", IPC_REGISTER_WINAMP_IPCMESSAGE); + if (IPC_LIBRARY_SENDTOMENU > 65536 && SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)0, IPC_LIBRARY_SENDTOMENU) == (LRESULT)-1) + { + s.mode = 1; + s.hwnd = hwndDlg; + s.data_type = ML_TYPE_ITEMRECORDLIST; + s.ctx[1] = 1; + s.build_hMenu = sendto_hmenu; + } + + wchar_t *artist = NULL; + wchar_t *album = NULL; + int n = resultlist.GetSelectionMark(); + if (n != -1) + { + artist = itemCache.Items[n].artist; + album = itemCache.Items[n].album; + wchar_t str[2048] = {0}, str2[128] = {0}; + // (BigG): Check the ini settings for viewing vs playing and create the menu accordingly + // Keeping this here in case we want to use the ini setting: + //StringCchPrintfW(str, 2048, WASABI_API_LNGSTRINGW( (g_viewnotplay != 0) ? IDS_VIEW_ALL_FILES_BY : IDS_PLAY_ALL_FILES_BY), artist ? artist : L""); + + int len = lstrlenW(artist); + if (len > 39) + { + StringCchPrintfW(str2, 40, L"%.36s...", artist);//WASABI_API_LNGSTRINGW(IDS_VIEW_ALL_FILES_BY), artist ? artist : L""); + StringCchPrintfW(str, 2048, WASABI_API_LNGSTRINGW(IDS_VIEW_ALL_FILES_BY), str2); + } + else + { + StringCchPrintfW(str, 2048, WASABI_API_LNGSTRINGW(IDS_VIEW_ALL_FILES_BY), artist ? artist : L""); + } + FixAmps(str, 2048); + MENUITEMINFOW mii = + { + sizeof(MENUITEMINFOW), + MIIM_TYPE | MIIM_ID, + MFT_STRING, + MFS_ENABLED, + 0x1234, + NULL, + NULL, + NULL, + 0, + str, + 0, + }; + + if (!(!cloud_hinst || cloud_hinst == (HINSTANCE)1 || + !SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GET_CLOUD_ACTIVE))) + { + MENUITEMINFOW m = {sizeof(m), MIIM_TYPE | MIIM_ID | MIIM_SUBMENU, MFT_SEPARATOR, 0}; + m.wID = CLOUD_SOURCE_MENUS - 1; + InsertMenuItemW(menu, 0, FALSE, &m); + + wchar_t a[100] = {0}; + m.fType = MFT_STRING; + m.dwTypeData = WASABI_API_LNGSTRINGW_BUF(IDS_CLOUD_SOURCES, a, 100); + m.wID = CLOUD_SOURCE_MENUS; + m.hSubMenu = cloud_hmenu = CreatePopupMenu(); + InsertMenuItemW(menu, 0, FALSE, &m); + } + + if (artist && artist[0]) + { + InsertMenuItemW(menu, ID_EDITITEMINFOS, FALSE, &mii); + } + // (BigG): Check the ini settings for viewing vs playing and create the menu accordingly + // Keeping this here in case we want to use the ini setting: + len = lstrlenW(album); + if (len > 39) + { + StringCchPrintfW(str2, 40, L"%.36s...", album); + StringCchPrintfW(str, 2048, WASABI_API_LNGSTRINGW(IDS_VIEW_ALL_FILES_FROM), str2); + } + else + { + StringCchPrintfW(str, 2048, WASABI_API_LNGSTRINGW(IDS_VIEW_ALL_FILES_FROM), album ? album : L""); + } + FixAmps(str, 2048); + mii.cch = wcslen(str); + mii.wID = 0x1235; + if (album && album[0]) + { + InsertMenuItemW(menu, ID_EDITITEMINFOS, FALSE, &mii); + } + + { + mii.wID = 0xdeadbeef; + mii.fType = MFT_SEPARATOR; + InsertMenuItemW(menu, ID_EDITITEMINFOS, FALSE, &mii); + } + } + else + { + EnableMenuItem(menu, ID_MEDIAWND_PLAYSELECTEDFILES, MF_BYCOMMAND | MF_GRAYED); + EnableMenuItem(menu, ID_MEDIAWND_ENQUEUESELECTEDFILES, MF_BYCOMMAND | MF_GRAYED); + EnableMenuItem(menu, IDC_REFRESH_METADATA, MF_BYCOMMAND | MF_GRAYED); + EnableMenuItem(menu, ID_MEDIAWND_REMOVEFROMLIBRARY, MF_BYCOMMAND | MF_GRAYED); + EnableMenuItem(menu, ID_EDITITEMINFOS, MF_BYCOMMAND | MF_GRAYED); + EnableMenuItem(menu, ID_MEDIAWND_EXPLOREFOLDER, MF_BYCOMMAND | MF_GRAYED); + EnableMenuItem(menu, ID_PE_ID3, MF_BYCOMMAND | MF_GRAYED); + EnableMenuItem(menu, 2, MF_BYPOSITION | MF_GRAYED); //grays the "Add to playlist..." menu + EnableMenuItem(menu, rate_idx, MF_BYPOSITION | MF_GRAYED); //grays the "Rate..." menu + EnableMenuItem(menu, 13, MF_BYPOSITION | MF_GRAYED); //grays the "Remove..." menu + } + + menufucker_t mf = {sizeof(mf),MENU_MEDIAVIEW,menu,0x3000,0x4000,0}; + mf.extinf.mediaview.list = resultlist.getwnd(); + mf.extinf.mediaview.items = &itemCache; + pluginMessage message_build = {ML_IPC_MENUFUCKER_BUILD,(intptr_t)&mf,0}; + SendMessage(plugin.hwndLibraryParent, WM_ML_IPC, (WPARAM)&message_build, ML_IPC_SEND_PLUGIN_MESSAGE); + + Menu_SetRatingValue(rate_hmenu, 0); + UpdateMenuItems(hwndDlg, menu, IDR_VIEW_ACCELERATORS); + int r = DoTrackPopup(menu, TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTBUTTON, x, y, hwndDlg, NULL); + + pluginMessage message_result = {ML_IPC_MENUFUCKER_RESULT,(intptr_t)&mf,r,0}; + SendMessage(plugin.hwndLibraryParent, WM_ML_IPC, (WPARAM)&message_result, ML_IPC_SEND_PLUGIN_MESSAGE); + + switch (r) + { + case ID_MEDIAWND_PLAYSELECTEDFILES: + case ID_MEDIAWND_ENQUEUESELECTEDFILES: + playFiles((r == ID_MEDIAWND_ENQUEUESELECTEDFILES), 0); + break; + case ID_MEDIAWND_SELECTALL: + { + LVITEM item = {0}; + item.state = LVIS_SELECTED; + item.stateMask = LVIS_SELECTED; + SendMessageW(hwndFrom, LVM_SETITEMSTATE, (WPARAM)-1, (LPARAM)&item); + } + break; + case ID_MEDIAWND_REMOVEFROMLIBRARY: + removeSelectedItems(0); + break; + case ID_EDITITEMINFOS: + if (resultlist.GetSelectedCount() > 0) + editInfo(hwndDlg); + break; + case ID_PE_ID3: + fileInfoDialogs(hwndDlg); + PostMessageW(hwndDlg, WM_NEXTDLGCTL, (WPARAM)hwndFrom, (LPARAM)TRUE); + break; + case IDC_REFRESH_METADATA: + RefreshMetadata(hwndDlg); + break; + case 0x1234: // all files from selected artist + { + wchar_t tmp[2048] = {0}; + GayStringW escaped; + queryStrEscape(artist, escaped); + + // Keeping this here in case we want to use the ini setting later: + //if ( g_viewnotplay ) // (BigG): Check to see if we should play or view the current tracks + //{ + StringCchPrintfW(tmp, 2048, L"?artist = \"%s\"", escaped.Get()); + SetWindowTextW(hwndSearchGlobal, tmp); + //} + //else // Otherwise do the old behavior and just play it back + //{ + // StringCchPrintfW(tmp, 2048, L"artist = \"%s\"", escaped.Get()); + // main_playQuery(g_view_metaconf, tmp, 0); + //} + + SetWindowTextW(hwndSearchGlobal, tmp); + } + break; + case 0x1235: // all files from selected album + { + wchar_t tmp[2048] = {0}; + GayStringW escaped; + queryStrEscape(album, escaped); + + // Keeping this here in case we want to use the ini setting later: + //if ( g_viewnotplay ) // (BigG): Check to see if we should play or view the current tracks + //{ + StringCchPrintfW(tmp, 2048, L"?album = \"%s\"", escaped.Get()); + SetWindowTextW(hwndSearchGlobal, tmp); + //} + //else // Otherwise do the old behavior and just play it back + //{ + // StringCchPrintfW(tmp, 2048, L"album = \"%s\"", escaped.Get()); + // main_playQuery(g_view_metaconf, tmp, 0); + //} + } + break; + case ID_RATE_1: + case ID_RATE_2: + case ID_RATE_3: + case ID_RATE_4: + case ID_RATE_5: + case ID_RATE_0: + { + int rate = r - ID_RATE_1 + 1; + if (r == ID_RATE_0) rate = 0; + int x; + int has = 0; + EnterCriticalSection(&g_db_cs); + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + for (x = 0; x < itemCache.Size; x ++) + { + if (resultlist.GetSelected(x)) + { + if (NDE_Scanner_LocateNDEFilename(s, MAINTABLE_ID_FILENAME, FIRST_RECORD, itemCache.Items[x].filename)) + { + has++; + NDE_Scanner_Edit(s); + db_setFieldInt(s, MAINTABLE_ID_RATING, rate); + NDE_Scanner_Post(s); + itemCache.Items[x].rating = rate; + if (g_config->ReadInt(L"writeratings", 0)) + { + wchar_t buf[64] = {0}; + if (rate > 0) + { + wsprintfW(buf, L"%d", rate); + } + else + buf[0] = 0; + updateFileInfo(itemCache.Items[x].filename, DB_FIELDNAME_rating, buf); + SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_WRITE_EXTENDED_FILE_INFO); + } + } + } + } + NDE_Table_DestroyScanner(g_table, s); + + if (g_table_dirty) + { + g_table_dirty = 0; + NDE_Table_Sync(g_table); + } + LeaveCriticalSection(&g_db_cs); + + if (has) + { + ListView_RedrawItems(resultlist.getwnd(), 0, itemCache.Size - 1); + PostMessage(GetParent(hwndDlg), WM_APP + 4, (WPARAM)rate, (LPARAM)0); + } + } + break; + case ID_MEDIAWND_EXPLOREFOLDER: + exploreItemFolder(hwndDlg); + break; + case ID_MEDIAWND_REMOVE_REMOVEALLDEADFILES: + removeDeadFiles(hwndDlg); + break; + case ID_MEDIAWND_REMOVE_PHYSICALLYREMOVESELECTEDITEMS: + RecycleSelectedItems(); + break; + default: + { + if (cloud_hmenu && (r >= CLOUD_SOURCE_MENUS && r < CLOUD_SOURCE_MENUS_UPPER)) // deals with cloud specific menus + { + // 0 = no change + // 1 = add cloud + // 2 = add local + // 4 = removed + int mode = 0; + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_PROCESS_CLOUD_STATUS, (intptr_t)r, (intptr_t)&mode); + int n = resultlist.GetSelectionMark(); + if (n != -1) + { + switch (mode) + { + case 1: + setCloudValue(&itemCache.Items[n], L"5"); + break; + + case 2: + setCloudValue(&itemCache.Items[n], L"0"); + break; + + case 4: + setCloudValue(&itemCache.Items[n], L"4"); + break; + } + InvalidateRect(resultlist.getwnd(), NULL, TRUE); + } + break; + } + + if (s.mode == 2) + { + s.menu_id = r; + if (SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&s, IPC_LIBRARY_SENDTOMENU) == (LRESULT)-1) + { + // build my data. + s.mode = 3; + s.data_type = ML_TYPE_ITEMRECORDLISTW; + itemRecordListW myObj = {0, }; + copyFilesToItemCacheW(&myObj); // does not dupe strings + s.data = (void*) & myObj; + LRESULT result = SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM) & s, IPC_LIBRARY_SENDTOMENU); + if (result != 1) + { + s.mode = 3; + s.data_type = ML_TYPE_ITEMRECORDLIST; + itemRecordList objA = {0, }; + convertRecordList(&objA, &myObj); + s.data = (void*) & objA; + + SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&s, IPC_LIBRARY_SENDTOMENU); + freeRecordList(&objA); + } + _aligned_free(myObj.Items); + } + } + break; + } + } + + if (s.mode) + { + s.mode = 4; + SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&s, IPC_LIBRARY_SENDTOMENU); // cleanup + } + sendto_hmenu = 0; + DestroyMenu(cloud_hmenu); + cloud_hmenu = 0; + DestroyMenu(globmenu); + UpdateWindow(hwndFrom); + EatKeyboard(); +} + +static BOOL ListView_OnFindItem(HWND hwndDlg, NMLVFINDITEMW *pfi, LRESULT *pResult, UINT uMsg) +{ + if (bgThread_Handle) return FALSE; + + int i = pfi->iStart; + if (i >= itemCache.Size) i = 0; + + int cnt = itemCache.Size - i; + if (pfi->lvfi.flags & LVFI_WRAP) cnt += i; + + int by = g_view_metaconf->ReadInt(L"mv_sort_by", MEDIAVIEW_COL_ARTIST); + + while (cnt-- > 0) + { + itemRecordW *thisitem = itemCache.Items + i; + wchar_t tmp[128] = {0}; + wchar_t *name = 0; + + switch (by) + { + case MEDIAVIEW_COL_FILENAME: + name = thisitem->filename + wcslen(thisitem->filename); + while (name >= thisitem->filename && *name != L'/' && *name != L'\\') name--; + break; + case MEDIAVIEW_COL_FULLPATH: + name = thisitem->filename; + break; + case MEDIAVIEW_COL_EXTENSION: + name = PathFindExtensionW(thisitem->filename); + if (name && *name) + name++; + break; + case MEDIAVIEW_COL_TITLE: name = thisitem->title; break; + case MEDIAVIEW_COL_COMMENT: name = thisitem->comment; break; + case MEDIAVIEW_COL_ARTIST: name = thisitem->artist; break; + case MEDIAVIEW_COL_ALBUM: name = thisitem->album; break; + case MEDIAVIEW_COL_GENRE: name = thisitem->genre; break; + case MEDIAVIEW_COL_YEAR: + tmp[0] = 0; + if (thisitem->year >= 0) StringCchPrintfW(tmp, 128, L"%04d", thisitem->year); + name = tmp; + break; + case MEDIAVIEW_COL_TRACK: + tmp[0] = 0; + if (thisitem->track > 0) + { + if (thisitem->tracks > 0) StringCchPrintfW(tmp, 128, L"%d/%d", thisitem->track, thisitem->tracks); + else StringCchPrintfW(tmp, 128, L"%d", thisitem->track); + } + name = tmp; + break; + case MEDIAVIEW_COL_LENGTH: + tmp[0] = 0; + if (thisitem->length >= 0) StringCchPrintfW(tmp, 128, L"%d:%02d", thisitem->length / 60, thisitem->length % 60); + name = tmp; + break; + case MEDIAVIEW_COL_RATING: + tmp[0] = 0; + if (thisitem->rating > 0) StringCchPrintfW(tmp, 128, L"%d", thisitem->rating); + name = tmp; + break; + case MEDIAVIEW_COL_CLOUD: + { + tmp[0] = 0; + wchar_t *x = getRecordExtendedItem_fast(thisitem, extended_fields.cloud); + if (x && *x) StringCchPrintfW(tmp, 128, L"%d", x); + name = tmp; + break; + } + case MEDIAVIEW_COL_PLAYCOUNT: + tmp[0] = 0; + if (thisitem->playcount > 0) StringCchPrintfW(tmp, 128, L"%d", thisitem->playcount); + name = tmp; + break; + case MEDIAVIEW_COL_BITRATE: + if (thisitem->bitrate > 0) + StringCchPrintfW(name = tmp, 128, L"%d%s", thisitem->bitrate, WASABI_API_LNGSTRINGW(IDS_KBPS)); + break; + case MEDIAVIEW_COL_BPM: + if (thisitem->bpm > 0) + StringCchPrintfW(name = tmp, 128, L"%d", thisitem->bpm); + break; + case MEDIAVIEW_COL_TYPE: + name = WASABI_API_LNGSTRINGW(thisitem->type ? IDS_VIDEO : IDS_AUDIO); + break; + case MEDIAVIEW_COL_DISC: + tmp[0] = 0; + if (thisitem->disc > 0) + { + if (thisitem->discs > 0) + StringCchPrintfW(tmp, 128, L"%d/%d", thisitem->disc, thisitem->discs); + else + StringCchPrintfW(tmp, 128, L"%d", thisitem->disc); + } + name = tmp; + break; + case MEDIAVIEW_COL_ALBUMARTIST: + name = thisitem->albumartist; + break; + case MEDIAVIEW_COL_PUBLISHER: + name = thisitem->publisher; + break; + case MEDIAVIEW_COL_COMPOSER: + name = thisitem->composer; + break; + case MEDIAVIEW_COL_ALBUMGAIN: + name = thisitem->replaygain_album_gain; + break; + case MEDIAVIEW_COL_TRACKGAIN: + name = thisitem->replaygain_track_gain; + break; + case MEDIAVIEW_COL_FILESIZE: + tmp[0] = 0; + if (thisitem->filesize > 0) StringCchPrintfW(tmp, 128, L"%d", thisitem->filesize); + name = tmp; + break; + case MEDIAVIEW_COL_FILETIME: + tmp[0] = 0; + if (thisitem->filetime > 0) StringCchPrintfW(tmp, 128, L"%d", thisitem->filetime); + name = tmp; + break; + case MEDIAVIEW_COL_LASTUPD: + tmp[0] = 0; + if (thisitem->lastupd > 0) StringCchPrintfW(tmp, 128, L"%d", thisitem->lastupd); + name = tmp; + break; + case MEDIAVIEW_COL_DATEADDED: + { + tmp[0] = 0; + wchar_t *x = getRecordExtendedItem_fast(thisitem,extended_fields.dateadded); + if (x && *x) StringCchPrintfW(tmp, 128, L"%d", x); + name = tmp; + break; + } + case MEDIAVIEW_COL_LASTPLAY: + tmp[0] = 0; + if (thisitem->lastplay > 0) StringCchPrintfW(tmp, 128, L"%d", thisitem->lastplay); + name = tmp; + break; + case MEDIAVIEW_COL_ISPODCAST: + { + wchar_t * t = getRecordExtendedItem_fast(thisitem, extended_fields.ispodcast); + name = WASABI_API_LNGSTRINGW(t && wcscmp(t,L"1") ? IDS_PODCAST : IDS_NON_PODCAST); + } + break; + case MEDIAVIEW_COL_PODCASTCHANNEL: + name = getRecordExtendedItem_fast(thisitem,extended_fields.podcastchannel); + break; + case MEDIAVIEW_COL_PODCASTPUBDATE: + { + tmp[0] = 0; + wchar_t *x = getRecordExtendedItem_fast(thisitem,extended_fields.podcastpubdate); + if (x && *x) StringCchPrintfW(tmp, 128, L"%d", x); + name = tmp; + } + break; + case MEDIAVIEW_COL_CATEGORY: + name = thisitem->category; + break; + case MEDIAVIEW_COL_DIRECTOR: + name = getRecordExtendedItem_fast(thisitem,extended_fields.director); + break; + case MEDIAVIEW_COL_PRODUCER: + name = getRecordExtendedItem_fast(thisitem,extended_fields.producer); + break; + case MEDIAVIEW_COL_DIMENSION: + { + tmp[0] = 0; + wchar_t *w = getRecordExtendedItem_fast(thisitem,extended_fields.width); + wchar_t *h = getRecordExtendedItem_fast(thisitem,extended_fields.height); + if (w && *w && h && *h) StringCchPrintfW(tmp, 128, L"%dx%d", _wtoi(w), _wtoi(h)); + name = tmp; + break; + } + } + + if (!name) name = L""; + else SKIP_THE_AND_WHITESPACEW(name) + + if (pfi->lvfi.flags & (4 | LVFI_PARTIAL)) + { + if (!StrCmpNIW(name, pfi->lvfi.psz, wcslen(pfi->lvfi.psz))) + { + *pResult = i; + return TRUE; + } + } + else if (pfi->lvfi.flags & LVFI_STRING) + { + if (!lstrcmpiW(name, pfi->lvfi.psz)) + { + *pResult = i; + return TRUE; + } + } + else + { + *pResult = i; + return TRUE; + } + if (++i == itemCache.Size) i = 0; + } + *pResult = i; + return TRUE; +} +static BOOL ListView_OnGetDispInfo(HWND hwndDlg, NMLVDISPINFOW* pdi, UINT uMsg) +{ + LVITEMW *pItem; + itemRecordW *pRec; + + pItem = &pdi->item; + + if (bgThread_Handle) + { + if (0 == pItem->iItem && 0 == pItem->iSubItem && (LVIF_TEXT & pItem->mask)) + { + static char bufpos = 0; + static int buflen = 17; + static wchar_t buffer[64];//L"Scanning _\0/-\\|"; + if (!buffer[0]) + { + WASABI_API_LNGSTRINGW_BUF(IDS_SCANNING_PLAIN,buffer,54); + StringCchCatW(buffer,64,L" _"); + StringCchCatW(buffer+(buflen=lstrlenW(buffer)+1),64,L"/-\\|"); + buflen+=4; + } + int pos = buflen - 5;; + buffer[pos - 1] = buffer[pos + (bufpos++&3) + 1]; + pItem->pszText = buffer; + } + return FALSE; + } + + if (pItem->iItem < 0 || pItem->iItem >= itemCache.Size) return FALSE; + + pRec = itemCache.Items + pItem->iItem; + + if (LVIF_TEXT & pItem->mask) + { + switch (columnOrder[pItem->iSubItem]) + { + case MEDIAVIEW_COL_FILENAME: // show filename (Tho we'll show without the path cause paths are gay) + pItem->pszText = PathFindFileNameW(pRec->filename); + break; + case MEDIAVIEW_COL_FULLPATH: // show filename (Tho we'll show without the path cause paths are gay) + pItem->pszText = pRec->filename; + break; + case MEDIAVIEW_COL_EXTENSION: + pItem->pszText = PathFindExtensionW(pRec->filename); + if (pItem->pszText && *pItem->pszText) pItem->pszText++; + break; + case MEDIAVIEW_COL_TITLE: + pItem->pszText = pRec->title; + break; + case MEDIAVIEW_COL_COMMENT: + pItem->pszText = pRec->comment; + break; + case MEDIAVIEW_COL_ALBUM: + pItem->pszText = pRec->album; + break; + case MEDIAVIEW_COL_ARTIST: + pItem->pszText = pRec->artist; + break; + case MEDIAVIEW_COL_TRACK: + if (pRec->track > 0) + { + if (pRec->tracks > 0) StringCchPrintfW(pItem->pszText, pItem->cchTextMax, L"%d/%d", pRec->track, pRec->tracks); + else StringCchPrintfW(pItem->pszText, pItem->cchTextMax, L"%d", pRec->track); + } + break; + case MEDIAVIEW_COL_GENRE: + pItem->pszText = pRec->genre; + break; + case MEDIAVIEW_COL_YEAR: + if (pRec->year >= 0) StringCchPrintfW(pItem->pszText, pItem->cchTextMax, L"%04d", pRec->year); + break; + case MEDIAVIEW_COL_LENGTH: + if (pRec->length >= 0) StringCchPrintfW(pItem->pszText, pItem->cchTextMax, L"%d:%02d", pRec->length / 60, pRec->length % 60); + break; + case MEDIAVIEW_COL_RATING: + if (0 == pItem->iSubItem && ratingBackText[0]) pItem->pszText = ratingBackText; + else if (pRec->rating > 0 && pRec->rating <= 5) _itow(pRec->rating, pItem->pszText, 10); + break; + case MEDIAVIEW_COL_CLOUD: + { + wchar_t *t = getRecordExtendedItem_fast(pRec, extended_fields.cloud); + if (t && *t) StringCchPrintfW(pItem->pszText, pItem->cchTextMax, L"%d", _wtoi(t)); + break; + } + case MEDIAVIEW_COL_PLAYCOUNT: + if (pRec->playcount >= 0) StringCchPrintfW(pItem->pszText, pItem->cchTextMax, L"%d", pRec->playcount); + else pItem->pszText = L"0"; + break; + case MEDIAVIEW_COL_DISC: + if (pRec->disc > 0) + { + if (pRec->discs > 0) StringCchPrintfW(pItem->pszText, pItem->cchTextMax, L"%d/%d", pRec->disc, pRec->discs); + else StringCchPrintfW(pItem->pszText, pItem->cchTextMax, L"%d", pRec->disc); + } + break; + case MEDIAVIEW_COL_ALBUMARTIST: + pItem->pszText = pRec->albumartist; + break; + case MEDIAVIEW_COL_PUBLISHER: + pItem->pszText = pRec->publisher; + break; + case MEDIAVIEW_COL_COMPOSER: + pItem->pszText = pRec->composer; + break; + case MEDIAVIEW_COL_ALBUMGAIN: + pItem->pszText = pRec->replaygain_album_gain; + break; + case MEDIAVIEW_COL_TRACKGAIN: + pItem->pszText = pRec->replaygain_track_gain; + break; + case MEDIAVIEW_COL_TYPE: + pItem->pszText = WASABI_API_LNGSTRINGW((pRec->type) ? IDS_VIDEO : IDS_AUDIO); + break; + case MEDIAVIEW_COL_BITRATE: + if (pRec->bitrate > 0) StringCchPrintfW(pItem->pszText, pItem->cchTextMax, L"%d%s", pRec->bitrate, WASABI_API_LNGSTRINGW(IDS_KBPS)); + break; + case MEDIAVIEW_COL_BPM: + if (pRec->bpm > 0) StringCchPrintfW(pItem->pszText, pItem->cchTextMax, L"%d", pRec->bpm); + break; + case MEDIAVIEW_COL_FILESIZE: + if (pRec->filesize != -1) WASABI_API_LNG->FormattedSizeString(pItem->pszText, pItem->cchTextMax, pRec->filesize); + break; + case MEDIAVIEW_COL_FILETIME: + MakeDateString(pRec->filetime, pItem->pszText, pItem->cchTextMax); + break; + case MEDIAVIEW_COL_LASTUPD: + MakeDateString(pRec->lastupd, pItem->pszText, pItem->cchTextMax); + break; + case MEDIAVIEW_COL_DATEADDED: + { + wchar_t * t = getRecordExtendedItem_fast(pRec,extended_fields.dateadded); + if (t && *t) MakeDateString(_wtoi64(t), pItem->pszText, pItem->cchTextMax); + break; + } + case MEDIAVIEW_COL_LASTPLAY: + if (pRec->lastplay > 0) MakeDateString(pRec->lastplay, pItem->pszText, pItem->cchTextMax); + break; + case MEDIAVIEW_COL_ISPODCAST: + { + wchar_t *t = getRecordExtendedItem_fast(pRec, extended_fields.ispodcast); + pItem->pszText = WASABI_API_LNGSTRINGW((t && t[0] == L'1' && !t[1]) ? IDS_PODCAST : IDS_NON_PODCAST); + break; + } + case MEDIAVIEW_COL_PODCASTCHANNEL: + pItem->pszText = getRecordExtendedItem_fast(pRec, extended_fields.podcastchannel); + break; + case MEDIAVIEW_COL_PODCASTPUBDATE: + { + wchar_t * t = getRecordExtendedItem_fast(pRec,extended_fields.podcastpubdate); + if (t && *t) MakeDateString(_wtoi64(t), pItem->pszText, pItem->cchTextMax); + break; + } + case MEDIAVIEW_COL_CATEGORY: + pItem->pszText = pRec->category; + break; + case MEDIAVIEW_COL_DIRECTOR: + pItem->pszText = getRecordExtendedItem_fast(pRec, extended_fields.director); + break; + case MEDIAVIEW_COL_PRODUCER: + pItem->pszText = getRecordExtendedItem_fast(pRec, extended_fields.producer); + break; + case MEDIAVIEW_COL_DIMENSION: + { + wchar_t *w = getRecordExtendedItem_fast(pRec,extended_fields.width); + wchar_t *h = getRecordExtendedItem_fast(pRec,extended_fields.height); + if (w && *w && h && *h) StringCchPrintfW(pItem->pszText, pItem->cchTextMax, L"%dx%d", _wtoi(w), _wtoi(h)); + break; + } + } + if (!pItem->pszText) pItem->pszText = L""; + } + return FALSE; +} +static BOOL ListView_OnColumnClick(HWND hwndDlg, NMLISTVIEW *pnmv) +{ + int l_sc = g_view_metaconf->ReadInt(L"mv_sort_by", MEDIAVIEW_COL_ARTIST); + int l_sd = g_view_metaconf->ReadInt(L"mv_sort_dir", 0); + if (columnOrder[pnmv->iSubItem] == l_sc) l_sd = !l_sd; + else + { + /* JF> I like this better when the direction doesnt get reset every + time you choose a new column. To revert to old behavior, uncomment + this line: + l_sd=0; + */ + l_sc = columnOrder[pnmv->iSubItem]; + } + + g_view_metaconf->WriteInt(L"mv_sort_by", l_sc); + g_view_metaconf->WriteInt(L"mv_sort_dir", l_sd); + MLSkinnedListView_DisplaySort(pnmv->hdr.hwndFrom, pnmv->iSubItem, !l_sd); + sortResults(g_view_metaconf, &itemCache); + resultlist.SetVirtualCount(0); + resultlist.SetVirtualCount(itemCache.Size); // TODO: we could set a limit here + ListView_RedrawItems(pnmv->hdr.hwndFrom, 0, itemCache.Size - 1); + return FALSE; +} +static BOOL ListView_OnBeginDrag(HWND hwndDlg, NMLISTVIEW *pnmv) +{ + switch (columnOrder[pnmv->iSubItem]) + { + case MEDIAVIEW_COL_RATING: + ratingColumn.hwndList = pnmv->hdr.hwndFrom; + ratingColumn.fStyle = RCS_DEFAULT; + ratingColumn.iItem = pnmv->iItem; + ratingColumn.iSubItem = pnmv->iSubItem; + ratingColumn.value = ((UINT)pnmv->iItem < (UINT)itemCache.Size) ? itemCache.Items[pnmv->iItem].rating : 0; + MLRatingColumn_BeginDrag(plugin.hwndLibraryParent, &ratingColumn); + break; + } + + SetCapture(hwndDlg); + return FALSE; +} + +static BOOL ListView_OnReturn(HWND hwndDlg, NMHDR *pnmh) +{ + SendMessage(hwndDlg, WM_COMMAND, ((!!(GetAsyncKeyState(VK_SHIFT)&0x8000)) ^(!!g_config->ReadInt(L"enqueuedef", 0))) + ? IDC_BUTTON_ENQUEUE : IDC_BUTTON_PLAY, 0); + return FALSE; +} + +static BOOL ListView_OnCustomDraw(HWND hwndDlg, NMLVCUSTOMDRAW *plvcd, LRESULT *pResult) +{ + static BOOL bDrawFocus; + static RECT rcView; + static RATINGCOLUMNPAINT ratingColumnPaint; + static CLOUDCOLUMNPAINT cloudColumnPaint; + + *pResult = CDRF_DODEFAULT; + + switch (plvcd->nmcd.dwDrawStage) + { + case CDDS_PREPAINT: + *pResult |= CDRF_NOTIFYITEMDRAW; + CopyRect(&rcView, &plvcd->nmcd.rc); + + ratingColumnPaint.fStyle = RCS_DEFAULT; + ratingColumnPaint.hwndList = plvcd->nmcd.hdr.hwndFrom; + ratingColumnPaint.hdc = plvcd->nmcd.hdc; + ratingColumnPaint.prcView = &rcView; + + cloudColumnPaint.hwndList = plvcd->nmcd.hdr.hwndFrom; + cloudColumnPaint.hdc = plvcd->nmcd.hdc; + cloudColumnPaint.prcView = &rcView; + return TRUE; + + case CDDS_ITEMPREPAINT: + *pResult |= CDRF_NOTIFYSUBITEMDRAW; + bDrawFocus = (CDIS_FOCUS & plvcd->nmcd.uItemState); + if (bDrawFocus) + { + plvcd->nmcd.uItemState &= ~CDIS_FOCUS; + *pResult |= CDRF_NOTIFYPOSTPAINT; + } + return TRUE; + case CDDS_ITEMPOSTPAINT: + if (bDrawFocus) + { + RECT rc; + rc.left = LVIR_BOUNDS; + SendMessageW(plvcd->nmcd.hdr.hwndFrom, LVM_GETITEMRECT, plvcd->nmcd.dwItemSpec, (LPARAM)&rc); + rc.left += 3; + DrawFocusRect(plvcd->nmcd.hdc, &rc); + plvcd->nmcd.uItemState |= CDIS_FOCUS; + bDrawFocus = FALSE; + } + *pResult = CDRF_SKIPDEFAULT; + return TRUE; + + case(CDDS_SUBITEM | CDDS_ITEMPREPAINT): + switch (columnOrder[plvcd->iSubItem]) + { + case MEDIAVIEW_COL_RATING: + if (bgThread_Handle || (0 == plvcd->iSubItem && 0 == plvcd->nmcd.rc.right)) break; + ratingColumnPaint.iItem = plvcd->nmcd.dwItemSpec; + ratingColumnPaint.iSubItem = plvcd->iSubItem; + ratingColumnPaint.value = (plvcd->nmcd.dwItemSpec >= 0 && plvcd->nmcd.dwItemSpec < (UINT)itemCache.Size) ? itemCache.Items[plvcd->nmcd.dwItemSpec].rating : 0; + ratingColumnPaint.prcItem = &plvcd->nmcd.rc; + ratingColumnPaint.rgbBk = plvcd->clrTextBk; + ratingColumnPaint.rgbFg = plvcd->clrText; + + if (MLRatingColumn_Paint(plugin.hwndLibraryParent, &ratingColumnPaint)) + { + *pResult = CDRF_SKIPDEFAULT; + return TRUE; + } + break; + + case MEDIAVIEW_COL_CLOUD: + if (bgThread_Handle || (0 == plvcd->iSubItem && 0 == plvcd->nmcd.rc.right)) break; + + int icon = 4; + wchar_t *t = getRecordExtendedItem_fast(&itemCache.Items[plvcd->nmcd.dwItemSpec], extended_fields.cloud); + if (t && *t) icon = _wtoi(t); + + cloudColumnPaint.iItem = plvcd->nmcd.dwItemSpec; + cloudColumnPaint.iSubItem = plvcd->iSubItem; + cloudColumnPaint.value = icon; + cloudColumnPaint.prcItem = &plvcd->nmcd.rc; + cloudColumnPaint.rgbBk = plvcd->clrTextBk; + cloudColumnPaint.rgbFg = plvcd->clrText; + + if (MLCloudColumn_Paint(plugin.hwndLibraryParent, &cloudColumnPaint)) + { + *pResult = CDRF_SKIPDEFAULT; + return TRUE; + } + break; + } + break; + } + return FALSE; +} + +static BOOL ListView_OnClick(HWND hwnDlg, NMITEMACTIVATE *pnmitem) +{ + if (bgThread_Handle) return FALSE; + + if (pnmitem->iItem != -1) + { + switch (columnOrder[pnmitem->iSubItem]) + { + case MEDIAVIEW_COL_RATING: + ratingColumn.hwndList = pnmitem->hdr.hwndFrom; + ratingColumn.ptAction = pnmitem->ptAction; + ratingColumn.bRedrawNow = TRUE; + ratingColumn.fStyle = RCS_DEFAULT; + if (!MLRatingColumn_Click(plugin.hwndLibraryParent, &ratingColumn)) return FALSE; + SetRating(ratingColumn.iItem, ratingColumn.value, ratingColumn.hwndList); + break; + + case MEDIAVIEW_COL_CLOUD: + { + RECT itemRect = {0}; + if (pnmitem->iSubItem) + ListView_GetSubItemRect(pnmitem->hdr.hwndFrom, pnmitem->iItem, pnmitem->iSubItem, LVIR_BOUNDS, &itemRect); + else + { + ListView_GetItemRect(pnmitem->hdr.hwndFrom, pnmitem->iItem, &itemRect, LVIR_BOUNDS); + itemRect.right = itemRect.left + ListView_GetColumnWidth(pnmitem->hdr.hwndFrom, pnmitem->iSubItem); + } + + MapWindowPoints(pnmitem->hdr.hwndFrom, HWND_DESKTOP, (POINT*)&itemRect, 2); + + HMENU cloud_menu = CreatePopupMenu(); + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_GET_CLOUD_STATUS, (intptr_t)itemCache.Items[pnmitem->iItem].filename, (intptr_t)&cloud_menu); + if (cloud_menu) + { + int r = DoTrackPopup(cloud_menu, TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTBUTTON, itemRect.right, itemRect.top, pnmitem->hdr.hwndFrom, NULL); + if (r >= CLOUD_SOURCE_MENUS && r < CLOUD_SOURCE_MENUS_UPPER) + { + // 0 = no change + // 1 = adding to cloud + // 2 = added locally + // 4 = removed + int mode = 0; // deals with cloud specific menus + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_PROCESS_CLOUD_STATUS, (intptr_t)r, (intptr_t)&mode); + switch (mode) + { + case 1: + setCloudValue(&itemCache.Items[pnmitem->iItem], L"5"); + break; + + case 2: + setCloudValue(&itemCache.Items[pnmitem->iItem], L"4"); + break; + + case 4: + setCloudValue(&itemCache.Items[pnmitem->iItem], L"4"); + break; + } + + InvalidateRect(resultlist.getwnd(), NULL, TRUE); + } + DestroyMenu(cloud_menu); + } + } + break; + } + } + return FALSE; +} + +static BOOL ListView_OnHotTrack(HWND hwndDlg, NMLISTVIEW *pnmlv, LRESULT *pResult) +{ + UINT iItem; + + if (bgThread_Handle) + { + pnmlv->iItem = -1; + *pResult = TRUE; + return TRUE; + } + + if (-1 == pnmlv->iItem && 0 == pnmlv->iSubItem) + { + LVHITTESTINFO lvhit; + lvhit.pt = pnmlv->ptAction; + SendMessageW(pnmlv->hdr.hwndFrom, LVM_HITTEST, 0, (LPARAM)&lvhit); + iItem = lvhit.iItem; + } + else iItem = pnmlv->iItem; + + switch (columnOrder[pnmlv->iSubItem]) + { + case MEDIAVIEW_COL_RATING: + ratingColumn.hwndList = pnmlv->hdr.hwndFrom; + ratingColumn.fStyle = RCS_DEFAULT; + ratingColumn.iItem = iItem; + ratingColumn.iSubItem = pnmlv->iSubItem; + ratingColumn.value = (iItem < (UINT)itemCache.Size) ? itemCache.Items[iItem].rating : 0; + ratingColumn.ptAction = pnmlv->ptAction; + ratingColumn.bRedrawNow = TRUE; + MLRatingColumn_Track(plugin.hwndLibraryParent, &ratingColumn); + break; + } + + // LVS_EX_ONECLICKACTIVATE enabled - make listview select nothing + pnmlv->iItem = -1; + *pResult = TRUE; + return TRUE; +} + +/////////// Dialog Messages / Notifications +static void Dialog_OnDisplayChange(HWND hwndDlg) +{ + INT i; + HWND hwndList = GetDlgItem(hwndDlg, IDC_LIST2); + + for (i = 0; -1 != columnOrder[i] && MEDIAVIEW_COL_RATING != columnOrder[i] && MEDIAVIEW_COL_CLOUD != columnOrder[i]; i++); + if (-1 != columnOrder[i]) + { + if (hwndList) + { + INT w = (INT)SendMessageW(hwndList, LVM_GETCOLUMNWIDTH, i, 0L); + SendMessageW(hwndList, LVM_SETCOLUMNWIDTH, i, (LPARAM)w); + } + } + LayoutWindows(hwndDlg, TRUE); +} + +static wchar_t tt_buf[256] = {L""}; +static int last_item = -1, last_icon = -1; +LRESULT pmp_listview(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { + if (uMsg == WM_NOTIFY) + { + LPNMHDR l=(LPNMHDR)lParam; + switch (l->code) + { + case TTN_SHOW: + { + LVHITTESTINFO lvh = {0}; + GetCursorPos(&lvh.pt); + ScreenToClient(hwnd, &lvh.pt); + ListView_SubItemHitTest(hwnd, &lvh); + + int cloudcol = (int)GetPropW(hwnd, L"pmp_list_info"); + if (lvh.iItem != -1 && lvh.iSubItem == cloudcol) + { + RECT r = {0}; + if (lvh.iSubItem) + ListView_GetSubItemRect(hwnd, lvh.iItem, lvh.iSubItem, LVIR_BOUNDS, &r); + else + { + ListView_GetItemRect(hwnd, lvh.iItem, &r, LVIR_BOUNDS); + r.right = r.left + ListView_GetColumnWidth(hwnd, cloudcol); + } + + MapWindowPoints(hwnd, HWND_DESKTOP, (LPPOINT)&r, 2); + SetWindowPos(l->hwndFrom, HWND_TOPMOST, r.right, r.top + 2, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE); + return 1; + } + } + break; + + case TTN_NEEDTEXTW: + { + LVHITTESTINFO lvh = {0}; + GetCursorPos(&lvh.pt); + ScreenToClient(hwnd, &lvh.pt); + ListView_SubItemHitTest(hwnd, &lvh); + + int cloudcol = (int)GetPropW(hwnd, L"pmp_list_info"); + if (lvh.iItem != -1 && lvh.iSubItem == cloudcol) + { + LPNMTTDISPINFOW lpnmtdi = (LPNMTTDISPINFOW)lParam; + int icon = 4; + wchar_t *t = getRecordExtendedItem_fast(&itemCache.Items[lvh.iItem], extended_fields.cloud); + if (t && *t) icon = _wtoi(t); + + if (last_item == lvh.iItem && last_icon == icon) + { + lpnmtdi->lpszText = tt_buf; + return 0; + } + + if (icon == 4) + { + WASABI_API_LNGSTRINGW_BUF(IDS_UPLOAD_TO_SOURCE, tt_buf, ARRAYSIZE(tt_buf)); + } + else if (icon == 5) + { + WASABI_API_LNGSTRINGW_BUF(IDS_UPLOADING_TO_SOURCE, tt_buf, ARRAYSIZE(tt_buf)); + } + else + { + if (!cloud_hinst) cloud_hinst = (HINSTANCE)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GET_CLOUD_HINST); + if (cloud_hinst && cloud_hinst != (HINSTANCE)1) + { + winampMediaLibraryPlugin *(*gp)(); + gp = (winampMediaLibraryPlugin * (__cdecl *)(void))GetProcAddress(cloud_hinst, "winampGetMediaLibraryPlugin"); + if (gp) + { + winampMediaLibraryPlugin *mlplugin = gp(); + if (mlplugin && (mlplugin->version >= MLHDR_VER_OLD && mlplugin->version <= MLHDR_VER)) + { + WASABI_API_LNGSTRINGW_BUF(IDS_TRACK_AVAILABLE, tt_buf, ARRAYSIZE(tt_buf)); + + nx_string_t *out_devicenames = 0; + size_t num_names = mlplugin->MessageProc(0x405, (INT_PTR)itemCache.Items[lvh.iItem].filename, (INT_PTR)&out_devicenames, 0); + if (num_names > 0) + { + for (size_t i = 0; i < num_names; i++) + { + if (i > 0) StringCchCatW(tt_buf, ARRAYSIZE(tt_buf), L", "); + StringCchCatW(tt_buf, ARRAYSIZE(tt_buf), out_devicenames[i]->string); + } + } + else + { + WASABI_API_LNGSTRINGW_BUF(IDS_UPLOAD_TO_SOURCE, tt_buf, ARRAYSIZE(tt_buf)); + } + if (out_devicenames) + free(out_devicenames); + } + } + } + } + last_item = lvh.iItem; + last_icon = icon; + lpnmtdi->lpszText = tt_buf; + + // bit of a fiddle but it allows for multi-line tooltips + //SendMessage(l->hwndFrom, TTM_SETMAXTIPWIDTH, 0, 0); + } + else + return CallWindowProcW((WNDPROC)GetPropW(hwnd, L"pmp_list_proc"), hwnd, uMsg, wParam, lParam); + } + return 0; + } + } + + return CallWindowProcW((WNDPROC)GetPropW(hwnd, L"pmp_list_proc"), hwnd, uMsg, wParam, lParam); +} + +void Dialog_UpdateButtonText(HWND hwndDlg, int _enqueuedef) +{ + if (groupBtn) + { + switch(_enqueuedef) + { + case 1: + SetDlgItemTextW(hwndDlg, IDC_BUTTON_PLAY, view.enqueue); + customAllowed = FALSE; + break; + + default: + // v5.66+ - re-use the old predixis parts so the button can be used functionally via ml_enqplay + // pass the hwnd, button id and plug-in id so the ml plug-in can check things as needed + pluginMessage p = {ML_MSG_VIEW_BUTTON_HOOK_IN_USE, (INT_PTR)_enqueuedef, 0, 0}; + + wchar_t *pszTextW = (wchar_t *)SENDMLIPC(plugin.hwndLibraryParent, ML_IPC_SEND_PLUGIN_MESSAGE, (WPARAM)&p); + if (pszTextW && pszTextW[0] != 0) + { + // set this to be a bit different so we can just use one button and not the + // mixable one as well (leaving that to prevent messing with the resources) + SetDlgItemTextW(hwndDlg, IDC_BUTTON_PLAY, pszTextW); + customAllowed = TRUE; + } + else + { + SetDlgItemTextW(hwndDlg, IDC_BUTTON_PLAY, view.play); + customAllowed = FALSE; + } + break; + } + } +} + +enum +{ + BPM_ECHO_WM_COMMAND=0x1, // send WM_COMMAND and return value + BPM_WM_COMMAND = 0x2, // just send WM_COMMAND +}; + +BOOL Dialog_ButtonPopupMenu(HWND hwndDlg, int buttonId, HMENU menu, int flags=0) +{ + RECT r; + HWND buttonHWND = GetDlgItem(hwndDlg, buttonId); + GetWindowRect(buttonHWND, &r); + UpdateMenuItems(hwndDlg, menu, IDR_VIEW_ACCELERATORS); + MLSkinnedButton_SetDropDownState(buttonHWND, TRUE); + UINT tpmFlags = TPM_RIGHTBUTTON | TPM_LEFTBUTTON | TPM_BOTTOMALIGN | TPM_LEFTALIGN; + if (!(flags & BPM_WM_COMMAND)) tpmFlags |= TPM_RETURNCMD; + int x = DoTrackPopup(menu, tpmFlags, r.left, r.top, hwndDlg, NULL); + if ((flags & BPM_ECHO_WM_COMMAND) && x) + SendMessage(hwndDlg, WM_COMMAND, MAKEWPARAM(x, 0), 0); + MLSkinnedButton_SetDropDownState(buttonHWND, FALSE); + return x; +} + +static void Dialog_Play(HWND hwndDlg, HWND from, UINT idFrom) +{ + HMENU listMenu = GetSubMenu(g_context_menus2, 0); + int count = GetMenuItemCount(listMenu); + if (count > 2) + { + for (int i = 2; i < count; i++) + { + DeleteMenu(listMenu, 2, MF_BYPOSITION); + } + } + + Dialog_ButtonPopupMenu(hwndDlg, idFrom, listMenu, BPM_WM_COMMAND); +} + +static INT_PTR Dialog_OnInit(HWND hwndDlg, HWND hwndFocus, LPARAM lParam) +{ + // benski> this is just going here because it's very likely to get called. will only get compiled in debug mode. + assert(sizeof(extra_idsW) / sizeof(*extra_idsW) == sizeof(extra_strsW) / sizeof(*extra_strsW)); + + g_displaysearch = !(BOOL)lParam; + + // Set the hwnd for the search to a global only if the multipane view hasnt set it yet, as it takes precedence to which box gets populated with the query + //if (!IsWindow(hwndSearchGlobal)) + hwndSearchGlobal = GetDlgItem(hwndDlg, IDC_QUICKSEARCH); + + HACCEL accel = WASABI_API_LOADACCELERATORSW(IDR_VIEW_ACCELERATORS); + if (accel) + WASABI_API_APP->app_addAccelerators(hwndDlg, &accel, 1, TRANSLATE_MODE_CHILD); + + if (!view.play) + { + SENDMLIPC(plugin.hwndLibraryParent, ML_IPC_GET_VIEW_BUTTON_TEXT, (WPARAM)&view); + } + + HWND hwndList; + FLICKERFIX ff; + INT index; + INT ffcl[] = { IDC_CLEAR, + IDC_BUTTON_PLAY, + IDC_BUTTON_ENQUEUE, + IDC_BUTTON_MIX, + IDC_BUTTON_INFOTOGGLE, + IDC_BUTTON_CREATEPLAYLIST, + IDC_MIXABLE, + IDC_MEDIASTATUS, + }; + + m_hwnd = hwndDlg; + m_bgupdinfoviewerflag = 0; + columnOrder[0] = -1; + last_item = -1; + tt_buf[0] = 0; + + if (!cloud_hinst) cloud_hinst = (HINSTANCE)SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GET_CLOUD_HINST); + if (cloud_hinst && cloud_hinst != (HINSTANCE)1) + { + winampMediaLibraryPlugin *(*gp)(); + gp = (winampMediaLibraryPlugin * (__cdecl *)(void))GetProcAddress(cloud_hinst, "winampGetMediaLibraryPlugin"); + if (gp) + { + winampMediaLibraryPlugin *mlplugin = gp(); + if (mlplugin && (mlplugin->version >= MLHDR_VER_OLD && mlplugin->version <= MLHDR_VER)) + { + int64_t *out_ids = 0; + nx_string_t *out_filenames = 0; + size_t num_files = mlplugin->MessageProc(0x404, (INT_PTR)&out_filenames, (INT_PTR)&out_ids, 0xDEADBEEF); + for (size_t i = 0; i < num_files; i++) + { + cloudFiles.push_back((wchar_t *)out_filenames[i]->string); + } + if (out_filenames) + { + free(out_filenames); + out_filenames = 0; + } + if (out_ids) + { + free(out_ids); + out_ids = 0; + } + + HWND ml_pmp_window = FindWindowW(L"ml_pmp_window", NULL); + if (IsWindow(ml_pmp_window)) + { + SendMessage(ml_pmp_window, WM_PMP_IPC, (WPARAM)&cloudUploading, PMP_IPC_GETCLOUDTRANSFERS); + wchar_t a[32] = {0}; + StringCchPrintfW(a, 32, L"%d", cloudUploading.size()); + } + } + } + } + + EnterCriticalSection(&g_db_cs); + if (!m_media_scanner) m_media_scanner = NDE_Table_CreateScanner(g_table); + LeaveCriticalSection(&g_db_cs); + + itemCache.Items = 0; + itemCache.Alloc = 0; + itemCache.Size = 0; + + hwndList = GetDlgItem(hwndDlg, IDC_LIST2); + if (IsWindow(hwndList)) + { + resultlist.setwnd(hwndList); + resultlist.ForceUnicode(); + + DWORD styleEx = LVS_EX_DOUBLEBUFFER | LVS_EX_HEADERDRAGDROP | LVS_EX_ONECLICKACTIVATE; /*LVS_EX_ONECLICKACTIVATE - needed to hottracking work prior WinXp */ + SendMessageW(hwndList, LVM_SETEXTENDEDLISTVIEWSTYLE, styleEx, styleEx); + + HWND hwndHeader = (HWND)SendMessage(hwndList, LVM_GETHEADER, 0, 0L); + if (IsWindow(hwndHeader)) SetWindowLongPtrW(hwndHeader, GWLP_ID, IDC_LIST2HEADER); + + MLSKINWINDOW skin = {0}; + skin.hwndToSkin = hwndList; + skin.skinType = SKINNEDWND_TYPE_LISTVIEW; + skin.style = SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS | SWLVS_FULLROWSELECT | SWLVS_DOUBLEBUFFER | SWLVS_ALTERNATEITEMS; + MLSkinWindow(plugin.hwndLibraryParent, &skin); + } + else resultlist.setwnd(NULL); + + ff.mode = FFM_ERASEINPAINT; + for (index = 0; index < sizeof(ffcl) / sizeof(INT); index++) + { + ff.hwnd = GetDlgItem(hwndDlg, ffcl[index]); + SENDMLIPC(plugin.hwndLibraryParent, ML_IPC_FLICKERFIX, (WPARAM)&ff); + } + + if (!g_displaysearch) // disable search box + { + ShowWindow(GetDlgItem(hwndDlg, IDC_QUICKSEARCH), SW_HIDE); + ShowWindow(GetDlgItem(hwndDlg, IDC_CLEAR), SW_HIDE); + ShowWindow(GetDlgItem(hwndDlg, IDC_SEARCHCAPTION), SW_HIDE); + } + + if (!cloud_hinst || cloud_hinst == (HINSTANCE)1) + memcpy(columnOrder, defColumnOrder, sizeof(defColumnOrder)); + else + memcpy(columnOrder, defColumnOrderCloud, sizeof(defColumnOrderCloud)); + //Read the column order + + Dialog_OnDisplayChange(hwndDlg); + + int cloudcol = -1; + int l = g_view_metaconf->ReadInt(L"nbcolumns", 0); + if (l) + { + if (l > MAX_COLUMN_ORDER - 1) l = MAX_COLUMN_ORDER - 1; + index = 0; + for (; index < l; index++) + { + wchar_t tmp[128] = {0}; + StringCchPrintfW(tmp, 128, L"column%d", index); + int v = g_view_metaconf->ReadInt(tmp, 0); + if (v == MEDIAVIEW_COL_CLOUD) cloudcol = index; + if (v < 0 || v >= MEDIAVIEW_COL_NUMS) v = 0; + columnOrder[index] = (BYTE)v; + } + columnOrder[index] = -1; + } + + if (cloudcol == -1 && !g_view_metaconf->ReadInt(L"cloud", 1)) + { + g_view_metaconf->WriteInt(L"cloud", 1); + for(int i = l; i != 0; i--) + { + columnOrder[i+1] = columnOrder[i]; + if (i == 3) + { + columnOrder[i] = MEDIAVIEW_COL_CLOUD; + break; + } + } + } + + if (!GetPropW(hwndList, L"pmp_list_proc")) { + SetPropW(hwndList, L"pmp_list_proc", (HANDLE)SetWindowLongPtrW(hwndList, GWLP_WNDPROC, (LONG_PTR)pmp_listview)); + } + initColumnsHeader(hwndList); + + char *pszTextA = (g_config->ReadInt(L"remembersearch", 0)) ? g_view_metaconf->ReadString("lastquery_utf8", "") : ""; + AutoWide queryUnicode(pszTextA, CP_UTF8); + SetDlgItemTextW(hwndDlg, IDC_QUICKSEARCH, queryUnicode); + KillTimer(hwndDlg, UPDATE_QUERY_TIMER_ID); + doQuery(hwndDlg, queryUnicode, 0); + + updateInfoText(hwndDlg); + + search_oldWndProc = (WNDPROC)SetWindowLongPtrW(GetDlgItem(hwndDlg, IDC_QUICKSEARCH), GWLP_WNDPROC, (LONG_PTR)search_newWndProc); + + if (g_table && !NDE_Table_GetRecordsCount(g_table) && !g_config->ReadInt(L"noshowadddlg", 0)) + { + SetTimer(hwndDlg, 5050, 1000, NULL); + } + + groupBtn = g_config->ReadInt(L"groupbtn", 1); + enqueuedef = (g_config->ReadInt(L"enqueuedef", 0) == 1); + + /// detect predixis + predixisExist = FALSE; + //predixis out - begin + //pluginMessage p = {ML_MSG_PDXS_STATUS, (INT_PTR)"test", 0, 0}; + //pszTextA = (char *)SENDMLIPC(plugin.hwndLibraryParent, ML_IPC_SEND_PLUGIN_MESSAGE, (WPARAM)&p); + //predixisExist = (pszTextA != NULL && pszTextA[0] != 0); + //predixis out - end + + // v5.66+ - re-use the old predixis parts so the button can be used functionally via ml_enqplay + // pass the hwnd, button id and plug-in id so the ml plug-in can check things as needed + pluginMessage p = {ML_MSG_VIEW_BUTTON_HOOK, (INT_PTR)hwndDlg, (INT_PTR)MAKELONG(IDC_BUTTON_MIX, IDC_BUTTON_ENQUEUE), (INT_PTR)L"ml_local"}; + wchar_t *pszTextW = (wchar_t *)SENDMLIPC(plugin.hwndLibraryParent, ML_IPC_SEND_PLUGIN_MESSAGE, (WPARAM)&p); + if (pszTextW && pszTextW[0] != 0) + { + // set this to be a bit different so we can just use one button and not the + // mixable one as well (leaving that to prevent messing with the resources) + customAllowed = TRUE; + SetDlgItemTextW(hwndDlg, IDC_BUTTON_MIX, pszTextW); + } + else + customAllowed = FALSE; + + ShowWindow(GetDlgItem(hwndDlg, IDC_BUTTON_MIX), (!customAllowed ? SW_HIDE : SW_SHOW)); + ShowWindow(GetDlgItem(hwndDlg, IDC_MIXABLE), (!(predixisExist & 1) ? SW_HIDE : SW_SHOW)); + + MLSKINWINDOW m = {0}; + m.hwndToSkin = hwndDlg; + m.skinType = SKINNEDWND_TYPE_AUTO; + m.style = SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS | SWLVS_FULLROWSELECT | SWLVS_DOUBLEBUFFER | SWLVS_ALTERNATEITEMS; + MLSkinWindow(plugin.hwndLibraryParent, &m); + + m.skinType = SKINNEDWND_TYPE_BUTTON; + m.style = SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS | (groupBtn ? SWBS_SPLITBUTTON : 0); + + const int buttonids[] = {IDC_BUTTON_PLAY, IDC_BUTTON_ENQUEUE, IDC_BUTTON_MIX}; + for (size_t i=0;i!=sizeof(buttonids)/sizeof(buttonids[0]);i++) + { + m.hwndToSkin = GetDlgItem(hwndDlg, buttonids[i]); + if (IsWindow(m.hwndToSkin)) MLSkinWindow(plugin.hwndLibraryParent, &m); + } + + m.skinType = SKINNEDWND_TYPE_AUTO; + m.style = SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS; + + const int buttonidz[] = {IDC_SEARCHCAPTION, IDC_QUICKSEARCH, IDC_MEDIASTATUS, IDC_CLEAR, IDC_BUTTON_INFOTOGGLE, IDC_BUTTON_CREATEPLAYLIST, IDC_MIXABLE}; + for (size_t i=0;i!=sizeof(buttonidz)/sizeof(buttonidz[0]);i++) + { + m.hwndToSkin = GetDlgItem(hwndDlg, buttonidz[i]); + if (IsWindow(m.hwndToSkin)) MLSkinWindow(plugin.hwndLibraryParent, &m); + } + + Dialog_UpdateButtonText(hwndDlg, enqueuedef); + return FALSE; +} + +static BOOL Dialog_OnNotify(HWND hwndDlg, INT idCtrl, NMHDR* pnmh, LRESULT *pResult) +{ + switch (pnmh->idFrom) + { + case IDC_LIST2: + switch (pnmh->code) + { + case LVN_ITEMCHANGED: return ListView_OnItemChanged(hwndDlg, (NMLISTVIEW*)pnmh); + case NM_DBLCLK: return ListView_OnDoubleClick(hwndDlg, (NMITEMACTIVATE*)pnmh); + case LVN_ODFINDITEMA: + case LVN_ODFINDITEMW: return ListView_OnFindItem(hwndDlg, (NMLVFINDITEMW*)pnmh, pResult, pnmh->code); + case LVN_GETDISPINFOA: + case LVN_GETDISPINFOW: return ListView_OnGetDispInfo(hwndDlg, (NMLVDISPINFOW*)pnmh, pnmh->code); + case LVN_COLUMNCLICK: return ListView_OnColumnClick(hwndDlg, (NMLISTVIEW*)pnmh); + case LVN_BEGINDRAG: return ListView_OnBeginDrag(hwndDlg, (NMLISTVIEW*)pnmh); + case NM_RETURN: return ListView_OnReturn(hwndDlg, pnmh); + case NM_CUSTOMDRAW: return ListView_OnCustomDraw(hwndDlg, (NMLVCUSTOMDRAW*)pnmh, pResult); + case LVN_HOTTRACK: return ListView_OnHotTrack(hwndDlg, (NMLISTVIEW*)pnmh, pResult); + case NM_CLICK: return ListView_OnClick(hwndDlg, (NMITEMACTIVATE*)pnmh); + } + break; + case IDC_LIST2HEADER: + switch (pnmh->code) + { + case NM_RCLICK: return Header_OnRightClick(hwndDlg, pnmh, pResult); + case HDN_ENDDRAG: return Header_OnEndDrag(hwndDlg, (NMHEADERW*)pnmh, pResult); + case HDN_ITEMCHANGINGA: + case HDN_ITEMCHANGINGW: return Header_OnItemChanging(hwndDlg, (NMHEADERW*)pnmh, pResult, pnmh->code); + } + break; + } + return FALSE; +} + +static void Dialog_OnInitMenuPopup(HWND hwndDlg, HMENU hMenu, UINT nIndex, BOOL bSysMenu) +{ + if (hMenu && hMenu == s.build_hMenu && s.mode == 1) + { + myMenu = TRUE; + if (SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&s, IPC_LIBRARY_SENDTOMENU) == (LRESULT)-1) + s.mode = 2; + myMenu = FALSE; + } + if (rate_hmenu && hMenu == rate_hmenu) + { + int x; + int sel = 0; + for (x = 0; x < itemCache.Size; x ++) + { + if (resultlist.GetSelected(x)) + { + int s = itemCache.Items[x].rating; + if (s == sel || !sel) sel = s; + if (s != sel) break; + } + } + if (-1 == sel) sel = 0; + Menu_SetRatingValue(rate_hmenu, sel); + } + if (cloud_hmenu && hMenu == cloud_hmenu) + { + int n = resultlist.GetSelectionMark(); + if (n != -1 && !GetMenuItemCount(hMenu)) + { + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_GET_CLOUD_STATUS, (intptr_t)itemCache.Items[n].filename, (intptr_t)&cloud_hmenu); + } + } +} + +static void Dialog_OnMouseMove(HWND hwndDlg, UINT nFlags, POINTS pts) +{ + if (GetCapture() == hwndDlg) + { + mlDropItemStruct m = {0}; + + POINTSTOPOINT(m.p, pts); + MapWindowPoints(hwndDlg, HWND_DESKTOP, (POINT*)&m.p, 1); + + if (MLRatingColumn_Drag(plugin.hwndLibraryParent, &m.p)) return; + + m.type = ML_TYPE_ITEMRECORDLIST; + pluginHandleIpcMessage(ML_IPC_HANDLEDRAG, (WPARAM)&m); + + } +} +static void Dialog_OnLButtonUp(HWND hwndDlg, UINT nFlags, POINTS pts) +{ + if (GetCapture() == hwndDlg) + { + mlDropItemStruct m = {0}; + + ReleaseCapture(); + + POINTSTOPOINT(m.p, pts); + MapWindowPoints(hwndDlg, HWND_DESKTOP, (POINT*)&m.p, 1); + + ratingColumn.bCanceled = FALSE; + ratingColumn.ptAction = m.p; + ratingColumn.bRedrawNow = TRUE; + + if (MLRatingColumn_EndDrag(plugin.hwndLibraryParent, &ratingColumn)) + { + SetRating(ratingColumn.iItem, ratingColumn.value, ratingColumn.hwndList); + return; + } + + m.type = ML_TYPE_ITEMRECORDLISTW; + m.flags = ML_HANDLEDRAG_FLAG_NOCURSOR; + + + pluginHandleIpcMessage(ML_IPC_HANDLEDRAG, (WPARAM)&m); + + if (m.result > 0) // try itemRecordListW + { + itemRecordListW myObj = {0, }; + copyFilesToItemCacheW(&myObj); + m.flags = 0; + m.result = 0; + m.data = (void*) & myObj; + pluginHandleIpcMessage(ML_IPC_HANDLEDROP, (WPARAM)&m); + _aligned_free(myObj.Items); // DO NOT empty this object, cause it doesnt own its data + } + else // if it didn't work, fall back to itemRecordList + { + m.type = ML_TYPE_ITEMRECORDLIST; + m.result = 0; + + pluginHandleIpcMessage(ML_IPC_HANDLEDRAG, (WPARAM)&m); + if (m.result > 0) + { + itemRecordListW myObj = {0, }; + copyFilesToItemCacheW(&myObj); + + itemRecordList objA = {0, }; + convertRecordList(&objA, &myObj); + m.flags = 0; + m.result = 0; + m.data = (void*) & objA; + pluginHandleIpcMessage(ML_IPC_HANDLEDROP, (WPARAM)&m); + emptyRecordList(&objA); + freeRecordList(&objA); + _aligned_free(myObj.Items); // DO NOT empty this object, cause it doesnt own its data + } + } + } +} + +class ItemRecordPlaylist : public ifc_playlist +{ +public: + ItemRecordPlaylist(const itemRecordListW *_list) + { + list = _list; + } + +private: + size_t GetNumItems() + { + return list->Size; + } + + size_t GetItem(size_t item, wchar_t *filename, size_t filenameCch) + { + if (item < (size_t)list->Size && list->Items[item].filename) + { + StringCchCopyW(filename, filenameCch, list->Items[item].filename); + return 1; + } + return 0; + } + + size_t GetItemTitle(size_t item, wchar_t *title, size_t titleCch) + { + if (item < (size_t)list->Size && list->Items[item].filename) + { + TAG_FMT_EXT(list->Items[item].filename, itemrecordWTagFunc, ndeTagFuncFree, (void*)&list->Items[item], title, titleCch, 0); + return 1; + } + return 0; + } + + int GetItemLengthMilliseconds(size_t item) + { + if (item < (size_t)list->Size && list->Items[item].length>=0) + { + return list->Items[item].length * 1000; + } + return -1000; + } + +private: + const itemRecordListW *list; +protected: + RECVS_DISPATCH; +}; + +#define CBCLASS ItemRecordPlaylist +START_DISPATCH; +CB(IFC_PLAYLIST_GETNUMITEMS, GetNumItems) +CB(IFC_PLAYLIST_GETITEM, GetItem) +CB(IFC_PLAYLIST_GETITEMTITLE, GetItemTitle) +CB(IFC_PLAYLIST_GETITEMLENGTHMILLISECONDS, GetItemLengthMilliseconds) +END_DISPATCH; +#undef CBCLASS + + +static void Dialog_OnCommand(HWND hwndDlg, UINT idCtrl, INT nCode, HWND hwndCtrl) +{ + if (GetFocus() != hwndSearchGlobal) + { + switch (idCtrl) + { + case IDC_CLEAR: + SetDlgItemText(hwndDlg, IDC_QUICKSEARCH, L""); + break; + case IDC_BUTTON_INFOTOGGLE: + updateInfoText(hwndDlg, TRUE); + UpdateWindow(hwndDlg); + LayoutWindows(hwndDlg, TRUE); + break; + case IDC_QUICKSEARCH: + if (nCode == EN_CHANGE) + { + KillTimer(hwndDlg, UPDATE_QUERY_TIMER_ID); + SetTimer(hwndDlg, UPDATE_QUERY_TIMER_ID, g_querydelay, NULL); + } + break; + case ID_AUDIOWND_PLAYSELECTION: + case ID_QUERYWND_PLAYQUERY: + case IDC_BUTTON_PLAY: + case ID_MEDIAWND_PLAYSELECTEDFILES: + case ID_AUDIOWND_ENQUEUESELECTION: + case IDC_BUTTON_ENQUEUE: + case ID_MEDIAWND_ENQUEUESELECTEDFILES: + case IDC_BUTTON_MIX: + { + if (nCode == MLBN_DROPDOWN) + { + Dialog_Play(hwndDlg, hwndCtrl, idCtrl); + } + else + { + int action; + if (idCtrl == IDC_BUTTON_PLAY || idCtrl == ID_MEDIAWND_PLAYSELECTEDFILES || idCtrl == ID_AUDIOWND_PLAYSELECTION) + { + action = (nCode == 1) ? g_config->ReadInt(L"enqueuedef", 0) == 1 : 0; + } + else if (idCtrl == IDC_BUTTON_ENQUEUE || idCtrl == ID_MEDIAWND_ENQUEUESELECTEDFILES || idCtrl == ID_AUDIOWND_ENQUEUESELECTION) + { + action = (nCode == 1) ? g_config->ReadInt(L"enqueuedef", 0) != 1 : 1; + } + else + break; + + int i, l = itemCache.Size; + for (i = 0; i < l; i++) if (resultlist.GetSelected(i)) break; + playFiles(action/*idCtrl == IDC_BUTTON_ENQUEUE*/, i == l); + } + } + break; + case IDC_BUTTON_CREATEPLAYLIST: +#if 0 + // TODO consider exposing this option somehow... + if (AGAVE_API_PLAYLISTMANAGER) // This is the old Create Playlist button code + { + wchar_t fn[MAX_PATH] = {0}; + wchar_t dir[MAX_PATH] = {0}; + GetTempPathW(MAX_PATH,dir); + GetTempFileNameW(dir,L"ml_playlist",0,fn); + wcscat(fn,L".m3u8"); + + ItemRecordPlaylist playlist(&itemCache); + if (AGAVE_API_PLAYLISTMANAGER->Save(fn, &playlist) == PLAYLISTMANAGER_SUCCESS) + { + mlAddPlaylist p={sizeof(p),NULL,fn,PL_FLAGS_IMPORT,-1,-1}; + SendMessage(plugin.hwndLibraryParent,WM_ML_IPC,(WPARAM)&p,ML_IPC_PLAYLIST_ADD); + DeleteFileW(fn); + } + } +#endif + if (AGAVE_API_PLAYLIST_GENERATOR) + { + const int number_selected = resultlist.GetSelectedCount(); // Total selected + + if (number_selected > 0) + { + itemRecordListW recordList; // Record list + itemRecordW *records = new itemRecordW[number_selected]; // Array of records + + int selectedRecordcounter = 0; + for (int i = 0; i < itemCache.Size; i++) + { + if (resultlist.GetSelected(i)) // See if the current item is selected or not + { + records[selectedRecordcounter] = itemCache.Items[i]; // If its selected then add it to our itemlist + selectedRecordcounter++; + } + } + + recordList.Size = selectedRecordcounter; // Set the correct size of the record list + recordList.Items = records; // Set the array of records to the record list + + AGAVE_API_PLAYLIST_GENERATOR->GeneratePlaylist(hwndDlg, &recordList); // Call the playlist API with the list of selected records + + delete [] records; // Free up the array of records + } + else + { + wchar_t title[64] = {0}; + MessageBoxW(m_hwnd, WASABI_API_LNGSTRINGW(IDS_ERROR_PLG_SELECT_TRACKS), WASABI_API_LNGSTRINGW_BUF(IDS_NULLSOFT_PLAYLIST_GENERATOR,title,64), MB_OK | MB_ICONINFORMATION); + } + } + break; +#if 0 + case IDC_BUTTON_MIX: + { + itemRecordList list; + int i; + int ct = 0; + for (i = 0; i < itemCache.Size; i++) + { + if (resultlist.GetSelected(i)) + { + ct++; + } + } + ZeroMemory(&list, sizeof(itemRecordList)); + allocRecordList(&list, ct, 1); + list.Size = ct; + ct = 0; + for (i = 0; i < itemCache.Size; i++) + { + if (resultlist.GetSelected(i)) + { + convertRecord(&list.Items[ct], &itemCache.Items[i]); + ct++; + } + } + pluginMessage p = {ML_MSG_PDXS_MIX, (INT_PTR) &list, 0, 0}; + SendMessage(plugin.hwndLibraryParent, WM_ML_IPC, (WPARAM)&p, ML_IPC_SEND_PLUGIN_MESSAGE); + emptyRecordList(&list); + freeRecordList(&list); + } + break; +#endif + case ID_MEDIAWND_SELECTALL: + { + LVITEM item = {0}; + item.state = LVIS_SELECTED; + item.stateMask = LVIS_SELECTED; + SendMessageW(resultlist.getwnd(), LVM_SETITEMSTATE, (WPARAM)-1, (LPARAM)&item); + } + break; + case ID_MEDIAWND_REMOVEFROMLIBRARY: + removeSelectedItems(0); + break; + case ID_EDITITEMINFOS: + if (resultlist.GetSelectedCount() > 0) + editInfo(hwndDlg); + break; + case ID_PE_ID3: + fileInfoDialogs(hwndDlg); + PostMessageW(hwndDlg, WM_NEXTDLGCTL, (WPARAM)resultlist.getwnd(), (LPARAM)TRUE); + break; + case IDC_REFRESH_METADATA: + RefreshMetadata(hwndDlg); + break; + case ID_MEDIAWND_EXPLOREFOLDER: + exploreItemFolder(hwndDlg); + break; + } + } + else + { + switch (idCtrl) + { + case IDC_QUICKSEARCH: + if (nCode == EN_CHANGE) + { + KillTimer(hwndDlg, UPDATE_QUERY_TIMER_ID); + SetTimer(hwndDlg, UPDATE_QUERY_TIMER_ID, g_querydelay, NULL); + } + break; + case ID_MEDIAWND_SELECTALL: + SendMessageW(hwndSearchGlobal, EM_SETSEL, 0, -1); + break; + case ID_MEDIAWND_REMOVEFROMLIBRARY: + { + DWORD start = -1, end = -1; + SendMessageW(hwndSearchGlobal, EM_GETSEL, (WPARAM)&start, (LPARAM)&end); + if (start != -1) + { + if (start == end) + { + SendMessageW(hwndSearchGlobal, EM_SETSEL, start, end + 1); + } + SendMessageW(hwndSearchGlobal, EM_REPLACESEL, TRUE, (LPARAM)""); + SendMessageW(hwndSearchGlobal, EM_SETSEL, start, start); + } + } + break; + } + } +} + +static void Dialog_OnTimer(HWND hwndDlg, UINT_PTR idEvent, TIMERPROC fnTimer) +{ + switch (idEvent) + { + case 5050: + KillTimer(hwndDlg, 5050); + WASABI_API_DIALOGBOXW(IDD_NEEDADDFILES, hwndDlg, needAddFilesProc); + PostMessage(GetParent(hwndDlg), WM_APP + 1, (WPARAM)0, (LPARAM)0); + break; + case 6600: + KillTimer(hwndDlg, idEvent); + if (m_last_selitem >= 0 && m_last_selitem < itemCache.Size) + { + if (predixisExist & 1) + { + // Only single seeds are supported currently + if (resultlist.GetSelectedCount() == 1 && isMixable(itemCache.Items[m_last_selitem])) + { + SetDlgItemTextW(hwndDlg, IDC_MIXABLE, WASABI_API_LNGSTRINGW(IDS_MIXABLE)); + isMixablePresent = true; + } + else SetDlgItemText(hwndDlg, IDC_MIXABLE, L""); + } + SendMessageW(GetParent(hwndDlg), WM_SHOWFILEINFO, (WPARAM)FALSE, (LPARAM)itemCache.Items[m_last_selitem].filename); + m_last_selitem = -1; + } + break; + case 123: + if (bgThread_Handle) + { + HWND hwndList; + hwndList = resultlist.getwnd(); + if (1 != ListView_GetItemCount(hwndList)) ListView_SetItemCountEx(hwndList, 1, LVSICF_NOINVALIDATEALL | LVSICF_NOSCROLL); + ListView_RedrawItems(hwndList, 0, 0); + //UpdateWindow(hwndList); + } + break; + case UPDATE_QUERY_TIMER_ID: + { + KillTimer(hwndDlg, UPDATE_QUERY_TIMER_ID); + wchar_t buf[2048] = {0}; + GetWindowTextW(GetDlgItem(hwndDlg, IDC_QUICKSEARCH), buf, ARRAYSIZE(buf)); + doQuery(hwndDlg, buf); + } + break; + case UPDATE_RESULT_LIST_TIMER_ID: + { + ListView_RedrawItems(resultlist.getwnd(), 0, resultlist.GetCount() - 1); + } + break; + } +} + +static void Dialog_OnDestroy(HWND hwndDlg) +{ + HWND hwndList; + INT i, j; + wchar_t buf[2048] = {0}; + + bgQuery_Stop(); + + GetDlgItemTextW(hwndDlg, IDC_QUICKSEARCH, buf, ARRAYSIZE(buf)); + g_view_metaconf->WriteString("lastquery_utf8", AutoChar(buf, CP_UTF8)); + + hwndList = GetDlgItem(hwndDlg, IDC_LIST2); + if (hwndList && IsWindow(hwndList)) + { + for (i = 0; columnOrder[i] != -1; i++) + { + headerColumn *cl = &columnList[columnOrder[i]]; + g_view_metaconf->WriteInt(AutoWide(cl->config_name), SendMessageW(hwndList, LVM_GETCOLUMNWIDTH, i, 0L)); + } + } + + //Save the column order + for (i = 0; columnOrder[i] != -1; i++); + g_view_metaconf->WriteInt(L"nbcolumns", i); + for (j = 0; j < i; j++) + { + wchar_t tmp[128] = {0}; + StringCchPrintfW(tmp, 128, L"column%d", j); + g_view_metaconf->WriteInt(tmp, columnOrder[j]); + } + + freeRecordList(&itemCache); + itemCache.Items = 0; + itemCache.Alloc = 0; + itemCache.Size = 0; + + cloudFiles.clear(); + cloudUploading.clear(); + + hwndSearchGlobal = 0; // Set the hwnd for the search to a global to null so we know we are not in the single pane view +} + +static void Dialog_OnWindowPosChanged(HWND hwndDlg, WINDOWPOS *pwp) +{ + if ((SWP_NOSIZE | SWP_NOMOVE) != ((SWP_NOSIZE | SWP_NOMOVE) & pwp->flags) || (SWP_FRAMECHANGED & pwp->flags)) + { + LayoutWindows(hwndDlg, !(SWP_NOREDRAW & pwp->flags), 0 != (SWP_SHOWWINDOW & pwp->flags)); + } +} + +static void Dialog_OnSyncHeaderOrder(HWND hwndDlg, HWND hwndHeader) +{ + LVCOLUMNW column = {0}; + wchar_t buffer[128] = {0}; + signed char tempOrder[MAX_COLUMN_ORDER] = {0}; + HWND hwndList = GetDlgItem(hwndDlg, IDC_LIST2); + + if (!hwndList) return; + + CopyMemory(tempOrder, columnOrder, sizeof(tempOrder)/sizeof(signed char)); + + column.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM | LVCF_IMAGE; + column.cchTextMax = sizeof(buffer) /sizeof(wchar_t); + + SendMessageW(hwndList, WM_SETREDRAW, FALSE, 0L); + + INT sort = MLSkinnedListView_GetSort(hwndList); + INT count = (INT)SendMessageW(hwndHeader, HDM_GETITEMCOUNT, 0, 0L); + if (count > 0) + { + INT index = count + 1, *pOrder = (INT*)calloc(1, sizeof(INT)*count); + if (pOrder && SendMessageW(hwndList, LVM_GETCOLUMNORDERARRAY, count, (LPARAM)pOrder)) + { + INT order; + for (order = 0; order < count; order++) + { + column.pszText = buffer; + if (!SendMessageW(hwndList, LVM_GETCOLUMNW, pOrder[order], (LPARAM)&column)) continue; + column.iOrder = order; + + // update position of the cloud column icon + if (tempOrder[pOrder[order]] == MEDIAVIEW_COL_CLOUD) + { + if (!cloud_hinst || cloud_hinst == (HINSTANCE)1 || + !SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GET_CLOUD_ACTIVE)) + { + MLSkinnedHeader_SetCloudColumn(ListView_GetHeader(hwndList), -1); + SetPropW(hwndList, L"pmp_list_info", (HANDLE)-1); + column.cx = 0; + } + else + { + MLSkinnedHeader_SetCloudColumn(ListView_GetHeader(hwndList), order); + SetPropW(hwndList, L"pmp_list_info", (HANDLE)order); + column.cx = 27; + MLCloudColumn_GetWidth(plugin.hwndLibraryParent, &column.cx); + } + } + + SendMessageW(hwndList, LVM_INSERTCOLUMNW, index++, (LPARAM)&column); + columnOrder[order] = tempOrder[pOrder[order]]; + + if (LOWORD(sort) == pOrder[order]) MLSkinnedListView_DisplaySort(hwndList, order, HIWORD(sort)); + } + for (order = 0; order < count; order++) SendMessageW(hwndList, LVM_DELETECOLUMN, 0, 0L); + } + + for (index = 0; -1 != columnOrder[index] && MEDIAVIEW_COL_RATING != columnOrder[index] && MEDIAVIEW_COL_CLOUD != columnOrder[index]; index++); + if (-1 != columnOrder[index]) + { + INT w = (INT)SendMessageW(hwndList, LVM_GETCOLUMNWIDTH, index, 0L); + SendMessageW(hwndList, LVM_SETCOLUMNWIDTH, index, (LPARAM)w); + } + + if (pOrder) free(pOrder); + } + + SendMessageW(hwndList, WM_SETREDRAW, TRUE, 0L); +} + +static void Window_OnQueryFileInfo(HWND hwnd) +{ + INT index; + HWND hwndList = GetDlgItem(hwnd, IDC_LIST2); + index = (hwndList) ? (INT)SendMessage(hwndList, LVM_GETNEXTITEM, (WPARAM)-1, (LPARAM)LVNI_FOCUSED) : -1; + SendMessageW(GetParent(hwnd), WM_SHOWFILEINFO, (WPARAM)FALSE, (LPARAM)((-1 != index && index < itemCache.Size) ? itemCache.Items[index].filename : L"")); +} + +void Window_OnDropFiles(HWND hwndDlg, HDROP hdrop) +{ + wchar_t temp[1024] = {0}; + int y = DragQueryFileW(hdrop, 0xffffffff, temp, 1024); + if (y > 0) + { + wchar_t **paths = (wchar_t **)calloc(y, sizeof(wchar_t *)); + int *guesses = (int *)calloc(y, sizeof(int)); + int *metas = (int *)calloc(y, sizeof(int)); + int *recs= (int *)calloc(y, sizeof(int)); + if (paths && guesses && metas && recs) + { + size_t count=0; + for (int x = 0; x < y; x ++) + { + DragQueryFileW(hdrop, x, temp, 1024); + int guess = -1, meta = -1, rec = 1; + // do this for normal media drops + PLCallBackW plCB; + if (AGAVE_API_PLAYLISTMANAGER && PLAYLISTMANAGER_SUCCESS != AGAVE_API_PLAYLISTMANAGER->Load(temp, &plCB)) + { + autoscan_add_directory(temp, &guess, &meta, &rec, 0); + if (guess == -1) guess = g_config->ReadInt(L"guessmode", 0); + if (meta == -1) meta = g_config->ReadInt(L"usemetadata", 1); + paths[count] = _wcsdup(temp); + guesses[count]=guess; + metas[count]=meta; + recs[count]=rec; + count++; + } + } + DragFinish(hdrop); + Scan_ScanFolders(hwndDlg, count, paths, guesses, metas, recs); + if (IsWindow(m_curview_hwnd)) SendMessage(m_curview_hwnd, WM_APP + 1, 0, 0); //update current view + } + else + { + free(paths); + free(guesses); + free(metas); + free(recs); + } + } + else DragFinish(hdrop); +} + + +INT_PTR CALLBACK view_mediaDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + BOOL a = dialogSkinner.Handle(hwndDlg, uMsg, wParam, lParam); if (a) return a; + + switch (uMsg) + { + case WM_INITMENUPOPUP: Dialog_OnInitMenuPopup(hwndDlg, (HMENU)wParam, LOWORD(lParam), HIWORD(lParam)); break; + case WM_DISPLAYCHANGE: Dialog_OnDisplayChange(hwndDlg); break; + case WM_INITDIALOG: return Dialog_OnInit(hwndDlg, (HWND)wParam, lParam); + case WM_MOUSEMOVE: Dialog_OnMouseMove(hwndDlg, (UINT)wParam, MAKEPOINTS(lParam)); break; + case WM_LBUTTONUP: Dialog_OnLButtonUp(hwndDlg, (UINT)wParam, MAKEPOINTS(lParam)); break; + case WM_DROPFILES: Window_OnDropFiles(hwndDlg, (HDROP)wParam); + case WM_COMMAND: Dialog_OnCommand(hwndDlg, LOWORD(wParam), HIWORD(wParam), (HWND)lParam); break; + case WM_TIMER: Dialog_OnTimer(hwndDlg, (UINT_PTR) wParam, (TIMERPROC)lParam); break; + case WM_DESTROY: Dialog_OnDestroy(hwndDlg); break; + case WM_WINDOWPOSCHANGED: Dialog_OnWindowPosChanged(hwndDlg, (WINDOWPOS*)lParam); break; + case WM_ERASEBKGND: return 1; //handled by WADlg_DrawChildWindowBorders in WM_PAINT + case WM_CONTEXTMENU: + Dialog_OnContextMenu(hwndDlg, (HWND)wParam, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)); + return 0; + case WM_NOTIFY: + { + LRESULT result; + result = 0L; + if (Dialog_OnNotify(hwndDlg, (INT)wParam, (NMHDR*)lParam, &result)) + { + SetWindowLongPtrW(hwndDlg, DWLP_MSGRESULT, (LONG_PTR)result); + return TRUE; + } + } + break; + case IM_SYNCHEADERORDER: Dialog_OnSyncHeaderOrder(hwndDlg, (HWND)lParam); break; + case WM_APP + 3: // send by bgthread + if (wParam == 0x666) m_bgupdinfoviewerflag = 1; + else if (wParam == 0x69) + { + bgQuery_Stop(); + + resultlist.SetVirtualCount(0); + resultlist.SetVirtualCount(itemCache.Size); // TODO: we could set a limit here + ListView_RedrawItems(resultlist.getwnd(), 0, itemCache.Size - 1); + UpdateWindow(resultlist.getwnd()); + + __int64 total_len_bytes = bg_total_len_bytes; + + int total_length_s = (int)bg_total_len_s & 0x7FFFFFFF; + wchar_t buffer[4*64] = {0}; + wchar_t *pb[4] = {0}; + for (int i = 0; i < 4; i++) pb[i] = buffer + i * 64; + + + int index(0); + + StringCchPrintfW(pb[index], 64, L"%d %s", itemCache.Size, + WASABI_API_LNGSTRINGW(itemCache.Size == 1 ? IDS_ITEM : IDS_ITEMS)); + index++; + + if (itemCache.Size) + { + int uncert = 0; //bg_total_len_s>>31; + if (total_length_s < 60*60) StringCchPrintfW(pb[index], 64, L"[%s%u:%02u]", uncert ? L"~" : L"", total_length_s / 60, total_length_s % 60); + else if (total_length_s < 60*60*24) StringCchPrintfW(pb[index], 64, L"[%s%u:%02u:%02u]", uncert ? L"~" : L"", total_length_s / 60 / 60, (total_length_s / 60) % 60, total_length_s % 60); + else + { + wchar_t days[16] = {0}; + int total_days = total_length_s / (60 * 60 * 24); + total_length_s -= total_days * 60 * 60 * 24; + StringCchPrintfW(pb[index], 64, + WASABI_API_LNGSTRINGW(IDS_LENGTH_DURATION_STRING), + uncert ? L"~" : L"", total_days, + WASABI_API_LNGSTRINGW_BUF(total_days == 1 ? IDS_DAY : IDS_DAYS, days, 16), + total_length_s / 60 / 60, (total_length_s / 60) % 60, total_length_s % 60); + } + index++; + } + + if (total_len_bytes) + { + StringCchCopyW(pb[index], 64, L"["); + WASABI_API_LNG->FormattedSizeString(pb[index] + 1, 64, total_len_bytes); + StringCchCatW(pb[index], 64, L"]"); + index++; + } + + unsigned int ms = (UINT)(querytime.QuadPart * 1000 / freq.QuadPart); + StringCchPrintfW(pb[index], 64, WASABI_API_LNGSTRINGW(IDS_IN_X_SEC), ms / 1000.0f); + index++; + + SetStatusText(GetDlgItem(hwndDlg, IDC_MEDIASTATUS), (LPCWSTR*)pb, index); + + if (m_bgupdinfoviewerflag) + { + m_bgupdinfoviewerflag = 0; + if (itemCache.Size > 0) + { + if (predixisExist) + { + if (resultlist.GetSelectedCount() == 1 && isMixable(itemCache.Items[0])) + { + SetDlgItemText(hwndDlg, IDC_MIXABLE, L""); + isMixablePresent = true; + } + else + { + SetDlgItemText(hwndDlg, IDC_MIXABLE, L""); + } + } + SendMessageW(GetParent(hwndDlg), WM_SHOWFILEINFO, (WPARAM)FALSE, (LPARAM)itemCache.Items[0].filename); + } + } + } + break; + case WM_APP + 1: + bgQuery((resultsniff_funcW)wParam, (int)lParam); + break; + case WM_APP + 5: + { + // TODO + int done = (HIWORD(wParam) == 1); + int code = (LOWORD(wParam)); + for (int i = 0; i < itemCache.Size; i ++) + { + // 0 = no change + // 1 = add cloud + // 2 = add local + // 4 = removed + if (!lstrcmpiW(itemCache.Items[i].filename, (wchar_t *)lParam)) + { + if (!done) + { + setCloudValue(&itemCache.Items[i], L"5"); + } + else + { + if (code == NErr_Success) + { + // uploaded ok + // TODO if going to another device, will need to alter this + setCloudValue(&itemCache.Items[i], L"0"); + } + else + { + // re-query state + setCloudValue(&itemCache.Items[i], L"0"); + } + } + InvalidateRect(resultlist.getwnd(), NULL, TRUE); + break; + } + } + break; + } + case WM_APP + 6: // handles the ml_cloud 'first pull' announces so we + { // can then show the cloud column & update the cache + initColumnsHeader(resultlist.getwnd()); + bgQuery();//(resultsniff_funcW)wParam, (int)lParam); + break; + } + case WM_APP + 104: + { + Dialog_UpdateButtonText(hwndDlg, wParam); + LayoutWindows(hwndDlg, TRUE); + return 0; + } + case WM_PAINT: + { + int tab[] = { IDC_LIST2 | DCW_SUNKENBORDER, IDC_QUICKSEARCH | DCW_SUNKENBORDER}; + dialogSkinner.Draw(hwndDlg, tab, 1 + !!IsWindowVisible(GetDlgItem(hwndDlg, IDC_QUICKSEARCH))); + } + return 0; + + case WM_ML_CHILDIPC: + switch (lParam) + { + case ML_CHILDIPC_GO_TO_SEARCHBAR: + SendDlgItemMessage(hwndDlg, IDC_QUICKSEARCH, EM_SETSEL, 0, -1); + SetFocus(GetDlgItem(hwndDlg, IDC_QUICKSEARCH)); + break; + case ML_CHILDIPC_REFRESH_SEARCH: + PostMessage(hwndDlg, WM_COMMAND, MAKEWPARAM(IDC_QUICKSEARCH, EN_CHANGE), (LPARAM)GetDlgItem(hwndDlg, IDC_QUICKSEARCH)); + break; + } + break; + + case WM_USER + 0x201: + offsetX = (short)LOWORD(wParam); + offsetY = (short)HIWORD(wParam); + g_rgnUpdate = (HRGN)lParam; + return TRUE; + case WM_QUERYFILEINFO: Window_OnQueryFileInfo(hwndDlg); break; + } + return FALSE; +} + +//////////////////////////////// Customize columns dialog + +static signed char edit_columnOrder[MAX_COLUMN_ORDER]; + +static INT_PTR CALLBACK custColumns_dialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + static HWND m_curlistbox_hwnd, m_availlistbox_hwnd; + + switch (uMsg) + { + case WM_INITDIALOG: + memcpy(edit_columnOrder, columnOrder, sizeof(edit_columnOrder)); + m_curlistbox_hwnd = GetDlgItem(hwndDlg, IDC_LIST1); + m_availlistbox_hwnd = GetDlgItem(hwndDlg, IDC_LIST2); + + if (NULL != WASABI_API_APP) + { + if (NULL != m_curlistbox_hwnd) + WASABI_API_APP->DirectMouseWheel_EnableConvertToMouseWheel(m_curlistbox_hwnd, TRUE); + if (NULL != m_availlistbox_hwnd) + WASABI_API_APP->DirectMouseWheel_EnableConvertToMouseWheel(m_availlistbox_hwnd, TRUE); + } + + case WM_USER + 32: + { + for (int i = 0; edit_columnOrder[i] != -1; i++) + { + int c = edit_columnOrder[i]; + headerColumn *cl = &columnList[c]; + int column_id = cl->column_id; + if (column_id == IDS_CLOUD || column_id == IDS_CLOUD_HIDDEN) + { + // if no cloud support at all then we hide everything + if (!cloud_hinst || cloud_hinst == (HINSTANCE)1) continue; + column_id = ((!cloud_hinst || cloud_hinst == (HINSTANCE)1 || + !SendMessageW(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GET_CLOUD_ACTIVE)) ? IDS_CLOUD_HIDDEN : IDS_CLOUD); + } + int r = SendMessageW(m_curlistbox_hwnd, LB_ADDSTRING, 0, (LPARAM)WASABI_API_LNGSTRINGW(column_id)); + SendMessageW(m_curlistbox_hwnd, LB_SETITEMDATA, r, c); + } + + for (int i = 0; i < sizeof(columnList) / sizeof(headerColumn); i++) + { + headerColumn *cl = &columnList[i]; + int j; + for (j = 0; edit_columnOrder[j] != -1 && edit_columnOrder[j] != i; j++); + if (edit_columnOrder[j] == -1) + { + int column_id = cl->column_id; + if (column_id == IDS_CLOUD || column_id == IDS_CLOUD_HIDDEN) + { + // if no cloud support at all then we hide everything + if (!cloud_hinst || cloud_hinst == (HINSTANCE)1) continue; + column_id = ((!cloud_hinst || cloud_hinst == (HINSTANCE)1 || + !SendMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_GET_CLOUD_ACTIVE)) ? IDS_CLOUD_HIDDEN : IDS_CLOUD); + } + int r = SendMessageW(m_availlistbox_hwnd, LB_ADDSTRING, 0, (LPARAM)WASABI_API_LNGSTRINGW(column_id)); + SendMessageW(m_availlistbox_hwnd, LB_SETITEMDATA, r, i); + } + } + } + break; + case WM_COMMAND: + switch (LOWORD(wParam)) + { + case IDC_DEFS: + if (!cloud_hinst || cloud_hinst == (HINSTANCE)1) + memcpy(edit_columnOrder, defColumnOrder, sizeof(defColumnOrder)); + else + memcpy(edit_columnOrder, defColumnOrderCloud, sizeof(defColumnOrderCloud)); + SendMessage(m_curlistbox_hwnd, LB_RESETCONTENT, 0, 0); + SendMessage(m_availlistbox_hwnd, LB_RESETCONTENT, 0, 0); + SendMessage(hwndDlg, WM_USER + 32, 0, 0); + break; + case IDC_LIST2: + if (HIWORD(wParam) != LBN_DBLCLK) + { + if (HIWORD(wParam) == LBN_SELCHANGE) + { + int r = SendMessage(m_availlistbox_hwnd, LB_GETSELCOUNT, 0, 0) > 0; + EnableWindow(GetDlgItem(hwndDlg, IDC_BUTTON2), r); + } + return 0; + } + case IDC_BUTTON2: + //add column + { + for (int i = 0;i < SendMessage(m_availlistbox_hwnd, LB_GETCOUNT, 0, 0);i++) + { + if (SendMessage(m_availlistbox_hwnd, LB_GETSEL, i, 0)) + { + int c = SendMessage(m_availlistbox_hwnd, LB_GETITEMDATA, i, 0); + int j; + for (j = 0;edit_columnOrder[j] != -1;j++); + edit_columnOrder[j] = (BYTE)c; + edit_columnOrder[j + 1] = -1; + SendMessage(m_availlistbox_hwnd, LB_DELETESTRING, i, 0); + i--; + + int r = SendMessageW(m_curlistbox_hwnd, LB_ADDSTRING, 0, (LPARAM)WASABI_API_LNGSTRINGW(columnList[c].column_id)); + SendMessageW(m_curlistbox_hwnd, LB_SETITEMDATA, r, c); + } + } + EnableWindow(GetDlgItem(hwndDlg, IDC_BUTTON2), 0); + } + break; + case IDC_LIST1: + if (HIWORD(wParam) != LBN_DBLCLK) + { + if (HIWORD(wParam) == LBN_SELCHANGE) + { + int r = SendMessage(m_curlistbox_hwnd, LB_GETSELCOUNT, 0, 0) > 0; + EnableWindow(GetDlgItem(hwndDlg, IDC_BUTTON3), r); + EnableWindow(GetDlgItem(hwndDlg, IDC_BUTTON4), r); + EnableWindow(GetDlgItem(hwndDlg, IDC_BUTTON5), r); + } + return 0; + } + case IDC_BUTTON3: + //remove column + { + for (int i = 0;i < SendMessage(m_curlistbox_hwnd, LB_GETCOUNT, 0, 0);i++) + { + if (SendMessage(m_curlistbox_hwnd, LB_GETSEL, i, 0)) + { + int c = edit_columnOrder[i]; + for (int j = i;edit_columnOrder[j] != -1;j++) + { + edit_columnOrder[j] = edit_columnOrder[j + 1]; + } + SendMessage(m_curlistbox_hwnd, LB_DELETESTRING, i, 0); + i--; + + int r = SendMessageW(m_availlistbox_hwnd, LB_ADDSTRING, 0, (LPARAM)WASABI_API_LNGSTRINGW(columnList[c].column_id)); + SendMessageW(m_availlistbox_hwnd, LB_SETITEMDATA, r, c); + } + } + EnableWindow(GetDlgItem(hwndDlg, IDC_BUTTON3), 0); + EnableWindow(GetDlgItem(hwndDlg, IDC_BUTTON4), 0); + EnableWindow(GetDlgItem(hwndDlg, IDC_BUTTON5), 0); + } + break; + case IDC_BUTTON4: + //move column up + { + for (int i = 0;i < (INT)SendMessage(m_curlistbox_hwnd, LB_GETCOUNT, 0, 0);i++) + { + if (i != 0 && (INT)SendMessage(m_curlistbox_hwnd, LB_GETSEL, i, 0)) + { + BYTE c = edit_columnOrder[i - 1]; + edit_columnOrder[i - 1] = edit_columnOrder[i]; + edit_columnOrder[i] = c; + + SendMessage(m_curlistbox_hwnd, LB_DELETESTRING, i - 1, 0); + int r = (INT)SendMessageW(m_curlistbox_hwnd, LB_INSERTSTRING, i, (LPARAM)WASABI_API_LNGSTRINGW(columnList[c].column_id)); + SendMessage(m_curlistbox_hwnd, LB_SETITEMDATA, r, c); + } + } + } + break; + case IDC_BUTTON5: + //move column down + { + int l = SendMessage(m_curlistbox_hwnd, LB_GETCOUNT, 0, 0); + for (int i = l - 2;i >= 0;i--) + { + if (SendMessage(m_curlistbox_hwnd, LB_GETSEL, i, 0)) + { + BYTE c = edit_columnOrder[i + 1]; + edit_columnOrder[i + 1] = edit_columnOrder[i]; + edit_columnOrder[i] = c; + + SendMessage(m_curlistbox_hwnd, LB_DELETESTRING, i + 1, 0); + int r = (INT)SendMessageW(m_curlistbox_hwnd, LB_INSERTSTRING, i, (LPARAM)WASABI_API_LNGSTRINGW(columnList[c].column_id)); + SendMessage(m_curlistbox_hwnd, LB_SETITEMDATA, r, c); + } + } + } + break; + case IDOK: + { + HWND hwndList = resultlist.getwnd(); + memcpy(columnOrder, edit_columnOrder, sizeof(edit_columnOrder)); + if (hwndList) + { + initColumnsHeader(hwndList); + InvalidateRect(hwndList, NULL, TRUE); + UpdateWindow(hwndList); + } + } + case IDCANCEL: + EndDialog(hwndDlg, 0); + break; + } + break; + case WM_DESTROY: + if (NULL != WASABI_API_APP) + { + if (NULL != m_curlistbox_hwnd) + WASABI_API_APP->DirectMouseWheel_EnableConvertToMouseWheel(m_curlistbox_hwnd, FALSE); + if (NULL != m_availlistbox_hwnd) + WASABI_API_APP->DirectMouseWheel_EnableConvertToMouseWheel(m_availlistbox_hwnd, FALSE); + + WASABI_API_APP->app_removeAccelerators(hwndDlg); + } + break; + } + return FALSE; +} + +void customizeColumnsDialog(HWND hwndParent) +{ + WASABI_API_DIALOGBOXW(IDD_CUSTCOLUMNS, hwndParent, custColumns_dialogProc); + EatKeyboard(); +} + +bool isMixable(itemRecordW &song) +{ + if (!song.filename) return false; + + AutoChar charFn(song.filename); + pluginMessage p = {ML_MSG_PDXS_STATUS, (INT_PTR)(char *)charFn, 0, 0}; + char *text = (char *)SendMessage(plugin.hwndLibraryParent, WM_ML_IPC, (WPARAM) & p, ML_IPC_SEND_PLUGIN_MESSAGE); + // Analyzed/Identified = mixable + return text && (text[0] == 'A' || text[0] == 'I'); +} + +void AccessingGracenoteHack(int p) +{ + if (p == 0) + { + GetDlgItemTextW(m_hwnd, IDC_MEDIASTATUS, oldText, 4096); + SetDlgItemTextW(m_hwnd, IDC_MEDIASTATUS, L"Accessing Gracenote Database"); + } + else + { + SetDlgItemTextW(m_hwnd, IDC_MEDIASTATUS, oldText); + } +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/view_miniinfo.cpp b/Src/Plugins/Library/ml_local/view_miniinfo.cpp new file mode 100644 index 00000000..997efe63 --- /dev/null +++ b/Src/Plugins/Library/ml_local/view_miniinfo.cpp @@ -0,0 +1,201 @@ +#include "main.h" +#include "api__ml_local.h" +#include "..\..\General\gen_ml/config.h" +#include "resource.h" + +#include "..\..\General\gen_ml/ml_ipc_0313.h" + +static int g_displayinfo = TRUE, g_displayinfochanged=FALSE; + +static HWND m_media_hwnd = NULL; +static HWND m_info_hwnd = NULL; + +static HRGN g_rgnUpdate = NULL; +static int offsetX = 0, offsetY = 0; + +#define IDC_WEBINFO 0x1000 + +static void LayoutWindows(HWND hwnd, BOOL fShowInfo, BOOL fRedraw) +{ + RECT rc, ri, rg; + HRGN rgn = NULL; + + GetClientRect(hwnd, &rc); + SetRect(&rg, 0, 0, 0, 0); + + if (rc.bottom - rc.top < WASABI_API_APP->getScaleY(180)) fShowInfo = FALSE; + if (rc.bottom <= rc.top || rc.right <= rc.left) return; + + if (fShowInfo) + { + if (!IsWindow(m_info_hwnd)) // create browser + { + WEBINFOCREATE wic = {0}; + wic.hwndParent = hwnd; + wic.uMsgQuery = WM_QUERYFILEINFO; + wic.x = rc.left; + wic.y = rc.bottom - WASABI_API_APP->getScaleY(101); + wic.cx = (rc.right - rc.left) - WASABI_API_APP->getScaleX(3); + wic.cy = WASABI_API_APP->getScaleY(100); + wic.ctrlId = IDC_WEBINFO; + + m_info_hwnd = (HWND)SENDMLIPC(plugin.hwndLibraryParent, ML_IPC_CREATEWEBINFO, (WPARAM)&wic); + if (IsWindow(m_info_hwnd)) + { + SetWindowPos(m_info_hwnd, HWND_BOTTOM, 0, 0, 0, 0, + SWP_NOZORDER | SWP_NOMOVE | SWP_NOSIZE | SWP_NOREDRAW | SWP_NOCOPYBITS); + ShowWindow(m_info_hwnd, SW_SHOWNORMAL); + } + } + else + { + SetWindowPos(m_info_hwnd, NULL, rc.left, rc.bottom - WASABI_API_APP->getScaleY(101), + rc.right - WASABI_API_APP->getScaleX(3), WASABI_API_APP->getScaleY(100), + SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOCOPYBITS | SWP_NOREDRAW); + } + + if (IsWindow(m_info_hwnd)) + { + rc.bottom -= WASABI_API_APP->getScaleY(104); + SetRect(&rg, rc.left, rc.bottom - WASABI_API_APP->getScaleY(101), + rc.right - WASABI_API_APP->getScaleX(10), + rc.bottom - WASABI_API_APP->getScaleY(1)); + } + } + + InvalidateRect(hwnd, NULL, TRUE); + + if (IsWindow(m_media_hwnd)) + { + SetRect(&ri, rc.left, rc.top, rc.right, rc.bottom); + rgn = CreateRectRgn(0, 0, ri.right - ri.left, ri.bottom - ri.top); + SendMessage(m_media_hwnd, WM_USER + 0x201, MAKEWPARAM(offsetX, offsetY), (LPARAM)rgn); + SetWindowPos(m_media_hwnd, NULL, ri.left, ri.top, ri.right - ri.left, ri.bottom - ri.top, + SWP_NOZORDER | SWP_NOCOPYBITS | SWP_NOACTIVATE | ((!fRedraw) ? SWP_NOREDRAW : 0)); + SendMessage(m_media_hwnd, WM_USER + 0x201, 0, 0L); + if (IsWindowVisible(m_media_hwnd)) + { + ValidateRect(hwnd, &ri); + if (GetUpdateRect(m_media_hwnd, NULL, FALSE)) + { + GetUpdateRgn(m_media_hwnd, rgn, FALSE); + OffsetRgn(rgn, ri.left, ri.top); + InvalidateRgn(hwnd, rgn, FALSE); + } + } + } + + if (fRedraw) + { + UpdateWindow(hwnd); + if (IsWindow(m_media_hwnd)) UpdateWindow(m_media_hwnd); + } + if (g_rgnUpdate) + { + GetUpdateRgn(hwnd, g_rgnUpdate, FALSE); + if (rgn) + { + OffsetRgn(rgn, rc.left, rc.top); + CombineRgn(g_rgnUpdate, g_rgnUpdate, rgn, RGN_OR); + } + } + ValidateRgn(hwnd, NULL); + if (rgn) DeleteObject(rgn); +} + +INT_PTR CALLBACK view_miniinfoDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam) +{ + BOOL a=dialogSkinner.Handle(hwndDlg,uMsg,wParam,lParam); if (a) return a; + + switch(uMsg) + { + case WM_DISPLAYCHANGE: + if (IsWindow(m_media_hwnd)) PostMessageW(m_media_hwnd, WM_DISPLAYCHANGE, wParam, lParam); + if (IsWindow(m_info_hwnd)) PostMessageW(m_info_hwnd, WM_DISPLAYCHANGE, wParam, lParam); + break; + + case WM_INITDIALOG: + { + g_displayinfo = g_view_metaconf->ReadInt(L"midivvis", 1); + g_displayinfochanged = FALSE; + m_media_hwnd = (lParam) ? WASABI_API_CREATEDIALOGW(((INT_PTR*)lParam)[1], hwndDlg, (DLGPROC)((INT_PTR*)lParam)[0]) : NULL; + SetWindowPos(m_media_hwnd, NULL, 0,0,0,0, SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOMOVE | SWP_NOSIZE | SWP_NOREDRAW | SWP_SHOWWINDOW); + + MLSKINWINDOW m = {0}; + m.skinType = SKINNEDWND_TYPE_DIALOG; + m.hwndToSkin = hwndDlg; + m.style = SWS_USESKINFONT | SWS_USESKINCOLORS | SWS_USESKINCURSORS; + MLSkinWindow(plugin.hwndLibraryParent, &m); + } + return TRUE; + + case WM_WINDOWPOSCHANGED: + if ((SWP_NOSIZE | SWP_NOMOVE) != ((SWP_NOSIZE | SWP_NOMOVE) & ((WINDOWPOS*)lParam)->flags) || + (SWP_FRAMECHANGED & ((WINDOWPOS*)lParam)->flags)) + { + LayoutWindows(hwndDlg, g_displayinfo, !(SWP_NOREDRAW & ((WINDOWPOS*)lParam)->flags)); + } + return 0; + + case WM_APP+1: //sent by parent for resizing window + if (IsWindow(m_media_hwnd)) return SendMessage(m_media_hwnd,uMsg,wParam,lParam); // forward on + return 0; + + case WM_APP+2: //sent by media child to get current query + return SendMessage(GetParent(hwndDlg),uMsg,wParam,lParam); // forward on + + case WM_QUERYFILEINFO: if(IsWindow(m_media_hwnd)) PostMessageW(m_media_hwnd, uMsg, wParam, lParam); break; + + case WM_SHOWFILEINFO: + if (IsWindow(m_info_hwnd)) + { + WEBINFOSHOW wis = {0}; + wis.pszFileName = (LPCWSTR)lParam; + wis.fFlags = (TRUE == wParam) ? WISF_FORCE : WISF_NORMAL; + SENDMLIPC(m_info_hwnd, ML_IPC_WEBINFO_SHOWINFO, (WPARAM)&wis); + } + case WM_USER+66: + if (wParam == -1) + { + g_displayinfo = !g_displayinfo; + g_displayinfochanged = !g_displayinfochanged; + if (IsWindow(m_info_hwnd)) ShowWindow(m_info_hwnd, (g_displayinfo) ? SW_SHOWNA : SW_HIDE); + LayoutWindows(hwndDlg, g_displayinfo, TRUE); + } + SetWindowLongPtr(hwndDlg,DWLP_MSGRESULT, (g_displayinfo) ? 0xff : 0xf0); + return TRUE; + + case WM_USER + 0x200: + SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, 1); // yes, we support no - redraw resize + return TRUE; + + case WM_USER + 0x201: + offsetX = (short)LOWORD(wParam); + offsetY = (short)HIWORD(wParam); + g_rgnUpdate = (HRGN)lParam; + return TRUE; + + case WM_PAINT: + { + if (GetDlgItem(hwndDlg, IDC_WEBINFO)) + { + static int tab[] = { IDC_WEBINFO | DCW_SUNKENBORDER }; + dialogSkinner.Draw(hwndDlg, tab, sizeof(tab) / sizeof(tab[0])); + } + else + dialogSkinner.Draw(hwndDlg, 0, 0); + } + return 0; + + case WM_ERASEBKGND: + return 1; //handled by WADlg_DrawChildWindowBorders in WM_PAINT + + case WM_DESTROY: + if(g_displayinfochanged) g_view_metaconf->WriteInt(L"midivvis", g_displayinfo); + if (IsWindow(m_info_hwnd)) SENDMLIPC(m_info_hwnd, ML_IPC_WEBINFO_RELEASE, 0); + m_media_hwnd = NULL; + m_info_hwnd = NULL; + break; + } + return FALSE; +}
\ No newline at end of file diff --git a/Src/Plugins/Library/ml_local/wa_subclass.cpp b/Src/Plugins/Library/ml_local/wa_subclass.cpp new file mode 100644 index 00000000..f5f20a08 --- /dev/null +++ b/Src/Plugins/Library/ml_local/wa_subclass.cpp @@ -0,0 +1,314 @@ +#include "main.h" +#include "api__ml_local.h" +#include "resource.h" +#include "../nu/listview.h" + +#define WINAMP_FILE_ADDTOLIBRARY 40344 +#define WINAMP_FILE_ADDCURRENTPLEDIT 40466 +#define WINAMP_SHOWLIBRARY 40379 +wchar_t *recent_fn = 0; +static HMENU last_viewmenu = 0; +WORD waMenuID = 0; + +extern W_ListView resultlist; +extern volatile int no_lv_update; +void UpdateLocalResultsCache(const wchar_t *filename); + +static void onPlayFileTrack() +{ + int autoaddplays = g_config->ReadInt(L"autoaddplays", 0); + int trackplays = g_config->ReadInt(L"trackplays", 1); + if (!trackplays && !autoaddplays) + return ; + + if (g_table && recent_fn) + { + wchar_t filename2[MAX_PATH] = {0}; // full lfn path if set + EnterCriticalSection(&g_db_cs); + + nde_scanner_t s = NDE_Table_CreateScanner(g_table); + int found=FindFileInDatabase(s, MAINTABLE_ID_FILENAME, recent_fn, filename2); + + if (found) // if it's in the table already + { + if (trackplays) // if we're tracking plays + { + NDE_Scanner_Edit(s); + nde_field_t f = NDE_Scanner_GetFieldByID(s, MAINTABLE_ID_PLAYCOUNT); + int cnt = f ? NDE_IntegerField_GetValue(f) : 0; + time_t t = time(NULL); + + db_setFieldInt(s, MAINTABLE_ID_PLAYCOUNT, ++cnt); + db_setFieldInt(s, MAINTABLE_ID_LASTPLAY, (int)t); + if (asked_for_playcount) + PostMessage(plugin.hwndWinampParent, WM_WA_IPC, 0, IPC_UPDTITLE); + + // Issue a wasabi system callback after we have successfully added a file in the ml database + api_mldb::played_info info = {t, cnt}; + WASABI_API_SYSCB->syscb_issueCallback(api_mldb::SYSCALLBACK, api_mldb::MLDB_FILE_PLAYED, (size_t)recent_fn, (size_t)&info); + + NDE_Scanner_Post(s); + // disabled in 5.65 (was added in 5.64?) as causing + // noticeable ui lockups on sync with large library + // so instead we'll risk it and flush on 50 instead + /*g_table_dirty = 0; + NDE_Table_Sync(g_table);*/ + } + NDE_Table_DestroyScanner(g_table, s); + } + else // not found in main table, we are in the main table, time to add if set + { + NDE_Table_DestroyScanner(g_table, s); + + if (autoaddplays) + { + int guess = -1, meta = -1, rec = 1; + autoscan_add_directory(recent_fn, &guess, &meta, &rec, 1); // use this folder's guess/meta options + if (guess == -1) guess = g_config->ReadInt(L"guessmode", 0); + if (meta == -1) meta = g_config->ReadInt(L"usemetadata", 1); + addFileToDb(recent_fn, 0, meta, guess, 1, (int)time(NULL)); + } + } + + if (g_table_dirty > 50) + { + g_table_dirty = 0; + NDE_Table_Sync(g_table); + } + + LeaveCriticalSection(&g_db_cs); + } +} + +void onStartPlayFileTrack(const wchar_t *filename, bool resume) +{ + if (!(wcsstr(filename, L"://") && _wcsnicmp(filename, L"cda://", 6) && _wcsnicmp(filename, L"file://", 7))) + { + int timer = -1, timer1 = -1, timer2 = -1; + + KillTimer(plugin.hwndWinampParent, 8081); + if (!resume) + { + free(recent_fn); + recent_fn = _wcsdup(filename); + } + + // wait for x seconds + if(g_config->ReadInt(L"trackplays_wait_secs",0)) + { + timer1 = g_config->ReadInt(L"trackplays_wait_secs_lim",5)*1000; + } + + // wait for x percent of the song (approx to a second) + if(g_config->ReadInt(L"trackplays_wait_percent",0)) + { + basicFileInfoStructW bfiW = {0}; + bfiW.filename = recent_fn; + SendMessage(plugin.hwndWinampParent, WM_WA_IPC, (WPARAM)&bfiW, IPC_GET_BASIC_FILE_INFOW); + if(bfiW.length > 0) + { + bfiW.length=bfiW.length*1000; + timer2 = (bfiW.length*g_config->ReadInt(L"trackplays_wait_percent_lim",50))/100; + } + } + + // decide on which playback option will be the prefered duration (smallest wins) + if(timer1 != -1 && timer2 != -1) + { + if(timer1 > timer2) + { + timer = timer2; + } + if(timer2 > timer1) + { + timer = timer1; + } + } + else if(timer1 == -1 && timer2 != -1) + { + timer = timer2; + } + else if(timer2 == -1 && timer1 != -1) + { + timer = timer1; + } + + // if no match or something went wrong then try to ensure the default timer value is used + SetTimer(plugin.hwndWinampParent, 8081, ((timer > 0)? timer : 350), NULL); + } +} + +static void FileUpdated(const wchar_t *filename) +{ + if (g_table) + { + EnterCriticalSection(&g_db_cs); + int guess = -1, meta = -1, rec = 1; + autoscan_add_directory(filename, &guess, &meta, &rec, 1); // use this folder's guess/meta options + if (guess == -1) guess = g_config->ReadInt(L"guessmode", 0); + if (meta == -1) meta = g_config->ReadInt(L"usemetadata", 1); + addFileToDb(filename, TRUE, meta, guess, 0, 0, true); + LeaveCriticalSection(&g_db_cs); + + if (g_table_dirty > 10) + { + g_table_dirty = 0; + EnterCriticalSection(&g_db_cs); + NDE_Table_Sync(g_table); + LeaveCriticalSection(&g_db_cs); + } + + if (!no_lv_update) + UpdateLocalResultsCache(filename); + } + ClearCache(filename); + ClearTitleHookCache(); +} + +LRESULT APIENTRY wa_newWndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + switch (uMsg) + { + case WM_TIMER: + if (recent_fn && wParam == 8081) + { + if (SendMessage(hwndDlg, WM_WA_IPC, 0, IPC_GETOUTPUTTIME) > 350) + { + KillTimer(hwndDlg, 8081); + if (SendMessage(hwndDlg, WM_WA_IPC, 0, IPC_ISPLAYING) == 1) + { + onPlayFileTrack(); + } + free(recent_fn); + recent_fn = 0; + } + } + break; + case WM_WA_IPC: + switch (lParam) + { + case IPC_CB_MISC: + if (wParam == IPC_CB_MISC_TITLE) + { + if(!SendMessage(hwndDlg, WM_WA_IPC, 0, IPC_ISPLAYING)) + { + KillTimer(hwndDlg, 8081); + } + } + else if (wParam == IPC_CB_MISC_PAUSE) + { + KillTimer(hwndDlg, 8081); + } + else if (wParam == IPC_CB_MISC_UNPAUSE) + { + if (recent_fn) onStartPlayFileTrack(recent_fn, true); + } + break; + case IPC_FILE_TAG_MAY_HAVE_UPDATEDW: + { + wchar_t *filename = (wchar_t *)wParam; + if (filename) + FileUpdated(filename); + } + break; + case IPC_FILE_TAG_MAY_HAVE_UPDATED: + { + char *filename = (char *)wParam; + if (filename) + FileUpdated(AutoWide(filename)); + } + break; + case IPC_STOPPLAYING: + { + KillTimer(hwndDlg, 8081); + free(recent_fn); + recent_fn = 0; + } + break; + case IPC_GET_EXTENDED_FILE_INFO_HOOKABLE: + // guessing for metadata for when the library isn't open yet. + if (!g_table && wParam && !m_calling_getfileinfo) return doGuessProc(hwndDlg, uMsg, wParam, lParam); + break; + default: + { + if (lParam == IPC_CLOUD_ENABLED) + { + if (m_curview_hwnd) SendMessage(m_curview_hwnd, WM_APP + 6, 0, 0); //update current view + } + } + break; + } + break; + case WM_INITMENUPOPUP: + { + HMENU hmenuPopup = (HMENU) wParam; + if (hmenuPopup == wa_play_menu) + { + if (last_viewmenu) + { + RemoveMenu(wa_play_menu, waMenuID, MF_BYCOMMAND); + DestroyMenu(last_viewmenu); + last_viewmenu = NULL; + } + + mlGetTreeStruct mgts = { 1000, 55000, -1}; + last_viewmenu = (HMENU)SendMessage(plugin.hwndLibraryParent, WM_ML_IPC, (WPARAM) & mgts, ML_IPC_GETTREE); + if (last_viewmenu) + { + if (GetMenuItemCount(last_viewmenu) > 0) + { + int count = GetMenuItemCount(wa_play_menu); + MENUITEMINFOW menuItem = {sizeof(MENUITEMINFOW), MIIM_SUBMENU | MIIM_ID | MIIM_TYPE, MFT_STRING, MFS_ENABLED, waMenuID, + last_viewmenu, NULL, NULL, NULL, WASABI_API_LNGSTRINGW(IDS_MEDIA_LIBRARY_VIEW_RESULTS), 0}; + InsertMenuItemW(wa_play_menu, count, TRUE, &menuItem); + } + else + { + DestroyMenu(last_viewmenu); + last_viewmenu = 0; + } + } + } + } + break; + case WM_COMMAND: + case WM_SYSCOMMAND: + WORD lowP = LOWORD(wParam); + if (lowP == WINAMP_FILE_ADDTOLIBRARY) + { + if (!plugin.hwndLibraryParent || !IsWindowVisible(plugin.hwndLibraryParent)) + { + SendMessage(plugin.hwndWinampParent, WM_COMMAND, MAKEWPARAM(WINAMP_SHOWLIBRARY, 0), 0L); + } + add_to_library(plugin.hwndLibraryParent); + } + else if (lowP == WINAMP_FILE_ADDCURRENTPLEDIT) + { + add_pledit_to_library(); + } + else if (uMsg == WM_COMMAND && wParam > 45000 && wParam < 55000) + { + int n = wParam - 45000; + if (m_query_list[n]) + { + mediaLibrary.SwitchToPluginView(n); + return 0; + } + } + else if (uMsg == WM_COMMAND && wParam > 55000 && wParam < 65000) + { + int n = wParam - 55000; + if (m_query_list[n]) + { + queryItem *item = m_query_list[n]; + wchar_t configDir[MAX_PATH] = {0}; + PathCombineW(configDir, g_viewsDir, item->metafn); + C_Config viewconf(configDir); + main_playQuery(&viewconf, item->query, 0, 1); + return 0; + } + } + break; + } + return CallWindowProcW(wa_oldWndProc, hwndDlg, uMsg, wParam, lParam); +}
\ No newline at end of file |
