/* $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);