moving from https://github.com/perberos/mate-desktop-environment

1 files changed, 996 insertions, 0 deletions

diff --git a/src/caja-zoom-control.c b/src/caja-zoom-control.c
new file mode 100644
index 00000000..a11ca9e9
--- /dev/null
+++ b/src/caja-zoom-control.c
@@ -0,0 +1,996 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+
+/*
+ * Caja
+ *
+ * Copyright (C) 2000 Eazel, Inc.
+ * Copyright (C) 2004 Red Hat, Inc.
+ *
+ * Caja is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Caja is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * Author: Andy Hertzfeld <[email protected]>
+ *         Alexander Larsson <[email protected]>
+ *
+ * This is the zoom control for the location bar
+ *
+ */
+
+#include <config.h>
+#include "caja-zoom-control.h"
+
+#include <atk/atkaction.h>
+#include <glib/gi18n.h>
+#include <eel/eel-accessibility.h>
+#include <eel/eel-glib-extensions.h>
+#include <eel/eel-graphic-effects.h>
+#include <eel/eel-gtk-extensions.h>
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+#include <libcaja-private/caja-file-utilities.h>
+#include <libcaja-private/caja-global-preferences.h>
+#include <libcaja-private/caja-marshal.h>
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+enum
+{
+    ZOOM_IN,
+    ZOOM_OUT,
+    ZOOM_TO_LEVEL,
+    ZOOM_TO_DEFAULT,
+    CHANGE_VALUE,
+    LAST_SIGNAL
+};
+
+struct CajaZoomControlDetails
+{
+    GtkWidget *zoom_in;
+    GtkWidget *zoom_out;
+    GtkWidget *zoom_label;
+    GtkWidget *zoom_button;
+
+    CajaZoomLevel zoom_level;
+    CajaZoomLevel min_zoom_level;
+    CajaZoomLevel max_zoom_level;
+    gboolean has_min_zoom_level;
+    gboolean has_max_zoom_level;
+    GList *preferred_zoom_levels;
+
+    gboolean marking_menu_items;
+};
+
+
+static guint signals[LAST_SIGNAL];
+
+static gpointer accessible_parent_class;
+
+static const char * const caja_zoom_control_accessible_action_names[] =
+{
+    N_("Zoom In"),
+    N_("Zoom Out"),
+    N_("Zoom to Default"),
+};
+
+static const int caja_zoom_control_accessible_action_signals[] =
+{
+    ZOOM_IN,
+    ZOOM_OUT,
+    ZOOM_TO_DEFAULT,
+};
+
+static const char * const caja_zoom_control_accessible_action_descriptions[] =
+{
+    N_("Increase the view size"),
+    N_("Decrease the view size"),
+    N_("Use the normal view size")
+};
+
+static GtkMenu *create_zoom_menu (CajaZoomControl *zoom_control);
+
+static GType caja_zoom_control_accessible_get_type (void);
+
+/* button assignments */
+#define CONTEXTUAL_MENU_BUTTON 3
+
+#define NUM_ACTIONS ((int)G_N_ELEMENTS (caja_zoom_control_accessible_action_names))
+
+G_DEFINE_TYPE (CajaZoomControl, caja_zoom_control, GTK_TYPE_HBOX);
+
+static void
+caja_zoom_control_finalize (GObject *object)
+{
+    g_list_free (CAJA_ZOOM_CONTROL (object)->details->preferred_zoom_levels);
+
+    G_OBJECT_CLASS (caja_zoom_control_parent_class)->finalize (object);
+}
+
+static void
+zoom_button_clicked (GtkButton *button, CajaZoomControl *zoom_control)
+{
+    g_signal_emit (zoom_control, signals[ZOOM_TO_DEFAULT], 0);
+}
+
+static void
+zoom_popup_menu_show (GdkEventButton *event, CajaZoomControl *zoom_control)
+{
+    eel_pop_up_context_menu (create_zoom_menu (zoom_control),
+                             EEL_DEFAULT_POPUP_MENU_DISPLACEMENT,
+                             EEL_DEFAULT_POPUP_MENU_DISPLACEMENT,
+                             event);
+}
+
+static void
+menu_position_under_widget (GtkMenu   *menu,
+                            gint      *x,
+                            gint      *y,
+                            gboolean  *push_in,
+                            gpointer   user_data)
+{
+    GtkWidget *widget;
+    GtkWidget *container;
+    GtkRequisition req;
+    GtkRequisition menu_req;
+    GdkRectangle monitor;
+    int monitor_num;
+    GdkScreen *screen;
+    GtkAllocation allocation;
+
+    widget = GTK_WIDGET (user_data);
+    g_assert (GTK_IS_WIDGET (widget));
+
+    container = gtk_widget_get_ancestor (widget, GTK_TYPE_CONTAINER);
+    g_assert (container != NULL);
+
+    gtk_widget_size_request (widget, &req);
+    gtk_widget_size_request (GTK_WIDGET (menu), &menu_req);
+    gtk_widget_get_allocation (widget, &allocation);
+
+    screen = gtk_widget_get_screen (GTK_WIDGET (menu));
+    monitor_num = gdk_screen_get_monitor_at_window (screen, gtk_widget_get_window (widget));
+    if (monitor_num < 0)
+    {
+        monitor_num = 0;
+    }
+    gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
+
+    gdk_window_get_origin (gtk_widget_get_window (widget), x, y);
+    if (!gtk_widget_get_has_window (widget))
+    {
+        *x += allocation.x;
+        *y += allocation.y;
+    }
+
+    if (gtk_widget_get_direction (container) == GTK_TEXT_DIR_LTR)
+    {
+        *x += allocation.width - req.width;
+    }
+    else
+    {
+        *x += req.width - menu_req.width;
+    }
+
+    if ((*y + allocation.height + menu_req.height) <= monitor.y + monitor.height)
+    {
+        *y += allocation.height;
+    }
+    else if ((*y - menu_req.height) >= monitor.y)
+    {
+        *y -= menu_req.height;
+    }
+    else if (monitor.y + monitor.height - (*y + allocation.height) > *y)
+    {
+        *y += allocation.height;
+    }
+    else
+    {
+        *y -= menu_req.height;
+    }
+
+    *push_in = FALSE;
+}
+
+
+static void
+zoom_popup_menu (GtkWidget *widget, CajaZoomControl *zoom_control)
+{
+    GtkMenu *menu;
+
+    menu = create_zoom_menu (zoom_control);
+    gtk_menu_popup (menu, NULL, NULL,
+                    menu_position_under_widget, widget,
+                    0, gtk_get_current_event_time ());
+    gtk_menu_shell_select_first (GTK_MENU_SHELL (menu), FALSE);
+}
+
+/* handle button presses */
+static gboolean
+caja_zoom_control_button_press_event (GtkWidget *widget,
+                                      GdkEventButton *event,
+                                      CajaZoomControl *zoom_control)
+{
+    if (event->type != GDK_BUTTON_PRESS)
+    {
+        return FALSE;
+    }
+
+    /* check for the context menu button and show the menu */
+    if (event->button == CONTEXTUAL_MENU_BUTTON)
+    {
+        zoom_popup_menu_show (event, zoom_control);
+        return TRUE;
+    }
+    /* We don't change our state (to reflect the new zoom) here.
+       The zoomable will call back with the new level.
+       Actually, the callback goes to the viewframe containing the
+       zoomable which, in turn, emits zoom_level_changed,
+       which someone (e.g. caja_window) picks up and handles by
+       calling into is - caja_zoom_control_set_zoom_level.
+    */
+
+    return FALSE;
+}
+
+static void
+zoom_out_clicked (GtkButton *button,
+                  CajaZoomControl *zoom_control)
+{
+    if (caja_zoom_control_can_zoom_out (zoom_control))
+    {
+        g_signal_emit (G_OBJECT (zoom_control), signals[ZOOM_OUT], 0);
+    }
+}
+
+static void
+zoom_in_clicked (GtkButton *button,
+                 CajaZoomControl *zoom_control)
+{
+    if (caja_zoom_control_can_zoom_in (zoom_control))
+    {
+        g_signal_emit (G_OBJECT (zoom_control), signals[ZOOM_IN], 0);
+    }
+}
+
+static void
+set_label_size (CajaZoomControl *zoom_control)
+{
+    const char *text;
+    PangoLayout *layout;
+    int width;
+    int height;
+
+    text = gtk_label_get_text (GTK_LABEL (zoom_control->details->zoom_label));
+    layout = gtk_label_get_layout (GTK_LABEL (zoom_control->details->zoom_label));
+    pango_layout_set_text (layout, "100%", -1);
+    pango_layout_get_pixel_size (layout, &width, &height);
+    gtk_widget_set_size_request (zoom_control->details->zoom_label, width, height);
+    gtk_label_set_text (GTK_LABEL (zoom_control->details->zoom_label),
+                        text);
+}
+
+static void
+label_style_set_callback (GtkWidget *label,
+                          GtkStyle *style,
+                          gpointer user_data)
+{
+    set_label_size (CAJA_ZOOM_CONTROL (user_data));
+}
+
+static void
+caja_zoom_control_init (CajaZoomControl *zoom_control)
+{
+    GtkWidget *image;
+    int i;
+
+    zoom_control->details = G_TYPE_INSTANCE_GET_PRIVATE (zoom_control, CAJA_TYPE_ZOOM_CONTROL, CajaZoomControlDetails);
+
+    zoom_control->details->zoom_level = CAJA_ZOOM_LEVEL_STANDARD;
+    zoom_control->details->min_zoom_level = CAJA_ZOOM_LEVEL_SMALLEST;
+    zoom_control->details->max_zoom_level = CAJA_ZOOM_LEVEL_LARGEST;
+    zoom_control->details->has_min_zoom_level = TRUE;
+    zoom_control->details->has_max_zoom_level = TRUE;
+
+    for (i = CAJA_ZOOM_LEVEL_LARGEST; i >= CAJA_ZOOM_LEVEL_SMALLEST; i--)
+    {
+        zoom_control->details->preferred_zoom_levels = g_list_prepend (
+                    zoom_control->details->preferred_zoom_levels,
+                    GINT_TO_POINTER (i));
+    }
+
+    image = gtk_image_new_from_stock (GTK_STOCK_ZOOM_OUT, GTK_ICON_SIZE_MENU);
+    zoom_control->details->zoom_out = gtk_button_new ();
+    gtk_button_set_focus_on_click (GTK_BUTTON (zoom_control->details->zoom_out), FALSE);
+    gtk_button_set_relief (GTK_BUTTON (zoom_control->details->zoom_out),
+                           GTK_RELIEF_NONE);
+    gtk_widget_set_tooltip_text (zoom_control->details->zoom_out,
+                                 _("Decrease the view size"));
+    g_signal_connect (G_OBJECT (zoom_control->details->zoom_out),
+                      "clicked", G_CALLBACK (zoom_out_clicked),
+                      zoom_control);
+    gtk_container_add (GTK_CONTAINER (zoom_control->details->zoom_out), image);
+    gtk_box_pack_start (GTK_BOX (zoom_control),
+                        zoom_control->details->zoom_out, FALSE, FALSE, 0);
+
+    zoom_control->details->zoom_button = gtk_button_new ();
+    gtk_button_set_focus_on_click (GTK_BUTTON (zoom_control->details->zoom_button), FALSE);
+    gtk_button_set_relief (GTK_BUTTON (zoom_control->details->zoom_button),
+                           GTK_RELIEF_NONE);
+    gtk_widget_set_tooltip_text (zoom_control->details->zoom_button,
+                                 _("Use the normal view size"));
+
+    gtk_widget_add_events (GTK_WIDGET (zoom_control->details->zoom_button),
+                           GDK_BUTTON_PRESS_MASK
+                           | GDK_BUTTON_RELEASE_MASK
+                           | GDK_POINTER_MOTION_MASK);
+
+    g_signal_connect (G_OBJECT (zoom_control->details->zoom_button),
+                      "button-press-event",
+                      G_CALLBACK (caja_zoom_control_button_press_event),
+                      zoom_control);
+
+    g_signal_connect (G_OBJECT (zoom_control->details->zoom_button),
+                      "clicked", G_CALLBACK (zoom_button_clicked),
+                      zoom_control);
+
+    g_signal_connect (G_OBJECT (zoom_control->details->zoom_button),
+                      "popup-menu", G_CALLBACK (zoom_popup_menu),
+                      zoom_control);
+
+    zoom_control->details->zoom_label = gtk_label_new ("100%");
+    g_signal_connect (zoom_control->details->zoom_label,
+                      "style_set",
+                      G_CALLBACK (label_style_set_callback),
+                      zoom_control);
+    set_label_size (zoom_control);
+
+    gtk_container_add (GTK_CONTAINER (zoom_control->details->zoom_button), zoom_control->details->zoom_label);
+
+    gtk_box_pack_start (GTK_BOX (zoom_control),
+                        zoom_control->details->zoom_button, TRUE, TRUE, 0);
+
+    image = gtk_image_new_from_stock (GTK_STOCK_ZOOM_IN, GTK_ICON_SIZE_MENU);
+    zoom_control->details->zoom_in = gtk_button_new ();
+    gtk_button_set_focus_on_click (GTK_BUTTON (zoom_control->details->zoom_in), FALSE);
+    gtk_button_set_relief (GTK_BUTTON (zoom_control->details->zoom_in),
+                           GTK_RELIEF_NONE);
+    gtk_widget_set_tooltip_text (zoom_control->details->zoom_in,
+                                 _("Increase the view size"));
+    g_signal_connect (G_OBJECT (zoom_control->details->zoom_in),
+                      "clicked", G_CALLBACK (zoom_in_clicked),
+                      zoom_control);
+
+    gtk_container_add (GTK_CONTAINER (zoom_control->details->zoom_in), image);
+    gtk_box_pack_start (GTK_BOX (zoom_control),
+                        zoom_control->details->zoom_in, FALSE, FALSE, 0);
+
+    gtk_widget_show_all (zoom_control->details->zoom_out);
+    gtk_widget_show_all (zoom_control->details->zoom_button);
+    gtk_widget_show_all (zoom_control->details->zoom_in);
+}
+
+/* Allocate a new zoom control */
+GtkWidget *
+caja_zoom_control_new (void)
+{
+    return gtk_widget_new (caja_zoom_control_get_type (), NULL);
+}
+
+static void
+caja_zoom_control_redraw (CajaZoomControl *zoom_control)
+{
+    int percent;
+    char *num_str;
+
+    gtk_widget_set_sensitive (zoom_control->details->zoom_in,
+                              caja_zoom_control_can_zoom_in (zoom_control));
+    gtk_widget_set_sensitive (zoom_control->details->zoom_out,
+                              caja_zoom_control_can_zoom_out (zoom_control));
+
+    percent = floor ((100.0 * caja_get_relative_icon_size_for_zoom_level (zoom_control->details->zoom_level)) + .2);
+    num_str = g_strdup_printf ("%d%%", percent);
+    gtk_label_set_text (GTK_LABEL (zoom_control->details->zoom_label), num_str);
+    g_free (num_str);
+}
+
+/* routines to create and handle the zoom menu */
+
+static void
+zoom_menu_callback (GtkMenuItem *item, gpointer callback_data)
+{
+    CajaZoomLevel zoom_level;
+    CajaZoomControl *zoom_control;
+    gboolean can_zoom;
+
+    zoom_control = CAJA_ZOOM_CONTROL (callback_data);
+
+    /* Don't do anything if we're just setting the toggle state of menu items. */
+    if (zoom_control->details->marking_menu_items)
+    {
+        return;
+    }
+
+    /* Don't send the signal if the menuitem was toggled off */
+    if (!gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (item)))
+    {
+        return;
+    }
+
+    zoom_level = (CajaZoomLevel) GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item), "zoom_level"));
+
+    /* Assume we can zoom and then check whether we're right. */
+    can_zoom = TRUE;
+    if (zoom_control->details->has_min_zoom_level &&
+            zoom_level < zoom_control->details->min_zoom_level)
+        can_zoom = FALSE; /* no, we're below the minimum zoom level. */
+    if (zoom_control->details->has_max_zoom_level &&
+            zoom_level > zoom_control->details->max_zoom_level)
+        can_zoom = FALSE; /* no, we're beyond the upper zoom level. */
+
+    /* if we can zoom */
+    if (can_zoom)
+    {
+        g_signal_emit (zoom_control, signals[ZOOM_TO_LEVEL], 0, zoom_level);
+    }
+}
+
+static GtkRadioMenuItem *
+create_zoom_menu_item (CajaZoomControl *zoom_control, GtkMenu *menu,
+                       CajaZoomLevel zoom_level,
+                       GtkRadioMenuItem *previous_radio_item)
+{
+    GtkWidget *menu_item;
+    char *item_text;
+    GSList *radio_item_group;
+    int percent;
+
+    /* Set flag so that callback isn't activated when set_active called
+     * to set toggle state of other radio items.
+     */
+    zoom_control->details->marking_menu_items = TRUE;
+
+    percent = floor ((100.0 * caja_get_relative_icon_size_for_zoom_level (zoom_level)) + .5);
+    item_text = g_strdup_printf ("%d%%", percent);
+
+    radio_item_group = previous_radio_item == NULL
+                       ? NULL
+                       : gtk_radio_menu_item_get_group (previous_radio_item);
+    menu_item = gtk_radio_menu_item_new_with_label (radio_item_group, item_text);
+    g_free (item_text);
+
+    gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
+                                    zoom_level == zoom_control->details->zoom_level);
+
+    g_object_set_data (G_OBJECT (menu_item), "zoom_level", GINT_TO_POINTER (zoom_level));
+    g_signal_connect_object (menu_item, "activate",
+                             G_CALLBACK (zoom_menu_callback), zoom_control, 0);
+
+    gtk_widget_show (menu_item);
+    gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
+
+    zoom_control->details->marking_menu_items = FALSE;
+
+    return GTK_RADIO_MENU_ITEM (menu_item);
+}
+
+static GtkMenu *
+create_zoom_menu (CajaZoomControl *zoom_control)
+{
+    GtkMenu *menu;
+    GtkRadioMenuItem *previous_item;
+    GList *node;
+
+    menu = GTK_MENU (gtk_menu_new ());
+
+    previous_item = NULL;
+    for (node = zoom_control->details->preferred_zoom_levels; node != NULL; node = node->next)
+    {
+        previous_item = create_zoom_menu_item
+                        (zoom_control, menu, GPOINTER_TO_INT (node->data), previous_item);
+    }
+
+    return menu;
+}
+
+static AtkObject *
+caja_zoom_control_get_accessible (GtkWidget *widget)
+{
+    AtkObject *accessible;
+
+    accessible = eel_accessibility_get_atk_object (widget);
+
+    if (accessible)
+    {
+        return accessible;
+    }
+
+    accessible = g_object_new
+                 (caja_zoom_control_accessible_get_type (), NULL);
+
+    return eel_accessibility_set_atk_object_return (widget, accessible);
+}
+
+static void
+caja_zoom_control_change_value (CajaZoomControl *zoom_control,
+                                GtkScrollType scroll)
+{
+    switch (scroll)
+    {
+    case GTK_SCROLL_STEP_DOWN :
+        if (caja_zoom_control_can_zoom_out (zoom_control))
+        {
+            g_signal_emit (zoom_control, signals[ZOOM_OUT], 0);
+        }
+        break;
+    case GTK_SCROLL_STEP_UP :
+        if (caja_zoom_control_can_zoom_in (zoom_control))
+        {
+            g_signal_emit (zoom_control, signals[ZOOM_IN], 0);
+        }
+        break;
+    default :
+        g_warning ("Invalid scroll type %d for CajaZoomControl:change_value", scroll);
+    }
+}
+
+void
+caja_zoom_control_set_zoom_level (CajaZoomControl *zoom_control,
+                                  CajaZoomLevel zoom_level)
+{
+    zoom_control->details->zoom_level = zoom_level;
+    caja_zoom_control_redraw (zoom_control);
+}
+
+void
+caja_zoom_control_set_parameters (CajaZoomControl *zoom_control,
+                                  CajaZoomLevel min_zoom_level,
+                                  CajaZoomLevel max_zoom_level,
+                                  gboolean has_min_zoom_level,
+                                  gboolean has_max_zoom_level,
+                                  GList *zoom_levels)
+{
+    g_return_if_fail (CAJA_IS_ZOOM_CONTROL (zoom_control));
+
+    zoom_control->details->min_zoom_level = min_zoom_level;
+    zoom_control->details->max_zoom_level = max_zoom_level;
+    zoom_control->details->has_min_zoom_level = has_min_zoom_level;
+    zoom_control->details->has_max_zoom_level = has_max_zoom_level;
+
+    g_list_free (zoom_control->details->preferred_zoom_levels);
+    zoom_control->details->preferred_zoom_levels = zoom_levels;
+
+    caja_zoom_control_redraw (zoom_control);
+}
+
+CajaZoomLevel
+caja_zoom_control_get_zoom_level (CajaZoomControl *zoom_control)
+{
+    return zoom_control->details->zoom_level;
+}
+
+CajaZoomLevel
+caja_zoom_control_get_min_zoom_level (CajaZoomControl *zoom_control)
+{
+    return zoom_control->details->min_zoom_level;
+}
+
+CajaZoomLevel
+caja_zoom_control_get_max_zoom_level (CajaZoomControl *zoom_control)
+{
+    return zoom_control->details->max_zoom_level;
+}
+
+gboolean
+caja_zoom_control_has_min_zoom_level (CajaZoomControl *zoom_control)
+{
+    return zoom_control->details->has_min_zoom_level;
+}
+
+gboolean
+caja_zoom_control_has_max_zoom_level (CajaZoomControl *zoom_control)
+{
+    return zoom_control->details->has_max_zoom_level;
+}
+
+gboolean
+caja_zoom_control_can_zoom_in (CajaZoomControl *zoom_control)
+{
+    return !zoom_control->details->has_max_zoom_level ||
+           (zoom_control->details->zoom_level
+            < zoom_control->details->max_zoom_level);
+}
+
+gboolean
+caja_zoom_control_can_zoom_out (CajaZoomControl *zoom_control)
+{
+    return !zoom_control->details->has_min_zoom_level ||
+           (zoom_control->details->zoom_level
+            > zoom_control->details->min_zoom_level);
+}
+
+static gboolean
+caja_zoom_control_scroll_event (GtkWidget *widget, GdkEventScroll *event)
+{
+    CajaZoomControl *zoom_control;
+
+    zoom_control = CAJA_ZOOM_CONTROL (widget);
+
+    if (event->type != GDK_SCROLL)
+    {
+        return FALSE;
+    }
+
+    if (event->direction == GDK_SCROLL_DOWN &&
+            caja_zoom_control_can_zoom_out (zoom_control))
+    {
+        g_signal_emit (widget, signals[ZOOM_OUT], 0);
+    }
+    else if (event->direction == GDK_SCROLL_UP &&
+             caja_zoom_control_can_zoom_in (zoom_control))
+    {
+        g_signal_emit (widget, signals[ZOOM_IN], 0);
+    }
+
+    /* We don't change our state (to reflect the new zoom) here. The zoomable will
+     * call back with the new level. Actually, the callback goes to the view-frame
+     * containing the zoomable which, in turn, emits zoom_level_changed, which
+     * someone (e.g. caja_window) picks up and handles by calling into us -
+     * caja_zoom_control_set_zoom_level.
+     */
+    return TRUE;
+}
+
+
+
+static void
+caja_zoom_control_class_init (CajaZoomControlClass *class)
+{
+    GtkWidgetClass *widget_class;
+    GtkBindingSet *binding_set;
+
+    G_OBJECT_CLASS (class)->finalize = caja_zoom_control_finalize;
+
+    widget_class = GTK_WIDGET_CLASS (class);
+
+    widget_class->get_accessible = caja_zoom_control_get_accessible;
+    widget_class->scroll_event = caja_zoom_control_scroll_event;
+
+    class->change_value = caja_zoom_control_change_value;
+
+    signals[ZOOM_IN] =
+        g_signal_new ("zoom_in",
+                      G_TYPE_FROM_CLASS (class),
+                      G_SIGNAL_RUN_LAST,
+                      G_STRUCT_OFFSET (CajaZoomControlClass,
+                                       zoom_in),
+                      NULL, NULL,
+                      g_cclosure_marshal_VOID__VOID,
+                      G_TYPE_NONE, 0);
+
+    signals[ZOOM_OUT] =
+        g_signal_new ("zoom_out",
+                      G_TYPE_FROM_CLASS (class),
+                      G_SIGNAL_RUN_LAST,
+                      G_STRUCT_OFFSET (CajaZoomControlClass,
+                                       zoom_out),
+                      NULL, NULL,
+                      g_cclosure_marshal_VOID__VOID,
+                      G_TYPE_NONE, 0);
+
+    signals[ZOOM_TO_LEVEL] =
+        g_signal_new ("zoom_to_level",
+                      G_TYPE_FROM_CLASS (class),
+                      G_SIGNAL_RUN_LAST,
+                      G_STRUCT_OFFSET (CajaZoomControlClass,
+                                       zoom_to_level),
+                      NULL, NULL,
+                      g_cclosure_marshal_VOID__INT,
+                      G_TYPE_NONE,
+                      1,
+                      G_TYPE_INT);
+
+    signals[ZOOM_TO_DEFAULT] =
+        g_signal_new ("zoom_to_default",
+                      G_TYPE_FROM_CLASS (class),
+                      G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+                      G_STRUCT_OFFSET (CajaZoomControlClass,
+                                       zoom_to_default),
+                      NULL, NULL,
+                      g_cclosure_marshal_VOID__VOID,
+                      G_TYPE_NONE, 0);
+
+    signals[CHANGE_VALUE] =
+        g_signal_new ("change_value",
+                      G_TYPE_FROM_CLASS (class),
+                      G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+                      G_STRUCT_OFFSET (CajaZoomControlClass,
+                                       change_value),
+                      NULL, NULL,
+                      g_cclosure_marshal_VOID__ENUM,
+                      G_TYPE_NONE, 1, GTK_TYPE_SCROLL_TYPE);
+
+    binding_set = gtk_binding_set_by_class (class);
+
+    gtk_binding_entry_add_signal (binding_set,
+                                  GDK_KP_Subtract, 0,
+                                  "change_value",
+                                  1, GTK_TYPE_SCROLL_TYPE,
+                                  GTK_SCROLL_STEP_DOWN);
+    gtk_binding_entry_add_signal (binding_set,
+                                  GDK_minus, 0,
+                                  "change_value",
+                                  1, GTK_TYPE_SCROLL_TYPE,
+                                  GTK_SCROLL_STEP_DOWN);
+
+    gtk_binding_entry_add_signal (binding_set,
+                                  GDK_KP_Equal, 0,
+                                  "zoom_to_default",
+                                  0);
+    gtk_binding_entry_add_signal (binding_set,
+                                  GDK_KP_Equal, 0,
+                                  "zoom_to_default",
+                                  0);
+
+    gtk_binding_entry_add_signal (binding_set,
+                                  GDK_KP_Add, 0,
+                                  "change_value",
+                                  1, GTK_TYPE_SCROLL_TYPE,
+                                  GTK_SCROLL_STEP_UP);
+    gtk_binding_entry_add_signal (binding_set,
+                                  GDK_plus, 0,
+                                  "change_value",
+                                  1, GTK_TYPE_SCROLL_TYPE,
+                                  GTK_SCROLL_STEP_UP);
+
+    g_type_class_add_private (G_OBJECT_CLASS (class), sizeof (CajaZoomControlDetails));
+}
+
+static gboolean
+caja_zoom_control_accessible_do_action (AtkAction *accessible, int i)
+{
+    GtkWidget *widget;
+
+    g_assert (i >= 0 && i < NUM_ACTIONS);
+
+    widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
+    if (!widget)
+    {
+        return FALSE;
+    }
+
+    g_signal_emit (widget,
+                   signals[caja_zoom_control_accessible_action_signals [i]],
+                   0);
+
+    return TRUE;
+}
+
+static int
+caja_zoom_control_accessible_get_n_actions (AtkAction *accessible)
+{
+
+    return NUM_ACTIONS;
+}
+
+static const char* caja_zoom_control_accessible_action_get_description(AtkAction* accessible, int i)
+{
+    g_assert(i >= 0 && i < NUM_ACTIONS);
+
+    return _(caja_zoom_control_accessible_action_descriptions[i]);
+}
+
+static const char* caja_zoom_control_accessible_action_get_name(AtkAction* accessible, int i)
+{
+    g_assert (i >= 0 && i < NUM_ACTIONS);
+
+    return _(caja_zoom_control_accessible_action_names[i]);
+}
+
+static void caja_zoom_control_accessible_action_interface_init(AtkActionIface* iface)
+{
+    iface->do_action = caja_zoom_control_accessible_do_action;
+    iface->get_n_actions = caja_zoom_control_accessible_get_n_actions;
+    iface->get_description = caja_zoom_control_accessible_action_get_description;
+    iface->get_name = caja_zoom_control_accessible_action_get_name;
+}
+
+static void
+caja_zoom_control_accessible_get_current_value (AtkValue *accessible,
+        GValue *value)
+{
+    CajaZoomControl *control;
+
+    g_value_init (value, G_TYPE_INT);
+
+    control = CAJA_ZOOM_CONTROL (gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible)));
+    if (!control)
+    {
+        g_value_set_int (value, CAJA_ZOOM_LEVEL_STANDARD);
+        return;
+    }
+
+    g_value_set_int (value, control->details->zoom_level);
+}
+
+static void
+caja_zoom_control_accessible_get_maximum_value (AtkValue *accessible,
+        GValue *value)
+{
+    CajaZoomControl *control;
+
+    g_value_init (value, G_TYPE_INT);
+
+    control = CAJA_ZOOM_CONTROL (gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible)));
+    if (!control)
+    {
+        g_value_set_int (value, CAJA_ZOOM_LEVEL_STANDARD);
+        return;
+    }
+
+    g_value_set_int (value, control->details->max_zoom_level);
+}
+
+static void
+caja_zoom_control_accessible_get_minimum_value (AtkValue *accessible,
+        GValue *value)
+{
+    CajaZoomControl *control;
+
+    g_value_init (value, G_TYPE_INT);
+
+    control = CAJA_ZOOM_CONTROL (gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible)));
+    if (!control)
+    {
+        g_value_set_int (value, CAJA_ZOOM_LEVEL_STANDARD);
+        return;
+    }
+
+    g_value_set_int (value, control->details->min_zoom_level);
+}
+
+static CajaZoomLevel
+nearest_preferred (CajaZoomControl *zoom_control, CajaZoomLevel value)
+{
+    CajaZoomLevel last_value;
+    CajaZoomLevel current_value;
+    GList *l;
+
+    if (!zoom_control->details->preferred_zoom_levels)
+    {
+        return value;
+    }
+
+    last_value = GPOINTER_TO_INT (zoom_control->details->preferred_zoom_levels->data);
+    current_value = last_value;
+
+    for (l = zoom_control->details->preferred_zoom_levels; l != NULL; l = l->next)
+    {
+        current_value = GPOINTER_TO_INT (l->data);
+
+        if (current_value > value)
+        {
+            float center = (last_value + current_value) / 2;
+
+            return (value < center) ? last_value : current_value;
+
+        }
+
+        last_value = current_value;
+    }
+
+    return current_value;
+}
+
+static gboolean
+caja_zoom_control_accessible_set_current_value (AtkValue *accessible,
+        const GValue *value)
+{
+    CajaZoomControl *control;
+    CajaZoomLevel zoom;
+
+    control = CAJA_ZOOM_CONTROL (gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible)));
+    if (!control)
+    {
+        return FALSE;
+    }
+
+    zoom = nearest_preferred (control, g_value_get_int (value));
+
+    g_signal_emit (control, signals[ZOOM_TO_LEVEL], 0, zoom);
+
+    return TRUE;
+}
+
+static void
+caja_zoom_control_accessible_value_interface_init (AtkValueIface *iface)
+{
+    iface->get_current_value = caja_zoom_control_accessible_get_current_value;
+    iface->get_maximum_value = caja_zoom_control_accessible_get_maximum_value;
+    iface->get_minimum_value = caja_zoom_control_accessible_get_minimum_value;
+    iface->set_current_value = caja_zoom_control_accessible_set_current_value;
+}
+
+static const char* caja_zoom_control_accessible_get_name(AtkObject* accessible)
+{
+    return _("Zoom");
+}
+
+static const char* caja_zoom_control_accessible_get_description(AtkObject* accessible)
+{
+    return _("Set the zoom level of the current view");
+}
+
+static void
+caja_zoom_control_accessible_initialize (AtkObject *accessible,
+        gpointer  data)
+{
+    if (ATK_OBJECT_CLASS (accessible_parent_class)->initialize != NULL)
+    {
+        ATK_OBJECT_CLASS (accessible_parent_class)->initialize (accessible, data);
+    }
+    atk_object_set_role (accessible, ATK_ROLE_DIAL);
+}
+
+static void
+caja_zoom_control_accessible_class_init (AtkObjectClass *klass)
+{
+    accessible_parent_class = g_type_class_peek_parent (klass);
+
+    klass->get_name = caja_zoom_control_accessible_get_name;
+    klass->get_description = caja_zoom_control_accessible_get_description;
+    klass->initialize = caja_zoom_control_accessible_initialize;
+}
+
+static GType
+caja_zoom_control_accessible_get_type (void)
+{
+    static GType type = 0;
+
+    if (!type)
+    {
+        static GInterfaceInfo atk_action_info =
+        {
+            (GInterfaceInitFunc)caja_zoom_control_accessible_action_interface_init,
+            (GInterfaceFinalizeFunc)NULL,
+            NULL
+        };
+
+        static GInterfaceInfo atk_value_info =
+        {
+            (GInterfaceInitFunc)caja_zoom_control_accessible_value_interface_init,
+            (GInterfaceFinalizeFunc)NULL,
+            NULL
+        };
+
+        type = eel_accessibility_create_derived_type
+               ("CajaZoomControlAccessible",
+                GTK_TYPE_HBOX,
+                caja_zoom_control_accessible_class_init);
+
+        g_type_add_interface_static (type, ATK_TYPE_ACTION,
+                                     &atk_action_info);
+        g_type_add_interface_static (type, ATK_TYPE_VALUE,
+                                     &atk_value_info);
+    }
+
+    return type;
+}
+
+void
+caja_zoom_control_set_active_appearance (CajaZoomControl *zoom_control, gboolean is_active)
+{
+    gtk_widget_set_sensitive (gtk_bin_get_child (GTK_BIN (zoom_control->details->zoom_in)), is_active);
+    gtk_widget_set_sensitive (gtk_bin_get_child (GTK_BIN (zoom_control->details->zoom_out)), is_active);
+    gtk_widget_set_sensitive (zoom_control->details->zoom_label, is_active);
+}