/* $XConsortium: UTMactions.c /main/5 1995/07/15 21:12:10 drk $ */

/*

 * 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

 */

#include <Xm/XmP.h>

#include <Xm/TransferP.h>

#include "UTMtransfer.h"

/* We assume no more than 100 targets will ever be available.  MAXT

   is this upper limit */

#define MAXT 100

#define BYTELENGTH( length, format ) \

  ((format == 8) ? length : \

   ((format == 16) ? length * sizeof(short) : \

    (length * sizeof(long))))

TransferDataRec datums[MAXT]; /* Should never be larger than this */

unsigned int num_datums = 0;

/*******************************************************************

 * UpdateList

 * 

 * This takes the transfered items and updates the displayed list

 * with the transferred target names.  Note that we call a version of

 * XGetAtomName with an installed error handler.  This prevents an

 * app. exit if the Atom id is illegal.  

 *******************************************************************/

static void 

UpdateList(Widget w, XtEnum ignore, XmTransferDoneCallbackStruct *data)

{

  int i;

  XmListDeleteAllItems(list);

  for(i = 0; i < num_datums; i++) {

    char *name;

    XmString temp;

    if (datums[i].target != 0) {

      name = GetSafeAtom(XtDisplay(w), datums[i].target);

      if (name != NULL) {

        temp = XmStringCreateLocalized(name);

        XFree(name);

      }

      else {

        temp = XmStringCreateLocalized("Illegal atom");

      }

    } 

    else {

      temp = XmStringCreateLocalized("Bad target");

      if (name != NULL) XFree(name);

    }

    XmListAddItemUnselected(list, temp, 0);

    XmStringFree(temp);

  }

}

/********************************************************************

 * ReceiveData

 *

 * This requests the targets passed from the request for TARGETS that

 * happed in the destination callback.  Note that you must not start

 * an infinite loop of requesting the target TARGETS.  It will normally

 * be in the list of targets received.  Also,  requesting DELETE has

 * both a side effect and no value associated.  So we do not request

 * these targets.

 ********************************************************************/

static void 

ReceiveData(Widget w, XtPointer ignore, XmSelectionCallbackStruct *data)

{

  if (data -> target != XInternAtom(XtDisplay(w), XmSTARGETS, False)) {

    if (num_datums < MAXT) {

      datums[num_datums].target = data -> target;

      datums[num_datums].type = data -> type;

      datums[num_datums].length = data -> length;

      datums[num_datums].format = data -> format;

      datums[num_datums].value = data -> value;

      num_datums++;

    }

  } else {

    Atom *dlist = (Atom *) data -> value;

    Atom DELETE, TARGETS, INSERT_SELECTION, LINK_SELECTION;

    int i, count = 0;

    if (data -> length == 0) {

      XmTransferDone(data -> transfer_id, XmTRANSFER_DONE_FAIL);

      return;

    }

    /* This doneProc is performed after all transfers have completed. */

    XmeTransferAddDoneProc(data -> transfer_id, 

                           (XmSelectionFinishedProc) UpdateList);

    DELETE = XInternAtom(XtDisplay(w), XmSDELETE, False);

    TARGETS = XInternAtom(XtDisplay(w), XmSTARGETS, False);

    INSERT_SELECTION = XInternAtom(XtDisplay(w), "INSERT_SELECTION", False);

    LINK_SELECTION = XInternAtom(XtDisplay(w), "LINK_SELECTION", False);

    /* first free current datums */

    for(i = 0; i < num_datums; i++) {

      XtFree(datums[num_datums].value);

      datums[num_datums].value = NULL;

    }

    num_datums = 0;

    XmTransferStartRequest(data -> transfer_id);

    for(i = 0; i < data -> length; i++) {

      if (dlist[i] != DELETE &&

	  dlist[i] != INSERT_SELECTION &&

	  dlist[i] != LINK_SELECTION &&

          dlist[i] != TARGETS &&

	  dlist[i] != None) {

        XmTransferValue(data -> transfer_id, dlist[i], 

                        (XtCallbackProc) ReceiveData, NULL, 0);

      }

    }

    XmTransferSendRequest(data -> transfer_id, 0);

  }

}

/*****************************************************************

 * DestinationCallback

 *

 * This just requests the list of targets.  ReceiveData does the

 * rest.

 *****************************************************************/

void 

TargetDestinationCB(Widget w, XtPointer ignore, XtPointer call_data)

{

  XmDestinationCallbackStruct *cs;

  char *selection_atom_name, *atom_name;

  cs = (XmDestinationCallbackStruct *) call_data;

  selection_atom_name = GetSafeAtom(XtDisplay(w), cs->selection);

  if (selection_atom_name == NULL)

       selection_atom_name = "Illegal atom";

  printf("Destination Callback of drawing area called with: \n");

  printf("        selection = %s\n", selection_atom_name);

  printf("        operation = %s\n\n", GetStringFrom(cs->operation));

  XmTransferValue(cs -> transfer_id, 

                  XInternAtom(XtDisplay(w), XmSTARGETS, False),

                  (XtCallbackProc) ReceiveData, NULL, 0);

}

void 

