← Back to branch summary

~ubuntu-branches/ubuntu/saucy/gimp/saucy

« back to all changes in this revision

Viewing changes to plug-ins/common/compose.c

  • Committer: Package Import Robot
  • Author(s): Micah Gersten
  • Date: 2012-05-20 19:21:01 UTC
  • mfrom: (1.1.26) (0.4.16 sid)
  • Revision ID: package-import@ubuntu.com-20120520192101-bs7zetx8ffoq2nfv
Tags: 2.8.0-2ubuntu1
https://launchpad.net/bugs/908472
* Merge from Debian unstable (LP: #908472). Remaining Changes:
  - debian/patches/02_help-message.patch,
    debian/patches/03_gimp.desktop.in.in.patch:
    + Update some strings for Ubuntu
  - debian/control:
    + Update description
  - debian/rules:
    + Set gettext domain and update translation templates
* Drop the following patches that were applied upstream:
  - debian/patches/ghost-cursor.patch: fix Wacom tablet cursor events
  - debian/patches/embed-page-setup-dialog.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
plug-ins/common/compose.c
4
4
 * Compose plug-in (C) 1997,1999 Peter Kirchgessner
5
5
 * e-mail: peter@kirchgessner.net, WWW: http://www.kirchgessner.net
6
6
 *
7
 
 * This program is free software; you can redistribute it and/or modify
 
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
9
 
 * the Free Software Foundation; either version 2 of the License, or
 
9
 * the Free Software Foundation; either version 3 of the License, or
10
10
 * (at your option) any later version.
11
11
 *
12
12
 * This program is distributed in the hope that it will be useful,
15
15
 * GNU General Public License for more details.
16
16
 *
17
17
 * You should have received a copy of the GNU General Public License
18
 
 * along with this program; if not, write to the Free Software
19
 
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
18
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
20
19
 */
21
20
 
22
21
/*
44
43
#define DRAWABLE_COMPOSE_PROC "plug-in-drawable-compose"
45
44
#define RECOMPOSE_PROC        "plug-in-recompose"
46
45
#define PLUG_IN_BINARY        "compose"
 
46
#define PLUG_IN_ROLE          "gimp-compose"
47
47
 
48
48
 
49
49
typedef struct
176
176
 
177
177
  /*  Compose functon  */
178
178
  void  (* compose_fun) (guchar **src,
179
 
                         gint    *incr_src,
180
 
                         gint     numpix,
181
 
                         guchar  *dst,
 
179
                         gint    *incr_src,
 
180
                         gint     numpix,
 
181
                         guchar  *dst,
182
182
                         gboolean dst_has_alpha);
183
183
} COMPOSE_DSC;
184
184
 
