graphics/gimp
graphics/gimp
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/gimp synced 2024-10-19 14:23:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added the rcm plugin.

Browse source 
--Sven
This commit is contained in:
Sven Neumann 1999-04-05 20:31:20 +00:00
parent 24ffa60f1b
commit 4c3308411d
16 changed files with 3301 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
ChangeLog
View file

@ -1,3 +1,11 @@
Mon Apr 5 22:28:01 MEST 1999 Sven Neumann <sven@gimp.org>
* configure.in
* plug-ins/Makefile.am
* plug-ins/rcm: Added RotateColorMap plug-in. This is a rewrite
of the original plug-in by Pavel Grinfeld done by Sven Anders
(anderss@fmi.uni-passau.de)
1999-04-05 Michael Natterer <mitschel@cs.tu-berlin.de>
* app/action_area.h: #include <gtk/gtk.h>.

1
configure.in
View file

@ -783,6 +783,7 @@ plug-ins/print/Makefile
plug-ins/ps/Makefile
plug-ins/psd/Makefile
plug-ins/randomize/Makefile
plug-ins/rcm/Makefile
plug-ins/ripple/Makefile
plug-ins/rotate/Makefile
plug-ins/rotators/Makefile

1
plug-ins/Makefile.am
View file

@ -111,6 +111,7 @@ SUBDIRS = \
ps \
psd \
randomize \
rcm \
ripple \
rotate \
rotators \

6
plug-ins/rcm/.cvsignore Normal file
View file

@ -0,0 +1,6 @@
Makefile.in
Makefile
.deps
_libs
.libs
rcm

39
plug-ins/rcm/Makefile.am Normal file
View file

@ -0,0 +1,39 @@
## Process this file with automake to produce Makefile.in
pluginlibdir = $(gimpplugindir)/plug-ins
pluginlib_PROGRAMS = rcm
rcm_SOURCES = \
rcm.c \
rcm_dialog.c \
rcm_callback.c \
rcm_gdk.c \
rcm_misc.c
INCLUDES = \
-I$(top_srcdir) \
$(GTK_CFLAGS) \
-I$(includedir)
LDADD = \
$(top_builddir)/libgimp/libgimp.la \
$(GTK_LIBS)
DEPS = \
$(top_builddir)/libgimp/libgimp.la
rcm_DEPENDENCIES = $(DEPS)
.PHONY: files
files:
@files=`ls $(DISTFILES) 2> /dev/null`; for p in $$files; do \
echo $$p; \
done
@for subdir in $(SUBDIRS); do \
files=`cd $$subdir; $(MAKE) files | grep -v "make\[[1-9]\]"`; \
for file in $$files; do \
echo $$subdir/$$file; \
done; \
done

278
plug-ins/rcm/rcm.c Normal file
View file

@ -0,0 +1,278 @@
/*
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This is a plug-in for the GIMP.
*
* Colormap-Rotation plug-in. Exchanges two color ranges.
*
* Copyright (C) 1999 Sven Anders (anderss@fmi.uni-passau.de)
* Based on code from Pavel Grinfeld (pavel@ml.com)
*
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/*-----------------------------------------------------------------------------------
* Change log:
*
* Version 2.0, 04 April 1999.
* Nearly complete rewrite, made plug-in stable.
* (Works with GIMP 1.1 and GTK+ 1.2)
*
* Version 1.0, 27 March 1997.
* Initial (unstable) release by Pavel Grinfeld
*
*-----------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpintl.h>
#include "rcm.h"
#include "rcm_misc.h"
#include "rcm_dialog.h"
#include "rcm_callback.h"
/*-----------------------------------------------------------------------------------*/
/* Forward declarations */
/*-----------------------------------------------------------------------------------*/
void query(void);
void run(char *name, int nparams, GParam *param, int *nreturn_vals, GParam **return_vals);
/*-----------------------------------------------------------------------------------*/
/* Global variables */
/*-----------------------------------------------------------------------------------*/
RcmParams Current =
{
SELECTION, /* SELECTION ONLY */
TRUE, /* REAL TIME */
FALSE, /* SUCCESS */
RADIANS_OVER_PI, /* START IN RADIANS OVER PI */
GRAY_TO
};
/*-----------------------------------------------------------------------------------*/
/* Local variables */
/*-----------------------------------------------------------------------------------*/
GPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
/*-----------------------------------------------------------------------------------*/
/* Dummy function */
/*-----------------------------------------------------------------------------------*/
MAIN();
/*-----------------------------------------------------------------------------------*/
/* Query plug-in */
/*-----------------------------------------------------------------------------------*/
void query(void)
{
GParamDef args[] =
{
{ PARAM_INT32, "run_mode", "Interactive, non-interactive" },
{ PARAM_IMAGE, "image", "Input image (used for indexed images)" },
{ PARAM_DRAWABLE, "drawable", "Input drawable" },
};
GParamDef *return_vals = NULL;
int nargs = sizeof (args) / sizeof (args[0]);
int nreturn_vals = 0;
gimp_install_procedure ("Colormap rotation plug-in",
"Colormap rotation as in xv",
"Exchanges two color ranges. "\
"Based on code from Pavel Grinfeld (pavel@ml.com). "\
"This version written by Sven Anders (anderss@fmi.uni-passau.de).",
"Sven Anders (anderss@fmi.uni-passau.de) and Pavel Grinfeld (pavel@ml.com)",
"Sven Anders (anderss@fmi.uni-passau.de)",
"04th April 1999",
"<Image>/Filters/Darkroom/Colormap Rotation",
"RGB*",
PROC_PLUG_IN,
nargs, nreturn_vals,
args, return_vals);
}
/*-----------------------------------------------------------------------------------*/
/* Rotate colormap of a single row */
/*-----------------------------------------------------------------------------------*/
void rcm_row(const guchar *src_row, guchar *dest_row,
gint row, gint row_width, gint bytes)
{
gint col, bytenum, skip;
hsv H,S,V,R,G,B;
for (col=0; col < row_width; col++)
{
skip = 0;
R = (float)src_row[col*bytes + 0]/255.0;
G = (float)src_row[col*bytes + 1]/255.0;
B = (float)src_row[col*bytes + 2]/255.0;
rgb_to_hsv(R,G,B, &H,&S,&V);
if (rcm_is_gray(S))
{
if (Current.Gray_to_from == GRAY_FROM)
{
if (rcm_angle_inside_slice(Current.Gray->hue,Current.From->angle) <= 1)
{
H = Current.Gray->hue / TP;
S = Current.Gray->satur;
}
else
{
skip = 1;
}
}
else
{
skip = 1;
hsv_to_rgb(Current.Gray->hue/TP, Current.Gray->satur, V, &R, &G, &B);
}
}
if (!skip)
{
H = rcm_linear(rcm_left_end(Current.From->angle),
rcm_right_end(Current.From->angle),
rcm_left_end(Current.To->angle),
rcm_right_end(Current.To->angle),
H*TP);
H = angle_mod_2PI(H) / TP;
hsv_to_rgb(H,S,V, &R,&G,&B);
}
dest_row[col*bytes +0] = R * 255;
dest_row[col*bytes +1] = G * 255;
dest_row[col*bytes +2] = B * 255;
if (bytes > 3)
{
for (bytenum=3; bytenum<bytes; bytenum++)
dest_row[col*bytes+bytenum] = src_row[col*bytes+bytenum];
}
}
}
/*-----------------------------------------------------------------------------------*/
/* Rotate colormap row by row ... */
/*-----------------------------------------------------------------------------------*/
void rcm(GDrawable *drawable)
{
GPixelRgn srcPR, destPR;
gint width, height;
gint bytes;
guchar *src_row, *dest_row;
gint row;
gint x1, y1, x2, y2;
gimp_drawable_mask_bounds (drawable->id, &x1, &y1, &x2, &y2);
width = drawable->width;
height = drawable->height;
bytes = drawable->bpp;
src_row = (guchar *) malloc ((x2 - x1) * bytes);
dest_row = (guchar *) malloc ((x2 - x1) * bytes);
gimp_pixel_rgn_init(&srcPR, drawable, 0, 0, width, height, FALSE, FALSE);
gimp_pixel_rgn_init(&destPR, drawable, 0, 0, width, height, TRUE, TRUE);
for (row=y1; row < y2; row++)
{
gimp_pixel_rgn_get_row(&srcPR, src_row, x1, row, (x2 - x1));
rcm_row(src_row, dest_row, row, (x2 - x1), bytes);
gimp_pixel_rgn_set_row(&destPR, dest_row, x1, row, (x2 - x1));
if ((row % 10) == 0)
gimp_progress_update((double) row / (double) (y2 - y1));
}
/* update the processed region */
gimp_drawable_flush(drawable);
gimp_drawable_merge_shadow(drawable->id, TRUE);
gimp_drawable_update(drawable->id, x1, y1, (x2 - x1), (y2 - y1));
free (src_row);
free (dest_row);
}
/*-----------------------------------------------------------------------------------*/
/* STANDARD RUN */
/*-----------------------------------------------------------------------------------*/
void run(char *name, int nparams, GParam *param, int *nreturn_vals, GParam **return_vals)
{
GParam values[1];
GStatusType status = STATUS_SUCCESS;
*nreturn_vals = 1;
*return_vals = values;
values[0].type = PARAM_STATUS;
values[0].data.d_status = status;
Current.drawable = gimp_drawable_get(param[2].data.d_drawable);
Current.mask = gimp_drawable_get(gimp_image_get_selection(param[1].data.d_image));
/* works not on INDEXED images */
if (gimp_drawable_indexed (Current.drawable->id) ||
gimp_drawable_gray (Current.drawable->id) )
{
status = STATUS_EXECUTION_ERROR;
}
else
{
/* call dialog and rotate the colormap */
if (gimp_drawable_color(Current.drawable->id) && rcm_dialog())
{
gimp_progress_init(_("Rotating the colormap..."));
gimp_tile_cache_ntiles(2 * (Current.drawable->width / gimp_tile_width() + 1));
rcm(Current.drawable);
gimp_displays_flush();
}
else
status = STATUS_EXECUTION_ERROR;
}
values[0].data.d_status = status;
if (status == STATUS_SUCCESS)
gimp_drawable_detach(Current.drawable);
}

148
plug-ins/rcm/rcm.h Normal file
View file

@ -0,0 +1,148 @@
/*
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This is a plug-in for the GIMP.
*
* Colormap-Rotation plug-in. Exchanges two color ranges.
*
* Copyright (C) 1999 Sven Anders (anderss@fmi.uni-passau.de)
* Based on code from Pavel Grinfeld (pavel@ml.com)
*
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/*-----------------------------------------------------------------------------------
* Change log:
*
* Version 2.0, 04 April 1999.
* Nearly complete rewrite, made plug-in stable.
* (Works with GIMP 1.1 and GTK+ 1.2)
*
* Version 1.0, 27 March 1997.
* Initial (unstable) release by Pavel Grinfeld
*
*-----------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------*/
/* Global defines */
/*-----------------------------------------------------------------------------------*/
#ifndef PI
#define PI 3.14159265358979323846
#endif
#define TP (2*PI)
/*-----------------------------------------------------------------------------------*/
/* Typedefs */
/*-----------------------------------------------------------------------------------*/
enum { ENTIRE_IMAGE, SELECTION, SELECTION_IN_CONTEXT, PREVIEW_OPTIONS };
enum { EACH, BOTH, DEGREES, RADIANS, RADIANS_OVER_PI,
GRAY_FROM, GRAY_TO, CURRENT, ORIGINAL };
typedef enum { VIRGIN, DRAG_START, DRAGING, DO_NOTHING } RcmOp;
typedef double hsv;
typedef struct
{
float alpha;
float beta;
int cw_ccw;
} RcmAngle;
typedef struct
{
gint width;
gint height;
guchar *rgb;
hsv *hsv;
guchar *mask;
} ReducedImage;
typedef struct
{
GtkWidget *preview;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *cw_ccw_button;
GtkWidget *cw_ccw_box;
GtkWidget *cw_ccw_label;
GtkWidget *cw_ccw_pixmap;
GtkWidget *a_b_button;
GtkWidget *a_b_box;
GtkWidget *a_b_pixmap;
GtkWidget *f360_button;
GtkWidget *f360_box;
GtkWidget *f360_pixmap;
GtkWidget *alpha_entry;
GtkWidget *alpha_units_label;
GtkWidget *beta_entry;
GtkWidget *beta_units_label;
gfloat *target;
gint mode;
RcmAngle *angle;
RcmOp action_flag;
gfloat prev_clicked;
} RcmCircle;
typedef struct
{
GtkWidget *dlg;
GtkWidget *bna_frame;
GtkWidget *before;
GtkWidget *after;
} RcmBna;
typedef struct
{
GtkWidget *preview;
GtkWidget *frame;
float gray_sat;
float hue;
float satur;
GtkWidget *gray_sat_entry;
GtkWidget *hue_entry;
GtkWidget *hue_units_label;
GtkWidget *satur_entry;
RcmOp action_flag;
} RcmGray;
typedef struct
{
gint Slctn;
gint RealTime;
gint Success;
gint Units;
gint Gray_to_from;
GDrawable *drawable;
GDrawable *mask;
ReducedImage *reduced;
RcmCircle *To;
RcmCircle *From;
RcmGray *Gray;
RcmBna *Bna;
} RcmParams;
/*-----------------------------------------------------------------------------------*/
/* Global variables */
/*-----------------------------------------------------------------------------------*/
extern RcmParams Current;
/*-----------------------------------------------------------------------------------*/

