util.h

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Utility functions for UI
 *
 * Authors:
 *   Tavmjong Bah
 *   John Smith
 *
 * Copyright (C) 2013, 2018 Authors
 * Released under GNU GPL v2+, read the file 'COPYING' for more information.
 */
 
#ifndef UI_UTIL_SEEN
#define UI_UTIL_SEEN
 
#include <gtkmm/notebook.h>
#include <2geom/rect.h>
 
/*
 * Use these errors when building from glade files for graceful
 * fallbacks and prevent crashes from corrupt ui files.
 */
class UIBuilderError : public std::exception {};
class UIFileUnavailable : public UIBuilderError {};
class WidgetUnavailable : public UIBuilderError {};
 
namespace Cairo {
class Matrix;
class ImageSurface;
} // namespace Cairo
 
namespace Glib {
class ustring;
} // namespace Glib
 
namespace Gtk {
class Editable;
class Label;
class TextBuffer;
class Widget;
} // namespace Gtk
 
namespace Inkscape::Colors {
class Color;
} // namespace Inkscape::Colors
 
Glib::ustring ink_ellipsize_text(Glib::ustring const &src, std::size_t maxlen);
 
void reveal_widget(Gtk::Widget *widget, bool show);
 
// check if widget in a container is actually visible
bool is_widget_effectively_visible(Gtk::Widget const *widget);
 
namespace Inkscape::UI {
 
void set_icon_sizes(Gtk::Widget *parent, int pixel_size);
void set_icon_sizes(GtkWidget *parent, int pixel_size);
 
void gui_warning(const std::string &msg, Gtk::Window * parent_window = nullptr);
 
enum class ForEachResult {
    _continue, // go on to the next widget
    _break,    // stop here, return current widget
    _skip      // do not recurse into current widget, go to the next one
};
 
void system_open(const Glib::ustring &path);
std::vector<Gtk::Widget *> get_children(Gtk::Widget &widget);
Gtk::Widget &get_nth_child(Gtk::Widget &widget, std::size_t index);
template <typename Widget> void remove_all_children(Widget &widget)
{
    for (auto const child: get_children(widget)) {
        widget.remove(*child);
    }
}
 
template <typename Func>
Gtk::Widget *for_each_child(Gtk::Widget &widget, Func &&func,
                            bool const plus_self = false, bool const recurse = false,
                            int const level = 0)
{
    static_assert(std::is_invocable_r_v<ForEachResult, Func, Gtk::Widget &>);
 
    if (plus_self) {
        auto ret = func(widget);
        if (ret == ForEachResult::_break) return &widget;
 
        // skip this widget?
        if (ret == ForEachResult::_skip) return nullptr;
    }
 
    if (!recurse && level > 0) return nullptr;
 
    for (auto const child: get_children(widget)) {
        auto const descendant = for_each_child(*child, func, true, recurse, level + 1);
        if (descendant) return descendant;
    }
 
    return nullptr;
}
 
template <typename Func>
Gtk::Widget *for_each_descendant(Gtk::Widget &widget, Func &&func)
{
    return for_each_child(widget, std::forward<Func>(func), true, true);
}
 
template <typename Func>
Gtk::Widget *for_each_parent(Gtk::Widget &widget, Func &&func)
{
    static_assert(std::is_invocable_r_v<ForEachResult, Func, Gtk::Widget &>);
    for (auto parent = widget.get_parent(); parent; parent = parent->get_parent()) {
        if (func(*parent) == ForEachResult::_break) {
            return parent;
        }
    }
    return nullptr;
}
 
template <typename Func>
Gtk::Widget* for_each_page(Gtk::Notebook& notebook, Func&& func) {
    static_assert(std::is_invocable_r_v<ForEachResult, Func, Gtk::Widget&>);
 
    const int page_number = notebook.get_n_pages();
    for (int page_index = 0; page_index < page_number; ++page_index) {
        auto page = notebook.get_nth_page(page_index);
        if (!page) continue;
 
        if (func(*page) == ForEachResult::_break) return page;
    }
 
    return nullptr;
}
 
[[nodiscard]] Gtk::Widget *find_widget_by_name(Gtk::Widget &parent, Glib::ustring const &name, bool visible_only);
[[nodiscard]] Gtk::Widget *find_focusable_widget(Gtk::Widget &parent);
[[nodiscard]] bool is_descendant_of(Gtk::Widget const &descendant, Gtk::Widget const &ancestor);
[[nodiscard]] bool contains_focus(Gtk::Widget &widget);
 
[[nodiscard]] int get_font_size(Gtk::Widget &widget);
 
// If max_width_chars is > 0, then the created Label has :max-width-chars set to
// that limit, the :ellipsize mode is set to the passed-in @a mode, & a ::query-
// tooltip handler is connected to show the label as the tooltip when ellipsized
void ellipsize(Gtk::Label &label, int max_width_chars, Pango::EllipsizeMode mode);
 
} // namespace Inkscape::UI
 
