← Back to branch summary

~ubuntu-branches/ubuntu/trusty/unity-control-center/trusty

« back to all changes in this revision

Viewing changes to panels/universal-access/zoom-options.c

  • Committer: Package Import Robot
  • Author(s): Robert Ancell
  • Date: 2014-01-08 16:29:18 UTC
  • Revision ID: package-import@ubuntu.com-20140108162918-g29dd08tr913y2qh
Tags: upstream-14.04.0
Import upstream version 14.04.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
panels/universal-access/zoom-options.c
 
1
/*
 
2
 * Copyright 2011 Inclusive Design Research Centre, OCAD University.
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or modify it
 
5
 * under the terms of the GNU General Public License as published by the
 
6
 * Free Software Foundation; either version 2.1 of the License, or (at your
 
7
 * option) any later version.
 
8
 *
 
9
 * This program is distributed in the hope that it will be useful, but WITHOUT
 
10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 
11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 
12
 * for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU Lesser General Public License
 
15
 * along with this program; if not, write to the Free Software Foundation,
 
16
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
17
 *
 
18
 * Author: Joseph Scheuhammer <clown@alum.mit.edu>
 
19
 */
 
20
 
 
21
#include "zoom-options.h"
 
22
#include <gdk/gdk.h>
 
23
#include <glib/gi18n.h>
 
24
#include <string.h>
 
25
 
 
26
#define WID(w) (GtkWidget *) gtk_builder_get_object (priv->builder, w)
 
27
 
 
28
#define POSITION_MODEL_VALUE_COLUMN     2
 
29
#define FONT_SCALE                      1.25
 
30
 
 
31
struct _ZoomOptionsPrivate
 
32
{
 
33
  GtkBuilder *builder;
 
34
  GSettings *settings;
 
35
  GSettings *application_settings;
 
36
 
 
37
  GtkWidget *position_combobox;
 
38
  GtkWidget *follow_mouse_radio;
 
39
  GtkWidget *screen_part_radio;
 
40
  GtkWidget *centered_radio;
 
41
  GtkWidget *push_radio;
 
42
  GtkWidget *proportional_radio;
 
43
  GtkWidget *extend_beyond_checkbox;
 
44
  GtkWidget *brightness_slider;
 
45
  GtkWidget *contrast_slider;
 
46
 
 
47
  GtkWidget *dialog;
 
48
};
 
49
 
 
50
G_DEFINE_TYPE (ZoomOptions, zoom_options, G_TYPE_OBJECT);
 
51
 
 
52
static gchar *brightness_keys[] = {
 
53
  "brightness-red",
 
54
  "brightness-green",
 
55
  "brightness-blue",
 
56
  NULL
 
57
};
 
58
 
 
59
static gchar *contrast_keys[] = {
 
60
  "contrast-red",
 
61
  "contrast-green",
 
62
  "contrast-blue",
 
63
  NULL
 
64
};
 
65
 
 
66
inline void set_active (GtkWidget* toggle, gboolean sense);
 
67
inline gboolean get_active (GtkWidget* toggle);
 
68
inline void set_sensitive (GtkWidget *widget, gboolean sense);
 
69
 
 
70
static void set_enable_screen_part_ui (GtkWidget *widget, ZoomOptionsPrivate *priv);
 
71
static void mouse_tracking_notify_cb (GSettings *settings, const gchar *key, ZoomOptionsPrivate *priv);
 
72
static void scale_label (GtkBin *toggle, PangoAttrList *attrs);
 
73
static void xhairs_color_opacity_changed (GtkColorButton *button, ZoomOptionsPrivate *priv);
 
74
static void xhairs_length_add_marks (GtkScale *scale);
 
75
static void effects_slider_set_value (GtkRange *slider, GSettings *settings);
 
76
static void brightness_slider_notify_cb (GSettings *settings, const gchar *key, ZoomOptionsPrivate *priv);
 
77
static void contrast_slider_notify_cb (GSettings *settings, const gchar *key, ZoomOptionsPrivate *priv);
 
78
static void effects_slider_changed (GtkRange *slider, ZoomOptionsPrivate *priv);
 
79
 
 
80
/* Utilties to save on line length */
 
81
 
 
82
inline void
 
83
set_active (GtkWidget* toggle, gboolean sense)
 
84
{
 
85
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), sense);
 
86
}
 
87
 
 
88
inline gboolean
 
