Attachment 16700 Details for Bug 1478 – src/Selection.c

src/Selection.c

Selection.c (text/plain), 64.40 KB, created by Ryan Hajdaj on 2008-05-22 20:21:23 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Ryan Hajdaj

Created: 2008-05-22 20:21:23 UTC

Size: 64.40 KB

patch

obsolete

>/* $Xorg: Selection.c,v 1.4 2001/02/09 02:03:56 xorgcvs Exp $ */
>
>/***********************************************************
>Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts,
>Copyright 1993 by Sun Microsystems, Inc. Mountain View, CA.
>
>                        All Rights Reserved
>
>Permission to use, copy, modify, and distribute this software and its
>documentation for any purpose and without fee is hereby granted,
>provided that the above copyright notice appear in all copies and that
>both that copyright notice and this permission notice appear in
>supporting documentation, and that the names of Digital or Sun not be
>used in advertising or publicity pertaining to distribution of the
>software without specific, written prior permission.
>
>DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
>ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
>DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
>WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
>ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
>SOFTWARE.
>
>SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO  THIS  SOFTWARE,
>INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
>NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE  LI-
>ABLE  FOR  ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
>ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,  DATA  OR
>PROFITS,  WHETHER  IN  AN  ACTION OF CONTRACT, NEGLIGENCE OR
>OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
>THE USE OR PERFORMANCE OF THIS SOFTWARE.
>
>******************************************************************/
>
>/*
>
>Copyright 1987, 1988, 1994, 1998  The Open Group
>
>Permission to use, copy, modify, distribute, and sell this software and its
>documentation for any purpose is hereby granted without fee, provided that
>the above copyright notice appear in all copies and that both that
>copyright notice and this permission notice appear in supporting
>documentation.
>
>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
>OPEN GROUP 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 of The Open Group shall not be
>used in advertising or otherwise to promote the sale, use or other dealings
>in this Software without prior written authorization from The Open Group.
>
>*/
>/* $XFree86: xc/lib/Xt/Selection.c,v 3.9 2001/12/14 19:56:29 dawes Exp $ */
>
>#ifdef HAVE_CONFIG_H
>#include <config.h>
>#endif
>#include "IntrinsicI.h"
>#include "StringDefs.h"
>#include "SelectionI.h"
>#include <X11/Xatom.h>
>#include <stdio.h>
>
>void _XtSetDefaultSelectionTimeout(
>	unsigned long *timeout)
>{
>	*timeout = 5000; /* default to 5 seconds */
>}
>
>void XtSetSelectionTimeout(
>	unsigned long timeout)
>{
>	XtAppSetSelectionTimeout(_XtDefaultAppContext(), timeout);
>}
>
>void XtAppSetSelectionTimeout(
>	XtAppContext app,
>	unsigned long timeout)
>{
>	LOCK_APP(app);
>	app->selectionTimeout = timeout;
>	UNLOCK_APP(app);
>}
>
>unsigned long XtGetSelectionTimeout(void)
>{
>	return XtAppGetSelectionTimeout(_XtDefaultAppContext());
>}
>
>unsigned long XtAppGetSelectionTimeout(
>	XtAppContext app)
>{
>	unsigned long retval;
>
>	LOCK_APP(app);
>	retval = app->selectionTimeout;
>	UNLOCK_APP(app);
>	return retval;
>}
>
>
>/* General utilities */
>
>static void HandleSelectionReplies(Widget, XtPointer, XEvent *, Boolean *);
>static void ReqTimedOut(XtPointer, XtIntervalId *);
>static void HandlePropertyGone(Widget, XtPointer, XEvent *, Boolean *);
>static void HandleGetIncrement(Widget, XtPointer, XEvent *, Boolean *);
>static void HandleIncremental(Display *, Widget, Atom, CallBackInfo, unsigned long);
>
>static XContext selectPropertyContext = 0;
>static XContext paramPropertyContext = 0;
>static XContext multipleContext = 0;
>
>/* Multiple utilities */
>static void AddSelectionRequests(Widget, Atom, int, Atom *, XtSelectionCallbackProc *, int, XtPointer *, Boolean *, Atom *);
>static Boolean IsGatheringRequest(Widget, Atom);
>
>#define PREALLOCED 32
>
>/* Parameter utilities */
>static void AddParamInfo(Widget, Atom, Atom);
>static void RemoveParamInfo(Widget, Atom);
>static Atom GetParamInfo(Widget, Atom);
>
>static int StorageSize[3] = {1, sizeof(short), sizeof(long)};
>#define BYTELENGTH(length, format) ((length) * StorageSize[(format)>>4])
>#define NUMELEM(bytelength, format) ((bytelength) / StorageSize[(format)>>4])
>
>/* Xlib and Xt are permitted to have different memory allocators, and in the
> * XtSelectionCallbackProc the client is instructed to free the selection
> * value with XtFree, so the selection value received from XGetWindowProperty
> * should be copied to memory allocated through Xt.  But copying is
> * undesirable since the selection value may be large, and, under normal
> * library configuration copying is unnecessary.
> */
>#ifdef XTTRACEMEMORY
>#define XT_COPY_SELECTION	1
>#endif
>
>/*ARGSUSED*/
>static void FreePropList(
> Widget w,			/* unused */
> XtPointer closure,
> XtPointer callData)		/* unused */
>{
>    PropList sarray = (PropList)closure;
>    LOCK_PROCESS;
>    XDeleteContext(sarray->dpy, DefaultRootWindow(sarray->dpy),
>		   selectPropertyContext);
>    UNLOCK_PROCESS;
>    XtFree((char*)sarray->list);
>    XtFree((char*)closure);
>}
>
>
>static PropList GetPropList(
>    Display *dpy)
>{
>    PropList sarray;
>    Atom atoms[4];
>    static char* names[] = {
>	"INCR",
>	"MULTIPLE",
>	"TIMESTAMP",
>	"_XT_SELECTION_0" };
>
>    LOCK_PROCESS;
>    if (selectPropertyContext == 0)
>	selectPropertyContext = XUniqueContext();
>    if (XFindContext(dpy, DefaultRootWindow(dpy), selectPropertyContext,
>		     (XPointer *)&sarray)) {
>	XtPerDisplay pd = _XtGetPerDisplay(dpy);
>	sarray = (PropList) __XtMalloc((unsigned) sizeof(PropListRec));
>	sarray->dpy = dpy;
>	XInternAtoms(dpy, names, 4, FALSE, atoms);
>	sarray->incr_atom = atoms[0];
>	sarray->indirect_atom = atoms[1];
>	sarray->timestamp_atom = atoms[2];
>	sarray->propCount = 1;
>	sarray->list =
>	    (SelectionProp)__XtMalloc((unsigned) sizeof(SelectionPropRec));
>	sarray->list[0].prop = atoms[3];
>	sarray->list[0].avail = TRUE;
>	(void) XSaveContext(dpy, DefaultRootWindow(dpy), selectPropertyContext,
>			    (char *) sarray);
>	_XtAddCallback( &pd->destroy_callbacks,
>			FreePropList, (XtPointer)sarray );
>    }
>    UNLOCK_PROCESS;
>    return sarray;
>}
>
>
>static Atom GetSelectionProperty(
>    Display *dpy)
>{
> SelectionProp p;
> int propCount;
> char propname[80];
> PropList sarray = GetPropList(dpy);
>
> for (p = sarray->list, propCount=sarray->propCount;
>	propCount;
>	p++, propCount--) {
>   if (p->avail) {
>      p->avail = FALSE;
>      return(p->prop);
>   }
> }
> propCount = sarray->propCount++;
> sarray->list = (SelectionProp) XtRealloc((XtPointer)sarray->list,
>  		(unsigned)(sarray->propCount*sizeof(SelectionPropRec)));
> (void) sprintf(propname, "%s%d", "_XT_SELECTION_", propCount);
> sarray->list[propCount].prop = XInternAtom(dpy, propname, FALSE);
> sarray->list[propCount].avail = FALSE;
> return(sarray->list[propCount].prop);
>}
>
>static void FreeSelectionProperty(
>    Display *dpy,
>    Atom prop)
>{
> SelectionProp p;
> PropList sarray;
> if (prop == None) return;
> LOCK_PROCESS;
> if (XFindContext(dpy, DefaultRootWindow(dpy), selectPropertyContext,
>		  (XPointer *)&sarray))
>    XtAppErrorMsg(XtDisplayToApplicationContext(dpy),
>	    "noSelectionProperties", "freeSelectionProperty", XtCXtToolkitError,
>		"internal error: no selection property context for display",
>		 (String *)NULL,  (Cardinal *)NULL );
> UNLOCK_PROCESS;
> for (p = sarray->list; p; p++)
>   if (p->prop == prop) {
>      p->avail = TRUE;
>      return;
>      }
>}
>
>static void FreeInfo(
>    CallBackInfo info)
>{
>    XtFree((char*)info->incremental);
>    XtFree((char*)info->callbacks);
>    XtFree((char*)info->req_closure);
>    XtFree((char*)info->target);
>    XtFree((char*)info);
>}
>
>static CallBackInfo MakeInfo(
>    Select ctx,
>    XtSelectionCallbackProc *callbacks,
>    XtPointer *closures,
>    int count,
>    Widget widget,
>    Time time,
>    Boolean *incremental,
>    Atom *properties)
>{
>    	CallBackInfo info = XtNew(CallBackInfoRec);
>
>	info->ctx = ctx;
>	info->callbacks = (XtSelectionCallbackProc *)
>	    __XtMalloc((unsigned) (count * sizeof(XtSelectionCallbackProc)));
>	(void) memmove((char*)info->callbacks, (char*)callbacks,
>		       count * sizeof(XtSelectionCallbackProc));
>	info->req_closure =
>	    (XtPointer*)__XtMalloc((unsigned) (count * sizeof(XtPointer)));
>	(void) memmove((char*)info->req_closure, (char*)closures,
>		       count * sizeof(XtPointer));
>	if (count == 1 && properties != NULL && properties[0] != None)
>	    info->property = properties[0];
>	else {
>	    info->property = GetSelectionProperty(XtDisplay(widget));
>	    XDeleteProperty(XtDisplay(widget), XtWindow(widget),
>			    info->property);
>	}
>	info->proc = HandleSelectionReplies;
>	info->widget = widget;
>	info->time = time;
>	info->incremental = (Boolean*) __XtMalloc(count * sizeof(Boolean));
>	(void) memmove((char*)info->incremental, (char*) incremental,
>		       count * sizeof(Boolean));
>	info->current = 0;
>	info->value = NULL;
>	return (info);
>}
>
>static void RequestSelectionValue(
>    CallBackInfo info,
>    Atom selection,
>    Atom target)
>{
>#ifndef DEBUG_WO_TIMERS
>    XtAppContext app = XtWidgetToApplicationContext(info->widget);
>	info->timeout = XtAppAddTimeOut(app,
>			 app->selectionTimeout, ReqTimedOut, (XtPointer)info);
>#endif
>	XtAddEventHandler(info->widget, (EventMask)0, TRUE,
>			  HandleSelectionReplies, (XtPointer)info);
>	XConvertSelection(info->ctx->dpy, selection, target,
>			  info->property, XtWindow(info->widget), info->time);
>}
>
>
>static XContext selectContext = 0;
>
>static Select NewContext(
>    Display *dpy,
>    Atom selection)
>{
>    /* assert(selectContext != 0) */
>    Select ctx = XtNew(SelectRec);
>    ctx->dpy = dpy;
>    ctx->selection = selection;
>    ctx->widget = NULL;
>    ctx->prop_list = GetPropList(dpy);
>    ctx->ref_count = 0;
>    ctx->free_when_done = FALSE;
>    ctx->was_disowned = FALSE;
>    LOCK_PROCESS;
>    (void)XSaveContext(dpy, (Window)selection, selectContext, (char *)ctx);
>    UNLOCK_PROCESS;
>    return ctx;
>}
>
>static Select FindCtx(
>    Display *dpy,
>    Atom selection)
>{
>    Select ctx;
>
>    LOCK_PROCESS;
>    if (selectContext == 0)
>	selectContext = XUniqueContext();
>    if (XFindContext(dpy, (Window)selection, selectContext, (XPointer *)&ctx))
>	ctx = NewContext(dpy, selection);
>    UNLOCK_PROCESS;
>    return ctx;
>}
>
>/*ARGSUSED*/
>static void WidgetDestroyed(
>    Widget widget,
>    XtPointer closure, XtPointer data)
>{
>    Select ctx = (Select) closure;
>    if (ctx->widget == widget) {
>	if (ctx->free_when_done)
>	    XtFree((char*)ctx);
>	else
>	    ctx->widget = NULL;
>    }
>}
>
>/* Selection Owner code */
>
>static void HandleSelectionEvents(Widget, XtPointer, XEvent *, Boolean *);
>
>static Boolean LoseSelection(
>    Select ctx,
>    Widget widget,
>    Atom selection,
>    Time time)
>{
>    if ((ctx->widget == widget) &&
>	(ctx->selection == selection) && /* paranoia */
>	!ctx->was_disowned &&
>	((time == CurrentTime) || (time >= ctx->time)))
>    {
>	XtRemoveEventHandler(widget, (EventMask)0, TRUE,
>			     HandleSelectionEvents, (XtPointer)ctx);
>	XtRemoveCallback(widget, XtNdestroyCallback,
>			 WidgetDestroyed, (XtPointer)ctx);
>	ctx->was_disowned = TRUE; /* widget officially loses ownership */
>	/* now inform widget */
>	if (ctx->loses) {
>	    if (ctx->incremental)
>	       (*(XtLoseSelectionIncrProc)ctx->loses)
>		   (widget, &ctx->selection, ctx->owner_closure);
>	    else  (*ctx->loses)(widget, &ctx->selection);
>	}
>	return(TRUE);
>    }
>    else return(FALSE);
>}
>
>static XContext selectWindowContext = 0;
>
>/* %%% Xlib.h should make this public! */
>typedef int (*xErrorHandler)(Display*, XErrorEvent*);
>
>static xErrorHandler oldErrorHandler = NULL;
>static unsigned long firstProtectRequest;
>static Window errorWindow;
>
>static int LocalErrorHandler (
>    Display *dpy,
>    XErrorEvent *error)
>{
>    int retval;
>
>    /* If BadWindow error on selection requestor, nothing to do but let
>     * the transfer timeout.  Otherwise, invoke saved error handler. */
>
>    LOCK_PROCESS;
>
>    if (error->error_code == BadWindow && error->resourceid == errorWindow &&
>	error->serial >= firstProtectRequest) {
>	UNLOCK_PROCESS;
>	return 0;
>    }
>
>    if (oldErrorHandler == NULL) {
>	UNLOCK_PROCESS;
>	return 0;  /* should never happen */
>    }
>
>    retval = (*oldErrorHandler)(dpy, error);
>    UNLOCK_PROCESS;
>    return retval;
>}
>
>static void StartProtectedSection(
>    Display *dpy,
>    Window window)
>{
>    /* protect ourselves against request window being destroyed
>     * before completion of transfer */
>
>    LOCK_PROCESS;
>    oldErrorHandler = XSetErrorHandler(LocalErrorHandler);
>    firstProtectRequest = NextRequest(dpy);
>    errorWindow = window;
>    UNLOCK_PROCESS;
>}
>
>static void EndProtectedSection(
>    Display *dpy)
>{
>    /* flush any generated errors on requestor and
>     * restore original error handler */
>
>    XSync(dpy, False);
>
>    LOCK_PROCESS;
>    XSetErrorHandler(oldErrorHandler);
>    oldErrorHandler = NULL;
>    UNLOCK_PROCESS;
>}
>
>static void AddHandler(
>    Request req,
>    EventMask mask,
>    XtEventHandler proc,
>    XtPointer closure)
>{
>    Display *dpy = req->ctx->dpy;
>    Window window = req->requestor;
>    Widget widget = XtWindowToWidget(dpy, window);
>
>    if (widget != NULL) req->widget = widget;
>    else widget = req->widget;
>
>    if (XtWindow(widget) == window)
>	XtAddEventHandler(widget, mask, False, proc, closure);
>    else {
>	RequestWindowRec *requestWindowRec;
>	LOCK_PROCESS;
>	if (selectWindowContext == 0)
>	    selectWindowContext = XUniqueContext();
>	if (XFindContext(dpy, window, selectWindowContext,
>			 (XPointer *)&requestWindowRec)) {
>	    requestWindowRec = XtNew(RequestWindowRec);
>	    requestWindowRec->active_transfer_count = 0;
>	    (void)XSaveContext(dpy, window, selectWindowContext,
>			       (char *)requestWindowRec);
>	}
>	UNLOCK_PROCESS;
>	if (requestWindowRec->active_transfer_count++ == 0) {
>	    XtRegisterDrawable(dpy, window, widget);
>	    XSelectInput(dpy, window, mask);
>	}
>	XtAddRawEventHandler(widget, mask, FALSE, proc, closure);
>    }
>}
>
>static void RemoveHandler(
>    Request req,
>    EventMask mask,
>    XtEventHandler proc,
>    XtPointer closure)
>{
>    Display *dpy = req->ctx->dpy;
>    Window window = req->requestor;
>    Widget widget = req->widget;
>
>    if ((XtWindowToWidget(dpy, window) == widget) &&
>        (XtWindow(widget) != window)) {
>	/* we had to hang this window onto our widget; take it off */
>	RequestWindowRec* requestWindowRec;
>	XtRemoveRawEventHandler(widget, mask, TRUE, proc, closure);
>	LOCK_PROCESS;
>	(void)XFindContext(dpy, window, selectWindowContext,
>			   (XPointer *)&requestWindowRec);
>	UNLOCK_PROCESS;
>	if (--requestWindowRec->active_transfer_count == 0) {
>	    XtUnregisterDrawable(dpy, window);
>	    StartProtectedSection(dpy, window);
>	    XSelectInput(dpy, window, 0L);
>	    EndProtectedSection(dpy);
>	    LOCK_PROCESS;
>	    (void)XDeleteContext(dpy, window, selectWindowContext);
>	    UNLOCK_PROCESS;
>	    XtFree((char*)requestWindowRec);
>	}
>    } else {
>        XtRemoveEventHandler(widget, mask, TRUE,  proc, closure);
>    }
>}
>
>/* ARGSUSED */
>static void OwnerTimedOut(
>    XtPointer closure,
>    XtIntervalId   *id)
>{
>    Request req = (Request)closure;
>    Select ctx = req->ctx;
>
>    if (ctx->incremental && (ctx->owner_cancel != NULL)) {
>	(*ctx->owner_cancel)(ctx->widget, &ctx->selection,
>			     &req->target, (XtRequestId*)&req,
>			     ctx->owner_closure);
>    } else {
>	if (ctx->notify == NULL)
>	    XtFree((char*)req->value);
>	else {
>	    /* the requestor hasn't deleted the property, but
>	     * the owner needs to free the value.
>	     */
>	    if (ctx->incremental)
>		(*(XtSelectionDoneIncrProc)ctx->notify)
>			      (ctx->widget, &ctx->selection, &req->target,
>			       (XtRequestId*)&req, ctx->owner_closure);
>	    else
>		(*ctx->notify)(ctx->widget, &ctx->selection, &req->target);
>	}
>    }
>
>    RemoveHandler(req, (EventMask)PropertyChangeMask,
>		  HandlePropertyGone, closure);
>    XtFree((char*)req);
>    if (--ctx->ref_count == 0 && ctx->free_when_done)
>	XtFree((char*)ctx);
>}
>
>static void SendIncrement(
>    Request incr)
>{
>    Display *dpy = incr->ctx->dpy;
>
>    unsigned long incrSize = MAX_SELECTION_INCR(dpy);
>    if (incrSize > incr->bytelength - incr->offset)
>        incrSize = incr->bytelength - incr->offset;
>    StartProtectedSection(dpy, incr->requestor);
>    XChangeProperty(dpy, incr->requestor, incr->property,
>    	    incr->type, incr->format, PropModeReplace,
>	    (unsigned char *)incr->value + incr->offset,
>	    NUMELEM((int)incrSize, incr->format));
>    EndProtectedSection(dpy);
>    incr->offset += incrSize;
>}
>
>static void AllSent(
>    Request req)
>{
>    Select ctx = req->ctx;
>    StartProtectedSection(ctx->dpy, req->requestor);
>    XChangeProperty(ctx->dpy, req->requestor,
>		    req->property, req->type,  req->format,
>		    PropModeReplace, (unsigned char *) NULL, 0);
>    EndProtectedSection(ctx->dpy);
>    req->allSent = TRUE;
>
>    if (ctx->notify == NULL) XtFree((char*)req->value);
>}
>
>/*ARGSUSED*/
>static void HandlePropertyGone(
>    Widget widget,
>    XtPointer closure,
>    XEvent *ev,
>    Boolean *cont)
>{
>    XPropertyEvent *event = (XPropertyEvent *) ev;
>    Request req = (Request)closure;
>    Select ctx = req->ctx;
>
>    if ((event->type != PropertyNotify) ||
>        (event->state != PropertyDelete) ||
>	(event->atom != req->property) ||
>	(event->window != req->requestor))
>      return;
>#ifndef DEBUG_WO_TIMERS
>    XtRemoveTimeOut(req->timeout);
>#endif
>    if (req->allSent) {
>	if (ctx->notify) {
>	    if (ctx->incremental) {
>		(*(XtSelectionDoneIncrProc)ctx->notify)
>			      (ctx->widget, &ctx->selection, &req->target,
>			       (XtRequestId*)&req, ctx->owner_closure);
>	    }
>	    else (*ctx->notify)(ctx->widget, &ctx->selection, &req->target);
>	}
>	RemoveHandler(req, (EventMask)PropertyChangeMask,
>		      HandlePropertyGone, closure);
>	XtFree((char*)req);
>	if (--ctx->ref_count == 0 && ctx->free_when_done)
>	    XtFree((char*)ctx);
>    } else  { /* is this part of an incremental transfer? */
>	if (ctx->incremental) {
>	     if (req->bytelength == 0)
>		AllSent(req);
>	     else {
>		unsigned long size = MAX_SELECTION_INCR(ctx->dpy);
>    		SendIncrement(req);
>		(*(XtConvertSelectionIncrProc)ctx->convert)
>			   (ctx->widget, &ctx->selection, &req->target,
>			    &req->type, &req->value,
>			    &req->bytelength, &req->format,
>			    &size, ctx->owner_closure, (XtPointer*)&req);
>		if (req->bytelength)
>		    req->bytelength = BYTELENGTH(req->bytelength, req->format);
>		req->offset = 0;
>	    }
>	} else {
>	    if (req->offset < req->bytelength)
>		SendIncrement(req);
>	    else AllSent(req);
>	}
>#ifndef DEBUG_WO_TIMERS
>	{
>	  XtAppContext app = XtWidgetToApplicationContext(req->widget);
>	  req->timeout = XtAppAddTimeOut(app,
>			 app->selectionTimeout, OwnerTimedOut, (XtPointer)req);
>	}
>#endif
>    }
>}
>
>static void PrepareIncremental(
>    Request req,
>    Widget widget,
>    Window window,
>    Atom property,
>    Atom target,
>    Atom targetType,
>    XtPointer value,
>    unsigned long length,
>    int format)
>{
>	req->type = targetType;
>	req->value = value;
>	req->bytelength = BYTELENGTH(length,format);
>	req->format = format;
>	req->offset = 0;
>	req->target = target;
>	req->widget = widget;
>	req->allSent = FALSE;
>#ifndef DEBUG_WO_TIMERS
>	{
>	XtAppContext app = XtWidgetToApplicationContext(widget);
>	req->timeout = XtAppAddTimeOut(app,
>			 app->selectionTimeout, OwnerTimedOut, (XtPointer)req);
>	}
>#endif
>	AddHandler(req, (EventMask)PropertyChangeMask,
>		   HandlePropertyGone, (XtPointer)req);
>/* now send client INCR property */
>	XChangeProperty(req->ctx->dpy, window, req->property,
>			req->ctx->prop_list->incr_atom,
>			32, PropModeReplace,
>			(unsigned char *)&req->bytelength, 1);
>}
>
>static Boolean GetConversion(
>    Select ctx,			/* logical owner */
>    XSelectionRequestEvent* event,
>    Atom target,
>    Atom property,		/* requestor's property */
>    Widget widget)		/* physical owner (receives events) */
>{
>    XtPointer value = NULL;
>    unsigned long length;
>    int format;
>    Atom targetType;
>    Request req = XtNew(RequestRec);
>    Boolean timestamp_target = (target == ctx->prop_list->timestamp_atom);
>
>    req->ctx = ctx;
>    req->event = *event;
>    req->property = property;
>    req->requestor = event->requestor;
>
>    if (timestamp_target) {
>	value = __XtMalloc(sizeof(long));
>	*(long*)value = ctx->time;
>	targetType = XA_INTEGER;
>	length = 1;
>	format = 32;
>    }
>    else {
>	ctx->ref_count++;
>	if (ctx->incremental == TRUE) {
>	     unsigned long size = MAX_SELECTION_INCR(ctx->dpy);
>	     if ((*(XtConvertSelectionIncrProc)ctx->convert)
>			       (ctx->widget, &event->selection, &target,
>				&targetType, &value, &length, &format,
>				&size, ctx->owner_closure, (XtRequestId*)&req)
>		     == FALSE) {
>		 XtFree((char*)req);
>		 ctx->ref_count--;
>		 return(FALSE);
>	     }
>	     StartProtectedSection(ctx->dpy, event->requestor);
>	     PrepareIncremental(req, widget, event->requestor, property,
>				target, targetType, value, length, format);
>	     return(TRUE);
>	}
>	ctx->req = req;
>	if ((*ctx->convert)(ctx->widget, &event->selection, &target,
>			    &targetType, &value, &length, &format) == FALSE) {
>	    XtFree((char*)req);
>	    ctx->req = NULL;
>	    ctx->ref_count--;
>	    return(FALSE);
>	}
>	ctx->req = NULL;
>    }
>    StartProtectedSection(ctx->dpy, event->requestor);
>    if (BYTELENGTH(length,format) <= (unsigned long) MAX_SELECTION_INCR(ctx->dpy)) {
>	if (! timestamp_target) {
>	    if (ctx->notify != NULL) {
>		  req->target = target;
>		  req->widget = widget;
>		  req->allSent = TRUE;
>#ifndef DEBUG_WO_TIMERS
>		  {
>		  XtAppContext app = XtWidgetToApplicationContext(req->widget);
>		  req->timeout = XtAppAddTimeOut(app,
>			 app->selectionTimeout, OwnerTimedOut, (XtPointer)req);
>		  }
>#endif
>	          AddHandler(req, (EventMask)PropertyChangeMask,
>			     HandlePropertyGone, (XtPointer)req);
>	      }
>	      else ctx->ref_count--;
>        }
>	XChangeProperty(ctx->dpy, event->requestor, property,
>			targetType, format, PropModeReplace,
>			(unsigned char *)value, (int)length);
>	/* free storage for client if no notify proc */
>	if (timestamp_target || ctx->notify == NULL) {
>	    XtFree((char*)value);
>	    XtFree((char*)req);
>	}
>    } else {
>	 PrepareIncremental(req, widget, event->requestor, property,
>			    target, targetType, value, length, format);
>    }
>    return(TRUE);
>}
>
>/*ARGSUSED*/
>static void HandleSelectionEvents(
>    Widget widget,
>    XtPointer closure,
>    XEvent *event,
>    Boolean *cont)
>{
>    Select ctx;
>    XSelectionEvent ev;
>    Atom target;
>    int count;
>    Boolean writeback = FALSE;
>
>    ctx = (Select) closure;
>    switch (event->type) {
>      case SelectionClear:
>	/* if this event is not for the selection we registered for,
>	 * don't do anything */
>	if (ctx->selection != event->xselectionclear.selection ||
>	    ctx->serial > event->xselectionclear.serial)
>	    break;
>	(void) LoseSelection(ctx, widget, event->xselectionclear.selection,
>			event->xselectionclear.time);
>	break;
>      case SelectionRequest:
>	/* if this event is not for the selection we registered for,
>	 * don't do anything */
>	if (ctx->selection != event->xselectionrequest.selection)
>	    break;
>	ev.type = SelectionNotify;
>	ev.display = event->xselectionrequest.display;
>	ev.requestor = event->xselectionrequest.requestor;
>	ev.selection = event->xselectionrequest.selection;
>	ev.time = event->xselectionrequest.time;
>	ev.target = event->xselectionrequest.target;
>	if (event->xselectionrequest.property == None) /* obsolete requestor */
>	   event->xselectionrequest.property = event->xselectionrequest.target;
>	if (ctx->widget != widget || ctx->was_disowned
>	   || ((event->xselectionrequest.time != CurrentTime)
>	        && (event->xselectionrequest.time < ctx->time))) {
>	    ev.property = None;
>	    StartProtectedSection(ev.display, ev.requestor);
>	} else {
>	   if (ev.target == ctx->prop_list->indirect_atom) {
>	      IndirectPair *p;
>	      int format;
>	      unsigned long bytesafter, length;
>	      unsigned char *value;
>	      ev.property = event->xselectionrequest.property;
>	      StartProtectedSection(ev.display, ev.requestor);
>	      (void) XGetWindowProperty(ev.display, ev.requestor,
>			event->xselectionrequest.property, 0L, 1000000,
>			False,(Atom)AnyPropertyType, &target, &format, &length,
>			&bytesafter, &value);
>	      count = BYTELENGTH(length, format) / sizeof(IndirectPair);
>	      for (p = (IndirectPair *)value; count; p++, count--) {
>		  EndProtectedSection(ctx->dpy);
>		  if (!GetConversion(ctx, (XSelectionRequestEvent*)event,
>				     p->target, p->property, widget)) {
>
>			p->target = None;
>			writeback = TRUE;
>			StartProtectedSection(ctx->dpy, ev.requestor);
>		  }
>	      }
>	      if (writeback)
>		XChangeProperty(ev.display, ev.requestor,
>			event->xselectionrequest.property, target,
>			format, PropModeReplace, value, (int)length);
>	      XFree((char *)value);
>	  } else /* not multiple */ {
>	       if (GetConversion(ctx, (XSelectionRequestEvent*)event,
>				 event->xselectionrequest.target,
>				 event->xselectionrequest.property,
>				 widget))
>		   ev.property = event->xselectionrequest.property;
>	       else {
>		   ev.property = None;
>		   StartProtectedSection(ctx->dpy, ev.requestor);
>	       }
>	   }
>      }
>      (void) XSendEvent(ctx->dpy, ev.requestor, False, (unsigned long)NULL,
>		   (XEvent *) &ev);
>
>      EndProtectedSection(ctx->dpy);
>
>      break;
>    }
>}
>
>static Boolean OwnSelection(
>    Widget widget,
>    Atom selection,
>    Time time,
>    XtConvertSelectionProc convert,
>    XtLoseSelectionProc lose,
>    XtSelectionDoneProc notify,
>    XtCancelConvertSelectionProc cancel,
>    XtPointer closure,
>    Boolean incremental)
>{
>    Select ctx;
>    Select oldctx = NULL;
>
>    if (!XtIsRealized(widget)) return False;
>
>    ctx = FindCtx(XtDisplay(widget), selection);
>    if (ctx->widget != widget || ctx->time != time ||
>	ctx->ref_count || ctx->was_disowned)
>    {
>	Boolean replacement = FALSE;
>	Window window = XtWindow(widget);
>	unsigned long serial = XNextRequest(ctx->dpy);
>        XSetSelectionOwner(ctx->dpy, selection, window, time);
>        if (XGetSelectionOwner(ctx->dpy, selection) != window)
>	    return FALSE;
>	if (ctx->ref_count) {	/* exchange is in-progress */
>#ifdef DEBUG_ACTIVE
>	    printf( "Active exchange for widget \"%s\"; selection=0x%lx, ref_count=%d\n",
>		    XtName(widget), (long)selection, ctx->ref_count );
>#endif
>	    if (ctx->widget != widget ||
>		ctx->convert != convert ||
>		ctx->loses != lose ||
>		ctx->notify != notify ||
>		ctx->owner_cancel != cancel ||
>		ctx->incremental != incremental ||
>		ctx->owner_closure != closure)
>	    {
>		if (ctx->widget == widget) {
>		    XtRemoveEventHandler(widget, (EventMask)0, TRUE,
>					HandleSelectionEvents, (XtPointer)ctx);
>		    XtRemoveCallback(widget, XtNdestroyCallback,
>				     WidgetDestroyed, (XtPointer)ctx);
>		    replacement = TRUE;
>		}
>		else if (!ctx->was_disowned) {
>		    oldctx = ctx;
>		}
>		ctx->free_when_done = TRUE;
>		ctx = NewContext(XtDisplay(widget), selection);
>	    }
>	    else if (!ctx->was_disowned) { /* current owner is new owner */
>		ctx->time = time;
>		return TRUE;
>	    }
>	}
>    	if (ctx->widget != widget || ctx->was_disowned || replacement) {
>	    if (ctx->widget && !ctx->was_disowned && !replacement) {
>		oldctx = ctx;
>		oldctx->free_when_done = TRUE;
>		ctx = NewContext(XtDisplay(widget), selection);
>	    }
>	    XtAddEventHandler(widget, (EventMask)0, TRUE,
>			      HandleSelectionEvents, (XtPointer)ctx);
>	    XtAddCallback(widget, XtNdestroyCallback,
>			  WidgetDestroyed, (XtPointer)ctx);
>	}
>	ctx->widget = widget;	/* Selection offically changes hands. */
>	ctx->time = time;
>	ctx->serial = serial;
>    }
>    ctx->convert = convert;
>    ctx->loses = lose;
>    ctx->notify = notify;
>    ctx->owner_cancel = cancel;
>    ctx->incremental = incremental;
>    ctx->owner_closure = closure;
>    ctx->was_disowned = FALSE;
>
>    /* Defer calling the previous selection owner's lose selection procedure
>     * until the new selection is established, to allow the previous
>     * selection owner to ask for the new selection to be converted in
>     * the lose selection procedure.  The context pointer is the closure
>     * of the event handler and the destroy callback, so the old context
>     * pointer and the record contents must be preserved for LoseSelection.
>     */
>    if (oldctx) {
>	(void) LoseSelection(oldctx, oldctx->widget, selection, oldctx->time);
>	if (!oldctx->ref_count && oldctx->free_when_done)
>	    XtFree((char*)oldctx);
>    }
>    return TRUE;
>}
>
>
>Boolean XtOwnSelection(
>    Widget widget,
>    Atom selection,
>    Time time,
>    XtConvertSelectionProc convert,
>    XtLoseSelectionProc lose,
>    XtSelectionDoneProc notify)
>{
>    Boolean retval;
>    WIDGET_TO_APPCON(widget);
>
>    LOCK_APP(app);
>    retval = OwnSelection(widget, selection, time, convert, lose, notify,
>			(XtCancelConvertSelectionProc)NULL,
>			(XtPointer)NULL, FALSE);
>    UNLOCK_APP(app);
>    return retval;
>}
>
>
>Boolean XtOwnSelectionIncremental(
>    Widget widget,
>    Atom selection,
>    Time time,
>    XtConvertSelectionIncrProc convert,
>    XtLoseSelectionIncrProc lose,
>    XtSelectionDoneIncrProc notify,
>    XtCancelConvertSelectionProc cancel,
>    XtPointer closure)
>{
>    Boolean retval;
>    WIDGET_TO_APPCON(widget);
>
>    LOCK_APP(app);
>    retval = OwnSelection(widget, selection, time,
>			(XtConvertSelectionProc)convert,
>			(XtLoseSelectionProc)lose,
>			(XtSelectionDoneProc)notify,
>			cancel, closure, TRUE);
>    UNLOCK_APP(app);
>    return retval;
>}
>
>
>void XtDisownSelection(widget, selection, time)
>    Widget widget;
>    Atom selection;
>    Time time;
>{
>    Select ctx;
>    WIDGET_TO_APPCON(widget);
>
>    LOCK_APP(app);
>    ctx = FindCtx(XtDisplay(widget), selection);
>    if (LoseSelection(ctx, widget, selection, time))
>	XSetSelectionOwner(XtDisplay(widget), selection, None, time);
>    UNLOCK_APP(app);
>}
>
>/* Selection Requestor code */
>
>static Boolean IsINCRtype(
>    CallBackInfo info,
>    Window window,
>    Atom prop)
>{
>    unsigned long bytesafter;
>    unsigned long length;
>    int format;
>    Atom type;
>    unsigned char *value;
>
>    if (prop == None) return False;
>
>    (void)XGetWindowProperty(XtDisplay(info->widget), window, prop, 0L, 0L,
>			     False, info->ctx->prop_list->incr_atom,
>			     &type, &format, &length, &bytesafter, &value);
>
>    return (type == info->ctx->prop_list->incr_atom);
>}
>
>/*ARGSUSED*/
>static void ReqCleanup(
>    Widget widget,
>    XtPointer closure,
>    XEvent *ev,
>    Boolean *cont)
>{
>    CallBackInfo info = (CallBackInfo)closure;
>    unsigned long bytesafter, length;
>    char *value;
>    int format;
>    Atom target;
>
>    if (ev->type == SelectionNotify) {
>	XSelectionEvent *event = (XSelectionEvent *) ev;
>	if (!MATCH_SELECT(event, info)) return; /* not really for us */
>         XtRemoveEventHandler(widget, (EventMask)0, TRUE,
>			   ReqCleanup, (XtPointer) info );
>	if (IsINCRtype(info, XtWindow(widget), event->property)) {
>	    info->proc = HandleGetIncrement;
>	    XtAddEventHandler(info->widget, (EventMask) PropertyChangeMask,
>			      FALSE, ReqCleanup, (XtPointer) info);
>	} else {
>	   if (event->property != None)
>		XDeleteProperty(event->display, XtWindow(widget),
>				event->property);
>           FreeSelectionProperty(XtDisplay(widget), info->property);
>	   FreeInfo(info);
>	}
>    } else if ((ev->type == PropertyNotify) &&
>		(ev->xproperty.state == PropertyNewValue) &&
>	        (ev->xproperty.atom == info->property)) {
>	XPropertyEvent *event = (XPropertyEvent *) ev;
>        (void) XGetWindowProperty(event->display, XtWindow(widget),
>			   event->atom, 0L, 1000000, True, AnyPropertyType,
>			   &target, &format, &length, &bytesafter,
>			   (unsigned char **) &value);
>	XFree(value);
>	if (length == 0) {
>           XtRemoveEventHandler(widget, (EventMask) PropertyChangeMask, FALSE,
>			   ReqCleanup, (XtPointer) info );
>           FreeSelectionProperty(XtDisplay(widget), info->property);
>	   XtFree(info->value);	/* requestor never got this, so free now */
>	   FreeInfo(info);
>	}
>    }
>}
>
>/* ARGSUSED */
>static void ReqTimedOut(
>    XtPointer closure,
>    XtIntervalId   *id)
>{
>    XtPointer value = NULL;
>    unsigned long length = 0;
>    int format = 8;
>    Atom resulttype = XT_CONVERT_FAIL;
>    CallBackInfo info = (CallBackInfo)closure;
>    unsigned long bytesafter;
>    unsigned long proplength;
>    Atom type;
>    IndirectPair *pairs;
>    XtPointer *c;
>    int i;
>
>    if (*info->target == info->ctx->prop_list->indirect_atom) {
>        (void) XGetWindowProperty(XtDisplay(info->widget),
>			   XtWindow(info->widget), info->property, 0L,
>			   10000000, True, AnyPropertyType, &type, &format,
>			   &proplength, &bytesafter, (unsigned char **) &pairs);
>       XFree((char*)pairs);
>       for (proplength = proplength / IndirectPairWordSize, i = 0, c = info->req_closure;
>	           proplength; proplength--, c++, i++)
>	    (*info->callbacks[i])(info->widget, *c,
>   	          &info->ctx->selection, &resulttype, value, &length, &format);
>    } else {
>	(*info->callbacks[0])(info->widget, *info->req_closure,
>	    &info->ctx->selection, &resulttype, value, &length, &format);
>    }
>
>    /* change event handlers for straggler events */
>    if (info->proc == (XtEventHandler)HandleSelectionReplies) {
>        XtRemoveEventHandler(info->widget, (EventMask)0,
>			TRUE, info->proc, (XtPointer) info);
>	XtAddEventHandler(info->widget, (EventMask)0, TRUE,
>		ReqCleanup, (XtPointer) info);
>    } else {
>        XtRemoveEventHandler(info->widget,(EventMask) PropertyChangeMask,
>			FALSE, info->proc, (XtPointer) info);
>	XtAddEventHandler(info->widget, (EventMask) PropertyChangeMask,
>		FALSE, ReqCleanup, (XtPointer) info);
>    }
>
>}
>
>/*ARGSUSED*/
>static void HandleGetIncrement(
>    Widget widget,
>    XtPointer closure,
>    XEvent *ev,
>    Boolean *cont)
>{
>    XPropertyEvent *event = (XPropertyEvent *) ev;
>    CallBackInfo info = (CallBackInfo) closure;
>    Select ctx = info->ctx;
>    char *value;
>    unsigned long bytesafter;
>    unsigned long length;
>    int bad;
>    int n = info->current;
>
>    if ((event->state != PropertyNewValue) || (event->atom != info->property))
>	 return;
>
>    bad = XGetWindowProperty(event->display, XtWindow(widget),
>			     event->atom, 0L,
>			     10000000, True, AnyPropertyType, &info->type,
>			     &info->format, &length, &bytesafter,
>			     (unsigned char **) &value);
>    if (bad)
>      return;
>#ifndef DEBUG_WO_TIMERS
>    XtRemoveTimeOut(info->timeout);
>#endif
>    if (length == 0) {
>       unsigned long u_offset = NUMELEM(info->offset, info->format);
>       (*info->callbacks[n])(widget, *info->req_closure, &ctx->selection,
>			     &info->type,
>			     (info->offset == 0 ? value : info->value),
>			     &u_offset, &info->format);
>       /* assert ((info->offset != 0) == (info->incremental[n]) */
>       if (info->offset != 0) XFree(value);
>       XtRemoveEventHandler(widget, (EventMask) PropertyChangeMask, FALSE,
>		HandleGetIncrement, (XtPointer) info);
>       FreeSelectionProperty(event->display, info->property);
>       FreeInfo(info);
>    } else { /* add increment to collection */
>      if (info->incremental[n]) {
>#ifdef XT_COPY_SELECTION
>	  int size = BYTELENGTH(length, info->format) + 1;
>	  char *tmp = __XtMalloc((Cardinal) size);
>	  (void) memmove(tmp, value, size);
>	  XFree(value);
>	  value = tmp;
>#endif
>        (*info->callbacks[n])(widget, *info->req_closure, &ctx->selection,
>			      &info->type, value, &length, &info->format);
>      } else {
>	  int size = BYTELENGTH(length, info->format);
>	  if (info->offset + size > info->bytelength) {
>	      /* allocate enough for this and the next increment */
>	      info->bytelength = info->offset + size * 2;
>	      info->value = XtRealloc(info->value,
>				      (Cardinal) info->bytelength);
>	  }
>	  (void) memmove(&info->value[info->offset], value, size);
>	  info->offset += size;
>	  XFree(value);
>      }
>     /* reset timer */
>#ifndef DEBUG_WO_TIMERS
>     {
>     XtAppContext app = XtWidgetToApplicationContext(info->widget);
>     info->timeout = XtAppAddTimeOut(app,
>			 app->selectionTimeout, ReqTimedOut, (XtPointer) info);
>     }
>#endif
>   }
>}
>
>
>static void HandleNone(
>    Widget widget,
>    XtSelectionCallbackProc callback,
>    XtPointer closure,
>    Atom selection)
>{
>    unsigned long length = 0;
>    int format = 8;
>    Atom type = None;
>
>    (*callback)(widget, closure, &selection,
>		&type, NULL, &length, &format);
>}
>
>
>static long IncrPropSize(
>     Widget widget,
>     unsigned char* value,
>     int format,
>     unsigned long length)
>{
>    unsigned long size;
>    if (format == 32) {
>	size = ((long*)value)[length-1]; /* %%% what order for longs? */
>	return size;
>    }
>    else {
>	XtAppWarningMsg( XtWidgetToApplicationContext(widget),
>			"badFormat","xtGetSelectionValue",XtCXtToolkitError,
>	"Selection owner returned type INCR property with format != 32",
>			(String*)NULL, (Cardinal*)NULL );
>	return 0;
>    }
>}
>
>
>static
>Boolean HandleNormal(
>    Display *dpy,
>    Widget widget,
>    Atom property,
>    CallBackInfo info,
>    XtPointer closure,
>    Atom selection)
>{
>    unsigned long bytesafter;
>    unsigned long length;
>    int format;
>    Atom type;
>    unsigned char *value;
>    int number = info->current;
>
>    (void) XGetWindowProperty(dpy, XtWindow(widget), property, 0L,
>			      10000000, False, AnyPropertyType,
>			      &type, &format, &length, &bytesafter, &value);
>
>    if (type == info->ctx->prop_list->incr_atom) {
>	unsigned long size = IncrPropSize(widget, value, format, length);
>	XFree((char *)value);
>	if (info->property != property) {
>	    /* within MULTIPLE */
>	    CallBackInfo ninfo;
>	    ninfo = MakeInfo(info->ctx, &info->callbacks[number],
>			     &info->req_closure[number], 1, widget,
>			     info->time, &info->incremental[number], &property);
>	    ninfo->target = (Atom *) __XtMalloc((unsigned) sizeof(Atom));
>	    *ninfo->target = info->target[number + 1];
>	    info = ninfo;
>	}
>	HandleIncremental(dpy, widget, property, info, size);
>	return FALSE;
>    }
>
>    XDeleteProperty(dpy, XtWindow(widget), property);
>#ifdef XT_COPY_SELECTION
>    if (value) {   /* it could have been deleted after the SelectionNotify */
>	int size = BYTELENGTH(length, info->format) + 1;
>	char *tmp = __XtMalloc((Cardinal) size);
>	(void) memmove(tmp, value, size);
>	XFree(value);
>	value = (unsigned char *) tmp;
>    }
>#endif
>    (*info->callbacks[number])(widget, closure, &selection,
>			       &type, (XtPointer)value, &length, &format);
>
>    if (info->incremental[number]) {
>	/* let requestor know the whole thing has been received */
>	value = (unsigned char*)__XtMalloc((unsigned)1);
>	length = 0;
>	(*info->callbacks[number])(widget, closure, &selection,
>				   &type, (XtPointer)value, &length, &format);
>    }
>    return TRUE;
>}
>
>static void HandleIncremental(
>    Display *dpy,
>    Widget widget,
>    Atom property,
>    CallBackInfo info,
>    unsigned long size)
>{
>    XtAddEventHandler(widget, (EventMask) PropertyChangeMask, FALSE,
>		      HandleGetIncrement, (XtPointer) info);
>
>    /* now start the transfer */
>    XDeleteProperty(dpy, XtWindow(widget), property);
>    XFlush(dpy);
>
>    info->bytelength = size;
>    if (info->incremental[info->current]) /* requestor wants incremental too */
>	info->value = NULL;	/* so no need for buffer to assemble value */
>    else
>	info->value = (char *) __XtMalloc((unsigned) info->bytelength);
>    info->offset = 0;
>
>    /* reset the timer */
>    info->proc = HandleGetIncrement;
>#ifndef DEBUG_WO_TIMERS
>    {
>    XtAppContext app = XtWidgetToApplicationContext(info->widget);
>    info->timeout = XtAppAddTimeOut(app,
>			 app->selectionTimeout, ReqTimedOut, (XtPointer) info);
>    }
>#endif
>}
>
>/*ARGSUSED*/
>static void HandleSelectionReplies(
>    Widget widget,
>    XtPointer closure,
>    XEvent *ev,
>    Boolean *cont)
>{
>    XSelectionEvent *event = (XSelectionEvent *) ev;
>    Display *dpy = event->display;
>    CallBackInfo info = (CallBackInfo) closure;
>    Select ctx = info->ctx;
>    IndirectPair *pairs, *p;
>    unsigned long bytesafter;
>    unsigned long length;
>    int format;
>    Atom type;
>    XtPointer *c;
>
>    if (event->type != SelectionNotify) return;
>    if (!MATCH_SELECT(event, info)) return; /* not really for us */
>#ifndef DEBUG_WO_TIMERS
>    XtRemoveTimeOut(info->timeout);
>#endif
>    XtRemoveEventHandler(widget, (EventMask)0, TRUE,
>		HandleSelectionReplies, (XtPointer) info );
>    if (event->target == ctx->prop_list->indirect_atom) {
>        (void) XGetWindowProperty(dpy, XtWindow(widget), info->property, 0L,
>			   10000000, True, AnyPropertyType, &type, &format,
>			   &length, &bytesafter, (unsigned char **) &pairs);
>       for (length = length / IndirectPairWordSize, p = pairs,
>	    c = info->req_closure;
>	    length; length--, p++, c++, info->current++) {
>	    if (event->property == None || format != 32 || p->target == None
>		|| /* bug compatibility */ p->property == None) {
>		HandleNone(widget, info->callbacks[info->current],
>			   *c, event->selection);
>		if (p->property != None)
>                    FreeSelectionProperty(XtDisplay(widget), p->property);
>	    } else {
>		if (HandleNormal(dpy, widget, p->property, info, *c,
>				 event->selection)) {
>		    FreeSelectionProperty(XtDisplay(widget), p->property);
>		}
>	    }
>       }
>       XFree((char*)pairs);
>       FreeSelectionProperty(dpy, info->property);
>       FreeInfo(info);
>    } else if (event->property == None) {
>	HandleNone(widget, info->callbacks[0], *info->req_closure, event->selection);
>        FreeSelectionProperty(XtDisplay(widget), info->property);
>	FreeInfo(info);
>    } else {
>	if (HandleNormal(dpy, widget, event->property, info,
>			 *info->req_closure, event->selection)) {
>	    FreeSelectionProperty(XtDisplay(widget), info->property);
>	    FreeInfo(info);
>	}
>    }
>}
>
>static void DoLocalTransfer(
>    Request req,
>    Atom selection,
>    Atom target,
>    Widget widget,		/* The widget requesting the value. */
>    XtSelectionCallbackProc callback,
>    XtPointer closure,	/* the closure for the callback, not the conversion */
>    Boolean incremental,
>    Atom property)
>{
>    Select ctx = req->ctx;
>    XtPointer value = NULL, temp, total = NULL;
>    unsigned long length;
>    int format;
>    Atom resulttype;
>    unsigned long totallength = 0;
>
>        req->event.type = 0;
>        req->event.target = target;
>        req->event.property = req->property = property;
>        req->event.requestor = req->requestor = XtWindow(widget);
>
>	if (ctx->incremental) {
>	   unsigned long size = MAX_SELECTION_INCR(ctx->dpy);
>	   if (!(*(XtConvertSelectionIncrProc)ctx->convert)
>			   (ctx->widget, &selection, &target,
>			    &resulttype, &value, &length, &format,
>			    &size, ctx->owner_closure, (XtRequestId*)&req)) {
>	       HandleNone(widget, callback, closure, selection);
>	   }
>	   else {
>		if (incremental) {
>		  Boolean allSent = FALSE;
>	          while (!allSent) {
>	    	      if (ctx->notify && (value != NULL)) {
>              	        int bytelength = BYTELENGTH(length,format);
>	                /* both sides think they own this storage */
>	                temp = __XtMalloc((unsigned)bytelength);
>	                (void) memmove(temp, value, bytelength);
>	                value = temp;
>	              }
>		      /* use care; older clients were never warned that
>		       * they must return a value even if length==0
>		       */
>		     if (value == NULL) value = __XtMalloc((unsigned)1);
>		     (*callback)(widget, closure, &selection,
>			&resulttype, value, &length, &format);
>		     if (length) {
>			 /* should owner be notified on end-of-piece?
>			  * Spec is unclear, but non-local transfers don't.
>			  */
>			 (*(XtConvertSelectionIncrProc)ctx->convert)
>					(ctx->widget, &selection, &target,
>					 &resulttype, &value, &length, &format,
>					 &size, ctx->owner_closure,
>					 (XtRequestId*)&req);
>		     }
>		     else allSent = TRUE;
>		  }
>	        } else {
>	          while (length) {
>		    int bytelength = BYTELENGTH(length, format);
>		    total = XtRealloc(total,
>			    (unsigned) (totallength += bytelength));
>		    (void) memmove((char*)total + totallength - bytelength,
>			    value,
>			    bytelength);
>		    (*(XtConvertSelectionIncrProc)ctx->convert)
>			   (ctx->widget, &selection, &target,
>			    &resulttype, &value, &length, &format,
>			    &size, ctx->owner_closure, (XtRequestId*)&req);
>		  }
>		  if (total == NULL) total = __XtMalloc(1);
>		  totallength = NUMELEM(totallength, format);
>		  (*callback)(widget, closure, &selection, &resulttype,
>		    total,  &totallength, &format);
>	      }
>	      if (ctx->notify)
>		  (*(XtSelectionDoneIncrProc)ctx->notify)
>				(ctx->widget, &selection, &target,
>				 (XtRequestId*)&req, ctx->owner_closure);
>	      else XtFree((char*)value);
>	  }
>	} else { /* not incremental owner */
>	  if (!(*ctx->convert)(ctx->widget, &selection, &target,
>			     &resulttype, &value, &length, &format)) {
>	    HandleNone(widget, callback, closure, selection);
>	  } else {
>	      if (ctx->notify && (value != NULL)) {
>                int bytelength = BYTELENGTH(length,format);
>	        /* both sides think they own this storage; better copy */
>	        temp = __XtMalloc((unsigned)bytelength);
>	        (void) memmove(temp, value, bytelength);
>	        value = temp;
>	      }
>	      if (value == NULL) value = __XtMalloc((unsigned)1);
>	      (*callback)(widget, closure, &selection, &resulttype,
>			  value, &length, &format);
>	      if (ctx->notify)
>	         (*ctx->notify)(ctx->widget, &selection, &target);
>	  }
>      }
>}
>
>static void GetSelectionValue(
>    Widget widget,
>    Atom selection,
>    Atom target,
>    XtSelectionCallbackProc callback,
>    XtPointer closure,
>    Time time,
>    Boolean incremental,
>    Atom property)
>{
>    Select ctx;
>    CallBackInfo info;
>    Atom properties[1];
>
>    properties[0] = property;
>
>    ctx = FindCtx(XtDisplay(widget), selection);
>    if (ctx->widget && !ctx->was_disowned) {
>	RequestRec req;
>	ctx->req = &req;
>	req.ctx = ctx;
>	req.event.time = time;
>	ctx->ref_count++;
>	DoLocalTransfer(&req, selection, target, widget,
>			callback, closure, incremental, property);
>	if (--ctx->ref_count == 0 && ctx->free_when_done)
>	    XtFree((char*)ctx);
>	else
>	    ctx->req = NULL;
>    }
>    else {
>	info = MakeInfo(ctx, &callback, &closure, 1, widget,
>			time, &incremental, properties);
>	info->target = (Atom *)__XtMalloc((unsigned) sizeof(Atom));
>	 *(info->target) = target;
>	RequestSelectionValue(info, selection, target);
>    }
>}
>
>
>void XtGetSelectionValue(
>    Widget widget,
>    Atom selection,
>    Atom target,
>    XtSelectionCallbackProc callback,
>    XtPointer closure,
>    Time time)
>{
>    Atom property;
>    Boolean incr = False;
>    WIDGET_TO_APPCON(widget);
>
>    LOCK_APP(app);
>    property = GetParamInfo(widget, selection);
>    RemoveParamInfo(widget, selection);
>
>    if (IsGatheringRequest(widget, selection)) {
>      AddSelectionRequests(widget, selection, 1, &target, &callback, 1,
>			   &closure, &incr, &property);
>    } else {
>      GetSelectionValue(widget, selection, target, callback,
>			closure, time, FALSE, property);
>    }
>    UNLOCK_APP(app);
>}
>
>
>void XtGetSelectionValueIncremental(
>    Widget widget,
>    Atom selection,
>    Atom target,
>    XtSelectionCallbackProc callback,
>    XtPointer closure,
>    Time time)
>{
>    Atom property;
>    Boolean incr = TRUE;
>    WIDGET_TO_APPCON(widget);
>
>    LOCK_APP(app);
>    property = GetParamInfo(widget, selection);
>    RemoveParamInfo(widget, selection);
>
>    if (IsGatheringRequest(widget, selection)) {
>      AddSelectionRequests(widget, selection, 1, &target, &callback, 1,
>			   &closure, &incr, &property);
>    } else {
>      GetSelectionValue(widget, selection, target, callback,
>			closure, time, TRUE, property);
>    }
>
>    UNLOCK_APP(app);
>}
>
>
>static void GetSelectionValues(
>    Widget widget,
>    Atom selection,
>    Atom *targets,
>    int count,
>    XtSelectionCallbackProc *callbacks,
>    int num_callbacks,
>    XtPointer *closures,
>    Time time,
>    Boolean *incremental,
>    Atom *properties)
>{
>    Select ctx;
>    CallBackInfo info;
>    IndirectPair *pairs, *p;
>    Atom *t;
>
>    if (count == 0) return;
>    ctx = FindCtx(XtDisplay(widget), selection);
>    if (ctx->widget && !ctx->was_disowned) {
>        int j, i;
>	RequestRec req;
>	ctx->req = &req;
>	req.ctx = ctx;
>	req.event.time = time;
>	ctx->ref_count++;
>	for (i = 0, j = 0; count; count--, i++, j++ ) {
>	  if (j >= num_callbacks) j = 0;
>
>	  DoLocalTransfer(&req, selection, targets[i], widget,
>			  callbacks[j], closures[i], incremental[i],
>			  properties ? properties[i] : None);
>
>	}
>	if (--ctx->ref_count == 0 && ctx->free_when_done)
>	    XtFree((char*)ctx);
>	else
>	    ctx->req = NULL;
>    } else {
>        XtSelectionCallbackProc *passed_callbacks;
>	XtSelectionCallbackProc stack_cbs[32];
>        int i = 0, j = 0;
>
>	passed_callbacks = (XtSelectionCallbackProc *)
>	  XtStackAlloc(sizeof(XtSelectionCallbackProc) * count, stack_cbs);
>
>	/* To deal with the old calls from XtGetSelectionValues* we
>	   will repeat however many callbacks have been passed into
>	   the array */
>	for(i = 0; i < count; i++) {
>	  if (j >= num_callbacks) j = 0;
>	  passed_callbacks[i] = callbacks[j];
>	  j++;
>	}
>	info = MakeInfo(ctx, passed_callbacks, closures, count, widget,
>			time, incremental, properties);
>	XtStackFree((XtPointer) passed_callbacks, stack_cbs);
>
>	info->target = (Atom *)__XtMalloc((unsigned) ((count+1) * sizeof(Atom)));
>        (*info->target) = ctx->prop_list->indirect_atom;
>	(void) memmove((char *) info->target+sizeof(Atom), (char *) targets,
>		       count * sizeof(Atom));
>	pairs = (IndirectPair*)__XtMalloc((unsigned)(count*sizeof(IndirectPair)));
>	for (p = &pairs[count-1], t = &targets[count-1], i = count - 1;
>	     p >= pairs;  p--, t--, i--) {
>	   p->target = *t;
>	   if (properties == NULL || properties[i] == None) {
>	     p->property = GetSelectionProperty(XtDisplay(widget));
>	     XDeleteProperty(XtDisplay(widget), XtWindow(widget),
>			     p->property);
>	   } else {
>	     p->property = properties[i];
>	   }
>	}
>	XChangeProperty(XtDisplay(widget), XtWindow(widget),
>			info->property, info->property,
>			32, PropModeReplace, (unsigned char *) pairs,
>			count * IndirectPairWordSize);
>	XtFree((char*)pairs);
>	RequestSelectionValue(info, selection, ctx->prop_list->indirect_atom);
>    }
>}
>
>
>void XtGetSelectionValues(
>    Widget widget,
>    Atom selection,
>    Atom *targets,
>    int count,
>    XtSelectionCallbackProc callback,
>    XtPointer *closures,
>    Time time)
>{
>    Boolean incremental_values[32];
>    Boolean *incremental;
>    int i;
>    WIDGET_TO_APPCON(widget);
>
>    LOCK_APP(app);
>    incremental = XtStackAlloc(count * sizeof(Boolean), incremental_values);
>    for(i = 0; i < count; i++) incremental[i] = FALSE;
>    if (IsGatheringRequest(widget, selection)) {
>      AddSelectionRequests(widget, selection, count, targets, &callback,
>			   1, closures, incremental, NULL);
>    } else {
>      GetSelectionValues(widget, selection, targets, count, &callback, 1,
>			 closures, time, incremental, NULL);
>    }
>    XtStackFree((XtPointer) incremental, incremental_values);
>    UNLOCK_APP(app);
>}
>
>
>void XtGetSelectionValuesIncremental(
>    Widget widget,
>    Atom selection,
>    Atom *targets,
>    int count,
>    XtSelectionCallbackProc callback,
>    XtPointer *closures,
>    Time time)
>{
>    Boolean incremental_values[32];
>    Boolean *incremental;
>    int i;
>    WIDGET_TO_APPCON(widget);
>
>    LOCK_APP(app);
>    incremental = XtStackAlloc(count * sizeof(Boolean), incremental_values);
>    for(i = 0; i < count; i++) incremental[i] = TRUE;
>    if (IsGatheringRequest(widget, selection)) {
>      AddSelectionRequests(widget, selection, count, targets, &callback,
>			   1, closures, incremental, NULL);
>    } else {
>      GetSelectionValues(widget, selection, targets, count,
>			 &callback, 1, closures, time, incremental, NULL);
>    }
>    XtStackFree((XtPointer) incremental, incremental_values);
>    UNLOCK_APP(app);
>}
>
>
>static Request GetRequestRecord(
>    Widget widget,
>    Atom selection,
>    XtRequestId id)
>{
>    Request req = (Request)id;
>    Select ctx = NULL;
>
>    if (   (req == NULL
>	    && ((ctx = FindCtx( XtDisplay(widget), selection )) == NULL
>		|| ctx->req == NULL
>		|| ctx->selection != selection
>		|| ctx->widget == NULL))
>	|| (req != NULL
>	    && (req->ctx == NULL
>		|| req->ctx->selection != selection
>		|| req->ctx->widget != widget)))
>    {
>	String params = XtName(widget);
>	Cardinal num_params = 1;
>	XtAppWarningMsg(XtWidgetToApplicationContext(widget),
>			 "notInConvertSelection", "xtGetSelectionRequest",
>			 XtCXtToolkitError,
>			 "XtGetSelectionRequest or XtGetSelectionParameters called for widget \"%s\" outside of ConvertSelection proc",
>			 &params, &num_params
>		       );
>	return NULL;
>    }
>
>    if (req == NULL) {
>	/* non-incremental owner; only one request can be
>	 * outstanding at a time, so it's safe to keep ptr in ctx */
>	req = ctx->req;
>    }
>    return req;
>}
>
>XSelectionRequestEvent *XtGetSelectionRequest(
>    Widget widget,
>    Atom selection,
>    XtRequestId id)
>{
>    Request req = (Request)id;
>    WIDGET_TO_APPCON(widget);
>
>    LOCK_APP(app);
>
>    req = GetRequestRecord(widget, selection, id);
>
>    if (! req) {
>	UNLOCK_APP(app);
>	return (XSelectionRequestEvent*) NULL;
>    }
>
>    if (req->event.type == 0) {
>	/* owner is local; construct the remainder of the event */
>	req->event.type = SelectionRequest;
>	req->event.serial = LastKnownRequestProcessed(XtDisplay(widget));
>	req->event.send_event = True;
>	req->event.display = XtDisplay(widget);
>	req->event.owner = XtWindow(req->ctx->widget);
>	req->event.selection = selection;
>    }
>    UNLOCK_APP(app);
>    return &req->event;
>}
>
>/* Property atom access */
>Atom XtReservePropertyAtom(
>     Widget w)
>{
>  return(GetSelectionProperty(XtDisplay(w)));
>}
>
>void XtReleasePropertyAtom(
>     Widget w,
>     Atom atom)
>{
>  FreeSelectionProperty(XtDisplay(w), atom);
>}
>
>
>/* Multiple utilities */
>
>/* All requests are put in a single list per widget.  It is
>   very unlikely anyone will be gathering multiple MULTIPLE
>   requests at the same time,  so the loss in efficiency for
>   this case is acceptable */
>
>/* Queue one or more requests to the one we're gathering */
>static void AddSelectionRequests(
>     Widget wid,
>     Atom sel,
>     int count,
>     Atom *targets,
>     XtSelectionCallbackProc *callbacks,
>     int num_cb,
>     XtPointer *closures,
>     Boolean *incrementals,
>     Atom *properties)
>{
>  QueuedRequestInfo qi;
>  Window window = XtWindow(wid);
>  Display *dpy = XtDisplay(wid);
>
>  LOCK_PROCESS;
>  if (multipleContext == 0) multipleContext = XUniqueContext();
>
>  qi = NULL;
>  (void) XFindContext(dpy, window, multipleContext, (XPointer*) &qi);
>
>  if (qi != NULL) {
>    QueuedRequest *req = qi->requests;
>    int start = qi->count;
>    int i = 0;
>    int j = 0;
>
>    qi->count += count;
>    req = (QueuedRequest*) XtRealloc((char*) req,
>				     (start + count) *
>				     sizeof(QueuedRequest));
>    while(i < count) {
>      QueuedRequest newreq = (QueuedRequest)
>	__XtMalloc(sizeof(QueuedRequestRec));
>      newreq->selection = sel;
>      newreq->target = targets[i];
>      if (properties != NULL)
>	newreq->param = properties[i];
>      else {
>	newreq->param = GetSelectionProperty(dpy);
>	XDeleteProperty(dpy, window, newreq->param);
>      }
>      newreq->callback = callbacks[j];
>      newreq->closure = closures[i];
>      newreq->incremental = incrementals[i];
>
>      req[start] = newreq;
>      start++;
>      i++;
>      j++;
>      if (j > num_cb) j = 0;
>    }
>
>    qi->requests = req;
>  } else {
>    /* Impossible */
>  }
>
>  UNLOCK_PROCESS;
>}
>
>/* Only call IsGatheringRequest when we have a lock already */
>
>static Boolean IsGatheringRequest(
>     Widget wid,
>     Atom sel)
>{
>  QueuedRequestInfo qi;
>  Window window = XtWindow(wid);
>  Display *dpy = XtDisplay(wid);
>  Boolean found = False;
>  int i;
>
>  if (multipleContext == 0) multipleContext = XUniqueContext();
>
>  qi = NULL;
>  (void) XFindContext(dpy, window, multipleContext, (XPointer*) &qi);
>
>  if (qi != NULL) {
>    i = 0;
>    while(qi->selections[i] != None) {
>      if (qi->selections[i] == sel) {
>	found = True;
>	break;
>      }
>      i++;
>    }
>  }
>
>  return(found);
>}
>
>/* Cleanup request scans the request queue and releases any
>   properties queued, and removes any requests queued */
>static void CleanupRequest(
>     Display *dpy,
>     QueuedRequestInfo qi,
>     Atom sel)
>{
>  int i, j, n;
>
>  i = 0;
>
>  /* Remove this selection from the list */
>  n = 0;
>  while(qi->selections[n] != sel &&
>	qi->selections[n] != None) n++;
>  if (qi->selections[n] == sel) {
>    while(qi->selections[n] != None) {
>      qi->selections[n] = qi->selections[n + 1];
>      n++;
>    }
>  }
>
>  while(i < qi->count) {
>    QueuedRequest req = qi->requests[i];
>
>    if (req->selection == sel) {
>      /* Match */
>      if (req->param != None)
>	FreeSelectionProperty(dpy, req->param);
>      qi->count--;
>
>      for(j = i; j < qi->count; j++)
>	qi->requests[j] = qi->requests[j + 1];
>
>      XtFree((char*) req);
>    } else {
>      i++;
>    }
>  }
>}
>
>extern void XtCreateSelectionRequest(
>    Widget widget,
>    Atom selection)
>{
>  QueuedRequestInfo queueInfo;
>  Window window = XtWindow(widget);
>  Display *dpy = XtDisplay(widget);
>  int n;
>
>  LOCK_PROCESS;
>  if (multipleContext == 0) multipleContext = XUniqueContext();
>
>  queueInfo = NULL;
>  (void) XFindContext(dpy, window, multipleContext, (XPointer*) &queueInfo);
>
>  /* If there is one,  then cancel it */
>  if (queueInfo != 0)
>    CleanupRequest(dpy, queueInfo, selection);
>  else {
>    /* Create it */
>    queueInfo = (QueuedRequestInfo) __XtMalloc(sizeof(QueuedRequestInfoRec));
>    queueInfo->count = 0;
>    queueInfo->selections = (Atom*) __XtMalloc(sizeof(Atom) * 2);
>    queueInfo->selections[0] = None;
>    queueInfo->requests = (QueuedRequest *)
>      __XtMalloc(sizeof(QueuedRequest));
>  }
>
>  /* Append this selection to list */
>  n = 0;
>  while(queueInfo->selections[n] != None) n++;
>  queueInfo->selections =
>    (Atom*) XtRealloc((char*) queueInfo->selections,
>		      (n + 2) * sizeof(Atom));
>  queueInfo->selections[n] = selection;
>  queueInfo->selections[n + 1] = None;
>
>  (void) XSaveContext(dpy, window, multipleContext, (char*) queueInfo);
>  UNLOCK_PROCESS;
>}
>
>extern void XtSendSelectionRequest(
>    Widget widget,
>    Atom selection,
>    Time time)
>{
>  QueuedRequestInfo queueInfo;
>  Window window = XtWindow(widget);
>  Display *dpy = XtDisplay(widget);
>
>  LOCK_PROCESS;
>  if (multipleContext == 0) multipleContext = XUniqueContext();
>
>  queueInfo = NULL;
>  (void) XFindContext(dpy, window, multipleContext, (XPointer*) &queueInfo);
>  if (queueInfo != NULL) {
>    int count = 0;
>    int i;
>    QueuedRequest *req = queueInfo->requests;
>
>    /* Construct the requests and send it using
>       GetSelectionValues */
>    for(i = 0; i < queueInfo->count; i++)
>      if (req[i]->selection == selection) count++;
>
>    if (count > 0) {
>      if (count == 1) {
>	for(i = 0; i < queueInfo->count; i++)
>	  if (req[i]->selection == selection) break;
>
>	/* special case a multiple which isn't needed */
>	GetSelectionValue(widget, selection, req[i]->target,
>			  req[i]->callback, req[i]->closure, time,
>			  req[i]->incremental, req[i]->param);
>      } else {
>	Atom *targets;
>	Atom t[PREALLOCED];
>	XtSelectionCallbackProc *cbs;
>	XtSelectionCallbackProc c[PREALLOCED];
>	XtPointer *closures;
>	XtPointer cs[PREALLOCED];
>	Boolean *incrs;
>	Boolean ins[PREALLOCED];
>	Atom *props;
>	Atom p[PREALLOCED];
>	int i = 0;
>	int j = 0;
>
>	/* Allocate */
>	targets = (Atom *) XtStackAlloc(count * sizeof(Atom), t);
>	cbs = (XtSelectionCallbackProc *)
>	  XtStackAlloc(count * sizeof(XtSelectionCallbackProc), c);
>	closures = (XtPointer *) XtStackAlloc(count * sizeof(XtPointer), cs);
>	incrs = (Boolean *) XtStackAlloc(count * sizeof(Boolean), ins);
>	props = (Atom *) XtStackAlloc(count * sizeof(Atom), p);
>
>	/* Copy */
>	for(i = 0; i < queueInfo->count; i++) {
>	  if (req[i]->selection == selection) {
>	    targets[j] = req[i]->target;
>	    cbs[j] = req[i]->callback;
>	    closures[j] = req[i]->closure;
>	    incrs[j] = req[i]->incremental;
>	    props[j] = req[i]->param;
>	    j++;
>	  }
>	}
>
>	/* Make the request */
>	GetSelectionValues(widget, selection, targets, count,
>			   cbs, count, closures, time, incrs, props);
>
>	/* Free */
>	XtStackFree((XtPointer) targets, t);
>	XtStackFree((XtPointer) cbs, c);
>	XtStackFree((XtPointer) closures, cs);
>	XtStackFree((XtPointer) incrs, ins);
>	XtStackFree((XtPointer) props, p);
>      }
>    }
>  }
>
>  CleanupRequest(dpy, queueInfo, selection);
>  UNLOCK_PROCESS;
>}
>
>extern void XtCancelSelectionRequest(
>    Widget widget,
>    Atom selection)
>{
>  QueuedRequestInfo queueInfo;
>  Window window = XtWindow(widget);
>  Display *dpy = XtDisplay(widget);
>
>  LOCK_PROCESS;
>  if (multipleContext == 0) multipleContext = XUniqueContext();
>
>  queueInfo = NULL;
>  (void) XFindContext(dpy, window, multipleContext, (XPointer*) &queueInfo);
>  /* If there is one,  then cancel it */
>  if (queueInfo != 0)
>    CleanupRequest(dpy, queueInfo, selection);
>  UNLOCK_PROCESS;
>}
>
>/* Parameter utilities */
>
>/* Parameters on a selection request */
>/* Places data on allocated parameter atom,  then records the
>   parameter atom data for use in the next call to one of
>   the XtGetSelectionValue functions. */
>void XtSetSelectionParameters(
>    Widget requestor,
>    Atom selection,
>    Atom type,
>    XtPointer value,
>    unsigned long length,
>    int format)
>{
>  Display *dpy = XtDisplay(requestor);
>  Window window = XtWindow(requestor);
>  Atom property = GetParamInfo(requestor, selection);
>
>  if (property == None) {
>    property = GetSelectionProperty(dpy);
>    AddParamInfo(requestor, selection, property);
>  }
>
>  XChangeProperty(dpy, window, property,
>		  type, format, PropModeReplace,
>		  (unsigned char *) value, length);
>}
>
>/* Retrieves data passed in a parameter. Data for this is stored
>   on the originator's window */
>void XtGetSelectionParameters(
>    Widget owner,
>    Atom selection,
>    XtRequestId request_id,
>    Atom* type_return,
>    XtPointer* value_return,
>    unsigned long* length_return,
>    int* format_return)
>{
>    Request req;
>    Display *dpy = XtDisplay(owner);
>    WIDGET_TO_APPCON(owner);
>
>    *value_return = NULL;
>    *length_return = *format_return = 0;
>    *type_return = None;
>
>    LOCK_APP(app);
>
>    req = GetRequestRecord(owner, selection, request_id);
>
>    if (req && req->property) {
>	unsigned long bytes_after;	/* unused */
>	StartProtectedSection(dpy, req->requestor);
>	XGetWindowProperty(dpy, req->requestor, req->property, 0L, 10000000,
>			   False, AnyPropertyType, type_return, format_return,
>			   length_return, &bytes_after,
>			   (unsigned char**) value_return);
>	EndProtectedSection(dpy);
>#ifdef XT_COPY_SELECTION
>	if (*value_return) {
>	    int size = BYTELENGTH(*length_return, *format_return) + 1;
>	    char *tmp = __XtMalloc((Cardinal) size);
>	    (void) memmove(tmp, *value_return, size);
>	    XFree(*value_return);
>	    *value_return = tmp;
>	}
>#endif
>    }
>    UNLOCK_APP(app);
>}
>
>/*  Parameters are temporarily stashed in an XContext.  A list is used because
> *  there may be more than one selection request in progress.  The context
> *  data is deleted when the list is empty.  In the future, the parameter
> *  context could be merged with other contexts used during selections.
> */
>
>static void AddParamInfo(
>    Widget w,
>    Atom selection,
>    Atom param_atom)
>{
>    int n;
>    Param p;
>    ParamInfo pinfo;
>
>    LOCK_PROCESS;
>    if (paramPropertyContext == 0)
>	paramPropertyContext = XUniqueContext();
>
>    if (XFindContext(XtDisplay(w), XtWindow(w), paramPropertyContext,
>		     (XPointer *) &pinfo)) {
>	pinfo = (ParamInfo) __XtMalloc(sizeof(ParamInfoRec));
>	pinfo->count = 1;
>	pinfo->paramlist = XtNew(ParamRec);
>	p = pinfo->paramlist;
>	(void) XSaveContext(XtDisplay(w), XtWindow(w), paramPropertyContext,
>			    (char *)pinfo);
>    }
>    else {
>	for (n = pinfo->count, p = pinfo->paramlist; n; n--, p++) {
>	    if (p->selection == None || p->selection == selection)
>		break;
>	}
>	if (n == 0) {
>	    pinfo->count++;
>	    pinfo->paramlist = (Param)
>		XtRealloc((char*) pinfo->paramlist,
>			  pinfo->count * sizeof(ParamRec));
>	    p = &pinfo->paramlist[pinfo->count - 1];
>	    (void) XSaveContext(XtDisplay(w), XtWindow(w),
>				paramPropertyContext, (char *)pinfo);
>	}
>    }
>    p->selection = selection;
>    p->param = param_atom;
>    UNLOCK_PROCESS;
>}
>
>static void RemoveParamInfo(
>    Widget w,
>    Atom selection)
>{
>    int n;
>    Param p;
>    ParamInfo pinfo;
>    Boolean retain = False;
>
>    LOCK_PROCESS;
>    if (paramPropertyContext
>	&& (XFindContext(XtDisplay(w), XtWindow(w), paramPropertyContext,
>			 (XPointer *) &pinfo) == 0)) {
>
>	/* Find and invalidate the parameter data. */
>	for (n = pinfo->count, p = pinfo->paramlist; n; n--, p++) {
>	    if (p->selection != None) {
>		if (p->selection == selection)
>		    p->selection = None;
>		else
>		    retain = True;
>	    }
>	}
>	/* If there's no valid data remaining, release the context entry. */
>	if (! retain) {
>	    XtFree((char*) pinfo->paramlist);
>	    XtFree((char*) pinfo);
>	    XDeleteContext(XtDisplay(w), XtWindow(w), paramPropertyContext);
>	}
>    }
>    UNLOCK_PROCESS;
>}
>
>static Atom GetParamInfo(
>    Widget w,
>    Atom selection)
>{
>    int n;
>    Param p;
>    ParamInfo pinfo;
>    Atom atom = None;
>
>    LOCK_PROCESS;
>    if (paramPropertyContext
>	&& (XFindContext(XtDisplay(w), XtWindow(w), paramPropertyContext,
>			 (XPointer *) &pinfo) == 0)) {
>
>	for (n = pinfo->count, p = pinfo->paramlist; n; n--, p++)
>	    if (p->selection == selection) {
>		atom = p->param;
>		break;
>	    }
>    }
>    UNLOCK_PROCESS;
>    return atom;
>}

Actions: View

Attachments on bug 1478: 16700 | 16706

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.