← Back to branch summary

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

« back to all changes in this revision

Viewing changes to app/core/gimpimage-merge.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/core/gimpimage-merge.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
 * This program is free software; you can redistribute it and/or modify
50
50
 
51
51
#include "gimp-intl.h"
52
52
 
 
53
static GimpLayer * gimp_image_merge_layers (GimpImage     *image,
 
54
                                            GSList        *merge_list,
 
55
                                            GimpContext   *context,
 
56
                                            GimpMergeType  merge_type,
 
57
                                            const gchar   *undo_desc);
 
58
 
53
59
 
54
60
/*  public functions  */
55
61
 
56
62
GimpLayer *
57
 
gimp_image_merge_visible_layers (GimpImage     *gimage,
 
63
gimp_image_merge_visible_layers (GimpImage     *image,
58
64
                                 GimpContext   *context,
59
 
                                 GimpMergeType  merge_type)
 
65
                                 GimpMergeType  merge_type,
 
66
                                 gboolean       discard_invisible)
60
67
{
61
68
  GList     *list;
62
69
  GSList    *merge_list       = NULL;
 
70
  GSList    *invisible_list   = NULL;
63
71
  gboolean   had_floating_sel = FALSE;
64
72
  GimpLayer *layer            = NULL;
65
73
 
66
 
  g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
 
74
  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
67
75
  g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
68
76
 
69
77
  /* if there's a floating selection, anchor it */
70
 
  if (gimp_image_floating_sel (gimage))
 
78
  if (gimp_image_floating_sel (image))
71
79
    {
72
 
      floating_sel_anchor (gimage->floating_sel);
 
80
      floating_sel_anchor (image->floating_sel);
73
81
      had_floating_sel = TRUE;
74
82
    }
75
83
 
76
 
  for (list = GIMP_LIST (gimage->layers)->list;
 
84
  for (list = GIMP_LIST (image->layers)->list;
77
85
       list;
78
86
       list = g_list_next (list))
79
87
    {
80
 
      layer = (GimpLayer *) list->data;
 
88
      layer = list->data;
81
89
 
82
90
      if (gimp_item_get_visible (GIMP_ITEM (layer)))
83
 
        merge_list = g_slist_append (merge_list, layer);
 
91
        {
 
92
          merge_list = g_slist_append (merge_list, layer);
 
93
        }
 
94
      else if (discard_invisible)
 
95
        {
 
96
          invisible_list = g_slist_append (invisible_list, layer);
 
97
        }
84
98
    }
85
99
 
86
 
  if (merge_list && merge_list->next)
 
100
  if (merge_list)
87
101
    {
88
 
      gimp_set_busy (gimage->gimp);
89
 
 
90
 
      layer = gimp_image_merge_layers (gimage, merge_list, context, merge_type,
 
102
      const gchar *undo_desc = _("Merge Visible Layers");
 
103
 
 
104
      gimp_set_busy (image->gimp);
 
105
 
 
106
      if (invisible_list)
 
107
        {
 
108
          gimp_image_undo_group_start (image,
 
109
                                       GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE,
 
110
                                       undo_desc);
 
111
        }
 
112
 
 
113
      layer = gimp_image_merge_layers (image, merge_list, context, merge_type,
91
114
                                       _("Merge Visible Layers"));
92
115
      g_slist_free (merge_list);
93
116
 
94
 
      gimp_unset_busy (gimage->gimp);
 
117
      if (invisible_list)
 
118
        {
 
119
          GSList *list;
 
120
 
 
121
          for (list = invisible_list; list; list = g_slist_next (list))
 
122
            gimp_image_remove_layer (image, list->data);
 
123
 
 
124
          gimp_image_undo_group_end (image);
 
125
          g_slist_free (invisible_list);
 
126
        }
 
127
 
 
128
 
 
129
      gimp_unset_busy (image->gimp);
95
130
 
96
131
      return layer;
97
132
    }
98
 
  else
99
 
    {
100
 
      g_slist_free (merge_list);
101
 
 
102
 
      /* If there was a floating selection, we have done something.
103
 
         No need to warn the user. Return the active layer instead */
104
 
      if (had_floating_sel)
105
 
        return gimage->active_layer;
106
 
      else
107
 
        g_message (_("Not enough visible layers for a merge. "
108
 
                     "There must be at least two."));
109
 
 
110
 
      return NULL;
111
 
    }
 
133
 
 
134
  return image->active_layer;
112
135
}
113
136
 
114
137
GimpLayer *
115
 
gimp_image_flatten (GimpImage   *gimage,
 
138
gimp_image_flatten (GimpImage   *image,
116
139
                    GimpContext *context)
117
140
{
118
141
  GList     *list;
119
142
  GSList    *merge_list = NULL;
120
143
  GimpLayer *layer;
121
144
 
122
 
  g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
 
145
  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
123
146
  g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
124
147
 
125
 
  gimp_set_busy (gimage->gimp);
 
148
  gimp_set_busy (image->gimp);
126
149
 
127
150
  /* if there's a floating selection, anchor it */
128
 
  if (gimp_image_floating_sel (gimage))
129
 
    floating_sel_anchor (gimage->floating_sel);
 
151
  if (gimp_image_floating_sel (image))
 
152
    floating_sel_anchor (image->floating_sel);
130
153
 
131
 
  for (list = GIMP_LIST (gimage->layers)->list;
 
154
  for (list = GIMP_LIST (image->layers)->list;
132
155
       list;
133
156
       list = g_list_next (list))
134
157
    {
135
 
      layer = (GimpLayer *) list->data;
 
158
      layer = list->data;
136
159
 
137
160
      if (gimp_item_get_visible (GIMP_ITEM (layer)))
138
161
        merge_list = g_slist_append (merge_list, layer);
139
162
    }
140
163
 
141
 
  layer = gimp_image_merge_layers (gimage, merge_list, context,
 
164
  layer = gimp_image_merge_layers (image, merge_list, context,
142
165
                                   GIMP_FLATTEN_IMAGE, _("Flatten Image"));
143
166
  g_slist_free (merge_list);
144
167
 
145
 
  gimp_image_alpha_changed (gimage);
 
168
  gimp_image_alpha_changed (image);
146
169
 
147
 
  gimp_unset_busy (gimage->gimp);
 
170
  gimp_unset_busy (image->gimp);
148
171
 
149
172
  return layer;
150
173
}
151
174
 
152
175
GimpLayer *
153
 
gimp_image_merge_down (GimpImage     *gimage,
 
176
gimp_image_merge_down (GimpImage     *image,
154
177
                       GimpLayer     *current_layer,
155
178
                       GimpContext   *context,
156
179
                       GimpMergeType  merge_type)
160
183
  GList     *layer_list;
161
184
  GSList    *merge_list;
162
185
 
163
 
  g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
 
186
  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
164
187
  g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
165
188
 
166
 
  for (list = GIMP_LIST (gimage->layers)->list, layer_list = NULL;
 
189
  for (list = GIMP_LIST (image->layers)->list, layer_list = NULL;
167
190
       list && !layer_list;
168
191
       list = g_list_next (list))
169
192
    {
170
 
      layer = (GimpLayer *) list->data;
 
193
      layer = list->data;
171
194
 
172
195
      if (layer == current_layer)
173
196
        break;
177
200
       layer_list && !merge_list;
178
201
       layer_list = g_list_next (layer_list))
179
202
    {
180
 
      layer = (GimpLayer *) layer_list->data;
 
203
      layer = layer_list->data;
181
204
 
182
205
      if (gimp_item_get_visible (GIMP_ITEM (layer)))
183
206
        merge_list = g_slist_append (NULL, layer);
184
207
    }
185
208
 
186
 
  if (merge_list)
187
 
    {
188
 
      merge_list = g_slist_prepend (merge_list, current_layer);
189
 
 
190
 
      gimp_set_busy (gimage->gimp);
191
 
 
192
 
      layer = gimp_image_merge_layers (gimage, merge_list, context, merge_type,
193
 
                                       _("Merge Down"));
 
209
  merge_list = g_slist_prepend (merge_list, current_layer);
 
210
 
 
211
  gimp_set_busy (image->gimp);
 
212
 
 
213
  layer = gimp_image_merge_layers (image, merge_list, context, merge_type,
 
214
                                   _("Merge Down"));
 
215
  g_slist_free (merge_list);
 
216
 
 
217
  gimp_unset_busy (image->gimp);
 
218
 
 
219
  return layer;
 
220
}
 
221
 
 
222
/* merging vectors */
 
223
 
 
224
GimpVectors *
 
225
gimp_image_merge_visible_vectors (GimpImage *image)
 
226
{
 
227
  GList       *list           = NULL;
 
228
  GSList      *merge_list     = NULL;
 
229
  GSList      *cur_item       = NULL;
 
230
  GimpVectors *vectors        = NULL;
 
231
  GimpVectors *target_vectors = NULL;
 
232
  gchar       *name           = NULL;
 
233
  gint         pos            = 0;
 
234
 
 
235
  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
 
236
 
 
237
  for (list = GIMP_LIST (image->vectors)->list;
 
238
       list;
 
239
       list = g_list_next (list))
 
240
    {
 
241
      vectors = list->data;
 
242
 
 
243
      if (gimp_item_get_visible (GIMP_ITEM (vectors)))
 
244
        merge_list = g_slist_append (merge_list, vectors);
 
245
    }
 
246
 
 
247
  if (merge_list && merge_list->next)
 
248
    {
 
249
      gimp_set_busy (image->gimp);
 
250
 
 
251
      gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE,
 
252
                                   _("Merge Visible Paths"));
 
253
 
 
254
      cur_item = merge_list;
 
255
      vectors = GIMP_VECTORS (cur_item->data);
 
256
 
 
257
      name = g_strdup (gimp_object_get_name (GIMP_OBJECT (vectors)));
 
258
      target_vectors = GIMP_VECTORS (
 
259
                            gimp_item_duplicate (GIMP_ITEM (vectors),
 
260
                                                 GIMP_TYPE_VECTORS,
 
261
                                                 FALSE));
 
262
      pos = gimp_image_get_vectors_index (image, vectors);
 
263
      gimp_image_remove_vectors (image, vectors);
 
264
      cur_item = cur_item->next;
 
265
 
 
266
      while (cur_item)
 
267
        {
 
268
          vectors = GIMP_VECTORS (cur_item->data);
 
269
          gimp_vectors_add_strokes (vectors, target_vectors);
 
270
          gimp_image_remove_vectors (image, vectors);
 
271
 
 
272
          cur_item = g_slist_next (cur_item);
 
273
        }
 
274
 
 
275
      gimp_object_take_name (GIMP_OBJECT (target_vectors), name);
 
276
 
194
277
      g_slist_free (merge_list);
195
278
 
196
 
      gimp_unset_busy (gimage->gimp);
197
 
 
198
 
      return layer;
 
279
      gimp_image_add_vectors (image, target_vectors, pos);
 
280
      gimp_unset_busy (image->gimp);
 
281
 
 
282
      gimp_image_undo_group_end (image);
 
283
 
 
284
      return target_vectors;
199
285
    }
200
286
  else
201
287
    {
202
 
      g_message (_("There are not enough visible layers for a merge down."));
 
288
      gimp_message (image->gimp, NULL, GIMP_MESSAGE_WARNING,
 
289
                    _("Not enough visible paths for a merge. "
 
290
                      "There must be at least two."));
203
291
      return NULL;
204
292
    }
205
293
}
206
294
 
207
 
GimpLayer *
208
 
gimp_image_merge_layers (GimpImage     *gimage,
 
295
 
 
296
/*  private functions  */
 
297
 
 
298
static GimpLayer *
 
299
gimp_image_merge_layers (GimpImage     *image,
209
300
                         GSList        *merge_list,
210
301
                         GimpContext   *context,
211
302
                         GimpMergeType  merge_type,
229
320
  gint             off_x, off_y;
230
321
  gchar           *name;
231
322
 
232
 
  g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
 
323
  g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
233
324
  g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
234
325
 
235
326
  layer        = NULL;
242
333
  count = 0;
243
334
  while (merge_list)
244
335
    {
245
 
      layer = (GimpLayer *) merge_list->data;
 
336
      layer = merge_list->data;
246
337
 
247
338
      gimp_item_offsets (GIMP_ITEM (layer), &off_x, &off_y);
248
339
 
270
361
            }
271
362
          if (merge_type == GIMP_CLIP_TO_IMAGE)
272
363
            {
273
 
              x1 = CLAMP (x1, 0, gimage->width);
274
 
              y1 = CLAMP (y1, 0, gimage->height);
275
 
              x2 = CLAMP (x2, 0, gimage->width);
276
 
              y2 = CLAMP (y2, 0, gimage->height);
 
364
              x1 = CLAMP (x1, 0, image->width);
 
365
              y1 = CLAMP (y1, 0, image->height);
 
366
              x2 = CLAMP (x2, 0, image->width);
 
367
              y2 = CLAMP (y2, 0, image->height);
277
368
            }
278
369
          break;
279
370
 
292
383
            {
293
384
              x1 = 0;
294
385
              y1 = 0;
295
 
              x2 = gimage->width;
296
 
              y2 = gimage->height;
 
386
              x2 = image->width;
 
387
              y2 = image->height;
297
388
            }
298
389
          break;
299
390
        }
308
399
 
309
400
  /*  Start a merge undo group. */
310
401
 
311
 
  gimp_image_undo_group_start (gimage, GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE,
 
402
  gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE,
312
403
                               undo_desc);
313
404
 
314
405
  name = g_strdup (gimp_object_get_name (GIMP_OBJECT (layer)));
316
407
  if (merge_type == GIMP_FLATTEN_IMAGE ||
317
408
      gimp_drawable_type (GIMP_DRAWABLE (layer)) == GIMP_INDEXED_IMAGE)
318
409
    {
319
 
      type = GIMP_IMAGE_TYPE_FROM_BASE_TYPE (gimp_image_base_type (gimage));
 
410
      type = GIMP_IMAGE_TYPE_FROM_BASE_TYPE (gimp_image_base_type (image));
320
411
 
321
 
      merge_layer = gimp_layer_new (gimage, (x2 - x1), (y2 - y1),
 
412
      merge_layer = gimp_layer_new (image, (x2 - x1), (y2 - y1),
322
413
                                    type,
323
414
                                    gimp_object_get_name (GIMP_OBJECT (layer)),
324
415
                                    GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE);
332
423
      GIMP_ITEM (merge_layer)->offset_y = y1;
333
424
 
334
425
      /*  get the background for compositing  */
335
 
      gimp_image_get_background (gimage, GIMP_DRAWABLE (merge_layer),
336
 
                                 context, bg);
 
426
      gimp_image_get_background (image, context,
 
427
                                 gimp_drawable_type (GIMP_DRAWABLE (merge_layer)),
 
428
                                 bg);
337
429
 
338
430
      /*  init the pixel region  */
339
431
      pixel_region_init (&src1PR,
340
 
                         gimp_drawable_data (GIMP_DRAWABLE (merge_layer)),
 
432
                         gimp_drawable_get_tiles (GIMP_DRAWABLE (merge_layer)),
341
433
                         0, 0,
342
 
                         gimage->width, gimage->height,
 
434
                         image->width, image->height,
343
435
                         TRUE);
344
436
 
345
437
      /*  set the region to the background color  */
356
448
       */
357
449
 
358
450
      merge_layer =
359
 
        gimp_layer_new (gimage, (x2 - x1), (y2 - y1),
 
451
        gimp_layer_new (image, (x2 - x1), (y2 - y1),
360
452
                        gimp_drawable_type_with_alpha (GIMP_DRAWABLE (layer)),
361
453
                        "merged layer",
362
454
                        GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE);
372
464
 
373
465
      /*  Set the layer to transparent  */
374
466
      pixel_region_init (&src1PR,
375
 
                         gimp_drawable_data (GIMP_DRAWABLE (merge_layer)),
 
467
                         gimp_drawable_get_tiles (GIMP_DRAWABLE (merge_layer)),
376
468
                         0, 0,
377
469
                         (x2 - x1), (y2 - y1),
378
470
                         TRUE);
383
475
      /*  Find the index in the layer list of the bottom layer--we need this
384
476
       *  in order to add the final, merged layer to the layer list correctly
385
477
       */
386
 
      layer = (GimpLayer *) reverse_list->data;
 
478
      layer = reverse_list->data;
387
479
      position =
388
 
        gimp_container_num_children (gimage->layers) -
389
 
        gimp_container_get_child_index (gimage->layers, GIMP_OBJECT (layer));
 
480
        gimp_container_num_children (image->layers) -
 
481
        gimp_container_get_child_index (image->layers, GIMP_OBJECT (layer));
390
482
    }
391
483
 
392
484
  bottom_layer = layer;
403
495
    {
404
496
      GimpLayerModeEffects  mode;
405
497
 
406
 
      layer = (GimpLayer *) reverse_list->data;
 
498
      layer = reverse_list->data;
407
499
 
408
500
      /*  determine what sort of operation is being attempted and
409
501
       *  if it's actually legal...
427
519
 
428
520
      /* configure the pixel regions  */
429
521
      pixel_region_init (&src1PR,
430
 
                         gimp_drawable_data (GIMP_DRAWABLE (merge_layer)),
 
522
                         gimp_drawable_get_tiles (GIMP_DRAWABLE (merge_layer)),
431
523
                         (x3 - x1), (y3 - y1), (x4 - x3), (y4 - y3),
432
524
                         TRUE);
433
525
      pixel_region_init (&src2PR,
434
 
                         gimp_drawable_data (GIMP_DRAWABLE (layer)),
 
526
                         gimp_drawable_get_tiles (GIMP_DRAWABLE (layer)),
435
527
                         (x3 - off_x), (y3 - off_y),
436
528
                         (x4 - x3), (y4 - y3),
437
529
                         FALSE);
438
530
 
439
531
      if (layer->mask && layer->mask->apply_mask)
440
532
        {
441
 
          pixel_region_init (&maskPR,
442
 
                             gimp_drawable_data (GIMP_DRAWABLE (layer->mask)),
443
 
                             (x3 - off_x), (y3 - off_y),
444
 
                             (x4 - x3), (y4 - y3),
 
533
          TileManager *tiles;
 
534
 
 
535
          tiles = gimp_drawable_get_tiles (GIMP_DRAWABLE (layer->mask));
 
536
 
 
537
          pixel_region_init (&maskPR, tiles,
 
538
                             (x3 - off_x), (y3 - off_y), (x4 - x3), (y4 - y3),
445
539
                             FALSE);
446
540
          mask = &maskPR;
447
541
        }
464
558
                       active,
465
559
                       operation);
466
560
 
467
 
      gimp_image_remove_layer (gimage, layer);
 
561
      gimp_image_remove_layer (image, layer);
 
562
 
468
563
      reverse_list = g_slist_next (reverse_list);
469
564
    }
470
565
 
473
568
  /*  if the type is flatten, remove all the remaining layers  */
474
569
  if (merge_type == GIMP_FLATTEN_IMAGE)
475
570
    {
476
 
      list = GIMP_LIST (gimage->layers)->list;
 
571
      list = GIMP_LIST (image->layers)->list;
477
572
      while (list)
478
573
        {
479
 
          layer = (GimpLayer *) list->data;
 
574
          layer = list->data;
480
575
 
481
576
          list = g_list_next (list);
482
 
          gimp_image_remove_layer (gimage, layer);
 
577
          gimp_image_remove_layer (image, layer);
483
578
        }
484
579
 
485
 
      gimp_image_add_layer (gimage, merge_layer, position);
 
580
      gimp_image_add_layer (image, merge_layer, position);
486
581
    }
487
582
  else
488
583
    {
489
 
      /*  Add the layer to the gimage  */
490
 
      gimp_image_add_layer (gimage, merge_layer,
491
 
         gimp_container_num_children (gimage->layers) - position + 1);
 
584
      /*  Add the layer to the image  */
 
585
      gimp_image_add_layer (image, merge_layer,
 
586
         gimp_container_num_children (image->layers) - position + 1);
492
587
    }
493
588
 
494
589
  /* set the name after the original layers have been removed so we
495
590
   * don't end up with #2 appended to the name
496
591
   */
497
 
  gimp_object_set_name (GIMP_OBJECT (merge_layer), name);
498
 
  g_free (name);
 
592
  gimp_object_take_name (GIMP_OBJECT (merge_layer), name);
499
593
 
500
594
  gimp_item_set_visible (GIMP_ITEM (merge_layer), TRUE, TRUE);
501
595
 
502
596
  /*  End the merge undo group  */
503
 
  gimp_image_undo_group_end (gimage);
 
597
  gimp_image_undo_group_end (image);
504
598
 
505
599
  gimp_drawable_update (GIMP_DRAWABLE (merge_layer),
506
600
                        0, 0,
509
603
 
510
604
  return merge_layer;
511
605
}
512
 
 
513
 
/* merging vectors */
514
 
 
515
 
GimpVectors *
516
 
gimp_image_merge_visible_vectors (GimpImage *gimage)
517
 
{
518
 
  GList       *list           = NULL;
519
 
  GSList      *merge_list     = NULL;
520
 
  GSList      *cur_item       = NULL;
521
 
  GimpVectors *vectors        = NULL;
522
 
  GimpVectors *target_vectors = NULL;
523
 
  guchar      *name           = NULL;
524
 
  gint         pos            = 0;
525
 
 
526
 
  g_return_val_if_fail (GIMP_IS_IMAGE (gimage), NULL);
527
 
 
528
 
  for (list = GIMP_LIST (gimage->vectors)->list;
529
 
       list;
530
 
       list = g_list_next (list))
531
 
    {
532
 
      vectors = (GimpVectors *) list->data;
533
 
 
534
 
      if (gimp_item_get_visible (GIMP_ITEM (vectors)))
535
 
        merge_list = g_slist_append (merge_list, vectors);
536
 
    }
537
 
 
538
 
  if (merge_list && merge_list->next)
539
 
    {
540
 
      gimp_set_busy (gimage->gimp);
541
 
 
542
 
      gimp_image_undo_group_start (gimage, GIMP_UNDO_GROUP_IMAGE_VECTORS_MERGE,
543
 
                                   _("Merge Visible Paths"));
544
 
 
545
 
      cur_item = merge_list;
546
 
      vectors = GIMP_VECTORS (cur_item->data);
547
 
 
548
 
      name = g_strdup (gimp_object_get_name (GIMP_OBJECT (vectors)));
549
 
      target_vectors = GIMP_VECTORS (
550
 
                            gimp_item_duplicate (GIMP_ITEM (vectors),
551
 
                                                 GIMP_TYPE_VECTORS,
552
 
                                                 FALSE));
553
 
      pos = gimp_image_get_vectors_index (gimage, vectors);
554
 
      gimp_image_remove_vectors (gimage, vectors);
555
 
      cur_item = cur_item->next;
556
 
 
557
 
      while (cur_item)
558
 
        {
559
 
          vectors = GIMP_VECTORS (cur_item->data);
560
 
          gimp_vectors_add_strokes (vectors, target_vectors);
561
 
          gimp_image_remove_vectors (gimage, vectors);
562
 
 
563
 
          cur_item = g_slist_next (cur_item);
564
 
        }
565
 
 
566
 
      gimp_object_set_name (GIMP_OBJECT (target_vectors), name);
567
 
      g_free (name);
568
 
 
569
 
      g_slist_free (merge_list);
570
 
 
571
 
      gimp_image_add_vectors (gimage, target_vectors, pos);
572
 
      gimp_unset_busy (gimage->gimp);
573
 
 
574
 
      gimp_image_undo_group_end (gimage);
575
 
 
576
 
      return target_vectors;
577
 
    }
578
 
  else
579
 
    {
580
 
      g_message (_("Not enough visible paths for a merge. "
581
 
                   "There must be at least two."));
582
 
 
583
 
      return NULL;
584
 
    }
585
 
}
586