ink-color-wheel.h

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * @file
 * HSLuv color wheel widget, based on the web implementation at
 * https://www.hsluv.org
*//*
 * Authors:
 *   Tavmjong Bah
 *   Massinissa Derriche <massinissa.derriche@gmail.com>
 *   Daniel Boles <dboles.src+inkscape@gmail.com>
 *
 * Copyright (C) 2018, 2021, 2023 Authors
 *
 * Released under GNU GPL v2+, read the file 'COPYING' for more information.
 */
 
#ifndef INK_COLORWHEEL_H
#define INK_COLORWHEEL_H
 
#include <array>
#include <memory>
#include <utility>
#include <vector>
#include <2geom/point.h>
#include <2geom/line.h>
#include <sigc++/signal.h>
#include <gtk/gtk.h> // GtkEventControllerKey
#include <gtkmm/aspectframe.h>
#include <gtkmm/gesture.h> // Gtk::EventSequenceState
 
#include "color-wheel.h"
#include "colors/color.h"
#include "ui/widget/widget-vfuncs-class-init.h" // for focus
 
namespace Gtk {
class Builder;
class DrawingArea;
class EventControllerMotion;
class GestureClick;
} // namespace Gtk
 
namespace Inkscape::Colors {
class Color;
} // namespace Inkscape::Colors
 
namespace Inkscape::UI::Widget {
 
class Bin;
 
struct ColorPoint final
{
    ColorPoint();
    ColorPoint(double x, double y, Colors::Color color);
    ColorPoint(double x, double y, guint color);
 
    std::pair<double const &, double const &> get_xy() const { return {x, y}; }
 
    // eurgh!
    double x;
    double y;
    Colors::Color color;
};
 
// AspectFrame because we are circular & enforcing 1:1 eases drawing without overallocating buffers
class ColorWheelBase : public Gtk::AspectFrame, public ColorWheel
{
public:
    ColorWheelBase(Colors::Space::Type type, std::vector<double> initial_color);
    ColorWheelBase(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& builder, Colors::Space::Type type, std::vector<double> initial_color);
 
    virtual bool setColor(Colors::Color const &color,
                        bool overrideHue = true, bool emit = true) = 0;
    virtual Colors::Color getColor() const { return _values; }
 
    bool isAdjusting() const { return _adjusting; }
 
    sigc::connection connect_color_changed(sigc::slot<void ()>);
 
    // debug facility - performance testing only
    void redraw(const Cairo::RefPtr<Cairo::Context>& ctx) override { on_drawing_area_draw(ctx, 1024, 1024); }
protected:
    Colors::Color _values;
    bool _adjusting = false;
 
    void color_changed();
    void queue_drawing_area_draw();
 
    [[nodiscard]] Gtk::Allocation get_drawing_area_allocation() const;
    [[nodiscard]] bool drawing_area_has_focus() const;
    void focus_drawing_area();
 
private:
    void set_color(const Colors::Color& color) override { setColor(color, false, false); }
    // Colors::Color get_color() const override { return getColor(); }
    sigc::connection connect_color_changed(sigc::slot<void(const Colors::Color&)> callback) override {
        return _signal_color_changed.connect([this, callback](){ callback(getColor()); });
    }
    Gtk::Widget& get_widget() override { return *this; }
 
    void construct();
    sigc::signal<void ()> _signal_color_changed;
 
    UI::Widget::Bin *_bin;
    Gtk::DrawingArea *_drawing_area;
    virtual void on_drawing_area_size(int width, int height, int baseline) {}
    virtual void on_drawing_area_draw(Cairo::RefPtr<Cairo::Context> const &cr, int, int) = 0;
 
    virtual Gtk::EventSequenceState on_click_pressed (Gtk::GestureClick const& controller, 
                                                      int n_press, double x, double y) = 0;
    virtual Gtk::EventSequenceState on_click_released(int n_press, double x, double y) = 0;
 
    virtual void on_motion(Gtk::EventControllerMotion const &motion, double x, double y) = 0;
    void _on_motion(Gtk::EventControllerMotion const &motion, double x, double y);
 
    virtual bool on_key_pressed(unsigned keyval, unsigned keycode, Gdk::ModifierType state)
    {
        return false;
    }
 
