/* 
 *  @OPENGROUP_COPYRIGHT@
 *  COPYRIGHT NOTICE
 *  Copyright (c) 1990, 1991, 1992, 1993 Open Software Foundation, Inc.
 *  Copyright (c) 1996, 1997, 1998, 1999, 2000 The Open Group
 *  ALL RIGHTS RESERVED (MOTIF). See the file named COPYRIGHT.MOTIF for
 *  the full copyright text.
 *  
 *  This software is subject to an open license. It may only be
 *  used on, with or for operating systems which are themselves open
 *  source systems. You must contact The Open Group for a license
 *  allowing distribution and sublicensing of this software on, with,
 *  or for operating systems which are not Open Source programs.
 *  
 *  See http://www.opengroup.org/openmotif/license for full
 *  details of the license agreement. Any use, reproduction, or
 *  distribution of the program constitutes recipient's acceptance of
 *  this agreement.
 *  
 *  EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
 *  PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *  KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY
 *  WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
 *  OR FITNESS FOR A PARTICULAR PURPOSE
 *  
 *  EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
 *  NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT,
 *  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *  DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED
 *  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 *  ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
 *  EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGES.
 */ 
/* 
 * HISTORY
*/ 
#ifdef REV_INFO
#ifndef lint
static char rcsid[] = "$TOG: CutPaste.c /main/27 1999/05/26 17:42:48 samborn $"
#endif
#endif
/* (c) Copyright 1989, DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. */
/* (c) Copyright 1987, 1988, 1989, 1990, 1991, 1992 HEWLETT-PACKARD COMPANY */

#define CUTPASTE

#include "XmI.h"		/* for MAX */
#include <Xm/CutPaste.h>
#include "MessagesI.h"
#include "CutPasteI.h"
#include <string.h>
#include <stdio.h>

#define XMERROR(key, message)                                            \
    XtErrorMsg (key, "xmClipboardError", "XmToolkitError", message, NULL, NULL)

#define XMRETRY 3
#define XM_APPEND 0
#define XM_REPLACE 1
#define XM_PREPEND 2

#define XM_HEADER_ID 0
#define XM_NEXT_ID   1
#define XM_LOCK_ID   2

#define XM_FIRST_FREE_ID 1000	/* First Item Id allocated */
#define XM_ITEM_ID_INC 1000	/* Increase in Item Id between each copy */
#define XM_ITEM_ID_MAX 5000	/* 'Safe' threshold for resetting Item Id */

#define XM_FORMAT_HEADER_TYPE 1
#define XM_DATA_ITEM_RECORD_TYPE 2
#define XM_HEADER_RECORD_TYPE 3

#define XM_UNDELETE 0
#define XM_DELETE 1

#define XM_DATA_REQUEST_MESSAGE 0
#define XM_DATA_DELETE_MESSAGE  1

#define XM_CLIPBOARD_MESSAGE1	_XmMMsgCutPaste_0000
#define XM_CLIPBOARD_MESSAGE2	_XmMMsgCutPaste_0001
#define XM_CLIPBOARD_MESSAGE3	_XmMMsgCutPaste_0002
#define CLIPBOARD_BAD_DATA_TYPE	_XmMMsgCutPaste_0003
#define BAD_DATA_TYPE		_XmMMsgCutPaste_0004
#define CLIPBOARD_CORRUPT	_XmMMsgCutPaste_0005
#define CORRUPT_DATA_STRUCTURE	_XmMMsgCutPaste_0006
/* #define CLIPBOARD_BAD_FORMAT	_XmMMsgCutPaste_0007	*/	/* unused */
#define BAD_FORMAT		_XmMMsgCutPaste_0008
#define BAD_FORMAT_NON_NULL	_XmMMsgCutPaste_0009


#define XM_STRING	 8
#define XM_COMPOUND_TEXT 8
#define XM_ATOM	32
#define XM_ATOM_PAIR	32 
#define XM_BITMAP	32
#define XM_PIXMAP	32
#define XM_DRAWABLE	32
#define XM_SPAN	32
#define XM_INTEGER	32
#define XM_WINDOW	32
#define XM_PIXEL	32
#define XM_COLORMAP	32
#define XM_TEXT	 8

#define MAX_SELECTION_INCR(dpy) (((65536 < XMaxRequestSize(dpy)) ? \
      (65536 << 2)  : (XMaxRequestSize(dpy) << 2))-100)

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

#define CONVERT_32_FACTOR (sizeof(unsigned long) / 4)

typedef long itemId;

typedef unsigned long timeStamp;

/*-----------------------------------------------------*/
/*   Define the clipboard selection information record */
/*-----------------------------------------------------*/

typedef struct _ClipboardSelectionInfo {
    long format;
    unsigned long count;
    char *data;
    Atom type;
    Boolean received;
    Boolean success;
} ClipboardSelectionInfoRec, *ClipboardSelectionInfo;

/*------------------------------------------------------------*/
/*   Define the clipboard property destroy information record */
/*------------------------------------------------------------*/

typedef struct _ClipboardDestroyInfo {

    Display *display;
    Window  window;
    Atom property;

} ClipboardDestroyInfoRec, *ClipboardDestroyInfo;

/*-------------------------------------------------------*/
/*   Define the clipboard cut by name information record */
/*-------------------------------------------------------*/

typedef struct _ClipboardCutByNameInfo {

    Window window;
    itemId formatitemid;

} ClipboardCutByNameInfoRec, *ClipboardCutByNameInfo;

/*---------------------------------------------------*/
/*   Define the clipboard format registration record */
/*---------------------------------------------------*/

typedef struct _ClipboardFormatRegRec {

    long formatLength;

} ClipboardFormatRegRec, *ClipboardFormatRegPtr;

/*-------------------------------------------*/
/*   Define the clipboard lock record        */
/*-------------------------------------------*/

typedef struct _ClipboardLockRec {

    Window windowId;
    long   lockLevel;

} ClipboardLockRec, *ClipboardLockPtr;

/*---------------------------------------------------*/
/*   Define the clipboard format item record         */
/*---------------------------------------------------*/

typedef struct _ClipboardFormatItemRec {

    long recordType;
    itemId parentItemId;/* this is the data item that owns the format */
    Display *displayId;	/* display id of application owning data */
    Window windowId;	/* window id for cut by name */
    Widget cutByNameWidget;    /* window id for cut by name */
    Window cutByNameWindow;    /* window id for cut by name */
    long cutByNameCBIndex;     /* address of callback routine for */
    			       /* cut by name data */
    long itemLength;	/* length of this format item data */
    itemId formatDataId;	/* id for format item data, */
    			        /* 0 if passed by name */
    Atom formatNameAtom;	/* format name atom */
    unsigned long formatNameLength;

    unsigned long cancelledFlag; /* format was cancelled by poster */
    unsigned long cutByNameFlag; /* data has not yet been provided */

    itemId thisFormatId;  /* id given application for identifying format item */
    itemId itemPrivateId; /* id provide by application for identifying item */

    unsigned long copiedLength;  /* amount already copied incrementally */

} ClipboardFormatItemRec, *ClipboardFormatItem;

/*-------------------------------------------------*/
/*   Define the clipboard data item record         */
/*-------------------------------------------------*/

typedef struct _ClipboardDataItemRec {

    long recordType;
    itemId adjunctData; /* for future compatibility */
    Display *displayId;	/* display id of application owning data */
    Window windowId;	/* window id for cut by name */

    itemId thisItemId;  /* item id of this data item */

    unsigned long dataItemLabelId; /* id of label (comp) string */
    unsigned long formatIdList;	 /* offset of beginning of format id list */
    long formatCount;		/* number of formats stored for this item */
    long cancelledFormatCount;	/* number of cut by name formats cancelled */

    unsigned long cutByNameFlag;  /* data has not yet been provided */
    unsigned long deletePendingFlag;	/* is item marked for deletion? */
    unsigned long permanentItemFlag;	/* is item permanent or temporary? */

    long cutByNameCBIndex;   /* address of callback routine for */
    					/* cut by name data */
    Widget cutByNameWidget;   /* widget receiving messages concerning */
    				      /* cut by name */
    Window cutByNameWindow;

} ClipboardDataItemRec, *ClipboardDataItem;

/*----------------------------------------------*/
/*   Define the clipboard header record         */
/*----------------------------------------------*/

typedef struct _ClipboardHeaderRec {

    long recordType;
    itemId adjunctHeader;	/* for future compatibility */
    unsigned long maxItems;	/* maximum number of clipboard items */
    				/* including those marked for delete */
    unsigned long dataItemList;	    /* offset of data item id list */

    itemId nextPasteItemId;    	/* data id of next item id to paste */
    itemId oldNextPasteItemId; 	/* data id of old next paste item id */
    itemId deletedByCopyId;	/* item marked deleted by last copy, if any */
    itemId lastCopyItemId;  /* item id of last item put on clipboard */
    itemId recopyId;        /* item id of item requested for recopy */
      
    unsigned long currItems;   /* current number of clipboard items */
    			       /* including those marked for delete */
    timeStamp   selectionTimestamp; /* for ICCCM clipboard selection compatability */
    timeStamp   copyFromTimestamp; /* time of event causing inquire or copy from */
    unsigned long foreignCopiedLength; /* amount copied so far in incr copy from */ 
			      /* selection */
    Window ownSelection;
    unsigned long incrementalCopyFrom;  /* requested in increments */

    unsigned long startCopyCalled;  /* to ensure that start copy is called
					before copy or endcopy */

} ClipboardHeaderRec, *ClipboardHeader;

/*---------------------------------------------*/

typedef union {
    ClipboardFormatItemRec format;
    ClipboardDataItemRec   item;
    ClipboardHeaderRec     header;
} ClipboardUnionRec, *ClipboardPointer;

/*---------------------------------------------*/
     
/********    Static Function Declarations    ********/

static Time ClipboardGetCurrentTime( 
                        Display *dpy) ;
static void ClipboardSetNextItemId( 
                        Display *display,
                        long itemid) ;
static Boolean WeOwnSelection( Display*, ClipboardHeader header );
static void AssertClipboardSelection( 
                        Display *display,
                        Window window,
                        ClipboardHeader header,
                        Time time) ;
static Boolean ClipboardConvertProc(Widget, Atom *, Atom *, Atom *, 
				 XtPointer *, unsigned long *, int *);
static Atom GetTypeFromTarget(Display*, Atom);
static Window InitializeSelection( 
                        Display *display,
                        ClipboardHeader header,
                        Window window,
                        Time time) ;
static int RegIfMatch( 
                        Display *display,
                        char *format_name,
                        char *match_name,
                        int format_length) ;
static int RegisterFormat( 
                        Display *display,
                        char *format_name,
                        int format_length) ;
static void ClipboardError( 
                        char *key,
                        char *message) ;
static void ClipboardEventHandler( 
                        Widget widget,
                        XtPointer closure,
                        XEvent *event,
                        Boolean *cont) ;
static int ClipboardFindItem( 
                        Display *display,
                        itemId itemid,
                        XtPointer *outpointer,
                        unsigned long *outlength,
			Atom *outtype,
                        int *format,
                        int rec_type) ;
static int GetWindowProperty( 
                        Display *display,
                        Window window,
                        Atom property_atom,
                        XtPointer *outpointer,
                        unsigned long *outlength,
                        Atom *type,
                        int *format,
#if NeedWidePrototypes
                        int delete_flag) ;
#else
                        Boolean delete_flag) ;
#endif /* NeedWidePrototypes */
static int ClipboardRetrieveItem( 
                        Display *display,
                        itemId itemid,
                        int add_length,
                        int def_length,
                        XtPointer *outpointer,
                        unsigned long *outlength,
  			Atom *type,
                        int *format,
                        int rec_type,
                        unsigned long discard) ;
static void ClipboardReplaceItem( 
                        Display *display,
                        itemId itemid,
                        XtPointer pointer,
                        unsigned long length,
                        int mode,
                        int format,
#if NeedWidePrototypes
                        int free_flag,
#else
                        Boolean free_flag,
#endif /* NeedWidePrototypes */
  			Atom type);
static Atom ClipboardGetAtomFromId( 
                        Display *display,
                        itemId itemid) ;
static Atom ClipboardGetAtomFromFormat( 
                        Display *display,
                        char *format_name) ;
static int ClipboardGetLenFromFormat( 
                        Display *display,
                        char *format_name,
                        int *format_length) ;
static ClipboardHeader ClipboardOpen( 
                        Display *display,
                        int add_length) ;
static void ClipboardClose( 
                        Display *display,
                        ClipboardHeader root_clipboard_header) ;
static void ClipboardDeleteId( 
                        Display *display,
                        itemId itemid) ;
static ClipboardFormatItem ClipboardFindFormat( 
                        Display *display,
                        ClipboardHeader header,
                        char *format,
                        itemId itemid,
                        int n,
                        unsigned long *maxnamelength,
                        int *count,
                        unsigned long *matchlength) ;
static void ClipboardDeleteFormat( 
                        Display *display,
                        itemId formatitemid) ;
static void ClipboardDeleteFormats( 
                        Display *display,
                        Window window,
                        itemId dataitemid) ;
static void ClipboardDeleteItemLabel( 
                        Display *display,
                        Window window,
                        itemId dataitemid) ;
static unsigned long ClipboardIsMarkedForDelete( 
                        Display *display,
                        ClipboardHeader header,
                        itemId itemid) ;
static void ClipboardDeleteItem( 
                        Display *display,
                        Window window,
                        ClipboardHeader header,
                        itemId deleteid) ;
static void ClipboardDeleteMarked( 
                        Display *display,
                        Window window,
                        ClipboardHeader header) ;
static void ClipboardMarkItem( 
                        Display *display,
                        ClipboardHeader header,
                        itemId dataitemid,
                        unsigned long state) ;
static int ClipboardSendMessage( 
                        Display *display,
                        Window window,
                        ClipboardFormatItem formatptr,
                        int messagetype) ;
static int ClipboardDataIsReady( 
                        Display *display,
                        XEvent *event,
                        char *private_info) ;
#if 0
static int ClipboardRequestorIsReady( 
                        Display *display,
                        XEvent *event,
                        char *private_info) ;
#endif
static int ClipboardGetSelection( 
                        Display *display,
                        Window window,
                        Atom target,
                        XtPointer *value,
			Atom *type,
                        unsigned long *size,
			int *format) ;
static int ClipboardRequestDataAndWait( 
                        Display *display,
                        Window window,
                        ClipboardFormatItem formatptr) ;
static itemId ClipboardGetNewItemId( 
                        Display *display) ;
static void ClipboardSetAccess( 
                        Display *display,
                        Window window) ;
static int ClipboardLock( 
                        Display *display,
                        Window window) ;
static int ClipboardUnlock( 
                        Display *display,
                        Window window,
#if NeedWidePrototypes
                        int all_levels) ;
#else
                        Boolean all_levels) ;
#endif /* NeedWidePrototypes */
static int ClipboardSearchForWindow( 
                        Display *display,
                        Window parentwindow,
                        Window window) ;
static int ClipboardWindowExists( 
                        Display *display,
                        Window window) ;
static void ClipboardReceiveData(Widget, XtPointer, Atom*, Atom*,
				 XtPointer, unsigned long *, int *) ;
static int ClipboardRetrieve(Display *display, Window window,
			     char *format, XtPointer buffer,
			     unsigned long length,
			     unsigned long *outlength,
			     long *private_id,
			     Atom *outtype);
static Boolean ClipboardGetByNameItem(Display* dpy, 
				      Window win,
				      ClipboardHeader header,
				      char* format);
static void ClipboardTimeout(XtPointer, XtIntervalId*);
/********    End Static Function Declarations    ********/

/*---------------------------------------------*/
/* static data				       */
/*---------------------------------------------*/

static XmCutPasteProc	*cbProcTable = NULL;
static long		*cbIdTable = NULL;
static int		maxCbProcs = 0;


/*---------------------------------------------*/
/* internal routines			       */
/*---------------------------------------------*/

