static GdkPaintable * gtk_icon_helper_load_paintable (GtkIconHelper *self, gboolean *out_symbolic) { GdkPaintable *paintable; GIcon *gicon; gboolean symbolic; switch (gtk_image_definition_get_storage_type (self->def)) { case GTK_IMAGE_PAINTABLE: paintable = g_object_ref (gtk_image_definition_get_paintable (self->def)); symbolic = FALSE; break; case GTK_IMAGE_ICON_NAME: if (self->use_fallback) gicon = g_themed_icon_new_with_default_fallbacks (gtk_image_definition_get_icon_name (self->def)); else gicon = g_themed_icon_new (gtk_image_definition_get_icon_name (self->def)); paintable = ensure_paintable_for_gicon (self, gtk_css_node_get_style (self->node), gtk_widget_get_direction (self->owner), gtk_widget_get_scale_factor (self->owner), gicon, &symbolic); g_object_unref (gicon); break; case GTK_IMAGE_GICON: paintable = ensure_paintable_for_gicon (self, gtk_css_node_get_style (self->node), gtk_widget_get_direction (self->owner), gtk_widget_get_scale_factor (self->owner), gtk_image_definition_get_gicon (self->def), &symbolic); break; case GTK_IMAGE_EMPTY: default: paintable = NULL; symbolic = FALSE; break; } *out_symbolic = symbolic; return paintable; }
/** * gs_shell_main_window_mapped_cb: */ static void gs_shell_main_window_mapped_cb (GtkWidget *widget, GsShell *shell) { GsShellPrivate *priv = gs_shell_get_instance_private (shell); gs_plugin_loader_set_scale (priv->plugin_loader, gtk_widget_get_scale_factor (widget)); }
static void gd_tagged_entry_tag_ensure_close_surface (GdTaggedEntryTag *tag, GtkStyleContext *context) { GtkIconInfo *info; GdkPixbuf *pixbuf; gint icon_size; gint scale_factor; if (tag->close_surface != NULL) return; gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &icon_size, NULL); scale_factor = gtk_widget_get_scale_factor (GTK_WIDGET (tag->entry)); info = gtk_icon_theme_lookup_icon_for_scale (gtk_icon_theme_get_default (), "window-close-symbolic", icon_size, scale_factor, GTK_ICON_LOOKUP_GENERIC_FALLBACK); /* FIXME: we need a fallback icon in case the icon is not found */ pixbuf = gtk_icon_info_load_symbolic_for_context (info, context, NULL, NULL); tag->close_surface = gdk_cairo_surface_create_from_pixbuf (pixbuf, scale_factor, tag->window); g_object_unref (info); g_object_unref (pixbuf); }
static NemoIconInfo * real_get_icon (NemoWindow *window, NemoWindowSlot *slot) { return nemo_icon_info_lookup_from_name (NEMO_ICON_DESKTOP, 48, gtk_widget_get_scale_factor (GTK_WIDGET (window))); }
static NautilusIconInfo * nautilus_canvas_view_container_get_icon_images (NautilusCanvasContainer *container, NautilusCanvasIconData *data, int size, gboolean for_drag_accept) { NautilusCanvasView *canvas_view; NautilusFile *file; NautilusFileIconFlags flags; NautilusIconInfo *icon_info; gint scale; file = (NautilusFile *) data; g_assert (NAUTILUS_IS_FILE (file)); canvas_view = get_canvas_view (container); g_return_val_if_fail (canvas_view != NULL, NULL); flags = NAUTILUS_FILE_ICON_FLAGS_USE_EMBLEMS | NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS; if (for_drag_accept) { flags |= NAUTILUS_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT; } scale = gtk_widget_get_scale_factor (GTK_WIDGET (canvas_view)); icon_info = nautilus_file_get_icon (file, size, scale, flags); return icon_info; }
static void size_allocate(GtkWidget *widget, GdkRectangle *allocation, gpointer user_data) { GeglGtkView *self = GEGL_GTK_VIEW(widget); gint scale_factor; scale_factor = gtk_widget_get_scale_factor (widget); view_helper_set_allocation(GET_PRIVATE(self), allocation, scale_factor); }
gint bg_source_get_scale_factor (BgSource *source) { BgSourcePrivate *priv; g_return_val_if_fail (BG_IS_SOURCE (source), 1); priv = bg_source_get_instance_private (source); return gtk_widget_get_scale_factor (priv->window); }
static void update_display_preview (CcBackgroundPanel *panel, GtkWidget *widget, CcBackgroundItem *current_background) { CcBackgroundPanelPrivate *priv = panel->priv; GtkAllocation allocation; const gint preview_width = 309; const gint preview_height = 168; gint scale_factor; GdkPixbuf *pixbuf; cairo_t *cr; gtk_widget_get_allocation (widget, &allocation); if (!current_background) return; scale_factor = gtk_widget_get_scale_factor (widget); pixbuf = cc_background_item_get_frame_thumbnail (current_background, priv->thumb_factory, preview_width, preview_height, scale_factor, -2, TRUE); cr = gdk_cairo_create (gtk_widget_get_window (widget)); gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0); cairo_paint (cr); g_object_unref (pixbuf); pixbuf = NULL; if (current_background == priv->current_background && panel->priv->display_screenshot != NULL) { pixbuf = gdk_pixbuf_scale_simple (panel->priv->display_screenshot, preview_width, preview_height, GDK_INTERP_BILINEAR); } if (pixbuf) { gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0); cairo_paint (cr); g_object_unref (pixbuf); } cairo_destroy (cr); }
static void gtk_icon_helper_ensure_surface (GtkIconHelper *self) { int scale; if (self->priv->rendered_surface) return; scale = gtk_widget_get_scale_factor (gtk_css_gadget_get_owner (GTK_CSS_GADGET (self))); self->priv->rendered_surface = gtk_icon_helper_load_surface (self, scale); }
static void photos_image_view_update (PhotosImageView *self) { GdkRectangle viewport; GeglRectangle bbox; float zoom_scaled = 1.0; gint scale_factor; gint viewport_height_real; gint viewport_width_real; if (self->node == NULL) return; gtk_widget_get_allocation (GTK_WIDGET (self), &viewport); if (viewport.width < 0 || viewport.height < 0) return; bbox = gegl_node_get_bounding_box (self->node); if (bbox.width < 0 || bbox.height < 0) return; scale_factor = gtk_widget_get_scale_factor (GTK_WIDGET (self)); viewport_height_real = viewport.height * scale_factor; viewport_width_real = viewport.width * scale_factor; if (bbox.height > viewport_height_real || bbox.width > viewport_width_real) { gfloat height_ratio = bbox.height / (gfloat) viewport_height_real; gfloat width_ratio = bbox.width / (gfloat) viewport_width_real; gfloat max_ratio = MAX (height_ratio, width_ratio); zoom_scaled = 1.0 / max_ratio; bbox.width = (gint) (zoom_scaled * bbox.width + 0.5); bbox.height = (gint) (zoom_scaled * bbox.height + 0.5); bbox.x = (gint) (zoom_scaled * bbox.x + 0.5); bbox.y = (gint) (zoom_scaled * bbox.y + 0.5); } self->zoom_scaled = zoom_scaled; self->zoom = self->zoom_scaled / (gfloat) scale_factor; /* At this point, viewport is definitely bigger than bbox. */ self->x_scaled = (bbox.width - viewport_width_real) / 2.0 + bbox.x; self->y_scaled = (bbox.height - viewport_height_real) / 2.0 + bbox.y; self->x = self->x_scaled / (gfloat) scale_factor; self->y = self->y_scaled / (gfloat) scale_factor; }
static void file_icons_changed (NautilusFile *file, NautilusFileConflictDialog *fcd) { GdkPixbuf *pixbuf; pixbuf = nautilus_file_get_icon_pixbuf (fcd->details->destination, NAUTILUS_ICON_SIZE_LARGE, TRUE, gtk_widget_get_scale_factor (fcd->details->dest_image), NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS); gtk_image_set_from_pixbuf (GTK_IMAGE (fcd->details->dest_image), pixbuf); g_object_unref (pixbuf); pixbuf = nautilus_file_get_icon_pixbuf (fcd->details->source, NAUTILUS_ICON_SIZE_LARGE, TRUE, gtk_widget_get_scale_factor (fcd->details->src_image), NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS); gtk_image_set_from_pixbuf (GTK_IMAGE (fcd->details->src_image), pixbuf); g_object_unref (pixbuf); }
static gboolean resize_cb (GtkWidget * widget, GdkEvent * event, gpointer sink) { GtkAllocation allocation; gint scale = 1; #if GTK_CHECK_VERSION(3, 10, 0) scale = gtk_widget_get_scale_factor (widget); #endif gtk_widget_get_allocation (widget, &allocation); gst_video_overlay_set_render_rectangle (GST_VIDEO_OVERLAY (sink), allocation.x * scale, allocation.y * scale, allocation.width * scale, allocation.height * scale); return G_SOURCE_CONTINUE; }
static void update_size_window (MetaResizePopup *popup) { char *str; int x, y; int width, height; int scale; g_return_if_fail (popup->size_window != NULL); scale = gtk_widget_get_scale_factor (GTK_WIDGET (popup->size_window)); /* Translators: This represents the size of a window. The first number is * the width of the window and the second is the height. */ str = g_strdup_printf (_("%d x %d"), popup->horizontal_size, popup->vertical_size); gtk_label_set_text (GTK_LABEL (popup->size_label), str); g_free (str); gtk_window_get_size (GTK_WINDOW (popup->size_window), &width, &height); x = popup->rect.x + (popup->rect.width - width) / 2; y = popup->rect.y + (popup->rect.height - height) / 2; if (scale) { x = x / scale; y = y / scale; } if (gtk_widget_get_realized (popup->size_window)) { /* using move_resize to avoid jumpiness */ gdk_window_move_resize (gtk_widget_get_window (popup->size_window), x, y, width, height); } else { gtk_window_move (GTK_WINDOW (popup->size_window), x, y); } }
static void render_image (UmUserImage *image) { cairo_surface_t *surface; gint scale, pixel_size; if (image->priv->user == NULL) return; pixel_size = gtk_image_get_pixel_size (GTK_IMAGE (image)); scale = gtk_widget_get_scale_factor (GTK_WIDGET (image)); surface = render_user_icon (image->priv->user, UM_ICON_STYLE_NONE, pixel_size > 0 ? pixel_size : 48, scale); gtk_image_set_from_surface (GTK_IMAGE (image), surface); cairo_surface_destroy (surface); }
static GtkStyleProviderPrivate * gtk_css_widget_node_get_style_provider (GtkCssNode *node) { GtkCssWidgetNode *widget_node = GTK_CSS_WIDGET_NODE (node); GtkStyleContext *context; GtkStyleCascade *cascade; if (widget_node->widget == NULL) return NULL; context = _gtk_widget_peek_style_context (widget_node->widget); if (context) return gtk_style_context_get_style_provider (context); cascade = _gtk_settings_get_style_cascade (gtk_widget_get_settings (widget_node->widget), gtk_widget_get_scale_factor (widget_node->widget)); return GTK_STYLE_PROVIDER_PRIVATE (cascade); }
void gtd_row_measure_with_max (GtkWidget *widget, GtkOrientation orientation, gint for_size, gint *minimum, gint *natural, gint *minimum_baseline, gint *natural_baseline) { if (orientation == GTK_ORIENTATION_VERTICAL) { gtk_widget_measure (gtk_bin_get_child (GTK_BIN (widget)), orientation, for_size, minimum, natural, minimum_baseline, natural_baseline); } else { gint local_minimum_width; gint local_natural_width; gint scale_factor; gint margins; gtk_widget_measure (gtk_bin_get_child (GTK_BIN (widget)), orientation, for_size, &local_minimum_width, &local_natural_width, minimum_baseline, natural_baseline); scale_factor = gtk_widget_get_scale_factor (widget); margins = gtk_widget_get_margin_start (widget) + gtk_widget_get_margin_end (widget); if (minimum) *minimum = (MIN (local_minimum_width, MAX_WIDTH) - margins) * scale_factor; if (natural) *natural = (MAX (local_minimum_width, MAX_WIDTH) - margins) * scale_factor; } }
static void photos_image_view_draw_node (PhotosImageView *self, cairo_t *cr, GdkRectangle *rect) { const Babl *format; GeglRectangle roi; cairo_surface_t *surface = NULL; guchar *buf = NULL; gint scale_factor; gint stride; gint64 end; gint64 start; scale_factor = gtk_widget_get_scale_factor (GTK_WIDGET (self)); roi.x = (gint) self->x_scaled + rect->x * scale_factor; roi.y = (gint) self->y_scaled + rect->y * scale_factor; roi.width = rect->width * scale_factor; roi.height = rect->height * scale_factor; format = babl_format ("cairo-ARGB32"); stride = cairo_format_stride_for_width (CAIRO_FORMAT_ARGB32, roi.width); buf = g_malloc0 (stride * roi.height); start = g_get_monotonic_time (); gegl_node_blit (self->node, (gdouble) self->zoom_scaled, &roi, format, buf, GEGL_AUTO_ROWSTRIDE, GEGL_BLIT_CACHE | GEGL_BLIT_DIRTY); end = g_get_monotonic_time (); photos_debug (PHOTOS_DEBUG_GEGL, "PhotosImageView: Node Blit: %" G_GINT64_FORMAT, end - start); surface = cairo_image_surface_create_for_data (buf, CAIRO_FORMAT_ARGB32, roi.width, roi.height, stride); cairo_surface_set_device_scale (surface, (gdouble) scale_factor, (gdouble) scale_factor); cairo_set_source_surface (cr, surface, rect->x, rect->y); cairo_paint (cr); cairo_surface_destroy (surface); g_free (buf); }
static void bg_source_calculate_thumbnail_dimensions (BgSource *source) { BgSourcePrivate *priv = bg_source_get_instance_private (source); gint scale_factor; priv->thumbnail_height = THUMBNAIL_HEIGHT; priv->thumbnail_width = THUMBNAIL_WIDTH; if (priv->window == NULL) return; scale_factor = gtk_widget_get_scale_factor (priv->window); if (scale_factor > 1) { priv->thumbnail_height *= scale_factor; priv->thumbnail_width *= scale_factor; } }
static void from_name (GtkSourcePixbufHelper *helper, GtkWidget *widget, gint size) { GdkScreen *screen; GtkIconTheme *icon_theme; GtkIconInfo *info; GtkIconLookupFlags flags; gint scale; screen = gtk_widget_get_screen (widget); icon_theme = gtk_icon_theme_get_for_screen (screen); flags = GTK_ICON_LOOKUP_USE_BUILTIN; scale = gtk_widget_get_scale_factor (widget); info = gtk_icon_theme_lookup_icon_for_scale (icon_theme, helper->icon_name, size, scale, flags); if (info) { GdkPixbuf *pixbuf; if (gtk_icon_info_is_symbolic (info)) { GtkStyleContext *context; context = gtk_widget_get_style_context (widget); pixbuf = gtk_icon_info_load_symbolic_for_context (info, context, NULL, NULL); } else { pixbuf = gtk_icon_info_load_icon (info, NULL); } set_cache (helper, pixbuf); } }
GdkPixbuf * nemo_ui_get_menu_icon (const char *icon_name, GtkWidget *parent_widget) { NemoIconInfo *info; GdkPixbuf *pixbuf; int size; int scale; size = nemo_get_icon_size_for_stock_size (GTK_ICON_SIZE_MENU); scale = gtk_widget_get_scale_factor (parent_widget); if (g_path_is_absolute (icon_name)) { info = nemo_icon_info_lookup_from_path (icon_name, size, scale); } else { info = nemo_icon_info_lookup_from_name (icon_name, size, scale); } pixbuf = nemo_icon_info_get_pixbuf_nodefault_at_size (info, size); g_object_unref (info); return pixbuf; }
static gint gd_tagged_entry_tag_get_width (GdTaggedEntryTag *tag, GdTaggedEntry *entry) { GtkBorder button_padding, button_border, button_margin; GtkStyleContext *context; GtkStateFlags state; gint layout_width; gint button_width; gint scale_factor; gd_tagged_entry_tag_ensure_layout (tag, entry); pango_layout_get_pixel_size (tag->layout, &layout_width, NULL); context = gd_tagged_entry_tag_get_context (tag, entry); state = gd_tagged_entry_tag_get_state (tag, entry); gtk_style_context_get_padding (context, state, &button_padding); gtk_style_context_get_border (context, state, &button_border); gtk_style_context_get_margin (context, state, &button_margin); gd_tagged_entry_tag_ensure_close_surface (tag, context); g_object_unref (context); button_width = 0; if (entry->button_visible && tag->has_close_button) { scale_factor = gtk_widget_get_scale_factor (GTK_WIDGET (entry)); button_width = cairo_image_surface_get_width (tag->close_surface) / scale_factor + BUTTON_INTERNAL_SPACING; } return layout_width + button_padding.left + button_padding.right + button_border.left + button_border.right + button_margin.left + button_margin.right + button_width; }
void cb_scale_factor(GObject* object, GParamSpec* UNUSED(pspec), gpointer data) { zathura_t* zathura = data; if (zathura == NULL || zathura->document == NULL) { return; } int new_factor = gtk_widget_get_scale_factor(GTK_WIDGET(object)); if (new_factor == 0) { girara_debug("Ignoring new device scale factor = 0"); return; } zathura_device_factors_t current = zathura_document_get_device_factors(zathura->document); if (fabs(new_factor - current.x) >= DBL_EPSILON || fabs(new_factor - current.y) >= DBL_EPSILON) { zathura_document_set_device_factors(zathura->document, new_factor, new_factor); girara_debug("New device scale factor: %d", new_factor); zathura_update_view_ppi(zathura); render_all(zathura); } }
void egg_empty_state_set_resource (EggEmptyState *self, const gchar *resource) { EggEmptyStatePrivate *priv = egg_empty_state_get_instance_private (self); g_return_if_fail (EGG_IS_EMPTY_STATE (self)); if (resource != NULL) { GdkPixbuf *pixbuf; GError *error = NULL; gint scale_factor; scale_factor = gtk_widget_get_scale_factor (GTK_WIDGET (self)); pixbuf = gdk_pixbuf_new_from_resource_at_scale (resource, 128 * scale_factor, 128 * scale_factor, TRUE, &error); if (pixbuf == NULL) { g_warning ("%s", error->message); g_clear_error (&error); return; } g_object_set (priv->image, "pixbuf", pixbuf, NULL); g_clear_object (&pixbuf); } }
static void _size_changed_cb (GtkWidget * widget, GdkRectangle * rectangle, GstGtkGLSink * gtk_sink) { gint scale_factor, width, height; gboolean reconfigure; scale_factor = gtk_widget_get_scale_factor (widget); width = scale_factor * gtk_widget_get_allocated_width (widget); height = scale_factor * gtk_widget_get_allocated_height (widget); GST_OBJECT_LOCK (gtk_sink); reconfigure = (width != gtk_sink->display_width || height != gtk_sink->display_height); gtk_sink->display_width = width; gtk_sink->display_height = height; GST_OBJECT_UNLOCK (gtk_sink); if (reconfigure) { GST_DEBUG_OBJECT (gtk_sink, "Sending reconfigure event on sinkpad."); gst_pad_push_event (GST_BASE_SINK (gtk_sink)->sinkpad, gst_event_new_reconfigure ()); } }
int XournalView::getDpiScaleFactor() { XOJ_CHECK_TYPE(XournalView); return gtk_widget_get_scale_factor(widget); }
static NemoIconInfo * nemo_icon_view_container_get_icon_images (NemoIconContainer *container, NemoIconData *data, int size, char **embedded_text, gboolean for_drag_accept, gboolean need_large_embeddded_text, gboolean *embedded_text_needs_loading, gboolean *has_window_open) { NemoIconView *icon_view; char **emblems_to_ignore; NemoFile *file; NemoFileIconFlags flags; NemoIconInfo *icon_info; GdkPixbuf *pixbuf; GIcon *emblemed_icon; GEmblem *emblem; GList *emblem_icons, *l; gint scale; file = (NemoFile *) data; g_assert (NEMO_IS_FILE (file)); icon_view = get_icon_view (container); g_return_val_if_fail (icon_view != NULL, NULL); *has_window_open = nemo_file_has_open_window (file); flags = NEMO_FILE_ICON_FLAGS_USE_MOUNT_ICON_AS_EMBLEM | NEMO_FILE_ICON_FLAGS_USE_THUMBNAILS; if (for_drag_accept) { flags |= NEMO_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT; } emblems_to_ignore = nemo_view_get_emblem_names_to_exclude (NEMO_VIEW (icon_view)); emblem_icons = nemo_file_get_emblem_icons (file, emblems_to_ignore); g_strfreev (emblems_to_ignore); scale = gtk_widget_get_scale_factor (GTK_WIDGET (icon_view)); icon_info = nemo_file_get_icon (file, size, scale, flags); /* apply emblems */ if (emblem_icons != NULL) { l = emblem_icons; pixbuf = nemo_icon_info_get_pixbuf (icon_info); gint w, h, s; gboolean bad_ratio; w = gdk_pixbuf_get_width (pixbuf); h = gdk_pixbuf_get_height (pixbuf); s = MAX (w, h); if (s < size) size = s; bad_ratio = nemo_icon_get_emblem_size_for_icon_size (size) * scale > w || nemo_icon_get_emblem_size_for_icon_size (size) * scale > h; if (bad_ratio) goto skip_emblem; /* Would prefer to not use goto, but * I don't want to do these checks on * non-emblemed icons (the majority) * as it would be too costly */ emblem = g_emblem_new (l->data); emblemed_icon = g_emblemed_icon_new (G_ICON (pixbuf), emblem); g_object_unref (emblem); for (l = l->next; l != NULL; l = l->next) { emblem = g_emblem_new (l->data); g_emblemed_icon_add_emblem (G_EMBLEMED_ICON (emblemed_icon), emblem); g_object_unref (emblem); } g_clear_object (&icon_info); icon_info = nemo_icon_info_lookup (emblemed_icon, size, scale); g_object_unref (emblemed_icon); skip_emblem: g_object_unref (pixbuf); } if (emblem_icons != NULL) { g_list_free_full (emblem_icons, g_object_unref); } return icon_info; }
void nemo_launch_application_by_uri (GAppInfo *application, GList *uris, GtkWindow *parent_window) { char *uri; GList *locations, *l; GFile *location; NemoFile *file; gboolean result; GError *error; GdkDisplay *display; GdkAppLaunchContext *launch_context; NemoIconInfo *icon; int count, total; g_assert (uris != NULL); /* count the number of uris with local paths */ count = 0; total = g_list_length (uris); locations = NULL; for (l = uris; l != NULL; l = l->next) { uri = l->data; location = g_file_new_for_uri (uri); if (g_file_is_native (location)) { count++; } locations = g_list_prepend (locations, location); } locations = g_list_reverse (locations); if (parent_window != NULL) { display = gtk_widget_get_display (GTK_WIDGET (parent_window)); } else { display = gdk_display_get_default (); } launch_context = gdk_display_get_app_launch_context (display); if (parent_window != NULL) { gdk_app_launch_context_set_screen (launch_context, gtk_window_get_screen (parent_window)); } file = nemo_file_get_by_uri (uris->data); icon = nemo_file_get_icon (file, 48, gtk_widget_get_scale_factor (GTK_WIDGET (parent_window)), 0); nemo_file_unref (file); if (icon) { gdk_app_launch_context_set_icon_name (launch_context, nemo_icon_info_get_used_name (icon)); g_object_unref (icon); } error = NULL; if (count == total) { /* All files are local, so we can use g_app_info_launch () with * the file list we constructed before. */ result = g_app_info_launch (application, locations, G_APP_LAUNCH_CONTEXT (launch_context), &error); } else { /* Some files are non local, better use g_app_info_launch_uris (). */ result = g_app_info_launch_uris (application, uris, G_APP_LAUNCH_CONTEXT (launch_context), &error); } g_object_unref (launch_context); if (result) { for (l = uris; l != NULL; l = l->next) { file = nemo_file_get_by_uri (l->data); nemo_recent_add_file (file, application); nemo_file_unref (file); } } g_list_free_full (locations, g_object_unref); }
static gboolean gtk_color_swatch_render_overlay (GtkCssGadget *gadget, cairo_t *cr, int x, int y, int width, int height, gpointer data) { GtkWidget *widget; GtkColorSwatch *swatch; GtkStyleContext *context; GtkStateFlags state; GtkIconTheme *theme; GtkIconInfo *icon_info = NULL; gint scale; widget = gtk_css_gadget_get_owner (gadget); swatch = GTK_COLOR_SWATCH (widget); theme = gtk_icon_theme_get_default (); context = gtk_widget_get_style_context (widget); state = gtk_style_context_get_state (context); scale = gtk_widget_get_scale_factor (widget); if (swatch->priv->icon) { icon_info = gtk_icon_theme_lookup_icon_for_scale (theme, swatch->priv->icon, PIXBUF_SIZE, scale, GTK_ICON_LOOKUP_GENERIC_FALLBACK | GTK_ICON_LOOKUP_USE_BUILTIN); } else if ((state & GTK_STATE_FLAG_SELECTED) != 0) { GIcon *gicon; gicon = g_themed_icon_new ("object-select-symbolic"); /* fallback for themes that don't have object-select-symbolic */ g_themed_icon_append_name (G_THEMED_ICON (gicon), "gtk-apply"); icon_info = gtk_icon_theme_lookup_by_gicon_for_scale (theme, gicon, PIXBUF_SIZE, scale, GTK_ICON_LOOKUP_USE_BUILTIN); g_object_unref (gicon); } /* now draw the overlay image */ if (icon_info != NULL) { GdkPixbuf *pixbuf; pixbuf = gtk_icon_info_load_symbolic_for_context (icon_info, context, NULL, NULL); if (pixbuf != NULL) { cairo_surface_t *surface; surface = gdk_cairo_surface_create_from_pixbuf (pixbuf, scale, gtk_widget_get_window (widget)); gtk_render_icon_surface (context, cr, surface, x, y); cairo_surface_destroy (surface); g_object_unref (pixbuf); } g_object_unref (icon_info); } return FALSE; }
/** * gs_screenshot_image_load_async: **/ void gs_screenshot_image_load_async (GsScreenshotImage *ssimg, GCancellable *cancellable) { AsImage *im = NULL; GsScreenshotImagePrivate *priv; SoupURI *base_uri = NULL; const gchar *url; gint rc; _cleanup_free_ gchar *basename = NULL; _cleanup_free_ gchar *cachedir2 = NULL; _cleanup_free_ gchar *cachedir = NULL; _cleanup_free_ gchar *sizedir = NULL; g_return_if_fail (GS_IS_SCREENSHOT_IMAGE (ssimg)); priv = gs_screenshot_image_get_instance_private (ssimg); g_return_if_fail (AS_IS_SCREENSHOT (priv->screenshot)); g_return_if_fail (priv->width != 0); g_return_if_fail (priv->height != 0); /* load an image according to the scale factor */ priv->scale = gtk_widget_get_scale_factor (GTK_WIDGET (ssimg)); im = as_screenshot_get_image (priv->screenshot, priv->width * priv->scale, priv->height * priv->scale); /* if we've failed to load a HiDPI image, fallback to LoDPI */ if (im == NULL && priv->scale > 1) { priv->scale = 1; im = as_screenshot_get_image (priv->screenshot, priv->width, priv->height); } if (im == NULL) { /* TRANSLATORS: this is when we request a screenshot size that * the generator did not create or the parser did not add */ gs_screenshot_image_set_error (ssimg, _("Screenshot size not found")); return; } url = as_image_get_url (im); basename = g_path_get_basename (url); if (priv->width == G_MAXUINT || priv->height == G_MAXUINT) { sizedir = g_strdup ("unknown"); } else { sizedir = g_strdup_printf ("%ux%u", priv->width * priv->scale, priv->height * priv->scale); } cachedir = g_build_filename (priv->cachedir, "gnome-software", "screenshots", sizedir, NULL); rc = g_mkdir_with_parents (cachedir, 0700); if (rc != 0) { /* TRANSLATORS: this is when we try create the cache directory * but we were out of space or permission was denied */ gs_screenshot_image_set_error (ssimg, _("Could not create cache")); return; } /* does local file already exist */ priv->filename = g_build_filename (cachedir, basename, NULL); if (g_file_test (priv->filename, G_FILE_TEST_EXISTS)) { as_screenshot_show_image (ssimg); return; } /* can we load a blurred smaller version of this straight away */ if (priv->width > AS_IMAGE_THUMBNAIL_WIDTH && priv->height > AS_IMAGE_THUMBNAIL_HEIGHT) { cachedir2 = g_build_filename (priv->cachedir, "gnome-software", "screenshots", "112x63", basename, NULL); if (g_file_test (cachedir2, G_FILE_TEST_EXISTS)) gs_screenshot_image_show_blurred (ssimg, cachedir2); } /* download file */ g_debug ("downloading %s to %s", url, priv->filename); base_uri = soup_uri_new (url); if (base_uri == NULL || !SOUP_URI_VALID_FOR_HTTP (base_uri)) { /* TRANSLATORS: this is when we try to download a screenshot * that was not a valid URL */ gs_screenshot_image_set_error (ssimg, _("Screenshot not valid")); soup_uri_free (base_uri); return; } /* cancel any previous messages */ if (priv->message != NULL) { soup_session_cancel_message (priv->session, priv->message, SOUP_STATUS_CANCELLED); g_clear_object (&priv->message); } priv->message = soup_message_new_from_uri (SOUP_METHOD_GET, base_uri); if (priv->message == NULL) { /* TRANSLATORS: this is when networking is not available */ gs_screenshot_image_set_error (ssimg, _("Screenshot not available")); soup_uri_free (base_uri); return; } /* send async */ soup_session_queue_message (priv->session, g_object_ref (priv->message) /* transfer full */, gs_screenshot_image_complete_cb, g_object_ref (ssimg)); soup_uri_free (base_uri); }
static void file_list_ready_cb (GList *files, gpointer user_data) { NautilusFileConflictDialog *fcd = user_data; NautilusFile *src, *dest, *dest_dir; time_t src_mtime, dest_mtime; gboolean source_is_dir, dest_is_dir, should_show_type; NautilusFileConflictDialogDetails *details; char *primary_text, *message, *secondary_text; const gchar *message_extra; char *dest_name, *dest_dir_name, *edit_name; char *label_text; char *size, *date, *type = NULL; GdkPixbuf *pixbuf; GtkWidget *label; GString *str; PangoAttrList *attr_list; details = fcd->details; details->handle = NULL; dest_dir = g_list_nth_data (files, 0); dest = g_list_nth_data (files, 1); src = g_list_nth_data (files, 2); src_mtime = nautilus_file_get_mtime (src); dest_mtime = nautilus_file_get_mtime (dest); dest_name = nautilus_file_get_display_name (dest); dest_dir_name = nautilus_file_get_display_name (dest_dir); source_is_dir = nautilus_file_is_directory (src); dest_is_dir = nautilus_file_is_directory (dest); type = nautilus_file_get_mime_type (dest); should_show_type = !nautilus_file_is_mime_type (src, type); g_free (type); type = NULL; /* Set up the right labels */ if (dest_is_dir) { if (source_is_dir) { primary_text = g_strdup_printf (_("Merge folder “%s”?"), dest_name); message_extra = _("Merging will ask for confirmation before replacing any files in " "the folder that conflict with the files being copied."); if (src_mtime > dest_mtime) { message = g_strdup_printf ( _("An older folder with the same name already exists in “%s”."), dest_dir_name); } else if (src_mtime < dest_mtime) { message = g_strdup_printf ( _("A newer folder with the same name already exists in “%s”."), dest_dir_name); } else { message = g_strdup_printf ( _("Another folder with the same name already exists in “%s”."), dest_dir_name); } } else { message_extra = _("Replacing it will remove all files in the folder."); primary_text = g_strdup_printf (_("Replace folder “%s”?"), dest_name); message = g_strdup_printf (_("A folder with the same name already exists in “%s”."), dest_dir_name); } } else { primary_text = g_strdup_printf (_("Replace file “%s”?"), dest_name); message_extra = _("Replacing it will overwrite its content."); if (src_mtime > dest_mtime) { message = g_strdup_printf ( _("An older file with the same name already exists in “%s”."), dest_dir_name); } else if (src_mtime < dest_mtime) { message = g_strdup_printf ( _("A newer file with the same name already exists in “%s”."), dest_dir_name); } else { message = g_strdup_printf ( _("Another file with the same name already exists in “%s”."), dest_dir_name); } } secondary_text = g_strdup_printf ("%s\n%s", message, message_extra); g_free (message); label = gtk_label_new (primary_text); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_label_set_line_wrap_mode (GTK_LABEL (label), PANGO_WRAP_WORD_CHAR); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (details->titles_vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); attr_list = pango_attr_list_new (); pango_attr_list_insert (attr_list, pango_attr_weight_new (PANGO_WEIGHT_BOLD)); pango_attr_list_insert (attr_list, pango_attr_scale_new (PANGO_SCALE_LARGE)); g_object_set (label, "attributes", attr_list, NULL); pango_attr_list_unref (attr_list); label = gtk_label_new (secondary_text); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (details->titles_vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (primary_text); g_free (secondary_text); /* Set up file icons */ pixbuf = nautilus_file_get_icon_pixbuf (dest, NAUTILUS_ICON_SIZE_LARGE, TRUE, gtk_widget_get_scale_factor (fcd->details->titles_vbox), NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS); details->dest_image = gtk_image_new_from_pixbuf (pixbuf); gtk_box_pack_start (GTK_BOX (details->first_hbox), details->dest_image, FALSE, FALSE, 0); gtk_widget_show (details->dest_image); g_object_unref (pixbuf); pixbuf = nautilus_file_get_icon_pixbuf (src, NAUTILUS_ICON_SIZE_LARGE, TRUE, gtk_widget_get_scale_factor (fcd->details->titles_vbox), NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS); details->src_image = gtk_image_new_from_pixbuf (pixbuf); gtk_box_pack_start (GTK_BOX (details->second_hbox), details->src_image, FALSE, FALSE, 0); gtk_widget_show (details->src_image); g_object_unref (pixbuf); /* Set up labels */ label = gtk_label_new (NULL); date = nautilus_file_get_string_attribute (dest, "date_modified"); size = nautilus_file_get_string_attribute (dest, "size"); if (should_show_type) { type = nautilus_file_get_string_attribute (dest, "type"); } str = g_string_new (NULL); g_string_append_printf (str, "<b>%s</b>\n", _("Original file")); g_string_append_printf (str, "%s %s\n", _("Size:"), size); if (should_show_type) { g_string_append_printf (str, "%s %s\n", _("Type:"), type); } g_string_append_printf (str, "%s %s", _("Last modified:"), date); label_text = str->str; gtk_label_set_markup (GTK_LABEL (label), label_text); gtk_box_pack_start (GTK_BOX (details->first_hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (size); g_free (type); g_free (date); g_string_erase (str, 0, -1); /* Second label */ label = gtk_label_new (NULL); date = nautilus_file_get_string_attribute (src, "date_modified"); size = nautilus_file_get_string_attribute (src, "size"); if (should_show_type) { type = nautilus_file_get_string_attribute (src, "type"); } g_string_append_printf (str, "<b>%s</b>\n", _("Replace with")); g_string_append_printf (str, "%s %s\n", _("Size:"), size); if (should_show_type) { g_string_append_printf (str, "%s %s\n", _("Type:"), type); } g_string_append_printf (str, "%s %s", _("Last modified:"), date); label_text = g_string_free (str, FALSE); gtk_label_set_markup (GTK_LABEL (label), label_text); gtk_box_pack_start (GTK_BOX (details->second_hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (size); g_free (date); g_free (type); g_free (label_text); /* Populate the entry */ edit_name = nautilus_file_get_edit_name (dest); details->conflict_name = edit_name; gtk_entry_set_text (GTK_ENTRY (details->entry), edit_name); if (source_is_dir && dest_is_dir) { gtk_button_set_label (GTK_BUTTON (details->replace_button), _("Merge")); } nautilus_file_monitor_add (src, fcd, NAUTILUS_FILE_ATTRIBUTES_FOR_ICON); nautilus_file_monitor_add (dest, fcd, NAUTILUS_FILE_ATTRIBUTES_FOR_ICON); details->src_handler_id = g_signal_connect (src, "changed", G_CALLBACK (file_icons_changed), fcd); details->dest_handler_id = g_signal_connect (dest, "changed", G_CALLBACK (file_icons_changed), fcd); }