/**
* Convertit un pixbuf en chaine codée en base 64
*
* \param pixbuf
*
* */
gchar * gsb_select_icon_create_chaine_base64_from_pixbuf ( GdkPixbuf *pixbuf )
{
GdkPixdata pixdata;
guint8 *str;
guint longueur;
gchar * str64;
gdk_pixdata_from_pixbuf ( &pixdata, pixbuf, FALSE );
str = gdk_pixdata_serialize ( &pixdata, &longueur );
str64 = g_base64_encode(str, longueur);
g_free(str);
return str64;
}
static char* serializer_pixbuf_encode_b64 (Serializer* self, GdkPixbuf* pixbuf) {
char* result = NULL;
GdkPixdata _tmp0_ = {0};
GdkPixdata pixdata;
void* pixel_data;
guchar* _tmp3_;
gint _tmp2__length1;
guchar* _tmp2_;
gint _tmp1_;
char* _tmp4_;
char* rt;
g_return_val_if_fail (self != NULL, NULL);
g_return_val_if_fail (pixbuf != NULL, NULL);
pixdata = (_tmp0_.magic = (guint32) 0, _tmp0_);
pixel_data = gdk_pixdata_from_pixbuf (&pixdata, pixbuf, TRUE);
rt = (_tmp4_ = (_tmp3_ = (_tmp2_ = gdk_pixdata_serialize (&pixdata, &_tmp1_), _tmp2__length1 = _tmp1_, _tmp2_), g_base64_encode (_tmp3_, _tmp1_)), _tmp2_ = (g_free (_tmp2_), NULL), _tmp4_);
g_free (pixel_data);
result = rt;
return result;
}
static void
create_factory_entry(GtkItemFactoryEntry *entry, VALUE self, VALUE path, VALUE item_type, VALUE accel, VALUE extdata, VALUE func, VALUE data)
{
VALUE action;
entry->path = NIL_P(path) ? NULL : RVAL2CSTR(path);
entry->item_type = NIL_P(item_type) ? "<Branch>" : RVAL2CSTR(item_type);
entry->accelerator = NIL_P(accel) ? NULL : RVAL2CSTR(accel);
if (menuitem_type_check(entry->item_type) == 0) {
entry->callback = NULL;
} else {
if (NIL_P(func)) {
entry->callback = NULL;
} else {
entry->callback = items_exec_callback_wrap;
}
}
action = rb_ary_new3(2, func, data);
G_RELATIVE(self, action);
rb_hash_aset(action_table, UINT2NUM(action_id), action);
entry->callback_action = action_id;
action_id++;
if (NIL_P(extdata)){
entry->extra_data = NULL;
} else if (TYPE(extdata) == T_STRING){
entry->extra_data = RVAL2CSTR(extdata);
} else if (TYPE(extdata) == T_SYMBOL){
entry->extra_data = rb_id2name(SYM2ID(extdata));
} else if (RVAL2GTYPE(extdata) == GDK_TYPE_PIXBUF){
GdkPixdata pixdata;
guint stream_length_p;
gdk_pixdata_from_pixbuf(&pixdata, GDK_PIXBUF(RVAL2GOBJ(extdata)), TRUE);
entry->extra_data = gdk_pixdata_serialize(&pixdata, &stream_length_p);
} else {
entry->extra_data = NULL;
}
}
static void layers_panel_init ( VikLayersPanel *vlp )
{
GtkWidget *hbox;
GtkWidget *addbutton, *addimage;
GtkWidget *removebutton, *removeimage;
GtkWidget *upbutton, *upimage;
GtkWidget *downbutton, *downimage;
GtkWidget *cutbutton, *cutimage;
GtkWidget *copybutton, *copyimage;
GtkWidget *pastebutton, *pasteimage;
GtkWidget *scrolledwindow;
GtkItemFactoryEntry entry;
guint i, tmp;
vlp->vvp = NULL;
hbox = gtk_hbox_new ( TRUE, 2 );
vlp->vt = vik_treeview_new ( );
vlp->toplayer = vik_aggregate_layer_new ();
vik_layer_rename ( VIK_LAYER(vlp->toplayer), _("Top Layer"));
g_signal_connect_swapped ( G_OBJECT(vlp->toplayer), "update", G_CALLBACK(vik_layers_panel_emit_update), vlp );
vik_treeview_add_layer ( vlp->vt, NULL, &(vlp->toplayer_iter), VIK_LAYER(vlp->toplayer)->name, NULL, vlp->toplayer, VIK_LAYER_AGGREGATE, VIK_LAYER_AGGREGATE );
vik_layer_realize ( VIK_LAYER(vlp->toplayer), vlp->vt, &(vlp->toplayer_iter) );
g_signal_connect_swapped ( vlp->vt, "popup_menu", G_CALLBACK(menu_popup_cb), vlp);
g_signal_connect_swapped ( vlp->vt, "button_press_event", G_CALLBACK(layers_button_press_cb), vlp);
g_signal_connect_swapped ( vlp->vt, "item_toggled", G_CALLBACK(layers_item_toggled), vlp);
g_signal_connect_swapped ( vlp->vt, "item_edited", G_CALLBACK(layers_item_edited), vlp);
g_signal_connect_swapped ( vlp->vt, "key_press_event", G_CALLBACK(layers_key_press_cb), vlp);
/* Add button */
addimage = gtk_image_new_from_stock ( GTK_STOCK_ADD, GTK_ICON_SIZE_SMALL_TOOLBAR );
addbutton = gtk_button_new ( );
gtk_container_add ( GTK_CONTAINER(addbutton), addimage );
gtk_widget_set_tooltip_text ( GTK_WIDGET(addbutton), _("Add new layer"));
gtk_box_pack_start ( GTK_BOX(hbox), addbutton, TRUE, TRUE, 0 );
g_signal_connect_swapped ( G_OBJECT(addbutton), "clicked", G_CALLBACK(layers_popup_cb), vlp );
/* Remove button */
removeimage = gtk_image_new_from_stock ( GTK_STOCK_REMOVE, GTK_ICON_SIZE_SMALL_TOOLBAR );
removebutton = gtk_button_new ( );
gtk_container_add ( GTK_CONTAINER(removebutton), removeimage );
gtk_widget_set_tooltip_text ( GTK_WIDGET(removebutton), _("Remove selected layer"));
gtk_box_pack_start ( GTK_BOX(hbox), removebutton, TRUE, TRUE, 0 );
g_signal_connect_swapped ( G_OBJECT(removebutton), "clicked", G_CALLBACK(vik_layers_panel_delete_selected), vlp );
/* Up button */
upimage = gtk_image_new_from_stock ( GTK_STOCK_GO_UP, GTK_ICON_SIZE_SMALL_TOOLBAR );
upbutton = gtk_button_new ( );
gtk_container_add ( GTK_CONTAINER(upbutton), upimage );
gtk_widget_set_tooltip_text ( GTK_WIDGET(upbutton), _("Move selected layer up"));
gtk_box_pack_start ( GTK_BOX(hbox), upbutton, TRUE, TRUE, 0 );
g_signal_connect_swapped ( G_OBJECT(upbutton), "clicked", G_CALLBACK(layers_move_item_up), vlp );
/* Down button */
downimage = gtk_image_new_from_stock ( GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_SMALL_TOOLBAR );
downbutton = gtk_button_new ( );
gtk_container_add ( GTK_CONTAINER(downbutton), downimage );
gtk_widget_set_tooltip_text ( GTK_WIDGET(downbutton), _("Move selected layer down"));
gtk_box_pack_start ( GTK_BOX(hbox), downbutton, TRUE, TRUE, 0 );
g_signal_connect_swapped ( G_OBJECT(downbutton), "clicked", G_CALLBACK(layers_move_item_down), vlp );
/* Cut button */
cutimage = gtk_image_new_from_stock ( GTK_STOCK_CUT, GTK_ICON_SIZE_SMALL_TOOLBAR );
cutbutton = gtk_button_new ( );
gtk_container_add ( GTK_CONTAINER(cutbutton), cutimage );
gtk_widget_set_tooltip_text ( GTK_WIDGET(cutbutton), _("Cut selected layer"));
gtk_box_pack_start ( GTK_BOX(hbox), cutbutton, TRUE, TRUE, 0 );
g_signal_connect_swapped ( G_OBJECT(cutbutton), "clicked", G_CALLBACK(vik_layers_panel_cut_selected), vlp );
/* Copy button */
copyimage = gtk_image_new_from_stock ( GTK_STOCK_COPY, GTK_ICON_SIZE_SMALL_TOOLBAR );
copybutton = gtk_button_new ( );
gtk_container_add ( GTK_CONTAINER(copybutton), copyimage );
gtk_widget_set_tooltip_text ( GTK_WIDGET(copybutton), _("Copy selected layer"));
gtk_box_pack_start ( GTK_BOX(hbox), copybutton, TRUE, TRUE, 0 );
g_signal_connect_swapped ( G_OBJECT(copybutton), "clicked", G_CALLBACK(vik_layers_panel_copy_selected), vlp );
/* Paste button */
pasteimage = gtk_image_new_from_stock ( GTK_STOCK_PASTE, GTK_ICON_SIZE_SMALL_TOOLBAR );
pastebutton = gtk_button_new ( );
gtk_container_add ( GTK_CONTAINER(pastebutton),pasteimage );
gtk_widget_set_tooltip_text ( GTK_WIDGET(pastebutton), _("Paste layer below selected layer"));
gtk_box_pack_start ( GTK_BOX(hbox), pastebutton, TRUE, TRUE, 0 );
g_signal_connect_swapped ( G_OBJECT(pastebutton), "clicked", G_CALLBACK(vik_layers_panel_paste_selected), vlp );
scrolledwindow = gtk_scrolled_window_new ( NULL, NULL );
gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
gtk_container_add ( GTK_CONTAINER(scrolledwindow), GTK_WIDGET(vlp->vt) );
gtk_box_pack_start ( GTK_BOX(vlp), scrolledwindow, TRUE, TRUE, 0 );
gtk_box_pack_start ( GTK_BOX(vlp), hbox, FALSE, FALSE, 0 );
vlp->popup_factory = gtk_item_factory_new ( GTK_TYPE_MENU, "<main>", NULL );
gtk_item_factory_create_items ( vlp->popup_factory, NUM_BASE_ENTRIES, base_entries, vlp );
for ( i = 0; i < VIK_LAYER_NUM_TYPES; i++ )
{
/* TODO: FIXME: if name has a '/' in it it will get all messed up. why not have an itemfactory field with
name, icon, shortcut, etc.? */
/* Note: we use a temporary label in order to share translation with other codde */
gchar *label = g_strdup_printf(_("New %s Layer"), vik_layer_get_interface(i)->name );
entry.path = g_strdup_printf("%s/%s", base_entries[NUM_BASE_ENTRIES-1].path, label );
g_free ( label );
entry.accelerator = NULL;
entry.callback = (GtkItemFactoryCallback) vik_layers_panel_new_layer;
entry.callback_action = i;
if ( vik_layer_get_interface(i)->icon )
{
entry.item_type = "<ImageItem>";
entry.extra_data = gdk_pixdata_serialize ( vik_layer_get_interface(i)->icon, &tmp );
}
else
entry.item_type = "<Item>";
gtk_item_factory_create_item ( vlp->popup_factory, &entry, vlp, 1 );
g_free ( (gpointer) entry.extra_data );
g_free ( entry.path );
}
}
/**
* gdk_pixdata_to_csource:
* @pixdata: a #GdkPixdata to convert to C source.
* @name: used for naming generated data structures or macros.
* @dump_type: a #GdkPixdataDumpType determining the kind of C
* source to be generated.
*
* Generates C source code suitable for compiling images directly
* into programs.
*
* gdk-pixbuf ships with a program called
* [gdk-pixbuf-csource][gdk-pixbuf-csource], which offers a command
* line interface to this function.
*
* Returns: a newly-allocated string containing the C source form
* of @pixdata.
* Deprecated: 2.32: Use #GResource instead.
**/
GString*
gdk_pixdata_to_csource (GdkPixdata *pixdata,
const gchar *name,
GdkPixdataDumpType dump_type)
{
CSourceData cdata = { 0, };
gchar *s_uint_8;
guint bpp, width, height, rowstride;
gboolean rle_encoded;
gchar *macro_name;
guint8 *img_buffer, *img_buffer_end, *stream = NULL;
guint stream_length;
GString *gstring;
/* check args passing */
g_return_val_if_fail (pixdata != NULL, NULL);
g_return_val_if_fail (name != NULL, NULL);
/* check pixdata contents */
g_return_val_if_fail (pixdata->magic == GDK_PIXBUF_MAGIC_NUMBER, NULL);
g_return_val_if_fail (pixdata->width > 0, NULL);
g_return_val_if_fail (pixdata->height > 0, NULL);
g_return_val_if_fail (pixdata->rowstride >= pixdata->width, NULL);
g_return_val_if_fail ((pixdata->pixdata_type & GDK_PIXDATA_COLOR_TYPE_MASK) == GDK_PIXDATA_COLOR_TYPE_RGB ||
(pixdata->pixdata_type & GDK_PIXDATA_COLOR_TYPE_MASK) == GDK_PIXDATA_COLOR_TYPE_RGBA, NULL);
g_return_val_if_fail ((pixdata->pixdata_type & GDK_PIXDATA_SAMPLE_WIDTH_MASK) == GDK_PIXDATA_SAMPLE_WIDTH_8, NULL);
g_return_val_if_fail ((pixdata->pixdata_type & GDK_PIXDATA_ENCODING_MASK) == GDK_PIXDATA_ENCODING_RAW ||
(pixdata->pixdata_type & GDK_PIXDATA_ENCODING_MASK) == GDK_PIXDATA_ENCODING_RLE, NULL);
g_return_val_if_fail (pixdata->pixel_data != NULL, NULL);
img_buffer = pixdata->pixel_data;
if (pixdata->length < 1)
img_buffer_end = img_buffer + pixdata_get_length (pixdata);
else
img_buffer_end = img_buffer + pixdata->length - GDK_PIXDATA_HEADER_LENGTH;
g_return_val_if_fail (img_buffer < img_buffer_end, NULL);
bpp = (pixdata->pixdata_type & GDK_PIXDATA_COLOR_TYPE_MASK) == GDK_PIXDATA_COLOR_TYPE_RGB ? 3 : 4;
width = pixdata->width;
height = pixdata->height;
rowstride = pixdata->rowstride;
rle_encoded = (pixdata->pixdata_type & GDK_PIXDATA_ENCODING_RLE) > 0;
macro_name = g_ascii_strup (name, -1);
cdata.dump_macros = (dump_type & GDK_PIXDATA_DUMP_MACROS) > 0;
cdata.dump_struct = (dump_type & GDK_PIXDATA_DUMP_PIXDATA_STRUCT) > 0;
cdata.dump_stream = !cdata.dump_macros && !cdata.dump_struct;
g_return_val_if_fail (cdata.dump_macros + cdata.dump_struct + cdata.dump_stream == 1, NULL);
cdata.dump_gtypes = (dump_type & GDK_PIXDATA_DUMP_CTYPES) == 0;
cdata.dump_rle_decoder = (dump_type & GDK_PIXDATA_DUMP_RLE_DECODER) > 0;
cdata.static_prefix = (dump_type & GDK_PIXDATA_DUMP_STATIC) ? "static " : "";
cdata.const_prefix = (dump_type & GDK_PIXDATA_DUMP_CONST) ? "const " : "";
gstring = g_string_new (NULL);
cdata.gstring = gstring;
if (!cdata.dump_macros && cdata.dump_gtypes)
s_uint_8 = "guint8 ";
else if (!cdata.dump_macros)
s_uint_8 = "unsigned char";
else if (cdata.dump_macros && cdata.dump_gtypes)
s_uint_8 = "guint8";
else /* cdata.dump_macros && !cdata.dump_gtypes */
s_uint_8 = "unsigned char";
/* initial comment
*/
APPEND (gstring,
"/* GdkPixbuf %s C-Source image dump %s*/\n\n",
bpp > 3 ? "RGBA" : "RGB",
rle_encoded ? "1-byte-run-length-encoded " : "");
/* dump RLE decoder for structures
*/
if (cdata.dump_rle_decoder && cdata.dump_struct)
save_rle_decoder (gstring,
macro_name,
cdata.dump_gtypes ? "guint" : "unsigned int",
cdata.dump_gtypes ? "guint8" : "unsigned char",
bpp);
/* format & size blurbs
*/
if (cdata.dump_macros)
{
APPEND (gstring, "#define %s_ROWSTRIDE (%u)\n",
macro_name, rowstride);
APPEND (gstring, "#define %s_WIDTH (%u)\n",
macro_name, width);
APPEND (gstring, "#define %s_HEIGHT (%u)\n",
macro_name, height);
APPEND (gstring, "#define %s_BYTES_PER_PIXEL (%u) /* 3:RGB, 4:RGBA */\n",
macro_name, bpp);
}
if (cdata.dump_struct)
{
APPEND (gstring, "%s%sGdkPixdata %s = {\n",
cdata.static_prefix, cdata.const_prefix, name);
APPEND (gstring, " 0x%x, /* Pixbuf magic: 'GdkP' */\n",
GDK_PIXBUF_MAGIC_NUMBER);
APPEND (gstring, " %d + %lu, /* header length + pixel_data length */\n",
GDK_PIXDATA_HEADER_LENGTH,
rle_encoded ? (glong)(img_buffer_end - img_buffer) : (glong)rowstride * height);
APPEND (gstring, " 0x%x, /* pixdata_type */\n",
pixdata->pixdata_type);
APPEND (gstring, " %u, /* rowstride */\n",
rowstride);
APPEND (gstring, " %u, /* width */\n",
width);
APPEND (gstring, " %u, /* height */\n",
height);
APPEND (gstring, " /* pixel_data: */\n");
}
if (cdata.dump_stream)
{
guint pix_length = img_buffer_end - img_buffer;
stream = gdk_pixdata_serialize (pixdata, &stream_length);
img_buffer = stream;
img_buffer_end = stream + stream_length;
APPEND (gstring, "#ifdef __SUNPRO_C\n");
APPEND (gstring, "#pragma align 4 (%s)\n", name);
APPEND (gstring, "#endif\n");
APPEND (gstring, "#ifdef __GNUC__\n");
APPEND (gstring, "%s%s%s %s[] __attribute__ ((__aligned__ (4))) = \n",
cdata.static_prefix, cdata.const_prefix,
cdata.dump_gtypes ? "guint8" : "unsigned char",
name);
APPEND (gstring, "#else\n");
APPEND (gstring, "%s%s%s %s[] = \n",
cdata.static_prefix, cdata.const_prefix,
cdata.dump_gtypes ? "guint8" : "unsigned char",
name);
APPEND (gstring, "#endif\n");
APPEND (gstring, "{ \"\"\n /* Pixbuf magic (0x%x) */\n \"",
GDK_PIXBUF_MAGIC_NUMBER);
cdata.pos = 3;
save_uchar (&cdata, *img_buffer++); save_uchar (&cdata, *img_buffer++);
save_uchar (&cdata, *img_buffer++); save_uchar (&cdata, *img_buffer++);
APPEND (gstring, "\"\n /* length: header (%d) + pixel_data (%u) */\n \"",
GDK_PIXDATA_HEADER_LENGTH,
rle_encoded ? pix_length : rowstride * height);
cdata.pos = 3;
save_uchar (&cdata, *img_buffer++); save_uchar (&cdata, *img_buffer++);
save_uchar (&cdata, *img_buffer++); save_uchar (&cdata, *img_buffer++);
APPEND (gstring, "\"\n /* pixdata_type (0x%x) */\n \"",
pixdata->pixdata_type);
cdata.pos = 3;
save_uchar (&cdata, *img_buffer++); save_uchar (&cdata, *img_buffer++);
save_uchar (&cdata, *img_buffer++); save_uchar (&cdata, *img_buffer++);
APPEND (gstring, "\"\n /* rowstride (%u) */\n \"",
rowstride);
cdata.pos = 3;
save_uchar (&cdata, *img_buffer++); save_uchar (&cdata, *img_buffer++);
save_uchar (&cdata, *img_buffer++); save_uchar (&cdata, *img_buffer++);
APPEND (gstring, "\"\n /* width (%u) */\n \"", width);
cdata.pos = 3;
save_uchar (&cdata, *img_buffer++); save_uchar (&cdata, *img_buffer++);
save_uchar (&cdata, *img_buffer++); save_uchar (&cdata, *img_buffer++);
APPEND (gstring, "\"\n /* height (%u) */\n \"", height);
cdata.pos = 3;
save_uchar (&cdata, *img_buffer++); save_uchar (&cdata, *img_buffer++);
save_uchar (&cdata, *img_buffer++); save_uchar (&cdata, *img_buffer++);
APPEND (gstring, "\"\n /* pixel_data: */\n");
}
/* pixel_data intro
*/
if (cdata.dump_macros)
{
APPEND (gstring, "#define %s_%sPIXEL_DATA ((%s*) \\\n",
macro_name,
rle_encoded ? "RLE_" : "",
s_uint_8);
APPEND (gstring, " \"");
cdata.pos = 2;
}
if (cdata.dump_struct)
{
APPEND (gstring, " \"");
cdata.pos = 3;
}
if (cdata.dump_stream)
{
APPEND (gstring, " \"");
cdata.pos = 3;
}
/* pixel_data
*/
do
save_uchar (&cdata, *img_buffer++);
while (img_buffer < img_buffer_end);
/* pixel_data trailer
*/
if (cdata.dump_macros)
APPEND (gstring, "\")\n\n");
if (cdata.dump_struct)
APPEND (gstring, "\",\n};\n\n");
if (cdata.dump_stream)
APPEND (gstring, "\"};\n\n");
/* dump RLE decoder for macros
*/
if (cdata.dump_rle_decoder && cdata.dump_macros)
save_rle_decoder (gstring,
macro_name,
cdata.dump_gtypes ? "guint" : "unsigned int",
cdata.dump_gtypes ? "guint8" : "unsigned char",
bpp);
/* cleanup
*/
g_free (stream);
g_free (macro_name);
return gstring;
}
