home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / unofficial-plug-ins / mathmap / mathmap.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-10-06  |  53.0 KB  |  2,086 lines
  1. /* The GIMP -- an image manipulation program
  2.  * Copyright (C) 1995 Spencer Kimball and Peter Mattis
  3.  *
  4.  * MathMap plug-in --- generate an image by means of a mathematical expression
  5.  * Copyright (C) 1997-2000 Mark Probst
  6.  * schani@unix.cslab.tuwien.ac.at
  7.  *
  8.  * Plug-In structure based on:
  9.  *   Whirl plug-in --- distort an image into a whirlpool
  10.  *   Copyright (C) 1997 Federico Mena Quintero
  11.  *   federico@nuclecu.unam.mx
  12.  *
  13.  * Version 0.11
  14.  *
  15.  * This program is free software; you can redistribute it and/or modify
  16.  * it under the terms of the GNU General Public License as published by
  17.  * the Free Software Foundation; either version 2 of the License, or
  18.  * (at your option) any later version.
  19.  *
  20.  * This program is distributed in the hope that it will be useful,
  21.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23.  * GNU General Public License for more details.
  24.  *
  25.  * You should have received a copy of the GNU General Public License
  26.  * along with this program; if not, write to the Free Software
  27.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  28.  */
  29.  
  30. #define MATHMAP_VERSION       "0.11"
  31.  
  32. #define MATHMAP_MANUAL_URL    "http://www.complang.tuwien.ac.at/~schani/mathmap/manual.html"
  33.  
  34. #include <stdlib.h>
  35. #include <stdio.h>
  36. #include <assert.h>
  37. #include <string.h>
  38. #include <unistd.h>
  39. #include <ctype.h>
  40.  
  41. #include <gtk/gtk.h>
  42. #include <libgimp/gimp.h>
  43.  
  44. #include "lispreader.h"
  45. #include "exprtree.h"
  46. #include "builtins.h"
  47. #include "postfix.h"
  48. #include "tags.h"
  49. #include "scanner.h"
  50. #include "vars.h"
  51. #include "userval.h"
  52. #include "internals.h"
  53. #include "macros.h"
  54. #include "jump.h"
  55. #include "mathmap.h"
  56. #include "colorwell.h"
  57. #include "noise.h"
  58. #ifdef USE_CGEN
  59. #include "cgen.h"
  60. #endif
  61.  
  62. #ifdef USE_CGEN
  63. #define EVAL_EXPR     eval_c_code
  64. #else
  65. #define EVAL_EXPR     eval_postfix
  66. #endif
  67.  
  68. /***** Macros *****/
  69.  
  70. #define MIN(a, b) (((a) < (b)) ? (a) : (b))
  71. #define MAX(a, b) (((a) > (b)) ? (a) : (b))
  72.  
  73.  
  74. /***** Magic numbers *****/
  75.  
  76. #define PREVIEW_SIZE 128
  77. #define SCALE_WIDTH  200
  78. #define ENTRY_WIDTH  60
  79.  
  80. /* Even more stuff from Quartics plugins */
  81. #define CHECK_SIZE  8
  82. #define CHECK_DARK  ((int) (1.0 / 3.0 * 255))
  83. #define CHECK_LIGHT ((int) (2.0 / 3.0 * 255))   
  84.  
  85.  
  86. #define DEFAULT_EXPRESSION      "origValXY(x+sin(y*10)*3,y+sin(x*10)*3)"
  87. #define DEFAULT_NUMBER_FRAMES   10
  88.  
  89. #define FLAG_INTERSAMPLING      1
  90. #define FLAG_OVERSAMPLING       2
  91. #define FLAG_ANIMATION          4
  92.  
  93. #define MAX_EXPRESSION_LENGTH   8192
  94.  
  95. #define NUM_GRADIENT_SAMPLES    1024
  96.  
  97. /***** Types *****/
  98.  
  99. typedef struct {
  100.     gint flags;
  101.     gint frames;
  102.     gfloat param_t;
  103.     gchar expression[MAX_EXPRESSION_LENGTH];
  104. } mathmap_vals_t;
  105.  
  106. typedef struct {
  107.     GtkWidget *preview;
  108.     guchar *wimage;
  109.     gint run;
  110. } mathmap_interface_t;
  111.  
  112. typedef struct {
  113.     GDrawable *drawable;
  114.     gint bpp;
  115.     gint row;
  116.     gint col;
  117.     GTile *tile;
  118.     guchar *fast_image_source;
  119.     int used;
  120. } input_drawable_t;
  121.  
  122. /***** Prototypes *****/
  123.  
  124. static void query(void);
  125. static void run(char    *name,
  126.         int      nparams,
  127.         GParam  *param,
  128.         int     *nreturn_vals,
  129.         GParam **return_vals);
  130.  
  131. static void init_internals (void);
  132.  
  133. static void expression_copy (gchar *dest, gchar *src);
  134.  
  135. static void mathmap (int frame_num);
  136. static gint32 mathmap_layer_copy(gint32 layerID);
  137.  
  138. extern int mmparse (void);
  139.  
  140. static void build_fast_image_source (input_drawable_t *drawable);
  141.  
  142. static void update_userval_table (void);
  143.  
  144. static void update_gradient (void);
  145. static gint mathmap_dialog (int);
  146. static void dialog_scale_update (GtkAdjustment *adjustment, gint *value);
  147. static void dialog_t_update (GtkAdjustment *adjustment, gfloat *value);
  148. static void dialog_text_changed (void);
  149. static void dialog_text_update (void);
  150. static void dialog_intersampling_update (GtkWidget *widget, gpointer data);
  151. static void dialog_oversampling_update (GtkWidget *widget, gpointer data);
  152. static void dialog_auto_preview_update (GtkWidget *widget, gpointer data);
  153. static void dialog_fast_preview_update (GtkWidget *widget, gpointer data);
  154. static void dialog_edge_behaviour_update (GtkWidget *widget, gpointer data);
  155. static void dialog_edge_color_changed (ColorWell *color_well, gpointer data);
  156. static void dialog_edge_color_set (void);
  157. static void dialog_animation_update (GtkWidget *widget, gpointer data);
  158. static void dialog_preview_callback (GtkWidget *widget, gpointer data);
  159. static void dialog_close_callback (GtkWidget *widget, gpointer data);
  160. static void dialog_ok_callback (GtkWidget *widget, gpointer data);
  161. static void dialog_cancel_callback (GtkWidget *widget, gpointer data);
  162. static void dialog_help_callback (GtkWidget *widget, gpointer data);
  163. static void dialog_about_callback (GtkWidget *widget, gpointer data);
  164. static void dialog_tree_changed (GtkTree *tree);
  165.  
  166. /***** Variables *****/
  167.  
  168. GPlugInInfo PLUG_IN_INFO = {
  169.     NULL,   /* init_proc */
  170.     NULL,   /* quit_proc */
  171.     query,  /* query_proc */
  172.     run     /* run_proc */
  173. }; /* PLUG_IN_INFO */
  174.  
  175.  
  176. static mathmap_vals_t mmvals = {
  177.     FLAG_INTERSAMPLING,      /* flags */
  178.     DEFAULT_NUMBER_FRAMES,   /* frames */
  179.     0.0,                     /* t */
  180.     DEFAULT_EXPRESSION       /* expression */
  181. }; /* mmvals */
  182.  
  183. static mathmap_interface_t wint = {
  184.     NULL,  /* preview */
  185.     NULL,  /* wimage */
  186.     FALSE  /* run */
  187. }; /* wint */
  188.  
  189. #define MAX_INPUT_DRAWABLES 64
  190.  
  191. static GRunModeType run_mode;
  192. static gint32 image_id;
  193. static gint32 layer_id;
  194. static input_drawable_t input_drawables[MAX_INPUT_DRAWABLES];
  195. static GDrawable *output_drawable;
  196.  
  197. static gint   tile_width, tile_height;
  198. gint   sel_x1, sel_y1, sel_x2, sel_y2;
  199. gint   sel_width, sel_height;
  200. gint   preview_width, preview_height;
  201.  
  202. static int imageWidth, imageHeight;
  203.  
  204. static double cen_x, cen_y;
  205. static double scale_x, scale_y;
  206. static double radius, radius2;
  207.  
  208. char error_string[1024];
  209.  
  210. GtkWidget *expression_entry = 0,
  211.     *frame_table,
  212.     *t_table,
  213.     *edge_color_well,
  214.     *uservalues_scrolled_window,
  215.     *uservalues_table;
  216. GtkColorSelectionDialog *color_selection_dialog;
  217.  
  218. exprtree *theExprtree = 0;
  219. int img_width, img_height,
  220.     originX,
  221.     originY,
  222.     outputBPP,
  223.     previewing = 0,
  224.     auto_preview = 1,
  225.     fast_preview = 1;
  226. int usesRA = 0,
  227.     expression_changed = 1;
  228. double currentX,
  229.     currentY,
  230.     currentR,
  231.     currentA,
  232.     currentT,
  233.     imageR,
  234.     imageX,
  235.     imageY,
  236.     imageW,
  237.     imageH,
  238.     middleX,
  239.     middleY;
  240. int intersamplingEnabled,
  241.     oversamplingEnabled,
  242.     animationEnabled = 1;
  243. int edge_behaviour_color = 1,
  244.     edge_behaviour_wrap = 2,
  245.     edge_behaviour_reflect = 3;
  246. int edge_behaviour_mode = 1;
  247. unsigned char edge_color[4] = { 0, 0, 0, 0 };
  248. int num_gradient_samples = NUM_GRADIENT_SAMPLES;
  249. tuple_t gradient_samples[NUM_GRADIENT_SAMPLES];
  250.  
  251. /***** Functions *****/
  252.  
  253. /*****/
  254.  
  255. static void
  256. expression_copy (gchar *dest, gchar *src)
  257. {
  258.     strncpy(dest, src, MAX_EXPRESSION_LENGTH);
  259.     dest[MAX_EXPRESSION_LENGTH - 1] = 0;
  260. }
  261.  
  262.  
  263. /*****/
  264.  
  265. MAIN()
  266.  
  267.  
  268. /*****/
  269.  
  270. static lisp_object_t*
  271. read_rc_file (void)
  272. {
  273.     static lisp_object_t *obj = 0;
  274.  
  275.     gchar *filename;
  276.     FILE *file;
  277.     lisp_stream_t stream;
  278.  
  279.     if (obj != 0)
  280.     return obj;
  281.  
  282.     filename = gimp_personal_rc_file("mathmaprc");
  283.     file = fopen(filename, "r");
  284.     g_free(filename);
  285.     if (file == 0)
  286.     {
  287.     filename = g_strconcat(gimp_data_directory(), G_DIR_SEPARATOR_S, "mathmaprc", NULL);
  288.     file = fopen(filename, "r");
  289.     g_free(filename);
  290.  
  291.     if (file == 0)
  292.         return 0;
  293.     }
  294.  
  295.     obj = lisp_read(lisp_stream_init_file(&stream, file));
  296.     fclose(file);
  297.  
  298.     return obj;
  299. }
  300.  
  301. static void
  302. register_lisp_obj (lisp_object_t *obj, char *symbol_prefix, char *menu_prefix)
  303. {
  304.     int symbol_prefix_len = strlen(symbol_prefix);
  305.     int menu_prefix_len = strlen(menu_prefix);
  306.  
  307.     for (; lisp_type(obj) != LISP_TYPE_NIL; obj = lisp_cdr(obj))
  308.     {
  309.     lisp_object_t *vars[2];
  310.     int is_group = 0;
  311.     lisp_object_t *name_obj, *data;
  312.     char *symbol, *menu;
  313.     int i;
  314.     int name_len;
  315.  
  316.     assert(lisp_type(obj) == LISP_TYPE_CONS);
  317.  
  318.     if (lisp_match_string("(group #?(string) . #?(list))", lisp_car(obj), vars))
  319.         is_group = 1;
  320.     else if (lisp_match_string("(expression #?(string) #?(string))", lisp_car(obj), vars))
  321.         is_group = 0;
  322.     else
  323.         assert(0);
  324.  
  325.     name_obj = vars[0];
  326.     data = vars[1];
  327.  
  328.     name_len = strlen(lisp_string(name_obj));
  329.  
  330.     symbol = g_malloc(symbol_prefix_len + name_len + 2);
  331.     strcpy(symbol, symbol_prefix);
  332.     strcat(symbol, "_");
  333.     strcat(symbol, lisp_string(name_obj));
  334.  
  335.     menu = g_malloc(menu_prefix_len + name_len + 2);
  336.     strcpy(menu, menu_prefix);
  337.     strcat(menu, "/");
  338.     strcat(menu, lisp_string(name_obj));
  339.  
  340.     for (i = symbol_prefix_len + 1; i < symbol_prefix_len + 1 + name_len; ++i)
  341.         if (symbol[i] == ' ')
  342.         symbol[i] = '_';
  343.         else
  344.         symbol[i] = tolower(symbol[i]);
  345.  
  346.     if (is_group)
  347.         register_lisp_obj(data, symbol, menu);
  348.     else
  349.     {
  350.         static GParamDef args[] = {
  351.         { PARAM_INT32,      "run_mode",         "Interactive, non-interactive" },
  352.         { PARAM_IMAGE,      "image",            "Input image" },
  353.         { PARAM_DRAWABLE,   "drawable",         "Input drawable" },
  354.         { PARAM_INT32,      "flags",            "1: Intersampling 2: Oversampling 4: Animate" },
  355.         { PARAM_INT32,      "frames",           "Number of frames" },
  356.         { PARAM_FLOAT,      "param_t",          "The parameter t (if not animating)" }
  357.         };
  358.         static GParamDef *return_vals  = NULL;
  359.         static int nargs = sizeof(args) / sizeof(args[0]);
  360.         static int nreturn_vals = 0;
  361.  
  362.         fprintf(stderr, "registering %s (%s)\n", symbol, menu);
  363.  
  364.         gimp_install_procedure(symbol,
  365.                    "Generate an image using a mathematical expression.",
  366.                    "Generates an image by means of a mathematical expression. The expression "
  367.                    "can also refer to the data of an original image. Thus, arbitrary "
  368.                    "distortions can be constructed. Even animations can be generated.",
  369.                    "Mark Probst",
  370.                    "Mark Probst",
  371.                    "April 2000, " MATHMAP_VERSION,
  372.                    menu,
  373.                    "RGB*, GRAY*",
  374.                    PROC_PLUG_IN,
  375.                    nargs,
  376.                    nreturn_vals,
  377.                    args,
  378.                    return_vals);
  379.     }
  380.  
  381.     g_free(menu);
  382.     g_free(symbol);
  383.     }
  384. }
  385.  
  386. static void
  387. register_examples (void)
  388. {
  389.     lisp_object_t *obj = read_rc_file();
  390.  
  391.     if (obj == 0)
  392.     return;
  393.  
  394.     register_lisp_obj(obj, "mathmap", "<Image>/Filters/Generic/MathMap");
  395.     lisp_free(obj);
  396. }
  397.  
  398. static char*
  399. expression_for_symbol (char *symbol, lisp_object_t *obj)
  400. {
  401.     for (; lisp_type(obj) != LISP_TYPE_NIL; obj = lisp_cdr(obj))
  402.     {
  403.     lisp_object_t *vars[2];
  404.     int is_group = 0;
  405.     char *name;
  406.     int i;
  407.     int name_len;
  408.  
  409.     assert(lisp_type(obj) == LISP_TYPE_CONS);
  410.  
  411.     if (lisp_match_string("(group #?(string) . #?(list))", lisp_car(obj), vars))
  412.         is_group = 1;
  413.     else if (lisp_match_string("(expression #?(string) #?(string))", lisp_car(obj), vars))
  414.         is_group = 0;
  415.     else
  416.         assert(0);
  417.  
  418.     name = lisp_string(vars[0]);
  419.     name_len = strlen(name);
  420.  
  421.     if (name_len > strlen(symbol))
  422.         continue;
  423.     if ((!is_group && name_len != strlen(symbol))
  424.         || (is_group && name_len == strlen(symbol)))
  425.         continue;
  426.     if (is_group && symbol[name_len] != '_')
  427.         continue;
  428.  
  429.     for (i = 0; i < name_len; ++i)
  430.         if ((name[i] == ' ' && symbol[i] != '_')
  431.         || (name[i] != ' ' && symbol[i] != tolower(name[i])))
  432.         break;
  433.  
  434.     if (i == name_len)
  435.     {
  436.         if (is_group)
  437.         {
  438.         char *exp = expression_for_symbol(symbol + name_len + 1, vars[1]);
  439.  
  440.         if (exp != 0)
  441.             return exp;
  442.         }
  443.         else
  444.         return lisp_string(vars[1]);
  445.     }
  446.     }
  447.  
  448.     return 0;
  449. }
  450.  
  451. static void
  452. query(void)
  453. {
  454.     static GParamDef args[] = {
  455.     { PARAM_INT32,      "run_mode",         "Interactive, non-interactive" },
  456.     { PARAM_IMAGE,      "image",            "Input image" },
  457.     { PARAM_DRAWABLE,   "drawable",         "Input drawable" },
  458.     { PARAM_INT32,      "flags",            "1: Intersampling 2: Oversampling 4: Animate" },
  459.     { PARAM_INT32,      "frames",           "Number of frames" },
  460.     { PARAM_FLOAT,      "param_t",          "The parameter t (if not animating)" },
  461.     { PARAM_STRING,     "expression",       "MathMap expression" }
  462.     };
  463.     static GParamDef *return_vals  = NULL;
  464.     static int nargs = sizeof(args) / sizeof(args[0]);
  465.     static int nreturn_vals = 0;
  466.  
  467.     gimp_install_procedure("plug_in_mathmap",
  468.                "Generate an image using a mathematical expression.",
  469.                "Generates an image by means of a mathematical expression. The expression "
  470.                "can also refer to the data of an original image. Thus, arbitrary "
  471.                "distortions can be constructed. Even animations can be generated.",
  472.                "Mark Probst",
  473.                "Mark Probst",
  474.                "April 2000, " MATHMAP_VERSION,
  475.                "<Image>/Filters/Generic/MathMap/MathMap",
  476.                "RGB*, GRAY*",
  477.                PROC_PLUG_IN,
  478.                nargs,
  479.                nreturn_vals,
  480.                args,
  481.                return_vals);
  482.  
  483.     register_examples();
  484. }
  485.  
  486. /*****/
  487.  
  488. static void
  489. run (char *name, int nparams, GParam *param, int *nreturn_vals, GParam **return_vals)
  490. {
  491.     static GParam values[1];
  492.  
  493.     GStatusType status;
  494.     double xhsiz, yhsiz;
  495.     int pwidth, pheight;
  496.  
  497.     int mutable_expression = 1;
  498.  
  499.     fprintf(stderr, "started as %s\n", name);
  500.     if (strncmp(name, "mathmap_", 8) == 0)
  501.     {
  502.     char *exp = expression_for_symbol(name + 8, read_rc_file());
  503.  
  504.     fprintf(stderr, "found %s\n", exp);
  505.  
  506.     if (exp != 0)
  507.     {
  508.         strcpy(mmvals.expression, exp);
  509.         mutable_expression = 0;
  510.     }
  511.     }
  512.  
  513.     status   = STATUS_SUCCESS;
  514.     run_mode = param[0].data.d_int32;
  515.  
  516.     image_id = param[1].data.d_int32;
  517.     layer_id = gimp_image_get_active_layer(image_id);
  518.  
  519.     values[0].type = PARAM_STATUS;
  520.     values[0].data.d_status = status;
  521.  
  522.     *nreturn_vals = 1;
  523.     *return_vals = values;
  524.  
  525.     /* Get the active drawable info */
  526.  
  527.     input_drawables[0].drawable = gimp_drawable_get(param[2].data.d_drawable);
  528.     input_drawables[0].bpp = gimp_drawable_bpp(input_drawables[0].drawable->id);
  529.     input_drawables[0].row = input_drawables[0].col = -1;
  530.     input_drawables[0].tile = 0;
  531.     input_drawables[0].fast_image_source = 0;
  532.     input_drawables[0].used = 1;
  533.  
  534.     outputBPP = input_drawables[0].bpp;
  535.  
  536.     tile_width = gimp_tile_width();
  537.     tile_height = gimp_tile_height();
  538.  
  539.     img_width = gimp_drawable_width(input_drawables[0].drawable->id);
  540.     img_height = gimp_drawable_height(input_drawables[0].drawable->id);
  541.  
  542.     gimp_drawable_mask_bounds(input_drawables[0].drawable->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
  543.  
  544.     originX = sel_x1;
  545.     originY = sel_y1;
  546.  
  547.     sel_width  = sel_x2 - sel_x1;
  548.     sel_height = sel_y2 - sel_y1;
  549.  
  550.     cen_x = (double) (sel_x2 - 1 + sel_x1) / 2.0;
  551.     cen_y = (double) (sel_y2 - 1 + sel_y1) / 2.0;
  552.  
  553.     xhsiz = (double) (sel_width - 1) / 2.0;
  554.     yhsiz = (double) (sel_height - 1) / 2.0;
  555.  
  556.     if (xhsiz < yhsiz) {
  557.     scale_x = yhsiz / xhsiz;
  558.     scale_y = 1.0;
  559.     } else if (xhsiz > yhsiz) {
  560.     scale_x = 1.0;
  561.     scale_y = xhsiz / yhsiz;
  562.     } else {
  563.     scale_x = 1.0;
  564.     scale_y = 1.0;
  565.     } /* else */
  566.  
  567.     radius  = MAX(xhsiz, yhsiz);
  568.     radius2 = radius * radius;
  569.  
  570.     /* Calculate preview size */
  571.  
  572.     if (sel_width > sel_height) {
  573.     pwidth  = MIN(sel_width, PREVIEW_SIZE);
  574.     pheight = sel_height * pwidth / sel_width;
  575.     } else {
  576.     pheight = MIN(sel_height, PREVIEW_SIZE);
  577.     pwidth  = sel_width * pheight / sel_height;
  578.     } /* else */
  579.  
  580.     preview_width  = MAX(pwidth, 2);  /* Min size is 2 */
  581.     preview_height = MAX(pheight, 2);
  582.  
  583.     init_builtins();
  584.     init_tags();
  585.     init_internals();
  586.     init_macros();
  587.     init_noise();
  588.  
  589.     /* See how we will run */
  590.  
  591.     switch (run_mode) {
  592.     case RUN_INTERACTIVE:
  593.         /* Possibly retrieve data */
  594.  
  595.         gimp_get_data(name, &mmvals);
  596.  
  597.         /* Get information from the dialog */
  598.  
  599.         update_gradient();
  600.  
  601.         if (!mathmap_dialog(mutable_expression))
  602.         return;
  603.  
  604.         break;
  605.  
  606.     case RUN_NONINTERACTIVE:
  607.         /* Make sure all the arguments are present */
  608.  
  609.         if (nparams != 5)
  610.         status = STATUS_CALLING_ERROR;
  611.  
  612.         if (status == STATUS_SUCCESS)
  613.         {
  614.         expression_copy(mmvals.expression, param[3].data.d_string);
  615.         mmvals.flags = param[4].data.d_int32;
  616.         }
  617.  
  618.         break;
  619.  
  620.     case RUN_WITH_LAST_VALS:
  621.         /* Possibly retrieve data */
  622.  
  623.         gimp_get_data(name, &mmvals);
  624.         break;
  625.  
  626.     default:
  627.         break;
  628.     } /* switch */
  629.  
  630.     /* Mathmap the image */
  631.  
  632.     if ((status == STATUS_SUCCESS)
  633.     && (gimp_drawable_color(input_drawables[0].drawable->id)
  634.         || gimp_drawable_gray(input_drawables[0].drawable->id)))
  635.     {
  636.     intersamplingEnabled = mmvals.flags & FLAG_INTERSAMPLING;
  637.     oversamplingEnabled = mmvals.flags & FLAG_OVERSAMPLING;
  638.     animationEnabled = mmvals.flags & FLAG_ANIMATION;
  639.  
  640.     update_gradient();
  641.  
  642.     /* Set the tile cache size */
  643.  
  644.     gimp_tile_cache_ntiles((input_drawables[0].drawable->width + gimp_tile_width() - 1)
  645.                    / gimp_tile_width());
  646.  
  647.     /* Run! */
  648.  
  649.     if (animationEnabled)
  650.     {
  651.         int frameNum;
  652.  
  653.         for (frameNum = 0; frameNum < mmvals.frames; ++frameNum)
  654.         {
  655.         gint32 layer;
  656.         char layerName[100];
  657.  
  658.         currentT = (double)frameNum / (double)mmvals.frames;
  659.         layer = mathmap_layer_copy(layer_id);
  660.         sprintf(layerName, "Frame %d", frameNum + 1);
  661.         gimp_layer_set_name(layer, layerName);
  662.         output_drawable = gimp_drawable_get(layer);
  663.         mathmap(frameNum);
  664.         gimp_image_add_layer(image_id, layer, 0);
  665.         }
  666.     }
  667.     else
  668.     {
  669.         currentT = mmvals.param_t;
  670.         output_drawable = input_drawables[0].drawable;
  671.         mathmap(-1);
  672.     }
  673.  
  674.     /* If run mode is interactive, flush displays */
  675.  
  676.     if (run_mode != RUN_NONINTERACTIVE)
  677.         gimp_displays_flush();
  678.  
  679.     /* Store data */
  680.  
  681.     if (run_mode == RUN_INTERACTIVE)
  682.         gimp_set_data(name, &mmvals, sizeof(mathmap_vals_t));
  683.     } else if (status == STATUS_SUCCESS)
  684.     status = STATUS_EXECUTION_ERROR;
  685.  
  686.     values[0].data.d_status = status;
  687.  
  688.     gimp_drawable_detach(input_drawables[0].drawable);
  689. } /* run */
  690.  
  691.  
  692. /*****/
  693.  
  694. static internal_t *xy_internal = 0, *ra_internal = 0;
  695.  
  696. inline void
  697. calc_ra (void)
  698. {
  699.     if (ra_internal->is_used)
  700.     {
  701.     double x = currentX,
  702.         y = currentY;
  703.  
  704.     currentR = sqrt(x * x + y * y);
  705.     if (currentR == 0.0)
  706.         currentA = 0.0;
  707.     else
  708.         currentA = acos(x / currentR) * 180 / G_PI;
  709.  
  710.     if (y < 0)
  711.         currentA = 360 - currentA;
  712.     }
  713. }
  714.  
  715. static void
  716. init_internals (void)
  717. {
  718.     xy_internal = register_internal("xy", xy_tag_number, 2);
  719.     ra_internal = register_internal("ra", ra_tag_number, 2);
  720.     register_internal("t", nil_tag_number, 1);
  721.     register_internal("XY", xy_tag_number, 2);
  722.     register_internal("WH", xy_tag_number, 2);
  723.     register_internal("R", nil_tag_number, 1);
  724. }
  725.  
  726. static void
  727. update_image_internals (void)
  728. {
  729.     internal_t *internal;
  730.     tuple_info_t dummy;
  731.  
  732.     internal = lookup_internal("t", &dummy);
  733.     internal->value.data[0] = currentT;
  734.  
  735.     internal = lookup_internal("XY", &dummy);
  736.     internal->value.data[0] = imageX;
  737.     internal->value.data[1] = imageY;
  738.     
  739.     internal = lookup_internal("WH", &dummy);
  740.     internal->value.data[0] = imageW;
  741.     internal->value.data[1] = imageH;
  742.     
  743.     internal = lookup_internal("R", &dummy);
  744.     internal->value.data[0] = imageR;
  745. }
  746.  
  747. static void
  748. update_pixel_internals (void)
  749. {
  750.     xy_internal->value.data[0] = currentX;
  751.     xy_internal->value.data[1] = currentY;
  752.  
  753.     ra_internal->value.data[0] = currentR;
  754.     ra_internal->value.data[1] = currentA;
  755. }
  756.  
  757. /*****/
  758.  
  759. static gint32 
  760. mathmap_layer_copy(gint32 layerID)
  761. {
  762.     GParam *return_vals;
  763.     int nreturn_vals;
  764.     gint32 nlayer;
  765.  
  766.     return_vals = gimp_run_procedure ("gimp_layer_copy", 
  767.                       &nreturn_vals,
  768.                       PARAM_LAYER, layerID,
  769.                       PARAM_INT32, TRUE,
  770.                       PARAM_END);
  771.  
  772.     if (return_vals[0].data.d_status == STATUS_SUCCESS)
  773.     nlayer = return_vals[1].data.d_layer;
  774.     else
  775.     nlayer = -1;
  776.     gimp_destroy_params(return_vals, nreturn_vals);
  777.     return nlayer;
  778. } 
  779.  
  780. /*****/
  781.  
  782. static void
  783. update_gradient (void)
  784. {
  785.     gdouble *samples;
  786.     int i;
  787.  
  788.     samples = gimp_gradients_sample_uniform(num_gradient_samples);
  789.  
  790.     for (i = 0; i < num_gradient_samples; ++i)
  791.     gradient_samples[i] = color_to_tuple(samples[i * 4 + 0], samples[i * 4 + 1],
  792.                          samples[i * 4 + 2], samples[i * 4 + 3]);
  793. }
  794.  
  795. /*****/
  796.  
  797. static int
  798. generate_code (void)
  799. {
  800.     static int result;
  801.  
  802.     result = 1;
  803.  
  804.     if (expression_changed)
  805.     {
  806.     if (run_mode == RUN_INTERACTIVE && expression_entry != 0)
  807.         dialog_text_update();
  808.  
  809.     theExprtree = 0;
  810.     usesRA = 0;
  811.  
  812.     untag_uservals();
  813.  
  814.     DO_JUMP_CODE {
  815.         clear_all_variables();
  816.         internals_clear_used();
  817.         scanFromString(mmvals.expression);
  818.         mmparse();
  819.         endScanningFromString();
  820.  
  821.         assert(theExprtree != 0);
  822.  
  823.         if (theExprtree->result.number != rgba_tag_number || theExprtree->result.length != 4)
  824.         {
  825.         sprintf(error_string, "The expression must have the result type rgba:4.");
  826.         JUMP(1);
  827.         }
  828.  
  829. #ifdef USE_CGEN
  830.         assert(gen_and_load_c_code(theExprtree));
  831. #else
  832.         make_postfix(theExprtree);
  833.         output_postfix();
  834. #endif
  835.  
  836.         expression_changed = 0;
  837.     } WITH_JUMP_HANDLER {
  838.         gimp_message(error_string);
  839.         make_empty_postfix();
  840.  
  841.         result = 0;
  842.     } END_JUMP_HANDLER;
  843.  
  844.     clear_untagged_uservals();
  845.     untag_uservals();
  846.     update_userval_table();
  847.     }
  848.  
  849.     update_image_internals();
  850.  
  851.     return result;
  852. }
  853.  
  854. /*****/
  855.  
  856. void
  857. write_tuple_to_pixel (tuple_t *tuple, guchar *dest)
  858. {
  859.     float redf,
  860.     greenf,
  861.     bluef,
  862.     alphaf;
  863.  
  864.     tuple_to_color(tuple, &redf, &greenf, &bluef, &alphaf);
  865.  
  866.     if (outputBPP == 1 || outputBPP == 2)
  867.     dest[0] = (0.299 * redf + 0.587 * greenf + 0.114 * bluef) * 255;
  868.     else if (outputBPP == 3 || outputBPP == 4)
  869.     {
  870.     dest[0] = redf * 255;
  871.     dest[1] = greenf * 255;
  872.     dest[2] = bluef * 255;
  873.     }
  874.     else
  875.     assert(0);
  876.  
  877.     if (outputBPP == 2 || outputBPP == 4)
  878.     dest[outputBPP - 1] = alphaf * 255;
  879. }
  880.  
  881. /*****/
  882.  
  883. static void
  884. unref_tiles (void)
  885. {
  886.     int i;
  887.  
  888.     for (i = 0; i < MAX_INPUT_DRAWABLES; ++i)
  889.     if (input_drawables[i].used != 0 && input_drawables[i].tile != 0)
  890.     {
  891.         gimp_tile_unref(input_drawables[i].tile, FALSE);
  892.         input_drawables[i].tile = 0;
  893.     }
  894. }
  895.  
  896. /*****/
  897.  
  898. int
  899. alloc_input_drawable (GDrawable *drawable)
  900. {
  901.     int i;
  902.  
  903.     for (i = 0; i < MAX_INPUT_DRAWABLES; ++i)
  904.     if (!input_drawables[i].used)
  905.         break;
  906.     if (i == MAX_INPUT_DRAWABLES)
  907.     return -1;
  908.  
  909.     input_drawables[i].drawable = drawable;
  910.     input_drawables[i].bpp = gimp_drawable_bpp(drawable->id);
  911.     input_drawables[i].row = -1;
  912.     input_drawables[i].col = -1;
  913.     input_drawables[i].tile = 0;
  914.     input_drawables[i].fast_image_source = 0;
  915.     input_drawables[i].used = 1;
  916.  
  917.     return i;
  918. }
  919.  
  920. void
  921. free_input_drawable (int index)
  922. {
  923.     assert(input_drawables[index].used);
  924.     if (input_drawables[index].tile != 0)
  925.     {
  926.     gimp_tile_unref(input_drawables[index].tile, FALSE);
  927.     input_drawables[index].tile = 0;
  928.     }
  929.     if (input_drawables[index].fast_image_source != 0)
  930.     {
  931.     g_free(input_drawables[index].fast_image_source);
  932.     input_drawables[index].fast_image_source = 0;
  933.     }
  934.     input_drawables[index].drawable = 0;
  935.     input_drawables[index].used = 0;
  936. }
  937.  
  938. GDrawable*
  939. get_input_drawable (int index)
  940. {
  941.     assert(input_drawables[index].used);
  942.  
  943.     return input_drawables[index].drawable;
  944. }
  945.  
  946. /*****/
  947.  
  948. static void
  949. mathmap (int frame_num)
  950. {
  951.     GPixelRgn dest_rgn;
  952.     gpointer  pr;
  953.     gint      progress, max_progress;
  954.     guchar   *dest_row;
  955.     guchar   *dest;
  956.     gint      row, col;
  957.     int i;
  958.     gchar progress_info[30];
  959.  
  960.     previewing = 0;
  961.  
  962.     num_ops = 0;
  963.  
  964.     outputBPP = gimp_drawable_bpp(output_drawable->id);
  965.  
  966.     if (generate_code())
  967.     {
  968.     /* Initialize pixel region */
  969.  
  970.     gimp_pixel_rgn_init(&dest_rgn, output_drawable, sel_x1, sel_y1, sel_width, sel_height,
  971.                 TRUE, TRUE);
  972.  
  973.     imageWidth = sel_width;
  974.     imageW = imageWidth;
  975.     imageHeight = sel_height;
  976.     imageH = imageHeight;
  977.  
  978.     middleX = imageWidth / 2.0;
  979.     middleY = imageHeight / 2.0;
  980.  
  981.     if (middleX > imageWidth - middleX)
  982.         imageX = middleX;
  983.     else
  984.         imageX = imageWidth - middleX;
  985.  
  986.     if (middleY > imageHeight - middleY)
  987.         imageY = middleY;
  988.     else
  989.         imageY = imageHeight - middleY;
  990.     
  991.     imageR = sqrt(imageX * imageX + imageY * imageY);
  992.  
  993.     progress     = 0;
  994.     max_progress = sel_width * sel_height;
  995.  
  996.     if (frame_num >= 0)
  997.         sprintf(progress_info, "Mathmapping frame %d...", frame_num + 1);
  998.     else
  999.         strcpy(progress_info, "Mathmapping...");
  1000.     gimp_progress_init(progress_info);
  1001.  
  1002.     for (pr = gimp_pixel_rgns_register(1, &dest_rgn);
  1003.          pr != NULL; pr = gimp_pixel_rgns_process(pr))
  1004.     {
  1005.         if (oversamplingEnabled)
  1006.         {
  1007.         unsigned char *line1,
  1008.             *line2,
  1009.             *line3;
  1010.  
  1011.         dest_row = dest_rgn.data;
  1012.  
  1013.         line1 = (unsigned char*)malloc((sel_width + 1) * outputBPP);
  1014.         line2 = (unsigned char*)malloc(sel_width * outputBPP);
  1015.         line3 = (unsigned char*)malloc((sel_width + 1) * outputBPP);
  1016.  
  1017.         for (col = 0; col <= dest_rgn.w; ++col)
  1018.         {
  1019.             currentX = col + dest_rgn.x - sel_x1 - middleX;
  1020.             currentY = -(0.0 + dest_rgn.y - sel_y1 - middleY);
  1021.             calc_ra();
  1022.             update_pixel_internals();
  1023.             write_tuple_to_pixel(EVAL_EXPR(), line1 + col * outputBPP);
  1024.         }
  1025.  
  1026.         for (row = 0; row < dest_rgn.h; ++row)
  1027.         {
  1028.             dest = dest_row;
  1029.  
  1030.             for (col = 0; col < dest_rgn.w; ++col)
  1031.             {
  1032.             currentX = col + dest_rgn.x - sel_x1 + 0.5 - middleX;
  1033.             currentY = -(row + dest_rgn.y - sel_y1 + 0.5 - middleY);
  1034.             calc_ra();
  1035.             update_pixel_internals();
  1036.             write_tuple_to_pixel(EVAL_EXPR(), line2 + col * outputBPP);
  1037.             }
  1038.             for (col = 0; col <= dest_rgn.w; ++col)
  1039.             {
  1040.             currentX = col + dest_rgn.x - sel_x1 - middleX;
  1041.             currentY = -(row + dest_rgn.y - sel_y1 + 1.0 - middleY);
  1042.             calc_ra();
  1043.             update_pixel_internals();
  1044.             write_tuple_to_pixel(EVAL_EXPR(), line3 + col * outputBPP);
  1045.             }
  1046.         
  1047.             for (col = 0; col < dest_rgn.w; ++col)
  1048.             {
  1049.             for (i = 0; i < outputBPP; ++i)
  1050.                 dest[i] = (line1[col*outputBPP+i]
  1051.                        + line1[(col+1)*outputBPP+i]
  1052.                        + 2*line2[col*outputBPP+i]
  1053.                        + line3[col*outputBPP+i]
  1054.                        + line3[(col+1)*outputBPP+i]) / 6;
  1055.             dest += outputBPP;
  1056.             }
  1057.  
  1058.             memcpy(line1, line3, (imageWidth + 1) * outputBPP);
  1059.  
  1060.             dest_row += dest_rgn.rowstride;
  1061.         }
  1062.         }
  1063.         else
  1064.         {
  1065.         dest_row = dest_rgn.data;
  1066.  
  1067.         for (row = dest_rgn.y; row < (dest_rgn.y + dest_rgn.h); row++)
  1068.         {
  1069.             dest = dest_row;
  1070.  
  1071.             for (col = dest_rgn.x; col < (dest_rgn.x + dest_rgn.w); col++)
  1072.             {
  1073.             currentX = col - sel_x1 - middleX;
  1074.             currentY = -(row - sel_y1 - middleY);
  1075.             calc_ra();
  1076.             update_pixel_internals();
  1077.             write_tuple_to_pixel(EVAL_EXPR(), dest);
  1078.             dest += outputBPP;
  1079.             }
  1080.         
  1081.             dest_row += dest_rgn.rowstride;
  1082.         }
  1083.         }
  1084.  
  1085.         /* Update progress */
  1086.         progress += dest_rgn.w * dest_rgn.h;
  1087.         gimp_progress_update((double) progress / max_progress);
  1088.     }
  1089.  
  1090.     unref_tiles();
  1091.  
  1092.     gimp_drawable_flush(output_drawable);
  1093.     gimp_drawable_merge_shadow(output_drawable->id, TRUE);
  1094.     gimp_drawable_update(output_drawable->id, sel_x1, sel_y1, sel_width, sel_height);
  1095.  
  1096. #ifndef USE_CGEN
  1097.     fprintf(stderr, "executed %d instructions\n", num_ops);
  1098. #endif
  1099.     }
  1100. } /* mathmap */
  1101.  
  1102. /*****/
  1103.  
  1104. void
  1105. mathmap_get_pixel(int drawable_index, int x, int y, guchar *pixel)
  1106. {
  1107.     gint newcol, newrow;
  1108.     gint newcoloff, newrowoff;
  1109.     guchar *p;
  1110.     int i;
  1111.     input_drawable_t *drawable;
  1112.  
  1113.     if (drawable_index < 0 || drawable_index >= MAX_INPUT_DRAWABLES || !input_drawables[drawable_index].used
  1114.     || x < 0 || x >= img_width
  1115.     || y < 0 || y >= img_height)
  1116.     {
  1117.     for (i = 0; i < outputBPP; ++i)
  1118.         pixel[i] = edge_color[i];
  1119.     return;
  1120.     }
  1121.  
  1122.     drawable = &input_drawables[drawable_index];
  1123.  
  1124.     newcol = x / tile_width;
  1125.     newcoloff = x % tile_width;
  1126.     newrow = y / tile_height;
  1127.     newrowoff = y % tile_height;
  1128.  
  1129.     if (drawable->col != newcol || drawable->row != newrow || drawable->tile == NULL)
  1130.     {
  1131.     if (drawable->tile != NULL)
  1132.         gimp_tile_unref(drawable->tile, FALSE);
  1133.  
  1134.     drawable->tile = gimp_drawable_get_tile(drawable->drawable, FALSE, newrow, newcol);
  1135.     assert(drawable->tile != 0);
  1136.     gimp_tile_ref(drawable->tile);
  1137.  
  1138.     drawable->col = newcol;
  1139.     drawable->row = newrow;
  1140.     }
  1141.  
  1142.     p = drawable->tile->data + drawable->tile->bpp * (drawable->tile->ewidth * newrowoff + newcoloff);
  1143.  
  1144.     if (drawable->bpp == 1 || drawable->bpp == 2)
  1145.     pixel[0] = pixel[1] = pixel[2] = p[0];
  1146.     else if (drawable->bpp == 3 || drawable->bpp == 4)
  1147.     for (i = 0; i < 3; ++i)
  1148.         pixel[i] = p[i];
  1149.     else
  1150.     assert(0);
  1151.  
  1152.     if (drawable->bpp == 1 || drawable->bpp == 3)
  1153.     pixel[3] = 255;
  1154.     else
  1155.     pixel[3] = p[drawable->bpp - 1];
  1156. }
  1157.  
  1158. void
  1159. mathmap_get_fast_pixel(int drawable_index, int x, int y, guchar *pixel)
  1160. {
  1161.     input_drawable_t *drawable;
  1162.  
  1163.     if (drawable_index < 0 || drawable_index >= MAX_INPUT_DRAWABLES || !input_drawables[drawable_index].used
  1164.     || x < 0 || x >= preview_width
  1165.     || y < 0 || y >= preview_height)
  1166.     {
  1167.     int i;
  1168.  
  1169.     for (i = 0; i < outputBPP; ++i)
  1170.         pixel[i] = edge_color[i];
  1171.     return;
  1172.     }
  1173.  
  1174.     drawable = &input_drawables[drawable_index];
  1175.  
  1176.     if (drawable->fast_image_source == 0)
  1177.     build_fast_image_source(drawable);
  1178.  
  1179.     memcpy(pixel, drawable->fast_image_source + (x + y * preview_width) * 4, 4);
  1180. }
  1181.  
  1182. /*****/
  1183.  
  1184. static void
  1185. build_fast_image_source (input_drawable_t *drawable)
  1186. {
  1187.     guchar *p;
  1188.     int x, y;
  1189.  
  1190.     assert(drawable->fast_image_source == 0);
  1191.  
  1192.     p = drawable->fast_image_source = g_malloc(preview_width * preview_height * 4);
  1193.  
  1194.     for (y = 0; y < preview_height; ++y)
  1195.     {
  1196.     for (x = 0; x < preview_width; ++x)
  1197.     {
  1198.         mathmap_get_pixel(drawable - input_drawables,
  1199.                   sel_x1 + x * sel_width / preview_width,
  1200.                   sel_y1 + y * sel_height / preview_height, p);
  1201.         p += 4;
  1202.     }
  1203.     }
  1204. }
  1205.  
  1206. /*****/
  1207.  
  1208. static GtkWidget*
  1209. tree_from_lisp_object (GtkWidget *root_item, lisp_object_t *obj)
  1210. {
  1211.     GtkWidget *tree = gtk_tree_new();
  1212.  
  1213.     if (root_item != 0)
  1214.     gtk_tree_item_set_subtree(GTK_TREE_ITEM(root_item), tree);
  1215.  
  1216.     for (; lisp_type(obj) != LISP_TYPE_NIL; obj = lisp_cdr(obj))
  1217.     {
  1218.     lisp_object_t *vars[2];
  1219.     GtkWidget *item = 0;
  1220.  
  1221.     assert(lisp_type(obj) == LISP_TYPE_CONS);
  1222.  
  1223.     if (lisp_match_string("(group #?(string) . #?(list))", lisp_car(obj), vars))
  1224.     {
  1225.         item = gtk_tree_item_new_with_label(lisp_string(vars[0]));
  1226.         gtk_tree_append(GTK_TREE(tree), item);
  1227.         gtk_widget_show(item);
  1228.         tree_from_lisp_object(item, vars[1]);
  1229.     }
  1230.     else if (lisp_match_string("(expression #?(string) #?(string))", lisp_car(obj), vars))
  1231.     {
  1232.         item = gtk_tree_item_new_with_label(lisp_string(vars[0]));
  1233.         gtk_tree_append(GTK_TREE(tree), item);
  1234.         gtk_widget_show(item);
  1235.         gtk_object_set_user_data(GTK_OBJECT(item),
  1236.                      strcpy((char*)malloc(strlen(lisp_string(vars[1])) + 1),
  1237.                         lisp_string(vars[1])));
  1238.     }
  1239.     else
  1240.         assert(0);
  1241.     }
  1242.  
  1243.     gtk_widget_show(tree);
  1244.  
  1245.     if (root_item != 0)
  1246.     gtk_tree_item_expand(GTK_TREE_ITEM(root_item));
  1247.  
  1248.     return tree;
  1249. }
  1250.  
  1251. static GtkWidget*
  1252. read_tree_from_rc (void)
  1253. {
  1254.     GtkWidget *tree;
  1255.     lisp_object_t *obj = read_rc_file();
  1256.  
  1257.     if (obj == 0)
  1258.     {
  1259.     tree = gtk_tree_new();
  1260.     gtk_widget_show(tree);
  1261.     return tree;
  1262.     }
  1263.  
  1264.     tree = tree_from_lisp_object(0, obj);
  1265.     lisp_free(obj);
  1266.  
  1267.     return tree;
  1268. }
  1269.  
  1270. /*****/
  1271.  
  1272. static void
  1273. update_userval_table (void)
  1274. {
  1275.     if (uservalues_table != 0)
  1276.     {
  1277.     gtk_container_remove(GTK_CONTAINER(GTK_BIN(uservalues_scrolled_window)->child), uservalues_table);
  1278.     uservalues_table = 0;
  1279.     }
  1280.  
  1281.     uservalues_table = make_userval_table();
  1282.  
  1283.     if (uservalues_table != 0)
  1284.     {
  1285. #if GTK_MAJOR_VERSION < 1 || (GTK_MAJOR_VERSION == 1 && GTK_MINOR_VERSION < 1)
  1286.     gtk_container_add(GTK_CONTAINER(uservalues_scrolled_window), uservalues_table);
  1287. #else
  1288.     gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(uservalues_scrolled_window), uservalues_table);
  1289. #endif
  1290.     }
  1291. }
  1292.  
  1293.  
  1294. /*****/
  1295.  
  1296. static gint
  1297. mathmap_dialog (int mutable_expression)
  1298. {
  1299.     GtkWidget *dialog;
  1300.     GtkWidget *top_table, *middle_table;
  1301.     GtkWidget *vbox;
  1302.     GtkWidget *frame;
  1303.     GtkWidget *table;
  1304.     GtkWidget *button;
  1305.     GtkWidget *label;
  1306.     GtkWidget *toggle;
  1307.     GtkWidget *alignment;
  1308.     GtkWidget *root_tree;
  1309.     GtkWidget *scale;
  1310.     GtkWidget *vscrollbar;
  1311.     GtkWidget *notebook;
  1312.     GtkObject *adjustment;
  1313.     GSList *edge_group = 0;
  1314.     gint        argc,
  1315.     position = 0;
  1316.     gchar     **argv;
  1317.     guchar     *color_cube;
  1318.  
  1319.     argc    = 1;
  1320.     argv    = g_new(gchar *, 1);
  1321.     argv[0] = g_strdup("mathmap");
  1322.  
  1323.     gtk_init(&argc, &argv);
  1324.  
  1325.     gtk_preview_set_gamma(gimp_gamma());
  1326.     gtk_preview_set_install_cmap(gimp_install_cmap());
  1327.     color_cube = gimp_color_cube();
  1328.     gtk_preview_set_color_cube(color_cube[0], color_cube[1], color_cube[2], color_cube[3]);
  1329.  
  1330.     gtk_widget_set_default_visual(gtk_preview_get_visual());
  1331.     gtk_widget_set_default_colormap(gtk_preview_get_cmap());
  1332.  
  1333.     wint.wimage = g_malloc(preview_width * preview_height * 3 * sizeof(guchar));
  1334.  
  1335.     dialog = gtk_dialog_new();
  1336.     gtk_window_set_title(GTK_WINDOW(dialog), "MathMap");
  1337.     gtk_window_position(GTK_WINDOW(dialog), GTK_WIN_POS_MOUSE);
  1338.     gtk_container_border_width(GTK_CONTAINER(dialog), 0);
  1339.     gtk_signal_connect(GTK_OBJECT(dialog), "destroy",
  1340.                (GtkSignalFunc) dialog_close_callback,
  1341.                NULL);
  1342.  
  1343.     top_table = gtk_hbox_new(FALSE, 0);
  1344.     gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), top_table, TRUE, TRUE, 0);
  1345.     gtk_widget_show(top_table);
  1346.  
  1347.     /* Preview */
  1348.  
  1349.     vbox = gtk_vbox_new(FALSE, 0);
  1350.     gtk_box_pack_start(GTK_BOX(top_table), vbox, FALSE, FALSE, 0);
  1351.     gtk_widget_show(vbox);
  1352.     frame = gtk_frame_new(NULL);
  1353.     gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
  1354.     gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0);
  1355.     gtk_widget_show(frame);
  1356.  
  1357.     wint.preview = gtk_preview_new(GTK_PREVIEW_COLOR);
  1358.     gtk_preview_size(GTK_PREVIEW(wint.preview), preview_width, preview_height);
  1359.     gtk_container_add(GTK_CONTAINER(frame), wint.preview);
  1360.     gtk_widget_show(wint.preview);
  1361.  
  1362.     button = gtk_button_new_with_label("Preview");
  1363.     gtk_signal_connect(GTK_OBJECT(button), "clicked",
  1364.                (GtkSignalFunc)dialog_preview_callback, 0);
  1365.     gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0);
  1366.     gtk_widget_show(button);
  1367.  
  1368.     /* Notebook */
  1369.  
  1370.     notebook = gtk_notebook_new();
  1371.     gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
  1372.     gtk_box_pack_start(GTK_BOX(top_table), notebook, TRUE, TRUE, 0);
  1373.     gtk_widget_show(notebook);
  1374.  
  1375.     /* Settings */
  1376.  
  1377.     middle_table = gtk_table_new(3, 2, FALSE);
  1378.     gtk_container_border_width(GTK_CONTAINER(middle_table), 6);
  1379.     gtk_table_set_col_spacings(GTK_TABLE(middle_table), 4);
  1380.     gtk_widget_show(middle_table);
  1381.  
  1382.             /* Sampling */
  1383.  
  1384.             table = gtk_table_new(2, 1, FALSE);
  1385.         gtk_container_border_width(GTK_CONTAINER(table), 6);
  1386.         gtk_table_set_row_spacings(GTK_TABLE(table), 4);
  1387.     
  1388.         frame = gtk_frame_new(NULL);
  1389.         gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
  1390.         gtk_container_add(GTK_CONTAINER(frame), table);
  1391.         gtk_table_attach(GTK_TABLE(middle_table), frame, 0, 1, 0, 1, GTK_FILL, 0, 0, 0);
  1392.  
  1393.         gtk_widget_show(table);
  1394.         gtk_widget_show(frame);
  1395.  
  1396.                 /* Intersampling */
  1397.  
  1398.         toggle = gtk_check_button_new_with_label("Intersampling");
  1399.         gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(toggle),
  1400.                         mmvals.flags & FLAG_INTERSAMPLING);
  1401.         gtk_table_attach(GTK_TABLE(table), toggle, 0, 1, 0, 1, GTK_FILL, 0, 0, 0);
  1402.         gtk_signal_connect(GTK_OBJECT(toggle), "toggled",
  1403.                    (GtkSignalFunc)dialog_intersampling_update, 0);
  1404.         gtk_widget_show(toggle);
  1405.  
  1406.         /* Oversampling */
  1407.         
  1408.         toggle = gtk_check_button_new_with_label("Oversampling");
  1409.         gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(toggle),
  1410.                         mmvals.flags & FLAG_OVERSAMPLING);
  1411.         gtk_table_attach(GTK_TABLE(table), toggle, 0, 1, 1, 2, GTK_FILL, 0, 0, 0);
  1412.         gtk_signal_connect(GTK_OBJECT(toggle), "toggled",
  1413.                    (GtkSignalFunc)dialog_oversampling_update, 0);
  1414.         gtk_widget_show(toggle);
  1415.  
  1416.         /* Preview Options */
  1417.  
  1418.             table = gtk_table_new(2, 1, FALSE);
  1419.         gtk_container_border_width(GTK_CONTAINER(table), 6);
  1420.         gtk_table_set_row_spacings(GTK_TABLE(table), 4);
  1421.     
  1422.         frame = gtk_frame_new(NULL);
  1423.         gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
  1424.         gtk_container_add(GTK_CONTAINER(frame), table);
  1425.         gtk_table_attach(GTK_TABLE(middle_table), frame, 0, 1, 1, 2, GTK_FILL, 0, 0, 0);
  1426.  
  1427.         gtk_widget_show(table);
  1428.         gtk_widget_show(frame);
  1429.  
  1430.             /* Auto Preview */
  1431.  
  1432.             toggle = gtk_check_button_new_with_label("Auto Preview");
  1433.         gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(toggle), auto_preview);
  1434.         gtk_table_attach(GTK_TABLE(table), toggle, 0, 1, 0, 1, GTK_FILL, 0, 0, 0);
  1435.         gtk_signal_connect(GTK_OBJECT(toggle), "toggled",
  1436.                    (GtkSignalFunc)dialog_auto_preview_update, 0);
  1437.         gtk_widget_show(toggle);
  1438.  
  1439.             /* Fast Preview */
  1440.  
  1441.         toggle = gtk_check_button_new_with_label("Fast Preview");
  1442.         gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(toggle), fast_preview);
  1443.         gtk_table_attach(GTK_TABLE(table), toggle, 0, 1, 1, 2, GTK_FILL, 0, 0, 0);
  1444.         gtk_signal_connect(GTK_OBJECT(toggle), "toggled",
  1445.                    (GtkSignalFunc)dialog_fast_preview_update, 0);
  1446.         gtk_widget_show(toggle);
  1447.  
  1448.         /* Edge Behaviour */
  1449.  
  1450.         table = gtk_table_new(2, 3, FALSE);
  1451.         gtk_container_border_width(GTK_CONTAINER(table), 6);
  1452.         gtk_table_set_row_spacings(GTK_TABLE(table), 4);
  1453.  
  1454.         frame = gtk_frame_new("Edge Behaviour");
  1455.         gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
  1456.         gtk_container_add(GTK_CONTAINER(frame), table);
  1457.         gtk_table_attach(GTK_TABLE(middle_table), frame, 0, 1, 2, 3, GTK_FILL, 0, 0, 0);
  1458.  
  1459.         gtk_widget_show(table);
  1460.         gtk_widget_show(frame);
  1461.  
  1462.             /* Color */
  1463.  
  1464.             toggle = gtk_radio_button_new_with_label(edge_group, "Color");
  1465.         edge_group = gtk_radio_button_group(GTK_RADIO_BUTTON(toggle));
  1466.         gtk_table_attach(GTK_TABLE(table), toggle, 0, 1, 0, 1, GTK_FILL, 0, 0, 0);
  1467.         gtk_signal_connect(GTK_OBJECT(toggle), "toggled",
  1468.                    (GtkSignalFunc)dialog_edge_behaviour_update, &edge_behaviour_color);
  1469.         gtk_widget_show(toggle);
  1470.  
  1471.         edge_color_well = color_well_new();
  1472.         gtk_signal_connect(GTK_OBJECT(edge_color_well), "color-changed",
  1473.                    (GtkSignalFunc)dialog_edge_color_changed, 0);
  1474.         dialog_edge_color_set();
  1475.         gtk_widget_show(edge_color_well);
  1476.         gtk_table_attach(GTK_TABLE(table), edge_color_well, 1, 2, 0, 1, GTK_FILL, 0, 0, 0);
  1477.  
  1478.             /* Wrap */
  1479.  
  1480.             toggle = gtk_radio_button_new_with_label(edge_group, "Wrap");
  1481.         edge_group = gtk_radio_button_group(GTK_RADIO_BUTTON(toggle));
  1482.         gtk_table_attach(GTK_TABLE(table), toggle, 0, 1, 1, 2, GTK_FILL, 0, 0, 0);
  1483.         gtk_signal_connect(GTK_OBJECT(toggle), "toggled",
  1484.                    (GtkSignalFunc)dialog_edge_behaviour_update, &edge_behaviour_wrap);
  1485.         gtk_widget_show(toggle);
  1486.  
  1487.             /* Reflect */
  1488.  
  1489.             toggle = gtk_radio_button_new_with_label(edge_group, "Reflect");
  1490.         edge_group = gtk_radio_button_group(GTK_RADIO_BUTTON(toggle));
  1491.         gtk_table_attach(GTK_TABLE(table), toggle, 0, 1, 2, 3, GTK_FILL, 0, 0, 0);
  1492.         gtk_signal_connect(GTK_OBJECT(toggle), "toggled",
  1493.                    (GtkSignalFunc)dialog_edge_behaviour_update, &edge_behaviour_reflect);
  1494.         gtk_widget_show(toggle);
  1495.  
  1496.         /* Animation */
  1497.         
  1498.         table = gtk_table_new(3, 1, FALSE);
  1499.         gtk_container_border_width(GTK_CONTAINER(table), 6);
  1500.         gtk_table_set_row_spacings(GTK_TABLE(table), 4);
  1501.         gtk_table_set_col_spacings(GTK_TABLE(table), 4);
  1502.     
  1503.         frame = gtk_frame_new(NULL);
  1504.         gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
  1505.         gtk_container_add(GTK_CONTAINER(frame), table);
  1506.  
  1507.         alignment = gtk_alignment_new(0, 0, 0, 0);
  1508.         gtk_container_add(GTK_CONTAINER(alignment), frame);
  1509.         gtk_table_attach(GTK_TABLE(middle_table), alignment, 1, 2, 0, 3, GTK_FILL, 0, 0, 0);
  1510.  
  1511.         gtk_widget_show(table);
  1512.         gtk_widget_show(frame);
  1513.         gtk_widget_show(alignment);
  1514.  
  1515.             /* Animation Toggle */
  1516.  
  1517.             alignment = gtk_alignment_new(0, 0, 0, 0);
  1518.         toggle = gtk_check_button_new_with_label("Animate");
  1519.         gtk_container_add(GTK_CONTAINER(alignment), toggle);
  1520.         gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(toggle),
  1521.                         mmvals.flags & FLAG_ANIMATION);
  1522.         gtk_table_attach(GTK_TABLE(table), alignment, 0, 1, 0, 1, GTK_FILL, 0, 0, 0);
  1523.         gtk_signal_connect(GTK_OBJECT(toggle), "toggled",
  1524.                    (GtkSignalFunc)dialog_animation_update, 0);
  1525.         gtk_widget_show(toggle);
  1526.         gtk_widget_show(alignment);
  1527.  
  1528.         /* Number of Frames */
  1529.  
  1530.         frame_table = gtk_table_new(1, 2, FALSE);
  1531.         gtk_table_set_col_spacings(GTK_TABLE(frame_table), 4);
  1532.         gtk_table_attach(GTK_TABLE(table), frame_table, 0, 1, 1, 2, GTK_FILL, 0, 0, 0);
  1533.  
  1534.         label = gtk_label_new("Frames");
  1535.         gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  1536.         gtk_table_attach(GTK_TABLE(frame_table), label, 0, 1, 0, 1, GTK_FILL, 0, 0, 0);
  1537.         adjustment = gtk_adjustment_new(mmvals.frames, 2, 100, 1.0, 1.0, 0.0);
  1538.         scale = gtk_hscale_new(GTK_ADJUSTMENT(adjustment));
  1539.         gtk_widget_set_usize(scale, 100, 0);
  1540.         gtk_table_attach (GTK_TABLE (frame_table), scale, 1, 2, 0, 1, GTK_FILL, 0, 0, 0);
  1541.         gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP);
  1542.         gtk_scale_set_digits(GTK_SCALE(scale),0);
  1543.         gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
  1544.         gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed",
  1545.                     (GtkSignalFunc) dialog_scale_update,
  1546.                     &mmvals.frames);
  1547.         gtk_widget_show(label);
  1548.         gtk_widget_show(scale);
  1549.  
  1550.         gtk_widget_show(frame_table);
  1551.         gtk_widget_set_sensitive(frame_table, mmvals.flags & FLAG_ANIMATION);
  1552.  
  1553.         /* t */
  1554.  
  1555.         t_table = gtk_table_new(1, 2, FALSE);
  1556.         gtk_table_set_col_spacings(GTK_TABLE(t_table), 4);
  1557.         gtk_table_attach(GTK_TABLE(table), t_table, 0, 1, 2, 3, GTK_FILL, 0, 0, 0);
  1558.  
  1559.         label = gtk_label_new("Parameter t");
  1560.         gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
  1561.         gtk_table_attach(GTK_TABLE(t_table), label, 0, 1, 0, 1, GTK_FILL, 0, 0, 0);
  1562.         adjustment = gtk_adjustment_new(mmvals.param_t, 0.0, 1.0, 0.01, 0.1, 0.0);
  1563.         scale = gtk_hscale_new(GTK_ADJUSTMENT(adjustment));
  1564.         gtk_widget_set_usize(scale, 100, 0);
  1565.         gtk_table_attach (GTK_TABLE (t_table), scale, 1, 2, 0, 1, GTK_FILL, 0, 0, 0);
  1566.         gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP);
  1567.         gtk_scale_set_digits(GTK_SCALE(scale),2);
  1568.         gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_CONTINUOUS);
  1569.         gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed",
  1570.                     (GtkSignalFunc) dialog_t_update,
  1571.                     &mmvals.param_t);
  1572.         gtk_widget_show(label);
  1573.         gtk_widget_show(scale);
  1574.  
  1575.         gtk_widget_show(t_table);
  1576.         gtk_widget_set_sensitive(t_table, !(mmvals.flags & FLAG_ANIMATION));
  1577.  
  1578.     label = gtk_label_new("Settings");
  1579.     gtk_widget_show(label);
  1580.     gtk_notebook_append_page_menu(GTK_NOTEBOOK(notebook), middle_table, label, label);
  1581.  
  1582.         /* Expression */
  1583.  
  1584.     if (mutable_expression)
  1585.     {
  1586.         table = gtk_hbox_new(FALSE, 0);
  1587.         gtk_widget_show(table);
  1588.  
  1589.         label = gtk_label_new("Expression");
  1590.         gtk_widget_show(label);
  1591.         gtk_notebook_append_page_menu(GTK_NOTEBOOK(notebook), table, label, label);
  1592.  
  1593.         expression_entry = gtk_text_new(NULL, NULL);
  1594.         gtk_signal_connect(GTK_OBJECT(expression_entry), "changed",
  1595.                    (GtkSignalFunc)dialog_text_changed,
  1596.                    (gpointer)NULL);
  1597.         gtk_text_set_editable(GTK_TEXT(expression_entry), TRUE);
  1598.         gtk_box_pack_start(GTK_BOX(table), expression_entry, TRUE, TRUE, 0);
  1599.         gtk_widget_show(expression_entry);
  1600.         /* gtk_text_freeze(GTK_TEXT(expression_entry)); */
  1601.         gtk_widget_realize(expression_entry);
  1602.         /* gtk_text_thaw(GTK_TEXT(expression_entry)); */
  1603.         gtk_editable_insert_text(GTK_EDITABLE(expression_entry), mmvals.expression,
  1604.                      strlen(mmvals.expression), &position);
  1605.  
  1606.         vscrollbar = gtk_vscrollbar_new(GTK_TEXT(expression_entry)->vadj);
  1607.         gtk_box_pack_start(GTK_BOX(table), vscrollbar, FALSE, FALSE, 0);
  1608.         gtk_widget_show (vscrollbar);
  1609.     }
  1610.  
  1611.     /* User Values */
  1612.  
  1613.     uservalues_scrolled_window = gtk_scrolled_window_new(NULL, NULL);
  1614.     gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(uservalues_scrolled_window),
  1615.                     GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  1616.     gtk_widget_show(uservalues_scrolled_window);
  1617.  
  1618.     uservalues_table = 0;
  1619.  
  1620.     label = gtk_label_new("User Values");
  1621.     gtk_widget_show(label);
  1622.     gtk_notebook_append_page_menu(GTK_NOTEBOOK(notebook), uservalues_scrolled_window, label, label);
  1623.  
  1624.     /* Examples */
  1625.  
  1626.     if (mutable_expression)
  1627.     {
  1628.         table = gtk_scrolled_window_new (NULL, NULL);
  1629.         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(table),
  1630.                         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  1631.         gtk_widget_show (table);
  1632.  
  1633.         root_tree = read_tree_from_rc();
  1634.         gtk_signal_connect(GTK_OBJECT(root_tree), "selection_changed",
  1635.                    (GtkSignalFunc)dialog_tree_changed,
  1636.                    (gpointer)NULL);
  1637. #if GTK_MAJOR_VERSION < 1 || (GTK_MAJOR_VERSION == 1 && GTK_MINOR_VERSION < 1)
  1638.         gtk_container_add(GTK_CONTAINER(table), root_tree);
  1639. #else
  1640.         gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(table), root_tree);
  1641. #endif
  1642.         gtk_tree_set_selection_mode(GTK_TREE(root_tree), GTK_SELECTION_BROWSE);
  1643.         gtk_tree_set_view_lines(GTK_TREE(root_tree), FALSE);
  1644.         gtk_tree_set_view_mode(GTK_TREE(root_tree), FALSE);
  1645.         gtk_widget_show(root_tree);
  1646.  
  1647.         label = gtk_label_new("Examples");
  1648.         gtk_widget_show(label);
  1649.         gtk_notebook_append_page_menu(GTK_NOTEBOOK(notebook), table, label, label);
  1650.     }
  1651.  
  1652.     /* Buttons */
  1653.  
  1654.     gtk_container_border_width(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), 6);
  1655.  
  1656.     button = gtk_button_new_with_label("OK");
  1657.     GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  1658.     gtk_signal_connect(GTK_OBJECT(button), "clicked",
  1659.                (GtkSignalFunc) dialog_ok_callback,
  1660.                dialog);
  1661.     gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area), button, TRUE, TRUE, 0);
  1662.     gtk_widget_grab_default(button);
  1663.     gtk_widget_show(button);
  1664.  
  1665.     button = gtk_button_new_with_label("Cancel");
  1666.     GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  1667.     gtk_signal_connect(GTK_OBJECT(button), "clicked",
  1668.                (GtkSignalFunc) dialog_cancel_callback,
  1669.                dialog);
  1670.     gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area), button, TRUE, TRUE, 0);
  1671.     gtk_widget_show(button);
  1672.  
  1673.     button = gtk_button_new_with_label("Help");
  1674.     GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  1675.     gtk_signal_connect(GTK_OBJECT(button), "clicked",
  1676.                (GtkSignalFunc) dialog_help_callback,
  1677.                dialog);
  1678.     gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area), button, TRUE, TRUE, 0);
  1679.     gtk_widget_show(button);
  1680.  
  1681.     button = gtk_button_new_with_label("About");
  1682.     GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
  1683.     gtk_signal_connect(GTK_OBJECT(button), "clicked",
  1684.                (GtkSignalFunc) dialog_about_callback,
  1685.                dialog);
  1686.     gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area), button, TRUE, TRUE, 0);
  1687.     gtk_widget_show(button);
  1688.  
  1689.     /* Done */
  1690.  
  1691.     if (!mutable_expression)
  1692.     dialog_update_preview();
  1693.  
  1694.     gtk_widget_show(dialog);
  1695.  
  1696.     gtk_main();
  1697.     gdk_flush();
  1698.  
  1699.     unref_tiles();
  1700.  
  1701.     g_free(wint.wimage);
  1702.  
  1703.     return wint.run;
  1704. } /* mathmap_dialog */
  1705.  
  1706.  
  1707. /*****/
  1708.  
  1709. void
  1710. dialog_update_preview(void)
  1711. {
  1712.     double  left, right, bottom, top;
  1713.     double  dx, dy;
  1714.     int     x, y;
  1715.     double  scale_x, scale_y;
  1716.     guchar *p_ul, *p_lr, *p;
  1717.     gint check,check_0,check_1; 
  1718.  
  1719.     update_uservals();
  1720.  
  1721.     previewing = fast_preview;
  1722.  
  1723.     intersamplingEnabled = mmvals.flags & FLAG_INTERSAMPLING;
  1724.     oversamplingEnabled = mmvals.flags & FLAG_OVERSAMPLING;
  1725.  
  1726.     currentT = mmvals.param_t;
  1727.  
  1728.     left   = sel_x1;
  1729.     right  = sel_x2 - 1;
  1730.     bottom = sel_y2 - 1;
  1731.     top    = sel_y1;
  1732.  
  1733.     dx = (right - left) / (preview_width - 1);
  1734.     dy = (bottom - top) / (preview_height - 1);
  1735.  
  1736.     scale_x = (double) (preview_width - 1) / (right - left);
  1737.     scale_y = (double) (preview_height - 1) / (bottom - top);
  1738.  
  1739.     p_ul = wint.wimage;
  1740.     p_lr = wint.wimage + 3 * (preview_width * preview_height - 1);
  1741.  
  1742.     imageWidth = sel_width;
  1743.     imageW = imageWidth;
  1744.     imageHeight = sel_height;
  1745.     imageH = imageHeight;
  1746.  
  1747.     middleX = imageWidth / 2.0;
  1748.     middleY = imageHeight / 2.0;
  1749.  
  1750.     if (middleX > imageWidth - middleX)
  1751.     imageX = middleX;
  1752.     else
  1753.     imageX = imageWidth - middleX;
  1754.  
  1755.     if (middleY > imageHeight - middleY)
  1756.     imageY = middleY;
  1757.     else
  1758.     imageY = imageHeight - middleY;
  1759.     
  1760.     imageR = sqrt(imageX * imageX + imageY * imageY);
  1761.  
  1762.     if (generate_code())
  1763.     {
  1764.     for (y = 0; y < preview_height; y++)
  1765.     {
  1766.         if ((y / CHECK_SIZE) & 1) {
  1767.         check_0 = CHECK_DARK;
  1768.         check_1 = CHECK_LIGHT;
  1769.         } else {
  1770.         check_0 = CHECK_LIGHT;
  1771.         check_1 = CHECK_DARK;
  1772.         }                        
  1773.         for (x = 0; x < preview_width; x++)
  1774.         {
  1775.         tuple_t *result;
  1776.         float redf,
  1777.             greenf,
  1778.             bluef,
  1779.             alphaf;
  1780.  
  1781.         currentX = x * imageWidth / preview_width - middleX;
  1782.         currentY = -(y * imageHeight / preview_height - middleY);
  1783.         calc_ra();
  1784.         update_pixel_internals();
  1785.         result = EVAL_EXPR();
  1786.         tuple_to_color(result, &redf, &greenf, &bluef, &alphaf);
  1787.  
  1788.         if (input_drawables[0].bpp < 2)
  1789.             redf = greenf = bluef = 0.299 * redf + 0.587 * greenf + 0.114 * bluef;
  1790.  
  1791.         p_ul[0] = redf * 255;
  1792.         p_ul[1] = greenf * 255;
  1793.         p_ul[2] = bluef * 255;
  1794.  
  1795.         if (outputBPP == 2 || outputBPP == 4)
  1796.         {
  1797.             if (((x) / CHECK_SIZE) & 1)
  1798.             check = check_0;
  1799.             else
  1800.             check = check_1;
  1801.             p_ul[0] = check + (p_ul[0] - check) * alphaf;
  1802.             p_ul[1] = check + (p_ul[1] - check) * alphaf;
  1803.             p_ul[2] = check + (p_ul[2] - check) * alphaf;
  1804.         }
  1805.  
  1806.         p_ul += 3;
  1807.         }
  1808.     }
  1809.  
  1810.     p = wint.wimage;
  1811.  
  1812.     for (y = 0; y < preview_height; y++)
  1813.     {
  1814.         gtk_preview_draw_row(GTK_PREVIEW(wint.preview), p, 0, y, preview_width);
  1815.  
  1816.         p += preview_width * 3;
  1817.     }
  1818.  
  1819.     gtk_widget_draw(wint.preview, NULL);
  1820.     gdk_flush();
  1821.     }
  1822. } /* dialog_update_preview */
  1823.  
  1824.  
  1825. /*****/
  1826.  
  1827. static void
  1828. dialog_scale_update(GtkAdjustment *adjustment, gint *value)
  1829. {
  1830.     *value = (gint)adjustment->value;
  1831. } /* dialog_scale_update */
  1832.  
  1833.  
  1834. /*****/
  1835.  
  1836. static void
  1837. dialog_t_update(GtkAdjustment *adjustment, gfloat *value)
  1838. {
  1839.     *value = (gfloat)adjustment->value;
  1840.  
  1841.     if (auto_preview)
  1842.     dialog_update_preview();
  1843. } /* dialog_scale_update */
  1844.  
  1845.  
  1846. /*****/
  1847.  
  1848. static void
  1849. dialog_text_changed (void)
  1850. {
  1851.     expression_changed = 1;
  1852. }
  1853.  
  1854. /*****/
  1855.  
  1856. static void
  1857. dialog_text_update (void)
  1858. {
  1859.     guint length = gtk_text_get_length(GTK_TEXT(expression_entry));
  1860.     char *expression = (char*)malloc(length + 1);
  1861.     int i;
  1862.  
  1863.     for (i = 0; i < length; ++i)
  1864.     expression[i] = GTK_TEXT_INDEX(GTK_TEXT(expression_entry), i);
  1865.     expression[i] = '\0';
  1866.  
  1867.     expression_copy(mmvals.expression, expression);
  1868.  
  1869.     free(expression);
  1870. } /* dialog_text_update */
  1871.  
  1872. /*****/
  1873.  
  1874. static void
  1875. dialog_oversampling_update (GtkWidget *widget, gpointer data)
  1876. {
  1877.     mmvals.flags &= ~FLAG_OVERSAMPLING;
  1878.  
  1879.     if (GTK_TOGGLE_BUTTON(widget)->active)
  1880.     mmvals.flags |= FLAG_OVERSAMPLING;
  1881. }
  1882.  
  1883. /*****/
  1884.  
  1885. static void
  1886. dialog_auto_preview_update (GtkWidget *widget, gpointer data)
  1887. {
  1888.     auto_preview = GTK_TOGGLE_BUTTON(widget)->active;
  1889. }
  1890.  
  1891. /*****/
  1892.  
  1893. static void
  1894. dialog_fast_preview_update (GtkWidget *widget, gpointer data)
  1895. {
  1896.     fast_preview = GTK_TOGGLE_BUTTON(widget)->active;
  1897.     if (auto_preview)
  1898.     dialog_update_preview();
  1899. }
  1900.  
  1901. /*****/
  1902.  
  1903. static void
  1904. dialog_edge_behaviour_update (GtkWidget *widget, gpointer data)
  1905. {
  1906.     edge_behaviour_mode = *(int*)data;
  1907.     if (edge_behaviour_mode == edge_behaviour_color)
  1908.     {
  1909.     gtk_widget_set_sensitive(edge_color_well, 1);
  1910.     }
  1911.     else
  1912.     {
  1913.     gtk_widget_set_sensitive(edge_color_well, 0);
  1914.     }
  1915.  
  1916.     if (auto_preview)
  1917.     dialog_update_preview();
  1918. }
  1919.  
  1920. static void
  1921. dialog_edge_color_set (void)
  1922. {
  1923.     gdouble color[4];
  1924.     int i;
  1925.  
  1926.     for (i = 0; i < 4; ++i)
  1927.     color[i] = edge_color[i] / 255.0;
  1928.  
  1929.     color_well_set_color(COLOR_WELL(edge_color_well), color);
  1930. }
  1931.  
  1932. static void
  1933. dialog_edge_color_changed (ColorWell *color_well, gpointer data)
  1934. {
  1935.     gdouble color[4];
  1936.     int i;
  1937.  
  1938.     color_well_get_color(color_well, color);
  1939.     for (i = 0; i < 4; ++i)
  1940.     edge_color[i] = color[i] * 255.0;
  1941.     if (auto_preview)
  1942.     dialog_update_preview();
  1943. }
  1944.  
  1945. /*****/
  1946.  
  1947. static void
  1948. dialog_intersampling_update (GtkWidget *widget, gpointer data)
  1949. {
  1950.     mmvals.flags &= ~FLAG_INTERSAMPLING;
  1951.  
  1952.     if (GTK_TOGGLE_BUTTON(widget)->active)
  1953.     mmvals.flags |= FLAG_INTERSAMPLING;
  1954.  
  1955.     expression_changed = 1;
  1956.  
  1957.     if (auto_preview)
  1958.     dialog_update_preview();
  1959. }
  1960.  
  1961. /*****/
  1962.  
  1963. static void
  1964. dialog_animation_update (GtkWidget *widget, gpointer data)
  1965. {
  1966.     mmvals.flags &= ~FLAG_ANIMATION;
  1967.  
  1968.     if (GTK_TOGGLE_BUTTON(widget)->active)
  1969.     mmvals.flags |= FLAG_ANIMATION;
  1970.  
  1971.     gtk_widget_set_sensitive(frame_table, mmvals.flags & FLAG_ANIMATION);
  1972.     gtk_widget_set_sensitive(t_table, !(mmvals.flags & FLAG_ANIMATION));
  1973. }
  1974.  
  1975. /*****/
  1976.  
  1977. static void
  1978. dialog_preview_callback (GtkWidget *widget, gpointer data)
  1979. {
  1980.     update_gradient();
  1981.     dialog_update_preview();
  1982. }
  1983.  
  1984. /*****/
  1985.  
  1986. static void
  1987. dialog_close_callback (GtkWidget *widget, gpointer data)
  1988. {
  1989.     gtk_main_quit();
  1990. } /* dialog_close_callback */
  1991.  
  1992.  
  1993. /*****/
  1994.  
  1995. static void
  1996. dialog_ok_callback (GtkWidget *widget, gpointer data)
  1997. {
  1998.     if (generate_code())
  1999.     {
  2000.     wint.run = TRUE;
  2001.     gtk_widget_destroy(GTK_WIDGET(data));
  2002.     }
  2003. } /* dialog_ok_callback */
  2004.  
  2005.  
  2006. /*****/
  2007.  
  2008. static void
  2009. dialog_cancel_callback (GtkWidget *widget, gpointer data)
  2010. {
  2011.     gtk_widget_destroy(GTK_WIDGET(data));
  2012. } /* dialog_cancel_callback */
  2013.  
  2014. /*****/
  2015.  
  2016. static void
  2017. dialog_help_callback (GtkWidget *widget, gpointer data)
  2018. {
  2019.     char *proc_blurb, *proc_help, *proc_author, *proc_copyright, *proc_date;
  2020.     int proc_type, nparams, nreturn_vals;
  2021.     GParamDef *params, *return_vals;
  2022.     gint baz;
  2023.  
  2024.     if (gimp_query_procedure ("extension_web_browser",
  2025.                   &proc_blurb, &proc_help, 
  2026.                   &proc_author, &proc_copyright, &proc_date,
  2027.                   &proc_type, &nparams, &nreturn_vals,
  2028.                   ¶ms, &return_vals)) 
  2029.     gimp_run_procedure ("extension_web_browser", &baz,
  2030.                 PARAM_INT32, RUN_NONINTERACTIVE,
  2031.                 PARAM_STRING, MATHMAP_MANUAL_URL,
  2032.                 PARAM_INT32, 1,
  2033.                 PARAM_END);
  2034.     else 
  2035.     {
  2036.     gchar *message = g_strdup_printf("See %s", MATHMAP_MANUAL_URL);
  2037.  
  2038.     gimp_message(message);
  2039.     g_free(message);
  2040.     }                                            
  2041. } /* dialog_help_callback */
  2042.  
  2043. /*****/
  2044.  
  2045. static void
  2046. dialog_about_callback (GtkWidget *widget, gpointer data)
  2047. {
  2048.     gimp_message("MathMap " MATHMAP_VERSION "\n"
  2049.          "written by\n"
  2050.          "Mark Probst <schani@complang.tuwien.ac.at>");
  2051. } /* dialog_about_callback */
  2052.  
  2053. /*****/
  2054.  
  2055. static void
  2056. dialog_tree_changed (GtkTree *tree)
  2057. {
  2058.     GList *selection;
  2059.     GtkWidget *tree_item;
  2060.  
  2061.     selection = GTK_TREE_SELECTION(tree);
  2062.  
  2063.     if (g_list_length(selection) != 1)
  2064.     return;
  2065.  
  2066.     tree_item = GTK_WIDGET(selection->data);
  2067.  
  2068.     if (gtk_object_get_user_data(GTK_OBJECT(tree_item)) != 0)
  2069.     {
  2070.     char *expression = (char*)gtk_object_get_user_data(GTK_OBJECT(tree_item));
  2071.     gint position = 0;
  2072.  
  2073.     tree_item = GTK_WIDGET(selection->data);
  2074.     
  2075.     gtk_editable_delete_text(GTK_EDITABLE(expression_entry), 0,
  2076.                  gtk_text_get_length(GTK_TEXT(expression_entry)));
  2077.     gtk_editable_insert_text(GTK_EDITABLE(expression_entry), expression, strlen(expression),
  2078.                  &position);
  2079.  
  2080.     expression_copy(mmvals.expression, expression);
  2081.     }
  2082.  
  2083.     if (auto_preview)
  2084.     dialog_update_preview();
  2085. }
  2086.