static GList *
gimp_cursor_view_get_aux_info (GimpDocked *docked)
{
GimpCursorView *view = GIMP_CURSOR_VIEW (docked);
GList *aux_info;
const gchar *nick;
GimpSessionInfoAux *aux;
aux_info = parent_docked_iface->get_aux_info (docked);
if (gimp_enum_get_value (GIMP_TYPE_COLOR_FRAME_MODE,
GIMP_COLOR_FRAME (view->color_frame_1)->frame_mode,
NULL, &nick, NULL, NULL))
{
aux = gimp_session_info_aux_new (AUX_INFO_FRAME_1_MODE, nick);
aux_info = g_list_append (aux_info, aux);
}
if (gimp_enum_get_value (GIMP_TYPE_COLOR_FRAME_MODE,
GIMP_COLOR_FRAME (view->color_frame_2)->frame_mode,
NULL, &nick, NULL, NULL))
{
aux = gimp_session_info_aux_new (AUX_INFO_FRAME_2_MODE, nick);
aux_info = g_list_append (aux_info, aux);
}
return aux_info;
}
void
gimp_cursor_view_clear_cursor (GimpCursorView *view)
{
g_return_if_fail (GIMP_IS_CURSOR_VIEW (view));
gtk_label_set_text (GTK_LABEL (view->pixel_x_label), _("n/a"));
gtk_label_set_text (GTK_LABEL (view->pixel_y_label), _("n/a"));
gtk_label_set_text (GTK_LABEL (view->unit_x_label), _("n/a"));
gtk_label_set_text (GTK_LABEL (view->unit_y_label), _("n/a"));
gimp_color_frame_set_invalid (GIMP_COLOR_FRAME (view->color_frame_1));
gimp_color_frame_set_invalid (GIMP_COLOR_FRAME (view->color_frame_2));
}
static void
gimp_sample_point_editor_points_changed (GimpSamplePointEditor *editor)
{
GimpImageEditor *image_editor = GIMP_IMAGE_EDITOR (editor);
GList *sample_points;
gint n_points = 0;
gint i;
if (image_editor->image)
{
sample_points = gimp_image_get_sample_points (image_editor->image);
n_points = MIN (4, g_list_length (sample_points));
}
for (i = 0; i < n_points; i++)
{
gtk_widget_set_sensitive (editor->color_frames[i], TRUE);
editor->dirty[i] = TRUE;
}
for (i = n_points; i < 4; i++)
{
gtk_widget_set_sensitive (editor->color_frames[i], FALSE);
gimp_color_frame_set_invalid (GIMP_COLOR_FRAME (editor->color_frames[i]));
editor->dirty[i] = FALSE;
}
if (n_points > 0)
gimp_sample_point_editor_dirty (editor, -1);
}
static void
gimp_color_frame_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GimpColorFrame *frame = GIMP_COLOR_FRAME (object);
switch (property_id)
{
case PROP_MODE:
gimp_color_frame_set_mode (frame, g_value_get_enum (value));
break;
case PROP_HAS_NUMBER:
gimp_color_frame_set_has_number (frame, g_value_get_boolean (value));
break;
case PROP_NUMBER:
gimp_color_frame_set_number (frame, g_value_get_int (value));
break;
case PROP_HAS_COLOR_AREA:
gimp_color_frame_set_has_color_area (frame, g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_cursor_view_set_aux_info (GimpDocked *docked,
GList *aux_info)
{
GimpCursorView *view = GIMP_CURSOR_VIEW (docked);
GList *list;
parent_docked_iface->set_aux_info (docked, aux_info);
for (list = aux_info; list; list = g_list_next (list))
{
GimpSessionInfoAux *aux = list->data;
GtkWidget *frame = NULL;
if (! strcmp (aux->name, AUX_INFO_FRAME_1_MODE))
frame = view->color_frame_1;
else if (! strcmp (aux->name, AUX_INFO_FRAME_2_MODE))
frame = view->color_frame_2;
if (frame)
{
GEnumClass *enum_class;
GEnumValue *enum_value;
enum_class = g_type_class_peek (GIMP_TYPE_COLOR_FRAME_MODE);
enum_value = g_enum_get_value_by_nick (enum_class, aux->value);
if (enum_value)
gimp_color_frame_set_mode (GIMP_COLOR_FRAME (frame),
enum_value->value);
}
}
}
static gboolean
gimp_sample_point_editor_update (GimpSamplePointEditor *editor)
{
GimpImageEditor *image_editor = GIMP_IMAGE_EDITOR (editor);
GList *sample_points;
gint n_points = 0;
GList *list;
gint i;
editor->dirty_idle_id = 0;
if (! image_editor->image)
return FALSE;
sample_points = gimp_image_get_sample_points (image_editor->image);
n_points = MIN (4, g_list_length (sample_points));
for (i = 0, list = sample_points;
i < n_points;
i++, list = g_list_next (list))
{
if (editor->dirty[i])
{
GimpSamplePoint *sample_point = list->data;
GimpColorFrame *color_frame;
const Babl *format;
guchar pixel[32];
GimpRGB color;
gint x;
gint y;
editor->dirty[i] = FALSE;
color_frame = GIMP_COLOR_FRAME (editor->color_frames[i]);
gimp_sample_point_get_position (sample_point, &x, &y);
if (gimp_image_pick_color (image_editor->image, NULL,
x, y,
editor->sample_merged,
FALSE, 0.0,
&format,
pixel,
&color))
{
gimp_color_frame_set_color (color_frame, FALSE,
format, pixel, &color);
}
else
{
gimp_color_frame_set_invalid (color_frame);
}
}
}
return FALSE;
}
static void
gimp_color_frame_dispose (GObject *object)
{
GimpColorFrame *frame = GIMP_COLOR_FRAME (object);
gimp_color_frame_set_color_config (frame, NULL);
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static gboolean
gimp_color_frame_expose (GtkWidget *widget,
GdkEventExpose *eevent)
{
GimpColorFrame *frame = GIMP_COLOR_FRAME (widget);
if (frame->has_number)
{
GtkStyle *style = gtk_widget_get_style (widget);
GtkAllocation allocation;
GtkAllocation menu_allocation;
GtkAllocation color_area_allocation;
cairo_t *cr;
gchar buf[8];
gint w, h;
gdouble scale;
gtk_widget_get_allocation (widget, &allocation);
gtk_widget_get_allocation (frame->menu, &menu_allocation);
gtk_widget_get_allocation (frame->color_area, &color_area_allocation);
cr = gdk_cairo_create (gtk_widget_get_window (widget));
gdk_cairo_region (cr, eevent->region);
cairo_clip (cr);
cairo_translate (cr, allocation.x, allocation.y);
gdk_cairo_set_source_color (cr, &style->light[GTK_STATE_NORMAL]);
g_snprintf (buf, sizeof (buf), "%d", frame->number);
if (! frame->number_layout)
frame->number_layout = gtk_widget_create_pango_layout (widget, NULL);
pango_layout_set_text (frame->number_layout, buf, -1);
pango_layout_get_pixel_size (frame->number_layout, &w, &h);
scale = ((gdouble) (allocation.height -
menu_allocation.height -
color_area_allocation.height) /
(gdouble) h);
cairo_scale (cr, scale, scale);
cairo_move_to (cr,
(allocation.width / 2.0) / scale - w / 2.0,
(allocation.height / 2.0 +
menu_allocation.height / 2.0 +
color_area_allocation.height / 2.0) / scale - h / 2.0);
pango_cairo_show_layout (cr, frame->number_layout);
cairo_destroy (cr);
}
return GTK_WIDGET_CLASS (parent_class)->expose_event (widget, eevent);
}
static void
gimp_color_picker_tool_info_update (GimpColorPickerTool *picker_tool,
GimpImageType sample_type,
const GimpRGB *color,
gint color_index)
{
gimp_color_area_set_color (GIMP_COLOR_AREA (picker_tool->color_area),
color);
gimp_color_frame_set_color (GIMP_COLOR_FRAME (picker_tool->color_frame1),
sample_type, color, color_index);
gimp_color_frame_set_color (GIMP_COLOR_FRAME (picker_tool->color_frame2),
sample_type, color, color_index);
/* don't use gtk_window_present() because it would focus the dialog */
if (gtk_widget_get_visible (picker_tool->dialog))
gdk_window_show (gtk_widget_get_window (picker_tool->dialog));
else
gtk_widget_show (picker_tool->dialog);
}
static void
gimp_color_frame_finalize (GObject *object)
{
GimpColorFrame *frame = GIMP_COLOR_FRAME (object);
if (frame->number_layout)
{
g_object_unref (frame->number_layout);
frame->number_layout = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gimp_color_frame_style_set (GtkWidget *widget,
GtkStyle *prev_style)
{
GimpColorFrame *frame = GIMP_COLOR_FRAME (widget);
GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style);
if (frame->number_layout)
{
g_object_unref (frame->number_layout);
frame->number_layout = NULL;
}
}
static void
gimp_color_picker_tool_info_update (GimpColorPickerTool *picker_tool,
const Babl *sample_format,
const GimpRGB *color,
gint color_index)
{
GimpTool *tool = GIMP_TOOL (picker_tool);
gimp_tool_gui_set_shell (picker_tool->gui,
gimp_display_get_shell (tool->display));
gimp_tool_gui_set_viewable (picker_tool->gui,
GIMP_VIEWABLE (tool->drawable));
gimp_color_area_set_color (GIMP_COLOR_AREA (picker_tool->color_area),
color);
gimp_color_frame_set_color (GIMP_COLOR_FRAME (picker_tool->color_frame1),
sample_format, color, color_index);
gimp_color_frame_set_color (GIMP_COLOR_FRAME (picker_tool->color_frame2),
sample_format, color, color_index);
gimp_tool_gui_show (picker_tool->gui);
}
void
gimp_cursor_view_update_cursor (GimpCursorView *view,
GimpImage *image,
GimpUnit unit,
gdouble x,
gdouble y)
{
gboolean in_image;
gdouble unit_factor;
gint unit_digits;
const gchar *unit_str;
gchar format_buf[32];
gchar buf[32];
GimpImageType sample_type;
GimpRGB color;
gint color_index;
g_return_if_fail (GIMP_IS_CURSOR_VIEW (view));
g_return_if_fail (GIMP_IS_IMAGE (image));
if (unit == GIMP_UNIT_PIXEL)
unit = gimp_image_get_unit (image);
in_image = (x >= 0.0 && x < gimp_image_get_width (image) &&
y >= 0.0 && y < gimp_image_get_height (image));
unit_factor = _gimp_unit_get_factor (image->gimp, unit);
unit_digits = _gimp_unit_get_digits (image->gimp, unit);
unit_str = _gimp_unit_get_abbreviation (image->gimp, unit);
#define FORMAT_STRING(s) (in_image ? (s) : "("s")")
g_snprintf (buf, sizeof (buf), FORMAT_STRING ("%d"), (gint) floor (x));
gtk_label_set_text (GTK_LABEL (view->pixel_x_label), buf);
g_snprintf (buf, sizeof (buf), FORMAT_STRING ("%d"), (gint) floor (y));
gtk_label_set_text (GTK_LABEL (view->pixel_y_label), buf);
g_snprintf (format_buf, sizeof (format_buf),
FORMAT_STRING ("%%.%df %s"), unit_digits, unit_str);
g_snprintf (buf, sizeof (buf), format_buf,
x * unit_factor / image->xresolution);
gtk_label_set_text (GTK_LABEL (view->unit_x_label), buf);
g_snprintf (buf, sizeof (buf), format_buf,
y * unit_factor / image->yresolution);
gtk_label_set_text (GTK_LABEL (view->unit_y_label), buf);
if (gimp_image_pick_color (image, NULL,
(gint) floor (x),
(gint) floor (y),
view->sample_merged,
FALSE, 0.0,
&sample_type, &color, &color_index))
{
gimp_color_frame_set_color (GIMP_COLOR_FRAME (view->color_frame_1),
sample_type, &color, color_index);
gimp_color_frame_set_color (GIMP_COLOR_FRAME (view->color_frame_2),
sample_type, &color, color_index);
}
else
{
gimp_color_frame_set_invalid (GIMP_COLOR_FRAME (view->color_frame_1));
gimp_color_frame_set_invalid (GIMP_COLOR_FRAME (view->color_frame_2));
}
}
static void
gimp_cursor_view_init (GimpCursorView *view)
{
GtkWidget *frame;
GtkWidget *table;
GtkWidget *toggle;
gint content_spacing;
view->sample_merged = TRUE;
gtk_widget_style_get (GTK_WIDGET (view),
"content-spacing", &content_spacing,
NULL);
/* cursor information */
view->coord_hbox = gtk_hbox_new (TRUE, content_spacing);
gtk_box_pack_start (GTK_BOX (view), view->coord_hbox, FALSE, FALSE, 0);
gtk_widget_show (view->coord_hbox);
frame = gimp_frame_new (_("Pixels"));
gtk_box_pack_start (GTK_BOX (view->coord_hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
table = gtk_table_new (2, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
view->pixel_x_label = gtk_label_new (_("n/a"));
gtk_misc_set_alignment (GTK_MISC (view->pixel_x_label), 1.0, 0.5);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
_("X"), 0.5, 0.5,
view->pixel_x_label, 1, FALSE);
view->pixel_y_label = gtk_label_new (_("n/a"));
gtk_misc_set_alignment (GTK_MISC (view->pixel_y_label), 1.0, 0.5);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
_("Y"), 0.5, 0.5,
view->pixel_y_label, 1, FALSE);
frame = gimp_frame_new (_("Units"));
gtk_box_pack_start (GTK_BOX (view->coord_hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
table = gtk_table_new (2, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
view->unit_x_label = gtk_label_new (_("n/a"));
gtk_misc_set_alignment (GTK_MISC (view->unit_x_label), 1.0, 0.5);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
_("X"), 0.5, 0.5,
view->unit_x_label, 1, FALSE);
view->unit_y_label = gtk_label_new (_("n/a"));
gtk_misc_set_alignment (GTK_MISC (view->unit_y_label), 1.0, 0.5);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
_("Y"), 0.5, 0.5,
view->unit_y_label, 1, FALSE);
/* color information */
view->color_hbox = gtk_hbox_new (TRUE, content_spacing);
gtk_box_pack_start (GTK_BOX (view), view->color_hbox, FALSE, FALSE, 0);
gtk_widget_show (view->color_hbox);
view->color_frame_1 = gimp_color_frame_new ();
gimp_color_frame_set_mode (GIMP_COLOR_FRAME (view->color_frame_1),
GIMP_COLOR_FRAME_MODE_PIXEL);
gtk_box_pack_start (GTK_BOX (view->color_hbox), view->color_frame_1,
TRUE, TRUE, 0);
gtk_widget_show (view->color_frame_1);
view->color_frame_2 = gimp_color_frame_new ();
gimp_color_frame_set_mode (GIMP_COLOR_FRAME (view->color_frame_2),
GIMP_COLOR_FRAME_MODE_RGB);
gtk_box_pack_start (GTK_BOX (view->color_hbox), view->color_frame_2,
TRUE, TRUE, 0);
gtk_widget_show (view->color_frame_2);
/* sample merged toggle */
toggle = gimp_prop_check_button_new (G_OBJECT (view), "sample-merged",
_("_Sample Merged"));
gtk_box_pack_start (GTK_BOX (view), toggle, FALSE, FALSE, 0);
gtk_widget_show (toggle);
}
static void
gimp_color_picker_tool_info_create (GimpColorPickerTool *picker_tool)
{
GimpTool *tool = GIMP_TOOL (picker_tool);
GimpDisplayShell *shell;
GtkWidget *hbox;
GtkWidget *frame;
GimpRGB color;
g_return_if_fail (tool->display != NULL);
g_return_if_fail (tool->drawable != NULL);
shell = gimp_display_get_shell (tool->display);
picker_tool->gui = gimp_tool_gui_new (tool->tool_info,
_("Color Picker Information"),
gtk_widget_get_screen (GTK_WIDGET (shell)),
gimp_widget_get_monitor (GTK_WIDGET (shell)),
TRUE,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
gimp_tool_gui_set_auto_overlay (picker_tool->gui, TRUE);
gimp_tool_gui_set_focus_on_map (picker_tool->gui, FALSE);
gimp_tool_gui_set_viewable (picker_tool->gui,
GIMP_VIEWABLE (tool->drawable));
g_signal_connect (picker_tool->gui, "response",
G_CALLBACK (gimp_color_picker_tool_info_response),
picker_tool);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (gimp_tool_gui_get_vbox (picker_tool->gui)),
hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
picker_tool->color_frame1 = gimp_color_frame_new ();
gimp_color_frame_set_mode (GIMP_COLOR_FRAME (picker_tool->color_frame1),
GIMP_COLOR_FRAME_MODE_PIXEL);
gtk_box_pack_start (GTK_BOX (hbox), picker_tool->color_frame1,
FALSE, FALSE, 0);
gtk_widget_show (picker_tool->color_frame1);
picker_tool->color_frame2 = gimp_color_frame_new ();
gimp_color_frame_set_mode (GIMP_COLOR_FRAME (picker_tool->color_frame2),
GIMP_COLOR_FRAME_MODE_RGB);
gtk_box_pack_start (GTK_BOX (hbox), picker_tool->color_frame2,
FALSE, FALSE, 0);
gtk_widget_show (picker_tool->color_frame2);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
gimp_rgba_set (&color, 0.0, 0.0, 0.0, 0.0);
picker_tool->color_area =
gimp_color_area_new (&color,
gimp_drawable_has_alpha (tool->drawable) ?
GIMP_COLOR_AREA_LARGE_CHECKS :
GIMP_COLOR_AREA_FLAT,
GDK_BUTTON1_MASK | GDK_BUTTON2_MASK);
gtk_widget_set_size_request (picker_tool->color_area, 48, -1);
gtk_drag_dest_unset (picker_tool->color_area);
gtk_container_add (GTK_CONTAINER (frame), picker_tool->color_area);
gtk_widget_show (picker_tool->color_area);
}
static void
gimp_color_picker_tool_info_create (GimpColorPickerTool *picker_tool)
{
GimpTool *tool = GIMP_TOOL (picker_tool);
GtkWidget *content_area;
GtkWidget *hbox;
GtkWidget *frame;
GimpRGB color;
g_return_if_fail (tool->drawable != NULL);
picker_tool->dialog = gimp_tool_dialog_new (tool->tool_info,
gimp_display_get_shell (tool->display),
_("Color Picker Information"),
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE,
NULL);
gtk_window_set_focus_on_map (GTK_WINDOW (picker_tool->dialog), FALSE);
gimp_viewable_dialog_set_viewable (GIMP_VIEWABLE_DIALOG (picker_tool->dialog),
GIMP_VIEWABLE (tool->drawable),
GIMP_CONTEXT (gimp_tool_get_options (tool)));
g_signal_connect (picker_tool->dialog, "response",
G_CALLBACK (gimp_color_picker_tool_info_response),
picker_tool);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (picker_tool->dialog));
hbox = gtk_hbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
gtk_box_pack_start (GTK_BOX (content_area), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
picker_tool->color_frame1 = gimp_color_frame_new ();
gimp_color_frame_set_mode (GIMP_COLOR_FRAME (picker_tool->color_frame1),
GIMP_COLOR_FRAME_MODE_PIXEL);
gtk_box_pack_start (GTK_BOX (hbox), picker_tool->color_frame1,
FALSE, FALSE, 0);
gtk_widget_show (picker_tool->color_frame1);
picker_tool->color_frame2 = gimp_color_frame_new ();
gimp_color_frame_set_mode (GIMP_COLOR_FRAME (picker_tool->color_frame2),
GIMP_COLOR_FRAME_MODE_RGB);
gtk_box_pack_start (GTK_BOX (hbox), picker_tool->color_frame2,
FALSE, FALSE, 0);
gtk_widget_show (picker_tool->color_frame2);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
gimp_rgba_set (&color, 0.0, 0.0, 0.0, 0.0);
picker_tool->color_area =
gimp_color_area_new (&color,
gimp_drawable_has_alpha (tool->drawable) ?
GIMP_COLOR_AREA_LARGE_CHECKS :
GIMP_COLOR_AREA_FLAT,
GDK_BUTTON1_MASK | GDK_BUTTON2_MASK);
gtk_widget_set_size_request (picker_tool->color_area, 48, -1);
gtk_drag_dest_unset (picker_tool->color_area);
gtk_container_add (GTK_CONTAINER (frame), picker_tool->color_area);
gtk_widget_show (picker_tool->color_area);
}
