/* 

 * Motif

 *

 * Copyright (c) 1987-2012, The Open Group. All rights reserved.

 *

 * These libraries and programs are free software; you can

 * redistribute them and/or modify them under the terms of the GNU

 * Lesser General Public License as published by the Free Software

 * Foundation; either version 2 of the License, or (at your option)

 * any later version.

 *

 * These libraries and programs are distributed in the hope that

 * they will be useful, but WITHOUT ANY WARRANTY; without even the

 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

 * PURPOSE. See the GNU Lesser General Public License for more

 * details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with these librararies and programs; if not, write

 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth

 * Floor, Boston, MA 02110-1301 USA

*/ 

/* 

 * HISTORY

*/ 

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#ifdef REV_INFO

#ifndef lint

static char rcsid[] = "$TOG: TextFSel.c /main/22 1997/10/14 15:38:30 cshi $"

#endif

#endif

/* (c) Copyright 1989, 1990, 1991, 1992 HEWLETT-PACKARD COMPANY */

#include <X11/Xatom.h>

#include <Xm/AtomMgr.h>

#include <Xm/DragC.h>

#include <Xm/TraitP.h>		/* for XmeTraitSet() */

#include <Xm/TransferP.h>

#include <Xm/TransferT.h>

#include <Xm/XmosP.h>

#include "TextFI.h"

#include "TextFSelI.h"

#include "TransferI.h"		/* for _XmConvertComplete() */

#include "TraversalI.h"		/* for _XmGetFocusPolicy() */

#include "XmI.h"

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

static void InsertSelection( 

                        Widget w,

                        XtPointer closure,

                        Atom *seltype,

                        Atom *type,

                        XtPointer value,

                        unsigned long *length,

                        int *format,

			XtPointer tid) ;

static void HandleInsertTargets(

                        Widget w,

                        XtPointer closure,

                        Atom *seltype,

                        Atom *type,

                        XtPointer value,

                        unsigned long *length,

                        int *format,

			XtPointer tid);

static void HandleDrop(Widget w,

		       XmDropProcCallbackStruct *cb,

		       XmDestinationCallbackStruct *ds);

static void TextFieldConvertCallback(Widget, 

				     XtPointer, 

				     XmConvertCallbackStruct*);

static void TextFieldDestinationCallback(Widget, 

					 XtPointer, 

					 XmDestinationCallbackStruct*);

static void SetDropContext(Widget w);

static void DeleteDropContext(Widget w);

static void HandleTargets(Widget w, 

			  XtPointer ignore, 

			  XmSelectionCallbackStruct *ds);

static void HandleDrop(Widget w,

		       XmDropProcCallbackStruct *cb,

		       XmDestinationCallbackStruct *ds);

static void DropDestroyCB(Widget w,

			  XtPointer clientData,

			  XtPointer callData);

static void DropTransferProc(Widget w, 

			     XtPointer ignore, 

			     XmSelectionCallbackStruct *ds);

static void DoStuff(Widget w, 

		    XtPointer ignore, 

		    XmSelectionCallbackStruct *ds);

/********    End Static Function Declarations    ********/

/* Transfer Trait record for TextField */

static XmConst XmTransferTraitRec textFieldTT = {

  0,  				/* version */

  (XmConvertCallbackProc) 	TextFieldConvertCallback,

  (XmDestinationCallbackProc)	TextFieldDestinationCallback,

  (XmDestinationCallbackProc)	NULL,

};

static XContext _XmTextFDNDContext = 0;

static _XmInsertSelect insert_select;

static _XmTextPrimSelect *prim_select;

/*ARGSUSED*/

static void

SetPrimarySelection(Widget w, 

		    XtEnum op,	/* unused */

		    XmTransferDoneCallbackStruct *ts) /* unused */

