← Back to branch summary

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

« back to all changes in this revision

Viewing changes to app/widgets/gimpimagedock.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/gimpimagedock.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
 * gimpimagedock.c
5
 
 * Copyright (C) 2001-2004 Michael Natterer <mitch@gimp.org>
 
5
 * Copyright (C) 2001-2005 Michael Natterer <mitch@gimp.org>
6
6
 *
7
7
 * This program is free software; you can redistribute it and/or modify
8
8
 * it under the terms of the GNU General Public License as published by
21
21
 
22
22
#include "config.h"
23
23
 
24
 
#include <string.h>
25
 
 
26
24
#include <gtk/gtk.h>
27
25
 
28
 
#include "libgimpbase/gimpbase.h"
29
 
#include "libgimpwidgets/gimpwidgets.h"
30
 
 
31
26
#include "widgets-types.h"
32
27
 
 
28
#include "config/gimpguiconfig.h"
 
29
 
33
30
#include "core/gimp.h"
 
31
#include "core/gimpcontainer.h"
34
32
#include "core/gimpcontext.h"
35
 
#include "core/gimpimage.h"
36
 
#include "core/gimplist.h"
37
 
#include "core/gimptoolinfo.h"
38
33
 
39
34
#include "gimpdialogfactory.h"
40
35
#include "gimpimagedock.h"
41
 
#include "gimpcontainercombobox.h"
42
 
#include "gimpcontainerview.h"
43
 
#include "gimpdockable.h"
44
 
#include "gimpdockbook.h"
45
 
#include "gimphelp-ids.h"
46
36
#include "gimpmenufactory.h"
47
 
#include "gimpsessioninfo.h"
48
37
#include "gimpuimanager.h"
49
38
 
50
 
#include "gimp-intl.h"
51
 
 
52
 
 
53
 
#define DEFAULT_MINIMAL_WIDTH     250
54
 
#define DEFAULT_MENU_PREVIEW_SIZE GTK_ICON_SIZE_SMALL_TOOLBAR
55
 
 
56
 
 
57
 
static void   gimp_image_dock_class_init          (GimpImageDockClass *klass);
58
 
static void   gimp_image_dock_init                (GimpImageDock      *dock);
59
 
 
60
 
static GObject * gimp_image_dock_constructor   (GType                  type,
61
 
                                                guint                  n_params,
62
 
                                                GObjectConstructParam *params);
63
 
static void   gimp_image_dock_destroy                 (GtkObject      *object);
64
 
 
65
 
static void   gimp_image_dock_style_set               (GtkWidget      *widget,
66
 
                                                       GtkStyle       *prev_style);
67
 
 
68
 
static void   gimp_image_dock_setup                   (GimpDock       *dock,
69
 
                                                       const GimpDock *template);
70
 
static void   gimp_image_dock_set_aux_info            (GimpDock       *dock,
71
 
                                                       GList          *aux_info);
72
 
static GList *gimp_image_dock_get_aux_info            (GimpDock       *dock);
73
 
static void   gimp_image_dock_book_added              (GimpDock       *dock,
74
 
                                                       GimpDockbook   *dockbook);
75
 
static void   gimp_image_dock_book_removed            (GimpDock       *dock,
76
 
                                                       GimpDockbook   *dockbook);
77
 
 
78
 
static void   gimp_image_dock_dockbook_changed        (GimpDockbook   *dockbook,
79
 
                                                       GimpDockable   *dockable,
80
 
                                                       GimpImageDock  *dock);
81
 
static void   gimp_image_dock_update_title            (GimpImageDock  *dock);
82
 
 
83
 
static void   gimp_image_dock_factory_display_changed (GimpContext    *context,
84
 
                                                       GimpObject     *display,
85
 
                                                       GimpDock       *dock);
86
 
static void   gimp_image_dock_factory_image_changed   (GimpContext    *context,
87
 
                                                       GimpImage      *gimage,
88
 
                                                       GimpDock       *dock);
89
 
static void   gimp_image_dock_display_changed         (GimpContext    *context,
90
 
                                                       GimpObject     *display,
91
 
                                                       GimpDock       *dock);
92
 
static void   gimp_image_dock_image_changed           (GimpContext    *context,
93
 
                                                       GimpImage      *gimage,
94
 
                                                       GimpDock       *dock);
95
 
static void   gimp_image_dock_auto_clicked            (GtkWidget      *widget,
96
 
                                                       GimpDock       *dock);
97
 
static void   gimp_image_dock_image_flush             (GimpImage      *gimage,
98
 
                                                       GimpDock       *dock);
99
 
 
100
 
 
101
 
static GimpDockClass *parent_class = NULL;
102
 
 
103
 
 
104
 
GType
105
 
gimp_image_dock_get_type (void)
106
 
