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.

50
plug-ins/rcm/rcm.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,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,15 +80,10 @@ GimpPlugInInfo PLUG_IN_INFO =
run, /* run_proc */
};
/*-----------------------------------------------------------------------------------*/
/* Dummy function */
/*-----------------------------------------------------------------------------------*/
MAIN()
/*-----------------------------------------------------------------------------------*/
/* Query plug-in */
/*-----------------------------------------------------------------------------------*/
static void
query (void)
@ -119,9 +110,8 @@ query (void)
args, NULL);
}
/*-----------------------------------------------------------------------------------*/
/* Rotate colormap of a single row */
/*-----------------------------------------------------------------------------------*/
void
rcm_row (const guchar *src_row,
@ -148,7 +138,8 @@ rcm_row (const guchar *src_row,
{
if (Current.Gray_to_from == GRAY_FROM)
{
if (rcm_angle_inside_slice(Current.Gray->hue,Current.From->angle) <= 1)
if (rcm_angle_inside_slice (Current.Gray->hue,
Current.From->angle) <= 1)
{
H = Current.Gray->hue / TP;
S = Current.Gray->satur;
@ -161,7 +152,8 @@ rcm_row (const guchar *src_row,
else
{
skip = 1;
gimp_hsv_to_rgb4 (rgb, Current.Gray->hue/TP, Current.Gray->satur, V);
gimp_hsv_to_rgb4 (rgb, Current.Gray->hue / TP,
Current.Gray->satur, V);
}
}
@ -189,9 +181,8 @@ rcm_row (const guchar *src_row,
}
}
/*-----------------------------------------------------------------------------------*/
/* Rotate colormap row by row ... */
/*-----------------------------------------------------------------------------------*/
void
rcm (GimpDrawable *drawable)
@ -237,9 +228,8 @@ rcm (GimpDrawable *drawable)
g_free (dest_row);
}
/*-----------------------------------------------------------------------------------*/
/* STANDARD RUN */
/*-----------------------------------------------------------------------------------*/
static void
run (const gchar *name,
@ -276,7 +266,8 @@ run (const gchar *name,
{
gimp_progress_init (_("Rotating the colormap..."));
gimp_tile_cache_ntiles(2 * (Current.drawable->width / gimp_tile_width() + 1));
gimp_tile_cache_ntiles (2 * (Current.drawable->width /
gimp_tile_width () + 1));
rcm (Current.drawable);
gimp_displays_flush ();
}
@ -285,6 +276,7 @@ run (const gchar *name,
}
values[0].data.d_status = status;
if (status == GIMP_PDB_SUCCESS)
gimp_drawable_detach (Current.drawable);
}

15
plug-ins/rcm/rcm.h
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,17 +34,15 @@
* 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 };
@ -132,10 +130,7 @@ typedef struct
RcmBna *Bna;
} RcmParams;
/*-----------------------------------------------------------------------------------*/
/* Global variables */
/*-----------------------------------------------------------------------------------*/
extern RcmParams Current;
/*-----------------------------------------------------------------------------------*/

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

@ -63,9 +63,7 @@
#include "pixmaps/rcm_cw.xpm"
/*---------------------------------------------------------------------------*/
/* Misc functions */
/*---------------------------------------------------------------------------*/
float
rcm_units_factor (gint units)
@ -105,12 +103,11 @@ rcm_set_pixmap (GtkWidget **widget,
style = gtk_widget_get_style (parent);
pixmap = gdk_pixmap_create_from_xpm_d (parent->window, &mask,
&style->bg[GTK_STATE_NORMAL], pixmap_data);
&style->bg[GTK_STATE_NORMAL],
pixmap_data);
if (*widget != NULL)
{
gtk_widget_destroy (*widget);
}
*widget = gtk_pixmap_new (pixmap, mask);
@ -119,9 +116,8 @@ rcm_set_pixmap (GtkWidget **widget,
gtk_widget_show (*widget);
}
/*---------------------------------------------------------------------------*/
/* Circle buttons */
/*---------------------------------------------------------------------------*/
void
rcm_360_degrees (GtkWidget *button,
@ -142,7 +138,8 @@ rcm_cw_ccw (GtkWidget *button,
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_xpm : rcm_ccw_xpm);
circle->cw_ccw_box,
(circle->angle->cw_ccw>0) ? rcm_cw_xpm : rcm_ccw_xpm);
gtk_label_set_text (GTK_LABEL (circle->cw_ccw_label),
(circle->angle->cw_ccw>0) ?
@ -167,9 +164,8 @@ rcm_a_to_b (GtkWidget *button,
rcm_render_preview (Current.Bna->after, CURRENT);
}
/*---------------------------------------------------------------------------*/
/* Misc: units buttons */
/*---------------------------------------------------------------------------*/
static void
rcm_spinbutton_to_degrees (GtkWidget *button,
@ -222,8 +218,6 @@ rcm_switch_to_degrees (GtkWidget *button,
}
}
/*---------------------------------------------------------------------------*/
static void
rcm_spinbutton_to_radians (GtkWidget *button,
float value,
@ -275,8 +269,6 @@ rcm_switch_to_radians (GtkWidget *button,
}
}
/*---------------------------------------------------------------------------*/
static void
rcm_spinbutton_to_radians_over_PI (GtkWidget *button,
float value,
@ -328,15 +320,15 @@ rcm_switch_to_radians_over_PI (GtkWidget *button,
}
}
/*---------------------------------------------------------------------------*/
/* Misc: Gray: mode buttons */
/*---------------------------------------------------------------------------*/
void
rcm_switch_to_gray_to (GtkWidget *button,
gpointer *value)
{
if (!GTK_TOGGLE_BUTTON(button)->active) return;
if (! GTK_TOGGLE_BUTTON (button)->active)
return;
Current.Gray_to_from = GRAY_TO;
rcm_render_preview (Current.Bna->after, CURRENT);
@ -346,28 +338,23 @@ void
rcm_switch_to_gray_from (GtkWidget *button,
gpointer *value)
{
if (!(GTK_TOGGLE_BUTTON(button)->active)) return;
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;
Current.RealTime = GTK_TOGGLE_BUTTON (button)->active;
}
/*---------------------------------------------------------------------------*/
static void
rcm_change_preview (void)
{
@ -392,8 +379,6 @@ rcm_change_preview (void)
gtk_widget_show (Current.Bna->after);
}
/*---------------------------------------------------------------------------*/
void
rcm_selection_in_context (GtkWidget *button,
gpointer *value)
@ -422,9 +407,7 @@ rcm_entire_image (GtkWidget *button,
}
/*---------------------------------------------------------------------------*/
/* Circle events */
/*---------------------------------------------------------------------------*/
gboolean
rcm_expose_event (GtkWidget *widget,
@ -446,8 +429,6 @@ rcm_expose_event (GtkWidget *widget,
return TRUE;
}
/*---------------------------------------------------------------------------*/
gboolean
rcm_button_press_event (GtkWidget *widget,
GdkEvent *event,
@ -476,13 +457,16 @@ rcm_button_press_event (GtkWidget *widget,
{
*(circle->target) = clicked_angle;
gtk_widget_queue_draw (circle->preview);
rcm_draw_arrows(widget->window, widget->style->black_gc, circle->angle);
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));
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));
circle->angle->beta *
rcm_units_factor(Current.Units));
if (Current.RealTime)
rcm_render_preview (Current.Bna->after, CURRENT);
@ -494,8 +478,6 @@ rcm_button_press_event (GtkWidget *widget,
return TRUE;
}
/*---------------------------------------------------------------------------*/
gboolean
rcm_release_event (GtkWidget *widget,
GdkEvent *event,
@ -506,6 +488,7 @@ rcm_release_event (GtkWidget *widget,
gtk_widget_queue_draw (circle->preview);
rcm_draw_arrows (widget->window, widget->style->black_gc, circle->angle);
}
circle->action_flag = VIRGIN;
if (! Current.RealTime)
@ -514,17 +497,15 @@ rcm_release_event (GtkWidget *widget,
return TRUE;
}
/*---------------------------------------------------------------------------*/
gboolean
rcm_motion_notify_event (GtkWidget *widget,
GdkEvent *event,
RcmCircle *circle)
{
gint x, y;
float clicked_angle, delta;
float *alpha, *beta;
int cw_ccw;
gfloat clicked_angle, delta;
gfloat *alpha, *beta;
gint cw_ccw;
GdkGCValues values;
alpha = &(circle->angle->alpha);
@ -555,20 +536,28 @@ rcm_motion_notify_event (GtkWidget *widget,
/* this should be erasing entire angle */
rcm_draw_arrows (widget->window, xor_gc, circle->angle);
}
if (circle->mode == EACH)
{
*(circle->target)=clicked_angle;
else {
}
else
{
circle->angle->alpha=angle_mod_2PI(circle->angle->alpha + delta);
circle->angle->beta =angle_mod_2PI(circle->angle->beta + delta);
}
gdk_window_process_updates (widget->window, FALSE);
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));
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));
circle->angle->beta *
rcm_units_factor(Current.Units));
if (Current.RealTime)
rcm_render_preview (Current.Bna->after, CURRENT);
}
@ -576,9 +565,8 @@ rcm_motion_notify_event (GtkWidget *widget,
return TRUE;
}
/*---------------------------------------------------------------------------*/
/* Gray circle events */
/*---------------------------------------------------------------------------*/
gboolean
rcm_gray_expose_event (GtkWidget *widget,
@ -590,7 +578,8 @@ rcm_gray_expose_event (GtkWidget *widget,
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);
rcm_draw_large_circle (widget->window,
widget->style->black_gc, circle->gray_sat);
}
else if (Current.RealTime)
rcm_render_preview (Current.Bna->after, CURRENT);
@ -598,8 +587,6 @@ rcm_gray_expose_event (GtkWidget *widget,
return TRUE;
}
/*---------------------------------------------------------------------------*/
gboolean
rcm_gray_button_press_event (GtkWidget *widget,
GdkEvent *event,
@ -615,19 +602,23 @@ rcm_gray_button_press_event (GtkWidget *widget,
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;
if (circle->satur > 1.0)
circle->satur = 1;
gtk_widget_queue_draw (circle->preview);
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,
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);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->satur_entry),
circle->satur);
if (Current.RealTime)
rcm_render_preview (Current.Bna->after,CURRENT);
@ -635,8 +626,6 @@ rcm_gray_button_press_event (GtkWidget *widget,
return TRUE;
}
/*---------------------------------------------------------------------------*/
gboolean
rcm_gray_release_event (GtkWidget *widget,
GdkEvent *event,
@ -650,13 +639,12 @@ rcm_gray_release_event (GtkWidget *widget,
circle->action_flag = VIRGIN;
if (!Current.RealTime) rcm_render_preview(Current.Bna->after, CURRENT);
if (!Current.RealTime)
rcm_render_preview (Current.Bna->after, CURRENT);
return TRUE;
}
/*---------------------------------------------------------------------------*/
gboolean
rcm_gray_motion_notify_event (GtkWidget *widget,
GdkEvent *event,
@ -673,14 +661,17 @@ rcm_gray_motion_notify_event (GtkWidget *widget,
if (circle->action_flag == DRAG_START)
{
gtk_widget_queue_draw (circle->preview);
rcm_draw_large_circle(circle->preview->window, circle->preview->style->black_gc,
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);
@ -689,35 +680,38 @@ rcm_gray_motion_notify_event (GtkWidget *widget,
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;
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);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->satur_entry),
circle->satur);
if (Current.RealTime) rcm_render_preview(Current.Bna->after, CURRENT);
if (Current.RealTime)
rcm_render_preview (Current.Bna->after, CURRENT);
return TRUE;
}
/*---------------------------------------------------------------------------*/
/* Spinbuttons */
/*---------------------------------------------------------------------------*/
void
rcm_set_alpha (GtkWidget *entry,
gpointer data)
{
RcmCircle *circle;
RcmCircle *circle = data;
circle = (RcmCircle *) data;
if (circle->action_flag != VIRGIN) return;
if (circle->action_flag != VIRGIN)
return;
circle->angle->alpha = gtk_spin_button_get_value(GTK_SPIN_BUTTON(entry)) /
rcm_units_factor(Current.Units);
circle->angle->alpha = (gtk_spin_button_get_value (GTK_SPIN_BUTTON (entry)) /
rcm_units_factor (Current.Units));
gtk_widget_queue_draw (circle->preview);
@ -727,19 +721,17 @@ rcm_set_alpha (GtkWidget *entry,
rcm_render_preview (Current.Bna->after, CURRENT);
}
/*---------------------------------------------------------------------------*/
void
rcm_set_beta (GtkWidget *entry,
gpointer data)
{
RcmCircle *circle;
RcmCircle *circle = data;
circle=(RcmCircle *) data;
if (circle->action_flag != VIRGIN) return;
if (circle->action_flag != VIRGIN)
return;
circle->angle->beta = gtk_spin_button_get_value(GTK_SPIN_BUTTON(entry)) /
rcm_units_factor(Current.Units);
circle->angle->beta = (gtk_spin_button_get_value (GTK_SPIN_BUTTON (entry)) /
rcm_units_factor(Current.Units));
gtk_widget_queue_draw (circle->preview);
@ -749,72 +741,68 @@ rcm_set_beta (GtkWidget *entry,
rcm_render_preview (Current.Bna->after, CURRENT);
}
/*---------------------------------------------------------------------------*/
void
rcm_set_hue (GtkWidget *entry,
gpointer data)
{
RcmGray *circle;
RcmGray *circle = data;
circle = (RcmGray *) data;
if (circle->action_flag != VIRGIN) return;
if (circle->action_flag != VIRGIN
) return;
circle->hue = gtk_spin_button_get_value(GTK_SPIN_BUTTON(entry)) /
rcm_units_factor(Current.Units);
circle->hue = (gtk_spin_button_get_value (GTK_SPIN_BUTTON (entry)) /
rcm_units_factor(Current.Units));
gtk_widget_queue_draw (circle->preview);
rcm_draw_little_circle(circle->preview->window, circle->preview->style->black_gc,
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,
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;
RcmGray *circle = data;
circle=(RcmGray *) data;
if (circle->action_flag != VIRGIN) return;
if (circle->action_flag != VIRGIN)
return;
circle->satur = gtk_spin_button_get_value (GTK_SPIN_BUTTON (entry));
gtk_widget_queue_draw (circle->preview);
rcm_draw_little_circle(circle->preview->window, circle->preview->style->black_gc,
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,
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;
RcmGray *circle = data;
circle->gray_sat = gtk_spin_button_get_value (GTK_SPIN_BUTTON (entry));
gtk_widget_queue_draw (circle->preview);
rcm_draw_large_circle(circle->preview->window, circle->preview->style->black_gc,
rcm_draw_large_circle (circle->preview->window,
circle->preview->style->black_gc,
circle->gray_sat);
rcm_render_preview (Current.Bna->after, CURRENT);
}
/*---------------------------------------------------------------------------*/

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

@ -36,107 +36,106 @@
*
*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/* 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);
void rcm_set_pixmap (GtkWidget **widget,
GtkWidget *parent,
GtkWidget *label_box,
gchar **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,
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,
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);

58
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,
@ -93,19 +88,17 @@ rcm_create_one_preview (GtkWidget **preview,
{
*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);
*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_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,
@ -175,7 +167,8 @@ rcm_create_pixmap_button (GtkWidget **label,
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);
0, 1, pos, pos + 1,
GTK_EXPAND | GTK_FILL, GTK_FILL, 4, 2);
/* create hbox */
*label_box = gtk_hbox_new (FALSE, 0);
@ -192,21 +185,22 @@ rcm_create_pixmap_button (GtkWidget **label,
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,
@ -227,7 +221,6 @@ rcm_create_one_circle (gint height,
/** 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);
/** Main: Circle: create frame & preview **/
@ -235,14 +228,13 @@ rcm_create_one_circle (gint height,
/* 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);
/* 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);
gtk_widget_show (st->preview);
/* set signals */
gtk_widget_set_events (st->preview, RANGE_ADJUST_MASK);
@ -275,6 +267,7 @@ rcm_create_one_circle (gint height,
(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;
@ -290,6 +283,7 @@ rcm_create_one_circle (gint height,
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_button = xpm_button;
@ -367,9 +361,8 @@ rcm_create_one_circle (gint height,
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)
@ -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,

14
plug-ins/rcm/rcm_dialog.h
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,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);

33
plug-ins/rcm/rcm_gdk.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,40 +34,36 @@
* 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)
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);
@ -76,14 +72,12 @@ rcm_draw_little_circle (GdkWindow *window,
2*LITTLE_RADIUS, 2*LITTLE_RADIUS, 0, 360*64);
}
/*-----------------------------------------------------------------------------------*/
void
rcm_draw_large_circle (GdkWindow *window,
GdkGC *color,
float gray_sat)
gfloat gray_sat)
{
int x, y;
gint x, y;
x = GRAY_CENTER;
y = GRAY_CENTER;
@ -96,7 +90,6 @@ rcm_draw_large_circle (GdkWindow *window,
0, 360 * 64);
}
/*-----------------------------------------------------------------------------------*/
#define REL .8
#define DEL .1
@ -107,14 +100,16 @@ rcm_draw_arrows (GdkWindow *window,
GdkGC *color,
RcmAngle *angle)
{
int dist;
float alpha, beta, cw_ccw, delta;
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;
if (cw_ccw == -1)
delta = delta - TP;
gdk_draw_line (window,color,
CENTER,

28
plug-ins/rcm/rcm_gdk.h
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,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);

79
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
@ -81,10 +80,10 @@ closest (float *alpha,
float *beta,
float angle)
{
float temp_alpha = MIN(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),
gfloat temp_beta = MIN (angle_mod_2PI (*beta -angle),
TP - angle_mod_2PI (*beta -angle));
if (temp_alpha-temp_beta < 0)
@ -104,9 +103,8 @@ angle_mod_2PI (float angle)
return angle;
}
/*-----------------------------------------------------------------------------------*/
/* supporting routines */
/*-----------------------------------------------------------------------------------*/
float
rcm_linear (float A,
@ -116,13 +114,16 @@ 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;
}
else
{
if (B<=x && x<=A)
return C+(D-C)/(B-A)*(x-A);
else if (B<=x+TP && x+TP<=A)
@ -130,6 +131,7 @@ rcm_linear (float A,
else
return x;
}
}
float
rcm_left_end (RcmAngle *angle)
@ -140,8 +142,11 @@ rcm_left_end (RcmAngle *angle)
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 */
}
}
@ -154,8 +159,11 @@ rcm_right_end (RcmAngle *angle)
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 */
}
}
@ -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,
@ -297,9 +304,8 @@ rcm_reduce_image (GimpDrawable *drawable,
if (bytes == 4)
tempRGB[i*RW*bytes+j*bytes+3] = src_row[whichcol*bytes+3];
} /* for j */
} /* for i */
}
}
/* return values */
@ -312,9 +318,8 @@ rcm_reduce_image (GimpDrawable *drawable,
return temp;
}
/*-----------------------------------------------------------------------------------*/
/* render before/after preview */
/*-----------------------------------------------------------------------------------*/
static gint
rcm_fake_transparency (gint i,
@ -336,7 +341,7 @@ rcm_render_preview (GtkWidget *preview,
gdouble H, S, V;
gdouble *hsv_array;
guchar rgb[3];
float degree, transp;
gfloat degree, transp;
/* init some variables */
@ -369,7 +374,8 @@ rcm_render_preview (GtkWidget *preview,
switch (Current.Gray_to_from)
{
case GRAY_FROM:
if (rcm_angle_inside_slice(Current.Gray->hue, Current.From->angle) <= 1)
if (rcm_angle_inside_slice (Current.Gray->hue,
Current.From->angle) <= 1)
{
H = Current.Gray->hue/TP;
S = Current.Gray->satur;
@ -384,9 +390,10 @@ rcm_render_preview (GtkWidget *preview,
gimp_hsv_to_rgb4 (rgb, Current.Gray->hue/TP, Current.Gray->satur, V);
break;
default: break;
} /* switch */
} /* if */
default:
break;
}
}
if (!skip)
{
@ -399,9 +406,10 @@ rcm_render_preview (GtkWidget *preview,
H = angle_mod_2PI(H) / TP;
gimp_hsv_to_rgb4 (rgb, H,S,V);
} /* if (!skip) */
}
if (unchanged)degree = 0;
if (unchanged)
degree = 0;
else
degree = reduced->mask[i*RW+j] / 255.0;
@ -418,14 +426,11 @@ rcm_render_preview (GtkWidget *preview,
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 */
{
@ -444,22 +449,19 @@ rcm_render_preview (GtkWidget *preview,
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 */
}
}
g_free (a);
gtk_widget_queue_draw (preview);
}
/*-----------------------------------------------------------------------------------*/
/* render circle */
/*-----------------------------------------------------------------------------------*/
void
rcm_render_circle (GtkWidget *preview,
@ -492,6 +494,7 @@ rcm_render_circle (GtkWidget *preview,
gimp_hsv_to_rgb4 (&a[i*3], h, s, v);
}
}
gtk_preview_draw_row (GTK_PREVIEW (preview), a, 0, j, sum);
}

57
plug-ins/rcm/rcm_misc.h
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,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);
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_linear (float,
float,
float,
float,
float);
float rcm_left_end (RcmAngle *angle);
float rcm_right_end (RcmAngle *angle);
/*-----------------------------------------------------------------------------------*/