← Back to branch summary

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

« back to all changes in this revision

Viewing changes to plug-ins/common/flarefx.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/flarefx.c
47
47
 
48
48
#include <string.h>
49
49
 
50
 
#include <gtk/gtk.h>
51
 
 
52
50
#include <libgimp/gimp.h>
53
51
#include <libgimp/gimpui.h>
54
52
 
55
53
#include "libgimp/stdplugins-intl.h"
56
54
 
57
55
 
 
56
#define PLUG_IN_PROC   "plug-in-flarefx"
 
57
#define PLUG_IN_BINARY "flarefx"
 
58
 
58
59
/* --- Typedefs --- */
59
60
typedef struct
60
61
{
61
62
  gint     posx;
62
63
  gint     posy;
63
 
  gboolean preview;
64
64
} FlareValues;
65
65
 
66
66
typedef struct REFLECT
147
147
 
148
148
 
149
149
/* --- Variables --- */
150
 
GimpPlugInInfo PLUG_IN_INFO =
 
150
const GimpPlugInInfo PLUG_IN_INFO =
151
151
{
152
152
  NULL,  /* init_proc  */
153
153
  NULL,  /* quit_proc  */
157
157
 
158
158
static FlareValues fvals =
159
159
{
160
 
  128, 128,   /* posx, posy */
161
 
  TRUE        /* preview    */
 
160
  128, 128   /* posx, posy */
162
161
};
163
162
 
164
163
static gfloat     scolor, sglow, sinner, souter; /* size     */
176
175
static void
177
176
query (void)
178
177
{
179
 
  static GimpParamDef args[] =
 
178
  static const GimpParamDef args[] =
180
179
  {
181
 
    { GIMP_PDB_INT32,    "run_mode", "Interactive, non-interactive" },
 
180
    { GIMP_PDB_INT32,    "run-mode", "Interactive, non-interactive" },
182
181
    { GIMP_PDB_IMAGE,    "image",    "Input image (unused)"         },
183
182
    { GIMP_PDB_DRAWABLE, "drawable", "Input drawable"               },
184
 
    { GIMP_PDB_INT32,    "posx",     "X-position"                   },
185
 
    { GIMP_PDB_INT32,    "posy",     "Y-position"                   }
 
183
    { GIMP_PDB_INT32,    "pos-x",    "X-position"                   },
 
184
    { GIMP_PDB_INT32,    "pos-y",    "Y-position"                   }
186
185
  };
187
186
 
188
 
  gimp_install_procedure ("plug_in_flarefx",
189
 
                          "Add lens flare effects",
 
187
  gimp_install_procedure (PLUG_IN_PROC,
 
188
                          N_("Add a lens flare effect"),
190
189
                          "Adds a lens flare effects.  Makes your image look "
191
190
                          "like it was snapped with a cheap camera with a lot "
192
191
                          "of lens :)",
193
192
                          "Karl-Johan Andersson", /* Author */
194
193
                          "Karl-Johan Andersson", /* Copyright */
195
194
                          "May 2000",
196
 
                          N_("_FlareFX..."),
 
195
                          N_("Lens _Flare..."),
197
196
                          "RGB*",
198
197
                          GIMP_PLUGIN,
199
198
                          G_N_ELEMENTS (args), 0,
200
199
                          args, NULL);
201
200
 
202
 
  gimp_plugin_menu_register ("plug_in_flarefx",
203
 
                             "<Image>/Filters/Light Effects");
 
201
  gimp_plugin_menu_register (PLUG_IN_PROC,
 
202
                             "<Image>/Filters/Light and Shadow/Light");
204
203
}
205
204
 
206
205
static void
232
231
    {
233
232
    case GIMP_RUN_INTERACTIVE:
234
233
      /*  Possibly retrieve data  */
235
 
      gimp_get_data ("plug_in_flarefx", &fvals);
 
234
      gimp_get_data (PLUG_IN_PROC, &fvals);
236
235
 
237
236
      /*  First acquire information with a dialog  */
238
237
      if (! flare_dialog (drawable))
255
254
 
256
255
    case GIMP_RUN_WITH_LAST_VALS:
257
256
      /*  Possibly retrieve data  */
258
 
      gimp_get_data ("plug_in_flarefx", &fvals);
 
257
      gimp_get_data (PLUG_IN_PROC, &fvals);
259
258
      break;
260
259
 
261
260
    default:
268
267
      if (gimp_drawable_is_rgb (drawable->drawable_id) ||
269
268
          gimp_drawable_is_gray (drawable->drawable_id))
270
269
        {
271
 
          gimp_progress_init (_("Render Flare..."));
 
270
          gimp_progress_init (_("Render lens flare"));
272
271
          gimp_tile_cache_ntiles (2 *
273
272
                                  (drawable->width / gimp_tile_width () + 1));
274
273
 
279
278
 
280
279
          /*  Store data  */
281
280
          if (run_mode == GIMP_RUN_INTERACTIVE)
282
 
            gimp_set_data ("plug_in_flarefx", &fvals, sizeof (FlareValues));
 
281
            gimp_set_data (PLUG_IN_PROC, &fvals, sizeof (FlareValues));
283
282
        }
284
283
      else
285
284
        {
286
 
          /* gimp_message ("FlareFX: cannot operate on indexed color images"); */
287
285
          status = GIMP_PDB_EXECUTION_ERROR;
288
286
        }
289
287
    }
303
301
  GtkWidget   *frame;
304
302
  gboolean     run;
305
303
 
306
 
  gimp_ui_init ("flarefx", TRUE);
 
304
  gimp_ui_init (PLUG_IN_BINARY, TRUE);
307
305
 
308
 
  dialog = gimp_dialog_new (_("FlareFX"), "flarefx",
 
306
  dialog = gimp_dialog_new (_("Lens Flare"), PLUG_IN_BINARY,
309
307
                            NULL, 0,
310
 
                            gimp_standard_help_func, "plug-in-flarefx",
 
308
                            gimp_standard_help_func, PLUG_IN_PROC,
311
309
 
312
310
                            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
313
311
                            GTK_STOCK_OK,     GTK_RESPONSE_OK,
314
312
 
315
313
                            NULL);
316
314
 
 
315
  gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
 
316
                                           GTK_RESPONSE_OK,
 
317
                                           GTK_RESPONSE_CANCEL,
 
318
                                           -1);
 
319
 
 
320
  gimp_window_set_transient (GTK_WINDOW (dialog));
 
321
 
317
322
  main_vbox = gtk_vbox_new (FALSE, 12);
318
323
  gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
319
324
  gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox);
320
325
  gtk_widget_show (main_vbox);
321
326
 
322
 
  preview = gimp_aspect_preview_new (drawable, &fvals.preview);
 
327
  preview = gimp_zoom_preview_new (drawable);
323
328
  gtk_widget_add_events (GIMP_PREVIEW (preview)->area,
324
329
                         GDK_POINTER_MOTION_MASK);
325
330
  gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0);
