/*
 * Motif
 *
 * Copyright (c) 1987-2012, The Open Group. All rights reserved.
 *
 * These libraries and programs are free software; you can
 * redistribute them and/or modify them under the terms of the GNU
 * Lesser General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * These libraries and programs are distributed in the hope that
 * they will be useful, but WITHOUT ANY WARRANTY; without even the
 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 * PURPOSE. See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with these librararies and programs; if not, write
 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
 * Floor, Boston, MA 02110-1301 USA
 * 
 */
#ifdef REV_INFO
#ifndef lint
static char rcsid[] = "$RCSfile: DataFSel.c,v $ $Revision: 1.6 $ $Date: 2003/10/06 10:10:23 $"
#endif
#endif
/*
*  (c) Copyright 1989, 1990, 1991, 1992 HEWLETT-PACKARD COMPANY */

#include <Xm/Ext.h>
#include <Xm/DataFSelP.h>
#include <Xm/DataFP.h>
#include <X11/Xatom.h>
#include <Xm/AtomMgr.h>
#include <Xm/XmosP.h>
#include <Xm/DragC.h>
#include <Xm/TextFP.h>


/********    Static Function Declarations    ********/
#ifdef _NO_PROTO

static void InsertSelection() ;
static Boolean ConvertInsertSelection() ;
static void HandleInsertTargets() ;

#else

static void InsertSelection( 
                        Widget w,
                        XtPointer closure,
                        Atom *seltype,
                        Atom *type,
                        XtPointer value,
                        unsigned long *length,
                        int *format) ;
static Boolean ConvertInsertSelection( 
                        Widget w,
                        Atom *selection,
                        Atom *type,
                        XtPointer *value,
                        unsigned long *length,
                        int *format,
			Atom locale_atom) ;
static void HandleInsertTargets(
                        Widget w,
                        XtPointer closure,
                        Atom *seltype,
                        Atom *type,
                        XtPointer value,
                        unsigned long *length,
                        int *format );
#endif /* _NO_PROTO */
/********    End Static Function Declarations    ********/

#ifdef _NO_PROTO
extern void _XmDataFieldDeselectSelection();
extern void _XmDataFieldStartSelection();
extern int _XmDataFieldCountBytes();
extern Boolean _XmDataFielddf_SetDestination();
extern void _XmDataFielddf_SetCursorPosition();
#else
#if NeedWidePrototypes
#define WIDE_PROTOTYPE		int
#else
#define WIDE_PROTOTYPE		Boolean
#endif

extern void _XmDataFieldDeselectSelection(Widget, int, WIDE_PROTOTYPE, Time);
extern void _XmDataFieldStartSelection(XmDataFieldWidget, XmTextPosition,
				       XmTextPosition, Time);
extern int _XmDataFieldCountBytes(XmDataFieldWidget, wchar_t *, int);
extern Boolean _XmDataFielddf_SetDestination(Widget, XmTextPosition, Time);
extern void _XmDataFielddf_SetCursorPosition(XmDataFieldWidget, XEvent *,
					     XmTextPosition, WIDE_PROTOTYPE,
					     WIDE_PROTOTYPE);

#undef WIDE_PROTOTYPE
#endif /* _NO_PROTO */


/* ARGSUSED */
static void
#ifdef _NO_PROTO
InsertSelection( w, closure, seltype, type, value, length, format )
        Widget w ;
        XtPointer closure ;
        Atom *seltype ;
        Atom *type ;
        XtPointer value ;
        unsigned long *length ;
        int *format ;
#else
InsertSelection(
        Widget w,
        XtPointer closure,
        Atom *seltype,
        Atom *type,
        XtPointer value,
        unsigned long *length,
        int *format )