745
plug-ins/rcm/rcm_callback.c Normal file
View file

@ -0,0 +1,745 @@
/*
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This is a plug-in for the GIMP.
*
* Colormap-Rotation plug-in. Exchanges two color ranges.
*
* Copyright (C) 1999 Sven Anders (anderss@fmi.uni-passau.de)
* Based on code from Pavel Grinfeld (pavel@ml.com)
*
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/*-----------------------------------------------------------------------------------
* Change log:
*
* Version 2.0, 04 April 1999.
* Nearly complete rewrite, made plug-in stable.
* (Works with GIMP 1.1 and GTK+ 1.2)
*
* Version 1.0, 27 March 1997.
* Initial (unstable) release by Pavel Grinfeld
*
*-----------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpintl.h>
#include "rcm.h"
#include "rcm_misc.h"
#include "rcm_gdk.h"
#include "rcm_dialog.h"
#include "rcm_pixmaps.h"
#include "rcm_callback.h"
/*-----------------------------------------------------------------------------------*/
/* Misc functions */
/*-----------------------------------------------------------------------------------*/
float rcm_units_factor(gint units)
{
switch (units)
{
case DEGREES: return 180.0/PI;
case RADIANS: return 1.0;
case RADIANS_OVER_PI: return 1.0/PI;
default: return -1;
}
}
gchar *rcm_units_string(gint units)
{
switch (units)
{
case DEGREES: return "deg";
case RADIANS: return "rad";
case RADIANS_OVER_PI: return "rad/pi";
default: return "(???)";
}
}
void rcm_set_pixmap(GtkWidget **widget, GtkWidget *parent,
GtkWidget *label_box, char **pixmap_data)
{
GdkPixmap *pixmap;
GdkBitmap *mask;
GtkStyle *style;
/* create pixmap */
style = gtk_widget_get_style(parent);
pixmap = gdk_pixmap_create_from_xpm_d(parent->window, &mask,
&style->bg[GTK_STATE_NORMAL], pixmap_data);
if (*widget != NULL)
{
gtk_widget_destroy(*widget);
}
*widget = gtk_pixmap_new(pixmap, mask);
gtk_box_pack_start(GTK_BOX(label_box), *widget, FALSE, FALSE, 3);
gtk_widget_show(*widget);
}
/*-----------------------------------------------------------------------------------*/
/* Ok/Cancel Buttons */
/*-----------------------------------------------------------------------------------*/
void rcm_close_callback(GtkWidget *widget, gpointer data)
{
gtk_main_quit();
}
void rcm_ok_callback(GtkWidget *widget, gpointer data)
{
gtk_widget_destroy(GTK_WIDGET(data));
Current.Success = 1;
}
/*-----------------------------------------------------------------------------------*/
/* Circle buttons */
/*-----------------------------------------------------------------------------------*/
void rcm_360_degrees(GtkWidget *button, RcmCircle *circle)
{
circle->action_flag = DO_NOTHING;
gtk_widget_draw(circle->preview, NULL);
circle->angle->beta = circle->angle->alpha-circle->angle->cw_ccw * 0.001;
rcm_draw_arrows(circle->preview->window, circle->preview->style->black_gc, circle->angle);
circle->action_flag = VIRGIN;
rcm_render_preview(Current.Bna->after, CURRENT);
}
void rcm_cw_ccw(GtkWidget *button, RcmCircle *circle)
{
circle->angle->cw_ccw *= -1;
rcm_set_pixmap(&circle->cw_ccw_pixmap, circle->cw_ccw_button->parent,
circle->cw_ccw_box, (circle->angle->cw_ccw>0) ? rcm_cw : rcm_ccw);
gtk_label_set(GTK_LABEL(circle->cw_ccw_label),
(circle->angle->cw_ccw>0) ? _("Switch to clockwise") : _("Switch to c/clockwise"));
rcm_a_to_b(button, circle);
}
void rcm_a_to_b(GtkWidget *button, RcmCircle *circle)
{
circle->action_flag = DO_NOTHING;
gtk_widget_draw(circle->preview, NULL);
SWAP(circle->angle->alpha, circle->angle->beta);
rcm_draw_arrows(circle->preview->window, circle->preview->style->black_gc,
circle->angle);
circle->action_flag = VIRGIN;
rcm_render_preview(Current.Bna->after, CURRENT);
}
/*-----------------------------------------------------------------------------------*/
/* Misc: units buttons */
/*-----------------------------------------------------------------------------------*/
static void rcm_spinbutton_to_degrees(GtkWidget *button, float value, GtkWidget *label)
{
GtkAdjustment *adj;
adj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(button));
adj->value = value * rcm_units_factor(Current.Units);
adj->upper = 360.0;
adj->step_increment = 0.01;
adj->page_increment = 1.0;
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(button), 2);
gtk_label_set(GTK_LABEL(label), rcm_units_string(Current.Units));
}
void rcm_switch_to_degrees(GtkWidget *button, gpointer *value)
{
if (GTK_TOGGLE_BUTTON(button)->active)
{
Current.Units = DEGREES;
rcm_spinbutton_to_degrees(Current.From->alpha_entry,
Current.From->angle->alpha,
Current.From->alpha_units_label);
rcm_spinbutton_to_degrees(Current.From->beta_entry,
Current.From->angle->beta,
Current.From->beta_units_label);
rcm_spinbutton_to_degrees(Current.To->alpha_entry,
Current.To->angle->alpha,
Current.To->alpha_units_label);
rcm_spinbutton_to_degrees(Current.To->beta_entry,
Current.To->angle->beta,
Current.To->beta_units_label);
rcm_spinbutton_to_degrees(Current.Gray->hue_entry,
Current.Gray->hue,
Current.Gray->hue_units_label);
Current.From->action_flag = VIRGIN;
Current.To->action_flag = VIRGIN;
Current.Gray->action_flag = VIRGIN;
}
}
/*-----------------------------------------------------------------------------------*/
static void rcm_spinbutton_to_radians(GtkWidget *button, float value, GtkWidget *label)
{
GtkAdjustment *adj;
adj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(button));
adj->value = value * rcm_units_factor(Current.Units);
adj->upper = TP;
adj->step_increment = 0.0001;
adj->page_increment = 0.001;
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(button), 4);
gtk_label_set(GTK_LABEL(label), rcm_units_string(Current.Units));
}
void rcm_switch_to_radians(GtkWidget *button, gpointer *value)
{
if (GTK_TOGGLE_BUTTON(button)->active)
{
Current.Units = RADIANS;
rcm_spinbutton_to_radians(Current.From->alpha_entry,
Current.From->angle->alpha,
Current.From->alpha_units_label);
rcm_spinbutton_to_radians(Current.From->beta_entry,
Current.From->angle->beta,
Current.From->beta_units_label);
rcm_spinbutton_to_radians(Current.To->alpha_entry,
Current.To->angle->alpha,
Current.To->alpha_units_label);
rcm_spinbutton_to_radians(Current.To->beta_entry,
Current.To->angle->beta,
Current.To->beta_units_label);
rcm_spinbutton_to_radians(Current.Gray->hue_entry,
Current.Gray->hue,
Current.Gray->hue_units_label);
Current.From->action_flag = VIRGIN;
Current.To->action_flag = VIRGIN;
Current.Gray->action_flag = VIRGIN;
}
}
/*-----------------------------------------------------------------------------------*/
static void rcm_spinbutton_to_radians_over_PI(GtkWidget *button, float value, GtkWidget *label)
{
GtkAdjustment *adj;
adj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(button));
adj->value = value * rcm_units_factor(Current.Units);
adj->upper = 2.0;
adj->step_increment = 0.0001;
adj->page_increment = 0.001;
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(button), 4);
gtk_label_set(GTK_LABEL(label), rcm_units_string(Current.Units));
}
void rcm_switch_to_radians_over_PI(GtkWidget *button, gpointer *value)
{
if (GTK_TOGGLE_BUTTON(button)->active)
{
Current.Units = RADIANS_OVER_PI;
rcm_spinbutton_to_radians_over_PI(Current.From->alpha_entry,
Current.From->angle->alpha,
Current.From->alpha_units_label);
rcm_spinbutton_to_radians_over_PI(Current.From->beta_entry,
Current.From->angle->beta,
Current.From->beta_units_label);
rcm_spinbutton_to_radians_over_PI(Current.To->alpha_entry,
Current.To->angle->alpha,
Current.To->alpha_units_label);
rcm_spinbutton_to_radians_over_PI(Current.To->beta_entry,
Current.To->angle->beta,
Current.To->beta_units_label);
rcm_spinbutton_to_radians_over_PI(Current.Gray->hue_entry,
Current.Gray->hue,
Current.Gray->hue_units_label);
Current.From->action_flag = VIRGIN;
Current.To->action_flag = VIRGIN;
Current.Gray->action_flag = VIRGIN;
}
}
/*-----------------------------------------------------------------------------------*/
/* Misc: Gray: mode buttons */
/*-----------------------------------------------------------------------------------*/
void rcm_switch_to_gray_to(GtkWidget *button, gpointer *value)
{
if (!GTK_TOGGLE_BUTTON(button)->active) return;
Current.Gray_to_from = GRAY_TO;
rcm_render_preview(Current.Bna->after, CURRENT);
}
void rcm_switch_to_gray_from(GtkWidget *button, gpointer *value)
{
if (!(GTK_TOGGLE_BUTTON(button)->active)) return;
Current.Gray_to_from = GRAY_FROM;
rcm_render_preview(Current.Bna->after, CURRENT);
}
/*-----------------------------------------------------------------------------------*/
/* Misc: Preview buttons */
/*-----------------------------------------------------------------------------------*/
void rcm_preview_as_you_drag(GtkWidget *button, gpointer *value)
{
if (GTK_TOGGLE_BUTTON(button)->active)
Current.RealTime = TRUE;
else
Current.RealTime = FALSE;
}
/*-----------------------------------------------------------------------------------*/
static void rcm_change_preview(void)
{
/* must hide and show or resize would not work ... */
gtk_widget_hide(Current.Bna->before);
gtk_widget_hide(Current.Bna->after);
gtk_preview_size(GTK_PREVIEW(Current.Bna->before),
Current.reduced->width, Current.reduced->height);
gtk_preview_size(GTK_PREVIEW(Current.Bna->after),
Current.reduced->width, Current.reduced->height);
rcm_render_preview(Current.Bna->before, ORIGINAL);
rcm_render_preview(Current.Bna->after, CURRENT);
gtk_widget_draw(Current.Bna->before, NULL);
gtk_widget_draw(Current.Bna->after, NULL);
gtk_widget_show(Current.Bna->before);
gtk_widget_show(Current.Bna->after);
}
/*-----------------------------------------------------------------------------------*/
void rcm_selection_in_context(GtkWidget *button, gpointer *value)
{
Current.reduced = rcm_reduce_image(Current.drawable, Current.mask,
MAX_PREVIEW_SIZE, SELECTION_IN_CONTEXT);
rcm_change_preview();
}
void rcm_selection(GtkWidget *button, gpointer *value)
{
Current.reduced = rcm_reduce_image(Current.drawable, Current.mask,
MAX_PREVIEW_SIZE, SELECTION);
rcm_change_preview();
}
void rcm_entire_image(GtkWidget *button, gpointer *value)
{
Current.reduced = rcm_reduce_image(Current.drawable, Current.mask,
MAX_PREVIEW_SIZE, ENTIRE_IMAGE);
rcm_change_preview();
}
/*-----------------------------------------------------------------------------------*/
/* Circle events */
/*-----------------------------------------------------------------------------------*/
gint rcm_expose_event(GtkWidget *widget, GdkEvent *event, RcmCircle *circle)
{
switch (circle->action_flag)
{
case DO_NOTHING: return 0;
case VIRGIN: rcm_draw_arrows(widget->window, widget->style->black_gc,
circle->angle);
break;
default: if (Current.RealTime)
rcm_render_preview(Current.Bna->after,CURRENT);
break;
}
return 1;
}
/*-----------------------------------------------------------------------------------*/
gint rcm_button_press_event(GtkWidget *widget, GdkEvent *event, RcmCircle *circle)
{
float clicked_angle;
float *alpha;
float *beta;
GdkEventButton *bevent;
alpha = &(circle->angle->alpha);
beta = &(circle->angle->beta);
bevent = (GdkEventButton *) event;
circle->action_flag = DRAG_START;
clicked_angle = angle_mod_2PI(arctg(CENTER-bevent->y, bevent->x-CENTER));
circle->prev_clicked = clicked_angle;
if ( (sqrt(sqr(bevent->y-CENTER) + sqr(bevent->x-CENTER)) > RADIUS * EACH_OR_BOTH) &&
(min_prox( *alpha, *beta, clicked_angle) < PI/12) )
{
circle->mode = EACH;
circle->target = closest(alpha, beta, clicked_angle);
if (*(circle->target) != clicked_angle)
{
*(circle->target) = clicked_angle;
gtk_widget_draw(circle->preview, NULL);
rcm_draw_arrows(widget->window, widget->style->black_gc, circle->angle);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(circle->alpha_entry),
circle->angle->alpha * rcm_units_factor(Current.Units));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(circle->beta_entry),
circle->angle->beta * rcm_units_factor(Current.Units));
if (Current.RealTime)
rcm_render_preview(Current.Bna->after, CURRENT);
}
}
else
circle->mode = BOTH;
return 1;
}
/*-----------------------------------------------------------------------------------*/
gint rcm_release_event(GtkWidget *widget, GdkEvent *event, RcmCircle *circle)
{
if (circle->action_flag == DRAGING)
rcm_draw_arrows(widget->window, widget->style->black_gc, circle->angle);
circle->action_flag = VIRGIN;
if (!(Current.RealTime))
rcm_render_preview(Current.Bna->after,CURRENT);
return 1;
}
/*-----------------------------------------------------------------------------------*/
gint rcm_motion_notify_event(GtkWidget *widget, GdkEvent *event, RcmCircle *circle)
{
gint x, y;
float clicked_angle, delta;
float *alpha, *beta;
int cw_ccw;
GdkGCValues values;
alpha = &(circle->angle->alpha);
beta = &(circle->angle->beta);
cw_ccw = circle->angle->cw_ccw;
delta = angle_mod_2PI(cw_ccw * (*beta - *alpha));
values.foreground = Current.From->preview->style->white;
values.function = GDK_XOR;
xor_gc = gdk_gc_new_with_values (Current.From->preview->window,
&values, GDK_GC_FOREGROUND | GDK_GC_FUNCTION);
gdk_window_get_pointer(widget->window, &x, &y, NULL);
clicked_angle = angle_mod_2PI(arctg(CENTER-y, x-CENTER));
delta = clicked_angle - circle->prev_clicked;
circle->prev_clicked = clicked_angle;
if (delta)
{
if (circle->action_flag == DRAG_START)
{
gtk_widget_draw(circle->preview, NULL);
circle->action_flag = DRAGING;
}
else
rcm_draw_arrows(widget->window, xor_gc, circle->angle); /* erase! */
if (circle->mode==EACH)
*(circle->target)=clicked_angle;
else {
circle->angle->alpha=angle_mod_2PI(circle->angle->alpha + delta);
circle->angle->beta =angle_mod_2PI(circle->angle->beta + delta);
}
rcm_draw_arrows(widget->window, xor_gc, circle->angle);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(circle->alpha_entry),
circle->angle->alpha * rcm_units_factor(Current.Units));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(circle->beta_entry),
circle->angle->beta * rcm_units_factor(Current.Units));
if (Current.RealTime)
rcm_render_preview(Current.Bna->after, CURRENT);
}
return 1;
}
/*-----------------------------------------------------------------------------------*/
/* Gray circle events */
/*-----------------------------------------------------------------------------------*/
gint rcm_gray_expose_event(GtkWidget *widget, GdkEvent *event, RcmGray *circle)
{
if (circle->action_flag == VIRGIN)
{
rcm_draw_little_circle(widget->window, widget->style->black_gc,
circle->hue, circle->satur);
rcm_draw_large_circle(widget->window, widget->style->black_gc, circle->gray_sat);
}
else if (Current.RealTime)
rcm_render_preview(Current.Bna->after, CURRENT);
return 1;
}
/*-----------------------------------------------------------------------------------*/
gint rcm_gray_button_press_event(GtkWidget *widget, GdkEvent *event, RcmGray *circle)
{
GdkEventButton *bevent;
int x, y;
bevent = (GdkEventButton *) event;
x = bevent->x - GRAY_CENTER - LITTLE_RADIUS;
y = GRAY_CENTER - bevent->y + LITTLE_RADIUS;
circle->action_flag = DRAG_START;
circle->hue = angle_mod_2PI(arctg(y, x));
circle->satur = sqrt(sqr(x)+sqr(y)) / GRAY_RADIUS;
if (circle->satur > 1.0) circle->satur = 1;
gtk_widget_draw(circle->preview, NULL);
rcm_draw_little_circle(widget->window, widget->style->black_gc,
circle->hue, circle->satur);
rcm_draw_large_circle(circle->preview->window, circle->preview->style->black_gc,
circle->gray_sat);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(circle->hue_entry),
circle->hue * rcm_units_factor(Current.Units));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(circle->satur_entry), circle->satur);
if (Current.RealTime)
rcm_render_preview(Current.Bna->after,CURRENT);
return 1;
}
/*-----------------------------------------------------------------------------------*/
gint rcm_gray_release_event(GtkWidget *widget, GdkEvent *event, RcmGray *circle)
{
if (circle->action_flag == DRAGING)
rcm_draw_little_circle(widget->window,
widget->style->black_gc,
circle->hue,
circle->satur);
circle->action_flag = VIRGIN;
if (!(Current.RealTime)) rcm_render_preview(Current.Bna->after, CURRENT);
return 1;
}
/*-----------------------------------------------------------------------------------*/
gint rcm_gray_motion_notify_event(GtkWidget *widget, GdkEvent *event, RcmGray *circle)
{
gint x, y;
GdkGCValues values;
values.foreground = Current.From->preview->style->white;
values.function = GDK_XOR;
xor_gc = gdk_gc_new_with_values (Current.From->preview->window,
&values, GDK_GC_FOREGROUND | GDK_GC_FUNCTION);
if (circle->action_flag == DRAG_START)
{
gtk_widget_draw(circle->preview, NULL);
rcm_draw_large_circle(circle->preview->window, circle->preview->style->black_gc,
circle->gray_sat);
circle->action_flag = DRAGING;
}
else
rcm_draw_little_circle(widget->window, xor_gc,
circle->hue, circle->satur); /* erase */
gdk_window_get_pointer(widget->window, &x, &y, NULL);
x = x - GRAY_CENTER - LITTLE_RADIUS;
y = GRAY_CENTER - y + LITTLE_RADIUS;
circle->hue = angle_mod_2PI(arctg(y, x));
circle->satur = sqrt(sqr(x) + sqr(y)) / GRAY_RADIUS;
if (circle->satur > 1.0) circle->satur = 1;
rcm_draw_little_circle(widget->window, xor_gc, circle->hue, circle->satur);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(circle->hue_entry),
circle->hue * rcm_units_factor(Current.Units));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(circle->satur_entry), circle->satur);
if (Current.RealTime) rcm_render_preview(Current.Bna->after, CURRENT);
return 1;
}
/*-----------------------------------------------------------------------------------*/
/* Spinbuttons */
/*-----------------------------------------------------------------------------------*/
void rcm_set_alpha(GtkWidget *entry, gpointer data)
{
RcmCircle *circle;
circle = (RcmCircle *) data;
if (circle->action_flag != VIRGIN) return;
circle->angle->alpha = gtk_spin_button_get_value_as_float(GTK_SPIN_BUTTON(entry)) /
rcm_units_factor(Current.Units);
gtk_widget_draw(circle->preview, NULL);
rcm_draw_arrows(circle->preview->window, circle->preview->style->black_gc,
circle->angle);
rcm_render_preview(Current.Bna->after, CURRENT);
}
/*-----------------------------------------------------------------------------------*/
void rcm_set_beta(GtkWidget *entry, gpointer data)
{
RcmCircle *circle;
circle=(RcmCircle *) data;
if (circle->action_flag != VIRGIN) return;
circle->angle->beta = gtk_spin_button_get_value_as_float(GTK_SPIN_BUTTON(entry)) /
rcm_units_factor(Current.Units);
gtk_widget_draw(circle->preview, NULL);
rcm_draw_arrows(circle->preview->window, circle->preview->style->black_gc,
circle->angle);
rcm_render_preview(Current.Bna->after, CURRENT);
}
/*-----------------------------------------------------------------------------------*/
void rcm_set_hue(GtkWidget *entry, gpointer data)
{
RcmGray *circle;
circle = (RcmGray *) data;
if (circle->action_flag != VIRGIN) return;
circle->hue = gtk_spin_button_get_value_as_float(GTK_SPIN_BUTTON(entry)) /
rcm_units_factor(Current.Units);
gtk_widget_draw(circle->preview, NULL);
rcm_draw_little_circle(circle->preview->window, circle->preview->style->black_gc,
circle->hue, circle->satur);
rcm_draw_large_circle(circle->preview->window, circle->preview->style->black_gc,
circle->gray_sat);
rcm_render_preview(Current.Bna->after, CURRENT);
}
/*-----------------------------------------------------------------------------------*/
void rcm_set_satur(GtkWidget *entry, gpointer data)
{
RcmGray *circle;
circle=(RcmGray *) data;
if (circle->action_flag != VIRGIN) return;
circle->satur = gtk_spin_button_get_value_as_float(GTK_SPIN_BUTTON(entry));
gtk_widget_draw(circle->preview, NULL);
rcm_draw_little_circle(circle->preview->window, circle->preview->style->black_gc,
circle->hue, circle->satur);
rcm_draw_large_circle(circle->preview->window, circle->preview->style->black_gc,
circle->gray_sat);
rcm_render_preview(Current.Bna->after, CURRENT);
}
/*-----------------------------------------------------------------------------------*/
void rcm_set_gray_sat(GtkWidget *entry, gpointer data)
{
RcmGray *circle;
circle=(RcmGray *) data;
circle->gray_sat = gtk_spin_button_get_value_as_float(GTK_SPIN_BUTTON(entry));
gtk_widget_draw(circle->preview, NULL);
rcm_draw_large_circle(circle->preview->window, circle->preview->style->black_gc,
circle->gray_sat);
rcm_render_preview(Current.Bna->after, CURRENT);
}
/*-----------------------------------------------------------------------------------*/

