← Back to branch summary

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

« back to all changes in this revision

Viewing changes to app/widgets/gimpitemtreeview.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/gimpitemtreeview.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
 * gimpitemtreeview.c
62
62
};
63
63
 
64
64
 
65
 
static void   gimp_item_tree_view_class_init   (GimpItemTreeViewClass *klass);
66
 
static void   gimp_item_tree_view_init         (GimpItemTreeView      *view,
67
 
                                                GimpItemTreeViewClass *view_class);
68
 
 
69
65
static void   gimp_item_tree_view_view_iface_init   (GimpContainerViewInterface *view_iface);
70
66
static void   gimp_item_tree_view_docked_iface_init (GimpDockedInterface *docked_iface);
71
67
 
72
 
static void  gimp_item_tree_view_set_context        (GimpDocked        *docked,
73
 
                                                     GimpContext       *context);
74
 
 
75
68
static GObject * gimp_item_tree_view_constructor    (GType              type,
76
69
                                                     guint              n_params,
77
70
                                                     GObjectConstructParam *params);
79
72
static void   gimp_item_tree_view_destroy           (GtkObject         *object);
80
73
 
81
74
static void   gimp_item_tree_view_real_set_image    (GimpItemTreeView  *view,
82
 
                                                     GimpImage         *gimage);
 
75
                                                     GimpImage         *image);
83
76
 
84
 
static void   gimp_item_tree_view_image_flush       (GimpImage         *gimage,
 
77
static void   gimp_item_tree_view_image_flush       (GimpImage         *image,
85
78
                                                     GimpItemTreeView  *view);
86
79
 
87
80
static void   gimp_item_tree_view_set_container     (GimpContainerView *view,
88
81
                                                     GimpContainer     *container);
 
82
static void   gimp_item_tree_view_set_context       (GimpContainerView *view,
 
83
                                                     GimpContext       *context);
 
84
 
89
85
static gpointer gimp_item_tree_view_insert_item     (GimpContainerView *view,
90
86
                                                     GimpViewable      *viewable,
91
87
                                                     gint               index);
112
108
                                                     GtkTreeViewDropPosition  drop_pos);
113
109
 
114
110
static void   gimp_item_tree_view_new_dropped       (GtkWidget         *widget,
 
111
                                                     gint               x,
 
112
                                                     gint               y,
115
113
                                                     GimpViewable      *viewable,
116
114
                                                     gpointer           data);
117
115
 
118
 