    void on_key_released(unsigned keyval, unsigned keycode, Gdk::ModifierType state);
};
 
class ColorWheelHSL
    : public WidgetVfuncsClassInit // As Gtkmm4 doesn't wrap focus_vfunc
    , public ColorWheelBase
{
public:
    ColorWheelHSL();
    ColorWheelHSL(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& builder);
    bool setColor(Colors::Color const &color,
                bool overrideHue = true, bool emit = true) override;
 
private:
    void on_drawing_area_size(int width, int height, int baseline) override;
    void on_drawing_area_draw(Cairo::RefPtr<Cairo::Context> const &cr, int, int) override;
    std::optional<bool> focus(Gtk::DirectionType direction) override;
 
    bool _set_from_xy(double x, double y);
    bool set_from_xy_delta(double dx, double dy);
    bool _is_in_ring(double x, double y);
    bool _is_in_triangle(double x, double y);
    void _update_ring_color(double x, double y);
 
    enum class DragMode {
        NONE,
        HUE,
        SATURATION_VALUE
    };
 
    static constexpr double _ring_width = 0.2;
    DragMode _mode = DragMode::NONE;
    bool _focus_on_ring = true;
 
    Gtk::EventSequenceState on_click_pressed (Gtk::GestureClick const& controller,
                                              int n_press, double x, double y) final;
    Gtk::EventSequenceState on_click_released(int n_press, double x, double y) final;
    void on_motion(Gtk::EventControllerMotion const &motion, double x, double y) final;
    bool on_key_pressed(unsigned keyval, unsigned keycode, Gdk::ModifierType state) final;
 
    // caches to speed up drawing
    using TriangleCorners = std::array<ColorPoint, 3>;
    using MinMax          = std::array<double    , 2>;
    std::optional<Geom::IntPoint> _cache_size;
    std::optional<MinMax             > _radii;
    std::optional<TriangleCorners    > _triangle_corners;
    std::optional<Geom::Point        > _marker_point;
    std::vector  <guint32            > _buffer_ring, _buffer_triangle;
    Cairo::RefPtr<Cairo::ImageSurface> _source_ring, _source_triangle;
    [[nodiscard]] MinMax          const &get_radii           ();
    [[nodiscard]] TriangleCorners const &get_triangle_corners();
    [[nodiscard]] Geom::Point     const &get_marker_point    ();
                  void                   update_ring_source    ();
    [[nodiscard]] TriangleCorners        update_triangle_source();
};
 
struct PickerGeometry {
    std::vector<Geom::Point> vertices; 
    double outer_circle_radius; 
    double inner_circle_radius; 
};
 
 
class ColorWheelHSLuv : public ColorWheelBase
{
public:
    ColorWheelHSLuv();
    ColorWheelHSLuv(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& builder);
 
    bool setColor(Colors::Color const &color,
                bool overrideHue = true, bool emit = true) override;
 
    void updateGeometry();
 
private:
    void on_drawing_area_draw(Cairo::RefPtr<Cairo::Context> const &cr, int, int) final;
 
    bool _set_from_xy(double const x, double const y);
    void _setFromPoint(Geom::Point const &pt) { _set_from_xy(pt[Geom::X], pt[Geom::Y]); }
    void _updatePolygon();
    bool _vertex() const;
 
    Gtk::EventSequenceState on_click_pressed (Gtk::GestureClick const& controller,
                                              int n_press, double x, double y) final;
    Gtk::EventSequenceState on_click_released(int n_press, double x, double y) final;
    void on_motion(Gtk::EventControllerMotion const &motion, double x, double y) final;
    bool on_key_pressed(unsigned keyval, unsigned keycode, Gdk::ModifierType state) final;
 
    double _scale = 1.0;
    std::unique_ptr<PickerGeometry> _picker_geometry;
    std::vector<guint32> _buffer_polygon;
    Cairo::RefPtr<::Cairo::ImageSurface> _surface_polygon;
    Geom::IntPoint _cache_size;
    int _square_size = 1;
};
 
} // namespace Inkscape::UI::Widget
 
#endif // INK_COLORWHEEL_HSLUV_H
 
/*
  Local Variables:
  mode:c++
  c-file-style:"stroustrup"
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  indent-tabs-mode:nil
  fill-column:99
  End:
*/
// vim:filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8: textwidth=99: