← Back to branch summary

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

« back to all changes in this revision

Viewing changes to plug-ins/common/diffraction.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/diffraction.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
 * Diffraction plug-in --- Generate diffraction patterns
23
23
 
24
24
#include "config.h"
25
25
 
26
 
#include <stdio.h>
27
 
#include <stdlib.h>
28
 
#ifdef HAVE_UNISTD_H
29
 
#include <unistd.h>
30
 
#endif
31
 
#include <sys/types.h>
32
 
 
33
 
#include <gtk/gtk.h>
34
 
 
35
26
#include <libgimp/gimp.h>
36
27
#include <libgimp/gimpui.h>
37
28
 
38
29
#include "libgimp/stdplugins-intl.h"
39
30
 
40
31
 
 
32
#define PLUG_IN_PROC   "plug-in-diffraction"
 
33
#define PLUG_IN_BINARY "diffraction"
 
34
 
 
35
 
41
36
/***** Magic numbers *****/
42
37
#define ITERATIONS      100
43
38
#define WEIRD_FACTOR      0.04
106
101
 
107
102
/***** Variables *****/
108
103
 
109
 
GimpPlugInInfo PLUG_IN_INFO =
 
104
const GimpPlugInInfo PLUG_IN_INFO =
110
105
{
111
106
  NULL,  /* init  */
112
107
  NULL,  /* quit  */
149
144
static void
150
145
query (void)
151
146
{
152
 
  static GimpParamDef args[] =
 
147
  static const GimpParamDef args[] =
153
148
  {
154
 
    { GIMP_PDB_INT32,    "run_mode",     "Interactive, non-interactive" },
 
149
    { GIMP_PDB_INT32,    "run-mode",     "Interactive, non-interactive" },
155
150
    { GIMP_PDB_IMAGE,    "image",        "Input image" },
156
151
    { GIMP_PDB_DRAWABLE, "drawable",     "Input drawable" },
157
 
    { GIMP_PDB_FLOAT,    "lam_r",        "Light frequency (red)" },
158
 
    { GIMP_PDB_FLOAT,     "lam_g",        "Light frequency (green)" },
159
 
    { GIMP_PDB_FLOAT,     "lam_b",        "Light frequency (blue)" },
160
 
    { GIMP_PDB_FLOAT,     "contour_r",    "Number of contours (red)" },
161
 
    { GIMP_PDB_FLOAT,     "contour_g",    "Number of contours (green)" },
162
 
    { GIMP_PDB_FLOAT,     "contour_b",    "Number of contours (blue)" },
163
 
    { GIMP_PDB_FLOAT,     "edges_r",      "Number of sharp edges (red)" },
164
 
    { GIMP_PDB_FLOAT,     "edges_g",      "Number of sharp edges (green)" },
165
 
    { GIMP_PDB_FLOAT,     "edges_b",      "Number of sharp edges (blue)" },
166
 
    { GIMP_PDB_FLOAT,     "brightness",   "Brightness and shifting/fattening of contours" },
167
 
    { GIMP_PDB_FLOAT,     "scattering",   "Scattering (Speed vs. quality)" },
168
 
    { GIMP_PDB_FLOAT,     "polarization", "Polarization" }
 
152
    { GIMP_PDB_FLOAT,    "lam-r",        "Light frequency (red)" },
 
153
    { GIMP_PDB_FLOAT,    "lam-g",        "Light frequency (green)" },
 
154
    { GIMP_PDB_FLOAT,    "lam-b",        "Light frequency (blue)" },
 
155
    { GIMP_PDB_FLOAT,    "contour-r",    "Number of contours (red)" },
 
156
    { GIMP_PDB_FLOAT,    "contour-g",    "Number of contours (green)" },
 
157
    { GIMP_PDB_FLOAT,    "contour-b",    "Number of contours (blue)" },
 
158
    { GIMP_PDB_FLOAT,    "edges-r",      "Number of sharp edges (red)" },
 
159
    { GIMP_PDB_FLOAT,    "edges-g",      "Number of sharp edges (green)" },
 
160
    { GIMP_PDB_FLOAT,    "edges-b",      "Number of sharp edges (blue)" },
 
161
    { GIMP_PDB_FLOAT,    "brightness",   "Brightness and shifting/fattening of contours" },
 
162
    { GIMP_PDB_FLOAT,    "scattering",   "Scattering (Speed vs. quality)" },
 
163
    { GIMP_PDB_FLOAT,    "polarization", "Polarization" }
169
164
  };
170
165
 
171
 
  gimp_install_procedure ("plug_in_diffraction",
172
 
                          "Generate diffraction patterns",
173
 
                          "Help?  What help?  Real men do not need help :-)",  /* FIXME */
 
166
  gimp_install_procedure (PLUG_IN_PROC,
 
167
                          N_("Generate diffraction patterns"),
 
168
                          "Help?  What help?  Real men do not need help :-)",
174
169
                          "Federico Mena Quintero",
175
170
                          "Federico Mena Quintero & David Bleecker",
176
171
                          "April 1997, 0.5",
180
175
                          G_N_ELEMENTS (args), 0,
181
176
                          args, NULL);
182
177
 
183
 
  gimp_plugin_menu_register ("plug_in_diffraction",
184
 
                             "<Image>/Filters/Render/Pattern");
 
178
  gimp_plugin_menu_register (PLUG_IN_PROC, "<Image>/Filters/Render/Pattern");
185
179
}
186
180
 
187
181
static void
217
211
    {
218
212
    case GIMP_RUN_INTERACTIVE:
219
213
      /* Possibly retrieve data */
220
 
      gimp_get_data ("plug_in_diffraction", &dvals);
 
214
      gimp_get_data (PLUG_IN_PROC, &dvals);
221
215
 
222
216
      /* Get information from the dialog */
223
217
      if (!diffraction_dialog ())
250
244
 
251
245
    case GIMP_RUN_WITH_LAST_VALS:
252
246
      /* Possibly retrieve data */
253
 
      gimp_get_data ("plug_in_diffraction", &dvals);
 
247
      gimp_get_data (PLUG_IN_PROC, &dvals);
254
248
      break;
255
249
 
256
250
    default:
261
255
  active_drawable = gimp_drawable_get (param[2].data.d_drawable);
262
256
 
263
257
  /* Create the diffraction pattern */
264
 
  if ((status == GIMP_PDB_SUCCESS) && gimp_drawable_is_rgb(active_drawable->drawable_id))
 
258
  if ((status == GIMP_PDB_SUCCESS) &&
 
259
      gimp_drawable_is_rgb (active_drawable->drawable_id))
265
260
    {
266
261
      /* Set the tile cache size */
267
262
      gimp_tile_cache_ntiles ((active_drawable->width + gimp_tile_width() - 1) /
276
271
 
277
272
      /* Store data */
278
273
      if (run_mode == GIMP_RUN_INTERACTIVE)
279
 
        gimp_set_data ("plug_in_diffraction",
280
 
                       &dvals, sizeof(diffraction_vals_t));
 
274
        gimp_set_data (PLUG_IN_PROC, &dvals, sizeof (diffraction_vals_t));
281
275
    }
282
276
  else if (status == GIMP_PDB_SUCCESS)
283
 
    status = GIMP_PDB_EXECUTION_ERROR;
 
277
    {
 
278
      status = GIMP_PDB_EXECUTION_ERROR;
 
279
    }
284
280
 
285
281
  values[0].data.d_status = status;
286
282
 
309
305
  py = 5.0 + param->dvert * (y - param->y1);
310
306
 
311
307
  diff_diffract (px, py, &rgb);
312
 
  
 
308
 
313
309
  dest[0] = 255.0 * rgb.r;
314
310
  dest[1] = 255.0 * rgb.g;
315
311
  dest[2] = 255.0 * rgb.b;
316
 
  
 
312
 
317
313
  if (bpp == 4)
318
314
    dest[3] = 255;
319
315
}
331
327
  param.dhoriz = 10.0 / (x2 - x1 - 1);
332
328
  param.dvert  = -10.0 / (y2 - y1 - 1);
333
329
 
334
 
  gimp_progress_init (_("Creating diffraction pattern..."));
 
330
  gimp_progress_init (_("Creating diffraction pattern"));
335
331
  iter = gimp_rgn_iterator_new (drawable, 0);
336
332
  gimp_rgn_iterator_dest (iter, diffraction_func, &param);
337
333
  gimp_rgn_iterator_free (iter);
433
429
  GtkObject *adj;
434
430
  gboolean   run;
435
431
 
436
 
  gimp_ui_init ("diffraction", TRUE);
 
432
  gimp_ui_init (PLUG_IN_BINARY, TRUE);
437
433
 
438
 
  dialog = gimp_dialog_new (_("Diffraction Patterns"), "diffraction",
 
434
  dialog = gimp_dialog_new (_("Diffraction Patterns"), PLUG_IN_BINARY,
439
435
                            NULL, 0,
440
 
                            gimp_standard_help_func, "plug-in-diffraction",
 
436
                            gimp_standard_help_func, PLUG_IN_PROC,
441
437
 
442
438
                            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
443
439
                            GTK_STOCK_OK,     GTK_RESPONSE_OK,
444
440
 
445
441
                            NULL);
446
442
 
 
443
  gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
 
444
                                           GTK_RESPONSE_OK,
 
445
                                           GTK_RESPONSE_CANCEL,
 
446
                                           -1);
 
447
 
 
448
  gimp_window_set_transient (GTK_WINDOW (dialog));
 
449
 
447
450
  hbox = gtk_hbox_new (FALSE, 12);
448
451
  gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
449
452
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox,
499
502
                              dvals.lam_r, 0.0, 20.0, 0.2, 1.0, 3,
500
503
                              TRUE, 0, 0,
501
504
                              NULL, NULL);
502
 
  g_signal_connect (adj, "value_changed",
 
505
  g_signal_connect (adj, "value-changed",
503
506
                    G_CALLBACK (gimp_double_adjustment_update),
504
507
                    &dvals.lam_r);
505
508
 
508
511
                              dvals.lam_g, 0.0, 20.0, 0.2, 1.0, 3,
509
512
                              TRUE, 0, 0,
510
513
                              NULL, NULL);
511
 
  g_signal_connect (adj, "value_changed",
 
514
  g_signal_connect (adj, "value-changed",
512
515
                    G_CALLBACK (gimp_double_adjustment_update),
513
516
                    &dvals.lam_g);
514
517
 
517
520
                              dvals.lam_b, 0.0, 20.0, 0.2, 1.0, 3,
518
521
                              TRUE, 0, 0,
519
522
                              NULL, NULL);
520
 
  g_signal_connect (adj, "value_changed",
 
523
  g_signal_connect (adj, "value-changed",
521
524
                    G_CALLBACK (gimp_double_adjustment_update),
522
525
                    &dvals.lam_b);
523
526
 
537
540
                              dvals.contour_r, 0.0, 10.0, 0.1, 1.0, 3,
538
541
                              TRUE, 0, 0,
539
542
                              NULL, NULL);
540
 
  g_signal_connect (adj, "value_changed",
 
543
  g_signal_connect (adj, "value-changed",
541
544
                    G_CALLBACK (gimp_double_adjustment_update),
542
545
                    &dvals.contour_r);
543
546
 
546
549
                              dvals.contour_g, 0.0, 10.0, 0.1, 1.0, 3,
547
550
                              TRUE, 0, 0,
548
551
                              NULL, NULL);
549
 
  g_signal_connect (adj, "value_changed",
 
552
  g_signal_connect (adj, "value-changed",
550
553
                    G_CALLBACK (gimp_double_adjustment_update),
551
554
                    &dvals.contour_g);
552
555
 
555
558
                              dvals.contour_b, 0.0, 10.0, 0.1, 1.0, 3,
556
559
                              TRUE, 0, 0,
557
560
                              NULL, NULL);
558
 
  g_signal_connect (adj, "value_changed",
 
561
  g_signal_connect (adj, "value-changed",
559
562
                    G_CALLBACK (gimp_double_adjustment_update),
560
563
                    &dvals.contour_b);
561
564
 
575
578
                              dvals.edges_r, 0.0, 1.0, 0.01, 0.1, 3,
576
579
                              TRUE, 0, 0,
577
580
                              NULL, NULL);
578
 
  g_signal_connect (adj, "value_changed",
 
581
  g_signal_connect (adj, "value-changed",
579
582
                    G_CALLBACK (gimp_double_adjustment_update),
580
583
                    &dvals.edges_r);
581
584
 
584
587
                              dvals.edges_g, 0.0, 1.0, 0.01, 0.1, 3,
585
588
                              TRUE, 0, 0,
586
589
                              NULL, NULL);
587
 
  g_signal_connect (adj, "value_changed",
 
590
  g_signal_connect (adj, "value-changed",
588
591
                    G_CALLBACK (gimp_double_adjustment_update),
589
592
                    &dvals.edges_g);
590
593
 
593
596
                              dvals.edges_b, 0.0, 1.0, 0.01, 0.1, 3,
594
597
                              TRUE, 0, 0,
595
598
                              NULL, NULL);
596
 
  g_signal_connect (adj, "value_changed",
 
599
  g_signal_connect (adj, "value-changed",
597
600
                    G_CALLBACK (gimp_double_adjustment_update),
598
601
                    &dvals.edges_b);
599
602
 
600
 
  label = gtk_label_new_with_mnemonic (_("Sharp edges"));
 
603
  label = gtk_label_new_with_mnemonic (_("Sharp Edges"));
601
604
  gtk_notebook_append_page (GTK_NOTEBOOK (notebook), table, label);
602
605
 
603
606
  /* Other options tab */
613
616
                              dvals.brightness, 0.0, 1.0, 0.01, 0.1, 3,
614
617
                              TRUE, 0, 0,
615
618
                              NULL, NULL);
616
 
  g_signal_connect (adj, "value_changed",
 
619
  g_signal_connect (adj, "value-changed",
617
620
                    G_CALLBACK (gimp_double_adjustment_update),
618
621
                    &dvals.brightness);
619
622
 
622
625
                              dvals.scattering, 0.0, 100.0, 1.0, 10.0, 3,
623
626
                              TRUE, 0, 0,
624
627
                              NULL, NULL);
625
 
  g_signal_connect (adj, "value_changed",
 
628
  g_signal_connect (adj, "value-changed",
626
629
                    G_CALLBACK (gimp_double_adjustment_update),
627
630
                    &dvals.scattering);
628
631
 
631
634
                              dvals.polarization, -1.0, 1.0, 0.02, 0.2, 3,
632
635
                              TRUE, 0, 0,
633
636
                              NULL, NULL);
634
 
  g_signal_connect (adj, "value_changed",
 
637
  g_signal_connect (adj, "value-changed",
635
638
                    G_CALLBACK (gimp_double_adjustment_update),
636
639
                    &dvals.polarization);
637
640
 
638
 
  label = gtk_label_new_with_mnemonic (_("Other options"));
 
641
  label = gtk_label_new_with_mnemonic (_("Other Options"));
639
642
  gtk_notebook_append_page (GTK_NOTEBOOK (notebook), table, label);
640
643
 
641
644
  /* Done */
686
689
          px += dx;
687
690
        }
688
691
 
689
 
      if ((y%10)==0)
690
 
      {
691
 
        gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (dint.progress),
692
 
                                       (gdouble) y /
693
 
                                       (gdouble) (PREVIEW_HEIGHT - 1));
694
 
        while (gtk_events_pending ())
695
 
          gtk_main_iteration ();
696
 
      }
 
692
      if ((y % 10) == 0)
 
693
        {
 
694
          gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (dint.progress),
 
695
                                         (gdouble) y /
 
696
                                         (gdouble) (PREVIEW_HEIGHT - 1));
 
697
          while (gtk_events_pending ())
 
698
            gtk_main_iteration ();
 
699
        }
 
700
 
697
701
      py += dy;
698
702
    }
699
703