static Time 
ClipboardGetCurrentTime(
        Display *dpy )
{
    XEvent event;
    Atom XmA_MOTIF_CLIP_TIME = XInternAtom(dpy, XmS_MOTIF_CLIP_TIME, False);

    XSelectInput(dpy, RootWindow(dpy, 0), PropertyChangeMask);
    XChangeProperty(dpy, RootWindow(dpy, 0),
                    XmA_MOTIF_CLIP_TIME, XmA_MOTIF_CLIP_TIME,
                    8,PropModeAppend,NULL,0);
    XWindowEvent(dpy, RootWindow(dpy, 0), PropertyChangeMask,&event);
    return(event.xproperty.time);
}
static void 
ClipboardSetNextItemId(
        Display *display,
        long itemid )
{
    itemId base;
    itemId nextItem;
    XtPointer int_ptr;
    unsigned long length;
    ClipboardHeader header;
    Atom type;
    itemId current_item;
    itemId last_item;

    header = ClipboardOpen( display, 0 );
    current_item = header->nextPasteItemId;
    last_item = header->oldNextPasteItemId;
    ClipboardClose( display, header );

    nextItem = itemid;
    do {
	base = nextItem - (nextItem % XM_ITEM_ID_INC);
	if (base >= XM_ITEM_ID_MAX) {
	    nextItem = XM_FIRST_FREE_ID;
	} else {
	    nextItem = base + XM_ITEM_ID_INC;
	}
    } while (nextItem == current_item - 1 || nextItem == last_item - 1);

    ClipboardFindItem( display,
			XM_NEXT_ID,
			&int_ptr,
			&length,
			&type,
			0,
			0 );
    *(long *) int_ptr = nextItem;

    ClipboardReplaceItem( display, XM_NEXT_ID, int_ptr, length,
			PropModeReplace, 32, True, XA_INTEGER);
}


/***********************************************************************
 * WeOwnSelection
 *
 * Check to see if the Motif clipboard owns the clipboard selection.
 * This enables us to shortcut and not use ICCCM data transfer to get
 * the clipboard data.
 *
 * Note that this is necessary for clipboard locking to work correctly.
 *
 ***********************************************************************/
static Boolean 
WeOwnSelection(
        Display *display,
	ClipboardHeader header )
{
    Window selectionwindow;
    Atom XmA_CLIPBOARD = XInternAtom( display, XmSCLIPBOARD, False );

    selectionwindow = XGetSelectionOwner( display, XmA_CLIPBOARD );

    return ( selectionwindow == header->ownSelection );
}

static void 
AssertClipboardSelection(
        Display *display,
        Window window,
        ClipboardHeader header,
        Time time )
{
    Widget widget;
    Atom XmA_CLIPBOARD;

    header->ownSelection = None;
    header->selectionTimestamp = 0;

    widget = XtWindowToWidget (display, window);

    /* Need a valid Widget to add an event handler. */

    if (widget == NULL)
    {
	return;
    }

    /* Assert ownership of CLIPBOARD selection only if there is valid data. */

    if (header->nextPasteItemId == 0)
    {
	return;
    }

    header->ownSelection = window;
    header->selectionTimestamp = time;

    XmA_CLIPBOARD = XInternAtom( display, XmSCLIPBOARD, False );
    XtOwnSelection(widget, XmA_CLIPBOARD, time, ClipboardConvertProc, 
		   NULL, NULL);
    return;
}

/* This function ensures that if the data item was copied by name, 
   it will be retrieved for the convert proc.  It returns true if
   the data was not copied by name or if the retrieval is sucessful */

static Boolean 
ClipboardGetByNameItem(Display* dpy, Window win,
		       ClipboardHeader header, char* format)
{
  short dataok;
  ClipboardFormatItem matchformat;
  unsigned long matchformatlength, maxname;
  int count;

  /* find the matching format for the next paste item */
  matchformat = ClipboardFindFormat(dpy, header, format,
				    (itemId) NULL, 0,
				    &maxname, &count, 
				    &matchformatlength );
  if (matchformat != 0)
    {
      dataok = 1;
      
      if ( matchformat->cutByNameFlag == 1 )
	{
	  /* passed by name */
	  dataok = ClipboardRequestDataAndWait(dpy, 
					       win,
					       matchformat);
	}
    } else {
      dataok = 0;
    }

  return(dataok != 0);
}


/*ARGSUSED*/
static Boolean
ClipboardConvertProc(Widget wid, 
		     Atom *selection, /* unused */
		     Atom *target, 
		     Atom *type, 
		     XtPointer *value, 
		     unsigned long *size, 
		     int *format)
{
  enum { XmA_TARGETS, XmA_TIMESTAMP, NUM_ATOMS };
  static char *atom_names[] = { XmSTARGETS, XmSTIMESTAMP };
  Display *display = XtDisplay(wid);
  Window window = XtWindow(wid);
  ClipboardHeader header;
  Boolean rval = True;
  char *format_name = NULL;
  Atom atoms[XtNumber(atom_names)];

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

  *value = NULL;
  *type = XA_INTEGER;
  *size = 0;
  *format = 8;

  if ( ClipboardLock( display, window ) != ClipboardSuccess )
    {
      /* We can't lock the clipboard,  something's wrong */
      return(False);
    }

  /* get the clipboard header */
  header = ClipboardOpen( display, 0 );
      
  if ( !WeOwnSelection( display, header ) ) 
    {
      /* we don't own the selection, something's wrong */
      rval = False;
      goto done;
    }

  if ( *target == atoms[XmA_TARGETS] )
    {
      Atom *ptr, *save_ptr;
      ClipboardFormatItem nextitem;
      int n, count;
      unsigned long dummy;
      
      *size = 0;
      *format = 32;
      *type = XA_ATOM;

      /* find the first format for the next paste item, if any remain */
      nextitem = ClipboardFindFormat( display, header, 0, 
				     (itemId) NULL, 1, &dummy, 
				     &count, &dummy );

      /* allocate storage for list of target atoms, 
	 plus the necessary */
      ptr = (Atom *)XtMalloc( sizeof(Atom) * (count + 2));
      save_ptr = ptr;

      /* Put required ICCCM targets which are supported */
      *ptr = atoms[XmA_TARGETS]; ptr++;
      *ptr = atoms[XmA_TIMESTAMP]; ptr++;
      n = 0; /* two targets right now */

      while ( nextitem != NULL && n < count )
	{
	  int ret_count;

	  /* add format to list */
	  *ptr = nextitem->formatNameAtom;
	  n = n + 1;
	  XtFree( (char *) nextitem );

	  /* find the nth format for the next paste item */
	  nextitem = ClipboardFindFormat( display, header, 0, 
					 (itemId) NULL, n + 1, &dummy, 
					 &ret_count, &dummy );
	  if (nextitem != NULL) ptr++;
	}
      *value = (char *) save_ptr;
      /* n is number of targets from the clipboard,
	 plus 2 builtin targets */
      *size = n + 2;
    } else if ( *target == atoms[XmA_TIMESTAMP] ) {
      timeStamp *timestamp;

      timestamp = (timeStamp *)XtMalloc(sizeof(timeStamp));
      *timestamp  = header->selectionTimestamp;
      *value = (char *) timestamp;
      *size = 1;
      *format = XM_INTEGER;
      *type = XA_INTEGER;
    } else {
      long private_id;
      unsigned long outlength;

      /* convert atom to format name */
      format_name = XGetAtomName( display, *target );
      ClipboardGetLenFromFormat( display, format_name, format) ;

      /* Make sure a byname item is first retrieved */
      ClipboardGetByNameItem(display, window, header, format_name);

      if (XmClipboardInquireLength( display, window, format_name, size)
	  != ClipboardSuccess) {
	rval = False;
	goto done;
      }

      if ( *size == 0 ) {
	rval = False;
	goto done;
      }
      
      *value = XtMalloc( (int) *size );

      if (ClipboardRetrieve(display, window, format_name, 
			    (XtPointer) *value, *size, &outlength, 
			    &private_id, type) != ClipboardSuccess ) {
	rval = False;
	goto done;
      }


      /* Fix size to be in format units */
      if (*format == 32) 
	*size = *size / sizeof(long);
      else if (*format == 16)
	*size = *size / sizeof(short);
    }

 done:

  if (format_name != NULL) XFree(format_name);
  ClipboardClose( display, header );
  ClipboardUnlock( display, window, False );
  return(rval);
}


static Window 
InitializeSelection(
        Display *display,
        ClipboardHeader header,
        Window window,
        Time time )
{
    Window selectionwindow;    
    Atom XmA_CLIPBOARD = XInternAtom( display, XmSCLIPBOARD, False );

    /* If there is no CLIPBOARD owner, and we have clipboard
       data, then assert ownership, and use that data. */

    selectionwindow = XGetSelectionOwner (display, XmA_CLIPBOARD);


    /* if the header is corrupted, give up. */

    if (selectionwindow == window && header->ownSelection == None)
    {
	selectionwindow = None;
	XSetSelectionOwner (display, XmA_CLIPBOARD, None, time);
    }

    if (selectionwindow != None) /* someone owns CLIPBOARD already */
    {
	return selectionwindow;
    }

    /* assert ownership of the clipboard selection */

    AssertClipboardSelection (display, window, header, time);

    selectionwindow = XGetSelectionOwner (display, XmA_CLIPBOARD);

    return (selectionwindow);
}


static int 
RegIfMatch(
        Display *display,
        char *format_name,
        char *match_name,
        int format_length )
{
	if ( strcmp( format_name, match_name ) == 0 )
	{
	    RegisterFormat( display, format_name, format_length );
	    return 1;
	}
    return 0;
}

static int 
RegisterFormat(
        Display *display,       /* Display id of application passing data */
        char *format_name,      /* Name string for data format */
        int format_length )     /* Format length  8-16-32 */
{
    Window rootwindow;
    Atom formatatom;
    int stored_len;

    /* if format is 32 in XChangeProperty, data must be long array */
    long long_format_length = format_length;

    /* get the atom for the format_name */
    formatatom = ClipboardGetAtomFromFormat( display, 
    					         format_name );

    rootwindow = RootWindow( display, 0 );

    if ( ClipboardGetLenFromFormat( display, 
				        format_name,
					&stored_len ) == ClipboardSuccess )
    {
	if ( stored_len == format_length )
	    return ClipboardSuccess;

	/* it is already registered, don't allow override */
	return ClipboardFail;
    }

    XChangeProperty( display, 
		     rootwindow, 
		     formatatom,
		     XA_INTEGER,
		     32,
		     PropModeReplace,
		     (unsigned char*)&long_format_length,
		     1 );

    return ClipboardSuccess;
}

/*---------------------------------------------*/
static void
CleanupHeader(
	      Display * display )
{
   XDeleteProperty (display,
		    RootWindow (display, 0), 
		    XInternAtom (display, XmS_MOTIF_CLIP_HEADER, False)); 

   XFlush(display);
}

/*---------------------------------------------*/
static void 
ClipboardError(
        char *key,
        char *message )
{
    XMERROR(key, message );

    exit(1);
}

/*---------------------------------------------*/
/* ARGSUSED */
static void 
ClipboardEventHandler(
        Widget widget,
        XtPointer closure,
        XEvent *event,
        Boolean *cont )
{
    enum { XmA_MOTIF_CLIP_MESSAGE, XmA_MOTIF_CLIP_DATA_REQUEST,
	   XmA_MOTIF_CLIP_DATA_DELETE, NUM_ATOMS };
    static char *atom_names[] = {
      XmS_MOTIF_CLIP_MESSAGE, XmS_MOTIF_CLIP_DATA_REQUEST,
      XmS_MOTIF_CLIP_DATA_DELETE };

    XClientMessageEvent *event_rcvd;
    Display *display;
    itemId formatitemid;
    ClipboardFormatItem formatitem; 
    unsigned long formatlength;
    Atom formattype, htype;
    long privateitemid;
    XmCutPasteProc callbackroutine = NULL;
    int reason, ret_value;
    Atom atoms[XtNumber(atom_names)];

    event_rcvd = (XClientMessageEvent*)event;

    if ( (event_rcvd->type & 127) != ClientMessage )
    	return ;

    display = XtDisplay(widget);

    assert(XtNumber(atom_names) == NUM_ATOMS);
    XInternAtoms( display, atom_names, XtNumber(atom_names), False, atoms );
    if (event_rcvd->message_type != atoms[XmA_MOTIF_CLIP_MESSAGE])
      return ;

    formatitemid  = event_rcvd->data.l[1];
    privateitemid = event_rcvd->data.l[2];

    /* get the callback routine */
    ret_value = ClipboardFindItem( display, 
    				       formatitemid,
    			   	       (XtPointer *) &formatitem,
    			   	       &formatlength,
				       &formattype,
				       0,
    			   	       XM_FORMAT_HEADER_TYPE );

    if ( ret_value != ClipboardSuccess ) 
    	return ;

    if (cbProcTable == NULL) return;

    if (formatitem->cutByNameCBIndex >= 0) {
      _XmProcessLock();
      callbackroutine = cbProcTable[formatitem->cutByNameCBIndex];
      _XmProcessUnlock();
    }

    XtFree( (char *) formatitem );

    if ( callbackroutine == NULL ) return ;

    reason = 0;

    if ( event_rcvd->data.l[0] == atoms[XmA_MOTIF_CLIP_DATA_REQUEST] )
    	reason = XmCR_CLIPBOARD_DATA_REQUEST;

    if ( event_rcvd->data.l[0] == atoms[XmA_MOTIF_CLIP_DATA_DELETE] )
    	reason = XmCR_CLIPBOARD_DATA_DELETE;

    if ( reason == 0 )
    	return ;

    /* call the callback routine */
    (*callbackroutine)( widget, 
    		        (long *) &formatitemid,
    		        &privateitemid,
    			&reason );

    /* if this was a data request, reset the recopy id */
    if (reason == XmCR_CLIPBOARD_DATA_REQUEST)
    {
	unsigned long hlength;
	ClipboardHeader header;

	ClipboardFindItem (display, XM_HEADER_ID, (XtPointer *)&header,
				&hlength, &htype, 0, 0);

	header->recopyId = 0;

	ClipboardReplaceItem (display, XM_HEADER_ID, header, hlength,
				PropModeReplace, 32, True, XA_INTEGER);
    }

    return ;
}

/*---------------------------------------------*/
static int 
ClipboardFindItem(
        Display *display,
        itemId itemid,
        XtPointer *outpointer,
        unsigned long *outlength,
	Atom *outtype,
        int *format,
        int rec_type )
{

    Window rootwindow;
    int ret_value;
    Atom itematom;
    int dummy;
    ClipboardPointer ptr;

    if (format == NULL) format = &dummy;

    rootwindow = RootWindow( display, 0 );

    /* convert the id into an atom */
    itematom = ClipboardGetAtomFromId( display, itemid );

    ret_value = GetWindowProperty(display,
				  rootwindow,
				  itematom,
				  outpointer,
				  outlength,
				  outtype,
				  format,
				  FALSE );

    if ( ret_value != ClipboardSuccess ) return ret_value;

    ptr = (ClipboardPointer)(*outpointer);

    if ( rec_type != 0 && ptr->header.recordType != rec_type )
    {
    	XtFree( (char *) *outpointer );
	CleanupHeader (display);
    	ClipboardError( CLIPBOARD_BAD_DATA_TYPE, BAD_DATA_TYPE );
    	return ClipboardFail;
    }

    return ClipboardSuccess;
}


/*---------------------------------------------*/
static int 
GetWindowProperty(
        Display *display,
        Window window,
        Atom property_atom,
        XtPointer *outpointer,
        unsigned long *outlength,
        Atom *type,
        int *format,
#if NeedWidePrototypes
        int delete_flag )
#else
        Boolean delete_flag )