344
344
{
345
345
  static GimpParamDef args[] =
346
346
  {
347
 
    { GIMP_PDB_INT32,    "run-mode",     "Interactive, non-interactive" },
 
347
    { GIMP_PDB_INT32,    "run-mode",     "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
348
348
    { GIMP_PDB_IMAGE,    "image1",       "First input image" },
349
349
    { GIMP_PDB_DRAWABLE, "drawable",     "Input drawable (not used)" },
350
350
    { GIMP_PDB_IMAGE,    "image2",       "Second input image" },
360
360
 
361
361
  static GimpParamDef drw_args[] =
362
362
  {
363
 
    { GIMP_PDB_INT32,    "run-mode",     "Interactive, non-interactive" },
 
363
    { GIMP_PDB_INT32,    "run-mode",     "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
364
364
    { GIMP_PDB_IMAGE,    "image1",       "First input image (not used)" },
365
365
    { GIMP_PDB_DRAWABLE, "drawable1",    "First input drawable" },
366
366
    { GIMP_PDB_DRAWABLE, "drawable2",    "Second input drawable" },
376
376
 
377
377
  static const GimpParamDef recompose_args[] =
378
378
  {
379
 
    { GIMP_PDB_INT32,    "run-mode", "Interactive, non-interactive" },
 
379
    { GIMP_PDB_INT32,    "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
380
380
    { GIMP_PDB_IMAGE,    "image",    "Image to recompose from" },
381
381
    { GIMP_PDB_DRAWABLE, "drawable", "Not used" },
382
382
  };
401
401
  drw_args[6].description = type_desc->str;
402
402
 
403
403
  gimp_install_procedure (COMPOSE_PROC,
404
 
                          N_("Create an image using multiple gray images as color channels"),
405
 
                          "This function creates a new image from "
406
 
                          "multiple gray images",
407
 
                          "Peter Kirchgessner",
408
 
                          "Peter Kirchgessner (peter@kirchgessner.net)",
409
 
                          "1997",
410
 
                          N_("C_ompose..."),
411
 
                          "GRAY*",
412
 
                          GIMP_PLUGIN,
413
 
                          G_N_ELEMENTS (args),
 
404
                          N_("Create an image using multiple gray images as color channels"),
 
405
                          "This function creates a new image from "
 
406
                          "multiple gray images",
 
407
                          "Peter Kirchgessner",
 
408
                          "Peter Kirchgessner (peter@kirchgessner.net)",
 
409
                          "1997",
 
410
                          N_("C_ompose..."),
 
411
                          "GRAY*",
 
412
                          GIMP_PLUGIN,
 
413
                          G_N_ELEMENTS (args),
414
414
                          G_N_ELEMENTS (return_vals),
415
 
                          args, return_vals);
 
415
                          args, return_vals);
416
416
 
417
417
  gimp_plugin_menu_register (COMPOSE_PROC, "<Image>/Colors/Components");
418
418
 
419
419
  gimp_install_procedure (DRAWABLE_COMPOSE_PROC,
420
 
                          "Compose an image from multiple drawables of gray images",
421
 
                          "This function creates a new image from "
422
 
                          "multiple drawables of gray images",
423
 
                          "Peter Kirchgessner",
424
 
                          "Peter Kirchgessner (peter@kirchgessner.net)",
425
 
                          "1998",
426
 
                          NULL,   /* It is not available in interactive mode */
427
 
                          "GRAY*",
428
 
                          GIMP_PLUGIN,
429
 
                          G_N_ELEMENTS (drw_args),
 
420
                          "Compose an image from multiple drawables of gray images",
 
421
                          "This function creates a new image from "
 
422
                          "multiple drawables of gray images",
 
423
                          "Peter Kirchgessner",
 
424
                          "Peter Kirchgessner (peter@kirchgessner.net)",
 
425
                          "1998",
 
426
                          NULL,   /* It is not available in interactive mode */
 
427
                          "GRAY*",
 
428
                          GIMP_PLUGIN,
 
429
                          G_N_ELEMENTS (drw_args),
430
430
                          G_N_ELEMENTS (drw_return_vals),
431
 
                          drw_args, drw_return_vals);
 
431
                          drw_args, drw_return_vals);
432
432
 
433
433
  gimp_install_procedure (RECOMPOSE_PROC,
434
 
                          N_("Recompose an image that was previously decomposed"),
435
 
                          "This function recombines the grayscale layers produced "
436
 
                          "by Decompose into a single RGB or RGBA layer, and "
 
434
                          N_("Recompose an image that was previously decomposed"),
 
435
                          "This function recombines the grayscale layers produced "
 
436
                          "by Decompose into a single RGB or RGBA layer, and "
437
437
                          "replaces the originally decomposed layer with the "
438
438
                          "result.",
439
 
                          "Bill Skaggs",
440
 
                          "Bill Skaggs",
441
 
                          "2004",
442
 
                          N_("R_ecompose"),
443
 
                          "GRAY*",
444
 
                          GIMP_PLUGIN,
445
 
                          G_N_ELEMENTS (recompose_args), 0,
446
 
                          recompose_args, NULL);
 
439
                          "Bill Skaggs",
 
440
                          "Bill Skaggs",
 
441
                          "2004",
 
442
                          N_("R_ecompose"),
 
443
                          "GRAY*",
 
444
                          GIMP_PLUGIN,
 
445
                          G_N_ELEMENTS (recompose_args), 0,
 
446
                          recompose_args, NULL);
447
447
 
448
448
  gimp_plugin_menu_register (RECOMPOSE_PROC, "<Image>/Colors/Components");
449
449
 
480
480
 
481
481
  if (strcmp (name, RECOMPOSE_PROC) == 0)
482
482
    {
483
 
      GimpParasite *parasite = gimp_image_parasite_find (param[1].data.d_image,
484
 
                                                         "decompose-data");
 
483
      GimpParasite *parasite = gimp_image_get_parasite (param[1].data.d_image,
 
484
                                                        "decompose-data");
485
485
 
486
486
      if (! parasite)
487
487
        {
616
616
                          compose_by_drawable);
617
617
 
618
618
      if (image_ID < 0)
619
 
        {
620
 
          status = GIMP_PDB_EXECUTION_ERROR;
621
 
        }
 
619
        {
 
620
          status = GIMP_PDB_EXECUTION_ERROR;
 
621
        }
622
622
      else
623
 
        {
624
 
          values[1].data.d_int32 = image_ID;
 
623
        {
 
624
          values[1].data.d_int32 = image_ID;
625
625
 
626
626
          if (composevals.do_recompose)
627
627
            {
635
635
              if (run_mode != GIMP_RUN_NONINTERACTIVE)
636
636
                gimp_display_new (image_ID);
637
637
            }
638
 
        }
 
638
        }
639
639
 
640
640
      /*  Store data  */
641
641
      if (run_mode == GIMP_RUN_INTERACTIVE)
703
703
  /* Check image sizes */
704
704
  if (compose_by_drawable)
705
705
    {
706
 
      if (! gimp_drawable_is_valid (inputs[first_ID].comp.ID))
 
706
      if (! gimp_item_is_valid (inputs[first_ID].comp.ID))
707
707
        {
708
708
          g_message (_("Specified layer %d not found"),
709
709
                     inputs[first_ID].comp.ID);
714
714
      height = gimp_drawable_height (inputs[first_ID].comp.ID);
715
715
 
716
716
      for (j = first_ID + 1; j < num_images; j++)
717
 
        {
 
717
        {
718
718
          if (inputs[j].is_ID)
719
719
            {
720
 
              if (! gimp_drawable_is_valid (inputs[j].comp.ID))
 
720
              if (! gimp_item_is_valid (inputs[j].comp.ID))
721
721
                {
722
722
                  g_message (_("Specified layer %d not found"),
723
723
                             inputs[j].comp.ID);
731
731
                  return -1;
732
732
                }
733
733
            }
734
 
        }
 
734
        }
735
735
      for (j = 0; j < num_images; j++)
736
736
        {
737
737
          if (inputs[j].is_ID)
746
746
      height = gimp_image_height (inputs[first_ID].comp.ID);
747
747
 
748
748
      for (j = first_ID + 1; j < num_images; j++)
749
 
        {
 
749
        {
750
750
          if (inputs[j].is_ID)
751
751
            {
752
752
              if ((width  != gimp_image_width (inputs[j].comp.ID)) ||
756
756
                  return -1;
757
757
                }
758
758
            }
759
 
        }
 
759
        }
760
760
 
761
761
      /* Get first layer/drawable for all input images */
762
762
      for (j = 0; j < num_images; j++)
763
 
        {
 
763
        {
764
764
          if (inputs[j].is_ID)
765
765
            {
766
766
              gint32 *layers;
778
778
              drawable_src[j] = gimp_drawable_get (layers[0]);
779
779
              g_free (layers);
780
780
            }
781
 
        }
 
781
        }
782
782
    }
783
783
 
784
784
  /* Get pixel region for all input drawables */
819
819
    {
820
820
      layer_ID_dst = composevals.source_layer_ID;
821
821
 
822
 
      if (! gimp_drawable_is_valid (layer_ID_dst))
 
822
      if (! gimp_item_is_valid (layer_ID_dst))
823
823
        {
824
824
          g_message (_("Unable to recompose, source layer not found"));
825
825
          return -1;
832
832
      gimp_pixel_rgn_init (&pixel_rgn_dst_read, drawable_dst,
833
833
                           0, 0, drawable_dst->width, drawable_dst->height,
834
834
                           FALSE, FALSE);
835
 
      image_ID_dst = gimp_drawable_get_image (layer_ID_dst);
 
835
      image_ID_dst = gimp_item_get_image (layer_ID_dst);
836
836
    }
837
837
  else
838
838
    {
868
868
                                   width, scan_lines);
869
869
 
870
870
      if (composevals.do_recompose)
871
 
        gimp_pixel_rgn_get_rect (&pixel_rgn_dst_read, dst, 0, i,
872
 
                                 width, scan_lines);
 
871
        gimp_pixel_rgn_get_rect (&pixel_rgn_dst_read, dst, 0, i,
 
872
                                 width, scan_lines);
873
873
 
874
874
      /* Do the composition */
875
875
      compose_dsc[compose_idx].compose_fun (src,
876
 
                                            incr_src,
877
 
                                            width * tile_height,
878
 
                                            dst,
 
876
                                            incr_src,
 
877
                                            width * tile_height,
 
878
                                            dst,
879
879
                                            gimp_drawable_has_alpha (layer_ID_dst));
880
880
 
881
881
      /* Set destination pixel region */
885
885
 
886
886
      gimp_progress_update ((gdouble) i / (gdouble) height);
887
887
    }
 
888
  gimp_progress_update (1.0);
888
889
 
889
890
  for (j = 0; j < num_images; j++)
890
891
    {
933
934
  gimp_image_set_filename (image_ID, filename);
934
935
 
935
936
  *layer_ID = gimp_layer_new (image_ID, _("Background"), width, height,
936
 
                              gdtype, 100, GIMP_NORMAL_MODE);
937
 
  gimp_image_add_layer (image_ID, *layer_ID, 0);
 
937
                              gdtype, 100, GIMP_NORMAL_MODE);
 
938
  gimp_image_insert_layer (image_ID, *layer_ID, -1, 0);
938
939
 
939
940
  *drawable = gimp_drawable_get (*layer_ID);
940
941
  gimp_pixel_rgn_init (pixel_rgn, *drawable, 0, 0, (*drawable)->width,
941
 
                       (*drawable)->height, TRUE, FALSE);
 
942
                       (*drawable)->height, TRUE, FALSE);
942
943
 
943
944
  return image_ID;
944
945
}
962
963
  if ((red_incr == 1) && (green_incr == 1) && (blue_incr == 1))
963
964
    {
964
965
      while (count-- > 0)
965
 
        {
966
 
          *(rgb_dst++) = *(red_src++);
967
 
          *(rgb_dst++) = *(green_src++);
968
 
          *(rgb_dst++) = *(blue_src++);
 
966
        {
 
967
          *(rgb_dst++) = *(red_src++);
 
968
          *(rgb_dst++) = *(green_src++);
 
969
          *(rgb_dst++) = *(blue_src++);
969
970
          if (dst_has_alpha)
970
971
            rgb_dst++;
971
 
        }
 
972
        }
972
973
    }
973
974
  else
974
975
    {
975
976
      while (count-- > 0)
976
 
        {
977
 
          *(rgb_dst++) = *red_src;     red_src += red_incr;
978
 
          *(rgb_dst++) = *green_src;   green_src += green_incr;
979
 
          *(rgb_dst++) = *blue_src;    blue_src += blue_incr;
 
977
        {
 
978
          *(rgb_dst++) = *red_src;     red_src += red_incr;
 
979
          *(rgb_dst++) = *green_src;   green_src += green_incr;
 
980
          *(rgb_dst++) = *blue_src;    blue_src += blue_incr;
980
981
          if (dst_has_alpha)
981
982
            rgb_dst++;
982
 
        }
 
983
        }
983
984
    }
984
985
}
985
986
 
1006
1007
      (alpha_incr == 1))
1007
1008
    {
1008
1009
      while (count-- > 0)
1009
 
        {
1010
 
          *(rgb_dst++) = *(red_src++);
1011
 
          *(rgb_dst++) = *(green_src++);
1012
 
          *(rgb_dst++) = *(blue_src++);
1013
 
          *(rgb_dst++) = *(alpha_src++);
1014
 
        }
 
1010
        {
 
1011
          *(rgb_dst++) = *(red_src++);
 
1012
          *(rgb_dst++) = *(green_src++);
 
1013
          *(rgb_dst++) = *(blue_src++);
 
1014
          *(rgb_dst++) = *(alpha_src++);
 
1015
        }
1015
1016
    }
1016
1017
  else
1017
1018
    {
1018
1019
      while (count-- > 0)
1019
 
        {
1020
 
          *(rgb_dst++) = *red_src;    red_src += red_incr;
1021
 
          *(rgb_dst++) = *green_src;  green_src += green_incr;
1022
 
          *(rgb_dst++) = *blue_src;   blue_src += blue_incr;
1023
 
          *(rgb_dst++) = *alpha_src;  alpha_src += alpha_incr;
1024
 
        }
 
1020
        {
 
1021
          *(rgb_dst++) = *red_src;    red_src += red_incr;
 
1022
          *(rgb_dst++) = *green_src;  green_src += green_incr;
 
1023
          *(rgb_dst++) = *blue_src;   blue_src += blue_incr;
 
1024
          *(rgb_dst++) = *alpha_src;  alpha_src += alpha_incr;
 
1025
        }
1025
1026
    }
1026
1027
}
1027
1028
 
1045
1046
  while (count-- > 0)
1046
1047
    {
1047
1048
      gimp_hsv_to_rgb4 (rgb_dst, (gdouble) *hue_src / 255.0,
1048
 
                                 (gdouble) *sat_src / 255.0,
1049
 
                                 (gdouble) *val_src / 255.0);
 
1049
                                 (gdouble) *sat_src / 255.0,
 
1050
                                 (gdouble) *val_src / 255.0);
1050
1051
      rgb_dst += 3;
1051
1052
      hue_src += hue_incr;
1052
1053
      sat_src += sat_incr;
1115
1116
  if ((cyan_incr == 1) && (magenta_incr == 1) && (yellow_incr == 1))
1116
1117
    {
1117
1118
      while (count-- > 0)
1118
 
        {
1119
 
          *(rgb_dst++) = 255 - *(cyan_src++);
1120
 
          *(rgb_dst++) = 255 - *(magenta_src++);
1121
 
          *(rgb_dst++) = 255 - *(yellow_src++);
 
1119
        {
 
1120
          *(rgb_dst++) = 255 - *(cyan_src++);
 
1121
          *(rgb_dst++) = 255 - *(magenta_src++);
 
1122
          *(rgb_dst++) = 255 - *(yellow_src++);
1122
1123
          if (dst_has_alpha)
1123
1124
            rgb_dst++;
1124
 
        }
 
1125
        }
1125
1126
    }
1126
1127
  else
1127
1128
    {
1128
1129
      while (count-- > 0)
1129
 
        {
1130
 
          *(rgb_dst++) = 255 - *cyan_src;
1131
 
          *(rgb_dst++) = 255 - *magenta_src;
1132
 
          *(rgb_dst++) = 255 - *yellow_src;
1133
 
          cyan_src += cyan_incr;
1134
 
          magenta_src += magenta_incr;
1135
 
          yellow_src += yellow_incr;
 
1130
        {
 
1131
          *(rgb_dst++) = 255 - *cyan_src;
 
1132
          *(rgb_dst++) = 255 - *magenta_src;
 
1133
          *(rgb_dst++) = 255 - *yellow_src;
 
1134
          cyan_src += cyan_incr;
 
1135
          magenta_src += magenta_incr;
 
1136
          yellow_src += yellow_incr;
1136
1137
          if (dst_has_alpha)
1137
1138
            rgb_dst++;
1138
 
        }
 
1139
        }
1139
1140
    }
1140
1141
}
1141
1142
 
