← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gimp/jaunty-security

« back to all changes in this revision

Viewing changes to app/widgets/gimpdataeditor.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2007-05-02 16:33:03 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070502163303-bvzhjzbpw8qglc4y
Tags: 2.3.16-1ubuntu1
* Resynchronized with Debian, remaining Ubuntu changes:
  - debian/rules: i18n magic.
* debian/control.in:
  - Maintainer: Ubuntu Core Developers <ubuntu-devel@lists.ubuntu.com>
* debian/patches/02_help-message.patch,
  debian/patches/03_gimp.desktop.in.in.patch,
  debian/patches/10_dont_show_wizard.patch: updated.
* debian/patches/04_composite-signedness.patch,
  debian/patches/05_add-letter-spacing.patch: dropped, used upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
app/widgets/gimpdataeditor.c
1
 
/* The GIMP -- an image manipulation program
 
1
/* GIMP - The GNU Image Manipulation Program
2
2
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
3
3
 *
4
4
 * gimpdataeditor.c
24
24
#include <string.h>
25
25
 
26
26
#include <gtk/gtk.h>
 
27
#include <gdk/gdkkeysyms.h>
27
28
 
28
29
#include "libgimpwidgets/gimpwidgets.h"
29
30
 
44
45
#include "gimp-intl.h"
45
46
 
46
47
 
 
48
#define DEFAULT_MINIMAL_HEIGHT 96
 
49
 
 
50
 
47
51
enum
48
52
{
49
53
  PROP_0,
50
54
  PROP_DATA_FACTORY,
 
55
  PROP_CONTEXT,
51
56
  PROP_DATA
52
57
};
53
58
 
54
59
 
55
 
static void       gimp_data_editor_class_init (GimpDataEditorClass *klass);
56
 
static void       gimp_data_editor_init       (GimpDataEditor      *view);
57
 
 
58
 
static void       gimp_data_editor_docked_iface_init (GimpDockedInterface *docked_iface);
 
60
static void       gimp_data_editor_docked_iface_init (GimpDockedInterface *iface);
59
61
 
60
62
static GObject  * gimp_data_editor_constructor       (GType            type,
61
63
                                                      guint            n_params,
70
72
                                                      GParamSpec     *pspec);
71
73
static void       gimp_data_editor_dispose           (GObject        *object);
72
74
 
 
75
static void       gimp_data_editor_style_set         (GtkWidget      *widget,
 
76
                                                      GtkStyle       *prev_style);
 
77
 
 
78
static void       gimp_data_editor_set_context       (GimpDocked     *docked,
 
79
                                                      GimpContext    *context);
73
80
static void       gimp_data_editor_set_aux_info      (GimpDocked     *docked,
74
81
                                                      GList          *aux_info);
75
82
static GList    * gimp_data_editor_get_aux_info      (GimpDocked     *docked);
 
83
static gchar    * gimp_data_editor_get_title         (GimpDocked     *docked);
76
84
 
77
85
static void       gimp_data_editor_real_set_data     (GimpDataEditor *editor,
78
86
                                                      GimpData       *data);
79
87
 
 
88
static void       gimp_data_editor_data_changed      (GimpContext    *context,
 
89
                                                      GimpData       *data,
 
90
                                                      GimpDataEditor *editor);
 
91
static gboolean   gimp_data_editor_name_key_press    (GtkWidget      *widget,
 
92
                                                      GdkEventKey    *kevent,
 
93
                                                      GimpDataEditor *editor);
80
94
static void       gimp_data_editor_name_activate     (GtkWidget      *widget,
81
95
                                                      GimpDataEditor *editor);
82
96
static gboolean   gimp_data_editor_name_focus_out    (GtkWidget      *widget,
93
107
static void       gimp_data_editor_save_dirty        (GimpDataEditor *editor);
94
108
 
95
109
 
96
 
static GimpEditorClass *parent_class = NULL;
97
 
 
98
 
 
99
 
GType
100
 
gimp_data_editor_get_type (void)
101
 
{
102
 
  static GType type = 0;
103
 
 
104
 
  if (! type)
105
 
    {
106
 
      static const GTypeInfo view_info =
107
 
      {
108
 
        sizeof (GimpDataEditorClass),
109
 
        NULL,           /* base_init */