#endif /* NeedWidePrototypes */
{

    int ret_value;
    Atom loc_type;
    unsigned long bytes_left;
    unsigned long cur_length;
    unsigned char *loc_pointer;
    unsigned long this_length;
    char *cur_pointer;
    int loc_format;
    long request_size;
    long offset;
    int byte_length;


    loc_pointer = NULL;
    bytes_left = 1;
    offset = 0;
    cur_length = 0;
    cur_pointer = NULL;

    *outpointer = 0;
    *outlength = 0;

    request_size = MAX_SELECTION_INCR( display );

    while ( bytes_left > 0 )
    {
	/* retrieve the item from the root */
	ret_value = XGetWindowProperty( display, 
					window, 
					property_atom,
					offset, /*offset*/
					request_size, /*length*/
					FALSE,
					AnyPropertyType,
					&loc_type,
					&loc_format,
					&this_length,
					&bytes_left,
					&loc_pointer );

        if ( ret_value != 0 ) 
            return ClipboardFail;

        if ( loc_pointer == 0 || this_length == 0 )
        {
            if ( delete_flag )
            {
                XDeleteProperty( display, window, property_atom );
	    }
	    if (loc_pointer != NULL) XFree ((char *)loc_pointer);
            return ClipboardFail;
	  }

        /* convert length according to format */
        byte_length = BYTELENGTH( this_length, loc_format );

	if ( cur_length == 0 )
	{
	    cur_pointer = XtMalloc((size_t)(byte_length + bytes_left));
	    /* Size arg. is truncated if sizeof( long) > sizeof( size_t) */
	    *outpointer = cur_pointer;
	}

	memcpy(cur_pointer, loc_pointer, (size_t) byte_length );
	cur_pointer = cur_pointer + byte_length;
	cur_length  = cur_length  + byte_length;
	offset += loc_format * this_length / 32;

	if (loc_pointer != NULL)
		XFree ((char *)loc_pointer);
    }

    if ( delete_flag )
    {
        XDeleteProperty( display, window, property_atom );
    }

    if ( format != NULL ) 
    {
	*format = loc_format;
    }

    if ( type != NULL )
    {
      char *temp;
      char *match = XmS_MOTIF_CLIP_ITEM;
      int i, len;
      Boolean equal = True;

      len = strlen(match);
      temp = XGetAtomName(display, loc_type);

      for(i = 0; i < len; i++) {
	if (temp[i] == 0 || temp[i] != match[i]) {
	  equal = False;
	  break;
	}
      }

      if (equal) /* Bogus type left by old Clipboard */
	*type = None; /* Signal bad type */
      else
	*type = loc_type;

      XFree(temp);
    }

    *outlength = cur_length;

    return ClipboardSuccess;
}

/*---------------------------------------------*/
static int 
ClipboardRetrieveItem(
        Display *display,
        itemId itemid,
        int add_length,             /* allocate this add'l */
        int def_length,             /* if item non-exist */
        XtPointer *outpointer,
        unsigned long *outlength,
        Atom *outtype,
        int *format,
        int rec_type,
        unsigned long discard )     /* ignore old data */
{

    int ret_value;
    int loc_format;
    unsigned long loclength;
    ClipboardPointer clipboard_pointer;
    Atom loctype;
    XtPointer pointer;

    /* retrieve the item from the root */
    ret_value = ClipboardFindItem(display, itemid, &pointer, &loclength,
				  &loctype, &loc_format, rec_type );

    if (loclength == 0 || ret_value != ClipboardSuccess)
    {
    	*outlength = def_length;
    }else{    
	if ( discard == 1 ) loclength = 0;

	*outlength = loclength + add_length;
    }

    /* get local memory for the item */
    clipboard_pointer = (ClipboardPointer)XtMalloc( (size_t) *outlength );

    /* Size arg. is truncated if sizeof( long) > sizeof( size_t) */
    if (ret_value == ClipboardSuccess)
    {
	/* copy the item into the local memory */
	memcpy(clipboard_pointer, pointer, (size_t) loclength );
    }

    *outpointer = (char*)clipboard_pointer;

    if (outtype != NULL) *outtype = loctype;

    /* free memory pointed to by pointer */
    XtFree( (char *) pointer );

    if ( format != 0 )
    {
	*format = loc_format;
    }

    /* return a pointer to the item */
    return ret_value;

}

/*---------------------------------------------*/
static void 
ClipboardReplaceItem(
        Display *display,
        itemId itemid,
        XtPointer pointer,
        unsigned long length,
        int mode,
        int format,
#if NeedWidePrototypes
        int free_flag,
#else
        Boolean free_flag,
#endif /* NeedWidePrototypes */
        Atom type)
{
    Window rootwindow;
    Atom itematom;
    XtPointer loc_pointer;
    unsigned long loc_length;
    int loc_mode;
    unsigned int max_req_size;

    loc_pointer = pointer;
    loc_mode = mode;

    rootwindow = RootWindow( display, 0 );

    /* convert the id into an atom */
    itematom = ClipboardGetAtomFromId( display, itemid );

    /* lengths are passed in bytes, but need to specify in format units */
    /* for ChangeProperty */
    loc_length = length / BYTELENGTH(1,format);

    max_req_size = ( MAX_SELECTION_INCR( display ) ) * 8 / format;

    do
    {
	unsigned long next_length;

	if ( loc_length > max_req_size )
	{
	    next_length = max_req_size;
	}else{
	    next_length = loc_length;
	}
	
	if (type == 0 || type == None) type = itematom;

	/* put the new values in the root */
	XChangeProperty( display, 
			 rootwindow, 
			 itematom,
			 type,
			 format,
			 loc_mode,
			 (unsigned char*)loc_pointer,
			 (int) next_length ); /* Truncation of next_length.*/

	loc_mode = PropModeAppend;
	loc_length = loc_length - next_length;
	loc_pointer = (char *) loc_pointer + BYTELENGTH(next_length,format);
      }
    while( loc_length > 0 );

    if ( free_flag == True )
    {
	/* note:  you have to depend on the free flag, even if the length */
	/* is zero, the pointer may point to non-zero-length allocated data */
        XtFree( (char *) pointer );
    }
}

/*---------------------------------------------*/
static Atom 
ClipboardGetAtomFromId(
        Display *display,
        itemId itemid )
{
    char *item;
    char atomname[ 100 ];

    switch ( (int)itemid )
    {	
	case 0:	item = XmS_MOTIF_CLIP_HEADER;
	    break;
	case 1: item = XmS_MOTIF_CLIP_NEXT_ID;
	    break;
	default:
    	    sprintf( atomname, "_MOTIF_CLIP_ITEM_%ld", itemid );
    	    item = atomname;
	    break;	
    }

    return XInternAtom( display, item, False );
}
/*---------------------------------------------*/
static Atom 
ClipboardGetAtomFromFormat(
        Display *display,
        char *format_name )
{
    char *atomname_format = "_MOTIF_CLIP_FORMAT_%s";
    char *item;
    Atom ret_value;

    item = XtMalloc( strlen( format_name ) + strlen( atomname_format ) + 1 );

    sprintf( item, atomname_format, format_name );

    ret_value = XInternAtom( display, item, False );

    XtFree( (char *) item );

    return ret_value;
}
/*---------------------------------------------*/
static int 
ClipboardGetLenFromFormat(
        Display *display,
        char *format_name,
        int *format_length )
{
    Atom format_atom;
    int ret_value;
    Window rootwindow;
    unsigned long outlength;
    unsigned char *outpointer;
    Atom type;
    int format;
    unsigned long bytes_left;

    outpointer = NULL;

    format_atom = ClipboardGetAtomFromFormat( display, format_name );

    rootwindow = RootWindow( display, 0 );

    /* get the format record */
    ret_value = XGetWindowProperty( display, 
				    rootwindow, 
				    format_atom,
				    0, /*offset*/
				    10000000, /*length*/
				    False,
				    AnyPropertyType,
				    &type,
				    &format,
				    &outlength,
				    &bytes_left,
				    &outpointer );

    if ( outpointer == 0 || outlength == 0 || ret_value !=0 )
    {
	/* if not successful, return warning that format is not registered */
	ret_value = ClipboardFail;

	*format_length = 8;

    }else{
	ret_value = ClipboardSuccess;

	/* return the length of the format */
	*format_length = *((long *)outpointer);
    }

    if (outpointer != NULL)
      XFree((char*)outpointer);

    return ret_value;
}

/*---------------------------------------------*/
static ClipboardHeader 
ClipboardOpen(
        Display *display,
        int add_length )
{
    int ret_value;
    unsigned long headerlength;
    ClipboardHeader root_clipboard_header;
    Atom headertype, type;
    long number ;
    unsigned long length;
    XtPointer int_ptr;

    ret_value = ClipboardSuccess;

    if ( add_length == 0 )
    {
	/* get the clipboard header */
	ret_value = ClipboardFindItem(display, 
				      XM_HEADER_ID,
				      (XtPointer *) &root_clipboard_header,
				      &headerlength,
				      &headertype,
				      0,
				      0 );
    }

    if ( add_length != 0 || ret_value != ClipboardSuccess )
    {
	/* get the clipboard header (this will allocate memory 
	   if doesn't exist) */

	ret_value = ClipboardRetrieveItem(display, 
					  XM_HEADER_ID,
					  add_length,
					  sizeof( ClipboardHeaderRec ),
					  (XtPointer *) &root_clipboard_header,
					  &headerlength,
					  NULL,
					  0,
					  0,
					  0 ); /* don't discard old data */
    }

    /* means clipboard header had not been initialized */
    if ( ret_value != ClipboardSuccess ) 
    {
    	root_clipboard_header->recordType = XM_HEADER_RECORD_TYPE;
    	root_clipboard_header->adjunctHeader = 0;
    	root_clipboard_header->maxItems = 1;
    	root_clipboard_header->currItems = 0;
    	root_clipboard_header->dataItemList = 
	  sizeof( ClipboardHeaderRec ) / CONVERT_32_FACTOR;
    	root_clipboard_header->nextPasteItemId = 0;
    	root_clipboard_header->lastCopyItemId = 0;
    	root_clipboard_header->recopyId = 0;
    	root_clipboard_header->oldNextPasteItemId = 0;
    	root_clipboard_header->deletedByCopyId = 0;
	root_clipboard_header->ownSelection = 0;
	root_clipboard_header->selectionTimestamp = CurrentTime;
	root_clipboard_header->copyFromTimestamp  = CurrentTime;
    	root_clipboard_header->foreignCopiedLength = 0;
    	root_clipboard_header->incrementalCopyFrom = 0;
	root_clipboard_header->startCopyCalled = (unsigned long) False;
    }

    /* make sure "next free id" property has been initialized */
    ret_value = ClipboardFindItem(display, 
				  XM_NEXT_ID,
				  &int_ptr,
				  &length,
				  &type,
				  0,
				  0 );

    if ( ret_value != ClipboardSuccess ) 
    {
	number = XM_FIRST_FREE_ID;
    	int_ptr = (XtPointer) &number;
    	
    	/* initialize the next id property */
	ClipboardReplaceItem(display,
			     XM_NEXT_ID,
			     int_ptr,
			     sizeof(long),
			     PropModeReplace,
			     32,
			     False,
			     XA_INTEGER );
    }
    else
    {
    	XtFree( (char*)int_ptr );
    }

    return root_clipboard_header;
}

/*---------------------------------------------*/
static void 
ClipboardClose(
        Display *display,
        ClipboardHeader root_clipboard_header )
{
    unsigned long headerlength;

    headerlength = sizeof( ClipboardHeaderRec ) + 
    		(root_clipboard_header -> currItems) * sizeof( itemId );

    /* replace the clipboard header */
    ClipboardReplaceItem(display, 
			 XM_HEADER_ID,
			 (XtPointer)root_clipboard_header,
			 headerlength,
			 PropModeReplace,
			 32,
			 True,
			 XA_INTEGER );
}

/*---------------------------------------------*/
static void 
ClipboardDeleteId(
        Display *display,
        itemId itemid )
{
    Window rootwindow;
    Atom itematom;

    rootwindow = RootWindow( display, 0 );

    itematom = ClipboardGetAtomFromId( display, itemid ); 

    XDeleteProperty( display, rootwindow, itematom );

}


/*---------------------------------------------*/
static ClipboardFormatItem 
ClipboardFindFormat(
        Display *display,       /* Display id of application wanting data */
        ClipboardHeader header,
        char *format,
        itemId itemid,
        int n,                  /* if looking for nth format */
        unsigned long *maxnamelength,/* receives max format name length */
        int *count,             /* receives next paste format count */
        unsigned long *matchlength )      /* receives length of matching format */
{
    ClipboardDataItem queryitem;
    ClipboardFormatItem currformat, matchformat;
    unsigned long reclength ;
    int i, free_flag, index;
    itemId currformatid, queryitemid, *idptr;
    Atom formatatom;
    Atom rectype;

    *count = 0;
    *maxnamelength = 0;

    if ( itemid < 0 ) return 0;

    /* if passed an item id then use that, otherwise use next paste item */
    if ( itemid != 0 )
    {
    	queryitemid = itemid;

    }else{

    	if ( header->currItems == 0 ) return 0;

        queryitemid = header->nextPasteItemId;
    }

    if ( queryitemid == 0 ) return 0;

    /* get the query item */
    if (ClipboardFindItem(display, queryitemid, (XtPointer *) &queryitem,
			  &reclength, &rectype, 0,
			  XM_DATA_ITEM_RECORD_TYPE ) == ClipboardFail ) 
    	return 0;

    if ( queryitem == 0 )
    {
	CleanupHeader (display);
	ClipboardError( CLIPBOARD_CORRUPT, CORRUPT_DATA_STRUCTURE );
	return 0;
    }

    *count = queryitem->formatCount - queryitem->cancelledFormatCount;

    if ( *count < 0 ) *count = 0;

    /* point to the first format id in the list */
    idptr = (itemId*)((char*)queryitem + 
		      queryitem->formatIdList * CONVERT_32_FACTOR);

    matchformat = 0;
    *matchlength = 0;
    index = 1;
    formatatom = XInternAtom( display, format, False );

    /* run through all the formats for the query item looking */
    /* for a name match with the input format name */
    for ( i = 0; i < queryitem->formatCount; i++ )
    {
	currformatid = *idptr; 

    	/* free the allocation unless it is the matching format	*/
    	free_flag = 1;

	/* get the next format */
	ClipboardFindItem(display, currformatid,
			  (XtPointer *) &currformat,
			  &reclength,
			  &rectype,
			  0,
			  XM_FORMAT_HEADER_TYPE );

    	if ( currformat == 0 )
    	{
	    CleanupHeader (display);
	    ClipboardError( CLIPBOARD_CORRUPT, CORRUPT_DATA_STRUCTURE );
    	    return 0;
    	}

    	if ( currformat->cancelledFlag == 0 )
    	{
	    /* format has not been cancelled */
	    *maxnamelength = MAX( *maxnamelength, 
				  currformat->formatNameLength );

	    if (format != NULL)
    	    {
		if ( currformat->formatNameAtom == formatatom )
		{
		    matchformat = currformat;
    		    free_flag = 0;
    		    *matchlength = reclength;
    		}

    	    }else{
		/* we're looking for the n'th format */
    		if ( index == n )
    		{
		    matchformat = currformat;
    		    free_flag = 0;
    		    *matchlength = reclength;
    		}

		index = index + 1;
    	    }
    	}

    	if (free_flag == 1 )
    	{
    	    XtFree( (char *) currformat );
    	}

    	idptr = idptr + 1;
    }

    XtFree( (char *) queryitem );

    return matchformat;
}

/*---------------------------------------------*/
static void 
ClipboardDeleteFormat(
        Display *display,
        itemId formatitemid )
{
    itemId  dataitemid;
    ClipboardDataItem dataitem;
    ClipboardFormatItem formatitem;
    unsigned long length ;
    unsigned long formatlength;
    Atom formattype, type;

    /* first get the format item out of the root */
    ClipboardFindItem( display, 
    			   formatitemid,
    			   (XtPointer *) &formatitem,
    			   &formatlength,
			   &formattype,
			   0,
    			   XM_FORMAT_HEADER_TYPE );

    if ( formatitem == 0 )
    {
	CleanupHeader (display);
	ClipboardError( CLIPBOARD_CORRUPT, CORRUPT_DATA_STRUCTURE );
	return;
    }

    if ( ( formatitem->cutByNameFlag == 0 ) ||
    	 ( formatitem->cancelledFlag != 0 ) )
    {
    	/* nothing to do, data not passed by name or already cancelled */
    	XtFree( (char *) formatitem );
    	return;
    }

    dataitemid = formatitem->parentItemId;

    /* now get the data item out of the root */
    ClipboardFindItem(display, 
		      dataitemid,
		      (XtPointer *) &dataitem,
		      &length,
		      &type,
		      0,
		      XM_DATA_ITEM_RECORD_TYPE );

    if ( dataitem == 0 )
    {
	CleanupHeader (display);
	ClipboardError( CLIPBOARD_CORRUPT, CORRUPT_DATA_STRUCTURE );
	return;
    }

    dataitem->cancelledFormatCount = dataitem->cancelledFormatCount + 1; 

    if ( dataitem->cancelledFormatCount == dataitem->formatCount ) 
    {
    	/* no formats left, mark the item for delete */
        dataitem->deletePendingFlag = 1;
    }

    /* set the cancel flag on */
    formatitem->cancelledFlag = 1;

    /* return the property on the root window for the item */
    ClipboardReplaceItem(display, 
			 formatitemid,
			 (XtPointer)formatitem,
			 formatlength,
			 PropModeReplace,
			 32,
			 True,
			 XA_INTEGER );

    ClipboardReplaceItem(display, 
			 dataitemid,
			 (XtPointer)dataitem,
			 length,
			 PropModeReplace,
			 32,
			 True,
			 XA_INTEGER);

}

