app: add GIMP_PRECISION_U32 and all its formats

app/actions/image-actions.c

@@ -167,6 +167,11 @@ static const GimpRadioActionEntry image_convert_precision_actions[] =
     NC_("image-convert-action", "Convert the image to 16 bit unsigned integer"),
     GIMP_PRECISION_U16, GIMP_HELP_IMAGE_CONVERT_U16 },
 
+  { "image-convert-u32", NULL,
+    NC_("image-convert-action", "32 bit unsigned integer"), NULL,
+    NC_("image-convert-action", "Convert the image to 32 bit unsigned integer"),
+    GIMP_PRECISION_U32, GIMP_HELP_IMAGE_CONVERT_U32 },
+
   { "image-convert-half", NULL,
     NC_("image-convert-action", "16 bit floating point"), NULL,
     NC_("image-convert-action", "Convert the image to 16 bit floating point"),
@@ -285,6 +290,7 @@ image_actions_update (GimpActionGroup *group,
         {
         case GIMP_PRECISION_U8:    action = "image-convert-u8";    break;
         case GIMP_PRECISION_U16:   action = "image-convert-u16";   break;
+        case GIMP_PRECISION_U32:   action = "image-convert-u32";   break;
         case GIMP_PRECISION_HALF:  action = "image-convert-half";  break;
         case GIMP_PRECISION_FLOAT: action = "image-convert-float"; break;
           break;
@@ -312,6 +318,7 @@ image_actions_update (GimpActionGroup *group,
 
   SET_SENSITIVE ("image-convert-u8",    image);
   SET_SENSITIVE ("image-convert-u16",   image && !is_indexed);
+  SET_SENSITIVE ("image-convert-u32",   image && !is_indexed);
   SET_SENSITIVE ("image-convert-half",  image && !is_indexed);
   SET_SENSITIVE ("image-convert-float", image && !is_indexed);
 

app/core/core-enums.c

@@ -755,6 +755,7 @@ gimp_precision_get_type (void)
   {
     { GIMP_PRECISION_U8, "GIMP_PRECISION_U8", "u8" },
     { GIMP_PRECISION_U16, "GIMP_PRECISION_U16", "u16" },
+    { GIMP_PRECISION_U32, "GIMP_PRECISION_U32", "u32" },
     { GIMP_PRECISION_HALF, "GIMP_PRECISION_HALF", "half" },
     { GIMP_PRECISION_FLOAT, "GIMP_PRECISION_FLOAT", "float" },
     { 0, NULL, NULL }
@@ -764,6 +765,7 @@ gimp_precision_get_type (void)
   {
     { GIMP_PRECISION_U8, NC_("precision", "8-bit unsigned integer"), NULL },
     { GIMP_PRECISION_U16, NC_("precision", "16-bit unsigned integer"), NULL },
+    { GIMP_PRECISION_U32, NC_("precision", "32-bit unsigned integer"), NULL },
     { GIMP_PRECISION_HALF, NC_("precision", "16-bit floating point"), NULL },
     { GIMP_PRECISION_FLOAT, NC_("precision", "32-bit floating point"), NULL },
     { 0, NULL, NULL }

app/core/core-enums.h

@@ -350,6 +350,7 @@ typedef enum
 {
   GIMP_PRECISION_U8,    /*< desc="8-bit unsigned integer"  >*/
   GIMP_PRECISION_U16,   /*< desc="16-bit unsigned integer" >*/
+  GIMP_PRECISION_U32,   /*< desc="32-bit unsigned integer" >*/
   GIMP_PRECISION_HALF,  /*< desc="16-bit floating point"   >*/
   GIMP_PRECISION_FLOAT  /*< desc="32-bit floating point"   >*/
 } GimpPrecision;

app/core/gimpimage-convert.c

@@ -1116,6 +1116,10 @@ gimp_image_convert_precision (GimpImage     *image,
       undo_desc = C_("undo-type", "Convert Image to 16 bit unsigned integer");
       break;
 
+    case GIMP_PRECISION_U32:
+      undo_desc = C_("undo-type", "Convert Image to 32 bit unsigned integer");
+      break;
+
     case GIMP_PRECISION_HALF:
       undo_desc = C_("undo-type", "Convert Image to 16 bit float");
       break;

app/core/gimpimage.c

@@ -1585,6 +1585,7 @@ gimp_image_get_mask_format (const GimpImage *image)
     {
     case GIMP_PRECISION_U8:    return babl_format ("Y u8");
     case GIMP_PRECISION_U16:   return babl_format ("Y u16");
+    case GIMP_PRECISION_U32:   return babl_format ("Y u32");
     case GIMP_PRECISION_HALF:  return babl_format ("Y half");
     case GIMP_PRECISION_FLOAT: return babl_format ("Y float");
     }

app/gegl/gimp-babl.c

@@ -74,6 +74,27 @@ gimp_babl_init (void)
                    babl_component ("A"),
                    NULL);
 
+  babl_format_new ("name", "R u32",
+                   babl_model ("RGBA"),
+                   babl_type ("u32"),
+                   babl_component ("R"),
+                   NULL);
+  babl_format_new ("name", "G u32",
+                   babl_model ("RGBA"),
+                   babl_type ("u32"),
+                   babl_component ("G"),
+                   NULL);
+  babl_format_new ("name", "B u32",
+                   babl_model ("RGBA"),
+                   babl_type ("u32"),
+                   babl_component ("B"),
+                   NULL);
+  babl_format_new ("name", "A u32",
+                   babl_model ("RGBA"),
+                   babl_type ("u32"),
+                   babl_component ("A"),
+                   NULL);
+
   babl_format_new ("name", "R half",
                    babl_model ("RGBA"),
                    babl_type ("half"),
@@ -132,42 +153,50 @@ babl_descriptions[] =
 {
   { "R'G'B' u8",  N_("RGB") },
   { "RGB u16",    N_("RGB") },
+  { "RGB u32",    N_("RGB") },
   { "RGB half",   N_("RGB") },
   { "RGB float",  N_("RGB") },
 
   { "R'G'B'A u8", N_("RGB-alpha") },
   { "RGBA u16",   N_("RGB-alpha") },
+  { "RGBA u32",   N_("RGB-alpha") },
   { "RGBA half",  N_("RGB-alpha") },
   { "RGBA float", N_("RGB-alpha") },
 
   { "Y' u8",      N_("Grayscale") },
   { "Y u8",       N_("Grayscale") },
   { "Y u16",      N_("Grayscale") },
+  { "Y u32",      N_("Grayscale") },
   { "Y half",     N_("Grayscale") },
   { "Y float",    N_("Grayscale") },
 
   { "Y'A u8",     N_("Grayscale-alpha") },
   { "YA u16",     N_("Grayscale-alpha") },
+  { "YA u32",     N_("Grayscale-alpha") },
   { "YA half",    N_("Grayscale-alpha") },
   { "YA float",   N_("Grayscale-alpha") },
 
   { "R' u8",      N_("Red component") },
   { "R u16",      N_("Red component") },
+  { "R u32",      N_("Red component") },
   { "R half",     N_("Red component") },
   { "R float",    N_("Red component") },
 
   { "G' u8",      N_("Green component") },
   { "G u16",      N_("Green component") },
+  { "G u32",      N_("Green component") },
   { "G half",     N_("Green component") },
   { "G float",    N_("Green component") },
 
   { "B' u8",      N_("Blue component") },
   { "B u16",      N_("Blue component") },
+  { "B u32",      N_("Blue component") },
   { "B half",     N_("Blue component") },
   { "B float",    N_("Blue component") },
 
   { "A u8",       N_("Alpha component") },
   { "A u16",      N_("Alpha component") },
+  { "A u32",      N_("Alpha component") },
   { "A half",     N_("Alpha component") },
   { "A float",    N_("Alpha component") },
   { "A double",   N_("Alpha component") }
@@ -257,6 +286,8 @@ gimp_babl_format_get_precision (const Babl *format)
     return GIMP_PRECISION_U8;
   else if (type == babl_type ("u16"))
     return GIMP_PRECISION_U16;
+  else if (type == babl_type ("u32"))
+    return GIMP_PRECISION_U32;
   else if (type == babl_type ("half"))
     return GIMP_PRECISION_HALF;
   else if (type == babl_type ("float"))
@@ -287,6 +318,12 @@ gimp_babl_format (GimpImageBaseType  base_type,
           else
             return babl_format ("RGB u16");
 
+        case GIMP_PRECISION_U32:
+          if (with_alpha)
+            return babl_format ("RGBA u32");
+          else
+            return babl_format ("RGB u32");
+
         case GIMP_PRECISION_HALF:
           if (with_alpha)
             return babl_format ("RGBA half");
@@ -319,6 +356,12 @@ gimp_babl_format (GimpImageBaseType  base_type,
           else
             return babl_format ("Y u16");
 
+        case GIMP_PRECISION_U32:
+          if (with_alpha)
+            return babl_format ("YA u32");
+          else
+            return babl_format ("Y u32");
+
         case GIMP_PRECISION_HALF:
           if (with_alpha)
             return babl_format ("YA half");
@@ -378,6 +421,18 @@ gimp_babl_component_format (GimpImageBaseType base_type,
             }
           break;
 
+        case GIMP_PRECISION_U32:
+          switch (index)
+            {
+            case 0: return babl_format ("R u32");
+            case 1: return babl_format ("G u32");
+            case 2: return babl_format ("B u32");
+            case 3: return babl_format ("A u32");
+            default:
+              break;
+            }
+          break;
+
         case GIMP_PRECISION_HALF:
           switch (index)
             {
@@ -430,6 +485,16 @@ gimp_babl_component_format (GimpImageBaseType base_type,
             }
           break;
 
+        case GIMP_PRECISION_U32:
+          switch (index)
+            {
+            case 0: return babl_format ("Y u32");
+            case 1: return babl_format ("A u32");
+            default:
+              break;
+            }
+          break;
+
         case GIMP_PRECISION_HALF:
           switch (index)
             {

app/widgets/gimphelp-ids.h

@@ -118,6 +118,7 @@
 #define GIMP_HELP_IMAGE_CONVERT_INDEXED           "gimp-image-convert-indexed"
 #define GIMP_HELP_IMAGE_CONVERT_U8                "gimp-image-convert-u8"
 #define GIMP_HELP_IMAGE_CONVERT_U16               "gimp-image-convert-u16"
+#define GIMP_HELP_IMAGE_CONVERT_U32               "gimp-image-convert-u32"
 #define GIMP_HELP_IMAGE_CONVERT_HALF              "gimp-image-convert-half"
 #define GIMP_HELP_IMAGE_CONVERT_FLOAT             "gimp-image-convert-float"
 #define GIMP_HELP_IMAGE_FLIP_HORIZONTAL           "gimp-image-flip-horizontal"

libgimp/gimpenums.h

@@ -266,6 +266,7 @@ typedef enum
 {
   GIMP_PRECISION_U8,
   GIMP_PRECISION_U16,
+  GIMP_PRECISION_U32,
   GIMP_PRECISION_HALF,
   GIMP_PRECISION_FLOAT
 } GimpPrecision;

menus/image-menu.xml.in

@@ -323,6 +323,7 @@
       <menu action="image-precision-menu" name="Precision">
         <menuitem action="image-convert-u8" />
         <menuitem action="image-convert-u16" />
+        <menuitem action="image-convert-u32" />
         <menuitem action="image-convert-half" />
         <menuitem action="image-convert-float" />
         <separator />

tools/pdbgen/enums.pl

@@ -541,11 +541,13 @@ package Gimp::CodeGen::enums;
 	{ contig => 1,
 	  header => 'core/core-enums.h',
 	  symbols => [ qw(GIMP_PRECISION_U8 GIMP_PRECISION_U16
-			  GIMP_PRECISION_HALF GIMP_PRECISION_FLOAT) ],
+			  GIMP_PRECISION_U32 GIMP_PRECISION_HALF
+			  GIMP_PRECISION_FLOAT) ],
 	  mapping => { GIMP_PRECISION_U8 => '0',
 		       GIMP_PRECISION_U16 => '1',
-		       GIMP_PRECISION_HALF => '2',
+		       GIMP_PRECISION_U32 => '2',
-		       GIMP_PRECISION_FLOAT => '3' }
+		       GIMP_PRECISION_HALF => '3',
+		       GIMP_PRECISION_FLOAT => '4' }
 	},
     GimpRotationType =>
 	{ contig => 1,