941 lines
23 KiB
C++
941 lines
23 KiB
C++
/** (c) Nullsoft, Inc. C O N F I D E N T I A L
|
|
** Filename: application.cpp
|
|
** Project: Winamp 5
|
|
** Description: Winamp's implementation of Wasabi's Application API.
|
|
** Also includes the main message loop.
|
|
** Author: Ben Allison benski@nullsoft.com
|
|
** Created:
|
|
**/
|
|
#include "main.h"
|
|
#include "application.h"
|
|
#include "../nu/AutoWide.h"
|
|
#include "api.h"
|
|
#include "../nu/ns_wc.h"
|
|
|
|
#define WIDEN2(x) L ## x
|
|
#define WIDEN(x) WIDEN2(x)
|
|
|
|
static UINT WINAMP_WM_DIRECT_MOUSE_WHEEL = WM_NULL;
|
|
static ATOM DIRECT_MOUSE_WHEEL_CONVERT_TO_MOUSE_WHEEL = 0;
|
|
|
|
static BOOL DirectMouseWheel_RegisterMessage()
|
|
{
|
|
WINAMP_WM_DIRECT_MOUSE_WHEEL = RegisterWindowMessageW(L"WINAMP_WM_DIRECT_MOUSE_WHEEL");
|
|
if (WM_NULL == WINAMP_WM_DIRECT_MOUSE_WHEEL)
|
|
return FALSE;
|
|
|
|
if (NULL != application)
|
|
application->DirectMouseWheel_InitBlackList();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
IsDirectMouseWheelMessage(const UINT uMsg)
|
|
{
|
|
if (WM_NULL == WINAMP_WM_DIRECT_MOUSE_WHEEL)
|
|
{
|
|
if (FALSE == DirectMouseWheel_RegisterMessage())
|
|
return FALSE;
|
|
}
|
|
|
|
return (WINAMP_WM_DIRECT_MOUSE_WHEEL == uMsg);
|
|
}
|
|
|
|
BOOL
|
|
DirectMouseWheel_EnableConvertToMouseWheel(HWND hwnd, BOOL enable)
|
|
{
|
|
if (FALSE != enable)
|
|
{
|
|
if (0 == DIRECT_MOUSE_WHEEL_CONVERT_TO_MOUSE_WHEEL)
|
|
{
|
|
DIRECT_MOUSE_WHEEL_CONVERT_TO_MOUSE_WHEEL = GlobalAddAtomW(L"DIRECT_MOUSE_WHEEL_CONVERT_TO_MOUSE_WHEEL");
|
|
if (0 == DIRECT_MOUSE_WHEEL_CONVERT_TO_MOUSE_WHEEL)
|
|
return FALSE;
|
|
}
|
|
|
|
if (0 == SetPropW(hwnd, (const wchar_t*)MAKEINTATOM(DIRECT_MOUSE_WHEEL_CONVERT_TO_MOUSE_WHEEL), (HANDLE)1))
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
if (0 != DIRECT_MOUSE_WHEEL_CONVERT_TO_MOUSE_WHEEL)
|
|
RemovePropW(hwnd, (const wchar_t*)MAKEINTATOM(DIRECT_MOUSE_WHEEL_CONVERT_TO_MOUSE_WHEEL));
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
DirectMouseWheel_IsConvertToMouseWheelEnabled(HWND hwnd)
|
|
{
|
|
return(0 != DIRECT_MOUSE_WHEEL_CONVERT_TO_MOUSE_WHEEL &&
|
|
NULL != GetPropW(hwnd, (const wchar_t*)MAKEINTATOM(DIRECT_MOUSE_WHEEL_CONVERT_TO_MOUSE_WHEEL)));
|
|
}
|
|
|
|
Application::Application()
|
|
: shuttingdown(0), activeDialog(NULL), machineID(GUID_NULL), userID(GUID_NULL), sessionID(GUID_NULL),
|
|
threadStorageIndex(TLS_OUT_OF_INDEXES), messageHook(NULL), disableMessageHook(false)
|
|
{
|
|
tlsIndex = TlsAlloc();
|
|
}
|
|
|
|
Application::~Application()
|
|
{
|
|
if (NULL != messageHook)
|
|
{
|
|
UnhookWindowsHookEx(messageHook);
|
|
messageHook = NULL;
|
|
}
|
|
}
|
|
|
|
const wchar_t *Application::main_getAppName()
|
|
{
|
|
return WIDEN(APP_NAME);
|
|
}
|
|
|
|
const wchar_t *Application::main_getVersionString()
|
|
{
|
|
return WIDEN(APP_NAME) L" " WIDEN(APP_VERSION_STRING);
|
|
}
|
|
|
|
const wchar_t *Application::main_getVersionNumString()
|
|
{
|
|
return WIDEN(APP_VERSION);
|
|
}
|
|
|
|
unsigned int Application::main_getBuildNumber()
|
|
{
|
|
return BUILD_NUMBER;
|
|
}
|
|
|
|
// a guid for our app : {4BE592C7-6937-426a-A388-ACF0EBC88E93}
|
|
static const GUID WinampGUID =
|
|
{
|
|
0x4be592c7, 0x6937, 0x426a, { 0xa3, 0x88, 0xac, 0xf0, 0xeb, 0xc8, 0x8e, 0x93 }
|
|
};
|
|
|
|
GUID Application::main_getGUID()
|
|
{
|
|
return WinampGUID;
|
|
}
|
|
|
|
HANDLE Application::main_getMainThreadHandle()
|
|
{
|
|
if (hMainThread == 0)
|
|
return (HANDLE)0;
|
|
HANDLE h = (HANDLE)0;
|
|
DuplicateHandle(GetCurrentProcess(), hMainThread, GetCurrentProcess(), &h, 0, FALSE, DUPLICATE_SAME_ACCESS);
|
|
return h;
|
|
}
|
|
|
|
HINSTANCE Application::main_gethInstance()
|
|
{
|
|
return hMainInstance;
|
|
}
|
|
|
|
const wchar_t *Application::main_getCommandLine()
|
|
{
|
|
return GetCommandLineW();
|
|
}
|
|
|
|
void Application::main_shutdown(int deferred)
|
|
{
|
|
|
|
int x = static_cast<int>(SendMessageW(hMainWindow, WM_WA_IPC, 0, IPC_IS_EXIT_ENABLED));
|
|
|
|
if (!x)
|
|
return;
|
|
|
|
shuttingdown = 1;
|
|
|
|
SendMessageW(hMainWindow, WM_CLOSE, 0, 0);
|
|
}
|
|
|
|
void Application::main_cancelShutdown()
|
|
{
|
|
shuttingdown = 0;
|
|
}
|
|
|
|
int Application::main_isShuttingDown()
|
|
{
|
|
return shuttingdown;
|
|
}
|
|
|
|
const wchar_t *Application::path_getAppPath()
|
|
{
|
|
return PROGDIR;
|
|
}
|
|
|
|
const wchar_t *Application::path_getUserSettingsPath()
|
|
{
|
|
return CONFIGDIR;
|
|
}
|
|
|
|
const wchar_t *Application::path_getSkinSettingsPath()
|
|
{
|
|
return SKINDIR;
|
|
}
|
|
|
|
int Application::app_getInitCount()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
void Application::app_addMessageProcessor(api_messageprocessor *processor)
|
|
{
|
|
messageProcessors.push_back(processor);
|
|
}
|
|
|
|
void Application::app_removeMessageProcessor(api_messageprocessor *processor)
|
|
{
|
|
//messageProcessors.eraseAll(processor);
|
|
auto it = messageProcessors.begin();
|
|
while (it != messageProcessors.end())
|
|
{
|
|
if (*it != processor)
|
|
{
|
|
it++;
|
|
continue;
|
|
}
|
|
|
|
it = messageProcessors.erase(it);
|
|
}
|
|
}
|
|
|
|
void Application::app_addModelessDialog(HWND hwnd)
|
|
{
|
|
OutputDebugStringA( "[Error] 'app_addModelessDialog' removed! Use 'ActiveDialog_Register' instead!\r\n" );
|
|
}
|
|
|
|
void Application::app_removeModelessDialog(HWND hwnd)
|
|
{
|
|
OutputDebugStringA( "[Error] 'app_removeModelessDialog' removed!Use 'ActiveDialog_Unregister' instead!\r\n" );
|
|
}
|
|
|
|
void Application::app_addAccelerators(HWND hwnd, HACCEL *phAccel, INT cAccel, UINT translateMode)
|
|
{
|
|
AccelMap::iterator accelIterator;
|
|
ACCELNODE *pList;
|
|
|
|
if (accelerators.size() > 0)
|
|
{
|
|
accelIterator = accelerators.end();
|
|
do
|
|
{
|
|
accelIterator--;
|
|
if (!IsWindow(accelIterator->first))
|
|
{
|
|
//app_removeAccelerators(accelIterator->first);
|
|
ACCELNODE* pList, * pNode;
|
|
pList = accelIterator->second;
|
|
while (pList)
|
|
{
|
|
pNode = pList;
|
|
pList = (pList->pNext) ? pList->pNext : NULL;
|
|
free(pNode);
|
|
}
|
|
accelIterator = accelerators.erase(accelIterator);
|
|
}
|
|
} while (accelIterator != accelerators.begin() && accelIterator != accelerators.end());
|
|
}
|
|
|
|
if (!IsWindow(hwnd) || !phAccel || cAccel <= 0) return;
|
|
|
|
accelIterator = accelerators.find(hwnd);
|
|
if(accelIterator != accelerators.end())
|
|
pList = accelIterator->second;
|
|
else
|
|
{
|
|
pList = (ACCELNODE*)calloc(1, sizeof(ACCELNODE));
|
|
if(pList)
|
|
{
|
|
accelerators.insert({hwnd, pList});
|
|
}
|
|
}
|
|
if (!pList) return;
|
|
while (pList->pNext) pList = pList->pNext;
|
|
|
|
while(cAccel--)
|
|
{
|
|
if (*phAccel)
|
|
{
|
|
ACCELNODE *pNode;
|
|
if (pList->hAccel)
|
|
{
|
|
pNode = (ACCELNODE*)calloc(1, sizeof(ACCELNODE));
|
|
pNode->pNext = NULL;
|
|
pList->pNext = pNode;
|
|
pList = pNode;
|
|
}
|
|
else pNode = pList;
|
|
|
|
pNode->hAccel = *phAccel;
|
|
pNode->translateMode = translateMode;
|
|
|
|
}
|
|
phAccel++;
|
|
}
|
|
}
|
|
|
|
void Application::app_removeAccelerators(HWND hwnd)
|
|
{
|
|
AccelMap::iterator iter = accelerators.find(hwnd);
|
|
if(iter == accelerators.end())
|
|
return;
|
|
|
|
ACCELNODE *pList, *pNode;
|
|
pList = iter->second;
|
|
while(pList)
|
|
{
|
|
pNode = pList;
|
|
pList = (pList->pNext) ? pList->pNext : NULL;
|
|
free(pNode);
|
|
}
|
|
accelerators.erase(hwnd);
|
|
}
|
|
|
|
int Application::app_getAccelerators(HWND hwnd, HACCEL *phAccel, INT cchAccelMax, BOOL bGlobal)
|
|
{
|
|
|
|
if (!hwnd || 0 == accelerators.size()) return 0;
|
|
if ((!phAccel && cchAccelMax) || (phAccel && !cchAccelMax)) return 0;
|
|
|
|
AccelMap::iterator accelIterator = accelerators.end();
|
|
INT count = 0;
|
|
|
|
do
|
|
{
|
|
accelIterator--;
|
|
for (ACCELNODE *pNode = accelIterator->second; NULL != pNode; pNode = pNode->pNext)
|
|
{
|
|
if (accelIterator->first == hwnd ||
|
|
(bGlobal && (TRANSLATE_MODE_GLOBAL == pNode->translateMode ||
|
|
(TRANSLATE_MODE_CHILD == pNode->translateMode && IsChild(accelIterator->first, hwnd)))))
|
|
{
|
|
if (phAccel && cchAccelMax)
|
|
{
|
|
*phAccel = pNode->hAccel;
|
|
phAccel++;
|
|
cchAccelMax--;
|
|
}
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
while (accelIterator != accelerators.begin() && (!phAccel || cchAccelMax));
|
|
|
|
return count;
|
|
}
|
|
|
|
void Application::app_registerGlobalWindow(HWND hwnd)
|
|
{
|
|
for (std::vector<HWND>::const_iterator e = globalWindows.begin(); e != globalWindows.end(); e++)
|
|
{
|
|
if (*e == hwnd) return;
|
|
}
|
|
globalWindows.push_back(hwnd);
|
|
}
|
|
|
|
void Application::app_unregisterGlobalWindow(HWND hwnd)
|
|
{
|
|
for (std::vector<HWND>::iterator e = globalWindows.begin(); e != globalWindows.end(); e++)
|
|
{
|
|
if (*e == hwnd)
|
|
{
|
|
globalWindows.erase(e);
|
|
return;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
bool Application::FilterMessage(MSG *msg) // returns 1 if you should Dispatch the message, will handle TranslateMessage for you
|
|
{
|
|
if (msg->hwnd != NULL && msg->hwnd != hMainWindow && msg->hwnd != hEQWindow // && msg.hwnd != hMBWindow
|
|
&& msg->hwnd != hPLWindow && msg->hwnd != hVideoWindow)
|
|
{
|
|
HWND hWndParent = NULL;
|
|
HWND temphwnd = msg->hwnd;
|
|
if (GetClassLong(temphwnd, GCW_ATOM) == (INT)32770)
|
|
hWndParent = temphwnd;
|
|
|
|
/*while (*/temphwnd = GetParent(temphwnd)/*)*/ ;
|
|
{
|
|
if (GetClassLong(temphwnd, GCW_ATOM) == (INT)32770)
|
|
hWndParent = temphwnd;
|
|
}
|
|
|
|
if (NULL != hWndParent)
|
|
{
|
|
BOOL processed;
|
|
|
|
disableMessageHook = true;
|
|
processed = IsDialogMessageW(hWndParent, msg);
|
|
disableMessageHook = false;
|
|
|
|
if (FALSE != processed)
|
|
return true;
|
|
}
|
|
|
|
//if (msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN ||
|
|
// msg->message == WM_KEYUP || msg->message == WM_SYSKEYUP)
|
|
//{
|
|
//if (IsChild(hMBWindow,msg.hwnd) && TranslateAccelerator(hMBWindow,hAccel[3],&msg)) continue;
|
|
TranslateMessage(msg);
|
|
//}
|
|
}
|
|
return false;
|
|
}
|
|
bool Application::isGlobalWindow(HWND hwnd)
|
|
{
|
|
for (std::vector<HWND>::const_iterator e = globalWindows.begin(); e != globalWindows.end(); e++)
|
|
{
|
|
if (*e == hwnd || IsChild(*e, hwnd)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Application::app_translateAccelerators(MSG *msg)
|
|
{
|
|
if (accelerators.size() > 0)
|
|
{
|
|
AccelMap::iterator accelIterator = accelerators.end();
|
|
do
|
|
{
|
|
accelIterator--;
|
|
for (ACCELNODE *pNode = accelIterator->second; NULL != pNode; pNode = pNode->pNext)
|
|
{
|
|
if (((TRANSLATE_MODE_GLOBAL == pNode->translateMode && isGlobalWindow(msg->hwnd)) ||
|
|
accelIterator->first == msg->hwnd ||
|
|
(TRANSLATE_MODE_CHILD == pNode->translateMode && IsChild(accelIterator->first, msg->hwnd))) &&
|
|
TranslateAcceleratorW(accelIterator->first, pNode->hAccel, msg))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
while (accelIterator != accelerators.begin());
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
Application::DirectMouseWheel_RegisterSkipClass(ATOM klass)
|
|
{
|
|
size_t index;
|
|
|
|
if (klass < 0xC000)
|
|
return false;
|
|
|
|
index = directMouseWheelBlackList.size();
|
|
while(index--)
|
|
{
|
|
if (directMouseWheelBlackList[index] == klass)
|
|
return false;
|
|
}
|
|
|
|
directMouseWheelBlackList.push_back(klass);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
Application::DirectMouseWheel_UnregisterSkipClass(ATOM klass)
|
|
{
|
|
size_t index;
|
|
|
|
if (klass < 0xC000)
|
|
return false;
|
|
|
|
index = directMouseWheelBlackList.size();
|
|
while(index--)
|
|
{
|
|
if (directMouseWheelBlackList[index] == klass)
|
|
{
|
|
directMouseWheelBlackList.erase(directMouseWheelBlackList.begin() + index);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
Application::DirectMouseWheel_EnableConvertToMouseWheel(HWND hwnd, BOOL enable)
|
|
{
|
|
return (0 != ::DirectMouseWheel_EnableConvertToMouseWheel(hwnd, enable));
|
|
}
|
|
|
|
void
|
|
Application::DirectMouseWheel_InitBlackList()
|
|
{
|
|
size_t index;
|
|
WNDCLASSW klassInfo;
|
|
ATOM klassAtom;
|
|
|
|
const static LPCWSTR defaultBlackListNames[] =
|
|
{
|
|
L"msctls_trackbar32",
|
|
L"msctls_updown32",
|
|
L"SysHeader32",
|
|
};
|
|
|
|
const static ATOM defaultBlackListAtoms[] =
|
|
{
|
|
0xC017, // button
|
|
0xC018, // edit
|
|
0xC019, // static
|
|
0xC01C, // combobox
|
|
};
|
|
|
|
for (index = 0; index < ARRAYSIZE(defaultBlackListAtoms); index++)
|
|
{
|
|
directMouseWheelBlackList.push_back(defaultBlackListAtoms[index]);
|
|
}
|
|
|
|
for (index = 0; index < ARRAYSIZE(defaultBlackListNames); index++)
|
|
{
|
|
klassAtom = (ATOM)GetClassInfoW(NULL, defaultBlackListNames[index], &klassInfo);
|
|
if (0 != klassAtom)
|
|
directMouseWheelBlackList.push_back(klassAtom);
|
|
}
|
|
}
|
|
|
|
bool
|
|
Application::DirectMouseWheel_ProccessMessage(MSG *msg)
|
|
{
|
|
HWND targetWindow;
|
|
ATOM targetAtom;
|
|
DWORD targetProcessId;
|
|
POINT mousePoint;
|
|
size_t index, listSize;
|
|
|
|
if (msg->message != WM_MOUSEWHEEL)
|
|
return false;
|
|
|
|
if (WM_NULL == WINAMP_WM_DIRECT_MOUSE_WHEEL)
|
|
{
|
|
if (FALSE == DirectMouseWheel_RegisterMessage())
|
|
return false;
|
|
}
|
|
|
|
POINTSTOPOINT(mousePoint, msg->lParam);
|
|
targetWindow = WindowFromPoint(mousePoint);
|
|
|
|
if (NULL == targetWindow || targetWindow == msg->hwnd)
|
|
return false;
|
|
|
|
GetWindowThreadProcessId(targetWindow, &targetProcessId);
|
|
if (targetProcessId != GetCurrentProcessId())
|
|
return false;
|
|
|
|
if (FALSE == IsWindowEnabled(targetWindow))
|
|
return false;
|
|
|
|
listSize = directMouseWheelBlackList.size();
|
|
index = 0;
|
|
|
|
while(index != listSize)
|
|
{
|
|
targetAtom = (ATOM)GetClassLongPtrW(targetWindow, GCW_ATOM);
|
|
for(index = 0; index < listSize; index++)
|
|
{
|
|
if (targetAtom == directMouseWheelBlackList[index])
|
|
{
|
|
targetWindow = GetAncestor(targetWindow, GA_PARENT);
|
|
if (NULL == targetWindow || targetWindow == msg->hwnd)
|
|
return false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (FALSE != DirectMouseWheel_IsConvertToMouseWheelEnabled(targetWindow))
|
|
{
|
|
SendMessageW(targetWindow, WM_MOUSEWHEEL, msg->wParam, msg->lParam);
|
|
return true;
|
|
}
|
|
else if (0 != SendMessageW(targetWindow, WINAMP_WM_DIRECT_MOUSE_WHEEL, msg->wParam, msg->lParam))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
HWND ActiveChildWindowFromPoint( HWND hwnd, POINTS cursor_s, const int *controls, size_t controlsCount )
|
|
{
|
|
POINT pt;
|
|
RECT controlRect;
|
|
HWND controlWindow;
|
|
|
|
POINTSTOPOINT( pt, cursor_s );
|
|
|
|
while ( controlsCount-- )
|
|
{
|
|
controlWindow = GetDlgItem( hwnd, controls[ controlsCount ] );
|
|
|
|
if ( controlWindow != NULL && GetClientRect( controlWindow, &controlRect ) != FALSE )
|
|
{
|
|
MapWindowPoints( controlWindow, HWND_DESKTOP, (POINT *) &controlRect, 2 );
|
|
|
|
if ( PtInRect( &controlRect, pt ) != FALSE )
|
|
{
|
|
unsigned long windowStyle = (unsigned long) GetWindowLongPtrW( controlWindow, GWL_STYLE );
|
|
|
|
if ( ( ( WS_VISIBLE | WS_DISABLED ) & windowStyle ) == WS_VISIBLE )
|
|
return controlWindow;
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
BOOL DirectMouseWheel_ProcessDialogMessage(HWND hwnd, unsigned int uMsg, WPARAM wParam, LPARAM lParam, const int controls[], int controlslen)
|
|
{
|
|
if (FALSE != ::IsDirectMouseWheelMessage(uMsg))
|
|
{
|
|
HWND targetWindow = ::ActiveChildWindowFromPoint(hwnd, MAKEPOINTS(lParam), controls, controlslen);
|
|
if (NULL != targetWindow)
|
|
{
|
|
SendMessageW(targetWindow, WM_MOUSEWHEEL, wParam, lParam);
|
|
SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, (long)TRUE);
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL Application::DirectMouseWheel_ProcessDialogMessage(HWND hwnd, unsigned int uMsg, WPARAM wParam, LPARAM lParam, const int controls[], int controlslen)
|
|
{
|
|
return ::DirectMouseWheel_ProcessDialogMessage(hwnd, uMsg, wParam, lParam, controls, controlslen);
|
|
}
|
|
|
|
void Application::ActiveDialog_Register(HWND hwnd)
|
|
{
|
|
activeDialog = hwnd;
|
|
}
|
|
|
|
void Application::ActiveDialog_Unregister(HWND hwnd)
|
|
{
|
|
if (hwnd == activeDialog)
|
|
activeDialog = NULL;
|
|
}
|
|
|
|
HWND Application::ActiveDialog_Get()
|
|
{
|
|
return activeDialog;
|
|
}
|
|
|
|
/* Plugins can register a 'Message Processor' to tap into the main message loop
|
|
for some purposes (Dialog message handling, ActiveX/ATL/COM, wxWidgets)
|
|
this is the only way to make sure all messages are processed correctly
|
|
@see api_application::app_addMessageProcessor() and api_messageprocessor.h
|
|
*/
|
|
|
|
bool Application::ProcessMessageLight( MSG *msg )
|
|
{
|
|
/* messageProcessors is the list of registered Message Processors */
|
|
for ( api_messageprocessor *processor : messageProcessors )
|
|
{
|
|
disableMessageHook = true;
|
|
|
|
if ( processor->ProcessMessage( msg ) ) // it'll return true if it wants to eat the message
|
|
{
|
|
disableMessageHook = false;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
disableMessageHook = false;
|
|
|
|
if ( false != DirectMouseWheel_ProccessMessage( msg ) )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool Application::ProcessMessage( MSG *msg )
|
|
{
|
|
if ( ProcessMessageLight( msg ) != false )
|
|
return true;
|
|
|
|
if ( ( msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN ) && app_translateAccelerators( msg ) )
|
|
return true;
|
|
|
|
|
|
if ( activeDialog != NULL )
|
|
{
|
|
disableMessageHook = true;
|
|
|
|
if ( IsDialogMessageW( activeDialog, msg ) != FALSE )
|
|
{
|
|
disableMessageHook = false;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
disableMessageHook = false;
|
|
|
|
return false;
|
|
}
|
|
|
|
intptr_t Application::app_messageLoopStep()
|
|
{
|
|
MSG msg;
|
|
|
|
if (PeekMessageW(&msg, NULL, 0, 0, TRUE))
|
|
{
|
|
if (msg.message == WM_QUIT)
|
|
{
|
|
PostQuitMessage((int)msg.wParam);
|
|
return msg.wParam ; // abandoned due to WM_QUIT
|
|
}
|
|
|
|
if (!ProcessMessage(&msg) && !FilterMessage(&msg))
|
|
DispatchMessageW(&msg);
|
|
|
|
if (WM_NCDESTROY == msg.message)
|
|
DirectMouseWheel_EnableConvertToMouseWheel(msg.hwnd, FALSE);
|
|
|
|
return msg.wParam;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
LRESULT CALLBACK Application::MessageHookProc( INT code, WPARAM wParam, LPARAM lParam )
|
|
{
|
|
if ( application == NULL || application->messageHook == NULL )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ( application->disableMessageHook == false )
|
|
{
|
|
switch ( code )
|
|
{
|
|
case MSGF_DIALOGBOX:
|
|
case MSGF_MESSAGEBOX:
|
|
if ( false != application->ProcessMessageLight( (MSG *) lParam ) )
|
|
return 1;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
application->disableMessageHook = false;
|
|
|
|
return CallNextHookEx( application->messageHook, code, wParam, lParam );
|
|
}
|
|
|
|
WPARAM Application::MessageLoop()
|
|
{
|
|
if ( messageHook == NULL )
|
|
messageHook = SetWindowsHookEx( WH_MSGFILTER, MessageHookProc, NULL, GetCurrentThreadId() );
|
|
|
|
for ( ;;)
|
|
{
|
|
DWORD dwStatus = MsgWaitForMultipleObjectsEx( 0, NULL, INFINITE, QS_ALLINPUT, MWMO_ALERTABLE | MWMO_INPUTAVAILABLE );
|
|
|
|
if ( dwStatus == WAIT_OBJECT_0 )
|
|
{
|
|
MSG msg;
|
|
while ( PeekMessageW( &msg, NULL, 0, 0, PM_REMOVE ) )
|
|
{
|
|
if ( msg.message == WM_QUIT )
|
|
return msg.wParam;
|
|
|
|
if ( !ProcessMessage( &msg ) && !FilterMessage( &msg ) )
|
|
DispatchMessageW( &msg );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
WPARAM WinampMessageLoop()
|
|
{
|
|
return WASABI_API_APP->MessageLoop();
|
|
}
|
|
|
|
const wchar_t *Application::path_getWorkingPath()
|
|
{
|
|
return config_cwd;
|
|
}
|
|
|
|
void Application::path_setWorkingPath(const wchar_t *newPath)
|
|
{
|
|
StringCchCopyW(config_cwd, MAX_PATH, newPath);
|
|
}
|
|
|
|
/*
|
|
int Application::GetMachineID(GUID *id)
|
|
{
|
|
// TODO: stuff this in the registry
|
|
if (machineID == GUID_NULL)
|
|
{
|
|
if (!GetPrivateProfileStruct(app_name, "mid", (LPVOID)&machineID, sizeof(machineID), INI_FILE) || machineID == GUID_NULL)
|
|
{
|
|
UuidCreate(&machineID);
|
|
WritePrivateProfileStruct(app_name, "mid", (LPVOID)&machineID, sizeof(machineID), INI_FILE);
|
|
}
|
|
}
|
|
|
|
*id = machineID;
|
|
return API_APPLICATION_SUCCESS;
|
|
}
|
|
*/
|
|
int Application::GetUserID(GUID *id)
|
|
{
|
|
if (userID == GUID_NULL)
|
|
{
|
|
config_uid_ft = (char)GetPrivateProfileIntW(L"Winamp", L"uid_ft", 0, INI_FILE);
|
|
|
|
wchar_t uid_str[512] = {0};
|
|
if (!GetPrivateProfileStructA(app_name, "uid", (LPVOID)&userID, sizeof(userID), INI_FILEA) || userID == GUID_NULL)
|
|
{
|
|
// attempt to restore the client uid after an uninstall, lost config file, etc
|
|
readwrite_client_uid(0, uid_str);
|
|
if (uid_str[0])
|
|
{
|
|
WritePrivateProfileStringW(AutoWide(app_name), L"uid", uid_str, INI_FILE);
|
|
}
|
|
|
|
if (!GetPrivateProfileStructA(app_name, "uid", (LPVOID)&userID, sizeof(userID), INI_FILEA) || userID == GUID_NULL)
|
|
{
|
|
UuidCreate(&userID);
|
|
WritePrivateProfileStructA(app_name, "uid", (LPVOID)&userID, sizeof(userID), INI_FILEA);
|
|
GetPrivateProfileStringW(AutoWide(app_name), L"uid", L"", uid_str, ARRAYSIZE(uid_str), INI_FILE);
|
|
readwrite_client_uid(1, uid_str);
|
|
// if done then no need to re-do it at a later point
|
|
config_uid_ft = 1;
|
|
}
|
|
}
|
|
|
|
// and just to make sure, if this is like a new run then we'll need to force into the registry
|
|
if (!config_uid_ft)
|
|
{
|
|
config_uid_ft = 1;
|
|
GetPrivateProfileStringW(AutoWide(app_name), L"uid", L"", uid_str, ARRAYSIZE(uid_str), INI_FILE);
|
|
readwrite_client_uid(1, uid_str);
|
|
}
|
|
}
|
|
|
|
*id = userID;
|
|
|
|
return API_APPLICATION_SUCCESS;
|
|
}
|
|
|
|
int Application::GetSessionID(GUID *id)
|
|
{
|
|
if (sessionID == GUID_NULL)
|
|
UuidCreate(&sessionID);
|
|
|
|
*id = sessionID;
|
|
return API_APPLICATION_SUCCESS;
|
|
}
|
|
|
|
size_t Application::AllocateThreadStorage()
|
|
{
|
|
return (size_t)InterlockedIncrement(&threadStorageIndex);
|
|
}
|
|
|
|
void *Application::GetThreadStorage(size_t index)
|
|
{
|
|
std::vector<void*> *ptrlist = (std::vector<void*> *)TlsGetValue(tlsIndex);
|
|
if (!ptrlist)
|
|
return 0;
|
|
|
|
if ((index+1) > ptrlist->size())
|
|
return 0;
|
|
|
|
return ptrlist->at(index);
|
|
}
|
|
|
|
void Application::SetThreadStorage(size_t index, void *value)
|
|
{
|
|
std::vector<void*> *ptrlist = (std::vector<void*> *)TlsGetValue(tlsIndex);
|
|
if (!ptrlist)
|
|
{
|
|
ptrlist = new std::vector<void*>;
|
|
TlsSetValue(tlsIndex, ptrlist);
|
|
}
|
|
size_t ptrlist_size = ptrlist->size();
|
|
if ((index+1) > ptrlist_size)
|
|
{
|
|
ptrlist->reserve(index+1);
|
|
for (size_t i=ptrlist_size;i<=index;i++)
|
|
{
|
|
ptrlist->push_back(0);
|
|
}
|
|
}
|
|
ptrlist->at(index) = value;
|
|
}
|
|
|
|
const wchar_t *Application::getATFString()
|
|
{
|
|
return config_titlefmt;
|
|
}
|
|
|
|
int Application::getScaleX(int x)
|
|
{
|
|
return ScaleX(x);
|
|
}
|
|
|
|
int Application::getScaleY(int y)
|
|
{
|
|
return ScaleY(y);
|
|
}
|
|
|
|
#define CBCLASS Application
|
|
START_DISPATCH;
|
|
CB(API_APPLICATION_MAIN_GETAPPNAME, main_getAppName)
|
|
CB(API_APPLICATION_MAIN_GETVERSIONSTRING, main_getVersionString)
|
|
CB(API_APPLICATION_MAIN_GETVERSIONSTRING2, main_getVersionNumString)
|
|
CB(API_APPLICATION_MAIN_GETBUILDNUMBER, main_getBuildNumber)
|
|
CB(API_APPLICATION_MAIN_GETGUID, main_getGUID)
|
|
CB(API_APPLICATION_MAIN_GETMAINTHREADHANDLE, main_getMainThreadHandle)
|
|
CB(API_APPLICATION_MAIN_GETHINSTANCE, main_gethInstance)
|
|
CB(API_APPLICATION_MAIN_GETCOMMANDLINE, main_getCommandLine)
|
|
VCB(API_APPLICATION_MAIN_SHUTDOWN, main_shutdown)
|
|
VCB(API_APPLICATION_MAIN_CANCELSHUTDOWN, main_cancelShutdown)
|
|
CB(API_APPLICATION_MAIN_ISSHUTTINGDOWN, main_isShuttingDown)
|
|
CB(API_APPLICATION_PATH_GETAPPPATH, path_getAppPath)
|
|
CB(API_APPLICATION_PATH_GETUSERSETTINGSPATH, path_getUserSettingsPath)
|
|
CB(API_APPLICATION_PATH_GETSKINSETTINGSPATH, path_getSkinSettingsPath)
|
|
CB(API_APPLICATION_APP_GETINITCOUNT, app_getInitCount)
|
|
CB(API_APPLICATION_APP_MESSAGELOOPSTEP, app_messageLoopStep)
|
|
VCB(API_APPLICATION_APP_ADDMESSAGEPROCESSOR, app_addMessageProcessor)
|
|
VCB(API_APPLICATION_APP_REMOVEMESSAGEPROCESSOR, app_removeMessageProcessor)
|
|
VCB(API_APPLICATION_APP_ADDMODELESSDIALOG, app_addModelessDialog)
|
|
VCB(API_APPLICATION_APP_REMOVEMODELESSDIALOG, app_removeModelessDialog)
|
|
VCB(API_APPLICATION_APP_ADDACCELERATORS, app_addAccelerators)
|
|
VCB(API_APPLICATION_APP_REMOVEACCELERATORS, app_removeAccelerators)
|
|
CB(API_APPLICATION_APP_TRANSLATEACCELERATORS, app_translateAccelerators);
|
|
CB(API_APPLICATION_APP_GETACCELERATORS, app_getAccelerators);
|
|
VCB(API_APPLICATION_APP_REGISTERGLOBALWINDOW, app_registerGlobalWindow);
|
|
VCB(API_APPLICATION_APP_UNREGISTERGLOBALWINDOW, app_unregisterGlobalWindow);
|
|
CB(API_APPLICATION_PATH_GETWORKINGPATH, path_getWorkingPath);
|
|
VCB(API_APPLICATION_PATH_SETWORKINGPATH, path_setWorkingPath);
|
|
CB(API_APPLICATION_DIRECTMOUSEWHEEL_REGISTERSKIPCLASS, DirectMouseWheel_RegisterSkipClass);
|
|
CB(API_APPLICATION_DIRECTMOUSEWHEEL_UNREGISTERSKIPCLASS, DirectMouseWheel_UnregisterSkipClass);
|
|
CB(API_APPLICATION_DIRECTMOUSEWHEEL_ENABLECONVERTTOMOUSEWHEEL, DirectMouseWheel_EnableConvertToMouseWheel);
|
|
CB(API_APPLICATION_DIRECTMOUSEWHEEL_PROCESSDIALOGMESSAGE, DirectMouseWheel_ProcessDialogMessage);
|
|
VCB(API_APPLICATION_ACTIVEDIALOG_REGISTER, ActiveDialog_Register);
|
|
VCB(API_APPLICATION_ACTIVEDIALOG_UNREGISTER, ActiveDialog_Unregister);
|
|
CB(API_APPLICATION_ACTIVEDIALOG_GET, ActiveDialog_Get);
|
|
/*
|
|
CB(API_APPLICATION_GETMACHINEID, GetMachineID);
|
|
*/
|
|
CB(API_APPLICATION_GETUSERID, GetUserID);
|
|
CB(API_APPLICATION_GETSESSIONID, GetSessionID);
|
|
CB(API_APPLICATION_ALLOCATETHREADSTORAGE, AllocateThreadStorage);
|
|
CB(API_APPLICATION_GETTHREADSTORAGE, GetThreadStorage);
|
|
VCB(API_APPLICATION_SETTHREADSTORAGE, SetThreadStorage);
|
|
CB(API_APPLICATION_GETATFSTRING, getATFString);
|
|
CB(API_APPLICATION_GETSCALEX, getScaleX);
|
|
CB(API_APPLICATION_GETSCALEY, getScaleY);
|
|
END_DISPATCH;
|
|
#undef CBCLASS |