#endif /* _NO_PROTO */
{
    _XmInsertSelect *insert_select = (_XmInsertSelect *) closure;
    XmDataFieldWidget tf = (XmDataFieldWidget) w;
    XmTextPosition left = 0;
    XmTextPosition right = 0;
    Boolean replace_res = False;
    Boolean dest_disjoint = False;
    wchar_t * wc_value;
    char * temp;
    int num_chars = 0;
    Atom COMPOUND_TEXT = XmInternAtom(XtDisplay(w), "COMPOUND_TEXT", False);
    char * total_tmp_value = NULL;
    XTextProperty tmp_prop;
    char **tmp_value;
    int num_vals;
    int malloc_size = 0;
    int i, status = 0;
    XmAnyCallbackStruct cb;

    if (!value) {
       insert_select->done_status = True;
       return;
    }

   /* Don't do replace if there is not text to add */
    if (*(char *) value == (char)'\0' || *length == 0){
       XtFree((char *)value);
       insert_select->done_status = True;
       return;
    }

    if (insert_select->select_type == XmPRIM_SELECT) {
       if (!XmDataFieldGetSelectionPosition (w, &left, &right) ||
	   left == right) {
          XBell(XtDisplay(w), 0);
          XtFree((char *)value);
          insert_select->done_status = True;
          insert_select->success_status = False;
          return;
       } 
    } else if (insert_select->select_type == XmDEST_SELECT) {
      if (XmDataFieldGetSelectionPosition (w, &left, &right) && left != right) {
         if ( TextF_CursorPosition(tf) < left ||
	      TextF_CursorPosition(tf) > right ||
              !XmTextF_pending_delete(tf)) {
            left = right = TextF_CursorPosition(tf);
            dest_disjoint = True;
         }
      } else
         left = right = TextF_CursorPosition(tf);
    }


    if (*type == COMPOUND_TEXT || *type == XA_STRING) {
       tmp_prop.value = (unsigned char *) value;
       tmp_prop.encoding = *type;
       tmp_prop.format = *format;
       tmp_prop.nitems = *length;
       num_vals = 0;
       status = XmbTextPropertyToTextList(XtDisplay(w), &tmp_prop, &tmp_value, 
					  &num_vals);
      /* if no conversion, num_vals won't change */
      /* status >0 if some characters can't be converted; continue anyway */
       if (num_vals && (status == Success || status > 0)) {
          for (i = 0; i < num_vals ; i++)
              malloc_size += strlen(tmp_value[i]);

          total_tmp_value = XtMalloc ((unsigned) malloc_size + 1);
          total_tmp_value[0] = '\0';
          for (i = 0; i < num_vals ; i++)
             strcat(total_tmp_value, tmp_value[i]);
	  XFreeStringList(tmp_value);
       }


       if (XmTextF_max_char_size(tf) == 1) {
          replace_res = _XmDataFieldReplaceText(tf, 
                                                (XEvent *) insert_select->event,
					        left, right, total_tmp_value, 
                                                malloc_size, True);
       } else { /* must convert to wchar_t before passing to Replace */
          wc_value = (wchar_t *)XtMalloc((unsigned) 
                               (1 + malloc_size) * sizeof(wchar_t));
          num_chars = mbstowcs(wc_value, total_tmp_value, 1 + malloc_size);
          replace_res = _XmDataFieldReplaceText(tf,
                                                (XEvent *) insert_select->event,
                                                left, right, (char*) wc_value,
                                                num_chars, True);
          XtFree((char *)wc_value);
       }
       XtFree(total_tmp_value);
    } else { /* it must be either TEXT or codeset of the locale */
       if (XmTextF_max_char_size(tf) == 1) {
         /* NOTE: casting *length could result in a truncated long. */
          replace_res = _XmDataFieldReplaceText(tf, 
					        (XEvent *)insert_select->event,
						left, right, (char *)value,
					        (unsigned)*length, True);
       } else {
          temp = XtMalloc((unsigned) *length + 1);
         /* NOTE: casting *length could result in a truncated long. */
          (void)memcpy((void*)temp, (void*)value, (unsigned)*length);
          temp[*length] = '\0';
          wc_value = (wchar_t*)XtMalloc((unsigned)
                                               (*length + 1) * sizeof(wchar_t));
      
         /* NOTE: casting *length could result in a truncated long. */
          num_chars = mbstowcs(wc_value, temp, (unsigned)*length + 1);
          replace_res = _XmDataFieldReplaceText(tf, 
                                                (XEvent *) insert_select->event,
					        left, right, (char*) wc_value,
					        num_chars, True);
          XtFree(temp);
          XtFree((char *)wc_value);
       }
    }

    if (!replace_res) {
       insert_select->success_status = False;
    } else {
       insert_select->success_status = True;

       if (!XmTextF_add_mode(tf)) XmTextF_prim_anchor(tf) = left;

       XmTextF_pending_off(tf) = True;
       if (XmTextF_max_char_size(tf) == 1)
       {
         _XmDataFielddf_SetCursorPosition(tf, NULL,
					  (XmTextPosition)(left + *length),
					  False, True);
       }
       else
       {
         _XmDataFielddf_SetCursorPosition(tf, NULL, left + num_chars, 
				       False, True);
       }
       (void) _XmDataFielddf_SetDestination(w, TextF_CursorPosition(tf),
					 insert_select->event->time);
       if (insert_select->select_type == XmDEST_SELECT) {
          if (left != right) {
             if (!dest_disjoint) {
                _XmDataFieldStartSelection(tf, TextF_CursorPosition(tf),
					   TextF_CursorPosition(tf),
                                           insert_select->event->time);
             } else {
                if (!XmTextF_add_mode(tf)) {
                   _XmDataFieldStartSelection(tf, TextF_CursorPosition(tf),
				  	      TextF_CursorPosition(tf),
                                  	      insert_select->event->time);
                }
             }
          }
       }
       cb.reason = XmCR_VALUE_CHANGED;
       cb.event = (XEvent *)insert_select->event;
       XtCallCallbackList((Widget) tf, TextF_ValueChangedCallback(tf),
                          (XtPointer) &cb);
    }

    XtFree((char *)value);
    value = NULL;
    insert_select->done_status = True;
}