/*---------------------------------------------*/
static void 
ClipboardDeleteFormats(
        Display *display,
        Window window,
        itemId dataitemid )
{
    itemId *deleteptr;
    ClipboardDataItem datalist;
    ClipboardFormatItem formatdata;
    unsigned long length ;
    Atom type;
    int i;

    /* first get the data item out of the root */
    ClipboardFindItem( display, 
    			   dataitemid,
    			   (XtPointer *) &datalist,
    			   &length,
			   &type,
			   0,
    			   XM_DATA_ITEM_RECORD_TYPE );

    if ( datalist == 0 )
    {
	CleanupHeader (display);
	ClipboardError( CLIPBOARD_CORRUPT, CORRUPT_DATA_STRUCTURE );
	return;
    }

    deleteptr = (itemId*)((char*) datalist +
			  datalist->formatIdList * CONVERT_32_FACTOR ); 

    for ( i = 0; i < datalist->formatCount; i++ )
    {
    	/* first delete the format data */
	ClipboardFindItem( display, 
			       *deleteptr,
			       (XtPointer *) &formatdata,
			       &length,
			       &type,
			       0,
    			       XM_FORMAT_HEADER_TYPE );

    	if ( formatdata == 0 )
    	{
	    CleanupHeader (display);
	    ClipboardError( CLIPBOARD_CORRUPT, CORRUPT_DATA_STRUCTURE );
    	    return;
    	}

    	if ( formatdata->cutByNameFlag == 1 )
    	{
    	    /* format was cut by name */
	    ClipboardSendMessage( display, 
    				      window,
    				      formatdata,
				      XM_DATA_DELETE_MESSAGE );
    	}

    	ClipboardDeleteId( display, formatdata->formatDataId );

        XtFree( (char *) formatdata );

    	/* then delete the format header */
    	ClipboardDeleteId( display, *deleteptr );

    	*deleteptr = 0;

    	deleteptr = deleteptr + 1;
    }

    XtFree( (char *) datalist );
}

/*---------------------------------------------*/
/* ARGSUSED */
 static void 
ClipboardDeleteItemLabel(
        Display *display,
        Window window,
        itemId dataitemid )
{
     ClipboardDataItem datalist;
     unsigned long length;
     Atom type;

     /* first get the data item out of the root */
     ClipboardFindItem( display,
                          dataitemid,
                          (XtPointer *) &datalist,
                          &length,
			  &type,
                          0,
                          XM_DATA_ITEM_RECORD_TYPE );

     if ( datalist == 0 )
     {
	CleanupHeader (display);
	ClipboardError( CLIPBOARD_CORRUPT, CORRUPT_DATA_STRUCTURE );
	return;
     }
     /* delete item label */
     ClipboardDeleteId (display, datalist->dataItemLabelId);

     XtFree( (char *) datalist );
 }

/*---------------------------------------------*/
/* ARGSUSED */
static unsigned long 
ClipboardIsMarkedForDelete(
        Display *display,
        ClipboardHeader header,
        itemId itemid )
{
    ClipboardDataItem curritem;
    unsigned long return_value, reclength;
    Atom rectype;

    if ( itemid == 0 ) 
    {
	CleanupHeader (display);
	ClipboardError( CLIPBOARD_CORRUPT, CORRUPT_DATA_STRUCTURE );
    	return 0;
    }

    /* get the next format */
    ClipboardFindItem( display, 
			   itemid,
			   (XtPointer *) &curritem,
			   &reclength,
			   &rectype,
			   0,
    			   XM_DATA_ITEM_RECORD_TYPE );

    if ( curritem == 0 ) 
    {
	CleanupHeader (display);
	ClipboardError( CLIPBOARD_CORRUPT, CORRUPT_DATA_STRUCTURE );
    	return 0;
    }

    return_value = curritem->deletePendingFlag;

    XtFree( (char *) curritem );

    return return_value;
}

/*---------------------------------------------*/
static void 
ClipboardDeleteItem(
        Display *display,
        Window window,
        ClipboardHeader header,
        itemId deleteid )
{
    int i;
    itemId *listptr,*thisid, *nextid, nextpasteid;
    int nextpasteindex;
    int lastflag = 0;

    /* find the delete id in the header item list */
    listptr = (itemId*)((char*) header + 
			header->dataItemList * CONVERT_32_FACTOR ); 

    i = 0;

    nextpasteindex = 0;
    nextpasteid    = 0;

    nextid = listptr;
    thisid = nextid;

    /* redo the item list */
    if(    !header->currItems    )
    {   return ;
        } 
    while ( i < header->currItems )
    {
    	i++ ;

	if (*nextid == deleteid ) 
    	{
    	    nextid++;

    	    nextpasteindex = i - 2;

    	    /* if this flag doesn't get reset, then delete item 
	       was last item */
    	    lastflag = 1;

    	    continue;
    	}

    	lastflag = 0;

    	*thisid = *nextid;

    	thisid = thisid + 1;
	nextid = nextid + 1;
    }

    *thisid = 0;

    header->currItems = header->currItems - 1;

    /* if we are deleting the next paste item, then we need to find
       a new one */
    if ( header->nextPasteItemId == deleteid )
    {

	if ( lastflag == 1 )
	{
	    nextpasteindex = nextpasteindex - 1; 
	}

	/* store this value temporarily */
	i = nextpasteindex;

	/* now find the next paste candidate
	   first try to find next older item to make next paste */
	while ( nextpasteindex >= 0 )
	{
	    thisid = listptr + nextpasteindex;

	    if ( !ClipboardIsMarkedForDelete( display, header, *thisid ) )
	    { 
		nextpasteid = *thisid;
		break;
	    }

	    nextpasteindex = nextpasteindex - 1;
	}

	/* if didn't find a next older item, find next newer item */
	if ( nextpasteid == 0 )
	{
	    /* restore this value */
	    nextpasteindex = i;

	    while ( nextpasteindex < header->currItems )
	    {
		thisid = listptr + nextpasteindex;

		if ( !ClipboardIsMarkedForDelete( display, header, *thisid ) )
		{ 
		    nextpasteid = *thisid;
		    break;
		}

		nextpasteindex = nextpasteindex + 1;
	    }
	}

        header->nextPasteItemId = nextpasteid;
        header->oldNextPasteItemId = 0;
    }
     /* delete the item label */
     ClipboardDeleteItemLabel( display, window, deleteid);

    /* delete all the formats belonging to the data item */
    ClipboardDeleteFormats( display, window, deleteid );

    /* now delete the item itself */
    ClipboardDeleteId( display, deleteid );
    	
    /* Cleanup any callback information for ByName */
    {
      int i;
      Boolean found = False;

      _XmProcessLock();
      for(i = 0; i < maxCbProcs; i++)
	if (found = (cbIdTable[i] == deleteid)) break;

      if (found) {
	cbProcTable[i] = NULL;
	cbIdTable[i] = 0;
      }
      _XmProcessUnlock();
    }
}


/*---------------------------------------------*/
static void 
ClipboardDeleteMarked(
        Display *display,
        Window window,
        ClipboardHeader header )
{
    itemId *nextIdPtr;
    unsigned long endi, i;

    /* find the header item list */
    nextIdPtr = (itemId*)((char*) header +
			  header->dataItemList * CONVERT_32_FACTOR); 

    i = 0;
    endi = header->currItems;

    /* run through the item list looking for things to delete */
    while( 1 )
    { 
    	if ( i >= endi ) break;

    	i = i + 1;

	if ( ClipboardIsMarkedForDelete( display, header, *nextIdPtr ) )
    	{
    	    ClipboardDeleteItem( display, window, header, *nextIdPtr );

    	}else{
    	    nextIdPtr = nextIdPtr + 1;
    	}    
    }
}
/*---------------------------------------------*/
/* ARGSUSED */
static void 
ClipboardMarkItem(
        Display *display,
        ClipboardHeader header,
        itemId dataitemid,
        unsigned long state )
{
    ClipboardDataItem itemheader;
    unsigned long itemlength;
    Atom itemtype;

    if ( dataitemid == 0 ) return;

    /* get a pointer to the item */
    ClipboardFindItem(display, 
		      dataitemid,
		      (XtPointer *) &itemheader,
		      &itemlength,
		      &itemtype,
		      0,
		      XM_DATA_ITEM_RECORD_TYPE );

    if ( itemheader == 0 ) 
    {
	CleanupHeader (display);
	ClipboardError( CLIPBOARD_CORRUPT, CORRUPT_DATA_STRUCTURE );
    	return;
    }

    /* mark the delete pending flag */
    itemheader->deletePendingFlag = state;

    /* return the item to the root window */
    ClipboardReplaceItem(display, dataitemid, (XtPointer)itemheader,
			 itemlength, PropModeReplace, 32, True,
			 XA_INTEGER );

}

/*---------------------------------------------*/
static int 
ClipboardSendMessage(
        Display *display,
        Window window,
        ClipboardFormatItem formatptr,
        int messagetype )
{
    enum { XmA_MOTIF_CLIP_MESSAGE, XmA_MOTIF_CLIP_DATA_REQUEST,
	   XmA_MOTIF_CLIP_DATA_DELETE, NUM_ATOMS };
    static char *atom_names[] = {
      XmS_MOTIF_CLIP_MESSAGE, XmS_MOTIF_CLIP_DATA_REQUEST,
      XmS_MOTIF_CLIP_DATA_DELETE };

    Window widgetwindow;
    XClientMessageEvent event_sent;
    long event_mask = 0;
    unsigned long headerlength;
    ClipboardHeader root_clipboard_header;
    Boolean dummy;
    Atom headertype;
    Atom atoms[XtNumber(atom_names)];

    widgetwindow = formatptr->cutByNameWindow;

    if ( widgetwindow == 0 ) return 0;

    assert(XtNumber(atom_names) == NUM_ATOMS);
    XInternAtoms( display, atom_names, XtNumber(atom_names), False, atoms );
    event_sent.type         = ClientMessage;
    event_sent.window       = widgetwindow;
    event_sent.message_type = atoms[XmA_MOTIF_CLIP_MESSAGE];
    event_sent.format	    = 32;

    switch ( messagetype )
    {	
	case XM_DATA_REQUEST_MESSAGE:	

	    /* get the clipboard header */
	    ClipboardFindItem( display, 
				   XM_HEADER_ID,
				   (XtPointer *) &root_clipboard_header,
				   &headerlength,
				   &headertype,
				   0,
				   0 );

	    /* set the recopy item id in the header (so locking 
	       can be circumvented) */

	    root_clipboard_header->recopyId = formatptr->thisFormatId;

	    /* replace the clipboard header */
	    ClipboardReplaceItem(display, XM_HEADER_ID,
				 (XtPointer)root_clipboard_header,
				 headerlength, PropModeReplace,
				 32, True, XA_INTEGER );

            event_sent.data.l[0] = atoms[XmA_MOTIF_CLIP_DATA_REQUEST];
	    break;

	case XM_DATA_DELETE_MESSAGE:	
            event_sent.data.l[0] = atoms[XmA_MOTIF_CLIP_DATA_DELETE];
	    break;
    }

    event_sent.data.l[1] = formatptr->thisFormatId;
    event_sent.data.l[2] = formatptr->itemPrivateId;

    /* is this the same application that stored the data? */
    if ( formatptr->windowId == window )
    {
    	/* call the event handler directly to avoid blocking */
    	ClipboardEventHandler( XtWindowToWidget(display,
						formatptr->cutByNameWindow),
			      0,
			      (XEvent *) &event_sent,
			      &dummy );
    }else{

	/* if we aren't in same application that stored the data, then 
	   make sure the window still exists */
        if ( !ClipboardWindowExists( display, widgetwindow )) return 0;

	/* send a client message to the window supplied by the user */
	XSendEvent( display, widgetwindow, True, event_mask, 
		    (XEvent*)&event_sent ); 
    }

    return 1;
}

/*---------------------------------------------*/
static int 
ClipboardDataIsReady(
        Display *display,
        XEvent *event,
        char *private_info )
{
     XDestroyWindowEvent *destroy_event;
     ClipboardCutByNameInfo cutbynameinfo;
     ClipboardFormatItem formatitem;
     unsigned long formatlength;
     Atom formattype;
     int okay;
 
     cutbynameinfo = ( ClipboardCutByNameInfo )private_info;

     if ( (event->type & 127) == DestroyNotify )
     {
        destroy_event = (XDestroyWindowEvent*)event;

        if ( destroy_event->window == cutbynameinfo->window )
        {
            cutbynameinfo->window = 0;
            return 1;
        }
     }

     if ( (event->type & 127) != PropertyNotify )
    	return 0;


     /* get the format item */
     ClipboardFindItem( display,
 			   cutbynameinfo->formatitemid,
 			   (XtPointer *) &formatitem,
 			   &formatlength,
			   &formattype,
			   0,
    			   XM_FORMAT_HEADER_TYPE );
 
     if ( formatitem == 0 ) 
     {
	CleanupHeader (display);
	ClipboardError( CLIPBOARD_CORRUPT, CORRUPT_DATA_STRUCTURE );
	return 0;
     }

     okay = (int)( formatitem->cutByNameFlag == 0 );
     	    
     /* release the allocation */
     XtFree( (char *) formatitem );
     
     return okay;
     
}


#if 0
/* This function is currently unused. */

/*---------------------------------------------*/
/* ARGSUSED */
static int 
ClipboardRequestorIsReady(
        Display *display,
        XEvent *event,
        char *private_info )
{
    XPropertyEvent *property_event;
    XDestroyWindowEvent *destroy_event;
    ClipboardDestroyInfo info;

    info = ( ClipboardDestroyInfo )private_info;

    if ( (event->type & 127) == DestroyNotify )
    {
        destroy_event = (XDestroyWindowEvent*)event;

        if ( destroy_event->window == info->window )
        {
            info->window = 0;
            return 1;
        }
    }

    if ( (event->type & 127) == PropertyNotify )
    {
        property_event = (XPropertyEvent*)event;

        /* make sure we have right property and are ready */
        if ( property_event->atom == info->property
                            &&
             property_event->state == PropertyDelete )
        {
            return 1;
        }
    }

    return 0;
 }
#endif

