aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/lib/Xt/Selection.c
diff options
context:
space:
mode:
Diffstat (limited to 'nx-X11/lib/Xt/Selection.c')
-rw-r--r--nx-X11/lib/Xt/Selection.c2295
1 files changed, 0 insertions, 2295 deletions
diff --git a/nx-X11/lib/Xt/Selection.c b/nx-X11/lib/Xt/Selection.c
deleted file mode 100644
index 46c75f882..000000000
--- a/nx-X11/lib/Xt/Selection.c
+++ /dev/null
@@ -1,2295 +0,0 @@
-/* $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;
- 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;
-}