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

1496 lines
32 KiB
C
Raw Blame History

/* The GIMP -- an image manipulation program
* Copyright (C) 1995 Spencer Kimball and Peter Mattis
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include "libgimpcolor/gimpcolor.h"
#include "libgimpwidgets/gimpwidgets.h"
#include "apptypes.h"
#include "color_select.h"
#include "colormaps.h"
#include "gimpdnd.h"
#include "gimprc.h"
#include "session.h"
#include "color_area.h"
#include "libgimp/gimpcolorselector.h"
#include "libgimp/gimpintl.h"
#define XY_DEF_WIDTH 200
#define XY_DEF_HEIGHT 200
#define Z_DEF_WIDTH 15
#define Z_DEF_HEIGHT 200
#define COLOR_AREA_WIDTH 74
#define COLOR_AREA_HEIGHT 20
#define COLOR_AREA_MASK (GDK_EXPOSURE_MASK | \
GDK_BUTTON_PRESS_MASK | \
GDK_BUTTON_RELEASE_MASK | \
GDK_BUTTON1_MOTION_MASK | \
GDK_ENTER_NOTIFY_MASK)
typedef enum
{
COLOR_SELECT_HUE = 0,
COLOR_SELECT_SATURATION,
COLOR_SELECT_VALUE,
COLOR_SELECT_RED,
COLOR_SELECT_GREEN,
COLOR_SELECT_BLUE,
COLOR_SELECT_ALPHA,
COLOR_SELECT_HUE_SATURATION,
COLOR_SELECT_HUE_VALUE,
COLOR_SELECT_SATURATION_VALUE,
COLOR_SELECT_RED_GREEN,
COLOR_SELECT_RED_BLUE,
COLOR_SELECT_GREEN_BLUE
} ColorSelectFillType;
typedef enum
{
UPDATE_VALUES = 1 << 0,
UPDATE_POS = 1 << 1,
UPDATE_XY_COLOR = 1 << 2,
UPDATE_Z_COLOR = 1 << 3,
UPDATE_CALLER = 1 << 6
} ColorSelectUpdateType;
typedef void (* ColorSelectCallback) (const GimpHSV *hsv,
const GimpRGB *rgb,
gpointer data);
typedef struct _ColorSelect ColorSelect;
struct _ColorSelect
{
GtkWidget *xy_color;
GtkWidget *z_color;
gint pos[3];
GimpHSV hsv;
GimpRGB rgb;
gint z_color_fill;
gint xy_color_fill;
GdkGC *gc;
ColorSelectCallback callback;
gpointer client_data;
};
typedef struct _ColorSelectFill ColorSelectFill;
typedef void (* ColorSelectFillUpdateProc) (ColorSelectFill *color_select_fill);
struct _ColorSelectFill
{
guchar *buffer;
gint y;
gint width;
gint height;
GimpHSV hsv;
GimpRGB rgb;
ColorSelectFillUpdateProc update;
};
static GtkWidget * color_select_widget_new (ColorSelect *csp,
const GimpRGB *color);
static void color_select_drop_color (GtkWidget *widget,
const GimpRGB *color,
gpointer data);
static void color_select_update (ColorSelect *csp,
ColorSelectUpdateType);
static void color_select_update_caller (ColorSelect *csp);
static void color_select_update_values (ColorSelect *csp);
static void color_select_update_rgb_values (ColorSelect *csp);
static void color_select_update_hsv_values (ColorSelect *csp);
static void color_select_update_pos (ColorSelect *csp);
static gint color_select_xy_expose (GtkWidget *widget,
GdkEventExpose *eevent,
ColorSelect *color_select);
static gint color_select_xy_events (GtkWidget *widget,
GdkEvent *event,
ColorSelect *color_select);
static gint color_select_z_expose (GtkWidget *widget,
GdkEventExpose *eevent,
ColorSelect *color_select);
static gint color_select_z_events (GtkWidget *widet,
GdkEvent *event,
ColorSelect *color_select);
static void color_select_image_fill (GtkWidget *,
ColorSelectFillType,
const GimpHSV *hsv,
const GimpRGB *rgb);
static void color_select_draw_z_marker (ColorSelect *csp,
GdkRectangle *);
static void color_select_draw_xy_marker (ColorSelect *csp,
GdkRectangle *);
static void color_select_update_red (ColorSelectFill *csf);
static void color_select_update_green (ColorSelectFill *csf);
static void color_select_update_blue (ColorSelectFill *csf);
static void color_select_update_hue (ColorSelectFill *csf);
static void color_select_update_saturation (ColorSelectFill *csf);
static void color_select_update_value (ColorSelectFill *csf);
static void color_select_update_red_green (ColorSelectFill *csf);
static void color_select_update_red_blue (ColorSelectFill *csf);
static void color_select_update_green_blue (ColorSelectFill *csf);
static void color_select_update_hue_saturation (ColorSelectFill *csf);
static void color_select_update_hue_value (ColorSelectFill *csf);
static void color_select_update_saturation_value (ColorSelectFill *csf);
static GtkWidget * color_select_notebook_new (const GimpHSV *hsv,
const GimpRGB *rgb,
gboolean show_alpha,
GimpColorSelectorCallback,
gpointer ,
gpointer *);
static void color_select_notebook_free (gpointer );
static void color_select_notebook_set_color (gpointer ,
const GimpHSV *hsv,
const GimpRGB *rgb);
static void color_select_notebook_set_channel (gpointer ,
GimpColorSelectorChannelType channel);
static void color_select_notebook_update_callback (const GimpHSV *hsv,
const GimpRGB *rgb,
gpointer );
/* Static variables */
static ColorSelectFillUpdateProc update_procs[] =
{
color_select_update_hue,
color_select_update_saturation,
color_select_update_value,
color_select_update_red,
color_select_update_green,
color_select_update_blue,
NULL, /* alpha */
color_select_update_hue_saturation,
color_select_update_hue_value,
color_select_update_saturation_value,
color_select_update_red_green,
color_select_update_red_blue,
color_select_update_green_blue,
};
/* dnd stuff */
static GtkTargetEntry color_select_target_table[] =
{
GIMP_TARGET_COLOR
};
static guint n_color_select_targets = (sizeof (color_select_target_table) /
sizeof (color_select_target_table[0]));
/* Register the GIMP colour selector with the color notebook */
void
color_select_init (void)
{
GimpColorSelectorMethods methods =
{
color_select_notebook_new,
color_select_notebook_free,
color_select_notebook_set_color,
color_select_notebook_set_channel
};
gimp_color_selector_register ("GIMP", "built_in.html", &methods);
}
static GtkWidget *
color_select_widget_new (ColorSelect *csp,
const GimpRGB *color)
{
GtkWidget *main_vbox;
GtkWidget *main_hbox;
GtkWidget *hbox;
GtkWidget *xy_frame;
GtkWidget *z_frame;
main_vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 2);
main_hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), main_hbox, TRUE, FALSE, 0);
gtk_widget_show (main_hbox);
hbox = gtk_hbox_new (FALSE, 2);
gtk_box_pack_start (GTK_BOX (main_hbox), hbox, TRUE, FALSE, 0);
gtk_widget_show (hbox);
/* The x/y component preview */
xy_frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (xy_frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), xy_frame, FALSE, FALSE, 2);
gtk_widget_show (xy_frame);
csp->xy_color = gtk_preview_new (GTK_PREVIEW_COLOR);
gtk_preview_set_dither (GTK_PREVIEW (csp->xy_color), GDK_RGB_DITHER_MAX);
gtk_preview_size (GTK_PREVIEW (csp->xy_color), XY_DEF_WIDTH, XY_DEF_HEIGHT);
gtk_widget_set_events (csp->xy_color, COLOR_AREA_MASK);
gtk_signal_connect_after (GTK_OBJECT (csp->xy_color), "expose_event",
GTK_SIGNAL_FUNC (color_select_xy_expose),
csp);
gtk_signal_connect (GTK_OBJECT (csp->xy_color), "event",
GTK_SIGNAL_FUNC (color_select_xy_events),
csp);
gtk_container_add (GTK_CONTAINER (xy_frame), csp->xy_color);
gtk_widget_show (csp->xy_color);
/* dnd stuff */
gtk_drag_dest_set (csp->xy_color,
GTK_DEST_DEFAULT_HIGHLIGHT |
GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_DROP,
color_select_target_table, n_color_select_targets,
GDK_ACTION_COPY);
gimp_dnd_color_dest_set (csp->xy_color, color_select_drop_color, csp);
/* The z component preview */
z_frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (z_frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), z_frame, FALSE, FALSE, 2);
gtk_widget_show (z_frame);
csp->z_color = gtk_preview_new (GTK_PREVIEW_COLOR);
gtk_preview_set_dither (GTK_PREVIEW (csp->z_color), GDK_RGB_DITHER_MAX);
gtk_preview_size (GTK_PREVIEW (csp->z_color), Z_DEF_WIDTH, Z_DEF_HEIGHT);
gtk_widget_set_events (csp->z_color, COLOR_AREA_MASK);
gtk_signal_connect_after (GTK_OBJECT (csp->z_color), "expose_event",
GTK_SIGNAL_FUNC (color_select_z_expose),
csp);
gtk_signal_connect (GTK_OBJECT (csp->z_color), "event",
GTK_SIGNAL_FUNC (color_select_z_events),
csp);
gtk_container_add (GTK_CONTAINER (z_frame), csp->z_color);
gtk_widget_show (csp->z_color);
return main_vbox;
}
static void
color_select_drop_color (GtkWidget *widget,
const GimpRGB *color,
gpointer data)
{
ColorSelect *csp;
csp = (ColorSelect *) data;
csp->rgb = *color;
color_select_update_hsv_values (csp);
color_select_update_pos (csp);
color_select_update (csp, UPDATE_Z_COLOR);
color_select_update (csp, UPDATE_XY_COLOR);
color_select_update (csp, UPDATE_CALLER);
}
static void
color_select_set_color (ColorSelect *csp,
const GimpHSV *hsv,
const GimpRGB *rgb)
{
if (! csp)
return;
csp->hsv = *hsv;
csp->rgb = *rgb;
color_select_update_pos (csp);
color_select_update (csp, UPDATE_Z_COLOR);
color_select_update (csp, UPDATE_XY_COLOR);
}
static void
color_select_update (ColorSelect *csp,
ColorSelectUpdateType update)
{
if (!csp)
return;
if (update & UPDATE_POS)
color_select_update_pos (csp);
if (update & UPDATE_VALUES)
{
color_select_update_values (csp);
}
if (update & UPDATE_XY_COLOR)
{
color_select_image_fill (csp->xy_color, csp->xy_color_fill,
&csp->hsv, &csp->rgb);
gtk_widget_draw (csp->xy_color, NULL);
}
if (update & UPDATE_Z_COLOR)
{
color_select_image_fill (csp->z_color, csp->z_color_fill,
&csp->hsv, &csp->rgb);
gtk_widget_draw (csp->z_color, NULL);
}
if (update & UPDATE_CALLER)
color_select_update_caller (csp);
}
static void
color_select_update_caller (ColorSelect *csp)
{
if (csp && csp->callback)
{
(* csp->callback) (&csp->hsv,
&csp->rgb,
csp->client_data);
}
}
static void
color_select_update_values (ColorSelect *csp)
{
if (!csp)
return;
switch (csp->z_color_fill)
{
case COLOR_SELECT_RED:
csp->rgb.b = csp->pos[0] / 255.0;
csp->rgb.g = csp->pos[1] / 255.0;
csp->rgb.r = csp->pos[2] / 255.0;
break;
case COLOR_SELECT_GREEN:
csp->rgb.b = csp->pos[0] / 255.0;
csp->rgb.r = csp->pos[1] / 255.0;
csp->rgb.g = csp->pos[2] / 255.0;
break;
case COLOR_SELECT_BLUE:
csp->rgb.g = csp->pos[0] / 255.0;
csp->rgb.r = csp->pos[1] / 255.0;
csp->rgb.b = csp->pos[2] / 255.0;
break;
case COLOR_SELECT_HUE:
csp->hsv.v = csp->pos[0] / 255.0;
csp->hsv.s = csp->pos[1] / 255.0;
csp->hsv.h = csp->pos[2] / 255.0;
break;
case COLOR_SELECT_SATURATION:
csp->hsv.v = csp->pos[0] / 255.0;
csp->hsv.h = csp->pos[1] / 255.0;
csp->hsv.s = csp->pos[2] / 255.0;
break;
case COLOR_SELECT_VALUE:
csp->hsv.s = csp->pos[0] / 255.0;
csp->hsv.h = csp->pos[1] / 255.0;
csp->hsv.v = csp->pos[2] / 255.0;
break;
}
switch (csp->z_color_fill)
{
case COLOR_SELECT_RED:
case COLOR_SELECT_GREEN:
case COLOR_SELECT_BLUE:
color_select_update_hsv_values (csp);
break;
case COLOR_SELECT_HUE:
case COLOR_SELECT_SATURATION:
case COLOR_SELECT_VALUE:
color_select_update_rgb_values (csp);
break;
}
}
static void
color_select_update_rgb_values (ColorSelect *csp)
{
if (! csp)
return;
gimp_hsv_to_rgb (&csp->hsv, &csp->rgb);
}
static void
color_select_update_hsv_values (ColorSelect *csp)
{
if (! csp)
return;
gimp_rgb_to_hsv (&csp->rgb, &csp->hsv);
}
static void
color_select_update_pos (ColorSelect *csp)
{
if (! csp)
return;
switch (csp->z_color_fill)
{
case COLOR_SELECT_RED:
csp->pos[0] = (gint) (csp->rgb.b * 255.999);
csp->pos[1] = (gint) (csp->rgb.g * 255.999);
csp->pos[2] = (gint) (csp->rgb.r * 255.999);
break;
case COLOR_SELECT_GREEN:
csp->pos[0] = (gint) (csp->rgb.b * 255.999);
csp->pos[1] = (gint) (csp->rgb.r * 255.999);
csp->pos[2] = (gint) (csp->rgb.g * 255.999);
break;
case COLOR_SELECT_BLUE:
csp->pos[0] = (gint) (csp->rgb.g * 255.999);
csp->pos[1] = (gint) (csp->rgb.r * 255.999);
csp->pos[2] = (gint) (csp->rgb.b * 255.999);
break;
case COLOR_SELECT_HUE:
csp->pos[0] = (gint) (csp->hsv.v * 255.999);
csp->pos[1] = (gint) (csp->hsv.s * 255.999);
csp->pos[2] = (gint) (csp->hsv.h * 255.999);
break;
case COLOR_SELECT_SATURATION:
csp->pos[0] = (gint) (csp->hsv.v * 255.999);
csp->pos[1] = (gint) (csp->hsv.h * 255.999);
csp->pos[2] = (gint) (csp->hsv.s * 255.999);
break;
case COLOR_SELECT_VALUE:
csp->pos[0] = (gint) (csp->hsv.s * 255.999);
csp->pos[1] = (gint) (csp->hsv.h * 255.999);
csp->pos[2] = (gint) (csp->hsv.v * 255.999);
break;
}
}
static gint
color_select_xy_expose (GtkWidget *widget,
GdkEventExpose *event,
ColorSelect *csp)
{
if (! csp->gc)
csp->gc = gdk_gc_new (widget->window);
color_select_draw_xy_marker (csp, &event->area);
return FALSE;
}
static gint
color_select_xy_events (GtkWidget *widget,
GdkEvent *event,
ColorSelect *csp)
{
GdkEventButton *bevent;
GdkEventMotion *mevent;
gint tx, ty;
switch (event->type)
{
case GDK_BUTTON_PRESS:
bevent = (GdkEventButton *) event;
color_select_draw_xy_marker (csp, NULL);
csp->pos[0] = (bevent->x * 255) / (XY_DEF_WIDTH - 1);
csp->pos[1] = 255 - (bevent->y * 255) / (XY_DEF_HEIGHT - 1);
if (csp->pos[0] < 0)
csp->pos[0] = 0;
if (csp->pos[0] > 255)
csp->pos[0] = 255;
if (csp->pos[1] < 0)
csp->pos[1] = 0;
if (csp->pos[1] > 255)
csp->pos[1] = 255;
gdk_pointer_grab (csp->xy_color->window, FALSE,
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON1_MOTION_MASK |
GDK_BUTTON_RELEASE_MASK,
NULL, NULL, bevent->time);
color_select_draw_xy_marker (csp, NULL);
color_select_update (csp, UPDATE_VALUES | UPDATE_CALLER);
break;
case GDK_BUTTON_RELEASE:
bevent = (GdkEventButton *) event;
color_select_draw_xy_marker (csp, NULL);
csp->pos[0] = (bevent->x * 255) / (XY_DEF_WIDTH - 1);
csp->pos[1] = 255 - (bevent->y * 255) / (XY_DEF_HEIGHT - 1);
if (csp->pos[0] < 0)
csp->pos[0] = 0;
if (csp->pos[0] > 255)
csp->pos[0] = 255;
if (csp->pos[1] < 0)
csp->pos[1] = 0;
if (csp->pos[1] > 255)
csp->pos[1] = 255;
gdk_pointer_ungrab (bevent->time);
color_select_draw_xy_marker (csp, NULL);
color_select_update (csp, UPDATE_VALUES | UPDATE_CALLER);
break;
case GDK_MOTION_NOTIFY:
mevent = (GdkEventMotion *) event;
if (mevent->is_hint)
{
gdk_window_get_pointer (widget->window, &tx, &ty, NULL);
mevent->x = tx;
mevent->y = ty;
}
color_select_draw_xy_marker (csp, NULL);
csp->pos[0] = (mevent->x * 255) / (XY_DEF_WIDTH - 1);
csp->pos[1] = 255 - (mevent->y * 255) / (XY_DEF_HEIGHT - 1);
if (csp->pos[0] < 0)
csp->pos[0] = 0;
if (csp->pos[0] > 255)
csp->pos[0] = 255;
if (csp->pos[1] < 0)
csp->pos[1] = 0;
if (csp->pos[1] > 255)
csp->pos[1] = 255;
color_select_draw_xy_marker (csp, NULL);
color_select_update (csp, UPDATE_VALUES | UPDATE_CALLER);
break;
default:
break;
}
return FALSE;
}
static gint
color_select_z_expose (GtkWidget *widget,
GdkEventExpose *event,
ColorSelect *csp)
{
if (!csp->gc)
csp->gc = gdk_gc_new (widget->window);
color_select_draw_z_marker (csp, &event->area);
return FALSE;
}
static gint
color_select_z_events (GtkWidget *widget,
GdkEvent *event,
ColorSelect *csp)
{
GdkEventButton *bevent;
GdkEventMotion *mevent;
gint tx, ty;
switch (event->type)
{
case GDK_BUTTON_PRESS:
bevent = (GdkEventButton *) event;
color_select_draw_z_marker (csp, NULL);
csp->pos[2] = 255 - (bevent->y * 255) / (Z_DEF_HEIGHT - 1);
csp->pos[2] = CLAMP (csp->pos[2], 0, 255);
gdk_pointer_grab (csp->z_color->window, FALSE,
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON1_MOTION_MASK |
GDK_BUTTON_RELEASE_MASK,
NULL, NULL, bevent->time);
color_select_draw_z_marker (csp, NULL);
color_select_update (csp, UPDATE_VALUES | UPDATE_CALLER);
break;
case GDK_BUTTON_RELEASE:
bevent = (GdkEventButton *) event;
color_select_draw_z_marker (csp, NULL);
csp->pos[2] = 255 - (bevent->y * 255) / (Z_DEF_HEIGHT - 1);
csp->pos[2] = CLAMP (csp->pos[2], 0, 255);
gdk_pointer_ungrab (bevent->time);
color_select_draw_z_marker (csp, NULL);
color_select_update (csp, UPDATE_VALUES | UPDATE_XY_COLOR | UPDATE_CALLER);
break;
case GDK_MOTION_NOTIFY:
mevent = (GdkEventMotion *) event;
if (mevent->is_hint)
{
gdk_window_get_pointer (widget->window, &tx, &ty, NULL);
mevent->x = tx;
mevent->y = ty;
}
color_select_draw_z_marker (csp, NULL);
csp->pos[2] = 255 - (mevent->y * 255) / (Z_DEF_HEIGHT - 1);
csp->pos[2] = CLAMP (csp->pos[2], 0, 255);
color_select_draw_z_marker (csp, NULL);
color_select_update (csp, UPDATE_VALUES | UPDATE_CALLER);
break;
default:
break;
}
return FALSE;
}
static void
color_select_set_channel (ColorSelect *csp,
GimpColorSelectorChannelType type)
{
if (! csp)
return;
switch ((ColorSelectFillType) type)
{
case COLOR_SELECT_HUE:
csp->z_color_fill = COLOR_SELECT_HUE;
csp->xy_color_fill = COLOR_SELECT_SATURATION_VALUE;
break;
case COLOR_SELECT_SATURATION:
csp->z_color_fill = COLOR_SELECT_SATURATION;
csp->xy_color_fill = COLOR_SELECT_HUE_VALUE;
break;
case COLOR_SELECT_VALUE:
csp->z_color_fill = COLOR_SELECT_VALUE;
csp->xy_color_fill = COLOR_SELECT_HUE_SATURATION;
break;
case COLOR_SELECT_RED:
csp->z_color_fill = COLOR_SELECT_RED;
csp->xy_color_fill = COLOR_SELECT_GREEN_BLUE;
break;
case COLOR_SELECT_GREEN:
csp->z_color_fill = COLOR_SELECT_GREEN;
csp->xy_color_fill = COLOR_SELECT_RED_BLUE;
break;
case COLOR_SELECT_BLUE:
csp->z_color_fill = COLOR_SELECT_BLUE;
csp->xy_color_fill = COLOR_SELECT_RED_GREEN;
break;
default:
break;
}
color_select_update (csp, UPDATE_POS);
color_select_update (csp, UPDATE_Z_COLOR | UPDATE_XY_COLOR);
}
static void
color_select_image_fill (GtkWidget *preview,
ColorSelectFillType type,
const GimpHSV *hsv,
const GimpRGB *rgb)
{
ColorSelectFill csf;
gint height;
csf.buffer = g_malloc (preview->requisition.width * 3);
csf.update = update_procs[type];
csf.y = -1;
csf.width = preview->requisition.width;
csf.height = preview->requisition.height;
csf.hsv = *hsv;
csf.rgb = *rgb;
height = csf.height;
if (height > 0)
while (height--)
{
if (csf.update)
(* csf.update) (&csf);
gtk_preview_draw_row (GTK_PREVIEW (preview),
csf.buffer, 0, csf.y, csf.width);
}
g_free (csf.buffer);
}
static void
color_select_draw_z_marker (ColorSelect *csp,
GdkRectangle *clip)
{
gint width;
gint height;
gint y;
gint minx;
gint miny;
if (!csp->gc)
return;
y = (Z_DEF_HEIGHT - 1) - ((Z_DEF_HEIGHT - 1) * csp->pos[2]) / 255;
width = csp->z_color->requisition.width;
height = csp->z_color->requisition.height;
minx = 0;
miny = 0;
if (width <= 0)
return;
if (clip)
{
width = MIN(width, clip->x + clip->width);
height = MIN(height, clip->y + clip->height);
minx = MAX(0, clip->x);
miny = MAX(0, clip->y);
}
if (y >= miny && y < height)
{
gdk_gc_set_function (csp->gc, GDK_INVERT);
gdk_draw_line (csp->z_color->window, csp->gc, minx, y, width - 1, y);
gdk_gc_set_function (csp->gc, GDK_COPY);
}
}
static void
color_select_draw_xy_marker (ColorSelect *csp,
GdkRectangle *clip)
{
gint width;
gint height;
gint x, y;
gint minx, miny;
if (!csp->gc)
return;
x = ((XY_DEF_WIDTH - 1) * csp->pos[0]) / 255;
y = (XY_DEF_HEIGHT - 1) - ((XY_DEF_HEIGHT - 1) * csp->pos[1]) / 255;
width = csp->xy_color->requisition.width;
height = csp->xy_color->requisition.height;
minx = 0;
miny = 0;
if ((width <= 0) || (height <= 0))
return;
gdk_gc_set_function (csp->gc, GDK_INVERT);
if (clip)
{
width = MIN(width, clip->x + clip->width);
height = MIN(height, clip->y + clip->height);
minx = MAX(0, clip->x);
miny = MAX(0, clip->y);
}
if (y >= miny && y < height)
gdk_draw_line (csp->xy_color->window, csp->gc, minx, y, width - 1, y);
if (x >= minx && x < width)
gdk_draw_line (csp->xy_color->window, csp->gc, x, miny, x, height - 1);
gdk_gc_set_function (csp->gc, GDK_COPY);
}
static void
color_select_update_red (ColorSelectFill *csf)
{
guchar *p;
gint i, r;
p = csf->buffer;
csf->y += 1;
r = (csf->height - csf->y + 1) * 255 / csf->height;
if (r < 0)
r = 0;
if (r > 255)
r = 255;
for (i = 0; i < csf->width; i++)
{
*p++ = r;
*p++ = 0;
*p++ = 0;
}
}
static void
color_select_update_green (ColorSelectFill *csf)
{
guchar *p;
gint i, g;
p = csf->buffer;
csf->y += 1;
g = (csf->height - csf->y + 1) * 255 / csf->height;
if (g < 0)
g = 0;
if (g > 255)
g = 255;
for (i = 0; i < csf->width; i++)
{
*p++ = 0;
*p++ = g;
*p++ = 0;
}
}
static void
color_select_update_blue (ColorSelectFill *csf)
{
guchar *p;
gint i, b;
p = csf->buffer;
csf->y += 1;
b = (csf->height - csf->y + 1) * 255 / csf->height;
if (b < 0)
b = 0;
if (b > 255)
b = 255;
for (i = 0; i < csf->width; i++)
{
*p++ = 0;
*p++ = 0;
*p++ = b;
}
}
static void
color_select_update_hue (ColorSelectFill *csf)
{
guchar *p;
gfloat h, f;
gint r, g, b;
gint i;
p = csf->buffer;
csf->y += 1;
h = csf->y * 360.0 / csf->height;
h = CLAMP (360 - h, 0, 360);
h /= 60;
f = (h - (int) h) * 255;
r = g = b = 0;
switch ((int) h)
{
case 0:
r = 255;
g = f;
b = 0;
break;
case 1:
r = 255 - f;
g = 255;
b = 0;
break;
case 2:
r = 0;
g = 255;
b = f;
break;
case 3:
r = 0;
g = 255 - f;
b = 255;
break;
case 4:
r = f;
g = 0;
b = 255;
break;
case 5:
r = 255;
g = 0;
b = 255 - f;
break;
}
for (i = 0; i < csf->width; i++)
{
*p++ = r;
*p++ = g;
*p++ = b;
}
}
static void
color_select_update_saturation (ColorSelectFill *csf)
{
guchar *p;
gint s;
gint i;
p = csf->buffer;
csf->y += 1;
s = csf->y * 255 / csf->height;
if (s < 0)
s = 0;
if (s > 255)
s = 255;
s = 255 - s;
for (i = 0; i < csf->width; i++)
{
*p++ = s;
*p++ = s;
*p++ = s;
}
}
static void
color_select_update_value (ColorSelectFill *csf)
{
guchar *p;
gint v;
gint i;
p = csf->buffer;
csf->y += 1;
v = csf->y * 255 / csf->height;
if (v < 0)
v = 0;
if (v > 255)
v = 255;
v = 255 - v;
for (i = 0; i < csf->width; i++)
{
*p++ = v;
*p++ = v;
*p++ = v;
}
}
static void
color_select_update_red_green (ColorSelectFill *csf)
{
guchar *p;
gint i, r, b;
gfloat g, dg;
p = csf->buffer;
csf->y += 1;
b = (gint) (csf->rgb.b * 255.999);
r = (csf->height - csf->y + 1) * 255 / csf->height;
if (r < 0)
r = 0;
if (r > 255)
r = 255;
g = 0;
dg = 255.0 / csf->width;
for (i = 0; i < csf->width; i++)
{
*p++ = r;
*p++ = g;
*p++ = b;
g += dg;
}
}
static void
color_select_update_red_blue (ColorSelectFill *csf)
{
guchar *p;
gint i, r, g;
gfloat b, db;
p = csf->buffer;
csf->y += 1;
g = (gint) (csf->rgb.g * 255.999);
r = (csf->height - csf->y + 1) * 255 / csf->height;
if (r < 0)
r = 0;
if (r > 255)
r = 255;
b = 0;
db = 255.0 / csf->width;
for (i = 0; i < csf->width; i++)
{
*p++ = r;
*p++ = g;
*p++ = b;
b += db;
}
}
static void
color_select_update_green_blue (ColorSelectFill *csf)
{
guchar *p;
gint i, g, r;
gfloat b, db;
p = csf->buffer;
csf->y += 1;
r = (gint) (csf->rgb.r * 255.999);
g = (csf->height - csf->y + 1) * 255 / csf->height;
if (g < 0)
g = 0;
if (g > 255)
g = 255;
b = 0;
db = 255.0 / csf->width;
for (i = 0; i < csf->width; i++)
{
*p++ = r;
*p++ = g;
*p++ = b;
b += db;
}
}
static void
color_select_update_hue_saturation (ColorSelectFill *csf)
{
guchar *p;
gfloat h, v, s, ds;
gint f;
gint i;
p = csf->buffer;
csf->y += 1;
h = 360 - (csf->y * 360 / csf->height);
if (h < 0)
h = 0;
if (h > 359)
h = 359;
h /= 60;
f = (h - (int) h) * 255;
s = 0;
ds = 1.0 / csf->width;
v = csf->hsv.v;
switch ((int) h)
{
case 0:
for (i = 0; i < csf->width; i++)
{
*p++ = v * 255;
*p++ = v * (255 - (s * (255 - f)));
*p++ = v * 255 * (1 - s);
s += ds;
}
break;
case 1:
for (i = 0; i < csf->width; i++)
{
*p++ = v * (255 - s * f);
*p++ = v * 255;
*p++ = v * 255 * (1 - s);
s += ds;
}
break;
case 2:
for (i = 0; i < csf->width; i++)
{
*p++ = v * 255 * (1 - s);
*p++ = v *255;
*p++ = v * (255 - (s * (255 - f)));
s += ds;
}
break;
case 3:
for (i = 0; i < csf->width; i++)
{
*p++ = v * 255 * (1 - s);
*p++ = v * (255 - s * f);
*p++ = v * 255;
s += ds;
}
break;
case 4:
for (i = 0; i < csf->width; i++)
{
*p++ = v * (255 - (s * (255 - f)));
*p++ = v * (255 * (1 - s));
*p++ = v * 255;
s += ds;
}
break;
case 5:
for (i = 0; i < csf->width; i++)
{
*p++ = v * 255;
*p++ = v * 255 * (1 - s);
*p++ = v * (255 - s * f);
s += ds;
}
break;
}
}
static void
color_select_update_hue_value (ColorSelectFill *csf)
{
guchar *p;
gfloat h, v, dv, s;
gint f;
gint i;
p = csf->buffer;
csf->y += 1;
h = 360 - (csf->y * 360 / csf->height);
if (h < 0)
h = 0;
if (h > 359)
h = 359;
h /= 60;
f = (h - (int) h) * 255;
v = 0;
dv = 1.0 / csf->width;
s = csf->hsv.s;
switch ((int) h)
{
case 0:
for (i = 0; i < csf->width; i++)
{
*p++ = v * 255;
*p++ = v * (255 - (s * (255 - f)));
*p++ = v * 255 * (1 - s);
v += dv;
}
break;
case 1:
for (i = 0; i < csf->width; i++)
{
*p++ = v * (255 - s * f);
*p++ = v * 255;
*p++ = v * 255 * (1 - s);
v += dv;
}
break;
case 2:
for (i = 0; i < csf->width; i++)
{
*p++ = v * 255 * (1 - s);
*p++ = v *255;
*p++ = v * (255 - (s * (255 - f)));
v += dv;
}
break;
case 3:
for (i = 0; i < csf->width; i++)
{
*p++ = v * 255 * (1 - s);
*p++ = v * (255 - s * f);
*p++ = v * 255;
v += dv;
}
break;
case 4:
for (i = 0; i < csf->width; i++)
{
*p++ = v * (255 - (s * (255 - f)));
*p++ = v * (255 * (1 - s));
*p++ = v * 255;
v += dv;
}
break;
case 5:
for (i = 0; i < csf->width; i++)
{
*p++ = v * 255;
*p++ = v * 255 * (1 - s);
*p++ = v * (255 - s * f);
v += dv;
}
break;
}
}
static void
color_select_update_saturation_value (ColorSelectFill *csf)
{
guchar *p;
gfloat h, v, dv, s;
gint f;
gint i;
p = csf->buffer;
csf->y += 1;
s = (gfloat) csf->y / csf->height;
if (s < 0)
s = 0;
if (s > 1)
s = 1;
s = 1 - s;
h = (gfloat) csf->hsv.h * 360.0;
if (h >= 360)
h -= 360;
h /= 60;
f = (h - (gint) h) * 255;
v = 0;
dv = 1.0 / csf->width;
switch ((gint) h)
{
case 0:
for (i = 0; i < csf->width; i++)
{
*p++ = v * 255;
*p++ = v * (255 - (s * (255 - f)));
*p++ = v * 255 * (1 - s);
v += dv;
}
break;
case 1:
for (i = 0; i < csf->width; i++)
{
*p++ = v * (255 - s * f);
*p++ = v * 255;
*p++ = v * 255 * (1 - s);
v += dv;
}
break;
case 2:
for (i = 0; i < csf->width; i++)
{
*p++ = v * 255 * (1 - s);
*p++ = v *255;
*p++ = v * (255 - (s * (255 - f)));
v += dv;
}
break;
case 3:
for (i = 0; i < csf->width; i++)
{
*p++ = v * 255 * (1 - s);
*p++ = v * (255 - s * f);
*p++ = v * 255;
v += dv;
}
break;
case 4:
for (i = 0; i < csf->width; i++)
{
*p++ = v * (255 - (s * (255 - f)));
*p++ = v * (255 * (1 - s));
*p++ = v * 255;
v += dv;
}
break;
case 5:
for (i = 0; i < csf->width; i++)
{
*p++ = v * 255;
*p++ = v * 255 * (1 - s);
*p++ = v * (255 - s * f);
v += dv;
}
break;
}
}
/****************************/
/* Color notebook glue */
typedef struct
{
GimpColorSelectorCallback callback;
gpointer *client_data;
ColorSelect *csp;
GtkWidget *main_vbox;
} notebook_glue;
static GtkWidget *
color_select_notebook_new (const GimpHSV *hsv,
const GimpRGB *rgb,
gboolean show_alpha,
GimpColorSelectorCallback callback,
gpointer data,
/* RETURNS: */
gpointer *selector_data)
{
ColorSelect *csp;
notebook_glue *glue;
glue = g_new (notebook_glue, 1);
csp = g_new (ColorSelect, 1);
glue->csp = csp;
glue->callback = callback;
glue->client_data = data;
csp->callback = color_select_notebook_update_callback;
csp->client_data = glue;
csp->z_color_fill = COLOR_SELECT_HUE;
csp->xy_color_fill = COLOR_SELECT_SATURATION_VALUE;
csp->gc = NULL;
csp->hsv = *hsv;
csp->rgb = *rgb;
color_select_update_pos (csp);
glue->main_vbox = color_select_widget_new (csp, rgb);
color_select_update (csp, UPDATE_XY_COLOR | UPDATE_Z_COLOR);
*selector_data = glue;
return glue->main_vbox;
}
static void
color_select_notebook_free (gpointer data)
{
notebook_glue *glue = data;
gdk_gc_destroy (glue->csp->gc);
g_free (glue->csp);
/* don't need to destroy the widget, since it's done by the caller
* of this function
*/
g_free (glue);
}
static void
color_select_notebook_set_color (gpointer data,
const GimpHSV *hsv,
const GimpRGB *rgb)
{
notebook_glue *glue = data;
color_select_set_color (glue->csp, hsv, rgb);
}
static void
color_select_notebook_set_channel (gpointer data,
GimpColorSelectorChannelType channel)
{
notebook_glue *glue = data;
color_select_set_channel (glue->csp, channel);
}
static void
color_select_notebook_update_callback (const GimpHSV *hsv,
const GimpRGB *rgb,
gpointer data)
{
notebook_glue *glue = data;
glue->callback (glue->client_data, hsv, rgb);
}
Reference in New Issue View Git Blame Copy Permalink