[gimp] app, libgimp, pdb, plug-ins: update some more functions to get|set().



commit fa161527577d29499fac40da340e3baa6c853932
Author: Jehan <jehan girinstud io>
Date:   Tue Apr 6 00:47:07 2021 +0200

    app, libgimp, pdb, plug-ins: update some more functions to get|set().
    
    s/gimp_image_base_type/gimp_image_get_base_type/
    s/gimp_image_width/gimp_image_get_width/
    s/gimp_image_height/gimp_image_get_height/
    
    Sorry plug-in developers, more porting work! But really this seems like
    the right thing to do in order not to get stuck with inconsistent naming
    for many more years to come.

 app/pdb/image-cmds.c                     | 54 ++++++++++++++++----------------
 libgimp/gimp.def                         |  6 ++--
 libgimp/gimpexport.c                     | 34 ++++++++++----------
 libgimp/gimpimage_pdb.c                  | 18 +++++------
 libgimp/gimpimage_pdb.h                  |  6 ++--
 libgimp/gimpimagemetadata-save.c         |  8 ++---
 libgimp/gimplayer.c                      |  4 +--
 pdb/groups/image.pdb                     | 10 +++---
 plug-ins/common/animation-optimize.c     |  6 ++--
 plug-ins/common/animation-play.c         |  4 +--
 plug-ins/common/colormap-remap.c         |  2 +-
 plug-ins/common/compose.c                | 14 ++++-----
 plug-ins/common/curve-bend.c             |  2 +-
 plug-ins/common/file-gif-load.c          |  4 +--
 plug-ins/common/file-gif-save.c          |  8 ++---
 plug-ins/common/file-gih.c               | 12 +++----
 plug-ins/common/file-html-table.c        |  2 +-
 plug-ins/common/file-mng.c               |  6 ++--
 plug-ins/common/file-pdf-save.c          |  8 ++---
 plug-ins/common/file-ps.c                |  4 +--
 plug-ins/common/film.c                   | 12 +++----
 plug-ins/common/grid.c                   |  2 +-
 plug-ins/common/guillotine.c             |  4 +--
 plug-ins/file-dds/ddswrite.c             | 26 +++++++--------
 plug-ins/file-fli/fli-gimp.c             |  6 ++--
 plug-ins/file-ico/ico-dialog.c           |  4 +--
 plug-ins/file-ico/ico-save.c             |  2 +-
 plug-ins/file-psd/psd-image-res-load.c   |  4 +--
 plug-ins/file-psd/psd-save.c             | 14 ++++-----
 plug-ins/file-tiff/file-tiff-save.c      |  6 ++--
 plug-ins/file-tiff/file-tiff.c           |  2 +-
 plug-ins/imagemap/imap_cmd_gimp_guides.c |  4 +--
 plug-ins/imagemap/imap_main.c            |  4 +--
 33 files changed, 151 insertions(+), 151 deletions(-)
---
diff --git a/app/pdb/image-cmds.c b/app/pdb/image-cmds.c
index f3e91573e7..0b67ca6343 100644
--- a/app/pdb/image-cmds.c
+++ b/app/pdb/image-cmds.c
@@ -272,12 +272,12 @@ image_delete_invoker (GimpProcedure         *procedure,
 }
 
 static GimpValueArray *
