← Back to branch summary

~canonical-dx-team/ubuntu/maverick/gtk+2.0/menuproxy

« back to all changes in this revision

Viewing changes to gtk/gtkruler.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2007-05-04 12:24:25 UTC
  • mfrom: (1.1.21 upstream)
  • Revision ID: james.westby@ubuntu.com-20070504122425-0m8midgzrp40y8w2
Tags: 2.10.12-1ubuntu1
* Sync with Debian
* New upstream version:
  Fixed bugs:
  - 379414 file chooser warnings when changing path in the entry
  - 418585 GtkFileChooserDefault sizing code is not DPI independent
  - 419568 Crash in search if start with special letter
  - 435062 build dies with icon cache validation
  - 379399 Segfault to call gtk_print_operation_run twice.
  - 387889 cups backend has problems when there are too many printers
  - 418531 invalid read to gtkicontheme.c gtk_icon_theme_lookup_icon...
  - 423916 crash in color scheme code
  - 424042 Segmentation fault while quickly pressing Alt+arrows
  - 415260 Protect against negative indices when setting values in G...
  - 419171 XGetVisualInfo() may not set nxvisuals
  - 128852 Gdk cursors don't look good on win32
  - 344657 Ctrl-H doesn't toggle "Show Hidden Files" setting
  - 345345 PrintOperation::paginate is not emitted for class handler
  - 347567 GtkPrintOperation::end-print is not emitted if it's cance...
  - 369112 gtk_ui_manager_add_ui should accept unnamed separator
  - 392015 Selected menu item invisible on Windows Vista
  - 399253 MS-Windows Theme Bottom Tab placement rendering glitches
  - 399425 gtk_input_dialog_fill_axes() adds child to gtkscrolledwin...
  - 403251 [patch] little memory leak in GtkPrintJob
  - 403267 [patch] memory leak in GtkPageSetupUnixDialog
  - 403470 MS-Windows Theme tab placement other than on top leaks a ...
  - 404506 Windows system fonts that have multi-byte font names cann...
  - 405089 Incorrect window placement for GtkEventBox private window
  - 405515 Minor leak in gtkfilesystemmodel.c
  - 405539 gdk_pixbuf_save() for PNG saver can return FALSE without ...
  - 415681 gdk_window_clear_area includes an extra line and column o...
  - 418219 GtkRecentChooser should apply filter before sorting and c...
  - 418403 Scroll to printer after selecting it from settings
  - 421985 _gtk_print_operation_platform_backend_launch_preview
  - 421990 gtk_print_job_get_surface
  - 421993 gtk_print_operation_init
  - 423064 Conditional jump or move depends on uninitialised value(s...
  - 423722 Fix printing header in gtk-demo
  - 424168 gtk_print_operation_run on async preview
  - 425655 Don't install gtk+-unix-print-2.0.pc on non-UNIX platforms
  - 425786 GDK segfaults if XineramaQueryScreens fails
  - 428665 Lpr Backend gets stuck in infinite loop during gtk_enumer...
  - 429902 GtkPrintOperation leaks cairo contextes
  - 431997 First delay of GdkPixbufAnimationIter is wrong
  - 433242 Inconsistent scroll arrow position calculations
  - 433972 Placing gtk.Expander inside a gtk.TextView() changes gtk....
  - 434261 _gtk_toolbar_elide_underscores incorrectly handles some s...
  - 383354 ctrl-L should make 'Location' entry disappear
  - 418673 gtk_recent_manager_add_item
  - 429732 gtk_accel_group_finalize accesses invalid memory
  - 435028 WM_CLIENT_LEADER is wrong on the leader_window
  - 431067 Background of the header window is not updated
  - 338843 add recent files support inside the ui manager
  - 148535 add drop shadow to menus, tooltips, etc. under Windows XP
* debian/control.in:
  - Conflicts on ubuntulooks (<= 0.9.11-1)
* debian/patches/15_default-fallback-icon-theme.patch:
  - patch from Debian, fallback on gnome icon theme

Show diffs side-by-side

added added

removed removed

Lines of Context:
gtk/gtkruler.c
 
1
/* GTK - The GIMP Toolkit
 
2
 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
 
3
 *
 
4
 * This library is free software; you can redistribute it and/or
 
5
 * modify it under the terms of the GNU Lesser General Public
 
6
 * License as published by the Free Software Foundation; either
 
7
 * version 2 of the License, or (at your option) any later version.
 
8
 *
 
9
 * This library is distributed in the hope that it will be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
12
 * Lesser General Public License for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU Lesser General Public
 
15
 * License along with this library; if not, write to the
 
16
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 
17
 * Boston, MA 02111-1307, USA.
 
18
 */
 
19
 
 
20
/*
 
21
 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
 
22
 * file for a list of people on the GTK+ Team.  See the ChangeLog
 
23
 * files for a list of changes.  These files are distributed with
 
24
 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
 
25
 */
 
26
 
 
27
#include <config.h>
 
28
#include "gtkruler.h"
 
29
#include "gtkprivate.h"
 
30
#include "gtkintl.h"
 
31
#include "gtkalias.h"
 
32
 
 
33
enum {
 
34
  PROP_0,
 
35
  PROP_LOWER,
 
36
  PROP_UPPER,
 
37
  PROP_POSITION,
 
38
  PROP_MAX_SIZE,
 
39
  PROP_METRIC
 
40
};
 
41
 
 
42
static void gtk_ruler_realize       (GtkWidget      *widget);
 
43
static void gtk_ruler_unrealize     (GtkWidget      *widget);
 
44
static void gtk_ruler_size_allocate (GtkWidget      *widget,
 
45
                                     GtkAllocation  *allocation);
 
46
static gint gtk_ruler_expose        (GtkWidget      *widget,
 
47
                                     GdkEventExpose *event);
 
48
static void gtk_ruler_make_pixmap   (GtkRuler       *ruler);
 
49
static void gtk_ruler_set_property  (GObject        *object,
 
50
                                     guint            prop_id,
 
51
                                     const GValue   *value,
 
52
                                     GParamSpec     *pspec);
 
53
static void gtk_ruler_get_property  (GObject        *object,
 
54
                                     guint           prop_id,
 
55
                                     GValue         *value,
 
56
                                     GParamSpec     *pspec);
 
57
 
 
58
static const GtkRulerMetric ruler_metrics[] =
 
59
{
 
60
  { "Pixel", "Pi", 1.0, { 1, 2, 5, 10, 25, 50, 100, 250, 500, 1000 }, { 1, 5, 10, 50, 100 }},
 
61
  { "Inches", "In", 72.0, { 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 }, { 1, 2, 4, 8, 16 }},
 
62
  { "Centimeters", "Cn", 28.35, { 1, 2, 5, 10, 25, 50, 100, 250, 500, 1000 }, { 1, 5, 10, 50, 100 }},
 
63
};
 
64
 
 
65
G_DEFINE_TYPE (GtkRuler, gtk_ruler, GTK_TYPE_WIDGET)
 
66
 
 
67
static void
 
68
gtk_ruler_class_init (GtkRulerClass *class)
 
69
{
 
70
  GObjectClass   *gobject_class;
 
71
  GtkWidgetClass *widget_class;
 
72
 
 
73
  gobject_class = G_OBJECT_CLASS (class);
 
74
  widget_class = (GtkWidgetClass*) class;
 
75
 
 
76
  gobject_class->set_property = gtk_ruler_set_property;
 
77
  gobject_class->get_property = gtk_ruler_get_property;
 
78
 
 
79
  widget_class->realize = gtk_ruler_realize;
 
80
  widget_class->unrealize = gtk_ruler_unrealize;
 
81
  widget_class->size_allocate = gtk_ruler_size_allocate;
 
82
  widget_class->expose_event = gtk_ruler_expose;
 
83
 
 
84
  class->draw_ticks = NULL;
 
85
  class->draw_pos = NULL;
 
86
 
 
87
  g_object_class_install_property (gobject_class,
 
88
                                   PROP_LOWER,
 
89
                                   g_param_spec_double ("lower",
 
90
                                                        P_("Lower"),
 
91
                                                        P_("Lower limit of ruler"),
 
92
                                                        -G_MAXDOUBLE,
 
93
                                                        G_MAXDOUBLE,
 
94
                                                        0.0,
 
95
                                                        GTK_PARAM_READWRITE));  
 
96
 
 
97
  g_object_class_install_property (gobject_class,
 
98
                                   PROP_UPPER,
 
99
                                   g_param_spec_double ("upper",
 
100
                                                        P_("Upper"),
 
101
                                                        P_("Upper limit of ruler"),
 
102
                                                        -G_MAXDOUBLE,
 
103
                                                        G_MAXDOUBLE,
 
104
                                                        0.0,
 
105
                                                        GTK_PARAM_READWRITE));  
 
106
 
 
107
  g_object_class_install_property (gobject_class,
 
108
                                   PROP_POSITION,
 
109
                                   g_param_spec_double ("position",
 
110
                                                        P_("Position"),
 
111
                                                        P_("Position of mark on the ruler"),
 
112
                                                        -G_MAXDOUBLE,
 
113
                                                        G_MAXDOUBLE,
 
114
                                                        0.0,
 
115
                                                        GTK_PARAM_READWRITE));  
 
116
 
 
117
  g_object_class_install_property (gobject_class,
 
118
                                   PROP_MAX_SIZE,
 
119
                                   g_param_spec_double ("max-size",
 
120
                                                        P_("Max Size"),
 
121
                                                        P_("Maximum size of the ruler"),
 
122
                                                        -G_MAXDOUBLE,
 
123
                                                        G_MAXDOUBLE,
 
124
                                                        0.0,
 
125
                                                        GTK_PARAM_READWRITE));  
 
126
  /**
 
127
   * GtkRuler:metric:
 
128
   *
 
129
   * The metric used for the ruler.
 
130
   *
 
131
   * Since: 2.8
 
132
   */
 
133
  g_object_class_install_property (gobject_class,
 
134
                                   PROP_METRIC,
 
135
                                   g_param_spec_enum ("metric",
 
136
                                                      P_("Metric"),
 
137
                                                      P_("The metric used for the ruler"),
 
138
                                                      GTK_TYPE_METRIC_TYPE, 
 
139
                                                      GTK_PIXELS,
 
140
                                                      GTK_PARAM_READWRITE));  
 
141
}
 
142
 
 
143
static void
 
144
gtk_ruler_init (GtkRuler *ruler)
 
145
{
 
146
  ruler->backing_store = NULL;
 
147
  ruler->xsrc = 0;
 
148
  ruler->ysrc = 0;
 
149
  ruler->slider_size = 0;
 
150
  ruler->lower = 0;
 
151
  ruler->upper = 0;
 
152
  ruler->position = 0;
 
153
  ruler->max_size = 0;
 
154
 
 
155
  gtk_ruler_set_metric (ruler, GTK_PIXELS);
 
156
}
 
157
 
 
158
static void
 
159
gtk_ruler_set_property (GObject      *object,
 
160
                        guint         prop_id,
 
161
                        const GValue *value,
 
162
                        GParamSpec   *pspec)
 
163
{
 
164
  GtkRuler *ruler = GTK_RULER (object);
 
165
 
 
166
  switch (prop_id)
 
167
    {
 
168
    case PROP_LOWER:
 
169
      gtk_ruler_set_range (ruler, g_value_get_double (value), ruler->upper,
 
170
                           ruler->position, ruler->max_size);
 
171
      break;
 
172
    case PROP_UPPER:
 
173
      gtk_ruler_set_range (ruler, ruler->lower, g_value_get_double (value),
 
174
                           ruler->position, ruler->max_size);
 
175
      break;
 
176
    case PROP_POSITION:
 
177
      gtk_ruler_set_range (ruler, ruler->lower, ruler->upper,
 
178
                           g_value_get_double (value), ruler->max_size);
 
179
      break;
 
180
    case PROP_MAX_SIZE:
 
181
      gtk_ruler_set_range (ruler, ruler->lower, ruler->upper,
 
182
                           ruler->position,  g_value_get_double (value));
 
183
      break;
 
184
    case PROP_METRIC:
 
185
      gtk_ruler_set_metric (ruler, g_value_get_enum (value));
 
186
      break;
 
187
    default:
 
188
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 
189
      break;
 
190
    }
 
191
}
 
192
 
 
193
static void
 
194
gtk_ruler_get_property (GObject      *object,
 
195
                        guint         prop_id,
 
196
                        GValue       *value,
 
197
                        GParamSpec   *pspec)
 
198
{
 
199
  GtkRuler *ruler = GTK_RULER (object);
 
200
  
 
201
  switch (prop_id)
 
202
    {
 
203
    case PROP_LOWER:
 
204
      g_value_set_double (value, ruler->lower);
 
205
      break;
 
206
    case PROP_UPPER:
 
207
      g_value_set_double (value, ruler->upper);
 
208
      break;
 
209
    case PROP_POSITION:
 
210
      g_value_set_double (value, ruler->position);
 
211
      break;
 
212
    case PROP_MAX_SIZE:
 
213
      g_value_set_double (value, ruler->max_size);
 
214
      break;
 
215
    case PROP_METRIC:
 
216
      g_value_set_enum (value, gtk_ruler_get_metric (ruler));
 
217
      break;
 
218
    default:
 
219
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 
220
      break;
 
221
    }
 
222
}
 
223
 
 
224
void
 
225
gtk_ruler_set_metric (GtkRuler      *ruler,
 
226
                      GtkMetricType  metric)
 
227
{
 
228
  g_return_if_fail (GTK_IS_RULER (ruler));
 
229
 
 
230
  ruler->metric = (GtkRulerMetric *) &ruler_metrics[metric];
 
231
 
 
232
  if (GTK_WIDGET_DRAWABLE (ruler))
 
233
    gtk_widget_queue_draw (GTK_WIDGET (ruler));
 
234
 
 
235
  g_object_notify (G_OBJECT (ruler), "metric");
 
236
}
 
237
 
 
238
/**
 
239
 * gtk_ruler_get_metric:
 
240
 * @ruler: a #GtkRuler
 
241
 *
 
242
 * Gets the units used for a #GtkRuler. See gtk_ruler_set_metric().
 
243
 *
 
244
 * Return value: the units currently used for @ruler
 
245
 **/
 
246
GtkMetricType
 
247
gtk_ruler_get_metric (GtkRuler *ruler)
 
248
{
 
249
  gint i;
 
250
 
 
251
  g_return_val_if_fail (GTK_IS_RULER (ruler), 0);
 
252
 
 
253
  for (i = 0; i < G_N_ELEMENTS (ruler_metrics); i++)
 
254
    if (ruler->metric == &ruler_metrics[i])
 
255
      return i;
 
256
 
 
257
  g_assert_not_reached ();
 
258
 
 
259
  return 0;
 
260
}
 
261
 
 
262
void
 
263
gtk_ruler_set_range (GtkRuler *ruler,
 
264
                     gdouble   lower,
 
265
                     gdouble   upper,
 
266
                     gdouble   position,
 
267
                     gdouble   max_size)
 
268
{
 
269
  g_return_if_fail (GTK_IS_RULER (ruler));
 
270
 
 
271
  g_object_freeze_notify (G_OBJECT (ruler));
 
272
  if (ruler->lower != lower)
 
273
    {
 
274
      ruler->lower = lower;
 
275
      g_object_notify (G_OBJECT (ruler), "lower");
 
276
    }
 
277
  if (ruler->upper != upper)
 
278
    {
 
279
      ruler->upper = upper;
 
280
      g_object_notify (G_OBJECT (ruler), "upper");
 
281
    }
 
282
  if (ruler->position != position)
 
283
    {
 
284
      ruler->position = position;
 
285
      g_object_notify (G_OBJECT (ruler), "position");
 
286
    }
 
287
  if (ruler->max_size != max_size)
 
288
    {
 
289
      ruler->max_size = max_size;
 
290
      g_object_notify (G_OBJECT (ruler), "max-size");
 
291
    }
 
292
  g_object_thaw_notify (G_OBJECT (ruler));
 
293
 
 
294
  if (GTK_WIDGET_DRAWABLE (ruler))
 
295
    gtk_widget_queue_draw (GTK_WIDGET (ruler));
 
296
}
 
297
 
 
298
/**
 
299
 * gtk_ruler_get_range:
 
300
 * @ruler: a #GtkRuler
 
301
 * @lower: location to store lower limit of the ruler, or %NULL
 
302
 * @upper: location to store upper limit of the ruler, or %NULL
 
303
 * @position: location to store the current position of the mark on the ruler, or %NULL
 
304
 * @max_size: location to store the maximum size of the ruler used when calculating
 
305
 *            the space to leave for the text, or %NULL.
 
306
 *
 
307
 * Retrieves values indicating the range and current position of a #GtkRuler.
 
308
 * See gtk_ruler_set_range().
 
309
 **/
 
310
void
 
311
gtk_ruler_get_range (GtkRuler *ruler,
 
312
                     gdouble  *lower,
 
313
                     gdouble  *upper,
 
314
                     gdouble  *position,
 
315
                     gdouble  *max_size)
 
316
{
 
317
  g_return_if_fail (GTK_IS_RULER (ruler));
 
318
 
 
319
  if (lower)
 
320
    *lower = ruler->lower;
 
321
  if (upper)
 
322
    *upper = ruler->upper;
 
323
  if (position)
 
324
    *position = ruler->position;
 
325
  if (max_size)
 
326
    *max_size = ruler->max_size;
 
327
}
 
328
 
 
329
void
 
330
gtk_ruler_draw_ticks (GtkRuler *ruler)
 
331
{
 
332
  g_return_if_fail (GTK_IS_RULER (ruler));
 
333
 
 
334
  if (GTK_RULER_GET_CLASS (ruler)->draw_ticks)
 
335
    GTK_RULER_GET_CLASS (ruler)->draw_ticks (ruler);
 
336
}
 
337
 
 
338
void
 
339
gtk_ruler_draw_pos (GtkRuler *ruler)
 
340
{
 
341
  g_return_if_fail (GTK_IS_RULER (ruler));
 
342
 
 
343
  if (GTK_RULER_GET_CLASS (ruler)->draw_pos)
 
344
     GTK_RULER_GET_CLASS (ruler)->draw_pos (ruler);
 
345
}
 
346
 
 
347
 
 
348
static void
 
349
gtk_ruler_realize (GtkWidget *widget)
 
350
{
 
351
  GtkRuler *ruler;
 
352
  GdkWindowAttr attributes;
 
353
  gint attributes_mask;
 
354
 
 
355
  ruler = GTK_RULER (widget);
 
356
  GTK_WIDGET_SET_FLAGS (ruler, GTK_REALIZED);
 
357
 
 
358
  attributes.window_type = GDK_WINDOW_CHILD;
 
359
  attributes.x = widget->allocation.x;
 
360
  attributes.y = widget->allocation.y;
 
361
  attributes.width = widget->allocation.width;
 
362
  attributes.height = widget->allocation.height;
 
363
  attributes.wclass = GDK_INPUT_OUTPUT;
 
364
  attributes.visual = gtk_widget_get_visual (widget);
 
365
  attributes.colormap = gtk_widget_get_colormap (widget);
 
366
  attributes.event_mask = gtk_widget_get_events (widget);
 
367
  attributes.event_mask |= (GDK_EXPOSURE_MASK |
 
368
                            GDK_POINTER_MOTION_MASK |
 
369
                            GDK_POINTER_MOTION_HINT_MASK);
 
370
 
 
371
  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 
372
 
 
373
  widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
 
374
  gdk_window_set_user_data (widget->window, ruler);
 
375
 
 
376
  widget->style = gtk_style_attach (widget->style, widget->window);
 
377
  gtk_style_set_background (widget->style, widget->window, GTK_STATE_ACTIVE);
 
378
 
 
379
  gtk_ruler_make_pixmap (ruler);
 
380
}
 
381
 
 
382
static void
 
383
gtk_ruler_unrealize (GtkWidget *widget)
 
384
{
 
385
  GtkRuler *ruler = GTK_RULER (widget);
 
386
 
 
387
  if (ruler->backing_store)
 
388
    {
 
389
      g_object_unref (ruler->backing_store);
 
390
      ruler->backing_store = NULL;
 
391
    }
 
392
 
 
393
  if (ruler->non_gr_exp_gc)
 
394
    {
 
395
      g_object_unref (ruler->non_gr_exp_gc);
 
396
      ruler->non_gr_exp_gc = NULL;
 
397
    }
 
398
 
 
399
  if (GTK_WIDGET_CLASS (gtk_ruler_parent_class)->unrealize)
 
400
    (* GTK_WIDGET_CLASS (gtk_ruler_parent_class)->unrealize) (widget);
 
401
}
 
402
 
 
403
static void
 
404
gtk_ruler_size_allocate (GtkWidget     *widget,
 
405
                         GtkAllocation *allocation)
 
406
{
 
407
  GtkRuler *ruler = GTK_RULER (widget);
 
408
 
 
409
  widget->allocation = *allocation;
 
410
 
 
411
  if (GTK_WIDGET_REALIZED (widget))
 
412
    {
 
413
      gdk_window_move_resize (widget->window,
 
414
                              allocation->x, allocation->y,
 
415
                              allocation->width, allocation->height);
 
416
 
 
417
      gtk_ruler_make_pixmap (ruler);
 
418
    }
 
419
}
 
420
 
 
421
static gint
 
422
gtk_ruler_expose (GtkWidget      *widget,
 
423
                  GdkEventExpose *event)
 
424
{
 
425
  GtkRuler *ruler;
 
426
 
 
427
  if (GTK_WIDGET_DRAWABLE (widget))
 
428
    {
 
429
      ruler = GTK_RULER (widget);
 
430
 
 
431
      gtk_ruler_draw_ticks (ruler);
 
432
      
 
433
      gdk_draw_drawable (widget->window,
 
434
                         ruler->non_gr_exp_gc,
 
435
                         ruler->backing_store,
 
436
                         0, 0, 0, 0,
 
437
                         widget->allocation.width,
 
438
                         widget->allocation.height);
 
439
      
 
440
      gtk_ruler_draw_pos (ruler);
 
441
    }
 
442
 
 
443
  return FALSE;
 
444
}
 
445
 
 
446
static void
 
447
gtk_ruler_make_pixmap (GtkRuler *ruler)
 
448
{
 
449
  GtkWidget *widget;
 
450
  gint width;
 
451
  gint height;
 
452
 
 
453
  widget = GTK_WIDGET (ruler);
 
454
 
 
455
  if (ruler->backing_store)
 
456
    {
 
457
      gdk_drawable_get_size (ruler->backing_store, &width, &height);
 
458
      if ((width == widget->allocation.width) &&
 
459
          (height == widget->allocation.height))
 
460
        return;
 
461
 
 
462
      g_object_unref (ruler->backing_store);
 
463
    }
 
464
 
 
465
  ruler->backing_store = gdk_pixmap_new (widget->window,
 
466
                                         widget->allocation.width,
 
467
                                         widget->allocation.height,
 
468
                                         -1);
 
469
 
 
470
  ruler->xsrc = 0;
 
471
  ruler->ysrc = 0;
 
472
 
 
473
  if (!ruler->non_gr_exp_gc)
 
474
    {
 
475
      ruler->non_gr_exp_gc = gdk_gc_new (widget->window);
 
476
      gdk_gc_set_exposures (ruler->non_gr_exp_gc, FALSE);
 
477
    }
 
478
}
 
479
 
 
480
#define __GTK_RULER_C__
 
481
#include "gtkaliasdef.c"