xserver/hw/xquartz/pbproxy/x-selection.m

/* x-selection.m -- proxies between NSPasteboard and X11 selections
 *
 * Copyright (c) 2002-2012 Apple Inc. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation files
 * (the "Software"), to deal in the Software without restriction,
 * including without limitation the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT.  IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT
 * HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *
 * Except as contained in this notice, the name(s) of the above
 * copyright holders shall not be used in advertising or otherwise to
 * promote the sale, use or other dealings in this Software without
 * prior written authorization.
 */

#import "x-selection.h"

#include <stdio.h>
#include <stdlib.h>
#include <X11/Xatom.h>
#include <X11/Xutil.h>
#import <AppKit/NSGraphics.h>
#import <AppKit/NSImage.h>
#import <AppKit/NSBitmapImageRep.h>

/*
 * The basic design of the pbproxy code is as follows.
 *
 * When a client selects text, say from an xterm - we only copy it when the
 * X11 Edit->Copy menu item is pressed or the shortcut activated.  In this
 * case we take the PRIMARY selection, and set it as the NSPasteboard data.
 *
 * When an X11 client copies something to the CLIPBOARD, pbproxy greedily grabs
 * the data, sets it as the NSPasteboard data, and finally sets itself as
 * owner of the CLIPBOARD.
 *
 * When an X11 window is activated we check to see if the NSPasteboard has
 * changed.  If the NSPasteboard has changed, then we set pbproxy as owner
 * of the PRIMARY and CLIPBOARD and respond to requests for text and images.
 *
 * The behavior is now dynamic since the information above was written.
 * The behavior is now dependent on the pbproxy_prefs below.
 */

/*
 * TODO:
 * 1. handle MULTIPLE - I need to study the ICCCM further, and find a test app.
 * 2. Handle NSPasteboard updates immediately, not on active/inactive
 *    - Open xterm, run 'cat readme.txt | pbcopy'
 */

static struct {
    BOOL active;
    BOOL primary_on_grab; /* This is provided as an option for people who
                           * want it and has issues that won't ever be
                           * addressed to make it *always* work.
                           */
    BOOL clipboard_to_pasteboard;
    BOOL pasteboard_to_primary;
    BOOL pasteboard_to_clipboard;
} pbproxy_prefs = { YES, NO, YES, YES, YES };

@implementation x_selection

static struct propdata null_propdata = {
    NULL, 0, 0
};

#ifdef DEBUG
static void
dump_prefs()
{
    ErrorF("pbproxy preferences:\n"
           "\tactive %u\n"
           "\tprimary_on_grab %u\n"
           "\tclipboard_to_pasteboard %u\n"
           "\tpasteboard_to_primary %u\n"
           "\tpasteboard_to_clipboard %u\n",
           pbproxy_prefs.active,
           pbproxy_prefs.primary_on_grab,
           pbproxy_prefs.clipboard_to_pasteboard,
           pbproxy_prefs.pasteboard_to_primary,
           pbproxy_prefs.pasteboard_to_clipboard);
}
#endif

extern CFStringRef app_prefs_domain_cfstr;

static BOOL
prefs_get_bool(CFStringRef key, BOOL defaultValue)
{
    Boolean value, ok;

    value = CFPreferencesGetAppBooleanValue(key, app_prefs_domain_cfstr, &ok);

    return ok ? (BOOL)value : defaultValue;
}

static void
init_propdata(struct propdata *pdata)
{
    *pdata = null_propdata;
}

static void
free_propdata(struct propdata *pdata)
{
    free(pdata->data);
    *pdata = null_propdata;
}

/*
 * Return True if an error occurs.  Return False if pdata has data
 * and we finished.
 * The property is only deleted when bytesleft is 0 if delete is True.
 */
static Bool
get_property(Window win, Atom property, struct propdata *pdata, Bool delete,
             Atom *type)
{
    long offset = 0;
    unsigned long numitems, bytesleft = 0;
#ifdef TEST
    /* This is used to test the growth handling. */
    unsigned long length = 4UL;
#else
    unsigned long length = (100000UL + 3) / 4;
#endif
    unsigned char *buf = NULL, *chunk = NULL;
    size_t buflen = 0, chunkbytesize = 0;
    int format;

    TRACE();

    if (None == property)
        return True;

    do {
        unsigned long newbuflen = 0;
        unsigned char *newbuf = NULL;

#ifdef TEST
        ErrorF("bytesleft %lu\n", bytesleft);
#endif

        if (Success != XGetWindowProperty(xpbproxy_dpy, win, property,
                                          offset, length, delete,
                                          AnyPropertyType,
                                          type, &format, &numitems,
                                          &bytesleft, &chunk)) {
            DebugF("Error while getting window property.\n");
            *pdata = null_propdata;
            free(buf);
            return True;
        }

#ifdef TEST
        ErrorF("format %d numitems %lu bytesleft %lu\n",
               format, numitems, bytesleft);

        ErrorF("type %s\n", XGetAtomName(xpbproxy_dpy, *type));
#endif

        /* Format is the number of bits. */
        if (format == 8)
            chunkbytesize = numitems;
        else if (format == 16)
            chunkbytesize = numitems * sizeof(short);
        else if (format == 32)
            chunkbytesize = numitems * sizeof(long);

#ifdef TEST
        ErrorF("chunkbytesize %zu\n", chunkbytesize);
#endif
        newbuflen = buflen + chunkbytesize;
        if (newbuflen > 0) {
            newbuf = realloc(buf, newbuflen);

            if (NULL == newbuf) {
                XFree(chunk);
                free(buf);
                return True;
            }

            memcpy(newbuf + buflen, chunk, chunkbytesize);
            XFree(chunk);
            buf = newbuf;
            buflen = newbuflen;
            /* offset is a multiple of 32 bits*/
            offset += chunkbytesize / 4;
        }
        else {
            if (chunk)
                XFree(chunk);
        }

#ifdef TEST
        ErrorF("bytesleft %lu\n", bytesleft);
#endif
    } while (bytesleft > 0);

    pdata->data = buf;
    pdata->length = buflen;
    pdata->format = format;

    return /*success*/ False;
}

