ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/misc/clipboard.c

827 lines
22 KiB
C
Raw Blame History

/*
* 'Wine' Clipboard function handling
*
* Copyright 1994 Martin Ayotte
* 1996 Alex Korobka
*
*/
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include "windows.h"
#include "win.h"
#include "heap.h"
#include "message.h"
#include "clipboard.h"
#include "xmalloc.h"
#include "stddebug.h"
#include "debug.h"
#define CF_REGFORMATBASE 0xC000
typedef struct tagCLIPFORMAT {
WORD wFormatID;
WORD wRefCount;
WORD wDataPresent;
LPSTR Name;
HANDLE16 hData;
DWORD BufSize;
struct tagCLIPFORMAT *PrevFormat;
struct tagCLIPFORMAT *NextFormat;
} CLIPFORMAT, *LPCLIPFORMAT;
/* *************************************************************************
* internal variables
*/
static HWND hWndClipOwner = 0; /* current clipboard owner */
static HWND hWndClipWindow = 0; /* window that opened clipboard */
static HWND hWndViewer = 0; /* start of viewers chain */
static BOOL bClipChanged = FALSE;
static WORD LastRegFormat = CF_REGFORMATBASE;
static Bool selectionWait = False;
static Bool selectionAcquired = False;
static Window selectionWindow = None;
static Window selectionPrevWindow = None;
static CLIPFORMAT ClipFormats[16] = {
{ CF_TEXT, 1, 0, "Text", (HANDLE16)NULL, 0, NULL, &ClipFormats[1] },
{ CF_BITMAP, 1, 0, "Bitmap", (HANDLE16)NULL, 0, &ClipFormats[0], &ClipFormats[2] },
{ CF_METAFILEPICT, 1, 0, "MetaFile Picture", (HANDLE16)NULL, 0, &ClipFormats[1], &ClipFormats[3] },
{ CF_SYLK, 1, 0, "Sylk", (HANDLE16)NULL, 0, &ClipFormats[2], &ClipFormats[4] },
{ CF_DIF, 1, 0, "DIF", (HANDLE16)NULL, 0, &ClipFormats[3], &ClipFormats[5] },
{ CF_TIFF, 1, 0, "TIFF", (HANDLE16)NULL, 0, &ClipFormats[4], &ClipFormats[6] },
{ CF_OEMTEXT, 1, 0, "OEM Text", (HANDLE16)NULL, 0, &ClipFormats[5], &ClipFormats[7] },
{ CF_DIB, 1, 0, "DIB", (HANDLE16)NULL, 0, &ClipFormats[6], &ClipFormats[8] },
{ CF_PALETTE, 1, 0, "Palette", (HANDLE16)NULL, 0, &ClipFormats[7], &ClipFormats[9] },
{ CF_PENDATA, 1, 0, "PenData", (HANDLE16)NULL, 0, &ClipFormats[8], &ClipFormats[10] },
{ CF_RIFF, 1, 0, "RIFF", (HANDLE16)NULL, 0, &ClipFormats[9], &ClipFormats[11] },
{ CF_WAVE, 1, 0, "Wave", (HANDLE16)NULL, 0, &ClipFormats[10], &ClipFormats[12] },
{ CF_OWNERDISPLAY, 1, 0, "Owner Display", (HANDLE16)NULL, 0, &ClipFormats[11], &ClipFormats[13] },
{ CF_DSPTEXT, 1, 0, "DSPText", (HANDLE16)NULL, 0, &ClipFormats[12], &ClipFormats[14] },
{ CF_DSPMETAFILEPICT, 1, 0, "DSPMetaFile Picture", (HANDLE16)NULL, 0, &ClipFormats[13], &ClipFormats[15] },
{ CF_DSPBITMAP, 1, 0, "DSPBitmap", (HANDLE16)NULL, 0, &ClipFormats[14], NULL }
};
/**************************************************************************
* CLIPBOARD_CheckSelection
*/
void CLIPBOARD_CheckSelection(WND* pWnd)
{
dprintf_clipboard(stddeb,"\tchecking %08x\n", (unsigned)pWnd->window);
if( selectionAcquired && selectionWindow != None &&
pWnd->window == selectionWindow )
{
selectionPrevWindow = selectionWindow;
selectionWindow = None;
if( pWnd->next )
selectionWindow = pWnd->next->window;
else if( pWnd->parent )
if( pWnd->parent->child != pWnd )
selectionWindow = pWnd->parent->child->window;
dprintf_clipboard(stddeb,"\tswitching selection from %08x to %08x\n",
(unsigned)selectionPrevWindow, (unsigned)selectionWindow);
if( selectionWindow != None )
{
XSetSelectionOwner(display, XA_PRIMARY, selectionWindow, CurrentTime);
if( XGetSelectionOwner(display, XA_PRIMARY) != selectionWindow )
selectionWindow = None;
}
}
}
/**************************************************************************
* CLIPBOARD_DisOwn
*
* Called from DestroyWindow().
*/
void CLIPBOARD_DisOwn(WND* pWnd)
{
LPCLIPFORMAT lpFormat = ClipFormats;
dprintf_clipboard(stddeb,"DisOwn: clipboard owner = %04x, sw = %08x\n",
hWndClipOwner, (unsigned)selectionWindow);
if( pWnd->hwndSelf == hWndClipOwner)
{
SendMessage16(hWndClipOwner,WM_RENDERALLFORMATS,0,0L);
/* check if all formats were rendered */
while(lpFormat)
{
if( lpFormat->wDataPresent && !lpFormat->hData )
{
dprintf_clipboard(stddeb,"\tdata missing for clipboard format %i\n", lpFormat->wFormatID);
lpFormat->wDataPresent = 0;
}
lpFormat = lpFormat->NextFormat;
}
hWndClipOwner = 0;
}
/* now try to salvage current selection from being destroyed by X */
CLIPBOARD_CheckSelection(pWnd);
}
/**************************************************************************
* CLIPBOARD_DeleteRecord
*/
void CLIPBOARD_DeleteRecord(LPCLIPFORMAT lpFormat)
{
if( lpFormat->wFormatID >= CF_GDIOBJFIRST &&
lpFormat->wFormatID <= CF_GDIOBJLAST )
DeleteObject32(lpFormat->hData);
else if( lpFormat->hData )
GlobalFree16(lpFormat->hData);
lpFormat->wDataPresent = 0;
lpFormat->hData = 0;
bClipChanged = TRUE;
}
/**************************************************************************
* CLIPBOARD_RequestXSelection
*/
BOOL CLIPBOARD_RequestXSelection()
{
HWND hWnd = (hWndClipWindow) ? hWndClipWindow : GetActiveWindow16();
if( !hWnd ) return FALSE;
dprintf_clipboard(stddeb,"Requesting selection...\n");
/* request data type XA_STRING, later
* CLIPBOARD_ReadSelection() will be invoked
* from the SelectionNotify event handler */
XConvertSelection(display,XA_PRIMARY,XA_STRING,
XInternAtom(display,"PRIMARY_TEXT",False),
WIN_GetXWindow(hWnd),CurrentTime);
/* wait until SelectionNotify is processed */
selectionWait=True;
while(selectionWait)
EVENT_WaitXEvent( TRUE, FALSE );
/* we treat Unix text as CF_OEMTEXT */
dprintf_clipboard(stddeb,"\tgot CF_OEMTEXT = %i\n",
ClipFormats[CF_OEMTEXT-1].wDataPresent);
return (BOOL)ClipFormats[CF_OEMTEXT-1].wDataPresent;
}
/**************************************************************************
* CLIPBOARD_IsPresent
*/
BOOL CLIPBOARD_IsPresent(WORD wFormat)
{
LPCLIPFORMAT lpFormat = ClipFormats;
/* special case */
if( wFormat == CF_TEXT || wFormat == CF_OEMTEXT )
return lpFormat[CF_TEXT-1].wDataPresent |
lpFormat[CF_OEMTEXT-1].wDataPresent;
while(TRUE) {
if (lpFormat == NULL) return FALSE;
if (lpFormat->wFormatID == wFormat) break;
lpFormat = lpFormat->NextFormat;
}
return (lpFormat->wDataPresent);
}
/**************************************************************************
* OpenClipboard [USER.137]
*/
BOOL OpenClipboard(HWND hWnd)
{
BOOL bRet = FALSE;
dprintf_clipboard(stddeb,"OpenClipboard(%04x) = ", hWnd);
if (!hWndClipWindow)
{
hWndClipWindow = hWnd;
bRet = TRUE;
}
bClipChanged = FALSE;
dprintf_clipboard(stddeb,"%i\n", bRet);
return bRet;
}
/**************************************************************************
* CloseClipboard [USER.138]
*/
BOOL CloseClipboard()
{
dprintf_clipboard(stddeb,"CloseClipboard(); !\n");
if (hWndClipWindow == 0) return FALSE;
hWndClipWindow = 0;
if (bClipChanged && hWndViewer) SendMessage16(hWndViewer,WM_DRAWCLIPBOARD,0,0L);
return TRUE;
}
/**************************************************************************
* EmptyClipboard [USER.139]
*/
BOOL EmptyClipboard()
{
LPCLIPFORMAT lpFormat = ClipFormats;
dprintf_clipboard(stddeb,"EmptyClipboard()\n");
if (hWndClipWindow == 0) return FALSE;
/* destroy private objects */
if (hWndClipOwner)
SendMessage16(hWndClipOwner,WM_DESTROYCLIPBOARD,0,0L);
while(lpFormat)
{
if ( lpFormat->wDataPresent || lpFormat->hData )
CLIPBOARD_DeleteRecord( lpFormat );
lpFormat = lpFormat->NextFormat;
}
hWndClipOwner = hWndClipWindow;
if(selectionAcquired)
{
selectionAcquired = False;
selectionPrevWindow = selectionWindow;
selectionWindow = None;
dprintf_clipboard(stddeb, "\tgiving up selection (spw = %08x)\n",
(unsigned)selectionPrevWindow);
XSetSelectionOwner(display,XA_PRIMARY,None,CurrentTime);
}
return TRUE;
}
/**************************************************************************
* GetClipboardOwner [USER.140]
*/
HWND GetClipboardOwner()
{
dprintf_clipboard(stddeb,
"GetClipboardOwner() = %04x !\n", hWndClipOwner);
return hWndClipOwner;
}
/**************************************************************************
* SetClipboardData [USER.141]
*/
HANDLE16 SetClipboardData(WORD wFormat, HANDLE16 hData)
{
LPCLIPFORMAT lpFormat = ClipFormats;
Window owner;
dprintf_clipboard(stddeb,
"SetClipboardData(%04X, %04x) !\n", wFormat, hData);
while(TRUE)
{
if (lpFormat == NULL) return 0;
if (lpFormat->wFormatID == wFormat) break;
lpFormat = lpFormat->NextFormat;
}
/* Acquire X selection if text format */
if( !selectionAcquired &&
(wFormat == CF_TEXT || wFormat == CF_OEMTEXT) )
{
owner = WIN_GetXWindow(hWndClipWindow);
XSetSelectionOwner(display,XA_PRIMARY,owner,CurrentTime);
if( XGetSelectionOwner(display,XA_PRIMARY) == owner )
{
selectionAcquired = True;
selectionWindow = owner;
dprintf_clipboard(stddeb,"Grabbed X selection, owner=(%08x)\n",
(unsigned) owner);
}
}
if ( lpFormat->wDataPresent || lpFormat->hData )
{
CLIPBOARD_DeleteRecord(lpFormat);
/* delete existing CF_TEXT/CF_OEMTEXT aliases */
if( wFormat == CF_TEXT && ClipFormats[CF_OEMTEXT-1].hData
&& !ClipFormats[CF_OEMTEXT-1].wDataPresent )
CLIPBOARD_DeleteRecord(&ClipFormats[CF_OEMTEXT-1]);
if( wFormat == CF_OEMTEXT && ClipFormats[CF_TEXT-1].hData
&& !ClipFormats[CF_TEXT-1].wDataPresent )
CLIPBOARD_DeleteRecord(&ClipFormats[CF_TEXT-1]);
}
bClipChanged = TRUE;
lpFormat->wDataPresent = 1;
lpFormat->hData = hData; /* 0 is legal, see WM_RENDERFORMAT */
return lpFormat->hData;
}
/**************************************************************************
* CLIPBOARD_RenderFormat
*/
BOOL32 CLIPBOARD_RenderFormat(LPCLIPFORMAT lpFormat)
{
if( lpFormat->wDataPresent && !lpFormat->hData )
if( IsWindow(hWndClipOwner) )
SendMessage16(hWndClipOwner,WM_RENDERFORMAT,
(WPARAM16)lpFormat->wFormatID,0L);
else
{
dprintf_clipboard(stddeb,"\thWndClipOwner (%04x) is lost!\n",
hWndClipOwner);
hWndClipOwner = 0; lpFormat->wDataPresent = 0;
return FALSE;
}
return (lpFormat->hData) ? TRUE : FALSE;
}
/**************************************************************************
* CLIPBOARD_RenderText
*/
BOOL32 CLIPBOARD_RenderText(LPCLIPFORMAT lpTarget, LPCLIPFORMAT lpSource)
{
UINT size = GlobalSize16( lpSource->hData );
LPCSTR lpstrS = (LPSTR)GlobalLock16(lpSource->hData);
LPSTR lpstrT;
if( !lpstrS ) return FALSE;
dprintf_clipboard(stddeb,"\tconverting from '%s' to '%s', %i chars\n",
lpSource->Name, lpTarget->Name, size);
lpTarget->hData = GlobalAlloc16(GMEM_ZEROINIT, size);
lpstrT = (LPSTR)GlobalLock16(lpTarget->hData);
if( lpstrT )
{
if( lpSource->wFormatID == CF_TEXT )
CharToOemBuff32A(lpstrS, lpstrT, size);
else
OemToCharBuff32A(lpstrS, lpstrT, size);
dprintf_clipboard(stddeb,"\tgot %s\n", lpstrT);
return TRUE;
}
lpTarget->hData = 0;
return FALSE;
}
/**************************************************************************
* GetClipboardData [USER.142]
*/
HANDLE16 GetClipboardData(WORD wFormat)
{
LPCLIPFORMAT lpRender = ClipFormats;
LPCLIPFORMAT lpUpdate = NULL;
if (!hWndClipWindow) return 0;
dprintf_clipboard(stddeb,"GetClipboardData(%04X)\n", wFormat);
if( wFormat == CF_TEXT && !lpRender[CF_TEXT-1].wDataPresent
&& lpRender[CF_OEMTEXT-1].wDataPresent )
{
lpRender = &ClipFormats[CF_OEMTEXT-1];
lpUpdate = &ClipFormats[CF_TEXT-1];
dprintf_clipboard(stddeb,"\tOEMTEXT -> TEXT\n");
}
else if( wFormat == CF_OEMTEXT && !lpRender[CF_OEMTEXT-1].wDataPresent
&& lpRender[CF_TEXT-1].wDataPresent )
{
lpRender = &ClipFormats[CF_TEXT-1];
lpUpdate = &ClipFormats[CF_OEMTEXT-1];
dprintf_clipboard(stddeb,"\tTEXT -> OEMTEXT\n");
}
else
{
while(TRUE)
{
if (lpRender == NULL) return 0;
if (lpRender->wFormatID == wFormat) break;
lpRender = lpRender->NextFormat;
}
lpUpdate = lpRender;
}
if( !CLIPBOARD_RenderFormat(lpRender) ) return 0;
if( lpUpdate != lpRender &&
!lpUpdate->hData ) CLIPBOARD_RenderText(lpUpdate, lpRender);
dprintf_clipboard(stddeb,"\treturning %04x (type %i)\n",
lpUpdate->hData, lpUpdate->wFormatID);
return lpUpdate->hData;
}
/**************************************************************************
* CountClipboardFormats [USER.143]
*/
INT CountClipboardFormats()
{
int FormatCount = 0;
LPCLIPFORMAT lpFormat = ClipFormats;
dprintf_clipboard(stddeb,"CountClipboardFormats()\n");
if( !selectionAcquired ) CLIPBOARD_RequestXSelection();
FormatCount += abs(lpFormat[CF_TEXT-1].wDataPresent -
lpFormat[CF_OEMTEXT-1].wDataPresent);
while(TRUE) {
if (lpFormat == NULL) break;
if (lpFormat->wDataPresent)
{
dprintf_clipboard(stddeb, "\tdata found for format %i\n", lpFormat->wFormatID);
FormatCount++;
}
lpFormat = lpFormat->NextFormat;
}
dprintf_clipboard(stddeb,"\ttotal %d\n", FormatCount);
return FormatCount;
}
/**************************************************************************
* EnumClipboardFormats [USER.144]
*/
UINT16 EnumClipboardFormats(UINT16 wFormat)
{
LPCLIPFORMAT lpFormat = ClipFormats;
dprintf_clipboard(stddeb,"EnumClipboardFormats(%04X)\n", wFormat);
if( !hWndClipWindow ) return 0;
if( (!wFormat || wFormat == CF_TEXT || wFormat == CF_OEMTEXT)
&& !selectionAcquired) CLIPBOARD_RequestXSelection();
if (wFormat == 0)
if (lpFormat->wDataPresent || ClipFormats[CF_OEMTEXT-1].wDataPresent)
return lpFormat->wFormatID;
else
wFormat = lpFormat->wFormatID; /* and CF_TEXT is not available */
/* walk up to the specified format record */
while(TRUE) {
if (lpFormat == NULL) return 0;
if (lpFormat->wFormatID == wFormat) break;
lpFormat = lpFormat->NextFormat;
}
/* find next format with available data */
lpFormat = lpFormat->NextFormat;
while(TRUE) {
if (lpFormat == NULL) return 0;
if (lpFormat->wDataPresent ||
(lpFormat->wFormatID == CF_OEMTEXT &&
ClipFormats[CF_TEXT-1].wDataPresent)) break;
lpFormat = lpFormat->NextFormat;
}
return lpFormat->wFormatID;
}
/**************************************************************************
* RegisterClipboardFormat16 (USER.145)
*/
UINT16 RegisterClipboardFormat16( LPCSTR FormatName )
{
LPCLIPFORMAT lpNewFormat;
LPCLIPFORMAT lpFormat = ClipFormats;
if (FormatName == NULL) return 0;
dprintf_clipboard(stddeb,"RegisterClipboardFormat('%s') !\n", FormatName);
/* walk format chain to see if it's already registered */
while(TRUE) {
if ( !strcmp(lpFormat->Name,FormatName) )
{
lpFormat->wRefCount++;
return lpFormat->wFormatID;
}
if ( lpFormat->NextFormat == NULL ) break;
lpFormat = lpFormat->NextFormat;
}
/* allocate storage for new format entry */
lpNewFormat = (LPCLIPFORMAT)xmalloc(sizeof(CLIPFORMAT));
lpFormat->NextFormat = lpNewFormat;
lpNewFormat->wFormatID = LastRegFormat;
lpNewFormat->wRefCount = 1;
lpNewFormat->Name = (LPSTR)xmalloc(strlen(FormatName) + 1);
strcpy(lpNewFormat->Name, FormatName);
lpNewFormat->wDataPresent = 0;
lpNewFormat->hData = 0;
lpNewFormat->BufSize = 0;
lpNewFormat->PrevFormat = lpFormat;
lpNewFormat->NextFormat = NULL;
return LastRegFormat++;
}
/**************************************************************************
* RegisterClipboardFormat32A (USER32.430)
*/
UINT32 RegisterClipboardFormat32A( LPCSTR formatName )
{
return RegisterClipboardFormat16( formatName );
}
/**************************************************************************
* RegisterClipboardFormat32W (USER32.431)
*/
UINT32 RegisterClipboardFormat32W( LPCWSTR formatName )
{
LPSTR aFormat = HEAP_strdupWtoA( GetProcessHeap(), 0, formatName );
UINT32 ret = RegisterClipboardFormat32A( aFormat );
HeapFree( GetProcessHeap(), 0, aFormat );
return ret;
}
/**************************************************************************
* GetClipboardFormatName [USER.146]
*/
int GetClipboardFormatName(WORD wFormat, LPSTR retStr, short maxlen)
{
LPCLIPFORMAT lpFormat = ClipFormats;
dprintf_clipboard(stddeb,
"GetClipboardFormat(%04X, %p, %d) !\n", wFormat, retStr, maxlen);
while(TRUE) {
if (lpFormat == NULL) return 0;
if (lpFormat->wFormatID == wFormat) break;
lpFormat = lpFormat->NextFormat;
}
if (lpFormat->Name == NULL ||
lpFormat->wFormatID < CF_REGFORMATBASE) return 0;
dprintf_clipboard(stddeb,
"GetClipboardFormat // Name='%s' !\n", lpFormat->Name);
strncpy(retStr, lpFormat->Name, maxlen - 1);
retStr[maxlen] = 0;
return strlen(retStr);
}
/**************************************************************************
* SetClipboardViewer [USER.147]
*/
HWND SetClipboardViewer(HWND hWnd)
{
HWND hwndPrev = hWndViewer;
dprintf_clipboard(stddeb,"SetClipboardViewer(%04x)\n", hWnd);
hWndViewer = hWnd;
return hwndPrev;
}
/**************************************************************************
* GetClipboardViewer [USER.148]
*/
HWND GetClipboardViewer()
{
dprintf_clipboard(stddeb,"GetClipboardFormat() = %04x\n", hWndViewer);
return hWndViewer;
}
/**************************************************************************
* ChangeClipboardChain [USER.149]
*/
BOOL16 ChangeClipboardChain16(HWND16 hWnd, HWND16 hWndNext)
{
return ChangeClipboardChain32(hWnd,hWndNext);
}
/**************************************************************************
* ChangeClipboardChain [USER32.21]
*/
BOOL32 ChangeClipboardChain32(HWND32 hWnd, HWND32 hWndNext)
{
BOOL32 bRet = 0;
dprintf_clipboard(stdnimp, "ChangeClipboardChain(%04x, %04x)\n", hWnd, hWndNext);
if( hWndViewer )
bRet = !SendMessage16( hWndViewer, WM_CHANGECBCHAIN,
(WPARAM16)hWnd, (LPARAM)hWndNext);
else
dprintf_clipboard(stddeb,"ChangeClipboardChain: hWndViewer is lost\n");
if( hWnd == hWndViewer ) hWndViewer = hWndNext;
return bRet;
}
/**************************************************************************
* IsClipboardFormatAvailable [USER.193]
*/
BOOL IsClipboardFormatAvailable(WORD wFormat)
{
dprintf_clipboard(stddeb,"IsClipboardFormatAvailable(%04X) !\n", wFormat);
if( (wFormat == CF_TEXT || wFormat == CF_OEMTEXT) &&
!selectionAcquired ) CLIPBOARD_RequestXSelection();
return CLIPBOARD_IsPresent(wFormat);
}
/**************************************************************************
* GetOpenClipboardWindow [USER.248]
*/
HWND GetOpenClipboardWindow()
{
dprintf_clipboard(stddeb,
"GetOpenClipboardWindow() = %04x\n", hWndClipWindow);
return hWndClipWindow;
}
/**************************************************************************
* GetPriorityClipboardFormat [USER.402]
*/
int GetPriorityClipboardFormat(WORD *lpPriorityList, short nCount)
{
dprintf_clipboard(stdnimp,
"GetPriorityClipboardFormat(%p, %d) !\n", lpPriorityList, nCount);
return 0;
}
/**************************************************************************
* CLIPBOARD_ReadSelection
*
* Called from the SelectionNotify event handler.
*/
void CLIPBOARD_ReadSelection(Window w,Atom prop)
{
HANDLE16 hText = 0;
LPCLIPFORMAT lpFormat = ClipFormats;
dprintf_clipboard(stddeb,"ReadSelection callback\n");
if(prop != None)
{
Atom atype=AnyPropertyType;
int aformat;
unsigned long nitems,remain;
unsigned char* val=NULL;
dprintf_clipboard(stddeb,"\tgot property %s\n",XGetAtomName(display,prop));
/* TODO: Properties longer than 64K */
if(XGetWindowProperty(display,w,prop,0,0x3FFF,True,XA_STRING,
&atype, &aformat, &nitems, &remain, &val) != Success)
dprintf_clipboard(stddeb,"\tcouldn't read property\n");
else
{
dprintf_clipboard(stddeb,"\tType %s,Format %d,nitems %ld,value %s\n",
XGetAtomName(display,atype),aformat,nitems,val);
if(atype == XA_STRING && aformat == 8)
{
int i,inlcount = 0;
char* lpstr;
dprintf_clipboard(stddeb,"\tselection is '%s'\n",val);
for(i=0; i <= nitems; i++)
if( val[i] == '\n' ) inlcount++;
if( nitems )
{
hText=GlobalAlloc16(GMEM_MOVEABLE, nitems + inlcount + 1);
if( (lpstr = (char*)GlobalLock16(hText)) )
for(i=0,inlcount=0; i <= nitems; i++)
{
if( val[i] == '\n' ) lpstr[inlcount++]='\r';
lpstr[inlcount++]=val[i];
}
else hText = 0;
}
}
XFree(val);
}
}
/* delete previous CF_TEXT and CF_OEMTEXT data */
if( hText )
{
lpFormat = &ClipFormats[CF_TEXT-1];
if (lpFormat->wDataPresent || lpFormat->hData)
CLIPBOARD_DeleteRecord(lpFormat);
lpFormat = &ClipFormats[CF_OEMTEXT-1];
if (lpFormat->wDataPresent || lpFormat->hData)
CLIPBOARD_DeleteRecord(lpFormat);
lpFormat->wDataPresent = 1;
lpFormat->hData = hText;
}
selectionWait=False;
}
/**************************************************************************
* CLIPBOARD_ReleaseSelection
*
* Wine might have lost XA_PRIMARY selection because of
* EmptyClipboard() or other client.
*/
void CLIPBOARD_ReleaseSelection(Window w, HWND hwnd)
{
/* w is the window that lost selection,
*
* selectionPrevWindow is nonzero if CheckSelection() was called.
*/
dprintf_clipboard(stddeb,"\tevent->window = %08x (sw = %08x, spw=%08x)\n",
(unsigned)w, (unsigned)selectionWindow, (unsigned)selectionPrevWindow );
if( selectionAcquired )
if( w == selectionWindow || selectionPrevWindow == None)
{
/* alright, we really lost it */
selectionAcquired = False;
selectionWindow = None;
/* but we'll keep existing data for internal use */
}
else if( w == selectionPrevWindow )
{
w = XGetSelectionOwner(display, XA_PRIMARY);
if( w == None )
XSetSelectionOwner(display, XA_PRIMARY, selectionWindow, CurrentTime);
}
selectionPrevWindow = None;
}
Reference in New Issue View Git Blame Copy Permalink