/* ARGSUSED */
static void
#ifdef _NO_PROTO
HandleInsertTargets( w, closure, seltype, type, value, length, format )
        Widget w ;
        XtPointer closure ;
        Atom *seltype ;
        Atom *type ;
        XtPointer value ;
        unsigned long *length ;
        int *format ;
#else
HandleInsertTargets(
        Widget w,
        XtPointer closure,
        Atom *seltype,
        Atom *type,
        XtPointer value,
        unsigned long *length,
        int *format )
#endif /* _NO_PROTO */
{
   _XmInsertSelect *insert_select = (_XmInsertSelect *) closure;
   Atom TEXT = XmInternAtom(XtDisplay(w), "TEXT", False);
   Atom COMPOUND_TEXT = XmInternAtom(XtDisplay(w),"COMPOUND_TEXT", False);
   Atom target = TEXT;
   Atom *atom_ptr;
   int i;

   if (!length) {
      XtFree((char *)value);
      insert_select->done_status = True;
      return; /* Supports no targets, so don't bother sending anything */
   }

   atom_ptr = (Atom *)value;

    for (i = 0; i < *length; i++, atom_ptr++) {
      if (*atom_ptr == COMPOUND_TEXT) {
         target = *atom_ptr;
         break;
      } else if (*atom_ptr == XA_STRING)
         target = *atom_ptr;
    }

   XtGetSelectionValue(w, *seltype, target,
                       InsertSelection,
                       (XtPointer) insert_select,
                       insert_select->event->time);

}

/*
 * Converts requested target of insert selection.
 */
/*--------------------------------------------------------------------------+*/
static Boolean
#ifdef _NO_PROTO
ConvertInsertSelection( w, selection, type, value, length, format, locale_atom )
        Widget w ;
        Atom *selection ;
        Atom *type ;
        XtPointer *value ;
        unsigned long *length ;
        int *format ;
	Atom locale_atom;
#else
ConvertInsertSelection(
        Widget w,
        Atom *selection,
        Atom *type,
        XtPointer *value,
        unsigned long *length,
        int *format,
	Atom locale_atom)