/* Implementation methods */

/* This finds the preferred type from a TARGETS list.*/
- (Atom) find_preferred:(struct propdata *)pdata
{
    Atom a = None;
    size_t i, step;
    Bool png = False, jpeg = False, utf8 = False, string = False;

    TRACE();

    if (pdata->format != 32) {
        ErrorF(
            "Atom list is expected to be formatted as an array of 32bit values.\n");
        return None;
    }

    for (i = 0, step = sizeof(long); i < pdata->length; i += step) {
        a = (Atom) * (long *)(pdata->data + i);

        if (a == atoms->image_png) {
            png = True;
        }
        else if (a == atoms->image_jpeg) {
            jpeg = True;
        }
        else if (a == atoms->utf8_string) {
            utf8 = True;
        }
        else if (a == atoms->string) {
            string = True;
        }
        else {
            char *type = XGetAtomName(xpbproxy_dpy, a);
            if (type) {
                DebugF("Unhandled X11 mime type: %s", type);
                XFree(type);
            }
        }
    }

    /*We prefer PNG over strings, and UTF8 over a Latin-1 string.*/
    if (png)
        return atoms->image_png;

    if (jpeg)
        return atoms->image_jpeg;

    if (utf8)
        return atoms->utf8_string;

    if (string)
        return atoms->string;

    /* This is evidently something we don't know how to handle.*/
    return None;
}

/* Return True if this is an INCR-style transfer. */
- (Bool) is_incr_type:(XSelectionEvent *)e
{
    Atom seltype;
    int format;
    unsigned long numitems = 0UL, bytesleft = 0UL;
    unsigned char *chunk;

    TRACE();

    if (Success != XGetWindowProperty(xpbproxy_dpy, e->requestor, e->property,
                                      /*offset*/ 0L, /*length*/ 4UL,
                                      /*Delete*/ False,
                                      AnyPropertyType, &seltype, &format,
                                      &numitems, &bytesleft, &chunk)) {
        return False;
    }

    if (chunk)
        XFree(chunk);

    return (seltype == atoms->incr) ? True : False;
}

/*
 * This should be called after a selection has been copied,
 * or when the selection is unfinished before a transfer completes.
 */
- (void) release_pending
{
    TRACE();

    free_propdata(&pending.propdata);
    pending.requestor = None;
    pending.selection = None;
}

/* Return True if an error occurs during an append.*/
/* Return False if the append succeeds. */
- (Bool) append_to_pending:(struct propdata *)pdata requestor:(Window)
   requestor
{
    unsigned char *newdata;
    size_t newlength;

    TRACE();

    if (requestor != pending.requestor) {
        [self release_pending];
        pending.requestor = requestor;
    }

    newlength = pending.propdata.length + pdata->length;
    newdata = realloc(pending.propdata.data, newlength);

    if (NULL == newdata) {
        perror("realloc propdata");
        [self release_pending];
        return True;
    }

    memcpy(newdata + pending.propdata.length, pdata->data, pdata->length);
    pending.propdata.data = newdata;
    pending.propdata.length = newlength;

    return False;
}

/* Called when X11 becomes active (i.e. has key focus) */
- (void) x_active:(Time)timestamp
{
    static NSInteger changeCount;
    NSInteger countNow;
    NSPasteboard *pb;

    TRACE();

    pb = [NSPasteboard generalPasteboard];

    if (nil == pb)
        return;

    countNow = [pb changeCount];

    if (countNow != changeCount) {
        DebugF("changed pasteboard!\n");
        changeCount = countNow;

        if (pbproxy_prefs.pasteboard_to_primary) {
            XSetSelectionOwner(xpbproxy_dpy, atoms->primary,
                               _selection_window,
                               CurrentTime);
        }

        if (pbproxy_prefs.pasteboard_to_clipboard) {
            [self own_clipboard];
        }
    }

#if 0
    /*gstaplin: we should perhaps investigate something like this branch above...*/
    if ([_pasteboard availableTypeFromArray: _known_types] != nil) {
        /* Pasteboard has data we should proxy; I think it makes
           sense to put it on both CLIPBOARD and PRIMARY */

        XSetSelectionOwner(xpbproxy_dpy, atoms->clipboard,
                           _selection_window, timestamp);
        XSetSelectionOwner(xpbproxy_dpy, atoms->primary,
                           _selection_window, timestamp);
    }
#endif
}

/* Called when X11 loses key focus */
- (void) x_inactive:(Time)timestamp
{
    TRACE();
}

/* This requests the TARGETS list from the PRIMARY selection owner. */
- (void) x_copy_request_targets
{
    TRACE();

    request_atom = atoms->targets;
    XConvertSelection(xpbproxy_dpy, atoms->primary, atoms->targets,
                      atoms->primary, _selection_window, CurrentTime);
}