110
 
        NULL,           /* base_finalize */
111
 
        (GClassInitFunc) gimp_data_editor_class_init,
112
 
        NULL,           /* class_finalize */
113
 
        NULL,           /* class_data */
114
 
        sizeof (GimpDataEditor),
115
 
        0,              /* n_preallocs */
116
 
        (GInstanceInitFunc) gimp_data_editor_init,
117
 
      };
118
 
      static const GInterfaceInfo docked_iface_info =
119
 
      {
120
 
        (GInterfaceInitFunc) gimp_data_editor_docked_iface_init,
121
 
        NULL,           /* iface_finalize */
122
 
        NULL            /* iface_data     */
123
 
      };
124
 
 
125
 
      type = g_type_register_static (GIMP_TYPE_EDITOR,
126
 
                                     "GimpDataEditor",
127
 
                                     &view_info, 0);
128
 
 
129
 
      g_type_add_interface_static (type, GIMP_TYPE_DOCKED,
130
 
                                   &docked_iface_info);
131
 
    }
132
 
 
133
 
  return type;
134
 
}
 
110
G_DEFINE_TYPE_WITH_CODE (GimpDataEditor, gimp_data_editor, GIMP_TYPE_EDITOR,
 
111
                         G_IMPLEMENT_INTERFACE (GIMP_TYPE_DOCKED,
 
112
                                                gimp_data_editor_docked_iface_init))
 
113
 
 
114
#define parent_class gimp_data_editor_parent_class
 
115
 
 
116
static GimpDockedInterface *parent_docked_iface = NULL;
 
117
 
135
118
 
136
119
static void
137
120
gimp_data_editor_class_init (GimpDataEditorClass *klass)
138
121
{
139
 
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
140
 
 
141
 
  parent_class = g_type_class_peek_parent (klass);
 
122
  GObjectClass   *object_class = G_OBJECT_CLASS (klass);
 
123
  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
142
124
 
143
125
  object_class->constructor  = gimp_data_editor_constructor;
144
126
  object_class->set_property = gimp_data_editor_set_property;
145
127
  object_class->get_property = gimp_data_editor_get_property;
146
128
  object_class->dispose      = gimp_data_editor_dispose;
147
129
 
 
130
  widget_class->style_set    = gimp_data_editor_style_set;
 
131
 
148
132
  klass->set_data            = gimp_data_editor_real_set_data;
149
133
 
150
134
  g_object_class_install_property (object_class, PROP_DATA_FACTORY,
151
135
                                   g_param_spec_object ("data-factory",
152
136
                                                        NULL, NULL,
153
137
                                                        GIMP_TYPE_DATA_FACTORY,
154
 
                                                        G_PARAM_READWRITE |
 
138
                                                        GIMP_PARAM_READWRITE |
155
139
                                                        G_PARAM_CONSTRUCT_ONLY));
156
140
 
 
141
  g_object_class_install_property (object_class, PROP_CONTEXT,
 
142
                                   g_param_spec_object ("context",
 
143
                                                        NULL, NULL,
 
144
                                                        GIMP_TYPE_CONTEXT,
 
145
                                                        GIMP_PARAM_READWRITE));
 
146
 
157
147
  g_object_class_install_property (object_class, PROP_DATA,
158
148
                                   g_param_spec_object ("data",
159
149
                                                        NULL, NULL,
160
150
                                                        GIMP_TYPE_DATA,
161
 
                                                        G_PARAM_READWRITE));
 
151
                                                        GIMP_PARAM_READWRITE));
 