136
plug-ins/rcm/rcm_callback.h Normal file
View file

@ -0,0 +1,136 @@
/*
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This is a plug-in for the GIMP.
*
* Colormap-Rotation plug-in. Exchanges two color ranges.
*
* Copyright (C) 1999 Sven Anders (anderss@fmi.uni-passau.de)
* Based on code from Pavel Grinfeld (pavel@ml.com)
*
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/*-----------------------------------------------------------------------------------
* Change log:
*
* Version 2.0, 04 April 1999.
* Nearly complete rewrite, made plug-in stable.
* (Works with GIMP 1.1 and GTK+ 1.2)
*
* Version 1.0, 27 March 1997.
* Initial (unstable) release by Pavel Grinfeld
*
*-----------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------*/
/* Misc functions */
/*-----------------------------------------------------------------------------------*/
float rcm_units_factor(gint units);
gchar *rcm_units_string(gint units);
void rcm_set_pixmap(GtkWidget **widget, GtkWidget *parent,
GtkWidget *label_box, char **pixmap_data);
/*-----------------------------------------------------------------------------------*/
/* Ok/Cancel Buttons */
/*-----------------------------------------------------------------------------------*/
void rcm_close_callback(GtkWidget *widget, gpointer data);
void rcm_ok_callback(GtkWidget *widget, gpointer data);
/*-----------------------------------------------------------------------------------*/
/* Circle buttons */
/*-----------------------------------------------------------------------------------*/
void rcm_360_degrees(GtkWidget *button, RcmCircle *circle);
void rcm_cw_ccw(GtkWidget *button, RcmCircle *circle);
void rcm_a_to_b(GtkWidget *button, RcmCircle *circle);
/*-----------------------------------------------------------------------------------*/
/* Misc: units buttons */
/*-----------------------------------------------------------------------------------*/
void rcm_switch_to_degrees(GtkWidget *button, gpointer *value);
void rcm_switch_to_radians(GtkWidget *button, gpointer *value);
void rcm_switch_to_radians_over_PI(GtkWidget *button, gpointer *value);
/*-----------------------------------------------------------------------------------*/
/* Misc: Gray: mode buttons */
/*-----------------------------------------------------------------------------------*/
void rcm_switch_to_gray_to(GtkWidget *button, gpointer *value);
void rcm_switch_to_gray_from(GtkWidget *button, gpointer *value);
/*-----------------------------------------------------------------------------------*/
/* Misc: Preview buttons */
/*-----------------------------------------------------------------------------------*/
void rcm_preview_as_you_drag(GtkWidget *button, gpointer *value);
void rcm_selection_in_context(GtkWidget *button, gpointer *value);
void rcm_selection(GtkWidget *button, gpointer *value);
void rcm_entire_image(GtkWidget *button, gpointer *value);
/*-----------------------------------------------------------------------------------*/
/* Circle events */
/*-----------------------------------------------------------------------------------*/
gint rcm_expose_event(GtkWidget *widget, GdkEvent *event, RcmCircle *circle);
gint rcm_button_press_event(GtkWidget *widget, GdkEvent *event, RcmCircle *circle);
gint rcm_release_event(GtkWidget *widget, GdkEvent *event, RcmCircle *circle);
gint rcm_motion_notify_event(GtkWidget *widget, GdkEvent *event, RcmCircle *circle);
/*-----------------------------------------------------------------------------------*/
/* Gray circle events */
/*-----------------------------------------------------------------------------------*/
gint rcm_gray_expose_event(GtkWidget *widget, GdkEvent *event, RcmGray *circle);
gint rcm_gray_button_press_event(GtkWidget *widget, GdkEvent *event, RcmGray *circle);
gint rcm_gray_release_event(GtkWidget *widget, GdkEvent *event, RcmGray *circle);
gint rcm_gray_motion_notify_event(GtkWidget *widget, GdkEvent *event, RcmGray *circle);
/*-----------------------------------------------------------------------------------*/
/* Spinbuttons */
/*-----------------------------------------------------------------------------------*/
void rcm_set_alpha(GtkWidget *entry, gpointer data);
void rcm_set_beta(GtkWidget *entry, gpointer data);
void rcm_set_hue(GtkWidget *entry, gpointer data);
void rcm_set_satur(GtkWidget *entry, gpointer data);
void rcm_set_gray_sat(GtkWidget *entry, gpointer data);
/*-----------------------------------------------------------------------------------*/

