/* $TOG: Transfer.c /main/17 1997/07/16 16:31:41 csn $ */
/*
 * Motif
 *
 * Copyright (c) 1987-2012, The Open Group. All rights reserved.
 *
 * These libraries and programs are free software; you can
 * redistribute them and/or modify them under the terms of the GNU
 * Lesser General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * These libraries and programs are distributed in the hope that
 * they will be useful, but WITHOUT ANY WARRANTY; without even the
 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 * PURPOSE. See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with these librararies and programs; if not, write
 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
 * Floor, Boston, MA 02110-1301 USA
 */
/*
 * HISTORY
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif


#include <X11/Xatom.h>
#include <Xm/AtomMgr.h>
#include <Xm/DragDrop.h>
#include <Xm/SpecRenderT.h>
#include <Xm/TraitP.h>
#include <Xm/VendorSP.h>
#include <Xm/XmosP.h>
#include "CutPasteI.h"
#include "DragBSI.h"
#include "HashI.h"
#include "MessagesI.h"
#include "ResEncodI.h"
#include "TransferI.h"
#include "XmI.h"


typedef enum { DoXFree, DoFree } FreeType;
#define FreeSafeAtomName(val,how) if (1) { if (DoXFree==how) XFree(val); else free(val); } 

static ConvertContext LookupContextBlock(Display*, Atom);
static void ClearContextBlock(Display*, Atom);
static void ClipboardCallback(Widget, long*, long*, int*);
static void DisownCallback(Widget, XtPointer, XtPointer);
static void FreeTransferID(XtPointer);
static void CallDoneProcs(Widget, XtPointer, XmTransferDoneCallbackStruct*);
static XtPointer GetTransferID(void);
static void SelectionCallbackWrapper(Widget, XtPointer, Atom*, Atom*,
				     XtPointer, unsigned long*, int*);
static Boolean DragConvertHandler(Widget, Atom *, Atom *, Atom *, 
				  XtPointer *, unsigned long *, int *);
static void SecondaryConvertHandler(Widget, XtPointer, 
				    XmConvertCallbackStruct *);
static void ReleaseSecondaryLock(Widget, XtEnum, XmTransferDoneCallbackStruct*);
static void DropDestinationHandler(Widget, XtPointer,
				   XmDropProcCallbackStruct *);
static TransferBlock AddTransferBlock(TransferContext tc);
static void SecondaryDone(Widget, XtPointer, Atom*, Atom*,
			  XtPointer, unsigned long*, int*);
static void TransferWarning(Widget w, char* name, char* type, char* message);
static void DeleteDropCBStruct(Widget w, XtEnum ignored_status,
			       XmTransferDoneCallbackStruct *cs);
static void FinishTransfer(Widget wid, TransferContext tc);
static char* GetSafeAtomName(Display *display, Atom a, FreeType *howFree);
static void LoseProc(Widget w, Atom *selection);
static void ClipboardLoseProc(Widget w, Atom *selection);

#define BAD_ATOM_MESSAGE    _XmMMsgTransfer_0005
#define BAD_STATUS_MESSAGE  _XmMMsgTransfer_0004
#define BAD_SCB_MESSAGE     _XmMMsgTransfer_0000
#define BAD_MATCHED_CONVERT _XmMMsgTransfer_0002
#define BAD_STATUS          _XmMMsgTransfer_0003
#define ERROR_MULTIPLE_IN_PROGRESS _XmMMsgTransfer_0006
#define ERROR_MULTIPLE_NOT_IN_PROGRESS _XmMMsgTransfer_0007
#define MERGE "XmeConvertMerge"
#define ATOM  "XGetAtomName"
#define MATCH "Format or type mismatch"
#define ARG "Argument"
#define START_MULTIPLE "XmTransferStartRequest"
#define END_MULTIPLE "XmTransferSendRequest"

#define XmS_MOTIF_SNAPSHOT "_MOTIF_SNAPSHOT"
#define XmSCLIPBOARD_MANAGER "CLIPBOARD_MANAGER"

#define BYTELENGTH( length, format ) \
  ((format == 8) ? length : \
   ((format == 16) ? length * sizeof(short) : \
    (length * sizeof(long))))

static int local_convert_flag = 0;

static XmHashTable DataIdDictionary = NULL;

void
_XmConvertHandlerSetLocal(void)
{
  _XmProcessLock();
  local_convert_flag = 1;
  _XmProcessUnlock();
}

/************************************************************************/
/*									*/
/* Convert section.  These functions provide an API to setting up 	*/
/* selections,  working with the clipboard and starting Drag and Drop.  */
/* 									*/
/************************************************************************/

/****************************************************************/
/* ConvertHandler is a generalized version of the convert proc  */
/* in Xt.  It calls the convertCallbacks and the transferTrait  */
/* on the particular widgetclass.				*/
/****************************************************************/

Boolean
_XmConvertHandler(Widget wid, Atom *selection, Atom *target, 
		  Atom *type, XtPointer *value, 
		  unsigned long *size, int *fmt)
{
  enum { XmA_MOTIF_DESTINATION, XmAINSERT_SELECTION,
	 XmALINK_SELECTION, XmA_MOTIF_LOSE_SELECTION, XmA_MOTIF_DROP,
	 XmACLIPBOARD, XmA_MOTIF_CLIPBOARD_TARGETS,
	 XmA_MOTIF_DEFERRED_CLIPBOARD_TARGETS, NUM_ATOMS };
  static char *atom_names[] = { XmS_MOTIF_DESTINATION, XmSINSERT_SELECTION,
	 XmSLINK_SELECTION, XmS_MOTIF_LOSE_SELECTION, XmS_MOTIF_DROP,
	 XmSCLIPBOARD, XmS_MOTIF_CLIPBOARD_TARGETS,
	 XmS_MOTIF_DEFERRED_CLIPBOARD_TARGETS };

  XmTransferTrait ttrait;
  XmConvertCallbackStruct cbstruct;
  ConvertContext cc;
  Atom atoms[XtNumber(atom_names)];
  Atom real_selection_atom = None; /* DND hides the selection atom from us */
  int my_local_convert_flag;

  assert(XtNumber(atom_names) == NUM_ATOMS);
  XInternAtoms(XtDisplay(wid), atom_names, XtNumber(atom_names), False, atoms);

  _XmProcessLock();
  my_local_convert_flag = local_convert_flag;
  _XmProcessUnlock();

  /* Find the context block */

  cc = LookupContextBlock(XtDisplay(wid), *selection);

  /* Setup the callback structure */

  cbstruct.reason = XmCR_OK;
  cbstruct.event = NULL;
  cbstruct.selection = *selection;
  cbstruct.target = *target;
  cbstruct.source_data = (XtPointer) cc -> drag_context;
  cbstruct.flags = XmCONVERTING_NONE;
  cbstruct.location_data = cc -> location_data;
  cbstruct.status = XmCONVERT_DEFAULT;
  cbstruct.value = NULL;
  cbstruct.type = XA_INTEGER;
  cbstruct.format = 8;
  cbstruct.length = 0;

 
  _XmProcessLock();
  /* Get the request event if we can */
  if (my_local_convert_flag == 0) {
    Arg args[1];
    Widget req_widget;

    if (*selection == atoms[XmA_MOTIF_DROP]) {
      XtSetArg(args[0], XmNiccHandle, &real_selection_atom);
      XtGetValues(cc -> drag_context, args, 1);
      cbstruct.event = (XEvent *) XtGetSelectionRequest(cc -> drag_context, 
							real_selection_atom, 
							NULL);
      req_widget = cc -> drag_context;
    } else {
      cbstruct.event = (XEvent *) XtGetSelectionRequest(wid, *selection, 
							NULL);
      req_widget = wid;
    }

    /* Get the parameters from this request.  Use the correct
       selection atom here as well */
    {
      Atom sel_atom = (real_selection_atom != None) 
	? real_selection_atom : *selection;
      XtGetSelectionParameters(req_widget, sel_atom, NULL,
			       &cbstruct.parm_type, &cbstruct.parm, 
			       &cbstruct.parm_length, &cbstruct.parm_format);
    }
  } else {
    /* We're called locally when XmeClipboardSource is invoked and there
       is no CLIPBOARD_MANAGER.  In this case we must pickup the operation
       from the context block and put it in the parameter */
    if (*selection == atoms[XmACLIPBOARD]) {
      if (*target == atoms[XmA_MOTIF_CLIPBOARD_TARGETS] ||
	  *target == atoms[XmA_MOTIF_DEFERRED_CLIPBOARD_TARGETS]) {
	cbstruct.parm = (XtPointer) cc -> op;
	cbstruct.parm_length = 1;
	cbstruct.parm_format = 32;
	cbstruct.parm_type = XA_INTEGER;
      }	else {
	cbstruct.parm = NULL;
	cbstruct.parm_length = 0;
	cbstruct.parm_format = 8;
	cbstruct.parm_type = None;
      }
    }
  }    
  _XmProcessUnlock();

  if (cbstruct.event != NULL &&
      ((XSelectionRequestEvent *) cbstruct.event) -> requestor ==
      ((XSelectionRequestEvent *) cbstruct.event) -> owner) {
    cbstruct.flags |= XmCONVERTING_SAME;
  }

  _XmProcessLock();
  /* Reset bypass flag */
  local_convert_flag = 0;
  _XmProcessUnlock();

  if (*selection != atoms[XmA_MOTIF_DESTINATION] ||
      *target == atoms[XmA_MOTIF_LOSE_SELECTION]) {
    /* First we call any convert callbacks */

    if (XtHasCallbacks(wid, XmNconvertCallback) == XtCallbackHasSome)
      XtCallCallbacks(wid, XmNconvertCallback, &cbstruct);

    if (cbstruct.status == XmCONVERT_MORE)
      {
	/* Print error message,  and revert this flag to
	   XmCONVERT_DEFAULT */
	XmeWarning(wid, BAD_STATUS_MESSAGE);
	cbstruct.status = XmCONVERT_DEFAULT;
      }

    /* Now lookup the trait on this widget and call the
       internal routine */

    if (cbstruct.status == XmCONVERT_DEFAULT ||
	cbstruct.status == XmCONVERT_MERGE) {
      ttrait = (XmTransferTrait) 
	XmeTraitGet((XtPointer) XtClass(wid), XmQTtransfer);
      if (ttrait != NULL)
	ttrait -> convertProc(wid, NULL, &cbstruct);
    }
  }

  /* If this is an INSERT_SELECTION or LINK_SELECTION then 
     we call SecondaryConvertHandler to finish the work */
  if (cbstruct.status == XmCONVERT_DEFAULT &&
      (*target == atoms[XmAINSERT_SELECTION] ||
       *target == atoms[XmALINK_SELECTION]))
    SecondaryConvertHandler(wid, NULL, &cbstruct);

  /* Copy out the flags value for CLIPBOARD to use */
  cc -> flags = cbstruct.flags;

  if (cbstruct.status == XmCONVERT_DONE ||
      cbstruct.status == XmCONVERT_DEFAULT)
    {
      /* Copy out the data */
      *value = cbstruct.value;
      *size = cbstruct.length;
      *fmt = cbstruct.format;
      *type = cbstruct.type;
      return True;
    }
  else
    {
      *value = NULL;
      *size = 0;
      *fmt = 8;
      *type = None;
      return False;
    }
}