#endif /* _NO_PROTO */
{
   XtAppContext app = XtWidgetToApplicationContext(w);
   XSelectionRequestEvent * req_event;
   static unsigned long old_serial = 0;
   Atom TARGETS = XmInternAtom(XtDisplay(w), "TARGETS", False);
   Atom MOTIF_DESTINATION = XmInternAtom(XtDisplay(w), "MOTIF_DESTINATION",
					 False);
   Atom actual_type;
   int actual_format;
   unsigned long nitems;
   unsigned long bytes;
   unsigned char *prop = NULL;
   _XmInsertSelect insert_select;
   _XmTextInsertPair *pair;

   insert_select.done_status = False;
   insert_select.success_status = False;

   if (*selection == MOTIF_DESTINATION) {
      insert_select.select_type = XmDEST_SELECT;
   } else if (*selection == XA_PRIMARY) {
      insert_select.select_type = XmPRIM_SELECT;
   }

   req_event = XtGetSelectionRequest(w, *selection, NULL);

   insert_select.event = req_event;

  /* Work around for intrinsics selection bug */
   if (old_serial != req_event->serial)
      old_serial = req_event->serial;
   else
      return False;

   if (XGetWindowProperty(req_event->display, req_event->requestor,
                      req_event->property, 0L, 10000000, False,
                      AnyPropertyType, &actual_type, &actual_format,
                      &nitems, &bytes, &prop) != Success)
      return FALSE;

   pair = (_XmTextInsertPair *)prop;

   if (pair->target != locale_atom) {
     /*
      * Make selection request to find out which targets
      * the selection can provide.
      */
      XtGetSelectionValue(w, pair->selection, TARGETS,
                          HandleInsertTargets,
                          (XtPointer) &insert_select,
                          req_event->time);
   } else {
     /*
      * Make selection request to replace the selection
      * with the insert selection.
      */
      XtGetSelectionValue(w, pair->selection, pair->target,
                          InsertSelection,
                          (XtPointer) &insert_select,
                          req_event->time);
   }
  /*
   * Make sure the above selection request is completed
   * before returning from the convert proc.
   */
   for (;;) {
       XEvent event;

       if (insert_select.done_status)
          break;
       XtAppNextEvent(app, &event);
       XtDispatchEvent(&event);
   }

   *type = XmInternAtom(XtDisplay(w), "NULL", False);
   *format = 8;
   *value = NULL;
   *length = 0;

   if(    prop != NULL    )
     {
       XFree((void *)prop);
     }
   return (insert_select.success_status);
}

/* ARGSUSED */
Boolean
#ifdef _NO_PROTO
_XmDataFieldConvert( w, selection, target, type, value, length, format )
        Widget w ;
        Atom *selection ;
        Atom *target ;
        Atom *type ;
        XtPointer *value ;
        unsigned long *length ;
        int *format ;
#else
_XmDataFieldConvert(
        Widget w,
        Atom *selection,
        Atom *target,
        Atom *type,
        XtPointer *value,
        unsigned long *length,
        int *format )