859
plug-ins/rcm/rcm_dialog.c Normal file
View file

@ -0,0 +1,859 @@
/*
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This is a plug-in for the GIMP.
*
* Colormap-Rotation plug-in. Exchanges two color ranges.
*
* Copyright (C) 1999 Sven Anders (anderss@fmi.uni-passau.de)
* Based on code from Pavel Grinfeld (pavel@ml.com)
*
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/*-----------------------------------------------------------------------------------
* Change log:
*
* Version 2.0, 04 April 1999.
* Nearly complete rewrite, made plug-in stable.
* (Works with GIMP 1.1 and GTK+ 1.2)
*
* Version 1.0, 27 March 1997.
* Initial (unstable) release by Pavel Grinfeld
*
*-----------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpintl.h>
#include "rcm.h"
#include "rcm_misc.h"
#include "rcm_pixmaps.h"
#include "rcm_gdk.h"
#include "rcm_callback.h"
#include "rcm_dialog.h"
/*-----------------------------------------------------------------------------------*/
/* Defines */
/*-----------------------------------------------------------------------------------*/
#define INITIAL_ALPHA 0
#define INITIAL_BETA (PI/2.0)
#define INITIAL_GRAY_SAT 0.0
#define INITIAL_GRAY_RSAT 0.0
#define INITIAL_GRAY_HUE 0.0
#define RANGE_ADJUST_MASK GDK_EXPOSURE_MASK | \
GDK_ENTER_NOTIFY_MASK | \
GDK_BUTTON_PRESS_MASK | \
GDK_BUTTON_RELEASE_MASK | \
GDK_BUTTON1_MOTION_MASK | \
GDK_POINTER_MOTION_HINT_MASK
/*-----------------------------------------------------------------------------------*/
/* Previews: create one preview */
/*-----------------------------------------------------------------------------------*/
void rcm_create_one_preview(GtkWidget **preview, GtkWidget **frame,
int previewWidth, int previewHeight)
{
*frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(*frame), GTK_SHADOW_IN);
gtk_container_border_width(GTK_CONTAINER(*frame), 0);
gtk_widget_show(*frame);
*preview = gtk_preview_new(GTK_PREVIEW_COLOR);
gtk_preview_size(GTK_PREVIEW(*preview), previewWidth, previewHeight);
gtk_widget_show(*preview);
gtk_container_add(GTK_CONTAINER(*frame), *preview);
}
/*-----------------------------------------------------------------------------------*/
/* Previews */
/*-----------------------------------------------------------------------------------*/
GtkWidget *rcm_create_previews(void)
{
GtkWidget *frame, *blabel, *alabel, *bframe, *aframe, *table;
/* Previews: create the previews */
rcm_create_one_preview(&Current.Bna->before, &bframe,
Current.reduced->width, Current.reduced->height);
rcm_create_one_preview(&Current.Bna->after, &aframe,
Current.reduced->width, Current.reduced->height);
/* Previews: frame */
frame = gtk_frame_new(_("Preview"));
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width(GTK_CONTAINER(frame), 5);
alabel = gtk_label_new(_("Rotated"));
gtk_widget_show(alabel);
blabel = gtk_label_new(_("Original"));
gtk_widget_show(blabel);
table = gtk_table_new(4, 1, FALSE);
gtk_container_border_width(GTK_CONTAINER(table), 10);
gtk_table_set_row_spacings(GTK_TABLE(table), 0);
gtk_table_set_col_spacings(GTK_TABLE(table), 20);
gtk_container_add(GTK_CONTAINER(frame), table);
gtk_table_attach(GTK_TABLE(table), blabel, 0, 1, 0, 1,
GTK_EXPAND, GTK_EXPAND|GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), bframe, 0, 1, 1, 2,
GTK_EXPAND, GTK_EXPAND, 0, 0);
gtk_table_attach(GTK_TABLE(table), alabel, 0, 1, 2, 3,
GTK_EXPAND, GTK_EXPAND|GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), aframe, 0, 1, 3, 4,
GTK_EXPAND, GTK_EXPAND, 0, 0);
gtk_widget_show(table);
gtk_widget_show(frame);
return frame;
}
/*-----------------------------------------------------------------------------------*/
/* Main: Create one pixmap button */
/*-----------------------------------------------------------------------------------*/
void rcm_create_pixmap_button(GtkWidget **label, GtkWidget **xpm_button,
GtkWidget **label_box, GtkSignalFunc callback,
gpointer data, gchar *text, GtkWidget *parent, gint pos)
{
/* create button */
*xpm_button = gtk_button_new();
gtk_signal_connect(GTK_OBJECT(*xpm_button), "clicked", callback, data);
gtk_widget_show(*xpm_button);
gtk_table_attach(GTK_TABLE(parent), *xpm_button,
0, 1, pos, pos+1, GTK_EXPAND|GTK_FILL, GTK_FILL, 5, 2);
/* create hbox */
*label_box = gtk_hbox_new(FALSE, 0);
gtk_widget_show(*label_box);
/* create label */
*label = gtk_label_new(text);
gtk_widget_show(*label);
/* put label and pixmap in hbox */
gtk_box_pack_end(GTK_BOX(*label_box), *label, TRUE, FALSE, 0);
/* create hbox in button */
gtk_container_add(GTK_CONTAINER(*xpm_button), *label_box);
}
/*-----------------------------------------------------------------------------------*/
/* Set buttons pixmaps */
/*-----------------------------------------------------------------------------------*/
void rcm_set_pixmaps(RcmCircle *circle)
{
rcm_set_pixmap(&circle->cw_ccw_pixmap, circle->cw_ccw_button->parent, circle->cw_ccw_box, rcm_cw);
rcm_set_pixmap(&circle->a_b_pixmap, circle->a_b_button->parent, circle->a_b_box, rcm_a_b);
rcm_set_pixmap(&circle->f360_pixmap, circle->f360_button->parent, circle->f360_box, rcm_360);
}
/*-----------------------------------------------------------------------------------*/
/* Main: One circles with values and buttons */
/*-----------------------------------------------------------------------------------*/
RcmCircle *rcm_create_one_circle(gint height, gchar *label_content)
{
GtkWidget *frame, *button_table, *legend_table;
GtkWidget *label, *label_box, *xpm_button, *entry;
GtkAdjustment *adj;
RcmCircle *st;
st = g_new(RcmCircle, 1);
st->action_flag = VIRGIN;
st->angle = g_new(RcmAngle, 1);
st->angle->alpha = INITIAL_ALPHA;
st->angle->beta = INITIAL_BETA;
st->angle->cw_ccw = 1;
/** Main: Circle: create (main) frame **/
st->frame = gtk_frame_new(label_content);
gtk_container_border_width(GTK_CONTAINER(st->frame), 0);
gtk_widget_show(st->frame);
/** Main: Circle: create frame & preview **/
/* create frame */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_container_border_width(GTK_CONTAINER(frame), 0);
gtk_widget_show(frame);
/* create preview */
st->preview = gtk_preview_new(GTK_PREVIEW_COLOR);
gtk_preview_size(GTK_PREVIEW(st->preview), height, height);
gtk_widget_show(st->preview);
gtk_container_add(GTK_CONTAINER(frame), st->preview);
/* set signals */
gtk_widget_set_events(st->preview, RANGE_ADJUST_MASK);
gtk_signal_connect_after(GTK_OBJECT(st->preview), "expose_event",
(GtkSignalFunc) rcm_expose_event, st);
gtk_signal_connect(GTK_OBJECT(st->preview), "button_press_event",
(GtkSignalFunc) rcm_button_press_event, st);
gtk_signal_connect(GTK_OBJECT(st->preview), "button_release_event",
(GtkSignalFunc) rcm_release_event, st);
gtk_signal_connect(GTK_OBJECT(st->preview), "motion_notify_event",
(GtkSignalFunc) rcm_motion_notify_event, st);
rcm_render_circle(st->preview, SUM, MARGIN);
/** Main: Circle: create table for buttons **/
button_table = gtk_table_new(3, 1, FALSE);
gtk_widget_show(button_table);
/** Main: Circle: Buttons **/
rcm_create_pixmap_button(&label, &xpm_button, &label_box, rcm_cw_ccw, st,
(st->angle->cw_ccw>0) ? _("Switch to clockwise") : _("Switch to c/clockwise"),
button_table, 0);
st->cw_ccw_pixmap = NULL;
st->cw_ccw_button = xpm_button;
st->cw_ccw_box = label_box;
st->cw_ccw_label = label;
rcm_create_pixmap_button(&label, &xpm_button, &label_box, rcm_a_to_b, st,
_("Change order of arrows"), button_table, 1);
st->a_b_pixmap = NULL;
st->a_b_box = label_box;
st->a_b_button = xpm_button;
rcm_create_pixmap_button(&label, &xpm_button, &label_box, rcm_360_degrees, st,
_("Select all"), button_table, 2);
st->f360_pixmap = NULL;
st->f360_box = label_box;
st->f360_button = xpm_button;
/** Main: Circle: Legend **/
legend_table = gtk_table_new(1, 6, FALSE);
gtk_widget_show(legend_table);
/* spinbutton 1 */
label = gtk_label_new(_("From"));
gtk_widget_show(label);
gtk_table_attach(GTK_TABLE(legend_table), label, 0,1, 0,1,
0, GTK_EXPAND, 5, 5);
st->angle->alpha = INITIAL_ALPHA;
adj = (GtkAdjustment *) gtk_adjustment_new(st->angle->alpha, 0.0, 2.0, 0.0001, 0.001, 0.0);
st->alpha_entry = entry = gtk_spin_button_new(adj, 0.01, 4);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(entry), TRUE);
gtk_widget_show(entry);
gtk_signal_connect(GTK_OBJECT(entry), "changed", (GtkSignalFunc)rcm_set_alpha, st);
gtk_table_attach(GTK_TABLE(legend_table), entry, 1,2, 0,1,
GTK_EXPAND|GTK_FILL, GTK_EXPAND, 2 ,5);
/* label */
st->alpha_units_label = gtk_label_new(rcm_units_string(Current.Units));
gtk_widget_show(st->alpha_units_label);
gtk_table_attach(GTK_TABLE(legend_table), st->alpha_units_label, 2,3, 0,1,
0, GTK_EXPAND, 5, 5);
/* spinbutton 2 */
label = gtk_label_new(_("to"));
gtk_widget_show(label);
gtk_table_attach(GTK_TABLE(legend_table), label, 3,4, 0,1,
0, GTK_EXPAND, 5, 5);
st->angle->beta = INITIAL_BETA;
adj = (GtkAdjustment *) gtk_adjustment_new(st->angle->beta, 0.0, 2.0, 0.0001, 0.001, 0.0);
st->beta_entry = entry = gtk_spin_button_new(adj, 0.01, 4);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(entry), TRUE);
gtk_widget_show(entry);
gtk_signal_connect(GTK_OBJECT(entry), "changed", (GtkSignalFunc)rcm_set_beta, st);
gtk_table_attach(GTK_TABLE(legend_table), entry, 4,5, 0,1,
GTK_EXPAND|GTK_FILL, GTK_EXPAND, 2 ,5);
/* label */
st->beta_units_label = gtk_label_new(rcm_units_string(Current.Units));
gtk_widget_show(st->beta_units_label);
gtk_table_attach(GTK_TABLE(legend_table), st->beta_units_label, 5,6, 0,1,
0, GTK_EXPAND, 5, 5);
/* Main: Circle: create table for Preview / Buttons / Legend */
st->table= gtk_table_new(2, 2, FALSE);
gtk_widget_show(st->table);
gtk_table_attach(GTK_TABLE(st->table), frame, 0, 1, 0, 1,
0, GTK_EXPAND, 4, 0);
gtk_table_attach(GTK_TABLE(st->table), button_table, 1, 2, 0, 1,
0, GTK_EXPAND, 2, 0);
gtk_table_attach(GTK_TABLE(st->table), legend_table, 0, 2, 1, 2,
GTK_EXPAND|GTK_FILL, GTK_EXPAND, 0, 2);
/* add table to (main) frame */
gtk_container_add(GTK_CONTAINER(st->frame), st->table);
return st;
}
/*-----------------------------------------------------------------------------------*/
/* Main */
/*-----------------------------------------------------------------------------------*/
GtkWidget *rcm_create_main(void)
{
GtkWidget *frame, *table;
/* Main: create frame */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width(GTK_CONTAINER(frame), 5);
/* Main: create previews */
Current.From = rcm_create_one_circle(SUM, _("From"));
Current.To = rcm_create_one_circle(SUM, _("To"));
/* Main: create table */
table = gtk_table_new(3, 2, FALSE);
gtk_container_border_width(GTK_CONTAINER(table), 5);
gtk_container_add(GTK_CONTAINER(frame), table);
/* Main: insert previews in table */
gtk_table_attach(GTK_TABLE(table), Current.From->frame, 0, 1, 0, 1,
GTK_EXPAND|GTK_FILL, GTK_EXPAND, 0, 0);
gtk_table_attach(GTK_TABLE(table), Current.To->frame, 0, 1, 1, 2,
GTK_EXPAND|GTK_FILL, GTK_EXPAND, 0, 0);
gtk_widget_show(table);
gtk_widget_show(frame);
return frame;
}
/*-----------------------------------------------------------------------------------*/
/* Misc: Gray */
/*-----------------------------------------------------------------------------------*/
RcmGray *rcm_create_gray(void)
{
GtkWidget *frame, *preview, *as_or_to_frame;
GtkWidget *table, *previewframe, *legend_table;
GtkWidget *mini_table;
GtkWidget *label, *entry;
GtkWidget *gray_sat_frame;
GtkWidget *radio_box, *button;
GSList *group = NULL;
RcmGray *st;
GtkAdjustment *adj;
st = g_new(RcmGray,1);
st->hue = 0;
st->satur = 0;
st->action_flag = VIRGIN;
/** Gray **/
st->frame = frame = gtk_frame_new(_("Gray"));
gtk_widget_show(frame);
/* Gray: Circle: Circle (Preview) */
previewframe = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(previewframe), GTK_SHADOW_IN);
gtk_container_border_width (GTK_CONTAINER(previewframe), 0);
gtk_widget_show(previewframe);
st->preview = preview = gtk_preview_new (GTK_PREVIEW_COLOR);
gtk_preview_size(GTK_PREVIEW(preview), GRAY_SUM, GRAY_SUM);
gtk_widget_show(preview);
gtk_container_add(GTK_CONTAINER(previewframe), preview);
gtk_widget_set_events(preview,RANGE_ADJUST_MASK);
gtk_signal_connect_after(GTK_OBJECT(preview),"expose_event",
(GtkSignalFunc) rcm_gray_expose_event, st);
gtk_signal_connect(GTK_OBJECT(preview),"button_press_event",
(GtkSignalFunc) rcm_gray_button_press_event, st);
gtk_signal_connect(GTK_OBJECT(preview),"button_release_event",
(GtkSignalFunc) rcm_gray_release_event, st);
gtk_signal_connect(GTK_OBJECT(preview),"motion_notify_event",
(GtkSignalFunc) rcm_gray_motion_notify_event, st);
/* Gray: Circle: Legend */
legend_table = gtk_table_new(2, 3, FALSE);
gtk_widget_show(legend_table);
gtk_container_border_width(GTK_CONTAINER(legend_table), 1);
/* Gray: Circle: Spinbutton 1 */
label = gtk_label_new(_("Hue"));
gtk_widget_show(label);
gtk_table_attach(GTK_TABLE(legend_table), label, 0,1, 0,1,
GTK_EXPAND|GTK_FILL, GTK_EXPAND, 0, 2);
st->hue = INITIAL_GRAY_HUE;
adj = (GtkAdjustment *) gtk_adjustment_new(st->hue, 0.0, 2.0, 0.0001, 0.001, 0.0);
st->hue_entry = entry = gtk_spin_button_new(adj, 0.01, 4);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(entry), TRUE);
gtk_widget_set_usize (entry, 75, 0);
gtk_widget_show(entry);
gtk_signal_connect(GTK_OBJECT(entry), "changed", (GtkSignalFunc)rcm_set_hue, st);
gtk_table_attach(GTK_TABLE(legend_table), entry, 1,2, 0,1,
GTK_EXPAND|GTK_FILL, GTK_EXPAND, 0 ,2);
/* Gray: Circle: units label */
st->hue_units_label = gtk_label_new(rcm_units_string(Current.Units));
gtk_widget_show(st->hue_units_label);
gtk_table_attach(GTK_TABLE(legend_table), st->hue_units_label, 2,3, 0,1,
GTK_EXPAND, GTK_EXPAND, 0, 2);
/* Gray: Circle: Spinbutton 2 */
label = gtk_label_new(_("Saturation"));
gtk_widget_show(label);
gtk_table_attach(GTK_TABLE(legend_table), label, 0,1, 1,2,
GTK_EXPAND|GTK_FILL, GTK_EXPAND, 0, 2);
st->satur = INITIAL_GRAY_SAT;
adj = (GtkAdjustment *) gtk_adjustment_new(st->satur, 0.0, 1.0, 0.0001, 0.001, 0.0);
st->satur_entry = entry = gtk_spin_button_new(adj, 0.01, 4);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(entry), TRUE);
gtk_widget_set_usize (entry, 75, 0);
gtk_widget_show(entry);
gtk_signal_connect(GTK_OBJECT(entry), "changed", (GtkSignalFunc)rcm_set_satur, st);
gtk_table_attach(GTK_TABLE(legend_table), entry, 1,2, 1,2,
GTK_EXPAND|GTK_FILL, GTK_EXPAND, 0, 2);
/** Gray: Operation-Mode **/
as_or_to_frame = gtk_frame_new(_("Mode"));
gtk_container_border_width (GTK_CONTAINER (as_or_to_frame), 5);
gtk_widget_show(as_or_to_frame);
radio_box = gtk_vbox_new(FALSE, 3);
gtk_container_add(GTK_CONTAINER(as_or_to_frame), radio_box);
gtk_container_border_width(GTK_CONTAINER(radio_box), 5);
gtk_widget_show(radio_box);
/* Gray: Operation-Mode: two radio buttons */
button = gtk_radio_button_new_with_label(group, _("Treat as this"));
gtk_widget_show(button);
gtk_box_pack_start(GTK_BOX(radio_box), button, TRUE, FALSE, 0);
if (Current.Gray_to_from == GRAY_FROM) gtk_button_clicked(GTK_BUTTON(button));
gtk_signal_connect(GTK_OBJECT(button), "clicked",
(GtkSignalFunc) rcm_switch_to_gray_from,
&(Current.Gray_to_from));
group = gtk_radio_button_group(GTK_RADIO_BUTTON(button));
button = gtk_radio_button_new_with_label(group, _("Change to this"));
gtk_widget_show(button);
gtk_box_pack_start(GTK_BOX(radio_box), button, TRUE, FALSE, 0);
if (Current.Gray_to_from == GRAY_TO) gtk_button_clicked(GTK_BUTTON(button));
gtk_signal_connect(GTK_OBJECT(button), "clicked",
(GtkSignalFunc) rcm_switch_to_gray_to,
&(Current.Gray_to_from));
group = gtk_radio_button_group(GTK_RADIO_BUTTON(button));
/** Gray: What is gray? **/
gray_sat_frame = gtk_frame_new(_("What is Gray?"));
gtk_container_border_width(GTK_CONTAINER(gray_sat_frame), 5);
gtk_widget_show(gray_sat_frame);
table = gtk_table_new(1, 3, FALSE);
gtk_widget_show(table);
label = gtk_label_new(_("Saturation"));
gtk_widget_show(label);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1, GTK_EXPAND|GTK_FILL, GTK_EXPAND, 0,0);
label = gtk_label_new("<=");
gtk_widget_show(label);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1, GTK_EXPAND|GTK_FILL, GTK_EXPAND, 0,0);
st->gray_sat = INITIAL_GRAY_RSAT;
adj = (GtkAdjustment *) gtk_adjustment_new(st->gray_sat, 0.0, 1.0, 0.0001, 0.001, 0.0);
st->gray_sat_entry = entry = gtk_spin_button_new(adj, 0.01, 4);
gtk_widget_show(entry);
gtk_signal_connect(GTK_OBJECT(entry), "changed", (GtkSignalFunc)rcm_set_gray_sat, st);
gtk_table_attach(GTK_TABLE(table), entry, 2, 3, 0, 1, GTK_EXPAND|GTK_FILL, GTK_EXPAND, 3,0);
gtk_container_add(GTK_CONTAINER(gray_sat_frame), table);
/** add all frames to table **/
/* add preview and legend to table */
mini_table = gtk_table_new(2, 1, FALSE);
gtk_widget_show(mini_table);
gtk_table_attach(GTK_TABLE(mini_table), previewframe, 0, 1, 0, 1,
GTK_EXPAND, GTK_EXPAND, 0, 0);
gtk_table_attach(GTK_TABLE(mini_table), legend_table, 0, 1, 1, 2,
GTK_EXPAND|GTK_FILL, GTK_EXPAND|GTK_FILL, 0, 0);
/* add mini_table & two frames to table */
table = gtk_table_new(2, 2, FALSE);
gtk_widget_show(table);
gtk_table_attach(GTK_TABLE(table), mini_table, 0, 1, 0, 2,
GTK_EXPAND|GTK_FILL, GTK_EXPAND|GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), as_or_to_frame, 1, 2, 0, 1,
GTK_EXPAND|GTK_FILL, GTK_EXPAND|GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), gray_sat_frame, 1, 2, 1, 2,
GTK_EXPAND|GTK_FILL, GTK_EXPAND|GTK_FILL, 0, 0);
gtk_container_add(GTK_CONTAINER(frame), table);
/* update circle (preview) */
rcm_render_circle(preview, GRAY_SUM, GRAY_MARGIN);
return st;
}
/*-----------------------------------------------------------------------------------*/
/* Misc */
/*-----------------------------------------------------------------------------------*/
GtkWidget *rcm_create_misc(void)
{
GtkWidget *frame, *label,*table;
GtkWidget *units_frame, *units_vbox;
GtkWidget *preview_frame, *preview_vbox;
GtkWidget *item, *menu, *root, *hbox;
GtkWidget *button;
GSList *units_group = NULL;
GSList *preview_group = NULL;
/** Misc: Main frame **/
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
gtk_container_border_width(GTK_CONTAINER(frame), 5);
/** Misc: Gray circle **/
Current.Gray = rcm_create_gray();
/** Misc: Used unit selection **/
units_frame = gtk_frame_new(_("Units"));
gtk_widget_show(units_frame);
units_vbox=gtk_vbox_new(FALSE, 3);
gtk_container_add(GTK_CONTAINER(units_frame), units_vbox);
gtk_container_border_width(GTK_CONTAINER(units_vbox), 5);
gtk_widget_show(units_vbox);
/* Misc: Used unit selection: 3 radio buttons */
button = gtk_radio_button_new_with_label(units_group, N_("Radians"));
gtk_widget_show(button);
gtk_box_pack_start(GTK_BOX(units_vbox), button, TRUE, TRUE, 0);
if (Current.Units == RADIANS) gtk_button_clicked(GTK_BUTTON(button));
gtk_signal_connect(GTK_OBJECT(button), "clicked",
(GtkSignalFunc) rcm_switch_to_radians, NULL);
units_group = gtk_radio_button_group(GTK_RADIO_BUTTON(button));
button = gtk_radio_button_new_with_label(units_group, N_("Radians/Pi"));
gtk_widget_show(button);
gtk_box_pack_start(GTK_BOX(units_vbox), button, TRUE, TRUE, 0);
if (Current.Units == RADIANS_OVER_PI) gtk_button_clicked(GTK_BUTTON(button));
gtk_signal_connect(GTK_OBJECT(button), "clicked",
(GtkSignalFunc) rcm_switch_to_radians_over_PI, NULL);
units_group = gtk_radio_button_group(GTK_RADIO_BUTTON(button));
button = gtk_radio_button_new_with_label(units_group, N_("Degrees"));
gtk_widget_show(button);
gtk_box_pack_start(GTK_BOX(units_vbox), button, TRUE, TRUE, 0);
if (Current.Units == DEGREES) gtk_button_clicked(GTK_BUTTON(button));
gtk_signal_connect(GTK_OBJECT(button), "clicked",
(GtkSignalFunc) rcm_switch_to_degrees, NULL);
/** Misc: Preview settings **/
/* Misc: Preview settings: Continuous update ?! */
preview_frame = gtk_frame_new(_("Preview"));
preview_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_border_width(GTK_CONTAINER(preview_vbox), 5);
gtk_widget_show(preview_vbox);
gtk_container_add(GTK_CONTAINER(preview_frame), preview_vbox);
gtk_widget_show(preview_frame);
button = gtk_check_button_new_with_label(_("Continuous update"));
gtk_box_pack_start(GTK_BOX(preview_vbox), button, TRUE, FALSE, 0);
gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (button), Current.RealTime);
gtk_signal_connect(GTK_OBJECT (button), "clicked",
(GtkSignalFunc) (GtkSignalFunc) rcm_preview_as_you_drag,
&(Current.RealTime));
gtk_widget_show(button);
/* Misc: Preview settings: Area */
hbox = gtk_hbox_new(FALSE,3);
gtk_widget_show(hbox);
gtk_box_pack_start(GTK_BOX(preview_vbox), hbox, TRUE, FALSE, 5);
label = gtk_label_new(_("Area"));
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 3);
/* create menu entries */
menu = gtk_menu_new();
item = gtk_radio_menu_item_new_with_label(preview_group, N_("Entire Image"));
preview_group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(item));
gtk_menu_append(GTK_MENU(menu), item);
gtk_widget_show(item);
gtk_signal_connect(GTK_OBJECT(item), "activate",
(GtkSignalFunc) rcm_entire_image, NULL);
item = gtk_radio_menu_item_new_with_label(preview_group, N_("Selection"));
preview_group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(item));
gtk_menu_append(GTK_MENU(menu), item);
gtk_widget_show(item);
gtk_signal_connect (GTK_OBJECT(item), "activate",
(GtkSignalFunc) rcm_selection, NULL);
item = gtk_radio_menu_item_new_with_label(preview_group, N_("Context"));
preview_group = gtk_radio_menu_item_group(GTK_RADIO_MENU_ITEM(item));
gtk_widget_show(item);
gtk_menu_append(GTK_MENU(menu), item);
gtk_signal_connect(GTK_OBJECT(item), "activate",
(GtkSignalFunc) rcm_selection_in_context, NULL);
/* create (options) menu */
root = gtk_option_menu_new();
gtk_option_menu_set_menu(GTK_OPTION_MENU(root), menu);
gtk_option_menu_set_history(GTK_OPTION_MENU(root), 4);
gtk_widget_show(root);
gtk_box_pack_start(GTK_BOX(hbox), root, FALSE, FALSE, 0);
table = gtk_table_new(2, 2, FALSE);
gtk_widget_show(table);
gtk_container_border_width(GTK_CONTAINER(table),0);
gtk_container_add(GTK_CONTAINER(frame), table);
/** add frames (gray/preview/units) to table **/
gtk_table_attach(GTK_TABLE(table), Current.Gray->frame, 0, 2, 0, 1,
GTK_EXPAND|GTK_FILL, GTK_FILL, 5, 3);
gtk_table_attach(GTK_TABLE(table), preview_frame, 0, 1, 1, 2,
GTK_EXPAND|GTK_FILL, GTK_FILL, 5, 3);
gtk_table_attach(GTK_TABLE(table), units_frame, 1, 2, 1, 2,
GTK_EXPAND|GTK_FILL, GTK_FILL, 5, 3);
gtk_widget_show (frame);
return frame;
}
/*-----------------------------------------------------------------------------------*/
/* create and call main dialog */
/*-----------------------------------------------------------------------------------*/
gint rcm_dialog(void)
{
GtkWidget *table, *dlg, *hbox, *notebook;
GtkWidget *previews, *mains, *miscs;
GtkWidget *buttonTable, *OKbutton, *CANCELbutton;
guchar *color_cube;
gchar **argv;
gint argc;
argc = 1;
argv = g_new(gchar *, 1);
argv[0] = g_strdup("rcm");
Current.Bna = g_new(RcmBna, 1);
/* init GTK and install colormap */
gtk_init(&argc, &argv);
gtk_rc_parse(gimp_gtkrc());
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());
/* Create dialog */
dlg = gtk_dialog_new();
Current.Bna->dlg = dlg;
gtk_window_set_title(GTK_WINDOW(dlg), _("Colormap Rotation"));
gtk_signal_connect(GTK_OBJECT(dlg), "destroy",
(GtkSignalFunc) rcm_close_callback, NULL);
/* create buttons */
OKbutton = gtk_button_new_with_label(_("OK"));
GTK_WIDGET_SET_FLAGS(OKbutton, GTK_CAN_DEFAULT);
gtk_signal_connect(GTK_OBJECT (OKbutton), "clicked",
(GtkSignalFunc) rcm_ok_callback, dlg);
gtk_widget_grab_default(OKbutton);
gtk_widget_show(OKbutton);
CANCELbutton = gtk_button_new_with_label(_("Cancel"));
GTK_WIDGET_SET_FLAGS(CANCELbutton, GTK_CAN_DEFAULT);
gtk_signal_connect_object(GTK_OBJECT(CANCELbutton), "clicked",
(GtkSignalFunc) gtk_widget_destroy, GTK_OBJECT(dlg));
gtk_widget_show(CANCELbutton);
/* Create table with ok/cancel */
buttonTable = gtk_table_new(1, 4, TRUE);
gtk_container_border_width(GTK_CONTAINER(buttonTable),0);
gtk_table_set_col_spacings(GTK_TABLE(buttonTable),3);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dlg)->action_area),
buttonTable, TRUE, TRUE, 0);
gtk_table_attach(GTK_TABLE(buttonTable), OKbutton, 1, 2, 0, 1,
GTK_FILL|GTK_EXPAND, 0, 0, 0);
gtk_table_attach(GTK_TABLE(buttonTable), CANCELbutton, 2, 3, 0, 1,
GTK_FILL|GTK_EXPAND, 0, 0, 0);
gtk_widget_show(buttonTable);
/* Create sub-dialogs */
Current.reduced = rcm_reduce_image(Current.drawable, Current.mask,
MAX_PREVIEW_SIZE, ENTIRE_IMAGE);
previews = rcm_create_previews();
mains = rcm_create_main();
miscs = rcm_create_misc();
Current.Bna->bna_frame = previews;
rcm_render_preview(Current.Bna->before, ORIGINAL);
rcm_render_preview(Current.Bna->after, CURRENT);
/* H-Box */
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dlg)->vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show(hbox);
gtk_box_pack_start(GTK_BOX(hbox), previews, TRUE, TRUE, 0);
/* Notebook */
notebook = gtk_notebook_new();
gtk_container_border_width(GTK_CONTAINER(notebook), 10);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP);
gtk_box_pack_start(GTK_BOX(hbox), notebook, TRUE, TRUE, 0);
gtk_widget_show(notebook);
table = gtk_table_new(1, 2, FALSE);
gtk_widget_show(table);
gtk_table_attach(GTK_TABLE(table), mains, 1, 2, 0, 1,
GTK_EXPAND|GTK_FILL, GTK_EXPAND|GTK_FILL, 5, 0);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), table, gtk_label_new(_("Main")));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), miscs, gtk_label_new(_("Misc")));
/* show dialog */
gtk_widget_show(dlg);
/* set pixmaps */
rcm_set_pixmaps(Current.From);
rcm_set_pixmaps(Current.To);
/* Flush display, start main-loop */
gdk_flush();
gtk_main();
return Current.Success;
}

