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