convert-cmds.c 16.1 KB
Newer Older
1
/* GIMP - The GNU Image Manipulation Program
2
 * Copyright (C) 1995-2003 Spencer Kimball and Peter Mattis
Manish Singh's avatar
Manish Singh committed
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

19
/* NOTE: This file is auto-generated by pdbgen.pl. */
Manish Singh's avatar
Manish Singh committed
20

21
#include "config.h"
Manish Singh's avatar
Manish Singh committed
22

23
#include <glib-object.h>
24

25
#include "pdb-types.h"
26

27 28
#include "core/gimpimage-convert.h"
#include "core/gimpimage.h"
29
#include "core/gimppalette.h"
30
#include "core/gimpparamspecs.h"
Manish Singh's avatar
Manish Singh committed
31

32
#include "gimppdb.h"
33
#include "gimppdberror.h"
34 35
#include "gimppdb-utils.h"
#include "gimpprocedure.h"
36
#include "internal-procs.h"
37

38 39
#include "gimp-intl.h"

Manish Singh's avatar
Manish Singh committed
40

41
static GValueArray *
42 43 44 45 46 47
image_convert_rgb_invoker (GimpProcedure      *procedure,
                           Gimp               *gimp,
                           GimpContext        *context,
                           GimpProgress       *progress,
                           const GValueArray  *args,
                           GError            **error)
Manish Singh's avatar
Manish Singh committed
48 49
{
  gboolean success = TRUE;
50
  GimpImage *image;
Manish Singh's avatar
Manish Singh committed
51

52
  image = gimp_value_get_image (&args->values[0], gimp);
Manish Singh's avatar
Manish Singh committed
53 54

  if (success)
55
    {
56 57 58 59 60 61
      if (gimp_pdb_image_is_not_base_type (image, GIMP_RGB, error))
        {
          success = gimp_image_convert (image, GIMP_RGB,
                                        0, 0, FALSE, FALSE, 0, NULL,
                                        NULL, error);
        }
62
      else
63 64 65
        {
          success = FALSE;
        }
66
    }
Manish Singh's avatar
Manish Singh committed
67

68
  return gimp_procedure_get_return_values (procedure, success);
Manish Singh's avatar
Manish Singh committed
69 70
}

71
static GValueArray *
72 73 74 75 76 77
image_convert_grayscale_invoker (GimpProcedure      *procedure,
                                 Gimp               *gimp,
                                 GimpContext        *context,
                                 GimpProgress       *progress,
                                 const GValueArray  *args,
                                 GError            **error)
Manish Singh's avatar
Manish Singh committed
78 79
{
  gboolean success = TRUE;
80
  GimpImage *image;
Manish Singh's avatar
Manish Singh committed
81

82
  image = gimp_value_get_image (&args->values[0], gimp);
Manish Singh's avatar
Manish Singh committed
83 84

  if (success)
85
    {
86 87 88 89 90 91
      if (gimp_pdb_image_is_not_base_type (image, GIMP_GRAY, error))
        {
          success = gimp_image_convert (image, GIMP_GRAY,
                                        0, 0, FALSE, FALSE, 0, NULL,
                                        NULL, error);
        }
92
      else
93 94 95
        {
          success = FALSE;
        }
96
    }
Manish Singh's avatar
Manish Singh committed
97

98
  return gimp_procedure_get_return_values (procedure, success);
Manish Singh's avatar
Manish Singh committed
99 100
}

101
static GValueArray *
102 103 104 105 106 107
image_convert_indexed_invoker (GimpProcedure      *procedure,
                               Gimp               *gimp,
                               GimpContext        *context,
                               GimpProgress       *progress,
                               const GValueArray  *args,
                               GError            **error)
108 109
{
  gboolean success = TRUE;
110
  GimpImage *image;
111 112 113 114 115
  gint32 dither_type;
  gint32 palette_type;
  gint32 num_cols;
  gboolean alpha_dither;
  gboolean remove_unused;
116
  const gchar *palette;
117

118 119 120 121 122 123 124
  image = gimp_value_get_image (&args->values[0], gimp);
  dither_type = g_value_get_enum (&args->values[1]);
  palette_type = g_value_get_enum (&args->values[2]);
  num_cols = g_value_get_int (&args->values[3]);
  alpha_dither = g_value_get_boolean (&args->values[4]);
  remove_unused = g_value_get_boolean (&args->values[5]);
  palette = g_value_get_string (&args->values[6]);
125 126 127

  if (success)
    {
128
      GimpPalette *pal = NULL;
129

130
      if (gimp_pdb_image_is_not_base_type (image, GIMP_INDEXED, error))
131 132 133 134 135 136 137 138 139
        {
          switch (palette_type)
            {
            case GIMP_MAKE_PALETTE:
              if (num_cols < 1 || num_cols > MAXNUMCOLORS)
                success = FALSE;
              break;

            case GIMP_CUSTOM_PALETTE:
140 141
              pal = gimp_pdb_get_palette (gimp, palette, FALSE, error);
              if (! pal)
142 143 144
                {
                  success = FALSE;
                }
145
              else if (pal->n_colors > MAXNUMCOLORS)
146 147 148 149 150 151
                {
                  g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_INVALID_ARGUMENT,
                               _("Cannot convert to a palette "
                                 "with more than 256 colors."));
                  success = FALSE;
                }
152 153 154 155 156 157
              break;

            default:
              break;
            }
        }
158
      else
Sven Neumann's avatar
Sven Neumann committed
159 160 161
        {
          success = FALSE;
        }
162

163
      if (success)
Sven Neumann's avatar
Sven Neumann committed
164 165 166
        success = gimp_image_convert (image, GIMP_INDEXED,
                                      num_cols, dither_type,
                                      alpha_dither, remove_unused,
167
                                      palette_type, pal,
168
                                      NULL, error);
169 170
    }