/****************************************************************/
/* DragConvertHandler acts as a wrapper to convert handler for	*/
/* drag and drop.  This is because drag and drop passes the     */
/* DragContext as the widget to the convert proc in the drag    */
/****************************************************************/

static Boolean
DragConvertHandler(Widget drag_context, Atom *selection, Atom *target, 
		      Atom *type, XtPointer *value, 
		      unsigned long *size, int *fmt)
{
  ConvertContext cc;
  Atom MOTIF_DROP = XInternAtom(XtDisplay(drag_context), XmS_MOTIF_DROP, False);

  /* Find the context block */

  cc = LookupContextBlock(XtDisplay(drag_context), MOTIF_DROP);

  /* Originating widget was stored in client_data */

  return(_XmConvertHandler((Widget) cc -> client_data,
			   selection, target, 
			   type, value, size, fmt));

}

static int secondary_lock = 0;

/********************************************************************/
/* SecondaryConvertHandler handles the detail of                    */
/* Secondary selection.  This is because secondary is a synchronous */
/* mechanism which requires a spinlock.				    */
/********************************************************************/

/*ARGSUSED*/
static void
SecondaryConvertHandler(Widget w, 
			XtPointer ignored, /* unused */
			XmConvertCallbackStruct *cs)
{
  enum { XmANULL, XmAINSERT_SELECTION, XmALINK_SELECTION, NUM_ATOMS };
  static char *atom_names[] = {XmSNULL, XmSINSERT_SELECTION, XmSLINK_SELECTION};

  XtAppContext app = XtWidgetToApplicationContext(w);
  _XmTextInsertPair *pair;
  XSelectionRequestEvent *req_event;
  static unsigned long old_serial = 0;
  Atom atoms[XtNumber(atom_names)];
  XtEnum operation;

  _XmProcessLock();
  if (secondary_lock != 0) {
    cs -> status = XmCONVERT_REFUSE;
    _XmProcessUnlock();
    return;
  }
  _XmProcessUnlock();

  req_event = XtGetSelectionRequest(w, cs -> selection, NULL);

  cs -> event = (XEvent *) req_event;

  _XmProcessLock();
  /* Work around for intrinsics selection bug */
  if (req_event != NULL && old_serial != req_event->serial)
    old_serial = req_event->serial;
  else {
    cs -> status = XmCONVERT_REFUSE;
    _XmProcessUnlock();
    return;
  }
  _XmProcessUnlock();

  if (cs -> parm_length == 0)
    {
      cs -> status = XmCONVERT_REFUSE;
      return;
    }

  pair = (_XmTextInsertPair *) cs -> parm;

  _XmProcessLock();
  /* Lock */
  secondary_lock = 1;
  _XmProcessUnlock();

  assert(XtNumber(atom_names) == NUM_ATOMS);
  XInternAtoms(XtDisplay(w), atom_names, XtNumber(atom_names), False, atoms);

  if (cs -> target == atoms[XmAINSERT_SELECTION])
    operation = XmCOPY;
  else if (cs -> target == atoms[XmALINK_SELECTION])
    operation = XmLINK;
  else 
    operation = XmOTHER;

  if (_XmDestinationHandler(w, pair -> selection, 
			    operation, ReleaseSecondaryLock, 
			    (XtPointer) pair -> target,
			    req_event -> time, req_event) != True) {
    cs -> status = XmCONVERT_REFUSE;
    return;
  }

  /*
   * Make sure the above selection request is completed
   * before returning from the convert proc.
   */

#ifdef XTHREADS
  while (XtAppGetExitFlag(app) == False) {
#else
  for (;;) {
#endif
    XEvent event;
    XtInputMask mask;

    if (secondary_lock == 0) break;
#ifndef XTHREADS
    XtAppNextEvent(app, &event);
    XtDispatchEvent(&event);
#else
    while (!(mask = XtAppPending(app)))
	;  /* Busy waiting - so that we don't lose our lock */
    if (mask & XtIMXEvent) { /* We have an XEvent */
	/* Get the event since we know its there.
	 * Note that XtAppNextEvent would also process
	 * timers/alternate inputs.
	 */
	XtAppNextEvent(app, &event); /* no blocking */
	XtDispatchEvent(&event); /* Process it */
    }
    else /* not an XEvent, process it */
	XtAppProcessEvent(app, mask); /* non blocking */
#endif
  }

  cs -> value = NULL;
  cs -> type = atoms[XmANULL];
  cs -> format = 8;
  cs -> length = 0;
  cs -> status = XmCONVERT_DONE;
}

/*ARGSUSED*/
static void
ReleaseSecondaryLock(Widget w,	/* unused */
		     XtEnum a,	/* unused */
		     XmTransferDoneCallbackStruct *ts) /* unused */
{
  _XmProcessLock();
  secondary_lock = 0;
  _XmProcessUnlock();
}


/****************************************************************/
/* ClipboardLoseProc allows us to perform the delete operation  */
/* for the case where the user is performing a CUT to the       */
/* CLIPBOARD,  and the CLIPBOARD is owned by a			*/
/* CLIPBOARD_MANAGER.						*/
/****************************************************************/
static void
ClipboardLoseProc(Widget w, Atom *selection)
{
  Atom DELETE = XInternAtom(XtDisplay(w), XmSDELETE, False);
  XtPointer value;
  Atom type;
  unsigned long size;
  int fmt;

  _XmConvertHandlerSetLocal();
  _XmConvertHandler(w, selection, &DELETE, 
		    &type, &value, &size, &fmt);

  LoseProc(w, selection);
}

/****************************************************************/
/* LoseProc is just a thin wrapper routine so			*/
/* we have a place to do bookkeeping.				*/
/****************************************************************/

static void
LoseProc(Widget w, Atom *selection)
{
  XtPointer value;
  Atom type;
  unsigned long size;
  int fmt;
  Atom MOTIF_LOSE = XInternAtom(XtDisplay(w), XmS_MOTIF_LOSE_SELECTION, False);

  _XmConvertHandlerSetLocal();
  _XmConvertHandler(w, selection, &MOTIF_LOSE, 
		    &type, &value, &size, &fmt);
  XtFree((char*) value);
  XtRemoveCallback(w, XmNdestroyCallback, DisownCallback,
		   (XtPointer) *selection);
}

/********************************************************************/
/* This gets run to disown the selection if the widget is destroyed */
/********************************************************************/

/*ARGSUSED*/
static void 
DisownCallback(Widget w, 
	       XtPointer ignore, /* unused */
	       XtPointer client_data)
{
  Time time = XtLastTimestampProcessed(XtDisplay(w));

  XtDisownSelection(w, (Atom) client_data, time);
}


/****************************************************************/
/* XmeConvertMerge  merges the new data into the old return     */
/* value in the callback structure.				*/
/****************************************************************/
void
XmeConvertMerge(XtPointer data, Atom type, int format, 
		unsigned long size, XmConvertCallbackStruct *cs)
{
  _XmProcessLock();
  if (cs -> status != XmCONVERT_MERGE) {
    TransferWarning(NULL, MERGE, ARG, BAD_STATUS);
    _XmProcessUnlock();
    return;
  }

  /* Merge the results.  Format and type better agree */
  if (format == cs -> format && type == cs -> type)
    {
      int total_size, offset, user_bytes;
	      
      /* Calculate all sizes in bytes */
      offset = BYTELENGTH(cs -> length, cs -> format);
      user_bytes = BYTELENGTH(size, format);
      total_size = offset + user_bytes;
      /* Reallocate user data */
      cs-> value = (XtPointer) XtRealloc((char*) cs -> value, total_size);
      if (cs -> value == NULL) {
    	_XmProcessUnlock();
	return;
      }
      /* Copy widget data to cs.value from data */
      memcpy(&((char*) cs -> value)[offset], (char*) data, user_bytes);
      /* Add in the new size */
      cs -> length += size;
    }
  else /* If not,  print an error message */
    TransferWarning(NULL, MERGE, MATCH, BAD_MATCHED_CONVERT);
  _XmProcessUnlock();
}


/****************************************************************/
/* XmeTransferAddDoneProc(tid, done_proc)			*/
/* Adds a new done proc to the end of the current list of done  */
/* procs.  							*/
/****************************************************************/

void
XmeTransferAddDoneProc(XtPointer id,
		       XmSelectionFinishedProc done_proc)
{
  TransferContext tid = (TransferContext) id;

  _XmProcessLock();
  tid -> numDoneProcs++;

  if (tid -> numDoneProcs == 1)
    tid -> doneProcs = (XmSelectionFinishedProc *) 
      XtMalloc(sizeof(XmSelectionFinishedProc*));
  else
    tid -> doneProcs = (XmSelectionFinishedProc *) 
      XtRealloc((char*) tid -> doneProcs,
		sizeof(XmSelectionFinishedProc*) * tid -> numDoneProcs);

  tid -> doneProcs[tid -> numDoneProcs - 1] = done_proc;
  _XmProcessUnlock();
}


/****************************************************************/
/* XmePrimarySource(Widget, Time) 				*/
/* Owns the primary selection and sets up the appropriate       */
/* conversion handling						*/
/****************************************************************/

Boolean
XmePrimarySource(Widget w, Time time)
{
  return(XmeNamedSource(w, XA_PRIMARY, time));
}

/****************************************************************/
/* XmeNamedSource(Widget, Atom, Time) 				*/
/* Owns the named selection and sets up the appropriate         */
/* conversion handling						*/
/****************************************************************/

Boolean
XmeNamedSource(Widget w, Atom sel, Time time)
{
  Boolean status;

  _XmWidgetToAppContext(w);

  _XmAppLock(app);
  ClearContextBlock(XtDisplay(w), sel);

  if (time == 0) time = XtLastTimestampProcessed(XtDisplay(w));

  status = XtOwnSelection(w, sel, time, _XmConvertHandler, 
			  LoseProc, NULL);

  if (status) XtAddCallback(w, XmNdestroyCallback, DisownCallback,
			    (XtPointer) sel);

  _XmAppUnlock(app);
  return(status);
}

/****************************************************************/
/* XmeSecondarySource(Widget, Op, Time) 			*/
/* Owns the secondary selection and sets up the appropriate     */
/* conversion handling.  This is the function to call when 	*/
/* starting the secondary selection.  				*/
/****************************************************************/

Boolean
XmeSecondarySource(Widget w, Time time)
{
  return(XmeNamedSource(w, XA_SECONDARY, time));
}

/****************************************************************/
/* XmeSecondaryTransfer(Widget, target, op, Time) 		*/
/* Triggers the actual secondary transfer by requesting the     */
/* target passed into XmeSecondarySource of the selection 	*/
/* _MOTIF_DESTINATION						*/
/****************************************************************/

void
XmeSecondaryTransfer(Widget w, Atom target, XtEnum op, Time time)
{
  enum { XmA_MOTIF_DESTINATION, XmAINSERT_SELECTION,
	 XmALINK_SELECTION, XmAATOM_PAIR, NUM_ATOMS };
  static char *atom_names[] = { XmS_MOTIF_DESTINATION, XmSINSERT_SELECTION,
	 XmSLINK_SELECTION, XmIATOM_PAIR };

  ConvertContext cc;
  _XmTextInsertPair pair;
  Atom transfer_target;
  Atom atoms[XtNumber(atom_names)];
  _XmWidgetToAppContext(w);

  _XmAppLock(app);
  assert(XtNumber(atom_names) == NUM_ATOMS);
  XInternAtoms(XtDisplay(w), atom_names, XtNumber(atom_names), False, atoms);

  cc = LookupContextBlock(XtDisplay(w), XA_SECONDARY);
  cc -> op = op;

  if (op == XmLINK)
    transfer_target = atoms[XmALINK_SELECTION];
  else
    transfer_target = atoms[XmAINSERT_SELECTION];

  pair.selection = XA_SECONDARY;
  pair.target = target;

  XtSetSelectionParameters(w, atoms[XmA_MOTIF_DESTINATION], atoms[XmAATOM_PAIR],
			   (XtPointer) &pair, 2, 32);
  XtGetSelectionValue(w, atoms[XmA_MOTIF_DESTINATION], transfer_target,
		      SecondaryDone, NULL, time);
  _XmAppUnlock(app);
}

/*****************************************************************/
/* SecondaryDone deals with the completion of the                */
/* convert selection request started in XmeSecondaryTransfer     */
/* This also callback to a widget supplied routine to deal with  */
/* issues surrounding the success or failure of the transfer     */
/*****************************************************************/
/*ARGSUSED*/
static void 
SecondaryDone(Widget wid, 
	      XtPointer client_data, /* unused */
	      Atom *selection,	/* unused */
	      Atom *type, XtPointer value, 
	      unsigned long *length, int *format)
{
  ConvertContext cc;
  Boolean success;
  Atom convert_selection;
  Atom DELETE = XInternAtom(XtDisplay(wid), XmSDELETE, False);

  cc = LookupContextBlock(XtDisplay(wid), XA_SECONDARY);

  if (*type == None && *length == 0 && value == NULL)
    success = False;
  else
    success = True;

  convert_selection = XA_SECONDARY;
  /* Call the convertCallback with target DELETE if successful */
  if (success && cc -> op == XmMOVE) {
    _XmConvertHandlerSetLocal();
    _XmConvertHandler(wid, &convert_selection,
		      &DELETE, 
		      type, (XtPointer*) &value, length, format);
    XtFree((char*) value);
  }

  XtDisownSelection(wid, convert_selection, 
		    XtLastTimestampProcessed(XtDisplay(wid)));
}



/****************************************************************/
/* XmeClipboardSource(Widget, Op, Time)				*/
/* Puts data onto the clipboard.  				*/
/****************************************************************/

Boolean
XmeClipboardSource(Widget w, XtEnum op, Time time)
{
  enum { XmA_MOTIF_DEFERRED_CLIPBOARD_TARGETS,
	 XmA_MOTIF_CLIPBOARD_TARGETS, XmACLIPBOARD,
	 XmACLIPBOARD_MANAGER, XmA_MOTIF_SNAPSHOT, XmADELETE, NUM_ATOMS };
  static char *atom_names[] = { XmS_MOTIF_DEFERRED_CLIPBOARD_TARGETS,
	 XmS_MOTIF_CLIPBOARD_TARGETS, XmSCLIPBOARD,
	 XmSCLIPBOARD_MANAGER, XmS_MOTIF_SNAPSHOT, XmSDELETE };

  ConvertContext cc;
  Atom type, type2, *targets;
  XtPointer value;
  unsigned long size, size2;
  int format, format2;
  int i, count, status, transferred = 0;
  Display *display;
  long itemid;
  char *name;
  FreeType howFree;
  Atom atoms[XtNumber(atom_names)];
  Window clipboard_owner;
  _XmWidgetToAppContext(w);

  _XmAppLock(app);
  display = XtDisplay(w);

  assert(XtNumber(atom_names) == NUM_ATOMS);
  XInternAtoms(display, atom_names, XtNumber(atom_names), False, atoms);

  if (time == 0) time = XtLastTimestampProcessed(display);

  ClearContextBlock(display, atoms[XmACLIPBOARD]);

  cc = LookupContextBlock(display, atoms[XmACLIPBOARD]);
  cc -> op = op;

  /* If there is a clipboard manager,  then just take 
     ownership of the clipboard selection and the manager
     will do the rest.  Otherwise we use the motif clipboard
     code. */
  clipboard_owner = XGetSelectionOwner(display, atoms[XmACLIPBOARD_MANAGER]);
  if (clipboard_owner != None) {
    int status;

    if (op == XmMOVE) {
      /* We call a special lose proc for move which will call
	 _XmConvertHandler to delete the selection */
      status = XtOwnSelection(w, atoms[XmACLIPBOARD], time,
			      _XmConvertHandler, ClipboardLoseProc, NULL);
    } else {
      status = XtOwnSelection(w, atoms[XmACLIPBOARD], time,
			      _XmConvertHandler, LoseProc, NULL);
    }

    if (status)
    {
      XtAddCallback(w, XmNdestroyCallback, DisownCallback,
			      (XtPointer) atoms[XmACLIPBOARD]);
    } else {
      _XmAppUnlock(app);
      return True;
    }
  }

  /* Use Motif clipboard */
  status = XmClipboardStartCopy(display, XtWindow(w), NULL, 
				time, w, ClipboardCallback, &itemid);
  
  if (status == XmClipboardLocked) {
	_XmAppUnlock(app);
	return(False);
  }
  
  /* OK.  We've got the clipboard, now setup the targets items */
  cc -> itemid = itemid;
  
  /* Call the converter to get the targets for the clipboard
     if _MOTIF_CLIPBOARD_TARGETS doesn't work then try 
     TARGETS target */
  _XmConvertHandlerSetLocal();
  if (_XmConvertHandler(w, &atoms[XmACLIPBOARD],
			&atoms[XmA_MOTIF_CLIPBOARD_TARGETS],
			&type, &value, &size, &format) == True &&
      size != 0 &&
      type == XA_ATOM) {
    targets = (Atom *) value;
    count = size;
    /* For each item we register the format, ask to convert it
       and if it is converted we put it on the clipboard */
    for(i = 0; i < count; i++) {
      name = GetSafeAtomName(display, targets[i], &howFree);
      _XmConvertHandlerSetLocal();
      if (_XmConvertHandler(w, &atoms[XmACLIPBOARD], &targets[i], 
			    &type2, &value, &size2, &format2) == True &&
	  ! (cc -> flags & XmCONVERTING_PARTIAL)) {
	XmClipboardRegisterFormat(display, name, format2);
	/* format must be 8, 16 or 32. */
	size2 = BYTELENGTH(size2, format2);
	transferred++;
	/* Critical section for MT */
	_XmProcessLock();
	_XmClipboardPassType(type2);
	XmClipboardCopy(display, XtWindow(w), itemid, name, value, size2, 0, 0);
	_XmProcessUnlock();
	/* End Critical section for MT */
      }
      XtFree((char*) value);
      FreeSafeAtomName(name,howFree);
    }
    XtFree((char*) targets);
  }
  
  /* Call the converter to get the deferred targets for the
     clipboard */
  _XmConvertHandlerSetLocal();
  if( _XmConvertHandler(w, &atoms[XmACLIPBOARD],
			&atoms[XmA_MOTIF_DEFERRED_CLIPBOARD_TARGETS],
			&type, &value, &size, &format) == True &&
      size != 0 &&
      type == XA_ATOM) {
    _XmProcessLock();
    if (DataIdDictionary == NULL) {
      /* Create dictionary which stores data about particular
	 snapshots and particular dataids.  Since it 
	 takes an integer as a key,  don't need match or hash 
	 functions */
      DataIdDictionary = _XmAllocHashTable(10, NULL, NULL);
    }
    _XmProcessUnlock();
    
    targets = (Atom *) value;
    count = size;
    /* If there are deferred targets then the snapshot target
       must be converted successfully.  The value returned
       by snapshot will be used as a unique id in the 
       clipboard callback to identify this deferred data
       item */
    _XmConvertHandlerSetLocal();
    if (_XmConvertHandler(w, &atoms[XmACLIPBOARD], &atoms[XmA_MOTIF_SNAPSHOT], 
			  &type2, &value, &size2, &format2) == True) {
      long data_id;
      SnapshotRequest req;
      
      if (count != 0) {
	req = (SnapshotRequest) XtMalloc(sizeof(SnapshotRequestRec));
	req -> outstanding = 0;
	req -> distinguisher = * (Atom *) value;
      } else {
	req = NULL;
      }
      
      XtFree((char*) value);
      
      for(i = 0; i < count; i++) {
	name = GetSafeAtomName(display, targets[i], &howFree);
	transferred++;
	/* Critical section for MT */
	_XmProcessLock();
	_XmClipboardPassType(type2);
	XmClipboardCopy(display, XtWindow(w), itemid, name,
			NULL, 0, targets[i], &data_id);
	_XmProcessUnlock();
	/* End Critical section for MT */
	/* Associate the data_id with this snapshot and increment
	   the number of requests outstanding */
	_XmProcessLock();
	_XmAddHashEntry(DataIdDictionary, (XmHashKey)data_id, (XtPointer)req);
	_XmProcessUnlock();
	req -> outstanding++;
        FreeSafeAtomName(name,howFree);
      }
    }
    XtFree((char*) targets);
  }
  XmClipboardEndCopy(display, XtWindow(w), itemid);
  
  if (op == XmMOVE && transferred != 0) {
    _XmConvertHandlerSetLocal();
    _XmConvertHandler(w, &atoms[XmACLIPBOARD], &atoms[XmADELETE], 
		      &type, &value, &size, &format);
    XtFree((char*) value);
  }

  if (transferred != 0) {
    _XmAppUnlock(app);
    return(True);
  }
  else {
    _XmAppUnlock(app);
    return(False);
  }
}

static void 
ClipboardCallback(Widget w, long *data_id, long *target, int *reason)
{
  XtPointer value;
  Atom type;
  unsigned long size;
  int format;
  Display *display;
  Atom CLIPBOARD = XInternAtom(XtDisplay(w), XmSCLIPBOARD, False);
  SnapshotRequest req;
  ConvertContext cc;

  cc = LookupContextBlock(XtDisplay(w), CLIPBOARD);

  _XmProcessLock();
  req = (SnapshotRequest) _XmGetHashEntry(DataIdDictionary,
					  (XmHashKey) *data_id);
  /* Decrement count and remove this association */
  req -> outstanding--;
  _XmRemoveHashEntry(DataIdDictionary, (XtPointer)data_id);
  _XmProcessUnlock();

  display = XtDisplay(w);

  if (*reason != XmCR_CLIPBOARD_DATA_DELETE) {
    _XmConvertHandlerSetLocal();
    if (_XmConvertHandler(w, &req -> distinguisher, (Atom *) target, 
			  &type, &value, &size, &format) == True &&
	! (cc -> flags & XmCONVERTING_PARTIAL)) {
      char *name;
      FreeType howFree;
     
      size = BYTELENGTH( size, format );
      if (format % 8 != 0) size++;
      
      name = GetSafeAtomName(display, * (Atom *) target, &howFree);
      XmClipboardRegisterFormat(display, name, format);
      FreeSafeAtomName(name,howFree);
      /* Critical section for MT */
      _XmProcessLock();
      _XmClipboardPassType(type);
      XmClipboardCopyByName(display, XtWindow(w), *data_id, 
			    value, size, 0L);
      _XmProcessUnlock();
      XtFree((char*) value);
    }
    else
      XmClipboardCopyByName(display, XtWindow(w), *data_id, 
			    NULL, 0, 0L);
  }

  if (req -> outstanding == 0) {
    Atom done = XInternAtom(display, XmIDONE, False);

    /* If this was the last item,  call _XmConvertHandler with
       DELETE on the distinguisher and then free the req */
    _XmConvertHandlerSetLocal();
    _XmConvertHandler(w, &req -> distinguisher, 
		      (Atom *) &done, &type, &value, &size, &format);
    XtFree((char*) value);
    XtFree((char*) req);
  }
}

/****************************************************************/
/* XmeDragSource						*/
/* Sets up for drag and drop and calls XmDragStart		*/
/****************************************************************/

Widget 
XmeDragSource(Widget w, XtPointer location_data, XEvent *event,
	      ArgList in_args, Cardinal in_arg_count)
{
  enum { XmA_MOTIF_DROP, XmA_MOTIF_EXPORT_TARGETS, NUM_ATOMS };
  static char *atom_names[] = { XmS_MOTIF_DROP, XmS_MOTIF_EXPORT_TARGETS };

  Arg *args;
  int arg_count;
  XtPointer targets;
  unsigned long size;
  Atom type;
  int format;
  Widget dragContext;
  ConvertContext cc;
  Atom atoms[XtNumber(atom_names)];
  _XmWidgetToAppContext(w);

  _XmAppLock(app);

  assert(XtNumber(atom_names) == NUM_ATOMS);
  XInternAtoms(XtDisplay(w), atom_names, XtNumber(atom_names), False, atoms);

  /* merge and copy arg list */
  arg_count = in_arg_count + 10;
  args = (Arg *) XtMalloc(sizeof(Arg) * arg_count);
  for(arg_count = 0; arg_count < in_arg_count; arg_count++)
    args[arg_count] = in_args[arg_count];

  arg_count = in_arg_count;

  ClearContextBlock(XtDisplay(w), atoms[XmA_MOTIF_DROP]);

  cc = LookupContextBlock(XtDisplay(w), atoms[XmA_MOTIF_DROP]);

  cc -> location_data = location_data;
  cc -> client_data = (XtPointer) w;

  XtSetArg(args[arg_count], XmNconvertProc, DragConvertHandler); 
  arg_count++;

  _XmConvertHandlerSetLocal();
  if (_XmConvertHandler(w, &atoms[XmA_MOTIF_DROP],
			&atoms[XmA_MOTIF_EXPORT_TARGETS],
			&type, &targets, &size, &format) == True) {
    XtSetArg(args[arg_count], XmNexportTargets, targets); arg_count++;
    XtSetArg(args[arg_count], XmNnumExportTargets, size); arg_count++;
  } else {
    /* Free copied arguments */
    XtFree((char*) args);
    XtFree((char*) targets);
    _XmAppUnlock(app);
    return(NULL);
  }

  XtSetArg(args[arg_count], XmNclientData, location_data); arg_count++;

  dragContext = XmDragStart(w, event, args, arg_count);
  cc -> drag_context = dragContext;

  /* Free copied arguments */
  XtFree((char*) args);
  XtFree((char*) targets);

  _XmAppUnlock(app);
  return(dragContext);
}


/****************************************************************/
/* Destination section						*/
/* 								*/
/****************************************************************/

/* internal flag for transfer block setup */
static int TB_internal = 0;

Boolean
_XmDestinationHandler(Widget wid, Atom selection, XtEnum op,
		      XmSelectionFinishedProc done_proc,
		      XtPointer location_data, Time time,
		      XSelectionRequestEvent *event)
{
  Window selection_owner;
  TransferContext tc;
  XmDestinationCallbackStruct *cbstruct;
  XmTransferTrait ttrait;
  Atom MOTIF_DROP = XInternAtom(XtDisplay(wid), XmS_MOTIF_DROP, False);

  cbstruct = (XmDestinationCallbackStruct *) 
    XtMalloc(sizeof(XmDestinationCallbackStruct));

  cbstruct -> reason = XmCR_OK;
  cbstruct -> event = (XEvent *) event;
  cbstruct -> selection = selection;
  cbstruct -> flags = 0;
  cbstruct -> operation = op;
  cbstruct -> location_data = location_data;
  cbstruct -> destination_data = NULL;
  cbstruct -> time = time;

  /* Setup transfer */
  cbstruct -> transfer_id = (XtPointer) GetTransferID();
  tc = (TransferContext) cbstruct -> transfer_id;
  tc -> widget = wid;
  tc -> numDoneProcs = 0;
  tc -> doneProcs = NULL;
  tc -> auto_proc = (XtCallbackProc) NULL;
  tc -> status = XmTRANSFER_DONE_DEFAULT;
  tc -> flags = TC_NONE;
  tc -> selection = selection;
  tc -> real_selection = selection;
  tc -> op = op;
  tc -> client_data = NULL;
  tc -> drop_context = (Widget) NULL;
  tc -> drag_context = (Widget) NULL;
  tc -> callback_struct = cbstruct;

  if (done_proc != NULL)
    XmeTransferAddDoneProc((XtPointer) tc, done_proc);

  ttrait = (XmTransferTrait) 
    XmeTraitGet((XtPointer) XtClass(wid), XmQTtransfer);

  if (tc -> selection == MOTIF_DROP) {
    /* We pass the drop callback struct in through location_data */
    XmDropProcCallbackStruct *ds = (XmDropProcCallbackStruct *) location_data;
    XtPointer malloc_ds;
    int i;
    Arg args[1];

    malloc_ds = XtMalloc(sizeof(XmDropProcCallbackStruct));
    memcpy(malloc_ds, ds, sizeof(XmDropProcCallbackStruct));
    location_data = malloc_ds;
    XmeTransferAddDoneProc((XtPointer) tc, DeleteDropCBStruct);
    tc -> drag_context = ds -> dragContext;

    i = 0;
    XtSetArg(args[i], XmNiccHandle, &tc -> real_selection); i++;
    XtGetValues(ds->dragContext, args, i);

    /* If this is a drop,  we need to do more to figure out who
       really owns the selection */
    selection_owner = XGetSelectionOwner(XtDisplay(wid), tc -> real_selection);
    if (XtWindowToWidget(XtDisplay(wid), selection_owner) != (Widget) NULL) {
      ConvertContext cc;
      cc = LookupContextBlock(XtDisplay(wid), MOTIF_DROP);

      /* We go get the origination information if this is in the same
	 client as the originator.  We know its the same client if
	 XtWindowToWidget is successful */
      if (cc -> client_data == (XtPointer) wid)
	cbstruct -> flags |= XmCONVERTING_SAME;
    }

    /* We pass this callback struct on through destination_data
       and get new data from the widget trait for location_data */
    cbstruct -> destination_data = location_data;
    cbstruct -> location_data = NULL;
  } else { /* Not D&D */
    /* For regular selections,  we can just use this info,  otherwise
       we need to get the real selection atom for D&D */
    selection_owner = XGetSelectionOwner(XtDisplay(wid), selection);
    if (selection_owner == XtWindow(wid))
      cbstruct -> flags |= XmCONVERTING_SAME;
  }

  /* Call the prehook to allow the widget to setup information.  This
     is currently only envisioned to be useful in D&D */
  if (ttrait != NULL && ttrait -> destinationPreHookProc != NULL)
    ttrait -> destinationPreHookProc(wid, NULL, cbstruct);

    /* First we call any destination callbacks */
  if (XtHasCallbacks(wid, XmNdestinationCallback) == XtCallbackHasSome)
    XtCallCallbacks(wid, XmNdestinationCallback, cbstruct);

  tc -> flags |= TC_CALLED_CALLBACKS;

  /* Now lookup the trait on this widget and call the
     internal routine if there were no transfers via the
     destination callbacks (or no destination callbacks) or
     there were transfers and the user set the status to
     DEFAULT and has finished (if it hasn't finished we'll
     handle this in SelectionCallbackWrapper) */
  if (ttrait != NULL &&
      tc -> status == XmTRANSFER_DONE_DEFAULT &&
      ((tc -> count == 0) ||
       (tc -> outstanding == 0 &&
	! (TC_CALLED_WIDGET)))) {
    _XmProcessLock();
    TB_internal = 1;
    _XmProcessUnlock();
    tc -> flags |= TC_CALLED_WIDGET;
    if (ttrait -> destinationProc != 0)
      ttrait -> destinationProc(wid, NULL, cbstruct);
    _XmProcessLock();
    TB_internal = 0;
    _XmProcessUnlock();
  }
  
  if (tc -> count == 0 &&
      tc -> selection == MOTIF_DROP) {
    XmDropProcCallbackStruct *ds = (XmDropProcCallbackStruct *) location_data;

    if (ds -> dropAction == XmDROP_HELP) {
      /* If a drop help occured, then we do not want to cleanup yet,
	 despite there being no transfers.  Right at this moment,
	 the user is deciding whether to accept or cancel the drop
	 based on the presented dialog. */
      tc -> flags |= TC_EXITED_DH; /* Indicate safe to free record */
      /* Exit immediately to avoid freeing the transfer block below */
      return(True);
    } else {
      /* If no transfers occurred,  and this is a drop,
	 then it failed */
      Arg args[2];
      XtSetArg(args[0], XmNtransferStatus, XmTRANSFER_FAILURE);
      XtSetArg(args[1], XmNnumDropTransfers, 0);
      XmDropTransferStart(tc -> drag_context, args, 2);
    }
  }

  /* If we either have performed no transfers or we are finished
     with the transfers,  go finish the work */
  if (tc -> count == 0 || tc -> outstanding == 0)
    {
      FinishTransfer(wid, tc);
      return(True);
    }
  else {
    /* Otherwise set the flag so SelectionCallbackWrapper can 
       finish the work */
    tc -> flags |= TC_EXITED_DH; /* Indicate safe to free record */
    return(True);
  }
}

static void
FinishTransfer(Widget wid, TransferContext tc)
{
  XmTransferDoneCallbackStruct ts;

  tc -> flags |= TC_FLUSHED;  /* Ignore any future requests */
  ts.reason = XmCR_OK;
  ts.event = (XEvent *) NULL;
  ts.selection = tc -> selection;
  ts.transfer_id = (XtPointer) tc;

  if (tc -> status == XmTRANSFER_DONE_FAIL)
    ts.status = XmTRANSFER_DONE_FAIL;
  else
    ts.status = XmTRANSFER_DONE_SUCCEED;

  /* Override if no transfers have occurred */
  if (tc -> count == 0) ts.status = XmTRANSFER_DONE_FAIL;

  ts.client_data = tc -> client_data;

  CallDoneProcs(wid, tc, &ts);
  XtFree((char*) tc -> callback_struct);
  FreeTransferID(tc);
}

/****************************************************************/
/* DropDestinationHandler acts as a wrapper to the destination  */
/* handler for drag and drop.  This is because drag and drop    */
/* passes the DragContext as the widget to the destination proc */
/* in the drop							*/
/****************************************************************/

/*ARGSUSED*/
static void 
DeleteDropCBStruct(Widget w,	/* unused */
		   XtEnum ignored_status, /* unused */
		   XmTransferDoneCallbackStruct *cs)
{
  TransferContext tc = (TransferContext) cs -> transfer_id;

  /* The malloc'd structure is in the destination_data member */
  XtFree((char*) tc -> callback_struct -> destination_data);
}

/*ARGSUSED*/
static void 
DropDestinationHandler(Widget w, 
		       XtPointer client_data, /* unused */
		       XmDropProcCallbackStruct *ds)
{
  Atom MOTIF_DROP = XInternAtom(XtDisplay(w), XmS_MOTIF_DROP, False);
  XtEnum op;

  if (ds -> dropAction == XmDROP_HELP ||
      ds -> operation == XmDROP_NOOP)
    op = XmOTHER;
  else
    op = ds -> operation;

  (void) _XmDestinationHandler(w, MOTIF_DROP, op, NULL,
			       (XtPointer) ds, ds -> timeStamp, NULL);
}


/*************************************************************/
/* XmePrimarySink begins a transfer for the contents of the  */
/* XA_PRIMARY selection.                                     */
/*************************************************************/
Boolean
XmePrimarySink(Widget w, XtEnum op, XtPointer location_data, Time time)
{
  Boolean ret_val;
  _XmWidgetToAppContext(w);

  _XmAppLock(app);
  ret_val = _XmDestinationHandler(w, XA_PRIMARY, op, NULL,
			       location_data, time, NULL);
  _XmAppUnlock(app);
  return ret_val;
}

/*************************************************************/
/* XmeNamedSink begins a transfer for the contents of the    */
/* named selection.                                          */
/*************************************************************/
Boolean
XmeNamedSink(Widget w, Atom sel, XtEnum op, XtPointer location_data, Time time)
{
  Boolean ret_val;
  _XmWidgetToAppContext(w);

  _XmAppLock(app);
  ret_val = _XmDestinationHandler(w, sel, op, NULL,
			       location_data, time, NULL);
  _XmAppUnlock(app);
  return ret_val;
}

/*************************************************************/
/* XmeSecondarySink takes ownership of the MOTIF_DESTINATION */
/* selection.                                                */
/*************************************************************/
Boolean
XmeSecondarySink(Widget w, Time time)
{
  Boolean status;
  Atom MOTIF_DESTINATION = XInternAtom(XtDisplay(w), XmS_MOTIF_DESTINATION, False);
  _XmWidgetToAppContext(w);

  _XmAppLock(app);
  ClearContextBlock(XtDisplay(w), MOTIF_DESTINATION);

  if (time == 0) time = XtLastTimestampProcessed(XtDisplay(w));

  /* Setup our end of the secondary selection */

  status = XtOwnSelection(w, MOTIF_DESTINATION, time,
			  _XmConvertHandler, LoseProc, NULL);

  if (status) XtAddCallback(w, XmNdestroyCallback, DisownCallback,
			    (XtPointer) MOTIF_DESTINATION);

  _XmAppUnlock(app);
  return(status);
}

/**************************************************************/
/* XmeClipboardSink begins a transfer for the contents of the */
/* CLIPBOARD selection.                                       */
/**************************************************************/
Boolean
XmeClipboardSink(Widget w, XtEnum op, XtPointer location_data)
{
  Atom CLIPBOARD = XInternAtom(XtDisplay(w), XmSCLIPBOARD, False);
  Boolean ret_val;
  _XmWidgetToAppContext(w);

  _XmAppLock(app);
  ret_val = _XmDestinationHandler(w, CLIPBOARD, op,
			       NULL, location_data, 0, NULL);
  _XmAppUnlock(app);
  return ret_val;
}

/*************************************************************/
/* XmeDropSink creates a drop site that will use the         */
/* destinationCallbacks to handle drops.                     */
/*************************************************************/
void
XmeDropSink(Widget w, ArgList in_args, Cardinal in_arg_count)
{
  Arg *args;
  int arg_count;
  _XmWidgetToAppContext(w);

  _XmAppLock(app);
  /* merge and copy arg list */
  arg_count = in_arg_count + 2;
  args = (Arg *) XtMalloc(sizeof(Arg) * arg_count);
  for(arg_count = 0; arg_count < in_arg_count; arg_count++)
    args[arg_count] = in_args[arg_count];

  arg_count = in_arg_count;

  XtSetArg(args[arg_count], XmNdropProc, DropDestinationHandler); 
  arg_count++;

  XmDropSiteRegister(w, args, arg_count);

  XtFree((char*) args);
  _XmAppUnlock(app);
}


/*************************************************************/
/* Transfer routine section                                  */
/*************************************************************/

/************************************************************************/
/* XmTransferDone allows the user to control the transfer queue		*/
/* If the user calls XmTransferDone with a status of DEFAULT then	*/
/* all remaining non-internal transfers are ignored and the widget's    */
/* internal transfers are done.   SUCCEED, FAIL or CONTINUE cause the   */
/* entire queue to be flushed,  and the appropriate status to be set.   */
/************************************************************************/
void
XmTransferDone(XtPointer transfer_id, XmTransferStatus status)
{
  TransferContext tc = (TransferContext) transfer_id;
  Atom MOTIF_DROP = XInternAtom(XtDisplay(tc -> widget), XmS_MOTIF_DROP, False);
  _XmWidgetToAppContext(tc->widget);

  _XmAppLock(app);
  tc -> status = status;

  /* Make sure MULTIPLE request is unblocked */
  if (tc -> flags & TC_IN_MULTIPLE) {
    tc -> flags &= ~ TC_IN_MULTIPLE;
    XtSendSelectionRequest(tc -> widget, tc -> selection, 
			   XtLastTimestampProcessed(XtDisplay(tc -> widget)));
  }

  if (status == XmTRANSFER_DONE_SUCCEED ||
      status == XmTRANSFER_DONE_FAIL ||
      status == XmTRANSFER_DONE_CONTINUE) 
    {
      tc -> flags |= TC_FLUSHED;

      if (status == XmTRANSFER_DONE_FAIL &&
	  tc -> selection == MOTIF_DROP) {
	Arg args[2];
	XtSetArg(args[0], XmNtransferStatus, XmTRANSFER_FAILURE);
	XtSetArg(args[1], XmNnumDropTransfers, 0); 
	if (tc -> drop_context != (Widget) NULL)
	  XtSetValues(tc -> drop_context, args, 2);
	else
	  XmDropTransferStart(tc -> drag_context, args, 2);

	/* Also,  if there are no transfers,  and we have exited
	   _XmDestinationHandler,  we must cleanup the transfer
	   infomation here as SelectionCallbackWrapper,  where the
	   data is normally freed, won't be called */
	if (tc -> count == 0 &&
	    tc -> flags & TC_EXITED_DH ) {
	  FinishTransfer(tc -> widget, tc);
	}
      }
    }
  else if (status == XmTRANSFER_DONE_DEFAULT) 
    {
      TransferBlock tb;
      
      /* If we are going to default then we'll skip
	 all requests placed by callbacks */
      for(tb = tc -> requests; 
	  tb != NULL;
	  tb = (TransferBlock) tb -> next) {
	if (!(tb -> flags & TB_INTERNAL))
	  tb -> flags = tb -> flags | TB_IGNORE;
      }
    }
  _XmAppUnlock(app);
}

/************************************************************************/
/* XmTransferSetParameters defines a set of parameters to be passed     */
/* with the next call to XmTransferValue.				*/
/************************************************************************/

void
XmTransferSetParameters(XtPointer transfer_id, 
			XtPointer parm, 
			int parm_fmt,
			unsigned long parm_length, 
			Atom parm_type)
{
  TransferContext tc = (TransferContext) transfer_id;
  _XmWidgetToAppContext(tc->widget);

  _XmAppLock(app);
  /******************************************************/
  /* Return if we already finished this transfer set    */
  /* The problem is that if the flags are set then we   */
  /* are about to delete the transferContext in         */
  /* SelectionCallbackWrapper()                         */
  /******************************************************/
  if (tc -> flags & TC_FLUSHED) {
	_XmAppUnlock(app);
	return;
  }

  if (parm_fmt == 0) parm_fmt = 8;

  if (parm != NULL)
    XtSetSelectionParameters(tc -> widget, tc -> real_selection,
			     parm_type, parm, parm_length, parm_fmt);
  _XmAppUnlock(app);
}

/************************************************************************/
/* XmTransferValue allows the user to get data from the owner of the    */
/* selection for which we started the destination callback.		*/
/* This takes care of the small details for getting the data from 	*/
/* either the selection mechanism (user, PRIMARY, SECONDARY, or		*/
/* CLIPBOARD) or from another mechanism (Drag and Drop).		*/
/************************************************************************/

void 
XmTransferValue(XtPointer transfer_id,
		Atom target,
		XtCallbackProc proc, 
		XtPointer client_data, 
		Time time)
{
  enum { XmACLIPBOARD, XmA_MOTIF_DROP, NUM_ATOMS };
  static char *atom_names[] = { XmSCLIPBOARD, XmS_MOTIF_DROP };

  TransferContext tc = (TransferContext) transfer_id;
  TransferBlock tb;
  unsigned long length;
  Atom atoms[XtNumber(atom_names)];
  _XmWidgetToAppContext(tc->widget);

  _XmAppLock(app);
  /******************************************************/
  /* Return if we already finished this transfer set    */
  /* The problem is that if the flags are set then we   */
  /* are about to delete the transferContext in         */
  /* SelectionCallbackWrapper()                         */
  /******************************************************/
  if (tc -> flags & TC_FLUSHED) {
	_XmAppUnlock(app);
	return;  
  }

  assert(XtNumber(atom_names) == NUM_ATOMS);
  XInternAtoms(XtDisplay(tc -> widget), atom_names, XtNumber(atom_names), 
	       False, atoms); 

  if (time == 0)
    time = XtLastTimestampProcessed(XtDisplay(tc -> widget));  

  tb = AddTransferBlock(tc);

  tb -> client_data = client_data;
  tb -> selection_proc = proc;
  tb -> target = target;
  tb -> location_data = NULL;

  tc -> outstanding++;
  tc -> count++;

  if (tc -> selection == atoms[XmACLIPBOARD]) {
    /* Assure the clipboard is owned to prevent orphan data
       problems in the data transfer */
    XmClipboardInquireLength(XtDisplay(tc -> widget), 
			     XtWindow(tc -> widget),
			     XmSTARGETS,
			     &length);
  }

  if (tc -> selection != atoms[XmA_MOTIF_DROP]) 
    {
      XtGetSelectionValue(tc -> widget, tc -> real_selection, target,
			  SelectionCallbackWrapper, (XtPointer)tc, time);
    }
  else
    {
      XmDropTransferEntryRec transfers[1];

      transfers[0].client_data = (XtPointer) tc;
      transfers[0].target = tb -> target;
      if (tc -> drop_context == NULL)
	{
	  Arg args[5];

	  XtSetArg(args[0], XmNdropTransfers, transfers);
	  XtSetArg(args[1], XmNnumDropTransfers, 1);
	  XtSetArg(args[2], XmNtransferProc, SelectionCallbackWrapper);
	  tc -> drop_context = 
	    (Widget) XmDropTransferStart(tc -> drag_context, args, 3);
	}
      else
	XmDropTransferAdd(tc -> drop_context, transfers, 1);
    }
  _XmAppUnlock(app);
}


/************************************************************************/
/* XmTransferStartRequest and XmTransferSendRequest bracket a MULTIPLE	*/
/* request.  In between the user calls XmTransferSetParameters and 	*/
/* XmTransferValue to arrange requests.					*/
/************************************************************************/
void
XmTransferStartRequest(XtPointer transfer_id)
{
  TransferContext tc = (TransferContext) transfer_id;
  _XmWidgetToAppContext(tc->widget);

  _XmAppLock(app);
  /******************************************************/
  /* Return if we already finished this transfer set    */
  /* The problem is that if the flags are set then we   */
  /* are about to delete the transferContext in         */
  /* SelectionCallbackWrapper()                         */
  /******************************************************/
  if (tc -> flags & TC_FLUSHED) {
	_XmAppUnlock(app);
	return;  
  }

  if (tc -> flags & TC_IN_MULTIPLE) {
    char *sel;
    FreeType howFree;

    sel = GetSafeAtomName(XtDisplay(tc -> widget), tc -> selection, &howFree);
    /* Already doing a multiple */
    TransferWarning(tc->widget, START_MULTIPLE,
		    sel, 
		    ERROR_MULTIPLE_IN_PROGRESS);
    FreeSafeAtomName(sel,howFree);
    _XmAppUnlock(app);
    return;
  }

  tc -> flags |= TC_IN_MULTIPLE;

  XtCreateSelectionRequest(tc -> widget, tc -> real_selection);
  _XmAppUnlock(app);
}

void 
XmTransferSendRequest(XtPointer transfer_id, Time time)
{
  TransferContext tc = (TransferContext) transfer_id;
  _XmWidgetToAppContext(tc->widget);

  _XmAppLock(app);
  /******************************************************/
  /* Return if we already finished this transfer set    */
  /* The problem is that if the flags are set then we   */
  /* are about to delete the transferContext in         */
  /* SelectionCallbackWrapper()                         */
  /******************************************************/
  if (tc -> flags & TC_FLUSHED) {
    /* Assume that cleanup would be appropriate here */
    XtCancelSelectionRequest(tc -> widget, tc -> real_selection);
    _XmAppUnlock(app);
    return;  
  }

  if (! (tc -> flags & TC_IN_MULTIPLE)) {
    char     *sel;
    FreeType howFree;

    sel = GetSafeAtomName(XtDisplay(tc -> widget), tc -> selection, &howFree);
    /* Not doing a multiple */
    TransferWarning(tc->widget, END_MULTIPLE,
		    sel, 
		    ERROR_MULTIPLE_NOT_IN_PROGRESS);
    FreeSafeAtomName(sel, howFree);
    _XmAppUnlock(app);
    return;
  }

  tc -> flags &= ~ TC_IN_MULTIPLE;

  if (time == 0) time = XtLastTimestampProcessed(XtDisplay(tc -> widget));

  XtSendSelectionRequest(tc -> widget, tc -> real_selection, time);
  _XmAppUnlock(app);
}

/************************************************************************/
/* SelectionCallbackWrapper does the bookeeping for the transfer 	*/
/* routines and makes sure that the TransferContext is deleted when 	*/
/* there are no more outstanding transfers.				*/
/************************************************************************/
static void 
SelectionCallbackWrapper(Widget wid, XtPointer client_data, 
			 Atom *selection, Atom *type,
			 XtPointer value, unsigned long *length,
			 int *format)
{
  enum { XmA_MOTIF_DROP, XmADELETE, NUM_ATOMS };
  static char *atom_names[] = { XmS_MOTIF_DROP, XmSDELETE };

  XmSelectionCallbackStruct cbstruct;
  TransferContext tc = (TransferContext) client_data;
  TransferBlock tb = tc -> requests;
  Atom atoms[XtNumber(atom_names)];

  assert(XtNumber(atom_names) == NUM_ATOMS);
  XInternAtoms(XtDisplay(wid), atom_names, XtNumber(atom_names), False, atoms);

  /* Get the real widget if this is a drop transfer */
  if (tc -> selection == atoms[XmA_MOTIF_DROP])
    wid = tc -> widget;

  if (tc -> outstanding == 0) {
    XmeWarning(wid, BAD_SCB_MESSAGE);
    return;
  }

  if (tb != NULL) {
    /* Unchain this transfer block */
    tc -> requests = (TransferBlock) tb -> next;
    /* If this is the last block then reset last */
    if (tc -> last == tb) tc -> last = NULL;
  }

  if (! (tc -> flags & TC_FLUSHED)) {
    if (tb != NULL && 
	! (tb -> flags & TB_IGNORE)) {
      cbstruct.reason = XmCR_OK;
      cbstruct.event = (XEvent *) NULL;
      cbstruct.selection = *selection;
      cbstruct.target = tb -> target;
      cbstruct.transfer_id = (XtPointer) tc;
      cbstruct.flags = XmSELECTION_DEFAULT;
      cbstruct.remaining = tc -> outstanding;
      cbstruct.type = *type;
      cbstruct.value = value;
      cbstruct.length = *length;
      cbstruct.format = *format;

      if (tb -> selection_proc != NULL)
	tb -> selection_proc(wid, tb -> client_data, &cbstruct);
    }
  }


  /* Free this transfer block */
  if (tb != NULL) {
    XtFree((char*) tb);
  }

  /* Ignore callbacks after we're done */
  tc -> outstanding--;

  /* When outstanding is 0,  check to see if the status is
     XmTRANSFER_DONE_DEFAULT.  This indicates that we
     should attempt calling the widget's destination
     proc.  We'll set a flag in tc to indicate that
     we've done this,  so we don't repeat the action */
  if (tc -> outstanding == 0 &&
      tc -> status == XmTRANSFER_DONE_DEFAULT &&
      tc -> flags & TC_CALLED_CALLBACKS &&
      !(tc -> flags & TC_CALLED_WIDGET)) {
    XmTransferTrait ttrait;

    tc -> flags |= TC_CALLED_WIDGET;
    ttrait = (XmTransferTrait) 
      XmeTraitGet((XtPointer) XtClass(wid), XmQTtransfer);

    /* Now lookup the trait on this widget and call the
       internal routine. */
    if (ttrait != NULL) {
    _XmProcessLock();
      TB_internal = 1;
    _XmProcessUnlock();
      if (ttrait -> destinationProc != 0)
	ttrait -> destinationProc(wid, NULL, tc -> callback_struct);
    _XmProcessLock();
      TB_internal = 0;
    _XmProcessUnlock();
    }
  }

  /* Send a delete if this is a move operation and we've complete
     successfully for PRIMARY transfer */
  if (tc -> selection == XA_PRIMARY &&
      tc -> outstanding == 0 &&
      tc -> count != 0 &&
      (tc -> status == XmTRANSFER_DONE_SUCCEED ||
       tc -> status == XmTRANSFER_DONE_DEFAULT) &&
      tc -> op == XmMOVE &&
      ! (tc -> flags & TC_DID_DELETE)) {
    tc -> flags |= TC_DID_DELETE;
    XmTransferValue((XtPointer) tc, atoms[XmADELETE], NULL, NULL,
		    XtLastTimestampProcessed(XtDisplay(wid)));
  }

  /* When outstanding reaches 0,  free context block.  But don't
     do this in the local case.  There we can free in the caller, 
     so check the TC_EXITED_DH flag to see if we've exited
     _XmDestinationHandler yet. */
  if (tc -> outstanding == 0 &&
      tc -> flags & TC_EXITED_DH ) {
    FinishTransfer(wid, tc);
  }
}

/**********************************************************/
/* Context block handlers for convert and transfer blocks */
/**********************************************************/

typedef struct __XmCCKey {
  Display *display;
  Atom	  selection;
} _XmCCKeyRec, *_XmCCKey;

static Boolean
CCMatch(XtPointer x, XtPointer y) 
{
  _XmCCKey a, b;

  a = (_XmCCKey) x;
  b = (_XmCCKey) y;

  return(a -> display   ==  b -> display &&
	 a -> selection ==  b -> selection);
}

static XmHashValue
CCHash(XtPointer x)
{
  _XmCCKey a;

  a = (_XmCCKey) x;

  return((XmHashValue) ((long) a -> display + (long) a -> selection));
}

static XmHashTable ConvertHashTable = (XmHashTable) NULL;

static ConvertContext
LookupContextBlock(Display *d, Atom a)
{
  ConvertContext cc;
  _XmCCKeyRec x;

  x.display = d;
  x.selection = a;

  _XmProcessLock();
  if (ConvertHashTable == (XmHashTable) NULL) 
    ConvertHashTable = _XmAllocHashTable(10, CCMatch, CCHash);

  cc = (ConvertContext) _XmGetHashEntry(ConvertHashTable, (XmHashKey) &x);
  _XmProcessUnlock();

  if (cc == NULL) {
    _XmCCKey new_k;

    new_k = (_XmCCKey) XtMalloc(sizeof(_XmCCKeyRec));
    new_k -> display = d;
    new_k -> selection = a;

    /* Allocate a context block for this selection */
    cc = (ConvertContext) XtMalloc(sizeof(ConvertContextRec));
    _XmProcessLock();
    _XmAddHashEntry(ConvertHashTable, (XmHashKey)new_k, (XtPointer)cc);
    _XmProcessUnlock();
  }

  return(cc);
}

static void
ClearContextBlock(Display *d, Atom a)
{
  ConvertContext cc;
  
  cc = LookupContextBlock(d, a);

  cc -> flags = 0;
  cc -> op = 0;
  cc -> itemid = 0;
  cc -> location_data = NULL;
  cc -> client_data = NULL;
  cc -> drag_context = (Widget) NULL;
}

/* Functions to get and free transfer ids */

static TransferContext global_tc = NULL;
static TransferContext free_tc = NULL;

static XtPointer 
GetTransferID(void)
{
  TransferContext rval;

  /* If there is one on the free list,  unchain it
     and return it */

  _XmProcessLock();
  if (free_tc != NULL) 
    {
      rval = free_tc;
      free_tc = (TransferContext) rval -> next;
    }
  else
    rval = (TransferContext) XtMalloc(sizeof(TransferContextRec));

  /* Put it on the chain */

  rval -> next = (XtPointer) global_tc;
  rval -> prev = NULL;

  if (global_tc != NULL) global_tc -> prev = (XtPointer) rval;
  global_tc = rval;
  _XmProcessUnlock();

  /* Initialize */
  rval -> outstanding = 0;
  rval -> count = 0;
  rval -> flags = TC_NONE;
  rval -> requests = NULL;
  rval -> last = NULL;

  return((XtPointer) rval);
}

static void
FreeTransferID(XtPointer id)
{
  TransferContext tid = (TransferContext) id;
  TransferContext pid, nid;

  /* Free done_proc list */
  if (tid -> doneProcs != NULL) XtFree((char*) tid -> doneProcs);

  /* first unchain from global_tc */

  if (global_tc == tid) 
    {
      _XmProcessLock();
      global_tc = (TransferContext) tid -> next;
      if (global_tc != NULL)
	global_tc -> prev = NULL;
      _XmProcessUnlock();
    }
  else
    {
      /* Get previous and next */
      pid = (TransferContext) tid -> prev;
      nid = (TransferContext) tid -> next;
      /* Connect prev and next */
      if (pid != NULL) pid -> next = (XtPointer) nid;
      if (nid != NULL) nid -> prev = (XtPointer) pid;
    }

  _XmProcessLock();
  /* Put on free list */
  tid -> next = (XtPointer) free_tc;
  free_tc = tid;
  _XmProcessUnlock();
}

static void
CallDoneProcs(Widget wid, XtPointer id, XmTransferDoneCallbackStruct *ts)
{
  int i;
  TransferContext tid = (TransferContext) id;

  for(i = 0; i < tid -> numDoneProcs; i++) {
    (tid -> doneProcs[i])(wid, tid -> op, ts);
  }
}

static TransferBlock
AddTransferBlock(TransferContext tc)
{
  TransferBlock tb;

  tb = (TransferBlock) XtMalloc(sizeof(TransferBlockRec));
  tb -> next = NULL;
  /* we append blocks to the end of the list */
  if (tc -> requests == NULL) 
    {
      tc -> requests = tb;
      tc -> last = tb;
    }
  else 
    {
      (tc -> last) -> next = (XtPointer) tb;
      tc -> last = tb;
    }

  _XmProcessLock();
  if (TB_internal)
    tb -> flags = TB_INTERNAL;
  else
    tb -> flags = TB_NONE;
  _XmProcessUnlock();

  return(tb);
}

/* Warning routine */
static void 
TransferWarning(Widget w, char* name, char* type, char* message)
{
  XmeWarning(w, message);
}

/****************************************************************/
/* Standard target support					*/
/*								*/
/* This support makes it easy for all widgets to support a set	*/
/* of targets which can be automatically converted to.		*/
/*								*/
/****************************************************************/

/* 
 * XmeStandardTargets takes a widget, and a count of the widget's
 * private target list, and returns a list of standard targets.
 * The count of standard targets is returned in the passed in
 * integer
 */

#define MAXBUILTIN 12

Atom*
XmeStandardTargets(Widget w, int count, int *tcount)
{
  enum { XmATARGETS, XmATIMESTAMP, XmAFOREGROUND, XmABACKGROUND,
	 XmACLASS, XmANAME, XmACLIENT_WINDOW, XmA_MOTIF_RENDER_TABLE,
	 XmA_MOTIF_ENCODING_REGISTRY, NUM_ATOMS };
  static char *atom_names[] = {
    XmSTARGETS, XmSTIMESTAMP, XmIFOREGROUND, XmIBACKGROUND,
    XmICLASS, XmINAME, XmSCLIENT_WINDOW, XmS_MOTIF_RENDER_TABLE,
    XmS_MOTIF_ENCODING_REGISTRY };

  int i = 0;
  Atom atoms[XtNumber(atom_names)];
  Atom *targets;
  _XmWidgetToAppContext(w);

  _XmAppLock(app);
  targets = (Atom *) XtMalloc(sizeof(Atom) * MAXBUILTIN);

  assert(XtNumber(atom_names) == NUM_ATOMS);
  XInternAtoms(XtDisplay(w), atom_names, XtNumber(atom_names), False, atoms);

  targets[i] = atoms[XmATARGETS]; i++;
  targets[i] = atoms[XmATIMESTAMP]; i++;
  targets[i] = atoms[XmAFOREGROUND]; i++;
  targets[i] = atoms[XmABACKGROUND]; i++;
  targets[i] = XA_COLORMAP; i++;
  targets[i] = atoms[XmACLASS]; i++;
  targets[i] = atoms[XmANAME]; i++;
  targets[i] = atoms[XmACLIENT_WINDOW]; i++;
  targets[i] = atoms[XmA_MOTIF_RENDER_TABLE]; i++;
  targets[i] = atoms[XmA_MOTIF_ENCODING_REGISTRY]; i++;

  /* Realloc the full size now */
  targets = (Atom *) XtRealloc((char*) targets, sizeof(Atom) * (count + i));

  *tcount = i; /* Return the builtin target count */
  _XmAppUnlock(app);
  return(targets);
}

/*
 * XmeStandardConvert is called when receiving an unknown
 * target.  It should be called last in most convert procs.
 */

/*ARGSUSED*/
void
XmeStandardConvert(Widget w, 
		   XtPointer ignore, /* unused */
		   XmConvertCallbackStruct *cs)
{
  enum { XmATARGETS, XmAFOREGROUND, XmAPIXEL, XmABACKGROUND,
	 XmACLASS, XmANAME, XmACLIENT_WINDOW, XmA_MOTIF_RENDER_TABLE,
	 XmA_MOTIF_ENCODING_REGISTRY, NUM_ATOMS };
  static char *atom_names[] = {
    XmSTARGETS, XmIFOREGROUND, XmIPIXEL, XmIBACKGROUND,
    XmICLASS, XmINAME, XmSCLIENT_WINDOW, XmS_MOTIF_RENDER_TABLE,
    XmS_MOTIF_ENCODING_REGISTRY };

  Arg arg[1];
  Atom atoms[XtNumber(atom_names)];
  _XmWidgetToAppContext(w);

  _XmAppLock(app);
  assert(XtNumber(atom_names) == NUM_ATOMS);
  XInternAtoms(XtDisplay(w), atom_names, XtNumber(atom_names), False, atoms);

  if (atoms[XmATARGETS] == cs -> target) {
    int tcount;
    cs -> value = (XtPointer) XmeStandardTargets(w, 0, &tcount);
    cs -> format = 32;
    cs -> length = tcount;
    cs -> type = XA_ATOM;
  } else if (atoms[XmAFOREGROUND] == cs -> target) {
    Pixel *fg;

    if (XmIsGadget(w)) w = XtParent(w);

    fg = (Pixel *) XtMalloc(sizeof(Pixel));
    XtSetArg(arg[0], XtNforeground, fg);
    XtGetValues(w, arg, 1);

    cs -> value = (XtPointer) fg;
    cs -> format = 32;
    cs -> length = 1;
    cs -> type = atoms[XmAPIXEL];
  } else if (atoms[XmABACKGROUND] == cs -> target) {
    Pixel *bg;

    if (XmIsGadget(w)) w = XtParent(w);

    bg = (Pixel *) XtMalloc(sizeof(Pixel));
    XtSetArg(arg[0], XtNbackground, bg);
    XtGetValues(w, arg, 1);

    cs -> value = (XtPointer) bg;
    cs -> format = 32;
    cs -> length = 1;
    cs -> type = atoms[XmAPIXEL];
  } else if (XA_COLORMAP == cs -> target) {
    Colormap *cmap;

    if (XmIsGadget(w)) w = XtParent(w);

    cmap = (Colormap *) XtMalloc(sizeof(Colormap));
    XtSetArg(arg[0], XtNcolormap, cmap);
    XtGetValues(w, arg, 1);

    cs -> value = (XtPointer) cmap;
    cs -> format = 32;
    cs -> length = 1;
    cs -> type = XA_COLORMAP;
  } else if (atoms[XmACLASS] == cs -> target) {
    Widget current;
    unsigned long bytesAfter;

    cs -> value = NULL;
    cs -> format = 32;
    cs -> length = 0;
    cs -> type = XA_INTEGER;

    for(current = w; 
	current != (Widget) NULL; 
	current = XtParent(current)) {
      if (XtIsShell(current)) {
	XGetWindowProperty(XtDisplay(current), XtWindow(current), 
			   XA_WM_CLASS, 0L, 100000L, False,
			   (Atom) AnyPropertyType, 
			   &cs -> type,
			   &cs -> format,
			   &cs -> length,
			   &bytesAfter,
			   (unsigned char**) &cs -> value);
	if (cs -> value != NULL) break;
      }
    }
  } else if (atoms[XmANAME] == cs -> target) {
    Widget current;
    unsigned long bytesAfter;
    Atom type;
    int format;
    unsigned char *value = NULL;
    char *total_value;
    unsigned long length;

    for(current = w; 
	current != (Widget) NULL; 
	current = XtParent(current)) {
      if (XtIsShell(current)) {
	XGetWindowProperty(XtDisplay(current), XtWindow(current), 
			   XA_WM_NAME, 0L, 100000L, False,
			   (Atom) AnyPropertyType, 
			   &type,
			   &format,
			   &length,
			   &bytesAfter,
			   &value);
	if (value != NULL) break;
      }
    }
    
    total_value = _XmTextToLocaleText(w, (XtPointer)value, type, 
				      format, length, NULL);
    
    cs -> value = (XtPointer) total_value;
    cs -> format = 8;
    cs -> length = total_value != NULL ? strlen(total_value) : 0;
    cs -> type = XmeGetEncodingAtom(w);
  } else if (atoms[XmACLIENT_WINDOW] == cs -> target) {
    Widget current;
    Window *cw;

    cw = (Window *) XtMalloc(sizeof(Window));
    for(current = w; current != (Widget) NULL; current = XtParent(current))
      if (XtIsShell(current)) break;

    *cw = XtWindow(current);
    cs -> value = (XtPointer) cw;
    cs -> format = 32;
    cs -> length = 1;
    cs -> type = XA_WINDOW;
  } else if (atoms[XmA_MOTIF_RENDER_TABLE] == cs -> target) {
    XmRenderTable table;
    Arg args[1];
    char *value;
    int size;

    table = (XmRenderTable) NULL;
    XtSetArg(args[0], XmNrenderTable, &table);
    XtGetValues(w, args, 1);

    if (table == NULL) {
      /* If we didn't find a render table on this widget, then
	 go ahead and look up the chain for something which 
	 does have one */
      table = XmeGetDefaultRenderTable(w, XmTEXT_RENDER_TABLE);
    }

    if (table != NULL) {
      size = XmRenderTableCvtToProp(w, table, &value);
      cs -> value = (XtPointer) value;
      cs -> format = 8;
      cs -> length = size;
      cs -> type = XA_STRING;
    }
  } else if (atoms[XmA_MOTIF_ENCODING_REGISTRY] == cs -> target) {
    int len;

    cs -> format = 8;
    cs -> type = XA_STRING;
    cs -> value = _XmGetEncodingRegistryTarget(&len);
    cs -> length = len;
  }
  _XmAppUnlock(app);
}

Atom
XmeGetEncodingAtom(Widget w)
{
  int ret_status = 0;
  XTextProperty tmp_prop;
  char * tmp_string = "ABC";  /* these are characters in XPCS, so... safe */
  Atom encoding;
  _XmWidgetToAppContext(w);

  _XmAppLock(app);
  tmp_prop.value = NULL; /* just in case X doesn't do it */
  ret_status = XmbTextListToTextProperty(XtDisplay(w), &tmp_string, 1,
					 (XICCEncodingStyle)XTextStyle, 
					 &tmp_prop);
  if (ret_status == Success)
    encoding = tmp_prop.encoding;
  else
    encoding = None;        /* XmbTextList... should always be able
			   * to convert XPCS characters; but in
			   * case its broken, this prevents a core
			   * dump.
			   */
  if (tmp_prop.value != NULL) XFree((char *)tmp_prop.value);
  _XmAppUnlock(app);
  return(encoding);
}


char *
_XmTextToLocaleText(Widget w,
		    XtPointer value,
		    Atom type,
		    int format,
		    unsigned long length,
		    Boolean *success)
{
  Atom COMPOUND_TEXT = XInternAtom(XtDisplay(w), XmSCOMPOUND_TEXT, False);
#ifdef UTF8_SUPPORTED
  Atom UTF8_STRING = XInternAtom(XtDisplay(w), XmSUTF8_STRING, False);
#endif
  XTextProperty text_prop;
  int status;
  char ** values;
  int num_values = 0;
  char *total_value = NULL;
  int malloc_size = 0;
  int i;

  if (type == XA_STRING || type == COMPOUND_TEXT
#ifdef UTF8_SUPPORTED
      || type == UTF8_STRING
#endif
     ) {
    text_prop.value = (unsigned char *) value;
    text_prop.encoding = type;
    text_prop.format = format;
    text_prop.nitems = length;

    status = XmbTextPropertyToTextList(XtDisplay(w), &text_prop, &values,
				       &num_values);

    if (success != NULL) {
      if (status == Success || status > 0)
	*success = True;
      else
	*success = False;
    }

    if (num_values) { 
      for (i = 0; i < num_values ; i++)
	malloc_size += strlen(values[i]);

      total_value = XtMalloc ((unsigned) malloc_size + 1);
      total_value[0] = '\0';
      for (i = 0; i < num_values ; i++)
	strcat(total_value, values[i]);
      XFreeStringList(values);
    }
  }
  return total_value;
}

void
_XmConvertComplete(Widget wid, XtPointer value, 
		   unsigned long size, int format, Atom type,
		   XmConvertCallbackStruct *cs)
{

  if (value == NULL && cs -> value == NULL) {
    XmeStandardConvert(wid, NULL, cs);
  } else {
    if (cs -> status == XmCONVERT_MERGE) {
      XmeConvertMerge(value, type, format,  size, cs);
      XtFree((char*) value);
    } else { 
      /* Not merging */
      if (cs -> value != NULL) XtFree((char*) cs -> value);
      cs -> type = type;
      cs -> value = value;
      cs -> length = size;
      cs -> format = format;
    }
  }

  if (cs -> value != NULL)
    cs -> status = XmCONVERT_DONE;
  else
    cs -> status = XmCONVERT_REFUSE;
}

XmDestinationCallbackStruct*
_XmTransferGetDestinationCBStruct(XtPointer tid)
{
  TransferContext tc = (TransferContext) tid;

  return(tc -> callback_struct);
}

/* Error handler for XGetAtomName */

static int SIF_ErrorFlag;
 
/*ARGSUSED*/
static int 
SIF_ErrorHandler(
     Display *display,		/* unused */
     XErrorEvent *event)

{
  _XmProcessLock();
  SIF_ErrorFlag = event -> type;
  _XmProcessUnlock();

  return 0;
}

/* NOTE! XGetAtomName return value MUST be freed with XFree; however, there
 ** isn't a good way to allocate data which can be freed with XFree. We could
 ** cache a static character pointer to NULL and check it to decide whether or
 ** not to free; for now, just pass information back on what to do with the
 ** returned value.
 */
static char* 
GetSafeAtomName(Display *display, Atom a, FreeType *howFree)
{
  XErrorHandler old_Handler;
  char *returnvalue;

  /* Setup error proc and reset error flag */
  old_Handler = XSetErrorHandler((XErrorHandler) SIF_ErrorHandler);
  _XmProcessLock();
  SIF_ErrorFlag = 0;
  _XmProcessUnlock();

  returnvalue = XGetAtomName(display, a);
  *howFree = DoXFree;

  XSetErrorHandler(old_Handler);

  _XmProcessLock();
  if (SIF_ErrorFlag != 0) {
    returnvalue = (char*) malloc(1);
    returnvalue[0] = 0; /* Create empty string to return */
    *howFree = DoFree;
    TransferWarning(NULL, ATOM, ARG, BAD_ATOM_MESSAGE);
  }
  _XmProcessUnlock();
  return(returnvalue);
}