From dcce4eae31bf798949a7991cac165bcd6d0a0eef Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Wed, 21 May 2014 18:03:59 +0200 Subject: SPColorSlider c++-sification: added ColorSlider class (bzr r13341.6.1) --- src/widgets/sp-color-scales.cpp | 4 +- src/widgets/sp-color-scales.h | 8 ++ src/widgets/sp-color-slider.cpp | 202 ++++++++++++++++++++++++++++++-- src/widgets/sp-color-slider.h | 81 ++++++++++++- src/widgets/sp-color-wheel-selector.cpp | 4 +- src/widgets/sp-color-wheel-selector.h | 8 ++ 6 files changed, 294 insertions(+), 13 deletions(-) (limited to 'src') diff --git a/src/widgets/sp-color-scales.cpp b/src/widgets/sp-color-scales.cpp index c3f9d511c..a7d458561 100644 --- a/src/widgets/sp-color-scales.cpp +++ b/src/widgets/sp-color-scales.cpp @@ -5,11 +5,13 @@ #ifdef HAVE_CONFIG_H # include "config.h" #endif + +#include "sp-color-scales.h" + #include #include #include #include "../dialogs/dialog-events.h" -#include "sp-color-scales.h" #include "svg/svg-icc-color.h" #define CSC_CHANNEL_R (1 << 0) diff --git a/src/widgets/sp-color-scales.h b/src/widgets/sp-color-scales.h index 3b11bc05e..cd3900f85 100644 --- a/src/widgets/sp-color-scales.h +++ b/src/widgets/sp-color-scales.h @@ -1,6 +1,14 @@ #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 diff --git a/src/widgets/sp-color-slider.cpp b/src/widgets/sp-color-slider.cpp index 9b13ba1c5..07e1d79fb 100644 --- a/src/widgets/sp-color-slider.cpp +++ b/src/widgets/sp-color-slider.cpp @@ -1,7 +1,8 @@ -/* - * A slider with colored background - * - * Author: +/** + * @file + * A slider with colored background - implementation. + */ +/* Author: * Lauris Kaplinski * bulia byak * @@ -10,13 +11,200 @@ * This code is in public domain */ +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "sp-color-slider.h" + #include +#include +#include +#include + #include "sp-color-scales.h" #include "preferences.h" -#define SLIDER_WIDTH 96 -#define SLIDER_HEIGHT 8 -#define ARROW_SIZE 7 +static const gint SLIDER_WIDTH = 96; +static const gint SLIDER_HEIGHT = 8; +static const gint ARROW_SIZE = 7; + + +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; +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + enum { GRABBED, diff --git a/src/widgets/sp-color-slider.h b/src/widgets/sp-color-slider.h index 591d8368a..6821c8fe4 100644 --- a/src/widgets/sp-color-slider.h +++ b/src/widgets/sp-color-slider.h @@ -1,10 +1,7 @@ #ifndef __SP_COLOR_SLIDER_H__ #define __SP_COLOR_SLIDER_H__ -/* - * A slider with colored background - * - * Author: +/* Author: * Lauris Kaplinski * * Copyright (C) 2001-2002 Lauris Kaplinski @@ -12,6 +9,82 @@ * This code is in public domain */ +#ifdef HAVE_CONFIG_H +# include +#endif + +#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H +#include +#endif + +#include + +#include + + +/* + * 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; +}; + + + + + #include #include diff --git a/src/widgets/sp-color-wheel-selector.cpp b/src/widgets/sp-color-wheel-selector.cpp index 7c8bb1df7..1cc2e06d6 100644 --- a/src/widgets/sp-color-wheel-selector.cpp +++ b/src/widgets/sp-color-wheel-selector.cpp @@ -1,11 +1,13 @@ #ifdef HAVE_CONFIG_H # include "config.h" #endif + +#include "sp-color-wheel-selector.h" + #include #include #include #include "../dialogs/dialog-events.h" -#include "sp-color-wheel-selector.h" #include "sp-color-scales.h" #include "sp-color-icc-selector.h" #include "../svg/svg-icc-color.h" diff --git a/src/widgets/sp-color-wheel-selector.h b/src/widgets/sp-color-wheel-selector.h index bbd377422..6f45b6bba 100644 --- a/src/widgets/sp-color-wheel-selector.h +++ b/src/widgets/sp-color-wheel-selector.h @@ -1,6 +1,14 @@ #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 -- cgit v1.2.3 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 +++++ src/widgets/CMakeLists.txt | 2 - src/widgets/Makefile_insert | 2 - src/widgets/sp-color-icc-selector.cpp | 2 +- src/widgets/sp-color-scales.cpp | 1 + src/widgets/sp-color-scales.h | 3 +- src/widgets/sp-color-slider.cpp | 959 ------------------------------- src/widgets/sp-color-slider.h | 140 ----- src/widgets/sp-color-wheel-selector.cpp | 1 + src/widgets/sp-color-wheel-selector.h | 4 +- 13 files changed, 1117 insertions(+), 1108 deletions(-) create mode 100644 src/ui/widget/color-slider.cpp create mode 100644 src/ui/widget/color-slider.h delete mode 100644 src/widgets/sp-color-slider.cpp delete mode 100644 src/widgets/sp-color-slider.h (limited to 'src') 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 diff --git a/src/widgets/CMakeLists.txt b/src/widgets/CMakeLists.txt index fe4433153..b65e0b1db 100644 --- a/src/widgets/CMakeLists.txt +++ b/src/widgets/CMakeLists.txt @@ -40,7 +40,6 @@ set(widgets_SRC sp-color-notebook.cpp sp-color-scales.cpp sp-color-selector.cpp - sp-color-slider.cpp sp-color-wheel-selector.cpp sp-widget.cpp sp-xmlview-attr-list.cpp @@ -97,7 +96,6 @@ set(widgets_SRC sp-color-notebook.h sp-color-scales.h sp-color-selector.h - sp-color-slider.h sp-color-wheel-selector.h sp-widget.h sp-xmlview-attr-list.h diff --git a/src/widgets/Makefile_insert b/src/widgets/Makefile_insert index 97713cbee..a4a3bb61b 100644 --- a/src/widgets/Makefile_insert +++ b/src/widgets/Makefile_insert @@ -74,8 +74,6 @@ ink_common_sources += \ widgets/sp-color-scales.h \ widgets/sp-color-selector.cpp \ widgets/sp-color-selector.h \ - widgets/sp-color-slider.cpp \ - widgets/sp-color-slider.h \ widgets/sp-color-wheel-selector.cpp \ widgets/sp-color-wheel-selector.h \ widgets/spinbutton-events.cpp \ diff --git a/src/widgets/sp-color-icc-selector.cpp b/src/widgets/sp-color-icc-selector.cpp index 53e73dd57..baed7e3b6 100644 --- a/src/widgets/sp-color-icc-selector.cpp +++ b/src/widgets/sp-color-icc-selector.cpp @@ -13,7 +13,7 @@ #include "../dialogs/dialog-events.h" #include "sp-color-icc-selector.h" #include "sp-color-scales.h" -#include "sp-color-slider.h" +#include "ui/widget/color-slider.h" #include "svg/svg-icc-color.h" #include "colorspace.h" #include "document.h" diff --git a/src/widgets/sp-color-scales.cpp b/src/widgets/sp-color-scales.cpp index a7d458561..7d5874506 100644 --- a/src/widgets/sp-color-scales.cpp +++ b/src/widgets/sp-color-scales.cpp @@ -13,6 +13,7 @@ #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) diff --git a/src/widgets/sp-color-scales.h b/src/widgets/sp-color-scales.h index cd3900f85..65925fecb 100644 --- a/src/widgets/sp-color-scales.h +++ b/src/widgets/sp-color-scales.h @@ -13,12 +13,13 @@ #include #include -#include #include struct SPColorScales; struct SPColorScalesClass; +struct SPColorSlider; + typedef enum { SP_COLOR_SCALES_MODE_NONE = 0, diff --git a/src/widgets/sp-color-slider.cpp b/src/widgets/sp-color-slider.cpp deleted file mode 100644 index 07e1d79fb..000000000 --- a/src/widgets/sp-color-slider.cpp +++ /dev/null @@ -1,959 +0,0 @@ -/** - * @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 "sp-color-slider.h" - -#include -#include -#include -#include - -#include "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; - - -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; -} - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -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/widgets/sp-color-slider.h b/src/widgets/sp-color-slider.h deleted file mode 100644 index 6821c8fe4..000000000 --- a/src/widgets/sp-color-slider.h +++ /dev/null @@ -1,140 +0,0 @@ -#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 - - -/* - * 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; -}; - - - - - -#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 diff --git a/src/widgets/sp-color-wheel-selector.cpp b/src/widgets/sp-color-wheel-selector.cpp index 1cc2e06d6..de2d030d4 100644 --- a/src/widgets/sp-color-wheel-selector.cpp +++ b/src/widgets/sp-color-wheel-selector.cpp @@ -11,6 +11,7 @@ #include "sp-color-scales.h" #include "sp-color-icc-selector.h" #include "../svg/svg-icc-color.h" +#include "ui/widget/color-slider.h" #include "ui/widget/gimpcolorwheel.h" G_BEGIN_DECLS diff --git a/src/widgets/sp-color-wheel-selector.h b/src/widgets/sp-color-wheel-selector.h index 6f45b6bba..b7b86438c 100644 --- a/src/widgets/sp-color-wheel-selector.h +++ b/src/widgets/sp-color-wheel-selector.h @@ -12,14 +12,12 @@ #include #include -#include "sp-color-slider.h" #include "sp-color-selector.h" - - typedef struct _GimpColorWheel GimpColorWheel; struct SPColorWheelSelector; struct SPColorWheelSelectorClass; +struct SPColorSlider; class ColorWheelSelector: public ColorSelector { -- cgit v1.2.3 From fe272ea3f531111c3ab361ca31ded84b1e7106df Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Fri, 23 May 2014 11:59:24 +0200 Subject: SPColorWheelSelector uses refactored ColorSlider class (bzr r13341.6.3) --- src/widgets/sp-color-wheel-selector.cpp | 92 ++++++++++++++------------------- src/widgets/sp-color-wheel-selector.h | 21 ++++++-- 2 files changed, 56 insertions(+), 57 deletions(-) (limited to 'src') diff --git a/src/widgets/sp-color-wheel-selector.cpp b/src/widgets/sp-color-wheel-selector.cpp index de2d030d4..0ef669aca 100644 --- a/src/widgets/sp-color-wheel-selector.cpp +++ b/src/widgets/sp-color-wheel-selector.cpp @@ -7,6 +7,7 @@ #include #include #include +#include #include "../dialogs/dialog-events.h" #include "sp-color-scales.h" #include "sp-color-icc-selector.h" @@ -160,28 +161,26 @@ void ColorWheelSelector::init() _adj = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 255.0, 1.0, 10.0, 10.0)); /* Slider */ - _slider = sp_color_slider_new (_adj); - gtk_widget_set_tooltip_text (_slider, _("Alpha (opacity)")); - gtk_widget_show (_slider); + _slider = Gtk::manage(new Inkscape::UI::Widget::ColorSlider(Glib::wrap(_adj))); + _slider->set_tooltip_text(_("Alpha (opacity)")); + _slider->show(); #if GTK_CHECK_VERSION(3,0,0) - gtk_widget_set_margin_left(_slider, XPAD); - gtk_widget_set_margin_right(_slider, XPAD); - gtk_widget_set_margin_top(_slider, YPAD); - gtk_widget_set_margin_bottom(_slider, YPAD); - gtk_widget_set_hexpand(_slider, TRUE); - gtk_widget_set_halign(_slider, GTK_ALIGN_FILL); - gtk_widget_set_valign(_slider, GTK_ALIGN_FILL); - gtk_grid_attach(GTK_GRID(t), _slider, 1, row, 1, 1); + _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, 1, 2, row, row + 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, XPAD, YPAD); + gtk_table_attach(GTK_TABLE (t), _slider->gobj(), 1, 2, row, row + 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, XPAD, YPAD); #endif - sp_color_slider_set_colors (SP_COLOR_SLIDER (_slider), - 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->set_colors(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); @@ -206,12 +205,9 @@ void ColorWheelSelector::init() g_signal_connect (G_OBJECT (_adj), "value_changed", G_CALLBACK (_adjustmentChanged), _csel); - g_signal_connect (G_OBJECT (_slider), "grabbed", - G_CALLBACK (_sliderGrabbed), _csel); - g_signal_connect (G_OBJECT (_slider), "released", - G_CALLBACK (_sliderReleased), _csel); - g_signal_connect (G_OBJECT (_slider), "changed", - G_CALLBACK (_sliderChanged), _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 ); @@ -243,9 +239,8 @@ GtkWidget *sp_color_wheel_selector_new() /* Helpers for setting color value */ -static void preserve_icc(SPColor *color, SPColorWheelSelector *cs){ - ColorSelector* selector = static_cast(SP_COLOR_SELECTOR(cs)->base); - color->icc = selector->getColor().icc ? new SVGICCColor(*selector->getColor().icc) : 0; +void ColorWheelSelector::_preserve_icc(SPColor *color) const { + color->icc = getColor().icc ? new SVGICCColor(*getColor().icc) : 0; } void ColorWheelSelector::_colorChanged() @@ -264,7 +259,7 @@ void ColorWheelSelector::_colorChanged() guint32 mid = _color.toRGBA32( 0x7f ); guint32 end = _color.toRGBA32( 0xff ); - sp_color_slider_set_colors(SP_COLOR_SLIDER(_slider), start, mid, end); + _slider->set_colors(start, mid, end); ColorScales::setScaled(_adj, _alpha); @@ -287,45 +282,38 @@ void ColorWheelSelector::_adjustmentChanged( GtkAdjustment *adjustment, SPColorW wheelSelector->_updating = TRUE; - preserve_icc(&wheelSelector->_color, cs); + wheelSelector->_preserve_icc(&wheelSelector->_color); wheelSelector->_updateInternals( wheelSelector->_color, ColorScales::getScaled( wheelSelector->_adj ), wheelSelector->_dragging ); wheelSelector->_updating = FALSE; } -void ColorWheelSelector::_sliderGrabbed( SPColorSlider *slider, SPColorWheelSelector *cs ) +void ColorWheelSelector::_sliderGrabbed() { - (void)slider; - ColorWheelSelector* wheelSelector = static_cast(SP_COLOR_SELECTOR(cs)->base); - if (!wheelSelector->_dragging) { - wheelSelector->_dragging = TRUE; - wheelSelector->_grabbed(); + if (!_dragging) { + _dragging = TRUE; + _grabbed(); - preserve_icc(&wheelSelector->_color, cs); - wheelSelector->_updateInternals( wheelSelector->_color, ColorScales::getScaled( wheelSelector->_adj ), wheelSelector->_dragging ); + _preserve_icc(&_color); + _updateInternals( _color, ColorScales::getScaled( _adj ), _dragging ); } } -void ColorWheelSelector::_sliderReleased( SPColorSlider *slider, SPColorWheelSelector *cs ) +void ColorWheelSelector::_sliderReleased() { - (void)slider; - ColorWheelSelector* wheelSelector = static_cast(SP_COLOR_SELECTOR(cs)->base); - if (wheelSelector->_dragging) { - wheelSelector->_dragging = FALSE; - wheelSelector->_released(); + if (_dragging) { + _dragging = FALSE; + _released(); - preserve_icc(&wheelSelector->_color, cs); - wheelSelector->_updateInternals( wheelSelector->_color, ColorScales::getScaled( wheelSelector->_adj ), wheelSelector->_dragging ); + _preserve_icc(&_color); + _updateInternals( _color, ColorScales::getScaled( _adj ), _dragging ); } } -void ColorWheelSelector::_sliderChanged( SPColorSlider *slider, SPColorWheelSelector *cs ) +void ColorWheelSelector::_sliderChanged() { - (void)slider; - ColorWheelSelector* wheelSelector = static_cast(SP_COLOR_SELECTOR(cs)->base); - - preserve_icc(&wheelSelector->_color, cs); - wheelSelector->_updateInternals( wheelSelector->_color, ColorScales::getScaled( wheelSelector->_adj ), wheelSelector->_dragging ); + _preserve_icc(&_color); + _updateInternals( _color, ColorScales::getScaled( _adj ), _dragging ); } void ColorWheelSelector::_wheelChanged( GimpColorWheel *wheel, SPColorWheelSelector *cs ) @@ -346,9 +334,9 @@ void ColorWheelSelector::_wheelChanged( GimpColorWheel *wheel, SPColorWheelSelec guint32 mid = color.toRGBA32( 0x7f ); guint32 end = color.toRGBA32( 0xff ); - sp_color_slider_set_colors (SP_COLOR_SLIDER(wheelSelector->_slider), start, mid, end); + wheelSelector->_slider->set_colors(start, mid, end); - preserve_icc(&color, cs); + wheelSelector->_preserve_icc(&color); wheelSelector->_updateInternals( color, wheelSelector->_alpha, gimp_color_wheel_is_adjusting(wheel) ); } diff --git a/src/widgets/sp-color-wheel-selector.h b/src/widgets/sp-color-wheel-selector.h index b7b86438c..bb6078906 100644 --- a/src/widgets/sp-color-wheel-selector.h +++ b/src/widgets/sp-color-wheel-selector.h @@ -17,7 +17,16 @@ typedef struct _GimpColorWheel GimpColorWheel; struct SPColorWheelSelector; struct SPColorWheelSelectorClass; -struct SPColorSlider; + +namespace Inkscape { +namespace UI { +namespace Widget { + +class ColorSlider; + +} +} +} class ColorWheelSelector: public ColorSelector { @@ -32,9 +41,9 @@ protected: static void _adjustmentChanged ( GtkAdjustment *adjustment, SPColorWheelSelector *cs ); - static void _sliderGrabbed( SPColorSlider *slider, SPColorWheelSelector *cs ); - static void _sliderReleased( SPColorSlider *slider, SPColorWheelSelector *cs ); - static void _sliderChanged( SPColorSlider *slider, SPColorWheelSelector *cs ); + void _sliderGrabbed(); + void _sliderReleased(); + void _sliderChanged(); static void _wheelChanged( GimpColorWheel *wheel, SPColorWheelSelector *cs ); static void _fooChanged( GtkWidget foo, SPColorWheelSelector *cs ); @@ -45,7 +54,7 @@ protected: gboolean _dragging : 1; GtkAdjustment* _adj; // Channel adjustment GtkWidget* _wheel; - GtkWidget* _slider; + Inkscape::UI::Widget::ColorSlider* _slider; GtkWidget* _sbtn; // Spinbutton GtkWidget* _label; // Label @@ -53,6 +62,8 @@ private: // By default, disallow copy constructor and assignment operator ColorWheelSelector( const ColorWheelSelector& obj ); ColorWheelSelector& operator=( const ColorWheelSelector& obj ); + + void _preserve_icc(SPColor *color) const; }; -- 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') 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') 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') 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') 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') 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') 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') 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 15db1bacac6f25cef94f92bb4aa0fc96a02b4113 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 24 May 2014 19:20:57 +0200 Subject: SPColorSlider c++-sification: fixed crash at exit (bzr r13341.6.11) --- src/widgets/sp-color-wheel-selector.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src') diff --git a/src/widgets/sp-color-wheel-selector.cpp b/src/widgets/sp-color-wheel-selector.cpp index 0ef669aca..2100f555c 100644 --- a/src/widgets/sp-color-wheel-selector.cpp +++ b/src/widgets/sp-color-wheel-selector.cpp @@ -161,7 +161,7 @@ void ColorWheelSelector::init() _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))); + _slider = Gtk::manage(new Inkscape::UI::Widget::ColorSlider(Glib::wrap(_adj, true))); _slider->set_tooltip_text(_("Alpha (opacity)")); _slider->show(); -- cgit v1.2.3 From 38b4b1f4d34eb3e67c770bd833629e92b336155a Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 24 May 2014 19:59:29 +0200 Subject: SPColorSlider c++-sification: use in sp-color-scales (bzr r13341.6.12) --- src/widgets/sp-color-scales.cpp | 182 ++++++++++++++++++---------------------- src/widgets/sp-color-scales.h | 18 ++-- 2 files changed, 94 insertions(+), 106 deletions(-) (limited to 'src') diff --git a/src/widgets/sp-color-scales.cpp b/src/widgets/sp-color-scales.cpp index 7d5874506..94950e937 100644 --- a/src/widgets/sp-color-scales.cpp +++ b/src/widgets/sp-color-scales.cpp @@ -11,6 +11,8 @@ #include #include #include +#include + #include "../dialogs/dialog-events.h" #include "svg/svg-icc-color.h" #include "ui/widget/color-slider.h" @@ -166,18 +168,18 @@ void ColorScales::init() /* Adjustment */ _a[i] = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, _rangeLimit, 1.0, 10.0, 10.0)); /* Slider */ - _s[i] = sp_color_slider_new (_a[i]); - gtk_widget_show (_s[i]); + _s[i] = Gtk::manage(new Inkscape::UI::Widget::ColorSlider(Glib::wrap(_a[i], true))); + _s[i]->show(); #if GTK_CHECK_VERSION(3,0,0) - gtk_widget_set_margin_left(_s[i], XPAD); - gtk_widget_set_margin_right(_s[i], XPAD); - gtk_widget_set_margin_top(_s[i], YPAD); - gtk_widget_set_margin_bottom(_s[i], YPAD); - gtk_widget_set_hexpand(_s[i], TRUE); - gtk_grid_attach(GTK_GRID(t), _s[i], 1, i, 1, 1); + _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], 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 */ @@ -203,12 +205,9 @@ void ColorScales::init() /* Signals */ g_signal_connect (G_OBJECT (_a[i]), "value_changed", G_CALLBACK (_adjustmentAnyChanged), _csel); - g_signal_connect (G_OBJECT (_s[i]), "grabbed", - G_CALLBACK (_sliderAnyGrabbed), _csel); - g_signal_connect (G_OBJECT (_s[i]), "released", - G_CALLBACK (_sliderAnyReleased), _csel); - g_signal_connect (G_OBJECT (_s[i]), "changed", - G_CALLBACK (_sliderAnyChanged), _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 */ @@ -429,20 +428,20 @@ void ColorScales::setMode(SPColorScalesMode mode) case SP_COLOR_SCALES_MODE_RGB: _setRangeLimit(255.0); gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[0]), _("_R:")); - gtk_widget_set_tooltip_text (_s[0], _("Red")); + _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:")); - gtk_widget_set_tooltip_text (_s[1], _("Green")); + _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:")); - gtk_widget_set_tooltip_text (_s[2], _("Blue")); + _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:")); - gtk_widget_set_tooltip_text (_s[3], _("Alpha (opacity)")); + _s[3]->set_tooltip_text(_("Alpha (opacity)")); gtk_widget_set_tooltip_text (_b[3], _("Alpha (opacity)")); - sp_color_slider_set_map (SP_COLOR_SLIDER (_s[0]), NULL); + _s[0]->set_map(NULL); gtk_widget_hide (_l[4]); - gtk_widget_hide (_s[4]); + _s[4]->hide(); gtk_widget_hide (_b[4]); _updating = TRUE; setScaled( _a[0], rgba[0] ); @@ -455,20 +454,20 @@ void ColorScales::setMode(SPColorScalesMode mode) case SP_COLOR_SCALES_MODE_HSV: _setRangeLimit(255.0); gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[0]), _("_H:")); - gtk_widget_set_tooltip_text (_s[0], _("Hue")); + _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:")); - gtk_widget_set_tooltip_text (_s[1], _("Saturation")); + _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:")); - gtk_widget_set_tooltip_text (_s[2], _("Lightness")); + _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:")); - gtk_widget_set_tooltip_text (_s[3], _("Alpha (opacity)")); + _s[3]->set_tooltip_text(_("Alpha (opacity)")); gtk_widget_set_tooltip_text (_b[3], _("Alpha (opacity)")); - sp_color_slider_set_map (SP_COLOR_SLIDER (_s[0]), (guchar *)(sp_color_scales_hue_map())); + _s[0]->set_map((guchar *)(sp_color_scales_hue_map())); gtk_widget_hide (_l[4]); - gtk_widget_hide (_s[4]); + _s[4]->hide(); gtk_widget_hide (_b[4]); _updating = TRUE; c[0] = 0.0; @@ -483,23 +482,23 @@ void ColorScales::setMode(SPColorScalesMode mode) case SP_COLOR_SCALES_MODE_CMYK: _setRangeLimit(100.0); gtk_label_set_markup_with_mnemonic (GTK_LABEL (_l[0]), _("_C:")); - gtk_widget_set_tooltip_text (_s[0], _("Cyan")); + _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:")); - gtk_widget_set_tooltip_text (_s[1], _("Magenta")); + _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:")); - gtk_widget_set_tooltip_text (_s[2], _("Yellow")); + _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:")); - gtk_widget_set_tooltip_text (_s[3], _("Black")); + _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:")); - gtk_widget_set_tooltip_text (_s[4], _("Alpha (opacity)")); + _s[4]->set_tooltip_text(_("Alpha (opacity)")); gtk_widget_set_tooltip_text (_b[4], _("Alpha (opacity)")); - sp_color_slider_set_map (SP_COLOR_SLIDER (_s[0]), NULL); + _s[0]->set_map(NULL); gtk_widget_show (_l[4]); - gtk_widget_show (_s[4]); + _s[4]->show(); gtk_widget_show (_b[4]); _updating = TRUE; @@ -572,34 +571,27 @@ void ColorScales::_adjustmentAnyChanged( GtkAdjustment *adjustment, SPColorScale _adjustmentChanged(cs, channel); } -void ColorScales::_sliderAnyGrabbed( SPColorSlider *slider, SPColorScales *cs ) +void ColorScales::_sliderAnyGrabbed() { - (void)slider; - ColorScales* scales = static_cast(SP_COLOR_SELECTOR(cs)->base); - if (!scales->_dragging) { - scales->_dragging = TRUE; - scales->_grabbed(); - scales->_recalcColor( FALSE ); + if (!_dragging) { + _dragging = TRUE; + _grabbed(); + _recalcColor( FALSE ); } } -void ColorScales::_sliderAnyReleased( SPColorSlider *slider, SPColorScales *cs ) +void ColorScales::_sliderAnyReleased() { - (void)slider; - ColorScales* scales = static_cast(SP_COLOR_SELECTOR(cs)->base); - if (scales->_dragging) { - scales->_dragging = FALSE; - scales->_released(); - scales->_recalcColor( FALSE ); + if (_dragging) { + _dragging = FALSE; + _released(); + _recalcColor( FALSE ); } } -void ColorScales::_sliderAnyChanged( SPColorSlider *slider, SPColorScales *cs ) +void ColorScales::_sliderAnyChanged() { - (void)slider; - ColorScales* scales = static_cast(SP_COLOR_SELECTOR(cs)->base); - - scales->_recalcColor( TRUE ); + _recalcColor( TRUE ); } void ColorScales::_adjustmentChanged( SPColorScales *cs, guint channel ) @@ -626,31 +618,27 @@ void ColorScales::_updateSliders( guint channels ) case SP_COLOR_SCALES_MODE_RGB: if ((channels != CSC_CHANNEL_R) && (channels != CSC_CHANNEL_A)) { /* Update red */ - sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[0]), - 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)); + _s[0]->set_colors(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 */ - sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[1]), - 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)); + _s[1]->set_colors(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 */ - sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[2]), - 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)); + _s[2]->set_colors(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 */ - sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[3]), - 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)); + _s[3]->set_colors(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: @@ -660,28 +648,25 @@ void ColorScales::_updateSliders( guint channels ) 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])); - sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[1]), - 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)); + _s[1]->set_colors(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); - sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[2]), - 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)); + _s[2]->set_colors(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])); - sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[3]), - 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)); + _s[3]->set_colors(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: @@ -690,48 +675,43 @@ void ColorScales::_updateSliders( guint channels ) 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])); - sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[0]), - 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)); + _s[0]->set_colors(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])); - sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[1]), - 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)); + _s[1]->set_colors(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])); - sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[2]), - 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)); + _s[2]->set_colors(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); - sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[3]), - 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)); + _s[3]->set_colors(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])); - sp_color_slider_set_colors (SP_COLOR_SLIDER (_s[4]), - 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)); + _s[4]->set_colors(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: diff --git a/src/widgets/sp-color-scales.h b/src/widgets/sp-color-scales.h index 65925fecb..06b8f3859 100644 --- a/src/widgets/sp-color-scales.h +++ b/src/widgets/sp-color-scales.h @@ -18,8 +18,16 @@ struct SPColorScales; struct SPColorScalesClass; -struct SPColorSlider; +namespace Inkscape { +namespace UI { +namespace Widget { + +class ColorSlider; + +} +} +} typedef enum { SP_COLOR_SCALES_MODE_NONE = 0, @@ -52,9 +60,9 @@ protected: virtual void _colorChanged(); static void _adjustmentAnyChanged(GtkAdjustment *adjustment, SPColorScales *cs); - static void _sliderAnyGrabbed(SPColorSlider *slider, SPColorScales *cs); - static void _sliderAnyReleased(SPColorSlider *slider, SPColorScales *cs); - static void _sliderAnyChanged(SPColorSlider *slider, SPColorScales *cs); + void _sliderAnyGrabbed(); + void _sliderAnyReleased(); + void _sliderAnyChanged(); static void _adjustmentChanged(SPColorScales *cs, guint channel); void _getRgbaFloatv(gfloat *rgba); @@ -70,7 +78,7 @@ protected: gboolean _updating : 1; gboolean _dragging : 1; GtkAdjustment *_a[5]; /* Channel adjustments */ - GtkWidget *_s[5]; /* Channel sliders */ + Inkscape::UI::Widget::ColorSlider *_s[5]; /* Channel sliders */ GtkWidget *_b[5]; /* Spinbuttons */ GtkWidget *_l[5]; /* Labels */ -- cgit v1.2.3 From f7eca78772e3f94787c3de8d09b5cf92a46e2eab Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 24 May 2014 22:03:06 +0200 Subject: SPColorSlider c++-sification: use in sp-color-icc-selector (bzr r13341.6.13) --- src/widgets/sp-color-icc-selector.cpp | 72 +++++++++++++++++------------------ 1 file changed, 35 insertions(+), 37 deletions(-) (limited to 'src') diff --git a/src/widgets/sp-color-icc-selector.cpp b/src/widgets/sp-color-icc-selector.cpp index baed7e3b6..ca64a915f 100644 --- a/src/widgets/sp-color-icc-selector.cpp +++ b/src/widgets/sp-color-icc-selector.cpp @@ -104,7 +104,7 @@ public: colorspace::Component _component; GtkAdjustment *_adj; // Component adjustment - GtkWidget *_slider; + Inkscape::UI::Widget::ColorSlider *_slider; GtkWidget *_btn; // spinbutton GtkWidget *_label; // Label guchar *_map; @@ -123,9 +123,9 @@ public: static void _adjustmentChanged ( GtkAdjustment *adjustment, SPColorICCSelector *cs ); - static void _sliderGrabbed( SPColorSlider *slider, SPColorICCSelector *cs ); - static void _sliderReleased( SPColorSlider *slider, SPColorICCSelector *cs ); - static void _sliderChanged( SPColorSlider *slider, SPColorICCSelector *cs ); + void _sliderGrabbed(); + void _sliderReleased(); + void _sliderChanged(); static void _profileSelected( GtkWidget* src, gpointer data ); static void _fixupHit( GtkWidget* src, gpointer data ); @@ -149,7 +149,7 @@ public: std::vector _compUI; GtkAdjustment* _adj; // Channel adjustment - GtkWidget* _slider; + Inkscape::UI::Widget::ColorSlider* _slider; GtkWidget* _sbtn; // Spinbutton GtkWidget* _label; // Label @@ -521,15 +521,15 @@ void ColorICCSelector::init() _impl->_compUI[i]._adj = GTK_ADJUSTMENT( gtk_adjustment_new( 0.0, 0.0, scaleValue, step, page, page ) ); // Slider - _impl->_compUI[i]._slider = sp_color_slider_new( _impl->_compUI[i]._adj ); + _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) - gtk_widget_set_tooltip_text( _impl->_compUI[i]._slider, (i < things.size()) ? things[i].tip.c_str() : "" ); + _impl->_compUI[i]._slider->set_tooltip_text((i < things.size()) ? things[i].tip.c_str() : ""); #else - gtk_widget_set_tooltip_text( _impl->_compUI[i]._slider, "." ); + _impl->_compUI[i]._slider->set_tooltip_text("."); #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2) - gtk_widget_show( _impl->_compUI[i]._slider ); + _impl->_compUI[i]._slider->show(); - attachToGridOrTable(t, _impl->_compUI[i]._slider, 1, row, 1, 1, true); + 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) @@ -550,9 +550,9 @@ 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]._slider ), "grabbed", G_CALLBACK( ColorICCSelectorImpl::_sliderGrabbed ), _csel ); - g_signal_connect( G_OBJECT( _impl->_compUI[i]._slider ), "released", G_CALLBACK( ColorICCSelectorImpl::_sliderReleased ), _csel ); - g_signal_connect( G_OBJECT( _impl->_compUI[i]._slider ), "changed", G_CALLBACK( ColorICCSelectorImpl::_sliderChanged ), _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++; } @@ -568,16 +568,15 @@ void ColorICCSelector::init() _impl->_adj = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 255.0, 1.0, 10.0, 10.0)); // Slider - _impl->_slider = sp_color_slider_new(_impl->_adj); - gtk_widget_set_tooltip_text(_impl->_slider, _("Alpha (opacity)")); - gtk_widget_show(_impl->_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, 1, row, 1, 1, true); + attachToGridOrTable(t, _impl->_slider->gobj(), 1, row, 1, 1, true); - sp_color_slider_set_colors( SP_COLOR_SLIDER( _impl->_slider ), - 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->set_colors(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 @@ -592,9 +591,9 @@ void ColorICCSelector::init() // Signals g_signal_connect(G_OBJECT(_impl->_adj), "value_changed", G_CALLBACK(ColorICCSelectorImpl::_adjustmentChanged), _csel); - g_signal_connect(G_OBJECT(_impl->_slider), "grabbed", G_CALLBACK(ColorICCSelectorImpl::_sliderGrabbed), _csel); - g_signal_connect(G_OBJECT(_impl->_slider), "released", G_CALLBACK(ColorICCSelectorImpl::_sliderReleased), _csel); - g_signal_connect(G_OBJECT(_impl->_slider), "changed", G_CALLBACK(ColorICCSelectorImpl::_sliderChanged), _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) @@ -880,7 +879,7 @@ void ColorICCSelectorImpl::_setProfile( SVGICCColor* profile ) for ( size_t i = 0; i < _compUI.size(); i++ ) { gtk_widget_hide( _compUI[i]._label ); - gtk_widget_hide( _compUI[i]._slider ); + _compUI[i]._slider->hide(); gtk_widget_hide( _compUI[i]._btn ); } @@ -903,13 +902,12 @@ void ColorICCSelectorImpl::_setProfile( SVGICCColor* profile ) 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() : ""); - gtk_widget_set_tooltip_text( _compUI[i]._slider, (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() : "" ); - sp_color_slider_set_colors( SP_COLOR_SLIDER(_compUI[i]._slider), - 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]._slider->set_colors(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 ); @@ -919,14 +917,14 @@ void ColorICCSelectorImpl::_setProfile( SVGICCColor* profile ) gtk_spin_button_set_digits( GTK_SPIN_BUTTON(_compUI[i]._btn), digits ); */ gtk_widget_show( _compUI[i]._label ); - gtk_widget_show( _compUI[i]._slider ); + _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 ); - gtk_widget_hide( _compUI[i]._slider ); + _compUI[i]._slider->hide(); gtk_widget_hide( _compUI[i]._btn ); } } @@ -983,7 +981,7 @@ void ColorICCSelectorImpl::_updateSliders( gint ignore ) cmsHTRANSFORM trans = _prof->getTransfToSRGB8(); if ( trans ) { cmsDoTransform( trans, scratch, _compUI[i]._map, 1024 ); - sp_color_slider_set_map( SP_COLOR_SLIDER(_compUI[i]._slider), _compUI[i]._map ); + _compUI[i]._slider->set_map(_compUI[i]._map); } } } @@ -998,7 +996,7 @@ void ColorICCSelectorImpl::_updateSliders( gint ignore ) guint32 mid = _owner->_color.toRGBA32( 0x7f ); guint32 end = _owner->_color.toRGBA32( 0xff ); - sp_color_slider_set_colors( SP_COLOR_SLIDER(_slider), start, mid, end ); + _slider->set_colors(start, mid, end); } @@ -1091,7 +1089,7 @@ void ColorICCSelectorImpl::_adjustmentChanged( GtkAdjustment *adjustment, SPColo #endif // DEBUG_LCMS } -void ColorICCSelectorImpl::_sliderGrabbed( SPColorSlider * /*slider*/, SPColorICCSelector * /*cs*/ ) +void ColorICCSelectorImpl::_sliderGrabbed() { // ColorICCSelector* iccSelector = dynamic_cast(SP_COLOR_SELECTOR(cs)->base); // if (!iccSelector->_dragging) { @@ -1101,7 +1099,7 @@ void ColorICCSelectorImpl::_sliderGrabbed( SPColorSlider * /*slider*/, SPColorIC // } } -void ColorICCSelectorImpl::_sliderReleased( SPColorSlider * /*slider*/, SPColorICCSelector * /*cs*/ ) +void ColorICCSelectorImpl::_sliderReleased() { // ColorICCSelector* iccSelector = dynamic_cast(SP_COLOR_SELECTOR(cs)->base); // if (iccSelector->_dragging) { @@ -1114,7 +1112,7 @@ void ColorICCSelectorImpl::_sliderReleased( SPColorSlider * /*slider*/, SPColorI #ifdef DEBUG_LCMS void ColorICCSelectorImpl::_sliderChanged( SPColorSlider *slider, SPColorICCSelector *cs ) #else -void ColorICCSelectorImpl::_sliderChanged( SPColorSlider * /*slider*/, SPColorICCSelector * /*cs*/ ) +void ColorICCSelectorImpl::_sliderChanged() #endif // DEBUG_LCMS { #ifdef DEBUG_LCMS -- 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') 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') 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