{

  XmTextFieldWidget tf = (XmTextFieldWidget) w;

  XmTextPosition cursorPos = tf->text.cursor_position;

  _XmProcessLock();

  if (!prim_select) {

    _XmProcessUnlock();

    return;

  }

  if (prim_select->num_chars > 0) {

    tf->text.prim_anchor = prim_select->position;

    cursorPos = prim_select->position + prim_select->num_chars;

    _XmTextFieldStartSelection(tf, tf->text.prim_anchor, cursorPos,

			       prim_select->time);

    tf->text.pending_off = False;

    _XmTextFieldSetCursorPosition(tf, NULL, cursorPos, True, True);

  }

  if (--prim_select->ref_count == 0) {

    XtFree((char *)prim_select);

    prim_select = NULL;

  }

  _XmProcessUnlock();

}

/*ARGSUSED*/

static void

CleanPrimarySelection(Widget w, 

		    XtEnum op,	/* unused */

		    XmTransferDoneCallbackStruct *ts) /* unused */

{

  _XmProcessLock();

  if (!prim_select)

  {

    _XmProcessUnlock();

    return;

  }

  if (--prim_select->ref_count == 0) {

    XtFree((char *)prim_select);

    prim_select = NULL;

  }

  _XmProcessUnlock();

}

static void 

TextFieldSecondaryWrapper(Widget w, XtPointer closure,

			     XmSelectionCallbackStruct *ds)

{

  Atom XA_TARGETS = XInternAtom(XtDisplay(w), XmSTARGETS, False);

  if (ds -> target == XA_TARGETS)

    HandleInsertTargets(w, closure, &(ds -> selection), &(ds -> type),

			ds -> value, &(ds -> length), &(ds -> format),

			ds -> transfer_id);

  else

    InsertSelection(w, closure, &(ds -> selection), &(ds -> type),

		    ds -> value, &(ds -> length), &(ds -> format),

		    ds -> transfer_id);

}

/* ARGSUSED */

static void

InsertSelection(

        Widget w,

        XtPointer closure,

        Atom *seltype,

        Atom *type,

        XtPointer value,

        unsigned long *length,

        int *format,

	XtPointer tid)

