summaryrefslogtreecommitdiffstats
path: root/plug-ins/gimpressionist/orientmap.c
diff options
context:
space:
mode:
Diffstat (limited to 'plug-ins/gimpressionist/orientmap.c')
-rw-r--r--plug-ins/gimpressionist/orientmap.c717
1 files changed, 717 insertions, 0 deletions
diff --git a/plug-ins/gimpressionist/orientmap.c b/plug-ins/gimpressionist/orientmap.c
new file mode 100644
index 0000000..1b8b765
--- /dev/null
+++ b/plug-ins/gimpressionist/orientmap.c
@@ -0,0 +1,717 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * 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 3 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, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <gtk/gtk.h>
+
+#include <libgimp/gimp.h>
+#include <libgimp/gimpui.h>
+
+#include "gimpressionist.h"
+#include "ppmtool.h"
+#include "infile.h"
+
+#include "preview.h"
+
+#include "orientmap.h"
+
+#include "libgimp/stdplugins-intl.h"
+
+#define NUMVECTYPES 4
+
+static GtkWidget *orient_map_window;
+
+static GtkWidget *vector_preview;
+static GtkWidget *orient_map_preview_prev;
+static GtkWidget *prev_button;
+static GtkWidget *next_button;
+static GtkWidget *add_button;
+static GtkWidget *kill_button;
+static GtkAdjustment *vector_preview_brightness_adjust = NULL;
+
+static GtkAdjustment *angle_adjust = NULL;
+static GtkAdjustment *strength_adjust = NULL;
+static GtkAdjustment *orient_map_str_exp_adjust = NULL;
+static GtkAdjustment *angle_offset_adjust = NULL;
+static GtkWidget *vector_types[NUMVECTYPES];
+static GtkWidget *orient_voronoi = NULL;
+
+#define OMWIDTH 150
+#define OMHEIGHT 150
+
+static vector_t vector[MAXORIENTVECT];
+static gint num_vectors = 0;
+static gint vector_type;
+
+static ppm_t update_om_preview_nbuffer = {0, 0, NULL};
+
+static gint selectedvector = 0;
+static ppm_t update_vector_preview_backup = {0, 0, NULL};
+static ppm_t update_vector_preview_buffer = {0, 0, NULL};
+
+static gboolean adjignore = FALSE;
+
+double get_direction (double x, double y, int from)
+{
+ gint i;
+ gint n;
+ gint voronoi;
+ gdouble sum, dx, dy, dst;
+ vector_t *vec;
+ gdouble angoff, strexp;
+ gint first = 0, last;
+
+ if (from == 0)
+ {
+ n = num_vectors;
+ vec = vector;
+ angoff = gtk_adjustment_get_value (angle_offset_adjust);
+ strexp = gtk_adjustment_get_value (orient_map_str_exp_adjust);
+ voronoi = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (orient_voronoi));
+ }
+ else
+ {
+ n = pcvals.num_orient_vectors;
+ vec = pcvals.orient_vectors;
+ angoff = pcvals.orient_angle_offset;
+ strexp = pcvals.orient_strength_exponent;
+ voronoi = pcvals.orient_voronoi;
+ }
+
+ if (voronoi)
+ {
+ gdouble bestdist = -1.0;
+
+ for (i = 0; i < n; i++)
+ {
+ dst = dist (x,y,vec[i].x,vec[i].y);
+
+ if ((bestdist < 0.0) || (dst < bestdist))
+ {
+ bestdist = dst;
+ first = i;
+ }
+ }
+ last = first+1;
+ }
+ else
+ {
+ first = 0;
+ last = n;
+ }
+
+ dx = dy = 0.0;
+ sum = 0.0;
+ for (i = first; i < last; i++)
+ {
+ gdouble s = vec[i].str;
+ gdouble tx = 0.0, ty = 0.0;
+
+ if (vec[i].type == 0)
+ {
+ tx = vec[i].dx;
+ ty = vec[i].dy;
+ }
+ else if (vec[i].type == 1)
+ {
+ gdouble a = atan2 (vec[i].dy, vec[i].dx);
+
+ a -= atan2 (y-vec[i].y, x-vec[i].x);
+ tx = sin (a + G_PI_2);
+ ty = cos (a + G_PI_2);
+ }
+ else if (vec[i].type == 2)
+ {
+ gdouble a = atan2 (vec[i].dy, vec[i].dx);
+
+ a += atan2 (y-vec[i].y, x-vec[i].x);
+ tx = sin (a + G_PI_2);
+ ty = cos (a + G_PI_2);
+ }
+ else if (vec[i].type == 3)
+ {
+ gdouble a = atan2 (vec[i].dy, vec[i].dx);
+
+ a -= atan2 (y-vec[i].y, x-vec[i].x)*2;
+ tx = sin (a + G_PI_2);
+ ty = cos (a + G_PI_2);
+ }
+
+ dst = dist (x,y,vec[i].x,vec[i].y);
+ dst = pow (dst, strexp);
+
+ if (dst < 0.0001)
+ dst = 0.0001;
+ s = s / dst;
+
+ dx += tx * s;
+ dy += ty * s;
+ sum += s;
+ }
+ dx = dx / sum;
+ dy = dy / sum;
+
+ return 90 - (gimp_rad_to_deg (atan2 (dy, dx)) + angoff);
+}
+
+static void
+update_orient_map_preview_prev (void)
+{
+ int x, y;
+ guchar black[3] = {0, 0, 0};
+ guchar gray[3] = {120, 120, 120};
+ guchar white[3] = {255, 255, 255};
+
+ if (!PPM_IS_INITED (&update_om_preview_nbuffer))
+ ppm_new (&update_om_preview_nbuffer,OMWIDTH,OMHEIGHT);
+
+ fill (&update_om_preview_nbuffer, black);
+
+ for (y = 6; y < OMHEIGHT-4; y += 10)
+ for (x = 6; x < OMWIDTH-4; x += 10)
+ {
+ double dir =
+ gimp_deg_to_rad (get_direction (x / (double)OMWIDTH,
+ y / (double)OMHEIGHT,0));
+ double xo = sin (dir) * 4.0;
+ double yo = cos (dir) * 4.0;
+ ppm_drawline (&update_om_preview_nbuffer,
+ x - xo, y - yo, x + xo, y + yo,
+ gray);
+ ppm_put_rgb (&update_om_preview_nbuffer,
+ x - xo, y - yo,
+ white);
+ }
+
+ gimp_preview_area_draw (GIMP_PREVIEW_AREA (orient_map_preview_prev),
+ 0, 0, OMWIDTH, OMHEIGHT,
+ GIMP_RGB_IMAGE,
+ (guchar *)update_om_preview_nbuffer.col,
+ OMWIDTH * 3);
+
+ gtk_widget_queue_draw (orient_map_preview_prev);
+
+ gtk_widget_set_sensitive (prev_button, (num_vectors > 1));
+ gtk_widget_set_sensitive (next_button, (num_vectors > 1));
+ gtk_widget_set_sensitive (add_button, (num_vectors < MAXORIENTVECT));
+ gtk_widget_set_sensitive (kill_button, (num_vectors > 1));
+}
+
+static void
+update_vector_prev (void)
+{
+ static gint ok = 0;
+ gint i, x, y;
+ gdouble dir, xo, yo;
+ gdouble val;
+ static gdouble last_val = 0.0;
+ guchar gray[3] = {120, 120, 120};
+ guchar red[3] = {255, 0, 0};
+ guchar white[3] = {255, 255, 255};
+
+ if (vector_preview_brightness_adjust)
+ val = 1.0 - gtk_adjustment_get_value (vector_preview_brightness_adjust) / 100.0;
+ else
+ val = 0.5;
+
+ if (!ok || (val != last_val))
+ {
+ infile_copy_to_ppm (&update_vector_preview_backup);
+ ppm_apply_brightness (&update_vector_preview_backup, val, 1,1,1);
+
+ if ((update_vector_preview_backup.width != OMWIDTH) ||
+ (update_vector_preview_backup.height != OMHEIGHT))
+ resize_fast (&update_vector_preview_backup, OMWIDTH, OMHEIGHT);
+ ok = 1;
+ }
+ ppm_copy (&update_vector_preview_backup, &update_vector_preview_buffer);
+
+ for (i = 0; i < num_vectors; i++)
+ {
+ gdouble s;
+
+ x = vector[i].x * OMWIDTH;
+ y = vector[i].y * OMHEIGHT;
+ dir = gimp_deg_to_rad (vector[i].dir);
+ s = gimp_deg_to_rad (vector[i].str);
+ xo = sin (dir) * (6.0+100*s);
+ yo = cos (dir) * (6.0+100*s);
+
+ if (i == selectedvector)
+ {
+ ppm_drawline (&update_vector_preview_buffer,
+ x - xo, y - yo, x + xo, y + yo, red);
+ }
+ else
+ {
+ ppm_drawline (&update_vector_preview_buffer,
+ x - xo, y - yo, x + xo, y + yo, gray);
+ }
+ ppm_put_rgb (&update_vector_preview_buffer, x - xo, y - yo, white);
+ }
+
+ gimp_preview_area_draw (GIMP_PREVIEW_AREA (vector_preview),
+ 0, 0, OMWIDTH, OMHEIGHT,
+ GIMP_RGB_IMAGE,
+ (guchar *)update_vector_preview_buffer.col,
+ OMWIDTH * 3);
+}
+
+void
+orientation_map_free_resources (void)
+{
+ ppm_kill (&update_om_preview_nbuffer);
+ ppm_kill (&update_vector_preview_backup);
+ ppm_kill (&update_vector_preview_buffer);
+}
+
+static void
+update_slides (void)
+{
+ gint type;
+
+ adjignore = TRUE;
+ gtk_adjustment_set_value (angle_adjust, vector[selectedvector].dir);
+ gtk_adjustment_set_value (strength_adjust, vector[selectedvector].str);
+ type = vector[selectedvector].type;
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (vector_types[type]), TRUE);
+ adjignore = FALSE;
+}
+
+static void
+prev_click_callback (GtkWidget *w, gpointer data)
+{
+ selectedvector--;
+ if (selectedvector < 0)
+ selectedvector = num_vectors-1;
+ update_slides ();
+ update_vector_prev ();
+}
+
+static void
+next_click_callback (GtkWidget *w, gpointer data)
+{
+ selectedvector++;
+ if (selectedvector == num_vectors) selectedvector = 0;
+ update_slides ();
+ update_vector_prev ();
+}
+
+static void
+add_new_vector (gdouble x, gdouble y)
+{
+ vector[num_vectors].x = x;
+ vector[num_vectors].y = y;
+ vector[num_vectors].dir = 0.0;
+ vector[num_vectors].dx = sin (gimp_deg_to_rad (0.0));
+ vector[num_vectors].dy = cos (gimp_deg_to_rad (0.0));
+ vector[num_vectors].str = 1.0;
+ vector[num_vectors].type = 0;
+ selectedvector = num_vectors;
+ num_vectors++;
+}
+
+static void
+add_click_callback (GtkWidget *w, gpointer data)
+{
+ add_new_vector (0.5, 0.5);
+ update_slides ();
+ update_vector_prev ();
+ update_orient_map_preview_prev ();
+}
+
+static void
+delete_click_callback (GtkWidget *w, gpointer data)
+{
+ int i;
+
+ for (i = selectedvector; i < num_vectors-1; i++)
+ vector[i] = vector[i + 1];
+
+ num_vectors--;
+
+ if (selectedvector >= num_vectors) selectedvector = 0;
+ update_slides ();
+ update_vector_prev ();
+ update_orient_map_preview_prev ();
+}
+
+static void
+map_click_callback (GtkWidget *w, GdkEventButton *event)
+{
+ if (event->button == 1)
+ {
+ vector[selectedvector].x = event->x / (double)OMWIDTH;
+ vector[selectedvector].y = event->y / (double)OMHEIGHT;
+ }
+ else if (event->button == 2)
+ {
+ if (num_vectors + 1 == MAXORIENTVECT)
+ return;
+ add_new_vector (event->x / (double)OMWIDTH,
+ event->y / (double)OMHEIGHT);
+ update_slides ();
+
+ }
+ else if (event->button == 3)
+ {
+ gdouble d;
+
+ d = atan2 (OMWIDTH * vector[selectedvector].x - event->x,
+ OMHEIGHT * vector[selectedvector].y - event->y);
+ vector[selectedvector].dir = gimp_rad_to_deg (d);
+ vector[selectedvector].dx = sin (d);
+ vector[selectedvector].dy = cos (d);
+ update_slides ();
+ }
+ update_vector_prev ();
+ update_orient_map_preview_prev ();
+}
+
+static void
+angle_adjust_move_callback (GtkWidget *w, gpointer data)
+{
+ if (adjignore)
+ return;
+ vector[selectedvector].dir = gtk_adjustment_get_value (angle_adjust);
+ vector[selectedvector].dx =
+ sin (gimp_deg_to_rad (vector[selectedvector].dir));
+ vector[selectedvector].dy =
+ cos (gimp_deg_to_rad (vector[selectedvector].dir));
+ update_vector_prev ();
+ update_orient_map_preview_prev ();
+}
+
+static void
+strength_adjust_move_callback (GtkWidget *w, gpointer data)
+{
+ if (adjignore)
+ return;
+ vector[selectedvector].str = gtk_adjustment_get_value (strength_adjust);
+ update_vector_prev ();
+ update_orient_map_preview_prev ();
+}
+
+static void
+strength_exponent_adjust_move_callback (GtkWidget *w, gpointer data)
+{
+ if (adjignore)
+ return;
+ update_vector_prev ();
+ update_orient_map_preview_prev ();
+}
+
+static void
+angle_offset_adjust_move_callback (GtkWidget *w, gpointer data)
+{
+ if (adjignore)
+ return;
+ update_vector_prev ();
+ update_orient_map_preview_prev ();
+}
+
+static void
+vector_type_click_callback (GtkWidget *w, gpointer data)
+{
+ if (adjignore)
+ return;
+
+ gimp_radio_button_update (w, data);
+ vector[selectedvector].type = vector_type;
+ update_vector_prev ();
+ update_orient_map_preview_prev ();
+}
+
+static void
+orient_map_response (GtkWidget *widget,
+ gint response_id,
+ gpointer data)
+{
+ switch (response_id)
+ {
+ case GTK_RESPONSE_APPLY:
+ case GTK_RESPONSE_OK:
+ {
+ gint i;
+
+ for (i = 0; i < num_vectors; i++)
+ pcvals.orient_vectors[i] = vector[i];
+
+ pcvals.num_orient_vectors = num_vectors;
+ pcvals.orient_strength_exponent = gtk_adjustment_get_value (orient_map_str_exp_adjust);
+ pcvals.orient_angle_offset = gtk_adjustment_get_value (angle_offset_adjust);
+ pcvals.orient_voronoi = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (orient_voronoi));
+ }
+ };
+
+ if (response_id != GTK_RESPONSE_APPLY)
+ gtk_widget_hide (widget);
+}
+
+static void
+init_vectors (void)
+{
+ if (pcvals.num_orient_vectors)
+ {
+ gint i;
+
+ num_vectors = pcvals.num_orient_vectors;
+ for (i = 0; i < num_vectors; i++)
+ vector[i] = pcvals.orient_vectors[i];
+ }
+ else
+ {/* Shouldn't happen */
+ num_vectors = 0;
+ add_new_vector (0.5, 0.5);
+ }
+ if (selectedvector >= num_vectors)
+ selectedvector = num_vectors-1;
+}
+
+void
+update_orientmap_dialog (void)
+{
+ if (!orient_map_window) return;
+
+ init_vectors ();
+
+ gtk_adjustment_set_value (orient_map_str_exp_adjust,
+ pcvals.orient_strength_exponent);
+ gtk_adjustment_set_value (angle_offset_adjust,
+ pcvals.orient_angle_offset);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (orient_voronoi),
+ pcvals.orient_voronoi);
+
+ update_vector_prev ();
+ update_orient_map_preview_prev ();
+}
+
+void
+create_orientmap_dialog (GtkWidget *parent)
+{
+ GtkWidget *tmpw, *tmpw2;
+ GtkWidget *table1, *table2;
+ GtkWidget *frame;
+ GtkWidget *ebox, *hbox, *vbox;
+
+ init_vectors ();
+
+ if (orient_map_window)
+ {
+ update_vector_prev ();
+ update_orient_map_preview_prev ();
+ gtk_widget_show (orient_map_window);
+ return;
+ }
+
+ orient_map_window =
+ gimp_dialog_new (_("Orientation Map Editor"), PLUG_IN_ROLE,
+ gtk_widget_get_toplevel (parent), 0,
+ gimp_standard_help_func, PLUG_IN_PROC,
+
+ _("_Apply"), GTK_RESPONSE_APPLY,
+ _("_Cancel"), GTK_RESPONSE_CANCEL,
+ _("_OK"), GTK_RESPONSE_OK,
+
+ NULL);
+
+ gtk_dialog_set_alternative_button_order (GTK_DIALOG (orient_map_window),
+ GTK_RESPONSE_OK,
+ GTK_RESPONSE_APPLY,
+ GTK_RESPONSE_CANCEL,
+ -1);
+
+ g_signal_connect (orient_map_window, "response",
+ G_CALLBACK (orient_map_response),
+ orient_map_window);
+ g_signal_connect (orient_map_window, "destroy",
+ G_CALLBACK (gtk_widget_destroyed),
+ &orient_map_window);
+
+ table1 = gtk_table_new (2, 5, FALSE);
+ gtk_container_set_border_width (GTK_CONTAINER (table1), 6);
+ gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (orient_map_window))),
+ table1, TRUE, TRUE, 0);
+ gtk_widget_show (table1);
+
+ frame = gtk_frame_new (_("Vectors"));
+ gtk_container_set_border_width (GTK_CONTAINER (frame), 2);
+ gtk_table_attach (GTK_TABLE (table1), frame, 0, 1, 0, 1,
+ GTK_EXPAND, GTK_EXPAND, 0, 0);
+ gtk_widget_show (frame);
+
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+ gtk_container_add (GTK_CONTAINER (frame), hbox);
+ gtk_widget_show (hbox);
+
+ ebox = gtk_event_box_new ();
+ gimp_help_set_help_data (ebox,
+ _("The vector-field. "
+ "Left-click to move selected vector, "
+ "Right-click to point it towards mouse, "
+ "Middle-click to add a new vector."), NULL);
+ gtk_box_pack_start (GTK_BOX (hbox), ebox, FALSE, FALSE, 0);
+
+ tmpw = vector_preview = gimp_preview_area_new ();
+ gtk_widget_set_size_request (tmpw, OMWIDTH, OMHEIGHT);
+ gtk_container_add (GTK_CONTAINER (ebox), tmpw);
+ gtk_widget_show (tmpw);
+ gtk_widget_add_events (ebox, GDK_BUTTON_PRESS_MASK);
+ g_signal_connect (ebox, "button-press-event",
+ G_CALLBACK (map_click_callback), NULL);
+ gtk_widget_show (ebox);
+
+ vector_preview_brightness_adjust = (GtkAdjustment *)
+ gtk_adjustment_new (50.0, 0.0, 100.0, 1.0, 1.0, 1.0);
+ tmpw = gtk_scale_new (GTK_ORIENTATION_VERTICAL,
+ vector_preview_brightness_adjust);
+ gtk_scale_set_draw_value (GTK_SCALE (tmpw), FALSE);
+ gtk_box_pack_start (GTK_BOX (hbox), tmpw, FALSE, FALSE,0);
+ gtk_widget_show (tmpw);
+ g_signal_connect (vector_preview_brightness_adjust, "value-changed",
+ G_CALLBACK (update_vector_prev), NULL);
+ gimp_help_set_help_data (tmpw, _("Adjust the preview's brightness"), NULL);
+
+ tmpw2 = tmpw = gtk_frame_new (_("Preview"));
+ gtk_container_set_border_width (GTK_CONTAINER (tmpw), 2);
+ gtk_table_attach (GTK_TABLE (table1), tmpw, 1,2, 0,1,
+ GTK_EXPAND, GTK_EXPAND, 0, 0);
+ gtk_widget_show (tmpw);
+
+ tmpw = orient_map_preview_prev = gimp_preview_area_new ();
+ gtk_widget_set_size_request (tmpw, OMWIDTH, OMHEIGHT);
+ gtk_container_add (GTK_CONTAINER (tmpw2), tmpw);
+ gtk_widget_show (tmpw);
+
+ hbox = tmpw = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+ gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
+ gtk_container_set_border_width (GTK_CONTAINER (tmpw), 2);
+ gtk_table_attach_defaults (GTK_TABLE (table1), tmpw, 0,1, 1,2);
+ gtk_widget_show (tmpw);
+
+ prev_button = tmpw = gtk_button_new_with_mnemonic ("_<<");
+ gtk_box_pack_start (GTK_BOX (hbox), tmpw, FALSE, TRUE, 0);
+ gtk_widget_show (tmpw);
+ g_signal_connect (tmpw, "clicked", G_CALLBACK (prev_click_callback), NULL);
+ gimp_help_set_help_data (tmpw, _("Select previous vector"), NULL);
+
+ next_button = tmpw = gtk_button_new_with_mnemonic ("_>>");
+ gtk_box_pack_start (GTK_BOX (hbox),tmpw,FALSE,TRUE,0);
+ gtk_widget_show (tmpw);
+ g_signal_connect (tmpw, "clicked", G_CALLBACK (next_click_callback), NULL);
+ gimp_help_set_help_data (tmpw, _("Select next vector"), NULL);
+
+ add_button = tmpw = gtk_button_new_with_mnemonic ( _("A_dd"));
+ gtk_box_pack_start (GTK_BOX (hbox), tmpw, FALSE, TRUE, 0);
+ gtk_widget_show (tmpw);
+ g_signal_connect (tmpw, "clicked", G_CALLBACK (add_click_callback), NULL);
+ gimp_help_set_help_data (tmpw, _("Add new vector"), NULL);
+
+ kill_button = tmpw = gtk_button_new_with_mnemonic ( _("_Kill"));
+ gtk_box_pack_start (GTK_BOX (hbox), tmpw, FALSE, TRUE, 0);
+ gtk_widget_show (tmpw);
+ g_signal_connect (tmpw, "clicked", G_CALLBACK (delete_click_callback), NULL);
+ gimp_help_set_help_data (tmpw, _("Delete selected vector"), NULL);
+
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+ gtk_box_set_spacing (GTK_BOX (hbox), 12);
+ gtk_table_attach_defaults (GTK_TABLE (table1), hbox, 0, 2, 2, 3);
+ gtk_widget_show (hbox);
+
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+ gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
+ gtk_widget_show (vbox);
+
+ frame = gimp_int_radio_group_new (TRUE, _("Type"),
+ G_CALLBACK (vector_type_click_callback),
+ &vector_type, 0,
+
+ _("_Normal"), 0, &vector_types[0],
+ _("Vorte_x"), 1, &vector_types[1],
+ _("Vortex_2"), 2, &vector_types[2],
+ _("Vortex_3"), 3, &vector_types[3],
+
+ NULL);
+ gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
+ gtk_widget_show (frame);
+
+ orient_voronoi = tmpw = gtk_check_button_new_with_mnemonic ( _("_Voronoi"));
+ gtk_box_pack_start (GTK_BOX (vbox), tmpw, TRUE, TRUE, 0);
+ gtk_widget_show (tmpw);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tmpw),
+ pcvals.orient_voronoi);
+ g_signal_connect (tmpw, "clicked",
+ G_CALLBACK (angle_offset_adjust_move_callback), NULL);
+ gimp_help_set_help_data (tmpw,
+ _("Voronoi-mode makes only the vector closest to the given point have any influence"),
+ NULL);
+
+ table2 = gtk_table_new (4, 3, FALSE);
+ gtk_table_set_col_spacings (GTK_TABLE (table2), 4);
+ gtk_box_pack_start (GTK_BOX (hbox), table2, TRUE, TRUE, 0);
+ gtk_widget_show (table2);
+
+ angle_adjust = (GtkAdjustment *)
+ gimp_scale_entry_new (GTK_TABLE (table2), 0, 0,
+ _("A_ngle:"),
+ 150, 6, 0.0,
+ 0.0, 360.0, 1.0, 10.0, 1,
+ TRUE, 0, 0,
+ _("Change the angle of the selected vector"),
+ NULL);
+ g_signal_connect (angle_adjust, "value-changed",
+ G_CALLBACK (angle_adjust_move_callback), NULL);
+
+ angle_offset_adjust = (GtkAdjustment *)
+ gimp_scale_entry_new (GTK_TABLE (table2), 0, 1,
+ _("Ang_le offset:"),
+ 150, 6, 0.0,
+ 0.0, 360.0, 1.0, 10.0, 1,
+ TRUE, 0, 0,
+ _("Offset all vectors with a given angle"),
+ NULL);
+ g_signal_connect (angle_offset_adjust, "value-changed",
+ G_CALLBACK (angle_offset_adjust_move_callback), NULL);
+
+ strength_adjust = (GtkAdjustment *)
+ gimp_scale_entry_new (GTK_TABLE (table2), 0, 2,
+ _("_Strength:"),
+ 150, 6, 1.0,
+ 0.1, 5.0, 0.1, 1.0, 1,
+ TRUE, 0, 0,
+ _("Change the strength of the selected vector"),
+ NULL);
+ g_signal_connect (strength_adjust, "value-changed",
+ G_CALLBACK (strength_adjust_move_callback), NULL);
+
+ orient_map_str_exp_adjust = (GtkAdjustment *)
+ gimp_scale_entry_new (GTK_TABLE (table2), 0, 3,
+ _("S_trength exp.:"),
+ 150, 6, 1.0,
+ 0.1, 10.9, 0.1, 1.0, 1,
+ TRUE, 0, 0,
+ _("Change the exponent of the strength"),
+ NULL);
+ g_signal_connect (orient_map_str_exp_adjust, "value-changed",
+ G_CALLBACK (strength_exponent_adjust_move_callback), NULL);
+
+ gtk_widget_show (orient_map_window);
+
+ update_vector_prev ();
+ update_orient_map_preview_prev ();
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-10 03:37:59 +0000