/* * Copyright © 2025 Red Hat, Inc * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library. If not, see . * * SPDX-License-Identifier: LGPL-2.1-or-later * * Authors: Matthias Clasen */ #include "paintable-editor.h" #include "shape-editor.h" #include "path-paintable.h" static void size_changed (PaintableEditor *self); static void paintable_editor_set_initial_state (PaintableEditor *self, unsigned int state); struct _PaintableEditor { GtkWidget parent_instance; PathPaintable *paintable; unsigned int state; GtkScrolledWindow *swin; GtkEntry *author; GtkEntry *license; GtkEntry *description; GtkEntry *keywords; GtkEntry *width; GtkEntry *height; GtkLabel *compat; GtkLabel *summary1; GtkLabel *summary2; GtkSpinButton *initial_state; GtkImage *icon_image; GtkBox *path_elts; }; struct _PaintableEditorClass { GtkWidgetClass parent_class; }; enum { PROP_PAINTABLE = 1, PROP_INITIAL_STATE, NUM_PROPERTIES, }; static GParamSpec *properties[NUM_PROPERTIES]; G_DEFINE_TYPE (PaintableEditor, paintable_editor, GTK_TYPE_WIDGET) /* {{{ Utilities, callbacks */ static void clear_shape_editors (PaintableEditor *self) { GtkWidget *child; while ((child = gtk_widget_get_first_child (GTK_WIDGET (self->path_elts))) != NULL) gtk_box_remove (self->path_elts, child); } static void append_shape_editor (PaintableEditor *self, Shape *shape) { ShapeEditor *pe; pe = shape_editor_new (self->paintable, shape); gtk_box_append (self->path_elts, GTK_WIDGET (pe)); gtk_box_append (self->path_elts, gtk_separator_new (GTK_ORIENTATION_HORIZONTAL)); } static void create_shape_editors (PaintableEditor *self) { Shape *content; gtk_box_append (self->path_elts, gtk_separator_new (GTK_ORIENTATION_HORIZONTAL)); content = path_paintable_get_content (self->paintable); for (unsigned int i = 0; i < content->shapes->len; i++) { Shape *shape = g_ptr_array_index (content->shapes, i); if (!shape_is_graphical (shape) && shape->type != SHAPE_GROUP) continue; append_shape_editor (self, shape); } } static void update_size (PaintableEditor *self) { g_autofree char *text = NULL; text = g_strdup_printf ("%g", path_paintable_get_width (self->paintable)); gtk_editable_set_text (GTK_EDITABLE (self->width), text); g_set_str (&text, g_strdup_printf ("%g", path_paintable_get_height (self->paintable))); gtk_editable_set_text (GTK_EDITABLE (self->height), text); } static void update_summary (PaintableEditor *self) { if (self->paintable) { unsigned int state = path_paintable_get_state (self->paintable); g_autofree char *summary1 = NULL; g_autofree char *summary2 = NULL; unsigned int n; n = 0; for (size_t i = 0; i < path_paintable_get_n_paths (self->paintable); i++) { uint64_t states = path_paintable_get_path_states (self->paintable, i); if (states & (1ul << state)) n++; } if (state == STATE_UNSET) { summary1 = g_strdup ("Current state: -1"); summary2 = g_strdup_printf ("%" G_GSIZE_FORMAT " path elements", path_paintable_get_n_paths (self->paintable)); } else { summary1 = g_strdup_printf ("Current state: %u", state); summary2 = g_strdup_printf ("%" G_GSIZE_FORMAT " path elements, %u in current state", path_paintable_get_n_paths (self->paintable), n); } gtk_label_set_label (self->summary1, summary1); gtk_label_set_label (self->summary2, summary2); } else { gtk_label_set_label (self->summary1, ""); gtk_label_set_label (self->summary2, ""); } } static void update_compat (PaintableEditor *self) { switch (path_paintable_get_compatibility (self->paintable)) { case GTK_4_0: gtk_label_set_label (self->compat, "GTK 4.0"); break; case GTK_4_20: gtk_label_set_label (self->compat, "GTK 4.20"); break; case GTK_4_22: gtk_label_set_label (self->compat, "GTK 4.22"); break; default: g_assert_not_reached (); } } static void update_icon_paintable (PaintableEditor *self) { GdkPaintable *paintable = GDK_PAINTABLE (path_paintable_get_icon_paintable (self->paintable)); gtk_image_set_from_paintable (self->icon_image, paintable); g_object_unref (paintable); } static void paths_changed (PaintableEditor *self) { clear_shape_editors (self); create_shape_editors (self); update_size (self); update_summary (self); update_icon_paintable (self); } static void changed (PaintableEditor *self) { update_compat (self); update_size (self); update_summary (self); update_icon_paintable (self); } static void size_changed (PaintableEditor *self) { const char *text; double width, height; int res; text = gtk_editable_get_text (GTK_EDITABLE (self->width)); res = sscanf (text, "%lf", &width); text = gtk_editable_get_text (GTK_EDITABLE (self->height)); res += sscanf (text, "%lf", &height); if (res == 2 && width > 0 && height > 0) path_paintable_set_size (self->paintable, width, height); } static void author_changed (PaintableEditor *self) { const char *text = gtk_editable_get_text (GTK_EDITABLE (self->author)); path_paintable_set_author (self->paintable, text); } static void license_changed (PaintableEditor *self) { const char *text = gtk_editable_get_text (GTK_EDITABLE (self->license)); path_paintable_set_license (self->paintable, text); } static void description_changed (PaintableEditor *self) { const char *text = gtk_editable_get_text (GTK_EDITABLE (self->description)); path_paintable_set_description (self->paintable, text); } static void keywords_changed (PaintableEditor *self) { const char *text = gtk_editable_get_text (GTK_EDITABLE (self->keywords)); path_paintable_set_keywords (self->paintable, text); } /* }}} */ /* {{{ GObject boilerplate */ static void paintable_editor_init (PaintableEditor *self) { gtk_widget_init_template (GTK_WIDGET (self)); } static void paintable_editor_set_property (GObject *object, unsigned int prop_id, const GValue *value, GParamSpec *pspec) { PaintableEditor *self = PAINTABLE_EDITOR (object); switch (prop_id) { case PROP_PAINTABLE: paintable_editor_set_paintable (self, g_value_get_object (value)); break; case PROP_INITIAL_STATE: paintable_editor_set_initial_state (self, g_value_get_uint (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void paintable_editor_get_property (GObject *object, unsigned int prop_id, GValue *value, GParamSpec *pspec) { PaintableEditor *self = PAINTABLE_EDITOR (object); switch (prop_id) { case PROP_PAINTABLE: g_value_set_object (value, self->paintable); break; case PROP_INITIAL_STATE: g_value_set_uint (value, self->state); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void paintable_editor_dispose (GObject *object) { PaintableEditor *self = PAINTABLE_EDITOR (object); if (self->paintable) g_signal_handlers_disconnect_by_func (self->paintable, paths_changed, self); g_clear_object (&self->paintable); clear_shape_editors (self); gtk_widget_dispose_template (GTK_WIDGET (object), PAINTABLE_EDITOR_TYPE); G_OBJECT_CLASS (paintable_editor_parent_class)->dispose (object); } static void paintable_editor_finalize (GObject *object) { G_OBJECT_CLASS (paintable_editor_parent_class)->finalize (object); } static void paintable_editor_class_init (PaintableEditorClass *class) { GObjectClass *object_class = G_OBJECT_CLASS (class); GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class); g_type_ensure (SHAPE_EDITOR_TYPE); object_class->dispose = paintable_editor_dispose; object_class->finalize = paintable_editor_finalize; object_class->set_property = paintable_editor_set_property; object_class->get_property = paintable_editor_get_property; properties[PROP_PAINTABLE] = g_param_spec_object ("paintable", NULL, NULL, PATH_PAINTABLE_TYPE, G_PARAM_READWRITE | G_PARAM_STATIC_NAME); properties[PROP_INITIAL_STATE] = g_param_spec_uint ("initial-state", NULL, NULL, 0, G_MAXUINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_NAME); g_object_class_install_properties (object_class, NUM_PROPERTIES, properties); gtk_widget_class_set_template_from_resource (widget_class, "/org/gtk/Shaper/paintable-editor.ui"); gtk_widget_class_bind_template_child (widget_class, PaintableEditor, swin); gtk_widget_class_bind_template_child (widget_class, PaintableEditor, author); gtk_widget_class_bind_template_child (widget_class, PaintableEditor, license); gtk_widget_class_bind_template_child (widget_class, PaintableEditor, description); gtk_widget_class_bind_template_child (widget_class, PaintableEditor, keywords); gtk_widget_class_bind_template_child (widget_class, PaintableEditor, width); gtk_widget_class_bind_template_child (widget_class, PaintableEditor, height); gtk_widget_class_bind_template_child (widget_class, PaintableEditor, compat); gtk_widget_class_bind_template_child (widget_class, PaintableEditor, summary1); gtk_widget_class_bind_template_child (widget_class, PaintableEditor, summary2); gtk_widget_class_bind_template_child (widget_class, PaintableEditor, initial_state); gtk_widget_class_bind_template_child (widget_class, PaintableEditor, icon_image); gtk_widget_class_bind_template_child (widget_class, PaintableEditor, path_elts); gtk_widget_class_bind_template_callback (widget_class, size_changed); gtk_widget_class_bind_template_callback (widget_class, author_changed); gtk_widget_class_bind_template_callback (widget_class, license_changed); gtk_widget_class_bind_template_callback (widget_class, description_changed); gtk_widget_class_bind_template_callback (widget_class, keywords_changed); gtk_widget_class_set_layout_manager_type (widget_class, GTK_TYPE_BIN_LAYOUT); gtk_widget_class_set_css_name (widget_class, "PaintableEditor"); } /* }}} */ /* {{{ Public API */ PaintableEditor * paintable_editor_new (void) { return g_object_new (PAINTABLE_EDITOR_TYPE, NULL); } PathPaintable * paintable_editor_get_paintable (PaintableEditor *self) { g_return_val_if_fail (PAINTABLE_IS_EDITOR (self), NULL); return self->paintable; } void paintable_editor_set_paintable (PaintableEditor *self, PathPaintable *paintable) { g_return_if_fail (PAINTABLE_IS_EDITOR (self)); if (self->paintable == paintable) return; if (self->paintable) { g_signal_handlers_disconnect_by_func (self->paintable, paths_changed, self); g_signal_handlers_disconnect_by_func (self->paintable, changed, self); g_signal_handlers_disconnect_by_func (self->paintable, update_summary, self); } clear_shape_editors (self); g_set_object (&self->paintable, paintable); if (paintable) { g_autofree char *width = NULL; g_autofree char *height = NULL; const char *text; text = path_paintable_get_author (paintable); gtk_editable_set_text (GTK_EDITABLE (self->author), text ? text : ""); text = path_paintable_get_license (paintable); gtk_editable_set_text (GTK_EDITABLE (self->license), text ? text : ""); text = path_paintable_get_description (paintable); gtk_editable_set_text (GTK_EDITABLE (self->description), text ? text : ""); text = path_paintable_get_keywords (paintable); gtk_editable_set_text (GTK_EDITABLE (self->keywords), text ? text : ""); width = g_strdup_printf ("%g", path_paintable_get_width (paintable)); gtk_editable_set_text (GTK_EDITABLE (self->width), width); height = g_strdup_printf ("%g", path_paintable_get_height (paintable)); gtk_editable_set_text (GTK_EDITABLE (self->height), height); g_signal_connect_swapped (paintable, "paths-changed", G_CALLBACK (paths_changed), self); g_signal_connect_swapped (paintable, "changed", G_CALLBACK (changed), self); g_signal_connect_swapped (paintable, "notify::state", G_CALLBACK (update_summary), self); create_shape_editors (self); update_summary (self); update_compat (self); update_icon_paintable (self); } g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_PAINTABLE]); } static void paintable_editor_set_initial_state (PaintableEditor *self, unsigned int state) { g_return_if_fail (PAINTABLE_IS_EDITOR (self)); if (self->state == state) return; self->state = state; g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_INITIAL_STATE]); } void paintable_editor_add_path (PaintableEditor *self) { g_autoptr (GskPath) path = NULL; char buffer[128]; Shape *content; size_t idx; if (path_paintable_get_n_paths (self->paintable) == 0) path_paintable_set_size (self->paintable, 100.f, 100.f); g_snprintf (buffer, sizeof (buffer), "M 0 0 L "); g_ascii_formatd (buffer + strlen (buffer), sizeof (buffer) - strlen (buffer), "%g ", path_paintable_get_width (self->paintable)); g_ascii_formatd (buffer + strlen (buffer), sizeof (buffer) - strlen (buffer), "%g ", path_paintable_get_height (self->paintable)); path = gsk_path_parse (buffer); g_signal_handlers_block_by_func (self->paintable, paths_changed, self); idx = path_paintable_add_path (self->paintable, path); for (unsigned int i = 1; i < 100; i++) { char id[64]; g_snprintf (id, sizeof (id), "path%u", i); if (path_paintable_get_shape_by_id (self->paintable, id) == NULL) { Shape *shape; shape = path_paintable_get_shape (self->paintable, idx); g_set_str (&shape->id, id); break; } } content = path_paintable_get_content (self->paintable); append_shape_editor (self, g_ptr_array_index (content->shapes, content->shapes->len - 1)); g_signal_handlers_unblock_by_func (self->paintable, paths_changed, self); } /* }}} */ /* vim:set foldmethod=marker: */