{

  _XmInsertSelect *insert_select = (_XmInsertSelect *) closure;

  XmTextFieldWidget tf = (XmTextFieldWidget) 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 = XInternAtom(XtDisplay(w), XmSCOMPOUND_TEXT, False);

  Atom UTF8_STRING = XInternAtom(XtDisplay(w), XmSUTF8_STRING, False);

  char * total_value = NULL;

  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 (!tf->text.has_primary ||

	tf->text.prim_pos_left == tf->text.prim_pos_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 (tf->text.has_primary &&

	(left = tf->text.prim_pos_left) != (right = tf->text.prim_pos_right)) {

      if ( TextF_CursorPosition(tf) < left ||

	  TextF_CursorPosition(tf) > right ||

	  !tf->text.pending_delete) {

	left = right = TextF_CursorPosition(tf);

	dest_disjoint = True;

      }

    } else

      left = right = TextF_CursorPosition(tf);

  }

  if (*type == COMPOUND_TEXT || *type == XA_STRING || *type == UTF8_STRING) {

    total_value =  _XmTextToLocaleText(w, value, *type, *format, 

				       *length, NULL);

    if (total_value) {

      if (tf->text.max_char_size == 1) {

	num_chars = strlen(total_value);

	replace_res = _XmTextFieldReplaceText(tf, 

					      (XEvent *)insert_select->event,

					      left, right, total_value, 

					      num_chars, True);

      } else { /* must convert to wchar_t before passing to Replace */

	int len = strlen(total_value) + 1;

	wc_value = (wchar_t *)XtMalloc((unsigned) len * sizeof(wchar_t));

	num_chars = mbstowcs(wc_value, total_value, len);

	if (num_chars < 0) 

	  num_chars = 0;

	else

	  replace_res = _XmTextFieldReplaceText(tf,

                                                (XEvent *)insert_select->event,

                                                left, right, (char*) wc_value,

                                                num_chars, True);

	XtFree((char *)wc_value);

      }

      XtFree(total_value);

    }

  } else { /* it must be either TEXT or codeset of the locale */

    if (tf->text.max_char_size == 1) {

      /* NOTE: casting *length could result in a truncated long. */

      num_chars = *length;

      replace_res = _XmTextFieldReplaceText(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, (size_t)*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);

      if (num_chars < 0)

	num_chars = 0;

      else

	replace_res = _XmTextFieldReplaceText(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 (!tf->text.add_mode) tf->text.prim_anchor = left;

    tf->text.pending_off = True;

    _XmTextFieldSetCursorPosition(tf, NULL, left + num_chars, False, True);

    (void) _XmTextFieldSetDestination(w, TextF_CursorPosition(tf),

				      insert_select->event->time);

    if (insert_select->select_type == XmDEST_SELECT) {

      if (left != right) {

	if (!dest_disjoint || !tf->text.add_mode) {

	  _XmTextFieldStartSelection(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

HandleInsertTargets(

        Widget w,

        XtPointer closure,

        Atom *seltype,

        Atom *type,

        XtPointer value,

        unsigned long *length,

        int *format,

	XtPointer tid )

{

  enum { XmATEXT, XmACOMPOUND_TEXT, XmAUTF8_STRING, NUM_ATOMS };

  static char *atom_names[] = { XmSTEXT, XmSCOMPOUND_TEXT, XmSUTF8_STRING };

  _XmInsertSelect *insert_select = (_XmInsertSelect *) closure;

  Atom atoms[XtNumber(atom_names)];

  Atom CS_OF_ENCODING = XmeGetEncodingAtom(w);

  Atom target;

  Atom *atom_ptr;

  Boolean supports_encoding_data = False;

  Boolean supports_CT = False;

  Boolean supports_text = False;

  Boolean supports_utf8_string = False;

  int i;

  if (0 == *length) {

    XtFree((char *)value);

    insert_select->done_status = True;

    return; /* Supports no targets, so don't bother sending anything */

  }

  assert(XtNumber(atom_names) == NUM_ATOMS);

  XInternAtoms(XtDisplay(w), atom_names, XtNumber(atom_names), False, atoms);

  atom_ptr = (Atom *)value;

  for (i = 0; i < *length; i++, atom_ptr++) {

    if (*atom_ptr == atoms[XmATEXT])

      supports_text = True;

    if (*atom_ptr == CS_OF_ENCODING) 

      supports_encoding_data = True;

    if (*atom_ptr == atoms[XmACOMPOUND_TEXT]) 

      supports_CT = True;

#ifdef UTF8_SUPPORTED

    if (*atom_ptr == atoms[XmAUTF8_STRING]) 

      supports_utf8_string = True;

#endif

  }

  if (supports_text && supports_encoding_data)

    target = atoms[XmATEXT];

  else if (supports_CT)

    target = atoms[XmACOMPOUND_TEXT];

#ifdef UTF8_SUPPORTED

  else if (supports_utf8_string)

    target = atoms[XmAUTF8_STRING];

#endif

  else if (supports_encoding_data)

    target = CS_OF_ENCODING;

  else

    target = XA_STRING;

  XmTransferValue(tid, target,

		  (XtCallbackProc) TextFieldSecondaryWrapper,

		  closure, insert_select -> event -> time);

}

/* ARGSUSED */

Boolean

_XmTextFieldConvert(

        Widget w,

        Atom *selection,

        Atom *target,

        Atom *type,

        XtPointer *value,

        unsigned long *length,

        int *format,

	Widget drag_context,

        XEvent *event)

{

  enum { XmA_MOTIF_DESTINATION, XmAINSERT_SELECTION, XmADELETE,

	 XmATARGETS, XmATEXT, XmACOMPOUND_TEXT, XmATIMESTAMP,

	 XmA_MOTIF_DROP, XmACLIPBOARD, XmANULL, XmAUTF8_STRING,

	 NUM_ATOMS };

  static char *atom_names[] = {

    XmS_MOTIF_DESTINATION, XmSINSERT_SELECTION, XmSDELETE,

    XmSTARGETS, XmSTEXT, XmSCOMPOUND_TEXT, XmSTIMESTAMP,

    XmS_MOTIF_DROP, XmSCLIPBOARD, XmSNULL, XmSUTF8_STRING };

  XmTextFieldWidget tf;

  Atom atoms[XtNumber(atom_names)];

  Atom CS_OF_ENCODING = XmeGetEncodingAtom(w);

  XSelectionRequestEvent * req_event = (XSelectionRequestEvent *) 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;

  char *tmp_value;

  int ret_status = 0;

  Time _time;

  XmAnyCallbackStruct cb;

  assert(XtNumber(atom_names) == NUM_ATOMS);

  XInternAtoms(XtDisplay(w), atom_names, XtNumber(atom_names), False, atoms);

  if (req_event == NULL) 

    _time = XtLastTimestampProcessed(XtDisplay(w));

  else

    _time = req_event -> time;

  tf = (XmTextFieldWidget) w;

  if (tf == NULL) return False;

  if (*selection == XA_PRIMARY || *selection == atoms[XmACLIPBOARD]) {

    has_selection = tf->text.has_primary;

    left = tf->text.prim_pos_left;

    right = tf->text.prim_pos_right;

    is_primary = True;

    is_secondary = is_destination = is_drop = False;

  } else if (*selection == atoms[XmA_MOTIF_DESTINATION]) {

    has_selection = tf->text.has_destination;

    is_destination = True;

    is_secondary = is_primary = is_drop = False;

  } else if (*selection == XA_SECONDARY) {

    has_selection = tf->text.has_secondary;

    left = tf->text.sec_pos_left;

    right = tf->text.sec_pos_right;

    is_secondary = True;

    is_destination = is_primary = is_drop = False;

  } else if (*selection == atoms[XmA_MOTIF_DROP]) {

    has_selection = tf->text.has_primary;

    left = tf->text.prim_pos_left;

    right = tf->text.prim_pos_right;

    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 == atoms[XmATARGETS]) {

    Atom *targs = XmeStandardTargets(w, 10, &target_count);

    *value = (XtPointer) targs;

    if (XA_STRING != CS_OF_ENCODING) {

      targs[target_count] = CS_OF_ENCODING;  target_count++;

    }

    if (is_primary || is_destination) {

      targs[target_count] = atoms[XmAINSERT_SELECTION]; target_count++;

    }

    if (is_primary || is_secondary || is_drop) {

      targs[target_count] = atoms[XmACOMPOUND_TEXT]; target_count++;

      targs[target_count] = atoms[XmATEXT]; target_count++;

      targs[target_count] = XA_STRING; target_count++;

      targs[target_count] = atoms[XmAUTF8_STRING]; target_count++;

    }

    if (is_primary || is_drop) {

      targs[target_count] = atoms[XmADELETE]; target_count++;

    }

    *type = XA_ATOM;

    *length = target_count;

    *format = 32;

  } else if (*target == atoms[XmATIMESTAMP]) {

    Time *timestamp;

    timestamp = (Time *) XtMalloc(sizeof(Time));

    if (is_primary)

      *timestamp = tf->text.prim_time;

    else if (is_destination)

      *timestamp = tf->text.dest_time;

    else if (is_secondary)

      *timestamp = tf->text.sec_time;

    else if (is_drop)

      *timestamp = tf->text.prim_time;

    *value = (XtPointer) timestamp;

    *type = XA_INTEGER;

    *length = sizeof(Time) / 4;

    *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 (tf->text.max_char_size != 1) {

      int stat ;

      /* NOTE: casting (right - left) could result in a truncated long. */

      *length = _XmTextFieldCountBytes(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), 

		   (size_t)*length); /* NOTE: casting *length could result

					  in a truncated long. */

    }

    tmp_value[*length] = '\0';

    tmp_prop.value = NULL;

    /* 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 == atoms[XmATEXT] || *target == CS_OF_ENCODING) {

    *type = CS_OF_ENCODING;

    *format = 8;

    if (is_destination || !has_selection) return False;

    if (tf->text.max_char_size != 1) {

      int stat ;

      /* NOTE: casting (right - left) could result in a truncated long. */

      *length = _XmTextFieldCountBytes(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),

		   (size_t)*length); /* NOTE: casting *length could result

					  in a truncated long. */

    }

    (*(char **)value)[*length]='\0';

  } else if (*target == atoms[XmACOMPOUND_TEXT]) {

    *type = atoms[XmACOMPOUND_TEXT];

    *format = 8;

    if (is_destination || !has_selection) return False;

    if (tf->text.max_char_size != 1) { 

      int stat ;

      /* convert to char* before converting to CT.  NOTE: casting

       * (right - left) could result in a truncated long.

       */

      *length = _XmTextFieldCountBytes(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), 

		   (size_t)*length); /* NOTE: casting *length could result

					  in a truncated long. */

    }

    tmp_value[*length] = '\0';

    tmp_prop.value = NULL;

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

    }

#ifdef UTF8_SUPPORTED

  } else if (*target == atoms[XmAUTF8_STRING]) {

    *type = atoms[XmAUTF8_STRING];

    *format = 8;

    if (is_destination || !has_selection) return False;

    if (tf->text.max_char_size != 1) { 

      int stat ;

      /* convert to char* before converting to CT.  NOTE: casting

       * (right - left) could result in a truncated long.

       */

      *length = _XmTextFieldCountBytes(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), 

		   (size_t)*length); /* NOTE: casting *length could result

					  in a truncated long. */

    }

    tmp_value[*length] = '\0';

    tmp_prop.value = NULL;

    /* Convert to compound text */

    ret_status = 

      XmbTextListToTextProperty(XtDisplay(w), &tmp_value, 1,

				(XICCEncodingStyle)XUTF8StringStyle,

				&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;

    }

#endif

  } else if (*target == atoms[XmAINSERT_SELECTION]) {

    if (is_secondary) 

      return False;

    else

      return True;

    /* Delete the selection */

  } else if (*target == atoms[XmADELETE]) {

    XmTextPosition left, right;

    Boolean move_cursor = True;

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

    left = tf->text.prim_pos_left;

    right = tf->text.prim_pos_right;

      if (is_drop) {

	if (_XmTextFieldGetDropReciever((Widget)tf) == (Widget) tf)

	  move_cursor = False;

      } else {

	if (req_event != NULL &&

	    req_event->requestor == XtWindow((Widget)tf))

	  move_cursor = False;

      }

    if (!_XmTextFieldReplaceText(tf, (XEvent *) req_event,

				 left, right, NULL, 0, move_cursor)) {

      tf->text.has_primary = True;

      return False;

    }

    _XmTextFieldStartSelection(tf, tf->text.prim_anchor,

			       tf->text.prim_anchor, _time);

    cb.reason = XmCR_VALUE_CHANGED;

    cb.event = (XEvent *) req_event;

    XtCallCallbackList((Widget) tf, TextF_ValueChangedCallback(tf),

		       (XtPointer) &cb;;

    tf->text.has_primary = True;

    if (tf->text.has_destination)

      tf->text.prim_anchor = TextF_CursorPosition(tf);

    *type = atoms[XmANULL];

    *value = NULL;

    *length = 0;

    *format = 8;

  } else

    /* unknown selection type */

    return FALSE;

  return TRUE;

}

/* ARGSUSED */

void

_XmTextFieldLoseSelection(

        Widget w,

        Atom *selection )

{

    XmTextFieldWidget tf = (XmTextFieldWidget) w;

    Atom MOTIF_DESTINATION = XInternAtom(XtDisplay(w),

                                        XmS_MOTIF_DESTINATION, False);

/* Losing Primary Selection */

    if (*selection == XA_PRIMARY && tf->text.has_primary) {

        XmAnyCallbackStruct cb;

        _XmTextFieldDeselectSelection(w, False, 0);

        cb.reason = XmCR_LOSE_PRIMARY;

        cb.event = NULL;

        XtCallCallbackList(w, tf->text.lose_primary_callback, (XtPointer) &cb;;

/* Losing Destination Selection */

    } else if (*selection == MOTIF_DESTINATION) {

        Boolean orig_ibeam_off = tf->text.refresh_ibeam_off;

        tf->text.has_destination = False;

       /* 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.

	*/

	tf->text.refresh_ibeam_off = False;

	_XmTextFieldDrawInsertionPoint(tf, False);

	tf->text.blink_on = True;

	_XmTextFieldDrawInsertionPoint(tf, True);

	/* Restore the state of the refresh_ibeam_off flag. */

        tf->text.refresh_ibeam_off = orig_ibeam_off;

/* Losing Secondary Selection */

    } else if (*selection == XA_SECONDARY && tf->text.has_secondary){

        _XmTextFieldSetSel2(w, 0, 0, True, 

			    XtLastTimestampProcessed(XtDisplay(w)));

    }

}

static void

SetDropContext(Widget w)

{

  Display *display = XtDisplay(w);

  Screen *screen = XtScreen(w);

  XContext loc_context;

  _XmProcessLock();

  if (_XmTextFDNDContext == 0)

    _XmTextFDNDContext = XUniqueContext();

  loc_context = _XmTextFDNDContext;

  _XmProcessUnlock();

  XSaveContext(display, (Window)screen,

	       loc_context, (XPointer)w);

}

static void

DeleteDropContext(Widget w)

{

  Display *display = XtDisplay(w);

  Screen *screen = XtScreen(w);

  XContext loc_context;

  _XmProcessLock();

  loc_context = _XmTextFDNDContext;

  _XmProcessUnlock();

  XDeleteContext(display, (Window)screen, loc_context);

}

Widget

_XmTextFieldGetDropReciever(Widget w)

{

  Widget widget;

  XContext loc_context;

  _XmProcessLock();

  loc_context = _XmTextFDNDContext;

  _XmProcessUnlock();

  if (loc_context == 0) return NULL;

  if (!XFindContext(XtDisplay(w), (Window) XtScreen(w),

		    loc_context, (char **) &widget)) {

    return widget;

  } 

  return NULL;

}

/* ARGSUSED */

static void

DropDestroyCB(Widget      w,

	      XtPointer   clientData,

	      XtPointer   callData)

{

  XmTransferDoneCallbackStruct *ts = 

    (XmTransferDoneCallbackStruct *) callData;

  DeleteDropContext(w);

  if (ts->client_data != NULL) XtFree((char*) ts->client_data);

}

static void 

DropTransferProc(Widget w, XtPointer closure,

		 XmSelectionCallbackStruct *ds)

{

  enum { XmACOMPOUND_TEXT, XmANULL, XmADELETE,

#ifdef UTF8_SUPPORTED

      XmAUTF8_STRING,

#endif

      NUM_ATOMS };

  static char *atom_names[] = { XmSCOMPOUND_TEXT, XmSNULL, XmSDELETE,

#ifdef UTF8_SUPPORTED

      XmSUTF8_STRING

#endif

      };

  _XmTextDropTransferRec *transfer_rec = (_XmTextDropTransferRec *) closure;

  XmTextFieldWidget tf = (XmTextFieldWidget) w;

  Atom atoms[XtNumber(atom_names)];

  Atom CS_OF_ENCODING = XmeGetEncodingAtom(w);

  XmTextPosition insertPosLeft, insertPosRight, left, right, cursorPos;

  int max_length = 0;

  Boolean local = tf->text.has_primary;

  char * total_value = NULL;

  wchar_t * wc_total_value;

  unsigned long total_length = 0;

  int wc_total_length;

  Boolean replace = False;

  XmAnyCallbackStruct cb;

  assert(XtNumber(atom_names) == NUM_ATOMS);

  XInternAtoms(XtDisplay(w), atom_names, XtNumber(atom_names), False, atoms);

  /* When type = NULL, we are assuming a DELETE request has been requested */

  if (ds->type == atoms[XmANULL]) {

    if (transfer_rec->num_chars > 0 && transfer_rec->move) {

      tf->text.prim_anchor = transfer_rec->insert_pos;

      cursorPos = transfer_rec->insert_pos + transfer_rec->num_chars;

      _XmTextFieldSetCursorPosition(tf, NULL, cursorPos,

				    False, True);

      _XmTextFieldStartSelection(tf, tf->text.prim_anchor, 

				 TextF_CursorPosition(tf),