From a06f51f786230bfd26ddd34d27be438d4bebbd04 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Fri, 23 May 2014 11:09:05 +0200 Subject: moved widgets/sp-color-slider to ui/widget/color-slider (bzr r13341.6.2) --- src/ui/CMakeLists.txt | 2 + src/ui/widget/Makefile_insert | 2 + src/ui/widget/color-slider.cpp | 961 +++++++++++++++++++++++++++++++++++++++++ src/ui/widget/color-slider.h | 146 +++++++ 4 files changed, 1111 insertions(+) create mode 100644 src/ui/widget/color-slider.cpp create mode 100644 src/ui/widget/color-slider.h (limited to 'src/ui') diff --git a/src/ui/CMakeLists.txt b/src/ui/CMakeLists.txt index 7d80f1e36..883ba3427 100644 --- a/src/ui/CMakeLists.txt +++ b/src/ui/CMakeLists.txt @@ -109,6 +109,7 @@ set(ui_SRC widget/button.cpp widget/color-picker.cpp widget/color-preview.cpp + widget/color-slider.cpp widget/dock-item.cpp widget/dock.cpp widget/entity-entry.cpp @@ -270,6 +271,7 @@ set(ui_SRC widget/button.h widget/color-picker.h widget/color-preview.h + widget/color-slider.h widget/combo-enums.h widget/dock-item.h widget/dock.h diff --git a/src/ui/widget/Makefile_insert b/src/ui/widget/Makefile_insert index 608dd5334..6deaf6671 100644 --- a/src/ui/widget/Makefile_insert +++ b/src/ui/widget/Makefile_insert @@ -10,6 +10,8 @@ ink_common_sources += \ ui/widget/color-picker.h \ ui/widget/color-preview.cpp \ ui/widget/color-preview.h \ + ui/widget/color-slider.cpp \ + ui/widget/color-slider.h \ ui/widget/combo-enums.h \ ui/widget/dock.h \ ui/widget/dock.cpp \ diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp new file mode 100644 index 000000000..430239f00 --- /dev/null +++ b/src/ui/widget/color-slider.cpp @@ -0,0 +1,961 @@ +/** + * @file + * A slider with colored background - implementation. + */ +/* Author: + * Lauris Kaplinski + * bulia byak + * + * Copyright (C) 2001-2002 Lauris Kaplinski + * + * This code is in public domain + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "color-slider.h" + +#include +#include +#include +#include + +#include "widgets/sp-color-scales.h" +#include "preferences.h" + +static const gint SLIDER_WIDTH = 96; +static const gint SLIDER_HEIGHT = 8; +static const gint ARROW_SIZE = 7; + +namespace Inkscape { +namespace UI { +namespace Widget { + +ColorSlider::ColorSlider(Gtk::Adjustment* adjustment) + : _dragging(false) + , _adjustment(NULL) + , _value(0.0) + , _oldvalue(0.0) + , _mapsize(0) + , _map(NULL) +{ + _c0[0] = 0x00; + _c0[1] = 0x00; + _c0[2] = 0x00; + _c0[3] = 0xff; + + _cm[0] = 0xff; + _cm[1] = 0x00; + _cm[2] = 0x00; + _cm[3] = 0xff; + + _c0[0] = 0xff; + _c0[1] = 0xff; + _c0[2] = 0xff; + _c0[3] = 0xff; + + _b0 = 0x5f; + _b1 = 0xa0; + _bmask = 0x08; + + set_adjustment(adjustment); +} + +ColorSlider::~ColorSlider() { + if (_adjustment) { + //TODO: disconnect all connections + delete _adjustment; + _adjustment = NULL; + } +} + +void ColorSlider::on_realize() { + set_realized(); + + if(!_refGdkWindow) + { + GdkWindowAttr attributes; + gint attributes_mask; + Gtk::Allocation allocation = get_allocation(); + + memset(&attributes, 0, sizeof(attributes)); + attributes.x = allocation.get_x(); + attributes.y = allocation.get_y(); + attributes.width = allocation.get_width(); + attributes.height = allocation.get_height(); + attributes.window_type = GDK_WINDOW_CHILD; + attributes.wclass = GDK_INPUT_OUTPUT; + attributes.visual = gdk_screen_get_system_visual(gdk_screen_get_default()); +#if !GTK_CHECK_VERSION(3,0,0) + attributes.colormap = gdk_screen_get_system_colormap(gdk_screen_get_default()); +#endif + attributes.event_mask = get_events (); + attributes.event_mask |= (Gdk::EXPOSURE_MASK | + Gdk::BUTTON_PRESS_MASK | + Gdk::BUTTON_RELEASE_MASK | + Gdk::POINTER_MOTION_MASK | + Gdk::ENTER_NOTIFY_MASK | + Gdk::LEAVE_NOTIFY_MASK); + +#if GTK_CHECK_VERSION(3,0,0) + attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL; +#else + attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP; +#endif + + _refGdkWindow = Gdk::Window::create(get_parent_window(), &attributes, + attributes_mask); + set_window(_refGdkWindow); + _refGdkWindow->set_user_data(gobj()); + + style_attach(); + } +} + +void ColorSlider::on_unrealize() { + _refGdkWindow.reset(); + + Gtk::Widget::on_unrealize(); +} + +void ColorSlider::on_size_request(Gtk::Requisition* requisition) { + GtkStyle *style = gtk_widget_get_style(gobj()); + requisition->width = SLIDER_WIDTH + style->xthickness * 2; + requisition->height = SLIDER_HEIGHT + style->ythickness * 2; +} + +//TODO: GTK3 prefferred width/height + +void ColorSlider::on_size_allocate(Gtk::Allocation& allocation) { + if (get_realized()) { + _refGdkWindow->move_resize(allocation.get_x(), allocation.get_y(), + allocation.get_width(), allocation.get_height()); + } +} + +//TODO: if not GTK3 +bool ColorSlider::on_expose_event(GdkEventExpose* event) { + bool result = false; + + if (get_is_drawable()) { + Cairo::RefPtr cr = _refGdkWindow->create_cairo_context(); + result = on_draw(cr); + } + return result; +} + +bool ColorSlider::on_button_press_event(GdkEventButton *event) { + //TODO: implementation + return false; +} + +bool ColorSlider::on_button_release_event(GdkEventButton *event) { + //TODO: implementation + return false; +} + +bool ColorSlider::on_motion_notify_event(GdkEventMotion *event) { + //TODO: implementation + return false; +} + +void ColorSlider::set_adjustment(Gtk::Adjustment* /*adjustment*/) { + //TODO: implementation +} + +void ColorSlider::set_colors(guint32 start, guint32 min, guint32 end) { + +} + +void ColorSlider::set_map(const guchar *map) { + +} + +void ColorSlider::set_background(guint dark, guint light, guint size) { + +} + +bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { + return false; +} + +}//namespace Widget +}//namespace UI +}//namespace Inkscape + + + + + + + + + + + + + + + + + + + + + + + + +enum { + GRABBED, + DRAGGED, + RELEASED, + CHANGED, + LAST_SIGNAL +}; + +static void sp_color_slider_class_init (SPColorSliderClass *klass); +static void sp_color_slider_init (SPColorSlider *slider); +static void sp_color_slider_dispose(GObject *object); + +static void sp_color_slider_realize (GtkWidget *widget); +static void sp_color_slider_size_request (GtkWidget *widget, GtkRequisition *requisition); + +#if GTK_CHECK_VERSION(3,0,0) +static void sp_color_slider_get_preferred_width(GtkWidget *widget, + gint *minimal_width, + gint *natural_width); + +static void sp_color_slider_get_preferred_height(GtkWidget *widget, + gint *minimal_height, + gint *natural_height); +#else +static gboolean sp_color_slider_expose(GtkWidget *widget, GdkEventExpose *event); +#endif + +static void sp_color_slider_size_allocate (GtkWidget *widget, GtkAllocation *allocation); + +static gboolean sp_color_slider_draw(GtkWidget *widget, cairo_t *cr); + +static gint sp_color_slider_button_press (GtkWidget *widget, GdkEventButton *event); +static gint sp_color_slider_button_release (GtkWidget *widget, GdkEventButton *event); +static gint sp_color_slider_motion_notify (GtkWidget *widget, GdkEventMotion *event); + +static void sp_color_slider_adjustment_changed (GtkAdjustment *adjustment, SPColorSlider *slider); +static void sp_color_slider_adjustment_value_changed (GtkAdjustment *adjustment, SPColorSlider *slider); + +static const guchar *sp_color_slider_render_gradient (gint x0, gint y0, gint width, gint height, + gint c[], gint dc[], guint b0, guint b1, guint mask); +static const guchar *sp_color_slider_render_map (gint x0, gint y0, gint width, gint height, + guchar *map, gint start, gint step, guint b0, guint b1, guint mask); + +static GtkWidgetClass *parent_class; +static guint slider_signals[LAST_SIGNAL] = {0}; + +GType +sp_color_slider_get_type (void) +{ + static GType type = 0; + if (!type) { + GTypeInfo info = { + sizeof (SPColorSliderClass), + NULL, NULL, + (GClassInitFunc) sp_color_slider_class_init, + NULL, NULL, + sizeof (SPColorSlider), + 0, + (GInstanceInitFunc) sp_color_slider_init, + NULL + }; + type = g_type_register_static (GTK_TYPE_WIDGET, "SPColorSlider", &info, (GTypeFlags)0); + } + return type; +} + +static void sp_color_slider_class_init(SPColorSliderClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS(klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass); + + parent_class = GTK_WIDGET_CLASS(g_type_class_peek_parent(klass)); + + slider_signals[GRABBED] = g_signal_new ("grabbed", + G_TYPE_FROM_CLASS(object_class), + (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE), + G_STRUCT_OFFSET (SPColorSliderClass, grabbed), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + slider_signals[DRAGGED] = g_signal_new ("dragged", + G_TYPE_FROM_CLASS(object_class), + (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE), + G_STRUCT_OFFSET (SPColorSliderClass, dragged), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + slider_signals[RELEASED] = g_signal_new ("released", + G_TYPE_FROM_CLASS(object_class), + (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE), + G_STRUCT_OFFSET (SPColorSliderClass, released), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + slider_signals[CHANGED] = g_signal_new ("changed", + G_TYPE_FROM_CLASS(object_class), + (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE), + G_STRUCT_OFFSET (SPColorSliderClass, changed), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + object_class->dispose = sp_color_slider_dispose; + + widget_class->realize = sp_color_slider_realize; +#if GTK_CHECK_VERSION(3,0,0) + widget_class->get_preferred_width = sp_color_slider_get_preferred_width; + widget_class->get_preferred_height = sp_color_slider_get_preferred_height; + widget_class->draw = sp_color_slider_draw; +#else + widget_class->size_request = sp_color_slider_size_request; + widget_class->expose_event = sp_color_slider_expose; +#endif + widget_class->size_allocate = sp_color_slider_size_allocate; +/* widget_class->draw_focus = sp_color_slider_draw_focus; */ +/* widget_class->draw_default = sp_color_slider_draw_default; */ + + widget_class->button_press_event = sp_color_slider_button_press; + widget_class->button_release_event = sp_color_slider_button_release; + widget_class->motion_notify_event = sp_color_slider_motion_notify; +} + +static void +sp_color_slider_init (SPColorSlider *slider) +{ + /* We are widget with window */ + gtk_widget_set_has_window (GTK_WIDGET(slider), TRUE); + + slider->dragging = FALSE; + + slider->adjustment = NULL; + slider->value = 0.0; + + slider->c0[0] = 0x00; + slider->c0[1] = 0x00; + slider->c0[2] = 0x00; + slider->c0[3] = 0xff; + + slider->cm[0] = 0xff; + slider->cm[1] = 0x00; + slider->cm[2] = 0x00; + slider->cm[3] = 0xff; + + slider->c1[0] = 0xff; + slider->c1[1] = 0xff; + slider->c1[2] = 0xff; + slider->c1[3] = 0xff; + + slider->b0 = 0x5f; + slider->b1 = 0xa0; + slider->bmask = 0x08; + + slider->map = NULL; +} + +static void sp_color_slider_dispose(GObject *object) +{ + SPColorSlider *slider = SP_COLOR_SLIDER (object); + + if (slider->adjustment) { + g_signal_handlers_disconnect_matched (G_OBJECT (slider->adjustment), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, slider); + g_object_unref (slider->adjustment); + slider->adjustment = NULL; + } + + if ((G_OBJECT_CLASS(parent_class))->dispose) + (* (G_OBJECT_CLASS(parent_class))->dispose) (object); +} + +static void +sp_color_slider_realize (GtkWidget *widget) +{ + GdkWindowAttr attributes; + gint attributes_mask; + GtkAllocation allocation; + + gtk_widget_get_allocation(widget, &allocation); + gtk_widget_set_realized (widget, TRUE); + + attributes.window_type = GDK_WINDOW_CHILD; + attributes.x = allocation.x; + attributes.y = allocation.y; + attributes.width = allocation.width; + attributes.height = allocation.height; + attributes.wclass = GDK_INPUT_OUTPUT; + attributes.visual = gdk_screen_get_system_visual(gdk_screen_get_default()); + +#if !GTK_CHECK_VERSION(3,0,0) + attributes.colormap = gdk_screen_get_system_colormap(gdk_screen_get_default()); +#endif + + attributes.event_mask = gtk_widget_get_events (widget); + attributes.event_mask |= (GDK_EXPOSURE_MASK | + GDK_BUTTON_PRESS_MASK | + GDK_BUTTON_RELEASE_MASK | + GDK_POINTER_MOTION_MASK | + GDK_ENTER_NOTIFY_MASK | + GDK_LEAVE_NOTIFY_MASK); +#if GTK_CHECK_VERSION(3,0,0) + attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL; +#else + attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP; +#endif + + gtk_widget_set_window(widget, + gdk_window_new(gtk_widget_get_parent_window(widget), + &attributes, attributes_mask)); + + gdk_window_set_user_data(gtk_widget_get_window(widget), widget); + +#if !GTK_CHECK_VERSION(3,0,0) + // This doesn't do anything in GTK+ 3 + gtk_widget_set_style(widget, + gtk_style_attach(gtk_widget_get_style(widget), + gtk_widget_get_window(widget))); +#endif +} + +static void +sp_color_slider_size_request (GtkWidget *widget, GtkRequisition *requisition) +{ + GtkStyle *style = gtk_widget_get_style(widget); + requisition->width = SLIDER_WIDTH + style->xthickness * 2; + requisition->height = SLIDER_HEIGHT + style->ythickness * 2; +} + +#if GTK_CHECK_VERSION(3,0,0) +static void sp_color_slider_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width) +{ + GtkRequisition requisition; + sp_color_slider_size_request(widget, &requisition); + *minimal_width = *natural_width = requisition.width; +} + +static void sp_color_slider_get_preferred_height(GtkWidget *widget, gint *minimal_height, gint *natural_height) +{ + GtkRequisition requisition; + sp_color_slider_size_request(widget, &requisition); + *minimal_height = *natural_height = requisition.height; +} +#endif + +static void +sp_color_slider_size_allocate (GtkWidget *widget, GtkAllocation *allocation) +{ + gtk_widget_set_allocation(widget, allocation); + + if (gtk_widget_get_realized (widget)) { + /* Resize GdkWindow */ + gdk_window_move_resize(gtk_widget_get_window(widget), + allocation->x, allocation->y, + allocation->width, allocation->height); + } +} + +#if !GTK_CHECK_VERSION(3,0,0) +static gboolean sp_color_slider_expose(GtkWidget *widget, GdkEventExpose * /*event*/) +{ + gboolean result = FALSE; + + if (gtk_widget_is_drawable(widget)) { + GdkWindow *window = gtk_widget_get_window(widget); + cairo_t *cr = gdk_cairo_create(window); + result = sp_color_slider_draw(widget, cr); + cairo_destroy(cr); + } + + return result; +} +#endif + +static gint +sp_color_slider_button_press (GtkWidget *widget, GdkEventButton *event) +{ + SPColorSlider *slider; + + slider = SP_COLOR_SLIDER (widget); + + if (event->button == 1) { + GtkAllocation allocation; + gtk_widget_get_allocation(widget, &allocation); + gint cx, cw; + cx = gtk_widget_get_style(widget)->xthickness; + cw = allocation.width - 2 * cx; + g_signal_emit (G_OBJECT (slider), slider_signals[GRABBED], 0); + slider->dragging = TRUE; + slider->oldvalue = slider->value; + ColorScales::setScaled( slider->adjustment, CLAMP ((gfloat) (event->x - cx) / cw, 0.0, 1.0) ); + g_signal_emit (G_OBJECT (slider), slider_signals[DRAGGED], 0); + +#if GTK_CHECK_VERSION(3,0,0) + gdk_device_grab(gdk_event_get_device(reinterpret_cast(event)), + gtk_widget_get_window(widget), + GDK_OWNERSHIP_NONE, + FALSE, + static_cast(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK), + NULL, + event->time); +#else + gdk_pointer_grab(gtk_widget_get_window(widget), FALSE, + static_cast(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK), + NULL, NULL, event->time); +#endif + } + + return FALSE; +} + +static gint +sp_color_slider_button_release (GtkWidget *widget, GdkEventButton *event) +{ + SPColorSlider *slider; + + slider = SP_COLOR_SLIDER (widget); + + if (event->button == 1) { + +#if GTK_CHECK_VERSION(3,0,0) + gdk_device_ungrab(gdk_event_get_device(reinterpret_cast(event)), + gdk_event_get_time(reinterpret_cast(event))); +#else + gdk_pointer_ungrab (event->time); +#endif + + slider->dragging = FALSE; + g_signal_emit (G_OBJECT (slider), slider_signals[RELEASED], 0); + if (slider->value != slider->oldvalue) g_signal_emit (G_OBJECT (slider), slider_signals[CHANGED], 0); + } + + return FALSE; +} + +static gint +sp_color_slider_motion_notify (GtkWidget *widget, GdkEventMotion *event) +{ + SPColorSlider *slider; + + slider = SP_COLOR_SLIDER (widget); + + if (slider->dragging) { + gint cx, cw; + GtkAllocation allocation; + gtk_widget_get_allocation(widget, &allocation); + cx = gtk_widget_get_style(widget)->xthickness; + cw = allocation.width - 2 * cx; + ColorScales::setScaled( slider->adjustment, CLAMP ((gfloat) (event->x - cx) / cw, 0.0, 1.0) ); + g_signal_emit (G_OBJECT (slider), slider_signals[DRAGGED], 0); + } + + return FALSE; +} + +GtkWidget *sp_color_slider_new(GtkAdjustment *adjustment) +{ + SPColorSlider *slider = SP_COLOR_SLIDER(g_object_new(SP_TYPE_COLOR_SLIDER, NULL)); + + sp_color_slider_set_adjustment (slider, adjustment); + + return GTK_WIDGET (slider); +} + +void sp_color_slider_set_adjustment(SPColorSlider *slider, GtkAdjustment *adjustment) +{ + g_return_if_fail (slider != NULL); + g_return_if_fail (SP_IS_COLOR_SLIDER (slider)); + + if (!adjustment) { + adjustment = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 1.0, 0.01, 0.0, 0.0)); + } else { + gtk_adjustment_set_page_increment(adjustment, 0.0); + gtk_adjustment_set_page_size(adjustment, 0.0); + } + + if (slider->adjustment != adjustment) { + if (slider->adjustment) { + g_signal_handlers_disconnect_matched (G_OBJECT (slider->adjustment), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, slider); + g_object_unref (slider->adjustment); + } + + slider->adjustment = adjustment; + g_object_ref (adjustment); + g_object_ref_sink (adjustment); + + g_signal_connect (G_OBJECT (adjustment), "changed", + G_CALLBACK (sp_color_slider_adjustment_changed), slider); + g_signal_connect (G_OBJECT (adjustment), "value_changed", + G_CALLBACK (sp_color_slider_adjustment_value_changed), slider); + + slider->value = ColorScales::getScaled( adjustment ); + + sp_color_slider_adjustment_changed (adjustment, slider); + } +} + +void +sp_color_slider_set_colors (SPColorSlider *slider, guint32 start, guint32 mid, guint32 end) +{ + g_return_if_fail (slider != NULL); + g_return_if_fail (SP_IS_COLOR_SLIDER (slider)); + + // Remove any map, if set + slider->map = 0; + + slider->c0[0] = start >> 24; + slider->c0[1] = (start >> 16) & 0xff; + slider->c0[2] = (start >> 8) & 0xff; + slider->c0[3] = start & 0xff; + + slider->cm[0] = mid >> 24; + slider->cm[1] = (mid >> 16) & 0xff; + slider->cm[2] = (mid >> 8) & 0xff; + slider->cm[3] = mid & 0xff; + + slider->c1[0] = end >> 24; + slider->c1[1] = (end >> 16) & 0xff; + slider->c1[2] = (end >> 8) & 0xff; + slider->c1[3] = end & 0xff; + + gtk_widget_queue_draw (GTK_WIDGET (slider)); +} + +void +sp_color_slider_set_map (SPColorSlider *slider, const guchar *map) +{ + g_return_if_fail (slider != NULL); + g_return_if_fail (SP_IS_COLOR_SLIDER (slider)); + + slider->map = const_cast(map); + + gtk_widget_queue_draw (GTK_WIDGET (slider)); +} + +void +sp_color_slider_set_background (SPColorSlider *slider, guint dark, guint light, guint size) +{ + g_return_if_fail (slider != NULL); + g_return_if_fail (SP_IS_COLOR_SLIDER (slider)); + + slider->b0 = dark; + slider->b1 = light; + slider->bmask = size; + + gtk_widget_queue_draw (GTK_WIDGET (slider)); +} + +static void +sp_color_slider_adjustment_changed (GtkAdjustment */*adjustment*/, SPColorSlider *slider) +{ + gtk_widget_queue_draw (GTK_WIDGET (slider)); +} + +static void +sp_color_slider_adjustment_value_changed (GtkAdjustment *adjustment, SPColorSlider *slider) +{ + GtkWidget *widget; + + widget = GTK_WIDGET (slider); + + if (slider->value != ColorScales::getScaled( adjustment )) { + gint cx, cy, cw, ch; + GtkStyle *style = gtk_widget_get_style(widget); + GtkAllocation allocation; + gtk_widget_get_allocation(widget, &allocation); + cx = style->xthickness; + cy = style->ythickness; + cw = allocation.width - 2 * cx; + ch = allocation.height - 2 * cy; + if ((gint) (ColorScales::getScaled( adjustment ) * cw) != (gint) (slider->value * cw)) { + gint ax, ay; + gfloat value; + value = slider->value; + slider->value = ColorScales::getScaled( adjustment ); + ax = (int)(cx + value * cw - ARROW_SIZE / 2 - 2); + ay = cy; + gtk_widget_queue_draw_area (widget, ax, ay, ARROW_SIZE + 4, ch); + ax = (int)(cx + slider->value * cw - ARROW_SIZE / 2 - 2); + ay = cy; + gtk_widget_queue_draw_area (widget, ax, ay, ARROW_SIZE + 4, ch); + } else { + slider->value = ColorScales::getScaled( adjustment ); + } + } +} + +static gboolean sp_color_slider_draw(GtkWidget *widget, cairo_t *cr) +{ + SPColorSlider *slider = SP_COLOR_SLIDER(widget); + + gboolean colorsOnTop = Inkscape::Preferences::get()->getBool("/options/workarounds/colorsontop", false); + + GtkAllocation allocation; + gtk_widget_get_allocation(widget, &allocation); + +#if GTK_CHECK_VERSION(3,0,0) + GtkStyleContext *context = gtk_widget_get_style_context(widget); +#else + GdkWindow *window = gtk_widget_get_window(widget); + GtkStyle *style = gtk_widget_get_style(widget); +#endif + + // Draw shadow + if (colorsOnTop) { +#if GTK_CHECK_VERSION(3,0,0) + gtk_render_frame(context, + cr, + 0, 0, + allocation.width, allocation.height); +#else + gtk_paint_shadow( style, window, + gtk_widget_get_state(widget), GTK_SHADOW_IN, + NULL, widget, "colorslider", + 0, 0, + allocation.width, allocation.height); +#endif + } + + /* Paintable part of color gradient area */ + GdkRectangle carea; + +#if GTK_CHECK_VERSION(3,0,0) + GtkBorder padding; + + gtk_style_context_get_padding(context, + gtk_widget_get_state_flags(widget), + &padding); + + carea.x = padding.left; + carea.y = padding.top; +#else + carea.x = style->xthickness; + carea.y = style->ythickness; +#endif + + carea.width = allocation.width - 2 * carea.x; + carea.height = allocation.height - 2 * carea.y; + + if (slider->map) { + /* Render map pixelstore */ + gint d = (1024 << 16) / carea.width; + gint s = 0; + + const guchar *b = sp_color_slider_render_map(0, 0, carea.width, carea.height, + slider->map, s, d, + slider->b0, slider->b1, slider->bmask); + + if (b != NULL && carea.width > 0) { + GdkPixbuf *pb = gdk_pixbuf_new_from_data (b, GDK_COLORSPACE_RGB, + 0, 8, carea.width, carea.height, carea.width * 3, NULL, NULL); + + gdk_cairo_set_source_pixbuf(cr, pb, carea.x, carea.y); + cairo_paint(cr); + g_object_unref(pb); + } + + } else { + gint c[4], dc[4]; + + /* Render gradient */ + + // part 1: from c0 to cm + if (carea.width > 0) { + for (gint i = 0; i < 4; i++) { + c[i] = slider->c0[i] << 16; + dc[i] = ((slider->cm[i] << 16) - c[i]) / (carea.width/2); + } + guint wi = carea.width/2; + const guchar *b = sp_color_slider_render_gradient(0, 0, wi, carea.height, + c, dc, slider->b0, slider->b1, slider->bmask); + + /* Draw pixelstore 1 */ + if (b != NULL && wi > 0) { + GdkPixbuf *pb = gdk_pixbuf_new_from_data (b, GDK_COLORSPACE_RGB, + 0, 8, wi, carea.height, wi * 3, NULL, NULL); + + gdk_cairo_set_source_pixbuf(cr, pb, carea.x, carea.y); + cairo_paint(cr); + g_object_unref(pb); + } + } + + // part 2: from cm to c1 + if (carea.width > 0) { + for (gint i = 0; i < 4; i++) { + c[i] = slider->cm[i] << 16; + dc[i] = ((slider->c1[i] << 16) - c[i]) / (carea.width/2); + } + guint wi = carea.width/2; + const guchar *b = sp_color_slider_render_gradient(carea.width/2, 0, wi, carea.height, + c, dc, + slider->b0, slider->b1, slider->bmask); + + /* Draw pixelstore 2 */ + if (b != NULL && wi > 0) { + GdkPixbuf *pb = gdk_pixbuf_new_from_data (b, GDK_COLORSPACE_RGB, + 0, 8, wi, carea.height, wi * 3, NULL, NULL); + + gdk_cairo_set_source_pixbuf(cr, pb, carea.width/2 + carea.x, carea.y); + cairo_paint(cr); + + g_object_unref(pb); + } + } + } + + /* Draw shadow */ + if (!colorsOnTop) { +#if GTK_CHECK_VERSION(3,0,0) + gtk_render_frame(context, + cr, + 0, 0, + allocation.width, allocation.height); +#else + gtk_paint_shadow( style, window, + gtk_widget_get_state(widget), GTK_SHADOW_IN, + NULL, widget, "colorslider", + 0, 0, + allocation.width, allocation.height); +#endif + } + + /* Draw arrow */ + gint x = (int)(slider->value * (carea.width - 1) - ARROW_SIZE / 2 + carea.x); + gint y1 = carea.y; + gint y2 = carea.y + carea.height - 1; + cairo_set_line_width(cr, 1.0); + + // Define top arrow + cairo_move_to(cr, x - 0.5, y1 + 0.5); + cairo_line_to(cr, x + ARROW_SIZE - 0.5, y1 + 0.5); + cairo_line_to(cr, x + (ARROW_SIZE-1)/2.0, y1 + ARROW_SIZE/2.0 + 0.5); + cairo_line_to(cr, x - 0.5, y1 + 0.5); + + // Define bottom arrow + cairo_move_to(cr, x - 0.5, y2 + 0.5); + cairo_line_to(cr, x + ARROW_SIZE - 0.5, y2 + 0.5); + cairo_line_to(cr, x + (ARROW_SIZE-1)/2.0, y2 - ARROW_SIZE/2.0 + 0.5); + cairo_line_to(cr, x - 0.5, y2 + 0.5); + + // Render both arrows + cairo_set_source_rgb(cr, 1.0, 1.0, 1.0); + cairo_stroke_preserve(cr); + cairo_set_source_rgb(cr, 0.0, 0.0, 0.0); + cairo_fill(cr); + + return FALSE; +} + +/* Colors are << 16 */ + +static const guchar * +sp_color_slider_render_gradient (gint x0, gint y0, gint width, gint height, + gint c[], gint dc[], guint b0, guint b1, guint mask) +{ + static guchar *buf = NULL; + static gint bs = 0; + guchar *dp; + gint x, y; + guint r, g, b, a; + + if (buf && (bs < width * height)) { + g_free (buf); + buf = NULL; + } + if (!buf) { + buf = g_new (guchar, width * height * 3); + bs = width * height; + } + + dp = buf; + r = c[0]; + g = c[1]; + b = c[2]; + a = c[3]; + for (x = x0; x < x0 + width; x++) { + gint cr, cg, cb, ca; + guchar *d; + cr = r >> 16; + cg = g >> 16; + cb = b >> 16; + ca = a >> 16; + d = dp; + for (y = y0; y < y0 + height; y++) { + guint bg, fc; + /* Background value */ + bg = ((x & mask) ^ (y & mask)) ? b0 : b1; + fc = (cr - bg) * ca; + d[0] = bg + ((fc + (fc >> 8) + 0x80) >> 8); + fc = (cg - bg) * ca; + d[1] = bg + ((fc + (fc >> 8) + 0x80) >> 8); + fc = (cb - bg) * ca; + d[2] = bg + ((fc + (fc >> 8) + 0x80) >> 8); + d += 3 * width; + } + r += dc[0]; + g += dc[1]; + b += dc[2]; + a += dc[3]; + dp += 3; + } + + return buf; +} + +/* Positions are << 16 */ + +static const guchar * +sp_color_slider_render_map (gint x0, gint y0, gint width, gint height, + guchar *map, gint start, gint step, guint b0, guint b1, guint mask) +{ + static guchar *buf = NULL; + static gint bs = 0; + guchar *dp; + gint x, y; + + if (buf && (bs < width * height)) { + g_free (buf); + buf = NULL; + } + if (!buf) { + buf = g_new (guchar, width * height * 3); + bs = width * height; + } + + dp = buf; + for (x = x0; x < x0 + width; x++) { + gint cr, cg, cb, ca; + guchar *d = dp; + guchar *sp = map + 4 * (start >> 16); + cr = *sp++; + cg = *sp++; + cb = *sp++; + ca = *sp++; + for (y = y0; y < y0 + height; y++) { + guint bg, fc; + /* Background value */ + bg = ((x & mask) ^ (y & mask)) ? b0 : b1; + fc = (cr - bg) * ca; + d[0] = bg + ((fc + (fc >> 8) + 0x80) >> 8); + fc = (cg - bg) * ca; + d[1] = bg + ((fc + (fc >> 8) + 0x80) >> 8); + fc = (cb - bg) * ca; + d[2] = bg + ((fc + (fc >> 8) + 0x80) >> 8); + d += 3 * width; + } + dp += 3; + start += step; + } + + return buf; +} + diff --git a/src/ui/widget/color-slider.h b/src/ui/widget/color-slider.h new file mode 100644 index 000000000..d8be7d111 --- /dev/null +++ b/src/ui/widget/color-slider.h @@ -0,0 +1,146 @@ +#ifndef __SP_COLOR_SLIDER_H__ +#define __SP_COLOR_SLIDER_H__ + +/* Author: + * Lauris Kaplinski + * + * Copyright (C) 2001-2002 Lauris Kaplinski + * + * This code is in public domain + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H +#include +#endif + +#include +#include + +namespace Inkscape +{ +namespace UI +{ +namespace Widget +{ + +/* + * A slider with colored background + */ +class ColorSlider: public Gtk::Widget { +public: + //if GTK2 + ColorSlider(Gtk::Adjustment *adjustment); + ~ColorSlider(); + + void set_adjustment(Gtk::Adjustment *adjustment); + + void set_colors(guint32 start, guint32 mid, guint32 end); + + void set_map(const guchar* map); + + void set_background(guint dark, guint light, guint size); + + sigc::signal signal_grabbed; + sigc::signal signal_dragged; + sigc::signal signal_released; + sigc::signal signal_value_changed; + +protected: + void on_size_allocate(Gtk::Allocation& allocation); + void on_realize(); + void on_unrealize(); + bool on_button_press_event(GdkEventButton *event); + bool on_button_release_event(GdkEventButton *event); + bool on_motion_notify_event(GdkEventMotion *event); + + //if GTK2 + void on_size_request(Gtk::Requisition* requisition); + bool on_expose_event(GdkEventExpose* event); + //if GTK3 + //request mode, get preffered width/height vfunc + //endif + + bool on_draw(const Cairo::RefPtr& cr); + + //TODO: on_adjustment_changed method + //TODO: on_adjustment value changed method + connection + +private: + bool _dragging; + + Gtk::Adjustment *_adjustment; + + gfloat _value; + gfloat _oldvalue; + guchar _c0[4], _cm[4], _c1[4]; + guchar _b0, _b1; + guchar _bmask; + + gint _mapsize; + guchar *_map; + + Glib::RefPtr _refGdkWindow; +}; + +}//namespace Widget +}//namespace UI +}//namespace Inkscape + + +#include + +#include + + + +struct SPColorSlider; +struct SPColorSliderClass; + +#define SP_TYPE_COLOR_SLIDER (sp_color_slider_get_type ()) +#define SP_COLOR_SLIDER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SP_TYPE_COLOR_SLIDER, SPColorSlider)) +#define SP_COLOR_SLIDER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), SP_TYPE_COLOR_SLIDER, SPColorSliderClass)) +#define SP_IS_COLOR_SLIDER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), SP_TYPE_COLOR_SLIDER)) +#define SP_IS_COLOR_SLIDER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SP_TYPE_COLOR_SLIDER)) + +struct SPColorSlider { + GtkWidget widget; + + guint dragging : 1; + + GtkAdjustment *adjustment; + + gfloat value; + gfloat oldvalue; + guchar c0[4], cm[4], c1[4]; + guchar b0, b1; + guchar bmask; + + gint mapsize; + guchar *map; +}; + +struct SPColorSliderClass { + GtkWidgetClass parent_class; + + void (* grabbed) (SPColorSlider *slider); + void (* dragged) (SPColorSlider *slider); + void (* released) (SPColorSlider *slider); + void (* changed) (SPColorSlider *slider); +}; + +GType sp_color_slider_get_type (void); + +GtkWidget *sp_color_slider_new (GtkAdjustment *adjustment); + +void sp_color_slider_set_adjustment (SPColorSlider *slider, GtkAdjustment *adjustment); +void sp_color_slider_set_colors (SPColorSlider *slider, guint32 start, guint32 mid, guint32 end); +void sp_color_slider_set_map (SPColorSlider *slider, const guchar *map); +void sp_color_slider_set_background (SPColorSlider *slider, guint dark, guint light, guint size); + + + +#endif -- cgit v1.2.3 From 07ce2371a81e1393032c2ce4e0c0373282df204b Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Fri, 23 May 2014 12:53:33 +0200 Subject: ported draw method (bzr r13341.6.4) --- src/ui/widget/color-slider.cpp | 173 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 167 insertions(+), 6 deletions(-) (limited to 'src/ui') diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index 430239f00..d927a7f67 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -29,6 +29,11 @@ static const gint SLIDER_WIDTH = 96; static const gint SLIDER_HEIGHT = 8; static const gint ARROW_SIZE = 7; +static const guchar *sp_color_slider_render_gradient (gint x0, gint y0, gint width, gint height, + gint c[], gint dc[], guint b0, guint b1, guint mask); +static const guchar *sp_color_slider_render_map (gint x0, gint y0, gint width, gint height, + guchar *map, gint start, gint step, guint b0, guint b1, guint mask); + namespace Inkscape { namespace UI { namespace Widget { @@ -165,8 +170,26 @@ void ColorSlider::set_adjustment(Gtk::Adjustment* /*adjustment*/) { //TODO: implementation } -void ColorSlider::set_colors(guint32 start, guint32 min, guint32 end) { +void ColorSlider::set_colors(guint32 start, guint32 mid, guint32 end) { + // Remove any map, if set + _map = 0; + + _c0[0] = start >> 24; + _c0[1] = (start >> 16) & 0xff; + _c0[2] = (start >> 8) & 0xff; + _c0[3] = start & 0xff; + _cm[0] = mid >> 24; + _cm[1] = (mid >> 16) & 0xff; + _cm[2] = (mid >> 8) & 0xff; + _cm[3] = mid & 0xff; + + _c1[0] = end >> 24; + _c1[1] = (end >> 16) & 0xff; + _c1[2] = (end >> 8) & 0xff; + _c1[3] = end & 0xff; + + queue_draw(); } void ColorSlider::set_map(const guchar *map) { @@ -178,6 +201,149 @@ void ColorSlider::set_background(guint dark, guint light, guint size) { } bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { + gboolean colorsOnTop = Inkscape::Preferences::get()->getBool("/options/workarounds/colorsontop", false); + + Gtk::Allocation allocation = get_allocation(); + +#if GTK_CHECK_VERSION(3,0,0) + Glib::RefPtr context = get_style_context(); +#else + Glib::RefPtr window = get_window(); + Glib::RefPtr style = get_style(); +#endif + + // Draw shadow + if (colorsOnTop) { +#if GTK_CHECK_VERSION(3,0,0) + context->render_frame(cr, 0, 0, + allocation.get_width(), allocation.get_height()); +#else + style->paint_shadow(window, get_state(), Gtk::SHADOW_IN, + Gdk::Rectangle(), *this, "colorslider", + 0, 0, + allocation.get_width(), allocation.get_height()); +#endif + } + + /* Paintable part of color gradient area */ + Gdk::Rectangle carea; + +#if GTK_CHECK_VERSION(3,0,0) + Gtk::Border padding; + + padding = style_context->get_padding(get_state_flags()); + + carea.set_x(padding.get_left()); + carea.set_y(padding.get_top());; +#else + carea.set_x(style->get_xthickness()); + carea.set_y(style->get_ythickness()); +#endif + + carea.set_width(allocation.get_width() - 2 * carea.get_x()); + carea.set_height(allocation.get_height() - 2 * carea.get_y()); + + if (_map) { + /* Render map pixelstore */ + gint d = (1024 << 16) / carea.get_width(); + gint s = 0; + + const guchar *b = sp_color_slider_render_map(0, 0, carea.get_width(), carea.get_height(), + _map, s, d, + _b0, _b1, _bmask); + + if (b != NULL && carea.get_width() > 0) { + Glib::RefPtr pb = Gdk::Pixbuf::create_from_data(b, Gdk::COLORSPACE_RGB, + false, 8, carea.get_width(), carea.get_height(), carea.get_width() * 3); + + Gdk::Cairo::set_source_pixbuf(cr, pb, carea.get_x(), carea.get_y()); + cr->paint(); + } + + } else { + gint c[4], dc[4]; + + /* Render gradient */ + + // part 1: from c0 to cm + if (carea.get_width() > 0) { + for (gint i = 0; i < 4; i++) { + c[i] = _c0[i] << 16; + dc[i] = ((_cm[i] << 16) - c[i]) / (carea.get_width()/2); + } + guint wi = carea.get_width()/2; + const guchar *b = sp_color_slider_render_gradient(0, 0, wi, carea.get_height(), + c, dc, _b0, _b1, _bmask); + + /* Draw pixelstore 1 */ + if (b != NULL && wi > 0) { + Glib::RefPtr pb = Gdk::Pixbuf::create_from_data(b, Gdk::COLORSPACE_RGB, + false, 8, wi, carea.get_height(), carea.get_width() * 3); + + Gdk::Cairo::set_source_pixbuf(cr, pb, carea.get_x(), carea.get_y()); + cr->paint(); + } + } + + // part 2: from cm to c1 + if (carea.get_width() > 0) { + for (gint i = 0; i < 4; i++) { + c[i] = _cm[i] << 16; + dc[i] = ((_c1[i] << 16) - c[i]) / (carea.get_width()/2); + } + guint wi = carea.get_width()/2; + const guchar *b = sp_color_slider_render_gradient(carea.get_width()/2, 0, wi, carea.get_height(), + c, dc, + _b0, _b1, _bmask); + + /* Draw pixelstore 2 */ + if (b != NULL && wi > 0) { + Glib::RefPtr pb = Gdk::Pixbuf::create_from_data(b, Gdk::COLORSPACE_RGB, + false, 8, wi, carea.get_height(), carea.get_width() * 3); + + Gdk::Cairo::set_source_pixbuf(cr, pb, carea.get_width()/2 + carea.get_x(), carea.get_y()); + cr->paint(); + } + } + } + + /* Draw shadow */ + if (!colorsOnTop) { +#if GTK_CHECK_VERSION(3,0,0) + context->render_frame(cr, 0, 0, + allocation.get_width(), allocation.get_height()); +#else + style->paint_shadow(window, get_state(), Gtk::SHADOW_IN, + Gdk::Rectangle(), *this, "colorslider", + 0, 0, + allocation.get_width(), allocation.get_height()); +#endif + } + + /* Draw arrow */ + gint x = (int)(_value * (carea.get_width() - 1) - ARROW_SIZE / 2 + carea.get_x()); + gint y1 = carea.get_y(); + gint y2 = carea.get_y() + carea.get_height() - 1; + cr->set_line_width(1.0); + + // Define top arrow + cr->move_to(x - 0.5, y1 + 0.5); + cr->line_to(x + ARROW_SIZE - 0.5, y1 + 0.5); + cr->line_to(x + (ARROW_SIZE-1)/2.0, y1 + ARROW_SIZE/2.0 + 0.5); + cr->line_to(x - 0.5, y1 + 0.5); + + // Define bottom arrow + cr->move_to(x - 0.5, y2 + 0.5); + cr->line_to(x + ARROW_SIZE - 0.5, y2 + 0.5); + cr->line_to(x + (ARROW_SIZE-1)/2.0, y2 - ARROW_SIZE/2.0 + 0.5); + cr->line_to(x - 0.5, y2 + 0.5); + + // Render both arrows + cr->set_source_rgb(1.0, 1.0, 1.0); + cr->stroke_preserve(); + cr->set_source_rgb(0.0, 0.0, 0.0); + cr->fill(); + return false; } @@ -246,11 +412,6 @@ static gint sp_color_slider_motion_notify (GtkWidget *widget, GdkEventMotion *ev static void sp_color_slider_adjustment_changed (GtkAdjustment *adjustment, SPColorSlider *slider); static void sp_color_slider_adjustment_value_changed (GtkAdjustment *adjustment, SPColorSlider *slider); -static const guchar *sp_color_slider_render_gradient (gint x0, gint y0, gint width, gint height, - gint c[], gint dc[], guint b0, guint b1, guint mask); -static const guchar *sp_color_slider_render_map (gint x0, gint y0, gint width, gint height, - guchar *map, gint start, gint step, guint b0, guint b1, guint mask); - static GtkWidgetClass *parent_class; static guint slider_signals[LAST_SIGNAL] = {0}; -- cgit v1.2.3 From 837f710ed9947b30a77a990ae27beed10449f977 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 24 May 2014 01:32:04 +0200 Subject: SPColorSlider c++-sification: ported drawing (bzr r13341.6.5) --- src/ui/widget/color-slider.cpp | 79 ++++++++++++++++++++++++++++++++++++++---- src/ui/widget/color-slider.h | 6 ++++ 2 files changed, 78 insertions(+), 7 deletions(-) (limited to 'src/ui') diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index d927a7f67..82eafdcf8 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -70,8 +70,9 @@ ColorSlider::ColorSlider(Gtk::Adjustment* adjustment) ColorSlider::~ColorSlider() { if (_adjustment) { - //TODO: disconnect all connections - delete _adjustment; + _adjustment_changed_connection.disconnect(); + _adjustment_value_changed_connection.disconnect(); + _adjustment->unreference(); _adjustment = NULL; } } @@ -134,6 +135,8 @@ void ColorSlider::on_size_request(Gtk::Requisition* requisition) { //TODO: GTK3 prefferred width/height void ColorSlider::on_size_allocate(Gtk::Allocation& allocation) { + set_allocation(allocation); + if (get_realized()) { _refGdkWindow->move_resize(allocation.get_x(), allocation.get_y(), allocation.get_width(), allocation.get_height()); @@ -166,8 +169,64 @@ bool ColorSlider::on_motion_notify_event(GdkEventMotion *event) { return false; } -void ColorSlider::set_adjustment(Gtk::Adjustment* /*adjustment*/) { - //TODO: implementation +void ColorSlider::set_adjustment(Gtk::Adjustment *adjustment) { + if (!adjustment) { + _adjustment = Gtk::manage(new Gtk::Adjustment(0.0, 0.0, 1.0, 0.01, 0.0, 0.0)); + } else { + adjustment->set_page_increment(0.0); + adjustment->set_page_size(0.0); + } + + if (_adjustment != adjustment) { + if (_adjustment) { + _adjustment_changed_connection.disconnect(); + _adjustment_value_changed_connection.disconnect(); + //if GTK2 + _adjustment->unreference(); + } + + _adjustment = adjustment; + _adjustment->reference(); + + _adjustment_changed_connection = _adjustment->signal_changed().connect( + sigc::mem_fun(this, &ColorSlider::on_adjustment_changed)); + _adjustment_value_changed_connection = _adjustment->signal_value_changed().connect( + sigc::mem_fun(this, &ColorSlider::on_adjustment_value_changed)); + + _value = ColorScales::getScaled(_adjustment->gobj()); + + on_adjustment_changed(); + } +} + +void ColorSlider::on_adjustment_changed() { + queue_draw(); +} + +void ColorSlider::on_adjustment_value_changed() { + if (_value != ColorScales::getScaled( _adjustment->gobj() )) { + gint cx, cy, cw, ch; + Glib::RefPtr style = get_style(); + Gtk::Allocation allocation = get_allocation(); + cx = style->get_xthickness(); + cy = style->get_ythickness(); + cw = allocation.get_width() - 2 * cx; + ch = allocation.get_height() - 2 * cy; + if ((gint) (ColorScales::getScaled( _adjustment->gobj() ) * cw) != (gint) (_value * cw)) { + gint ax, ay; + gfloat value; + value = _value; + _value = ColorScales::getScaled( _adjustment->gobj() ); + ax = (int)(cx + value * cw - ARROW_SIZE / 2 - 2); + ay = cy; + queue_draw_area(ax, ay, ARROW_SIZE + 4, ch); + ax = (int)(cx + _value * cw - ARROW_SIZE / 2 - 2); + ay = cy; + queue_draw_area(ax, ay, ARROW_SIZE + 4, ch); + } else { + _value = ColorScales::getScaled( _adjustment->gobj() ); + } + } } void ColorSlider::set_colors(guint32 start, guint32 mid, guint32 end) { @@ -193,11 +252,17 @@ void ColorSlider::set_colors(guint32 start, guint32 mid, guint32 end) { } void ColorSlider::set_map(const guchar *map) { + _map = const_cast(map); + queue_draw(); } void ColorSlider::set_background(guint dark, guint light, guint size) { + _b0 = dark; + _b1 = light; + _bmask = size; + queue_draw(); } bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { @@ -278,7 +343,7 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { /* Draw pixelstore 1 */ if (b != NULL && wi > 0) { Glib::RefPtr pb = Gdk::Pixbuf::create_from_data(b, Gdk::COLORSPACE_RGB, - false, 8, wi, carea.get_height(), carea.get_width() * 3); + false, 8, wi, carea.get_height(), wi * 3); Gdk::Cairo::set_source_pixbuf(cr, pb, carea.get_x(), carea.get_y()); cr->paint(); @@ -299,7 +364,7 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { /* Draw pixelstore 2 */ if (b != NULL && wi > 0) { Glib::RefPtr pb = Gdk::Pixbuf::create_from_data(b, Gdk::COLORSPACE_RGB, - false, 8, wi, carea.get_height(), carea.get_width() * 3); + false, 8, wi, carea.get_height(), wi * 3); Gdk::Cairo::set_source_pixbuf(cr, pb, carea.get_width()/2 + carea.get_x(), carea.get_y()); cr->paint(); @@ -1012,7 +1077,7 @@ static gboolean sp_color_slider_draw(GtkWidget *widget, cairo_t *cr) cairo_stroke_preserve(cr); cairo_set_source_rgb(cr, 0.0, 0.0, 0.0); cairo_fill(cr); - + return FALSE; } diff --git a/src/ui/widget/color-slider.h b/src/ui/widget/color-slider.h index d8be7d111..7f3088772 100644 --- a/src/ui/widget/color-slider.h +++ b/src/ui/widget/color-slider.h @@ -36,6 +36,7 @@ public: ColorSlider(Gtk::Adjustment *adjustment); ~ColorSlider(); + //if GTK2 void set_adjustment(Gtk::Adjustment *adjustment); void set_colors(guint32 start, guint32 mid, guint32 end); @@ -70,9 +71,14 @@ protected: //TODO: on_adjustment value changed method + connection private: + void on_adjustment_changed(); + void on_adjustment_value_changed(); + bool _dragging; Gtk::Adjustment *_adjustment; + sigc::connection _adjustment_changed_connection; + sigc::connection _adjustment_value_changed_connection; gfloat _value; gfloat _oldvalue; -- cgit v1.2.3 From 84379bcbe7e5008ee24d0b1f465d2c55ff9529b7 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 24 May 2014 14:42:58 +0200 Subject: SPColorSlider c++-sification: ported mouse events (bzr r13341.6.6) --- src/ui/widget/color-slider.cpp | 53 +++++++++++++++++++++++++++++++++++++++--- 1 file changed, 50 insertions(+), 3 deletions(-) (limited to 'src/ui') diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index 82eafdcf8..2c330e9ca 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -18,6 +18,7 @@ #include "color-slider.h" #include +#include #include #include #include @@ -155,17 +156,63 @@ bool ColorSlider::on_expose_event(GdkEventExpose* event) { } bool ColorSlider::on_button_press_event(GdkEventButton *event) { - //TODO: implementation + if (event->button == 1) { + Gtk::Allocation allocation = get_allocation(); + gint cx, cw; + cx = get_style()->get_xthickness(); + cw = allocation.get_width() - 2 * cx; + signal_grabbed.emit(); + _dragging = true; + _oldvalue = _value; + ColorScales::setScaled( _adjustment->gobj(), CLAMP ((gfloat) (event->x - cx) / cw, 0.0, 1.0) ); + signal_dragged.emit(); + +#if GTK_CHECK_VERSION(3,0,0) + gdk_device_grab(gdk_event_get_device(reinterpret_cast(event)), + _refGdkWindow->gobj(), + GDK_OWNERSHIP_NONE, + FALSE, + static_cast(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK), + NULL, + event->time); +#else + get_window()->pointer_grab(false, Gdk::POINTER_MOTION_MASK | Gdk::BUTTON_RELEASE_MASK, Gdk::Cursor(), event->time); +#endif + } + return false; } bool ColorSlider::on_button_release_event(GdkEventButton *event) { - //TODO: implementation + if (event->button == 1) { + +#if GTK_CHECK_VERSION(3,0,0) + gdk_device_ungrab(gdk_event_get_device(reinterpret_cast(event)), + gdk_event_get_time(reinterpret_cast(event))); +#else + get_window()->pointer_ungrab(event->time); +#endif + + _dragging = false; + signal_released.emit(); + if (_value != _oldvalue) { + signal_value_changed.emit(); + } + } + return false; } bool ColorSlider::on_motion_notify_event(GdkEventMotion *event) { - //TODO: implementation + if (_dragging) { + gint cx, cw; + Gtk::Allocation allocation = get_allocation(); + cx = get_style()->get_xthickness(); + cw = allocation.get_width() - 2 * cx; + ColorScales::setScaled( _adjustment->gobj(), CLAMP ((gfloat) (event->x - cx) / cw, 0.0, 1.0) ); + signal_dragged.emit(); + } + return false; } -- cgit v1.2.3 From a87f50a6174b65b8db1d0a091d30a5de206f03df Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 24 May 2014 15:07:28 +0200 Subject: SPColorSlider c++-sification: fixed drawing border (bzr r13341.6.7) --- src/ui/widget/color-slider.cpp | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) (limited to 'src/ui') diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index 2c330e9ca..31ae5fbdf 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -330,10 +330,11 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { context->render_frame(cr, 0, 0, allocation.get_width(), allocation.get_height()); #else - style->paint_shadow(window, get_state(), Gtk::SHADOW_IN, - Gdk::Rectangle(), *this, "colorslider", - 0, 0, - allocation.get_width(), allocation.get_height()); + gtk_paint_shadow( style->gobj(), window->gobj(), + gtk_widget_get_state(gobj()), GTK_SHADOW_IN, + NULL, gobj(), "colorslider", + 0, 0, + allocation.get_width(), allocation.get_height()); #endif } @@ -425,10 +426,11 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { context->render_frame(cr, 0, 0, allocation.get_width(), allocation.get_height()); #else - style->paint_shadow(window, get_state(), Gtk::SHADOW_IN, - Gdk::Rectangle(), *this, "colorslider", - 0, 0, - allocation.get_width(), allocation.get_height()); + gtk_paint_shadow( style->gobj(), window->gobj(), + gtk_widget_get_state(gobj()), GTK_SHADOW_IN, + NULL, gobj(), "colorslider", + 0, 0, + allocation.get_width(), allocation.get_height()); #endif } -- cgit v1.2.3 From c77abbc4c33e15c742b477a178e90816f4ab3d67 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 24 May 2014 15:16:37 +0200 Subject: SPColorSlider c++-sification: fixed failed Gtk assertion (bzr r13341.6.8) --- src/ui/widget/color-slider.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'src/ui') diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index 31ae5fbdf..b28393be0 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -176,7 +176,9 @@ bool ColorSlider::on_button_press_event(GdkEventButton *event) { NULL, event->time); #else - get_window()->pointer_grab(false, Gdk::POINTER_MOTION_MASK | Gdk::BUTTON_RELEASE_MASK, Gdk::Cursor(), event->time); + gdk_pointer_grab(get_window()->gobj(), FALSE, + static_cast(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK), + NULL, NULL, event->time); #endif } -- cgit v1.2.3 From 0d4b01e5ed7dd47bc2f1664845803de87ebb2b01 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 24 May 2014 16:40:56 +0200 Subject: SPColorSlider c++-sification: compilation with GTK3 (bzr r13341.6.9) --- src/ui/widget/color-slider.cpp | 99 ++++++++++++++++++++++++++++++++++-------- src/ui/widget/color-slider.h | 33 ++++++++------ 2 files changed, 100 insertions(+), 32 deletions(-) (limited to 'src/ui') diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index b28393be0..450dcd6f6 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -22,6 +22,11 @@ #include #include #include +#if GTK_CHECK_VERSION(3,0,0) +#include +#else +#include +#endif #include "widgets/sp-color-scales.h" #include "preferences.h" @@ -39,9 +44,14 @@ namespace Inkscape { namespace UI { namespace Widget { +#if GTK_CHECK_VERSION(3,0,0) +ColorSlider::ColorSlider(Glib::RefPtr adjustment) + : _dragging(false) +#else ColorSlider::ColorSlider(Gtk::Adjustment* adjustment) : _dragging(false) , _adjustment(NULL) +#endif , _value(0.0) , _oldvalue(0.0) , _mapsize(0) @@ -73,8 +83,12 @@ ColorSlider::~ColorSlider() { if (_adjustment) { _adjustment_changed_connection.disconnect(); _adjustment_value_changed_connection.disconnect(); +#if GTK_CHECK_VERSION(3,0,0) + _adjustment.reset(); +#else _adjustment->unreference(); _adjustment = NULL; +#endif } } @@ -117,7 +131,9 @@ void ColorSlider::on_realize() { set_window(_refGdkWindow); _refGdkWindow->set_user_data(gobj()); +#if !GTK_CHECK_VERSION(3,0,0) style_attach(); +#endif } } @@ -127,14 +143,6 @@ void ColorSlider::on_unrealize() { Gtk::Widget::on_unrealize(); } -void ColorSlider::on_size_request(Gtk::Requisition* requisition) { - GtkStyle *style = gtk_widget_get_style(gobj()); - requisition->width = SLIDER_WIDTH + style->xthickness * 2; - requisition->height = SLIDER_HEIGHT + style->ythickness * 2; -} - -//TODO: GTK3 prefferred width/height - void ColorSlider::on_size_allocate(Gtk::Allocation& allocation) { set_allocation(allocation); @@ -144,7 +152,32 @@ void ColorSlider::on_size_allocate(Gtk::Allocation& allocation) { } } -//TODO: if not GTK3 +#if GTK_CHECK_VERSION(3,0,0) + +void ColorSlider::get_preferred_width_vfunc(int& minimum_width, int& natural_width) const +{ + Glib::RefPtrstyle_context = get_style_context(); + Gtk::Border padding = style_context->get_padding(get_state_flags()); + int width = SLIDER_WIDTH + padding.get_left() + padding.get_right(); + minimum_width = natural_width = width; + +} + +void ColorSlider::get_preferred_height_vfunc(int& minimum_height, int& natural_height) const +{ + Glib::RefPtrstyle_context = get_style_context(); + Gtk::Border padding = style_context->get_padding(get_state_flags()); + int height = SLIDER_WIDTH + padding.get_top() + padding.get_bottom(); + minimum_height = natural_height = height; +} +#else + +void ColorSlider::on_size_request(Gtk::Requisition* requisition) { + GtkStyle *style = gtk_widget_get_style(gobj()); + requisition->width = SLIDER_WIDTH + style->xthickness * 2; + requisition->height = SLIDER_HEIGHT + style->ythickness * 2; +} + bool ColorSlider::on_expose_event(GdkEventExpose* event) { bool result = false; @@ -155,11 +188,17 @@ bool ColorSlider::on_expose_event(GdkEventExpose* event) { return result; } +#endif + bool ColorSlider::on_button_press_event(GdkEventButton *event) { if (event->button == 1) { Gtk::Allocation allocation = get_allocation(); gint cx, cw; +#if GTK_CHECK_VERSION(3,0,0) + cx = get_style_context()->get_padding(get_state_flags()).get_left(); +#else cx = get_style()->get_xthickness(); +#endif cw = allocation.get_width() - 2 * cx; signal_grabbed.emit(); _dragging = true; @@ -209,7 +248,11 @@ bool ColorSlider::on_motion_notify_event(GdkEventMotion *event) { if (_dragging) { gint cx, cw; Gtk::Allocation allocation = get_allocation(); +#if GTK_CHECK_VERSION(3,0,0) + cx = get_style_context()->get_padding(get_state_flags()).get_left(); +#else cx = get_style()->get_xthickness(); +#endif cw = allocation.get_width() - 2 * cx; ColorScales::setScaled( _adjustment->gobj(), CLAMP ((gfloat) (event->x - cx) / cw, 0.0, 1.0) ); signal_dragged.emit(); @@ -218,9 +261,17 @@ bool ColorSlider::on_motion_notify_event(GdkEventMotion *event) { return false; } +#if GTK_CHECK_VERSION(3,0,0) +void ColorSlider::set_adjustment(Glib::RefPtr adjustment) { +#else void ColorSlider::set_adjustment(Gtk::Adjustment *adjustment) { +#endif if (!adjustment) { +#if GTK_CHECK_VERSION(3,0,0) + _adjustment = Gtk::Adjustment::create(0.0, 0.0, 1.0, 0.01, 0.0, 0.0); +#else _adjustment = Gtk::manage(new Gtk::Adjustment(0.0, 0.0, 1.0, 0.01, 0.0, 0.0)); +#endif } else { adjustment->set_page_increment(0.0); adjustment->set_page_size(0.0); @@ -230,35 +281,45 @@ void ColorSlider::set_adjustment(Gtk::Adjustment *adjustment) { if (_adjustment) { _adjustment_changed_connection.disconnect(); _adjustment_value_changed_connection.disconnect(); - //if GTK2 +#if !GTK_CHECK_VERSION(3,0,0) _adjustment->unreference(); +#endif } _adjustment = adjustment; +#if !GTK_CHECK_VERSION(3,0,0) _adjustment->reference(); - +#endif _adjustment_changed_connection = _adjustment->signal_changed().connect( - sigc::mem_fun(this, &ColorSlider::on_adjustment_changed)); + sigc::mem_fun(this, &ColorSlider::_on_adjustment_changed)); _adjustment_value_changed_connection = _adjustment->signal_value_changed().connect( - sigc::mem_fun(this, &ColorSlider::on_adjustment_value_changed)); + sigc::mem_fun(this, &ColorSlider::_on_adjustment_value_changed)); _value = ColorScales::getScaled(_adjustment->gobj()); - on_adjustment_changed(); + _on_adjustment_changed(); } } -void ColorSlider::on_adjustment_changed() { +void ColorSlider::_on_adjustment_changed() { queue_draw(); } -void ColorSlider::on_adjustment_value_changed() { +void ColorSlider::_on_adjustment_value_changed() { if (_value != ColorScales::getScaled( _adjustment->gobj() )) { gint cx, cy, cw, ch; +#if GTK_CHECK_VERSION(3,0,0) + Glib::RefPtrstyle_context = get_style_context(); + Gtk::Allocation allocation = get_allocation(); + Gtk::Border padding = style_context->get_padding(get_state_flags()); + cx = padding.get_left(); + cy = padding.get_top(); +#else Glib::RefPtr style = get_style(); Gtk::Allocation allocation = get_allocation(); cx = style->get_xthickness(); cy = style->get_ythickness(); +#endif cw = allocation.get_width() - 2 * cx; ch = allocation.get_height() - 2 * cy; if ((gint) (ColorScales::getScaled( _adjustment->gobj() ) * cw) != (gint) (_value * cw)) { @@ -320,7 +381,7 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { Gtk::Allocation allocation = get_allocation(); #if GTK_CHECK_VERSION(3,0,0) - Glib::RefPtr context = get_style_context(); + Glib::RefPtr style_context = get_style_context(); #else Glib::RefPtr window = get_window(); Glib::RefPtr style = get_style(); @@ -329,7 +390,7 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { // Draw shadow if (colorsOnTop) { #if GTK_CHECK_VERSION(3,0,0) - context->render_frame(cr, 0, 0, + style_context->render_frame(cr, 0, 0, allocation.get_width(), allocation.get_height()); #else gtk_paint_shadow( style->gobj(), window->gobj(), @@ -425,7 +486,7 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { /* Draw shadow */ if (!colorsOnTop) { #if GTK_CHECK_VERSION(3,0,0) - context->render_frame(cr, 0, 0, + style_context->render_frame(cr, 0, 0, allocation.get_width(), allocation.get_height()); #else gtk_paint_shadow( style->gobj(), window->gobj(), diff --git a/src/ui/widget/color-slider.h b/src/ui/widget/color-slider.h index 7f3088772..c6d843fe5 100644 --- a/src/ui/widget/color-slider.h +++ b/src/ui/widget/color-slider.h @@ -32,12 +32,18 @@ namespace Widget */ class ColorSlider: public Gtk::Widget { public: - //if GTK2 +#if GTK_CHECK_VERSION(3,0,0) + ColorSlider(Glib::RefPtr adjustment); +#else ColorSlider(Gtk::Adjustment *adjustment); +#endif ~ColorSlider(); - //if GTK2 +#if GTK_CHECK_VERSION(3,0,0) + void set_adjustment(Glib::RefPtr adjustment); +#else void set_adjustment(Gtk::Adjustment *adjustment); +#endif void set_colors(guint32 start, guint32 mid, guint32 end); @@ -57,26 +63,27 @@ protected: bool on_button_press_event(GdkEventButton *event); bool on_button_release_event(GdkEventButton *event); bool on_motion_notify_event(GdkEventMotion *event); + bool on_draw(const Cairo::RefPtr& cr); - //if GTK2 +#if GTK_CHECK_VERSION(3,0,0) + void get_preferred_width_vfunc(int& minimum_width, int& natural_width) const; + void get_preferred_height_vfunc(int& minimum_height, int& natural_height) const; +#else void on_size_request(Gtk::Requisition* requisition); bool on_expose_event(GdkEventExpose* event); - //if GTK3 - //request mode, get preffered width/height vfunc - //endif - - bool on_draw(const Cairo::RefPtr& cr); - - //TODO: on_adjustment_changed method - //TODO: on_adjustment value changed method + connection +#endif private: - void on_adjustment_changed(); - void on_adjustment_value_changed(); + void _on_adjustment_changed(); + void _on_adjustment_value_changed(); bool _dragging; +#if GTK_CHECK_VERSION(3,0,0) + Glib::RefPtr _adjustment; +#else Gtk::Adjustment *_adjustment; +#endif sigc::connection _adjustment_changed_connection; sigc::connection _adjustment_value_changed_connection; -- cgit v1.2.3 From c28cce00312a421bea39c4d78360e3939c573de3 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 24 May 2014 19:14:18 +0200 Subject: SPColorSlider c++-sification: fixed size request (bzr r13341.6.10) --- src/ui/widget/color-slider.cpp | 12 +++++++++++- src/ui/widget/color-slider.h | 2 ++ 2 files changed, 13 insertions(+), 1 deletion(-) (limited to 'src/ui') diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index 450dcd6f6..ff69e6ed5 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -160,16 +160,26 @@ void ColorSlider::get_preferred_width_vfunc(int& minimum_width, int& natural_wid Gtk::Border padding = style_context->get_padding(get_state_flags()); int width = SLIDER_WIDTH + padding.get_left() + padding.get_right(); minimum_width = natural_width = width; +} +void ColorSlider::get_preferred_width_for_height_vfunc(int /*height*/, int& minimum_width, int& natural_width) const +{ + get_preferred_width(minimum_width, natural_width); } void ColorSlider::get_preferred_height_vfunc(int& minimum_height, int& natural_height) const { Glib::RefPtrstyle_context = get_style_context(); Gtk::Border padding = style_context->get_padding(get_state_flags()); - int height = SLIDER_WIDTH + padding.get_top() + padding.get_bottom(); + int height = SLIDER_HEIGHT + padding.get_top() + padding.get_bottom(); minimum_height = natural_height = height; } + +void ColorSlider::get_preferred_height_for_width_vfunc(int /*width*/, int& minimum_height, int& natural_height) const +{ + get_preferred_height(minimum_height, natural_height); +} + #else void ColorSlider::on_size_request(Gtk::Requisition* requisition) { diff --git a/src/ui/widget/color-slider.h b/src/ui/widget/color-slider.h index c6d843fe5..eb4cd99c3 100644 --- a/src/ui/widget/color-slider.h +++ b/src/ui/widget/color-slider.h @@ -67,7 +67,9 @@ protected: #if GTK_CHECK_VERSION(3,0,0) void get_preferred_width_vfunc(int& minimum_width, int& natural_width) const; + void get_preferred_width_for_height_vfunc(int height, int& minimum_width, int& natural_width) const; void get_preferred_height_vfunc(int& minimum_height, int& natural_height) const; + void get_preferred_height_for_width_vfunc(int width, int& minimum_height, int& natural_height) const; #else void on_size_request(Gtk::Requisition* requisition); bool on_expose_event(GdkEventExpose* event); -- cgit v1.2.3 From 8a251752c5dc2dc686b815f527f4ce20c477b03c Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 24 May 2014 22:09:33 +0200 Subject: SPColorSlider c++-sification: remove gobject based code (bzr r13341.6.14) --- src/ui/widget/color-slider.cpp | 665 ----------------------------------------- src/ui/widget/color-slider.h | 53 ---- 2 files changed, 718 deletions(-) (limited to 'src/ui') diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index ff69e6ed5..d501e3724 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -538,671 +538,6 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { }//namespace UI }//namespace Inkscape - - - - - - - - - - - - - - - - - - - - - - - -enum { - GRABBED, - DRAGGED, - RELEASED, - CHANGED, - LAST_SIGNAL -}; - -static void sp_color_slider_class_init (SPColorSliderClass *klass); -static void sp_color_slider_init (SPColorSlider *slider); -static void sp_color_slider_dispose(GObject *object); - -static void sp_color_slider_realize (GtkWidget *widget); -static void sp_color_slider_size_request (GtkWidget *widget, GtkRequisition *requisition); - -#if GTK_CHECK_VERSION(3,0,0) -static void sp_color_slider_get_preferred_width(GtkWidget *widget, - gint *minimal_width, - gint *natural_width); - -static void sp_color_slider_get_preferred_height(GtkWidget *widget, - gint *minimal_height, - gint *natural_height); -#else -static gboolean sp_color_slider_expose(GtkWidget *widget, GdkEventExpose *event); -#endif - -static void sp_color_slider_size_allocate (GtkWidget *widget, GtkAllocation *allocation); - -static gboolean sp_color_slider_draw(GtkWidget *widget, cairo_t *cr); - -static gint sp_color_slider_button_press (GtkWidget *widget, GdkEventButton *event); -static gint sp_color_slider_button_release (GtkWidget *widget, GdkEventButton *event); -static gint sp_color_slider_motion_notify (GtkWidget *widget, GdkEventMotion *event); - -static void sp_color_slider_adjustment_changed (GtkAdjustment *adjustment, SPColorSlider *slider); -static void sp_color_slider_adjustment_value_changed (GtkAdjustment *adjustment, SPColorSlider *slider); - -static GtkWidgetClass *parent_class; -static guint slider_signals[LAST_SIGNAL] = {0}; - -GType -sp_color_slider_get_type (void) -{ - static GType type = 0; - if (!type) { - GTypeInfo info = { - sizeof (SPColorSliderClass), - NULL, NULL, - (GClassInitFunc) sp_color_slider_class_init, - NULL, NULL, - sizeof (SPColorSlider), - 0, - (GInstanceInitFunc) sp_color_slider_init, - NULL - }; - type = g_type_register_static (GTK_TYPE_WIDGET, "SPColorSlider", &info, (GTypeFlags)0); - } - return type; -} - -static void sp_color_slider_class_init(SPColorSliderClass *klass) -{ - GObjectClass *object_class = G_OBJECT_CLASS(klass); - GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass); - - parent_class = GTK_WIDGET_CLASS(g_type_class_peek_parent(klass)); - - slider_signals[GRABBED] = g_signal_new ("grabbed", - G_TYPE_FROM_CLASS(object_class), - (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE), - G_STRUCT_OFFSET (SPColorSliderClass, grabbed), - NULL, NULL, - g_cclosure_marshal_VOID__VOID, - G_TYPE_NONE, 0); - slider_signals[DRAGGED] = g_signal_new ("dragged", - G_TYPE_FROM_CLASS(object_class), - (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE), - G_STRUCT_OFFSET (SPColorSliderClass, dragged), - NULL, NULL, - g_cclosure_marshal_VOID__VOID, - G_TYPE_NONE, 0); - slider_signals[RELEASED] = g_signal_new ("released", - G_TYPE_FROM_CLASS(object_class), - (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE), - G_STRUCT_OFFSET (SPColorSliderClass, released), - NULL, NULL, - g_cclosure_marshal_VOID__VOID, - G_TYPE_NONE, 0); - slider_signals[CHANGED] = g_signal_new ("changed", - G_TYPE_FROM_CLASS(object_class), - (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE), - G_STRUCT_OFFSET (SPColorSliderClass, changed), - NULL, NULL, - g_cclosure_marshal_VOID__VOID, - G_TYPE_NONE, 0); - - object_class->dispose = sp_color_slider_dispose; - - widget_class->realize = sp_color_slider_realize; -#if GTK_CHECK_VERSION(3,0,0) - widget_class->get_preferred_width = sp_color_slider_get_preferred_width; - widget_class->get_preferred_height = sp_color_slider_get_preferred_height; - widget_class->draw = sp_color_slider_draw; -#else - widget_class->size_request = sp_color_slider_size_request; - widget_class->expose_event = sp_color_slider_expose; -#endif - widget_class->size_allocate = sp_color_slider_size_allocate; -/* widget_class->draw_focus = sp_color_slider_draw_focus; */ -/* widget_class->draw_default = sp_color_slider_draw_default; */ - - widget_class->button_press_event = sp_color_slider_button_press; - widget_class->button_release_event = sp_color_slider_button_release; - widget_class->motion_notify_event = sp_color_slider_motion_notify; -} - -static void -sp_color_slider_init (SPColorSlider *slider) -{ - /* We are widget with window */ - gtk_widget_set_has_window (GTK_WIDGET(slider), TRUE); - - slider->dragging = FALSE; - - slider->adjustment = NULL; - slider->value = 0.0; - - slider->c0[0] = 0x00; - slider->c0[1] = 0x00; - slider->c0[2] = 0x00; - slider->c0[3] = 0xff; - - slider->cm[0] = 0xff; - slider->cm[1] = 0x00; - slider->cm[2] = 0x00; - slider->cm[3] = 0xff; - - slider->c1[0] = 0xff; - slider->c1[1] = 0xff; - slider->c1[2] = 0xff; - slider->c1[3] = 0xff; - - slider->b0 = 0x5f; - slider->b1 = 0xa0; - slider->bmask = 0x08; - - slider->map = NULL; -} - -static void sp_color_slider_dispose(GObject *object) -{ - SPColorSlider *slider = SP_COLOR_SLIDER (object); - - if (slider->adjustment) { - g_signal_handlers_disconnect_matched (G_OBJECT (slider->adjustment), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, slider); - g_object_unref (slider->adjustment); - slider->adjustment = NULL; - } - - if ((G_OBJECT_CLASS(parent_class))->dispose) - (* (G_OBJECT_CLASS(parent_class))->dispose) (object); -} - -static void -sp_color_slider_realize (GtkWidget *widget) -{ - GdkWindowAttr attributes; - gint attributes_mask; - GtkAllocation allocation; - - gtk_widget_get_allocation(widget, &allocation); - gtk_widget_set_realized (widget, TRUE); - - attributes.window_type = GDK_WINDOW_CHILD; - attributes.x = allocation.x; - attributes.y = allocation.y; - attributes.width = allocation.width; - attributes.height = allocation.height; - attributes.wclass = GDK_INPUT_OUTPUT; - attributes.visual = gdk_screen_get_system_visual(gdk_screen_get_default()); - -#if !GTK_CHECK_VERSION(3,0,0) - attributes.colormap = gdk_screen_get_system_colormap(gdk_screen_get_default()); -#endif - - attributes.event_mask = gtk_widget_get_events (widget); - attributes.event_mask |= (GDK_EXPOSURE_MASK | - GDK_BUTTON_PRESS_MASK | - GDK_BUTTON_RELEASE_MASK | - GDK_POINTER_MOTION_MASK | - GDK_ENTER_NOTIFY_MASK | - GDK_LEAVE_NOTIFY_MASK); -#if GTK_CHECK_VERSION(3,0,0) - attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL; -#else - attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP; -#endif - - gtk_widget_set_window(widget, - gdk_window_new(gtk_widget_get_parent_window(widget), - &attributes, attributes_mask)); - - gdk_window_set_user_data(gtk_widget_get_window(widget), widget); - -#if !GTK_CHECK_VERSION(3,0,0) - // This doesn't do anything in GTK+ 3 - gtk_widget_set_style(widget, - gtk_style_attach(gtk_widget_get_style(widget), - gtk_widget_get_window(widget))); -#endif -} - -static void -sp_color_slider_size_request (GtkWidget *widget, GtkRequisition *requisition) -{ - GtkStyle *style = gtk_widget_get_style(widget); - requisition->width = SLIDER_WIDTH + style->xthickness * 2; - requisition->height = SLIDER_HEIGHT + style->ythickness * 2; -} - -#if GTK_CHECK_VERSION(3,0,0) -static void sp_color_slider_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width) -{ - GtkRequisition requisition; - sp_color_slider_size_request(widget, &requisition); - *minimal_width = *natural_width = requisition.width; -} - -static void sp_color_slider_get_preferred_height(GtkWidget *widget, gint *minimal_height, gint *natural_height) -{ - GtkRequisition requisition; - sp_color_slider_size_request(widget, &requisition); - *minimal_height = *natural_height = requisition.height; -} -#endif - -static void -sp_color_slider_size_allocate (GtkWidget *widget, GtkAllocation *allocation) -{ - gtk_widget_set_allocation(widget, allocation); - - if (gtk_widget_get_realized (widget)) { - /* Resize GdkWindow */ - gdk_window_move_resize(gtk_widget_get_window(widget), - allocation->x, allocation->y, - allocation->width, allocation->height); - } -} - -#if !GTK_CHECK_VERSION(3,0,0) -static gboolean sp_color_slider_expose(GtkWidget *widget, GdkEventExpose * /*event*/) -{ - gboolean result = FALSE; - - if (gtk_widget_is_drawable(widget)) { - GdkWindow *window = gtk_widget_get_window(widget); - cairo_t *cr = gdk_cairo_create(window); - result = sp_color_slider_draw(widget, cr); - cairo_destroy(cr); - } - - return result; -} -#endif - -static gint -sp_color_slider_button_press (GtkWidget *widget, GdkEventButton *event) -{ - SPColorSlider *slider; - - slider = SP_COLOR_SLIDER (widget); - - if (event->button == 1) { - GtkAllocation allocation; - gtk_widget_get_allocation(widget, &allocation); - gint cx, cw; - cx = gtk_widget_get_style(widget)->xthickness; - cw = allocation.width - 2 * cx; - g_signal_emit (G_OBJECT (slider), slider_signals[GRABBED], 0); - slider->dragging = TRUE; - slider->oldvalue = slider->value; - ColorScales::setScaled( slider->adjustment, CLAMP ((gfloat) (event->x - cx) / cw, 0.0, 1.0) ); - g_signal_emit (G_OBJECT (slider), slider_signals[DRAGGED], 0); - -#if GTK_CHECK_VERSION(3,0,0) - gdk_device_grab(gdk_event_get_device(reinterpret_cast(event)), - gtk_widget_get_window(widget), - GDK_OWNERSHIP_NONE, - FALSE, - static_cast(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK), - NULL, - event->time); -#else - gdk_pointer_grab(gtk_widget_get_window(widget), FALSE, - static_cast(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK), - NULL, NULL, event->time); -#endif - } - - return FALSE; -} - -static gint -sp_color_slider_button_release (GtkWidget *widget, GdkEventButton *event) -{ - SPColorSlider *slider; - - slider = SP_COLOR_SLIDER (widget); - - if (event->button == 1) { - -#if GTK_CHECK_VERSION(3,0,0) - gdk_device_ungrab(gdk_event_get_device(reinterpret_cast(event)), - gdk_event_get_time(reinterpret_cast(event))); -#else - gdk_pointer_ungrab (event->time); -#endif - - slider->dragging = FALSE; - g_signal_emit (G_OBJECT (slider), slider_signals[RELEASED], 0); - if (slider->value != slider->oldvalue) g_signal_emit (G_OBJECT (slider), slider_signals[CHANGED], 0); - } - - return FALSE; -} - -static gint -sp_color_slider_motion_notify (GtkWidget *widget, GdkEventMotion *event) -{ - SPColorSlider *slider; - - slider = SP_COLOR_SLIDER (widget); - - if (slider->dragging) { - gint cx, cw; - GtkAllocation allocation; - gtk_widget_get_allocation(widget, &allocation); - cx = gtk_widget_get_style(widget)->xthickness; - cw = allocation.width - 2 * cx; - ColorScales::setScaled( slider->adjustment, CLAMP ((gfloat) (event->x - cx) / cw, 0.0, 1.0) ); - g_signal_emit (G_OBJECT (slider), slider_signals[DRAGGED], 0); - } - - return FALSE; -} - -GtkWidget *sp_color_slider_new(GtkAdjustment *adjustment) -{ - SPColorSlider *slider = SP_COLOR_SLIDER(g_object_new(SP_TYPE_COLOR_SLIDER, NULL)); - - sp_color_slider_set_adjustment (slider, adjustment); - - return GTK_WIDGET (slider); -} - -void sp_color_slider_set_adjustment(SPColorSlider *slider, GtkAdjustment *adjustment) -{ - g_return_if_fail (slider != NULL); - g_return_if_fail (SP_IS_COLOR_SLIDER (slider)); - - if (!adjustment) { - adjustment = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 1.0, 0.01, 0.0, 0.0)); - } else { - gtk_adjustment_set_page_increment(adjustment, 0.0); - gtk_adjustment_set_page_size(adjustment, 0.0); - } - - if (slider->adjustment != adjustment) { - if (slider->adjustment) { - g_signal_handlers_disconnect_matched (G_OBJECT (slider->adjustment), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, slider); - g_object_unref (slider->adjustment); - } - - slider->adjustment = adjustment; - g_object_ref (adjustment); - g_object_ref_sink (adjustment); - - g_signal_connect (G_OBJECT (adjustment), "changed", - G_CALLBACK (sp_color_slider_adjustment_changed), slider); - g_signal_connect (G_OBJECT (adjustment), "value_changed", - G_CALLBACK (sp_color_slider_adjustment_value_changed), slider); - - slider->value = ColorScales::getScaled( adjustment ); - - sp_color_slider_adjustment_changed (adjustment, slider); - } -} - -void -sp_color_slider_set_colors (SPColorSlider *slider, guint32 start, guint32 mid, guint32 end) -{ - g_return_if_fail (slider != NULL); - g_return_if_fail (SP_IS_COLOR_SLIDER (slider)); - - // Remove any map, if set - slider->map = 0; - - slider->c0[0] = start >> 24; - slider->c0[1] = (start >> 16) & 0xff; - slider->c0[2] = (start >> 8) & 0xff; - slider->c0[3] = start & 0xff; - - slider->cm[0] = mid >> 24; - slider->cm[1] = (mid >> 16) & 0xff; - slider->cm[2] = (mid >> 8) & 0xff; - slider->cm[3] = mid & 0xff; - - slider->c1[0] = end >> 24; - slider->c1[1] = (end >> 16) & 0xff; - slider->c1[2] = (end >> 8) & 0xff; - slider->c1[3] = end & 0xff; - - gtk_widget_queue_draw (GTK_WIDGET (slider)); -} - -void -sp_color_slider_set_map (SPColorSlider *slider, const guchar *map) -{ - g_return_if_fail (slider != NULL); - g_return_if_fail (SP_IS_COLOR_SLIDER (slider)); - - slider->map = const_cast(map); - - gtk_widget_queue_draw (GTK_WIDGET (slider)); -} - -void -sp_color_slider_set_background (SPColorSlider *slider, guint dark, guint light, guint size) -{ - g_return_if_fail (slider != NULL); - g_return_if_fail (SP_IS_COLOR_SLIDER (slider)); - - slider->b0 = dark; - slider->b1 = light; - slider->bmask = size; - - gtk_widget_queue_draw (GTK_WIDGET (slider)); -} - -static void -sp_color_slider_adjustment_changed (GtkAdjustment */*adjustment*/, SPColorSlider *slider) -{ - gtk_widget_queue_draw (GTK_WIDGET (slider)); -} - -static void -sp_color_slider_adjustment_value_changed (GtkAdjustment *adjustment, SPColorSlider *slider) -{ - GtkWidget *widget; - - widget = GTK_WIDGET (slider); - - if (slider->value != ColorScales::getScaled( adjustment )) { - gint cx, cy, cw, ch; - GtkStyle *style = gtk_widget_get_style(widget); - GtkAllocation allocation; - gtk_widget_get_allocation(widget, &allocation); - cx = style->xthickness; - cy = style->ythickness; - cw = allocation.width - 2 * cx; - ch = allocation.height - 2 * cy; - if ((gint) (ColorScales::getScaled( adjustment ) * cw) != (gint) (slider->value * cw)) { - gint ax, ay; - gfloat value; - value = slider->value; - slider->value = ColorScales::getScaled( adjustment ); - ax = (int)(cx + value * cw - ARROW_SIZE / 2 - 2); - ay = cy; - gtk_widget_queue_draw_area (widget, ax, ay, ARROW_SIZE + 4, ch); - ax = (int)(cx + slider->value * cw - ARROW_SIZE / 2 - 2); - ay = cy; - gtk_widget_queue_draw_area (widget, ax, ay, ARROW_SIZE + 4, ch); - } else { - slider->value = ColorScales::getScaled( adjustment ); - } - } -} - -static gboolean sp_color_slider_draw(GtkWidget *widget, cairo_t *cr) -{ - SPColorSlider *slider = SP_COLOR_SLIDER(widget); - - gboolean colorsOnTop = Inkscape::Preferences::get()->getBool("/options/workarounds/colorsontop", false); - - GtkAllocation allocation; - gtk_widget_get_allocation(widget, &allocation); - -#if GTK_CHECK_VERSION(3,0,0) - GtkStyleContext *context = gtk_widget_get_style_context(widget); -#else - GdkWindow *window = gtk_widget_get_window(widget); - GtkStyle *style = gtk_widget_get_style(widget); -#endif - - // Draw shadow - if (colorsOnTop) { -#if GTK_CHECK_VERSION(3,0,0) - gtk_render_frame(context, - cr, - 0, 0, - allocation.width, allocation.height); -#else - gtk_paint_shadow( style, window, - gtk_widget_get_state(widget), GTK_SHADOW_IN, - NULL, widget, "colorslider", - 0, 0, - allocation.width, allocation.height); -#endif - } - - /* Paintable part of color gradient area */ - GdkRectangle carea; - -#if GTK_CHECK_VERSION(3,0,0) - GtkBorder padding; - - gtk_style_context_get_padding(context, - gtk_widget_get_state_flags(widget), - &padding); - - carea.x = padding.left; - carea.y = padding.top; -#else - carea.x = style->xthickness; - carea.y = style->ythickness; -#endif - - carea.width = allocation.width - 2 * carea.x; - carea.height = allocation.height - 2 * carea.y; - - if (slider->map) { - /* Render map pixelstore */ - gint d = (1024 << 16) / carea.width; - gint s = 0; - - const guchar *b = sp_color_slider_render_map(0, 0, carea.width, carea.height, - slider->map, s, d, - slider->b0, slider->b1, slider->bmask); - - if (b != NULL && carea.width > 0) { - GdkPixbuf *pb = gdk_pixbuf_new_from_data (b, GDK_COLORSPACE_RGB, - 0, 8, carea.width, carea.height, carea.width * 3, NULL, NULL); - - gdk_cairo_set_source_pixbuf(cr, pb, carea.x, carea.y); - cairo_paint(cr); - g_object_unref(pb); - } - - } else { - gint c[4], dc[4]; - - /* Render gradient */ - - // part 1: from c0 to cm - if (carea.width > 0) { - for (gint i = 0; i < 4; i++) { - c[i] = slider->c0[i] << 16; - dc[i] = ((slider->cm[i] << 16) - c[i]) / (carea.width/2); - } - guint wi = carea.width/2; - const guchar *b = sp_color_slider_render_gradient(0, 0, wi, carea.height, - c, dc, slider->b0, slider->b1, slider->bmask); - - /* Draw pixelstore 1 */ - if (b != NULL && wi > 0) { - GdkPixbuf *pb = gdk_pixbuf_new_from_data (b, GDK_COLORSPACE_RGB, - 0, 8, wi, carea.height, wi * 3, NULL, NULL); - - gdk_cairo_set_source_pixbuf(cr, pb, carea.x, carea.y); - cairo_paint(cr); - g_object_unref(pb); - } - } - - // part 2: from cm to c1 - if (carea.width > 0) { - for (gint i = 0; i < 4; i++) { - c[i] = slider->cm[i] << 16; - dc[i] = ((slider->c1[i] << 16) - c[i]) / (carea.width/2); - } - guint wi = carea.width/2; - const guchar *b = sp_color_slider_render_gradient(carea.width/2, 0, wi, carea.height, - c, dc, - slider->b0, slider->b1, slider->bmask); - - /* Draw pixelstore 2 */ - if (b != NULL && wi > 0) { - GdkPixbuf *pb = gdk_pixbuf_new_from_data (b, GDK_COLORSPACE_RGB, - 0, 8, wi, carea.height, wi * 3, NULL, NULL); - - gdk_cairo_set_source_pixbuf(cr, pb, carea.width/2 + carea.x, carea.y); - cairo_paint(cr); - - g_object_unref(pb); - } - } - } - - /* Draw shadow */ - if (!colorsOnTop) { -#if GTK_CHECK_VERSION(3,0,0) - gtk_render_frame(context, - cr, - 0, 0, - allocation.width, allocation.height); -#else - gtk_paint_shadow( style, window, - gtk_widget_get_state(widget), GTK_SHADOW_IN, - NULL, widget, "colorslider", - 0, 0, - allocation.width, allocation.height); -#endif - } - - /* Draw arrow */ - gint x = (int)(slider->value * (carea.width - 1) - ARROW_SIZE / 2 + carea.x); - gint y1 = carea.y; - gint y2 = carea.y + carea.height - 1; - cairo_set_line_width(cr, 1.0); - - // Define top arrow - cairo_move_to(cr, x - 0.5, y1 + 0.5); - cairo_line_to(cr, x + ARROW_SIZE - 0.5, y1 + 0.5); - cairo_line_to(cr, x + (ARROW_SIZE-1)/2.0, y1 + ARROW_SIZE/2.0 + 0.5); - cairo_line_to(cr, x - 0.5, y1 + 0.5); - - // Define bottom arrow - cairo_move_to(cr, x - 0.5, y2 + 0.5); - cairo_line_to(cr, x + ARROW_SIZE - 0.5, y2 + 0.5); - cairo_line_to(cr, x + (ARROW_SIZE-1)/2.0, y2 - ARROW_SIZE/2.0 + 0.5); - cairo_line_to(cr, x - 0.5, y2 + 0.5); - - // Render both arrows - cairo_set_source_rgb(cr, 1.0, 1.0, 1.0); - cairo_stroke_preserve(cr); - cairo_set_source_rgb(cr, 0.0, 0.0, 0.0); - cairo_fill(cr); - - return FALSE; -} - /* Colors are << 16 */ static const guchar * diff --git a/src/ui/widget/color-slider.h b/src/ui/widget/color-slider.h index eb4cd99c3..bbc14afc9 100644 --- a/src/ui/widget/color-slider.h +++ b/src/ui/widget/color-slider.h @@ -105,57 +105,4 @@ private: }//namespace UI }//namespace Inkscape - -#include - -#include - - - -struct SPColorSlider; -struct SPColorSliderClass; - -#define SP_TYPE_COLOR_SLIDER (sp_color_slider_get_type ()) -#define SP_COLOR_SLIDER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SP_TYPE_COLOR_SLIDER, SPColorSlider)) -#define SP_COLOR_SLIDER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), SP_TYPE_COLOR_SLIDER, SPColorSliderClass)) -#define SP_IS_COLOR_SLIDER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), SP_TYPE_COLOR_SLIDER)) -#define SP_IS_COLOR_SLIDER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SP_TYPE_COLOR_SLIDER)) - -struct SPColorSlider { - GtkWidget widget; - - guint dragging : 1; - - GtkAdjustment *adjustment; - - gfloat value; - gfloat oldvalue; - guchar c0[4], cm[4], c1[4]; - guchar b0, b1; - guchar bmask; - - gint mapsize; - guchar *map; -}; - -struct SPColorSliderClass { - GtkWidgetClass parent_class; - - void (* grabbed) (SPColorSlider *slider); - void (* dragged) (SPColorSlider *slider); - void (* released) (SPColorSlider *slider); - void (* changed) (SPColorSlider *slider); -}; - -GType sp_color_slider_get_type (void); - -GtkWidget *sp_color_slider_new (GtkAdjustment *adjustment); - -void sp_color_slider_set_adjustment (SPColorSlider *slider, GtkAdjustment *adjustment); -void sp_color_slider_set_colors (SPColorSlider *slider, guint32 start, guint32 mid, guint32 end); -void sp_color_slider_set_map (SPColorSlider *slider, const guchar *map); -void sp_color_slider_set_background (SPColorSlider *slider, guint dark, guint light, guint size); - - - #endif -- cgit v1.2.3 From 0744a31c573dc80d6e8166319e07375e97884f15 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sun, 25 May 2014 00:02:36 +0200 Subject: SPColorSlider c++-sification: remove unnecessary reference to Gtk::Adjustment (bzr r13341.6.15) --- src/ui/widget/color-slider.cpp | 3 --- 1 file changed, 3 deletions(-) (limited to 'src/ui') diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index d501e3724..fc64fad6f 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -297,9 +297,6 @@ void ColorSlider::set_adjustment(Gtk::Adjustment *adjustment) { } _adjustment = adjustment; -#if !GTK_CHECK_VERSION(3,0,0) - _adjustment->reference(); -#endif _adjustment_changed_connection = _adjustment->signal_changed().connect( sigc::mem_fun(this, &ColorSlider::_on_adjustment_changed)); _adjustment_value_changed_connection = _adjustment->signal_value_changed().connect( -- cgit v1.2.3 From 1cf0f193c7848428a1cce2dfa40716608163fa33 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Thu, 29 May 2014 13:59:08 +0200 Subject: SPColorSelector c++-sification: added SelectedColor class (bzr r13341.6.25) --- src/ui/Makefile_insert | 2 ++ 1 file changed, 2 insertions(+) (limited to 'src/ui') diff --git a/src/ui/Makefile_insert b/src/ui/Makefile_insert index 4081f86f8..75801886e 100644 --- a/src/ui/Makefile_insert +++ b/src/ui/Makefile_insert @@ -11,5 +11,7 @@ ink_common_sources += \ ui/previewfillable.h \ ui/previewholder.cpp \ ui/previewholder.h \ + ui/selected-color.h \ + ui/selected-color.cpp \ ui/uxmanager.cpp \ ui/uxmanager.h -- cgit v1.2.3 From 51eab9e9fdc5a520f91cb90ba101cedd62fd3eb4 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Thu, 29 May 2014 18:21:29 +0200 Subject: SPColorSelector c++-sification: added SelectedColor class (bzr r13341.6.26) --- src/ui/selected-color.cpp | 92 +++++++++++++++++++++++++++++++++++++++++++++++ src/ui/selected-color.h | 55 ++++++++++++++++++++++++++++ 2 files changed, 147 insertions(+) create mode 100644 src/ui/selected-color.cpp create mode 100644 src/ui/selected-color.h (limited to 'src/ui') diff --git a/src/ui/selected-color.cpp b/src/ui/selected-color.cpp new file mode 100644 index 000000000..246c51ebd --- /dev/null +++ b/src/ui/selected-color.cpp @@ -0,0 +1,92 @@ +/** @file + * Color selected in color selector widget. + * This file was created during the refactoring of SPColorSelector + *//* + * Authors: + * bulia byak + * Jon A. Cruz + * Tomasz Boczkowski + * + * Copyright (C) 2014 Authors + * Released under GNU GPL, read the file 'COPYING' for more information + */ +#include +#include + +#include "selected-color.h" + +double SelectedColor::_epsilon = 1e-4; + +SelectedColor::SelectedColor() + : _color(0) + , _alpha(1.0) + , _virgin(true) +{ + +} + +SelectedColor::~SelectedColor() { + +} + +void SelectedColor::set_color(const SPColor& color) +{ + set_color_alpha( color, _alpha ); +} + +SPColor SelectedColor::get_color() const +{ + return _color; +} + +void SelectedColor::set_alpha(gfloat alpha) +{ + g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) ); + set_color_alpha( _color, alpha ); +} + +gfloat SelectedColor::get_alpha() const +{ + return _alpha; +} + +void SelectedColor::set_color_alpha(const SPColor& color, gfloat alpha, bool emit) +{ +#ifdef DUMP_CHANGE_INFO + g_message("SelectedColor::setColorAlpha( this=%p, %f, %f, %f, %s, %f, %s) in %s", this, color.v.c[0], color.v.c[1], color.v.c[2], (color.icc?color.icc->colorProfile.c_str():""), alpha, (emit?"YES":"no"), FOO_NAME(_csel)); +#endif + g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) ); + +#ifdef DUMP_CHANGE_INFO + g_message("---- SelectedColor::setColorAlpha virgin:%s !close:%s alpha is:%s in %s", + (_virgin?"YES":"no"), + (!color.isClose( _color, _epsilon )?"YES":"no"), + ((fabs((_alpha) - (alpha)) >= _epsilon )?"YES":"no"), + FOO_NAME(_csel) + ); +#endif + + if ( _virgin || !color.isClose( _color, _epsilon ) || + (fabs((_alpha) - (alpha)) >= _epsilon )) { + + _virgin = false; + + _color = color; + _alpha = alpha; + + if (emit) { + signal_changed.emit(); + } +#ifdef DUMP_CHANGE_INFO + } else { + g_message("++++ SelectedColor::setColorAlpha color:%08x ==> _color:%08X isClose:%s in %s", color.toRGBA32(alpha), _color.toRGBA32(_alpha), + (color.isClose( _color, _epsilon )?"YES":"no"), FOO_NAME(_csel)); +#endif + } +} + +void SelectedColor::get_color_alpha(SPColor &color, gfloat &alpha) const { + color = _color; + alpha = _alpha; +} + diff --git a/src/ui/selected-color.h b/src/ui/selected-color.h new file mode 100644 index 000000000..f7f0d6ad0 --- /dev/null +++ b/src/ui/selected-color.h @@ -0,0 +1,55 @@ +/** @file + * Color selected in color selector widget. + * This file was created during the refactoring of SPColorSelector + *//* + * Authors: + * bulia byak + * Jon A. Cruz + * Tomasz Boczkowski + * + * Copyright (C) 2014 Authors + * Released under GNU GPL, read the file 'COPYING' for more information + */ +#ifndef SEEN_SELECTED_COLOR +#define SEEN_SELECTED_COLOR + +#include +#include "color.h" + +class SelectedColor +{ +public: + SelectedColor(); + virtual ~SelectedColor(); + + void set_color( const SPColor& color ); + SPColor get_color() const; + + void set_alpha( gfloat alpha ); + gfloat get_alpha() const; + + void set_color_alpha( const SPColor& color, gfloat alpha, bool emit = false ); + void get_color_alpha( SPColor &color, gfloat &alpha ) const; + + sigc::signal signal_changed; +private: + // By default, disallow copy constructor and assignment operator + SelectedColor( const SelectedColor& obj ); + SelectedColor& operator=( const SelectedColor& obj ); + + SPColor _color; + /** + * Color alpha value guaranteed to be in [0, 1]. + */ + gfloat _alpha; + + /** + * This flag is true if no color is set yet + */ + bool _virgin; + + static double _epsilon; +}; + +#endif + -- cgit v1.2.3 From e373a552e457bb9aec3a31cf7d3fd01ded3f330d Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Fri, 30 May 2014 13:28:00 +0200 Subject: SPColorSelector c++-sification: added ColorSelectorFactory (bzr r13341.6.27) --- src/ui/selected-color.cpp | 6 ++++++ src/ui/selected-color.h | 20 ++++++++++++++++++-- 2 files changed, 24 insertions(+), 2 deletions(-) (limited to 'src/ui') diff --git a/src/ui/selected-color.cpp b/src/ui/selected-color.cpp index 246c51ebd..927c421b8 100644 --- a/src/ui/selected-color.cpp +++ b/src/ui/selected-color.cpp @@ -15,6 +15,9 @@ #include "selected-color.h" +namespace Inkscape { +namespace UI { + double SelectedColor::_epsilon = 1e-4; SelectedColor::SelectedColor() @@ -90,3 +93,6 @@ void SelectedColor::get_color_alpha(SPColor &color, gfloat &alpha) const { alpha = _alpha; } +} +} + diff --git a/src/ui/selected-color.h b/src/ui/selected-color.h index f7f0d6ad0..db2f2f68c 100644 --- a/src/ui/selected-color.h +++ b/src/ui/selected-color.h @@ -14,10 +14,13 @@ #define SEEN_SELECTED_COLOR #include +#include #include "color.h" -class SelectedColor -{ +namespace Inkscape { +namespace UI { + +class SelectedColor { public: SelectedColor(); virtual ~SelectedColor(); @@ -51,5 +54,18 @@ private: static double _epsilon; }; + +class ColorSelectorFactory { +public: + virtual ~ColorSelectorFactory() {} + + virtual Gtk::Widget* createWidget(SelectedColor& color) const = 0; + virtual Glib::ustring modeName() const = 0; +}; + + +} +} + #endif -- cgit v1.2.3 From 17055d029cc8732d1b2636b9e98338c8e7056558 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Fri, 30 May 2014 15:55:34 +0200 Subject: SPColorNotebok c++-sification - available pages list (bzr r13341.6.28) --- src/ui/selected-color.cpp | 5 +++-- src/ui/selected-color.h | 8 ++++++++ 2 files changed, 11 insertions(+), 2 deletions(-) (limited to 'src/ui') diff --git a/src/ui/selected-color.cpp b/src/ui/selected-color.cpp index 927c421b8..f61c3b7f8 100644 --- a/src/ui/selected-color.cpp +++ b/src/ui/selected-color.cpp @@ -10,11 +10,12 @@ * Copyright (C) 2014 Authors * Released under GNU GPL, read the file 'COPYING' for more information */ -#include -#include #include "selected-color.h" +#include +#include + namespace Inkscape { namespace UI { diff --git a/src/ui/selected-color.h b/src/ui/selected-color.h index db2f2f68c..a56ee6afb 100644 --- a/src/ui/selected-color.h +++ b/src/ui/selected-color.h @@ -13,6 +13,14 @@ #ifndef SEEN_SELECTED_COLOR #define SEEN_SELECTED_COLOR +#ifdef HAVE_CONFIG_H +# include +#endif + +#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H +#include +#endif + #include #include #include "color.h" -- cgit v1.2.3 From 7a205911659013dea26f1554158cc050fdff20bc Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Fri, 30 May 2014 18:47:23 +0200 Subject: changed coding style of SelectedColor (bzr r13341.6.30) --- src/ui/selected-color.cpp | 32 +++++++++++++++++++++----------- src/ui/selected-color.h | 46 +++++++++++++++++++++++++++------------------- 2 files changed, 48 insertions(+), 30 deletions(-) (limited to 'src/ui') diff --git a/src/ui/selected-color.cpp b/src/ui/selected-color.cpp index f61c3b7f8..296b15796 100644 --- a/src/ui/selected-color.cpp +++ b/src/ui/selected-color.cpp @@ -19,7 +19,7 @@ namespace Inkscape { namespace UI { -double SelectedColor::_epsilon = 1e-4; +double const SelectedColor::_EPSILON = 1e-4; SelectedColor::SelectedColor() : _color(0) @@ -33,28 +33,28 @@ SelectedColor::~SelectedColor() { } -void SelectedColor::set_color(const SPColor& color) +void SelectedColor::setColor(SPColor const &color) { - set_color_alpha( color, _alpha ); + setColorAlpha( color, _alpha ); } -SPColor SelectedColor::get_color() const +SPColor SelectedColor::color() const { return _color; } -void SelectedColor::set_alpha(gfloat alpha) +void SelectedColor::setAlpha(gfloat alpha) { g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) ); - set_color_alpha( _color, alpha ); + setColorAlpha( _color, alpha ); } -gfloat SelectedColor::get_alpha() const +gfloat SelectedColor::alpha() const { return _alpha; } -void SelectedColor::set_color_alpha(const SPColor& color, gfloat alpha, bool emit) +void SelectedColor::setColorAlpha(SPColor const &color, gfloat alpha, bool emit) { #ifdef DUMP_CHANGE_INFO g_message("SelectedColor::setColorAlpha( this=%p, %f, %f, %f, %s, %f, %s) in %s", this, color.v.c[0], color.v.c[1], color.v.c[2], (color.icc?color.icc->colorProfile.c_str():""), alpha, (emit?"YES":"no"), FOO_NAME(_csel)); @@ -70,8 +70,8 @@ void SelectedColor::set_color_alpha(const SPColor& color, gfloat alpha, bool emi ); #endif - if ( _virgin || !color.isClose( _color, _epsilon ) || - (fabs((_alpha) - (alpha)) >= _epsilon )) { + if ( _virgin || !color.isClose( _color, _EPSILON ) || + (fabs((_alpha) - (alpha)) >= _EPSILON )) { _virgin = false; @@ -89,7 +89,7 @@ void SelectedColor::set_color_alpha(const SPColor& color, gfloat alpha, bool emi } } -void SelectedColor::get_color_alpha(SPColor &color, gfloat &alpha) const { +void SelectedColor::colorAlpha(SPColor &color, gfloat &alpha) const { color = _color; alpha = _alpha; } @@ -97,3 +97,13 @@ void SelectedColor::get_color_alpha(SPColor &color, gfloat &alpha) const { } } +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 : diff --git a/src/ui/selected-color.h b/src/ui/selected-color.h index a56ee6afb..08b84b66c 100644 --- a/src/ui/selected-color.h +++ b/src/ui/selected-color.h @@ -33,47 +33,55 @@ public: SelectedColor(); virtual ~SelectedColor(); - void set_color( const SPColor& color ); - SPColor get_color() const; + void setColor(SPColor const &color); + SPColor color() const; - void set_alpha( gfloat alpha ); - gfloat get_alpha() const; + void setAlpha(gfloat alpha); + gfloat alpha() const; - void set_color_alpha( const SPColor& color, gfloat alpha, bool emit = false ); - void get_color_alpha( SPColor &color, gfloat &alpha ) const; + void setColorAlpha(SPColor const &color, gfloat alpha, bool emit = false); + void colorAlpha(SPColor &color, gfloat &alpha) const; sigc::signal signal_changed; private: // By default, disallow copy constructor and assignment operator - SelectedColor( const SelectedColor& obj ); - SelectedColor& operator=( const SelectedColor& obj ); + SelectedColor(SelectedColor const &obj); + SelectedColor& operator=(SelectedColor const &obj); - SPColor _color; - /** - * Color alpha value guaranteed to be in [0, 1]. - */ - gfloat _alpha; + SPColor _color; + /** + * Color alpha value guaranteed to be in [0, 1]. + */ + gfloat _alpha; /** * This flag is true if no color is set yet */ bool _virgin; - static double _epsilon; + static double const _EPSILON; }; - class ColorSelectorFactory { public: - virtual ~ColorSelectorFactory() {} + virtual ~ColorSelectorFactory() { + } - virtual Gtk::Widget* createWidget(SelectedColor& color) const = 0; + virtual Gtk::Widget* createWidget(SelectedColor &color) const = 0; virtual Glib::ustring modeName() const = 0; }; - } } #endif - +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 : -- cgit v1.2.3 From b0e9181bacdad19055532a2620f5390815b91727 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Fri, 30 May 2014 22:53:40 +0200 Subject: added ColorEntry class, refactored SPColorNotebook to use it (bzr r13341.6.31) --- src/ui/widget/Makefile_insert | 2 + src/ui/widget/color-entry.cpp | 115 ++++++++++++++++++++++++++++++++++++++++++ src/ui/widget/color-entry.h | 59 ++++++++++++++++++++++ 3 files changed, 176 insertions(+) create mode 100644 src/ui/widget/color-entry.cpp create mode 100644 src/ui/widget/color-entry.h (limited to 'src/ui') diff --git a/src/ui/widget/Makefile_insert b/src/ui/widget/Makefile_insert index 6deaf6671..bad3342b1 100644 --- a/src/ui/widget/Makefile_insert +++ b/src/ui/widget/Makefile_insert @@ -6,6 +6,8 @@ ink_common_sources += \ ui/widget/attr-widget.h \ ui/widget/button.h \ ui/widget/button.cpp \ + ui/widget/color-entry.cpp \ + ui/widget/color-entry.h \ ui/widget/color-picker.cpp \ ui/widget/color-picker.h \ ui/widget/color-preview.cpp \ diff --git a/src/ui/widget/color-entry.cpp b/src/ui/widget/color-entry.cpp new file mode 100644 index 000000000..223c86fd3 --- /dev/null +++ b/src/ui/widget/color-entry.cpp @@ -0,0 +1,115 @@ +/** @file + * Entry widget for typing color value in css form + *//* + * Authors: + * Tomasz Boczkowski + * + * Copyright (C) 2014 Authors + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H +#include +#endif + +#include +#include + +#include "color-entry.h" + +namespace Inkscape { +namespace UI { +namespace Widget { + +ColorEntry::ColorEntry(SelectedColor &color) + : _color(color) + , _updating(false) +{ + _color_changed_connection = color.signal_changed.connect(sigc::mem_fun(this, &ColorEntry::_onColorChanged)); + _onColorChanged(); + + set_max_length(8); + set_width_chars(8); + set_tooltip_text(_("Hexadecimal RGBA value of the color")); +} + +ColorEntry::~ColorEntry() { + _color_changed_connection.disconnect(); +} + +void ColorEntry::on_changed() { + if (_updating) { + return; + } + + Glib::ustring text = get_text(); + bool changed = false; + + //Coerce the value format to eight hex digits + if (!text.empty() && text[0] == '#') { + changed = true; + text.erase(0, 1); + if (text.size() == 6) { + // it was a standard RGB hex + unsigned int alph = SP_COLOR_F_TO_U(_color.alpha()); + Glib::ustring tmp = Glib::ustring::format(std::hex, std::setw(2), std::setfill(L'0'), alph); + text += tmp; + } + } + + gchar* str = g_strdup(text.c_str()); + gchar* end = 0; + guint64 rgba = g_ascii_strtoull(str, &end, 16); + if (end != str) { + ptrdiff_t len = end - str; + if (len < 8) { + rgba = rgba << (4 * (8 - len)); + } + _updating = true; + if (changed) { + set_text(str); + } + SPColor color(rgba); + _color.setColorAlpha(color, SP_RGBA32_A_F(rgba), true); + _updating = false; + } + g_free(str); +} + + +void ColorEntry::_onColorChanged() { + if (_updating) { + return; + } + + SPColor color = _color.color(); + gdouble alpha = _color.alpha(); + + guint32 rgba = color.toRGBA32( alpha ); + Glib::ustring text = Glib::ustring::format(std::hex, std::setw(8), std::setfill(L'0'), rgba); + + Glib::ustring old_text = get_text(); + if (old_text != text) { + _updating = true; + set_text(text); + _updating = false; + } +} + +} +} +} +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 : diff --git a/src/ui/widget/color-entry.h b/src/ui/widget/color-entry.h new file mode 100644 index 000000000..742324337 --- /dev/null +++ b/src/ui/widget/color-entry.h @@ -0,0 +1,59 @@ +/** @file + * Entry widget for typing color value in css form + *//* + * Authors: + * Tomasz Boczkowski + * + * Copyright (C) 2014 Authors + * Released under GNU GPL, read the file 'COPYING' for more information + */ + +#ifndef SEEN_COLOR_ENTRY_H +#define SEEN_COLOR_ENTRY_H_ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H +#include +#endif + +#include +#include "ui/selected-color.h" + +namespace Inkscape { +namespace UI { +namespace Widget { + +class ColorEntry: public Gtk::Entry { +public: + ColorEntry(SelectedColor &color); + virtual ~ColorEntry(); + +protected: + void on_changed(); + +private: + void _onColorChanged(); + + SelectedColor &_color; + sigc::connection _color_changed_connection; + bool _updating; +}; + +} +} +} + +#endif +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 : -- cgit v1.2.3 From 746ade6352656a8db136039a1dd9cff9645ed9f4 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 31 May 2014 09:14:19 +0200 Subject: ColorSlider coding style (bzr r13341.6.32) --- src/ui/widget/color-slider.cpp | 38 +++++++++++++++++++------------------- src/ui/widget/color-slider.h | 32 +++++++++++++++++++++----------- 2 files changed, 40 insertions(+), 30 deletions(-) (limited to 'src/ui') diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index fc64fad6f..711942e28 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -76,7 +76,7 @@ ColorSlider::ColorSlider(Gtk::Adjustment* adjustment) _b1 = 0xa0; _bmask = 0x08; - set_adjustment(adjustment); + setAdjustment(adjustment); } ColorSlider::~ColorSlider() { @@ -95,7 +95,7 @@ ColorSlider::~ColorSlider() { void ColorSlider::on_realize() { set_realized(); - if(!_refGdkWindow) + if(!_gdk_window) { GdkWindowAttr attributes; gint attributes_mask; @@ -126,10 +126,10 @@ void ColorSlider::on_realize() { attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP; #endif - _refGdkWindow = Gdk::Window::create(get_parent_window(), &attributes, + _gdk_window = Gdk::Window::create(get_parent_window(), &attributes, attributes_mask); - set_window(_refGdkWindow); - _refGdkWindow->set_user_data(gobj()); + set_window(_gdk_window); + _gdk_window->set_user_data(gobj()); #if !GTK_CHECK_VERSION(3,0,0) style_attach(); @@ -138,7 +138,7 @@ void ColorSlider::on_realize() { } void ColorSlider::on_unrealize() { - _refGdkWindow.reset(); + _gdk_window.reset(); Gtk::Widget::on_unrealize(); } @@ -147,7 +147,7 @@ void ColorSlider::on_size_allocate(Gtk::Allocation& allocation) { set_allocation(allocation); if (get_realized()) { - _refGdkWindow->move_resize(allocation.get_x(), allocation.get_y(), + _gdk_window->move_resize(allocation.get_x(), allocation.get_y(), allocation.get_width(), allocation.get_height()); } } @@ -192,7 +192,7 @@ bool ColorSlider::on_expose_event(GdkEventExpose* event) { bool result = false; if (get_is_drawable()) { - Cairo::RefPtr cr = _refGdkWindow->create_cairo_context(); + Cairo::RefPtr cr = _gdk_window->create_cairo_context(); result = on_draw(cr); } return result; @@ -218,7 +218,7 @@ bool ColorSlider::on_button_press_event(GdkEventButton *event) { #if GTK_CHECK_VERSION(3,0,0) gdk_device_grab(gdk_event_get_device(reinterpret_cast(event)), - _refGdkWindow->gobj(), + _gdk_window->gobj(), GDK_OWNERSHIP_NONE, FALSE, static_cast(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK), @@ -272,9 +272,9 @@ bool ColorSlider::on_motion_notify_event(GdkEventMotion *event) { } #if GTK_CHECK_VERSION(3,0,0) -void ColorSlider::set_adjustment(Glib::RefPtr adjustment) { +void ColorSlider::setAdjustment(Glib::RefPtr adjustment) { #else -void ColorSlider::set_adjustment(Gtk::Adjustment *adjustment) { +void ColorSlider::setAdjustment(Gtk::Adjustment *adjustment) { #endif if (!adjustment) { #if GTK_CHECK_VERSION(3,0,0) @@ -298,21 +298,21 @@ void ColorSlider::set_adjustment(Gtk::Adjustment *adjustment) { _adjustment = adjustment; _adjustment_changed_connection = _adjustment->signal_changed().connect( - sigc::mem_fun(this, &ColorSlider::_on_adjustment_changed)); + sigc::mem_fun(this, &ColorSlider::_onAdjustmentChanged)); _adjustment_value_changed_connection = _adjustment->signal_value_changed().connect( - sigc::mem_fun(this, &ColorSlider::_on_adjustment_value_changed)); + sigc::mem_fun(this, &ColorSlider::_onAdjustmentValueChanged)); _value = ColorScales::getScaled(_adjustment->gobj()); - _on_adjustment_changed(); + _onAdjustmentChanged(); } } -void ColorSlider::_on_adjustment_changed() { +void ColorSlider::_onAdjustmentChanged() { queue_draw(); } -void ColorSlider::_on_adjustment_value_changed() { +void ColorSlider::_onAdjustmentValueChanged() { if (_value != ColorScales::getScaled( _adjustment->gobj() )) { gint cx, cy, cw, ch; #if GTK_CHECK_VERSION(3,0,0) @@ -346,7 +346,7 @@ void ColorSlider::_on_adjustment_value_changed() { } } -void ColorSlider::set_colors(guint32 start, guint32 mid, guint32 end) { +void ColorSlider::setColors(guint32 start, guint32 mid, guint32 end) { // Remove any map, if set _map = 0; @@ -368,13 +368,13 @@ void ColorSlider::set_colors(guint32 start, guint32 mid, guint32 end) { queue_draw(); } -void ColorSlider::set_map(const guchar *map) { +void ColorSlider::setMap(const guchar *map) { _map = const_cast(map); queue_draw(); } -void ColorSlider::set_background(guint dark, guint light, guint size) { +void ColorSlider::setBackground(guint dark, guint light, guint size) { _b0 = dark; _b1 = light; _bmask = size; diff --git a/src/ui/widget/color-slider.h b/src/ui/widget/color-slider.h index bbc14afc9..ef54c84e6 100644 --- a/src/ui/widget/color-slider.h +++ b/src/ui/widget/color-slider.h @@ -1,6 +1,3 @@ -#ifndef __SP_COLOR_SLIDER_H__ -#define __SP_COLOR_SLIDER_H__ - /* Author: * Lauris Kaplinski * @@ -9,6 +6,9 @@ * This code is in public domain */ +#ifndef SEEN_COLOR_SLIDER_H +#define SEEN_COLOR_SLIDER_H + #ifdef HAVE_CONFIG_H # include #endif @@ -40,16 +40,16 @@ public: ~ColorSlider(); #if GTK_CHECK_VERSION(3,0,0) - void set_adjustment(Glib::RefPtr adjustment); + void setAdjustment(Glib::RefPtr adjustment); #else - void set_adjustment(Gtk::Adjustment *adjustment); + void setAdjustment(Gtk::Adjustment *adjustment); #endif - void set_colors(guint32 start, guint32 mid, guint32 end); + void setColors(guint32 start, guint32 mid, guint32 end); - void set_map(const guchar* map); + void setMap(const guchar* map); - void set_background(guint dark, guint light, guint size); + void setBackground(guint dark, guint light, guint size); sigc::signal signal_grabbed; sigc::signal signal_dragged; @@ -76,8 +76,8 @@ protected: #endif private: - void _on_adjustment_changed(); - void _on_adjustment_value_changed(); + void _onAdjustmentChanged(); + void _onAdjustmentValueChanged(); bool _dragging; @@ -98,7 +98,7 @@ private: gint _mapsize; guchar *_map; - Glib::RefPtr _refGdkWindow; + Glib::RefPtr _gdk_window; }; }//namespace Widget @@ -106,3 +106,13 @@ private: }//namespace Inkscape #endif +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 : -- cgit v1.2.3 From e8f6b534a6db5c64b5d3a1fc9e4f1f691cb04ecc Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 31 May 2014 10:35:07 +0200 Subject: added dragged, released, grabbed signals to SelectedColor (bzr r13341.6.33) --- src/ui/selected-color.cpp | 22 +++++++++++++++++++++- src/ui/selected-color.h | 6 ++++++ src/ui/widget/color-entry.cpp | 2 ++ src/ui/widget/color-entry.h | 1 + 4 files changed, 30 insertions(+), 1 deletion(-) (limited to 'src/ui') diff --git a/src/ui/selected-color.cpp b/src/ui/selected-color.cpp index 296b15796..1be171a6b 100644 --- a/src/ui/selected-color.cpp +++ b/src/ui/selected-color.cpp @@ -25,6 +25,7 @@ SelectedColor::SelectedColor() : _color(0) , _alpha(1.0) , _virgin(true) + , _held(false) { } @@ -79,7 +80,11 @@ void SelectedColor::setColorAlpha(SPColor const &color, gfloat alpha, bool emit) _alpha = alpha; if (emit) { - signal_changed.emit(); + if (_held) { + signal_dragged.emit(); + } else { + signal_changed.emit(); + } } #ifdef DUMP_CHANGE_INFO } else { @@ -94,6 +99,21 @@ void SelectedColor::colorAlpha(SPColor &color, gfloat &alpha) const { alpha = _alpha; } +void SelectedColor::setHeld(bool held) { + bool grabbed = held && !_held; + bool released = !held && _held; + + _held = held; + + if (grabbed) { + signal_grabbed.emit(); + } + + if (released) { + signal_released.emit(); + } +} + } } diff --git a/src/ui/selected-color.h b/src/ui/selected-color.h index 08b84b66c..ec0cc55e3 100644 --- a/src/ui/selected-color.h +++ b/src/ui/selected-color.h @@ -42,6 +42,11 @@ public: void setColorAlpha(SPColor const &color, gfloat alpha, bool emit = false); void colorAlpha(SPColor &color, gfloat &alpha) const; + void setHeld(bool held); + + sigc::signal signal_grabbed; + sigc::signal signal_dragged; + sigc::signal signal_released; sigc::signal signal_changed; private: // By default, disallow copy constructor and assignment operator @@ -54,6 +59,7 @@ private: */ gfloat _alpha; + bool _held; /** * This flag is true if no color is set yet */ diff --git a/src/ui/widget/color-entry.cpp b/src/ui/widget/color-entry.cpp index 223c86fd3..56fd6080e 100644 --- a/src/ui/widget/color-entry.cpp +++ b/src/ui/widget/color-entry.cpp @@ -30,6 +30,7 @@ ColorEntry::ColorEntry(SelectedColor &color) , _updating(false) { _color_changed_connection = color.signal_changed.connect(sigc::mem_fun(this, &ColorEntry::_onColorChanged)); + _color_dragged_connection = color.signal_dragged.connect(sigc::mem_fun(this, &ColorEntry::_onColorChanged)); _onColorChanged(); set_max_length(8); @@ -39,6 +40,7 @@ ColorEntry::ColorEntry(SelectedColor &color) ColorEntry::~ColorEntry() { _color_changed_connection.disconnect(); + _color_dragged_connection.disconnect(); } void ColorEntry::on_changed() { diff --git a/src/ui/widget/color-entry.h b/src/ui/widget/color-entry.h index 742324337..148b5dfe9 100644 --- a/src/ui/widget/color-entry.h +++ b/src/ui/widget/color-entry.h @@ -39,6 +39,7 @@ private: SelectedColor &_color; sigc::connection _color_changed_connection; + sigc::connection _color_dragged_connection; bool _updating; }; -- cgit v1.2.3 From ba8232e27fbff22f2af10c39a66c2a084bacbfb4 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 31 May 2014 10:48:29 +0200 Subject: SPColorWheelSelector c++-sification: moved to ui/widgets (bzr r13341.6.34) --- src/ui/widget/Makefile_insert | 2 + src/ui/widget/color-wheel-selector.cpp | 366 +++++++++++++++++++++++++++++++++ src/ui/widget/color-wheel-selector.h | 111 ++++++++++ 3 files changed, 479 insertions(+) create mode 100644 src/ui/widget/color-wheel-selector.cpp create mode 100644 src/ui/widget/color-wheel-selector.h (limited to 'src/ui') diff --git a/src/ui/widget/Makefile_insert b/src/ui/widget/Makefile_insert index bad3342b1..97625f04e 100644 --- a/src/ui/widget/Makefile_insert +++ b/src/ui/widget/Makefile_insert @@ -8,6 +8,8 @@ ink_common_sources += \ ui/widget/button.cpp \ ui/widget/color-entry.cpp \ ui/widget/color-entry.h \ + ui/widget/color-wheel-selector.cpp \ + ui/widget/color-wheel-selector.h \ ui/widget/color-picker.cpp \ ui/widget/color-picker.h \ ui/widget/color-preview.cpp \ diff --git a/src/ui/widget/color-wheel-selector.cpp b/src/ui/widget/color-wheel-selector.cpp new file mode 100644 index 000000000..134232813 --- /dev/null +++ b/src/ui/widget/color-wheel-selector.cpp @@ -0,0 +1,366 @@ +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "color-wheel-selector.h" + +#include +#include +#include +#include +#include "dialogs/dialog-events.h" +#include "widgets/sp-color-scales.h" +#include "svg/svg-icc-color.h" +#include "ui/widget/color-slider.h" +#include "ui/widget/gimpcolorwheel.h" + +G_BEGIN_DECLS + +static void sp_color_wheel_selector_class_init (SPColorWheelSelectorClass *klass); +static void sp_color_wheel_selector_init (SPColorWheelSelector *cs); +static void sp_color_wheel_selector_dispose(GObject *object); + +static void sp_color_wheel_selector_show_all (GtkWidget *widget); +static void sp_color_wheel_selector_hide(GtkWidget *widget); + + +G_END_DECLS + +static SPColorSelectorClass *parent_class; + +#define XPAD 4 +#define YPAD 1 + + +const gchar* ColorWheelSelector::MODE_NAME = N_("Wheel"); + +GType +sp_color_wheel_selector_get_type (void) +{ + static GType type = 0; + if (!type) { + static const GTypeInfo info = { + sizeof (SPColorWheelSelectorClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) sp_color_wheel_selector_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof (SPColorWheelSelector), + 0, /* n_preallocs */ + (GInstanceInitFunc) sp_color_wheel_selector_init, + 0, /* value_table */ + }; + + type = g_type_register_static (SP_TYPE_COLOR_SELECTOR, + "SPColorWheelSelector", + &info, + static_cast< GTypeFlags > (0) ); + } + return type; +} + +static void sp_color_wheel_selector_class_init(SPColorWheelSelectorClass *klass) +{ + static const gchar* nameset[] = {N_("Wheel"), 0}; + GObjectClass *object_class = G_OBJECT_CLASS(klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass); + SPColorSelectorClass *selector_class = SP_COLOR_SELECTOR_CLASS (klass); + + parent_class = SP_COLOR_SELECTOR_CLASS (g_type_class_peek_parent (klass)); + + selector_class->name = nameset; + selector_class->submode_count = 1; + + object_class->dispose = sp_color_wheel_selector_dispose; + + widget_class->show_all = sp_color_wheel_selector_show_all; + widget_class->hide = sp_color_wheel_selector_hide; +} + +ColorWheelSelector::ColorWheelSelector( SPColorSelector* csel ) + : ColorSelector( csel ), + _updating( FALSE ), + _dragging( FALSE ), + _adj(0), + _wheel(0), + _slider(0), + _sbtn(0), + _label(0) +{ +} + +ColorWheelSelector::~ColorWheelSelector() +{ + _adj = 0; + _wheel = 0; + _sbtn = 0; + _label = 0; +} + +void sp_color_wheel_selector_init (SPColorWheelSelector *cs) +{ + SP_COLOR_SELECTOR(cs)->base = new ColorWheelSelector( SP_COLOR_SELECTOR(cs) ); + + if ( SP_COLOR_SELECTOR(cs)->base ) + { + SP_COLOR_SELECTOR(cs)->base->init(); + } +} + +void ColorWheelSelector::init() +{ + gint row = 0; + + _updating = FALSE; + _dragging = FALSE; + +#if GTK_CHECK_VERSION(3,0,0) + GtkWidget *t = gtk_grid_new(); +#else + GtkWidget *t = gtk_table_new (5, 3, FALSE); +#endif + + gtk_widget_show (t); + gtk_box_pack_start (GTK_BOX (_csel), t, TRUE, TRUE, 0); + + /* Create components */ + row = 0; + + _wheel = gimp_color_wheel_new(); + gtk_widget_show( _wheel ); + +#if GTK_CHECK_VERSION(3,0,0) + gtk_widget_set_halign(_wheel, GTK_ALIGN_FILL); + gtk_widget_set_valign(_wheel, GTK_ALIGN_FILL); + gtk_widget_set_hexpand(_wheel, TRUE); + gtk_widget_set_vexpand(_wheel, TRUE); + gtk_grid_attach(GTK_GRID(t), _wheel, 0, row, 3, 1); +#else + gtk_table_attach(GTK_TABLE(t), _wheel, 0, 3, row, row + 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0); +#endif + + row++; + + /* Label */ + _label = gtk_label_new_with_mnemonic (_("_A:")); + gtk_misc_set_alignment (GTK_MISC (_label), 1.0, 0.5); + gtk_widget_show (_label); + +#if GTK_CHECK_VERSION(3,0,0) + gtk_widget_set_margin_left(_label, XPAD); + gtk_widget_set_margin_right(_label, XPAD); + gtk_widget_set_margin_top(_label, YPAD); + gtk_widget_set_margin_bottom(_label, YPAD); + gtk_widget_set_halign(_label, GTK_ALIGN_FILL); + gtk_widget_set_valign(_label, GTK_ALIGN_FILL); + gtk_grid_attach(GTK_GRID(t), _label, 0, row, 1, 1); +#else + gtk_table_attach (GTK_TABLE (t), _label, 0, 1, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD); +#endif + + /* Adjustment */ + _adj = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 255.0, 1.0, 10.0, 10.0)); + + /* Slider */ + _slider = Gtk::manage(new Inkscape::UI::Widget::ColorSlider(Glib::wrap(_adj, true))); + _slider->set_tooltip_text(_("Alpha (opacity)")); + _slider->show(); + +#if GTK_CHECK_VERSION(3,0,0) + _slider->set_margin_left(XPAD); + _slider->set_margin_right(XPAD); + _slider->set_margin_top(YPAD); + _slider->set_margin_bottom(YPAD); + _slider->set_hexpand(true); + _slider->set_halign(Gtk::ALIGN_FILL); + _slider->set_valign(Gtk::ALIGN_FILL); + gtk_grid_attach(GTK_GRID(t), _slider->gobj(), 1, row, 1, 1); +#else + gtk_table_attach(GTK_TABLE (t), _slider->gobj(), 1, 2, row, row + 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, XPAD, YPAD); +#endif + + _slider->setColors(SP_RGBA32_F_COMPOSE (1.0, 1.0, 1.0, 0.0), + SP_RGBA32_F_COMPOSE (1.0, 1.0, 1.0, 0.5), + SP_RGBA32_F_COMPOSE (1.0, 1.0, 1.0, 1.0)); + + /* Spinbutton */ + _sbtn = gtk_spin_button_new (GTK_ADJUSTMENT (_adj), 1.0, 0); + gtk_widget_set_tooltip_text (_sbtn, _("Alpha (opacity)")); + sp_dialog_defocus_on_enter (_sbtn); + gtk_label_set_mnemonic_widget (GTK_LABEL(_label), _sbtn); + gtk_widget_show (_sbtn); + +#if GTK_CHECK_VERSION(3,0,0) + gtk_widget_set_margin_left(_sbtn, XPAD); + gtk_widget_set_margin_right(_sbtn, XPAD); + gtk_widget_set_margin_top(_sbtn, YPAD); + gtk_widget_set_margin_bottom(_sbtn, YPAD); + gtk_widget_set_halign(_sbtn, GTK_ALIGN_CENTER); + gtk_widget_set_valign(_sbtn, GTK_ALIGN_CENTER); + gtk_grid_attach(GTK_GRID(t), _sbtn, 2, row, 1, 1); +#else + gtk_table_attach (GTK_TABLE (t), _sbtn, 2, 3, row, row + 1, (GtkAttachOptions)0, (GtkAttachOptions)0, XPAD, YPAD); +#endif + + /* Signals */ + g_signal_connect (G_OBJECT (_adj), "value_changed", + G_CALLBACK (_adjustmentChanged), _csel); + + _slider->signal_grabbed.connect(sigc::mem_fun(*this, &ColorWheelSelector::_sliderGrabbed)); + _slider->signal_released.connect(sigc::mem_fun(*this, &ColorWheelSelector::_sliderReleased)); + _slider->signal_value_changed.connect(sigc::mem_fun(*this, &ColorWheelSelector::_sliderChanged)); + + g_signal_connect( G_OBJECT(_wheel), "changed", + G_CALLBACK (_wheelChanged), _csel ); +} + +static void sp_color_wheel_selector_dispose(GObject *object) +{ + if ((G_OBJECT_CLASS(parent_class))->dispose) + (* (G_OBJECT_CLASS(parent_class))->dispose) (object); +} + +static void +sp_color_wheel_selector_show_all (GtkWidget *widget) +{ + gtk_widget_show (widget); +} + +static void sp_color_wheel_selector_hide(GtkWidget *widget) +{ + gtk_widget_hide(widget); +} + +GtkWidget *sp_color_wheel_selector_new() +{ + SPColorWheelSelector *csel = SP_COLOR_WHEEL_SELECTOR(g_object_new (SP_TYPE_COLOR_WHEEL_SELECTOR, NULL)); + + return GTK_WIDGET (csel); +} + +/* Helpers for setting color value */ + +void ColorWheelSelector::_preserve_icc(SPColor *color) const { + color->icc = getColor().icc ? new SVGICCColor(*getColor().icc) : 0; +} + +void ColorWheelSelector::_colorChanged() +{ +#ifdef DUMP_CHANGE_INFO + g_message("ColorWheelSelector::_colorChanged( this=%p, %f, %f, %f, %f)", this, color.v.c[0], color.v.c[1], color.v.c[2], alpha ); +#endif + _updating = TRUE; + { + float hsv[3] = {0,0,0}; + sp_color_rgb_to_hsv_floatv(hsv, _color.v.c[0], _color.v.c[1], _color.v.c[2]); + gimp_color_wheel_set_color( GIMP_COLOR_WHEEL(_wheel), hsv[0], hsv[1], hsv[2] ); + } + + guint32 start = _color.toRGBA32( 0x00 ); + guint32 mid = _color.toRGBA32( 0x7f ); + guint32 end = _color.toRGBA32( 0xff ); + + _slider->setColors(start, mid, end); + + ColorScales::setScaled(_adj, _alpha); + + _updating = FALSE; +} + +void ColorWheelSelector::_adjustmentChanged( GtkAdjustment *adjustment, SPColorWheelSelector *cs ) +{ +// TODO check this. It looks questionable: + // if a value is entered between 0 and 1 exclusive, normalize it to (int) 0..255 or 0..100 + gdouble value = gtk_adjustment_get_value (adjustment); + gdouble upper = gtk_adjustment_get_upper (adjustment); + + if (value > 0.0 && value < 1.0) { + gtk_adjustment_set_value( adjustment, floor (value * upper + 0.5) ); + } + + ColorWheelSelector* wheelSelector = static_cast(SP_COLOR_SELECTOR(cs)->base); + if (wheelSelector->_updating) return; + + wheelSelector->_updating = TRUE; + + wheelSelector->_preserve_icc(&wheelSelector->_color); + wheelSelector->_updateInternals( wheelSelector->_color, ColorScales::getScaled( wheelSelector->_adj ), wheelSelector->_dragging ); + + wheelSelector->_updating = FALSE; +} + +void ColorWheelSelector::_sliderGrabbed() +{ + if (!_dragging) { + _dragging = TRUE; + _grabbed(); + + _preserve_icc(&_color); + _updateInternals( _color, ColorScales::getScaled( _adj ), _dragging ); + } +} + +void ColorWheelSelector::_sliderReleased() +{ + if (_dragging) { + _dragging = FALSE; + _released(); + + _preserve_icc(&_color); + _updateInternals( _color, ColorScales::getScaled( _adj ), _dragging ); + } +} + +void ColorWheelSelector::_sliderChanged() +{ + _preserve_icc(&_color); + _updateInternals( _color, ColorScales::getScaled( _adj ), _dragging ); +} + +void ColorWheelSelector::_wheelChanged( GimpColorWheel *wheel, SPColorWheelSelector *cs ) +{ + ColorWheelSelector* wheelSelector = static_cast(SP_COLOR_SELECTOR(cs)->base); + + gdouble h = 0; + gdouble s = 0; + gdouble v = 0; + gimp_color_wheel_get_color( wheel, &h, &s, &v ); + + float rgb[3] = {0,0,0}; + sp_color_hsv_to_rgb_floatv (rgb, h, s, v); + + SPColor color(rgb[0], rgb[1], rgb[2]); + + guint32 start = color.toRGBA32( 0x00 ); + guint32 mid = color.toRGBA32( 0x7f ); + guint32 end = color.toRGBA32( 0xff ); + + wheelSelector->_slider->setColors(start, mid, end); + + wheelSelector->_preserve_icc(&color); + wheelSelector->_updateInternals( color, wheelSelector->_alpha, gimp_color_wheel_is_adjusting(wheel) ); +} + + +Gtk::Widget *ColorWheelSelectorFactory::createWidget(Inkscape::UI::SelectedColor &color) const { + GtkWidget *w = sp_color_selector_new(SP_TYPE_COLOR_WHEEL_SELECTOR); + Gtk::Widget *wrapped = Gtk::manage(Glib::wrap(w)); + return wrapped; +} + +Glib::ustring ColorWheelSelectorFactory::modeName() const { + return gettext(ColorWheelSelector::MODE_NAME); +} + + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 : diff --git a/src/ui/widget/color-wheel-selector.h b/src/ui/widget/color-wheel-selector.h new file mode 100644 index 000000000..7a9cb5093 --- /dev/null +++ b/src/ui/widget/color-wheel-selector.h @@ -0,0 +1,111 @@ +#ifndef SEEN_SP_COLOR_WHEEL_SELECTOR_H +#define SEEN_SP_COLOR_WHEEL_SELECTOR_H + +#ifdef HAVE_CONFIG_H +# include +#endif + +#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H +#include +#endif + +#include +#include + +#include "widgets/sp-color-selector.h" +#include "ui/selected-color.h" + +typedef struct _GimpColorWheel GimpColorWheel; +struct SPColorWheelSelector; +struct SPColorWheelSelectorClass; + +namespace Inkscape { +namespace UI { +namespace Widget { + +class ColorSlider; + +} +} +} + +class ColorWheelSelector: public ColorSelector +{ +public: + static const gchar* MODE_NAME; + + ColorWheelSelector( SPColorSelector* csel ); + virtual ~ColorWheelSelector(); + + virtual void init(); + +protected: + virtual void _colorChanged(); + + static void _adjustmentChanged ( GtkAdjustment *adjustment, SPColorWheelSelector *cs ); + + void _sliderGrabbed(); + void _sliderReleased(); + void _sliderChanged(); + static void _wheelChanged( GimpColorWheel *wheel, SPColorWheelSelector *cs ); + + static void _fooChanged( GtkWidget foo, SPColorWheelSelector *cs ); + + void _recalcColor( gboolean changing ); + + gboolean _updating : 1; + gboolean _dragging : 1; + GtkAdjustment* _adj; // Channel adjustment + GtkWidget* _wheel; + Inkscape::UI::Widget::ColorSlider* _slider; + GtkWidget* _sbtn; // Spinbutton + GtkWidget* _label; // Label + +private: + // By default, disallow copy constructor and assignment operator + ColorWheelSelector( const ColorWheelSelector& obj ); + ColorWheelSelector& operator=( const ColorWheelSelector& obj ); + + void _preserve_icc(SPColor *color) const; +}; + + + +#define SP_TYPE_COLOR_WHEEL_SELECTOR (sp_color_wheel_selector_get_type ()) +#define SP_COLOR_WHEEL_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SP_TYPE_COLOR_WHEEL_SELECTOR, SPColorWheelSelector)) +#define SP_COLOR_WHEEL_SELECTOR_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), SP_TYPE_COLOR_WHEEL_SELECTOR, SPColorWheelSelectorClass)) +#define SP_IS_COLOR_WHEEL_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), SP_TYPE_COLOR_WHEEL_SELECTOR)) +#define SP_IS_COLOR_WHEEL_SELECTOR_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SP_TYPE_COLOR_WHEEL_SELECTOR)) + +struct SPColorWheelSelector { + SPColorSelector parent; +}; + +struct SPColorWheelSelectorClass { + SPColorSelectorClass parent_class; +}; + +GType sp_color_wheel_selector_get_type (void); + +GtkWidget *sp_color_wheel_selector_new (void); + + +class ColorWheelSelectorFactory: public Inkscape::UI::ColorSelectorFactory { +public: + Gtk::Widget *createWidget(Inkscape::UI::SelectedColor &color) const; + Glib::ustring modeName() const; +}; + + +#endif // SEEN_SP_COLOR_WHEEL_SELECTOR_H + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 : -- cgit v1.2.3 From c2b99414ee441654e641552f372ebf1165f94ffc Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 31 May 2014 12:34:20 +0200 Subject: SPColorWheelSelector c++-sification: inherit Gtk::Table/Grid (bzr r13341.6.35) --- src/ui/selected-color.cpp | 13 +- src/ui/selected-color.h | 2 + src/ui/widget/color-wheel-selector.cpp | 220 +++++++++++---------------------- src/ui/widget/color-wheel-selector.h | 70 +++++------ 4 files changed, 112 insertions(+), 193 deletions(-) (limited to 'src/ui') diff --git a/src/ui/selected-color.cpp b/src/ui/selected-color.cpp index 1be171a6b..10ca68b21 100644 --- a/src/ui/selected-color.cpp +++ b/src/ui/selected-color.cpp @@ -16,6 +16,8 @@ #include #include +#include "svg/svg-icc-color.h" + namespace Inkscape { namespace UI { @@ -24,8 +26,8 @@ double const SelectedColor::_EPSILON = 1e-4; SelectedColor::SelectedColor() : _color(0) , _alpha(1.0) - , _virgin(true) , _held(false) + , _virgin(true) { } @@ -36,7 +38,7 @@ SelectedColor::~SelectedColor() { void SelectedColor::setColor(SPColor const &color) { - setColorAlpha( color, _alpha ); + setColorAlpha( color, _alpha, true); } SPColor SelectedColor::color() const @@ -47,7 +49,7 @@ SPColor SelectedColor::color() const void SelectedColor::setAlpha(gfloat alpha) { g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) ); - setColorAlpha( _color, alpha ); + setColorAlpha( _color, alpha, true); } gfloat SelectedColor::alpha() const @@ -111,9 +113,14 @@ void SelectedColor::setHeld(bool held) { if (released) { signal_released.emit(); + signal_changed.emit(); } } +void SelectedColor::preserveICC() { + _color.icc = _color.icc ? new SVGICCColor(*_color.icc) : 0; +} + } } diff --git a/src/ui/selected-color.h b/src/ui/selected-color.h index ec0cc55e3..5d3d89672 100644 --- a/src/ui/selected-color.h +++ b/src/ui/selected-color.h @@ -44,6 +44,8 @@ public: void setHeld(bool held); + void preserveICC(); + sigc::signal signal_grabbed; sigc::signal signal_dragged; sigc::signal signal_released; diff --git a/src/ui/widget/color-wheel-selector.cpp b/src/ui/widget/color-wheel-selector.cpp index 134232813..e14c70728 100644 --- a/src/ui/widget/color-wheel-selector.cpp +++ b/src/ui/widget/color-wheel-selector.cpp @@ -11,22 +11,14 @@ #include "dialogs/dialog-events.h" #include "widgets/sp-color-scales.h" #include "svg/svg-icc-color.h" +#include "ui/selected-color.h" #include "ui/widget/color-slider.h" #include "ui/widget/gimpcolorwheel.h" -G_BEGIN_DECLS +namespace Inkscape { +namespace UI { +namespace Widget { -static void sp_color_wheel_selector_class_init (SPColorWheelSelectorClass *klass); -static void sp_color_wheel_selector_init (SPColorWheelSelector *cs); -static void sp_color_wheel_selector_dispose(GObject *object); - -static void sp_color_wheel_selector_show_all (GtkWidget *widget); -static void sp_color_wheel_selector_hide(GtkWidget *widget); - - -G_END_DECLS - -static SPColorSelectorClass *parent_class; #define XPAD 4 #define YPAD 1 @@ -34,60 +26,24 @@ static SPColorSelectorClass *parent_class; const gchar* ColorWheelSelector::MODE_NAME = N_("Wheel"); -GType -sp_color_wheel_selector_get_type (void) -{ - static GType type = 0; - if (!type) { - static const GTypeInfo info = { - sizeof (SPColorWheelSelectorClass), - NULL, /* base_init */ - NULL, /* base_finalize */ - (GClassInitFunc) sp_color_wheel_selector_class_init, - NULL, /* class_finalize */ - NULL, /* class_data */ - sizeof (SPColorWheelSelector), - 0, /* n_preallocs */ - (GInstanceInitFunc) sp_color_wheel_selector_init, - 0, /* value_table */ - }; - - type = g_type_register_static (SP_TYPE_COLOR_SELECTOR, - "SPColorWheelSelector", - &info, - static_cast< GTypeFlags > (0) ); - } - return type; -} - -static void sp_color_wheel_selector_class_init(SPColorWheelSelectorClass *klass) -{ - static const gchar* nameset[] = {N_("Wheel"), 0}; - GObjectClass *object_class = G_OBJECT_CLASS(klass); - GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass); - SPColorSelectorClass *selector_class = SP_COLOR_SELECTOR_CLASS (klass); - - parent_class = SP_COLOR_SELECTOR_CLASS (g_type_class_peek_parent (klass)); - - selector_class->name = nameset; - selector_class->submode_count = 1; - - object_class->dispose = sp_color_wheel_selector_dispose; - - widget_class->show_all = sp_color_wheel_selector_show_all; - widget_class->hide = sp_color_wheel_selector_hide; -} - -ColorWheelSelector::ColorWheelSelector( SPColorSelector* csel ) - : ColorSelector( csel ), - _updating( FALSE ), - _dragging( FALSE ), +ColorWheelSelector::ColorWheelSelector(SelectedColor &color) +#if GTK_CHECK_VERSION(3,0,0) + : Gtk::Grid() +#else + : Gtk::Table(5, 3, false) +#endif + , _color(color) + , _updating(false), _adj(0), _wheel(0), _slider(0), _sbtn(0), _label(0) { + _initUI(); + _color_changed_connection = color.signal_changed.connect(sigc::mem_fun(this, &ColorWheelSelector::_colorChanged)); + _color_dragged_connection = color.signal_dragged.connect(sigc::mem_fun(this, &ColorWheelSelector::_colorChanged)); + } ColorWheelSelector::~ColorWheelSelector() @@ -96,33 +52,17 @@ ColorWheelSelector::~ColorWheelSelector() _wheel = 0; _sbtn = 0; _label = 0; -} - -void sp_color_wheel_selector_init (SPColorWheelSelector *cs) -{ - SP_COLOR_SELECTOR(cs)->base = new ColorWheelSelector( SP_COLOR_SELECTOR(cs) ); - if ( SP_COLOR_SELECTOR(cs)->base ) - { - SP_COLOR_SELECTOR(cs)->base->init(); - } + _color_changed_connection.disconnect(); + _color_dragged_connection.disconnect(); } -void ColorWheelSelector::init() -{ +void ColorWheelSelector::_initUI() { gint row = 0; - _updating = FALSE; - _dragging = FALSE; - -#if GTK_CHECK_VERSION(3,0,0) - GtkWidget *t = gtk_grid_new(); -#else - GtkWidget *t = gtk_table_new (5, 3, FALSE); -#endif + GtkWidget *t = GTK_WIDGET(gobj()); - gtk_widget_show (t); - gtk_box_pack_start (GTK_BOX (_csel), t, TRUE, TRUE, 0); + //gtk_widget_show (t); /* Create components */ row = 0; @@ -205,44 +145,14 @@ void ColorWheelSelector::init() /* Signals */ g_signal_connect (G_OBJECT (_adj), "value_changed", - G_CALLBACK (_adjustmentChanged), _csel); + G_CALLBACK (_adjustmentChanged), this); _slider->signal_grabbed.connect(sigc::mem_fun(*this, &ColorWheelSelector::_sliderGrabbed)); _slider->signal_released.connect(sigc::mem_fun(*this, &ColorWheelSelector::_sliderReleased)); _slider->signal_value_changed.connect(sigc::mem_fun(*this, &ColorWheelSelector::_sliderChanged)); g_signal_connect( G_OBJECT(_wheel), "changed", - G_CALLBACK (_wheelChanged), _csel ); -} - -static void sp_color_wheel_selector_dispose(GObject *object) -{ - if ((G_OBJECT_CLASS(parent_class))->dispose) - (* (G_OBJECT_CLASS(parent_class))->dispose) (object); -} - -static void -sp_color_wheel_selector_show_all (GtkWidget *widget) -{ - gtk_widget_show (widget); -} - -static void sp_color_wheel_selector_hide(GtkWidget *widget) -{ - gtk_widget_hide(widget); -} - -GtkWidget *sp_color_wheel_selector_new() -{ - SPColorWheelSelector *csel = SP_COLOR_WHEEL_SELECTOR(g_object_new (SP_TYPE_COLOR_WHEEL_SELECTOR, NULL)); - - return GTK_WIDGET (csel); -} - -/* Helpers for setting color value */ - -void ColorWheelSelector::_preserve_icc(SPColor *color) const { - color->icc = getColor().icc ? new SVGICCColor(*getColor().icc) : 0; + G_CALLBACK (_wheelChanged), this ); } void ColorWheelSelector::_colorChanged() @@ -250,26 +160,34 @@ void ColorWheelSelector::_colorChanged() #ifdef DUMP_CHANGE_INFO g_message("ColorWheelSelector::_colorChanged( this=%p, %f, %f, %f, %f)", this, color.v.c[0], color.v.c[1], color.v.c[2], alpha ); #endif - _updating = TRUE; + if (_updating) { + return; + } + + _updating = true; { float hsv[3] = {0,0,0}; - sp_color_rgb_to_hsv_floatv(hsv, _color.v.c[0], _color.v.c[1], _color.v.c[2]); + sp_color_rgb_to_hsv_floatv(hsv, _color.color().v.c[0], _color.color().v.c[1], _color.color().v.c[2]); gimp_color_wheel_set_color( GIMP_COLOR_WHEEL(_wheel), hsv[0], hsv[1], hsv[2] ); } - guint32 start = _color.toRGBA32( 0x00 ); - guint32 mid = _color.toRGBA32( 0x7f ); - guint32 end = _color.toRGBA32( 0xff ); + guint32 start = _color.color().toRGBA32( 0x00 ); + guint32 mid = _color.color().toRGBA32( 0x7f ); + guint32 end = _color.color().toRGBA32( 0xff ); _slider->setColors(start, mid, end); - ColorScales::setScaled(_adj, _alpha); + ColorScales::setScaled(_adj, _color.alpha()); _updating = FALSE; } -void ColorWheelSelector::_adjustmentChanged( GtkAdjustment *adjustment, SPColorWheelSelector *cs ) +void ColorWheelSelector::_adjustmentChanged( GtkAdjustment *adjustment, ColorWheelSelector *cs ) { + if (cs->_updating) { + return; + } + // TODO check this. It looks questionable: // if a value is entered between 0 and 1 exclusive, normalize it to (int) 0..255 or 0..100 gdouble value = gtk_adjustment_get_value (adjustment); @@ -279,48 +197,42 @@ void ColorWheelSelector::_adjustmentChanged( GtkAdjustment *adjustment, SPColorW gtk_adjustment_set_value( adjustment, floor (value * upper + 0.5) ); } - ColorWheelSelector* wheelSelector = static_cast(SP_COLOR_SELECTOR(cs)->base); - if (wheelSelector->_updating) return; + cs->_updating = true; - wheelSelector->_updating = TRUE; + cs->_color.preserveICC(); - wheelSelector->_preserve_icc(&wheelSelector->_color); - wheelSelector->_updateInternals( wheelSelector->_color, ColorScales::getScaled( wheelSelector->_adj ), wheelSelector->_dragging ); + cs->_color.setAlpha(ColorScales::getScaled( cs->_adj )); - wheelSelector->_updating = FALSE; + cs->_updating = false; } void ColorWheelSelector::_sliderGrabbed() { - if (!_dragging) { - _dragging = TRUE; - _grabbed(); - - _preserve_icc(&_color); - _updateInternals( _color, ColorScales::getScaled( _adj ), _dragging ); - } + _color.preserveICC(); + _color.setHeld(true); } void ColorWheelSelector::_sliderReleased() { - if (_dragging) { - _dragging = FALSE; - _released(); - - _preserve_icc(&_color); - _updateInternals( _color, ColorScales::getScaled( _adj ), _dragging ); - } + _color.preserveICC(); + _color.setHeld(false); } void ColorWheelSelector::_sliderChanged() { - _preserve_icc(&_color); - _updateInternals( _color, ColorScales::getScaled( _adj ), _dragging ); + if (_updating) { + return; + } + + _updating = true; + _color.preserveICC(); + _color.setAlpha(ColorScales::getScaled(_adj)); + _updating = false; } -void ColorWheelSelector::_wheelChanged( GimpColorWheel *wheel, SPColorWheelSelector *cs ) +void ColorWheelSelector::_wheelChanged( GimpColorWheel *wheel, ColorWheelSelector *wheelSelector ) { - ColorWheelSelector* wheelSelector = static_cast(SP_COLOR_SELECTOR(cs)->base); + if (wheelSelector->_updating) return; gdouble h = 0; gdouble s = 0; @@ -338,21 +250,31 @@ void ColorWheelSelector::_wheelChanged( GimpColorWheel *wheel, SPColorWheelSelec wheelSelector->_slider->setColors(start, mid, end); - wheelSelector->_preserve_icc(&color); - wheelSelector->_updateInternals( color, wheelSelector->_alpha, gimp_color_wheel_is_adjusting(wheel) ); + wheelSelector->_updating = true; + + wheelSelector->_color.preserveICC(); + + wheelSelector->_color.setHeld(gimp_color_wheel_is_adjusting(wheel)); + wheelSelector->_color.setColor(color); + + wheelSelector->_updating = false; } Gtk::Widget *ColorWheelSelectorFactory::createWidget(Inkscape::UI::SelectedColor &color) const { - GtkWidget *w = sp_color_selector_new(SP_TYPE_COLOR_WHEEL_SELECTOR); - Gtk::Widget *wrapped = Gtk::manage(Glib::wrap(w)); - return wrapped; + Gtk::Widget *w = Gtk::manage(new ColorWheelSelector(color)); + return w; } Glib::ustring ColorWheelSelectorFactory::modeName() const { return gettext(ColorWheelSelector::MODE_NAME); } +} +} +} + + /* Local Variables: diff --git a/src/ui/widget/color-wheel-selector.h b/src/ui/widget/color-wheel-selector.h index 7a9cb5093..e289a8df6 100644 --- a/src/ui/widget/color-wheel-selector.h +++ b/src/ui/widget/color-wheel-selector.h @@ -1,3 +1,14 @@ +/** + * @file + * Color selector widget containing GIMP color wheel and slider + */ +/* Authors: + * Tomasz Boczkowski (c++-sification) + * + * Copyright (C) 2014 Authors + * + * This code is in public domain + */ #ifndef SEEN_SP_COLOR_WHEEL_SELECTOR_H #define SEEN_SP_COLOR_WHEEL_SELECTOR_H @@ -11,13 +22,11 @@ #include #include +#include -#include "widgets/sp-color-selector.h" #include "ui/selected-color.h" typedef struct _GimpColorWheel GimpColorWheel; -struct SPColorWheelSelector; -struct SPColorWheelSelectorClass; namespace Inkscape { namespace UI { @@ -25,36 +34,31 @@ namespace Widget { class ColorSlider; -} -} -} - -class ColorWheelSelector: public ColorSelector +class ColorWheelSelector + : public Gtk::Table //if GTK2 { public: static const gchar* MODE_NAME; - ColorWheelSelector( SPColorSelector* csel ); + ColorWheelSelector(SelectedColor &color); virtual ~ColorWheelSelector(); - virtual void init(); - protected: + void _initUI(); virtual void _colorChanged(); - static void _adjustmentChanged ( GtkAdjustment *adjustment, SPColorWheelSelector *cs ); + static void _adjustmentChanged ( GtkAdjustment *adjustment, ColorWheelSelector *cs ); void _sliderGrabbed(); void _sliderReleased(); void _sliderChanged(); - static void _wheelChanged( GimpColorWheel *wheel, SPColorWheelSelector *cs ); - - static void _fooChanged( GtkWidget foo, SPColorWheelSelector *cs ); + static void _wheelChanged( GimpColorWheel *wheel, ColorWheelSelector *cs ); void _recalcColor( gboolean changing ); - gboolean _updating : 1; - gboolean _dragging : 1; + SelectedColor &_color; + bool _updating; + GtkAdjustment* _adj; // Channel adjustment GtkWidget* _wheel; Inkscape::UI::Widget::ColorSlider* _slider; @@ -66,36 +70,20 @@ private: ColorWheelSelector( const ColorWheelSelector& obj ); ColorWheelSelector& operator=( const ColorWheelSelector& obj ); - void _preserve_icc(SPColor *color) const; + sigc::connection _color_changed_connection; + sigc::connection _color_dragged_connection; }; - - -#define SP_TYPE_COLOR_WHEEL_SELECTOR (sp_color_wheel_selector_get_type ()) -#define SP_COLOR_WHEEL_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SP_TYPE_COLOR_WHEEL_SELECTOR, SPColorWheelSelector)) -#define SP_COLOR_WHEEL_SELECTOR_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), SP_TYPE_COLOR_WHEEL_SELECTOR, SPColorWheelSelectorClass)) -#define SP_IS_COLOR_WHEEL_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), SP_TYPE_COLOR_WHEEL_SELECTOR)) -#define SP_IS_COLOR_WHEEL_SELECTOR_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SP_TYPE_COLOR_WHEEL_SELECTOR)) - -struct SPColorWheelSelector { - SPColorSelector parent; -}; - -struct SPColorWheelSelectorClass { - SPColorSelectorClass parent_class; -}; - -GType sp_color_wheel_selector_get_type (void); - -GtkWidget *sp_color_wheel_selector_new (void); - - -class ColorWheelSelectorFactory: public Inkscape::UI::ColorSelectorFactory { +class ColorWheelSelectorFactory: public ColorSelectorFactory { public: - Gtk::Widget *createWidget(Inkscape::UI::SelectedColor &color) const; + Gtk::Widget *createWidget(SelectedColor &color) const; Glib::ustring modeName() const; }; +} +} +} + #endif // SEEN_SP_COLOR_WHEEL_SELECTOR_H -- cgit v1.2.3 From acb2a6bf56c0c932e89114e00cef10fdb5c2f9b5 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 31 May 2014 14:59:50 +0200 Subject: SPColorWheelSelector c++-sification: replaced gtk calls by gtkmm versions (bzr r13341.6.37) --- src/ui/widget/color-wheel-selector.cpp | 146 ++++++++++++++++----------------- src/ui/widget/color-wheel-selector.h | 30 ++++--- 2 files changed, 90 insertions(+), 86 deletions(-) (limited to 'src/ui') diff --git a/src/ui/widget/color-wheel-selector.cpp b/src/ui/widget/color-wheel-selector.cpp index e14c70728..e49e4ba16 100644 --- a/src/ui/widget/color-wheel-selector.cpp +++ b/src/ui/widget/color-wheel-selector.cpp @@ -8,6 +8,8 @@ #include #include #include +#include +#include #include "dialogs/dialog-events.h" #include "widgets/sp-color-scales.h" #include "svg/svg-icc-color.h" @@ -33,12 +35,12 @@ ColorWheelSelector::ColorWheelSelector(SelectedColor &color) : Gtk::Table(5, 3, false) #endif , _color(color) - , _updating(false), - _adj(0), - _wheel(0), - _slider(0), - _sbtn(0), - _label(0) + , _updating(false) +#if !GTK_CHECK_VERSION(3,0,0) + , _alpha_adjustment(NULL) +#endif + , _wheel(0) + , _slider(0) { _initUI(); _color_changed_connection = color.signal_changed.connect(sigc::mem_fun(this, &ColorWheelSelector::_colorChanged)); @@ -48,24 +50,18 @@ ColorWheelSelector::ColorWheelSelector(SelectedColor &color) ColorWheelSelector::~ColorWheelSelector() { - _adj = 0; _wheel = 0; - _sbtn = 0; - _label = 0; +#if !GTK_CHECK_VERSION(3,0,0) + delete _alpha_adjustment; +#endif _color_changed_connection.disconnect(); _color_dragged_connection.disconnect(); } void ColorWheelSelector::_initUI() { - gint row = 0; - - GtkWidget *t = GTK_WIDGET(gobj()); - - //gtk_widget_show (t); - /* Create components */ - row = 0; + gint row = 0; _wheel = gimp_color_wheel_new(); gtk_widget_show( _wheel ); @@ -75,35 +71,38 @@ void ColorWheelSelector::_initUI() { gtk_widget_set_valign(_wheel, GTK_ALIGN_FILL); gtk_widget_set_hexpand(_wheel, TRUE); gtk_widget_set_vexpand(_wheel, TRUE); - gtk_grid_attach(GTK_GRID(t), _wheel, 0, row, 3, 1); + gtk_grid_attach(GTK_GRID(gobj()), _wheel, 0, row, 3, 1); #else - gtk_table_attach(GTK_TABLE(t), _wheel, 0, 3, row, row + 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0); + gtk_table_attach(GTK_TABLE(gobj()), _wheel, 0, 3, row, row + 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0); #endif row++; /* Label */ - _label = gtk_label_new_with_mnemonic (_("_A:")); - gtk_misc_set_alignment (GTK_MISC (_label), 1.0, 0.5); - gtk_widget_show (_label); + Gtk::Label* label = Gtk::manage(new Gtk::Label(_("_A:"), true)); + label->set_alignment(1.0, 0.5); + label->show(); #if GTK_CHECK_VERSION(3,0,0) - gtk_widget_set_margin_left(_label, XPAD); - gtk_widget_set_margin_right(_label, XPAD); - gtk_widget_set_margin_top(_label, YPAD); - gtk_widget_set_margin_bottom(_label, YPAD); - gtk_widget_set_halign(_label, GTK_ALIGN_FILL); - gtk_widget_set_valign(_label, GTK_ALIGN_FILL); - gtk_grid_attach(GTK_GRID(t), _label, 0, row, 1, 1); + label->set_margin_left(XPAD); + label->set_margin_right(XPAD); + label->set_margin_top(YPAD); + label->set_margin_bottom(YPAD); + label->set_halign(Gtk::ALIGN_FILL); + label->set_valign(Gtk::ALIGN_FILL); + attach(*label, 0, row, 1, 1); #else - gtk_table_attach (GTK_TABLE (t), _label, 0, 1, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD); + attach(*label, 0, 1, row, row + 1, Gtk::FILL, Gtk::FILL, XPAD, YPAD); #endif /* Adjustment */ - _adj = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 255.0, 1.0, 10.0, 10.0)); - +#if GTK_CHECK_VERSION(3,0,0) + _alpha_adjustment = Gtk::Adjustment::create(0.0, 0.0, 255.0, 1.0, 10.0, 10.0); +#else + _alpha_adjustment = new Gtk::Adjustment(0.0, 0.0, 255.0, 1.0, 10.0, 10.0); +#endif /* Slider */ - _slider = Gtk::manage(new Inkscape::UI::Widget::ColorSlider(Glib::wrap(_adj, true))); + _slider = Gtk::manage(new Inkscape::UI::Widget::ColorSlider(_alpha_adjustment)); _slider->set_tooltip_text(_("Alpha (opacity)")); _slider->show(); @@ -115,9 +114,9 @@ void ColorWheelSelector::_initUI() { _slider->set_hexpand(true); _slider->set_halign(Gtk::ALIGN_FILL); _slider->set_valign(Gtk::ALIGN_FILL); - gtk_grid_attach(GTK_GRID(t), _slider->gobj(), 1, row, 1, 1); + attach(*_slider, 1, row, 1, 1); #else - gtk_table_attach(GTK_TABLE (t), _slider->gobj(), 1, 2, row, row + 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, XPAD, YPAD); + attach(*_slider, 1, 2, row, row+1, Gtk::EXPAND | Gtk::FILL, Gtk::FILL, XPAD, YPAD); #endif _slider->setColors(SP_RGBA32_F_COMPOSE (1.0, 1.0, 1.0, 0.0), @@ -125,32 +124,34 @@ void ColorWheelSelector::_initUI() { SP_RGBA32_F_COMPOSE (1.0, 1.0, 1.0, 1.0)); /* Spinbutton */ - _sbtn = gtk_spin_button_new (GTK_ADJUSTMENT (_adj), 1.0, 0); - gtk_widget_set_tooltip_text (_sbtn, _("Alpha (opacity)")); - sp_dialog_defocus_on_enter (_sbtn); - gtk_label_set_mnemonic_widget (GTK_LABEL(_label), _sbtn); - gtk_widget_show (_sbtn); +#if GTK_CHECK_VERSION(3,0,0) + Gtk::SpinButton* spin_button = Gtk::manage(new Gtk::SpinButton(_alpha_adjustment, 1.0, 0)); + #else + Gtk::SpinButton* spin_button = Gtk::manage(new Gtk::SpinButton(*_alpha_adjustment, 1.0, 0)); +#endif + spin_button->set_tooltip_text(_("Alpha (opacity)")); + sp_dialog_defocus_on_enter(GTK_WIDGET(spin_button->gobj())); + label->set_mnemonic_widget(*spin_button); + spin_button->show(); #if GTK_CHECK_VERSION(3,0,0) - gtk_widget_set_margin_left(_sbtn, XPAD); - gtk_widget_set_margin_right(_sbtn, XPAD); - gtk_widget_set_margin_top(_sbtn, YPAD); - gtk_widget_set_margin_bottom(_sbtn, YPAD); - gtk_widget_set_halign(_sbtn, GTK_ALIGN_CENTER); - gtk_widget_set_valign(_sbtn, GTK_ALIGN_CENTER); - gtk_grid_attach(GTK_GRID(t), _sbtn, 2, row, 1, 1); + + spin_button->set_margin_left(XPAD); + spin_button->set_margin_right(XPAD); + spin_button->set_margin_top(YPAD); + spin_button->set_margin_bottom(YPAD); + spin_button->set_halign(Gtk::ALIGN_CENTER); + spin_button->set_valign(Gtk::ALIGN_CENTER); + attach(*spin_button, 2, row, 1, 1); #else - gtk_table_attach (GTK_TABLE (t), _sbtn, 2, 3, row, row + 1, (GtkAttachOptions)0, (GtkAttachOptions)0, XPAD, YPAD); + attach(*spin_button, 2, 3, row, row + 1, (Gtk::AttachOptions)0, (Gtk::AttachOptions)0, XPAD, YPAD); #endif /* Signals */ - g_signal_connect (G_OBJECT (_adj), "value_changed", - G_CALLBACK (_adjustmentChanged), this); - + _alpha_adjustment->signal_value_changed().connect(sigc::mem_fun(this, &ColorWheelSelector::_adjustmentChanged)); _slider->signal_grabbed.connect(sigc::mem_fun(*this, &ColorWheelSelector::_sliderGrabbed)); _slider->signal_released.connect(sigc::mem_fun(*this, &ColorWheelSelector::_sliderReleased)); _slider->signal_value_changed.connect(sigc::mem_fun(*this, &ColorWheelSelector::_sliderChanged)); - g_signal_connect( G_OBJECT(_wheel), "changed", G_CALLBACK (_wheelChanged), this ); } @@ -158,7 +159,7 @@ void ColorWheelSelector::_initUI() { void ColorWheelSelector::_colorChanged() { #ifdef DUMP_CHANGE_INFO - g_message("ColorWheelSelector::_colorChanged( this=%p, %f, %f, %f, %f)", this, color.v.c[0], color.v.c[1], color.v.c[2], alpha ); + g_message("ColorWheelSelector::_colorChanged( this=%p, %f, %f, %f, %f)", this, _color.color().v.c[0], _color.color().v.c[1], _color.color().v.c[2], alpha ); #endif if (_updating) { return; @@ -177,33 +178,30 @@ void ColorWheelSelector::_colorChanged() _slider->setColors(start, mid, end); - ColorScales::setScaled(_adj, _color.alpha()); + ColorScales::setScaled(_alpha_adjustment->gobj(), _color.alpha()); - _updating = FALSE; + _updating = false; } -void ColorWheelSelector::_adjustmentChanged( GtkAdjustment *adjustment, ColorWheelSelector *cs ) +void ColorWheelSelector::_adjustmentChanged() { - if (cs->_updating) { + if (_updating) { return; } + _updating = true; -// TODO check this. It looks questionable: + // TODO check this. It looks questionable: // if a value is entered between 0 and 1 exclusive, normalize it to (int) 0..255 or 0..100 - gdouble value = gtk_adjustment_get_value (adjustment); - gdouble upper = gtk_adjustment_get_upper (adjustment); - + gdouble value = _alpha_adjustment->get_value(); + gdouble upper = _alpha_adjustment->get_upper(); if (value > 0.0 && value < 1.0) { - gtk_adjustment_set_value( adjustment, floor (value * upper + 0.5) ); + _alpha_adjustment->set_value(floor(value * upper + 0.5)); } - cs->_updating = true; - - cs->_color.preserveICC(); - - cs->_color.setAlpha(ColorScales::getScaled( cs->_adj )); + _color.preserveICC(); + _color.setAlpha(ColorScales::getScaled(_alpha_adjustment->gobj())); - cs->_updating = false; + _updating = false; } void ColorWheelSelector::_sliderGrabbed() @@ -226,13 +224,16 @@ void ColorWheelSelector::_sliderChanged() _updating = true; _color.preserveICC(); - _color.setAlpha(ColorScales::getScaled(_adj)); + _color.setAlpha(ColorScales::getScaled(_alpha_adjustment->gobj())); _updating = false; } -void ColorWheelSelector::_wheelChanged( GimpColorWheel *wheel, ColorWheelSelector *wheelSelector ) +void ColorWheelSelector::_wheelChanged(GimpColorWheel *wheel, ColorWheelSelector *wheelSelector) { - if (wheelSelector->_updating) return; + if (wheelSelector->_updating){ + return; + } + wheelSelector->_updating = true; gdouble h = 0; gdouble s = 0; @@ -250,8 +251,6 @@ void ColorWheelSelector::_wheelChanged( GimpColorWheel *wheel, ColorWheelSelecto wheelSelector->_slider->setColors(start, mid, end); - wheelSelector->_updating = true; - wheelSelector->_color.preserveICC(); wheelSelector->_color.setHeld(gimp_color_wheel_is_adjusting(wheel)); @@ -273,9 +272,6 @@ Glib::ustring ColorWheelSelectorFactory::modeName() const { } } } - - - /* Local Variables: mode:c++ diff --git a/src/ui/widget/color-wheel-selector.h b/src/ui/widget/color-wheel-selector.h index e289a8df6..f5213fad7 100644 --- a/src/ui/widget/color-wheel-selector.h +++ b/src/ui/widget/color-wheel-selector.h @@ -22,7 +22,11 @@ #include #include +#if GTK_CHECK_VERSION(3,0,0) +#include +#else #include +#endif #include "ui/selected-color.h" @@ -35,7 +39,11 @@ namespace Widget { class ColorSlider; class ColorWheelSelector - : public Gtk::Table //if GTK2 +#if GTK_CHECK_VERSION(3,0,0) + : public Gtk::Grid +#else + : public Gtk::Table +#endif { public: static const gchar* MODE_NAME; @@ -45,25 +53,25 @@ public: protected: void _initUI(); - virtual void _colorChanged(); - - static void _adjustmentChanged ( GtkAdjustment *adjustment, ColorWheelSelector *cs ); + void _colorChanged(); + void _adjustmentChanged(); void _sliderGrabbed(); void _sliderReleased(); void _sliderChanged(); - static void _wheelChanged( GimpColorWheel *wheel, ColorWheelSelector *cs ); + static void _wheelChanged(GimpColorWheel *wheel, ColorWheelSelector *cs); - void _recalcColor( gboolean changing ); + void _recalcColor(gboolean changing); SelectedColor &_color; bool _updating; - - GtkAdjustment* _adj; // Channel adjustment +#if GTK_CHECK_VERSION(3,0,0) + Glib::RefPtr _alpha_adjustment; +#else + Gtk::Adjustment* _alpha_adjustment; +#endif GtkWidget* _wheel; Inkscape::UI::Widget::ColorSlider* _slider; - GtkWidget* _sbtn; // Spinbutton - GtkWidget* _label; // Label private: // By default, disallow copy constructor and assignment operator @@ -74,6 +82,7 @@ private: sigc::connection _color_dragged_connection; }; + class ColorWheelSelectorFactory: public ColorSelectorFactory { public: Gtk::Widget *createWidget(SelectedColor &color) const; @@ -84,7 +93,6 @@ public: } } - #endif // SEEN_SP_COLOR_WHEEL_SELECTOR_H /* -- cgit v1.2.3 From 9325918fd04118cda566f15120b975467b2e6e9f Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 31 May 2014 15:09:21 +0200 Subject: SPColorScales c++-sification - move to ui/widget (bzr r13341.6.38) --- src/ui/widget/Makefile_insert | 2 + src/ui/widget/color-scales.cpp | 788 +++++++++++++++++++++++++++++++++ src/ui/widget/color-scales.h | 139 ++++++ src/ui/widget/color-slider.cpp | 2 +- src/ui/widget/color-wheel-selector.cpp | 2 +- 5 files changed, 931 insertions(+), 2 deletions(-) create mode 100644 src/ui/widget/color-scales.cpp create mode 100644 src/ui/widget/color-scales.h (limited to 'src/ui') diff --git a/src/ui/widget/Makefile_insert b/src/ui/widget/Makefile_insert index 97625f04e..039e2a8d9 100644 --- a/src/ui/widget/Makefile_insert +++ b/src/ui/widget/Makefile_insert @@ -16,6 +16,8 @@ ink_common_sources += \ ui/widget/color-preview.h \ ui/widget/color-slider.cpp \ ui/widget/color-slider.h \ + ui/widget/color-scales.cpp \ + ui/widget/color-scales.h \ ui/widget/combo-enums.h \ ui/widget/dock.h \ ui/widget/dock.cpp \ diff --git a/src/ui/widget/color-scales.cpp b/src/ui/widget/color-scales.cpp new file mode 100644 index 000000000..bba44034a --- /dev/null +++ b/src/ui/widget/color-scales.cpp @@ -0,0 +1,788 @@ +/* + * bulia byak + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "ui/widget/color-scales.h" + +#include +#include +#include +#include + +#include "dialogs/dialog-events.h" +#include "svg/svg-icc-color.h" +#include "ui/widget/color-slider.h" + +#define CSC_CHANNEL_R (1 << 0) +#define CSC_CHANNEL_G (1 << 1) +#define CSC_CHANNEL_B (1 << 2) +#define CSC_CHANNEL_A (1 << 3) +#define CSC_CHANNEL_H (1 << 0) +#define CSC_CHANNEL_S (1 << 1) +#define CSC_CHANNEL_V (1 << 2) +#define CSC_CHANNEL_C (1 << 0) +#define CSC_CHANNEL_M (1 << 1) +#define CSC_CHANNEL_Y (1 << 2) +#define CSC_CHANNEL_K (1 << 3) +#define CSC_CHANNEL_CMYKA (1 << 4) + +#define CSC_CHANNELS_ALL 0 + + +G_BEGIN_DECLS + +static void sp_color_scales_class_init (SPColorScalesClass *klass); +static void sp_color_scales_init (SPColorScales *cs); +static void sp_color_scales_dispose(GObject *object); + +static void sp_color_scales_show_all (GtkWidget *widget); +static void sp_color_scales_hide(GtkWidget *widget); + +static const gchar *sp_color_scales_hue_map (void); + +G_END_DECLS + +static SPColorSelectorClass *parent_class; + +#define XPAD 4 +#define YPAD 1 + +#define noDUMP_CHANGE_INFO 1 + +const gchar* ColorScales::SUBMODE_NAMES[] = { + N_("None"), + N_("RGB"), + N_("HSL"), + N_("CMYK") +}; + +GType +sp_color_scales_get_type (void) +{ + static GType type = 0; + if (!type) { + static const GTypeInfo info = { + sizeof (SPColorScalesClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) sp_color_scales_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof (SPColorScales), + 0, /* n_preallocs */ + (GInstanceInitFunc) sp_color_scales_init, + NULL + }; + + type = g_type_register_static (SP_TYPE_COLOR_SELECTOR, + "SPColorScales", + &info, + static_cast< GTypeFlags > (0) ); + } + return type; +} + +static void +sp_color_scales_class_init (SPColorScalesClass *klass) +{ + static const gchar* nameset[] = {N_("RGB"), N_("HSL"), N_("CMYK"), 0}; + GObjectClass *object_class = G_OBJECT_CLASS(klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass); + SPColorSelectorClass *selector_class = SP_COLOR_SELECTOR_CLASS (klass); + + parent_class = SP_COLOR_SELECTOR_CLASS (g_type_class_peek_parent (klass)); + + selector_class->name = nameset; + selector_class->submode_count = 3; + + object_class->dispose = sp_color_scales_dispose; + + widget_class->show_all = sp_color_scales_show_all; + widget_class->hide = sp_color_scales_hide; +} + +ColorScales::ColorScales( SPColorSelector* csel ) + : ColorSelector( csel ), + _mode( SP_COLOR_SCALES_MODE_NONE ), + _rangeLimit( 255.0 ), + _updating( FALSE ), + _dragging( FALSE ) +{ + for (gint i = 0; i < 5; i++) { + _l[i] = 0; + _a[i] = 0; + _s[i] = 0; + _b[i] = 0; + } +} + +ColorScales::~ColorScales() +{ + for (gint i = 0; i < 5; i++) { + _l[i] = 0; + _a[i] = 0; + _s[i] = 0; + _b[i] = 0; + } +} + +void sp_color_scales_init (SPColorScales *cs) +{ + SP_COLOR_SELECTOR(cs)->base = new ColorScales( SP_COLOR_SELECTOR(cs) ); + + if ( SP_COLOR_SELECTOR(cs)->base ) + { + SP_COLOR_SELECTOR(cs)->base->init(); + } +} + +void ColorScales::init() +{ + gint i; + + _updating = FALSE; + _dragging = FALSE; + +#if GTK_CHECK_VERSION(3,0,0) + GtkWidget *t = gtk_grid_new(); +#else + GtkWidget *t = gtk_table_new (5, 3, FALSE); +#endif + gtk_widget_show (t); + gtk_box_pack_start (GTK_BOX (_csel), t, TRUE, TRUE, 4); + + /* Create components */ + for (i = 0; i < static_cast< gint > (G_N_ELEMENTS(_a)) ; i++) { + /* Label */ + _l[i] = gtk_label_new(""); + gtk_misc_set_alignment (GTK_MISC (_l[i]), 1.0, 0.5); + gtk_widget_show (_l[i]); + +#if GTK_CHECK_VERSION(3,0,0) + gtk_widget_set_margin_left(_l[i], XPAD); + gtk_widget_set_margin_right(_l[i], XPAD); + gtk_widget_set_margin_top(_l[i], YPAD); + gtk_widget_set_margin_bottom(_l[i], YPAD); + gtk_grid_attach(GTK_GRID(t), _l[i], 0, i, 1, 1); +#else + gtk_table_attach (GTK_TABLE (t), _l[i], 0, 1, i, i + 1, GTK_FILL, GTK_FILL, XPAD, YPAD); +#endif + + /* Adjustment */ + _a[i] = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, _rangeLimit, 1.0, 10.0, 10.0)); + /* Slider */ + _s[i] = Gtk::manage(new Inkscape::UI::Widget::ColorSlider(Glib::wrap(_a[i], true))); + _s[i]->show(); + +#if GTK_CHECK_VERSION(3,0,0) + _s[i]->set_margin_left(XPAD); + _s[i]->set_margin_right(XPAD); + _s[i]->set_margin_top(YPAD); + _s[i]->set_margin_bottom(YPAD); + _s[i]->set_hexpand(true); + gtk_grid_attach(GTK_GRID(t), _s[i]->gobj(), 1, i, 1, 1); +#else + gtk_table_attach (GTK_TABLE (t), _s[i]->gobj(), 1, 2, i, i + 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, XPAD, YPAD); +#endif + + /* Spinbutton */ + _b[i] = gtk_spin_button_new (GTK_ADJUSTMENT (_a[i]), 1.0, 0); + sp_dialog_defocus_on_enter (_b[i]); + gtk_label_set_mnemonic_widget (GTK_LABEL(_l[i]), _b[i]); + gtk_widget_show (_b[i]); + +#if GTK_CHECK_VERSION(3,0,0) + gtk_widget_set_margin_left(_b[i], XPAD); + gtk_widget_set_margin_right(_b[i], XPAD); + gtk_widget_set_margin_top(_b[i], YPAD); + gtk_widget_set_margin_bottom(_b[i], YPAD); + gtk_widget_set_halign(_b[i], GTK_ALIGN_CENTER); + gtk_widget_set_valign(_b[i], GTK_ALIGN_CENTER); + gtk_grid_attach(GTK_GRID(t), _b[i], 2, i, 1, 1); +#else + gtk_table_attach (GTK_TABLE (t), _b[i], 2, 3, i, i + 1, (GtkAttachOptions)0, (GtkAttachOptions)0, XPAD, YPAD); +#endif + + /* Attach channel value to adjustment */ + g_object_set_data (G_OBJECT (_a[i]), "channel", GINT_TO_POINTER (i)); + /* Signals */ + g_signal_connect (G_OBJECT (_a[i]), "value_changed", + G_CALLBACK (_adjustmentAnyChanged), _csel); + _s[i]->signal_grabbed.connect(sigc::mem_fun(this, &ColorScales::_sliderAnyGrabbed)); + _s[i]->signal_released.connect(sigc::mem_fun(this, &ColorScales::_sliderAnyReleased)); + _s[i]->signal_value_changed.connect(sigc::mem_fun(this, &ColorScales::_sliderAnyChanged)); + } + + /* Initial mode is none, so it works */ + setMode(SP_COLOR_SCALES_MODE_RGB); +} + +static void sp_color_scales_dispose(GObject *object) +{ + if ((G_OBJECT_CLASS(parent_class))->dispose) + (* (G_OBJECT_CLASS(parent_class))->dispose) (object); +} + +static void +sp_color_scales_show_all (GtkWidget *widget) +{ + gtk_widget_show (widget); +} + +static void sp_color_scales_hide(GtkWidget *widget) +{ + gtk_widget_hide(widget); +} + +GtkWidget *sp_color_scales_new() +{ + SPColorScales *csel = SP_COLOR_SCALES(g_object_new (SP_TYPE_COLOR_SCALES, NULL)); + + return GTK_WIDGET (csel); +} + +void ColorScales::_recalcColor( gboolean changing ) +{ + if ( changing ) + { + SPColor color; + gfloat alpha = 1.0; + gfloat c[5]; + + switch (_mode) { + case SP_COLOR_SCALES_MODE_RGB: + case SP_COLOR_SCALES_MODE_HSV: + _getRgbaFloatv(c); + color.set( c[0], c[1], c[2] ); + alpha = c[3]; + break; + case SP_COLOR_SCALES_MODE_CMYK: + { + _getCmykaFloatv( c ); + + float rgb[3]; + sp_color_cmyk_to_rgb_floatv( rgb, c[0], c[1], c[2], c[3] ); + color.set( rgb[0], rgb[1], rgb[2] ); + alpha = c[4]; + break; + } + default: + g_warning ("file %s: line %d: Illegal color selector mode %d", __FILE__, __LINE__, _mode); + break; + } + + /* Preserve ICC */ + color.icc = _color.icc ? new SVGICCColor(*_color.icc) : 0; + + _updateInternals( color, alpha, _dragging ); + } + else + { + _updateInternals( _color, _alpha, _dragging ); + } +} + +/* Helpers for setting color value */ +gfloat ColorScales::getScaled( const GtkAdjustment *a ) +{ + gfloat val = gtk_adjustment_get_value (const_cast(a)) + / gtk_adjustment_get_upper (const_cast(a)); + return val; +} + +void ColorScales::setScaled( GtkAdjustment *a, gfloat v ) +{ + gfloat val = v * gtk_adjustment_get_upper (a); + gtk_adjustment_set_value( a, val ); +} + +void ColorScales::_setRangeLimit( gdouble upper ) +{ + _rangeLimit = upper; + for ( gint i = 0; i < static_cast(G_N_ELEMENTS(_a)); i++ ) { + gtk_adjustment_set_upper (_a[i], upper); + gtk_adjustment_changed( _a[i] ); + } +} + +void ColorScales::_colorChanged() +{ +#ifdef DUMP_CHANGE_INFO + g_message("ColorScales::_colorChanged( this=%p, %f, %f, %f, %f)", this, _color.v.c[0], _color.v.c[1], _color.v.c[2], _alpha ); +#endif + gfloat tmp[3]; + gfloat c[5] = {0.0, 0.0, 0.0, 0.0}; + + switch (_mode) { + case SP_COLOR_SCALES_MODE_RGB: + sp_color_get_rgb_floatv( &_color, c ); + c[3] = _alpha; + c[4] = 0.0; + break; + case SP_COLOR_SCALES_MODE_HSV: + sp_color_get_rgb_floatv( &_color, tmp ); + sp_color_rgb_to_hsl_floatv (c, tmp[0], tmp[1], tmp[2]); + c[3] = _alpha; + c[4] = 0.0; + break; + case SP_COLOR_SCALES_MODE_CMYK: + sp_color_get_cmyk_floatv( &_color, c ); + c[4] = _alpha; + break; + default: + g_warning ("file %s: line %d: Illegal color selector mode %d", __FILE__, __LINE__, _mode); + break; + } + + _updating = TRUE; + setScaled( _a[0], c[0] ); + setScaled( _a[1], c[1] ); + setScaled( _a[2], c[2] ); + setScaled( _a[3], c[3] ); + setScaled( _a[4], c[4] ); + _updateSliders( CSC_CHANNELS_ALL ); + _updating = FALSE; +} + +void ColorScales::_getRgbaFloatv( gfloat *rgba ) +{ + g_return_if_fail (rgba != NULL); + + switch (_mode) { + case SP_COLOR_SCALES_MODE_RGB: + rgba[0] = getScaled(_a[0]); + rgba[1] = getScaled(_a[1]); + rgba[2] = getScaled(_a[2]); + rgba[3] = getScaled(_a[3]); + break; + case SP_COLOR_SCALES_MODE_HSV: + sp_color_hsl_to_rgb_floatv (rgba, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2])); + rgba[3] = getScaled(_a[3]); + break; + case SP_COLOR_SCALES_MODE_CMYK: + sp_color_cmyk_to_rgb_floatv (rgba, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3])); + rgba[3] = getScaled(_a[4]); + break; + default: + g_warning ("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__); + break; + } +} + +void ColorScales::_getCmykaFloatv( gfloat *cmyka ) +{ + gfloat rgb[3]; + + g_return_if_fail (cmyka != NULL); + + switch (_mode) { + case SP_COLOR_SCALES_MODE_RGB: + sp_color_rgb_to_cmyk_floatv (cmyka, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2])); + cmyka[4] = getScaled(_a[3]); + break; + case SP_COLOR_SCALES_MODE_HSV: + sp_color_hsl_to_rgb_floatv (rgb, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2])); + sp_color_rgb_to_cmyk_floatv (cmyka, rgb[0], rgb[1], rgb[2]); + cmyka[4] = getScaled(_a[3]); + break; + case SP_COLOR_SCALES_MODE_CMYK: + cmyka[0] = getScaled(_a[0]); + cmyka[1] = getScaled(_a[1]); + cmyka[2] = getScaled(_a[2]); + cmyka[3] = getScaled(_a[3]); + cmyka[4] = getScaled(_a[4]); + break; + default: + g_warning ("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__); + break; + } +} + +guint32 ColorScales::_getRgba32() +{ + gfloat c[4]; + guint32 rgba; + + _getRgbaFloatv(c); + + rgba = SP_RGBA32_F_COMPOSE (c[0], c[1], c[2], c[3]); + + return rgba; +} + +void ColorScales::setMode(SPColorScalesMode mode) +{ + gfloat rgba[4]; + gfloat c[4]; + + if (_mode == mode) return; + + if ((_mode == SP_COLOR_SCALES_MODE_RGB) || + (_mode == SP_COLOR_SCALES_MODE_HSV) || + (_mode == SP_COLOR_SCALES_MODE_CMYK)) { + _getRgbaFloatv(rgba); + } else { + rgba[0] = rgba[1] = rgba[2] = rgba[3] = 1.0; + } + + _mode = mode; + + switch (mode) { + case SP_COLOR_SCALES_MODE_RGB: + _setRangeLimit(255.0); + gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[0]), _("_R:")); + _s[0]->set_tooltip_text(_("Red")); + gtk_widget_set_tooltip_text (_b[0], _("Red")); + gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[1]), _("_G:")); + _s[1]->set_tooltip_text(_("Green")); + gtk_widget_set_tooltip_text (_b[1], _("Green")); + gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[2]), _("_B:")); + _s[2]->set_tooltip_text(_("Blue")); + gtk_widget_set_tooltip_text (_b[2], _("Blue")); + gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[3]), _("_A:")); + _s[3]->set_tooltip_text(_("Alpha (opacity)")); + gtk_widget_set_tooltip_text (_b[3], _("Alpha (opacity)")); + _s[0]->setMap(NULL); + gtk_widget_hide (_l[4]); + _s[4]->hide(); + gtk_widget_hide (_b[4]); + _updating = TRUE; + setScaled( _a[0], rgba[0] ); + setScaled( _a[1], rgba[1] ); + setScaled( _a[2], rgba[2] ); + setScaled( _a[3], rgba[3] ); + _updating = FALSE; + _updateSliders( CSC_CHANNELS_ALL ); + break; + case SP_COLOR_SCALES_MODE_HSV: + _setRangeLimit(255.0); + gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[0]), _("_H:")); + _s[0]->set_tooltip_text(_("Hue")); + gtk_widget_set_tooltip_text (_b[0], _("Hue")); + gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[1]), _("_S:")); + _s[1]->set_tooltip_text(_("Saturation")); + gtk_widget_set_tooltip_text (_b[1], _("Saturation")); + gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[2]), _("_L:")); + _s[2]->set_tooltip_text(_("Lightness")); + gtk_widget_set_tooltip_text (_b[2], _("Lightness")); + gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[3]), _("_A:")); + _s[3]->set_tooltip_text(_("Alpha (opacity)")); + gtk_widget_set_tooltip_text (_b[3], _("Alpha (opacity)")); + _s[0]->setMap((guchar *)(sp_color_scales_hue_map())); + gtk_widget_hide (_l[4]); + _s[4]->hide(); + gtk_widget_hide (_b[4]); + _updating = TRUE; + c[0] = 0.0; + sp_color_rgb_to_hsl_floatv (c, rgba[0], rgba[1], rgba[2]); + setScaled( _a[0], c[0] ); + setScaled( _a[1], c[1] ); + setScaled( _a[2], c[2] ); + setScaled( _a[3], rgba[3] ); + _updating = FALSE; + _updateSliders( CSC_CHANNELS_ALL ); + break; + case SP_COLOR_SCALES_MODE_CMYK: + _setRangeLimit(100.0); + gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[0]), _("_C:")); + _s[0]->set_tooltip_text(_("Cyan")); + gtk_widget_set_tooltip_text (_b[0], _("Cyan")); + gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[1]), _("_M:")); + _s[1]->set_tooltip_text(_("Magenta")); + gtk_widget_set_tooltip_text (_b[1], _("Magenta")); + gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[2]), _("_Y:")); + _s[2]->set_tooltip_text(_("Yellow")); + gtk_widget_set_tooltip_text (_b[2], _("Yellow")); + gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[3]), _("_K:")); + _s[3]->set_tooltip_text(_("Black")); + gtk_widget_set_tooltip_text (_b[3], _("Black")); + gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[4]), _("_A:")); + _s[4]->set_tooltip_text(_("Alpha (opacity)")); + gtk_widget_set_tooltip_text (_b[4], _("Alpha (opacity)")); + _s[0]->setMap(NULL); + gtk_widget_show (_l[4]); + _s[4]->show(); + gtk_widget_show (_b[4]); + _updating = TRUE; + + sp_color_rgb_to_cmyk_floatv (c, rgba[0], rgba[1], rgba[2]); + setScaled( _a[0], c[0] ); + setScaled( _a[1], c[1] ); + setScaled( _a[2], c[2] ); + setScaled( _a[3], c[3] ); + + setScaled( _a[4], rgba[3] ); + _updating = FALSE; + _updateSliders( CSC_CHANNELS_ALL ); + break; + default: + g_warning ("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__); + break; + } +} + +SPColorScalesMode ColorScales::getMode() const +{ + return _mode; +} + +void ColorScales::setSubmode( guint submode ) +{ + g_return_if_fail (_csel != NULL); + g_return_if_fail (SP_IS_COLOR_SCALES (_csel)); + g_return_if_fail (submode < 3); + + switch ( submode ) + { + default: + case 0: + setMode(SP_COLOR_SCALES_MODE_RGB); + break; + case 1: + setMode(SP_COLOR_SCALES_MODE_HSV); + break; + case 2: + setMode(SP_COLOR_SCALES_MODE_CMYK); + break; + } +} + +guint ColorScales::getSubmode() const +{ + guint submode = 0; + + switch ( _mode ) + { + case SP_COLOR_SCALES_MODE_HSV: + submode = 1; + break; + case SP_COLOR_SCALES_MODE_CMYK: + submode = 2; + break; + case SP_COLOR_SCALES_MODE_RGB: + default: + submode = 0; + } + + return submode; +} + +void ColorScales::_adjustmentAnyChanged( GtkAdjustment *adjustment, SPColorScales *cs ) +{ + gint channel = GPOINTER_TO_INT (g_object_get_data(G_OBJECT (adjustment), "channel")); + + _adjustmentChanged(cs, channel); +} + +void ColorScales::_sliderAnyGrabbed() +{ + if (!_dragging) { + _dragging = TRUE; + _grabbed(); + _recalcColor( FALSE ); + } +} + +void ColorScales::_sliderAnyReleased() +{ + if (_dragging) { + _dragging = FALSE; + _released(); + _recalcColor( FALSE ); + } +} + +void ColorScales::_sliderAnyChanged() +{ + _recalcColor( TRUE ); +} + +void ColorScales::_adjustmentChanged( SPColorScales *cs, guint channel ) +{ + ColorScales* scales = static_cast(SP_COLOR_SELECTOR(cs)->base); + if (scales->_updating) return; + + scales->_updating = TRUE; + + scales->_updateSliders( (1 << channel) ); + + scales->_recalcColor (TRUE); + + scales->_updating = FALSE; +} + +void ColorScales::_updateSliders( guint channels ) +{ + gfloat rgb0[3], rgbm[3], rgb1[3]; +#ifdef SPCS_PREVIEW + guint32 rgba; +#endif + switch (_mode) { + case SP_COLOR_SCALES_MODE_RGB: + if ((channels != CSC_CHANNEL_R) && (channels != CSC_CHANNEL_A)) { + /* Update red */ + _s[0]->setColors(SP_RGBA32_F_COMPOSE (0.0, getScaled(_a[1]), getScaled(_a[2]), 1.0), + SP_RGBA32_F_COMPOSE (0.5, getScaled(_a[1]), getScaled(_a[2]), 1.0), + SP_RGBA32_F_COMPOSE (1.0, getScaled(_a[1]), getScaled(_a[2]), 1.0)); + } + if ((channels != CSC_CHANNEL_G) && (channels != CSC_CHANNEL_A)) { + /* Update green */ + _s[1]->setColors(SP_RGBA32_F_COMPOSE(getScaled(_a[0]), 0.0, getScaled(_a[2]), 1.0), + SP_RGBA32_F_COMPOSE(getScaled(_a[0]), 0.5, getScaled(_a[2]), 1.0), + SP_RGBA32_F_COMPOSE(getScaled(_a[0]), 1.0, getScaled(_a[2]), 1.0)); + } + if ((channels != CSC_CHANNEL_B) && (channels != CSC_CHANNEL_A)) { + /* Update blue */ + _s[2]->setColors(SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), 0.0, 1.0), + SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), 0.5, 1.0), + SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), 1.0, 1.0)); + } + if (channels != CSC_CHANNEL_A) { + /* Update alpha */ + _s[3]->setColors(SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 0.0), + SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 0.5), + SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 1.0)); + } + break; + case SP_COLOR_SCALES_MODE_HSV: + /* Hue is never updated */ + if ((channels != CSC_CHANNEL_S) && (channels != CSC_CHANNEL_A)) { + /* Update saturation */ + sp_color_hsl_to_rgb_floatv (rgb0, getScaled(_a[0]), 0.0, getScaled(_a[2])); + sp_color_hsl_to_rgb_floatv (rgbm, getScaled(_a[0]), 0.5, getScaled(_a[2])); + sp_color_hsl_to_rgb_floatv (rgb1, getScaled(_a[0]), 1.0, getScaled(_a[2])); + _s[1]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0), + SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0), + SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0)); + } + if ((channels != CSC_CHANNEL_V) && (channels != CSC_CHANNEL_A)) { + /* Update value */ + sp_color_hsl_to_rgb_floatv (rgb0, getScaled(_a[0]), getScaled(_a[1]), 0.0); + sp_color_hsl_to_rgb_floatv (rgbm, getScaled(_a[0]), getScaled(_a[1]), 0.5); + sp_color_hsl_to_rgb_floatv (rgb1, getScaled(_a[0]), getScaled(_a[1]), 1.0); + _s[2]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0), + SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0), + SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0)); + } + if (channels != CSC_CHANNEL_A) { + /* Update alpha */ + sp_color_hsl_to_rgb_floatv (rgb0, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2])); + _s[3]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 0.0), + SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 0.5), + SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0)); + } + break; + case SP_COLOR_SCALES_MODE_CMYK: + if ((channels != CSC_CHANNEL_C) && (channels != CSC_CHANNEL_CMYKA)) { + /* Update C */ + sp_color_cmyk_to_rgb_floatv (rgb0, 0.0, getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3])); + sp_color_cmyk_to_rgb_floatv (rgbm, 0.5, getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3])); + sp_color_cmyk_to_rgb_floatv (rgb1, 1.0, getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3])); + _s[0]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0), + SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0), + SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0)); + } + if ((channels != CSC_CHANNEL_M) && (channels != CSC_CHANNEL_CMYKA)) { + /* Update M */ + sp_color_cmyk_to_rgb_floatv (rgb0, getScaled(_a[0]), 0.0, getScaled(_a[2]), getScaled(_a[3])); + sp_color_cmyk_to_rgb_floatv (rgbm, getScaled(_a[0]), 0.5, getScaled(_a[2]), getScaled(_a[3])); + sp_color_cmyk_to_rgb_floatv (rgb1, getScaled(_a[0]), 1.0, getScaled(_a[2]), getScaled(_a[3])); + _s[1]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0), + SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0), + SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0)); + } + if ((channels != CSC_CHANNEL_Y) && (channels != CSC_CHANNEL_CMYKA)) { + /* Update Y */ + sp_color_cmyk_to_rgb_floatv (rgb0, getScaled(_a[0]), getScaled(_a[1]), 0.0, getScaled(_a[3])); + sp_color_cmyk_to_rgb_floatv (rgbm, getScaled(_a[0]), getScaled(_a[1]), 0.5, getScaled(_a[3])); + sp_color_cmyk_to_rgb_floatv (rgb1, getScaled(_a[0]), getScaled(_a[1]), 1.0, getScaled(_a[3])); + _s[2]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0), + SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0), + SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0)); + } + if ((channels != CSC_CHANNEL_K) && (channels != CSC_CHANNEL_CMYKA)) { + /* Update K */ + sp_color_cmyk_to_rgb_floatv (rgb0, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 0.0); + sp_color_cmyk_to_rgb_floatv (rgbm, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 0.5); + sp_color_cmyk_to_rgb_floatv (rgb1, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 1.0); + _s[3]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0), + SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0), + SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0)); + } + if (channels != CSC_CHANNEL_CMYKA) { + /* Update alpha */ + sp_color_cmyk_to_rgb_floatv (rgb0, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3])); + _s[4]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 0.0), + SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 0.5), + SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0)); + } + break; + default: + g_warning ("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__); + break; + } + + // Force the internal color to be updated + if ( !_updating ) + { + _recalcColor( TRUE ); + } + +#ifdef SPCS_PREVIEW + rgba = sp_color_scales_get_rgba32 (cs); + sp_color_preview_set_rgba32 (SP_COLOR_PREVIEW (_p), rgba); +#endif +} + +static const gchar * +sp_color_scales_hue_map (void) +{ + static gchar *map = NULL; + + if (!map) { + gchar *p; + gint h; + map = g_new (gchar, 4 * 1024); + p = map; + for (h = 0; h < 1024; h++) { + gfloat rgb[3]; + sp_color_hsl_to_rgb_floatv (rgb, h / 1024.0, 1.0, 0.5); + *p++ = SP_COLOR_F_TO_U (rgb[0]); + *p++ = SP_COLOR_F_TO_U (rgb[1]); + *p++ = SP_COLOR_F_TO_U (rgb[2]); + *p++ = 255; + } + } + + return map; +} + +ColorScalesFactory::ColorScalesFactory(SPColorScalesMode submode) + : _submode(submode) +{ +} + +ColorScalesFactory::~ColorScalesFactory() { +} + +Gtk::Widget *ColorScalesFactory::createWidget(Inkscape::UI::SelectedColor &color) const { + GtkWidget *w = sp_color_selector_new(SP_TYPE_COLOR_SCALES); + SPColorSelector* csel; + + csel = SP_COLOR_SELECTOR (w); + if ( _submode > 0 ) + { + csel->base->setSubmode( _submode - 1 ); + } + + Gtk::Widget *wrapped = Gtk::manage(Glib::wrap(w)); + return wrapped; +} + +Glib::ustring ColorScalesFactory::modeName() const { + return gettext(ColorScales::SUBMODE_NAMES[_submode]); +} diff --git a/src/ui/widget/color-scales.h b/src/ui/widget/color-scales.h new file mode 100644 index 000000000..946f0935e --- /dev/null +++ b/src/ui/widget/color-scales.h @@ -0,0 +1,139 @@ +#ifndef SEEN_SP_COLOR_SCALES_H +#define SEEN_SP_COLOR_SCALES_H + +#ifdef HAVE_CONFIG_H +# include +#endif + +#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H +#include +#endif + +#include +#include + +#include +#include + +#include "ui/selected-color.h" + +struct SPColorScales; +struct SPColorScalesClass; + +namespace Inkscape { +namespace UI { +namespace Widget { + +class ColorSlider; + +} +} +} + +typedef enum { + SP_COLOR_SCALES_MODE_NONE = 0, + SP_COLOR_SCALES_MODE_RGB = 1, + SP_COLOR_SCALES_MODE_HSV = 2, + SP_COLOR_SCALES_MODE_CMYK = 3 +} SPColorScalesMode; + + + +class ColorScales: public ColorSelector +{ +public: + static const gchar* SUBMODE_NAMES[]; + + static gfloat getScaled( const GtkAdjustment *a ); + static void setScaled( GtkAdjustment *a, gfloat v); + + ColorScales(SPColorSelector *csel); + virtual ~ColorScales(); + + virtual void init(); + + virtual void setSubmode(guint submode); + virtual guint getSubmode() const; + + void setMode(SPColorScalesMode mode); + SPColorScalesMode getMode() const; + + +protected: + virtual void _colorChanged(); + + static void _adjustmentAnyChanged(GtkAdjustment *adjustment, SPColorScales *cs); + void _sliderAnyGrabbed(); + void _sliderAnyReleased(); + void _sliderAnyChanged(); + static void _adjustmentChanged(SPColorScales *cs, guint channel); + + void _getRgbaFloatv(gfloat *rgba); + void _getCmykaFloatv(gfloat *cmyka); + guint32 _getRgba32(); + void _updateSliders(guint channels); + void _recalcColor(gboolean changing); + + void _setRangeLimit( gdouble upper ); + + SPColorScalesMode _mode; + gdouble _rangeLimit; + gboolean _updating : 1; + gboolean _dragging : 1; + GtkAdjustment *_a[5]; /* Channel adjustments */ + Inkscape::UI::Widget::ColorSlider *_s[5]; /* Channel sliders */ + GtkWidget *_b[5]; /* Spinbuttons */ + GtkWidget *_l[5]; /* Labels */ + +private: + // By default, disallow copy constructor and assignment operator + ColorScales(ColorScales const &obj); + ColorScales &operator=(ColorScales const &obj ); +}; + + + +#define SP_TYPE_COLOR_SCALES (sp_color_scales_get_type()) +#define SP_COLOR_SCALES(o) (G_TYPE_CHECK_INSTANCE_CAST((o), SP_TYPE_COLOR_SCALES, SPColorScales)) +#define SP_COLOR_SCALES_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), SP_TYPE_COLOR_SCALES, SPColorScalesClass)) +#define SP_IS_COLOR_SCALES(o) (G_TYPE_CHECK_INSTANCE_TYPE((o), SP_TYPE_COLOR_SCALES)) +#define SP_IS_COLOR_SCALES_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE((k), SP_TYPE_COLOR_SCALES)) + +struct SPColorScales { + SPColorSelector parent; +}; + +struct SPColorScalesClass { + SPColorSelectorClass parent_class; +}; + +GType sp_color_scales_get_type(); + +GtkWidget *sp_color_scales_new(); + + +class ColorScalesFactory: public Inkscape::UI::ColorSelectorFactory { +public: + ColorScalesFactory(SPColorScalesMode submode); + ~ColorScalesFactory(); + + Gtk::Widget *createWidget(Inkscape::UI::SelectedColor &color) const; + Glib::ustring modeName() const; + +private: + SPColorScalesMode _submode; +}; + + +#endif /* !SEEN_SP_COLOR_SCALES_H */ + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 : diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index 711942e28..ad9662c6c 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -28,7 +28,7 @@ #include #endif -#include "widgets/sp-color-scales.h" +#include "ui/widget/color-scales.h" #include "preferences.h" static const gint SLIDER_WIDTH = 96; diff --git a/src/ui/widget/color-wheel-selector.cpp b/src/ui/widget/color-wheel-selector.cpp index e49e4ba16..4bf40dbb6 100644 --- a/src/ui/widget/color-wheel-selector.cpp +++ b/src/ui/widget/color-wheel-selector.cpp @@ -11,9 +11,9 @@ #include #include #include "dialogs/dialog-events.h" -#include "widgets/sp-color-scales.h" #include "svg/svg-icc-color.h" #include "ui/selected-color.h" +#include "ui/widget/color-scales.h" #include "ui/widget/color-slider.h" #include "ui/widget/gimpcolorwheel.h" -- cgit v1.2.3 From 0debbafdabda818d9f9a971be6cd225c50e51d1a Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 31 May 2014 15:12:26 +0200 Subject: updated CMakeLists (bzr r13341.6.39) --- src/ui/CMakeLists.txt | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'src/ui') diff --git a/src/ui/CMakeLists.txt b/src/ui/CMakeLists.txt index 883ba3427..65e93f1b0 100644 --- a/src/ui/CMakeLists.txt +++ b/src/ui/CMakeLists.txt @@ -3,6 +3,7 @@ set(ui_SRC clipboard.cpp control-manager.cpp previewholder.cpp + selected-color.cpp uxmanager.cpp cache/svg_preview_cache.cpp @@ -107,9 +108,12 @@ set(ui_SRC widget/anchor-selector.cpp widget/button.cpp + widget/color-entry.cpp widget/color-picker.cpp widget/color-preview.cpp + widget/color-scales.cpp widget/color-slider.cpp + widget/color-wheel-selector.cpp widget/dock-item.cpp widget/dock.cpp widget/entity-entry.cpp @@ -160,6 +164,7 @@ set(ui_SRC previewable.h previewfillable.h previewholder.h + selected-color.h uxmanager.h cache/svg_preview_cache.h @@ -269,9 +274,12 @@ set(ui_SRC widget/anchor-selector.h widget/attr-widget.h widget/button.h + widget/color-entry.h widget/color-picker.h widget/color-preview.h + widget/color-scales.h widget/color-slider.h + widget/color-wheel-selector.h widget/combo-enums.h widget/dock-item.h widget/dock.h -- cgit v1.2.3 From d128fc4fd60ebcd8ac820f584b5a4b3b35ad5b00 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 31 May 2014 20:15:08 +0200 Subject: SPColorScales c++-sification - using SelectedColor (bzr r13341.6.40) --- src/ui/widget/color-scales.cpp | 253 ++++++++++++----------------------------- src/ui/widget/color-scales.h | 63 ++++------ 2 files changed, 92 insertions(+), 224 deletions(-) (limited to 'src/ui') diff --git a/src/ui/widget/color-scales.cpp b/src/ui/widget/color-scales.cpp index bba44034a..234e7a2d1 100644 --- a/src/ui/widget/color-scales.cpp +++ b/src/ui/widget/color-scales.cpp @@ -32,27 +32,18 @@ #define CSC_CHANNELS_ALL 0 - -G_BEGIN_DECLS - -static void sp_color_scales_class_init (SPColorScalesClass *klass); -static void sp_color_scales_init (SPColorScales *cs); -static void sp_color_scales_dispose(GObject *object); - -static void sp_color_scales_show_all (GtkWidget *widget); -static void sp_color_scales_hide(GtkWidget *widget); - -static const gchar *sp_color_scales_hue_map (void); - -G_END_DECLS - -static SPColorSelectorClass *parent_class; - #define XPAD 4 #define YPAD 1 #define noDUMP_CHANGE_INFO 1 +namespace Inkscape { +namespace UI { +namespace Widget { + + +static const gchar * sp_color_scales_hue_map (); + const gchar* ColorScales::SUBMODE_NAMES[] = { N_("None"), N_("RGB"), @@ -60,54 +51,14 @@ const gchar* ColorScales::SUBMODE_NAMES[] = { N_("CMYK") }; -GType -sp_color_scales_get_type (void) -{ - static GType type = 0; - if (!type) { - static const GTypeInfo info = { - sizeof (SPColorScalesClass), - NULL, /* base_init */ - NULL, /* base_finalize */ - (GClassInitFunc) sp_color_scales_class_init, - NULL, /* class_finalize */ - NULL, /* class_data */ - sizeof (SPColorScales), - 0, /* n_preallocs */ - (GInstanceInitFunc) sp_color_scales_init, - NULL - }; - - type = g_type_register_static (SP_TYPE_COLOR_SELECTOR, - "SPColorScales", - &info, - static_cast< GTypeFlags > (0) ); - } - return type; -} - -static void -sp_color_scales_class_init (SPColorScalesClass *klass) -{ - static const gchar* nameset[] = {N_("RGB"), N_("HSL"), N_("CMYK"), 0}; - GObjectClass *object_class = G_OBJECT_CLASS(klass); - GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass); - SPColorSelectorClass *selector_class = SP_COLOR_SELECTOR_CLASS (klass); - - parent_class = SP_COLOR_SELECTOR_CLASS (g_type_class_peek_parent (klass)); - - selector_class->name = nameset; - selector_class->submode_count = 3; - - object_class->dispose = sp_color_scales_dispose; - - widget_class->show_all = sp_color_scales_show_all; - widget_class->hide = sp_color_scales_hide; -} - -ColorScales::ColorScales( SPColorSelector* csel ) - : ColorSelector( csel ), - _mode( SP_COLOR_SCALES_MODE_NONE ), +ColorScales::ColorScales(SelectedColor &color, SPColorScalesMode mode) +#if GTK_CHECK_VERSION(3,0,0) + : Gtk::Grid() +#else + : Gtk::Table(5, 3, false) +#endif + , _color(color) + , _rangeLimit( 255.0 ), _updating( FALSE ), _dragging( FALSE ) @@ -118,6 +69,12 @@ ColorScales::ColorScales( SPColorSelector* csel ) _s[i] = 0; _b[i] = 0; } + + _initUI(mode); + + _color.signal_changed.connect(sigc::mem_fun(this, &ColorScales::_onColorChanged)); + _color.signal_dragged.connect(sigc::mem_fun(this, &ColorScales::_onColorChanged)); + } ColorScales::~ColorScales() @@ -130,30 +87,14 @@ ColorScales::~ColorScales() } } -void sp_color_scales_init (SPColorScales *cs) -{ - SP_COLOR_SELECTOR(cs)->base = new ColorScales( SP_COLOR_SELECTOR(cs) ); - - if ( SP_COLOR_SELECTOR(cs)->base ) - { - SP_COLOR_SELECTOR(cs)->base->init(); - } -} - -void ColorScales::init() +void ColorScales::_initUI(SPColorScalesMode mode) { gint i; _updating = FALSE; _dragging = FALSE; -#if GTK_CHECK_VERSION(3,0,0) - GtkWidget *t = gtk_grid_new(); -#else - GtkWidget *t = gtk_table_new (5, 3, FALSE); -#endif - gtk_widget_show (t); - gtk_box_pack_start (GTK_BOX (_csel), t, TRUE, TRUE, 4); + GtkWidget *t = GTK_WIDGET(gobj()); /* Create components */ for (i = 0; i < static_cast< gint > (G_N_ELEMENTS(_a)) ; i++) { @@ -211,42 +152,23 @@ void ColorScales::init() g_object_set_data (G_OBJECT (_a[i]), "channel", GINT_TO_POINTER (i)); /* Signals */ g_signal_connect (G_OBJECT (_a[i]), "value_changed", - G_CALLBACK (_adjustmentAnyChanged), _csel); + G_CALLBACK (_adjustmentAnyChanged), this); _s[i]->signal_grabbed.connect(sigc::mem_fun(this, &ColorScales::_sliderAnyGrabbed)); _s[i]->signal_released.connect(sigc::mem_fun(this, &ColorScales::_sliderAnyReleased)); _s[i]->signal_value_changed.connect(sigc::mem_fun(this, &ColorScales::_sliderAnyChanged)); } /* Initial mode is none, so it works */ - setMode(SP_COLOR_SCALES_MODE_RGB); -} - -static void sp_color_scales_dispose(GObject *object) -{ - if ((G_OBJECT_CLASS(parent_class))->dispose) - (* (G_OBJECT_CLASS(parent_class))->dispose) (object); -} - -static void -sp_color_scales_show_all (GtkWidget *widget) -{ - gtk_widget_show (widget); -} - -static void sp_color_scales_hide(GtkWidget *widget) -{ - gtk_widget_hide(widget); -} - -GtkWidget *sp_color_scales_new() -{ - SPColorScales *csel = SP_COLOR_SCALES(g_object_new (SP_TYPE_COLOR_SCALES, NULL)); - - return GTK_WIDGET (csel); + setMode(mode); } void ColorScales::_recalcColor( gboolean changing ) { + if (_updating) { + return; + } + _updating = true; + if ( changing ) { SPColor color; @@ -275,15 +197,14 @@ void ColorScales::_recalcColor( gboolean changing ) break; } - /* Preserve ICC */ - color.icc = _color.icc ? new SVGICCColor(*_color.icc) : 0; - - _updateInternals( color, alpha, _dragging ); + _color.preserveICC(); + _color.setColorAlpha(color, alpha, true); } else { - _updateInternals( _color, _alpha, _dragging ); + // _updateInternals( _color, _alpha, _dragging ); } + _updating = false; } /* Helpers for setting color value */ @@ -309,29 +230,34 @@ void ColorScales::_setRangeLimit( gdouble upper ) } } -void ColorScales::_colorChanged() +void ColorScales::_onColorChanged() { + if (_updating || !get_visible()) { + return; + } #ifdef DUMP_CHANGE_INFO - g_message("ColorScales::_colorChanged( this=%p, %f, %f, %f, %f)", this, _color.v.c[0], _color.v.c[1], _color.v.c[2], _alpha ); + g_message("ColorScales::_onColorChanged( this=%p, %f, %f, %f, %f)", this, _color.color().v.c[0], _color.color().v.c[1], _color.color().v.c[2], _color.alpha() ); #endif gfloat tmp[3]; gfloat c[5] = {0.0, 0.0, 0.0, 0.0}; + SPColor color = _color.color(); + switch (_mode) { case SP_COLOR_SCALES_MODE_RGB: - sp_color_get_rgb_floatv( &_color, c ); - c[3] = _alpha; + sp_color_get_rgb_floatv( &color, c ); + c[3] = _color.alpha(); c[4] = 0.0; break; case SP_COLOR_SCALES_MODE_HSV: - sp_color_get_rgb_floatv( &_color, tmp ); + sp_color_get_rgb_floatv( &color, tmp ); sp_color_rgb_to_hsl_floatv (c, tmp[0], tmp[1], tmp[2]); - c[3] = _alpha; + c[3] = _color.alpha(); c[4] = 0.0; break; case SP_COLOR_SCALES_MODE_CMYK: - sp_color_get_cmyk_floatv( &_color, c ); - c[4] = _alpha; + sp_color_get_cmyk_floatv( &color, c ); + c[4] = _color.alpha(); break; default: g_warning ("file %s: line %d: Illegal color selector mode %d", __FILE__, __LINE__, _mode); @@ -530,48 +456,7 @@ SPColorScalesMode ColorScales::getMode() const return _mode; } -void ColorScales::setSubmode( guint submode ) -{ - g_return_if_fail (_csel != NULL); - g_return_if_fail (SP_IS_COLOR_SCALES (_csel)); - g_return_if_fail (submode < 3); - - switch ( submode ) - { - default: - case 0: - setMode(SP_COLOR_SCALES_MODE_RGB); - break; - case 1: - setMode(SP_COLOR_SCALES_MODE_HSV); - break; - case 2: - setMode(SP_COLOR_SCALES_MODE_CMYK); - break; - } -} - -guint ColorScales::getSubmode() const -{ - guint submode = 0; - - switch ( _mode ) - { - case SP_COLOR_SCALES_MODE_HSV: - submode = 1; - break; - case SP_COLOR_SCALES_MODE_CMYK: - submode = 2; - break; - case SP_COLOR_SCALES_MODE_RGB: - default: - submode = 0; - } - - return submode; -} - -void ColorScales::_adjustmentAnyChanged( GtkAdjustment *adjustment, SPColorScales *cs ) +void ColorScales::_adjustmentAnyChanged( GtkAdjustment *adjustment, ColorScales *cs ) { gint channel = GPOINTER_TO_INT (g_object_get_data(G_OBJECT (adjustment), "channel")); @@ -580,39 +465,46 @@ void ColorScales::_adjustmentAnyChanged( GtkAdjustment *adjustment, SPColorScale void ColorScales::_sliderAnyGrabbed() { + if (_updating) { + return; + } + _updating = true; if (!_dragging) { _dragging = TRUE; - _grabbed(); + _color.setHeld(true); _recalcColor( FALSE ); } + _updating = false; } void ColorScales::_sliderAnyReleased() { + if (_updating) { + return; + } + _updating = true; if (_dragging) { _dragging = FALSE; - _released(); + _color.setHeld(false); _recalcColor( FALSE ); } + _updating = false; } void ColorScales::_sliderAnyChanged() { + if (_updating) { + return; + } _recalcColor( TRUE ); } -void ColorScales::_adjustmentChanged( SPColorScales *cs, guint channel ) +void ColorScales::_adjustmentChanged( ColorScales *scales, guint channel ) { - ColorScales* scales = static_cast(SP_COLOR_SELECTOR(cs)->base); if (scales->_updating) return; - scales->_updating = TRUE; - scales->_updateSliders( (1 << channel) ); - scales->_recalcColor (TRUE); - - scales->_updating = FALSE; } void ColorScales::_updateSliders( guint channels ) @@ -770,19 +662,14 @@ ColorScalesFactory::~ColorScalesFactory() { } Gtk::Widget *ColorScalesFactory::createWidget(Inkscape::UI::SelectedColor &color) const { - GtkWidget *w = sp_color_selector_new(SP_TYPE_COLOR_SCALES); - SPColorSelector* csel; - - csel = SP_COLOR_SELECTOR (w); - if ( _submode > 0 ) - { - csel->base->setSubmode( _submode - 1 ); - } - - Gtk::Widget *wrapped = Gtk::manage(Glib::wrap(w)); - return wrapped; + Gtk::Widget *w = Gtk::manage(new ColorScales(color, _submode)); + return w; } Glib::ustring ColorScalesFactory::modeName() const { return gettext(ColorScales::SUBMODE_NAMES[_submode]); } + +} +} +} diff --git a/src/ui/widget/color-scales.h b/src/ui/widget/color-scales.h index 946f0935e..21f9708c1 100644 --- a/src/ui/widget/color-scales.h +++ b/src/ui/widget/color-scales.h @@ -9,26 +9,23 @@ #include #endif +#include #include #include - -#include -#include +#if GTK_CHECK_VERSION(3,0,0) +#include +#else +#include +#endif #include "ui/selected-color.h" -struct SPColorScales; -struct SPColorScalesClass; - namespace Inkscape { namespace UI { namespace Widget { class ColorSlider; -} -} -} typedef enum { SP_COLOR_SCALES_MODE_NONE = 0, @@ -39,7 +36,12 @@ typedef enum { -class ColorScales: public ColorSelector +class ColorScales +#if GTK_CHECK_VERSION(3,0,0) + : public Gtk::Grid +#else + : public Gtk::Table +#endif { public: static const gchar* SUBMODE_NAMES[]; @@ -47,26 +49,22 @@ public: static gfloat getScaled( const GtkAdjustment *a ); static void setScaled( GtkAdjustment *a, gfloat v); - ColorScales(SPColorSelector *csel); + ColorScales(SelectedColor &color, SPColorScalesMode mode); virtual ~ColorScales(); - virtual void init(); - - virtual void setSubmode(guint submode); - virtual guint getSubmode() const; + virtual void _initUI(SPColorScalesMode mode); void setMode(SPColorScalesMode mode); SPColorScalesMode getMode() const; - protected: - virtual void _colorChanged(); + void _onColorChanged(); - static void _adjustmentAnyChanged(GtkAdjustment *adjustment, SPColorScales *cs); + static void _adjustmentAnyChanged(GtkAdjustment *adjustment, ColorScales *cs); void _sliderAnyGrabbed(); void _sliderAnyReleased(); void _sliderAnyChanged(); - static void _adjustmentChanged(SPColorScales *cs, guint channel); + static void _adjustmentChanged(ColorScales *cs, guint channel); void _getRgbaFloatv(gfloat *rgba); void _getCmykaFloatv(gfloat *cmyka); @@ -76,6 +74,7 @@ protected: void _setRangeLimit( gdouble upper ); + SelectedColor &_color; SPColorScalesMode _mode; gdouble _rangeLimit; gboolean _updating : 1; @@ -92,26 +91,6 @@ private: }; - -#define SP_TYPE_COLOR_SCALES (sp_color_scales_get_type()) -#define SP_COLOR_SCALES(o) (G_TYPE_CHECK_INSTANCE_CAST((o), SP_TYPE_COLOR_SCALES, SPColorScales)) -#define SP_COLOR_SCALES_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), SP_TYPE_COLOR_SCALES, SPColorScalesClass)) -#define SP_IS_COLOR_SCALES(o) (G_TYPE_CHECK_INSTANCE_TYPE((o), SP_TYPE_COLOR_SCALES)) -#define SP_IS_COLOR_SCALES_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE((k), SP_TYPE_COLOR_SCALES)) - -struct SPColorScales { - SPColorSelector parent; -}; - -struct SPColorScalesClass { - SPColorSelectorClass parent_class; -}; - -GType sp_color_scales_get_type(); - -GtkWidget *sp_color_scales_new(); - - class ColorScalesFactory: public Inkscape::UI::ColorSelectorFactory { public: ColorScalesFactory(SPColorScalesMode submode); @@ -124,9 +103,11 @@ private: SPColorScalesMode _submode; }; +} +} +} -#endif /* !SEEN_SP_COLOR_SCALES_H */ - +#endif /* Local Variables: mode:c++ -- cgit v1.2.3 From e1e64d41e2a71a5e9a18b5a40803a72ad288cd53 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 31 May 2014 20:22:51 +0200 Subject: SPColorICC c++sification: moved to ui/widget/ (bzr r13341.6.41) --- src/ui/CMakeLists.txt | 2 + src/ui/widget/Makefile_insert | 2 + src/ui/widget/color-icc-selector.cpp | 1150 ++++++++++++++++++++++++++++++++++ src/ui/widget/color-icc-selector.h | 81 +++ 4 files changed, 1235 insertions(+) create mode 100644 src/ui/widget/color-icc-selector.cpp create mode 100644 src/ui/widget/color-icc-selector.h (limited to 'src/ui') diff --git a/src/ui/CMakeLists.txt b/src/ui/CMakeLists.txt index 65e93f1b0..dbfba0508 100644 --- a/src/ui/CMakeLists.txt +++ b/src/ui/CMakeLists.txt @@ -109,6 +109,7 @@ set(ui_SRC widget/anchor-selector.cpp widget/button.cpp widget/color-entry.cpp + widget/color-icc-selector.cpp widget/color-picker.cpp widget/color-preview.cpp widget/color-scales.cpp @@ -275,6 +276,7 @@ set(ui_SRC widget/attr-widget.h widget/button.h widget/color-entry.h + widget/color-icc-selector.h widget/color-picker.h widget/color-preview.h widget/color-scales.h diff --git a/src/ui/widget/Makefile_insert b/src/ui/widget/Makefile_insert index 039e2a8d9..f39236da7 100644 --- a/src/ui/widget/Makefile_insert +++ b/src/ui/widget/Makefile_insert @@ -8,6 +8,8 @@ ink_common_sources += \ ui/widget/button.cpp \ ui/widget/color-entry.cpp \ ui/widget/color-entry.h \ + ui/widget/color-icc-selector.cpp \ + ui/widget/color-icc-selector.h \ ui/widget/color-wheel-selector.cpp \ ui/widget/color-wheel-selector.h \ ui/widget/color-picker.cpp \ diff --git a/src/ui/widget/color-icc-selector.cpp b/src/ui/widget/color-icc-selector.cpp new file mode 100644 index 000000000..74e63f320 --- /dev/null +++ b/src/ui/widget/color-icc-selector.cpp @@ -0,0 +1,1150 @@ +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "widgets/gradient-vector.h" +#include +#include +#include +#include +#include +#include + +#include "dialogs/dialog-events.h" +#include "ui/widget/color-icc-selector.h" +#include "ui/widget/color-scales.h" +#include "ui/widget/color-slider.h" +#include "svg/svg-icc-color.h" +#include "colorspace.h" +#include "document.h" +#include "inkscape.h" +#include "profile-manager.h" + +#define noDEBUG_LCMS + +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) +#include "color-profile.h" +#include "cms-system.h" +#include "color-profile-cms-fns.h" + +#ifdef DEBUG_LCMS +#include "preferences.h" +#endif // DEBUG_LCMS +#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + + +using namespace Inkscape::UI::Widget; + + +#ifdef DEBUG_LCMS +extern guint update_in_progress; +#define DEBUG_MESSAGE(key, ...) \ +{\ + Inkscape::Preferences *prefs = Inkscape::Preferences::get();\ + bool dump = prefs->getBool("/options/scislac/" #key);\ + bool dumpD = prefs->getBool("/options/scislac/" #key "D");\ + bool dumpD2 = prefs->getBool("/options/scislac/" #key "D2");\ + dumpD &&= ( (update_in_progress == 0) || dumpD2 );\ + if ( dump )\ + {\ + g_message( __VA_ARGS__ );\ +\ + }\ + if ( dumpD )\ + {\ + GtkWidget *dialog = gtk_message_dialog_new(NULL,\ + GTK_DIALOG_DESTROY_WITH_PARENT, \ + GTK_MESSAGE_INFO, \ + GTK_BUTTONS_OK, \ + __VA_ARGS__ \ + );\ + g_signal_connect_swapped(dialog, "response",\ + G_CALLBACK(gtk_widget_destroy), \ + dialog); \ + gtk_widget_show_all( dialog );\ + }\ +} +#endif // DEBUG_LCMS + + + +G_BEGIN_DECLS + +static void sp_color_icc_selector_class_init (SPColorICCSelectorClass *klass); +static void sp_color_icc_selector_init (SPColorICCSelector *cs); +static void sp_color_icc_selector_dispose(GObject *object); + +static void sp_color_icc_selector_show_all (GtkWidget *widget); +static void sp_color_icc_selector_hide(GtkWidget *widget); + +G_END_DECLS + +/** + * Class containing the parts for a single color component's UI presence. + */ +class ComponentUI +{ +public: + ComponentUI() : + _component(), + _adj(0), + _slider(0), + _btn(0), + _label(0), + _map(0) + { + } + + ComponentUI(colorspace::Component const &component) : + _component(component), + _adj(0), + _slider(0), + _btn(0), + _label(0), + _map(0) + { + } + + colorspace::Component _component; + GtkAdjustment *_adj; // Component adjustment + Inkscape::UI::Widget::ColorSlider *_slider; + GtkWidget *_btn; // spinbutton + GtkWidget *_label; // Label + guchar *_map; +}; + +/** + * Class that implements the internals of the selector. + */ +class ColorICCSelectorImpl +{ +public: + + ColorICCSelectorImpl( ColorICCSelector *owner); + + ~ColorICCSelectorImpl(); + + static void _adjustmentChanged ( GtkAdjustment *adjustment, SPColorICCSelector *cs ); + + void _sliderGrabbed(); + void _sliderReleased(); + void _sliderChanged(); + + static void _profileSelected( GtkWidget* src, gpointer data ); + static void _fixupHit( GtkWidget* src, gpointer data ); + +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + void _setProfile( SVGICCColor* profile ); + void _switchToProfile( gchar const* name ); +#endif + void _updateSliders( gint ignore ); + void _profilesChanged( std::string const & name ); + + ColorICCSelector *_owner; + + gboolean _updating : 1; + gboolean _dragging : 1; + + guint32 _fixupNeeded; + GtkWidget* _fixupBtn; + GtkWidget* _profileSel; + + std::vector _compUI; + + GtkAdjustment* _adj; // Channel adjustment + Inkscape::UI::Widget::ColorSlider* _slider; + GtkWidget* _sbtn; // Spinbutton + GtkWidget* _label; // Label + +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + std::string _profileName; + Inkscape::ColorProfile* _prof; + guint _profChannelCount; + gulong _profChangedID; +#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) +}; + + +static SPColorSelectorClass *parent_class; + +#define XPAD 4 +#define YPAD 1 + +namespace +{ + +size_t maxColorspaceComponentCount = 0; + +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + +/** + * Internal variable to track all known colorspaces. + */ +std::set knownColorspaces; + +#endif + + +/** + * Simple helper to allow bitwise or on GtkAttachOptions. + */ +GtkAttachOptions operator|(GtkAttachOptions lhs, GtkAttachOptions rhs) +{ + return static_cast(static_cast(lhs) | static_cast(rhs)); +} + +/** + * Helper function to handle GTK2/GTK3 attachment #ifdef code. + */ +void attachToGridOrTable(GtkWidget *parent, + GtkWidget *child, + guint left, + guint top, + guint width, + guint height, + bool hexpand = false, + bool centered = false, + guint xpadding = XPAD, + guint ypadding = YPAD) +{ +#if GTK_CHECK_VERSION(3,0,0) + gtk_widget_set_margin_left( child, xpadding ); + gtk_widget_set_margin_right( child, xpadding ); + gtk_widget_set_margin_top( child, ypadding ); + gtk_widget_set_margin_bottom( child, ypadding ); + if (hexpand) { + gtk_widget_set_hexpand(child, TRUE); + } + if (centered) { + gtk_widget_set_halign( child, GTK_ALIGN_CENTER ); + gtk_widget_set_valign( child, GTK_ALIGN_CENTER ); + } + gtk_grid_attach( GTK_GRID(parent), child, left, top, width, height ); +#else + GtkAttachOptions xoptions = centered ? static_cast(0) : hexpand ? (GTK_EXPAND | GTK_FILL) : GTK_FILL; + GtkAttachOptions yoptions = centered ? static_cast(0) : GTK_FILL; + + gtk_table_attach( GTK_TABLE(parent), child, left, left + width, top, top + height, xoptions, yoptions, xpadding, ypadding ); +#endif +} + +} // namespace + +GType sp_color_icc_selector_get_type(void) +{ + static GType type = 0; + if (!type) { + static const GTypeInfo info = { + sizeof (SPColorICCSelectorClass), + NULL, // base_init + NULL, // base_finalize + (GClassInitFunc) sp_color_icc_selector_class_init, + NULL, // class_finalize + NULL, // class_data + sizeof (SPColorICCSelector), + 0, // n_preallocs + (GInstanceInitFunc) sp_color_icc_selector_init, + 0, // value_table + }; + + type = g_type_register_static (SP_TYPE_COLOR_SELECTOR, + "SPColorICCSelector", + &info, + static_cast< GTypeFlags > (0) ); + } + return type; +} + +static void sp_color_icc_selector_class_init(SPColorICCSelectorClass *klass) +{ + static const gchar* nameset[] = {N_("CMS"), 0}; + GObjectClass *object_class = G_OBJECT_CLASS(klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass); + SPColorSelectorClass *selector_class = SP_COLOR_SELECTOR_CLASS (klass); + + parent_class = SP_COLOR_SELECTOR_CLASS (g_type_class_peek_parent (klass)); + + selector_class->name = nameset; + selector_class->submode_count = 1; + + object_class->dispose = sp_color_icc_selector_dispose; + + widget_class->show_all = sp_color_icc_selector_show_all; + widget_class->hide = sp_color_icc_selector_hide; +} + +const gchar* ColorICCSelector::MODE_NAME = N_("CMS"); + +ColorICCSelector::ColorICCSelector( SPColorSelector* csel ) + : ColorSelector( csel ), + _impl(NULL) +{ +} + +ColorICCSelector::~ColorICCSelector() +{ + if (_impl) + { + delete _impl; + _impl = 0; + } +} + +void sp_color_icc_selector_init(SPColorICCSelector *cs) +{ + SP_COLOR_SELECTOR(cs)->base = new ColorICCSelector( SP_COLOR_SELECTOR(cs) ); + + if ( SP_COLOR_SELECTOR(cs)->base ) + { + SP_COLOR_SELECTOR(cs)->base->init(); + } +} + + +/* +icSigRgbData +icSigCmykData +icSigCmyData +*/ +#define SPACE_ID_RGB 0 +#define SPACE_ID_CMY 1 +#define SPACE_ID_CMYK 2 + + +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) +static cmsUInt16Number* getScratch() { + // bytes per pixel * input channels * width + static cmsUInt16Number* scritch = static_cast(g_new(cmsUInt16Number, 4 * 1024)); + + return scritch; +} + +colorspace::Component::Component() : + name(), + tip(), + scale(1) +{ +} + +colorspace::Component::Component(std::string const &name, std::string const &tip, guint scale) : + name(name), + tip(tip), + scale(scale) +{ +} + +std::vector colorspace::getColorSpaceInfo( uint32_t space ) +{ + static std::map > sets; + if (sets.empty()) + { + sets[cmsSigXYZData].push_back(Component("_X", "X", 2)); // TYPE_XYZ_16 + sets[cmsSigXYZData].push_back(Component("_Y", "Y", 1)); + sets[cmsSigXYZData].push_back(Component("_Z", "Z", 2)); + + sets[cmsSigLabData].push_back(Component("_L", "L", 100)); // TYPE_Lab_16 + sets[cmsSigLabData].push_back(Component("_a", "a", 256)); + sets[cmsSigLabData].push_back(Component("_b", "b", 256)); + + //cmsSigLuvData + + sets[cmsSigYCbCrData].push_back(Component("_Y", "Y", 1)); // TYPE_YCbCr_16 + sets[cmsSigYCbCrData].push_back(Component("C_b", "Cb", 1)); + sets[cmsSigYCbCrData].push_back(Component("C_r", "Cr", 1)); + + sets[cmsSigYxyData].push_back(Component("_Y", "Y", 1)); // TYPE_Yxy_16 + sets[cmsSigYxyData].push_back(Component("_x", "x", 1)); + sets[cmsSigYxyData].push_back(Component("y", "y", 1)); + + sets[cmsSigRgbData].push_back(Component(_("_R:"), _("Red"), 1)); // TYPE_RGB_16 + sets[cmsSigRgbData].push_back(Component(_("_G:"), _("Green"), 1)); + sets[cmsSigRgbData].push_back(Component(_("_B:"), _("Blue"), 1)); + + sets[cmsSigGrayData].push_back(Component(_("G:"), _("Gray"), 1)); // TYPE_GRAY_16 + + sets[cmsSigHsvData].push_back(Component(_("_H:"), _("Hue"), 360)); // TYPE_HSV_16 + sets[cmsSigHsvData].push_back(Component(_("_S:"), _("Saturation"), 1)); + sets[cmsSigHsvData].push_back(Component("_V:", "Value", 1)); + + sets[cmsSigHlsData].push_back(Component(_("_H:"), _("Hue"), 360)); // TYPE_HLS_16 + sets[cmsSigHlsData].push_back(Component(_("_L:"), _("Lightness"), 1)); + sets[cmsSigHlsData].push_back(Component(_("_S:"), _("Saturation"), 1)); + + sets[cmsSigCmykData].push_back(Component(_("_C:"), _("Cyan"), 1)); // TYPE_CMYK_16 + sets[cmsSigCmykData].push_back(Component(_("_M:"), _("Magenta"), 1)); + sets[cmsSigCmykData].push_back(Component(_("_Y:"), _("Yellow"), 1)); + sets[cmsSigCmykData].push_back(Component(_("_K:"), _("Black"), 1)); + + sets[cmsSigCmyData].push_back(Component(_("_C:"), _("Cyan"), 1)); // TYPE_CMY_16 + sets[cmsSigCmyData].push_back(Component(_("_M:"), _("Magenta"), 1)); + sets[cmsSigCmyData].push_back(Component(_("_Y:"), _("Yellow"), 1)); + + for (std::map >::iterator it = sets.begin(); it != sets.end(); ++it) + { + knownColorspaces.insert(it->first); + maxColorspaceComponentCount = std::max(maxColorspaceComponentCount, it->second.size()); + } + } + + std::vector target; + + if (sets.find(space) != sets.end()) + { + target = sets[space]; + } + return target; +} + + +std::vector colorspace::getColorSpaceInfo( Inkscape::ColorProfile *prof ) +{ + return getColorSpaceInfo( asICColorSpaceSig(prof->getColorSpace()) ); +} + +#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + +ColorICCSelectorImpl::ColorICCSelectorImpl(ColorICCSelector *owner) : + _owner(owner), + _updating( FALSE ), + _dragging( FALSE ), + _fixupNeeded(0), + _fixupBtn(0), + _profileSel(0), + _compUI(), + _adj(0), + _slider(0), + _sbtn(0), + _label(0) +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + , + _profileName(), + _prof(0), + _profChannelCount(0), + _profChangedID(0) +#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) +{ +} + +ColorICCSelectorImpl::~ColorICCSelectorImpl() +{ + _adj = 0; + _sbtn = 0; + _label = 0; +} + +void ColorICCSelector::init() +{ + if (_impl) delete(_impl); + _impl = new ColorICCSelectorImpl(this); + gint row = 0; + + _impl->_updating = FALSE; + _impl->_dragging = FALSE; + +#if GTK_CHECK_VERSION(3,0,0) + GtkWidget *t = gtk_grid_new(); +#else + GtkWidget *t = gtk_table_new(5, 3, FALSE); +#endif + + gtk_widget_show (t); + gtk_box_pack_start (GTK_BOX (_csel), t, TRUE, TRUE, 4); + + _impl->_compUI.clear(); + + // Create components + row = 0; + + + _impl->_fixupBtn = gtk_button_new_with_label(_("Fix")); + g_signal_connect( G_OBJECT(_impl->_fixupBtn), "clicked", G_CALLBACK(ColorICCSelectorImpl::_fixupHit), (gpointer)_impl ); + gtk_widget_set_sensitive( _impl->_fixupBtn, FALSE ); + gtk_widget_set_tooltip_text( _impl->_fixupBtn, _("Fix RGB fallback to match icc-color() value.") ); + //gtk_misc_set_alignment( GTK_MISC (_impl->_fixupBtn), 1.0, 0.5 ); + gtk_widget_show( _impl->_fixupBtn ); + + attachToGridOrTable(t, _impl->_fixupBtn, 0, row, 1, 1); + + // Combobox and store with 2 columns : label (0) and full name (1) + GtkListStore *store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING); + _impl->_profileSel = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store)); + + GtkCellRenderer *renderer = gtk_cell_renderer_text_new (); + gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(_impl->_profileSel), renderer, TRUE); + gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(_impl->_profileSel), renderer, "text", 0, NULL); + + GtkTreeIter iter; + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, &iter, 0, _(""), 1, _(""), -1); + + gtk_widget_show( _impl->_profileSel ); + gtk_combo_box_set_active( GTK_COMBO_BOX(_impl->_profileSel), 0 ); + + attachToGridOrTable(t, _impl->_profileSel, 1, row, 1, 1); + +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + _impl->_profChangedID = g_signal_connect( G_OBJECT(_impl->_profileSel), "changed", G_CALLBACK(ColorICCSelectorImpl::_profileSelected), (gpointer)_impl ); +#else + gtk_widget_set_sensitive( _impl->_profileSel, false ); +#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + + + row++; + + // populate the data for colorspaces and channels: +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + std::vector things = colorspace::getColorSpaceInfo( cmsSigRgbData ); +#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + + for ( size_t i = 0; i < maxColorspaceComponentCount; i++ ) { +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + if (i < things.size()) { + _impl->_compUI.push_back(ComponentUI(things[i])); + } else { + _impl->_compUI.push_back(ComponentUI()); + } + + std::string labelStr = (i < things.size()) ? things[i].name.c_str() : ""; +#else + _impl->_compUI.push_back(ComponentUI()); + + std::string labelStr = "."; +#endif + + _impl->_compUI[i]._label = gtk_label_new_with_mnemonic( labelStr.c_str() ); + gtk_misc_set_alignment( GTK_MISC (_impl->_compUI[i]._label), 1.0, 0.5 ); + gtk_widget_show( _impl->_compUI[i]._label ); + + attachToGridOrTable(t, _impl->_compUI[i]._label, 0, row, 1, 1); + + // Adjustment + guint scaleValue = _impl->_compUI[i]._component.scale; + gdouble step = static_cast(scaleValue) / 100.0; + gdouble page = static_cast(scaleValue) / 10.0; + gint digits = (step > 0.9) ? 0 : 2; + _impl->_compUI[i]._adj = GTK_ADJUSTMENT( gtk_adjustment_new( 0.0, 0.0, scaleValue, step, page, page ) ); + + // Slider + _impl->_compUI[i]._slider = Gtk::manage(new Inkscape::UI::Widget::ColorSlider(Glib::wrap(_impl->_compUI[i]._adj, true))); +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + _impl->_compUI[i]._slider->set_tooltip_text((i < things.size()) ? things[i].tip.c_str() : ""); +#else + _impl->_compUI[i]._slider->set_tooltip_text("."); +#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + _impl->_compUI[i]._slider->show(); + + attachToGridOrTable(t, _impl->_compUI[i]._slider->gobj(), 1, row, 1, 1, true); + + _impl->_compUI[i]._btn = gtk_spin_button_new( _impl->_compUI[i]._adj, step, digits ); +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + gtk_widget_set_tooltip_text( _impl->_compUI[i]._btn, (i < things.size()) ? things[i].tip.c_str() : "" ); +#else + gtk_widget_set_tooltip_text( _impl->_compUI[i]._btn, "." ); +#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + sp_dialog_defocus_on_enter( _impl->_compUI[i]._btn ); + gtk_label_set_mnemonic_widget( GTK_LABEL(_impl->_compUI[i]._label), _impl->_compUI[i]._btn ); + gtk_widget_show( _impl->_compUI[i]._btn ); + + attachToGridOrTable(t, _impl->_compUI[i]._btn, 2, row, 1, 1, false, true); + + _impl->_compUI[i]._map = g_new( guchar, 4 * 1024 ); + memset( _impl->_compUI[i]._map, 0x0ff, 1024 * 4 ); + + + // Signals + g_signal_connect( G_OBJECT( _impl->_compUI[i]._adj ), "value_changed", G_CALLBACK( ColorICCSelectorImpl::_adjustmentChanged ), _csel ); + + _impl->_compUI[i]._slider->signal_grabbed.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderGrabbed)); + _impl->_compUI[i]._slider->signal_released.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderReleased)); + _impl->_compUI[i]._slider->signal_value_changed.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderChanged)); + + row++; + } + + // Label + _impl->_label = gtk_label_new_with_mnemonic(_("_A:")); + gtk_misc_set_alignment(GTK_MISC(_impl->_label), 1.0, 0.5); + gtk_widget_show(_impl->_label); + + attachToGridOrTable(t, _impl->_label, 0, row, 1, 1); + + // Adjustment + _impl->_adj = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 255.0, 1.0, 10.0, 10.0)); + + // Slider + _impl->_slider = Gtk::manage(new Inkscape::UI::Widget::ColorSlider(Glib::wrap(_impl->_adj, true))); + _impl->_slider->set_tooltip_text(_("Alpha (opacity)")); + _impl->_slider->show(); + + attachToGridOrTable(t, _impl->_slider->gobj(), 1, row, 1, 1, true); + + _impl->_slider->setColors(SP_RGBA32_F_COMPOSE( 1.0, 1.0, 1.0, 0.0 ), + SP_RGBA32_F_COMPOSE( 1.0, 1.0, 1.0, 0.5 ), + SP_RGBA32_F_COMPOSE( 1.0, 1.0, 1.0, 1.0 ) ); + + + // Spinbutton + _impl->_sbtn = gtk_spin_button_new(GTK_ADJUSTMENT(_impl->_adj), 1.0, 0); + gtk_widget_set_tooltip_text(_impl->_sbtn, _("Alpha (opacity)")); + sp_dialog_defocus_on_enter(_impl->_sbtn); + gtk_label_set_mnemonic_widget(GTK_LABEL(_impl->_label), _impl->_sbtn); + gtk_widget_show(_impl->_sbtn); + + attachToGridOrTable(t, _impl->_sbtn, 2, row, 1, 1, false, true); + + // Signals + g_signal_connect(G_OBJECT(_impl->_adj), "value_changed", G_CALLBACK(ColorICCSelectorImpl::_adjustmentChanged), _csel); + + _impl->_slider->signal_grabbed.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderGrabbed)); + _impl->_slider->signal_released.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderReleased)); + _impl->_slider->signal_value_changed.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderChanged)); +} + +static void sp_color_icc_selector_dispose(GObject *object) +{ + if ((G_OBJECT_CLASS(parent_class))->dispose) { + (* (G_OBJECT_CLASS(parent_class))->dispose)(object); + } +} + +static void +sp_color_icc_selector_show_all (GtkWidget *widget) +{ + gtk_widget_show (widget); +} + +static void sp_color_icc_selector_hide(GtkWidget *widget) +{ + gtk_widget_hide(widget); +} + +GtkWidget * +sp_color_icc_selector_new (void) +{ + SPColorICCSelector *csel; + + csel = static_cast(g_object_new (SP_TYPE_COLOR_ICC_SELECTOR, NULL)); + + return GTK_WIDGET (csel); +} + + +void ColorICCSelectorImpl::_fixupHit( GtkWidget* /*src*/, gpointer data ) +{ + ColorICCSelectorImpl* self = reinterpret_cast(data); + gtk_widget_set_sensitive( self->_fixupBtn, FALSE ); + self->_adjustmentChanged( self->_compUI[0]._adj, SP_COLOR_ICC_SELECTOR(self->_owner->_csel) ); +} + +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) +void ColorICCSelectorImpl::_profileSelected( GtkWidget* /*src*/, gpointer data ) +{ + ColorICCSelectorImpl* self = reinterpret_cast(data); + + GtkTreeIter iter; + if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(self->_profileSel), &iter)) { + GtkTreeModel *store = gtk_combo_box_get_model(GTK_COMBO_BOX(self->_profileSel)); + gchar* name = 0; + + gtk_tree_model_get(store, &iter, 1, &name, -1); + self->_switchToProfile( name ); + gtk_widget_set_tooltip_text(self->_profileSel, name ); + + if ( name ) { + g_free( name ); + } + } +} +#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) +void ColorICCSelectorImpl::_switchToProfile( gchar const* name ) +{ + bool dirty = false; + SPColor tmp( _owner->_color ); + + if ( name ) { + if ( tmp.icc && tmp.icc->colorProfile == name ) { +#ifdef DEBUG_LCMS + g_message("Already at name [%s]", name ); +#endif // DEBUG_LCMS + } else { +#ifdef DEBUG_LCMS + g_message("Need to switch to profile [%s]", name ); +#endif // DEBUG_LCMS + if ( tmp.icc ) { + tmp.icc->colors.clear(); + } else { + tmp.icc = new SVGICCColor(); + } + tmp.icc->colorProfile = name; + Inkscape::ColorProfile* newProf = SP_ACTIVE_DOCUMENT->profileManager->find(name); + if ( newProf ) { + cmsHTRANSFORM trans = newProf->getTransfFromSRGB8(); + if ( trans ) { + guint32 val = _owner->_color.toRGBA32(0); + guchar pre[4] = { + static_cast(SP_RGBA32_R_U(val)), + static_cast(SP_RGBA32_G_U(val)), + static_cast(SP_RGBA32_B_U(val)), + 255}; +#ifdef DEBUG_LCMS + g_message("Shoving in [%02x] [%02x] [%02x]", pre[0], pre[1], pre[2]); +#endif // DEBUG_LCMS + cmsUInt16Number post[4] = {0,0,0,0}; + cmsDoTransform( trans, pre, post, 1 ); +#ifdef DEBUG_LCMS + g_message("got on out [%04x] [%04x] [%04x] [%04x]", post[0], post[1], post[2], post[3]); +#endif // DEBUG_LCMS +#if HAVE_LIBLCMS1 + guint count = _cmsChannelsOf( asICColorSpaceSig(newProf->getColorSpace()) ); +#elif HAVE_LIBLCMS2 + guint count = cmsChannelsOf( asICColorSpaceSig(newProf->getColorSpace()) ); +#endif + + std::vector things = colorspace::getColorSpaceInfo(asICColorSpaceSig(newProf->getColorSpace())); + + for ( guint i = 0; i < count; i++ ) { + gdouble val = (((gdouble)post[i])/65535.0) * (gdouble)((i < things.size()) ? things[i].scale : 1); +#ifdef DEBUG_LCMS + g_message(" scaled %d by %d to be %f", i, ((i < things.size()) ? things[i].scale : 1), val); +#endif // DEBUG_LCMS + tmp.icc->colors.push_back(val); + } + cmsHTRANSFORM retrans = newProf->getTransfToSRGB8(); + if ( retrans ) { + cmsDoTransform( retrans, post, pre, 1 ); +#ifdef DEBUG_LCMS + g_message(" back out [%02x] [%02x] [%02x]", pre[0], pre[1], pre[2]); +#endif // DEBUG_LCMS + tmp.set(SP_RGBA32_U_COMPOSE(pre[0], pre[1], pre[2], 0xff)); + } + } + } + dirty = true; + } + } else { +#ifdef DEBUG_LCMS + g_message("NUKE THE ICC"); +#endif // DEBUG_LCMS + if ( tmp.icc ) { + delete tmp.icc; + tmp.icc = 0; + dirty = true; + _fixupHit( 0, this ); + } else { +#ifdef DEBUG_LCMS + g_message("No icc to nuke"); +#endif // DEBUG_LCMS + } + } + + if ( dirty ) { +#ifdef DEBUG_LCMS + g_message("+----------------"); + g_message("+ new color is [%s]", tmp.toString().c_str()); +#endif // DEBUG_LCMS + _setProfile( tmp.icc ); + //_adjustmentChanged( _compUI[0]._adj, SP_COLOR_ICC_SELECTOR(_csel) ); + _owner->setColorAlpha( tmp, _owner->_alpha, true ); +#ifdef DEBUG_LCMS + g_message("+_________________"); +#endif // DEBUG_LCMS + } +} +#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) +void ColorICCSelectorImpl::_profilesChanged( std::string const & name ) +{ + GtkComboBox* combo = GTK_COMBO_BOX(_profileSel); + + g_signal_handler_block( G_OBJECT(_profileSel), _profChangedID ); + + GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model(combo)); + gtk_list_store_clear(store); + + GtkTreeIter iter; + gtk_list_store_append (store, &iter); + gtk_list_store_set(store, &iter, 0, _(""), 1, _(""), -1); + + gtk_combo_box_set_active( combo, 0 ); + + int index = 1; + const GSList *current = SP_ACTIVE_DOCUMENT->getResourceList( "iccprofile" ); + while ( current ) { + SPObject* obj = SP_OBJECT(current->data); + Inkscape::ColorProfile* prof = reinterpret_cast(obj); + + gtk_list_store_append (store, &iter); + gtk_list_store_set(store, &iter, 0, gr_ellipsize_text(prof->name, 25).c_str(), 1, prof->name, -1); + + if ( name == prof->name ) { + gtk_combo_box_set_active( combo, index ); + gtk_widget_set_tooltip_text(_profileSel, prof->name ); + } + + index++; + current = g_slist_next(current); + } + + g_signal_handler_unblock( G_OBJECT(_profileSel), _profChangedID ); +} +#else +void ColorICCSelectorImpl::_profilesChanged( std::string const & /*name*/ ) +{ +} +#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + +// Helpers for setting color value + +void ColorICCSelector::_colorChanged() +{ + _impl->_updating = TRUE; + //sp_color_icc_set_color( SP_COLOR_ICC( _icc ), &color ); + +#ifdef DEBUG_LCMS + g_message( "/^^^^^^^^^ %p::_colorChanged(%08x:%s)", this, + _color.toRGBA32(_alpha), ( (_color.icc) ? _color.icc->colorProfile.c_str(): "" ) + ); +#endif // DEBUG_LCMS + +#ifdef DEBUG_LCMS + g_message("FLIPPIES!!!! %p '%s'", _color.icc, (_color.icc ? _color.icc->colorProfile.c_str():"")); +#endif // DEBUG_LCMS + + _impl->_profilesChanged( (_color.icc) ? _color.icc->colorProfile : std::string("") ); + ColorScales::setScaled( _impl->_adj, _alpha ); + +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + _impl->_setProfile( _color.icc ); + _impl->_fixupNeeded = 0; + gtk_widget_set_sensitive( _impl->_fixupBtn, FALSE ); + + if (_impl->_prof) { + if (_impl->_prof->getTransfToSRGB8() ) { + cmsUInt16Number tmp[4]; + for ( guint i = 0; i < _impl->_profChannelCount; i++ ) { + gdouble val = 0.0; + if ( _color.icc->colors.size() > i ) { + if ( _impl->_compUI[i]._component.scale == 256 ) { + val = (_color.icc->colors[i] + 128.0) / static_cast(_impl->_compUI[i]._component.scale); + } else { + val = _color.icc->colors[i] / static_cast(_impl->_compUI[i]._component.scale); + } + } + tmp[i] = val * 0x0ffff; + } + guchar post[4] = {0,0,0,0}; + cmsHTRANSFORM trans = _impl->_prof->getTransfToSRGB8(); + if ( trans ) { + cmsDoTransform( trans, tmp, post, 1 ); + guint32 other = SP_RGBA32_U_COMPOSE(post[0], post[1], post[2], 255 ); + if ( other != _color.toRGBA32(255) ) { + _impl->_fixupNeeded = other; + gtk_widget_set_sensitive( _impl->_fixupBtn, TRUE ); +#ifdef DEBUG_LCMS + g_message("Color needs to change 0x%06x to 0x%06x", _color.toRGBA32(255) >> 8, other >> 8 ); +#endif // DEBUG_LCMS + } + } + } + } +#else + //(void)color; +#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + _impl->_updateSliders( -1 ); + + + _impl->_updating = FALSE; +#ifdef DEBUG_LCMS + g_message( "\\_________ %p::_colorChanged()", this ); +#endif // DEBUG_LCMS +} + +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) +void ColorICCSelectorImpl::_setProfile( SVGICCColor* profile ) +{ +#ifdef DEBUG_LCMS + g_message( "/^^^^^^^^^ %p::_setProfile(%s)", this, + ( (profile) ? profile->colorProfile.c_str() : "") + ); +#endif // DEBUG_LCMS + bool profChanged = false; + if ( _prof && (!profile || (_profileName != profile->colorProfile) ) ) { + // Need to clear out the prior one + profChanged = true; + _profileName.clear(); + _prof = 0; + _profChannelCount = 0; + } else if ( profile && !_prof ) { + profChanged = true; + } + + for ( size_t i = 0; i < _compUI.size(); i++ ) { + gtk_widget_hide( _compUI[i]._label ); + _compUI[i]._slider->hide(); + gtk_widget_hide( _compUI[i]._btn ); + } + + if ( profile ) { + _prof = SP_ACTIVE_DOCUMENT->profileManager->find(profile->colorProfile.c_str()); + if ( _prof && (asICColorProfileClassSig(_prof->getProfileClass()) != cmsSigNamedColorClass) ) { +#if HAVE_LIBLCMS1 + _profChannelCount = _cmsChannelsOf( asICColorSpaceSig(_prof->getColorSpace()) ); +#elif HAVE_LIBLCMS2 + _profChannelCount = cmsChannelsOf( asICColorSpaceSig(_prof->getColorSpace()) ); +#endif + + if ( profChanged ) { + std::vector things = colorspace::getColorSpaceInfo(asICColorSpaceSig(_prof->getColorSpace())); + for (size_t i = 0; (i < things.size()) && (i < _profChannelCount); ++i) + { + _compUI[i]._component = things[i]; + } + + for ( guint i = 0; i < _profChannelCount; i++ ) { + gtk_label_set_text_with_mnemonic( GTK_LABEL(_compUI[i]._label), (i < things.size()) ? things[i].name.c_str() : ""); + + _compUI[i]._slider->set_tooltip_text((i < things.size()) ? things[i].tip.c_str() : ""); + gtk_widget_set_tooltip_text( _compUI[i]._btn, (i < things.size()) ? things[i].tip.c_str() : "" ); + + _compUI[i]._slider->setColors(SPColor(0.0, 0.0, 0.0).toRGBA32(0xff), + SPColor(0.5, 0.5, 0.5).toRGBA32(0xff), + SPColor(1.0, 1.0, 1.0).toRGBA32(0xff) ); +/* + _compUI[i]._adj = GTK_ADJUSTMENT( gtk_adjustment_new( val, 0.0, _fooScales[i], step, page, page ) ); + g_signal_connect( G_OBJECT( _compUI[i]._adj ), "value_changed", G_CALLBACK( _adjustmentChanged ), _csel ); + + sp_color_slider_set_adjustment( SP_COLOR_SLIDER(_compUI[i]._slider), _compUI[i]._adj ); + gtk_spin_button_set_adjustment( GTK_SPIN_BUTTON(_compUI[i]._btn), _compUI[i]._adj ); + gtk_spin_button_set_digits( GTK_SPIN_BUTTON(_compUI[i]._btn), digits ); +*/ + gtk_widget_show( _compUI[i]._label ); + _compUI[i]._slider->show(); + gtk_widget_show( _compUI[i]._btn ); + //gtk_adjustment_set_value( _compUI[i]._adj, 0.0 ); + //gtk_adjustment_set_value( _compUI[i]._adj, val ); + } + for ( size_t i = _profChannelCount; i < _compUI.size(); i++ ) { + gtk_widget_hide( _compUI[i]._label ); + _compUI[i]._slider->hide(); + gtk_widget_hide( _compUI[i]._btn ); + } + } + } else { + // Give up for now on named colors + _prof = 0; + } + } + +#ifdef DEBUG_LCMS + g_message( "\\_________ %p::_setProfile()", this ); +#endif // DEBUG_LCMS +} +#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + +void ColorICCSelectorImpl::_updateSliders( gint ignore ) +{ +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + if ( _owner->_color.icc ) + { + for ( guint i = 0; i < _profChannelCount; i++ ) { + gdouble val = 0.0; + if ( _owner->_color.icc->colors.size() > i ) { + if ( _compUI[i]._component.scale == 256 ) { + val = (_owner->_color.icc->colors[i] + 128.0) / static_cast(_compUI[i]._component.scale); + } else { + val = _owner->_color.icc->colors[i] / static_cast(_compUI[i]._component.scale); + } + } + gtk_adjustment_set_value( _compUI[i]._adj, val ); + } + + if ( _prof ) { + if ( _prof->getTransfToSRGB8() ) { + for ( guint i = 0; i < _profChannelCount; i++ ) { + if ( static_cast(i) != ignore ) { + cmsUInt16Number* scratch = getScratch(); + cmsUInt16Number filler[4] = {0, 0, 0, 0}; + for ( guint j = 0; j < _profChannelCount; j++ ) { + filler[j] = 0x0ffff * ColorScales::getScaled( _compUI[j]._adj ); + } + + cmsUInt16Number* p = scratch; + for ( guint x = 0; x < 1024; x++ ) { + for ( guint j = 0; j < _profChannelCount; j++ ) { + if ( j == i ) { + *p++ = x * 0x0ffff / 1024; + } else { + *p++ = filler[j]; + } + } + } + + cmsHTRANSFORM trans = _prof->getTransfToSRGB8(); + if ( trans ) { + cmsDoTransform( trans, scratch, _compUI[i]._map, 1024 ); + _compUI[i]._slider->setMap(_compUI[i]._map); + } + } + } + } + } + } +#else + (void)ignore; +#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + + guint32 start = _owner->_color.toRGBA32( 0x00 ); + guint32 mid = _owner->_color.toRGBA32( 0x7f ); + guint32 end = _owner->_color.toRGBA32( 0xff ); + + _slider->setColors(start, mid, end); +} + + +void ColorICCSelectorImpl::_adjustmentChanged( GtkAdjustment *adjustment, SPColorICCSelector *cs ) +{ +// // TODO check this. It looks questionable: +// // if a value is entered between 0 and 1 exclusive, normalize it to (int) 0..255 or 0..100 +// if (adjustment->value > 0.0 && adjustment->value < 1.0) { +// gtk_adjustment_set_value( adjustment, floor ((adjustment->value) * adjustment->upper + 0.5) ); +// } + +#ifdef DEBUG_LCMS + g_message( "/^^^^^^^^^ %p::_adjustmentChanged()", cs ); +#endif // DEBUG_LCMS + + ColorICCSelector* iccSelector = static_cast(SP_COLOR_SELECTOR(cs)->base); + if (iccSelector->_impl->_updating) { + return; + } + + iccSelector->_impl->_updating = TRUE; + + gint match = -1; + + SPColor newColor( iccSelector->_color ); + gfloat scaled = ColorScales::getScaled( iccSelector->_impl->_adj ); + if ( iccSelector->_impl->_adj == adjustment ) { +#ifdef DEBUG_LCMS + g_message("ALPHA"); +#endif // DEBUG_LCMS + } else { +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + for ( size_t i = 0; i < iccSelector->_impl->_compUI.size(); i++ ) { + if ( iccSelector->_impl->_compUI[i]._adj == adjustment ) { + match = i; + break; + } + } + if ( match >= 0 ) { +#ifdef DEBUG_LCMS + g_message(" channel %d", match ); +#endif // DEBUG_LCMS + } + + + cmsUInt16Number tmp[4]; + for ( guint i = 0; i < 4; i++ ) { + tmp[i] = ColorScales::getScaled( iccSelector->_impl->_compUI[i]._adj ) * 0x0ffff; + } + guchar post[4] = {0,0,0,0}; + + cmsHTRANSFORM trans = iccSelector->_impl->_prof->getTransfToSRGB8(); + if ( trans ) { + cmsDoTransform( trans, tmp, post, 1 ); + } + + SPColor other( SP_RGBA32_U_COMPOSE(post[0], post[1], post[2], 255) ); + other.icc = new SVGICCColor(); + if ( iccSelector->_color.icc ) { + other.icc->colorProfile = iccSelector->_color.icc->colorProfile; + } + + guint32 prior = iccSelector->_color.toRGBA32(255); + guint32 newer = other.toRGBA32(255); + + if ( prior != newer ) { +#ifdef DEBUG_LCMS + g_message("Transformed color from 0x%08x to 0x%08x", prior, newer ); + g_message(" ~~~~ FLIP"); +#endif // DEBUG_LCMS + newColor = other; + newColor.icc->colors.clear(); + for ( guint i = 0; i < iccSelector->_impl->_profChannelCount; i++ ) { + gdouble val = ColorScales::getScaled( iccSelector->_impl->_compUI[i]._adj ); + val *= iccSelector->_impl->_compUI[i]._component.scale; + if ( iccSelector->_impl->_compUI[i]._component.scale == 256 ) { + val -= 128; + } + newColor.icc->colors.push_back( val ); + } + } +#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + } + iccSelector->_updateInternals( newColor, scaled, iccSelector->_impl->_dragging ); + iccSelector->_impl->_updateSliders( match ); + + iccSelector->_impl->_updating = FALSE; +#ifdef DEBUG_LCMS + g_message( "\\_________ %p::_adjustmentChanged()", cs ); +#endif // DEBUG_LCMS +} + +void ColorICCSelectorImpl::_sliderGrabbed() +{ +// ColorICCSelector* iccSelector = dynamic_cast(SP_COLOR_SELECTOR(cs)->base); +// if (!iccSelector->_dragging) { +// iccSelector->_dragging = TRUE; +// iccSelector->_grabbed(); +// iccSelector->_updateInternals( iccSelector->_color, ColorScales::getScaled( iccSelector->_impl->_adj ), iccSelector->_dragging ); +// } +} + +void ColorICCSelectorImpl::_sliderReleased() +{ +// ColorICCSelector* iccSelector = dynamic_cast(SP_COLOR_SELECTOR(cs)->base); +// if (iccSelector->_dragging) { +// iccSelector->_dragging = FALSE; +// iccSelector->_released(); +// iccSelector->_updateInternals( iccSelector->_color, ColorScales::getScaled( iccSelector->_adj ), iccSelector->_dragging ); +// } +} + +#ifdef DEBUG_LCMS +void ColorICCSelectorImpl::_sliderChanged( SPColorSlider *slider, SPColorICCSelector *cs ) +#else +void ColorICCSelectorImpl::_sliderChanged() +#endif // DEBUG_LCMS +{ +#ifdef DEBUG_LCMS + g_message("Changed %p and %p", slider, cs ); +#endif // DEBUG_LCMS +// ColorICCSelector* iccSelector = dynamic_cast(SP_COLOR_SELECTOR(cs)->base); + +// iccSelector->_updateInternals( iccSelector->_color, ColorScales::getScaled( iccSelector->_adj ), iccSelector->_dragging ); +} + +Gtk::Widget *ColorICCSelectorFactory::createWidget(Inkscape::UI::SelectedColor &color) const { + GtkWidget *w = sp_color_selector_new(SP_TYPE_COLOR_ICC_SELECTOR); + Gtk::Widget *wrapped = Gtk::manage(Glib::wrap(w)); + return wrapped; +} + +Glib::ustring ColorICCSelectorFactory::modeName() const { + return gettext(ColorICCSelector::MODE_NAME); +} + + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 : diff --git a/src/ui/widget/color-icc-selector.h b/src/ui/widget/color-icc-selector.h new file mode 100644 index 000000000..cee8305cd --- /dev/null +++ b/src/ui/widget/color-icc-selector.h @@ -0,0 +1,81 @@ +#ifndef SEEN_SP_COLOR_ICC_SELECTOR_H +#define SEEN_SP_COLOR_ICC_SELECTOR_H + +#include +#include + +#include "widgets/sp-color-selector.h" +#include "ui/selected-color.h" + +namespace Inkscape { +class ColorProfile; +} + +struct SPColorICCSelector; +struct SPColorICCSelectorClass; + +class ColorICCSelectorImpl; + +class ColorICCSelector: public ColorSelector +{ +public: + static const gchar* MODE_NAME; + + ColorICCSelector( SPColorSelector* csel ); + virtual ~ColorICCSelector(); + + virtual void init(); + +protected: + virtual void _colorChanged(); + + void _recalcColor( gboolean changing ); + +private: + friend class ColorICCSelectorImpl; + + // By default, disallow copy constructor and assignment operator + ColorICCSelector( const ColorICCSelector& obj ); + ColorICCSelector& operator=( const ColorICCSelector& obj ); + + ColorICCSelectorImpl *_impl; +}; + + + +#define SP_TYPE_COLOR_ICC_SELECTOR (sp_color_icc_selector_get_type()) +#define SP_COLOR_ICC_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_CAST((o), SP_TYPE_COLOR_ICC_SELECTOR, SPColorICCSelector)) +#define SP_COLOR_ICC_SELECTOR_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), SP_TYPE_COLOR_ICC_SELECTOR, SPColorICCSelectorClass)) +#define SP_IS_COLOR_ICC_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_TYPE((o), SP_TYPE_COLOR_ICC_SELECTOR)) +#define SP_IS_COLOR_ICC_SELECTOR_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE((k), SP_TYPE_COLOR_ICC_SELECTOR)) + +struct SPColorICCSelector { + SPColorSelector parent; +}; + +struct SPColorICCSelectorClass { + SPColorSelectorClass parent_class; +}; + +GType sp_color_icc_selector_get_type(void); + +GtkWidget *sp_color_icc_selector_new(void); + +class ColorICCSelectorFactory: public Inkscape::UI::ColorSelectorFactory { +public: + Gtk::Widget* createWidget(Inkscape::UI::SelectedColor &color) const; + Glib::ustring modeName() const; +}; + +#endif // SEEN_SP_COLOR_ICC_SELECTOR_H + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 : -- cgit v1.2.3 From 9d88682d5df45121fec6350cc028e5fb666e4776 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 31 May 2014 21:34:24 +0200 Subject: SPColorICC c++sification: using SelectedColor (bzr r13341.6.42) --- src/ui/widget/color-icc-selector.cpp | 416 ++++++++++++++--------------------- src/ui/widget/color-icc-selector.h | 58 ++--- 2 files changed, 199 insertions(+), 275 deletions(-) (limited to 'src/ui') diff --git a/src/ui/widget/color-icc-selector.cpp b/src/ui/widget/color-icc-selector.cpp index 74e63f320..1187dd081 100644 --- a/src/ui/widget/color-icc-selector.cpp +++ b/src/ui/widget/color-icc-selector.cpp @@ -32,10 +32,6 @@ #endif // DEBUG_LCMS #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - -using namespace Inkscape::UI::Widget; - - #ifdef DEBUG_LCMS extern guint update_in_progress; #define DEBUG_MESSAGE(key, ...) \ @@ -67,106 +63,6 @@ extern guint update_in_progress; #endif // DEBUG_LCMS - -G_BEGIN_DECLS - -static void sp_color_icc_selector_class_init (SPColorICCSelectorClass *klass); -static void sp_color_icc_selector_init (SPColorICCSelector *cs); -static void sp_color_icc_selector_dispose(GObject *object); - -static void sp_color_icc_selector_show_all (GtkWidget *widget); -static void sp_color_icc_selector_hide(GtkWidget *widget); - -G_END_DECLS - -/** - * Class containing the parts for a single color component's UI presence. - */ -class ComponentUI -{ -public: - ComponentUI() : - _component(), - _adj(0), - _slider(0), - _btn(0), - _label(0), - _map(0) - { - } - - ComponentUI(colorspace::Component const &component) : - _component(component), - _adj(0), - _slider(0), - _btn(0), - _label(0), - _map(0) - { - } - - colorspace::Component _component; - GtkAdjustment *_adj; // Component adjustment - Inkscape::UI::Widget::ColorSlider *_slider; - GtkWidget *_btn; // spinbutton - GtkWidget *_label; // Label - guchar *_map; -}; - -/** - * Class that implements the internals of the selector. - */ -class ColorICCSelectorImpl -{ -public: - - ColorICCSelectorImpl( ColorICCSelector *owner); - - ~ColorICCSelectorImpl(); - - static void _adjustmentChanged ( GtkAdjustment *adjustment, SPColorICCSelector *cs ); - - void _sliderGrabbed(); - void _sliderReleased(); - void _sliderChanged(); - - static void _profileSelected( GtkWidget* src, gpointer data ); - static void _fixupHit( GtkWidget* src, gpointer data ); - -#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - void _setProfile( SVGICCColor* profile ); - void _switchToProfile( gchar const* name ); -#endif - void _updateSliders( gint ignore ); - void _profilesChanged( std::string const & name ); - - ColorICCSelector *_owner; - - gboolean _updating : 1; - gboolean _dragging : 1; - - guint32 _fixupNeeded; - GtkWidget* _fixupBtn; - GtkWidget* _profileSel; - - std::vector _compUI; - - GtkAdjustment* _adj; // Channel adjustment - Inkscape::UI::Widget::ColorSlider* _slider; - GtkWidget* _sbtn; // Spinbutton - GtkWidget* _label; // Label - -#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - std::string _profileName; - Inkscape::ColorProfile* _prof; - guint _profChannelCount; - gulong _profChangedID; -#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) -}; - - -static SPColorSelectorClass *parent_class; - #define XPAD 4 #define YPAD 1 @@ -230,77 +126,6 @@ void attachToGridOrTable(GtkWidget *parent, } // namespace -GType sp_color_icc_selector_get_type(void) -{ - static GType type = 0; - if (!type) { - static const GTypeInfo info = { - sizeof (SPColorICCSelectorClass), - NULL, // base_init - NULL, // base_finalize - (GClassInitFunc) sp_color_icc_selector_class_init, - NULL, // class_finalize - NULL, // class_data - sizeof (SPColorICCSelector), - 0, // n_preallocs - (GInstanceInitFunc) sp_color_icc_selector_init, - 0, // value_table - }; - - type = g_type_register_static (SP_TYPE_COLOR_SELECTOR, - "SPColorICCSelector", - &info, - static_cast< GTypeFlags > (0) ); - } - return type; -} - -static void sp_color_icc_selector_class_init(SPColorICCSelectorClass *klass) -{ - static const gchar* nameset[] = {N_("CMS"), 0}; - GObjectClass *object_class = G_OBJECT_CLASS(klass); - GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass); - SPColorSelectorClass *selector_class = SP_COLOR_SELECTOR_CLASS (klass); - - parent_class = SP_COLOR_SELECTOR_CLASS (g_type_class_peek_parent (klass)); - - selector_class->name = nameset; - selector_class->submode_count = 1; - - object_class->dispose = sp_color_icc_selector_dispose; - - widget_class->show_all = sp_color_icc_selector_show_all; - widget_class->hide = sp_color_icc_selector_hide; -} - -const gchar* ColorICCSelector::MODE_NAME = N_("CMS"); - -ColorICCSelector::ColorICCSelector( SPColorSelector* csel ) - : ColorSelector( csel ), - _impl(NULL) -{ -} - -ColorICCSelector::~ColorICCSelector() -{ - if (_impl) - { - delete _impl; - _impl = 0; - } -} - -void sp_color_icc_selector_init(SPColorICCSelector *cs) -{ - SP_COLOR_SELECTOR(cs)->base = new ColorICCSelector( SP_COLOR_SELECTOR(cs) ); - - if ( SP_COLOR_SELECTOR(cs)->base ) - { - SP_COLOR_SELECTOR(cs)->base->init(); - } -} - - /* icSigRgbData icSigCmykData @@ -403,8 +228,141 @@ std::vector colorspace::getColorSpaceInfo( Inkscape::Colo #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) -ColorICCSelectorImpl::ColorICCSelectorImpl(ColorICCSelector *owner) : + + + + + + + + + + + + + + + + + +namespace Inkscape { +namespace UI { +namespace Widget { + +/** + * Class containing the parts for a single color component's UI presence. + */ +class ComponentUI +{ +public: + ComponentUI() : + _component(), + _adj(0), + _slider(0), + _btn(0), + _label(0), + _map(0) + { + } + + ComponentUI(colorspace::Component const &component) : + _component(component), + _adj(0), + _slider(0), + _btn(0), + _label(0), + _map(0) + { + } + + colorspace::Component _component; + GtkAdjustment *_adj; // Component adjustment + Inkscape::UI::Widget::ColorSlider *_slider; + GtkWidget *_btn; // spinbutton + GtkWidget *_label; // Label + guchar *_map; +}; + +/** + * Class that implements the internals of the selector. + */ +class ColorICCSelectorImpl +{ +public: + + ColorICCSelectorImpl(ColorICCSelector *owner, SelectedColor &color); + + ~ColorICCSelectorImpl(); + + static void _adjustmentChanged ( GtkAdjustment *adjustment, ColorICCSelectorImpl *cs ); + + void _sliderGrabbed(); + void _sliderReleased(); + void _sliderChanged(); + + static void _profileSelected( GtkWidget* src, gpointer data ); + static void _fixupHit( GtkWidget* src, gpointer data ); + +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + void _setProfile( SVGICCColor* profile ); + void _switchToProfile( gchar const* name ); +#endif + void _updateSliders( gint ignore ); + void _profilesChanged( std::string const & name ); + + ColorICCSelector *_owner; + SelectedColor &_color; + + gboolean _updating : 1; + gboolean _dragging : 1; + + guint32 _fixupNeeded; + GtkWidget* _fixupBtn; + GtkWidget* _profileSel; + + std::vector _compUI; + + GtkAdjustment* _adj; // Channel adjustment + Inkscape::UI::Widget::ColorSlider* _slider; + GtkWidget* _sbtn; // Spinbutton + GtkWidget* _label; // Label + +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + std::string _profileName; + Inkscape::ColorProfile* _prof; + guint _profChannelCount; + gulong _profChangedID; +#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) +}; + + + + +const gchar* ColorICCSelector::MODE_NAME = N_("CMS"); + +ColorICCSelector::ColorICCSelector(SelectedColor &color) + : _impl(NULL) +{ + _impl = new ColorICCSelectorImpl(this, color); + init(); + color.signal_changed.connect(sigc::mem_fun(this, &ColorICCSelector::_colorChanged)); + //color.signal_dragged.connect(sigc::mem_fun(this, &ColorICCSelector::_colorChanged)); +} + +ColorICCSelector::~ColorICCSelector() +{ + if (_impl) + { + delete _impl; + _impl = 0; + } +} + + + +ColorICCSelectorImpl::ColorICCSelectorImpl(ColorICCSelector *owner, SelectedColor &color) : _owner(owner), + _color(color), _updating( FALSE ), _dragging( FALSE ), _fixupNeeded(0), @@ -434,21 +392,14 @@ ColorICCSelectorImpl::~ColorICCSelectorImpl() void ColorICCSelector::init() { - if (_impl) delete(_impl); - _impl = new ColorICCSelectorImpl(this); gint row = 0; _impl->_updating = FALSE; _impl->_dragging = FALSE; -#if GTK_CHECK_VERSION(3,0,0) - GtkWidget *t = gtk_grid_new(); -#else - GtkWidget *t = gtk_table_new(5, 3, FALSE); -#endif + GtkWidget* t = GTK_WIDGET(gobj()); gtk_widget_show (t); - gtk_box_pack_start (GTK_BOX (_csel), t, TRUE, TRUE, 4); _impl->_compUI.clear(); @@ -552,7 +503,7 @@ void ColorICCSelector::init() // Signals - g_signal_connect( G_OBJECT( _impl->_compUI[i]._adj ), "value_changed", G_CALLBACK( ColorICCSelectorImpl::_adjustmentChanged ), _csel ); + g_signal_connect( G_OBJECT( _impl->_compUI[i]._adj ), "value_changed", G_CALLBACK( ColorICCSelectorImpl::_adjustmentChanged ), _impl ); _impl->_compUI[i]._slider->signal_grabbed.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderGrabbed)); _impl->_compUI[i]._slider->signal_released.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderReleased)); @@ -593,47 +544,18 @@ void ColorICCSelector::init() attachToGridOrTable(t, _impl->_sbtn, 2, row, 1, 1, false, true); // Signals - g_signal_connect(G_OBJECT(_impl->_adj), "value_changed", G_CALLBACK(ColorICCSelectorImpl::_adjustmentChanged), _csel); + g_signal_connect(G_OBJECT(_impl->_adj), "value_changed", G_CALLBACK(ColorICCSelectorImpl::_adjustmentChanged), _impl); _impl->_slider->signal_grabbed.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderGrabbed)); _impl->_slider->signal_released.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderReleased)); _impl->_slider->signal_value_changed.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderChanged)); } -static void sp_color_icc_selector_dispose(GObject *object) -{ - if ((G_OBJECT_CLASS(parent_class))->dispose) { - (* (G_OBJECT_CLASS(parent_class))->dispose)(object); - } -} - -static void -sp_color_icc_selector_show_all (GtkWidget *widget) -{ - gtk_widget_show (widget); -} - -static void sp_color_icc_selector_hide(GtkWidget *widget) -{ - gtk_widget_hide(widget); -} - -GtkWidget * -sp_color_icc_selector_new (void) -{ - SPColorICCSelector *csel; - - csel = static_cast(g_object_new (SP_TYPE_COLOR_ICC_SELECTOR, NULL)); - - return GTK_WIDGET (csel); -} - - void ColorICCSelectorImpl::_fixupHit( GtkWidget* /*src*/, gpointer data ) { ColorICCSelectorImpl* self = reinterpret_cast(data); gtk_widget_set_sensitive( self->_fixupBtn, FALSE ); - self->_adjustmentChanged( self->_compUI[0]._adj, SP_COLOR_ICC_SELECTOR(self->_owner->_csel) ); + self->_adjustmentChanged( self->_compUI[0]._adj, self ); } #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) @@ -661,7 +583,7 @@ void ColorICCSelectorImpl::_profileSelected( GtkWidget* /*src*/, gpointer data ) void ColorICCSelectorImpl::_switchToProfile( gchar const* name ) { bool dirty = false; - SPColor tmp( _owner->_color ); + SPColor tmp( _color.color() ); if ( name ) { if ( tmp.icc && tmp.icc->colorProfile == name ) { @@ -682,7 +604,7 @@ void ColorICCSelectorImpl::_switchToProfile( gchar const* name ) if ( newProf ) { cmsHTRANSFORM trans = newProf->getTransfFromSRGB8(); if ( trans ) { - guint32 val = _owner->_color.toRGBA32(0); + guint32 val = _color.color().toRGBA32(0); guchar pre[4] = { static_cast(SP_RGBA32_R_U(val)), static_cast(SP_RGBA32_G_U(val)), @@ -746,7 +668,7 @@ void ColorICCSelectorImpl::_switchToProfile( gchar const* name ) #endif // DEBUG_LCMS _setProfile( tmp.icc ); //_adjustmentChanged( _compUI[0]._adj, SP_COLOR_ICC_SELECTOR(_csel) ); - _owner->setColorAlpha( tmp, _owner->_alpha, true ); + _color.setColor(tmp); #ifdef DEBUG_LCMS g_message("+_________________"); #endif // DEBUG_LCMS @@ -805,19 +727,19 @@ void ColorICCSelector::_colorChanged() #ifdef DEBUG_LCMS g_message( "/^^^^^^^^^ %p::_colorChanged(%08x:%s)", this, - _color.toRGBA32(_alpha), ( (_color.icc) ? _color.icc->colorProfile.c_str(): "" ) + _impl->_color.color().toRGBA32(_impl->_color.alpha()), ( (_impl->_color.color().icc) ? _impl->_color.color().icc->colorProfile.c_str(): "" ) ); #endif // DEBUG_LCMS #ifdef DEBUG_LCMS - g_message("FLIPPIES!!!! %p '%s'", _color.icc, (_color.icc ? _color.icc->colorProfile.c_str():"")); + g_message("FLIPPIES!!!! %p '%s'", _impl->_color.color().icc, (_impl->_color.color().icc ? _impl->_color.color().icc->colorProfile.c_str():"")); #endif // DEBUG_LCMS - _impl->_profilesChanged( (_color.icc) ? _color.icc->colorProfile : std::string("") ); - ColorScales::setScaled( _impl->_adj, _alpha ); + _impl->_profilesChanged( (_impl->_color.color().icc) ? _impl->_color.color().icc->colorProfile : std::string("") ); + ColorScales::setScaled( _impl->_adj, _impl->_color.alpha() ); #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - _impl->_setProfile( _color.icc ); + _impl->_setProfile( _impl->_color.color().icc ); _impl->_fixupNeeded = 0; gtk_widget_set_sensitive( _impl->_fixupBtn, FALSE ); @@ -826,11 +748,11 @@ void ColorICCSelector::_colorChanged() cmsUInt16Number tmp[4]; for ( guint i = 0; i < _impl->_profChannelCount; i++ ) { gdouble val = 0.0; - if ( _color.icc->colors.size() > i ) { + if ( _impl->_color.color().icc->colors.size() > i ) { if ( _impl->_compUI[i]._component.scale == 256 ) { - val = (_color.icc->colors[i] + 128.0) / static_cast(_impl->_compUI[i]._component.scale); + val = (_impl->_color.color().icc->colors[i] + 128.0) / static_cast(_impl->_compUI[i]._component.scale); } else { - val = _color.icc->colors[i] / static_cast(_impl->_compUI[i]._component.scale); + val = _impl->_color.color().icc->colors[i] / static_cast(_impl->_compUI[i]._component.scale); } } tmp[i] = val * 0x0ffff; @@ -840,7 +762,7 @@ void ColorICCSelector::_colorChanged() if ( trans ) { cmsDoTransform( trans, tmp, post, 1 ); guint32 other = SP_RGBA32_U_COMPOSE(post[0], post[1], post[2], 255 ); - if ( other != _color.toRGBA32(255) ) { + if ( other != _impl->_color.color().toRGBA32(255) ) { _impl->_fixupNeeded = other; gtk_widget_set_sensitive( _impl->_fixupBtn, TRUE ); #ifdef DEBUG_LCMS @@ -947,15 +869,15 @@ void ColorICCSelectorImpl::_setProfile( SVGICCColor* profile ) void ColorICCSelectorImpl::_updateSliders( gint ignore ) { #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - if ( _owner->_color.icc ) + if ( _color.color().icc ) { for ( guint i = 0; i < _profChannelCount; i++ ) { gdouble val = 0.0; - if ( _owner->_color.icc->colors.size() > i ) { + if ( _color.color().icc->colors.size() > i ) { if ( _compUI[i]._component.scale == 256 ) { - val = (_owner->_color.icc->colors[i] + 128.0) / static_cast(_compUI[i]._component.scale); + val = (_color.color().icc->colors[i] + 128.0) / static_cast(_compUI[i]._component.scale); } else { - val = _owner->_color.icc->colors[i] / static_cast(_compUI[i]._component.scale); + val = _color.color().icc->colors[i] / static_cast(_compUI[i]._component.scale); } } gtk_adjustment_set_value( _compUI[i]._adj, val ); @@ -996,15 +918,15 @@ void ColorICCSelectorImpl::_updateSliders( gint ignore ) (void)ignore; #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - guint32 start = _owner->_color.toRGBA32( 0x00 ); - guint32 mid = _owner->_color.toRGBA32( 0x7f ); - guint32 end = _owner->_color.toRGBA32( 0xff ); + guint32 start = _color.color().toRGBA32( 0x00 ); + guint32 mid = _color.color().toRGBA32( 0x7f ); + guint32 end = _color.color().toRGBA32( 0xff ); _slider->setColors(start, mid, end); } -void ColorICCSelectorImpl::_adjustmentChanged( GtkAdjustment *adjustment, SPColorICCSelector *cs ) +void ColorICCSelectorImpl::_adjustmentChanged( GtkAdjustment *adjustment, ColorICCSelectorImpl *cs ) { // // TODO check this. It looks questionable: // // if a value is entered between 0 and 1 exclusive, normalize it to (int) 0..255 or 0..100 @@ -1016,7 +938,7 @@ void ColorICCSelectorImpl::_adjustmentChanged( GtkAdjustment *adjustment, SPColo g_message( "/^^^^^^^^^ %p::_adjustmentChanged()", cs ); #endif // DEBUG_LCMS - ColorICCSelector* iccSelector = static_cast(SP_COLOR_SELECTOR(cs)->base); + ColorICCSelector* iccSelector = cs->_owner; if (iccSelector->_impl->_updating) { return; } @@ -1025,7 +947,7 @@ void ColorICCSelectorImpl::_adjustmentChanged( GtkAdjustment *adjustment, SPColo gint match = -1; - SPColor newColor( iccSelector->_color ); + SPColor newColor( iccSelector->_impl->_color.color() ); gfloat scaled = ColorScales::getScaled( iccSelector->_impl->_adj ); if ( iccSelector->_impl->_adj == adjustment ) { #ifdef DEBUG_LCMS @@ -1059,11 +981,11 @@ void ColorICCSelectorImpl::_adjustmentChanged( GtkAdjustment *adjustment, SPColo SPColor other( SP_RGBA32_U_COMPOSE(post[0], post[1], post[2], 255) ); other.icc = new SVGICCColor(); - if ( iccSelector->_color.icc ) { - other.icc->colorProfile = iccSelector->_color.icc->colorProfile; + if ( iccSelector->_impl->_color.color().icc ) { + other.icc->colorProfile = iccSelector->_impl->_color.color().icc->colorProfile; } - guint32 prior = iccSelector->_color.toRGBA32(255); + guint32 prior = iccSelector->_impl->_color.color().toRGBA32(255); guint32 newer = other.toRGBA32(255); if ( prior != newer ) { @@ -1084,7 +1006,8 @@ void ColorICCSelectorImpl::_adjustmentChanged( GtkAdjustment *adjustment, SPColo } #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) } - iccSelector->_updateInternals( newColor, scaled, iccSelector->_impl->_dragging ); + iccSelector->_impl->_color.setColorAlpha(newColor, scaled, true); + //iccSelector->_updateInternals( newColor, scaled, iccSelector->_impl->_dragging ); iccSelector->_impl->_updateSliders( match ); iccSelector->_impl->_updating = FALSE; @@ -1128,16 +1051,17 @@ void ColorICCSelectorImpl::_sliderChanged() } Gtk::Widget *ColorICCSelectorFactory::createWidget(Inkscape::UI::SelectedColor &color) const { - GtkWidget *w = sp_color_selector_new(SP_TYPE_COLOR_ICC_SELECTOR); - Gtk::Widget *wrapped = Gtk::manage(Glib::wrap(w)); - return wrapped; + Gtk::Widget *w = Gtk::manage(new ColorICCSelector(color)); + return w; } Glib::ustring ColorICCSelectorFactory::modeName() const { return gettext(ColorICCSelector::MODE_NAME); } - +} +} +} /* Local Variables: mode:c++ diff --git a/src/ui/widget/color-icc-selector.h b/src/ui/widget/color-icc-selector.h index cee8305cd..b917066dd 100644 --- a/src/ui/widget/color-icc-selector.h +++ b/src/ui/widget/color-icc-selector.h @@ -1,27 +1,43 @@ #ifndef SEEN_SP_COLOR_ICC_SELECTOR_H #define SEEN_SP_COLOR_ICC_SELECTOR_H -#include -#include +#ifdef HAVE_CONFIG_H +# include +#endif + +#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H +#include +#endif + +#include +#if GTK_CHECK_VERSION(3,0,0) +#include +#else +#include +#endif -#include "widgets/sp-color-selector.h" #include "ui/selected-color.h" namespace Inkscape { + class ColorProfile; -} -struct SPColorICCSelector; -struct SPColorICCSelectorClass; +namespace UI { +namespace Widget { class ColorICCSelectorImpl; -class ColorICCSelector: public ColorSelector +class ColorICCSelector +#if GTK_CHECK_VERSION(3,0,0) + : public Gtk::Grid +#else + : public Gtk::Table +#endif { public: static const gchar* MODE_NAME; - ColorICCSelector( SPColorSelector* csel ); + ColorICCSelector(SelectedColor &color); virtual ~ColorICCSelector(); virtual void init(); @@ -42,31 +58,15 @@ private: }; - -#define SP_TYPE_COLOR_ICC_SELECTOR (sp_color_icc_selector_get_type()) -#define SP_COLOR_ICC_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_CAST((o), SP_TYPE_COLOR_ICC_SELECTOR, SPColorICCSelector)) -#define SP_COLOR_ICC_SELECTOR_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), SP_TYPE_COLOR_ICC_SELECTOR, SPColorICCSelectorClass)) -#define SP_IS_COLOR_ICC_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_TYPE((o), SP_TYPE_COLOR_ICC_SELECTOR)) -#define SP_IS_COLOR_ICC_SELECTOR_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE((k), SP_TYPE_COLOR_ICC_SELECTOR)) - -struct SPColorICCSelector { - SPColorSelector parent; -}; - -struct SPColorICCSelectorClass { - SPColorSelectorClass parent_class; -}; - -GType sp_color_icc_selector_get_type(void); - -GtkWidget *sp_color_icc_selector_new(void); - -class ColorICCSelectorFactory: public Inkscape::UI::ColorSelectorFactory { +class ColorICCSelectorFactory: public ColorSelectorFactory { public: - Gtk::Widget* createWidget(Inkscape::UI::SelectedColor &color) const; + Gtk::Widget* createWidget(SelectedColor &color) const; Glib::ustring modeName() const; }; +} +} +} #endif // SEEN_SP_COLOR_ICC_SELECTOR_H /* -- cgit v1.2.3 From ade68e2b3601c0ef2912440b028e7b9e1f326bcc Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sun, 1 Jun 2014 10:41:10 +0200 Subject: inhibit SelectedColor::setColorAlpha in the callbacks of it's signals (bzr r13341.6.43) --- src/ui/selected-color.cpp | 29 ++++++++++++++++++++--------- src/ui/selected-color.h | 4 +++- src/ui/widget/color-entry.cpp | 8 +------- src/ui/widget/color-icc-selector.cpp | 2 +- src/ui/widget/color-scales.cpp | 18 +++++------------- src/ui/widget/color-wheel-selector.cpp | 14 ++------------ 6 files changed, 32 insertions(+), 43 deletions(-) (limited to 'src/ui') diff --git a/src/ui/selected-color.cpp b/src/ui/selected-color.cpp index 10ca68b21..24720f870 100644 --- a/src/ui/selected-color.cpp +++ b/src/ui/selected-color.cpp @@ -28,6 +28,7 @@ SelectedColor::SelectedColor() , _alpha(1.0) , _held(false) , _virgin(true) + , _updating(false) { } @@ -38,7 +39,7 @@ SelectedColor::~SelectedColor() { void SelectedColor::setColor(SPColor const &color) { - setColorAlpha( color, _alpha, true); + setColorAlpha( color, _alpha); } SPColor SelectedColor::color() const @@ -49,7 +50,7 @@ SPColor SelectedColor::color() const void SelectedColor::setAlpha(gfloat alpha) { g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) ); - setColorAlpha( _color, alpha, true); + setColorAlpha( _color, alpha); } gfloat SelectedColor::alpha() const @@ -57,13 +58,17 @@ gfloat SelectedColor::alpha() const return _alpha; } -void SelectedColor::setColorAlpha(SPColor const &color, gfloat alpha, bool emit) +void SelectedColor::setColorAlpha(SPColor const &color, gfloat alpha) { #ifdef DUMP_CHANGE_INFO g_message("SelectedColor::setColorAlpha( this=%p, %f, %f, %f, %s, %f, %s) in %s", this, color.v.c[0], color.v.c[1], color.v.c[2], (color.icc?color.icc->colorProfile.c_str():""), alpha, (emit?"YES":"no"), FOO_NAME(_csel)); #endif g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) ); + if (_updating) { + return; + } + #ifdef DUMP_CHANGE_INFO g_message("---- SelectedColor::setColorAlpha virgin:%s !close:%s alpha is:%s in %s", (_virgin?"YES":"no"), @@ -81,13 +86,14 @@ void SelectedColor::setColorAlpha(SPColor const &color, gfloat alpha, bool emit) _color = color; _alpha = alpha; - if (emit) { - if (_held) { - signal_dragged.emit(); - } else { - signal_changed.emit(); - } + _updating = true; + if (_held) { + signal_dragged.emit(); + } else { + signal_changed.emit(); } + _updating = false; + #ifdef DUMP_CHANGE_INFO } else { g_message("++++ SelectedColor::setColorAlpha color:%08x ==> _color:%08X isClose:%s in %s", color.toRGBA32(alpha), _color.toRGBA32(_alpha), @@ -102,11 +108,15 @@ void SelectedColor::colorAlpha(SPColor &color, gfloat &alpha) const { } void SelectedColor::setHeld(bool held) { + if (_updating) { + return; + } bool grabbed = held && !_held; bool released = !held && _held; _held = held; + _updating = true; if (grabbed) { signal_grabbed.emit(); } @@ -115,6 +125,7 @@ void SelectedColor::setHeld(bool held) { signal_released.emit(); signal_changed.emit(); } + _updating = false; } void SelectedColor::preserveICC() { diff --git a/src/ui/selected-color.h b/src/ui/selected-color.h index 5d3d89672..9f86d4255 100644 --- a/src/ui/selected-color.h +++ b/src/ui/selected-color.h @@ -39,7 +39,7 @@ public: void setAlpha(gfloat alpha); gfloat alpha() const; - void setColorAlpha(SPColor const &color, gfloat alpha, bool emit = false); + void setColorAlpha(SPColor const &color, gfloat alpha); void colorAlpha(SPColor &color, gfloat &alpha) const; void setHeld(bool held); @@ -67,6 +67,8 @@ private: */ bool _virgin; + bool _updating; + static double const _EPSILON; }; diff --git a/src/ui/widget/color-entry.cpp b/src/ui/widget/color-entry.cpp index 56fd6080e..e26cb4ade 100644 --- a/src/ui/widget/color-entry.cpp +++ b/src/ui/widget/color-entry.cpp @@ -71,23 +71,17 @@ void ColorEntry::on_changed() { if (len < 8) { rgba = rgba << (4 * (8 - len)); } - _updating = true; if (changed) { set_text(str); } SPColor color(rgba); - _color.setColorAlpha(color, SP_RGBA32_A_F(rgba), true); - _updating = false; + _color.setColorAlpha(color, SP_RGBA32_A_F(rgba)); } g_free(str); } void ColorEntry::_onColorChanged() { - if (_updating) { - return; - } - SPColor color = _color.color(); gdouble alpha = _color.alpha(); diff --git a/src/ui/widget/color-icc-selector.cpp b/src/ui/widget/color-icc-selector.cpp index 1187dd081..d679f9273 100644 --- a/src/ui/widget/color-icc-selector.cpp +++ b/src/ui/widget/color-icc-selector.cpp @@ -1006,7 +1006,7 @@ void ColorICCSelectorImpl::_adjustmentChanged( GtkAdjustment *adjustment, ColorI } #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) } - iccSelector->_impl->_color.setColorAlpha(newColor, scaled, true); + iccSelector->_impl->_color.setColorAlpha(newColor, scaled); //iccSelector->_updateInternals( newColor, scaled, iccSelector->_impl->_dragging ); iccSelector->_impl->_updateSliders( match ); diff --git a/src/ui/widget/color-scales.cpp b/src/ui/widget/color-scales.cpp index 234e7a2d1..ac1f52da3 100644 --- a/src/ui/widget/color-scales.cpp +++ b/src/ui/widget/color-scales.cpp @@ -164,11 +164,6 @@ void ColorScales::_initUI(SPColorScalesMode mode) void ColorScales::_recalcColor( gboolean changing ) { - if (_updating) { - return; - } - _updating = true; - if ( changing ) { SPColor color; @@ -198,13 +193,12 @@ void ColorScales::_recalcColor( gboolean changing ) } _color.preserveICC(); - _color.setColorAlpha(color, alpha, true); + _color.setColorAlpha(color, alpha); } else { // _updateInternals( _color, _alpha, _dragging ); } - _updating = false; } /* Helpers for setting color value */ @@ -232,7 +226,7 @@ void ColorScales::_setRangeLimit( gdouble upper ) void ColorScales::_onColorChanged() { - if (_updating || !get_visible()) { + if (!get_visible()) { return; } #ifdef DUMP_CHANGE_INFO @@ -468,13 +462,11 @@ void ColorScales::_sliderAnyGrabbed() if (_updating) { return; } - _updating = true; if (!_dragging) { _dragging = TRUE; _color.setHeld(true); _recalcColor( FALSE ); } - _updating = false; } void ColorScales::_sliderAnyReleased() @@ -482,13 +474,11 @@ void ColorScales::_sliderAnyReleased() if (_updating) { return; } - _updating = true; if (_dragging) { _dragging = FALSE; _color.setHeld(false); _recalcColor( FALSE ); } - _updating = false; } void ColorScales::_sliderAnyChanged() @@ -501,7 +491,9 @@ void ColorScales::_sliderAnyChanged() void ColorScales::_adjustmentChanged( ColorScales *scales, guint channel ) { - if (scales->_updating) return; + if (scales->_updating) { + return; + } scales->_updateSliders( (1 << channel) ); scales->_recalcColor (TRUE); diff --git a/src/ui/widget/color-wheel-selector.cpp b/src/ui/widget/color-wheel-selector.cpp index 4bf40dbb6..5f7260635 100644 --- a/src/ui/widget/color-wheel-selector.cpp +++ b/src/ui/widget/color-wheel-selector.cpp @@ -161,10 +161,8 @@ void ColorWheelSelector::_colorChanged() #ifdef DUMP_CHANGE_INFO g_message("ColorWheelSelector::_colorChanged( this=%p, %f, %f, %f, %f)", this, _color.color().v.c[0], _color.color().v.c[1], _color.color().v.c[2], alpha ); #endif - if (_updating) { - return; - } + bool oldval = _updating; _updating = true; { float hsv[3] = {0,0,0}; @@ -180,7 +178,7 @@ void ColorWheelSelector::_colorChanged() ColorScales::setScaled(_alpha_adjustment->gobj(), _color.alpha()); - _updating = false; + _updating = oldval; } void ColorWheelSelector::_adjustmentChanged() @@ -188,7 +186,6 @@ void ColorWheelSelector::_adjustmentChanged() if (_updating) { return; } - _updating = true; // TODO check this. It looks questionable: // if a value is entered between 0 and 1 exclusive, normalize it to (int) 0..255 or 0..100 @@ -200,8 +197,6 @@ void ColorWheelSelector::_adjustmentChanged() _color.preserveICC(); _color.setAlpha(ColorScales::getScaled(_alpha_adjustment->gobj())); - - _updating = false; } void ColorWheelSelector::_sliderGrabbed() @@ -222,10 +217,8 @@ void ColorWheelSelector::_sliderChanged() return; } - _updating = true; _color.preserveICC(); _color.setAlpha(ColorScales::getScaled(_alpha_adjustment->gobj())); - _updating = false; } void ColorWheelSelector::_wheelChanged(GimpColorWheel *wheel, ColorWheelSelector *wheelSelector) @@ -233,7 +226,6 @@ void ColorWheelSelector::_wheelChanged(GimpColorWheel *wheel, ColorWheelSelector if (wheelSelector->_updating){ return; } - wheelSelector->_updating = true; gdouble h = 0; gdouble s = 0; @@ -255,8 +247,6 @@ void ColorWheelSelector::_wheelChanged(GimpColorWheel *wheel, ColorWheelSelector wheelSelector->_color.setHeld(gimp_color_wheel_is_adjusting(wheel)); wheelSelector->_color.setColor(color); - - wheelSelector->_updating = false; } -- cgit v1.2.3 From bb5dacfc027558432b9a46f61329d7bd02731571 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sun, 1 Jun 2014 13:03:36 +0200 Subject: Using SelectedColor in extenstion/param/color (bzr r13341.6.45) --- src/ui/selected-color.cpp | 12 ++++++++++++ src/ui/selected-color.h | 3 +++ 2 files changed, 15 insertions(+) (limited to 'src/ui') diff --git a/src/ui/selected-color.cpp b/src/ui/selected-color.cpp index 24720f870..ed3e06e2f 100644 --- a/src/ui/selected-color.cpp +++ b/src/ui/selected-color.cpp @@ -58,6 +58,18 @@ gfloat SelectedColor::alpha() const return _alpha; } +void SelectedColor::setValue(guint32 value) +{ + SPColor color(value); + gfloat alpha = SP_RGBA32_A_F(value); + setColorAlpha(color, alpha); +} + +guint32 SelectedColor::value() const +{ + return color().toRGBA32(_alpha); +} + void SelectedColor::setColorAlpha(SPColor const &color, gfloat alpha) { #ifdef DUMP_CHANGE_INFO diff --git a/src/ui/selected-color.h b/src/ui/selected-color.h index 9f86d4255..b4268f553 100644 --- a/src/ui/selected-color.h +++ b/src/ui/selected-color.h @@ -39,6 +39,9 @@ public: void setAlpha(gfloat alpha); gfloat alpha() const; + void setValue(guint32 value); + guint32 value() const; + void setColorAlpha(SPColor const &color, gfloat alpha); void colorAlpha(SPColor &color, gfloat &alpha) const; -- cgit v1.2.3 From 0d71d02e49a5eab7f9e79b246961c1349320a986 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sun, 1 Jun 2014 13:24:00 +0200 Subject: using SelectedColor in ColorPicker (bzr r13341.6.46) --- src/ui/widget/color-picker.cpp | 70 ++++++++++++++++++------------------------ src/ui/widget/color-picker.h | 8 +++-- 2 files changed, 35 insertions(+), 43 deletions(-) (limited to 'src/ui') diff --git a/src/ui/widget/color-picker.cpp b/src/ui/widget/color-picker.cpp index 5585f2db4..f909535b1 100644 --- a/src/ui/widget/color-picker.cpp +++ b/src/ui/widget/color-picker.cpp @@ -27,8 +27,6 @@ namespace Inkscape { namespace UI { namespace Widget { -void sp_color_picker_color_mod(SPColorSelector *csel, GObject *cp); - ColorPicker::ColorPicker (const Glib::ustring& title, const Glib::ustring& tip, guint32 rgba, bool undo) : _preview(rgba), _title(title), _rgba(rgba), _undo(undo), @@ -39,12 +37,15 @@ ColorPicker::ColorPicker (const Glib::ustring& title, const Glib::ustring& tip, _preview.show(); add (_preview); set_tooltip_text (tip); + + _selected_color.signal_changed.connect(sigc::mem_fun(this, &ColorPicker::_onSelectedColorChanged)); + _selected_color.signal_dragged.connect(sigc::mem_fun(this, &ColorPicker::_onSelectedColorChanged)); + _selected_color.signal_released.connect(sigc::mem_fun(this, &ColorPicker::_onSelectedColorChanged)); } ColorPicker::~ColorPicker() { closeWindow(); - _colorSelector = NULL; } void ColorPicker::setupDialog(const Glib::ustring &title) @@ -55,25 +56,17 @@ void ColorPicker::setupDialog(const Glib::ustring &title) _colorSelectorDialog.hide(); _colorSelectorDialog.set_title (title); _colorSelectorDialog.set_border_width (4); - _colorSelector = SP_COLOR_SELECTOR(sp_color_selector_new(SP_TYPE_COLOR_NOTEBOOK)); + + _color_selector = Gtk::manage(ColorNotebook::create(_selected_color)); #if WITH_GTKMM_3_0 _colorSelectorDialog.get_content_area()->pack_start ( - *Glib::wrap(&_colorSelector->vbox), true, true, 0); + *_color_selector, true, true, 0); #else _colorSelectorDialog.get_vbox()->pack_start ( - *Glib::wrap(&_colorSelector->vbox), true, true, 0); + *_color_selector, true, true, 0); #endif - - g_signal_connect(G_OBJECT(_colorSelector), "dragged", - G_CALLBACK(sp_color_picker_color_mod), (void *)this); - g_signal_connect(G_OBJECT(_colorSelector), "released", - G_CALLBACK(sp_color_picker_color_mod), (void *)this); - g_signal_connect(G_OBJECT(_colorSelector), "changed", - G_CALLBACK(sp_color_picker_color_mod), (void *)this); - - gtk_widget_show(GTK_WIDGET(_colorSelector)); - + _color_selector->show(); } void ColorPicker::setRgba32 (guint32 rgba) @@ -82,11 +75,11 @@ void ColorPicker::setRgba32 (guint32 rgba) _preview.setRgba32 (rgba); _rgba = rgba; - if (_colorSelector) + if (_color_selector) { - SPColor color; - color.set( rgba ); - _colorSelector->base->setColorAlpha(color, SP_RGBA32_A_F(rgba)); + _updating = true; + _selected_color.setValue(rgba); + _updating = false; } } @@ -97,11 +90,11 @@ void ColorPicker::closeWindow() void ColorPicker::on_clicked() { - if (_colorSelector) + if (_color_selector) { - SPColor color; - color.set( _rgba ); - _colorSelector->base->setColorAlpha(color, SP_RGBA32_A_F(_rgba)); + _updating = true; + _selected_color.setValue(_rgba); + _updating = false; } _colorSelectorDialog.show(); } @@ -110,34 +103,31 @@ void ColorPicker::on_changed (guint32) { } -void sp_color_picker_color_mod(SPColorSelector *csel, GObject *cp) -{ +void ColorPicker::_onSelectedColorChanged() { + if (_updating) { + return; + } + if (_in_use) { return; } else { _in_use = true; } - SPColor color; - float alpha = 0; - csel->base->getColorAlpha(color, alpha); - guint32 rgba = color.toRGBA32( alpha ); - - ColorPicker *ptr = reinterpret_cast(cp); - - (ptr->_preview).setRgba32 (rgba); + guint32 rgba = _selected_color.value(); + _preview.setRgba32(rgba); - if (ptr->_undo && SP_ACTIVE_DESKTOP) + if (_undo && SP_ACTIVE_DESKTOP) { DocumentUndo::done(sp_desktop_document(SP_ACTIVE_DESKTOP), SP_VERB_NONE, - /* TODO: annotate */ "color-picker.cpp:130"); + /* TODO: annotate */ "color-picker.cpp:130"); + } - ptr->on_changed (rgba); + on_changed(rgba); _in_use = false; - ptr->_changed_signal.emit (rgba); - ptr->_rgba = rgba; + _changed_signal.emit(rgba); + _rgba = rgba; } - }//namespace Widget }//namespace UI }//namespace Inkscape diff --git a/src/ui/widget/color-picker.h b/src/ui/widget/color-picker.h index b4da5dbf2..49275a04c 100644 --- a/src/ui/widget/color-picker.h +++ b/src/ui/widget/color-picker.h @@ -26,6 +26,7 @@ #include #include #include +#include "ui/selected-color.h" #include "ui/widget/color-preview.h" struct SPColorSelector; @@ -57,7 +58,7 @@ public: protected: - friend void sp_color_picker_color_mod(SPColorSelector *csel, GObject *cp); + void _onSelectedColorChanged(); virtual void on_clicked(); virtual void on_changed (guint32); @@ -67,13 +68,14 @@ protected: sigc::signal _changed_signal; guint32 _rgba; bool _undo; - + bool _updating; //Dialog void setupDialog(const Glib::ustring &title); //Inkscape::UI::Dialog::Dialog _colorSelectorDialog; Gtk::Dialog _colorSelectorDialog; - SPColorSelector *_colorSelector; + SelectedColor _selected_color; + Gtk::Widget *_color_selector; }; }//namespace Widget -- cgit v1.2.3 From 66275a3a9f7666fe68355c1d8c452395b706db30 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sun, 1 Jun 2014 17:29:01 +0200 Subject: moved ColorNotebook to ui/widget (bzr r13341.6.51) --- src/ui/CMakeLists.txt | 2 + src/ui/widget/Makefile_insert | 2 + src/ui/widget/color-notebook.cpp | 675 +++++++++++++++++++++++++++++++++++++++ src/ui/widget/color-notebook.h | 150 +++++++++ src/ui/widget/color-picker.cpp | 2 +- 5 files changed, 830 insertions(+), 1 deletion(-) create mode 100644 src/ui/widget/color-notebook.cpp create mode 100644 src/ui/widget/color-notebook.h (limited to 'src/ui') diff --git a/src/ui/CMakeLists.txt b/src/ui/CMakeLists.txt index dbfba0508..45b4c7960 100644 --- a/src/ui/CMakeLists.txt +++ b/src/ui/CMakeLists.txt @@ -110,6 +110,7 @@ set(ui_SRC widget/button.cpp widget/color-entry.cpp widget/color-icc-selector.cpp + widget/color-notebook.cpp widget/color-picker.cpp widget/color-preview.cpp widget/color-scales.cpp @@ -277,6 +278,7 @@ set(ui_SRC widget/button.h widget/color-entry.h widget/color-icc-selector.h + widget/color-notebook.h widget/color-picker.h widget/color-preview.h widget/color-scales.h diff --git a/src/ui/widget/Makefile_insert b/src/ui/widget/Makefile_insert index f39236da7..ddb641069 100644 --- a/src/ui/widget/Makefile_insert +++ b/src/ui/widget/Makefile_insert @@ -10,6 +10,8 @@ ink_common_sources += \ ui/widget/color-entry.h \ ui/widget/color-icc-selector.cpp \ ui/widget/color-icc-selector.h \ + ui/widget/color-notebook.cpp \ + ui/widget/color-notebook.h \ ui/widget/color-wheel-selector.cpp \ ui/widget/color-wheel-selector.h \ ui/widget/color-picker.cpp \ diff --git a/src/ui/widget/color-notebook.cpp b/src/ui/widget/color-notebook.cpp new file mode 100644 index 000000000..2b592e620 --- /dev/null +++ b/src/ui/widget/color-notebook.cpp @@ -0,0 +1,675 @@ +/* + * A notebook with RGB, CMYK, CMS, HSL, and Wheel pages + * + * Author: + * Lauris Kaplinski + * bulia byak + * + * Copyright (C) 2001-2002 Lauris Kaplinski + * + * This code is in public domain + */ + +#undef SPCS_PREVIEW +#define noDUMP_CHANGE_INFO + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "widgets/icon.h" +#include +#include +#include +#include +#include +#include +#include + +#include "dialogs/dialog-events.h" +#include "preferences.h" +#include "widgets/spw-utilities.h" +#include "svg/svg-icc-color.h" +#include "inkscape.h" +#include "document.h" +#include "profile-manager.h" +#include "color-profile.h" +#include "cms-system.h" +#include "tools-switch.h" +#include "ui/tools/tool-base.h" +#include "ui/widget/color-entry.h" +#include "ui/widget/color-icc-selector.h" +#include "ui/widget/color-notebook.h" +#include "ui/widget/color-scales.h" +#include "ui/widget/color-wheel-selector.h" + +using Inkscape::CMSSystem; + +using namespace Inkscape::UI; +using namespace Inkscape::UI::Widget; + +struct SPColorNotebookTracker { + const gchar* name; + const gchar* className; + GType type; + guint submode; + gboolean enabledFull; + gboolean enabledBrief; + SPColorNotebook *backPointer; +}; + + +static void sp_color_notebook_class_init (SPColorNotebookClass *klass); +static void sp_color_notebook_init (SPColorNotebook *colorbook); +static void sp_color_notebook_dispose(GObject *object); + +static void sp_color_notebook_show_all (GtkWidget *widget); +static void sp_color_notebook_hide(GtkWidget *widget); + +static SPColorSelectorClass *parent_class; + +#define XPAD 4 +#define YPAD 1 + +GType sp_color_notebook_get_type(void) +{ + static GType type = 0; + if (!type) { + GTypeInfo info = { + sizeof(SPColorNotebookClass), + 0, // base_init + 0, // base_finalize + (GClassInitFunc)sp_color_notebook_class_init, + 0, // class_finalize + 0, // class_data + sizeof(SPColorNotebook), + 0, // n_preallocs + (GInstanceInitFunc)sp_color_notebook_init, + 0 // value_table + }; + type = g_type_register_static(SP_TYPE_COLOR_SELECTOR, "SPColorNotebook", &info, static_cast(0)); + } + return type; +} + +static void sp_color_notebook_class_init(SPColorNotebookClass *klass) +{ + GObjectClass *object_class = reinterpret_cast(klass); + GtkWidgetClass *widget_class = reinterpret_cast(klass); + + parent_class = SP_COLOR_SELECTOR_CLASS(g_type_class_peek_parent(klass)); + + object_class->dispose = sp_color_notebook_dispose; + + widget_class->show_all = sp_color_notebook_show_all; + widget_class->hide = sp_color_notebook_hide; +} + +static void +sp_color_notebook_switch_page(GtkNotebook *notebook, + GtkWidget *page, + guint page_num, + SPColorNotebook *colorbook) +{ + if ( colorbook ) + { + // remember the page we switched to + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setInt("/colorselector/page", page_num); + } +} + +static void +sp_color_notebook_init (SPColorNotebook *colorbook) +{ + SP_COLOR_SELECTOR(colorbook)->base = new ColorNotebook( SP_COLOR_SELECTOR(colorbook) ); + + if ( SP_COLOR_SELECTOR(colorbook)->base ) + { + SP_COLOR_SELECTOR(colorbook)->base->init(); + } +} + +void ColorNotebook::init() +{ + guint row = 0; + + _updating = false; + + _book = gtk_notebook_new (); + gtk_widget_show (_book); + + // Dont show the notebook tabs, use radiobuttons instead + gtk_notebook_set_show_border (GTK_NOTEBOOK (_book), false); + gtk_notebook_set_show_tabs (GTK_NOTEBOOK (_book), false); + +#if GTK_CHECK_VERSION(3,0,0) + _buttonbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); + gtk_box_set_homogeneous(GTK_BOX(_buttonbox), TRUE); +#else + _buttonbox = gtk_hbox_new (TRUE, 2); +#endif + + gtk_widget_show (_buttonbox); + _buttons = new GtkWidget *[_available_pages.size()]; + + for (int i = 0; static_cast(i) < _available_pages.size(); i++ ) + { + _addPage(_available_pages[i]); + } + +#if GTK_CHECK_VERSION(3,0,0) + GtkWidget* table = gtk_grid_new(); +#else + GtkWidget* table = gtk_table_new(2, 3, FALSE); +#endif + + gtk_widget_show (table); + + gtk_box_pack_start (GTK_BOX (_csel), table, TRUE, TRUE, 0); + + sp_set_font_size_smaller (_buttonbox); + +#if GTK_CHECK_VERSION(3,0,0) + gtk_widget_set_margin_left(_buttonbox, XPAD); + gtk_widget_set_margin_right(_buttonbox, XPAD); + gtk_widget_set_margin_top(_buttonbox, YPAD); + gtk_widget_set_margin_bottom(_buttonbox, YPAD); + gtk_widget_set_hexpand(_buttonbox, TRUE); + gtk_widget_set_valign(_buttonbox, GTK_ALIGN_CENTER); + gtk_grid_attach(GTK_GRID(table), _buttonbox, 0, row, 2, 1); +#else + gtk_table_attach (GTK_TABLE (table), _buttonbox, 0, 2, row, row + 1, + static_cast(GTK_EXPAND|GTK_FILL), + static_cast(0), + XPAD, YPAD); +#endif + + row++; + +#if GTK_CHECK_VERSION(3,0,0) + gtk_widget_set_margin_left(_book, XPAD*2); + gtk_widget_set_margin_right(_book, XPAD*2); + gtk_widget_set_margin_top(_book, YPAD); + gtk_widget_set_margin_bottom(_book, YPAD); + gtk_widget_set_hexpand(_book, TRUE); + gtk_widget_set_vexpand(_book, TRUE); + gtk_grid_attach(GTK_GRID(table), _book, 0, row, 2, 1); +#else + gtk_table_attach (GTK_TABLE (table), _book, 0, 2, row, row + 1, + static_cast(GTK_EXPAND|GTK_FILL), + static_cast(GTK_EXPAND|GTK_FILL), + XPAD*2, YPAD); +#endif + + // restore the last active page + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + _setCurrentPage(prefs->getInt("/colorselector/page", 0)); + + + /* Commented out: see comment at the bottom of the header file + { + gboolean found = FALSE; + + _popup = gtk_menu_new(); + GtkMenu *menu = GTK_MENU (_popup); + + for (int i = 0; i < _trackerList->len; i++ ) + { + SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (g_ptr_array_index (_trackerList, i)); + if ( entry ) + { + GtkWidget *item = gtk_check_menu_item_new_with_label (_(entry->name)); + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), entry->enabledFull); + gtk_widget_show (item); + gtk_menu_shell_append (GTK_MENU_SHELL(menu), item); + + g_signal_connect (G_OBJECT (item), "activate", + G_CALLBACK (sp_color_notebook_menuitem_response), + reinterpret_cast< gpointer > (entry) ); + found = TRUE; + } + } + + GtkWidget *arrow = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_NONE); + gtk_widget_show (arrow); + + _btn = gtk_button_new (); + gtk_widget_show (_btn); + gtk_container_add (GTK_CONTAINER (_btn), arrow); + + GtkWidget *align = gtk_alignment_new (1.0, 0.0, 0.0, 0.0); + gtk_widget_show (align); + gtk_container_add (GTK_CONTAINER (align), _btn); + + // uncomment to reenable the "show/hide modes" menu, + // but first fix it so it remembers its settings in prefs and does not take that much space (entire vertical column!) + gtk_table_attach (GTK_TABLE (table), align, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD); + + g_signal_connect_swapped(G_OBJECT(_btn), "event", G_CALLBACK (sp_color_notebook_menu_handler), G_OBJECT(_csel)); + if ( !found ) + { + gtk_widget_set_sensitive (_btn, FALSE); + } + } + */ + + row++; + +#if GTK_CHECK_VERSION(3,0,0) + GtkWidget *rgbabox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); +#else + GtkWidget *rgbabox = gtk_hbox_new (FALSE, 0); +#endif + +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + /* Create color management icons */ + _box_colormanaged = gtk_event_box_new (); + GtkWidget *colormanaged = gtk_image_new_from_icon_name ("color-management-icon", GTK_ICON_SIZE_SMALL_TOOLBAR); + gtk_container_add (GTK_CONTAINER (_box_colormanaged), colormanaged); + gtk_widget_set_tooltip_text (_box_colormanaged, _("Color Managed")); + gtk_widget_set_sensitive (_box_colormanaged, false); + gtk_box_pack_start(GTK_BOX(rgbabox), _box_colormanaged, FALSE, FALSE, 2); + + _box_outofgamut = gtk_event_box_new (); + GtkWidget *outofgamut = gtk_image_new_from_icon_name ("out-of-gamut-icon", GTK_ICON_SIZE_SMALL_TOOLBAR); + gtk_container_add (GTK_CONTAINER (_box_outofgamut), outofgamut); + gtk_widget_set_tooltip_text (_box_outofgamut, _("Out of gamut!")); + gtk_widget_set_sensitive (_box_outofgamut, false); + gtk_box_pack_start(GTK_BOX(rgbabox), _box_outofgamut, FALSE, FALSE, 2); + + _box_toomuchink = gtk_event_box_new (); + GtkWidget *toomuchink = gtk_image_new_from_icon_name ("too-much-ink-icon", GTK_ICON_SIZE_SMALL_TOOLBAR); + gtk_container_add (GTK_CONTAINER (_box_toomuchink), toomuchink); + gtk_widget_set_tooltip_text (_box_toomuchink, _("Too much ink!")); + gtk_widget_set_sensitive (_box_toomuchink, false); + gtk_box_pack_start(GTK_BOX(rgbabox), _box_toomuchink, FALSE, FALSE, 2); +#endif //defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + + + /* Color picker */ + GtkWidget *picker = gtk_image_new_from_icon_name ("color-picker", GTK_ICON_SIZE_SMALL_TOOLBAR); + _btn_picker = gtk_button_new (); + gtk_button_set_relief(GTK_BUTTON(_btn_picker), GTK_RELIEF_NONE); + gtk_container_add (GTK_CONTAINER (_btn_picker), picker); + gtk_widget_set_tooltip_text (_btn_picker, _("Pick colors from image")); + gtk_box_pack_start(GTK_BOX(rgbabox), _btn_picker, FALSE, FALSE, 2); + g_signal_connect(G_OBJECT(_btn_picker), "clicked", G_CALLBACK(ColorNotebook::_picker_clicked), _csel); + + /* Create RGBA entry and color preview */ + _rgbal = gtk_label_new_with_mnemonic (_("RGBA_:")); + gtk_misc_set_alignment (GTK_MISC (_rgbal), 1.0, 0.5); + gtk_box_pack_start(GTK_BOX(rgbabox), _rgbal, TRUE, TRUE, 2); + + ColorEntry* rgba_entry = Gtk::manage(new ColorEntry(_selected_color)); + sp_dialog_defocus_on_enter (GTK_WIDGET(rgba_entry->gobj())); + gtk_box_pack_start(GTK_BOX(rgbabox), GTK_WIDGET(rgba_entry->gobj()), FALSE, FALSE, 0); + gtk_label_set_mnemonic_widget (GTK_LABEL(_rgbal), GTK_WIDGET(rgba_entry->gobj())); + + sp_set_font_size_smaller (rgbabox); + gtk_widget_show_all (rgbabox); + +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + //the "too much ink" icon is initially hidden + gtk_widget_hide(GTK_WIDGET(_box_toomuchink)); +#endif //defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + +#if GTK_CHECK_VERSION(3,0,0) + gtk_widget_set_margin_left(rgbabox, XPAD); + gtk_widget_set_margin_right(rgbabox, XPAD); + gtk_widget_set_margin_top(rgbabox, YPAD); + gtk_widget_set_margin_bottom(rgbabox, YPAD); + gtk_grid_attach(GTK_GRID(table), rgbabox, 0, row, 2, 1); +#else + gtk_table_attach (GTK_TABLE (table), rgbabox, 0, 2, row, row + 1, GTK_FILL, GTK_SHRINK, XPAD, YPAD); +#endif + +#ifdef SPCS_PREVIEW + _p = sp_color_preview_new (0xffffffff); + gtk_widget_show (_p); + gtk_table_attach (GTK_TABLE (table), _p, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD); +#endif + + _switchId = g_signal_connect(G_OBJECT (_book), "switch-page", + G_CALLBACK (sp_color_notebook_switch_page), SP_COLOR_NOTEBOOK(_csel)); + + _selected_color.signal_changed.connect(sigc::mem_fun(this, &ColorNotebook::_onSelectedColorChanged)); + _selected_color.signal_dragged.connect(sigc::mem_fun(this, &ColorNotebook::_onSelectedColorDragged)); + _selected_color.signal_grabbed.connect(sigc::mem_fun(this, &ColorNotebook::_onSelectedColorGrabbed)); + _selected_color.signal_released.connect(sigc::mem_fun(this, &ColorNotebook::_onSelectedColorReleased)); +} + +static void sp_color_notebook_dispose(GObject *object) +{ + if (((GObjectClass *) (parent_class))->dispose) + (* ((GObjectClass *) (parent_class))->dispose) (object); +} + +ColorNotebook::~ColorNotebook() +{ + if ( _switchId ) + { + if ( _book ) + { + g_signal_handler_disconnect (_book, _switchId); + _switchId = 0; + } + } + + if ( _buttons ) + { + delete [] _buttons; + _buttons = 0; + } + +} + +static void +sp_color_notebook_show_all (GtkWidget *widget) +{ + gtk_widget_show (widget); +} + +static void sp_color_notebook_hide(GtkWidget *widget) +{ + gtk_widget_hide(widget); +} + +GtkWidget *sp_color_notebook_new() +{ + SPColorNotebook *colorbook = SP_COLOR_NOTEBOOK(g_object_new (SP_TYPE_COLOR_NOTEBOOK, NULL)); + + return GTK_WIDGET(colorbook); +} + +ColorNotebook::ColorNotebook( SPColorSelector* csel ) + : ColorSelector( csel ) + , _selected_color(_selected_color_tmp) +{ + Page *page; + + page = new Page(new ColorScalesFactory(SP_COLOR_SCALES_MODE_RGB), true); + _available_pages.push_back(page); + page = new Page(new ColorScalesFactory(SP_COLOR_SCALES_MODE_HSV), true); + _available_pages.push_back(page); + page = new Page(new ColorScalesFactory(SP_COLOR_SCALES_MODE_CMYK), true); + _available_pages.push_back(page); + page = new Page(new ColorWheelSelectorFactory, true); + _available_pages.push_back(page); +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + page = new Page(new ColorICCSelectorFactory, true); + _available_pages.push_back(page); +#endif +} + +Gtk::Widget *ColorNotebook::create(SelectedColor &color) { + GtkWidget *w = sp_color_selector_new(SP_TYPE_COLOR_NOTEBOOK); + SPColorSelector *s = SP_COLOR_SELECTOR(w); + ColorNotebook* nb = dynamic_cast(s->base); + return Glib::wrap(w); +} + +ColorNotebook::Page::Page(Inkscape::UI::ColorSelectorFactory *selector_factory, bool enabled_full) + : selector_factory(selector_factory) + , enabled_full(enabled_full) +{ +} + +void ColorNotebook::_colorChanged() +{ + _updating = true; + _selected_color.setColorAlpha(_color, _alpha); + _updateICCButtons(); + _updating = false; +} + +void ColorNotebook::_picker_clicked(GtkWidget * /*widget*/, SPColorNotebook * /*colorbook*/) +{ + // Set the dropper into a "one click" mode, so it reverts to the previous tool after a click + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setBool("/tools/dropper/onetimepick", true); + Inkscape::UI::Tools::sp_toggle_dropper(SP_ACTIVE_DESKTOP); +} + +// TODO pass in param so as to avoid the need for SP_ACTIVE_DOCUMENT +void ColorNotebook::_updateICCButtons() +{ + SPColor color = _selected_color.color(); + gfloat alpha = _selected_color.alpha(); + + g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) ); + +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + /* update color management icon*/ + gtk_widget_set_sensitive (_box_colormanaged, color.icc != NULL); + + /* update out-of-gamut icon */ + gtk_widget_set_sensitive (_box_outofgamut, false); + if (color.icc){ + Inkscape::ColorProfile* target_profile = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str()); + if ( target_profile ) + gtk_widget_set_sensitive(_box_outofgamut, target_profile->GamutCheck(color)); + } + + /* update too-much-ink icon */ + gtk_widget_set_sensitive (_box_toomuchink, false); + if (color.icc){ + Inkscape::ColorProfile* prof = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str()); + if ( prof && CMSSystem::isPrintColorSpace(prof) ) { + gtk_widget_show(GTK_WIDGET(_box_toomuchink)); + double ink_sum = 0; + for (unsigned int i=0; icolors.size(); i++){ + ink_sum += color.icc->colors[i]; + } + + /* Some literature states that when the sum of paint values exceed 320%, it is considered to be a satured color, + which means the paper can get too wet due to an excessive ammount of ink. This may lead to several issues + such as misalignment and poor quality of printing in general.*/ + if ( ink_sum > 3.2 ) + gtk_widget_set_sensitive (_box_toomuchink, true); + } else { + gtk_widget_hide(GTK_WIDGET(_box_toomuchink)); + } + } +#endif //defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) +} + +void ColorNotebook::_setCurrentPage(int i) +{ + gtk_notebook_set_current_page(GTK_NOTEBOOK(_book), i); + + if (_buttons && (static_cast(i) < _available_pages.size())) { + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(_buttons[i]), TRUE); + } +} + +void ColorNotebook::_buttonClicked(GtkWidget *widget, SPColorNotebook *colorbook) +{ + ColorNotebook* nb = dynamic_cast(SP_COLOR_SELECTOR(colorbook)->base); + + if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(widget))) { + return; + } + + for(gint i = 0; i < gtk_notebook_get_n_pages (GTK_NOTEBOOK (nb->_book)); i++) { + if (nb->_buttons[i] == widget) { + gtk_notebook_set_current_page (GTK_NOTEBOOK (nb->_book), i); + } + } +} + +void ColorNotebook::_onSelectedColorChanged() { + if (_updating) { + return; + } + + SPColor color; + gfloat alpha = 1.0; + _selected_color.colorAlpha(color, alpha); + _updateInternals(color, alpha, false); + _updateICCButtons(); +} + +void ColorNotebook::_onSelectedColorDragged() { + if (_updating) { + return; + } + SPColor color; + gfloat alpha = 1.0; + _selected_color.colorAlpha(color, alpha); + _updateInternals(color, alpha, true); + _updateICCButtons(); +} + +void ColorNotebook::_onSelectedColorGrabbed() { + if (_updating) { + return; + } + + _grabbed(); +} + +void ColorNotebook::_onSelectedColorReleased() { + if (_updating) { + return; + } + _released(); +} + +GtkWidget* ColorNotebook::_addPage(Page& page) { + Gtk::Widget *selector_widget; + + selector_widget = page.selector_factory->createWidget(_selected_color); + if (selector_widget) { + selector_widget->show(); + + Glib::ustring mode_name = page.selector_factory->modeName(); + Gtk::Widget* tab_label = Gtk::manage(new Gtk::Label(mode_name)); + gint page_num = gtk_notebook_append_page( GTK_NOTEBOOK(_book), selector_widget->gobj(), tab_label->gobj()); + + _buttons[page_num] = gtk_radio_button_new_with_label(NULL, mode_name.c_str()); + gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(_buttons[page_num]), FALSE); + if (page_num > 0) { + GSList *group = gtk_radio_button_get_group (GTK_RADIO_BUTTON(_buttons[0])); + gtk_radio_button_set_group (GTK_RADIO_BUTTON(_buttons[page_num]), group); + } + gtk_widget_show (_buttons[page_num]); + gtk_box_pack_start (GTK_BOX (_buttonbox), _buttons[page_num], TRUE, TRUE, 0); + + g_signal_connect (G_OBJECT (_buttons[page_num]), "clicked", G_CALLBACK (_buttonClicked), _csel); + } + + return selector_widget->gobj(); +} + + +/* Commented out: see comment at the bottom of the header file + +GtkWidget* ColorNotebook::getPage(GType page_type, guint submode) +{ + gint count = 0; + gint i = 0; + GtkWidget* page = 0; + +// count = gtk_notebook_get_n_pages (_book); + count = 200; + for ( i = 0; i < count && !page; i++ ) + { + page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), i); + if ( page ) + { + SPColorSelector* csel; + guint pagemode; + csel = SP_COLOR_SELECTOR (page); + pagemode = csel->base->getSubmode(); + if ( G_TYPE_FROM_INSTANCE (page) == page_type + && pagemode == submode ) + { + // found it. + break; + } + else + { + page = 0; + } + } + else + { + break; + } + } + return page; +} + +void ColorNotebook::removePage( GType page_type, guint submode ) +{ + GtkWidget *page = 0; + + page = getPage(page_type, submode); + if ( page ) + { + gint where = gtk_notebook_page_num (GTK_NOTEBOOK (_book), page); + if ( where >= 0 ) + { + if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (_book)) == where ) + { +// getColorAlpha(_color, &_alpha); + } + gtk_notebook_remove_page (GTK_NOTEBOOK (_book), where); + } + } +} + + +static gint sp_color_notebook_menu_handler( GtkWidget *widget, GdkEvent *event ) +{ + if (event->type == GDK_BUTTON_PRESS) + { + SPColorSelector* csel = SP_COLOR_SELECTOR(widget); + (dynamic_cast(csel->base))->menuHandler( event ); + + // Tell calling code that we have handled this event; the buck + // stops here. + return TRUE; + } + + //Tell calling code that we have not handled this event; pass it on. + return FALSE; +} + +gint ColorNotebook::menuHandler( GdkEvent* event ) +{ + GdkEventButton *bevent = (GdkEventButton *) event; + gtk_menu_popup (GTK_MENU( _popup ), NULL, NULL, NULL, NULL, + bevent->button, bevent->time); + return TRUE; +} + +static void sp_color_notebook_menuitem_response (GtkMenuItem *menuitem, gpointer user_data) +{ + gboolean active = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem)); + SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (user_data); + if ( entry ) + { + if ( active ) + { + (dynamic_cast(SP_COLOR_SELECTOR(entry->backPointer)->base))->addPage(entry->type, entry->submode); + } + else + { + (dynamic_cast(SP_COLOR_SELECTOR(entry->backPointer)->base))->removePage(entry->type, entry->submode); + } + } +} +*/ + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 : diff --git a/src/ui/widget/color-notebook.h b/src/ui/widget/color-notebook.h new file mode 100644 index 000000000..177519e25 --- /dev/null +++ b/src/ui/widget/color-notebook.h @@ -0,0 +1,150 @@ +#ifndef SEEN_SP_COLOR_NOTEBOOK_H +#define SEEN_SP_COLOR_NOTEBOOK_H + +/* + * A notebook with RGB, CMYK, CMS, HSL, and Wheel pages + * + * Author: + * Lauris Kaplinski + * + * Copyright (C) 2001-2002 Lauris Kaplinski + * + * This code is in public domain + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H +#include +#endif + +#include +#include +#include +#include + +#include "color.h" +#include "widgets/sp-color-selector.h" +#include "ui/selected-color.h" + + +struct SPColorNotebook; + +class ColorNotebook: public ColorSelector +{ +public: + ColorNotebook( SPColorSelector* csel ); + virtual ~ColorNotebook(); + + //Temporary factory method - transition from SPColorSelector + static Gtk::Widget* create(Inkscape::UI::SelectedColor &color); + + virtual void init(); + +protected: + struct Page { + Page(Inkscape::UI::ColorSelectorFactory *selector_factory, bool enabled_full); + + Inkscape::UI::ColorSelectorFactory *selector_factory; + bool enabled_full; + }; + + static void _buttonClicked(GtkWidget *widget, SPColorNotebook *colorbook); + static void _picker_clicked(GtkWidget *widget, SPColorNotebook *colorbook); + + virtual void _colorChanged(); + + virtual void _onSelectedColorChanged(); + virtual void _onSelectedColorDragged(); + virtual void _onSelectedColorGrabbed(); + virtual void _onSelectedColorReleased(); + + void _updateICCButtons(); + void _setCurrentPage(int i); + + GtkWidget* _addPage(Page& page); + + Inkscape::UI::SelectedColor _selected_color_tmp; + Inkscape::UI::SelectedColor &_selected_color; + gboolean _updating : 1; + gulong _switchId; + gulong _entryId; + GtkWidget *_book; + GtkWidget *_buttonbox; + GtkWidget **_buttons; + GtkWidget *_rgbal; /* RGBA entry */ +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + GtkWidget *_box_outofgamut, *_box_colormanaged, *_box_toomuchink; +#endif //defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + GtkWidget *_btn_picker; + GtkWidget *_p; /* Color preview */ + boost::ptr_vector _available_pages; + +private: + // By default, disallow copy constructor and assignment operator + ColorNotebook( const ColorNotebook& obj ); + ColorNotebook& operator=( const ColorNotebook& obj ); + + /* Following methods support the pop-up menu to choose + * active color selectors (notebook tabs). This function + * is not used in Inkscape. If you want to re-enable it you have to + * * port the code to c++ + * * fix it so it remembers its settings in prefs + * * fix it so it does not take that much space (entire vertical column!) + * Current class design supports dynamic addtion and removal of color selectors + * + GtkWidget* addPage( GType page_type, guint submode ); + void removePage( GType page_type, guint submode ); + GtkWidget* getPage( GType page_type, guint submode ); + gint menuHandler( GdkEvent* event ); + + */ +}; + + + + + +#define SP_TYPE_COLOR_NOTEBOOK (sp_color_notebook_get_type ()) +#define SP_COLOR_NOTEBOOK(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SP_TYPE_COLOR_NOTEBOOK, SPColorNotebook)) +#define SP_COLOR_NOTEBOOK_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), SP_TYPE_COLOR_NOTEBOOK, SPColorNotebookClass)) +#define SP_IS_COLOR_NOTEBOOK(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), SP_TYPE_COLOR_NOTEBOOK)) +#define SP_IS_COLOR_NOTEBOOK_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SP_TYPE_COLOR_NOTEBOOK)) + +struct SPColorNotebook { + SPColorSelector parent; /* Parent */ +}; + +struct SPColorNotebookClass { + SPColorSelectorClass parent_class; + + void (* grabbed) (SPColorNotebook *rgbsel); + void (* dragged) (SPColorNotebook *rgbsel); + void (* released) (SPColorNotebook *rgbsel); + void (* changed) (SPColorNotebook *rgbsel); +}; + +GType sp_color_notebook_get_type(void); + +GtkWidget *sp_color_notebook_new (void); + +/* void sp_color_notebook_set_mode (SPColorNotebook *csel, SPColorNotebookMode mode); */ +/* SPColorNotebookMode sp_color_notebook_get_mode (SPColorNotebook *csel); */ + + + +#endif // SEEN_SP_COLOR_NOTEBOOK_H + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 : + diff --git a/src/ui/widget/color-picker.cpp b/src/ui/widget/color-picker.cpp index f909535b1..dc827f377 100644 --- a/src/ui/widget/color-picker.cpp +++ b/src/ui/widget/color-picker.cpp @@ -17,7 +17,7 @@ #include "document-undo.h" #include "dialogs/dialog-events.h" -#include "widgets/sp-color-notebook.h" +#include "ui/widget/color-notebook.h" #include "verbs.h" -- cgit v1.2.3 From 761b8956cc9cb923a7e7c5a95eacfaf7ba36d475 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sun, 1 Jun 2014 19:00:26 +0200 Subject: ColorNotebook is Gtk::Widget and uses ColorSelector (bzr r13341.6.52) --- src/ui/widget/color-notebook.cpp | 334 +++++++++++---------------------------- src/ui/widget/color-notebook.h | 94 ++++------- src/ui/widget/color-picker.cpp | 2 +- 3 files changed, 122 insertions(+), 308 deletions(-) (limited to 'src/ui') diff --git a/src/ui/widget/color-notebook.cpp b/src/ui/widget/color-notebook.cpp index 2b592e620..32a141e08 100644 --- a/src/ui/widget/color-notebook.cpp +++ b/src/ui/widget/color-notebook.cpp @@ -1,11 +1,13 @@ -/* - * A notebook with RGB, CMYK, CMS, HSL, and Wheel pages - * - * Author: +/** + * @file + * A notebook with RGB, CMYK, CMS, HSL, and Wheel pages - implementation + */ +/* Authors: * Lauris Kaplinski * bulia byak + * Tomasz Boczkowski (c++-sification) * - * Copyright (C) 2001-2002 Lauris Kaplinski + * Copyright (C) 2001-2014 Authors * * This code is in public domain */ @@ -25,6 +27,7 @@ #include #include #include +#include #include "dialogs/dialog-events.h" #include "preferences.h" @@ -45,103 +48,70 @@ using Inkscape::CMSSystem; -using namespace Inkscape::UI; -using namespace Inkscape::UI::Widget; - -struct SPColorNotebookTracker { - const gchar* name; - const gchar* className; - GType type; - guint submode; - gboolean enabledFull; - gboolean enabledBrief; - SPColorNotebook *backPointer; -}; - - -static void sp_color_notebook_class_init (SPColorNotebookClass *klass); -static void sp_color_notebook_init (SPColorNotebook *colorbook); -static void sp_color_notebook_dispose(GObject *object); - -static void sp_color_notebook_show_all (GtkWidget *widget); -static void sp_color_notebook_hide(GtkWidget *widget); - -static SPColorSelectorClass *parent_class; - #define XPAD 4 #define YPAD 1 -GType sp_color_notebook_get_type(void) -{ - static GType type = 0; - if (!type) { - GTypeInfo info = { - sizeof(SPColorNotebookClass), - 0, // base_init - 0, // base_finalize - (GClassInitFunc)sp_color_notebook_class_init, - 0, // class_finalize - 0, // class_data - sizeof(SPColorNotebook), - 0, // n_preallocs - (GInstanceInitFunc)sp_color_notebook_init, - 0 // value_table - }; - type = g_type_register_static(SP_TYPE_COLOR_SELECTOR, "SPColorNotebook", &info, static_cast(0)); - } - return type; -} +namespace Inkscape { +namespace UI { +namespace Widget { + + +ColorNotebook::ColorNotebook(SelectedColor &color) +#if GTK_CHECK_VERSION(3,0,0) + : Gtk::Grid() +#else + : Gtk::Table(2, 3, false) +#endif + , _selected_color(color) -static void sp_color_notebook_class_init(SPColorNotebookClass *klass) { - GObjectClass *object_class = reinterpret_cast(klass); - GtkWidgetClass *widget_class = reinterpret_cast(klass); + Page *page; - parent_class = SP_COLOR_SELECTOR_CLASS(g_type_class_peek_parent(klass)); + page = new Page(new ColorScalesFactory(SP_COLOR_SCALES_MODE_RGB), true); + _available_pages.push_back(page); + page = new Page(new ColorScalesFactory(SP_COLOR_SCALES_MODE_HSV), true); + _available_pages.push_back(page); + page = new Page(new ColorScalesFactory(SP_COLOR_SCALES_MODE_CMYK), true); + _available_pages.push_back(page); + page = new Page(new ColorWheelSelectorFactory, true); + _available_pages.push_back(page); +#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) + page = new Page(new ColorICCSelectorFactory, true); + _available_pages.push_back(page); +#endif - object_class->dispose = sp_color_notebook_dispose; + _initUI(); - widget_class->show_all = sp_color_notebook_show_all; - widget_class->hide = sp_color_notebook_hide; + _selected_color.signal_changed.connect(sigc::mem_fun(this, &ColorNotebook::_onSelectedColorChanged)); + _selected_color.signal_dragged.connect(sigc::mem_fun(this, &ColorNotebook::_onSelectedColorChanged)); } -static void -sp_color_notebook_switch_page(GtkNotebook *notebook, - GtkWidget *page, - guint page_num, - SPColorNotebook *colorbook) +ColorNotebook::~ColorNotebook() { - if ( colorbook ) + if ( _buttons ) { - // remember the page we switched to - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setInt("/colorselector/page", page_num); + delete [] _buttons; + _buttons = 0; } + } -static void -sp_color_notebook_init (SPColorNotebook *colorbook) +ColorNotebook::Page::Page(Inkscape::UI::ColorSelectorFactory *selector_factory, bool enabled_full) + : selector_factory(selector_factory) + , enabled_full(enabled_full) { - SP_COLOR_SELECTOR(colorbook)->base = new ColorNotebook( SP_COLOR_SELECTOR(colorbook) ); - - if ( SP_COLOR_SELECTOR(colorbook)->base ) - { - SP_COLOR_SELECTOR(colorbook)->base->init(); - } } -void ColorNotebook::init() + +void ColorNotebook::_initUI() { guint row = 0; - _updating = false; - - _book = gtk_notebook_new (); - gtk_widget_show (_book); - - // Dont show the notebook tabs, use radiobuttons instead - gtk_notebook_set_show_border (GTK_NOTEBOOK (_book), false); - gtk_notebook_set_show_tabs (GTK_NOTEBOOK (_book), false); + Gtk::Notebook *notebook = Gtk::manage(new Gtk::Notebook); + notebook->show(); + notebook->set_show_border(false); + notebook->set_show_tabs(false); + _book = GTK_WIDGET(notebook->gobj()); #if GTK_CHECK_VERSION(3,0,0) _buttonbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); @@ -158,16 +128,6 @@ void ColorNotebook::init() _addPage(_available_pages[i]); } -#if GTK_CHECK_VERSION(3,0,0) - GtkWidget* table = gtk_grid_new(); -#else - GtkWidget* table = gtk_table_new(2, 3, FALSE); -#endif - - gtk_widget_show (table); - - gtk_box_pack_start (GTK_BOX (_csel), table, TRUE, TRUE, 0); - sp_set_font_size_smaller (_buttonbox); #if GTK_CHECK_VERSION(3,0,0) @@ -177,12 +137,9 @@ void ColorNotebook::init() gtk_widget_set_margin_bottom(_buttonbox, YPAD); gtk_widget_set_hexpand(_buttonbox, TRUE); gtk_widget_set_valign(_buttonbox, GTK_ALIGN_CENTER); - gtk_grid_attach(GTK_GRID(table), _buttonbox, 0, row, 2, 1); + attach(*Glib::wrap(_buttonbox), 0, row, 2, 1); #else - gtk_table_attach (GTK_TABLE (table), _buttonbox, 0, 2, row, row + 1, - static_cast(GTK_EXPAND|GTK_FILL), - static_cast(0), - XPAD, YPAD); + attach(*Glib::wrap(_buttonbox), 0, 2, row, row+1, Gtk::EXPAND | Gtk::FILL, static_cast(0), XPAD, YPAD); #endif row++; @@ -194,12 +151,9 @@ void ColorNotebook::init() gtk_widget_set_margin_bottom(_book, YPAD); gtk_widget_set_hexpand(_book, TRUE); gtk_widget_set_vexpand(_book, TRUE); - gtk_grid_attach(GTK_GRID(table), _book, 0, row, 2, 1); + attach(*notebook, 0, row, 2, 1); #else - gtk_table_attach (GTK_TABLE (table), _book, 0, 2, row, row + 1, - static_cast(GTK_EXPAND|GTK_FILL), - static_cast(GTK_EXPAND|GTK_FILL), - XPAD*2, YPAD); + attach(*notebook, 0, 2, row, row+1, Gtk::EXPAND | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, XPAD * 2, YPAD); #endif // restore the last active page @@ -294,7 +248,7 @@ void ColorNotebook::init() gtk_container_add (GTK_CONTAINER (_btn_picker), picker); gtk_widget_set_tooltip_text (_btn_picker, _("Pick colors from image")); gtk_box_pack_start(GTK_BOX(rgbabox), _btn_picker, FALSE, FALSE, 2); - g_signal_connect(G_OBJECT(_btn_picker), "clicked", G_CALLBACK(ColorNotebook::_picker_clicked), _csel); + g_signal_connect(G_OBJECT(_btn_picker), "clicked", G_CALLBACK(ColorNotebook::_onPickerClicked), this); /* Create RGBA entry and color preview */ _rgbal = gtk_label_new_with_mnemonic (_("RGBA_:")); @@ -319,118 +273,60 @@ void ColorNotebook::init() gtk_widget_set_margin_right(rgbabox, XPAD); gtk_widget_set_margin_top(rgbabox, YPAD); gtk_widget_set_margin_bottom(rgbabox, YPAD); + attach(*Glib::wrap(rgbabox), 0, row, 2, 1); gtk_grid_attach(GTK_GRID(table), rgbabox, 0, row, 2, 1); #else - gtk_table_attach (GTK_TABLE (table), rgbabox, 0, 2, row, row + 1, GTK_FILL, GTK_SHRINK, XPAD, YPAD); + attach(*Glib::wrap(rgbabox), 0, 2, row, row + 1, Gtk::FILL, Gtk::SHRINK, XPAD, YPAD); #endif #ifdef SPCS_PREVIEW _p = sp_color_preview_new (0xffffffff); gtk_widget_show (_p); - gtk_table_attach (GTK_TABLE (table), _p, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD); + attach(*Glib::wrap(_p), 2, 3, row, row + 1, Gtk::FILL, Gtk::FILL, XPAD, YPAD); #endif - _switchId = g_signal_connect(G_OBJECT (_book), "switch-page", - G_CALLBACK (sp_color_notebook_switch_page), SP_COLOR_NOTEBOOK(_csel)); - - _selected_color.signal_changed.connect(sigc::mem_fun(this, &ColorNotebook::_onSelectedColorChanged)); - _selected_color.signal_dragged.connect(sigc::mem_fun(this, &ColorNotebook::_onSelectedColorDragged)); - _selected_color.signal_grabbed.connect(sigc::mem_fun(this, &ColorNotebook::_onSelectedColorGrabbed)); - _selected_color.signal_released.connect(sigc::mem_fun(this, &ColorNotebook::_onSelectedColorReleased)); + g_signal_connect(G_OBJECT (_book), "switch-page", + G_CALLBACK (ColorNotebook::_onPageSwitched), this); } -static void sp_color_notebook_dispose(GObject *object) +void ColorNotebook::_onPickerClicked(GtkWidget * /*widget*/, ColorNotebook * /*colorbook*/) { - if (((GObjectClass *) (parent_class))->dispose) - (* ((GObjectClass *) (parent_class))->dispose) (object); + // Set the dropper into a "one click" mode, so it reverts to the previous tool after a click + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setBool("/tools/dropper/onetimepick", true); + Inkscape::UI::Tools::sp_toggle_dropper(SP_ACTIVE_DESKTOP); } -ColorNotebook::~ColorNotebook() +void ColorNotebook::_onButtonClicked(GtkWidget *widget, ColorNotebook *nb) { - if ( _switchId ) - { - if ( _book ) - { - g_signal_handler_disconnect (_book, _switchId); - _switchId = 0; - } + if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(widget))) { + return; } - if ( _buttons ) - { - delete [] _buttons; - _buttons = 0; + for(gint i = 0; i < gtk_notebook_get_n_pages (GTK_NOTEBOOK (nb->_book)); i++) { + if (nb->_buttons[i] == widget) { + gtk_notebook_set_current_page (GTK_NOTEBOOK (nb->_book), i); + } } - } -static void -sp_color_notebook_show_all (GtkWidget *widget) -{ - gtk_widget_show (widget); -} - -static void sp_color_notebook_hide(GtkWidget *widget) -{ - gtk_widget_hide(widget); -} - -GtkWidget *sp_color_notebook_new() -{ - SPColorNotebook *colorbook = SP_COLOR_NOTEBOOK(g_object_new (SP_TYPE_COLOR_NOTEBOOK, NULL)); - - return GTK_WIDGET(colorbook); -} - -ColorNotebook::ColorNotebook( SPColorSelector* csel ) - : ColorSelector( csel ) - , _selected_color(_selected_color_tmp) -{ - Page *page; - - page = new Page(new ColorScalesFactory(SP_COLOR_SCALES_MODE_RGB), true); - _available_pages.push_back(page); - page = new Page(new ColorScalesFactory(SP_COLOR_SCALES_MODE_HSV), true); - _available_pages.push_back(page); - page = new Page(new ColorScalesFactory(SP_COLOR_SCALES_MODE_CMYK), true); - _available_pages.push_back(page); - page = new Page(new ColorWheelSelectorFactory, true); - _available_pages.push_back(page); -#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - page = new Page(new ColorICCSelectorFactory, true); - _available_pages.push_back(page); -#endif -} - -Gtk::Widget *ColorNotebook::create(SelectedColor &color) { - GtkWidget *w = sp_color_selector_new(SP_TYPE_COLOR_NOTEBOOK); - SPColorSelector *s = SP_COLOR_SELECTOR(w); - ColorNotebook* nb = dynamic_cast(s->base); - return Glib::wrap(w); -} - -ColorNotebook::Page::Page(Inkscape::UI::ColorSelectorFactory *selector_factory, bool enabled_full) - : selector_factory(selector_factory) - , enabled_full(enabled_full) -{ -} - -void ColorNotebook::_colorChanged() -{ - _updating = true; - _selected_color.setColorAlpha(_color, _alpha); +void ColorNotebook::_onSelectedColorChanged() { _updateICCButtons(); - _updating = false; } -void ColorNotebook::_picker_clicked(GtkWidget * /*widget*/, SPColorNotebook * /*colorbook*/) +void ColorNotebook::_onPageSwitched(GtkNotebook *notebook, + GtkWidget *page, + guint page_num, + ColorNotebook *colorbook) { - // Set the dropper into a "one click" mode, so it reverts to the previous tool after a click - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - prefs->setBool("/tools/dropper/onetimepick", true); - Inkscape::UI::Tools::sp_toggle_dropper(SP_ACTIVE_DESKTOP); + if (colorbook) { + // remember the page we switched to + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + prefs->setInt("/colorselector/page", page_num); + } } + // TODO pass in param so as to avoid the need for SP_ACTIVE_DOCUMENT void ColorNotebook::_updateICCButtons() { @@ -483,60 +379,7 @@ void ColorNotebook::_setCurrentPage(int i) } } -void ColorNotebook::_buttonClicked(GtkWidget *widget, SPColorNotebook *colorbook) -{ - ColorNotebook* nb = dynamic_cast(SP_COLOR_SELECTOR(colorbook)->base); - - if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(widget))) { - return; - } - - for(gint i = 0; i < gtk_notebook_get_n_pages (GTK_NOTEBOOK (nb->_book)); i++) { - if (nb->_buttons[i] == widget) { - gtk_notebook_set_current_page (GTK_NOTEBOOK (nb->_book), i); - } - } -} - -void ColorNotebook::_onSelectedColorChanged() { - if (_updating) { - return; - } - - SPColor color; - gfloat alpha = 1.0; - _selected_color.colorAlpha(color, alpha); - _updateInternals(color, alpha, false); - _updateICCButtons(); -} - -void ColorNotebook::_onSelectedColorDragged() { - if (_updating) { - return; - } - SPColor color; - gfloat alpha = 1.0; - _selected_color.colorAlpha(color, alpha); - _updateInternals(color, alpha, true); - _updateICCButtons(); -} - -void ColorNotebook::_onSelectedColorGrabbed() { - if (_updating) { - return; - } - - _grabbed(); -} - -void ColorNotebook::_onSelectedColorReleased() { - if (_updating) { - return; - } - _released(); -} - -GtkWidget* ColorNotebook::_addPage(Page& page) { +void ColorNotebook::_addPage(Page& page) { Gtk::Widget *selector_widget; selector_widget = page.selector_factory->createWidget(_selected_color); @@ -556,12 +399,13 @@ GtkWidget* ColorNotebook::_addPage(Page& page) { gtk_widget_show (_buttons[page_num]); gtk_box_pack_start (GTK_BOX (_buttonbox), _buttons[page_num], TRUE, TRUE, 0); - g_signal_connect (G_OBJECT (_buttons[page_num]), "clicked", G_CALLBACK (_buttonClicked), _csel); + g_signal_connect (G_OBJECT (_buttons[page_num]), "clicked", G_CALLBACK (_onButtonClicked), this); } - - return selector_widget->gobj(); } +} +} +} /* Commented out: see comment at the bottom of the header file diff --git a/src/ui/widget/color-notebook.h b/src/ui/widget/color-notebook.h index 177519e25..8b74f20f1 100644 --- a/src/ui/widget/color-notebook.h +++ b/src/ui/widget/color-notebook.h @@ -1,16 +1,18 @@ -#ifndef SEEN_SP_COLOR_NOTEBOOK_H -#define SEEN_SP_COLOR_NOTEBOOK_H - -/* +/** + * @file * A notebook with RGB, CMYK, CMS, HSL, and Wheel pages - * - * Author: + */ +/* Authors: * Lauris Kaplinski + * bulia byak + * Tomasz Boczkowski (c++-sification) * - * Copyright (C) 2001-2002 Lauris Kaplinski + * Copyright (C) 2001-2014 Authors * * This code is in public domain */ +#ifndef SEEN_SP_COLOR_NOTEBOOK_H +#define SEEN_SP_COLOR_NOTEBOOK_H #ifdef HAVE_CONFIG_H # include @@ -23,26 +25,30 @@ #include #include #include +#if GTK_CHECK_VERSION(3,0,0) +#include +#else #include +#endif #include "color.h" -#include "widgets/sp-color-selector.h" #include "ui/selected-color.h" +namespace Inkscape { +namespace UI { +namespace Widget { -struct SPColorNotebook; - -class ColorNotebook: public ColorSelector +class ColorNotebook +#if GTK_CHECK_VERSION(3,0,0) + : public Gtk::Grid +#else + : public Gtk::Table +#endif { public: - ColorNotebook( SPColorSelector* csel ); + ColorNotebook(SelectedColor &color); virtual ~ColorNotebook(); - //Temporary factory method - transition from SPColorSelector - static Gtk::Widget* create(Inkscape::UI::SelectedColor &color); - - virtual void init(); - protected: struct Page { Page(Inkscape::UI::ColorSelectorFactory *selector_factory, bool enabled_full); @@ -51,25 +57,19 @@ protected: bool enabled_full; }; - static void _buttonClicked(GtkWidget *widget, SPColorNotebook *colorbook); - static void _picker_clicked(GtkWidget *widget, SPColorNotebook *colorbook); - - virtual void _colorChanged(); + virtual void _initUI(); + void _addPage(Page& page); + static void _onButtonClicked(GtkWidget *widget, ColorNotebook *colorbook); + static void _onPickerClicked(GtkWidget *widget, ColorNotebook *colorbook); + static void _onPageSwitched(GtkNotebook *notebook, GtkWidget *page, + guint page_num, ColorNotebook *colorbook); virtual void _onSelectedColorChanged(); - virtual void _onSelectedColorDragged(); - virtual void _onSelectedColorGrabbed(); - virtual void _onSelectedColorReleased(); void _updateICCButtons(); void _setCurrentPage(int i); - GtkWidget* _addPage(Page& page); - - Inkscape::UI::SelectedColor _selected_color_tmp; Inkscape::UI::SelectedColor &_selected_color; - gboolean _updating : 1; - gulong _switchId; gulong _entryId; GtkWidget *_book; GtkWidget *_buttonbox; @@ -103,40 +103,10 @@ private: */ }; - - - - -#define SP_TYPE_COLOR_NOTEBOOK (sp_color_notebook_get_type ()) -#define SP_COLOR_NOTEBOOK(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SP_TYPE_COLOR_NOTEBOOK, SPColorNotebook)) -#define SP_COLOR_NOTEBOOK_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), SP_TYPE_COLOR_NOTEBOOK, SPColorNotebookClass)) -#define SP_IS_COLOR_NOTEBOOK(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), SP_TYPE_COLOR_NOTEBOOK)) -#define SP_IS_COLOR_NOTEBOOK_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SP_TYPE_COLOR_NOTEBOOK)) - -struct SPColorNotebook { - SPColorSelector parent; /* Parent */ -}; - -struct SPColorNotebookClass { - SPColorSelectorClass parent_class; - - void (* grabbed) (SPColorNotebook *rgbsel); - void (* dragged) (SPColorNotebook *rgbsel); - void (* released) (SPColorNotebook *rgbsel); - void (* changed) (SPColorNotebook *rgbsel); -}; - -GType sp_color_notebook_get_type(void); - -GtkWidget *sp_color_notebook_new (void); - -/* void sp_color_notebook_set_mode (SPColorNotebook *csel, SPColorNotebookMode mode); */ -/* SPColorNotebookMode sp_color_notebook_get_mode (SPColorNotebook *csel); */ - - - +} +} +} #endif // SEEN_SP_COLOR_NOTEBOOK_H - /* Local Variables: mode:c++ diff --git a/src/ui/widget/color-picker.cpp b/src/ui/widget/color-picker.cpp index dc827f377..a9948309e 100644 --- a/src/ui/widget/color-picker.cpp +++ b/src/ui/widget/color-picker.cpp @@ -57,7 +57,7 @@ void ColorPicker::setupDialog(const Glib::ustring &title) _colorSelectorDialog.set_title (title); _colorSelectorDialog.set_border_width (4); - _color_selector = Gtk::manage(ColorNotebook::create(_selected_color)); + _color_selector = Gtk::manage(new ColorNotebook(_selected_color)); #if WITH_GTKMM_3_0 _colorSelectorDialog.get_content_area()->pack_start ( -- cgit v1.2.3 From 6ebb6cfcf28dfd36a22ce4fe11324971c34ee70c Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 2 May 2015 14:54:37 +0200 Subject: gtk3 compile fix (bzr r14059.1.13) --- src/ui/dialog/objects.h | 4 ---- src/ui/selected-color.cpp | 8 ++------ src/ui/selected-color.h | 14 +++++--------- src/ui/widget/color-notebook.h | 10 +++------- 4 files changed, 10 insertions(+), 26 deletions(-) (limited to 'src/ui') diff --git a/src/ui/dialog/objects.h b/src/ui/dialog/objects.h index aa50353c2..7a826d02e 100644 --- a/src/ui/dialog/objects.h +++ b/src/ui/dialog/objects.h @@ -16,10 +16,6 @@ # include #endif -#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H -# include -#endif - #include #include #include diff --git a/src/ui/selected-color.cpp b/src/ui/selected-color.cpp index 0d3505c45..7652e5acf 100644 --- a/src/ui/selected-color.cpp +++ b/src/ui/selected-color.cpp @@ -14,15 +14,11 @@ # include "config.h" #endif -#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H -#include -#endif - +#include #include -#include -#include "selected-color.h" #include "svg/svg-icc-color.h" +#include "ui/selected-color.h" namespace Inkscape { namespace UI { diff --git a/src/ui/selected-color.h b/src/ui/selected-color.h index b4268f553..168099c82 100644 --- a/src/ui/selected-color.h +++ b/src/ui/selected-color.h @@ -13,18 +13,14 @@ #ifndef SEEN_SELECTED_COLOR #define SEEN_SELECTED_COLOR -#ifdef HAVE_CONFIG_H -# include -#endif - -#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H -#include -#endif - #include -#include #include "color.h" +namespace Gtk +{ + class Widget; +} + namespace Inkscape { namespace UI { diff --git a/src/ui/widget/color-notebook.h b/src/ui/widget/color-notebook.h index 8b74f20f1..9e2aa8ec9 100644 --- a/src/ui/widget/color-notebook.h +++ b/src/ui/widget/color-notebook.h @@ -18,18 +18,14 @@ # include #endif -#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H -#include -#endif - #include -#include -#include -#if GTK_CHECK_VERSION(3,0,0) +#if WITH_GTKMM_3_0 #include #else #include #endif +#include +#include #include "color.h" #include "ui/selected-color.h" -- cgit v1.2.3 From 2fee41cb4965333df801ae5fd97ac5ea95df049a Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sun, 3 May 2015 10:19:47 +0200 Subject: Removed unnecessary inclusion of glibmm/threads.h (bzr r14059.1.14) --- src/ui/widget/color-entry.cpp | 12 ++---------- src/ui/widget/color-entry.h | 8 -------- src/ui/widget/color-icc-selector.cpp | 9 +++------ src/ui/widget/color-icc-selector.h | 6 +----- src/ui/widget/color-notebook.cpp | 5 ----- src/ui/widget/color-scales.cpp | 8 ++------ src/ui/widget/color-scales.h | 9 +-------- src/ui/widget/color-slider.cpp | 7 +++---- src/ui/widget/color-slider.h | 8 -------- src/ui/widget/color-wheel-selector.h | 8 +------- 10 files changed, 13 insertions(+), 67 deletions(-) (limited to 'src/ui') diff --git a/src/ui/widget/color-entry.cpp b/src/ui/widget/color-entry.cpp index e26cb4ade..89a63c6d0 100644 --- a/src/ui/widget/color-entry.cpp +++ b/src/ui/widget/color-entry.cpp @@ -7,17 +7,9 @@ * Copyright (C) 2014 Authors * Released under GNU GPL, read the file 'COPYING' for more information */ - -#ifdef HAVE_CONFIG_H -# include -#endif - -#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H -#include -#endif - -#include +#include #include +#include #include "color-entry.h" diff --git a/src/ui/widget/color-entry.h b/src/ui/widget/color-entry.h index 148b5dfe9..ecb0518b1 100644 --- a/src/ui/widget/color-entry.h +++ b/src/ui/widget/color-entry.h @@ -11,14 +11,6 @@ #ifndef SEEN_COLOR_ENTRY_H #define SEEN_COLOR_ENTRY_H_ -#ifdef HAVE_CONFIG_H -# include -#endif - -#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H -#include -#endif - #include #include "ui/selected-color.h" diff --git a/src/ui/widget/color-icc-selector.cpp b/src/ui/widget/color-icc-selector.cpp index db73c9111..e8d5be8a7 100644 --- a/src/ui/widget/color-icc-selector.cpp +++ b/src/ui/widget/color-icc-selector.cpp @@ -2,14 +2,11 @@ # include "config.h" #endif -#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H -#include -#endif - #include -#include -#include #include +#include + +#include #include #include #include diff --git a/src/ui/widget/color-icc-selector.h b/src/ui/widget/color-icc-selector.h index b917066dd..6066586f5 100644 --- a/src/ui/widget/color-icc-selector.h +++ b/src/ui/widget/color-icc-selector.h @@ -5,12 +5,8 @@ # include #endif -#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H -#include -#endif - #include -#if GTK_CHECK_VERSION(3,0,0) +#if WITH_GTKMM_3_0 #include #else #include diff --git a/src/ui/widget/color-notebook.cpp b/src/ui/widget/color-notebook.cpp index 0a4473a3b..ddffb0246 100644 --- a/src/ui/widget/color-notebook.cpp +++ b/src/ui/widget/color-notebook.cpp @@ -19,16 +19,11 @@ # include "config.h" #endif -#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H -#include -#endif - #include "widgets/icon.h" #include #include #include #include -#include #include #include #include diff --git a/src/ui/widget/color-scales.cpp b/src/ui/widget/color-scales.cpp index 1771644d1..e9931e938 100644 --- a/src/ui/widget/color-scales.cpp +++ b/src/ui/widget/color-scales.cpp @@ -6,14 +6,10 @@ # include "config.h" #endif -#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H -#include -#endif - #include -#include -#include #include +#include +#include #include "svg/svg-icc-color.h" #include "ui/dialog-events.h" diff --git a/src/ui/widget/color-scales.h b/src/ui/widget/color-scales.h index 0f0c4f90e..af7f726f1 100644 --- a/src/ui/widget/color-scales.h +++ b/src/ui/widget/color-scales.h @@ -5,14 +5,7 @@ # include #endif -#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H -#include -#endif - -#include -#include -#include -#if GTK_CHECK_VERSION(3,0,0) +#if WITH_GTKMM_3_0 #include #else #include diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index ad9662c6c..bf8b85dbd 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -15,20 +15,19 @@ # include "config.h" #endif -#include "color-slider.h" - -#include #include #include #include #include -#if GTK_CHECK_VERSION(3,0,0) +#if WITH_GTKMM_3_0 #include #else #include #endif +#include #include "ui/widget/color-scales.h" +#include "ui/widget/color-slider.h" #include "preferences.h" static const gint SLIDER_WIDTH = 96; diff --git a/src/ui/widget/color-slider.h b/src/ui/widget/color-slider.h index 48d067bb8..2f2e7b2db 100644 --- a/src/ui/widget/color-slider.h +++ b/src/ui/widget/color-slider.h @@ -12,14 +12,6 @@ #ifndef SEEN_COLOR_SLIDER_H #define SEEN_COLOR_SLIDER_H -#ifdef HAVE_CONFIG_H -# include -#endif - -#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H -#include -#endif - #include #include diff --git a/src/ui/widget/color-wheel-selector.h b/src/ui/widget/color-wheel-selector.h index f5213fad7..ec30cc7c5 100644 --- a/src/ui/widget/color-wheel-selector.h +++ b/src/ui/widget/color-wheel-selector.h @@ -16,13 +16,7 @@ # include #endif -#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H -#include -#endif - -#include -#include -#if GTK_CHECK_VERSION(3,0,0) +#if WITH_GTKMM_3_0 #include #else #include -- cgit v1.2.3 From f107d4347aefa08df9738e23cf078da73277711e Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sun, 3 May 2015 11:01:16 +0200 Subject: Introduced fixes after merge proposal review (bzr r14059.1.16) --- src/ui/widget/color-entry.cpp | 5 ++- src/ui/widget/color-icc-selector.cpp | 45 ++++++++---------------- src/ui/widget/color-scales.cpp | 67 ++++++++++++++++-------------------- src/ui/widget/color-scales.h | 2 +- 4 files changed, 46 insertions(+), 73 deletions(-) (limited to 'src/ui') diff --git a/src/ui/widget/color-entry.cpp b/src/ui/widget/color-entry.cpp index 89a63c6d0..a1fabf181 100644 --- a/src/ui/widget/color-entry.cpp +++ b/src/ui/widget/color-entry.cpp @@ -49,9 +49,8 @@ void ColorEntry::on_changed() { text.erase(0, 1); if (text.size() == 6) { // it was a standard RGB hex - unsigned int alph = SP_COLOR_F_TO_U(_color.alpha()); - Glib::ustring tmp = Glib::ustring::format(std::hex, std::setw(2), std::setfill(L'0'), alph); - text += tmp; + unsigned int alpha = SP_COLOR_F_TO_U(_color.alpha()); + text += Glib::ustring::format(std::hex, std::setw(2), std::setfill(L'0'), alpha); } } diff --git a/src/ui/widget/color-icc-selector.cpp b/src/ui/widget/color-icc-selector.cpp index e8d5be8a7..48c098604 100644 --- a/src/ui/widget/color-icc-selector.cpp +++ b/src/ui/widget/color-icc-selector.cpp @@ -236,23 +236,6 @@ std::vector colorspace::getColorSpaceInfo( Inkscape::Colo #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - - - - - - - - - - - - - - - - - namespace Inkscape { namespace UI { namespace Widget { @@ -263,23 +246,23 @@ namespace Widget { class ComponentUI { public: - ComponentUI() : - _component(), - _adj(0), - _slider(0), - _btn(0), - _label(0), - _map(0) + ComponentUI() + : _component() + , _adj(0) + , _slider(0) + , _btn(0) + , _label(0) + , _map(0) { } - ComponentUI(colorspace::Component const &component) : - _component(component), - _adj(0), - _slider(0), - _btn(0), - _label(0), - _map(0) + ComponentUI(colorspace::Component const &component) + : _component(component) + , _adj(0) + , _slider(0) + , _btn(0) + , _label(0) + , _map(0) { } diff --git a/src/ui/widget/color-scales.cpp b/src/ui/widget/color-scales.cpp index e9931e938..9f18b2d96 100644 --- a/src/ui/widget/color-scales.cpp +++ b/src/ui/widget/color-scales.cpp @@ -176,43 +176,36 @@ void ColorScales::_initUI(SPColorScalesMode mode) setMode(mode); } -void ColorScales::_recalcColor( gboolean changing ) +void ColorScales::_recalcColor() { - if ( changing ) + SPColor color; + gfloat alpha = 1.0; + gfloat c[5]; + + switch (_mode) { + case SP_COLOR_SCALES_MODE_RGB: + case SP_COLOR_SCALES_MODE_HSV: + _getRgbaFloatv(c); + color.set( c[0], c[1], c[2] ); + alpha = c[3]; + break; + case SP_COLOR_SCALES_MODE_CMYK: { - SPColor color; - gfloat alpha = 1.0; - gfloat c[5]; - - switch (_mode) { - case SP_COLOR_SCALES_MODE_RGB: - case SP_COLOR_SCALES_MODE_HSV: - _getRgbaFloatv(c); - color.set( c[0], c[1], c[2] ); - alpha = c[3]; - break; - case SP_COLOR_SCALES_MODE_CMYK: - { - _getCmykaFloatv( c ); - - float rgb[3]; - sp_color_cmyk_to_rgb_floatv( rgb, c[0], c[1], c[2], c[3] ); - color.set( rgb[0], rgb[1], rgb[2] ); - alpha = c[4]; - break; - } - default: - g_warning ("file %s: line %d: Illegal color selector mode %d", __FILE__, __LINE__, _mode); - break; - } - - _color.preserveICC(); - _color.setColorAlpha(color, alpha); + _getCmykaFloatv( c ); + + float rgb[3]; + sp_color_cmyk_to_rgb_floatv( rgb, c[0], c[1], c[2], c[3] ); + color.set( rgb[0], rgb[1], rgb[2] ); + alpha = c[4]; + break; } - else - { - // _updateInternals( _color, _alpha, _dragging ); + default: + g_warning ("file %s: line %d: Illegal color selector mode %d", __FILE__, __LINE__, _mode); + break; } + + _color.preserveICC(); + _color.setColorAlpha(color, alpha); } /* Helpers for setting color value */ @@ -479,7 +472,6 @@ void ColorScales::_sliderAnyGrabbed() if (!_dragging) { _dragging = TRUE; _color.setHeld(true); - _recalcColor( FALSE ); } } @@ -491,7 +483,6 @@ void ColorScales::_sliderAnyReleased() if (_dragging) { _dragging = FALSE; _color.setHeld(false); - _recalcColor( FALSE ); } } @@ -500,7 +491,7 @@ void ColorScales::_sliderAnyChanged() if (_updating) { return; } - _recalcColor( TRUE ); + _recalcColor(); } void ColorScales::_adjustmentChanged( ColorScales *scales, guint channel ) @@ -510,7 +501,7 @@ void ColorScales::_adjustmentChanged( ColorScales *scales, guint channel ) } scales->_updateSliders( (1 << channel) ); - scales->_recalcColor (TRUE); + scales->_recalcColor(); } void ColorScales::_updateSliders( guint channels ) @@ -627,7 +618,7 @@ void ColorScales::_updateSliders( guint channels ) // Force the internal color to be updated if ( !_updating ) { - _recalcColor( TRUE ); + _recalcColor(); } #ifdef SPCS_PREVIEW diff --git a/src/ui/widget/color-scales.h b/src/ui/widget/color-scales.h index af7f726f1..0744a645c 100644 --- a/src/ui/widget/color-scales.h +++ b/src/ui/widget/color-scales.h @@ -63,7 +63,7 @@ protected: void _getCmykaFloatv(gfloat *cmyka); guint32 _getRgba32(); void _updateSliders(guint channels); - void _recalcColor(gboolean changing); + void _recalcColor(); void _setRangeLimit( gdouble upper ); -- cgit v1.2.3 From 5afcb9ce46813689190a622590aee6ab618fb6f4 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sun, 3 May 2015 11:05:46 +0200 Subject: Removed commented out code from ColorNotebook (bzr r14059.1.17) --- src/ui/widget/color-notebook.cpp | 149 --------------------------------------- src/ui/widget/color-notebook.h | 15 ---- 2 files changed, 164 deletions(-) (limited to 'src/ui') diff --git a/src/ui/widget/color-notebook.cpp b/src/ui/widget/color-notebook.cpp index ddffb0246..92b1d7086 100644 --- a/src/ui/widget/color-notebook.cpp +++ b/src/ui/widget/color-notebook.cpp @@ -168,55 +168,6 @@ void ColorNotebook::_initUI() // restore the last active page Inkscape::Preferences *prefs = Inkscape::Preferences::get(); _setCurrentPage(prefs->getInt("/colorselector/page", 0)); - - - /* Commented out: see comment at the bottom of the header file - { - gboolean found = FALSE; - - _popup = gtk_menu_new(); - GtkMenu *menu = GTK_MENU (_popup); - - for (int i = 0; i < _trackerList->len; i++ ) - { - SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (g_ptr_array_index (_trackerList, i)); - if ( entry ) - { - GtkWidget *item = gtk_check_menu_item_new_with_label (_(entry->name)); - gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), entry->enabledFull); - gtk_widget_show (item); - gtk_menu_shell_append (GTK_MENU_SHELL(menu), item); - - g_signal_connect (G_OBJECT (item), "activate", - G_CALLBACK (sp_color_notebook_menuitem_response), - reinterpret_cast< gpointer > (entry) ); - found = TRUE; - } - } - - GtkWidget *arrow = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_NONE); - gtk_widget_show (arrow); - - _btn = gtk_button_new (); - gtk_widget_show (_btn); - gtk_container_add (GTK_CONTAINER (_btn), arrow); - - GtkWidget *align = gtk_alignment_new (1.0, 0.0, 0.0, 0.0); - gtk_widget_show (align); - gtk_container_add (GTK_CONTAINER (align), _btn); - - // uncomment to reenable the "show/hide modes" menu, - // but first fix it so it remembers its settings in prefs and does not take that much space (entire vertical column!) - gtk_table_attach (GTK_TABLE (table), align, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD); - - g_signal_connect_swapped(G_OBJECT(_btn), "event", G_CALLBACK (sp_color_notebook_menu_handler), G_OBJECT(_csel)); - if ( !found ) - { - gtk_widget_set_sensitive (_btn, FALSE); - } - } - */ - row++; #if GTK_CHECK_VERSION(3,0,0) @@ -420,106 +371,6 @@ void ColorNotebook::_addPage(Page& page) { } } -/* Commented out: see comment at the bottom of the header file - -GtkWidget* ColorNotebook::getPage(GType page_type, guint submode) -{ - gint count = 0; - gint i = 0; - GtkWidget* page = 0; - -// count = gtk_notebook_get_n_pages (_book); - count = 200; - for ( i = 0; i < count && !page; i++ ) - { - page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), i); - if ( page ) - { - SPColorSelector* csel; - guint pagemode; - csel = SP_COLOR_SELECTOR (page); - pagemode = csel->base->getSubmode(); - if ( G_TYPE_FROM_INSTANCE (page) == page_type - && pagemode == submode ) - { - // found it. - break; - } - else - { - page = 0; - } - } - else - { - break; - } - } - return page; -} - -void ColorNotebook::removePage( GType page_type, guint submode ) -{ - GtkWidget *page = 0; - - page = getPage(page_type, submode); - if ( page ) - { - gint where = gtk_notebook_page_num (GTK_NOTEBOOK (_book), page); - if ( where >= 0 ) - { - if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (_book)) == where ) - { -// getColorAlpha(_color, &_alpha); - } - gtk_notebook_remove_page (GTK_NOTEBOOK (_book), where); - } - } -} - - -static gint sp_color_notebook_menu_handler( GtkWidget *widget, GdkEvent *event ) -{ - if (event->type == GDK_BUTTON_PRESS) - { - SPColorSelector* csel = SP_COLOR_SELECTOR(widget); - (dynamic_cast(csel->base))->menuHandler( event ); - - // Tell calling code that we have handled this event; the buck - // stops here. - return TRUE; - } - - //Tell calling code that we have not handled this event; pass it on. - return FALSE; -} - -gint ColorNotebook::menuHandler( GdkEvent* event ) -{ - GdkEventButton *bevent = (GdkEventButton *) event; - gtk_menu_popup (GTK_MENU( _popup ), NULL, NULL, NULL, NULL, - bevent->button, bevent->time); - return TRUE; -} - -static void sp_color_notebook_menuitem_response (GtkMenuItem *menuitem, gpointer user_data) -{ - gboolean active = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem)); - SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (user_data); - if ( entry ) - { - if ( active ) - { - (dynamic_cast(SP_COLOR_SELECTOR(entry->backPointer)->base))->addPage(entry->type, entry->submode); - } - else - { - (dynamic_cast(SP_COLOR_SELECTOR(entry->backPointer)->base))->removePage(entry->type, entry->submode); - } - } -} -*/ - /* Local Variables: mode:c++ diff --git a/src/ui/widget/color-notebook.h b/src/ui/widget/color-notebook.h index 9e2aa8ec9..9909aa39c 100644 --- a/src/ui/widget/color-notebook.h +++ b/src/ui/widget/color-notebook.h @@ -82,21 +82,6 @@ private: // By default, disallow copy constructor and assignment operator ColorNotebook( const ColorNotebook& obj ); ColorNotebook& operator=( const ColorNotebook& obj ); - - /* Following methods support the pop-up menu to choose - * active color selectors (notebook tabs). This function - * is not used in Inkscape. If you want to re-enable it you have to - * * port the code to c++ - * * fix it so it remembers its settings in prefs - * * fix it so it does not take that much space (entire vertical column!) - * Current class design supports dynamic addtion and removal of color selectors - * - GtkWidget* addPage( GType page_type, guint submode ); - void removePage( GType page_type, guint submode ); - GtkWidget* getPage( GType page_type, guint submode ); - gint menuHandler( GdkEvent* event ); - - */ }; } -- cgit v1.2.3 From d41a1b907e503a5e6c587c35607a5fa2015eb0ae Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sun, 3 May 2015 11:42:05 +0200 Subject: Reformatted refactored files (bzr r14059.1.18) --- src/ui/widget/color-entry.cpp | 18 +- src/ui/widget/color-entry.h | 3 +- src/ui/widget/color-icc-selector.cpp | 784 +++++++++++++++-------------- src/ui/widget/color-icc-selector.h | 27 +- src/ui/widget/color-notebook.cpp | 200 ++++---- src/ui/widget/color-notebook.h | 16 +- src/ui/widget/color-scales.cpp | 888 ++++++++++++++++----------------- src/ui/widget/color-scales.h | 27 +- src/ui/widget/color-slider.cpp | 491 +++++++++--------- src/ui/widget/color-slider.h | 43 +- src/ui/widget/color-wheel-selector.cpp | 96 ++-- src/ui/widget/color-wheel-selector.h | 22 +- 12 files changed, 1291 insertions(+), 1324 deletions(-) (limited to 'src/ui') diff --git a/src/ui/widget/color-entry.cpp b/src/ui/widget/color-entry.cpp index a1fabf181..473d7de65 100644 --- a/src/ui/widget/color-entry.cpp +++ b/src/ui/widget/color-entry.cpp @@ -30,12 +30,14 @@ ColorEntry::ColorEntry(SelectedColor &color) set_tooltip_text(_("Hexadecimal RGBA value of the color")); } -ColorEntry::~ColorEntry() { +ColorEntry::~ColorEntry() +{ _color_changed_connection.disconnect(); _color_dragged_connection.disconnect(); } -void ColorEntry::on_changed() { +void ColorEntry::on_changed() +{ if (_updating) { return; } @@ -43,7 +45,7 @@ void ColorEntry::on_changed() { Glib::ustring text = get_text(); bool changed = false; - //Coerce the value format to eight hex digits + // Coerce the value format to eight hex digits if (!text.empty() && text[0] == '#') { changed = true; text.erase(0, 1); @@ -54,8 +56,8 @@ void ColorEntry::on_changed() { } } - gchar* str = g_strdup(text.c_str()); - gchar* end = 0; + gchar *str = g_strdup(text.c_str()); + gchar *end = 0; guint64 rgba = g_ascii_strtoull(str, &end, 16); if (end != str) { ptrdiff_t len = end - str; @@ -72,11 +74,12 @@ void ColorEntry::on_changed() { } -void ColorEntry::_onColorChanged() { +void ColorEntry::_onColorChanged() +{ SPColor color = _color.color(); gdouble alpha = _color.alpha(); - guint32 rgba = color.toRGBA32( alpha ); + guint32 rgba = color.toRGBA32(alpha); Glib::ustring text = Glib::ustring::format(std::hex, std::setw(8), std::setfill(L'0'), rgba); Glib::ustring old_text = get_text(); @@ -86,7 +89,6 @@ void ColorEntry::_onColorChanged() { _updating = false; } } - } } } diff --git a/src/ui/widget/color-entry.h b/src/ui/widget/color-entry.h index ecb0518b1..cd7d6164a 100644 --- a/src/ui/widget/color-entry.h +++ b/src/ui/widget/color-entry.h @@ -18,7 +18,8 @@ namespace Inkscape { namespace UI { namespace Widget { -class ColorEntry: public Gtk::Entry { +class ColorEntry : public Gtk::Entry +{ public: ColorEntry(SelectedColor &color); virtual ~ColorEntry(); diff --git a/src/ui/widget/color-icc-selector.cpp b/src/ui/widget/color-icc-selector.cpp index 48c098604..a7e75bfc5 100644 --- a/src/ui/widget/color-icc-selector.cpp +++ b/src/ui/widget/color-icc-selector.cpp @@ -1,5 +1,5 @@ #ifdef HAVE_CONFIG_H -# include "config.h" +#include "config.h" #endif #include @@ -36,40 +36,30 @@ #ifdef DEBUG_LCMS extern guint update_in_progress; -#define DEBUG_MESSAGE(key, ...) \ -{\ - Inkscape::Preferences *prefs = Inkscape::Preferences::get();\ - bool dump = prefs->getBool("/options/scislac/" #key);\ - bool dumpD = prefs->getBool("/options/scislac/" #key "D");\ - bool dumpD2 = prefs->getBool("/options/scislac/" #key "D2");\ - dumpD &&= ( (update_in_progress == 0) || dumpD2 );\ - if ( dump )\ - {\ - g_message( __VA_ARGS__ );\ -\ - }\ - if ( dumpD )\ - {\ - GtkWidget *dialog = gtk_message_dialog_new(NULL,\ - GTK_DIALOG_DESTROY_WITH_PARENT, \ - GTK_MESSAGE_INFO, \ - GTK_BUTTONS_OK, \ - __VA_ARGS__ \ - );\ - g_signal_connect_swapped(dialog, "response",\ - G_CALLBACK(gtk_widget_destroy), \ - dialog); \ - gtk_widget_show_all( dialog );\ - }\ -} +#define DEBUG_MESSAGE(key, ...) \ + { \ + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); \ + bool dump = prefs->getBool("/options/scislac/" #key); \ + bool dumpD = prefs->getBool("/options/scislac/" #key "D"); \ + bool dumpD2 = prefs->getBool("/options/scislac/" #key "D2"); \ + dumpD && = ((update_in_progress == 0) || dumpD2); \ + if (dump) { \ + g_message(__VA_ARGS__); \ + } \ + if (dumpD) { \ + GtkWidget *dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, \ + GTK_BUTTONS_OK, __VA_ARGS__); \ + g_signal_connect_swapped(dialog, "response", G_CALLBACK(gtk_widget_destroy), dialog); \ + gtk_widget_show_all(dialog); \ + } \ + } #endif // DEBUG_LCMS #define XPAD 4 #define YPAD 1 -namespace -{ +namespace { size_t maxColorspaceComponentCount = 0; @@ -94,41 +84,35 @@ GtkAttachOptions operator|(GtkAttachOptions lhs, GtkAttachOptions rhs) /** * Helper function to handle GTK2/GTK3 attachment #ifdef code. */ -void attachToGridOrTable(GtkWidget *parent, - GtkWidget *child, - guint left, - guint top, - guint width, - guint height, - bool hexpand = false, - bool centered = false, - guint xpadding = XPAD, - guint ypadding = YPAD) +void attachToGridOrTable(GtkWidget *parent, GtkWidget *child, guint left, guint top, guint width, guint height, + bool hexpand = false, bool centered = false, guint xpadding = XPAD, guint ypadding = YPAD) { -#if GTK_CHECK_VERSION(3,0,0) - #if GTK_CHECK_VERSION(3,12,0) - gtk_widget_set_margin_start( child, xpadding ); - gtk_widget_set_margin_end( child, xpadding ); - #else - gtk_widget_set_margin_left( child, xpadding ); - gtk_widget_set_margin_right( child, xpadding ); - #endif - - gtk_widget_set_margin_top( child, ypadding ); - gtk_widget_set_margin_bottom( child, ypadding ); +#if GTK_CHECK_VERSION(3, 0, 0) + #if GTK_CHECK_VERSION(3, 12, 0) + gtk_widget_set_margin_start(child, xpadding); + gtk_widget_set_margin_end(child, xpadding); + #else + gtk_widget_set_margin_left(child, xpadding); + gtk_widget_set_margin_right(child, xpadding); + #endif + + gtk_widget_set_margin_top(child, ypadding); + gtk_widget_set_margin_bottom(child, ypadding); if (hexpand) { gtk_widget_set_hexpand(child, TRUE); } if (centered) { - gtk_widget_set_halign( child, GTK_ALIGN_CENTER ); - gtk_widget_set_valign( child, GTK_ALIGN_CENTER ); + gtk_widget_set_halign(child, GTK_ALIGN_CENTER); + gtk_widget_set_valign(child, GTK_ALIGN_CENTER); } - gtk_grid_attach( GTK_GRID(parent), child, left, top, width, height ); + gtk_grid_attach(GTK_GRID(parent), child, left, top, width, height); #else - GtkAttachOptions xoptions = centered ? static_cast(0) : hexpand ? (GTK_EXPAND | GTK_FILL) : GTK_FILL; + GtkAttachOptions xoptions = + centered ? static_cast(0) : hexpand ? (GTK_EXPAND | GTK_FILL) : GTK_FILL; GtkAttachOptions yoptions = centered ? static_cast(0) : GTK_FILL; - gtk_table_attach( GTK_TABLE(parent), child, left, left + width, top, top + height, xoptions, yoptions, xpadding, ypadding ); + gtk_table_attach(GTK_TABLE(parent), child, left, left + width, top, top + height, xoptions, yoptions, xpadding, + ypadding); #endif } @@ -145,32 +129,32 @@ icSigCmyData #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) -static cmsUInt16Number* getScratch() { +static cmsUInt16Number *getScratch() +{ // bytes per pixel * input channels * width - static cmsUInt16Number* scritch = static_cast(g_new(cmsUInt16Number, 4 * 1024)); + static cmsUInt16Number *scritch = static_cast(g_new(cmsUInt16Number, 4 * 1024)); return scritch; } -colorspace::Component::Component() : - name(), - tip(), - scale(1) +colorspace::Component::Component() + : name() + , tip() + , scale(1) { } -colorspace::Component::Component(std::string const &name, std::string const &tip, guint scale) : - name(name), - tip(tip), - scale(scale) +colorspace::Component::Component(std::string const &name, std::string const &tip, guint scale) + : name(name) + , tip(tip) + , scale(scale) { } -std::vector colorspace::getColorSpaceInfo( uint32_t space ) +std::vector colorspace::getColorSpaceInfo(uint32_t space) { static std::map > sets; - if (sets.empty()) - { + if (sets.empty()) { sets[cmsSigXYZData].push_back(Component("_X", "X", 2)); // TYPE_XYZ_16 sets[cmsSigXYZData].push_back(Component("_Y", "Y", 1)); sets[cmsSigXYZData].push_back(Component("_Z", "Z", 2)); @@ -179,7 +163,7 @@ std::vector colorspace::getColorSpaceInfo( uint32_t space sets[cmsSigLabData].push_back(Component("_a", "a", 256)); sets[cmsSigLabData].push_back(Component("_b", "b", 256)); - //cmsSigLuvData + // cmsSigLuvData sets[cmsSigYCbCrData].push_back(Component("_Y", "Y", 1)); // TYPE_YCbCr_16 sets[cmsSigYCbCrData].push_back(Component("C_b", "Cb", 1)); @@ -212,8 +196,7 @@ std::vector colorspace::getColorSpaceInfo( uint32_t space sets[cmsSigCmyData].push_back(Component(_("_M:"), _("Magenta"), 1)); sets[cmsSigCmyData].push_back(Component(_("_Y:"), _("Yellow"), 1)); - for (std::map >::iterator it = sets.begin(); it != sets.end(); ++it) - { + for (std::map >::iterator it = sets.begin(); it != sets.end(); ++it) { knownColorspaces.insert(it->first); maxColorspaceComponentCount = std::max(maxColorspaceComponentCount, it->second.size()); } @@ -221,17 +204,16 @@ std::vector colorspace::getColorSpaceInfo( uint32_t space std::vector target; - if (sets.find(space) != sets.end()) - { + if (sets.find(space) != sets.end()) { target = sets[space]; } return target; } -std::vector colorspace::getColorSpaceInfo( Inkscape::ColorProfile *prof ) +std::vector colorspace::getColorSpaceInfo(Inkscape::ColorProfile *prof) { - return getColorSpaceInfo( asICColorSpaceSig(prof->getColorSpace()) ); + return getColorSpaceInfo(asICColorSpaceSig(prof->getColorSpace())); } #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) @@ -243,9 +225,8 @@ namespace Widget { /** * Class containing the parts for a single color component's UI presence. */ -class ComponentUI -{ -public: +class ComponentUI { + public: ComponentUI() : _component() , _adj(0) @@ -269,37 +250,35 @@ public: colorspace::Component _component; GtkAdjustment *_adj; // Component adjustment Inkscape::UI::Widget::ColorSlider *_slider; - GtkWidget *_btn; // spinbutton - GtkWidget *_label; // Label - guchar *_map; + GtkWidget *_btn; // spinbutton + GtkWidget *_label; // Label + guchar *_map; }; /** * Class that implements the internals of the selector. */ -class ColorICCSelectorImpl -{ -public: - +class ColorICCSelectorImpl { + public: ColorICCSelectorImpl(ColorICCSelector *owner, SelectedColor &color); ~ColorICCSelectorImpl(); - static void _adjustmentChanged ( GtkAdjustment *adjustment, ColorICCSelectorImpl *cs ); + static void _adjustmentChanged(GtkAdjustment *adjustment, ColorICCSelectorImpl *cs); void _sliderGrabbed(); void _sliderReleased(); void _sliderChanged(); - static void _profileSelected( GtkWidget* src, gpointer data ); - static void _fixupHit( GtkWidget* src, gpointer data ); + static void _profileSelected(GtkWidget *src, gpointer data); + static void _fixupHit(GtkWidget *src, gpointer data); #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - void _setProfile( SVGICCColor* profile ); - void _switchToProfile( gchar const* name ); + void _setProfile(SVGICCColor *profile); + void _switchToProfile(gchar const *name); #endif - void _updateSliders( gint ignore ); - void _profilesChanged( std::string const & name ); + void _updateSliders(gint ignore); + void _profilesChanged(std::string const &name); ColorICCSelector *_owner; SelectedColor &_color; @@ -308,19 +287,19 @@ public: gboolean _dragging : 1; guint32 _fixupNeeded; - GtkWidget* _fixupBtn; - GtkWidget* _profileSel; + GtkWidget *_fixupBtn; + GtkWidget *_profileSel; std::vector _compUI; - GtkAdjustment* _adj; // Channel adjustment - Inkscape::UI::Widget::ColorSlider* _slider; - GtkWidget* _sbtn; // Spinbutton - GtkWidget* _label; // Label + GtkAdjustment *_adj; // Channel adjustment + Inkscape::UI::Widget::ColorSlider *_slider; + GtkWidget *_sbtn; // Spinbutton + GtkWidget *_label; // Label #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) std::string _profileName; - Inkscape::ColorProfile* _prof; + Inkscape::ColorProfile *_prof; guint _profChannelCount; gulong _profChangedID; #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) @@ -328,8 +307,7 @@ public: - -const gchar* ColorICCSelector::MODE_NAME = N_("CMS"); +const gchar *ColorICCSelector::MODE_NAME = N_("CMS"); ColorICCSelector::ColorICCSelector(SelectedColor &color) : _impl(NULL) @@ -337,13 +315,12 @@ ColorICCSelector::ColorICCSelector(SelectedColor &color) _impl = new ColorICCSelectorImpl(this, color); init(); color.signal_changed.connect(sigc::mem_fun(this, &ColorICCSelector::_colorChanged)); - //color.signal_dragged.connect(sigc::mem_fun(this, &ColorICCSelector::_colorChanged)); + // color.signal_dragged.connect(sigc::mem_fun(this, &ColorICCSelector::_colorChanged)); } ColorICCSelector::~ColorICCSelector() { - if (_impl) - { + if (_impl) { delete _impl; _impl = 0; } @@ -351,25 +328,24 @@ ColorICCSelector::~ColorICCSelector() -ColorICCSelectorImpl::ColorICCSelectorImpl(ColorICCSelector *owner, SelectedColor &color) : - _owner(owner), - _color(color), - _updating( FALSE ), - _dragging( FALSE ), - _fixupNeeded(0), - _fixupBtn(0), - _profileSel(0), - _compUI(), - _adj(0), - _slider(0), - _sbtn(0), - _label(0) +ColorICCSelectorImpl::ColorICCSelectorImpl(ColorICCSelector *owner, SelectedColor &color) + : _owner(owner) + , _color(color) + , _updating(FALSE) + , _dragging(FALSE) + , _fixupNeeded(0) + , _fixupBtn(0) + , _profileSel(0) + , _compUI() + , _adj(0) + , _slider(0) + , _sbtn(0) + , _label(0) #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - , - _profileName(), - _prof(0), - _profChannelCount(0), - _profChangedID(0) + , _profileName() + , _prof(0) + , _profChannelCount(0) + , _profChangedID(0) #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) { } @@ -388,9 +364,9 @@ void ColorICCSelector::init() _impl->_updating = FALSE; _impl->_dragging = FALSE; - GtkWidget* t = GTK_WIDGET(gobj()); + GtkWidget *t = GTK_WIDGET(gobj()); - gtk_widget_show (t); + gtk_widget_show(t); _impl->_compUI.clear(); @@ -399,50 +375,53 @@ void ColorICCSelector::init() _impl->_fixupBtn = gtk_button_new_with_label(_("Fix")); - g_signal_connect( G_OBJECT(_impl->_fixupBtn), "clicked", G_CALLBACK(ColorICCSelectorImpl::_fixupHit), (gpointer)_impl ); - gtk_widget_set_sensitive( _impl->_fixupBtn, FALSE ); - gtk_widget_set_tooltip_text( _impl->_fixupBtn, _("Fix RGB fallback to match icc-color() value.") ); - //gtk_misc_set_alignment( GTK_MISC (_impl->_fixupBtn), 1.0, 0.5 ); - gtk_widget_show( _impl->_fixupBtn ); + g_signal_connect(G_OBJECT(_impl->_fixupBtn), "clicked", G_CALLBACK(ColorICCSelectorImpl::_fixupHit), + (gpointer)_impl); + gtk_widget_set_sensitive(_impl->_fixupBtn, FALSE); + gtk_widget_set_tooltip_text(_impl->_fixupBtn, _("Fix RGB fallback to match icc-color() value.")); + // gtk_misc_set_alignment( GTK_MISC (_impl->_fixupBtn), 1.0, 0.5 ); + gtk_widget_show(_impl->_fixupBtn); attachToGridOrTable(t, _impl->_fixupBtn, 0, row, 1, 1); // Combobox and store with 2 columns : label (0) and full name (1) - GtkListStore *store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING); - _impl->_profileSel = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store)); + GtkListStore *store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING); + _impl->_profileSel = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store)); - GtkCellRenderer *renderer = gtk_cell_renderer_text_new (); + GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(_impl->_profileSel), renderer, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(_impl->_profileSel), renderer, "text", 0, NULL); GtkTreeIter iter; - gtk_list_store_append (store, &iter); - gtk_list_store_set (store, &iter, 0, _(""), 1, _(""), -1); + gtk_list_store_append(store, &iter); + gtk_list_store_set(store, &iter, 0, _(""), 1, _(""), -1); - gtk_widget_show( _impl->_profileSel ); - gtk_combo_box_set_active( GTK_COMBO_BOX(_impl->_profileSel), 0 ); + gtk_widget_show(_impl->_profileSel); + gtk_combo_box_set_active(GTK_COMBO_BOX(_impl->_profileSel), 0); attachToGridOrTable(t, _impl->_profileSel, 1, row, 1, 1); #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - _impl->_profChangedID = g_signal_connect( G_OBJECT(_impl->_profileSel), "changed", G_CALLBACK(ColorICCSelectorImpl::_profileSelected), (gpointer)_impl ); + _impl->_profChangedID = g_signal_connect(G_OBJECT(_impl->_profileSel), "changed", + G_CALLBACK(ColorICCSelectorImpl::_profileSelected), (gpointer)_impl); #else - gtk_widget_set_sensitive( _impl->_profileSel, false ); + gtk_widget_set_sensitive(_impl->_profileSel, false); #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) row++; - // populate the data for colorspaces and channels: +// populate the data for colorspaces and channels: #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - std::vector things = colorspace::getColorSpaceInfo( cmsSigRgbData ); + std::vector things = colorspace::getColorSpaceInfo(cmsSigRgbData); #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - for ( size_t i = 0; i < maxColorspaceComponentCount; i++ ) { + for (size_t i = 0; i < maxColorspaceComponentCount; i++) { #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) if (i < things.size()) { _impl->_compUI.push_back(ComponentUI(things[i])); - } else { + } + else { _impl->_compUI.push_back(ComponentUI()); } @@ -453,9 +432,9 @@ void ColorICCSelector::init() std::string labelStr = "."; #endif - _impl->_compUI[i]._label = gtk_label_new_with_mnemonic( labelStr.c_str() ); - gtk_misc_set_alignment( GTK_MISC (_impl->_compUI[i]._label), 1.0, 0.5 ); - gtk_widget_show( _impl->_compUI[i]._label ); + _impl->_compUI[i]._label = gtk_label_new_with_mnemonic(labelStr.c_str()); + gtk_misc_set_alignment(GTK_MISC(_impl->_compUI[i]._label), 1.0, 0.5); + gtk_widget_show(_impl->_compUI[i]._label); attachToGridOrTable(t, _impl->_compUI[i]._label, 0, row, 1, 1); @@ -464,10 +443,11 @@ void ColorICCSelector::init() gdouble step = static_cast(scaleValue) / 100.0; gdouble page = static_cast(scaleValue) / 10.0; gint digits = (step > 0.9) ? 0 : 2; - _impl->_compUI[i]._adj = GTK_ADJUSTMENT( gtk_adjustment_new( 0.0, 0.0, scaleValue, step, page, page ) ); + _impl->_compUI[i]._adj = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, scaleValue, step, page, page)); // Slider - _impl->_compUI[i]._slider = Gtk::manage(new Inkscape::UI::Widget::ColorSlider(Glib::wrap(_impl->_compUI[i]._adj, true))); + _impl->_compUI[i]._slider = + Gtk::manage(new Inkscape::UI::Widget::ColorSlider(Glib::wrap(_impl->_compUI[i]._adj, true))); #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) _impl->_compUI[i]._slider->set_tooltip_text((i < things.size()) ? things[i].tip.c_str() : ""); #else @@ -477,28 +457,31 @@ void ColorICCSelector::init() attachToGridOrTable(t, _impl->_compUI[i]._slider->gobj(), 1, row, 1, 1, true); - _impl->_compUI[i]._btn = gtk_spin_button_new( _impl->_compUI[i]._adj, step, digits ); + _impl->_compUI[i]._btn = gtk_spin_button_new(_impl->_compUI[i]._adj, step, digits); #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - gtk_widget_set_tooltip_text( _impl->_compUI[i]._btn, (i < things.size()) ? things[i].tip.c_str() : "" ); + gtk_widget_set_tooltip_text(_impl->_compUI[i]._btn, (i < things.size()) ? things[i].tip.c_str() : ""); #else - gtk_widget_set_tooltip_text( _impl->_compUI[i]._btn, "." ); + gtk_widget_set_tooltip_text(_impl->_compUI[i]._btn, "."); #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - sp_dialog_defocus_on_enter( _impl->_compUI[i]._btn ); - gtk_label_set_mnemonic_widget( GTK_LABEL(_impl->_compUI[i]._label), _impl->_compUI[i]._btn ); - gtk_widget_show( _impl->_compUI[i]._btn ); + sp_dialog_defocus_on_enter(_impl->_compUI[i]._btn); + gtk_label_set_mnemonic_widget(GTK_LABEL(_impl->_compUI[i]._label), _impl->_compUI[i]._btn); + gtk_widget_show(_impl->_compUI[i]._btn); attachToGridOrTable(t, _impl->_compUI[i]._btn, 2, row, 1, 1, false, true); - _impl->_compUI[i]._map = g_new( guchar, 4 * 1024 ); - memset( _impl->_compUI[i]._map, 0x0ff, 1024 * 4 ); + _impl->_compUI[i]._map = g_new(guchar, 4 * 1024); + memset(_impl->_compUI[i]._map, 0x0ff, 1024 * 4); // Signals - g_signal_connect( G_OBJECT( _impl->_compUI[i]._adj ), "value_changed", G_CALLBACK( ColorICCSelectorImpl::_adjustmentChanged ), _impl ); + g_signal_connect(G_OBJECT(_impl->_compUI[i]._adj), "value_changed", + G_CALLBACK(ColorICCSelectorImpl::_adjustmentChanged), _impl); _impl->_compUI[i]._slider->signal_grabbed.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderGrabbed)); - _impl->_compUI[i]._slider->signal_released.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderReleased)); - _impl->_compUI[i]._slider->signal_value_changed.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderChanged)); + _impl->_compUI[i]._slider->signal_released.connect( + sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderReleased)); + _impl->_compUI[i]._slider->signal_value_changed.connect( + sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderChanged)); row++; } @@ -520,9 +503,8 @@ void ColorICCSelector::init() attachToGridOrTable(t, _impl->_slider->gobj(), 1, row, 1, 1, true); - _impl->_slider->setColors(SP_RGBA32_F_COMPOSE( 1.0, 1.0, 1.0, 0.0 ), - SP_RGBA32_F_COMPOSE( 1.0, 1.0, 1.0, 0.5 ), - SP_RGBA32_F_COMPOSE( 1.0, 1.0, 1.0, 1.0 ) ); + _impl->_slider->setColors(SP_RGBA32_F_COMPOSE(1.0, 1.0, 1.0, 0.0), SP_RGBA32_F_COMPOSE(1.0, 1.0, 1.0, 0.5), + SP_RGBA32_F_COMPOSE(1.0, 1.0, 1.0, 1.0)); // Spinbutton @@ -535,66 +517,69 @@ void ColorICCSelector::init() attachToGridOrTable(t, _impl->_sbtn, 2, row, 1, 1, false, true); // Signals - g_signal_connect(G_OBJECT(_impl->_adj), "value_changed", G_CALLBACK(ColorICCSelectorImpl::_adjustmentChanged), _impl); + g_signal_connect(G_OBJECT(_impl->_adj), "value_changed", G_CALLBACK(ColorICCSelectorImpl::_adjustmentChanged), + _impl); _impl->_slider->signal_grabbed.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderGrabbed)); _impl->_slider->signal_released.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderReleased)); _impl->_slider->signal_value_changed.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderChanged)); } -void ColorICCSelectorImpl::_fixupHit( GtkWidget* /*src*/, gpointer data ) +void ColorICCSelectorImpl::_fixupHit(GtkWidget * /*src*/, gpointer data) { - ColorICCSelectorImpl* self = reinterpret_cast(data); - gtk_widget_set_sensitive( self->_fixupBtn, FALSE ); - self->_adjustmentChanged( self->_compUI[0]._adj, self ); + ColorICCSelectorImpl *self = reinterpret_cast(data); + gtk_widget_set_sensitive(self->_fixupBtn, FALSE); + self->_adjustmentChanged(self->_compUI[0]._adj, self); } #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) -void ColorICCSelectorImpl::_profileSelected( GtkWidget* /*src*/, gpointer data ) +void ColorICCSelectorImpl::_profileSelected(GtkWidget * /*src*/, gpointer data) { - ColorICCSelectorImpl* self = reinterpret_cast(data); + ColorICCSelectorImpl *self = reinterpret_cast(data); - GtkTreeIter iter; + GtkTreeIter iter; if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(self->_profileSel), &iter)) { GtkTreeModel *store = gtk_combo_box_get_model(GTK_COMBO_BOX(self->_profileSel)); - gchar* name = 0; + gchar *name = 0; gtk_tree_model_get(store, &iter, 1, &name, -1); - self->_switchToProfile( name ); - gtk_widget_set_tooltip_text(self->_profileSel, name ); + self->_switchToProfile(name); + gtk_widget_set_tooltip_text(self->_profileSel, name); - if ( name ) { - g_free( name ); + if (name) { + g_free(name); } } } #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) -void ColorICCSelectorImpl::_switchToProfile( gchar const* name ) +void ColorICCSelectorImpl::_switchToProfile(gchar const *name) { bool dirty = false; - SPColor tmp( _color.color() ); + SPColor tmp(_color.color()); - if ( name ) { - if ( tmp.icc && tmp.icc->colorProfile == name ) { + if (name) { + if (tmp.icc && tmp.icc->colorProfile == name) { #ifdef DEBUG_LCMS - g_message("Already at name [%s]", name ); + g_message("Already at name [%s]", name); #endif // DEBUG_LCMS - } else { + } + else { #ifdef DEBUG_LCMS - g_message("Need to switch to profile [%s]", name ); + g_message("Need to switch to profile [%s]", name); #endif // DEBUG_LCMS - if ( tmp.icc ) { + if (tmp.icc) { tmp.icc->colors.clear(); - } else { + } + else { tmp.icc = new SVGICCColor(); } tmp.icc->colorProfile = name; - Inkscape::ColorProfile* newProf = SP_ACTIVE_DOCUMENT->profileManager->find(name); - if ( newProf ) { + Inkscape::ColorProfile *newProf = SP_ACTIVE_DOCUMENT->profileManager->find(name); + if (newProf) { cmsHTRANSFORM trans = newProf->getTransfFromSRGB8(); - if ( trans ) { + if (trans) { guint32 val = _color.color().toRGBA32(0); guchar pre[4] = { static_cast(SP_RGBA32_R_U(val)), @@ -604,29 +589,31 @@ void ColorICCSelectorImpl::_switchToProfile( gchar const* name ) #ifdef DEBUG_LCMS g_message("Shoving in [%02x] [%02x] [%02x]", pre[0], pre[1], pre[2]); #endif // DEBUG_LCMS - cmsUInt16Number post[4] = {0,0,0,0}; - cmsDoTransform( trans, pre, post, 1 ); + cmsUInt16Number post[4] = { 0, 0, 0, 0 }; + cmsDoTransform(trans, pre, post, 1); #ifdef DEBUG_LCMS g_message("got on out [%04x] [%04x] [%04x] [%04x]", post[0], post[1], post[2], post[3]); #endif // DEBUG_LCMS #if HAVE_LIBLCMS1 - guint count = _cmsChannelsOf( asICColorSpaceSig(newProf->getColorSpace()) ); + guint count = _cmsChannelsOf(asICColorSpaceSig(newProf->getColorSpace())); #elif HAVE_LIBLCMS2 - guint count = cmsChannelsOf( asICColorSpaceSig(newProf->getColorSpace()) ); + guint count = cmsChannelsOf(asICColorSpaceSig(newProf->getColorSpace())); #endif - std::vector things = colorspace::getColorSpaceInfo(asICColorSpaceSig(newProf->getColorSpace())); + std::vector things = + colorspace::getColorSpaceInfo(asICColorSpaceSig(newProf->getColorSpace())); - for ( guint i = 0; i < count; i++ ) { - gdouble val = (((gdouble)post[i])/65535.0) * (gdouble)((i < things.size()) ? things[i].scale : 1); + for (guint i = 0; i < count; i++) { + gdouble val = + (((gdouble)post[i]) / 65535.0) * (gdouble)((i < things.size()) ? things[i].scale : 1); #ifdef DEBUG_LCMS g_message(" scaled %d by %d to be %f", i, ((i < things.size()) ? things[i].scale : 1), val); #endif // DEBUG_LCMS tmp.icc->colors.push_back(val); } cmsHTRANSFORM retrans = newProf->getTransfToSRGB8(); - if ( retrans ) { - cmsDoTransform( retrans, post, pre, 1 ); + if (retrans) { + cmsDoTransform(retrans, post, pre, 1); #ifdef DEBUG_LCMS g_message(" back out [%02x] [%02x] [%02x]", pre[0], pre[1], pre[2]); #endif // DEBUG_LCMS @@ -636,28 +623,30 @@ void ColorICCSelectorImpl::_switchToProfile( gchar const* name ) } dirty = true; } - } else { + } + else { #ifdef DEBUG_LCMS - g_message("NUKE THE ICC"); + g_message("NUKE THE ICC"); #endif // DEBUG_LCMS - if ( tmp.icc ) { + if (tmp.icc) { delete tmp.icc; tmp.icc = 0; dirty = true; - _fixupHit( 0, this ); - } else { + _fixupHit(0, this); + } + else { #ifdef DEBUG_LCMS - g_message("No icc to nuke"); + g_message("No icc to nuke"); #endif // DEBUG_LCMS } } - if ( dirty ) { + if (dirty) { #ifdef DEBUG_LCMS g_message("+----------------"); g_message("+ new color is [%s]", tmp.toString().c_str()); #endif // DEBUG_LCMS - _setProfile( tmp.icc ); + _setProfile(tmp.icc); //_adjustmentChanged( _compUI[0]._adj, SP_COLOR_ICC_SELECTOR(_csel) ); _color.setColor(tmp); #ifdef DEBUG_LCMS @@ -668,45 +657,43 @@ void ColorICCSelectorImpl::_switchToProfile( gchar const* name ) #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) -void ColorICCSelectorImpl::_profilesChanged( std::string const & name ) +void ColorICCSelectorImpl::_profilesChanged(std::string const &name) { - GtkComboBox* combo = GTK_COMBO_BOX(_profileSel); + GtkComboBox *combo = GTK_COMBO_BOX(_profileSel); - g_signal_handler_block( G_OBJECT(_profileSel), _profChangedID ); + g_signal_handler_block(G_OBJECT(_profileSel), _profChangedID); GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model(combo)); gtk_list_store_clear(store); GtkTreeIter iter; - gtk_list_store_append (store, &iter); + gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, _(""), 1, _(""), -1); - gtk_combo_box_set_active( combo, 0 ); + gtk_combo_box_set_active(combo, 0); int index = 1; - const GSList *current = SP_ACTIVE_DOCUMENT->getResourceList( "iccprofile" ); - while ( current ) { - SPObject* obj = SP_OBJECT(current->data); - Inkscape::ColorProfile* prof = reinterpret_cast(obj); + const GSList *current = SP_ACTIVE_DOCUMENT->getResourceList("iccprofile"); + while (current) { + SPObject *obj = SP_OBJECT(current->data); + Inkscape::ColorProfile *prof = reinterpret_cast(obj); - gtk_list_store_append (store, &iter); + gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, gr_ellipsize_text(prof->name, 25).c_str(), 1, prof->name, -1); - if ( name == prof->name ) { - gtk_combo_box_set_active( combo, index ); - gtk_widget_set_tooltip_text(_profileSel, prof->name ); + if (name == prof->name) { + gtk_combo_box_set_active(combo, index); + gtk_widget_set_tooltip_text(_profileSel, prof->name); } index++; current = g_slist_next(current); } - g_signal_handler_unblock( G_OBJECT(_profileSel), _profChangedID ); + g_signal_handler_unblock(G_OBJECT(_profileSel), _profChangedID); } #else -void ColorICCSelectorImpl::_profilesChanged( std::string const & /*name*/ ) -{ -} +void ColorICCSelectorImpl::_profilesChanged(std::string const & /*name*/) {} #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) // Helpers for setting color value @@ -714,190 +701,199 @@ void ColorICCSelectorImpl::_profilesChanged( std::string const & /*name*/ ) void ColorICCSelector::_colorChanged() { _impl->_updating = TRUE; - //sp_color_icc_set_color( SP_COLOR_ICC( _icc ), &color ); +// sp_color_icc_set_color( SP_COLOR_ICC( _icc ), &color ); #ifdef DEBUG_LCMS - g_message( "/^^^^^^^^^ %p::_colorChanged(%08x:%s)", this, - _impl->_color.color().toRGBA32(_impl->_color.alpha()), ( (_impl->_color.color().icc) ? _impl->_color.color().icc->colorProfile.c_str(): "" ) - ); + g_message("/^^^^^^^^^ %p::_colorChanged(%08x:%s)", this, _impl->_color.color().toRGBA32(_impl->_color.alpha()), + ((_impl->_color.color().icc) ? _impl->_color.color().icc->colorProfile.c_str() : "")); #endif // DEBUG_LCMS #ifdef DEBUG_LCMS - g_message("FLIPPIES!!!! %p '%s'", _impl->_color.color().icc, (_impl->_color.color().icc ? _impl->_color.color().icc->colorProfile.c_str():"")); + g_message("FLIPPIES!!!! %p '%s'", _impl->_color.color().icc, + (_impl->_color.color().icc ? _impl->_color.color().icc->colorProfile.c_str() : "")); #endif // DEBUG_LCMS - _impl->_profilesChanged( (_impl->_color.color().icc) ? _impl->_color.color().icc->colorProfile : std::string("") ); - ColorScales::setScaled( _impl->_adj, _impl->_color.alpha() ); + _impl->_profilesChanged((_impl->_color.color().icc) ? _impl->_color.color().icc->colorProfile : std::string("")); + ColorScales::setScaled(_impl->_adj, _impl->_color.alpha()); #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - _impl->_setProfile( _impl->_color.color().icc ); + _impl->_setProfile(_impl->_color.color().icc); _impl->_fixupNeeded = 0; - gtk_widget_set_sensitive( _impl->_fixupBtn, FALSE ); + gtk_widget_set_sensitive(_impl->_fixupBtn, FALSE); if (_impl->_prof) { - if (_impl->_prof->getTransfToSRGB8() ) { + if (_impl->_prof->getTransfToSRGB8()) { cmsUInt16Number tmp[4]; - for ( guint i = 0; i < _impl->_profChannelCount; i++ ) { + for (guint i = 0; i < _impl->_profChannelCount; i++) { gdouble val = 0.0; - if ( _impl->_color.color().icc->colors.size() > i ) { - if ( _impl->_compUI[i]._component.scale == 256 ) { - val = (_impl->_color.color().icc->colors[i] + 128.0) / static_cast(_impl->_compUI[i]._component.scale); - } else { - val = _impl->_color.color().icc->colors[i] / static_cast(_impl->_compUI[i]._component.scale); + if (_impl->_color.color().icc->colors.size() > i) { + if (_impl->_compUI[i]._component.scale == 256) { + val = (_impl->_color.color().icc->colors[i] + 128.0) / + static_cast(_impl->_compUI[i]._component.scale); + } + else { + val = _impl->_color.color().icc->colors[i] / + static_cast(_impl->_compUI[i]._component.scale); } } tmp[i] = val * 0x0ffff; } - guchar post[4] = {0,0,0,0}; + guchar post[4] = { 0, 0, 0, 0 }; cmsHTRANSFORM trans = _impl->_prof->getTransfToSRGB8(); - if ( trans ) { - cmsDoTransform( trans, tmp, post, 1 ); - guint32 other = SP_RGBA32_U_COMPOSE(post[0], post[1], post[2], 255 ); - if ( other != _impl->_color.color().toRGBA32(255) ) { + if (trans) { + cmsDoTransform(trans, tmp, post, 1); + guint32 other = SP_RGBA32_U_COMPOSE(post[0], post[1], post[2], 255); + if (other != _impl->_color.color().toRGBA32(255)) { _impl->_fixupNeeded = other; - gtk_widget_set_sensitive( _impl->_fixupBtn, TRUE ); + gtk_widget_set_sensitive(_impl->_fixupBtn, TRUE); #ifdef DEBUG_LCMS - g_message("Color needs to change 0x%06x to 0x%06x", _color.toRGBA32(255) >> 8, other >> 8 ); + g_message("Color needs to change 0x%06x to 0x%06x", _color.toRGBA32(255) >> 8, other >> 8); #endif // DEBUG_LCMS } } } } #else - //(void)color; +//(void)color; #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - _impl->_updateSliders( -1 ); + _impl->_updateSliders(-1); _impl->_updating = FALSE; #ifdef DEBUG_LCMS - g_message( "\\_________ %p::_colorChanged()", this ); + g_message("\\_________ %p::_colorChanged()", this); #endif // DEBUG_LCMS } #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) -void ColorICCSelectorImpl::_setProfile( SVGICCColor* profile ) +void ColorICCSelectorImpl::_setProfile(SVGICCColor *profile) { #ifdef DEBUG_LCMS - g_message( "/^^^^^^^^^ %p::_setProfile(%s)", this, - ( (profile) ? profile->colorProfile.c_str() : "") - ); + g_message("/^^^^^^^^^ %p::_setProfile(%s)", this, ((profile) ? profile->colorProfile.c_str() : "")); #endif // DEBUG_LCMS bool profChanged = false; - if ( _prof && (!profile || (_profileName != profile->colorProfile) ) ) { + if (_prof && (!profile || (_profileName != profile->colorProfile))) { // Need to clear out the prior one profChanged = true; _profileName.clear(); _prof = 0; _profChannelCount = 0; - } else if ( profile && !_prof ) { + } + else if (profile && !_prof) { profChanged = true; } - for ( size_t i = 0; i < _compUI.size(); i++ ) { - gtk_widget_hide( _compUI[i]._label ); + for (size_t i = 0; i < _compUI.size(); i++) { + gtk_widget_hide(_compUI[i]._label); _compUI[i]._slider->hide(); - gtk_widget_hide( _compUI[i]._btn ); + gtk_widget_hide(_compUI[i]._btn); } - if ( profile ) { + if (profile) { _prof = SP_ACTIVE_DOCUMENT->profileManager->find(profile->colorProfile.c_str()); - if ( _prof && (asICColorProfileClassSig(_prof->getProfileClass()) != cmsSigNamedColorClass) ) { + if (_prof && (asICColorProfileClassSig(_prof->getProfileClass()) != cmsSigNamedColorClass)) { #if HAVE_LIBLCMS1 - _profChannelCount = _cmsChannelsOf( asICColorSpaceSig(_prof->getColorSpace()) ); + _profChannelCount = _cmsChannelsOf(asICColorSpaceSig(_prof->getColorSpace())); #elif HAVE_LIBLCMS2 - _profChannelCount = cmsChannelsOf( asICColorSpaceSig(_prof->getColorSpace()) ); + _profChannelCount = cmsChannelsOf(asICColorSpaceSig(_prof->getColorSpace())); #endif - if ( profChanged ) { - std::vector things = colorspace::getColorSpaceInfo(asICColorSpaceSig(_prof->getColorSpace())); - for (size_t i = 0; (i < things.size()) && (i < _profChannelCount); ++i) - { + if (profChanged) { + std::vector things = + colorspace::getColorSpaceInfo(asICColorSpaceSig(_prof->getColorSpace())); + for (size_t i = 0; (i < things.size()) && (i < _profChannelCount); ++i) { _compUI[i]._component = things[i]; } - for ( guint i = 0; i < _profChannelCount; i++ ) { - gtk_label_set_text_with_mnemonic( GTK_LABEL(_compUI[i]._label), (i < things.size()) ? things[i].name.c_str() : ""); + for (guint i = 0; i < _profChannelCount; i++) { + gtk_label_set_text_with_mnemonic(GTK_LABEL(_compUI[i]._label), + (i < things.size()) ? things[i].name.c_str() : ""); - _compUI[i]._slider->set_tooltip_text((i < things.size()) ? things[i].tip.c_str() : ""); - gtk_widget_set_tooltip_text( _compUI[i]._btn, (i < things.size()) ? things[i].tip.c_str() : "" ); + _compUI[i]._slider->set_tooltip_text((i < things.size()) ? things[i].tip.c_str() : ""); + gtk_widget_set_tooltip_text(_compUI[i]._btn, (i < things.size()) ? things[i].tip.c_str() : ""); _compUI[i]._slider->setColors(SPColor(0.0, 0.0, 0.0).toRGBA32(0xff), - SPColor(0.5, 0.5, 0.5).toRGBA32(0xff), - SPColor(1.0, 1.0, 1.0).toRGBA32(0xff) ); -/* - _compUI[i]._adj = GTK_ADJUSTMENT( gtk_adjustment_new( val, 0.0, _fooScales[i], step, page, page ) ); - g_signal_connect( G_OBJECT( _compUI[i]._adj ), "value_changed", G_CALLBACK( _adjustmentChanged ), _csel ); - - sp_color_slider_set_adjustment( SP_COLOR_SLIDER(_compUI[i]._slider), _compUI[i]._adj ); - gtk_spin_button_set_adjustment( GTK_SPIN_BUTTON(_compUI[i]._btn), _compUI[i]._adj ); - gtk_spin_button_set_digits( GTK_SPIN_BUTTON(_compUI[i]._btn), digits ); -*/ - gtk_widget_show( _compUI[i]._label ); + SPColor(0.5, 0.5, 0.5).toRGBA32(0xff), + SPColor(1.0, 1.0, 1.0).toRGBA32(0xff)); + /* + _compUI[i]._adj = GTK_ADJUSTMENT( gtk_adjustment_new( val, 0.0, _fooScales[i], + step, page, page ) ); + g_signal_connect( G_OBJECT( _compUI[i]._adj ), "value_changed", G_CALLBACK( + _adjustmentChanged ), _csel ); + + sp_color_slider_set_adjustment( SP_COLOR_SLIDER(_compUI[i]._slider), + _compUI[i]._adj ); + gtk_spin_button_set_adjustment( GTK_SPIN_BUTTON(_compUI[i]._btn), + _compUI[i]._adj ); + gtk_spin_button_set_digits( GTK_SPIN_BUTTON(_compUI[i]._btn), digits ); + */ + gtk_widget_show(_compUI[i]._label); _compUI[i]._slider->show(); - gtk_widget_show( _compUI[i]._btn ); - //gtk_adjustment_set_value( _compUI[i]._adj, 0.0 ); - //gtk_adjustment_set_value( _compUI[i]._adj, val ); + gtk_widget_show(_compUI[i]._btn); + // gtk_adjustment_set_value( _compUI[i]._adj, 0.0 ); + // gtk_adjustment_set_value( _compUI[i]._adj, val ); } - for ( size_t i = _profChannelCount; i < _compUI.size(); i++ ) { - gtk_widget_hide( _compUI[i]._label ); + for (size_t i = _profChannelCount; i < _compUI.size(); i++) { + gtk_widget_hide(_compUI[i]._label); _compUI[i]._slider->hide(); - gtk_widget_hide( _compUI[i]._btn ); + gtk_widget_hide(_compUI[i]._btn); } } - } else { + } + else { // Give up for now on named colors _prof = 0; } } #ifdef DEBUG_LCMS - g_message( "\\_________ %p::_setProfile()", this ); + g_message("\\_________ %p::_setProfile()", this); #endif // DEBUG_LCMS } #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) -void ColorICCSelectorImpl::_updateSliders( gint ignore ) +void ColorICCSelectorImpl::_updateSliders(gint ignore) { #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - if ( _color.color().icc ) - { - for ( guint i = 0; i < _profChannelCount; i++ ) { + if (_color.color().icc) { + for (guint i = 0; i < _profChannelCount; i++) { gdouble val = 0.0; - if ( _color.color().icc->colors.size() > i ) { - if ( _compUI[i]._component.scale == 256 ) { + if (_color.color().icc->colors.size() > i) { + if (_compUI[i]._component.scale == 256) { val = (_color.color().icc->colors[i] + 128.0) / static_cast(_compUI[i]._component.scale); - } else { + } + else { val = _color.color().icc->colors[i] / static_cast(_compUI[i]._component.scale); } } - gtk_adjustment_set_value( _compUI[i]._adj, val ); + gtk_adjustment_set_value(_compUI[i]._adj, val); } - if ( _prof ) { - if ( _prof->getTransfToSRGB8() ) { - for ( guint i = 0; i < _profChannelCount; i++ ) { - if ( static_cast(i) != ignore ) { - cmsUInt16Number* scratch = getScratch(); - cmsUInt16Number filler[4] = {0, 0, 0, 0}; - for ( guint j = 0; j < _profChannelCount; j++ ) { - filler[j] = 0x0ffff * ColorScales::getScaled( _compUI[j]._adj ); + if (_prof) { + if (_prof->getTransfToSRGB8()) { + for (guint i = 0; i < _profChannelCount; i++) { + if (static_cast(i) != ignore) { + cmsUInt16Number *scratch = getScratch(); + cmsUInt16Number filler[4] = { 0, 0, 0, 0 }; + for (guint j = 0; j < _profChannelCount; j++) { + filler[j] = 0x0ffff * ColorScales::getScaled(_compUI[j]._adj); } - - cmsUInt16Number* p = scratch; - for ( guint x = 0; x < 1024; x++ ) { - for ( guint j = 0; j < _profChannelCount; j++ ) { - if ( j == i ) { + + cmsUInt16Number *p = scratch; + for (guint x = 0; x < 1024; x++) { + for (guint j = 0; j < _profChannelCount; j++) { + if (j == i) { *p++ = x * 0x0ffff / 1024; - } else { + } + else { *p++ = filler[j]; } } } - + cmsHTRANSFORM trans = _prof->getTransfToSRGB8(); - if ( trans ) { - cmsDoTransform( trans, scratch, _compUI[i]._map, 1024 ); + if (trans) { + cmsDoTransform(trans, scratch, _compUI[i]._map, 1024); _compUI[i]._slider->setMap(_compUI[i]._map); } } @@ -909,15 +905,15 @@ void ColorICCSelectorImpl::_updateSliders( gint ignore ) (void)ignore; #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - guint32 start = _color.color().toRGBA32( 0x00 ); - guint32 mid = _color.color().toRGBA32( 0x7f ); - guint32 end = _color.color().toRGBA32( 0xff ); + guint32 start = _color.color().toRGBA32(0x00); + guint32 mid = _color.color().toRGBA32(0x7f); + guint32 end = _color.color().toRGBA32(0xff); _slider->setColors(start, mid, end); } -void ColorICCSelectorImpl::_adjustmentChanged( GtkAdjustment *adjustment, ColorICCSelectorImpl *cs ) +void ColorICCSelectorImpl::_adjustmentChanged(GtkAdjustment *adjustment, ColorICCSelectorImpl *cs) { // // TODO check this. It looks questionable: // // if a value is entered between 0 and 1 exclusive, normalize it to (int) 0..255 or 0..100 @@ -926,130 +922,132 @@ void ColorICCSelectorImpl::_adjustmentChanged( GtkAdjustment *adjustment, ColorI // } #ifdef DEBUG_LCMS - g_message( "/^^^^^^^^^ %p::_adjustmentChanged()", cs ); + g_message("/^^^^^^^^^ %p::_adjustmentChanged()", cs); #endif // DEBUG_LCMS - ColorICCSelector* iccSelector = cs->_owner; - if (iccSelector->_impl->_updating) { - return; - } + ColorICCSelector *iccSelector = cs->_owner; + if (iccSelector->_impl->_updating) { + return; + } - iccSelector->_impl->_updating = TRUE; + iccSelector->_impl->_updating = TRUE; - gint match = -1; + gint match = -1; - SPColor newColor( iccSelector->_impl->_color.color() ); - gfloat scaled = ColorScales::getScaled( iccSelector->_impl->_adj ); - if ( iccSelector->_impl->_adj == adjustment ) { + SPColor newColor(iccSelector->_impl->_color.color()); + gfloat scaled = ColorScales::getScaled(iccSelector->_impl->_adj); + if (iccSelector->_impl->_adj == adjustment) { #ifdef DEBUG_LCMS - g_message("ALPHA"); + g_message("ALPHA"); #endif // DEBUG_LCMS - } else { + } + else { #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - for ( size_t i = 0; i < iccSelector->_impl->_compUI.size(); i++ ) { - if ( iccSelector->_impl->_compUI[i]._adj == adjustment ) { - match = i; - break; - } - } - if ( match >= 0 ) { + for (size_t i = 0; i < iccSelector->_impl->_compUI.size(); i++) { + if (iccSelector->_impl->_compUI[i]._adj == adjustment) { + match = i; + break; + } + } + if (match >= 0) { #ifdef DEBUG_LCMS - g_message(" channel %d", match ); + g_message(" channel %d", match); #endif // DEBUG_LCMS - } + } - cmsUInt16Number tmp[4]; - for ( guint i = 0; i < 4; i++ ) { - tmp[i] = ColorScales::getScaled( iccSelector->_impl->_compUI[i]._adj ) * 0x0ffff; - } - guchar post[4] = {0,0,0,0}; + cmsUInt16Number tmp[4]; + for (guint i = 0; i < 4; i++) { + tmp[i] = ColorScales::getScaled(iccSelector->_impl->_compUI[i]._adj) * 0x0ffff; + } + guchar post[4] = { 0, 0, 0, 0 }; - cmsHTRANSFORM trans = iccSelector->_impl->_prof->getTransfToSRGB8(); - if ( trans ) { - cmsDoTransform( trans, tmp, post, 1 ); - } + cmsHTRANSFORM trans = iccSelector->_impl->_prof->getTransfToSRGB8(); + if (trans) { + cmsDoTransform(trans, tmp, post, 1); + } - SPColor other( SP_RGBA32_U_COMPOSE(post[0], post[1], post[2], 255) ); - other.icc = new SVGICCColor(); - if ( iccSelector->_impl->_color.color().icc ) { - other.icc->colorProfile = iccSelector->_impl->_color.color().icc->colorProfile; - } + SPColor other(SP_RGBA32_U_COMPOSE(post[0], post[1], post[2], 255)); + other.icc = new SVGICCColor(); + if (iccSelector->_impl->_color.color().icc) { + other.icc->colorProfile = iccSelector->_impl->_color.color().icc->colorProfile; + } - guint32 prior = iccSelector->_impl->_color.color().toRGBA32(255); - guint32 newer = other.toRGBA32(255); + guint32 prior = iccSelector->_impl->_color.color().toRGBA32(255); + guint32 newer = other.toRGBA32(255); - if ( prior != newer ) { + if (prior != newer) { #ifdef DEBUG_LCMS - g_message("Transformed color from 0x%08x to 0x%08x", prior, newer ); - g_message(" ~~~~ FLIP"); + g_message("Transformed color from 0x%08x to 0x%08x", prior, newer); + g_message(" ~~~~ FLIP"); #endif // DEBUG_LCMS - newColor = other; - newColor.icc->colors.clear(); - for ( guint i = 0; i < iccSelector->_impl->_profChannelCount; i++ ) { - gdouble val = ColorScales::getScaled( iccSelector->_impl->_compUI[i]._adj ); - val *= iccSelector->_impl->_compUI[i]._component.scale; - if ( iccSelector->_impl->_compUI[i]._component.scale == 256 ) { - val -= 128; - } - newColor.icc->colors.push_back( val ); - } - } + newColor = other; + newColor.icc->colors.clear(); + for (guint i = 0; i < iccSelector->_impl->_profChannelCount; i++) { + gdouble val = ColorScales::getScaled(iccSelector->_impl->_compUI[i]._adj); + val *= iccSelector->_impl->_compUI[i]._component.scale; + if (iccSelector->_impl->_compUI[i]._component.scale == 256) { + val -= 128; + } + newColor.icc->colors.push_back(val); + } + } #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - } - iccSelector->_impl->_color.setColorAlpha(newColor, scaled); - //iccSelector->_updateInternals( newColor, scaled, iccSelector->_impl->_dragging ); - iccSelector->_impl->_updateSliders( match ); + } + iccSelector->_impl->_color.setColorAlpha(newColor, scaled); + // iccSelector->_updateInternals( newColor, scaled, iccSelector->_impl->_dragging ); + iccSelector->_impl->_updateSliders(match); - iccSelector->_impl->_updating = FALSE; + iccSelector->_impl->_updating = FALSE; #ifdef DEBUG_LCMS - g_message( "\\_________ %p::_adjustmentChanged()", cs ); + g_message("\\_________ %p::_adjustmentChanged()", cs); #endif // DEBUG_LCMS } void ColorICCSelectorImpl::_sliderGrabbed() { -// ColorICCSelector* iccSelector = dynamic_cast(SP_COLOR_SELECTOR(cs)->base); -// if (!iccSelector->_dragging) { -// iccSelector->_dragging = TRUE; -// iccSelector->_grabbed(); -// iccSelector->_updateInternals( iccSelector->_color, ColorScales::getScaled( iccSelector->_impl->_adj ), iccSelector->_dragging ); -// } + // ColorICCSelector* iccSelector = dynamic_cast(SP_COLOR_SELECTOR(cs)->base); + // if (!iccSelector->_dragging) { + // iccSelector->_dragging = TRUE; + // iccSelector->_grabbed(); + // iccSelector->_updateInternals( iccSelector->_color, ColorScales::getScaled( iccSelector->_impl->_adj ), + // iccSelector->_dragging ); + // } } void ColorICCSelectorImpl::_sliderReleased() { -// ColorICCSelector* iccSelector = dynamic_cast(SP_COLOR_SELECTOR(cs)->base); -// if (iccSelector->_dragging) { -// iccSelector->_dragging = FALSE; -// iccSelector->_released(); -// iccSelector->_updateInternals( iccSelector->_color, ColorScales::getScaled( iccSelector->_adj ), iccSelector->_dragging ); -// } + // ColorICCSelector* iccSelector = dynamic_cast(SP_COLOR_SELECTOR(cs)->base); + // if (iccSelector->_dragging) { + // iccSelector->_dragging = FALSE; + // iccSelector->_released(); + // iccSelector->_updateInternals( iccSelector->_color, ColorScales::getScaled( iccSelector->_adj ), + // iccSelector->_dragging ); + // } } #ifdef DEBUG_LCMS -void ColorICCSelectorImpl::_sliderChanged( SPColorSlider *slider, SPColorICCSelector *cs ) +void ColorICCSelectorImpl::_sliderChanged(SPColorSlider *slider, SPColorICCSelector *cs) #else void ColorICCSelectorImpl::_sliderChanged() #endif // DEBUG_LCMS { #ifdef DEBUG_LCMS - g_message("Changed %p and %p", slider, cs ); + g_message("Changed %p and %p", slider, cs); #endif // DEBUG_LCMS -// ColorICCSelector* iccSelector = dynamic_cast(SP_COLOR_SELECTOR(cs)->base); + // ColorICCSelector* iccSelector = dynamic_cast(SP_COLOR_SELECTOR(cs)->base); -// iccSelector->_updateInternals( iccSelector->_color, ColorScales::getScaled( iccSelector->_adj ), iccSelector->_dragging ); + // iccSelector->_updateInternals( iccSelector->_color, ColorScales::getScaled( iccSelector->_adj ), + // iccSelector->_dragging ); } -Gtk::Widget *ColorICCSelectorFactory::createWidget(Inkscape::UI::SelectedColor &color) const { +Gtk::Widget *ColorICCSelectorFactory::createWidget(Inkscape::UI::SelectedColor &color) const +{ Gtk::Widget *w = Gtk::manage(new ColorICCSelector(color)); return w; } -Glib::ustring ColorICCSelectorFactory::modeName() const { - return gettext(ColorICCSelector::MODE_NAME); -} - +Glib::ustring ColorICCSelectorFactory::modeName() const { return gettext(ColorICCSelector::MODE_NAME); } } } } diff --git a/src/ui/widget/color-icc-selector.h b/src/ui/widget/color-icc-selector.h index 6066586f5..37201de3b 100644 --- a/src/ui/widget/color-icc-selector.h +++ b/src/ui/widget/color-icc-selector.h @@ -2,7 +2,7 @@ #define SEEN_SP_COLOR_ICC_SELECTOR_H #ifdef HAVE_CONFIG_H -# include +#include #endif #include @@ -24,42 +24,41 @@ namespace Widget { class ColorICCSelectorImpl; class ColorICCSelector -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) : public Gtk::Grid #else : public Gtk::Table #endif -{ -public: - static const gchar* MODE_NAME; + { + public: + static const gchar *MODE_NAME; ColorICCSelector(SelectedColor &color); virtual ~ColorICCSelector(); virtual void init(); -protected: + protected: virtual void _colorChanged(); - void _recalcColor( gboolean changing ); + void _recalcColor(gboolean changing); -private: + private: friend class ColorICCSelectorImpl; // By default, disallow copy constructor and assignment operator - ColorICCSelector( const ColorICCSelector& obj ); - ColorICCSelector& operator=( const ColorICCSelector& obj ); + ColorICCSelector(const ColorICCSelector &obj); + ColorICCSelector &operator=(const ColorICCSelector &obj); ColorICCSelectorImpl *_impl; }; -class ColorICCSelectorFactory: public ColorSelectorFactory { -public: - Gtk::Widget* createWidget(SelectedColor &color) const; +class ColorICCSelectorFactory : public ColorSelectorFactory { + public: + Gtk::Widget *createWidget(SelectedColor &color) const; Glib::ustring modeName() const; }; - } } } diff --git a/src/ui/widget/color-notebook.cpp b/src/ui/widget/color-notebook.cpp index 92b1d7086..0150f2ca2 100644 --- a/src/ui/widget/color-notebook.cpp +++ b/src/ui/widget/color-notebook.cpp @@ -16,7 +16,7 @@ #define noDUMP_CHANGE_INFO #ifdef HAVE_CONFIG_H -# include "config.h" +#include "config.h" #endif #include "widgets/icon.h" @@ -56,7 +56,7 @@ namespace Widget { ColorNotebook::ColorNotebook(SelectedColor &color) -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) : Gtk::Grid() #else : Gtk::Table(2, 3, false) @@ -87,12 +87,10 @@ ColorNotebook::ColorNotebook(SelectedColor &color) ColorNotebook::~ColorNotebook() { - if ( _buttons ) - { - delete [] _buttons; + if (_buttons) { + delete[] _buttons; _buttons = 0; } - } ColorNotebook::Page::Page(Inkscape::UI::ColorSelectorFactory *selector_factory, bool enabled_full) @@ -112,57 +110,57 @@ void ColorNotebook::_initUI() notebook->set_show_tabs(false); _book = GTK_WIDGET(notebook->gobj()); -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) _buttonbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_set_homogeneous(GTK_BOX(_buttonbox), TRUE); #else - _buttonbox = gtk_hbox_new (TRUE, 2); + _buttonbox = gtk_hbox_new(TRUE, 2); #endif - gtk_widget_show (_buttonbox); + gtk_widget_show(_buttonbox); _buttons = new GtkWidget *[_available_pages.size()]; - for (int i = 0; static_cast(i) < _available_pages.size(); i++ ) - { + for (int i = 0; static_cast(i) < _available_pages.size(); i++) { _addPage(_available_pages[i]); } - sp_set_font_size_smaller (_buttonbox); + sp_set_font_size_smaller(_buttonbox); -#if GTK_CHECK_VERSION(3,0,0) - #if GTK_CHECK_VERSION(3,12,0) +#if GTK_CHECK_VERSION(3, 0, 0) + #if GTK_CHECK_VERSION(3, 12, 0) gtk_widget_set_margin_start(_buttonbox, XPAD); gtk_widget_set_margin_end(_buttonbox, XPAD); - #else + #else gtk_widget_set_margin_left(_buttonbox, XPAD); gtk_widget_set_margin_right(_buttonbox, XPAD); - #endif + #endif gtk_widget_set_margin_top(_buttonbox, YPAD); gtk_widget_set_margin_bottom(_buttonbox, YPAD); gtk_widget_set_hexpand(_buttonbox, TRUE); gtk_widget_set_valign(_buttonbox, GTK_ALIGN_CENTER); attach(*Glib::wrap(_buttonbox), 0, row, 2, 1); #else - attach(*Glib::wrap(_buttonbox), 0, 2, row, row+1, Gtk::EXPAND | Gtk::FILL, static_cast(0), XPAD, YPAD); + attach(*Glib::wrap(_buttonbox), 0, 2, row, row + 1, Gtk::EXPAND | Gtk::FILL, static_cast(0), + XPAD, YPAD); #endif row++; -#if GTK_CHECK_VERSION(3,0,0) - #if GTK_CHECK_VERSION(3,12,0) - gtk_widget_set_margin_start(_book, XPAD*2); - gtk_widget_set_margin_end(_book, XPAD*2); - #else - gtk_widget_set_margin_left(_book, XPAD*2); - gtk_widget_set_margin_right(_book, XPAD*2); - #endif +#if GTK_CHECK_VERSION(3, 0, 0) +#if GTK_CHECK_VERSION(3, 12, 0) + gtk_widget_set_margin_start(_book, XPAD * 2); + gtk_widget_set_margin_end(_book, XPAD * 2); +#else + gtk_widget_set_margin_left(_book, XPAD * 2); + gtk_widget_set_margin_right(_book, XPAD * 2); +#endif gtk_widget_set_margin_top(_book, YPAD); gtk_widget_set_margin_bottom(_book, YPAD); gtk_widget_set_hexpand(_book, TRUE); gtk_widget_set_vexpand(_book, TRUE); attach(*notebook, 0, row, 2, 1); #else - attach(*notebook, 0, 2, row, row+1, Gtk::EXPAND | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, XPAD * 2, YPAD); + attach(*notebook, 0, 2, row, row + 1, Gtk::EXPAND | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, XPAD * 2, YPAD); #endif // restore the last active page @@ -170,72 +168,72 @@ void ColorNotebook::_initUI() _setCurrentPage(prefs->getInt("/colorselector/page", 0)); row++; -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) GtkWidget *rgbabox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #else - GtkWidget *rgbabox = gtk_hbox_new (FALSE, 0); + GtkWidget *rgbabox = gtk_hbox_new(FALSE, 0); #endif #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) /* Create color management icons */ - _box_colormanaged = gtk_event_box_new (); - GtkWidget *colormanaged = gtk_image_new_from_icon_name ("color-management-icon", GTK_ICON_SIZE_SMALL_TOOLBAR); - gtk_container_add (GTK_CONTAINER (_box_colormanaged), colormanaged); - gtk_widget_set_tooltip_text (_box_colormanaged, _("Color Managed")); - gtk_widget_set_sensitive (_box_colormanaged, false); + _box_colormanaged = gtk_event_box_new(); + GtkWidget *colormanaged = gtk_image_new_from_icon_name("color-management-icon", GTK_ICON_SIZE_SMALL_TOOLBAR); + gtk_container_add(GTK_CONTAINER(_box_colormanaged), colormanaged); + gtk_widget_set_tooltip_text(_box_colormanaged, _("Color Managed")); + gtk_widget_set_sensitive(_box_colormanaged, false); gtk_box_pack_start(GTK_BOX(rgbabox), _box_colormanaged, FALSE, FALSE, 2); - _box_outofgamut = gtk_event_box_new (); - GtkWidget *outofgamut = gtk_image_new_from_icon_name ("out-of-gamut-icon", GTK_ICON_SIZE_SMALL_TOOLBAR); - gtk_container_add (GTK_CONTAINER (_box_outofgamut), outofgamut); - gtk_widget_set_tooltip_text (_box_outofgamut, _("Out of gamut!")); - gtk_widget_set_sensitive (_box_outofgamut, false); + _box_outofgamut = gtk_event_box_new(); + GtkWidget *outofgamut = gtk_image_new_from_icon_name("out-of-gamut-icon", GTK_ICON_SIZE_SMALL_TOOLBAR); + gtk_container_add(GTK_CONTAINER(_box_outofgamut), outofgamut); + gtk_widget_set_tooltip_text(_box_outofgamut, _("Out of gamut!")); + gtk_widget_set_sensitive(_box_outofgamut, false); gtk_box_pack_start(GTK_BOX(rgbabox), _box_outofgamut, FALSE, FALSE, 2); - _box_toomuchink = gtk_event_box_new (); - GtkWidget *toomuchink = gtk_image_new_from_icon_name ("too-much-ink-icon", GTK_ICON_SIZE_SMALL_TOOLBAR); - gtk_container_add (GTK_CONTAINER (_box_toomuchink), toomuchink); - gtk_widget_set_tooltip_text (_box_toomuchink, _("Too much ink!")); - gtk_widget_set_sensitive (_box_toomuchink, false); + _box_toomuchink = gtk_event_box_new(); + GtkWidget *toomuchink = gtk_image_new_from_icon_name("too-much-ink-icon", GTK_ICON_SIZE_SMALL_TOOLBAR); + gtk_container_add(GTK_CONTAINER(_box_toomuchink), toomuchink); + gtk_widget_set_tooltip_text(_box_toomuchink, _("Too much ink!")); + gtk_widget_set_sensitive(_box_toomuchink, false); gtk_box_pack_start(GTK_BOX(rgbabox), _box_toomuchink, FALSE, FALSE, 2); -#endif //defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) +#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) /* Color picker */ - GtkWidget *picker = gtk_image_new_from_icon_name ("color-picker", GTK_ICON_SIZE_SMALL_TOOLBAR); - _btn_picker = gtk_button_new (); + GtkWidget *picker = gtk_image_new_from_icon_name("color-picker", GTK_ICON_SIZE_SMALL_TOOLBAR); + _btn_picker = gtk_button_new(); gtk_button_set_relief(GTK_BUTTON(_btn_picker), GTK_RELIEF_NONE); - gtk_container_add (GTK_CONTAINER (_btn_picker), picker); - gtk_widget_set_tooltip_text (_btn_picker, _("Pick colors from image")); + gtk_container_add(GTK_CONTAINER(_btn_picker), picker); + gtk_widget_set_tooltip_text(_btn_picker, _("Pick colors from image")); gtk_box_pack_start(GTK_BOX(rgbabox), _btn_picker, FALSE, FALSE, 2); g_signal_connect(G_OBJECT(_btn_picker), "clicked", G_CALLBACK(ColorNotebook::_onPickerClicked), this); /* Create RGBA entry and color preview */ - _rgbal = gtk_label_new_with_mnemonic (_("RGBA_:")); - gtk_misc_set_alignment (GTK_MISC (_rgbal), 1.0, 0.5); + _rgbal = gtk_label_new_with_mnemonic(_("RGBA_:")); + gtk_misc_set_alignment(GTK_MISC(_rgbal), 1.0, 0.5); gtk_box_pack_start(GTK_BOX(rgbabox), _rgbal, TRUE, TRUE, 2); - ColorEntry* rgba_entry = Gtk::manage(new ColorEntry(_selected_color)); - sp_dialog_defocus_on_enter (GTK_WIDGET(rgba_entry->gobj())); + ColorEntry *rgba_entry = Gtk::manage(new ColorEntry(_selected_color)); + sp_dialog_defocus_on_enter(GTK_WIDGET(rgba_entry->gobj())); gtk_box_pack_start(GTK_BOX(rgbabox), GTK_WIDGET(rgba_entry->gobj()), FALSE, FALSE, 0); - gtk_label_set_mnemonic_widget (GTK_LABEL(_rgbal), GTK_WIDGET(rgba_entry->gobj())); + gtk_label_set_mnemonic_widget(GTK_LABEL(_rgbal), GTK_WIDGET(rgba_entry->gobj())); - sp_set_font_size_smaller (rgbabox); - gtk_widget_show_all (rgbabox); + sp_set_font_size_smaller(rgbabox); + gtk_widget_show_all(rgbabox); #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - //the "too much ink" icon is initially hidden + // the "too much ink" icon is initially hidden gtk_widget_hide(GTK_WIDGET(_box_toomuchink)); -#endif //defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) +#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) -#if GTK_CHECK_VERSION(3,0,0) - #if GTK_CHECK_VERSION(3,12,0) +#if GTK_CHECK_VERSION(3, 0, 0) + #if GTK_CHECK_VERSION(3, 12, 0) gtk_widget_set_margin_start(rgbabox, XPAD); gtk_widget_set_margin_end(rgbabox, XPAD); - #else + #else gtk_widget_set_margin_left(rgbabox, XPAD); gtk_widget_set_margin_right(rgbabox, XPAD); - #endif + #endif gtk_widget_set_margin_top(rgbabox, YPAD); gtk_widget_set_margin_bottom(rgbabox, YPAD); attach(*Glib::wrap(rgbabox), 0, row, 2, 1); @@ -244,13 +242,12 @@ void ColorNotebook::_initUI() #endif #ifdef SPCS_PREVIEW - _p = sp_color_preview_new (0xffffffff); - gtk_widget_show (_p); + _p = sp_color_preview_new(0xffffffff); + gtk_widget_show(_p); attach(*Glib::wrap(_p), 2, 3, row, row + 1, Gtk::FILL, Gtk::FILL, XPAD, YPAD); #endif - g_signal_connect(G_OBJECT (_book), "switch-page", - G_CALLBACK (ColorNotebook::_onPageSwitched), this); + g_signal_connect(G_OBJECT(_book), "switch-page", G_CALLBACK(ColorNotebook::_onPageSwitched), this); } void ColorNotebook::_onPickerClicked(GtkWidget * /*widget*/, ColorNotebook * /*colorbook*/) @@ -261,27 +258,22 @@ void ColorNotebook::_onPickerClicked(GtkWidget * /*widget*/, ColorNotebook * /*c Inkscape::UI::Tools::sp_toggle_dropper(SP_ACTIVE_DESKTOP); } -void ColorNotebook::_onButtonClicked(GtkWidget *widget, ColorNotebook *nb) +void ColorNotebook::_onButtonClicked(GtkWidget *widget, ColorNotebook *nb) { - if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(widget))) { + if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) { return; } - for(gint i = 0; i < gtk_notebook_get_n_pages (GTK_NOTEBOOK (nb->_book)); i++) { + for (gint i = 0; i < gtk_notebook_get_n_pages(GTK_NOTEBOOK(nb->_book)); i++) { if (nb->_buttons[i] == widget) { - gtk_notebook_set_current_page (GTK_NOTEBOOK (nb->_book), i); + gtk_notebook_set_current_page(GTK_NOTEBOOK(nb->_book), i); } } } -void ColorNotebook::_onSelectedColorChanged() { - _updateICCButtons(); -} +void ColorNotebook::_onSelectedColorChanged() { _updateICCButtons(); } -void ColorNotebook::_onPageSwitched(GtkNotebook *notebook, - GtkWidget *page, - guint page_num, - ColorNotebook *colorbook) +void ColorNotebook::_onPageSwitched(GtkNotebook *notebook, GtkWidget *page, guint page_num, ColorNotebook *colorbook) { if (colorbook) { // remember the page we switched to @@ -297,41 +289,45 @@ void ColorNotebook::_updateICCButtons() SPColor color = _selected_color.color(); gfloat alpha = _selected_color.alpha(); - g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) ); + g_return_if_fail((0.0 <= alpha) && (alpha <= 1.0)); #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) /* update color management icon*/ - gtk_widget_set_sensitive (_box_colormanaged, color.icc != NULL); + gtk_widget_set_sensitive(_box_colormanaged, color.icc != NULL); /* update out-of-gamut icon */ - gtk_widget_set_sensitive (_box_outofgamut, false); - if (color.icc){ - Inkscape::ColorProfile* target_profile = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str()); - if ( target_profile ) + gtk_widget_set_sensitive(_box_outofgamut, false); + if (color.icc) { + Inkscape::ColorProfile *target_profile = + SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str()); + if (target_profile) gtk_widget_set_sensitive(_box_outofgamut, target_profile->GamutCheck(color)); } /* update too-much-ink icon */ - gtk_widget_set_sensitive (_box_toomuchink, false); - if (color.icc){ - Inkscape::ColorProfile* prof = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str()); - if ( prof && CMSSystem::isPrintColorSpace(prof) ) { + gtk_widget_set_sensitive(_box_toomuchink, false); + if (color.icc) { + Inkscape::ColorProfile *prof = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str()); + if (prof && CMSSystem::isPrintColorSpace(prof)) { gtk_widget_show(GTK_WIDGET(_box_toomuchink)); double ink_sum = 0; - for (unsigned int i=0; icolors.size(); i++){ + for (unsigned int i = 0; i < color.icc->colors.size(); i++) { ink_sum += color.icc->colors[i]; } - /* Some literature states that when the sum of paint values exceed 320%, it is considered to be a satured color, - which means the paper can get too wet due to an excessive ammount of ink. This may lead to several issues + /* Some literature states that when the sum of paint values exceed 320%, it is considered to be a satured + color, + which means the paper can get too wet due to an excessive ammount of ink. This may lead to several + issues such as misalignment and poor quality of printing in general.*/ - if ( ink_sum > 3.2 ) - gtk_widget_set_sensitive (_box_toomuchink, true); - } else { + if (ink_sum > 3.2) + gtk_widget_set_sensitive(_box_toomuchink, true); + } + else { gtk_widget_hide(GTK_WIDGET(_box_toomuchink)); } } -#endif //defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) +#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) } void ColorNotebook::_setCurrentPage(int i) @@ -343,7 +339,8 @@ void ColorNotebook::_setCurrentPage(int i) } } -void ColorNotebook::_addPage(Page& page) { +void ColorNotebook::_addPage(Page &page) +{ Gtk::Widget *selector_widget; selector_widget = page.selector_factory->createWidget(_selected_color); @@ -351,22 +348,21 @@ void ColorNotebook::_addPage(Page& page) { selector_widget->show(); Glib::ustring mode_name = page.selector_factory->modeName(); - Gtk::Widget* tab_label = Gtk::manage(new Gtk::Label(mode_name)); - gint page_num = gtk_notebook_append_page( GTK_NOTEBOOK(_book), selector_widget->gobj(), tab_label->gobj()); + Gtk::Widget *tab_label = Gtk::manage(new Gtk::Label(mode_name)); + gint page_num = gtk_notebook_append_page(GTK_NOTEBOOK(_book), selector_widget->gobj(), tab_label->gobj()); _buttons[page_num] = gtk_radio_button_new_with_label(NULL, mode_name.c_str()); gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(_buttons[page_num]), FALSE); if (page_num > 0) { - GSList *group = gtk_radio_button_get_group (GTK_RADIO_BUTTON(_buttons[0])); - gtk_radio_button_set_group (GTK_RADIO_BUTTON(_buttons[page_num]), group); + GSList *group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(_buttons[0])); + gtk_radio_button_set_group(GTK_RADIO_BUTTON(_buttons[page_num]), group); } - gtk_widget_show (_buttons[page_num]); - gtk_box_pack_start (GTK_BOX (_buttonbox), _buttons[page_num], TRUE, TRUE, 0); + gtk_widget_show(_buttons[page_num]); + gtk_box_pack_start(GTK_BOX(_buttonbox), _buttons[page_num], TRUE, TRUE, 0); - g_signal_connect (G_OBJECT (_buttons[page_num]), "clicked", G_CALLBACK (_onButtonClicked), this); + g_signal_connect(G_OBJECT(_buttons[page_num]), "clicked", G_CALLBACK(_onButtonClicked), this); } } - } } } diff --git a/src/ui/widget/color-notebook.h b/src/ui/widget/color-notebook.h index 9909aa39c..d28028c72 100644 --- a/src/ui/widget/color-notebook.h +++ b/src/ui/widget/color-notebook.h @@ -15,7 +15,7 @@ #define SEEN_SP_COLOR_NOTEBOOK_H #ifdef HAVE_CONFIG_H -# include +#include #endif #include @@ -35,7 +35,7 @@ namespace UI { namespace Widget { class ColorNotebook -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) : public Gtk::Grid #else : public Gtk::Table @@ -54,12 +54,11 @@ protected: }; virtual void _initUI(); - void _addPage(Page& page); + void _addPage(Page &page); static void _onButtonClicked(GtkWidget *widget, ColorNotebook *colorbook); static void _onPickerClicked(GtkWidget *widget, ColorNotebook *colorbook); - static void _onPageSwitched(GtkNotebook *notebook, GtkWidget *page, - guint page_num, ColorNotebook *colorbook); + static void _onPageSwitched(GtkNotebook *notebook, GtkWidget *page, guint page_num, ColorNotebook *colorbook); virtual void _onSelectedColorChanged(); void _updateICCButtons(); @@ -73,17 +72,16 @@ protected: GtkWidget *_rgbal; /* RGBA entry */ #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) GtkWidget *_box_outofgamut, *_box_colormanaged, *_box_toomuchink; -#endif //defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) +#endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) GtkWidget *_btn_picker; GtkWidget *_p; /* Color preview */ boost::ptr_vector _available_pages; private: // By default, disallow copy constructor and assignment operator - ColorNotebook( const ColorNotebook& obj ); - ColorNotebook& operator=( const ColorNotebook& obj ); + ColorNotebook(const ColorNotebook &obj); + ColorNotebook &operator=(const ColorNotebook &obj); }; - } } } diff --git a/src/ui/widget/color-scales.cpp b/src/ui/widget/color-scales.cpp index 9f18b2d96..5fa5af902 100644 --- a/src/ui/widget/color-scales.cpp +++ b/src/ui/widget/color-scales.cpp @@ -3,7 +3,7 @@ */ #ifdef HAVE_CONFIG_H -# include "config.h" +#include "config.h" #endif #include @@ -41,26 +41,20 @@ namespace UI { namespace Widget { -static const gchar * sp_color_scales_hue_map (); +static const gchar *sp_color_scales_hue_map(); -const gchar* ColorScales::SUBMODE_NAMES[] = { - N_("None"), - N_("RGB"), - N_("HSL"), - N_("CMYK") -}; +const gchar *ColorScales::SUBMODE_NAMES[] = { N_("None"), N_("RGB"), N_("HSL"), N_("CMYK") }; ColorScales::ColorScales(SelectedColor &color, SPColorScalesMode mode) -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) : Gtk::Grid() #else : Gtk::Table(5, 3, false) #endif , _color(color) - , - _rangeLimit( 255.0 ), - _updating( FALSE ), - _dragging( FALSE ) + , _rangeLimit(255.0) + , _updating(FALSE) + , _dragging(FALSE) { for (gint i = 0; i < 5; i++) { _l[i] = 0; @@ -73,7 +67,6 @@ ColorScales::ColorScales(SelectedColor &color, SPColorScalesMode mode) _color.signal_changed.connect(sigc::mem_fun(this, &ColorScales::_onColorChanged)); _color.signal_dragged.connect(sigc::mem_fun(this, &ColorScales::_onColorChanged)); - } ColorScales::~ColorScales() @@ -88,92 +81,92 @@ ColorScales::~ColorScales() void ColorScales::_initUI(SPColorScalesMode mode) { - gint i; + gint i; - _updating = FALSE; - _dragging = FALSE; + _updating = FALSE; + _dragging = FALSE; - GtkWidget *t = GTK_WIDGET(gobj()); + GtkWidget *t = GTK_WIDGET(gobj()); - /* Create components */ - for (i = 0; i < static_cast< gint > (G_N_ELEMENTS(_a)) ; i++) { - /* Label */ - _l[i] = gtk_label_new(""); - gtk_misc_set_alignment (GTK_MISC (_l[i]), 1.0, 0.5); - gtk_widget_show (_l[i]); + /* Create components */ + for (i = 0; i < static_cast(G_N_ELEMENTS(_a)); i++) { + /* Label */ + _l[i] = gtk_label_new(""); + gtk_misc_set_alignment(GTK_MISC(_l[i]), 1.0, 0.5); + gtk_widget_show(_l[i]); -#if GTK_CHECK_VERSION(3,0,0) - #if GTK_CHECK_VERSION(3,12,0) - gtk_widget_set_margin_start(_l[i], XPAD); - gtk_widget_set_margin_end(_l[i], XPAD); +#if GTK_CHECK_VERSION(3, 0, 0) + #if GTK_CHECK_VERSION(3, 12, 0) + gtk_widget_set_margin_start(_l[i], XPAD); + gtk_widget_set_margin_end(_l[i], XPAD); #else - gtk_widget_set_margin_left(_l[i], XPAD); - gtk_widget_set_margin_right(_l[i], XPAD); + gtk_widget_set_margin_left(_l[i], XPAD); + gtk_widget_set_margin_right(_l[i], XPAD); #endif - gtk_widget_set_margin_top(_l[i], YPAD); - gtk_widget_set_margin_bottom(_l[i], YPAD); - gtk_grid_attach(GTK_GRID(t), _l[i], 0, i, 1, 1); + gtk_widget_set_margin_top(_l[i], YPAD); + gtk_widget_set_margin_bottom(_l[i], YPAD); + gtk_grid_attach(GTK_GRID(t), _l[i], 0, i, 1, 1); #else - gtk_table_attach (GTK_TABLE (t), _l[i], 0, 1, i, i + 1, GTK_FILL, GTK_FILL, XPAD, YPAD); + gtk_table_attach(GTK_TABLE(t), _l[i], 0, 1, i, i + 1, GTK_FILL, GTK_FILL, XPAD, YPAD); #endif - /* Adjustment */ - _a[i] = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, _rangeLimit, 1.0, 10.0, 10.0)); - /* Slider */ - _s[i] = Gtk::manage(new Inkscape::UI::Widget::ColorSlider(Glib::wrap(_a[i], true))); - _s[i]->show(); + /* Adjustment */ + _a[i] = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, _rangeLimit, 1.0, 10.0, 10.0)); + /* Slider */ + _s[i] = Gtk::manage(new Inkscape::UI::Widget::ColorSlider(Glib::wrap(_a[i], true))); + _s[i]->show(); -#if GTK_CHECK_VERSION(3,0,0) - #if GTK_CHECK_VERSION(3,12,0) - _s[i]->set_margin_start(XPAD); - _s[i]->set_margin_end(XPAD); +#if GTK_CHECK_VERSION(3, 0, 0) + #if GTK_CHECK_VERSION(3, 12, 0) + _s[i]->set_margin_start(XPAD); + _s[i]->set_margin_end(XPAD); #else - _s[i]->set_margin_left(XPAD); - _s[i]->set_margin_right(XPAD); + _s[i]->set_margin_left(XPAD); + _s[i]->set_margin_right(XPAD); #endif - _s[i]->set_margin_top(YPAD); - _s[i]->set_margin_bottom(YPAD); - _s[i]->set_hexpand(true); - gtk_grid_attach(GTK_GRID(t), _s[i]->gobj(), 1, i, 1, 1); + _s[i]->set_margin_top(YPAD); + _s[i]->set_margin_bottom(YPAD); + _s[i]->set_hexpand(true); + gtk_grid_attach(GTK_GRID(t), _s[i]->gobj(), 1, i, 1, 1); #else - gtk_table_attach (GTK_TABLE (t), _s[i]->gobj(), 1, 2, i, i + 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, XPAD, YPAD); + gtk_table_attach(GTK_TABLE(t), _s[i]->gobj(), 1, 2, i, i + 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), + GTK_FILL, XPAD, YPAD); #endif - /* Spinbutton */ - _b[i] = gtk_spin_button_new (GTK_ADJUSTMENT (_a[i]), 1.0, 0); - sp_dialog_defocus_on_enter (_b[i]); - gtk_label_set_mnemonic_widget (GTK_LABEL(_l[i]), _b[i]); - gtk_widget_show (_b[i]); + /* Spinbutton */ + _b[i] = gtk_spin_button_new(GTK_ADJUSTMENT(_a[i]), 1.0, 0); + sp_dialog_defocus_on_enter(_b[i]); + gtk_label_set_mnemonic_widget(GTK_LABEL(_l[i]), _b[i]); + gtk_widget_show(_b[i]); -#if GTK_CHECK_VERSION(3,0,0) - #if GTK_CHECK_VERSION(3,12,0) - gtk_widget_set_margin_start(_b[i], XPAD); - gtk_widget_set_margin_end(_b[i], XPAD); +#if GTK_CHECK_VERSION(3, 0, 0) + #if GTK_CHECK_VERSION(3, 12, 0) + gtk_widget_set_margin_start(_b[i], XPAD); + gtk_widget_set_margin_end(_b[i], XPAD); #else - gtk_widget_set_margin_left(_b[i], XPAD); - gtk_widget_set_margin_right(_b[i], XPAD); + gtk_widget_set_margin_left(_b[i], XPAD); + gtk_widget_set_margin_right(_b[i], XPAD); #endif - gtk_widget_set_margin_top(_b[i], YPAD); - gtk_widget_set_margin_bottom(_b[i], YPAD); - gtk_widget_set_halign(_b[i], GTK_ALIGN_CENTER); - gtk_widget_set_valign(_b[i], GTK_ALIGN_CENTER); - gtk_grid_attach(GTK_GRID(t), _b[i], 2, i, 1, 1); + gtk_widget_set_margin_top(_b[i], YPAD); + gtk_widget_set_margin_bottom(_b[i], YPAD); + gtk_widget_set_halign(_b[i], GTK_ALIGN_CENTER); + gtk_widget_set_valign(_b[i], GTK_ALIGN_CENTER); + gtk_grid_attach(GTK_GRID(t), _b[i], 2, i, 1, 1); #else - gtk_table_attach (GTK_TABLE (t), _b[i], 2, 3, i, i + 1, (GtkAttachOptions)0, (GtkAttachOptions)0, XPAD, YPAD); + gtk_table_attach(GTK_TABLE(t), _b[i], 2, 3, i, i + 1, (GtkAttachOptions)0, (GtkAttachOptions)0, XPAD, YPAD); #endif - /* Attach channel value to adjustment */ - g_object_set_data (G_OBJECT (_a[i]), "channel", GINT_TO_POINTER (i)); - /* Signals */ - g_signal_connect (G_OBJECT (_a[i]), "value_changed", - G_CALLBACK (_adjustmentAnyChanged), this); - _s[i]->signal_grabbed.connect(sigc::mem_fun(this, &ColorScales::_sliderAnyGrabbed)); - _s[i]->signal_released.connect(sigc::mem_fun(this, &ColorScales::_sliderAnyReleased)); - _s[i]->signal_value_changed.connect(sigc::mem_fun(this, &ColorScales::_sliderAnyChanged)); - } - - /* Initial mode is none, so it works */ - setMode(mode); + /* Attach channel value to adjustment */ + g_object_set_data(G_OBJECT(_a[i]), "channel", GINT_TO_POINTER(i)); + /* Signals */ + g_signal_connect(G_OBJECT(_a[i]), "value_changed", G_CALLBACK(_adjustmentAnyChanged), this); + _s[i]->signal_grabbed.connect(sigc::mem_fun(this, &ColorScales::_sliderAnyGrabbed)); + _s[i]->signal_released.connect(sigc::mem_fun(this, &ColorScales::_sliderAnyReleased)); + _s[i]->signal_value_changed.connect(sigc::mem_fun(this, &ColorScales::_sliderAnyChanged)); + } + + /* Initial mode is none, so it works */ + setMode(mode); } void ColorScales::_recalcColor() @@ -183,25 +176,24 @@ void ColorScales::_recalcColor() gfloat c[5]; switch (_mode) { - case SP_COLOR_SCALES_MODE_RGB: - case SP_COLOR_SCALES_MODE_HSV: - _getRgbaFloatv(c); - color.set( c[0], c[1], c[2] ); - alpha = c[3]; - break; - case SP_COLOR_SCALES_MODE_CMYK: - { - _getCmykaFloatv( c ); - - float rgb[3]; - sp_color_cmyk_to_rgb_floatv( rgb, c[0], c[1], c[2], c[3] ); - color.set( rgb[0], rgb[1], rgb[2] ); - alpha = c[4]; - break; - } - default: - g_warning ("file %s: line %d: Illegal color selector mode %d", __FILE__, __LINE__, _mode); - break; + case SP_COLOR_SCALES_MODE_RGB: + case SP_COLOR_SCALES_MODE_HSV: + _getRgbaFloatv(c); + color.set(c[0], c[1], c[2]); + alpha = c[3]; + break; + case SP_COLOR_SCALES_MODE_CMYK: { + _getCmykaFloatv(c); + + float rgb[3]; + sp_color_cmyk_to_rgb_floatv(rgb, c[0], c[1], c[2], c[3]); + color.set(rgb[0], rgb[1], rgb[2]); + alpha = c[4]; + break; + } + default: + g_warning("file %s: line %d: Illegal color selector mode %d", __FILE__, __LINE__, _mode); + break; } _color.preserveICC(); @@ -209,25 +201,25 @@ void ColorScales::_recalcColor() } /* Helpers for setting color value */ -gfloat ColorScales::getScaled( const GtkAdjustment *a ) +gfloat ColorScales::getScaled(const GtkAdjustment *a) { - gfloat val = gtk_adjustment_get_value (const_cast(a)) - / gtk_adjustment_get_upper (const_cast(a)); + gfloat val = gtk_adjustment_get_value(const_cast(a)) / + gtk_adjustment_get_upper(const_cast(a)); return val; } -void ColorScales::setScaled( GtkAdjustment *a, gfloat v ) +void ColorScales::setScaled(GtkAdjustment *a, gfloat v) { - gfloat val = v * gtk_adjustment_get_upper (a); - gtk_adjustment_set_value( a, val ); + gfloat val = v * gtk_adjustment_get_upper(a); + gtk_adjustment_set_value(a, val); } -void ColorScales::_setRangeLimit( gdouble upper ) +void ColorScales::_setRangeLimit(gdouble upper) { _rangeLimit = upper; - for ( gint i = 0; i < static_cast(G_N_ELEMENTS(_a)); i++ ) { - gtk_adjustment_set_upper (_a[i], upper); - gtk_adjustment_changed( _a[i] ); + for (gint i = 0; i < static_cast(G_N_ELEMENTS(_a)); i++) { + gtk_adjustment_set_upper(_a[i], upper); + gtk_adjustment_changed(_a[i]); } } @@ -237,231 +229,230 @@ void ColorScales::_onColorChanged() return; } #ifdef DUMP_CHANGE_INFO - g_message("ColorScales::_onColorChanged( this=%p, %f, %f, %f, %f)", this, _color.color().v.c[0], _color.color().v.c[1], _color.color().v.c[2], _color.alpha() ); + g_message("ColorScales::_onColorChanged( this=%p, %f, %f, %f, %f)", this, _color.color().v.c[0], + _color.color().v.c[1], _color.color().v.c[2], _color.alpha()); #endif gfloat tmp[3]; - gfloat c[5] = {0.0, 0.0, 0.0, 0.0}; + gfloat c[5] = { 0.0, 0.0, 0.0, 0.0 }; SPColor color = _color.color(); switch (_mode) { - case SP_COLOR_SCALES_MODE_RGB: - sp_color_get_rgb_floatv( &color, c ); - c[3] = _color.alpha(); - c[4] = 0.0; - break; - case SP_COLOR_SCALES_MODE_HSV: - sp_color_get_rgb_floatv( &color, tmp ); - sp_color_rgb_to_hsl_floatv (c, tmp[0], tmp[1], tmp[2]); - c[3] = _color.alpha(); - c[4] = 0.0; - break; - case SP_COLOR_SCALES_MODE_CMYK: - sp_color_get_cmyk_floatv( &color, c ); - c[4] = _color.alpha(); - break; - default: - g_warning ("file %s: line %d: Illegal color selector mode %d", __FILE__, __LINE__, _mode); - break; + case SP_COLOR_SCALES_MODE_RGB: + sp_color_get_rgb_floatv(&color, c); + c[3] = _color.alpha(); + c[4] = 0.0; + break; + case SP_COLOR_SCALES_MODE_HSV: + sp_color_get_rgb_floatv(&color, tmp); + sp_color_rgb_to_hsl_floatv(c, tmp[0], tmp[1], tmp[2]); + c[3] = _color.alpha(); + c[4] = 0.0; + break; + case SP_COLOR_SCALES_MODE_CMYK: + sp_color_get_cmyk_floatv(&color, c); + c[4] = _color.alpha(); + break; + default: + g_warning("file %s: line %d: Illegal color selector mode %d", __FILE__, __LINE__, _mode); + break; } _updating = TRUE; - setScaled( _a[0], c[0] ); - setScaled( _a[1], c[1] ); - setScaled( _a[2], c[2] ); - setScaled( _a[3], c[3] ); - setScaled( _a[4], c[4] ); - _updateSliders( CSC_CHANNELS_ALL ); + setScaled(_a[0], c[0]); + setScaled(_a[1], c[1]); + setScaled(_a[2], c[2]); + setScaled(_a[3], c[3]); + setScaled(_a[4], c[4]); + _updateSliders(CSC_CHANNELS_ALL); _updating = FALSE; } -void ColorScales::_getRgbaFloatv( gfloat *rgba ) +void ColorScales::_getRgbaFloatv(gfloat *rgba) { - g_return_if_fail (rgba != NULL); - - switch (_mode) { - case SP_COLOR_SCALES_MODE_RGB: - rgba[0] = getScaled(_a[0]); - rgba[1] = getScaled(_a[1]); - rgba[2] = getScaled(_a[2]); - rgba[3] = getScaled(_a[3]); - break; - case SP_COLOR_SCALES_MODE_HSV: - sp_color_hsl_to_rgb_floatv (rgba, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2])); - rgba[3] = getScaled(_a[3]); - break; - case SP_COLOR_SCALES_MODE_CMYK: - sp_color_cmyk_to_rgb_floatv (rgba, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3])); - rgba[3] = getScaled(_a[4]); - break; - default: - g_warning ("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__); - break; - } + g_return_if_fail(rgba != NULL); + + switch (_mode) { + case SP_COLOR_SCALES_MODE_RGB: + rgba[0] = getScaled(_a[0]); + rgba[1] = getScaled(_a[1]); + rgba[2] = getScaled(_a[2]); + rgba[3] = getScaled(_a[3]); + break; + case SP_COLOR_SCALES_MODE_HSV: + sp_color_hsl_to_rgb_floatv(rgba, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2])); + rgba[3] = getScaled(_a[3]); + break; + case SP_COLOR_SCALES_MODE_CMYK: + sp_color_cmyk_to_rgb_floatv(rgba, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3])); + rgba[3] = getScaled(_a[4]); + break; + default: + g_warning("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__); + break; + } } -void ColorScales::_getCmykaFloatv( gfloat *cmyka ) +void ColorScales::_getCmykaFloatv(gfloat *cmyka) { - gfloat rgb[3]; - - g_return_if_fail (cmyka != NULL); - - switch (_mode) { - case SP_COLOR_SCALES_MODE_RGB: - sp_color_rgb_to_cmyk_floatv (cmyka, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2])); - cmyka[4] = getScaled(_a[3]); - break; - case SP_COLOR_SCALES_MODE_HSV: - sp_color_hsl_to_rgb_floatv (rgb, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2])); - sp_color_rgb_to_cmyk_floatv (cmyka, rgb[0], rgb[1], rgb[2]); - cmyka[4] = getScaled(_a[3]); - break; - case SP_COLOR_SCALES_MODE_CMYK: - cmyka[0] = getScaled(_a[0]); - cmyka[1] = getScaled(_a[1]); - cmyka[2] = getScaled(_a[2]); - cmyka[3] = getScaled(_a[3]); - cmyka[4] = getScaled(_a[4]); - break; - default: - g_warning ("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__); - break; - } + gfloat rgb[3]; + + g_return_if_fail(cmyka != NULL); + + switch (_mode) { + case SP_COLOR_SCALES_MODE_RGB: + sp_color_rgb_to_cmyk_floatv(cmyka, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2])); + cmyka[4] = getScaled(_a[3]); + break; + case SP_COLOR_SCALES_MODE_HSV: + sp_color_hsl_to_rgb_floatv(rgb, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2])); + sp_color_rgb_to_cmyk_floatv(cmyka, rgb[0], rgb[1], rgb[2]); + cmyka[4] = getScaled(_a[3]); + break; + case SP_COLOR_SCALES_MODE_CMYK: + cmyka[0] = getScaled(_a[0]); + cmyka[1] = getScaled(_a[1]); + cmyka[2] = getScaled(_a[2]); + cmyka[3] = getScaled(_a[3]); + cmyka[4] = getScaled(_a[4]); + break; + default: + g_warning("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__); + break; + } } guint32 ColorScales::_getRgba32() { - gfloat c[4]; - guint32 rgba; + gfloat c[4]; + guint32 rgba; - _getRgbaFloatv(c); + _getRgbaFloatv(c); - rgba = SP_RGBA32_F_COMPOSE (c[0], c[1], c[2], c[3]); + rgba = SP_RGBA32_F_COMPOSE(c[0], c[1], c[2], c[3]); - return rgba; + return rgba; } void ColorScales::setMode(SPColorScalesMode mode) { - gfloat rgba[4]; - gfloat c[4]; - - if (_mode == mode) return; - - if ((_mode == SP_COLOR_SCALES_MODE_RGB) || - (_mode == SP_COLOR_SCALES_MODE_HSV) || - (_mode == SP_COLOR_SCALES_MODE_CMYK)) { - _getRgbaFloatv(rgba); - } else { - rgba[0] = rgba[1] = rgba[2] = rgba[3] = 1.0; - } - - _mode = mode; - - switch (mode) { - case SP_COLOR_SCALES_MODE_RGB: - _setRangeLimit(255.0); - gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[0]), _("_R:")); - _s[0]->set_tooltip_text(_("Red")); - gtk_widget_set_tooltip_text (_b[0], _("Red")); - gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[1]), _("_G:")); - _s[1]->set_tooltip_text(_("Green")); - gtk_widget_set_tooltip_text (_b[1], _("Green")); - gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[2]), _("_B:")); - _s[2]->set_tooltip_text(_("Blue")); - gtk_widget_set_tooltip_text (_b[2], _("Blue")); - gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[3]), _("_A:")); - _s[3]->set_tooltip_text(_("Alpha (opacity)")); - gtk_widget_set_tooltip_text (_b[3], _("Alpha (opacity)")); - _s[0]->setMap(NULL); - gtk_widget_hide (_l[4]); - _s[4]->hide(); - gtk_widget_hide (_b[4]); - _updating = TRUE; - setScaled( _a[0], rgba[0] ); - setScaled( _a[1], rgba[1] ); - setScaled( _a[2], rgba[2] ); - setScaled( _a[3], rgba[3] ); - _updating = FALSE; - _updateSliders( CSC_CHANNELS_ALL ); - break; - case SP_COLOR_SCALES_MODE_HSV: - _setRangeLimit(255.0); - gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[0]), _("_H:")); - _s[0]->set_tooltip_text(_("Hue")); - gtk_widget_set_tooltip_text (_b[0], _("Hue")); - gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[1]), _("_S:")); - _s[1]->set_tooltip_text(_("Saturation")); - gtk_widget_set_tooltip_text (_b[1], _("Saturation")); - gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[2]), _("_L:")); - _s[2]->set_tooltip_text(_("Lightness")); - gtk_widget_set_tooltip_text (_b[2], _("Lightness")); - gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[3]), _("_A:")); - _s[3]->set_tooltip_text(_("Alpha (opacity)")); - gtk_widget_set_tooltip_text (_b[3], _("Alpha (opacity)")); - _s[0]->setMap((guchar *)(sp_color_scales_hue_map())); - gtk_widget_hide (_l[4]); - _s[4]->hide(); - gtk_widget_hide (_b[4]); - _updating = TRUE; - c[0] = 0.0; - sp_color_rgb_to_hsl_floatv (c, rgba[0], rgba[1], rgba[2]); - setScaled( _a[0], c[0] ); - setScaled( _a[1], c[1] ); - setScaled( _a[2], c[2] ); - setScaled( _a[3], rgba[3] ); - _updating = FALSE; - _updateSliders( CSC_CHANNELS_ALL ); - break; - case SP_COLOR_SCALES_MODE_CMYK: - _setRangeLimit(100.0); - gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[0]), _("_C:")); - _s[0]->set_tooltip_text(_("Cyan")); - gtk_widget_set_tooltip_text (_b[0], _("Cyan")); - gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[1]), _("_M:")); - _s[1]->set_tooltip_text(_("Magenta")); - gtk_widget_set_tooltip_text (_b[1], _("Magenta")); - gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[2]), _("_Y:")); - _s[2]->set_tooltip_text(_("Yellow")); - gtk_widget_set_tooltip_text (_b[2], _("Yellow")); - gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[3]), _("_K:")); - _s[3]->set_tooltip_text(_("Black")); - gtk_widget_set_tooltip_text (_b[3], _("Black")); - gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[4]), _("_A:")); - _s[4]->set_tooltip_text(_("Alpha (opacity)")); - gtk_widget_set_tooltip_text (_b[4], _("Alpha (opacity)")); - _s[0]->setMap(NULL); - gtk_widget_show (_l[4]); - _s[4]->show(); - gtk_widget_show (_b[4]); - _updating = TRUE; - - sp_color_rgb_to_cmyk_floatv (c, rgba[0], rgba[1], rgba[2]); - setScaled( _a[0], c[0] ); - setScaled( _a[1], c[1] ); - setScaled( _a[2], c[2] ); - setScaled( _a[3], c[3] ); - - setScaled( _a[4], rgba[3] ); - _updating = FALSE; - _updateSliders( CSC_CHANNELS_ALL ); - break; - default: - g_warning ("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__); - break; - } -} + gfloat rgba[4]; + gfloat c[4]; -SPColorScalesMode ColorScales::getMode() const -{ - return _mode; + if (_mode == mode) + return; + + if ((_mode == SP_COLOR_SCALES_MODE_RGB) || (_mode == SP_COLOR_SCALES_MODE_HSV) || + (_mode == SP_COLOR_SCALES_MODE_CMYK)) { + _getRgbaFloatv(rgba); + } + else { + rgba[0] = rgba[1] = rgba[2] = rgba[3] = 1.0; + } + + _mode = mode; + + switch (mode) { + case SP_COLOR_SCALES_MODE_RGB: + _setRangeLimit(255.0); + gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[0]), _("_R:")); + _s[0]->set_tooltip_text(_("Red")); + gtk_widget_set_tooltip_text(_b[0], _("Red")); + gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[1]), _("_G:")); + _s[1]->set_tooltip_text(_("Green")); + gtk_widget_set_tooltip_text(_b[1], _("Green")); + gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[2]), _("_B:")); + _s[2]->set_tooltip_text(_("Blue")); + gtk_widget_set_tooltip_text(_b[2], _("Blue")); + gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[3]), _("_A:")); + _s[3]->set_tooltip_text(_("Alpha (opacity)")); + gtk_widget_set_tooltip_text(_b[3], _("Alpha (opacity)")); + _s[0]->setMap(NULL); + gtk_widget_hide(_l[4]); + _s[4]->hide(); + gtk_widget_hide(_b[4]); + _updating = TRUE; + setScaled(_a[0], rgba[0]); + setScaled(_a[1], rgba[1]); + setScaled(_a[2], rgba[2]); + setScaled(_a[3], rgba[3]); + _updating = FALSE; + _updateSliders(CSC_CHANNELS_ALL); + break; + case SP_COLOR_SCALES_MODE_HSV: + _setRangeLimit(255.0); + gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[0]), _("_H:")); + _s[0]->set_tooltip_text(_("Hue")); + gtk_widget_set_tooltip_text(_b[0], _("Hue")); + gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[1]), _("_S:")); + _s[1]->set_tooltip_text(_("Saturation")); + gtk_widget_set_tooltip_text(_b[1], _("Saturation")); + gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[2]), _("_L:")); + _s[2]->set_tooltip_text(_("Lightness")); + gtk_widget_set_tooltip_text(_b[2], _("Lightness")); + gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[3]), _("_A:")); + _s[3]->set_tooltip_text(_("Alpha (opacity)")); + gtk_widget_set_tooltip_text(_b[3], _("Alpha (opacity)")); + _s[0]->setMap((guchar *)(sp_color_scales_hue_map())); + gtk_widget_hide(_l[4]); + _s[4]->hide(); + gtk_widget_hide(_b[4]); + _updating = TRUE; + c[0] = 0.0; + sp_color_rgb_to_hsl_floatv(c, rgba[0], rgba[1], rgba[2]); + setScaled(_a[0], c[0]); + setScaled(_a[1], c[1]); + setScaled(_a[2], c[2]); + setScaled(_a[3], rgba[3]); + _updating = FALSE; + _updateSliders(CSC_CHANNELS_ALL); + break; + case SP_COLOR_SCALES_MODE_CMYK: + _setRangeLimit(100.0); + gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[0]), _("_C:")); + _s[0]->set_tooltip_text(_("Cyan")); + gtk_widget_set_tooltip_text(_b[0], _("Cyan")); + gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[1]), _("_M:")); + _s[1]->set_tooltip_text(_("Magenta")); + gtk_widget_set_tooltip_text(_b[1], _("Magenta")); + gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[2]), _("_Y:")); + _s[2]->set_tooltip_text(_("Yellow")); + gtk_widget_set_tooltip_text(_b[2], _("Yellow")); + gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[3]), _("_K:")); + _s[3]->set_tooltip_text(_("Black")); + gtk_widget_set_tooltip_text(_b[3], _("Black")); + gtk_label_set_markup_with_mnemonic(GTK_LABEL(_l[4]), _("_A:")); + _s[4]->set_tooltip_text(_("Alpha (opacity)")); + gtk_widget_set_tooltip_text(_b[4], _("Alpha (opacity)")); + _s[0]->setMap(NULL); + gtk_widget_show(_l[4]); + _s[4]->show(); + gtk_widget_show(_b[4]); + _updating = TRUE; + + sp_color_rgb_to_cmyk_floatv(c, rgba[0], rgba[1], rgba[2]); + setScaled(_a[0], c[0]); + setScaled(_a[1], c[1]); + setScaled(_a[2], c[2]); + setScaled(_a[3], c[3]); + + setScaled(_a[4], rgba[3]); + _updating = FALSE; + _updateSliders(CSC_CHANNELS_ALL); + break; + default: + g_warning("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__); + break; + } } -void ColorScales::_adjustmentAnyChanged( GtkAdjustment *adjustment, ColorScales *cs ) +SPColorScalesMode ColorScales::getMode() const { return _mode; } + +void ColorScales::_adjustmentAnyChanged(GtkAdjustment *adjustment, ColorScales *cs) { - gint channel = GPOINTER_TO_INT (g_object_get_data(G_OBJECT (adjustment), "channel")); + gint channel = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(adjustment), "channel")); - _adjustmentChanged(cs, channel); + _adjustmentChanged(cs, channel); } void ColorScales::_sliderAnyGrabbed() @@ -469,10 +460,10 @@ void ColorScales::_sliderAnyGrabbed() if (_updating) { return; } - if (!_dragging) { - _dragging = TRUE; + if (!_dragging) { + _dragging = TRUE; _color.setHeld(true); - } + } } void ColorScales::_sliderAnyReleased() @@ -480,10 +471,10 @@ void ColorScales::_sliderAnyReleased() if (_updating) { return; } - if (_dragging) { - _dragging = FALSE; + if (_dragging) { + _dragging = FALSE; _color.setHeld(false); - } + } } void ColorScales::_sliderAnyChanged() @@ -494,160 +485,159 @@ void ColorScales::_sliderAnyChanged() _recalcColor(); } -void ColorScales::_adjustmentChanged( ColorScales *scales, guint channel ) +void ColorScales::_adjustmentChanged(ColorScales *scales, guint channel) { - if (scales->_updating) { - return; - } + if (scales->_updating) { + return; + } - scales->_updateSliders( (1 << channel) ); - scales->_recalcColor(); + scales->_updateSliders((1 << channel)); + scales->_recalcColor(); } -void ColorScales::_updateSliders( guint channels ) +void ColorScales::_updateSliders(guint channels) { - gfloat rgb0[3], rgbm[3], rgb1[3]; + gfloat rgb0[3], rgbm[3], rgb1[3]; #ifdef SPCS_PREVIEW - guint32 rgba; + guint32 rgba; #endif - switch (_mode) { - case SP_COLOR_SCALES_MODE_RGB: - if ((channels != CSC_CHANNEL_R) && (channels != CSC_CHANNEL_A)) { - /* Update red */ - _s[0]->setColors(SP_RGBA32_F_COMPOSE (0.0, getScaled(_a[1]), getScaled(_a[2]), 1.0), - SP_RGBA32_F_COMPOSE (0.5, getScaled(_a[1]), getScaled(_a[2]), 1.0), - SP_RGBA32_F_COMPOSE (1.0, getScaled(_a[1]), getScaled(_a[2]), 1.0)); - } - if ((channels != CSC_CHANNEL_G) && (channels != CSC_CHANNEL_A)) { - /* Update green */ - _s[1]->setColors(SP_RGBA32_F_COMPOSE(getScaled(_a[0]), 0.0, getScaled(_a[2]), 1.0), - SP_RGBA32_F_COMPOSE(getScaled(_a[0]), 0.5, getScaled(_a[2]), 1.0), - SP_RGBA32_F_COMPOSE(getScaled(_a[0]), 1.0, getScaled(_a[2]), 1.0)); - } - if ((channels != CSC_CHANNEL_B) && (channels != CSC_CHANNEL_A)) { - /* Update blue */ - _s[2]->setColors(SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), 0.0, 1.0), - SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), 0.5, 1.0), - SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), 1.0, 1.0)); - } - if (channels != CSC_CHANNEL_A) { - /* Update alpha */ - _s[3]->setColors(SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 0.0), - SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 0.5), - SP_RGBA32_F_COMPOSE (getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 1.0)); - } - break; - case SP_COLOR_SCALES_MODE_HSV: - /* Hue is never updated */ - if ((channels != CSC_CHANNEL_S) && (channels != CSC_CHANNEL_A)) { - /* Update saturation */ - sp_color_hsl_to_rgb_floatv (rgb0, getScaled(_a[0]), 0.0, getScaled(_a[2])); - sp_color_hsl_to_rgb_floatv (rgbm, getScaled(_a[0]), 0.5, getScaled(_a[2])); - sp_color_hsl_to_rgb_floatv (rgb1, getScaled(_a[0]), 1.0, getScaled(_a[2])); - _s[1]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0), - SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0), - SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0)); - } - if ((channels != CSC_CHANNEL_V) && (channels != CSC_CHANNEL_A)) { - /* Update value */ - sp_color_hsl_to_rgb_floatv (rgb0, getScaled(_a[0]), getScaled(_a[1]), 0.0); - sp_color_hsl_to_rgb_floatv (rgbm, getScaled(_a[0]), getScaled(_a[1]), 0.5); - sp_color_hsl_to_rgb_floatv (rgb1, getScaled(_a[0]), getScaled(_a[1]), 1.0); - _s[2]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0), - SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0), - SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0)); - } - if (channels != CSC_CHANNEL_A) { - /* Update alpha */ - sp_color_hsl_to_rgb_floatv (rgb0, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2])); - _s[3]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 0.0), - SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 0.5), - SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0)); - } - break; - case SP_COLOR_SCALES_MODE_CMYK: - if ((channels != CSC_CHANNEL_C) && (channels != CSC_CHANNEL_CMYKA)) { - /* Update C */ - sp_color_cmyk_to_rgb_floatv (rgb0, 0.0, getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3])); - sp_color_cmyk_to_rgb_floatv (rgbm, 0.5, getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3])); - sp_color_cmyk_to_rgb_floatv (rgb1, 1.0, getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3])); - _s[0]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0), - SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0), - SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0)); - } - if ((channels != CSC_CHANNEL_M) && (channels != CSC_CHANNEL_CMYKA)) { - /* Update M */ - sp_color_cmyk_to_rgb_floatv (rgb0, getScaled(_a[0]), 0.0, getScaled(_a[2]), getScaled(_a[3])); - sp_color_cmyk_to_rgb_floatv (rgbm, getScaled(_a[0]), 0.5, getScaled(_a[2]), getScaled(_a[3])); - sp_color_cmyk_to_rgb_floatv (rgb1, getScaled(_a[0]), 1.0, getScaled(_a[2]), getScaled(_a[3])); - _s[1]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0), - SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0), - SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0)); - } - if ((channels != CSC_CHANNEL_Y) && (channels != CSC_CHANNEL_CMYKA)) { - /* Update Y */ - sp_color_cmyk_to_rgb_floatv (rgb0, getScaled(_a[0]), getScaled(_a[1]), 0.0, getScaled(_a[3])); - sp_color_cmyk_to_rgb_floatv (rgbm, getScaled(_a[0]), getScaled(_a[1]), 0.5, getScaled(_a[3])); - sp_color_cmyk_to_rgb_floatv (rgb1, getScaled(_a[0]), getScaled(_a[1]), 1.0, getScaled(_a[3])); - _s[2]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0), - SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0), - SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0)); - } - if ((channels != CSC_CHANNEL_K) && (channels != CSC_CHANNEL_CMYKA)) { - /* Update K */ - sp_color_cmyk_to_rgb_floatv (rgb0, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 0.0); - sp_color_cmyk_to_rgb_floatv (rgbm, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 0.5); - sp_color_cmyk_to_rgb_floatv (rgb1, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 1.0); - _s[3]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0), - SP_RGBA32_F_COMPOSE (rgbm[0], rgbm[1], rgbm[2], 1.0), - SP_RGBA32_F_COMPOSE (rgb1[0], rgb1[1], rgb1[2], 1.0)); - } - if (channels != CSC_CHANNEL_CMYKA) { - /* Update alpha */ - sp_color_cmyk_to_rgb_floatv (rgb0, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3])); - _s[4]->setColors(SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 0.0), - SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 0.5), - SP_RGBA32_F_COMPOSE (rgb0[0], rgb0[1], rgb0[2], 1.0)); - } - break; - default: - g_warning ("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__); - break; - } - - // Force the internal color to be updated - if ( !_updating ) - { + switch (_mode) { + case SP_COLOR_SCALES_MODE_RGB: + if ((channels != CSC_CHANNEL_R) && (channels != CSC_CHANNEL_A)) { + /* Update red */ + _s[0]->setColors(SP_RGBA32_F_COMPOSE(0.0, getScaled(_a[1]), getScaled(_a[2]), 1.0), + SP_RGBA32_F_COMPOSE(0.5, getScaled(_a[1]), getScaled(_a[2]), 1.0), + SP_RGBA32_F_COMPOSE(1.0, getScaled(_a[1]), getScaled(_a[2]), 1.0)); + } + if ((channels != CSC_CHANNEL_G) && (channels != CSC_CHANNEL_A)) { + /* Update green */ + _s[1]->setColors(SP_RGBA32_F_COMPOSE(getScaled(_a[0]), 0.0, getScaled(_a[2]), 1.0), + SP_RGBA32_F_COMPOSE(getScaled(_a[0]), 0.5, getScaled(_a[2]), 1.0), + SP_RGBA32_F_COMPOSE(getScaled(_a[0]), 1.0, getScaled(_a[2]), 1.0)); + } + if ((channels != CSC_CHANNEL_B) && (channels != CSC_CHANNEL_A)) { + /* Update blue */ + _s[2]->setColors(SP_RGBA32_F_COMPOSE(getScaled(_a[0]), getScaled(_a[1]), 0.0, 1.0), + SP_RGBA32_F_COMPOSE(getScaled(_a[0]), getScaled(_a[1]), 0.5, 1.0), + SP_RGBA32_F_COMPOSE(getScaled(_a[0]), getScaled(_a[1]), 1.0, 1.0)); + } + if (channels != CSC_CHANNEL_A) { + /* Update alpha */ + _s[3]->setColors(SP_RGBA32_F_COMPOSE(getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 0.0), + SP_RGBA32_F_COMPOSE(getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 0.5), + SP_RGBA32_F_COMPOSE(getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 1.0)); + } + break; + case SP_COLOR_SCALES_MODE_HSV: + /* Hue is never updated */ + if ((channels != CSC_CHANNEL_S) && (channels != CSC_CHANNEL_A)) { + /* Update saturation */ + sp_color_hsl_to_rgb_floatv(rgb0, getScaled(_a[0]), 0.0, getScaled(_a[2])); + sp_color_hsl_to_rgb_floatv(rgbm, getScaled(_a[0]), 0.5, getScaled(_a[2])); + sp_color_hsl_to_rgb_floatv(rgb1, getScaled(_a[0]), 1.0, getScaled(_a[2])); + _s[1]->setColors(SP_RGBA32_F_COMPOSE(rgb0[0], rgb0[1], rgb0[2], 1.0), + SP_RGBA32_F_COMPOSE(rgbm[0], rgbm[1], rgbm[2], 1.0), + SP_RGBA32_F_COMPOSE(rgb1[0], rgb1[1], rgb1[2], 1.0)); + } + if ((channels != CSC_CHANNEL_V) && (channels != CSC_CHANNEL_A)) { + /* Update value */ + sp_color_hsl_to_rgb_floatv(rgb0, getScaled(_a[0]), getScaled(_a[1]), 0.0); + sp_color_hsl_to_rgb_floatv(rgbm, getScaled(_a[0]), getScaled(_a[1]), 0.5); + sp_color_hsl_to_rgb_floatv(rgb1, getScaled(_a[0]), getScaled(_a[1]), 1.0); + _s[2]->setColors(SP_RGBA32_F_COMPOSE(rgb0[0], rgb0[1], rgb0[2], 1.0), + SP_RGBA32_F_COMPOSE(rgbm[0], rgbm[1], rgbm[2], 1.0), + SP_RGBA32_F_COMPOSE(rgb1[0], rgb1[1], rgb1[2], 1.0)); + } + if (channels != CSC_CHANNEL_A) { + /* Update alpha */ + sp_color_hsl_to_rgb_floatv(rgb0, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2])); + _s[3]->setColors(SP_RGBA32_F_COMPOSE(rgb0[0], rgb0[1], rgb0[2], 0.0), + SP_RGBA32_F_COMPOSE(rgb0[0], rgb0[1], rgb0[2], 0.5), + SP_RGBA32_F_COMPOSE(rgb0[0], rgb0[1], rgb0[2], 1.0)); + } + break; + case SP_COLOR_SCALES_MODE_CMYK: + if ((channels != CSC_CHANNEL_C) && (channels != CSC_CHANNEL_CMYKA)) { + /* Update C */ + sp_color_cmyk_to_rgb_floatv(rgb0, 0.0, getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3])); + sp_color_cmyk_to_rgb_floatv(rgbm, 0.5, getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3])); + sp_color_cmyk_to_rgb_floatv(rgb1, 1.0, getScaled(_a[1]), getScaled(_a[2]), getScaled(_a[3])); + _s[0]->setColors(SP_RGBA32_F_COMPOSE(rgb0[0], rgb0[1], rgb0[2], 1.0), + SP_RGBA32_F_COMPOSE(rgbm[0], rgbm[1], rgbm[2], 1.0), + SP_RGBA32_F_COMPOSE(rgb1[0], rgb1[1], rgb1[2], 1.0)); + } + if ((channels != CSC_CHANNEL_M) && (channels != CSC_CHANNEL_CMYKA)) { + /* Update M */ + sp_color_cmyk_to_rgb_floatv(rgb0, getScaled(_a[0]), 0.0, getScaled(_a[2]), getScaled(_a[3])); + sp_color_cmyk_to_rgb_floatv(rgbm, getScaled(_a[0]), 0.5, getScaled(_a[2]), getScaled(_a[3])); + sp_color_cmyk_to_rgb_floatv(rgb1, getScaled(_a[0]), 1.0, getScaled(_a[2]), getScaled(_a[3])); + _s[1]->setColors(SP_RGBA32_F_COMPOSE(rgb0[0], rgb0[1], rgb0[2], 1.0), + SP_RGBA32_F_COMPOSE(rgbm[0], rgbm[1], rgbm[2], 1.0), + SP_RGBA32_F_COMPOSE(rgb1[0], rgb1[1], rgb1[2], 1.0)); + } + if ((channels != CSC_CHANNEL_Y) && (channels != CSC_CHANNEL_CMYKA)) { + /* Update Y */ + sp_color_cmyk_to_rgb_floatv(rgb0, getScaled(_a[0]), getScaled(_a[1]), 0.0, getScaled(_a[3])); + sp_color_cmyk_to_rgb_floatv(rgbm, getScaled(_a[0]), getScaled(_a[1]), 0.5, getScaled(_a[3])); + sp_color_cmyk_to_rgb_floatv(rgb1, getScaled(_a[0]), getScaled(_a[1]), 1.0, getScaled(_a[3])); + _s[2]->setColors(SP_RGBA32_F_COMPOSE(rgb0[0], rgb0[1], rgb0[2], 1.0), + SP_RGBA32_F_COMPOSE(rgbm[0], rgbm[1], rgbm[2], 1.0), + SP_RGBA32_F_COMPOSE(rgb1[0], rgb1[1], rgb1[2], 1.0)); + } + if ((channels != CSC_CHANNEL_K) && (channels != CSC_CHANNEL_CMYKA)) { + /* Update K */ + sp_color_cmyk_to_rgb_floatv(rgb0, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 0.0); + sp_color_cmyk_to_rgb_floatv(rgbm, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 0.5); + sp_color_cmyk_to_rgb_floatv(rgb1, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), 1.0); + _s[3]->setColors(SP_RGBA32_F_COMPOSE(rgb0[0], rgb0[1], rgb0[2], 1.0), + SP_RGBA32_F_COMPOSE(rgbm[0], rgbm[1], rgbm[2], 1.0), + SP_RGBA32_F_COMPOSE(rgb1[0], rgb1[1], rgb1[2], 1.0)); + } + if (channels != CSC_CHANNEL_CMYKA) { + /* Update alpha */ + sp_color_cmyk_to_rgb_floatv(rgb0, getScaled(_a[0]), getScaled(_a[1]), getScaled(_a[2]), + getScaled(_a[3])); + _s[4]->setColors(SP_RGBA32_F_COMPOSE(rgb0[0], rgb0[1], rgb0[2], 0.0), + SP_RGBA32_F_COMPOSE(rgb0[0], rgb0[1], rgb0[2], 0.5), + SP_RGBA32_F_COMPOSE(rgb0[0], rgb0[1], rgb0[2], 1.0)); + } + break; + default: + g_warning("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__); + break; + } + + // Force the internal color to be updated + if (!_updating) { _recalcColor(); } #ifdef SPCS_PREVIEW - rgba = sp_color_scales_get_rgba32 (cs); - sp_color_preview_set_rgba32 (SP_COLOR_PREVIEW (_p), rgba); + rgba = sp_color_scales_get_rgba32(cs); + sp_color_preview_set_rgba32(SP_COLOR_PREVIEW(_p), rgba); #endif } -static const gchar * -sp_color_scales_hue_map (void) +static const gchar *sp_color_scales_hue_map(void) { - static gchar *map = NULL; - - if (!map) { - gchar *p; - gint h; - map = g_new (gchar, 4 * 1024); - p = map; - for (h = 0; h < 1024; h++) { - gfloat rgb[3]; - sp_color_hsl_to_rgb_floatv (rgb, h / 1024.0, 1.0, 0.5); - *p++ = SP_COLOR_F_TO_U (rgb[0]); - *p++ = SP_COLOR_F_TO_U (rgb[1]); - *p++ = SP_COLOR_F_TO_U (rgb[2]); - *p++ = 255; - } - } - - return map; + static gchar *map = NULL; + + if (!map) { + gchar *p; + gint h; + map = g_new(gchar, 4 * 1024); + p = map; + for (h = 0; h < 1024; h++) { + gfloat rgb[3]; + sp_color_hsl_to_rgb_floatv(rgb, h / 1024.0, 1.0, 0.5); + *p++ = SP_COLOR_F_TO_U(rgb[0]); + *p++ = SP_COLOR_F_TO_U(rgb[1]); + *p++ = SP_COLOR_F_TO_U(rgb[2]); + *p++ = 255; + } + } + + return map; } ColorScalesFactory::ColorScalesFactory(SPColorScalesMode submode) @@ -655,10 +645,10 @@ ColorScalesFactory::ColorScalesFactory(SPColorScalesMode submode) { } -ColorScalesFactory::~ColorScalesFactory() { -} +ColorScalesFactory::~ColorScalesFactory() {} -Gtk::Widget *ColorScalesFactory::createWidget(Inkscape::UI::SelectedColor &color) const { +Gtk::Widget *ColorScalesFactory::createWidget(Inkscape::UI::SelectedColor &color) const +{ Gtk::Widget *w = Gtk::manage(new ColorScales(color, _submode)); return w; } diff --git a/src/ui/widget/color-scales.h b/src/ui/widget/color-scales.h index 0744a645c..025f92e2d 100644 --- a/src/ui/widget/color-scales.h +++ b/src/ui/widget/color-scales.h @@ -2,7 +2,7 @@ #define SEEN_SP_COLOR_SCALES_H #ifdef HAVE_CONFIG_H -# include +#include #endif #if WITH_GTKMM_3_0 @@ -19,7 +19,6 @@ namespace Widget { class ColorSlider; - typedef enum { SP_COLOR_SCALES_MODE_NONE = 0, SP_COLOR_SCALES_MODE_RGB = 1, @@ -27,20 +26,18 @@ typedef enum { SP_COLOR_SCALES_MODE_CMYK = 3 } SPColorScalesMode; - - class ColorScales -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) : public Gtk::Grid #else : public Gtk::Table #endif { public: - static const gchar* SUBMODE_NAMES[]; + static const gchar *SUBMODE_NAMES[]; - static gfloat getScaled( const GtkAdjustment *a ); - static void setScaled( GtkAdjustment *a, gfloat v); + static gfloat getScaled(const GtkAdjustment *a); + static void setScaled(GtkAdjustment *a, gfloat v); ColorScales(SelectedColor &color, SPColorScalesMode mode); virtual ~ColorScales(); @@ -65,26 +62,26 @@ protected: void _updateSliders(guint channels); void _recalcColor(); - void _setRangeLimit( gdouble upper ); + void _setRangeLimit(gdouble upper); SelectedColor &_color; SPColorScalesMode _mode; gdouble _rangeLimit; gboolean _updating : 1; gboolean _dragging : 1; - GtkAdjustment *_a[5]; /* Channel adjustments */ + GtkAdjustment *_a[5]; /* Channel adjustments */ Inkscape::UI::Widget::ColorSlider *_s[5]; /* Channel sliders */ - GtkWidget *_b[5]; /* Spinbuttons */ - GtkWidget *_l[5]; /* Labels */ + GtkWidget *_b[5]; /* Spinbuttons */ + GtkWidget *_l[5]; /* Labels */ private: // By default, disallow copy constructor and assignment operator ColorScales(ColorScales const &obj); - ColorScales &operator=(ColorScales const &obj ); + ColorScales &operator=(ColorScales const &obj); }; - -class ColorScalesFactory: public Inkscape::UI::ColorSelectorFactory { +class ColorScalesFactory : public Inkscape::UI::ColorSelectorFactory +{ public: ColorScalesFactory(SPColorScalesMode submode); ~ColorScalesFactory(); diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index bf8b85dbd..0c9586a67 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -12,7 +12,7 @@ */ #ifdef HAVE_CONFIG_H -# include "config.h" +#include "config.h" #endif #include @@ -34,20 +34,20 @@ static const gint SLIDER_WIDTH = 96; static const gint SLIDER_HEIGHT = 8; static const gint ARROW_SIZE = 7; -static const guchar *sp_color_slider_render_gradient (gint x0, gint y0, gint width, gint height, - gint c[], gint dc[], guint b0, guint b1, guint mask); -static const guchar *sp_color_slider_render_map (gint x0, gint y0, gint width, gint height, - guchar *map, gint start, gint step, guint b0, guint b1, guint mask); +static const guchar *sp_color_slider_render_gradient(gint x0, gint y0, gint width, gint height, gint c[], gint dc[], + guint b0, guint b1, guint mask); +static const guchar *sp_color_slider_render_map(gint x0, gint y0, gint width, gint height, guchar *map, gint start, + gint step, guint b0, guint b1, guint mask); namespace Inkscape { namespace UI { namespace Widget { -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) ColorSlider::ColorSlider(Glib::RefPtr adjustment) : _dragging(false) #else -ColorSlider::ColorSlider(Gtk::Adjustment* adjustment) +ColorSlider::ColorSlider(Gtk::Adjustment *adjustment) : _dragging(false) , _adjustment(NULL) #endif @@ -78,11 +78,12 @@ ColorSlider::ColorSlider(Gtk::Adjustment* adjustment) setAdjustment(adjustment); } -ColorSlider::~ColorSlider() { +ColorSlider::~ColorSlider() +{ if (_adjustment) { _adjustment_changed_connection.disconnect(); _adjustment_value_changed_connection.disconnect(); -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) _adjustment.reset(); #else _adjustment->unreference(); @@ -91,103 +92,102 @@ ColorSlider::~ColorSlider() { } } -void ColorSlider::on_realize() { +void ColorSlider::on_realize() +{ set_realized(); - if(!_gdk_window) - { - GdkWindowAttr attributes; - gint attributes_mask; - Gtk::Allocation allocation = get_allocation(); - - memset(&attributes, 0, sizeof(attributes)); - attributes.x = allocation.get_x(); - attributes.y = allocation.get_y(); - attributes.width = allocation.get_width(); - attributes.height = allocation.get_height(); - attributes.window_type = GDK_WINDOW_CHILD; - attributes.wclass = GDK_INPUT_OUTPUT; - attributes.visual = gdk_screen_get_system_visual(gdk_screen_get_default()); -#if !GTK_CHECK_VERSION(3,0,0) - attributes.colormap = gdk_screen_get_system_colormap(gdk_screen_get_default()); + if (!_gdk_window) { + GdkWindowAttr attributes; + gint attributes_mask; + Gtk::Allocation allocation = get_allocation(); + + memset(&attributes, 0, sizeof(attributes)); + attributes.x = allocation.get_x(); + attributes.y = allocation.get_y(); + attributes.width = allocation.get_width(); + attributes.height = allocation.get_height(); + attributes.window_type = GDK_WINDOW_CHILD; + attributes.wclass = GDK_INPUT_OUTPUT; + attributes.visual = gdk_screen_get_system_visual(gdk_screen_get_default()); +#if !GTK_CHECK_VERSION(3, 0, 0) + attributes.colormap = gdk_screen_get_system_colormap(gdk_screen_get_default()); #endif - attributes.event_mask = get_events (); - attributes.event_mask |= (Gdk::EXPOSURE_MASK | - Gdk::BUTTON_PRESS_MASK | - Gdk::BUTTON_RELEASE_MASK | - Gdk::POINTER_MOTION_MASK | - Gdk::ENTER_NOTIFY_MASK | - Gdk::LEAVE_NOTIFY_MASK); - -#if GTK_CHECK_VERSION(3,0,0) - attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL; + attributes.event_mask = get_events(); + attributes.event_mask |= (Gdk::EXPOSURE_MASK | Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK | + Gdk::POINTER_MOTION_MASK | Gdk::ENTER_NOTIFY_MASK | Gdk::LEAVE_NOTIFY_MASK); + +#if GTK_CHECK_VERSION(3, 0, 0) + attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL; #else - attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP; + attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP; #endif - _gdk_window = Gdk::Window::create(get_parent_window(), &attributes, - attributes_mask); - set_window(_gdk_window); - _gdk_window->set_user_data(gobj()); + _gdk_window = Gdk::Window::create(get_parent_window(), &attributes, attributes_mask); + set_window(_gdk_window); + _gdk_window->set_user_data(gobj()); -#if !GTK_CHECK_VERSION(3,0,0) - style_attach(); +#if !GTK_CHECK_VERSION(3, 0, 0) + style_attach(); #endif } } -void ColorSlider::on_unrealize() { +void ColorSlider::on_unrealize() +{ _gdk_window.reset(); Gtk::Widget::on_unrealize(); } -void ColorSlider::on_size_allocate(Gtk::Allocation& allocation) { +void ColorSlider::on_size_allocate(Gtk::Allocation &allocation) +{ set_allocation(allocation); if (get_realized()) { - _gdk_window->move_resize(allocation.get_x(), allocation.get_y(), - allocation.get_width(), allocation.get_height()); + _gdk_window->move_resize(allocation.get_x(), allocation.get_y(), allocation.get_width(), + allocation.get_height()); } } -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) -void ColorSlider::get_preferred_width_vfunc(int& minimum_width, int& natural_width) const +void ColorSlider::get_preferred_width_vfunc(int &minimum_width, int &natural_width) const { - Glib::RefPtrstyle_context = get_style_context(); + Glib::RefPtr style_context = get_style_context(); Gtk::Border padding = style_context->get_padding(get_state_flags()); int width = SLIDER_WIDTH + padding.get_left() + padding.get_right(); minimum_width = natural_width = width; } -void ColorSlider::get_preferred_width_for_height_vfunc(int /*height*/, int& minimum_width, int& natural_width) const +void ColorSlider::get_preferred_width_for_height_vfunc(int /*height*/, int &minimum_width, int &natural_width) const { get_preferred_width(minimum_width, natural_width); } -void ColorSlider::get_preferred_height_vfunc(int& minimum_height, int& natural_height) const +void ColorSlider::get_preferred_height_vfunc(int &minimum_height, int &natural_height) const { - Glib::RefPtrstyle_context = get_style_context(); + Glib::RefPtr style_context = get_style_context(); Gtk::Border padding = style_context->get_padding(get_state_flags()); int height = SLIDER_HEIGHT + padding.get_top() + padding.get_bottom(); minimum_height = natural_height = height; } -void ColorSlider::get_preferred_height_for_width_vfunc(int /*width*/, int& minimum_height, int& natural_height) const +void ColorSlider::get_preferred_height_for_width_vfunc(int /*width*/, int &minimum_height, int &natural_height) const { get_preferred_height(minimum_height, natural_height); } #else -void ColorSlider::on_size_request(Gtk::Requisition* requisition) { +void ColorSlider::on_size_request(Gtk::Requisition *requisition) +{ GtkStyle *style = gtk_widget_get_style(gobj()); requisition->width = SLIDER_WIDTH + style->xthickness * 2; requisition->height = SLIDER_HEIGHT + style->ythickness * 2; } -bool ColorSlider::on_expose_event(GdkEventExpose* event) { +bool ColorSlider::on_expose_event(GdkEventExpose *event) +{ bool result = false; if (get_is_drawable()) { @@ -199,11 +199,12 @@ bool ColorSlider::on_expose_event(GdkEventExpose* event) { #endif -bool ColorSlider::on_button_press_event(GdkEventButton *event) { +bool ColorSlider::on_button_press_event(GdkEventButton *event) +{ if (event->button == 1) { Gtk::Allocation allocation = get_allocation(); gint cx, cw; -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) cx = get_style_context()->get_padding(get_state_flags()).get_left(); #else cx = get_style()->get_xthickness(); @@ -212,33 +213,30 @@ bool ColorSlider::on_button_press_event(GdkEventButton *event) { signal_grabbed.emit(); _dragging = true; _oldvalue = _value; - ColorScales::setScaled( _adjustment->gobj(), CLAMP ((gfloat) (event->x - cx) / cw, 0.0, 1.0) ); + ColorScales::setScaled(_adjustment->gobj(), CLAMP((gfloat)(event->x - cx) / cw, 0.0, 1.0)); signal_dragged.emit(); -#if GTK_CHECK_VERSION(3,0,0) - gdk_device_grab(gdk_event_get_device(reinterpret_cast(event)), - _gdk_window->gobj(), - GDK_OWNERSHIP_NONE, - FALSE, - static_cast(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK), - NULL, - event->time); +#if GTK_CHECK_VERSION(3, 0, 0) + gdk_device_grab( + gdk_event_get_device(reinterpret_cast(event)), _gdk_window->gobj(), GDK_OWNERSHIP_NONE, FALSE, + static_cast(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK), NULL, event->time); #else gdk_pointer_grab(get_window()->gobj(), FALSE, - static_cast(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK), - NULL, NULL, event->time); + static_cast(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK), NULL, NULL, + event->time); #endif } return false; } -bool ColorSlider::on_button_release_event(GdkEventButton *event) { +bool ColorSlider::on_button_release_event(GdkEventButton *event) +{ if (event->button == 1) { -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) gdk_device_ungrab(gdk_event_get_device(reinterpret_cast(event)), - gdk_event_get_time(reinterpret_cast(event))); + gdk_event_get_time(reinterpret_cast(event))); #else get_window()->pointer_ungrab(event->time); #endif @@ -253,35 +251,39 @@ bool ColorSlider::on_button_release_event(GdkEventButton *event) { return false; } -bool ColorSlider::on_motion_notify_event(GdkEventMotion *event) { +bool ColorSlider::on_motion_notify_event(GdkEventMotion *event) +{ if (_dragging) { gint cx, cw; Gtk::Allocation allocation = get_allocation(); -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) cx = get_style_context()->get_padding(get_state_flags()).get_left(); #else cx = get_style()->get_xthickness(); #endif cw = allocation.get_width() - 2 * cx; - ColorScales::setScaled( _adjustment->gobj(), CLAMP ((gfloat) (event->x - cx) / cw, 0.0, 1.0) ); + ColorScales::setScaled(_adjustment->gobj(), CLAMP((gfloat)(event->x - cx) / cw, 0.0, 1.0)); signal_dragged.emit(); } return false; } -#if GTK_CHECK_VERSION(3,0,0) -void ColorSlider::setAdjustment(Glib::RefPtr adjustment) { +#if GTK_CHECK_VERSION(3, 0, 0) +void ColorSlider::setAdjustment(Glib::RefPtr adjustment) +{ #else -void ColorSlider::setAdjustment(Gtk::Adjustment *adjustment) { +void ColorSlider::setAdjustment(Gtk::Adjustment *adjustment) +{ #endif if (!adjustment) { -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) _adjustment = Gtk::Adjustment::create(0.0, 0.0, 1.0, 0.01, 0.0, 0.0); #else _adjustment = Gtk::manage(new Gtk::Adjustment(0.0, 0.0, 1.0, 0.01, 0.0, 0.0)); #endif - } else { + } + else { adjustment->set_page_increment(0.0); adjustment->set_page_size(0.0); } @@ -290,16 +292,16 @@ void ColorSlider::setAdjustment(Gtk::Adjustment *adjustment) { if (_adjustment) { _adjustment_changed_connection.disconnect(); _adjustment_value_changed_connection.disconnect(); -#if !GTK_CHECK_VERSION(3,0,0) +#if !GTK_CHECK_VERSION(3, 0, 0) _adjustment->unreference(); #endif } _adjustment = adjustment; - _adjustment_changed_connection = _adjustment->signal_changed().connect( - sigc::mem_fun(this, &ColorSlider::_onAdjustmentChanged)); - _adjustment_value_changed_connection = _adjustment->signal_value_changed().connect( - sigc::mem_fun(this, &ColorSlider::_onAdjustmentValueChanged)); + _adjustment_changed_connection = + _adjustment->signal_changed().connect(sigc::mem_fun(this, &ColorSlider::_onAdjustmentChanged)); + _adjustment_value_changed_connection = + _adjustment->signal_value_changed().connect(sigc::mem_fun(this, &ColorSlider::_onAdjustmentValueChanged)); _value = ColorScales::getScaled(_adjustment->gobj()); @@ -307,15 +309,14 @@ void ColorSlider::setAdjustment(Gtk::Adjustment *adjustment) { } } -void ColorSlider::_onAdjustmentChanged() { - queue_draw(); -} +void ColorSlider::_onAdjustmentChanged() { queue_draw(); } -void ColorSlider::_onAdjustmentValueChanged() { - if (_value != ColorScales::getScaled( _adjustment->gobj() )) { +void ColorSlider::_onAdjustmentValueChanged() +{ + if (_value != ColorScales::getScaled(_adjustment->gobj())) { gint cx, cy, cw, ch; -#if GTK_CHECK_VERSION(3,0,0) - Glib::RefPtrstyle_context = get_style_context(); +#if GTK_CHECK_VERSION(3, 0, 0) + Glib::RefPtr style_context = get_style_context(); Gtk::Allocation allocation = get_allocation(); Gtk::Border padding = style_context->get_padding(get_state_flags()); cx = padding.get_left(); @@ -328,24 +329,26 @@ void ColorSlider::_onAdjustmentValueChanged() { #endif cw = allocation.get_width() - 2 * cx; ch = allocation.get_height() - 2 * cy; - if ((gint) (ColorScales::getScaled( _adjustment->gobj() ) * cw) != (gint) (_value * cw)) { + if ((gint)(ColorScales::getScaled(_adjustment->gobj()) * cw) != (gint)(_value * cw)) { gint ax, ay; gfloat value; value = _value; - _value = ColorScales::getScaled( _adjustment->gobj() ); + _value = ColorScales::getScaled(_adjustment->gobj()); ax = (int)(cx + value * cw - ARROW_SIZE / 2 - 2); ay = cy; queue_draw_area(ax, ay, ARROW_SIZE + 4, ch); ax = (int)(cx + _value * cw - ARROW_SIZE / 2 - 2); ay = cy; queue_draw_area(ax, ay, ARROW_SIZE + 4, ch); - } else { - _value = ColorScales::getScaled( _adjustment->gobj() ); + } + else { + _value = ColorScales::getScaled(_adjustment->gobj()); } } } -void ColorSlider::setColors(guint32 start, guint32 mid, guint32 end) { +void ColorSlider::setColors(guint32 start, guint32 mid, guint32 end) +{ // Remove any map, if set _map = 0; @@ -367,13 +370,15 @@ void ColorSlider::setColors(guint32 start, guint32 mid, guint32 end) { queue_draw(); } -void ColorSlider::setMap(const guchar *map) { +void ColorSlider::setMap(const guchar *map) +{ _map = const_cast(map); queue_draw(); } -void ColorSlider::setBackground(guint dark, guint light, guint size) { +void ColorSlider::setBackground(guint dark, guint light, guint size) +{ _b0 = dark; _b1 = light; _bmask = size; @@ -381,12 +386,13 @@ void ColorSlider::setBackground(guint dark, guint light, guint size) { queue_draw(); } -bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { +bool ColorSlider::on_draw(const Cairo::RefPtr &cr) +{ gboolean colorsOnTop = Inkscape::Preferences::get()->getBool("/options/workarounds/colorsontop", false); Gtk::Allocation allocation = get_allocation(); -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) Glib::RefPtr style_context = get_style_context(); #else Glib::RefPtr window = get_window(); @@ -395,28 +401,25 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { // Draw shadow if (colorsOnTop) { -#if GTK_CHECK_VERSION(3,0,0) - style_context->render_frame(cr, 0, 0, - allocation.get_width(), allocation.get_height()); +#if GTK_CHECK_VERSION(3, 0, 0) + style_context->render_frame(cr, 0, 0, allocation.get_width(), allocation.get_height()); #else - gtk_paint_shadow( style->gobj(), window->gobj(), - gtk_widget_get_state(gobj()), GTK_SHADOW_IN, - NULL, gobj(), "colorslider", - 0, 0, - allocation.get_width(), allocation.get_height()); + gtk_paint_shadow(style->gobj(), window->gobj(), gtk_widget_get_state(gobj()), GTK_SHADOW_IN, NULL, gobj(), + "colorslider", 0, 0, allocation.get_width(), allocation.get_height()); #endif } /* Paintable part of color gradient area */ Gdk::Rectangle carea; -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) Gtk::Border padding; padding = style_context->get_padding(get_state_flags()); carea.set_x(padding.get_left()); - carea.set_y(padding.get_top());; + carea.set_y(padding.get_top()); + ; #else carea.set_x(style->get_xthickness()); carea.set_y(style->get_ythickness()); @@ -430,19 +433,18 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { gint d = (1024 << 16) / carea.get_width(); gint s = 0; - const guchar *b = sp_color_slider_render_map(0, 0, carea.get_width(), carea.get_height(), - _map, s, d, - _b0, _b1, _bmask); + const guchar *b = + sp_color_slider_render_map(0, 0, carea.get_width(), carea.get_height(), _map, s, d, _b0, _b1, _bmask); if (b != NULL && carea.get_width() > 0) { - Glib::RefPtr pb = Gdk::Pixbuf::create_from_data(b, Gdk::COLORSPACE_RGB, - false, 8, carea.get_width(), carea.get_height(), carea.get_width() * 3); + Glib::RefPtr pb = Gdk::Pixbuf::create_from_data( + b, Gdk::COLORSPACE_RGB, false, 8, carea.get_width(), carea.get_height(), carea.get_width() * 3); Gdk::Cairo::set_source_pixbuf(cr, pb, carea.get_x(), carea.get_y()); cr->paint(); } - - } else { + } + else { gint c[4], dc[4]; /* Render gradient */ @@ -451,16 +453,15 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { if (carea.get_width() > 0) { for (gint i = 0; i < 4; i++) { c[i] = _c0[i] << 16; - dc[i] = ((_cm[i] << 16) - c[i]) / (carea.get_width()/2); + dc[i] = ((_cm[i] << 16) - c[i]) / (carea.get_width() / 2); } - guint wi = carea.get_width()/2; - const guchar *b = sp_color_slider_render_gradient(0, 0, wi, carea.get_height(), - c, dc, _b0, _b1, _bmask); + guint wi = carea.get_width() / 2; + const guchar *b = sp_color_slider_render_gradient(0, 0, wi, carea.get_height(), c, dc, _b0, _b1, _bmask); /* Draw pixelstore 1 */ if (b != NULL && wi > 0) { - Glib::RefPtr pb = Gdk::Pixbuf::create_from_data(b, Gdk::COLORSPACE_RGB, - false, 8, wi, carea.get_height(), wi * 3); + Glib::RefPtr pb = + Gdk::Pixbuf::create_from_data(b, Gdk::COLORSPACE_RGB, false, 8, wi, carea.get_height(), wi * 3); Gdk::Cairo::set_source_pixbuf(cr, pb, carea.get_x(), carea.get_y()); cr->paint(); @@ -471,37 +472,32 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { if (carea.get_width() > 0) { for (gint i = 0; i < 4; i++) { c[i] = _cm[i] << 16; - dc[i] = ((_c1[i] << 16) - c[i]) / (carea.get_width()/2); + dc[i] = ((_c1[i] << 16) - c[i]) / (carea.get_width() / 2); } - guint wi = carea.get_width()/2; - const guchar *b = sp_color_slider_render_gradient(carea.get_width()/2, 0, wi, carea.get_height(), - c, dc, - _b0, _b1, _bmask); + guint wi = carea.get_width() / 2; + const guchar *b = sp_color_slider_render_gradient(carea.get_width() / 2, 0, wi, carea.get_height(), c, dc, + _b0, _b1, _bmask); /* Draw pixelstore 2 */ if (b != NULL && wi > 0) { - Glib::RefPtr pb = Gdk::Pixbuf::create_from_data(b, Gdk::COLORSPACE_RGB, - false, 8, wi, carea.get_height(), wi * 3); + Glib::RefPtr pb = + Gdk::Pixbuf::create_from_data(b, Gdk::COLORSPACE_RGB, false, 8, wi, carea.get_height(), wi * 3); - Gdk::Cairo::set_source_pixbuf(cr, pb, carea.get_width()/2 + carea.get_x(), carea.get_y()); + Gdk::Cairo::set_source_pixbuf(cr, pb, carea.get_width() / 2 + carea.get_x(), carea.get_y()); cr->paint(); } } } - /* Draw shadow */ - if (!colorsOnTop) { -#if GTK_CHECK_VERSION(3,0,0) - style_context->render_frame(cr, 0, 0, - allocation.get_width(), allocation.get_height()); + /* Draw shadow */ + if (!colorsOnTop) { +#if GTK_CHECK_VERSION(3, 0, 0) + style_context->render_frame(cr, 0, 0, allocation.get_width(), allocation.get_height()); #else - gtk_paint_shadow( style->gobj(), window->gobj(), - gtk_widget_get_state(gobj()), GTK_SHADOW_IN, - NULL, gobj(), "colorslider", - 0, 0, - allocation.get_width(), allocation.get_height()); + gtk_paint_shadow(style->gobj(), window->gobj(), gtk_widget_get_state(gobj()), GTK_SHADOW_IN, NULL, gobj(), + "colorslider", 0, 0, allocation.get_width(), allocation.get_height()); #endif - } + } /* Draw arrow */ gint x = (int)(_value * (carea.get_width() - 1) - ARROW_SIZE / 2 + carea.get_x()); @@ -510,16 +506,16 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { cr->set_line_width(1.0); // Define top arrow - cr->move_to(x - 0.5, y1 + 0.5); - cr->line_to(x + ARROW_SIZE - 0.5, y1 + 0.5); - cr->line_to(x + (ARROW_SIZE-1)/2.0, y1 + ARROW_SIZE/2.0 + 0.5); - cr->line_to(x - 0.5, y1 + 0.5); + cr->move_to(x - 0.5, y1 + 0.5); + cr->line_to(x + ARROW_SIZE - 0.5, y1 + 0.5); + cr->line_to(x + (ARROW_SIZE - 1) / 2.0, y1 + ARROW_SIZE / 2.0 + 0.5); + cr->line_to(x - 0.5, y1 + 0.5); // Define bottom arrow - cr->move_to(x - 0.5, y2 + 0.5); - cr->line_to(x + ARROW_SIZE - 0.5, y2 + 0.5); - cr->line_to(x + (ARROW_SIZE-1)/2.0, y2 - ARROW_SIZE/2.0 + 0.5); - cr->line_to(x - 0.5, y2 + 0.5); + cr->move_to(x - 0.5, y2 + 0.5); + cr->line_to(x + ARROW_SIZE - 0.5, y2 + 0.5); + cr->line_to(x + (ARROW_SIZE - 1) / 2.0, y2 - ARROW_SIZE / 2.0 + 0.5); + cr->line_to(x - 0.5, y2 + 0.5); // Render both arrows cr->set_source_rgb(1.0, 1.0, 1.0); @@ -530,111 +526,108 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { return false; } -}//namespace Widget -}//namespace UI -}//namespace Inkscape +} // namespace Widget +} // namespace UI +} // namespace Inkscape /* Colors are << 16 */ -static const guchar * -sp_color_slider_render_gradient (gint x0, gint y0, gint width, gint height, - gint c[], gint dc[], guint b0, guint b1, guint mask) +static const guchar *sp_color_slider_render_gradient(gint x0, gint y0, gint width, gint height, gint c[], gint dc[], + guint b0, guint b1, guint mask) { - static guchar *buf = NULL; - static gint bs = 0; - guchar *dp; - gint x, y; - guint r, g, b, a; - - if (buf && (bs < width * height)) { - g_free (buf); - buf = NULL; - } - if (!buf) { - buf = g_new (guchar, width * height * 3); - bs = width * height; - } - - dp = buf; - r = c[0]; - g = c[1]; - b = c[2]; - a = c[3]; - for (x = x0; x < x0 + width; x++) { - gint cr, cg, cb, ca; - guchar *d; - cr = r >> 16; - cg = g >> 16; - cb = b >> 16; - ca = a >> 16; - d = dp; - for (y = y0; y < y0 + height; y++) { - guint bg, fc; - /* Background value */ - bg = ((x & mask) ^ (y & mask)) ? b0 : b1; - fc = (cr - bg) * ca; - d[0] = bg + ((fc + (fc >> 8) + 0x80) >> 8); - fc = (cg - bg) * ca; - d[1] = bg + ((fc + (fc >> 8) + 0x80) >> 8); - fc = (cb - bg) * ca; - d[2] = bg + ((fc + (fc >> 8) + 0x80) >> 8); - d += 3 * width; - } - r += dc[0]; - g += dc[1]; - b += dc[2]; - a += dc[3]; - dp += 3; - } - - return buf; + static guchar *buf = NULL; + static gint bs = 0; + guchar *dp; + gint x, y; + guint r, g, b, a; + + if (buf && (bs < width * height)) { + g_free(buf); + buf = NULL; + } + if (!buf) { + buf = g_new(guchar, width * height * 3); + bs = width * height; + } + + dp = buf; + r = c[0]; + g = c[1]; + b = c[2]; + a = c[3]; + for (x = x0; x < x0 + width; x++) { + gint cr, cg, cb, ca; + guchar *d; + cr = r >> 16; + cg = g >> 16; + cb = b >> 16; + ca = a >> 16; + d = dp; + for (y = y0; y < y0 + height; y++) { + guint bg, fc; + /* Background value */ + bg = ((x & mask) ^ (y & mask)) ? b0 : b1; + fc = (cr - bg) * ca; + d[0] = bg + ((fc + (fc >> 8) + 0x80) >> 8); + fc = (cg - bg) * ca; + d[1] = bg + ((fc + (fc >> 8) + 0x80) >> 8); + fc = (cb - bg) * ca; + d[2] = bg + ((fc + (fc >> 8) + 0x80) >> 8); + d += 3 * width; + } + r += dc[0]; + g += dc[1]; + b += dc[2]; + a += dc[3]; + dp += 3; + } + + return buf; } /* Positions are << 16 */ -static const guchar * -sp_color_slider_render_map (gint x0, gint y0, gint width, gint height, - guchar *map, gint start, gint step, guint b0, guint b1, guint mask) +static const guchar *sp_color_slider_render_map(gint x0, gint y0, gint width, gint height, guchar *map, gint start, + gint step, guint b0, guint b1, guint mask) { - static guchar *buf = NULL; - static gint bs = 0; - guchar *dp; - gint x, y; - - if (buf && (bs < width * height)) { - g_free (buf); - buf = NULL; - } - if (!buf) { - buf = g_new (guchar, width * height * 3); - bs = width * height; - } - - dp = buf; - for (x = x0; x < x0 + width; x++) { - gint cr, cg, cb, ca; - guchar *d = dp; - guchar *sp = map + 4 * (start >> 16); - cr = *sp++; - cg = *sp++; - cb = *sp++; - ca = *sp++; - for (y = y0; y < y0 + height; y++) { - guint bg, fc; - /* Background value */ - bg = ((x & mask) ^ (y & mask)) ? b0 : b1; - fc = (cr - bg) * ca; - d[0] = bg + ((fc + (fc >> 8) + 0x80) >> 8); - fc = (cg - bg) * ca; - d[1] = bg + ((fc + (fc >> 8) + 0x80) >> 8); - fc = (cb - bg) * ca; - d[2] = bg + ((fc + (fc >> 8) + 0x80) >> 8); - d += 3 * width; - } - dp += 3; - start += step; - } - - return buf; -} + static guchar *buf = NULL; + static gint bs = 0; + guchar *dp; + gint x, y; + + if (buf && (bs < width * height)) { + g_free(buf); + buf = NULL; + } + if (!buf) { + buf = g_new(guchar, width * height * 3); + bs = width * height; + } + dp = buf; + for (x = x0; x < x0 + width; x++) { + gint cr, cg, cb, ca; + guchar *d = dp; + guchar *sp = map + 4 * (start >> 16); + cr = *sp++; + cg = *sp++; + cb = *sp++; + ca = *sp++; + for (y = y0; y < y0 + height; y++) { + guint bg, fc; + /* Background value */ + bg = ((x & mask) ^ (y & mask)) ? b0 : b1; + fc = (cr - bg) * ca; + d[0] = bg + ((fc + (fc >> 8) + 0x80) >> 8); + fc = (cg - bg) * ca; + d[1] = bg + ((fc + (fc >> 8) + 0x80) >> 8); + fc = (cb - bg) * ca; + d[2] = bg + ((fc + (fc >> 8) + 0x80) >> 8); + d += 3 * width; + } + dp += 3; + start += step; + } + + return buf; +} diff --git a/src/ui/widget/color-slider.h b/src/ui/widget/color-slider.h index 2f2e7b2db..253f3123c 100644 --- a/src/ui/widget/color-slider.h +++ b/src/ui/widget/color-slider.h @@ -15,26 +15,23 @@ #include #include -namespace Inkscape -{ -namespace UI -{ -namespace Widget -{ +namespace Inkscape { +namespace UI { +namespace Widget { /* * A slider with colored background */ -class ColorSlider: public Gtk::Widget { +class ColorSlider : public Gtk::Widget { public: -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) ColorSlider(Glib::RefPtr adjustment); #else ColorSlider(Gtk::Adjustment *adjustment); #endif ~ColorSlider(); -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) void setAdjustment(Glib::RefPtr adjustment); #else void setAdjustment(Gtk::Adjustment *adjustment); @@ -42,7 +39,7 @@ public: void setColors(guint32 start, guint32 mid, guint32 end); - void setMap(const guchar* map); + void setMap(const guchar *map); void setBackground(guint dark, guint light, guint size); @@ -52,22 +49,22 @@ public: sigc::signal signal_value_changed; protected: - void on_size_allocate(Gtk::Allocation& allocation); + void on_size_allocate(Gtk::Allocation &allocation); void on_realize(); void on_unrealize(); bool on_button_press_event(GdkEventButton *event); bool on_button_release_event(GdkEventButton *event); bool on_motion_notify_event(GdkEventMotion *event); - bool on_draw(const Cairo::RefPtr& cr); + bool on_draw(const Cairo::RefPtr &cr); -#if GTK_CHECK_VERSION(3,0,0) - void get_preferred_width_vfunc(int& minimum_width, int& natural_width) const; - void get_preferred_width_for_height_vfunc(int height, int& minimum_width, int& natural_width) const; - void get_preferred_height_vfunc(int& minimum_height, int& natural_height) const; - void get_preferred_height_for_width_vfunc(int width, int& minimum_height, int& natural_height) const; +#if GTK_CHECK_VERSION(3, 0, 0) + void get_preferred_width_vfunc(int &minimum_width, int &natural_width) const; + void get_preferred_width_for_height_vfunc(int height, int &minimum_width, int &natural_width) const; + void get_preferred_height_vfunc(int &minimum_height, int &natural_height) const; + void get_preferred_height_for_width_vfunc(int width, int &minimum_height, int &natural_height) const; #else - void on_size_request(Gtk::Requisition* requisition); - bool on_expose_event(GdkEventExpose* event); + void on_size_request(Gtk::Requisition *requisition); + bool on_expose_event(GdkEventExpose *event); #endif private: @@ -76,7 +73,7 @@ private: bool _dragging; -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) Glib::RefPtr _adjustment; #else Gtk::Adjustment *_adjustment; @@ -96,9 +93,9 @@ private: Glib::RefPtr _gdk_window; }; -}//namespace Widget -}//namespace UI -}//namespace Inkscape +} // namespace Widget +} // namespace UI +} // namespace Inkscape #endif /* diff --git a/src/ui/widget/color-wheel-selector.cpp b/src/ui/widget/color-wheel-selector.cpp index e00fb2fab..8c6402d90 100644 --- a/src/ui/widget/color-wheel-selector.cpp +++ b/src/ui/widget/color-wheel-selector.cpp @@ -1,5 +1,5 @@ #ifdef HAVE_CONFIG_H -# include "config.h" +#include "config.h" #endif #include "color-wheel-selector.h" @@ -26,17 +26,17 @@ namespace Widget { #define YPAD 1 -const gchar* ColorWheelSelector::MODE_NAME = N_("Wheel"); +const gchar *ColorWheelSelector::MODE_NAME = N_("Wheel"); ColorWheelSelector::ColorWheelSelector(SelectedColor &color) -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) : Gtk::Grid() #else : Gtk::Table(5, 3, false) #endif , _color(color) , _updating(false) -#if !GTK_CHECK_VERSION(3,0,0) +#if !GTK_CHECK_VERSION(3, 0, 0) , _alpha_adjustment(NULL) #endif , _wheel(0) @@ -45,13 +45,12 @@ ColorWheelSelector::ColorWheelSelector(SelectedColor &color) _initUI(); _color_changed_connection = color.signal_changed.connect(sigc::mem_fun(this, &ColorWheelSelector::_colorChanged)); _color_dragged_connection = color.signal_dragged.connect(sigc::mem_fun(this, &ColorWheelSelector::_colorChanged)); - } ColorWheelSelector::~ColorWheelSelector() { _wheel = 0; -#if !GTK_CHECK_VERSION(3,0,0) +#if !GTK_CHECK_VERSION(3, 0, 0) delete _alpha_adjustment; #endif @@ -59,32 +58,34 @@ ColorWheelSelector::~ColorWheelSelector() _color_dragged_connection.disconnect(); } -void ColorWheelSelector::_initUI() { +void ColorWheelSelector::_initUI() +{ /* Create components */ gint row = 0; _wheel = gimp_color_wheel_new(); - gtk_widget_show( _wheel ); + gtk_widget_show(_wheel); -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) gtk_widget_set_halign(_wheel, GTK_ALIGN_FILL); gtk_widget_set_valign(_wheel, GTK_ALIGN_FILL); gtk_widget_set_hexpand(_wheel, TRUE); gtk_widget_set_vexpand(_wheel, TRUE); gtk_grid_attach(GTK_GRID(gobj()), _wheel, 0, row, 3, 1); #else - gtk_table_attach(GTK_TABLE(gobj()), _wheel, 0, 3, row, row + 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0); + gtk_table_attach(GTK_TABLE(gobj()), _wheel, 0, 3, row, row + 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), + (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0); #endif row++; /* Label */ - Gtk::Label* label = Gtk::manage(new Gtk::Label(_("_A:"), true)); + Gtk::Label *label = Gtk::manage(new Gtk::Label(_("_A:"), true)); label->set_alignment(1.0, 0.5); label->show(); -#if GTK_CHECK_VERSION(3,0,0) - #if GTK_CHECK_VERSION(3,12,0) +#if GTK_CHECK_VERSION(3, 0, 0) + #if GTK_CHECK_VERSION(3, 12, 0) label->set_margin_start(XPAD); label->set_margin_end(XPAD); #else @@ -100,8 +101,8 @@ void ColorWheelSelector::_initUI() { attach(*label, 0, 1, row, row + 1, Gtk::FILL, Gtk::FILL, XPAD, YPAD); #endif - /* Adjustment */ -#if GTK_CHECK_VERSION(3,0,0) +/* Adjustment */ +#if GTK_CHECK_VERSION(3, 0, 0) _alpha_adjustment = Gtk::Adjustment::create(0.0, 0.0, 255.0, 1.0, 10.0, 10.0); #else _alpha_adjustment = new Gtk::Adjustment(0.0, 0.0, 255.0, 1.0, 10.0, 10.0); @@ -111,8 +112,8 @@ void ColorWheelSelector::_initUI() { _slider->set_tooltip_text(_("Alpha (opacity)")); _slider->show(); -#if GTK_CHECK_VERSION(3,0,0) - #if GTK_CHECK_VERSION(3,12,0) +#if GTK_CHECK_VERSION(3, 0, 0) + #if GTK_CHECK_VERSION(3, 12, 0) _slider->set_margin_start(XPAD); _slider->set_margin_end(XPAD); #else @@ -126,26 +127,25 @@ void ColorWheelSelector::_initUI() { _slider->set_valign(Gtk::ALIGN_FILL); attach(*_slider, 1, row, 1, 1); #else - attach(*_slider, 1, 2, row, row+1, Gtk::EXPAND | Gtk::FILL, Gtk::FILL, XPAD, YPAD); + attach(*_slider, 1, 2, row, row + 1, Gtk::EXPAND | Gtk::FILL, Gtk::FILL, XPAD, YPAD); #endif - _slider->setColors(SP_RGBA32_F_COMPOSE (1.0, 1.0, 1.0, 0.0), - SP_RGBA32_F_COMPOSE (1.0, 1.0, 1.0, 0.5), - SP_RGBA32_F_COMPOSE (1.0, 1.0, 1.0, 1.0)); + _slider->setColors(SP_RGBA32_F_COMPOSE(1.0, 1.0, 1.0, 0.0), SP_RGBA32_F_COMPOSE(1.0, 1.0, 1.0, 0.5), + SP_RGBA32_F_COMPOSE(1.0, 1.0, 1.0, 1.0)); - /* Spinbutton */ -#if GTK_CHECK_VERSION(3,0,0) - Gtk::SpinButton* spin_button = Gtk::manage(new Gtk::SpinButton(_alpha_adjustment, 1.0, 0)); - #else - Gtk::SpinButton* spin_button = Gtk::manage(new Gtk::SpinButton(*_alpha_adjustment, 1.0, 0)); +/* Spinbutton */ +#if GTK_CHECK_VERSION(3, 0, 0) + Gtk::SpinButton *spin_button = Gtk::manage(new Gtk::SpinButton(_alpha_adjustment, 1.0, 0)); +#else + Gtk::SpinButton *spin_button = Gtk::manage(new Gtk::SpinButton(*_alpha_adjustment, 1.0, 0)); #endif spin_button->set_tooltip_text(_("Alpha (opacity)")); sp_dialog_defocus_on_enter(GTK_WIDGET(spin_button->gobj())); label->set_mnemonic_widget(*spin_button); spin_button->show(); -#if GTK_CHECK_VERSION(3,0,0) - #if GTK_CHECK_VERSION(3,12,0) +#if GTK_CHECK_VERSION(3, 0, 0) + #if GTK_CHECK_VERSION(3, 12, 0) spin_button->set_margin_start(XPAD); spin_button->set_margin_end(XPAD); #else @@ -167,27 +167,27 @@ void ColorWheelSelector::_initUI() { _slider->signal_released.connect(sigc::mem_fun(*this, &ColorWheelSelector::_sliderReleased)); _slider->signal_value_changed.connect(sigc::mem_fun(*this, &ColorWheelSelector::_sliderChanged)); - g_signal_connect( G_OBJECT(_wheel), "changed", - G_CALLBACK (_wheelChanged), this ); + g_signal_connect(G_OBJECT(_wheel), "changed", G_CALLBACK(_wheelChanged), this); } void ColorWheelSelector::_colorChanged() { #ifdef DUMP_CHANGE_INFO - g_message("ColorWheelSelector::_colorChanged( this=%p, %f, %f, %f, %f)", this, _color.color().v.c[0], _color.color().v.c[1], _color.color().v.c[2], alpha ); + g_message("ColorWheelSelector::_colorChanged( this=%p, %f, %f, %f, %f)", this, _color.color().v.c[0], + _color.color().v.c[1], _color.color().v.c[2], alpha); #endif bool oldval = _updating; _updating = true; { - float hsv[3] = {0,0,0}; + float hsv[3] = { 0, 0, 0 }; sp_color_rgb_to_hsv_floatv(hsv, _color.color().v.c[0], _color.color().v.c[1], _color.color().v.c[2]); - gimp_color_wheel_set_color( GIMP_COLOR_WHEEL(_wheel), hsv[0], hsv[1], hsv[2] ); + gimp_color_wheel_set_color(GIMP_COLOR_WHEEL(_wheel), hsv[0], hsv[1], hsv[2]); } - guint32 start = _color.color().toRGBA32( 0x00 ); - guint32 mid = _color.color().toRGBA32( 0x7f ); - guint32 end = _color.color().toRGBA32( 0xff ); + guint32 start = _color.color().toRGBA32(0x00); + guint32 mid = _color.color().toRGBA32(0x7f); + guint32 end = _color.color().toRGBA32(0xff); _slider->setColors(start, mid, end); @@ -238,23 +238,23 @@ void ColorWheelSelector::_sliderChanged() void ColorWheelSelector::_wheelChanged(GimpColorWheel *wheel, ColorWheelSelector *wheelSelector) { - if (wheelSelector->_updating){ + if (wheelSelector->_updating) { return; } gdouble h = 0; gdouble s = 0; gdouble v = 0; - gimp_color_wheel_get_color( wheel, &h, &s, &v ); - - float rgb[3] = {0,0,0}; - sp_color_hsv_to_rgb_floatv (rgb, h, s, v); + gimp_color_wheel_get_color(wheel, &h, &s, &v); + + float rgb[3] = { 0, 0, 0 }; + sp_color_hsv_to_rgb_floatv(rgb, h, s, v); SPColor color(rgb[0], rgb[1], rgb[2]); - guint32 start = color.toRGBA32( 0x00 ); - guint32 mid = color.toRGBA32( 0x7f ); - guint32 end = color.toRGBA32( 0xff ); + guint32 start = color.toRGBA32(0x00); + guint32 mid = color.toRGBA32(0x7f); + guint32 end = color.toRGBA32(0xff); wheelSelector->_slider->setColors(start, mid, end); @@ -265,15 +265,13 @@ void ColorWheelSelector::_wheelChanged(GimpColorWheel *wheel, ColorWheelSelector } -Gtk::Widget *ColorWheelSelectorFactory::createWidget(Inkscape::UI::SelectedColor &color) const { +Gtk::Widget *ColorWheelSelectorFactory::createWidget(Inkscape::UI::SelectedColor &color) const +{ Gtk::Widget *w = Gtk::manage(new ColorWheelSelector(color)); return w; } -Glib::ustring ColorWheelSelectorFactory::modeName() const { - return gettext(ColorWheelSelector::MODE_NAME); -} - +Glib::ustring ColorWheelSelectorFactory::modeName() const { return gettext(ColorWheelSelector::MODE_NAME); } } } } diff --git a/src/ui/widget/color-wheel-selector.h b/src/ui/widget/color-wheel-selector.h index ec30cc7c5..f97f70f6a 100644 --- a/src/ui/widget/color-wheel-selector.h +++ b/src/ui/widget/color-wheel-selector.h @@ -13,7 +13,7 @@ #define SEEN_SP_COLOR_WHEEL_SELECTOR_H #ifdef HAVE_CONFIG_H -# include +#include #endif #if WITH_GTKMM_3_0 @@ -33,14 +33,14 @@ namespace Widget { class ColorSlider; class ColorWheelSelector -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) : public Gtk::Grid #else : public Gtk::Table #endif { public: - static const gchar* MODE_NAME; + static const gchar *MODE_NAME; ColorWheelSelector(SelectedColor &color); virtual ~ColorWheelSelector(); @@ -59,30 +59,28 @@ protected: SelectedColor &_color; bool _updating; -#if GTK_CHECK_VERSION(3,0,0) +#if GTK_CHECK_VERSION(3, 0, 0) Glib::RefPtr _alpha_adjustment; #else - Gtk::Adjustment* _alpha_adjustment; + Gtk::Adjustment *_alpha_adjustment; #endif - GtkWidget* _wheel; - Inkscape::UI::Widget::ColorSlider* _slider; + GtkWidget *_wheel; + Inkscape::UI::Widget::ColorSlider *_slider; private: // By default, disallow copy constructor and assignment operator - ColorWheelSelector( const ColorWheelSelector& obj ); - ColorWheelSelector& operator=( const ColorWheelSelector& obj ); + ColorWheelSelector(const ColorWheelSelector &obj); + ColorWheelSelector &operator=(const ColorWheelSelector &obj); sigc::connection _color_changed_connection; sigc::connection _color_dragged_connection; }; - -class ColorWheelSelectorFactory: public ColorSelectorFactory { +class ColorWheelSelectorFactory : public ColorSelectorFactory { public: Gtk::Widget *createWidget(SelectedColor &color) const; Glib::ustring modeName() const; }; - } } } -- cgit v1.2.3 From cd9885ddc7dfbf7769f902dd7ee043892a2c8ee9 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 9 May 2015 14:53:54 +0200 Subject: fixed crash in paint selector when changing from gradient to solid color (bzr r14059.1.23) --- src/ui/selected-color.cpp | 17 ++++++++++------- src/ui/selected-color.h | 2 +- src/ui/widget/color-scales.cpp | 11 +++-------- 3 files changed, 14 insertions(+), 16 deletions(-) (limited to 'src/ui') diff --git a/src/ui/selected-color.cpp b/src/ui/selected-color.cpp index 7652e5acf..6573129d3 100644 --- a/src/ui/selected-color.cpp +++ b/src/ui/selected-color.cpp @@ -72,7 +72,7 @@ guint32 SelectedColor::value() const return color().toRGBA32(_alpha); } -void SelectedColor::setColorAlpha(SPColor const &color, gfloat alpha) +void SelectedColor::setColorAlpha(SPColor const &color, gfloat alpha, bool emit_signal) { #ifdef DUMP_CHANGE_INFO g_message("SelectedColor::setColorAlpha( this=%p, %f, %f, %f, %s, %f, %s) in %s", this, color.v.c[0], color.v.c[1], color.v.c[2], (color.icc?color.icc->colorProfile.c_str():""), alpha, (emit?"YES":"no"), FOO_NAME(_csel)); @@ -100,13 +100,16 @@ void SelectedColor::setColorAlpha(SPColor const &color, gfloat alpha) _color = color; _alpha = alpha; - _updating = true; - if (_held) { - signal_dragged.emit(); - } else { - signal_changed.emit(); + if (emit_signal) + { + _updating = true; + if (_held) { + signal_dragged.emit(); + } else { + signal_changed.emit(); + } + _updating = false; } - _updating = false; #ifdef DUMP_CHANGE_INFO } else { diff --git a/src/ui/selected-color.h b/src/ui/selected-color.h index 168099c82..e9e702d43 100644 --- a/src/ui/selected-color.h +++ b/src/ui/selected-color.h @@ -38,7 +38,7 @@ public: void setValue(guint32 value); guint32 value() const; - void setColorAlpha(SPColor const &color, gfloat alpha); + void setColorAlpha(SPColor const &color, gfloat alpha, bool emit_signal = true); void colorAlpha(SPColor &color, gfloat &alpha) const; void setHeld(bool held); diff --git a/src/ui/widget/color-scales.cpp b/src/ui/widget/color-scales.cpp index 5fa5af902..ead636406 100644 --- a/src/ui/widget/color-scales.cpp +++ b/src/ui/widget/color-scales.cpp @@ -376,8 +376,8 @@ void ColorScales::setMode(SPColorScalesMode mode) setScaled(_a[1], rgba[1]); setScaled(_a[2], rgba[2]); setScaled(_a[3], rgba[3]); - _updating = FALSE; _updateSliders(CSC_CHANNELS_ALL); + _updating = FALSE; break; case SP_COLOR_SCALES_MODE_HSV: _setRangeLimit(255.0); @@ -404,8 +404,8 @@ void ColorScales::setMode(SPColorScalesMode mode) setScaled(_a[1], c[1]); setScaled(_a[2], c[2]); setScaled(_a[3], rgba[3]); - _updating = FALSE; _updateSliders(CSC_CHANNELS_ALL); + _updating = FALSE; break; case SP_COLOR_SCALES_MODE_CMYK: _setRangeLimit(100.0); @@ -437,8 +437,8 @@ void ColorScales::setMode(SPColorScalesMode mode) setScaled(_a[3], c[3]); setScaled(_a[4], rgba[3]); - _updating = FALSE; _updateSliders(CSC_CHANNELS_ALL); + _updating = FALSE; break; default: g_warning("file %s: line %d: Illegal color selector mode", __FILE__, __LINE__); @@ -607,11 +607,6 @@ void ColorScales::_updateSliders(guint channels) break; } - // Force the internal color to be updated - if (!_updating) { - _recalcColor(); - } - #ifdef SPCS_PREVIEW rgba = sp_color_scales_get_rgba32(cs); sp_color_preview_set_rgba32(SP_COLOR_PREVIEW(_p), rgba); -- cgit v1.2.3 From 78cee203a59243dcabbf67499682ce720be6d1d6 Mon Sep 17 00:00:00 2001 From: Jabier Arraiza Cenoz Date: Sat, 9 May 2015 17:50:08 +0200 Subject: Remove documentUnits from live_effect/effect.cpp/h Remove units from fillet-chamfer and roughen (bzr r14136) --- src/ui/dialog/lpe-fillet-chamfer-properties.cpp | 22 ++-------------------- src/ui/dialog/lpe-fillet-chamfer-properties.h | 8 +------- 2 files changed, 3 insertions(+), 27 deletions(-) (limited to 'src/ui') diff --git a/src/ui/dialog/lpe-fillet-chamfer-properties.cpp b/src/ui/dialog/lpe-fillet-chamfer-properties.cpp index f63b19e86..061055feb 100644 --- a/src/ui/dialog/lpe-fillet-chamfer-properties.cpp +++ b/src/ui/dialog/lpe-fillet-chamfer-properties.cpp @@ -27,7 +27,6 @@ #include "selection-chemistry.h" #include "ui/icon-names.h" #include "ui/widget/imagetoggler.h" -#include "util/units.h" #include //#include "event-context.h" @@ -122,18 +121,14 @@ void FilletChamferPropertiesDialog::showDialog( SPDesktop *desktop, Geom::Point knotpoint, const Inkscape::LivePathEffect:: FilletChamferPointArrayParamKnotHolderEntity *pt, - const gchar *unit, bool use_distance, - bool aprox_radius, - Glib::ustring documentUnit) + bool aprox_radius) { FilletChamferPropertiesDialog *dialog = new FilletChamferPropertiesDialog(); dialog->_set_desktop(desktop); - dialog->_set_unit(unit); dialog->_set_use_distance(use_distance); dialog->_set_aprox(aprox_radius); - dialog->_set_document_unit(documentUnit); dialog->_set_knot_point(knotpoint); dialog->_set_pt(pt); @@ -168,7 +163,6 @@ void FilletChamferPropertiesDialog::_apply() } d_pos = _index + (d_pos / 100); } else { - d_pos = Inkscape::Util::Quantity::convert(d_pos, unit, document_unit); d_pos = d_pos * -1; } _knotpoint->knot_set_offset(Geom::Point(d_pos, d_width)); @@ -218,11 +212,9 @@ void FilletChamferPropertiesDialog::_set_knot_point(Geom::Point knotpoint) _fillet_chamfer_position_label.set_label(_("Position (%):")); } else { _flexible = false; - std::string posConcat = Glib::ustring::compose (_("%1 (%2):"), distance_or_radius, unit); + std::string posConcat = Glib::ustring::compose (_("%1:"), distance_or_radius); _fillet_chamfer_position_label.set_label(_(posConcat.c_str())); position = knotpoint[Geom::X] * -1; - - position = Inkscape::Util::Quantity::convert(position, document_unit, unit); } _fillet_chamfer_position_numeric.set_value(position); if (knotpoint.y() == 1) { @@ -247,16 +239,6 @@ void FilletChamferPropertiesDialog::_set_pt( pt); } -void FilletChamferPropertiesDialog::_set_unit(const gchar *abbr) -{ - unit = abbr; -} - -void FilletChamferPropertiesDialog::_set_document_unit(Glib::ustring abbr) -{ - document_unit = abbr; -} - void FilletChamferPropertiesDialog::_set_use_distance(bool use_knot_distance) { use_distance = use_knot_distance; diff --git a/src/ui/dialog/lpe-fillet-chamfer-properties.h b/src/ui/dialog/lpe-fillet-chamfer-properties.h index 870a1734f..99494bd63 100644 --- a/src/ui/dialog/lpe-fillet-chamfer-properties.h +++ b/src/ui/dialog/lpe-fillet-chamfer-properties.h @@ -30,10 +30,8 @@ public: static void showDialog(SPDesktop *desktop, Geom::Point knotpoint, const Inkscape::LivePathEffect:: FilletChamferPointArrayParamKnotHolderEntity *pt, - const gchar *unit, bool use_distance, - bool aprox_radius, - Glib::ustring documentUnit); + bool aprox_radius); protected: @@ -68,15 +66,11 @@ protected: void _set_desktop(SPDesktop *desktop); void _set_pt(const Inkscape::LivePathEffect:: FilletChamferPointArrayParamKnotHolderEntity *pt); - void _set_unit(const gchar *abbr); - void _set_document_unit(Glib::ustring abbr); void _set_use_distance(bool use_knot_distance); void _set_aprox(bool aprox_radius); void _apply(); void _close(); bool _flexible; - const gchar *unit; - Glib::ustring document_unit; bool use_distance; bool aprox; void _set_knot_point(Geom::Point knotpoint); -- cgit v1.2.3 From 3b8c4f31de73bd83057bffb8105498ae62be1984 Mon Sep 17 00:00:00 2001 From: Marc Jeanmougin Date: Sun, 10 May 2015 23:55:55 +0200 Subject: Fix for bug 1194091 Fixed bugs: - https://launchpad.net/bugs/1194091 (bzr r14142) --- src/ui/dialog/layers.cpp | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) (limited to 'src/ui') diff --git a/src/ui/dialog/layers.cpp b/src/ui/dialog/layers.cpp index 65351cb68..c6888386f 100644 --- a/src/ui/dialog/layers.cpp +++ b/src/ui/dialog/layers.cpp @@ -713,13 +713,21 @@ bool LayersPanel::_handleDragDrop(const Glib::RefPtr& /*contex */ void LayersPanel::_doTreeMove( ) { - if (_dnd_source ) { + if (_dnd_source && _dnd_source->getRepr() ) { + if(!_dnd_target){ + _dnd_source->doWriteTransform(_dnd_source->getRepr(), _dnd_source->document->getRoot()->i2doc_affine().inverse() * _dnd_source->i2doc_affine()); + }else{ + SPItem* parent = _dnd_into ? _dnd_target : dynamic_cast(_dnd_target->parent); + if(parent){ + Geom::Affine move = parent->i2doc_affine().inverse() * _dnd_source->i2doc_affine(); + _dnd_source->doWriteTransform(_dnd_source->getRepr(), move); + } + } _dnd_source->moveTo(_dnd_target, _dnd_into); _selectLayer(_dnd_source); _dnd_source = NULL; DocumentUndo::done( _desktop->doc() , SP_VERB_NONE, _("Moved layer")); - } } -- cgit v1.2.3 From f7bd98a01dce9cb5a1532ab983c0b39b4d14d8f5 Mon Sep 17 00:00:00 2001 From: Nicolas Dufour Date: Mon, 11 May 2015 17:58:35 +0200 Subject: UI. Fix for Bug #1450875 (A change of the Image quality for an embedded/linked image can't be saved in some circumstances.). Fixed bugs: - https://launchpad.net/bugs/1450875 (bzr r14144) --- src/ui/dialog/object-properties.cpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'src/ui') diff --git a/src/ui/dialog/object-properties.cpp b/src/ui/dialog/object-properties.cpp index fc21a30d4..75430ed44 100644 --- a/src/ui/dialog/object-properties.cpp +++ b/src/ui/dialog/object-properties.cpp @@ -529,10 +529,12 @@ void ObjectProperties::_imageRenderingChanged() SPCSSAttr *css = sp_repr_css_attr_new(); sp_repr_css_set_property(css, "image-rendering", scale.c_str()); Inkscape::XML::Node *image_node = item->getRepr(); - if( image_node ) { + if (image_node) { sp_repr_css_change(image_node, css, "style"); + DocumentUndo::done(SP_ACTIVE_DOCUMENT, SP_VERB_DIALOG_ITEM, + _("Set image rendering option")); } - sp_repr_css_attr_unref( css ); + sp_repr_css_attr_unref(css); _blocked = false; } -- cgit v1.2.3 From fbff05fb816454688444dd23169a70092f1252bc Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Tue, 12 May 2015 00:28:20 +0200 Subject: fixed color selector not remembering it's last open tab (bzr r14059.1.25) --- src/ui/widget/color-notebook.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/ui') diff --git a/src/ui/widget/color-notebook.cpp b/src/ui/widget/color-notebook.cpp index 0150f2ca2..60abf43bf 100644 --- a/src/ui/widget/color-notebook.cpp +++ b/src/ui/widget/color-notebook.cpp @@ -275,7 +275,7 @@ void ColorNotebook::_onSelectedColorChanged() { _updateICCButtons(); } void ColorNotebook::_onPageSwitched(GtkNotebook *notebook, GtkWidget *page, guint page_num, ColorNotebook *colorbook) { - if (colorbook) { + if (colorbook->get_visible()) { // remember the page we switched to Inkscape::Preferences *prefs = Inkscape::Preferences::get(); prefs->setInt("/colorselector/page", page_num); -- cgit v1.2.3 From c1b1d511b45348d8bccc5d22cd3471bb540cde12 Mon Sep 17 00:00:00 2001 From: Tavmjong Bah Date: Tue, 12 May 2015 21:43:24 +0200 Subject: GUI for font-variant-xxx, parse 'font-variant-ligatures'. This is a work in progress. (bzr r14148) --- src/ui/dialog/text-edit.cpp | 9 +- src/ui/dialog/text-edit.h | 4 + src/ui/widget/Makefile_insert | 6 +- src/ui/widget/font-variants.cpp | 246 ++++++++++++++++++++++++++++++++++++++++ src/ui/widget/font-variants.h | 119 +++++++++++++++++++ 5 files changed, 381 insertions(+), 3 deletions(-) create mode 100644 src/ui/widget/font-variants.cpp create mode 100644 src/ui/widget/font-variants.h (limited to 'src/ui') diff --git a/src/ui/dialog/text-edit.cpp b/src/ui/dialog/text-edit.cpp index 815aa12ef..98ea7f9f7 100644 --- a/src/ui/dialog/text-edit.cpp +++ b/src/ui/dialog/text-edit.cpp @@ -69,6 +69,7 @@ TextEdit::TextEdit() font_label(_("_Font"), true), layout_frame(), text_label(_("_Text"), true), + vari_label(_("_Variants"), true), setasdefault_button(_("Set as _default")), close_button(Gtk::Stock::CLOSE), apply_button(Gtk::Stock::APPLY), @@ -195,7 +196,8 @@ TextEdit::TextEdit() notebook.append_page(font_vbox, font_label); notebook.append_page(text_vbox, text_label); - + notebook.append_page(vari_vbox, vari_label); + /* Buttons */ setasdefault_button.set_use_underline(true); apply_button.set_can_default(); @@ -384,6 +386,11 @@ void TextEdit::onReadSelection ( gboolean dostyle, gboolean /*docontent*/ ) gtk_entry_set_text ((GtkEntry *) gtk_bin_get_child ((GtkBin *) spacing_combo), sstr); g_free(sstr); + // Update font variant widget + //int result_variants = + sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTVARIANTS); + vari_vbox.update( query.font_variant_ligatures.computed, query.font_variant_ligatures.value ); + } blocked = false; } diff --git a/src/ui/dialog/text-edit.h b/src/ui/dialog/text-edit.h index 117ad2e28..f088fd337 100644 --- a/src/ui/dialog/text-edit.h +++ b/src/ui/dialog/text-edit.h @@ -32,6 +32,7 @@ #include "ui/widget/panel.h" #include "ui/widget/frame.h" #include "ui/dialog/desktop-tracker.h" +#include "ui/widget/font-variants.h" class SPItem; struct SPFontSelector; @@ -213,6 +214,9 @@ private: GtkWidget *text_view; // TODO - Convert this to a Gtk::TextView, but GtkSpell doesn't seem to work with it GtkTextBuffer *text_buffer; + Inkscape::UI::Widget::FontVariants vari_vbox; + Gtk::Label vari_label; + Gtk::HBox button_row; Gtk::Button setasdefault_button; Gtk::Button close_button; diff --git a/src/ui/widget/Makefile_insert b/src/ui/widget/Makefile_insert index e18b790bd..305076a9d 100644 --- a/src/ui/widget/Makefile_insert +++ b/src/ui/widget/Makefile_insert @@ -21,8 +21,10 @@ ink_common_sources += \ ui/widget/entry.h \ ui/widget/filter-effect-chooser.h \ ui/widget/filter-effect-chooser.cpp \ - ui/widget/gimpspinscale.c \ - ui/widget/gimpspinscale.h \ + ui/widget/font-variants.h \ + ui/widget/font-variants.cpp \ + ui/widget/gimpspinscale.c \ + ui/widget/gimpspinscale.h \ ui/widget/gimpcolorwheel.c \ ui/widget/gimpcolorwheel.h \ ui/widget/frame.cpp \ diff --git a/src/ui/widget/font-variants.cpp b/src/ui/widget/font-variants.cpp new file mode 100644 index 000000000..46fbc2aa4 --- /dev/null +++ b/src/ui/widget/font-variants.cpp @@ -0,0 +1,246 @@ +/* + * Author: + * Tavmjong Bah + * + * Copyright (C) 2015 Tavmong Bah + * + * Released under GNU GPL. Read the file 'COPYING' for more information. + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include + +#include + +#include "font-variants.h" + +// For updating from selection +#include "desktop.h" +#include "selection.h" +#include "style.h" +#include "sp-text.h" +#include "sp-tspan.h" +#include "sp-tref.h" +#include "sp-textpath.h" +#include "sp-item-group.h" + +namespace Inkscape { +namespace UI { +namespace Widget { + + FontVariants::FontVariants () : + Gtk::VBox (), + _ligatures_frame ( Glib::ustring(_("Ligatures" )) ), + _ligatures_common ( Glib::ustring(_("Common" )) ), + _ligatures_discretionary ( Glib::ustring(_("Discretionary")) ), + _ligatures_historical ( Glib::ustring(_("Historical" )) ), + _ligatures_contextual ( Glib::ustring(_("Contextual" )) ), + + _position_frame ( Glib::ustring(_("Position" )) ), + _position_normal ( Glib::ustring(_("Normal" )) ), + _position_sub ( Glib::ustring(_("Subscript" )) ), + _position_super ( Glib::ustring(_("Superscript" )) ), + + _caps_frame ( Glib::ustring(_("Capitals" )) ), + _caps_normal ( Glib::ustring(_("Normal" )) ), + _caps_small ( Glib::ustring(_("Small" )) ), + _caps_all_small ( Glib::ustring(_("All small" )) ), + _caps_petite ( Glib::ustring(_("Petite" )) ), + _caps_all_petite ( Glib::ustring(_("All petite" )) ), + _caps_unicase ( Glib::ustring(_("Unicase" )) ), + _caps_titling ( Glib::ustring(_("Titling" )) ), + + _numeric_frame ( Glib::ustring(_("Numeric" )) ), + _numeric_lining ( Glib::ustring(_("Lining" )) ), + _numeric_old_style ( Glib::ustring(_("Old Style" )) ), + _numeric_default_style ( Glib::ustring(_("Default Style")) ), + _numeric_proportional ( Glib::ustring(_("Proportional" )) ), + _numeric_tabular ( Glib::ustring(_("Tabular" )) ), + _numeric_default_width ( Glib::ustring(_("Default Width")) ), + _numeric_diagonal ( Glib::ustring(_("Diagonal" )) ), + _numeric_stacked ( Glib::ustring(_("Stacked" )) ), + _numeric_default_fractions( Glib::ustring(_("Default Fractions")) ), + _numeric_ordinal ( Glib::ustring(_("Ordinal" )) ), + _numeric_slashed_zero ( Glib::ustring(_("Slashed Zero" )) ) + + + { + + // Ligatures -------------------------- + _ligatures_common.set_tooltip_text( + _("Common ligatures. On by default. OpenType tables: 'liga', 'clig'")); + _ligatures_discretionary.set_tooltip_text( + _("Discretionary ligatures. Off by default. OpenType table: 'dlig'")); + _ligatures_historical.set_tooltip_text( + _("Historical ligatures. Off by default. OpenType table: 'hlig'")); + _ligatures_contextual.set_tooltip_text( + _("Contextual forms. On by default. OpenType table: 'calt'")); + + + _ligatures_common.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::ligatures_callback) ); + _ligatures_discretionary.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::ligatures_callback) ); + _ligatures_historical.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::ligatures_callback) ); + _ligatures_contextual.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::ligatures_callback) ); + _ligatures_vbox.add( _ligatures_common ); + _ligatures_vbox.add( _ligatures_discretionary ); + _ligatures_vbox.add( _ligatures_historical ); + _ligatures_vbox.add( _ligatures_contextual ); + _ligatures_frame.add( _ligatures_vbox ); + add( _ligatures_frame ); + + ligatures_init(); + + // Position ---------------------------------- + _position_vbox.add( _position_normal ); + _position_vbox.add( _position_sub ); + _position_vbox.add( _position_super ); + _position_frame.add( _position_vbox ); + add( _position_frame ); + + // Group buttons + Gtk::RadioButton::Group position_group = _position_normal.get_group(); + _position_sub.set_group(position_group); + _position_super.set_group(position_group); + _position_normal.signal_pressed().connect ( sigc::mem_fun(*this, &FontVariants::position_callback) ); + _position_sub.signal_pressed().connect ( sigc::mem_fun(*this, &FontVariants::position_callback) ); + _position_super.signal_pressed().connect ( sigc::mem_fun(*this, &FontVariants::position_callback) ); + + position_init(); + + // Caps ---------------------------------- + _caps_vbox.add( _caps_normal ); + _caps_vbox.add( _caps_small ); + _caps_vbox.add( _caps_all_small ); + _caps_vbox.add( _caps_petite ); + _caps_vbox.add( _caps_all_petite ); + _caps_vbox.add( _caps_unicase ); + _caps_vbox.add( _caps_titling ); + _caps_frame.add( _caps_vbox ); + add( _caps_frame ); + + // Group buttons + Gtk::RadioButton::Group caps_group = _caps_normal.get_group(); + _caps_small.set_group(caps_group); + _caps_all_small.set_group(caps_group); + _caps_petite.set_group(caps_group); + _caps_all_petite.set_group(caps_group); + _caps_unicase.set_group(caps_group); + _caps_titling.set_group(caps_group); + _caps_normal.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) ); + _caps_small.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) ); + _caps_all_small.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) ); + _caps_petite.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) ); + _caps_all_petite.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) ); + _caps_unicase.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) ); + _caps_titling.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) ); + + caps_init(); + + // Numeric ------------------------------ + _numeric_stylebox.add( _numeric_default_style ); + _numeric_stylebox.add( _numeric_lining ); + _numeric_stylebox.add( _numeric_old_style ); + _numeric_vbox.add( _numeric_stylebox ); + _numeric_widthbox.add( _numeric_default_width ); + _numeric_widthbox.add( _numeric_proportional ); + _numeric_widthbox.add( _numeric_tabular ); + _numeric_vbox.add( _numeric_widthbox ); + _numeric_fractionbox.add( _numeric_default_fractions ); + _numeric_fractionbox.add( _numeric_diagonal ); + _numeric_fractionbox.add( _numeric_stacked ); + _numeric_vbox.add( _numeric_fractionbox ); + _numeric_vbox.add( _numeric_ordinal ); + _numeric_vbox.add( _numeric_slashed_zero ); + _numeric_frame.add( _numeric_vbox ); + add( _numeric_frame ); + + // Group buttons + Gtk::RadioButton::Group style_group = _numeric_default_style.get_group(); + _numeric_lining.set_group(style_group); + _numeric_old_style.set_group(style_group); + + Gtk::RadioButton::Group width_group = _numeric_default_width.get_group(); + _numeric_proportional.set_group(width_group); + _numeric_tabular.set_group(width_group); + + Gtk::RadioButton::Group fraction_group = _numeric_default_fractions.get_group(); + _numeric_diagonal.set_group(fraction_group); + _numeric_stacked.set_group(fraction_group); + + show_all_children(); + } + + void + FontVariants::ligatures_init() { + // std::cout << "FontVariants::ligatures_init()" << std::endl; + } + + void + FontVariants::ligatures_callback() { + // std::cout << "FontVariants::ligatures_callback()" << std::endl; + } + + void + FontVariants::position_init() { + // std::cout << "FontVariants::position_init()" << std::endl; + } + + void + FontVariants::position_callback() { + // std::cout << "FontVariants::position_callback()" << std::endl; + } + + void + FontVariants::caps_init() { + // std::cout << "FontVariants::caps_init()" << std::endl; + } + + void + FontVariants::caps_callback() { + // std::cout << "FontVariants::caps_callback()" << std::endl; + } + + void + FontVariants::numeric_init() { + std::cout << "FontVariants::numeric_init()" << std::endl; + // _numeric_tabular.set_inconsistent(); + } + + void + FontVariants::numeric_callback() { + // std::cout << "FontVariants::numeric_callback()" << std::endl; + } + + void + FontVariants::update( unsigned all, unsigned mix ) { + // std::cout << "FontVariants::update" << std::endl; + + _ligatures_common.set_active( all & SP_CSS_FONT_VARIANT_LIGATURES_COMMON ); + _ligatures_discretionary.set_active( all & SP_CSS_FONT_VARIANT_LIGATURES_DISCRETIONARY ); + _ligatures_historical.set_active( all & SP_CSS_FONT_VARIANT_LIGATURES_HISTORICAL ); + _ligatures_contextual.set_active( all & SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL ); + + _ligatures_common.set_inconsistent( mix & SP_CSS_FONT_VARIANT_LIGATURES_COMMON ); + _ligatures_discretionary.set_inconsistent( mix & SP_CSS_FONT_VARIANT_LIGATURES_DISCRETIONARY ); + _ligatures_historical.set_inconsistent( mix & SP_CSS_FONT_VARIANT_LIGATURES_HISTORICAL ); + _ligatures_contextual.set_inconsistent( mix & SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL ); + } + +} // namespace Widget +} // namespace UI +} // namespace Inkscape + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 : diff --git a/src/ui/widget/font-variants.h b/src/ui/widget/font-variants.h new file mode 100644 index 000000000..bef14c4bd --- /dev/null +++ b/src/ui/widget/font-variants.h @@ -0,0 +1,119 @@ +/* + * Author: + * Tavmjong Bah + * + * Copyright (C) 2015 Tavmong Bah + * + * Released under GNU GPL. Read the file 'COPYING' for more information. + */ + +#ifndef INKSCAPE_UI_WIDGET_FONT_VARIANT_H +#define INKSCAPE_UI_WIDGET_FONT_VARIANT_H + +// Temp: both frame and expander +#include +#include +#include +#include + +class SPDesktop; +class SPObject; + +namespace Inkscape { +namespace UI { +namespace Widget { + +/** + * A container for selecting font variants (OpenType Features). + */ +class FontVariants : public Gtk::VBox +{ + +public: + + /** + * Constructor + */ + FontVariants(); + +protected: + // To start, use four check buttons. + Gtk::Expander _ligatures_frame; + Gtk::VBox _ligatures_vbox; + Gtk::CheckButton _ligatures_common; + Gtk::CheckButton _ligatures_discretionary; + Gtk::CheckButton _ligatures_historical; + Gtk::CheckButton _ligatures_contextual; + + // Exclusive options + Gtk::Expander _position_frame; + Gtk::VBox _position_vbox; + Gtk::RadioButton _position_normal; + Gtk::RadioButton _position_sub; + Gtk::RadioButton _position_super; + + // Exclusive options (maybe a dropdown menu to save space?) + Gtk::Expander _caps_frame; + Gtk::VBox _caps_vbox; + Gtk::RadioButton _caps_normal; + Gtk::RadioButton _caps_small; + Gtk::RadioButton _caps_all_small; + Gtk::RadioButton _caps_petite; + Gtk::RadioButton _caps_all_petite; + Gtk::RadioButton _caps_unicase; + Gtk::RadioButton _caps_titling; + + // Complicated! + Gtk::Expander _numeric_frame; + Gtk::VBox _numeric_vbox; + Gtk::HBox _numeric_stylebox; + Gtk::RadioButton _numeric_lining; + Gtk::RadioButton _numeric_old_style; + Gtk::RadioButton _numeric_default_style; + Gtk::HBox _numeric_widthbox; + Gtk::RadioButton _numeric_proportional; + Gtk::RadioButton _numeric_tabular; + Gtk::RadioButton _numeric_default_width; + Gtk::HBox _numeric_fractionbox; + Gtk::RadioButton _numeric_diagonal; + Gtk::RadioButton _numeric_stacked; + Gtk::RadioButton _numeric_default_fractions; + Gtk::CheckButton _numeric_ordinal; + Gtk::CheckButton _numeric_slashed_zero; + +private: + void ligatures_init(); + void ligatures_callback(); + + void position_init(); + void position_callback(); + + void caps_init(); + void caps_callback(); + + void numeric_init(); + void numeric_callback(); + +public: + void update_recursive( SPObject *object ); + void update( unsigned all, unsigned mix ); + +}; + + +} // namespace Widget +} // namespace UI +} // namespace Inkscape + +#endif // INKSCAPE_UI_WIDGET_FONT_VARIANT_H + +/* + Local Variables: + mode:c++ + c-file-style:"stroustrup" + c-file-offsets:((innamespace . 0)(inline-open . 0)) + indent-tabs-mode:nil + fill-column:99 + End: +*/ +// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 : -- cgit v1.2.3 From 5f3d8bb9fbfefd83502fed2c8a7b2a2909a92059 Mon Sep 17 00:00:00 2001 From: su_v Date: Tue, 12 May 2015 22:23:05 +0200 Subject: cmake: fix build with new GUI for font-variant-xxx (r14148) (bzr r14149) --- src/ui/CMakeLists.txt | 2 ++ 1 file changed, 2 insertions(+) (limited to 'src/ui') diff --git a/src/ui/CMakeLists.txt b/src/ui/CMakeLists.txt index 991d11feb..164d74156 100644 --- a/src/ui/CMakeLists.txt +++ b/src/ui/CMakeLists.txt @@ -122,6 +122,7 @@ set(ui_SRC widget/entity-entry.cpp widget/entry.cpp widget/filter-effect-chooser.cpp + widget/font-variants.cpp widget/frame.cpp widget/gimpcolorwheel.c widget/gimpspinscale.c @@ -295,6 +296,7 @@ set(ui_SRC widget/entity-entry.h widget/entry.h widget/filter-effect-chooser.h + widget/font-variants.h widget/frame.h widget/gimpspinscale.h widget/gimpcolorwheel.h -- cgit v1.2.3 From ffd7534dc2d5d718dbc0720c17dda56f57fcd7ed Mon Sep 17 00:00:00 2001 From: Tavmjong Bah Date: Thu, 14 May 2015 07:24:57 +0200 Subject: Enable setting of 'font-variant-ligatures' (rendering waits on new Pango library). (bzr r14152) --- src/ui/dialog/text-edit.cpp | 5 ++++- src/ui/widget/font-variants.cpp | 28 ++++++++++++++++++++++++++++ src/ui/widget/font-variants.h | 3 ++- 3 files changed, 34 insertions(+), 2 deletions(-) (limited to 'src/ui') diff --git a/src/ui/dialog/text-edit.cpp b/src/ui/dialog/text-edit.cpp index 98ea7f9f7..2726d979c 100644 --- a/src/ui/dialog/text-edit.cpp +++ b/src/ui/dialog/text-edit.cpp @@ -517,12 +517,15 @@ SPCSSAttr *TextEdit::fillTextStyle () sp_repr_css_set_property (css, "writing-mode", "tb"); } - // Note that CSS 1.1 does not support line-height; we set it for consistency, but also set + // Note that SVG 1.1 does not support line-height; we set it for consistency, but also set // sodipodi:linespacing for backwards compatibility; in 1.2 we use line-height for flowtext const gchar *sstr = gtk_combo_box_text_get_active_text ((GtkComboBoxText *) spacing_combo); sp_repr_css_set_property (css, "line-height", sstr); + // Font variants + vari_vbox.fill_css( css ); + return css; } diff --git a/src/ui/widget/font-variants.cpp b/src/ui/widget/font-variants.cpp index 46fbc2aa4..7da7662e2 100644 --- a/src/ui/widget/font-variants.cpp +++ b/src/ui/widget/font-variants.cpp @@ -27,6 +27,7 @@ #include "sp-tref.h" #include "sp-textpath.h" #include "sp-item-group.h" +#include "xml/repr.h" namespace Inkscape { namespace UI { @@ -230,6 +231,33 @@ namespace Widget { _ligatures_contextual.set_inconsistent( mix & SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL ); } + void + FontVariants::fill_css( SPCSSAttr *css ) { + + // Ligatures + bool common = _ligatures_common.get_active(); + bool discretionary = _ligatures_discretionary.get_active(); + bool historical = _ligatures_historical.get_active(); + bool contextual = _ligatures_contextual.get_active(); + + if( !common && !discretionary && !historical && !contextual ) { + sp_repr_css_set_property(css, "font-variant-ligatures", "none" ); + } else if ( common && !discretionary && !historical && contextual ) { + sp_repr_css_set_property(css, "font-variant-ligatures", "normal" ); + } else { + Glib::ustring css_string; + if ( !common ) + css_string += "no-common-ligatures "; + if ( discretionary ) + css_string += "discretionary-ligatures "; + if ( historical ) + css_string += "historical-ligatures "; + if ( !contextual ) + css_string += "no-contextual "; + sp_repr_css_set_property(css, "font-variant-ligatures", css_string.c_str() ); + } + } + } // namespace Widget } // namespace UI } // namespace Inkscape diff --git a/src/ui/widget/font-variants.h b/src/ui/widget/font-variants.h index bef14c4bd..f58b80f34 100644 --- a/src/ui/widget/font-variants.h +++ b/src/ui/widget/font-variants.h @@ -18,6 +18,7 @@ class SPDesktop; class SPObject; +class SPCSSAttr; namespace Inkscape { namespace UI { @@ -95,9 +96,9 @@ private: void numeric_callback(); public: - void update_recursive( SPObject *object ); void update( unsigned all, unsigned mix ); + void fill_css( SPCSSAttr* css ); }; -- cgit v1.2.3 From ddf9853ed86846c5cc4e22a1ede31dafcda5c99d Mon Sep 17 00:00:00 2001 From: Tavmjong Bah Date: Sat, 16 May 2015 14:50:10 +0200 Subject: Enable setting of 'font-variant-position' and 'font-variant-caps'. Rendering awaits Pango update. (bzr r14155) --- src/ui/dialog/text-edit.cpp | 2 +- src/ui/widget/font-variants.cpp | 121 ++++++++++++++++++++++++++++++++++++---- src/ui/widget/font-variants.h | 19 ++++++- 3 files changed, 130 insertions(+), 12 deletions(-) (limited to 'src/ui') diff --git a/src/ui/dialog/text-edit.cpp b/src/ui/dialog/text-edit.cpp index 2726d979c..4fd227f01 100644 --- a/src/ui/dialog/text-edit.cpp +++ b/src/ui/dialog/text-edit.cpp @@ -389,7 +389,7 @@ void TextEdit::onReadSelection ( gboolean dostyle, gboolean /*docontent*/ ) // Update font variant widget //int result_variants = sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_FONTVARIANTS); - vari_vbox.update( query.font_variant_ligatures.computed, query.font_variant_ligatures.value ); + vari_vbox.update( &query ); } blocked = false; diff --git a/src/ui/widget/font-variants.cpp b/src/ui/widget/font-variants.cpp index 7da7662e2..8ca926d8f 100644 --- a/src/ui/widget/font-variants.cpp +++ b/src/ui/widget/font-variants.cpp @@ -66,8 +66,12 @@ namespace Widget { _numeric_stacked ( Glib::ustring(_("Stacked" )) ), _numeric_default_fractions( Glib::ustring(_("Default Fractions")) ), _numeric_ordinal ( Glib::ustring(_("Ordinal" )) ), - _numeric_slashed_zero ( Glib::ustring(_("Slashed Zero" )) ) + _numeric_slashed_zero ( Glib::ustring(_("Slashed Zero" )) ), + _ligatures_changed( false ), + _position_changed( false ), + _caps_changed( false ), + _numeric_changed( false ) { @@ -183,6 +187,7 @@ namespace Widget { void FontVariants::ligatures_callback() { // std::cout << "FontVariants::ligatures_callback()" << std::endl; + _ligatures_changed = true; } void @@ -193,6 +198,7 @@ namespace Widget { void FontVariants::position_callback() { // std::cout << "FontVariants::position_callback()" << std::endl; + _position_changed = true; } void @@ -203,6 +209,7 @@ namespace Widget { void FontVariants::caps_callback() { // std::cout << "FontVariants::caps_callback()" << std::endl; + _caps_changed = true; } void @@ -214,21 +221,61 @@ namespace Widget { void FontVariants::numeric_callback() { // std::cout << "FontVariants::numeric_callback()" << std::endl; + _numeric_changed = true; } + // Update GUI based on query. void - FontVariants::update( unsigned all, unsigned mix ) { + FontVariants::update( SPStyle const *query ) { // std::cout << "FontVariants::update" << std::endl; - _ligatures_common.set_active( all & SP_CSS_FONT_VARIANT_LIGATURES_COMMON ); - _ligatures_discretionary.set_active( all & SP_CSS_FONT_VARIANT_LIGATURES_DISCRETIONARY ); - _ligatures_historical.set_active( all & SP_CSS_FONT_VARIANT_LIGATURES_HISTORICAL ); - _ligatures_contextual.set_active( all & SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL ); + _ligatures_all = query->font_variant_ligatures.computed; + _ligatures_mix = query->font_variant_ligatures.value; + + _ligatures_common.set_active( _ligatures_all & SP_CSS_FONT_VARIANT_LIGATURES_COMMON ); + _ligatures_discretionary.set_active(_ligatures_all & SP_CSS_FONT_VARIANT_LIGATURES_DISCRETIONARY ); + _ligatures_historical.set_active( _ligatures_all & SP_CSS_FONT_VARIANT_LIGATURES_HISTORICAL ); + _ligatures_contextual.set_active( _ligatures_all & SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL ); + + _ligatures_common.set_inconsistent( _ligatures_mix & SP_CSS_FONT_VARIANT_LIGATURES_COMMON ); + _ligatures_discretionary.set_inconsistent( _ligatures_mix & SP_CSS_FONT_VARIANT_LIGATURES_DISCRETIONARY ); + _ligatures_historical.set_inconsistent( _ligatures_mix & SP_CSS_FONT_VARIANT_LIGATURES_HISTORICAL ); + _ligatures_contextual.set_inconsistent( _ligatures_mix & SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL ); + + _position_all = query->font_variant_position.computed; + _position_mix = query->font_variant_position.value; - _ligatures_common.set_inconsistent( mix & SP_CSS_FONT_VARIANT_LIGATURES_COMMON ); - _ligatures_discretionary.set_inconsistent( mix & SP_CSS_FONT_VARIANT_LIGATURES_DISCRETIONARY ); - _ligatures_historical.set_inconsistent( mix & SP_CSS_FONT_VARIANT_LIGATURES_HISTORICAL ); - _ligatures_contextual.set_inconsistent( mix & SP_CSS_FONT_VARIANT_LIGATURES_CONTEXTUAL ); + _position_normal.set_active( _position_all & SP_CSS_FONT_VARIANT_POSITION_NORMAL ); + _position_sub.set_active( _position_all & SP_CSS_FONT_VARIANT_POSITION_SUB ); + _position_super.set_active( _position_all & SP_CSS_FONT_VARIANT_POSITION_SUPER ); + + _position_normal.set_inconsistent( _position_mix & SP_CSS_FONT_VARIANT_POSITION_NORMAL ); + _position_sub.set_inconsistent( _position_mix & SP_CSS_FONT_VARIANT_POSITION_SUB ); + _position_super.set_inconsistent( _position_mix & SP_CSS_FONT_VARIANT_POSITION_SUPER ); + + unsigned _caps_all = query->font_variant_caps.computed; + unsigned _caps_mix = query->font_variant_caps.value; + + _caps_normal.set_active( _caps_all & SP_CSS_FONT_VARIANT_CAPS_NORMAL ); + _caps_small.set_active( _caps_all & SP_CSS_FONT_VARIANT_CAPS_SMALL ); + _caps_all_small.set_active( _caps_all & SP_CSS_FONT_VARIANT_CAPS_ALL_SMALL ); + _caps_petite.set_active( _caps_all & SP_CSS_FONT_VARIANT_CAPS_PETITE ); + _caps_all_petite.set_active( _caps_all & SP_CSS_FONT_VARIANT_CAPS_ALL_PETITE ); + _caps_unicase.set_active( _caps_all & SP_CSS_FONT_VARIANT_CAPS_UNICASE ); + _caps_titling.set_active( _caps_all & SP_CSS_FONT_VARIANT_CAPS_TITLING ); + + _caps_normal.set_inconsistent( _caps_mix & SP_CSS_FONT_VARIANT_CAPS_NORMAL ); + _caps_small.set_inconsistent( _caps_mix & SP_CSS_FONT_VARIANT_CAPS_SMALL ); + _caps_all_small.set_inconsistent( _caps_mix & SP_CSS_FONT_VARIANT_CAPS_ALL_SMALL ); + _caps_petite.set_inconsistent( _caps_mix & SP_CSS_FONT_VARIANT_CAPS_PETITE ); + _caps_all_petite.set_inconsistent( _caps_mix & SP_CSS_FONT_VARIANT_CAPS_ALL_PETITE ); + _caps_unicase.set_inconsistent( _caps_mix & SP_CSS_FONT_VARIANT_CAPS_UNICASE ); + _caps_titling.set_inconsistent( _caps_mix & SP_CSS_FONT_VARIANT_CAPS_TITLING ); + + _ligatures_changed = false; + _position_changed = false; + _caps_changed = false; + _numeric_changed = false; } void @@ -256,6 +303,60 @@ namespace Widget { css_string += "no-contextual "; sp_repr_css_set_property(css, "font-variant-ligatures", css_string.c_str() ); } + + // Position + { + unsigned position_new = SP_CSS_FONT_VARIANT_POSITION_NORMAL; + Glib::ustring css_string; + if( _position_normal.get_active() ) { + css_string = "normal"; + } else if( _position_sub.get_active() ) { + css_string = "sub"; + position_new = SP_CSS_FONT_VARIANT_POSITION_SUB; + } else if( _position_super.get_active() ) { + css_string = "super"; + position_new = SP_CSS_FONT_VARIANT_POSITION_SUPER; + } + + // 'if' may not be necessary... need to test. + if( (_position_all != position_new) || ((_position_mix != 0) && _position_changed) ) { + sp_repr_css_set_property(css, "font-variant-position", css_string.c_str() ); + } + } + + // Caps + { + unsigned caps_new = SP_CSS_FONT_VARIANT_CAPS_NORMAL; + Glib::ustring css_string; + if( _caps_normal.get_active() ) { + css_string = "normal"; + caps_new = SP_CSS_FONT_VARIANT_CAPS_NORMAL; + } else if( _caps_small.get_active() ) { + css_string = "small-caps"; + caps_new = SP_CSS_FONT_VARIANT_CAPS_SMALL; + } else if( _caps_all_small.get_active() ) { + css_string = "all-small-caps"; + caps_new = SP_CSS_FONT_VARIANT_CAPS_ALL_SMALL; + } else if( _caps_all_petite.get_active() ) { + css_string = "petite"; + caps_new = SP_CSS_FONT_VARIANT_CAPS_PETITE; + } else if( _caps_all_petite.get_active() ) { + css_string = "all-petite"; + caps_new = SP_CSS_FONT_VARIANT_CAPS_ALL_PETITE; + } else if( _caps_unicase.get_active() ) { + css_string = "unicase"; + caps_new = SP_CSS_FONT_VARIANT_CAPS_UNICASE; + } else if( _caps_titling.get_active() ) { + css_string = "titling"; + caps_new = SP_CSS_FONT_VARIANT_CAPS_TITLING; + } + + // May not be necessary... need to test. + //if( (_caps_all != caps_new) || ((_caps_mix != 0) && _caps_changed) ) { + sp_repr_css_set_property(css, "font-variant-caps", css_string.c_str() ); + //} + } + } } // namespace Widget diff --git a/src/ui/widget/font-variants.h b/src/ui/widget/font-variants.h index f58b80f34..04c05d3c6 100644 --- a/src/ui/widget/font-variants.h +++ b/src/ui/widget/font-variants.h @@ -18,6 +18,7 @@ class SPDesktop; class SPObject; +class SPStyle; class SPCSSAttr; namespace Inkscape { @@ -95,8 +96,24 @@ private: void numeric_init(); void numeric_callback(); + // To determine if we need to write out property (may not be necessary) + unsigned _ligatures_all; + unsigned _position_all; + unsigned _caps_all; + unsigned _numeric_all; + + unsigned _ligatures_mix; + unsigned _position_mix; + unsigned _caps_mix; + unsigned _numeric_mix; + + bool _ligatures_changed; + bool _position_changed; + bool _caps_changed; + bool _numeric_changed; + public: - void update( unsigned all, unsigned mix ); + void update( SPStyle const *query ); void fill_css( SPCSSAttr* css ); }; -- cgit v1.2.3 From a1a3b4c11831f2a81201863556058fefcb741f4d Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sun, 17 May 2015 12:10:12 +0200 Subject: fixed: color scales - extra row in RGB mode (bzr r14059.1.28) --- src/ui/widget/color-scales.cpp | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'src/ui') diff --git a/src/ui/widget/color-scales.cpp b/src/ui/widget/color-scales.cpp index ead636406..b940acbc7 100644 --- a/src/ui/widget/color-scales.cpp +++ b/src/ui/widget/color-scales.cpp @@ -165,6 +165,11 @@ void ColorScales::_initUI(SPColorScalesMode mode) _s[i]->signal_value_changed.connect(sigc::mem_fun(this, &ColorScales::_sliderAnyChanged)); } + //Prevent 5th bar from being shown by PanelDialog::show_all_children + gtk_widget_set_no_show_all(_l[4], TRUE); + _s[4]->set_no_show_all(true); + gtk_widget_set_no_show_all(_b[4], TRUE); + /* Initial mode is none, so it works */ setMode(mode); } -- cgit v1.2.3 From 279bb517e59386cc3a5b299cafb78c0eb81cbedd Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sun, 17 May 2015 13:33:31 +0200 Subject: fixed: color scales - updating color when switched from undefined (bzr r14059.1.29) --- src/ui/selected-color.cpp | 13 +++---- src/ui/widget/color-icc-selector.cpp | 19 ++++++++-- src/ui/widget/color-icc-selector.h | 2 + src/ui/widget/color-scales.cpp | 69 +++++++++++++++++++++------------- src/ui/widget/color-scales.h | 2 + src/ui/widget/color-wheel-selector.cpp | 57 +++++++++++++++++----------- src/ui/widget/color-wheel-selector.h | 4 +- 7 files changed, 107 insertions(+), 59 deletions(-) (limited to 'src/ui') diff --git a/src/ui/selected-color.cpp b/src/ui/selected-color.cpp index 6573129d3..8c37ee7e0 100644 --- a/src/ui/selected-color.cpp +++ b/src/ui/selected-color.cpp @@ -75,7 +75,7 @@ guint32 SelectedColor::value() const void SelectedColor::setColorAlpha(SPColor const &color, gfloat alpha, bool emit_signal) { #ifdef DUMP_CHANGE_INFO - g_message("SelectedColor::setColorAlpha( this=%p, %f, %f, %f, %s, %f, %s) in %s", this, color.v.c[0], color.v.c[1], color.v.c[2], (color.icc?color.icc->colorProfile.c_str():""), alpha, (emit?"YES":"no"), FOO_NAME(_csel)); + g_message("SelectedColor::setColorAlpha( this=%p, %f, %f, %f, %s, %f, %s)", this, color.v.c[0], color.v.c[1], color.v.c[2], (color.icc?color.icc->colorProfile.c_str():""), alpha, (emit_signal?"YES":"no")); #endif g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) ); @@ -84,11 +84,10 @@ void SelectedColor::setColorAlpha(SPColor const &color, gfloat alpha, bool emit_ } #ifdef DUMP_CHANGE_INFO - g_message("---- SelectedColor::setColorAlpha virgin:%s !close:%s alpha is:%s in %s", + g_message("---- SelectedColor::setColorAlpha virgin:%s !close:%s alpha is:%s", (_virgin?"YES":"no"), - (!color.isClose( _color, _epsilon )?"YES":"no"), - ((fabs((_alpha) - (alpha)) >= _epsilon )?"YES":"no"), - FOO_NAME(_csel) + (!color.isClose( _color, _EPSILON )?"YES":"no"), + ((fabs((_alpha) - (alpha)) >= _EPSILON )?"YES":"no") ); #endif @@ -113,8 +112,8 @@ void SelectedColor::setColorAlpha(SPColor const &color, gfloat alpha, bool emit_ #ifdef DUMP_CHANGE_INFO } else { - g_message("++++ SelectedColor::setColorAlpha color:%08x ==> _color:%08X isClose:%s in %s", color.toRGBA32(alpha), _color.toRGBA32(_alpha), - (color.isClose( _color, _epsilon )?"YES":"no"), FOO_NAME(_csel)); + g_message("++++ SelectedColor::setColorAlpha color:%08x ==> _color:%08X isClose:%s", color.toRGBA32(alpha), _color.toRGBA32(_alpha), + (color.isClose( _color, _EPSILON )?"YES":"no")); #endif } } diff --git a/src/ui/widget/color-icc-selector.cpp b/src/ui/widget/color-icc-selector.cpp index a7e75bfc5..2c00ba081 100644 --- a/src/ui/widget/color-icc-selector.cpp +++ b/src/ui/widget/color-icc-selector.cpp @@ -366,8 +366,6 @@ void ColorICCSelector::init() GtkWidget *t = GTK_WIDGET(gobj()); - gtk_widget_show(t); - _impl->_compUI.clear(); // Create components @@ -523,6 +521,8 @@ void ColorICCSelector::init() _impl->_slider->signal_grabbed.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderGrabbed)); _impl->_slider->signal_released.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderReleased)); _impl->_slider->signal_value_changed.connect(sigc::mem_fun(_impl, &ColorICCSelectorImpl::_sliderChanged)); + + gtk_widget_show(t); } void ColorICCSelectorImpl::_fixupHit(GtkWidget * /*src*/, gpointer data) @@ -696,6 +696,16 @@ void ColorICCSelectorImpl::_profilesChanged(std::string const &name) void ColorICCSelectorImpl::_profilesChanged(std::string const & /*name*/) {} #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) +void ColorICCSelector::on_show() +{ +#if GTK_CHECK_VERSION(3, 0, 0) + Gtk::Grid::on_show(); +#else + Gtk::Table::on_show(); +#endif + _colorChanged(); +} + // Helpers for setting color value void ColorICCSelector::_colorChanged() @@ -894,7 +904,10 @@ void ColorICCSelectorImpl::_updateSliders(gint ignore) cmsHTRANSFORM trans = _prof->getTransfToSRGB8(); if (trans) { cmsDoTransform(trans, scratch, _compUI[i]._map, 1024); - _compUI[i]._slider->setMap(_compUI[i]._map); + if (_compUI[i]._slider) + { + _compUI[i]._slider->setMap(_compUI[i]._map); + } } } } diff --git a/src/ui/widget/color-icc-selector.h b/src/ui/widget/color-icc-selector.h index 37201de3b..1bcb0a540 100644 --- a/src/ui/widget/color-icc-selector.h +++ b/src/ui/widget/color-icc-selector.h @@ -39,6 +39,8 @@ class ColorICCSelector virtual void init(); protected: + void on_show(); + virtual void _colorChanged(); void _recalcColor(gboolean changing); diff --git a/src/ui/widget/color-scales.cpp b/src/ui/widget/color-scales.cpp index b940acbc7..170f83887 100644 --- a/src/ui/widget/color-scales.cpp +++ b/src/ui/widget/color-scales.cpp @@ -205,34 +205,8 @@ void ColorScales::_recalcColor() _color.setColorAlpha(color, alpha); } -/* Helpers for setting color value */ -gfloat ColorScales::getScaled(const GtkAdjustment *a) -{ - gfloat val = gtk_adjustment_get_value(const_cast(a)) / - gtk_adjustment_get_upper(const_cast(a)); - return val; -} - -void ColorScales::setScaled(GtkAdjustment *a, gfloat v) -{ - gfloat val = v * gtk_adjustment_get_upper(a); - gtk_adjustment_set_value(a, val); -} - -void ColorScales::_setRangeLimit(gdouble upper) -{ - _rangeLimit = upper; - for (gint i = 0; i < static_cast(G_N_ELEMENTS(_a)); i++) { - gtk_adjustment_set_upper(_a[i], upper); - gtk_adjustment_changed(_a[i]); - } -} - -void ColorScales::_onColorChanged() +void ColorScales::_updateDisplay() { - if (!get_visible()) { - return; - } #ifdef DUMP_CHANGE_INFO g_message("ColorScales::_onColorChanged( this=%p, %f, %f, %f, %f)", this, _color.color().v.c[0], _color.color().v.c[1], _color.color().v.c[2], _color.alpha()); @@ -273,6 +247,47 @@ void ColorScales::_onColorChanged() _updating = FALSE; } +/* Helpers for setting color value */ +gfloat ColorScales::getScaled(const GtkAdjustment *a) +{ + gfloat val = gtk_adjustment_get_value(const_cast(a)) / + gtk_adjustment_get_upper(const_cast(a)); + return val; +} + +void ColorScales::setScaled(GtkAdjustment *a, gfloat v) +{ + gfloat val = v * gtk_adjustment_get_upper(a); + gtk_adjustment_set_value(a, val); +} + +void ColorScales::_setRangeLimit(gdouble upper) +{ + _rangeLimit = upper; + for (gint i = 0; i < static_cast(G_N_ELEMENTS(_a)); i++) { + gtk_adjustment_set_upper(_a[i], upper); + gtk_adjustment_changed(_a[i]); + } +} + +void ColorScales::_onColorChanged() +{ + if (!get_visible()) { + return; + } + _updateDisplay(); +} + +void ColorScales::on_show() +{ +#if GTK_CHECK_VERSION(3, 0, 0) + Gtk::Grid::on_show(); +#else + Gtk::Table::on_show(); +#endif + _updateDisplay(); +} + void ColorScales::_getRgbaFloatv(gfloat *rgba) { g_return_if_fail(rgba != NULL); diff --git a/src/ui/widget/color-scales.h b/src/ui/widget/color-scales.h index 025f92e2d..aeacfbcc1 100644 --- a/src/ui/widget/color-scales.h +++ b/src/ui/widget/color-scales.h @@ -49,6 +49,7 @@ public: protected: void _onColorChanged(); + void on_show(); static void _adjustmentAnyChanged(GtkAdjustment *adjustment, ColorScales *cs); void _sliderAnyGrabbed(); @@ -61,6 +62,7 @@ protected: guint32 _getRgba32(); void _updateSliders(guint channels); void _recalcColor(); + void _updateDisplay(); void _setRangeLimit(gdouble upper); diff --git a/src/ui/widget/color-wheel-selector.cpp b/src/ui/widget/color-wheel-selector.cpp index 8c6402d90..ed3400bb5 100644 --- a/src/ui/widget/color-wheel-selector.cpp +++ b/src/ui/widget/color-wheel-selector.cpp @@ -170,30 +170,19 @@ void ColorWheelSelector::_initUI() g_signal_connect(G_OBJECT(_wheel), "changed", G_CALLBACK(_wheelChanged), this); } -void ColorWheelSelector::_colorChanged() +void ColorWheelSelector::on_show() { -#ifdef DUMP_CHANGE_INFO - g_message("ColorWheelSelector::_colorChanged( this=%p, %f, %f, %f, %f)", this, _color.color().v.c[0], - _color.color().v.c[1], _color.color().v.c[2], alpha); +#if GTK_CHECK_VERSION(3, 0, 0) + Gtk::Grid::on_show(); +#else + Gtk::Table::on_show(); #endif + _updateDisplay(); +} - bool oldval = _updating; - _updating = true; - { - float hsv[3] = { 0, 0, 0 }; - sp_color_rgb_to_hsv_floatv(hsv, _color.color().v.c[0], _color.color().v.c[1], _color.color().v.c[2]); - gimp_color_wheel_set_color(GIMP_COLOR_WHEEL(_wheel), hsv[0], hsv[1], hsv[2]); - } - - guint32 start = _color.color().toRGBA32(0x00); - guint32 mid = _color.color().toRGBA32(0x7f); - guint32 end = _color.color().toRGBA32(0xff); - - _slider->setColors(start, mid, end); - - ColorScales::setScaled(_alpha_adjustment->gobj(), _color.alpha()); - - _updating = oldval; +void ColorWheelSelector::_colorChanged() +{ + _updateDisplay(); } void ColorWheelSelector::_adjustmentChanged() @@ -264,6 +253,32 @@ void ColorWheelSelector::_wheelChanged(GimpColorWheel *wheel, ColorWheelSelector wheelSelector->_color.setColor(color); } +void ColorWheelSelector::_updateDisplay() +{ +#ifdef DUMP_CHANGE_INFO + g_message("ColorWheelSelector::_colorChanged( this=%p, %f, %f, %f, %f)", this, _color.color().v.c[0], + _color.color().v.c[1], _color.color().v.c[2], alpha); +#endif + + bool oldval = _updating; + _updating = true; + { + float hsv[3] = { 0, 0, 0 }; + sp_color_rgb_to_hsv_floatv(hsv, _color.color().v.c[0], _color.color().v.c[1], _color.color().v.c[2]); + gimp_color_wheel_set_color(GIMP_COLOR_WHEEL(_wheel), hsv[0], hsv[1], hsv[2]); + } + + guint32 start = _color.color().toRGBA32(0x00); + guint32 mid = _color.color().toRGBA32(0x7f); + guint32 end = _color.color().toRGBA32(0xff); + + _slider->setColors(start, mid, end); + + ColorScales::setScaled(_alpha_adjustment->gobj(), _color.alpha()); + + _updating = oldval; +} + Gtk::Widget *ColorWheelSelectorFactory::createWidget(Inkscape::UI::SelectedColor &color) const { diff --git a/src/ui/widget/color-wheel-selector.h b/src/ui/widget/color-wheel-selector.h index f97f70f6a..5711d417c 100644 --- a/src/ui/widget/color-wheel-selector.h +++ b/src/ui/widget/color-wheel-selector.h @@ -48,6 +48,8 @@ public: protected: void _initUI(); + void on_show(); + void _colorChanged(); void _adjustmentChanged(); void _sliderGrabbed(); @@ -55,7 +57,7 @@ protected: void _sliderChanged(); static void _wheelChanged(GimpColorWheel *wheel, ColorWheelSelector *cs); - void _recalcColor(gboolean changing); + void _updateDisplay(); SelectedColor &_color; bool _updating; -- cgit v1.2.3 From e6770f0bb8829e60c6a8babddeb7104dcc50fea8 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sun, 17 May 2015 13:43:24 +0200 Subject: fixed: color icc selector - extra rows on startup (bzr r14059.1.30) --- src/ui/widget/color-icc-selector.cpp | 3 +++ 1 file changed, 3 insertions(+) (limited to 'src/ui') diff --git a/src/ui/widget/color-icc-selector.cpp b/src/ui/widget/color-icc-selector.cpp index 2c00ba081..1c31ae33a 100644 --- a/src/ui/widget/color-icc-selector.cpp +++ b/src/ui/widget/color-icc-selector.cpp @@ -433,6 +433,7 @@ void ColorICCSelector::init() _impl->_compUI[i]._label = gtk_label_new_with_mnemonic(labelStr.c_str()); gtk_misc_set_alignment(GTK_MISC(_impl->_compUI[i]._label), 1.0, 0.5); gtk_widget_show(_impl->_compUI[i]._label); + gtk_widget_set_no_show_all(_impl->_compUI[i]._label, TRUE); attachToGridOrTable(t, _impl->_compUI[i]._label, 0, row, 1, 1); @@ -452,6 +453,7 @@ void ColorICCSelector::init() _impl->_compUI[i]._slider->set_tooltip_text("."); #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) _impl->_compUI[i]._slider->show(); + _impl->_compUI[i]._slider->set_no_show_all(); attachToGridOrTable(t, _impl->_compUI[i]._slider->gobj(), 1, row, 1, 1, true); @@ -464,6 +466,7 @@ void ColorICCSelector::init() sp_dialog_defocus_on_enter(_impl->_compUI[i]._btn); gtk_label_set_mnemonic_widget(GTK_LABEL(_impl->_compUI[i]._label), _impl->_compUI[i]._btn); gtk_widget_show(_impl->_compUI[i]._btn); + gtk_widget_set_no_show_all(_impl->_compUI[i]._btn, TRUE); attachToGridOrTable(t, _impl->_compUI[i]._btn, 2, row, 1, 1, false, true); -- cgit v1.2.3 From 7c7e740dd76054367ceae7f545ac27f0d7cdc7f0 Mon Sep 17 00:00:00 2001 From: Tavmjong Bah Date: Mon, 18 May 2015 21:50:54 +0200 Subject: Enable setting of 'font-variant-ligatures' (rendering waits on new Pango library). (bzr r14162) --- src/ui/widget/font-variants.cpp | 87 ++++++++++++++++++++++++++++++++++++++--- 1 file changed, 82 insertions(+), 5 deletions(-) (limited to 'src/ui') diff --git a/src/ui/widget/font-variants.cpp b/src/ui/widget/font-variants.cpp index 8ca926d8f..56c24ea6f 100644 --- a/src/ui/widget/font-variants.cpp +++ b/src/ui/widget/font-variants.cpp @@ -214,8 +214,7 @@ namespace Widget { void FontVariants::numeric_init() { - std::cout << "FontVariants::numeric_init()" << std::endl; - // _numeric_tabular.set_inconsistent(); + // std::cout << "FontVariants::numeric_init()" << std::endl; } void @@ -227,7 +226,6 @@ namespace Widget { // Update GUI based on query. void FontVariants::update( SPStyle const *query ) { - // std::cout << "FontVariants::update" << std::endl; _ligatures_all = query->font_variant_ligatures.computed; _ligatures_mix = query->font_variant_ligatures.value; @@ -253,8 +251,8 @@ namespace Widget { _position_sub.set_inconsistent( _position_mix & SP_CSS_FONT_VARIANT_POSITION_SUB ); _position_super.set_inconsistent( _position_mix & SP_CSS_FONT_VARIANT_POSITION_SUPER ); - unsigned _caps_all = query->font_variant_caps.computed; - unsigned _caps_mix = query->font_variant_caps.value; + _caps_all = query->font_variant_caps.computed; + _caps_mix = query->font_variant_caps.value; _caps_normal.set_active( _caps_all & SP_CSS_FONT_VARIANT_CAPS_NORMAL ); _caps_small.set_active( _caps_all & SP_CSS_FONT_VARIANT_CAPS_SMALL ); @@ -272,6 +270,46 @@ namespace Widget { _caps_unicase.set_inconsistent( _caps_mix & SP_CSS_FONT_VARIANT_CAPS_UNICASE ); _caps_titling.set_inconsistent( _caps_mix & SP_CSS_FONT_VARIANT_CAPS_TITLING ); + _numeric_all = query->font_variant_numeric.computed; + _numeric_mix = query->font_variant_numeric.value; + + if (_numeric_all & SP_CSS_FONT_VARIANT_NUMERIC_LINING_NUMS) { + _numeric_lining.set_active(); + } else if (_numeric_all & SP_CSS_FONT_VARIANT_NUMERIC_OLDSTYLE_NUMS) { + _numeric_old_style.set_active(); + } else { + _numeric_default_style.set_active(); + } + + if (_numeric_all & SP_CSS_FONT_VARIANT_NUMERIC_PROPORTIONAL_NUMS) { + _numeric_proportional.set_active(); + } else if (_numeric_all & SP_CSS_FONT_VARIANT_NUMERIC_TABULAR_NUMS) { + _numeric_tabular.set_active(); + } else { + _numeric_default_width.set_active(); + } + + if (_numeric_all & SP_CSS_FONT_VARIANT_NUMERIC_DIAGONAL_FRACTIONS) { + _numeric_diagonal.set_active(); + } else if (_numeric_all & SP_CSS_FONT_VARIANT_NUMERIC_STACKED_FRACTIONS) { + _numeric_stacked.set_active(); + } else { + _numeric_default_fractions.set_active(); + } + + _numeric_ordinal.set_active( _numeric_all & SP_CSS_FONT_VARIANT_NUMERIC_ORDINAL ); + _numeric_slashed_zero.set_active( _numeric_all & SP_CSS_FONT_VARIANT_NUMERIC_SLASHED_ZERO ); + + + _numeric_lining.set_inconsistent( _numeric_mix & SP_CSS_FONT_VARIANT_NUMERIC_LINING_NUMS ); + _numeric_old_style.set_inconsistent( _numeric_mix & SP_CSS_FONT_VARIANT_NUMERIC_OLDSTYLE_NUMS ); + _numeric_proportional.set_inconsistent( _numeric_mix & SP_CSS_FONT_VARIANT_NUMERIC_PROPORTIONAL_NUMS ); + _numeric_tabular.set_inconsistent( _numeric_mix & SP_CSS_FONT_VARIANT_NUMERIC_TABULAR_NUMS ); + _numeric_diagonal.set_inconsistent( _numeric_mix & SP_CSS_FONT_VARIANT_NUMERIC_DIAGONAL_FRACTIONS ); + _numeric_stacked.set_inconsistent( _numeric_mix & SP_CSS_FONT_VARIANT_NUMERIC_STACKED_FRACTIONS ); + _numeric_ordinal.set_inconsistent( _numeric_mix & SP_CSS_FONT_VARIANT_NUMERIC_ORDINAL ); + _numeric_slashed_zero.set_inconsistent( _numeric_mix & SP_CSS_FONT_VARIANT_NUMERIC_SLASHED_ZERO ); + _ligatures_changed = false; _position_changed = false; _caps_changed = false; @@ -357,6 +395,45 @@ namespace Widget { //} } + // Numeric + bool default_style = _numeric_default_style.get_active(); + bool lining = _numeric_lining.get_active(); + bool old_style = _numeric_old_style.get_active(); + + bool default_width = _numeric_default_width.get_active(); + bool proportional = _numeric_proportional.get_active(); + bool tabular = _numeric_tabular.get_active(); + + bool default_fractions = _numeric_default_fractions.get_active(); + bool diagonal = _numeric_diagonal.get_active(); + bool stacked = _numeric_stacked.get_active(); + + bool ordinal = _numeric_ordinal.get_active(); + bool slashed_zero = _numeric_slashed_zero.get_active(); + + if (default_style & default_width & default_fractions & !ordinal & !slashed_zero) { + sp_repr_css_set_property(css, "font-variant-numeric", "normal"); + } else { + Glib::ustring css_string; + if ( lining ) + css_string += "lining-nums "; + if ( old_style ) + css_string += "oldstyle-nums "; + if ( proportional ) + css_string += "proportional-nums "; + if ( tabular ) + css_string += "tabular-nums "; + if ( diagonal ) + css_string += "diagonal-fractions "; + if ( stacked ) + css_string += "stacked-fractions "; + if ( ordinal ) + css_string += "ordinal "; + if ( slashed_zero ) + css_string += "slashed-zero "; + sp_repr_css_set_property(css, "font-variant-numeric", css_string.c_str() ); + } + } } // namespace Widget -- cgit v1.2.3 From 421d13903f4ae30d1b536788e9b48b69398bf139 Mon Sep 17 00:00:00 2001 From: Tavmjong Bah Date: Wed, 20 May 2015 10:53:59 +0200 Subject: Font-variants widget: Enable 'Apply' button. Add more tooltips. (bzr r14163) --- src/ui/dialog/text-edit.cpp | 15 ++++++ src/ui/dialog/text-edit.h | 13 +++++ src/ui/widget/font-variants.cpp | 114 ++++++++++++++++++++++++++++++---------- src/ui/widget/font-variants.h | 19 ++++++- 4 files changed, 132 insertions(+), 29 deletions(-) (limited to 'src/ui') diff --git a/src/ui/dialog/text-edit.cpp b/src/ui/dialog/text-edit.cpp index 4fd227f01..1a696c820 100644 --- a/src/ui/dialog/text-edit.cpp +++ b/src/ui/dialog/text-edit.cpp @@ -218,6 +218,7 @@ TextEdit::TextEdit() setasdefault_button.signal_clicked().connect(sigc::mem_fun(*this, &TextEdit::onSetDefault)); apply_button.signal_clicked().connect(sigc::mem_fun(*this, &TextEdit::onApply)); close_button.signal_clicked().connect(sigc::bind(_signal_response.make_slot(), GTK_RESPONSE_CLOSE)); + fontVariantChangedConn = vari_vbox.connectChanged(sigc::bind(sigc::ptr_fun(&onFontVariantChange), this)); desktopChangeConn = deskTrack.connectDesktopChanged( sigc::mem_fun(*this, &TextEdit::setTargetDesktop) ); deskTrack.connect(GTK_WIDGET(gobj())); @@ -232,6 +233,7 @@ TextEdit::~TextEdit() selectChangedConn.disconnect(); desktopChangeConn.disconnect(); deskTrack.disconnect(); + fontVariantChangedConn.disconnect(); } void TextEdit::styleButton(Gtk::RadioButton *button, gchar const *tooltip, gchar const *icon_name, Gtk::RadioButton *group_button ) @@ -656,6 +658,19 @@ void TextEdit::onFontChange(SPFontSelector * /*fontsel*/, gchar* fontspec, TextE } +void TextEdit::onFontVariantChange(TextEdit *self) +{ + if( self->blocked ) + return; + + SPItem *text = self->getSelectedTextItem (); + + if (text) { + self->apply_button.set_sensitive ( true ); + } + self->setasdefault_button.set_sensitive ( true ); +} + void TextEdit::onStartOffsetChange(GtkTextBuffer * /*text_buffer*/, TextEdit *self) { SPItem *text = self->getSelectedTextItem(); diff --git a/src/ui/dialog/text-edit.h b/src/ui/dialog/text-edit.h index f088fd337..41f89b3e7 100644 --- a/src/ui/dialog/text-edit.h +++ b/src/ui/dialog/text-edit.h @@ -36,6 +36,7 @@ class SPItem; struct SPFontSelector; +class FontVariants; class font_instance; class SPCSSAttr; @@ -111,6 +112,17 @@ protected: */ static void onFontChange (SPFontSelector *fontsel, gchar* fontspec, TextEdit *self); + /** + * Callback invoked when the user modifies the font variant through the dialog. + * + * onFontChange updates the dialog UI. The subfunction setPreviewText updates the preview label. + * + * @param fontsel pointer to FontVariant (currently not used). + * @param fontspec for the text to be previewed. + * @param self pointer to the current instance of the dialog. + */ + static void onFontVariantChange (TextEdit *self); + /** * Callback invoked when the user modifies the startOffset of text on a path. * @@ -228,6 +240,7 @@ private: sigc::connection selectChangedConn; sigc::connection subselChangedConn; sigc::connection selectModifiedConn; + sigc::connection fontVariantChangedConn; bool blocked; const Glib::ustring samplephrase; diff --git a/src/ui/widget/font-variants.cpp b/src/ui/widget/font-variants.cpp index 56c24ea6f..637631fda 100644 --- a/src/ui/widget/font-variants.cpp +++ b/src/ui/widget/font-variants.cpp @@ -76,6 +76,8 @@ namespace Widget { { // Ligatures -------------------------- + + // Add tooltips _ligatures_common.set_tooltip_text( _("Common ligatures. On by default. OpenType tables: 'liga', 'clig'")); _ligatures_discretionary.set_tooltip_text( @@ -85,11 +87,13 @@ namespace Widget { _ligatures_contextual.set_tooltip_text( _("Contextual forms. On by default. OpenType table: 'calt'")); - + // Add signals _ligatures_common.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::ligatures_callback) ); _ligatures_discretionary.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::ligatures_callback) ); _ligatures_historical.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::ligatures_callback) ); _ligatures_contextual.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::ligatures_callback) ); + + // Add to frame _ligatures_vbox.add( _ligatures_common ); _ligatures_vbox.add( _ligatures_discretionary ); _ligatures_vbox.add( _ligatures_historical ); @@ -100,32 +104,41 @@ namespace Widget { ligatures_init(); // Position ---------------------------------- - _position_vbox.add( _position_normal ); - _position_vbox.add( _position_sub ); - _position_vbox.add( _position_super ); - _position_frame.add( _position_vbox ); - add( _position_frame ); + + // Add tooltips + _position_normal.set_tooltip_text( _("Normal position.")); + _position_sub.set_tooltip_text( _("Subscript. OpenType table: 'subs'") ); + _position_super.set_tooltip_text( _("Superscript. OpenType table: 'sups'") ); // Group buttons Gtk::RadioButton::Group position_group = _position_normal.get_group(); _position_sub.set_group(position_group); _position_super.set_group(position_group); + + // Add signals _position_normal.signal_pressed().connect ( sigc::mem_fun(*this, &FontVariants::position_callback) ); _position_sub.signal_pressed().connect ( sigc::mem_fun(*this, &FontVariants::position_callback) ); _position_super.signal_pressed().connect ( sigc::mem_fun(*this, &FontVariants::position_callback) ); + // Add to frame + _position_vbox.add( _position_normal ); + _position_vbox.add( _position_sub ); + _position_vbox.add( _position_super ); + _position_frame.add( _position_vbox ); + add( _position_frame ); + position_init(); // Caps ---------------------------------- - _caps_vbox.add( _caps_normal ); - _caps_vbox.add( _caps_small ); - _caps_vbox.add( _caps_all_small ); - _caps_vbox.add( _caps_petite ); - _caps_vbox.add( _caps_all_petite ); - _caps_vbox.add( _caps_unicase ); - _caps_vbox.add( _caps_titling ); - _caps_frame.add( _caps_vbox ); - add( _caps_frame ); + + // Add tooltips + _caps_normal.set_tooltip_text( _("Normal capitalization.")); + _caps_small.set_tooltip_text( _("Small-caps (lowercase). OpenType table: 'smcp'")); + _caps_all_small.set_tooltip_text( _("All small-caps (uppercase and lowercase). OpenType tables: 'c2sc' and 'smcp'")); + _caps_petite.set_tooltip_text( _("Petite-caps (lowercase). OpenType table: 'pcap'")); + _caps_all_petite.set_tooltip_text( _("All petite-caps (uppercase and lowercase). OpenType tables: 'c2sc' and 'pcap'")); + _caps_unicase.set_tooltip_text( _("Unicase (small caps for uppercase, normal for lowercase). OpenType table: 'unic'")); + _caps_titling.set_tooltip_text( _("Titling caps (lighter-weight uppercase for use in titles). OpenType table: 'titl'")); // Group buttons Gtk::RadioButton::Group caps_group = _caps_normal.get_group(); @@ -135,6 +148,8 @@ namespace Widget { _caps_all_petite.set_group(caps_group); _caps_unicase.set_group(caps_group); _caps_titling.set_group(caps_group); + + // Add signals _caps_normal.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) ); _caps_small.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) ); _caps_all_small.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) ); @@ -143,9 +158,61 @@ namespace Widget { _caps_unicase.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) ); _caps_titling.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::caps_callback) ); + // Add to frame + _caps_vbox.add( _caps_normal ); + _caps_vbox.add( _caps_small ); + _caps_vbox.add( _caps_all_small ); + _caps_vbox.add( _caps_petite ); + _caps_vbox.add( _caps_all_petite ); + _caps_vbox.add( _caps_unicase ); + _caps_vbox.add( _caps_titling ); + _caps_frame.add( _caps_vbox ); + add( _caps_frame ); + caps_init(); // Numeric ------------------------------ + + // Add tooltips + _numeric_default_style.set_tooltip_text( _("Normal style.")); + _numeric_lining.set_tooltip_text( _("Lining numerals. OpenType table: 'lnum'")); + _numeric_old_style.set_tooltip_text( _("Old style numerals. OpenType table: 'onum'")); + _numeric_default_width.set_tooltip_text( _("Normal widths.")); + _numeric_proportional.set_tooltip_text( _("Proportional width numerals. OpenType table: 'pnum'")); + _numeric_tabular.set_tooltip_text( _("Same width numerals. OpenType table: 'tnum'")); + _numeric_default_fractions.set_tooltip_text( _("Normal fractions.")); + _numeric_diagonal.set_tooltip_text( _("Diagonal fractions. OpenType table: 'frac'")); + _numeric_stacked.set_tooltip_text( _("Stacked fractions. OpenType table: 'afrc'")); + _numeric_ordinal.set_tooltip_text( _("Ordinals (raised 'th', etc.). OpenType table: 'ordn'")); + _numeric_slashed_zero.set_tooltip_text( _("Slashed zeros. OpenType table: 'zero'")); + + // Group buttons + Gtk::RadioButton::Group style_group = _numeric_default_style.get_group(); + _numeric_lining.set_group(style_group); + _numeric_old_style.set_group(style_group); + + Gtk::RadioButton::Group width_group = _numeric_default_width.get_group(); + _numeric_proportional.set_group(width_group); + _numeric_tabular.set_group(width_group); + + Gtk::RadioButton::Group fraction_group = _numeric_default_fractions.get_group(); + _numeric_diagonal.set_group(fraction_group); + _numeric_stacked.set_group(fraction_group); + + // Add signals + _numeric_default_style.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::numeric_callback) ); + _numeric_lining.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::numeric_callback) ); + _numeric_old_style.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::numeric_callback) ); + _numeric_default_width.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::numeric_callback) ); + _numeric_proportional.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::numeric_callback) ); + _numeric_tabular.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::numeric_callback) ); + _numeric_default_fractions.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::numeric_callback) ); + _numeric_diagonal.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::numeric_callback) ); + _numeric_stacked.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::numeric_callback) ); + _numeric_ordinal.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::numeric_callback) ); + _numeric_slashed_zero.signal_clicked().connect ( sigc::mem_fun(*this, &FontVariants::numeric_callback) ); + + // Add to frame _numeric_stylebox.add( _numeric_default_style ); _numeric_stylebox.add( _numeric_lining ); _numeric_stylebox.add( _numeric_old_style ); @@ -163,20 +230,9 @@ namespace Widget { _numeric_frame.add( _numeric_vbox ); add( _numeric_frame ); - // Group buttons - Gtk::RadioButton::Group style_group = _numeric_default_style.get_group(); - _numeric_lining.set_group(style_group); - _numeric_old_style.set_group(style_group); - - Gtk::RadioButton::Group width_group = _numeric_default_width.get_group(); - _numeric_proportional.set_group(width_group); - _numeric_tabular.set_group(width_group); - - Gtk::RadioButton::Group fraction_group = _numeric_default_fractions.get_group(); - _numeric_diagonal.set_group(fraction_group); - _numeric_stacked.set_group(fraction_group); show_all_children(); + } void @@ -188,6 +244,7 @@ namespace Widget { FontVariants::ligatures_callback() { // std::cout << "FontVariants::ligatures_callback()" << std::endl; _ligatures_changed = true; + _changed_signal.emit(); } void @@ -199,6 +256,7 @@ namespace Widget { FontVariants::position_callback() { // std::cout << "FontVariants::position_callback()" << std::endl; _position_changed = true; + _changed_signal.emit(); } void @@ -210,6 +268,7 @@ namespace Widget { FontVariants::caps_callback() { // std::cout << "FontVariants::caps_callback()" << std::endl; _caps_changed = true; + _changed_signal.emit(); } void @@ -221,6 +280,7 @@ namespace Widget { FontVariants::numeric_callback() { // std::cout << "FontVariants::numeric_callback()" << std::endl; _numeric_changed = true; + _changed_signal.emit(); } // Update GUI based on query. diff --git a/src/ui/widget/font-variants.h b/src/ui/widget/font-variants.h index 04c05d3c6..e6a9dd68b 100644 --- a/src/ui/widget/font-variants.h +++ b/src/ui/widget/font-variants.h @@ -10,8 +10,6 @@ #ifndef INKSCAPE_UI_WIDGET_FONT_VARIANT_H #define INKSCAPE_UI_WIDGET_FONT_VARIANT_H -// Temp: both frame and expander -#include #include #include #include @@ -112,10 +110,27 @@ private: bool _caps_changed; bool _numeric_changed; + sigc::signal _changed_signal; + public: + + /** + * Update GUI based on query results. + */ void update( SPStyle const *query ); + /** + * Fill SPCSSAttr based on settings of buttons. + */ void fill_css( SPCSSAttr* css ); + + /** + * Let others know that user has changed GUI settings. + * (Used to enable 'Apply' and 'Default' buttons.) + */ + sigc::connection connectChanged(sigc::slot slot) { + return _changed_signal.connect(slot); + } }; -- cgit v1.2.3 From da59adbf4c5d970a899919d37a22a31865f9c540 Mon Sep 17 00:00:00 2001 From: Tavmjong Bah Date: Thu, 21 May 2015 10:09:24 +0200 Subject: Don't fill entry box with zeros while typing. Bug introduced with r14160. (bzr r14166) --- src/ui/widget/color-entry.cpp | 10 ++++++++++ src/ui/widget/color-entry.h | 1 + 2 files changed, 11 insertions(+) (limited to 'src/ui') diff --git a/src/ui/widget/color-entry.cpp b/src/ui/widget/color-entry.cpp index 473d7de65..f5658c3a6 100644 --- a/src/ui/widget/color-entry.cpp +++ b/src/ui/widget/color-entry.cpp @@ -20,6 +20,7 @@ namespace Widget { ColorEntry::ColorEntry(SelectedColor &color) : _color(color) , _updating(false) + , _updatingrgba(false) { _color_changed_connection = color.signal_changed.connect(sigc::mem_fun(this, &ColorEntry::_onColorChanged)); _color_dragged_connection = color.signal_dragged.connect(sigc::mem_fun(this, &ColorEntry::_onColorChanged)); @@ -41,6 +42,9 @@ void ColorEntry::on_changed() if (_updating) { return; } + if (_updatingrgba) { + return; // Typing text into entry box + } Glib::ustring text = get_text(); bool changed = false; @@ -64,11 +68,13 @@ void ColorEntry::on_changed() if (len < 8) { rgba = rgba << (4 * (8 - len)); } + _updatingrgba = true; if (changed) { set_text(str); } SPColor color(rgba); _color.setColorAlpha(color, SP_RGBA32_A_F(rgba)); + _updatingrgba = false; } g_free(str); } @@ -76,6 +82,10 @@ void ColorEntry::on_changed() void ColorEntry::_onColorChanged() { + if (_updatingrgba) { + return; + } + SPColor color = _color.color(); gdouble alpha = _color.alpha(); diff --git a/src/ui/widget/color-entry.h b/src/ui/widget/color-entry.h index cd7d6164a..edabe1980 100644 --- a/src/ui/widget/color-entry.h +++ b/src/ui/widget/color-entry.h @@ -34,6 +34,7 @@ private: sigc::connection _color_changed_connection; sigc::connection _color_dragged_connection; bool _updating; + bool _updatingrgba; }; } -- cgit v1.2.3