LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static HWND hwndNextViewer ;
HGLOBAL hGlobal ;
HDC hdc ;
PTSTR pGlobal ;
PAINTSTRUCT ps ;
RECT rect ;
switch (message)
{
case WM_CREATE:
hwndNextViewer = SetClipboardViewer (hwnd) ;
return 0 ;
case WM_CHANGECBCHAIN:
if ((HWND) wParam == hwndNextViewer)
hwndNextViewer = (HWND) lParam ;
else if (hwndNextViewer)
SendMessage (hwndNextViewer, message, wParam, lParam) ;
return 0 ;
case WM_DRAWCLIPBOARD:
if (hwndNextViewer)
SendMessage (hwndNextViewer, message, wParam, lParam) ;
InvalidateRect (hwnd, NULL, TRUE) ;
return 0 ;
case WM_PAINT:
hdc = BeginPaint (hwnd, &ps) ;
GetClientRect (hwnd, &rect) ;
OpenClipboard (hwnd) ;
#ifdef UNICODE
hGlobal = GetClipboardData (CF_UNICODETEXT) ;
#else
hGlobal = GetClipboardData (CF_TEXT) ;
#endif
if (hGlobal != NULL)
{
pGlobal = (PTSTR) GlobalLock (hGlobal) ;
DrawText (hdc, pGlobal, -1, &rect, DT_EXPANDTABS) ;
GlobalUnlock (hGlobal) ;
}
CloseClipboard () ;
EndPaint (hwnd, &ps) ;
return 0 ;
case WM_DESTROY:
ChangeClipboardChain (hwnd, hwndNextViewer) ;
PostQuitMessage (0) ;
return 0 ;
}
return DefWindowProc (hwnd, message, wParam, lParam) ;
}
~QClipboardData()
{
Q_ASSERT(clipBoardViewer->testAttribute(Qt::WA_WState_Created));
ChangeClipboardChain(clipBoardViewer->internalWinId(), nextClipboardViewer);
delete clipBoardViewer;
releaseIData();
}
void QWindowsClipboard::unregisterViewer()
{
if (m_clipboardViewer) {
ChangeClipboardChain(m_clipboardViewer, m_nextClipboardViewer);
DestroyWindow(m_clipboardViewer);
m_clipboardViewer = m_nextClipboardViewer = 0;
}
}
// Routine to shutdown all the hooks and stuff
BOOL
vncDesktop::Shutdown()
{
// If we created a timer then kill it
if (m_timerid != NULL)
KillTimer(NULL, m_timerid);
// If we created a window then kill it and the hooks
if(m_hwnd != NULL)
{
// Remove the system hooks
//UnSetHooks(GetCurrentThreadId());
// The window is being closed - remove it from the viewer list
ChangeClipboardChain(m_hwnd, m_hnextviewer);
// Close the hook window
DestroyWindow(m_hwnd);
m_hwnd = NULL;
m_hnextviewer = NULL;
}
// Now free all the bitmap stuff
if (m_hrootdc != NULL)
{
// Release our device context
//if(ReleaseDC(NULL, m_hrootdc) == 0)
//{
// //vnclog.Print(LL_INTERR, VNCLOG("failed to ReleaseDC\n"));
//}
m_hrootdc = NULL;
}
if (m_hmemdc != NULL)
{
// Release our device context
////if (!DeleteDC(m_hmemdc))
//{
// //vnclog.Print(LL_INTERR, VNCLOG("failed to DeleteDC\n"));
//}
m_hmemdc = NULL;
}
if (m_membitmap != NULL)
{
// Release the custom bitmap, if any
//if (!DeleteObject(m_membitmap))
//{
// //vnclog.Print(LL_INTERR, VNCLOG("failed to DeleteObject\n"));
//}
m_membitmap = NULL;
}
// ***
// vncService::SelectHomeWinStation();
return TRUE;
}
void CClipSpyListCtrl::OnDestroy()
{
if ( NULL != m_hwndNextClipboardViewer )
ChangeClipboardChain ( m_hwndNextClipboardViewer );
// if ( m_pDropTarget )
// {
// m_pDropTarget->RevokeDT();
// m_pDropTarget->Release();
// }
}
/* Remove ourselves from the chain of cliboard listeners */
static void removeFromCBChain (VBOXCLIPBOARDCONTEXT *pCtx)
{
if (vboxClipboardIsNewAPI(pCtx))
{
pCtx->pfnRemoveClipboardFormatListener(pCtx->hwnd);
}
else
{
ChangeClipboardChain(pCtx->hwnd, pCtx->hwndNextInChain);
pCtx->hwndNextInChain = NULL;
}
}
void QWindowsClipboard::unregisterViewer()
{
if (m_clipboardViewer) {
if (m_formatListenerRegistered) {
QWindowsContext::user32dll.removeClipboardFormatListener(m_clipboardViewer);
m_formatListenerRegistered = false;
} else {
ChangeClipboardChain(m_clipboardViewer, m_nextClipboardViewer);
m_nextClipboardViewer = 0;
}
DestroyWindow(m_clipboardViewer);
m_clipboardViewer = 0;
}
}
/* Remove ourselves from the chain of cliboard listeners */
static void vboxClipboardRemoveFromCBChain(PVBOXCLIPBOARDCONTEXT pCtx)
{
AssertPtrReturnVoid(pCtx);
if (vboxClipboardIsNewAPI(pCtx))
{
pCtx->pfnRemoveClipboardFormatListener(pCtx->hwnd);
}
else
{
ChangeClipboardChain(pCtx->hwnd, pCtx->hwndNextInChain);
pCtx->hwndNextInChain = NULL;
}
/** @todo r=andy Return code?? */
}
/*!
ウインドウを閉じるときに発生。デバイスコンテキストとか確保した画面構造のメモリとかも終了。
@param[in] hWnd 親ウインドウのハンドル
@return 無し
*/
VOID Cls_OnDestroy( HWND hWnd )
{
UnregisterHotKey( hWnd, IDHK_CLIPSTEAL_FILECHANGE );
ChangeClipboardChain( hWnd , ghNextViewer ); // クリップボードチェインから離脱
gstNtfyIcon.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP | NIF_INFO;
Shell_NotifyIcon( NIM_DELETE, &gstNtfyIcon ); // トレイアイコン破壊
DeleteBrush( ghBrush );
PostQuitMessage( 0 );
return;
}
static LRESULT CALLBACK clipboard_wnd_proc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
{
static UINT wm_drawclipboard;
static UINT wm_clipboardupdate;
static UINT wm_destroyclipboard;
LRESULT ret;
switch(msg) {
case WM_DRAWCLIPBOARD:
EnterCriticalSection(&clipboard_cs);
wm_drawclipboard++;
LeaveCriticalSection(&clipboard_cs);
break;
case WM_CHANGECBCHAIN:
if (next_wnd == (HWND)wp)
next_wnd = (HWND)lp;
else if (next_wnd)
SendMessageA(next_wnd, msg, wp, lp);
break;
case WM_DESTROYCLIPBOARD:
wm_destroyclipboard++;
ok( GetClipboardOwner() == hwnd, "WM_DESTROYCLIPBOARD owner %p\n", GetClipboardOwner() );
break;
case WM_CLIPBOARDUPDATE:
wm_clipboardupdate++;
break;
case WM_USER:
ChangeClipboardChain(hwnd, next_wnd);
PostQuitMessage(0);
break;
case WM_USER+1:
ret = wm_drawclipboard;
wm_drawclipboard = 0;
return ret;
case WM_USER+2:
ret = wm_clipboardupdate;
wm_clipboardupdate = 0;
return ret;
case WM_USER+3:
ret = wm_destroyclipboard;
wm_destroyclipboard = 0;
return ret;
}
return DefWindowProcA(hwnd, msg, wp, lp);
}
static PyObject *
py_change_clipboard_chain(PyObject* self, PyObject* args)
{
// @pyparm int|hWndRemove||Integer handle to the window to be removed from
// the chain. The handle must have been passed to the SetClipboardViewer
// function.
// @pyparm int|hWndNewNext||Integer handle to the window that follows the
// hWndRemove window in the clipboard viewer chain. (This is the handle
// returned by SetClipboardViewer, unless the sequence was changed in
// response to a WM_CHANGECBCHAIN message.)
HWND hWndRemove;
HWND hWndNewNext;
PyObject *obhWndRemove, *obhWndNewNext;
if (!PyArg_ParseTuple(args, "OO:ChangeClipboardChain",
&obhWndRemove, &obhWndNewNext)) {
return NULL;
}
if (!PyWinObject_AsHANDLE(obhWndRemove, (HANDLE *)&hWndRemove))
return NULL;
if (!PyWinObject_AsHANDLE(obhWndNewNext, (HANDLE *)&hWndNewNext))
return NULL;
BOOL rc;
Py_BEGIN_ALLOW_THREADS;
rc = ChangeClipboardChain(hWndRemove, hWndNewNext);
Py_END_ALLOW_THREADS;
return (Py_BuildValue("i", (int)rc));
// @comm The window identified by hWndNewNext replaces the hWndRemove window
// in the chain. The SetClipboardViewer function sends a WM_CHANGECBCHAIN
// message to the first window in the clipboard viewer chain.
// @pyseeapi ChangeClipboardChain
// @rdesc The return value indicates the result of passing the
// WM_CHANGECBCHAIN message to the windows in the clipboard viewer chain.
// Because a window in the chain typically returns FALSE when it processes
// WM_CHANGECBCHAIN, the return value from ChangeClipboardChain is typically
// FALSE. If there is only one window in the chain, the return value is
// typically TRUE.
}
void auto_lookup_stop()
{
#ifdef __WIN32__
if(registered == TRUE) {
hidden_hwnd = GDK_WINDOW_HWND (hidden_window->window);
ChangeClipboardChain(hidden_hwnd, next_hwnd);
next_hwnd = NULL;
registered = FALSE;
}
#else
if(tag_timeout != 0)
gtk_timeout_remove(tag_timeout);
tag_timeout = 0;
#endif
auto_lookup_suspended = FALSE;
}
LRESULT CALLBACK
HiddenWndProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
LRESULT retval;
HANDLE hText;
char *pText;
gchar *str;
switch (msg) {
case WM_DESTROY:
ChangeClipboardChain(hwnd , next_hwnd);
PostQuitMessage(0);
break;
case WM_DRAWCLIPBOARD:
OpenClipboard(hwnd);
hText = GetClipboardData(CF_TEXT);
if(hText != NULL) {
pText = GlobalLock(hText);
GlobalUnlock(hText);
}
CloseClipboard();
//remove_space(pText);
str = iconv_convert(fs_codeset, "utf-8", pText);
search_selected(str);
g_free(str);
if(next_hwnd != NULL)
SendMessage(next_hwnd, msg, wParam, lParam);
break;
case WM_CHANGECBCHAIN:
if((HWND)wParam == next_hwnd)
next_hwnd = (HWND)lParam;
break;
default:
break;
}
retval = OrgWndProc(hwnd, msg, wParam, lParam);
return retval;
}
static LRESULT CALLBACK clipboard_wnd_proc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
{
switch(msg) {
case WM_DRAWCLIPBOARD:
EnterCriticalSection(&clipboard_cs);
LeaveCriticalSection(&clipboard_cs);
break;
case WM_CHANGECBCHAIN:
if (next_wnd == (HWND)wp)
next_wnd = (HWND)lp;
else if (next_wnd)
SendMessageA(next_wnd, msg, wp, lp);
break;
case WM_USER:
ChangeClipboardChain(hwnd, next_wnd);
PostQuitMessage(0);
break;
}
return DefWindowProcA(hwnd, msg, wp, lp);
}
void fsClipboardCatchMgr::Enable(BOOL bEnable)
{
if (bEnable)
{
if (m_bEnabled == FALSE)
{
m_hNextViewer = SetClipboardViewer ();
m_bEnabled = TRUE;
}
}
else
{
if (m_bEnabled)
{
ChangeClipboardChain (m_hNextViewer);
m_bEnabled = FALSE;
}
}
}
__fastcall TScreenSnapper::~TScreenSnapper()
{
ChangeClipboardChain(Handle,NextHandle); // Unregister from clipboard chain
}
LRESULT CALLBACK
winClipboardWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static HWND s_hwndNextViewer;
static Bool s_fCBCInitialized;
static Display *pDisplay;
static Window iWindow;
static ClipboardAtoms *atoms;
static Bool fRunning;
/* Branch on message type */
switch (message) {
case WM_DESTROY:
{
winDebug("winClipboardWindowProc - WM_DESTROY\n");
if (g_fHasModernClipboardApi)
{
/* Remove clipboard listener */
g_fpRemoveClipboardFormatListener(hwnd);
}
else
{
/* Remove ourselves from the clipboard chain */
ChangeClipboardChain(hwnd, s_hwndNextViewer);
}
s_hwndNextViewer = NULL;
}
return 0;
case WM_WM_QUIT:
{
winDebug("winClipboardWindowProc - WM_WM_QUIT\n");
fRunning = FALSE;
PostQuitMessage(0);
}
return 0;
case WM_CREATE:
{
ClipboardWindowCreationParams *cwcp = (ClipboardWindowCreationParams *)((CREATESTRUCT *)lParam)->lpCreateParams;
winDebug("winClipboardWindowProc - WM_CREATE\n");
pDisplay = cwcp->pClipboardDisplay;
iWindow = cwcp->iClipboardWindow;
atoms = cwcp->atoms;
fRunning = TRUE;
if (g_fHasModernClipboardApi)
{
g_fpAddClipboardFormatListener(hwnd);
}
else
{
HWND first, next;
DWORD error_code = 0;
first = GetClipboardViewer(); /* Get handle to first viewer in chain. */
if (first == hwnd)
return 0; /* Make sure it's not us! */
/* Add ourselves to the clipboard viewer chain */
next = SetClipboardViewer(hwnd);
error_code = GetLastError();
if (SUCCEEDED(error_code) && (next == first)) /* SetClipboardViewer must have succeeded, and the handle */
s_hwndNextViewer = next; /* it returned must have been the first window in the chain */
else
s_fCBCInitialized = FALSE;
}
}
return 0;
case WM_CHANGECBCHAIN:
{
winDebug("winClipboardWindowProc - WM_CHANGECBCHAIN: wParam(%p) "
"lParam(%p) s_hwndNextViewer(%p)\n",
(HWND)wParam, (HWND)lParam, s_hwndNextViewer);
if ((HWND) wParam == s_hwndNextViewer) {
s_hwndNextViewer = (HWND) lParam;
if (s_hwndNextViewer == hwnd) {
s_hwndNextViewer = NULL;
ErrorF("winClipboardWindowProc - WM_CHANGECBCHAIN: "
"attempted to set next window to ourselves.");
}
}
else if (s_hwndNextViewer)
SendMessage(s_hwndNextViewer, message, wParam, lParam);
}
winDebug("winClipboardWindowProc - WM_CHANGECBCHAIN: Exit\n");
return 0;
case WM_WM_REINIT:
{
/* Ensure that we're in the clipboard chain. Some apps,
* WinXP's remote desktop for one, don't play nice with the
* chain. This message is called whenever we receive a
* WM_ACTIVATEAPP message to ensure that we continue to
* receive clipboard messages.
*
* It might be possible to detect if we're still in the chain
* by calling SendMessage (GetClipboardViewer(),
* WM_DRAWCLIPBOARD, 0, 0); and then seeing if we get the
* WM_DRAWCLIPBOARD message. That, however, might be more
* expensive than just putting ourselves back into the chain.
*/
HWND first, next;
DWORD error_code = 0;
winDebug("winClipboardWindowProc - WM_WM_REINIT: Enter\n");
if (g_fHasModernClipboardApi)
{
return 0;
}
first = GetClipboardViewer(); /* Get handle to first viewer in chain. */
if (first == hwnd)
return 0; /* Make sure it's not us! */
winDebug(" WM_WM_REINIT: Replacing us(%p) with %p at head "
"of chain\n", hwnd, s_hwndNextViewer);
s_fCBCInitialized = FALSE;
ChangeClipboardChain(hwnd, s_hwndNextViewer);
s_hwndNextViewer = NULL;
s_fCBCInitialized = FALSE;
winDebug(" WM_WM_REINIT: Putting us back at head of chain.\n");
first = GetClipboardViewer(); /* Get handle to first viewer in chain. */
if (first == hwnd)
return 0; /* Make sure it's not us! */
next = SetClipboardViewer(hwnd);
error_code = GetLastError();
if (SUCCEEDED(error_code) && (next == first)) /* SetClipboardViewer must have succeeded, and the handle */
s_hwndNextViewer = next; /* it returned must have been the first window in the chain */
else
s_fCBCInitialized = FALSE;
}
winDebug("winClipboardWindowProc - WM_WM_REINIT: Exit\n");
return 0;
case WM_DRAWCLIPBOARD:
case WM_CLIPBOARDUPDATE:
{
static Bool s_fProcessingDrawClipboard = FALSE;
int iReturn;
if (message == WM_DRAWCLIPBOARD)
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD: Enter\n");
else
winDebug("winClipboardWindowProc - WM_CLIPBOARDUPDATE: Enter\n");
if (!g_fHasModernClipboardApi)
{
/*
* We've occasionally seen a loop in the clipboard chain.
* Try and fix it on the first hint of recursion.
*/
if (!s_fProcessingDrawClipboard) {
s_fProcessingDrawClipboard = TRUE;
}
else {
/* Attempt to break the nesting by getting out of the chain, twice?, and then fix and bail */
s_fCBCInitialized = FALSE;
ChangeClipboardChain(hwnd, s_hwndNextViewer);
winFixClipboardChain();
ErrorF("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"Nested calls detected. Re-initing.\n");
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD: Exit\n");
s_fProcessingDrawClipboard = FALSE;
return 0;
}
/* Bail on first message */
if (!s_fCBCInitialized) {
s_fCBCInitialized = TRUE;
s_fProcessingDrawClipboard = FALSE;
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD: Exit\n");
return 0;
}
}
/*
* NOTE: We cannot bail out when NULL == GetClipboardOwner ()
* because some applications deal with the clipboard in a manner
* that causes the clipboard owner to be NULL when they are in
* fact taking ownership. One example of this is the Win32
* native compile of emacs.
*/
/* Bail when we still own the clipboard */
if (hwnd == GetClipboardOwner()) {
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"We own the clipboard, returning.\n");
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD: Exit\n");
s_fProcessingDrawClipboard = FALSE;
if (s_hwndNextViewer)
SendMessage(s_hwndNextViewer, message, wParam, lParam);
return 0;
}
/* Bail when shutting down */
if (!fRunning)
return 0;
/*
* Do not take ownership of the X11 selections when something
* other than CF_TEXT or CF_UNICODETEXT has been copied
* into the Win32 clipboard.
*/
if (!IsClipboardFormatAvailable(CF_TEXT)
&& !IsClipboardFormatAvailable(CF_UNICODETEXT)) {
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"Clipboard does not contain CF_TEXT nor "
"CF_UNICODETEXT.\n");
/*
* We need to make sure that the X Server has processed
* previous XSetSelectionOwner messages.
*/
XSync(pDisplay, FALSE);
winDebug("winClipboardWindowProc - XSync done.\n");
/* Release PRIMARY selection if owned */
iReturn = XGetSelectionOwner(pDisplay, XA_PRIMARY);
if (iReturn == iWindow) {
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"PRIMARY selection is owned by us.\n");
XSetSelectionOwner(pDisplay, XA_PRIMARY, None, CurrentTime);
}
else if (BadWindow == iReturn || BadAtom == iReturn)
ErrorF("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"XGetSelectionOwner failed for PRIMARY: %d\n",
iReturn);
/* Release CLIPBOARD selection if owned */
iReturn = XGetSelectionOwner(pDisplay, atoms->atomClipboard);
if (iReturn == iWindow) {
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"CLIPBOARD selection is owned by us, releasing\n");
XSetSelectionOwner(pDisplay, atoms->atomClipboard, None, CurrentTime);
}
else if (BadWindow == iReturn || BadAtom == iReturn)
ErrorF("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"XGetSelectionOwner failed for CLIPBOARD: %d\n",
iReturn);
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD: Exit\n");
s_fProcessingDrawClipboard = FALSE;
if (s_hwndNextViewer)
SendMessage(s_hwndNextViewer, message, wParam, lParam);
return 0;
}
/* Reassert ownership of PRIMARY */
iReturn = XSetSelectionOwner(pDisplay,
XA_PRIMARY, iWindow, CurrentTime);
if (iReturn == BadAtom || iReturn == BadWindow ||
XGetSelectionOwner(pDisplay, XA_PRIMARY) != iWindow) {
ErrorF("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"Could not reassert ownership of PRIMARY\n");
}
else {
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"Reasserted ownership of PRIMARY\n");
}
/* Reassert ownership of the CLIPBOARD */
iReturn = XSetSelectionOwner(pDisplay,
atoms->atomClipboard, iWindow, CurrentTime);
if (iReturn == BadAtom || iReturn == BadWindow ||
XGetSelectionOwner(pDisplay, atoms->atomClipboard) != iWindow) {
ErrorF("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"Could not reassert ownership of CLIPBOARD\n");
}
else {
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"Reasserted ownership of CLIPBOARD\n");
}
/* Flush the pending SetSelectionOwner event now */
XFlush(pDisplay);
s_fProcessingDrawClipboard = FALSE;
}
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD: Exit\n");
/* Pass the message on the next window in the clipboard viewer chain */
if (s_hwndNextViewer)
SendMessage(s_hwndNextViewer, message, wParam, lParam);
return 0;
case WM_DESTROYCLIPBOARD:
/*
* NOTE: Intentionally do nothing.
* Changes in the Win32 clipboard are handled by WM_DRAWCLIPBOARD
* above. We only process this message to conform to the specs
* for delayed clipboard rendering in Win32. You might think
* that we need to release ownership of the X11 selections, but
* we do not, because a WM_DRAWCLIPBOARD message will closely
* follow this message and reassert ownership of the X11
* selections, handling the issue for us.
*/
winDebug("winClipboardWindowProc - WM_DESTROYCLIPBOARD - Ignored.\n");
return 0;
case WM_RENDERALLFORMATS:
winDebug("winClipboardWindowProc - WM_RENDERALLFORMATS - Hello.\n");
/*
WM_RENDERALLFORMATS is sent as we are shutting down, to render the
clipboard so it's contents remains available to other applications.
Unfortunately, this can't work without major changes. The server is
already waiting for us to stop, so we can't ask for the rendering of
clipboard text now.
*/
return 0;
case WM_RENDERFORMAT:
{
int iReturn;
Bool fConvertToUnicode;
Bool pasted = FALSE;
Atom selection;
ClipboardConversionData data;
int best_target = 0;
winDebug("winClipboardWindowProc - WM_RENDERFORMAT %d - Hello.\n",
(int)wParam);
/* Flag whether to convert to Unicode or not */
fConvertToUnicode = (CF_UNICODETEXT == wParam);
selection = winClipboardGetLastOwnedSelectionAtom(atoms);
if (selection == None) {
ErrorF("winClipboardWindowProc - no monitored selection is owned\n");
goto fake_paste;
}
winDebug("winClipboardWindowProc - requesting targets for selection from owner\n");
/* Request the selection's supported conversion targets */
XConvertSelection(pDisplay,
selection,
atoms->atomTargets,
atoms->atomLocalProperty,
iWindow, CurrentTime);
/* Process X events */
data.fUseUnicode = fConvertToUnicode;
iReturn = winProcessXEventsTimeout(hwnd,
iWindow,
pDisplay,
&data,
atoms,
WIN_POLL_TIMEOUT);
if (WIN_XEVENTS_NOTIFY_TARGETS != iReturn) {
ErrorF
("winClipboardWindowProc - timed out waiting for WIN_XEVENTS_NOTIFY_TARGETS\n");
goto fake_paste;
}
/* Choose the most preferred target */
{
struct target_priority
{
Atom target;
unsigned int priority;
};
struct target_priority target_priority_table[] =
{
{ atoms->atomCompoundText, 0 },
#ifdef X_HAVE_UTF8_STRING
{ atoms->atomUTF8String, 1 },
#endif
{ XA_STRING, 2 },
};
int best_priority = INT_MAX;
int i,j;
for (i = 0 ; data.targetList[i] != 0; i++)
{
for (j = 0; j < sizeof(target_priority_table)/sizeof(struct target_priority); j ++)
{
if ((data.targetList[i] == target_priority_table[j].target) &&
(target_priority_table[j].priority < best_priority))
{
best_target = target_priority_table[j].target;
best_priority = target_priority_table[j].priority;
}
}
}
}
free(data.targetList);
data.targetList = 0;
winDebug("winClipboardWindowProc - best target is %d\n", best_target);
/* No useful targets found */
if (best_target == 0)
goto fake_paste;
winDebug("winClipboardWindowProc - requesting selection from owner\n");
/* Request the selection contents */
XConvertSelection(pDisplay,
selection,
best_target,
atoms->atomLocalProperty,
iWindow, CurrentTime);
/* Process X events */
iReturn = winProcessXEventsTimeout(hwnd,
iWindow,
pDisplay,
&data,
atoms,
WIN_POLL_TIMEOUT);
/*
* winProcessXEventsTimeout had better have seen a notify event,
* or else we are dealing with a buggy or old X11 app.
*/
if (WIN_XEVENTS_NOTIFY_DATA != iReturn) {
ErrorF
("winClipboardWindowProc - timed out waiting for WIN_XEVENTS_NOTIFY_DATA\n");
}
else {
pasted = TRUE;
}
/*
* If we couldn't get the data from the X clipboard, we
* have to paste some fake data to the Win32 clipboard to
* satisfy the requirement that we write something to it.
*/
fake_paste:
if (!pasted)
{
/* Paste no data, to satisfy required call to SetClipboardData */
SetClipboardData(CF_UNICODETEXT, NULL);
SetClipboardData(CF_TEXT, NULL);
}
winDebug("winClipboardWindowProc - WM_RENDERFORMAT - Returning.\n");
return 0;
}
}
/* Let Windows perform default processing for unhandled messages */
return DefWindowProc(hwnd, message, wParam, lParam);
}
LRESULT onDestroy(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
ChangeClipboardChain(hWnd, hwndNextViewer);
PostQuitMessage(0);
return 0;
}
void VDAgent::input_desktop_message_loop()
{
TCHAR desktop_name[MAX_PATH];
HDESK hdesk;
hdesk = OpenInputDesktop(0, FALSE, GENERIC_ALL);
if (!hdesk) {
vd_printf("OpenInputDesktop() failed: %lu", GetLastError());
_running = false;
return;
}
if (!SetThreadDesktop(hdesk)) {
vd_printf("SetThreadDesktop failed %lu", GetLastError());
_running = false;
return;
}
if (GetUserObjectInformation(hdesk, UOI_NAME, desktop_name, sizeof(desktop_name), NULL)) {
vd_printf("Desktop: %S", desktop_name);
} else {
vd_printf("GetUserObjectInformation failed %lu", GetLastError());
}
// loading the display settings for the current session's logged on user only
// after 1) we receive logon event, and 2) the desktop switched from Winlogon
if (_tcscmp(desktop_name, TEXT("Winlogon")) == 0) {
_logon_desktop = true;
} else {
// first load after connection
if (!_display_setting_initialized) {
vd_printf("First display setting");
_display_setting.load();
_display_setting_initialized = true;
} else if (_logon_occured && _logon_desktop) {
vd_printf("LOGON display setting");
_display_setting.load();
}
_logon_occured = false;
_logon_desktop = false;
}
_hwnd = CreateWindow(VD_AGENT_WINCLASS_NAME, NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL);
if (!_hwnd) {
vd_printf("CreateWindow() failed: %lu", GetLastError());
_running = false;
return;
}
if (!WTSRegisterSessionNotification(_hwnd, NOTIFY_FOR_ALL_SESSIONS)) {
vd_printf("WTSRegisterSessionNotification() failed: %lu", GetLastError());
}
if (_system_version == SYS_VER_WIN_7_CLASS) {
_add_clipboard_listener(_hwnd);
} else {
_hwnd_next_viewer = SetClipboardViewer(_hwnd);
}
while (_running && !_desktop_switch) {
event_dispatcher(INFINITE, QS_ALLINPUT);
}
_desktop_switch = false;
if (_pending_input) {
KillTimer(_hwnd, VD_TIMER_ID);
_pending_input = false;
}
if (_system_version == SYS_VER_WIN_7_CLASS) {
_remove_clipboard_listener(_hwnd);
} else {
ChangeClipboardChain(_hwnd, _hwnd_next_viewer);
}
WTSUnRegisterSessionNotification(_hwnd);
DestroyWindow(_hwnd);
CloseDesktop(hdesk);
}
////////////////////////////////////////////////////////////////////////////////
// Window procedure for the Desktop window
LRESULT CALLBACK
DesktopWndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
#ifndef _X64
vncDesktop *_this = (vncDesktop*)GetWindowLong(hwnd, GWL_USERDATA);
#else
vncDesktop *_this = (vncDesktop*)GetWindowLongPtr(hwnd, GWLP_USERDATA);
#endif
/*#ifdef _DEBUG
char szText[256];
sprintf(szText,"Message %i\n",iMsg );
OutputDebugString(szText);
//vnclog.Print(LL_INTERR, VNCLOG("%i \n"),iMsg);
#endif*/
switch (iMsg)
{
case WM_CREATE:
vnclog.Print(LL_INTERR, VNCLOG("wmcreate \n"));
break;
case WM_TIMER:
if (_this->can_be_hooked)
{
if (wParam==100)
{
KillTimer(hwnd, 100);
if (_this->startw8)
{
_this->startw8(!_this->multi_monitor);
vnclog.Print(LL_INTERR, VNCLOG("set W8 hooks OK\n"));
_this->m_hookinited = TRUE;
}
else if (_this->SetHook)
{
_this->SetHook(hwnd);
vnclog.Print(LL_INTERR, VNCLOG("set SC hooks OK\n"));
_this->m_hookinited = TRUE;
if (_this->SetKeyboardFilterHooks) _this->SetKeyboardFilterHooks( _this->m_bIsInputDisabledByClient || _this->m_server->LocalInputsDisabled());
if (_this->SetMouseFilterHooks) _this->SetMouseFilterHooks( _this->m_bIsInputDisabledByClient || _this->m_server->LocalInputsDisabled());
}
else if (_this->SetHooks)
{
if (!_this->SetHooks(
GetCurrentThreadId(),
RFB_SCREEN_UPDATE,
RFB_COPYRECT_UPDATE,
RFB_MOUSE_UPDATE, 0
))
{
vnclog.Print(LL_INTERR, VNCLOG("failed to set system hooks\n"));
// Switch on full screen polling, so they can see something, at least...
_this->m_server->PollFullScreen(TRUE);
_this->m_hookinited = FALSE;
}
else
{
vnclog.Print(LL_INTERR, VNCLOG("set hooks OK\n"));
_this->m_hookinited = TRUE;
// Start up the keyboard and mouse filters
if (_this->SetKeyboardFilterHook) _this->SetKeyboardFilterHook(_this->m_bIsInputDisabledByClient || _this->m_server->LocalInputsDisabled());
if (_this->SetMouseFilterHook) _this->SetMouseFilterHook(_this->m_bIsInputDisabledByClient || _this->m_server->LocalInputsDisabled());
}
}
}
else SetEvent(_this->trigger_events[0]);
}
break;
case WM_MOUSESHAPE:
if (_this->can_be_hooked)
{
SetEvent(_this->trigger_events[3]);
}
break;
case WM_HOOKCHANGE:
if (wParam==1)
{
if (_this->m_hookinited==FALSE)
SetTimer(hwnd,100,1000,NULL);
}
else if (wParam==2)
{
if (_this->m_hookinited)
{
if (_this->SetHook)
{
if (_this->SetKeyboardFilterHooks) _this->SetKeyboardFilterHooks( _this->m_bIsInputDisabledByClient || _this->m_server->LocalInputsDisabled());
if (_this->SetMouseFilterHooks) _this->SetMouseFilterHooks( _this->m_bIsInputDisabledByClient || _this->m_server->LocalInputsDisabled());
}
else if (_this->SetHooks)
{
if (_this->SetKeyboardFilterHook) _this->SetKeyboardFilterHook( _this->m_bIsInputDisabledByClient || _this->m_server->LocalInputsDisabled());
if (_this->SetMouseFilterHook) _this->SetMouseFilterHook( _this->m_bIsInputDisabledByClient || _this->m_server->LocalInputsDisabled());
}
}
}
else if (_this->m_hookinited)
{
_this->m_hookinited=FALSE;
if (_this->stopw8)
{
vnclog.Print(LL_INTERR, VNCLOG("unset W8 hooks OK\n"));
_this->stopw8();
}
if (_this->UnSetHook)
{
vnclog.Print(LL_INTERR, VNCLOG("unset SC hooks OK\n"));
_this->UnSetHook(hwnd);
}
else if (_this->UnSetHooks)
{
if(!_this->UnSetHooks(GetCurrentThreadId()) )
vnclog.Print(LL_INTERR, VNCLOG("Unsethooks Failed\n"));
else vnclog.Print(LL_INTERR, VNCLOG("Unsethooks OK\n"));
}
}
return true;
case WM_QUERYENDSESSION:
/*if (OSversion()==2)
{
if (_this->m_hnextviewer!=NULL) ChangeClipboardChain(hwnd, _this->m_hnextviewer);
_this->m_hnextviewer=NULL;
if (_this->m_hookinited)
{
_this->m_hookinited=FALSE;
if (_this->UnSetHook)
{
vnclog.Print(LL_INTERR, VNCLOG("unset SC hooks OK\n"));
_this->UnSetHook(hwnd);
}
else if (_this->UnSetHooks)
{
if(!_this->UnSetHooks(GetCurrentThreadId()) )
vnclog.Print(LL_INTERR, VNCLOG("Unsethooks Failed\n"));
else vnclog.Print(LL_INTERR, VNCLOG("Unsethooks OK\n"));
}
}
vnclog.Print(LL_INTERR, VNCLOG("WM_QUERYENDSESSION\n"));
PostQuitMessage(0);
SetEvent(_this->trigger_events[5]);
}*/
return DefWindowProc(hwnd, iMsg, wParam, lParam);
case WM_CLOSE:
if (_this->m_hnextviewer!=NULL) ChangeClipboardChain(hwnd, _this->m_hnextviewer);
_this->m_hnextviewer=NULL;
DestroyWindow(hwnd);
break;
case WM_DESTROY:
KillTimer(hwnd, 100);
if (_this->m_hnextviewer!=NULL) ChangeClipboardChain(hwnd, _this->m_hnextviewer);
_this->m_hnextviewer=NULL;
if (_this->m_hookinited)
{
if (_this->stopw8)
{
vnclog.Print(LL_INTERR, VNCLOG("unset W8 hooks OK\n"));
_this->stopw8();
}
if (_this->UnSetHook)
{
vnclog.Print(LL_INTERR, VNCLOG("unset SC hooks OK\n"));
_this->UnSetHook(hwnd);
}
else if (_this->UnSetHooks)
{
if(!_this->UnSetHooks(GetCurrentThreadId()) )
vnclog.Print(LL_INTERR, VNCLOG("Unsethooks Failed\n"));
else vnclog.Print(LL_INTERR, VNCLOG("Unsethooks OK\n"));
}
_this->m_hookinited=FALSE;
}
vnclog.Print(LL_INTERR, VNCLOG("WM_DESTROY\n"));
break;
///ddihook
case WM_SYSCOMMAND:
// User has clicked an item on the tray menu
switch (wParam)
{
case SC_MONITORPOWER:
vnclog.Print(LL_INTINFO, VNCLOG("Monitor22 %i\n"),lParam);
}
vnclog.Print(LL_INTINFO, VNCLOG("Monitor3 %i %i\n"),wParam,lParam);
return DefWindowProc(hwnd, iMsg, wParam, lParam);
case WM_POWER:
case WM_POWERBROADCAST:
// User has clicked an item on the tray menu
switch (wParam)
{
case SC_MONITORPOWER:
vnclog.Print(LL_INTINFO, VNCLOG("Monitor222 %i\n"),lParam);
}
vnclog.Print(LL_INTINFO, VNCLOG("Power3 %i %i\n"),wParam,lParam);
return DefWindowProc(hwnd, iMsg, wParam, lParam);
case WM_COPYDATA:
{
PCOPYDATASTRUCT pMyCDS = (PCOPYDATASTRUCT) lParam;
if (pMyCDS->dwData==112233)
{
DWORD mysize=pMyCDS->cbData;
char mytext[1024];
char *myptr;
char split[4][6];
strcpy(mytext,(LPCSTR)pMyCDS->lpData);
myptr=mytext;
for (DWORD j =0; j<(mysize/20);j++)
{
for (int i=0;i<4;i++)
{
strcpy(split[i]," ");
strncpy(split[i],myptr,4);
myptr=myptr+5;
}
_this->QueueRect(rfb::Rect(atoi(split[0]), atoi(split[1]), atoi(split[2]), atoi(split[3])));
}
}
//vnclog.Print(LL_INTINFO, VNCLOG("copydata\n"));
}
return 0;
// GENERAL
case WM_DISPLAYCHANGE:
// The display resolution is changing
// We must kick off any clients since their screen size will be wrong
// WE change the clients screensize, if they support it.
vnclog.Print(LL_INTERR, VNCLOG("WM_DISPLAYCHANGE\n"));
// We First check if the Resolution changed is caused by a temp resolution switch
// For a temp resolution we don't use the driver, to fix the mirror driver
// to the new change, a resolution switch is needed, preventing screensaver locking.
if (_this->m_videodriver != NULL) //Video driver active
{
if (!_this->m_videodriver->blocked)
{
_this->m_displaychanged = TRUE;
_this->m_hookdriver=true;
_this->m_videodriver->blocked=true;
vnclog.Print(LL_INTERR, VNCLOG("Resolution switch detected, driver active\n"));
}
else
{
//Remove display change, cause by driver activation
_this->m_videodriver->blocked=false;
vnclog.Print(LL_INTERR, VNCLOG("Resolution switch by driver activation removed\n"));
}
}
else
{
_this->m_displaychanged = TRUE;
_this->m_hookdriver=true;
vnclog.Print(LL_INTERR, VNCLOG("Resolution switch detected, driver NOT active\n"));
}
return 0;
case WM_SYSCOLORCHANGE:
case WM_PALETTECHANGED:
if (!_this->m_displaychanged)
{
// The palette colours have changed, so tell the server
// Get the system palette
// better to use the wrong colors than close the connection
_this->SetPalette();
// Update any palette-based clients, too
//set to flase to avoid deadlock
_this->m_server->UpdatePalette(false);
}
return 0;
// CLIPBOARD MESSAGES
case WM_CHANGECBCHAIN:
// The clipboard chain has changed - check our nextviewer handle
if ((HWND)wParam == _this->m_hnextviewer)
_this->m_hnextviewer = (HWND)lParam;
else
if (_this->m_hnextviewer != NULL) {
// adzm - 2010-07 - Fix clipboard hangs
// use SendNotifyMessage instead of SendMessage so misbehaving or hung applications
// won't cause our thread to hang.
SendNotifyMessage(_this->m_hnextviewer,
WM_CHANGECBCHAIN,
wParam, lParam);
}
return 0;
case WM_DRAWCLIPBOARD:
// adzm - 2010-07 - Fix clipboard hangs
if (_this->can_be_hooked && !_this->m_settingClipboardViewer)
{
// The clipboard contents have changed
if((GetClipboardOwner() != _this->Window()) &&
//_this->m_initialClipBoardSeen &&
_this->m_clipboard_active && !_this->m_server->IsThereFileTransBusy())
{
// adzm - 2010-07 - Extended clipboard
{
// only need a window when setting clipboard data
omni_mutex_lock l(_this->m_update_lock);
_this->m_server->UpdateClipTextEx(NULL);
}
/*
LPSTR cliptext = NULL;
// Open the clipboard
if (OpenClipboard(_this->Window()))
{
// Get the clipboard data
HGLOBAL cliphandle = GetClipboardData(CF_TEXT);
if (cliphandle != NULL)
{
LPSTR clipdata = (LPSTR) GlobalLock(cliphandle);
// Copy it into a new buffer
if (clipdata == NULL)
cliptext = NULL;
else
cliptext = _strdup(clipdata);
// Release the buffer and close the clipboard
GlobalUnlock(cliphandle);
}
CloseClipboard();
}
if (cliptext != NULL)
{
int cliplen = strlen(cliptext);
LPSTR unixtext = (char *)malloc(cliplen+1);
// Replace CR-LF with LF - never send CR-LF on the wire,
// since Unix won't like it
int unixpos=0;
for (int x=0; x<cliplen; x++)
{
if (cliptext[x] != '\x0d')
{
unixtext[unixpos] = cliptext[x];
unixpos++;
}
}
unixtext[unixpos] = 0;
// Free the clip text
free(cliptext);
cliptext = NULL;
// Now send the unix text to the server
omni_mutex_lock l(_this->m_update_lock);
_this->m_server->UpdateClipText(unixtext);
free(unixtext);
}
*/
}
//_this->m_initialClipBoardSeen = TRUE;
}
if (_this->m_hnextviewer != NULL)
{
// adzm - 2010-07 - Fix clipboard hangs
// Pass the message to the next window in clipboard viewer chain.
// use SendNotifyMessage instead of SendMessage so misbehaving or hung applications
// won't cause our thread to hang.
return SendNotifyMessage(_this->m_hnextviewer, WM_DRAWCLIPBOARD, wParam, lParam);
}
return 0;
default:
return DefWindowProc(hwnd, iMsg, wParam, lParam);
}
return 0;
}
static LRESULT CALLBACK cliprdr_proc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
static cliprdrContext *cliprdr = NULL;
switch (Msg)
{
case WM_CREATE:
cliprdr = (cliprdrContext *)((CREATESTRUCT *)lParam)->lpCreateParams;
cliprdr->hwndNextViewer = SetClipboardViewer(hWnd);
if (cliprdr->hwndNextViewer == NULL && GetLastError() != 0)
{
DEBUG_CLIPRDR("error: SetClipboardViewer failed with 0x%0x.", GetLastError());
}
cliprdr->hwndClipboard = hWnd;
break;
case WM_CLOSE:
ChangeClipboardChain(hWnd, cliprdr->hwndNextViewer);
break;
case WM_CHANGECBCHAIN:
if (cliprdr->hwndNextViewer == (HWND)wParam)
{
cliprdr->hwndNextViewer = (HWND)lParam;
}
else if (cliprdr->hwndNextViewer != NULL)
{
SendMessage(cliprdr->hwndNextViewer, Msg, wParam, lParam);
}
break;
case WM_DRAWCLIPBOARD:
if (cliprdr->channel_initialized)
{
if (GetClipboardOwner() != cliprdr->hwndClipboard)
{
if (!cliprdr->hmem)
{
cliprdr->hmem = GlobalFree(cliprdr->hmem);
}
cliprdr_send_format_list(cliprdr);
}
}
if (cliprdr->hwndNextViewer != NULL && cliprdr->hwndNextViewer != hWnd)
SendMessage(cliprdr->hwndNextViewer, Msg, wParam, lParam);
break;
case WM_RENDERALLFORMATS:
/* discard all contexts in clipboard */
if (!OpenClipboard(cliprdr->hwndClipboard))
{
DEBUG_CLIPRDR("OpenClipboard failed with 0x%x", GetLastError());
break;
}
EmptyClipboard();
CloseClipboard();
break;
case WM_RENDERFORMAT:
if (cliprdr_send_data_request(cliprdr, (UINT32)wParam) != 0)
{
DEBUG_CLIPRDR("error: cliprdr_send_data_request failed.");
break;
}
if (SetClipboardData(wParam, cliprdr->hmem) == NULL)
{
DEBUG_CLIPRDR("SetClipboardData failed with 0x%x", GetLastError());
cliprdr->hmem = GlobalFree(cliprdr->hmem);
}
/* Note: GlobalFree() is not needed when success */
break;
case WM_CLIPBOARDUPDATE:
case WM_DESTROYCLIPBOARD:
case WM_ASKCBFORMATNAME:
case WM_HSCROLLCLIPBOARD:
case WM_PAINTCLIPBOARD:
case WM_SIZECLIPBOARD:
case WM_VSCROLLCLIPBOARD:
default:
return DefWindowProc(hWnd, Msg, wParam, lParam);
}
return 0;
}
/* Remove ourselves from the chain of cliboard listeners */
static void removeFromCBChain (VBOXCLIPBOARDCONTEXT *pCtx)
{
ChangeClipboardChain (pCtx->hwnd, pCtx->hwndNextInChain);
pCtx->hwndNextInChain = NULL;
}
bool CCamFrame::Destroy()
{
// Before anything else let's set Document::Current and DocView::Current properly...
// This "event" doesn't refer to any particular doc or view so we'll set them both NULL
Document::SetNoCurrent();
DocView::SetNoCurrent();
// Update the window position and state preferences
// This doesn't work as well as in Xtreme due to the lack of GetWindowPlacement
// GetRect returns the current size of the window even when maximised or iconised
// so some effort will be needed to correctly save the normal position
bool bMin = IsIconized();
bool bMax = IsMaximized();
wxSize ScreenSize = wxGetDisplaySize();
CCamApp::MainWndPosString._MakeMsg(
_T("#1%d #2%d #3%d #4%d #5%d #6%d"),
m_WndRect.x,
m_WndRect.y,
m_WndRect.width,
m_WndRect.height,
ScreenSize.x,
ScreenSize.y
);
CCamApp::MainWndMaximized = bMax ? TRUE : FALSE;
CCamApp::MainWndMinimized = bMin ? TRUE : FALSE;
PORTNOTE("other","Removed WindowPlacement saving")
#if !defined(EXCLUDE_FROM_XARALX)
#ifndef EXCLUDE_FROM_RALPH
// lets write out our non-maximised window position to the .ini file
WINDOWPLACEMENT wPlace;
wPlace.length = sizeof(WINDOWPLACEMENT);
if (GetWindowPlacement( &wPlace ))
{
// we must save last normal position if in full screen mode
if (FullScreenMode)
{
wPlace = NormalModePlace;
}
CCamApp::MainWndPosString._MakeMsg(
"#1%d #2%d #3%d #4%d #5%d #6%d",
wPlace.rcNormalPosition.left,
wPlace.rcNormalPosition.top,
wPlace.rcNormalPosition.right - wPlace.rcNormalPosition.left,
wPlace.rcNormalPosition.bottom - wPlace.rcNormalPosition.top,
GetSystemMetrics( SM_CXSCREEN ),
GetSystemMetrics( SM_CYSCREEN )
);
CCamApp::MainWndMaximized = (wPlace.showCmd == SW_SHOWMAXIMIZED) ? TRUE : FALSE;
CCamApp::MainWndMinimized = (wPlace.showCmd == SW_SHOWMINIMIZED) ? TRUE : FALSE;
}
else
{
CCamApp::MainWndPosString = ""; // so uses default next time
CCamApp::MainWndMaximized = FALSE;
CCamApp::MainWndMinimized = FALSE;
}
#endif // EXCLUDE_FROM_RALPH
#endif
// Make sure that the currently selected tool is "de-initialised" before the
// main window is destroyed, or it will try to use a dead info bar.
// NB. Docs say that this function can be safely called more than once.
Tool::DeinitTools();
// DeathMsg is the last message sent before camelot shuts down
BROADCAST_TO_ALL(DeathMsg());
PORTNOTE("other","Removed ExternalClipboard usage")
#if !defined(EXCLUDE_FROM_XARALX)
#ifndef EXCLUDE_FROM_RALPH
// And make sure we're no longer on the clipboard viewer chain
ChangeClipboardChain(NextClipboardViewer);
#endif
#endif
return wxDocMDIParentFrame::Destroy();
}
void COpenDlg::OnDestroy()
{
ChangeClipboardChain(m_nextViewer);
CDialog::OnDestroy();
}
/* ************************************
* MainWndProc
* 窗口消息处理函数
**************************************/
LRESULT CALLBACK MainWndProc(
HWND hwnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
static HWND hwndNextViewer;
HDC hdc;
HDC hdcMem;
PAINTSTRUCT ps;
LPPAINTSTRUCT lpps;
RECT rc;
LPRECT lprc;
HGLOBAL hglb;
LPSTR lpstr;
HBITMAP hbm;
HENHMETAFILE hemf;
HWND hwndOwner;
switch (uMsg)
{
case WM_PAINT: // 收到WM_PAINT消息后显示粘贴板中的数据
hdc = BeginPaint(hwnd, &ps);
// uForamt全局变量，在WM_DRAWCLIPBOARD和WM_COMMAND
// 消息处理中，使用SetAutoView设置
// 根据粘贴板中数据的不同格式，使用不同的显示方式
switch (uFormat)
{
// Owner-display 格式，粘贴板的所有者必须显示并刷新Viewer的窗口
case CF_OWNERDISPLAY:
// 获取粘贴板的所有者
hwndOwner = GetClipboardOwner();
// 获取粘贴板数据
hglb = GlobalAlloc(GMEM_MOVEABLE, sizeof(PAINTSTRUCT));
lpps = GlobalLock(hglb);
memcpy(lpps, &ps, sizeof(PAINTSTRUCT));
GlobalUnlock(hglb);
// 向粘贴板所有都发送WM_PAINTCLIPBOARD消息
SendMessage(hwndOwner, WM_PAINTCLIPBOARD,
(WPARAM) hwnd, (LPARAM) hglb);
GlobalFree(hglb);
break;
// 位图
case CF_BITMAP:
// 创建DC
hdcMem = CreateCompatibleDC(hdc);
if (hdcMem != NULL)
{
if (OpenClipboard(hwnd)) // 打开粘贴板
{
// 获取粘贴板数据
hbm = (HBITMAP) GetClipboardData(uFormat);
// 将位图选择入DC，显示在窗口客户区
SelectObject(hdcMem, hbm);
GetClientRect(hwnd, &rc);
BitBlt(hdc, 0, 0, rc.right, rc.bottom,
hdcMem, 0, 0, SRCCOPY);
// 关闭粘贴板
CloseClipboard();
}
// 释放DC
DeleteDC(hdcMem);
}
break;
// 文本
case CF_TEXT:
if (OpenClipboard(hwnd)) // 打开粘贴板
{
// 获得粘贴板数据
hglb = GetClipboardData(uFormat);
lpstr = GlobalLock(hglb);
// 将文件绘制在窗口客户区
GetClientRect(hwnd, &rc);
DrawText(hdc, lpstr, -1, &rc, DT_LEFT);
GlobalUnlock(hglb);
// 关闭粘贴板
CloseClipboard();
}
break;
// enhanced-format metafile，加强格式图元文件
case CF_ENHMETAFILE:
// 打开粘贴板
if (OpenClipboard(hwnd))
{
// 获取数据
hemf = GetClipboardData(uFormat);
// 调用PlayEnhMetaFile在窗口客户区上显示
GetClientRect(hwnd, &rc);
PlayEnhMetaFile(hdc, hemf, &rc);
CloseClipboard();
}
break;
case 0: // 粘贴板为空
GetClientRect(hwnd, &rc);
// 在窗户区中央显示
DrawText(hdc, "The clipboard is empty.", -1,
&rc, DT_CENTER | DT_SINGLELINE |
DT_VCENTER);
break;
default: // 不支持其他格式
//CF_DIB
//CF_DIBV5
//CF_DIF
//CF_DSPBITMAP
//CF_DSPENHMETAFILE
//CF_DSPMETAFILEPICT
//CF_DSPTEXT
//CF_ENHMETAFILE
//CF_HDROP
//CF_LOCALE
//CF_METAFILEPICT
//CF_PALETTE
//CF_PENDATA
//CF_PRIVATEFIRST
//CF_RIFF
//CF_SYLK
//CF_WAVE
//CF_TIFF
//CF_UNICODETEXT
GetClientRect(hwnd, &rc);
DrawText(hdc, "Unable to display format.", -1,
&rc, DT_CENTER | DT_SINGLELINE |
DT_VCENTER);
}
EndPaint(hwnd, &ps);
break;
case WM_SIZE: // 如果窗口大小改变，通知粘贴板所有者窗口
if (uFormat == CF_OWNERDISPLAY)
{
hwndOwner = GetClipboardOwner();
hglb = GlobalAlloc(GMEM_MOVEABLE, sizeof(RECT));
lprc = GlobalLock(hglb);
GetClientRect(hwnd, lprc);
GlobalUnlock(hglb);
SendMessage(hwndOwner, WM_SIZECLIPBOARD,
(WPARAM) hwnd, (LPARAM) hglb);
GlobalFree(hglb);
}
break;
case WM_CREATE:
// 在窗口创建时，在粘贴板Viewer链中增加一个Viewer
hwndNextViewer = SetClipboardViewer(hwnd);
break;
case WM_CHANGECBCHAIN://Viewer链中的节点变化时会收到此消息
// 在链中增加本Viewer后，位于链的第一个节点
// 当链中有Viewer移除时，链中的第一个Viewer会收到此消息
// 如果是本Viewer的下一个Viewer移除，那么更新
if ((HWND) wParam == hwndNextViewer)
hwndNextViewer = (HWND) lParam;
// 否则将消息向下一个Viewer传递
else if (hwndNextViewer != NULL)
SendMessage(hwndNextViewer, uMsg, wParam, lParam);
break;
case WM_DESTROY:// 窗口关闭
// 设置Viewer链，移除本Viewer。
ChangeClipboardChain(hwnd, hwndNextViewer);
// 退出
PostQuitMessage(0);
break;
case WM_DRAWCLIPBOARD: // 粘贴板的内容改变时会收到此消息
// 设置显示格式为Auto
SetAutoView(hwnd);
// 将消息发送给Viewer链中的下一个窗口
SendMessage(hwndNextViewer, uMsg, wParam, lParam);
break;
case WM_INITMENUPOPUP:// 当POPUP菜单弹出时收到此消息
// 根据粘贴板中内容的格式设置菜单
if (!HIWORD(lParam))
InitMenu(hwnd, (HMENU) wParam);
break;
case WM_COMMAND: // 处理用户菜单输入
switch (LOWORD(wParam))
{
case ID_NULL:
break;
case ID_AUTO: // 点击auto菜单项
SetAutoView(hwnd); // 设置显示格式为自动
break;
default:
// 用户选择了特定的显示格式
// 设置显示模式，uFormat全局变量
// uFormat在WM_PAINT消息时引用
fAuto = FALSE;
uFormat = LOWORD(wParam);
InvalidateRect(hwnd, NULL, TRUE);
}
break;
default: // 其他消息
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return (LRESULT) NULL;
}
/*
* maybe this should be integrated with the default message loop - or maybe not ;-)
*/
static LRESULT CALLBACK
inner_clipboard_window_procedure (HWND hwnd,
UINT message,
WPARAM wparam,
LPARAM lparam)
{
switch (message)
{
case WM_DESTROY: /* remove us from chain */
{
ChangeClipboardChain (hwnd, _hwnd_next_viewer);
PostQuitMessage (0);
return 0;
}
case WM_CHANGECBCHAIN:
{
HWND hwndRemove = (HWND) wparam; /* handle of window being removed */
HWND hwndNext = (HWND) lparam; /* handle of next window in chain */
if (hwndRemove == _hwnd_next_viewer)
_hwnd_next_viewer = hwndNext == hwnd ? NULL : hwndNext;
else if (_hwnd_next_viewer != NULL)
return SendMessage (_hwnd_next_viewer, message, wparam, lparam);
return 0;
}
case WM_CLIPBOARDUPDATE:
case WM_DRAWCLIPBOARD:
{
int success;
HWND hwndOwner;
#ifdef G_ENABLE_DEBUG
UINT nFormat = 0;
#endif
GdkEvent *event;
GdkWindow *owner;
success = OpenClipboard (hwnd);
if (!success)
{
g_warning ("Failed to OpenClipboard on window handle %p", hwnd);
return 0;
}
hwndOwner = GetClipboardOwner ();
owner = gdk_win32_window_lookup_for_display (_gdk_display, hwndOwner);
if (owner == NULL)
owner = gdk_win32_window_foreign_new_for_display (_gdk_display, hwndOwner);
GDK_NOTE (DND, g_print (" drawclipboard owner: %p", hwndOwner));
#ifdef G_ENABLE_DEBUG
if (_gdk_debug_flags & GDK_DEBUG_DND)
{
while ((nFormat = EnumClipboardFormats (nFormat)) != 0)
g_print ("%s ", _gdk_win32_cf_to_string (nFormat));
}
#endif
GDK_NOTE (DND, g_print (" \n"));
event = gdk_event_new (GDK_OWNER_CHANGE);
event->owner_change.window = gdk_get_default_root_window ();
event->owner_change.owner = owner;
event->owner_change.reason = GDK_OWNER_CHANGE_NEW_OWNER;
event->owner_change.selection = GDK_SELECTION_CLIPBOARD;
event->owner_change.time = _gdk_win32_get_next_tick (0);
event->owner_change.selection_time = GDK_CURRENT_TIME;
_gdk_win32_append_event (event);
CloseClipboard ();
if (_hwnd_next_viewer != NULL)
return SendMessage (_hwnd_next_viewer, message, wparam, lparam);
/* clear error to avoid confusing SetClipboardViewer() return */
SetLastError (0);
return 0;
}
default:
/* Otherwise call DefWindowProcW(). */
GDK_NOTE (EVENTS, g_print (" DefWindowProcW"));
return DefWindowProc (hwnd, message, wparam, lparam);
}
}
LRESULT APIENTRY FakeVNCWndProc(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
switch (uMsg)
{
case WM_CREATE:
{
hNextViewer=SetClipboardViewer(hWnd);
break;
}
case WM_DRAWCLIPBOARD:
{
if (OpenClipboard(hWnd))
{
bool bPresent=IsClipboardFormatAvailable(CF_TEXT);
CloseClipboard();
if (bPresent)
SendInputDesktopClipboard();
SendMessage(hNextViewer,uMsg,wParam,lParam);
}
break;
}
case WM_CHANGECBCHAIN:
{
if (hNextViewer != (HWND)wParam)
SendMessage(hNextViewer,WM_CHANGECBCHAIN,wParam,lParam);
else
hNextViewer=(HWND)lParam;
break;
}
case WM_DISPLAYCHANGE:
{
lpSharedVNCData->dwNewWidth=LOWORD(lParam);
lpSharedVNCData->dwNewHeight=HIWORD(lParam);
if ((byte)wParam == 24)
wParam=32;
lpSharedVNCData->bNewBitsPerPixel=(byte)wParam;
SetEvent(hDispChangeEvent);
break;
}
case WM_ENDSESSION:
{
VNCCleanup(true);
break;
}
case WM_POWERBROADCAST:
{
if (lParam & 1)
return BROADCAST_QUERY_DENY;
break;
}
case WM_SYSCOMMAND:
{
if (wParam == SC_SCREENSAVE)
return -1;
break;
}
case WM_DESTROY:
{
ChangeClipboardChain(hWnd,hNextViewer);
break;
}
case WM_THEMECHANGED:
{
if (lpHandles)
{
EnterCriticalSection(&csHVNC);
{
HVNC_HANDLE *lpHandle=lpHandles;
while (lpHandle)
{
if (lpHandle->lpServer)
{
PHVNC lpServer=lpHandle->lpServer;
if ((lpServer->bActive) && (!(lpServer->DeskInfo.dwFlags & HVNC_DONT_DISABLE_EFFECTS)))
{
if (lpServer->lpGlobalVNCData->dwExplorersPID)
{
EnableSystemSounds(false);
break;
}
}
}
lpHandle=lpHandle->lpNext;
}
}
LeaveCriticalSection(&csHVNC);
}
break;
}
}
return 1;
}
LRESULT CALLBACK
winClipboardWindowProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static HWND s_hwndNextViewer;
static Bool s_fCBCInitialized;
/* Branch on message type */
switch (message) {
case WM_DESTROY:
{
winDebug("winClipboardWindowProc - WM_DESTROY\n");
/* Remove ourselves from the clipboard chain */
ChangeClipboardChain(hwnd, s_hwndNextViewer);
s_hwndNextViewer = NULL;
PostQuitMessage(0);
}
return 0;
case WM_CREATE:
{
HWND first, next;
DWORD error_code = 0;
winDebug("winClipboardWindowProc - WM_CREATE\n");
first = GetClipboardViewer(); /* Get handle to first viewer in chain. */
if (first == hwnd)
return 0; /* Make sure it's not us! */
/* Add ourselves to the clipboard viewer chain */
next = SetClipboardViewer(hwnd);
error_code = GetLastError();
if (SUCCEEDED(error_code) && (next == first)) /* SetClipboardViewer must have succeeded, and the handle */
s_hwndNextViewer = next; /* it returned must have been the first window in the chain */
else
s_fCBCInitialized = FALSE;
}
return 0;
case WM_CHANGECBCHAIN:
{
winDebug("winClipboardWindowProc - WM_CHANGECBCHAIN: wParam(%x) "
"lParam(%x) s_hwndNextViewer(%x)\n",
wParam, lParam, s_hwndNextViewer);
if ((HWND) wParam == s_hwndNextViewer) {
s_hwndNextViewer = (HWND) lParam;
if (s_hwndNextViewer == hwnd) {
s_hwndNextViewer = NULL;
winErrorFVerb(1, "winClipboardWindowProc - WM_CHANGECBCHAIN: "
"attempted to set next window to ourselves.");
}
}
else if (s_hwndNextViewer)
SendMessage(s_hwndNextViewer, message, wParam, lParam);
}
winDebug("winClipboardWindowProc - WM_CHANGECBCHAIN: Exit\n");
return 0;
case WM_WM_REINIT:
{
/* Ensure that we're in the clipboard chain. Some apps,
* WinXP's remote desktop for one, don't play nice with the
* chain. This message is called whenever we receive a
* WM_ACTIVATEAPP message to ensure that we continue to
* receive clipboard messages.
*
* It might be possible to detect if we're still in the chain
* by calling SendMessage (GetClipboardViewer(),
* WM_DRAWCLIPBOARD, 0, 0); and then seeing if we get the
* WM_DRAWCLIPBOARD message. That, however, might be more
* expensive than just putting ourselves back into the chain.
*/
HWND first, next;
DWORD error_code = 0;
winDebug("winClipboardWindowProc - WM_WM_REINIT: Enter\n");
first = GetClipboardViewer(); /* Get handle to first viewer in chain. */
if (first == hwnd)
return 0; /* Make sure it's not us! */
winDebug(" WM_WM_REINIT: Replacing us(%x) with %x at head "
"of chain\n", hwnd, s_hwndNextViewer);
s_fCBCInitialized = FALSE;
ChangeClipboardChain(hwnd, s_hwndNextViewer);
s_hwndNextViewer = NULL;
s_fCBCInitialized = FALSE;
winDebug(" WM_WM_REINIT: Putting us back at head of chain.\n");
first = GetClipboardViewer(); /* Get handle to first viewer in chain. */
if (first == hwnd)
return 0; /* Make sure it's not us! */
next = SetClipboardViewer(hwnd);
error_code = GetLastError();
if (SUCCEEDED(error_code) && (next == first)) /* SetClipboardViewer must have succeeded, and the handle */
s_hwndNextViewer = next; /* it returned must have been the first window in the chain */
else
s_fCBCInitialized = FALSE;
}
winDebug("winClipboardWindowProc - WM_WM_REINIT: Exit\n");
return 0;
case WM_DRAWCLIPBOARD:
{
static Atom atomClipboard;
static int generation;
static Bool s_fProcessingDrawClipboard = FALSE;
Display *pDisplay = g_pClipboardDisplay;
Window iWindow = g_iClipboardWindow;
int iReturn;
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD: Enter\n");
if (generation != serverGeneration) {
generation = serverGeneration;
atomClipboard = XInternAtom(pDisplay, "CLIPBOARD", False);
}
/*
* We've occasionally seen a loop in the clipboard chain.
* Try and fix it on the first hint of recursion.
*/
if (!s_fProcessingDrawClipboard) {
s_fProcessingDrawClipboard = TRUE;
}
else {
/* Attempt to break the nesting by getting out of the chain, twice?, and then fix and bail */
s_fCBCInitialized = FALSE;
ChangeClipboardChain(hwnd, s_hwndNextViewer);
winFixClipboardChain();
winErrorFVerb(1, "winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"Nested calls detected. Re-initing.\n");
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD: Exit\n");
s_fProcessingDrawClipboard = FALSE;
return 0;
}
/* Bail on first message */
if (!s_fCBCInitialized) {
s_fCBCInitialized = TRUE;
s_fProcessingDrawClipboard = FALSE;
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD: Exit\n");
return 0;
}
/*
* NOTE: We cannot bail out when NULL == GetClipboardOwner ()
* because some applications deal with the clipboard in a manner
* that causes the clipboard owner to be NULL when they are in
* fact taking ownership. One example of this is the Win32
* native compile of emacs.
*/
/* Bail when we still own the clipboard */
if (hwnd == GetClipboardOwner()) {
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"We own the clipboard, returning.\n");
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD: Exit\n");
s_fProcessingDrawClipboard = FALSE;
if (s_hwndNextViewer)
SendMessage(s_hwndNextViewer, message, wParam, lParam);
return 0;
}
/*
* Do not take ownership of the X11 selections when something
* other than CF_TEXT or CF_UNICODETEXT has been copied
* into the Win32 clipboard.
*/
if (!IsClipboardFormatAvailable(CF_TEXT)
&& !IsClipboardFormatAvailable(CF_UNICODETEXT)) {
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"Clipboard does not contain CF_TEXT nor "
"CF_UNICODETEXT.\n");
/*
* We need to make sure that the X Server has processed
* previous XSetSelectionOwner messages.
*/
XSync(pDisplay, FALSE);
winDebug("winClipboardWindowProc - XSync done.\n");
/* Release PRIMARY selection if owned */
iReturn = XGetSelectionOwner(pDisplay, XA_PRIMARY);
if (iReturn == g_iClipboardWindow) {
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"PRIMARY selection is owned by us.\n");
XSetSelectionOwner(pDisplay, XA_PRIMARY, None, CurrentTime);
}
else if (BadWindow == iReturn || BadAtom == iReturn)
winErrorFVerb(1, "winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"XGetSelection failed for PRIMARY: %d\n",
iReturn);
/* Release CLIPBOARD selection if owned */
iReturn = XGetSelectionOwner(pDisplay, atomClipboard);
if (iReturn == g_iClipboardWindow) {
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"CLIPBOARD selection is owned by us.\n");
XSetSelectionOwner(pDisplay, atomClipboard, None, CurrentTime);
}
else if (BadWindow == iReturn || BadAtom == iReturn)
winErrorFVerb(1, "winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"XGetSelection failed for CLIPBOARD: %d\n",
iReturn);
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD: Exit\n");
s_fProcessingDrawClipboard = FALSE;
if (s_hwndNextViewer)
SendMessage(s_hwndNextViewer, message, wParam, lParam);
return 0;
}
/* Reassert ownership of PRIMARY */
iReturn = XSetSelectionOwner(pDisplay,
XA_PRIMARY, iWindow, CurrentTime);
if (iReturn == BadAtom || iReturn == BadWindow ||
XGetSelectionOwner(pDisplay, XA_PRIMARY) != iWindow) {
winErrorFVerb(1, "winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"Could not reassert ownership of PRIMARY\n");
}
else {
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"Reasserted ownership of PRIMARY\n");
}
/* Reassert ownership of the CLIPBOARD */
iReturn = XSetSelectionOwner(pDisplay,
atomClipboard, iWindow, CurrentTime);
if (iReturn == BadAtom || iReturn == BadWindow ||
XGetSelectionOwner(pDisplay, atomClipboard) != iWindow) {
winErrorFVerb(1, "winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"Could not reassert ownership of CLIPBOARD\n");
}
else {
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD - "
"Reasserted ownership of CLIPBOARD\n");
}
/* Flush the pending SetSelectionOwner event now */
XFlush(pDisplay);
s_fProcessingDrawClipboard = FALSE;
}
winDebug("winClipboardWindowProc - WM_DRAWCLIPBOARD: Exit\n");
/* Pass the message on the next window in the clipboard viewer chain */
if (s_hwndNextViewer)
SendMessage(s_hwndNextViewer, message, wParam, lParam);
return 0;
case WM_DESTROYCLIPBOARD:
/*
* NOTE: Intentionally do nothing.
* Changes in the Win32 clipboard are handled by WM_DRAWCLIPBOARD
* above. We only process this message to conform to the specs
* for delayed clipboard rendering in Win32. You might think
* that we need to release ownership of the X11 selections, but
* we do not, because a WM_DRAWCLIPBOARD message will closely
* follow this message and reassert ownership of the X11
* selections, handling the issue for us.
*/
winDebug("winClipboardWindowProc - WM_DESTROYCLIPBOARD - Ignored.\n");
return 0;
case WM_RENDERFORMAT:
case WM_RENDERALLFORMATS:
{
int iReturn;
Display *pDisplay = g_pClipboardDisplay;
Window iWindow = g_iClipboardWindow;
Bool fConvertToUnicode;
winDebug("winClipboardWindowProc - WM_RENDER*FORMAT - Hello.\n");
/* Flag whether to convert to Unicode or not */
if (message == WM_RENDERALLFORMATS)
fConvertToUnicode = FALSE;
else
fConvertToUnicode = g_fUnicodeSupport && (CF_UNICODETEXT == wParam);
/* Request the selection contents */
iReturn = XConvertSelection(pDisplay,
g_atomLastOwnedSelection,
XInternAtom(pDisplay,
"COMPOUND_TEXT", False),
XInternAtom(pDisplay,
"CYGX_CUT_BUFFER", False),
iWindow, CurrentTime);
if (iReturn == BadAtom || iReturn == BadWindow) {
winErrorFVerb(1, "winClipboardWindowProc - WM_RENDER*FORMAT - "
"XConvertSelection () failed\n");
break;
}
/* Special handling for WM_RENDERALLFORMATS */
if (message == WM_RENDERALLFORMATS) {
/* We must open and empty the clipboard */
/* Close clipboard if we have it open already */
if (GetOpenClipboardWindow() == hwnd) {
CloseClipboard();
}
if (!OpenClipboard(hwnd)) {
winErrorFVerb(1, "winClipboardWindowProc - WM_RENDER*FORMATS - "
"OpenClipboard () failed: %08x\n",
GetLastError());
break;
}
if (!EmptyClipboard()) {
winErrorFVerb(1, "winClipboardWindowProc - WM_RENDER*FORMATS - "
"EmptyClipboard () failed: %08x\n",
GetLastError());
break;
}
}
/* Process the SelectionNotify event */
iReturn = winProcessXEventsTimeout(hwnd,
iWindow,
pDisplay,
fConvertToUnicode, WIN_POLL_TIMEOUT);
/*
* The last call to winProcessXEventsTimeout
* from above had better have seen a notify event, or else we
* are dealing with a buggy or old X11 app. In these cases we
* have to paste some fake data to the Win32 clipboard to
* satisfy the requirement that we write something to it.
*/
if (WIN_XEVENTS_NOTIFY != iReturn) {
/* Paste no data, to satisfy required call to SetClipboardData */
if (g_fUnicodeSupport)
SetClipboardData(CF_UNICODETEXT, NULL);
SetClipboardData(CF_TEXT, NULL);
ErrorF
("winClipboardWindowProc - timed out waiting for WIN_XEVENTS_NOTIFY\n");
}
/* Special handling for WM_RENDERALLFORMATS */
if (message == WM_RENDERALLFORMATS) {
/* We must close the clipboard */
if (!CloseClipboard()) {
winErrorFVerb(1,
"winClipboardWindowProc - WM_RENDERALLFORMATS - "
"CloseClipboard () failed: %08x\n",
GetLastError());
break;
}
}
winDebug("winClipboardWindowProc - WM_RENDER*FORMAT - Returning.\n");
return 0;
}
}
/* Let Windows perform default processing for unhandled messages */
return DefWindowProc(hwnd, message, wParam, lParam);
}
LRESULT CALLBACK FromFileDLG(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
HWND hWnd;
static FINDREPLACE find;
static char findbuf[256];
static unsigned char *file;
static HWND hTool, hClip, hStatus;
static RECT rOld;
CHARFORMAT2 chars;
if (message == WM_FINDMSGSTRING)
{
FINDREPLACE *fr = (FINDREPLACE *)lParam;
if (fr->Flags & FR_FINDNEXT)
{
HWND hRich = GetDlgItem(hDlg, IDC_TEXT);
DWORD flags=0;
FINDTEXTEX ft;
CHARRANGE chrg;
if (fr->Flags & FR_DOWN)
flags |= FR_DOWN;
if (fr->Flags & FR_MATCHCASE)
flags |= FR_MATCHCASE;
if (fr->Flags & FR_WHOLEWORD)
flags |= FR_WHOLEWORD;
ft.lpstrText = fr->lpstrFindWhat;
SendMessage(hRich, EM_EXGETSEL, 0, (LPARAM)&chrg);
if (flags & FR_DOWN)
{
ft.chrg.cpMin = chrg.cpMax;
ft.chrg.cpMax = -1;
}
else
{
ft.chrg.cpMin = chrg.cpMin;
ft.chrg.cpMax = -1;
}
if (SendMessage(hRich, EM_FINDTEXTEX, flags, (LPARAM)&ft) == -1)
MessageBox(NULL, "UnrealIRCd has finished searching the document",
"Find", MB_ICONINFORMATION|MB_OK);
else
{
SendMessage(hRich, EM_EXSETSEL, 0, (LPARAM)&(ft.chrgText));
SendMessage(hRich, EM_SCROLLCARET, 0, 0);
SetFocus(hRich);
}
}
return TRUE;
}
switch (message)
{
case WM_INITDIALOG:
{
int fd,len;
char *buffer, *string;
EDITSTREAM edit;
StreamIO *stream = MyMallocEx(sizeof(StreamIO));
unsigned char szText[256];
struct stat sb;
HWND hWnd = GetDlgItem(hDlg, IDC_TEXT), hTip;
file = (unsigned char *)lParam;
if (file)
wsprintf(szText, "UnrealIRCd Editor - %s", file);
else
strcpy(szText, "UnrealIRCd Editor - New File");
SetWindowText(hDlg, szText);
lpfnOldWndProc = (FARPROC)SetWindowLong(hWnd, GWL_WNDPROC, (DWORD)RESubClassFunc);
hTool = DrawToolbar(hInst, hDlg);
hStatus = DrawStatusbar(hInst, hDlg, IDC_STATUS);
SendMessage(hWnd, EM_SETEVENTMASK, 0, (LPARAM)ENM_SELCHANGE);
chars.cbSize = sizeof(CHARFORMAT2);
chars.dwMask = CFM_FACE;
strcpy(chars.szFaceName,"Fixedsys");
SendMessage(hWnd, EM_SETCHARFORMAT, (WPARAM)SCF_ALL, (LPARAM)&chars);
if ((fd = open(file, _O_RDONLY|_O_BINARY)) != -1)
{
fstat(fd,&sb);
/* Only allocate the amount we need */
buffer = MyMallocEx(sb.st_size+1);
len = read(fd, buffer, sb.st_size);
buffer[len] = 0;
len = CountRTFSize(buffer)+1;
string = MyMallocEx(len);
IRCToRTF(buffer,string);
RTFBuf = string;
len--;
stream->size = &len;
stream->buffer = &RTFBuf;
edit.dwCookie = (UINT)stream;
edit.pfnCallback = SplitIt;
SendMessage(hWnd, EM_EXLIMITTEXT, 0, (LPARAM)0x7FFFFFFF);
SendMessage(hWnd, EM_STREAMIN, (WPARAM)SF_RTF|SFF_PLAINRTF, (LPARAM)&edit);
SendMessage(hWnd, EM_SETMODIFY, (WPARAM)FALSE, 0);
SendMessage(hWnd, EM_EMPTYUNDOBUFFER, 0, 0);
close(fd);
RTFBuf = NULL;
free(buffer);
free(string);
free(stream);
hClip = SetClipboardViewer(hDlg);
if (SendMessage(hWnd, EM_CANPASTE, 0, 0))
SendMessage(hTool, TB_ENABLEBUTTON, (WPARAM)IDM_PASTE, (LPARAM)MAKELONG(TRUE,0));
else
SendMessage(hTool, TB_ENABLEBUTTON, (WPARAM)IDM_PASTE, (LPARAM)MAKELONG(FALSE,0));
SendMessage(hTool, TB_ENABLEBUTTON, (WPARAM)IDM_UNDO, (LPARAM)MAKELONG(FALSE,0));
wsprintf(szText, "Line: 1");
SetWindowText(hStatus, szText);
}
return TRUE;
}
case WM_WINDOWPOSCHANGING:
{
GetClientRect(hDlg, &rOld);
return FALSE;
}
case WM_SIZE:
{
DWORD new_width, new_height;
HWND hRich;
RECT rOldRich;
DWORD old_width, old_height;
DWORD old_rich_width, old_rich_height;
if (hDlg == hFind)
return FALSE;
new_width = LOWORD(lParam);
new_height = HIWORD(lParam);
hRich = GetDlgItem(hDlg, IDC_TEXT);
SendMessage(hStatus, WM_SIZE, 0, 0);
SendMessage(hTool, TB_AUTOSIZE, 0, 0);
old_width = rOld.right-rOld.left;
old_height = rOld.bottom-rOld.top;
new_width = new_width - old_width;
new_height = new_height - old_height;
GetWindowRect(hRich, &rOldRich);
old_rich_width = rOldRich.right-rOldRich.left;
old_rich_height = rOldRich.bottom-rOldRich.top;
SetWindowPos(hRich, NULL, 0, 0, old_rich_width+new_width,
old_rich_height+new_height,
SWP_NOMOVE|SWP_NOREPOSITION|SWP_NOZORDER);
bzero(&rOld, sizeof(RECT));
return TRUE;
}
case WM_NOTIFY:
switch (((NMHDR *)lParam)->code)
{
case EN_SELCHANGE:
{
HWND hWnd = GetDlgItem(hDlg, IDC_TEXT);
DWORD start, end, currline;
static DWORD prevline = 0;
unsigned char buffer[512];
chars.cbSize = sizeof(CHARFORMAT2);
SendMessage(hWnd, EM_GETCHARFORMAT, (WPARAM)SCF_SELECTION, (LPARAM)&chars);
if (chars.dwMask & CFM_BOLD && chars.dwEffects & CFE_BOLD)
SendMessage(hTool, TB_CHECKBUTTON, (WPARAM)IDC_BOLD, (LPARAM)MAKELONG(TRUE,0));
else
SendMessage(hTool, TB_CHECKBUTTON, (WPARAM)IDC_BOLD, (LPARAM)MAKELONG(FALSE,0));
if (chars.dwMask & CFM_UNDERLINE && chars.dwEffects & CFE_UNDERLINE)
SendMessage(hTool, TB_CHECKBUTTON, (WPARAM)IDC_UNDERLINE, (LPARAM)MAKELONG(TRUE,0));
else
SendMessage(hTool, TB_CHECKBUTTON, (WPARAM)IDC_UNDERLINE, (LPARAM)MAKELONG(FALSE,0));
SendMessage(hWnd, EM_GETSEL,(WPARAM)&start, (LPARAM)&end);
if (start == end)
{
SendMessage(hTool, TB_ENABLEBUTTON, (WPARAM)IDM_COPY, (LPARAM)MAKELONG(FALSE,0));
SendMessage(hTool, TB_ENABLEBUTTON, (WPARAM)IDM_CUT, (LPARAM)MAKELONG(FALSE,0));
}
else
{
SendMessage(hTool, TB_ENABLEBUTTON, (WPARAM)IDM_COPY, (LPARAM)MAKELONG(TRUE,0));
SendMessage(hTool, TB_ENABLEBUTTON, (WPARAM)IDM_CUT, (LPARAM)MAKELONG(TRUE,0));
}
if (SendMessage(hWnd, EM_CANUNDO, 0, 0))
SendMessage(hTool, TB_ENABLEBUTTON, (WPARAM)IDM_UNDO, (LPARAM)MAKELONG(TRUE,0));
else
SendMessage(hTool, TB_ENABLEBUTTON, (WPARAM)IDM_UNDO, (LPARAM)MAKELONG(FALSE,0));
if (SendMessage(hWnd, EM_CANREDO, 0, 0))
SendMessage(hTool, TB_ENABLEBUTTON, (WPARAM)IDM_REDO, (LPARAM)MAKELONG(TRUE,0));
else
SendMessage(hTool, TB_ENABLEBUTTON, (WPARAM)IDM_REDO, (LPARAM)MAKELONG(FALSE,0));
currline = SendMessage(hWnd, EM_LINEFROMCHAR, (WPARAM)-1, 0);
currline++;
if (currline != prevline)
{
wsprintf(buffer, "Line: %d", currline);
SetWindowText(hStatus, buffer);
prevline = currline;
}
return TRUE;
}
case TTN_GETDISPINFO:
{
LPTOOLTIPTEXT lpttt = (LPTOOLTIPTEXT) lParam;
lpttt->hinst = NULL;
switch (lpttt->hdr.idFrom)
{
case IDM_NEW:
strcpy(lpttt->szText, "New");
break;
case IDM_SAVE:
strcpy(lpttt->szText, "Save");
break;
case IDM_CUT:
strcpy(lpttt->szText, "Cut");
break;
case IDM_COPY:
strcpy(lpttt->szText, "Copy");
break;
case IDM_PASTE:
strcpy(lpttt->szText, "Paste");
break;
case IDM_UNDO:
strcpy(lpttt->szText, "Undo");
break;
case IDM_REDO:
strcpy(lpttt->szText, "Redo");
break;
case IDC_BOLD:
strcpy(lpttt->szText, "Bold");
break;
case IDC_UNDERLINE:
strcpy(lpttt->szText, "Underline");
break;
case IDC_COLOR:
strcpy(lpttt->szText, "Text Color");
break;
case IDC_BGCOLOR:
strcpy(lpttt->szText, "Background Color");
break;
case IDC_GOTO:
strcpy(lpttt->szText, "Goto");
break;
case IDC_FIND:
strcpy(lpttt->szText, "Find");
break;
}
return TRUE;
}
case NM_DBLCLK:
DialogBox(hInst, "GOTO", hDlg, (DLGPROC)GotoDLG);
return (TRUE);
}
return (TRUE);
case WM_COMMAND:
if (LOWORD(wParam) == IDC_BOLD)
{
hWnd = GetDlgItem(hDlg, IDC_TEXT);
if (SendMessage(hTool, TB_ISBUTTONCHECKED, (WPARAM)IDC_BOLD, (LPARAM)0) != 0)
{
chars.cbSize = sizeof(CHARFORMAT2);
chars.dwMask = CFM_BOLD;
chars.dwEffects = CFE_BOLD;
SendMessage(hWnd, EM_SETCHARFORMAT, (WPARAM)SCF_SELECTION, (LPARAM)&chars);
SendMessage(hWnd, EM_HIDESELECTION, 0, 0);
SetFocus(hWnd);
}
else
{
chars.cbSize = sizeof(CHARFORMAT2);
chars.dwMask = CFM_BOLD;
chars.dwEffects = 0;
SendMessage(hWnd, EM_SETCHARFORMAT, (WPARAM)SCF_SELECTION, (LPARAM)&chars);
SendMessage(hWnd, EM_HIDESELECTION, 0, 0);
SetFocus(hWnd);
}
return TRUE;
}
else if (LOWORD(wParam) == IDC_UNDERLINE)
{
hWnd = GetDlgItem(hDlg, IDC_TEXT);
if (SendMessage(hTool, TB_ISBUTTONCHECKED, (WPARAM)IDC_UNDERLINE, (LPARAM)0) != 0)
{
chars.cbSize = sizeof(CHARFORMAT2);
chars.dwMask = CFM_UNDERLINETYPE;
chars.bUnderlineType = CFU_UNDERLINE;
SendMessage(hWnd, EM_SETCHARFORMAT, (WPARAM)SCF_SELECTION, (LPARAM)&chars);
SendMessage(hWnd, EM_HIDESELECTION, 0, 0);
SetFocus(hWnd);
}
else
{
chars.cbSize = sizeof(CHARFORMAT2);
chars.dwMask = CFM_UNDERLINETYPE;
chars.bUnderlineType = CFU_UNDERLINENONE;
SendMessage(hWnd, EM_SETCHARFORMAT, (WPARAM)SCF_SELECTION, (LPARAM)&chars);
SendMessage(hWnd, EM_HIDESELECTION, 0, 0);
SetFocus(hWnd);
}
return TRUE;
}
if (LOWORD(wParam) == IDC_COLOR)
{
DialogBoxParam(hInst, "Color", hDlg, (DLGPROC)ColorDLG, (LPARAM)WM_USER+10);
return 0;
}
if (LOWORD(wParam) == IDC_BGCOLOR)
{
DialogBoxParam(hInst, "Color", hDlg, (DLGPROC)ColorDLG, (LPARAM)WM_USER+11);
return 0;
}
if (LOWORD(wParam) == IDC_GOTO)
{
DialogBox(hInst, "GOTO", hDlg, (DLGPROC)GotoDLG);
return 0;
}
if (LOWORD(wParam) == IDC_FIND)
{
static FINDREPLACE fr;
bzero(&fr, sizeof(FINDREPLACE));
fr.lStructSize = sizeof(FINDREPLACE);
fr.hwndOwner = hDlg;
fr.lpstrFindWhat = findbuf;
fr.wFindWhatLen = 255;
hFind = FindText(&fr);
return 0;
}
hWnd = GetDlgItem(hDlg, IDC_TEXT);
if (LOWORD(wParam) == IDM_COPY)
{
SendMessage(hWnd, WM_COPY, 0, 0);
return 0;
}
if (LOWORD(wParam) == IDM_SELECTALL)
{
SendMessage(hWnd, EM_SETSEL, 0, -1);
return 0;
}
if (LOWORD(wParam) == IDM_PASTE)
{
SendMessage(hWnd, WM_PASTE, 0, 0);
return 0;
}
if (LOWORD(wParam) == IDM_CUT)
{
SendMessage(hWnd, WM_CUT, 0, 0);
return 0;
}
if (LOWORD(wParam) == IDM_UNDO)
{
SendMessage(hWnd, EM_UNDO, 0, 0);
return 0;
}
if (LOWORD(wParam) == IDM_REDO)
{
SendMessage(hWnd, EM_REDO, 0, 0);
return 0;
}
if (LOWORD(wParam) == IDM_DELETE)
{
SendMessage(hWnd, WM_CLEAR, 0, 0);
return 0;
}
if (LOWORD(wParam) == IDM_SAVE)
{
int fd;
EDITSTREAM edit;
OPENFILENAME lpopen;
if (!file)
{
unsigned char path[MAX_PATH];
path[0] = '\0';
bzero(&lpopen, sizeof(OPENFILENAME));
lpopen.lStructSize = sizeof(OPENFILENAME);
lpopen.hwndOwner = hDlg;
lpopen.lpstrFilter = NULL;
lpopen.lpstrCustomFilter = NULL;
lpopen.nFilterIndex = 0;
lpopen.lpstrFile = path;
lpopen.nMaxFile = MAX_PATH;
lpopen.lpstrFileTitle = NULL;
lpopen.lpstrInitialDir = CONFDIR;
lpopen.lpstrTitle = NULL;
lpopen.Flags = (OFN_ENABLESIZING|OFN_NONETWORKBUTTON|
OFN_OVERWRITEPROMPT);
if (GetSaveFileName(&lpopen))
file = path;
else
break;
}
fd = open(file, _O_TRUNC|_O_CREAT|_O_WRONLY|_O_BINARY,_S_IWRITE);
edit.dwCookie = 0;
edit.pfnCallback = BufferIt;
SendMessage(GetDlgItem(hDlg, IDC_TEXT), EM_STREAMOUT, (WPARAM)SF_RTF|SFF_PLAINRTF, (LPARAM)&edit);
RTFToIRC(fd, RTFBuf, strlen(RTFBuf));
free(RTFBuf);
RTFBuf = NULL;
SendMessage(GetDlgItem(hDlg, IDC_TEXT), EM_SETMODIFY, (WPARAM)FALSE, 0);
return 0;
}
if (LOWORD(wParam) == IDM_NEW)
{
unsigned char text[1024];
BOOL newfile = FALSE;
int ans;
if (SendMessage(GetDlgItem(hDlg, IDC_TEXT), EM_GETMODIFY, 0, 0) != 0)
{
sprintf(text, "The text in the %s file has changed.\r\n\r\nDo you want to save the changes?", file ? file : "new");
ans = MessageBox(hDlg, text, "UnrealIRCd", MB_YESNOCANCEL|MB_ICONWARNING);
if (ans == IDNO)
newfile = TRUE;
if (ans == IDCANCEL)
return TRUE;
if (ans == IDYES)
{
SendMessage(hDlg, WM_COMMAND, MAKEWPARAM(IDM_SAVE,0), 0);
newfile = TRUE;
}
}
else
newfile = TRUE;
if (newfile == TRUE)
{
unsigned char szText[256];
file = NULL;
strcpy(szText, "UnrealIRCd Editor - New File");
SetWindowText(hDlg, szText);
SetWindowText(GetDlgItem(hDlg, IDC_TEXT), NULL);
}
break;
}
break;
case WM_USER+10:
{
HWND hWnd = GetDlgItem(hDlg, IDC_TEXT);
EndDialog((HWND)lParam, TRUE);
chars.cbSize = sizeof(CHARFORMAT2);
chars.dwMask = CFM_COLOR;
chars.crTextColor = (COLORREF)wParam;
SendMessage(hWnd, EM_SETCHARFORMAT, (WPARAM)SCF_SELECTION, (LPARAM)&chars);
SendMessage(hWnd, EM_HIDESELECTION, 0, 0);
SetFocus(hWnd);
break;
}
case WM_USER+11:
{
HWND hWnd = GetDlgItem(hDlg, IDC_TEXT);
EndDialog((HWND)lParam, TRUE);
chars.cbSize = sizeof(CHARFORMAT2);
chars.dwMask = CFM_BACKCOLOR;
chars.crBackColor = (COLORREF)wParam;
SendMessage(hWnd, EM_SETCHARFORMAT, (WPARAM)SCF_SELECTION, (LPARAM)&chars);
SendMessage(hWnd, EM_HIDESELECTION, 0, 0);
SetFocus(hWnd);
break;
}
case WM_CHANGECBCHAIN:
if ((HWND)wParam == hClip)
hClip = (HWND)lParam;
else
SendMessage(hClip, WM_CHANGECBCHAIN, wParam, lParam);
break;
case WM_DRAWCLIPBOARD:
if (SendMessage(GetDlgItem(hDlg, IDC_TEXT), EM_CANPASTE, 0, 0))
SendMessage(hTool, TB_ENABLEBUTTON, (WPARAM)IDM_PASTE, (LPARAM)MAKELONG(TRUE,0));
else
SendMessage(hTool, TB_ENABLEBUTTON, (WPARAM)IDM_PASTE, (LPARAM)MAKELONG(FALSE,0));
SendMessage(hClip, WM_DRAWCLIPBOARD, wParam, lParam);
break;
case WM_CLOSE:
{
unsigned char text[256];
int ans;
if (SendMessage(GetDlgItem(hDlg, IDC_TEXT), EM_GETMODIFY, 0, 0) != 0)
{
sprintf(text, "The text in the %s file has changed.\r\n\r\nDo you want to save the changes?", file ? file : "new");
ans = MessageBox(hDlg, text, "UnrealIRCd", MB_YESNOCANCEL|MB_ICONWARNING);
if (ans == IDNO)
EndDialog(hDlg, TRUE);
if (ans == IDCANCEL)
return TRUE;
if (ans == IDYES)
{
SendMessage(hDlg, WM_COMMAND, MAKEWPARAM(IDM_SAVE,0), 0);
EndDialog(hDlg, TRUE);
}
}
else
EndDialog(hDlg, TRUE);
break;
}
case WM_DESTROY:
ChangeClipboardChain(hDlg, hClip);
break;
}
return FALSE;
}
void CClipboardMonitorDlg::OnDestroy( )
{
ChangeClipboardChain(m_nextWindowInChain);
}