89
get_active (GtkWidget* toggle)
 
90
{
 
91
    return gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (toggle));
 
92
}
 
93
 
 
94
inline void
 
95
set_sensitive (GtkWidget *widget, gboolean sense)
 
96
{
 
97
    gtk_widget_set_sensitive (widget, sense);
 
98
}
 
99
 
 
100
static void
 
101
mouse_tracking_radio_toggled_cb (GtkWidget *widget, ZoomOptionsPrivate *priv)
 
102
{
 
103
        if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)) == TRUE)
 
104
          {
 
105
        g_settings_set_string (priv->settings, "mouse-tracking",
 
106
                                   gtk_buildable_get_name (GTK_BUILDABLE (widget)));
 
107
      }
 
108
}
 
109
 
 
110
static void
 
111
init_mouse_mode_radio_group (GSList *mode_group, ZoomOptionsPrivate *priv)
 
112
{
 
113
    gchar *mode;
 
114
    gchar *name;
 
115
 
 
116
    mode = g_settings_get_string (priv->settings, "mouse-tracking");
 
117
        for (; mode_group != NULL; mode_group = mode_group->next)
 
118
          {
 
119
            name = (gchar *) gtk_buildable_get_name (GTK_BUILDABLE (mode_group->data));
 
120
            if (g_strcmp0 (name, mode) == 0)
 
121
              set_active (GTK_WIDGET (mode_group->data), TRUE);
 
122
            else
 
123
              set_active (GTK_WIDGET (mode_group->data), FALSE);
 
124
 
 
125
            g_signal_connect (G_OBJECT (mode_group->data), "toggled",
 
126
                          G_CALLBACK(mouse_tracking_radio_toggled_cb),
 
127
                          priv);
 
128
          }
 
129
}
 
130
 
 
131
static void
 
132
init_screen_part_section (ZoomOptionsPrivate *priv, PangoAttrList *pango_attrs)
 
133
{
 
134
  gboolean lens_mode;
 
135
  GSList *mouse_mode_group;
 
136
 
 
137
  priv->follow_mouse_radio = WID ("moveableLens");
 
138
  priv->screen_part_radio = WID ("screenPart");
 
139
  priv->centered_radio = WID ("centered");
 
140
  priv->push_radio = WID ("push");
 
141
  priv->proportional_radio = WID ("proportional");
 
142
  priv->extend_beyond_checkbox = WID ("scrollAtEdges");
 
143
 
 
144
  /* Scale the labels of the toggles */
 
145
  scale_label (GTK_BIN(priv->follow_mouse_radio), pango_attrs);
 
146
  scale_label (GTK_BIN(priv->screen_part_radio), pango_attrs);
 
147
  scale_label (GTK_BIN(priv->centered_radio), pango_attrs);
 
148
  scale_label (GTK_BIN(priv->push_radio), pango_attrs);
 
149
  scale_label (GTK_BIN(priv->proportional_radio), pango_attrs);
 
150
  scale_label (GTK_BIN(priv->extend_beyond_checkbox), pango_attrs);
 
151
 
 
152
  lens_mode = g_settings_get_boolean (priv->settings, "lens-mode");
 
153
  set_active (priv->follow_mouse_radio, lens_mode);
 
154
  set_active (priv->screen_part_radio, !lens_mode);
 
155
 
 
156
  mouse_mode_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (priv->centered_radio));
 
157
  init_mouse_mode_radio_group (mouse_mode_group, priv);
 
158
  set_enable_screen_part_ui (priv->screen_part_radio, priv);
 
159
 
 
160
  g_settings_bind (priv->settings, "lens-mode",
 
161
                   priv->follow_mouse_radio, "active",
 
162
                   G_SETTINGS_BIND_DEFAULT);
 
163
 
 
164
  g_settings_bind (priv->settings, "scroll-at-edges",
 
165
                   priv->extend_beyond_checkbox, "active",
 
166
                   G_SETTINGS_BIND_DEFAULT);
 
167
 
 
168
  g_signal_connect (G_OBJECT (priv->screen_part_radio), "toggled",
 
169
                    G_CALLBACK (set_enable_screen_part_ui), priv);
 
170
 
 
171
  g_signal_connect (G_OBJECT (priv->settings), "changed::mouse-tracking",
 
172
                    G_CALLBACK (mouse_tracking_notify_cb), priv);
 
173
}
 