{
107
 
  static GType dock_type = 0;
108
 
 
109
 
  if (! dock_type)
110
 
    {
111
 
      static const GTypeInfo dock_info =
112
 
      {
113
 
        sizeof (GimpImageDockClass),
114
 
        NULL,           /* base_init */
115
 
        NULL,           /* base_finalize */
116
 
        (GClassInitFunc) gimp_image_dock_class_init,
117
 
        NULL,           /* class_finalize */
118
 
        NULL,           /* class_data */
119
 
        sizeof (GimpImageDock),
120
 
        0,              /* n_preallocs */
121
 
        (GInstanceInitFunc) gimp_image_dock_init,
122
 
      };
123
 
 
124
 
      dock_type = g_type_register_static (GIMP_TYPE_DOCK,
125
 
                                          "GimpImageDock",
126
 
                                          &dock_info, 0);
127
 
    }
128
 
 
129
 
  return dock_type;
130
 
}
 
39
 
 
40
static GObject * gimp_image_dock_constructor  (GType                  type,
 
41
                                               guint                  n_params,
 
42
                                               GObjectConstructParam *params);
 
43
 
 
44
static void      gimp_image_dock_destroy      (GtkObject             *object);
 
45
 
 
46
static void      gimp_image_dock_display_changed  (GimpContext       *context,
 
47
                                                   GimpObject        *display,
 
48
                                                   GimpImageDock     *dock);
 
49
static void      gimp_image_dock_image_flush      (GimpImage         *image,
 
50
                                                   GimpImageDock     *dock);
 
51
 
 
52
static void      gimp_image_dock_notify_transient (GimpConfig        *config,
 
53
                                                   GParamSpec        *pspec,
 
54
                                                   GimpDock          *dock);
 
55
 
 
56
 
 
57
G_DEFINE_TYPE (GimpImageDock, gimp_image_dock, GIMP_TYPE_DOCK)
 
58
 
 
59
#define parent_class gimp_image_dock_parent_class
 
60
 
131
61
 
132
62
static void
133
63
gimp_image_dock_class_init (GimpImageDockClass *klass)
134
64
{
135
 
  GObjectClass   *object_class;
136
 
  GtkObjectClass *gtk_object_class;
137
 
  GtkWidgetClass *widget_class;
138
 
  GimpDockClass  *dock_class;
139
 
 
140
 
  object_class     = G_OBJECT_CLASS (klass);
141
 
  gtk_object_class = GTK_OBJECT_CLASS (klass);
142
 
  widget_class     = GTK_WIDGET_CLASS (klass);
143
 
  dock_class       = GIMP_DOCK_CLASS (klass);
144
 
 
145
 
  parent_class = g_type_class_peek_parent (klass);
 
65
  GObjectClass   *object_class     = G_OBJECT_CLASS (klass);
 
66
  GtkObjectClass *gtk_object_class = GTK_OBJECT_CLASS (klass);
146
67
 
147
68
  object_class->constructor = gimp_image_dock_constructor;
148
69
 
149
70
  gtk_object_class->destroy = gimp_image_dock_destroy;
150
71
 
151
 
  widget_class->style_set   = gimp_image_dock_style_set;
152
 
 
153
 
  dock_class->setup         = gimp_image_dock_setup;
154
 
  dock_class->set_aux_info  = gimp_image_dock_set_aux_info;
155
 
  dock_class->get_aux_info  = gimp_image_dock_get_aux_info;
156
 
  dock_class->book_added    = gimp_image_dock_book_added;
157
 
  dock_class->book_removed  = gimp_image_dock_book_removed;
158
 
 
159
 
  gtk_widget_class_install_style_property (widget_class,
160
 
                                           g_param_spec_int ("minimal_width",
161
 
                                                             NULL, NULL,
162
 
                                                             0,
163
 
                                                             G_MAXINT,
164
 
                                                             DEFAULT_MINIMAL_WIDTH,
165
 
                                                             G_PARAM_READABLE));
166
 
  gtk_widget_class_install_style_property (widget_class,
167
 
                                           g_param_spec_enum ("menu_preview_size",
168
 
                                                              NULL, NULL,
169
 
                                                              GTK_TYPE_ICON_SIZE,
170
 
                                                              DEFAULT_MENU_PREVIEW_SIZE,
171
 
                                                              G_PARAM_READABLE));
 
72
  klass->ui_manager_name    = "<Dock>";
172
73
}
173
74
 