static void   gimp_item_tree_view_item_changed      (GimpImage         *gimage,
 
116
static void   gimp_item_tree_view_item_changed      (GimpImage         *image,
119
117
                                                     GimpItemTreeView  *view);
120
 
static void   gimp_item_tree_view_size_changed      (GimpImage         *gimage,
 
118
static void   gimp_item_tree_view_size_changed      (GimpImage         *image,
121
119
                                                     GimpItemTreeView  *view);
122
120
 
123
121
static void   gimp_item_tree_view_name_edited       (GtkCellRendererText *cell,
147
145
                                                     GimpUndoType       undo_type);
148
146
 
149
147
 
150
 
static guint  view_signals[LAST_SIGNAL] = { 0 };
151
 
 
152
 
static GimpContainerTreeViewClass *parent_class      = NULL;
 
148
G_DEFINE_TYPE_WITH_CODE (GimpItemTreeView, gimp_item_tree_view,
 
149
                         GIMP_TYPE_CONTAINER_TREE_VIEW,
 
150
                         G_IMPLEMENT_INTERFACE (GIMP_TYPE_CONTAINER_VIEW,
 
151
                                                gimp_item_tree_view_view_iface_init)
 
152
                         G_IMPLEMENT_INTERFACE (GIMP_TYPE_DOCKED,
 
153
                                                gimp_item_tree_view_docked_iface_init))
 
154
 
 
155
#define parent_class gimp_item_tree_view_parent_class
 
156
 
153
157
static GimpContainerViewInterface *parent_view_iface = NULL;
154
158
 
155
 
 
156
 
GType
157
 
gimp_item_tree_view_get_type (void)
158
 
{
159
 
  static GType type = 0;
160
 
 
161
 
  if (! type)
162
 
    {
163
 
      static const GTypeInfo view_info =
164
 
      {
165
 
        sizeof (GimpItemTreeViewClass),
166
 
        NULL,           /* base_init */
167
 
        NULL,           /* base_finalize */
168
 
        (GClassInitFunc) gimp_item_tree_view_class_init,
169
 
        NULL,           /* class_finalize */
170
 
        NULL,           /* class_data */
171
 
        sizeof (GimpItemTreeView),
172
 
        0,              /* n_preallocs */
173
 
        (GInstanceInitFunc) gimp_item_tree_view_init,
174
 
      };
175
 
 
176
 
      static const GInterfaceInfo view_iface_info =
177
 
      {
178
 
        (GInterfaceInitFunc) gimp_item_tree_view_view_iface_init,
179
 
        NULL,           /* iface_finalize */
180
 
        NULL            /* iface_data     */
181
 
      };
182
 
      static const GInterfaceInfo docked_iface_info =
183
 
      {
184
 
        (GInterfaceInitFunc) gimp_item_tree_view_docked_iface_init,
185
 
        NULL,           /* iface_finalize */
186
 
        NULL            /* iface_data     */
187
 
      };
188
 
 
189
 
      type = g_type_register_static (GIMP_TYPE_CONTAINER_TREE_VIEW,
190
 
                                     "GimpItemTreeView",
191
 
                                     &view_info, G_TYPE_FLAG_ABSTRACT);
192
 
 
193
 
      g_type_add_interface_static (type, GIMP_TYPE_CONTAINER_VIEW,
194
 
                                   &view_iface_info);
195
 
      g_type_add_interface_static (type, GIMP_TYPE_DOCKED,
196
 
                                   &docked_iface_info);
197
 
    }
198
 
 
199
 
  return type;
200
 
}
 
159
static guint view_signals[LAST_SIGNAL] = { 0 };
 
160
 
201
161
 
202
162
static void
203
163
gimp_item_tree_view_class_init (GimpItemTreeViewClass *klass)
206
166
  GtkObjectClass             *gtk_object_class;
207
167
  GimpContainerTreeViewClass *tree_view_class;
208
168
 
209
 
  object_class         = G_OBJECT_CLASS (klass);
210
 
  gtk_object_class     = GTK_OBJECT_CLASS (klass);
211
 
  tree_view_class      = GIMP_CONTAINER_TREE_VIEW_CLASS (klass);
212
 
 
213
 
  parent_class = g_type_class_peek_parent (klass);
 
169
  object_class     = G_OBJECT_CLASS (klass);
 
170
  gtk_object_class = GTK_OBJECT_CLASS (klass);
 
171
  tree_view_class  = GIMP_CONTAINER_TREE_VIEW_CLASS (klass);
214
172
 
215
173
  view_signals[SET_IMAGE] =
216
 
    g_signal_new ("set_image",
217
 
                  G_TYPE_FROM_CLASS (klass),
218
 
                  G_SIGNAL_RUN_LAST,
219
 
                  G_STRUCT_OFFSET (GimpItemTreeViewClass, set_image),
220
 
                  NULL, NULL,
221
 
                  gimp_marshal_VOID__OBJECT,
222
 
                  G_TYPE_NONE, 1,
223
 
                  GIMP_TYPE_OBJECT);
 
174
    g_signal_new ("set-image",
 
175
                  G_TYPE_FROM_CLASS (klass),
 
176
                  G_SIGNAL_RUN_LAST,
 
177
                  G_STRUCT_OFFSET (GimpItemTreeViewClass, set_image),
 
178
                  NULL, NULL,
 
179
                  gimp_marshal_VOID__OBJECT,
 
180
                  G_TYPE_NONE, 1,
 
181
                  GIMP_TYPE_OBJECT);
224
182
 
225
183
  object_class->constructor      = gimp_item_tree_view_constructor;
226
184
 
256
214
}
257
215
 
258
216
static void
259
 
gimp_item_tree_view_init (GimpItemTreeView      *view,
260
 
                          GimpItemTreeViewClass *view_class)
 
217
gimp_item_tree_view_view_iface_init (GimpContainerViewInterface *iface)
 
218
{
 
219
  parent_view_iface = g_type_interface_peek_parent (iface);
 
220
 
 
221
  iface->set_container = gimp_item_tree_view_set_container;
 
222
  iface->set_context   = gimp_item_tree_view_set_context;
 
223
  iface->insert_item   = gimp_item_tree_view_insert_item;
 
224
  iface->select_item   = gimp_item_tree_view_select_item;
 
225
  iface->activate_item = gimp_item_tree_view_activate_item;
 
226
  iface->context_item  = gimp_item_tree_view_context_item;
 
227
}
 
228
 
 
229
static void
 
230
gimp_item_tree_view_docked_iface_init (GimpDockedInterface *iface)
 
231
{
 
232
  iface->get_preview = NULL;
 
233
}
 
234
 
 
235
static void
 
236
gimp_item_tree_view_init (GimpItemTreeView *view)
261
237
{
262
238
  GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (view);
263
239
 
278
254
  tree_view->model_columns[tree_view->n_model_columns] = G_TYPE_BOOLEAN;
279
255
  tree_view->n_model_columns++;
280
256
 
281
 
  view->context = NULL;
282
 
  view->gimage  = NULL;
 
257
  tree_view->dnd_drop_to_empty = TRUE;
 
258
 
 
259
  view->image  = NULL;
283
260
 
284
261
  view->visible_changed_handler_id = 0;
285
262
  view->linked_changed_handler_id  = 0;
286
263
}
287
264
 
288
 
static void
289
 
gimp_item_tree_view_view_iface_init (GimpContainerViewInterface *view_iface)
290
 
{
291
 
  parent_view_iface = g_type_interface_peek_parent (view_iface);
292
 
 
293
 
  view_iface->set_container = gimp_item_tree_view_set_container;
294
 
  view_iface->insert_item   = gimp_item_tree_view_insert_item;
295
 
  view_iface->select_item   = gimp_item_tree_view_select_item;
296
 
  view_iface->activate_item = gimp_item_tree_view_activate_item;
297
 
  view_iface->context_item  = gimp_item_tree_view_context_item;
298
 
}
299
 
 
300
 
static void
301
 
gimp_item_tree_view_docked_iface_init (GimpDockedInterface *docked_iface)
302
 
{
303
 
  docked_iface->get_preview = NULL;
304
 
  docked_iface->set_context = gimp_item_tree_view_set_context;
305
 
}
306
 
 
307
 
static void
308
 
gimp_item_tree_view_set_context (GimpDocked  *docked,
309
 
                                 GimpContext *context)
310
 
{
311
 
  GimpItemTreeView *view   = GIMP_ITEM_TREE_VIEW (docked);
312
 
  GimpImage        *gimage = NULL;
313
 
 
314
 
  if (view->context)
315
 
    {
316
 
      g_signal_handlers_disconnect_by_func (view->context,
317
 
                                            gimp_item_tree_view_set_image,
318
 
                                            view);
319
 
    }
320
 
 
321
 
  view->context = context;
322
 
 
323
 
  if (context)
324
 
    {
325
 
      g_signal_connect_swapped (context, "image_changed",
326
 
                                G_CALLBACK (gimp_item_tree_view_set_image),
327
 
                                view);
328
 
 
329
 
      gimage = gimp_context_get_image (context);
330
 
    }
331
 
 
332
 
  gimp_item_tree_view_set_image (view, gimage);
333
 
}
334
 
 
335
265
static GObject *
336
266
gimp_item_tree_view_constructor (GType                  type,
337
267
                                 guint                  n_params,
407
337
    gimp_editor_add_action_button (editor, item_view_class->action_group,
408
338
                                   item_view_class->edit_action, NULL);
409
339
  gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (item_view),
410
 
                                  GTK_BUTTON (item_view->edit_button),
411
 
                                  item_view_class->item_type);
 
340
                                  GTK_BUTTON (item_view->edit_button),
 
341
                                  item_view_class->item_type);