/* Called when the Edit/Copy item on the main X11 menubar is selected
 * and no appkit window claims it. */
- (void) x_copy:(Time)timestamp
{
    Window w;

    TRACE();

    w = XGetSelectionOwner(xpbproxy_dpy, atoms->primary);

    if (None != w) {
        ++pending_copy;

        if (1 == pending_copy) {
            /*
             * There are no other copy operations in progress, so we
             * can proceed safely.  Otherwise the copy_completed method
             * will see that the pending_copy is > 1, and do another copy.
             */
            [self x_copy_request_targets];
        }
    }
}

/* Set pbproxy as owner of the SELECTION_MANAGER selection.
 * This prevents tools like xclipboard from causing havoc.
 * Returns TRUE on success
 */
- (BOOL) set_clipboard_manager_status:(BOOL)value
{
    TRACE();

    Window owner = XGetSelectionOwner(xpbproxy_dpy, atoms->clipboard_manager);

    if (value) {
        if (owner == _selection_window)
            return TRUE;

        if (owner != None) {
            ErrorF(
                "A clipboard manager using window 0x%lx already owns the clipboard selection.  "
                "pbproxy will not sync clipboard to pasteboard.\n", owner);
            return FALSE;
        }

        XSetSelectionOwner(xpbproxy_dpy, atoms->clipboard_manager,
                           _selection_window,
                           CurrentTime);
        return (_selection_window ==
                XGetSelectionOwner(xpbproxy_dpy, atoms->clipboard_manager));
    }
    else {
        if (owner != _selection_window)
            return TRUE;

        XSetSelectionOwner(xpbproxy_dpy, atoms->clipboard_manager, None,
                           CurrentTime);
        return (None ==
                XGetSelectionOwner(xpbproxy_dpy, atoms->clipboard_manager));
    }

    return FALSE;
}

/*
 * This occurs when we previously owned a selection,
 * and then lost it from another client.
 */
- (void) clear_event:(XSelectionClearEvent *)e
{

    TRACE();

    DebugF("e->selection %s\n", XGetAtomName(xpbproxy_dpy, e->selection));

    if (e->selection == atoms->clipboard) {
        /*
         * We lost ownership of the CLIPBOARD.
         */
        ++pending_clipboard;

        if (1 == pending_clipboard) {
            /* Claim the clipboard contents from the new owner. */
            [self claim_clipboard];
        }
    }
    else if (e->selection == atoms->clipboard_manager) {
        if (pbproxy_prefs.clipboard_to_pasteboard) {
            /* Another CLIPBOARD_MANAGER has set itself as owner.  Disable syncing
             * to avoid a race.
             */
            ErrorF("Another clipboard manager was started!  "
                   "xpbproxy is disabling syncing with clipboard.\n");
            pbproxy_prefs.clipboard_to_pasteboard = NO;
        }
    }
}

/*
 * We greedily acquire the clipboard after it changes, and on startup.
 */
- (void) claim_clipboard
{
    Window owner;

    TRACE();

    if (!pbproxy_prefs.clipboard_to_pasteboard)
        return;

    owner = XGetSelectionOwner(xpbproxy_dpy, atoms->clipboard);
    if (None == owner) {
        /*
         * The owner probably died or we are just starting up pbproxy.
         * Set pbproxy's _selection_window as the owner, and continue.
         */
        DebugF("No clipboard owner.\n");
        [self copy_completed:atoms->clipboard];
        return;
    }
    else if (owner == _selection_window) {
        [self copy_completed:atoms->clipboard];
        return;
    }

    DebugF("requesting targets\n");

    request_atom = atoms->targets;
    XConvertSelection(xpbproxy_dpy, atoms->clipboard, atoms->targets,
                      atoms->clipboard, _selection_window, CurrentTime);
    XFlush(xpbproxy_dpy);
    /* Now we will get a SelectionNotify event in the future. */
}

/* Greedily acquire the clipboard. */
- (void) own_clipboard
{

    TRACE();

    /* We should perhaps have a boundary limit on the number of iterations... */
    do {
        XSetSelectionOwner(xpbproxy_dpy, atoms->clipboard, _selection_window,
                           CurrentTime);
    } while (_selection_window != XGetSelectionOwner(xpbproxy_dpy,
                                                     atoms->clipboard));
}

- (void) init_reply:(XEvent *)reply request:(XSelectionRequestEvent *)e
{
    reply->xselection.type = SelectionNotify;
    reply->xselection.selection = e->selection;
    reply->xselection.target = e->target;
    reply->xselection.requestor = e->requestor;
    reply->xselection.time = e->time;
    reply->xselection.property = None;
}

- (void) send_reply:(XEvent *)reply
{
    /*
     * We are supposed to use an empty event mask, and not propagate
     * the event, according to the ICCCM.
     */
    DebugF("reply->xselection.requestor 0x%lx\n", reply->xselection.requestor);

    XSendEvent(xpbproxy_dpy, reply->xselection.requestor, False, 0, reply);
    XFlush(xpbproxy_dpy);
}

/*
 * This responds to a TARGETS request.
 * The result is a list of a ATOMs that correspond to the types available
 * for a selection.
 * For instance an application might provide a UTF8_STRING and a STRING
 * (in Latin-1 encoding).  The requestor can then make the choice based on
 * the list.
 */