/*---------------------------------------------*/
static int 
ClipboardGetSelection(Display *display,
		      Window window,
		      Atom target,
		      XtPointer *value,
		      Atom *type,
		      unsigned long *size,
		      int *format)
{
    ClipboardSelectionInfoRec info;
    Widget dest;
    XtAppContext app;
    Atom XmA_CLIPBOARD;

    dest = XtWindowToWidget(display, window);

    if (dest == (Widget) NULL) {
      return(FALSE);
    }

    app = XtWidgetToApplicationContext(dest);

    /* initialize the fields in the info record passed to the */
    /* predicate function */
    info.success = FALSE;
    info.received = FALSE;
    info.data = NULL;
    info.count = 0;
    info.format = 8;
    info.type = None;

    /* ask for the data in the specified format */
    XmA_CLIPBOARD = XInternAtom( display, XmSCLIPBOARD, False );
    XtGetSelectionValue(dest, XmA_CLIPBOARD, target,
			ClipboardReceiveData, &info, 
			XtLastTimestampProcessed(display));

#ifdef XTHREADS
    while (XtAppGetExitFlag(app) == False) {
#else
    for(;;) {
#endif
      XEvent event;
      XtInputMask mask;
      if (info.received) 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
   }

    *value = info.data;
    *size = info.count;
    *type = info.type;
    *format = info.format;

    if (*value == NULL || *size == 0)
	return FALSE;

    return TRUE;
}

/*ARGSUSED*/
static void
ClipboardReceiveData(Widget dest, /* unused */
		     XtPointer client_data,
		     Atom *selection, /* unused */
		     Atom *type,
		     XtPointer value, 
		     unsigned long *length, 
		     int *format)
{
  ClipboardSelectionInfo info;

  info = ( ClipboardSelectionInfo ) client_data;

  info->received = TRUE;

  if ( *type != XT_CONVERT_FAIL )
    {
      info -> format = *format;
      info -> count = BYTELENGTH(*length, *format);
      info -> type = *type;
      info -> data = (char*) value;
      info -> success = TRUE;
    }
  else 
    {
      info -> format = 8;
      info -> count = 0;
      info -> type = None;
      info -> data = NULL;
      info -> success = FALSE;
    }
}

static int 
ClipboardRequestDataAndWait(
        Display *display,
        Window window,
        ClipboardFormatItem formatptr )
{
    XEvent event_return;
    int dataisready;
    unsigned long maxtime;
    XWindowAttributes rootattributes;
    Window rootwindow;
    ClipboardCutByNameInfoRec cutbynameinfo;
    Boolean timer_expired;
    XtAppContext app_context;
    XtIntervalId timerid;
    Widget wid;

    rootwindow = RootWindow( display, 0 );

    /* get the current root window event mask */
    XGetWindowAttributes( display, rootwindow, &rootattributes );

    /* select for property notify as well as current mask */
    XSelectInput( display, 
		  rootwindow, 
		  PropertyChangeMask  |
		  StructureNotifyMask | rootattributes.your_event_mask );

    if ( ClipboardSendMessage( display, 
    			           window,
    			           formatptr,
    			           XM_DATA_REQUEST_MESSAGE ) == 0 )
    {
	/* put mask back the way it was */
	XSelectInput( display, 
		      rootwindow, 
		      rootattributes.your_event_mask );
    	return 0;
    }

    cutbynameinfo.formatitemid = formatptr->thisFormatId;
    cutbynameinfo.window = window;

    dataisready = XCheckIfEvent( display, 
    				 &event_return, 
    				 ClipboardDataIsReady, 
                                 (char*)&cutbynameinfo );

    if ( cutbynameinfo.window == 0 )
    {
        /* this means the cut by name window had been destroyed */
        return 0;
    }

    /* We quit after the timeout to prevent deadlock */
    wid = XtWindowToWidget(display, window);
    if (wid != (Widget) NULL) {
      app_context = XtWidgetToApplicationContext(wid);
      maxtime = XtAppGetSelectionTimeout(app_context);
    } else {
      maxtime = 5000;
    }
    timer_expired = False;
    timerid = XtAppAddTimeOut(app_context, maxtime, 
			      ClipboardTimeout, &timer_expired);
#ifdef XTHREADS
    while( !dataisready && !timer_expired &&
		(XtAppGetExitFlag(app_context) == False)) {
#else
    while( !dataisready && !timer_expired) {
#endif
      XtInputMask mask;
#ifndef XTHREADS
      XtAppNextEvent(app_context, &event_return);
      dataisready = 
	ClipboardDataIsReady(display, &event_return,
				(char*)&cutbynameinfo);
      XtDispatchEvent(&event_return);
#else
      while (!(mask = XtAppPending(app_context)))
		; /* busy waiting - don't lose lock */
      if (mask & XtIMXEvent) {
	  XtAppNextEvent(app_context, &event_return);
	  dataisready = 
	      ClipboardDataIsReady(display, &event_return,
				(char*)&cutbynameinfo);
	  XtDispatchEvent(&event_return);
      }
      else
	  XtAppProcessEvent(app_context, mask);
#endif
    }
    if (! timer_expired) XtRemoveTimeOut(timerid);

    if (! dataisready) return 0; /* Fail,  no response */

    if ( cutbynameinfo.window == 0 )
    {
        /* this means the cut by name window had been destroyed */
        return 0;
    }

    /* put mask back the way it was */
    XSelectInput( display, 
		  rootwindow, 
		  rootattributes.your_event_mask );

    return 1;
}

/*ARGSUSED*/
static void
ClipboardTimeout(XtPointer client_data, 
		 XtIntervalId* timer) /* unused */
{
  Boolean *flag = (Boolean *) client_data;

  *flag = True;
}


/*---------------------------------------------*/
static itemId
ClipboardGetNewItemId( 
                        Display *display )
{
    XtPointer propertynumber;
    unsigned long length;
    itemId loc_id;
    Atom type;

    ClipboardFindItem(display, XM_NEXT_ID, &propertynumber, &length,
		      &type, 0, 0 );

    loc_id = ++*((itemId*)propertynumber);

    ClipboardReplaceItem(display, XM_NEXT_ID, propertynumber, length,
			 PropModeReplace, 32, True, XA_INTEGER);

    return loc_id;
}


/*---------------------------------------------*/
static void 
ClipboardSetAccess(
        Display *display,
        Window window )
{
    Atom itematom;

    itematom = XInternAtom( display, XmS_MOTIF_CLIP_LOCK_ACCESS_VALID, False );

    /* put the clipboard lock access valid property on window */
    XChangeProperty( display, 
		     window, 
		     itematom,
		     itematom,
		     8,
		     PropModeReplace,
		     (unsigned char*)"yes",
		     3 );
}

/*---------------------------------------------*/
static int 
ClipboardLock(
        Display *display,
        Window window )
{
    enum { XmA_MOTIF_CLIP_LOCK, XmA_CLIPBOARD, NUM_ATOMS };
    static char *atom_names[] = { XmS_MOTIF_CLIP_LOCK, XmSCLIPBOARD };

    ClipboardLockPtr lockptr;
    unsigned long length;
    Window lock_owner;
    Boolean take_lock = False;
    Atom ignoretype;
    Atom atoms[XtNumber(atom_names)];
    _XmDisplayToAppContext(display);

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

    _XmAppLock(app);

    lock_owner = XGetSelectionOwner (display, atoms[XmA_MOTIF_CLIP_LOCK]);

    if (lock_owner != window && lock_owner != None) {
	_XmAppUnlock(app);
	return (ClipboardLocked);
    }
    
    ClipboardFindItem (display, XM_LOCK_ID, (XtPointer *)&lockptr,
                          &length, &ignoretype, 0, 0);

    if (length == 0)	/* create new lock property */
    {
	lockptr = (ClipboardLockPtr)XtMalloc(sizeof(ClipboardLockRec));
	lockptr->lockLevel = 0;
    }

    if (lockptr->lockLevel == 0) /* new or invalid V1.0 lock. Take the lock */
    {
	lockptr->windowId = window;
	lockptr->lockLevel = 1;
	take_lock = True;
    }
    else if (lockptr->windowId == window) /* already have the lock */
    {
	lockptr->lockLevel += 1;
    }
    else	/* another client has the lock */
    {
	if (ClipboardWindowExists (display, lockptr->windowId))
	{
	    XtFree ((char *)lockptr);
	    _XmAppUnlock(app);
	    return (ClipboardLocked);
	}
	else /* locking client has gone away, clipboard may be corrupted */
	{
	    ClipboardHeader header;
	    Window owner = XGetSelectionOwner (display, atoms[XmA_CLIPBOARD]);
	    Time timestamp = ClipboardGetCurrentTime(display);

	    /* Drop the selection if a Motif client owns it */

            header = ClipboardOpen (display, 0);
	    if (header->ownSelection == owner)
	    {
		XSetSelectionOwner (display, XmA_CLIPBOARD, None, timestamp);
	    }
            ClipboardClose (display, header);

	    /* Reset the header property */

	    CleanupHeader (display);
	    header = ClipboardOpen (display, 0);
	    ClipboardClose (display, header);

	    /* Take the lock */

	    lockptr->windowId = window;
	    lockptr->lockLevel = 1;
	    take_lock = True;
	}	    
    }

    if (take_lock == True) {
	if (XGetSelectionOwner (display, atoms[XmA_MOTIF_CLIP_LOCK]) == None) {
	    XSetSelectionOwner (display, atoms[XmA_MOTIF_CLIP_LOCK], window, 
				ClipboardGetCurrentTime(display));
	    if (XGetSelectionOwner (display, atoms[XmA_MOTIF_CLIP_LOCK]) != window) {
		XtFree ((char *)lockptr);
	        _XmAppUnlock(app);
		return (ClipboardLocked);
	    }
	}
	else {
	    XtFree ((char *)lockptr);
	    _XmAppUnlock(app);
	    return (ClipboardLocked);
	}
    }

    ClipboardReplaceItem (display, XM_LOCK_ID, (XtPointer)lockptr,
			  sizeof(ClipboardLockRec), PropModeReplace, 
			  32, False, XA_INTEGER );

    ClipboardSetAccess (display, window);

    XtFree ((char *)lockptr);

    _XmAppUnlock(app);
    return (ClipboardSuccess);
}

/*---------------------------------------------*/
static int 
ClipboardUnlock(
        Display *display,
        Window window,
#if NeedWidePrototypes
        int all_levels )
#else
        Boolean all_levels )
#endif /* NeedWidePrototypes */
{
    unsigned long length;
    ClipboardLockPtr lockptr;
    Atom _MOTIF_CLIP_LOCK = XInternAtom (display, XmS_MOTIF_CLIP_LOCK, False);
    Window lock_owner = XGetSelectionOwner (display, _MOTIF_CLIP_LOCK);
    Boolean release_lock = False;
    Atom ignoretype;

    if (lock_owner != window && lock_owner != None)
	return (ClipboardFail);

    ClipboardFindItem (display, XM_LOCK_ID, (XtPointer *)&lockptr,
		       &length, &ignoretype, 0, 0);

    if (length == 0) /* There is no lock property */
    {
    	return (ClipboardFail);
    }

    if ( lockptr->windowId != window ) /* Someone else has the lock */
    {
    	XtFree ((char *)lockptr);
    	return (ClipboardFail);
    }

    /* do the unlock */

    if (all_levels == 0)
    {
        lockptr->lockLevel -= 1;
    }else{
        lockptr->lockLevel = 0;
    }

    if (lockptr->lockLevel <= 0)
    {
	length = 0;
	release_lock = True;
    }else{
	length = sizeof(ClipboardLockRec);
    }

    ClipboardReplaceItem (display, XM_LOCK_ID, (XtPointer)lockptr, length,
			  PropModeReplace, 32, False, XA_INTEGER);
    XtFree ((char *)lockptr);


    if (release_lock == True) {
	XSetSelectionOwner (display, _MOTIF_CLIP_LOCK, None,
			    ClipboardGetCurrentTime(display));
    }

    return (ClipboardSuccess);
}

/*---------------------------------------------*/
static int 
ClipboardSearchForWindow(
        Display *display,
        Window parentwindow,
        Window window )
{
    /* recursively search the roots descendant tree for the given window */

    Window rootwindow, p_window, *children;
    unsigned int numchildren;
    int found, i;
    Window *windowptr;

    if (XQueryTree( display, parentwindow, &rootwindow, &p_window,
		     &children, &numchildren ) == 0)
    {
	return (0);
    }

    found = 0;
    windowptr = children;

    /* now search through the list for the window */
    for ( i = 0; i < numchildren; i++ )
    {
	if ( *windowptr == window )
    	{
    	    found = 1;
    	}else{
    	    found = ClipboardSearchForWindow( display, *windowptr, window); 
   	}
    	if ( found == 1 ) break;
	windowptr = windowptr + 1;
    }

    XtFree( (char*)children );

    return found;
}

/*---------------------------------------------*/
static int 
ClipboardWindowExists(
        Display *display,
        Window window )
{
    Window rootwindow;
    Atom itematom;
    int exists;
    unsigned long outlength;
    unsigned char *outpointer;
    Atom type;
    int format;
    unsigned long bytes_left;

    outpointer = NULL;

    rootwindow = RootWindow( display, 0 );

    exists = ClipboardSearchForWindow( display, rootwindow, window );

    if ( exists == 1 )
    {
	/* see if the window has the lock activity property, for if
	   it doesn't then this is a new assignment of the window id
	   and the lock is bogus due to a crash of the application 
	   with the original locking window */
       itematom = XInternAtom(display, XmS_MOTIF_CLIP_LOCK_ACCESS_VALID, False);

       XGetWindowProperty( display, 
			window, 
			itematom,
			0, /*offset*/
			10000000, /*length*/
			False,
			AnyPropertyType,
			&type,
			&format,
			&outlength,
			&bytes_left,
			&outpointer );

	if ( outpointer == 0 || outlength == 0 )
    	{
    	    /* not the same window that locked the clipboard */
	    exists = 0;
    	}

    if(outpointer != NULL)
	   XFree((char*)outpointer);
    }    

    return exists;
}
/*---------------------------------------------*/
/* external routines			       */
/*---------------------------------------------*/


/*---------------------------------------------*/
int 
XmClipboardBeginCopy(
        Display *display,   /* display id for application passing data */
        Window window,  /* window to receive request for cut by name data */
        XmString label,     /* label to be associated with data item   */
        Widget widget,      /* only for cut by name */
        VoidProc callback,/* addr of callback routine for cut by name */
        long *itemid )      /* received id to identify this data item */
{
    return(XmClipboardStartCopy( display, window, label, CurrentTime, 
				widget, (XmCutPasteProc)callback, itemid ));
}

/*---------------------------------------------*/
int 
XmClipboardStartCopy(
        Display *display,   /* display id for application passing data */
        Window window,  /* window to receive request for cut by name data */
        XmString label, /* label to be associated with data item   */
        Time timestamp, /* timestamp of event triggering copy to clipboard */
        Widget widget,  /* only for cut by name */
        XmCutPasteProc callback,/* addr of callback routine for cut by name */
        long *itemid )  /* received id to identify this data item */
{
    ClipboardHeader header;
    ClipboardDataItem itemheader;
    unsigned long itemlength;
    itemId loc_itemid;
    int status;
    char *asn1string;
    int asn1strlen;
    _XmDisplayToAppContext(display);

    _XmAppLock(app);
    status = ClipboardLock( display, window );
    if ( status == ClipboardLocked ) {
	_XmAppUnlock(app);
	return ClipboardLocked;
    }

    /* get the clipboard header, make sure clipboard is initialized */
    header = ClipboardOpen( display, 0 );

    header->selectionTimestamp = timestamp;
    header->startCopyCalled = (unsigned long) True;

    /* allocate storage for the data item  */ 
    itemlength = sizeof( ClipboardDataItemRec );

    itemheader = (ClipboardDataItem)XtMalloc( (size_t) itemlength );

    loc_itemid = ClipboardGetNewItemId( display ); 

    /* initialize fields in the data item */
    itemheader->thisItemId = loc_itemid;
    itemheader->adjunctData = 0;
    itemheader->recordType = XM_DATA_ITEM_RECORD_TYPE;
    itemheader->displayId = display;
    itemheader->windowId  = window;
    itemheader->dataItemLabelId = ClipboardGetNewItemId( display ); 
    itemheader->formatIdList = itemlength / CONVERT_32_FACTOR; /* offset */
    itemheader->formatCount = 0;
    itemheader->cancelledFormatCount = 0;
    itemheader->deletePendingFlag = 0;
    itemheader->permanentItemFlag = 0;
    itemheader->cutByNameFlag = 0;
    itemheader->cutByNameCBIndex = -1;
    itemheader->cutByNameWidget = 0;
    itemheader->cutByNameWindow = 0;

    if ( callback != 0 && widget != 0 )
    {
      int i = 0;
      Boolean found = False;

      _XmProcessLock(); 
      while(i < maxCbProcs && ! found) {
 	if (cbProcTable[i] == NULL)
 	  found = True;
 	else
 	  i++;
      }
       
      if (! found) {
 	int oldLimit = maxCbProcs;
 	
 	maxCbProcs += 20;
 	
 	/* Need to extend tables */
 	cbProcTable = (XmCutPasteProc *) XtRealloc((char*) cbProcTable,
 						   sizeof(XmCutPasteProc) *
 						   maxCbProcs);
 	cbIdTable = (long *) XtRealloc((char*) cbIdTable, 
 				       sizeof(long) * maxCbProcs);
 	for(i = oldLimit; i < maxCbProcs; i++) {
 	  cbProcTable[i] = NULL;
 	  cbIdTable[i] = 0;
 	}
 	i = oldLimit;
      }
       
      cbProcTable[i] = callback;
      cbIdTable[i] = itemheader->thisItemId;
      _XmProcessUnlock();
   
      /* set up client message handling if widget passed */
      itemheader->cutByNameCBIndex = i;
      itemheader->cutByNameWidget = widget;
      itemheader->cutByNameWindow = XtWindow( widget );
      ClipboardSetAccess( display, itemheader->cutByNameWindow );
    }

    if (label != NULL) {
      asn1strlen = XmCvtXmStringToByteStream(label,
					     (unsigned char **) &asn1string);
    
      /* store the label */
      ClipboardReplaceItem(display, 
			   itemheader->dataItemLabelId,
			   (XtPointer) asn1string,
			   asn1strlen,
			   PropModeReplace,
			   8,
			   False, 
			   XInternAtom(display, 
				       XmS_MOTIF_COMPOUND_STRING, False));

      XtFree(asn1string);
    }

    /* return the item to the root window */
    ClipboardReplaceItem(display, 
			 loc_itemid,
			 (XtPointer)itemheader,
			 itemlength,
			 PropModeReplace,
			 32,
			 True,
			 XA_INTEGER );

    if ( itemid != 0 )
    {
        *itemid = (long)loc_itemid;
    }

    ClipboardClose( display, header );

    ClipboardUnlock( display, window, 0 );

    _XmAppUnlock(app);
    return ClipboardSuccess;
}

/* The following code is a workaround for UTM to pass in the type of the
   to be copied data.  It is a bug in the clipboard interface that the
   type information cannot be passed in.  Note that when Motif goes to
   multithread safety,  anything calling _XmClipboardPassType will need
   to have a critical section around that call and the call to 
   XmClipboardCopy or XmClipboardCopyByName */

static Atom _passed_type = None;

void
_XmClipboardPassType(Atom type)
{
  _XmProcessLock();
  _passed_type = type;
  _XmProcessUnlock();
}

int 
XmClipboardCopy(
        Display *display,   /* Display id of application passing data */
        Window window,
        long itemid,        /* id returned from begin copy */
        char *format,       /* Name string for data format */
        XtPointer buffer,   /* Address of buffer holding data in this format */
        unsigned long length,   /* Length of the data */
        long private_id,     /* Private id provide by application */
        long *dataid )       /* Data id returned by clipboard */
{
    ClipboardDataItem itemheader;
    ClipboardHeader header;
    ClipboardFormatItem formatptr;
    char *formatdataptr;
    itemId formatid, formatdataid, *idptr;
    char *to_ptr;
    int status, count, format_len ;
    unsigned long maxname, formatlength, itemlength, formatdatalength;
    Atom type;
    _XmDisplayToAppContext(display);

    _XmAppLock(app);
    _XmProcessLock();
    if (_passed_type != None) {
      type = _passed_type;
      _passed_type = None;
    } else {
      type = GetTypeFromTarget(display, XInternAtom(display, format, False));
    }
    _XmProcessUnlock();

    status = ClipboardLock( display, window );
    if ( status == ClipboardLocked ) {
	_XmAppUnlock(app);
	return ClipboardLocked;
    }

    /* get the clipboard header */
    header = ClipboardOpen( display, 0 );
 
    if (!header->startCopyCalled) {
	XmeWarning(NULL, XM_CLIPBOARD_MESSAGE1);
        ClipboardUnlock( display, window, 0 );
	_XmAppUnlock(app);
        return ClipboardFail;
    } 

    /* first check to see if the format already exists for this item */
    formatptr = ClipboardFindFormat(display, header, format, 
				    (itemId) itemid, 0,
				    &maxname, &count, &formatlength );

    /* if format doesn't exist, then have to access the data item
       record */
    if ( formatptr == 0 )
    {
	/* get a pointer to the item */
	status = ClipboardRetrieveItem(display, 
				       (itemId)itemid,
				       sizeof( itemId ),
				       0,
				       (XtPointer *) &itemheader,
				       &itemlength,
				       NULL,
				       0,
				       XM_DATA_ITEM_RECORD_TYPE,
				       0 );
	if (status != ClipboardSuccess)
	{
	    ClipboardUnlock( display, window, 0 );
	    _XmAppUnlock(app);
	    return (status);
	}

	itemheader->formatCount = itemheader->formatCount + 1;

	if ((itemheader->formatCount * 2 + 2) >= XM_ITEM_ID_INC) {
	    XmeWarning(NULL, XM_CLIPBOARD_MESSAGE3);
	    XtFree( (char *)itemheader);
	    ClipboardUnlock( display, window, 0 );
	    _XmAppUnlock(app);
	    return ClipboardFail;
	}

	formatlength = sizeof( ClipboardFormatItemRec );

	/* allocate local storage for the data format record */ 
	formatptr     = (ClipboardFormatItem)XtMalloc( (size_t) formatlength );

	formatid     = ClipboardGetNewItemId( display ); 
	formatdataid = ClipboardGetNewItemId( display ); 

	/* put format record id in data item's format id list */
	idptr = (itemId*)( (char *)itemheader + (itemlength - sizeof(itemId)) );

	*idptr = formatid; 

	/* initialize the fields in the format record */
	formatptr->recordType = XM_FORMAT_HEADER_TYPE;
	formatptr->formatNameAtom = XInternAtom( display, format, False );
	formatptr->itemLength = 0;
	formatptr->formatNameLength = strlen( format );
	formatptr->formatDataId = formatdataid;
	formatptr->thisFormatId = formatid;
	formatptr->itemPrivateId = private_id;
	formatptr->cancelledFlag = 0;
	formatptr->copiedLength = 0;
	formatptr->parentItemId = itemid;
	formatptr->cutByNameWidget = itemheader->cutByNameWidget;
	formatptr->cutByNameWindow = itemheader->cutByNameWindow;
	formatptr->cutByNameCBIndex = itemheader->cutByNameCBIndex;
	formatptr->windowId = itemheader->windowId;
	formatptr->displayId = itemheader->displayId;

	/* if buffer is null then it is a pass by name */
	if ( buffer != 0 )
	{
	    formatptr->cutByNameFlag = 0;
	    formatdatalength = length;
	}else{
	    itemheader->cutByNameFlag = 1;
	    formatptr->cutByNameFlag = 1;
	    formatdatalength = sizeof(Atom);  /* we want a property stored regardless */
	}    	

	if( ClipboardGetLenFromFormat( display, format, &format_len ) 
			== ClipboardFail)
	{
	    /* if it's one of the predefined formats, register 
	       it for second try */
	  XmClipboardRegisterFormat(display, format, 0);

	  ClipboardGetLenFromFormat( display, format, &format_len );
	}

	/* return the property on the root window for the item */
	ClipboardReplaceItem(display, itemid, (XtPointer)itemheader,
			     itemlength, PropModeReplace, 32,
			     True, XA_INTEGER );

	formatdataptr = XtMalloc( (size_t) formatdatalength );

        to_ptr = formatdataptr; 
    }else{
    	formatid = formatptr->thisFormatId;
    	formatdataid = formatptr->formatDataId;
    	
    	/* the format already existed so get the data and append */
    	ClipboardRetrieveItem(display, 
			      formatdataid,
			      (int) length, /* BAD NEWS: truncation here.*/
			      0,
			      (XtPointer *) &formatdataptr,
			      &formatdatalength,
			      NULL,
			      &format_len,
			      0,
			      0 );

	to_ptr = (char *)formatdataptr + (formatdatalength - length);
    }

    if ( buffer != 0 )
    {
	/* copy the format data over to acquired storage */
	memcpy( to_ptr, buffer, (size_t) length );
    }

    formatptr->itemLength += length/((format_len==32)?CONVERT_32_FACTOR:1);

    /* replace the property on the root window for the format data */
    ClipboardReplaceItem(display, 
			 formatdataid,
			 formatdataptr,
			 formatdatalength,
			 PropModeReplace,
			 format_len,  /* 8, 16, or 32 */
			 True,
			 type );
    
    /* replace the property on the root window for the format */
    ClipboardReplaceItem(display, 
			 formatid,
			 (XtPointer)formatptr,
			 formatlength,
			 PropModeReplace,
			 32,
			 True,
			 XA_INTEGER);

    if ( dataid != 0 )
    {
        *dataid = formatid;
    }

    ClipboardClose( display, header );

    ClipboardUnlock( display, window, 0 );

    _XmAppUnlock(app);
    return ClipboardSuccess;
}

/*---------------------------------------------*/
int 
XmClipboardEndCopy(
        Display *display,
        Window window,
        long itemid )
{
    ClipboardDataItem itemheader;
    ClipboardHeader header;
    itemId *itemlist;
    unsigned long itemlength ;
    long newitemoffset;
    itemId *newitemaddr;
    int status;
    Atom itemtype;
    _XmDisplayToAppContext(display);

    _XmAppLock(app);
    status = ClipboardLock( display, window );
    if ( status == ClipboardLocked ) {
	_XmAppUnlock(app);
	return ClipboardLocked;
    }

    /* get the clipboard header */
    header = ClipboardOpen( display, sizeof( itemId ) );

    if (!header->startCopyCalled) {
	XmeWarning(NULL, XM_CLIPBOARD_MESSAGE2);
        ClipboardUnlock( display, window, 0 );
	_XmAppUnlock(app);
        return ClipboardFail;
    } 

    ClipboardDeleteMarked( display, window, header );

    if (header->currItems >= header->maxItems) 
    {
	itemlist = (itemId*)((char *) header + 
			     header->dataItemList * CONVERT_32_FACTOR);

    	/* mark least recent item for deletion and delete previously mark */
        ClipboardMarkItem( display, header, *itemlist, XM_DELETE );

    	header->deletedByCopyId = *itemlist;
    } else {
	header->deletedByCopyId = 0;
    }

    newitemoffset = header->dataItemList + 
    		    (header->currItems * sizeof( itemId ) / CONVERT_32_FACTOR);

    /* stick new item at the bottom of the list */
    newitemaddr = (itemId*)((char *) header + newitemoffset * CONVERT_32_FACTOR);

    *newitemaddr = (itemId)itemid;

    /* new items always become next paste item */
    header->oldNextPasteItemId  = header->nextPasteItemId;
    header->nextPasteItemId = (itemId)itemid;
    header->lastCopyItemId = (itemId)itemid;

    header->currItems = header->currItems + 1;
    header->startCopyCalled = False;

    /* if there was a cut by name format, then set up event handling */
    ClipboardFindItem(display,
		      itemid,
		      (XtPointer *) &itemheader,
		      &itemlength,
		      &itemtype,
		      0,
		      XM_DATA_ITEM_RECORD_TYPE );

    if ( itemheader == 0 ) 
    {
	CleanupHeader (display);
	ClipboardError( CLIPBOARD_CORRUPT, CORRUPT_DATA_STRUCTURE );
    	return ClipboardFail;
    }

    if ( itemheader->cutByNameWindow != 0 )
    {
        EventMask event_mask = 0;

    	XtAddEventHandler( XtWindowToWidget(display, 
					    itemheader->cutByNameWindow), 
			  event_mask, TRUE, 
			  ClipboardEventHandler, 0 );
    }

    XtFree( (char *) itemheader ); 

    AssertClipboardSelection(display, window, header, 
			     header->selectionTimestamp );

    ClipboardSetNextItemId(display, itemid);

    ClipboardClose( display, header );

    ClipboardUnlock( display, window, 0 );

    _XmAppUnlock(app);
    return ClipboardSuccess;
}

/*---------------------------------------------*/
int 
XmClipboardCancelCopy(
        Display *display,
        Window window,
        long itemid )   /* id returned by begin copy */
{
    itemId deleteitemid;
    itemId previous;
    XtPointer int_ptr;
    unsigned long length;
    ClipboardHeader header;
    Atom type;
    _XmDisplayToAppContext(display);

    _XmAppLock(app);
    if ( ClipboardLock( display, window) == ClipboardLocked ) {
	_XmAppUnlock(app);
        return(ClipboardLocked);
    }

    deleteitemid = (itemId)itemid;

    /* first, free up the properties set by the StartCopy and Copy calls */

    /* delete the item label */
    ClipboardDeleteItemLabel( display, window, deleteitemid);

    /* delete all the formats belonging to the data item */
    ClipboardDeleteFormats( display, window, deleteitemid );

    /* now delete the item itself */
    ClipboardDeleteId( display, deleteitemid );

    /*******************************************************************
     * reset the startCopyCalled flag and reset the XM_NEXT_ID property
     * it's value prior to StartCopy. 
     *******************************************************************/
    ClipboardFindItem( display,
			XM_NEXT_ID,
			&int_ptr,
			&length,
			&type,
			0,
			0 );

    previous = itemid - 1;
    *(long *) int_ptr = previous;

    ClipboardReplaceItem( display,
			XM_NEXT_ID,
			int_ptr,
			sizeof(long),
			PropModeReplace,
			32,
			True,
			XA_INTEGER );

    header = ClipboardOpen( display, 0);
    header->startCopyCalled = False;
    ClipboardClose( display, header );

    ClipboardUnlock( display, window, 0 );

    _XmAppUnlock(app);
    return(ClipboardSuccess);
}

/*---------------------------------------------*/
int 
XmClipboardWithdrawFormat(
        Display *display,
        Window window,
        long data )  /* data id of format no longer provided by application */
{
    int status;
    _XmDisplayToAppContext(display);

    _XmAppLock(app);
    status = ClipboardLock( display, window  );
    if ( status == ClipboardLocked ) {
	_XmAppUnlock(app);
	return ClipboardLocked;
    }

    ClipboardDeleteFormat( display, data );

    ClipboardUnlock( display, window, 0 );

    _XmAppUnlock(app);
    return ClipboardSuccess;
}

/*---------------------------------------------*/
int 
XmClipboardCopyByName(
        Display *display,   /* Display id of application passing data */
        Window window,
        long data,          /* Data id returned previously by clipboard */
        XtPointer buffer,   /* Address of buffer holding data in this format */
        unsigned long length,   /* Length of the data */
        long private_id )    /* Private id provide by application */
{
    ClipboardFormatItem formatheader;
    int format;
    char *formatdataptr;
    unsigned long formatlength, formatdatalength;
    char *to_ptr;
    int status, locked;
    unsigned long headerlength;
    ClipboardHeader root_clipboard_header;
    Atom headertype, formattype;
    Atom type;
    _XmDisplayToAppContext(display);

    _XmAppLock(app);
    /* get the clipboard header */
    ClipboardFindItem( display, 
			   XM_HEADER_ID,
			   (XtPointer *) &root_clipboard_header,
			   &headerlength,
			   &headertype,
			   0,
    			   0 );

    locked = 0;

    /* if this is a recopy as the result of a callback, then circumvent */
    /* any existing lock */
    if ( root_clipboard_header->recopyId != data )
    {        
	status = ClipboardLock( display, window );
	if ( status == ClipboardLocked ){
	    _XmAppUnlock(app);
	    return ClipboardLocked;
	}
    	locked = 1;

    }else{
	root_clipboard_header->recopyId = 0;

	/* replace the clipboard header */
	ClipboardReplaceItem(display, 
			     XM_HEADER_ID,
			     (XtPointer)root_clipboard_header,
			     headerlength,
			     PropModeReplace,
			     32,
			     False,
			     XA_INTEGER );
    }

    /* get a pointer to the format */
    if ( ClipboardFindItem(display, 
			   data,
			   (XtPointer *) &formatheader,
			   &formatlength,
			   &formattype,
			   0,
			   XM_FORMAT_HEADER_TYPE ) == ClipboardSuccess )
    {
	formatheader->itemPrivateId = private_id;

    	ClipboardRetrieveItem(display, 
			      formatheader->formatDataId,
			      (int) length,/* BAD NEWS: truncation here.*/
			      0,
			      (XtPointer *) &formatdataptr,
			      &formatdatalength,
			      &formattype,
			      &format,
			      0,
			      formatheader->cutByNameFlag ); 

	if (formatheader->cutByNameFlag)
	    formatheader->itemLength = length/((format==32)?CONVERT_32_FACTOR:1);
	else
	    formatheader->itemLength += length/((format==32)?CONVERT_32_FACTOR:1);

	/* if cut by name, discard any old data */
    	formatheader->cutByNameFlag = 0;
    	
        to_ptr = (char *) formatdataptr + (formatdatalength - length);

	/* copy the format data over to acquired storage */
	memcpy( to_ptr, buffer, (size_t) length );

	/* If we've passed in a new type from UTM,  use it,  otherwise
	   we'll use the type on the clipboard (for compatibility with 
	   old mechanism) */
	_XmProcessLock();
	if (_passed_type != None) {
	  type = _passed_type;
	  _passed_type = None;
	} else {
	  type = formattype;
	}
	_XmProcessUnlock();

	/* create the property on the root window for the format data */
	ClipboardReplaceItem(display, 
			     formatheader->formatDataId,
			     formatdataptr,
			     length,
			     PropModeReplace,
			     format,
			     True,
			     type );

	/* change the property on the root window for the format item */
	ClipboardReplaceItem(display, 
			     data,
			     (XtPointer)formatheader,
			     formatlength,
			     PropModeReplace,
			     32,
			     True,
			     XA_INTEGER);
    }
    else {
	CleanupHeader (display);
	ClipboardError( CLIPBOARD_CORRUPT, CORRUPT_DATA_STRUCTURE );
    	return ClipboardFail;
    }

    if ( locked )
    {
        ClipboardUnlock( display, window, 0 );
    }

    XtFree( (char *) root_clipboard_header );

    _XmAppUnlock(app);
    return ClipboardSuccess;
}


/*---------------------------------------------*/
int 
XmClipboardUndoCopy(
        Display *display,
        Window window )
{
    ClipboardHeader header;
    ClipboardDataItem itemheader;
    unsigned long itemlength;
    itemId itemid;
    int status, undo_okay;
    Atom itemtype;
    _XmDisplayToAppContext(display);

    _XmAppLock(app);
    status = ClipboardLock( display, window );
    if ( status == ClipboardLocked ) {
	_XmAppUnlock(app);
	return ClipboardLocked;
    }

    /* note: second call to undo, undoes the first call */

    /* get the clipboard header */
    header = ClipboardOpen( display, 0 );

    itemid = header->lastCopyItemId;

    undo_okay = 0;

    if ( itemid == 0 )
    {
    	undo_okay = 1;

    } else {
	/* get the item */
	ClipboardFindItem( display,
			       itemid,
			       (XtPointer *) &itemheader,
			       &itemlength,
			       &itemtype,
			       0,
    			       XM_DATA_ITEM_RECORD_TYPE );

	if ( itemheader == 0 ) 
	{
	   CleanupHeader (display);
	   ClipboardError( CLIPBOARD_CORRUPT, CORRUPT_DATA_STRUCTURE );
	   return ClipboardFail;
	}

	/* if no last copy item
	   or if the item's window or display don't match, then can't undo */
	if ( itemheader->windowId == window ) 
	{
    	    undo_okay = 1;

	    /* mark last item for delete
	    */
    	    ClipboardMarkItem( display, header, itemid, XM_DELETE );
    	}

    	XtFree( (char*)itemheader );
    }

    if ( undo_okay )
    {
	/* fetch the item marked deleted by the last copy, if any */
	itemid = header->deletedByCopyId;

	/* mark it undeleted */
	ClipboardMarkItem( display, header, itemid, XM_UNDELETE );

	/* switch item marked deleted */
	header->deletedByCopyId = header->lastCopyItemId;
	header->lastCopyItemId = itemid;

	/* switch next paste and old next paste */
	itemid = header->oldNextPasteItemId;
	header->oldNextPasteItemId = header->nextPasteItemId;
	header->nextPasteItemId = itemid;
    }

    ClipboardClose( display, header );

    ClipboardUnlock( display, window, 0 );

    _XmAppUnlock(app);
    return ClipboardSuccess;
}

/*---------------------------------------------*/
int 
XmClipboardLock(
        Display *display,
        Window window )     /* identifies application owning lock */
{
    int ret_val;
    _XmDisplayToAppContext(display);
    _XmAppLock(app);
    ret_val = ClipboardLock( display, window );
    _XmAppUnlock(app);
    return ret_val;
}


/*---------------------------------------------*/
int 
XmClipboardUnlock(
        Display *display,
        Window window,  /* specifies window owning lock, must match window */
#if NeedWidePrototypes  /* passed to clipboardlock */
        int all_levels )
#else
        Boolean all_levels )