174
75
static void
175
76
gimp_image_dock_init (GimpImageDock *dock)
176
77
{
177
 
  GtkWidget *hbox;
178
 
 
179
 
  dock->image_container      = NULL;
180
 
  dock->display_container    = NULL;
181
 
  dock->show_image_menu      = FALSE;
182
 
  dock->auto_follow_active   = TRUE;
183
 
  dock->update_title_idle_id = 0;
184
 
 
185
 
  hbox = gtk_hbox_new (FALSE, 2);
186
 
  gtk_box_pack_start (GTK_BOX (GIMP_DOCK (dock)->main_vbox), hbox,
187
 
                      FALSE, FALSE, 0);
188
 
  gtk_box_reorder_child (GTK_BOX (GIMP_DOCK (dock)->main_vbox), hbox, 0);
189
 
 
190
 
  if (dock->show_image_menu)
191
 
    gtk_widget_show (hbox);
192
 
 
193
 
  dock->image_combo = gimp_container_combo_box_new (NULL, NULL, 16, 1);
194
 
  gtk_box_pack_start (GTK_BOX (hbox), dock->image_combo, TRUE, TRUE, 0);
195
 
  gtk_widget_show (dock->image_combo);
196
 
 
197
 
  g_signal_connect (dock->image_combo, "destroy",
198
 
                    G_CALLBACK (gtk_widget_destroyed),
199
 
                    &dock->image_combo);
200
 
 
201
 
  gimp_help_set_help_data (dock->image_combo, NULL, GIMP_HELP_DOCK_IMAGE_MENU);
202
 
 
203
 
  dock->auto_button = gtk_toggle_button_new_with_label (_("Auto"));
204
 
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dock->auto_button),
205
 
                                dock->auto_follow_active);
206
 
  gtk_box_pack_start (GTK_BOX (hbox), dock->auto_button, FALSE, FALSE, 0);
207
 
  gtk_widget_show (dock->auto_button);
208
 
 
209
 
  g_signal_connect (dock->auto_button, "clicked",
210
 
                    G_CALLBACK (gimp_image_dock_auto_clicked),
211
 
                    dock);
212
 
 
213
 
  gimp_help_set_help_data (dock->auto_button,
214
 
                           _("When enabled the dialog automatically "
215
 
                             "follows the image you are working on."),
216
 
                           GIMP_HELP_DOCK_AUTO_BUTTON);
 
78
  dock->ui_manager             = NULL;
 
79
  dock->image_flush_handler_id = 0;
217
80
}
218
81
 
219
82
static GObject *
221
84
                             guint                  n_params,
222
85
                             GObjectConstructParam *params)
223
86
{
224
 
  GObject         *object;
225
 
  GimpImageDock   *dock;
226
 
  GimpMenuFactory *menu_factory;
227
 
  GtkUIManager    *ui_manager;
228
 
  GtkAccelGroup   *accel_group;
 
87
  GObject       *object;
 
88
  GimpImageDock *dock;
 
89
  GimpGuiConfig *config;
 
90
  GtkAccelGroup *accel_group;
229
91
 
230
92
  object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
231
93
 
232
94
  dock = GIMP_IMAGE_DOCK (object);
233
95
 
234
 
  menu_factory = GIMP_DOCK (object)->dialog_factory->menu_factory;
235
 
 
236
 
  dock->ui_manager = gimp_menu_factory_manager_new (menu_factory, "<Dock>",
237
 
                                                    dock, FALSE);
238
 
 
239
 
  ui_manager = GTK_UI_MANAGER (dock->ui_manager);
240
 
 
241
 
  accel_group = gtk_ui_manager_get_accel_group (ui_manager);
 
96
  config = GIMP_GUI_CONFIG (GIMP_DOCK (dock)->context->gimp->config);
 
97
 
 
98
  dock->ui_manager =
 
99
    gimp_menu_factory_manager_new (GIMP_DOCK (dock)->dialog_factory->menu_factory,
 
100
                                   GIMP_IMAGE_DOCK_GET_CLASS (dock)->ui_manager_name,
 
101
                                   dock,
 
102
                                   config->tearoff_menus);
 
103
 
 
104
  accel_group =
 
105
    gtk_ui_manager_get_accel_group (GTK_UI_MANAGER (dock->ui_manager));
242
106
 
243
107
  gtk_window_add_accel_group (GTK_WINDOW (object), accel_group);
244
108
 
 
109
  dock->image_flush_handler_id =
 
110
    gimp_container_add_handler (GIMP_DOCK (dock)->context->gimp->images, "flush",
 
111
                                G_CALLBACK (gimp_image_dock_image_flush),
 
112
                                dock);
 
113
 
 
114
  g_signal_connect_object (GIMP_DOCK (dock)->context, "display-changed",
 
115
                           G_CALLBACK (gimp_image_dock_display_changed),
 
116
                           dock, 0);
 
117
 
 
118
  g_signal_connect_object (GIMP_DOCK (dock)->context->gimp->config,
 
119
                           "notify::transient-docks",
 
120
                           G_CALLBACK (gimp_image_dock_notify_transient),
 
121
                           dock, 0);
 
122
 
245
123
  return object;
246
124
}
247
125
 
250
128
{
251
129
  GimpImageDock *dock = GIMP_IMAGE_DOCK (object);
252
130
 
253
 
  if (dock->update_title_idle_id)
254
 
    {
255
 
      g_source_remove (dock->update_title_idle_id);
256
 
      dock->update_title_idle_id = 0;
257
 
    }
258
 
 
259
131
  if (dock->image_flush_handler_id)
260
132
    {
261
 
      gimp_container_remove_handler (dock->image_container,
 
133
      gimp_container_remove_handler (GIMP_DOCK (dock)->context->gimp->images,
262
134
                                     dock->image_flush_handler_id);
263
135
      dock->image_flush_handler_id = 0;
264
136
    }
269
141
      dock->ui_manager = NULL;
270
142
    }
271
143
 
272
 
  /*  remove the image menu and the auto button manually here because
273
 
   *  of weird cross-connections with GimpDock's context
274
 
   */
275
 
  if (GIMP_DOCK (dock)->main_vbox &&
276
 
      dock->image_combo           &&
277
 
      dock->image_combo->parent)
278
 
    {
279
 
      gtk_container_remove (GTK_CONTAINER (GIMP_DOCK (dock)->main_vbox),
280
 
                            dock->image_combo->parent);
281
 
    }
282
 
 
283
144
  GTK_OBJECT_CLASS (parent_class)->destroy (object);
284
145
}
285
146
 
286
147
static void
287
 
gimp_image_dock_style_set (GtkWidget *widget,
288
 
                           GtkStyle  *prev_style)
289
 
{
290
 
  GimpImageDock *image_dock;
291
 
  gint           minimal_width;
292
 
  GtkIconSize    menu_preview_size;
293
 
  GdkScreen     *screen;
294
 
  gint           menu_preview_width  = 18;
295
 
  gint           menu_preview_height = 18;
296
 
  gint           focus_line_width;
297
 
  gint           focus_padding;
298
 
  gint           ythickness;
299
 
 
300
 
  image_dock = GIMP_IMAGE_DOCK (widget);
301
 
 
302
 
  if (GTK_WIDGET_CLASS (parent_class)->style_set)
303
 
    GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);
304
 
 
305
 
  gtk_widget_style_get (widget,
306
 
                        "minimal_width",     &minimal_width,
307
 
                        "menu_preview_size", &menu_preview_size,
308
 
                        NULL);
309
 
 
310
 
  screen = gtk_widget_get_screen (image_dock->image_combo);
311
 
  gtk_icon_size_lookup_for_settings (gtk_settings_get_for_screen (screen),
312
 
                                     menu_preview_size,
313
 
                                     &menu_preview_width,
314
 
                                     &menu_preview_height);
315
 
 
316
 
  gtk_widget_style_get (image_dock->auto_button,
317
 
                        "focus_line_width", &focus_line_width,
318
 
                        "focus_padding",    &focus_padding,
319
 
                        NULL);
320
 
 
321
 
  ythickness = image_dock->auto_button->style->ythickness;
322
 
 
323
 
  gtk_widget_set_size_request (widget, minimal_width, -1);
324
 
 
325
 
  gimp_container_view_set_preview_size (GIMP_CONTAINER_VIEW (image_dock->image_combo),
326
 
                                        menu_preview_height, 1);
327
 
 
328
 
  gtk_widget_set_size_request (image_dock->auto_button, -1,
329
 
                               menu_preview_height +
330
 
                               2 * (1 /* CHILD_SPACING */ +
331
 
                                    ythickness            +
332
 
                                    focus_padding         +
333
 
                                    focus_line_width));
334
 
}
335
 
 
336
 
static void
337
 
gimp_image_dock_setup (GimpDock       *dock,
338
 
                       const GimpDock *template)
339
 
{
340
 
  if (GIMP_IS_IMAGE_DOCK (template))
341
 
    {
342
 
      gboolean auto_follow_active;
343
 
      gboolean show_image_menu;
344
 
 
345
 
      auto_follow_active = GIMP_IMAGE_DOCK (template)->auto_follow_active;
346
 
      show_image_menu    = GIMP_IMAGE_DOCK (template)->show_image_menu;
347
 
 
348
 
      gimp_image_dock_set_auto_follow_active (GIMP_IMAGE_DOCK (dock),
349
 
                                              auto_follow_active);
350
 
      gimp_image_dock_set_show_image_menu (GIMP_IMAGE_DOCK (dock),
351
 
                                           show_image_menu);
352
 
    }
353
 
}
354
 
 
355
 
#define AUX_INFO_SHOW_IMAGE_MENU     "show-image-menu"
356
 
#define AUX_INFO_FOLLOW_ACTIVE_IMAGE "follow-active-image"
357
 
 
358
 
