diff options
Diffstat (limited to 'plug-ins/fractal-explorer/fractal-explorer-dialogs.c')
| -rw-r--r-- | plug-ins/fractal-explorer/fractal-explorer-dialogs.c | 1889 |
1 files changed, 1889 insertions, 0 deletions
diff --git a/plug-ins/fractal-explorer/fractal-explorer-dialogs.c b/plug-ins/fractal-explorer/fractal-explorer-dialogs.c new file mode 100644 index 0000000..8f53860 --- /dev/null +++ b/plug-ins/fractal-explorer/fractal-explorer-dialogs.c @@ -0,0 +1,1889 @@ +/********************************************************************** + 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 <errno.h> +#include <stdlib.h> +#include <string.h> + +#include <glib/gstdio.h> + +#include <libgimp/gimp.h> +#include <libgimp/gimpui.h> + +#include "fractal-explorer.h" +#include "fractal-explorer-dialogs.h" + +#include "libgimp/stdplugins-intl.h" + + +#define ZOOM_UNDO_SIZE 100 + + +static gint n_gradient_samples = 0; +static gdouble *gradient_samples = NULL; +static gchar *gradient_name = NULL; +static gboolean ready_now = FALSE; +static gchar *tpath = NULL; +static DialogElements *elements = NULL; +static GtkWidget *cmap_preview; +static GtkWidget *maindlg; + +static explorer_vals_t zooms[ZOOM_UNDO_SIZE]; +static gint zoomindex = 0; +static gint zoommax = 0; + +static gint oldxpos = -1; +static gint oldypos = -1; +static gdouble x_press = -1.0; +static gdouble y_press = -1.0; + +static explorer_vals_t standardvals = +{ + 0, + -2.0, + 2.0, + -1.5, + 1.5, + 50.0, + -0.75, + -0.2, + 0, + 1.0, + 1.0, + 1.0, + 1, + 1, + 0, + 0, + 0, + 0, + 1, + 256, + 0 +}; + +/********************************************************************** + FORWARD DECLARATIONS + *********************************************************************/ + +static void load_file_chooser_response (GtkFileChooser *chooser, + gint response_id, + gpointer data); +static void save_file_chooser_response (GtkFileChooser *chooser, + gint response_id, + gpointer data); +static void create_load_file_chooser (GtkWidget *widget, + GtkWidget *dialog); +static void create_save_file_chooser (GtkWidget *widget, + GtkWidget *dialog); + +static void cmap_preview_size_allocate (GtkWidget *widget, + GtkAllocation *allocation); + +/********************************************************************** + CALLBACKS + *********************************************************************/ + +static void +dialog_response (GtkWidget *widget, + gint response_id, + gpointer data) +{ + switch (response_id) + { + case GTK_RESPONSE_OK: + wint.run = TRUE; + gtk_widget_destroy (widget); + break; + + default: + gtk_widget_destroy (widget); + break; + } +} + +static void +dialog_reset_callback (GtkWidget *widget, + gpointer data) +{ + wvals.xmin = standardvals.xmin; + wvals.xmax = standardvals.xmax; + wvals.ymin = standardvals.ymin; + wvals.ymax = standardvals.ymax; + wvals.iter = standardvals.iter; + wvals.cx = standardvals.cx; + wvals.cy = standardvals.cy; + + dialog_change_scale (); + set_cmap_preview (); + dialog_update_preview (); +} + +static void +dialog_redraw_callback (GtkWidget *widget, + gpointer data) +{ + gint alwaysprev = wvals.alwayspreview; + + wvals.alwayspreview = TRUE; + set_cmap_preview (); + dialog_update_preview (); + wvals.alwayspreview = alwaysprev; +} + +static void +dialog_undo_zoom_callback (GtkWidget *widget, + gpointer data) +{ + if (zoomindex > 0) + { + zooms[zoomindex] = wvals; + zoomindex--; + wvals = zooms[zoomindex]; + dialog_change_scale (); + set_cmap_preview (); + dialog_update_preview (); + } +} + +static void +dialog_redo_zoom_callback (GtkWidget *widget, + gpointer data) +{ + if (zoomindex < zoommax) + { + zoomindex++; + wvals = zooms[zoomindex]; + dialog_change_scale (); + set_cmap_preview (); + dialog_update_preview (); + } +} + +static void +dialog_step_in_callback (GtkWidget *widget, + gpointer data) +{ + double xdifferenz; + double ydifferenz; + + if (zoomindex < ZOOM_UNDO_SIZE - 1) + { + zooms[zoomindex]=wvals; + zoomindex++; + } + zoommax = zoomindex; + + xdifferenz = wvals.xmax - wvals.xmin; + ydifferenz = wvals.ymax - wvals.ymin; + wvals.xmin += 1.0 / 6.0 * xdifferenz; + wvals.ymin += 1.0 / 6.0 * ydifferenz; + wvals.xmax -= 1.0 / 6.0 * xdifferenz; + wvals.ymax -= 1.0 / 6.0 * ydifferenz; + zooms[zoomindex] = wvals; + + dialog_change_scale (); + set_cmap_preview (); + dialog_update_preview (); +} + +static void +dialog_step_out_callback (GtkWidget *widget, + gpointer data) +{ + gdouble xdifferenz; + gdouble ydifferenz; + + if (zoomindex < ZOOM_UNDO_SIZE - 1) + { + zooms[zoomindex]=wvals; + zoomindex++; + } + zoommax = zoomindex; + + xdifferenz = wvals.xmax - wvals.xmin; + ydifferenz = wvals.ymax - wvals.ymin; + wvals.xmin -= 1.0 / 4.0 * xdifferenz; + wvals.ymin -= 1.0 / 4.0 * ydifferenz; + wvals.xmax += 1.0 / 4.0 * xdifferenz; + wvals.ymax += 1.0 / 4.0 * ydifferenz; + zooms[zoomindex] = wvals; + + dialog_change_scale (); + set_cmap_preview (); + dialog_update_preview (); +} + +static void +explorer_toggle_update (GtkWidget *widget, + gpointer data) +{ + gimp_toggle_button_update (widget, data); + + set_cmap_preview (); + dialog_update_preview (); +} + +static void +explorer_radio_update (GtkWidget *widget, + gpointer data) +{ + gboolean c_sensitive; + + gimp_radio_button_update (widget, data); + + switch (wvals.fractaltype) + { + case TYPE_MANDELBROT: + case TYPE_SIERPINSKI: + c_sensitive = FALSE; + break; + + default: + c_sensitive = TRUE; + break; + } + + gimp_scale_entry_set_sensitive (elements->cx, c_sensitive); + gimp_scale_entry_set_sensitive (elements->cy, c_sensitive); + + set_cmap_preview (); + dialog_update_preview (); +} + +static void +explorer_double_adjustment_update (GtkAdjustment *adjustment, + gpointer data) +{ + gimp_double_adjustment_update (adjustment, data); + + set_cmap_preview (); + dialog_update_preview (); +} + +static void +explorer_number_of_colors_callback (GtkAdjustment *adjustment, + gpointer data) +{ + gimp_int_adjustment_update (adjustment, data); + + g_free (gradient_samples); + + if (! gradient_name) + gradient_name = gimp_context_get_gradient (); + + gimp_gradient_get_uniform_samples (gradient_name, + wvals.ncolors, + wvals.gradinvert, + &n_gradient_samples, + &gradient_samples); + + set_cmap_preview (); + dialog_update_preview (); +} + +static void +explorer_gradient_select_callback (GimpGradientSelectButton *gradient_button, + const gchar *name, + gint width, + const gdouble *gradient_data, + gboolean dialog_closing, + gpointer data) +{ + g_free (gradient_name); + g_free (gradient_samples); + + gradient_name = g_strdup (name); + + gimp_gradient_get_uniform_samples (gradient_name, + wvals.ncolors, + wvals.gradinvert, + &n_gradient_samples, + &gradient_samples); + + if (wvals.colormode == 1) + { + set_cmap_preview (); + dialog_update_preview (); + } +} + +static void +preview_draw_crosshair (gint px, + gint py) +{ + gint x, y; + guchar *p_ul; + + p_ul = wint.wimage + 3 * (preview_width * py + 0); + + for (x = 0; x < preview_width; x++) + { + p_ul[0] ^= 254; + p_ul[1] ^= 254; + p_ul[2] ^= 254; + p_ul += 3; + } + + p_ul = wint.wimage + 3 * (preview_width * 0 + px); + + for (y = 0; y < preview_height; y++) + { + p_ul[0] ^= 254; + p_ul[1] ^= 254; + p_ul[2] ^= 254; + p_ul += 3 * preview_width; + } +} + +static void +preview_redraw (void) +{ + gimp_preview_area_draw (GIMP_PREVIEW_AREA (wint.preview), + 0, 0, preview_width, preview_height, + GIMP_RGB_IMAGE, + wint.wimage, preview_width * 3); + + gtk_widget_queue_draw (wint.preview); +} + +static gboolean +preview_button_press_event (GtkWidget *widget, + GdkEventButton *event) +{ + if (event->button == 1) + { + x_press = event->x; + y_press = event->y; + xbild = preview_width; + ybild = preview_height; + xdiff = (xmax - xmin) / xbild; + ydiff = (ymax - ymin) / ybild; + + preview_draw_crosshair (x_press, y_press); + preview_redraw (); + } + return TRUE; +} + +static gboolean +preview_motion_notify_event (GtkWidget *widget, + GdkEventButton *event) +{ + if (oldypos != -1) + { + preview_draw_crosshair (oldxpos, oldypos); + } + + oldxpos = event->x; + oldypos = event->y; + + if ((oldxpos >= 0.0) && + (oldypos >= 0.0) && + (oldxpos < preview_width) && + (oldypos < preview_height)) + { + preview_draw_crosshair (oldxpos, oldypos); + } + else + { + oldypos = -1; + oldxpos = -1; + } + + preview_redraw (); + + return TRUE; +} + +static gboolean +preview_leave_notify_event (GtkWidget *widget, + GdkEventButton *event) +{ + if (oldypos != -1) + { + preview_draw_crosshair (oldxpos, oldypos); + } + oldxpos = -1; + oldypos = -1; + + preview_redraw (); + + gdk_window_set_cursor (gtk_widget_get_window (maindlg), NULL); + + return TRUE; +} + +static gboolean +preview_enter_notify_event (GtkWidget *widget, + GdkEventButton *event) +{ + static GdkCursor *cursor = NULL; + + if (! cursor) + { + GdkDisplay *display = gtk_widget_get_display (maindlg); + + cursor = gdk_cursor_new_for_display (display, GDK_TCROSS); + + } + + gdk_window_set_cursor (gtk_widget_get_window (maindlg), cursor); + + return TRUE; +} + +static gboolean +preview_button_release_event (GtkWidget *widget, + GdkEventButton *event) +{ + gdouble l_xmin; + gdouble l_xmax; + gdouble l_ymin; + gdouble l_ymax; + + if (event->button == 1) + { + gdouble x_release, y_release; + + x_release = event->x; + y_release = event->y; + + if ((x_press >= 0.0) && (y_press >= 0.0) && + (x_release >= 0.0) && (y_release >= 0.0) && + (x_press < preview_width) && (y_press < preview_height) && + (x_release < preview_width) && (y_release < preview_height)) + { + l_xmin = (wvals.xmin + + (wvals.xmax - wvals.xmin) * (x_press / preview_width)); + l_xmax = (wvals.xmin + + (wvals.xmax - wvals.xmin) * (x_release / preview_width)); + l_ymin = (wvals.ymin + + (wvals.ymax - wvals.ymin) * (y_press / preview_height)); + l_ymax = (wvals.ymin + + (wvals.ymax - wvals.ymin) * (y_release / preview_height)); + + if (zoomindex < ZOOM_UNDO_SIZE - 1) + { + zooms[zoomindex] = wvals; + zoomindex++; + } + zoommax = zoomindex; + wvals.xmin = l_xmin; + wvals.xmax = l_xmax; + wvals.ymin = l_ymin; + wvals.ymax = l_ymax; + dialog_change_scale (); + dialog_update_preview (); + oldypos = oldxpos = -1; + } + } + + return TRUE; +} + +/********************************************************************** + FUNCTION: explorer_dialog + *********************************************************************/ + +gint +explorer_dialog (void) +{ + GtkWidget *dialog; + GtkWidget *top_hbox; + GtkWidget *left_vbox; + GtkWidget *abox; + GtkWidget *vbox; + GtkWidget *bbox; + GtkWidget *frame; + GtkWidget *toggle; + GtkWidget *toggle_vbox; + GtkWidget *toggle_vbox2; + GtkWidget *toggle_vbox3; + GtkWidget *notebook; + GtkWidget *hbox; + GtkWidget *table; + GtkWidget *button; + GtkWidget *gradient; + gchar *path; + gchar *gradient_name; + GSList *group = NULL; + gint i; + + gimp_ui_init (PLUG_IN_BINARY, TRUE); + + path = gimp_gimprc_query ("fractalexplorer-path"); + + if (path) + { + fractalexplorer_path = g_filename_from_utf8 (path, -1, NULL, NULL, NULL); + g_free (path); + } + else + { + gchar *gimprc = gimp_personal_rc_file ("gimprc"); + gchar *full_path = gimp_config_build_data_path ("fractalexplorer"); + gchar *esc_path = g_strescape (full_path, NULL); + g_free (full_path); + + g_message (_("No %s in gimprc:\n" + "You need to add an entry like\n" + "(%s \"%s\")\n" + "to your %s file."), + "fractalexplorer-path", + "fractalexplorer-path", + esc_path, gimp_filename_to_utf8 (gimprc)); + + g_free (gimprc); + g_free (esc_path); + } + + wint.wimage = g_new (guchar, preview_width * preview_height * 3); + elements = g_new (DialogElements, 1); + + dialog = maindlg = + gimp_dialog_new (_("Fractal Explorer"), PLUG_IN_ROLE, + NULL, 0, + gimp_standard_help_func, PLUG_IN_PROC, + + _("_Cancel"), GTK_RESPONSE_CANCEL, + _("_OK"), GTK_RESPONSE_OK, + + NULL); + + gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), + GTK_RESPONSE_OK, + GTK_RESPONSE_CANCEL, + -1); + + gimp_window_set_transient (GTK_WINDOW (dialog)); + + g_signal_connect (dialog, "response", + G_CALLBACK (dialog_response), + NULL); + + g_signal_connect (dialog, "destroy", + G_CALLBACK (gtk_main_quit), + NULL); + + top_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); + gtk_container_set_border_width (GTK_CONTAINER (top_hbox), 12); + gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), + top_hbox, FALSE, FALSE, 0); + gtk_widget_show (top_hbox); + + left_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); + gtk_box_pack_start (GTK_BOX (top_hbox), left_vbox, FALSE, FALSE, 0); + gtk_widget_show (left_vbox); + + /* Preview */ + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); + gtk_box_pack_start (GTK_BOX (left_vbox), vbox, FALSE, FALSE, 0); + gtk_widget_show (vbox); + + abox = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); + gtk_box_pack_start (GTK_BOX (vbox), abox, FALSE, FALSE, 0); + gtk_widget_show (abox); + + frame = gtk_frame_new (NULL); + gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); + gtk_container_add (GTK_CONTAINER (abox), frame); + gtk_widget_show (frame); + + wint.preview = gimp_preview_area_new (); + gtk_widget_set_size_request (wint.preview, preview_width, preview_height); + gtk_container_add (GTK_CONTAINER (frame), wint.preview); + + g_signal_connect (wint.preview, "button-press-event", + G_CALLBACK (preview_button_press_event), + NULL); + g_signal_connect (wint.preview, "button-release-event", + G_CALLBACK (preview_button_release_event), + NULL); + g_signal_connect (wint.preview, "motion-notify-event", + G_CALLBACK (preview_motion_notify_event), + NULL); + g_signal_connect (wint.preview, "leave-notify-event", + G_CALLBACK (preview_leave_notify_event), + NULL); + g_signal_connect (wint.preview, "enter-notify-event", + G_CALLBACK (preview_enter_notify_event), + NULL); + + gtk_widget_set_events (wint.preview, (GDK_BUTTON_PRESS_MASK | + GDK_BUTTON_RELEASE_MASK | + GDK_POINTER_MOTION_MASK | + GDK_LEAVE_NOTIFY_MASK | + GDK_ENTER_NOTIFY_MASK)); + gtk_widget_show (wint.preview); + + toggle = gtk_check_button_new_with_mnemonic (_("Re_altime preview")); + gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); + g_signal_connect (toggle, "toggled", + G_CALLBACK (explorer_toggle_update), + &wvals.alwayspreview); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), + wvals.alwayspreview); + gtk_widget_show (toggle); + gimp_help_set_help_data (toggle, _("If enabled the preview will " + "be redrawn automatically"), NULL); + + button = gtk_button_new_with_mnemonic (_("R_edraw preview")); + gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); + g_signal_connect (button, "clicked", + G_CALLBACK (dialog_redraw_callback), + dialog); + gtk_widget_show (button); + + /* Zoom Options */ + frame = gimp_frame_new (_("Zoom")); + gtk_box_pack_start (GTK_BOX (left_vbox), frame, FALSE, FALSE, 0); + gtk_widget_show (frame); + + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); + gtk_container_add (GTK_CONTAINER (frame), vbox); + gtk_widget_show (vbox); + + bbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); + gtk_box_set_homogeneous (GTK_BOX (bbox), TRUE); + gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0); + gtk_widget_show (bbox); + + button = gtk_button_new_with_mnemonic (_("Zoom _In")); + gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0); + gtk_widget_show (button); + + g_signal_connect (button, "clicked", + G_CALLBACK (dialog_step_in_callback), + dialog); + + button = gtk_button_new_with_mnemonic (_("Zoom _Out")); + gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0); + gtk_widget_show (button); + + g_signal_connect (button, "clicked", + G_CALLBACK (dialog_step_out_callback), + dialog); + + bbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); + gtk_box_set_homogeneous (GTK_BOX (bbox), TRUE); + gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0); + gtk_widget_show (bbox); + + button = gtk_button_new_with_mnemonic (_("_Undo")); + gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0); + gtk_widget_show (button); + + gimp_help_set_help_data (button, _("Undo last zoom change"), NULL); + + g_signal_connect (button, "clicked", + G_CALLBACK (dialog_undo_zoom_callback), + dialog); + + button = gtk_button_new_with_mnemonic (_("_Redo")); + gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0); + gtk_widget_show (button); + + gimp_help_set_help_data (button, _("Redo last zoom change"), NULL); + + g_signal_connect (button, "clicked", + G_CALLBACK (dialog_redo_zoom_callback), + dialog); + + /* Create notebook */ + notebook = gtk_notebook_new (); + gtk_box_pack_start (GTK_BOX (top_hbox), notebook, FALSE, FALSE, 0); + gtk_widget_show (notebook); + + /* "Parameters" page */ + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); + gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); + gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, + gtk_label_new_with_mnemonic (_("_Parameters"))); + gtk_widget_show (vbox); + + frame = gimp_frame_new (_("Fractal Parameters")); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + gtk_widget_show (frame); + + table = gtk_table_new (8, 3, FALSE); + gtk_table_set_col_spacings (GTK_TABLE (table), 6); + gtk_table_set_row_spacings (GTK_TABLE (table), 6); + gtk_table_set_row_spacing (GTK_TABLE (table), 6, 12); + gtk_container_add (GTK_CONTAINER (frame), table); + gtk_widget_show (table); + + elements->xmin = + gimp_scale_entry_new (GTK_TABLE (table), 0, 0, + _("Left:"), SCALE_WIDTH, 10, + wvals.xmin, -3, 3, 0.001, 0.01, 5, + TRUE, 0, 0, NULL, NULL); + g_signal_connect (elements->xmin, "value-changed", + G_CALLBACK (explorer_double_adjustment_update), + &wvals.xmin); + + elements->xmax = + gimp_scale_entry_new (GTK_TABLE (table), 0, 1, + _("Right:"), SCALE_WIDTH, 10, + wvals.xmax, -3, 3, 0.001, 0.01, 5, + TRUE, 0, 0, NULL, NULL); + g_signal_connect (elements->xmax, "value-changed", + G_CALLBACK (explorer_double_adjustment_update), + &wvals.xmax); + + elements->ymin = + gimp_scale_entry_new (GTK_TABLE (table), 0, 2, + _("Top:"), SCALE_WIDTH, 10, + wvals.ymin, -3, 3, 0.001, 0.01, 5, + TRUE, 0, 0, NULL, NULL); + g_signal_connect (elements->ymin, "value-changed", + G_CALLBACK (explorer_double_adjustment_update), + &wvals.ymin); + + elements->ymax = + gimp_scale_entry_new (GTK_TABLE (table), 0, 3, + _("Bottom:"), SCALE_WIDTH, 10, + wvals.ymax, -3, 3, 0.001, 0.01, 5, + TRUE, 0, 0, NULL, NULL); + g_signal_connect (elements->ymax, "value-changed", + G_CALLBACK (explorer_double_adjustment_update), + &wvals.ymax); + + elements->iter = + gimp_scale_entry_new (GTK_TABLE (table), 0, 4, + _("Iterations:"), SCALE_WIDTH, 10, + wvals.iter, 1, 1000, 1, 10, 0, + TRUE, 0, 0, + _("The higher the number of iterations, " + "the more details will be calculated"), NULL); + g_signal_connect (elements->iter, "value-changed", + G_CALLBACK (explorer_double_adjustment_update), + &wvals.iter); + + elements->cx = + gimp_scale_entry_new (GTK_TABLE (table), 0, 5, + _("CX:"), SCALE_WIDTH, 10, + wvals.cx, -2.5, 2.5, 0.001, 0.01, 5, + TRUE, 0, 0, + _("Changes aspect of fractal"), NULL); + g_signal_connect (elements->cx, "value-changed", + G_CALLBACK (explorer_double_adjustment_update), + &wvals.cx); + + elements->cy = + gimp_scale_entry_new (GTK_TABLE (table), 0, 6, + _("CY:"), SCALE_WIDTH, 10, + wvals.cy, -2.5, 2.5, 0.001, 0.01, 5, + TRUE, 0, 0, + _("Changes aspect of fractal"), NULL); + g_signal_connect (elements->cy, "value-changed", + G_CALLBACK (explorer_double_adjustment_update), + &wvals.cy); + + bbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); + gtk_box_set_homogeneous (GTK_BOX (bbox), TRUE); + gtk_table_attach_defaults (GTK_TABLE (table), bbox, 0, 3, 7, 8); + gtk_widget_show (bbox); + + button = gtk_button_new_with_mnemonic (_("_Open")); + gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0); + g_signal_connect (button, "clicked", + G_CALLBACK (create_load_file_chooser), + dialog); + gtk_widget_show (button); + gimp_help_set_help_data (button, _("Load a fractal from file"), NULL); + + button = gtk_button_new_with_mnemonic (_("_Reset")); + gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0); + g_signal_connect (button, "clicked", + G_CALLBACK (dialog_reset_callback), + dialog); + gtk_widget_show (button); + gimp_help_set_help_data (button, _("Reset parameters to default values"), + NULL); + + button = gtk_button_new_with_mnemonic (_("_Save")); + gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0); + g_signal_connect (button, "clicked", + G_CALLBACK (create_save_file_chooser), + dialog); + gtk_widget_show (button); + gimp_help_set_help_data (button, _("Save active fractal to file"), NULL); + + /* Fractal type toggle box */ + frame = gimp_frame_new (_("Fractal Type")); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + gtk_widget_show (frame); + + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); + gtk_container_add (GTK_CONTAINER (frame), hbox); + gtk_widget_show (hbox); + + toggle_vbox = + gimp_int_radio_group_new (FALSE, NULL, + G_CALLBACK (explorer_radio_update), + &wvals.fractaltype, wvals.fractaltype, + + _("Mandelbrot"), TYPE_MANDELBROT, + &(elements->type[TYPE_MANDELBROT]), + _("Julia"), TYPE_JULIA, + &(elements->type[TYPE_JULIA]), + _("Barnsley 1"), TYPE_BARNSLEY_1, + &(elements->type[TYPE_BARNSLEY_1]), + _("Barnsley 2"), TYPE_BARNSLEY_2, + &(elements->type[TYPE_BARNSLEY_2]), + _("Barnsley 3"), TYPE_BARNSLEY_3, + &(elements->type[TYPE_BARNSLEY_3]), + _("Spider"), TYPE_SPIDER, + &(elements->type[TYPE_SPIDER]), + _("Man'o'war"), TYPE_MAN_O_WAR, + &(elements->type[TYPE_MAN_O_WAR]), + _("Lambda"), TYPE_LAMBDA, + &(elements->type[TYPE_LAMBDA]), + _("Sierpinski"), TYPE_SIERPINSKI, + &(elements->type[TYPE_SIERPINSKI]), + + NULL); + + toggle_vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); + for (i = TYPE_BARNSLEY_2; i <= TYPE_SPIDER; i++) + { + g_object_ref (elements->type[i]); + + gtk_widget_hide (elements->type[i]); + gtk_container_remove (GTK_CONTAINER (toggle_vbox), elements->type[i]); + gtk_box_pack_start (GTK_BOX (toggle_vbox2), elements->type[i], + FALSE, FALSE, 0); + gtk_widget_show (elements->type[i]); + + g_object_unref (elements->type[i]); + } + + toggle_vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); + for (i = TYPE_MAN_O_WAR; i <= TYPE_SIERPINSKI; i++) + { + g_object_ref (elements->type[i]); + + gtk_widget_hide (elements->type[i]); + gtk_container_remove (GTK_CONTAINER (toggle_vbox), elements->type[i]); + gtk_box_pack_start (GTK_BOX (toggle_vbox3), elements->type[i], + FALSE, FALSE, 0); + gtk_widget_show (elements->type[i]); + + g_object_unref (elements->type[i]); + } + + gtk_box_pack_start (GTK_BOX (hbox), toggle_vbox, FALSE, FALSE, 0); + gtk_widget_show (toggle_vbox); + + gtk_box_pack_start (GTK_BOX (hbox), toggle_vbox2, FALSE, FALSE, 0); + gtk_widget_show (toggle_vbox2); + + gtk_box_pack_start (GTK_BOX (hbox), toggle_vbox3, FALSE, FALSE, 0); + gtk_widget_show (toggle_vbox3); + + /* Color page */ + vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); + gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); + gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, + gtk_label_new_with_mnemonic (_("Co_lors"))); + gtk_widget_show (vbox); + + /* Number of Colors frame */ + frame = gimp_frame_new (_("Number of Colors")); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + gtk_widget_show (frame); + + table = gtk_table_new (2, 3, FALSE); + gtk_table_set_col_spacings (GTK_TABLE (table), 6); + gtk_table_set_row_spacings (GTK_TABLE (table), 6); + gtk_container_add (GTK_CONTAINER (frame), table); + gtk_widget_show (table); + + elements->ncol = + gimp_scale_entry_new (GTK_TABLE (table), 0, 0, + _("Number of colors:"), SCALE_WIDTH, 0, + wvals.ncolors, 2, MAXNCOLORS, 1, 10, 0, + TRUE, 0, 0, + _("Change the number of colors in the mapping"), + NULL); + g_signal_connect (elements->ncol, "value-changed", + G_CALLBACK (explorer_number_of_colors_callback), + &wvals.ncolors); + + elements->useloglog = toggle = + gtk_check_button_new_with_label (_("Use loglog smoothing")); + gtk_table_attach_defaults (GTK_TABLE (table), toggle, 0, 3, 1, 2); + g_signal_connect (toggle, "toggled", + G_CALLBACK (explorer_toggle_update), + &wvals.useloglog); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), wvals.useloglog); + gtk_widget_show (toggle); + gimp_help_set_help_data (toggle, _("Use log log smoothing to eliminate " + "\"banding\" in the result"), NULL); + + /* Color Density frame */ + frame = gimp_frame_new (_("Color Density")); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + gtk_widget_show (frame); + + table = gtk_table_new (3, 3, FALSE); + gtk_table_set_col_spacings (GTK_TABLE (table), 6); + gtk_table_set_row_spacings (GTK_TABLE (table), 6); + gtk_container_add (GTK_CONTAINER (frame), table); + gtk_widget_show (table); + + elements->red = + gimp_scale_entry_new (GTK_TABLE (table), 0, 0, + _("Red:"), SCALE_WIDTH, 0, + wvals.redstretch, 0, 1, 0.01, 0.1, 2, + TRUE, 0, 0, + _("Change the intensity of the red channel"), NULL); + g_signal_connect (elements->red, "value-changed", + G_CALLBACK (explorer_double_adjustment_update), + &wvals.redstretch); + + elements->green = + gimp_scale_entry_new (GTK_TABLE (table), 0, 1, + _("Green:"), SCALE_WIDTH, 0, + wvals.greenstretch, 0, 1, 0.01, 0.1, 2, + TRUE, 0, 0, + _("Change the intensity of the green channel"), NULL); + g_signal_connect (elements->green, "value-changed", + G_CALLBACK (explorer_double_adjustment_update), + &wvals.greenstretch); + + elements->blue = + gimp_scale_entry_new (GTK_TABLE (table), 0, 2, + _("Blue:"), SCALE_WIDTH, 0, + wvals.bluestretch, 0, 1, 0.01, 0.1, 2, + TRUE, 0, 0, + _("Change the intensity of the blue channel"), NULL); + g_signal_connect (elements->blue, "value-changed", + G_CALLBACK (explorer_double_adjustment_update), + &wvals.bluestretch); + + /* Color Function frame */ + frame = gimp_frame_new (_("Color Function")); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + gtk_widget_show (frame); + + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); + gtk_container_add (GTK_CONTAINER (frame), hbox); + gtk_widget_show (hbox); + + /* Redmode radio frame */ + frame = gimp_int_radio_group_new (TRUE, _("Red"), + G_CALLBACK (explorer_radio_update), + &wvals.redmode, wvals.redmode, + + _("Sine"), SINUS, + &elements->redmode[SINUS], + _("Cosine"), COSINUS, + &elements->redmode[COSINUS], + C_("color-function", "None"), NONE, + &elements->redmode[NONE], + + NULL); + gimp_help_set_help_data (elements->redmode[SINUS], + _("Use sine-function for this color component"), + NULL); + gimp_help_set_help_data (elements->redmode[COSINUS], + _("Use cosine-function for this color " + "component"), NULL); + gimp_help_set_help_data (elements->redmode[NONE], + _("Use linear mapping instead of any " + "trigonometrical function for this color " + "channel"), NULL); + gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); + gtk_widget_show (frame); + + toggle_vbox = gtk_bin_get_child (GTK_BIN (frame)); + + elements->redinvert = toggle = + gtk_check_button_new_with_label (_("Inversion")); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), wvals.redinvert); + gtk_box_pack_start (GTK_BOX (toggle_vbox), toggle, FALSE, FALSE, 0); + g_signal_connect (toggle, "toggled", + G_CALLBACK (explorer_toggle_update), + &wvals.redinvert); + gtk_widget_show (toggle); + gimp_help_set_help_data (toggle, + _("If you enable this option higher color values " + "will be swapped with lower ones and vice " + "versa"), NULL); + + /* Greenmode radio frame */ + frame = gimp_int_radio_group_new (TRUE, _("Green"), + G_CALLBACK (explorer_radio_update), + &wvals.greenmode, wvals.greenmode, + + _("Sine"), SINUS, + &elements->greenmode[SINUS], + _("Cosine"), COSINUS, + &elements->greenmode[COSINUS], + C_("color-function", "None"), NONE, + &elements->greenmode[NONE], + + NULL); + gimp_help_set_help_data (elements->greenmode[SINUS], + _("Use sine-function for this color component"), + NULL); + gimp_help_set_help_data (elements->greenmode[COSINUS], + _("Use cosine-function for this color " + "component"), NULL); + gimp_help_set_help_data (elements->greenmode[NONE], + _("Use linear mapping instead of any " + "trigonometrical function for this color " + "channel"), NULL); + gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); + gtk_widget_show (frame); + + toggle_vbox = gtk_bin_get_child (GTK_BIN (frame)); + + elements->greeninvert = toggle = + gtk_check_button_new_with_label (_("Inversion")); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), wvals.greeninvert); + gtk_box_pack_start (GTK_BOX (toggle_vbox), toggle, FALSE, FALSE, 0); + g_signal_connect (toggle, "toggled", + G_CALLBACK (explorer_toggle_update), + &wvals.greeninvert); + gtk_widget_show (toggle); + gimp_help_set_help_data (toggle, + _("If you enable this option higher color values " + "will be swapped with lower ones and vice " + "versa"), NULL); + + /* Bluemode radio frame */ + frame = gimp_int_radio_group_new (TRUE, _("Blue"), + G_CALLBACK (explorer_radio_update), + &wvals.bluemode, wvals.bluemode, + + _("Sine"), SINUS, + &elements->bluemode[SINUS], + _("Cosine"), COSINUS, + &elements->bluemode[COSINUS], + C_("color-function", "None"), NONE, + &elements->bluemode[NONE], + + NULL); + gimp_help_set_help_data (elements->bluemode[SINUS], + _("Use sine-function for this color component"), + NULL); + gimp_help_set_help_data (elements->bluemode[COSINUS], + _("Use cosine-function for this color " + "component"), NULL); + gimp_help_set_help_data (elements->bluemode[NONE], + _("Use linear mapping instead of any " + "trigonometrical function for this color " + "channel"), NULL); + gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); + gtk_widget_show (frame); + + toggle_vbox = gtk_bin_get_child (GTK_BIN (frame)); + + elements->blueinvert = toggle = + gtk_check_button_new_with_label (_("Inversion")); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON( toggle), wvals.blueinvert); + gtk_box_pack_start (GTK_BOX (toggle_vbox), toggle, FALSE, FALSE, 0); + g_signal_connect (toggle, "toggled", + G_CALLBACK (explorer_toggle_update), + &wvals.blueinvert); + gtk_widget_show (toggle); + gimp_help_set_help_data (toggle, + _("If you enable this option higher color values " + "will be swapped with lower ones and vice " + "versa"), NULL); + + /* Colormode toggle box */ + frame = gimp_frame_new (_("Color Mode")); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + gtk_widget_show (frame); + + toggle_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); + gtk_container_add (GTK_CONTAINER (frame), toggle_vbox); + gtk_widget_show (toggle_vbox); + + toggle = elements->colormode[0] = + gtk_radio_button_new_with_label (group, _("As specified above")); + group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (toggle)); + gtk_box_pack_start (GTK_BOX (toggle_vbox), toggle, FALSE, FALSE, 0); + g_object_set_data (G_OBJECT (toggle), "gimp-item-data", + GINT_TO_POINTER (0)); + g_signal_connect (toggle, "toggled", + G_CALLBACK (explorer_radio_update), + &wvals.colormode); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), + wvals.colormode == 0); + gtk_widget_show (toggle); + gimp_help_set_help_data (toggle, + _("Create a color-map with the options you " + "specified above (color density/function). The " + "result is visible in the preview image"), NULL); + + hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); + gtk_box_pack_start (GTK_BOX (toggle_vbox), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + toggle = elements->colormode[1] = + gtk_radio_button_new_with_label (group, + _("Apply active gradient to final image")); + group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (toggle)); + gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 0); + g_object_set_data (G_OBJECT (toggle), "gimp-item-data", + GINT_TO_POINTER (1)); + g_signal_connect (toggle, "toggled", + G_CALLBACK (explorer_radio_update), + &wvals.colormode); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), + wvals.colormode == 1); + gtk_widget_show (toggle); + gimp_help_set_help_data (toggle, + _("Create a color-map using a gradient from " + "the gradient editor"), NULL); + + gradient_name = gimp_context_get_gradient (); + + gimp_gradient_get_uniform_samples (gradient_name, + wvals.ncolors, + wvals.gradinvert, + &n_gradient_samples, + &gradient_samples); + + gradient = gimp_gradient_select_button_new (_("FractalExplorer Gradient"), + gradient_name); + g_signal_connect (gradient, "gradient-set", + G_CALLBACK (explorer_gradient_select_callback), NULL); + g_free (gradient_name); + gtk_box_pack_start (GTK_BOX (hbox), gradient, FALSE, FALSE, 0); + gtk_widget_show (gradient); + + abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); + { + gint xsize, ysize; + + for (ysize = 1; ysize * ysize * ysize < 8192; ysize++) /**/; + xsize = wvals.ncolors / ysize; + while (xsize * ysize < 8192) xsize++; + + gtk_widget_set_size_request (abox, xsize, ysize * 4); + } + gtk_box_pack_start (GTK_BOX (toggle_vbox), abox, FALSE, FALSE, 0); + gtk_widget_show (abox); + + cmap_preview = gimp_preview_area_new (); + gtk_widget_set_size_request (cmap_preview, 32, 32); + gtk_container_add (GTK_CONTAINER (abox), cmap_preview); + g_signal_connect (cmap_preview, "size-allocate", + G_CALLBACK (cmap_preview_size_allocate), NULL); + gtk_widget_show (cmap_preview); + + frame = add_objects_list (); + gtk_notebook_append_page (GTK_NOTEBOOK (notebook), frame, + gtk_label_new_with_mnemonic (_("_Fractals"))); + gtk_widget_show (frame); + + gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), 0); + + gtk_widget_show (dialog); + ready_now = TRUE; + + set_cmap_preview (); + dialog_update_preview (); + + gtk_main (); + + g_free (wint.wimage); + + return wint.run; +} + + +/********************************************************************** + FUNCTION: dialog_update_preview + *********************************************************************/ + +void +dialog_update_preview (void) +{ + gint ycoord; + guchar *p_ul; + + if (NULL == wint.preview) + return; + + if (ready_now && wvals.alwayspreview) + { + xmin = wvals.xmin; + xmax = wvals.xmax; + ymin = wvals.ymin; + ymax = wvals.ymax; + xbild = preview_width; + ybild = preview_height; + xdiff = (xmax - xmin) / xbild; + ydiff = (ymax - ymin) / ybild; + + p_ul = wint.wimage; + + for (ycoord = 0; ycoord < preview_height; ycoord++) + { + explorer_render_row (NULL, + p_ul, + ycoord, + preview_width, + 3); + p_ul += preview_width * 3; + } + + preview_redraw (); + } +} + +/********************************************************************** + FUNCTION: cmap_preview_size_allocate() + *********************************************************************/ + +static void +cmap_preview_size_allocate (GtkWidget *widget, + GtkAllocation *allocation) +{ + gint i; + gint x; + gint y; + gint j; + guchar *b; + GimpPreviewArea *preview = GIMP_PREVIEW_AREA (widget); + + b = g_new (guchar, allocation->width * allocation->height * 3); + + for (y = 0; y < allocation->height; y++) + { + for (x = 0; x < allocation->width; x++) + { + i = x + (y / 4) * allocation->width; + if (i > wvals.ncolors) + { + for (j = 0; j < 3; j++) + b[(y*allocation->width + x) * 3 + j] = 0; + } + else + { + b[(y*allocation->width + x) * 3] = colormap[i].r; + b[(y*allocation->width + x) * 3 + 1] = colormap[i].g; + b[(y*allocation->width + x) * 3 + 2] = colormap[i].b; + } + } + } + gimp_preview_area_draw (preview, + 0, 0, allocation->width, allocation->height, + GIMP_RGB_IMAGE, b, allocation->width*3); + gtk_widget_queue_draw (cmap_preview); + + g_free (b); + +} + +/********************************************************************** + FUNCTION: set_cmap_preview() + *********************************************************************/ + +void +set_cmap_preview (void) +{ + gint xsize, ysize; + + if (NULL == cmap_preview) + return; + + make_color_map (); + + for (ysize = 1; ysize * ysize * ysize < wvals.ncolors; ysize++) + /**/; + xsize = wvals.ncolors / ysize; + while (xsize * ysize < wvals.ncolors) + xsize++; + + gtk_widget_set_size_request (cmap_preview, xsize, ysize * 4); +} + +/********************************************************************** + FUNCTION: make_color_map() + *********************************************************************/ + +void +make_color_map (void) +{ + gint i; + gint r; + gint gr; + gint bl; + gdouble redstretch; + gdouble greenstretch; + gdouble bluestretch; + gdouble pi = atan (1) * 4; + + /* get gradient samples if they don't exist -- fixes gradient color + * mode for noninteractive use (bug #103470). + */ + if (gradient_samples == NULL) + { + gchar *gradient_name = gimp_context_get_gradient (); + + gimp_gradient_get_uniform_samples (gradient_name, + wvals.ncolors, + wvals.gradinvert, + &n_gradient_samples, + &gradient_samples); + + g_free (gradient_name); + } + + redstretch = wvals.redstretch * 127.5; + greenstretch = wvals.greenstretch * 127.5; + bluestretch = wvals.bluestretch * 127.5; + + for (i = 0; i < wvals.ncolors; i++) + if (wvals.colormode == 1) + { + colormap[i].r = (guchar)(gradient_samples[i * 4] * 255.9); + colormap[i].g = (guchar)(gradient_samples[i * 4 + 1] * 255.9); + colormap[i].b = (guchar)(gradient_samples[i * 4 + 2] * 255.9); + } + else + { + double x = (i*2.0) / wvals.ncolors; + r = gr = bl = 0; + + switch (wvals.redmode) + { + case SINUS: + r = (int) redstretch *(1.0 + sin((x - 1) * pi)); + break; + case COSINUS: + r = (int) redstretch *(1.0 + cos((x - 1) * pi)); + break; + case NONE: + r = (int)(redstretch *(x)); + break; + default: + break; + } + + switch (wvals.greenmode) + { + case SINUS: + gr = (int) greenstretch *(1.0 + sin((x - 1) * pi)); + break; + case COSINUS: + gr = (int) greenstretch *(1.0 + cos((x - 1) * pi)); + break; + case NONE: + gr = (int)(greenstretch *(x)); + break; + default: + break; + } + + switch (wvals.bluemode) + { + case SINUS: + bl = (int) bluestretch * (1.0 + sin ((x - 1) * pi)); + break; + case COSINUS: + bl = (int) bluestretch * (1.0 + cos ((x - 1) * pi)); + break; + case NONE: + bl = (int) (bluestretch * x); + break; + default: + break; + } + + r = MIN (r, 255); + gr = MIN (gr, 255); + bl = MIN (bl, 255); + + if (wvals.redinvert) + r = 255 - r; + + if (wvals.greeninvert) + gr = 255 - gr; + + if (wvals.blueinvert) + bl = 255 - bl; + + colormap[i].r = r; + colormap[i].g = gr; + colormap[i].b = bl; + } +} + +/********************************************************************** + FUNCTION: dialog_change_scale + *********************************************************************/ + +void +dialog_change_scale (void) +{ + ready_now = FALSE; + + gtk_adjustment_set_value (GTK_ADJUSTMENT (elements->xmin), wvals.xmin); + gtk_adjustment_set_value (GTK_ADJUSTMENT (elements->xmax), wvals.xmax); + gtk_adjustment_set_value (GTK_ADJUSTMENT (elements->ymin), wvals.ymin); + gtk_adjustment_set_value (GTK_ADJUSTMENT (elements->ymax), wvals.ymax); + gtk_adjustment_set_value (GTK_ADJUSTMENT (elements->iter), wvals.iter); + gtk_adjustment_set_value (GTK_ADJUSTMENT (elements->cx), wvals.cx); + gtk_adjustment_set_value (GTK_ADJUSTMENT (elements->cy), wvals.cy); + + gtk_adjustment_set_value (GTK_ADJUSTMENT (elements->red), wvals.redstretch); + gtk_adjustment_set_value (GTK_ADJUSTMENT (elements->green),wvals.greenstretch); + gtk_adjustment_set_value (GTK_ADJUSTMENT (elements->blue), wvals.bluestretch); + + gtk_toggle_button_set_active + (GTK_TOGGLE_BUTTON (elements->type[wvals.fractaltype]), TRUE); + + gtk_toggle_button_set_active + (GTK_TOGGLE_BUTTON (elements->redmode[wvals.redmode]), TRUE); + gtk_toggle_button_set_active + (GTK_TOGGLE_BUTTON (elements->greenmode[wvals.greenmode]), TRUE); + gtk_toggle_button_set_active + (GTK_TOGGLE_BUTTON (elements->bluemode[wvals.bluemode]), TRUE); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (elements->redinvert), + wvals.redinvert); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (elements->greeninvert), + wvals.greeninvert); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (elements->blueinvert), + wvals.blueinvert); + + gtk_toggle_button_set_active + (GTK_TOGGLE_BUTTON (elements->colormode[wvals.colormode]), TRUE); + + ready_now = TRUE; +} + + +/********************************************************************** + FUNCTION: save_options + *********************************************************************/ + +static void +save_options (FILE * fp) +{ + gchar buf[64]; + + /* Save options */ + + fprintf (fp, "fractaltype: %i\n", wvals.fractaltype); + + g_ascii_dtostr (buf, sizeof (buf), wvals.xmin); + fprintf (fp, "xmin: %s\n", buf); + + g_ascii_dtostr (buf, sizeof (buf), wvals.xmax); + fprintf (fp, "xmax: %s\n", buf); + + g_ascii_dtostr (buf, sizeof (buf), wvals.ymin); + fprintf (fp, "ymin: %s\n", buf); + + g_ascii_dtostr (buf, sizeof (buf), wvals.ymax); + fprintf (fp, "ymax: %s\n", buf); + + g_ascii_dtostr (buf, sizeof (buf), wvals.iter); + fprintf (fp, "iter: %s\n", buf); + + g_ascii_dtostr (buf, sizeof (buf), wvals.cx); + fprintf (fp, "cx: %s\n", buf); + + g_ascii_dtostr (buf, sizeof (buf), wvals.cy); + fprintf (fp, "cy: %s\n", buf); + + g_ascii_dtostr (buf, sizeof (buf), wvals.redstretch * 128.0); + fprintf (fp, "redstretch: %s\n", buf); + + g_ascii_dtostr (buf, sizeof (buf), wvals.greenstretch * 128.0); + fprintf (fp, "greenstretch: %s\n", buf); + + g_ascii_dtostr (buf, sizeof (buf), wvals.bluestretch * 128.0); + fprintf (fp, "bluestretch: %s\n", buf); + + fprintf (fp, "redmode: %i\n", wvals.redmode); + fprintf (fp, "greenmode: %i\n", wvals.greenmode); + fprintf (fp, "bluemode: %i\n", wvals.bluemode); + fprintf (fp, "redinvert: %i\n", wvals.redinvert); + fprintf (fp, "greeninvert: %i\n", wvals.greeninvert); + fprintf (fp, "blueinvert: %i\n", wvals.blueinvert); + fprintf (fp, "colormode: %i\n", wvals.colormode); + fputs ("#**********************************************************************\n", fp); + fprintf(fp, "<EOF>\n"); + fputs ("#**********************************************************************\n", fp); +} + +static void +save_callback (void) +{ + FILE *fp; + const gchar *savename = filename; + + fp = g_fopen (savename, "wt+"); + + if (!fp) + { + g_message (_("Could not open '%s' for writing: %s"), + gimp_filename_to_utf8 (savename), g_strerror (errno)); + return; + } + + /* Write header out */ + fputs (FRACTAL_HEADER, fp); + fputs ("#**********************************************************************\n", fp); + fputs ("# This is a data file for the Fractal Explorer plug-in for GIMP *\n", fp); + fputs ("#**********************************************************************\n", fp); + + save_options (fp); + + if (ferror (fp)) + g_message (_("Could not write '%s': %s"), + gimp_filename_to_utf8 (savename), g_strerror (ferror (fp))); + + fclose (fp); +} + +static void +save_file_chooser_response (GtkFileChooser *chooser, + gint response_id, + gpointer data) +{ + if (response_id == GTK_RESPONSE_OK) + { + filename = gtk_file_chooser_get_filename (chooser); + + save_callback (); + } + + gtk_widget_destroy (GTK_WIDGET (chooser)); +} + +static void +file_chooser_set_default_folder (GtkFileChooser *chooser) +{ + GList *path_list; + gchar *dir; + + if (! fractalexplorer_path) + return; + + path_list = gimp_path_parse (fractalexplorer_path, 256, FALSE, NULL); + + dir = gimp_path_get_user_writable_dir (path_list); + + if (! dir) + dir = g_strdup (gimp_directory ()); + + gtk_file_chooser_set_current_folder (chooser, dir); + + g_free (dir); + gimp_path_free (path_list); +} + +static void +load_file_chooser_response (GtkFileChooser *chooser, + gint response_id, + gpointer data) +{ + if (response_id == GTK_RESPONSE_OK) + { + filename = gtk_file_chooser_get_filename (chooser); + + if (g_file_test (filename, G_FILE_TEST_IS_REGULAR)) + { + explorer_load (); + } + + gtk_widget_show (maindlg); + dialog_change_scale (); + set_cmap_preview (); + dialog_update_preview (); + } + + gtk_widget_destroy (GTK_WIDGET (chooser)); +} + +static void +create_load_file_chooser (GtkWidget *widget, + GtkWidget *dialog) +{ + static GtkWidget *window = NULL; + + if (!window) + { + window = + gtk_file_chooser_dialog_new (_("Load Fractal Parameters"), + GTK_WINDOW (dialog), + GTK_FILE_CHOOSER_ACTION_OPEN, + + _("_Cancel"), GTK_RESPONSE_CANCEL, + _("_Open"), GTK_RESPONSE_OK, + + NULL); + + gtk_dialog_set_default_response (GTK_DIALOG (window), GTK_RESPONSE_OK); + + gtk_dialog_set_alternative_button_order (GTK_DIALOG (window), + GTK_RESPONSE_OK, + GTK_RESPONSE_CANCEL, + -1); + + file_chooser_set_default_folder (GTK_FILE_CHOOSER (window)); + + g_signal_connect (window, "destroy", + G_CALLBACK (gtk_widget_destroyed), + &window); + g_signal_connect (window, "response", + G_CALLBACK (load_file_chooser_response), + window); + } + + gtk_window_present (GTK_WINDOW (window)); +} + +static void +create_save_file_chooser (GtkWidget *widget, + GtkWidget *dialog) +{ + static GtkWidget *window = NULL; + + if (! window) + { + window = + gtk_file_chooser_dialog_new (_("Save Fractal Parameters"), + GTK_WINDOW (dialog), + GTK_FILE_CHOOSER_ACTION_SAVE, + + _("_Cancel"), GTK_RESPONSE_CANCEL, + _("_Save"), GTK_RESPONSE_OK, + + NULL); + + gtk_dialog_set_alternative_button_order (GTK_DIALOG (window), + GTK_RESPONSE_OK, + GTK_RESPONSE_CANCEL, + -1); + gtk_dialog_set_default_response (GTK_DIALOG (window), GTK_RESPONSE_OK); + + gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (window), + TRUE); + g_signal_connect (window, "destroy", + G_CALLBACK (gtk_widget_destroyed), + &window); + g_signal_connect (window, "response", + G_CALLBACK (save_file_chooser_response), + window); + } + + if (tpath) + { + gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (window), tpath); + } + else + { + file_chooser_set_default_folder (GTK_FILE_CHOOSER (window)); + } + + gtk_window_present (GTK_WINDOW (window)); +} + +gchar* +get_line (gchar *buf, + gint s, + FILE *from, + gint init) +{ + gint slen; + gchar *ret; + + if (init) + line_no = 1; + else + line_no++; + + do + { + ret = fgets (buf, s, from); + } + while (!ferror (from) && buf[0] == '#'); + + slen = strlen (buf); + + /* The last newline is a pain */ + if (slen > 0) + buf[slen - 1] = '\0'; + + if (ferror (from)) + { + g_warning ("Error reading file"); + return NULL; + } + + return ret; +} + +gint +load_options (fractalexplorerOBJ *xxx, + FILE *fp) +{ + gchar load_buf[MAX_LOAD_LINE]; + gchar str_buf[MAX_LOAD_LINE]; + gchar opt_buf[MAX_LOAD_LINE]; + + /* default values */ + xxx->opts = standardvals; + xxx->opts.gradinvert = FALSE; + + get_line (load_buf, MAX_LOAD_LINE, fp, 0); + + while (!feof (fp) && strcmp (load_buf, "<EOF>")) + { + /* Get option name */ + sscanf (load_buf, "%255s %255s", str_buf, opt_buf); + + if (!strcmp (str_buf, "fractaltype:")) + { + gint sp = 0; + + sp = atoi (opt_buf); + if (sp < 0) + return -1; + xxx->opts.fractaltype = sp; + } + else if (!strcmp (str_buf, "xmin:")) + { + xxx->opts.xmin = g_ascii_strtod (opt_buf, NULL); + } + else if (!strcmp (str_buf, "xmax:")) + { + xxx->opts.xmax = g_ascii_strtod (opt_buf, NULL); + } + else if (!strcmp(str_buf, "ymin:")) + { + xxx->opts.ymin = g_ascii_strtod (opt_buf, NULL); + } + else if (!strcmp (str_buf, "ymax:")) + { + xxx->opts.ymax = g_ascii_strtod (opt_buf, NULL); + } + else if (!strcmp(str_buf, "redstretch:")) + { + gdouble sp = g_ascii_strtod (opt_buf, NULL); + xxx->opts.redstretch = sp / 128.0; + } + else if (!strcmp(str_buf, "greenstretch:")) + { + gdouble sp = g_ascii_strtod (opt_buf, NULL); + xxx->opts.greenstretch = sp / 128.0; + } + else if (!strcmp (str_buf, "bluestretch:")) + { + gdouble sp = g_ascii_strtod (opt_buf, NULL); + xxx->opts.bluestretch = sp / 128.0; + } + else if (!strcmp (str_buf, "iter:")) + { + xxx->opts.iter = g_ascii_strtod (opt_buf, NULL); + } + else if (!strcmp(str_buf, "cx:")) + { + xxx->opts.cx = g_ascii_strtod (opt_buf, NULL); + } + else if (!strcmp (str_buf, "cy:")) + { + xxx->opts.cy = g_ascii_strtod (opt_buf, NULL); + } + else if (!strcmp(str_buf, "redmode:")) + { + xxx->opts.redmode = atoi (opt_buf); + } + else if (!strcmp(str_buf, "greenmode:")) + { + xxx->opts.greenmode = atoi (opt_buf); + } + else if (!strcmp(str_buf, "bluemode:")) + { + xxx->opts.bluemode = atoi (opt_buf); + } + else if (!strcmp (str_buf, "redinvert:")) + { + xxx->opts.redinvert = atoi (opt_buf); + } + else if (!strcmp (str_buf, "greeninvert:")) + { + xxx->opts.greeninvert = atoi (opt_buf); + } + else if (!strcmp(str_buf, "blueinvert:")) + { + xxx->opts.blueinvert = atoi (opt_buf); + } + else if (!strcmp (str_buf, "colormode:")) + { + xxx->opts.colormode = atoi (opt_buf); + } + + get_line (load_buf, MAX_LOAD_LINE, fp, 0); + } + + return 0; +} + +void +explorer_load (void) +{ + FILE *fp; + gchar load_buf[MAX_LOAD_LINE]; + + g_assert (filename != NULL); + + fp = g_fopen (filename, "rt"); + + if (!fp) + { + g_message (_("Could not open '%s' for reading: %s"), + gimp_filename_to_utf8 (filename), g_strerror (errno)); + return; + } + get_line (load_buf, MAX_LOAD_LINE, fp, 1); + + if (strncmp (FRACTAL_HEADER, load_buf, strlen (load_buf))) + { + g_message (_("'%s' is not a FractalExplorer file"), + gimp_filename_to_utf8 (filename)); + fclose (fp); + return; + } + if (load_options (current_obj,fp)) + { + g_message (_("'%s' is corrupt. Line %d Option section incorrect"), + gimp_filename_to_utf8 (filename), line_no); + fclose (fp); + return; + } + + wvals = current_obj->opts; + + fclose (fp); +} |