#endif /* NeedWidePrototypes */
{
    int ret_val;
    _XmDisplayToAppContext(display);
    _XmAppLock(app);
    ret_val = ClipboardUnlock( display, window, all_levels );
    _XmAppUnlock(app);
    return ret_val;
}


/*---------------------------------------------*/
int 
XmClipboardStartRetrieve(
        Display *display,       /* Display id of application wanting data */
        Window window,
        Time timestamp )
{
    ClipboardHeader header;
    int status;
    _XmDisplayToAppContext(display);

    _XmAppLock(app);
    status = ClipboardLock( display, window );
    if ( status == ClipboardLocked ) {
	_XmAppUnlock(app);
	return ClipboardLocked;
    }

    header = ClipboardOpen( display, 0 );

    header->incrementalCopyFrom = True;
    header->copyFromTimestamp = timestamp;
    header->foreignCopiedLength = 0;

    ClipboardClose( display, header );

    ClipboardUnlock( display, window, 0 );

    _XmAppUnlock(app);
    return ClipboardSuccess;
}

/*---------------------------------------------*/
int 
XmClipboardEndRetrieve(
        Display *display,   /* Display id of application wanting data */
        Window window )
{
    ClipboardHeader header;
    _XmDisplayToAppContext(display);

    _XmAppLock(app);
    header = ClipboardOpen( display, 0 );

    header->incrementalCopyFrom = False;
    header->copyFromTimestamp   = CurrentTime;

    ClipboardClose( display, header );

    ClipboardUnlock( display, window, 0 );

    _XmAppUnlock(app);
    return ClipboardSuccess;
}

