/* LIBGIMP - The GIMP Library * Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball * * gimpcolorarea.c * Copyright (C) 2001 Sven Neumann * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library 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 * Library General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ #include "config.h" #include #include "libgimpcolor/gimpcolor.h" #include "libgimpbase/gimpbase.h" #include "gimpwidgetstypes.h" #include "gimpcolorarea.h" #define DRAG_PREVIEW_SIZE 32 #define DRAG_ICON_OFFSET -8 enum { COLOR_CHANGED, LAST_SIGNAL }; static void gimp_color_area_class_init (GimpColorAreaClass *klass); static void gimp_color_area_init (GimpColorArea *gca); static void gimp_color_area_destroy (GtkObject *object); static void gimp_color_area_size_allocate (GtkWidget *widget, GtkAllocation *allocation); static gboolean gimp_color_area_expose (GtkWidget *widget, GdkEventExpose *event); static void gimp_color_area_update (GimpColorArea *gca); static gboolean gimp_color_area_idle_update (gpointer data); static void gimp_color_area_drag_begin (GtkWidget *widget, GdkDragContext *context); static void gimp_color_area_drag_end (GtkWidget *widget, GdkDragContext *context); static void gimp_color_area_drag_data_received (GtkWidget *widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *selection_data, guint info, guint time); static void gimp_color_area_drag_data_get (GtkWidget *widget, GdkDragContext *context, GtkSelectionData *selection_data, guint info, guint time); static const GtkTargetEntry targets[] = { { "application/x-color", 0 } }; static guint gimp_color_area_signals[LAST_SIGNAL] = { 0 }; static GtkDrawingAreaClass * parent_class = NULL; GType gimp_color_area_get_type (void) { static GType gca_type = 0; if (! gca_type) { static const GTypeInfo gca_info = { sizeof (GimpColorAreaClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gimp_color_area_class_init, NULL, /* class_finalize */ NULL, /* class_data */ sizeof (GimpColorArea), 0, /* n_preallocs */ (GInstanceInitFunc) gimp_color_area_init, }; gca_type = g_type_register_static (GTK_TYPE_DRAWING_AREA, "GimpColorArea", &gca_info, 0); } return gca_type; } static void gimp_color_area_class_init (GimpColorAreaClass *klass) { GtkObjectClass *object_class; GtkWidgetClass *widget_class; object_class = GTK_OBJECT_CLASS (klass); widget_class = GTK_WIDGET_CLASS (klass); parent_class = g_type_class_peek_parent (klass); gimp_color_area_signals[COLOR_CHANGED] = g_signal_new ("color_changed", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST, G_STRUCT_OFFSET (GimpColorAreaClass, color_changed), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); object_class->destroy = gimp_color_area_destroy; widget_class->size_allocate = gimp_color_area_size_allocate; widget_class->expose_event = gimp_color_area_expose; widget_class->drag_begin = gimp_color_area_drag_begin; widget_class->drag_end = gimp_color_area_drag_end; widget_class->drag_data_received = gimp_color_area_drag_data_received; widget_class->drag_data_get = gimp_color_area_drag_data_get; klass->color_changed = NULL; } static void gimp_color_area_init (GimpColorArea *gca) { gimp_rgba_set (&gca->color, 0.0, 0.0, 0.0, 1.0); gca->buf = NULL; gca->width = 0; gca->height = 0; gca->rowstride = 0; gca->type = GIMP_COLOR_AREA_FLAT; gca->idle_id = 0; } static void gimp_color_area_destroy (GtkObject *object) { GimpColorArea *gca; g_return_if_fail (GIMP_IS_COLOR_AREA (object)); gca = GIMP_COLOR_AREA (object); if (gca->buf) { g_free (gca->buf); gca->buf = NULL; gca->width = 0; gca->height = 0; gca->rowstride = 0; } if (gca->idle_id) { g_source_remove (gca->idle_id); gca->idle_id = 0; } if (GTK_OBJECT_CLASS (parent_class)->destroy) GTK_OBJECT_CLASS (parent_class)->destroy (object); } static void gimp_color_area_size_allocate (GtkWidget *widget, GtkAllocation *allocation) { GimpColorArea *gca; gca = GIMP_COLOR_AREA (widget); if (GTK_WIDGET_CLASS (parent_class)->size_allocate) GTK_WIDGET_CLASS (parent_class)->size_allocate (widget, allocation); if (widget->allocation.width != gca->width || widget->allocation.height != gca->height) { gca->width = widget->allocation.width; gca->height = widget->allocation.height; gca->rowstride = (gca->width * 3 + 3) & ~0x3; g_free (gca->buf); gca->buf = g_new (guchar, gca->rowstride * gca->height); gimp_color_area_update (gca); } } static gboolean gimp_color_area_expose (GtkWidget *widget, GdkEventExpose *event) { GimpColorArea *gca; guchar *buf; gca = GIMP_COLOR_AREA (widget); if (gca->idle_id || ! gca->buf || ! GTK_WIDGET_DRAWABLE (widget)) return FALSE; buf = gca->buf + event->area.y * gca->rowstride + event->area.x * 3; gdk_draw_rgb_image_dithalign (widget->window, widget->style->black_gc, event->area.x, event->area.y, event->area.width, event->area.height, GDK_RGB_DITHER_MAX, buf, gca->rowstride, event->area.x, event->area.y); return FALSE; } /** * gimp_color_area_new: * @color: A pointer to a #GimpRGB struct. * @type: The type of color area to create. * @drag_mask: The event_mask that should trigger drags. * * Creates a new #GimpColorArea widget. * * This returns a preview area showing the color. It handles color * DND. If the color changes, the "color_changed" signal is emitted. * * Returns: Pointer to the new #GimpColorArea widget. **/ GtkWidget * gimp_color_area_new (const GimpRGB *color, GimpColorAreaType type, GdkModifierType drag_mask) { GimpColorArea *gca; g_return_val_if_fail (color != NULL, NULL); gca = g_object_new (GIMP_TYPE_COLOR_AREA, NULL); gca->color = *color; gca->type = type; gtk_drag_dest_set (GTK_WIDGET (gca), GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP, targets, 1, GDK_ACTION_COPY); /* do we need this ?? */ drag_mask &= (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK); if (drag_mask) gtk_drag_source_set (GTK_WIDGET (gca), drag_mask, targets, 1, GDK_ACTION_COPY | GDK_ACTION_MOVE); return GTK_WIDGET (gca); } /** * gimp_color_area_set_color: * @gca: Pointer to a #GimpColorArea. * @color: * **/ void gimp_color_area_set_color (GimpColorArea *gca, const GimpRGB *color) { g_return_if_fail (GIMP_IS_COLOR_AREA (gca)); g_return_if_fail (color != NULL); if (gimp_rgba_distance (&gca->color, color) > 0.000001) { gca->color = *color; gimp_color_area_update (gca); g_signal_emit (G_OBJECT (gca), gimp_color_area_signals[COLOR_CHANGED], 0); } } void gimp_color_area_get_color (GimpColorArea *gca, GimpRGB *color) { g_return_if_fail (GIMP_IS_COLOR_AREA (gca)); g_return_if_fail (color != NULL); *color = gca->color; } gboolean gimp_color_area_has_alpha (GimpColorArea *gca) { g_return_val_if_fail (GIMP_IS_COLOR_AREA (gca), FALSE); return gca->type != GIMP_COLOR_AREA_FLAT; } void gimp_color_area_set_type (GimpColorArea *gca, GimpColorAreaType type) { g_return_if_fail (GIMP_IS_COLOR_AREA (gca)); gca->type = type; gimp_color_area_update (gca); } static void gimp_color_area_update (GimpColorArea *gca) { g_return_if_fail (GIMP_IS_COLOR_AREA (gca)); if (gca->idle_id) { g_source_remove (gca->idle_id); } gca->idle_id = g_idle_add_full (G_PRIORITY_LOW, (GSourceFunc) gimp_color_area_idle_update, gca, NULL); } static gboolean gimp_color_area_idle_update (gpointer data) { GimpColorArea *gca; GtkWidget *widget; guint width, height; guint x, y; guint check_size = 0; guchar light[3]; guchar dark[3]; guchar opaque[3]; guchar *p; gdouble frac; gca = GIMP_COLOR_AREA (data); widget = GTK_WIDGET (data); gca->idle_id = 0; if (! GTK_WIDGET_REALIZED (widget)) return FALSE; if (! gca->buf) return FALSE; width = gca->width; height = gca->height; switch (gca->type) { case GIMP_COLOR_AREA_FLAT: check_size = 0; break; case GIMP_COLOR_AREA_SMALL_CHECKS: check_size = GIMP_CHECK_SIZE_SM; break; case GIMP_COLOR_AREA_LARGE_CHECKS: check_size = GIMP_CHECK_SIZE; break; } opaque[0] = gca->color.r * 255.999; opaque[1] = gca->color.g * 255.999; opaque[2] = gca->color.b * 255.999; if (check_size && gca->color.a < 1.0) { light[0] = (GIMP_CHECK_LIGHT + (gca->color.r - GIMP_CHECK_LIGHT) * gca->color.a) * 255.999; dark[0] = (GIMP_CHECK_DARK + (gca->color.r - GIMP_CHECK_DARK) * gca->color.a) * 255.999; light[1] = (GIMP_CHECK_LIGHT + (gca->color.g - GIMP_CHECK_LIGHT) * gca->color.a) * 255.999; dark[1] = (GIMP_CHECK_DARK + (gca->color.g - GIMP_CHECK_DARK) * gca->color.a) * 255.999; light[2] = (GIMP_CHECK_LIGHT + (gca->color.b - GIMP_CHECK_LIGHT) * gca->color.a) * 255.999; dark[2] = (GIMP_CHECK_DARK + (gca->color.b - GIMP_CHECK_DARK) * gca->color.a) * 255.999; for (y = 0; y < height; y++) { p = gca->buf + y * gca->rowstride; for (x = 0; x < width; x++) { if ((width - x) * height > y * width) { *p++ = opaque[0]; *p++ = opaque[1]; *p++ = opaque[2]; continue; } frac = y - (gdouble) ((width - x) * height) / (gdouble) width; if (((x / check_size) ^ (y / check_size)) & 1) { if ((gint) frac) { *p++ = light[0]; *p++ = light[1]; *p++ = light[2]; } else { *p++ = (gdouble) light[0] * frac + (gdouble) opaque[0] * (1.0 - frac); *p++ = (gdouble) light[1] * frac + (gdouble) opaque[1] * (1.0 - frac); *p++ = (gdouble) light[2] * frac + (gdouble) opaque[2] * (1.0 - frac); } } else { if ((gint) frac) { *p++ = dark[0]; *p++ = dark[1]; *p++ = dark[2]; } else { *p++ = (gdouble) dark[0] * frac + (gdouble) opaque[0] * (1.0 - frac); *p++ = (gdouble) dark[1] * frac + (gdouble) opaque[1] * (1.0 - frac); *p++ = (gdouble) dark[2] * frac + (gdouble) opaque[2] * (1.0 - frac); } } } } } else { for (y = 0; y < height; y++) { p = gca->buf + y * gca->rowstride; for (x = 0; x < width; x++) { *p++ = opaque[0]; *p++ = opaque[1]; *p++ = opaque[2]; } } } gtk_widget_queue_draw (GTK_WIDGET (gca)); return FALSE; } static void gimp_color_area_drag_begin (GtkWidget *widget, GdkDragContext *context) { GimpRGB color; GtkWidget *window; GtkWidget *frame; GtkWidget *color_area; window = gtk_window_new (GTK_WINDOW_POPUP); gtk_widget_realize (window); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT); gtk_container_add (GTK_CONTAINER (window), frame); gimp_color_area_get_color (GIMP_COLOR_AREA (widget), &color); color_area = gimp_color_area_new (&color, GIMP_COLOR_AREA (widget)->type, 0); gtk_widget_set_size_request (color_area, DRAG_PREVIEW_SIZE, DRAG_PREVIEW_SIZE); gtk_container_add (GTK_CONTAINER (frame), color_area); gtk_widget_show (color_area); gtk_widget_show (frame); g_object_set_data_full (G_OBJECT (widget), "gimp-color-area-drag-window", window, (GDestroyNotify) gtk_widget_destroy); gtk_drag_set_icon_widget (context, window, DRAG_ICON_OFFSET, DRAG_ICON_OFFSET); } static void gimp_color_area_drag_end (GtkWidget *widget, GdkDragContext *context) { g_object_set_data (G_OBJECT (widget), "gimp-color-area-drag-window", NULL); } static void gimp_color_area_drag_data_received (GtkWidget *widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *selection_data, guint info, guint time) { GimpColorArea *gca; GimpRGB color; guint16 *vals; gca = GIMP_COLOR_AREA (widget); if (selection_data->length < 0) return; if ((selection_data->format != 16) || (selection_data->length != 8)) { g_warning ("Received invalid color data"); return; } vals = (guint16 *)selection_data->data; gimp_rgba_set (&color, (gdouble) vals[0] / 0xffff, (gdouble) vals[1] / 0xffff, (gdouble) vals[2] / 0xffff, (gdouble) vals[3] / 0xffff); gimp_color_area_set_color (gca, &color); } static void gimp_color_area_drag_data_get (GtkWidget *widget, GdkDragContext *context, GtkSelectionData *selection_data, guint info, guint time) { GimpColorArea *gca; guint16 vals[4]; gca = GIMP_COLOR_AREA (widget); vals[0] = gca->color.r * 0xffff; vals[1] = gca->color.g * 0xffff; vals[2] = gca->color.b * 0xffff; if (gca->type == GIMP_COLOR_AREA_FLAT) vals[3] = 0xffff; else vals[3] = gca->color.a * 0xffff; gtk_selection_data_set (selection_data, gdk_atom_intern ("application/x-color", FALSE), 16, (guchar *)vals, 8); }