174
 
 
175
static void
 
176
set_enable_screen_part_ui (GtkWidget *widget, ZoomOptionsPrivate *priv)
 
177
{
 
178
    gboolean screen_part;
 
179
 
 
180
    /* If the "screen part" radio is not checked, then the "follow mouse" radio
 
181
     * is checked (== lens mode). Set mouse tracking back to the default.
 
182
     */
 
183
    screen_part = get_active (priv->screen_part_radio);
 
184
    if (!screen_part)
 
185
      {
 
186
        g_settings_set_string (priv->settings,
 
187
                               "mouse-tracking", "proportional");
 
188
      }
 
189
 
 
190
    set_sensitive (priv->centered_radio, screen_part);
 
191
    set_sensitive (priv->push_radio, screen_part);
 
192
    set_sensitive (priv->proportional_radio, screen_part);
 
193
    set_sensitive (priv->extend_beyond_checkbox, screen_part);
 
194
}
 
195
 
 
196
static void
 
197
mouse_tracking_notify_cb (GSettings             *settings,
 
198
                          const gchar           *key,
 
199
                          ZoomOptionsPrivate    *priv)
 
200
{
 
201
  gchar *tracking;
 
202
 
 
203
  tracking = g_settings_get_string (settings, key);
 
204
  if (g_strcmp0 (tracking, "proportional") == 0)
 
205
    {
 
206
      set_active (priv->proportional_radio, TRUE);
 
207
    }
 
208
  else if (g_strcmp0 (tracking, "centered") == 0)
 
209
    {
 
210
      set_active (priv->centered_radio, TRUE);
 
211
    }
 
212
  else
 
213
    {
 
214
      set_active (priv->push_radio, TRUE);
 
215
    }
 
216
}
 
217
 
 
218
static void
 
219
scale_label (GtkBin *toggle, PangoAttrList *attrs)
 
220
{
 
221
  GtkWidget *label;
 
222
 
 
223
  label = gtk_bin_get_child (toggle);
 
224
  gtk_label_set_attributes (GTK_LABEL (label), attrs);
 
225
}
 
226
 
 
227
static void
 
228
screen_position_combo_changed_cb (GtkWidget *combobox, ZoomOptions *options)
 
229
{
 
230
  ZoomOptionsPrivate *priv = options->priv;
 
231
  gchar *combo_value = NULL;
 
232
  GtkTreeIter iter;
 
233
 
 
234
  gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combobox), &iter);
 
235
 
 
236
  gtk_tree_model_get (gtk_combo_box_get_model (GTK_COMBO_BOX (combobox)), &iter,
 
237
                      POSITION_MODEL_VALUE_COLUMN, &combo_value,
 
238
                      -1);
 
239
 
 
240
  if (g_strcmp0 (combo_value, ""))
 
241
    {
 
242
      g_settings_set_string (priv->settings, "screen-position", combo_value);
 
243
    }
 
244
 
 
245
  g_free (combo_value);
 
246
}
 
247
 
 
248
static void
 
249
screen_position_notify_cb (GSettings *settings,
 
250
                           const gchar *key,
 
251
                           ZoomOptions *options)
 
252
{
 
253
  ZoomOptionsPrivate *priv = options->priv;
 
254
  gchar *position;
 
255
  GtkTreeIter iter;
 
256
  GtkTreeModel *model;
 
257
  GtkComboBox *combobox;
 
258
  gboolean valid;
 
259
  gchar *combo_value;
 
260
 
 
261
  position = g_settings_get_string (settings, key);
 
262
  position = g_settings_get_string (priv->settings, key);
 
263
  combobox = GTK_COMBO_BOX (WID ("screen_position_combo_box"));
 
264
  model = gtk_combo_box_get_model (combobox);
 
265
 
 
266
  /* Find the matching screen position value in the combobox model.  If nothing
 
267
   * matches, leave the combobox as is.
 
268
   */
 
269
  valid = gtk_tree_model_get_iter_first (model, &iter);
 
270
  while (valid)
 
271
    {
 
272
        gtk_tree_model_get (model, &iter,
 
273
                            POSITION_MODEL_VALUE_COLUMN, &combo_value,
 
274
                            -1);
 
275
        if (!g_strcmp0 (combo_value, position))
 
276
          {
 
277
            g_signal_handlers_block_by_func (combobox, screen_position_combo_changed_cb, priv);
 
278
            gtk_combo_box_set_active_iter (combobox, &iter);
 
279
            g_signal_handlers_unblock_by_func (combobox, screen_position_combo_changed_cb, priv);
 
280
            g_free (combo_value);
 
281
            break;
 
282
          }
 
283
 
 
284
        g_free (combo_value);
 
285
        valid = gtk_tree_model_iter_next (model, &iter);
 
286
    }
 
287
}
 