- (void) send_targets:(XSelectionRequestEvent *)e pasteboard:(NSPasteboard *)
   pb
{
    XEvent reply;
    NSArray *pbtypes;

    [self init_reply:&reply request:e];

    pbtypes = [pb types];
    if (pbtypes) {
        long list[7]; /* Don't forget to increase this if we handle more types! */
        long count = 0;

        /*
         * I'm not sure if this is needed, but some toolkits/clients list
         * TARGETS in response to targets.
         */
        list[count] = atoms->targets;
        ++count;

        if ([pbtypes containsObject:NSStringPboardType]) {
            /* We have a string type that we can convert to UTF8, or Latin-1... */
            DebugF("NSStringPboardType\n");
            list[count] = atoms->utf8_string;
            ++count;
            list[count] = atoms->string;
            ++count;
            list[count] = atoms->compound_text;
            ++count;
        }

        /* TODO add the NSPICTPboardType back again, once we have conversion
         * functionality in send_image.
         */
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations" // NSPICTPboardType
#endif

        if ([pbtypes containsObject:NSPICTPboardType]
            || [pbtypes containsObject:NSTIFFPboardType]) {
            /* We can convert a TIFF to a PNG or JPEG. */
            DebugF("NSTIFFPboardType\n");
            list[count] = atoms->image_png;
            ++count;
            list[count] = atoms->image_jpeg;
            ++count;
        }

#ifdef __clang__
#pragma clang diagnostic pop
#endif

        if (count) {
            /* We have a list of ATOMs to send. */
            XChangeProperty(xpbproxy_dpy, e->requestor, e->property,
                            atoms->atom, 32,
                            PropModeReplace, (unsigned char *)list,
                            count);

            reply.xselection.property = e->property;
        }
    }

    [self send_reply:&reply];
}

- (void) send_string:(XSelectionRequestEvent *)e utf8:(BOOL)utf8 pasteboard:(
       NSPasteboard *)pb
{
    XEvent reply;
    NSArray *pbtypes;
    NSString *data;
    const char *bytes;
    NSUInteger length;

    TRACE();

    [self init_reply:&reply request:e];

    pbtypes = [pb types];

    if (![pbtypes containsObject:NSStringPboardType]) {
        [self send_reply:&reply];
        return;
    }

    DebugF("pbtypes retainCount after containsObject: %lu\n",
           [pbtypes retainCount]);

    data = [pb stringForType:NSStringPboardType];

    if (nil == data) {
        [self send_reply:&reply];
        return;
    }

    if (utf8) {
        bytes = [data UTF8String];
        /*
         * We don't want the UTF-8 string length here.
         * We want the length in bytes.
         */
        length = strlen(bytes);

        if (length < 50) {
            DebugF("UTF-8: %s\n", bytes);
            DebugF("UTF-8 length: %lu\n", length);
        }
    }
    else {
        DebugF("Latin-1\n");
        bytes = [data cStringUsingEncoding:NSISOLatin1StringEncoding];
        /*WARNING: bytes is not NUL-terminated. */
        length = [data lengthOfBytesUsingEncoding:NSISOLatin1StringEncoding];
    }

    DebugF("e->target %s\n", XGetAtomName(xpbproxy_dpy, e->target));

    XChangeProperty(xpbproxy_dpy, e->requestor, e->property, e->target,
                    8, PropModeReplace, (unsigned char *)bytes, length);

    reply.xselection.property = e->property;

    [self send_reply:&reply];
}

- (void) send_compound_text:(XSelectionRequestEvent *)e pasteboard:(
       NSPasteboard *)pb
{
    XEvent reply;
    NSArray *pbtypes;

    TRACE();

    [self init_reply:&reply request:e];

    pbtypes = [pb types];

    if ([pbtypes containsObject: NSStringPboardType]) {
        NSString *data = [pb stringForType:NSStringPboardType];
        if (nil != data) {
            /*
             * Cast to (void *) to avoid a const warning.
             * AFAIK Xutf8TextListToTextProperty does not modify the input memory.
             */
            void *utf8 = (void *)[data UTF8String];
            char *list[] = { utf8, NULL };
            XTextProperty textprop;

            textprop.value = NULL;

            if (Success == Xutf8TextListToTextProperty(xpbproxy_dpy, list, 1,
                                                       XCompoundTextStyle,
                                                       &textprop)) {

                if (8 != textprop.format)
                    DebugF(
                        "textprop.format is unexpectedly not 8 - it's %d instead\n",
                        textprop.format);

                XChangeProperty(xpbproxy_dpy, e->requestor, e->property,
                                atoms->compound_text, textprop.format,
                                PropModeReplace, textprop.value,
                                textprop.nitems);

                reply.xselection.property = e->property;
            }

            if (textprop.value)
                XFree(textprop.value);

        }
    }

    [self send_reply:&reply];
}

/* Finding a test application that uses MULTIPLE has proven to be difficult. */
- (void) send_multiple:(XSelectionRequestEvent *)e
{
    XEvent reply;

    TRACE();

    [self init_reply:&reply request:e];

    if (None != e->property) {}

    [self send_reply:&reply];
}

/* Return nil if an error occurred. */
/* DO NOT retain the encdata for longer than the length of an event response.
 * The autorelease pool will reuse/free it.
 */
