p96705831
/
gimp
forked from openkylin/gimp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
gimp/plug-ins/ifs-compose/ifs-compose.c

2800 lines
87 KiB
C
Raw Blame History

/* GIMP - The GNU Image Manipulation Program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* IfsCompose is a interface for creating IFS fractals by
* direct manipulation.
* Copyright (C) 1997 Owen Taylor
*
* 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/>.
*/
/* TODO
* ----
*
* 1. Run in non-interactive mode (need to figure out useful way for a
* script to give the 19N parameters for an image). Perhaps just
* support saving parameters to a file, script passes file name.
* 2. Figure out if we need multiple phases for supersampled brushes.
*/
#include "config.h"
#include <string.h>
#include <errno.h>
#include <glib/gstdio.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include "ifs-compose.h"
#include "libgimp/stdplugins-intl.h"
#define RESPONSE_RESET 1
#define RESPONSE_OPEN 2
#define RESPONSE_SAVE 3
#define DESIGN_AREA_MAX_SIZE 300
#define PREVIEW_RENDER_CHUNK 10000
#define UNDO_LEVELS 24
#define PLUG_IN_PARASITE "ifscompose-parasite"
#define PLUG_IN_PROC "plug-in-ifscompose"
#define PLUG_IN_BINARY "ifs-compose"
#define PLUG_IN_ROLE "gimp-ifs-compose"
typedef enum
{
OP_TRANSLATE,
OP_ROTATE, /* or scale */
OP_STRETCH
} DesignOp;
typedef enum
{
VALUE_PAIR_INT,
VALUE_PAIR_DOUBLE
} ValuePairType;
typedef struct
{
GtkAdjustment *adjustment;
GtkWidget *scale;
GtkWidget *spin;
ValuePairType type;
guint timeout_id;
union
{
gdouble *d;
gint *i;
} data;
} ValuePair;
typedef struct
{
IfsComposeVals ifsvals;
AffElement **elements;
gboolean *element_selected;
gint current_element;
} UndoItem;
typedef struct
{
GimpRGB *color;
GtkWidget *hbox;
GtkWidget *orig_preview;
GtkWidget *button;
gboolean fixed_point;
} ColorMap;
typedef struct
{
GtkWidget *dialog;
ValuePair *iterations_pair;
ValuePair *subdivide_pair;
ValuePair *radius_pair;
ValuePair *memory_pair;
} IfsOptionsDialog;
typedef struct
{
GtkWidget *area;
GtkUIManager *ui_manager;
GdkPixmap *pixmap;
DesignOp op;
gdouble op_x;
gdouble op_y;
gdouble op_xcenter;
gdouble op_ycenter;
gdouble op_center_x;
gdouble op_center_y;
guint button_state;
gint num_selected;
} IfsDesignArea;
typedef struct
{
ValuePair *prob_pair;
ValuePair *x_pair;
ValuePair *y_pair;
ValuePair *scale_pair;
ValuePair *angle_pair;
ValuePair *asym_pair;
ValuePair *shear_pair;
GtkWidget *flip_check_button;
ColorMap *red_cmap;
ColorMap *green_cmap;
ColorMap *blue_cmap;
ColorMap *black_cmap;
ColorMap *target_cmap;
ValuePair *hue_scale_pair;
ValuePair *value_scale_pair;
GtkWidget *simple_button;
GtkWidget *full_button;
GtkWidget *current_frame;
GtkWidget *preview;
guchar *preview_data;
gint preview_iterations;
gint drawable_width;
gint drawable_height;
gint preview_width;
gint preview_height;
AffElement *selected_orig;
gint current_element;
AffElementVals current_vals;
gboolean in_update; /* true if we're currently in
update_values() - don't do anything
on updates */
} IfsDialog;
typedef struct
{
gboolean run;
} IfsComposeInterface;
/* Declare local functions.
*/
static void query (void);
static void run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals);
/* user interface functions */
static gint ifs_compose_dialog (gint32 drawable_id);
static void ifs_options_dialog (GtkWidget *parent);
static GtkWidget * ifs_compose_trans_page (void);
static GtkWidget * ifs_compose_color_page (void);
static GtkUIManager * design_op_menu_create (GtkWidget *window);
static void design_op_actions_update (void);
static void design_area_create (GtkWidget *window,
gint design_width,
gint design_height);
/* functions for drawing design window */
static void update_values (void);
static void set_current_element (gint index);
static void design_area_realize (GtkWidget *widget);
static gint design_area_expose (GtkWidget *widget,
GdkEventExpose *event);
static gint design_area_button_press (GtkWidget *widget,
GdkEventButton *event);
static gint design_area_button_release (GtkWidget *widget,
GdkEventButton *event);
static void design_area_select_all_callback (GtkWidget *widget,
gpointer data);
static gint design_area_configure (GtkWidget *widget,
GdkEventConfigure *event);
static gint design_area_motion (GtkWidget *widget,
GdkEventMotion *event);
static void design_area_redraw (void);
/* Undo ring functions */
static void undo_begin (void);
static void undo_update (gint element);
static void undo_exchange (gint el);
static void undo (void);
static void redo (void);
static void recompute_center (gboolean save_undo);
static void recompute_center_cb (GtkWidget *widget,
gpointer data);
static void ifs_compose (gint32 drawable_id);
static ColorMap *color_map_create (const gchar *name,
GimpRGB *orig_color,
GimpRGB *data,
gboolean fixed_point);
static void color_map_color_changed_cb (GtkWidget *widget,
ColorMap *color_map);
static void color_map_update (ColorMap *color_map);
/* interface functions */
static void simple_color_toggled (GtkWidget *widget, gpointer data);
static void simple_color_set_sensitive (void);
static void val_changed_update (void);
static ValuePair *value_pair_create (gpointer data,
gdouble lower,
gdouble upper,
gboolean create_scale,
ValuePairType type);
static void value_pair_update (ValuePair *value_pair);
static void value_pair_scale_callback (GtkAdjustment *adjustment,
ValuePair *value_pair);
static void design_op_update_callback (GtkRadioAction *action,
GtkRadioAction *current,
gpointer data);
static void flip_check_button_callback (GtkWidget *widget, gpointer data);
static gint preview_idle_render (gpointer data);
static void ifs_compose_preview (void);
static void ifs_compose_set_defaults (void);
static void ifs_compose_new_callback (GtkAction *action,
gpointer data);
static void ifs_compose_delete_callback (GtkAction *action,
gpointer data);
static void ifs_compose_options_callback (GtkAction *action,
gpointer data);
static void ifs_compose_load (GtkWidget *parent);
static void ifs_compose_save (GtkWidget *parent);
static void ifs_compose_response (GtkWidget *widget,
gint response_id,
gpointer data);
/*
* Some static variables
*/
static IfsDialog *ifsD = NULL;
static IfsOptionsDialog *ifsOptD = NULL;
static IfsDesignArea *ifsDesign = NULL;
static AffElement **elements = NULL;
static gint *element_selected = NULL;
/* labels are generated by printing this int */
static gint count_for_naming = 0;
static UndoItem undo_ring[UNDO_LEVELS];
static gint undo_cur = -1;
static gint undo_num = 0;
static gint undo_start = 0;
/* num_elements = 0, signals not inited */
static IfsComposeVals ifsvals =
{
0, /* num_elements */
50000, /* iterations */
4096, /* max_memory */
4, /* subdivide */
0.75, /* radius */
1.0, /* aspect ratio */
0.5, /* center_x */
0.5, /* center_y */
};
static IfsComposeInterface ifscint =
{
FALSE, /* run */
};
const GimpPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
MAIN ()
static void
query (void)
{
static const GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
{ GIMP_PDB_IMAGE, "image", "Input image" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
};
static const GimpParamDef *return_vals = NULL;
static int nreturn_vals = 0;
gimp_install_procedure (PLUG_IN_PROC,
N_("Create an Iterated Function System (IFS) fractal"),
"Interactively create an Iterated Function System "
"fractal. Use the window on the upper left to adjust "
"the component transformations of the fractal. The "
"operation that is performed is selected by the "
"buttons underneath the window, or from a menu "
"popped up by the right mouse button. The fractal "
"will be rendered with a transparent background if "
"the current image has an alpha channel.",
"Owen Taylor",
"Owen Taylor",
"1997",
N_("_IFS Fractal..."),
"*",
GIMP_PLUGIN,
G_N_ELEMENTS (args), nreturn_vals,
args, return_vals);
gimp_plugin_menu_register (PLUG_IN_PROC,
"<Image>/Filters/Render/Fractals");
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[1];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GimpParasite *parasite = NULL;
gint32 image_id;
gint32 drawable_id;
gboolean found_parasite = FALSE;
INIT_I18N ();
gegl_init (NULL, NULL);
run_mode = param[0].data.d_int32;
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
image_id = param[1].data.d_image;
drawable_id = param[2].data.d_drawable;
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
/* Possibly retrieve data; first look for a parasite -
* if not found, fall back to global values
*/
parasite = gimp_item_get_parasite (drawable_id,
PLUG_IN_PARASITE);
if (parasite)
{
found_parasite = ifsvals_parse_string (gimp_parasite_data (parasite),
&ifsvals, &elements);
gimp_parasite_free (parasite);
}
if (!found_parasite)
{
gint length = gimp_get_data_size (PLUG_IN_PROC);
if (length > 0)
{
gchar *data = g_new (gchar, length);
gimp_get_data (PLUG_IN_PROC, data);
ifsvals_parse_string (data, &ifsvals, &elements);
g_free (data);
}
}
/* after ifsvals_parse_string, need to set up naming */
count_for_naming = ifsvals.num_elements;
/* First acquire information with a dialog */
if (! ifs_compose_dialog (drawable_id))
return;
break;
case GIMP_RUN_NONINTERACTIVE:
status = GIMP_PDB_CALLING_ERROR;
break;
case GIMP_RUN_WITH_LAST_VALS:
{
gint length = gimp_get_data_size (PLUG_IN_PROC);
if (length > 0)
{
gchar *data = g_new (gchar, length);
gimp_get_data (PLUG_IN_PROC, data);
ifsvals_parse_string (data, &ifsvals, &elements);
g_free (data);
}
else
{
ifs_compose_set_defaults ();
}
}
break;
default:
break;
}
/* Render the fractal */
if (status == GIMP_PDB_SUCCESS)
{
if (run_mode == GIMP_RUN_INTERACTIVE)
{
gchar *str;
GimpParasite *parasite;
gimp_image_undo_group_start (image_id);
/* run the effect */
ifs_compose (drawable_id);
/* Store data for next invocation - both globally and
* as a parasite on this layer
*/
str = ifsvals_stringify (&ifsvals, elements);
gimp_set_data (PLUG_IN_PROC, str, strlen (str) + 1);
parasite = gimp_parasite_new (PLUG_IN_PARASITE,
GIMP_PARASITE_PERSISTENT |
GIMP_PARASITE_UNDOABLE,
strlen (str) + 1, str);
gimp_item_attach_parasite (drawable_id, parasite);
gimp_parasite_free (parasite);
g_free (str);
gimp_image_undo_group_end (image_id);
gimp_displays_flush ();
}
else
{
/* run the effect */
ifs_compose (drawable_id);
}
}
values[0].data.d_status = status;
}
static GtkWidget *
ifs_compose_trans_page (void)
{
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *label;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
table = gtk_table_new (3, 6, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 12);
gtk_table_set_col_spacing (GTK_TABLE (table), 2, 6);
gtk_table_set_col_spacing (GTK_TABLE (table), 4, 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 12);
gtk_table_set_row_spacing (GTK_TABLE (table), 2, 6);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
/* X */
label = gtk_label_new (_("X:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
ifsD->x_pair = value_pair_create (&ifsD->current_vals.x, 0.0, 1.0, FALSE,
VALUE_PAIR_DOUBLE);
gtk_table_attach (GTK_TABLE (table), ifsD->x_pair->spin, 1, 2, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ifsD->x_pair->spin);
/* Y */
label = gtk_label_new (_("Y:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
ifsD->y_pair = value_pair_create (&ifsD->current_vals.y, 0.0, 1.0, FALSE,
VALUE_PAIR_DOUBLE);
gtk_table_attach (GTK_TABLE (table), ifsD->y_pair->spin, 1, 2, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ifsD->y_pair->spin);
/* Scale */
label = gtk_label_new (_("Scale:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
ifsD->scale_pair = value_pair_create (&ifsD->current_vals.scale, 0.0, 1.0,
FALSE, VALUE_PAIR_DOUBLE);
gtk_table_attach (GTK_TABLE (table), ifsD->scale_pair->spin, 3, 4, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ifsD->scale_pair->spin);
/* Angle */
label = gtk_label_new (_("Angle:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
ifsD->angle_pair = value_pair_create (&ifsD->current_vals.theta, -180, 180,
FALSE, VALUE_PAIR_DOUBLE);
gtk_table_attach (GTK_TABLE (table), ifsD->angle_pair->spin, 3, 4, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ifsD->angle_pair->spin);
/* Asym */
label = gtk_label_new (_("Asymmetry:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_table_attach (GTK_TABLE (table), label, 4, 5, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
ifsD->asym_pair = value_pair_create (&ifsD->current_vals.asym, 0.10, 10.0,
FALSE, VALUE_PAIR_DOUBLE);
gtk_table_attach (GTK_TABLE (table), ifsD->asym_pair->spin, 5, 6, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ifsD->asym_pair->spin);
/* Shear */
label = gtk_label_new (_("Shear:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_table_attach (GTK_TABLE (table), label, 4, 5, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
ifsD->shear_pair = value_pair_create (&ifsD->current_vals.shear, -10.0, 10.0,
FALSE, VALUE_PAIR_DOUBLE);
gtk_table_attach (GTK_TABLE (table), ifsD->shear_pair->spin, 5, 6, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ifsD->shear_pair->spin);
/* Flip */
ifsD->flip_check_button = gtk_check_button_new_with_label (_("Flip"));
gtk_table_attach (GTK_TABLE (table), ifsD->flip_check_button, 0, 6, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
g_signal_connect (ifsD->flip_check_button, "toggled",
G_CALLBACK (flip_check_button_callback),
NULL);
gtk_widget_show (ifsD->flip_check_button);
return vbox;
}
static GtkWidget *
ifs_compose_color_page (void)
{
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *label;
GSList *group = NULL;
GimpRGB color;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
table = gtk_table_new (3, 5, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 12);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
/* Simple color control section */
ifsD->simple_button = gtk_radio_button_new_with_label (group, _("Simple"));
gtk_table_attach (GTK_TABLE (table), ifsD->simple_button, 0, 1, 0, 2,
GTK_FILL, GTK_FILL, 0, 0);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (ifsD->simple_button));
g_signal_connect (ifsD->simple_button, "toggled",
G_CALLBACK (simple_color_toggled),
NULL);
gtk_widget_show (ifsD->simple_button);
ifsD->target_cmap = color_map_create (_("IFS Fractal: Target"), NULL,
&ifsD->current_vals.target_color, TRUE);
gtk_table_attach (GTK_TABLE (table), ifsD->target_cmap->hbox, 1, 2, 0, 2,
GTK_FILL, 0, 0, 0);
gtk_widget_show (ifsD->target_cmap->hbox);
label = gtk_label_new (_("Scale hue by:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
ifsD->hue_scale_pair = value_pair_create (&ifsD->current_vals.hue_scale,
0.0, 1.0, TRUE, VALUE_PAIR_DOUBLE);
gtk_table_attach (GTK_TABLE (table), ifsD->hue_scale_pair->scale, 3, 4, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ifsD->hue_scale_pair->scale);
gtk_table_attach (GTK_TABLE (table), ifsD->hue_scale_pair->spin, 4, 5, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ifsD->hue_scale_pair->spin);
label = gtk_label_new (_("Scale value by:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
ifsD->value_scale_pair = value_pair_create (&ifsD->current_vals.value_scale,
0.0, 1.0, TRUE, VALUE_PAIR_DOUBLE);
gtk_table_attach (GTK_TABLE (table), ifsD->value_scale_pair->scale,
3, 4, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ifsD->value_scale_pair->scale);
gtk_table_attach (GTK_TABLE (table), ifsD->value_scale_pair->spin,
4, 5, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ifsD->value_scale_pair->spin);
/* Full color control section */
ifsD->full_button = gtk_radio_button_new_with_label (group, _("Full"));
gtk_table_attach (GTK_TABLE (table), ifsD->full_button, 0, 1, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (ifsD->full_button));
gtk_widget_show (ifsD->full_button);
gimp_rgb_parse_name (&color, "red", -1);
gimp_rgb_set_alpha (&color, 1.0);
ifsD->red_cmap = color_map_create (_("IFS Fractal: Red"), &color,
&ifsD->current_vals.red_color, FALSE);
gtk_table_attach (GTK_TABLE (table), ifsD->red_cmap->hbox, 1, 2, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ifsD->red_cmap->hbox);
gimp_rgb_parse_name (&color, "green", -1);
gimp_rgb_set_alpha (&color, 1.0);
ifsD->green_cmap = color_map_create (_("IFS Fractal: Green"), &color,
&ifsD->current_vals.green_color, FALSE);
gtk_table_attach (GTK_TABLE (table), ifsD->green_cmap->hbox, 2, 3, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ifsD->green_cmap->hbox);
gimp_rgb_parse_name (&color, "blue", -1);
gimp_rgb_set_alpha (&color, 1.0);
ifsD->blue_cmap = color_map_create (_("IFS Fractal: Blue"), &color,
&ifsD->current_vals.blue_color, FALSE);
gtk_table_attach (GTK_TABLE (table), ifsD->blue_cmap->hbox, 3, 4, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ifsD->blue_cmap->hbox);
gimp_rgb_parse_name (&color, "black", -1);
gimp_rgb_set_alpha (&color, 1.0);
ifsD->black_cmap = color_map_create (_("IFS Fractal: Black"), &color,
&ifsD->current_vals.black_color, FALSE);
gtk_table_attach (GTK_TABLE (table), ifsD->black_cmap->hbox, 4, 5, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ifsD->black_cmap->hbox);
return vbox;
}
static gint
ifs_compose_dialog (gint32 drawable_id)
{
GtkWidget *dialog;
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *main_vbox;
GtkWidget *toolbar;
GtkWidget *aspect_frame;
GtkWidget *notebook;
GtkWidget *page;
gint design_width = gimp_drawable_width (drawable_id);
gint design_height = gimp_drawable_height (drawable_id);
if (design_width > design_height)
{
if (design_width > DESIGN_AREA_MAX_SIZE)
{
design_height = design_height * DESIGN_AREA_MAX_SIZE / design_width;
design_width = DESIGN_AREA_MAX_SIZE;
}
}
else
{
if (design_height > DESIGN_AREA_MAX_SIZE)
{
design_width = design_width * DESIGN_AREA_MAX_SIZE / design_height;
design_height = DESIGN_AREA_MAX_SIZE;
}
}
ifsD = g_new0 (IfsDialog, 1);
ifsD->drawable_width = gimp_drawable_width (drawable_id);
ifsD->drawable_height = gimp_drawable_height (drawable_id);
ifsD->preview_width = design_width;
ifsD->preview_height = design_height;
gimp_ui_init (PLUG_IN_BINARY, TRUE);
dialog = gimp_dialog_new (_("IFS Fractal"), PLUG_IN_ROLE,
NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC,
_("_Open"), RESPONSE_OPEN,
_("_Save"), RESPONSE_SAVE,
_("_Reset"), RESPONSE_RESET,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_OK"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
RESPONSE_OPEN,
RESPONSE_SAVE,
RESPONSE_RESET,
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gimp_window_set_transient (GTK_WINDOW (dialog));
g_object_add_weak_pointer (G_OBJECT (dialog), (gpointer) &dialog);
g_signal_connect (dialog, "response",
G_CALLBACK (ifs_compose_response),
NULL);
g_signal_connect (dialog, "destroy",
G_CALLBACK (gtk_main_quit),
NULL);
design_area_create (dialog, design_width, design_height);
toolbar = gtk_ui_manager_get_widget (ifsDesign->ui_manager,
"/ifs-compose-toolbar");
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
toolbar, FALSE, FALSE, 0);
gtk_widget_show (toolbar);
/* The main vbox */
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
main_vbox, TRUE, TRUE, 0);
/* The design area */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
aspect_frame = gtk_aspect_frame_new (NULL,
0.5, 0.5,
(gdouble) design_width / design_height,
0);
gtk_frame_set_shadow_type (GTK_FRAME (aspect_frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), aspect_frame, TRUE, TRUE, 0);
gtk_widget_show (aspect_frame);
gtk_container_add (GTK_CONTAINER (aspect_frame), ifsDesign->area);
gtk_widget_show (ifsDesign->area);
/* The Preview */
aspect_frame = gtk_aspect_frame_new (NULL,
0.5, 0.5,
(gdouble) design_width / design_height,
0);
gtk_frame_set_shadow_type (GTK_FRAME (aspect_frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), aspect_frame, TRUE, TRUE, 0);
ifsD->preview = gimp_preview_area_new ();
gtk_widget_set_size_request (ifsD->preview,
ifsD->preview_width,
ifsD->preview_height);
gtk_container_add (GTK_CONTAINER (aspect_frame), ifsD->preview);
gtk_widget_show (ifsD->preview);
gtk_widget_show (aspect_frame);
gtk_widget_show (hbox);
/* The current transformation frame */
ifsD->current_frame = gimp_frame_new (NULL);
gtk_box_pack_start (GTK_BOX (main_vbox), ifsD->current_frame,
FALSE, FALSE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add (GTK_CONTAINER (ifsD->current_frame), vbox);
/* The notebook */
notebook = gtk_notebook_new ();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
gtk_box_pack_start (GTK_BOX (vbox), notebook, FALSE, FALSE, 0);
gtk_widget_show (notebook);
page = ifs_compose_trans_page ();
label = gtk_label_new (_("Spatial Transformation"));
gtk_label_set_xalign (GTK_LABEL (label), 0.5);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label);
gtk_widget_show (page);
page = ifs_compose_color_page ();
label = gtk_label_new (_("Color Transformation"));
gtk_label_set_xalign (GTK_LABEL (label), 0.5);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label);
gtk_widget_show (page);
/* The probability entry */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new (_("Relative probability:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
ifsD->prob_pair = value_pair_create (&ifsD->current_vals.prob, 0.0, 5.0, TRUE,
VALUE_PAIR_DOUBLE);
gtk_box_pack_start (GTK_BOX (hbox), ifsD->prob_pair->scale, TRUE, TRUE, 0);
gtk_widget_show (ifsD->prob_pair->scale);
gtk_box_pack_start (GTK_BOX (hbox), ifsD->prob_pair->spin, FALSE, TRUE, 0);
gtk_widget_show (ifsD->prob_pair->spin);
gtk_widget_show (hbox);
gtk_widget_show (vbox);
gtk_widget_show (ifsD->current_frame);
gtk_widget_show (main_vbox);
if (ifsvals.num_elements == 0)
{
ifs_compose_set_defaults ();
}
else
{
gint i;
gdouble ratio = (gdouble) ifsD->drawable_height / ifsD->drawable_width;
element_selected = g_new (gint, ifsvals.num_elements);
element_selected[0] = TRUE;
for (i = 1; i < ifsvals.num_elements; i++)
element_selected[i] = FALSE;
if (ratio != ifsvals.aspect_ratio)
{
/* Adjust things so that what fit onto the old image, fits
onto the new image */
Aff2 t1, t2, t3;
gdouble x_offset, y_offset;
gdouble center_x, center_y;
gdouble scale;
if (ratio < ifsvals.aspect_ratio)
{
scale = ratio/ifsvals.aspect_ratio;
x_offset = (1-scale)/2;
y_offset = 0;
}
else
{
scale = 1;
x_offset = 0;
y_offset = (ratio - ifsvals.aspect_ratio)/2;
}
aff2_scale (&t1, scale, 0);
aff2_translate (&t2, x_offset, y_offset);
aff2_compose (&t3, &t2, &t1);
aff2_invert (&t1, &t3);
aff2_apply (&t3, ifsvals.center_x, ifsvals.center_y, &center_x,
&center_y);
for (i = 0; i < ifsvals.num_elements; i++)
{
aff_element_compute_trans (elements[i],1, ifsvals.aspect_ratio,
ifsvals.center_x, ifsvals.center_y);
aff2_compose (&t2, &elements[i]->trans, &t1);
aff2_compose (&elements[i]->trans, &t3, &t2);
aff_element_decompose_trans (elements[i],&elements[i]->trans,
1, ifsvals.aspect_ratio,
center_x, center_y);
}
ifsvals.center_x = center_x;
ifsvals.center_y = center_y;
ifsvals.aspect_ratio = ratio;
}
for (i = 0; i < ifsvals.num_elements; i++)
aff_element_compute_color_trans (elements[i]);
/* boundary and spatial transformations will be computed
when the design_area gets a ConfigureNotify event */
set_current_element (0);
ifsD->selected_orig = g_new (AffElement, ifsvals.num_elements);
}
gtk_widget_show (dialog);
ifs_compose_preview ();
gtk_main ();
g_object_unref (ifsDesign->ui_manager);
if (dialog)
gtk_widget_destroy (dialog);
if (ifsOptD)
gtk_widget_destroy (ifsOptD->dialog);
gdk_flush ();
g_free (ifsD);
return ifscint.run;
}
static void
design_area_create (GtkWidget *window,
gint design_width,
gint design_height)
{
ifsDesign = g_new0 (IfsDesignArea, 1);
ifsDesign->op = OP_TRANSLATE;
ifsDesign->area = gtk_drawing_area_new ();
gtk_widget_set_size_request (ifsDesign->area, design_width, design_height);
g_signal_connect (ifsDesign->area, "realize",
G_CALLBACK (design_area_realize),
NULL);
g_signal_connect (ifsDesign->area, "expose-event",
G_CALLBACK (design_area_expose),
NULL);
g_signal_connect (ifsDesign->area, "button-press-event",
G_CALLBACK (design_area_button_press),
NULL);
g_signal_connect (ifsDesign->area, "button-release-event",
G_CALLBACK (design_area_button_release),
NULL);
g_signal_connect (ifsDesign->area, "motion-notify-event",
G_CALLBACK (design_area_motion),
NULL);
g_signal_connect (ifsDesign->area, "configure-event",
G_CALLBACK (design_area_configure),
NULL);
gtk_widget_set_events (ifsDesign->area,
GDK_EXPOSURE_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK);
ifsDesign->ui_manager = design_op_menu_create (window);
design_op_actions_update ();
}
static GtkUIManager *
design_op_menu_create (GtkWidget *window)
{
static GtkActionEntry actions[] =
{
{ "ifs-compose-menu", NULL, "IFS Fractal Menu" },
{ "new", GIMP_ICON_DOCUMENT_NEW,
N_("_New"), "<primary>N", NULL,
G_CALLBACK (ifs_compose_new_callback) },
{ "delete", GIMP_ICON_EDIT_DELETE,
N_("_Delete"), "<primary>D", NULL,
G_CALLBACK (ifs_compose_delete_callback) },
{ "undo", GIMP_ICON_EDIT_UNDO,
N_("_Undo"), "<primary>Z", NULL,
G_CALLBACK (undo) },
{ "redo", GIMP_ICON_EDIT_REDO,
N_("_Redo"), "<primary>Y", NULL,
G_CALLBACK (redo) },
{ "select-all", GIMP_ICON_SELECTION_ALL,
N_("Select _All"), "<primary>A", NULL,
G_CALLBACK (design_area_select_all_callback) },
{ "center", GIMP_ICON_CENTER,
N_("Re_center"), "<primary>C", N_("Recompute Center"),
G_CALLBACK (recompute_center_cb) },
{ "options", GIMP_ICON_PREFERENCES_SYSTEM,
N_("Render Options"), NULL, NULL,
G_CALLBACK (ifs_compose_options_callback) }
};
static GtkRadioActionEntry radio_actions[] =
{
{ "move", GIMP_ICON_TOOL_MOVE,
N_("Move"), "M", NULL, OP_TRANSLATE },
{ "rotate", GIMP_ICON_TOOL_ROTATE,
N_("Rotate"), "R", N_("Rotate / Scale"), OP_ROTATE },
{ "stretch", GIMP_ICON_TOOL_PERSPECTIVE,
N_("Stretch"), "S", NULL, OP_STRETCH }
};
GtkUIManager *ui_manager = gtk_ui_manager_new ();
GtkActionGroup *group = gtk_action_group_new ("Actions");
gtk_action_group_set_translation_domain (group, NULL);
gtk_action_group_add_actions (group,
actions,
G_N_ELEMENTS (actions),
window);
gtk_action_group_add_radio_actions (group,
radio_actions,
G_N_ELEMENTS (radio_actions),
ifsDesign->op,
G_CALLBACK (design_op_update_callback),
window);
gtk_window_add_accel_group (GTK_WINDOW (window),
gtk_ui_manager_get_accel_group (ui_manager));
gtk_accel_group_lock (gtk_ui_manager_get_accel_group (ui_manager));
gtk_ui_manager_insert_action_group (ui_manager, group, -1);
g_object_unref (group);
gtk_ui_manager_add_ui_from_string (ui_manager,
"<ui>"
" <menubar name=\"dummy-menubar\">"
" <menu action=\"ifs-compose-menu\">"
" <menuitem action=\"move\" />"
" <menuitem action=\"rotate\" />"
" <menuitem action=\"stretch\" />"
" <separator />"
" <menuitem action=\"new\" />"
" <menuitem action=\"delete\" />"
" <menuitem action=\"undo\" />"
" <menuitem action=\"redo\" />"
" <menuitem action=\"select-all\" />"
" <menuitem action=\"center\" />"
" <separator />"
" <menuitem action=\"options\" />"
" </menu>"
" </menubar>"
"</ui>",
-1, NULL);
gtk_ui_manager_add_ui_from_string (ui_manager,
"<ui>"
" <toolbar name=\"ifs-compose-toolbar\">"
" <toolitem action=\"move\" />"
" <toolitem action=\"rotate\" />"
" <toolitem action=\"stretch\" />"
" <separator />"
" <toolitem action=\"new\" />"
" <toolitem action=\"delete\" />"
" <toolitem action=\"undo\" />"
" <toolitem action=\"redo\" />"
" <toolitem action=\"select-all\" />"
" <toolitem action=\"center\" />"
" <separator />"
" <toolitem action=\"options\" />"
" </toolbar>"
"</ui>",
-1, NULL);
return ui_manager;
}
static void
design_op_actions_update (void)
{
GtkAction *act;
act = gtk_ui_manager_get_action (ifsDesign->ui_manager,
"/ui/dummy-menubar/ifs-compose-menu/undo");
gtk_action_set_sensitive (act, undo_cur >= 0);
act = gtk_ui_manager_get_action (ifsDesign->ui_manager,
"/ui/dummy-menubar/ifs-compose-menu/redo");
gtk_action_set_sensitive (act, undo_cur != undo_num - 1);
act = gtk_ui_manager_get_action (ifsDesign->ui_manager,
"/ui/dummy-menubar/ifs-compose-menu/delete");
gtk_action_set_sensitive (act, ifsvals.num_elements > 2);
}
static void
ifs_options_dialog (GtkWidget *parent)
{
if (!ifsOptD)
{
GtkWidget *table;
GtkWidget *label;
ifsOptD = g_new0 (IfsOptionsDialog, 1);
ifsOptD->dialog =
gimp_dialog_new (_("IFS Fractal Render Options"), PLUG_IN_ROLE,
parent, 0,
gimp_standard_help_func, PLUG_IN_PROC,
_("_Close"), GTK_RESPONSE_CLOSE,
NULL);
g_signal_connect (ifsOptD->dialog, "response",
G_CALLBACK (gtk_widget_hide),
NULL);
/* Table of options */
table = gtk_table_new (4, 3, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (table), 12);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (ifsOptD->dialog))),
table, FALSE, FALSE, 0);
gtk_widget_show (table);
label = gtk_label_new (_("Max. memory:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
ifsOptD->memory_pair = value_pair_create (&ifsvals.max_memory,
1, 1000000, FALSE,
VALUE_PAIR_INT);
gtk_table_attach (GTK_TABLE (table), ifsOptD->memory_pair->spin,
1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ifsOptD->memory_pair->spin);
label = gtk_label_new (_("Iterations:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
ifsOptD->iterations_pair = value_pair_create (&ifsvals.iterations,
1, 10000000, FALSE,
VALUE_PAIR_INT);
gtk_table_attach (GTK_TABLE (table), ifsOptD->iterations_pair->spin,
1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ifsOptD->iterations_pair->spin);
gtk_widget_show (label);
label = gtk_label_new (_("Subdivide:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
ifsOptD->subdivide_pair = value_pair_create (&ifsvals.subdivide,
1, 10, FALSE,
VALUE_PAIR_INT);
gtk_table_attach (GTK_TABLE (table), ifsOptD->subdivide_pair->spin,
1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ifsOptD->subdivide_pair->spin);
label = gtk_label_new (_("Spot radius:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
ifsOptD->radius_pair = value_pair_create (&ifsvals.radius,
0, 5, TRUE,
VALUE_PAIR_DOUBLE);
gtk_table_attach (GTK_TABLE (table), ifsOptD->radius_pair->scale,
1, 2, 3, 4, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ifsOptD->radius_pair->scale);
gtk_table_attach (GTK_TABLE (table), ifsOptD->radius_pair->spin,
2, 3, 3, 4, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (ifsOptD->radius_pair->spin);
value_pair_update (ifsOptD->iterations_pair);
value_pair_update (ifsOptD->subdivide_pair);
value_pair_update (ifsOptD->memory_pair);
value_pair_update (ifsOptD->radius_pair);
gtk_widget_show (ifsOptD->dialog);
}
else
{
gtk_window_present (GTK_WINDOW (ifsOptD->dialog));
}
}
static void
ifs_compose (gint32 drawable_id)
{
GeglBuffer *buffer = gimp_drawable_get_shadow_buffer (drawable_id);
gint width = gimp_drawable_width (drawable_id);
gint height = gimp_drawable_height (drawable_id);
gboolean alpha = gimp_drawable_has_alpha (drawable_id);
const Babl *format;
gint num_bands;
gint band_height;
gint band_y;
gint band_no;
gint i, j;
guchar *data;
guchar *mask = NULL;
guchar *nhits;
guchar rc, gc, bc;
GimpRGB color;
if (alpha)
format = babl_format ("R'G'B'A u8");
else
format = babl_format ("R'G'B' u8");
num_bands = ceil ((gdouble) (width * height * SQR (ifsvals.subdivide) * 5)
/ (1024 * ifsvals.max_memory));
band_height = (height + num_bands - 1) / num_bands;
if (band_height > height)
band_height = height;
mask = g_new (guchar, width * band_height * SQR (ifsvals.subdivide));
data = g_new (guchar, width * band_height * SQR (ifsvals.subdivide) * 3);
nhits = g_new (guchar, width * band_height * SQR (ifsvals.subdivide));
gimp_context_get_background (&color);
gimp_rgb_get_uchar (&color, &rc, &gc, &bc);
for (band_no = 0, band_y = 0; band_no < num_bands; band_no++)
{
GeglBufferIterator *iter;
GeglRectangle *roi;
gimp_progress_init_printf (_("Rendering IFS (%d/%d)"),
band_no + 1, num_bands);
/* render the band to a buffer */
if (band_y + band_height > height)
band_height = height - band_y;
/* we don't need to clear data since we store nhits */
memset (mask, 0, width * band_height * SQR (ifsvals.subdivide));
memset (nhits, 0, width * band_height * SQR (ifsvals.subdivide));
ifs_render (elements,
ifsvals.num_elements, width, height, ifsvals.iterations,
&ifsvals, band_y, band_height, data, mask, nhits, FALSE);
/* transfer the image to the drawable */
iter = gegl_buffer_iterator_new (buffer,
GEGL_RECTANGLE (0, band_y,
width, band_height), 0,
format,
GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE, 1);
roi = &iter->items[0].roi;
while (gegl_buffer_iterator_next (iter))
{
guchar *destrow = iter->items[0].data;
for (j = roi->y; j < (roi->y + roi->height); j++)
{
guchar *dest = destrow;
for (i = roi->x; i < (roi->x + roi->width); i++)
{
/* Accumulate a reduced pixel */
gint rtot = 0;
gint btot = 0;
gint gtot = 0;
gint mtot = 0;
gint ii, jj;
for (jj = 0; jj < ifsvals.subdivide; jj++)
{
guchar *ptr;
guchar *maskptr;
ptr = data +
3 * (((j - band_y) * ifsvals.subdivide + jj) *
ifsvals.subdivide * width +
i * ifsvals.subdivide);
maskptr = mask +
((j - band_y) * ifsvals.subdivide + jj) *
ifsvals.subdivide * width +
i * ifsvals.subdivide;
for (ii = 0; ii < ifsvals.subdivide; ii++)
{
guchar maskval = *maskptr++;
mtot += maskval;
rtot += maskval* *ptr++;
gtot += maskval* *ptr++;
btot += maskval* *ptr++;
}
}
if (mtot)
{
rtot /= mtot;
gtot /= mtot;
btot /= mtot;
mtot /= SQR (ifsvals.subdivide);
}
if (alpha)
{
*dest++ = rtot;
*dest++ = gtot;
*dest++ = btot;
*dest++ = mtot;
}
else
{
*dest++ = (mtot * rtot + (255 - mtot) * rc) / 255;
*dest++ = (mtot * gtot + (255 - mtot) * gc) / 255;
*dest++ = (mtot * btot + (255 - mtot) * bc) / 255;
}
}
if (alpha)
destrow += roi->width * 4;
else
destrow += roi->width * 3;
}
}
band_y += band_height;
}
g_free (mask);
g_free (data);
g_free (nhits);
g_object_unref (buffer);
gimp_drawable_merge_shadow (drawable_id, TRUE);
gimp_drawable_update (drawable_id, 0, 0, width, height);
}
static void
update_values (void)
{
ifsD->in_update = TRUE;
ifsD->current_vals = elements[ifsD->current_element]->v;
ifsD->current_vals.theta *= 180/G_PI;
value_pair_update (ifsD->prob_pair);
value_pair_update (ifsD->x_pair);
value_pair_update (ifsD->y_pair);
value_pair_update (ifsD->scale_pair);
value_pair_update (ifsD->angle_pair);
value_pair_update (ifsD->asym_pair);
value_pair_update (ifsD->shear_pair);
color_map_update (ifsD->red_cmap);
color_map_update (ifsD->green_cmap);
color_map_update (ifsD->blue_cmap);
color_map_update (ifsD->black_cmap);
color_map_update (ifsD->target_cmap);
value_pair_update (ifsD->hue_scale_pair);
value_pair_update (ifsD->value_scale_pair);
if (elements[ifsD->current_element]->v.simple_color)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ifsD->simple_button),
TRUE);
else
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ifsD->full_button),
TRUE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ifsD->flip_check_button),
elements[ifsD->current_element]->v.flip);
ifsD->in_update = FALSE;
simple_color_set_sensitive ();
}
static void
set_current_element (gint index)
{
gchar *frame_name = g_strdup_printf (_("Transformation %s"),
elements[index]->name);
ifsD->current_element = index;
gtk_frame_set_label (GTK_FRAME (ifsD->current_frame),frame_name);
g_free (frame_name);
update_values ();
}
static void
design_area_realize (GtkWidget *widget)
{
const gint cursors[3] =
{
GDK_FLEUR, /* OP_TRANSLATE */
GDK_EXCHANGE, /* OP_ROTATE */
GDK_CROSSHAIR /* OP_SHEAR */
};
GdkDisplay *display = gtk_widget_get_display (widget);
GdkCursor *cursor = gdk_cursor_new_for_display (display,
cursors[ifsDesign->op]);
gdk_window_set_cursor (gtk_widget_get_window (widget), cursor);
gdk_cursor_unref (cursor);
}
static gboolean
design_area_expose (GtkWidget *widget,
GdkEventExpose *event)
{
GtkStyle *style = gtk_widget_get_style (widget);
GtkStateType state = gtk_widget_get_state (widget);
cairo_t *cr;
GtkAllocation allocation;
PangoLayout *layout;
gint i;
gint cx, cy;
gtk_widget_get_allocation (widget, &allocation);
cr = gdk_cairo_create (ifsDesign->pixmap);
gdk_cairo_set_source_color (cr, &style->bg[state]);
cairo_paint (cr);
cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
cairo_translate (cr, 0.5, 0.5);
/* draw an indicator for the center */
cx = ifsvals.center_x * allocation.width;
cy = ifsvals.center_y * allocation.width;
cairo_move_to (cr, cx - 10, cy);
cairo_line_to (cr, cx + 10, cy);
cairo_move_to (cr, cx, cy - 10);
cairo_line_to (cr, cx, cy + 10);
gdk_cairo_set_source_color (cr, &style->fg[state]);
cairo_set_line_width (cr, 1.0);
cairo_stroke (cr);
layout = gtk_widget_create_pango_layout (widget, NULL);
for (i = 0; i < ifsvals.num_elements; i++)
{
aff_element_draw (elements[i], element_selected[i],
allocation.width,
allocation.height,
cr,
&style->fg[state],
layout);
}
g_object_unref (layout);
cairo_destroy (cr);
cr = gdk_cairo_create (gtk_widget_get_window (widget));
gdk_cairo_region (cr, event->region);
cairo_clip (cr);
gdk_cairo_set_source_pixmap (cr, ifsDesign->pixmap, 0.0, 0.0);
cairo_paint (cr);
cairo_destroy (cr);
return FALSE;
}
static gboolean
design_area_configure (GtkWidget *widget,
GdkEventConfigure *event)
{
GtkAllocation allocation;
gint i;
gtk_widget_get_allocation (widget, &allocation);
for (i = 0; i < ifsvals.num_elements; i++)
aff_element_compute_trans (elements[i],
allocation.width, allocation.height,
ifsvals.center_x, ifsvals.center_y);
for (i = 0; i < ifsvals.num_elements; i++)
aff_element_compute_boundary (elements[i],
allocation.width, allocation.height,
elements, ifsvals.num_elements);
if (ifsDesign->pixmap)
{
g_object_unref (ifsDesign->pixmap);
}
ifsDesign->pixmap = gdk_pixmap_new (gtk_widget_get_window (widget),
allocation.width,
allocation.height,
-1); /* Is this correct? */
return FALSE;
}
static gint
design_area_button_press (GtkWidget *widget,
GdkEventButton *event)
{
GtkAllocation allocation;
gint i;
gint old_current;
gtk_widget_get_allocation (ifsDesign->area, &allocation);
gtk_widget_grab_focus (widget);
if (gdk_event_triggers_context_menu ((GdkEvent *) event))
{
GtkWidget *menu =
gtk_ui_manager_get_widget (ifsDesign->ui_manager,
"/dummy-menubar/ifs-compose-menu");
if (GTK_IS_MENU_ITEM (menu))
menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu));
gtk_menu_set_screen (GTK_MENU (menu), gtk_widget_get_screen (widget));
gtk_menu_popup (GTK_MENU (menu),
NULL, NULL, NULL, NULL,
event->button, event->time);
return FALSE;
}
old_current = ifsD->current_element;
ifsD->current_element = -1;
/* Find out where the button press was */
for (i = 0; i < ifsvals.num_elements; i++)
{
if (ipolygon_contains (elements[i]->click_boundary, event->x, event->y))
{
set_current_element (i);
break;
}
}
/* if the user started manipulating an object, set up a new
position on the undo ring */
if (ifsD->current_element >= 0)
undo_begin ();
if (!(event->state & GDK_SHIFT_MASK)
&& ( (ifsD->current_element<0)
|| !element_selected[ifsD->current_element] ))
{
for (i = 0; i < ifsvals.num_elements; i++)
element_selected[i] = FALSE;
}
if (ifsD->current_element >= 0)
{
ifsDesign->button_state |= GDK_BUTTON1_MASK;
element_selected[ifsD->current_element] = TRUE;
ifsDesign->num_selected = 0;
ifsDesign->op_xcenter = 0.0;
ifsDesign->op_ycenter = 0.0;
for (i = 0; i < ifsvals.num_elements; i++)
{
if (element_selected[i])
{
ifsD->selected_orig[i] = *elements[i];
ifsDesign->op_xcenter += elements[i]->v.x;
ifsDesign->op_ycenter += elements[i]->v.y;
ifsDesign->num_selected++;
undo_update (i);
}
}
ifsDesign->op_xcenter /= ifsDesign->num_selected;
ifsDesign->op_ycenter /= ifsDesign->num_selected;
ifsDesign->op_x = (gdouble)event->x / allocation.width;
ifsDesign->op_y = (gdouble)event->y / allocation.width;
ifsDesign->op_center_x = ifsvals.center_x;
ifsDesign->op_center_y = ifsvals.center_y;
}
else
{
ifsD->current_element = old_current;
element_selected[old_current] = TRUE;
}
design_area_redraw ();
return FALSE;
}
static gint
design_area_button_release (GtkWidget *widget,
GdkEventButton *event)
{
if (event->button == 1 &&
(ifsDesign->button_state & GDK_BUTTON1_MASK))
{
ifsDesign->button_state &= ~GDK_BUTTON1_MASK;
ifs_compose_preview ();
}
return FALSE;
}
static gint
design_area_motion (GtkWidget *widget,
GdkEventMotion *event)
{
GtkAllocation allocation;
gint i;
gdouble xo;
gdouble yo;
gdouble xn;
gdouble yn;
Aff2 trans, t1, t2, t3;
if (! (ifsDesign->button_state & GDK_BUTTON1_MASK))
return FALSE;
gtk_widget_get_allocation (ifsDesign->area, &allocation);
xo = (ifsDesign->op_x - ifsDesign->op_xcenter);
yo = (ifsDesign->op_y - ifsDesign->op_ycenter);
xn = (gdouble) event->x / allocation.width - ifsDesign->op_xcenter;
yn = (gdouble) event->y / allocation.width - ifsDesign->op_ycenter;
switch (ifsDesign->op)
{
case OP_ROTATE:
aff2_translate (&t1,-ifsDesign->op_xcenter * allocation.width,
-ifsDesign->op_ycenter * allocation.width);
aff2_scale (&t2,
sqrt((SQR(xn)+SQR(yn))/(SQR(xo)+SQR(yo))),
0);
aff2_compose (&t3, &t2, &t1);
aff2_rotate (&t1, - atan2(yn, xn) + atan2(yo, xo));
aff2_compose (&t2, &t1, &t3);
aff2_translate (&t3, ifsDesign->op_xcenter * allocation.width,
ifsDesign->op_ycenter * allocation.width);
aff2_compose (&trans, &t3, &t2);
break;
case OP_STRETCH:
aff2_translate (&t1,-ifsDesign->op_xcenter * allocation.width,
-ifsDesign->op_ycenter * allocation.width);
aff2_compute_stretch (&t2, xo, yo, xn, yn);
aff2_compose (&t3, &t2, &t1);
aff2_translate (&t1, ifsDesign->op_xcenter * allocation.width,
ifsDesign->op_ycenter * allocation.width);
aff2_compose (&trans, &t1, &t3);
break;
case OP_TRANSLATE:
aff2_translate (&trans,
(xn-xo) * allocation.width,
(yn-yo) * allocation.width);
break;
}
for (i = 0; i < ifsvals.num_elements; i++)
if (element_selected[i])
{
if (ifsDesign->num_selected == ifsvals.num_elements)
{
gdouble cx, cy;
aff2_invert (&t1, &trans);
aff2_compose (&t2, &trans, &ifsD->selected_orig[i].trans);
aff2_compose (&elements[i]->trans, &t2, &t1);
cx = ifsDesign->op_center_x * allocation.width;
cy = ifsDesign->op_center_y * allocation.width;
aff2_apply (&trans, cx, cy, &cx, &cy);
ifsvals.center_x = cx / allocation.width;
ifsvals.center_y = cy / allocation.width;
}
else
{
aff2_compose (&elements[i]->trans, &trans,
&ifsD->selected_orig[i].trans);
}
aff_element_decompose_trans (elements[i],&elements[i]->trans,
allocation.width, allocation.height,
ifsvals.center_x, ifsvals.center_y);
aff_element_compute_trans (elements[i],
allocation.width, allocation.height,
ifsvals.center_x, ifsvals.center_y);
}
update_values ();
design_area_redraw ();
/* Ask for more motion events in case the event was a hint */
gdk_event_request_motions (event);
return FALSE;
}
static void
design_area_redraw (void)
{
GtkAllocation allocation;
gint i;
gtk_widget_get_allocation (ifsDesign->area, &allocation);
for (i = 0; i < ifsvals.num_elements; i++)
aff_element_compute_boundary (elements[i],
allocation.width, allocation.height,
elements, ifsvals.num_elements);
gtk_widget_queue_draw (ifsDesign->area);
}
/* Undo ring functions */
static void
undo_begin (void)
{
gint i, j;
gint to_delete;
gint new_index;
if (undo_cur == UNDO_LEVELS-1)
{
to_delete = 1;
undo_start = (undo_start + 1) % UNDO_LEVELS;
}
else
{
undo_cur++;
to_delete = undo_num - undo_cur;
}
undo_num = undo_num - to_delete + 1;
new_index = (undo_start + undo_cur) % UNDO_LEVELS;
/* remove any redo elements or the oldest element if necessary */
for (j = new_index; to_delete > 0; j = (j+1) % UNDO_LEVELS, to_delete--)
{
for (i = 0; i < undo_ring[j].ifsvals.num_elements; i++)
if (undo_ring[j].elements[i])
aff_element_free (undo_ring[j].elements[i]);
g_free (undo_ring[j].elements);
g_free (undo_ring[j].element_selected);
}
undo_ring[new_index].ifsvals = ifsvals;
undo_ring[new_index].elements = g_new (AffElement *,ifsvals.num_elements);
undo_ring[new_index].element_selected = g_new (gboolean,
ifsvals.num_elements);
undo_ring[new_index].current_element = ifsD->current_element;
for (i = 0; i < ifsvals.num_elements; i++)
{
undo_ring[new_index].elements[i] = NULL;
undo_ring[new_index].element_selected[i] = element_selected[i];
}
design_op_actions_update ();
}
static void
undo_update (gint el)
{
AffElement *elem;
/* initialize */
elem = NULL;
if (!undo_ring[(undo_start + undo_cur) % UNDO_LEVELS].elements[el])
undo_ring[(undo_start + undo_cur) % UNDO_LEVELS].elements[el]
= elem = g_new (AffElement, 1);
*elem = *elements[el];
elem->draw_boundary = NULL;
elem->click_boundary = NULL;
}
static void
undo_exchange (gint el)
{
GtkAllocation allocation;
gint i;
AffElement **telements;
gboolean *tselected;
IfsComposeVals tifsvals;
gint tcurrent;
gtk_widget_get_allocation (ifsDesign->area, &allocation);
/* swap the arrays and values*/
telements = elements;
elements = undo_ring[el].elements;
undo_ring[el].elements = telements;
tifsvals = ifsvals;
ifsvals = undo_ring[el].ifsvals;
undo_ring[el].ifsvals = tifsvals;
tselected = element_selected;
element_selected = undo_ring[el].element_selected;
undo_ring[el].element_selected = tselected;
tcurrent = ifsD->current_element;
ifsD->current_element = undo_ring[el].current_element;
undo_ring[el].current_element = tcurrent;
/* now swap back any unchanged elements */
for (i = 0; i < ifsvals.num_elements; i++)
if (!elements[i])
{
elements[i] = undo_ring[el].elements[i];
undo_ring[el].elements[i] = NULL;
}
else
aff_element_compute_trans (elements[i],
allocation.width, allocation.height,
ifsvals.center_x, ifsvals.center_y);
set_current_element (ifsD->current_element);
design_area_redraw ();
ifs_compose_preview ();
}
static void
undo (void)
{
if (undo_cur >= 0)
{
undo_exchange ((undo_start + undo_cur) % UNDO_LEVELS);
undo_cur--;
}
design_op_actions_update ();
}
static void
redo (void)
{
if (undo_cur != undo_num - 1)
{
undo_cur++;
undo_exchange ((undo_start + undo_cur) % UNDO_LEVELS);
}
design_op_actions_update ();
}
static void
design_area_select_all_callback (GtkWidget *widget,
gpointer data)
{
gint i;
for (i = 0; i < ifsvals.num_elements; i++)
element_selected[i] = TRUE;
design_area_redraw ();
}
/* Interface functions */
static void
val_changed_update (void)
{
GtkAllocation allocation;
AffElement *cur;
if (ifsD->in_update)
return;
gtk_widget_get_allocation (ifsDesign->area, &allocation);
cur = elements[ifsD->current_element];
undo_begin ();
undo_update (ifsD->current_element);
cur->v = ifsD->current_vals;
cur->v.theta *= G_PI/180.0;
aff_element_compute_trans (cur,
allocation.width, allocation.height,
ifsvals.center_x, ifsvals.center_y);
aff_element_compute_color_trans (cur);
design_area_redraw ();
ifs_compose_preview ();
}
/* Pseudo-widget representing a color mapping */
#define COLOR_SAMPLE_SIZE 30
static ColorMap *
color_map_create (const gchar *name,
GimpRGB *orig_color,
GimpRGB *data,
gboolean fixed_point)
{
GtkWidget *frame;
GtkWidget *arrow;
ColorMap *color_map = g_new (ColorMap, 1);
gimp_rgb_set_alpha (data, 1.0);
color_map->color = data;
color_map->fixed_point = fixed_point;
color_map->hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (color_map->hbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
color_map->orig_preview =
gimp_color_area_new (fixed_point ? data : orig_color,
GIMP_COLOR_AREA_FLAT, 0);
gtk_drag_dest_unset (color_map->orig_preview);
gtk_widget_set_size_request (color_map->orig_preview,
COLOR_SAMPLE_SIZE, COLOR_SAMPLE_SIZE);
gtk_container_add (GTK_CONTAINER (frame), color_map->orig_preview);
gtk_widget_show (color_map->orig_preview);
arrow = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (color_map->hbox), arrow, FALSE, FALSE, 0);
gtk_widget_show (arrow);
color_map->button = gimp_color_button_new (name,
COLOR_SAMPLE_SIZE,
COLOR_SAMPLE_SIZE,
data,
GIMP_COLOR_AREA_FLAT);
gtk_box_pack_start (GTK_BOX (color_map->hbox), color_map->button,
FALSE, FALSE, 0);
gtk_widget_show (color_map->button);
g_signal_connect (color_map->button, "color-changed",
G_CALLBACK (gimp_color_button_get_color),
data);
g_signal_connect (color_map->button, "color-changed",
G_CALLBACK (color_map_color_changed_cb),
color_map);
return color_map;
}
static void
color_map_color_changed_cb (GtkWidget *widget,
ColorMap *color_map)
{
if (ifsD->in_update)
return;
undo_begin ();
undo_update (ifsD->current_element);
elements[ifsD->current_element]->v = ifsD->current_vals;
elements[ifsD->current_element]->v.theta *= G_PI/180.0;
aff_element_compute_color_trans (elements[ifsD->current_element]);
update_values ();
ifs_compose_preview ();
}
static void
color_map_update (ColorMap *color_map)
{
gimp_color_button_set_color (GIMP_COLOR_BUTTON (color_map->button),
color_map->color);
if (color_map->fixed_point)
gimp_color_area_set_color (GIMP_COLOR_AREA (color_map->orig_preview),
color_map->color);
}
static void
simple_color_set_sensitive (void)
{
gint sc = elements[ifsD->current_element]->v.simple_color;
gtk_widget_set_sensitive (ifsD->target_cmap->hbox, sc);
gtk_widget_set_sensitive (ifsD->hue_scale_pair->scale, sc);
gtk_widget_set_sensitive (ifsD->hue_scale_pair->spin, sc);
gtk_widget_set_sensitive (ifsD->value_scale_pair->scale, sc);
gtk_widget_set_sensitive (ifsD->value_scale_pair->spin, sc);
gtk_widget_set_sensitive (ifsD->red_cmap->hbox, !sc);
gtk_widget_set_sensitive (ifsD->green_cmap->hbox, !sc);
gtk_widget_set_sensitive (ifsD->blue_cmap->hbox, !sc);
gtk_widget_set_sensitive (ifsD->black_cmap->hbox, !sc);
}
static void
simple_color_toggled (GtkWidget *widget,
gpointer data)
{
AffElement *cur = elements[ifsD->current_element];
cur->v.simple_color = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
ifsD->current_vals.simple_color = cur->v.simple_color;
if (cur->v.simple_color)
aff_element_compute_color_trans (cur);
val_changed_update ();
simple_color_set_sensitive ();
}
/* Generic mechanism for scale/entry combination (possibly without
scale) */
static ValuePair *
value_pair_create (gpointer data,
gdouble lower,
gdouble upper,
gboolean create_scale,
ValuePairType type)
{
ValuePair *value_pair = g_new (ValuePair, 1);
value_pair->data.d = data;
value_pair->type = type;
value_pair->timeout_id = 0;
value_pair->adjustment = (GtkAdjustment *)
gtk_adjustment_new (1.0, lower, upper,
(upper - lower) / 100,
(upper - lower) / 10,
0.0);
value_pair->spin = gimp_spin_button_new (value_pair->adjustment, 1.0, 3);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (value_pair->spin), TRUE);
gtk_widget_set_size_request (value_pair->spin, 72, -1);
g_signal_connect (value_pair->adjustment, "value-changed",
G_CALLBACK (value_pair_scale_callback),
value_pair);
if (create_scale)
{
value_pair->scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL,
value_pair->adjustment);
if (type == VALUE_PAIR_INT)
gtk_scale_set_digits (GTK_SCALE (value_pair->scale), 0);
else
gtk_scale_set_digits (GTK_SCALE (value_pair->scale), 3);
gtk_scale_set_draw_value (GTK_SCALE (value_pair->scale), FALSE);
}
else
{
value_pair->scale = NULL;
}
return value_pair;
}
static void
value_pair_update (ValuePair *value_pair)
{
if (value_pair->type == VALUE_PAIR_INT)
gtk_adjustment_set_value (value_pair->adjustment, *value_pair->data.i);
else
gtk_adjustment_set_value (value_pair->adjustment, *value_pair->data.d);
}
static gboolean
value_pair_scale_callback_real (gpointer data)
{
ValuePair *value_pair = data;
gint changed = FALSE;
if (value_pair->type == VALUE_PAIR_DOUBLE)
{
if ((gdouble) *value_pair->data.d !=
gtk_adjustment_get_value (value_pair->adjustment))
{
changed = TRUE;
*value_pair->data.d = gtk_adjustment_get_value (value_pair->adjustment);
}
}
else
{
if (*value_pair->data.i !=
(gint) gtk_adjustment_get_value (value_pair->adjustment))
{
changed = TRUE;
*value_pair->data.i = gtk_adjustment_get_value (value_pair->adjustment);
}
}
if (changed)
val_changed_update ();
value_pair->timeout_id = 0;
return FALSE;
}
static void
value_pair_scale_callback (GtkAdjustment *adjustment,
ValuePair *value_pair)
{
if (value_pair->timeout_id != 0)
return;
value_pair->timeout_id = g_timeout_add (500, /* update every half second */
value_pair_scale_callback_real,
value_pair);
}
static void
design_op_update_callback (GtkRadioAction *action,
GtkRadioAction *current,
gpointer data)
{
ifsDesign->op = gtk_radio_action_get_current_value (action);
/* cursor switch */
if (gtk_widget_get_realized (ifsDesign->area))
design_area_realize (ifsDesign->area);
}
static void
recompute_center_cb (GtkWidget *widget,
gpointer data)
{
recompute_center (TRUE);
}
static void
recompute_center (gboolean save_undo)
{
GtkAllocation allocation;
gint i;
gdouble x, y;
gdouble center_x = 0.0;
gdouble center_y = 0.0;
gtk_widget_get_allocation (ifsDesign->area, &allocation);
if (save_undo)
undo_begin ();
for (i = 0; i < ifsvals.num_elements; i++)
{
if (save_undo)
undo_update (i);
aff_element_compute_trans (elements[i],1, ifsvals.aspect_ratio,
ifsvals.center_x, ifsvals.center_y);
aff2_fixed_point (&elements[i]->trans, &x, &y);
center_x += x;
center_y += y;
}
ifsvals.center_x = center_x/ifsvals.num_elements;
ifsvals.center_y = center_y/ifsvals.num_elements;
for (i = 0; i < ifsvals.num_elements; i++)
{
aff_element_decompose_trans (elements[i],&elements[i]->trans,
1, ifsvals.aspect_ratio,
ifsvals.center_x, ifsvals.center_y);
}
if (allocation.width > 1 && allocation.height > 1)
{
for (i = 0; i < ifsvals.num_elements; i++)
aff_element_compute_trans (elements[i],
allocation.width, allocation.height,
ifsvals.center_x, ifsvals.center_y);
design_area_redraw ();
update_values ();
}
}
static void
flip_check_button_callback (GtkWidget *widget,
gpointer data)
{
GtkAllocation allocation;
guint i;
gboolean active;
if (ifsD->in_update)
return;
gtk_widget_get_allocation (ifsDesign->area, &allocation);
active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
undo_begin ();
for (i = 0; i < ifsvals.num_elements; i++)
{
if (element_selected[i])
{
undo_update (i);
elements[i]->v.flip = active;
aff_element_compute_trans (elements[i],
allocation.width, allocation.height,
ifsvals.center_x, ifsvals.center_y);
}
}
update_values ();
design_area_redraw ();
ifs_compose_preview ();
}
static void
ifs_compose_set_defaults (void)
{
gint i;
GimpRGB color;
gimp_context_get_foreground (&color);
ifsvals.aspect_ratio =
(gdouble)ifsD->drawable_height / ifsD->drawable_width;
for (i = 0; i < ifsvals.num_elements; i++)
aff_element_free (elements[i]);
count_for_naming = 0;
ifsvals.num_elements = 3;
elements = g_realloc (elements, ifsvals.num_elements * sizeof(AffElement *));
element_selected = g_realloc (element_selected,
ifsvals.num_elements * sizeof(gboolean));
elements[0] = aff_element_new (0.3, 0.37 * ifsvals.aspect_ratio, &color,
++count_for_naming);
element_selected[0] = FALSE;
elements[1] = aff_element_new (0.7, 0.37 * ifsvals.aspect_ratio, &color,
++count_for_naming);
element_selected[1] = FALSE;
elements[2] = aff_element_new (0.5, 0.7 * ifsvals.aspect_ratio, &color,
++count_for_naming);
element_selected[2] = FALSE;
ifsvals.center_x = 0.5;
ifsvals.center_y = 0.5 * ifsvals.aspect_ratio;
ifsvals.iterations = ifsD->drawable_height * ifsD->drawable_width;
ifsvals.subdivide = 3;
ifsvals.max_memory = 4096;
if (ifsOptD)
{
value_pair_update (ifsOptD->iterations_pair);
value_pair_update (ifsOptD->subdivide_pair);
value_pair_update (ifsOptD->radius_pair);
value_pair_update (ifsOptD->memory_pair);
}
ifsvals.radius = 0.7;
set_current_element (0);
element_selected[0] = TRUE;
recompute_center (FALSE);
if (ifsD->selected_orig)
g_free (ifsD->selected_orig);
ifsD->selected_orig = g_new (AffElement, ifsvals.num_elements);
}
/* show a transient message dialog */
static void
ifscompose_message_dialog (GtkMessageType type,
GtkWindow *parent,
const gchar *title,
const gchar *message)
{
GtkWidget *dialog;
dialog = gtk_message_dialog_new (parent, 0, type, GTK_BUTTONS_OK,
"%s", message);
if (title)
gtk_window_set_title (GTK_WINDOW (dialog), title);
gtk_window_set_role (GTK_WINDOW (dialog), "ifscompose-message");
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
/* save an ifs file */
static void
ifsfile_save_response (GtkWidget *dialog,
gint response_id,
gpointer data)
{
if (response_id == GTK_RESPONSE_OK)
{
gchar *filename;
gchar *str;
FILE *fh;
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
str = ifsvals_stringify (&ifsvals, elements);
fh = g_fopen (filename, "wb");
if (! fh)
{
gchar *message =
g_strdup_printf (_("Could not open '%s' for writing: %s"),
gimp_filename_to_utf8 (filename),
g_strerror (errno));
ifscompose_message_dialog (GTK_MESSAGE_ERROR, GTK_WINDOW (dialog),
_("Save failed"), message);
g_free (message);
g_free (filename);
return;
}
fputs (str, fh);
fclose (fh);
}
gtk_widget_destroy (dialog);
}
/* replace ifsvals and elements with specified new values
* recompute and update everything necessary */
static void
ifsfile_replace_ifsvals (IfsComposeVals *new_ifsvals,
AffElement **new_elements)
{
GtkAllocation allocation;
guint i;
gtk_widget_get_allocation (ifsDesign->area, &allocation);
for (i = 0; i < ifsvals.num_elements; i++)
aff_element_free (elements[i]);
g_free (elements);
ifsvals = *new_ifsvals;
elements = new_elements;
for (i = 0; i < ifsvals.num_elements; i++)
{
aff_element_compute_trans (elements[i],
allocation.width, allocation.height,
ifsvals.center_x, ifsvals.center_y);
aff_element_compute_color_trans (elements[i]);
}
element_selected = g_realloc (element_selected,
ifsvals.num_elements * sizeof(gboolean));
for (i = 0; i < ifsvals.num_elements; i++)
element_selected[i] = FALSE;
if (ifsOptD)
{
value_pair_update (ifsOptD->iterations_pair);
value_pair_update (ifsOptD->subdivide_pair);
value_pair_update (ifsOptD->radius_pair);
value_pair_update (ifsOptD->memory_pair);
}
set_current_element (0);
element_selected[0] = TRUE;
recompute_center (FALSE);
if (ifsD->selected_orig)
g_free (ifsD->selected_orig);
ifsD->selected_orig = g_new (AffElement, ifsvals.num_elements);
}
/* load an ifs file */
static void
ifsfile_load_response (GtkWidget *dialog,
gint response_id,
gpointer data)
{
if (response_id == GTK_RESPONSE_OK)
{
gchar *filename;
gchar *buffer;
AffElement **new_elements;
IfsComposeVals new_ifsvals;
GError *error = NULL;
guint i;
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
if (! g_file_get_contents (filename, &buffer, NULL, &error))
{
ifscompose_message_dialog (GTK_MESSAGE_ERROR, GTK_WINDOW (dialog),
_("Open failed"), error->message);
g_error_free (error);
g_free (filename);
return;
}
if (! ifsvals_parse_string (buffer, &new_ifsvals, &new_elements))
{
gchar *message = g_strdup_printf (_("File '%s' doesn't seem to be "
"an IFS Fractal file."),
gimp_filename_to_utf8 (filename));
ifscompose_message_dialog (GTK_MESSAGE_ERROR, GTK_WINDOW (dialog),
_("Open failed"), message);
g_free (filename);
g_free (message);
g_free (buffer);
return;
}
g_free (buffer);
g_free (filename);
undo_begin ();
for (i = 0; i < ifsvals.num_elements; i++)
undo_update (i);
ifsfile_replace_ifsvals (&new_ifsvals, new_elements);
design_op_actions_update ();
ifs_compose_preview ();
design_area_redraw ();
}
gtk_widget_destroy (GTK_WIDGET (dialog));
}
static void
ifs_compose_save (GtkWidget *parent)
{
static GtkWidget *dialog = NULL;
if (! dialog)
{
dialog =
gtk_file_chooser_dialog_new (_("Save as IFS Fractal file"),
GTK_WINDOW (parent),
GTK_FILE_CHOOSER_ACTION_SAVE,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Save"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog),
TRUE);
g_signal_connect (dialog, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&dialog);
g_signal_connect (dialog, "response",
G_CALLBACK (ifsfile_save_response),
NULL);
}
gtk_window_present (GTK_WINDOW (dialog));
}
static void
ifs_compose_load (GtkWidget *parent)
{
static GtkWidget *dialog = NULL;
if (! dialog)
{
dialog =
gtk_file_chooser_dialog_new (_("Open IFS Fractal file"),
GTK_WINDOW (parent),
GTK_FILE_CHOOSER_ACTION_OPEN,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Open"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
g_signal_connect (dialog, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&dialog);
g_signal_connect (dialog, "response",
G_CALLBACK (ifsfile_load_response),
NULL);
}
gtk_window_present (GTK_WINDOW (dialog));
}
static void
ifs_compose_new_callback (GtkAction *action,
gpointer data)
{
GtkAllocation allocation;
GimpRGB color;
gint i;
AffElement *elem;
gtk_widget_get_allocation (ifsDesign->area, &allocation);
undo_begin ();
gimp_context_get_foreground (&color);
elem = aff_element_new (0.5, 0.5 * allocation.height / allocation.width,
&color,
++count_for_naming);
ifsvals.num_elements++;
elements = g_realloc (elements, ifsvals.num_elements * sizeof (AffElement *));
element_selected = g_realloc (element_selected,
ifsvals.num_elements * sizeof (gboolean));
for (i = 0; i < ifsvals.num_elements-1; i++)
element_selected[i] = FALSE;
element_selected[ifsvals.num_elements-1] = TRUE;
elements[ifsvals.num_elements-1] = elem;
set_current_element (ifsvals.num_elements-1);
ifsD->selected_orig = g_realloc (ifsD->selected_orig,
ifsvals.num_elements * sizeof(AffElement));
aff_element_compute_trans (elem,
allocation.width, allocation.height,
ifsvals.center_x, ifsvals.center_y);
design_area_redraw ();
ifs_compose_preview ();
design_op_actions_update ();
}
static void
ifs_compose_delete_callback (GtkAction *action,
gpointer data)
{
gint i;
gint new_current;
undo_begin ();
undo_update (ifsD->current_element);
aff_element_free (elements[ifsD->current_element]);
if (ifsD->current_element < ifsvals.num_elements-1)
{
undo_update (ifsvals.num_elements-1);
elements[ifsD->current_element] = elements[ifsvals.num_elements-1];
new_current = ifsD->current_element;
}
else
new_current = ifsvals.num_elements-2;
ifsvals.num_elements--;
for (i = 0; i < ifsvals.num_elements; i++)
if (element_selected[i])
{
new_current = i;
break;
}
element_selected[new_current] = TRUE;
set_current_element (new_current);
design_area_redraw ();
ifs_compose_preview ();
design_op_actions_update ();
}
static void
ifs_compose_options_callback (GtkAction *action,
gpointer data)
{
ifs_options_dialog (GTK_WIDGET (data));
}
static gint
preview_idle_render (gpointer data)
{
GtkAllocation allocation;
gint iterations = PREVIEW_RENDER_CHUNK;
gint i;
gtk_widget_get_allocation (ifsDesign->area, &allocation);
if (iterations > ifsD->preview_iterations)
iterations = ifsD->preview_iterations;
for (i = 0; i < ifsvals.num_elements; i++)
aff_element_compute_trans (elements[i],
allocation.width, allocation.height,
ifsvals.center_x, ifsvals.center_y);
ifs_render (elements, ifsvals.num_elements,
allocation.width, allocation.height,
iterations,&ifsvals, 0, allocation.height,
ifsD->preview_data, NULL, NULL, TRUE);
for (i = 0; i < ifsvals.num_elements; i++)
aff_element_compute_trans (elements[i],
allocation.width, allocation.height,
ifsvals.center_x, ifsvals.center_y);
ifsD->preview_iterations -= iterations;
gimp_preview_area_draw (GIMP_PREVIEW_AREA (ifsD->preview),
0, 0, allocation.width, allocation.height,
GIMP_RGB_IMAGE,
ifsD->preview_data,
allocation.width * 3);
return (ifsD->preview_iterations != 0);
}
static void
ifs_compose_preview (void)
{
/* Expansion isn't really supported for previews */
gint i;
gint width = ifsD->preview_width;
gint height = ifsD->preview_height;
guchar rc, gc, bc;
guchar *ptr;
GimpRGB color;
if (!ifsD->preview_data)
ifsD->preview_data = g_new (guchar, 3 * width * height);
gimp_context_get_background (&color);
gimp_rgb_get_uchar (&color, &rc, &gc, &bc);
ptr = ifsD->preview_data;
for (i = 0; i < width * height; i++)
{
*ptr++ = rc;
*ptr++ = gc;
*ptr++ = bc;
}
if (ifsD->preview_iterations == 0)
g_idle_add (preview_idle_render, NULL);
ifsD->preview_iterations =
ifsvals.iterations * ((gdouble) width * height /
(ifsD->drawable_width * ifsD->drawable_height));
}
static void
ifs_compose_response (GtkWidget *widget,
gint response_id,
gpointer data)
{
switch (response_id)
{
case RESPONSE_OPEN:
ifs_compose_load (widget);
break;
case RESPONSE_SAVE:
ifs_compose_save (widget);
break;
case RESPONSE_RESET:
{
GtkAllocation allocation;
gint i;
gtk_widget_get_allocation (ifsDesign->area, &allocation);
undo_begin ();
for (i = 0; i < ifsvals.num_elements; i++)
undo_update (i);
ifs_compose_set_defaults ();
ifs_compose_preview ();
for (i = 0; i < ifsvals.num_elements; i++)
aff_element_compute_trans (elements[i],
allocation.width, allocation.height,
ifsvals.center_x, ifsvals.center_y);
design_area_redraw ();
design_op_actions_update ();
}
break;
case GTK_RESPONSE_OK:
ifscint.run = TRUE;
default:
gtk_widget_destroy (widget);
break;
}
}
Reference in New Issue View Git Blame Copy Permalink