288
 
 
289
static void
 
290
init_xhairs_color_opacity (GtkColorButton *color_button, GSettings *settings)
 
291
{
 
292
    gchar *color_setting;
 
293
    GdkRGBA rgba;
 
294
 
 
295
    color_setting = g_settings_get_string (settings, "cross-hairs-color");
 
296
    gdk_rgba_parse (&rgba, color_setting);
 
297
 
 
298
    rgba.alpha = g_settings_get_double (settings, "cross-hairs-opacity");
 
299
    gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (color_button), &rgba);
 
300
}
 
301
 
 
302
static void
 
303
xhairs_color_notify_cb (GSettings *settings, gchar *key, GtkColorButton *button)
 
304
{
 
305
    init_xhairs_color_opacity (button, settings);
 
306
}
 
307
 
 
308
static void
 
309
xhairs_opacity_notify_cb (GSettings *settings, gchar *key, GtkColorButton *button)
 
310
{
 
311
    GdkRGBA rgba;
 
312
    gdouble opacity;
 
313
 
 
314
    opacity = g_settings_get_double (settings, key);
 
315
    gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (button), &rgba);
 
316
    rgba.alpha = opacity * 65535;
 
317
    gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (button), &rgba);
 
318
}
 
319
 
 
320
#define TO_HEX(x) (int) ((gdouble) x * 255.0)
 
321
static void
 
322
xhairs_color_opacity_changed (GtkColorButton *button, ZoomOptionsPrivate *priv)
 
323
{
 
324
    GdkRGBA rgba;
 
325
    gchar *color_string;
 
326
 
 
327
    gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (button), &rgba);
 
328
    color_string = g_strdup_printf ("#%02x%02x%02x",
 
329
                                    TO_HEX(rgba.red),
 
330
                                    TO_HEX(rgba.green),
 
331
                                    TO_HEX(rgba.blue));
 
332
 
 
333
    g_settings_set_string (priv->settings, "cross-hairs-color", color_string);
 
334
    g_free (color_string);
 
335
 
 
336
    g_settings_set_double (priv->settings, "cross-hairs-opacity", rgba.alpha);
 
337
}
 
338
 
 
339
static void xhairs_length_add_marks (GtkScale *scale)
 
340
{
 
341
    gint length, quarter_length;
 
342
    GtkAdjustment *scale_model;
 
343
 
 
344
    /* Get maximum dimension of screen */
 
345
    length = MAX(gdk_screen_width(), gdk_screen_height());
 
346
    scale_model = gtk_range_get_adjustment (GTK_RANGE (scale));
 
347
    if (length < gtk_adjustment_get_upper(scale_model))
 
348
      {
 
349
        gtk_adjustment_set_upper (scale_model, length);
 
350
      }
 
351
 
 
352
    /* The crosshair is made up of four lines in pairs (top, bottom) and
 
353
       (left, right).  Stipulating: "quarter of the screen" means that the
 
354
       length of one hair is 25% of the screen. */
 
355
    quarter_length = length / 4;
 
356
 
 
357
    gtk_scale_add_mark (scale, 0, GTK_POS_BOTTOM, C_("Distance", "Short"));
 
358
    gtk_scale_add_mark (scale, quarter_length, GTK_POS_BOTTOM, C_("Distance", "¼ Screen"));
 
359
    gtk_scale_add_mark (scale, quarter_length * 2 , GTK_POS_BOTTOM, C_("Distance", "½ Screen"));
 
360
    gtk_scale_add_mark (scale, quarter_length * 3, GTK_POS_BOTTOM, C_("Distance", "¾ Screen"));
 
361
    gtk_scale_add_mark (scale, length, GTK_POS_BOTTOM, C_("Distance", "Long"));
 
362
}
 
363
 
 
364
static void
 
365
init_effects_slider (GtkRange *slider,
 
366
                     ZoomOptionsPrivate *priv,
 
367
                     gchar **keys,
 
368
                     GCallback notify_cb)
 
