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

fixed help ID. 

2004-01-30  Michael Natterer  <mitch@gimp.org>

	* plug-ins/rcm/rcm_dialog.c (rcm_dialog): fixed help ID.

	* plug-ins/rcm/rcm.[ch]
	* plug-ins/rcm/rcm_callback.[ch]
	* plug-ins/rcm/rcm_dialog.[ch]
	* plug-ins/rcm/rcm_gdk.[ch]
	* plug-ins/rcm/rcm_misc.[ch]: completely reindented, removed
	overly long /*---...---*/ comment lines, fixed spacing.
This commit is contained in:
Michael Natterer 2004-01-30 11:53:28 +00:00 committed by Michael Natterer
parent e9c6e913f4
commit a6a21841a1
11 changed files with 955 additions and 985 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
ChangeLog
View File

@ -1,3 +1,14 @@
2004-01-30 Michael Natterer <mitch@gimp.org>
* plug-ins/rcm/rcm_dialog.c (rcm_dialog): fixed help ID.
* plug-ins/rcm/rcm.[ch]
* plug-ins/rcm/rcm_callback.[ch]
* plug-ins/rcm/rcm_dialog.[ch]
* plug-ins/rcm/rcm_gdk.[ch]
* plug-ins/rcm/rcm_misc.[ch]: completely reindented, removed
overly long /*---...---*/ comment lines, fixed spacing.
2004-01-30 Michael Schumacher <schumaml@cvs.gnome.org>
* libgimpwidgets/gimpwidgets.def: added missing symbols.

260
plug-ins/rcm/rcm.c
View File

