← Back to branch summary

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

« back to all changes in this revision

Viewing changes to plug-ins/common/vpropagate.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/vpropagate.c
26
26
   (self == min && (! modified_flag))   ; modified_flag holds history of update
27
27
   In other word, pixel itself is not a neighbor of it.
28
28
*/
 
29
/*
 
30
   in response to bug #156545, after lengthy discussion, the meanings of "dilate"
 
31
   and "erode" are being swapped -- 19 May 2006.
 
32
*/
29
33
 
30
34
#include "config.h"
31
35
 
32
 
#include <stdio.h>
33
36
#include <stdlib.h>
34
37
#include <string.h>
35
38
 
36
 
#include <gtk/gtk.h>
37
 
 
38
39
#include <libgimp/gimp.h>
39
40
#include <libgimp/gimpui.h>
40
41
 
41
42
#include "libgimp/stdplugins-intl.h"
42
43
 
43
44
 
44
 
#define DEFAULT_PLUG_IN_NAME "plug_in_vpropagate"
 
45
#define VPROPAGATE_PROC      "plug-in-vpropagate"
 
46
#define ERODE_PROC           "plug-in-erode"
 
47
#define DILATE_PROC          "plug-in-dilate"
 
48
#define PLUG_IN_BINARY       "vpropagate"
45
49
#define PLUG_IN_IMAGE_TYPES  "RGB*, GRAY*"
46
 
#define SHORT_NAME           "vpropagate"
47
 
#define HELP_ID              "plug-in-vpropagate"
48
 
#define ERODE_PLUG_IN_NAME   "plug_in_erode"
49
 
#define DILATE_PLUG_IN_NAME  "plug_in_dilate"
50
 
 
51
50
 
52
51
#define VP_RGB          (1 << 0)
53
52
#define VP_GRAY         (1 << 1)
130
129
                                             int, guchar *, guchar *, guchar *,
131
130
                                             void *);
132
131
 
133
 
GimpPlugInInfo PLUG_IN_INFO =
 
132
const GimpPlugInInfo PLUG_IN_INFO =
134
133
{
135
134
  NULL,  /* init_proc  */
136
135
  NULL,  /* quit_proc  */
138
137
  run,   /* run_proc   */
139
138
};
140
139
 
141
 
#define UPDATE_STEP         20
142
140
#define SCALE_WIDTH        100
143
 
#define PROPAGATING_VALUE  1<<0
144
 
#define PROPAGATING_ALPHA  1<<1
 
141
#define PROPAGATING_VALUE  (1 << 0)
 
142
#define PROPAGATING_ALPHA  (1 << 1)
145
143
 