369
{
 
370
  gchar **key;
 
371
  gchar *signal;
 
372
 
 
373
  g_object_set_data (G_OBJECT (slider), "settings-keys", keys);
 
374
  effects_slider_set_value (slider, priv->settings);
 
375
 
 
376
  for (key = keys; *key; key++)
 
377
    {
 
378
      signal = g_strdup_printf ("changed::%s", *key);
 
379
      g_signal_connect (G_OBJECT (priv->settings), signal, notify_cb, priv);
 
380
      g_free (signal);
 
381
    }
 
382
  g_signal_connect (G_OBJECT (slider), "value-changed",
 
383
                    G_CALLBACK (effects_slider_changed),
 
384
                    priv);
 
385
  gtk_scale_add_mark (GTK_SCALE (slider), 0, GTK_POS_BOTTOM, NULL);
 
386
}
 
387
 
 
388
static void
 
389
effects_slider_set_value (GtkRange *slider, GSettings *settings)
 
390
{
 
391
    gchar **keys;
 
392
    gdouble red, green, blue;
 
393
    gdouble value;
 
394
 
 
395
    keys = g_object_get_data (G_OBJECT (slider), "settings-keys");
 
396
 
 
397
    red = g_settings_get_double (settings, keys[0]);
 
398
    green = g_settings_get_double (settings, keys[1]);
 
399
    blue = g_settings_get_double (settings, keys[2]);
 
400
 
 
401
    if (red == green && green == blue)
 
402
      value = red;
 
403
    else
 
404
      /* use NTSC conversion weights for reasonable average */
 
405
      value = 0.299 * red + 0.587 * green + 0.114 * blue;
 
406
 
 
407
    gtk_range_set_value (slider, value);
 
408
}
 
409
 
 
410
static void
 
411
brightness_slider_notify_cb (GSettings *settings,
 
412
                             const gchar *key,
 
413
                             ZoomOptionsPrivate *priv)
 
414
{
 
415
  GtkRange *slider = GTK_RANGE (priv->brightness_slider);
 
416
 
 
417
  g_signal_handlers_block_by_func (slider, effects_slider_changed, priv);
 
418
  effects_slider_set_value (slider, settings);
 
419
  g_signal_handlers_unblock_by_func (slider, effects_slider_changed, priv);
 
420
}
 
421
 
 
422
static void
 
423
contrast_slider_notify_cb (GSettings *settings,
 
424
                           const gchar *key,
 
425
                           ZoomOptionsPrivate *priv)
 
426
{
 
427
  GtkRange *slider = GTK_RANGE (priv->contrast_slider);
 
428
 
 
429
  g_signal_handlers_block_by_func (slider, effects_slider_changed, priv);
 
430
  effects_slider_set_value (slider, settings);
 
431
  g_signal_handlers_unblock_by_func (slider, effects_slider_changed, priv);
 
432
}
 
433
 
 
434
static void
 
435
effects_slider_changed (GtkRange *slider, ZoomOptionsPrivate *priv)
 
436
{
 
437
  gchar **keys, **key;
 
438
  gdouble value;
 
439
 
 
440
  keys = g_object_get_data (G_OBJECT (slider), "settings-keys");
 
441
  value = gtk_range_get_value (slider);
 
442
 
 
443
  for (key = keys; *key; key++)
 
444
    {
 
445
      g_settings_set_double (priv->settings, *key, value);
 
446
    }
 
447
}
 
448
 
 
449
static void
 
450
zoom_option_close_dialog_cb (GtkWidget *closer, ZoomOptionsPrivate *priv)
 
451
{
 
452
    if (priv->dialog != NULL)
 
453
        gtk_widget_hide (priv->dialog);
 
454
}
 
455
 
 
456
static void
 
457
zoom_options_dispose (GObject *object)
 
458
{
 
459
  g_return_if_fail (object != NULL);
 
460
  g_return_if_fail (ZOOM_IS_OPTIONS (object));
 
461
  ZoomOptionsPrivate *priv = ZOOM_OPTIONS (object)->priv;
 
462
 
 
463
  if (priv->builder)
 
464
    {
 
465
      g_object_unref (priv->builder);
 
466
      priv->builder = NULL;
 
467
    }
 
468
 
 
469
  if (priv->settings)
 
470
    {
 
471
      g_object_unref (priv->settings);
 
472
      priv->settings = NULL;
 
473
    }
 
474
 
 
475
  g_clear_object (&priv->application_settings);
 
476
 
 
477
  if (priv->dialog)
 
478
    {
 
479
      gtk_widget_destroy (priv->dialog);
 
480
      priv->dialog = NULL;
 
481
    }
 
482
 
 
483
  G_OBJECT_CLASS (zoom_options_parent_class)->dispose (object);
 
484
}
 