@ -24,9 +24,9 @@
* 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)
@ -34,24 +34,25 @@
* Version 1.0, 27 March 1997.
* Initial (unstable) release by Pavel Grinfeld
*
*-----------------------------------------------------------------------------------*/
#include <stdio.h>
#include <math.h>
*----------------------------------------------------------------------------*/
#include "config.h"
#include <stdio.h>
#include <gtk/gtk.h>
#include "libgimp/gimp.h"
#include "libgimp/stdplugins-intl.h"
#include "rcm.h"
#include "rcm_misc.h"
#include "rcm_dialog.h"
#include "rcm_callback.h"
/*-----------------------------------------------------------------------------------*/
#include "libgimp/stdplugins-intl.h"
/* Forward declarations */
/*-----------------------------------------------------------------------------------*/
static void query (void);
static void run (const gchar *name,
@ -60,9 +61,8 @@ static void run (const gchar *name,
gint *nreturn_vals,
GimpParam **return_vals);
/*-----------------------------------------------------------------------------------*/
/* Global variables */
/*-----------------------------------------------------------------------------------*/
RcmParams Current =
{
@ -72,10 +72,6 @@ RcmParams Current =
GRAY_TO
};
/*-----------------------------------------------------------------------------------*/
/* Local variables */
/*-----------------------------------------------------------------------------------*/
GimpPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
@ -84,17 +80,12 @@ GimpPlugInInfo PLUG_IN_INFO =
run, /* run_proc */
};
/*-----------------------------------------------------------------------------------*/
/* Dummy function */
/*-----------------------------------------------------------------------------------*/
MAIN()
/*-----------------------------------------------------------------------------------*/
/* Query plug-in */
/*-----------------------------------------------------------------------------------*/
static void
/* Query plug-in */
static void
query (void)
{
GimpParamDef args[] =
@ -119,95 +110,95 @@ query (void)
args, NULL);
}
/*-----------------------------------------------------------------------------------*/
/* Rotate colormap of a single row */
/*-----------------------------------------------------------------------------------*/
void
rcm_row (const guchar *src_row,
/* Rotate colormap of a single row */
void
rcm_row (const guchar *src_row,
guchar *dest_row,
gint row,
gint row_width,
gint row,
gint row_width,
gint bytes)
{
gint col, bytenum, skip;
gdouble H,S,V;
guchar rgb[3];
for (col=0; col < row_width; col++)
{
skip = 0;
rgb[0] = src_row[col*bytes + 0];
rgb[1] = src_row[col*bytes + 1];
rgb[2] = src_row[col*bytes + 2];
gimp_rgb_to_hsv4 (rgb, &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;
gimp_hsv_to_rgb4 (rgb, Current.Gray->hue/TP, Current.Gray->satur, V);
}
}
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);
gint col, bytenum, skip;
gdouble H, S, V;
guchar rgb[3];
H = angle_mod_2PI(H) / TP;
gimp_hsv_to_rgb4 (rgb, H, S, V);
}
dest_row[col * bytes + 0] = rgb[0];
dest_row[col * bytes + 1] = rgb[1];
dest_row[col * bytes + 2] = rgb[2];
if (bytes > 3)
for (col = 0; col < row_width; col++)
{
for (bytenum=3; bytenum<bytes; bytenum++)
dest_row[col*bytes+bytenum] = src_row[col*bytes+bytenum];
skip = 0;
rgb[0] = src_row[col * bytes + 0];
rgb[1] = src_row[col * bytes + 1];
rgb[2] = src_row[col * bytes + 2];
gimp_rgb_to_hsv4 (rgb, &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;
gimp_hsv_to_rgb4 (rgb, Current.Gray->hue / TP,
Current.Gray->satur, V);
}
}
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;
gimp_hsv_to_rgb4 (rgb, H, S, V);
}
dest_row[col * bytes + 0] = rgb[0];
dest_row[col * bytes + 1] = rgb[1];
dest_row[col * bytes + 2] = rgb[2];
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
/* Rotate colormap row by row ... */
void
rcm (GimpDrawable *drawable)
{
GimpPixelRgn srcPR, destPR;
gint width, height;
gint bytes;
guchar *src_row, *dest_row;
gint row;
gint x1, y1, x2, y2;
gint width, height;
gint bytes;
guchar *src_row, *dest_row;
gint row;
gint x1, y1, x2, y2;
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
width = drawable->width;
width = drawable->width;
height = drawable->height;
bytes = drawable->bpp;
bytes = drawable->bpp;
src_row = g_new (guchar, (x2 - x1) * bytes);
dest_row = g_new (guchar, (x2 - x1) * bytes);
@ -215,31 +206,30 @@ rcm (GimpDrawable *drawable)
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));
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));
}
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->drawable_id, TRUE);
gimp_drawable_update(drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, x1, y1, (x2 - x1), (y2 - y1));
g_free (src_row);
g_free (dest_row);
}
/*-----------------------------------------------------------------------------------*/
/* STANDARD RUN */
/*-----------------------------------------------------------------------------------*/
static void
run (const gchar *name,
@ -248,43 +238,45 @@ run (const gchar *name,
gint *nreturn_vals,
GimpParam **return_vals)
{
GimpParam values[1];
GimpParam values[1];
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
*nreturn_vals = 1;
*return_vals = values;
*return_vals = values;
INIT_I18N ();
values[0].type = GIMP_PDB_STATUS;
values[0].type = GIMP_PDB_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 */
/* works not on INDEXED images */
if (gimp_drawable_is_indexed (Current.drawable->drawable_id) ||
gimp_drawable_is_gray (Current.drawable->drawable_id) )
{
status = GIMP_PDB_EXECUTION_ERROR;
}
else
{
/* call dialog and rotate the colormap */
if (gimp_drawable_is_rgb(Current.drawable->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 = GIMP_PDB_EXECUTION_ERROR;
}
}
else
{
/* call dialog and rotate the colormap */
if (gimp_drawable_is_rgb (Current.drawable->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 = GIMP_PDB_EXECUTION_ERROR;
}
values[0].data.d_status = status;
if (status == GIMP_PDB_SUCCESS)
gimp_drawable_detach(Current.drawable);
gimp_drawable_detach (Current.drawable);
}

19
plug-ins/rcm/rcm.h
View File

@ -24,9 +24,9 @@
* 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)
@ -34,21 +34,19 @@
* Version 1.0, 27 March 1997.
* Initial (unstable) release by Pavel Grinfeld
*
*-----------------------------------------------------------------------------------*/
*----------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------*/
/* Global defines */
/*-----------------------------------------------------------------------------------*/
#define TP (2*G_PI)
/*-----------------------------------------------------------------------------------*/
/* Typedefs */
/*-----------------------------------------------------------------------------------*/
enum { ENTIRE_IMAGE, SELECTION, SELECTION_IN_CONTEXT, PREVIEW_OPTIONS };
enum { EACH, BOTH, DEGREES, RADIANS, RADIANS_OVER_PI,
enum { EACH, BOTH, DEGREES, RADIANS, RADIANS_OVER_PI,
GRAY_FROM, GRAY_TO, CURRENT, ORIGINAL };
typedef enum { VIRGIN, DRAG_START, DRAGING, DO_NOTHING } RcmOp;
@ -132,10 +130,7 @@ typedef struct
RcmBna *Bna;
} RcmParams;
/*-----------------------------------------------------------------------------------*/
/* Global variables */
/*-----------------------------------------------------------------------------------*/
extern RcmParams Current;
/*-----------------------------------------------------------------------------------*/

624
plug-ins/rcm/rcm_callback.c
View File

File diff suppressed because it is too large Load Diff

141
plug-ins/rcm/rcm_callback.h
View File

@ -26,7 +26,7 @@
/*---------------------------------------------------------------------------
* Change log:
*
*
* Version 2.0, 04 April 1999.
* Nearly complete rewrite, made plug-in stable.
* (Works with GIMP 1.1 and GTK+ 1.2)
@ -36,107 +36,106 @@
*
*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/* Misc functions */
/*---------------------------------------------------------------------------*/
float rcm_units_factor(gint units);
float rcm_units_factor (gint units);
gchar *rcm_units_string(gint units);
gchar *rcm_units_string (gint units);
void rcm_set_pixmap (GtkWidget **widget,
GtkWidget *parent,
GtkWidget *label_box,
gchar **pixmap_data);
void rcm_set_pixmap(GtkWidget **widget, GtkWidget *parent,
GtkWidget *label_box, char **pixmap_data);
/*---------------------------------------------------------------------------*/
/* Ok Button */
/*---------------------------------------------------------------------------*/
void rcm_ok_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_360_degrees (GtkWidget *button,
RcmCircle *circle);
void rcm_cw_ccw (GtkWidget *button,
RcmCircle *circle);
void rcm_a_to_b (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_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);
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_to (GtkWidget *button,
gpointer *value);
void rcm_switch_to_gray_from (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_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);
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 */
/*---------------------------------------------------------------------------*/
gboolean rcm_expose_event(GtkWidget *widget, GdkEvent *event,
RcmCircle *circle);
gboolean rcm_expose_event (GtkWidget *widget,
GdkEvent *event,
RcmCircle *circle);
gboolean rcm_button_press_event (GtkWidget *widget,
GdkEvent *event,
RcmCircle *circle);
gboolean rcm_release_event (GtkWidget *widget,
GdkEvent *event,
RcmCircle *circle);
gboolean rcm_motion_notify_event (GtkWidget *widget,
GdkEvent *event,
RcmCircle *circle);
gboolean rcm_button_press_event(GtkWidget *widget, GdkEvent *event,
RcmCircle *circle);
gboolean rcm_release_event(GtkWidget *widget, GdkEvent *event,
RcmCircle *circle);
gboolean rcm_motion_notify_event(GtkWidget *widget, GdkEvent *event,
RcmCircle *circle);
/*---------------------------------------------------------------------------*/
/* Gray circle events */
/*---------------------------------------------------------------------------*/
gboolean rcm_gray_expose_event(GtkWidget *widget, GdkEvent *event,
RcmGray *circle);
gboolean rcm_gray_expose_event (GtkWidget *widget,
GdkEvent *event,
RcmGray *circle);
gboolean rcm_gray_button_press_event (GtkWidget *widget,
GdkEvent *event,
RcmGray *circle);
gboolean rcm_gray_release_event (GtkWidget *widget,
GdkEvent *event,
RcmGray *circle);
gboolean rcm_gray_motion_notify_event (GtkWidget *widget,
GdkEvent *event,
RcmGray *circle);
gboolean rcm_gray_button_press_event(GtkWidget *widget, GdkEvent *event,
RcmGray *circle);
gboolean rcm_gray_release_event(GtkWidget *widget, GdkEvent *event,
RcmGray *circle);
gboolean 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);
/*---------------------------------------------------------------------------*/
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);

228
plug-ins/rcm/rcm_dialog.c
View File

@ -46,13 +46,9 @@
#endif
#undef GTK_DISABLE_DEPRECATED
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include "libgimp/stdplugins-intl.h"
#include "rcm.h"
#include "rcm_misc.h"
#include "rcm_gdk.h"
@ -63,10 +59,10 @@
#include "pixmaps/rcm_a_b.xpm"
#include "pixmaps/rcm_cw.xpm"
#include "libgimp/stdplugins-intl.h"
/*---------------------------------------------------------------------------*/
/* Defines */
/*---------------------------------------------------------------------------*/
#define INITIAL_ALPHA 0
#define INITIAL_BETA G_PI_2
@ -81,9 +77,8 @@
GDK_BUTTON1_MOTION_MASK | \
GDK_POINTER_MOTION_HINT_MASK
/*---------------------------------------------------------------------------*/
/* Previews: create one preview */
/*---------------------------------------------------------------------------*/
static void
rcm_create_one_preview (GtkWidget **preview,
@ -91,21 +86,19 @@ rcm_create_one_preview (GtkWidget **preview,
gint previewWidth,
gint previewHeight)
{
*frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(*frame), GTK_SHADOW_IN);
gtk_container_set_border_width(GTK_CONTAINER(*frame), 0);
gtk_widget_show(*frame);
*frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (*frame), GTK_SHADOW_IN);
gtk_widget_show (*frame);
*preview = gtk_preview_new(GTK_PREVIEW_COLOR);
*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);
gtk_preview_size (GTK_PREVIEW (*preview), previewWidth, previewHeight);
gtk_container_add (GTK_CONTAINER (*frame), *preview);
gtk_widget_show (*preview);
}
/*---------------------------------------------------------------------------*/
/* Previews */
/*---------------------------------------------------------------------------*/
static GtkWidget*
rcm_create_previews (void)
@ -153,9 +146,8 @@ rcm_create_previews (void)
return frame;
}
/*---------------------------------------------------------------------------*/
/* Main: Create one pixmap button */
/*---------------------------------------------------------------------------*/
static void
rcm_create_pixmap_button (GtkWidget **label,
@ -168,84 +160,84 @@ rcm_create_pixmap_button (GtkWidget **label,
gint pos)
{
/* create button */
*xpm_button = gtk_button_new();
*xpm_button = gtk_button_new ();
g_signal_connect (*xpm_button, "clicked",
callback,
data);
gtk_widget_show(*xpm_button);
gtk_widget_show (*xpm_button);
gtk_table_attach(GTK_TABLE(parent), *xpm_button,
0, 1, pos, pos+1, GTK_EXPAND|GTK_FILL, GTK_FILL, 4, 2);
gtk_table_attach (GTK_TABLE (parent), *xpm_button,
0, 1, pos, pos + 1,
GTK_EXPAND | GTK_FILL, GTK_FILL, 4, 2);
/* create hbox */
*label_box = gtk_hbox_new(FALSE, 0);
gtk_widget_show(*label_box);
*label_box = gtk_hbox_new (FALSE, 0);
gtk_widget_show (*label_box);
/* create label */
*label = gtk_label_new(text);
gtk_widget_show(*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);
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);
gtk_container_add (GTK_CONTAINER (*xpm_button), *label_box);
}
/*---------------------------------------------------------------------------*/
/* Set buttons pixmaps */
/*---------------------------------------------------------------------------*/
static void
rcm_set_pixmaps (RcmCircle *circle)
{
rcm_set_pixmap(&circle->cw_ccw_pixmap, circle->cw_ccw_button->parent, circle->cw_ccw_box, rcm_cw_xpm);
rcm_set_pixmap(&circle->a_b_pixmap, circle->a_b_button->parent, circle->a_b_box, rcm_a_b_xpm);
rcm_set_pixmap(&circle->f360_pixmap, circle->f360_button->parent, circle->f360_box, rcm_360_xpm);
rcm_set_pixmap (&circle->cw_ccw_pixmap, circle->cw_ccw_button->parent,
circle->cw_ccw_box, rcm_cw_xpm);
rcm_set_pixmap (&circle->a_b_pixmap, circle->a_b_button->parent,
circle->a_b_box, rcm_a_b_xpm);
rcm_set_pixmap (&circle->f360_pixmap, circle->f360_button->parent,
circle->f360_box, rcm_360_xpm);
}
/*---------------------------------------------------------------------------*/
/* Main: One circles with values and buttons */
/*---------------------------------------------------------------------------*/
static RcmCircle*
rcm_create_one_circle (gint height,
gchar *label_content)
{
GtkWidget *frame, *button_table, *legend_table;
GtkWidget *label, *label_box, *xpm_button, *entry;
GtkWidget *frame, *button_table, *legend_table;
GtkWidget *label, *label_box, *xpm_button, *entry;
GtkAdjustment *adj;
RcmCircle *st;
RcmCircle *st;
st = g_new(RcmCircle, 1);
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->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_set_border_width(GTK_CONTAINER(st->frame), 0);
gtk_widget_show(st->frame);
st->frame = gtk_frame_new (label_content);
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_set_border_width(GTK_CONTAINER(frame), 0);
gtk_widget_show(frame);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
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);
st->preview = gtk_preview_new (GTK_PREVIEW_COLOR);
gtk_preview_size (GTK_PREVIEW (st->preview), height, height);
gtk_container_add (GTK_CONTAINER (frame), st->preview);
gtk_widget_show (st->preview);
/* set signals */
gtk_widget_set_events(st->preview, RANGE_ADJUST_MASK);
gtk_widget_set_events (st->preview, RANGE_ADJUST_MASK);
g_signal_connect_after (st->preview, "expose_event",
G_CALLBACK (rcm_expose_event),
@ -263,46 +255,48 @@ rcm_create_one_circle (gint height,
G_CALLBACK (rcm_motion_notify_event),
st);
rcm_render_circle(st->preview, SUM, MARGIN);
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);
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,
G_CALLBACK (rcm_cw_ccw), st,
(st->angle->cw_ccw>0) ?
_("Switch to clockwise") : _("Switch to c/clockwise"),
button_table, 0);
rcm_create_pixmap_button (&label, &xpm_button, &label_box,
G_CALLBACK (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;
st->cw_ccw_box = label_box;
st->cw_ccw_label = label;
rcm_create_pixmap_button(&label, &xpm_button, &label_box,
G_CALLBACK (rcm_a_to_b), st,
_("Change order of arrows"), button_table, 1);
rcm_create_pixmap_button (&label, &xpm_button, &label_box,
G_CALLBACK (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_box = label_box;
st->a_b_button = xpm_button;
rcm_create_pixmap_button(&label, &xpm_button, &label_box,
G_CALLBACK (rcm_360_degrees), st,
_("Select all"), button_table, 2);
rcm_create_pixmap_button (&label, &xpm_button, &label_box,
G_CALLBACK (rcm_360_degrees), st,
_("Select all"), button_table, 2);
st->f360_pixmap = NULL;
st->f360_box = label_box;
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);
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);
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);
@ -318,58 +312,57 @@ rcm_create_one_circle (gint height,
/* label */
st->alpha_units_label = gtk_label_new(rcm_units_string(Current.Units));
gtk_widget_show(st->alpha_units_label);
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, 4, 4);
gtk_table_attach (GTK_TABLE (legend_table), st->alpha_units_label, 2, 3, 0, 1,
0, GTK_EXPAND, 4, 4);
/* 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, 4, 4);
label = gtk_label_new (_("To"));
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (legend_table), label, 3,4, 0,1,
0, GTK_EXPAND, 4, 4);
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_table_attach(GTK_TABLE(legend_table), entry, 4,5, 0,1,
GTK_EXPAND|GTK_FILL, GTK_EXPAND, 2, 4);
gtk_widget_show(entry);
st->beta_entry = entry = gtk_spin_button_new (adj, 0.01, 4);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (entry), TRUE);
gtk_table_attach (GTK_TABLE (legend_table), entry, 4,5, 0,1,
GTK_EXPAND|GTK_FILL, GTK_EXPAND, 2, 4);
gtk_widget_show (entry);
g_signal_connect (entry, "changed",
G_CALLBACK (rcm_set_beta),
st);
/* label */
st->beta_units_label = gtk_label_new(rcm_units_string(Current.Units));
gtk_widget_show(st->beta_units_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, 4, 4);
gtk_table_attach (GTK_TABLE (legend_table), st->beta_units_label, 5,6, 0,1,
0, GTK_EXPAND, 4, 4);
/* Main: Circle: create table for Preview / Buttons / Legend */
st->table= gtk_table_new(2, 2, FALSE);
gtk_widget_show(st->table);
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), 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), 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);
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);
gtk_container_add (GTK_CONTAINER (st->frame), st->table);
return st;
}
/*---------------------------------------------------------------------------*/
/* Main */
/*---------------------------------------------------------------------------*/
static GtkWidget*
rcm_create_main (void)
@ -391,9 +384,8 @@ rcm_create_main (void)
return vbox;
}
/*---------------------------------------------------------------------------*/
/* Misc: Gray */
/*---------------------------------------------------------------------------*/
static RcmGray*
rcm_create_gray (void)
@ -404,8 +396,8 @@ rcm_create_gray (void)
GtkWidget *label, *entry;
GtkWidget *gray_sat_frame;
GtkWidget *radio_box, *button;
GSList *group = NULL;
RcmGray *st;
GSList *group = NULL;
RcmGray *st;
GtkAdjustment *adj;
st = g_new (RcmGray, 1);
@ -531,7 +523,7 @@ rcm_create_gray (void)
&(Current.Gray_to_from));
/** Gray: What is gray? **/
gray_sat_frame = gtk_frame_new(_("What is Gray?"));
gray_sat_frame = gtk_frame_new (_("What is Gray?"));
gtk_widget_show (gray_sat_frame);
table = gtk_table_new (1, 3, FALSE);
@ -539,7 +531,7 @@ rcm_create_gray (void)
gtk_container_set_border_width (GTK_CONTAINER (table), 4);
gtk_widget_show (table);
label = gtk_label_new(_("Saturation"));
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);
@ -600,9 +592,8 @@ rcm_create_gray (void)
return st;
}
/*----------------------------------------------------------------------------*/
/* Misc */
/*----------------------------------------------------------------------------*/
static GtkWidget *
rcm_create_misc (void)
@ -751,9 +742,8 @@ rcm_create_misc (void)
return table;
}
/*---------------------------------------------------------------------------*/
/* create and call main dialog */
/*---------------------------------------------------------------------------*/
gint
rcm_dialog (void)
@ -770,7 +760,7 @@ rcm_dialog (void)
/* Create dialog */
dlg = gimp_dialog_new (_("Colormap Rotation"), "rcm",
NULL, 0,
gimp_standard_help_func, "filters/rcm.html",
gimp_standard_help_func, "plug-in-rotate-colormap",
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,

16
plug-ins/rcm/rcm_dialog.h
View File

@ -24,9 +24,9 @@
* 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)
@ -34,18 +34,14 @@
* Version 1.0, 27 March 1997.
* Initial (unstable) release by Pavel Grinfeld
*
*-----------------------------------------------------------------------------------*/
*----------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------*/
/* Global defines */
/*-----------------------------------------------------------------------------------*/
#define MAX_PREVIEW_SIZE 150
/*-----------------------------------------------------------------------------------*/
/* Procedures */
/*-----------------------------------------------------------------------------------*/
gint rcm_dialog();
/*-----------------------------------------------------------------------------------*/
gint rcm_dialog (void);