51
plug-ins/rcm/rcm_dialog.h Normal file
View file

@ -0,0 +1,51 @@
/*
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This is a plug-in for the GIMP.
*
* Colormap-Rotation plug-in. Exchanges two color ranges.
*
* Copyright (C) 1999 Sven Anders (anderss@fmi.uni-passau.de)
* Based on code from Pavel Grinfeld (pavel@ml.com)
*
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/*-----------------------------------------------------------------------------------
* Change log:
*
* Version 2.0, 04 April 1999.
* Nearly complete rewrite, made plug-in stable.
* (Works with GIMP 1.1 and GTK+ 1.2)
*
* Version 1.0, 27 March 1997.
* Initial (unstable) release by Pavel Grinfeld
*
*-----------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------*/
/* Global defines */
/*-----------------------------------------------------------------------------------*/
#define MAX_PREVIEW_SIZE 150
/*-----------------------------------------------------------------------------------*/
/* Procedures */
/*-----------------------------------------------------------------------------------*/
gint rcm_dialog();
/*-----------------------------------------------------------------------------------*/

165
plug-ins/rcm/rcm_gdk.c Normal file
View file

@ -0,0 +1,165 @@
/*
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This is a plug-in for the GIMP.
*
* Colormap-Rotation plug-in. Exchanges two color ranges.
*
* Copyright (C) 1999 Sven Anders (anderss@fmi.uni-passau.de)
* Based on code from Pavel Grinfeld (pavel@ml.com)
*
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/*-----------------------------------------------------------------------------------
* Change log:
*
* Version 2.0, 04 April 1999.
* Nearly complete rewrite, made plug-in stable.
* (Works with GIMP 1.1 and GTK+ 1.2)
*
* Version 1.0, 27 March 1997.
* Initial (unstable) release by Pavel Grinfeld
*
*-----------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpintl.h>
#include "rcm.h"
#include "rcm_misc.h"
#include "rcm_dialog.h"
#include "rcm_gdk.h"
/*-----------------------------------------------------------------------------------*/
/* Global variables */
/*-----------------------------------------------------------------------------------*/
GdkGC *xor_gc;
/*-----------------------------------------------------------------------------------*/
/* Misc functions */
/*-----------------------------------------------------------------------------------*/
inline int R(float X)
{
return X + 0.5;
}
/*-----------------------------------------------------------------------------------*/
/* Drawing routines */
/*-----------------------------------------------------------------------------------*/
void rcm_draw_little_circle(GdkWindow *window, GdkGC *color, float hue, float satur)
{
int x,y;
x = GRAY_CENTER + GRAY_RADIUS * satur * cos(hue);
y = GRAY_CENTER - GRAY_RADIUS * satur * sin(hue);
gdk_draw_arc(window, color, 0, x-LITTLE_RADIUS, y-LITTLE_RADIUS,
2*LITTLE_RADIUS, 2*LITTLE_RADIUS, 0, 360*64);
}
/*-----------------------------------------------------------------------------------*/
void rcm_draw_large_circle(GdkWindow *window, GdkGC *color, float gray_sat)
{
int x, y;
x = GRAY_CENTER;
y = GRAY_CENTER;
gdk_draw_arc(window, color, 0,
R(x - GRAY_RADIUS * gray_sat),
R(y - GRAY_RADIUS * gray_sat),
R(2 * GRAY_RADIUS * gray_sat),
R(2 * GRAY_RADIUS * gray_sat),
0, 360 * 64);
}
/*-----------------------------------------------------------------------------------*/
#define REL .8
#define DEL .1
#define TICK 10
void rcm_draw_arrows(GdkWindow *window, GdkGC *color, RcmAngle *angle)
{
int dist;
float alpha, beta, cw_ccw, delta;
alpha = angle->alpha;
beta = angle->beta;
cw_ccw = angle->cw_ccw;
delta = angle_mod_2PI(beta - alpha);
if (cw_ccw == -1) delta = delta - TP;
gdk_draw_line(window,color,
CENTER,
CENTER,
R(CENTER + RADIUS * cos(alpha)),
R(CENTER - RADIUS * sin(alpha)));
gdk_draw_line(window,color,
CENTER + RADIUS * cos(alpha),
CENTER - RADIUS * sin(alpha),
R(CENTER + RADIUS * REL * cos(alpha - DEL)),
R(CENTER - RADIUS * REL * sin(alpha - DEL)));
gdk_draw_line(window,color,
CENTER + RADIUS * cos(alpha),
CENTER - RADIUS * sin(alpha),
R(CENTER + RADIUS * REL * cos(alpha + DEL)),
R(CENTER - RADIUS * REL * sin(alpha + DEL)));
gdk_draw_line(window,color,
CENTER,
CENTER,
R(CENTER + RADIUS * cos(beta)),
R(CENTER - RADIUS * sin(beta)));
gdk_draw_line(window,color,
CENTER + RADIUS * cos(beta),
CENTER - RADIUS * sin(beta),
R(CENTER + RADIUS * REL * cos(beta - DEL)),
R(CENTER - RADIUS * REL * sin(beta - DEL)));
gdk_draw_line(window,color,
CENTER + RADIUS * cos(beta),
CENTER - RADIUS * sin(beta),
R(CENTER + RADIUS * REL * cos(beta + DEL)),
R(CENTER - RADIUS * REL * sin(beta + DEL)));
dist = RADIUS * EACH_OR_BOTH;
gdk_draw_line(window,color,
CENTER + dist * cos(beta),
CENTER - dist * sin(beta),
R(CENTER + dist * cos(beta) + cw_ccw * TICK * sin(beta)),
R(CENTER - dist * sin(beta) + cw_ccw * TICK * cos(beta)));
alpha *= 180*64/PI;
delta *= 180*64/PI;
gdk_draw_arc(window, color, 0, CENTER - dist, CENTER - dist,
2*dist, 2*dist, alpha, delta);
}