412
342
 
413
343
  item_view->new_button =
414
344
    gimp_editor_add_action_button (editor, item_view_class->action_group,
420
350
   *  it was clicked or dropped
421
351
   */
422
352
  gimp_dnd_viewable_dest_add (item_view->new_button,
423
 
                              item_view_class->item_type,
424
 
                              gimp_item_tree_view_new_dropped,
425
 
                              item_view);
 
353
                              item_view_class->item_type,
 
354
                              gimp_item_tree_view_new_dropped,
 
355
                              item_view);
426
356
 
427
357
  item_view->raise_button =
428
358
    gimp_editor_add_action_button (editor, item_view_class->action_group,
442
372
    gimp_editor_add_action_button (editor, item_view_class->action_group,
443
373
                                   item_view_class->duplicate_action, NULL);
444
374
  gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (item_view),
445
 
                                  GTK_BUTTON (item_view->duplicate_button),
446
 
                                  item_view_class->item_type);
 
375
                                  GTK_BUTTON (item_view->duplicate_button),
 
376
                                  item_view_class->item_type);
447
377
 
448
378
  item_view->delete_button =
449
379
    gimp_editor_add_action_button (editor, item_view_class->action_group,
450
380
                                   item_view_class->delete_action, NULL);
451
381
  gimp_container_view_enable_dnd (GIMP_CONTAINER_VIEW (item_view),
452
 
                                  GTK_BUTTON (item_view->delete_button),
453
 
                                  item_view_class->item_type);
 
382
                                  GTK_BUTTON (item_view->delete_button),
 
383
                                  item_view_class->item_type);
454
384
 
455
385
  return object;
456
386
}
460
390
{
461
391
  GimpItemTreeView *view = GIMP_ITEM_TREE_VIEW (object);
462
392
 
463
 
  if (view->gimage)
 
393
  if (view->image)
464
394
    gimp_item_tree_view_set_image (view, NULL);
465
395
 
466
396
  GTK_OBJECT_CLASS (parent_class)->destroy (object);
468
398
 
469
399
GtkWidget *
470
400
gimp_item_tree_view_new (GType            view_type,
471
 
                         gint             preview_size,
472
 
                         gint             preview_border_width,
473
 
                         GimpImage       *gimage,
 
401
                         gint             view_size,
 
402
                         gint             view_border_width,
 
403
                         GimpImage       *image,
474
404
                         GimpMenuFactory *menu_factory,
475
405
                         const gchar     *menu_identifier,
476
406
                         const gchar     *ui_path)
478
408
  GimpItemTreeView *item_view;
479
409
 
480
410
  g_return_val_if_fail (g_type_is_a (view_type, GIMP_TYPE_ITEM_TREE_VIEW), NULL);
481
 
  g_return_val_if_fail (preview_size >  0 &&
482
 
                        preview_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL);
483
 
  g_return_val_if_fail (preview_border_width >= 0 &&
484
 
                        preview_border_width <= GIMP_VIEW_MAX_BORDER_WIDTH,
 
411
  g_return_val_if_fail (view_size >  0 &&
 
412
                        view_size <= GIMP_VIEWABLE_MAX_PREVIEW_SIZE, NULL);
 
413
  g_return_val_if_fail (view_border_width >= 0 &&
 
414
                        view_border_width <= GIMP_VIEW_MAX_BORDER_WIDTH,
485
415
                        NULL);
486
 
  g_return_val_if_fail (gimage == NULL || GIMP_IS_IMAGE (gimage), NULL);
 
416
  g_return_val_if_fail (image == NULL || GIMP_IS_IMAGE (image), NULL);
487
417
  g_return_val_if_fail (GIMP_IS_MENU_FACTORY (menu_factory), NULL);
488
418
  g_return_val_if_fail (menu_identifier != NULL, NULL);
489
419
  g_return_val_if_fail (ui_path != NULL, NULL);
495
425
                            "ui-path",         ui_path,
496
426
                            NULL);
497
427
 
498
 
  gimp_container_view_set_preview_size (GIMP_CONTAINER_VIEW (item_view),
499
 
                                        preview_size, preview_border_width);
 
428
  gimp_container_view_set_view_size (GIMP_CONTAINER_VIEW (item_view),
 
429
                                     view_size, view_border_width);
500
430
 
501
 
  gimp_item_tree_view_set_image (item_view, gimage);
 
431
  gimp_item_tree_view_set_image (item_view, image);
502
432
 
503
433
  return GTK_WIDGET (item_view);
504
434
}
505
435
 
506
436
void
507
437
gimp_item_tree_view_set_image (GimpItemTreeView *view,
508
 
                               GimpImage        *gimage)
 
438
                               GimpImage        *image)
509
439
{
510
440
  g_return_if_fail (GIMP_IS_ITEM_TREE_VIEW (view));
511
 
  g_return_if_fail (gimage == NULL || GIMP_IS_IMAGE (gimage));
 
441
  g_return_if_fail (image == NULL || GIMP_IS_IMAGE (image));
512
442
 
513
 
  g_signal_emit (view, view_signals[SET_IMAGE], 0, gimage);
 
443
  g_signal_emit (view, view_signals[SET_IMAGE], 0, image);
514
444
 
515
445
  gimp_ui_manager_update (GIMP_EDITOR (view)->ui_manager, view);
516
446
}
517
447
 
 
448
GimpImage *
 
449
gimp_item_tree_view_get_image (GimpItemTreeView *view)
 
450
{
 
451
  g_return_val_if_fail (GIMP_IS_ITEM_TREE_VIEW (view), NULL);
 
452
 
 
453
  return view->image;
 
454
}
 
455
 
518
456
static void
519
457
gimp_item_tree_view_real_set_image (GimpItemTreeView *view,
520
 
                                    GimpImage        *gimage)
 
458
                                    GimpImage        *image)
