summaryrefslogtreecommitdiff
path: root/src/Selection.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/Selection.c')
-rw-r--r--src/Selection.c2306
1 files changed, 2306 insertions, 0 deletions
diff --git a/src/Selection.c b/src/Selection.c
new file mode 100644
index 0000000..846b1bd
--- /dev/null
+++ b/src/Selection.c
@@ -0,0 +1,2306 @@
+/* $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.
+
+*/
+
+#include "IntrinsicI.h"
+#include "StringDefs.h"
+#include "SelectionI.h"
+#include <X11/Xatom.h>
+
+void _XtSetDefaultSelectionTimeout(timeout)
+ unsigned long *timeout;
+{
+ *timeout = 5000; /* default to 5 seconds */
+}
+
+void XtSetSelectionTimeout(timeout)
+ unsigned long timeout;
+{
+ XtAppSetSelectionTimeout(_XtDefaultAppContext(), timeout);
+}
+
+void XtAppSetSelectionTimeout(app, timeout)
+ XtAppContext app;
+ unsigned long timeout;
+{
+ LOCK_APP(app);
+ app->selectionTimeout = timeout;
+ UNLOCK_APP(app);
+}
+
+unsigned long XtGetSelectionTimeout()
+{
+ return XtAppGetSelectionTimeout(_XtDefaultAppContext());
+}
+
+unsigned long XtAppGetSelectionTimeout(app)
+ XtAppContext app;
+{
+ unsigned long retval;
+
+ LOCK_APP(app);
+ retval = app->selectionTimeout;
+ UNLOCK_APP(app);
+ return retval;
+}
+
+
+/* General utilities */
+
+static void HandleSelectionReplies();
+static void ReqTimedOut();
+static void HandlePropertyGone();
+static void HandleGetIncrement();
+static void HandleIncremental();
+
+static XContext selectPropertyContext = 0;
+static XContext paramPropertyContext = 0;
+static XContext multipleContext = 0;
+
+/* Multiple utilities */
+static void AddSelectionRequests();
+static Boolean IsGatheringRequest();
+
+#define PREALLOCED 32
+
+/* Parameter utilities */
+static void AddParamInfo();
+static void RemoveParamInfo();
+static Atom GetParamInfo();
+
+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(w, closure, callData)
+ 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(dpy)
+ 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(dpy)
+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(dpy, prop)
+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(info)
+ 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(ctx, callbacks, closures, count,
+ widget, time, incremental, properties)
+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(info, selection, target)
+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(dpy, selection)
+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(dpy, selection)
+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, closure, data)
+Widget widget;
+XtPointer closure, 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();
+
+static Boolean LoseSelection(ctx, widget, selection, time)
+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)(
+#if NeedFunctionPrototypes
+ Display*, XErrorEvent*
+#endif
+ );
+
+static xErrorHandler oldErrorHandler = NULL;
+static unsigned long firstProtectRequest;
+static Window errorWindow;
+
+static int LocalErrorHandler (dpy, error)
+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(dpy, window)
+ 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(dpy)
+ 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(req, mask, proc, closure)
+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(req, mask, proc, closure)
+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(closure, id)
+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(incr)
+ Request incr;
+{
+ Display *dpy = incr->ctx->dpy;
+
+ int 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(incrSize, incr->format));
+ EndProtectedSection(dpy);
+ incr->offset += incrSize;
+}
+
+static void AllSent(req)
+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, closure, ev, cont)
+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(req, widget, window, property, target,
+ targetType, value, length, format)
+Request req;
+Widget widget;
+Window window;
+Atom target;
+Atom property;
+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(ctx, event, target, property, widget)
+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) <= 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, closure, event, cont)
+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;
+ 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, selection, time, convert, lose, notify,
+ cancel, closure, incremental)
+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, selection, time, convert, lose, notify)
+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, selection, time, convert,
+ lose, notify, cancel, closure)
+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(info, window, prop)
+ 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, closure, ev, cont)
+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(closure, id)
+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, closure, ev, cont)
+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, callback, closure, selection)
+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, value, format, length)
+ 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(dpy, widget, property, info, closure, selection)
+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(dpy, widget, property, info, size)
+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, closure, ev, cont)
+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(req, selection, target, widget,
+ callback, closure, incremental, property)
+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, selection, target, callback,
+ closure, time, incremental, property)
+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, selection, target, callback, closure, time)
+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, selection, target, callback,
+ closure, time)
+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, selection, targets, count, callbacks,
+ num_callbacks, closures, time, incremental,
+ properties)
+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, selection, targets, count, callback,
+ closures, time)
+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, selection, targets, count,
+ callback, closures, time)
+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, selection, id)
+ 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, selection, id)
+ 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(w)
+ Widget w;
+{
+ return(GetSelectionProperty(XtDisplay(w)));
+}
+
+void XtReleasePropertyAtom(w, atom)
+ 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(wid, sel, count, targets, callbacks,
+ num_cb, closures, incrementals, properties)
+ 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(wid, sel)
+ 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(dpy, qi, sel)
+ 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, selection)
+ 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, selection, time)
+ 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, selection)
+ 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(requestor, selection, type, value, length, format)
+ 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(owner, selection, request_id, type_return,
+ value_return, length_return, format_return)
+ 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(w, selection, param_atom)
+ 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(w, selection)
+ 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(w, selection)
+ 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;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-21 20:39:35 +0000