diff options
Diffstat (limited to 'src/caja-property-browser.c')
| -rw-r--r-- | src/caja-property-browser.c | 2492 |
1 files changed, 2492 insertions, 0 deletions
diff --git a/src/caja-property-browser.c b/src/caja-property-browser.c new file mode 100644 index 00000000..aa7b29f2 --- /dev/null +++ b/src/caja-property-browser.c @@ -0,0 +1,2492 @@ +/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */ + +/* + * Caja + * + * Copyright (C) 2000 Eazel, Inc. + * + * Caja is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * Caja is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Andy Hertzfeld <[email protected]> + */ + +/* This is the implementation of the property browser window, which + * gives the user access to an extensible palette of properties which + * can be dropped on various elements of the user interface to + * customize them + */ + +#include <config.h> +#include <math.h> +#include "caja-property-browser.h" + +#include <eel/eel-gdk-extensions.h> +#include <eel/eel-gdk-pixbuf-extensions.h> +#include <eel/eel-glib-extensions.h> +#include <eel/eel-mate-extensions.h> +#include <eel/eel-gtk-extensions.h> +#include <eel/eel-gtk-macros.h> +#include <eel/eel-image-table.h> +#include <eel/eel-labeled-image.h> +#include <eel/eel-stock-dialogs.h> +#include <eel/eel-string.h> +#include <eel/eel-vfs-extensions.h> +#include <eel/eel-xml-extensions.h> +#include <libxml/parser.h> +#include <gtk/gtk.h> +#include <glib/gi18n.h> +#include <glib/gstdio.h> +#include <gio/gio.h> +#include <libcaja-private/caja-customization-data.h> +#include <libcaja-private/caja-directory.h> +#include <libcaja-private/caja-emblem-utils.h> +#include <libcaja-private/caja-file-utilities.h> +#include <libcaja-private/caja-file.h> +#include <libcaja-private/caja-global-preferences.h> +#include <libcaja-private/caja-metadata.h> +#include <libcaja-private/caja-signaller.h> +#include <atk/atkrelationset.h> + +/* property types */ + +typedef enum +{ + CAJA_PROPERTY_NONE, + CAJA_PROPERTY_PATTERN, + CAJA_PROPERTY_COLOR, + CAJA_PROPERTY_EMBLEM +} CajaPropertyType; + +struct CajaPropertyBrowserDetails +{ + GtkHBox *container; + + GtkWidget *content_container; + GtkWidget *content_frame; + GtkWidget *content_table; + + GtkWidget *category_container; + GtkWidget *category_box; + + GtkWidget *title_box; + GtkWidget *title_label; + GtkWidget *help_label; + + GtkWidget *bottom_box; + + GtkWidget *add_button; + GtkWidget *add_button_image; + GtkWidget *remove_button; + GtkWidget *remove_button_image; + + GtkWidget *patterns_dialog; + GtkWidget *colors_dialog; + GtkWidget *emblems_dialog; + + GtkWidget *keyword; + GtkWidget *emblem_image; + GtkWidget *image_button; + + GtkWidget *color_picker; + GtkWidget *color_name; + + GList *keywords; + + char *path; + char *category; + char *dragged_file; + char *drag_type; + char *image_path; + char *filename; + + CajaPropertyType category_type; + + int category_position; + + GdkPixbuf *property_chit; + + gboolean remove_mode; + gboolean keep_around; + gboolean has_local; +}; + +static void caja_property_browser_class_init (GtkObjectClass *object_klass); +static void caja_property_browser_init (GtkObject *object); +static void caja_property_browser_destroy (GtkObject *object); +static void caja_property_browser_update_contents (CajaPropertyBrowser *property_browser); +static void caja_property_browser_set_category (CajaPropertyBrowser *property_browser, + const char *new_category); +static void caja_property_browser_set_dragged_file (CajaPropertyBrowser *property_browser, + const char *dragged_file_name); +static void caja_property_browser_set_drag_type (CajaPropertyBrowser *property_browser, + const char *new_drag_type); +static void add_new_button_callback (GtkWidget *widget, + CajaPropertyBrowser *property_browser); +static void cancel_remove_mode (CajaPropertyBrowser *property_browser); +static void done_button_callback (GtkWidget *widget, + GtkWidget *property_browser); +static void help_button_callback (GtkWidget *widget, + GtkWidget *property_browser); +static void remove_button_callback (GtkWidget *widget, + CajaPropertyBrowser *property_browser); +static gboolean caja_property_browser_delete_event_callback (GtkWidget *widget, + GdkEvent *event, + gpointer user_data); +static void caja_property_browser_hide_callback (GtkWidget *widget, + gpointer user_data); +static void caja_property_browser_drag_end (GtkWidget *widget, + GdkDragContext *context); +static void caja_property_browser_drag_begin (GtkWidget *widget, + GdkDragContext *context); +static void caja_property_browser_drag_data_get (GtkWidget *widget, + GdkDragContext *context, + GtkSelectionData *selection_data, + guint info, + guint32 time); +static void caja_property_browser_theme_changed (gpointer user_data); +static void emit_emblems_changed_signal (void); +static void emblems_changed_callback (GObject *signaller, + CajaPropertyBrowser *property_browser); + +/* misc utilities */ +static void element_clicked_callback (GtkWidget *image_table, + GtkWidget *child, + const EelImageTableEvent *event, + gpointer callback_data); + +static GdkPixbuf * make_drag_image (CajaPropertyBrowser *property_browser, + const char *file_name); +static GdkPixbuf * make_color_drag_image (CajaPropertyBrowser *property_browser, + const char *color_spec, + gboolean trim_edges); + + +#define BROWSER_CATEGORIES_FILE_NAME "browser.xml" + +#define PROPERTY_BROWSER_WIDTH 540 +#define PROPERTY_BROWSER_HEIGHT 340 +#define MAX_EMBLEM_HEIGHT 52 +#define STANDARD_BUTTON_IMAGE_HEIGHT 42 + +#define MAX_ICON_WIDTH 63 +#define MAX_ICON_HEIGHT 63 +#define COLOR_SQUARE_SIZE 48 + +#define LABELED_IMAGE_SPACING 2 +#define IMAGE_TABLE_X_SPACING 6 +#define IMAGE_TABLE_Y_SPACING 4 + +#define ERASE_OBJECT_NAME "erase.png" + +enum +{ + PROPERTY_TYPE +}; + +static GtkTargetEntry drag_types[] = +{ + { "text/uri-list", 0, PROPERTY_TYPE } +}; + + +EEL_CLASS_BOILERPLATE (CajaPropertyBrowser, + caja_property_browser, + GTK_TYPE_WINDOW) + +/* initializing the class object by installing the operations we override */ +static void +caja_property_browser_class_init (GtkObjectClass *object_klass) +{ + CajaPropertyBrowserClass *klass; + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (object_klass); + + klass = CAJA_PROPERTY_BROWSER_CLASS (object_klass); + + object_klass->destroy = caja_property_browser_destroy; + widget_class->drag_begin = caja_property_browser_drag_begin; + widget_class->drag_data_get = caja_property_browser_drag_data_get; + widget_class->drag_end = caja_property_browser_drag_end; +} + +/* initialize the instance's fields, create the necessary subviews, etc. */ + +static void +caja_property_browser_init (GtkObject *object) +{ + CajaPropertyBrowser *property_browser; + GtkWidget *widget, *temp_box, *temp_hbox, *temp_frame, *vbox; + GtkWidget *temp_button; + GtkWidget *viewport; + char *temp_str; + + property_browser = CAJA_PROPERTY_BROWSER (object); + widget = GTK_WIDGET (object); + + property_browser->details = g_new0 (CajaPropertyBrowserDetails, 1); + + property_browser->details->category = g_strdup ("patterns"); + property_browser->details->category_type = CAJA_PROPERTY_PATTERN; + + /* load the chit frame */ + temp_str = caja_pixmap_file ("chit_frame.png"); + if (temp_str != NULL) + { + property_browser->details->property_chit = gdk_pixbuf_new_from_file (temp_str, NULL); + } + g_free (temp_str); + + /* set the initial size of the property browser */ + gtk_window_set_default_size (GTK_WINDOW (property_browser), + PROPERTY_BROWSER_WIDTH, + PROPERTY_BROWSER_HEIGHT); + + /* set the title and standard close accelerator */ + gtk_window_set_title (GTK_WINDOW (widget), _("Backgrounds and Emblems")); + gtk_window_set_wmclass (GTK_WINDOW (widget), "property_browser", "Caja"); + gtk_window_set_type_hint (GTK_WINDOW (widget), GDK_WINDOW_TYPE_HINT_DIALOG); + eel_gtk_window_set_up_close_accelerator (GTK_WINDOW (widget)); + + /* create the main vbox. */ + vbox = gtk_vbox_new (FALSE, 12); + gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); + gtk_widget_show (vbox); + gtk_container_add (GTK_CONTAINER (property_browser), vbox); + + /* create the container box */ + property_browser->details->container = GTK_HBOX (gtk_hbox_new (FALSE, 6)); + gtk_widget_show (GTK_WIDGET (property_browser->details->container)); + gtk_box_pack_start (GTK_BOX (vbox), + GTK_WIDGET (property_browser->details->container), + TRUE, TRUE, 0); + + /* make the category container */ + property_browser->details->category_container = gtk_scrolled_window_new (NULL, NULL); + property_browser->details->category_position = -1; + + viewport = gtk_viewport_new (NULL, NULL); + gtk_widget_show (viewport); + gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE); + + gtk_box_pack_start (GTK_BOX (property_browser->details->container), + property_browser->details->category_container, FALSE, FALSE, 0); + gtk_widget_show (property_browser->details->category_container); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (property_browser->details->category_container), + GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); + + /* allocate a table to hold the category selector */ + property_browser->details->category_box = gtk_vbox_new (FALSE, 6); + gtk_container_add(GTK_CONTAINER(viewport), property_browser->details->category_box); + gtk_container_add (GTK_CONTAINER (property_browser->details->category_container), viewport); + gtk_widget_show (GTK_WIDGET (property_browser->details->category_box)); + + /* make the content container vbox */ + property_browser->details->content_container = gtk_vbox_new (FALSE, 6); + gtk_widget_show (property_browser->details->content_container); + gtk_box_pack_start (GTK_BOX (property_browser->details->container), + property_browser->details->content_container, + TRUE, TRUE, 0); + + /* create the title box */ + property_browser->details->title_box = gtk_event_box_new(); + + gtk_widget_show(property_browser->details->title_box); + gtk_box_pack_start (GTK_BOX(property_browser->details->content_container), + property_browser->details->title_box, + FALSE, FALSE, 0); + + temp_frame = gtk_frame_new(NULL); + gtk_frame_set_shadow_type(GTK_FRAME(temp_frame), GTK_SHADOW_NONE); + gtk_widget_show(temp_frame); + gtk_container_add(GTK_CONTAINER(property_browser->details->title_box), temp_frame); + + temp_hbox = gtk_hbox_new(FALSE, 0); + gtk_widget_show(temp_hbox); + + gtk_container_add(GTK_CONTAINER(temp_frame), temp_hbox); + + /* add the title label */ + property_browser->details->title_label = gtk_label_new (""); + eel_gtk_label_set_scale (GTK_LABEL (property_browser->details->title_label), PANGO_SCALE_X_LARGE); + eel_gtk_label_make_bold (GTK_LABEL (property_browser->details->title_label)); + + gtk_widget_show(property_browser->details->title_label); + gtk_box_pack_start (GTK_BOX(temp_hbox), property_browser->details->title_label, FALSE, FALSE, 0); + + /* add the help label */ + property_browser->details->help_label = gtk_label_new (""); + gtk_widget_show(property_browser->details->help_label); + gtk_box_pack_end (GTK_BOX (temp_hbox), property_browser->details->help_label, FALSE, FALSE, 0); + + /* add the bottom box to hold the command buttons */ + temp_box = gtk_event_box_new(); + gtk_widget_show(temp_box); + + property_browser->details->bottom_box = gtk_hbox_new (FALSE, 6); + gtk_widget_show (property_browser->details->bottom_box); + + gtk_box_pack_end (GTK_BOX (vbox), temp_box, FALSE, FALSE, 0); + gtk_container_add (GTK_CONTAINER (temp_box), property_browser->details->bottom_box); + + /* create the "help" button */ + temp_button = gtk_button_new_from_stock (GTK_STOCK_HELP); + + gtk_widget_show (temp_button); + gtk_box_pack_start (GTK_BOX (property_browser->details->bottom_box), temp_button, FALSE, FALSE, 0); + g_signal_connect_object (temp_button, "clicked", G_CALLBACK (help_button_callback), property_browser, 0); + + /* create the "done" button */ + temp_button = gtk_button_new_from_stock (GTK_STOCK_CLOSE); + gtk_widget_set_can_default (temp_button, TRUE); + + gtk_widget_show (temp_button); + gtk_box_pack_end (GTK_BOX (property_browser->details->bottom_box), temp_button, FALSE, FALSE, 0); + gtk_widget_grab_default (temp_button); + gtk_widget_grab_focus (temp_button); + g_signal_connect_object (temp_button, "clicked", G_CALLBACK (done_button_callback), property_browser, 0); + + /* create the "remove" button */ + property_browser->details->remove_button = gtk_button_new_with_mnemonic (_("_Remove...")); + + property_browser->details->remove_button_image = gtk_image_new_from_stock (GTK_STOCK_REMOVE, GTK_ICON_SIZE_BUTTON); + gtk_button_set_image (GTK_BUTTON (property_browser->details->remove_button), + property_browser->details->remove_button_image); + gtk_widget_show_all (property_browser->details->remove_button); + + gtk_box_pack_end (GTK_BOX (property_browser->details->bottom_box), + property_browser->details->remove_button, FALSE, FALSE, 0); + + g_signal_connect_object (property_browser->details->remove_button, "clicked", + G_CALLBACK (remove_button_callback), property_browser, 0); + + /* now create the "add new" button */ + property_browser->details->add_button = gtk_button_new_with_mnemonic (_("Add new...")); + + property_browser->details->add_button_image = gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON); + gtk_button_set_image (GTK_BUTTON (property_browser->details->add_button), + property_browser->details->add_button_image); + gtk_widget_show_all (property_browser->details->add_button); + + gtk_box_pack_end (GTK_BOX(property_browser->details->bottom_box), + property_browser->details->add_button, FALSE, FALSE, 0); + + g_signal_connect_object (property_browser->details->add_button, "clicked", + G_CALLBACK (add_new_button_callback), property_browser, 0); + + + /* now create the actual content, with the category pane and the content frame */ + + /* the actual contents are created when necessary */ + property_browser->details->content_frame = NULL; + + /* add a callback for when the theme changes */ + eel_preferences_add_callback (CAJA_PREFERENCES_THEME, + caja_property_browser_theme_changed, + property_browser); + + g_signal_connect (property_browser, "delete_event", + G_CALLBACK (caja_property_browser_delete_event_callback), NULL); + g_signal_connect (property_browser, "hide", + G_CALLBACK (caja_property_browser_hide_callback), NULL); + + g_signal_connect_object (caja_signaller_get_current (), + "emblems_changed", + G_CALLBACK (emblems_changed_callback), property_browser, 0); + + /* initially, display the top level */ + caja_property_browser_set_path(property_browser, BROWSER_CATEGORIES_FILE_NAME); +} + +/* Destroy the three dialogs for adding patterns/colors/emblems if any of them + exist. */ +static void +caja_property_browser_destroy_dialogs (CajaPropertyBrowser *property_browser) +{ + if (property_browser->details->patterns_dialog) + { + gtk_widget_destroy (property_browser->details->patterns_dialog); + property_browser->details->patterns_dialog = NULL; + } + if (property_browser->details->colors_dialog) + { + gtk_widget_destroy (property_browser->details->colors_dialog); + property_browser->details->colors_dialog = NULL; + } + if (property_browser->details->emblems_dialog) + { + gtk_widget_destroy (property_browser->details->emblems_dialog); + property_browser->details->emblems_dialog = NULL; + } +} + +static void +caja_property_browser_destroy (GtkObject *object) +{ + CajaPropertyBrowser *property_browser; + + + property_browser = CAJA_PROPERTY_BROWSER (object); + + caja_property_browser_destroy_dialogs (property_browser); + + g_free (property_browser->details->path); + g_free (property_browser->details->category); + g_free (property_browser->details->dragged_file); + g_free (property_browser->details->drag_type); + + eel_g_list_free_deep (property_browser->details->keywords); + + if (property_browser->details->property_chit) + { + g_object_unref (property_browser->details->property_chit); + } + + g_free (property_browser->details); + + eel_preferences_remove_callback (CAJA_PREFERENCES_THEME, + caja_property_browser_theme_changed, + property_browser); + + EEL_CALL_PARENT (GTK_OBJECT_CLASS, destroy, (object)); +} + +/* create a new instance */ +CajaPropertyBrowser * +caja_property_browser_new (GdkScreen *screen) +{ + CajaPropertyBrowser *browser; + + browser = CAJA_PROPERTY_BROWSER + (gtk_widget_new (caja_property_browser_get_type (), NULL)); + + gtk_window_set_screen (GTK_WINDOW (browser), screen); + gtk_widget_show (GTK_WIDGET(browser)); + + return browser; +} + +/* show the main property browser */ + +void +caja_property_browser_show (GdkScreen *screen) +{ + static GtkWindow *browser = NULL; + + if (browser == NULL) + { + browser = GTK_WINDOW (caja_property_browser_new (screen)); + g_object_add_weak_pointer (G_OBJECT (browser), + (gpointer *) &browser); + } + else + { + gtk_window_set_screen (browser, screen); + gtk_window_present (browser); + } +} + +static gboolean +caja_property_browser_delete_event_callback (GtkWidget *widget, + GdkEvent *event, + gpointer user_data) +{ + /* Hide but don't destroy */ + gtk_widget_hide(widget); + return TRUE; +} + +static void +caja_property_browser_hide_callback (GtkWidget *widget, + gpointer user_data) +{ + CajaPropertyBrowser *property_browser; + + property_browser = CAJA_PROPERTY_BROWSER (widget); + + cancel_remove_mode (property_browser); + + /* Destroy the 3 dialogs to add new patterns/colors/emblems. */ + caja_property_browser_destroy_dialogs (property_browser); +} + +/* remember the name of the dragged file */ +static void +caja_property_browser_set_dragged_file (CajaPropertyBrowser *property_browser, + const char *dragged_file_name) +{ + g_free (property_browser->details->dragged_file); + property_browser->details->dragged_file = g_strdup (dragged_file_name); +} + +/* remember the drag type */ +static void +caja_property_browser_set_drag_type (CajaPropertyBrowser *property_browser, + const char *new_drag_type) +{ + g_free (property_browser->details->drag_type); + property_browser->details->drag_type = g_strdup (new_drag_type); +} + +static void +caja_property_browser_drag_begin (GtkWidget *widget, + GdkDragContext *context) +{ + CajaPropertyBrowser *property_browser; + GtkWidget *child; + GdkPixbuf *pixbuf; + int x_delta, y_delta; + char *element_name; + + property_browser = CAJA_PROPERTY_BROWSER (widget); + + child = g_object_steal_data (G_OBJECT (property_browser), "dragged-image"); + g_return_if_fail (child != NULL); + + element_name = g_object_get_data (G_OBJECT (child), "property-name"); + g_return_if_fail (child != NULL); + + /* compute the offsets for dragging */ + if (strcmp (drag_types[0].target, "application/x-color") != 0) + { + /* it's not a color, so, for now, it must be an image */ + /* fiddle with the category to handle the "reset" case properly */ + char * save_category = property_browser->details->category; + if (eel_strcmp (property_browser->details->category, "colors") == 0) + { + property_browser->details->category = "patterns"; + } + pixbuf = make_drag_image (property_browser, element_name); + property_browser->details->category = save_category; + } + else + { + pixbuf = make_color_drag_image (property_browser, element_name, TRUE); + } + + /* set the pixmap and mask for dragging */ + if (pixbuf != NULL) + { + x_delta = gdk_pixbuf_get_width (pixbuf) / 2; + y_delta = gdk_pixbuf_get_height (pixbuf) / 2; + + gtk_drag_set_icon_pixbuf + (context, + pixbuf, + x_delta, y_delta); + g_object_unref (pixbuf); + } + +} + + +/* drag and drop data get handler */ + +static void +caja_property_browser_drag_data_get (GtkWidget *widget, + GdkDragContext *context, + GtkSelectionData *selection_data, + guint info, + guint32 time) +{ + char *image_file_name, *image_file_uri; + gboolean is_reset; + CajaPropertyBrowser *property_browser = CAJA_PROPERTY_BROWSER(widget); + GdkAtom target; + + g_return_if_fail (widget != NULL); + g_return_if_fail (context != NULL); + + target = gtk_selection_data_get_target (selection_data); + + switch (info) + { + case PROPERTY_TYPE: + /* formulate the drag data based on the drag type. Eventually, we will + probably select the behavior from properties in the category xml definition, + but for now we hardwire it to the drag_type */ + + is_reset = FALSE; + if (strcmp (property_browser->details->drag_type, + "property/keyword") == 0) + { + char *keyword_str = eel_filename_strip_extension (property_browser->details->dragged_file); + gtk_selection_data_set (selection_data, target, 8, keyword_str, strlen (keyword_str)); + g_free (keyword_str); + return; + } + else if (strcmp (property_browser->details->drag_type, + "application/x-color") == 0) + { + GdkColor color; + guint16 colorArray[4]; + + /* handle the "reset" case as an image */ + if (eel_strcmp (property_browser->details->dragged_file, RESET_IMAGE_NAME) != 0) + { + gdk_color_parse (property_browser->details->dragged_file, &color); + + colorArray[0] = color.red; + colorArray[1] = color.green; + colorArray[2] = color.blue; + colorArray[3] = 0xffff; + + gtk_selection_data_set(selection_data, + target, 16, (const char *) &colorArray[0], 8); + return; + } + else + { + is_reset = TRUE; + } + + } + + image_file_name = g_strdup_printf ("%s/%s/%s", + CAJA_DATADIR, + is_reset ? "patterns" : property_browser->details->category, + property_browser->details->dragged_file); + + if (!g_file_test (image_file_name, G_FILE_TEST_EXISTS)) + { + char *user_directory; + g_free (image_file_name); + + user_directory = caja_get_user_directory (); + image_file_name = g_strdup_printf ("%s/%s/%s", + user_directory, + property_browser->details->category, + property_browser->details->dragged_file); + + g_free (user_directory); + } + + image_file_uri = g_filename_to_uri (image_file_name, NULL, NULL); + gtk_selection_data_set (selection_data, target, 8, image_file_uri, strlen (image_file_uri)); + g_free (image_file_name); + g_free (image_file_uri); + + break; + default: + g_assert_not_reached (); + } +} + +/* drag and drop end handler, where we destroy ourselves, since the transaction is complete */ + +static void +caja_property_browser_drag_end (GtkWidget *widget, GdkDragContext *context) +{ + CajaPropertyBrowser *property_browser = CAJA_PROPERTY_BROWSER(widget); + if (!property_browser->details->keep_around) + { + gtk_widget_hide (GTK_WIDGET (widget)); + } +} + +/* utility routine to check if the passed-in uri is an image file */ +static gboolean +ensure_file_is_image (GFile *file) +{ + GFileInfo *info; + const char *mime_type; + gboolean ret; + + info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE, 0, NULL, NULL); + if (info == NULL) + { + return FALSE; + } + + mime_type = g_file_info_get_content_type (info); + if (mime_type == NULL) + { + return FALSE; + } + + ret = (g_content_type_is_a (mime_type, "image/*") && + !g_content_type_equals (mime_type, "image/svg") && + !g_content_type_equals (mime_type, "image/svg+xml")); + + g_object_unref (info); + + return ret; +} + +/* create the appropriate pixbuf for the passed in file */ + +static GdkPixbuf * +make_drag_image (CajaPropertyBrowser *property_browser, const char* file_name) +{ + GdkPixbuf *pixbuf, *orig_pixbuf; + char *image_file_name; + char *icon_name; + gboolean is_reset; + CajaIconInfo *info; + + if (property_browser->details->category_type == CAJA_PROPERTY_EMBLEM) + { + if (strcmp (file_name, "erase") == 0) + { + pixbuf = NULL; + + image_file_name = caja_pixmap_file (ERASE_OBJECT_NAME); + if (image_file_name != NULL) + { + pixbuf = gdk_pixbuf_new_from_file (image_file_name, NULL); + } + g_free (image_file_name); + } + else + { + icon_name = caja_emblem_get_icon_name_from_keyword (file_name); + info = caja_icon_info_lookup_from_name (icon_name, CAJA_ICON_SIZE_STANDARD); + pixbuf = caja_icon_info_get_pixbuf_at_size (info, CAJA_ICON_SIZE_STANDARD); + g_object_unref (info); + g_free (icon_name); + } + return pixbuf; + } + + image_file_name = g_strdup_printf ("%s/%s/%s", + CAJA_DATADIR, + property_browser->details->category, + file_name); + + if (!g_file_test (image_file_name, G_FILE_TEST_EXISTS)) + { + char *user_directory; + g_free (image_file_name); + + user_directory = caja_get_user_directory (); + + image_file_name = g_strdup_printf ("%s/%s/%s", + user_directory, + property_browser->details->category, + file_name); + + g_free (user_directory); + } + + orig_pixbuf = gdk_pixbuf_new_from_file_at_scale (image_file_name, + MAX_ICON_WIDTH, MAX_ICON_HEIGHT, + TRUE, + NULL); + + g_free (image_file_name); + + if (orig_pixbuf == NULL) + { + return NULL; + } + + is_reset = eel_strcmp (file_name, RESET_IMAGE_NAME) == 0; + + if (strcmp (property_browser->details->category, "patterns") == 0 && + property_browser->details->property_chit != NULL) + { + pixbuf = caja_customization_make_pattern_chit (orig_pixbuf, property_browser->details->property_chit, TRUE, is_reset); + } + else + { + pixbuf = eel_gdk_pixbuf_scale_down_to_fit (orig_pixbuf, MAX_ICON_WIDTH, MAX_ICON_HEIGHT); + } + + g_object_unref (orig_pixbuf); + + return pixbuf; +} + + +/* create a pixbuf and fill it with a color */ + +static GdkPixbuf* +make_color_drag_image (CajaPropertyBrowser *property_browser, const char *color_spec, gboolean trim_edges) +{ + GdkPixbuf *color_square; + GdkPixbuf *ret; + int row, col, stride; + char *pixels, *row_pixels; + GdkColor color; + + color_square = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, COLOR_SQUARE_SIZE, COLOR_SQUARE_SIZE); + + gdk_color_parse (color_spec, &color); + color.red >>= 8; + color.green >>= 8; + color.blue >>= 8; + + pixels = gdk_pixbuf_get_pixels (color_square); + stride = gdk_pixbuf_get_rowstride (color_square); + + /* loop through and set each pixel */ + for (row = 0; row < COLOR_SQUARE_SIZE; row++) + { + row_pixels = (pixels + (row * stride)); + for (col = 0; col < COLOR_SQUARE_SIZE; col++) + { + *row_pixels++ = color.red; + *row_pixels++ = color.green; + *row_pixels++ = color.blue; + *row_pixels++ = 255; + } + } + + g_assert (color_square != NULL); + + if (property_browser->details->property_chit != NULL) + { + ret = caja_customization_make_pattern_chit (color_square, + property_browser->details->property_chit, + trim_edges, FALSE); + g_object_unref (color_square); + } + else + { + ret = color_square; + } + + return ret; +} + +/* this callback handles button presses on the category widget. It maintains the active state */ + +static void +category_toggled_callback (GtkWidget *widget, char *category_name) +{ + CajaPropertyBrowser *property_browser; + + property_browser = CAJA_PROPERTY_BROWSER (g_object_get_data (G_OBJECT (widget), "user_data")); + + /* exit remove mode when the user switches categories, since there might be nothing to remove + in the new category */ + property_browser->details->remove_mode = FALSE; + + caja_property_browser_set_category (property_browser, category_name); +} + +static xmlDocPtr +read_browser_xml (CajaPropertyBrowser *property_browser) +{ + char *path; + xmlDocPtr document; + + path = caja_get_data_file_path (property_browser->details->path); + if (path == NULL) + { + return NULL; + } + document = xmlParseFile (path); + g_free (path); + return document; +} + +static void +write_browser_xml (CajaPropertyBrowser *property_browser, + xmlDocPtr document) +{ + char *user_directory, *path; + + user_directory = caja_get_user_directory (); + path = g_build_filename (user_directory, property_browser->details->path, NULL); + g_free (user_directory); + xmlSaveFile (path, document); + g_free (path); +} + +static xmlNodePtr +get_color_category (xmlDocPtr document) +{ + return eel_xml_get_root_child_by_name_and_property (document, "category", "name", "colors"); +} + +/* routines to remove specific category types. First, handle colors */ + +static void +remove_color (CajaPropertyBrowser *property_browser, const char* color_name) +{ + /* load the local xml file to remove the color */ + xmlDocPtr document; + xmlNodePtr cur_node, color_node; + gboolean match; + char *name; + + document = read_browser_xml (property_browser); + if (document == NULL) + { + return; + } + + /* find the colors category */ + cur_node = get_color_category (document); + if (cur_node != NULL) + { + /* loop through the colors to find one that matches */ + for (color_node = eel_xml_get_children (cur_node); + color_node != NULL; + color_node = color_node->next) + { + + if (color_node->type != XML_ELEMENT_NODE) + { + continue; + } + + name = xmlGetProp (color_node, "name"); + match = name != NULL + && strcmp (name, color_name) == 0; + xmlFree (name); + + if (match) + { + xmlUnlinkNode (color_node); + xmlFreeNode (color_node); + write_browser_xml (property_browser, document); + break; + } + } + } + + xmlFreeDoc (document); +} + +/* remove the pattern matching the passed in name */ + +static void +remove_pattern(CajaPropertyBrowser *property_browser, const char* pattern_name) +{ + char *pattern_path; + char *user_directory; + + user_directory = caja_get_user_directory (); + + /* build the pathname of the pattern */ + pattern_path = g_build_filename (user_directory, + "patterns", + pattern_name, + NULL); + g_free (user_directory); + + /* delete the pattern from the pattern directory */ + if (g_unlink (pattern_path) != 0) + { + char *message = g_strdup_printf (_("Sorry, but pattern %s could not be deleted."), pattern_name); + char *detail = _("Check that you have permission to delete the pattern."); + eel_show_error_dialog (message, detail, GTK_WINDOW (property_browser)); + g_free (message); + } + + g_free (pattern_path); +} + +/* remove the emblem matching the passed in name */ + +static void +remove_emblem (CajaPropertyBrowser *property_browser, const char* emblem_name) +{ + /* delete the emblem from the emblem directory */ + if (caja_emblem_remove_emblem (emblem_name) == FALSE) + { + char *message = g_strdup_printf (_("Sorry, but emblem %s could not be deleted."), emblem_name); + char *detail = _("Check that you have permission to delete the emblem."); + eel_show_error_dialog (message, detail, GTK_WINDOW (property_browser)); + g_free (message); + } + else + { + emit_emblems_changed_signal (); + } +} + +/* handle removing the passed in element */ + +static void +caja_property_browser_remove_element (CajaPropertyBrowser *property_browser, EelLabeledImage *child) +{ + const char *element_name; + char *color_name; + + element_name = g_object_get_data (G_OBJECT (child), "property-name"); + + /* lookup category and get mode, then case out and handle the modes */ + switch (property_browser->details->category_type) + { + case CAJA_PROPERTY_PATTERN: + remove_pattern (property_browser, element_name); + break; + case CAJA_PROPERTY_COLOR: + color_name = eel_labeled_image_get_text (child); + remove_color (property_browser, color_name); + g_free (color_name); + break; + case CAJA_PROPERTY_EMBLEM: + remove_emblem (property_browser, element_name); + break; + default: + break; + } +} + +static void +update_preview_cb (GtkFileChooser *fc, + GtkImage *preview) +{ + char *filename; + GdkPixbuf *pixbuf; + + filename = gtk_file_chooser_get_preview_filename (fc); + if (filename) + { + pixbuf = gdk_pixbuf_new_from_file (filename, NULL); + + gtk_file_chooser_set_preview_widget_active (fc, pixbuf != NULL); + + if (pixbuf) + { + gtk_image_set_from_pixbuf (preview, pixbuf); + g_object_unref (pixbuf); + } + + g_free (filename); + } +} + +static void +icon_button_clicked_cb (GtkButton *b, + CajaPropertyBrowser *browser) +{ + GtkWidget *dialog; + GtkFileFilter *filter; + GtkWidget *preview; + int res; + + dialog = gtk_file_chooser_dialog_new (_("Select an Image File for the New Emblem"), + GTK_WINDOW (browser), + GTK_FILE_CHOOSER_ACTION_OPEN, + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, + NULL); + gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), + DATADIR "/pixmaps"); + filter = gtk_file_filter_new (); + gtk_file_filter_add_pixbuf_formats (filter); + gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter); + + preview = gtk_image_new (); + gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (dialog), + preview); + g_signal_connect (dialog, "update-preview", + G_CALLBACK (update_preview_cb), preview); + + res = gtk_dialog_run (GTK_DIALOG (dialog)); + + if (res == GTK_RESPONSE_ACCEPT) + { + /* update the image */ + g_free (browser->details->filename); + browser->details->filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); + gtk_image_set_from_file (GTK_IMAGE (browser->details->image_button), browser->details->filename); + } + + gtk_widget_destroy (dialog); +} + +/* here's where we create the emblem dialog */ +static GtkWidget* +caja_emblem_dialog_new (CajaPropertyBrowser *property_browser) +{ + GtkWidget *widget; + GtkWidget *button; + GtkWidget *dialog; + GtkWidget *label; + GtkWidget *table = gtk_table_new(2, 2, FALSE); + + dialog = gtk_dialog_new_with_buttons (_("Create a New Emblem"), + GTK_WINDOW (property_browser), 0, + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + GTK_STOCK_OK, GTK_RESPONSE_OK, + NULL); + + /* install the table in the dialog */ + gtk_container_set_border_width (GTK_CONTAINER (table), 5); + gtk_table_set_row_spacings (GTK_TABLE (table), 6); + gtk_table_set_col_spacings (GTK_TABLE (table), 12); + gtk_widget_show (table); + + gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE); + gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); + gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), 2); + gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE); + gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); + gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), table, TRUE, TRUE, 0); + gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_OK); + + /* make the keyword label and field */ + + widget = gtk_label_new_with_mnemonic(_("_Keyword:")); + gtk_misc_set_alignment (GTK_MISC (widget), 0, 0.5); + gtk_widget_show(widget); + gtk_table_attach(GTK_TABLE(table), widget, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); + + property_browser->details->keyword = gtk_entry_new (); + gtk_entry_set_activates_default (GTK_ENTRY (property_browser->details->keyword), TRUE); + gtk_entry_set_max_length (GTK_ENTRY (property_browser->details->keyword), 24); + gtk_widget_show(property_browser->details->keyword); + gtk_table_attach(GTK_TABLE(table), property_browser->details->keyword, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0); + gtk_widget_grab_focus(property_browser->details->keyword); + gtk_label_set_mnemonic_widget (GTK_LABEL (widget), + GTK_WIDGET (property_browser->details->keyword)); + + /* default image is the generic emblem */ + g_free (property_browser->details->image_path); + property_browser->details->image_path = g_build_filename (CAJA_PIXMAPDIR, "emblems.png", NULL); + + /* set up a file chooser to pick the image file */ + label = gtk_label_new_with_mnemonic (_("_Image:")); + gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); + gtk_widget_show (label); + gtk_table_attach (GTK_TABLE(table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); + + widget = gtk_hbox_new (FALSE, 0); + gtk_widget_show (widget); + + button = gtk_button_new (); + property_browser->details->image_button = gtk_image_new_from_file (property_browser->details->image_path); + gtk_button_set_image (GTK_BUTTON (button), property_browser->details->image_button); + g_signal_connect (button, "clicked", G_CALLBACK (icon_button_clicked_cb), + property_browser); + gtk_label_set_mnemonic_widget (GTK_LABEL (label), button); + + gtk_widget_show (button); + gtk_table_attach (GTK_TABLE (table), widget, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0); + gtk_box_pack_start (GTK_BOX (widget), button, FALSE, FALSE, 0); + + return dialog; +} + +/* create the color selection dialog */ + +static GtkWidget* +caja_color_selection_dialog_new (CajaPropertyBrowser *property_browser) +{ + GtkWidget *widget; + GtkWidget *dialog; + GtkWidget *table = gtk_table_new(2, 2, FALSE); + + dialog = gtk_dialog_new_with_buttons (_("Create a New Color:"), + GTK_WINDOW (property_browser), 0, + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + GTK_STOCK_OK, GTK_RESPONSE_OK, + NULL); + + /* install the table in the dialog */ + + gtk_widget_show (table); + gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), table, TRUE, TRUE, 0); + gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_OK); + + /* make the name label and field */ + + widget = gtk_label_new_with_mnemonic(_("Color _name:")); + gtk_widget_show(widget); + gtk_table_attach(GTK_TABLE(table), widget, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); + + property_browser->details->color_name = gtk_entry_new (); + gtk_entry_set_activates_default (GTK_ENTRY (property_browser->details->color_name), TRUE); + gtk_entry_set_max_length (GTK_ENTRY (property_browser->details->color_name), 24); + gtk_widget_grab_focus (property_browser->details->color_name); + gtk_label_set_mnemonic_widget (GTK_LABEL (widget), property_browser->details->color_name); + gtk_widget_show(property_browser->details->color_name); + gtk_table_attach(GTK_TABLE(table), property_browser->details->color_name, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0); + gtk_widget_grab_focus(property_browser->details->color_name); + + /* default image is the generic emblem */ + g_free(property_browser->details->image_path); + + widget = gtk_label_new_with_mnemonic(_("Color _value:")); + gtk_widget_show(widget); + gtk_table_attach(GTK_TABLE(table), widget, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); + + property_browser->details->color_picker = gtk_color_button_new (); + gtk_widget_show (property_browser->details->color_picker); + gtk_label_set_mnemonic_widget (GTK_LABEL (widget), property_browser->details->color_picker); + + gtk_table_attach(GTK_TABLE(table), property_browser->details->color_picker, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0); + + return dialog; +} + +/* add the newly selected file to the browser images */ +static void +add_pattern_to_browser (GtkDialog *dialog, gint response_id, gpointer *data) +{ + char *directory_path, *destination_name; + char *basename; + char *user_directory; + GFile *dest, *selected; + + CajaPropertyBrowser *property_browser = CAJA_PROPERTY_BROWSER (data); + + if (response_id != GTK_RESPONSE_ACCEPT) + { + gtk_widget_hide (GTK_WIDGET (dialog)); + return; + } + + selected = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog)); + + /* don't allow the user to change the reset image */ + basename = g_file_get_basename (selected); + if (basename && eel_strcmp (basename, RESET_IMAGE_NAME) == 0) + { + eel_show_error_dialog (_("Sorry, but you cannot replace the reset image."), + _("Reset is a special image that cannot be deleted."), + NULL); + g_object_unref (selected); + g_free (basename); + return; + } + + + user_directory = caja_get_user_directory (); + + /* copy the image file to the patterns directory */ + directory_path = g_build_filename (user_directory, "patterns", NULL); + g_free (user_directory); + destination_name = g_build_filename (directory_path, basename, NULL); + + /* make the directory if it doesn't exist */ + if (!g_file_test (directory_path, G_FILE_TEST_EXISTS)) + { + g_mkdir_with_parents (directory_path, 0775); + } + + dest = g_file_new_for_path (destination_name); + + g_free (destination_name); + g_free (directory_path); + + if (!g_file_copy (selected, dest, + 0, + NULL, NULL, NULL, NULL)) + { + char *message = g_strdup_printf (_("Sorry, but the pattern %s could not be installed."), basename); + eel_show_error_dialog (message, NULL, GTK_WINDOW (property_browser)); + g_free (message); + } + g_object_unref (selected); + g_object_unref (dest); + g_free (basename); + + + /* update the property browser's contents to show the new one */ + caja_property_browser_update_contents (property_browser); + + gtk_widget_hide (GTK_WIDGET (dialog)); +} + +/* here's where we initiate adding a new pattern by putting up a file selector */ + +static void +add_new_pattern (CajaPropertyBrowser *property_browser) +{ + GtkWidget *dialog; + GtkFileFilter *filter; + GtkWidget *preview; + + if (property_browser->details->patterns_dialog) + { + gtk_window_present (GTK_WINDOW (property_browser->details->patterns_dialog)); + } + else + { + property_browser->details->patterns_dialog = dialog = + gtk_file_chooser_dialog_new (_("Select an Image File to Add as a Pattern"), + GTK_WINDOW (property_browser), + GTK_FILE_CHOOSER_ACTION_OPEN, + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, + NULL); + gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), + DATADIR "/caja/patterns/"); + filter = gtk_file_filter_new (); + gtk_file_filter_add_pixbuf_formats (filter); + gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog), filter); + + gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (dialog), FALSE); + + preview = gtk_image_new (); + gtk_file_chooser_set_preview_widget (GTK_FILE_CHOOSER (dialog), + preview); + g_signal_connect (dialog, "update-preview", + G_CALLBACK (update_preview_cb), preview); + + g_signal_connect (dialog, "response", + G_CALLBACK (add_pattern_to_browser), + property_browser); + + gtk_widget_show (GTK_WIDGET (dialog)); + + if (property_browser->details->patterns_dialog) + eel_add_weak_pointer (&property_browser->details->patterns_dialog); + } +} + +/* here's where we add the passed in color to the file that defines the colors */ + +static void +add_color_to_file (CajaPropertyBrowser *property_browser, const char *color_spec, const char *color_name) +{ + xmlNodePtr cur_node, new_color_node, children_node; + xmlDocPtr document; + xmlChar *child_color_name; + gboolean color_name_exists = FALSE; + + document = read_browser_xml (property_browser); + if (document == NULL) + { + return; + } + + /* find the colors category */ + cur_node = get_color_category (document); + if (cur_node != NULL) + { + /* check if theres already a color whith that name */ + children_node = cur_node->xmlChildrenNode; + while (children_node != NULL) + { + child_color_name = xmlGetProp (children_node, "name"); + if (xmlStrcmp (color_name, child_color_name) == 0) + { + color_name_exists = TRUE; + xmlFree (child_color_name); + break; + } + xmlFree (child_color_name); + + children_node = children_node->next; + } + + /* add a new color node */ + if (!color_name_exists) + { + new_color_node = xmlNewChild (cur_node, NULL, "color", NULL); + xmlNodeSetContent (new_color_node, color_spec); + xmlSetProp (new_color_node, "local", "1"); + xmlSetProp (new_color_node, "name", color_name); + + write_browser_xml (property_browser, document); + } + else + { + eel_show_error_dialog (_("The color cannot be installed."), + _("Sorry, but you must specify an unused color name for the new color."), + GTK_WINDOW (property_browser)); + } + } + + xmlFreeDoc (document); +} + +/* handle the OK button being pushed on the color selection dialog */ +static void +add_color_to_browser (GtkWidget *widget, gint which_button, gpointer *data) +{ + char * color_spec; + const char *color_name; + char *stripped_color_name; + + CajaPropertyBrowser *property_browser = CAJA_PROPERTY_BROWSER (data); + + if (which_button == GTK_RESPONSE_OK) + { + GdkColor color; + + gtk_color_button_get_color (GTK_COLOR_BUTTON (property_browser->details->color_picker), &color); + color_spec = gdk_color_to_string (&color); + + color_name = gtk_entry_get_text (GTK_ENTRY (property_browser->details->color_name)); + stripped_color_name = g_strstrip (g_strdup (color_name)); + if (strlen (stripped_color_name) == 0) + { + eel_show_error_dialog (_("The color cannot be installed."), + _("Sorry, but you must specify a non-blank name for the new color."), + GTK_WINDOW (property_browser)); + + } + else + { + add_color_to_file (property_browser, color_spec, stripped_color_name); + caja_property_browser_update_contents(property_browser); + } + g_free (stripped_color_name); + g_free (color_spec); + } + + gtk_widget_destroy(property_browser->details->colors_dialog); + property_browser->details->colors_dialog = NULL; +} + +/* create the color selection dialog, pre-set with the color that was just selected */ +static void +show_color_selection_window (GtkWidget *widget, gpointer *data) +{ + GdkColor color; + CajaPropertyBrowser *property_browser = CAJA_PROPERTY_BROWSER(data); + + gtk_color_selection_get_current_color (GTK_COLOR_SELECTION + (gtk_color_selection_dialog_get_color_selection (GTK_COLOR_SELECTION_DIALOG (property_browser->details->colors_dialog))), + &color); + gtk_widget_destroy (property_browser->details->colors_dialog); + + /* allocate a new color selection dialog */ + property_browser->details->colors_dialog = caja_color_selection_dialog_new (property_browser); + + /* set the color to the one picked by the selector */ + gtk_color_button_set_color (GTK_COLOR_BUTTON (property_browser->details->color_picker), &color); + + /* connect the signals to the new dialog */ + + eel_add_weak_pointer (&property_browser->details->colors_dialog); + + g_signal_connect_object (property_browser->details->colors_dialog, "response", + G_CALLBACK (add_color_to_browser), property_browser, 0); + gtk_window_set_position (GTK_WINDOW (property_browser->details->colors_dialog), GTK_WIN_POS_MOUSE); + gtk_widget_show (GTK_WIDGET(property_browser->details->colors_dialog)); +} + + +/* here's the routine to add a new color, by putting up a color selector */ + +static void +add_new_color (CajaPropertyBrowser *property_browser) +{ + if (property_browser->details->colors_dialog) + { + gtk_window_present (GTK_WINDOW (property_browser->details->colors_dialog)); + } + else + { + GtkColorSelectionDialog *color_dialog; + GtkWidget *ok_button, *cancel_button, *help_button; + + property_browser->details->colors_dialog = gtk_color_selection_dialog_new (_("Select a Color to Add")); + color_dialog = GTK_COLOR_SELECTION_DIALOG (property_browser->details->colors_dialog); + + eel_add_weak_pointer (&property_browser->details->colors_dialog); + + g_object_get (color_dialog, "ok-button", &ok_button, + "cancel-button", &cancel_button, + "help-button", &help_button, NULL); + + g_signal_connect_object (ok_button, "clicked", + G_CALLBACK (show_color_selection_window), property_browser, 0); + g_signal_connect_object (cancel_button, "clicked", + G_CALLBACK (gtk_widget_destroy), color_dialog, G_CONNECT_SWAPPED); + gtk_widget_hide (help_button); + + gtk_window_set_position (GTK_WINDOW (color_dialog), GTK_WIN_POS_MOUSE); + gtk_widget_show (GTK_WIDGET(color_dialog)); + } +} + +/* here's where we handle clicks in the emblem dialog buttons */ +static void +emblem_dialog_clicked (GtkWidget *dialog, int which_button, CajaPropertyBrowser *property_browser) +{ + const char *new_keyword; + char *stripped_keyword; + char *emblem_path; + GFile *emblem_file; + GdkPixbuf *pixbuf; + + if (which_button == GTK_RESPONSE_OK) + { + + /* update the image path from the file entry */ + if (property_browser->details->filename) + { + emblem_path = property_browser->details->filename; + emblem_file = g_file_new_for_path (emblem_path); + if (ensure_file_is_image (emblem_file)) + { + g_free (property_browser->details->image_path); + property_browser->details->image_path = emblem_path; + } + else + { + char *message = g_strdup_printf + (_("Sorry, but \"%s\" is not a usable image file."), emblem_path); + eel_show_error_dialog (_("The file is not an image."), message, GTK_WINDOW (property_browser)); + g_free (message); + g_free (emblem_path); + emblem_path = NULL; + g_object_unref (emblem_file); + return; + } + g_object_unref (emblem_file); + } + + emblem_file = g_file_new_for_path (property_browser->details->image_path); + pixbuf = caja_emblem_load_pixbuf_for_emblem (emblem_file); + g_object_unref (emblem_file); + + if (pixbuf == NULL) + { + char *message = g_strdup_printf + (_("Sorry, but \"%s\" is not a usable image file."), property_browser->details->image_path); + eel_show_error_dialog (_("The file is not an image."), message, GTK_WINDOW (property_browser)); + g_free (message); + } + + new_keyword = gtk_entry_get_text(GTK_ENTRY(property_browser->details->keyword)); + if (new_keyword == NULL) + { + stripped_keyword = NULL; + } + else + { + stripped_keyword = g_strstrip (g_strdup (new_keyword)); + } + + + caja_emblem_install_custom_emblem (pixbuf, + stripped_keyword, + stripped_keyword, + GTK_WINDOW (property_browser)); + if (pixbuf != NULL) + g_object_unref (pixbuf); + + caja_emblem_refresh_list (); + + emit_emblems_changed_signal (); + + g_free (stripped_keyword); + } + + gtk_widget_destroy (dialog); + + property_browser->details->keyword = NULL; + property_browser->details->emblem_image = NULL; + property_browser->details->filename = NULL; +} + +/* here's the routine to add a new emblem, by putting up an emblem dialog */ + +static void +add_new_emblem (CajaPropertyBrowser *property_browser) +{ + if (property_browser->details->emblems_dialog) + { + gtk_window_present (GTK_WINDOW (property_browser->details->emblems_dialog)); + } + else + { + property_browser->details->emblems_dialog = caja_emblem_dialog_new (property_browser); + + eel_add_weak_pointer (&property_browser->details->emblems_dialog); + + g_signal_connect_object (property_browser->details->emblems_dialog, "response", + G_CALLBACK (emblem_dialog_clicked), property_browser, 0); + gtk_window_set_position (GTK_WINDOW (property_browser->details->emblems_dialog), GTK_WIN_POS_MOUSE); + gtk_widget_show (GTK_WIDGET(property_browser->details->emblems_dialog)); + } +} + +/* cancelremove mode */ +static void +cancel_remove_mode (CajaPropertyBrowser *property_browser) +{ + if (property_browser->details->remove_mode) + { + property_browser->details->remove_mode = FALSE; + caja_property_browser_update_contents(property_browser); + gtk_widget_show (property_browser->details->help_label); + } +} + +/* handle the add_new button */ + +static void +add_new_button_callback(GtkWidget *widget, CajaPropertyBrowser *property_browser) +{ + /* handle remove mode, where we act as a cancel button */ + if (property_browser->details->remove_mode) + { + cancel_remove_mode (property_browser); + return; + } + + switch (property_browser->details->category_type) + { + case CAJA_PROPERTY_PATTERN: + add_new_pattern (property_browser); + break; + case CAJA_PROPERTY_COLOR: + add_new_color (property_browser); + break; + case CAJA_PROPERTY_EMBLEM: + add_new_emblem (property_browser); + break; + default: + break; + } +} + +/* handle the "done" button */ +static void +done_button_callback (GtkWidget *widget, GtkWidget *property_browser) +{ + cancel_remove_mode (CAJA_PROPERTY_BROWSER (property_browser)); + gtk_widget_hide (property_browser); +} + +/* handle the "help" button */ +static void +help_button_callback (GtkWidget *widget, GtkWidget *property_browser) +{ + GError *error = NULL; + GtkWidget *dialog; + + gtk_show_uri (gtk_widget_get_screen (property_browser), + "ghelp:user-guide#goscaja-50", + gtk_get_current_event_time (), &error); + + if (error) + { + dialog = gtk_message_dialog_new (GTK_WINDOW (property_browser), + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_OK, + _("There was an error displaying help: \n%s"), + error->message); + + g_signal_connect (G_OBJECT (dialog), + "response", G_CALLBACK (gtk_widget_destroy), + NULL); + gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); + gtk_widget_show (dialog); + g_error_free (error); + } +} + +/* handle the "remove" button */ +static void +remove_button_callback(GtkWidget *widget, CajaPropertyBrowser *property_browser) +{ + if (property_browser->details->remove_mode) + { + return; + } + + property_browser->details->remove_mode = TRUE; + gtk_widget_hide (property_browser->details->help_label); + caja_property_browser_update_contents(property_browser); +} + +/* this callback handles clicks on the image or color based content content elements */ + +static void +element_clicked_callback (GtkWidget *image_table, + GtkWidget *child, + const EelImageTableEvent *event, + gpointer callback_data) +{ + CajaPropertyBrowser *property_browser; + GtkTargetList *target_list; + GdkDragContext *context; + const char *element_name; + GdkDragAction action; + + g_return_if_fail (EEL_IS_IMAGE_TABLE (image_table)); + g_return_if_fail (EEL_IS_LABELED_IMAGE (child)); + g_return_if_fail (event != NULL); + g_return_if_fail (CAJA_IS_PROPERTY_BROWSER (callback_data)); + g_return_if_fail (g_object_get_data (G_OBJECT (child), "property-name") != NULL); + + element_name = g_object_get_data (G_OBJECT (child), "property-name"); + property_browser = CAJA_PROPERTY_BROWSER (callback_data); + + /* handle remove mode by removing the element */ + if (property_browser->details->remove_mode) + { + caja_property_browser_remove_element (property_browser, EEL_LABELED_IMAGE (child)); + property_browser->details->remove_mode = FALSE; + caja_property_browser_update_contents (property_browser); + gtk_widget_show (property_browser->details->help_label); + return; + } + + /* set up the drag and drop type corresponding to the category */ + drag_types[0].target = property_browser->details->drag_type; + + /* treat the reset property in the colors section specially */ + if (eel_strcmp (element_name, RESET_IMAGE_NAME) == 0) + { + drag_types[0].target = "x-special/mate-reset-background"; + } + + target_list = gtk_target_list_new (drag_types, G_N_ELEMENTS (drag_types)); + caja_property_browser_set_dragged_file(property_browser, element_name); + action = event->button == 3 ? GDK_ACTION_ASK : GDK_ACTION_MOVE | GDK_ACTION_COPY; + + g_object_set_data (G_OBJECT (property_browser), "dragged-image", child); + + context = gtk_drag_begin (GTK_WIDGET (property_browser), + target_list, + GDK_ACTION_ASK | GDK_ACTION_MOVE | GDK_ACTION_COPY, + event->button, + event->event); + gtk_target_list_unref (target_list); + + /* optionally (if the shift key is down) hide the property browser - it will later be destroyed when the drag ends */ + property_browser->details->keep_around = (event->state & GDK_SHIFT_MASK) == 0; + if (! property_browser->details->keep_around) + { + gtk_widget_hide (GTK_WIDGET (property_browser)); + } +} + +static void +labeled_image_configure (EelLabeledImage *labeled_image) +{ + g_return_if_fail (EEL_IS_LABELED_IMAGE (labeled_image)); + + eel_labeled_image_set_spacing (labeled_image, LABELED_IMAGE_SPACING); +} + +/* Make a color tile for a property */ +static GtkWidget * +labeled_image_new (const char *text, + GdkPixbuf *pixbuf, + const char *property_name, + double scale_factor) +{ + GtkWidget *labeled_image; + + labeled_image = eel_labeled_image_new (text, pixbuf); + labeled_image_configure (EEL_LABELED_IMAGE (labeled_image)); + + if (property_name != NULL) + { + g_object_set_data_full (G_OBJECT (labeled_image), + "property-name", + g_strdup (property_name), + g_free); + } + + return labeled_image; +} + +static void +make_properties_from_directories (CajaPropertyBrowser *property_browser) +{ + CajaCustomizationData *customization_data; + char *object_name; + char *object_label; + GdkPixbuf *object_pixbuf; + EelImageTable *image_table; + GtkWidget *reset_object = NULL; + GList *icons, *l; + char *icon_name; + char *keyword; + GtkWidget *property_image; + GtkWidget *blank; + guint num_images; + char *path; + CajaIconInfo *info; + + g_return_if_fail (CAJA_IS_PROPERTY_BROWSER (property_browser)); + g_return_if_fail (EEL_IS_IMAGE_TABLE (property_browser->details->content_table)); + + image_table = EEL_IMAGE_TABLE (property_browser->details->content_table); + + if (property_browser->details->category_type == CAJA_PROPERTY_EMBLEM) + { + eel_g_list_free_deep (property_browser->details->keywords); + property_browser->details->keywords = NULL; + + icons = caja_emblem_list_available (); + + property_browser->details->has_local = FALSE; + l = icons; + while (l != NULL) + { + icon_name = (char *)l->data; + l = l->next; + + if (!caja_emblem_should_show_in_list (icon_name)) + { + continue; + } + + object_name = caja_emblem_get_keyword_from_icon_name (icon_name); + if (caja_emblem_can_remove_emblem (object_name)) + { + property_browser->details->has_local = TRUE; + } + else if (property_browser->details->remove_mode) + { + g_free (object_name); + continue; + } + info = caja_icon_info_lookup_from_name (icon_name, CAJA_ICON_SIZE_STANDARD); + object_pixbuf = caja_icon_info_get_pixbuf_at_size (info, CAJA_ICON_SIZE_STANDARD); + object_label = g_strdup (caja_icon_info_get_display_name (info)); + g_object_unref (info); + + if (object_label == NULL) + { + object_label = g_strdup (object_name); + } + + property_image = labeled_image_new (object_label, object_pixbuf, object_name, PANGO_SCALE_LARGE); + eel_labeled_image_set_fixed_image_height (EEL_LABELED_IMAGE (property_image), MAX_EMBLEM_HEIGHT); + + keyword = eel_filename_strip_extension (object_name); + property_browser->details->keywords = g_list_prepend (property_browser->details->keywords, + keyword); + + gtk_container_add (GTK_CONTAINER (image_table), property_image); + gtk_widget_show (property_image); + + g_free (object_name); + g_free (object_label); + if (object_pixbuf != NULL) + { + g_object_unref (object_pixbuf); + } + } + eel_g_list_free_deep (icons); + } + else + { + customization_data = caja_customization_data_new (property_browser->details->category, + !property_browser->details->remove_mode, + MAX_ICON_WIDTH, + MAX_ICON_HEIGHT); + if (customization_data == NULL) + { + return; + } + + /* interate through the set of objects and display each */ + while (caja_customization_data_get_next_element_for_display (customization_data, + &object_name, + &object_pixbuf, + &object_label)) + { + + property_image = labeled_image_new (object_label, object_pixbuf, object_name, PANGO_SCALE_LARGE); + + gtk_container_add (GTK_CONTAINER (image_table), property_image); + gtk_widget_show (property_image); + + /* Keep track of ERASE objects to place them prominently later */ + if (property_browser->details->category_type == CAJA_PROPERTY_PATTERN + && !eel_strcmp (object_name, RESET_IMAGE_NAME)) + { + g_assert (reset_object == NULL); + reset_object = property_image; + } + + gtk_widget_show (property_image); + + g_free (object_name); + g_free (object_label); + if (object_pixbuf != NULL) + { + g_object_unref (object_pixbuf); + } + } + + property_browser->details->has_local = caja_customization_data_private_data_was_displayed (customization_data); + caja_customization_data_destroy (customization_data); + } + + /* + * We place ERASE objects (for emblems) at the end with a blank in between. + */ + if (property_browser->details->category_type == CAJA_PROPERTY_EMBLEM) + { + blank = eel_image_table_add_empty_image (image_table); + labeled_image_configure (EEL_LABELED_IMAGE (blank)); + + + num_images = eel_wrap_table_get_num_children (EEL_WRAP_TABLE (image_table)); + g_assert (num_images > 0); + eel_wrap_table_reorder_child (EEL_WRAP_TABLE (image_table), + blank, + num_images - 1); + + gtk_widget_show (blank); + + object_pixbuf = NULL; + + path = caja_pixmap_file (ERASE_OBJECT_NAME); + if (path != NULL) + { + object_pixbuf = gdk_pixbuf_new_from_file (path, NULL); + } + g_free (path); + property_image = labeled_image_new (_("Erase"), object_pixbuf, "erase", PANGO_SCALE_LARGE); + eel_labeled_image_set_fixed_image_height (EEL_LABELED_IMAGE (property_image), MAX_EMBLEM_HEIGHT); + + gtk_container_add (GTK_CONTAINER (image_table), property_image); + gtk_widget_show (property_image); + + eel_wrap_table_reorder_child (EEL_WRAP_TABLE (image_table), + property_image, -1); + + if (object_pixbuf != NULL) + { + g_object_unref (object_pixbuf); + } + } + + /* + * We place RESET objects (for colors and patterns) at the beginning. + */ + if (reset_object != NULL) + { + g_assert (EEL_IS_LABELED_IMAGE (reset_object)); + eel_wrap_table_reorder_child (EEL_WRAP_TABLE (image_table), + reset_object, + 0); + } + +} + +/* utility routine to add a reset property in the first position */ +static void +add_reset_property (CajaPropertyBrowser *property_browser) +{ + char *reset_image_file_name; + GtkWidget *reset_image; + GdkPixbuf *reset_pixbuf, *reset_chit; + + reset_chit = NULL; + + reset_image_file_name = g_strdup_printf ("%s/%s/%s", CAJA_DATADIR, "patterns", RESET_IMAGE_NAME); + reset_pixbuf = gdk_pixbuf_new_from_file (reset_image_file_name, NULL); + if (reset_pixbuf != NULL && property_browser->details->property_chit != NULL) + { + reset_chit = caja_customization_make_pattern_chit (reset_pixbuf, property_browser->details->property_chit, FALSE, TRUE); + } + + g_free (reset_image_file_name); + + reset_image = labeled_image_new (_("Reset"), reset_chit != NULL ? reset_chit : reset_pixbuf, RESET_IMAGE_NAME, PANGO_SCALE_MEDIUM); + gtk_container_add (GTK_CONTAINER (property_browser->details->content_table), reset_image); + eel_wrap_table_reorder_child (EEL_WRAP_TABLE (property_browser->details->content_table), + reset_image, + 0); + gtk_widget_show (reset_image); + + if (reset_pixbuf != NULL) + { + g_object_unref (reset_pixbuf); + } + + if (reset_chit != NULL) + { + g_object_unref (reset_chit); + } +} + +/* generate properties from the children of the passed in node */ +/* for now, we just handle color nodes */ + +static void +make_properties_from_xml_node (CajaPropertyBrowser *property_browser, + xmlNodePtr node) +{ + xmlNodePtr child_node; + GdkPixbuf *pixbuf; + GtkWidget *new_property; + char *deleted, *local, *color, *name; + + gboolean local_only = property_browser->details->remove_mode; + + /* add a reset property in the first slot */ + if (!property_browser->details->remove_mode) + { + add_reset_property (property_browser); + } + + property_browser->details->has_local = FALSE; + + for (child_node = eel_xml_get_children (node); + child_node != NULL; + child_node = child_node->next) + { + + if (child_node->type != XML_ELEMENT_NODE) + { + continue; + } + + /* We used to mark colors that were removed with the "deleted" attribute. + * To prevent these colors from suddenly showing up now, this legacy remains. + */ + deleted = xmlGetProp (child_node, "deleted"); + local = xmlGetProp (child_node, "local"); + + if (deleted == NULL && (!local_only || local != NULL)) + { + if (local != NULL) + { + property_browser->details->has_local = TRUE; + } + + color = xmlNodeGetContent (child_node); + name = eel_xml_get_property_translated (child_node, "name"); + + /* make the image from the color spec */ + pixbuf = make_color_drag_image (property_browser, color, FALSE); + + /* make the tile from the pixmap and name */ + new_property = labeled_image_new (name, pixbuf, color, PANGO_SCALE_LARGE); + + gtk_container_add (GTK_CONTAINER (property_browser->details->content_table), new_property); + gtk_widget_show (new_property); + + g_object_unref (pixbuf); + xmlFree (color); + xmlFree (name); + } + + xmlFree (local); + xmlFree (deleted); + } +} + +/* handle theme changes by updating the browser contents */ + +static void +caja_property_browser_theme_changed (gpointer user_data) +{ + CajaPropertyBrowser *property_browser; + + property_browser = CAJA_PROPERTY_BROWSER(user_data); + caja_property_browser_update_contents (property_browser); +} + +/* make_category generates widgets corresponding all of the objects in the passed in directory */ +static void +make_category(CajaPropertyBrowser *property_browser, const char* path, const char* mode, xmlNodePtr node, const char *description) +{ + + /* set up the description in the help label */ + gtk_label_set_text (GTK_LABEL (property_browser->details->help_label), description); + + /* case out on the mode */ + if (strcmp (mode, "directory") == 0) + make_properties_from_directories (property_browser); + else if (strcmp (mode, "inline") == 0) + make_properties_from_xml_node (property_browser, node); + +} + +/* Create a category button */ +static GtkWidget * +property_browser_category_button_new (const char *display_name, + const char *image) +{ + GtkWidget *button; + char *file_name; + + g_return_val_if_fail (display_name != NULL, NULL); + g_return_val_if_fail (image != NULL, NULL); + + file_name = caja_pixmap_file (image); + if (file_name != NULL) + { + button = eel_labeled_image_radio_button_new_from_file_name (display_name, file_name); + } + else + { + button = eel_labeled_image_radio_button_new (display_name, NULL); + } + + gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE); + + /* We also want all of the buttons to be the same height */ + eel_labeled_image_set_fixed_image_height (EEL_LABELED_IMAGE (gtk_bin_get_child (GTK_BIN (button))), STANDARD_BUTTON_IMAGE_HEIGHT); + + g_free (file_name); + + return button; +} + +/* this is a utility routine to generate a category link widget and install it in the browser */ +static void +make_category_link (CajaPropertyBrowser *property_browser, + const char *name, + const char *display_name, + const char *image, + GtkRadioButton **group) +{ + GtkWidget *button; + + g_return_if_fail (name != NULL); + g_return_if_fail (image != NULL); + g_return_if_fail (display_name != NULL); + g_return_if_fail (CAJA_IS_PROPERTY_BROWSER (property_browser)); + + button = property_browser_category_button_new (display_name, image); + gtk_widget_show (button); + + if (*group) + { + gtk_radio_button_set_group (GTK_RADIO_BUTTON (button), + gtk_radio_button_get_group (*group)); + } + else + { + *group = GTK_RADIO_BUTTON (button); + } + + /* if the button represents the current category, highlight it */ + if (property_browser->details->category && + strcmp (property_browser->details->category, name) == 0) + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); + + /* Place it in the category box */ + gtk_box_pack_start (GTK_BOX (property_browser->details->category_box), + button, FALSE, FALSE, 0); + + property_browser->details->category_position += 1; + + /* add a signal to handle clicks */ + g_object_set_data (G_OBJECT(button), "user_data", property_browser); + g_signal_connect_data + (button, "toggled", + G_CALLBACK (category_toggled_callback), + g_strdup (name), (GClosureNotify) g_free, 0); +} + +/* update_contents populates the property browser with information specified by the path and other state variables */ +void +caja_property_browser_update_contents (CajaPropertyBrowser *property_browser) +{ + xmlNodePtr cur_node; + xmlDocPtr document; + GtkWidget *viewport; + GtkRadioButton *group; + gboolean got_categories; + char *name, *image, *type, *description, *display_name, *path, *mode; + const char *text; + + /* load the xml document corresponding to the path and selection */ + document = read_browser_xml (property_browser); + if (document == NULL) + { + return; + } + + /* remove the existing content box, if any, and allocate a new one */ + if (property_browser->details->content_frame) + { + gtk_widget_destroy(property_browser->details->content_frame); + } + + /* allocate a new container, with a scrollwindow and viewport */ + property_browser->details->content_frame = gtk_scrolled_window_new (NULL, NULL); + viewport = gtk_viewport_new (NULL, NULL); + gtk_widget_show(viewport); + gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_IN); + gtk_container_add (GTK_CONTAINER (property_browser->details->content_container), property_browser->details->content_frame); + gtk_widget_show (property_browser->details->content_frame); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (property_browser->details->content_frame), + GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); + + /* allocate a table to hold the content widgets */ + property_browser->details->content_table = eel_image_table_new (TRUE); + eel_wrap_table_set_x_spacing (EEL_WRAP_TABLE (property_browser->details->content_table), + IMAGE_TABLE_X_SPACING); + eel_wrap_table_set_y_spacing (EEL_WRAP_TABLE (property_browser->details->content_table), + IMAGE_TABLE_Y_SPACING); + + g_signal_connect_object (property_browser->details->content_table, "child_pressed", + G_CALLBACK (element_clicked_callback), property_browser, 0); + + gtk_container_add(GTK_CONTAINER(viewport), property_browser->details->content_table); + gtk_container_add (GTK_CONTAINER (property_browser->details->content_frame), viewport); + gtk_widget_show (GTK_WIDGET (property_browser->details->content_table)); + + /* iterate through the xml file to generate the widgets */ + got_categories = property_browser->details->category_position >= 0; + if (!got_categories) + { + property_browser->details->category_position = 0; + } + + group = NULL; + for (cur_node = eel_xml_get_children (xmlDocGetRootElement (document)); + cur_node != NULL; + cur_node = cur_node->next) + { + + if (cur_node->type != XML_ELEMENT_NODE) + { + continue; + } + + if (strcmp (cur_node->name, "category") == 0) + { + name = xmlGetProp (cur_node, "name"); + + if (property_browser->details->category != NULL + && strcmp (property_browser->details->category, name) == 0) + { + path = xmlGetProp (cur_node, "path"); + mode = xmlGetProp (cur_node, "mode"); + description = eel_xml_get_property_translated (cur_node, "description"); + type = xmlGetProp (cur_node, "type"); + + make_category (property_browser, + path, + mode, + cur_node, + description); + caja_property_browser_set_drag_type (property_browser, type); + + xmlFree (path); + xmlFree (mode); + xmlFree (description); + xmlFree (type); + } + + if (!got_categories) + { + display_name = eel_xml_get_property_translated (cur_node, "display_name"); + image = xmlGetProp (cur_node, "image"); + + make_category_link (property_browser, + name, + display_name, + image, + &group); + + xmlFree (display_name); + xmlFree (image); + } + + xmlFree (name); + } + } + + /* release the xml document and we're done */ + xmlFreeDoc (document); + + /* update the title and button */ + + if (property_browser->details->category == NULL) + { + gtk_label_set_text (GTK_LABEL (property_browser->details->title_label), _("Select a Category:")); + gtk_widget_hide(property_browser->details->add_button); + gtk_widget_hide(property_browser->details->remove_button); + + } + else + { + char *label_text; + char *stock_id; + if (property_browser->details->remove_mode) + { + stock_id = GTK_STOCK_CANCEL; + text = _("C_ancel Remove"); + } + else + { + stock_id = GTK_STOCK_ADD; + /* FIXME: Using spaces to add padding is not good design. */ + switch (property_browser->details->category_type) + { + case CAJA_PROPERTY_PATTERN: + text = _("_Add a New Pattern..."); + break; + case CAJA_PROPERTY_COLOR: + text = _("_Add a New Color..."); + break; + case CAJA_PROPERTY_EMBLEM: + text = _("_Add a New Emblem..."); + break; + default: + text = NULL; + break; + } + } + + /* enable the "add new" button and update it's name and icon */ + gtk_image_set_from_stock (GTK_IMAGE(property_browser->details->add_button_image), stock_id, + GTK_ICON_SIZE_BUTTON); + + if (text != NULL) + { + gtk_button_set_label (GTK_BUTTON (property_browser->details->add_button), text); + + } + gtk_widget_show (property_browser->details->add_button); + + + if (property_browser->details->remove_mode) + { + + switch (property_browser->details->category_type) + { + case CAJA_PROPERTY_PATTERN: + label_text = g_strdup (_("Click on a pattern to remove it")); + break; + case CAJA_PROPERTY_COLOR: + label_text = g_strdup (_("Click on a color to remove it")); + break; + case CAJA_PROPERTY_EMBLEM: + label_text = g_strdup (_("Click on an emblem to remove it")); + break; + default: + label_text = NULL; + break; + } + } + else + { + switch (property_browser->details->category_type) + { + case CAJA_PROPERTY_PATTERN: + label_text = g_strdup (_("Patterns:")); + break; + case CAJA_PROPERTY_COLOR: + label_text = g_strdup (_("Colors:")); + break; + case CAJA_PROPERTY_EMBLEM: + label_text = g_strdup (_("Emblems:")); + break; + default: + label_text = NULL; + break; + } + } + + if (label_text) + { + gtk_label_set_text_with_mnemonic + (GTK_LABEL (property_browser->details->title_label), label_text); + } + g_free(label_text); + + /* enable the remove button (if necessary) and update its name */ + + /* case out instead of substituting to provide flexibilty for other languages */ + /* FIXME: Using spaces to add padding is not good design. */ + switch (property_browser->details->category_type) + { + case CAJA_PROPERTY_PATTERN: + text = _("_Remove a Pattern..."); + break; + case CAJA_PROPERTY_COLOR: + text = _("_Remove a Color..."); + break; + case CAJA_PROPERTY_EMBLEM: + text = _("_Remove an Emblem..."); + break; + default: + text = NULL; + break; + } + + if (property_browser->details->remove_mode + || !property_browser->details->has_local) + gtk_widget_hide(property_browser->details->remove_button); + else + gtk_widget_show(property_browser->details->remove_button); + if (text != NULL) + { + gtk_button_set_label (GTK_BUTTON (property_browser->details->remove_button), text); + } + } +} + +/* set the category and regenerate contents as necessary */ + +static void +caja_property_browser_set_category (CajaPropertyBrowser *property_browser, + const char *new_category) +{ + /* there's nothing to do if the category is the same as the current one */ + if (eel_strcmp (property_browser->details->category, new_category) == 0) + { + return; + } + + g_free (property_browser->details->category); + property_browser->details->category = g_strdup (new_category); + + /* set up the property type enum */ + if (eel_strcmp (new_category, "patterns") == 0) + { + property_browser->details->category_type = CAJA_PROPERTY_PATTERN; + } + else if (eel_strcmp (new_category, "colors") == 0) + { + property_browser->details->category_type = CAJA_PROPERTY_COLOR; + } + else if (eel_strcmp (new_category, "emblems") == 0) + { + property_browser->details->category_type = CAJA_PROPERTY_EMBLEM; + } + else + { + property_browser->details->category_type = CAJA_PROPERTY_NONE; + } + + /* populate the per-uri box with the info */ + caja_property_browser_update_contents (property_browser); +} + + +/* here is the routine that populates the property browser with the appropriate information + when the path changes */ + +void +caja_property_browser_set_path (CajaPropertyBrowser *property_browser, + const char *new_path) +{ + /* there's nothing to do if the uri is the same as the current one */ + if (eel_strcmp (property_browser->details->path, new_path) == 0) + { + return; + } + + g_free (property_browser->details->path); + property_browser->details->path = g_strdup (new_path); + + /* populate the per-uri box with the info */ + caja_property_browser_update_contents (property_browser); +} + +static void +emblems_changed_callback (GObject *signaller, + CajaPropertyBrowser *property_browser) +{ + caja_property_browser_update_contents (property_browser); +} + + +static void +emit_emblems_changed_signal (void) +{ + g_signal_emit_by_name (caja_signaller_get_current (), "emblems_changed"); +} |