/* Es el encargado de convertir o guardar
 * cualquier objeto en formato tipo cualquiera
 * recibe el obj y el apuntador
 * se le pasa el tamaño 
 * y lo convierte en cualquier cosa
 * y lo entrega 
*/

void*  convert_object_to_void(void* objeto,unsigned int tama)
{
 void* convertido;
 /*a malloc se le pasa el tamaño del objeto que desea el usuario,
  se arma, y se prueba a la vez   
 */
 if( (convertido=malloc(tama))==NULL)
  {
   printf("No se pudo crear el objeto pedido por el usuario\nEl programa termina");
   exit(1);/*Se sale del programa*/
  }
  /*Hace los movimientos de memoria correspondientes.
  */
  memmove(convertido,objeto,tama); 
  return convertido;
}


/*Es el encargado de convertir un obg en tipo cadena
*/

char* convert_obj_char(void* obj)
 {
  
  unsigned int tama;
  char* objeto;
  /*un apuntador tipo unión*/
  aptdr_cadena obj_gene;
  /*el objeto es copiado al apuntador tipo unión*/
  obj_gene->apunt=obj;
  /* se obtiene el tasmaño según la cadena representada*/
  tama=sizeof(obj_gene->cadena);
  objeto=(char*)convert_object_to_void(obj,tama);
  return objeto;
 }





/**
 * dia_selection_data_set_diaitem:
 * @selection_data: a #GtkSelectionData
 * @item: a #DiaCanvasItem
 * 
 * El #DiaCanvasItem es puesto a la «selection» del portapapeles
 * El ítem es convertido a un tipo char*
 * 
 * Entrega verdadero %TRUE i «the selection» ha sido satisfactoriamente ,
 *  si no es así entrega un falso %FALSE.
 *
 * 
 **/
gboolean  dia_selection_data_set_diaitem(GtkSelectionData *selection_data,
			                 DiaCanvasItem* item)
{
  char* str;
  unsigned int len;
  str =(gchar*)convert_obj_char(item);
  len=sizeof(str);
  printf("la long del str en dia_selection_data_set_diaitem : %d \n",len); 
  GdkAtom atom;
  /*Define el tipode «apuntador» para el dia canvas item gradado en el porta papeles*/
  /*Definido por una cadena estática*/
  atom=gdk_atom_intern("dia/char",FALSE);
  gtk_selection_data_set(selection_data,atom, 8, (guchar*)str,(gsize)len);
  free (str);
  return TRUE;
 }

/*Es la función encargada de 
 *liberar la copia del objeto pasado
 * al porta papeles
*/ 

static void dia_item_clear_func (GtkClipboard *clipboard,void* data)
{
  printf("entro a dia_item_clear_func \n");
  free (data);
}



/*Es la encargada de obtener los datos 
 * del item
*/

static void dia_item_get_func (GtkClipboard *clipboard,GtkSelectionData *selection_data,
		               guint info, gpointer data)
{
 /*Es la encargada de convertir*/
 printf("entro a dia_item_get_func \n");
  dia_selection_data_set_diaitem (selection_data, data);
}




/**
 * gtk_clipboard_set_dia_obj:
 * @clipboard: a #GtkClipboard object
 * @dia_obj:   Dia ítem obj.
 * 
 * 
 * Pone el contenido al porta papeles de un obj tipo dia
 * Se le hace una copia en la memoria y gtk lleva
 * la responsabilidad para la respuesta cuando se hace
 * el pedido de el obj y convirtiéndolo al formato pedido
 * Sets the contents of the clipboard to the given dia item. GTK+ will
 * make a copy of the obj and take responsibility for responding
 * for requests for the obj, and for converting the obj into
 * the requested format.
 **/