149
plug-ins/rcm/rcm_gdk.c
View File

@ -24,9 +24,9 @@
* 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)
@ -34,135 +34,130 @@
* Version 1.0, 27 March 1997.
* Initial (unstable) release by Pavel Grinfeld
*
*-----------------------------------------------------------------------------------*/
*----------------------------------------------------------------------------*/
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <gtk/gtk.h>
#include <libgimp/gimp.h>
#include <libgimp/gimpui.h>
#include "rcm.h"
#include "rcm_misc.h"
#include "rcm_dialog.h"
#include "rcm_gdk.h"
/*-----------------------------------------------------------------------------------*/
/* Global variables */
/*-----------------------------------------------------------------------------------*/
GdkGC *xor_gc;
/*-----------------------------------------------------------------------------------*/
/* Drawing routines */
/*-----------------------------------------------------------------------------------*/
void
rcm_draw_little_circle (GdkWindow *window,
GdkGC *color,
float hue,
float satur)
void
rcm_draw_little_circle (GdkWindow *window,
GdkGC *color,
gfloat hue,
gfloat satur)
{
int x,y;
gint 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);
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)
void
rcm_draw_large_circle (GdkWindow *window,
GdkGC *color,
gfloat gray_sat)
{
int x, y;
gint x, y;
x = GRAY_CENTER;
y = GRAY_CENTER;
gdk_draw_arc(window, color, 0,
ROUND (x - GRAY_RADIUS * gray_sat),
ROUND (y - GRAY_RADIUS * gray_sat),
ROUND (2 * GRAY_RADIUS * gray_sat),
ROUND (2 * GRAY_RADIUS * gray_sat),
0, 360 * 64);
gdk_draw_arc (window, color, 0,
ROUND (x - GRAY_RADIUS * gray_sat),
ROUND (y - GRAY_RADIUS * gray_sat),
ROUND (2 * GRAY_RADIUS * gray_sat),
ROUND (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,
void
rcm_draw_arrows (GdkWindow *window,
GdkGC *color,
RcmAngle *angle)
{
int dist;
float alpha, beta, cw_ccw, delta;
alpha = angle->alpha;
beta = angle->beta;
gint dist;
gfloat 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;
delta = angle_mod_2PI(beta - alpha);
gdk_draw_line(window,color,
CENTER,
CENTER,
ROUND (CENTER + RADIUS * cos(alpha)),
ROUND (CENTER - RADIUS * sin(alpha)));
if (cw_ccw == -1)
delta = delta - TP;
gdk_draw_line(window,color,
CENTER + RADIUS * cos(alpha),
CENTER - RADIUS * sin(alpha),
ROUND (CENTER + RADIUS * REL * cos(alpha - DEL)),
ROUND (CENTER - RADIUS * REL * sin(alpha - DEL)));
gdk_draw_line (window,color,
CENTER,
CENTER,
ROUND (CENTER + RADIUS * cos(alpha)),
ROUND (CENTER - RADIUS * sin(alpha)));
gdk_draw_line(window,color,
CENTER + RADIUS * cos(alpha),
CENTER - RADIUS * sin(alpha),
ROUND (CENTER + RADIUS * REL * cos(alpha + DEL)),
ROUND (CENTER - RADIUS * REL * sin(alpha + DEL)));
gdk_draw_line( window,color,
CENTER + RADIUS * cos(alpha),
CENTER - RADIUS * sin(alpha),
ROUND (CENTER + RADIUS * REL * cos(alpha - DEL)),
ROUND (CENTER - RADIUS * REL * sin(alpha - DEL)));
gdk_draw_line(window,color,
CENTER,
CENTER,
ROUND (CENTER + RADIUS * cos(beta)),
ROUND (CENTER - RADIUS * sin(beta)));
gdk_draw_line (window,color,
CENTER + RADIUS * cos(alpha),
CENTER - RADIUS * sin(alpha),
ROUND (CENTER + RADIUS * REL * cos(alpha + DEL)),
ROUND (CENTER - RADIUS * REL * sin(alpha + DEL)));
gdk_draw_line(window,color,
CENTER + RADIUS * cos(beta),
CENTER - RADIUS * sin(beta),
ROUND (CENTER + RADIUS * REL * cos(beta - DEL)),
ROUND (CENTER - RADIUS * REL * sin(beta - DEL)));
gdk_draw_line (window,color,
CENTER,
CENTER,
ROUND (CENTER + RADIUS * cos(beta)),
ROUND (CENTER - RADIUS * sin(beta)));
gdk_draw_line(window,color,
CENTER + RADIUS * cos(beta),
CENTER - RADIUS * sin(beta),
ROUND (CENTER + RADIUS * REL * cos(beta + DEL)),
ROUND (CENTER - RADIUS * REL * sin(beta + DEL)));
gdk_draw_line (window,color,
CENTER + RADIUS * cos(beta),
CENTER - RADIUS * sin(beta),
ROUND (CENTER + RADIUS * REL * cos(beta - DEL)),
ROUND (CENTER - RADIUS * REL * sin(beta - DEL)));
gdk_draw_line (window,color,
CENTER + RADIUS * cos(beta),
CENTER - RADIUS * sin(beta),
ROUND (CENTER + RADIUS * REL * cos(beta + DEL)),
ROUND (CENTER - RADIUS * REL * sin(beta + DEL)));
dist = RADIUS * EACH_OR_BOTH;
gdk_draw_line(window,color,
CENTER + dist * cos(beta),
CENTER - dist * sin(beta),
ROUND (CENTER + dist * cos(beta) + cw_ccw * TICK * sin(beta)),
ROUND (CENTER - dist * sin(beta) + cw_ccw * TICK * cos(beta)));
gdk_draw_line (window,color,
CENTER + dist * cos(beta),
CENTER - dist * sin(beta),
ROUND (CENTER + dist * cos(beta) + cw_ccw * TICK * sin(beta)),
ROUND (CENTER - dist * sin(beta) + cw_ccw * TICK * cos(beta)));
alpha *= 180 * 64 / G_PI;
delta *= 180 * 64 / G_PI;
gdk_draw_arc(window, color, 0, CENTER - dist, CENTER - dist,
gdk_draw_arc (window, color, 0, CENTER - dist, CENTER - dist,
2*dist, 2*dist, alpha, delta);
}

30
plug-ins/rcm/rcm_gdk.h
View File

@ -24,9 +24,9 @@
* 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)
@ -34,11 +34,10 @@
* Version 1.0, 27 March 1997.
* Initial (unstable) release by Pavel Grinfeld
*
*-----------------------------------------------------------------------------------*/
*----------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------*/
/* Global defines */
/*-----------------------------------------------------------------------------------*/
#define RADIUS 60
#define MARGIN 4
@ -54,18 +53,19 @@
#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);
/*-----------------------------------------------------------------------------------*/
void rcm_draw_little_circle (GdkWindow *window,
GdkGC *color,
gfloat hue,
gfloat satur);
void rcm_draw_large_circle (GdkWindow *window,
GdkGC *color,
gfloat gray_sat);
void rcm_draw_arrows (GdkWindow *window,
GdkGC *color,
RcmAngle *angle);

397
plug-ins/rcm/rcm_misc.c
View File

@ -24,7 +24,7 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/*-----------------------------------------------------------------------------------
/*----------------------------------------------------------------------------
* Change log:
*
* Version 2.0, 04 April 1999.
@ -34,13 +34,12 @@
* Version 1.0, 27 March 1997.
* Initial (unstable) release by Pavel Grinfeld
*
*-----------------------------------------------------------------------------------*/
*----------------------------------------------------------------------------*/
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#ifdef __GNUC__
#warning GTK_DISABLE_DEPRECATED
@ -68,10 +67,10 @@ 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));
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);
}
@ -81,13 +80,13 @@ closest (float *alpha,
float *beta,
float angle)
{
float temp_alpha = MIN(angle_mod_2PI(*alpha-angle),
TP-angle_mod_2PI(*alpha-angle));
gfloat 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));
gfloat temp_beta = MIN (angle_mod_2PI (*beta -angle),
TP - angle_mod_2PI (*beta -angle));
if (temp_alpha-temp_beta<0)
if (temp_alpha-temp_beta < 0)
return alpha;
else
return beta;
@ -104,9 +103,8 @@ angle_mod_2PI (float angle)
return angle;
}
/*-----------------------------------------------------------------------------------*/
/* supporting routines */
/*-----------------------------------------------------------------------------------*/
float
rcm_linear (float A,
@ -116,19 +114,23 @@ rcm_linear (float A,
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;
{
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;
{
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
@ -139,10 +141,13 @@ rcm_left_end (RcmAngle *angle)
gint cw_ccw = angle->cw_ccw;
switch (cw_ccw)
{
case (-1): if (alpha < beta) return alpha + TP;
default: return alpha; /* 1 */
}
{
case (-1):
if (alpha < beta) return alpha + TP;
default:
return alpha; /* 1 */
}
}
float
@ -153,18 +158,21 @@ rcm_right_end (RcmAngle *angle)
gint cw_ccw = angle->cw_ccw;
switch (cw_ccw)
{
case 1: if (beta < alpha) return beta + TP;
default: return beta; /* -1 */
}
{
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));
return angle_mod_2PI (slice->cw_ccw * (slice->beta-angle)) /
angle_mod_2PI (slice->cw_ccw * (slice->beta-slice->alpha));
}
gboolean
@ -173,9 +181,8 @@ rcm_is_gray (float s)
return (s <= Current.Gray->gray_sat);
}
/*-----------------------------------------------------------------------------------*/
/* reduce image/selection for preview */
/*-----------------------------------------------------------------------------------*/
ReducedImage*
rcm_reduce_image (GimpDrawable *drawable,
@ -183,22 +190,22 @@ rcm_reduce_image (GimpDrawable *drawable,
gint LongerSize,
gint Slctn)
{
guint32 gimage;
GimpPixelRgn srcPR, srcMask;
guint32 gimage;
GimpPixelRgn 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;
gint offx, offy;
gdouble *tempHSV, H, S, V;
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;
gint offx, offy;
gdouble *tempHSV, H, S, V;
bytes = drawable->bpp;
temp = g_new0 (ReducedImage, 1);
/* get bounds of image or selection */
gimp_drawable_mask_bounds(drawable->drawable_id, &x1, &y1, &x2, &y2);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
if (((x2-x1) != drawable->width) || ((y2-y1) != drawable->height))
NoSelectionMade = FALSE;
@ -206,7 +213,7 @@ rcm_reduce_image (GimpDrawable *drawable,
NoSelectionMade = TRUE;
switch (Slctn)
{
{
case ENTIRE_IMAGE:
x1 = 0;
x2 = drawable->width;
@ -223,7 +230,7 @@ rcm_reduce_image (GimpDrawable *drawable,
default:
break; /* take selection dimensions */
}
}
/* clamp to image size since this is the size of the mask */
@ -244,15 +251,15 @@ rcm_reduce_image (GimpDrawable *drawable,
return temp;
if (width > height)
{
RW = LongerSize;
RH = (float) height * (float) LongerSize / (float) width;
}
{
RW = LongerSize;
RH = (float) height * (float) LongerSize / (float) width;
}
else
{
RH = LongerSize;
RW = (float)width * (float) LongerSize / (float) height;
}
{
RH = LongerSize;
RW = (float)width * (float) LongerSize / (float) height;
}
/* allocate memory */
@ -269,52 +276,50 @@ rcm_reduce_image (GimpDrawable *drawable,
/* 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 + offx, y1 + offy + whichrow, width);
for (j=0; j<RW; j++)
for (i = 0; i < RH; i++)
{
whichcol = (float)j * (float)width / (float)RW;
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 + offx, y1 + offy + whichrow, width);
if (NoSelectionMade)
tempmask[i*RW+j] = 255;
else
tempmask[i*RW+j] = src_mask_row[whichcol];
for (j = 0; j < RW; j++)
{
whichcol = (float)j * (float)width / (float)RW;
gimp_rgb_to_hsv4 (&src_row[whichcol*bytes], &H, &S, &V);
if (NoSelectionMade)
tempmask[i*RW+j] = 255;
else
tempmask[i*RW+j] = src_mask_row[whichcol];
tempRGB[i*RW*bytes+j*bytes+0] = src_row[whichcol*bytes+0];
tempRGB[i*RW*bytes+j*bytes+1] = src_row[whichcol*bytes+1];
tempRGB[i*RW*bytes+j*bytes+2] = src_row[whichcol*bytes+2];
gimp_rgb_to_hsv4 (&src_row[whichcol*bytes], &H, &S, &V);
tempHSV[i*RW*bytes+j*bytes+0] = H;
tempHSV[i*RW*bytes+j*bytes+1] = S;
tempHSV[i*RW*bytes+j*bytes+2] = V;
tempRGB[i*RW*bytes+j*bytes+0] = src_row[whichcol*bytes+0];
tempRGB[i*RW*bytes+j*bytes+1] = src_row[whichcol*bytes+1];
tempRGB[i*RW*bytes+j*bytes+2] = src_row[whichcol*bytes+2];
if (bytes == 4)
tempRGB[i*RW*bytes+j*bytes+3] = src_row[whichcol*bytes+3];
tempHSV[i*RW*bytes+j*bytes+0] = H;
tempHSV[i*RW*bytes+j*bytes+1] = S;
tempHSV[i*RW*bytes+j*bytes+2] = V;
} /* for j */
} /* for i */
if (bytes == 4)
tempRGB[i*RW*bytes+j*bytes+3] = src_row[whichcol*bytes+3];
}
}
/* return values */
temp->width = RW;
temp->width = RW;
temp->height = RH;
temp->rgb = tempRGB;
temp->hsv = tempHSV;
temp->mask = tempmask;
temp->rgb = tempRGB;
temp->hsv = tempHSV;
temp->mask = tempmask;
return temp;
}
/*-----------------------------------------------------------------------------------*/
/* render before/after preview */
/*-----------------------------------------------------------------------------------*/
static gint
rcm_fake_transparency (gint i,
@ -331,12 +336,12 @@ rcm_render_preview (GtkWidget *preview,
gint version)
{
ReducedImage *reduced;
gint RW, RH, bytes, i, j, k, unchanged, skip;
guchar *rgb_array, *a;
gdouble H, S, V;
gdouble *hsv_array;
guchar rgb[3];
float degree, transp;
gint RW, RH, bytes, i, j, k, unchanged, skip;
guchar *rgb_array, *a;
gdouble H, S, V;
gdouble *hsv_array;
guchar rgb[3];
gfloat degree, transp;
/* init some variables */
@ -352,114 +357,111 @@ rcm_render_preview (GtkWidget *preview,
a = g_new (guchar, bytes * RW);
if (version == CURRENT)
{
for (i=0; i<RH; i++)
{
for (j=0; j<RW; j++)
{
unchanged = 1; /* TRUE */
skip = 0; /* FALSE */
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];
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;
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;
gimp_hsv_to_rgb4 (rgb, Current.Gray->hue/TP, Current.Gray->satur, V);
break;
case GRAY_TO:
unchanged = 0;
skip = 1;
gimp_hsv_to_rgb4 (rgb, Current.Gray->hue/TP, Current.Gray->satur, V);
break;
default: break;
} /* switch */
} /* if */
default:
break;
}
}
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);
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;
gimp_hsv_to_rgb4 (rgb, H,S,V);
} /* if (!skip) */
H = angle_mod_2PI(H) / TP;
gimp_hsv_to_rgb4 (rgb, H,S,V);
}
if (unchanged)degree = 0;
else
degree = reduced->mask[i*RW+j] / 255.0;
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 * rgb[0];
a[j*3+1] = (1-degree) * rgb_array[i*RW*bytes + j*bytes + 1] + degree * rgb[1];
a[j*3+2] = (1-degree) * rgb_array[i*RW*bytes + j*bytes + 2] + degree * rgb[2];
a[j*3+0] = (1-degree) * rgb_array[i*RW*bytes + j*bytes + 0] + degree * rgb[0];
a[j*3+1] = (1-degree) * rgb_array[i*RW*bytes + j*bytes + 1] + degree * rgb[1];
a[j*3+2] = (1-degree) * rgb_array[i*RW*bytes + j*bytes + 2] + degree * rgb[2];
/* 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);
}
/* 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 */
}
gtk_preview_draw_row (GTK_PREVIEW (preview), a, 0, i, RW);
}
}
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];
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 */
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);
}
}
}
} /* for j */
gtk_preview_draw_row(GTK_PREVIEW(preview), a, 0, i, RW);
} /* for i */
}
gtk_preview_draw_row (GTK_PREVIEW (preview), a, 0, i, RW);
}
}
g_free (a);
gtk_widget_queue_draw (preview);
}
/*-----------------------------------------------------------------------------------*/
/* render circle */
/*-----------------------------------------------------------------------------------*/
void
rcm_render_circle (GtkWidget *preview,
@ -475,25 +477,26 @@ rcm_render_circle (GtkWidget *preview,
a = g_new (guchar, 3*sum);
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 * G_PI);
v = 1 - sqrt (s) / 4;
gimp_hsv_to_rgb4 (&a[i*3], h, s, v);
}
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 * G_PI);
v = 1 - sqrt (s) / 4;
gimp_hsv_to_rgb4 (&a[i*3], h, s, v);
}
}
gtk_preview_draw_row (GTK_PREVIEW (preview), a, 0, j, sum);
}
gtk_preview_draw_row(GTK_PREVIEW(preview), a, 0, j, sum);
}
g_free (a);
gtk_widget_queue_draw (preview);

65
plug-ins/rcm/rcm_misc.h
View File

@ -24,9 +24,9 @@
* 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)
@ -34,44 +34,45 @@
* Version 1.0, 27 March 1997.
* Initial (unstable) release by Pavel Grinfeld
*
*-----------------------------------------------------------------------------------*/
*----------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------*/
/* Global defines */
/*-----------------------------------------------------------------------------------*/
#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 arctg (gfloat y,
gfloat x);
float min_prox (gfloat alpha,
gfloat beta,
gfloat angle);
float *closest (gfloat *alpha,
gfloat *beta,
gfloat angle);
float angle_mod_2PI (gfloat angle);
ReducedImage *rcm_reduce_image (GimpDrawable *,
GimpDrawable *,
gint ,
gint );
void rcm_render_preview (GtkWidget *,
gint);
void rcm_render_circle (GtkWidget *preview,
gint sum,
gint margin);
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(GimpDrawable *, GimpDrawable *, 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) */
/*-----------------------------------------------------------------------------------*/
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);
/*-----------------------------------------------------------------------------------*/
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);