- (NSData *) encode_image_data:(NSData *)data type:(NSBitmapImageFileType)
   enctype
{
    NSBitmapImageRep *bmimage = nil;
    NSData *encdata = nil;
    NSDictionary *dict = nil;

    bmimage = [[NSBitmapImageRep alloc] initWithData:data];

    if (nil == bmimage)
        return nil;

    dict = [[NSDictionary alloc] init];
    encdata = [bmimage representationUsingType:enctype properties:dict];

    if (nil == encdata) {
        [dict autorelease];
        [bmimage autorelease];
        return nil;
    }

    [dict autorelease];
    [bmimage autorelease];

    return encdata;
}

/* Return YES when an error has occurred when trying to send the PICT. */
/* The caller should send a default response with a property of None when an error occurs. */
- (BOOL) send_image_pict_reply:(XSelectionRequestEvent *)e
                    pasteboard:(NSPasteboard *)pb
                          type:(NSBitmapImageFileType)imagetype
{
    XEvent reply;
    NSImage *img = nil;
    NSData *data = nil, *encdata = nil;
    NSUInteger length;
    const void *bytes = NULL;

    img = [[NSImage alloc] initWithPasteboard:pb];

    if (nil == img) {
        return YES;
    }

    data = [img TIFFRepresentation];

    if (nil == data) {
        [img autorelease];
        ErrorF("unable to convert PICT to TIFF!\n");
        return YES;
    }

    encdata = [self encode_image_data:data type:imagetype];
    if (nil == encdata) {
        [img autorelease];
        return YES;
    }

    [self init_reply:&reply request:e];

    length = [encdata length];
    bytes = [encdata bytes];

    XChangeProperty(xpbproxy_dpy, e->requestor, e->property, e->target,
                    8, PropModeReplace, bytes, length);
    reply.xselection.property = e->property;

    [self send_reply:&reply];

    [img autorelease];

    return NO; /*no error*/
}

/* Return YES if an error occurred. */
/* The caller should send a reply with a property of None when an error occurs. */
- (BOOL) send_image_tiff_reply:(XSelectionRequestEvent *)e
                    pasteboard:(NSPasteboard *)pb
                          type:(NSBitmapImageFileType)imagetype
{
    XEvent reply;
    NSData *data = nil;
    NSData *encdata = nil;
    NSUInteger length;
    const void *bytes = NULL;

    data = [pb dataForType:NSTIFFPboardType];

    if (nil == data)
        return YES;

    encdata = [self encode_image_data:data type:imagetype];

    if (nil == encdata)
        return YES;

    [self init_reply:&reply request:e];

    length = [encdata length];
    bytes = [encdata bytes];

    XChangeProperty(xpbproxy_dpy, e->requestor, e->property, e->target,
                    8, PropModeReplace, bytes, length);
    reply.xselection.property = e->property;

    [self send_reply:&reply];

    return NO; /*no error*/
}

- (void) send_image:(XSelectionRequestEvent *)e pasteboard:(NSPasteboard *)pb
{
    NSArray *pbtypes = nil;
    NSBitmapImageFileType imagetype = NSPNGFileType;

    TRACE();

    if (e->target == atoms->image_png)
        imagetype = NSPNGFileType;
    else if (e->target == atoms->image_jpeg)
        imagetype = NSJPEGFileType;
    else {
        ErrorF(
            "internal failure in xpbproxy!  imagetype being sent isn't PNG or JPEG.\n");
    }

    pbtypes = [pb types];

    if (pbtypes) {
        if ([pbtypes containsObject:NSTIFFPboardType]) {
            if (NO ==
                [self send_image_tiff_reply:e pasteboard:pb type:imagetype])
                return;
        }
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated-declarations" // NSPICTPboardType
#endif
        else if ([pbtypes containsObject:NSPICTPboardType])
#ifdef __clang__
#pragma clang diagnostic pop
#endif
        {
            if (NO ==
                [self send_image_pict_reply:e pasteboard:pb type:imagetype])
                return;

            /* Fall through intentionally to the send_none: */
        }
    }

    [self send_none:e];
}

- (void)send_none:(XSelectionRequestEvent *)e
{
    XEvent reply;

    TRACE();

    [self init_reply:&reply request:e];
    [self send_reply:&reply];
}

/* Another client requested the data or targets of data available from the clipboard. */
- (void)request_event:(XSelectionRequestEvent *)e
{
    NSPasteboard *pb;

    TRACE();

    /* TODO We should also keep track of the time of the selection, and
     * according to the ICCCM "refuse the request" if the event timestamp
     * is before we owned it.
     * What should we base the time on?  How can we get the current time just
     * before an XSetSelectionOwner?  Is it the server's time, or the clients?
     * According to the XSelectionRequestEvent manual page, the Time value
     * may be set to CurrentTime or a time, so that makes it a bit different.
     * Perhaps we should just punt and ignore races.
     */

    /*TODO we need a COMPOUND_TEXT test app*/
    /*TODO we need a MULTIPLE test app*/

    pb = [NSPasteboard generalPasteboard];
    if (nil == pb) {
        [self send_none:e];
        return;
    }

    if (None != e->target)
        DebugF("e->target %s\n", XGetAtomName(xpbproxy_dpy, e->target));

    if (e->target == atoms->targets) {
        /* The paste requestor wants to know what TARGETS we support. */
        [self send_targets:e pasteboard:pb];
    }
    else if (e->target == atoms->multiple) {
        /*
         * This isn't finished, and may never be, unless I can find
         * a good test app.
         */
        [self send_multiple:e];
    }
    else if (e->target == atoms->utf8_string) {
        [self send_string:e utf8:YES pasteboard:pb];
    }
    else if (e->target == atoms->string) {
        [self send_string:e utf8:NO pasteboard:pb];
    }
    else if (e->target == atoms->compound_text) {
        [self send_compound_text:e pasteboard:pb];
    }
    else if (e->target == atoms->multiple) {
        [self send_multiple:e];
    }
    else if (e->target == atoms->image_png || e->target ==
             atoms->image_jpeg) {
        [self send_image:e pasteboard:pb];
    }
    else {
        [self send_none:e];
    }
}

