gnustep/libs-back
0
0
Fork 0
mirror of https://github.com/gnustep/libs-back.git synced 2025-02-24 12:21:34 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
libs-back/Tools/xpbs.m
Fred Kiefer 1a8c599b43 Made some of the NSLog messages more explicit on what did go wrong. 
git-svn-id: svn+ssh://svn.gna.org/svn/gnustep/libs/back/trunk@17495 72102866-910b-0410-8b05-ffd578937521
2003-08-19 17:42:18 +00:00

1183 lines
29 KiB
Objective-C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
xpbs.m
GNUstep pasteboard server - X extension
Copyright (C) 1999 Free Software Foundation, Inc.
Author: Richard Frith-Macdonald <richard@brainstorm.co.uk>
Date: April 1999
This file is part of the GNUstep Project
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
You should have received a copy of the GNU General Public
License along with this library; see the file COPYING.LIB.
If not, write to the Free Software Foundation,
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <Foundation/Foundation.h>
#include <Foundation/NSUserDefaults.h>
#include <AppKit/NSPasteboard.h>
#include <X11/Xatom.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <x11/xdnd.h>
static Atom osTypeToX(NSString *t);
/*
* Non-predefined atoms that are used in the X selection mechanism
*/
static char* atom_names[] = {
"CHARACTER_POSITION",
"CLIENT_WINDOW",
"HOST_NAME",
"HOSTNAME",
"LENGTH",
"LIST_LENGTH",
"NAME",
"OWNER_OS",
"SPAN",
"TARGETS",
"TIMESTAMP",
"USER",
"TEXT",
"NULL",
"FILE_NAME",
"CLIPBOARD",
"UTF8_STRING"
};
static Atom atoms[sizeof(atom_names)/sizeof(char*)];
/*
* Macros to access elements in atom_names array.
*/
#define XG_CHAR_POSITION atoms[0]
#define XG_CLIENT_WINDOW atoms[1]
#define XG_HOST_NAME atoms[2]
#define XG_HOSTNAME atoms[3]
#define XG_LENGTH atoms[4]
#define XG_LIST_LENGTH atoms[5]
#define XG_NAME atoms[6]
#define XG_OWNER_OS atoms[7]
#define XG_SPAN atoms[8]
#define XG_TARGETS atoms[9]
#define XG_TIMESTAMP atoms[10]
#define XG_USER atoms[11]
#define XG_TEXT atoms[12]
#define XG_NULL atoms[13]
#define XG_FILE_NAME atoms[14]
#define XA_CLIPBOARD atoms[15]
#define XG_UTF8_STRING atoms[16]
static Atom
osTypeToX(NSString *t)
{
if ([t isEqualToString: NSStringPboardType] == YES)
#ifdef X_HAVE_UTF8_STRING
return XG_UTF8_STRING;
#else
return XA_STRING;
#endif
else if ([t isEqualToString: NSColorPboardType] == YES)
return XG_NULL;
else if ([t isEqualToString: NSFileContentsPboardType] == YES)
return XG_NULL;
else if ([t isEqualToString: NSFilenamesPboardType] == YES)
return XG_FILE_NAME;
else if ([t isEqualToString: NSFontPboardType] == YES)
return XG_NULL;
else if ([t isEqualToString: NSRulerPboardType] == YES)
return XG_NULL;
else if ([t isEqualToString: NSPostScriptPboardType] == YES)
return XG_NULL;
else if ([t isEqualToString: NSTabularTextPboardType] == YES)
return XG_NULL;
else if ([t isEqualToString: NSRTFPboardType] == YES)
return XG_NULL;
else if ([t isEqualToString: NSRTFDPboardType] == YES)
return XG_NULL;
else if ([t isEqualToString: NSTIFFPboardType] == YES)
return XG_NULL;
else if ([t isEqualToString: NSDataLinkPboardType] == YES)
return XG_NULL;
else if ([t isEqualToString: NSGeneralPboardType] == YES)
return XG_NULL;
else
return XG_NULL;
}
@interface XPbOwner : NSObject
{
NSPasteboard *_pb;
NSData *_obj;
NSString *_name;
Atom _xPb;
Time _waitingForSelection;
Time _timeOfLastAppend;
BOOL _ownedByOpenStep;
}
+ (XPbOwner*) ownerByXPb: (Atom)p;
+ (XPbOwner*) ownerByOsPb: (NSString*)p;
+ (void) receivedEvent: (void*)data
type: (RunLoopEventType)type
extra: (void*)extra
forMode: (NSString*)mode;
+ (NSDate*) timedOutEvent: (void*)data
type: (RunLoopEventType)type
forMode: (NSString*)mode;
+ (void) xPropertyNotify: (XPropertyEvent*)xEvent;
+ (void) xSelectionClear: (XSelectionClearEvent*)xEvent;
+ (void) xSelectionNotify: (XSelectionEvent*)xEvent;
+ (void) xSelectionRequest: (XSelectionRequestEvent*)xEvent;
- (NSData*) data;
- (id) initWithXPb: (Atom)x osPb: (NSPasteboard*)o;
- (BOOL) ownedByOpenStep;
- (NSPasteboard*) osPb;
- (void) pasteboardChangedOwner: (NSPasteboard*)sender;
- (void) pasteboard: (NSPasteboard*)pb provideDataForType: (NSString*)type;
- (void) setData: (NSData*)obj;
- (void) setOwnedByOpenStep: (BOOL)flag;
- (void) setTimeOfLastAppend: (Time)when;
- (void) setWaitingForSelection: (Time)when;
- (Time) timeOfLastAppend;
- (Time) waitingForSelection;
- (Atom) xPb;
- (void) xSelectionClear;
- (void) xSelectionNotify: (XSelectionEvent*)xEvent;
- (void) xSelectionRequest: (XSelectionRequestEvent*)xEvent;
- (BOOL) xProvideSelection: (XSelectionRequestEvent*)xEvent;
- (Time) xTimeByAppending: (Atom) defaultType;
- (BOOL) xSendData: (unsigned char*) data format: (int) format
items: (int) numItems type: (Atom) xType
to: (Window) window property: (Atom) property;
@end
// Special subclass for the drag pasteboard
@interface XDragPbOwner : XPbOwner
{
}
@end
/*
* The display we are using - everything refers to it.
*/
static Display *xDisplay;
static Window xRootWin;
static Window xAppWin;
static NSMapTable *ownByX;
static NSMapTable *ownByO;
static NSString *xWaitMode = @"XPasteboardWaitMode";
@implementation XPbOwner
+ (void) initialize
{
if (self == [XPbOwner class])
{
XPbOwner *o;
NSPasteboard *p;
Atom generalPb, selectionPb;
ownByO = NSCreateMapTable(NSObjectMapKeyCallBacks,
NSNonOwnedPointerMapValueCallBacks, 0);
ownByX = NSCreateMapTable(NSIntMapKeyCallBacks,
NSNonOwnedPointerMapValueCallBacks, 0);
xDisplay = XOpenDisplay(NULL);
if (xDisplay == 0)
{
NSLog(@"Unable to open X display - no X interoperation available");
}
else
{
NSRunLoop *l = [NSRunLoop currentRunLoop];
int desc;
/*
* Set up atoms for use in X selection mechanism.
*/
XInternAtoms(xDisplay, atom_names, sizeof(atom_names)/sizeof(char*),
False, atoms);
xRootWin = RootWindow(xDisplay, DefaultScreen(xDisplay));
xAppWin = XCreateSimpleWindow(xDisplay, xRootWin,
0, 0, 100, 100, 1, 1, 0L);
/*
* Add the X descriptor to the run loop so we get callbacks when
* X events arrive.
*/
desc = XConnectionNumber(xDisplay);
[l addEvent: (void*)(gsaddr)desc
type: ET_RDESC
watcher: (id<RunLoopEvents>)self
forMode: NSDefaultRunLoopMode];
[l addEvent: (void*)(gsaddr)desc
type: ET_RDESC
watcher: (id<RunLoopEvents>)self
forMode: NSConnectionReplyMode];
[l addEvent: (void*)(gsaddr)desc
type: ET_RDESC
watcher: (id<RunLoopEvents>)self
forMode: xWaitMode];
XSelectInput(xDisplay, xAppWin, PropertyChangeMask);
XFlush(xDisplay);
}
/*
* According to the new open desktop specification
* http://www.freedesktop.org/standards/clipboards-spec/clipboards.txt
* these two pasteboards should be switched around. That is,
* general should be XA_CLIPBOARD and selection XA_PRIMARY.
* The problem is that most X programs still use the old way.
* For these environments we offer a switch to the old mode.
*/
if ([[NSUserDefaults standardUserDefaults] boolForKey: @"GSOldClipboard"])
{
generalPb = XA_PRIMARY;
selectionPb = XA_CLIPBOARD;
}
else
{
generalPb = XA_CLIPBOARD;
selectionPb = XA_PRIMARY;
}
/*
* For the general and the selection pasteboard we establish an initial
* owner that is the X selection system. In this way, any X window
* selection already active will be available to the GNUstep system.
* These objects are not released!
*/
p = [NSPasteboard generalPasteboard];
o = [[XPbOwner alloc] initWithXPb: generalPb osPb: p];
[o xSelectionClear];
p = [NSPasteboard pasteboardWithName: @"Selection"];
o = [[XPbOwner alloc] initWithXPb: selectionPb osPb: p];
[o xSelectionClear];
// Call this to get the class initialisation
[XDragPbOwner class];
}
}
+ (XPbOwner*) ownerByOsPb: (NSString*)p
{
return (XPbOwner*)NSMapGet(ownByO, (void*)(gsaddr)p);
}
+ (XPbOwner*) ownerByXPb: (Atom)x
{
return (XPbOwner*)NSMapGet(ownByX, (void*)(gsaddr)x);
}
/*
* This is the event handler called by the runloop when the X descriptor
* has data available to read.
*/
+ (void) receivedEvent: (void*)data
type: (RunLoopEventType)type
extra: (void*)extra
forMode: (NSString*)mode
{
int count;
NSAssert(type == ET_RDESC, NSInternalInconsistencyException);
while ((count = XPending(xDisplay)) > 0)
{
while (count-- > 0)
{
XEvent xEvent;
XNextEvent(xDisplay, &xEvent);
switch (xEvent.type)
{
case PropertyNotify:
[self xPropertyNotify: (XPropertyEvent*)&xEvent];
NSDebugLLog(@"Pbs", @"PropertyNotify.");
break;
case SelectionNotify:
[self xSelectionNotify: (XSelectionEvent*)&xEvent];
NSDebugLLog(@"Pbs", @"SelectionNotify.");
break;
case SelectionClear:
[self xSelectionClear: (XSelectionClearEvent*)&xEvent];
NSDebugLLog(@"Pbs", @"SelectionClear.");
break;
case SelectionRequest:
[self xSelectionRequest: (XSelectionRequestEvent*)&xEvent];
NSDebugLLog(@"Pbs", @"SelectionRequest.");
break;
default:
NSDebugLLog(@"Pbs", @"Unexpected X event.");
break;
}
}
}
}
/*
* This handler called if an operation times out - never happens 'cos we
* don't supply any timeouts - included for protocol conformance.
*/
+ (NSDate*) timedOutEvent: (void*)data
type: (RunLoopEventType)type
forMode: (NSString*)mode
{
return nil;
}
#define FULL_LENGTH 8192L /* Amount to read */
+ (void) xSelectionClear: (XSelectionClearEvent*)xEvent
{
XPbOwner *o;
o = [self ownerByXPb: xEvent->selection];
if (o == nil)
{
NSDebugLLog(@"Pbs", @"Selection clear for unknown selection - '%s'.",
XGetAtomName(xDisplay, xEvent->selection));
return;
}
if (xEvent->window != (Window)xAppWin)
{
NSDebugLLog(@"Pbs", @"Selection clear for wrong (not our) window.");
return;
}
[o xSelectionClear];
}
+ (void) xPropertyNotify: (XPropertyEvent*)xEvent
{
XPbOwner *o;
o = [self ownerByXPb: xEvent->atom];
if (o == nil)
{
NSDebugLLog(@"Pbs", @"Property notify for unknown property - '%s'.",
XGetAtomName(xDisplay, xEvent->atom));
return;
}
if (xEvent->window != (Window)xAppWin)
{
NSDebugLLog(@"Pbs", @"Property notify for wrong (not our) window.");
return;
}
if (xEvent->time != 0)
{
[o setTimeOfLastAppend: xEvent->time];
}
}
+ (void) xSelectionNotify: (XSelectionEvent*)xEvent
{
XPbOwner *o;
o = [self ownerByXPb: xEvent->selection];
if (o == nil)
{
NSDebugLLog(@"Pbs", @"Selection notify for unknown selection - '%s'.",
XGetAtomName(xDisplay, xEvent->selection));
return;
}
if (xEvent->requestor != (Window)xAppWin)
{
NSDebugLLog(@"Pbs", @"Selection notify for wrong (not our) window.");
return;
}
else
{
NSDebugLLog(@"Pbs", @"Selection (%s) notify - '%s'.",
XGetAtomName(xDisplay, xEvent->selection),
XGetAtomName(xDisplay, xEvent->property));
}
[o xSelectionNotify: xEvent];
}
+ (void) xSelectionRequest: (XSelectionRequestEvent*)xEvent
{
XPbOwner *o;
o = [self ownerByXPb: xEvent->selection];
if (o == nil)
{
NSDebugLLog(@"Pbs", @"Selection request for unknown selection - '%s'.",
XGetAtomName(xDisplay, xEvent->selection));
return;
}
if (xEvent->requestor == (Window)xAppWin)
{
NSDebugLLog(@"Pbs", @"Selection request for wrong (our) window.");
return;
}
if (xEvent->property == None)
{
NSDebugLLog(@"Pbs", @"Selection request without reply property set.");
return;
}
[o xSelectionRequest: xEvent];
}
- (NSData*) data
{
return _obj;
}
- (void) dealloc
{
RELEASE(_pb);
RELEASE(_obj);
/*
* Remove self from map of X pasteboard owners.
*/
NSMapRemove(ownByX, (void*)(gsaddr)_xPb);
NSMapRemove(ownByO, (void*)(gsaddr)_name);
[super dealloc];
}
- (id) initWithXPb: (Atom)x osPb: (NSPasteboard*)o
{
_pb = RETAIN(o);
_name = [_pb name];
_xPb = x;
/*
* Add self to map of all X pasteboard owners.
*/
NSMapInsert(ownByX, (void*)(gsaddr)_xPb, (void*)(gsaddr)self);
NSMapInsert(ownByO, (void*)(gsaddr)_name, (void*)(gsaddr)self);
return self;
}
- (NSPasteboard*) osPb
{
return _pb;
}
- (BOOL) ownedByOpenStep
{
return _ownedByOpenStep;
}
- (void) pasteboardChangedOwner: (NSPasteboard*)sender
{
Window w;
/*
* If this gets called, a GNUstep object has grabbed the pasteboard
* or has changed the types of data available from the pasteboard
* so we must tell the X server that we have the current selection.
* To conform to ICCCM we need to specify an up-to-date timestamp.
*/
Atom defaultType = XG_UTF8_STRING;
//Atom defaultType = XA_STRING;
XSetSelectionOwner(xDisplay, _xPb, xAppWin,
[self xTimeByAppending: defaultType]);
w = XGetSelectionOwner(xDisplay, _xPb);
if (w != xAppWin)
{
NSLog(@"Failed to set X selection owner to the pasteboard server.");
}
else
{
[self setOwnedByOpenStep: YES];
}
}
- (void) requestData: (Atom)xType
{
Time whenRequested;
/*
* Do a nul append to a property to get a timestamp, if it returns the
* 'CurrentTime' constant then we haven't been able to get one.
*/
whenRequested = [self xTimeByAppending: xType];
if (whenRequested != CurrentTime)
{
NSDate *limit;
/*
* Ok - we got a timestamp, so we can ask the selection system for
* the pasteboard data that was/is valid for that time.
* Ask the X system to provide the pasteboard data in the
* appropriate property of our application root window.
*/
XConvertSelection(xDisplay, [self xPb], xType,
[self xPb], xAppWin, whenRequested);
XFlush(xDisplay);
/*
* Run an event loop to read X events until we have aquired the
* pasteboard data we need.
*/
limit = [NSDate dateWithTimeIntervalSinceNow: 20.0];
[self setWaitingForSelection: whenRequested];
while ([self waitingForSelection] == whenRequested)
{
[[NSRunLoop currentRunLoop] runMode: xWaitMode
beforeDate: limit];
if ([limit timeIntervalSinceNow] <= 0.0)
break; /* Timeout */
}
if ([self waitingForSelection] != 0)
{
[self setWaitingForSelection: 0];
NSLog(@"Timed out waiting for X selection '%s'",
XGetAtomName(xDisplay, xType));
}
}
}
- (void) pasteboard: (NSPasteboard*)pb provideDataForType: (NSString*)type
{
[self setData: nil];
/*
* If this gets called, a GNUstep object wants the pasteboard contents
* and a plain old X application is providing them, so we must grab
* the info.
*/
if ([type isEqual: NSStringPboardType])
{
[self requestData: XG_UTF8_STRING];
if ([self data] == nil)
[self requestData: XA_STRING];
}
else
{
NSLog(@"Request for non-string info from X pasteboard: %@", type);
}
[pb setData: [self data] forType: type];
}
- (void) setData: (NSData*)obj
{
ASSIGN(_obj, obj);
}
- (void) setOwnedByOpenStep: (BOOL)f
{
_ownedByOpenStep = f;
}
- (void) setTimeOfLastAppend: (Time)when
{
_timeOfLastAppend = when;
}
- (void) setWaitingForSelection: (Time)when
{
_waitingForSelection = when;
}
- (Time) timeOfLastAppend
{
return _timeOfLastAppend;
}
- (Time) waitingForSelection
{
return _waitingForSelection;
}
- (Atom) xPb
{
return _xPb;
}
static BOOL appendFailure;
static int
xErrorHandler(Display *d, XErrorEvent *e)
{
appendFailure = YES;
return 0;
}
- (void) xSelectionClear
{
NSArray *types;
/*
* Really we should check to see what types of data the selection owner is
* making available, and declare them all - but as a temporary HACK we just
* declare string data.
*/
types = [NSArray arrayWithObject: NSStringPboardType];
[_pb declareTypes: types owner: self];
[self setOwnedByOpenStep: NO];
}
- (void) xSelectionNotify: (XSelectionEvent*)xEvent
{
int status;
unsigned char *data;
long long_offset = 0L;
long long_length = FULL_LENGTH;
Atom req_type = AnyPropertyType;
Atom actual_type;
int actual_format;
unsigned long bytes_remaining;
unsigned long number_items;
NSMutableData *md = nil;
if (xEvent->property == (Atom)None)
{
NSDebugLLog(@"Pbs", @"Owning program failed to convert data.");
[self setWaitingForSelection: 0];
return;
}
if ([self waitingForSelection] > xEvent->time)
{
NSLog(@"Unexpected selection notify - time %u.", xEvent->time);
return;
}
[self setWaitingForSelection: 0];
/*
* Read data from property identified in SelectionNotify event.
*/
do
{
status = XGetWindowProperty(xDisplay,
xEvent->requestor,
xEvent->property,
long_offset, // offset
long_length,
True, // Delete prop when read.
req_type,
&actual_type,
&actual_format,
&number_items,
&bytes_remaining,
&data);
if ((status == Success) && (number_items > 0))
{
long count = number_items * actual_format / 8;
if (md == nil)
{
md = [[NSMutableData alloc] initWithBytes: (void *)data
length: count];
req_type = actual_type;
}
else
{
if (req_type != actual_type)
{
NSLog(@"Selection changed type from %s to %s.",
XGetAtomName(xDisplay, req_type),
XGetAtomName(xDisplay, actual_type));
RELEASE(md);
return;
}
[md appendBytes: (void *)data length: count];
}
long_offset += count / 4;
if (data)
{
XFree(data);
}
}
}
while ((status == Success) && (bytes_remaining > 0));
if (status == Success)
{
// Convert data to text string.
if (actual_type == XG_UTF8_STRING)
{
NSString *s;
NSData *d;
s = [[NSString alloc] initWithData: md
encoding: NSUTF8StringEncoding];
d = [NSSerializer serializePropertyList: s];
RELEASE(s);
[self setData: d];
}
else if (actual_type == XA_STRING)
{
NSString *s;
NSData *d;
s = [[NSString alloc] initWithData: md
encoding: NSISOLatin1StringEncoding];
d = [NSSerializer serializePropertyList: s];
RELEASE(s);
[self setData: d];
}
else
{
NSLog(@"Unsupported data type '%s' from X selection.",
XGetAtomName(xDisplay, actual_type));
}
}
RELEASE(md);
}
- (void) xSelectionRequest: (XSelectionRequestEvent*)xEvent
{
XSelectionEvent notify_event;
BOOL status;
status = [self xProvideSelection: xEvent];
/*
* Set up the selection notify information from the event information
* so we comply with the ICCCM.
*/
notify_event.display = xEvent->display;
notify_event.type = SelectionNotify;
notify_event.requestor = xEvent->requestor;
notify_event.selection = xEvent->selection;
notify_event.target = xEvent->target;
notify_event.time = xEvent->time;
notify_event.property = xEvent->property;
/*
* If for any reason we cannot provide the data to the requestor, we must
* send a selection notify with a property of 'None' so that the requestor
* knows the request failed.
*/
if (status == NO)
notify_event.property = None;
XSendEvent(xEvent->display, xEvent->requestor, False, 0L,
(XEvent*)&notify_event);
}
- (BOOL) xProvideSelection: (XSelectionRequestEvent*)xEvent
{
NSArray *types = [_pb types];
unsigned numOsTypes = [types count];
NSString *osType = nil;
Atom xType = XG_NULL;
unsigned char *data = 0;
int format = 0;
int numItems = 0;
unsigned i;
if (xEvent->target == XG_TARGETS)
{
unsigned numTypes = 0;
Atom xTypes[numOsTypes];
/*
* The requestor wants a list of the types we can supply it with.
*/
for (i = 0; i < numOsTypes; i++)
{
NSString *type = [types objectAtIndex: i];
Atom t;
t = osTypeToX(type);
if (t != XG_NULL)
{
unsigned j;
for (j = 0; j < numTypes; j++)
{
if (xTypes[j] == t)
break;
}
if (j == numTypes)
{
xTypes[numTypes++] = t;
}
}
}
if (numTypes > 0)
{
/*
* We can supply one or more types of data to the requestor so
* we will give it a list of the types supported.
*/
xType = XA_ATOM;
data = malloc(numTypes*sizeof(Atom));
memcpy(data, xTypes, numTypes*sizeof(Atom));
numItems = numTypes;
format = 32;
}
else
{
/*
* No OS types that are convertable to X types.
*/
xType = XG_NULL;
}
}
else
{
if (xEvent->target == AnyPropertyType)
{
/*
* The requestor will accept any type of data - so we use the first
* OpenStep type that corresponds to a known X type.
*/
for (i = 0; i < numOsTypes; i++)
{
NSString *type = [types objectAtIndex: i];
Atom t = osTypeToX(type);
if (t != XG_NULL)
{
osType = type;
xType = t;
break;
}
}
}
else
{
// A fixed type was requested.
xType = xEvent->target;
/*
* Find an available OpenStep pasteboard type that corresponds
* to the requested X type.
*/
for (i = 0; i < numOsTypes; i++)
{
NSString *type = [types objectAtIndex: i];
Atom t = osTypeToX(type);
if (t == xType)
{
osType = type;
xType = t;
break;
}
}
// If UTF8 is the default we have to handle the case where the target
// applciaiton cannot handle this.
if ((osType == nil) &&
[types containsObject: NSStringPboardType] &&
((xType == XA_STRING) || (xType == XG_TEXT)))
{
osType = NSStringPboardType;
}
}
/*
* Now we know what type of data is required - so get it from the
* pasteboard and convert to a format X can understand.
*/
if (osType != nil)
{
if ([osType isEqualToString: NSStringPboardType])
{
NSString *s = [_pb stringForType: NSStringPboardType];
NSData *d;
if (xType == XG_UTF8_STRING)
{
d = [s dataUsingEncoding: NSUTF8StringEncoding];
}
else
{
d = [s dataUsingEncoding: NSISOLatin1StringEncoding];
}
format = 8;
if (d != nil)
{
numItems = [d length];
data = malloc(numItems + 1);
if (data)
[d getBytes: data];
}
}
else
{
NSLog(@"Trying to convert from unsupported type - '%@'", osType);
}
}
}
return [self xSendData: data format: format items: numItems type: xType
to: xEvent->requestor property: xEvent->property];
}
- (BOOL) xSendData: (unsigned char*) data format: (int) format
items: (int) numItems type: (Atom) xType
to: (Window) window property: (Atom) property
{
BOOL status = NO;
/*
* If we have managed to convert data of the appropritate type, we must now
* append the data to the property on the requesting window.
* We do this in small chunks, checking for errors, in case the window
* manager puts a limit on the data size we can use.
* This is not thread-safe - but I think that's a general problem with X.
*/
if (data != 0 && numItems != 0 && format != 0)
{
int (*oldHandler)(Display*, XErrorEvent*);
int mode = PropModeReplace;
int pos = 0;
int maxItems = 4096 * 8 / format;
appendFailure = NO;
oldHandler = XSetErrorHandler(xErrorHandler);
while (appendFailure == NO && pos < numItems)
{
if (pos + maxItems > numItems)
{
maxItems = numItems - pos;
}
XChangeProperty(xDisplay, window, property,
xType, format, mode, &data[pos*format/8], maxItems);
mode = PropModeAppend;
pos += maxItems;
XSync(xDisplay, False);
}
XFree(data);
XSetErrorHandler(oldHandler);
if (appendFailure == NO)
{
status = YES;
}
}
return status;
}
- (Time) xTimeByAppending: (Atom)defaultType
{
NSDate *limit;
Time whenRequested;
Atom actualType = 0;
int actualFormat = 0;
unsigned long ni;
unsigned long ba;
unsigned char *pr;
/*
* Do a nul append to a property to get a timestamp,
* - but first we must determine the property-type and format.
*/
XGetWindowProperty(xDisplay, xAppWin, [self xPb], 0, 0, False,
AnyPropertyType, &actualType, &actualFormat, &ni, &ba, &pr);
if (pr != 0)
XFree(pr);
if (actualType == None)
{
/*
* The property doesn't exist - so we will be creating a new (empty)
* property.
*/
actualType = defaultType;
actualFormat = 8;
}
XChangeProperty(xDisplay, xAppWin, [self xPb], actualType, actualFormat,
PropModeReplace, 0, 0);
XFlush(xDisplay);
limit = [NSDate dateWithTimeIntervalSinceNow: 3.0];
[self setTimeOfLastAppend: 0];
/*
* Run an event loop until we get a notification for our nul append.
* this will give us an up-to-date timestamp as required by ICCCM.
*/
while ([self timeOfLastAppend] == 0)
{
[[NSRunLoop currentRunLoop] runMode: xWaitMode
beforeDate: limit];
if ([limit timeIntervalSinceNow] <= 0.0)
break; /* Timeout */
}
if ((whenRequested = [self timeOfLastAppend]) == 0)
{
NSLog(@"Timed out waiting for X append");
whenRequested = CurrentTime;
}
return whenRequested;
}
@end
// This are copies of functions from XGContextEvent.m.
// We should create a separate file for them.
static inline
Atom *
mimeTypeForPasteboardType(Display *xDisplay, NSZone *zone, NSArray *types)
{
Atom *typelist;
int count = [types count];
int i;
typelist = NSZoneMalloc(zone, (count+1) * sizeof(Atom));
for (i = 0; i < count; i++)
{
NSString *mime = [NSPasteboard mimeTypeForPasteboardType:
[types objectAtIndex: i]];
typelist[i] = XInternAtom(xDisplay, [mime cString], False);
}
typelist[count] = 0;
return typelist;
}
static inline
NSArray *
pasteboardTypeForMimeType(Display *xDisplay, NSZone *zone, Atom *typelist)
{
Atom *type = typelist;
NSMutableArray *newTypes = [[NSMutableArray allocWithZone: zone] init];
while(*type != None)
{
char *s = XGetAtomName(xDisplay, *type);
if (s)
{
[newTypes addObject: [NSPasteboard pasteboardTypeForMimeType:
[NSString stringWithCString: s]]];
}
}
return AUTORELEASE(newTypes);
}
static DndClass dnd;
@implementation XDragPbOwner
+ (void) initialize
{
if (self == [XDragPbOwner class])
{
NSPasteboard *p;
xdnd_init(&dnd, xDisplay);
p = [NSPasteboard pasteboardWithName: NSDragPboard];
[[XDragPbOwner alloc] initWithXPb: dnd.XdndSelection osPb: p];
}
}
- (void) pasteboardChangedOwner: (NSPasteboard*)sender
{
NSArray *types;
Atom *typelist;
// Some GNUstep application did grap the drag pasteboard. Report this to X.
if (xdnd_set_selection_owner(&dnd, xAppWin, None))
{
NSLog(@"Failed to set X drag selection owner to the pasteboard server.");
}
[self setOwnedByOpenStep: YES];
// We also have to set the supported types for our window
types = [_pb types];
typelist = mimeTypeForPasteboardType(xDisplay, [self zone], types);
xdnd_set_type_list(&dnd, xAppWin, typelist);
NSZoneFree([self zone], typelist);
}
- (NSArray*) availableTypes
{
Window window;
Atom *types;
NSArray *newTypes;
window = XGetSelectionOwner(xDisplay, dnd.XdndSelection);
if (window == None)
return nil;
xdnd_get_type_list(&dnd, window, &types);
newTypes = pasteboardTypeForMimeType(xDisplay, [self zone], types);
free(types);
return newTypes;
}
- (void) pasteboard: (NSPasteboard*)pb provideDataForType: (NSString*)type
{
NSString *mime = [NSPasteboard mimeTypeForPasteboardType: type];
Atom mType = XInternAtom(xDisplay, [mime cString], False);
Window window;
Time whenRequested = CurrentTime;
NSDate *limit;
[self setData: nil];
// How can we get the selection owner?
window = XGetSelectionOwner(xDisplay, dnd.XdndSelection);
xdnd_convert_selection(&dnd, window, xAppWin, mType);
XFlush(xDisplay);
/*
* Run an event loop to read X events until we have aquired the
* pasteboard data we need.
*/
limit = [NSDate dateWithTimeIntervalSinceNow: 20.0];
[self setWaitingForSelection: whenRequested];
while ([self waitingForSelection] == whenRequested)
{
[[NSRunLoop currentRunLoop] runMode: xWaitMode
beforeDate: limit];
if ([limit timeIntervalSinceNow] <= 0.0)
break; /* Timeout */
}
if ([self waitingForSelection] != 0)
{
[self setWaitingForSelection: 0];
NSLog(@"Timed out waiting for X selection");
}
[pb setData: [self data] forType: type];
}
- (void) xSelectionClear
{
// Do nothing as we don't know, which new types will be supplied
[self setOwnedByOpenStep: NO];
}
@end
Reference in a new issue View git blame Copy permalink