71
plug-ins/rcm/rcm_gdk.h Normal file
View file

@ -0,0 +1,71 @@
/*
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This is a plug-in for the GIMP.
*
* Colormap-Rotation plug-in. Exchanges two color ranges.
*
* Copyright (C) 1999 Sven Anders (anderss@fmi.uni-passau.de)
* Based on code from Pavel Grinfeld (pavel@ml.com)
*
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/*-----------------------------------------------------------------------------------
* Change log:
*
* Version 2.0, 04 April 1999.
* Nearly complete rewrite, made plug-in stable.
* (Works with GIMP 1.1 and GTK+ 1.2)
*
* Version 1.0, 27 March 1997.
* Initial (unstable) release by Pavel Grinfeld
*
*-----------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------*/
/* Global defines */
/*-----------------------------------------------------------------------------------*/
#define RADIUS 60
#define MARGIN 4
#define SUM (2*RADIUS + 2*MARGIN)
#define CENTER (SUM/2)
#define GRAY_RADIUS 60
#define GRAY_MARGIN 3
#define GRAY_SUM (2*GRAY_RADIUS + 2*GRAY_MARGIN)
#define GRAY_CENTER (GRAY_SUM/2)
#define LITTLE_RADIUS 3
#define EACH_OR_BOTH 0.3
/*-----------------------------------------------------------------------------------*/
/* Global variables */
/*-----------------------------------------------------------------------------------*/
extern GdkGC *xor_gc;
/*-----------------------------------------------------------------------------------*/
void rcm_draw_little_circle(GdkWindow *window, GdkGC *color, float hue, float satur);
void rcm_draw_large_circle(GdkWindow *window, GdkGC *color, float gray_sat);
void rcm_draw_arrows(GdkWindow *window, GdkGC *color, RcmAngle *angle);
/*-----------------------------------------------------------------------------------*/