/* This handles the events resulting from an XConvertSelection request. */
- (void) notify_event:(XSelectionEvent *)e
{
    Atom type;
    struct propdata pdata;

    TRACE();

    [self release_pending];

    if (None == e->property) {
        DebugF("e->property is None.\n");
        [self copy_completed:e->selection];
        /* Nothing is selected. */
        return;
    }

#if 0
    ErrorF("e->selection %s\n", XGetAtomName(xpbproxy_dpy, e->selection));
    ErrorF("e->property %s\n", XGetAtomName(xpbproxy_dpy, e->property));
#endif

    if ([self is_incr_type:e]) {
        /*
         * This is an INCR-style transfer, which means that we
         * will get the data after a series of PropertyNotify events.
         */
        DebugF("is INCR\n");

        if (get_property(e->requestor, e->property, &pdata, /*Delete*/ True,
                         &type)) {
            /*
             * An error occurred, so we should invoke the copy_completed:, but
             * not handle_selection:type:propdata:
             */
            [self copy_completed:e->selection];
            return;
        }

        free_propdata(&pdata);

        pending.requestor = e->requestor;
        pending.selection = e->selection;

        DebugF("set pending.requestor to 0x%lx\n", pending.requestor);
    }
    else {
        if (get_property(e->requestor, e->property, &pdata, /*Delete*/ True,
                         &type)) {
            [self copy_completed:e->selection];
            return;
        }

        /* We have the complete selection data.*/
        [self handle_selection:e->selection type:type propdata:&pdata];

        DebugF("handled selection with the first notify_event\n");
    }
}

/* This is used for INCR transfers.  See the ICCCM for the details. */
/* This is used to retrieve PRIMARY and CLIPBOARD selections. */
- (void) property_event:(XPropertyEvent *)e
{
    struct propdata pdata;
    Atom type;

    TRACE();

    if (None != e->atom) {
#ifdef DEBUG
        char *name = XGetAtomName(xpbproxy_dpy, e->atom);

        if (name) {
            DebugF("e->atom %s\n", name);
            XFree(name);
        }
#endif
    }

    if (None != pending.requestor && PropertyNewValue == e->state) {
        DebugF("pending.requestor 0x%lx\n", pending.requestor);

        if (get_property(e->window, e->atom, &pdata, /*Delete*/ True,
                         &type)) {
            [self copy_completed:pending.selection];
            [self release_pending];
            return;
        }

        if (0 == pdata.length) {
            /*
             * We completed the transfer.
             * handle_selection will call copy_completed: for us.
             */
            [self handle_selection:pending.selection type:type propdata:&
             pending.propdata];
            free_propdata(&pdata);
            pending.propdata = null_propdata;
            pending.requestor = None;
            pending.selection = None;
        }
        else {
            [self append_to_pending:&pdata requestor:e->window];
            free_propdata(&pdata);
        }
    }
}

- (void) xfixes_selection_notify:(XFixesSelectionNotifyEvent *)e
{
    if (!pbproxy_prefs.active)
        return;

    switch (e->subtype) {
    case XFixesSetSelectionOwnerNotify:
        if (e->selection == atoms->primary && pbproxy_prefs.primary_on_grab)
            [self x_copy:e->timestamp];
        break;

    case XFixesSelectionWindowDestroyNotify:
    case XFixesSelectionClientCloseNotify:
    default:
        ErrorF("Unhandled XFixesSelectionNotifyEvent: subtype=%d\n",
               e->subtype);
        break;
    }
}

- (void) handle_targets: (Atom)selection propdata:(struct propdata *)pdata
{
    /* Find a type we can handle and prefer from the list of ATOMs. */
    Atom preferred;
    char *name;

    TRACE();

    preferred = [self find_preferred:pdata];

    if (None == preferred) {
        /*
         * This isn't required by the ICCCM, but some apps apparently
         * don't respond to TARGETS properly.
         */
        preferred = atoms->string;
    }

    (void)name; /* Avoid a warning with non-debug compiles. */
#ifdef DEBUG
    name = XGetAtomName(xpbproxy_dpy, preferred);

    if (name) {
        DebugF("requesting %s\n", name);
    }
#endif
    request_atom = preferred;
    XConvertSelection(xpbproxy_dpy, selection, preferred, selection,
                      _selection_window, CurrentTime);
}