#endif /* _NO_PROTO */
{
    XmDataFieldWidget tf;
    Atom MOTIF_DESTINATION = XmInternAtom(XtDisplay(w),
                                        "MOTIF_DESTINATION", False);
    Atom INSERT_SELECTION = XmInternAtom(XtDisplay(w),
                                           "INSERT_SELECTION", False);
    Atom DELETE = XmInternAtom(XtDisplay(w), "DELETE", False);
    Atom CLIPBOARD = XmInternAtom(XtDisplay(w), "CLIPBOARD", False);
    Atom LENGTH = XmInternAtom(XtDisplay(w), "LENGTH", False);
    Atom TARGETS = XmInternAtom(XtDisplay(w), "TARGETS", False);
    Atom MULTIPLE = XmInternAtom(XtDisplay(w), "MULTIPLE", False);
    Atom TEXT = XmInternAtom(XtDisplay(w), "TEXT", False);
    Atom COMPOUND_TEXT = XmInternAtom(XtDisplay(w), "COMPOUND_TEXT", False);
    Atom TIMESTAMP = XmInternAtom(XtDisplay(w), "TIMESTAMP", False);
    Atom MOTIF_DROP = XmInternAtom(XtDisplay(w), "_MOTIF_DROP", False);
    Atom CS_OF_LOCALE; /* to be initialized by XmbTextListToTextProperty */
    XSelectionRequestEvent * req_event;
    Boolean has_selection = False;
    XmTextPosition left = 0;
    XmTextPosition right = 0;
    Boolean is_primary;
    Boolean is_secondary;
    Boolean is_destination;
    Boolean is_drop;
    int target_count = 0;
    XTextProperty tmp_prop;
    int ret_status = 0;
    int MAX_TARGS = 20;
    char * tmp_value;
    char * tmp_string = "ABC";  /* these are characters in XPCS, so... safe */
    XtPointer c_ptr;
    Arg args[1];
    XmAnyCallbackStruct cb;

    if (*selection == MOTIF_DROP) {
       XtSetArg (args[0], XmNclientData, &c_ptr);
       XtGetValues (w, args, 1);
       tf = (XmDataFieldWidget) c_ptr;
    } else
       tf = (XmDataFieldWidget) w;

    if (tf == NULL) return False;

    ret_status = XmbTextListToTextProperty(XtDisplay(w), &tmp_string, 1,
                                      (XICCEncodingStyle)XTextStyle, &tmp_prop);
    if (ret_status == Success)
       CS_OF_LOCALE = tmp_prop.encoding;
    else
       CS_OF_LOCALE = (Atom) 9999; /* XmbTextList... should always be able
				       * to convert XPCS characters; but in
				       * case its broken, this prevents a core
				       * dump.
				       */

    if ((*selection == XA_PRIMARY) || (*selection == CLIPBOARD)) {
       has_selection = XmTextF_has_primary(tf);
       left = XmTextF_prim_pos_left(tf);
       right = XmTextF_prim_pos_right(tf);
       is_primary = True;
       is_secondary = is_destination = is_drop = False;
    } else if (*selection == MOTIF_DESTINATION) {
       has_selection = XmTextF_has_destination(tf);
       is_destination = True;
       is_secondary = is_primary = is_drop = False;
    } else if (*selection == XA_SECONDARY) {
       has_selection = XmTextF_has_secondary(tf);
       left = XmTextF_sec_pos_left(tf);
       right = XmTextF_sec_pos_right(tf);
       is_secondary = True;
       is_destination = is_primary = is_drop = False;
    } else if (*selection == MOTIF_DROP) {
       has_selection = XmTextF_has_primary(tf);
       left = XmTextF_prim_pos_left(tf);
       right = XmTextF_prim_pos_right(tf);
       is_drop = True;
       is_destination = is_primary = is_secondary = False;
    } else
       return False;

  /*
   * TARGETS identifies what targets the textfield widget can
   * provide data for.
   */
    if (*target == TARGETS) {
      Atom *targs = (Atom *)XtMalloc((unsigned) (MAX_TARGS * sizeof(Atom)));

      *value = (XtPointer) targs;
      *targs++ = CS_OF_LOCALE; target_count++;
      *targs++ = TARGETS; target_count++;
      *targs++ = LENGTH; target_count++;
      *targs++ = MULTIPLE; target_count++;
      *targs++ = TIMESTAMP; target_count++;
      if (is_primary || is_destination)
         *targs++ = INSERT_SELECTION; target_count++;
      if (is_primary || is_secondary || is_drop) {
         *targs++ = COMPOUND_TEXT; target_count++;
         *targs++ = TEXT; target_count++;
         *targs++ = XA_STRING; target_count++;
      }
      if (is_primary || is_drop) {
         *targs++ = DELETE; target_count++;
      }
      *type = XA_ATOM;
      *length = (target_count*sizeof(Atom)) >> 2; /*convert to work count */
      *format = 32;
   } else if (*target == TIMESTAMP) {
      Time *timestamp;
      timestamp = (Time *) XtMalloc(sizeof(Time));
      if (is_primary)
         *timestamp = XmTextF_prim_time(tf);
      else if (is_destination)
         *timestamp = XmTextF_dest_time(tf);
      else if (is_secondary)
         *timestamp = XmTextF_sec_time(tf);
      else if (is_drop)
         *timestamp = XmTextF_prim_time(tf);
      *value = (XtPointer) timestamp;
      *type = XA_INTEGER;
      *length = sizeof(Time);
      *format = 32;
    } else if (*target == XA_STRING) {
      *type = (Atom) XA_STRING;
      *format = 8;
      if (is_destination || !has_selection) return False;

      /* put a char* value into tmp_value, then convert to 8859.1 */
      if (XmTextF_max_char_size(tf) != 1) {
	  int stat ;

	/* NOTE: casting (right - left) could result in a truncated long. */
         *length = _XmDataFieldCountBytes(tf, TextF_WcValue(tf) + left, 
                                          (int)(right - left));
         tmp_value = XtMalloc((unsigned) *length + 1);
         stat = wcstombs(tmp_value, TextF_WcValue(tf) + left,
		           (unsigned)*length); /* NOTE: casting *length could
					 	  result in a truncated long. */
	  if (stat < 0) /* wcstombs will return neg value on conv failure */
	      *length = 0;
	  else *length = (unsigned long) stat ;
      } else {
         *length = right - left;
         tmp_value = XtMalloc((unsigned) *length + 1);
        /* get the selection value */
         (void)memcpy((void*)tmp_value, (void*)(TextF_Value(tf) + left), 
		      (unsigned)*length); /* NOTE: casting *length could result
				             in a truncated long. */
      }
      tmp_value[*length] = '\0';
      /* convert tmp_value to 8859.1 */
      ret_status = XmbTextListToTextProperty(XtDisplay(w), &tmp_value, 1, 
                                             (XICCEncodingStyle)XStringStyle,
                                             &tmp_prop);
      XtFree(tmp_value);
      if (ret_status == Success || ret_status > 0){
         *value = (XtPointer) tmp_prop.value;
         *length = tmp_prop.nitems;
      } else {
         *value = NULL;
         *length = 0;
         return False;
      }
    } else if (*target == TEXT || *target == CS_OF_LOCALE) {
      *type = CS_OF_LOCALE;
      *format = 8;
      if (is_destination || !has_selection) return False;
      if (XmTextF_max_char_size(tf) != 1) {
	  int stat ;

	  /* NOTE: casting (right - left) could result in a truncated long. */
	  *length = _XmDataFieldCountBytes(tf, TextF_WcValue(tf) + left,
					   (int)(right - left));
	  *value = XtMalloc((unsigned) *length + 1);
	  stat = wcstombs((char *)*value, TextF_WcValue(tf) + left,
			  (unsigned)*length); /* NOTE: casting *length could
						 result in a truncated long */
	  if (stat < 0) /* wcstombs return neg value on conv failure */
	      *length = 0;
	  else *length = (unsigned long) stat ;
      } else {
         *length = right - left;
         *value = XtMalloc((unsigned) *length + 1);
        /* get the selection value */
         (void)memcpy((void*)*value, (void*)(TextF_Value(tf) + left),
		      (unsigned)*length); /* NOTE: casting *length could result
				             in a truncated long. */
      }
      (*(char **)value)[*length]='\0';
    } else if (*target == COMPOUND_TEXT) {
      *type = COMPOUND_TEXT;
      *format = 8;
      if (is_destination || !has_selection) return False;
      if (XmTextF_max_char_size(tf) != 1) { 
	int stat ;

	/* convert to char* before converting to CT.  NOTE: casting
         * (right - left) could result in a truncated long.
         */
         *length = _XmDataFieldCountBytes(tf, TextF_WcValue(tf) + left,
                                          (int)(right - left));
         tmp_value = XtMalloc((unsigned) *length + 1);
         stat = wcstombs(tmp_value, TextF_WcValue(tf) + left,
		           (unsigned)*length); /* NOTE: casting *length could
					 	  result in a truncated long. */
	if (stat < 0) /* wcstombs will return neg value on conv failure */
	    *length = 0;
	else *length = (unsigned long) stat ;
      } else { /* malloc the space and copy the data to be converted */
         *length = right - left;
         tmp_value = XtMalloc((unsigned) *length + 1);
        /* get the selection value */
         (void)memcpy((void*)tmp_value, (void*)(TextF_Value(tf) + left), 
		      (unsigned)*length); /* NOTE: casting *length could result
				             in a truncated long. */
      }
      tmp_value[*length] = '\0';

     /* Convert to compound text */
      ret_status = XmbTextListToTextProperty(XtDisplay(w), &tmp_value, 1,
                                          (XICCEncodingStyle)XCompoundTextStyle,
                                             &tmp_prop);
      XtFree(tmp_value);
      if (ret_status == Success || ret_status > 0){
         *length = tmp_prop.nitems;
	 *value = (XtPointer)tmp_prop.value;
      } else {
         *value = NULL;
         *length = 0;
         return False;
      }
  /*
   * Provide data for INSERT_SELECTION requests, used in
   * swaping selections.
   */
    } else if (*target == INSERT_SELECTION) {
      if (is_secondary) return False;
      return (ConvertInsertSelection((Widget) tf, selection, type,
                                     value, length, format, CS_OF_LOCALE));

  /* Delete the selection */
    } else if (*target == DELETE) {
      XmTextPosition left, right;
      Boolean move_cursor = True;

      if (!(is_primary || is_drop)) return False;

      if (is_drop) {
         Atom real_selection_atom; /* DND hides the selection atom from us */

         XtSetArg(args[0], XmNiccHandle, &real_selection_atom);
         XtGetValues(w, args, 1); /* 'w' is the drag context */
         req_event = XtGetSelectionRequest(w, real_selection_atom, NULL);
      } else {
         req_event = XtGetSelectionRequest((Widget) tf, *selection, NULL);
      }

      left = XmTextF_prim_pos_left(tf);
      right = XmTextF_prim_pos_right(tf);

      if (is_drop) {
           if (_XmDataFieldGetDropReciever((Widget)tf) == (Widget) tf)
              move_cursor = False;
      } else {
         if (req_event->requestor == XtWindow((Widget)tf))
	    move_cursor = False;
      }

      _XmDataFieldStartSelection(tf, XmTextF_prim_anchor(tf), XmTextF_prim_anchor(tf),
 				 req_event->time);

      if (!_XmDataFieldReplaceText(tf, (XEvent *) req_event,
				   left, right, NULL, 0, move_cursor)) {
           XmTextF_has_primary(tf) = True;
           return False;
      }
      cb.reason = XmCR_VALUE_CHANGED;
      cb.event = (XEvent *) req_event;
      XtCallCallbackList((Widget) tf, TextF_ValueChangedCallback(tf),
			 (XtPointer) &cb);

      XmTextF_has_primary(tf) = True;

      if (XmTextF_has_destination(tf))
          XmTextF_prim_anchor(tf) = TextF_CursorPosition(tf);

      *type = XmInternAtom(XtDisplay(w), "NULL", False);
      *value = NULL;
      *length = 0;
      *format = 8;
    } else if (*target == LENGTH) {
	long *len = (long*)XtMalloc(sizeof(long));

	if (right > left)
	    *len = right - left; 
	else
	    *len = left - right; 

	*value = (XtPointer)len;
	*type = XA_INTEGER;
    	*length = 1L;
    	*format = 32;
    } else   /* unknown selection type */
	return FALSE;
    return TRUE;
}