548
plug-ins/rcm/rcm_misc.c Normal file
View file

@ -0,0 +1,548 @@
/*
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This is a plug-in for the GIMP.
*
* Colormap-Rotation plug-in. Exchanges two color ranges.
*
* Copyright (C) 1999 Sven Anders (anderss@fmi.uni-passau.de)
* Based on code from Pavel Grinfeld (pavel@ml.com)
*
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/*-----------------------------------------------------------------------------------
* Change log:
*
* Version 2.0, 04 April 1999.
* Nearly complete rewrite, made plug-in stable.
* (Works with GIMP 1.1 and GTK+ 1.2)
*
* Version 1.0, 27 March 1997.
* Initial (unstable) release by Pavel Grinfeld
*
*-----------------------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include "rcm.h"
#include "rcm_misc.h"
#include "rcm_gdk.h"
/*-----------------------------------------------------------------------------------*/
inline float arctg(float y, float x)
{
float temp = atan2(y,x);
return (temp<0) ? (temp+TP) : temp;
}
inline float sign(float x)
{
return (x<0)?(-1):(1);
}
/*-----------------------------------------------------------------------------------*/
float min_prox(float alpha, float beta, float angle)
{
gfloat temp1 = MIN(angle_mod_2PI(alpha - angle),
TP-angle_mod_2PI(alpha - angle));
gfloat temp2 = MIN(angle_mod_2PI(beta - angle),
TP-angle_mod_2PI(beta - angle));
return MIN(temp1, temp2);
}
float *closest(float *alpha, float *beta, float angle)
{
float temp_alpha = MIN(angle_mod_2PI(*alpha-angle),
TP-angle_mod_2PI(*alpha-angle));
float temp_beta = MIN(angle_mod_2PI(*beta -angle),
TP-angle_mod_2PI(*beta -angle));
if (temp_alpha-temp_beta<0)
return alpha;
else
return beta;
}
float angle_mod_2PI(float angle)
{
if (angle < 0)
return angle + TP;
else if (angle > TP)
return angle - TP;
else
return angle;
}
/*-----------------------------------------------------------------------------------*/
/* supporting routines */
/*-----------------------------------------------------------------------------------*/
float rcm_linear(float A, float B, float C, float D, float x)
{
if (B > A)
if (A<=x && x<=B)
return C+(D-C)/(B-A)*(x-A);
else if (A<=x+TP && x+TP<=B)
return C+(D-C)/(B-A)*(x+TP-A);
else
return x;
else
if (B<=x && x<=A)
return C+(D-C)/(B-A)*(x-A);
else if (B<=x+TP && x+TP<=A)
return C+(D-C)/(B-A)*(x+TP-A);
else
return x;
}
float rcm_left_end(RcmAngle *angle)
{
gfloat alpha = angle->alpha;
gfloat beta = angle->beta;
gint cw_ccw = angle->cw_ccw;
switch (cw_ccw)
{
case (-1): if (alpha < beta) return alpha + TP;
default: return alpha; /* 1 */
}
}
float rcm_right_end(RcmAngle *angle)
{
gfloat alpha = angle->alpha;
gfloat beta = angle->beta;
gint cw_ccw = angle->cw_ccw;
switch (cw_ccw)
{
case 1: if (beta < alpha) return beta + TP;
default: return beta; /* -1 */
}
}
float rcm_angle_inside_slice(float angle, RcmAngle *slice)
{
return angle_mod_2PI(slice->cw_ccw * (slice->beta-angle)) /
angle_mod_2PI(slice->cw_ccw * (slice->beta-slice->alpha));
}
gint rcm_is_gray(float s)
{
if (s <= Current.Gray->gray_sat) return 1;
return 0;
}
/*-----------------------------------------------------------------------------------*/
/* reduce image/selection for preview */
/*-----------------------------------------------------------------------------------*/
ReducedImage *rcm_reduce_image(GDrawable *drawable, GDrawable *mask, gint LongerSize, gint Slctn)
{
GPixelRgn srcPR, srcMask;
ReducedImage *temp;
guchar *tempRGB, *src_row, *tempmask, *src_mask_row;
gint i, j, whichcol, whichrow, x1, x2, y1, y2;
gint RH, RW, width, height, bytes;
gint NoSelectionMade;
hsv *tempHSV, H, S, V;
guchar R, G ,B;
bytes = drawable->bpp;
temp = g_new(ReducedImage, 1);
/* get bounds of image or selection */
gimp_drawable_mask_bounds(drawable->id, &x1, &y1, &x2, &y2);
if ( ((x2-x1) != drawable->width) && ((y2-y1) != drawable->height))
NoSelectionMade = FALSE;
else
NoSelectionMade = TRUE;
switch (Slctn)
{
case ENTIRE_IMAGE:
x1 = 0;
x2 = drawable->width;
y1 = 0;
y2 = drawable->height;
break;
case SELECTION_IN_CONTEXT:
x1 = MAX(0, x1 - (x2-x1) / 2.0);
x2 = MIN(drawable->width, x2 + (x2-x1) / 2.0);
y1 = MAX(0, y1 - (y2-y1) / 2.0);
y2 = MIN(drawable->height, y2 + (y2-y1) / 2.0);
break;
default:
break; /* take selection dimensions */
}
/* calculate size of preview */
width = x2 - x1;
height = y2 - y1;
if (width > height)
{
RW = LongerSize;
RH = (float) height * (float) LongerSize / (float) width;
}
else
{
RH = LongerSize;
RW = (float)width * (float) LongerSize / (float) height;
}
/* allocate memory */
tempRGB = (guchar *) malloc(RW * RH * bytes);
tempHSV = (hsv *) malloc(RW * RH * bytes * sizeof(hsv));
tempmask = (guchar *) malloc(RW * RH);
gimp_pixel_rgn_init(&srcPR, drawable, x1, y1, width, height, FALSE, FALSE);
gimp_pixel_rgn_init(&srcMask, mask, x1, y1, width, height, FALSE, FALSE);
src_row = (guchar *) malloc(width * bytes);
src_mask_row = (guchar *) malloc(width * bytes);
/* reduce image */
for (i=0; i<RH; i++)
{
whichrow = (float)i * (float)height / (float)RH;
gimp_pixel_rgn_get_row (&srcPR, src_row, x1, y1+whichrow, width);
gimp_pixel_rgn_get_row (&srcMask, src_mask_row, x1, y1+whichrow, width);
for (j=0; j<RW; j++)
{
whichcol = (float)j * (float)width / (float)RW;
if (NoSelectionMade)
tempmask[i*RW+j] = 255;
else
tempmask[i*RW+j] = src_mask_row[whichcol];
R = src_row[whichcol*bytes+0];
G = src_row[whichcol*bytes+1];
B = src_row[whichcol*bytes+2];
rgb_to_hsv(R/255.0, G/255.0, B/255.0, &H, &S, &V);
tempRGB[i*RW*bytes+j*bytes+0] = R;
tempRGB[i*RW*bytes+j*bytes+1] = G;
tempRGB[i*RW*bytes+j*bytes+2] = B;
tempHSV[i*RW*bytes+j*bytes+0] = H;
tempHSV[i*RW*bytes+j*bytes+1] = S;
tempHSV[i*RW*bytes+j*bytes+2] = V;
if (bytes == 4)
tempRGB[i*RW*bytes+j*bytes+3] = src_row[whichcol*bytes+3];
} /* for j */
} /* for i */
/* return values */
temp->width = RW;
temp->height = RH;
temp->rgb = tempRGB;
temp->hsv = tempHSV;
temp->mask = tempmask;
return temp;
}
/*-----------------------------------------------------------------------------------*/
/* render before/after preview */
/*-----------------------------------------------------------------------------------*/
static gint rcm_fake_transparency(gint i, gint j)
{
if ( ((i%20)-10)*((j%20)-10) > 0 ) return 102;
return 153;
}
void rcm_render_preview(GtkWidget *preview, gint version)
{
ReducedImage *reduced;
gint RW, RH, bytes, i, j, k, unchanged, skip;
guchar *rgb_array, *a;
hsv H, S, V, R, G, B;
hsv *hsv_array;
float degree, transp;
/* init some variables */
reduced = Current.reduced;
RW = reduced->width;
RH = reduced->height;
bytes = Current.drawable->bpp;
hsv_array = reduced->hsv;
rgb_array = reduced->rgb;
a = (guchar *) malloc(bytes * RW);
if (preview == NULL)
{
printf("Asked to preview a NULL! Shouldn't happen!\n");
return;
}
if (version == CURRENT)
{
for (i=0; i<RH; i++)
{
for (j=0; j<RW; j++)
{
unchanged = 1; /* TRUE */
skip = 0; /* FALSE */
H = hsv_array[i*RW*bytes + j*bytes + 0];
S = hsv_array[i*RW*bytes + j*bytes + 1];
V = hsv_array[i*RW*bytes + j*bytes + 2];
if (rcm_is_gray(S) && (reduced->mask[i*RW+j] != 0))
{
switch (Current.Gray_to_from)
{
case GRAY_FROM:
if (rcm_angle_inside_slice(Current.Gray->hue, Current.From->angle) <= 1)
{
H = Current.Gray->hue/TP;
S = Current.Gray->satur;
}
else
skip = 1;
break;
case GRAY_TO:
unchanged = 0;
skip = 1;
hsv_to_rgb(Current.Gray->hue/TP, Current.Gray->satur, V, &R,&G,&B);
break;
default: break;
} /* switch */
} /* if */
if (!skip)
{
unchanged = 0;
H = rcm_linear(rcm_left_end(Current.From->angle),
rcm_right_end(Current.From->angle),
rcm_left_end(Current.To->angle),
rcm_right_end(Current.To->angle),
H*TP);
H = angle_mod_2PI(H) / TP;
hsv_to_rgb(H,S,V, &R,&G,&B);
} /* if (!skip) */
if (unchanged)
degree = 0;
else
degree = reduced->mask[i*RW+j] / 255.0;
a[j*3+0] = (1-degree) * rgb_array[i*RW*bytes + j*bytes + 0] + degree * R * 255;
a[j*3+1] = (1-degree) * rgb_array[i*RW*bytes + j*bytes + 1] + degree * G * 255;
a[j*3+2] = (1-degree) * rgb_array[i*RW*bytes + j*bytes + 2] + degree * B * 255;
/* apply transparency */
if (bytes == 4)
{
for (k=0; k<3; k++)
{
// transp = reduced->mask[i*RW*bytes+j*bytes+3] / 255.0;
transp = rgb_array[i*RW*bytes+j*bytes+3] / 255.0;
a[3*j+k] = transp * a[3*j+k] + (1-transp) * rcm_fake_transparency(i,j);
}
} /* if */
} /* for j */
gtk_preview_draw_row(GTK_PREVIEW(preview), a, 0, i, RW);
} /* for i */
}
else /* ORIGINAL */
{
for (i=0; i<RH; i++)
{
for (j=0; j<RW; j++)
{
a[j*3+0] = rgb_array[i*RW*bytes + j*bytes + 0];
a[j*3+1] = rgb_array[i*RW*bytes + j*bytes + 1];
a[j*3+2] = rgb_array[i*RW*bytes + j*bytes + 2];
if (bytes == 4)
{
for (k=0; k<3; k++)
{
transp = rgb_array[i*RW*bytes+j*bytes+3] / 255.0;
a[3*j+k] = transp * a[3*j+k] + (1-transp) * rcm_fake_transparency(i,j);
}
} /* if */
} /* for j */
gtk_preview_draw_row(GTK_PREVIEW(preview), a, 0, i, RW);
} /* for i */
}
free(a);
gtk_widget_draw(preview, NULL);
gdk_flush();
}
/*-----------------------------------------------------------------------------------*/
/* render circle */
/*-----------------------------------------------------------------------------------*/
void rcm_render_circle(GtkWidget *preview, int sum, int margin)
{
gint i, j;
hsv h, s, v, r, g, b;
guchar *a;
a = (guchar *) malloc(3*sum);
if (preview == NULL) return;
for (j=0; j<sum; j++)
{
for (i=0; i<sum; i++)
{
s = sqrt((sqr(i-sum/2.0) + sqr(j-sum/2.0)) / (float)sqr(sum/2.0-margin));
if (s > 1)
{
a[i*3+0] = 255;
a[i*3+1] = 255;
a[i*3+2] = 255;
}
else
{
h = arctg(sum/2.0-j, i-sum/2.0)/(2*PI);
v = 1-sqrt(s)/2;
hsv_to_rgb(h,s,v, &r, &g, &b);
a[i*3+0] = r*255;
a[i*3+1] = g*255;
a[i*3+2] = b*255;
}
}
gtk_preview_draw_row(GTK_PREVIEW(preview), a, 0, j, sum);
}
free(a);
gtk_widget_draw(preview, NULL);
gdk_flush();
}
/*-----------------------------------------------------------------------------------*/
/* Conversion routines */
/*-----------------------------------------------------------------------------------*/
void rgb_to_hsv (hsv r, hsv g, hsv b, hsv *h, hsv *s, hsv *l)
{
hsv v;
hsv m;
hsv vm;
hsv r2, g2, b2;
v = MAX(r,g);
v = MAX(v,b);
m = MIN(r,g);
m = MIN(m,b);
if ((*l = (m + v) / 2.0) <= 0.0)
{
*s = *h = 0;
return;
}
if ((*s = vm = v - m) > 0.0)
{
*s /= (*l <= 0.5) ? (v + m ) : (2.0 - v - m);
}
else
{
*h = 0;
return;
}
r2 = (v - r) / vm;
g2 = (v - g) / vm;
b2 = (v - b) / vm;
if (r == v)
*h = (g == m ? 5.0 + b2 : 1.0 - g2);
else if (g == v)
*h = (b == m ? 1.0 + r2 : 3.0 - b2);
else
*h = (r == m ? 3.0 + g2 : 5.0 - r2);
*h /= 6;
}
void hsv_to_rgb (hsv h, hsv sl, hsv l, hsv *r, hsv *g, hsv *b)
{
hsv v, m, sv;
gint sextant;
hsv fract, vsf, mid1, mid2;
v = (l <= 0.5) ? (l * (1.0 + sl)) : (l + sl - l * sl);
if (v <= 0)
{
*r = *g = *b = 0.0;
}
else
{
m = l + l - v;
sv = (v - m ) / v;
h *= 6.0;
sextant = h;
fract = h - sextant;
vsf = v * sv * fract;
mid1 = m + vsf;
mid2 = v - vsf;
switch (sextant)
{
case 0: *r = v; *g = mid1; *b = m; break;
case 1: *r = mid2; *g = v; *b = m; break;
case 2: *r = m; *g = v; *b = mid1; break;
case 3: *r = m; *g = mid2; *b = v; break;
case 4: *r = mid1; *g = m; *b = v; break;
case 5: *r = v; *g = m; *b = mid2; break;
}
}
}