/* This handles the image type of selection (typically in CLIPBOARD). */
/* We convert to a TIFF, so that other applications can paste more easily. */
- (void) handle_image: (struct propdata *)pdata pasteboard:(NSPasteboard *)pb
{
    NSArray *pbtypes;
    NSUInteger length;
    NSData *data, *tiff;
    NSBitmapImageRep *bmimage;

    TRACE();

    length = pdata->length;
    data = [[NSData alloc] initWithBytes:pdata->data length:length];

    if (nil == data) {
        DebugF("unable to create NSData object!\n");
        return;
    }

    DebugF("data retainCount before NSBitmapImageRep initWithData: %lu\n",
           [data retainCount]);

    bmimage = [[NSBitmapImageRep alloc] initWithData:data];

    if (nil == bmimage) {
        [data autorelease];
        DebugF("unable to create NSBitmapImageRep!\n");
        return;
    }

    DebugF("data retainCount after NSBitmapImageRep initWithData: %lu\n",
           [data retainCount]);

    @try
    {
        tiff = [bmimage TIFFRepresentation];
    }

    @catch (NSException *e)
    {
        DebugF("NSTIFFException!\n");
        [data autorelease];
        [bmimage autorelease];
        return;
    }

    DebugF("bmimage retainCount after TIFFRepresentation %lu\n",
           [bmimage retainCount]);

    pbtypes = [NSArray arrayWithObjects:NSTIFFPboardType, nil];

    if (nil == pbtypes) {
        [data autorelease];
        [bmimage autorelease];
        return;
    }

    [pb declareTypes:pbtypes owner:nil];
    if (YES != [pb setData:tiff forType:NSTIFFPboardType]) {
        DebugF("writing pasteboard data failed!\n");
    }

    [data autorelease];

    DebugF("bmimage retainCount before release %lu\n", [bmimage retainCount]);

    [bmimage autorelease];
}

/* This handles the UTF8_STRING type of selection. */
- (void) handle_utf8_string:(struct propdata *)pdata pasteboard:(NSPasteboard
                                                                 *)pb
{
    NSString *string;
    NSArray *pbtypes;

    TRACE();

    string =
        [[NSString alloc] initWithBytes:pdata->data length:pdata->length
         encoding:
         NSUTF8StringEncoding];

    if (nil == string)
        return;

    pbtypes = [NSArray arrayWithObjects:NSStringPboardType, nil];

    if (nil == pbtypes) {
        [string autorelease];
        return;
    }

    [pb declareTypes:pbtypes owner:nil];

    if (YES != [pb setString:string forType:NSStringPboardType]) {
        ErrorF("pasteboard setString:forType: failed!\n");
    }
    [string autorelease];
    DebugF("done handling utf8 string\n");
}

/* This handles the STRING type, which should be in Latin-1. */
- (void) handle_string: (struct propdata *)pdata pasteboard:(NSPasteboard *)
   pb
{
    NSString *string;
    NSArray *pbtypes;

    TRACE();

    string =
        [[NSString alloc] initWithBytes:pdata->data length:pdata->length
         encoding:
         NSISOLatin1StringEncoding];

    if (nil == string)
        return;

    pbtypes = [NSArray arrayWithObjects:NSStringPboardType, nil];

    if (nil == pbtypes) {
        [string autorelease];
        return;
    }

    [pb declareTypes:pbtypes owner:nil];
    if (YES != [pb setString:string forType:NSStringPboardType]) {
        ErrorF("pasteboard setString:forType failed in handle_string!\n");
    }
    [string autorelease];
}

/* This is called when the selection is completely retrieved from another client. */
/* Warning: this frees the propdata. */
- (void) handle_selection:(Atom)selection type:(Atom)type propdata:(struct
                                                                    propdata
                                                                    *)pdata
{
    NSPasteboard *pb;

    TRACE();

    pb = [NSPasteboard generalPasteboard];

    if (nil == pb) {
        [self copy_completed:selection];
        free_propdata(pdata);
        return;
    }

    /*
     * Some apps it seems set the type to TARGETS instead of ATOM, such as Eterm.
     * These aren't ICCCM compliant apps, but we need these to work...
     */
    if (request_atom == atoms->targets
        && (type == atoms->atom || type == atoms->targets)) {
        [self handle_targets:selection propdata:pdata];
        free_propdata(pdata);
        return;
    }
    else if (type == atoms->image_png) {
        [self handle_image:pdata pasteboard:pb];
    }
    else if (type == atoms->image_jpeg) {
        [self handle_image:pdata pasteboard:pb];
    }
    else if (type == atoms->utf8_string) {
        [self handle_utf8_string:pdata pasteboard:pb];
    }
    else if (type == atoms->string) {
        [self handle_string:pdata pasteboard:pb];
    }

    free_propdata(pdata);

    [self copy_completed:selection];
}

- (void) copy_completed:(Atom)selection
{
    TRACE();
    char *name;

    (void)name; /* Avoid warning with non-debug compiles. */
#ifdef DEBUG
    name = XGetAtomName(xpbproxy_dpy, selection);
    if (name) {
        DebugF("copy_completed: %s\n", name);
        XFree(name);
    }
#endif

    if (selection == atoms->primary && pending_copy > 0) {
        --pending_copy;
        if (pending_copy > 0) {
            /* Copy PRIMARY again. */
            [self x_copy_request_targets];
            return;
        }
    }
    else if (selection == atoms->clipboard && pending_clipboard > 0) {
        --pending_clipboard;
        if (pending_clipboard > 0) {
            /* Copy CLIPBOARD. */
            [self claim_clipboard];
            return;
        }
        else {
            /* We got the final data.  Now set pbproxy as the owner. */
            [self own_clipboard];
            return;
        }
    }

    /*
     * We had 1 or more primary in progress, and the clipboard arrived
     * while we were busy.
     */
    if (pending_clipboard > 0) {
        [self claim_clipboard];
    }
}