521
459
{
522
 
  if (view->gimage == gimage)
 
460
  if (view->image == image)
523
461
    return;
524
462
 
525
 
  if (view->gimage)
 
463
  if (view->image)
526
464
    {
527
 
      g_signal_handlers_disconnect_by_func (view->gimage,
528
 
                                            gimp_item_tree_view_item_changed,
529
 
                                            view);
530
 
      g_signal_handlers_disconnect_by_func (view->gimage,
531
 
                                            gimp_item_tree_view_size_changed,
532
 
                                            view);
 
465
      g_signal_handlers_disconnect_by_func (view->image,
 
466
                                            gimp_item_tree_view_item_changed,
 
467
                                            view);
 
468
      g_signal_handlers_disconnect_by_func (view->image,
 
469
                                            gimp_item_tree_view_size_changed,
 
470
                                            view);
533
471
 
534
472
      gimp_container_view_set_container (GIMP_CONTAINER_VIEW (view), NULL);
535
473
 
536
 
      g_signal_handlers_disconnect_by_func (view->gimage,
 
474
      g_signal_handlers_disconnect_by_func (view->image,
537
475
                                            gimp_item_tree_view_image_flush,
538
476
                                            view);
539
477
    }
540
478
 
541
 
  view->gimage = gimage;
 
479
  view->image = image;
542
480
 
543
 
  if (view->gimage)
 
481
  if (view->image)
544
482
    {
545
483
      GimpContainer *container;
546
484
 
547
485
      container =
548
 
        GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_container (view->gimage);
 
486
        GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_container (view->image);
549
487
 
550
488
      gimp_container_view_set_container (GIMP_CONTAINER_VIEW (view), container);
551
489
 
552
 
      g_signal_connect (view->gimage,
 
490
      g_signal_connect (view->image,
553
491
                        GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->signal_name,
554
 
                        G_CALLBACK (gimp_item_tree_view_item_changed),
555
 
                        view);
556
 
      g_signal_connect (view->gimage, "size_changed",
557
 
                        G_CALLBACK (gimp_item_tree_view_size_changed),
558
 
                        view);
 
492
                        G_CALLBACK (gimp_item_tree_view_item_changed),
 
493
                        view);
 
494
      g_signal_connect (view->image, "size-changed",
 
495
                        G_CALLBACK (gimp_item_tree_view_size_changed),
 
496
                        view);
559
497
 
560
 
      g_signal_connect (view->gimage, "flush",
 
498
      g_signal_connect (view->image, "flush",
561
499
                        G_CALLBACK (gimp_item_tree_view_image_flush),
562
500
                        view);
563
501
 
564
 
      gimp_item_tree_view_item_changed (view->gimage, view);
 
502
      gimp_item_tree_view_item_changed (view->image, view);
565
503
    }
566
504
}
567
505
 
568
506
static void
569
 
gimp_item_tree_view_image_flush (GimpImage        *gimage,
 
507
gimp_item_tree_view_image_flush (GimpImage        *image,
570
508
                                 GimpItemTreeView *view)
571
509
{
572
510
  gimp_ui_manager_update (GIMP_EDITOR (view)->ui_manager, view);
587
525
  if (old_container)
588
526
    {
589
527
      gimp_container_remove_handler (old_container,
590
 
                                     item_view->visible_changed_handler_id);
 
528
                                     item_view->visible_changed_handler_id);
591
529
      gimp_container_remove_handler (old_container,
592
 
                                     item_view->linked_changed_handler_id);
 
530
                                     item_view->linked_changed_handler_id);
593
531
 
594
532
      item_view->visible_changed_handler_id = 0;
595
533
      item_view->linked_changed_handler_id  = 0;
600
538
  if (container)
601
539
    {
602
540
      item_view->visible_changed_handler_id =
603
 
        gimp_container_add_handler (container, "visibility_changed",
604
 
                                    G_CALLBACK (gimp_item_tree_view_visible_changed),
605
 
                                    view);
 
541
        gimp_container_add_handler (container, "visibility-changed",
 
542
                                    G_CALLBACK (gimp_item_tree_view_visible_changed),
 
543
                                    view);
606
544
      item_view->linked_changed_handler_id =
607
 
        gimp_container_add_handler (container, "linked_changed",
608
 
                                    G_CALLBACK (gimp_item_tree_view_linked_changed),
609
 
                                    view);
610
 
    }
 
545
        gimp_container_add_handler (container, "linked-changed",
 
546
                                    G_CALLBACK (gimp_item_tree_view_linked_changed),
 
547
                                    view);
 
548
    }
 
549
}
 
550
 
 
551
static void
 
552
gimp_item_tree_view_set_context (GimpContainerView *view,
 
553
                                 GimpContext       *context)
 
554
{
 
555
  GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (view);
 
556
  GimpItemTreeView      *item_view = GIMP_ITEM_TREE_VIEW (view);
 
557
  GimpImage             *image     = NULL;
 
558
  GimpContext           *old_context;
 
559
 
 
560
  old_context = gimp_container_view_get_context (view);
 
561
 
 
562
  if (old_context)
 
563
    {
 
564
      g_signal_handlers_disconnect_by_func (old_context,
 
565
                                            gimp_item_tree_view_set_image,
 
566
                                            item_view);
 
567
    }
 
568
 
 
569
  parent_view_iface->set_context (view, context);
 
570
 
 
571
  if (context)
 
572
    {
 
573
      if (! tree_view->dnd_gimp)
 
574
        tree_view->dnd_gimp = context->gimp;
 
575
 
 
576
      g_signal_connect_swapped (context, "image-changed",
 
577
                                G_CALLBACK (gimp_item_tree_view_set_image),
 
578
                                item_view);
 
579
 
 
580
      image = gimp_context_get_image (context);
 
581
    }
 
582
 
 
583
  gimp_item_tree_view_set_image (item_view, image);
611
584
}
612
585
 
613
586
static gpointer
649
622
 
650
623
      item_view_class = GIMP_ITEM_TREE_VIEW_GET_CLASS (tree_view);
651
624
 
652
 
      active_item = item_view_class->get_active_item (tree_view->gimage);
 
625
      active_item = item_view_class->get_active_item (tree_view->image);
653
626
 
654
627
      if (active_item != (GimpItem *) item)
655
 
        {
656
 
          item_view_class->set_active_item (tree_view->gimage,
 
628
        {
 
629
          item_view_class->set_active_item (tree_view->image,
657
630
                                            GIMP_ITEM (item));
658
631
 
659
 
          gimp_image_flush (tree_view->gimage);
660
 
        }
 
632
          gimp_image_flush (tree_view->image);
 
633
        }
661
634
    }
662
635
 
663
636
  gimp_ui_manager_update (GIMP_EDITOR (tree_view)->ui_manager, tree_view);
677
650
 
678
651
  if (item_view_class->activate_action)
679
652
    {
680
 
      GtkAction *action;
681
 
 
682
 
      action = gimp_ui_manager_find_action (GIMP_EDITOR (view)->ui_manager,
683
 
                                            item_view_class->action_group,
684
 
                                            item_view_class->activate_action);
685
 
 
686
 
      if (action)
687
 
        gtk_action_activate (action);
 
653
      gimp_ui_manager_activate_action (GIMP_EDITOR (view)->ui_manager,
 
654
                                       item_view_class->action_group,
 
655
                                       item_view_class->activate_action);
688
656
    }
689
657
}
690
658
 