-image_base_type_invoker (GimpProcedure         *procedure,
-                         Gimp                  *gimp,
-                         GimpContext           *context,
-                         GimpProgress          *progress,
-                         const GimpValueArray  *args,
-                         GError               **error)
+image_get_base_type_invoker (GimpProcedure         *procedure,
+                             Gimp                  *gimp,
+                             GimpContext           *context,
+                             GimpProgress          *progress,
+                             const GimpValueArray  *args,
+                             GError               **error)
 {
   gboolean success = TRUE;
   GimpValueArray *return_vals;
@@ -359,12 +359,12 @@ image_get_default_new_layer_mode_invoker (GimpProcedure         *procedure,
 }
 
 static GimpValueArray *
-image_width_invoker (GimpProcedure         *procedure,
-                     Gimp                  *gimp,
-                     GimpContext           *context,
-                     GimpProgress          *progress,
-                     const GimpValueArray  *args,
-                     GError               **error)
+image_get_width_invoker (GimpProcedure         *procedure,
+                         Gimp                  *gimp,
+                         GimpContext           *context,
+                         GimpProgress          *progress,
+                         const GimpValueArray  *args,
+                         GError               **error)
 {
   gboolean success = TRUE;
   GimpValueArray *return_vals;
@@ -388,12 +388,12 @@ image_width_invoker (GimpProcedure         *procedure,
 }
 
 static GimpValueArray *
-image_height_invoker (GimpProcedure         *procedure,
-                      Gimp                  *gimp,
-                      GimpContext           *context,
-                      GimpProgress          *progress,
-                      const GimpValueArray  *args,
-                      GError               **error)
+image_get_height_invoker (GimpProcedure         *procedure,
+                          Gimp                  *gimp,
+                          GimpContext           *context,
+                          GimpProgress          *progress,
+                          const GimpValueArray  *args,
+                          GError               **error)
 {
   gboolean success = TRUE;
   GimpValueArray *return_vals;
@@ -3112,11 +3112,11 @@ register_image_procs (GimpPDB *pdb)
   g_object_unref (procedure);
 
   /*
-   * gimp-image-base-type
+   * gimp-image-get-base-type
    */
-  procedure = gimp_procedure_new (image_base_type_invoker);
+  procedure = gimp_procedure_new (image_get_base_type_invoker);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
-                               "gimp-image-base-type");
+                               "gimp-image-get-base-type");
   gimp_procedure_set_static_help (procedure,
                                   "Get the base type of the image.",
                                   "This procedure returns the image's base type. Layers in the image must be 
of this subtype, but can have an optional alpha channel.",
@@ -3202,11 +3202,11 @@ register_image_procs (GimpPDB *pdb)
   g_object_unref (procedure);
 
   /*
-   * gimp-image-width
+   * gimp-image-get-width
    */
-  procedure = gimp_procedure_new (image_width_invoker);
+  procedure = gimp_procedure_new (image_get_width_invoker);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
-                               "gimp-image-width");
+                               "gimp-image-get-width");
   gimp_procedure_set_static_help (procedure,
                                   "Return the width of the image",
                                   "This procedure returns the image's width. This value is independent of 
any of the layers in this image. This is the \"canvas\" width.",
@@ -3231,11 +3231,11 @@ register_image_procs (GimpPDB *pdb)
   g_object_unref (procedure);
 
   /*
-   * gimp-image-height
+   * gimp-image-get-height
    */
-  procedure = gimp_procedure_new (image_height_invoker);
+  procedure = gimp_procedure_new (image_get_height_invoker);
   gimp_object_set_static_name (GIMP_OBJECT (procedure),
-                               "gimp-image-height");
+                               "gimp-image-get-height");
   gimp_procedure_set_static_help (procedure,
                                   "Return the height of the image",
                                   "This procedure returns the image's height. This value is independent of 
any of the layers in this image. This is the \"canvas\" height.",
diff --git a/libgimp/gimp.def b/libgimp/gimp.def
index da2b342fec..c8ab391faf 100644
--- a/libgimp/gimp.def
+++ b/libgimp/gimp.def
@@ -352,7 +352,6 @@ EXPORTS
        gimp_image_add_sample_point
        gimp_image_add_vguide
        gimp_image_attach_parasite
-       gimp_image_base_type
        gimp_image_clean_all
        gimp_image_convert_color_profile
        gimp_image_convert_color_profile_from_file
@@ -379,6 +378,7 @@ EXPORTS
        gimp_image_get_active_drawable
        gimp_image_get_active_layer
        gimp_image_get_active_vectors
+       gimp_image_get_base_type
        gimp_image_get_by_id
        gimp_image_get_channel_by_name
        gimp_image_get_channel_by_tattoo
@@ -394,6 +394,7 @@ EXPORTS
        gimp_image_get_floating_sel
        gimp_image_get_guide_orientation
        gimp_image_get_guide_position
+       gimp_image_get_height
        gimp_image_get_id
        gimp_image_get_imported_file
        gimp_image_get_item_position
@@ -417,6 +418,7 @@ EXPORTS
        gimp_image_get_vectors
        gimp_image_get_vectors_by_name
        gimp_image_get_vectors_by_tattoo
+       gimp_image_get_width
        gimp_image_get_xcf_file
        gimp_image_grid_get_background_color
        gimp_image_grid_get_foreground_color
@@ -428,7 +430,6 @@ EXPORTS
        gimp_image_grid_set_offset
        gimp_image_grid_set_spacing
        gimp_image_grid_set_style
-       gimp_image_height
        gimp_image_id_is_valid
        gimp_image_insert_channel
        gimp_image_insert_layer
@@ -500,7 +501,6 @@ EXPORTS
        gimp_image_undo_is_enabled
        gimp_image_undo_thaw
        gimp_image_unset_active_channel
-       gimp_image_width
        gimp_item_attach_parasite
        gimp_item_delete
        gimp_item_detach_parasite
diff --git a/libgimp/gimpexport.c b/libgimp/gimpexport.c
index 635ffe1722..f1cc7dec77 100644
--- a/libgimp/gimpexport.c
+++ b/libgimp/gimpexport.c
@@ -94,7 +94,7 @@ export_merge (GimpImage  *image,
        * merge that follows will ensure that the offset, opacity and
        * size are correct
        */
-      switch (gimp_image_base_type (image))
+      switch (gimp_image_get_base_type (image))
         {
         case GIMP_RGB:
           layer_type = GIMP_RGBA_IMAGE;
@@ -110,8 +110,8 @@ export_merge (GimpImage  *image,
           g_return_if_reached ();
         }
       transp = gimp_layer_new (image, "-",
-                               gimp_image_width (image),
-                               gimp_image_height (image),
+                               gimp_image_get_width (image),
+                               gimp_image_get_height (image),
                                layer_type,
                                100.0, GIMP_LAYER_MODE_NORMAL);
       gimp_image_insert_layer (image, transp, NULL, 1);
@@ -135,17 +135,17 @@ export_merge (GimpImage  *image,
       layers = gimp_image_list_layers (image);
 
       /*  make sure that the merged drawable matches the image size  */
-      if (gimp_drawable_width  (GIMP_DRAWABLE (merged)) !=
-          gimp_image_width  (image) ||
-          gimp_drawable_height (GIMP_DRAWABLE (merged)) !=
-          gimp_image_height (image))
+      if (gimp_drawable_width   (GIMP_DRAWABLE (merged)) !=
+          gimp_image_get_width  (image) ||
+          gimp_drawable_height  (GIMP_DRAWABLE (merged)) !=
+          gimp_image_get_height (image))
         {
           gint off_x, off_y;
 
           gimp_drawable_offsets (GIMP_DRAWABLE (merged), &off_x, &off_y);
           gimp_layer_resize (merged,
-                             gimp_image_width (image),
-                             gimp_image_height (image),
+                             gimp_image_get_width (image),
+                             gimp_image_get_height (image),
                              off_x, off_y);
         }
     }
@@ -271,7 +271,7 @@ static void
 export_convert_bitmap (GimpImage  *image,
                        GList     **drawables)
 {
-  if (gimp_image_base_type (image) == GIMP_INDEXED)
+  if (gimp_image_get_base_type (image) == GIMP_INDEXED)
     gimp_image_convert_rgb (image);
 
   gimp_image_convert_indexed (image,
@@ -303,8 +303,8 @@ export_crop_image (GimpImage  *image,
                    GList     **drawables)
 {
   gimp_image_crop (image,
-                   gimp_image_width  (image),
-                   gimp_image_height (image),
+                   gimp_image_get_width  (image),
+                   gimp_image_get_height (image),
                    0, 0);
 }
 
@@ -935,8 +935,8 @@ gimp_export_image (GimpImage               **image,
 
           image_bounds.x      = 0;
           image_bounds.y      = 0;
-          image_bounds.width  = gimp_image_width  (*image);
-          image_bounds.height = gimp_image_height (*image);
+          image_bounds.width  = gimp_image_get_width  (*image);
+          image_bounds.height = gimp_image_get_height (*image);
 
           for (iter = layers; iter; iter = iter->next)
             {
@@ -977,9 +977,9 @@ gimp_export_image (GimpImage               **image,
           gimp_drawable_offsets (drawable, &offset_x, &offset_y);
 
           if ((gimp_layer_get_opacity (GIMP_LAYER (drawable)) < 100.0) ||
-              (gimp_image_width (*image) !=
+              (gimp_image_get_width (*image) !=
                gimp_drawable_width (drawable))            ||
-              (gimp_image_height (*image) !=
+              (gimp_image_get_height (*image) !=
                gimp_drawable_height (drawable))           ||
               offset_x || offset_y)
             {
@@ -1043,7 +1043,7 @@ gimp_export_image (GimpImage               **image,
   g_list_free (layers);
 
   /* check the image type */
-  type = gimp_image_base_type (*image);
+  type = gimp_image_get_base_type (*image);
   switch (type)
     {
     case GIMP_RGB:
diff --git a/libgimp/gimpimage_pdb.c b/libgimp/gimpimage_pdb.c
index 44fd332c46..7b9726daac 100644
--- a/libgimp/gimpimage_pdb.c
+++ b/libgimp/gimpimage_pdb.c
@@ -284,7 +284,7 @@ gimp_image_delete (GimpImage *image)
 }
 
 /**
- * gimp_image_base_type:
+ * gimp_image_get_base_type:
  * @image: The image.
  *
  * Get the base type of the image.
@@ -295,7 +295,7 @@ gimp_image_delete (GimpImage *image)
  * Returns: The image's base type.
  **/
 GimpImageBaseType
-gimp_image_base_type (GimpImage *image)
+gimp_image_get_base_type (GimpImage *image)
 {
   GimpValueArray *args;
   GimpValueArray *return_vals;
@@ -306,7 +306,7 @@ gimp_image_base_type (GimpImage *image)
                                           G_TYPE_NONE);
 
   return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
-                                              "gimp-image-base-type",
+                                              "gimp-image-get-base-type",
                                               args);
   gimp_value_array_unref (args);
 
@@ -391,7 +391,7 @@ gimp_image_get_default_new_layer_mode (GimpImage *image)
 }
 
 /**
- * gimp_image_width:
+ * gimp_image_get_width:
  * @image: The image.
  *
  * Return the width of the image
@@ -402,7 +402,7 @@ gimp_image_get_default_new_layer_mode (GimpImage *image)
  * Returns: The image's width.
  **/
 gint
-gimp_image_width (GimpImage *image)
+gimp_image_get_width (GimpImage *image)
 {
   GimpValueArray *args;
   GimpValueArray *return_vals;
@@ -413,7 +413,7 @@ gimp_image_width (GimpImage *image)
                                           G_TYPE_NONE);
 
   return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
-                                              "gimp-image-width",
+                                              "gimp-image-get-width",
                                               args);
   gimp_value_array_unref (args);
 
@@ -426,7 +426,7 @@ gimp_image_width (GimpImage *image)
 }
 
 /**
- * gimp_image_height:
+ * gimp_image_get_height:
  * @image: The image.
  *
  * Return the height of the image
@@ -437,7 +437,7 @@ gimp_image_width (GimpImage *image)
  * Returns: The image's height.
  **/
 gint
-gimp_image_height (GimpImage *image)
+gimp_image_get_height (GimpImage *image)
 {
   GimpValueArray *args;
   GimpValueArray *return_vals;
@@ -448,7 +448,7 @@ gimp_image_height (GimpImage *image)
                                           G_TYPE_NONE);
 
   return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
-                                              "gimp-image-height",
+                                              "gimp-image-get-height",
                                               args);
   gimp_value_array_unref (args);
 
diff --git a/libgimp/gimpimage_pdb.h b/libgimp/gimpimage_pdb.h
index ddeae7578c..a994a71cc7 100644
--- a/libgimp/gimpimage_pdb.h
+++ b/libgimp/gimpimage_pdb.h
@@ -43,11 +43,11 @@ GimpImage*               gimp_image_new_with_precision         (gint
                                                                 GimpPrecision        precision);
 GimpImage*               gimp_image_duplicate                  (GimpImage           *image);
 gboolean                 gimp_image_delete                     (GimpImage           *image);
-GimpImageBaseType        gimp_image_base_type                  (GimpImage           *image);
+GimpImageBaseType        gimp_image_get_base_type              (GimpImage           *image);
 GimpPrecision            gimp_image_get_precision              (GimpImage           *image);
 GimpLayerMode            gimp_image_get_default_new_layer_mode (GimpImage           *image);
-gint                     gimp_image_width                      (GimpImage           *image);
-gint                     gimp_image_height                     (GimpImage           *image);
+gint                     gimp_image_get_width                  (GimpImage           *image);
+gint                     gimp_image_get_height                 (GimpImage           *image);
 GimpLayer**              gimp_image_get_layers                 (GimpImage           *image,
                                                                 gint                *num_layers);
 GimpChannel**            gimp_image_get_channels               (GimpImage           *image,
diff --git a/libgimp/gimpimagemetadata-save.c b/libgimp/gimpimagemetadata-save.c
index f310966fa2..ff9ba52fab 100644
--- a/libgimp/gimpimagemetadata-save.c
+++ b/libgimp/gimpimagemetadata-save.c
@@ -94,8 +94,8 @@ gimp_image_metadata_save_prepare (GimpImage             *image,
       gchar          *str;
       GExiv2Metadata *g2metadata = GEXIV2_METADATA (metadata);
 
-      image_width  = gimp_image_width  (image);
-      image_height = gimp_image_height (image);
+      image_width  = gimp_image_get_width  (image);
+      image_height = gimp_image_get_height (image);
 
       datetime = g_date_time_new_now_local ();
 
@@ -587,8 +587,8 @@ gimp_image_metadata_save_finish (GimpImage              *image,
 
 #define EXIF_THUMBNAIL_SIZE 256
 
-      image_width  = gimp_image_width  (image);
-      image_height = gimp_image_height (image);
+      image_width  = gimp_image_get_width  (image);
+      image_height = gimp_image_get_height (image);
 
       if (image_width > image_height)
         {
diff --git a/libgimp/gimplayer.c b/libgimp/gimplayer.c
index 2e97187274..7737b5b589 100644
--- a/libgimp/gimplayer.c
+++ b/libgimp/gimplayer.c
@@ -182,7 +182,7 @@ gimp_layer_new_from_pixbuf (GimpImage     *image,
 
   g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL);
 
-  if (gimp_image_base_type (image) != GIMP_RGB)
+  if (gimp_image_get_base_type (image) != GIMP_RGB)
     {
       g_warning ("gimp_layer_new_from_pixbuf() needs an RGB image");
       return NULL;
@@ -262,7 +262,7 @@ gimp_layer_new_from_surface (GimpImage            *image,
   g_return_val_if_fail (cairo_surface_get_type (surface) ==
                         CAIRO_SURFACE_TYPE_IMAGE, NULL);
 
-  if (gimp_image_base_type (image) != GIMP_RGB)
+  if (gimp_image_get_base_type (image) != GIMP_RGB)
     {
       g_warning ("gimp_layer_new_from_surface() needs an RGB image");
       return NULL;
diff --git a/pdb/groups/image.pdb b/pdb/groups/image.pdb
index 9b1ae0aea1..fb6006b039 100644
--- a/pdb/groups/image.pdb
+++ b/pdb/groups/image.pdb
@@ -1432,7 +1432,7 @@ CODE
     );
 }
 
-sub image_base_type {
+sub image_get_base_type {
     $blurb = 'Get the base type of the image.';
 
     $help = <<'HELP';
@@ -1766,7 +1766,7 @@ CODE
     );
 }
 
-sub image_width {
+sub image_get_width {
     $blurb = 'Return the width of the image';
 
     $help = <<'HELP';
@@ -1795,7 +1795,7 @@ CODE
     );
 }
 
-sub image_height {
+sub image_get_height {
     $blurb = 'Return the height of the image';
 
     $help = <<'HELP';
@@ -3131,10 +3131,10 @@ CODE
             get_images
             image_new image_new_with_precision
             image_duplicate image_delete
-            image_base_type
+            image_get_base_type
             image_get_precision
             image_get_default_new_layer_mode
-            image_width image_height
+            image_get_width image_get_height
             image_get_layers
             image_get_channels
             image_get_vectors
diff --git a/plug-ins/common/animation-optimize.c b/plug-ins/common/animation-optimize.c
index e0371c9368..be05aee7dc 100644
--- a/plug-ins/common/animation-optimize.c
+++ b/plug-ins/common/animation-optimize.c
@@ -533,10 +533,10 @@ do_optimizations (GimpRunMode  run_mode,
       break;
     }
 
-  width     = gimp_image_width (image);
-  height    = gimp_image_height (image);
+  width     = gimp_image_get_width (image);
+  height    = gimp_image_get_height (image);
   layers    = gimp_image_get_layers (image, &total_frames);
-  imagetype = gimp_image_base_type (image);
+  imagetype = gimp_image_get_base_type (image);
   pixelstep = (imagetype == GIMP_RGB) ? 4 : 2;
 
   drawabletype_alpha = (imagetype == GIMP_RGB) ? GIMP_RGBA_IMAGE :
diff --git a/plug-ins/common/animation-play.c b/plug-ins/common/animation-play.c
index 4335eb7b98..79c2871d2b 100644
--- a/plug-ins/common/animation-play.c
+++ b/plug-ins/common/animation-play.c
@@ -1126,8 +1126,8 @@ initialize (void)
       return;
     }
 
-  width  = gimp_image_width (image);
-  height = gimp_image_height (image);
+  width  = gimp_image_get_width (image);
+  height = gimp_image_get_height (image);
 
   layers = gimp_image_list_layers (image);
   layers = g_list_reverse (layers);
diff --git a/plug-ins/common/colormap-remap.c b/plug-ins/common/colormap-remap.c
index 7ae5b636ec..75c59b7728 100644
--- a/plug-ins/common/colormap-remap.c
+++ b/plug-ins/common/colormap-remap.c
@@ -218,7 +218,7 @@ remap_run (GimpProcedure        *procedure,
   gegl_init (NULL, NULL);
 
   /*  Make sure that the image is indexed  */
-  if (gimp_image_base_type (image) != GIMP_INDEXED)
+  if (gimp_image_get_base_type (image) != GIMP_INDEXED)
     return gimp_procedure_new_return_values (procedure,
                                              GIMP_PDB_EXECUTION_ERROR,
                                              NULL);
diff --git a/plug-ins/common/compose.c b/plug-ins/common/compose.c
index f0a03a81c5..b42cf4e8d4 100644
--- a/plug-ins/common/compose.c
+++ b/plug-ins/common/compose.c
@@ -1007,8 +1007,8 @@ compose (const gchar  *compose_type,
     }
   else    /* Compose by image */
     {
-      width  = gimp_image_width  (inputs[first_object].comp.object);
-      height = gimp_image_height (inputs[first_object].comp.object);
+      width  = gimp_image_get_width  (inputs[first_object].comp.object);
+      height = gimp_image_get_height (inputs[first_object].comp.object);
 
       precision = gimp_image_get_precision (inputs[first_object].comp.object);
 
@@ -1016,8 +1016,8 @@ compose (const gchar  *compose_type,
         {
           if (inputs[j].is_object)
             {
-              if ((width  != gimp_image_width  (inputs[j].comp.object)) ||
-                  (height != gimp_image_height (inputs[j].comp.object)))
+              if ((width  != gimp_image_get_width  (inputs[j].comp.object)) ||
+                  (height != gimp_image_get_height (inputs[j].comp.object)))
                 {
                   g_message (_("Images have different size"));
                   return NULL;
@@ -1376,9 +1376,9 @@ check_gray (GimpImage *image,
             gpointer   data)
 
 {
-  return ((gimp_image_base_type (image) == GIMP_GRAY) &&
-          (gimp_image_width  (image) == composeint.width) &&
-          (gimp_image_height (image) == composeint.height));
+  return ((gimp_image_get_base_type (image) == GIMP_GRAY) &&
+          (gimp_image_get_width  (image) == composeint.width) &&
+          (gimp_image_get_height (image) == composeint.height));
 }
 
 static void
diff --git a/plug-ins/common/curve-bend.c b/plug-ins/common/curve-bend.c
index 87b9de06e3..1f7005bfed 100644
--- a/plug-ins/common/curve-bend.c
+++ b/plug-ins/common/curve-bend.c
@@ -2683,7 +2683,7 @@ p_create_pv_image (GimpDrawable  *src_drawable,
   src_height = gimp_drawable_height (src_drawable);
 
   new_image = gimp_image_new (PREVIEW_SIZE_X, PREVIEW_SIZE_Y,
-                              gimp_image_base_type (gimp_item_get_image (GIMP_ITEM (src_drawable))));
+                              gimp_image_get_base_type (gimp_item_get_image (GIMP_ITEM (src_drawable))));
   gimp_image_undo_disable (new_image);
 
   type = gimp_drawable_type (src_drawable);
diff --git a/plug-ins/common/file-gif-load.c b/plug-ins/common/file-gif-load.c
index d88713185a..24bcaf7e2c 100644
--- a/plug-ins/common/file-gif-load.c
+++ b/plug-ins/common/file-gif-load.c
@@ -294,8 +294,8 @@ gif_load_thumb (GimpProcedure        *procedure,
                                                   NULL);
 
   GIMP_VALUES_SET_IMAGE (return_vals, 1, image);
-  GIMP_VALUES_SET_INT   (return_vals, 2, gimp_image_width  (image));
-  GIMP_VALUES_SET_INT   (return_vals, 3, gimp_image_height (image));
+  GIMP_VALUES_SET_INT   (return_vals, 2, gimp_image_get_width  (image));
+  GIMP_VALUES_SET_INT   (return_vals, 3, gimp_image_get_height (image));
 
   gimp_value_array_truncate (return_vals, 4);
 
diff --git a/plug-ins/common/file-gif-save.c b/plug-ins/common/file-gif-save.c
index 59789539c5..7c52c377e4 100644
--- a/plug-ins/common/file-gif-save.c
+++ b/plug-ins/common/file-gif-save.c
@@ -656,8 +656,8 @@ sanity_check (GFile        *file,
   gint   image_width;
   gint   image_height;
 
-  image_width  = gimp_image_width (*image);
-  image_height = gimp_image_height (*image);
+  image_width  = gimp_image_get_width (*image);
+  image_height = gimp_image_get_height (*image);
 
   if (image_width > G_MAXUSHORT || image_height > G_MAXUSHORT)
     {
@@ -934,8 +934,8 @@ save_image (GFile         *file,
         }
     }
 
-  cols = gimp_image_width (image);
-  rows = gimp_image_height (image);
+  cols = gimp_image_get_width (image);
+  rows = gimp_image_get_height (image);
   Interlace = config_interlace;
   if (! gif_encode_header (output, is_gif89, cols, rows, bgindex,
                            BitsPerPixel, Red, Green, Blue, get_pixel,
diff --git a/plug-ins/common/file-gih.c b/plug-ins/common/file-gih.c
index a21a49aece..1c3d132cf6 100644
--- a/plug-ins/common/file-gih.c
+++ b/plug-ins/common/file-gih.c
@@ -360,8 +360,8 @@ gih_save (GimpProcedure        *procedure,
     case GIMP_RUN_INTERACTIVE:
       gihparams.ncells = (num_layers * gihparams.rows * gihparams.cols);
 
-      gihparams.cellwidth  = gimp_image_width (image)  / gihparams.cols;
-      gihparams.cellheight = gimp_image_height (image) / gihparams.rows;
+      gihparams.cellwidth  = gimp_image_get_width (image)  / gihparams.cols;
+      gihparams.cellheight = gimp_image_get_height (image) / gihparams.rows;
 
       parasite = gimp_image_get_parasite (orig_image,
                                           "gimp-brush-pipe-parameters");
@@ -538,7 +538,7 @@ size_adjustment_callback (GtkAdjustment      *adjustment,
 
   if (adj->orientation == GIMP_ORIENTATION_VERTICAL)
     {
-      size = gimp_image_width (adj->image);
+      size = gimp_image_get_width (adj->image);
       newn = size / *(adj->value);
       adj->nguides = newn - 1;
       adj->guides = g_new (gint32, adj->nguides);
@@ -548,7 +548,7 @@ size_adjustment_callback (GtkAdjustment      *adjustment,
     }
   else
     {
-      size = gimp_image_height (adj->image);
+      size = gimp_image_get_height (adj->image);
       newn = size / *(adj->value);
       adj->nguides = newn - 1;
       adj->guides = g_new (gint32, adj->nguides);
@@ -672,7 +672,7 @@ gih_save_dialog (GimpImage *image)
   box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
 
   adjustment = gtk_adjustment_new (gihparams.cellwidth,
-                                   2, gimp_image_width (image), 1, 10, 0);
+                                   2, gimp_image_get_width (image), 1, 10, 0);
   spinbutton = gimp_spin_button_new (adjustment, 1.0, 0);
   gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
   gtk_box_pack_start (GTK_BOX (box), spinbutton, FALSE, FALSE, 0);
@@ -696,7 +696,7 @@ gih_save_dialog (GimpImage *image)
   gtk_widget_show (label);
 
   adjustment = gtk_adjustment_new (gihparams.cellheight,
-                                   2, gimp_image_height (image), 1, 10, 0);
+                                   2, gimp_image_get_height (image), 1, 10, 0);
   spinbutton = gimp_spin_button_new (adjustment, 1.0, 0);
   gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
   gtk_box_pack_start (GTK_BOX (box), spinbutton, FALSE, FALSE, 0);
diff --git a/plug-ins/common/file-html-table.c b/plug-ins/common/file-html-table.c
index e698c4cfa2..4aab0072bc 100644
--- a/plug-ins/common/file-html-table.c
+++ b/plug-ins/common/file-html-table.c
@@ -613,7 +613,7 @@ save_dialog (GimpImage     *image,
                       main_vbox, TRUE, TRUE, 0);
   gtk_widget_show (main_vbox);
 
-  if (gimp_image_width (image) * gimp_image_height (image) > 4096)
+  if (gimp_image_get_width (image) * gimp_image_get_height (image) > 4096)
     {
       GtkWidget *eek;
       GtkWidget *label;
diff --git a/plug-ins/common/file-mng.c b/plug-ins/common/file-mng.c
index c62e78ef69..4f5f48e6ef 100644
--- a/plug-ins/common/file-mng.c
+++ b/plug-ins/common/file-mng.c
@@ -834,8 +834,8 @@ mng_save_image (GFile         *file,
   else
     mng_ticks_per_second = 0;
 
-  rows = gimp_image_height (image);
-  cols = gimp_image_width  (image);
+  rows = gimp_image_get_height (image);
+  cols = gimp_image_get_width  (image);
 
   mng_simplicity_profile = (MNG_SIMPLICITY_VALID |
                             MNG_SIMPLICITY_SIMPLEFEATURES |
@@ -1029,7 +1029,7 @@ mng_save_image (GFile         *file,
         }
     }
 
-  if (gimp_image_base_type (image) == GIMP_INDEXED)
+  if (gimp_image_get_base_type (image) == GIMP_INDEXED)
     {
       guchar *palette;
       gint    numcolors;
diff --git a/plug-ins/common/file-pdf-save.c b/plug-ins/common/file-pdf-save.c
index 76e2c77588..0b150cade5 100644
--- a/plug-ins/common/file-pdf-save.c
+++ b/plug-ins/common/file-pdf-save.c
@@ -817,8 +817,8 @@ pdf_save_image (GimpProcedure *procedure,
       y_scale = 72.0 / y_res;
 
       cairo_pdf_surface_set_size (pdf_file,
-                                  gimp_image_width  (image) * x_scale,
-                                  gimp_image_height (image) * y_scale);
+                                  gimp_image_get_width  (image) * x_scale,
+                                  gimp_image_get_height (image) * y_scale);
 
       /* This way we set how many pixels are there in every inch.
        * It's very important for PangoCairo
@@ -845,8 +845,8 @@ pdf_save_image (GimpProcedure *procedure,
           GimpRGB color;
 
           cairo_rectangle (cr, 0.0, 0.0,
-                           gimp_image_width  (image),
-                           gimp_image_height (image));
+                           gimp_image_get_width  (image),
+                           gimp_image_get_height (image));
           gimp_context_get_background (&color);
           cairo_set_source_rgb (cr,
                                 color.r,
diff --git a/plug-ins/common/file-ps.c b/plug-ins/common/file-ps.c
index d06b3e2e90..0b0a20c809 100644
--- a/plug-ins/common/file-ps.c
+++ b/plug-ins/common/file-ps.c
@@ -1442,8 +1442,8 @@ ps_set_save_size (PSSaveVals *vals,
     xres = yres = 72.0;
 
   /* Calculate size of image in inches */
-  width  = gimp_image_width (image);
-  height = gimp_image_height (image);
+  width  = gimp_image_get_width (image);
+  height = gimp_image_get_height (image);
   iw = width  / xres;
   ih = height / yres;
 
diff --git a/plug-ins/common/film.c b/plug-ins/common/film.c
index 09e7b7d134..ff2ede167b 100644
--- a/plug-ins/common/film.c
+++ b/plug-ins/common/film.c
@@ -457,7 +457,7 @@ film (void)
       picture_height = 0;
       for (iter = images_src; iter; iter = iter->next)
         {
-          height = gimp_image_height (iter->data);
+          height = gimp_image_get_height (iter->data);
           if (height > picture_height) picture_height = height;
         }
       film_height = (int)(picture_height / filmvals.picture_height + 0.5);
@@ -482,8 +482,8 @@ film (void)
       layers = gimp_image_list_layers (iter->data);
 
       /* Get scaled image size */
-      width = gimp_image_width (iter->data);
-      height = gimp_image_height (iter->data);
+      width = gimp_image_get_width (iter->data);
+      height = gimp_image_get_height (iter->data);
       f = ((double)picture_height) / (double)height;
       picture_width = width * f;
 
@@ -562,11 +562,11 @@ film (void)
   for (iter = images_src; iter; iter = iter->next)
     {
       image_tmp = gimp_image_duplicate (iter->data);
-      width = gimp_image_width (image_tmp);
-      height = gimp_image_height (image_tmp);
+      width = gimp_image_get_width (image_tmp);
+      height = gimp_image_get_height (image_tmp);
       f = ((gdouble) picture_height) / (gdouble) height;
       picture_width = width * f;
-      if (gimp_image_base_type (image_tmp) != GIMP_RGB)
+      if (gimp_image_get_base_type (image_tmp) != GIMP_RGB)
         gimp_image_convert_rgb (image_tmp);
       gimp_image_scale (image_tmp, picture_width, picture_height);
 
diff --git a/plug-ins/common/grid.c b/plug-ins/common/grid.c
index 92a51efd84..067e9fe29a 100644
--- a/plug-ins/common/grid.c
+++ b/plug-ins/common/grid.c
@@ -438,7 +438,7 @@ grid (GimpImage    *image,
 
   alpha = gimp_drawable_has_alpha (drawable);
 
-  switch (gimp_image_base_type (image))
+  switch (gimp_image_get_base_type (image))
     {
     case GIMP_RGB:
       blend = TRUE;
diff --git a/plug-ins/common/guillotine.c b/plug-ins/common/guillotine.c
index 6de8df5af8..033de7ff6d 100644
--- a/plug-ins/common/guillotine.c
+++ b/plug-ins/common/guillotine.c
@@ -209,8 +209,8 @@ guillotine (GimpImage *image,
   GList    *hguides, *hg;
   GList    *vguides, *vg;
 
-  image_width  = gimp_image_width (image);
-  image_height = gimp_image_height (image);
+  image_width  = gimp_image_get_width (image);
+  image_height = gimp_image_get_height (image);
 
   hguides = g_list_append (NULL,    GINT_TO_POINTER (0));
   hguides = g_list_append (hguides, GINT_TO_POINTER (image_height));
diff --git a/plug-ins/file-dds/ddswrite.c b/plug-ins/file-dds/ddswrite.c
index 23da7ae08e..57d84690a8 100644
--- a/plug-ins/file-dds/ddswrite.c
+++ b/plug-ins/file-dds/ddswrite.c
@@ -161,8 +161,8 @@ check_mipmaps (GimpImage *image,
   layers = gimp_image_list_layers (image);
   num_layers = g_list_length (layers);
 
-  w = gimp_image_width (image);
-  h = gimp_image_height (image);
+  w = gimp_image_get_width (image);
+  h = gimp_image_get_height (image);
 
   num_mipmaps = get_num_mipmaps (w, h);
 
@@ -244,8 +244,8 @@ check_cubemap (GimpImage *image)
         cubemap_faces[i] = NULL;
 
       /* find the mipmap level 0 layers */
-      w = gimp_image_width (image);
-      h = gimp_image_height (image);
+      w = gimp_image_get_width (image);
+      h = gimp_image_get_height (image);
 
       for (i = 0, list = layers;
            i < num_layers;
@@ -485,8 +485,8 @@ get_array_size (GimpImage *image)
   layers = gimp_image_list_layers (image);
   num_layers = g_list_length (layers);
 
-  w = gimp_image_width (image);
-  h = gimp_image_height (image);
+  w = gimp_image_get_width (image);
+  h = gimp_image_get_height (image);
 
   for (i = 0, list = layers;
        i < num_layers;
@@ -872,7 +872,7 @@ write_layer (FILE         *fp,
                 "perceptual-metric",  &perceptual_metric,
                 NULL);
 
-  basetype = gimp_image_base_type (image);
+  basetype = gimp_image_get_base_type (image);
   type = gimp_drawable_type (drawable);
 
   buffer = gimp_drawable_get_buffer (drawable);
@@ -1203,7 +1203,7 @@ write_volume_mipmaps (FILE      *fp,
                 "gamma",              &gamma,
                 NULL);
 
-  type = gimp_image_base_type (image);
+  type = gimp_image_get_base_type (image);
 
   if (compression != DDS_COMPRESS_NONE)
     return;
@@ -1219,7 +1219,7 @@ write_volume_mipmaps (FILE      *fp,
   else
     format = babl_format ("R'G'B'A u8");
 
-  if (gimp_image_base_type (image) == GIMP_INDEXED)
+  if (gimp_image_get_base_type (image) == GIMP_INDEXED)
     palette = gimp_image_get_colormap (image, &colors);
 
   offset = 0;
@@ -1352,11 +1352,11 @@ write_image (FILE         *fp,
     }
   else
     {
-      w = gimp_image_width (image);
-      h = gimp_image_height (image);
+      w = gimp_image_get_width (image);
+      h = gimp_image_get_height (image);
     }
 
-  basetype = gimp_image_base_type (image);
+  basetype = gimp_image_get_base_type (image);
   drawable_type = gimp_drawable_type (drawable);
 
   switch (drawable_type)
@@ -1876,7 +1876,7 @@ config_notify (GObject          *config,
       GimpImageBaseType base_type;
       gboolean          transparent_color;
 
-      base_type = gimp_image_base_type (image);
+      base_type = gimp_image_get_base_type (image);
 
       g_object_get (config,
                     "transparent-color", &transparent_color,
diff --git a/plug-ins/file-fli/fli-gimp.c b/plug-ins/file-fli/fli-gimp.c
index 0a23b19d2d..93f4eff376 100644
--- a/plug-ins/file-fli/fli-gimp.c
+++ b/plug-ins/file-fli/fli-gimp.c
@@ -703,7 +703,7 @@ save_image (GFile      *file,
   gimp_context_get_background (&background);
   gimp_rgb_get_uchar (&background, &red, &green, &blue);
 
-  switch (gimp_image_base_type (image))
+  switch (gimp_image_get_base_type (image))
     {
     case GIMP_GRAY:
       /* build grayscale palette */
@@ -756,8 +756,8 @@ save_image (GFile      *file,
    */
   fli_header.filesize = 0;  /* will be fixed when writing the header */
   fli_header.frames   = 0;  /* will be fixed during the write */
-  fli_header.width    = gimp_image_width (image);
-  fli_header.height   = gimp_image_height (image);
+  fli_header.width    = gimp_image_get_width (image);
+  fli_header.height   = gimp_image_get_height (image);
 
   if ((fli_header.width == 320) && (fli_header.height == 200))
     {
diff --git a/plug-ins/file-ico/ico-dialog.c b/plug-ins/file-ico/ico-dialog.c
index b42d36409c..ff7c8e6fb6 100644
--- a/plug-ins/file-ico/ico-dialog.c
+++ b/plug-ins/file-ico/ico-dialog.c
@@ -275,7 +275,7 @@ ico_dialog_update_icon_preview (GtkWidget    *dialog,
 
       image = gimp_item_get_image (GIMP_ITEM (layer));
 
-      tmp_image = gimp_image_new (w, h, gimp_image_base_type (image));
+      tmp_image = gimp_image_new (w, h, gimp_image_get_base_type (image));
       gimp_image_undo_disable (tmp_image);
 
       if (gimp_drawable_is_indexed (layer))
@@ -372,7 +372,7 @@ ico_dialog_update_icon_preview (GtkWidget    *dialog,
 
       image = gimp_item_get_image (GIMP_ITEM (layer));
 
-      tmp_image = gimp_image_new (w, h, gimp_image_base_type (image));
+      tmp_image = gimp_image_new (w, h, gimp_image_get_base_type (image));
       gimp_image_undo_disable (tmp_image);
 
       if (gimp_drawable_is_indexed (layer))
diff --git a/plug-ins/file-ico/ico-save.c b/plug-ins/file-ico/ico-save.c
index aa3a5bc25f..a8b98aa038 100644
--- a/plug-ins/file-ico/ico-save.c
+++ b/plug-ins/file-ico/ico-save.c
@@ -625,7 +625,7 @@ ico_image_get_reduced_buf (GimpDrawable *layer,
       GimpImage  *image = gimp_item_get_image (GIMP_ITEM (layer));
       GeglBuffer *tmp;
 
-      tmp_image = gimp_image_new (w, h, gimp_image_base_type (image));
+      tmp_image = gimp_image_new (w, h, gimp_image_get_base_type (image));
       gimp_image_undo_disable (tmp_image);
 
       if (gimp_drawable_is_indexed (layer))
diff --git a/plug-ins/file-psd/psd-image-res-load.c b/plug-ins/file-psd/psd-image-res-load.c
index 5cfb34b518..b721c7930a 100644
--- a/plug-ins/file-psd/psd-image-res-load.c
+++ b/plug-ins/file-psd/psd-image-res-load.c
@@ -1511,8 +1511,8 @@ load_resource_2000 (const PSDimageres  *res_a,
   if (path_rec ==0)
     return 0;
 
-  image_width = gimp_image_width (image);
-  image_height = gimp_image_height (image);
+  image_width = gimp_image_get_width (image);
+  image_height = gimp_image_get_height (image);
 
   /* Create path */
   if (res_a->id == PSD_WORKING_PATH)
diff --git a/plug-ins/file-psd/psd-save.c b/plug-ins/file-psd/psd-save.c
index 83c8beb1b1..20c8718d51 100644
--- a/plug-ins/file-psd/psd-save.c
+++ b/plug-ins/file-psd/psd-save.c
@@ -1573,7 +1573,7 @@ save_data (FILE      *fd,
                             gimp_drawable_has_alpha (GIMP_DRAWABLE (PSDImageData.merged_layer)),
                             0));
 
-  imageHeight = gimp_image_height (image);
+  imageHeight = gimp_image_get_height (image);
 
   write_gint16 (fd, 1, "RLE compression");
 
@@ -1612,7 +1612,7 @@ create_merged_image (GimpImage *image)
   if (! gimp_drawable_has_alpha (GIMP_DRAWABLE (projection)))
     return projection;
 
-  if (gimp_image_base_type (image) != GIMP_INDEXED)
+  if (gimp_image_get_base_type (image) != GIMP_INDEXED)
     {
       GeglBuffer         *buffer             = gimp_drawable_get_buffer (GIMP_DRAWABLE (projection));
       const Babl         *format             = get_pixel_format (GIMP_DRAWABLE (projection));
@@ -1667,13 +1667,13 @@ get_image_data (GimpImage *image)
 
   PSDImageData.compression = FALSE;
 
-  PSDImageData.image_height = gimp_image_height (image);
+  PSDImageData.image_height = gimp_image_get_height (image);
   IFDBG printf ("\tGot number of rows: %d\n", PSDImageData.image_height);
 
-  PSDImageData.image_width = gimp_image_width (image);
+  PSDImageData.image_width = gimp_image_get_width (image);
   IFDBG printf ("\tGot number of cols: %d\n", PSDImageData.image_width);
 
-  PSDImageData.baseType = gimp_image_base_type (image);
+  PSDImageData.baseType = gimp_image_get_base_type (image);
   IFDBG printf ("\tGot base type: %d\n", PSDImageData.baseType);
 
   PSDImageData.merged_layer = create_merged_image (image);
@@ -1711,8 +1711,8 @@ save_image (GFile      *file,
 
   IFDBG printf (" Function: save_image\n");
 
-  if (gimp_image_width (image) > 30000 ||
-      gimp_image_height (image) > 30000)
+  if (gimp_image_get_width (image) > 30000 ||
+      gimp_image_get_height (image) > 30000)
     {
       g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
                    _("Unable to export '%s'.  The PSD file format does not "
diff --git a/plug-ins/file-tiff/file-tiff-save.c b/plug-ins/file-tiff/file-tiff-save.c
index 56d41ae93e..659cdf602b 100644
--- a/plug-ins/file-tiff/file-tiff-save.c
+++ b/plug-ins/file-tiff/file-tiff-save.c
@@ -630,7 +630,7 @@ save_layer (TIFF        *tif,
 
   if (compression == COMPRESSION_JPEG)
     {
-      if (gimp_image_base_type (image) == GIMP_INDEXED)
+      if (gimp_image_get_base_type (image) == GIMP_INDEXED)
         {
           g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
                                _("Indexed pictures cannot be compressed "
@@ -935,8 +935,8 @@ save_thumbnail (GimpImage *image,
 
 #define EXIF_THUMBNAIL_SIZE 256
 
-  image_width  = gimp_image_width  (image);
-  image_height = gimp_image_height (image);
+  image_width  = gimp_image_get_width  (image);
+  image_height = gimp_image_get_height (image);
 
   if (image_width > image_height)
     {
diff --git a/plug-ins/file-tiff/file-tiff.c b/plug-ins/file-tiff/file-tiff.c
index ff2812e7ca..d79345c311 100644
--- a/plug-ins/file-tiff/file-tiff.c
+++ b/plug-ins/file-tiff/file-tiff.c
@@ -340,7 +340,7 @@ tiff_save (GimpProcedure        *procedure,
       if (! save_dialog (orig_image, procedure, G_OBJECT (config),
                          n_drawables == 1 ? gimp_drawable_has_alpha (drawables[0]) : TRUE,
                          image_is_monochrome (image),
-                         gimp_image_base_type (image) == GIMP_INDEXED,
+                         gimp_image_get_base_type (image) == GIMP_INDEXED,
                          image_is_multi_layer (image)))
         {
           return gimp_procedure_new_return_values (procedure, GIMP_PDB_CANCEL,
diff --git a/plug-ins/imagemap/imap_cmd_gimp_guides.c b/plug-ins/imagemap/imap_cmd_gimp_guides.c
index fbc6e17a15..00d90eff4c 100644
--- a/plug-ins/imagemap/imap_cmd_gimp_guides.c
+++ b/plug-ins/imagemap/imap_cmd_gimp_guides.c
@@ -80,7 +80,7 @@ gimp_guides_ok_cb(gpointer data)
 
    if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(param->right_border)))
       vguides = g_slist_append(vguides,
-                               GINT_TO_POINTER(gimp_image_width(image)));
+                               GINT_TO_POINTER(gimp_image_get_width(image)));
 
    if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(param->upper_border)))
       hguides = g_slist_append(NULL, GINT_TO_POINTER(0));
@@ -89,7 +89,7 @@ gimp_guides_ok_cb(gpointer data)
 
    if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(param->lower_border)))
       hguides = g_slist_append(hguides,
-                               GINT_TO_POINTER(gimp_image_height(image)));
+                               GINT_TO_POINTER(gimp_image_get_height(image)));
 
    url = gtk_entry_get_text(GTK_ENTRY(param->url));
 
diff --git a/plug-ins/imagemap/imap_main.c b/plug-ins/imagemap/imap_main.c
index da246776e4..c49e973b1f 100644
--- a/plug-ins/imagemap/imap_main.c
+++ b/plug-ins/imagemap/imap_main.c
@@ -209,8 +209,8 @@ imap_run (GimpProcedure        *procedure,
     }
 
   _image_name   = gimp_image_get_name (image);
-  _image_width  = gimp_image_width (image);
-  _image_height = gimp_image_height (image);
+  _image_width  = gimp_image_get_width (image);
+  _image_height = gimp_image_get_height (image);
 
   _map_info.color = gimp_drawable_is_rgb (_drawable);
 


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]