/*---------------------------------------------*/
int 
XmClipboardRetrieve(
        Display *display,        /* Display id of application wanting data */
        Window window,
        char *format,   /* Name string for data format */
        XtPointer buffer, /* Address of buffer to receive data in this format */
        unsigned long length,    /* Length of the data buffer */
        unsigned long *outlength,/* Length of the data transferred to buffer */
        long *private_id )   /* Private id provide by application */
{
  Atom ignoretype;
  int  ret_val;
  _XmDisplayToAppContext(display);

  _XmAppLock(app);
  ret_val = ClipboardRetrieve(display, window, format, buffer,
		   length, outlength, private_id, &ignoretype);
  _XmAppUnlock(app);
  return ret_val;
}

static int
ClipboardRetrieve(Display *display, Window window,
		  char *format, XtPointer buffer,
		  unsigned long length,
		  unsigned long *outlength,
		  long *private_id,
		  Atom *outtype)
{
    ClipboardHeader header;
    ClipboardFormatItem matchformat;
    char *formatdata;
    unsigned long formatdatalength ;
    unsigned long matchformatlength;
    Atom matchformattype;
    int truncate, count;
    unsigned long maxname ;
    itemId matchid;
    char *ptr;
    int status, dataok, outformatsize;
    unsigned long loc_outlength;
    itemId loc_private;
    unsigned long copiedlength, remaininglength;
    Time timestamp;
    
    status = ClipboardLock( display, window );
    if ( status == ClipboardLocked ) return ClipboardLocked;

    /* get the clipboard header */
    header = ClipboardOpen( display, 0 );
    timestamp = header->copyFromTimestamp;

    loc_outlength = 0;
    loc_private = 0;
    truncate = 0;
    dataok = 0;
    ptr = NULL;

    /* check to see if we need to reclaim the selection */
    InitializeSelection( display, header, window, timestamp );

    /* get the data from clipboard or selection owner */
    if ( WeOwnSelection( display, header ) )
    {
	/* we own the selection */

	/* find the matching format for the next paste item */
	matchformat = ClipboardFindFormat(display, header, format,
					  (itemId) NULL, 0,
					  &maxname, &count, 
					  &matchformatlength );
	if (matchformat != 0)
	  {
	    dataok = 1;

	    matchid = matchformat->thisFormatId;

	    if ( matchformat->cutByNameFlag == 1 )
	    {
		/* passed by name */

 	        /* Note:  This code is now partially copied into
		   another function,  ClipboardGetByNameItem,  so
		   updates in this section should be reflected there */

		dataok = ClipboardRequestDataAndWait(display, 
						     window,
						     matchformat);
		if ( dataok )
		{
		  /* re-check out matchformat since it may have changed */
		  XtFree( (char *) matchformat );

		  ClipboardFindItem(display,
				    matchid,
				    (XtPointer *) &matchformat,
				    &matchformatlength,
				    &matchformattype,
				    0,
				    XM_FORMAT_HEADER_TYPE );

		  if ( matchformat == 0 ) 
		  {
 		     CleanupHeader (display);
		     ClipboardError( CLIPBOARD_CORRUPT,
				     CORRUPT_DATA_STRUCTURE );
		     return ClipboardFail;
		   }
		}
	    }

	    if ( dataok )
	    {
	        ClipboardFindItem(display,
				  matchformat->formatDataId,
				  (XtPointer *) &formatdata,
				  &formatdatalength,
				  outtype,
				  0,
				  0 );

		if ( matchformat == 0 ) 
		{
 		   CleanupHeader (display);
		   ClipboardError( CLIPBOARD_CORRUPT, CORRUPT_DATA_STRUCTURE );
		   return ClipboardFail;
		}

		copiedlength = matchformat->copiedLength;
		ptr = formatdata + copiedlength;

		remaininglength = formatdatalength - copiedlength;

		if ( length < remaininglength )
		{
		    loc_outlength = length;
		    truncate = 1;
		}else{
		    loc_outlength = remaininglength;
		}

		if ( header->incrementalCopyFrom )
		{
		    /* update the copied length */
		    if ( loc_outlength == remaininglength )
		    {
			/* we've copied everything, so reset */
			matchformat->copiedLength = 0;
		    }else{
			matchformat->copiedLength = matchformat->copiedLength
						  + loc_outlength;
		    }
		}

		loc_private = matchformat->itemPrivateId;
	    }

	    ClipboardReplaceItem(display, 
				 matchid,
				 (XtPointer)matchformat,
				 matchformatlength,
				 PropModeReplace,
				 32,
				 True,
				 XA_INTEGER );
	}


	/* Unfortunately the clipboard routines don't have a type
	   interface.  Go ask for a type if type is bogus */
	if (*outtype == None)
	  *outtype = GetTypeFromTarget(display, 
				       XInternAtom(display, format, False));
    }else{
	/* we don't own the selection, get the data from selection owner */
        if ( ClipboardGetSelection(display, window, 
				   XInternAtom(display, format, False),
				   (XtPointer *) &formatdata, 
				   outtype, &loc_outlength,
				   &outformatsize ) )
	{
	    /* we're okay */
		dataok = 1;

		/* copiedlength = header->foreignCopiedLength; */
		copiedlength = 0; /* No incr. for now.  Fix after beta */

		ptr = formatdata + copiedlength;

		remaininglength = loc_outlength - copiedlength;

		if ( length < remaininglength )
		{
		    loc_outlength = length;
		    truncate = 1;
		}else{
		    loc_outlength = remaininglength;
		}

		if ( header->incrementalCopyFrom )
		{
		    /* update the copied length */
		    if ( loc_outlength == remaininglength )
		    {
			/* we've copied everything, so reset */
			header->foreignCopiedLength = 0;
		    }else{
			header->foreignCopiedLength = 
						header->foreignCopiedLength
						  + loc_outlength;
		    }
		}
	    }
    }

    if ( dataok )
    {
	/* copy the data to the user buffer */
	memcpy( buffer, ptr, (size_t) loc_outlength );

	XtFree( (char *) formatdata );
    }

    /* try to prevent access violation even if outlength is mandatory */
    if ( outlength != 0 )
    {
    	*outlength = loc_outlength;
    }

    if ( private_id != 0 )
    {    	
	*private_id = loc_private;
    }


    ClipboardClose( display, header );
    ClipboardUnlock( display, window, 0 );

    if (truncate == 1) return ClipboardTruncate;
    if (dataok == 0)   return ClipboardNoData;    

    return ClipboardSuccess;
}

/*---------------------------------------------*/
int 
XmClipboardInquireCount(
        Display *display,
        Window window,
        int *count,     /* receives number of formats in next paste item */
        unsigned long *maxlength )/* receives max length of format names */
{
    ClipboardHeader header;
    char *alloc_to_free;
    unsigned long loc_maxlength, loc_matchlength;
    unsigned long loc_count_len ;
    int status;
    int loc_count ;
    Atom ignoretype;
    int ignoreformat;
    Time timestamp;
    _XmDisplayToAppContext(display);

    _XmAppLock(app);
    status = ClipboardLock( display, window );
    if ( status == ClipboardLocked ) {
	_XmAppUnlock(app);
	return ClipboardLocked;
    }

    /* get the clipboard header */
    header = ClipboardOpen( display, 0 );

    /* If StartRetrieve wasn't called use latest Timestamp from server */

    if ( header->copyFromTimestamp == CurrentTime )
    {
        timestamp = ClipboardGetCurrentTime(display);
    }else{
        timestamp = header->copyFromTimestamp;
    }

    /* check to see if we need to reclaim the selection */
    InitializeSelection( display, header, window, timestamp );
    loc_maxlength = 0;
    loc_count = 0;

    /* do we own the selection? */
    if ( WeOwnSelection( display, header ) )
    {
	/* yes, find the next paste item, only looking for
	   maxlength and count */
	alloc_to_free = (char*)ClipboardFindFormat( display, header, 0, 
							(itemId) NULL, 0,
							&loc_maxlength, 
							&loc_count,
							&loc_matchlength );
    }else{
	/* we don't own the selection, get the data from selection owner */
        if ( !ClipboardGetSelection(display, window, 
				    XInternAtom(display, XmSTARGETS, False),
				    (XtPointer *) &alloc_to_free, 
				    &ignoretype,
				    &loc_count_len,
				    &ignoreformat ) )
        {
	    _XmAppUnlock(app);
            return ClipboardNoData;

        }else{
            /* we obtained a TARGETS type selection conversion */
            Atom *atomptr;
            int i;

            atomptr   = (Atom*)alloc_to_free;

            /* returned count is in bytes, targets are atoms of
	       length sizeof(long) */
            loc_count = (int) loc_count_len / sizeof(Atom);

	    /* max the lengths of all the atom names */
	    for( i = 0; i < loc_count; i++ )
	    {
		    int temp;

		    if ((*atomptr) != (Atom)0)
		    {
		        char *str;

			str =  XGetAtomName( display, *atomptr );
			temp = strlen(str);
			XFree(str);

			if ( temp > loc_maxlength) 
			{
			    loc_maxlength = temp;
			}
		    }
		    atomptr++;
	     }
	}
    }	

    if ( maxlength != 0 )
    {
	/* user asked for max length of available format names */
	*maxlength = loc_maxlength;
    }

    if ( count != 0 )
    {
	*count = loc_count;
    }

    if ( alloc_to_free != 0 )
    {
	XtFree( (char *) alloc_to_free ); 
    }

    ClipboardClose( display, header );
    ClipboardUnlock( display, window, 0 );

    _XmAppUnlock(app);
    return ClipboardSuccess;
}