152
 
 
153
  gtk_widget_class_install_style_property (widget_class,
 
154
                                           g_param_spec_int ("minimal-height",
 
155
                                                             NULL, NULL,
 
156
                                                             32,
 
157
                                                             G_MAXINT,
 
158
                                                             DEFAULT_MINIMAL_HEIGHT,
 
159
                                                             GIMP_PARAM_READABLE));
162
160
}
163
161
 
164
162
static void
165
163
gimp_data_editor_init (GimpDataEditor *editor)
166
164
{
167
165
  editor->data_factory  = NULL;
 
166
  editor->context       = NULL;
168
167
  editor->data          = NULL;
169
168
  editor->data_editable = FALSE;
170
169
 
172
171
  gtk_box_pack_start (GTK_BOX (editor), editor->name_entry, FALSE, FALSE, 0);
173
172
  gtk_widget_show (editor->name_entry);
174
173
 
 
174
  gtk_editable_set_editable (GTK_EDITABLE (editor->name_entry), FALSE);
 
175
 
 
176
  g_signal_connect (editor->name_entry, "key-press-event",
 
177
                    G_CALLBACK (gimp_data_editor_name_key_press),
 
178
                    editor);
175
179
  g_signal_connect (editor->name_entry, "activate",
176
 
                    G_CALLBACK (gimp_data_editor_name_activate),
 
180
                    G_CALLBACK (gimp_data_editor_name_activate),
177
181
                    editor);
178
 
  g_signal_connect (editor->name_entry, "focus_out_event",
179
 
                    G_CALLBACK (gimp_data_editor_name_focus_out),
 
182
  g_signal_connect (editor->name_entry, "focus-out-event",
 
183
                    G_CALLBACK (gimp_data_editor_name_focus_out),
180
184
                    editor);
181
185
}
182
186
 
183
187
static void
184
 
gimp_data_editor_docked_iface_init (GimpDockedInterface *docked_iface)
 
188
gimp_data_editor_docked_iface_init (GimpDockedInterface *iface)
185
189
{
186
 
  docked_iface->set_aux_info = gimp_data_editor_set_aux_info;
187
 
  docked_iface->get_aux_info = gimp_data_editor_get_aux_info;
 
190
  parent_docked_iface = g_type_interface_peek_parent (iface);
 
191
 
 
192
  if (! parent_docked_iface)
 
193
    parent_docked_iface = g_type_default_interface_peek (GIMP_TYPE_DOCKED);
 
194
 
 
195
  iface->set_context  = gimp_data_editor_set_context;
 
196
  iface->set_aux_info = gimp_data_editor_set_aux_info;
 
197
  iface->get_aux_info = gimp_data_editor_get_aux_info;
 
198
  iface->get_title    = gimp_data_editor_get_title;
188
199
}
189
200
 
190
201
static GObject *
199
210
 
200
211
  editor = GIMP_DATA_EDITOR (object);
201
212
 
 
213
  g_assert (GIMP_IS_DATA_FACTORY (editor->data_factory));
 
214
 
 
215
  gimp_data_editor_set_edit_active (editor, TRUE);
 
216
 
202
217
  editor->save_button =
203
218
    gimp_editor_add_button (GIMP_EDITOR (editor),
204
219
                            GTK_STOCK_SAVE,
235
250
    case PROP_DATA_FACTORY:
236
251
      editor->data_factory = g_value_get_object (value);
237
252
      break;
 
253
    case PROP_CONTEXT:
 
254
      gimp_docked_set_context (GIMP_DOCKED (object),
 
255
                               g_value_get_object (value));
 
256
      break;
238
257
    case PROP_DATA:
239
 
      gimp_data_editor_set_data (editor,
240
 
                                 (GimpData *) g_value_get_object (value));
 
258
      gimp_data_editor_set_data (editor, g_value_get_object (value));
241
259
      break;
242
260
    default:
243
261
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
258
276
    case PROP_DATA_FACTORY:
259
277
      g_value_set_object (value, editor->data_factory);
260
278
      break;
 
279
    case PROP_CONTEXT:
 
280
      g_value_set_object (value, editor->context);
 
281
      break;
261
282
    case PROP_DATA:
262
283
      g_value_set_object (value, editor->data);
263
284
      break;
279
300
      gimp_data_editor_set_data (editor, NULL);
280
301
    }
281
302
 
 
303
  if (editor->context)
 
304
    gimp_docked_set_context (GIMP_DOCKED (editor), NULL);
 
305
 
282
306
  G_OBJECT_CLASS (parent_class)->dispose (object);
283
307
}
284
308
 
 
309
static void
 