/* ARGSUSED */
void
#ifdef _NO_PROTO
_XmDataFieldLoseSelection( w, selection )
        Widget w ;
        Atom *selection ;
#else
_XmDataFieldLoseSelection(
        Widget w,
        Atom *selection )
#endif /* _NO_PROTO */
{
    XmDataFieldWidget tf = (XmDataFieldWidget) w;
    Atom MOTIF_DESTINATION = XmInternAtom(XtDisplay(w),
                                        "MOTIF_DESTINATION", False);
/* Losing Primary Selection */
    if (*selection == XA_PRIMARY && XmTextF_has_primary(tf)) {
        XmAnyCallbackStruct cb;
        _XmDataFieldDeselectSelection(w, False, 0, 
				      XtLastTimestampProcessed(XtDisplay(w)));

        cb.reason = XmCR_LOSE_PRIMARY;
        cb.event = NULL;
        XtCallCallbackList(w, XmTextF_lose_primary_callback(tf),
			   (XtPointer) &cb);
/* Losing Destination Selection */
    } else if (*selection == MOTIF_DESTINATION) {
        XmTextF_has_destination(tf) = False;
	if (XmTextF_has_rect(tf)) _XmDataFieldSetClipRect(tf);
       /* if we have focus, we have a valid putback area.  If we don't have
	* focus, don't want to update the putback with the destination cursor
	* image.
	*/
	XmTextF_refresh_ibeam_off(tf) = False;
	_XmDataFieldDrawInsertionPoint(tf, False);
	XmTextF_blink_on(tf) = True;
	_XmDataFieldDrawInsertionPoint(tf, True);
/* Losing Secondary Selection */
    } else if (*selection == XA_SECONDARY && XmTextF_has_secondary(tf)){
        _XmDataFieldSetSel2(w, 0, 0, True, 
			    XtLastTimestampProcessed(XtDisplay(w)));
    }
}