// Mix two RGBA colors using simple linear interpolation:
//  0 -> only a, 1 -> only b, x in 0..1 -> (1 - x)*a + x*b
Gdk::RGBA mix_colors(const Gdk::RGBA& a, const Gdk::RGBA& b, float ratio);
 
// Create the same color, but with a different opacity (alpha)
Gdk::RGBA change_alpha(const Gdk::RGBA& color, double new_alpha);
 
double get_luminance(const Gdk::RGBA &color);
 
// Get CSS color for a Widget, based on its current state & a given CSS class.
// N.B.!! Big GTK devs donʼt think changing classes should work ‘within a frame’
// …but it does… & GTK3 GtkCalendar does that – so keep doing it, till we canʼt!
Gdk::RGBA get_color_with_class(Gtk::Widget &widget,
                               Glib::ustring const &css_class);
 
// Convert a Gdk color to a hex code for css injection.
Glib::ustring gdk_to_css_color(const Gdk::RGBA& color);
Gdk::RGBA css_color_to_gdk(const char *value);
 
guint32 to_guint32(Gdk::RGBA const &rgba);
Gdk::RGBA color_to_rgba(Inkscape::Colors::Color const &color);
Gdk::RGBA to_rgba(guint32 const u32);
 
// convert Gdk::RGBA into 32-bit rrggbbaa color, optionally replacing alpha, if specified
uint32_t conv_gdk_color_to_rgba(const Gdk::RGBA& color, double replace_alpha = -1);
 
Geom::IntRect cairo_to_geom(const Cairo::RectangleInt &rect);
Cairo::RectangleInt geom_to_cairo(const Geom::IntRect &rect);
Cairo::Matrix geom_to_cairo(const Geom::Affine &affine);
Geom::IntPoint dimensions(const Cairo::RefPtr<Cairo::ImageSurface> &surface);
Geom::IntPoint dimensions(const Gdk::Rectangle &allocation);
 
template <typename T>
inline Gdk::Graphene::Rect geom_to_gtk(Geom::GenericRect<T> const &rect) {
    return Gdk::Graphene::Rect(rect.left(), rect.top(), rect.width(), rect.height());
}
inline Gdk::Graphene::Point geom_to_gtk(Geom::IntPoint const &point) {
    return Gdk::Graphene::Point(point.x(), point.y());
}
inline Gdk::Graphene::Point geom_to_gtk(Geom::Point const &point) {
    return Gdk::Graphene::Point(point.x(), point.y());
}
 
// create a gradient with multiple steps to approximate profile described by given cubic spline
std::vector<GskColorStop> create_cubic_gradient(
    const Gdk::RGBA& from,
    const Gdk::RGBA& to,
    Geom::Point ctrl1,
    Geom::Point ctrl2,
    Geom::Point p0 = Geom::Point(0, 0),
    Geom::Point p1 = Geom::Point(1, 1),
    int steps = 8
);
 
// If on Windows, get the native window & set it to DWMA_USE_IMMERSIVE_DARK_MODE
void set_dark_titlebar(Glib::RefPtr<Gdk::Surface> const &surface, bool is_dark);
unsigned int get_color_value(const Glib::ustring color);
 
// Parse string that can contain floating point numbers and round them to given precision;
// Used on path data ("d" attribute).
Glib::ustring round_numbers(const Glib::ustring& text, int precision);
 
// As above, but operating in-place on a TextBuffer
void truncate_digits(const Glib::RefPtr<Gtk::TextBuffer>& buffer, int precision);
 
Glib::RefPtr<Gdk::Texture> to_texture(Cairo::RefPtr<Cairo::Surface> const &surface);
 
// Restrict widget's min size (min-width & min-height) to specified minimum to keep it square (when it's centered).
// Widget has to have a name given with set_name.
void restrict_minsize_to_square(Gtk::Widget& widget, int min_size_px);
 
char const *get_text(Gtk::Editable const &editable);
 
#endif // UI_UTIL_SEEN
 
/*
  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 :