void gtk_clipboard_set_dia_item (GtkClipboard *clipboard,const DiaCanvasItem* item)
{
  GtkTargetList *list;
  GList *l;
  GtkTargetEntry *targets;
  gint n_targets, i;
  void* copia_item;
  int j; 
 g_return_if_fail (clipboard != NULL);
 g_return_if_fail (item != NULL); /*si no se le pasa el ítem*/

  printf("entro a gtk_clipboard_set_dia_item \n");
  list = gtk_target_list_new (NULL, 0);
  gtk_target_list_add_text_targets (list, 0);

  n_targets = g_list_length (list->list);
  targets = g_new0 (GtkTargetEntry, n_targets);
  for (l = list->list, i = 0; l; l = l->next, i++)
    {
      GtkTargetPair *pair = (GtkTargetPair *)l->data;
      targets[i].target = gdk_atom_name (pair->target);
    }
  
  /*reserva el espaciod e memoria para la copia de item*/
  copia_item=malloc(sizeof(DiaCanvasItem));
  /*hace una copia del item*/
  memmove(copia_item,item,sizeof(item)); 
/*Hace la copia al porta papeles, se le pasa el portapaeles,..., 
 *la func encargada de «obtener la el obj en tipo texto»
 * la func encargada de liberar memoria
 * y la copia del ítem
 */
  j=gtk_clipboard_set_with_data (clipboard,targets, n_targets,
			       dia_item_get_func, dia_item_clear_func,
			       copia_item);

  printf(" resultado de: gtk_clipboard_set_with_data: %d \n",j); 
  gtk_clipboard_set_can_store (clipboard, NULL, 0);
  for (i = 0; i < n_targets; i++)
   free (targets[i].target);
   free (targets);
   gtk_target_list_unref (list);
}



/**
 * selection_data_get_dia_item
 * @selection_data: a #GtkSelectionData
 * 
 * El contenido de selection como un  #DiaCanvasItem.
 * 
 * Entrega: Si la selección es reconocida, entonces, entrega la
 *   info, y el tipo es convertido a #DiaCanvasItem, 
 *   y un nuevo ítem es puesto en mem y entrega un %NULL.
 *   If the result is non-%NULL it must be freed with g_object_unref().
 *
 * 
 **/
DiaCanvasItem* selection_data_get_dia_item(GtkSelectionData *selection_data)
{
  DiaCanvasItem* result = NULL;
  DatoPorta_papeles* dato;
  void* obj;
  g_message ("Entró a selection_data_get_dia_item:");
  printf("%d \n",selection_data->length );
  if (selection_data->length > 0)
    {
      /*El guchar es convertido a algo más genérico*/
      obj=convert_object_to_void((void*)selection_data->data,selection_data->length);
       g_message ("El objeto de selection"); 
       printf("%p \n",obj);
      dato->img=obj;
      result=(DiaCanvasItem*)dato->item;
     if (result)
        {
	 g_object_ref (result);
         free(obj);
         }
       }
    return result;
}




/*func encargada de recuperar la info del porta papeles*/
static void request_dia_item_received_func (GtkClipboard *clipboard,
			     GtkSelectionData *selection_data,
			     gpointer  data)
{
  Info* info = data;
  DiaCanvasItem *result = NULL;

  result = selection_data_get_dia_item (selection_data);
  info->callback (clipboard, result, info->user_data);
  g_free (info);
  if (result)
    g_object_unref (result);
}





/**
 * gtk_clipboard_request_dia_item:
 * @clipboard: a #GtkClipboard
 * @callback:  la función que es llamada cuando ,se haya
 *             recibido o no el elemento.
  * @user_data: la informaciónd de usuario para pasar al @callback.
 * 
 * Pide el contenido del portapeles como
 * un un elemnto del tipo dia canvas item
 * 
 * @callback La función a ser llamada. 
 *
 **/
void gtk_clipboard_request_dia_item(GtkClipboard *clipboard,
			    GtkClipboardTextReceivedFunc callback,
			    gpointer user_data)
{
  Info* info;
  
  g_return_if_fail (clipboard != NULL);
  g_return_if_fail (callback != NULL);
  
  info = malloc(sizeof(Info));
  info->callback = callback;
  info->user_data =(void*)user_data;
  /*Pide el contenido del portapapeles y se le pasa una func como conversora de
   * tal dato
   */
  gtk_clipboard_request_contents (clipboard, gdk_atom_intern("dia/char",FALSE),
				  request_dia_item_received_func, info);
}