/*---------------------------------------------*/
int 
XmClipboardInquireFormat(
        Display *display,       /* Display id of application inquiring */
        Window window,
        int n,                  /* Which format for this data item? */
        XtPointer buffer,       /* Address of buffer to receive format name */
        unsigned long bufferlength, /* Length of the buffer */
        unsigned long *outlength )  /* Receives length copied to name buffer */
{
    ClipboardHeader header;
    ClipboardFormatItem matchformat;
    char *alloc_to_free;
    char *ptr;
    int count;
    unsigned long loc_matchlength, maxname, loc_outlength ;
    int status;
    Atom ignoretype;
    int ignoreformat;
    _XmDisplayToAppContext(display);

    _XmAppLock(app);
    status = ClipboardLock( display, window );
    if ( status == ClipboardLocked ) {
	_XmAppUnlock(app);
	return ClipboardLocked;
    }

    status = ClipboardSuccess;

    /* get the clipboard header */
    header = ClipboardOpen( display, 0 );

    /* check to see if we need to reclaim the selection */
    InitializeSelection( display, header, window, 
			     header->copyFromTimestamp );

    ptr = NULL;
    loc_outlength = 0;

    /* do we own the selection? */
    if ( WeOwnSelection( display, header ) )
    {
	/* retrieve the matching format */
	matchformat = ClipboardFindFormat(display, header, 0,
					     (itemId) NULL, n,
					     &maxname, &count, 
					     &loc_matchlength );

	if ( matchformat != 0 ) {
	  ptr = XGetAtomName( display, matchformat->formatNameAtom ); 
	  XtFree( (char *) matchformat );
	} else {
	  status = ClipboardNoData;
	}
    }else{
        /* we don't own the selection, get the data from selection owner */
        if ( !ClipboardGetSelection(display, window, 
				    XInternAtom(display, XmSTARGETS, False),
				    (XtPointer *) &alloc_to_free,
				    &ignoretype,
				    &loc_matchlength, &ignoreformat ) )
        {
            *outlength = 0;
	    _XmAppUnlock(app);
            return ClipboardNoData;

        } else {
            /* we obtained a TARGETS type selection conversion */
            Atom *nth_atom;

            nth_atom = (Atom*)alloc_to_free;

            /* returned count is in bytes, targets are atoms 
	       of length sizeof(long) */
            loc_matchlength = loc_matchlength / sizeof(Atom);

            if ( loc_matchlength >= n )
            {
                nth_atom = nth_atom + n - 1;

                ptr = XGetAtomName( display, *nth_atom );

                XtFree( (char *) alloc_to_free );
            }
	}
    }

    if ( ptr != 0 )
    {
	loc_outlength = strlen( ptr );

	if ( loc_outlength > bufferlength )
	{
	    status = ClipboardTruncate;

	    loc_outlength = bufferlength;
	}
	strncpy( (char *) buffer, ptr, (unsigned) loc_outlength );
	/* loc_outlenght is truncated above.*/

	XtFree( (char *) ptr );
    }

    if ( outlength != 0 )
    {
    	*outlength = loc_outlength;
    }

    ClipboardClose( display, header );
    ClipboardUnlock( display, window, 0 );

    _XmAppUnlock(app);
    return status;
}


/*---------------------------------------------*/
int 
XmClipboardInquireLength(
        Display *display,   /* Display id of application inquiring */
        Window window,
        char *format,       /* Name string for data format */
        unsigned long *length )/* Receives length of the data in that format */
{

    ClipboardHeader header;
    ClipboardFormatItem matchformat;
    char *alloc_to_free;
    int count ;
    unsigned long loc_length, maxname, loc_matchlength;
    Atom ignoretype;
    int ignoreformat;
    int status;
    int format_len;
    _XmDisplayToAppContext(display);

    _XmAppLock(app);
    status = ClipboardLock( display, window );
    if ( status == ClipboardLocked ) {
	_XmAppUnlock(app);
	return ClipboardLocked;
    }

    /* get the clipboard header */
    header = ClipboardOpen( display, 0 );

    /* check to see if we need to reclaim the selection */
    InitializeSelection( display, header, window, 
			     header->copyFromTimestamp );

    loc_length = 0;

    /* do we own the selection? */
    if ( WeOwnSelection( display, header ) )
    {
	/* retrieve the next paste item */
	matchformat = ClipboardFindFormat(display, header, format,
					     (itemId) NULL, 0, &maxname,
					     &count, &loc_matchlength);

	/* return the length */
	if ( matchformat != 0 )
	{
	    if ( CONVERT_32_FACTOR != 1 )
	      {
		  ClipboardGetLenFromFormat( display,
					    format,
					    &format_len );
		  loc_length = matchformat->itemLength * 
		    ((format_len==32)?CONVERT_32_FACTOR:1);
	      }
	    else
	      {
		  loc_length = matchformat->itemLength;
	      }

	    XtFree( (char *) matchformat );
	} else {
	  status = ClipboardNoData;
	}
    }else{
        /* we don't own the selection, get the data from selection owner */
        if ( !ClipboardGetSelection(display, window,
				    XInternAtom(display, format, False),
				    (XtPointer *) &alloc_to_free,
				    &ignoretype, &loc_length, &ignoreformat ) )
        {
	    _XmAppUnlock(app);
            return ClipboardNoData;

        }else{

            XtFree( (char *) alloc_to_free );
	}
    }

    if ( length != 0 )
    {
    	*length = loc_length;
    }

    ClipboardClose( display, header );
    ClipboardUnlock( display, window, 0 );

    _XmAppUnlock(app);
    return status;
}


/*---------------------------------------------*/
int 
XmClipboardInquirePendingItems(
        Display *display,       /* Display id of application passing data */
        Window window,
        char *format,           /* Name string for data format */
        XmClipboardPendingList *list,
        unsigned long *count )  /* Number of items in returned list */
{
    ClipboardHeader header;
    ClipboardFormatItem matchformat;
    XmClipboardPendingList itemlist, nextlistptr;
    itemId *id_ptr;
    int loc_count, i;
    unsigned long maxname, loc_matchlength;
    int status;
    _XmDisplayToAppContext(display);

    _XmAppLock(app);
    status = ClipboardLock( display, window );
    if ( status == ClipboardLocked ) {
	_XmAppUnlock(app);
	return ClipboardLocked;
    }

    if ( list == 0 )
    {
    	/* just get out to avoid access violation */
	ClipboardUnlock( display, window, 0 );
	_XmAppUnlock(app);
        return ClipboardSuccess;
    }

    *list = 0;
    loc_count = 0;

    /* get the clipboard header */
    header = ClipboardOpen( display, 0 );

    id_ptr = (itemId*)((char *) header +
		       header->dataItemList * CONVERT_32_FACTOR);

    itemlist = (XmClipboardPendingList)XtMalloc( (size_t)
    			(header->currItems * sizeof( XmClipboardPendingRec)));

    nextlistptr = itemlist;

    /* run through all the items in the clipboard looking 
       for matching formats */
    for ( i = 0; i < header->currItems; i++ )
    {
    	/* if it is marked for delete, skip it */
    	if ( ClipboardIsMarkedForDelete( display, header, *id_ptr ) )
    	{
    	    matchformat = 0;
    	}else{
    	    int dummy;

	    /* see if there is a matching format */
	    matchformat = ClipboardFindFormat( display, header, 
						   format, *id_ptr, 
						   0, &maxname, &dummy,
    						   &loc_matchlength );
    	}

    	if ( matchformat != 0 )
    	{
    	    /* found matching format */
    	    if ( matchformat->cutByNameFlag == 1 )
    	    {
    		/* it was passed by name so is pending */
    	    	nextlistptr->DataId = matchformat->thisFormatId;    	    
    	    	nextlistptr->PrivateId = matchformat->itemPrivateId;

    		nextlistptr = nextlistptr + 1;
    		loc_count = loc_count + 1;
    	    }

    	    XtFree( (char *) matchformat );
    	}

    	id_ptr = id_ptr + 1;
    }

    ClipboardClose( display, header );

    ClipboardUnlock( display, window, 0 );

    if ( count != 0 )
    {
        *count = loc_count;
    }

    *list  = itemlist;

    _XmAppUnlock(app);
    return status;
}


/*---------------------------------------------*/
int
XmClipboardRegisterFormat(
        Display *display,       /* Display id of application passing data */
        char *format_name,      /* Name string for data format            */
        int format_length )     /* Format length  8-16-32         */
{
    int ret_val;
    _XmDisplayToAppContext(display);

    _XmAppLock(app);
    if ( format_length != 0 && 
	 format_length != 8 && format_length != 16 && format_length != 32 )
    {
    	XmeWarning ( NULL, BAD_FORMAT );
	_XmAppUnlock(app);
	return ClipboardBadFormat;
    }

    if ( format_name == 0  ||  strlen( format_name ) == 0 )
    {
    	XmeWarning ( NULL, BAD_FORMAT_NON_NULL );
    }

    /* make sure predefined formats are registered */
    /* use dummy format as a test, if not found then register the rest */
    if ( format_length != 0 )
    {
	ret_val = RegisterFormat( display, format_name, format_length );
	_XmAppUnlock(app);
	return ret_val;

    }else{
      /* caller asking to look through predefines for format name */
      if (
	RegIfMatch( display, format_name, XmSTARGETS, XM_ATOM ) ||
	RegIfMatch( display, format_name, XmSMULTIPLE, XM_ATOM_PAIR ) ||
	RegIfMatch( display, format_name, XmSTIMESTAMP, XM_INTEGER ) ||
	RegIfMatch( display, format_name, "STRING", XM_STRING ) ||
        RegIfMatch( display, format_name, XmSCOMPOUND_TEXT, XM_COMPOUND_TEXT) ||
	RegIfMatch( display, format_name, XmILIST_LENGTH, XM_INTEGER ) ||
	RegIfMatch( display, format_name, "PIXMAP", XM_DRAWABLE ) ||
	RegIfMatch( display, format_name, "DRAWABLE", XM_DRAWABLE ) ||
	RegIfMatch( display, format_name, "BITMAP", XM_BITMAP ) ||
	RegIfMatch( display, format_name, XmIFOREGROUND, XM_PIXEL ) ||
	RegIfMatch( display, format_name, XmIBACKGROUND, XM_PIXEL ) ||
	RegIfMatch( display, format_name, "COLORMAP", XM_COLORMAP ) ||
	RegIfMatch( display, format_name, XmIODIF, XM_TEXT ) ||
	RegIfMatch( display, format_name, XmIOWNER_OS, XM_TEXT ) ||
	RegIfMatch( display, format_name, XmSFILE_NAME, XM_TEXT ) ||
	RegIfMatch( display, format_name, XmIHOST_NAME, XM_TEXT ) ||
	RegIfMatch( display, format_name, XmICHARACTER_POSITION, XM_SPAN ) ||
	RegIfMatch( display, format_name, XmILINE_NUMBER, XM_SPAN ) ||
	RegIfMatch( display, format_name, XmICOLUMN_NUMBER, XM_SPAN ) ||
	RegIfMatch( display, format_name, XmSLENGTH, XM_INTEGER ) ||
	RegIfMatch( display, format_name, XmIUSER, XM_TEXT ) ||
	RegIfMatch( display, format_name, XmIPROCEDURE, XM_TEXT ) ||
	RegIfMatch( display, format_name, XmIMODULE, XM_TEXT ) ||
	RegIfMatch( display, format_name, XmIPROCESS, XM_INTEGER ) ||
	RegIfMatch( display, format_name, XmITASK, XM_INTEGER ) ||
	RegIfMatch( display, format_name, XmICLASS, XM_TEXT ) ||
	RegIfMatch( display, format_name, XmINAME, XM_TEXT ) ||
	RegIfMatch( display, format_name, XmSCLIENT_WINDOW, XM_WINDOW )
	 )  {
	    _XmAppUnlock(app);
	    return ClipboardSuccess;
	    }
    }

    _XmAppUnlock(app);
    return ClipboardFail;
}

/*********************************************************************
 * GetTypeFromTarget
 *
 * This function makes an attempt to get a suitable type for a 
 * particular target.  This isn't perfect,  but much better than
 * the old clipboard method which simply used the target as the
 * type.  Most requestors won't care,  and they definitely won't
 * via the clipboard routines,  as these have no type parameter.
 * But UTM and other ICCCM clients care
 *********************************************************************/

static Atom
GetTypeFromTarget(Display *display, Atom target)
{
  enum { 
    XmAATOM_PAIR, XmABACKGROUND, XmACHARACTER_POSITION, XmACLASS,
    XmACOLUMN_NUMBER, XmAFOREGROUND, XmAHOST_NAME, XmALINE_NUMBER,
    XmALIST_LENGTH, XmAMODULE, XmANAME, XmANone, XmAODIF, XmAOWNER_OS,
    XmAPIXEL, XmAPROCEDURE, XmAPROCESS, XmASPAN, XmATASK, XmAUSER,
    XmACLIENT_WINDOW, XmADELETE, XmAFILE, XmAFILE_NAME,
    XmAINSERT_PROPERTY, XmAINSERT_SELECTION, XmALENGTH,
    XmALINK_SELECTION, XmAMULTIPLE, XmATARGETS, XmATEXT, XmATIMESTAMP,
    XmA_MOTIF_CLIPBOARD_TARGETS, XmA_MOTIF_DEFERRED_CLIPBOARD_TARGETS,
    XmA_MOTIF_ENCODING_REGISTRY, XmA_MOTIF_EXPORT_TARGETS,
    XmA_MOTIF_RENDER_TABLE, NUM_ATOMS };
  static char *atom_names[] = { 
    XmIATOM_PAIR, XmIBACKGROUND, XmICHARACTER_POSITION, XmICLASS,
    XmICOLUMN_NUMBER, XmIFOREGROUND, XmIHOST_NAME, XmILINE_NUMBER,
    XmILIST_LENGTH, XmIMODULE, XmINAME, XmINone, XmIODIF, XmIOWNER_OS,
    XmIPIXEL, XmIPROCEDURE, XmIPROCESS, XmISPAN, XmITASK, XmIUSER,
    XmSCLIENT_WINDOW, XmSDELETE, XmSFILE, XmSFILE_NAME,
    XmSINSERT_PROPERTY, XmSINSERT_SELECTION, XmSLENGTH,
    XmSLINK_SELECTION, XmSMULTIPLE, XmSTARGETS, XmSTEXT, XmSTIMESTAMP,
    XmS_MOTIF_CLIPBOARD_TARGETS, XmS_MOTIF_DEFERRED_CLIPBOARD_TARGETS,
    XmS_MOTIF_ENCODING_REGISTRY, XmS_MOTIF_EXPORT_TARGETS,
    XmS_MOTIF_RENDER_TABLE };
  Atom atoms[XtNumber(atom_names)];

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

  if (target == atoms[XmATARGETS] ||
      target == atoms[XmA_MOTIF_EXPORT_TARGETS] ||
      target == atoms[XmA_MOTIF_CLIPBOARD_TARGETS] ||
      target == atoms[XmA_MOTIF_DEFERRED_CLIPBOARD_TARGETS])
    return(XA_ATOM);
  if (target == atoms[XmAMULTIPLE]) 
    return(atoms[XmAATOM_PAIR]);
  if (target == atoms[XmATIMESTAMP] ||
      target == atoms[XmALIST_LENGTH] ||
      target == atoms[XmAPROCESS] ||
      target == atoms[XmATASK] ||
      target == atoms[XmALENGTH])
    return(XA_INTEGER);
  if (target == atoms[XmATEXT] ||
      target == atoms[XmAODIF] ||
      target == atoms[XmAOWNER_OS] ||
      target == atoms[XmAFILE_NAME] ||
      target == atoms[XmAFILE] ||
      target == atoms[XmAHOST_NAME] ||
      target == atoms[XmAUSER] ||
      target == atoms[XmAPROCEDURE] ||
      target == atoms[XmAMODULE] ||
      target == atoms[XmACLASS] ||
      target == atoms[XmANAME]) {
    int ret_status = 0;
    XTextProperty tmp_prop;
    char * tmp_string = "ABC";  /* these are characters in XPCS, so... safe */
    Atom encoding;

    tmp_prop.value = NULL; 
    ret_status = XmbTextListToTextProperty(display, &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);
    return(encoding);
  }
  if (target == XA_PIXMAP) return(XA_DRAWABLE);
  if (target == atoms[XmAFOREGROUND] ||
      target == atoms[XmABACKGROUND])
    return(atoms[XmAPIXEL]);
  if (target == atoms[XmACHARACTER_POSITION] ||
      target == atoms[XmALINE_NUMBER] ||
      target == atoms[XmACOLUMN_NUMBER])
    return(atoms[XmASPAN]);
  if (target == atoms[XmACLIENT_WINDOW])
    return(XA_WINDOW);
  if (target == atoms[XmADELETE] ||
      target == atoms[XmAINSERT_SELECTION] ||
      target == atoms[XmALINK_SELECTION] ||
      target == atoms[XmAINSERT_PROPERTY])
    return(atoms[XmANone]);
  if (target == atoms[XmA_MOTIF_ENCODING_REGISTRY] ||
      target == atoms[XmA_MOTIF_RENDER_TABLE])
    return(XA_STRING);

  return(target); /* by default */
}