82
plug-ins/rcm/rcm_misc.h Normal file
View file

@ -0,0 +1,82 @@
/*
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This is a plug-in for the GIMP.
*
* Colormap-Rotation plug-in. Exchanges two color ranges.
*
* Copyright (C) 1999 Sven Anders (anderss@fmi.uni-passau.de)
* Based on code from Pavel Grinfeld (pavel@ml.com)
*
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/*-----------------------------------------------------------------------------------
* Change log:
*
* Version 2.0, 04 April 1999.
* Nearly complete rewrite, made plug-in stable.
* (Works with GIMP 1.1 and GTK+ 1.2)
*
* Version 1.0, 27 March 1997.
* Initial (unstable) release by Pavel Grinfeld
*
*-----------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------*/
/* Global defines */
/*-----------------------------------------------------------------------------------*/
#define sqr(X) ((X)*(X))
#define SWAP(X,Y) {float t=X; X=Y; Y=t;}
/*-----------------------------------------------------------------------------------*/
/* used in 'rcm_callback.c' and 'rcm_dialog.c' */
/*-----------------------------------------------------------------------------------*/
float arctg(float y, float x);
float min_prox(float alpha, float beta, float angle);
float *closest(float *alpha, float *beta, float angle);
float angle_mod_2PI(float angle);
ReducedImage *rcm_reduce_image(GDrawable *, GDrawable *, gint, gint);
void rcm_render_preview(GtkWidget *, gint);
void rcm_render_circle(GtkWidget *preview, int sum, int margin);
/*-----------------------------------------------------------------------------------*/
/* only used in 'rcm.c' (or local) */
/*-----------------------------------------------------------------------------------*/
void rgb_to_hsv (hsv r, hsv g, hsv b, hsv *h, hsv *s, hsv *l);
void hsv_to_rgb (hsv h, hsv sl, hsv l, hsv *r, hsv *g, hsv *b);
float rcm_angle_inside_slice(float angle, RcmAngle *slice);
gint rcm_is_gray(float s);
float rcm_linear(float, float, float, float, float);
float rcm_left_end(RcmAngle *angle);
float rcm_right_end(RcmAngle *angle);
/*-----------------------------------------------------------------------------------*/

163
plug-ins/rcm/rcm_pixmaps.h Normal file
View file

@ -0,0 +1,163 @@
/* XPM */
static char * rcm_360[] = {
"24 24 15 1",
" c None",
". c #E50466",
"+ c #E50365",
"@ c #F20233",
"# c #FF0000",
"$ c #FE0000",
"% c #FB000C",
"& c #F50126",
"* c #F80119",
"= c #F20132",
"- c #EB034C",
"; c #EB024C",
"> c #F80019",
", c #E20472",
"' c #E80359",
" ",
" ",
" ",
" ",
" ...+++ ",
" @###$$$% ",
" $& @*$ ",
" $= * ",
" %& @% ",
" -$ $; ",
" >#$$$$# -$ ",
" $ ",
" $ ",
" $- $ ",
" $,%@ $ ",
" %>$ =% $> ",
" @ > $+ ",
" @ @% @& ",
" ' &$ $& ",
" =#......$= ",
" ###$$$ ",
" ",
" ",
" "};
/* XPM */
static char * rcm_a_b[] = {
"24 24 14 1",
" c None",
". c #FE0000",
"+ c #E50466",
"@ c #FF0000",
"# c #F20233",
"$ c #F50126",
"% c #F80019",
"& c #FB000C",
"* c #F20132",
"= c #EB024C",
"- c #E50365",
"; c #EB034C",
"> c #E80359",
", c #F80119",
" ",
" . + ",
" @ #$ ",
" @ @% ",
" @@@#+ ",
" .@$ $&# ",
" @$$ *$ ",
" . =# -*; ",
" . = $> ",
" @ * $= ",
" . #= ",
" @ $> ",
" @ .- ",
" . ;* ",
" @ ; ",
" @ +. ",
" @ , ",
" . #> > ",
" . >$ >* #> ",
" @ =# * , ",
" @ =$&, ",
" . &.% ",
" .;++++++++++++++,.#+++ ",
" .@@....@@@@...........$"};
/* XPM */
static char * rcm_ccw[] = {
"24 24 13 1",
" c None",
". c #F20233",
"+ c #EB034C",
"@ c #FF0000",
"# c #F20132",
"$ c #FB000C",
"% c #F50126",
"& c #FE0000",
"* c #E50365",
"= c #EB024C",
"- c #E50466",
"; c #F80019",
"> c #F80119",
" ",
" ",
" ",
" ",
" ",
" ..... ",
" +@#####$% ",
" &#* &# ",
" . .% +% ",
" . +& $# ",
" @&+=#- .# ",
" @&%% $ ",
" # ",
" ",
" . .$$ ",
" ; $#$&= ",
" -& >=& ",
" %$ >& + ",
" %& &; ",
" *;@.-+&&* ",
" =@% ",
" ",
" ",
" "};
/* XPM */
static char * rcm_cw[] = {
"24 24 13 1",
" c None",
". c #F20233",
"+ c #F50126",
"@ c #FB000C",
"# c #F20132",
"$ c #FE0000",
"% c #EB024C",
"& c #FF0000",
"* c #E50365",
"= c #E50466",
"- c #EB034C",
"; c #F80019",
"> c #F80119",
" ",
" ",
" ",
" ",
" ",
" ..... ",
" +@#####$% ",
" .& *.$ ",
" +% +# . ",
" .@ $% # ",
" .# =.%-$$ ",
" @ ++$$ ",
" # ",
" ",
" @@. . ",
" -$@#@ ; ",
" $%> $* ",
" % $> @+ ",
" ;$ $+ ",
" *&&-=.$;* ",
" +$% ",
" ",
" ",
" "};