static void
359
 
gimp_image_dock_set_aux_info (GimpDock *dock,
360
 
                              GList    *aux_info)
361
 
{
362
 
  GimpImageDock *image_dock  = GIMP_IMAGE_DOCK (dock);
363
 
  GList         *list;
364
 
  gboolean       menu_shown  = image_dock->show_image_menu;
365
 
  gboolean       auto_follow = image_dock->auto_follow_active;
366
 
 
367
 
  for (list = aux_info; list; list = g_list_next (list))
368
 
    {
369
 
      GimpSessionInfoAux *aux = list->data;
370
 
 
371
 
      if (! strcmp (aux->name, AUX_INFO_SHOW_IMAGE_MENU))
372
 
        {
373
 
          menu_shown = ! g_ascii_strcasecmp (aux->value, "true");
374
 
        }
375
 
      else if (! strcmp (aux->name, AUX_INFO_FOLLOW_ACTIVE_IMAGE))
376
 
        {
377
 
          auto_follow = ! g_ascii_strcasecmp (aux->value, "true");
378
 
        }
379
 
    }
380
 
 
381
 
  if (menu_shown != image_dock->show_image_menu)
382
 
    gimp_image_dock_set_show_image_menu (image_dock, menu_shown);
383
 
 
384
 
  if (auto_follow != image_dock->auto_follow_active)
385
 
    gimp_image_dock_set_auto_follow_active (image_dock, auto_follow);
386
 
}
387
 
 
388
 
static GList *
389
 
gimp_image_dock_get_aux_info (GimpDock *dock)
390
 
{
391
 
  GimpImageDock      *image_dock = GIMP_IMAGE_DOCK (dock);
392
 
  GList              *aux_info   = NULL;
393
 
  GimpSessionInfoAux *aux;
394
 
 
395
 
  aux = gimp_session_info_aux_new (AUX_INFO_SHOW_IMAGE_MENU,
396
 
                                   image_dock->show_image_menu ?
397
 
                                   "true" : "false");
398
 
  aux_info = g_list_append (aux_info, aux);
399
 
 
400
 
  aux = gimp_session_info_aux_new (AUX_INFO_FOLLOW_ACTIVE_IMAGE,
401
 
                                   image_dock->auto_follow_active ?
402
 
                                   "true" : "false");
403
 
  aux_info = g_list_append (aux_info, aux);
404
 
 
405
 
  return aux_info;
406
 
}
407
 
 
408
 
static void
409
 
gimp_image_dock_book_added (GimpDock     *dock,
410
 
                            GimpDockbook *dockbook)
411
 
{
412
 
  g_signal_connect (dockbook, "dockable_added",
413
 
                    G_CALLBACK (gimp_image_dock_dockbook_changed),
414
 
                    dock);
415
 
  g_signal_connect (dockbook, "dockable_removed",
416
 
                    G_CALLBACK (gimp_image_dock_dockbook_changed),
417
 
                    dock);
418
 
  g_signal_connect (dockbook, "dockable_reordered",
419
 
                    G_CALLBACK (gimp_image_dock_dockbook_changed),
420
 
                    dock);
421
 
 
422
 
  gimp_image_dock_update_title (GIMP_IMAGE_DOCK (dock));
423
 
 
424
 
  GIMP_DOCK_CLASS (parent_class)->book_added (dock, dockbook);
425
 
}
426
 
 
427
 
static void
428
 
gimp_image_dock_book_removed (GimpDock     *dock,
429
 
                              GimpDockbook *dockbook)
430
 
{
431
 
  g_signal_handlers_disconnect_by_func (dockbook,
432
 
                                        gimp_image_dock_dockbook_changed,
433
 
                                        dock);
434
 
 
435
 
  gimp_image_dock_update_title (GIMP_IMAGE_DOCK (dock));
436
 
 
437
 
  GIMP_DOCK_CLASS (parent_class)->book_removed (dock, dockbook);
438
 
}
439
 
 
440
 
GtkWidget *
441
 
gimp_image_dock_new (GimpDialogFactory *dialog_factory,
442
 
                     GimpContainer     *image_container,
443
 
                     GimpContainer     *display_container)
444
 