709
677
                                   GdkDragAction           *return_drag_action)
710
678
{
711
679
  if (GIMP_IS_ITEM (src_viewable) &&
712
 
      gimp_item_get_image (GIMP_ITEM (src_viewable)) !=
713
 
      gimp_item_get_image (GIMP_ITEM (dest_viewable)))
 
680
      (dest_viewable == NULL ||
 
681
       gimp_item_get_image (GIMP_ITEM (src_viewable)) !=
 
682
       gimp_item_get_image (GIMP_ITEM (dest_viewable))))
714
683
    {
715
684
      if (return_drop_pos)
716
685
        *return_drop_pos = drop_pos;
740
709
  GimpItemTreeView      *item_view      = GIMP_ITEM_TREE_VIEW (tree_view);
741
710
  GimpItemTreeViewClass *item_view_class;
742
711
  GimpContainer         *container;
743
 
  gint                   src_index;
744
 
  gint                   dest_index;
 
712
  gint                   dest_index     = -1;
745
713
 
746
714
  container = gimp_container_view_get_container (container_view);
747
715
 
748
 
  src_index  = gimp_container_get_child_index (container,
749
 
                                               GIMP_OBJECT (src_viewable));
750
 
  dest_index = gimp_container_get_child_index (container,
751
 
                                               GIMP_OBJECT (dest_viewable));
 
716
  if (dest_viewable)
 
717
    dest_index = gimp_container_get_child_index (container,
 
718
                                                 GIMP_OBJECT (dest_viewable));
752
719
 
753
720
  item_view_class = GIMP_ITEM_TREE_VIEW_GET_CLASS (item_view);
754
721
 
755
 
  if (item_view->gimage != gimp_item_get_image (GIMP_ITEM (src_viewable)))
 
722
  if (item_view->image != gimp_item_get_image (GIMP_ITEM (src_viewable)) ||
 
723
      ! g_type_is_a (G_TYPE_FROM_INSTANCE (src_viewable),
 
724
                     item_view_class->item_type))
756
725
    {
 
726
      GType     item_type = item_view_class->item_type;
757
727
      GimpItem *new_item;
758
728
 
759
 
      if (drop_pos == GTK_TREE_VIEW_DROP_AFTER)
 
729
      if (g_type_is_a (G_TYPE_FROM_INSTANCE (src_viewable), item_type))
 
730
        item_type = G_TYPE_FROM_INSTANCE (src_viewable);
 
731
 
 
732
      if (dest_viewable && drop_pos == GTK_TREE_VIEW_DROP_AFTER)
760
733
        dest_index++;
761
734
 
762
735
      new_item = gimp_item_convert (GIMP_ITEM (src_viewable),
763
 
                                    item_view->gimage,
764
 
                                    G_TYPE_FROM_INSTANCE (src_viewable),
765
 
                                    TRUE);
 
736
                                    item_view->image, item_type, TRUE);
766
737
 
767
 
      item_view_class->add_item (item_view->gimage, new_item, dest_index);
 
738
      item_view_class->add_item (item_view->image, new_item, dest_index);
768
739
    }