- (void) reload_preferences
{
    /*
     * It's uncertain how we could handle the synchronization failing, so cast to void.
     * The prefs_get_bool should fall back to defaults if the org.x.X11 plist doesn't exist or is invalid.
     */
    (void)CFPreferencesAppSynchronize(app_prefs_domain_cfstr);
#ifdef STANDALONE_XPBPROXY
    if (xpbproxy_is_standalone)
        pbproxy_prefs.active = YES;
    else
#endif
    pbproxy_prefs.active = prefs_get_bool(CFSTR(
                                              "sync_pasteboard"),
                                          pbproxy_prefs.active);
    pbproxy_prefs.primary_on_grab =
        prefs_get_bool(CFSTR(
                           "sync_primary_on_select"),
                       pbproxy_prefs.primary_on_grab);
    pbproxy_prefs.clipboard_to_pasteboard =
        prefs_get_bool(CFSTR(
                           "sync_clipboard_to_pasteboard"),
                       pbproxy_prefs.clipboard_to_pasteboard);
    pbproxy_prefs.pasteboard_to_primary =
        prefs_get_bool(CFSTR(
                           "sync_pasteboard_to_primary"),
                       pbproxy_prefs.pasteboard_to_primary);
    pbproxy_prefs.pasteboard_to_clipboard =
        prefs_get_bool(CFSTR(
                           "sync_pasteboard_to_clipboard"),
                       pbproxy_prefs.pasteboard_to_clipboard);

    /* This is used for debugging. */
    //dump_prefs();

    if (pbproxy_prefs.active && pbproxy_prefs.primary_on_grab &&
        !xpbproxy_have_xfixes) {
        ErrorF(
            "Disabling sync_primary_on_select functionality due to missing XFixes extension.\n");
        pbproxy_prefs.primary_on_grab = NO;
    }

    /* Claim or release the CLIPBOARD_MANAGER atom */
    if (![self set_clipboard_manager_status:(pbproxy_prefs.active &&
                                             pbproxy_prefs.
                                             clipboard_to_pasteboard)])
        pbproxy_prefs.clipboard_to_pasteboard = NO;

    if (pbproxy_prefs.active && pbproxy_prefs.clipboard_to_pasteboard)
        [self claim_clipboard];
}

- (BOOL) is_active
{
    return pbproxy_prefs.active;
}

/* NSPasteboard-required methods */

- (void) paste:(id)sender
{
    TRACE();
}

- (void) pasteboard:(NSPasteboard *)pb provideDataForType:(NSString *)type
{
    TRACE();
}

- (void) pasteboardChangedOwner:(NSPasteboard *)pb
{
    TRACE();

    /* Right now we don't care with this. */
}

/* Allocation */

- (id) init
{
    unsigned long pixel;

    self = [super init];
    if (self == nil)
        return nil;

    atoms->primary = XInternAtom(xpbproxy_dpy, "PRIMARY", False);
    atoms->clipboard = XInternAtom(xpbproxy_dpy, "CLIPBOARD", False);
    atoms->text = XInternAtom(xpbproxy_dpy, "TEXT", False);
    atoms->utf8_string = XInternAtom(xpbproxy_dpy, "UTF8_STRING", False);
    atoms->string = XInternAtom(xpbproxy_dpy, "STRING", False);
    atoms->targets = XInternAtom(xpbproxy_dpy, "TARGETS", False);
    atoms->multiple = XInternAtom(xpbproxy_dpy, "MULTIPLE", False);
    atoms->cstring = XInternAtom(xpbproxy_dpy, "CSTRING", False);
    atoms->image_png = XInternAtom(xpbproxy_dpy, "image/png", False);
    atoms->image_jpeg = XInternAtom(xpbproxy_dpy, "image/jpeg", False);
    atoms->incr = XInternAtom(xpbproxy_dpy, "INCR", False);
    atoms->atom = XInternAtom(xpbproxy_dpy, "ATOM", False);
    atoms->clipboard_manager = XInternAtom(xpbproxy_dpy, "CLIPBOARD_MANAGER",
                                           False);
    atoms->compound_text = XInternAtom(xpbproxy_dpy, "COMPOUND_TEXT", False);
    atoms->atom_pair = XInternAtom(xpbproxy_dpy, "ATOM_PAIR", False);

    pixel = BlackPixel(xpbproxy_dpy, DefaultScreen(xpbproxy_dpy));
    _selection_window =
        XCreateSimpleWindow(xpbproxy_dpy, DefaultRootWindow(xpbproxy_dpy),
                            0, 0, 1, 1, 0, pixel, pixel);

    /* This is used to get PropertyNotify events when doing INCR transfers. */
    XSelectInput(xpbproxy_dpy, _selection_window, PropertyChangeMask);

    request_atom = None;

    init_propdata(&pending.propdata);
    pending.requestor = None;
    pending.selection = None;

    pending_copy = 0;
    pending_clipboard = 0;

    if (xpbproxy_have_xfixes)
        XFixesSelectSelectionInput(xpbproxy_dpy, _selection_window,
                                   atoms->primary,
                                   XFixesSetSelectionOwnerNotifyMask);

    [self reload_preferences];

    return self;
}

- (void) dealloc
{
    if (None != _selection_window) {
        XDestroyWindow(xpbproxy_dpy, _selection_window);
        _selection_window = None;
    }

    free_propdata(&pending.propdata);

    [super dealloc];
}

@end