1159
1160
  gint    black_incr   = incr_src[3];
1160
1161
  GimpRGB grgb;
1161
1162
 
1162
 
  gimp_rgb_set (&grgb, 0, 0, 0);
 
1163
  gimp_rgb_set(&grgb, 0, 0, 0);
1163
1164
 
1164
1165
  while (count-- > 0)
1165
1166
    {
1167
1168
      guchar   r, g, b;
1168
1169
 
1169
1170
      gimp_cmyk_set_uchar (&gcmyk,
1170
 
                           *cyan_src, *magenta_src, *yellow_src, *black_src);
 
1171
                           *cyan_src, *magenta_src, *yellow_src,
 
1172
                           *black_src);
1171
1173
      gimp_cmyk_to_rgb (&gcmyk, &grgb);
1172
1174
      gimp_rgb_get_uchar (&grgb, &r, &g, &b);
1173
1175
 
1475
1477
 
1476
1478
  gimp_ui_init (PLUG_IN_BINARY, TRUE);
1477
1479
 
1478
 
  layer_list = gimp_image_get_layers (gimp_drawable_get_image (drawable_ID),
 
1480
  layer_list = gimp_image_get_layers (gimp_item_get_image (drawable_ID),
1479
1481
                                      &nlayers);
1480
1482
 
1481
 
  dialog = gimp_dialog_new (_("Compose"), PLUG_IN_BINARY,
 
1483
  dialog = gimp_dialog_new (_("Compose"), PLUG_IN_ROLE,
1482
1484
                            NULL, 0,
1483
1485
                            gimp_standard_help_func, COMPOSE_PROC,
1484
1486
 
1498
1500
 
1499
1501
  gimp_window_set_transient (GTK_WINDOW (dialog));
1500
1502
 
1501
 
  main_vbox = gtk_vbox_new (FALSE, 12);
 
1503
  main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
1502
1504
  gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
1503
 
  gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox);
 
1505
  gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
 
1506
                      main_vbox, TRUE, TRUE, 0);
1504
1507
  gtk_widget_show (main_vbox);
1505
1508
 
1506
1509
  /* Compose type combo */
1509
1512
  gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
1510
1513
  gtk_widget_show (frame);
1511
1514
 
1512
 
  hbox = gtk_hbox_new (FALSE, 6);
 
1515
  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
1513
1516
  gtk_container_add (GTK_CONTAINER (frame), hbox);
1514
1517
  gtk_widget_show (hbox);
1515
1518
 
1551
1554
  gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
1552
1555
  gtk_widget_show (frame);
1553
1556
 
1554
 
  vbox = gtk_vbox_new (FALSE, 6);
 
1557
  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
1555
1558
  gtk_container_add (GTK_CONTAINER (frame), vbox);
1556
1559
  gtk_widget_show (vbox);
1557
1560
 
1571
1574
      GtkTreeModel *model;
1572
1575
      GdkPixbuf    *ico;
1573
1576
 
1574
 
      hbox = gtk_hbox_new (FALSE, 6);
 
1577
      hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
1575
1578
      gtk_table_attach (GTK_TABLE (table), hbox, 0, 1, j, j + 1,
1576
1579
                        GTK_FILL, GTK_FILL, 0, 0);
1577
1580
      gtk_widget_show (hbox);
1615
1618
                          -1);
1616
1619
      g_object_unref (ico);
1617
1620
      gtk_table_attach (GTK_TABLE (table), combo, 1, 2, j, j + 1,
1618
 
                        GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 
1621
                        GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
1619
1622
      gtk_widget_show (combo);
1620
1623
 
1621
1624
      gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
1687
1690
 
1688
1691
{
1689
1692
  return ((gimp_image_base_type (image_id) == GIMP_GRAY) &&
1690
 
          (gimp_image_width  (image_id) == composeint.width) &&
1691
 
          (gimp_image_height (image_id) == composeint.height));
 
1693
          (gimp_image_width  (image_id) == composeint.width) &&
 
1694
          (gimp_image_height (image_id) == composeint.height));
1692
1695
}
1693
1696
 
1694
1697
static void