← Back to branch summary

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

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2007-05-02 16:33:03 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070502163303-bvzhjzbpw8qglc4y
Tags: 2.3.16-1ubuntu1
* Resynchronized with Debian, remaining Ubuntu changes:
  - debian/rules: i18n magic.
* debian/control.in:
  - Maintainer: Ubuntu Core Developers <ubuntu-devel@lists.ubuntu.com>
* debian/patches/02_help-message.patch,
  debian/patches/03_gimp.desktop.in.in.patch,
  debian/patches/10_dont_show_wizard.patch: updated.
* debian/patches/04_composite-signedness.patch,
  debian/patches/05_add-letter-spacing.patch: dropped, used upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plug-ins/common/xbm.c
1
 
/* The GIMP -- an image manipulation program
 
1
/* GIMP - The GNU Image Manipulation Program
2
2
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
3
3
 *
4
4
 * X10 and X11 bitmap (XBM) loading and saving file filter for the GIMP.
39
39
#include "config.h"
40
40
 
41
41
#include <errno.h>
42
 
#include <stdio.h>
43
 
#include <stdlib.h>
44
42
#include <string.h>
45
43
 
46
 
#include <gtk/gtk.h>
 
44
#include <glib/gstdio.h>
47
45
 
48
46
#include <libgimp/gimp.h>
49
47
#include <libgimp/gimpui.h>
51
49
#include "libgimp/stdplugins-intl.h"
52
50
 
53
51
 
 
52
#define LOAD_PROC      "file-xbm-load"
 
53
#define SAVE_PROC      "file-xbm-save"
 
54
#define PLUG_IN_BINARY "xbm"
 
55
 
 
56
 
54
57
/* Wear your GIMP with pride! */
55
58
#define DEFAULT_USE_COMMENT TRUE
56
59
#define MAX_COMMENT         72
58
61
 
59
62
/* C identifier prefix. */
60
63
#define DEFAULT_PREFIX "bitmap"
61
 
#define MAX_PREFIX     24
 
64
#define MAX_PREFIX     64
62
65
 
63
66
/* Whether or not to save as X10 bitmap. */
64
67
#define DEFAULT_X10_FORMAT FALSE
115
118
static void      mask_ext_entry_callback (GtkWidget   *widget,
116
119
                                          gpointer     data);
117
120
 
118
 
GimpPlugInInfo PLUG_IN_INFO =
 