146
144
/* parameters */
147
145
typedef struct
220
218
static void
221
219
query (void)
222
220
{
223
 
  static GimpParamDef args[] =
 
221
  static const GimpParamDef args[] =
224
222
  {
225
 
    { GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
226
 
    { GIMP_PDB_IMAGE, "image", "Input image (not used)" },
227
 
    { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
228
 
    { GIMP_PDB_INT32, "propagate-mode", "propagate 0:white, 1:black, 2:middle value 3:foreground to peak, 4:foreground, 5:background, 6:opaque, 7:transparent" },
229
 
    { GIMP_PDB_INT32, "propagating-channel", "channels which values are propagated" },
230
 
    { GIMP_PDB_FLOAT, "propagating-rate", "0.0 <= propagatating_rate <= 1.0" },
231
 
    { GIMP_PDB_INT32, "direction-mask", "0 <= direction-mask <= 15" },
232
 
    { GIMP_PDB_INT32, "lower-limit", "0 <= lower-limit <= 255" },
233
 
    { GIMP_PDB_INT32, "upper-limit", "0 <= upper-limit <= 255" }
 
223
    { GIMP_PDB_INT32,    "run-mode",            "Interactive, non-interactive" },
 
224
    { GIMP_PDB_IMAGE,    "image",               "Input image (not used)" },
 
225
    { GIMP_PDB_DRAWABLE, "drawable",            "Input drawable" },
 
226
    { GIMP_PDB_INT32,    "propagate-mode",      "propagate 0:white, 1:black, 2:middle value 3:foreground to peak, 4:foreground, 5:background, 6:opaque, 7:transparent" },
 
227
    { GIMP_PDB_INT32,    "propagating-channel", "channels which values are propagated" },
 
228
    { GIMP_PDB_FLOAT,    "propagating-rate",    "0.0 <= propagatating_rate <= 1.0" },
 
229
    { GIMP_PDB_INT32,    "direction-mask",      "0 <= direction-mask <= 15" },
 
230
    { GIMP_PDB_INT32,    "lower-limit",         "0 <= lower-limit <= 255" },
 
231
    { GIMP_PDB_INT32,    "upper-limit",         "0 <= upper-limit <= 255" }
234
232
  };
235
233
 
236
 
  gimp_install_procedure (DEFAULT_PLUG_IN_NAME,
237
 
                          "Propagate values of the layer",
 
234
  gimp_install_procedure (VPROPAGATE_PROC,
 
235
                          N_("Propagate certain colors to neighboring pixels"),
238
236
                          "Propagate values of the layer",
239
237
                          "Shuji Narazaki (narazaki@InetQ.or.jp)",
240
238
                          "Shuji Narazaki",
245
243
                          G_N_ELEMENTS (args), 0,
246
244
                          args, NULL);
247
245
 
248
 
  gimp_install_procedure (ERODE_PLUG_IN_NAME,
249
 
                          "Erode image",
 
246
  gimp_install_procedure (ERODE_PROC,
 
247
                          N_("Shrink darker areas of the image"),
250
248
                          "Erode image",
251
249
                          "Shuji Narazaki (narazaki@InetQ.or.jp)",
252
250
                          "Shuji Narazaki",
257
255
                          G_N_ELEMENTS (args), 0,
258
256
                          args, NULL);
259
257
 
260
 
  gimp_install_procedure (DILATE_PLUG_IN_NAME,
261
 
                          "Dilate image",
 
258
  gimp_install_procedure (DILATE_PROC,
 
259
                          N_("Grow darker areas of the image"),
262
260
                          "Dilate image",
263
261
                          "Shuji Narazaki (narazaki@InetQ.or.jp)",
264
262
                          "Shuji Narazaki",
269
267
                          G_N_ELEMENTS (args), 0,
270
268
                          args, NULL);
271
269
 
272
 
  gimp_plugin_menu_register (DEFAULT_PLUG_IN_NAME, "<Image>/Filters/Distorts");
273
 
  gimp_plugin_menu_register (ERODE_PLUG_IN_NAME,   "<Image>/Filters/Generic");
274
 
  gimp_plugin_menu_register (DILATE_PLUG_IN_NAME,  "<Image>/Filters/Generic");
 
270
  gimp_plugin_menu_register (VPROPAGATE_PROC, "<Image>/Filters/Distorts");
 
271
  gimp_plugin_menu_register (ERODE_PROC,      "<Image>/Filters/Generic");
 
272
  gimp_plugin_menu_register (DILATE_PROC,     "<Image>/Filters/Generic");
275
273
}
276
274
 
277
275
static void
300
298
  switch (run_mode)
301
299
    {
302
300
    case GIMP_RUN_INTERACTIVE:
303
 
      if (strcmp (name, DEFAULT_PLUG_IN_NAME) == 0)
 
301
      if (strcmp (name, VPROPAGATE_PROC) == 0)
304
302
        {
305
 
          gimp_get_data (DEFAULT_PLUG_IN_NAME, &vpvals);
 
303
          gimp_get_data (VPROPAGATE_PROC, &vpvals);
306
304
          /* building the values of dialog variables from vpvals. */
307
305
          propagate_alpha =
308
306
            (vpvals.propagating_channel & PROPAGATING_ALPHA) ? TRUE : FALSE;
319
317
          if (! vpropagate_dialog (drawable))
320
318
            return;
321
319
        }
322
 
      else if (strcmp (name, ERODE_PLUG_IN_NAME) == 0 ||
323
 
               strcmp (name, DILATE_PLUG_IN_NAME) == 0)
 
320
      else if (strcmp (name, ERODE_PROC) == 0 ||
 
321
               strcmp (name, DILATE_PROC) == 0)
324
322
        {
325
323
          vpvals.propagating_channel = PROPAGATING_VALUE;
326
324
          vpvals.propagating_rate    = 1.0;
328
326
          vpvals.lower_limit         = 0;
329
327
          vpvals.upper_limit         = 255;
330
328
 
331
 
          if (strcmp (name, ERODE_PLUG_IN_NAME) == 0)
 
329
          if (strcmp (name, ERODE_PROC) == 0)
 
330
            vpvals.propagate_mode = 1;
 
331
          else if (strcmp (name, DILATE_PROC) == 0)
332
332
            vpvals.propagate_mode = 0;
333
 
          else if (strcmp (name, DILATE_PLUG_IN_NAME) == 0)
334
 
            vpvals.propagate_mode = 1;
335
333
        }
336
334
      break;
337
335
 
338
336
    case GIMP_RUN_NONINTERACTIVE:
339
 
      if (strcmp (name, DEFAULT_PLUG_IN_NAME) == 0)
 
337
      if (strcmp (name, VPROPAGATE_PROC) == 0)
340
338
        {
341
339
          vpvals.propagate_mode      = param[3].data.d_int32;
342
340
          vpvals.propagating_channel = param[4].data.d_int32;
345
343
          vpvals.lower_limit         = param[7].data.d_int32;
346
344
          vpvals.upper_limit         = param[8].data.d_int32;
347
345
        }
348
 
      else if (strcmp (name, ERODE_PLUG_IN_NAME) == 0 ||
349
 
               strcmp (name, DILATE_PLUG_IN_NAME) == 0)
 
346
      else if (strcmp (name, ERODE_PROC) == 0 ||
 
347
               strcmp (name, DILATE_PROC) == 0)
350
348
        {
351
349
          vpvals.propagating_channel = PROPAGATING_VALUE;
352
350
          vpvals.propagating_rate    = 1.0;
354
352
          vpvals.lower_limit         = 0;
355
353
          vpvals.upper_limit         = 255;
356
354
 
357
 
          if (strcmp (name, ERODE_PLUG_IN_NAME) == 0)
 
355
          if (strcmp (name, ERODE_PROC) == 0)
 
356
            vpvals.propagate_mode = 1;
 
357
          else if (strcmp (name, DILATE_PROC) == 0)
358
358
            vpvals.propagate_mode = 0;
359
 
          else if (strcmp (name, DILATE_PLUG_IN_NAME) == 0)
360
 
            vpvals.propagate_mode = 1;
361
359
        }
362
360
      break;
363
361
 
444
442
    }
445
443
  else
446
444
    {
447
 
      gimp_drawable_mask_bounds (drawable->drawable_id, &begx, &begy, &endx, &endy);
 
445
      gimp_drawable_mask_bounds (drawable->drawable_id,
 
446
                                 &begx, &begy, &endx, &endy);
448
447
      width  = endx - begx;
449
448
      height = endy - begy;
450
449
    }
473
472
  best = g_new (guchar, bytes);
474
473
 
475
474
  if (!preview)
476
 
    gimp_progress_init (_("Value Propagating..."));
 
475
    gimp_progress_init (_("Value Propagate"));
477
476
 
478
477
  gimp_context_get_foreground (&foreground);
479
478
  gimp_rgb_get_uchar (&foreground, fore+0, fore+1, fore+2);
482
481
  for (y = begy ; y < endy ; y++)
483
482
    {
484
483
      prepare_row (&srcRgn, nr, begx, ((y+1) < endy) ? y+1 : endy, endx-begx);
 
484
 
485
485
      for (index = 0; index < (endx - begx) * bytes; index++)
486
486
        dest_row[index] = cr[index];
 
487
 
487
488
      for (x = 0 ; x < endx - begx; x++)
488
489
        {
489
490
          dest = dest_row + (x * bytes);
490
491
          here = cr + (x * bytes);
 
492
 
491
493
          /* *** copy source value to best value holder *** */
492
 
          memcpy ((void *)best, (void *)here, bytes);
 
494
          memcpy (best, here, bytes);
 
495
 
493
496
          if (operation.initializer)
494
497
            (* operation.initializer)(dtype, bytes, best, here, &tmp);
 
498
 
495
499
          /* *** gather neighbors' values: loop-unfolded version *** */
496
500
          if (up_index == -1)
497
501
            for (dx = left_index ; dx <= right_index ; dx++)
505
509
          /* *** store it to dest_row*** */
506
510
          (* operation.finalizer)(dtype, bytes, best, here, dest, tmp);
507
511
        }
 
512
 
508
513
      /* now store destline to destRgn */
509
514
      gimp_pixel_rgn_set_row (&destRgn, dest_row, begx, y, endx - begx);
 
515
 
510
516
      /* shift the row pointers  */
511
517
      swap = pr;
512
518
      pr = cr;
513
519
      cr = nr;
514
520
      nr = swap;
515
 
      /* update each UPDATE_STEP (optimizer must generate cheap code) */
516
 
      if (((y % 5) == 0) && !preview) /*(y % (int) ((endy - begy) / UPDATE_STEP)) == 0 */
517
 
        gimp_progress_update ((double)y / (double)(endy - begy));
 
521
 
 
522
 
 
523
      if (((y % 5) == 0) && !preview)
 
524
        gimp_progress_update ((gdouble) y / (gdouble) (endy - begy));
518
525
    }
519
526
 
520
527
  if (preview)
1053
1060
  gint       index = 0;
1054
1061
  gboolean   run;
1055
1062
 
1056
 
  gimp_ui_init ("vpropagate", FALSE);
 
1063
  gimp_ui_init (PLUG_IN_BINARY, FALSE);
1057
1064
 
1058
 
  dialog = gimp_dialog_new (_("Value Propagate"), "vpropagate",
 
1065
  dialog = gimp_dialog_new (_("Value Propagate"), PLUG_IN_BINARY,
1059
1066
                            NULL, 0,
1060
 
                            gimp_standard_help_func, HELP_ID,
 
1067
                            gimp_standard_help_func, VPROPAGATE_PROC,
1061
1068
 
1062
1069
                            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1063
1070
                            GTK_STOCK_OK,     GTK_RESPONSE_OK,
1064
1071
 
1065
1072
                            NULL);
1066
1073
 
 
1074
  gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
 
1075
                                           GTK_RESPONSE_OK,
 
1076
                                           GTK_RESPONSE_CANCEL,
 
1077
                                           -1);
 
1078
 
 
1079
  gimp_window_set_transient (GTK_WINDOW (dialog));
 
1080
 
1067
1081
  main_vbox = gtk_vbox_new (FALSE, 12);
1068
1082
  gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
1069
1083
  gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox);
1130
1144
                              vpvals.lower_limit, 0, 255, 1, 8, 0,
1131
1145
                              TRUE, 0, 0,
1132
1146
                              NULL, NULL);
1133
 
  g_signal_connect (adj, "value_changed",
 
1147
  g_signal_connect (adj, "value-changed",
1134
1148
                    G_CALLBACK (gimp_int_adjustment_update),
1135
1149
                    &vpvals.lower_limit);
1136
 
  g_signal_connect_swapped (adj, "value_changed",
 
1150
  g_signal_connect_swapped (adj, "value-changed",
1137
1151
                            G_CALLBACK (gimp_preview_invalidate),
1138
1152
                            preview);
1139
1153
 
1142
1156
                              vpvals.upper_limit, 0, 255, 1, 8, 0,
1143
1157
                              TRUE, 0, 0,
1144
1158
                              NULL, NULL);
1145
 
  g_signal_connect (adj, "value_changed",
 
1159
  g_signal_connect (adj, "value-changed",
1146
1160
                    G_CALLBACK (gimp_int_adjustment_update),
1147
1161
                    &vpvals.upper_limit);
1148
 
  g_signal_connect_swapped (adj, "value_changed",
 
1162
  g_signal_connect_swapped (adj, "value-changed",
1149
1163
                            G_CALLBACK (gimp_preview_invalidate),
1150
1164
                            preview);
1151
1165
 
1154
1168
                              vpvals.propagating_rate, 0, 1, 0.01, 0.1, 2,
1155
1169
                              TRUE, 0, 0,
1156
1170
                              NULL, NULL);
1157
 
  g_signal_connect (adj, "value_changed",
 
1171
  g_signal_connect (adj, "value-changed",
1158
1172
                    G_CALLBACK (gimp_double_adjustment_update),
1159
1173
                    &vpvals.propagating_rate);
1160
 
  g_signal_connect_swapped (adj, "value_changed",
 
1174
  g_signal_connect_swapped (adj, "value-changed",
1161
1175
                            G_CALLBACK (gimp_preview_invalidate),
1162
1176
                            preview);
1163
1177
 
1179
1193
      GtkWidget *toggle;
1180
1194
 
1181
1195
      toggle =
1182
 
        gtk_table_add_toggle (table, _("Propagating _Alpha Channel"),
 
1196
        gtk_table_add_toggle (table, _("Propagating _alpha channel"),
1183
1197
                              0, 3, 6,
1184
1198
                              G_CALLBACK (vpropagate_toggle_button_update),
1185
1199
                              &propagate_alpha);
1186
1200
 
1187
 
      if (gimp_layer_get_preserve_trans (drawable->drawable_id))
 
1201
      if (gimp_layer_get_lock_alpha (drawable->drawable_id))
1188
1202
        {
1189
1203
          gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), 0);
1190
1204
          gtk_widget_set_sensitive (toggle, FALSE);
1191
1205
        }
1192
1206
 
1193
 
      gtk_table_add_toggle (table, _("Propagating Value Channel"), 0, 3, 7,
 
1207
      gtk_table_add_toggle (table, _("Propagating value channel"), 0, 3, 7,
1194
1208
                            G_CALLBACK (vpropagate_toggle_button_update),
1195
1209
                            &propagate_value);
1196
1210
    }