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/widget/Makefile_insert | 2 + src/ui/widget/color-slider.cpp | 961 +++++++++++++++++++++++++++++++++++++++++ src/ui/widget/color-slider.h | 146 +++++++ 3 files changed, 1109 insertions(+) create mode 100644 src/ui/widget/color-slider.cpp create mode 100644 src/ui/widget/color-slider.h (limited to 'src/ui/widget') diff --git a/src/ui/widget/Makefile_insert b/src/ui/widget/Makefile_insert index 608dd5334..6deaf6671 100644 --- a/src/ui/widget/Makefile_insert +++ b/src/ui/widget/Makefile_insert @@ -10,6 +10,8 @@ ink_common_sources += \ ui/widget/color-picker.h \ ui/widget/color-preview.cpp \ ui/widget/color-preview.h \ + ui/widget/color-slider.cpp \ + ui/widget/color-slider.h \ ui/widget/combo-enums.h \ ui/widget/dock.h \ ui/widget/dock.cpp \ diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp new file mode 100644 index 000000000..430239f00 --- /dev/null +++ b/src/ui/widget/color-slider.cpp @@ -0,0 +1,961 @@ +/** + * @file + * A slider with colored background - implementation. + */ +/* Author: + * Lauris Kaplinski + * bulia byak + * + * Copyright (C) 2001-2002 Lauris Kaplinski + * + * This code is in public domain + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "color-slider.h" + +#include +#include +#include +#include + +#include "widgets/sp-color-scales.h" +#include "preferences.h" + +static const gint SLIDER_WIDTH = 96; +static const gint SLIDER_HEIGHT = 8; +static const gint ARROW_SIZE = 7; + +namespace Inkscape { +namespace UI { +namespace Widget { + +ColorSlider::ColorSlider(Gtk::Adjustment* adjustment) + : _dragging(false) + , _adjustment(NULL) + , _value(0.0) + , _oldvalue(0.0) + , _mapsize(0) + , _map(NULL) +{ + _c0[0] = 0x00; + _c0[1] = 0x00; + _c0[2] = 0x00; + _c0[3] = 0xff; + + _cm[0] = 0xff; + _cm[1] = 0x00; + _cm[2] = 0x00; + _cm[3] = 0xff; + + _c0[0] = 0xff; + _c0[1] = 0xff; + _c0[2] = 0xff; + _c0[3] = 0xff; + + _b0 = 0x5f; + _b1 = 0xa0; + _bmask = 0x08; + + set_adjustment(adjustment); +} + +ColorSlider::~ColorSlider() { + if (_adjustment) { + //TODO: disconnect all connections + delete _adjustment; + _adjustment = NULL; + } +} + +void ColorSlider::on_realize() { + set_realized(); + + if(!_refGdkWindow) + { + GdkWindowAttr attributes; + gint attributes_mask; + Gtk::Allocation allocation = get_allocation(); + + memset(&attributes, 0, sizeof(attributes)); + attributes.x = allocation.get_x(); + attributes.y = allocation.get_y(); + attributes.width = allocation.get_width(); + attributes.height = allocation.get_height(); + attributes.window_type = GDK_WINDOW_CHILD; + attributes.wclass = GDK_INPUT_OUTPUT; + attributes.visual = gdk_screen_get_system_visual(gdk_screen_get_default()); +#if !GTK_CHECK_VERSION(3,0,0) + attributes.colormap = gdk_screen_get_system_colormap(gdk_screen_get_default()); +#endif + attributes.event_mask = get_events (); + attributes.event_mask |= (Gdk::EXPOSURE_MASK | + Gdk::BUTTON_PRESS_MASK | + Gdk::BUTTON_RELEASE_MASK | + Gdk::POINTER_MOTION_MASK | + Gdk::ENTER_NOTIFY_MASK | + Gdk::LEAVE_NOTIFY_MASK); + +#if GTK_CHECK_VERSION(3,0,0) + attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL; +#else + attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP; +#endif + + _refGdkWindow = Gdk::Window::create(get_parent_window(), &attributes, + attributes_mask); + set_window(_refGdkWindow); + _refGdkWindow->set_user_data(gobj()); + + style_attach(); + } +} + +void ColorSlider::on_unrealize() { + _refGdkWindow.reset(); + + Gtk::Widget::on_unrealize(); +} + +void ColorSlider::on_size_request(Gtk::Requisition* requisition) { + GtkStyle *style = gtk_widget_get_style(gobj()); + requisition->width = SLIDER_WIDTH + style->xthickness * 2; + requisition->height = SLIDER_HEIGHT + style->ythickness * 2; +} + +//TODO: GTK3 prefferred width/height + +void ColorSlider::on_size_allocate(Gtk::Allocation& allocation) { + if (get_realized()) { + _refGdkWindow->move_resize(allocation.get_x(), allocation.get_y(), + allocation.get_width(), allocation.get_height()); + } +} + +//TODO: if not GTK3 +bool ColorSlider::on_expose_event(GdkEventExpose* event) { + bool result = false; + + if (get_is_drawable()) { + Cairo::RefPtr cr = _refGdkWindow->create_cairo_context(); + result = on_draw(cr); + } + return result; +} + +bool ColorSlider::on_button_press_event(GdkEventButton *event) { + //TODO: implementation + return false; +} + +bool ColorSlider::on_button_release_event(GdkEventButton *event) { + //TODO: implementation + return false; +} + +bool ColorSlider::on_motion_notify_event(GdkEventMotion *event) { + //TODO: implementation + return false; +} + +void ColorSlider::set_adjustment(Gtk::Adjustment* /*adjustment*/) { + //TODO: implementation +} + +void ColorSlider::set_colors(guint32 start, guint32 min, guint32 end) { + +} + +void ColorSlider::set_map(const guchar *map) { + +} + +void ColorSlider::set_background(guint dark, guint light, guint size) { + +} + +bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { + return false; +} + +}//namespace Widget +}//namespace UI +}//namespace Inkscape + + + + + + + + + + + + + + + + + + + + + + + + +enum { + GRABBED, + DRAGGED, + RELEASED, + CHANGED, + LAST_SIGNAL +}; + +static void sp_color_slider_class_init (SPColorSliderClass *klass); +static void sp_color_slider_init (SPColorSlider *slider); +static void sp_color_slider_dispose(GObject *object); + +static void sp_color_slider_realize (GtkWidget *widget); +static void sp_color_slider_size_request (GtkWidget *widget, GtkRequisition *requisition); + +#if GTK_CHECK_VERSION(3,0,0) +static void sp_color_slider_get_preferred_width(GtkWidget *widget, + gint *minimal_width, + gint *natural_width); + +static void sp_color_slider_get_preferred_height(GtkWidget *widget, + gint *minimal_height, + gint *natural_height); +#else +static gboolean sp_color_slider_expose(GtkWidget *widget, GdkEventExpose *event); +#endif + +static void sp_color_slider_size_allocate (GtkWidget *widget, GtkAllocation *allocation); + +static gboolean sp_color_slider_draw(GtkWidget *widget, cairo_t *cr); + +static gint sp_color_slider_button_press (GtkWidget *widget, GdkEventButton *event); +static gint sp_color_slider_button_release (GtkWidget *widget, GdkEventButton *event); +static gint sp_color_slider_motion_notify (GtkWidget *widget, GdkEventMotion *event); + +static void sp_color_slider_adjustment_changed (GtkAdjustment *adjustment, SPColorSlider *slider); +static void sp_color_slider_adjustment_value_changed (GtkAdjustment *adjustment, SPColorSlider *slider); + +static const guchar *sp_color_slider_render_gradient (gint x0, gint y0, gint width, gint height, + gint c[], gint dc[], guint b0, guint b1, guint mask); +static const guchar *sp_color_slider_render_map (gint x0, gint y0, gint width, gint height, + guchar *map, gint start, gint step, guint b0, guint b1, guint mask); + +static GtkWidgetClass *parent_class; +static guint slider_signals[LAST_SIGNAL] = {0}; + +GType +sp_color_slider_get_type (void) +{ + static GType type = 0; + if (!type) { + GTypeInfo info = { + sizeof (SPColorSliderClass), + NULL, NULL, + (GClassInitFunc) sp_color_slider_class_init, + NULL, NULL, + sizeof (SPColorSlider), + 0, + (GInstanceInitFunc) sp_color_slider_init, + NULL + }; + type = g_type_register_static (GTK_TYPE_WIDGET, "SPColorSlider", &info, (GTypeFlags)0); + } + return type; +} + +static void sp_color_slider_class_init(SPColorSliderClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS(klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass); + + parent_class = GTK_WIDGET_CLASS(g_type_class_peek_parent(klass)); + + slider_signals[GRABBED] = g_signal_new ("grabbed", + G_TYPE_FROM_CLASS(object_class), + (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE), + G_STRUCT_OFFSET (SPColorSliderClass, grabbed), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + slider_signals[DRAGGED] = g_signal_new ("dragged", + G_TYPE_FROM_CLASS(object_class), + (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE), + G_STRUCT_OFFSET (SPColorSliderClass, dragged), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + slider_signals[RELEASED] = g_signal_new ("released", + G_TYPE_FROM_CLASS(object_class), + (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE), + G_STRUCT_OFFSET (SPColorSliderClass, released), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + slider_signals[CHANGED] = g_signal_new ("changed", + G_TYPE_FROM_CLASS(object_class), + (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE), + G_STRUCT_OFFSET (SPColorSliderClass, changed), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + object_class->dispose = sp_color_slider_dispose; + + widget_class->realize = sp_color_slider_realize; +#if GTK_CHECK_VERSION(3,0,0) + widget_class->get_preferred_width = sp_color_slider_get_preferred_width; + widget_class->get_preferred_height = sp_color_slider_get_preferred_height; + widget_class->draw = sp_color_slider_draw; +#else + widget_class->size_request = sp_color_slider_size_request; + widget_class->expose_event = sp_color_slider_expose; +#endif + widget_class->size_allocate = sp_color_slider_size_allocate; +/* widget_class->draw_focus = sp_color_slider_draw_focus; */ +/* widget_class->draw_default = sp_color_slider_draw_default; */ + + widget_class->button_press_event = sp_color_slider_button_press; + widget_class->button_release_event = sp_color_slider_button_release; + widget_class->motion_notify_event = sp_color_slider_motion_notify; +} + +static void +sp_color_slider_init (SPColorSlider *slider) +{ + /* We are widget with window */ + gtk_widget_set_has_window (GTK_WIDGET(slider), TRUE); + + slider->dragging = FALSE; + + slider->adjustment = NULL; + slider->value = 0.0; + + slider->c0[0] = 0x00; + slider->c0[1] = 0x00; + slider->c0[2] = 0x00; + slider->c0[3] = 0xff; + + slider->cm[0] = 0xff; + slider->cm[1] = 0x00; + slider->cm[2] = 0x00; + slider->cm[3] = 0xff; + + slider->c1[0] = 0xff; + slider->c1[1] = 0xff; + slider->c1[2] = 0xff; + slider->c1[3] = 0xff; + + slider->b0 = 0x5f; + slider->b1 = 0xa0; + slider->bmask = 0x08; + + slider->map = NULL; +} + +static void sp_color_slider_dispose(GObject *object) +{ + SPColorSlider *slider = SP_COLOR_SLIDER (object); + + if (slider->adjustment) { + g_signal_handlers_disconnect_matched (G_OBJECT (slider->adjustment), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, slider); + g_object_unref (slider->adjustment); + slider->adjustment = NULL; + } + + if ((G_OBJECT_CLASS(parent_class))->dispose) + (* (G_OBJECT_CLASS(parent_class))->dispose) (object); +} + +static void +sp_color_slider_realize (GtkWidget *widget) +{ + GdkWindowAttr attributes; + gint attributes_mask; + GtkAllocation allocation; + + gtk_widget_get_allocation(widget, &allocation); + gtk_widget_set_realized (widget, TRUE); + + attributes.window_type = GDK_WINDOW_CHILD; + attributes.x = allocation.x; + attributes.y = allocation.y; + attributes.width = allocation.width; + attributes.height = allocation.height; + attributes.wclass = GDK_INPUT_OUTPUT; + attributes.visual = gdk_screen_get_system_visual(gdk_screen_get_default()); + +#if !GTK_CHECK_VERSION(3,0,0) + attributes.colormap = gdk_screen_get_system_colormap(gdk_screen_get_default()); +#endif + + attributes.event_mask = gtk_widget_get_events (widget); + attributes.event_mask |= (GDK_EXPOSURE_MASK | + GDK_BUTTON_PRESS_MASK | + GDK_BUTTON_RELEASE_MASK | + GDK_POINTER_MOTION_MASK | + GDK_ENTER_NOTIFY_MASK | + GDK_LEAVE_NOTIFY_MASK); +#if GTK_CHECK_VERSION(3,0,0) + attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL; +#else + attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP; +#endif + + gtk_widget_set_window(widget, + gdk_window_new(gtk_widget_get_parent_window(widget), + &attributes, attributes_mask)); + + gdk_window_set_user_data(gtk_widget_get_window(widget), widget); + +#if !GTK_CHECK_VERSION(3,0,0) + // This doesn't do anything in GTK+ 3 + gtk_widget_set_style(widget, + gtk_style_attach(gtk_widget_get_style(widget), + gtk_widget_get_window(widget))); +#endif +} + +static void +sp_color_slider_size_request (GtkWidget *widget, GtkRequisition *requisition) +{ + GtkStyle *style = gtk_widget_get_style(widget); + requisition->width = SLIDER_WIDTH + style->xthickness * 2; + requisition->height = SLIDER_HEIGHT + style->ythickness * 2; +} + +#if GTK_CHECK_VERSION(3,0,0) +static void sp_color_slider_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width) +{ + GtkRequisition requisition; + sp_color_slider_size_request(widget, &requisition); + *minimal_width = *natural_width = requisition.width; +} + +static void sp_color_slider_get_preferred_height(GtkWidget *widget, gint *minimal_height, gint *natural_height) +{ + GtkRequisition requisition; + sp_color_slider_size_request(widget, &requisition); + *minimal_height = *natural_height = requisition.height; +} +#endif + +static void +sp_color_slider_size_allocate (GtkWidget *widget, GtkAllocation *allocation) +{ + gtk_widget_set_allocation(widget, allocation); + + if (gtk_widget_get_realized (widget)) { + /* Resize GdkWindow */ + gdk_window_move_resize(gtk_widget_get_window(widget), + allocation->x, allocation->y, + allocation->width, allocation->height); + } +} + +#if !GTK_CHECK_VERSION(3,0,0) +static gboolean sp_color_slider_expose(GtkWidget *widget, GdkEventExpose * /*event*/) +{ + gboolean result = FALSE; + + if (gtk_widget_is_drawable(widget)) { + GdkWindow *window = gtk_widget_get_window(widget); + cairo_t *cr = gdk_cairo_create(window); + result = sp_color_slider_draw(widget, cr); + cairo_destroy(cr); + } + + return result; +} +#endif + +static gint +sp_color_slider_button_press (GtkWidget *widget, GdkEventButton *event) +{ + SPColorSlider *slider; + + slider = SP_COLOR_SLIDER (widget); + + if (event->button == 1) { + GtkAllocation allocation; + gtk_widget_get_allocation(widget, &allocation); + gint cx, cw; + cx = gtk_widget_get_style(widget)->xthickness; + cw = allocation.width - 2 * cx; + g_signal_emit (G_OBJECT (slider), slider_signals[GRABBED], 0); + slider->dragging = TRUE; + slider->oldvalue = slider->value; + ColorScales::setScaled( slider->adjustment, CLAMP ((gfloat) (event->x - cx) / cw, 0.0, 1.0) ); + g_signal_emit (G_OBJECT (slider), slider_signals[DRAGGED], 0); + +#if GTK_CHECK_VERSION(3,0,0) + gdk_device_grab(gdk_event_get_device(reinterpret_cast(event)), + gtk_widget_get_window(widget), + GDK_OWNERSHIP_NONE, + FALSE, + static_cast(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK), + NULL, + event->time); +#else + gdk_pointer_grab(gtk_widget_get_window(widget), FALSE, + static_cast(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK), + NULL, NULL, event->time); +#endif + } + + return FALSE; +} + +static gint +sp_color_slider_button_release (GtkWidget *widget, GdkEventButton *event) +{ + SPColorSlider *slider; + + slider = SP_COLOR_SLIDER (widget); + + if (event->button == 1) { + +#if GTK_CHECK_VERSION(3,0,0) + gdk_device_ungrab(gdk_event_get_device(reinterpret_cast(event)), + gdk_event_get_time(reinterpret_cast(event))); +#else + gdk_pointer_ungrab (event->time); +#endif + + slider->dragging = FALSE; + g_signal_emit (G_OBJECT (slider), slider_signals[RELEASED], 0); + if (slider->value != slider->oldvalue) g_signal_emit (G_OBJECT (slider), slider_signals[CHANGED], 0); + } + + return FALSE; +} + +static gint +sp_color_slider_motion_notify (GtkWidget *widget, GdkEventMotion *event) +{ + SPColorSlider *slider; + + slider = SP_COLOR_SLIDER (widget); + + if (slider->dragging) { + gint cx, cw; + GtkAllocation allocation; + gtk_widget_get_allocation(widget, &allocation); + cx = gtk_widget_get_style(widget)->xthickness; + cw = allocation.width - 2 * cx; + ColorScales::setScaled( slider->adjustment, CLAMP ((gfloat) (event->x - cx) / cw, 0.0, 1.0) ); + g_signal_emit (G_OBJECT (slider), slider_signals[DRAGGED], 0); + } + + return FALSE; +} + +GtkWidget *sp_color_slider_new(GtkAdjustment *adjustment) +{ + SPColorSlider *slider = SP_COLOR_SLIDER(g_object_new(SP_TYPE_COLOR_SLIDER, NULL)); + + sp_color_slider_set_adjustment (slider, adjustment); + + return GTK_WIDGET (slider); +} + +void sp_color_slider_set_adjustment(SPColorSlider *slider, GtkAdjustment *adjustment) +{ + g_return_if_fail (slider != NULL); + g_return_if_fail (SP_IS_COLOR_SLIDER (slider)); + + if (!adjustment) { + adjustment = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 1.0, 0.01, 0.0, 0.0)); + } else { + gtk_adjustment_set_page_increment(adjustment, 0.0); + gtk_adjustment_set_page_size(adjustment, 0.0); + } + + if (slider->adjustment != adjustment) { + if (slider->adjustment) { + g_signal_handlers_disconnect_matched (G_OBJECT (slider->adjustment), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, slider); + g_object_unref (slider->adjustment); + } + + slider->adjustment = adjustment; + g_object_ref (adjustment); + g_object_ref_sink (adjustment); + + g_signal_connect (G_OBJECT (adjustment), "changed", + G_CALLBACK (sp_color_slider_adjustment_changed), slider); + g_signal_connect (G_OBJECT (adjustment), "value_changed", + G_CALLBACK (sp_color_slider_adjustment_value_changed), slider); + + slider->value = ColorScales::getScaled( adjustment ); + + sp_color_slider_adjustment_changed (adjustment, slider); + } +} + +void +sp_color_slider_set_colors (SPColorSlider *slider, guint32 start, guint32 mid, guint32 end) +{ + g_return_if_fail (slider != NULL); + g_return_if_fail (SP_IS_COLOR_SLIDER (slider)); + + // Remove any map, if set + slider->map = 0; + + slider->c0[0] = start >> 24; + slider->c0[1] = (start >> 16) & 0xff; + slider->c0[2] = (start >> 8) & 0xff; + slider->c0[3] = start & 0xff; + + slider->cm[0] = mid >> 24; + slider->cm[1] = (mid >> 16) & 0xff; + slider->cm[2] = (mid >> 8) & 0xff; + slider->cm[3] = mid & 0xff; + + slider->c1[0] = end >> 24; + slider->c1[1] = (end >> 16) & 0xff; + slider->c1[2] = (end >> 8) & 0xff; + slider->c1[3] = end & 0xff; + + gtk_widget_queue_draw (GTK_WIDGET (slider)); +} + +void +sp_color_slider_set_map (SPColorSlider *slider, const guchar *map) +{ + g_return_if_fail (slider != NULL); + g_return_if_fail (SP_IS_COLOR_SLIDER (slider)); + + slider->map = const_cast(map); + + gtk_widget_queue_draw (GTK_WIDGET (slider)); +} + +void +sp_color_slider_set_background (SPColorSlider *slider, guint dark, guint light, guint size) +{ + g_return_if_fail (slider != NULL); + g_return_if_fail (SP_IS_COLOR_SLIDER (slider)); + + slider->b0 = dark; + slider->b1 = light; + slider->bmask = size; + + gtk_widget_queue_draw (GTK_WIDGET (slider)); +} + +static void +sp_color_slider_adjustment_changed (GtkAdjustment */*adjustment*/, SPColorSlider *slider) +{ + gtk_widget_queue_draw (GTK_WIDGET (slider)); +} + +static void +sp_color_slider_adjustment_value_changed (GtkAdjustment *adjustment, SPColorSlider *slider) +{ + GtkWidget *widget; + + widget = GTK_WIDGET (slider); + + if (slider->value != ColorScales::getScaled( adjustment )) { + gint cx, cy, cw, ch; + GtkStyle *style = gtk_widget_get_style(widget); + GtkAllocation allocation; + gtk_widget_get_allocation(widget, &allocation); + cx = style->xthickness; + cy = style->ythickness; + cw = allocation.width - 2 * cx; + ch = allocation.height - 2 * cy; + if ((gint) (ColorScales::getScaled( adjustment ) * cw) != (gint) (slider->value * cw)) { + gint ax, ay; + gfloat value; + value = slider->value; + slider->value = ColorScales::getScaled( adjustment ); + ax = (int)(cx + value * cw - ARROW_SIZE / 2 - 2); + ay = cy; + gtk_widget_queue_draw_area (widget, ax, ay, ARROW_SIZE + 4, ch); + ax = (int)(cx + slider->value * cw - ARROW_SIZE / 2 - 2); + ay = cy; + gtk_widget_queue_draw_area (widget, ax, ay, ARROW_SIZE + 4, ch); + } else { + slider->value = ColorScales::getScaled( adjustment ); + } + } +} + +static gboolean sp_color_slider_draw(GtkWidget *widget, cairo_t *cr) +{ + SPColorSlider *slider = SP_COLOR_SLIDER(widget); + + gboolean colorsOnTop = Inkscape::Preferences::get()->getBool("/options/workarounds/colorsontop", false); + + GtkAllocation allocation; + gtk_widget_get_allocation(widget, &allocation); + +#if GTK_CHECK_VERSION(3,0,0) + GtkStyleContext *context = gtk_widget_get_style_context(widget); +#else + GdkWindow *window = gtk_widget_get_window(widget); + GtkStyle *style = gtk_widget_get_style(widget); +#endif + + // Draw shadow + if (colorsOnTop) { +#if GTK_CHECK_VERSION(3,0,0) + gtk_render_frame(context, + cr, + 0, 0, + allocation.width, allocation.height); +#else + gtk_paint_shadow( style, window, + gtk_widget_get_state(widget), GTK_SHADOW_IN, + NULL, widget, "colorslider", + 0, 0, + allocation.width, allocation.height); +#endif + } + + /* Paintable part of color gradient area */ + GdkRectangle carea; + +#if GTK_CHECK_VERSION(3,0,0) + GtkBorder padding; + + gtk_style_context_get_padding(context, + gtk_widget_get_state_flags(widget), + &padding); + + carea.x = padding.left; + carea.y = padding.top; +#else + carea.x = style->xthickness; + carea.y = style->ythickness; +#endif + + carea.width = allocation.width - 2 * carea.x; + carea.height = allocation.height - 2 * carea.y; + + if (slider->map) { + /* Render map pixelstore */ + gint d = (1024 << 16) / carea.width; + gint s = 0; + + const guchar *b = sp_color_slider_render_map(0, 0, carea.width, carea.height, + slider->map, s, d, + slider->b0, slider->b1, slider->bmask); + + if (b != NULL && carea.width > 0) { + GdkPixbuf *pb = gdk_pixbuf_new_from_data (b, GDK_COLORSPACE_RGB, + 0, 8, carea.width, carea.height, carea.width * 3, NULL, NULL); + + gdk_cairo_set_source_pixbuf(cr, pb, carea.x, carea.y); + cairo_paint(cr); + g_object_unref(pb); + } + + } else { + gint c[4], dc[4]; + + /* Render gradient */ + + // part 1: from c0 to cm + if (carea.width > 0) { + for (gint i = 0; i < 4; i++) { + c[i] = slider->c0[i] << 16; + dc[i] = ((slider->cm[i] << 16) - c[i]) / (carea.width/2); + } + guint wi = carea.width/2; + const guchar *b = sp_color_slider_render_gradient(0, 0, wi, carea.height, + c, dc, slider->b0, slider->b1, slider->bmask); + + /* Draw pixelstore 1 */ + if (b != NULL && wi > 0) { + GdkPixbuf *pb = gdk_pixbuf_new_from_data (b, GDK_COLORSPACE_RGB, + 0, 8, wi, carea.height, wi * 3, NULL, NULL); + + gdk_cairo_set_source_pixbuf(cr, pb, carea.x, carea.y); + cairo_paint(cr); + g_object_unref(pb); + } + } + + // part 2: from cm to c1 + if (carea.width > 0) { + for (gint i = 0; i < 4; i++) { + c[i] = slider->cm[i] << 16; + dc[i] = ((slider->c1[i] << 16) - c[i]) / (carea.width/2); + } + guint wi = carea.width/2; + const guchar *b = sp_color_slider_render_gradient(carea.width/2, 0, wi, carea.height, + c, dc, + slider->b0, slider->b1, slider->bmask); + + /* Draw pixelstore 2 */ + if (b != NULL && wi > 0) { + GdkPixbuf *pb = gdk_pixbuf_new_from_data (b, GDK_COLORSPACE_RGB, + 0, 8, wi, carea.height, wi * 3, NULL, NULL); + + gdk_cairo_set_source_pixbuf(cr, pb, carea.width/2 + carea.x, carea.y); + cairo_paint(cr); + + g_object_unref(pb); + } + } + } + + /* Draw shadow */ + if (!colorsOnTop) { +#if GTK_CHECK_VERSION(3,0,0) + gtk_render_frame(context, + cr, + 0, 0, + allocation.width, allocation.height); +#else + gtk_paint_shadow( style, window, + gtk_widget_get_state(widget), GTK_SHADOW_IN, + NULL, widget, "colorslider", + 0, 0, + allocation.width, allocation.height); +#endif + } + + /* Draw arrow */ + gint x = (int)(slider->value * (carea.width - 1) - ARROW_SIZE / 2 + carea.x); + gint y1 = carea.y; + gint y2 = carea.y + carea.height - 1; + cairo_set_line_width(cr, 1.0); + + // Define top arrow + cairo_move_to(cr, x - 0.5, y1 + 0.5); + cairo_line_to(cr, x + ARROW_SIZE - 0.5, y1 + 0.5); + cairo_line_to(cr, x + (ARROW_SIZE-1)/2.0, y1 + ARROW_SIZE/2.0 + 0.5); + cairo_line_to(cr, x - 0.5, y1 + 0.5); + + // Define bottom arrow + cairo_move_to(cr, x - 0.5, y2 + 0.5); + cairo_line_to(cr, x + ARROW_SIZE - 0.5, y2 + 0.5); + cairo_line_to(cr, x + (ARROW_SIZE-1)/2.0, y2 - ARROW_SIZE/2.0 + 0.5); + cairo_line_to(cr, x - 0.5, y2 + 0.5); + + // Render both arrows + cairo_set_source_rgb(cr, 1.0, 1.0, 1.0); + cairo_stroke_preserve(cr); + cairo_set_source_rgb(cr, 0.0, 0.0, 0.0); + cairo_fill(cr); + + return FALSE; +} + +/* Colors are << 16 */ + +static const guchar * +sp_color_slider_render_gradient (gint x0, gint y0, gint width, gint height, + gint c[], gint dc[], guint b0, guint b1, guint mask) +{ + static guchar *buf = NULL; + static gint bs = 0; + guchar *dp; + gint x, y; + guint r, g, b, a; + + if (buf && (bs < width * height)) { + g_free (buf); + buf = NULL; + } + if (!buf) { + buf = g_new (guchar, width * height * 3); + bs = width * height; + } + + dp = buf; + r = c[0]; + g = c[1]; + b = c[2]; + a = c[3]; + for (x = x0; x < x0 + width; x++) { + gint cr, cg, cb, ca; + guchar *d; + cr = r >> 16; + cg = g >> 16; + cb = b >> 16; + ca = a >> 16; + d = dp; + for (y = y0; y < y0 + height; y++) { + guint bg, fc; + /* Background value */ + bg = ((x & mask) ^ (y & mask)) ? b0 : b1; + fc = (cr - bg) * ca; + d[0] = bg + ((fc + (fc >> 8) + 0x80) >> 8); + fc = (cg - bg) * ca; + d[1] = bg + ((fc + (fc >> 8) + 0x80) >> 8); + fc = (cb - bg) * ca; + d[2] = bg + ((fc + (fc >> 8) + 0x80) >> 8); + d += 3 * width; + } + r += dc[0]; + g += dc[1]; + b += dc[2]; + a += dc[3]; + dp += 3; + } + + return buf; +} + +/* Positions are << 16 */ + +static const guchar * +sp_color_slider_render_map (gint x0, gint y0, gint width, gint height, + guchar *map, gint start, gint step, guint b0, guint b1, guint mask) +{ + static guchar *buf = NULL; + static gint bs = 0; + guchar *dp; + gint x, y; + + if (buf && (bs < width * height)) { + g_free (buf); + buf = NULL; + } + if (!buf) { + buf = g_new (guchar, width * height * 3); + bs = width * height; + } + + dp = buf; + for (x = x0; x < x0 + width; x++) { + gint cr, cg, cb, ca; + guchar *d = dp; + guchar *sp = map + 4 * (start >> 16); + cr = *sp++; + cg = *sp++; + cb = *sp++; + ca = *sp++; + for (y = y0; y < y0 + height; y++) { + guint bg, fc; + /* Background value */ + bg = ((x & mask) ^ (y & mask)) ? b0 : b1; + fc = (cr - bg) * ca; + d[0] = bg + ((fc + (fc >> 8) + 0x80) >> 8); + fc = (cg - bg) * ca; + d[1] = bg + ((fc + (fc >> 8) + 0x80) >> 8); + fc = (cb - bg) * ca; + d[2] = bg + ((fc + (fc >> 8) + 0x80) >> 8); + d += 3 * width; + } + dp += 3; + start += step; + } + + return buf; +} + diff --git a/src/ui/widget/color-slider.h b/src/ui/widget/color-slider.h new file mode 100644 index 000000000..d8be7d111 --- /dev/null +++ b/src/ui/widget/color-slider.h @@ -0,0 +1,146 @@ +#ifndef __SP_COLOR_SLIDER_H__ +#define __SP_COLOR_SLIDER_H__ + +/* Author: + * Lauris Kaplinski + * + * Copyright (C) 2001-2002 Lauris Kaplinski + * + * This code is in public domain + */ + +#ifdef HAVE_CONFIG_H +# include +#endif + +#if GLIBMM_DISABLE_DEPRECATED && HAVE_GLIBMM_THREADS_H +#include +#endif + +#include +#include + +namespace Inkscape +{ +namespace UI +{ +namespace Widget +{ + +/* + * A slider with colored background + */ +class ColorSlider: public Gtk::Widget { +public: + //if GTK2 + ColorSlider(Gtk::Adjustment *adjustment); + ~ColorSlider(); + + void set_adjustment(Gtk::Adjustment *adjustment); + + void set_colors(guint32 start, guint32 mid, guint32 end); + + void set_map(const guchar* map); + + void set_background(guint dark, guint light, guint size); + + sigc::signal signal_grabbed; + sigc::signal signal_dragged; + sigc::signal signal_released; + sigc::signal signal_value_changed; + +protected: + void on_size_allocate(Gtk::Allocation& allocation); + void on_realize(); + void on_unrealize(); + bool on_button_press_event(GdkEventButton *event); + bool on_button_release_event(GdkEventButton *event); + bool on_motion_notify_event(GdkEventMotion *event); + + //if GTK2 + void on_size_request(Gtk::Requisition* requisition); + bool on_expose_event(GdkEventExpose* event); + //if GTK3 + //request mode, get preffered width/height vfunc + //endif + + bool on_draw(const Cairo::RefPtr& cr); + + //TODO: on_adjustment_changed method + //TODO: on_adjustment value changed method + connection + +private: + bool _dragging; + + Gtk::Adjustment *_adjustment; + + gfloat _value; + gfloat _oldvalue; + guchar _c0[4], _cm[4], _c1[4]; + guchar _b0, _b1; + guchar _bmask; + + gint _mapsize; + guchar *_map; + + Glib::RefPtr _refGdkWindow; +}; + +}//namespace Widget +}//namespace UI +}//namespace Inkscape + + +#include + +#include + + + +struct SPColorSlider; +struct SPColorSliderClass; + +#define SP_TYPE_COLOR_SLIDER (sp_color_slider_get_type ()) +#define SP_COLOR_SLIDER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SP_TYPE_COLOR_SLIDER, SPColorSlider)) +#define SP_COLOR_SLIDER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), SP_TYPE_COLOR_SLIDER, SPColorSliderClass)) +#define SP_IS_COLOR_SLIDER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), SP_TYPE_COLOR_SLIDER)) +#define SP_IS_COLOR_SLIDER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SP_TYPE_COLOR_SLIDER)) + +struct SPColorSlider { + GtkWidget widget; + + guint dragging : 1; + + GtkAdjustment *adjustment; + + gfloat value; + gfloat oldvalue; + guchar c0[4], cm[4], c1[4]; + guchar b0, b1; + guchar bmask; + + gint mapsize; + guchar *map; +}; + +struct SPColorSliderClass { + GtkWidgetClass parent_class; + + void (* grabbed) (SPColorSlider *slider); + void (* dragged) (SPColorSlider *slider); + void (* released) (SPColorSlider *slider); + void (* changed) (SPColorSlider *slider); +}; + +GType sp_color_slider_get_type (void); + +GtkWidget *sp_color_slider_new (GtkAdjustment *adjustment); + +void sp_color_slider_set_adjustment (SPColorSlider *slider, GtkAdjustment *adjustment); +void sp_color_slider_set_colors (SPColorSlider *slider, guint32 start, guint32 mid, guint32 end); +void sp_color_slider_set_map (SPColorSlider *slider, const guchar *map); +void sp_color_slider_set_background (SPColorSlider *slider, guint dark, guint light, guint size); + + + +#endif -- cgit v1.2.3 From 07ce2371a81e1393032c2ce4e0c0373282df204b Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Fri, 23 May 2014 12:53:33 +0200 Subject: ported draw method (bzr r13341.6.4) --- src/ui/widget/color-slider.cpp | 173 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 167 insertions(+), 6 deletions(-) (limited to 'src/ui/widget') diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index 430239f00..d927a7f67 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -29,6 +29,11 @@ static const gint SLIDER_WIDTH = 96; static const gint SLIDER_HEIGHT = 8; static const gint ARROW_SIZE = 7; +static const guchar *sp_color_slider_render_gradient (gint x0, gint y0, gint width, gint height, + gint c[], gint dc[], guint b0, guint b1, guint mask); +static const guchar *sp_color_slider_render_map (gint x0, gint y0, gint width, gint height, + guchar *map, gint start, gint step, guint b0, guint b1, guint mask); + namespace Inkscape { namespace UI { namespace Widget { @@ -165,8 +170,26 @@ void ColorSlider::set_adjustment(Gtk::Adjustment* /*adjustment*/) { //TODO: implementation } -void ColorSlider::set_colors(guint32 start, guint32 min, guint32 end) { +void ColorSlider::set_colors(guint32 start, guint32 mid, guint32 end) { + // Remove any map, if set + _map = 0; + + _c0[0] = start >> 24; + _c0[1] = (start >> 16) & 0xff; + _c0[2] = (start >> 8) & 0xff; + _c0[3] = start & 0xff; + _cm[0] = mid >> 24; + _cm[1] = (mid >> 16) & 0xff; + _cm[2] = (mid >> 8) & 0xff; + _cm[3] = mid & 0xff; + + _c1[0] = end >> 24; + _c1[1] = (end >> 16) & 0xff; + _c1[2] = (end >> 8) & 0xff; + _c1[3] = end & 0xff; + + queue_draw(); } void ColorSlider::set_map(const guchar *map) { @@ -178,6 +201,149 @@ void ColorSlider::set_background(guint dark, guint light, guint size) { } bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { + gboolean colorsOnTop = Inkscape::Preferences::get()->getBool("/options/workarounds/colorsontop", false); + + Gtk::Allocation allocation = get_allocation(); + +#if GTK_CHECK_VERSION(3,0,0) + Glib::RefPtr context = get_style_context(); +#else + Glib::RefPtr window = get_window(); + Glib::RefPtr style = get_style(); +#endif + + // Draw shadow + if (colorsOnTop) { +#if GTK_CHECK_VERSION(3,0,0) + context->render_frame(cr, 0, 0, + allocation.get_width(), allocation.get_height()); +#else + style->paint_shadow(window, get_state(), Gtk::SHADOW_IN, + Gdk::Rectangle(), *this, "colorslider", + 0, 0, + allocation.get_width(), allocation.get_height()); +#endif + } + + /* Paintable part of color gradient area */ + Gdk::Rectangle carea; + +#if GTK_CHECK_VERSION(3,0,0) + Gtk::Border padding; + + padding = style_context->get_padding(get_state_flags()); + + carea.set_x(padding.get_left()); + carea.set_y(padding.get_top());; +#else + carea.set_x(style->get_xthickness()); + carea.set_y(style->get_ythickness()); +#endif + + carea.set_width(allocation.get_width() - 2 * carea.get_x()); + carea.set_height(allocation.get_height() - 2 * carea.get_y()); + + if (_map) { + /* Render map pixelstore */ + gint d = (1024 << 16) / carea.get_width(); + gint s = 0; + + const guchar *b = sp_color_slider_render_map(0, 0, carea.get_width(), carea.get_height(), + _map, s, d, + _b0, _b1, _bmask); + + if (b != NULL && carea.get_width() > 0) { + Glib::RefPtr pb = Gdk::Pixbuf::create_from_data(b, Gdk::COLORSPACE_RGB, + false, 8, carea.get_width(), carea.get_height(), carea.get_width() * 3); + + Gdk::Cairo::set_source_pixbuf(cr, pb, carea.get_x(), carea.get_y()); + cr->paint(); + } + + } else { + gint c[4], dc[4]; + + /* Render gradient */ + + // part 1: from c0 to cm + if (carea.get_width() > 0) { + for (gint i = 0; i < 4; i++) { + c[i] = _c0[i] << 16; + dc[i] = ((_cm[i] << 16) - c[i]) / (carea.get_width()/2); + } + guint wi = carea.get_width()/2; + const guchar *b = sp_color_slider_render_gradient(0, 0, wi, carea.get_height(), + c, dc, _b0, _b1, _bmask); + + /* Draw pixelstore 1 */ + if (b != NULL && wi > 0) { + Glib::RefPtr pb = Gdk::Pixbuf::create_from_data(b, Gdk::COLORSPACE_RGB, + false, 8, wi, carea.get_height(), carea.get_width() * 3); + + Gdk::Cairo::set_source_pixbuf(cr, pb, carea.get_x(), carea.get_y()); + cr->paint(); + } + } + + // part 2: from cm to c1 + if (carea.get_width() > 0) { + for (gint i = 0; i < 4; i++) { + c[i] = _cm[i] << 16; + dc[i] = ((_c1[i] << 16) - c[i]) / (carea.get_width()/2); + } + guint wi = carea.get_width()/2; + const guchar *b = sp_color_slider_render_gradient(carea.get_width()/2, 0, wi, carea.get_height(), + c, dc, + _b0, _b1, _bmask); + + /* Draw pixelstore 2 */ + if (b != NULL && wi > 0) { + Glib::RefPtr pb = Gdk::Pixbuf::create_from_data(b, Gdk::COLORSPACE_RGB, + false, 8, wi, carea.get_height(), carea.get_width() * 3); + + Gdk::Cairo::set_source_pixbuf(cr, pb, carea.get_width()/2 + carea.get_x(), carea.get_y()); + cr->paint(); + } + } + } + + /* Draw shadow */ + if (!colorsOnTop) { +#if GTK_CHECK_VERSION(3,0,0) + context->render_frame(cr, 0, 0, + allocation.get_width(), allocation.get_height()); +#else + style->paint_shadow(window, get_state(), Gtk::SHADOW_IN, + Gdk::Rectangle(), *this, "colorslider", + 0, 0, + allocation.get_width(), allocation.get_height()); +#endif + } + + /* Draw arrow */ + gint x = (int)(_value * (carea.get_width() - 1) - ARROW_SIZE / 2 + carea.get_x()); + gint y1 = carea.get_y(); + gint y2 = carea.get_y() + carea.get_height() - 1; + cr->set_line_width(1.0); + + // Define top arrow + cr->move_to(x - 0.5, y1 + 0.5); + cr->line_to(x + ARROW_SIZE - 0.5, y1 + 0.5); + cr->line_to(x + (ARROW_SIZE-1)/2.0, y1 + ARROW_SIZE/2.0 + 0.5); + cr->line_to(x - 0.5, y1 + 0.5); + + // Define bottom arrow + cr->move_to(x - 0.5, y2 + 0.5); + cr->line_to(x + ARROW_SIZE - 0.5, y2 + 0.5); + cr->line_to(x + (ARROW_SIZE-1)/2.0, y2 - ARROW_SIZE/2.0 + 0.5); + cr->line_to(x - 0.5, y2 + 0.5); + + // Render both arrows + cr->set_source_rgb(1.0, 1.0, 1.0); + cr->stroke_preserve(); + cr->set_source_rgb(0.0, 0.0, 0.0); + cr->fill(); + return false; } @@ -246,11 +412,6 @@ static gint sp_color_slider_motion_notify (GtkWidget *widget, GdkEventMotion *ev static void sp_color_slider_adjustment_changed (GtkAdjustment *adjustment, SPColorSlider *slider); static void sp_color_slider_adjustment_value_changed (GtkAdjustment *adjustment, SPColorSlider *slider); -static const guchar *sp_color_slider_render_gradient (gint x0, gint y0, gint width, gint height, - gint c[], gint dc[], guint b0, guint b1, guint mask); -static const guchar *sp_color_slider_render_map (gint x0, gint y0, gint width, gint height, - guchar *map, gint start, gint step, guint b0, guint b1, guint mask); - static GtkWidgetClass *parent_class; static guint slider_signals[LAST_SIGNAL] = {0}; -- cgit v1.2.3 From 837f710ed9947b30a77a990ae27beed10449f977 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 24 May 2014 01:32:04 +0200 Subject: SPColorSlider c++-sification: ported drawing (bzr r13341.6.5) --- src/ui/widget/color-slider.cpp | 79 ++++++++++++++++++++++++++++++++++++++---- src/ui/widget/color-slider.h | 6 ++++ 2 files changed, 78 insertions(+), 7 deletions(-) (limited to 'src/ui/widget') diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index d927a7f67..82eafdcf8 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -70,8 +70,9 @@ ColorSlider::ColorSlider(Gtk::Adjustment* adjustment) ColorSlider::~ColorSlider() { if (_adjustment) { - //TODO: disconnect all connections - delete _adjustment; + _adjustment_changed_connection.disconnect(); + _adjustment_value_changed_connection.disconnect(); + _adjustment->unreference(); _adjustment = NULL; } } @@ -134,6 +135,8 @@ void ColorSlider::on_size_request(Gtk::Requisition* requisition) { //TODO: GTK3 prefferred width/height void ColorSlider::on_size_allocate(Gtk::Allocation& allocation) { + set_allocation(allocation); + if (get_realized()) { _refGdkWindow->move_resize(allocation.get_x(), allocation.get_y(), allocation.get_width(), allocation.get_height()); @@ -166,8 +169,64 @@ bool ColorSlider::on_motion_notify_event(GdkEventMotion *event) { return false; } -void ColorSlider::set_adjustment(Gtk::Adjustment* /*adjustment*/) { - //TODO: implementation +void ColorSlider::set_adjustment(Gtk::Adjustment *adjustment) { + if (!adjustment) { + _adjustment = Gtk::manage(new Gtk::Adjustment(0.0, 0.0, 1.0, 0.01, 0.0, 0.0)); + } else { + adjustment->set_page_increment(0.0); + adjustment->set_page_size(0.0); + } + + if (_adjustment != adjustment) { + if (_adjustment) { + _adjustment_changed_connection.disconnect(); + _adjustment_value_changed_connection.disconnect(); + //if GTK2 + _adjustment->unreference(); + } + + _adjustment = adjustment; + _adjustment->reference(); + + _adjustment_changed_connection = _adjustment->signal_changed().connect( + sigc::mem_fun(this, &ColorSlider::on_adjustment_changed)); + _adjustment_value_changed_connection = _adjustment->signal_value_changed().connect( + sigc::mem_fun(this, &ColorSlider::on_adjustment_value_changed)); + + _value = ColorScales::getScaled(_adjustment->gobj()); + + on_adjustment_changed(); + } +} + +void ColorSlider::on_adjustment_changed() { + queue_draw(); +} + +void ColorSlider::on_adjustment_value_changed() { + if (_value != ColorScales::getScaled( _adjustment->gobj() )) { + gint cx, cy, cw, ch; + Glib::RefPtr style = get_style(); + Gtk::Allocation allocation = get_allocation(); + cx = style->get_xthickness(); + cy = style->get_ythickness(); + cw = allocation.get_width() - 2 * cx; + ch = allocation.get_height() - 2 * cy; + if ((gint) (ColorScales::getScaled( _adjustment->gobj() ) * cw) != (gint) (_value * cw)) { + gint ax, ay; + gfloat value; + value = _value; + _value = ColorScales::getScaled( _adjustment->gobj() ); + ax = (int)(cx + value * cw - ARROW_SIZE / 2 - 2); + ay = cy; + queue_draw_area(ax, ay, ARROW_SIZE + 4, ch); + ax = (int)(cx + _value * cw - ARROW_SIZE / 2 - 2); + ay = cy; + queue_draw_area(ax, ay, ARROW_SIZE + 4, ch); + } else { + _value = ColorScales::getScaled( _adjustment->gobj() ); + } + } } void ColorSlider::set_colors(guint32 start, guint32 mid, guint32 end) { @@ -193,11 +252,17 @@ void ColorSlider::set_colors(guint32 start, guint32 mid, guint32 end) { } void ColorSlider::set_map(const guchar *map) { + _map = const_cast(map); + queue_draw(); } void ColorSlider::set_background(guint dark, guint light, guint size) { + _b0 = dark; + _b1 = light; + _bmask = size; + queue_draw(); } bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { @@ -278,7 +343,7 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { /* Draw pixelstore 1 */ if (b != NULL && wi > 0) { Glib::RefPtr pb = Gdk::Pixbuf::create_from_data(b, Gdk::COLORSPACE_RGB, - false, 8, wi, carea.get_height(), carea.get_width() * 3); + false, 8, wi, carea.get_height(), wi * 3); Gdk::Cairo::set_source_pixbuf(cr, pb, carea.get_x(), carea.get_y()); cr->paint(); @@ -299,7 +364,7 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { /* Draw pixelstore 2 */ if (b != NULL && wi > 0) { Glib::RefPtr pb = Gdk::Pixbuf::create_from_data(b, Gdk::COLORSPACE_RGB, - false, 8, wi, carea.get_height(), carea.get_width() * 3); + false, 8, wi, carea.get_height(), wi * 3); Gdk::Cairo::set_source_pixbuf(cr, pb, carea.get_width()/2 + carea.get_x(), carea.get_y()); cr->paint(); @@ -1012,7 +1077,7 @@ static gboolean sp_color_slider_draw(GtkWidget *widget, cairo_t *cr) cairo_stroke_preserve(cr); cairo_set_source_rgb(cr, 0.0, 0.0, 0.0); cairo_fill(cr); - + return FALSE; } diff --git a/src/ui/widget/color-slider.h b/src/ui/widget/color-slider.h index d8be7d111..7f3088772 100644 --- a/src/ui/widget/color-slider.h +++ b/src/ui/widget/color-slider.h @@ -36,6 +36,7 @@ public: ColorSlider(Gtk::Adjustment *adjustment); ~ColorSlider(); + //if GTK2 void set_adjustment(Gtk::Adjustment *adjustment); void set_colors(guint32 start, guint32 mid, guint32 end); @@ -70,9 +71,14 @@ protected: //TODO: on_adjustment value changed method + connection private: + void on_adjustment_changed(); + void on_adjustment_value_changed(); + bool _dragging; Gtk::Adjustment *_adjustment; + sigc::connection _adjustment_changed_connection; + sigc::connection _adjustment_value_changed_connection; gfloat _value; gfloat _oldvalue; -- cgit v1.2.3 From 84379bcbe7e5008ee24d0b1f465d2c55ff9529b7 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 24 May 2014 14:42:58 +0200 Subject: SPColorSlider c++-sification: ported mouse events (bzr r13341.6.6) --- src/ui/widget/color-slider.cpp | 53 +++++++++++++++++++++++++++++++++++++++--- 1 file changed, 50 insertions(+), 3 deletions(-) (limited to 'src/ui/widget') diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index 82eafdcf8..2c330e9ca 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -18,6 +18,7 @@ #include "color-slider.h" #include +#include #include #include #include @@ -155,17 +156,63 @@ bool ColorSlider::on_expose_event(GdkEventExpose* event) { } bool ColorSlider::on_button_press_event(GdkEventButton *event) { - //TODO: implementation + if (event->button == 1) { + Gtk::Allocation allocation = get_allocation(); + gint cx, cw; + cx = get_style()->get_xthickness(); + cw = allocation.get_width() - 2 * cx; + signal_grabbed.emit(); + _dragging = true; + _oldvalue = _value; + ColorScales::setScaled( _adjustment->gobj(), CLAMP ((gfloat) (event->x - cx) / cw, 0.0, 1.0) ); + signal_dragged.emit(); + +#if GTK_CHECK_VERSION(3,0,0) + gdk_device_grab(gdk_event_get_device(reinterpret_cast(event)), + _refGdkWindow->gobj(), + GDK_OWNERSHIP_NONE, + FALSE, + static_cast(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK), + NULL, + event->time); +#else + get_window()->pointer_grab(false, Gdk::POINTER_MOTION_MASK | Gdk::BUTTON_RELEASE_MASK, Gdk::Cursor(), event->time); +#endif + } + return false; } bool ColorSlider::on_button_release_event(GdkEventButton *event) { - //TODO: implementation + if (event->button == 1) { + +#if GTK_CHECK_VERSION(3,0,0) + gdk_device_ungrab(gdk_event_get_device(reinterpret_cast(event)), + gdk_event_get_time(reinterpret_cast(event))); +#else + get_window()->pointer_ungrab(event->time); +#endif + + _dragging = false; + signal_released.emit(); + if (_value != _oldvalue) { + signal_value_changed.emit(); + } + } + return false; } bool ColorSlider::on_motion_notify_event(GdkEventMotion *event) { - //TODO: implementation + if (_dragging) { + gint cx, cw; + Gtk::Allocation allocation = get_allocation(); + cx = get_style()->get_xthickness(); + cw = allocation.get_width() - 2 * cx; + ColorScales::setScaled( _adjustment->gobj(), CLAMP ((gfloat) (event->x - cx) / cw, 0.0, 1.0) ); + signal_dragged.emit(); + } + return false; } -- cgit v1.2.3 From a87f50a6174b65b8db1d0a091d30a5de206f03df Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 24 May 2014 15:07:28 +0200 Subject: SPColorSlider c++-sification: fixed drawing border (bzr r13341.6.7) --- src/ui/widget/color-slider.cpp | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) (limited to 'src/ui/widget') diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index 2c330e9ca..31ae5fbdf 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -330,10 +330,11 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { context->render_frame(cr, 0, 0, allocation.get_width(), allocation.get_height()); #else - style->paint_shadow(window, get_state(), Gtk::SHADOW_IN, - Gdk::Rectangle(), *this, "colorslider", - 0, 0, - allocation.get_width(), allocation.get_height()); + gtk_paint_shadow( style->gobj(), window->gobj(), + gtk_widget_get_state(gobj()), GTK_SHADOW_IN, + NULL, gobj(), "colorslider", + 0, 0, + allocation.get_width(), allocation.get_height()); #endif } @@ -425,10 +426,11 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { context->render_frame(cr, 0, 0, allocation.get_width(), allocation.get_height()); #else - style->paint_shadow(window, get_state(), Gtk::SHADOW_IN, - Gdk::Rectangle(), *this, "colorslider", - 0, 0, - allocation.get_width(), allocation.get_height()); + gtk_paint_shadow( style->gobj(), window->gobj(), + gtk_widget_get_state(gobj()), GTK_SHADOW_IN, + NULL, gobj(), "colorslider", + 0, 0, + allocation.get_width(), allocation.get_height()); #endif } -- cgit v1.2.3 From c77abbc4c33e15c742b477a178e90816f4ab3d67 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 24 May 2014 15:16:37 +0200 Subject: SPColorSlider c++-sification: fixed failed Gtk assertion (bzr r13341.6.8) --- src/ui/widget/color-slider.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'src/ui/widget') diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index 31ae5fbdf..b28393be0 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -176,7 +176,9 @@ bool ColorSlider::on_button_press_event(GdkEventButton *event) { NULL, event->time); #else - get_window()->pointer_grab(false, Gdk::POINTER_MOTION_MASK | Gdk::BUTTON_RELEASE_MASK, Gdk::Cursor(), event->time); + gdk_pointer_grab(get_window()->gobj(), FALSE, + static_cast(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK), + NULL, NULL, event->time); #endif } -- cgit v1.2.3 From 0d4b01e5ed7dd47bc2f1664845803de87ebb2b01 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 24 May 2014 16:40:56 +0200 Subject: SPColorSlider c++-sification: compilation with GTK3 (bzr r13341.6.9) --- src/ui/widget/color-slider.cpp | 99 ++++++++++++++++++++++++++++++++++-------- src/ui/widget/color-slider.h | 33 ++++++++------ 2 files changed, 100 insertions(+), 32 deletions(-) (limited to 'src/ui/widget') diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index b28393be0..450dcd6f6 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -22,6 +22,11 @@ #include #include #include +#if GTK_CHECK_VERSION(3,0,0) +#include +#else +#include +#endif #include "widgets/sp-color-scales.h" #include "preferences.h" @@ -39,9 +44,14 @@ namespace Inkscape { namespace UI { namespace Widget { +#if GTK_CHECK_VERSION(3,0,0) +ColorSlider::ColorSlider(Glib::RefPtr adjustment) + : _dragging(false) +#else ColorSlider::ColorSlider(Gtk::Adjustment* adjustment) : _dragging(false) , _adjustment(NULL) +#endif , _value(0.0) , _oldvalue(0.0) , _mapsize(0) @@ -73,8 +83,12 @@ ColorSlider::~ColorSlider() { if (_adjustment) { _adjustment_changed_connection.disconnect(); _adjustment_value_changed_connection.disconnect(); +#if GTK_CHECK_VERSION(3,0,0) + _adjustment.reset(); +#else _adjustment->unreference(); _adjustment = NULL; +#endif } } @@ -117,7 +131,9 @@ void ColorSlider::on_realize() { set_window(_refGdkWindow); _refGdkWindow->set_user_data(gobj()); +#if !GTK_CHECK_VERSION(3,0,0) style_attach(); +#endif } } @@ -127,14 +143,6 @@ void ColorSlider::on_unrealize() { Gtk::Widget::on_unrealize(); } -void ColorSlider::on_size_request(Gtk::Requisition* requisition) { - GtkStyle *style = gtk_widget_get_style(gobj()); - requisition->width = SLIDER_WIDTH + style->xthickness * 2; - requisition->height = SLIDER_HEIGHT + style->ythickness * 2; -} - -//TODO: GTK3 prefferred width/height - void ColorSlider::on_size_allocate(Gtk::Allocation& allocation) { set_allocation(allocation); @@ -144,7 +152,32 @@ void ColorSlider::on_size_allocate(Gtk::Allocation& allocation) { } } -//TODO: if not GTK3 +#if GTK_CHECK_VERSION(3,0,0) + +void ColorSlider::get_preferred_width_vfunc(int& minimum_width, int& natural_width) const +{ + Glib::RefPtrstyle_context = get_style_context(); + Gtk::Border padding = style_context->get_padding(get_state_flags()); + int width = SLIDER_WIDTH + padding.get_left() + padding.get_right(); + minimum_width = natural_width = width; + +} + +void ColorSlider::get_preferred_height_vfunc(int& minimum_height, int& natural_height) const +{ + Glib::RefPtrstyle_context = get_style_context(); + Gtk::Border padding = style_context->get_padding(get_state_flags()); + int height = SLIDER_WIDTH + padding.get_top() + padding.get_bottom(); + minimum_height = natural_height = height; +} +#else + +void ColorSlider::on_size_request(Gtk::Requisition* requisition) { + GtkStyle *style = gtk_widget_get_style(gobj()); + requisition->width = SLIDER_WIDTH + style->xthickness * 2; + requisition->height = SLIDER_HEIGHT + style->ythickness * 2; +} + bool ColorSlider::on_expose_event(GdkEventExpose* event) { bool result = false; @@ -155,11 +188,17 @@ bool ColorSlider::on_expose_event(GdkEventExpose* event) { return result; } +#endif + bool ColorSlider::on_button_press_event(GdkEventButton *event) { if (event->button == 1) { Gtk::Allocation allocation = get_allocation(); gint cx, cw; +#if GTK_CHECK_VERSION(3,0,0) + cx = get_style_context()->get_padding(get_state_flags()).get_left(); +#else cx = get_style()->get_xthickness(); +#endif cw = allocation.get_width() - 2 * cx; signal_grabbed.emit(); _dragging = true; @@ -209,7 +248,11 @@ bool ColorSlider::on_motion_notify_event(GdkEventMotion *event) { if (_dragging) { gint cx, cw; Gtk::Allocation allocation = get_allocation(); +#if GTK_CHECK_VERSION(3,0,0) + cx = get_style_context()->get_padding(get_state_flags()).get_left(); +#else cx = get_style()->get_xthickness(); +#endif cw = allocation.get_width() - 2 * cx; ColorScales::setScaled( _adjustment->gobj(), CLAMP ((gfloat) (event->x - cx) / cw, 0.0, 1.0) ); signal_dragged.emit(); @@ -218,9 +261,17 @@ bool ColorSlider::on_motion_notify_event(GdkEventMotion *event) { return false; } +#if GTK_CHECK_VERSION(3,0,0) +void ColorSlider::set_adjustment(Glib::RefPtr adjustment) { +#else void ColorSlider::set_adjustment(Gtk::Adjustment *adjustment) { +#endif if (!adjustment) { +#if GTK_CHECK_VERSION(3,0,0) + _adjustment = Gtk::Adjustment::create(0.0, 0.0, 1.0, 0.01, 0.0, 0.0); +#else _adjustment = Gtk::manage(new Gtk::Adjustment(0.0, 0.0, 1.0, 0.01, 0.0, 0.0)); +#endif } else { adjustment->set_page_increment(0.0); adjustment->set_page_size(0.0); @@ -230,35 +281,45 @@ void ColorSlider::set_adjustment(Gtk::Adjustment *adjustment) { if (_adjustment) { _adjustment_changed_connection.disconnect(); _adjustment_value_changed_connection.disconnect(); - //if GTK2 +#if !GTK_CHECK_VERSION(3,0,0) _adjustment->unreference(); +#endif } _adjustment = adjustment; +#if !GTK_CHECK_VERSION(3,0,0) _adjustment->reference(); - +#endif _adjustment_changed_connection = _adjustment->signal_changed().connect( - sigc::mem_fun(this, &ColorSlider::on_adjustment_changed)); + sigc::mem_fun(this, &ColorSlider::_on_adjustment_changed)); _adjustment_value_changed_connection = _adjustment->signal_value_changed().connect( - sigc::mem_fun(this, &ColorSlider::on_adjustment_value_changed)); + sigc::mem_fun(this, &ColorSlider::_on_adjustment_value_changed)); _value = ColorScales::getScaled(_adjustment->gobj()); - on_adjustment_changed(); + _on_adjustment_changed(); } } -void ColorSlider::on_adjustment_changed() { +void ColorSlider::_on_adjustment_changed() { queue_draw(); } -void ColorSlider::on_adjustment_value_changed() { +void ColorSlider::_on_adjustment_value_changed() { if (_value != ColorScales::getScaled( _adjustment->gobj() )) { gint cx, cy, cw, ch; +#if GTK_CHECK_VERSION(3,0,0) + Glib::RefPtrstyle_context = get_style_context(); + Gtk::Allocation allocation = get_allocation(); + Gtk::Border padding = style_context->get_padding(get_state_flags()); + cx = padding.get_left(); + cy = padding.get_top(); +#else Glib::RefPtr style = get_style(); Gtk::Allocation allocation = get_allocation(); cx = style->get_xthickness(); cy = style->get_ythickness(); +#endif cw = allocation.get_width() - 2 * cx; ch = allocation.get_height() - 2 * cy; if ((gint) (ColorScales::getScaled( _adjustment->gobj() ) * cw) != (gint) (_value * cw)) { @@ -320,7 +381,7 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { Gtk::Allocation allocation = get_allocation(); #if GTK_CHECK_VERSION(3,0,0) - Glib::RefPtr context = get_style_context(); + Glib::RefPtr style_context = get_style_context(); #else Glib::RefPtr window = get_window(); Glib::RefPtr style = get_style(); @@ -329,7 +390,7 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { // Draw shadow if (colorsOnTop) { #if GTK_CHECK_VERSION(3,0,0) - context->render_frame(cr, 0, 0, + style_context->render_frame(cr, 0, 0, allocation.get_width(), allocation.get_height()); #else gtk_paint_shadow( style->gobj(), window->gobj(), @@ -425,7 +486,7 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { /* Draw shadow */ if (!colorsOnTop) { #if GTK_CHECK_VERSION(3,0,0) - context->render_frame(cr, 0, 0, + style_context->render_frame(cr, 0, 0, allocation.get_width(), allocation.get_height()); #else gtk_paint_shadow( style->gobj(), window->gobj(), diff --git a/src/ui/widget/color-slider.h b/src/ui/widget/color-slider.h index 7f3088772..c6d843fe5 100644 --- a/src/ui/widget/color-slider.h +++ b/src/ui/widget/color-slider.h @@ -32,12 +32,18 @@ namespace Widget */ class ColorSlider: public Gtk::Widget { public: - //if GTK2 +#if GTK_CHECK_VERSION(3,0,0) + ColorSlider(Glib::RefPtr adjustment); +#else ColorSlider(Gtk::Adjustment *adjustment); +#endif ~ColorSlider(); - //if GTK2 +#if GTK_CHECK_VERSION(3,0,0) + void set_adjustment(Glib::RefPtr adjustment); +#else void set_adjustment(Gtk::Adjustment *adjustment); +#endif void set_colors(guint32 start, guint32 mid, guint32 end); @@ -57,26 +63,27 @@ protected: bool on_button_press_event(GdkEventButton *event); bool on_button_release_event(GdkEventButton *event); bool on_motion_notify_event(GdkEventMotion *event); + bool on_draw(const Cairo::RefPtr& cr); - //if GTK2 +#if GTK_CHECK_VERSION(3,0,0) + void get_preferred_width_vfunc(int& minimum_width, int& natural_width) const; + void get_preferred_height_vfunc(int& minimum_height, int& natural_height) const; +#else void on_size_request(Gtk::Requisition* requisition); bool on_expose_event(GdkEventExpose* event); - //if GTK3 - //request mode, get preffered width/height vfunc - //endif - - bool on_draw(const Cairo::RefPtr& cr); - - //TODO: on_adjustment_changed method - //TODO: on_adjustment value changed method + connection +#endif private: - void on_adjustment_changed(); - void on_adjustment_value_changed(); + void _on_adjustment_changed(); + void _on_adjustment_value_changed(); bool _dragging; +#if GTK_CHECK_VERSION(3,0,0) + Glib::RefPtr _adjustment; +#else Gtk::Adjustment *_adjustment; +#endif sigc::connection _adjustment_changed_connection; sigc::connection _adjustment_value_changed_connection; -- cgit v1.2.3 From c28cce00312a421bea39c4d78360e3939c573de3 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 24 May 2014 19:14:18 +0200 Subject: SPColorSlider c++-sification: fixed size request (bzr r13341.6.10) --- src/ui/widget/color-slider.cpp | 12 +++++++++++- src/ui/widget/color-slider.h | 2 ++ 2 files changed, 13 insertions(+), 1 deletion(-) (limited to 'src/ui/widget') diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index 450dcd6f6..ff69e6ed5 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -160,16 +160,26 @@ void ColorSlider::get_preferred_width_vfunc(int& minimum_width, int& natural_wid Gtk::Border padding = style_context->get_padding(get_state_flags()); int width = SLIDER_WIDTH + padding.get_left() + padding.get_right(); minimum_width = natural_width = width; +} +void ColorSlider::get_preferred_width_for_height_vfunc(int /*height*/, int& minimum_width, int& natural_width) const +{ + get_preferred_width(minimum_width, natural_width); } void ColorSlider::get_preferred_height_vfunc(int& minimum_height, int& natural_height) const { Glib::RefPtrstyle_context = get_style_context(); Gtk::Border padding = style_context->get_padding(get_state_flags()); - int height = SLIDER_WIDTH + padding.get_top() + padding.get_bottom(); + int height = SLIDER_HEIGHT + padding.get_top() + padding.get_bottom(); minimum_height = natural_height = height; } + +void ColorSlider::get_preferred_height_for_width_vfunc(int /*width*/, int& minimum_height, int& natural_height) const +{ + get_preferred_height(minimum_height, natural_height); +} + #else void ColorSlider::on_size_request(Gtk::Requisition* requisition) { diff --git a/src/ui/widget/color-slider.h b/src/ui/widget/color-slider.h index c6d843fe5..eb4cd99c3 100644 --- a/src/ui/widget/color-slider.h +++ b/src/ui/widget/color-slider.h @@ -67,7 +67,9 @@ protected: #if GTK_CHECK_VERSION(3,0,0) void get_preferred_width_vfunc(int& minimum_width, int& natural_width) const; + void get_preferred_width_for_height_vfunc(int height, int& minimum_width, int& natural_width) const; void get_preferred_height_vfunc(int& minimum_height, int& natural_height) const; + void get_preferred_height_for_width_vfunc(int width, int& minimum_height, int& natural_height) const; #else void on_size_request(Gtk::Requisition* requisition); bool on_expose_event(GdkEventExpose* event); -- cgit v1.2.3 From 8a251752c5dc2dc686b815f527f4ce20c477b03c Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sat, 24 May 2014 22:09:33 +0200 Subject: SPColorSlider c++-sification: remove gobject based code (bzr r13341.6.14) --- src/ui/widget/color-slider.cpp | 665 ----------------------------------------- src/ui/widget/color-slider.h | 53 ---- 2 files changed, 718 deletions(-) (limited to 'src/ui/widget') diff --git a/src/ui/widget/color-slider.cpp b/src/ui/widget/color-slider.cpp index ff69e6ed5..d501e3724 100644 --- a/src/ui/widget/color-slider.cpp +++ b/src/ui/widget/color-slider.cpp @@ -538,671 +538,6 @@ bool ColorSlider::on_draw(const Cairo::RefPtr& cr) { }//namespace UI }//namespace Inkscape - - - - - - - - - - - - - - - - - - - - - - - -enum { - GRABBED, - DRAGGED, - RELEASED, - CHANGED, - LAST_SIGNAL -}; - -static void sp_color_slider_class_init (SPColorSliderClass *klass); -static void sp_color_slider_init (SPColorSlider *slider); -static void sp_color_slider_dispose(GObject *object); - -static void sp_color_slider_realize (GtkWidget *widget); -static void sp_color_slider_size_request (GtkWidget *widget, GtkRequisition *requisition); - -#if GTK_CHECK_VERSION(3,0,0) -static void sp_color_slider_get_preferred_width(GtkWidget *widget, - gint *minimal_width, - gint *natural_width); - -static void sp_color_slider_get_preferred_height(GtkWidget *widget, - gint *minimal_height, - gint *natural_height); -#else -static gboolean sp_color_slider_expose(GtkWidget *widget, GdkEventExpose *event); -#endif - -static void sp_color_slider_size_allocate (GtkWidget *widget, GtkAllocation *allocation); - -static gboolean sp_color_slider_draw(GtkWidget *widget, cairo_t *cr); - -static gint sp_color_slider_button_press (GtkWidget *widget, GdkEventButton *event); -static gint sp_color_slider_button_release (GtkWidget *widget, GdkEventButton *event); -static gint sp_color_slider_motion_notify (GtkWidget *widget, GdkEventMotion *event); - -static void sp_color_slider_adjustment_changed (GtkAdjustment *adjustment, SPColorSlider *slider); -static void sp_color_slider_adjustment_value_changed (GtkAdjustment *adjustment, SPColorSlider *slider); - -static GtkWidgetClass *parent_class; -static guint slider_signals[LAST_SIGNAL] = {0}; - -GType -sp_color_slider_get_type (void) -{ - static GType type = 0; - if (!type) { - GTypeInfo info = { - sizeof (SPColorSliderClass), - NULL, NULL, - (GClassInitFunc) sp_color_slider_class_init, - NULL, NULL, - sizeof (SPColorSlider), - 0, - (GInstanceInitFunc) sp_color_slider_init, - NULL - }; - type = g_type_register_static (GTK_TYPE_WIDGET, "SPColorSlider", &info, (GTypeFlags)0); - } - return type; -} - -static void sp_color_slider_class_init(SPColorSliderClass *klass) -{ - GObjectClass *object_class = G_OBJECT_CLASS(klass); - GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass); - - parent_class = GTK_WIDGET_CLASS(g_type_class_peek_parent(klass)); - - slider_signals[GRABBED] = g_signal_new ("grabbed", - G_TYPE_FROM_CLASS(object_class), - (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE), - G_STRUCT_OFFSET (SPColorSliderClass, grabbed), - NULL, NULL, - g_cclosure_marshal_VOID__VOID, - G_TYPE_NONE, 0); - slider_signals[DRAGGED] = g_signal_new ("dragged", - G_TYPE_FROM_CLASS(object_class), - (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE), - G_STRUCT_OFFSET (SPColorSliderClass, dragged), - NULL, NULL, - g_cclosure_marshal_VOID__VOID, - G_TYPE_NONE, 0); - slider_signals[RELEASED] = g_signal_new ("released", - G_TYPE_FROM_CLASS(object_class), - (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE), - G_STRUCT_OFFSET (SPColorSliderClass, released), - NULL, NULL, - g_cclosure_marshal_VOID__VOID, - G_TYPE_NONE, 0); - slider_signals[CHANGED] = g_signal_new ("changed", - G_TYPE_FROM_CLASS(object_class), - (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE), - G_STRUCT_OFFSET (SPColorSliderClass, changed), - NULL, NULL, - g_cclosure_marshal_VOID__VOID, - G_TYPE_NONE, 0); - - object_class->dispose = sp_color_slider_dispose; - - widget_class->realize = sp_color_slider_realize; -#if GTK_CHECK_VERSION(3,0,0) - widget_class->get_preferred_width = sp_color_slider_get_preferred_width; - widget_class->get_preferred_height = sp_color_slider_get_preferred_height; - widget_class->draw = sp_color_slider_draw; -#else - widget_class->size_request = sp_color_slider_size_request; - widget_class->expose_event = sp_color_slider_expose; -#endif - widget_class->size_allocate = sp_color_slider_size_allocate; -/* widget_class->draw_focus = sp_color_slider_draw_focus; */ -/* widget_class->draw_default = sp_color_slider_draw_default; */ - - widget_class->button_press_event = sp_color_slider_button_press; - widget_class->button_release_event = sp_color_slider_button_release; - widget_class->motion_notify_event = sp_color_slider_motion_notify; -} - -static void -sp_color_slider_init (SPColorSlider *slider) -{ - /* We are widget with window */ - gtk_widget_set_has_window (GTK_WIDGET(slider), TRUE); - - slider->dragging = FALSE; - - slider->adjustment = NULL; - slider->value = 0.0; - - slider->c0[0] = 0x00; - slider->c0[1] = 0x00; - slider->c0[2] = 0x00; - slider->c0[3] = 0xff; - - slider->cm[0] = 0xff; - slider->cm[1] = 0x00; - slider->cm[2] = 0x00; - slider->cm[3] = 0xff; - - slider->c1[0] = 0xff; - slider->c1[1] = 0xff; - slider->c1[2] = 0xff; - slider->c1[3] = 0xff; - - slider->b0 = 0x5f; - slider->b1 = 0xa0; - slider->bmask = 0x08; - - slider->map = NULL; -} - -static void sp_color_slider_dispose(GObject *object) -{ - SPColorSlider *slider = SP_COLOR_SLIDER (object); - - if (slider->adjustment) { - g_signal_handlers_disconnect_matched (G_OBJECT (slider->adjustment), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, slider); - g_object_unref (slider->adjustment); - slider->adjustment = NULL; - } - - if ((G_OBJECT_CLASS(parent_class))->dispose) - (* (G_OBJECT_CLASS(parent_class))->dispose) (object); -} - -static void -sp_color_slider_realize (GtkWidget *widget) -{ - GdkWindowAttr attributes; - gint attributes_mask; - GtkAllocation allocation; - - gtk_widget_get_allocation(widget, &allocation); - gtk_widget_set_realized (widget, TRUE); - - attributes.window_type = GDK_WINDOW_CHILD; - attributes.x = allocation.x; - attributes.y = allocation.y; - attributes.width = allocation.width; - attributes.height = allocation.height; - attributes.wclass = GDK_INPUT_OUTPUT; - attributes.visual = gdk_screen_get_system_visual(gdk_screen_get_default()); - -#if !GTK_CHECK_VERSION(3,0,0) - attributes.colormap = gdk_screen_get_system_colormap(gdk_screen_get_default()); -#endif - - attributes.event_mask = gtk_widget_get_events (widget); - attributes.event_mask |= (GDK_EXPOSURE_MASK | - GDK_BUTTON_PRESS_MASK | - GDK_BUTTON_RELEASE_MASK | - GDK_POINTER_MOTION_MASK | - GDK_ENTER_NOTIFY_MASK | - GDK_LEAVE_NOTIFY_MASK); -#if GTK_CHECK_VERSION(3,0,0) - attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL; -#else - attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP; -#endif - - gtk_widget_set_window(widget, - gdk_window_new(gtk_widget_get_parent_window(widget), - &attributes, attributes_mask)); - - gdk_window_set_user_data(gtk_widget_get_window(widget), widget); - -#if !GTK_CHECK_VERSION(3,0,0) - // This doesn't do anything in GTK+ 3 - gtk_widget_set_style(widget, - gtk_style_attach(gtk_widget_get_style(widget), - gtk_widget_get_window(widget))); -#endif -} - -static void -sp_color_slider_size_request (GtkWidget *widget, GtkRequisition *requisition) -{ - GtkStyle *style = gtk_widget_get_style(widget); - requisition->width = SLIDER_WIDTH + style->xthickness * 2; - requisition->height = SLIDER_HEIGHT + style->ythickness * 2; -} - -#if GTK_CHECK_VERSION(3,0,0) -static void sp_color_slider_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width) -{ - GtkRequisition requisition; - sp_color_slider_size_request(widget, &requisition); - *minimal_width = *natural_width = requisition.width; -} - -static void sp_color_slider_get_preferred_height(GtkWidget *widget, gint *minimal_height, gint *natural_height) -{ - GtkRequisition requisition; - sp_color_slider_size_request(widget, &requisition); - *minimal_height = *natural_height = requisition.height; -} -#endif - -static void -sp_color_slider_size_allocate (GtkWidget *widget, GtkAllocation *allocation) -{ - gtk_widget_set_allocation(widget, allocation); - - if (gtk_widget_get_realized (widget)) { - /* Resize GdkWindow */ - gdk_window_move_resize(gtk_widget_get_window(widget), - allocation->x, allocation->y, - allocation->width, allocation->height); - } -} - -#if !GTK_CHECK_VERSION(3,0,0) -static gboolean sp_color_slider_expose(GtkWidget *widget, GdkEventExpose * /*event*/) -{ - gboolean result = FALSE; - - if (gtk_widget_is_drawable(widget)) { - GdkWindow *window = gtk_widget_get_window(widget); - cairo_t *cr = gdk_cairo_create(window); - result = sp_color_slider_draw(widget, cr); - cairo_destroy(cr); - } - - return result; -} -#endif - -static gint -sp_color_slider_button_press (GtkWidget *widget, GdkEventButton *event) -{ - SPColorSlider *slider; - - slider = SP_COLOR_SLIDER (widget); - - if (event->button == 1) { - GtkAllocation allocation; - gtk_widget_get_allocation(widget, &allocation); - gint cx, cw; - cx = gtk_widget_get_style(widget)->xthickness; - cw = allocation.width - 2 * cx; - g_signal_emit (G_OBJECT (slider), slider_signals[GRABBED], 0); - slider->dragging = TRUE; - slider->oldvalue = slider->value; - ColorScales::setScaled( slider->adjustment, CLAMP ((gfloat) (event->x - cx) / cw, 0.0, 1.0) ); - g_signal_emit (G_OBJECT (slider), slider_signals[DRAGGED], 0); - -#if GTK_CHECK_VERSION(3,0,0) - gdk_device_grab(gdk_event_get_device(reinterpret_cast(event)), - gtk_widget_get_window(widget), - GDK_OWNERSHIP_NONE, - FALSE, - static_cast(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK), - NULL, - event->time); -#else - gdk_pointer_grab(gtk_widget_get_window(widget), FALSE, - static_cast(GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK), - NULL, NULL, event->time); -#endif - } - - return FALSE; -} - -static gint -sp_color_slider_button_release (GtkWidget *widget, GdkEventButton *event) -{ - SPColorSlider *slider; - - slider = SP_COLOR_SLIDER (widget); - - if (event->button == 1) { - -#if GTK_CHECK_VERSION(3,0,0) - gdk_device_ungrab(gdk_event_get_device(reinterpret_cast(event)), - gdk_event_get_time(reinterpret_cast(event))); -#else - gdk_pointer_ungrab (event->time); -#endif - - slider->dragging = FALSE; - g_signal_emit (G_OBJECT (slider), slider_signals[RELEASED], 0); - if (slider->value != slider->oldvalue) g_signal_emit (G_OBJECT (slider), slider_signals[CHANGED], 0); - } - - return FALSE; -} - -static gint -sp_color_slider_motion_notify (GtkWidget *widget, GdkEventMotion *event) -{ - SPColorSlider *slider; - - slider = SP_COLOR_SLIDER (widget); - - if (slider->dragging) { - gint cx, cw; - GtkAllocation allocation; - gtk_widget_get_allocation(widget, &allocation); - cx = gtk_widget_get_style(widget)->xthickness; - cw = allocation.width - 2 * cx; - ColorScales::setScaled( slider->adjustment, CLAMP ((gfloat) (event->x - cx) / cw, 0.0, 1.0) ); - g_signal_emit (G_OBJECT (slider), slider_signals[DRAGGED], 0); - } - - return FALSE; -} - -GtkWidget *sp_color_slider_new(GtkAdjustment *adjustment) -{ - SPColorSlider *slider = SP_COLOR_SLIDER(g_object_new(SP_TYPE_COLOR_SLIDER, NULL)); - - sp_color_slider_set_adjustment (slider, adjustment); - - return GTK_WIDGET (slider); -} - -void sp_color_slider_set_adjustment(SPColorSlider *slider, GtkAdjustment *adjustment) -{ - g_return_if_fail (slider != NULL); - g_return_if_fail (SP_IS_COLOR_SLIDER (slider)); - - if (!adjustment) { - adjustment = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 1.0, 0.01, 0.0, 0.0)); - } else { - gtk_adjustment_set_page_increment(adjustment, 0.0); - gtk_adjustment_set_page_size(adjustment, 0.0); - } - - if (slider->adjustment != adjustment) { - if (slider->adjustment) { - g_signal_handlers_disconnect_matched (G_OBJECT (slider->adjustment), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, slider); - g_object_unref (slider->adjustment); - } - - slider->adjustment = adjustment; - g_object_ref (adjustment); - g_object_ref_sink (adjustment); - - g_signal_connect (G_OBJECT (adjustment), "changed", - G_CALLBACK (sp_color_slider_adjustment_changed), slider); - g_signal_connect (G_OBJECT (adjustment), "value_changed", - G_CALLBACK (sp_color_slider_adjustment_value_changed), slider); - - slider->value = ColorScales::getScaled( adjustment ); - - sp_color_slider_adjustment_changed (adjustment, slider); - } -} - -void -sp_color_slider_set_colors (SPColorSlider *slider, guint32 start, guint32 mid, guint32 end) -{ - g_return_if_fail (slider != NULL); - g_return_if_fail (SP_IS_COLOR_SLIDER (slider)); - - // Remove any map, if set - slider->map = 0; - - slider->c0[0] = start >> 24; - slider->c0[1] = (start >> 16) & 0xff; - slider->c0[2] = (start >> 8) & 0xff; - slider->c0[3] = start & 0xff; - - slider->cm[0] = mid >> 24; - slider->cm[1] = (mid >> 16) & 0xff; - slider->cm[2] = (mid >> 8) & 0xff; - slider->cm[3] = mid & 0xff; - - slider->c1[0] = end >> 24; - slider->c1[1] = (end >> 16) & 0xff; - slider->c1[2] = (end >> 8) & 0xff; - slider->c1[3] = end & 0xff; - - gtk_widget_queue_draw (GTK_WIDGET (slider)); -} - -void -sp_color_slider_set_map (SPColorSlider *slider, const guchar *map) -{ - g_return_if_fail (slider != NULL); - g_return_if_fail (SP_IS_COLOR_SLIDER (slider)); - - slider->map = const_cast(map); - - gtk_widget_queue_draw (GTK_WIDGET (slider)); -} - -void -sp_color_slider_set_background (SPColorSlider *slider, guint dark, guint light, guint size) -{ - g_return_if_fail (slider != NULL); - g_return_if_fail (SP_IS_COLOR_SLIDER (slider)); - - slider->b0 = dark; - slider->b1 = light; - slider->bmask = size; - - gtk_widget_queue_draw (GTK_WIDGET (slider)); -} - -static void -sp_color_slider_adjustment_changed (GtkAdjustment */*adjustment*/, SPColorSlider *slider) -{ - gtk_widget_queue_draw (GTK_WIDGET (slider)); -} - -static void -sp_color_slider_adjustment_value_changed (GtkAdjustment *adjustment, SPColorSlider *slider) -{ - GtkWidget *widget; - - widget = GTK_WIDGET (slider); - - if (slider->value != ColorScales::getScaled( adjustment )) { - gint cx, cy, cw, ch; - GtkStyle *style = gtk_widget_get_style(widget); - GtkAllocation allocation; - gtk_widget_get_allocation(widget, &allocation); - cx = style->xthickness; - cy = style->ythickness; - cw = allocation.width - 2 * cx; - ch = allocation.height - 2 * cy; - if ((gint) (ColorScales::getScaled( adjustment ) * cw) != (gint) (slider->value * cw)) { - gint ax, ay; - gfloat value; - value = slider->value; - slider->value = ColorScales::getScaled( adjustment ); - ax = (int)(cx + value * cw - ARROW_SIZE / 2 - 2); - ay = cy; - gtk_widget_queue_draw_area (widget, ax, ay, ARROW_SIZE + 4, ch); - ax = (int)(cx + slider->value * cw - ARROW_SIZE / 2 - 2); - ay = cy; - gtk_widget_queue_draw_area (widget, ax, ay, ARROW_SIZE + 4, ch); - } else { - slider->value = ColorScales::getScaled( adjustment ); - } - } -} - -static gboolean sp_color_slider_draw(GtkWidget *widget, cairo_t *cr) -{ - SPColorSlider *slider = SP_COLOR_SLIDER(widget); - - gboolean colorsOnTop = Inkscape::Preferences::get()->getBool("/options/workarounds/colorsontop", false); - - GtkAllocation allocation; - gtk_widget_get_allocation(widget, &allocation); - -#if GTK_CHECK_VERSION(3,0,0) - GtkStyleContext *context = gtk_widget_get_style_context(widget); -#else - GdkWindow *window = gtk_widget_get_window(widget); - GtkStyle *style = gtk_widget_get_style(widget); -#endif - - // Draw shadow - if (colorsOnTop) { -#if GTK_CHECK_VERSION(3,0,0) - gtk_render_frame(context, - cr, - 0, 0, - allocation.width, allocation.height); -#else - gtk_paint_shadow( style, window, - gtk_widget_get_state(widget), GTK_SHADOW_IN, - NULL, widget, "colorslider", - 0, 0, - allocation.width, allocation.height); -#endif - } - - /* Paintable part of color gradient area */ - GdkRectangle carea; - -#if GTK_CHECK_VERSION(3,0,0) - GtkBorder padding; - - gtk_style_context_get_padding(context, - gtk_widget_get_state_flags(widget), - &padding); - - carea.x = padding.left; - carea.y = padding.top; -#else - carea.x = style->xthickness; - carea.y = style->ythickness; -#endif - - carea.width = allocation.width - 2 * carea.x; - carea.height = allocation.height - 2 * carea.y; - - if (slider->map) { - /* Render map pixelstore */ - gint d = (1024 << 16) / carea.width; - gint s = 0; - - const guchar *b = sp_color_slider_render_map(0, 0, carea.width, carea.height, - slider->map, s, d, - slider->b0, slider->b1, slider->bmask); - - if (b != NULL && carea.width > 0) { - GdkPixbuf *pb = gdk_pixbuf_new_from_data (b, GDK_COLORSPACE_RGB, - 0, 8, carea.width, carea.height, carea.width * 3, NULL, NULL); - - gdk_cairo_set_source_pixbuf(cr, pb, carea.x, carea.y); - cairo_paint(cr); - g_object_unref(pb); - } - - } else { - gint c[4], dc[4]; - - /* Render gradient */ - - // part 1: from c0 to cm - if (carea.width > 0) { - for (gint i = 0; i < 4; i++) { - c[i] = slider->c0[i] << 16; - dc[i] = ((slider->cm[i] << 16) - c[i]) / (carea.width/2); - } - guint wi = carea.width/2; - const guchar *b = sp_color_slider_render_gradient(0, 0, wi, carea.height, - c, dc, slider->b0, slider->b1, slider->bmask); - - /* Draw pixelstore 1 */ - if (b != NULL && wi > 0) { - GdkPixbuf *pb = gdk_pixbuf_new_from_data (b, GDK_COLORSPACE_RGB, - 0, 8, wi, carea.height, wi * 3, NULL, NULL); - - gdk_cairo_set_source_pixbuf(cr, pb, carea.x, carea.y); - cairo_paint(cr); - g_object_unref(pb); - } - } - - // part 2: from cm to c1 - if (carea.width > 0) { - for (gint i = 0; i < 4; i++) { - c[i] = slider->cm[i] << 16; - dc[i] = ((slider->c1[i] << 16) - c[i]) / (carea.width/2); - } - guint wi = carea.width/2; - const guchar *b = sp_color_slider_render_gradient(carea.width/2, 0, wi, carea.height, - c, dc, - slider->b0, slider->b1, slider->bmask); - - /* Draw pixelstore 2 */ - if (b != NULL && wi > 0) { - GdkPixbuf *pb = gdk_pixbuf_new_from_data (b, GDK_COLORSPACE_RGB, - 0, 8, wi, carea.height, wi * 3, NULL, NULL); - - gdk_cairo_set_source_pixbuf(cr, pb, carea.width/2 + carea.x, carea.y); - cairo_paint(cr); - - g_object_unref(pb); - } - } - } - - /* Draw shadow */ - if (!colorsOnTop) { -#if GTK_CHECK_VERSION(3,0,0) - gtk_render_frame(context, - cr, - 0, 0, - allocation.width, allocation.height); -#else - gtk_paint_shadow( style, window, - gtk_widget_get_state(widget), GTK_SHADOW_IN, - NULL, widget, "colorslider", - 0, 0, - allocation.width, allocation.height); -#endif - } - - /* Draw arrow */ - gint x = (int)(slider->value * (carea.width - 1) - ARROW_SIZE / 2 + carea.x); - gint y1 = carea.y; - gint y2 = carea.y + carea.height - 1; - cairo_set_line_width(cr, 1.0); - - // Define top arrow - cairo_move_to(cr, x - 0.5, y1 + 0.5); - cairo_line_to(cr, x + ARROW_SIZE - 0.5, y1 + 0.5); - cairo_line_to(cr, x + (ARROW_SIZE-1)/2.0, y1 + ARROW_SIZE/2.0 + 0.5); - cairo_line_to(cr, x - 0.5, y1 + 0.5); - - // Define bottom arrow - cairo_move_to(cr, x - 0.5, y2 + 0.5); - cairo_line_to(cr, x + ARROW_SIZE - 0.5, y2 + 0.5); - cairo_line_to(cr, x + (ARROW_SIZE-1)/2.0, y2 - ARROW_SIZE/2.0 + 0.5); - cairo_line_to(cr, x - 0.5, y2 + 0.5); - - // Render both arrows - cairo_set_source_rgb(cr, 1.0, 1.0, 1.0); - cairo_stroke_preserve(cr); - cairo_set_source_rgb(cr, 0.0, 0.0, 0.0); - cairo_fill(cr); - - return FALSE; -} - /* Colors are << 16 */ static const guchar * diff --git a/src/ui/widget/color-slider.h b/src/ui/widget/color-slider.h index eb4cd99c3..bbc14afc9 100644 --- a/src/ui/widget/color-slider.h +++ b/src/ui/widget/color-slider.h @@ -105,57 +105,4 @@ private: }//namespace UI }//namespace Inkscape - -#include - -#include - - - -struct SPColorSlider; -struct SPColorSliderClass; - -#define SP_TYPE_COLOR_SLIDER (sp_color_slider_get_type ()) -#define SP_COLOR_SLIDER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SP_TYPE_COLOR_SLIDER, SPColorSlider)) -#define SP_COLOR_SLIDER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), SP_TYPE_COLOR_SLIDER, SPColorSliderClass)) -#define SP_IS_COLOR_SLIDER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), SP_TYPE_COLOR_SLIDER)) -#define SP_IS_COLOR_SLIDER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SP_TYPE_COLOR_SLIDER)) - -struct SPColorSlider { - GtkWidget widget; - - guint dragging : 1; - - GtkAdjustment *adjustment; - - gfloat value; - gfloat oldvalue; - guchar c0[4], cm[4], c1[4]; - guchar b0, b1; - guchar bmask; - - gint mapsize; - guchar *map; -}; - -struct SPColorSliderClass { - GtkWidgetClass parent_class; - - void (* grabbed) (SPColorSlider *slider); - void (* dragged) (SPColorSlider *slider); - void (* released) (SPColorSlider *slider); - void (* changed) (SPColorSlider *slider); -}; - -GType sp_color_slider_get_type (void); - -GtkWidget *sp_color_slider_new (GtkAdjustment *adjustment); - -void sp_color_slider_set_adjustment (SPColorSlider *slider, GtkAdjustment *adjustment); -void sp_color_slider_set_colors (SPColorSlider *slider, guint32 start, guint32 mid, guint32 end); -void sp_color_slider_set_map (SPColorSlider *slider, const guchar *map); -void sp_color_slider_set_background (SPColorSlider *slider, guint dark, guint light, guint size); - - - #endif -- cgit v1.2.3 From 0744a31c573dc80d6e8166319e07375e97884f15 Mon Sep 17 00:00:00 2001 From: Tomasz Boczkowski Date: Sun, 25 May 2014 00:02:36 +0200 Subject: SPColorSlider c++-sification: remove unnecessary reference to Gtk::Adjustment (bzr r13341.6.15) --- src/ui/widget/color-slider.cpp | 3 --- 1 file changed, 3 deletions(-) (limited to 'src/ui/widget') 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