dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/plug-ins/mathmap/mathmap.c

1330 lines
35 KiB
C
Raw Blame History

/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* MathMap plug-in --- generate an image by means of a mathematical expression
* Copyright (C) 1997 Mark Probst
* schani@unix.cslab.tuwien.ac.at
*
* Plug-In structure based on:
* Whirl plug-in --- distort an image into a whirlpool
* Copyright (C) 1997 Federico Mena Quintero
* federico@nuclecu.unam.mx
*
* Version 0.4
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include "exprtree.h"
#include "builtins.h"
#include "postfix.h"
#include "scanner.h"
/***** Macros *****/
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
/***** Magic numbers *****/
#define PREVIEW_SIZE 128
#define SCALE_WIDTH 200
#define ENTRY_WIDTH 60
#define DEFAULT_EXPRESSION "origValXY(x+sin(y*10)*3,y+sin(x*10)*3)"
#define DEFAULT_NUMBER_FRAMES 10
#define FLAG_INTERSAMPLING 1
#define FLAG_OVERSAMPLING 2
#define FLAG_ANIMATION 4
#define MAX_EXPRESSION_LENGTH 8192
/***** Types *****/
typedef struct {
gchar expression[MAX_EXPRESSION_LENGTH];
gint flags;
gint frames;
} mathmap_vals_t;
typedef struct {
GtkWidget *preview;
guchar *image;
guchar *wimage;
gint run;
} mathmap_interface_t;
/***** Prototypes *****/
static void query(void);
static void run(char *name,
int nparams,
GParam *param,
int *nreturn_vals,
GParam **return_vals);
static void expression_copy (gchar *dest, gchar *src);
static void mathmap (void);
void mathmap_get_pixel(int x, int y, guchar *pixel);
static gint32 mathmap_layer_copy(gint32 layerID);
extern int yyparse (void);
static void build_preview_source_image(void);
static gint mathmap_dialog(void);
static void dialog_update_preview(void);
/*
static void dialog_create_value(char *title, GtkTable *table, int row, gdouble *value,
double left, double right);
*/
static void dialog_scale_update(GtkAdjustment *adjustment, gint *value);
static void dialog_entry_update(GtkWidget *widget, gpointer value);
static void dialog_intersampling_update (GtkWidget *widget, gpointer data);
static void dialog_oversampling_update (GtkWidget *widget, gpointer data);
static void dialog_animation_update (GtkWidget *widget, gpointer data);
static void dialog_preview_callback (GtkWidget *widget, gpointer data);
static void dialog_example_callback (GtkWidget *widget, char *expression);
static void dialog_close_callback(GtkWidget *widget, gpointer data);
static void dialog_ok_callback(GtkWidget *widget, gpointer data);
static void dialog_cancel_callback(GtkWidget *widget, gpointer data);
/***** Variables *****/
GPlugInInfo PLUG_IN_INFO = {
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run /* run_proc */
}; /* PLUG_IN_INFO */
static mathmap_vals_t mmvals = {
DEFAULT_EXPRESSION, /* expression */
FLAG_INTERSAMPLING, /* flags */
DEFAULT_NUMBER_FRAMES /* frames */
}; /* mmvals */
static mathmap_interface_t wint = {
NULL, /* preview */
NULL, /* image */
NULL, /* wimage */
FALSE /* run */
}; /* wint */
static gint32 image_id;
static gint32 layer_id;
static GDrawable *input_drawable;
static GDrawable *output_drawable;
static gint tile_width, tile_height;
static gint img_width, img_height;
static gint sel_x1, sel_y1, sel_x2, sel_y2;
static gint sel_width, sel_height;
static gint preview_width, preview_height;
static GTile *the_tile = NULL;
static double cen_x, cen_y;
static double scale_x, scale_y;
static double radius, radius2;
GtkWidget *expression_entry = 0,
*animate_table;
exprtree *theExprtree = 0;
int imageWidth,
imageHeight,
wholeImageWidth,
wholeImageHeight,
originX,
originY,
inputBPP,
outputBPP;
int usesRA = 0;
double currentX,
currentY,
currentR,
currentA,
currentT,
imageR,
imageX,
imageY,
middleX,
middleY;
int intersamplingEnabled,
oversamplingEnabled,
animationEnabled = 1;
char *examples[][2] = {
{ "wave", "origValXY(x+sin(y*10+t*360)*3,y+sin(x*10+t*360)*3)" },
{ "square", "origValXY(sign(x)*x*x/50,sign(y)*y*y/50)" },
{ "mosaic", "origValXY(x-x%5,y-y%5)" },
{ "slice", "q=t*360;origValXY(x+5*sign(cos(9*y+q)),y+5*sign(cos(9*x+q)))" },
{ "mercator", "origValXY(x*cos(90/Y*y+t*360),y)" },
{ "pond", "origValRA(r+sin(r*20+t*360)*3,a)" },
{ "enhanced pond", "origValRA(r+(sin(500000/(r+100)+t*360)*7),a)" },
{ "sea 1", "origValXY(x+10*sin(t*360+2000*Y*pow(y+Y+60,-1)),y)" },
{ "sea 2", "origValXY(x,y+5*sin(t*360+2000*Y*pow(y+Y+60,-1)))" },
{ "sea 3", "s=sin(t*360+2000*Y*pow(y+Y+60,-1));origValXY(x+10*s,y+5*s)" },
{ "twirl 90", "origValRA(r,a+(r/R-1)*45)" },
{ "sphere", "p=r/(X*2);origValRA(r*(1-inintv(p,-0.5,0.5))+X/90*asin(inintv(p,-0.5,0.5)*r/X),a)" },
{ "jitter", "origValRA(r,a+(a+t*8)%8-4)" },
{ "radial mosaic", "origValRA(r-r%5,a-a%5)" },
{ "circular slice", "origValRA(r,a+(r+t*6)%6-3)" },
{ "fisheye", "origValRA(pow(r,2-t)/pow(R,1-t),a)" },
{ "center shake", "origValXY(x+max(0,cos(x*2))*5*max(0,cos(y*2))*cos(y*10),y+max(0,cos(x*2))*5*max(0,cos(y*2))*cos(x*10))" },
{ "spiral", "p=origValXY(x,y);q=sin((r-a*0.1)*10+t*360)*0.5+0.5;rgbColor(q*red(p),q*green(p),q*blue(p))" },
{ "alpha spiral", "p=origValXY(x,y);rgbaColor(red(p),green(p),blue(p),sin((r-a*0.1)*10+t*360)*0.5+0.5)" },
{ "scatter", "origValXY(x+rand(-3,3),y+rand(-3,3))" },
{ "desaturate", "p=origValXY(x,y);grayaColor(gray(p),alpha(p))" },
{ "darts", "p=origValXY(x,y);p=if inintv((a-9)%36,0,18) then p else rgbColor(1-red(p),1-green(p),1-blue(p)) end;if inintv(r%80,68,80) then p else rgbColor(1-red(p),1-green(p),1-blue(p)) end" },
{ "tile", "origValXY((x+X)*2%W-X,(y+Y)*2%H-Y)" },
{ "?", "origValRA(r,a+sin(a*10)*20)" },
{ "?", "origValRA(r+r%20,a)" },
{ "sine wave", "grayColor(sin(r*10)*0.5+0.5)" },
{ "grid", "grayColor(if (x%20)*(y%20) then 1 else 0 end)" },
{ "moire1", "q=t*360;rgbColor(abs(sin(15*r+q)+sin(15*a+q))*0.5,abs(sin(17*r+q)+sin(17*a+q))*0.5,abs(sin(19*r+q)+sin(19*a+q))*0.5)" },
{ "moire2", "grayColor(sin(x*y+t*360)*0.5+0.5)" },
{ "mandelbrot",
"tx=1.5*x/X-0.5; "
"ty=1.5*y/X-0; "
"iter=0; "
"xr=0; "
"xi=0; "
"xrsq=0; "
"xisq=0; "
"while xrsq+xisq<4 && iter<31 "
"do "
"xrsq=xr*xr; "
"xisq=xi*xi; "
"xi=2*xr*xi+ty; "
"xr=xrsq-xisq+tx; "
"iter=iter+1 "
"end; "
"grayColor(iter/32)" },
{ 0, 0 }
};
/***** Functions *****/
/*****/
static void
expression_copy (gchar *dest, gchar *src)
{
strncpy(dest, src, MAX_EXPRESSION_LENGTH);
dest[MAX_EXPRESSION_LENGTH - 1] = 0;
}
/*****/
MAIN();
/*****/
static void
query(void)
{
static GParamDef args[] = {
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "Input image" },
{ PARAM_DRAWABLE, "drawable", "Input drawable" },
{ PARAM_STRING, "expression", "MathMap expression" },
{ PARAM_INT32, "flags", "1: Intersampling 2: Oversampling 4: Animate" },
{ PARAM_INT32, "frames", "Number of Frames" }
}; /* args */
static GParamDef *return_vals = NULL;
static int nargs = sizeof(args) / sizeof(args[0]);
static int nreturn_vals = 0;
gimp_install_procedure("plug_in_mathmap",
"Generate an image using a mathematical expression.",
"Generates an image by means of a mathematical expression. The expression "
"can also refer to the data of an original image. Thus, arbitrary "
"distortions can be constructed. Even animations can be generated.",
"Mark Probst",
"Mark Probst",
"January 1998, 0.4",
"<Image>/Filters/Distorts/MathMap",
"RGB*, GRAY*",
PROC_PLUG_IN,
nargs,
nreturn_vals,
args,
return_vals);
} /* query */
/*****/
static void
run(char *name,
int nparams,
GParam *param,
int *nreturn_vals,
GParam **return_vals)
{
static GParam values[1];
GRunModeType run_mode;
GStatusType status;
double xhsiz, yhsiz;
int pwidth, pheight;
status = STATUS_SUCCESS;
run_mode = param[0].data.d_int32;
image_id = param[1].data.d_int32;
layer_id = gimp_image_get_active_layer(image_id);
values[0].type = PARAM_STATUS;
values[0].data.d_status = status;
*nreturn_vals = 1;
*return_vals = values;
/* Get the active drawable info */
input_drawable = gimp_drawable_get(param[2].data.d_drawable);
tile_width = gimp_tile_width();
tile_height = gimp_tile_height();
img_width = gimp_drawable_width(input_drawable->id);
img_height = gimp_drawable_height(input_drawable->id);
inputBPP = gimp_drawable_bpp(input_drawable->id);
gimp_drawable_mask_bounds(input_drawable->id, &sel_x1, &sel_y1, &sel_x2, &sel_y2);
originX = sel_x1;
originY = sel_y1;
sel_width = sel_x2 - sel_x1;
sel_height = sel_y2 - sel_y1;
cen_x = (double) (sel_x2 - 1 + sel_x1) / 2.0;
cen_y = (double) (sel_y2 - 1 + sel_y1) / 2.0;
xhsiz = (double) (sel_width - 1) / 2.0;
yhsiz = (double) (sel_height - 1) / 2.0;
if (xhsiz < yhsiz) {
scale_x = yhsiz / xhsiz;
scale_y = 1.0;
} else if (xhsiz > yhsiz) {
scale_x = 1.0;
scale_y = xhsiz / yhsiz;
} else {
scale_x = 1.0;
scale_y = 1.0;
} /* else */
radius = MAX(xhsiz, yhsiz);
radius2 = radius * radius;
/* Calculate preview size */
if (sel_width > sel_height) {
pwidth = MIN(sel_width, PREVIEW_SIZE);
pheight = sel_height * pwidth / sel_width;
} else {
pheight = MIN(sel_height, PREVIEW_SIZE);
pwidth = sel_width * pheight / sel_height;
} /* else */
preview_width = MAX(pwidth, 2); /* Min size is 2 */
preview_height = MAX(pheight, 2);
init_builtins();
/* See how we will run */
switch (run_mode) {
case RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data("plug_in_mathmap", &mmvals);
/* Get information from the dialog */
if (!mathmap_dialog())
return;
break;
case RUN_NONINTERACTIVE:
/* Make sure all the arguments are present */
if (nparams != 5)
status = STATUS_CALLING_ERROR;
if (status == STATUS_SUCCESS)
{
expression_copy(mmvals.expression, param[3].data.d_string);
mmvals.flags = param[4].data.d_int32;
}
break;
case RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data("plug_in_mathmap", &mmvals);
break;
default:
break;
} /* switch */
/* Mathmap the image */
if ((status == STATUS_SUCCESS)
&& (gimp_drawable_color(input_drawable->id)
|| gimp_drawable_gray(input_drawable->id)))
{
intersamplingEnabled = mmvals.flags & FLAG_INTERSAMPLING;
oversamplingEnabled = mmvals.flags & FLAG_OVERSAMPLING;
animationEnabled = mmvals.flags & FLAG_ANIMATION;
/* Set the tile cache size */
gimp_tile_cache_ntiles((input_drawable->width + gimp_tile_width() - 1)
/ gimp_tile_width());
/* Run! */
if (animationEnabled)
{
int frameNum;
for (frameNum = 0; frameNum < mmvals.frames; ++frameNum)
{
gint32 layer;
char layerName[100];
currentT = (double)frameNum / (double)mmvals.frames;
layer = mathmap_layer_copy(layer_id);
sprintf(layerName, "kurdenlayer %d", frameNum);
gimp_layer_set_name(layer, layerName);
output_drawable = gimp_drawable_get(layer);
mathmap();
gimp_image_add_layer(image_id, layer, 0);
}
}
else
{
currentT = 0.0;
output_drawable = input_drawable;
mathmap();
}
/* If run mode is interactive, flush displays */
if (run_mode != RUN_NONINTERACTIVE)
gimp_displays_flush();
/* Store data */
if (run_mode == RUN_INTERACTIVE)
gimp_set_data("plug_in_mathmap", &mmvals, sizeof(mathmap_vals_t));
} else if (status == STATUS_SUCCESS)
status = STATUS_EXECUTION_ERROR;
values[0].data.d_status = status;
gimp_drawable_detach(input_drawable);
} /* run */
/*****/
inline void
calc_ra (void)
{
if (usesRA)
{
double x = currentX,
y = currentY;
currentR = sqrt(x * x + y * y);
if (currentR == 0.0)
currentA = 0.0;
else
currentA = acos(x / currentR) * 180 / M_PI;
if (y < 0)
currentA = 360 - currentA;
}
}
static gint32
mathmap_layer_copy(gint32 layerID)
{
GParam *return_vals;
int nreturn_vals;
gint32 nlayer;
return_vals = gimp_run_procedure ("gimp_layer_copy",
&nreturn_vals,
PARAM_LAYER, layerID,
PARAM_INT32, TRUE,
PARAM_END);
if (return_vals[0].data.d_status == STATUS_SUCCESS)
nlayer = return_vals[1].data.d_layer;
else
nlayer = -1;
gimp_destroy_params(return_vals, nreturn_vals);
return nlayer;
}
static void
mathmap(void)
{
GPixelRgn dest_rgn;
gpointer pr;
gint progress, max_progress;
guchar *dest_row;
guchar *dest;
gint row, col;
double cx, cy;
int ix, iy;
double result;
int red,
green,
blue,
alpha;
outputBPP = gimp_drawable_bpp(output_drawable->id);
theExprtree = 0;
scanFromString(mmvals.expression);
yyparse();
endScanningFromString();
if (theExprtree == 0)
return;
make_postfix(theExprtree);
/* output_postfix(); */
/* Initialize pixel region */
gimp_pixel_rgn_init(&dest_rgn, output_drawable, sel_x1, sel_y1, sel_width, sel_height,
TRUE, TRUE);
imageWidth = sel_width;
imageHeight = sel_height;
wholeImageWidth = img_width;
wholeImageHeight = img_height;
middleX = imageWidth / 2.0;
middleY = imageHeight / 2.0;
if (middleX > imageWidth - middleX)
imageX = middleX;
else
imageX = imageWidth - middleX;
if (middleY > imageHeight - middleY)
imageY = middleY;
else
imageY = imageHeight - middleY;
imageR = sqrt(imageX * imageX + imageY * imageY);
progress = 0;
max_progress = sel_width * sel_height;
gimp_progress_init("Mathmapping...");
for (pr = gimp_pixel_rgns_register(1, &dest_rgn);
pr != NULL; pr = gimp_pixel_rgns_process(pr))
{
if (oversamplingEnabled)
{
unsigned char *line1,
*line2,
*line3;
dest_row = dest_rgn.data;
line1 = (unsigned char*)malloc((sel_width + 1) * 3);
line2 = (unsigned char*)malloc(sel_width * 3);
line3 = (unsigned char*)malloc((sel_width + 1) * 3);
for (col = 0; col <= dest_rgn.w; ++col)
{
currentX = col + dest_rgn.x - sel_x1 - middleX;
currentY = 0.0 + dest_rgn.y - sel_y1 - middleY;
calc_ra(); result = eval_postfix();
double_to_color(result, &red, &green, &blue, &alpha);
line1[col * 3 + 0] = red;
line1[col * 3 + 1] = green;
line1[col * 3 + 2] = blue;
}
for (row = 0; row < dest_rgn.h; ++row)
{
dest = dest_row;
for (col = 0; col < dest_rgn.w; ++col)
{
currentX = col + dest_rgn.x - sel_x1 + 0.5 - middleX;
currentY = row + dest_rgn.y - sel_y1 + 0.5 - middleY;
calc_ra(); result = eval_postfix();
double_to_color(result, &red, &green, &blue, &alpha);
line2[col * 3 + 0] = red;
line2[col * 3 + 1] = green;
line2[col * 3 + 2] = blue;
}
for (col = 0; col <= dest_rgn.w; ++col)
{
currentX = col + dest_rgn.x - sel_x1 - middleX;
currentY = row + dest_rgn.y - sel_y1 + 1.0 - middleY;
calc_ra(); result = eval_postfix();
double_to_color(result, &red, &green, &blue, &alpha);
line3[col * 3 + 0] = red;
line3[col * 3 + 1] = green;
line3[col * 3 + 2] = blue;
}
for (col = 0; col < dest_rgn.w; ++col)
{
red = line1[col*3+0]
+ line1[(col+1)*3+0]
+ 2*line2[col*3+0]
+ line3[col*3+0]
+ line3[(col+1)*3+0];
green = line1[col*3+1]
+ line1[(col+1)*3+1]
+ 2*line2[col*3+1]
+ line3[col*3+1]
+ line3[(col+1)*3+1];
blue = line1[col*3+2]
+ line1[(col+1)*3+2]
+ 2*line2[col*3+2]
+ line3[col*3+2]
+ line3[(col+1)*3+2];
dest[0] = red / 6;
dest[1] = green / 6;
dest[2] = blue / 6;
dest += outputBPP;
}
memcpy(line1, line3, (imageWidth + 1) * 3);
dest_row += dest_rgn.rowstride;
}
}
else
{
dest_row = dest_rgn.data;
for (row = dest_rgn.y; row < (dest_rgn.y + dest_rgn.h); row++)
{
dest = dest_row;
for (col = dest_rgn.x; col < (dest_rgn.x + dest_rgn.w); col++)
{
ix = (int) cx;
iy = (int) cy;
currentX = col - sel_x1 - middleX; currentY = row - sel_y1 - middleY;
calc_ra(); result = eval_postfix();
double_to_color(result, &red, &green, &blue, &alpha);
dest[0] = red;
if (outputBPP == 2)
dest[1] = alpha;
else if (outputBPP >= 3)
{
dest[1] = green;
dest[2] = blue;
if (outputBPP == 4)
dest[3] = alpha;
}
dest += outputBPP;
}
dest_row += dest_rgn.rowstride;
}
}
/* Update progress */
progress += dest_rgn.w * dest_rgn.h;
gimp_progress_update((double) progress / max_progress);
}
if (the_tile != NULL) {
gimp_tile_unref(the_tile, FALSE);
the_tile = NULL;
} /* if */
gimp_drawable_flush(output_drawable);
gimp_drawable_merge_shadow(output_drawable->id, TRUE);
gimp_drawable_update(output_drawable->id, sel_x1, sel_y1, sel_width, sel_height);
} /* mathmap */
/*****/
void
mathmap_get_pixel(int x, int y, guchar *pixel)
{
static gint row = -1;
static gint col = -1;
gint newcol, newrow;
gint newcoloff, newrowoff;
guchar *p;
int i;
if ((x < 0) || (x >= img_width) || (y < 0) || (y >= img_height)) {
pixel[0] = 0;
pixel[1] = 0;
pixel[2] = 0;
pixel[3] = 0;
return;
} /* if */
newcol = x / tile_width; /* The compiler should optimize this */
newcoloff = x % tile_width;
newrow = y / tile_height;
newrowoff = y % tile_height;
if ((col != newcol) || (row != newrow) || (the_tile == NULL)) {
if (the_tile != NULL)
gimp_tile_unref(the_tile, FALSE);
the_tile = gimp_drawable_get_tile(input_drawable, FALSE, newrow, newcol);
assert(the_tile != 0);
gimp_tile_ref(the_tile);
col = newcol;
row = newrow;
} /* if */
p = the_tile->data + the_tile->bpp * (the_tile->ewidth * newrowoff + newcoloff);
for (i = inputBPP; i; i--)
*pixel++ = *p++;
}
/*****/
static void
build_preview_source_image(void)
{
double left, right, bottom, top;
double px, py;
double dx, dy;
int x, y;
guchar *p;
guchar pixel[4];
wint.image = g_malloc(preview_width * preview_height * 3 * sizeof(guchar));
wint.wimage = g_malloc(preview_width * preview_height * 3 * sizeof(guchar));
left = sel_x1;
right = sel_x2 - 1;
bottom = sel_y2 - 1;
top = sel_y1;
dx = (right - left) / (preview_width - 1);
dy = (bottom - top) / (preview_height - 1);
py = top;
p = wint.image;
for (y = 0; y < preview_height; y++)
{
px = left;
for (x = 0; x < preview_width; x++)
{
mathmap_get_pixel((int) px, (int) py, pixel);
if (inputBPP < 3)
{
pixel[1] = pixel[0];
pixel[2] = pixel[0];
} /* if */
*p++ = pixel[0];
*p++ = pixel[1];
*p++ = pixel[2];
px += dx;
} /* for */
py += dy;
} /* for */
} /* build_preview_source_image */
/*****/
static gint
mathmap_dialog(void)
{
GtkWidget *dialog;
GtkWidget *top_table,
*middle_table;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *button;
GtkWidget *label;
GtkWidget *toggle;
GtkWidget *arrow;
GtkWidget *alignment;
GtkWidget *menubox;
GtkWidget *menubar;
GtkWidget *menubaritem;
GtkWidget *menu;
GtkWidget *item;
GtkWidget *scale;
GtkObject *adjustment;
int i;
gint argc;
gchar **argv;
guchar *color_cube;
/*
printf("Waiting... (pid %d)\n", getpid());
kill(getpid(), SIGSTOP);
*/
argc = 1;
argv = g_new(gchar *, 1);
argv[0] = g_strdup("mathmap");
gtk_init(&argc, &argv);
gtk_preview_set_gamma(gimp_gamma());
gtk_preview_set_install_cmap(gimp_install_cmap());
color_cube = gimp_color_cube();
gtk_preview_set_color_cube(color_cube[0], color_cube[1], color_cube[2], color_cube[3]);
gtk_widget_set_default_visual(gtk_preview_get_visual());
gtk_widget_set_default_colormap(gtk_preview_get_cmap());
build_preview_source_image();
dialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(dialog), "MathMap");
gtk_window_position(GTK_WINDOW(dialog), GTK_WIN_POS_MOUSE);
gtk_container_border_width(GTK_CONTAINER(dialog), 0);
gtk_signal_connect(GTK_OBJECT(dialog), "destroy",
(GtkSignalFunc) dialog_close_callback,
NULL);
top_table = gtk_table_new(5, 3, FALSE);
gtk_container_border_width(GTK_CONTAINER(top_table), 6);
gtk_table_set_row_spacings(GTK_TABLE(top_table), 4);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), top_table, FALSE, FALSE, 0);
gtk_widget_show(top_table);
/* Preview */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_table_attach(GTK_TABLE(top_table), frame, 1, 2, 0, 1, 0, 0, 0, 0);
gtk_widget_show(frame);
wint.preview = gtk_preview_new(GTK_PREVIEW_COLOR);
gtk_preview_size(GTK_PREVIEW(wint.preview), preview_width, preview_height);
gtk_container_add(GTK_CONTAINER(frame), wint.preview);
gtk_widget_show(wint.preview);
button = gtk_button_new_with_label("Preview");
gtk_signal_connect(GTK_OBJECT(button), "clicked", (GtkSignalFunc)dialog_preview_callback, 0);
gtk_table_attach(GTK_TABLE(top_table), button, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show(button);
middle_table = gtk_table_new(1, 2, FALSE);
gtk_container_border_width(GTK_CONTAINER(middle_table), 6);
gtk_table_set_col_spacings(GTK_TABLE(middle_table), 4);
gtk_table_attach(GTK_TABLE(top_table), middle_table, 0, 3, 2, 3, GTK_FILL, 0, 0, 0);
gtk_widget_show(middle_table);
/* Sampling */
table = gtk_table_new(2, 1, FALSE);
gtk_container_border_width(GTK_CONTAINER(table), 6);
gtk_table_set_row_spacings(GTK_TABLE(table), 4);
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
gtk_container_add(GTK_CONTAINER(frame), table);
alignment = gtk_alignment_new(0, 0, 0, 0);
gtk_container_add(GTK_CONTAINER(alignment), frame);
gtk_table_attach(GTK_TABLE(middle_table), alignment, 0, 1, 0, 1, GTK_FILL, 0, 0, 0);
gtk_widget_show(table);
gtk_widget_show(frame);
gtk_widget_show(alignment);
/* Intersampling */
alignment = gtk_alignment_new(0, 0, 0, 0);
toggle = gtk_check_button_new_with_label("Intersampling");
gtk_container_add(GTK_CONTAINER(alignment), toggle);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(toggle),
mmvals.flags & FLAG_INTERSAMPLING);
gtk_table_attach(GTK_TABLE(table), alignment, 0, 1, 0, 1, GTK_FILL, 0, 0, 0);
gtk_signal_connect(GTK_OBJECT(toggle), "toggled",
(GtkSignalFunc)dialog_intersampling_update, 0);
gtk_widget_show(toggle);
gtk_widget_show(alignment);
/* Oversampling */
alignment = gtk_alignment_new(0, 0, 0, 0);
toggle = gtk_check_button_new_with_label("Oversampling");
gtk_container_add(GTK_CONTAINER(alignment), toggle);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(toggle),
mmvals.flags & FLAG_OVERSAMPLING);
gtk_table_attach(GTK_TABLE(table), alignment, 0, 1, 1, 2, GTK_FILL, 0, 0, 0);
gtk_signal_connect(GTK_OBJECT(toggle), "toggled",
(GtkSignalFunc)dialog_oversampling_update, 0);
gtk_widget_show(toggle);
gtk_widget_show(alignment);
/* Animation */
table = gtk_table_new(2, 1, FALSE);
gtk_container_border_width(GTK_CONTAINER(table), 6);
gtk_table_set_row_spacings(GTK_TABLE(table), 4);
gtk_table_set_col_spacings(GTK_TABLE(table), 4);
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
gtk_container_add(GTK_CONTAINER(frame), table);
alignment = gtk_alignment_new(0, 0, 0, 0);
gtk_container_add(GTK_CONTAINER(alignment), frame);
gtk_table_attach(GTK_TABLE(middle_table), alignment, 1, 2, 0, 1, GTK_FILL, 0, 0, 0);
gtk_widget_show(table);
gtk_widget_show(frame);
gtk_widget_show(alignment);
/* Animation Toggle */
alignment = gtk_alignment_new(0, 0, 0, 0);
toggle = gtk_check_button_new_with_label("Animate");
gtk_container_add(GTK_CONTAINER(alignment), toggle);
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(toggle),
mmvals.flags & FLAG_ANIMATION);
gtk_table_attach(GTK_TABLE(table), alignment, 0, 1, 0, 1, GTK_FILL, 0, 0, 0);
gtk_signal_connect(GTK_OBJECT(toggle), "toggled",
(GtkSignalFunc)dialog_animation_update, 0);
gtk_widget_show(toggle);
gtk_widget_show(alignment);
/* Number of Frames */
animate_table = gtk_table_new(1, 2, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(animate_table), 4);
gtk_table_attach(GTK_TABLE(table), animate_table, 0, 1, 1, 2, GTK_FILL, 0, 0, 0);
label = gtk_label_new("Frames");
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(animate_table), label, 0, 1, 0, 1, GTK_FILL, 0, 0, 0);
adjustment = gtk_adjustment_new(mmvals.frames, 2, 100, 1.0, 1.0, 0.0);
scale = gtk_hscale_new(GTK_ADJUSTMENT(adjustment));
gtk_widget_set_usize(scale, 100, 0);
gtk_table_attach (GTK_TABLE (animate_table), scale, 1, 2, 0, 1, GTK_FILL, 0, 0, 0);
gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP);
gtk_scale_set_digits(GTK_SCALE(scale),0);
gtk_range_set_update_policy (GTK_RANGE (scale), GTK_UPDATE_DELAYED);
gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed",
(GtkSignalFunc) dialog_scale_update,
&mmvals.frames);
gtk_widget_show(label);
gtk_widget_show(scale);
gtk_widget_show(animate_table);
gtk_widget_set_sensitive(animate_table, mmvals.flags & FLAG_ANIMATION);
/* Menu */
menu = gtk_menu_new();
for (i = 0; examples[i][0] != 0; ++i)
{
item = gtk_menu_item_new_with_label(examples[i][0]);
gtk_menu_append(GTK_MENU(menu), item);
gtk_signal_connect(GTK_OBJECT(item), "activate",
(GtkSignalFunc)dialog_example_callback, examples[i][1]);
gtk_widget_show(item);
}
alignment = gtk_alignment_new(0, 0, 0, 0);
menubar = gtk_menu_bar_new();
gtk_container_add(GTK_CONTAINER(alignment), menubar);
menubaritem = gtk_menu_item_new();
menubox = gtk_hbox_new(FALSE, 2);
label = gtk_label_new("Examples");
arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT);
gtk_box_pack_start(GTK_BOX(menubox), arrow, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(menubox), label, FALSE, FALSE, 4);
gtk_container_add(GTK_CONTAINER(menubaritem), menubox);
gtk_container_add(GTK_CONTAINER(menubar), menubaritem);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menubaritem), menu);
gtk_table_attach(GTK_TABLE(top_table), alignment, 0, 3, 3, 4, GTK_FILL, 0, 0, 0);
gtk_widget_show(arrow);
gtk_widget_show(label);
gtk_widget_show(menubox);
gtk_widget_show(menubaritem);
gtk_widget_show(menubar);
gtk_widget_show(alignment);
/* Expression */
table = gtk_table_new(1, 2, FALSE);
gtk_container_border_width(GTK_CONTAINER(table), 0);
gtk_table_attach(GTK_TABLE(top_table), table, 0, 3, 4, 5, GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_widget_show(table);
label = gtk_label_new("Expression");
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 4, 0);
gtk_widget_show(label);
expression_entry = gtk_entry_new();
/*
gtk_object_set_user_data(GTK_OBJECT(entry), scale_data);
gtk_object_set_user_data(scale_data, entry);
*/
gtk_widget_set_usize(expression_entry, ENTRY_WIDTH, 0);
gtk_entry_set_text(GTK_ENTRY(expression_entry), mmvals.expression);
gtk_signal_connect(GTK_OBJECT(expression_entry), "changed",
(GtkSignalFunc) dialog_entry_update,
0);
gtk_table_attach(GTK_TABLE(table), expression_entry, 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_FILL, 4, 0);
gtk_widget_show(expression_entry);
/* Buttons */
gtk_container_border_width(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), 6);
button = gtk_button_new_with_label("OK");
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
(GtkSignalFunc) dialog_ok_callback,
dialog);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area), button, TRUE, TRUE, 0);
gtk_widget_grab_default(button);
gtk_widget_show(button);
button = gtk_button_new_with_label("Cancel");
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
(GtkSignalFunc) dialog_cancel_callback,
dialog);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area), button, TRUE, TRUE, 0);
gtk_widget_show(button);
/* Done */
gtk_widget_show(dialog);
/* dialog_update_preview(); */
gtk_main();
gdk_flush();
if (the_tile != NULL) {
gimp_tile_unref(the_tile, FALSE);
the_tile = NULL;
} /* if */
g_free(wint.image);
g_free(wint.wimage);
return wint.run;
} /* mathmap_dialog */
/*****/
static void
dialog_update_preview(void)
{
double left, right, bottom, top;
double dx, dy;
int x, y;
double scale_x, scale_y;
guchar *p_ul, *p_lr, *p;
intersamplingEnabled = mmvals.flags & FLAG_INTERSAMPLING;
oversamplingEnabled = mmvals.flags & FLAG_OVERSAMPLING;
left = sel_x1;
right = sel_x2 - 1;
bottom = sel_y2 - 1;
top = sel_y1;
dx = (right - left) / (preview_width - 1);
dy = (bottom - top) / (preview_height - 1);
scale_x = (double) (preview_width - 1) / (right - left);
scale_y = (double) (preview_height - 1) / (bottom - top);
p_ul = wint.wimage;
p_lr = wint.wimage + 3 * (preview_width * preview_height - 1);
scanFromString(mmvals.expression);
yyparse();
endScanningFromString();
if (theExprtree == 0)
return;
make_postfix(theExprtree);
imageWidth = sel_width;
imageHeight = sel_height;
wholeImageWidth = img_width;
wholeImageHeight = img_height;
middleX = imageWidth / 2.0;
middleY = imageHeight / 2.0;
if (middleX > imageWidth - middleX)
imageX = middleX;
else
imageX = imageWidth - middleX;
if (middleY > imageHeight - middleY)
imageY = middleY;
else
imageY = imageHeight - middleY;
imageR = sqrt(imageX * imageX + imageY * imageY);
for (y = 0; y < preview_height; y++)
{
for (x = 0; x < preview_width; x++)
{
double result;
int red,
green,
blue,
alpha;
currentX = x * imageWidth / preview_width - middleX;
currentY = y * imageHeight / preview_height - middleY;
calc_ra(); result = eval_postfix();
double_to_color(result, &red, &green, &blue, &alpha);
p_ul[0] = red;
p_ul[1] = green;
p_ul[2] = blue;
p_ul += 3;
}
}
p = wint.wimage;
for (y = 0; y < preview_height; y++)
{
gtk_preview_draw_row(GTK_PREVIEW(wint.preview), p, 0, y, preview_width);
p += preview_width * 3;
}
gtk_widget_draw(wint.preview, NULL);
gdk_flush();
} /* dialog_update_preview */
/*****/
/*
static void
dialog_create_value(char *title, GtkTable *table, int row, gdouble *value,
double left, double right)
{
GtkWidget *label;
GtkWidget *scale;
GtkWidget *entry;
GtkObject *scale_data;
char buf[256];
label = gtk_label_new(title);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(table, label, 0, 1, row, row + 1, GTK_FILL, GTK_FILL, 4, 0);
gtk_widget_show(label);
scale_data = gtk_adjustment_new(*value, left, right,
(right - left) / 360.0,
(right - left) / 360.0,
0.0);
gtk_signal_connect(GTK_OBJECT(scale_data), "value_changed",
(GtkSignalFunc) dialog_scale_update,
value);
scale = gtk_hscale_new(GTK_ADJUSTMENT(scale_data));
gtk_widget_set_usize(scale, SCALE_WIDTH, 0);
gtk_table_attach(table, scale, 1, 2, row, row + 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_scale_set_draw_value(GTK_SCALE(scale), FALSE);
gtk_scale_set_digits(GTK_SCALE(scale), 3);
gtk_range_set_update_policy(GTK_RANGE(scale), GTK_UPDATE_CONTINUOUS);
gtk_widget_show(scale);
entry = gtk_entry_new();
gtk_object_set_user_data(GTK_OBJECT(entry), scale_data);
gtk_object_set_user_data(scale_data, entry);
gtk_widget_set_usize(entry, ENTRY_WIDTH, 0);
sprintf(buf, "%0.2f", *value);
gtk_entry_set_text(GTK_ENTRY(entry), buf);
gtk_signal_connect(GTK_OBJECT(entry), "changed",
(GtkSignalFunc) dialog_entry_update,
value);
gtk_table_attach(GTK_TABLE(table), entry, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, 4, 0);
gtk_widget_show(entry);
}
*/
/*****/
static void
dialog_scale_update(GtkAdjustment *adjustment, gint *value)
{
*value = (gint)adjustment->value;
} /* dialog_scale_update */
/*****/
static void
dialog_entry_update(GtkWidget *widget, gpointer value)
{
expression_copy(mmvals.expression, gtk_entry_get_text(GTK_ENTRY(widget)));
} /* dialog_entry_update */
/*****/
static void
dialog_oversampling_update (GtkWidget *widget, gpointer data)
{
mmvals.flags &= ~FLAG_OVERSAMPLING;
if (GTK_TOGGLE_BUTTON(widget)->active)
mmvals.flags |= FLAG_OVERSAMPLING;
}
/*****/
static void
dialog_intersampling_update (GtkWidget *widget, gpointer data)
{
mmvals.flags &= ~FLAG_INTERSAMPLING;
if (GTK_TOGGLE_BUTTON(widget)->active)
mmvals.flags |= FLAG_INTERSAMPLING;
}
/*****/
static void
dialog_animation_update (GtkWidget *widget, gpointer data)
{
mmvals.flags &= ~FLAG_ANIMATION;
if (GTK_TOGGLE_BUTTON(widget)->active)
mmvals.flags |= FLAG_ANIMATION;
gtk_widget_set_sensitive(animate_table, mmvals.flags & FLAG_ANIMATION);
}
/*****/
static void
dialog_example_callback (GtkWidget *widget, char *expression)
{
gtk_entry_set_text(GTK_ENTRY(expression_entry), expression);
}
/*****/
static void
dialog_preview_callback (GtkWidget *widget, gpointer data)
{
dialog_update_preview();
}
/*****/
static void
dialog_close_callback(GtkWidget *widget, gpointer data)
{
gtk_main_quit();
} /* dialog_close_callback */
/*****/
static void
dialog_ok_callback(GtkWidget *widget, gpointer data)
{
wint.run = TRUE;
gtk_widget_destroy(GTK_WIDGET(data));
} /* dialog_ok_callback */
/*****/
static void
dialog_cancel_callback(GtkWidget *widget, gpointer data)
{
gtk_widget_destroy(GTK_WIDGET(data));
} /* dialog_cancel_callback */
Reference in New Issue View Git Blame Copy Permalink