{
445
 
  GimpImageDock *image_dock;
446
 
  GimpContext   *context;
447
 
  GdkScreen     *screen;
448
 
  gint           menu_preview_width;
449
 
  gint           menu_preview_height;
450
 
 
451
 
  g_return_val_if_fail (GIMP_IS_DIALOG_FACTORY (dialog_factory), NULL);
452
 
  g_return_val_if_fail (GIMP_IS_CONTAINER (image_container), NULL);
453
 
  g_return_val_if_fail (GIMP_IS_CONTAINER (display_container), NULL);
454
 
 
455
 
  context = gimp_context_new (dialog_factory->context->gimp,
456
 
                              "Dock Context", NULL);
457
 
 
458
 
  image_dock = g_object_new (GIMP_TYPE_IMAGE_DOCK,
459
 
                             "context",        context,
460
 
                             "dialog-factory", dialog_factory,
461
 
                             NULL);
462
 
 
463
 
  image_dock->image_container   = image_container;
464
 
  image_dock->display_container = display_container;
465
 
 
466
 
  image_dock->image_flush_handler_id =
467
 
    gimp_container_add_handler (image_container, "flush",
468
 
                                G_CALLBACK (gimp_image_dock_image_flush),
469
 
                                image_dock);
470
 
 
471
 
  gimp_help_connect (GTK_WIDGET (image_dock), gimp_standard_help_func,
472
 
                     GIMP_HELP_DOCK, NULL);
473
 
 
474
 
  gimp_context_define_properties (context,
475
 
                                  GIMP_CONTEXT_ALL_PROPS_MASK &
476
 
                                  ~(GIMP_CONTEXT_IMAGE_MASK |
477
 
                                    GIMP_CONTEXT_DISPLAY_MASK),
478
 
                                  FALSE);
479
 
  gimp_context_set_parent (context, dialog_factory->context);
480
 
 
481
 
  if (image_dock->auto_follow_active)
482
 
    {
483
 
      if (gimp_context_get_display (dialog_factory->context))
484
 
        gimp_context_copy_property (dialog_factory->context, context,
485
 
                                    GIMP_CONTEXT_PROP_DISPLAY);
486
 
      else
487
 
        gimp_context_copy_property (dialog_factory->context, context,
488
 
                                    GIMP_CONTEXT_PROP_IMAGE);
489
 
    }
490
 
 
491
 
  g_signal_connect_object (dialog_factory->context, "display_changed",
492
 
                           G_CALLBACK (gimp_image_dock_factory_display_changed),
493
 
                           image_dock,
494
 
                           0);
495
 
  g_signal_connect_object (dialog_factory->context, "image_changed",
496
 
                           G_CALLBACK (gimp_image_dock_factory_image_changed),
497
 
                           image_dock,
498
 
                           0);
499
 
 
500
 
  g_signal_connect_object (context, "display_changed",
501
 
                           G_CALLBACK (gimp_image_dock_display_changed),
502
 
                           image_dock,
503
 
                           0);
504
 
  g_signal_connect_object (context, "image_changed",
505
 
                           G_CALLBACK (gimp_image_dock_image_changed),
506
 
                           image_dock,
507
 
                           0);
508
 
 
509
 
  screen = gtk_widget_get_screen (GTK_WIDGET (image_dock));
510
 
  gtk_icon_size_lookup_for_settings (gtk_settings_get_for_screen (screen),
511
 
                                     DEFAULT_MENU_PREVIEW_SIZE,
512
 
                                     &menu_preview_width,
513
 
                                     &menu_preview_height);
514
 
 
515
 
  g_object_set (image_dock->image_combo,
516
 
                "container", image_container,
517
 
                "context",   context,
518
 
                NULL);
519
 
 
520
 
  return GTK_WIDGET (image_dock);
521
 
}
522
 
 
523
 
void
524
 
gimp_image_dock_set_auto_follow_active (GimpImageDock *image_dock,
525
 
                                        gboolean       auto_follow_active)
526
 
{
527
 
  g_return_if_fail (GIMP_IS_IMAGE_DOCK (image_dock));
528
 
 
529
 
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (image_dock->auto_button),
530
 
                                auto_follow_active ? TRUE : FALSE);
531
 
}
532
 
 
533
 
void
534
 
gimp_image_dock_set_show_image_menu (GimpImageDock *image_dock,
535
 
                                     gboolean       show)
536
 