121
const GimpPlugInInfo PLUG_IN_INFO =
119
122
{
120
123
  NULL,  /* init_proc  */
121
124
  NULL,  /* quit_proc  */
132
135
static void
133
136
query (void)
134
137
{
135
 
  static GimpParamDef load_args[] =
 
138
  static const GimpParamDef load_args[] =
136
139
  {
137
 
    { GIMP_PDB_INT32,  "run_mode",     "Interactive, non-interactive" },
 
140
    { GIMP_PDB_INT32,  "run-mode",     "Interactive, non-interactive" },
138
141
    { GIMP_PDB_STRING, "filename",     "The name of the file to load" },
139
 
    { GIMP_PDB_STRING, "raw_filename", "The name entered" }
 
142
    { GIMP_PDB_STRING, "raw-filename", "The name entered"             }
140
143
  };
141
144
 
142
 
  static GimpParamDef load_return_vals[] =
 
145
  static const GimpParamDef load_return_vals[] =
143
146
  {
144
147
    { GIMP_PDB_IMAGE,  "image",        "Output image" }
145
148
  };
146
149
 
147
 
  static GimpParamDef save_args[] =
 
150
  static const GimpParamDef save_args[] =
148
151
  {
149
 
    { GIMP_PDB_INT32,    "run_mode",       "Interactive, non-interactive" },
 
152
    { GIMP_PDB_INT32,    "run-mode",       "Interactive, non-interactive" },
150
153
    { GIMP_PDB_IMAGE,    "image",          "Input image" },
151
154
    { GIMP_PDB_DRAWABLE, "drawable",       "Drawable to save" },
152
155
    { GIMP_PDB_STRING,   "filename",       "The name of the file to save" },
153
 
    { GIMP_PDB_STRING,   "raw_filename",   "The name entered" },
 
156
    { GIMP_PDB_STRING,   "raw-filename",   "The name entered" },
154
157
    { GIMP_PDB_STRING,   "comment",        "Image description (maximum 72 bytes)" },
155
158
    { GIMP_PDB_INT32,    "x10",            "Save in X10 format" },
156
 
    { GIMP_PDB_INT32,    "x_hot",          "X coordinate of hotspot" },
157
 
    { GIMP_PDB_INT32,    "y_hot",          "Y coordinate of hotspot" },
 
159
    { GIMP_PDB_INT32,    "x-hot",          "X coordinate of hotspot" },
 
160
    { GIMP_PDB_INT32,    "y-hot",          "Y coordinate of hotspot" },
158
161
    { GIMP_PDB_STRING,   "prefix",         "Identifier prefix [determined from filename]"},
159
 
    { GIMP_PDB_INT32,    "write_mask",     "(0 = ignore, 1 = save as extra file)" },
160
 
    { GIMP_PDB_STRING,   "mask_extension", "Extension of the mask file" }
 
162
    { GIMP_PDB_INT32,    "write-mask",     "(0 = ignore, 1 = save as extra file)" },
 
163
    { GIMP_PDB_STRING,   "mask-extension", "Extension of the mask file" }
161
164
  } ;
162
165
 
163
 
  gimp_install_procedure ("file_xbm_load",
 
166
  gimp_install_procedure (LOAD_PROC,
164
167
                          "Load a file in X10 or X11 bitmap (XBM) file format",
165
168
                          "Load a file in X10 or X11 bitmap (XBM) file format.  XBM is a lossless format for flat black-and-white (two color indexed) images.",
166
169
                          "Gordon Matzigkeit",
173
176
                          G_N_ELEMENTS (load_return_vals),
174
177
                          load_args, load_return_vals);
175
178
 
176
 
  gimp_register_file_handler_mime ("file_xbm_load", "image/x-xbitmap");
177
 
  gimp_register_load_handler ("file_xbm_load",
 
179
  gimp_register_file_handler_mime (LOAD_PROC, "image/x-xbitmap");
 
180
  gimp_register_load_handler (LOAD_PROC,
178
181
                              "xbm,icon,bitmap",
179
182
                              "");
180
183
 
181
 
  gimp_install_procedure ("file_xbm_save",
 
184
  gimp_install_procedure (SAVE_PROC,
182
185
                          "Save a file in X10 or X11 bitmap (XBM) file format",
183
186
                          "Save a file in X10 or X11 bitmap (XBM) file format.  XBM is a lossless format for flat black-and-white (two color indexed) images.",
184
187
                          "Gordon Matzigkeit",
190
193
                          G_N_ELEMENTS (save_args), 0,
191
194
                          save_args, NULL);
192
195
 
193
 
  gimp_register_file_handler_mime ("file_xbm_save", "image/x-xbitmap");
194
 
  gimp_register_save_handler ("file_xbm_save", "xbm,icon,bitmap", "");
 
196
  gimp_register_file_handler_mime (SAVE_PROC, "image/x-xbitmap");
 
197
  gimp_register_save_handler (SAVE_PROC, "xbm,icon,bitmap", "");
195
198
}
196
199
 
197
200
static gchar *
204
207
 
205
208
  memset (xsvals.prefix, 0, sizeof (xsvals.prefix));
206
209
 
207
 
  /* Strip any extension. */
208
210
  if (prefix)
209
211
    {
 
212
      /* Strip any extension. */
210
213
      p = strrchr (prefix, '.');
211
214
      if (p && p != prefix)
212
215
        len = MIN (MAX_PREFIX, p - prefix);
238
241
 
239
242
  INIT_I18N ();
240
243
 
241
 
  strncpy (xsvals.comment, _("Created with The GIMP"), MAX_COMMENT);
 
244
  strncpy (xsvals.comment, "Created with GIMP", MAX_COMMENT);
242
245
 
243
246
  run_mode = param[0].data.d_int32;
244
247
 
253
256
    printf ("XBM: RUN %s\n", name);
254
257
#endif
255
258
 
256
 
  if (strcmp (name, "file_xbm_load") == 0)
 
259
  if (strcmp (name, LOAD_PROC) == 0)
257
260
    {
258
261
      image_ID = load_image (param[1].data.d_string);
259
262
 
268
271
          status = GIMP_PDB_EXECUTION_ERROR;
269
272
        }
270
273
    }
271
 
  else if (strcmp (name, "file_xbm_save") == 0)
 
274
  else if (strcmp (name, SAVE_PROC) == 0)
272
275
    {
273
276
      image_ID    = param[1].data.d_int32;
274
277
      drawable_ID = param[2].data.d_int32;
277
280
        {
278
281
        case GIMP_RUN_INTERACTIVE:
279
282
        case GIMP_RUN_WITH_LAST_VALS:
280
 
          gimp_ui_init ("xbm", FALSE);
 
283
          gimp_ui_init (PLUG_IN_BINARY, FALSE);
281
284
          export = gimp_export_image (&image_ID, &drawable_ID, "XBM",
282
285
                                      GIMP_EXPORT_CAN_HANDLE_BITMAP |
283
286
                                      GIMP_EXPORT_CAN_HANDLE_ALPHA);
298
301
        case GIMP_RUN_INTERACTIVE:
299
302
        case GIMP_RUN_WITH_LAST_VALS:
300
303
          /*  Possibly retrieve data  */
301
 
          gimp_get_data ("file_xbm_save", &xsvals);
 
304
          gimp_get_data (SAVE_PROC, &xsvals);
302
305
 
303
306
          /* Always override the prefix with the filename. */
304
307
          mask_filename = g_strdup (init_prefix (param[3].data.d_string));
423
426
          g_free (temp);
424
427
 
425
428
          /* Change any non-alphanumeric prefix characters to underscores. */
426
 
          temp = xsvals.prefix;
427
 
          while (*temp)
428
 
            {
429
 
              if (!g_ascii_isalnum (*temp))
430
 
                *temp = '_';
431
 
              temp ++;
432
 
            }
 
429
          for (temp = xsvals.prefix; *temp; temp++)
 
430
            if (! g_ascii_isalnum (*temp))
 
431
              *temp = '_';
433
432
 
434
433
          mask_prefix = g_strdup_printf ("%s%s",
435
434
                                         xsvals.prefix, xsvals.mask_ext);
436
435
 
 
436
          for (temp = mask_prefix; *temp; temp++)
 
437
            if (! g_ascii_isalnum (*temp))
 
438
              *temp = '_';
 
439
 
437
440
          if (save_image (param[3].data.d_string,
438
441
                          xsvals.prefix,
439
442
                          xsvals.comment,
446
449
                                                    image_ID, drawable_ID)))
447
450
            {
448
451
              /*  Store xsvals data  */
449
 
              gimp_set_data ("file_xbm_save", &xsvals, sizeof (xsvals));
 
452
              gimp_set_data (SAVE_PROC, &xsvals, sizeof (xsvals));
450
453
            }
451
454
          else
452
455
            {
703
706
  gint    y_hot = 0;
704
707
  gint    c, i, j, k;
705
708
  gint    tileheight, rowoffset;
706
 
 
707
 
  gchar *name_buf;
708
 
  gchar *comment;
709
 
 
710
 
  guchar cmap[] =
 
709
  gchar  *comment;
 
710
 
 
711
  const guchar cmap[] =
711
712
  {
712
713
    0x00, 0x00, 0x00,           /* black */
713
714
    0xff, 0xff, 0xff            /* white */
714
715
  };
715
716
 
716
 
  fp = fopen (filename, "rb");
 
717
  fp = g_fopen (filename, "rb");
717
718
  if (!fp)
718
719
    {
719
720
      g_message (_("Could not open '%s' for reading: %s"),
721
722
      return -1;
722
723
    }
723
724
 
724
 
  name_buf = g_strdup_printf (_("Opening '%s'..."),
725
 
                              gimp_filename_to_utf8 (filename));
726
 
  gimp_progress_init (name_buf);
727
 
  g_free (name_buf);
 
725
  gimp_progress_init_printf (_("Opening '%s'"),
 
726
                             gimp_filename_to_utf8 (filename));
728
727
 
729
728
  comment = fgetcomment (fp);
730
729
 
947
946
  gint     bpp;
948
947
 
949
948
  guchar *data, *cmap;
950
 
  gchar  *name_buf, *intfmt;
 
949
  gchar  *intfmt;
 
950
 
 
951
#if 0
 
952
  if (save_mask)
 
953
    g_printerr ("%s: save_mask '%s'\n", G_STRFUNC, prefix);
 
954
  else
 
955
    g_printerr ("%s: save_image '%s'\n", G_STRFUNC, prefix);
 
956
#endif
951
957
 
952
958
  drawable = gimp_drawable_get (drawable_ID);
953
959
  width    = drawable->width;
990
996
    }
991
997
 
992
998
  /* Now actually save the data. */
993
 
  fp = fopen (filename, "w");
 
999
  fp = g_fopen (filename, "w");
994
1000
  if (!fp)
995
1001
    {
996
1002
      g_message (_("Could not open '%s' for writing: %s"),
998
1004
      return FALSE;
999
1005
    }
1000
1006
 
1001
 
  name_buf = g_strdup_printf (_("Saving '%s'..."),
1002
 
                              gimp_filename_to_utf8 (filename));
1003
 
  gimp_progress_init (name_buf);
1004
 
  g_free (name_buf);
 
1007
  gimp_progress_init_printf (_("Saving '%s'"),
 
1008
                             gimp_filename_to_utf8 (filename));
1005
1009
 
1006
1010
  /* Maybe write the image comment. */
1007
1011
#if 0
1135
1139
static gboolean
1136
1140
save_dialog (gint32 drawable_ID)
1137
1141
{
1138
 
  GtkWidget *dlg;
 
1142
  GtkWidget *dialog;
1139
1143
  GtkWidget *frame;
1140
1144
  GtkWidget *vbox;
1141
1145
  GtkWidget *toggle;
1145
1149
  GtkObject *adj;
1146
1150
  gboolean   run;
1147
1151
 
1148
 
  dlg = gimp_dialog_new (_("Save as XBM"), "xbm",
1149
 
                         NULL, 0,
1150
 
                         gimp_standard_help_func, "file-xbm-save",
1151
 
 
1152
 
                         GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1153
 
                         GTK_STOCK_OK,     GTK_RESPONSE_OK,
1154
 
 
1155
 
                         NULL);
 
1152
  dialog = gimp_dialog_new (_("Save as XBM"), PLUG_IN_BINARY,
 
1153
                            NULL, 0,
 
1154
                            gimp_standard_help_func, SAVE_PROC,
 
1155
 
 
1156
                            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 
1157
                            GTK_STOCK_SAVE,   GTK_RESPONSE_OK,
 
1158
 
 
1159
                            NULL);
 
1160
 
 
1161
  gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
 
1162
                                           GTK_RESPONSE_OK,
 
1163
                                           GTK_RESPONSE_CANCEL,
 
1164
                                           -1);
 
1165
 
 
1166
  gimp_window_set_transient (GTK_WINDOW (dialog));
1156
1167
 
1157
1168
  /* parameter settings */
1158
1169
  frame = gimp_frame_new (_("XBM Options"));
1159
1170
  gtk_container_set_border_width (GTK_CONTAINER (frame), 12);
1160
 
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), frame, TRUE, TRUE, 0);
 
1171
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
 
1172
                      frame, TRUE, TRUE, 0);
1161
1173
  gtk_widget_show (frame);
1162
1174
 
1163
1175
  vbox = gtk_vbox_new (FALSE, 12);
1230
1242
  gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
1231
1243
                             _("Hot spot _X:"), 0.0, 0.5,
1232
1244
                             spinbutton, 1, TRUE);
1233
 
  g_signal_connect (adj, "value_changed",
 
1245
  g_signal_connect (adj, "value-changed",
1234
1246
                    G_CALLBACK (gimp_int_adjustment_update),
1235
1247
                    &xsvals.x_hot);
1236
1248
 
1240
1252
  gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
1241
1253
                             _("Hot spot _Y:"), 0.0, 0.5,
1242
1254
                             spinbutton, 1, TRUE);
1243
 
  g_signal_connect (adj, "value_changed",
 
1255
  g_signal_connect (adj, "value-changed",
1244
1256
                    G_CALLBACK (gimp_int_adjustment_update),
1245
1257
                    &xsvals.y_hot);
1246
1258
 
1281
1293
 
1282
1294
  /* Done. */
1283
1295
  gtk_widget_show (vbox);
1284
 
  gtk_widget_show (dlg);
1285
 
 
1286
 
  run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK);
1287
 
 
1288
 
  gtk_widget_destroy (dlg);
 
1296
  gtk_widget_show (dialog);
 
1297
 
 
1298
  run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
 
1299
 
 
1300
  gtk_widget_destroy (dialog);
1289
1301
 
1290
1302
  return run;
1291
1303
}
1316
1328
mask_ext_entry_callback (GtkWidget *widget,
1317
1329
                       gpointer   data)
1318
1330
{
1319
 
  memset (xsvals.prefix, 0, sizeof (xsvals.mask_ext));
 
1331
  memset (xsvals.mask_ext, 0, sizeof (xsvals.mask_ext));
1320
1332
  strncpy (xsvals.mask_ext,
1321
1333
           gtk_entry_get_text (GTK_ENTRY (widget)), MAX_MASK_EXT);
1322
1334
}