485
 
 
486
static void
 
487
zoom_options_finalize (GObject *object)
 
488
{
 
489
  G_OBJECT_CLASS (zoom_options_parent_class)->finalize (object);
 
490
}
 
491
 
 
492
static void
 
493
zoom_options_class_init (ZoomOptionsClass *klass)
 
494
{
 
495
  GObjectClass    *object_class = G_OBJECT_CLASS (klass);
 
496
 
 
497
  object_class->dispose = zoom_options_dispose;
 
498
  object_class->finalize = zoom_options_finalize;
 
499
 
 
500
  g_type_class_add_private (klass, sizeof (ZoomOptionsPrivate));
 
501
}
 
502
 
 
503
static void
 
504
zoom_options_init (ZoomOptions *self)
 
505
{
 
506
  ZoomOptionsPrivate *priv;
 
507
  GtkWidget *w;
 
508
  PangoAttrList *pango_attrs;
 
509
  PangoAttribute *attr;
 
510
  GError *err = NULL;
 
511
 
 
512
  priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, ZOOM_TYPE_OPTIONS, ZoomOptionsPrivate);
 
513
 
 
514
  priv->builder = gtk_builder_new ();
 
515
  gtk_builder_add_from_file (priv->builder,
 
516
                             GNOMECC_UI_DIR "/zoom-options.ui",
 
517
                             &err);
 
518
  if (err)
 
519
    {
 
520
      g_warning ("Could not load interface file: %s", err->message);
 
521
      g_error_free (err);
 
522
 
 
523
      g_object_unref (priv->builder);
 
524
      priv->builder = NULL;
 
525
 
 
526
      return;
 
527
    }
 
528
 
 
529
  priv->settings = g_settings_new ("org.gnome.desktop.a11y.magnifier");
 
530
  priv->application_settings = g_settings_new ("org.gnome.desktop.a11y.applications");
 
531
 
 
532
  pango_attrs = pango_attr_list_new ();
 
533
  attr = pango_attr_scale_new (FONT_SCALE);
 
534
  pango_attr_list_insert (pango_attrs, attr);
 
535
 
 
536
  /* Zoom switch */
 
537
  g_settings_bind (priv->application_settings, "screen-magnifier-enabled",
 
538
                   WID ("seeing_zoom_switch"), "active",
 
539
                   G_SETTINGS_BIND_DEFAULT);
 
540
 
 
541
  /* Magnification factor */
 
542
  w = WID ("magFactorSpinButton");
 
543
  g_settings_bind (priv->settings, "mag-factor",
 
544
                   gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (w)),
 
545
                   "value", G_SETTINGS_BIND_DEFAULT);
 
546
 
 
547
  /* Screen position combo */
 
548
  w = WID ("screen_position_combo_box");
 
549
  screen_position_notify_cb (priv->settings, "screen-position", self);
 
550
  g_signal_connect (G_OBJECT (priv->settings), "changed::screen-position",
 
551
                    G_CALLBACK (screen_position_notify_cb), self);
 
552
  g_signal_connect (G_OBJECT (w), "changed",
 
553
                    G_CALLBACK (screen_position_combo_changed_cb), self);
 
554
 
 
555
  /* Screen part section */
 
556
  init_screen_part_section (priv, pango_attrs);
 
557
 
 
558
  /* Cross hairs: show/hide ... */
 
559
  w = WID ("xhairsEnabledSwitch");
 
560
  g_settings_bind (priv->settings, "show-cross-hairs", w, "active",
 
561
                   G_SETTINGS_BIND_DEFAULT);
 
562
 
 
563
  /* ... Cross hairs: color and opacity */
 
564
  w = WID ("xHairsPicker");
 
565
  init_xhairs_color_opacity (GTK_COLOR_BUTTON (w), priv->settings);
 
566
  g_signal_connect (G_OBJECT (priv->settings), "changed::cross-hairs-color",
 
567
                    G_CALLBACK (xhairs_color_notify_cb), w);
 
