void
setup_menuitem_with_icon (GtkWidget *menuitem,
GtkIconSize icon_size,
GIcon *gicon,
const char *image_filename,
const char *title)
{
GtkWidget *image;
GIcon *icon = NULL;
image = gtk_image_new ();
g_object_set (image, "icon-size", icon_size, NULL);
if (gicon)
icon = g_object_ref (gicon);
else if (image_filename)
icon = panel_gicon_from_icon_name (image_filename);
gtk_image_set_from_gicon (GTK_IMAGE(image), icon, icon_size);
g_object_unref (icon);
gtk_widget_show (image);
setup_menuitem (menuitem, icon_size, image, title);
}
static void
trash_applet_monitor_changed (TrashApplet *applet)
{
GError *error = NULL;
GFileInfo *info;
GIcon *icon;
gint items;
info = g_file_query_info (applet->trash,
G_FILE_ATTRIBUTE_STANDARD_ICON","
G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT,
0, NULL, &error);
if (!info)
{
g_critical ("could not query trash:/: '%s'", error->message);
g_error_free (error);
return;
}
icon = g_file_info_get_icon (info);
items = g_file_info_get_attribute_uint32 (info,
G_FILE_ATTRIBUTE_TRASH_ITEM_COUNT);
if (!g_icon_equal (icon, applet->icon))
{
/* note: the size is meaningless here,
* since we do set_pixel_size() later
*/
gtk_image_set_from_gicon (GTK_IMAGE (applet->image),
icon, GTK_ICON_SIZE_MENU);
if (applet->icon)
g_object_unref (applet->icon);
applet->icon = g_object_ref (icon);
}
if (items != applet->items)
{
if (items)
{
char *text;
text = g_strdup_printf (ngettext ("%d Item in Trash",
"%d Items in Trash",
items), items);
gtk_widget_set_tooltip_text (GTK_WIDGET (applet), text);
g_free (text);
}
else
gtk_widget_set_tooltip_text (GTK_WIDGET (applet),
_("No Items in Trash"));
applet->items = items;
}
g_object_unref (info);
}
static gboolean
activatable_update_gicon (GtkImageMenuItem *image_menu_item, GtkAction *action)
{
GtkWidget *image;
GIcon *icon = gtk_action_get_gicon (action);
const gchar *stock_id;
gboolean ret = FALSE;
stock_id = gtk_action_get_stock_id (action);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
image = gtk_image_menu_item_get_image (image_menu_item);
if (icon && GTK_IS_IMAGE (image) &&
!(stock_id && gtk_icon_factory_lookup_default (stock_id)))
{
gtk_image_set_from_gicon (GTK_IMAGE (image), icon, GTK_ICON_SIZE_MENU);
ret = TRUE;
}
G_GNUC_END_IGNORE_DEPRECATIONS;
return ret;
}
static void
update_icon (GpMenuButtonApplet *menu_button)
{
GpMenuButtonAppletPrivate *priv;
GIcon *icon;
gchar *custom_icon;
GtkPositionType position;
priv = gp_menu_button_applet_get_instance_private (menu_button);
icon = NULL;
custom_icon = g_settings_get_string (priv->settings, "custom-icon");
if (*custom_icon != '\0')
icon = g_themed_icon_new (custom_icon);
if (icon == NULL && priv->menu != NULL && priv->custom_menu)
icon = gp_menu_get_icon (GP_MENU (priv->menu));
if (icon == NULL)
icon = g_themed_icon_new ("start-here");
gtk_image_set_from_gicon (GTK_IMAGE (priv->image), icon, GTK_ICON_SIZE_MENU);
g_object_unref (icon);
g_free (custom_icon);
position = gp_applet_get_position (GP_APPLET (menu_button));
update_arrow (menu_button, position);
}
static void
clear_tip (GtkMenuItem *item,
gpointer user_data)
{
GList *children;
GtkWidget *image;
GIcon *icon, *icon2;
const char *filename;
/* Not a stock icon? */
filename = g_object_get_data (G_OBJECT (item), "filename");
if (filename == NULL)
return;
children = gtk_container_get_children (GTK_CONTAINER (item));
image = children->data;
g_assert (image != NULL);
g_list_free (children);
gtk_image_get_gicon (GTK_IMAGE (image), &icon, NULL);
if (G_IS_EMBLEMED_ICON (icon))
icon2 = g_emblemed_icon_get_icon (G_EMBLEMED_ICON (icon));
else
return;
gtk_image_set_from_gicon (GTK_IMAGE (image), icon2, GTK_ICON_SIZE_DIALOG);
g_object_unref (icon);
}
static void
special_item_activated_cb (GtkAppChooserButton *b,
const gchar *item_name,
gpointer user_data)
{
gtk_image_set_from_gicon (GTK_IMAGE (sel_image), g_themed_icon_new ("face-smile"));
gtk_label_set_text (GTK_LABEL (sel_name), "Special Item");
}
static void
ido_media_player_menu_item_set_player_icon (IdoMediaPlayerMenuItem *self,
GIcon *icon)
{
g_return_if_fail (IDO_IS_MEDIA_PLAYER_MENU_ITEM (self));
gtk_image_set_from_gicon (GTK_IMAGE (self->player_icon), icon, GTK_ICON_SIZE_MENU);
}
static void
refresh_cb (GtkWidget *button,
gpointer user_data)
{
PackData *d = user_data;
gtk_image_set_from_gicon (GTK_IMAGE (d->image), d->numerable, d->size);
}
void
ol_player_chooser_set_image_by_gicon (OlPlayerChooser *window,
GIcon *icon)
{
ol_assert (OL_IS_PLAYER_CHOOSER (window));
ol_assert (G_IS_ICON (icon));
OlPlayerChooserPrivate *priv = OL_PLAYER_CHOOSER_GET_PRIVATE (window);
gtk_image_set_from_gicon (priv->info_icon, icon, GTK_ICON_SIZE_DIALOG);
}
static void
gtk_tool_button_sync_action_properties (GtkActivatable *activatable,
GtkAction *action)
{
GtkToolButton *button;
GIcon *icon;
const gchar *stock_id;
GtkIconSet *icon_set = NULL;
parent_activatable_iface->sync_action_properties (activatable, action);
if (!action)
return;
if (!gtk_activatable_get_use_action_appearance (activatable))
return;
button = GTK_TOOL_BUTTON (activatable);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
stock_id = gtk_action_get_stock_id (action);
G_GNUC_END_IGNORE_DEPRECATIONS;
gtk_tool_button_set_label (button, gtk_action_get_short_label (action));
gtk_tool_button_set_use_underline (button, TRUE);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
gtk_tool_button_set_stock_id (button, stock_id);
G_GNUC_END_IGNORE_DEPRECATIONS;
gtk_tool_button_set_icon_name (button, gtk_action_get_icon_name (action));
if (stock_id)
{
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
icon_set = gtk_icon_factory_lookup_default (stock_id);
G_GNUC_END_IGNORE_DEPRECATIONS;
}
if (icon_set != NULL)
gtk_tool_button_set_icon_widget (button, NULL);
else if ((icon = gtk_action_get_gicon (action)) != NULL)
{
GtkIconSize icon_size = gtk_tool_item_get_icon_size (GTK_TOOL_ITEM (button));
GtkWidget *image = gtk_tool_button_get_icon_widget (button);
if (!image)
{
image = gtk_image_new ();
gtk_widget_show (image);
gtk_tool_button_set_icon_widget (button, image);
}
gtk_image_set_from_gicon (GTK_IMAGE (image), icon, icon_size);
}
else if (gtk_action_get_icon_name (action))
gtk_tool_button_set_icon_name (button, gtk_action_get_icon_name (action));
else
gtk_tool_button_set_label (button, gtk_action_get_short_label (action));
}
static void
ido_source_menu_item_set_icon (IdoSourceMenuItem *item,
GIcon *icon)
{
if (icon)
gtk_image_set_from_gicon (GTK_IMAGE (item->icon), icon, GTK_ICON_SIZE_MENU);
else
gtk_image_clear (GTK_IMAGE (item->icon));
}
static void
gtk_places_view_row_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkPlacesViewRow *self = GTK_PLACES_VIEW_ROW (object);
switch (prop_id)
{
case PROP_ICON:
gtk_image_set_from_gicon (self->icon_image,
g_value_get_object (value),
GTK_ICON_SIZE_LARGE_TOOLBAR);
break;
case PROP_NAME:
gtk_label_set_label (self->name_label, g_value_get_string (value));
break;
case PROP_PATH:
gtk_label_set_label (self->path_label, g_value_get_string (value));
break;
case PROP_VOLUME:
g_set_object (&self->volume, g_value_get_object (value));
break;
case PROP_MOUNT:
g_set_object (&self->mount, g_value_get_object (value));
/*
* When we hide the eject button, no size is allocated for it. Since
* we want to have alignment between rows, it needs an empty space
* when the eject button is not available. So, call then
* gtk_widget_set_child_visible(), which makes the button allocate the
* size but it stays hidden when needed.
*/
gtk_widget_set_child_visible (GTK_WIDGET (self->eject_button), self->mount != NULL);
break;
case PROP_FILE:
g_set_object (&self->file, g_value_get_object (value));
break;
case PROP_IS_NETWORK:
gtk_places_view_row_set_is_network (self, g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static VALUE
rg_set_from_gicon(int argc, VALUE *argv, VALUE self)
{
GtkImage *image;
VALUE rb_gicon, rb_size;
image = RVAL2GTKIMAGE(self);
rb_scan_args(argc, argv, "11", &rb_gicon, &rb_size);
gtk_image_set_from_gicon(image,
RVAL2GICON(rb_gicon),
icon_size_from_ruby(image, rb_size));
return self;
}
/**
* gtk_tooltip_set_icon_from_gicon:
* @tooltip: a #GtkTooltip
* @gicon: (allow-none): a #GIcon representing the icon, or %NULL
* @size: (type int): a stock icon size
*
* Sets the icon of the tooltip (which is in front of the text)
* to be the icon indicated by @gicon with the size indicated
* by @size. If @gicon is %NULL, the image will be hidden.
*
* Since: 2.20
*/
void
gtk_tooltip_set_icon_from_gicon (GtkTooltip *tooltip,
GIcon *gicon,
GtkIconSize size)
{
g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
gtk_image_set_from_gicon (GTK_IMAGE (tooltip->image), gicon, size);
if (gicon)
gtk_widget_show (tooltip->image);
else
gtk_widget_hide (tooltip->image);
}
static void
button_clicked_cb (GtkButton *b,
gpointer user_data)
{
PackData *d = user_data;
GtkCssProvider *provider;
GtkStyleContext *style;
GError *error = NULL;
gchar *data, *bg_str, *grad1, *grad2;
const gchar data_format[] = "GtkNumerableIcon { background-color: %s; color: #000000;"
"background-image: -gtk-gradient (linear, 0 0, 1 1, from(%s), to(%s));"
"font: Monospace 12;"
/* "background-image: url('apple-red.png');" */
"}";
bg_str = g_strdup_printf ("rgb(%d,%d,%d)", g_random_int_range (0, 255), g_random_int_range (0, 255), g_random_int_range (0, 255));
grad1 = g_strdup_printf ("rgb(%d,%d,%d)", g_random_int_range (0, 255), g_random_int_range (0, 255), g_random_int_range (0, 255));
grad2 = g_strdup_printf ("rgb(%d,%d,%d)", g_random_int_range (0, 255), g_random_int_range (0, 255), g_random_int_range (0, 255));
data = g_strdup_printf (data_format, bg_str, grad1, grad2);
provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (provider, data, -1, &error);
g_assert (error == NULL);
style = gtk_widget_get_style_context (d->image);
gtk_style_context_add_provider (style, GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_USER);
if (d->odd) {
gtk_numerable_icon_set_background_icon_name (GTK_NUMERABLE_ICON (d->numerable), NULL);
gtk_numerable_icon_set_count (GTK_NUMERABLE_ICON (d->numerable), g_random_int_range (-99, 99));
} else {
gtk_numerable_icon_set_background_icon_name (GTK_NUMERABLE_ICON (d->numerable),
"emblem-favorite");
gtk_numerable_icon_set_label (GTK_NUMERABLE_ICON (d->numerable), "IVX");
}
gtk_image_set_from_gicon (GTK_IMAGE (d->image), d->numerable, d->size);
d->odd = !d->odd;
g_free (data);
g_free (bg_str);
g_free (grad1);
g_free (grad2);
g_object_unref (provider);
}
static void
pack_numerable (GtkWidget *parent,
GtkIconSize size)
{
PackData *d;
GtkWidget *vbox, *label, *image, *button;
gchar *str;
GIcon *icon, *numerable;
d = g_slice_new0 (PackData);
image = gtk_image_new ();
icon = g_themed_icon_new ("system-file-manager");
numerable = gtk_numerable_icon_new (icon);
d->image = image;
d->numerable = numerable;
d->odd = FALSE;
d->size = size;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_box_pack_start (GTK_BOX (parent), vbox, FALSE, FALSE, 0);
gtk_numerable_icon_set_count (GTK_NUMERABLE_ICON (numerable), 42);
gtk_box_pack_start (GTK_BOX (vbox), image, FALSE, FALSE, 0);
gtk_numerable_icon_set_style_context (GTK_NUMERABLE_ICON (numerable),
gtk_widget_get_style_context (image));
gtk_image_set_from_gicon (GTK_IMAGE (image), numerable, size);
label = gtk_label_new (NULL);
str = g_strdup_printf ("Numerable icon, hash %u", g_icon_hash (numerable));
gtk_label_set_label (GTK_LABEL (label), str);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Change icon number");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (button_clicked_cb), d);
button = gtk_button_new_with_label ("Properties");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (properties_cb), numerable);
button = gtk_button_new_with_label ("Refresh");
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (refresh_cb), d);
}
static void
volume_widget_init (VolumeWidget *self)
{
//g_debug("VolumeWidget::volume_widget_init");
VolumeWidgetPrivate * priv = VOLUME_WIDGET_GET_PRIVATE(self);
priv->ido_volume_slider = ido_scale_menu_item_new_with_range ("VOLUME", IDO_RANGE_STYLE_DEFAULT, 0, 0, 100, 1);
g_object_ref (priv->ido_volume_slider);
ido_scale_menu_item_set_primary_label (IDO_SCALE_MENU_ITEM(priv->ido_volume_slider), "VOLUME");
ido_scale_menu_item_set_style (IDO_SCALE_MENU_ITEM (priv->ido_volume_slider), IDO_SCALE_MENU_ITEM_STYLE_IMAGE);
g_object_set(priv->ido_volume_slider, "reverse-scroll-events", TRUE, NULL);
g_signal_connect (priv->ido_volume_slider,
"notify::parent", G_CALLBACK (volume_widget_parent_changed),
NULL);
GtkWidget* volume_widget = ido_scale_menu_item_get_scale((IdoScaleMenuItem*)priv->ido_volume_slider);
g_signal_connect(volume_widget, "change-value", G_CALLBACK(volume_widget_change_value_cb), self);
g_signal_connect(volume_widget, "value-changed", G_CALLBACK(volume_widget_value_changed_cb), self);
g_signal_connect(priv->ido_volume_slider, "slider-grabbed", G_CALLBACK(volume_widget_slider_grabbed), self);
g_signal_connect(priv->ido_volume_slider, "slider-released", G_CALLBACK(volume_widget_slider_released), self);
GtkWidget* primary_image = ido_scale_menu_item_get_primary_image((IdoScaleMenuItem*)priv->ido_volume_slider);
GIcon * primary_gicon = g_themed_icon_new_with_default_fallbacks("audio-volume-low-zero-panel");
gtk_image_set_from_gicon(GTK_IMAGE(primary_image), primary_gicon, GTK_ICON_SIZE_MENU);
g_object_unref(primary_gicon);
GtkWidget* secondary_image = ido_scale_menu_item_get_secondary_image((IdoScaleMenuItem*)priv->ido_volume_slider);
GIcon * secondary_gicon = g_themed_icon_new_with_default_fallbacks("audio-volume-high-panel");
gtk_image_set_from_gicon(GTK_IMAGE(secondary_image), secondary_gicon, GTK_ICON_SIZE_MENU);
g_object_unref(secondary_gicon);
GtkAdjustment *adj = gtk_range_get_adjustment (GTK_RANGE (volume_widget));
gtk_adjustment_set_step_increment(adj, 4);
}
static void
combo_changed_cb (GtkAppChooserButton *button,
gpointer user_data)
{
GAppInfo *app_info;
app_info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (button));
if (app_info == NULL)
return;
gtk_image_set_from_gicon (GTK_IMAGE (sel_image), g_app_info_get_icon (app_info));
gtk_label_set_text (GTK_LABEL (sel_name), g_app_info_get_display_name (app_info));
g_object_unref (app_info);
}
static void
combo_changed_cb (GtkComboBox *cb,
gpointer user_data)
{
GAppInfo *app_info;
app_info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (cb));
if (app_info == NULL)
return;
gtk_image_set_from_gicon (GTK_IMAGE (sel_image), g_app_info_get_icon (app_info),
GTK_ICON_SIZE_DIALOG);
gtk_label_set_text (GTK_LABEL (sel_name), g_app_info_get_display_name (app_info));
g_object_unref (app_info);
}
static void
gtk_tool_button_update (GtkActivatable *activatable,
GtkAction *action,
const gchar *property_name)
{
GtkToolButton *button;
GtkWidget *image;
parent_activatable_iface->update (activatable, action, property_name);
if (!gtk_activatable_get_use_action_appearance (activatable))
return;
button = GTK_TOOL_BUTTON (activatable);
if (strcmp (property_name, "short-label") == 0)
gtk_tool_button_set_label (button, gtk_action_get_short_label (action));
else if (strcmp (property_name, "stock-id") == 0)
gtk_tool_button_set_stock_id (button, gtk_action_get_stock_id (action));
else if (strcmp (property_name, "gicon") == 0)
{
const gchar *stock_id = gtk_action_get_stock_id (action);
GIcon *icon = gtk_action_get_gicon (action);
GtkIconSize icon_size = GTK_ICON_SIZE_BUTTON;
if ((stock_id && gtk_icon_factory_lookup_default (stock_id)) || !icon)
image = NULL;
else
{
image = gtk_tool_button_get_icon_widget (button);
icon_size = gtk_tool_item_get_icon_size (GTK_TOOL_ITEM (button));
if (!image)
image = gtk_image_new ();
}
gtk_tool_button_set_icon_widget (button, image);
gtk_image_set_from_gicon (GTK_IMAGE (image), icon, icon_size);
}
else if (strcmp (property_name, "icon-name") == 0)
gtk_tool_button_set_icon_name (button, gtk_action_get_icon_name (action));
}
static void
do_icons_to_add (void)
{
while (icons_to_add) {
IconToAdd *icon_to_add = icons_to_add->data;
icons_to_add = g_list_delete_link (icons_to_add, icons_to_add);
if (icon_to_add->stock_id) {
gtk_image_set_from_stock (
GTK_IMAGE (icon_to_add->image),
icon_to_add->stock_id,
icon_to_add->icon_size);
} else if (icon_to_add->gicon) {
gtk_image_set_from_gicon (
GTK_IMAGE (icon_to_add->image),
icon_to_add->gicon,
icon_to_add->icon_size);
} else {
g_assert (icon_to_add->pixbuf);
gtk_image_set_from_pixbuf (
GTK_IMAGE (icon_to_add->image),
icon_to_add->pixbuf);
g_signal_connect (icon_to_add->image, "style-set",
G_CALLBACK (menu_item_style_set),
GINT_TO_POINTER (icon_to_add->icon_size));
g_object_unref (icon_to_add->pixbuf);
}
if (icon_to_add->gicon)
g_object_unref (icon_to_add->gicon);
g_object_unref (icon_to_add->image);
g_free (icon_to_add);
}
}
static void
do_icons_to_add (void)
{
while (icons_to_add) {
IconToAdd *icon_to_add = icons_to_add->data;
int icon_height;
icons_to_add = g_list_delete_link (icons_to_add, icons_to_add);
if (icon_to_add->gicon) {
gtk_image_set_from_gicon (
GTK_IMAGE (icon_to_add->image),
icon_to_add->gicon,
icon_to_add->icon_size);
} else {
g_assert (icon_to_add->pixbuf);
gtk_image_set_from_pixbuf (
GTK_IMAGE (icon_to_add->image),
icon_to_add->pixbuf);
g_signal_connect (icon_to_add->image, "style-updated",
G_CALLBACK (menu_item_style_updated),
GINT_TO_POINTER (icon_to_add->icon_size));
g_object_unref (icon_to_add->pixbuf);
}
if (gtk_icon_size_lookup (icon_to_add->icon_size, NULL, &icon_height))
gtk_image_set_pixel_size (GTK_IMAGE (icon_to_add->image), icon_height);
if (icon_to_add->gicon)
g_object_unref (icon_to_add->gicon);
g_object_unref (icon_to_add->image);
g_free (icon_to_add);
}
}
static void
set_tip (GtkWidget *item,
const char *tip,
GEmblem *emblem)
{
GList *children;
GtkWidget *image;
GIcon *icon, *icon2;
children = gtk_container_get_children (GTK_CONTAINER (item));
image = children->data;
g_assert (image != NULL);
g_list_free (children);
gtk_image_get_gicon (GTK_IMAGE (image), &icon, NULL);
if (G_IS_EMBLEMED_ICON (icon)) {
return;
}
icon2 = g_emblemed_icon_new (icon, emblem);
gtk_image_set_from_gicon (GTK_IMAGE (image), icon2, GTK_ICON_SIZE_DIALOG);
gtk_widget_set_tooltip_text (GTK_WIDGET (item), tip);
}
static void update_ui (FmFilePropData *data)
{
GtkImage *img = (GtkImage*) data->icon;
if ( data->single_type ) // all files are of the same mime-type
{
GIcon *icon = NULL;
// FIXME_pcm: handle custom icons for some files
/* FIXME_pcm: display special property pages for special files or
* some specified mime-types. */
if ( data->single_file ) // only one file is selected.
{
FmFileInfo *file_info = (FmFileInfo*)fm_list_peek_head (data->files);
icon = fm_file_info_get_gicon (file_info);
}
if (data->mime_type)
{
if (!icon)
{
FmIcon *ficon = fm_mime_type_get_icon (data->mime_type);
if (ficon)
icon = ficon->gicon;
}
gtk_label_set_text (GTK_LABEL (data->type), fm_mime_type_get_desc (data->mime_type));
}
if (icon)
gtk_image_set_from_gicon (img, icon, GTK_ICON_SIZE_DIALOG);
if ( data->single_file && fm_file_info_is_symlink (data->file_info) )
{
gtk_widget_show (data->target_label);
gtk_widget_show (data->target);
gtk_label_set_text (GTK_LABEL (data->target), fm_file_info_get_target (data->file_info));
// gtk_label_set_text (data->type, fm_mime_type_get_desc (data->mime_type));
}
else
{
gtk_widget_destroy (data->target_label);
gtk_widget_destroy (data->target);
}
}
else
{
gtk_image_set_from_stock (img, GTK_STOCK_DND_MULTIPLE, GTK_ICON_SIZE_DIALOG);
gtk_widget_set_sensitive (data->name, FALSE);
gtk_label_set_text (GTK_LABEL (data->type), _("Files of different types"));
gtk_widget_destroy (data->target_label);
gtk_widget_destroy (data->target);
gtk_widget_destroy (data->open_with_label);
gtk_widget_destroy (data->open_with);
data->open_with = data->open_with_label = NULL;
}
// FIXME_pcm: check if all files has the same parent dir, mtime, or atime
if ( data->single_file )
{
char buf[128];
FmPath *parent = fm_path_get_parent (fm_file_info_get_path (data->file_info));
char *parent_str = parent ? fm_path_display_name (parent, TRUE) : NULL;
gtk_entry_set_text (GTK_ENTRY (data->name), fm_file_info_get_disp_name (data->file_info));
if (parent_str)
{
gtk_label_set_text (GTK_LABEL (data->dir), parent_str);
g_free (parent_str);
}
else
gtk_label_set_text (GTK_LABEL (data->dir), "");
gtk_label_set_text (GTK_LABEL (data->mtime), fm_file_info_get_disp_mtime (data->file_info));
// FIXME_pcm: need to encapsulate this in an libfm API.
strftime ( buf, sizeof ( buf ),
"%x %R",
localtime ( &data->file_info->atime ) );
gtk_label_set_text (GTK_LABEL (data->atime), buf);
}
else
{
gtk_entry_set_text (GTK_ENTRY (data->name), _("Multiple Files"));
gtk_widget_set_sensitive (data->name, FALSE);
}
update_permissions (data);
on_timeout (data);
}
static gint on_ask_rename(FmFileOpsJob* job, FmFileInfo* src, FmFileInfo* dest, char** new_name, FmProgressDisplay* data)
{
int res;
GtkBuilder* builder = gtk_builder_new();
GtkWidget *dlg, *src_icon, *dest_icon, *src_fi, *dest_fi, *filename, *apply_all;
char* tmp;
gtk_builder_set_translation_domain(builder, GETTEXT_PACKAGE);
ensure_dlg(data);
gtk_builder_add_from_file(builder, PACKAGE_UI_DIR "/ask-rename.ui", NULL);
dlg = (GtkWidget*)gtk_builder_get_object(builder, "dlg");
src_icon = (GtkWidget*)gtk_builder_get_object(builder, "src_icon");
src_fi = (GtkWidget*)gtk_builder_get_object(builder, "src_fi");
dest_icon = (GtkWidget*)gtk_builder_get_object(builder, "dest_icon");
dest_fi = (GtkWidget*)gtk_builder_get_object(builder, "dest_fi");
filename = (GtkWidget*)gtk_builder_get_object(builder, "filename");
apply_all = (GtkWidget*)gtk_builder_get_object(builder, "apply_all");
gtk_window_set_transient_for(GTK_WINDOW(dlg), data->dlg);
gtk_image_set_from_gicon(GTK_IMAGE(src_icon), src->icon->gicon, GTK_ICON_SIZE_DIALOG);
tmp = g_strdup_printf("Type: %s\nSize: %s\nModified: %s",
fm_file_info_get_desc(src),
fm_file_info_get_disp_size(src),
fm_file_info_get_disp_mtime(src));
gtk_label_set_text(GTK_LABEL(src_fi), tmp);
g_free(tmp);
gtk_image_set_from_gicon(GTK_IMAGE(dest_icon), src->icon->gicon, GTK_ICON_SIZE_DIALOG);
tmp = g_strdup_printf("Type: %s\nSize: %s\nModified: %s",
fm_file_info_get_desc(dest),
fm_file_info_get_disp_size(dest),
fm_file_info_get_disp_mtime(dest));
gtk_label_set_text(GTK_LABEL(dest_fi), tmp);
g_free(tmp);
gtk_entry_set_text(GTK_ENTRY(filename), dest->disp_name);
g_object_set_data(G_OBJECT(filename), "old_name", dest->disp_name);
g_signal_connect(filename, "changed", on_filename_changed, gtk_builder_get_object(builder, "rename"));
g_object_unref(builder);
res = gtk_dialog_run(GTK_DIALOG(dlg));
switch(res)
{
case RESPONSE_RENAME:
*new_name = g_strdup(gtk_entry_get_text(GTK_ENTRY(filename)));
res = FM_FILE_OP_RENAME;
break;
case RESPONSE_OVERWRITE:
res = FM_FILE_OP_OVERWRITE;
break;
case RESPONSE_SKIP:
res = FM_FILE_OP_SKIP;
break;
default:
res = FM_FILE_OP_CANCEL;
}
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(apply_all)))
{
/* FIXME: set default action */
}
gtk_widget_destroy(dlg);
return res;
}
inline static void show_autorun_dlg(GVolume* vol, GMount* mount)
{
GtkBuilder* builder;
GtkTreeIter it;
GtkTreeViewColumn* col;
GtkTreeSelection* tree_sel;
GtkCellRenderer*render;
GtkImage* icon;
GIcon* gicon;
AutoRun* data;
data = g_slice_new(AutoRun);
data->cancel = g_cancellable_new();
builder = gtk_builder_new();
gtk_builder_add_from_file(builder, PACKAGE_UI_DIR "/autorun.glade", NULL);
data->dlg = GTK_DIALOG(gtk_builder_get_object(builder, "dlg"));
data->view = GTK_TREE_VIEW(gtk_builder_get_object(builder, "listview"));
data->type = GTK_LABEL(gtk_builder_get_object(builder, "type"));
icon = GTK_IMAGE(gtk_builder_get_object(builder, "icon"));
g_object_unref(builder);
gicon = g_volume_get_icon(vol);
gtk_image_set_from_gicon(icon, gicon, GTK_ICON_SIZE_DIALOG);
g_object_unref(gicon);
gtk_dialog_set_default_response(data->dlg, GTK_RESPONSE_OK);
gtk_dialog_set_alternative_button_order(data->dlg, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1);
tree_sel = gtk_tree_view_get_selection(data->view);
gtk_tree_selection_set_mode(tree_sel, GTK_SELECTION_BROWSE);
col = gtk_tree_view_column_new();
render = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(col, render, FALSE);
gtk_tree_view_column_set_attributes(col, render, "gicon", 0, NULL);
render = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, render, FALSE);
gtk_tree_view_column_set_attributes(col, render, "text", 1, NULL);
gtk_tree_view_append_column(data->view, col);
data->store = gtk_list_store_new(3, G_TYPE_ICON, G_TYPE_STRING, G_TYPE_OBJECT);
data->mount = (GMount*)g_object_ref(mount);
gtk_list_store_append(data->store, &it);
gicon = g_themed_icon_new("system-file-manager");
gtk_list_store_set(data->store, &it, 0, gicon, 1, _("Open in File Manager"), -1);
g_object_unref(gicon);
gtk_tree_view_set_model(data->view, GTK_TREE_MODEL(data->store));
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(data->store), &it);
gtk_tree_selection_select_iter(tree_sel, &it);
g_signal_connect(data->view, "row-activated", G_CALLBACK(on_row_activated), data);
g_signal_connect(data->dlg, "response", G_CALLBACK(on_dlg_response), data);
g_signal_connect(data->mount, "unmounted", G_CALLBACK(on_unmount), data);
gtk_window_set_keep_above(GTK_WINDOW(data->dlg), TRUE);
gtk_window_present(GTK_WINDOW(data->dlg));
g_mount_guess_content_type(mount, TRUE, data->cancel, on_content_type_finished, data);
pcmanfm_ref();
}
static gint on_ask_rename(FmFileOpsJob* job, FmFileInfo* src, FmFileInfo* dest, char** new_name, FmProgressDisplay* data)
{
int res;
GtkBuilder* builder;
GtkDialog *dlg;
GtkImage *src_icon, *dest_icon;
GtkLabel *src_fi, *dest_fi;
GtkEntry *filename;
GtkToggleButton *apply_all;
char* tmp;
const char* disp_size;
FmPath* path;
FmIcon* icon;
/* return default operation if the user has set it */
if(data->default_opt)
return data->default_opt;
builder = gtk_builder_new();
path = fm_file_info_get_path(dest);
icon = fm_file_info_get_icon(src);
if(data->timer)
g_timer_stop(data->timer);
gtk_builder_set_translation_domain(builder, GETTEXT_PACKAGE);
ensure_dlg(data);
gtk_builder_add_from_file(builder, PACKAGE_UI_DIR "/ask-rename.ui", NULL);
dlg = GTK_DIALOG(gtk_builder_get_object(builder, "dlg"));
src_icon = GTK_IMAGE(gtk_builder_get_object(builder, "src_icon"));
src_fi = GTK_LABEL(gtk_builder_get_object(builder, "src_fi"));
dest_icon = GTK_IMAGE(gtk_builder_get_object(builder, "dest_icon"));
dest_fi = GTK_LABEL(gtk_builder_get_object(builder, "dest_fi"));
filename = GTK_ENTRY(gtk_builder_get_object(builder, "filename"));
apply_all = GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "apply_all"));
gtk_window_set_transient_for(GTK_WINDOW(dlg), GTK_WINDOW(data->dlg));
gtk_image_set_from_gicon(src_icon, icon->gicon, GTK_ICON_SIZE_DIALOG);
disp_size = fm_file_info_get_disp_size(src);
if(disp_size)
{
tmp = g_strdup_printf(_("Type: %s\nSize: %s\nModified: %s"),
fm_file_info_get_desc(src),
disp_size,
fm_file_info_get_disp_mtime(src));
}
else
{
tmp = g_strdup_printf(_("Type: %s\nModified: %s"),
fm_file_info_get_desc(src),
fm_file_info_get_disp_mtime(src));
}
gtk_label_set_text(src_fi, tmp);
g_free(tmp);
gtk_image_set_from_gicon(dest_icon, icon->gicon, GTK_ICON_SIZE_DIALOG);
disp_size = fm_file_info_get_disp_size(dest);
if(disp_size)
{
tmp = g_strdup_printf(_("Type: %s\nSize: %s\nModified: %s"),
fm_file_info_get_desc(dest),
fm_file_info_get_disp_size(dest),
fm_file_info_get_disp_mtime(dest));
}
else
{
tmp = g_strdup_printf(_("Type: %s\nModified: %s"),
fm_file_info_get_desc(dest),
fm_file_info_get_disp_mtime(dest));
}
gtk_label_set_text(dest_fi, tmp);
g_free(tmp);
tmp = g_filename_display_name(fm_path_get_basename(path));
gtk_entry_set_text(filename, tmp);
g_free(tmp);
tmp = (char*)fm_file_info_get_disp_name(dest); /* FIXME: cast const to char */
g_object_set_data(G_OBJECT(filename), "old_name", tmp);
g_signal_connect(filename, "changed", G_CALLBACK(on_filename_changed), gtk_builder_get_object(builder, "rename"));
g_object_unref(builder);
res = gtk_dialog_run(dlg);
switch(res)
{
case RESPONSE_RENAME:
*new_name = g_strdup(gtk_entry_get_text(filename));
res = FM_FILE_OP_RENAME;
break;
case RESPONSE_OVERWRITE:
res = FM_FILE_OP_OVERWRITE;
break;
case RESPONSE_SKIP:
res = FM_FILE_OP_SKIP;
break;
default:
res = FM_FILE_OP_CANCEL;
}
if(gtk_toggle_button_get_active(apply_all))
{
if(res == RESPONSE_OVERWRITE || res == FM_FILE_OP_SKIP)
data->default_opt = res;
}
gtk_widget_destroy(GTK_WIDGET(dlg));
if(data->timer)
g_timer_continue(data->timer);
return res;
}
static gint on_ask_rename (FmFileOpsJob *job, FmFileInfo *src, FmFileInfo *dest, char **new_name, FmProgressDisplay *data)
{
int res;
GtkBuilder *builder = gtk_builder_new ();
GtkWidget *dlg, *src_icon, *dest_icon, *src_fi, *dest_fi, *filename, *apply_all;
char *tmp;
const char *disp_size;
// return default operation if the user has set it
if (data->default_opt)
return data->default_opt;
if (data->timer)
g_timer_stop (data->timer);
gtk_builder_set_translation_domain (builder, GETTEXT_PACKAGE);
ensure_dlg (data);
gtk_builder_add_from_string (builder, RENAME_DLG, -1, NULL);
dlg = (GtkWidget*)gtk_builder_get_object (builder, "dlg");
src_icon = (GtkWidget*)gtk_builder_get_object (builder, "src_icon");
src_fi = (GtkWidget*)gtk_builder_get_object (builder, "src_fi");
dest_icon = (GtkWidget*)gtk_builder_get_object (builder, "dest_icon");
dest_fi = (GtkWidget*)gtk_builder_get_object (builder, "dest_fi");
filename = (GtkWidget*)gtk_builder_get_object (builder, "filename");
apply_all = (GtkWidget*)gtk_builder_get_object (builder, "apply_all");
gtk_window_set_transient_for (GTK_WINDOW (dlg), (GtkWindow*) data->dlg);
gtk_image_set_from_gicon (GTK_IMAGE (src_icon), fm_file_info_get_gicon (src), GTK_ICON_SIZE_DIALOG);
disp_size = fm_file_info_get_disp_size (src);
if (disp_size)
{
tmp = g_strdup_printf (_("Type: %s\nSize: %s\nModified: %s"),
fm_file_info_get_desc (src),
disp_size,
fm_file_info_get_disp_mtime (src));
}
else
{
tmp = g_strdup_printf (_("Type: %s\nModified: %s"),
fm_file_info_get_desc (src),
fm_file_info_get_disp_mtime (src));
}
gtk_label_set_text (GTK_LABEL (src_fi), tmp);
g_free (tmp);
gtk_image_set_from_gicon (GTK_IMAGE (dest_icon), fm_file_info_get_gicon (src), GTK_ICON_SIZE_DIALOG);
disp_size = fm_file_info_get_disp_size (dest);
if (disp_size)
{
tmp = g_strdup_printf (_("Type: %s\nSize: %s\nModified: %s"),
fm_file_info_get_desc (dest),
fm_file_info_get_disp_size (dest),
fm_file_info_get_disp_mtime (dest));
}
else
{
tmp = g_strdup_printf (_("Type: %s\nModified: %s"),
fm_file_info_get_desc (dest),
fm_file_info_get_disp_mtime (dest));
}
gtk_label_set_text (GTK_LABEL (dest_fi), tmp);
g_free (tmp);
tmp = g_filename_display_name (dest->path->name);
gtk_entry_set_text (GTK_ENTRY (filename), tmp);
g_free (tmp);
g_object_set_data (G_OBJECT (filename), "old_name", dest->disp_name);
g_signal_connect (filename, "changed", (GCallback) on_filename_changed, gtk_builder_get_object (builder, "rename"));
g_object_unref (builder);
res = gtk_dialog_run (GTK_DIALOG (dlg));
switch (res)
{
case RESPONSE_RENAME:
*new_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (filename)));
res = FM_FILE_OP_RENAME;
break;
case RESPONSE_OVERWRITE:
res = FM_FILE_OP_OVERWRITE;
break;
case RESPONSE_SKIP:
res = FM_FILE_OP_SKIP;
break;
default:
res = FM_FILE_OP_CANCEL;
}
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (apply_all)))
{
if (res == RESPONSE_OVERWRITE || res == FM_FILE_OP_SKIP)
data->default_opt = res;
}
gtk_widget_destroy (dlg);
if (data->timer)
g_timer_continue (data->timer);
return res;
}