{
537
 
  g_return_if_fail (GIMP_IS_IMAGE_DOCK (image_dock));
538
 
 
539
 
  if (show)
540
 
    gtk_widget_show (image_dock->image_combo->parent);
 
148
gimp_image_dock_display_changed (GimpContext   *context,
 
149
                                 GimpObject    *display,
 
150
                                 GimpImageDock *dock)
 
151
{
 
152
  gimp_ui_manager_update (dock->ui_manager, display);
 
153
 
 
154
  if (GIMP_GUI_CONFIG (context->gimp->config)->transient_docks)
 
155
    {
 
156
      GtkWindow *parent = NULL;
 
157
 
 
158
      if (display)
 
159
        g_object_get (display, "shell", &parent, NULL);
 
160
 
 
161
      gtk_window_set_transient_for (GTK_WINDOW (dock), parent);
 
162
 
 
163
      if (parent)
 
164
        g_object_unref (parent);
 
165
    }
 
166
}
 
167
 
 
168
static void
 
169
gimp_image_dock_image_flush (GimpImage     *image,
 
170
                             GimpImageDock *dock)
 
171
{
 
172
  if (image == gimp_context_get_image (GIMP_DOCK (dock)->context))
 
173
    {
 
174
      GimpObject *display = gimp_context_get_display (GIMP_DOCK (dock)->context);
 
175
 
 
176
      if (display)
 
177
        gimp_ui_manager_update (dock->ui_manager, display);
 
178
    }
 
179
}
 
180
 
 
181
static void
 
182
gimp_image_dock_notify_transient (GimpConfig *config,
 
183
                                  GParamSpec *pspec,
 
184
                                  GimpDock   *dock)
 
185
{
 
186
  if (GIMP_GUI_CONFIG (config)->transient_docks)
 
187
    {
 
188
      gimp_image_dock_display_changed (dock->context,
 
189
                                       gimp_context_get_display (dock->context),
 
190
                                       GIMP_IMAGE_DOCK (dock));
 
191
    }
541
192
  else
542
 
    gtk_widget_hide (image_dock->image_combo->parent);
543
 
 
544
 
  image_dock->show_image_menu = show ? TRUE : FALSE;
545
 
}
546
 
 
547
 
static void
548
 
gimp_image_dock_dockbook_changed (GimpDockbook  *dockbook,
549
 
                                  GimpDockable  *dockable,
550
 
                                  GimpImageDock *dock)
551
 
{
552
 
  gimp_image_dock_update_title (dock);
553
 
}
554
 
 
555
 
static gboolean
556
 
gimp_image_dock_update_title_idle (GimpImageDock *image_dock)
557
 
{
558
 
  GString *title;
559
 
  GList   *list;
560
 
 
561
 
  title = g_string_new (NULL);
562
 
 
563
 
  for (list = GIMP_DOCK (image_dock)->dockbooks;
564
 
       list;
565
 
       list = g_list_next (list))
566
 
    {
567
 
      GimpDockbook *dockbook = list->data;
568
 
      GList        *children;
569
 
      GList        *child;
570
 
 
571
 
      children = gtk_container_get_children (GTK_CONTAINER (dockbook));
572
 
 
573
 
      for (child = children; child; child = g_list_next (child))
574
 
        {
575
 
          GimpDockable *dockable = child->data;
576
 
 
577
 
          g_string_append (title, dockable->name);
578
 
 
579
 
          if (g_list_next (child))
580
 
            g_string_append (title, ", ");
581
 
        }
582
 
 
583
 
      g_list_free (children);
584
 
 
585
 
      if (g_list_next (list))
586
 
        g_string_append (title, " | ");
587
 
    }
588
 
 
589
 
  gtk_window_set_title (GTK_WINDOW (image_dock), title->str);
590
 
 
591
 
  g_string_free (title, TRUE);
592
 
 
593
 
  image_dock->update_title_idle_id = 0;
594
 
 
595
 
  return FALSE;
596
 
}
597
 
 
598
 
static void
599
 
gimp_image_dock_update_title (GimpImageDock *image_dock)
600
 
{
601
 
  if (image_dock->update_title_idle_id)
602
 
    g_source_remove (image_dock->update_title_idle_id);
603
 
 
604
 
  image_dock->update_title_idle_id =
605
 
    g_idle_add ((GSourceFunc) gimp_image_dock_update_title_idle,
606
 
                image_dock);
607
 
}
608
 
 
609
 
static void
610
 
gimp_image_dock_factory_display_changed (GimpContext *context,
611
 
                                         GimpObject  *display,
612
 
                                         GimpDock    *dock)
613
 
{
614
 
  GimpImageDock *image_dock = GIMP_IMAGE_DOCK (dock);
615
 
 
616
 
  if (display && image_dock->auto_follow_active)
617
 
    gimp_context_set_display (dock->context, display);
618
 
}
619
 
 
620
 
static void
621
 
gimp_image_dock_factory_image_changed (GimpContext *context,
622
 
                                       GimpImage   *gimage,
623
 
                                       GimpDock    *dock)
624
 
{
625
 
  GimpImageDock *image_dock = GIMP_IMAGE_DOCK (dock);
626
 
 
627
 
  /*  won't do anything if we already set the display above  */
628
 
  if (gimage && image_dock->auto_follow_active)
629
 
    gimp_context_set_image (dock->context, gimage);
630
 
}
631
 
 
632
 
static void
633
 
gimp_image_dock_display_changed (GimpContext *context,
634
 
                                 GimpObject  *display,
635
 
                                 GimpDock    *dock)
636
 
{
637
 
  GimpImageDock *image_dock = GIMP_IMAGE_DOCK (dock);
638
 
 
639
 
  gimp_ui_manager_update (image_dock->ui_manager, display);
640
 
}
641
 
 
642
 
static void
643
 
gimp_image_dock_image_changed (GimpContext *context,
644
 
                               GimpImage   *gimage,
645
 
                               GimpDock    *dock)
646
 
{
647
 
  GimpImageDock *image_dock = GIMP_IMAGE_DOCK (dock);
648
 
 
649
 
  if (gimage == NULL &&
650
 
      gimp_container_num_children (image_dock->image_container) > 0)
651
 
    {
652
 
      gimage = GIMP_IMAGE (gimp_container_get_child_by_index (image_dock->image_container, 0));
653
 
 
654
 
      if (gimage)
655
 
        {
656
 
          /*  this invokes this function recursively but we don't enter
657
 
           *  the if() branch the second time
658
 
           */
659
 
          gimp_context_set_image (context, gimage);
660
 
 
661
 
          /*  stop the emission of the original signal (the emission of
662
 
           *  the recursive signal is finished)
663
 
           */
664
 
          g_signal_stop_emission_by_name (context, "image_changed");
665
 
        }
666
 
    }
667
 
  else if (gimage != NULL &&
668
 
           gimp_container_num_children (image_dock->display_container) > 0)
669
 
    {
670
 
      GimpObject *gdisp;
671
 
      GimpImage  *gdisp_gimage;
672
 
      gboolean    find_display = TRUE;
673
 
 
674
 
      gdisp = gimp_context_get_display (context);
675
 
 
676
 
      if (gdisp)
677
 
        {
678
 
          g_object_get (gdisp, "image", &gdisp_gimage, NULL);
679
 
 
680
 
          if (gdisp_gimage)
681
 
            {
682
 
              g_object_unref (gdisp_gimage);
683
 
 
684
 
              if (gdisp_gimage == gimage)
685
 
                find_display = FALSE;
686
 
            }
687
 
        }
688
 
 
689
 
      if (find_display)
690
 
        {
691
 
          GList *list;
692
 
 
693
 
          for (list = GIMP_LIST (image_dock->display_container)->list;
694
 
               list;
695
 
               list = g_list_next (list))
696
 
            {
697
 
              gdisp = GIMP_OBJECT (list->data);
698
 
 
699
 
              g_object_get (gdisp, "image", &gdisp_gimage, NULL);
700
 
 
701
 
              if (gdisp_gimage)
702
 
                {
703
 
                  g_object_unref (gdisp_gimage);
704
 
 
705
 
                  if (gdisp_gimage == gimage)
706
 
                    {
707
 
                      /*  this invokes this function recursively but we
708
 
                       *  don't enter the if(find_display) branch the
709
 
                       *  second time
710
 
                       */
711
 
                      gimp_context_set_display (context, gdisp);
712
 
 
713
 
                      /*  don't stop signal emission here because the
714
 
                       *  context's image was not changed by the
715
 
                       *  recursive call
716
 
                       */
717
 
                      break;
718
 
                    }
719
 
                }
720
 
            }
721
 
        }
722
 
    }
723
 
}
724
 
 
725
 
static void
726
 
gimp_image_dock_auto_clicked (GtkWidget *widget,
727
 
                              GimpDock  *dock)
728
 
{
729
 
  GimpImageDock *image_dock = GIMP_IMAGE_DOCK (dock);
730
 
 
731
 
  gimp_toggle_button_update (widget, &image_dock->auto_follow_active);
732
 
 
733
 
  if (image_dock->auto_follow_active)
734
 
    {
735
 
      if (gimp_context_get_display (dock->dialog_factory->context))
736
 
        gimp_context_copy_property (dock->dialog_factory->context,
737
 
                                    dock->context,
738
 
                                    GIMP_CONTEXT_PROP_DISPLAY);
739
 
      else
740
 
        gimp_context_copy_property (dock->dialog_factory->context,
741
 
                                    dock->context,
742
 
                                    GIMP_CONTEXT_PROP_IMAGE);
743
 
    }
744
 
}
745
 
 
746
 
static void
747
 
gimp_image_dock_image_flush (GimpImage *gimage,
748
 
                             GimpDock  *dock)
749
 
{
750
 
  GimpImageDock *image_dock = GIMP_IMAGE_DOCK (dock);
751
 
  GimpImage     *dock_image;
752
 
 
753
 
  dock_image = gimp_context_get_image (dock->context);
754
 
 
755
 
  if (dock_image == gimage)
756
 
    {
757
 
      GimpObject *display = gimp_context_get_display (dock->context);
758
 
 
759
 
      if (display)
760
 
        gimp_ui_manager_update (image_dock->ui_manager, display);
 
193
    {
 
194
      gtk_window_set_transient_for (GTK_WINDOW (dock), NULL);
761
195
    }
762
196
}