171
  return gimp_procedure_get_return_values (procedure, success);
172 173
}

174
static GValueArray *
175 176 177 178 179 180
image_convert_set_dither_matrix_invoker (GimpProcedure      *procedure,
                                         Gimp               *gimp,
                                         GimpContext        *context,
                                         GimpProgress       *progress,
                                         const GValueArray  *args,
                                         GError            **error)
181 182 183 184 185 186 187 188 189 190 191 192 193 194
{
  gboolean success = TRUE;
  gint32 width;
  gint32 height;
  gint32 matrix_length;
  const guint8 *matrix;

  width = g_value_get_int (&args->values[0]);
  height = g_value_get_int (&args->values[1]);
  matrix_length = g_value_get_int (&args->values[2]);
  matrix = gimp_value_get_int8array (&args->values[3]);

  if (success)
    {
Sven Neumann's avatar
Sven Neumann committed
195
      gimp_image_convert_set_dither_matrix (matrix, width, height);
196 197 198 199 200
    }

  return gimp_procedure_get_return_values (procedure, success);
}

201
void
202
register_convert_procs (GimpPDB *pdb)
203
{
204 205 206 207 208
  GimpProcedure *procedure;

  /*
   * gimp-image-convert-rgb
   */
209
  procedure = gimp_procedure_new (image_convert_rgb_invoker);
210 211
  gimp_object_set_static_name (GIMP_OBJECT (procedure),
                               "gimp-image-convert-rgb");
212 213 214
  gimp_procedure_set_static_strings (procedure,
                                     "gimp-image-convert-rgb",
                                     "Convert specified image to RGB color",
215
                                     "This procedure converts the specified image to RGB color. This process requires an image in RGB or Indexed color mode. No image content is lost in this process aside from the colormap for an indexed image.",
216 217 218 219 220 221 222 223
                                     "Spencer Kimball & Peter Mattis",
                                     "Spencer Kimball & Peter Mattis",
                                     "1995-1996",
                                     NULL);
  gimp_procedure_add_argument (procedure,
                               gimp_param_spec_image_id ("image",
                                                         "image",
                                                         "The image",
224
                                                         pdb->gimp, FALSE,
225
                                                         GIMP_PARAM_READWRITE));
226
  gimp_pdb_register_procedure (pdb, procedure);
227
  g_object_unref (procedure);
228 229 230 231

  /*
   * gimp-image-convert-grayscale
   */
232
  procedure = gimp_procedure_new (image_convert_grayscale_invoker);
233 234
  gimp_object_set_static_name (GIMP_OBJECT (procedure),
                               "gimp-image-convert-grayscale");
235 236 237
  gimp_procedure_set_static_strings (procedure,
                                     "gimp-image-convert-grayscale",
                                     "Convert specified image to grayscale (256 intensity levels)",
238
                                     "This procedure converts the specified image to grayscale with 8 bits per pixel (256 intensity levels). This process requires an image in RGB or Indexed color mode.",
239 240 241 242 243 244 245 246
                                     "Spencer Kimball & Peter Mattis",
                                     "Spencer Kimball & Peter Mattis",
                                     "1995-1996",
                                     NULL);
  gimp_procedure_add_argument (procedure,
                               gimp_param_spec_image_id ("image",
                                                         "image",
                                                         "The image",
247
                                                         pdb->gimp, FALSE,
248
                                                         GIMP_PARAM_READWRITE));
249
  gimp_pdb_register_procedure (pdb, procedure);
250
  g_object_unref (procedure);
251 252 253 254

  /*
   * gimp-image-convert-indexed
   */
255
  procedure = gimp_procedure_new (image_convert_indexed_invoker);
256 257
  gimp_object_set_static_name (GIMP_OBJECT (procedure),
                               "gimp-image-convert-indexed");
258 259 260
  gimp_procedure_set_static_strings (procedure,
                                     "gimp-image-convert-indexed",
                                     "Convert specified image to and Indexed image",
261
                                     "This procedure converts the specified image to 'indexed' color. This process requires an image in RGB or Grayscale mode. The 'palette_type' specifies what kind of palette to use, A type of '0' means to use an optimal palette of 'num_cols' generated from the colors in the image. A type of '1' means to re-use the previous palette (not currently implemented). A type of '2' means to use the so-called WWW-optimized palette. Type '3' means to use only black and white colors. A type of '4' means to use a palette from the gimp palettes directories. The 'dither type' specifies what kind of dithering to use. '0' means no dithering, '1' means standard Floyd-Steinberg error diffusion, '2' means Floyd-Steinberg error diffusion with reduced bleeding, '3' means dithering based on pixel location ('Fixed' dithering).",
262 263 264 265 266 267 268 269
                                     "Spencer Kimball & Peter Mattis",
                                     "Spencer Kimball & Peter Mattis",
                                     "1995-1996",
                                     NULL);
  gimp_procedure_add_argument (procedure,
                               gimp_param_spec_image_id ("image",
                                                         "image",
                                                         "The image",
270
                                                         pdb->gimp, FALSE,
271 272 273 274
                                                         GIMP_PARAM_READWRITE));
  gimp_procedure_add_argument (procedure,
                               g_param_spec_enum ("dither-type",
                                                  "dither type",
275
                                                  "The dither type to use",
276 277 278 279 280 281
                                                  GIMP_TYPE_CONVERT_DITHER_TYPE,
                                                  GIMP_NO_DITHER,
                                                  GIMP_PARAM_READWRITE));
  gimp_procedure_add_argument (procedure,
                               g_param_spec_enum ("palette-type",
                                                  "palette type",
282
                                                  "The type of palette to use",
283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
                                                  GIMP_TYPE_CONVERT_PALETTE_TYPE,
                                                  GIMP_MAKE_PALETTE,
                                                  GIMP_PARAM_READWRITE));
  gimp_procedure_add_argument (procedure,
                               gimp_param_spec_int32 ("num-cols",
                                                      "num cols",
                                                      "The number of colors to quantize to, ignored unless (palette_type == GIMP_MAKE_PALETTE)",
                                                      G_MININT32, G_MAXINT32, 0,
                                                      GIMP_PARAM_READWRITE));
  gimp_procedure_add_argument (procedure,
                               g_param_spec_boolean ("alpha-dither",
                                                     "alpha dither",
                                                     "Dither transparency to fake partial opacity",
                                                     FALSE,
                                                     GIMP_PARAM_READWRITE));
  gimp_procedure_add_argument (procedure,
                               g_param_spec_boolean ("remove-unused",
                                                     "remove unused",
                                                     "Remove unused or duplicate color entries from final palette, ignored if (palette_type == GIMP_MAKE_PALETTE)",
                                                     FALSE,
                                                     GIMP_PARAM_READWRITE));
  gimp_procedure_add_argument (procedure,
                               gimp_param_spec_string ("palette",
                                                       "palette",
                                                       "The name of the custom palette to use, ignored unless (palette_type == GIMP_CUSTOM_PALETTE)",
308
                                                       FALSE, FALSE, FALSE,
309 310
                                                       NULL,
                                                       GIMP_PARAM_READWRITE));
311
  gimp_pdb_register_procedure (pdb, procedure);
312
  g_object_unref (procedure);
313 314 315 316 317

  /*
   * gimp-image-convert-set-dither-matrix
   */
  procedure = gimp_procedure_new (image_convert_set_dither_matrix_invoker);
318 319
  gimp_object_set_static_name (GIMP_OBJECT (procedure),
                               "gimp-image-convert-set-dither-matrix");
320 321 322 323
  gimp_procedure_set_static_strings (procedure,
                                     "gimp-image-convert-set-dither-matrix",
                                     "Set dither matrix for conversion to indexed",
                                     "This procedure sets the dither matrix used when converting images to INDEXED mode with positional dithering.",
324 325 326
                                     "David Gowers",
                                     "David Gowers",
                                     "2006",
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
                                     NULL);
  gimp_procedure_add_argument (procedure,
                               gimp_param_spec_int32 ("width",
                                                      "width",
                                                      "Width of the matrix (0 to reset to default matrix)",
                                                      G_MININT32, G_MAXINT32, 0,
                                                      GIMP_PARAM_READWRITE));
  gimp_procedure_add_argument (procedure,
                               gimp_param_spec_int32 ("height",
                                                      "height",
                                                      "Height of the matrix (0 to reset to default matrix)",
                                                      G_MININT32, G_MAXINT32, 0,
                                                      GIMP_PARAM_READWRITE));
  gimp_procedure_add_argument (procedure,
                               gimp_param_spec_int32 ("matrix-length",
                                                      "matrix length",
                                                      "The length of 'matrix'",
                                                      1, 1024, 1,
                                                      GIMP_PARAM_READWRITE));
  gimp_procedure_add_argument (procedure,
                               gimp_param_spec_int8_array ("matrix",
                                                           "matrix",
                                                           "The matrix -- all values must be >= 1",
                                                           GIMP_PARAM_READWRITE));
  gimp_pdb_register_procedure (pdb, procedure);
  g_object_unref (procedure);
353
}