310
gimp_data_editor_style_set (GtkWidget *widget,
 
311
                            GtkStyle  *prev_style)
 
312
{
 
313
  GimpDataEditor *editor = GIMP_DATA_EDITOR (widget);
 
314
  gint            minimal_height;
 
315
 
 
316
  if (GTK_WIDGET_CLASS (parent_class)->style_set)
 
317
    GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);
 
318
 
 
319
  gtk_widget_style_get (widget,
 
320
                        "minimal-height", &minimal_height,
 
321
                        NULL);
 
322
 
 
323
  if (editor->view)
 
324
    gtk_widget_set_size_request (editor->view, -1, minimal_height);
 
325
}
 
326
 
 
327
static void
 
328
gimp_data_editor_set_context (GimpDocked  *docked,
 
329
                              GimpContext *context)
 
330
{
 
331
  GimpDataEditor *editor = GIMP_DATA_EDITOR (docked);
 
332
 
 
333
  if (context == editor->context)
 
334
    return;
 
335
 
 
336
  if (parent_docked_iface->set_context)
 
337
    parent_docked_iface->set_context (docked, context);
 
338
 
 
339
  if (editor->context)
 
340
    {
 
341
      g_signal_handlers_disconnect_by_func (editor->context,
 
342
                                            gimp_data_editor_data_changed,
 
343
                                            editor);
 
344
 
 
345
      g_object_unref (editor->context);
 
346
    }
 
347
 
 
348
  editor->context = context;
 
349
 
 
350
  if (editor->context)
 
351
    {
 
352
      GType     data_type;
 
353
      GimpData *data;
 
354
 
 
355
      g_object_ref (editor->context);
 
356
 
 
357
      data_type = editor->data_factory->container->children_type;
 
358
      data = GIMP_DATA (gimp_context_get_by_type (editor->context, data_type));
 
359
 
 
360
      g_signal_connect (editor->context,
 
361
                        gimp_context_type_to_signal_name (data_type),
 
362
                        G_CALLBACK (gimp_data_editor_data_changed),
 
363
                        editor);
 
364
 
 
365
      gimp_data_editor_data_changed (editor->context, data, editor);
 
366
    }
 
367
}
 
368
 
 
369
#define AUX_INFO_EDIT_ACTIVE  "edit-active"
285
370
#define AUX_INFO_CURRENT_DATA "current-data"
286
371
 
287
372
static void
291
376
  GimpDataEditor *editor = GIMP_DATA_EDITOR (docked);
292
377
  GList          *list;
293
378
 
 
379
  parent_docked_iface->set_aux_info (docked, aux_info);
 
380
 
294
381
  for (list = aux_info; list; list = g_list_next (list))
