diff options
Diffstat (limited to 'Src/Plugins/General/gen_ml/IPC.cpp')
| -rw-r--r-- | Src/Plugins/General/gen_ml/IPC.cpp | 1588 |
1 files changed, 1588 insertions, 0 deletions
diff --git a/Src/Plugins/General/gen_ml/IPC.cpp b/Src/Plugins/General/gen_ml/IPC.cpp new file mode 100644 index 00000000..cc85ad2c --- /dev/null +++ b/Src/Plugins/General/gen_ml/IPC.cpp @@ -0,0 +1,1588 @@ +#include "main.h" +#include <time.h> +#include <winuser.h> +#include <assert.h> +#include "./ml.h" +#include "../winamp/wa_ipc.h" +#include "../winamp/ipc_pe.h" +#include "./resource.h" +#include "./comboskin.h" +#include "./childwnd.h" +#include "./sendto.h" +#include "./navigation.h" +#include "../nu/AutoWide.h" +#include "../nu/ns_wc.h" +#include "api__gen_ml.h" + +#include "./ml_ipc_0313.h" +#include "./ml_imageloader.h" +#include "./ml_imagefilter.h" +#include "./ml_imagelist.h" +#include "./ml_rating.h" +#include "./ml_ratingcolumn.h" +#include "./ml_cloud.h" +#include "./ml_cloudcolumn.h" +#include "./skinning.h" +#include "./fileview.h" + + +extern HWND m_curview_hwnd; +extern "C" HWND g_ownerwnd; +int queryEditOther(HWND hwnd, char *query, char *viewname, int mode); + +extern C_ItemList m_plugins; +extern HNAVCTRL hNavigation; +extern HMLIMGFLTRMNGR hmlifMngr; +extern HMLIMGLST hmlilRating; +extern HMLIMGLST hmlilCloud; + +static wchar_t playBuf[64], enqueueBuf[64]; + +#define WEBINFO_PREFFERED_HEIGHT 100 + +#define MAX_MENU_DEPTH 10 + +typedef struct _NAVMENUBUILDER +{ + HMENU hMenu[MAX_MENU_DEPTH]; + HNAVITEM hParent[MAX_MENU_DEPTH]; + INT level; + NAVITEM_I nis; + INT maxNum; + INT offset; + INT counter; +} NAVMENUBUILDER; + +static INT GetNavImageIndexFromTag(HMLIMGLST hmlil, INT_PTR tag) +{ + if (!hmlil) return -1; + + switch(tag) + { + case MLTREEIMAGE_NONE: + case MLTREEIMAGE_DEFAULT: + case MLTREEIMAGE_BRANCH: + return -1; + case MLTREEIMAGE_BRANCH_EXPANDED: + case MLTREEIMAGE_BRANCH_COLLAPSED: + case MLTREEIMAGE_BRANCH_NOCHILD: + break; + } + return MLImageListI_GetIndexFromTag(hmlil, tag); +} + +static BOOL CALLBACK EnumerateNavItemsCB(HNAVITEM hItem, LPARAM lParam) +{ + NAVMENUBUILDER *pnmb; + HNAVITEM hParent; + if (!lParam || !hItem) return FALSE; + + pnmb = (NAVMENUBUILDER*)lParam; + pnmb->counter++; + if (pnmb->maxNum > 0 && pnmb->counter == pnmb->maxNum) return FALSE; + if (!NavItemI_GetIndirect(hItem, &pnmb->nis)) return FALSE; + if (pnmb->nis.pszText) FixAmpsW(pnmb->nis.pszText, pnmb->nis.cchTextMax); + + hParent = NavItemI_GetParent(hItem); + while (hParent != pnmb->hParent[pnmb->level]) + { + pnmb->level--; + if (pnmb->level < 0) return FALSE; + } + + if (NIS_HASCHILDREN_I & pnmb->nis.style) + { + pnmb->level++; + if (pnmb->level == MAX_MENU_DEPTH) return FALSE; + + pnmb->hMenu[pnmb->level] = CreatePopupMenu(); + pnmb->hParent[pnmb->level] = hItem; + + // this will add a separator into the parent menu if we have a more than 1 child menu (ml_pmp can do this) + if(pnmb->level > 1 && GetMenuItemCount(pnmb->hMenu[pnmb->level-1]) == 1) AppendMenuW(pnmb->hMenu[pnmb->level-1], MF_SEPARATOR, 0, 0); + AppendMenuW(pnmb->hMenu[pnmb->level-1], MF_ENABLED | MF_STRING | MF_POPUP, (UINT_PTR)pnmb->hMenu[pnmb->level], pnmb->nis.pszText); + AppendMenuW(pnmb->hMenu[pnmb->level], MF_ENABLED | MF_STRING, pnmb->nis.id + pnmb->offset, pnmb->nis.pszText); + } + else + { + // if we've got a 'root' item for the current level then add a separator + if(pnmb->level && GetMenuItemCount(pnmb->hMenu[pnmb->level]) == 1) AppendMenuW(pnmb->hMenu[pnmb->level], MF_SEPARATOR, 0, 0); + AppendMenuW(pnmb->hMenu[pnmb->level], MF_ENABLED | MF_STRING, pnmb->nis.id + pnmb->offset, pnmb->nis.pszText); + } + + return TRUE; +} + +static INT_PTR getPlRating(HWND hwndML, INT_PTR plindex) +{ + const wchar_t *filename = (const wchar_t *)SendMessage(plugin.hwndParent, WM_WA_IPC, plindex, IPC_GETPLAYLISTFILEW); + if (!filename) return 0; + return SendMessage(hwndML, WM_ML_IPC, (WPARAM)filename, ML_IPC_GET_FILE_RATINGW); +} + +static INT_PTR SetPlRating(HWND hwndML, int plindex, int rating) +{ + const wchar_t *filename = (const wchar_t *)SendMessage(plugin.hwndParent, WM_WA_IPC, plindex, IPC_GETPLAYLISTFILEW); + if (!filename) return 0; + file_set_ratingW data; + data.fileName = filename; + data.newRating = rating; + return (INT_PTR)SendMessage(hwndML, WM_ML_IPC, (WPARAM)&data, ML_IPC_SET_FILE_RATINGW); +} + +INT_PTR IPC_PL_SetRating(HWND hwndML, INT_PTR param) +{ + pl_set_rating *psr = (pl_set_rating *)param; + if (psr) return SetPlRating(hwndML, psr->plentry, psr->rating); + return 0; +} + +static INT_PTR IPC_InsertView(UINT msg, INT_PTR param) +{ + INT insertAfterId = 0, parentId = 0; + BOOL converted = FALSE; + HNAVITEM hItem = 0, hParentItem = 0, hInsertAfter = 0; + NAVITEM_I nis = {0}; + + switch(msg) + { + case ML_IPC_TREEITEM_ADD: + case ML_IPC_TREEITEM_INSERT: + if (((MLTREEITEM*)param)->title) + { + nis.pszText = AutoWideDup(((MLTREEITEM*)param)->title); + converted = TRUE; + } + case ML_IPC_TREEITEM_INSERTW: + case ML_IPC_TREEITEM_ADDW: + if (ML_IPC_TREEITEM_ADD == msg || ML_IPC_TREEITEM_ADDW == msg) + nis.id = (INT)((MLTREEITEMW*)param)->id; + else + insertAfterId= (INT)((MLTREEITEMW*)param)->id; + + if (!converted) + nis.pszText = ((MLTREEITEMW*)param)->title; + + parentId = (INT)((MLTREEITEMW*)param)->parentId; + nis.style |= (((MLTREEITEMW*)param)->hasChildren) ? NIS_HASCHILDREN_I : 0; + nis.iImage = ((MLTREEITEMW*)param)->imageIndex; + break; + case ML_IPC_ADDTREEITEM_EX: + nis.iImage = ((mlAddTreeItemStructEx*)param)->imageIndex; + case ML_IPC_ADDTREEITEM: + if (((mlAddTreeItemStruct*)param)->title) + { + nis.pszText = AutoWideDup(((mlAddTreeItemStruct*)param)->title); + converted = TRUE; + } + parentId= (INT)((mlAddTreeItemStruct*)param)->parent_id; + nis.style |= (((mlAddTreeItemStruct*)param)->has_children) ? NIS_HASCHILDREN_I : 0; + break; + } + + nis.iImage = GetNavImageIndexFromTag(NavCtrlI_GetImageList(hNavigation), nis.iImage); + nis.iSelectedImage = nis.iImage; + nis.styleMask |= NIS_HASCHILDREN_I; + + if (nis.id) nis.mask |= NIMF_ITEMID_I; + if (nis.iImage) nis.mask |= NIMF_IMAGE_I; + if (nis.iSelectedImage) nis.mask |= NIMF_IMAGESEL_I; + if (nis.style) nis.mask |= NIMF_STYLE_I; + if (nis.pszText) nis.mask |= NIMF_TEXT_I; + if (nis.state) nis.mask |= NIMF_STATE_I; + + hInsertAfter = NavCtrlI_FindItem(hNavigation, insertAfterId); + hParentItem = NavCtrlI_FindItem(hNavigation, parentId); + + hItem = NavCtrlI_InsertItem(hNavigation, hInsertAfter, hParentItem, &nis); + + if (converted && nis.pszText) free(nis.pszText); + if (hItem) + { + if (ML_IPC_ADDTREEITEM ==msg || ML_IPC_ADDTREEITEM_EX == msg) + ((mlAddTreeItemStruct*)param)->this_id = NavItemI_GetId(hItem); + else + ((MLTREEITEMW*)param)->id = NavItemI_GetId(hItem); + } + + return (INT_PTR)hItem; +} + +static BOOL IPC_SetView(int msg, INT_PTR param) +{ + HNAVITEM hItem; + switch(msg) + { + case ML_IPC_SETTREEITEM: + case ML_IPC_SETTREEITEM_EX: + hItem = NavCtrlI_FindItem(hNavigation, (INT)((mlAddTreeItemStruct*)param)->this_id); + if (!hItem) return FALSE; + if (!NavItemI_SetText(hItem, AutoWide(((mlAddTreeItemStruct*)param)->title)) || + !NavItemI_SetStyle(hItem, (((mlAddTreeItemStruct*)param)->has_children) ? NIS_HASCHILDREN_I : 0, NIS_HASCHILDREN_I)) + return FALSE; + if (ML_IPC_SETTREEITEM_EX == msg) + { + INT mlilIndex = GetNavImageIndexFromTag(NavCtrlI_GetImageList(hNavigation), ((mlAddTreeItemStructEx*)param)->imageIndex); + if (!NavItemI_SetImageIndex(hItem, mlilIndex, IMAGE_NORMAL_I) || !NavItemI_SetImageIndex(hItem, mlilIndex, IMAGE_SELECTED_I)) return FALSE; + } + return TRUE; + case ML_IPC_TREEITEM_SETINFO: + case ML_IPC_TREEITEM_SETINFOW: + hItem = (((MLTREEITEMINFO*)param)->handle) ? + (HNAVITEM)((MLTREEITEMINFO*)param)->handle : + NavCtrlI_FindItem(hNavigation, (INT)((MLTREEITEMINFO*)param)->item.id); + if (!hItem) return FALSE; + if (MLTI_TEXT & ((MLTREEITEMINFO*)param)->mask) + { + if (!NavItemI_SetText(hItem, (ML_IPC_TREEITEM_SETINFOW == msg) ? ((MLTREEITEMINFOW*)param)->item.title : + AutoWide(((MLTREEITEMINFO*)param)->item.title))) return FALSE; + } + if (MLTI_ID & ((MLTREEITEMINFO*)param)->mask && + ! NavItemI_SetId(hItem, (INT)((MLTREEITEMINFO*)param)->item.id)) return FALSE; + if (MLTI_CHILDREN & ((MLTREEITEMINFO*)param)->mask && + !NavItemI_SetStyle(hItem, (((MLTREEITEMINFO*)param)->item.hasChildren) ? NIS_HASCHILDREN_I : 0, NIS_HASCHILDREN_I)) return FALSE; + if (MLTI_IMAGE & ((MLTREEITEMINFO*)param)->mask) + { + INT mlilIndex = GetNavImageIndexFromTag(NavCtrlI_GetImageList(hNavigation), ((MLTREEITEMINFO*)param)->item.imageIndex); + if (!NavItemI_SetImageIndex(hItem, mlilIndex, IMAGE_NORMAL_I) || !NavItemI_SetImageIndex(hItem, mlilIndex, IMAGE_SELECTED_I)) return FALSE; + } + } + return FALSE; +} + +static BOOL IPC_GetView(INT msg, INT_PTR param) +{ + HNAVITEM hItem; + + hItem = (((MLTREEITEMINFO*)param)->handle) ? + (HNAVITEM)((MLTREEITEMINFO*)param)->handle : + NavCtrlI_FindItem(hNavigation, (INT)((MLTREEITEMINFO*)param)->item.id); + if (!hItem) return FALSE; + + if (MLTI_ID & ((MLTREEITEMINFO*)param)->mask) ((MLTREEITEMINFO*)param)->item.id = NavItemI_GetId(hItem); + if (MLTI_CHILDREN & ((MLTREEITEMINFO*)param)->mask) ((MLTREEITEMINFO*)param)->item.hasChildren = NavItemI_HasChildren(hItem); + /// TODO: index <--> tag + if (MLTI_IMAGE & ((MLTREEITEMINFO*)param)->mask) + { + INT_PTR tag; + + ((MLTREEITEMINFO*)param)->item.id = (MLImageListI_GetTagFromIndex(NavCtrlI_GetImageList(hNavigation), + NavItemI_GetImageIndex(hItem, IMAGE_NORMAL_I), + &tag)) ? (INT)tag : -1; + } + if (MLTI_TEXT & ((MLTREEITEMINFO*)param)->mask) + { + if (ML_IPC_TREEITEM_GETINFO == msg) + { + wchar_t buffer[4096] = {0}; + if (!NavItemI_GetText(hItem, buffer, 4096)) return FALSE; + if (!WideCharToMultiByte(CP_ACP, 0, buffer, -1, + ((MLTREEITEMINFO*)param)->item.title, + (INT)((MLTREEITEMINFO*)param)->item.titleLen, NULL, NULL)) return FALSE; + } + else + { + if (!NavItemI_GetText(hItem, ((MLTREEITEMINFOW*)param)->item.title, (INT)((MLTREEITEMINFOW*)param)->item.titleLen)) return FALSE; + } + } + + return TRUE; +} + +static INT_PTR IPC_SendToWinamp(INT_PTR param) +{ + mlSendToWinampStruct *p = (mlSendToWinampStruct*)param; + if (p->data) + { + int enq = p->enqueue & 1; + if (!(p->enqueue & 2) && g_config->ReadInt(L"enqueuedef", 0)) enq ^= 1; + + switch (p->type) + { + case ML_TYPE_ITEMRECORDLIST: + case ML_TYPE_CDTRACKS: + main_playItemRecordList((itemRecordList*)p->data, enq); + break; + case ML_TYPE_ITEMRECORDLISTW: + main_playItemRecordListW((itemRecordListW *)p->data, enq); + break; + case ML_TYPE_STREAMNAMES: + case ML_TYPE_FILENAMES: + { + char *list = (char*)p->data; + int cnt = 0; + if (list) while (*list) + { + if (!cnt && !enq) SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_DELETE); + cnt++; + + COPYDATASTRUCT cds; + cds.dwData = IPC_PLAYFILE; + cds.lpData = (void *) list; + cds.cbData =(INT)strlen((char *) cds.lpData) + 1; // include space for null char + SendMessage(plugin.hwndParent, WM_COPYDATA, (WPARAM)NULL, (LPARAM)&cds); + + list += strlen(list) + 1; + } + if (cnt && !enq) SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_STARTPLAY); + } + break; + case ML_TYPE_STREAMNAMESW: + case ML_TYPE_FILENAMESW: + { + wchar_t *list = (wchar_t*)p->data; + int cnt = 0; + if ( list ) + { + while ( *list ) + { + if ( !cnt && !enq ) SendMessage( plugin.hwndParent, WM_WA_IPC, 0, IPC_DELETE ); + cnt++; + + COPYDATASTRUCT cds; + cds.dwData = IPC_PLAYFILEW; + cds.lpData = (void *)list; + cds.cbData = (INT)( sizeof( wchar_t ) * wcslen( (wchar_t *)cds.lpData ) + sizeof( wchar_t ) ); // include space for null char + SendMessage( plugin.hwndParent, WM_COPYDATA, (WPARAM)NULL, (LPARAM)&cds ); + + list += wcslen( list ) + 1; + } + } + + if (cnt && !enq) + SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_STARTPLAY); + } + break; + } + } + return 0; +} + +typedef struct __DRAGTARGET +{ + HWND hwnd; + UINT state; + INT testResult; +} DRAGTARGET; + +typedef enum +{ + DRAGSTATE_NOTSUPPORTED = -2, + DRAGSTATE_UNKNOWN = -1, + DRAGSTATE_REJECTED = 0, + DRAGSTATE_ACCEPTED = 1, +} DRAGSTATE; + +static DRAGTARGET dragTarget; +static UINT WAML_NOTIFY_DRAGDROP = 0; + +static INT_PTR IPC_HandleDrag(HWND hwndML, mlDropItemStruct *pdip) +{ + if (NULL == pdip) + { + SetCursor(LoadCursor(NULL, IDC_NO)); + return 0; + } + + HWND hTarget = (NULL != pdip) ? WindowFromPoint(pdip->p) : NULL; + + if (0 == WAML_NOTIFY_DRAGDROP) + { + WAML_NOTIFY_DRAGDROP = RegisterWindowMessageW(WAMLM_DRAGDROP); + if (0 == WAML_NOTIFY_DRAGDROP) + { + if (0 == (ML_HANDLEDRAG_FLAG_NOCURSOR & pdip->flags)) + SetCursor(LoadCursor(NULL, IDC_NO)); + return 0; + } + } + + if (NULL != dragTarget.hwnd && hTarget != dragTarget.hwnd) + { + if (DRAGSTATE_NOTSUPPORTED != dragTarget.state && + DRAGSTATE_UNKNOWN != dragTarget.state) + SendMessageW(dragTarget.hwnd, WAML_NOTIFY_DRAGDROP, DRAGDROP_DRAGLEAVE, 0L); + + dragTarget.hwnd = NULL; + dragTarget.state = DRAGSTATE_UNKNOWN; + dragTarget.testResult = 0; + } + + if (NULL == dragTarget.hwnd && NULL != hTarget) + { + DWORD targetPid; + GetWindowThreadProcessId(hTarget, &targetPid); + if (GetCurrentProcessId() != targetPid) + { + if (0 == (ML_HANDLEDRAG_FLAG_NOCURSOR & pdip->flags)) + SetCursor(LoadCursor(NULL, IDC_NO)); + return 0; + } + dragTarget.hwnd = hTarget; + } + + if (NULL != dragTarget.hwnd) + { + switch(dragTarget.state) + { + case DRAGSTATE_UNKNOWN: + pdip->result = 0; + if (SendMessageW(dragTarget.hwnd, WAML_NOTIFY_DRAGDROP, DRAGDROP_DRAGENTER, (LPARAM)pdip)) + { + dragTarget.testResult = pdip->result; + dragTarget.state = (dragTarget.testResult > 0) ? DRAGSTATE_ACCEPTED : DRAGSTATE_REJECTED; + if (0 == (ML_HANDLEDRAG_FLAG_NOCURSOR & pdip->flags)) + SetCursor((dragTarget.testResult > 0) ? hDragNDropCursor : LoadCursor(NULL, IDC_NO)); + return 0; + } + else + dragTarget.state = DRAGSTATE_NOTSUPPORTED; + break; + + case DRAGSTATE_REJECTED: + pdip->result = dragTarget.testResult; + return 0; + + case DRAGSTATE_ACCEPTED: + SendMessageW(dragTarget.hwnd, WAML_NOTIFY_DRAGDROP, DRAGDROP_DRAGOVER, (LPARAM)pdip); + dragTarget.testResult = pdip->result; + if (0 == (ML_HANDLEDRAG_FLAG_NOCURSOR & pdip->flags)) + SetCursor((dragTarget.testResult > 0) ? hDragNDropCursor : LoadCursor(NULL, IDC_NO)); + return 0; + } + } + pdip->result = handleDragDropMove(hwndML, pdip->type, pdip->p, !(pdip->flags & ML_HANDLEDRAG_FLAG_NOCURSOR)) > 0 ? 1 : -1; + return 0; +} + +static INT_PTR IPC_HandleDrop(INT_PTR param) +{ + if (param) + { + extern HNAVITEM g_treedrag_lastSel; + if (g_treedrag_lastSel) + { + NavItemI_SetState(g_treedrag_lastSel, 0, NIS_DROPHILITED_I); + g_treedrag_lastSel = 0; + } + + mlDropItemStruct *m = (mlDropItemStruct *)param; + if (!m->data) return 0; + + HWND h = WindowFromPoint(m->p); + if (!h) return 0;; + + if (NULL != dragTarget.hwnd) + { + BOOL bProcessed = FALSE; + if (DRAGSTATE_NOTSUPPORTED != dragTarget.state && + DRAGSTATE_UNKNOWN != dragTarget.state) + { + if (h != dragTarget.hwnd) + SendMessageW(dragTarget.hwnd, WAML_NOTIFY_DRAGDROP, DRAGDROP_DRAGLEAVE, 0L); + else + { + bProcessed = TRUE; + if (DRAGSTATE_ACCEPTED == dragTarget.state) + SendMessageW(dragTarget.hwnd, WAML_NOTIFY_DRAGDROP, DRAGDROP_DROP, (LPARAM)m); + } + } + + + dragTarget.hwnd = NULL; + dragTarget.state = DRAGSTATE_UNKNOWN; + dragTarget.testResult = 0; + + if (bProcessed) + return 0; + } + + extern HWND wa3wnd_fixwnd(HWND); + h = wa3wnd_fixwnd(h); + + itemRecordList *obj = (itemRecordList *)m->data; // may not be valid heh + + if (IsChild(plugin.hwndParent, h)) h = plugin.hwndParent; + else if (g_PEWindow && IsChild(g_PEWindow, h)) h = g_PEWindow; + else + { + HWND vid = (HWND)SendMessage(plugin.hwndParent, WM_WA_IPC, IPC_GETWND_VIDEO, IPC_GETWND); + if (vid) + { + if (h == vid || IsChild(vid, h)) h = plugin.hwndParent; + } + } + + if (h == plugin.hwndParent) + { + int enqueue = (!!g_config->ReadInt(L"enqueuedef", 0)) ^(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000)); + if (m->type == ML_TYPE_ITEMRECORDLIST || m->type == ML_TYPE_CDTRACKS) + main_playItemRecordList((itemRecordList *)m->data, enqueue); + else if (m->type == ML_TYPE_ITEMRECORDLISTW) + main_playItemRecordListW((itemRecordListW *)m->data, enqueue); + else if (m->type == ML_TYPE_FILENAMES || m->type == ML_TYPE_STREAMNAMES) + { + if (!enqueue) SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_DELETE); + char *p = (char*)m->data; + + while (p && *p) + { + COPYDATASTRUCT cds; + cds.dwData = IPC_PLAYFILE; + cds.lpData = (void *) p; + cds.cbData =(INT) strlen((char *) cds.lpData) + 1; // include space for null char + SendMessage(plugin.hwndParent, WM_COPYDATA, (WPARAM)NULL, (LPARAM)&cds); + p += strlen(p) + 1; + } + if (!enqueue) SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_STARTPLAY); + } + else if (m->type == ML_TYPE_FILENAMESW || m->type == ML_TYPE_STREAMNAMESW) + { + if (!enqueue) SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_DELETE); + wchar_t *p = (wchar_t*)m->data; + + while (p && *p) + { + COPYDATASTRUCT cds; + cds.dwData = IPC_PLAYFILEW; + cds.lpData = (void *) p; + cds.cbData =(INT)sizeof(wchar_t) * wcslen((wchar_t *) cds.lpData) + sizeof(wchar_t); // include space for null char + SendMessage(plugin.hwndParent, WM_COPYDATA, (WPARAM)NULL, (LPARAM)&cds); + p += wcslen(p) + 1; + } + if (!enqueue) SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_STARTPLAY); + } + else if (m->type == ML_TYPE_PLAYLIST) + { + if (!enqueue) SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_DELETE); + mlPlaylist *p = (mlPlaylist *)m->data; + + COPYDATASTRUCT cds; + cds.dwData = IPC_PLAYFILEW; + cds.lpData = (void *) p->filename; + cds.cbData = sizeof(wchar_t)*(wcslen(p->filename) + 1);// include space for null char + SendMessage(plugin.hwndParent, WM_COPYDATA, (WPARAM)NULL, (LPARAM)&cds); + + if (!enqueue) SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_STARTPLAY); + } + else if (m->type == ML_TYPE_PLAYLISTS) + { + if (!enqueue) SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_DELETE); + mlPlaylist **playlists = (mlPlaylist **)m->data; + while (playlists && *playlists) + { + mlPlaylist *p = *playlists; + COPYDATASTRUCT cds; + cds.dwData = IPC_PLAYFILEW; + cds.lpData = (void *) p->filename; + cds.cbData = sizeof(wchar_t)*(wcslen(p->filename) + 1);// include space for null char + SendMessage(plugin.hwndParent, WM_COPYDATA, (WPARAM)NULL, (LPARAM)&cds); + playlists++; + } + + if (!enqueue) SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_STARTPLAY); + } + } + else if (h == g_PEWindow) + { + POINT p = m->p; + ScreenToClient(g_PEWindow, &p); + LRESULT idx = SendMessage(g_PEWindow, WM_USER, IPC_PE_GETIDXFROMPOINT, (LPARAM) & p); + SendMessage(g_PEWindow, WM_USER, IPC_PE_SAVEEND, (LPARAM)idx); + if (m->type == ML_TYPE_ITEMRECORDLIST || m->type == ML_TYPE_CDTRACKS) + main_playItemRecordList((itemRecordList *)m->data, 1); + else if (m->type == ML_TYPE_ITEMRECORDLISTW) + main_playItemRecordListW((itemRecordListW *)m->data, 1); + else if (m->type == ML_TYPE_FILENAMES || m->type == ML_TYPE_STREAMNAMES) + { + char *fileName = (char*)m->data; + while (fileName && *fileName) + { + COPYDATASTRUCT cds; + cds.dwData = IPC_PLAYFILE; + cds.lpData = (void *)fileName; + cds.cbData = (INT)strlen((char *) cds.lpData) + 1; // include space for null char + SendMessage(plugin.hwndParent, WM_COPYDATA, (WPARAM)NULL, (LPARAM)&cds); + fileName += strlen(fileName) + 1; + } + } + else if (m->type == ML_TYPE_FILENAMESW || m->type == ML_TYPE_STREAMNAMESW) + { + wchar_t *fileName = (wchar_t*)m->data; + while (fileName && *fileName) + { + COPYDATASTRUCT cds; + cds.dwData = IPC_PLAYFILEW; + cds.lpData = (void *)fileName; + cds.cbData = (INT)sizeof(wchar_t) * wcslen((wchar_t *) cds.lpData) + sizeof(wchar_t); // include space for null char + SendMessage(plugin.hwndParent, WM_COPYDATA, (WPARAM)NULL, (LPARAM)&cds); + fileName += wcslen(fileName) + 1; + } + } + else if (m->type == ML_TYPE_PLAYLIST) + { + mlPlaylist *pl = (mlPlaylist *)m->data; + + COPYDATASTRUCT cds; + cds.dwData = IPC_PLAYFILEW; + cds.lpData = (void *) pl->filename; + cds.cbData = sizeof(wchar_t)*(wcslen(pl->filename) + 1);// include space for null char + SendMessage(plugin.hwndParent, WM_COPYDATA, (WPARAM)NULL, (LPARAM)&cds); + } + SendMessage(g_PEWindow, WM_USER, IPC_PE_RESTOREEND, 0); + } + else if (h == NavCtrlI_GetHWND(hNavigation)) + { + HNAVITEM hItemHit, hItemSel; + POINT pt = m->p; + MapWindowPoints(HWND_DESKTOP, h, &pt, 1); + + hItemHit = NavCtrlI_HitTest(hNavigation, &pt, NULL); + hItemSel = NavCtrlI_GetSelection(hNavigation); + + if (hItemHit == hItemSel) m->result = -1; + else + { + INT itemId = NavItemI_GetId(hItemHit); + if (itemId && plugin_SendMessage(ML_MSG_TREE_ONDROPTARGET, itemId, m->type, NULL) > 0) + plugin_SendMessage(ML_MSG_TREE_ONDROPTARGET, itemId, m->type, (INT_PTR)m->data); + } + } + else{ + // TODO: verify this is correct against NAV api usage + // try to send to the current view if all else failed + // e.g. dragging a playlist view onto bookmarks page + HNAVITEM hItemSel = NavCtrlI_GetSelection(hNavigation); + INT itemId = NavItemI_GetId(hItemSel); + if(itemId && plugin_SendMessage(ML_MSG_TREE_ONDROPTARGET, itemId, m->type, NULL) > 0) + plugin_SendMessage(ML_MSG_TREE_ONDROPTARGET, itemId, m->type, (INT_PTR)m->data); + } + } + return 0; +} + +static INT_PTR IPC_GetTree(INT_PTR param) +{ + mlGetTreeStruct *mgts; + HNAVITEM hStartItem = NULL, hStartItem2 = NULL; + NAVMENUBUILDER nmb; + wchar_t buffer[1024] = {0}; + + if (!param) return NULL; + + mgts = (mlGetTreeStruct *)param; + + hStartItem = NavCtrlI_FindItem(hNavigation, mgts->item_start); + + if (hStartItem) hStartItem2 = NavItemI_GetChild(hStartItem); + + nmb.level = 0; + nmb.hMenu[0] = CreatePopupMenu(); + nmb.hParent[0] = NavItemI_GetParent(hStartItem2); + nmb.maxNum = mgts->max_numitems; + nmb.offset = mgts->cmd_offset; + nmb.counter = 0; + nmb.nis.mask = NIMF_TEXT_I | NIMF_STYLE_I | NIMF_ITEMID_I; + nmb.nis.styleMask = NIS_HASCHILDREN_I; + nmb.nis.cchTextMax = sizeof(buffer)/sizeof(wchar_t); + nmb.nis.pszText = buffer; + + if(hStartItem2 || !mgts->item_start) NavCtrlI_EnumItems(hNavigation, EnumerateNavItemsCB, hStartItem2, (LPARAM)&nmb); + + return (INT_PTR)nmb.hMenu[0]; +} + +static INT_PTR IPC_GetRating(HWND hwndML, INT_PTR param) +{ + LRESULT plindex = SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_GETLISTPOS); + return getPlRating(hwndML, plindex); +} + +static INT_PTR IPC_SetRating(HWND hwndML, INT_PTR param) +{ + INT_PTR rating = min(5, max(0, param)); + LRESULT plindex = SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_GETLISTPOS); + SetPlRating(hwndML, (INT)plindex, (INT)rating); + SendMessage(plugin.hwndParent, WM_WA_IPC, 0, IPC_UPDTITLE); + return 1; +} + +static INT IPC_RegisterNavigationImage(INT_PTR param) +{ + HMLIMGLST hmlilNavigation; + MLIMAGESOURCE_I is; + INT_PTR tag; + INT mlilIndex; + + if (!param) return -1; + + hmlilNavigation = NavCtrlI_GetImageList(hNavigation); + if (!hmlilNavigation) return -1; + + ZeroMemory(&is, sizeof(MLIMAGESOURCE_I)); + is.hInst = ((MLTREEIMAGE*)param)->hinst; + is.bpp = 24; + is.lpszName = MAKEINTRESOURCEW(((MLTREEIMAGE*)param)->resourceId); + is.type = SRC_TYPE_BMP_I; + is.flags = ISF_FORCE_BPP_I; + + tag = ((MLTREEIMAGE*)param)->imageIndex; + if (-1 != tag) + { + mlilIndex = MLImageListI_GetIndexFromTag(hmlilNavigation, tag); + if (-1 != mlilIndex) + { + if (!MLImageListI_Replace(hmlilNavigation, mlilIndex, &is, + GUID_NULL, tag)) tag = -1; + } + } + else mlilIndex = -1; + + if (-1 == mlilIndex) + { + if ( -1 == tag) + { + static INT_PTR tagCounter = 8000; + tag = tagCounter++; + } + mlilIndex = MLImageListI_Add(hmlilNavigation, &is, MLIF_FILTER1_UID, tag); + if (-1 == mlilIndex) tag = -1; + } + + return (INT)tag; +} + +INT_PTR OnGetCurrentView(void) +{ + return (INT_PTR)m_curview_hwnd; +} + +static BOOL OnFlickerFixIPC(FLICKERFIX * pff) +{ + return (pff) ? FlickerFixWindow(pff->hwnd, pff->mode) : FALSE; +} + +static HBITMAP OnIPC_MLImageLoader_LoadDib(MLIMAGESOURCE *pmlis) +{ + return (pmlis && pmlis->cbSize == sizeof(MLIMAGESOURCE)) ? + MLImageLoaderI_LoadDib((MLIMAGESOURCE_I*)&pmlis->hInst) : + NULL; +} + +static BOOL OnIPC_MLImageLoader_CopyStruct(MLIMAGESOURCECOPY* pmlisCopy) +{ + return (pmlisCopy && pmlisCopy->dest && pmlisCopy->src && + pmlisCopy->dest->cbSize == sizeof(MLIMAGESOURCE) && + pmlisCopy->dest->cbSize == sizeof(MLIMAGESOURCE)) ? + MLImageLoaderI_CopyData((MLIMAGESOURCE_I*)&pmlisCopy->dest->hInst, (MLIMAGESOURCE_I*)&pmlisCopy->src->hInst) : + FALSE; +} + +static BOOL OnIPC_MLImageLoader_FreeStruct(MLIMAGESOURCE *pmlis) +{ + return (pmlis && pmlis->cbSize == sizeof(MLIMAGESOURCE)) ? + MLImageLoaderI_FreeData((MLIMAGESOURCE_I*)&pmlis->hInst) : + FALSE; +} + +static BOOL OnIPC_MLImageLoader_CheckExist(MLIMAGESOURCE *pmlis) +{ + return (NULL != pmlis && pmlis->cbSize == sizeof(MLIMAGESOURCE)) ? + MLImageLoaderI_CheckExist((MLIMAGESOURCE_I*)&pmlis->hInst) : + FALSE; +} + +static HMLIMGLST OnIPC_MLImageList_Create(MLIMAGELISTCREATE *pmlilCreate) +{ + return (pmlilCreate) ? MLImageListI_Create(pmlilCreate->cx, pmlilCreate->cy, pmlilCreate->flags, pmlilCreate->cInitial, pmlilCreate->cGrow, pmlilCreate->cCacheSize, hmlifMngr) : NULL; +} + +static BOOL OnIPC_MLImageList_Destroy(HMLIMGLST hmlil) +{ + return MLImageListI_Destroy(hmlil); +} + +static HIMAGELIST OnIPC_MLImageList_GetRealList(HMLIMGLST hmlil) +{ + return MLImageListI_GetRealList(hmlil); +} + +static INT OnIPC_MLImageList_GetRealIndex(MLIMAGELISTREALINDEX *pmlilRealIdx) +{ + return (pmlilRealIdx && pmlilRealIdx->cbSize == sizeof(MLIMAGELISTREALINDEX)) ? + MLImageListI_GetRealIndex(pmlilRealIdx->hmlil, pmlilRealIdx->mlilIndex, pmlilRealIdx->rgbBk, pmlilRealIdx->rgbFg) : -1; +} + +static INT OnIPC_MLImageList_Add(MLIMAGELISTITEM *pmlilItem) +{ + MLIMAGESOURCE_I *pis; + + if (!pmlilItem || pmlilItem->cbSize != sizeof(MLIMAGELISTITEM)) return -1; + + if (pmlilItem->pmlImgSource) + { + if (pmlilItem->pmlImgSource->cbSize != sizeof(MLIMAGESOURCE)) return -1; + pis = (MLIMAGESOURCE_I*)(&pmlilItem->pmlImgSource->hInst); + } + else pis = NULL; + pmlilItem->mlilIndex = MLImageListI_Add(pmlilItem->hmlil, pis, pmlilItem->filterUID, pmlilItem->nTag); + return pmlilItem->mlilIndex; +} + +static BOOL OnIPC_MLImageList_Replace(MLIMAGELISTITEM *pmlilItem) +{ + MLIMAGESOURCE_I *pis; + + if (!pmlilItem || pmlilItem->cbSize != sizeof(MLIMAGELISTITEM)) return -1; + + if (pmlilItem->pmlImgSource) + { + if (pmlilItem->pmlImgSource->cbSize != sizeof(MLIMAGESOURCE)) return -1; + pis = (MLIMAGESOURCE_I*)((INT*)pmlilItem->pmlImgSource + 1); + } + else pis = NULL; + return MLImageListI_Replace(pmlilItem->hmlil, pmlilItem->mlilIndex, pis, pmlilItem->filterUID, pmlilItem->nTag); +} + +static BOOL OnIPC_MLImageList_Remove(MLIMAGELISTITEM *pmlilItem) +{ + return (pmlilItem) ? MLImageListI_Remove(pmlilItem->hmlil, pmlilItem->mlilIndex) : FALSE; +} + +static BOOL OnIPC_MLImageList_GetImageSize(MLIMAGELISTIMAGESIZE *pmlilImageSize) +{ + return (pmlilImageSize) ? MLImageListI_GetImageSize(pmlilImageSize->hmlil, &pmlilImageSize->cx, &pmlilImageSize->cy) : FALSE; +} + +static INT OnIPC_MLImageList_GetImageCount(HMLIMGLST hmlil) +{ + return MLImageListI_GetImageCount(hmlil); +} + +static BOOL OnIPC_MLImageList_GetIndexFromTag(MLIMAGELISTTAG *pmlilTag) +{ + if (!pmlilTag) return FALSE; + pmlilTag->mlilIndex = MLImageListI_GetIndexFromTag(pmlilTag->hmlil, pmlilTag->nTag); + return (-1 != pmlilTag->mlilIndex); +} + +static BOOL OnIPC_MLImageList_GetTagFromIndex(MLIMAGELISTTAG *pmlilTag) +{ + return (pmlilTag) ? MLImageListI_GetTagFromIndex(pmlilTag->hmlil, pmlilTag->mlilIndex, &pmlilTag->nTag) : FALSE; +} + +static BOOL OnIPC_MLImageList_CheckItemExist(MLIMAGELISTITEM *pmlilItem) +{ + return (pmlilItem) ? MLImageListI_CheckItemExist(pmlilItem->hmlil, pmlilItem->mlilIndex) : FALSE; +} + +static BOOL OnIPC_MLImageFilter_Register(MLIMAGEFILTERINFO* pmlif) +{ + return (pmlif && pmlif->cbSize == sizeof(MLIMAGEFILTERINFO)) ? + MLImageFilterI_Register(hmlifMngr, (MLIMAGEFILTERINFO_I*)((INT*)pmlif +1)) : FALSE; +} + +static BOOL OnIPC_MLImageFilter_Unregister(const GUID* pUID) +{ + return (pUID) ? MLImageFilterI_Unregister(hmlifMngr, *pUID) : FALSE; +} + +static BOOL OnIPC_MLImageFilter_GetInfo(MLIMAGEFILTERINFO* pmlif) +{ + return (pmlif && pmlif->cbSize == sizeof(MLIMAGEFILTERINFO)) ? + MLImageFilterI_GetInfo(hmlifMngr, (MLIMAGEFILTERINFO_I*)((INT*)pmlif +1)) : FALSE; +} + +static BOOL OnIPC_MLImageFilter_ApplyEx(MLIMAGEFILTERAPPLYEX* pmlifApplyEx) +{ + if (!pmlifApplyEx || pmlifApplyEx->cbSize != sizeof(MLIMAGEFILTERAPPLYEX)) return FALSE; + return MLImageFilterI_ApplyEx(hmlifMngr, &pmlifApplyEx->filterUID, pmlifApplyEx->pData, pmlifApplyEx->cx, + pmlifApplyEx->cy, pmlifApplyEx->bpp, pmlifApplyEx->rgbBk, pmlifApplyEx->rgbFg, pmlifApplyEx->imageTag); +} + +static INT OnIPC_MLNavCtrl_BeginUpdate(UINT fRememberPos) +{ + return NavCtrlI_BeginUpdate(hNavigation, fRememberPos); +} + +static BOOL OnIPC_MLNavCtrl_DeleteItem(HNAVITEM hItem) +{ + return NavCtrlI_DeleteItem(hNavigation, hItem); +} + +static INT OnIPC_MLNavCtrl_EndUpdate(void) +{ + return NavCtrlI_EndUpdate(hNavigation); +} + +static BOOL OnIPC_MLNavCtrl_EnumItems(NAVCTRLENUMPARAMS *pnavEnumParams) +{ + return (pnavEnumParams) ? NavCtrlI_EnumItems(hNavigation, (NAVENUMPROC_I)pnavEnumParams->enumProc, + pnavEnumParams->hItemStart, pnavEnumParams->lParam) : FALSE; +} + +HNAVITEM OnIPC_MLNavCtrl_FindItemById(INT itemId) +{ + return NavCtrlI_FindItem(hNavigation, itemId); +} + +static HNAVITEM OnIPC_MLNavCtrl_FindItemByName(NAVCTRLFINDPARAMS *pnavFindParams) +{ + if (!pnavFindParams) return NULL; + return (!pnavFindParams->fFullNameSearch) ? + NavCtrlI_FindItemByName(hNavigation, pnavFindParams->Locale, pnavFindParams->compFlags, pnavFindParams->pszName, pnavFindParams->cchLength) : + NavCtrlI_FindItemByFullName(hNavigation, pnavFindParams->Locale, pnavFindParams->compFlags, pnavFindParams->pszName, pnavFindParams->cchLength, pnavFindParams->fAncestorOk); +} + +static HMLIMGLST OnIPC_MLNavCtrl_GetImageList(void) +{ + return NavCtrlI_GetImageList(hNavigation); +} + +static HNAVITEM OnIPC_MLNavCtrl_GetFirst(void) +{ + return NavCtrlI_GetRoot(hNavigation); +} + +static INT OnIPC_MLNavCtrl_GetIndent(void) +{ + return NavCtrlI_GetIndent(hNavigation); +} + +static DWORD OnIPC_MLNavCtrl_GetStyle(void) +{ + return NavCtrlI_GetStyle(hNavigation); +} + +static HNAVITEM OnIPC_MLNavCtrl_GetSelection(void) +{ + return NavCtrlI_GetSelection(hNavigation); +} + +static HWND OnIPC_MLNavCtrl_GetHWND(void) +{ + return NavCtrlI_GetHWND(hNavigation); +} + +static HNAVITEM OnIPC_MLNavCtrl_HitTest(NAVHITTEST *pnavHit) +{ + if (!pnavHit) return NULL; + pnavHit->hItem = NavCtrlI_HitTest(hNavigation, &pnavHit->pt, &pnavHit->flags); + return pnavHit->hItem; +} + +static HNAVITEM OnIPC_MLNavCtrl_InsertItem(NAVINSERTSTRUCT *pnavInsert) +{ + if (!hNavigation || !pnavInsert || pnavInsert->item.cbSize != sizeof(NAVITEM)) return NULL; + return NavCtrlI_InsertItem(hNavigation, pnavInsert->hInsertAfter, pnavInsert->hParent, (NAVITEM_I*)&pnavInsert->item.mask); +} + +static BOOL OnIPC_MLNavItem_EnsureVisible(HNAVITEM hItem) +{ + return NavItemI_EnsureVisible(hItem); +} + +static BOOL OnIPC_MLNavItem_Expand(NAVITEMEXPAND *pnavExpand) +{ + return (pnavExpand) ? NavItemI_Expand(pnavExpand->hItem, pnavExpand->fCmdExpand) : FALSE; +} + +static HNAVITEM OnIPC_MLNavItem_GetChild(HNAVITEM hItem) +{ + return NavItemI_GetChild(hItem); +} + +static INT OnIPC_MLNavItem_GetChildrenCount(HNAVITEM hItem) +{ + return NavItemI_GetChildrenCount(hItem); +} + +static INT OnIPC_MLNavItem_GetFullName(NAVITEMFULLNAME* pnavFullName) +{ + return (pnavFullName) ? NavItemI_GetFullName(pnavFullName->hItem, pnavFullName->pszText, pnavFullName->cchTextMax) : 0; +} + +static BOOL OnIPC_MLNavItem_GetInfo(NAVITEM *pnavItem) +{ + return (pnavItem && pnavItem->cbSize == sizeof(NAVITEM)) ? NavItemI_GetIndirect(pnavItem->hItem, (NAVITEM_I*)&pnavItem->mask) : FALSE; +} + +static HNAVITEM OnIPC_MLNavItem_GetNext(HNAVITEM hItem) +{ + return NavItemI_GetNext(hItem); +} + +static WORD OnIPC_MLNavItem_GetOrder(HNAVITEM hItem) +{ + return NavItemI_GetOrder(hItem); +} + +static HNAVITEM OnIPC_MLNavItem_GetParent(HNAVITEM hItem) +{ + return NavItemI_GetParent(hItem); +} + +static HNAVITEM OnIPC_MLNavItem_GetPrevious(HNAVITEM hItem) +{ + return NavItemI_GetPrevious(hItem); +} + +static BOOL OnIPC_MLNavItem_GetRect(NAVITEMGETRECT *pnavRect) +{ + return (pnavRect) ? NavItemI_GetRect(pnavRect->hItem, &pnavRect->rc, pnavRect->fItem) : FALSE; +} + +static UINT OnIPC_MLNavItem_GetState(HNAVITEM hItem) +{ + return NavItemI_GetState(hItem, 0xFFFFFFFF); +} + +static BOOL OnIPC_MLNavItem_HasChildrenReal(HNAVITEM hItem) +{ + return NavItemI_HasChildrenReal(hItem); +} + +static BOOL OnIPC_MLNavItem_Invalidate(NAVITEMINAVLIDATE *pnavInvalidate) +{ + return (pnavInvalidate) ? NavItemI_Invalidate(pnavInvalidate->hItem, pnavInvalidate->prc, pnavInvalidate->fErase) : FALSE; +} + +static BOOL OnIPC_MLNavItem_Move(NAVITEMMOVE *pnavMove) +{ + return (pnavMove) ? NavItemI_Move(pnavMove->hItem, pnavMove->hItemDest, pnavMove->fAfter) : FALSE; +} + +static BOOL OnIPC_MLNavItem_Select(HNAVITEM hItem) +{ + return NavItemI_Select(hItem); +} + +static BOOL OnIPC_MLNavItem_SetInfo(NAVITEM *pnavItem) +{ + return (pnavItem && pnavItem->cbSize == sizeof(NAVITEM)) ? NavItemI_SetIndirect(pnavItem->hItem, (NAVITEM_I*)&pnavItem->mask) : FALSE; +} + +static WORD OnIPC_MLNavItem_SetOrder(NAVITEMORDER *pnavOrder) +{ + return (pnavOrder) ? NavItemI_SetOrder(pnavOrder->hItem, pnavOrder->order, pnavOrder->flags) : 0xFFFF; +} + +static BOOL OnIPC_MLNavItem_EditTitle(HNAVITEM hItem) +{ + return NavItemI_EditTitle(hItem); +} + +static BOOL OnIPC_MLNavCtrl_EndEditTitle(BOOL fCancel) +{ + return NavCtrlI_EndEditTitle(hNavigation, fCancel); +} + +static BOOL OnIPC_MLRating_Draw(RATINGDRAWPARAMS *prdp) +{ + if (!prdp) return FALSE; + return MLRatingI_Draw(prdp->hdcDst, prdp->maxValue, prdp->value, prdp->trackingValue, + (prdp->hMLIL) ? prdp->hMLIL : hmlilRating, + (prdp->hMLIL) ? prdp->index : 0, + &prdp->rc, prdp->fStyle); +} + +static INT OnIPC_MLRating_Hittest(RATINGHITTESTPARAMS *prhtp) +{ + LONG result; + if (!prhtp) return FALSE; + result = MLRatingI_HitTest(prhtp->pt, prhtp->maxValue, + (prhtp->hMLIL) ? prhtp->hMLIL : hmlilRating, + &prhtp->rc, prhtp->fStyle); + prhtp->hitFlags = HIWORD(result); + prhtp->value = LOWORD(result); + return prhtp->value; +} + +static BOOL OnIPC_MLRating_CalcRect(RECT *prc) +{ + return (prc) ? MLRatingI_CalcMinRect(prc->top, (prc->left) ? (HMLIMGLST)(LONG_PTR)prc->left : hmlilRating, prc) : FALSE; +} + +static BOOL OnIPC_MLCloud_Draw(CLOUDDRAWPARAMS *prdp) +{ + if (!prdp) return FALSE; + return MLCloudI_Draw(prdp->hdcDst, prdp->value, (prdp->hMLIL) ? prdp->hMLIL : hmlilCloud, + (prdp->hMLIL) ? prdp->index : 0, &prdp->rc); +} + +static BOOL OnIPC_MLCloud_CalcRect(RECT *prc) +{ + return (prc) ? MLCloudI_CalcMinRect((prc->left) ? (HMLIMGLST)(LONG_PTR)prc->left : hmlilCloud, prc) : FALSE; +} + +static BOOL OnIPC_SkinWindow(MLSKINWINDOW* pmlsw) +{ + return (pmlsw) ? SkinWindowEx(pmlsw->hwndToSkin, pmlsw->skinType, pmlsw->style) : FALSE; +} + +static BOOL OnIPC_UnskinWindow(HWND hwndToUnskin) +{ + return UnskinWindow(hwndToUnskin); +} + +static BOOL OnIPC_TrackSkinnedPopup(MLSKINNEDPOPUP *pmlsp) +{ + if (pmlsp && pmlsp->cbSize == sizeof(MLSKINNEDPOPUP)) + { + return MediaLibrary_TrackPopupEx(pmlsp->hmenu, pmlsp->fuFlags, pmlsp->x, pmlsp->y, pmlsp->hwnd, pmlsp->lptpm, + pmlsp->hmlil, pmlsp->width, pmlsp->skinStyle, pmlsp->customProc, pmlsp->customParam); + } + else + return FALSE; +} + +static HANDLE OnIPC_InitSkinnedPopupHook(MLSKINNEDPOPUP *pmlsp) +{ + if (pmlsp && pmlsp->cbSize == sizeof(MLSKINNEDPOPUP)) + { + return MediaLibrary_InitSkinnedPopupHook(pmlsp->hwnd, pmlsp->hmlil, pmlsp->width, pmlsp->skinStyle, + pmlsp->customProc, pmlsp->customParam); + } + + return NULL; +} + +static BOOL OnIPC_RemoveSkinnedPopupHook(HANDLE hPopupHook) +{ + RemoveSkinnedPopupHook(hPopupHook); + return TRUE; +} + +static BOOL OnIPC_RatingColumn_Paint(RATINGCOLUMNPAINT *prcp) +{ + return (prcp) ? MLRatingColumnI_Paint((RATINGCOLUMNPAINT_I*)prcp) : FALSE; +} + +static BOOL OnIPC_RatingColumn_OnClick(RATINGCOLUMN *pRating) +{ + return (pRating) ? MLRatingColumnI_Click((RATINGCOLUMN_I*)pRating) : FALSE; +} + +static BOOL OnIPC_RatingColumn_OnTrack(RATINGCOLUMN *pRating) +{ + if (!pRating) return FALSE; + MLRatingColumnI_Track((RATINGCOLUMN_I*)pRating); + return TRUE; +} + +static BOOL OnIPC_RatingColumn_CancelTracking(BOOL bRedrawNow) +{ + MLRatingColumnI_CancelTracking(bRedrawNow); + return TRUE; +} + +static BOOL OnIPC_RatingColumn_BeginDrag(RATINGCOLUMN *pRating) +{ + return (pRating) ? MLRatingColumnI_BeginDrag((RATINGCOLUMN_I*)pRating) : FALSE; +} + +static BOOL OnIPC_RatingColumn_OnDrag(POINT *ppt) +{ + return (ppt) ? MLRatingColumnI_Drag(*ppt) : FALSE; +} + +static BOOL OnIPC_RatingColumn_OnEndDrag(RATINGCOLUMN *pRating) +{ + return (pRating) ? MLRatingColumnI_EndDrag((RATINGCOLUMN_I*)pRating) : FALSE; +} + +static BOOL OnIPC_RatingColumn_Animate(RATINGCOLUMN *pRating) +{ + if (!pRating) return FALSE; + MLRatingColumnI_Animate(pRating->hwndList, pRating->iItem, pRating->iSubItem); + return TRUE; +} + +static INT OnIPC_RatingColumn_GetMinWidth() +{ + return MLRatingColumnI_GetMinWidth(); +} + +static BOOL OnIPC_CloudColumn_GetWidth(INT *width) +{ + if (!width) return FALSE; + *width = MLCloudColumnI_GetWidth(*width); + return TRUE; +} + +static BOOL OnIPC_CloudColumn_Paint(RATINGCOLUMNPAINT *prcp) +{ + return (prcp) ? MLCloudColumnI_Paint((CLOUDCOLUMNPAINT_I*)prcp) : FALSE; +} + +static INT OnIPC_CloudColumn_GetMinWidth() +{ + return MLCloudColumnI_GetMinWidth(); +} + +static BOOL OnIPC_RatingColumn_FillBackString(RATINGBACKTEXT *prbt) +{ + if (!prbt) return FALSE; + MLRatingColumnI_FillBackString(prbt->pszText, prbt->cchTextMax, prbt->nColumnWidth, prbt->fStyle); + return TRUE; +} + +static BOOL OnIPC_RatingColumn_GetWidth(RATINGWIDTH *prw) +{ + if (!prw) return FALSE; + prw->width = MLRatingColumnI_GetWidth(prw->width, prw->fStyle); + return TRUE; +} + +static HWND OnIPC_CreateWebInfo(WEBINFOCREATE *pWebInfoCreate) +{ + + if (!pWebInfoCreate) return NULL; + if (-1 == pWebInfoCreate->cy) pWebInfoCreate->cy = WEBINFO_PREFFERED_HEIGHT; + + return CreateWebInfoWindow(pWebInfoCreate->hwndParent, pWebInfoCreate->uMsgQuery, + pWebInfoCreate->x, pWebInfoCreate->y, pWebInfoCreate->cx, pWebInfoCreate->cy, pWebInfoCreate->ctrlId); +} + +static HWND OnIPC_CreateFileView(MLFILEVIEWCREATESTRUCT *pfvcs) +{ + if (!pfvcs) return NULL; + return FileView_CreateDialog(pfvcs->hwndParent, pfvcs->fStyle, pfvcs->hwndInsertAfter, pfvcs->x, pfvcs->y, pfvcs->cx, pfvcs->cy); +} + +INT_PTR pluginHandleIpcMessage(HWND hwndML, int msg, INT_PTR param) +{ + switch (msg) + { + case ML_IPC_PL_GETRATING: return getPlRating(hwndML, param); + case ML_IPC_PL_SETRATING: return IPC_PL_SetRating(hwndML, param); + case ML_IPC_GETRATING: return IPC_GetRating(hwndML, param); + case ML_IPC_SETRATING: return IPC_SetRating(hwndML, param); + case ML_IPC_OPENPREFS: + { + extern prefsDlgRecW myPrefsItem; + SendMessage(plugin.hwndParent, WM_WA_IPC, (WPARAM)&myPrefsItem, IPC_OPENPREFSTOPAGE); + } + return 1; + + case ML_IPC_GETTREE: return IPC_GetTree(param); + case ML_IPC_TREEITEM_INSERT: + case ML_IPC_TREEITEM_INSERTW: + case ML_IPC_ADDTREEITEM_EX: + case ML_IPC_ADDTREEITEM: + case ML_IPC_TREEITEM_ADD: + case ML_IPC_TREEITEM_ADDW: return IPC_InsertView(msg, param); + case ML_IPC_SETTREEITEM_EX: + case ML_IPC_SETTREEITEM: + case ML_IPC_TREEITEM_SETINFO: + case ML_IPC_TREEITEM_SETINFOW: return (INT_PTR)IPC_SetView(msg, param); + case ML_IPC_TREEITEM_GETINFO: + case ML_IPC_TREEITEM_GETINFOW: return (INT_PTR)IPC_GetView(msg, param); + case ML_IPC_GETCURTREEITEM: return (INT_PTR)NavItemI_GetId(NavCtrlI_GetSelection(hNavigation)); + case ML_IPC_TREEITEM_GETSELECTED: return (INT_PTR)NavCtrlI_GetSelection(hNavigation); + case ML_IPC_SETCURTREEITEM: return (INT_PTR)NavItemI_Select(NavCtrlI_FindItem(hNavigation, (INT)param)); + case ML_IPC_TREEITEM_SELECT: return (INT_PTR)NavItemI_Select((HNAVITEM)param); + case ML_IPC_DELTREEITEM: return (INT_PTR)NavCtrlI_DeleteItem(hNavigation, NavCtrlI_FindItem(hNavigation, (INT)param)); + case ML_IPC_TREEITEM_DELETE: return (INT_PTR)NavCtrlI_DeleteItem(hNavigation, (HNAVITEM)param); + case ML_IPC_TREEITEM_GETHANDLE: return (INT_PTR)NavCtrlI_FindItem(hNavigation, (INT)param); + case ML_IPC_TREEITEM_GETCHILD: return (INT_PTR)((MLTI_ROOT == param) ? NavCtrlI_GetRoot(hNavigation) : NavItemI_GetChild((HNAVITEM)param)); + case ML_IPC_TREEITEM_GETNEXT: return (INT_PTR)NavItemI_GetNext((HNAVITEM)param); + case ML_IPC_TREEITEM_GETCHILD_ID: return (INT_PTR)NavItemI_GetId(NavItemI_GetChild(NavCtrlI_FindItem(hNavigation, (INT)param))); + case ML_IPC_TREEITEM_GETNEXT_ID: return (INT_PTR)NavItemI_GetId(NavItemI_GetNext(NavCtrlI_FindItem(hNavigation, (INT)param))); + case ML_IPC_TREEITEM_GETROOT: return (INT_PTR)NavCtrlI_GetRoot(hNavigation); + case ML_IPC_ADDTREEIMAGE: + case ML_IPC_TREEIMAGE_ADD: return (INT_PTR)IPC_RegisterNavigationImage(param); + case ML_IPC_GET_VIEW_BUTTON_TEXT: + { + if (!playBuf[0]) WASABI_API_LNGSTRINGW_BUF(IDS_PLAY, playBuf, ARRAYSIZE(playBuf)); + if (!enqueueBuf[0]) WASABI_API_LNGSTRINGW_BUF(IDS_ENQUEUE, enqueueBuf, ARRAYSIZE(enqueueBuf)); + + viewButtons *view = (viewButtons*)param; + if (view) + { + view->play = playBuf; + view->enqueue = enqueueBuf; + } + break; + } + + case ML_IPC_HANDLEDRAG: return IPC_HandleDrag(hwndML, (mlDropItemStruct*)param); + case ML_IPC_HANDLEDROP: // hmm, not sure bout this one =) + return IPC_HandleDrop(param); + + case ML_IPC_SKIN_COMBOBOX: return (param) ? (INT_PTR)(new ComboSkin((HWND)param)) : NULL; + case ML_IPC_UNSKIN_COMBOBOX: if (param) delete reinterpret_cast<ComboSkin*>(param); return (NULL != param); + case ML_IPC_SKIN_LISTVIEW: return (SkinWindowEx((HWND)param, SKINNEDWND_TYPE_LISTVIEW, SWS_USESKINCOLORS | SWS_USESKINCURSORS | SWLVS_FULLROWSELECT | SWLVS_DOUBLEBUFFER)) ? param : NULL; + case ML_IPC_UNSKIN_LISTVIEW: return UnskinWindow((HWND)param); + case ML_IPC_LISTVIEW_UPDATE: return MLSkinnedScrollWnd_UpdateBars((HWND)param, TRUE); + case ML_IPC_LISTVIEW_DISABLEHSCROLL:return MLSkinnedScrollWnd_ShowHorzBar((HWND)param, FALSE); + case ML_IPC_LISTVIEW_DISABLEVSCROLL:return MLSkinnedScrollWnd_ShowVertBar((HWND)param, FALSE); + + case ML_IPC_LISTVIEW_SHOWSORT: + if (param && ((LV_SKIN_SHOWSORT*)param)->listView) + { + if (((LV_SKIN_SHOWSORT*)param)->showSort) return TRUE; + return SendMessageW((HWND)((LV_SKIN_SHOWSORT*)param)->listView, WM_ML_IPC, + MAKEWPARAM((((LV_SKIN_SHOWSORT*)param)->showSort) ? 0 : -1, TRUE), + ML_IPC_SKINNEDLISTVIEW_DISPLAYSORT); + } + return 0; + case ML_IPC_LISTVIEW_SORT: + if (param && ((LV_SKIN_SORT*)param)->listView) + { + return SendMessageW((HWND)((LV_SKIN_SHOWSORT*)param)->listView, WM_ML_IPC, + MAKEWPARAM(((LV_SKIN_SORT*)param)->columnIndex, ((LV_SKIN_SORT*)param)->ascending), + ML_IPC_SKINNEDLISTVIEW_DISPLAYSORT); + } + return 0; + + case ML_IPC_SENDTOWINAMP: + return IPC_SendToWinamp(param); + + case ML_IPC_SKIN_WADLG_GETFUNC: + switch (param) + { + case 1: return (INT_PTR)WADlg_getColor; + case 2: return (INT_PTR)WADlg_handleDialogMsgs; + case 3: return (INT_PTR)WADlg_DrawChildWindowBorders; + case 4: return (INT_PTR)WADlg_getBitmap; + case 32: return (INT_PTR)childresize_init; + case 33: return (INT_PTR)childresize_resize; + case 66: + if (g_config->ReadInt(L"plfont_everywhere", 1)) + { + INT height = (INT)SendMessageW(plugin.hwndParent, WM_WA_IPC, 3, IPC_GET_GENSKINBITMAP); + DWORD charset = (DWORD)SendMessageW(plugin.hwndParent, WM_WA_IPC, 2, IPC_GET_GENSKINBITMAP); + char *fontname = (char*)SendMessageW(plugin.hwndParent, WM_WA_IPC, 1, IPC_GET_GENSKINBITMAP); + return (INT_PTR)CreateFontA(-height, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, charset, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DRAFT_QUALITY, DEFAULT_PITCH | FF_DONTCARE, fontname); + } + return 0; + + } + break; + case ML_IPC_ADDTOSENDTO: + if (param) + { + mlAddToSendToStruct *p = (mlAddToSendToStruct *)param; + if (p->context) + { + SendToMenu *a = (SendToMenu*)p->context; + a->onAddItem(p); + } + } + break; + case ML_IPC_ADDTOSENDTOW: + if (param) + { + mlAddToSendToStructW *p = (mlAddToSendToStructW *)param; + if (p->context) + { + SendToMenu *a = (SendToMenu*)p->context; + a->onAddItem(p); + } + } + break; + case ML_IPC_BRANCHSENDTO: + if (param) + { + mlAddToSendToStructW *p = (mlAddToSendToStructW *)param; + if (p->context) + { + SendToMenu *a = (SendToMenu*)p->context; + if (p->desc) + a->endBranch(p->desc); + else + a->startBranch(); + } + } + break; + case ML_IPC_ADDTOBRANCH: + if (param) + { + mlAddToSendToStructW *p = (mlAddToSendToStructW *)param; + if (p->context) + { + SendToMenu *a = (SendToMenu*)p->context; + a->addItemToBranch(p); + } + } + break; + + ///////////// plugin adding/removing + case ML_IPC_ADD_PLUGIN: + case ML_IPC_REMOVE_PLUGIN: + if (param) + { + winampMediaLibraryPlugin *p = (winampMediaLibraryPlugin *)param; + int x, l = m_plugins.GetSize(); + for (x = 0; x < l && m_plugins.Get(x) != (void *)param; x ++); + if (x < l) + { + if (msg == ML_IPC_ADD_PLUGIN) return -1; + m_plugins.Del(x); // remove this plugin + return 1; + } + if (msg == ML_IPC_REMOVE_PLUGIN) return -1; //plugin not found to delete + + if (p->version > MLHDR_VER && p->version < MLHDR_VER_OLD /*|| p->hDllInstance*/) return -1; //benski> cut the hDllInstance == 0 requirement, BUT you have to do a LoadLibrary to fake it out + + if (msg == ML_IPC_ADD_PLUGIN && p->hDllInstance) + { + // if they set the hDllInstance, do a LoadLibrary to increment the reference count + // that way we can FreeLibrary it safely later + TCHAR filename[MAX_PATH] = {0}; + GetModuleFileName(p->hDllInstance, filename, MAX_PATH); + HMODULE dummyLoad = LoadLibraryW(filename); + assert(dummyLoad == p->hDllInstance); + } + p->hwndLibraryParent = hwndML; + p->hwndWinampParent = plugin.hwndParent; + + m_plugins.Add(p); + return 1; + } + return -1; + case ML_IPC_SEND_PLUGIN_MESSAGE: + if (param) + { + pluginMessage *m = (pluginMessage*)param; + return plugin_SendMessage(m->messageType, m->param1, m->param2, m->param3); + } + return -1; + /* + case ML_IPC_GRACENOTE: + switch (param) + { + case GRACENOTE_TUID: return(INT_PTR)gracenoteGetTuid(); + case GRACENOTE_IS_WORKING: return(INT_PTR)gracenoteIsWorking(); + case GRACENOTE_DO_TIMER_STUFF: return(INT_PTR)gracenoteDoTimerStuff(); + case GRACENOTE_CANCEL_REQUEST: gracenoteCancelRequest(); return 1; + } + break; + */ + + case ML_IPC_REFRESH_PREFS: + refreshPrefs(param); + return 1; + + case ML_IPC_GETCURRENTVIEW: + return OnGetCurrentView(); + + case ML_IPC_ENSURE_VISIBLE: + if (!IsVisible()) + toggleVisible(); + return 1; + + case ML_IPC_IS_VISIBLE: + return IsVisible() ? 1 : 0; + + case ML_IPC_GET_PARENTAL_RATING: // TODO: store this in api_config + return g_config->ReadInt(L"tvrating", 7); + + case ML_IPC_TOGGLE_VISIBLE: + toggleVisible(); + return 1; + + case ML_IPC_FOCUS_TREE: + SetFocus(NavCtrlI_GetHWND(hNavigation)); + return 1; + + case ML_IPC_FLICKERFIX: return (param) ? OnFlickerFixIPC((FLICKERFIX*)param) : FALSE; + + case ML_IPC_GETVERSION: return PLUGIN_VERSION; + + case ML_IPC_SHOW_HELP: return MediaLibrary_OpenHelpUrl((const wchar_t*)param); + + case ML_IPC_IMAGELOADER_LOADDIB: return (INT_PTR)OnIPC_MLImageLoader_LoadDib((MLIMAGESOURCE*)param); + case ML_IPC_IMAGELOADER_COPYSTRUCT: return (INT_PTR)OnIPC_MLImageLoader_CopyStruct((MLIMAGESOURCECOPY*)param); + case ML_IPC_IMAGELOADER_FREESTRUCT: return (INT_PTR)OnIPC_MLImageLoader_FreeStruct((MLIMAGESOURCE*)param); + case ML_IPC_IMAGELOADER_CHECKEXIST: return (INT_PTR)OnIPC_MLImageLoader_CheckExist((MLIMAGESOURCE*)param); + + case ML_IPC_IMAGELIST_CREATE: return (INT_PTR)OnIPC_MLImageList_Create((MLIMAGELISTCREATE*)param); + case ML_IPC_IMAGELIST_DESTROY: return (INT_PTR)OnIPC_MLImageList_Destroy((HMLIMGLST)param); + case ML_IPC_IMAGELIST_GETREALLIST: return (INT_PTR)OnIPC_MLImageList_GetRealList((HMLIMGLST)param); + case ML_IPC_IMAGELIST_GETREALINDEX: return (INT_PTR)OnIPC_MLImageList_GetRealIndex((MLIMAGELISTREALINDEX*)param); + case ML_IPC_IMAGELIST_ADD: return (INT_PTR)OnIPC_MLImageList_Add((MLIMAGELISTITEM*)param); + case ML_IPC_IMAGELIST_REPLACE: return (INT_PTR)OnIPC_MLImageList_Replace((MLIMAGELISTITEM*)param); + case ML_IPC_IMAGELIST_REMOVE: return (INT_PTR)OnIPC_MLImageList_Remove((MLIMAGELISTITEM*)param); + case ML_IPC_IMAGELIST_GETIMAGESIZE: return (INT_PTR)OnIPC_MLImageList_GetImageSize((MLIMAGELISTIMAGESIZE*)param); + case ML_IPC_IMAGELIST_GETIMAGECOUNT: return (INT_PTR)OnIPC_MLImageList_GetImageCount((HMLIMGLST)param); + case ML_IPC_IMAGELIST_GETINDEXFROMTAG: return (INT_PTR)OnIPC_MLImageList_GetIndexFromTag((MLIMAGELISTTAG*)param); + case ML_IPC_IMAGELIST_GETTAGFROMINDEX: return (INT_PTR)OnIPC_MLImageList_GetTagFromIndex((MLIMAGELISTTAG*)param); + case ML_IPC_IMAGELIST_CHECKEXIST: return (INT_PTR)OnIPC_MLImageList_CheckItemExist((MLIMAGELISTITEM*)param); + case ML_IPC_IMAGEFILTER_REGISTER: return (INT_PTR)OnIPC_MLImageFilter_Register((MLIMAGEFILTERINFO*)param); + case ML_IPC_IMAGEFILTER_UNREGISTER: return (INT_PTR)OnIPC_MLImageFilter_Unregister((const GUID*)param); + case ML_IPC_IMAGEFILTER_GETINFO: return (INT_PTR)OnIPC_MLImageFilter_GetInfo((MLIMAGEFILTERINFO*)param); + case ML_IPC_IMAGEFILTER_APPLYEX: return (INT_PTR)OnIPC_MLImageFilter_ApplyEx((MLIMAGEFILTERAPPLYEX*)param); + + case ML_IPC_NAVCTRL_BEGINUPDATE: return (INT_PTR)OnIPC_MLNavCtrl_BeginUpdate((UINT)param); + case ML_IPC_NAVCTRL_DELETEITEM: return (INT_PTR)OnIPC_MLNavCtrl_DeleteItem((HNAVITEM)param); + case ML_IPC_NAVCTRL_ENDUPDATE: return (INT_PTR)OnIPC_MLNavCtrl_EndUpdate(); + case ML_IPC_NAVCTRL_ENUMITEMS: return (INT_PTR)OnIPC_MLNavCtrl_EnumItems((NAVCTRLENUMPARAMS*)param); + case ML_IPC_NAVCTRL_FINDITEMBYID: return (INT_PTR)OnIPC_MLNavCtrl_FindItemById((INT)param); + case ML_IPC_NAVCTRL_FINDITEMBYNAME: return (INT_PTR)OnIPC_MLNavCtrl_FindItemByName((NAVCTRLFINDPARAMS*)param); + case ML_IPC_NAVCTRL_GETIMAGELIST: return (INT_PTR)OnIPC_MLNavCtrl_GetImageList(); + case ML_IPC_NAVCTRL_GETFIRST: return (INT_PTR)OnIPC_MLNavCtrl_GetFirst(); + case ML_IPC_NAVCTRL_GETINDENT: return (INT_PTR)OnIPC_MLNavCtrl_GetIndent(); + case ML_IPC_NAVCTRL_GETSELECTION: return (INT_PTR)OnIPC_MLNavCtrl_GetSelection(); + case ML_IPC_NAVCTRL_GETHWND: return (INT_PTR)OnIPC_MLNavCtrl_GetHWND(); + case ML_IPC_NAVCTRL_HITTEST: return (INT_PTR)OnIPC_MLNavCtrl_HitTest((NAVHITTEST*)param); + case ML_IPC_NAVCTRL_INSERTITEM: return (INT_PTR)OnIPC_MLNavCtrl_InsertItem((NAVINSERTSTRUCT*)param); + case ML_IPC_NAVCTRL_ENDEDITTITLE: return (INT_PTR)OnIPC_MLNavCtrl_EndEditTitle((BOOL)param); + case ML_IPC_NAVCTRL_GETSTYLE: return (INT_PTR)OnIPC_MLNavCtrl_GetStyle(); + + case ML_IPC_NAVITEM_EDITTITLE: return (INT_PTR)OnIPC_MLNavItem_EditTitle((HNAVITEM)param); + case ML_IPC_NAVITEM_ENSUREVISIBLE: return (INT_PTR)OnIPC_MLNavItem_EnsureVisible((HNAVITEM)param); + case ML_IPC_NAVITEM_EXPAND: return (INT_PTR)OnIPC_MLNavItem_Expand((NAVITEMEXPAND*)param); + case ML_IPC_NAVITEM_GETCHILD: return (INT_PTR)OnIPC_MLNavItem_GetChild((HNAVITEM)param); + case ML_IPC_NAVITEM_GETCHILDRENCOUNT: return (INT_PTR)OnIPC_MLNavItem_GetChildrenCount((HNAVITEM)param); + case ML_IPC_NAVITEM_GETFULLNAME: return (INT_PTR)OnIPC_MLNavItem_GetFullName((NAVITEMFULLNAME*)param); + case ML_IPC_NAVITEM_GETINFO: return (INT_PTR)OnIPC_MLNavItem_GetInfo((NAVITEM*)param); + case ML_IPC_NAVITEM_GETNEXT: return (INT_PTR)OnIPC_MLNavItem_GetNext((HNAVITEM)param); + case ML_IPC_NAVITEM_GETORDER: return (INT_PTR)OnIPC_MLNavItem_GetOrder((HNAVITEM)param); + case ML_IPC_NAVITEM_GETPARENT: return (INT_PTR)OnIPC_MLNavItem_GetParent((HNAVITEM)param); + case ML_IPC_NAVITEM_GETPREVIOUS: return (INT_PTR)OnIPC_MLNavItem_GetPrevious((HNAVITEM)param); + case ML_IPC_NAVITEM_GETRECT: return (INT_PTR)OnIPC_MLNavItem_GetRect((NAVITEMGETRECT*)param); + case ML_IPC_NAVITEM_GETSTATE: return (INT_PTR)OnIPC_MLNavItem_GetState((HNAVITEM)param); + case ML_IPC_NAVITEM_HASCHILDRENREAL:return (INT_PTR)OnIPC_MLNavItem_HasChildrenReal((HNAVITEM)param); + case ML_IPC_NAVITEM_INVALIDATE: return (INT_PTR)OnIPC_MLNavItem_Invalidate((NAVITEMINAVLIDATE*)param); + case ML_IPC_NAVITEM_MOVE: return (INT_PTR)OnIPC_MLNavItem_Move((NAVITEMMOVE*)param); + case ML_IPC_NAVITEM_SELECT: return (INT_PTR)OnIPC_MLNavItem_Select((HNAVITEM)param); + case ML_IPC_NAVITEM_SETINFO: return (INT_PTR)OnIPC_MLNavItem_SetInfo((NAVITEM*)param); + case ML_IPC_NAVITEM_SETORDER: return (INT_PTR)OnIPC_MLNavItem_SetOrder((NAVITEMORDER*)param); + + case ML_IPC_RATING_DRAW: return (INT_PTR)OnIPC_MLRating_Draw((RATINGDRAWPARAMS*)param); + case ML_IPC_RATING_HITTEST: return (INT_PTR)OnIPC_MLRating_Hittest((RATINGHITTESTPARAMS*)param); + case ML_IPC_RATING_CALCRECT: return (INT_PTR)OnIPC_MLRating_CalcRect((RECT*)param); + + case ML_IPC_CLOUD_DRAW: return (INT_PTR)OnIPC_MLCloud_Draw((CLOUDDRAWPARAMS*)param); + case ML_IPC_CLOUD_CALCRECT: return (INT_PTR)OnIPC_MLCloud_CalcRect((RECT*)param); + + case ML_IPC_SKINWINDOW: return (INT_PTR)OnIPC_SkinWindow((MLSKINWINDOW*)param); + case ML_IPC_UNSKINWINDOW: return (INT_PTR)OnIPC_UnskinWindow((HWND)param); + + case ML_IPC_TRACKSKINNEDPOPUPEX: return (INT_PTR)OnIPC_TrackSkinnedPopup((MLSKINNEDPOPUP*)param); + case ML_IPC_INITSKINNEDPOPUPHOOK: return (INT_PTR)OnIPC_InitSkinnedPopupHook((MLSKINNEDPOPUP*)param); + case ML_IPC_REMOVESKINNEDPOPUPHOOK: return (INT_PTR)OnIPC_RemoveSkinnedPopupHook((HANDLE)param); + + case ML_IPC_RATINGCOLUMN_PAINT: return (INT_PTR)OnIPC_RatingColumn_Paint((RATINGCOLUMNPAINT*)param); + case ML_IPC_RATINGCOLUMN_CLICK: return (INT_PTR)OnIPC_RatingColumn_OnClick((RATINGCOLUMN*)param); + case ML_IPC_RATINGCOLUMN_TRACK: return (INT_PTR)OnIPC_RatingColumn_OnTrack((RATINGCOLUMN*)param); + case ML_IPC_RATINGCOLUMN_CANCELTRACKING: return (INT_PTR)OnIPC_RatingColumn_CancelTracking((BOOL)param); + case ML_IPC_RATINGCOLUMN_BEGINDRAG: return (INT_PTR)OnIPC_RatingColumn_BeginDrag((RATINGCOLUMN*)param); + case ML_IPC_RATINGCOLUMN_DRAG: return (INT_PTR)OnIPC_RatingColumn_OnDrag((POINT*)param); + case ML_IPC_RATINGCOLUMN_ENDDRAG: return (INT_PTR)OnIPC_RatingColumn_OnEndDrag((RATINGCOLUMN*)param); + case ML_IPC_RATINGCOLUMN_ANIMATE: return (INT_PTR)OnIPC_RatingColumn_Animate((RATINGCOLUMN*)param); + case ML_IPC_RATINGCOLUMN_GETMINWIDTH: return (INT_PTR)OnIPC_RatingColumn_GetMinWidth(); + case ML_IPC_RATINGCOLUMN_FILLBACKSTRING: return (INT_PTR)OnIPC_RatingColumn_FillBackString((RATINGBACKTEXT*)param); + case ML_IPC_RATINGCOLUMN_GETWIDTH: return (INT_PTR)OnIPC_RatingColumn_GetWidth((RATINGWIDTH*)param); + + case ML_IPC_CLOUDCOLUMN_PAINT: return (INT_PTR)OnIPC_CloudColumn_Paint((RATINGCOLUMNPAINT*)param); + case ML_IPC_CLOUDCOLUMN_GETMINWIDTH: return (INT_PTR)OnIPC_CloudColumn_GetMinWidth(); + case ML_IPC_CLOUDCOLUMN_GETWIDTH: return (INT_PTR)OnIPC_CloudColumn_GetWidth((INT*)param); + + case ML_IPC_CREATEWEBINFO: return (INT_PTR)OnIPC_CreateWebInfo((WEBINFOCREATE*)param); + case ML_IPC_CREATEFILEVIEW: return (INT_PTR)OnIPC_CreateFileView((MLFILEVIEWCREATESTRUCT*)param); + } + return 0; +}
\ No newline at end of file |