static void
redraw_viewer(void)
{
flush_gdk_buffers();
if (v_disparity_buffer)
{
gdk_draw_pixbuf(drawing_area->window,
drawing_area->style->fg_gc[GTK_WIDGET_STATE (drawing_area)],
GDK_PIXBUF(v_disparity_buffer), 0, 0, 0, 0,
v_disparity_map->width,
drawing_area->allocation.height,
GDK_RGB_DITHER_NONE, 0, 0);
}
if (road_profile_buffer)
{
gdk_draw_pixbuf(drawing_area->window,
drawing_area->style->fg_gc[GTK_WIDGET_STATE (drawing_area)],
GDK_PIXBUF(road_profile_buffer), 0, 0, v_disparity_map->width + 10, 0,
road_profile_image->width,
drawing_area->allocation.height,
GDK_RGB_DITHER_NONE, 0, 0);
}
if (right_buffer)
{
gdk_draw_pixbuf(drawing_area->window,
drawing_area->style->fg_gc[GTK_WIDGET_STATE (drawing_area)],
GDK_PIXBUF(right_buffer), 0, 0, v_disparity_map->width + road_profile_image->width + 20, 0,
right_image->width,
drawing_area->allocation.height,
GDK_RGB_DITHER_NONE, 0, 0);
}
}
/* doesn't return a ref to the pixbuf */
static GdkPixbuf *
check_message_pixbuf (GstMessage * msg, const gchar * name, gint channels,
gboolean has_alpha)
{
GdkPixbuf *pixbuf;
const GstStructure *s;
fail_unless (gst_message_get_structure (msg) != NULL);
s = gst_message_get_structure (msg);
fail_unless_equals_string (gst_structure_get_name (s), name);
fail_unless (gst_structure_has_field (s, "pixbuf"));
fail_unless (gst_structure_has_field_typed (s, "pixel-aspect-ratio",
GST_TYPE_FRACTION));
pixbuf =
GDK_PIXBUF (g_value_get_object (gst_structure_get_value (s, "pixbuf")));
fail_unless (GDK_IS_PIXBUF (pixbuf));
fail_unless_equals_int (gdk_pixbuf_get_n_channels (pixbuf), channels);
fail_unless_equals_int (gdk_pixbuf_get_has_alpha (pixbuf), has_alpha);
fail_unless_equals_int (gdk_pixbuf_get_width (pixbuf), 319);
fail_unless_equals_int (gdk_pixbuf_get_height (pixbuf), 241);
return pixbuf;
}
static VALUE
cview_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE text;
VALUE with_markup = Qnil;
GtkWidget *widget = NULL;
rb_scan_args(argc, argv, "02", &text, &with_markup);
if (NIL_P(text)) {
widget = gtk_cell_view_new();
} else {
G_CHILD_SET(self, id_text, text);
if (TYPE(text) == T_STRING){
if (NIL_P(with_markup) || RVAL2CBOOL(with_markup)){
widget = gtk_cell_view_new_with_markup(RVAL2CSTR(text));
} else {
widget = gtk_cell_view_new_with_text(RVAL2CSTR(text));
}
} else if (rb_obj_is_kind_of(text, GTYPE2CLASS(GDK_TYPE_PIXBUF))){
widget = gtk_cell_view_new_with_pixbuf(GDK_PIXBUF(RVAL2GOBJ(text)));
} else {
rb_raise(rb_eArgError,
"invalid argument %s (expect String or Gdk::Pixbuf)",
rb_class2name(CLASS_OF(text)));
}
}
RBGTK_INITIALIZE(self, widget);
return Qnil;
}
/* GObject stuff */
static void
astro_contact_row_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
AstroContactRowPrivate *priv;
g_return_if_fail (ASTRO_IS_CONTACT_ROW (object));
priv = ASTRO_CONTACT_ROW (object)->priv;
switch (prop_id)
{
case PROP_NAME:
astro_contact_row_set_name (ASTRO_CONTACT_ROW (object),
g_value_get_string (value));
break;
case PROP_ICON:
astro_contact_row_set_icon (ASTRO_CONTACT_ROW (object),
GDK_PIXBUF (g_value_get_object (value)));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
artwork_notify_cb (RhythmDB *db,
RhythmDBEntry *entry,
const char *property_name,
const GValue *metadata,
RBMtpSource *source)
{
RBMtpSourcePrivate *priv = MTP_SOURCE_GET_PRIVATE (source);
GdkPixbuf *pixbuf;
const char *album_name;
album_name = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_ALBUM);
/* check if we're looking for art for this entry, and if we actually got some */
if (g_hash_table_remove (priv->artwork_request_map, album_name) == FALSE)
return;
if (G_VALUE_HOLDS (metadata, GDK_TYPE_PIXBUF) == FALSE)
return;
pixbuf = GDK_PIXBUF (g_value_get_object (metadata));
rb_mtp_thread_set_album_image (priv->device_thread, album_name, pixbuf);
queue_free_space_update (source);
}
static PyObject *
pixbuf_get_pixels_array(PyObject *self, PyObject *args)
{
/* 1) read in Python pixbuf, get the underlying gdk_pixbuf */
PyGObject *py_pixbuf;
GdkPixbuf *gdk_pixbuf;
PyArrayObject *array;
int dims[3] = { 0, 0, 3 };
if (!PyArg_ParseTuple(args, "O!:pixbuf_get_pixels_array",
&PyGdkPixbuf_Type, &py_pixbuf))
return NULL;
gdk_pixbuf = GDK_PIXBUF(py_pixbuf->obj);
/* 2) same as pygtk/gtk/gdk.c _wrap_gdk_pixbuf_get_pixels_array()
* with 'self' changed to py_pixbuf
*/
dims[0] = gdk_pixbuf_get_height(gdk_pixbuf);
dims[1] = gdk_pixbuf_get_width(gdk_pixbuf);
if (gdk_pixbuf_get_has_alpha(gdk_pixbuf))
dims[2] = 4;
array = (PyArrayObject *)PyArray_FromDimsAndData(3, dims, PyArray_UBYTE,
(char *)gdk_pixbuf_get_pixels(gdk_pixbuf));
if (array == NULL)
return NULL;
array->strides[0] = gdk_pixbuf_get_rowstride(gdk_pixbuf);
/* the array holds a ref to the pixbuf pixels through this wrapper*/
Py_INCREF(py_pixbuf);
array->base = (PyObject *)py_pixbuf;
return PyArray_Return(array);
}
static void
art_cb (RBExtDBKey *key, const char *filename, GValue *data, MxFrame *frame)
{
ClutterActor *image;
GdkPixbuf *pixbuf;
if (data == NULL || G_VALUE_HOLDS (data, GDK_TYPE_PIXBUF) == FALSE) {
return;
}
clutter_threads_enter ();
image = gtk_clutter_texture_new ();
pixbuf = GDK_PIXBUF (g_value_get_object (data));
gtk_clutter_texture_set_from_pixbuf (GTK_CLUTTER_TEXTURE (image), pixbuf, NULL);
if (clutter_actor_get_height (image) > MAX_IMAGE_HEIGHT) {
clutter_actor_set_height (image, MAX_IMAGE_HEIGHT);
clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (image), TRUE);
}
if (clutter_actor_get_width (image) > MAX_IMAGE_HEIGHT) {
clutter_actor_set_width (image, MAX_IMAGE_HEIGHT);
}
mx_bin_set_child (MX_BIN (frame), image);
clutter_actor_show_all (CLUTTER_ACTOR (frame));
clutter_threads_leave ();
}
static VALUE
rg_s_from_image(int argc, VALUE *argv, G_GNUC_UNUSED VALUE self)
{
VALUE cmap, src, src_x, src_y, width, height, dest, dest_x, dest_y;
GdkPixbuf* buf;
rb_scan_args(argc, argv, "63", &cmap, &src, &src_x, &src_y, &width, &height,
&dest, &dest_x, &dest_y);
buf = gdk_pixbuf_get_from_image(GDK_PIXBUF(RVAL2GOBJ(dest)),
GDK_IMAGE(RVAL2GOBJ(src)),
GDK_COLORMAP(RVAL2GOBJ(cmap)),
NUM2INT(src_x), NUM2INT(src_y),
NIL_P(dest_x) ? 0 : NUM2INT(dest_x),
NIL_P(dest_y) ? 0 : NUM2INT(dest_y),
NUM2INT(width), NUM2INT(height));
if (NIL_P(dest)) {
if (buf) {
return GOBJ2RVAL(buf);
} else {
return Qnil;
}
} else {
return dest;
}
}
static void
on_sliced_image_loaded (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GObject *cache = source_object;
AsyncImageData *data = (AsyncImageData *)user_data;
GTask *task = G_TASK (res);
GList *list, *pixbufs;
if (g_task_had_error (task))
return;
pixbufs = g_task_propagate_pointer (task, NULL);
for (list = pixbufs; list; list = list->next)
{
ClutterActor *actor = load_from_pixbuf (GDK_PIXBUF (list->data));
clutter_actor_hide (actor);
clutter_actor_add_child (data->actor, actor);
}
g_list_free_full (pixbufs, g_object_unref);
if (data->load_callback != NULL)
data->load_callback (cache, data->load_callback_data);
}
static VALUE
it_s_add_builtin_icon(VALUE self, VALUE icon_name, VALUE size, VALUE pixbuf)
{
gtk_icon_theme_add_builtin_icon(RVAL2CSTR(icon_name), NUM2INT(size),
GDK_PIXBUF(RVAL2GOBJ(pixbuf)));
return self;
}
/*! \brief Get fallback pixbuf for displaying pictures.
* \par Function Description
* Returns a pixbuf containing the fallback image to be used if a
* picture object fails to load. The returned pixbuf should be freed
* with g_object_unref() when no longer needed.
*
* \return a #GdkPixbuf containing a warning image.
*/
GdkPixbuf *
o_picture_get_fallback_pixbuf (TOPLEVEL *toplevel)
{
static GdkPixbuf *pixbuf = NULL;
static gboolean failed = FALSE;
if (pixbuf == NULL && !failed) {
gchar *filename;
GError *error = NULL;
filename = g_build_filename (toplevel->bitmap_directory,
"gschem-warning.png", NULL);
pixbuf = gdk_pixbuf_new_from_file (filename, &error);
if (pixbuf == NULL) {
g_warning ( _("Failed to load fallback image %1$s: %2$s.\n"),
filename, error->message);
g_error_free (error);
failed = TRUE;
}
g_free (filename);
}
if (failed) return NULL;
g_assert (GDK_IS_PIXBUF (pixbuf));
return GDK_PIXBUF (g_object_ref (pixbuf));
}
static gboolean write_image(GObject* image, const char* filename)
{
char *keys[11]; /* enough for known keys + 1 */
char *vals[11];
GdkPixbuf *pix = GDK_PIXBUF(image);
char *known_keys[] = { "tEXt::Thumb::URI", "tEXt::Thumb::MTime",
"tEXt::Thumb::Size", "tEXt::Thumb::Mimetype",
"tEXt::Description", "tEXt::Software",
"tEXt::Thumb::Image::Width", "tEXt::Thumb::Image::Height",
"tEXt::Thumb::Document::Pages", "tEXt::Thumb::Movie::Length" };
guint i, x;
/* unfortunately GdkPixbuf APIs does not contain API to get
list of options that are set, neither there is API to save
the file with all options, so all we can do now is to scan
options for known ones and save them into target file */
for (i = 0, x = 0; i < G_N_ELEMENTS(known_keys); i++)
{
const char *val = gdk_pixbuf_get_option(pix, known_keys[i]);
if (val)
{
keys[x] = known_keys[i];
vals[x] = (char*)val;
x++;
}
}
keys[x] = NULL;
vals[x] = NULL;
return gdk_pixbuf_savev(pix, filename, "png", keys, vals, NULL);
}
static void
dump_thumbs (Itdb_PhotoDB *db, Itdb_Artwork *artwork,
const gchar *album_name, const gchar *dir)
{
GList *it;
gint i = 0;
GList *thumbnails;
thumbnails = itdb_thumb_to_pixbufs (db->device, artwork->thumbnail);
for (it = thumbnails; it != NULL; it = it->next, i++) {
gchar *filename, *path;
GdkPixbuf *pixbuf;
pixbuf = GDK_PIXBUF (it->data);
g_return_if_fail (pixbuf);
filename = g_strdup_printf ("%s-%d-%d.png",
album_name, artwork->id, i );
path = g_build_filename (dir, filename, NULL);
g_free (filename);
gdk_pixbuf_save (pixbuf, path, "png", NULL, NULL);
g_object_unref (pixbuf);
g_free (path);
}
g_list_free (thumbnails);
}
static VALUE
rg_m_set_icon(int argc, VALUE *argv, VALUE self)
{
VALUE context, obj, pixmap = Qnil, mask = Qnil, hot_x, hot_y;
if (argc == 6) {
rb_scan_args(argc, argv, "60", &context, &obj, &pixmap, &mask, &hot_x, &hot_y);
gtk_drag_set_icon_pixmap(RVAL2DC(context),
GDK_COLORMAP(RVAL2GOBJ(obj)),
GDK_PIXMAP(RVAL2GOBJ(pixmap)),
GDK_BITMAP(RVAL2GOBJ(mask)),
NUM2INT(hot_x), NUM2INT(hot_y));
} else {
rb_scan_args(argc, argv, "40", &context, &obj, &hot_x, &hot_y);
if (TYPE(obj) == T_SYMBOL){
gtk_drag_set_icon_stock(RVAL2DC(context), rb_id2name(SYM2ID(obj)),
NUM2INT(hot_x), NUM2INT(hot_y));
} else if (rb_obj_is_kind_of(obj, GTYPE2CLASS(GTK_TYPE_WIDGET))){
gtk_drag_set_icon_widget(RVAL2DC(context), RVAL2WIDGET(obj),
NUM2INT(hot_x), NUM2INT(hot_y));
} else if (rb_obj_is_kind_of(obj, GTYPE2CLASS(GDK_TYPE_PIXBUF))){
gtk_drag_set_icon_pixbuf(RVAL2DC(context),
GDK_PIXBUF(RVAL2GOBJ(obj)),
NUM2INT(hot_x), NUM2INT(hot_y));
} else {
rb_raise(rb_eArgError, "invalid argument %s", rb_class2name(CLASS_OF(obj)));
}
}
return self;
}
PyObject *
gdkpixbuf_get_pixels_array(PyObject *pixbuf_pyobject)
{
GdkPixbuf *pixbuf = GDK_PIXBUF(((PyGObject *)pixbuf_pyobject)->obj);
PyArrayObject *array;
npy_intp dims[3] = { 0, 0, 3 };
dims[0] = gdk_pixbuf_get_height(pixbuf);
dims[1] = gdk_pixbuf_get_width(pixbuf);
if (gdk_pixbuf_get_has_alpha(pixbuf))
dims[2] = 4;
guchar *pixels = gdk_pixbuf_get_pixels(pixbuf);
array = (PyArrayObject *)PyArray_SimpleNewFromData(3, dims, NPY_UBYTE,
pixels);
if (array == NULL)
return NULL;
PyArray_STRIDES(array)[0] = gdk_pixbuf_get_rowstride(pixbuf);
// the array holds a ref to the pixbuf pixels through this wrapper
Py_INCREF(pixbuf_pyobject);
#ifdef NPY_1_7_API_VERSION
PyArray_SetBaseObject(array, (PyObject *)pixbuf_pyobject);
#else
array->base = (PyObject *)pixbuf_pyobject;
#endif
return PyArray_Return(array);
}
static GeglRectangle
get_bounding_box (GeglOperation *operation)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
GeglRectangle result = {0,0,0,0};
if (!o->pixbuf)
{
return result;
}
result.x = 0;
result.y = 0;
result.width = gdk_pixbuf_get_width (GDK_PIXBUF (o->pixbuf));
result.height = gdk_pixbuf_get_height (GDK_PIXBUF (o->pixbuf));
return result;
}
static void
photos_base_item_icon_updated (PhotosBaseItem *self, GIcon *icon)
{
if (icon == NULL)
return;
photos_base_item_set_original_icon (self, GDK_PIXBUF (icon));
}
/*
* Method: set_mark_category_pixbuf(category, pixbuf)
* category: a category (as a string).
* pixbuf: a Gdk::Pixbuf object.
*
* Associates a given pixbuf with a given category.
*
* Returns: self.
*/
static VALUE
rg_set_mark_category_pixbuf(VALUE self, VALUE category, VALUE pixbuf)
{
gtk_source_view_set_mark_category_pixbuf(_SELF(self),
RVAL2CSTR(category),
GDK_PIXBUF(RVAL2GOBJ(pixbuf)));
return self;
}
void cgraphics_workspace_window_update_icon( widget_t *widget )
{
workspace_window_widget_t * window = (workspace_window_widget_t *)widget;
GtkNotebook * notebook = GTK_NOTEBOOK(WIDGET(OBJECT(window)->parent)->native);
GtkWidget * tab_label = gtk_notebook_get_tab_label(notebook, GTK_WIDGET(widget->native));
GtkImage * icon = GTK_IMAGE(g_object_get_data(G_OBJECT(tab_label), "icon"));
if(window->icon)
gtk_image_set_from_pixbuf(icon, GDK_PIXBUF(window->icon->native));
}
/**
* fm_pixbuf_from_icon_with_fallback
* @icon: icon descriptor
* @size: size in pixels
* @fallback: (allow-none): name of fallback icon
*
* Creates a #GdkPixbuf and draws icon there. If icon cannot be found then
* icon with name @fallback will be loaded instead.
*
* Returns: (transfer full): an image.
*
* Since: 1.2.0
*/
GdkPixbuf* fm_pixbuf_from_icon_with_fallback(FmIcon* icon, int size, const char *fallback)
{
GtkIconInfo* ii;
GdkPixbuf* pix = NULL;
GSList *pixs, *l;
PixEntry* ent;
pixs = (GSList*)g_object_steal_qdata(G_OBJECT(icon), fm_qdata_id);
for( l = pixs; l; l=l->next )
{
ent = (PixEntry*)l->data;
if(ent->size == size) /* cached pixbuf is found! */
{
return ent->pix ? GDK_PIXBUF(g_object_ref(ent->pix)) : NULL;
}
}
/* not found! load the icon from disk */
ii = gtk_icon_theme_lookup_by_gicon(gtk_icon_theme_get_default(), G_ICON(icon), size, GTK_ICON_LOOKUP_FORCE_SIZE);
if(ii)
{
pix = gtk_icon_info_load_icon(ii, NULL);
gtk_icon_info_free(ii);
/* increase ref_count to keep this pixbuf in memory
even when no one is using it. */
if(pix)
g_object_ref(pix);
}
if (pix == NULL)
{
char* str = g_icon_to_string(G_ICON(icon));
g_debug("unable to load icon %s", str);
if(fallback)
pix = gtk_icon_theme_load_icon(gtk_icon_theme_get_default(), fallback,
size, GTK_ICON_LOOKUP_USE_BUILTIN|GTK_ICON_LOOKUP_FORCE_SIZE, NULL);
if(pix == NULL) /* still unloadable */
pix = gtk_icon_theme_load_icon(gtk_icon_theme_get_default(), "unknown",
size, GTK_ICON_LOOKUP_USE_BUILTIN|GTK_ICON_LOOKUP_FORCE_SIZE, NULL);
if(G_LIKELY(pix))
g_object_ref(pix);
g_free(str);
}
/* cache this! */
ent = g_slice_new(PixEntry);
ent->size = size;
ent->pix = pix;
/* FIXME: maybe we should unload icons that nobody is using to reduce memory usage. */
/* g_object_weak_ref(); */
pixs = g_slist_prepend(pixs, ent);
g_object_set_qdata_full(G_OBJECT(icon), fm_qdata_id, pixs, destroy_pixbufs);
return pix;
}
static void
gdk_pixbuf_finalize (GObject *object)
{
GdkPixbuf *pixbuf = GDK_PIXBUF (object);
if (pixbuf->destroy_fn)
(* pixbuf->destroy_fn) (pixbuf->pixels, pixbuf->destroy_fn_data);
G_OBJECT_CLASS (gdk_pixbuf_parent_class)->finalize (object);
}
static VALUE
rbgdk_rval2gdkpixbufglist_body(VALUE value)
{
long i;
struct rval2gdkpixbufglist_args *args = (struct rval2gdkpixbufglist_args *)value;
for (i = 0; i < args->n; i++)
args->result = g_list_append(args->result, GDK_PIXBUF(RVAL2GOBJ(RARRAY_PTR(args->ary)[i])));
return Qnil;
}
GdkPixbuf *
list_store_get_pixbuf(GtkWidget *w, GtkTreeIter *iter, int col)
{
GtkTreeModel *model;
GObject *v;
model = gtk_tree_view_get_model(GTK_TREE_VIEW(w));
gtk_tree_model_get(model, iter, col, &v, -1);
return GDK_PIXBUF(v);
}
void adm_changeIcon_systray(void)
{
GdkPixbuf *cur;
flipflop%=nbListOfIcons; // Double check
cur=listOfIcons[flipflop];
ADM_assert(cur);
flipflop++;
flipflop%=nbListOfIcons; // Double check
gtk_image_set_from_pixbuf( GTK_IMAGE(img), GDK_PIXBUF(cur));
}
/*! \brief Get a pixel buffer for a picture object.
* \par Function Description
* Returns a #GdkPixbuf for the picture object \a object, or NULL if
* the picture could not be loaded.
*
* The returned value should have its reference count decremented with
* g_object_unref() when no longer needed.
*
* \param toplevel The current #TOPLEVEL.
* \param object The picture #OBJECT to inspect.
* \return A #GdkPixbuf for the picture.
*/
GdkPixbuf *
o_picture_get_pixbuf (TOPLEVEL *toplevel, OBJECT *object)
{
g_return_val_if_fail (object != NULL, NULL);
g_return_val_if_fail (object->picture != NULL, NULL);
if (object->picture->pixbuf != NULL) {
return GDK_PIXBUF (g_object_ref (object->picture->pixbuf));
} else {
return NULL;
}
}
static void
gdk_pixbuf_finalize (GObject *object)
{
GdkPixbuf *pixbuf = GDK_PIXBUF (object);
if (pixbuf->pixels && pixbuf->destroy_fn)
(* pixbuf->destroy_fn) (pixbuf->pixels, pixbuf->destroy_fn_data);
g_clear_pointer (&pixbuf->bytes, g_bytes_unref);
G_OBJECT_CLASS (gdk_pixbuf_parent_class)->finalize (object);
}
static GdkPixbuf*
gdk_pixbuf_gif_anim_get_static_image (GdkPixbufAnimation *animation)
{
GdkPixbufGifAnim *gif_anim;
gif_anim = GDK_PIXBUF_GIF_ANIM (animation);
if (gif_anim->frames == NULL)
return NULL;
else
return GDK_PIXBUF (((GdkPixbufFrame*)gif_anim->frames->data)->pixbuf);
}
static VALUE
rg_draw_pixbuf(VALUE self, VALUE gc, VALUE pixbuf, VALUE src_x, VALUE src_y, VALUE dest_x, VALUE dest_y, VALUE width, VALUE height, VALUE dither, VALUE x_dither, VALUE y_dither)
{
gdk_draw_pixbuf(_SELF(self),
GDK_GC(RVAL2GOBJ(gc)),
GDK_PIXBUF(RVAL2GOBJ(pixbuf)),
NUM2INT(src_x), NUM2INT(src_y),
NUM2INT(dest_x), NUM2INT(dest_y),
NUM2INT(width), NUM2INT(height),
RVAL2GENUM(dither, GDK_TYPE_RGB_DITHER),
NUM2INT(x_dither), NUM2INT(y_dither));
return self;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *output,
const GeglRectangle *result,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
if (o->pixbuf)
{
GeglRectangle extent;
extent.x = 0;
extent.y = 0;
extent.width = gdk_pixbuf_get_width (GDK_PIXBUF (o->pixbuf));
extent.height = gdk_pixbuf_get_height (GDK_PIXBUF (o->pixbuf));
gegl_buffer_set (output, &extent, 0, NULL, gdk_pixbuf_get_pixels (GDK_PIXBUF (o->pixbuf)),
GEGL_AUTO_ROWSTRIDE);
}
return TRUE;
}
static void create_pixbufs(void)
{
GtkTextDirection dir =
gtk_widget_get_direction(GTK_WIDGET(widgets.app));
bm_pixbufs = g_new0(BookMarksPixbufs, 1);
if (dir == GTK_TEXT_DIR_LTR) {
/* leave this for if we make custom reversable icons
if (!bm_pixbufs->pixbuf_closed)
bm_pixbufs->pixbuf_closed =
pixbuf_finder("book_closed.png", 16, NULL);
*/
bm_pixbufs->pixbuf_opened =
pixbuf_finder("book_open.png", 16, NULL);
} else {
/* leave this for if we make custom reversable icons
if (!bm_pixbufs->pixbuf_closed)
bm_pixbufs->pixbuf_closed =
pixbuf_finder("book_closed_rtol.png", 16, NULL);
*/
bm_pixbufs->pixbuf_opened =
pixbuf_finder("book_open_rtol.png", 16, NULL);
}
bm_pixbufs->pixbuf_closed =
pixbuf_finder("epiphany-bookmarks.png", 0, NULL);
bm_pixbufs->pixbuf_helpdoc =
pixbuf_finder("epiphany-bookmark-page.png", 0, NULL);
if (!bm_pixbufs->pixbuf_helpdoc)
#ifdef USE_GTK_3
bm_pixbufs->pixbuf_helpdoc =
#ifdef HAVE_GTK_310
GDK_PIXBUF(gtk_image_new_from_icon_name("gtk-dnd",
GTK_ICON_SIZE_BUTTON));
#else
gtk_widget_render_icon_pixbuf(widgets.app,
GTK_STOCK_DND,
GTK_ICON_SIZE_MENU);
#endif
#else
bm_pixbufs->pixbuf_helpdoc = gtk_widget_render_icon(widgets.app,
GTK_STOCK_DND,
GTK_ICON_SIZE_MENU, NULL);
#endif
}