TargetConvertCB(Widget w, XtPointer ignore, XtPointer call_data)

{

  XmConvertCallbackStruct *cs;

  char *selection_atom_name, *target_atom_name;

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

  Atom ME_TARGETS = XInternAtom(XtDisplay(w), XmS_MOTIF_EXPORT_TARGETS, False);

  Atom MC_TARGETS = XInternAtom(XtDisplay(w), 

                                XmS_MOTIF_CLIPBOARD_TARGETS, False);

  Atom DELETE = XInternAtom(XtDisplay(w), XmSDELETE, False);

  Atom LS = XInternAtom(XtDisplay(w), XmS_MOTIF_LOSE_SELECTION, False);

  Atom MDEST = XInternAtom(XtDisplay(w), XmS_MOTIF_DESTINATION, False);

  cs = (XmConvertCallbackStruct *) call_data;

  selection_atom_name = GetSafeAtom(XtDisplay(w), cs->selection);

  if (selection_atom_name == NULL)

       selection_atom_name = "Illegal atom";

  target_atom_name = GetSafeAtom(XtDisplay(w), cs->selection);

  if (target_atom_name == NULL)

       target_atom_name = "Illegal atom";

  printf("Convert Callback of drawing area called with: \n");

  printf("        selection         = %s\n", selection_atom_name);

  printf("        conversion target = %s\n\n", target_atom_name);

  if (cs -> target == ME_TARGETS ||

      cs -> target == MC_TARGETS) {

    /* Create an array large enough to hold all targets */

    Atom *targs = (Atom *) XtMalloc(sizeof(Atom) * num_datums);

    int i;

    int count = 0;

    for(i = 0; i < num_datums; i++) {

      if (datums[i].target != DELETE &&

	  datums[i].target != MC_TARGETS &&

	  datums[i].target != ME_TARGETS &&

          datums[i].target != TARGETS) {

        targs[count++] = datums[i].target;

      }

    }

    if (count > 0) {

      cs -> value = (XtPointer) targs;

      cs -> length = count;

      cs -> format = 32;

      cs -> type = XA_ATOM;

      cs -> status = XmCONVERT_DONE;

    } else {

      XtFree((char*) targs);

      cs -> status = XmCONVERT_REFUSE;

    }

  } else if (cs -> target == TARGETS) {

    /* Create an array large enough to hold all targets */

    Atom *targs = (Atom *) XtMalloc(sizeof(Atom) * num_datums);

    int i;

    for(i = 0; i < num_datums; i++) {

      targs[i] = datums[i].target;

    }

    cs -> value = (XtPointer) targs;

    cs -> length = num_datums;

    cs -> format = 32;

    cs -> type = XA_ATOM;

    cs -> status = XmCONVERT_DONE;

  }

 else if (cs -> target == LS) {

    /* Decide which selection was lost,  remove that label */

    if (cs -> selection == XA_PRIMARY)

      XtUnmanageChild(OwnPrimLG);

    else if (cs -> selection == MDEST)

      XtUnmanageChild(OwnSecLG);

  } 

 else {

    /* Try and find the right target,  otherwise fail */

    int i = 0;

    while(i < num_datums &&

          datums[i].target != cs -> target) 

      i++;

    if (i >= num_datums /* Not found */ ||

        datums[i].type == (Atom) 0 /* Illegal */ )

      {

        cs -> value = NULL;

        cs -> length = 0;

        cs -> type = None;

        cs -> format = 8;

        cs -> status = XmCONVERT_REFUSE;

      }

    else

      {

	char *temp;

	int size_in_bytes;

	size_in_bytes = datums[i].length * datums[i].format / 8;

	temp = XtMalloc(size_in_bytes);

	memcpy(temp, datums[i].value, size_in_bytes);

        cs -> status = XmCONVERT_DONE;

        cs -> length = datums[i].length;

        cs -> format = datums[i].format;

        cs -> type = datums[i].type;

        cs -> value = temp;

      }

  }

}

/* Error handler for XGetAtomName */

static int SIF_ErrorFlag;

static int 

SIF_ErrorHandler(Display *display, XErrorEvent *event)

{

  SIF_ErrorFlag = event -> type;

  return 0;

}

char * 

GetSafeAtom(Display *display, Atom a)

{

  XErrorHandler old_Handler;

  char *returnvalue;

  /* Setup error proc and reset error flag */

  old_Handler = XSetErrorHandler((XErrorHandler) SIF_ErrorHandler);

  SIF_ErrorFlag = 0;

  returnvalue = XGetAtomName(display, a);

  XSetErrorHandler(old_Handler);

  if (SIF_ErrorFlag == 0)

    return(returnvalue);

  else

    return(NULL);

}

char *

GetStringFrom(XtEnum operation)

{

  char *returnvalue;

  switch(operation) {

        case XmMOVE:

           returnvalue = "XmMOVE";

           break;

        case XmCOPY: 

           returnvalue = "XmCOPY";

           break;

        case XmLINK:

           returnvalue = "XmLINK";

           break;

        case XmOTHER:

           returnvalue = "XmOTHER";

           break;

        default:

           returnvalue = "Bad operation";

        }

  return(returnvalue);

}