361
366
  bytes  = drawable->bpp;
362
367
  if (preview)
363
368
    {
364
 
      gimp_preview_get_size (preview, &width, &height);
365
 
      src = gimp_drawable_get_thumbnail_data (drawable->drawable_id,
366
 
                                              &width, &height, &bytes);
 
369
      src = gimp_zoom_preview_get_source (GIMP_ZOOM_PREVIEW (preview),
 
370
                                          &width, &height, &bytes);
367
371
 
368
372
      xs = (gdouble)fvals.posx * width  / drawable->width;
369
373
      ys = (gdouble)fvals.posy * height / drawable->height;
723
727
{
724
728
  FlareCenter *center;
725
729
  GtkWidget   *frame;
 
730
  GtkWidget   *hbox;
726
731
  GtkWidget   *check;
727
732
  gint32       image_ID;
728
733
  gdouble      res_x;
746
751
                            G_CALLBACK (g_free),
747
752
                            center);
748
753
 
 
754
  hbox = gtk_hbox_new (FALSE, 0);
 
755
  gtk_container_add (GTK_CONTAINER (frame), hbox);
 
756
  gtk_widget_show (hbox);
 
757
 
749
758
  image_ID = gimp_drawable_get_image (drawable->drawable_id);
750
759
  gimp_image_get_resolution (image_ID, &res_x, &res_y);
751
760
 
764
773
                                         0, drawable->height);
765
774
 
766
775
  gtk_table_set_row_spacing (GTK_TABLE (center->coords), 1, 12);
767
 
  gtk_container_add (GTK_CONTAINER (frame), center->coords);
 
776
  gtk_box_pack_start (GTK_BOX (hbox), center->coords, FALSE, FALSE, 0);
768
777
  gtk_widget_show (center->coords);
769
778
 
770
 
  g_signal_connect (center->coords, "value_changed",
 
779
  g_signal_connect (center->coords, "value-changed",
771
780
                    G_CALLBACK (flare_center_coords_update),
772
781
                    center);
773
 
  g_signal_connect (center->coords, "refval_changed",
 
782
  g_signal_connect (center->coords, "refval-changed",
774
783
                    G_CALLBACK (flare_center_coords_update),
775
784
                    center);
776
785
 
777
 
  check = gtk_check_button_new_with_mnemonic (_("_Show cursor"));
 
786
  check = gtk_check_button_new_with_mnemonic (_("Show _position"));
778
787
  gtk_table_attach (GTK_TABLE (center->coords), check, 0, 5, 2, 3,
779
788
                    GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
780
789
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), show_cursor);
790
799
  g_signal_connect (preview->area, "realize",
791
800
                    G_CALLBACK (flare_center_preview_realize),
792
801
                    center);
793
 
  g_signal_connect_after (preview->area, "expose_event",
 
802
  g_signal_connect_after (preview->area, "expose-event",
794
803
                          G_CALLBACK (flare_center_preview_expose),
795
804
                          center);
796
805
  g_signal_connect (preview->area, "event",