769
 
  else
 
740
  else if (dest_viewable)
770
741
    {
 
742
      gint src_index;
 
743
 
 
744
      src_index = gimp_container_get_child_index (container,
 
745
                                                  GIMP_OBJECT (src_viewable));
 
746
 
771
747
      if (drop_pos == GTK_TREE_VIEW_DROP_AFTER && src_index > dest_index)
772
748
        {
773
749
          dest_index++;
777
753
          dest_index--;
778
754
        }
779
755
 
780
 
      item_view_class->reorder_item (item_view->gimage,
 
756
      item_view_class->reorder_item (item_view->image,
781
757
                                     GIMP_ITEM (src_viewable),
782
758
                                     dest_index,
783
759
                                     TRUE,
784
760
                                     item_view_class->reorder_desc);
785
761
    }
786
762
 
787
 
  gimp_image_flush (item_view->gimage);
 
763
  gimp_image_flush (item_view->image);
788
764
}
789
765
 
790
766
 
792
768
 
793
769
static void
794
770
gimp_item_tree_view_new_dropped (GtkWidget    *widget,
 
771
                                 gint          x,
 
772
                                 gint          y,
795
773
                                 GimpViewable *viewable,
796
774
                                 gpointer      data)
797
775
{
823
801
/*  GimpImage callbacks  */
824
802
 
825
803
static void
826
 
gimp_item_tree_view_item_changed (GimpImage        *gimage,
 
804
gimp_item_tree_view_item_changed (GimpImage        *image,
827
805
                                  GimpItemTreeView *view)
828
806
{
829
807
  GimpItem *item;
830
808
 
831
 
  item = GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (view->gimage);
 
809
  item = GIMP_ITEM_TREE_VIEW_GET_CLASS (view)->get_active_item (view->image);
832
810
 
833
811
  gimp_container_view_select_item (GIMP_CONTAINER_VIEW (view),
834
812
                                   (GimpViewable *) item);
835
813
}
836
814
 
837
815
static void
838
 
gimp_item_tree_view_size_changed (GimpImage        *gimage,
 
816
gimp_item_tree_view_size_changed (GimpImage        *image,
839
817
                                  GimpItemTreeView *tree_view)
840
818
{
841
819
  GimpContainerView *view = GIMP_CONTAINER_VIEW (tree_view);
842
 
  gint               preview_size;
 
820
  gint               view_size;
843
821
  gint               border_width;
844
822
 
845
 
  preview_size = gimp_container_view_get_preview_size (view, &border_width);
 
823
  view_size = gimp_container_view_get_view_size (view, &border_width);
846
824
 
847
 
  gimp_container_view_set_preview_size (view, preview_size, border_width);
 
825
  gimp_container_view_set_view_size (view, view_size, border_width);
848
826
}
849
827
 
850
828
static void
853
831
                                 const gchar         *new_name,
854
832
                                 GimpItemTreeView    *view)
855
833
{
856
 
  GimpContainerTreeView *tree_view;
 
834
  GimpContainerTreeView *tree_view = GIMP_CONTAINER_TREE_VIEW (view);
857
835
  GtkTreePath           *path;
858
836
  GtkTreeIter            iter;
859
837
 
860
 
  tree_view = GIMP_CONTAINER_TREE_VIEW (view);
861
 
 
862
838
  path = gtk_tree_path_new_from_string (path_str);
863
839
 
864
840
  if (gtk_tree_model_get_iter (tree_view->model, &iter, path))
978
954
  GimpUndoType           group_type;
979
955
  const gchar           *undo_desc;
980
956
 
981
 
  gboolean (* getter)  (const GimpItem *item);
982
 
  void     (* setter)  (GimpItem       *item,
983
 
                        gboolean        value,
984
 
                        gboolean        push_undo);
985
 
  gboolean (* pusher)  (GimpImage      *gimage,
986
 
                        const gchar    *undo_desc,
987
 
                        GimpItem       *item);
 
957
  gboolean   (* getter) (const GimpItem *item);
 
958
  void       (* setter) (GimpItem       *item,
 
959
                         gboolean        value,
 
960
                         gboolean        push_undo);
 
961
  GimpUndo * (* pusher) (GimpImage      *image,
 
962
                         const gchar    *undo_desc,
 
963
                         GimpItem       *item);
988
964
 
989
965
  switch (undo_type)
990
966
    {
1012
988
 
1013
989
  if (gtk_tree_model_get_iter (tree_view->model, &iter, path))
1014
990
    {
 
991
      GimpContext      *context;
1015
992
      GimpViewRenderer *renderer;
1016
993
      GimpItem         *item;
1017
 
      GimpImage        *gimage;
 
994
      GimpImage        *image;
1018
995
      gboolean          active;
1019
996
 
 
997
      context = gimp_container_view_get_context (GIMP_CONTAINER_VIEW (view));
 
998
 
1020
999
      gtk_tree_model_get (tree_view->model, &iter,
1021
1000
                          tree_view->model_column_renderer, &renderer,
1022
1001
                          -1);
1027
1006
      item = GIMP_ITEM (renderer->viewable);
1028
1007
      g_object_unref (renderer);
1029
1008
 
1030
 
      gimage = gimp_item_get_image (item);
 
1009
      image = gimp_item_get_image (item);
1031
1010
 
1032
1011
      if (state & GDK_SHIFT_MASK)
1033
1012
        {
1065
1044
 
1066
1045
              view_class = GIMP_ITEM_TREE_VIEW_GET_CLASS (view);
1067
1046
 
1068
 
              undo = gimp_image_undo_can_compress (gimage, GIMP_TYPE_UNDO_STACK,
 
1047
              undo = gimp_image_undo_can_compress (image, GIMP_TYPE_UNDO_STACK,
1069
1048
                                                   group_type);
1070
1049
 
1071
1050
              if (undo && (g_object_get_data (G_OBJECT (undo), "item-type") ==
1074
1053
 
1075
1054
              if (push_undo)
1076
1055
                {
1077
 
                  if (gimp_image_undo_group_start (gimage, group_type,
 
1056
                  if (gimp_image_undo_group_start (image, group_type,
1078
1057
                                                   undo_desc))
1079
1058
                    {
1080
 
                      undo = gimp_image_undo_can_compress (gimage,
 
1059
                      undo = gimp_image_undo_can_compress (image,
1081
1060
                                                           GIMP_TYPE_UNDO_STACK,
1082
1061
                                                           group_type);
1083
1062
 
1086
1065
                                           (gpointer) view_class->item_type);
1087
1066
                    }
1088
1067
 
1089
 
                  pusher (gimage, NULL, item);
 
1068
                  pusher (image, NULL, item);
1090
1069
 
1091
1070
                  for (list = on; list; list = g_list_next (list))
1092
 
                    pusher (gimage, NULL, list->data);
 
1071
                    pusher (image, NULL, list->data);
1093
1072
 
1094
1073
                  for (list = off; list; list = g_list_next (list))
1095
 
                    pusher (gimage, NULL, list->data);
 
1074
                    pusher (image, NULL, list->data);
1096
1075
 
1097
 
                  gimp_image_undo_group_end (gimage);
 
1076
                  gimp_image_undo_group_end (image);
1098
1077
                }
1099
1078
              else
1100
1079
                {
1101
 
                  gimp_undo_refresh_preview (undo);
 
1080
                  gimp_undo_refresh_preview (undo, context);
1102
1081
                }
1103
1082
            }
1104
1083
 
1123
1102
          GimpUndo *undo;
1124
1103
          gboolean  push_undo = TRUE;
1125
1104
 
1126
 
          undo = gimp_image_undo_can_compress (gimage, GIMP_TYPE_ITEM_UNDO,
 
1105
          undo = gimp_image_undo_can_compress (image, GIMP_TYPE_ITEM_UNDO,
1127
1106
                                               undo_type);
1128
1107
 
1129
1108
          if (undo && GIMP_ITEM_UNDO (undo)->item == item)
1132
1111
          setter (item, ! active, push_undo);
1133
1112
 
1134
1113
          if (!push_undo)
1135
 
            gimp_undo_refresh_preview (undo);
 
1114
            gimp_undo_refresh_preview (undo, context);
1136
1115
        }
1137
1116
 
1138
 
      gimp_image_flush (gimage);
 
1117
      gimp_image_flush (image);
1139
1118
    }
1140
1119
 
1141
1120
  gtk_tree_path_free (path);