void UninitPasteSerial()
{
bInitPasteSerial=FALSE;
if (nHotkeyDelimSkipID)
{
if (UnregisterHotKey(hMainWnd, nHotkeyDelimSkipID))
{
GlobalDeleteAtom(nHotkeyDelimSkipID);
nHotkeyDelimSkipID=0;
}
}
if (nHotkeyDelimAsTabID)
{
if (UnregisterHotKey(hMainWnd, nHotkeyDelimAsTabID))
{
GlobalDeleteAtom(nHotkeyDelimAsTabID);
nHotkeyDelimAsTabID=0;
}
}
if (nHotkeyDelimAsIsID)
{
if (UnregisterHotKey(hMainWnd, nHotkeyDelimAsIsID))
{
GlobalDeleteAtom(nHotkeyDelimAsIsID);
nHotkeyDelimAsIsID=0;
}
}
}
static HGLOBAL DoDdeRequest(const char *szItemName, HWND hwndDlg)
{
DWORD timeoutTick, thisTick;
MSG msg;
ATOM hSzItemName = GlobalAddAtomA(szItemName);
if ( !PostMessage(hwndDde, WM_DDE_REQUEST, (WPARAM)hwndDlg, MAKELPARAM(CF_TEXT, hSzItemName))) {
GlobalDeleteAtom(hSzItemName);
return NULL;
}
timeoutTick = GetTickCount()+5000;
ddeData = 0; ddeAcked = 0;
do {
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
if (ddeData || ddeAcked) break;
thisTick = GetTickCount();
if (thisTick>timeoutTick) break;
}
while (MsgWaitForMultipleObjects(0, NULL, FALSE, timeoutTick-thisTick, QS_ALLINPUT) == WAIT_OBJECT_0);
if ( !ddeData) {
GlobalDeleteAtom(hSzItemName);
return NULL;
}
return hGlobalDdeData;
}
static LRESULT DdeMessage(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
UINT_PTR hSzItem;
switch(msg) {
case WM_DDE_ACK:
ddeAcked = 1;
hwndDde = (HWND)wParam;
break;
case WM_DDE_DATA:
UnpackDDElParam(msg, lParam, (PUINT_PTR)&hGlobalDdeData, (PUINT_PTR)&hSzItem);
ddeData = 1;
if (hGlobalDdeData) {
DDEDATA* data = (DDEDATA*)GlobalLock(hGlobalDdeData);
if (data->fAckReq) {
DDEACK ack = {0};
PostMessage((HWND)wParam, WM_DDE_ACK, (WPARAM)hwndDlg, PackDDElParam(WM_DDE_ACK, *(PUINT)&ack, hSzItem));
}
else GlobalDeleteAtom((ATOM)hSzItem);
GlobalUnlock(hGlobalDdeData);
}
else GlobalDeleteAtom((ATOM)hSzItem);
break;
}
return 0;
}
void Hotkey::End()
{
stop_scan();
GlobalDeleteAtom(ScanHotKeyId);
stop_mainwindow();
GlobalDeleteAtom(MainWindowHotKeyId);
DestroyWindow(ServerWND);
}
void bm_Cleanup(HINSTANCE hInstance)
{
GlobalDeleteAtom(atomAlignStyle);
GlobalDeleteAtom(atomTailSize);
GlobalDeleteAtom(atomTimeout);
GlobalDeleteAtom(atomFont);
UnregisterClass(CLASSNAME_TOOLTIP,hInstance);
}
/******************************************************************
* WDML_HandleRequestReply
*
*
*/
static WDML_QUEUE_STATE WDML_HandleRequestReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct, DWORD *ack)
{
DDEACK ddeAck;
WINE_DDEHEAD wdh;
UINT_PTR uiLo, uiHi;
HSZ hsz;
if (WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
return WDML_QS_PASS;
switch (msg->message)
{
case WM_DDE_ACK:
UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
FreeDDElParam(WM_DDE_ACK, msg->lParam);
GlobalDeleteAtom(uiHi);
if (ack) *ack = uiLo;
WDML_ExtractAck(uiLo, &ddeAck);
pXAct->hDdeData = 0;
if (ddeAck.fAck)
ERR("Positive answer should appear in NACK for a request, assuming negative\n");
TRACE("Negative answer...\n");
break;
case WM_DDE_DATA:
UnpackDDElParam(WM_DDE_DATA, msg->lParam, &uiLo, &uiHi);
TRACE("Got the result (%08lx)\n", uiLo);
hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
if (DdeCmpStringHandles(hsz, pXAct->hszItem) != 0)
return WDML_QS_PASS;
pXAct->hDdeData = WDML_Global2DataHandle(pConv, (HGLOBAL)uiLo, &wdh);
if (wdh.fRelease)
{
GlobalFree((HGLOBAL)uiLo);
}
if (wdh.fAckReq)
{
pConv->instance->lastError = DMLERR_MEMORY_ERROR;
}
else
{
GlobalDeleteAtom(uiHi);
FreeDDElParam(WM_DDE_ACK, msg->lParam);
}
break;
default:
FreeDDElParam(msg->message, msg->lParam);
return WDML_QS_PASS;
}
return WDML_QS_HANDLED;
}
//see Q160957 and http://developer.netscape.com/docs/manuals/communicator/DDE/index.htm
static void GetOpenBrowserUrlsForBrowser(const char *szBrowser, HWND hwndDlg, HWND hwndCombo)
{
int windowCount, i;
DWORD *windowId;
DWORD dwResult;
ATOM hSzBrowser = GlobalAddAtomA(szBrowser);
ATOM hSzTopic = GlobalAddAtomA("WWW_ListWindows");
ddeAcked = 0;
if ( !SendMessageTimeout(HWND_BROADCAST, WM_DDE_INITIATE, (WPARAM)hwndDlg, MAKELPARAM(hSzBrowser, hSzTopic), SMTO_ABORTIFHUNG|SMTO_NORMAL, DDEMESSAGETIMEOUT, (PDWORD_PTR)&dwResult)
|| !ddeAcked) {
GlobalDeleteAtom(hSzTopic);
GlobalDeleteAtom(hSzBrowser);
return;
}
HGLOBAL hData = DoDdeRequest("WWW_ListWindows", hwndDlg);
if (hData == NULL) {
GlobalDeleteAtom(hSzTopic);
GlobalDeleteAtom(hSzBrowser);
return;
}
int dataLength = GlobalSize(hData)-offsetof(DDEDATA, Value);
DDEDATA *data = (DDEDATA*)GlobalLock(hData);
windowCount = dataLength / sizeof(DWORD);
windowId = (PDWORD)mir_alloc(sizeof(DWORD)*windowCount);
memcpy(windowId, data->Value, windowCount*sizeof(DWORD));
GlobalUnlock(hData);
FreeDdeRequestData(hData);
PostMessage(hwndDde, WM_DDE_TERMINATE, (WPARAM)hwndDlg, 0);
GlobalDeleteAtom(hSzTopic);
hSzTopic = GlobalAddAtomA("WWW_GetWindowInfo");
ddeAcked = 0;
if ( !SendMessageTimeout(HWND_BROADCAST, WM_DDE_INITIATE, (WPARAM)hwndDlg, MAKELPARAM(hSzBrowser, hSzTopic), SMTO_ABORTIFHUNG|SMTO_NORMAL, DDEMESSAGETIMEOUT, (PDWORD_PTR)&dwResult)
|| !ddeAcked) {
GlobalDeleteAtom(hSzTopic);
GlobalDeleteAtom(hSzBrowser);
mir_free(windowId);
return;
}
for (i=0;i<windowCount;i++) {
if (windowId[i] == 0) break;
{ char str[16];
mir_snprintf(str, _countof(str), "%d", windowId[i]);
hData = DoDdeRequest(str, hwndDlg);
}
if (hData != NULL) {
dataLength = GlobalSize(hData)-offsetof(DDEDATA, Value);
data = (DDEDATA*)GlobalLock(hData);
AddBrowserPageToCombo((char*)data->Value, hwndCombo);
GlobalUnlock(hData);
FreeDdeRequestData(hData);
}
}
PostMessage(hwndDde, WM_DDE_TERMINATE, (WPARAM)hwndDlg, 0);
GlobalDeleteAtom(hSzTopic);
GlobalDeleteAtom(hSzBrowser);
mir_free(windowId);
}
LRESULT OnDDEInitiate(HWND hwnd, WPARAM wparam, LPARAM lparam)
{
ATOM aServer = GlobalAddAtom(PDFSYNC_DDE_SERVICE);
ATOM aTopic = GlobalAddAtom(PDFSYNC_DDE_TOPIC);
if (LOWORD(lparam) == aServer && HIWORD(lparam) == aTopic) {
SendMessage((HWND)wparam, WM_DDE_ACK, (WPARAM)hwnd, MAKELPARAM(aServer, 0));
}
else {
GlobalDeleteAtom(aServer);
GlobalDeleteAtom(aTopic);
}
return 0;
}
static void DDE_StartConversation(HWND hwndClientDDE, LPCSTR szApplication, LPCSTR szTopic)
{
//static BOOL fInInitiate = FALSE;
ATOM atomApplication = *szApplication ? GlobalAddAtom(szApplication) : 0;
ATOM atomTopic = *szTopic ? GlobalAddAtom(szTopic ) : 0;
//fInInitiate = TRUE;
SendMessage(HWND(-1), WM_DDE_INITIATE, WPARAM(hwndClientDDE), MAKELONG(atomApplication, atomTopic));
//fInInitiate = FALSE;
if (atomApplication) GlobalDeleteAtom(atomApplication);
if (atomTopic ) GlobalDeleteAtom(atomTopic );
}
/* DllMain is invoked by every process in the entire system that is hooked
* by our window hooks, notably the tty processes' context, and by the user
* who wants tty messages (the app). Keep it light and simple.
*/
BOOL __declspec(dllexport) APIENTRY DllMain(HINSTANCE hModule, ULONG ulReason,
LPVOID pctx)
{
if (ulReason == DLL_PROCESS_ATTACH)
{
//hmodThis = hModule;
if (!hookwndmsg) {
origwndprop = MAKEINTATOM(GlobalAddAtom("Win9xConHookOrigProc"));
hookwndprop = MAKEINTATOM(GlobalAddAtom("Win9xConHookThunkWnd"));
hookwndmsg = RegisterWindowMessage("Win9xConHookMsg");
}
#ifdef DBG
// DbgPrintf("H ProcessAttach:%8.8x\r\n",
// GetCurrentProcessId());
#endif
}
else if ( ulReason == DLL_PROCESS_DETACH )
{
#ifdef DBG
// DbgPrintf("H ProcessDetach:%8.8x\r\n", GetCurrentProcessId());
#endif
if (monitor_hwnd)
SendMessage(monitor_hwnd, WM_DESTROY, 0, 0);
if (is_subclassed)
SendMessage(hwtty, hookwndmsg, 0, (LPARAM)hwtty);
if (hmodHook)
{
if (hhkGetMessage) {
UnhookWindowsHookEx(hhkGetMessage);
hhkGetMessage = NULL;
}
//if (hhkCallWndProc) {
// UnhookWindowsHookEx(hhkCallWndProc);
// hhkCallWndProc = NULL;
//}
FreeLibrary(hmodHook);
hmodHook = NULL;
}
if (is_service)
RegisterWindows9xService(FALSE);
if (hookwndmsg) {
GlobalDeleteAtom((ATOM)origwndprop);
GlobalDeleteAtom((ATOM)hookwndprop);
hookwndmsg = 0;
}
}
return TRUE;
}
bool CHotKeysToCmdRouter::UnregisterCommand(UINT i_command_id)
{
bool result = true;
bool is_command_exist = false;
if (NULL==mp_OriginalWnd)
{
_ASSERTE(0);
return false;
}
//ID-шек c кодом i_command_id в базе данных может быть больше одной, поэтому нам нужен цикл
HotKeyMap::iterator it;
while((it = _FindCommandID(i_command_id)) != m_hot_key_map.end())
{
is_command_exist = true;
//нашли ID-шку в базе данных. Надо снять с регистрации горячую клавишу
if (!UnregisterHotKey(mp_OriginalWnd->m_hWnd, (*it).first))
result = false;
if (GlobalDeleteAtom((*it).first) != 0)
result = false;
//удаляем из базы данных
m_hot_key_map.erase(it);
}
//если были ошибки или команды нет в базе данных, то возвращаем false.
return result && is_command_exist;
}
HotkeyCombo::~HotkeyCombo()
{
if (ID)
{
GlobalDeleteAtom(ID);
}
}
void Menu_Uninstall(void)
{
ImageList_Destroy(hImageListCold);
ImageList_Destroy(hImageListHot);
UnhookWindowsHookEx(g_hMenuHook);
GlobalDeleteAtom(g_hMenuAtom);
}
/******************************************************************
* WDML_HandlePokeReply
*
*
*/
static WDML_QUEUE_STATE WDML_HandlePokeReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct, DWORD *ack)
{
UINT_PTR uiLo, uiHi;
HSZ hsz;
if (msg->message != WM_DDE_ACK && WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
{
return WDML_QS_PASS;
}
UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
if (DdeCmpStringHandles(hsz, pXAct->hszItem) != 0)
{
return WDML_QS_PASS;
}
FreeDDElParam(WM_DDE_ACK, msg->lParam);
GlobalDeleteAtom(uiHi);
if (ack) *ack = uiLo;
pXAct->hMem = GlobalFree(pXAct->hMem);
pXAct->hDdeData = (HDDEDATA)TRUE;
return TRUE;
}
/******************************************************************
* WDML_ClientQueueAdvise
*
* Creates and queue an WM_DDE_ADVISE transaction
*/
static WDML_XACT* WDML_ClientQueueAdvise(WDML_CONV* pConv, UINT wType, UINT wFmt, HSZ hszItem)
{
DDEADVISE* pDdeAdvise;
WDML_XACT* pXAct;
ATOM atom;
TRACE("XTYP_ADVSTART (with%s data) transaction\n", (wType & XTYPF_NODATA) ? "out" : "");
atom = WDML_MakeAtomFromHsz(hszItem);
if (!atom) return NULL;
pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_ADVISE, wFmt, hszItem);
if (!pXAct)
{
GlobalDeleteAtom(atom);
return NULL;
}
pXAct->wType = wType & ~0x0F;
pXAct->hMem = GlobalAlloc(GHND | GMEM_DDESHARE, sizeof(DDEADVISE));
/* FIXME: hMem is unfreed for now... should be deleted in server */
/* pack DdeAdvise */
pDdeAdvise = GlobalLock(pXAct->hMem);
pDdeAdvise->fAckReq = (wType & XTYPF_ACKREQ) != 0;
pDdeAdvise->fDeferUpd = (wType & XTYPF_NODATA) != 0;
pDdeAdvise->cfFormat = wFmt;
GlobalUnlock(pXAct->hMem);
pXAct->lParam = PackDDElParam(WM_DDE_ADVISE, (UINT_PTR)pXAct->hMem, atom);
return pXAct;
}
int ps_get_monitor_timing(int monitor_index, MonitorTiming *timing)
{
LRESULT lresult;
char in[256];
if (!hPSWnd) return 0;
lresult = SendMessage(hPSWnd, UM_GETTIMING, monitor_index, 0);
if (lresult == -1)
{
mame_printf_verbose("PStrip: Could not get PowerStrip timing string\n");
return 0;
}
if (!GlobalGetAtomNameA(lresult, in, sizeof(in)))
{
mame_printf_verbose("PStrip: GlobalGetAtomName failed\n");
return 0;
}
mame_printf_verbose("PStrip: ps_get_monitor_timing(%d): %s\n", monitor_index, in);
read_timing_string(in, timing);
GlobalDeleteAtom(lresult); // delete atom created by PowerStrip
return 1;
}
int ps_set_monitor_timing(int monitor_index, MonitorTiming *timing)
{
LRESULT lresult;
ATOM atom;
char out[256];
if (!hPSWnd) return 0;
fill_timing_string(out, timing);
atom = GlobalAddAtomA(out);
if (atom)
{
lresult = SendMessage(hPSWnd, UM_SETCUSTOMTIMING, monitor_index, atom);
if (lresult < 0)
{
mame_printf_verbose("PStrip: SendMessage failed\n");
GlobalDeleteAtom(atom);
}
else
{
mame_printf_verbose("PStrip: ps_set_monitor_timing(%d): %s\n", monitor_index, out);
return 1;
}
}
else mame_printf_verbose("PStrip: ps_set_monitor_timing atom creation failed\n");
return 0;
}
int ps_create_resolution(int monitor_index, ModeLine *modeline)
{
LRESULT lresult;
ATOM atom;
char out[256];
MonitorTiming timing = {0};
if (!hPSWnd) return 0;
modeline_to_pstiming(modeline, &timing);
fill_timing_string(out, &timing);
atom = GlobalAddAtomA(out);
if (atom)
{
lresult = SendMessage(hPSWnd, UM_CREATERESOLUTION, monitor_index, atom);
if (lresult < 0)
{
mame_printf_verbose("PStrip: SendMessage failed\n");
GlobalDeleteAtom(atom);
}
else
{
mame_printf_verbose("PStrip: ps_create_resolution(%d): %dx%d succeded \n",
modeline->a_width, modeline->a_height, monitor_index);
return 1;
}
}
else mame_printf_verbose("PStrip: ps_create_resolution atom creation failed\n");
return 0;
}
/******************************************************************
* WDML_HandleIncomingData
*
*
*/
static WDML_QUEUE_STATE WDML_HandleIncomingData(WDML_CONV* pConv, MSG* msg, HDDEDATA* hdd)
{
UINT_PTR uiLo, uiHi;
HDDEDATA hDdeDataIn, hDdeDataOut;
WDML_LINK* pLink;
WINE_DDEHEAD wdh;
HSZ hsz;
TRACE("WM_DDE_DATA message received in the Client Proc!\n");
/* wParam -- sending window handle */
/* lParam -- hDdeData & item HSZ */
UnpackDDElParam(WM_DDE_DATA, msg->lParam, &uiLo, &uiHi);
hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
hDdeDataIn = WDML_Global2DataHandle(pConv, (HGLOBAL)uiLo, &wdh);
/* billx:
* For hot link, data should be passed to its callback with
* XTYP_ADVDATA and callback should return the proper status.
*/
pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_CLIENT_SIDE, hsz,
uiLo != 0, wdh.cfFormat);
if (!pLink)
{
WDML_DecHSZ(pConv->instance, hsz);
DdeFreeDataHandle(hDdeDataIn);
return WDML_QS_PASS;
}
if (hDdeDataIn != 0 && wdh.fAckReq)
{
WDML_PostAck(pConv, WDML_CLIENT_SIDE, 0, FALSE, TRUE, uiHi, msg->lParam, WM_DDE_DATA);
if (msg->lParam)
msg->lParam = 0;
}
else
{
GlobalDeleteAtom(uiHi);
}
hDdeDataOut = WDML_InvokeCallback(pConv->instance, XTYP_ADVDATA, pLink->uFmt, pLink->hConv,
pConv->hszTopic, pLink->hszItem, hDdeDataIn, 0, 0);
if (hDdeDataOut != (HDDEDATA)DDE_FACK || wdh.fRelease)
{
if (uiLo) GlobalFree((HANDLE)uiLo);
}
DdeFreeDataHandle(hDdeDataIn);
WDML_DecHSZ(pConv->instance, hsz);
if (msg->lParam)
FreeDDElParam(WM_DDE_DATA, msg->lParam);
return WDML_QS_HANDLED;
}
bool MessageCenter::unregisterHotkey()
{
for (int i=0; i<hotKeyId.size(); i++) {
ATOM id = hotKeyId[i];
UnregisterHotKey(self,id);
GlobalDeleteAtom(id);
}
return true;
}
static int FindMirandaForProfile(TCHAR * szProfile)
{
ENUMMIRANDAWINDOW x={0};
x.profile=szProfile;
x.msg=RegisterWindowMessage( _T( "Miranda::ProcessProfile" ));
x.aPath=GlobalAddAtom(szProfile);
EnumWindows(EnumMirandaWindows, (LPARAM)&x);
GlobalDeleteAtom(x.aPath);
return x.found;
}
ESTATUS main_AddNullTerminatedAtomAndVerifyW(LPWSTR pswzBuffer, ATOM *ptAtom)
{
ATOM tAtom = 0;
ESTATUS eReturn = ESTATUS_INVALID;
LPWSTR pswzCheckBuffer = NULL;
DWORD cbCheckBuffer = 0;
UINT uiRet = 0;
HMODULE hUser32 = NULL;
BOOL bWasAtomWrittenSuccessfully = FALSE;
// If user32.dll is not loaded, the ATOM functions return access denied. For more details see :
// http://www.tech-archive.net/Archive/Development/microsoft.public.win32.programmer.kernel/2004-03/0851.html
hUser32 = LoadLibrary(L"user32.dll");
do
{
tAtom = GlobalAddAtomW(pswzBuffer);
if (0 == tAtom)
{
printf("GlobalAddAtomA failed. GLE: 0x%X (%d)\n\n", GetLastError(), GetLastError());
eReturn = ESTATUS_MAIN_ADDNULLTERMINATEDATOMANDVERIFYW_GLOBALADDATOMW_FAILED;
goto lblCleanup;
}
eReturn = main_WasAtomWrittenSuccessfully(tAtom, pswzBuffer, &bWasAtomWrittenSuccessfully);
if (ESTATUS_FAILED(eReturn))
{
goto lblCleanup;
}
if (FALSE != bWasAtomWrittenSuccessfully)
{
break;
}
for (int i = 0; i < 0x2; i++)
{
SetLastError(ERROR_SUCCESS);
GlobalDeleteAtom(tAtom);
if (ERROR_SUCCESS != GetLastError())
{
eReturn = ESTATUS_MAIN_ADDNULLTERMINATEDATOMANDVERIFYW_GLOBALDELETEATOM_FAILED;
goto lblCleanup;
}
}
} while (FALSE == bWasAtomWrittenSuccessfully);
eReturn = ESTATUS_SUCCESS;
*ptAtom = tAtom;
lblCleanup:
return eReturn;
}
void FreeHotkey(THotkeyItem *item)
{
if (item->type == HKT_GLOBAL && item->Enabled)
UnregisterHotKey(g_hwndHotkeyHost, item->idHotkey);
GlobalDeleteAtom(item->idHotkey);
mir_free(item->pszName);
mir_free(item->pszService);
mir_free(item->ptszDescription);
mir_free(item->ptszSection);
mir_free(item);
}
BOOL BaseBar_UnregisterControl(HINSTANCE hInstance)
{
WNDCLASSEX wcex;
if (GetClassInfoEx(hInstance, WC_BASEBAR, &wcex) == 0)
return (FALSE);
UnregisterClass(WC_BASEBAR, hInstance);
GlobalDeleteAtom(s_hBaseBarAtom);
return (TRUE);
}
void Mint::UnregisterHotKey(int nID)
{
#ifdef WIN32
_ASSERT(m_hWnd!=NULL); // Should call SetHWND() before this function
::UnregisterHotKey(m_hWnd, nID);
GlobalDeleteAtom(nID);
#else
// Not Implemented
_ASSERT(FALSE);
return 0;
#endif
}
VOID SetTabletInputServiceProperties()
{
DWORD_PTR dwHwndTabletProperty =
TABLET_DISABLE_PRESSANDHOLD | // disables press and hold (right-click) gesture
TABLET_DISABLE_PENTAPFEEDBACK | // disables UI feedback on pen up (waves)
TABLET_DISABLE_PENBARRELFEEDBACK | // disables UI feedback on pen button down (circle)
TABLET_DISABLE_FLICKS; // disables pen flicks (back, forward, drag down, drag up)
ATOM atom = ::GlobalAddAtom(MICROSOFT_TABLETPENSERVICE_PROPERTY);
SetProp(g_hWnd, MICROSOFT_TABLETPENSERVICE_PROPERTY, reinterpret_cast<HANDLE>(dwHwndTabletProperty));
GlobalDeleteAtom(atom);
}
/******************************************************************
* WDML_HandleAdviseReply
*
* handles the reply to an advise request
*/
static WDML_QUEUE_STATE WDML_HandleAdviseReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct, DWORD *ack)
{
DDEACK ddeAck;
UINT_PTR uiLo, uiHi;
HSZ hsz;
if (msg->message != WM_DDE_ACK || WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
{
return WDML_QS_PASS;
}
UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
if (DdeCmpStringHandles(hsz, pXAct->hszItem) != 0)
return WDML_QS_PASS;
GlobalDeleteAtom(uiHi);
FreeDDElParam(WM_DDE_ACK, msg->lParam);
if (ack) *ack = uiLo;
WDML_ExtractAck(uiLo, &ddeAck);
if (ddeAck.fAck)
{
WDML_LINK* pLink;
/* billx: first to see if the link is already created. */
pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_CLIENT_SIDE,
pXAct->hszItem, TRUE, pXAct->wFmt);
if (pLink != NULL)
{
/* we found a link, and only need to modify it in case it changes */
pLink->transactionType = pXAct->wType;
}
else
{
WDML_AddLink(pConv->instance, (HCONV)pConv, WDML_CLIENT_SIDE,
pXAct->wType, pXAct->hszItem, pXAct->wFmt);
}
pXAct->hDdeData = (HDDEDATA)1;
}
else
{
TRACE("Returning FALSE on XTYP_ADVSTART - fAck was FALSE\n");
GlobalFree(pXAct->hMem);
pXAct->hDdeData = NULL;
}
return WDML_QS_HANDLED;
}
/******************************************************************
* WDML_ClientQueuePoke
*
*
*/
static WDML_XACT* WDML_ClientQueuePoke(WDML_CONV* pConv, LPVOID pData, DWORD cbData,
UINT wFmt, HSZ hszItem)
{
DDE_DATAHANDLE_HEAD *dh;
WDML_XACT *pXAct;
DDEPOKE *ddePoke;
HGLOBAL hglobal;
ATOM atom;
TRACE("XTYP_POKE transaction\n");
atom = WDML_MakeAtomFromHsz(hszItem);
if (!atom) return NULL;
pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_POKE, wFmt, hszItem);
if (!pXAct)
{
GlobalDeleteAtom(atom);
return NULL;
}
if (cbData == (DWORD)-1)
{
hglobal = pData;
dh = GlobalLock(hglobal);
cbData = GlobalSize(hglobal) - sizeof(DDE_DATAHANDLE_HEAD);
pData = dh + 1;
GlobalUnlock(hglobal);
}
pXAct->hMem = GlobalAlloc(GHND | GMEM_DDESHARE, FIELD_OFFSET(DDEPOKE, Value[cbData]));
ddePoke = GlobalLock(pXAct->hMem);
if (!ddePoke)
{
pConv->instance->lastError = DMLERR_MEMORY_ERROR;
return NULL;
}
ddePoke->unused = 0;
ddePoke->fRelease = TRUE;
ddePoke->cfFormat = wFmt;
memcpy(ddePoke->Value, pData, cbData);
GlobalUnlock(pXAct->hMem);
pXAct->lParam = PackDDElParam(WM_DDE_POKE, (UINT_PTR)pXAct->hMem, atom);
return pXAct;
}
static int UnregisterHotKeys()
{
if (hkInfo != NULL) {
for (int i = 0; i < hkiCount; i ++) {
UnregisterHotKey(hMessageWindow, (int)hkInfo[i].id);
GlobalDeleteAtom(hkInfo[i].id);
}
free(hkInfo);
}
DestroyWindow(hMessageWindow);
hkiCount = 0;
hkInfo = NULL;
hMessageWindow = NULL;
return 0;
}
gboolean free_key(GdkDisplay* gdisplay,
GdkWindow* groot,
HotkeyEntry* key)
{
ATOM atom;
gboolean retval;
if (!key->code || !key->mod)
return FALSE;
if (!(atom = find_hotkey_atom(key)))
return FALSE;
retval = UnregisterHotKey(get_dummy_win(), atom);
GlobalDeleteAtom(atom);
return retval;
}
