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

1539 lines
45 KiB
C
Raw Blame History

/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
* Film plug-in (C) 1997 Peter Kirchgessner
* e-mail: pkirchg@aol.com, WWW: http://members.aol.com/pkirchg
*
* 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.
*/
/*
* This plug-in generates a film roll with several images
*/
/* Event history:
* V 1.00, PK, 01-Jul-97, Creation
* V 1.01, PK, 24-Jul-97, Fix problem with previews on Irix
*/
static char ident[] = "@(#) GIMP Film plug-in v1.01 24-Jul-97";
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include "gtk/gtk.h"
#include "libgimp/gimp.h"
/* Maximum number of pictures per film */
#define MAX_FILM_PICTURES 64
/* Declare local functions
*/
static void query (void);
static void run (char *name,
int nparams,
GParam *param,
int *nreturn_vals,
GParam **return_vals);
/* Define how the plug-in works. Values marked (r) are with regard */
/* to film_height (i.e. it should be a value from 0.0 to 1.0) */
typedef struct {
int film_height; /* height of the film */
unsigned char film_color[3]; /* color of film */
double picture_height; /* height of picture (r) */
double picture_space; /* space between pictures (r) */
double hole_offset; /* distance from hole to edge of film (r) */
double hole_width; /* width of hole (r) */
double hole_height; /* height of holes (r) */
double hole_space; /* distance of holes (r) */
double number_height; /* height of picture numbering (r) */
int number_start; /* number for first picture */
unsigned char number_color[3]; /* color of number */
char number_fontf[256]; /* font family to use for numbering */
int number_pos[2]; /* flags where to draw numbers (top/bottom) */
int num_images; /* number of images */
gint32 image[MAX_FILM_PICTURES]; /* list of image IDs */
} FilmVals;
/* Handling for color selection dialogs */
typedef struct
{
GtkWidget *activate; /* The button that activates the color sel. dialog */
GtkWidget *colselect; /* The colour selection dialog itself */
GtkWidget *preview; /* The colour preview */
unsigned char color[3];/* The selected colour */
} CSEL;
/* Data to use for the dialog */
typedef struct
{
GtkWidget *dialog;
GtkWidget *left_entry[3];
GtkWidget *image_list_all;
GtkWidget *image_list_film;
int prv_width, prv_height;
CSEL csel[2];
int number_pos[2];
gint run;
} FilmInterface;
static gint32 create_new_image (char *filename, guint width, guint height,
GDrawableType gdtype, gint32 *layer_ID, GDrawable **drawable,
GPixelRgn *pixel_rgn);
static char *compose_image_name (gint32 image_ID);
static gint32 film (void);
static int check_filmvals (void);
static void convert_to_rgb (GDrawable *srcdrawable, int numpix,
unsigned char *src, unsigned char *dst);
static void set_pixels (int numpix, unsigned char *dst,
unsigned char *rgb);
static int scale_layer (gint32 src_layer, int src_x0, int src_y0,
int src_width, int src_height,
gint32 dst_layer, int dst_x0, int dst_y0,
int dst_width, int dst_height);
static unsigned char *create_hole_rgb (int width, int height);
static void draw_hole_rgb (GDrawable *drw, int x, int y,
int width, int height, unsigned char *hole);
static void draw_number (gint32 layer_ID, int num, int x, int y,
int height);
static GtkWidget *add_label_with_entry (char *label_text, char *entry_text,
int tab_index, GtkWidget *table);
static void add_color_button (int csel_index, int tab_index,
GtkWidget *table);
static void add_list_item_callback (GtkWidget *widget, GtkWidget *list);
static void del_list_item_callback (GtkWidget *widget, GtkWidget *list);
static GtkWidget *add_image_list (int add_box_flag, int n, gint32 *image_id,
GtkWidget *frame);
static gint film_dialog (gint32 image_ID);
static void film_close_callback (GtkWidget *widget,
gpointer data);
static void film_color_button_callback (GtkWidget *widget,
gpointer data);
static void film_ok_callback (GtkWidget *widget,
gpointer data);
static void numbering_toggle_update (GtkWidget *widget,
gpointer data);
static void color_select_ok_callback (GtkWidget *widget,
gpointer data);
static void color_select_cancel_callback (GtkWidget *widget,
gpointer data);
static void color_preview_show (GtkWidget *widget,
unsigned char *color);
GPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
static FilmVals filmvals =
{
256, /* Height of film */
{ 0, 0, 0 }, /* Color of film */
0.695, /* Picture height */
0.040, /* Picture spacing */
0.058, /* Hole offset to edge of film */
0.052, /* Hole width */
0.081, /* Hole height */
0.081, /* Hole distance */
0.052, /* Image number height */
1, /* Start index of numbering */
{ 239, 159, 0 }, /* Color of number */
"courier", /* Font family for numbering */
{ 1, 1 }, /* Numbering on top and bottom */
0, /* Number of images */
{ 0 } /* Input image list */
};
static FilmInterface filmint =
{
NULL, /* dialog */
{ NULL }, /* left entries */
NULL, NULL, /* image list widgets */
50, 20, /* size of preview */
{
{ NULL, NULL, NULL, { 0 } }, /* Color selection dialogs */
{ NULL, NULL, NULL, { 0 } }
},
{ 0 },
FALSE /* run */
};
static GRunModeType run_mode;
MAIN ()
static void
query ()
{
static GParamDef args[] =
{
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "Input image (only used as default image\
in interactive mode)" },
{ PARAM_DRAWABLE, "drawable", "Input drawable (not used)" },
{ PARAM_INT32, "film_height", "Height of film" },
{ PARAM_COLOR, "film_color", "Color of the film" },
{ PARAM_INT32, "number_start", "Start index for numbering" },
{ PARAM_STRING, "number_fontf", "Font family for drawing numbers" },
{ PARAM_COLOR, "number_color", "Color for numbers" },
{ PARAM_INT32, "at_top", "Flag for drawing numbers at top of film" },
{ PARAM_INT32, "at_bottom", "Flag for drawing numbers at bottom of film" },
{ PARAM_INT32, "num_images", "Number of images to be used for film" },
{ PARAM_INT32ARRAY, "image_ids", "num_images image IDs to be used for film"}
};
static GParamDef return_vals[] =
{
{ PARAM_IMAGE, "new_image", "Output image" }
};
static int nargs = sizeof (args) / sizeof (args[0]);
static int nreturn_vals = sizeof (return_vals) / sizeof (return_vals[0]);
gimp_install_procedure ("plug_in_film",
"Compose several images to a roll film",
"Compose several images to a roll film",
"Peter Kirchgessner",
"Peter Kirchgessner (pkirchg@aol.com)",
"1997",
"<Image>/Filters/Darkroom/Film",
"INDEXED*, GRAY*, RGB*",
PROC_PLUG_IN,
nargs, nreturn_vals,
args, return_vals);
}
static void
run (char *name,
int nparams,
GParam *param,
int *nreturn_vals,
GParam **return_vals)
{
static GParam values[2];
GStatusType status = STATUS_SUCCESS;
gint32 image_ID;
int k;
run_mode = param[0].data.d_int32;
*nreturn_vals = 2;
*return_vals = values;
values[0].type = PARAM_STATUS;
values[0].data.d_status = status;
values[1].type = PARAM_IMAGE;
values[1].data.d_int32 = -1;
switch (run_mode)
{
case RUN_INTERACTIVE:
/* Possibly retrieve data */
gimp_get_data ("plug_in_film", &filmvals);
/* First acquire information with a dialog */
if (! film_dialog (param[1].data.d_int32))
return;
break;
case RUN_NONINTERACTIVE:
/* Make sure all the arguments are there! */
/* Also we want to have some images to compose */
if ((nparams != 12) || (param[10].data.d_int32 < 1))
status = STATUS_CALLING_ERROR;
if (status == STATUS_SUCCESS)
{
filmvals.film_height = param[3].data.d_int32;
filmvals.film_color[0] = param[4].data.d_color.red;
filmvals.film_color[1] = param[4].data.d_color.green;
filmvals.film_color[2] = param[4].data.d_color.blue;
filmvals.number_start = param[5].data.d_int32;
k = sizeof (filmvals.number_fontf);
strncpy (filmvals.number_fontf, param[6].data.d_string, k);
filmvals.number_fontf[k-1] = '\0';
filmvals.number_color[0] = param[7].data.d_color.red;
filmvals.number_color[1] = param[7].data.d_color.green;
filmvals.number_color[2] = param[7].data.d_color.blue;
filmvals.number_pos[0] = param[8].data.d_int32;
filmvals.number_pos[1] = param[9].data.d_int32;
filmvals.num_images = param[10].data.d_int32;
if (filmvals.num_images > MAX_FILM_PICTURES)
filmvals.num_images = MAX_FILM_PICTURES;
for (k = 0; k < filmvals.num_images; k++)
filmvals.image[k] = param[11].data.d_int32array[k];
}
break;
case RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data ("plug_in_film", &filmvals);
break;
default:
break;
}
if (check_filmvals () < 0)
status = STATUS_CALLING_ERROR;
if (status == STATUS_SUCCESS)
{
if (run_mode != RUN_NONINTERACTIVE)
gimp_progress_init ("Composing Images...");
image_ID = film ();
if (image_ID <= 0)
{
status = STATUS_EXECUTION_ERROR;
}
else
{
values[1].data.d_int32 = image_ID;
gimp_image_enable_undo (image_ID);
gimp_image_clean_all (image_ID);
if (run_mode != RUN_NONINTERACTIVE)
gimp_display_new (image_ID);
}
/* Store data */
if (run_mode == RUN_INTERACTIVE)
gimp_set_data ("plug_in_film", &filmvals, sizeof (FilmVals));
}
values[0].data.d_status = status;
}
/* Compose a roll film image from several images */
static gint32
film (void)
{
int width, height, tile_height, scan_lines;
unsigned char *dst, *hole;
int film_height, film_width;
int picture_width, picture_height, picture_space, picture_x0, picture_y0;
int hole_offset, hole_width, hole_height, hole_space, hole_x;
int number_height, num_images, num_pictures;
int i, j, k, picture_count;
double f;
guchar f_red, f_green, f_blue;
gint nreturn_vals, num_layers;
gint32 *image_ID_src, image_ID_dst, layer_ID_src, layer_ID_dst;
gint32 *layers;
GDrawable *drawable_dst;
GPixelRgn pixel_rgn_dst;
/* initialize */
layers = NULL;
num_images = filmvals.num_images;
image_ID_src = filmvals.image;
if (num_images <= 0)
return (-1);
tile_height = gimp_tile_height ();
/* Save foreground colour */
gimp_palette_get_foreground (&f_red, &f_green, &f_blue);
film_height = filmvals.film_height;
picture_height = film_height * filmvals.picture_height;
picture_space = film_height * filmvals.picture_space;
picture_y0 = (film_height - picture_height)/2;
number_height = film_height * filmvals.number_height;
/* Calculate total film width */
film_width = 0;
num_pictures = 0;
for (j = 0; j < num_images; j++)
{
layers = gimp_image_get_layers (image_ID_src[j], &num_layers);
/* Get scaled image size */
width = gimp_image_width (image_ID_src[j]);
height = gimp_image_height (image_ID_src[j]);
f = ((double)picture_height) / (double)height;
picture_width = width * f;
for (k = 0; k < num_layers; k++)
{
if (gimp_layer_is_floating_selection (layers[k]))
continue;
film_width += (picture_space/2); /* Leading space */
film_width += picture_width; /* Scaled image width */
film_width += (picture_space/2); /* Trailing space */
num_pictures++;
}
if (layers) g_free (layers);
}
#ifdef FILM_DEBUG
printf ("film_height = %d, film_width = %d\n", film_height, film_width);
printf ("picture_height = %d, picture_space = %d, picture_y0 = %d\n",
picture_height, picture_space, picture_y0);
printf ("Number of pictures = %d\n", num_pictures);
#endif
image_ID_dst = create_new_image ("Untitled", (guint)film_width,
(guint)film_height, RGB_IMAGE, &layer_ID_dst,
&drawable_dst, &pixel_rgn_dst);
dst = (unsigned char *)g_malloc (film_width * tile_height * 3);
if (dst == NULL) return (-1);
/* Fill film background */
i = 0;
while (i < film_height)
{
scan_lines = (i+tile_height-1 < film_height) ? tile_height : (film_height-i);
set_pixels (film_width*scan_lines, dst, filmvals.film_color);
gimp_pixel_rgn_set_rect (&pixel_rgn_dst, dst, 0, i,
film_width, scan_lines);
i += scan_lines;
}
g_free (dst);
/* Draw all the holes */
hole_offset = film_height * filmvals.hole_offset;
hole_width = film_height * filmvals.hole_width;
hole_height = film_height * filmvals.hole_height;
hole_space = film_height * filmvals.hole_space;
hole_x = hole_space / 2;
#ifdef FILM_DEBUG
printf ("hole_x %d hole_offset %d hole_width %d hole_height %d hole_space %d\n",
hole_x, hole_offset, hole_width, hole_height, hole_space );
#endif
hole = create_hole_rgb (hole_width, hole_height);
if (hole)
{
while (hole_x < film_width)
{
draw_hole_rgb (drawable_dst, hole_x, hole_offset,
hole_width, hole_height, hole);
draw_hole_rgb (drawable_dst, hole_x, film_height-hole_offset-hole_height,
hole_width, hole_height, hole);
hole_x += hole_width + hole_space;
}
g_free (hole);
}
gimp_drawable_detach (drawable_dst);
/* Compose all images and layers */
picture_x0 = 0;
picture_count = 0;
for (j = 0; j < num_images; j++)
{
width = gimp_image_width (image_ID_src[j]);
height = gimp_image_height (image_ID_src[j]);
f = ((double)picture_height) / (double)height;
picture_width = width * f;
layers = gimp_image_get_layers (image_ID_src[j], &num_layers);
for (k = 0; k < num_layers; k++)
{
if (gimp_layer_is_floating_selection (layers[k]))
continue;
picture_x0 += (picture_space/2);
layer_ID_src = layers[k];
/* Scale the layer and insert int new image */
if (scale_layer (layer_ID_src, 0, 0, width, height,
layer_ID_dst, picture_x0, picture_y0,
picture_width, picture_height) < 0)
{
printf ("film: error during scale_layer\n");
return (-1);
}
/* Draw picture numbers */
if ((number_height > 0)
&& (filmvals.number_pos[0] || filmvals.number_pos[1]))
{
gimp_palette_set_foreground (filmvals.number_color[0],
filmvals.number_color[1],
filmvals.number_color[2]);
if (filmvals.number_pos[0])
draw_number (layer_ID_dst, filmvals.number_start + picture_count,
picture_x0 + picture_width/2,
(hole_offset-number_height)/2, number_height);
if (filmvals.number_pos[1])
draw_number (layer_ID_dst, filmvals.number_start + picture_count,
picture_x0 + picture_width/2,
film_height - (hole_offset + number_height)/2,
number_height);
gimp_palette_set_foreground (f_red, f_green, f_blue);
}
picture_x0 += picture_width + (picture_space/2);
if (run_mode != RUN_NONINTERACTIVE)
gimp_progress_update (((double)(picture_count+1)) / (double)num_pictures);
picture_count++;
}
}
if (layers) g_free (layers);
/* Drawing text/numbers leaves us with a floating selection. Stop it */
gimp_run_procedure ("gimp_floating_sel_anchor", &nreturn_vals,
PARAM_LAYER, gimp_image_floating_selection (image_ID_dst),
PARAM_END);
/* Restore foreground */
gimp_palette_set_foreground (f_red, f_green, f_blue);
return image_ID_dst;
}
/* Check filmvals. Unreasonable values are reset to a default. */
/* If this is not possible, -1 is returned. Otherwise 0 is returned. */
static int
check_filmvals (void)
{
if (filmvals.film_height < 10) filmvals.film_height = 10;
if (filmvals.number_start < 0) filmvals.number_start = 0;
if (filmvals.number_fontf[0] == '\0')
strcpy (filmvals.number_fontf, "courier");
if (filmvals.num_images < 1) return (-1);
return (0);
}
/* Converts numpix pixels from src to RGB at dst */
static void convert_to_rgb (GDrawable *srcdrawable,
int numpix,
unsigned char *src,
unsigned char *dst)
{
register unsigned char *from = src, *to = dst;
register int k;
register guchar *cmap, *colour;
gint ncols;
switch (gimp_drawable_type (srcdrawable->id))
{
case RGB_IMAGE:
memcpy ((char *)dst, (char *)src, numpix*3);
break;
case RGBA_IMAGE:
from = src;
to = dst;
k = numpix;
while (k-- > 0)
{
*(to++) = *(from++); *(to++) = *(from++); *(to++) = *(from++);
from++;
}
break;
case GRAY_IMAGE:
from = src;
to = dst;
k = numpix;
while (k-- > 0)
{
to[0] = to[1] = to[2] = *(from++);
to += 3;
}
break;
case GRAYA_IMAGE:
from = src;
to = dst;
k = numpix;
while (k-- > 0)
{
to[0] = to[1] = to[2] = *from;
from += 2;
to += 3;
}
break;
case INDEXED_IMAGE:
case INDEXEDA_IMAGE:
cmap = gimp_image_get_cmap (gimp_drawable_image_id (srcdrawable->id),
&ncols);
if (cmap)
{
from = src;
to = dst;
k = numpix;
while (k-- > 0)
{
colour = cmap + 3*(int)(*from);
*(to++) = *(colour++);
*(to++) = *(colour++);
*(to++) = *(colour++);
from += srcdrawable->bpp;
}
}
break;
default:
printf ("convert_to_rgb: unknown image type\n");
break;
}
}
/* Assigns numpix pixels starting at dst with color r,g,b */
static void
set_pixels (int numpix,
unsigned char *dst,
unsigned char *rgb)
{register int k;
register unsigned char ur, ug, ub, *udest;
if ((rgb[0] == rgb[1]) && (rgb[1] == rgb[2]))
{
memset (dst, (int)rgb[0], numpix*3);
return;
}
ur = rgb[0];
ug = rgb[1];
ub = rgb[2];
k = numpix;
udest = dst;
while (k-- > 0)
{
*(udest++) = ur;
*(udest++) = ug;
*(udest++) = ub;
}
}
/* Scales a portion of a layer and places it in another layer. */
/* On success, 0 is returned. Otherwise -1 is returned */
static int scale_layer (gint32 src_layer,
int src_x0,
int src_y0,
int src_width,
int src_height,
gint32 dst_layer,
int dst_x0,
int dst_y0,
int dst_width,
int dst_height)
{
int tile_height, i, scan_lines, numpix;
unsigned char *src, *tmp = (unsigned char *)ident; /* Just to satisfy gcc */
gint32 tmp_image, tmp_layer;
GDrawable *tmp_drawable, *src_drawable, *dst_drawable;
GPixelRgn tmp_pixel_rgn, src_pixel_rgn, dst_pixel_rgn;
tile_height = gimp_tile_height ();
src_drawable = gimp_drawable_get (src_layer);
/*** Get a RGB copy of the source region ***/
tmp_image = create_new_image ("Temporary", src_width, src_height,
RGB_IMAGE, &tmp_layer, &tmp_drawable, &tmp_pixel_rgn);
src = (unsigned char *)g_malloc (src_width * tile_height * src_drawable->bpp);
tmp = (unsigned char *)g_malloc (src_width * tile_height * tmp_drawable->bpp);
if ((src == NULL) || (tmp == NULL)) return (-1);
gimp_pixel_rgn_init (&src_pixel_rgn, src_drawable, src_x0, src_y0,
src_width, src_height, FALSE, FALSE);
i = 0;
while (i < src_height)
{
scan_lines = (i+tile_height-1 < src_height) ? tile_height : (src_height-i);
numpix = scan_lines*src_width;
/* Get part of source image */
gimp_pixel_rgn_get_rect (&src_pixel_rgn, src, src_x0, src_y0+i,
src_width, scan_lines);
convert_to_rgb (src_drawable, numpix, src, tmp);
/* Set part of temporary image */
gimp_pixel_rgn_set_rect (&tmp_pixel_rgn, tmp, 0, i, src_width, scan_lines);
i += scan_lines;
}
/* Now we have an image that is a copy of the */
/* source region and has been converted to RGB. */
/* We dont need any more access to the source image. */
gimp_drawable_detach (src_drawable);
g_free ((char *)src);
/*** Resize the temporary image if necessary ***/
if ((src_width != dst_width) || (src_height != dst_height))
{
gimp_drawable_detach (tmp_drawable);
gimp_layer_scale (tmp_layer, dst_width, dst_height, 0);
tmp_drawable = gimp_drawable_get (tmp_layer);
}
/*** Copy temporary image to destination image */
gimp_pixel_rgn_init (&tmp_pixel_rgn, tmp_drawable, 0, 0,
dst_width, dst_height, FALSE, FALSE);
g_free ((char *)tmp);
tmp = (unsigned char *)g_malloc (dst_width * tile_height * tmp_drawable->bpp);
dst_drawable = gimp_drawable_get (dst_layer);
gimp_pixel_rgn_init (&dst_pixel_rgn, dst_drawable, dst_x0, dst_y0,
dst_width, dst_height, TRUE, FALSE);
i = 0;
while (i < dst_height)
{
scan_lines = (i+tile_height-1 < dst_height) ? tile_height : (dst_height-i);
/* Get strip of temporary image */
gimp_pixel_rgn_get_rect (&tmp_pixel_rgn, tmp, 0, i,
dst_width, scan_lines);
/* Set strip of destination image */
gimp_pixel_rgn_set_rect (&dst_pixel_rgn, tmp, dst_x0, dst_y0+i,
dst_width, scan_lines);
i += scan_lines;
}
/* No more access to the temporary image */
gimp_drawable_detach (tmp_drawable);
g_free ((char *)tmp);
gimp_image_delete (tmp_image);
gimp_drawable_detach (dst_drawable);
return (0);
}
/* Create the RGB-pixels that make up the hole */
static unsigned char *
create_hole_rgb (int width, int height)
{unsigned char *hole, *top, *bottom;
int radius, length, k;
hole =(unsigned char *)g_malloc (width*height*3);
if (hole)
{
/* Fill a rectangle with white */
memset (hole, 255, width*height*3);
radius = height / 4;
if (radius > width/2) radius = width/2;
top = hole;
bottom = hole + (height-1)*width*3;
for (k = radius-1; k > 0; k--) /* Rounding corners */
{
length = (int)(radius - sqrt ((double)(radius*radius - k*k)) - 0.5);
if (length > 0)
{
set_pixels (length, top, filmvals.film_color);
set_pixels (length, top+(width-length)*3, filmvals.film_color);
set_pixels (length, bottom, filmvals.film_color);
set_pixels (length, bottom+(width-length)*3, filmvals.film_color);
}
top += width*3;
bottom -= width*3;
}
}
return (hole);
}
/* Draw the hole at the specified position */
static void
draw_hole_rgb (GDrawable *drw,
int x,
int y,
int width,
int height,
unsigned char *hole)
{GPixelRgn rgn;
unsigned char *data;
int tile_height = gimp_tile_height ();
int i, j, scan_lines, d_width = gimp_drawable_width (drw->id);
int length;
if ((width <= 0) || (height <= 0))
return;
if ((x+width <= 0) || (x >= d_width))
return;
length = width; /* Check that we dont draw past the image */
if ((x+length) >= d_width)
length = d_width-x;
data = (unsigned char *)g_malloc (length * tile_height * drw->bpp);
if (data == NULL) return;
gimp_pixel_rgn_init (&rgn, drw, x, y, length, height, TRUE, FALSE);
i = 0;
while (i < height)
{
scan_lines = (i+tile_height-1 < height) ? tile_height : (height-i);
if (length == width)
{
memcpy (data, hole + 3*width*i, width*scan_lines*3);
}
else /* We have to do some clipping */
{
for (j = 0; j < scan_lines; j++)
memcpy (data + j*length*3, hole + (i+j)*width*3, length*3);
}
gimp_pixel_rgn_set_rect (&rgn, data, x, y+i, length, scan_lines);
i += scan_lines;
}
g_free (data);
}
/* Draw the number of the picture onto the film */
static void
draw_number (gint32 layer_ID,
int num,
int x,
int y,
int height)
{char buf[32];
GDrawable *drw;
GParam *params;
gint nreturn_vals;
gint32 image_ID, descent;
char *family = filmvals.number_fontf;
sprintf (buf, "%d", num);
drw = gimp_drawable_get (layer_ID);
image_ID = gimp_drawable_image_id (layer_ID);
/* Numbers dont need the descent. Inquire it and move the text down */
params = gimp_run_procedure ("gimp_text_get_extents", &nreturn_vals,
PARAM_STRING, buf,
PARAM_FLOAT, (gfloat)height,
PARAM_INT32, (gint32)0, /* use pixelsize */
PARAM_STRING, "*", /* foundry */
PARAM_STRING, family, /* family */
PARAM_STRING, "*", /* weight */
PARAM_STRING, "*", /* slant */
PARAM_STRING, "*", /* set_width */
PARAM_STRING, "*", /* spacing */
PARAM_END);
if (params[0].data.d_status == STATUS_SUCCESS)
descent = params[4].data.d_int32;
else
descent = 0;
params = gimp_run_procedure ("gimp_text", &nreturn_vals,
PARAM_IMAGE, image_ID,
PARAM_DRAWABLE, layer_ID,
PARAM_FLOAT, (gfloat)x,
PARAM_FLOAT, (gfloat)(y+descent/2),
PARAM_STRING, buf,
PARAM_INT32, (gint32)1, /* border */
PARAM_INT32, (gint32)0, /* antialias */
PARAM_FLOAT, (gfloat)height,
PARAM_INT32, (gint32)0, /* use pixelsize */
PARAM_STRING, "*", /* foundry */
PARAM_STRING, family, /* family */
PARAM_STRING, "*", /* weight */
PARAM_STRING, "*", /* slant */
PARAM_STRING, "*", /* set_width */
PARAM_STRING, "*", /* spacing */
PARAM_END);
if (params[0].data.d_status != STATUS_SUCCESS)
printf ("draw_number: Error in drawing text\n");
gimp_drawable_detach (drw);
}
/* Create an image. Sets layer_ID, drawable and rgn. Returns image_ID */
static gint32
create_new_image (char *filename,
guint width,
guint height,
GDrawableType gdtype,
gint32 *layer_ID,
GDrawable **drawable,
GPixelRgn *pixel_rgn)
{
gint32 image_ID;
GImageType gitype;
if ((gdtype == GRAY_IMAGE) || (gdtype == GRAYA_IMAGE))
gitype = GRAY;
else if ((gdtype == INDEXED_IMAGE) || (gdtype == INDEXEDA_IMAGE))
gitype = INDEXED;
else
gitype = RGB;
image_ID = gimp_image_new (width, height, gitype);
gimp_image_set_filename (image_ID, filename);
*layer_ID = gimp_layer_new (image_ID, "Background", width, height,
gdtype, 100, NORMAL_MODE);
gimp_image_add_layer (image_ID, *layer_ID, 0);
if (drawable != NULL)
{
*drawable = gimp_drawable_get (*layer_ID);
if (pixel_rgn != NULL)
gimp_pixel_rgn_init (pixel_rgn, *drawable, 0, 0, (*drawable)->width,
(*drawable)->height, TRUE, FALSE);
}
return (image_ID);
}
static char *
compose_image_name (gint32 image_ID)
{static char buffer[256];
char *filename, *basename;
filename = gimp_image_get_filename (image_ID);
if (filename == NULL) return ("");
/* Compose a name of the basename and the image-ID */
basename = strrchr (filename, '/');
if (basename == NULL)
basename = filename;
else
basename++;
sprintf (buffer, "%s-%ld", basename, (long)image_ID);
g_free (filename);
return (buffer);
}
static GtkWidget *
add_label_with_entry (char *label_text,
char *entry_text,
int tab_index,
GtkWidget *table)
{
GtkWidget *label;
GtkWidget *entry;
label = gtk_label_new (label_text);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, tab_index, tab_index+1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
entry = gtk_entry_new ();
gtk_widget_set_usize (entry, 60, 0);
gtk_entry_set_text (GTK_ENTRY (entry), entry_text);
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, tab_index, tab_index+1,
0, 0, 0, 0);
gtk_widget_show (entry);
return (entry);
}
static void
add_color_button (int csel_index,
int tab_index,
GtkWidget *table)
{
GtkWidget *label;
GtkWidget *button;
GtkWidget *preview;
label = gtk_label_new ("Color:");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, tab_index, tab_index+1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
button = filmint.csel[csel_index].activate = gtk_button_new ();
memcpy (&(filmint.csel[csel_index].color[0]),
(csel_index == 0) ? filmvals.film_color : filmvals.number_color, 3);
preview = filmint.csel[csel_index].preview = gtk_preview_new(GTK_PREVIEW_COLOR);
gtk_preview_size (GTK_PREVIEW (preview), filmint.prv_width,
filmint.prv_height);
gtk_container_add (GTK_CONTAINER (button), preview);
gtk_widget_show (preview);
color_preview_show (preview, &(filmint.csel[csel_index].color[0]));
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) film_color_button_callback,
(gpointer)csel_index);
gtk_table_attach (GTK_TABLE (table), button, 1, 2, tab_index, tab_index+1,
0, 0, 0, 0);
gtk_widget_show (button);
}
static void
add_list_item_callback (GtkWidget *widget,
GtkWidget *list)
{
GList *tmp_list;
GtkWidget *label;
GtkWidget *list_item;
gint32 image_ID;
tmp_list = GTK_LIST (list)->selection;
while (tmp_list)
{
if ((label = (GtkWidget *)tmp_list->data) != NULL)
{
image_ID = (gint32)gtk_object_get_user_data (GTK_OBJECT (label));
list_item = gtk_list_item_new_with_label (compose_image_name (image_ID));
gtk_object_set_user_data (GTK_OBJECT (list_item), (gpointer)image_ID);
gtk_container_add (GTK_CONTAINER (filmint.image_list_film), list_item);
gtk_widget_show (list_item);
}
tmp_list = tmp_list->next;
}
}
static void
del_list_item_callback (GtkWidget *widget,
GtkWidget *list)
{
GList *tmp_list;
GList *clear_list;
tmp_list = GTK_LIST (list)->selection;
clear_list = NULL;
while (tmp_list)
{
clear_list = g_list_prepend (clear_list, tmp_list->data);
tmp_list = tmp_list->next;
}
clear_list = g_list_reverse (clear_list);
gtk_list_remove_items (GTK_LIST (list), clear_list);
tmp_list = clear_list;
while (tmp_list)
{
gtk_widget_destroy (GTK_WIDGET (tmp_list->data));
tmp_list = tmp_list->next;
}
g_list_free (clear_list);
}
static GtkWidget *
add_image_list (int add_box_flag,
int n,
gint32 *image_id,
GtkWidget *box)
{
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *label;
GtkWidget *scrolled_win;
GtkWidget *list;
GtkWidget *list_item;
GtkWidget *button;
int i;
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (box), box1);
gtk_widget_show (box1);
box2 = gtk_vbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (box2), 0);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
label = gtk_label_new (add_box_flag ? "Available images:"
: "On film:");
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
gtk_widget_show (label);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (box2), scrolled_win, TRUE, TRUE, 0);
gtk_widget_show (scrolled_win);
list = gtk_list_new ();
gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_MULTIPLE);
gtk_list_set_selection_mode (GTK_LIST (list), GTK_SELECTION_BROWSE);
gtk_container_add (GTK_CONTAINER (scrolled_win), list);
gtk_widget_show (list);
for (i = 0; i < n; i++)
{
list_item = gtk_list_item_new_with_label (compose_image_name (image_id[i]));
gtk_object_set_user_data (GTK_OBJECT (list_item), (gpointer)image_id[i]);
gtk_container_add (GTK_CONTAINER (list), list_item);
gtk_widget_show (list_item);
}
button = gtk_button_new_with_label (add_box_flag ? "add -->" : "remove");
GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
add_box_flag ? (GtkSignalFunc) add_list_item_callback
: (GtkSignalFunc) del_list_item_callback,
list);
gtk_box_pack_start (GTK_BOX (box2), button, FALSE, TRUE, 0);
gtk_widget_show (button);
return (list);
}
static gint
film_dialog (gint32 image_ID)
{
GtkWidget *dlg;
GtkWidget *button;
GtkWidget *hbox, *h0box;
GtkWidget *table;
GtkWidget *frame;
GtkWidget *toggle;
GtkWidget *vbox, *v0box;
guchar *color_cube;
char buffer[80];
gint32 *image_id_list;
int nimages, j;
gchar **argv;
gint argc;
argc = 1;
argv = g_new (gchar *, 1);
argv[0] = g_strdup ("Film");
gtk_init (&argc, &argv);
gtk_rc_parse (gimp_gtkrc ());
gdk_set_use_xshm(gimp_use_xshm());
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());
filmint.dialog = dlg = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dlg), "Film");
gtk_window_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
(GtkSignalFunc) film_close_callback,
NULL);
/* Action area */
button = gtk_button_new_with_label ("OK");
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) film_ok_callback, dlg);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->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_object (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
GTK_OBJECT (dlg));
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->action_area), button,
TRUE, TRUE, 0);
gtk_widget_show (button);
/* parameter settings */
hbox = gtk_hbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (hbox), 0);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
/*** The frames on the left keep film options ***/
v0box = gtk_vbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (v0box), 0);
gtk_box_pack_start (GTK_BOX (hbox), v0box, TRUE, TRUE, 0);
gtk_widget_show (v0box);
/* Film height/colour */
frame = gtk_frame_new ("Film");
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (frame), 5);
gtk_box_pack_start (GTK_BOX (v0box), frame, TRUE, TRUE, 0);
vbox = gtk_vbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (vbox), 5);
gtk_container_add (GTK_CONTAINER (frame), vbox);
table = gtk_table_new (2, 2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 5);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
gtk_widget_show (table);
/* Film height */
sprintf (buffer, "%d", (int)filmvals.film_height);
filmint.left_entry[0] = add_label_with_entry ("Height:", buffer, 0, table);
/* Film colour */
add_color_button (0, 1, table);
gtk_widget_show (vbox);
gtk_widget_show (frame);
/* Film numbering: Startindex/Font/colour */
frame = gtk_frame_new ("Numbering");
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (frame), 5);
gtk_box_pack_start (GTK_BOX (v0box), frame, TRUE, TRUE, 0);
vbox = gtk_vbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (vbox), 5);
gtk_container_add (GTK_CONTAINER (frame), vbox);
table = gtk_table_new (3, 2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 5);
gtk_table_set_col_spacings (GTK_TABLE (table), 5);
gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0);
gtk_widget_show (table);
/* Startindex */
sprintf (buffer, "%d", (int)filmvals.number_start);
filmint.left_entry[1] = add_label_with_entry ("Startindex:", buffer, 0, table);
/* Fontfamily for numbering */
filmint.left_entry[2] = add_label_with_entry ("Font:", filmvals.number_fontf,
1, table);
/* Numbering colour */
add_color_button (1, 2, table);
for (j = 0; j < 2; j++)
{
toggle = gtk_check_button_new_with_label (j ? "at bottom" : "at top");
gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0);
filmint.number_pos[j] = filmvals.number_pos[j];
gtk_signal_connect (GTK_OBJECT (toggle), "toggled",
(GtkSignalFunc) numbering_toggle_update,
&(filmint.number_pos[j]));
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (toggle),
filmint.number_pos[j]);
gtk_widget_show (toggle);
}
gtk_widget_show (vbox);
gtk_widget_show (frame);
gtk_widget_show (v0box);
h0box = gtk_hbox_new (FALSE, 0);
gtk_container_border_width (GTK_CONTAINER (h0box), 0);
gtk_box_pack_start (GTK_BOX (hbox), h0box, TRUE, TRUE, 0);
gtk_widget_show (h0box);
/*** The right frame keeps the image selection ***/
frame = gtk_frame_new ("Image selection");
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width (GTK_CONTAINER (frame), 5);
gtk_box_pack_start (GTK_BOX (h0box), frame, TRUE, TRUE, 0);
hbox = gtk_hbox_new (FALSE, 5);
gtk_container_border_width (GTK_CONTAINER (hbox), 5);
gtk_container_add (GTK_CONTAINER (frame), hbox);
/* Get a list of all image names */
image_id_list = gimp_query_images (&nimages);
filmint.image_list_all = add_image_list (1, nimages, image_id_list, hbox);
/* Get a list of the images used for the film */
filmint.image_list_film = add_image_list (0, 1, &image_ID, hbox);
gtk_widget_show (hbox);
gtk_widget_show (frame);
gtk_widget_show (h0box);
gtk_widget_show (dlg);
gtk_main ();
gdk_flush ();
return filmint.run;
}
static void
film_close_callback (GtkWidget *widget,
gpointer data)
{
gtk_main_quit ();
}
static void
film_color_button_callback (GtkWidget *widget,
gpointer data)
{int idx, j;
GtkColorSelectionDialog *csd;
GtkWidget *dialog;
gdouble colour[3];
idx = (int)data;
/* Is the colour selection dialog already running ? */
if (filmint.csel[idx].colselect != NULL) return;
for (j = 0; j < 3; j++)
colour[j] = filmint.csel[idx].color[j] / 255.0;
dialog = filmint.csel[idx].colselect = gtk_color_selection_dialog_new (
(idx == 0) ? "Films color Color Picker"
: "Numbers color Color Picker");
csd = GTK_COLOR_SELECTION_DIALOG (dialog);
gtk_widget_destroy (csd->help_button);
gtk_signal_connect (GTK_OBJECT (dialog), "destroy",
(GtkSignalFunc) color_select_cancel_callback, data);
gtk_signal_connect (GTK_OBJECT (csd->ok_button), "clicked",
(GtkSignalFunc) color_select_ok_callback, data);
gtk_signal_connect (GTK_OBJECT (csd->cancel_button), "clicked",
(GtkSignalFunc) color_select_cancel_callback, data);
gtk_color_selection_set_color (GTK_COLOR_SELECTION (csd->colorsel), colour);
gtk_window_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
gtk_widget_show (dialog);
}
static void
film_ok_callback (GtkWidget *widget,
gpointer data)
{int v, num_images;
char *s;
GtkWidget *dialog;
GtkWidget *label;
GList *tmp_list;
gint32 image_ID;
/* Read film height */
s = gtk_entry_get_text (GTK_ENTRY (filmint.left_entry[0]));
if ((sscanf (s, "%d", &v) == 1) && (v > 9))
filmvals.film_height = v;
/* Read numbers start index */
s = gtk_entry_get_text (GTK_ENTRY (filmint.left_entry[1]));
if ((sscanf (s, "%d", &v) == 1) && (v >= 0))
filmvals.number_start = v;
/* Read font family */
s = gtk_entry_get_text (GTK_ENTRY (filmint.left_entry[2]));
if (strlen (s) > 0)
{
strncpy (filmvals.number_fontf, s, sizeof (filmvals.number_fontf));
filmvals.number_fontf[sizeof (filmvals.number_fontf)-1] = '\0';
}
/* Read film color */
memcpy (filmvals.film_color, &(filmint.csel[0].color[0]), 3);
/* Read numbers color */
memcpy (filmvals.number_color, &(filmint.csel[1].color[0]), 3);
/* Read positioning of numbers */
filmvals.number_pos[0] = filmint.number_pos[0];
filmvals.number_pos[1] = filmint.number_pos[1];
/* Read image list */
num_images = 0;
if (filmint.image_list_film != NULL)
{
tmp_list = GTK_LIST (filmint.image_list_film)->children;
while (tmp_list)
{
if ((label = (GtkWidget *)tmp_list->data) != NULL)
{
image_ID = (gint32)gtk_object_get_user_data (GTK_OBJECT (label));
if ((image_ID > 0) && (num_images < MAX_FILM_PICTURES))
filmvals.image[num_images++] = image_ID;
}
tmp_list = tmp_list->next;
}
filmvals.num_images = num_images;
}
for (v = 0; v < sizeof(filmint.csel)/sizeof (filmint.csel[0]); v++)
{
if ((dialog = filmint.csel[v].colselect) != NULL)
{
filmint.csel[v].colselect = NULL;
gtk_widget_destroy (GTK_WIDGET (dialog));
}
}
filmint.run = TRUE;
gtk_widget_destroy (GTK_WIDGET (data));
}
static void
numbering_toggle_update (GtkWidget *widget,
gpointer data)
{
int *toggle_val;
toggle_val = (int *) data;
*toggle_val = ((GTK_TOGGLE_BUTTON (widget)->active) != 0);
}
static void
color_select_ok_callback (GtkWidget *widget,
gpointer data)
{gdouble color[3];
int idx, j;
GtkWidget *dialog;
idx = (int)data;
if ((dialog = filmint.csel[idx].colselect) == NULL) return;
gtk_color_selection_get_color (
GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (dialog)->colorsel),
color);
for (j = 0; j < 3; j++)
filmint.csel[idx].color[j] = (unsigned char)(color[j]*255.0);
color_preview_show (filmint.csel[idx].preview, &(filmint.csel[idx].color[0]));
filmint.csel[idx].colselect = NULL;
gtk_widget_destroy (dialog);
}
static void
color_select_cancel_callback (GtkWidget *widget,
gpointer data)
{int idx;
GtkWidget *dialog;
idx = (int)data;
if ((dialog = filmint.csel[idx].colselect) == NULL) return;
filmint.csel[idx].colselect = NULL;
gtk_widget_destroy (dialog);
}
static void
color_preview_show (GtkWidget *widget,
unsigned char *rgb)
{guchar *buf, *bp;
int j, width, height;
width = filmint.prv_width;
height = filmint.prv_height;
bp = buf = g_malloc (width*3);
if (buf == NULL) return;
for (j = 0; j < width; j++)
{
*(bp++) = rgb[0];
*(bp++) = rgb[1];
*(bp++) = rgb[2];
}
for (j = 0; j < height; j++)
gtk_preview_draw_row (GTK_PREVIEW (widget), buf, 0, j, width);
gtk_widget_draw (widget, NULL);
g_free (buf);
}
Reference in New Issue View Git Blame Copy Permalink