295
382
    {
296
383
      GimpSessionInfoAux *aux = list->data;
297
384
 
298
 
      if (! strcmp (aux->name, AUX_INFO_CURRENT_DATA))
299
 
        {
300
 
          GimpData *data;
301
 
 
302
 
          data = (GimpData *)
303
 
            gimp_container_get_child_by_name (editor->data_factory->container,
304
 
                                              aux->value);
305
 
 
306
 
          if (data)
307
 
            gimp_data_editor_set_data (editor, data);
 
385
      if (! strcmp (aux->name, AUX_INFO_EDIT_ACTIVE))
 
386
        {
 
387
          gboolean edit_active;
 
388
 
 
389
          edit_active = ! g_ascii_strcasecmp (aux->value, "true");
 
390
 
 
391
          gimp_data_editor_set_edit_active (editor, edit_active);
 
392
        }
 
393
      else if (! strcmp (aux->name, AUX_INFO_CURRENT_DATA))
 
394
        {
 
395
          if (! editor->edit_active)
 
396
            {
 
397
              GimpData *data;
 
398
 
 
399
              data = (GimpData *)
 
400
                gimp_container_get_child_by_name (editor->data_factory->container,
 
401
                                                  aux->value);
 
402
 
 
403
              if (data)
 
404
                gimp_data_editor_set_data (editor, data);
 
405
            }
308
406
        }
309
407
    }
310
408
}
312
410
static GList *
313
411
gimp_data_editor_get_aux_info (GimpDocked *docked)
314
412
{
315
 
  GimpDataEditor *editor   = GIMP_DATA_EDITOR (docked);
316
 
  GList          *aux_info = NULL;
 
413
  GimpDataEditor     *editor = GIMP_DATA_EDITOR (docked);
 
414
  GList              *aux_info;
 
415
  GimpSessionInfoAux *aux;
 
416
 
 
417
  aux_info = parent_docked_iface->get_aux_info (docked);
 
418
 
 
419
  aux = gimp_session_info_aux_new (AUX_INFO_EDIT_ACTIVE,
 
420
                                   editor->edit_active ? "true" : "false");
 
421
  aux_info = g_list_append (aux_info, aux);
317
422
 
318
423
  if (editor->data)
319
424
    {
320
 
      GimpSessionInfoAux *aux;
321
 
      const gchar        *value;
 
425
      const gchar *value;
322
426
 
323
427
      value = gimp_object_get_name (GIMP_OBJECT (editor->data));
324
428
 
329
433
  return aux_info;
330
434
}
331
435
 
 
436
static gchar *
 
437
gimp_data_editor_get_title (GimpDocked *docked)
 
438
{
 
439
  GimpDataEditor      *editor       = GIMP_DATA_EDITOR (docked);
 
440
  GimpDataEditorClass *editor_class = GIMP_DATA_EDITOR_GET_CLASS (editor);
 
441
 
 
442
  if (editor->data_editable)
 
443
    return g_strdup (editor_class->title);
 
444
  else
 
445
    return g_strdup_printf (_("%s (read only)"), editor_class->title);
 
446
}
 
447
 
332
448
static void
333
449
gimp_data_editor_real_set_data (GimpDataEditor *editor,
334
450
                                GimpData       *data)
335
451
{
 
452
  gboolean editable;
 
453
 
336
454
  if (editor->data)
337
455
    {
338
456
      g_signal_handlers_disconnect_by_func (editor->data,
348
466
    {
349
467
      g_object_ref (editor->data);
350
468
 
351
 
      g_signal_connect (editor->data, "name_changed",
 
469
      g_signal_connect (editor->data, "name-changed",
352
470
                        G_CALLBACK (gimp_data_editor_data_name_changed),
353
471
                        editor);
354
472
 
360
478
      gtk_entry_set_text (GTK_ENTRY (editor->name_entry), "");
361
479
    }
362
480
 
363
 
  editor->data_editable = (editor->data && editor->data->writable);
364
 
 
365
 
  gtk_widget_set_sensitive (editor->name_entry, editor->data_editable);
 
481
  editable = (editor->data && editor->data->writable);
 
482
 
 
483
  if (editor->data_editable != editable)
 
484
    {
 
485
      editor->data_editable = editable;
 
486
 
 
487
      gtk_editable_set_editable (GTK_EDITABLE (editor->name_entry), editable);
 
488
      gimp_docked_title_changed (GIMP_DOCKED (editor));
 
489
    }
366
490
}
367
491
 
368
492
void
395
519
  return editor->data;
396
520
}
397
521
 
 
522
void
 
523
gimp_data_editor_set_edit_active (GimpDataEditor *editor,
 
524
                                  gboolean        edit_active)
 
525
{
 
526
  g_return_if_fail (GIMP_IS_DATA_EDITOR (editor));
 
527
 
 
528
  if (editor->edit_active != edit_active)
 
529
    {
 
530
      editor->edit_active = edit_active;
 
531
 
 
532
      if (editor->edit_active && editor->context)
 
533
        {
 
534
          GType     data_type;
 
535
          GimpData *data;
 
536
 
 
537
          data_type = editor->data_factory->container->children_type;
 
538
          data = GIMP_DATA (gimp_context_get_by_type (editor->context,
 
539
                                                      data_type));
 
540
 
 
541
          gimp_data_editor_set_data (editor, data);
 
542
        }
 
543
    }
 
544
}
 
545
 
 
546
gboolean
 
547
gimp_data_editor_get_edit_active (GimpDataEditor *editor)
 
548
{
 
549
  g_return_val_if_fail (GIMP_IS_DATA_EDITOR (editor), FALSE);
 
550
 
 
551
  return editor->edit_active;
 
552
}
 
553
 
398
554
 
399
555
/*  private functions  */
400
556
 
401
557
static void
 
558
gimp_data_editor_data_changed (GimpContext    *context,
 
559
                               GimpData       *data,
 
560
                               GimpDataEditor *editor)
 
561
{
 
562
  if (editor->edit_active)
 
563
    gimp_data_editor_set_data (editor, data);
 
564
}
 
565
 
 
566
static gboolean
 
567
gimp_data_editor_name_key_press (GtkWidget      *widget,
 
568
                                 GdkEventKey    *kevent,
 
569
                                 GimpDataEditor *editor)
 
570
{
 
571
  if (kevent->keyval == GDK_Escape)
 
572
    {
 
573
      gtk_entry_set_text (GTK_ENTRY (editor->name_entry),
 
574
                          gimp_object_get_name (GIMP_OBJECT (editor->data)));
 
575
      return TRUE;
 
576
    }
 
577
 
 
578
  return FALSE;
 
579
}
 
580
 
 
581
static void
402
582
gimp_data_editor_name_activate (GtkWidget      *widget,
403
583
                                GimpDataEditor *editor)
404
584
{
405
585
  if (editor->data)
406
586
    {
407
 
      const gchar *entry_text;
408
 
 
409
 
      entry_text = gtk_entry_get_text (GTK_ENTRY (widget));
410
 
 
411
 
      gimp_object_set_name (GIMP_OBJECT (editor->data), entry_text);
 
587
      gchar *new_name;
 
588
 
 
589
      new_name = g_strdup (gtk_entry_get_text (GTK_ENTRY (widget)));
 
590
      new_name = g_strstrip (new_name);
 
591
 
 
592
      if (strlen (new_name))
 
593
        {
 
594
          gimp_object_take_name (GIMP_OBJECT (editor->data), new_name);
 
595
        }
 
596
      else
 
597
        {
 
598
          gtk_entry_set_text (GTK_ENTRY (widget),
 
599
                              gimp_object_get_name (GIMP_OBJECT (editor->data)));
 
600
          g_free (new_name);
 
601
        }
412
602
    }
413
603
}
414
604
 
427
617
                                    GimpDataEditor *editor)
428
618
{
429
619
  gtk_entry_set_text (GTK_ENTRY (editor->name_entry),
430
 
                      gimp_object_get_name (object));
 
620
                      gimp_object_get_name (object));
431
621
}
432
622
 
433
623
static void
450
640
  GimpData *data = editor->data;
451
641
 
452
642
  if (data && data->dirty && data->writable)
453
 
    gimp_data_factory_data_save_single (editor->data_factory, data);
 
643
    {
 
644
      GError *error = NULL;
 
645
 
 
646
      if (! gimp_data_factory_data_save_single (editor->data_factory, data,
 
647
                                                &error))
 
648
        {
 
649
          gimp_message (editor->data_factory->gimp, G_OBJECT (editor),
 
650
                        GIMP_MESSAGE_ERROR,
 
651
                        "%s", error->message);
 
652
          g_clear_error (&error);
 
653
        }
 
654
    }
454
655
}