summaryrefslogtreecommitdiff
path: root/libcaja-private/caja-icon-container.c
diff options
context:
space:
mode:
authorPerberos <[email protected]>2011-12-01 22:24:23 -0300
committerPerberos <[email protected]>2011-12-01 22:24:23 -0300
commit0e004c696b0e68b2cff37a4c3315b022a35eaf43 (patch)
tree43261e815529cb9518ed7be37af13b846af8b26b /libcaja-private/caja-icon-container.c
downloadcaja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.bz2
caja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.xz
moving from https://github.com/perberos/mate-desktop-environment
Diffstat (limited to 'libcaja-private/caja-icon-container.c')
-rw-r--r--libcaja-private/caja-icon-container.c10612
1 files changed, 10612 insertions, 0 deletions
diff --git a/libcaja-private/caja-icon-container.c b/libcaja-private/caja-icon-container.c
new file mode 100644
index 00000000..2be07d1e
--- /dev/null
+++ b/libcaja-private/caja-icon-container.c
@@ -0,0 +1,10612 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+
+/* caja-icon-container.c - Icon container widget.
+
+ Copyright (C) 1999, 2000 Free Software Foundation
+ Copyright (C) 2000, 2001 Eazel, Inc.
+ Copyright (C) 2002, 2003 Red Hat, Inc.
+
+ The Mate Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The Mate Library 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the Mate Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+
+ Authors: Ettore Perazzoli <[email protected]>,
+ Darin Adler <[email protected]>
+*/
+
+#include <config.h>
+#include <math.h>
+#include "caja-icon-container.h"
+
+#include "caja-debug-log.h"
+#include "caja-global-preferences.h"
+#include "caja-icon-private.h"
+#include "caja-lib-self-check-functions.h"
+#include "caja-marshal.h"
+#include <atk/atkaction.h>
+#include <eel/eel-accessibility.h>
+#include <eel/eel-background.h>
+#include <eel/eel-vfs-extensions.h>
+#include <eel/eel-gdk-pixbuf-extensions.h>
+#include <eel/eel-mate-extensions.h>
+#include <eel/eel-gtk-extensions.h>
+#include <eel/eel-art-extensions.h>
+#include <eel/eel-editable-label.h>
+#include <eel/eel-marshal.h>
+#include <eel/eel-string.h>
+#include <eel/eel-preferences.h>
+#include <eel/eel-enumeration.h>
+#include <eel/eel-canvas-rect-ellipse.h>
+#include <gdk/gdkkeysyms.h>
+#include <gtk/gtk.h>
+#include <gdk/gdkx.h>
+#include <glib/gi18n.h>
+#include <stdio.h>
+#include <string.h>
+
+#define TAB_NAVIGATION_DISABLED
+
+/* Interval for updating the rubberband selection, in milliseconds. */
+#define RUBBERBAND_TIMEOUT_INTERVAL 10
+
+/* Initial unpositioned icon value */
+#define ICON_UNPOSITIONED_VALUE -1
+
+/* Timeout for making the icon currently selected for keyboard operation visible.
+ * If this is 0, you can get into trouble with extra scrolling after holding
+ * down the arrow key for awhile when there are many items.
+ */
+#define KEYBOARD_ICON_REVEAL_TIMEOUT 10
+
+#define CONTEXT_MENU_TIMEOUT_INTERVAL 500
+
+/* Maximum amount of milliseconds the mouse button is allowed to stay down
+ * and still be considered a click.
+ */
+#define MAX_CLICK_TIME 1500
+
+/* Button assignments. */
+#define DRAG_BUTTON 1
+#define RUBBERBAND_BUTTON 1
+#define MIDDLE_BUTTON 2
+#define CONTEXTUAL_MENU_BUTTON 3
+#define DRAG_MENU_BUTTON 2
+
+/* Maximum size (pixels) allowed for icons at the standard zoom level. */
+#define MINIMUM_IMAGE_SIZE 24
+#define MAXIMUM_IMAGE_SIZE 96
+
+#define ICON_PAD_LEFT 4
+#define ICON_PAD_RIGHT 4
+#define ICON_BASE_WIDTH 96
+
+#define ICON_PAD_TOP 4
+#define ICON_PAD_BOTTOM 4
+
+#define CONTAINER_PAD_LEFT 4
+#define CONTAINER_PAD_RIGHT 4
+#define CONTAINER_PAD_TOP 4
+#define CONTAINER_PAD_BOTTOM 4
+
+#define STANDARD_ICON_GRID_WIDTH 155
+
+#define TEXT_BESIDE_ICON_GRID_WIDTH 205
+
+/* Desktop layout mode defines */
+#define DESKTOP_PAD_HORIZONTAL 10
+#define DESKTOP_PAD_VERTICAL 10
+#define SNAP_SIZE_X 78
+#define SNAP_SIZE_Y 20
+
+#define DEFAULT_SELECTION_BOX_ALPHA 0x40
+#define DEFAULT_HIGHLIGHT_ALPHA 0xff
+#define DEFAULT_NORMAL_ALPHA 0xff
+#define DEFAULT_PRELIGHT_ALPHA 0xff
+#define DEFAULT_LIGHT_INFO_COLOR 0xAAAAFD
+#define DEFAULT_DARK_INFO_COLOR 0x33337F
+
+#define DEFAULT_NORMAL_ICON_RENDER_MODE 0
+#define DEFAULT_PRELIGHT_ICON_RENDER_MODE 1
+#define DEFAULT_NORMAL_ICON_SATURATION 255
+#define DEFAULT_PRELIGHT_ICON_SATURATION 255
+#define DEFAULT_NORMAL_ICON_BRIGHTNESS 255
+#define DEFAULT_PRELIGHT_ICON_BRIGHTNESS 255
+#define DEFAULT_NORMAL_ICON_LIGHTEN 0
+#define DEFAULT_PRELIGHT_ICON_LIGHTEN 0
+
+#define MINIMUM_EMBEDDED_TEXT_RECT_WIDTH 20
+#define MINIMUM_EMBEDDED_TEXT_RECT_HEIGHT 20
+
+/* If icon size is bigger than this, request large embedded text.
+ * Its selected so that the non-large text should fit in "normal" icon sizes
+ */
+#define ICON_SIZE_FOR_LARGE_EMBEDDED_TEXT 55
+
+/* From caja-icon-canvas-item.c */
+#define MAX_TEXT_WIDTH_BESIDE 90
+
+#define SNAP_HORIZONTAL(func,x) ((func ((double)((x) - DESKTOP_PAD_HORIZONTAL) / SNAP_SIZE_X) * SNAP_SIZE_X) + DESKTOP_PAD_HORIZONTAL)
+#define SNAP_VERTICAL(func, y) ((func ((double)((y) - DESKTOP_PAD_VERTICAL) / SNAP_SIZE_Y) * SNAP_SIZE_Y) + DESKTOP_PAD_VERTICAL)
+
+#define SNAP_NEAREST_HORIZONTAL(x) SNAP_HORIZONTAL (eel_round, x)
+#define SNAP_NEAREST_VERTICAL(y) SNAP_VERTICAL (eel_round, y)
+
+#define SNAP_CEIL_HORIZONTAL(x) SNAP_HORIZONTAL (ceil, x)
+#define SNAP_CEIL_VERTICAL(y) SNAP_VERTICAL (ceil, y)
+
+/* Copied from CajaIconContainer */
+#define CAJA_ICON_CONTAINER_SEARCH_DIALOG_TIMEOUT 5
+
+/* Copied from CajaFile */
+#define UNDEFINED_TIME ((time_t) (-1))
+
+enum
+{
+ ACTION_ACTIVATE,
+ ACTION_MENU,
+ LAST_ACTION
+};
+
+typedef struct
+{
+ GList *selection;
+ char *action_descriptions[LAST_ACTION];
+} CajaIconContainerAccessiblePrivate;
+
+static GType caja_icon_container_accessible_get_type (void);
+
+static void activate_selected_items (CajaIconContainer *container);
+static void activate_selected_items_alternate (CajaIconContainer *container,
+ CajaIcon *icon);
+static void caja_icon_container_theme_changed (gpointer user_data);
+static void compute_stretch (StretchState *start,
+ StretchState *current);
+static CajaIcon *get_first_selected_icon (CajaIconContainer *container);
+static CajaIcon *get_nth_selected_icon (CajaIconContainer *container,
+ int index);
+static gboolean has_multiple_selection (CajaIconContainer *container);
+static gboolean all_selected (CajaIconContainer *container);
+static gboolean has_selection (CajaIconContainer *container);
+static void icon_destroy (CajaIconContainer *container,
+ CajaIcon *icon);
+static void end_renaming_mode (CajaIconContainer *container,
+ gboolean commit);
+static CajaIcon *get_icon_being_renamed (CajaIconContainer *container);
+static void finish_adding_new_icons (CajaIconContainer *container);
+static void update_label_color (EelBackground *background,
+ CajaIconContainer *icon_container);
+static inline void icon_get_bounding_box (CajaIcon *icon,
+ int *x1_return,
+ int *y1_return,
+ int *x2_return,
+ int *y2_return,
+ CajaIconCanvasItemBoundsUsage usage);
+static gboolean is_renaming (CajaIconContainer *container);
+static gboolean is_renaming_pending (CajaIconContainer *container);
+static void process_pending_icon_to_rename (CajaIconContainer *container);
+static void setup_label_gcs (CajaIconContainer *container);
+static void caja_icon_container_stop_monitor_top_left (CajaIconContainer *container,
+ CajaIconData *data,
+ gconstpointer client);
+static void caja_icon_container_start_monitor_top_left (CajaIconContainer *container,
+ CajaIconData *data,
+ gconstpointer client,
+ gboolean large_text);
+static void handle_hadjustment_changed (GtkAdjustment *adjustment,
+ CajaIconContainer *container);
+static void handle_vadjustment_changed (GtkAdjustment *adjustment,
+ CajaIconContainer *container);
+static GList * caja_icon_container_get_selected_icons (CajaIconContainer *container);
+static void caja_icon_container_update_visible_icons (CajaIconContainer *container);
+static void reveal_icon (CajaIconContainer *container,
+ CajaIcon *icon);
+
+static void caja_icon_container_set_rtl_positions (CajaIconContainer *container);
+static double get_mirror_x_position (CajaIconContainer *container,
+ CajaIcon *icon,
+ double x);
+
+static int compare_icons_horizontal (CajaIconContainer *container,
+ CajaIcon *icon_a,
+ CajaIcon *icon_b);
+
+static int compare_icons_vertical (CajaIconContainer *container,
+ CajaIcon *icon_a,
+ CajaIcon *icon_b);
+
+static void store_layout_timestamps_now (CajaIconContainer *container);
+
+static gpointer accessible_parent_class;
+
+static GQuark accessible_private_data_quark = 0;
+
+static const char *caja_icon_container_accessible_action_names[] =
+{
+ "activate",
+ "menu",
+ NULL
+};
+
+static const char *caja_icon_container_accessible_action_descriptions[] =
+{
+ "Activate selected items",
+ "Popup context menu",
+ NULL
+};
+
+G_DEFINE_TYPE (CajaIconContainer, caja_icon_container, EEL_TYPE_CANVAS);
+
+/* The CajaIconContainer signals. */
+enum
+{
+ ACTIVATE,
+ ACTIVATE_ALTERNATE,
+ BAND_SELECT_STARTED,
+ BAND_SELECT_ENDED,
+ BUTTON_PRESS,
+ CAN_ACCEPT_ITEM,
+ CONTEXT_CLICK_BACKGROUND,
+ CONTEXT_CLICK_SELECTION,
+ MIDDLE_CLICK,
+ GET_CONTAINER_URI,
+ GET_ICON_URI,
+ GET_ICON_DROP_TARGET_URI,
+ GET_STORED_ICON_POSITION,
+ ICON_POSITION_CHANGED,
+ GET_STORED_LAYOUT_TIMESTAMP,
+ STORE_LAYOUT_TIMESTAMP,
+ ICON_TEXT_CHANGED,
+ ICON_STRETCH_STARTED,
+ ICON_STRETCH_ENDED,
+ RENAMING_ICON,
+ LAYOUT_CHANGED,
+ MOVE_COPY_ITEMS,
+ HANDLE_NETSCAPE_URL,
+ HANDLE_URI_LIST,
+ HANDLE_TEXT,
+ HANDLE_RAW,
+ PREVIEW,
+ SELECTION_CHANGED,
+ ICON_ADDED,
+ ICON_REMOVED,
+ CLEARED,
+ START_INTERACTIVE_SEARCH,
+ LAST_SIGNAL
+};
+
+typedef struct
+{
+ int **icon_grid;
+ int *grid_memory;
+ int num_rows;
+ int num_columns;
+ gboolean tight;
+} PlacementGrid;
+
+static guint signals[LAST_SIGNAL];
+
+/* Functions dealing with CajaIcons. */
+
+static void
+icon_free (CajaIcon *icon)
+{
+ /* Destroy this canvas item; the parent will unref it. */
+ gtk_object_destroy (GTK_OBJECT (icon->item));
+ g_free (icon);
+}
+
+static gboolean
+icon_is_positioned (const CajaIcon *icon)
+{
+ return icon->x != ICON_UNPOSITIONED_VALUE && icon->y != ICON_UNPOSITIONED_VALUE;
+}
+
+
+/* x, y are the top-left coordinates of the icon. */
+static void
+icon_set_position (CajaIcon *icon,
+ double x, double y)
+{
+ CajaIconContainer *container;
+ double pixels_per_unit;
+ int container_left, container_top, container_right, container_bottom;
+ int x1, x2, y1, y2;
+ int container_x, container_y, container_width, container_height;
+ EelDRect icon_bounds;
+ int item_width, item_height;
+ int height_above, height_below, width_left, width_right;
+ int min_x, max_x, min_y, max_y;
+
+ if (icon->x == x && icon->y == y)
+ {
+ return;
+ }
+
+ container = CAJA_ICON_CONTAINER (EEL_CANVAS_ITEM (icon->item)->canvas);
+
+ if (icon == get_icon_being_renamed (container))
+ {
+ end_renaming_mode (container, TRUE);
+ }
+
+ if (caja_icon_container_get_is_fixed_size (container))
+ {
+ /* FIXME: This should be:
+
+ container_x = GTK_WIDGET (container)->allocation.x;
+ container_y = GTK_WIDGET (container)->allocation.y;
+ container_width = GTK_WIDGET (container)->allocation.width;
+ container_height = GTK_WIDGET (container)->allocation.height;
+
+ But for some reason the widget allocation is sometimes not done
+ at startup, and the allocation is then only 45x60. which is
+ really bad.
+
+ For now, we have a cheesy workaround:
+ */
+ container_x = 0;
+ container_y = 0;
+ container_width = gdk_screen_width () - container_x
+ - container->details->left_margin
+ - container->details->right_margin;
+ container_height = gdk_screen_height () - container_y
+ - container->details->top_margin
+ - container->details->bottom_margin;
+ pixels_per_unit = EEL_CANVAS (container)->pixels_per_unit;
+ /* Clip the position of the icon within our desktop bounds */
+ container_left = container_x / pixels_per_unit;
+ container_top = container_y / pixels_per_unit;
+ container_right = container_left + container_width / pixels_per_unit;
+ container_bottom = container_top + container_height / pixels_per_unit;
+
+ icon_get_bounding_box (icon, &x1, &y1, &x2, &y2,
+ BOUNDS_USAGE_FOR_ENTIRE_ITEM);
+ item_width = x2 - x1;
+ item_height = y2 - y1;
+
+ icon_bounds = caja_icon_canvas_item_get_icon_rectangle (icon->item);
+
+ /* determine icon rectangle relative to item rectangle */
+ height_above = icon_bounds.y0 - y1;
+ height_below = y2 - icon_bounds.y1;
+ width_left = icon_bounds.x0 - x1;
+ width_right = x2 - icon_bounds.x1;
+
+ min_x = container_left + DESKTOP_PAD_HORIZONTAL + width_left;
+ max_x = container_right - DESKTOP_PAD_HORIZONTAL - item_width + width_left;
+ x = CLAMP (x, min_x, max_x);
+
+ min_y = container_top + height_above + DESKTOP_PAD_VERTICAL;
+ max_y = container_bottom - DESKTOP_PAD_VERTICAL - item_height + height_above;
+ y = CLAMP (y, min_y, max_y);
+ }
+
+ if (icon->x == ICON_UNPOSITIONED_VALUE)
+ {
+ icon->x = 0;
+ }
+ if (icon->y == ICON_UNPOSITIONED_VALUE)
+ {
+ icon->y = 0;
+ }
+
+ eel_canvas_item_move (EEL_CANVAS_ITEM (icon->item),
+ x - icon->x,
+ y - icon->y);
+
+ icon->x = x;
+ icon->y = y;
+}
+
+static void
+icon_get_size (CajaIconContainer *container,
+ CajaIcon *icon,
+ guint *size)
+{
+ if (size != NULL)
+ {
+ *size = MAX (caja_get_icon_size_for_zoom_level (container->details->zoom_level)
+ * icon->scale, CAJA_ICON_SIZE_SMALLEST);
+ }
+}
+
+/* The icon_set_size function is used by the stretching user
+ * interface, which currently stretches in a way that keeps the aspect
+ * ratio. Later we might have a stretching interface that stretches Y
+ * separate from X and we will change this around.
+ */
+static void
+icon_set_size (CajaIconContainer *container,
+ CajaIcon *icon,
+ guint icon_size,
+ gboolean snap,
+ gboolean update_position)
+{
+ guint old_size;
+ double scale;
+
+ icon_get_size (container, icon, &old_size);
+ if (icon_size == old_size)
+ {
+ return;
+ }
+
+ scale = (double) icon_size /
+ caja_get_icon_size_for_zoom_level
+ (container->details->zoom_level);
+ caja_icon_container_move_icon (container, icon,
+ icon->x, icon->y,
+ scale, FALSE,
+ snap, update_position);
+}
+
+static void
+icon_raise (CajaIcon *icon)
+{
+ EelCanvasItem *item, *band;
+
+ item = EEL_CANVAS_ITEM (icon->item);
+ band = CAJA_ICON_CONTAINER (item->canvas)->details->rubberband_info.selection_rectangle;
+
+ eel_canvas_item_send_behind (item, band);
+}
+
+static void
+emit_stretch_started (CajaIconContainer *container, CajaIcon *icon)
+{
+ g_signal_emit (container,
+ signals[ICON_STRETCH_STARTED], 0,
+ icon->data);
+}
+
+static void
+emit_stretch_ended (CajaIconContainer *container, CajaIcon *icon)
+{
+ g_signal_emit (container,
+ signals[ICON_STRETCH_ENDED], 0,
+ icon->data);
+}
+
+static void
+icon_toggle_selected (CajaIconContainer *container,
+ CajaIcon *icon)
+{
+ end_renaming_mode (container, TRUE);
+
+ icon->is_selected = !icon->is_selected;
+ eel_canvas_item_set (EEL_CANVAS_ITEM (icon->item),
+ "highlighted_for_selection", (gboolean) icon->is_selected,
+ NULL);
+
+ /* If the icon is deselected, then get rid of the stretch handles.
+ * No harm in doing the same if the item is newly selected.
+ */
+ if (icon == container->details->stretch_icon)
+ {
+ container->details->stretch_icon = NULL;
+ caja_icon_canvas_item_set_show_stretch_handles (icon->item, FALSE);
+ /* snap the icon if necessary */
+ if (container->details->keep_aligned)
+ {
+ caja_icon_container_move_icon (container,
+ icon,
+ icon->x, icon->y,
+ icon->scale,
+ FALSE, TRUE, TRUE);
+ }
+
+ emit_stretch_ended (container, icon);
+ }
+
+ /* Raise each newly-selected icon to the front as it is selected. */
+ if (icon->is_selected)
+ {
+ icon_raise (icon);
+ }
+}
+
+/* Select an icon. Return TRUE if selection has changed. */
+static gboolean
+icon_set_selected (CajaIconContainer *container,
+ CajaIcon *icon,
+ gboolean select)
+{
+ g_assert (select == FALSE || select == TRUE);
+ g_assert (icon->is_selected == FALSE || icon->is_selected == TRUE);
+
+ if (select == icon->is_selected)
+ {
+ return FALSE;
+ }
+
+ icon_toggle_selected (container, icon);
+ g_assert (select == icon->is_selected);
+ return TRUE;
+}
+
+static inline void
+icon_get_bounding_box (CajaIcon *icon,
+ int *x1_return, int *y1_return,
+ int *x2_return, int *y2_return,
+ CajaIconCanvasItemBoundsUsage usage)
+{
+ double x1, y1, x2, y2;
+
+ if (usage == BOUNDS_USAGE_FOR_DISPLAY)
+ {
+ eel_canvas_item_get_bounds (EEL_CANVAS_ITEM (icon->item),
+ &x1, &y1, &x2, &y2);
+ }
+ else if (usage == BOUNDS_USAGE_FOR_LAYOUT)
+ {
+ caja_icon_canvas_item_get_bounds_for_layout (icon->item,
+ &x1, &y1, &x2, &y2);
+ }
+ else if (usage == BOUNDS_USAGE_FOR_ENTIRE_ITEM)
+ {
+ caja_icon_canvas_item_get_bounds_for_entire_item (icon->item,
+ &x1, &y1, &x2, &y2);
+ }
+ else
+ {
+ g_assert_not_reached ();
+ }
+
+ if (x1_return != NULL)
+ {
+ *x1_return = x1;
+ }
+
+ if (y1_return != NULL)
+ {
+ *y1_return = y1;
+ }
+
+ if (x2_return != NULL)
+ {
+ *x2_return = x2;
+ }
+
+ if (y2_return != NULL)
+ {
+ *y2_return = y2;
+ }
+}
+
+/* Utility functions for CajaIconContainer. */
+
+gboolean
+caja_icon_container_scroll (CajaIconContainer *container,
+ int delta_x, int delta_y)
+{
+ GtkAdjustment *hadj, *vadj;
+ int old_h_value, old_v_value;
+
+ hadj = gtk_layout_get_hadjustment (GTK_LAYOUT (container));
+ vadj = gtk_layout_get_vadjustment (GTK_LAYOUT (container));
+
+ /* Store the old ajustment values so we can tell if we
+ * ended up actually scrolling. We may not have in a case
+ * where the resulting value got pinned to the adjustment
+ * min or max.
+ */
+ old_h_value = gtk_adjustment_get_value (hadj);
+ old_v_value = gtk_adjustment_get_value (vadj);
+
+ eel_gtk_adjustment_set_value (hadj, gtk_adjustment_get_value (hadj) + delta_x);
+ eel_gtk_adjustment_set_value (vadj, gtk_adjustment_get_value (vadj) + delta_y);
+
+ /* return TRUE if we did scroll */
+ return gtk_adjustment_get_value (hadj) != old_h_value || gtk_adjustment_get_value (vadj) != old_v_value;
+}
+
+static void
+pending_icon_to_reveal_destroy_callback (CajaIconCanvasItem *item,
+ CajaIconContainer *container)
+{
+ g_assert (CAJA_IS_ICON_CONTAINER (container));
+ g_assert (container->details->pending_icon_to_reveal != NULL);
+ g_assert (container->details->pending_icon_to_reveal->item == item);
+
+ container->details->pending_icon_to_reveal = NULL;
+}
+
+static CajaIcon*
+get_pending_icon_to_reveal (CajaIconContainer *container)
+{
+ return container->details->pending_icon_to_reveal;
+}
+
+static void
+set_pending_icon_to_reveal (CajaIconContainer *container, CajaIcon *icon)
+{
+ CajaIcon *old_icon;
+
+ old_icon = container->details->pending_icon_to_reveal;
+
+ if (icon == old_icon)
+ {
+ return;
+ }
+
+ if (old_icon != NULL)
+ {
+ g_signal_handlers_disconnect_by_func
+ (old_icon->item,
+ G_CALLBACK (pending_icon_to_reveal_destroy_callback),
+ container);
+ }
+
+ if (icon != NULL)
+ {
+ g_signal_connect (icon->item, "destroy",
+ G_CALLBACK (pending_icon_to_reveal_destroy_callback),
+ container);
+ }
+
+ container->details->pending_icon_to_reveal = icon;
+}
+
+static void
+item_get_canvas_bounds (EelCanvasItem *item,
+ EelIRect *bounds,
+ gboolean safety_pad)
+{
+ EelDRect world_rect;
+
+ eel_canvas_item_get_bounds (item,
+ &world_rect.x0,
+ &world_rect.y0,
+ &world_rect.x1,
+ &world_rect.y1);
+ eel_canvas_item_i2w (item->parent,
+ &world_rect.x0,
+ &world_rect.y0);
+ eel_canvas_item_i2w (item->parent,
+ &world_rect.x1,
+ &world_rect.y1);
+ if (safety_pad)
+ {
+ world_rect.x0 -= ICON_PAD_LEFT + ICON_PAD_RIGHT;
+ world_rect.x1 += ICON_PAD_LEFT + ICON_PAD_RIGHT;
+
+ world_rect.y0 -= ICON_PAD_TOP + ICON_PAD_BOTTOM;
+ world_rect.y1 += ICON_PAD_TOP + ICON_PAD_BOTTOM;
+ }
+
+ eel_canvas_w2c (item->canvas,
+ world_rect.x0,
+ world_rect.y0,
+ &bounds->x0,
+ &bounds->y0);
+ eel_canvas_w2c (item->canvas,
+ world_rect.x1,
+ world_rect.y1,
+ &bounds->x1,
+ &bounds->y1);
+}
+
+static void
+icon_get_row_and_column_bounds (CajaIconContainer *container,
+ CajaIcon *icon,
+ EelIRect *bounds,
+ gboolean safety_pad)
+{
+ GList *p;
+ CajaIcon *one_icon;
+ EelIRect one_bounds;
+
+ item_get_canvas_bounds (EEL_CANVAS_ITEM (icon->item), bounds, safety_pad);
+
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ one_icon = p->data;
+
+ if (icon == one_icon)
+ {
+ continue;
+ }
+
+ if (compare_icons_horizontal (container, icon, one_icon) == 0)
+ {
+ item_get_canvas_bounds (EEL_CANVAS_ITEM (one_icon->item), &one_bounds, safety_pad);
+ bounds->x0 = MIN (bounds->x0, one_bounds.x0);
+ bounds->x1 = MAX (bounds->x1, one_bounds.x1);
+ }
+
+ if (compare_icons_vertical (container, icon, one_icon) == 0)
+ {
+ item_get_canvas_bounds (EEL_CANVAS_ITEM (one_icon->item), &one_bounds, safety_pad);
+ bounds->y0 = MIN (bounds->y0, one_bounds.y0);
+ bounds->y1 = MAX (bounds->y1, one_bounds.y1);
+ }
+ }
+
+
+}
+
+static void
+reveal_icon (CajaIconContainer *container,
+ CajaIcon *icon)
+{
+ CajaIconContainerDetails *details;
+ GtkAllocation allocation;
+ GtkAdjustment *hadj, *vadj;
+ EelIRect bounds;
+
+ if (!icon_is_positioned (icon))
+ {
+ set_pending_icon_to_reveal (container, icon);
+ return;
+ }
+
+ set_pending_icon_to_reveal (container, NULL);
+
+ details = container->details;
+ gtk_widget_get_allocation (GTK_WIDGET (container), &allocation);
+
+ hadj = gtk_layout_get_hadjustment (GTK_LAYOUT (container));
+ vadj = gtk_layout_get_vadjustment (GTK_LAYOUT (container));
+
+ if (caja_icon_container_is_auto_layout (container))
+ {
+ /* ensure that we reveal the entire row/column */
+ icon_get_row_and_column_bounds (container, icon, &bounds, TRUE);
+ }
+ else
+ {
+ item_get_canvas_bounds (EEL_CANVAS_ITEM (icon->item), &bounds, TRUE);
+ }
+ if (bounds.y0 < gtk_adjustment_get_value (vadj))
+ {
+ eel_gtk_adjustment_set_value (vadj, bounds.y0);
+ }
+ else if (bounds.y1 > gtk_adjustment_get_value (vadj) + allocation.height)
+ {
+ eel_gtk_adjustment_set_value
+ (vadj, bounds.y1 - allocation.height);
+ }
+
+ if (bounds.x0 < gtk_adjustment_get_value (hadj))
+ {
+ eel_gtk_adjustment_set_value (hadj, bounds.x0);
+ }
+ else if (bounds.x1 > gtk_adjustment_get_value (hadj) + allocation.width)
+ {
+ eel_gtk_adjustment_set_value
+ (hadj, bounds.x1 - allocation.width);
+ }
+}
+
+static void
+process_pending_icon_to_reveal (CajaIconContainer *container)
+{
+ CajaIcon *pending_icon_to_reveal;
+
+ pending_icon_to_reveal = get_pending_icon_to_reveal (container);
+
+ if (pending_icon_to_reveal != NULL)
+ {
+ reveal_icon (container, pending_icon_to_reveal);
+ }
+}
+
+static gboolean
+keyboard_icon_reveal_timeout_callback (gpointer data)
+{
+ CajaIconContainer *container;
+ CajaIcon *icon;
+
+ container = CAJA_ICON_CONTAINER (data);
+ icon = container->details->keyboard_icon_to_reveal;
+
+ g_assert (icon != NULL);
+
+ /* Only reveal the icon if it's still the keyboard focus or if
+ * it's still selected. Someone originally thought we should
+ * cancel this reveal if the user manages to sneak a direct
+ * scroll in before the timeout fires, but we later realized
+ * this wouldn't actually be an improvement
+ * (see bugzilla.gnome.org 40612).
+ */
+ if (icon == container->details->keyboard_focus
+ || icon->is_selected)
+ {
+ reveal_icon (container, icon);
+ }
+ container->details->keyboard_icon_reveal_timer_id = 0;
+
+ return FALSE;
+}
+
+static void
+unschedule_keyboard_icon_reveal (CajaIconContainer *container)
+{
+ CajaIconContainerDetails *details;
+
+ details = container->details;
+
+ if (details->keyboard_icon_reveal_timer_id != 0)
+ {
+ g_source_remove (details->keyboard_icon_reveal_timer_id);
+ }
+}
+
+static void
+schedule_keyboard_icon_reveal (CajaIconContainer *container,
+ CajaIcon *icon)
+{
+ CajaIconContainerDetails *details;
+
+ details = container->details;
+
+ unschedule_keyboard_icon_reveal (container);
+
+ details->keyboard_icon_to_reveal = icon;
+ details->keyboard_icon_reveal_timer_id
+ = g_timeout_add (KEYBOARD_ICON_REVEAL_TIMEOUT,
+ keyboard_icon_reveal_timeout_callback,
+ container);
+}
+
+static void
+clear_keyboard_focus (CajaIconContainer *container)
+{
+ if (container->details->keyboard_focus != NULL)
+ {
+ eel_canvas_item_set (EEL_CANVAS_ITEM (container->details->keyboard_focus->item),
+ "highlighted_as_keyboard_focus", 0,
+ NULL);
+ }
+
+ container->details->keyboard_focus = NULL;
+}
+
+static void inline
+emit_atk_focus_tracker_notify (CajaIcon *icon)
+{
+ AtkObject *atk_object = eel_accessibility_for_object (icon->item);
+ atk_focus_tracker_notify (atk_object);
+}
+
+/* Set @icon as the icon currently selected for keyboard operations. */
+static void
+set_keyboard_focus (CajaIconContainer *container,
+ CajaIcon *icon)
+{
+ g_assert (icon != NULL);
+
+ if (icon == container->details->keyboard_focus)
+ {
+ return;
+ }
+
+ clear_keyboard_focus (container);
+
+ container->details->keyboard_focus = icon;
+
+ eel_canvas_item_set (EEL_CANVAS_ITEM (container->details->keyboard_focus->item),
+ "highlighted_as_keyboard_focus", 1,
+ NULL);
+
+ emit_atk_focus_tracker_notify (icon);
+}
+
+static void
+set_keyboard_rubberband_start (CajaIconContainer *container,
+ CajaIcon *icon)
+{
+ container->details->keyboard_rubberband_start = icon;
+}
+
+static void
+clear_keyboard_rubberband_start (CajaIconContainer *container)
+{
+ container->details->keyboard_rubberband_start = NULL;
+}
+
+/* carbon-copy of eel_canvas_group_bounds(), but
+ * for CajaIconContainerItems it returns the
+ * bounds for the “entire item”.
+ */
+static void
+get_icon_bounds_for_canvas_bounds (EelCanvasGroup *group,
+ double *x1, double *y1,
+ double *x2, double *y2,
+ CajaIconCanvasItemBoundsUsage usage)
+{
+ EelCanvasItem *child;
+ GList *list;
+ double tx1, ty1, tx2, ty2;
+ double minx, miny, maxx, maxy;
+ int set;
+
+ /* Get the bounds of the first visible item */
+
+ child = NULL; /* Unnecessary but eliminates a warning. */
+
+ set = FALSE;
+
+ for (list = group->item_list; list; list = list->next)
+ {
+ child = list->data;
+
+ if (child->flags & EEL_CANVAS_ITEM_VISIBLE)
+ {
+ set = TRUE;
+ if (!CAJA_IS_ICON_CANVAS_ITEM (child) ||
+ usage == BOUNDS_USAGE_FOR_DISPLAY)
+ {
+ eel_canvas_item_get_bounds (child, &minx, &miny, &maxx, &maxy);
+ }
+ else if (usage == BOUNDS_USAGE_FOR_LAYOUT)
+ {
+ caja_icon_canvas_item_get_bounds_for_layout (CAJA_ICON_CANVAS_ITEM (child),
+ &minx, &miny, &maxx, &maxy);
+ }
+ else if (usage == BOUNDS_USAGE_FOR_ENTIRE_ITEM)
+ {
+ caja_icon_canvas_item_get_bounds_for_entire_item (CAJA_ICON_CANVAS_ITEM (child),
+ &minx, &miny, &maxx, &maxy);
+ }
+ else
+ {
+ g_assert_not_reached ();
+ }
+ break;
+ }
+ }
+
+ /* If there were no visible items, return an empty bounding box */
+
+ if (!set)
+ {
+ *x1 = *y1 = *x2 = *y2 = 0.0;
+ return;
+ }
+
+ /* Now we can grow the bounds using the rest of the items */
+
+ list = list->next;
+
+ for (; list; list = list->next)
+ {
+ child = list->data;
+
+ if (!(child->flags & EEL_CANVAS_ITEM_VISIBLE))
+ continue;
+
+ if (!CAJA_IS_ICON_CANVAS_ITEM (child) ||
+ usage == BOUNDS_USAGE_FOR_DISPLAY)
+ {
+ eel_canvas_item_get_bounds (child, &tx1, &ty1, &tx2, &ty2);
+ }
+ else if (usage == BOUNDS_USAGE_FOR_LAYOUT)
+ {
+ caja_icon_canvas_item_get_bounds_for_layout (CAJA_ICON_CANVAS_ITEM (child),
+ &tx1, &ty1, &tx2, &ty2);
+ }
+ else if (usage == BOUNDS_USAGE_FOR_ENTIRE_ITEM)
+ {
+ caja_icon_canvas_item_get_bounds_for_entire_item (CAJA_ICON_CANVAS_ITEM (child),
+ &tx1, &ty1, &tx2, &ty2);
+ }
+ else
+ {
+ g_assert_not_reached ();
+ }
+
+ if (tx1 < minx)
+ minx = tx1;
+
+ if (ty1 < miny)
+ miny = ty1;
+
+ if (tx2 > maxx)
+ maxx = tx2;
+
+ if (ty2 > maxy)
+ maxy = ty2;
+ }
+
+ /* Make the bounds be relative to our parent's coordinate system */
+
+ if (EEL_CANVAS_ITEM (group)->parent)
+ {
+ minx += group->xpos;
+ miny += group->ypos;
+ maxx += group->xpos;
+ maxy += group->ypos;
+ }
+
+ if (x1 != NULL)
+ {
+ *x1 = minx;
+ }
+
+ if (y1 != NULL)
+ {
+ *y1 = miny;
+ }
+
+ if (x2 != NULL)
+ {
+ *x2 = maxx;
+ }
+
+ if (y2 != NULL)
+ {
+ *y2 = maxy;
+ }
+}
+
+static void
+get_all_icon_bounds (CajaIconContainer *container,
+ double *x1, double *y1,
+ double *x2, double *y2,
+ CajaIconCanvasItemBoundsUsage usage)
+{
+ /* FIXME bugzilla.gnome.org 42477: Do we have to do something about the rubberband
+ * here? Any other non-icon items?
+ */
+ get_icon_bounds_for_canvas_bounds (EEL_CANVAS_GROUP (EEL_CANVAS (container)->root),
+ x1, y1, x2, y2, usage);
+}
+
+/* Don't preserve visible white space the next time the scroll region
+ * is recomputed when the container is not empty. */
+void
+caja_icon_container_reset_scroll_region (CajaIconContainer *container)
+{
+ container->details->reset_scroll_region_trigger = TRUE;
+}
+
+/* Set a new scroll region without eliminating any of the currently-visible area. */
+static void
+canvas_set_scroll_region_include_visible_area (EelCanvas *canvas,
+ double x1, double y1,
+ double x2, double y2)
+{
+ double old_x1, old_y1, old_x2, old_y2;
+ double old_scroll_x, old_scroll_y;
+ double height, width;
+ GtkAllocation allocation;
+
+ eel_canvas_get_scroll_region (canvas, &old_x1, &old_y1, &old_x2, &old_y2);
+ gtk_widget_get_allocation (GTK_WIDGET (canvas), &allocation);
+
+ width = (allocation.width) / canvas->pixels_per_unit;
+ height = (allocation.height) / canvas->pixels_per_unit;
+
+ old_scroll_x = gtk_adjustment_get_value (GTK_ADJUSTMENT (gtk_layout_get_hadjustment (GTK_LAYOUT (canvas))));
+ old_scroll_y = gtk_adjustment_get_value (GTK_ADJUSTMENT (gtk_layout_get_vadjustment (GTK_LAYOUT (canvas))));
+
+ x1 = MIN (x1, old_x1 + old_scroll_x);
+ y1 = MIN (y1, old_y1 + old_scroll_y);
+ x2 = MAX (x2, old_x1 + old_scroll_x + width);
+ y2 = MAX (y2, old_y1 + old_scroll_y + height);
+
+ eel_canvas_set_scroll_region
+ (canvas, x1, y1, x2, y2);
+}
+
+void
+caja_icon_container_update_scroll_region (CajaIconContainer *container)
+{
+ double x1, y1, x2, y2;
+ double pixels_per_unit;
+ GtkAdjustment *hadj, *vadj;
+ float step_increment;
+ gboolean reset_scroll_region;
+ GtkAllocation allocation;
+
+ pixels_per_unit = EEL_CANVAS (container)->pixels_per_unit;
+
+ if (caja_icon_container_get_is_fixed_size (container))
+ {
+ /* Set the scroll region to the size of the container allocation */
+ gtk_widget_get_allocation (GTK_WIDGET (container), &allocation);
+ eel_canvas_set_scroll_region
+ (EEL_CANVAS (container),
+ (double) - container->details->left_margin / pixels_per_unit,
+ (double) - container->details->top_margin / pixels_per_unit,
+ ((double) (allocation.width - 1)
+ - container->details->left_margin
+ - container->details->right_margin)
+ / pixels_per_unit,
+ ((double) (allocation.height - 1)
+ - container->details->top_margin
+ - container->details->bottom_margin)
+ / pixels_per_unit);
+ return;
+ }
+
+ reset_scroll_region = container->details->reset_scroll_region_trigger
+ || caja_icon_container_is_empty (container)
+ || caja_icon_container_is_auto_layout (container);
+
+ /* The trigger is only cleared when container is non-empty, so
+ * callers can reliably reset the scroll region when an item
+ * is added even if extraneous relayouts are called when the
+ * window is still empty.
+ */
+ if (!caja_icon_container_is_empty (container))
+ {
+ container->details->reset_scroll_region_trigger = FALSE;
+ }
+
+ get_all_icon_bounds (container, &x1, &y1, &x2, &y2, BOUNDS_USAGE_FOR_ENTIRE_ITEM);
+
+ /* Add border at the "end"of the layout (i.e. after the icons), to
+ * ensure we get some space when scrolled to the end.
+ * For horizontal layouts, we add a bottom border.
+ * Vertical layout is used by the compact view so the end
+ * depends on the RTL setting.
+ */
+ if (caja_icon_container_is_layout_vertical (container))
+ {
+ if (caja_icon_container_is_layout_rtl (container))
+ {
+ x1 -= ICON_PAD_LEFT + CONTAINER_PAD_LEFT;
+ }
+ else
+ {
+ x2 += ICON_PAD_RIGHT + CONTAINER_PAD_RIGHT;
+ }
+ }
+ else
+ {
+ y2 += ICON_PAD_BOTTOM + CONTAINER_PAD_BOTTOM;
+ }
+
+ /* Auto-layout assumes a 0, 0 scroll origin and at least allocation->width.
+ * Then we lay out to the right or to the left, so
+ * x can be < 0 and > allocation */
+ if (caja_icon_container_is_auto_layout (container))
+ {
+ gtk_widget_get_allocation (GTK_WIDGET (container), &allocation);
+ x1 = MIN (x1, 0);
+ x2 = MAX (x2, allocation.width / pixels_per_unit);
+ y1 = 0;
+ }
+ else
+ {
+ /* Otherwise we add the padding that is at the start of the
+ layout */
+ if (caja_icon_container_is_layout_rtl (container))
+ {
+ x2 += ICON_PAD_RIGHT + CONTAINER_PAD_RIGHT;
+ }
+ else
+ {
+ x1 -= ICON_PAD_LEFT + CONTAINER_PAD_LEFT;
+ }
+ y1 -= ICON_PAD_TOP + CONTAINER_PAD_TOP;
+ }
+
+ x2 -= 1;
+ x2 = MAX(x1, x2);
+
+ y2 -= 1;
+ y2 = MAX(y1, y2);
+
+ if (reset_scroll_region)
+ {
+ eel_canvas_set_scroll_region
+ (EEL_CANVAS (container),
+ x1, y1, x2, y2);
+ }
+ else
+ {
+ canvas_set_scroll_region_include_visible_area
+ (EEL_CANVAS (container),
+ x1, y1, x2, y2);
+ }
+
+ hadj = gtk_layout_get_hadjustment (GTK_LAYOUT (container));
+ vadj = gtk_layout_get_vadjustment (GTK_LAYOUT (container));
+
+ /* Scroll by 1/4 icon each time you click. */
+ step_increment = caja_get_icon_size_for_zoom_level
+ (container->details->zoom_level) / 4;
+ if (gtk_adjustment_get_step_increment (hadj) != step_increment)
+ {
+ gtk_adjustment_set_step_increment (hadj, step_increment);
+ gtk_adjustment_changed (hadj);
+ }
+ if (gtk_adjustment_get_step_increment (vadj) != step_increment)
+ {
+ gtk_adjustment_set_step_increment (vadj, step_increment);
+ gtk_adjustment_changed (vadj);
+ }
+
+ /* Now that we have a new scroll region, clamp the
+ * adjustments so we are within the valid scroll area.
+ */
+ eel_gtk_adjustment_clamp_value (hadj);
+ eel_gtk_adjustment_clamp_value (vadj);
+}
+
+static int
+compare_icons (gconstpointer a, gconstpointer b, gpointer icon_container)
+{
+ CajaIconContainerClass *klass;
+ const CajaIcon *icon_a, *icon_b;
+
+ icon_a = a;
+ icon_b = b;
+ klass = CAJA_ICON_CONTAINER_GET_CLASS (icon_container);
+
+ return klass->compare_icons (icon_container, icon_a->data, icon_b->data);
+}
+
+static void
+sort_icons (CajaIconContainer *container,
+ GList **icons)
+{
+ CajaIconContainerClass *klass;
+
+ klass = CAJA_ICON_CONTAINER_GET_CLASS (container);
+ g_assert (klass->compare_icons != NULL);
+
+ *icons = g_list_sort_with_data (*icons, compare_icons, container);
+}
+
+static void
+resort (CajaIconContainer *container)
+{
+ sort_icons (container, &container->details->icons);
+}
+
+#if 0
+static double
+get_grid_width (CajaIconContainer *container)
+{
+ if (container->details->label_position == CAJA_ICON_LABEL_POSITION_BESIDE)
+ {
+ return TEXT_BESIDE_ICON_GRID_WIDTH;
+ }
+ else
+ {
+ return STANDARD_ICON_GRID_WIDTH;
+ }
+}
+#endif
+typedef struct
+{
+ double width;
+ double height;
+ double x_offset;
+ double y_offset;
+} IconPositions;
+
+static void
+lay_down_one_line (CajaIconContainer *container,
+ GList *line_start,
+ GList *line_end,
+ double y,
+ double max_height,
+ GArray *positions,
+ gboolean whole_text)
+{
+ GList *p;
+ CajaIcon *icon;
+ double x, y_offset;
+ IconPositions *position;
+ int i;
+ gboolean is_rtl;
+
+ is_rtl = caja_icon_container_is_layout_rtl (container);
+
+ /* Lay out the icons along the baseline. */
+ x = ICON_PAD_LEFT;
+ i = 0;
+ for (p = line_start; p != line_end; p = p->next)
+ {
+ icon = p->data;
+
+ position = &g_array_index (positions, IconPositions, i++);
+
+ if (container->details->label_position == CAJA_ICON_LABEL_POSITION_BESIDE)
+ {
+ y_offset = (max_height - position->height) / 2;
+ }
+ else
+ {
+ y_offset = position->y_offset;
+ }
+
+ icon_set_position
+ (icon,
+ is_rtl ? get_mirror_x_position (container, icon, x + position->x_offset) : x + position->x_offset,
+ y + y_offset);
+ caja_icon_canvas_item_set_entire_text (icon->item, whole_text);
+
+ icon->saved_ltr_x = is_rtl ? get_mirror_x_position (container, icon, icon->x) : icon->x;
+
+ x += position->width;
+ }
+}
+
+static void
+lay_down_one_column (CajaIconContainer *container,
+ GList *line_start,
+ GList *line_end,
+ double x,
+ double y_start,
+ double y_iter,
+ GArray *positions)
+{
+ GList *p;
+ CajaIcon *icon;
+ double y;
+ IconPositions *position;
+ int i;
+ gboolean is_rtl;
+
+ is_rtl = caja_icon_container_is_layout_rtl (container);
+
+ /* Lay out the icons along the baseline. */
+ y = y_start;
+ i = 0;
+ for (p = line_start; p != line_end; p = p->next)
+ {
+ icon = p->data;
+
+ position = &g_array_index (positions, IconPositions, i++);
+
+ icon_set_position
+ (icon,
+ is_rtl ? get_mirror_x_position (container, icon, x + position->x_offset) : x + position->x_offset,
+ y + position->y_offset);
+
+ icon->saved_ltr_x = is_rtl ? get_mirror_x_position (container, icon, icon->x) : icon->x;
+
+ y += y_iter;
+ }
+}
+
+static void
+lay_down_icons_horizontal (CajaIconContainer *container,
+ GList *icons,
+ double start_y)
+{
+ GList *p, *line_start;
+ CajaIcon *icon;
+ double canvas_width, y, canvas_height;
+ GArray *positions;
+ IconPositions *position;
+ EelDRect bounds;
+ EelDRect icon_bounds;
+ EelDRect text_bounds;
+ double max_height_above, max_height_below;
+ double height_above, height_below;
+ double line_width;
+ gboolean gridded_layout;
+ double grid_width;
+ double max_text_width, max_icon_width;
+ int icon_width;
+ int i;
+ GtkAllocation allocation;
+
+ g_assert (CAJA_IS_ICON_CONTAINER (container));
+
+ if (icons == NULL)
+ {
+ return;
+ }
+
+ positions = g_array_new (FALSE, FALSE, sizeof (IconPositions));
+ gtk_widget_get_allocation (GTK_WIDGET (container), &allocation);
+
+ /* Lay out icons a line at a time. */
+ canvas_width = CANVAS_WIDTH(container, allocation);
+ canvas_height = CANVAS_HEIGHT(container, allocation);
+
+ max_icon_width = max_text_width = 0.0;
+
+ if (container->details->label_position == CAJA_ICON_LABEL_POSITION_BESIDE)
+ {
+ /* Would it be worth caching these bounds for the next loop? */
+ for (p = icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+
+ icon_bounds = caja_icon_canvas_item_get_icon_rectangle (icon->item);
+ max_icon_width = MAX (max_icon_width, ceil (icon_bounds.x1 - icon_bounds.x0));
+
+ text_bounds = caja_icon_canvas_item_get_text_rectangle (icon->item, TRUE);
+ max_text_width = MAX (max_text_width, ceil (text_bounds.x1 - text_bounds.x0));
+ }
+
+ grid_width = max_icon_width + max_text_width + ICON_PAD_LEFT + ICON_PAD_RIGHT;
+ }
+ else
+ {
+ grid_width = STANDARD_ICON_GRID_WIDTH;
+ }
+
+ gridded_layout = !caja_icon_container_is_tighter_layout (container);
+
+ line_width = container->details->label_position == CAJA_ICON_LABEL_POSITION_BESIDE ? ICON_PAD_LEFT : 0;
+ line_start = icons;
+ y = start_y + CONTAINER_PAD_TOP;
+ i = 0;
+
+ max_height_above = 0;
+ max_height_below = 0;
+ for (p = icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+
+ /* Assume it's only one level hierarchy to avoid costly affine calculations */
+ caja_icon_canvas_item_get_bounds_for_layout (icon->item,
+ &bounds.x0, &bounds.y0,
+ &bounds.x1, &bounds.y1);
+
+ icon_bounds = caja_icon_canvas_item_get_icon_rectangle (icon->item);
+ text_bounds = caja_icon_canvas_item_get_text_rectangle (icon->item, TRUE);
+
+ if (gridded_layout)
+ {
+ icon_width = ceil ((bounds.x1 - bounds.x0)/grid_width) * grid_width;
+
+
+ }
+ else
+ {
+ icon_width = (bounds.x1 - bounds.x0) + ICON_PAD_RIGHT + 8; /* 8 pixels extra for fancy selection box */
+ }
+
+ /* Calculate size above/below baseline */
+ height_above = icon_bounds.y1 - bounds.y0;
+ height_below = bounds.y1 - icon_bounds.y1;
+
+ /* If this icon doesn't fit, it's time to lay out the line that's queued up. */
+ if (line_start != p && line_width + icon_width >= canvas_width )
+ {
+ if (container->details->label_position == CAJA_ICON_LABEL_POSITION_BESIDE)
+ {
+ y += ICON_PAD_TOP;
+ }
+ else
+ {
+ /* Advance to the baseline. */
+ y += ICON_PAD_TOP + max_height_above;
+ }
+
+ lay_down_one_line (container, line_start, p, y, max_height_above, positions, FALSE);
+
+ if (container->details->label_position == CAJA_ICON_LABEL_POSITION_BESIDE)
+ {
+ y += max_height_above + max_height_below + ICON_PAD_BOTTOM;
+ }
+ else
+ {
+ /* Advance to next line. */
+ y += max_height_below + ICON_PAD_BOTTOM;
+ }
+
+ line_width = container->details->label_position == CAJA_ICON_LABEL_POSITION_BESIDE ? ICON_PAD_LEFT : 0;
+ line_start = p;
+ i = 0;
+
+ max_height_above = height_above;
+ max_height_below = height_below;
+ }
+ else
+ {
+ if (height_above > max_height_above)
+ {
+ max_height_above = height_above;
+ }
+ if (height_below > max_height_below)
+ {
+ max_height_below = height_below;
+ }
+ }
+
+ g_array_set_size (positions, i + 1);
+ position = &g_array_index (positions, IconPositions, i++);
+ position->width = icon_width;
+ position->height = icon_bounds.y1 - icon_bounds.y0;
+
+ if (container->details->label_position == CAJA_ICON_LABEL_POSITION_BESIDE)
+ {
+ if (gridded_layout)
+ {
+ position->x_offset = max_icon_width + ICON_PAD_LEFT + ICON_PAD_RIGHT - (icon_bounds.x1 - icon_bounds.x0);
+ }
+ else
+ {
+ position->x_offset = icon_width - ((icon_bounds.x1 - icon_bounds.x0) + (text_bounds.x1 - text_bounds.x0));
+ }
+ position->y_offset = 0;
+ }
+ else
+ {
+ position->x_offset = (icon_width - (icon_bounds.x1 - icon_bounds.x0)) / 2;
+ position->y_offset = icon_bounds.y0 - icon_bounds.y1;
+ }
+
+ /* Add this icon. */
+ line_width += icon_width;
+ }
+
+ /* Lay down that last line of icons. */
+ if (line_start != NULL)
+ {
+ if (container->details->label_position == CAJA_ICON_LABEL_POSITION_BESIDE)
+ {
+ y += ICON_PAD_TOP;
+ }
+ else
+ {
+ /* Advance to the baseline. */
+ y += ICON_PAD_TOP + max_height_above;
+ }
+
+ lay_down_one_line (container, line_start, NULL, y, max_height_above, positions, TRUE);
+
+ /* Advance to next line. */
+ y += max_height_below + ICON_PAD_BOTTOM;
+ }
+
+ g_array_free (positions, TRUE);
+}
+
+static void
+get_max_icon_dimensions (GList *icon_start,
+ GList *icon_end,
+ double *max_icon_width,
+ double *max_icon_height,
+ double *max_text_width,
+ double *max_text_height,
+ double *max_bounds_height)
+{
+ CajaIcon *icon;
+ EelDRect icon_bounds;
+ EelDRect text_bounds;
+ GList *p;
+ double y1, y2;
+
+ *max_icon_width = *max_text_width = 0.0;
+ *max_icon_height = *max_text_height = 0.0;
+ *max_bounds_height = 0.0;
+
+ /* Would it be worth caching these bounds for the next loop? */
+ for (p = icon_start; p != icon_end; p = p->next)
+ {
+ icon = p->data;
+
+ icon_bounds = caja_icon_canvas_item_get_icon_rectangle (icon->item);
+ *max_icon_width = MAX (*max_icon_width, ceil (icon_bounds.x1 - icon_bounds.x0));
+ *max_icon_height = MAX (*max_icon_height, ceil (icon_bounds.y1 - icon_bounds.y0));
+
+ text_bounds = caja_icon_canvas_item_get_text_rectangle (icon->item, TRUE);
+ *max_text_width = MAX (*max_text_width, ceil (text_bounds.x1 - text_bounds.x0));
+ *max_text_height = MAX (*max_text_height, ceil (text_bounds.y1 - text_bounds.y0));
+
+ caja_icon_canvas_item_get_bounds_for_layout (icon->item,
+ NULL, &y1,
+ NULL, &y2);
+ *max_bounds_height = MAX (*max_bounds_height, y2 - y1);
+ }
+}
+
+/* column-wise layout. At the moment, this only works with label-beside-icon (used by "Compact View"). */
+static void
+lay_down_icons_vertical (CajaIconContainer *container,
+ GList *icons,
+ double start_y)
+{
+ GList *p, *line_start;
+ CajaIcon *icon;
+ double canvas_width, x, canvas_height;
+ GArray *positions;
+ IconPositions *position;
+ EelDRect icon_bounds;
+ EelDRect text_bounds;
+ EelCanvasItem *item;
+ GtkAllocation allocation;
+
+ double line_height;
+
+ double max_height;
+ double max_height_with_borders;
+ double max_width;
+ double max_width_in_column;
+
+ double max_bounds_height;
+ double max_bounds_height_with_borders;
+
+ double max_text_width, max_icon_width;
+ double max_text_height, max_icon_height;
+ int height;
+ int i;
+
+ g_assert (CAJA_IS_ICON_CONTAINER (container));
+ g_assert (container->details->label_position == CAJA_ICON_LABEL_POSITION_BESIDE);
+
+ if (icons == NULL)
+ {
+ return;
+ }
+
+ positions = g_array_new (FALSE, FALSE, sizeof (IconPositions));
+ gtk_widget_get_allocation (GTK_WIDGET (container), &allocation);
+
+ /* Lay out icons a column at a time. */
+ canvas_width = CANVAS_WIDTH(container, allocation);
+ canvas_height = CANVAS_HEIGHT(container, allocation);
+
+ max_icon_width = max_text_width = 0.0;
+ max_icon_height = max_text_height = 0.0;
+ max_bounds_height = 0.0;
+
+ get_max_icon_dimensions (icons, NULL,
+ &max_icon_width, &max_icon_height,
+ &max_text_width, &max_text_height,
+ &max_bounds_height);
+
+ max_width = max_icon_width + max_text_width;
+ max_height = MAX (max_icon_height, max_text_height);
+ max_height_with_borders = ICON_PAD_TOP + max_height;
+
+ max_bounds_height_with_borders = ICON_PAD_TOP + max_bounds_height;
+
+ line_height = ICON_PAD_TOP;
+ line_start = icons;
+ x = 0;
+ i = 0;
+
+ max_width_in_column = 0.0;
+
+ for (p = icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+ item = EEL_CANVAS_ITEM (icon->item);
+
+ /* If this icon doesn't fit, it's time to lay out the column that's queued up. */
+
+ /* We use the bounds height here, since for wrapping we also want to consider
+ * overlapping emblems at the bottom. We may wrap a little bit too early since
+ * the icon with the max. bounds height may actually not be in the last row, but
+ * it is better than visual glitches
+ */
+ if (line_start != p && line_height + (max_bounds_height_with_borders-1) >= canvas_height )
+ {
+ x += ICON_PAD_LEFT;
+
+ /* correctly set (per-column) width */
+ if (!container->details->all_columns_same_width)
+ {
+ for (i = 0; i < (int) positions->len; i++)
+ {
+ position = &g_array_index (positions, IconPositions, i);
+ position->width = max_width_in_column;
+ }
+ }
+
+ lay_down_one_column (container, line_start, p, x, CONTAINER_PAD_TOP, max_height_with_borders, positions);
+
+ /* Advance to next column. */
+ if (container->details->all_columns_same_width)
+ {
+ x += max_width + ICON_PAD_RIGHT;
+ }
+ else
+ {
+ x += max_width_in_column + ICON_PAD_RIGHT;
+ }
+
+ line_height = ICON_PAD_TOP;
+ line_start = p;
+ i = 0;
+
+ max_width_in_column = 0;
+ }
+
+ icon_bounds = caja_icon_canvas_item_get_icon_rectangle (icon->item);
+ text_bounds = caja_icon_canvas_item_get_text_rectangle (icon->item, TRUE);
+
+ max_width_in_column = MAX (max_width_in_column,
+ ceil (icon_bounds.x1 - icon_bounds.x0) +
+ ceil (text_bounds.x1 - text_bounds.x0));
+
+ g_array_set_size (positions, i + 1);
+ position = &g_array_index (positions, IconPositions, i++);
+ if (container->details->all_columns_same_width)
+ {
+ position->width = max_width;
+ }
+ position->height = max_height;
+ position->y_offset = ICON_PAD_TOP;
+ position->x_offset = ICON_PAD_LEFT;
+
+ position->x_offset += max_icon_width - ceil (icon_bounds.x1 - icon_bounds.x0);
+
+ height = MAX (ceil (icon_bounds.y1 - icon_bounds.y0), ceil(text_bounds.y1 - text_bounds.y0));
+ position->y_offset += (max_height - height) / 2;
+
+ /* Add this icon. */
+ line_height += max_height_with_borders;
+ }
+
+ /* Lay down that last column of icons. */
+ if (line_start != NULL)
+ {
+ x += ICON_PAD_LEFT;
+ lay_down_one_column (container, line_start, NULL, x, CONTAINER_PAD_TOP, max_height_with_borders, positions);
+ }
+
+ g_array_free (positions, TRUE);
+}
+
+static void
+snap_position (CajaIconContainer *container,
+ CajaIcon *icon,
+ int *x, int *y)
+{
+ int center_x;
+ int baseline_y;
+ int icon_width;
+ int icon_height;
+ int total_width;
+ int total_height;
+ EelDRect icon_position;
+ GtkAllocation allocation;
+
+ icon_position = caja_icon_canvas_item_get_icon_rectangle (icon->item);
+ icon_width = icon_position.x1 - icon_position.x0;
+ icon_height = icon_position.y1 - icon_position.y0;
+
+ gtk_widget_get_allocation (GTK_WIDGET (container), &allocation);
+ total_width = CANVAS_WIDTH (container, allocation);
+ total_height = CANVAS_HEIGHT (container, allocation);
+
+ if (caja_icon_container_is_layout_rtl (container))
+ *x = get_mirror_x_position (container, icon, *x);
+
+ if (*x + icon_width / 2 < DESKTOP_PAD_HORIZONTAL + SNAP_SIZE_X)
+ {
+ *x = DESKTOP_PAD_HORIZONTAL + SNAP_SIZE_X - icon_width / 2;
+ }
+
+ if (*x + icon_width / 2 > total_width - (DESKTOP_PAD_HORIZONTAL + SNAP_SIZE_X))
+ {
+ *x = total_width - (DESKTOP_PAD_HORIZONTAL + SNAP_SIZE_X + (icon_width / 2));
+ }
+
+ if (*y + icon_height < DESKTOP_PAD_VERTICAL + SNAP_SIZE_Y)
+ {
+ *y = DESKTOP_PAD_VERTICAL + SNAP_SIZE_Y - icon_height;
+ }
+
+ if (*y + icon_height > total_height - (DESKTOP_PAD_VERTICAL + SNAP_SIZE_Y))
+ {
+ *y = total_height - (DESKTOP_PAD_VERTICAL + SNAP_SIZE_Y + (icon_height / 2));
+ }
+
+ center_x = *x + icon_width / 2;
+ *x = SNAP_NEAREST_HORIZONTAL (center_x) - (icon_width / 2);
+ if (caja_icon_container_is_layout_rtl (container))
+ {
+ *x = get_mirror_x_position (container, icon, *x);
+ }
+
+
+ /* Find the grid position vertically and place on the proper baseline */
+ baseline_y = *y + icon_height;
+ baseline_y = SNAP_NEAREST_VERTICAL (baseline_y);
+ *y = baseline_y - icon_height;
+}
+
+static int
+compare_icons_by_position (gconstpointer a, gconstpointer b)
+{
+ CajaIcon *icon_a, *icon_b;
+ int x1, y1, x2, y2;
+ int center_a;
+ int center_b;
+
+ icon_a = (CajaIcon*)a;
+ icon_b = (CajaIcon*)b;
+
+ icon_get_bounding_box (icon_a, &x1, &y1, &x2, &y2,
+ BOUNDS_USAGE_FOR_DISPLAY);
+ center_a = x1 + (x2 - x1) / 2;
+ icon_get_bounding_box (icon_b, &x1, &y1, &x2, &y2,
+ BOUNDS_USAGE_FOR_DISPLAY);
+ center_b = x1 + (x2 - x1) / 2;
+
+ return center_a == center_b ?
+ icon_a->y - icon_b->y :
+ center_a - center_b;
+}
+
+static PlacementGrid *
+placement_grid_new (CajaIconContainer *container, gboolean tight)
+{
+ PlacementGrid *grid;
+ int width, height;
+ int num_columns;
+ int num_rows;
+ int i;
+ GtkAllocation allocation;
+
+ /* Get container dimensions */
+ gtk_widget_get_allocation (GTK_WIDGET (container), &allocation);
+ width = CANVAS_WIDTH(container, allocation);
+ height = CANVAS_HEIGHT(container, allocation);
+
+ num_columns = width / SNAP_SIZE_X;
+ num_rows = height / SNAP_SIZE_Y;
+
+ if (num_columns == 0 || num_rows == 0)
+ {
+ return NULL;
+ }
+
+ grid = g_new0 (PlacementGrid, 1);
+ grid->tight = tight;
+ grid->num_columns = num_columns;
+ grid->num_rows = num_rows;
+
+ grid->grid_memory = g_new0 (int, (num_rows * num_columns));
+ grid->icon_grid = g_new0 (int *, num_columns);
+
+ for (i = 0; i < num_columns; i++)
+ {
+ grid->icon_grid[i] = grid->grid_memory + (i * num_rows);
+ }
+
+ return grid;
+}
+
+static void
+placement_grid_free (PlacementGrid *grid)
+{
+ g_free (grid->icon_grid);
+ g_free (grid->grid_memory);
+ g_free (grid);
+}
+
+static gboolean
+placement_grid_position_is_free (PlacementGrid *grid, EelIRect pos)
+{
+ int x, y;
+
+ g_assert (pos.x0 >= 0 && pos.x0 < grid->num_columns);
+ g_assert (pos.y0 >= 0 && pos.y0 < grid->num_rows);
+ g_assert (pos.x1 >= 0 && pos.x1 < grid->num_columns);
+ g_assert (pos.y1 >= 0 && pos.y1 < grid->num_rows);
+
+ for (x = pos.x0; x <= pos.x1; x++)
+ {
+ for (y = pos.y0; y <= pos.y1; y++)
+ {
+ if (grid->icon_grid[x][y] != 0)
+ {
+ return FALSE;
+ }
+ }
+ }
+
+ return TRUE;
+}
+
+static void
+placement_grid_mark (PlacementGrid *grid, EelIRect pos)
+{
+ int x, y;
+
+ g_assert (pos.x0 >= 0 && pos.x0 < grid->num_columns);
+ g_assert (pos.y0 >= 0 && pos.y0 < grid->num_rows);
+ g_assert (pos.x1 >= 0 && pos.x1 < grid->num_columns);
+ g_assert (pos.y1 >= 0 && pos.y1 < grid->num_rows);
+
+ for (x = pos.x0; x <= pos.x1; x++)
+ {
+ for (y = pos.y0; y <= pos.y1; y++)
+ {
+ grid->icon_grid[x][y] = 1;
+ }
+ }
+}
+
+static void
+canvas_position_to_grid_position (PlacementGrid *grid,
+ EelIRect canvas_position,
+ EelIRect *grid_position)
+{
+ /* The first causes minimal moving around during a snap, but
+ * can end up with partially overlapping icons. The second one won't
+ * allow any overlapping, but can cause more movement to happen
+ * during a snap. */
+ if (grid->tight)
+ {
+ grid_position->x0 = ceil ((double)(canvas_position.x0 - DESKTOP_PAD_HORIZONTAL) / SNAP_SIZE_X);
+ grid_position->y0 = ceil ((double)(canvas_position.y0 - DESKTOP_PAD_VERTICAL) / SNAP_SIZE_Y);
+ grid_position->x1 = floor ((double)(canvas_position.x1 - DESKTOP_PAD_HORIZONTAL) / SNAP_SIZE_X);
+ grid_position->y1 = floor ((double)(canvas_position.y1 - DESKTOP_PAD_VERTICAL) / SNAP_SIZE_Y);
+ }
+ else
+ {
+ grid_position->x0 = floor ((double)(canvas_position.x0 - DESKTOP_PAD_HORIZONTAL) / SNAP_SIZE_X);
+ grid_position->y0 = floor ((double)(canvas_position.y0 - DESKTOP_PAD_VERTICAL) / SNAP_SIZE_Y);
+ grid_position->x1 = floor ((double)(canvas_position.x1 - DESKTOP_PAD_HORIZONTAL) / SNAP_SIZE_X);
+ grid_position->y1 = floor ((double)(canvas_position.y1 - DESKTOP_PAD_VERTICAL) / SNAP_SIZE_Y);
+ }
+
+ grid_position->x0 = CLAMP (grid_position->x0, 0, grid->num_columns - 1);
+ grid_position->y0 = CLAMP (grid_position->y0, 0, grid->num_rows - 1);
+ grid_position->x1 = CLAMP (grid_position->x1, grid_position->x0, grid->num_columns - 1);
+ grid_position->y1 = CLAMP (grid_position->y1, grid_position->y0, grid->num_rows - 1);
+}
+
+static void
+placement_grid_mark_icon (PlacementGrid *grid, CajaIcon *icon)
+{
+ EelIRect icon_pos;
+ EelIRect grid_pos;
+
+ icon_get_bounding_box (icon,
+ &icon_pos.x0, &icon_pos.y0,
+ &icon_pos.x1, &icon_pos.y1,
+ BOUNDS_USAGE_FOR_LAYOUT);
+ canvas_position_to_grid_position (grid,
+ icon_pos,
+ &grid_pos);
+ placement_grid_mark (grid, grid_pos);
+}
+
+static void
+find_empty_location (CajaIconContainer *container,
+ PlacementGrid *grid,
+ CajaIcon *icon,
+ int start_x,
+ int start_y,
+ int *x,
+ int *y)
+{
+ double icon_width, icon_height;
+ int canvas_width;
+ int canvas_height;
+ int height_for_bound_check;
+ EelIRect icon_position;
+ EelDRect pixbuf_rect;
+ gboolean collision;
+ GtkAllocation allocation;
+
+ /* Get container dimensions */
+ gtk_widget_get_allocation (GTK_WIDGET (container), &allocation);
+ canvas_width = CANVAS_WIDTH(container, allocation);
+ canvas_height = CANVAS_HEIGHT(container, allocation);
+
+ icon_get_bounding_box (icon,
+ &icon_position.x0, &icon_position.y0,
+ &icon_position.x1, &icon_position.y1,
+ BOUNDS_USAGE_FOR_LAYOUT);
+ icon_width = icon_position.x1 - icon_position.x0;
+ icon_height = icon_position.y1 - icon_position.y0;
+
+ icon_get_bounding_box (icon,
+ NULL, &icon_position.y0,
+ NULL, &icon_position.y1,
+ BOUNDS_USAGE_FOR_ENTIRE_ITEM);
+ height_for_bound_check = icon_position.y1 - icon_position.y0;
+
+ pixbuf_rect = caja_icon_canvas_item_get_icon_rectangle (icon->item);
+
+ /* Start the icon on a grid location */
+ snap_position (container, icon, &start_x, &start_y);
+
+ icon_position.x0 = start_x;
+ icon_position.y0 = start_y;
+ icon_position.x1 = icon_position.x0 + icon_width;
+ icon_position.y1 = icon_position.y0 + icon_height;
+
+ do
+ {
+ EelIRect grid_position;
+ gboolean need_new_column;
+
+ collision = FALSE;
+
+ canvas_position_to_grid_position (grid,
+ icon_position,
+ &grid_position);
+
+ need_new_column = icon_position.y0 + height_for_bound_check + DESKTOP_PAD_VERTICAL > canvas_height;
+
+ if (need_new_column ||
+ !placement_grid_position_is_free (grid, grid_position))
+ {
+ icon_position.y0 += SNAP_SIZE_Y;
+ icon_position.y1 = icon_position.y0 + icon_height;
+
+ if (need_new_column)
+ {
+ /* Move to the next column */
+ icon_position.y0 = DESKTOP_PAD_VERTICAL + SNAP_SIZE_Y - (pixbuf_rect.y1 - pixbuf_rect.y0);
+ while (icon_position.y0 < DESKTOP_PAD_VERTICAL)
+ {
+ icon_position.y0 += SNAP_SIZE_Y;
+ }
+ icon_position.y1 = icon_position.y0 + icon_height;
+
+ icon_position.x0 += SNAP_SIZE_X;
+ icon_position.x1 = icon_position.x0 + icon_width;
+ }
+
+ collision = TRUE;
+ }
+ }
+ while (collision && (icon_position.x1 < canvas_width));
+
+ *x = icon_position.x0;
+ *y = icon_position.y0;
+}
+
+static void
+align_icons (CajaIconContainer *container)
+{
+ GList *unplaced_icons;
+ GList *l;
+ PlacementGrid *grid;
+
+ unplaced_icons = g_list_copy (container->details->icons);
+
+ unplaced_icons = g_list_sort (unplaced_icons,
+ compare_icons_by_position);
+
+ if (caja_icon_container_is_layout_rtl (container))
+ {
+ unplaced_icons = g_list_reverse (unplaced_icons);
+ }
+
+ grid = placement_grid_new (container, TRUE);
+
+ if (!grid)
+ {
+ return;
+ }
+
+ for (l = unplaced_icons; l != NULL; l = l->next)
+ {
+ CajaIcon *icon;
+ int x, y;
+
+ icon = l->data;
+ x = icon->saved_ltr_x;
+ y = icon->y;
+ find_empty_location (container, grid,
+ icon, x, y, &x, &y);
+
+ icon_set_position (icon, x, y);
+ icon->saved_ltr_x = icon->x;
+ placement_grid_mark_icon (grid, icon);
+ }
+
+ g_list_free (unplaced_icons);
+
+ placement_grid_free (grid);
+
+ if (caja_icon_container_is_layout_rtl (container))
+ {
+ caja_icon_container_set_rtl_positions (container);
+ }
+}
+
+static double
+get_mirror_x_position (CajaIconContainer *container, CajaIcon *icon, double x)
+{
+ EelDRect icon_bounds;
+ GtkAllocation allocation;
+
+ gtk_widget_get_allocation (GTK_WIDGET (container), &allocation);
+ icon_bounds = caja_icon_canvas_item_get_icon_rectangle (icon->item);
+
+ return CANVAS_WIDTH(container, allocation) - x - (icon_bounds.x1 - icon_bounds.x0);
+}
+
+static void
+caja_icon_container_set_rtl_positions (CajaIconContainer *container)
+{
+ GList *l;
+ CajaIcon *icon;
+ double x;
+
+ if (!container->details->icons)
+ {
+ return;
+ }
+
+ for (l = container->details->icons; l != NULL; l = l->next)
+ {
+ icon = l->data;
+ x = get_mirror_x_position (container, icon, icon->saved_ltr_x);
+ icon_set_position (icon, x, icon->y);
+ }
+}
+
+static void
+lay_down_icons_vertical_desktop (CajaIconContainer *container, GList *icons)
+{
+ GList *p, *placed_icons, *unplaced_icons;
+ int total, new_length, placed;
+ CajaIcon *icon;
+ int width, height, max_width, column_width, icon_width, icon_height;
+ int x, y, x1, x2, y1, y2;
+ EelDRect icon_rect;
+ GtkAllocation allocation;
+
+ /* Get container dimensions */
+ gtk_widget_get_allocation (GTK_WIDGET (container), &allocation);
+ width = CANVAS_WIDTH(container, allocation);
+ height = CANVAS_HEIGHT(container, allocation);
+
+ /* Determine which icons have and have not been placed */
+ placed_icons = NULL;
+ unplaced_icons = NULL;
+
+ total = g_list_length (container->details->icons);
+ new_length = g_list_length (icons);
+ placed = total - new_length;
+ if (placed > 0)
+ {
+ PlacementGrid *grid;
+ /* Add only placed icons in list */
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+ if (icon_is_positioned (icon))
+ {
+ icon_set_position(icon, icon->saved_ltr_x, icon->y);
+ placed_icons = g_list_prepend (placed_icons, icon);
+ }
+ else
+ {
+ icon->x = 0;
+ icon->y = 0;
+ unplaced_icons = g_list_prepend (unplaced_icons, icon);
+ }
+ }
+ placed_icons = g_list_reverse (placed_icons);
+ unplaced_icons = g_list_reverse (unplaced_icons);
+
+ grid = placement_grid_new (container, FALSE);
+
+ if (grid)
+ {
+ for (p = placed_icons; p != NULL; p = p->next)
+ {
+ placement_grid_mark_icon
+ (grid, (CajaIcon*)p->data);
+ }
+
+ /* Place unplaced icons in the best locations */
+ for (p = unplaced_icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+
+ icon_rect = caja_icon_canvas_item_get_icon_rectangle (icon->item);
+
+ /* Start the icon in the first column */
+ x = DESKTOP_PAD_HORIZONTAL + (SNAP_SIZE_X / 2) - ((icon_rect.x1 - icon_rect.x0) / 2);
+ y = DESKTOP_PAD_VERTICAL + SNAP_SIZE_Y - (icon_rect.y1 - icon_rect.y0);
+
+ find_empty_location (container,
+ grid,
+ icon,
+ x, y,
+ &x, &y);
+
+ icon_set_position (icon, x, y);
+ icon->saved_ltr_x = x;
+ placement_grid_mark_icon (grid, icon);
+ }
+
+ placement_grid_free (grid);
+ }
+
+ g_list_free (placed_icons);
+ g_list_free (unplaced_icons);
+ }
+ else
+ {
+ /* There are no placed icons. Just lay them down using our rules */
+ x = DESKTOP_PAD_HORIZONTAL;
+
+ while (icons != NULL)
+ {
+ int center_x;
+ int baseline;
+ int icon_height_for_bound_check;
+ gboolean should_snap;
+
+ should_snap = !(container->details->tighter_layout && !container->details->keep_aligned);
+
+ y = DESKTOP_PAD_VERTICAL;
+
+ max_width = 0;
+
+ /* Calculate max width for column */
+ for (p = icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+
+ icon_get_bounding_box (icon, &x1, &y1, &x2, &y2,
+ BOUNDS_USAGE_FOR_LAYOUT);
+ icon_width = x2 - x1;
+ icon_height = y2 - y1;
+
+ icon_get_bounding_box (icon, NULL, &y1, NULL, &y2,
+ BOUNDS_USAGE_FOR_ENTIRE_ITEM);
+ icon_height_for_bound_check = y2 - y1;
+
+ if (should_snap)
+ {
+ /* Snap the baseline to a grid position */
+ icon_rect = caja_icon_canvas_item_get_icon_rectangle (icon->item);
+ baseline = y + (icon_rect.y1 - icon_rect.y0);
+ baseline = SNAP_CEIL_VERTICAL (baseline);
+ y = baseline - (icon_rect.y1 - icon_rect.y0);
+ }
+
+ /* Check and see if we need to move to a new column */
+ if (y != DESKTOP_PAD_VERTICAL && y + icon_height_for_bound_check > height)
+ {
+ break;
+ }
+
+ if (max_width < icon_width)
+ {
+ max_width = icon_width;
+ }
+
+ y += icon_height + DESKTOP_PAD_VERTICAL;
+ }
+
+ y = DESKTOP_PAD_VERTICAL;
+
+ center_x = x + max_width / 2;
+ column_width = max_width;
+ if (should_snap)
+ {
+ /* Find the grid column to center on */
+ center_x = SNAP_CEIL_HORIZONTAL (center_x);
+ column_width = (center_x - x) + (max_width / 2);
+ }
+
+ /* Lay out column */
+ for (p = icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+ icon_get_bounding_box (icon, &x1, &y1, &x2, &y2,
+ BOUNDS_USAGE_FOR_LAYOUT);
+ icon_height = y2 - y1;
+
+ icon_get_bounding_box (icon, NULL, &y1, NULL, &y2,
+ BOUNDS_USAGE_FOR_ENTIRE_ITEM);
+ icon_height_for_bound_check = y2 - y1;
+
+ icon_rect = caja_icon_canvas_item_get_icon_rectangle (icon->item);
+
+ if (should_snap)
+ {
+ baseline = y + (icon_rect.y1 - icon_rect.y0);
+ baseline = SNAP_CEIL_VERTICAL (baseline);
+ y = baseline - (icon_rect.y1 - icon_rect.y0);
+ }
+
+ /* Check and see if we need to move to a new column */
+ if (y != DESKTOP_PAD_VERTICAL && y > height - icon_height_for_bound_check &&
+ /* Make sure we lay out at least one icon per column, to make progress */
+ p != icons)
+ {
+ x += column_width + DESKTOP_PAD_HORIZONTAL;
+ break;
+ }
+
+ icon_set_position (icon,
+ center_x - (icon_rect.x1 - icon_rect.x0) / 2,
+ y);
+
+ icon->saved_ltr_x = icon->x;
+ y += icon_height + DESKTOP_PAD_VERTICAL;
+ }
+ icons = p;
+ }
+ }
+
+ /* These modes are special. We freeze all of our positions
+ * after we do the layout.
+ */
+ /* FIXME bugzilla.gnome.org 42478:
+ * This should not be tied to the direction of layout.
+ * It should be a separate switch.
+ */
+ caja_icon_container_freeze_icon_positions (container);
+}
+
+
+static void
+lay_down_icons (CajaIconContainer *container, GList *icons, double start_y)
+{
+ switch (container->details->layout_mode)
+ {
+ case CAJA_ICON_LAYOUT_L_R_T_B:
+ case CAJA_ICON_LAYOUT_R_L_T_B:
+ lay_down_icons_horizontal (container, icons, start_y);
+ break;
+
+ case CAJA_ICON_LAYOUT_T_B_L_R:
+ case CAJA_ICON_LAYOUT_T_B_R_L:
+ if (caja_icon_container_get_is_desktop (container))
+ {
+ lay_down_icons_vertical_desktop (container, icons);
+ }
+ else
+ {
+ lay_down_icons_vertical (container, icons, start_y);
+ }
+ break;
+
+ default:
+ g_assert_not_reached ();
+ }
+}
+
+static void
+redo_layout_internal (CajaIconContainer *container)
+{
+ finish_adding_new_icons (container);
+
+ /* Don't do any re-laying-out during stretching. Later we
+ * might add smart logic that does this and leaves room for
+ * the stretched icon, but if we do it we want it to be fast
+ * and only re-lay-out when it's really needed.
+ */
+ if (container->details->auto_layout
+ && container->details->drag_state != DRAG_STATE_STRETCH)
+ {
+ resort (container);
+ lay_down_icons (container, container->details->icons, 0);
+ }
+
+ if (caja_icon_container_is_layout_rtl (container))
+ {
+ caja_icon_container_set_rtl_positions (container);
+ }
+
+ caja_icon_container_update_scroll_region (container);
+
+ process_pending_icon_to_reveal (container);
+ process_pending_icon_to_rename (container);
+ caja_icon_container_update_visible_icons (container);
+}
+
+static gboolean
+redo_layout_callback (gpointer callback_data)
+{
+ CajaIconContainer *container;
+
+ container = CAJA_ICON_CONTAINER (callback_data);
+ redo_layout_internal (container);
+ container->details->idle_id = 0;
+
+ return FALSE;
+}
+
+static void
+unschedule_redo_layout (CajaIconContainer *container)
+{
+ if (container->details->idle_id != 0)
+ {
+ g_source_remove (container->details->idle_id);
+ container->details->idle_id = 0;
+ }
+}
+
+static void
+schedule_redo_layout (CajaIconContainer *container)
+{
+ if (container->details->idle_id == 0
+ && container->details->has_been_allocated)
+ {
+ container->details->idle_id = g_idle_add
+ (redo_layout_callback, container);
+ }
+}
+
+static void
+redo_layout (CajaIconContainer *container)
+{
+ unschedule_redo_layout (container);
+ redo_layout_internal (container);
+}
+
+static void
+reload_icon_positions (CajaIconContainer *container)
+{
+ GList *p, *no_position_icons;
+ CajaIcon *icon;
+ gboolean have_stored_position;
+ CajaIconPosition position;
+ EelDRect bounds;
+ double bottom;
+ EelCanvasItem *item;
+
+ g_assert (!container->details->auto_layout);
+
+ resort (container);
+
+ no_position_icons = NULL;
+
+ /* Place all the icons with positions. */
+ bottom = 0;
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+
+ have_stored_position = FALSE;
+ g_signal_emit (container,
+ signals[GET_STORED_ICON_POSITION], 0,
+ icon->data,
+ &position,
+ &have_stored_position);
+ if (have_stored_position)
+ {
+ icon_set_position (icon, position.x, position.y);
+ item = EEL_CANVAS_ITEM (icon->item);
+ caja_icon_canvas_item_get_bounds_for_layout (icon->item,
+ &bounds.x0,
+ &bounds.y0,
+ &bounds.x1,
+ &bounds.y1);
+ eel_canvas_item_i2w (item->parent,
+ &bounds.x0,
+ &bounds.y0);
+ eel_canvas_item_i2w (item->parent,
+ &bounds.x1,
+ &bounds.y1);
+ if (bounds.y1 > bottom)
+ {
+ bottom = bounds.y1;
+ }
+ }
+ else
+ {
+ no_position_icons = g_list_prepend (no_position_icons, icon);
+ }
+ }
+ no_position_icons = g_list_reverse (no_position_icons);
+
+ /* Place all the other icons. */
+ lay_down_icons (container, no_position_icons, bottom + ICON_PAD_BOTTOM);
+ g_list_free (no_position_icons);
+}
+
+/* Container-level icon handling functions. */
+
+static gboolean
+button_event_modifies_selection (GdkEventButton *event)
+{
+ return (event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) != 0;
+}
+
+/* invalidate the cached label sizes for all the icons */
+static void
+invalidate_label_sizes (CajaIconContainer *container)
+{
+ GList *p;
+ CajaIcon *icon;
+
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+
+ caja_icon_canvas_item_invalidate_label_size (icon->item);
+ }
+}
+
+/* invalidate the entire labels (i.e. their attributes) for all the icons */
+static void
+invalidate_labels (CajaIconContainer *container)
+{
+ GList *p;
+ CajaIcon *icon;
+
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+
+ caja_icon_canvas_item_invalidate_label (icon->item);
+ }
+}
+
+static gboolean
+select_range (CajaIconContainer *container,
+ CajaIcon *icon1,
+ CajaIcon *icon2,
+ gboolean unselect_outside_range)
+{
+ gboolean selection_changed;
+ GList *p;
+ CajaIcon *icon;
+ CajaIcon *unmatched_icon;
+ gboolean select;
+
+ selection_changed = FALSE;
+
+ unmatched_icon = NULL;
+ select = FALSE;
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+
+ if (unmatched_icon == NULL)
+ {
+ if (icon == icon1)
+ {
+ unmatched_icon = icon2;
+ select = TRUE;
+ }
+ else if (icon == icon2)
+ {
+ unmatched_icon = icon1;
+ select = TRUE;
+ }
+ }
+
+ if (select || unselect_outside_range)
+ {
+ selection_changed |= icon_set_selected
+ (container, icon, select);
+ }
+
+ if (unmatched_icon != NULL && icon == unmatched_icon)
+ {
+ select = FALSE;
+ }
+
+ }
+
+ if (selection_changed && icon2 != NULL)
+ {
+ emit_atk_focus_tracker_notify (icon2);
+ }
+ return selection_changed;
+}
+
+
+static gboolean
+select_one_unselect_others (CajaIconContainer *container,
+ CajaIcon *icon_to_select)
+{
+ gboolean selection_changed;
+ GList *p;
+ CajaIcon *icon;
+
+ selection_changed = FALSE;
+
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+
+ selection_changed |= icon_set_selected
+ (container, icon, icon == icon_to_select);
+ }
+
+ if (selection_changed && icon_to_select != NULL)
+ {
+ emit_atk_focus_tracker_notify (icon_to_select);
+ reveal_icon (container, icon_to_select);
+ }
+ return selection_changed;
+}
+
+static gboolean
+unselect_all (CajaIconContainer *container)
+{
+ return select_one_unselect_others (container, NULL);
+}
+
+void
+caja_icon_container_move_icon (CajaIconContainer *container,
+ CajaIcon *icon,
+ int x, int y,
+ double scale,
+ gboolean raise,
+ gboolean snap,
+ gboolean update_position)
+{
+ CajaIconContainerDetails *details;
+ gboolean emit_signal;
+ CajaIconPosition position;
+
+ details = container->details;
+
+ emit_signal = FALSE;
+
+ if (icon == get_icon_being_renamed (container))
+ {
+ end_renaming_mode (container, TRUE);
+ }
+
+ if (scale != icon->scale)
+ {
+ icon->scale = scale;
+ caja_icon_container_update_icon (container, icon);
+ if (update_position)
+ {
+ redo_layout (container);
+ emit_signal = TRUE;
+ }
+ }
+
+ if (!details->auto_layout)
+ {
+ if (details->keep_aligned && snap)
+ {
+ snap_position (container, icon, &x, &y);
+ }
+
+ if (x != icon->x || y != icon->y)
+ {
+ icon_set_position (icon, x, y);
+ emit_signal = update_position;
+ }
+
+ icon->saved_ltr_x = caja_icon_container_is_layout_rtl (container) ? get_mirror_x_position (container, icon, icon->x) : icon->x;
+ }
+
+ if (emit_signal)
+ {
+ position.x = icon->saved_ltr_x;
+ position.y = icon->y;
+ position.scale = scale;
+ g_signal_emit (container,
+ signals[ICON_POSITION_CHANGED], 0,
+ icon->data, &position);
+ }
+
+ if (raise)
+ {
+ icon_raise (icon);
+ }
+
+ /* FIXME bugzilla.gnome.org 42474:
+ * Handling of the scroll region is inconsistent here. In
+ * the scale-changing case, redo_layout is called, which updates the
+ * scroll region appropriately. In other cases, it's up to the
+ * caller to make sure the scroll region is updated. This could
+ * lead to hard-to-track-down bugs.
+ */
+}
+
+/* Implementation of rubberband selection. */
+static void
+rubberband_select (CajaIconContainer *container,
+ const EelDRect *previous_rect,
+ const EelDRect *current_rect)
+{
+ GList *p;
+ gboolean selection_changed, is_in, canvas_rect_calculated;
+ CajaIcon *icon;
+ EelIRect canvas_rect;
+ EelCanvas *canvas;
+
+ selection_changed = FALSE;
+ canvas_rect_calculated = FALSE;
+
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+
+ if (!canvas_rect_calculated)
+ {
+ /* Only do this calculation once, since all the canvas items
+ * we are interating are in the same coordinate space
+ */
+ canvas = EEL_CANVAS_ITEM (icon->item)->canvas;
+ eel_canvas_w2c (canvas,
+ current_rect->x0,
+ current_rect->y0,
+ &canvas_rect.x0,
+ &canvas_rect.y0);
+ eel_canvas_w2c (canvas,
+ current_rect->x1,
+ current_rect->y1,
+ &canvas_rect.x1,
+ &canvas_rect.y1);
+ canvas_rect_calculated = TRUE;
+ }
+
+ is_in = caja_icon_canvas_item_hit_test_rectangle (icon->item, canvas_rect);
+
+ selection_changed |= icon_set_selected
+ (container, icon,
+ is_in ^ icon->was_selected_before_rubberband);
+ }
+
+ if (selection_changed)
+ {
+ g_signal_emit (container,
+ signals[SELECTION_CHANGED], 0);
+ }
+}
+
+static int
+rubberband_timeout_callback (gpointer data)
+{
+ CajaIconContainer *container;
+ GtkWidget *widget;
+ CajaIconRubberbandInfo *band_info;
+ int x, y;
+ double x1, y1, x2, y2;
+ double world_x, world_y;
+ int x_scroll, y_scroll;
+ int adj_x, adj_y;
+ gboolean adj_changed;
+ GtkAllocation allocation;
+
+ EelDRect selection_rect;
+
+ widget = GTK_WIDGET (data);
+ container = CAJA_ICON_CONTAINER (data);
+ band_info = &container->details->rubberband_info;
+
+ g_assert (band_info->timer_id != 0);
+ g_assert (EEL_IS_CANVAS_RECT (band_info->selection_rectangle) ||
+ EEL_IS_CANVAS_RECT (band_info->selection_rectangle));
+
+ adj_changed = FALSE;
+ gtk_widget_get_allocation (widget, &allocation);
+
+ adj_x = gtk_adjustment_get_value (gtk_layout_get_hadjustment (GTK_LAYOUT (container)));
+ if (adj_x != band_info->last_adj_x)
+ {
+ band_info->last_adj_x = adj_x;
+ adj_changed = TRUE;
+ }
+
+ adj_y = gtk_adjustment_get_value (gtk_layout_get_vadjustment (GTK_LAYOUT (container)));
+ if (adj_y != band_info->last_adj_y)
+ {
+ band_info->last_adj_y = adj_y;
+ adj_changed = TRUE;
+ }
+
+ gtk_widget_get_pointer (widget, &x, &y);
+
+ if (x < 0)
+ {
+ x_scroll = x;
+ x = 0;
+ }
+ else if (x >= allocation.width)
+ {
+ x_scroll = x - allocation.width + 1;
+ x = allocation.width - 1;
+ }
+ else
+ {
+ x_scroll = 0;
+ }
+
+ if (y < 0)
+ {
+ y_scroll = y;
+ y = 0;
+ }
+ else if (y >= allocation.height)
+ {
+ y_scroll = y - allocation.height + 1;
+ y = allocation.height - 1;
+ }
+ else
+ {
+ y_scroll = 0;
+ }
+
+ if (y_scroll == 0 && x_scroll == 0
+ && (int) band_info->prev_x == x && (int) band_info->prev_y == y && !adj_changed)
+ {
+ return TRUE;
+ }
+
+ caja_icon_container_scroll (container, x_scroll, y_scroll);
+
+ /* Remember to convert from widget to scrolled window coords */
+ eel_canvas_window_to_world (EEL_CANVAS (container),
+ x + gtk_adjustment_get_value (gtk_layout_get_hadjustment (GTK_LAYOUT (container))),
+ y + gtk_adjustment_get_value (gtk_layout_get_vadjustment (GTK_LAYOUT (container))),
+ &world_x, &world_y);
+
+ if (world_x < band_info->start_x)
+ {
+ x1 = world_x;
+ x2 = band_info->start_x;
+ }
+ else
+ {
+ x1 = band_info->start_x;
+ x2 = world_x;
+ }
+
+ if (world_y < band_info->start_y)
+ {
+ y1 = world_y;
+ y2 = band_info->start_y;
+ }
+ else
+ {
+ y1 = band_info->start_y;
+ y2 = world_y;
+ }
+
+ /* Don't let the area of the selection rectangle be empty.
+ * Aside from the fact that it would be funny when the rectangle disappears,
+ * this also works around a crash in libart that happens sometimes when a
+ * zero height rectangle is passed.
+ */
+ x2 = MAX (x1 + 1, x2);
+ y2 = MAX (y1 + 1, y2);
+
+ eel_canvas_item_set
+ (band_info->selection_rectangle,
+ "x1", x1, "y1", y1,
+ "x2", x2, "y2", y2,
+ NULL);
+
+ selection_rect.x0 = x1;
+ selection_rect.y0 = y1;
+ selection_rect.x1 = x2;
+ selection_rect.y1 = y2;
+
+ rubberband_select (container,
+ &band_info->prev_rect,
+ &selection_rect);
+
+ band_info->prev_x = x;
+ band_info->prev_y = y;
+
+ band_info->prev_rect = selection_rect;
+
+ return TRUE;
+}
+
+static void
+start_rubberbanding (CajaIconContainer *container,
+ GdkEventButton *event)
+{
+ AtkObject *accessible;
+ CajaIconContainerDetails *details;
+ CajaIconRubberbandInfo *band_info;
+ guint fill_color, outline_color;
+ GdkColor *fill_color_gdk;
+ guchar fill_color_alpha;
+ GList *p;
+ CajaIcon *icon;
+ GtkStyle *style;
+
+ details = container->details;
+ band_info = &details->rubberband_info;
+
+ g_signal_emit (container,
+ signals[BAND_SELECT_STARTED], 0);
+
+ for (p = details->icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+ icon->was_selected_before_rubberband = icon->is_selected;
+ }
+
+ eel_canvas_window_to_world
+ (EEL_CANVAS (container), event->x, event->y,
+ &band_info->start_x, &band_info->start_y);
+
+ gtk_widget_style_get (GTK_WIDGET (container),
+ "selection_box_color", &fill_color_gdk,
+ "selection_box_alpha", &fill_color_alpha,
+ NULL);
+
+ if (!fill_color_gdk)
+ {
+ style = gtk_widget_get_style (GTK_WIDGET (container));
+ fill_color_gdk = gdk_color_copy (&style->base[GTK_STATE_SELECTED]);
+ }
+
+ fill_color = eel_gdk_color_to_rgb (fill_color_gdk) << 8 | fill_color_alpha;
+
+ gdk_color_free (fill_color_gdk);
+
+ outline_color = fill_color | 255;
+
+ band_info->selection_rectangle = eel_canvas_item_new
+ (eel_canvas_root
+ (EEL_CANVAS (container)),
+ EEL_TYPE_CANVAS_RECT,
+ "x1", band_info->start_x,
+ "y1", band_info->start_y,
+ "x2", band_info->start_x,
+ "y2", band_info->start_y,
+ "fill_color_rgba", fill_color,
+ "outline_color_rgba", outline_color,
+ "width_pixels", 1,
+ NULL);
+
+ accessible = atk_gobject_accessible_for_object
+ (G_OBJECT (band_info->selection_rectangle));
+ atk_object_set_name (accessible, "selection");
+ atk_object_set_description (accessible, _("The selection rectangle"));
+
+ band_info->prev_x = event->x - gtk_adjustment_get_value (gtk_layout_get_hadjustment (GTK_LAYOUT (container)));
+ band_info->prev_y = event->y - gtk_adjustment_get_value (gtk_layout_get_vadjustment (GTK_LAYOUT (container)));
+
+ band_info->active = TRUE;
+
+ if (band_info->timer_id == 0)
+ {
+ band_info->timer_id = g_timeout_add
+ (RUBBERBAND_TIMEOUT_INTERVAL,
+ rubberband_timeout_callback,
+ container);
+ }
+
+ eel_canvas_item_grab (band_info->selection_rectangle,
+ (GDK_POINTER_MOTION_MASK
+ | GDK_BUTTON_RELEASE_MASK
+ | GDK_SCROLL_MASK),
+ NULL, event->time);
+}
+
+static void
+stop_rubberbanding (CajaIconContainer *container,
+ guint32 time)
+{
+ CajaIconRubberbandInfo *band_info;
+ GList *icons;
+
+ band_info = &container->details->rubberband_info;
+
+ g_assert (band_info->timer_id != 0);
+ g_source_remove (band_info->timer_id);
+ band_info->timer_id = 0;
+
+ band_info->active = FALSE;
+
+ /* Destroy this canvas item; the parent will unref it. */
+ eel_canvas_item_ungrab (band_info->selection_rectangle, time);
+ gtk_object_destroy (GTK_OBJECT (band_info->selection_rectangle));
+ band_info->selection_rectangle = NULL;
+
+ /* if only one item has been selected, use it as range
+ * selection base (cf. handle_icon_button_press) */
+ icons = caja_icon_container_get_selected_icons (container);
+ if (g_list_length (icons) == 1)
+ {
+ container->details->range_selection_base_icon = icons->data;
+ }
+ g_list_free (icons);
+
+ g_signal_emit (container,
+ signals[BAND_SELECT_ENDED], 0);
+}
+
+/* Keyboard navigation. */
+
+typedef gboolean (* IsBetterIconFunction) (CajaIconContainer *container,
+ CajaIcon *start_icon,
+ CajaIcon *best_so_far,
+ CajaIcon *candidate,
+ void *data);
+
+static CajaIcon *
+find_best_icon (CajaIconContainer *container,
+ CajaIcon *start_icon,
+ IsBetterIconFunction function,
+ void *data)
+{
+ GList *p;
+ CajaIcon *best, *candidate;
+
+ best = NULL;
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ candidate = p->data;
+
+ if (candidate != start_icon)
+ {
+ if ((* function) (container, start_icon, best, candidate, data))
+ {
+ best = candidate;
+ }
+ }
+ }
+ return best;
+}
+
+static CajaIcon *
+find_best_selected_icon (CajaIconContainer *container,
+ CajaIcon *start_icon,
+ IsBetterIconFunction function,
+ void *data)
+{
+ GList *p;
+ CajaIcon *best, *candidate;
+
+ best = NULL;
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ candidate = p->data;
+
+ if (candidate != start_icon && candidate->is_selected)
+ {
+ if ((* function) (container, start_icon, best, candidate, data))
+ {
+ best = candidate;
+ }
+ }
+ }
+ return best;
+}
+
+static int
+compare_icons_by_uri (CajaIconContainer *container,
+ CajaIcon *icon_a,
+ CajaIcon *icon_b)
+{
+ char *uri_a, *uri_b;
+ int result;
+
+ g_assert (CAJA_IS_ICON_CONTAINER (container));
+ g_assert (icon_a != NULL);
+ g_assert (icon_b != NULL);
+ g_assert (icon_a != icon_b);
+
+ uri_a = caja_icon_container_get_icon_uri (container, icon_a);
+ uri_b = caja_icon_container_get_icon_uri (container, icon_b);
+ result = strcmp (uri_a, uri_b);
+ g_assert (result != 0);
+ g_free (uri_a);
+ g_free (uri_b);
+
+ return result;
+}
+
+static int
+get_cmp_point_x (CajaIconContainer *container,
+ EelDRect icon_rect)
+{
+ if (container->details->label_position == CAJA_ICON_LABEL_POSITION_BESIDE)
+ {
+ if (gtk_widget_get_direction (GTK_WIDGET (container)) == GTK_TEXT_DIR_RTL)
+ {
+ return icon_rect.x0;
+ }
+ else
+ {
+ return icon_rect.x1;
+ }
+ }
+ else
+ {
+ return (icon_rect.x0 + icon_rect.x1) / 2;
+ }
+}
+
+static int
+get_cmp_point_y (CajaIconContainer *container,
+ EelDRect icon_rect)
+{
+ if (container->details->label_position == CAJA_ICON_LABEL_POSITION_BESIDE)
+ {
+ return (icon_rect.y0 + icon_rect.y1)/2;
+ }
+ else
+ {
+ return icon_rect.y1;
+ }
+}
+
+
+static int
+compare_icons_horizontal (CajaIconContainer *container,
+ CajaIcon *icon_a,
+ CajaIcon *icon_b)
+{
+ EelDRect world_rect;
+ int ax, bx;
+
+ world_rect = caja_icon_canvas_item_get_icon_rectangle (icon_a->item);
+ eel_canvas_w2c
+ (EEL_CANVAS (container),
+ get_cmp_point_x (container, world_rect),
+ get_cmp_point_y (container, world_rect),
+ &ax,
+ NULL);
+ world_rect = caja_icon_canvas_item_get_icon_rectangle (icon_b->item);
+ eel_canvas_w2c
+ (EEL_CANVAS (container),
+ get_cmp_point_x (container, world_rect),
+ get_cmp_point_y (container, world_rect),
+ &bx,
+ NULL);
+
+ if (ax < bx)
+ {
+ return -1;
+ }
+ if (ax > bx)
+ {
+ return +1;
+ }
+ return 0;
+}
+
+static int
+compare_icons_vertical (CajaIconContainer *container,
+ CajaIcon *icon_a,
+ CajaIcon *icon_b)
+{
+ EelDRect world_rect;
+ int ay, by;
+
+ world_rect = caja_icon_canvas_item_get_icon_rectangle (icon_a->item);
+ eel_canvas_w2c
+ (EEL_CANVAS (container),
+ get_cmp_point_x (container, world_rect),
+ get_cmp_point_y (container, world_rect),
+ NULL,
+ &ay);
+ world_rect = caja_icon_canvas_item_get_icon_rectangle (icon_b->item);
+ eel_canvas_w2c
+ (EEL_CANVAS (container),
+ get_cmp_point_x (container, world_rect),
+ get_cmp_point_y (container, world_rect),
+ NULL,
+ &by);
+
+ if (ay < by)
+ {
+ return -1;
+ }
+ if (ay > by)
+ {
+ return +1;
+ }
+ return 0;
+}
+
+static int
+compare_icons_horizontal_first (CajaIconContainer *container,
+ CajaIcon *icon_a,
+ CajaIcon *icon_b)
+{
+ EelDRect world_rect;
+ int ax, ay, bx, by;
+
+ world_rect = caja_icon_canvas_item_get_icon_rectangle (icon_a->item);
+ eel_canvas_w2c
+ (EEL_CANVAS (container),
+ get_cmp_point_x (container, world_rect),
+ get_cmp_point_y (container, world_rect),
+ &ax,
+ &ay);
+ world_rect = caja_icon_canvas_item_get_icon_rectangle (icon_b->item);
+ eel_canvas_w2c
+ (EEL_CANVAS (container),
+ get_cmp_point_x (container, world_rect),
+ get_cmp_point_y (container, world_rect),
+ &bx,
+ &by);
+
+ if (ax < bx)
+ {
+ return -1;
+ }
+ if (ax > bx)
+ {
+ return +1;
+ }
+ if (ay < by)
+ {
+ return -1;
+ }
+ if (ay > by)
+ {
+ return +1;
+ }
+ return compare_icons_by_uri (container, icon_a, icon_b);
+}
+
+static int
+compare_icons_vertical_first (CajaIconContainer *container,
+ CajaIcon *icon_a,
+ CajaIcon *icon_b)
+{
+ EelDRect world_rect;
+ int ax, ay, bx, by;
+
+ world_rect = caja_icon_canvas_item_get_icon_rectangle (icon_a->item);
+ eel_canvas_w2c
+ (EEL_CANVAS (container),
+ get_cmp_point_x (container, world_rect),
+ get_cmp_point_y (container, world_rect),
+ &ax,
+ &ay);
+ world_rect = caja_icon_canvas_item_get_icon_rectangle (icon_b->item);
+ eel_canvas_w2c
+ (EEL_CANVAS (container),
+ get_cmp_point_x (container, world_rect),
+ get_cmp_point_y (container, world_rect),
+ &bx,
+ &by);
+
+ if (ay < by)
+ {
+ return -1;
+ }
+ if (ay > by)
+ {
+ return +1;
+ }
+ if (ax < bx)
+ {
+ return -1;
+ }
+ if (ax > bx)
+ {
+ return +1;
+ }
+ return compare_icons_by_uri (container, icon_a, icon_b);
+}
+
+static gboolean
+leftmost_in_top_row (CajaIconContainer *container,
+ CajaIcon *start_icon,
+ CajaIcon *best_so_far,
+ CajaIcon *candidate,
+ void *data)
+{
+ if (best_so_far == NULL)
+ {
+ return TRUE;
+ }
+ return compare_icons_vertical_first (container, best_so_far, candidate) > 0;
+}
+
+static gboolean
+rightmost_in_top_row (CajaIconContainer *container,
+ CajaIcon *start_icon,
+ CajaIcon *best_so_far,
+ CajaIcon *candidate,
+ void *data)
+{
+ if (best_so_far == NULL)
+ {
+ return TRUE;
+ }
+ return compare_icons_vertical (container, best_so_far, candidate) > 0;
+ return compare_icons_horizontal (container, best_so_far, candidate) < 0;
+}
+
+static gboolean
+rightmost_in_bottom_row (CajaIconContainer *container,
+ CajaIcon *start_icon,
+ CajaIcon *best_so_far,
+ CajaIcon *candidate,
+ void *data)
+{
+ if (best_so_far == NULL)
+ {
+ return TRUE;
+ }
+ return compare_icons_vertical_first (container, best_so_far, candidate) < 0;
+}
+
+static int
+compare_with_start_row (CajaIconContainer *container,
+ CajaIcon *icon)
+{
+ EelCanvasItem *item;
+
+ item = EEL_CANVAS_ITEM (icon->item);
+
+ if (container->details->arrow_key_start_y < item->y1)
+ {
+ return -1;
+ }
+ if (container->details->arrow_key_start_y > item->y2)
+ {
+ return +1;
+ }
+ return 0;
+}
+
+static int
+compare_with_start_column (CajaIconContainer *container,
+ CajaIcon *icon)
+{
+ EelCanvasItem *item;
+
+ item = EEL_CANVAS_ITEM (icon->item);
+
+ if (container->details->arrow_key_start_x < item->x1)
+ {
+ return -1;
+ }
+ if (container->details->arrow_key_start_x > item->x2)
+ {
+ return +1;
+ }
+ return 0;
+}
+
+static gboolean
+same_row_right_side_leftmost (CajaIconContainer *container,
+ CajaIcon *start_icon,
+ CajaIcon *best_so_far,
+ CajaIcon *candidate,
+ void *data)
+{
+ /* Candidates not on the start row do not qualify. */
+ if (compare_with_start_row (container, candidate) != 0)
+ {
+ return FALSE;
+ }
+
+ /* Candidates that are farther right lose out. */
+ if (best_so_far != NULL)
+ {
+ if (compare_icons_horizontal_first (container,
+ best_so_far,
+ candidate) < 0)
+ {
+ return FALSE;
+ }
+ }
+
+ /* Candidate to the left of the start do not qualify. */
+ if (compare_icons_horizontal_first (container,
+ candidate,
+ start_icon) <= 0)
+ {
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static gboolean
+same_row_left_side_rightmost (CajaIconContainer *container,
+ CajaIcon *start_icon,
+ CajaIcon *best_so_far,
+ CajaIcon *candidate,
+ void *data)
+{
+ /* Candidates not on the start row do not qualify. */
+ if (compare_with_start_row (container, candidate) != 0)
+ {
+ return FALSE;
+ }
+
+ /* Candidates that are farther left lose out. */
+ if (best_so_far != NULL)
+ {
+ if (compare_icons_horizontal_first (container,
+ best_so_far,
+ candidate) > 0)
+ {
+ return FALSE;
+ }
+ }
+
+ /* Candidate to the right of the start do not qualify. */
+ if (compare_icons_horizontal_first (container,
+ candidate,
+ start_icon) >= 0)
+ {
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static gboolean
+next_row_leftmost (CajaIconContainer *container,
+ CajaIcon *start_icon,
+ CajaIcon *best_so_far,
+ CajaIcon *candidate,
+ void *data)
+{
+ /* sort out icons that are not below the current row */
+ if (compare_with_start_row (container, candidate) >= 0)
+ {
+ return FALSE;
+ }
+
+ if (best_so_far != NULL)
+ {
+ if (compare_icons_vertical_first (container,
+ best_so_far,
+ candidate) > 0)
+ {
+ /* candidate is above best choice, but below the current row */
+ return TRUE;
+ }
+
+ if (compare_icons_horizontal_first (container,
+ best_so_far,
+ candidate) > 0)
+ {
+ return TRUE;
+ }
+ }
+
+ return best_so_far == NULL;
+}
+
+static gboolean
+next_row_rightmost (CajaIconContainer *container,
+ CajaIcon *start_icon,
+ CajaIcon *best_so_far,
+ CajaIcon *candidate,
+ void *data)
+{
+ /* sort out icons that are not below the current row */
+ if (compare_with_start_row (container, candidate) >= 0)
+ {
+ return FALSE;
+ }
+
+ if (best_so_far != NULL)
+ {
+ if (compare_icons_vertical_first (container,
+ best_so_far,
+ candidate) > 0)
+ {
+ /* candidate is above best choice, but below the current row */
+ return TRUE;
+ }
+
+ if (compare_icons_horizontal_first (container,
+ best_so_far,
+ candidate) < 0)
+ {
+ return TRUE;
+ }
+ }
+
+ return best_so_far == NULL;
+}
+
+static gboolean
+next_column_bottommost (CajaIconContainer *container,
+ CajaIcon *start_icon,
+ CajaIcon *best_so_far,
+ CajaIcon *candidate,
+ void *data)
+{
+ /* sort out icons that are not on the right of the current column */
+ if (compare_with_start_column (container, candidate) >= 0)
+ {
+ return FALSE;
+ }
+
+ if (best_so_far != NULL)
+ {
+ if (compare_icons_horizontal_first (container,
+ best_so_far,
+ candidate) > 0)
+ {
+ /* candidate is above best choice, but below the current row */
+ return TRUE;
+ }
+
+ if (compare_icons_vertical_first (container,
+ best_so_far,
+ candidate) < 0)
+ {
+ return TRUE;
+ }
+ }
+
+ return best_so_far == NULL;
+}
+
+static gboolean
+previous_row_rightmost (CajaIconContainer *container,
+ CajaIcon *start_icon,
+ CajaIcon *best_so_far,
+ CajaIcon *candidate,
+ void *data)
+{
+ /* sort out icons that are not above the current row */
+ if (compare_with_start_row (container, candidate) <= 0)
+ {
+ return FALSE;
+ }
+
+ if (best_so_far != NULL)
+ {
+ if (compare_icons_vertical_first (container,
+ best_so_far,
+ candidate) < 0)
+ {
+ /* candidate is below the best choice, but above the current row */
+ return TRUE;
+ }
+
+ if (compare_icons_horizontal_first (container,
+ best_so_far,
+ candidate) < 0)
+ {
+ return TRUE;
+ }
+ }
+
+ return best_so_far == NULL;
+}
+
+static gboolean
+same_column_above_lowest (CajaIconContainer *container,
+ CajaIcon *start_icon,
+ CajaIcon *best_so_far,
+ CajaIcon *candidate,
+ void *data)
+{
+ /* Candidates not on the start column do not qualify. */
+ if (compare_with_start_column (container, candidate) != 0)
+ {
+ return FALSE;
+ }
+
+ /* Candidates that are higher lose out. */
+ if (best_so_far != NULL)
+ {
+ if (compare_icons_vertical_first (container,
+ best_so_far,
+ candidate) > 0)
+ {
+ return FALSE;
+ }
+ }
+
+ /* Candidates below the start do not qualify. */
+ if (compare_icons_vertical_first (container,
+ candidate,
+ start_icon) >= 0)
+ {
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static gboolean
+same_column_below_highest (CajaIconContainer *container,
+ CajaIcon *start_icon,
+ CajaIcon *best_so_far,
+ CajaIcon *candidate,
+ void *data)
+{
+ /* Candidates not on the start column do not qualify. */
+ if (compare_with_start_column (container, candidate) != 0)
+ {
+ return FALSE;
+ }
+
+ /* Candidates that are lower lose out. */
+ if (best_so_far != NULL)
+ {
+ if (compare_icons_vertical_first (container,
+ best_so_far,
+ candidate) < 0)
+ {
+ return FALSE;
+ }
+ }
+
+ /* Candidates above the start do not qualify. */
+ if (compare_icons_vertical_first (container,
+ candidate,
+ start_icon) <= 0)
+ {
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static gboolean
+previous_column_highest (CajaIconContainer *container,
+ CajaIcon *start_icon,
+ CajaIcon *best_so_far,
+ CajaIcon *candidate,
+ void *data)
+{
+ /* sort out icons that are not before the current column */
+ if (compare_with_start_column (container, candidate) <= 0)
+ {
+ return FALSE;
+ }
+
+ if (best_so_far != NULL)
+ {
+ if (compare_icons_horizontal (container,
+ best_so_far,
+ candidate) < 0)
+ {
+ /* candidate is right of the best choice, but left of the current column */
+ return TRUE;
+ }
+
+ if (compare_icons_vertical (container,
+ best_so_far,
+ candidate) > 0)
+ {
+ return TRUE;
+ }
+ }
+
+ return best_so_far == NULL;
+}
+
+
+static gboolean
+next_column_highest (CajaIconContainer *container,
+ CajaIcon *start_icon,
+ CajaIcon *best_so_far,
+ CajaIcon *candidate,
+ void *data)
+{
+ /* sort out icons that are not after the current column */
+ if (compare_with_start_column (container, candidate) >= 0)
+ {
+ return FALSE;
+ }
+
+ if (best_so_far != NULL)
+ {
+ if (compare_icons_horizontal_first (container,
+ best_so_far,
+ candidate) > 0)
+ {
+ /* candidate is left of the best choice, but right of the current column */
+ return TRUE;
+ }
+
+ if (compare_icons_vertical_first (container,
+ best_so_far,
+ candidate) > 0)
+ {
+ return TRUE;
+ }
+ }
+
+ return best_so_far == NULL;
+}
+
+static gboolean
+previous_column_lowest (CajaIconContainer *container,
+ CajaIcon *start_icon,
+ CajaIcon *best_so_far,
+ CajaIcon *candidate,
+ void *data)
+{
+ /* sort out icons that are not before the current column */
+ if (compare_with_start_column (container, candidate) <= 0)
+ {
+ return FALSE;
+ }
+
+ if (best_so_far != NULL)
+ {
+ if (compare_icons_horizontal_first (container,
+ best_so_far,
+ candidate) < 0)
+ {
+ /* candidate is right of the best choice, but left of the current column */
+ return TRUE;
+ }
+
+ if (compare_icons_vertical_first (container,
+ best_so_far,
+ candidate) < 0)
+ {
+ return TRUE;
+ }
+ }
+
+ return best_so_far == NULL;
+}
+
+static gboolean
+last_column_lowest (CajaIconContainer *container,
+ CajaIcon *start_icon,
+ CajaIcon *best_so_far,
+ CajaIcon *candidate,
+ void *data)
+{
+ if (best_so_far == NULL)
+ {
+ return TRUE;
+ }
+ return compare_icons_horizontal_first (container, best_so_far, candidate) < 0;
+}
+
+static gboolean
+closest_in_90_degrees (CajaIconContainer *container,
+ CajaIcon *start_icon,
+ CajaIcon *best_so_far,
+ CajaIcon *candidate,
+ void *data)
+{
+ EelDRect world_rect;
+ int x, y;
+ int dx, dy;
+ int dist;
+ int *best_dist;
+
+
+ world_rect = caja_icon_canvas_item_get_icon_rectangle (candidate->item);
+ eel_canvas_w2c
+ (EEL_CANVAS (container),
+ get_cmp_point_x (container, world_rect),
+ get_cmp_point_y (container, world_rect),
+ &x,
+ &y);
+
+ dx = x - container->details->arrow_key_start_x;
+ dy = y - container->details->arrow_key_start_y;
+
+ switch (container->details->arrow_key_direction)
+ {
+ case GTK_DIR_UP:
+ if (dy > 0 ||
+ ABS(dx) > ABS(dy))
+ {
+ return FALSE;
+ }
+ break;
+ case GTK_DIR_DOWN:
+ if (dy < 0 ||
+ ABS(dx) > ABS(dy))
+ {
+ return FALSE;
+ }
+ break;
+ case GTK_DIR_LEFT:
+ if (dx > 0 ||
+ ABS(dy) > ABS(dx))
+ {
+ return FALSE;
+ }
+ break;
+ case GTK_DIR_RIGHT:
+ if (dx < 0 ||
+ ABS(dy) > ABS(dx))
+ {
+ return FALSE;
+ }
+ break;
+ default:
+ g_assert_not_reached();
+ }
+
+ dist = dx*dx + dy*dy;
+ best_dist = data;
+
+ if (best_so_far == NULL)
+ {
+ *best_dist = dist;
+ return TRUE;
+ }
+
+ if (dist < *best_dist)
+ {
+ *best_dist = dist;
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static EelDRect
+get_rubberband (CajaIcon *icon1,
+ CajaIcon *icon2)
+{
+ EelDRect rect1;
+ EelDRect rect2;
+ EelDRect ret;
+
+ eel_canvas_item_get_bounds (EEL_CANVAS_ITEM (icon1->item),
+ &rect1.x0, &rect1.y0,
+ &rect1.x1, &rect1.y1);
+ eel_canvas_item_get_bounds (EEL_CANVAS_ITEM (icon2->item),
+ &rect2.x0, &rect2.y0,
+ &rect2.x1, &rect2.y1);
+
+ eel_drect_union (&ret, &rect1, &rect2);
+
+ return ret;
+}
+
+static void
+keyboard_move_to (CajaIconContainer *container,
+ CajaIcon *icon,
+ CajaIcon *from,
+ GdkEventKey *event)
+{
+ if (icon == NULL)
+ {
+ return;
+ }
+
+ if (event != NULL &&
+ (event->state & GDK_CONTROL_MASK) != 0 &&
+ (event->state & GDK_SHIFT_MASK) == 0)
+ {
+ /* Move the keyboard focus. Use Control modifier
+ * rather than Alt to avoid Sawfish conflict.
+ */
+ set_keyboard_focus (container, icon);
+ container->details->keyboard_rubberband_start = NULL;
+ }
+ else if (event != NULL &&
+ ((event->state & GDK_CONTROL_MASK) != 0 ||
+ !container->details->auto_layout) &&
+ (event->state & GDK_SHIFT_MASK) != 0)
+ {
+ /* Do rubberband selection */
+ EelDRect rect;
+
+ if (from && !container->details->keyboard_rubberband_start)
+ {
+ set_keyboard_rubberband_start (container, from);
+ }
+
+ set_keyboard_focus (container, icon);
+
+ if (icon && container->details->keyboard_rubberband_start)
+ {
+ rect = get_rubberband (container->details->keyboard_rubberband_start,
+ icon);
+ rubberband_select (container, NULL, &rect);
+ }
+ }
+ else if (event != NULL &&
+ (event->state & GDK_CONTROL_MASK) == 0 &&
+ (event->state & GDK_SHIFT_MASK) != 0)
+ {
+ /* Select range */
+ CajaIcon *start_icon;
+
+ start_icon = container->details->range_selection_base_icon;
+ if (start_icon == NULL || !start_icon->is_selected)
+ {
+ start_icon = icon;
+ container->details->range_selection_base_icon = icon;
+ }
+
+ set_keyboard_focus (container, icon);
+
+ if (select_range (container, start_icon, icon, TRUE))
+ {
+ g_signal_emit (container,
+ signals[SELECTION_CHANGED], 0);
+ }
+ }
+ else
+ {
+ /* Select icons and get rid of the special keyboard focus. */
+ clear_keyboard_focus (container);
+ clear_keyboard_rubberband_start (container);
+
+ container->details->range_selection_base_icon = icon;
+ if (select_one_unselect_others (container, icon))
+ {
+ g_signal_emit (container,
+ signals[SELECTION_CHANGED], 0);
+ }
+ }
+ schedule_keyboard_icon_reveal (container, icon);
+}
+
+static void
+keyboard_home (CajaIconContainer *container,
+ GdkEventKey *event)
+{
+ CajaIcon *from;
+ CajaIcon *to;
+
+ /* Home selects the first icon.
+ * Control-Home sets the keyboard focus to the first icon.
+ */
+
+ from = find_best_selected_icon (container, NULL,
+ rightmost_in_bottom_row,
+ NULL);
+ to = find_best_icon (container, NULL, leftmost_in_top_row, NULL);
+
+ keyboard_move_to (container, to, from, event);
+}
+
+static void
+keyboard_end (CajaIconContainer *container,
+ GdkEventKey *event)
+{
+ CajaIcon *to;
+ CajaIcon *from;
+
+ /* End selects the last icon.
+ * Control-End sets the keyboard focus to the last icon.
+ */
+ from = find_best_selected_icon (container, NULL,
+ leftmost_in_top_row,
+ NULL);
+ to = find_best_icon (container, NULL,
+ caja_icon_container_is_layout_vertical (container) ?
+ last_column_lowest :
+ rightmost_in_bottom_row,
+ NULL);
+
+ keyboard_move_to (container, to, from, event);
+}
+
+static void
+record_arrow_key_start (CajaIconContainer *container,
+ CajaIcon *icon,
+ GtkDirectionType direction)
+{
+ EelDRect world_rect;
+
+ world_rect = caja_icon_canvas_item_get_icon_rectangle (icon->item);
+ eel_canvas_w2c
+ (EEL_CANVAS (container),
+ get_cmp_point_x (container, world_rect),
+ get_cmp_point_y (container, world_rect),
+ &container->details->arrow_key_start_x,
+ &container->details->arrow_key_start_y);
+ container->details->arrow_key_direction = direction;
+}
+
+static void
+keyboard_arrow_key (CajaIconContainer *container,
+ GdkEventKey *event,
+ GtkDirectionType direction,
+ IsBetterIconFunction better_start,
+ IsBetterIconFunction empty_start,
+ IsBetterIconFunction better_destination,
+ IsBetterIconFunction better_destination_fallback_if_no_a11y,
+ IsBetterIconFunction better_destination_fallback_fallback,
+ IsBetterIconFunction better_destination_manual)
+{
+ CajaIcon *from;
+ CajaIcon *to;
+ int data;
+
+ /* Chose the icon to start with.
+ * If we have a keyboard focus, start with it.
+ * Otherwise, use the single selected icon.
+ * If there's multiple selection, use the icon farthest toward the end.
+ */
+
+ from = container->details->keyboard_focus;
+
+ if (from == NULL)
+ {
+ if (has_multiple_selection (container))
+ {
+ if (all_selected (container))
+ {
+ from = find_best_selected_icon
+ (container, NULL,
+ empty_start, NULL);
+ }
+ else
+ {
+ from = find_best_selected_icon
+ (container, NULL,
+ better_start, NULL);
+ }
+ }
+ else
+ {
+ from = get_first_selected_icon (container);
+ }
+ }
+
+ /* If there's no icon, select the icon farthest toward the end.
+ * If there is an icon, select the next icon based on the arrow direction.
+ */
+ if (from == NULL)
+ {
+ to = from = find_best_icon
+ (container, NULL,
+ empty_start, NULL);
+ }
+ else
+ {
+ record_arrow_key_start (container, from, direction);
+
+ to = find_best_icon
+ (container, from,
+ container->details->auto_layout ? better_destination : better_destination_manual,
+ &data);
+
+ /* only wrap around to next/previous row/column if no a11y is used.
+ * Visually impaired people may be easily confused by this.
+ */
+ if (to == NULL &&
+ better_destination_fallback_if_no_a11y != NULL &&
+ ATK_IS_NO_OP_OBJECT (gtk_widget_get_accessible (GTK_WIDGET (container))))
+ {
+ to = find_best_icon
+ (container, from,
+ better_destination_fallback_if_no_a11y,
+ &data);
+ }
+
+ /* With a layout like
+ * 1 2 3
+ * 4
+ * (horizontal layout)
+ *
+ * or
+ *
+ * 1 4
+ * 2
+ * 3
+ * (vertical layout)
+ *
+ * * pressing down for any of 1,2,3 (horizontal layout)
+ * * pressing right for any of 1,2,3 (vertical layout)
+ *
+ * Should select 4.
+ */
+ if (to == NULL &&
+ container->details->auto_layout &&
+ better_destination_fallback_fallback != NULL)
+ {
+ to = find_best_icon
+ (container, from,
+ better_destination_fallback_fallback,
+ &data);
+ }
+
+ if (to == NULL)
+ {
+ to = from;
+ }
+
+ }
+
+ keyboard_move_to (container, to, from, event);
+}
+
+static gboolean
+is_rectangle_selection_event (GdkEventKey *event)
+{
+ return (event->state & GDK_CONTROL_MASK) != 0 &&
+ (event->state & GDK_SHIFT_MASK) != 0;
+}
+
+static void
+keyboard_right (CajaIconContainer *container,
+ GdkEventKey *event)
+{
+ IsBetterIconFunction no_a11y;
+ IsBetterIconFunction next_column_fallback;
+
+ no_a11y = NULL;
+ if (container->details->auto_layout &&
+ !caja_icon_container_is_layout_vertical (container) &&
+ !is_rectangle_selection_event (event))
+ {
+ no_a11y = next_row_leftmost;
+ }
+
+ next_column_fallback = NULL;
+ if (caja_icon_container_is_layout_vertical (container) &&
+ gtk_widget_get_direction (GTK_WIDGET (container)) != GTK_TEXT_DIR_RTL)
+ {
+ next_column_fallback = next_column_bottommost;
+ }
+
+ /* Right selects the next icon in the same row.
+ * Control-Right sets the keyboard focus to the next icon in the same row.
+ */
+ keyboard_arrow_key (container,
+ event,
+ GTK_DIR_RIGHT,
+ rightmost_in_bottom_row,
+ caja_icon_container_is_layout_rtl (container) ?
+ rightmost_in_top_row : leftmost_in_top_row,
+ same_row_right_side_leftmost,
+ no_a11y,
+ next_column_fallback,
+ closest_in_90_degrees);
+}
+
+static void
+keyboard_left (CajaIconContainer *container,
+ GdkEventKey *event)
+{
+ IsBetterIconFunction no_a11y;
+ IsBetterIconFunction previous_column_fallback;
+
+ no_a11y = NULL;
+ if (container->details->auto_layout &&
+ !caja_icon_container_is_layout_vertical (container) &&
+ !is_rectangle_selection_event (event))
+ {
+ no_a11y = previous_row_rightmost;
+ }
+
+ previous_column_fallback = NULL;
+ if (caja_icon_container_is_layout_vertical (container) &&
+ gtk_widget_get_direction (GTK_WIDGET (container)) == GTK_TEXT_DIR_RTL)
+ {
+ previous_column_fallback = previous_column_lowest;
+ }
+
+ /* Left selects the next icon in the same row.
+ * Control-Left sets the keyboard focus to the next icon in the same row.
+ */
+ keyboard_arrow_key (container,
+ event,
+ GTK_DIR_LEFT,
+ rightmost_in_bottom_row,
+ caja_icon_container_is_layout_rtl (container) ?
+ rightmost_in_top_row : leftmost_in_top_row,
+ same_row_left_side_rightmost,
+ no_a11y,
+ previous_column_fallback,
+ closest_in_90_degrees);
+}
+
+static void
+keyboard_down (CajaIconContainer *container,
+ GdkEventKey *event)
+{
+ IsBetterIconFunction no_a11y;
+ IsBetterIconFunction next_row_fallback;
+
+ no_a11y = NULL;
+ if (container->details->auto_layout &&
+ caja_icon_container_is_layout_vertical (container) &&
+ !is_rectangle_selection_event (event))
+ {
+ if (gtk_widget_get_direction (GTK_WIDGET (container)) == GTK_TEXT_DIR_RTL)
+ {
+ no_a11y = previous_column_highest;
+ }
+ else
+ {
+ no_a11y = next_column_highest;
+ }
+ }
+
+ next_row_fallback = NULL;
+ if (!caja_icon_container_is_layout_vertical (container))
+ {
+ if (gtk_widget_get_direction (GTK_WIDGET (container)) == GTK_TEXT_DIR_RTL)
+ {
+ next_row_fallback = next_row_leftmost;
+ }
+ else
+ {
+ next_row_fallback = next_row_rightmost;
+ }
+ }
+
+ /* Down selects the next icon in the same column.
+ * Control-Down sets the keyboard focus to the next icon in the same column.
+ */
+ keyboard_arrow_key (container,
+ event,
+ GTK_DIR_DOWN,
+ rightmost_in_bottom_row,
+ caja_icon_container_is_layout_rtl (container) ?
+ rightmost_in_top_row : leftmost_in_top_row,
+ same_column_below_highest,
+ no_a11y,
+ next_row_fallback,
+ closest_in_90_degrees);
+}
+
+static void
+keyboard_up (CajaIconContainer *container,
+ GdkEventKey *event)
+{
+ IsBetterIconFunction no_a11y;
+
+ no_a11y = NULL;
+ if (container->details->auto_layout &&
+ caja_icon_container_is_layout_vertical (container) &&
+ !is_rectangle_selection_event (event))
+ {
+ if (gtk_widget_get_direction (GTK_WIDGET (container)) == GTK_TEXT_DIR_RTL)
+ {
+ no_a11y = next_column_bottommost;
+ }
+ else
+ {
+ no_a11y = previous_column_lowest;
+ }
+ }
+
+ /* Up selects the next icon in the same column.
+ * Control-Up sets the keyboard focus to the next icon in the same column.
+ */
+ keyboard_arrow_key (container,
+ event,
+ GTK_DIR_UP,
+ rightmost_in_bottom_row,
+ caja_icon_container_is_layout_rtl (container) ?
+ rightmost_in_top_row : leftmost_in_top_row,
+ same_column_above_lowest,
+ no_a11y,
+ NULL,
+ closest_in_90_degrees);
+}
+
+static void
+keyboard_space (CajaIconContainer *container,
+ GdkEventKey *event)
+{
+ CajaIcon *icon;
+
+ if (!has_selection (container) &&
+ container->details->keyboard_focus != NULL)
+ {
+ keyboard_move_to (container,
+ container->details->keyboard_focus,
+ NULL, NULL);
+ }
+ else if ((event->state & GDK_CONTROL_MASK) != 0 &&
+ (event->state & GDK_SHIFT_MASK) == 0)
+ {
+ /* Control-space toggles the selection state of the current icon. */
+ if (container->details->keyboard_focus != NULL)
+ {
+ icon_toggle_selected (container, container->details->keyboard_focus);
+ g_signal_emit (container, signals[SELECTION_CHANGED], 0);
+ if (container->details->keyboard_focus->is_selected)
+ {
+ container->details->range_selection_base_icon = container->details->keyboard_focus;
+ }
+ }
+ else
+ {
+ icon = find_best_selected_icon (container,
+ NULL,
+ leftmost_in_top_row,
+ NULL);
+ if (icon == NULL)
+ {
+ icon = find_best_icon (container,
+ NULL,
+ leftmost_in_top_row,
+ NULL);
+ }
+ if (icon != NULL)
+ {
+ set_keyboard_focus (container, icon);
+ }
+ }
+ }
+ else if ((event->state & GDK_SHIFT_MASK) != 0)
+ {
+ activate_selected_items_alternate (container, NULL);
+ }
+ else
+ {
+ activate_selected_items (container);
+ }
+}
+
+/* look for the first icon that matches the longest part of a given
+ * search pattern
+ */
+typedef struct
+{
+ gunichar *name;
+ int last_match_length;
+} BestNameMatch;
+
+#ifndef TAB_NAVIGATION_DISABLED
+static void
+select_previous_or_next_icon (CajaIconContainer *container,
+ gboolean next,
+ GdkEventKey *event)
+{
+ CajaIcon *icon;
+ const GList *item;
+
+ item = NULL;
+ /* Chose the icon to start with.
+ * If we have a keyboard focus, start with it.
+ * Otherwise, use the single selected icon.
+ */
+ icon = container->details->keyboard_focus;
+ if (icon == NULL)
+ {
+ icon = get_first_selected_icon (container);
+ }
+
+ if (icon != NULL)
+ {
+ /* must have at least @icon in the list */
+ g_assert (container->details->icons != NULL);
+ item = g_list_find (container->details->icons, icon);
+ g_assert (item != NULL);
+
+ item = next ? item->next : item->prev;
+ if (item == NULL)
+ {
+ item = next ? g_list_first (container->details->icons) : g_list_last (container->details->icons);
+ }
+
+ }
+ else if (container->details->icons != NULL)
+ {
+ /* no selection yet, pick the first or last item to select */
+ item = next ? g_list_first (container->details->icons) : g_list_last (container->details->icons);
+ }
+
+ icon = (item != NULL) ? item->data : NULL;
+
+ if (icon != NULL)
+ {
+ keyboard_move_to (container, icon, NULL, event);
+ }
+}
+#endif
+
+/* GtkObject methods. */
+
+static void
+destroy (GtkObject *object)
+{
+ CajaIconContainer *container;
+
+ container = CAJA_ICON_CONTAINER (object);
+
+ caja_icon_container_clear (container);
+
+ if (container->details->rubberband_info.timer_id != 0)
+ {
+ g_source_remove (container->details->rubberband_info.timer_id);
+ container->details->rubberband_info.timer_id = 0;
+ }
+
+ if (container->details->idle_id != 0)
+ {
+ g_source_remove (container->details->idle_id);
+ container->details->idle_id = 0;
+ }
+
+ if (container->details->stretch_idle_id != 0)
+ {
+ g_source_remove (container->details->stretch_idle_id);
+ container->details->stretch_idle_id = 0;
+ }
+
+ if (container->details->align_idle_id != 0)
+ {
+ g_source_remove (container->details->align_idle_id);
+ container->details->align_idle_id = 0;
+ }
+
+ if (container->details->selection_changed_id != 0)
+ {
+ g_source_remove (container->details->selection_changed_id);
+ container->details->selection_changed_id = 0;
+ }
+
+ if (container->details->size_allocation_count_id != 0)
+ {
+ g_source_remove (container->details->size_allocation_count_id);
+ container->details->size_allocation_count_id = 0;
+ }
+
+ /* destroy interactive search dialog */
+ if (container->details->search_window)
+ {
+ gtk_widget_destroy (container->details->search_window);
+ container->details->search_window = NULL;
+ container->details->search_entry = NULL;
+ if (container->details->typeselect_flush_timeout)
+ {
+ g_source_remove (container->details->typeselect_flush_timeout);
+ container->details->typeselect_flush_timeout = 0;
+ }
+ }
+
+
+ GTK_OBJECT_CLASS (caja_icon_container_parent_class)->destroy (object);
+}
+
+static void
+finalize (GObject *object)
+{
+ CajaIconContainerDetails *details;
+
+ details = CAJA_ICON_CONTAINER (object)->details;
+
+ eel_preferences_remove_callback (CAJA_PREFERENCES_THEME,
+ caja_icon_container_theme_changed,
+ object);
+
+ g_hash_table_destroy (details->icon_set);
+ details->icon_set = NULL;
+
+ g_free (details->font);
+
+ if (details->a11y_item_action_queue != NULL)
+ {
+ while (!g_queue_is_empty (details->a11y_item_action_queue))
+ {
+ g_free (g_queue_pop_head (details->a11y_item_action_queue));
+ }
+ g_queue_free (details->a11y_item_action_queue);
+ }
+ if (details->a11y_item_action_idle_handler != 0)
+ {
+ g_source_remove (details->a11y_item_action_idle_handler);
+ }
+
+ g_free (details);
+
+ G_OBJECT_CLASS (caja_icon_container_parent_class)->finalize (object);
+}
+
+/* GtkWidget methods. */
+
+static void
+size_request (GtkWidget *widget,
+ GtkRequisition *requisition)
+{
+ GTK_WIDGET_CLASS (caja_icon_container_parent_class)->size_request (widget, requisition);
+ requisition->width = 1;
+ requisition->height = 1;
+}
+
+static gboolean
+clear_size_allocation_count (gpointer data)
+{
+ CajaIconContainer *container;
+
+ container = CAJA_ICON_CONTAINER (data);
+
+ container->details->size_allocation_count_id = 0;
+ container->details->size_allocation_count = 0;
+
+ return FALSE;
+}
+
+static void
+size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation)
+{
+ CajaIconContainer *container;
+ gboolean need_layout_redone;
+ GtkAllocation wid_allocation;
+
+ container = CAJA_ICON_CONTAINER (widget);
+
+ need_layout_redone = !container->details->has_been_allocated;
+ gtk_widget_get_allocation (widget, &wid_allocation);
+
+ if (allocation->width != wid_allocation.width)
+ {
+ need_layout_redone = TRUE;
+ }
+
+ if (allocation->height != wid_allocation.height)
+ {
+ need_layout_redone = TRUE;
+ }
+
+ /* Under some conditions we can end up in a loop when size allocating.
+ * This happens when the icons don't fit without a scrollbar, but fits
+ * when a scrollbar is added (bug #129963 for details).
+ * We keep track of this looping by increasing a counter in size_allocate
+ * and clearing it in a high-prio idle (the only way to detect the loop is
+ * done).
+ * When we've done at more than two iterations (with/without scrollbar)
+ * we terminate this looping by not redoing the layout when the width
+ * is wider than the current one (i.e when removing the scrollbar).
+ */
+ if (container->details->size_allocation_count_id == 0)
+ {
+ container->details->size_allocation_count_id =
+ g_idle_add_full (G_PRIORITY_HIGH,
+ clear_size_allocation_count,
+ container, NULL);
+ }
+ container->details->size_allocation_count++;
+ if (container->details->size_allocation_count > 2 &&
+ allocation->width >= wid_allocation.width)
+ {
+ need_layout_redone = FALSE;
+ }
+
+ GTK_WIDGET_CLASS (caja_icon_container_parent_class)->size_allocate (widget, allocation);
+
+ container->details->has_been_allocated = TRUE;
+
+ if (need_layout_redone)
+ {
+ redo_layout (container);
+ }
+}
+
+static void
+realize (GtkWidget *widget)
+{
+ GdkBitmap *stipple;
+ GtkAdjustment *vadj, *hadj;
+ CajaIconContainer *container;
+
+ GTK_WIDGET_CLASS (caja_icon_container_parent_class)->realize (widget);
+
+ container = CAJA_ICON_CONTAINER (widget);
+
+ /* Ensure that the desktop window is native so the background
+ set on it is drawn by X. */
+ if (container->details->is_desktop)
+ {
+ gdk_x11_drawable_get_xid (gtk_layout_get_bin_window (GTK_LAYOUT (widget)));
+ }
+
+ /* Set up DnD. */
+ caja_icon_dnd_init (container, NULL);
+
+ setup_label_gcs (container);
+
+ stipple = eel_stipple_bitmap_for_screen
+ (gdk_drawable_get_screen (GDK_DRAWABLE (gtk_widget_get_window (widget))));
+
+ caja_icon_dnd_set_stipple (container, stipple);
+
+ hadj = gtk_layout_get_hadjustment (GTK_LAYOUT (widget));
+ g_signal_connect (hadj, "value_changed",
+ G_CALLBACK (handle_hadjustment_changed), widget);
+
+ vadj = gtk_layout_get_vadjustment (GTK_LAYOUT (widget));
+ g_signal_connect (vadj, "value_changed",
+ G_CALLBACK (handle_vadjustment_changed), widget);
+
+}
+
+static void
+unrealize (GtkWidget *widget)
+{
+ int i;
+ CajaIconContainer *container;
+
+ container = CAJA_ICON_CONTAINER (widget);
+
+ for (i = 0; i < LAST_LABEL_COLOR; i++)
+ {
+ if (container->details->label_gcs [i])
+ {
+ g_object_unref (container->details->label_gcs [i]);
+ container->details->label_gcs [i] = NULL;
+ }
+ }
+
+ caja_icon_dnd_fini (container);
+
+ if (container->details->typeselect_flush_timeout)
+ {
+ g_source_remove (container->details->typeselect_flush_timeout);
+ container->details->typeselect_flush_timeout = 0;
+ }
+
+ GTK_WIDGET_CLASS (caja_icon_container_parent_class)->unrealize (widget);
+}
+
+static void
+style_set (GtkWidget *widget,
+ GtkStyle *previous_style)
+{
+ CajaIconContainer *container;
+ gboolean frame_text;
+
+ container = CAJA_ICON_CONTAINER (widget);
+
+ gtk_widget_style_get (GTK_WIDGET (container),
+ "frame_text", &frame_text,
+ NULL);
+
+ container->details->use_drop_shadows = container->details->drop_shadows_requested && !frame_text;
+
+ caja_icon_container_theme_changed (CAJA_ICON_CONTAINER (widget));
+
+ if (gtk_widget_get_realized (widget))
+ {
+ invalidate_label_sizes (container);
+ caja_icon_container_request_update_all (container);
+ }
+
+ /* Don't chain up to parent, because that sets the background of the window and we're doing
+ that ourself with some delay, so this would cause flickering */
+}
+
+static gboolean
+button_press_event (GtkWidget *widget,
+ GdkEventButton *event)
+{
+ CajaIconContainer *container;
+ gboolean selection_changed;
+ gboolean return_value;
+ gboolean clicked_on_icon;
+
+ container = CAJA_ICON_CONTAINER (widget);
+ container->details->button_down_time = event->time;
+
+ /* Forget about the old keyboard selection now that we've started mousing. */
+ clear_keyboard_focus (container);
+ clear_keyboard_rubberband_start (container);
+
+ if (event->type == GDK_2BUTTON_PRESS || event->type == GDK_3BUTTON_PRESS)
+ {
+ /* We use our own double-click detection. */
+ return TRUE;
+ }
+
+ /* Invoke the canvas event handler and see if an item picks up the event. */
+ clicked_on_icon = GTK_WIDGET_CLASS (caja_icon_container_parent_class)->button_press_event (widget, event);
+
+ /* Move focus to icon container, unless we're still renaming (to avoid exiting
+ * renaming mode)
+ */
+ if (!gtk_widget_has_focus (widget) && !(is_renaming (container) || is_renaming_pending (container)))
+ {
+ gtk_widget_grab_focus (widget);
+ }
+
+ if (clicked_on_icon)
+ {
+ return TRUE;
+ }
+
+ if (event->button == DRAG_BUTTON &&
+ event->type == GDK_BUTTON_PRESS)
+ {
+ /* Clear the last click icon for double click */
+ container->details->double_click_icon[1] = container->details->double_click_icon[0];
+ container->details->double_click_icon[0] = NULL;
+ }
+
+ /* Button 1 does rubber banding. */
+ if (event->button == RUBBERBAND_BUTTON)
+ {
+ if (! button_event_modifies_selection (event))
+ {
+ selection_changed = unselect_all (container);
+ if (selection_changed)
+ {
+ g_signal_emit (container,
+ signals[SELECTION_CHANGED], 0);
+ }
+ }
+
+ start_rubberbanding (container, event);
+ return TRUE;
+ }
+
+ /* Prevent multi-button weirdness such as bug 6181 */
+ if (container->details->rubberband_info.active)
+ {
+ return TRUE;
+ }
+
+ /* Button 2 may be passed to the window manager. */
+ if (event->button == MIDDLE_BUTTON)
+ {
+ selection_changed = unselect_all (container);
+ if (selection_changed)
+ {
+ g_signal_emit (container, signals[SELECTION_CHANGED], 0);
+ }
+ g_signal_emit (widget, signals[MIDDLE_CLICK], 0, event);
+ return TRUE;
+ }
+
+ /* Button 3 does a contextual menu. */
+ if (event->button == CONTEXTUAL_MENU_BUTTON)
+ {
+ end_renaming_mode (container, TRUE);
+ selection_changed = unselect_all (container);
+ if (selection_changed)
+ {
+ g_signal_emit (container, signals[SELECTION_CHANGED], 0);
+ }
+ g_signal_emit (widget, signals[CONTEXT_CLICK_BACKGROUND], 0, event);
+ return TRUE;
+ }
+
+ /* Otherwise, we emit a button_press message. */
+ g_signal_emit (widget,
+ signals[BUTTON_PRESS], 0, event,
+ &return_value);
+ return return_value;
+}
+
+static void
+caja_icon_container_did_not_drag (CajaIconContainer *container,
+ GdkEventButton *event)
+{
+ CajaIconContainerDetails *details;
+ gboolean selection_changed;
+ static gint64 last_click_time = 0;
+ static gint click_count = 0;
+ gint double_click_time;
+ gint64 current_time;
+
+ details = container->details;
+
+ if (details->icon_selected_on_button_down &&
+ ((event->state & GDK_CONTROL_MASK) != 0 ||
+ (event->state & GDK_SHIFT_MASK) == 0))
+ {
+ if (button_event_modifies_selection (event))
+ {
+ details->range_selection_base_icon = NULL;
+ icon_toggle_selected (container, details->drag_icon);
+ g_signal_emit (container,
+ signals[SELECTION_CHANGED], 0);
+ }
+ else
+ {
+ details->range_selection_base_icon = details->drag_icon;
+ selection_changed = select_one_unselect_others
+ (container, details->drag_icon);
+
+ if (selection_changed)
+ {
+ g_signal_emit (container,
+ signals[SELECTION_CHANGED], 0);
+ }
+ }
+ }
+
+ if (details->drag_icon != NULL &&
+ (details->single_click_mode ||
+ event->button == MIDDLE_BUTTON))
+ {
+ /* Determine click count */
+ g_object_get (G_OBJECT (gtk_widget_get_settings (GTK_WIDGET (container))),
+ "gtk-double-click-time", &double_click_time,
+ NULL);
+ current_time = eel_get_system_time ();
+ if (current_time - last_click_time < double_click_time * 1000)
+ {
+ click_count++;
+ }
+ else
+ {
+ click_count = 0;
+ }
+
+ /* Stash time for next compare */
+ last_click_time = current_time;
+
+ /* If single-click mode, activate the selected icons, unless modifying
+ * the selection or pressing for a very long time, or double clicking.
+ */
+
+
+ if (click_count == 0 &&
+ event->time - details->button_down_time < MAX_CLICK_TIME &&
+ ! button_event_modifies_selection (event))
+ {
+
+ /* It's a tricky UI issue whether this should activate
+ * just the clicked item (as if it were a link), or all
+ * the selected items (as if you were issuing an "activate
+ * selection" command). For now, we're trying the activate
+ * entire selection version to see how it feels. Note that
+ * CajaList goes the other way because its "links" seem
+ * much more link-like.
+ */
+ if (event->button == MIDDLE_BUTTON)
+ {
+ activate_selected_items_alternate (container, NULL);
+ }
+ else
+ {
+ activate_selected_items (container);
+ }
+ }
+ }
+}
+
+static gboolean
+clicked_within_double_click_interval (CajaIconContainer *container)
+{
+ static gint64 last_click_time = 0;
+ static gint click_count = 0;
+ gint double_click_time;
+ gint64 current_time;
+
+ /* Determine click count */
+ g_object_get (G_OBJECT (gtk_widget_get_settings (GTK_WIDGET (container))),
+ "gtk-double-click-time", &double_click_time,
+ NULL);
+ current_time = eel_get_system_time ();
+ if (current_time - last_click_time < double_click_time * 1000)
+ {
+ click_count++;
+ }
+ else
+ {
+ click_count = 0;
+ }
+
+ /* Stash time for next compare */
+ last_click_time = current_time;
+
+ /* Only allow double click */
+ return (click_count == 1);
+}
+
+static void
+clear_drag_state (CajaIconContainer *container)
+{
+ container->details->drag_icon = NULL;
+ container->details->drag_state = DRAG_STATE_INITIAL;
+}
+
+static gboolean
+start_stretching (CajaIconContainer *container)
+{
+ CajaIconContainerDetails *details;
+ CajaIcon *icon;
+ EelDPoint world_point;
+ GtkWidget *toplevel;
+ GtkCornerType corner;
+ GdkCursor *cursor;
+
+ details = container->details;
+ icon = details->stretch_icon;
+
+ /* Check if we hit the stretch handles. */
+ world_point.x = details->drag_x;
+ world_point.y = details->drag_y;
+ if (!caja_icon_canvas_item_hit_test_stretch_handles (icon->item, world_point, &corner))
+ {
+ return FALSE;
+ }
+
+ switch (corner)
+ {
+ case GTK_CORNER_TOP_LEFT:
+ cursor = gdk_cursor_new (GDK_TOP_LEFT_CORNER);
+ break;
+ case GTK_CORNER_BOTTOM_LEFT:
+ cursor = gdk_cursor_new (GDK_BOTTOM_LEFT_CORNER);
+ break;
+ case GTK_CORNER_TOP_RIGHT:
+ cursor = gdk_cursor_new (GDK_TOP_RIGHT_CORNER);
+ break;
+ case GTK_CORNER_BOTTOM_RIGHT:
+ cursor = gdk_cursor_new (GDK_BOTTOM_RIGHT_CORNER);
+ break;
+ default:
+ cursor = NULL;
+ break;
+ }
+ /* Set up the dragging. */
+ details->drag_state = DRAG_STATE_STRETCH;
+ eel_canvas_w2c (EEL_CANVAS (container),
+ details->drag_x,
+ details->drag_y,
+ &details->stretch_start.pointer_x,
+ &details->stretch_start.pointer_y);
+ eel_canvas_w2c (EEL_CANVAS (container),
+ icon->x, icon->y,
+ &details->stretch_start.icon_x,
+ &details->stretch_start.icon_y);
+ icon_get_size (container, icon,
+ &details->stretch_start.icon_size);
+
+ eel_canvas_item_grab (EEL_CANVAS_ITEM (icon->item),
+ (GDK_POINTER_MOTION_MASK
+ | GDK_BUTTON_RELEASE_MASK),
+ cursor,
+ GDK_CURRENT_TIME);
+ if (cursor)
+ gdk_cursor_unref (cursor);
+
+ /* Ensure the window itself is focused.. */
+ toplevel = gtk_widget_get_toplevel (GTK_WIDGET (container));
+ if (toplevel != NULL && gtk_widget_get_realized (toplevel))
+ {
+ eel_gdk_window_focus (gtk_widget_get_window (toplevel), GDK_CURRENT_TIME);
+ }
+
+ return TRUE;
+}
+
+static gboolean
+update_stretch_at_idle (CajaIconContainer *container)
+{
+ CajaIconContainerDetails *details;
+ CajaIcon *icon;
+ double world_x, world_y;
+ StretchState stretch_state;
+
+ details = container->details;
+ icon = details->stretch_icon;
+
+ if (icon == NULL)
+ {
+ container->details->stretch_idle_id = 0;
+ return FALSE;
+ }
+
+ eel_canvas_w2c (EEL_CANVAS (container),
+ details->world_x, details->world_y,
+ &stretch_state.pointer_x, &stretch_state.pointer_y);
+
+ compute_stretch (&details->stretch_start,
+ &stretch_state);
+
+ eel_canvas_c2w (EEL_CANVAS (container),
+ stretch_state.icon_x, stretch_state.icon_y,
+ &world_x, &world_y);
+
+ icon_set_position (icon, world_x, world_y);
+ icon_set_size (container, icon, stretch_state.icon_size, FALSE, FALSE);
+
+ container->details->stretch_idle_id = 0;
+
+ return FALSE;
+}
+
+static void
+continue_stretching (CajaIconContainer *container,
+ double world_x, double world_y)
+{
+
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+ container->details->world_x = world_x;
+ container->details->world_y = world_y;
+
+ if (container->details->stretch_idle_id == 0)
+ {
+ container->details->stretch_idle_id = g_idle_add ((GtkFunction) update_stretch_at_idle, container);
+ }
+}
+
+static gboolean
+keyboard_stretching (CajaIconContainer *container,
+ GdkEventKey *event)
+{
+ CajaIcon *icon;
+ guint size;
+
+ icon = container->details->stretch_icon;
+
+ if (icon == NULL || !icon->is_selected)
+ {
+ return FALSE;
+ }
+
+ icon_get_size (container, icon, &size);
+
+ switch (event->keyval)
+ {
+ case GDK_equal:
+ case GDK_plus:
+ case GDK_KP_Add:
+ icon_set_size (container, icon, size + 5, FALSE, FALSE);
+ break;
+ case GDK_minus:
+ case GDK_KP_Subtract:
+ icon_set_size (container, icon, size - 5, FALSE, FALSE);
+ break;
+ case GDK_0:
+ case GDK_KP_0:
+ caja_icon_container_move_icon (container, icon,
+ icon->x, icon->y,
+ 1.0,
+ FALSE, TRUE, TRUE);
+ break;
+ }
+
+ return TRUE;
+}
+
+static void
+ungrab_stretch_icon (CajaIconContainer *container)
+{
+ eel_canvas_item_ungrab (EEL_CANVAS_ITEM (container->details->stretch_icon->item),
+ GDK_CURRENT_TIME);
+}
+
+static void
+end_stretching (CajaIconContainer *container,
+ double world_x, double world_y)
+{
+ CajaIconPosition position;
+ CajaIcon *icon;
+
+ continue_stretching (container, world_x, world_y);
+ ungrab_stretch_icon (container);
+
+ /* now that we're done stretching, update the icon's position */
+
+ icon = container->details->drag_icon;
+ if (caja_icon_container_is_layout_rtl (container))
+ {
+ position.x = icon->saved_ltr_x = get_mirror_x_position (container, icon, icon->x);
+ }
+ else
+ {
+ position.x = icon->x;
+ }
+ position.y = icon->y;
+ position.scale = icon->scale;
+ g_signal_emit (container,
+ signals[ICON_POSITION_CHANGED], 0,
+ icon->data, &position);
+
+ clear_drag_state (container);
+ redo_layout (container);
+}
+
+static gboolean
+undo_stretching (CajaIconContainer *container)
+{
+ CajaIcon *stretched_icon;
+
+ stretched_icon = container->details->stretch_icon;
+
+ if (stretched_icon == NULL)
+ {
+ return FALSE;
+ }
+
+ if (container->details->drag_state == DRAG_STATE_STRETCH)
+ {
+ ungrab_stretch_icon (container);
+ clear_drag_state (container);
+ }
+ caja_icon_canvas_item_set_show_stretch_handles
+ (stretched_icon->item, FALSE);
+
+ icon_set_position (stretched_icon,
+ container->details->stretch_initial_x,
+ container->details->stretch_initial_y);
+ icon_set_size (container,
+ stretched_icon,
+ container->details->stretch_initial_size,
+ TRUE,
+ TRUE);
+
+ container->details->stretch_icon = NULL;
+ emit_stretch_ended (container, stretched_icon);
+ redo_layout (container);
+
+ return TRUE;
+}
+
+static gboolean
+button_release_event (GtkWidget *widget,
+ GdkEventButton *event)
+{
+ CajaIconContainer *container;
+ CajaIconContainerDetails *details;
+ double world_x, world_y;
+
+ container = CAJA_ICON_CONTAINER (widget);
+ details = container->details;
+
+ if (event->button == RUBBERBAND_BUTTON && details->rubberband_info.active)
+ {
+ stop_rubberbanding (container, event->time);
+ return TRUE;
+ }
+
+ if (event->button == details->drag_button)
+ {
+ details->drag_button = 0;
+
+ switch (details->drag_state)
+ {
+ case DRAG_STATE_MOVE_OR_COPY:
+ if (!details->drag_started)
+ {
+ caja_icon_container_did_not_drag (container, event);
+ }
+ else
+ {
+ caja_icon_dnd_end_drag (container);
+ caja_debug_log (FALSE, CAJA_DEBUG_LOG_DOMAIN_USER,
+ "end drag from icon container");
+ }
+ break;
+ case DRAG_STATE_STRETCH:
+ eel_canvas_window_to_world
+ (EEL_CANVAS (container), event->x, event->y, &world_x, &world_y);
+ end_stretching (container, world_x, world_y);
+ break;
+ default:
+ break;
+ }
+
+ clear_drag_state (container);
+ return TRUE;
+ }
+
+ return GTK_WIDGET_CLASS (caja_icon_container_parent_class)->button_release_event (widget, event);
+}
+
+static int
+motion_notify_event (GtkWidget *widget,
+ GdkEventMotion *event)
+{
+ CajaIconContainer *container;
+ CajaIconContainerDetails *details;
+ double world_x, world_y;
+ int canvas_x, canvas_y;
+ GdkDragAction actions;
+
+ container = CAJA_ICON_CONTAINER (widget);
+ details = container->details;
+
+ if (details->drag_button != 0)
+ {
+ switch (details->drag_state)
+ {
+ case DRAG_STATE_MOVE_OR_COPY:
+ if (details->drag_started)
+ {
+ break;
+ }
+
+ eel_canvas_window_to_world
+ (EEL_CANVAS (container), event->x, event->y, &world_x, &world_y);
+
+ if (gtk_drag_check_threshold (widget,
+ details->drag_x,
+ details->drag_y,
+ world_x,
+ world_y))
+ {
+ details->drag_started = TRUE;
+ details->drag_state = DRAG_STATE_MOVE_OR_COPY;
+
+ end_renaming_mode (container, TRUE);
+
+ eel_canvas_w2c (EEL_CANVAS (container),
+ details->drag_x,
+ details->drag_y,
+ &canvas_x,
+ &canvas_y);
+
+ actions = GDK_ACTION_COPY
+ | GDK_ACTION_LINK
+ | GDK_ACTION_ASK;
+
+ if (container->details->drag_allow_moves)
+ {
+ actions |= GDK_ACTION_MOVE;
+ }
+
+ caja_icon_dnd_begin_drag (container,
+ actions,
+ details->drag_button,
+ event,
+ canvas_x,
+ canvas_y);
+ caja_debug_log (FALSE, CAJA_DEBUG_LOG_DOMAIN_USER,
+ "begin drag from icon container");
+ }
+ break;
+ case DRAG_STATE_STRETCH:
+ eel_canvas_window_to_world
+ (EEL_CANVAS (container), event->x, event->y, &world_x, &world_y);
+ continue_stretching (container, world_x, world_y);
+ break;
+ default:
+ break;
+ }
+ }
+
+ return GTK_WIDGET_CLASS (caja_icon_container_parent_class)->motion_notify_event (widget, event);
+}
+
+static void
+caja_icon_container_search_position_func (CajaIconContainer *container,
+ GtkWidget *search_dialog)
+{
+ gint x, y;
+ gint cont_x, cont_y;
+ gint cont_width, cont_height;
+ GdkWindow *cont_window;
+ GdkScreen *screen;
+ GtkRequisition requisition;
+ gint monitor_num;
+ GdkRectangle monitor;
+
+
+ cont_window = gtk_widget_get_window (GTK_WIDGET (container));
+ screen = gdk_drawable_get_screen (cont_window);
+
+ monitor_num = gdk_screen_get_monitor_at_window (screen, cont_window);
+ gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
+
+ gtk_widget_realize (search_dialog);
+
+ gdk_window_get_origin (cont_window, &cont_x, &cont_y);
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+ cont_width = gdk_window_get_width(GDK_WINDOW(cont_window));
+ cont_height = gdk_window_get_height(GDK_WINDOW(cont_window));
+#else
+ gdk_drawable_get_size(cont_window, &cont_width, &cont_height);
+#endif
+
+ gtk_widget_size_request (search_dialog, &requisition);
+
+ if (cont_x + cont_width - requisition.width > gdk_screen_get_width (screen))
+ {
+ x = gdk_screen_get_width (screen) - requisition.width;
+ }
+ else if (cont_x + cont_width - requisition.width < 0)
+ {
+ x = 0;
+ }
+ else
+ {
+ x = cont_x + cont_width - requisition.width;
+ }
+
+ if (cont_y + cont_height > gdk_screen_get_height (screen))
+ {
+ y = gdk_screen_get_height (screen) - requisition.height;
+ }
+ else if (cont_y + cont_height < 0) /* isn't really possible ... */
+ {
+ y = 0;
+ }
+ else
+ {
+ y = cont_y + cont_height;
+ }
+
+ gtk_window_move (GTK_WINDOW (search_dialog), x, y);
+}
+
+static gboolean
+caja_icon_container_real_search_enable_popdown (gpointer data)
+{
+ CajaIconContainer *container = (CajaIconContainer *)data;
+
+ container->details->disable_popdown = FALSE;
+
+ g_object_unref (container);
+
+ return FALSE;
+}
+
+static void
+caja_icon_container_search_enable_popdown (GtkWidget *widget,
+ gpointer data)
+{
+ CajaIconContainer *container = (CajaIconContainer *) data;
+
+ g_object_ref (container);
+ g_timeout_add (200, caja_icon_container_real_search_enable_popdown, data);
+}
+
+static void
+caja_icon_container_search_disable_popdown (GtkEntry *entry,
+ GtkMenu *menu,
+ gpointer data)
+{
+ CajaIconContainer *container = (CajaIconContainer *) data;
+
+ container->details->disable_popdown = TRUE;
+ g_signal_connect (menu, "hide",
+ G_CALLBACK (caja_icon_container_search_enable_popdown),
+ data);
+}
+
+/* Cut and paste from gtkwindow.c */
+static void
+send_focus_change (GtkWidget *widget, gboolean in)
+{
+ GdkEvent *fevent;
+
+ fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+
+ g_object_ref (widget);
+ ((GdkEventFocus *) fevent)->in = in;
+
+ gtk_widget_send_focus_change (widget, fevent);
+
+ fevent->focus_change.type = GDK_FOCUS_CHANGE;
+ fevent->focus_change.window = g_object_ref (gtk_widget_get_window (widget));
+ fevent->focus_change.in = in;
+
+ gtk_widget_event (widget, fevent);
+
+ g_object_notify (G_OBJECT (widget), "has-focus");
+
+ g_object_unref (widget);
+ gdk_event_free (fevent);
+}
+
+static void
+caja_icon_container_search_dialog_hide (GtkWidget *search_dialog,
+ CajaIconContainer *container)
+{
+ if (container->details->disable_popdown)
+ {
+ return;
+ }
+
+ if (container->details->search_entry_changed_id)
+ {
+ g_signal_handler_disconnect (container->details->search_entry,
+ container->details->search_entry_changed_id);
+ container->details->search_entry_changed_id = 0;
+ }
+ if (container->details->typeselect_flush_timeout)
+ {
+ g_source_remove (container->details->typeselect_flush_timeout);
+ container->details->typeselect_flush_timeout = 0;
+ }
+
+ /* send focus-in event */
+ send_focus_change (GTK_WIDGET (container->details->search_entry), FALSE);
+ gtk_widget_hide (search_dialog);
+ gtk_entry_set_text (GTK_ENTRY (container->details->search_entry), "");
+}
+
+static gboolean
+caja_icon_container_search_entry_flush_timeout (CajaIconContainer *container)
+{
+ caja_icon_container_search_dialog_hide (container->details->search_window, container);
+
+ return TRUE;
+}
+
+/* Because we're visible but offscreen, we just set a flag in the preedit
+ * callback.
+ */
+static void
+caja_icon_container_search_preedit_changed (GtkEntry *entry,
+ CajaIconContainer *container)
+{
+ container->details->imcontext_changed = 1;
+ if (container->details->typeselect_flush_timeout)
+ {
+ g_source_remove (container->details->typeselect_flush_timeout);
+ container->details->typeselect_flush_timeout =
+ g_timeout_add_seconds (CAJA_ICON_CONTAINER_SEARCH_DIALOG_TIMEOUT,
+ (GSourceFunc) caja_icon_container_search_entry_flush_timeout,
+ container);
+ }
+}
+
+static void
+caja_icon_container_search_activate (GtkEntry *entry,
+ CajaIconContainer *container)
+{
+ caja_icon_container_search_dialog_hide (container->details->search_window,
+ container);
+
+ activate_selected_items (container);
+}
+
+static gboolean
+caja_icon_container_search_delete_event (GtkWidget *widget,
+ GdkEventAny *event,
+ CajaIconContainer *container)
+{
+ g_assert (GTK_IS_WIDGET (widget));
+
+ caja_icon_container_search_dialog_hide (widget, container);
+
+ return TRUE;
+}
+
+static gboolean
+caja_icon_container_search_button_press_event (GtkWidget *widget,
+ GdkEventButton *event,
+ CajaIconContainer *container)
+{
+ g_assert (GTK_IS_WIDGET (widget));
+
+ caja_icon_container_search_dialog_hide (widget, container);
+
+ if (event->window == gtk_layout_get_bin_window (GTK_LAYOUT (container)))
+ {
+ button_press_event (GTK_WIDGET (container), event);
+ }
+
+ return TRUE;
+}
+
+static void
+caja_icon_container_get_icon_text (CajaIconContainer *container,
+ CajaIconData *data,
+ char **editable_text,
+ char **additional_text,
+ gboolean include_invisible)
+{
+ CajaIconContainerClass *klass;
+
+ klass = CAJA_ICON_CONTAINER_GET_CLASS (container);
+ g_assert (klass->get_icon_text != NULL);
+
+ klass->get_icon_text (container, data, editable_text, additional_text, include_invisible);
+}
+
+static gboolean
+caja_icon_container_search_iter (CajaIconContainer *container,
+ const char *key, gint n)
+{
+ GList *p;
+ CajaIcon *icon;
+ char *name;
+ int count;
+ char *normalized_key, *case_normalized_key;
+ char *normalized_name, *case_normalized_name;
+
+ g_assert (key != NULL);
+ g_assert (n >= 1);
+
+ normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
+ if (!normalized_key)
+ {
+ return FALSE;
+ }
+ case_normalized_key = g_utf8_casefold (normalized_key, -1);
+ g_free (normalized_key);
+ if (!case_normalized_key)
+ {
+ return FALSE;
+ }
+
+ icon = NULL;
+ name = NULL;
+ count = 0;
+ for (p = container->details->icons; p != NULL && count != n; p = p->next)
+ {
+ icon = p->data;
+ caja_icon_container_get_icon_text (container, icon->data, &name,
+ NULL, TRUE);
+
+ /* This can happen if a key event is handled really early while
+ * loading the icon container, before the items have all been
+ * updated once.
+ */
+ if (!name)
+ {
+ continue;
+ }
+
+ normalized_name = g_utf8_normalize (name, -1, G_NORMALIZE_ALL);
+ if (!normalized_name)
+ {
+ continue;
+ }
+ case_normalized_name = g_utf8_casefold (normalized_name, -1);
+ g_free (normalized_name);
+ if (!case_normalized_name)
+ {
+ continue;
+ }
+
+ if (strncmp (case_normalized_key, case_normalized_name,
+ strlen (case_normalized_key)) == 0)
+ {
+ count++;
+ }
+
+ g_free (case_normalized_name);
+ g_free (name);
+ name = NULL;
+ }
+
+ g_free (case_normalized_key);
+
+ if (count == n)
+ {
+ if (select_one_unselect_others (container, icon))
+ {
+ g_signal_emit (container, signals[SELECTION_CHANGED], 0);
+ }
+ schedule_keyboard_icon_reveal (container, icon);
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static void
+caja_icon_container_search_move (GtkWidget *window,
+ CajaIconContainer *container,
+ gboolean up)
+{
+ gboolean ret;
+ gint len;
+ gint count = 0;
+ const gchar *text;
+
+ text = gtk_entry_get_text (GTK_ENTRY (container->details->search_entry));
+
+ g_assert (text != NULL);
+
+ if (container->details->selected_iter == 0)
+ {
+ return;
+ }
+
+ if (up && container->details->selected_iter == 1)
+ {
+ return;
+ }
+
+ len = strlen (text);
+
+ if (len < 1)
+ {
+ return;
+ }
+
+ /* search */
+ unselect_all (container);
+
+ ret = caja_icon_container_search_iter (container, text,
+ up?((container->details->selected_iter) - 1):((container->details->selected_iter + 1)));
+
+ if (ret)
+ {
+ /* found */
+ container->details->selected_iter += up?(-1):(1);
+ }
+ else
+ {
+ /* return to old iter */
+ count = 0;
+ caja_icon_container_search_iter (container, text,
+ container->details->selected_iter);
+ }
+}
+
+static gboolean
+caja_icon_container_search_scroll_event (GtkWidget *widget,
+ GdkEventScroll *event,
+ CajaIconContainer *container)
+{
+ gboolean retval = FALSE;
+
+ if (event->direction == GDK_SCROLL_UP)
+ {
+ caja_icon_container_search_move (widget, container, TRUE);
+ retval = TRUE;
+ }
+ else if (event->direction == GDK_SCROLL_DOWN)
+ {
+ caja_icon_container_search_move (widget, container, FALSE);
+ retval = TRUE;
+ }
+
+ /* renew the flush timeout */
+ if (retval && container->details->typeselect_flush_timeout)
+ {
+ g_source_remove (container->details->typeselect_flush_timeout);
+ container->details->typeselect_flush_timeout =
+ g_timeout_add_seconds (CAJA_ICON_CONTAINER_SEARCH_DIALOG_TIMEOUT,
+ (GSourceFunc) caja_icon_container_search_entry_flush_timeout,
+ container);
+ }
+
+ return retval;
+}
+
+static gboolean
+caja_icon_container_search_key_press_event (GtkWidget *widget,
+ GdkEventKey *event,
+ CajaIconContainer *container)
+{
+ gboolean retval = FALSE;
+
+ g_assert (GTK_IS_WIDGET (widget));
+ g_assert (CAJA_IS_ICON_CONTAINER (container));
+
+ /* close window and cancel the search */
+ if (event->keyval == GDK_Escape || event->keyval == GDK_Tab)
+ {
+ caja_icon_container_search_dialog_hide (widget, container);
+ return TRUE;
+ }
+
+ /* close window and activate alternate */
+ if (event->keyval == GDK_Return && event->state & GDK_SHIFT_MASK)
+ {
+ caja_icon_container_search_dialog_hide (widget,
+ container);
+
+ activate_selected_items_alternate (container, NULL);
+ return TRUE;
+ }
+
+ /* select previous matching iter */
+ if (event->keyval == GDK_Up || event->keyval == GDK_KP_Up)
+ {
+ caja_icon_container_search_move (widget, container, TRUE);
+ retval = TRUE;
+ }
+
+ if (((event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) == (GDK_CONTROL_MASK | GDK_SHIFT_MASK))
+ && (event->keyval == GDK_g || event->keyval == GDK_G))
+ {
+ caja_icon_container_search_move (widget, container, TRUE);
+ retval = TRUE;
+ }
+
+ /* select next matching iter */
+ if (event->keyval == GDK_Down || event->keyval == GDK_KP_Down)
+ {
+ caja_icon_container_search_move (widget, container, FALSE);
+ retval = TRUE;
+ }
+
+ if (((event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) == GDK_CONTROL_MASK)
+ && (event->keyval == GDK_g || event->keyval == GDK_G))
+ {
+ caja_icon_container_search_move (widget, container, FALSE);
+ retval = TRUE;
+ }
+
+ /* renew the flush timeout */
+ if (retval && container->details->typeselect_flush_timeout)
+ {
+ g_source_remove (container->details->typeselect_flush_timeout);
+ container->details->typeselect_flush_timeout =
+ g_timeout_add_seconds (CAJA_ICON_CONTAINER_SEARCH_DIALOG_TIMEOUT,
+ (GSourceFunc) caja_icon_container_search_entry_flush_timeout,
+ container);
+ }
+
+ return retval;
+}
+
+static void
+caja_icon_container_search_init (GtkWidget *entry,
+ CajaIconContainer *container)
+{
+ gint ret;
+ gint len;
+ const gchar *text;
+
+ g_assert (GTK_IS_ENTRY (entry));
+ g_assert (CAJA_IS_ICON_CONTAINER (container));
+
+ text = gtk_entry_get_text (GTK_ENTRY (entry));
+ len = strlen (text);
+
+ /* search */
+ unselect_all (container);
+ if (container->details->typeselect_flush_timeout)
+ {
+ g_source_remove (container->details->typeselect_flush_timeout);
+ container->details->typeselect_flush_timeout =
+ g_timeout_add_seconds (CAJA_ICON_CONTAINER_SEARCH_DIALOG_TIMEOUT,
+ (GSourceFunc) caja_icon_container_search_entry_flush_timeout,
+ container);
+ }
+
+ if (len < 1)
+ {
+ return;
+ }
+
+ ret = caja_icon_container_search_iter (container, text, 1);
+
+ if (ret)
+ {
+ container->details->selected_iter = 1;
+ }
+}
+
+static void
+caja_icon_container_ensure_interactive_directory (CajaIconContainer *container)
+{
+ GtkWidget *frame, *vbox, *toplevel;
+
+ toplevel = gtk_widget_get_toplevel (GTK_WIDGET (container));
+
+ if (container->details->search_window != NULL)
+ {
+ return;
+ }
+
+ container->details->search_window = gtk_window_new (GTK_WINDOW_POPUP);
+
+ gtk_window_set_modal (GTK_WINDOW (container->details->search_window), TRUE);
+ gtk_window_set_type_hint (GTK_WINDOW (container->details->search_window),
+ GDK_WINDOW_TYPE_HINT_COMBO);
+
+ g_signal_connect (container->details->search_window, "delete_event",
+ G_CALLBACK (caja_icon_container_search_delete_event),
+ container);
+ g_signal_connect (container->details->search_window, "key_press_event",
+ G_CALLBACK (caja_icon_container_search_key_press_event),
+ container);
+ g_signal_connect (container->details->search_window, "button_press_event",
+ G_CALLBACK (caja_icon_container_search_button_press_event),
+ container);
+ g_signal_connect (container->details->search_window, "scroll_event",
+ G_CALLBACK (caja_icon_container_search_scroll_event),
+ container);
+
+ frame = gtk_frame_new (NULL);
+ gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
+ gtk_widget_show (frame);
+ gtk_container_add (GTK_CONTAINER (container->details->search_window), frame);
+
+ vbox = gtk_vbox_new (FALSE, 0);
+ gtk_widget_show (vbox);
+ gtk_container_add (GTK_CONTAINER (frame), vbox);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 3);
+
+ /* add entry */
+ container->details->search_entry = gtk_entry_new ();
+ gtk_widget_show (container->details->search_entry);
+ g_signal_connect (container->details->search_entry, "populate_popup",
+ G_CALLBACK (caja_icon_container_search_disable_popdown),
+ container);
+ g_signal_connect (container->details->search_entry, "activate",
+ G_CALLBACK (caja_icon_container_search_activate),
+ container);
+ g_signal_connect (container->details->search_entry,
+ "preedit-changed",
+ G_CALLBACK (caja_icon_container_search_preedit_changed),
+ container);
+ gtk_container_add (GTK_CONTAINER (vbox), container->details->search_entry);
+
+ gtk_widget_realize (container->details->search_entry);
+}
+
+/* Pops up the interactive search entry. If keybinding is TRUE then the user
+ * started this by typing the start_interactive_search keybinding. Otherwise, it came from
+ */
+static gboolean
+caja_icon_container_real_start_interactive_search (CajaIconContainer *container,
+ gboolean keybinding)
+{
+ /* We only start interactive search if we have focus. If one of our
+ * children have focus, we don't want to start the search.
+ */
+ GtkWidgetClass *entry_parent_class;
+
+ if (container->details->search_window != NULL &&
+ gtk_widget_get_visible (container->details->search_window))
+ {
+ return TRUE;
+ }
+
+ if (!gtk_widget_has_focus (GTK_WIDGET (container)))
+ {
+ return FALSE;
+ }
+
+ caja_icon_container_ensure_interactive_directory (container);
+
+ if (keybinding)
+ {
+ gtk_entry_set_text (GTK_ENTRY (container->details->search_entry), "");
+ }
+
+ /* done, show it */
+ caja_icon_container_search_position_func (container, container->details->search_window);
+ gtk_widget_show (container->details->search_window);
+ if (container->details->search_entry_changed_id == 0)
+ {
+ container->details->search_entry_changed_id =
+ g_signal_connect (container->details->search_entry, "changed",
+ G_CALLBACK (caja_icon_container_search_init),
+ container);
+ }
+
+ container->details->typeselect_flush_timeout =
+ g_timeout_add_seconds (CAJA_ICON_CONTAINER_SEARCH_DIALOG_TIMEOUT,
+ (GSourceFunc) caja_icon_container_search_entry_flush_timeout,
+ container);
+
+ /* Grab focus will select all the text. We don't want that to happen, so we
+ * call the parent instance and bypass the selection change. This is probably
+ * really non-kosher. */
+ entry_parent_class = g_type_class_peek_parent (GTK_ENTRY_GET_CLASS (container->details->search_entry));
+ (entry_parent_class->grab_focus) (container->details->search_entry);
+
+ /* send focus-in event */
+ send_focus_change (container->details->search_entry, TRUE);
+
+ /* search first matching iter */
+ caja_icon_container_search_init (container->details->search_entry, container);
+
+ return TRUE;
+}
+
+static gboolean
+caja_icon_container_start_interactive_search (CajaIconContainer *container)
+{
+ return caja_icon_container_real_start_interactive_search (container, TRUE);
+}
+
+static gboolean
+handle_popups (CajaIconContainer *container,
+ GdkEventKey *event,
+ const char *signal)
+{
+ GdkEventButton button_event = { 0 };
+
+ g_signal_emit_by_name (container, signal, &button_event);
+
+ return TRUE;
+}
+
+static int
+key_press_event (GtkWidget *widget,
+ GdkEventKey *event)
+{
+ CajaIconContainer *container;
+ gboolean handled;
+
+ container = CAJA_ICON_CONTAINER (widget);
+ handled = FALSE;
+
+ if (is_renaming (container) || is_renaming_pending (container))
+ {
+ switch (event->keyval)
+ {
+ case GDK_Return:
+ case GDK_KP_Enter:
+ end_renaming_mode (container, TRUE);
+ handled = TRUE;
+ break;
+ case GDK_Escape:
+ end_renaming_mode (container, FALSE);
+ handled = TRUE;
+ break;
+ default:
+ break;
+ }
+ }
+ else
+ {
+ switch (event->keyval)
+ {
+ case GDK_Home:
+ case GDK_KP_Home:
+ keyboard_home (container, event);
+ handled = TRUE;
+ break;
+ case GDK_End:
+ case GDK_KP_End:
+ keyboard_end (container, event);
+ handled = TRUE;
+ break;
+ case GDK_Left:
+ case GDK_KP_Left:
+ /* Don't eat Alt-Left, as that is used for history browsing */
+ if ((event->state & GDK_MOD1_MASK) == 0)
+ {
+ keyboard_left (container, event);
+ handled = TRUE;
+ }
+ break;
+ case GDK_Up:
+ case GDK_KP_Up:
+ /* Don't eat Alt-Up, as that is used for alt-shift-Up */
+ if ((event->state & GDK_MOD1_MASK) == 0)
+ {
+ keyboard_up (container, event);
+ handled = TRUE;
+ }
+ break;
+ case GDK_Right:
+ case GDK_KP_Right:
+ /* Don't eat Alt-Right, as that is used for history browsing */
+ if ((event->state & GDK_MOD1_MASK) == 0)
+ {
+ keyboard_right (container, event);
+ handled = TRUE;
+ }
+ break;
+ case GDK_Down:
+ case GDK_KP_Down:
+ /* Don't eat Alt-Down, as that is used for Open */
+ if ((event->state & GDK_MOD1_MASK) == 0)
+ {
+ keyboard_down (container, event);
+ handled = TRUE;
+ }
+ break;
+ case GDK_space:
+ keyboard_space (container, event);
+ handled = TRUE;
+ break;
+#ifndef TAB_NAVIGATION_DISABLED
+ case GDK_Tab:
+ case GDK_ISO_Left_Tab:
+ select_previous_or_next_icon (container,
+ (event->state & GDK_SHIFT_MASK) == 0, event);
+ handled = TRUE;
+ break;
+#endif
+ case GDK_Return:
+ case GDK_KP_Enter:
+ if ((event->state & GDK_SHIFT_MASK) != 0)
+ {
+ activate_selected_items_alternate (container, NULL);
+ }
+ else
+ {
+ activate_selected_items (container);
+ }
+
+ handled = TRUE;
+ break;
+ case GDK_Escape:
+ handled = undo_stretching (container);
+ break;
+ case GDK_plus:
+ case GDK_minus:
+ case GDK_equal:
+ case GDK_KP_Add:
+ case GDK_KP_Subtract:
+ case GDK_0:
+ case GDK_KP_0:
+ if (event->state & GDK_CONTROL_MASK)
+ {
+ handled = keyboard_stretching (container, event);
+ }
+ break;
+ case GDK_F10:
+ /* handle Ctrl+F10 because we want to display the
+ * background popup even if something is selected.
+ * The other cases are handled by popup_menu().
+ */
+ if (event->state & GDK_CONTROL_MASK)
+ {
+ handled = handle_popups (container, event,
+ "context_click_background");
+ }
+ break;
+ case GDK_v:
+ /* Eat Control + v to not enable type ahead */
+ if ((event->state & GDK_CONTROL_MASK) != 0)
+ {
+ handled = TRUE;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ if (!handled)
+ {
+ handled = GTK_WIDGET_CLASS (caja_icon_container_parent_class)->key_press_event (widget, event);
+ }
+
+ /* We pass the event to the search_entry. If its text changes, then we
+ * start the typeahead find capabilities.
+ * Copied from CajaIconContainer */
+ if (!handled &&
+ event->keyval != GDK_slash /* don't steal slash key event, used for "go to" */ &&
+ event->keyval != GDK_BackSpace &&
+ event->keyval != GDK_Delete)
+ {
+ GdkEvent *new_event;
+ GdkWindow *window;
+ char *old_text;
+ const char *new_text;
+ gboolean retval;
+ GdkScreen *screen;
+ gboolean text_modified;
+ gulong popup_menu_id;
+
+ caja_icon_container_ensure_interactive_directory (container);
+
+ /* Make a copy of the current text */
+ old_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (container->details->search_entry)));
+ new_event = gdk_event_copy ((GdkEvent *) event);
+ window = ((GdkEventKey *) new_event)->window;
+ ((GdkEventKey *) new_event)->window = gtk_widget_get_window (container->details->search_entry);
+ gtk_widget_realize (container->details->search_window);
+
+ popup_menu_id = g_signal_connect (container->details->search_entry,
+ "popup_menu", G_CALLBACK (gtk_true), NULL);
+
+ /* Move the entry off screen */
+ screen = gtk_widget_get_screen (GTK_WIDGET (container));
+ gtk_window_move (GTK_WINDOW (container->details->search_window),
+ gdk_screen_get_width (screen) + 1,
+ gdk_screen_get_height (screen) + 1);
+ gtk_widget_show (container->details->search_window);
+
+ /* Send the event to the window. If the preedit_changed signal is emitted
+ * during this event, we will set priv->imcontext_changed */
+ container->details->imcontext_changed = FALSE;
+ retval = gtk_widget_event (container->details->search_entry, new_event);
+ gtk_widget_hide (container->details->search_window);
+
+ g_signal_handler_disconnect (container->details->search_entry,
+ popup_menu_id);
+
+ /* We check to make sure that the entry tried to handle the text, and that
+ * the text has changed. */
+ new_text = gtk_entry_get_text (GTK_ENTRY (container->details->search_entry));
+ text_modified = strcmp (old_text, new_text) != 0;
+ g_free (old_text);
+ if (container->details->imcontext_changed || /* we're in a preedit */
+ (retval && text_modified)) /* ...or the text was modified */
+ {
+ if (caja_icon_container_real_start_interactive_search (container, FALSE))
+ {
+ gtk_widget_grab_focus (GTK_WIDGET (container));
+ return TRUE;
+ }
+ else
+ {
+ gtk_entry_set_text (GTK_ENTRY (container->details->search_entry), "");
+ return FALSE;
+ }
+ }
+
+ ((GdkEventKey *) new_event)->window = window;
+ gdk_event_free (new_event);
+ }
+
+ return handled;
+}
+
+static gboolean
+popup_menu (GtkWidget *widget)
+{
+ CajaIconContainer *container;
+
+ container = CAJA_ICON_CONTAINER (widget);
+
+ if (has_selection (container))
+ {
+ handle_popups (container, NULL,
+ "context_click_selection");
+ }
+ else
+ {
+ handle_popups (container, NULL,
+ "context_click_background");
+ }
+
+ return TRUE;
+}
+
+static void
+draw_canvas_background (EelCanvas *canvas,
+ int x, int y, int width, int height)
+{
+ /* Don't chain up to the parent to avoid clearing and redrawing */
+}
+
+
+static gboolean
+expose_event (GtkWidget *widget,
+ GdkEventExpose *event)
+{
+ /* g_warning ("Expose Icon Container %p '%d,%d: %d,%d'",
+ widget,
+ event->area.x, event->area.y,
+ event->area.width, event->area.height); */
+
+ return GTK_WIDGET_CLASS (caja_icon_container_parent_class)->expose_event (widget, event);
+}
+
+static AtkObject *
+get_accessible (GtkWidget *widget)
+{
+ AtkObject *accessible;
+
+ if ((accessible = eel_accessibility_get_atk_object (widget)))
+ {
+ return accessible;
+ }
+
+ accessible = g_object_new
+ (caja_icon_container_accessible_get_type (), NULL);
+
+ return eel_accessibility_set_atk_object_return (widget, accessible);
+}
+
+static void
+grab_notify_cb (GtkWidget *widget,
+ gboolean was_grabbed)
+{
+ CajaIconContainer *container;
+
+ container = CAJA_ICON_CONTAINER (widget);
+
+ if (container->details->rubberband_info.active &&
+ !was_grabbed)
+ {
+ /* we got a (un)grab-notify during rubberband.
+ * This happens when a new modal dialog shows
+ * up (e.g. authentication or an error). Stop
+ * the rubberbanding so that we can handle the
+ * dialog. */
+ stop_rubberbanding (container,
+ GDK_CURRENT_TIME);
+ }
+}
+
+static void
+text_ellipsis_limit_changed_container_callback (gpointer callback_data)
+{
+ CajaIconContainer *container;
+
+ container = CAJA_ICON_CONTAINER (callback_data);
+ invalidate_label_sizes (container);
+ schedule_redo_layout (container);
+}
+
+static GObject*
+caja_icon_container_constructor (GType type,
+ guint n_construct_params,
+ GObjectConstructParam *construct_params)
+{
+ CajaIconContainer *container;
+ GObject *object;
+
+ object = G_OBJECT_CLASS (caja_icon_container_parent_class)->constructor
+ (type,
+ n_construct_params,
+ construct_params);
+
+ container = CAJA_ICON_CONTAINER (object);
+ if (caja_icon_container_get_is_desktop (container))
+ {
+ eel_preferences_add_callback_while_alive (CAJA_PREFERENCES_DESKTOP_TEXT_ELLIPSIS_LIMIT,
+ text_ellipsis_limit_changed_container_callback,
+ container, G_OBJECT (container));
+ }
+ else
+ {
+ eel_preferences_add_callback_while_alive (CAJA_PREFERENCES_ICON_VIEW_TEXT_ELLIPSIS_LIMIT,
+ text_ellipsis_limit_changed_container_callback,
+ container, G_OBJECT (container));
+ }
+
+ return object;
+}
+
+/* Initialization. */
+
+static void
+caja_icon_container_class_init (CajaIconContainerClass *class)
+{
+ GtkWidgetClass *widget_class;
+ EelCanvasClass *canvas_class;
+ GtkBindingSet *binding_set;
+
+ G_OBJECT_CLASS (class)->constructor = caja_icon_container_constructor;
+ G_OBJECT_CLASS (class)->finalize = finalize;
+ GTK_OBJECT_CLASS (class)->destroy = destroy;
+
+ /* Signals. */
+
+ signals[SELECTION_CHANGED]
+ = g_signal_new ("selection_changed",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ selection_changed),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ signals[BUTTON_PRESS]
+ = g_signal_new ("button_press",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ button_press),
+ NULL, NULL,
+ caja_marshal_BOOLEAN__POINTER,
+ G_TYPE_BOOLEAN, 1,
+ GDK_TYPE_EVENT);
+ signals[ACTIVATE]
+ = g_signal_new ("activate",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ activate),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__POINTER,
+ G_TYPE_NONE, 1,
+ G_TYPE_POINTER);
+ signals[ACTIVATE_ALTERNATE]
+ = g_signal_new ("activate_alternate",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ activate_alternate),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__POINTER,
+ G_TYPE_NONE, 1,
+ G_TYPE_POINTER);
+ signals[CONTEXT_CLICK_SELECTION]
+ = g_signal_new ("context_click_selection",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ context_click_selection),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__POINTER,
+ G_TYPE_NONE, 1,
+ G_TYPE_POINTER);
+ signals[CONTEXT_CLICK_BACKGROUND]
+ = g_signal_new ("context_click_background",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ context_click_background),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__POINTER,
+ G_TYPE_NONE, 1,
+ G_TYPE_POINTER);
+ signals[MIDDLE_CLICK]
+ = g_signal_new ("middle_click",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ middle_click),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__POINTER,
+ G_TYPE_NONE, 1,
+ G_TYPE_POINTER);
+ signals[ICON_POSITION_CHANGED]
+ = g_signal_new ("icon_position_changed",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ icon_position_changed),
+ NULL, NULL,
+ caja_marshal_VOID__POINTER_POINTER,
+ G_TYPE_NONE, 2,
+ G_TYPE_POINTER,
+ G_TYPE_POINTER);
+ signals[ICON_TEXT_CHANGED]
+ = g_signal_new ("icon_text_changed",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ icon_text_changed),
+ NULL, NULL,
+ caja_marshal_VOID__POINTER_STRING,
+ G_TYPE_NONE, 2,
+ G_TYPE_POINTER,
+ G_TYPE_STRING);
+ signals[ICON_STRETCH_STARTED]
+ = g_signal_new ("icon_stretch_started",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ icon_stretch_started),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__POINTER,
+ G_TYPE_NONE, 1,
+ G_TYPE_POINTER);
+ signals[ICON_STRETCH_ENDED]
+ = g_signal_new ("icon_stretch_ended",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ icon_stretch_ended),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__POINTER,
+ G_TYPE_NONE, 1,
+ G_TYPE_POINTER);
+ signals[RENAMING_ICON]
+ = g_signal_new ("renaming_icon",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ renaming_icon),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__POINTER,
+ G_TYPE_NONE, 1,
+ G_TYPE_POINTER);
+ signals[GET_ICON_URI]
+ = g_signal_new ("get_icon_uri",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ get_icon_uri),
+ NULL, NULL,
+ eel_marshal_STRING__POINTER,
+ G_TYPE_STRING, 1,
+ G_TYPE_POINTER);
+ signals[GET_ICON_DROP_TARGET_URI]
+ = g_signal_new ("get_icon_drop_target_uri",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ get_icon_drop_target_uri),
+ NULL, NULL,
+ eel_marshal_STRING__POINTER,
+ G_TYPE_STRING, 1,
+ G_TYPE_POINTER);
+ signals[MOVE_COPY_ITEMS]
+ = g_signal_new ("move_copy_items",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ move_copy_items),
+ NULL, NULL,
+ caja_marshal_VOID__POINTER_POINTER_POINTER_ENUM_INT_INT,
+ G_TYPE_NONE, 6,
+ G_TYPE_POINTER,
+ G_TYPE_POINTER,
+ G_TYPE_POINTER,
+ GDK_TYPE_DRAG_ACTION,
+ G_TYPE_INT,
+ G_TYPE_INT);
+ signals[HANDLE_NETSCAPE_URL]
+ = g_signal_new ("handle_netscape_url",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ handle_netscape_url),
+ NULL, NULL,
+ caja_marshal_VOID__STRING_STRING_ENUM_INT_INT,
+ G_TYPE_NONE, 5,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ GDK_TYPE_DRAG_ACTION,
+ G_TYPE_INT,
+ G_TYPE_INT);
+ signals[HANDLE_URI_LIST]
+ = g_signal_new ("handle_uri_list",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ handle_uri_list),
+ NULL, NULL,
+ caja_marshal_VOID__STRING_STRING_ENUM_INT_INT,
+ G_TYPE_NONE, 5,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ GDK_TYPE_DRAG_ACTION,
+ G_TYPE_INT,
+ G_TYPE_INT);
+ signals[HANDLE_TEXT]
+ = g_signal_new ("handle_text",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ handle_text),
+ NULL, NULL,
+ caja_marshal_VOID__STRING_STRING_ENUM_INT_INT,
+ G_TYPE_NONE, 5,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ GDK_TYPE_DRAG_ACTION,
+ G_TYPE_INT,
+ G_TYPE_INT);
+ signals[HANDLE_RAW]
+ = g_signal_new ("handle_raw",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ handle_raw),
+ NULL, NULL,
+ caja_marshal_VOID__POINTER_INT_STRING_STRING_ENUM_INT_INT,
+ G_TYPE_NONE, 7,
+ G_TYPE_POINTER,
+ G_TYPE_INT,
+ G_TYPE_STRING,
+ G_TYPE_STRING,
+ GDK_TYPE_DRAG_ACTION,
+ G_TYPE_INT,
+ G_TYPE_INT);
+ signals[GET_CONTAINER_URI]
+ = g_signal_new ("get_container_uri",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ get_container_uri),
+ NULL, NULL,
+ eel_marshal_STRING__VOID,
+ G_TYPE_STRING, 0);
+ signals[CAN_ACCEPT_ITEM]
+ = g_signal_new ("can_accept_item",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ can_accept_item),
+ NULL, NULL,
+ eel_marshal_INT__POINTER_STRING,
+ G_TYPE_INT, 2,
+ G_TYPE_POINTER,
+ G_TYPE_STRING);
+ signals[GET_STORED_ICON_POSITION]
+ = g_signal_new ("get_stored_icon_position",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ get_stored_icon_position),
+ NULL, NULL,
+ eel_marshal_BOOLEAN__POINTER_POINTER,
+ G_TYPE_BOOLEAN, 2,
+ G_TYPE_POINTER,
+ G_TYPE_POINTER);
+ signals[GET_STORED_LAYOUT_TIMESTAMP]
+ = g_signal_new ("get_stored_layout_timestamp",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ get_stored_layout_timestamp),
+ NULL, NULL,
+ eel_marshal_BOOLEAN__POINTER_POINTER,
+ G_TYPE_BOOLEAN, 2,
+ G_TYPE_POINTER,
+ G_TYPE_POINTER);
+ signals[STORE_LAYOUT_TIMESTAMP]
+ = g_signal_new ("store_layout_timestamp",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ store_layout_timestamp),
+ NULL, NULL,
+ eel_marshal_BOOLEAN__POINTER_POINTER,
+ G_TYPE_BOOLEAN, 2,
+ G_TYPE_POINTER,
+ G_TYPE_POINTER);
+ signals[LAYOUT_CHANGED]
+ = g_signal_new ("layout_changed",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ layout_changed),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ signals[PREVIEW]
+ = g_signal_new ("preview",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ preview),
+ NULL, NULL,
+ caja_marshal_INT__POINTER_BOOLEAN,
+ G_TYPE_INT, 2,
+ G_TYPE_POINTER,
+ G_TYPE_BOOLEAN);
+ signals[BAND_SELECT_STARTED]
+ = g_signal_new ("band_select_started",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ band_select_started),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ signals[BAND_SELECT_ENDED]
+ = g_signal_new ("band_select_ended",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ band_select_ended),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ signals[ICON_ADDED]
+ = g_signal_new ("icon_added",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ icon_added),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__POINTER,
+ G_TYPE_NONE, 1, G_TYPE_POINTER);
+ signals[ICON_REMOVED]
+ = g_signal_new ("icon_removed",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ icon_removed),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__POINTER,
+ G_TYPE_NONE, 1, G_TYPE_POINTER);
+
+ signals[CLEARED]
+ = g_signal_new ("cleared",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ cleared),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+
+ signals[START_INTERACTIVE_SEARCH]
+ = g_signal_new ("start_interactive_search",
+ G_TYPE_FROM_CLASS (class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET (CajaIconContainerClass,
+ start_interactive_search),
+ NULL, NULL,
+ caja_marshal_BOOLEAN__VOID,
+ G_TYPE_BOOLEAN, 0);
+
+ /* GtkWidget class. */
+
+ widget_class = GTK_WIDGET_CLASS (class);
+ widget_class->size_request = size_request;
+ widget_class->size_allocate = size_allocate;
+ widget_class->realize = realize;
+ widget_class->unrealize = unrealize;
+ widget_class->button_press_event = button_press_event;
+ widget_class->button_release_event = button_release_event;
+ widget_class->motion_notify_event = motion_notify_event;
+ widget_class->key_press_event = key_press_event;
+ widget_class->popup_menu = popup_menu;
+ widget_class->get_accessible = get_accessible;
+ widget_class->style_set = style_set;
+ widget_class->expose_event = expose_event;
+ widget_class->grab_notify = grab_notify_cb;
+
+ canvas_class = EEL_CANVAS_CLASS (class);
+ canvas_class->draw_background = draw_canvas_background;
+
+ class->start_interactive_search = caja_icon_container_start_interactive_search;
+
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_boolean ("frame_text",
+ "Frame Text",
+ "Draw a frame around unselected text",
+ FALSE,
+ G_PARAM_READABLE));
+
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_boxed ("selection_box_color",
+ "Selection Box Color",
+ "Color of the selection box",
+ GDK_TYPE_COLOR,
+ G_PARAM_READABLE));
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_uchar ("selection_box_alpha",
+ "Selection Box Alpha",
+ "Opacity of the selection box",
+ 0, 0xff,
+ DEFAULT_SELECTION_BOX_ALPHA,
+ G_PARAM_READABLE));
+
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_uchar ("highlight_alpha",
+ "Highlight Alpha",
+ "Opacity of the highlight for selected icons",
+ 0, 0xff,
+ DEFAULT_HIGHLIGHT_ALPHA,
+ G_PARAM_READABLE));
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_uchar ("normal_alpha",
+ "Normal Alpha",
+ "Opacity of the normal icons if frame_text is set",
+ 0, 0xff,
+ DEFAULT_NORMAL_ALPHA,
+ G_PARAM_READABLE));
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_uchar ("prelight_alpha",
+ "Prelight Alpha",
+ "Opacity of the prelight icons if frame_text is set",
+ 0, 0xff,
+ DEFAULT_PRELIGHT_ALPHA,
+ G_PARAM_READABLE));
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_boxed ("light_info_color",
+ "Light Info Color",
+ "Color used for information text against a dark background",
+ GDK_TYPE_COLOR,
+ G_PARAM_READABLE));
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_boxed ("dark_info_color",
+ "Dark Info Color",
+ "Color used for information text against a light background",
+ GDK_TYPE_COLOR,
+ G_PARAM_READABLE));
+
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_uint ("normal_icon_render_mode",
+ "Normal Icon Render Mode",
+ "Mode of normal icons being rendered (0=normal, 1=spotlight, 2=colorize, 3=colorize-monochromely)",
+ 0, 3,
+ DEFAULT_NORMAL_ICON_RENDER_MODE,
+ G_PARAM_READABLE));
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_uint ("prelight_icon_render_mode",
+ "Prelight Icon Render Mode",
+ "Mode of prelight icons being rendered (0=normal, 1=spotlight, 2=colorize, 3=colorize-monochromely)",
+ 0, 3,
+ DEFAULT_PRELIGHT_ICON_RENDER_MODE,
+ G_PARAM_READABLE));
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_boxed ("normal_icon_color",
+ "Icon Normal Color",
+ "Color used for colorizing icons in normal state (default base[NORMAL])",
+ GDK_TYPE_COLOR,
+ G_PARAM_READABLE));
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_boxed ("prelight_icon_color",
+ "Icon Prelight Color",
+ "Color used for colorizing prelighted icons (default base[PRELIGHT])",
+ GDK_TYPE_COLOR,
+ G_PARAM_READABLE));
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_uint ("normal_icon_saturation",
+ "Normal Icon Saturation",
+ "Saturation of icons in normal state",
+ 0, 255,
+ DEFAULT_NORMAL_ICON_SATURATION,
+ G_PARAM_READABLE));
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_uint ("prelight_icon_saturation",
+ "Prelight Icon Saturation",
+ "Saturation of icons in prelight state",
+ 0, 255,
+ DEFAULT_PRELIGHT_ICON_SATURATION,
+ G_PARAM_READABLE));
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_uint ("normal_icon_brightness",
+ "Normal Icon Brightness",
+ "Brightness of icons in normal state",
+ 0, 255,
+ DEFAULT_NORMAL_ICON_BRIGHTNESS,
+ G_PARAM_READABLE));
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_uint ("prelight_icon_brightness",
+ "Prelight Icon Brightness",
+ "Brightness of icons in prelight state",
+ 0, 255,
+ DEFAULT_PRELIGHT_ICON_BRIGHTNESS,
+ G_PARAM_READABLE));
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_uint ("normal_icon_lighten",
+ "Normal Icon Lighten",
+ "Lighten icons in normal state",
+ 0, 255,
+ DEFAULT_NORMAL_ICON_LIGHTEN,
+ G_PARAM_READABLE));
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_uint ("prelight_icon_lighten",
+ "Prelight Icon Lighten",
+ "Lighten icons in prelight state",
+ 0, 255,
+ DEFAULT_PRELIGHT_ICON_LIGHTEN,
+ G_PARAM_READABLE));
+ gtk_widget_class_install_style_property (widget_class,
+ g_param_spec_boolean ("activate_prelight_icon_label",
+ "Activate Prelight Icon Label",
+ "Whether icon labels should make use of its prelight color in prelight state",
+ FALSE,
+ G_PARAM_READABLE));
+
+
+ binding_set = gtk_binding_set_by_class (class);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_f, GDK_CONTROL_MASK, "start_interactive_search", 0);
+ gtk_binding_entry_add_signal (binding_set, GDK_F, GDK_CONTROL_MASK, "start_interactive_search", 0);
+}
+
+static void
+update_selected (CajaIconContainer *container)
+{
+ GList *node;
+ CajaIcon *icon;
+
+ for (node = container->details->icons; node != NULL; node = node->next)
+ {
+ icon = node->data;
+ if (icon->is_selected)
+ {
+ eel_canvas_item_request_update (EEL_CANVAS_ITEM (icon->item));
+ }
+ }
+}
+
+static gboolean
+handle_focus_in_event (GtkWidget *widget, GdkEventFocus *event, gpointer user_data)
+{
+ update_selected (CAJA_ICON_CONTAINER (widget));
+
+ return FALSE;
+}
+
+static gboolean
+handle_focus_out_event (GtkWidget *widget, GdkEventFocus *event, gpointer user_data)
+{
+ /* End renaming and commit change. */
+ end_renaming_mode (CAJA_ICON_CONTAINER (widget), TRUE);
+ update_selected (CAJA_ICON_CONTAINER (widget));
+
+ return FALSE;
+}
+
+
+static int text_ellipsis_limits[CAJA_ZOOM_LEVEL_N_ENTRIES];
+static int desktop_text_ellipsis_limit;
+
+static gboolean
+get_text_ellipsis_limit_for_zoom (char **strs,
+ const char *zoom_level,
+ int *limit)
+{
+ char **p;
+ char *str;
+ gboolean success;
+
+ success = FALSE;
+
+ /* default */
+ *limit = 3;
+
+ if (zoom_level != NULL)
+ {
+ str = g_strdup_printf ("%s:%%d", zoom_level);
+ }
+ else
+ {
+ str = g_strdup ("%d");
+ }
+
+ if (strs != NULL)
+ {
+ for (p = strs; *p != NULL; p++)
+ {
+ if (sscanf (*p, str, limit))
+ {
+ success = TRUE;
+ }
+ }
+ }
+
+ g_free (str);
+
+ return success;
+}
+
+static void
+text_ellipsis_limit_changed_callback (gpointer callback_data)
+{
+ char **pref;
+ unsigned int i;
+ int one_limit;
+ const EelEnumeration *eenum;
+ const EelEnumerationEntry *entry;
+
+ pref = eel_preferences_get_string_array (CAJA_PREFERENCES_ICON_VIEW_TEXT_ELLIPSIS_LIMIT);
+
+ /* set default */
+ get_text_ellipsis_limit_for_zoom (pref, NULL, &one_limit);
+ for (i = 0; i < CAJA_ZOOM_LEVEL_N_ENTRIES; i++)
+ {
+ text_ellipsis_limits[i] = one_limit;
+ }
+
+ /* override for each zoom level */
+ eenum = eel_enumeration_lookup ("default_zoom_level");
+ g_assert (eenum != NULL);
+ for (i = 0; i < eel_enumeration_get_length (eenum); i++)
+ {
+ entry = eel_enumeration_get_nth_entry (eenum, i);
+ if (get_text_ellipsis_limit_for_zoom (pref, entry->name, &one_limit))
+ {
+ text_ellipsis_limits[entry->value] = one_limit;
+ }
+ }
+
+ g_strfreev (pref);
+}
+
+static void
+desktop_text_ellipsis_limit_changed_callback (gpointer callback_data)
+{
+ int pref;
+
+ pref = eel_preferences_get_integer (CAJA_PREFERENCES_DESKTOP_TEXT_ELLIPSIS_LIMIT);
+ desktop_text_ellipsis_limit = pref;
+}
+
+static void
+caja_icon_container_init (CajaIconContainer *container)
+{
+ CajaIconContainerDetails *details;
+ EelBackground *background;
+ static gboolean setup_prefs = FALSE;
+
+ details = g_new0 (CajaIconContainerDetails, 1);
+
+ details->icon_set = g_hash_table_new (g_direct_hash, g_direct_equal);
+ details->layout_timestamp = UNDEFINED_TIME;
+
+ details->zoom_level = CAJA_ZOOM_LEVEL_STANDARD;
+
+ details->font_size_table[CAJA_ZOOM_LEVEL_SMALLEST] = -2 * PANGO_SCALE;
+ details->font_size_table[CAJA_ZOOM_LEVEL_SMALLER] = -2 * PANGO_SCALE;
+ details->font_size_table[CAJA_ZOOM_LEVEL_SMALL] = -0 * PANGO_SCALE;
+ details->font_size_table[CAJA_ZOOM_LEVEL_STANDARD] = 0 * PANGO_SCALE;
+ details->font_size_table[CAJA_ZOOM_LEVEL_LARGE] = 0 * PANGO_SCALE;
+ details->font_size_table[CAJA_ZOOM_LEVEL_LARGER] = 0 * PANGO_SCALE;
+ details->font_size_table[CAJA_ZOOM_LEVEL_LARGEST] = 0 * PANGO_SCALE;
+
+ container->details = details;
+
+ /* when the background changes, we must set up the label text color */
+ background = eel_get_widget_background (GTK_WIDGET (container));
+
+ g_signal_connect_object (background, "appearance_changed",
+ G_CALLBACK (update_label_color), container, 0);
+
+ g_signal_connect (container, "focus-in-event",
+ G_CALLBACK (handle_focus_in_event), NULL);
+ g_signal_connect (container, "focus-out-event",
+ G_CALLBACK (handle_focus_out_event), NULL);
+
+ eel_background_set_use_base (background, TRUE);
+
+ /* read in theme-dependent data */
+ caja_icon_container_theme_changed (container);
+ eel_preferences_add_callback (CAJA_PREFERENCES_THEME,
+ caja_icon_container_theme_changed,
+ container);
+
+ if (!setup_prefs)
+ {
+ eel_preferences_add_callback (CAJA_PREFERENCES_ICON_VIEW_TEXT_ELLIPSIS_LIMIT,
+ text_ellipsis_limit_changed_callback,
+ NULL);
+ text_ellipsis_limit_changed_callback (NULL);
+
+ eel_preferences_add_callback (CAJA_PREFERENCES_DESKTOP_TEXT_ELLIPSIS_LIMIT,
+ desktop_text_ellipsis_limit_changed_callback,
+ NULL);
+ desktop_text_ellipsis_limit_changed_callback (NULL);
+
+ setup_prefs = TRUE;
+ }
+}
+
+typedef struct
+{
+ CajaIconContainer *container;
+ GdkEventButton *event;
+} ContextMenuParameters;
+
+static gboolean
+handle_icon_double_click (CajaIconContainer *container,
+ CajaIcon *icon,
+ GdkEventButton *event)
+{
+ CajaIconContainerDetails *details;
+
+ if (event->button != DRAG_BUTTON)
+ {
+ return FALSE;
+ }
+
+ details = container->details;
+
+ if (!details->single_click_mode &&
+ clicked_within_double_click_interval (container) &&
+ details->double_click_icon[0] == details->double_click_icon[1] &&
+ details->double_click_button[0] == details->double_click_button[1])
+ {
+ if (!button_event_modifies_selection (event))
+ {
+ activate_selected_items (container);
+ return TRUE;
+ }
+ else if ((event->state & GDK_CONTROL_MASK) == 0 &&
+ (event->state & GDK_SHIFT_MASK) != 0)
+ {
+ activate_selected_items_alternate (container, icon);
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+/* CajaIcon event handling. */
+
+/* Conceptually, pressing button 1 together with CTRL or SHIFT toggles
+ * selection of a single icon without affecting the other icons;
+ * without CTRL or SHIFT, it selects a single icon and un-selects all
+ * the other icons. But in this latter case, the de-selection should
+ * only happen when the button is released if the icon is already
+ * selected, because the user might select multiple icons and drag all
+ * of them by doing a simple click-drag.
+*/
+
+static gboolean
+handle_icon_button_press (CajaIconContainer *container,
+ CajaIcon *icon,
+ GdkEventButton *event)
+{
+ CajaIconContainerDetails *details;
+
+ details = container->details;
+
+ if (event->type == GDK_2BUTTON_PRESS || event->type == GDK_3BUTTON_PRESS)
+ {
+ return TRUE;
+ }
+
+ if (event->button != DRAG_BUTTON
+ && event->button != CONTEXTUAL_MENU_BUTTON
+ && event->button != DRAG_MENU_BUTTON)
+ {
+ return TRUE;
+ }
+
+ if ((event->button == DRAG_BUTTON) &&
+ event->type == GDK_BUTTON_PRESS)
+ {
+ /* The next double click has to be on this icon */
+ details->double_click_icon[1] = details->double_click_icon[0];
+ details->double_click_icon[0] = icon;
+
+ details->double_click_button[1] = details->double_click_button[0];
+ details->double_click_button[0] = event->button;
+ }
+
+ if (handle_icon_double_click (container, icon, event))
+ {
+ /* Double clicking does not trigger a D&D action. */
+ details->drag_button = 0;
+ details->drag_icon = NULL;
+ return TRUE;
+ }
+
+ if (event->button == DRAG_BUTTON
+ || event->button == DRAG_MENU_BUTTON)
+ {
+ details->drag_button = event->button;
+ details->drag_icon = icon;
+ details->drag_x = event->x;
+ details->drag_y = event->y;
+ details->drag_state = DRAG_STATE_MOVE_OR_COPY;
+ details->drag_started = FALSE;
+
+ /* Check to see if this is a click on the stretch handles.
+ * If so, it won't modify the selection.
+ */
+ if (icon == container->details->stretch_icon)
+ {
+ if (start_stretching (container))
+ {
+ return TRUE;
+ }
+ }
+ }
+
+ /* Modify the selection as appropriate. Selection is modified
+ * the same way for contextual menu as it would be without.
+ */
+ details->icon_selected_on_button_down = icon->is_selected;
+
+ if ((event->button == DRAG_BUTTON || event->button == MIDDLE_BUTTON) &&
+ (event->state & GDK_SHIFT_MASK) != 0)
+ {
+ CajaIcon *start_icon;
+
+ start_icon = details->range_selection_base_icon;
+ if (start_icon == NULL || !start_icon->is_selected)
+ {
+ start_icon = icon;
+ details->range_selection_base_icon = icon;
+ }
+ if (select_range (container, start_icon, icon,
+ (event->state & GDK_CONTROL_MASK) == 0))
+ {
+ g_signal_emit (container,
+ signals[SELECTION_CHANGED], 0);
+ }
+ }
+ else if (!details->icon_selected_on_button_down)
+ {
+ details->range_selection_base_icon = icon;
+ if (button_event_modifies_selection (event))
+ {
+ icon_toggle_selected (container, icon);
+ g_signal_emit (container,
+ signals[SELECTION_CHANGED], 0);
+ }
+ else
+ {
+ select_one_unselect_others (container, icon);
+ g_signal_emit (container,
+ signals[SELECTION_CHANGED], 0);
+ }
+ }
+
+ if (event->button == CONTEXTUAL_MENU_BUTTON)
+ {
+ g_signal_emit (container,
+ signals[CONTEXT_CLICK_SELECTION], 0,
+ event);
+ }
+
+
+ return TRUE;
+}
+
+static int
+item_event_callback (EelCanvasItem *item,
+ GdkEvent *event,
+ gpointer data)
+{
+ CajaIconContainer *container;
+ CajaIconContainerDetails *details;
+ CajaIcon *icon;
+
+ container = CAJA_ICON_CONTAINER (data);
+ details = container->details;
+
+ icon = CAJA_ICON_CANVAS_ITEM (item)->user_data;
+ g_assert (icon != NULL);
+
+ switch (event->type)
+ {
+ case GDK_BUTTON_PRESS:
+ if (handle_icon_button_press (container, icon, &event->button))
+ {
+ /* Stop the event from being passed along further. Returning
+ * TRUE ain't enough.
+ */
+ return TRUE;
+ }
+ return FALSE;
+ default:
+ return FALSE;
+ }
+}
+
+GtkWidget *
+caja_icon_container_new (void)
+{
+ return gtk_widget_new (CAJA_TYPE_ICON_CONTAINER, NULL);
+}
+
+/* Clear all of the icons in the container. */
+void
+caja_icon_container_clear (CajaIconContainer *container)
+{
+ CajaIconContainerDetails *details;
+ CajaIcon *icon;
+ GList *p;
+
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+ details = container->details;
+ details->layout_timestamp = UNDEFINED_TIME;
+ details->store_layout_timestamps_when_finishing_new_icons = FALSE;
+
+ if (details->icons == NULL)
+ {
+ return;
+ }
+
+ end_renaming_mode (container, TRUE);
+
+ clear_keyboard_focus (container);
+ clear_keyboard_rubberband_start (container);
+ unschedule_keyboard_icon_reveal (container);
+ set_pending_icon_to_reveal (container, NULL);
+ details->stretch_icon = NULL;
+ details->drop_target = NULL;
+
+ for (p = details->icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+ if (icon->is_monitored)
+ {
+ caja_icon_container_stop_monitor_top_left (container,
+ icon->data,
+ icon);
+ }
+ icon_free (p->data);
+ }
+ g_list_free (details->icons);
+ details->icons = NULL;
+ g_list_free (details->new_icons);
+ details->new_icons = NULL;
+
+ g_hash_table_destroy (details->icon_set);
+ details->icon_set = g_hash_table_new (g_direct_hash, g_direct_equal);
+
+ caja_icon_container_update_scroll_region (container);
+}
+
+gboolean
+caja_icon_container_is_empty (CajaIconContainer *container)
+{
+ return container->details->icons == NULL;
+}
+
+CajaIconData *
+caja_icon_container_get_first_visible_icon (CajaIconContainer *container)
+{
+ GList *l;
+ CajaIcon *icon, *best_icon;
+ double x, y;
+ double x1, y1, x2, y2;
+ double *pos, best_pos;
+ double hadj_v, vadj_v, h_page_size;
+ gboolean better_icon;
+ gboolean compare_lt;
+
+ hadj_v = gtk_adjustment_get_value (gtk_layout_get_hadjustment (GTK_LAYOUT (container)));
+ vadj_v = gtk_adjustment_get_value (gtk_layout_get_vadjustment (GTK_LAYOUT (container)));
+ h_page_size = gtk_adjustment_get_page_size (gtk_layout_get_hadjustment (GTK_LAYOUT (container)));
+
+ if (caja_icon_container_is_layout_rtl (container))
+ {
+ x = hadj_v + h_page_size - ICON_PAD_LEFT - 1;
+ y = vadj_v;
+ }
+ else
+ {
+ x = hadj_v;
+ y = vadj_v;
+ }
+
+ eel_canvas_c2w (EEL_CANVAS (container),
+ x, y,
+ &x, &y);
+
+ l = container->details->icons;
+ best_icon = NULL;
+ best_pos = 0;
+ while (l != NULL)
+ {
+ icon = l->data;
+
+ if (icon_is_positioned (icon))
+ {
+ eel_canvas_item_get_bounds (EEL_CANVAS_ITEM (icon->item),
+ &x1, &y1, &x2, &y2);
+
+ compare_lt = FALSE;
+ if (caja_icon_container_is_layout_vertical (container))
+ {
+ pos = &x1;
+ if (caja_icon_container_is_layout_rtl (container))
+ {
+ compare_lt = TRUE;
+ better_icon = x1 < x + ICON_PAD_LEFT;
+ }
+ else
+ {
+ better_icon = x2 > x + ICON_PAD_LEFT;
+ }
+ }
+ else
+ {
+ pos = &y1;
+ better_icon = y2 > y + ICON_PAD_TOP;
+ }
+ if (better_icon)
+ {
+ if (best_icon == NULL)
+ {
+ better_icon = TRUE;
+ }
+ else if (compare_lt)
+ {
+ better_icon = best_pos < *pos;
+ }
+ else
+ {
+ better_icon = best_pos > *pos;
+ }
+
+ if (better_icon)
+ {
+ best_icon = icon;
+ best_pos = *pos;
+ }
+ }
+ }
+
+ l = l->next;
+ }
+
+ return best_icon ? best_icon->data : NULL;
+}
+
+/* puts the icon at the top of the screen */
+void
+caja_icon_container_scroll_to_icon (CajaIconContainer *container,
+ CajaIconData *data)
+{
+ GList *l;
+ CajaIcon *icon;
+ GtkAdjustment *hadj, *vadj;
+ EelCanvasItem *item;
+ EelIRect bounds;
+ GtkAllocation allocation;
+
+ hadj = gtk_layout_get_hadjustment (GTK_LAYOUT (container));
+ vadj = gtk_layout_get_vadjustment (GTK_LAYOUT (container));
+ gtk_widget_get_allocation (GTK_WIDGET (container), &allocation);
+
+ /* We need to force a relayout now if there are updates queued
+ * since we need the final positions */
+ caja_icon_container_layout_now (container);
+
+ l = container->details->icons;
+ while (l != NULL)
+ {
+ icon = l->data;
+
+ if (icon->data == data &&
+ icon_is_positioned (icon))
+ {
+
+ item = EEL_CANVAS_ITEM (icon->item);
+
+ if (caja_icon_container_is_auto_layout (container))
+ {
+ /* ensure that we reveal the entire row/column */
+ icon_get_row_and_column_bounds (container, icon, &bounds, TRUE);
+ }
+ else
+ {
+ item_get_canvas_bounds (EEL_CANVAS_ITEM (icon->item), &bounds, TRUE);
+ }
+
+ if (caja_icon_container_is_layout_vertical (container))
+ {
+ if (caja_icon_container_is_layout_rtl (container))
+ {
+ eel_gtk_adjustment_set_value (hadj, bounds.x1 - allocation.width);
+ }
+ else
+ {
+ eel_gtk_adjustment_set_value (hadj, bounds.x0);
+ }
+ }
+ else
+ {
+ eel_gtk_adjustment_set_value (vadj, bounds.y0);
+ }
+ }
+
+ l = l->next;
+ }
+}
+
+/* Call a function for all the icons. */
+typedef struct
+{
+ CajaIconCallback callback;
+ gpointer callback_data;
+} CallbackAndData;
+
+static void
+call_icon_callback (gpointer data, gpointer callback_data)
+{
+ CajaIcon *icon;
+ CallbackAndData *callback_and_data;
+
+ icon = data;
+ callback_and_data = callback_data;
+ (* callback_and_data->callback) (icon->data, callback_and_data->callback_data);
+}
+
+void
+caja_icon_container_for_each (CajaIconContainer *container,
+ CajaIconCallback callback,
+ gpointer callback_data)
+{
+ CallbackAndData callback_and_data;
+
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+ callback_and_data.callback = callback;
+ callback_and_data.callback_data = callback_data;
+
+ g_list_foreach (container->details->icons,
+ call_icon_callback, &callback_and_data);
+}
+
+static int
+selection_changed_at_idle_callback (gpointer data)
+{
+ CajaIconContainer *container;
+
+ container = CAJA_ICON_CONTAINER (data);
+
+ g_signal_emit (container,
+ signals[SELECTION_CHANGED], 0);
+
+ container->details->selection_changed_id = 0;
+ return FALSE;
+}
+
+/* utility routine to remove a single icon from the container */
+
+static void
+icon_destroy (CajaIconContainer *container,
+ CajaIcon *icon)
+{
+ CajaIconContainerDetails *details;
+ gboolean was_selected;
+ CajaIcon *icon_to_focus;
+ GList *item;
+
+ details = container->details;
+
+ item = g_list_find (details->icons, icon);
+ item = item->next ? item->next : item->prev;
+ icon_to_focus = (item != NULL) ? item->data : NULL;
+
+ details->icons = g_list_remove (details->icons, icon);
+ details->new_icons = g_list_remove (details->new_icons, icon);
+ g_hash_table_remove (details->icon_set, icon->data);
+
+ was_selected = icon->is_selected;
+
+ if (details->keyboard_focus == icon ||
+ details->keyboard_focus == NULL)
+ {
+ if (icon_to_focus != NULL)
+ {
+ set_keyboard_focus (container, icon_to_focus);
+ }
+ else
+ {
+ clear_keyboard_focus (container);
+ }
+ }
+
+ if (details->keyboard_rubberband_start == icon)
+ {
+ clear_keyboard_rubberband_start (container);
+ }
+
+ if (details->keyboard_icon_to_reveal == icon)
+ {
+ unschedule_keyboard_icon_reveal (container);
+ }
+ if (details->drag_icon == icon)
+ {
+ clear_drag_state (container);
+ }
+ if (details->drop_target == icon)
+ {
+ details->drop_target = NULL;
+ }
+ if (details->range_selection_base_icon == icon)
+ {
+ details->range_selection_base_icon = NULL;
+ }
+ if (details->pending_icon_to_reveal == icon)
+ {
+ set_pending_icon_to_reveal (container, NULL);
+ }
+ if (details->stretch_icon == icon)
+ {
+ details->stretch_icon = NULL;
+ }
+
+ if (icon->is_monitored)
+ {
+ caja_icon_container_stop_monitor_top_left (container,
+ icon->data,
+ icon);
+ }
+ icon_free (icon);
+
+ if (was_selected)
+ {
+ /* Coalesce multiple removals causing multiple selection_changed events */
+ details->selection_changed_id = g_idle_add (selection_changed_at_idle_callback, container);
+ }
+}
+
+/* activate any selected items in the container */
+static void
+activate_selected_items (CajaIconContainer *container)
+{
+ GList *selection;
+
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+ selection = caja_icon_container_get_selection (container);
+ if (selection != NULL)
+ {
+ g_signal_emit (container,
+ signals[ACTIVATE], 0,
+ selection);
+ }
+ g_list_free (selection);
+}
+
+static void
+activate_selected_items_alternate (CajaIconContainer *container,
+ CajaIcon *icon)
+{
+ GList *selection;
+
+ g_assert (CAJA_IS_ICON_CONTAINER (container));
+
+ if (icon != NULL)
+ {
+ selection = g_list_prepend (NULL, icon->data);
+ }
+ else
+ {
+ selection = caja_icon_container_get_selection (container);
+ }
+ if (selection != NULL)
+ {
+ g_signal_emit (container,
+ signals[ACTIVATE_ALTERNATE], 0,
+ selection);
+ }
+ g_list_free (selection);
+}
+
+static CajaIcon *
+get_icon_being_renamed (CajaIconContainer *container)
+{
+ CajaIcon *rename_icon;
+
+ if (!is_renaming (container))
+ {
+ return NULL;
+ }
+
+ g_assert (!has_multiple_selection (container));
+
+ rename_icon = get_first_selected_icon (container);
+ g_assert (rename_icon != NULL);
+
+ return rename_icon;
+}
+
+static CajaIconInfo *
+caja_icon_container_get_icon_images (CajaIconContainer *container,
+ CajaIconData *data,
+ int size,
+ GList **emblem_pixbufs,
+ char **embedded_text,
+ gboolean for_drag_accept,
+ gboolean need_large_embeddded_text,
+ gboolean *embedded_text_needs_loading,
+ gboolean *has_open_window)
+{
+ CajaIconContainerClass *klass;
+
+ klass = CAJA_ICON_CONTAINER_GET_CLASS (container);
+ g_assert (klass->get_icon_images != NULL);
+
+ return klass->get_icon_images (container, data, size, emblem_pixbufs, embedded_text, for_drag_accept, need_large_embeddded_text, embedded_text_needs_loading, has_open_window);
+}
+
+static void
+caja_icon_container_freeze_updates (CajaIconContainer *container)
+{
+ CajaIconContainerClass *klass;
+
+ klass = CAJA_ICON_CONTAINER_GET_CLASS (container);
+ g_assert (klass->freeze_updates != NULL);
+
+ klass->freeze_updates (container);
+}
+
+static void
+caja_icon_container_unfreeze_updates (CajaIconContainer *container)
+{
+ CajaIconContainerClass *klass;
+
+ klass = CAJA_ICON_CONTAINER_GET_CLASS (container);
+ g_assert (klass->unfreeze_updates != NULL);
+
+ klass->unfreeze_updates (container);
+}
+
+static void
+caja_icon_container_start_monitor_top_left (CajaIconContainer *container,
+ CajaIconData *data,
+ gconstpointer client,
+ gboolean large_text)
+{
+ CajaIconContainerClass *klass;
+
+ klass = CAJA_ICON_CONTAINER_GET_CLASS (container);
+ g_assert (klass->start_monitor_top_left != NULL);
+
+ klass->start_monitor_top_left (container, data, client, large_text);
+}
+
+static void
+caja_icon_container_stop_monitor_top_left (CajaIconContainer *container,
+ CajaIconData *data,
+ gconstpointer client)
+{
+ CajaIconContainerClass *klass;
+
+ klass = CAJA_ICON_CONTAINER_GET_CLASS (container);
+ g_return_if_fail (klass->stop_monitor_top_left != NULL);
+
+ klass->stop_monitor_top_left (container, data, client);
+}
+
+
+static void
+caja_icon_container_prioritize_thumbnailing (CajaIconContainer *container,
+ CajaIcon *icon)
+{
+ CajaIconContainerClass *klass;
+
+ klass = CAJA_ICON_CONTAINER_GET_CLASS (container);
+ g_assert (klass->prioritize_thumbnailing != NULL);
+
+ klass->prioritize_thumbnailing (container, icon->data);
+}
+
+static void
+caja_icon_container_update_visible_icons (CajaIconContainer *container)
+{
+ GtkAdjustment *vadj, *hadj;
+ double min_y, max_y;
+ double min_x, max_x;
+ double x0, y0, x1, y1;
+ GList *node;
+ CajaIcon *icon;
+ gboolean visible;
+ GtkAllocation allocation;
+
+ hadj = gtk_layout_get_hadjustment (GTK_LAYOUT (container));
+ vadj = gtk_layout_get_vadjustment (GTK_LAYOUT (container));
+ gtk_widget_get_allocation (GTK_WIDGET (container), &allocation);
+
+ min_x = gtk_adjustment_get_value (hadj);
+ max_x = min_x + allocation.width;
+
+ min_y = gtk_adjustment_get_value (vadj);
+ max_y = min_y + allocation.height;
+
+ eel_canvas_c2w (EEL_CANVAS (container),
+ min_x, min_y, &min_x, &min_y);
+ eel_canvas_c2w (EEL_CANVAS (container),
+ max_x, max_y, &max_x, &max_y);
+
+ /* Do the iteration in reverse to get the render-order from top to
+ * bottom for the prioritized thumbnails.
+ */
+ for (node = g_list_last (container->details->icons); node != NULL; node = node->prev)
+ {
+ icon = node->data;
+
+ if (icon_is_positioned (icon))
+ {
+ eel_canvas_item_get_bounds (EEL_CANVAS_ITEM (icon->item),
+ &x0,
+ &y0,
+ &x1,
+ &y1);
+ eel_canvas_item_i2w (EEL_CANVAS_ITEM (icon->item)->parent,
+ &x0,
+ &y0);
+ eel_canvas_item_i2w (EEL_CANVAS_ITEM (icon->item)->parent,
+ &x1,
+ &y1);
+
+ if (caja_icon_container_is_layout_vertical (container))
+ {
+ visible = x1 >= min_x && x0 <= max_x;
+ }
+ else
+ {
+ visible = y1 >= min_y && y0 <= max_y;
+ }
+
+ if (visible)
+ {
+ caja_icon_canvas_item_set_is_visible (icon->item, TRUE);
+ caja_icon_container_prioritize_thumbnailing (container,
+ icon);
+ }
+ else
+ {
+ caja_icon_canvas_item_set_is_visible (icon->item, FALSE);
+ }
+ }
+ }
+}
+
+static void
+handle_vadjustment_changed (GtkAdjustment *adjustment,
+ CajaIconContainer *container)
+{
+ if (!caja_icon_container_is_layout_vertical (container))
+ {
+ caja_icon_container_update_visible_icons (container);
+ }
+}
+
+static void
+handle_hadjustment_changed (GtkAdjustment *adjustment,
+ CajaIconContainer *container)
+{
+ if (caja_icon_container_is_layout_vertical (container))
+ {
+ caja_icon_container_update_visible_icons (container);
+ }
+}
+
+
+void
+caja_icon_container_update_icon (CajaIconContainer *container,
+ CajaIcon *icon)
+{
+ CajaIconContainerDetails *details;
+ guint icon_size;
+ guint min_image_size, max_image_size;
+ CajaIconInfo *icon_info;
+ GdkPoint *attach_points;
+ int n_attach_points;
+ gboolean has_embedded_text_rect;
+ GdkPixbuf *pixbuf;
+ GList *emblem_pixbufs;
+ char *editable_text, *additional_text;
+ char *embedded_text;
+ GdkRectangle embedded_text_rect;
+ gboolean large_embedded_text;
+ gboolean embedded_text_needs_loading;
+ gboolean has_open_window;
+
+ if (icon == NULL)
+ {
+ return;
+ }
+
+ details = container->details;
+
+ /* compute the maximum size based on the scale factor */
+ min_image_size = MINIMUM_IMAGE_SIZE * EEL_CANVAS (container)->pixels_per_unit;
+ max_image_size = MAX (MAXIMUM_IMAGE_SIZE * EEL_CANVAS (container)->pixels_per_unit, CAJA_ICON_MAXIMUM_SIZE);
+
+ /* Get the appropriate images for the file. */
+ if (container->details->forced_icon_size > 0)
+ {
+ icon_size = container->details->forced_icon_size;
+ }
+ else
+ {
+ icon_get_size (container, icon, &icon_size);
+ }
+
+
+ icon_size = MAX (icon_size, min_image_size);
+ icon_size = MIN (icon_size, max_image_size);
+
+ /* Get the icons. */
+ emblem_pixbufs = NULL;
+ embedded_text = NULL;
+ large_embedded_text = icon_size > ICON_SIZE_FOR_LARGE_EMBEDDED_TEXT;
+ icon_info = caja_icon_container_get_icon_images (container, icon->data, icon_size,
+ &emblem_pixbufs,
+ &embedded_text,
+ icon == details->drop_target,
+ large_embedded_text, &embedded_text_needs_loading,
+ &has_open_window);
+
+
+ if (container->details->forced_icon_size > 0)
+ pixbuf = caja_icon_info_get_pixbuf_at_size (icon_info, icon_size);
+ else
+ pixbuf = caja_icon_info_get_pixbuf (icon_info);
+ caja_icon_info_get_attach_points (icon_info, &attach_points, &n_attach_points);
+ has_embedded_text_rect = caja_icon_info_get_embedded_rect (icon_info,
+ &embedded_text_rect);
+
+ if (has_embedded_text_rect && embedded_text_needs_loading)
+ {
+ icon->is_monitored = TRUE;
+ caja_icon_container_start_monitor_top_left (container, icon->data, icon, large_embedded_text);
+ }
+
+ caja_icon_container_get_icon_text (container,
+ icon->data,
+ &editable_text,
+ &additional_text,
+ FALSE);
+
+ /* If name of icon being renamed was changed from elsewhere, end renaming mode.
+ * Alternatively, we could replace the characters in the editable text widget
+ * with the new name, but that could cause timing problems if the user just
+ * happened to be typing at that moment.
+ */
+ if (icon == get_icon_being_renamed (container) &&
+ eel_strcmp (editable_text,
+ caja_icon_canvas_item_get_editable_text (icon->item)) != 0)
+ {
+ end_renaming_mode (container, FALSE);
+ }
+
+ eel_canvas_item_set (EEL_CANVAS_ITEM (icon->item),
+ "editable_text", editable_text,
+ "additional_text", additional_text,
+ "highlighted_for_drop", icon == details->drop_target,
+ NULL);
+
+ caja_icon_canvas_item_set_image (icon->item, pixbuf);
+ caja_icon_canvas_item_set_attach_points (icon->item, attach_points, n_attach_points);
+ caja_icon_canvas_item_set_emblems (icon->item, emblem_pixbufs);
+ caja_icon_canvas_item_set_embedded_text_rect (icon->item, &embedded_text_rect);
+ caja_icon_canvas_item_set_embedded_text (icon->item, embedded_text);
+
+ /* Let the pixbufs go. */
+ g_object_unref (pixbuf);
+ eel_gdk_pixbuf_list_free (emblem_pixbufs);
+
+ g_free (editable_text);
+ g_free (additional_text);
+
+ g_object_unref (icon_info);
+}
+
+static gboolean
+assign_icon_position (CajaIconContainer *container,
+ CajaIcon *icon)
+{
+ gboolean have_stored_position;
+ CajaIconPosition position;
+
+ /* Get the stored position. */
+ have_stored_position = FALSE;
+ position.scale = 1.0;
+ g_signal_emit (container,
+ signals[GET_STORED_ICON_POSITION], 0,
+ icon->data,
+ &position,
+ &have_stored_position);
+ icon->scale = position.scale;
+ if (!container->details->auto_layout)
+ {
+ if (have_stored_position)
+ {
+ icon_set_position (icon, position.x, position.y);
+ icon->saved_ltr_x = icon->x;
+ }
+ else
+ {
+ return FALSE;
+ }
+ }
+ return TRUE;
+}
+
+static void
+finish_adding_icon (CajaIconContainer *container,
+ CajaIcon *icon)
+{
+ caja_icon_container_update_icon (container, icon);
+ eel_canvas_item_show (EEL_CANVAS_ITEM (icon->item));
+
+ g_signal_connect_object (icon->item, "event",
+ G_CALLBACK (item_event_callback), container, 0);
+
+ g_signal_emit (container, signals[ICON_ADDED], 0, icon->data);
+}
+
+static void
+finish_adding_new_icons (CajaIconContainer *container)
+{
+ GList *p, *new_icons, *no_position_icons, *semi_position_icons;
+ CajaIcon *icon;
+ double bottom;
+
+ new_icons = container->details->new_icons;
+ container->details->new_icons = NULL;
+
+ /* Position most icons (not unpositioned manual-layout icons). */
+ new_icons = g_list_reverse (new_icons);
+ no_position_icons = semi_position_icons = NULL;
+ for (p = new_icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+ if (icon->has_lazy_position)
+ {
+ assign_icon_position (container, icon);
+ semi_position_icons = g_list_prepend (semi_position_icons, icon);
+ }
+ else if (!assign_icon_position (container, icon))
+ {
+ no_position_icons = g_list_prepend (no_position_icons, icon);
+ }
+
+ finish_adding_icon (container, icon);
+ }
+ g_list_free (new_icons);
+
+ if (semi_position_icons != NULL)
+ {
+ PlacementGrid *grid;
+ time_t now;
+ gboolean dummy;
+
+ g_assert (!container->details->auto_layout);
+
+ semi_position_icons = g_list_reverse (semi_position_icons);
+
+ /* This is currently only used on the desktop.
+ * Thus, we pass FALSE for tight, like lay_down_icons_tblr */
+ grid = placement_grid_new (container, FALSE);
+
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+
+ if (icon_is_positioned (icon) && !icon->has_lazy_position)
+ {
+ placement_grid_mark_icon (grid, icon);
+ }
+ }
+
+ now = time (NULL);
+
+ for (p = semi_position_icons; p != NULL; p = p->next)
+ {
+ CajaIcon *icon;
+ CajaIconPosition position;
+ int x, y;
+
+ icon = p->data;
+ x = icon->x;
+ y = icon->y;
+
+ find_empty_location (container, grid,
+ icon, x, y, &x, &y);
+
+ icon_set_position (icon, x, y);
+
+ position.x = icon->x;
+ position.y = icon->y;
+ position.scale = icon->scale;
+ placement_grid_mark_icon (grid, icon);
+ g_signal_emit (container, signals[ICON_POSITION_CHANGED], 0,
+ icon->data, &position);
+ g_signal_emit (container, signals[STORE_LAYOUT_TIMESTAMP], 0,
+ icon->data, &now, &dummy);
+
+ /* ensure that next time we run this code, the formerly semi-positioned
+ * icons are treated as being positioned. */
+ icon->has_lazy_position = FALSE;
+ }
+
+ placement_grid_free (grid);
+
+ g_list_free (semi_position_icons);
+ }
+
+ /* Position the unpositioned manual layout icons. */
+ if (no_position_icons != NULL)
+ {
+ g_assert (!container->details->auto_layout);
+
+ sort_icons (container, &no_position_icons);
+ if (caja_icon_container_get_is_desktop (container))
+ {
+ lay_down_icons (container, no_position_icons, CONTAINER_PAD_TOP);
+ }
+ else
+ {
+ get_all_icon_bounds (container, NULL, NULL, NULL, &bottom, BOUNDS_USAGE_FOR_LAYOUT);
+ lay_down_icons (container, no_position_icons, bottom + ICON_PAD_BOTTOM);
+ }
+ g_list_free (no_position_icons);
+ }
+
+ if (container->details->store_layout_timestamps_when_finishing_new_icons)
+ {
+ store_layout_timestamps_now (container);
+ container->details->store_layout_timestamps_when_finishing_new_icons = FALSE;
+ }
+}
+
+static gboolean
+is_old_or_unknown_icon_data (CajaIconContainer *container,
+ CajaIconData *data)
+{
+ time_t timestamp;
+ gboolean success;
+
+ if (container->details->layout_timestamp == UNDEFINED_TIME)
+ {
+ /* don't know */
+ return FALSE;
+ }
+
+ g_signal_emit (container,
+ signals[GET_STORED_LAYOUT_TIMESTAMP], 0,
+ data, &timestamp, &success);
+ return (!success || timestamp < container->details->layout_timestamp);
+}
+
+/**
+ * caja_icon_container_add:
+ * @container: A CajaIconContainer
+ * @data: Icon data.
+ *
+ * Add icon to represent @data to container.
+ * Returns FALSE if there was already such an icon.
+ **/
+gboolean
+caja_icon_container_add (CajaIconContainer *container,
+ CajaIconData *data)
+{
+ CajaIconContainerDetails *details;
+ CajaIcon *icon;
+ EelCanvasItem *band, *item;
+
+ g_return_val_if_fail (CAJA_IS_ICON_CONTAINER (container), FALSE);
+ g_return_val_if_fail (data != NULL, FALSE);
+
+ details = container->details;
+
+ if (g_hash_table_lookup (details->icon_set, data) != NULL)
+ {
+ return FALSE;
+ }
+
+ /* Create the new icon, including the canvas item. */
+ icon = g_new0 (CajaIcon, 1);
+ icon->data = data;
+ icon->x = ICON_UNPOSITIONED_VALUE;
+ icon->y = ICON_UNPOSITIONED_VALUE;
+
+ /* Whether the saved icon position should only be used
+ * if the previous icon position is free. If the position
+ * is occupied, another position near the last one will
+ */
+ icon->has_lazy_position = is_old_or_unknown_icon_data (container, data);
+ icon->scale = 1.0;
+ icon->item = CAJA_ICON_CANVAS_ITEM
+ (eel_canvas_item_new (EEL_CANVAS_GROUP (EEL_CANVAS (container)->root),
+ caja_icon_canvas_item_get_type (),
+ "visible", FALSE,
+ NULL));
+ icon->item->user_data = icon;
+
+ /* Make sure the icon is under the selection_rectangle */
+ item = EEL_CANVAS_ITEM (icon->item);
+ band = CAJA_ICON_CONTAINER (item->canvas)->details->rubberband_info.selection_rectangle;
+ if (band)
+ {
+ eel_canvas_item_send_behind (item, band);
+ }
+
+ /* Put it on both lists. */
+ details->icons = g_list_prepend (details->icons, icon);
+ details->new_icons = g_list_prepend (details->new_icons, icon);
+
+ g_hash_table_insert (details->icon_set, data, icon);
+
+ /* Run an idle function to add the icons. */
+ schedule_redo_layout (container);
+
+ return TRUE;
+}
+
+void
+caja_icon_container_layout_now (CajaIconContainer *container)
+{
+ if (container->details->idle_id != 0)
+ {
+ unschedule_redo_layout (container);
+ redo_layout_internal (container);
+ }
+
+ /* Also need to make sure we're properly resized, for instance
+ * newly added files may trigger a change in the size allocation and
+ * thus toggle scrollbars on */
+ gtk_container_check_resize (GTK_CONTAINER (gtk_widget_get_parent (GTK_WIDGET (container))));
+}
+
+/**
+ * caja_icon_container_remove:
+ * @container: A CajaIconContainer.
+ * @data: Icon data.
+ *
+ * Remove the icon with this data.
+ **/
+gboolean
+caja_icon_container_remove (CajaIconContainer *container,
+ CajaIconData *data)
+{
+ CajaIcon *icon;
+
+ g_return_val_if_fail (CAJA_IS_ICON_CONTAINER (container), FALSE);
+ g_return_val_if_fail (data != NULL, FALSE);
+
+ end_renaming_mode (container, FALSE);
+
+ icon = g_hash_table_lookup (container->details->icon_set, data);
+
+ if (icon == NULL)
+ {
+ return FALSE;
+ }
+
+ icon_destroy (container, icon);
+ schedule_redo_layout (container);
+
+ g_signal_emit (container, signals[ICON_REMOVED], 0, icon);
+
+ return TRUE;
+}
+
+/**
+ * caja_icon_container_request_update:
+ * @container: A CajaIconContainer.
+ * @data: Icon data.
+ *
+ * Update the icon with this data.
+ **/
+void
+caja_icon_container_request_update (CajaIconContainer *container,
+ CajaIconData *data)
+{
+ CajaIcon *icon;
+
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+ g_return_if_fail (data != NULL);
+
+ icon = g_hash_table_lookup (container->details->icon_set, data);
+
+ if (icon != NULL)
+ {
+ caja_icon_container_update_icon (container, icon);
+ schedule_redo_layout (container);
+ }
+}
+
+/* zooming */
+
+CajaZoomLevel
+caja_icon_container_get_zoom_level (CajaIconContainer *container)
+{
+ return container->details->zoom_level;
+}
+
+void
+caja_icon_container_set_zoom_level (CajaIconContainer *container, int new_level)
+{
+ CajaIconContainerDetails *details;
+ int pinned_level;
+ double pixels_per_unit;
+
+ details = container->details;
+
+ end_renaming_mode (container, TRUE);
+
+ pinned_level = new_level;
+ if (pinned_level < CAJA_ZOOM_LEVEL_SMALLEST)
+ {
+ pinned_level = CAJA_ZOOM_LEVEL_SMALLEST;
+ }
+ else if (pinned_level > CAJA_ZOOM_LEVEL_LARGEST)
+ {
+ pinned_level = CAJA_ZOOM_LEVEL_LARGEST;
+ }
+
+ if (pinned_level == details->zoom_level)
+ {
+ return;
+ }
+
+ details->zoom_level = pinned_level;
+
+ pixels_per_unit = (double) caja_get_icon_size_for_zoom_level (pinned_level)
+ / CAJA_ICON_SIZE_STANDARD;
+ eel_canvas_set_pixels_per_unit (EEL_CANVAS (container), pixels_per_unit);
+
+ invalidate_labels (container);
+ caja_icon_container_request_update_all (container);
+}
+
+/**
+ * caja_icon_container_request_update_all:
+ * For each icon, synchronizes the displayed information (image, text) with the
+ * information from the model.
+ *
+ * @container: An icon container.
+ **/
+void
+caja_icon_container_request_update_all (CajaIconContainer *container)
+{
+ GList *node;
+ CajaIcon *icon;
+
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+ for (node = container->details->icons; node != NULL; node = node->next)
+ {
+ icon = node->data;
+ caja_icon_container_update_icon (container, icon);
+ }
+
+ redo_layout (container);
+}
+
+/**
+ * caja_icon_container_reveal:
+ * Change scroll position as necessary to reveal the specified item.
+ */
+void
+caja_icon_container_reveal (CajaIconContainer *container, CajaIconData *data)
+{
+ CajaIcon *icon;
+
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+ g_return_if_fail (data != NULL);
+
+ icon = g_hash_table_lookup (container->details->icon_set, data);
+
+ if (icon != NULL)
+ {
+ reveal_icon (container, icon);
+ }
+}
+
+/**
+ * caja_icon_container_get_selection:
+ * @container: An icon container.
+ *
+ * Get a list of the icons currently selected in @container.
+ *
+ * Return value: A GList of the programmer-specified data associated to each
+ * selected icon, or NULL if no icon is selected. The caller is expected to
+ * free the list when it is not needed anymore.
+ **/
+GList *
+caja_icon_container_get_selection (CajaIconContainer *container)
+{
+ GList *list, *p;
+
+ g_return_val_if_fail (CAJA_IS_ICON_CONTAINER (container), NULL);
+
+ list = NULL;
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ CajaIcon *icon;
+
+ icon = p->data;
+ if (icon->is_selected)
+ {
+ list = g_list_prepend (list, icon->data);
+ }
+ }
+
+ return g_list_reverse (list);
+}
+
+static GList *
+caja_icon_container_get_selected_icons (CajaIconContainer *container)
+{
+ GList *list, *p;
+
+ g_return_val_if_fail (CAJA_IS_ICON_CONTAINER (container), NULL);
+
+ list = NULL;
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ CajaIcon *icon;
+
+ icon = p->data;
+ if (icon->is_selected)
+ {
+ list = g_list_prepend (list, icon);
+ }
+ }
+
+ return g_list_reverse (list);
+}
+
+/**
+ * caja_icon_container_invert_selection:
+ * @container: An icon container.
+ *
+ * Inverts the selection in @container.
+ *
+ **/
+void
+caja_icon_container_invert_selection (CajaIconContainer *container)
+{
+ GList *p;
+
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ CajaIcon *icon;
+
+ icon = p->data;
+ icon_toggle_selected (container, icon);
+ }
+
+ g_signal_emit (container, signals[SELECTION_CHANGED], 0);
+}
+
+
+/* Returns an array of GdkPoints of locations of the icons. */
+static GArray *
+caja_icon_container_get_icon_locations (CajaIconContainer *container,
+ GList *icons)
+{
+ GArray *result;
+ GList *node;
+ int index;
+
+ result = g_array_new (FALSE, TRUE, sizeof (GdkPoint));
+ result = g_array_set_size (result, g_list_length (icons));
+
+ for (index = 0, node = icons; node != NULL; index++, node = node->next)
+ {
+ g_array_index (result, GdkPoint, index).x =
+ ((CajaIcon *)node->data)->x;
+ g_array_index (result, GdkPoint, index).y =
+ ((CajaIcon *)node->data)->y;
+ }
+
+ return result;
+}
+
+/**
+ * caja_icon_container_get_selected_icon_locations:
+ * @container: An icon container widget.
+ *
+ * Returns an array of GdkPoints of locations of the selected icons.
+ **/
+GArray *
+caja_icon_container_get_selected_icon_locations (CajaIconContainer *container)
+{
+ GArray *result;
+ GList *icons;
+
+ g_return_val_if_fail (CAJA_IS_ICON_CONTAINER (container), NULL);
+
+ icons = caja_icon_container_get_selected_icons (container);
+ result = caja_icon_container_get_icon_locations (container, icons);
+ g_list_free (icons);
+
+ return result;
+}
+
+/**
+ * caja_icon_container_select_all:
+ * @container: An icon container widget.
+ *
+ * Select all the icons in @container at once.
+ **/
+void
+caja_icon_container_select_all (CajaIconContainer *container)
+{
+ gboolean selection_changed;
+ GList *p;
+ CajaIcon *icon;
+
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+ selection_changed = FALSE;
+
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+
+ selection_changed |= icon_set_selected (container, icon, TRUE);
+ }
+
+ if (selection_changed)
+ {
+ g_signal_emit (container,
+ signals[SELECTION_CHANGED], 0);
+ }
+}
+
+/**
+ * caja_icon_container_set_selection:
+ * @container: An icon container widget.
+ * @selection: A list of CajaIconData *.
+ *
+ * Set the selection to exactly the icons in @container which have
+ * programmer data matching one of the items in @selection.
+ **/
+void
+caja_icon_container_set_selection (CajaIconContainer *container,
+ GList *selection)
+{
+ gboolean selection_changed;
+ GHashTable *hash;
+ GList *p;
+ CajaIcon *icon;
+
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+ selection_changed = FALSE;
+
+ hash = g_hash_table_new (NULL, NULL);
+ for (p = selection; p != NULL; p = p->next)
+ {
+ g_hash_table_insert (hash, p->data, p->data);
+ }
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+
+ selection_changed |= icon_set_selected
+ (container, icon,
+ g_hash_table_lookup (hash, icon->data) != NULL);
+ }
+ g_hash_table_destroy (hash);
+
+ if (selection_changed)
+ {
+ g_signal_emit (container,
+ signals[SELECTION_CHANGED], 0);
+ }
+}
+
+/**
+ * caja_icon_container_select_list_unselect_others.
+ * @container: An icon container widget.
+ * @selection: A list of CajaIcon *.
+ *
+ * Set the selection to exactly the icons in @selection.
+ **/
+void
+caja_icon_container_select_list_unselect_others (CajaIconContainer *container,
+ GList *selection)
+{
+ gboolean selection_changed;
+ GHashTable *hash;
+ GList *p;
+ CajaIcon *icon;
+
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+ selection_changed = FALSE;
+
+ hash = g_hash_table_new (NULL, NULL);
+ for (p = selection; p != NULL; p = p->next)
+ {
+ g_hash_table_insert (hash, p->data, p->data);
+ }
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+
+ selection_changed |= icon_set_selected
+ (container, icon,
+ g_hash_table_lookup (hash, icon) != NULL);
+ }
+ g_hash_table_destroy (hash);
+
+ if (selection_changed)
+ {
+ g_signal_emit (container,
+ signals[SELECTION_CHANGED], 0);
+ }
+}
+
+/**
+ * caja_icon_container_unselect_all:
+ * @container: An icon container widget.
+ *
+ * Deselect all the icons in @container.
+ **/
+void
+caja_icon_container_unselect_all (CajaIconContainer *container)
+{
+ if (unselect_all (container))
+ {
+ g_signal_emit (container,
+ signals[SELECTION_CHANGED], 0);
+ }
+}
+
+/**
+ * caja_icon_container_get_icon_by_uri:
+ * @container: An icon container widget.
+ * @uri: The uri of an icon to find.
+ *
+ * Locate an icon, given the URI. The URI must match exactly.
+ * Later we may have to have some way of figuring out if the
+ * URI specifies the same object that does not require an exact match.
+ **/
+CajaIcon *
+caja_icon_container_get_icon_by_uri (CajaIconContainer *container,
+ const char *uri)
+{
+ CajaIconContainerDetails *details;
+ GList *p;
+
+ /* Eventually, we must avoid searching the entire icon list,
+ but it's OK for now.
+ A hash table mapping uri to icon is one possibility.
+ */
+
+ details = container->details;
+
+ for (p = details->icons; p != NULL; p = p->next)
+ {
+ CajaIcon *icon;
+ char *icon_uri;
+ gboolean is_match;
+
+ icon = p->data;
+
+ icon_uri = caja_icon_container_get_icon_uri
+ (container, icon);
+ is_match = strcmp (uri, icon_uri) == 0;
+ g_free (icon_uri);
+
+ if (is_match)
+ {
+ return icon;
+ }
+ }
+
+ return NULL;
+}
+
+static CajaIcon *
+get_nth_selected_icon (CajaIconContainer *container, int index)
+{
+ GList *p;
+ CajaIcon *icon;
+ int selection_count;
+
+ g_assert (index > 0);
+
+ /* Find the nth selected icon. */
+ selection_count = 0;
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+ if (icon->is_selected)
+ {
+ if (++selection_count == index)
+ {
+ return icon;
+ }
+ }
+ }
+ return NULL;
+}
+
+static CajaIcon *
+get_first_selected_icon (CajaIconContainer *container)
+{
+ return get_nth_selected_icon (container, 1);
+}
+
+static gboolean
+has_multiple_selection (CajaIconContainer *container)
+{
+ return get_nth_selected_icon (container, 2) != NULL;
+}
+
+static gboolean
+all_selected (CajaIconContainer *container)
+{
+ GList *p;
+ CajaIcon *icon;
+
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+ if (!icon->is_selected)
+ {
+ return FALSE;
+ }
+ }
+ return TRUE;
+}
+
+static gboolean
+has_selection (CajaIconContainer *container)
+{
+ return get_nth_selected_icon (container, 1) != NULL;
+}
+
+/**
+ * caja_icon_container_show_stretch_handles:
+ * @container: An icon container widget.
+ *
+ * Makes stretch handles visible on the first selected icon.
+ **/
+void
+caja_icon_container_show_stretch_handles (CajaIconContainer *container)
+{
+ CajaIconContainerDetails *details;
+ CajaIcon *icon;
+ guint initial_size;
+
+ icon = get_first_selected_icon (container);
+ if (icon == NULL)
+ {
+ return;
+ }
+
+ /* Check if it already has stretch handles. */
+ details = container->details;
+ if (details->stretch_icon == icon)
+ {
+ return;
+ }
+
+ /* Get rid of the existing stretch handles and put them on the new icon. */
+ if (details->stretch_icon != NULL)
+ {
+ caja_icon_canvas_item_set_show_stretch_handles
+ (details->stretch_icon->item, FALSE);
+ ungrab_stretch_icon (container);
+ emit_stretch_ended (container, details->stretch_icon);
+ }
+ caja_icon_canvas_item_set_show_stretch_handles (icon->item, TRUE);
+ details->stretch_icon = icon;
+
+ icon_get_size (container, icon, &initial_size);
+
+ /* only need to keep size in one dimension, since they are constrained to be the same */
+ container->details->stretch_initial_x = icon->x;
+ container->details->stretch_initial_y = icon->y;
+ container->details->stretch_initial_size = initial_size;
+
+ emit_stretch_started (container, icon);
+}
+
+/**
+ * caja_icon_container_has_stretch_handles
+ * @container: An icon container widget.
+ *
+ * Returns true if the first selected item has stretch handles.
+ **/
+gboolean
+caja_icon_container_has_stretch_handles (CajaIconContainer *container)
+{
+ CajaIcon *icon;
+
+ icon = get_first_selected_icon (container);
+ if (icon == NULL)
+ {
+ return FALSE;
+ }
+
+ return icon == container->details->stretch_icon;
+}
+
+/**
+ * caja_icon_container_is_stretched
+ * @container: An icon container widget.
+ *
+ * Returns true if the any selected item is stretched to a size other than 1.0.
+ **/
+gboolean
+caja_icon_container_is_stretched (CajaIconContainer *container)
+{
+ GList *p;
+ CajaIcon *icon;
+
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+ if (icon->is_selected && icon->scale != 1.0)
+ {
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+/**
+ * caja_icon_container_unstretch
+ * @container: An icon container widget.
+ *
+ * Gets rid of any icon stretching.
+ **/
+void
+caja_icon_container_unstretch (CajaIconContainer *container)
+{
+ GList *p;
+ CajaIcon *icon;
+
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+ if (icon->is_selected)
+ {
+ caja_icon_container_move_icon (container, icon,
+ icon->x, icon->y,
+ 1.0,
+ FALSE, TRUE, TRUE);
+ }
+ }
+}
+
+static void
+compute_stretch (StretchState *start,
+ StretchState *current)
+{
+ gboolean right, bottom;
+ int x_stretch, y_stretch;
+
+ /* FIXME bugzilla.gnome.org 45390: This doesn't correspond to
+ * the way the handles are drawn.
+ */
+ /* Figure out which handle we are dragging. */
+ right = start->pointer_x > start->icon_x + (int) start->icon_size / 2;
+ bottom = start->pointer_y > start->icon_y + (int) start->icon_size / 2;
+
+ /* Figure out how big we should stretch. */
+ x_stretch = start->pointer_x - current->pointer_x;
+ y_stretch = start->pointer_y - current->pointer_y;
+ if (right)
+ {
+ x_stretch = - x_stretch;
+ }
+ if (bottom)
+ {
+ y_stretch = - y_stretch;
+ }
+ current->icon_size = MAX ((int) start->icon_size + MIN (x_stretch, y_stretch),
+ (int) CAJA_ICON_SIZE_SMALLEST);
+
+ /* Figure out where the corner of the icon should be. */
+ current->icon_x = start->icon_x;
+ if (!right)
+ {
+ current->icon_x += start->icon_size - current->icon_size;
+ }
+ current->icon_y = start->icon_y;
+ if (!bottom)
+ {
+ current->icon_y += start->icon_size - current->icon_size;
+ }
+}
+
+char *
+caja_icon_container_get_icon_uri (CajaIconContainer *container,
+ CajaIcon *icon)
+{
+ char *uri;
+
+ uri = NULL;
+ g_signal_emit (container,
+ signals[GET_ICON_URI], 0,
+ icon->data,
+ &uri);
+ return uri;
+}
+
+char *
+caja_icon_container_get_icon_drop_target_uri (CajaIconContainer *container,
+ CajaIcon *icon)
+{
+ char *uri;
+
+ uri = NULL;
+ g_signal_emit (container,
+ signals[GET_ICON_DROP_TARGET_URI], 0,
+ icon->data,
+ &uri);
+ return uri;
+}
+
+/* Call to reset the scroll region only if the container is not empty,
+ * to avoid having the flag linger until the next file is added.
+ */
+static void
+reset_scroll_region_if_not_empty (CajaIconContainer *container)
+{
+ if (!caja_icon_container_is_empty (container))
+ {
+ caja_icon_container_reset_scroll_region (container);
+ }
+}
+
+/* Switch from automatic layout to manual or vice versa.
+ * If we switch to manual layout, we restore the icon positions from the
+ * last manual layout.
+ */
+void
+caja_icon_container_set_auto_layout (CajaIconContainer *container,
+ gboolean auto_layout)
+{
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+ g_return_if_fail (auto_layout == FALSE || auto_layout == TRUE);
+
+ if (container->details->auto_layout == auto_layout)
+ {
+ return;
+ }
+
+ reset_scroll_region_if_not_empty (container);
+ container->details->auto_layout = auto_layout;
+
+ if (!auto_layout)
+ {
+ reload_icon_positions (container);
+ caja_icon_container_freeze_icon_positions (container);
+ }
+
+ redo_layout (container);
+
+ g_signal_emit (container, signals[LAYOUT_CHANGED], 0);
+}
+
+
+/* Toggle the tighter layout boolean. */
+void
+caja_icon_container_set_tighter_layout (CajaIconContainer *container,
+ gboolean tighter_layout)
+{
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+ g_return_if_fail (tighter_layout == FALSE || tighter_layout == TRUE);
+
+ if (container->details->tighter_layout == tighter_layout)
+ {
+ return;
+ }
+
+ container->details->tighter_layout = tighter_layout;
+
+ if (container->details->auto_layout)
+ {
+ invalidate_label_sizes (container);
+ redo_layout (container);
+
+ g_signal_emit (container, signals[LAYOUT_CHANGED], 0);
+ }
+ else
+ {
+ /* in manual layout, label sizes still change, even though
+ * the icons don't move.
+ */
+ invalidate_label_sizes (container);
+ caja_icon_container_request_update_all (container);
+ }
+}
+
+gboolean
+caja_icon_container_is_keep_aligned (CajaIconContainer *container)
+{
+ return container->details->keep_aligned;
+}
+
+static gboolean
+align_icons_callback (gpointer callback_data)
+{
+ CajaIconContainer *container;
+
+ container = CAJA_ICON_CONTAINER (callback_data);
+ align_icons (container);
+ container->details->align_idle_id = 0;
+
+ return FALSE;
+}
+
+static void
+unschedule_align_icons (CajaIconContainer *container)
+{
+ if (container->details->align_idle_id != 0)
+ {
+ g_source_remove (container->details->align_idle_id);
+ container->details->align_idle_id = 0;
+ }
+}
+
+static void
+schedule_align_icons (CajaIconContainer *container)
+{
+ if (container->details->align_idle_id == 0
+ && container->details->has_been_allocated)
+ {
+ container->details->align_idle_id = g_idle_add
+ (align_icons_callback, container);
+ }
+}
+
+void
+caja_icon_container_set_keep_aligned (CajaIconContainer *container,
+ gboolean keep_aligned)
+{
+ if (container->details->keep_aligned != keep_aligned)
+ {
+ container->details->keep_aligned = keep_aligned;
+
+ if (keep_aligned && !container->details->auto_layout)
+ {
+ schedule_align_icons (container);
+ }
+ else
+ {
+ unschedule_align_icons (container);
+ }
+ }
+}
+
+void
+caja_icon_container_set_layout_mode (CajaIconContainer *container,
+ CajaIconLayoutMode mode)
+{
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+ container->details->layout_mode = mode;
+ invalidate_labels (container);
+
+ redo_layout (container);
+
+ g_signal_emit (container, signals[LAYOUT_CHANGED], 0);
+}
+
+void
+caja_icon_container_set_label_position (CajaIconContainer *container,
+ CajaIconLabelPosition position)
+{
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+ if (container->details->label_position != position)
+ {
+ container->details->label_position = position;
+
+ invalidate_labels (container);
+ caja_icon_container_request_update_all (container);
+
+ schedule_redo_layout (container);
+ }
+}
+
+/* Switch from automatic to manual layout, freezing all the icons in their
+ * current positions instead of restoring icon positions from the last manual
+ * layout as set_auto_layout does.
+ */
+void
+caja_icon_container_freeze_icon_positions (CajaIconContainer *container)
+{
+ gboolean changed;
+ GList *p;
+ CajaIcon *icon;
+ CajaIconPosition position;
+
+ changed = container->details->auto_layout;
+ container->details->auto_layout = FALSE;
+
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+
+ position.x = icon->saved_ltr_x;
+ position.y = icon->y;
+ position.scale = icon->scale;
+ g_signal_emit (container, signals[ICON_POSITION_CHANGED], 0,
+ icon->data, &position);
+ }
+
+ if (changed)
+ {
+ g_signal_emit (container, signals[LAYOUT_CHANGED], 0);
+ }
+}
+
+/* Re-sort, switching to automatic layout if it was in manual layout. */
+void
+caja_icon_container_sort (CajaIconContainer *container)
+{
+ gboolean changed;
+
+ changed = !container->details->auto_layout;
+ container->details->auto_layout = TRUE;
+
+ reset_scroll_region_if_not_empty (container);
+ redo_layout (container);
+
+ if (changed)
+ {
+ g_signal_emit (container, signals[LAYOUT_CHANGED], 0);
+ }
+}
+
+gboolean
+caja_icon_container_is_auto_layout (CajaIconContainer *container)
+{
+ g_return_val_if_fail (CAJA_IS_ICON_CONTAINER (container), FALSE);
+
+ return container->details->auto_layout;
+}
+
+gboolean
+caja_icon_container_is_tighter_layout (CajaIconContainer *container)
+{
+ g_return_val_if_fail (CAJA_IS_ICON_CONTAINER (container), FALSE);
+
+ return container->details->tighter_layout;
+}
+
+static void
+pending_icon_to_rename_destroy_callback (CajaIconCanvasItem *item, CajaIconContainer *container)
+{
+ g_assert (container->details->pending_icon_to_rename != NULL);
+ g_assert (container->details->pending_icon_to_rename->item == item);
+ container->details->pending_icon_to_rename = NULL;
+}
+
+static CajaIcon*
+get_pending_icon_to_rename (CajaIconContainer *container)
+{
+ return container->details->pending_icon_to_rename;
+}
+
+static void
+set_pending_icon_to_rename (CajaIconContainer *container, CajaIcon *icon)
+{
+ CajaIcon *old_icon;
+
+ old_icon = container->details->pending_icon_to_rename;
+
+ if (icon == old_icon)
+ {
+ return;
+ }
+
+ if (old_icon != NULL)
+ {
+ g_signal_handlers_disconnect_by_func
+ (old_icon->item,
+ G_CALLBACK (pending_icon_to_rename_destroy_callback),
+ container);
+ }
+
+ if (icon != NULL)
+ {
+ g_signal_connect (icon->item, "destroy",
+ G_CALLBACK (pending_icon_to_rename_destroy_callback), container);
+ }
+
+ container->details->pending_icon_to_rename = icon;
+}
+
+static void
+process_pending_icon_to_rename (CajaIconContainer *container)
+{
+ CajaIcon *pending_icon_to_rename;
+
+ pending_icon_to_rename = get_pending_icon_to_rename (container);
+
+ if (pending_icon_to_rename != NULL)
+ {
+ if (pending_icon_to_rename->is_selected && !has_multiple_selection (container))
+ {
+ caja_icon_container_start_renaming_selected_item (container, FALSE);
+ }
+ else
+ {
+ set_pending_icon_to_rename (container, NULL);
+ }
+ }
+}
+
+static gboolean
+is_renaming_pending (CajaIconContainer *container)
+{
+ return get_pending_icon_to_rename (container) != NULL;
+}
+
+static gboolean
+is_renaming (CajaIconContainer *container)
+{
+ return container->details->renaming;
+}
+
+/**
+ * caja_icon_container_start_renaming_selected_item
+ * @container: An icon container widget.
+ * @select_all: Whether the whole file should initially be selected, or
+ * only its basename (i.e. everything except its extension).
+ *
+ * Displays the edit name widget on the first selected icon
+ **/
+void
+caja_icon_container_start_renaming_selected_item (CajaIconContainer *container,
+ gboolean select_all)
+{
+ CajaIconContainerDetails *details;
+ CajaIcon *icon;
+ EelDRect icon_rect;
+ EelDRect text_rect;
+ PangoContext *context;
+ PangoFontDescription *desc;
+ const char *editable_text;
+ int x, y, width;
+ int start_offset, end_offset;
+
+ /* Check if it already in renaming mode, if so - select all */
+ details = container->details;
+ if (details->renaming)
+ {
+ eel_editable_label_select_region (EEL_EDITABLE_LABEL (details->rename_widget),
+ 0,
+ -1);
+ return;
+ }
+
+ /* Find selected icon */
+ icon = get_first_selected_icon (container);
+ if (icon == NULL)
+ {
+ return;
+ }
+
+ g_assert (!has_multiple_selection (container));
+
+
+ if (!icon_is_positioned (icon))
+ {
+ set_pending_icon_to_rename (container, icon);
+ return;
+ }
+
+ set_pending_icon_to_rename (container, NULL);
+
+ /* Make a copy of the original editable text for a later compare */
+ editable_text = caja_icon_canvas_item_get_editable_text (icon->item);
+
+ /* This could conceivably be NULL if a rename was triggered really early. */
+ if (editable_text == NULL)
+ {
+ return;
+ }
+
+ details->original_text = g_strdup (editable_text);
+
+ /* Freeze updates so files added while renaming don't cause rename to loose focus, bug #318373 */
+ caja_icon_container_freeze_updates (container);
+
+ /* Create text renaming widget, if it hasn't been created already.
+ * We deal with the broken icon text item widget by keeping it around
+ * so its contents can still be cut and pasted as part of the clipboard
+ */
+ if (details->rename_widget == NULL)
+ {
+ details->rename_widget = eel_editable_label_new ("Test text");
+ eel_editable_label_set_line_wrap (EEL_EDITABLE_LABEL (details->rename_widget), TRUE);
+ eel_editable_label_set_line_wrap_mode (EEL_EDITABLE_LABEL (details->rename_widget), PANGO_WRAP_WORD_CHAR);
+ eel_editable_label_set_draw_outline (EEL_EDITABLE_LABEL (details->rename_widget), TRUE);
+
+ if (details->label_position != CAJA_ICON_LABEL_POSITION_BESIDE)
+ {
+ eel_editable_label_set_justify (EEL_EDITABLE_LABEL (details->rename_widget), GTK_JUSTIFY_CENTER);
+ }
+
+ gtk_misc_set_padding (GTK_MISC (details->rename_widget), 1, 1);
+ gtk_layout_put (GTK_LAYOUT (container),
+ details->rename_widget, 0, 0);
+ }
+
+ /* Set the right font */
+ if (details->font)
+ {
+ desc = pango_font_description_from_string (details->font);
+ }
+ else
+ {
+ context = gtk_widget_get_pango_context (GTK_WIDGET (container));
+ desc = pango_font_description_copy (pango_context_get_font_description (context));
+ pango_font_description_set_size (desc,
+ pango_font_description_get_size (desc) +
+ container->details->font_size_table [container->details->zoom_level]);
+ }
+ eel_editable_label_set_font_description (EEL_EDITABLE_LABEL (details->rename_widget),
+ desc);
+ pango_font_description_free (desc);
+
+ icon_rect = caja_icon_canvas_item_get_icon_rectangle (icon->item);
+ text_rect = caja_icon_canvas_item_get_text_rectangle (icon->item, TRUE);
+
+ if (caja_icon_container_is_layout_vertical (container) &&
+ container->details->label_position == CAJA_ICON_LABEL_POSITION_BESIDE)
+ {
+ /* for one-line editables, the width changes dynamically */
+ width = -1;
+ }
+ else
+ {
+ width = caja_icon_canvas_item_get_max_text_width (icon->item);
+ }
+
+ if (details->label_position == CAJA_ICON_LABEL_POSITION_BESIDE)
+ {
+ eel_canvas_w2c (EEL_CANVAS_ITEM (icon->item)->canvas,
+ text_rect.x0,
+ text_rect.y0,
+ &x, &y);
+ }
+ else
+ {
+ eel_canvas_w2c (EEL_CANVAS_ITEM (icon->item)->canvas,
+ (icon_rect.x0 + icon_rect.x1) / 2,
+ icon_rect.y1,
+ &x, &y);
+ x = x - width / 2 - 1;
+ }
+
+ gtk_layout_move (GTK_LAYOUT (container),
+ details->rename_widget,
+ x, y);
+
+ gtk_widget_set_size_request (details->rename_widget,
+ width, -1);
+ eel_editable_label_set_text (EEL_EDITABLE_LABEL (details->rename_widget),
+ editable_text);
+ if (select_all)
+ {
+ start_offset = 0;
+ end_offset = -1;
+ }
+ else
+ {
+ eel_filename_get_rename_region (editable_text, &start_offset, &end_offset);
+ }
+ eel_editable_label_select_region (EEL_EDITABLE_LABEL (details->rename_widget),
+ start_offset,
+ end_offset);
+ gtk_widget_show (details->rename_widget);
+
+ gtk_widget_grab_focus (details->rename_widget);
+
+ g_signal_emit (container,
+ signals[RENAMING_ICON], 0,
+ GTK_EDITABLE (details->rename_widget));
+
+ caja_icon_container_update_icon (container, icon);
+
+ /* We are in renaming mode */
+ details->renaming = TRUE;
+ caja_icon_canvas_item_set_renaming (icon->item, TRUE);
+}
+
+static void
+end_renaming_mode (CajaIconContainer *container, gboolean commit)
+{
+ CajaIcon *icon;
+ const char *changed_text;
+
+ set_pending_icon_to_rename (container, NULL);
+
+ icon = get_icon_being_renamed (container);
+ if (icon == NULL)
+ {
+ return;
+ }
+
+ /* We are not in renaming mode */
+ container->details->renaming = FALSE;
+ caja_icon_canvas_item_set_renaming (icon->item, FALSE);
+
+ caja_icon_container_unfreeze_updates (container);
+
+ if (commit)
+ {
+ set_pending_icon_to_reveal (container, icon);
+ }
+
+ gtk_widget_grab_focus (GTK_WIDGET (container));
+
+ if (commit)
+ {
+ /* Verify that text has been modified before signalling change. */
+ changed_text = eel_editable_label_get_text (EEL_EDITABLE_LABEL (container->details->rename_widget));
+ if (strcmp (container->details->original_text, changed_text) != 0)
+ {
+ g_signal_emit (container,
+ signals[ICON_TEXT_CHANGED], 0,
+ icon->data,
+ changed_text);
+ }
+ }
+
+ gtk_widget_hide (container->details->rename_widget);
+
+ g_free (container->details->original_text);
+
+}
+
+/* emit preview signal, called by the canvas item */
+gboolean
+caja_icon_container_emit_preview_signal (CajaIconContainer *icon_container,
+ CajaIcon *icon,
+ gboolean start_flag)
+{
+ gboolean result;
+
+ g_return_val_if_fail (CAJA_IS_ICON_CONTAINER (icon_container), FALSE);
+ g_return_val_if_fail (icon != NULL, FALSE);
+ g_return_val_if_fail (start_flag == FALSE || start_flag == TRUE, FALSE);
+
+ result = FALSE;
+ g_signal_emit (icon_container,
+ signals[PREVIEW], 0,
+ icon->data,
+ start_flag,
+ &result);
+
+ return result;
+}
+
+gboolean
+caja_icon_container_has_stored_icon_positions (CajaIconContainer *container)
+{
+ GList *p;
+ CajaIcon *icon;
+ gboolean have_stored_position;
+ CajaIconPosition position;
+
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+
+ have_stored_position = FALSE;
+ g_signal_emit (container,
+ signals[GET_STORED_ICON_POSITION], 0,
+ icon->data,
+ &position,
+ &have_stored_position);
+ if (have_stored_position)
+ {
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
+void
+caja_icon_container_set_single_click_mode (CajaIconContainer *container,
+ gboolean single_click_mode)
+{
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+ container->details->single_click_mode = single_click_mode;
+}
+
+
+/* update the label color when the background changes */
+
+GdkGC *
+caja_icon_container_get_label_color_and_gc (CajaIconContainer *container,
+ GdkColor **color,
+ gboolean is_name,
+ gboolean is_highlight,
+ gboolean is_prelit)
+{
+ int idx;
+
+ if (is_name)
+ {
+ if (is_highlight)
+ {
+ if (gtk_widget_has_focus (GTK_WIDGET (container)))
+ {
+ idx = LABEL_COLOR_HIGHLIGHT;
+ }
+ else
+ {
+ idx = LABEL_COLOR_ACTIVE;
+ }
+ }
+ else
+ {
+ if (is_prelit)
+ {
+ idx = LABEL_COLOR_PRELIGHT;
+ }
+ else
+ {
+ idx = LABEL_COLOR;
+ }
+ }
+ }
+ else
+ {
+ if (is_highlight)
+ {
+ if (gtk_widget_has_focus (GTK_WIDGET (container)))
+ {
+ idx = LABEL_INFO_COLOR_HIGHLIGHT;
+ }
+ else
+ {
+ idx = LABEL_INFO_COLOR_ACTIVE;
+ }
+ }
+ else
+ {
+ idx = LABEL_INFO_COLOR;
+ }
+ }
+
+ if (color)
+ {
+ *color = &container->details->label_colors [idx];
+ }
+
+ return container->details->label_gcs [idx];
+}
+
+static void
+setup_gc_with_fg (CajaIconContainer *container, int idx, guint32 color)
+{
+ GdkGC *gc;
+ GdkColor gcolor;
+
+ gcolor = eel_gdk_rgb_to_color (color);
+ container->details->label_colors [idx] = gcolor;
+
+ gc = gdk_gc_new (gtk_layout_get_bin_window (GTK_LAYOUT (container)));
+ gdk_gc_set_rgb_fg_color (gc, &gcolor);
+
+ if (container->details->label_gcs [idx])
+ {
+ g_object_unref (container->details->label_gcs [idx]);
+ }
+
+ container->details->label_gcs [idx] = gc;
+}
+
+static void
+setup_label_gcs (CajaIconContainer *container)
+{
+ EelBackground *background;
+ GtkWidget *widget;
+ GdkColor *light_info_color, *dark_info_color;
+ guint light_info_value, dark_info_value;
+ gboolean frame_text;
+ GtkStyle *style;
+
+ if (!gtk_widget_get_realized (GTK_WIDGET (container)))
+ return;
+
+ widget = GTK_WIDGET (container);
+
+ g_assert (CAJA_IS_ICON_CONTAINER (container));
+
+ background = eel_get_widget_background (GTK_WIDGET (container));
+
+ /* read the info colors from the current theme; use a reasonable default if undefined */
+ gtk_widget_style_get (GTK_WIDGET (container),
+ "light_info_color", &light_info_color,
+ "dark_info_color", &dark_info_color,
+ NULL);
+ style = gtk_widget_get_style (widget);
+
+ if (light_info_color)
+ {
+ light_info_value = eel_gdk_color_to_rgb (light_info_color);
+ gdk_color_free (light_info_color);
+ }
+ else
+ {
+ light_info_value = DEFAULT_LIGHT_INFO_COLOR;
+ }
+
+ if (dark_info_color)
+ {
+ dark_info_value = eel_gdk_color_to_rgb (dark_info_color);
+ gdk_color_free (dark_info_color);
+ }
+ else
+ {
+ dark_info_value = DEFAULT_DARK_INFO_COLOR;
+ }
+
+ setup_gc_with_fg (container, LABEL_COLOR_HIGHLIGHT, eel_gdk_color_to_rgb (&style->text[GTK_STATE_SELECTED]));
+ setup_gc_with_fg (container, LABEL_COLOR_ACTIVE, eel_gdk_color_to_rgb (&style->text[GTK_STATE_ACTIVE]));
+ setup_gc_with_fg (container, LABEL_COLOR_PRELIGHT, eel_gdk_color_to_rgb (&style->text[GTK_STATE_PRELIGHT]));
+ setup_gc_with_fg (container,
+ LABEL_INFO_COLOR_HIGHLIGHT,
+ eel_gdk_color_is_dark (&style->base[GTK_STATE_SELECTED]) ? light_info_value : dark_info_value);
+ setup_gc_with_fg (container,
+ LABEL_INFO_COLOR_ACTIVE,
+ eel_gdk_color_is_dark (&style->base[GTK_STATE_ACTIVE]) ? light_info_value : dark_info_value);
+
+ /* If CajaIconContainer::frame_text is set, we can safely
+ * use the foreground color from the theme, because it will
+ * always be displayed against the gtk background */
+ gtk_widget_style_get (widget,
+ "frame_text", &frame_text,
+ NULL);
+
+ if (frame_text || !eel_background_is_set(background))
+ {
+ setup_gc_with_fg (container, LABEL_COLOR,
+ eel_gdk_color_to_rgb (&style->text[GTK_STATE_NORMAL]));
+ setup_gc_with_fg (container,
+ LABEL_INFO_COLOR,
+ eel_gdk_color_is_dark (&style->base[GTK_STATE_NORMAL]) ? light_info_value : dark_info_value);
+ }
+ else
+ {
+ if (container->details->use_drop_shadows || eel_background_is_dark (background))
+ {
+ setup_gc_with_fg (container, LABEL_COLOR, 0xEFEFEF);
+ setup_gc_with_fg (container,
+ LABEL_INFO_COLOR,
+ light_info_value);
+ }
+ else /* converse */
+ {
+ setup_gc_with_fg (container, LABEL_COLOR, 0x000000);
+ setup_gc_with_fg (container,
+ LABEL_INFO_COLOR,
+ dark_info_value);
+ }
+ }
+}
+
+static void
+update_label_color (EelBackground *background,
+ CajaIconContainer *container)
+{
+ g_assert (EEL_IS_BACKGROUND (background));
+
+ setup_label_gcs (container);
+}
+
+
+/* Return if the icon container is a fixed size */
+gboolean
+caja_icon_container_get_is_fixed_size (CajaIconContainer *container)
+{
+ g_return_val_if_fail (CAJA_IS_ICON_CONTAINER (container), FALSE);
+
+ return container->details->is_fixed_size;
+}
+
+/* Set the icon container to be a fixed size */
+void
+caja_icon_container_set_is_fixed_size (CajaIconContainer *container,
+ gboolean is_fixed_size)
+{
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+ container->details->is_fixed_size = is_fixed_size;
+}
+
+gboolean
+caja_icon_container_get_is_desktop (CajaIconContainer *container)
+{
+ g_return_val_if_fail (CAJA_IS_ICON_CONTAINER (container), FALSE);
+
+ return container->details->is_desktop;
+}
+
+void
+caja_icon_container_set_is_desktop (CajaIconContainer *container,
+ gboolean is_desktop)
+{
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+ container->details->is_desktop = is_desktop;
+}
+
+void
+caja_icon_container_set_margins (CajaIconContainer *container,
+ int left_margin,
+ int right_margin,
+ int top_margin,
+ int bottom_margin)
+{
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+ container->details->left_margin = left_margin;
+ container->details->right_margin = right_margin;
+ container->details->top_margin = top_margin;
+ container->details->bottom_margin = bottom_margin;
+
+ /* redo layout of icons as the margins have changed */
+ schedule_redo_layout (container);
+}
+
+void
+caja_icon_container_set_use_drop_shadows (CajaIconContainer *container,
+ gboolean use_drop_shadows)
+{
+ gboolean frame_text;
+
+ gtk_widget_style_get (GTK_WIDGET (container),
+ "frame_text", &frame_text,
+ NULL);
+
+ if (container->details->drop_shadows_requested == use_drop_shadows)
+ {
+ return;
+ }
+
+ container->details->drop_shadows_requested = use_drop_shadows;
+ container->details->use_drop_shadows = use_drop_shadows && !frame_text;
+ gtk_widget_queue_draw (GTK_WIDGET (container));
+}
+
+/* handle theme changes */
+
+static void
+caja_icon_container_theme_changed (gpointer user_data)
+{
+ CajaIconContainer *container;
+ GtkStyle *style;
+ GdkColor *prelight_icon_color, *normal_icon_color;
+ guchar highlight_alpha, normal_alpha, prelight_alpha;
+
+ container = CAJA_ICON_CONTAINER (user_data);
+
+ /* load the highlight color */
+ gtk_widget_style_get (GTK_WIDGET (container),
+ "highlight_alpha", &highlight_alpha,
+ NULL);
+
+ style = gtk_widget_get_style (GTK_WIDGET (container));
+
+ container->details->highlight_color_rgba =
+ EEL_RGBA_COLOR_PACK (style->base[GTK_STATE_SELECTED].red >> 8,
+ style->base[GTK_STATE_SELECTED].green >> 8,
+ style->base[GTK_STATE_SELECTED].blue >> 8,
+ highlight_alpha);
+ container->details->active_color_rgba =
+ EEL_RGBA_COLOR_PACK (style->base[GTK_STATE_ACTIVE].red >> 8,
+ style->base[GTK_STATE_ACTIVE].green >> 8,
+ style->base[GTK_STATE_ACTIVE].blue >> 8,
+ highlight_alpha);
+
+ /* load the prelight icon color */
+ gtk_widget_style_get (GTK_WIDGET (container),
+ "prelight_icon_color", &prelight_icon_color,
+ NULL);
+
+ if (prelight_icon_color)
+ {
+ container->details->prelight_icon_color_rgba =
+ EEL_RGBA_COLOR_PACK (prelight_icon_color->red >> 8,
+ prelight_icon_color->green >> 8,
+ prelight_icon_color->blue >> 8,
+ 255);
+ }
+ else /* if not defined by rc, set to default value */
+ {
+ container->details->prelight_icon_color_rgba =
+ EEL_RGBA_COLOR_PACK (style->base[GTK_STATE_PRELIGHT].red >> 8,
+ style->base[GTK_STATE_PRELIGHT].green >> 8,
+ style->base[GTK_STATE_PRELIGHT].blue >> 8,
+ 255);
+ }
+
+
+ /* load the normal icon color */
+ gtk_widget_style_get (GTK_WIDGET (container),
+ "normal_icon_color", &normal_icon_color,
+ NULL);
+
+ if (normal_icon_color)
+ {
+ container->details->normal_icon_color_rgba =
+ EEL_RGBA_COLOR_PACK (normal_icon_color->red >> 8,
+ normal_icon_color->green >> 8,
+ normal_icon_color->blue >> 8,
+ 255);
+ }
+ else /* if not defined by rc, set to default value */
+ {
+ container->details->normal_icon_color_rgba =
+ EEL_RGBA_COLOR_PACK (style->base[GTK_STATE_NORMAL].red >> 8,
+ style->base[GTK_STATE_NORMAL].green >> 8,
+ style->base[GTK_STATE_NORMAL].blue >> 8,
+ 255);
+ }
+
+
+ /* load the normal color */
+ gtk_widget_style_get (GTK_WIDGET (container),
+ "normal_alpha", &normal_alpha,
+ NULL);
+
+ container->details->normal_color_rgba =
+ EEL_RGBA_COLOR_PACK (style->base[GTK_STATE_NORMAL].red >> 8,
+ style->base[GTK_STATE_NORMAL].green >> 8,
+ style->base[GTK_STATE_NORMAL].blue >> 8,
+ normal_alpha);
+
+
+ /* load the prelight color */
+ gtk_widget_style_get (GTK_WIDGET (container),
+ "prelight_alpha", &prelight_alpha,
+ NULL);
+
+ container->details->prelight_color_rgba =
+ EEL_RGBA_COLOR_PACK (style->base[GTK_STATE_PRELIGHT].red >> 8,
+ style->base[GTK_STATE_PRELIGHT].green >> 8,
+ style->base[GTK_STATE_PRELIGHT].blue >> 8,
+ prelight_alpha);
+
+
+ setup_label_gcs (container);
+}
+
+void
+caja_icon_container_set_font (CajaIconContainer *container,
+ const char *font)
+{
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+ if (eel_strcmp (container->details->font, font) == 0)
+ {
+ return;
+ }
+
+ g_free (container->details->font);
+ container->details->font = g_strdup (font);
+
+ invalidate_labels (container);
+ caja_icon_container_request_update_all (container);
+ gtk_widget_queue_draw (GTK_WIDGET (container));
+}
+
+void
+caja_icon_container_set_font_size_table (CajaIconContainer *container,
+ const int font_size_table[CAJA_ZOOM_LEVEL_LARGEST + 1])
+{
+ int old_font_size;
+ int i;
+
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+ g_return_if_fail (font_size_table != NULL);
+
+ old_font_size = container->details->font_size_table[container->details->zoom_level];
+
+ for (i = 0; i <= CAJA_ZOOM_LEVEL_LARGEST; i++)
+ {
+ if (container->details->font_size_table[i] != font_size_table[i])
+ {
+ container->details->font_size_table[i] = font_size_table[i];
+ }
+ }
+
+ if (old_font_size != container->details->font_size_table[container->details->zoom_level])
+ {
+ invalidate_labels (container);
+ caja_icon_container_request_update_all (container);
+ }
+}
+
+/**
+ * caja_icon_container_get_icon_description
+ * @container: An icon container widget.
+ * @data: Icon data
+ *
+ * Gets the description for the icon. This function may return NULL.
+ **/
+char*
+caja_icon_container_get_icon_description (CajaIconContainer *container,
+ CajaIconData *data)
+{
+ CajaIconContainerClass *klass;
+
+ klass = CAJA_ICON_CONTAINER_GET_CLASS (container);
+
+ if (klass->get_icon_description)
+ {
+ return klass->get_icon_description (container, data);
+ }
+ else
+ {
+ return NULL;
+ }
+}
+
+gboolean
+caja_icon_container_get_allow_moves (CajaIconContainer *container)
+{
+ g_return_val_if_fail (CAJA_IS_ICON_CONTAINER (container), FALSE);
+
+ return container->details->drag_allow_moves;
+}
+
+void
+caja_icon_container_set_allow_moves (CajaIconContainer *container,
+ gboolean allow_moves)
+{
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+ container->details->drag_allow_moves = allow_moves;
+}
+
+void
+caja_icon_container_set_forced_icon_size (CajaIconContainer *container,
+ int forced_icon_size)
+{
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+ if (forced_icon_size != container->details->forced_icon_size)
+ {
+ container->details->forced_icon_size = forced_icon_size;
+
+ invalidate_label_sizes (container);
+ caja_icon_container_request_update_all (container);
+ }
+}
+
+void
+caja_icon_container_set_all_columns_same_width (CajaIconContainer *container,
+ gboolean all_columns_same_width)
+{
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+ if (all_columns_same_width != container->details->all_columns_same_width)
+ {
+ container->details->all_columns_same_width = all_columns_same_width;
+
+ invalidate_labels (container);
+ caja_icon_container_request_update_all (container);
+ }
+}
+
+/**
+ * caja_icon_container_set_highlighted_for_clipboard
+ * @container: An icon container widget.
+ * @data: Icon Data associated with all icons that should be highlighted.
+ * Others will be unhighlighted.
+ **/
+void
+caja_icon_container_set_highlighted_for_clipboard (CajaIconContainer *container,
+ GList *clipboard_icon_data)
+{
+ GList *l;
+ CajaIcon *icon;
+ gboolean highlighted_for_clipboard;
+
+ g_return_if_fail (CAJA_IS_ICON_CONTAINER (container));
+
+ for (l = container->details->icons; l != NULL; l = l->next)
+ {
+ icon = l->data;
+ highlighted_for_clipboard = (g_list_find (clipboard_icon_data, icon->data) != NULL);
+
+ eel_canvas_item_set (EEL_CANVAS_ITEM (icon->item),
+ "highlighted-for-clipboard", highlighted_for_clipboard,
+ NULL);
+ }
+
+}
+
+/* CajaIconContainerAccessible */
+
+static CajaIconContainerAccessiblePrivate *
+accessible_get_priv (AtkObject *accessible)
+{
+ CajaIconContainerAccessiblePrivate *priv;
+
+ priv = g_object_get_qdata (G_OBJECT (accessible),
+ accessible_private_data_quark);
+
+ return priv;
+}
+
+/* AtkAction interface */
+
+static gboolean
+caja_icon_container_accessible_do_action (AtkAction *accessible, int i)
+{
+ GtkWidget *widget;
+ CajaIconContainer *container;
+ GList *selection;
+
+ g_return_val_if_fail (i < LAST_ACTION, FALSE);
+
+ widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
+ if (!widget)
+ {
+ return FALSE;
+ }
+
+ container = CAJA_ICON_CONTAINER (widget);
+ switch (i)
+ {
+ case ACTION_ACTIVATE :
+ selection = caja_icon_container_get_selection (container);
+
+ if (selection)
+ {
+ g_signal_emit_by_name (container, "activate", selection);
+ g_list_free (selection);
+ }
+ break;
+ case ACTION_MENU :
+ handle_popups (container, NULL,"context_click_background");
+ break;
+ default :
+ g_warning ("Invalid action passed to CajaIconContainerAccessible::do_action");
+ return FALSE;
+ }
+ return TRUE;
+}
+
+static int
+caja_icon_container_accessible_get_n_actions (AtkAction *accessible)
+{
+ return LAST_ACTION;
+}
+
+static const char *
+caja_icon_container_accessible_action_get_description (AtkAction *accessible,
+ int i)
+{
+ CajaIconContainerAccessiblePrivate *priv;
+
+ g_assert (i < LAST_ACTION);
+
+ priv = accessible_get_priv (ATK_OBJECT (accessible));
+
+ if (priv->action_descriptions[i])
+ {
+ return priv->action_descriptions[i];
+ }
+ else
+ {
+ return caja_icon_container_accessible_action_descriptions[i];
+ }
+}
+
+static const char *
+caja_icon_container_accessible_action_get_name (AtkAction *accessible, int i)
+{
+ g_assert (i < LAST_ACTION);
+
+ return caja_icon_container_accessible_action_names[i];
+}
+
+static const char *
+caja_icon_container_accessible_action_get_keybinding (AtkAction *accessible,
+ int i)
+{
+ g_assert (i < LAST_ACTION);
+
+ return NULL;
+}
+
+static gboolean
+caja_icon_container_accessible_action_set_description (AtkAction *accessible,
+ int i,
+ const char *description)
+{
+ CajaIconContainerAccessiblePrivate *priv;
+
+ g_assert (i < LAST_ACTION);
+
+ priv = accessible_get_priv (ATK_OBJECT (accessible));
+
+ if (priv->action_descriptions[i])
+ {
+ g_free (priv->action_descriptions[i]);
+ }
+ priv->action_descriptions[i] = g_strdup (description);
+
+ return FALSE;
+}
+
+static void
+caja_icon_container_accessible_action_interface_init (AtkActionIface *iface)
+{
+ iface->do_action = caja_icon_container_accessible_do_action;
+ iface->get_n_actions = caja_icon_container_accessible_get_n_actions;
+ iface->get_description = caja_icon_container_accessible_action_get_description;
+ iface->get_name = caja_icon_container_accessible_action_get_name;
+ iface->get_keybinding = caja_icon_container_accessible_action_get_keybinding;
+ iface->set_description = caja_icon_container_accessible_action_set_description;
+}
+
+/* AtkSelection interface */
+
+static void
+caja_icon_container_accessible_update_selection (AtkObject *accessible)
+{
+ CajaIconContainer *container;
+ CajaIconContainerAccessiblePrivate *priv;
+ GList *l;
+ CajaIcon *icon;
+
+ container = CAJA_ICON_CONTAINER (gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible)));
+
+ priv = accessible_get_priv (accessible);
+
+ if (priv->selection)
+ {
+ g_list_free (priv->selection);
+ priv->selection = NULL;
+ }
+
+ for (l = container->details->icons; l != NULL; l = l->next)
+ {
+ icon = l->data;
+ if (icon->is_selected)
+ {
+ priv->selection = g_list_prepend (priv->selection,
+ icon);
+ }
+ }
+
+ priv->selection = g_list_reverse (priv->selection);
+}
+
+static void
+caja_icon_container_accessible_selection_changed_cb (CajaIconContainer *container,
+ gpointer data)
+{
+ g_signal_emit_by_name (data, "selection_changed");
+}
+
+static void
+caja_icon_container_accessible_icon_added_cb (CajaIconContainer *container,
+ CajaIconData *icon_data,
+ gpointer data)
+{
+ CajaIcon *icon;
+ AtkObject *atk_parent;
+ AtkObject *atk_child;
+ int index;
+
+ icon = g_hash_table_lookup (container->details->icon_set, icon_data);
+ if (icon)
+ {
+ atk_parent = ATK_OBJECT (data);
+ atk_child = atk_gobject_accessible_for_object
+ (G_OBJECT (icon->item));
+ index = g_list_index (container->details->icons, icon);
+
+ g_signal_emit_by_name (atk_parent, "children_changed::add",
+ index, atk_child, NULL);
+ }
+}
+
+static void
+caja_icon_container_accessible_icon_removed_cb (CajaIconContainer *container,
+ CajaIconData *icon_data,
+ gpointer data)
+{
+ CajaIcon *icon;
+ AtkObject *atk_parent;
+ AtkObject *atk_child;
+ int index;
+
+ icon = g_hash_table_lookup (container->details->icon_set, icon_data);
+ if (icon)
+ {
+ atk_parent = ATK_OBJECT (data);
+ atk_child = atk_gobject_accessible_for_object
+ (G_OBJECT (icon->item));
+ index = g_list_index (container->details->icons, icon);
+
+ g_signal_emit_by_name (atk_parent, "children_changed::remove",
+ index, atk_child, NULL);
+ }
+}
+
+static void
+caja_icon_container_accessible_cleared_cb (CajaIconContainer *container,
+ gpointer data)
+{
+ g_signal_emit_by_name (data, "children_changed", 0, NULL, NULL);
+}
+
+
+static gboolean
+caja_icon_container_accessible_add_selection (AtkSelection *accessible,
+ int i)
+{
+ GtkWidget *widget;
+ CajaIconContainer *container;
+ GList *l;
+ GList *selection;
+ CajaIcon *icon;
+
+ widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
+ if (!widget)
+ {
+ return FALSE;
+ }
+
+ container = CAJA_ICON_CONTAINER (widget);
+
+ l = g_list_nth (container->details->icons, i);
+ if (l)
+ {
+ icon = l->data;
+
+ selection = caja_icon_container_get_selection (container);
+ selection = g_list_prepend (selection,
+ icon->data);
+ caja_icon_container_set_selection (container, selection);
+
+ g_list_free (selection);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static gboolean
+caja_icon_container_accessible_clear_selection (AtkSelection *accessible)
+{
+ GtkWidget *widget;
+ CajaIconContainer *container;
+
+ widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
+ if (!widget)
+ {
+ return FALSE;
+ }
+
+ container = CAJA_ICON_CONTAINER (widget);
+
+ caja_icon_container_unselect_all (container);
+
+ return TRUE;
+}
+
+static AtkObject *
+caja_icon_container_accessible_ref_selection (AtkSelection *accessible,
+ int i)
+{
+ AtkObject *atk_object;
+ CajaIconContainerAccessiblePrivate *priv;
+ GList *item;
+ CajaIcon *icon;
+
+ caja_icon_container_accessible_update_selection (ATK_OBJECT (accessible));
+ priv = accessible_get_priv (ATK_OBJECT (accessible));
+
+ item = (g_list_nth (priv->selection, i));
+
+ if (item)
+ {
+ icon = item->data;
+ atk_object = atk_gobject_accessible_for_object (G_OBJECT (icon->item));
+ if (atk_object)
+ {
+ g_object_ref (atk_object);
+ }
+
+ return atk_object;
+ }
+ else
+ {
+ return NULL;
+ }
+}
+
+static int
+caja_icon_container_accessible_get_selection_count (AtkSelection *accessible)
+{
+ int count;
+ CajaIconContainerAccessiblePrivate *priv;
+
+ caja_icon_container_accessible_update_selection (ATK_OBJECT (accessible));
+ priv = accessible_get_priv (ATK_OBJECT (accessible));
+
+ count = g_list_length (priv->selection);
+
+ return count;
+}
+
+static gboolean
+caja_icon_container_accessible_is_child_selected (AtkSelection *accessible,
+ int i)
+{
+ CajaIconContainer *container;
+ GList *l;
+ CajaIcon *icon;
+ GtkWidget *widget;
+
+ widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
+ if (!widget)
+ {
+ return FALSE;
+ }
+
+ container = CAJA_ICON_CONTAINER (widget);
+
+ l = g_list_nth (container->details->icons, i);
+ if (l)
+ {
+ icon = l->data;
+ return icon->is_selected;
+ }
+ return FALSE;
+}
+
+static gboolean
+caja_icon_container_accessible_remove_selection (AtkSelection *accessible,
+ int i)
+{
+ CajaIconContainer *container;
+ CajaIconContainerAccessiblePrivate *priv;
+ GList *l;
+ GList *selection;
+ CajaIcon *icon;
+ GtkWidget *widget;
+
+ widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
+ if (!widget)
+ {
+ return FALSE;
+ }
+
+ caja_icon_container_accessible_update_selection (ATK_OBJECT (accessible));
+ priv = accessible_get_priv (ATK_OBJECT (accessible));
+
+ container = CAJA_ICON_CONTAINER (widget);
+
+ l = g_list_nth (priv->selection, i);
+ if (l)
+ {
+ icon = l->data;
+
+ selection = caja_icon_container_get_selection (container);
+ selection = g_list_remove (selection, icon->data);
+ caja_icon_container_set_selection (container, selection);
+
+ g_list_free (selection);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static gboolean
+caja_icon_container_accessible_select_all_selection (AtkSelection *accessible)
+{
+ CajaIconContainer *container;
+ GtkWidget *widget;
+
+ widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
+ if (!widget)
+ {
+ return FALSE;
+ }
+
+ container = CAJA_ICON_CONTAINER (widget);
+
+ caja_icon_container_select_all (container);
+
+ return TRUE;
+}
+
+void
+caja_icon_container_widget_to_file_operation_position (CajaIconContainer *container,
+ GdkPoint *position)
+{
+ double x, y;
+
+ g_return_if_fail (position != NULL);
+
+ x = position->x;
+ y = position->y;
+
+ eel_canvas_window_to_world (EEL_CANVAS (container), x, y, &x, &y);
+
+ position->x = (int) x;
+ position->y = (int) y;
+
+ /* ensure that we end up in the middle of the icon */
+ position->x -= caja_get_icon_size_for_zoom_level (container->details->zoom_level) / 2;
+ position->y -= caja_get_icon_size_for_zoom_level (container->details->zoom_level) / 2;
+}
+
+static void
+caja_icon_container_accessible_selection_interface_init (AtkSelectionIface *iface)
+{
+ iface->add_selection = caja_icon_container_accessible_add_selection;
+ iface->clear_selection = caja_icon_container_accessible_clear_selection;
+ iface->ref_selection = caja_icon_container_accessible_ref_selection;
+ iface->get_selection_count = caja_icon_container_accessible_get_selection_count;
+ iface->is_child_selected = caja_icon_container_accessible_is_child_selected;
+ iface->remove_selection = caja_icon_container_accessible_remove_selection;
+ iface->select_all_selection = caja_icon_container_accessible_select_all_selection;
+}
+
+
+static gint
+caja_icon_container_accessible_get_n_children (AtkObject *accessible)
+{
+ CajaIconContainer *container;
+ GtkWidget *widget;
+ gint i;
+
+ widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
+ if (!widget)
+ {
+ return FALSE;
+ }
+
+ container = CAJA_ICON_CONTAINER (widget);
+
+ i = g_hash_table_size (container->details->icon_set);
+ if (container->details->rename_widget)
+ {
+ i++;
+ }
+ return i;
+}
+
+static AtkObject*
+caja_icon_container_accessible_ref_child (AtkObject *accessible, int i)
+{
+ AtkObject *atk_object;
+ CajaIconContainer *container;
+ GList *item;
+ CajaIcon *icon;
+ GtkWidget *widget;
+
+ widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
+ if (!widget)
+ {
+ return NULL;
+ }
+
+ container = CAJA_ICON_CONTAINER (widget);
+
+ item = (g_list_nth (container->details->icons, i));
+
+ if (item)
+ {
+ icon = item->data;
+
+ atk_object = atk_gobject_accessible_for_object (G_OBJECT (icon->item));
+ g_object_ref (atk_object);
+
+ return atk_object;
+ }
+ else
+ {
+ if (i == g_list_length (container->details->icons))
+ {
+ if (container->details->rename_widget)
+ {
+ atk_object = gtk_widget_get_accessible (container->details->rename_widget);
+ g_object_ref (atk_object);
+
+ return atk_object;
+ }
+ }
+ return NULL;
+ }
+}
+
+static void
+caja_icon_container_accessible_initialize (AtkObject *accessible,
+ gpointer data)
+{
+ CajaIconContainer *container;
+ CajaIconContainerAccessiblePrivate *priv;
+
+ if (ATK_OBJECT_CLASS (accessible_parent_class)->initialize)
+ {
+ ATK_OBJECT_CLASS (accessible_parent_class)->initialize (accessible, data);
+ }
+
+ priv = g_new0 (CajaIconContainerAccessiblePrivate, 1);
+ g_object_set_qdata (G_OBJECT (accessible),
+ accessible_private_data_quark,
+ priv);
+
+ if (GTK_IS_ACCESSIBLE (accessible))
+ {
+ caja_icon_container_accessible_update_selection
+ (ATK_OBJECT (accessible));
+
+ container = CAJA_ICON_CONTAINER (gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible)));
+ g_signal_connect (G_OBJECT (container), "selection_changed",
+ G_CALLBACK (caja_icon_container_accessible_selection_changed_cb),
+ accessible);
+ g_signal_connect (G_OBJECT (container), "icon_added",
+ G_CALLBACK (caja_icon_container_accessible_icon_added_cb),
+ accessible);
+ g_signal_connect (G_OBJECT (container), "icon_removed",
+ G_CALLBACK (caja_icon_container_accessible_icon_removed_cb),
+ accessible);
+ g_signal_connect (G_OBJECT (container), "cleared",
+ G_CALLBACK (caja_icon_container_accessible_cleared_cb),
+ accessible);
+ }
+}
+
+static void
+caja_icon_container_accessible_finalize (GObject *object)
+{
+ CajaIconContainerAccessiblePrivate *priv;
+ int i;
+
+ priv = accessible_get_priv (ATK_OBJECT (object));
+ if (priv->selection)
+ {
+ g_list_free (priv->selection);
+ }
+
+ for (i = 0; i < LAST_ACTION; i++)
+ {
+ if (priv->action_descriptions[i])
+ {
+ g_free (priv->action_descriptions[i]);
+ }
+ }
+
+ g_free (priv);
+
+ G_OBJECT_CLASS (accessible_parent_class)->finalize (object);
+}
+
+static void
+caja_icon_container_accessible_class_init (AtkObjectClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+ accessible_parent_class = g_type_class_peek_parent (klass);
+
+ gobject_class->finalize = caja_icon_container_accessible_finalize;
+
+ klass->get_n_children = caja_icon_container_accessible_get_n_children;
+ klass->ref_child = caja_icon_container_accessible_ref_child;
+ klass->initialize = caja_icon_container_accessible_initialize;
+
+ accessible_private_data_quark = g_quark_from_static_string ("icon-container-accessible-private-data");
+}
+
+static GType
+caja_icon_container_accessible_get_type (void)
+{
+ static GType type = 0;
+
+ if (!type)
+ {
+ static GInterfaceInfo atk_action_info =
+ {
+ (GInterfaceInitFunc) caja_icon_container_accessible_action_interface_init,
+ (GInterfaceFinalizeFunc) NULL,
+ NULL
+ };
+
+ static GInterfaceInfo atk_selection_info =
+ {
+ (GInterfaceInitFunc) caja_icon_container_accessible_selection_interface_init,
+ (GInterfaceFinalizeFunc) NULL,
+ NULL
+ };
+
+ type = eel_accessibility_create_derived_type
+ ("CajaIconContainerAccessible",
+ EEL_TYPE_CANVAS,
+ caja_icon_container_accessible_class_init);
+
+ g_type_add_interface_static (type, ATK_TYPE_ACTION,
+ &atk_action_info);
+ g_type_add_interface_static (type, ATK_TYPE_SELECTION,
+ &atk_selection_info);
+ }
+
+ return type;
+}
+
+#if ! defined (CAJA_OMIT_SELF_CHECK)
+
+static char *
+check_compute_stretch (int icon_x, int icon_y, int icon_size,
+ int start_pointer_x, int start_pointer_y,
+ int end_pointer_x, int end_pointer_y)
+{
+ StretchState start, current;
+
+ start.icon_x = icon_x;
+ start.icon_y = icon_y;
+ start.icon_size = icon_size;
+ start.pointer_x = start_pointer_x;
+ start.pointer_y = start_pointer_y;
+ current.pointer_x = end_pointer_x;
+ current.pointer_y = end_pointer_y;
+
+ compute_stretch (&start, &current);
+
+ return g_strdup_printf ("%d,%d:%d",
+ current.icon_x,
+ current.icon_y,
+ current.icon_size);
+}
+
+void
+caja_self_check_icon_container (void)
+{
+ EEL_CHECK_STRING_RESULT (check_compute_stretch (0, 0, 16, 0, 0, 0, 0), "0,0:16");
+ EEL_CHECK_STRING_RESULT (check_compute_stretch (0, 0, 16, 16, 16, 17, 17), "0,0:17");
+ EEL_CHECK_STRING_RESULT (check_compute_stretch (0, 0, 16, 16, 16, 17, 16), "0,0:16");
+ EEL_CHECK_STRING_RESULT (check_compute_stretch (100, 100, 64, 105, 105, 40, 40), "35,35:129");
+}
+
+gboolean
+caja_icon_container_is_layout_rtl (CajaIconContainer *container)
+{
+ g_return_val_if_fail (CAJA_IS_ICON_CONTAINER (container), 0);
+
+ return container->details->layout_mode == CAJA_ICON_LAYOUT_T_B_R_L ||
+ container->details->layout_mode == CAJA_ICON_LAYOUT_R_L_T_B;
+}
+
+gboolean
+caja_icon_container_is_layout_vertical (CajaIconContainer *container)
+{
+ g_return_val_if_fail (CAJA_IS_ICON_CONTAINER (container), FALSE);
+
+ return (container->details->layout_mode == CAJA_ICON_LAYOUT_T_B_L_R ||
+ container->details->layout_mode == CAJA_ICON_LAYOUT_T_B_R_L);
+}
+
+int
+caja_icon_container_get_max_layout_lines_for_pango (CajaIconContainer *container)
+{
+ int limit;
+
+ if (caja_icon_container_get_is_desktop (container))
+ {
+ limit = desktop_text_ellipsis_limit;
+ }
+ else
+ {
+ limit = text_ellipsis_limits[container->details->zoom_level];
+ }
+
+ if (limit <= 0)
+ {
+ return G_MININT;
+ }
+
+ return -limit;
+}
+
+int
+caja_icon_container_get_max_layout_lines (CajaIconContainer *container)
+{
+ int limit;
+
+ if (caja_icon_container_get_is_desktop (container))
+ {
+ limit = desktop_text_ellipsis_limit;
+ }
+ else
+ {
+ limit = text_ellipsis_limits[container->details->zoom_level];
+ }
+
+ if (limit <= 0)
+ {
+ return G_MAXINT;
+ }
+
+ return limit;
+}
+
+void
+caja_icon_container_begin_loading (CajaIconContainer *container)
+{
+ gboolean dummy;
+
+ if (caja_icon_container_get_store_layout_timestamps (container))
+ {
+ container->details->layout_timestamp = UNDEFINED_TIME;
+ g_signal_emit (container,
+ signals[GET_STORED_LAYOUT_TIMESTAMP], 0,
+ NULL, &container->details->layout_timestamp, &dummy);
+ }
+}
+
+static void
+store_layout_timestamps_now (CajaIconContainer *container)
+{
+ CajaIcon *icon;
+ GList *p;
+ gboolean dummy;
+
+ container->details->layout_timestamp = time (NULL);
+ g_signal_emit (container,
+ signals[STORE_LAYOUT_TIMESTAMP], 0,
+ NULL, &container->details->layout_timestamp, &dummy);
+
+ for (p = container->details->icons; p != NULL; p = p->next)
+ {
+ icon = p->data;
+
+ g_signal_emit (container,
+ signals[STORE_LAYOUT_TIMESTAMP], 0,
+ icon->data, &container->details->layout_timestamp, &dummy);
+ }
+}
+
+
+void
+caja_icon_container_end_loading (CajaIconContainer *container,
+ gboolean all_icons_added)
+{
+ if (all_icons_added &&
+ caja_icon_container_get_store_layout_timestamps (container))
+ {
+ if (container->details->new_icons == NULL)
+ {
+ store_layout_timestamps_now (container);
+ }
+ else
+ {
+ container->details->store_layout_timestamps_when_finishing_new_icons = TRUE;
+ }
+ }
+}
+
+gboolean
+caja_icon_container_get_store_layout_timestamps (CajaIconContainer *container)
+{
+ return container->details->store_layout_timestamps;
+}
+
+
+void
+caja_icon_container_set_store_layout_timestamps (CajaIconContainer *container,
+ gboolean store_layout_timestamps)
+{
+ container->details->store_layout_timestamps = store_layout_timestamps;
+}
+
+
+#endif /* ! CAJA_OMIT_SELF_CHECK */
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-15 16:41:23 +0000