568
  g_signal_connect (G_OBJECT (priv->settings), "changed::cross-hairs-opacity",
 
569
                    G_CALLBACK (xhairs_opacity_notify_cb), w);
 
570
  g_signal_connect (G_OBJECT (w), "color-set",
 
571
                    G_CALLBACK (xhairs_color_opacity_changed),
 
572
                    priv);
 
573
 
 
574
  /* ... Cross hairs: thickness ... */
 
575
  w = WID ("xHairsThicknessSlider");
 
576
  g_settings_bind (priv->settings, "cross-hairs-thickness",
 
577
                   gtk_range_get_adjustment (GTK_RANGE (w)), "value",
 
578
                   G_SETTINGS_BIND_DEFAULT);
 
579
 
 
580
  /* ... Cross hairs: clip ... */
 
581
  w = WID ("xHairsClipCheckbox");
 
582
  scale_label (GTK_BIN(w), pango_attrs);
 
583
  g_settings_bind (priv->settings, "cross-hairs-clip", w, "active",
 
584
                   G_SETTINGS_BIND_INVERT_BOOLEAN);
 
585
 
 
586
  /* ... Cross hairs: length ... */
 
587
  w = WID ("xHairsLengthSlider");
 
588
  xhairs_length_add_marks (GTK_SCALE (w));
 
589
  g_settings_bind (priv->settings, "cross-hairs-length",
 
590
                   gtk_range_get_adjustment (GTK_RANGE (w)), "value",
 
591
                   G_SETTINGS_BIND_DEFAULT);
 
592
 
 
593
  /* ... Color effects ... */
 
594
  w = WID ("inverseEnabledSwitch");
 
595
  g_settings_bind (priv->settings, "invert-lightness", w, "active",
 
596
                   G_SETTINGS_BIND_DEFAULT);
 
597
 
 
598
  w = WID ("brightnessSlider");
 
599
  priv->brightness_slider = w;
 
600
  init_effects_slider (GTK_RANGE(w), priv, brightness_keys,
 
601
                       G_CALLBACK (brightness_slider_notify_cb));
 
602
 
 
603
  w = WID ("contrastSlider");
 
604
  priv->contrast_slider = w;
 
605
  init_effects_slider (GTK_RANGE(w), priv, contrast_keys,
 
606
                       G_CALLBACK (contrast_slider_notify_cb));
 
607
 
 
608
  w = WID ("grayscale_slider");
 
609
  g_settings_bind (priv->settings, "color-saturation",
 
610
                   gtk_range_get_adjustment (GTK_RANGE (w)), "value",
 
611
                   G_SETTINGS_BIND_DEFAULT);
 
612
  gtk_scale_add_mark (GTK_SCALE(w), 1.0, GTK_POS_BOTTOM, NULL);
 
613
  /* ... Window itself ... */
 
614
  priv->dialog = WID ("magPrefsDialog");
 
615
 
 
616
  w = WID ("closeButton");
 
617
  g_signal_connect (G_OBJECT (w), "clicked",
 
618
                    G_CALLBACK (zoom_option_close_dialog_cb),
 
619
                    priv);
 
620
  g_signal_connect (G_OBJECT (priv->dialog), "delete-event",
 
621
                    G_CALLBACK (gtk_widget_hide_on_delete),
 
622
                    NULL);
 
623
 
 
624
  pango_attr_list_unref (pango_attrs);
 
625
}
 
626
 
 
627
/**
 
628
 * zoom_options_set_parent:
 
629
 * @self: the #ZoomOptions object
 
630
 * @parent: the parent #GtkWindow
 
631
 *
 
632
 * Activate the dialog associated with this ZoomOptions.
 
633
 */
 
634
void
 
635
zoom_options_set_parent (ZoomOptions *self,
 
636
                         GtkWindow   *parent)
 
637
{
 
638
  g_return_if_fail (ZOOM_IS_OPTIONS (self));
 
639
 
 
640
  gtk_window_set_transient_for (GTK_WINDOW (self->priv->dialog), parent);
 
641
  gtk_window_set_modal (GTK_WINDOW (self->priv->dialog), TRUE);
 
642
  gtk_widget_show (self->priv->dialog);
 
643
}
 
644
 
 
645
ZoomOptions *
 
646
zoom_options_new (void)
 
647
{
 
648
  return g_object_new (ZOOM_TYPE_OPTIONS, NULL);
 
649
}