cut-n-paste/zoom-control/ephy-zoom-control.c

   1 /*
   2  *  Copyright (C) 2003, 2004 Christian Persch
   3  *
   4  *  Modified 2005 by James Bowes for use in evince.
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2, or (at your option)
   9  *  any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19  *
  20  *  $Id$
  21  */
  22
  23 #include "config.h"
  24
  25 #include "ephy-zoom-control.h"
  26 #include "ephy-zoom.h"
  27 #include "ev-debug.h"
  28
  29 #include <gtk/gtk.h>
  30 #include <gtk/gtkcombobox.h>
  31 #include <gtk/gtktooltips.h>
  32 #include <glib/gi18n.h>
  33
  34 #define EPHY_ZOOM_CONTROL_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), EPHY_TYPE_ZOOM_CONTROL, EphyZoomControlPrivate))
  35
  36 struct _EphyZoomControlPrivate
  37 {
  38         GtkComboBox *combo;
  39         float zoom;
  40         guint handler_id;
  41 };
  42
  43 enum
  44 {
  45         COL_TEXT,
  46         COL_IS_SEP
  47 };
  48
  49 enum
  50 {
  51         PROP_0,
  52         PROP_ZOOM
  53 };
  54
  55 enum
  56 {
  57         ZOOM_TO_LEVEL_SIGNAL,
  58         LAST_SIGNAL
  59 };
  60
  61 static guint signals[LAST_SIGNAL];
  62
  63 static GObjectClass *parent_class = NULL;
  64
  65 static void     ephy_zoom_control_class_init    (EphyZoomControlClass *klass);
  66 static void     ephy_zoom_control_init          (EphyZoomControl *control);
  67 static void     ephy_zoom_control_finalize      (GObject *o);
  68
  69 GType
  70 ephy_zoom_control_get_type (void)
  71 {
  72         static GType type = 0;
  73
  74         if (G_UNLIKELY (type == 0))
  75         {
  76                 const GTypeInfo our_info =
  77                         {
  78                                 sizeof (EphyZoomControlClass),
  79                                 NULL, /* base_init */
  80                                 NULL, /* base_finalize */
  81                                 (GClassInitFunc) ephy_zoom_control_class_init,
  82                                 NULL,
  83                                 NULL, /* class_data */
  84                                 sizeof (EphyZoomControl),
  85                                 0, /* n_preallocs */
  86                                 (GInstanceInitFunc) ephy_zoom_control_init,
  87                         };
  88
  89                 type = g_type_register_static (GTK_TYPE_TOOL_ITEM,
  90                                                "EphyZoomControl",
  91                                                &our_info, 0);
  92         }
  93
  94         return type;
  95 }
  96
  97 static void
  98 combo_changed_cb (GtkComboBox *combo, EphyZoomControl *control)
  99 {
 100         gint index;
 101         float zoom;
 102
 103         index = gtk_combo_box_get_active (combo);
 104         zoom = zoom_levels[index].level;
 105
 106         if (zoom != control->priv->zoom)
 107         {
 108                 g_signal_emit (control, signals[ZOOM_TO_LEVEL_SIGNAL], 0, zoom);
 109         }
 110 }
 111
 112 static void
 113 sync_zoom_cb (EphyZoomControl *control, GParamSpec *pspec, gpointer data)
 114 {
 115         EphyZoomControlPrivate *p = control->priv;
 116         guint index;
 117
 118         index = ephy_zoom_get_zoom_level_index (p->zoom);
 119
 120         g_signal_handler_block (p->combo, p->handler_id);
 121         gtk_combo_box_set_active (p->combo, index);
 122         g_signal_handler_unblock (p->combo, p->handler_id);
 123 }
 124
 125 static gboolean
 126 row_is_separator (GtkTreeModel *model,
 127                   GtkTreeIter  *iter,
 128                   gpointer      data)
 129 {
 130         gboolean is_sep;
 131         gtk_tree_model_get (model, iter, COL_IS_SEP, &is_sep, -1);
 132         return is_sep;
 133 }
 134
 135 static void
 136 ephy_zoom_control_init (EphyZoomControl *control)
 137 {
 138         EphyZoomControlPrivate *p;
 139         GtkWidget *vbox;
 140         GtkCellRenderer *renderer;
 141         GtkListStore    *store;
 142         GtkTreeIter      iter;
 143         guint i;
 144
 145         p = EPHY_ZOOM_CONTROL_GET_PRIVATE (control);
 146         control->priv = p;
 147
 148         p->zoom = 1.0;
 149
 150         store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
 151
 152         for (i = 0; i < n_zoom_levels; i++)
 153         {
 154                 gtk_list_store_append (store, &iter);
 155
 156                 if (zoom_levels[i].name != NULL) {
 157                         gtk_list_store_set (store, &iter,
 158                                             COL_TEXT, _(zoom_levels[i].name),
 159                                             -1);
 160                 } else {
 161                         gtk_list_store_set (store, &iter,
 162                                             COL_IS_SEP, zoom_levels[i].name == NULL,
 163                                             -1);
 164                 }
 165         }
 166
 167         p->combo = GTK_COMBO_BOX (gtk_combo_box_new_with_model (GTK_TREE_MODEL (store)));
 168         g_object_unref (store);
 169
 170         renderer = gtk_cell_renderer_text_new ();
 171         gtk_cell_layout_pack_start     (GTK_CELL_LAYOUT (p->combo), renderer, TRUE);
 172         gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (p->combo), renderer,
 173                                         "text", COL_TEXT, NULL);
 174         gtk_combo_box_set_row_separator_func (p->combo,
 175                                               (GtkTreeViewRowSeparatorFunc) row_is_separator,
 176                                               NULL, NULL);
 177
 178         gtk_combo_box_set_focus_on_click (p->combo, FALSE);
 179         g_object_ref (p->combo);
 180         gtk_object_sink (GTK_OBJECT (p->combo));
 181         gtk_widget_show (GTK_WIDGET (p->combo));
 182
 183         i = ephy_zoom_get_zoom_level_index (p->zoom);
 184         gtk_combo_box_set_active (p->combo, i);
 185
 186         vbox = gtk_vbox_new (TRUE, 0);
 187         gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (p->combo), TRUE, FALSE, 0);
 188         gtk_widget_show (vbox);
 189
 190         gtk_container_add (GTK_CONTAINER (control), vbox);
 191
 192         p->handler_id = g_signal_connect (p->combo, "changed",
 193                                           G_CALLBACK (combo_changed_cb), control);
 194
 195         g_signal_connect_object (control, "notify::zoom",
 196                                  G_CALLBACK (sync_zoom_cb), NULL, 0);
 197 }
 198
 199 static void
 200 ephy_zoom_control_set_property (GObject *object,
 201                                 guint prop_id,
 202                                 const GValue *value,
 203                                 GParamSpec *pspec)
 204 {
 205         EphyZoomControl *control;
 206         EphyZoomControlPrivate *p;
 207
 208         control = EPHY_ZOOM_CONTROL (object);
 209         p = control->priv;
 210
 211         switch (prop_id)
 212         {
 213                 case PROP_ZOOM:
 214                         p->zoom = g_value_get_float (value);
 215                         break;
 216         }
 217 }
 218
 219 static void
 220 ephy_zoom_control_get_property (GObject *object,
 221                                 guint prop_id,
 222                                 GValue *value,
 223                                 GParamSpec *pspec)
 224 {
 225         EphyZoomControl *control;
 226         EphyZoomControlPrivate *p;
 227
 228         control = EPHY_ZOOM_CONTROL (object);
 229         p = control->priv;
 230
 231         switch (prop_id)
 232         {
 233                 case PROP_ZOOM:
 234                         g_value_set_float (value, p->zoom);
 235                         break;
 236         }
 237 }
 238
 239 static void
 240 set_combo_tooltip (GtkWidget *widget,
 241                    GtkTooltipsData *data)
 242 {
 243         if (GTK_IS_BUTTON (widget))
 244         {
 245                 gtk_tooltips_set_tip (data->tooltips, widget,
 246                                       data->tip_text, data->tip_private);
 247         }
 248 }
 249
 250 static void
 251 combo_realized (GtkWidget *combo,
 252                 GtkWidget *control)
 253 {
 254         GtkTooltipsData *data;
 255
 256         data = gtk_tooltips_data_get (control);
 257         g_return_if_fail (data != NULL);
 258
 259         gtk_container_forall (GTK_CONTAINER (combo),
 260                               (GtkCallback) set_combo_tooltip, data);
 261 }
 262
 263 static gboolean
 264 ephy_zoom_control_set_tooltip (GtkToolItem *tool_item,
 265                                GtkTooltips *tooltips,
 266                                const char *tip_text,
 267                                const char *tip_private)
 268 {
 269         EphyZoomControl *control = EPHY_ZOOM_CONTROL (tool_item);
 270         GtkWidget *widget = GTK_WIDGET (tool_item);
 271
 272         /* hack to make tooltips work also on Ctrl-F1 */
 273         gtk_tooltips_set_tip (tooltips, widget, tip_text, tip_private);
 274
 275         g_signal_handlers_disconnect_by_func
 276                 (control->priv->combo, G_CALLBACK (combo_realized), widget);
 277
 278         if (GTK_WIDGET_REALIZED (tool_item))
 279         {
 280                 combo_realized (GTK_WIDGET (control->priv->combo), widget);
 281         }
 282         else
 283         {
 284                 g_signal_connect_after (control->priv->combo, "realize",
 285                                         G_CALLBACK (combo_realized), widget);
 286         }
 287
 288         return TRUE;
 289 }
 290
 291 static void
 292 ephy_zoom_control_class_init (EphyZoomControlClass *klass)
 293 {
 294         GObjectClass *object_class;
 295         GtkToolItemClass *tool_item_class;
 296
 297         parent_class = g_type_class_peek_parent (klass);
 298
 299         object_class = (GObjectClass *)klass;
 300         tool_item_class = (GtkToolItemClass *)klass;
 301
 302         object_class->set_property = ephy_zoom_control_set_property;
 303         object_class->get_property = ephy_zoom_control_get_property;
 304         object_class->finalize = ephy_zoom_control_finalize;
 305
 306         tool_item_class->set_tooltip = ephy_zoom_control_set_tooltip;
 307
 308         g_object_class_install_property (object_class,
 309                                          PROP_ZOOM,
 310                                          g_param_spec_float ("zoom",
 311                                                              "Zoom",
 312                                                              "Zoom level to display in the item.",
 313                                                              ZOOM_MINIMAL,
 314                                                              ZOOM_MAXIMAL,
 315                                                              1.0,
 316                                                              G_PARAM_READWRITE));
 317
 318         signals[ZOOM_TO_LEVEL_SIGNAL] =
 319                 g_signal_new ("zoom_to_level",
 320                               G_TYPE_FROM_CLASS (klass),
 321                               G_SIGNAL_RUN_LAST,
 322                               G_STRUCT_OFFSET (EphyZoomControlClass,
 323                                                zoom_to_level),
 324                               NULL, NULL,
 325                               g_cclosure_marshal_VOID__FLOAT,
 326                               G_TYPE_NONE,
 327                               1,
 328                               G_TYPE_FLOAT);
 329
 330         g_type_class_add_private (object_class, sizeof (EphyZoomControlPrivate));
 331 }
 332
 333 static void
 334 ephy_zoom_control_finalize (GObject *o)
 335 {
 336         EphyZoomControl *control = EPHY_ZOOM_CONTROL (o);
 337
 338         g_object_unref (control->priv->combo);
 339
 340         G_OBJECT_CLASS (parent_class)->finalize (o);
 341 }
 342
 343 void
 344 ephy_zoom_control_set_zoom_level (EphyZoomControl *control, float zoom)
 345 {
 346         g_return_if_fail (EPHY_IS_ZOOM_CONTROL (control));
 347
 348         if (zoom < ZOOM_MINIMAL || zoom > ZOOM_MAXIMAL) return;
 349
 350         control->priv->zoom = zoom;
 351         g_object_notify (G_OBJECT (control), "zoom");
 352 }
 353
 354 float
 355 ephy_zoom_control_get_zoom_level (EphyZoomControl *control)
 356 {
 357         g_return_val_if_fail (EPHY_IS_ZOOM_CONTROL (control), 1.0);
 358
 359         return control->priv->zoom;
 360 }