/*
* 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 "state-editor.h"
#include "shape-editor.h"
#include "path-paintable.h"
struct _StateEditor
{
GtkWindow parent_instance;
GtkGrid *grid;
PathPaintable *paintable;
unsigned int max_state;
gboolean updating;
};
struct _StateEditorClass
{
GtkWidgetClass parent_class;
};
enum
{
PROP_PAINTABLE = 1,
NUM_PROPERTIES,
};
static GParamSpec *properties[NUM_PROPERTIES];
G_DEFINE_TYPE (StateEditor, state_editor, GTK_TYPE_WINDOW)
/* {{{ Utilities, callbacks */
static void repopulate (StateEditor *self);
static GdkPaintable *
get_paintable_for_shape (StateEditor *self,
Shape *shape)
{
GtkSvg *svg = gtk_svg_new ();
g_autoptr (GBytes) bytes = NULL;
Shape *sh;
svg->width = path_paintable_get_width (self->paintable);
svg->height = path_paintable_get_height (self->paintable);
svg_shape_attr_set (svg->content,
SHAPE_ATTR_WIDTH,
svg_number_new (svg->width));
svg_shape_attr_set (svg->content,
SHAPE_ATTR_HEIGHT,
svg_number_new (svg->height));
svg_shape_attr_set (svg->content,
SHAPE_ATTR_VIEW_BOX,
svg_view_box_new (&GRAPHENE_RECT_INIT (0, 0, svg->width, svg->height)));
sh = shape_duplicate (shape);
svg_shape_attr_set (sh, SHAPE_ATTR_VISIBILITY, NULL);
svg_shape_attr_set (sh, SHAPE_ATTR_DISPLAY, NULL);
g_ptr_array_add (svg->content->shapes, sh);
bytes = gtk_svg_serialize (svg);
g_object_unref (svg);
svg = gtk_svg_new_from_bytes (bytes);
gtk_svg_play (svg);
return GDK_PAINTABLE (svg);
}
static gboolean
valid_state_name (const char *name)
{
if (strcmp (name, "all") == 0 ||
strcmp (name, "none") == 0 ||
g_ascii_isdigit (name[0]))
return FALSE;
return TRUE;
}
static void
update_state_names (StateEditor *self)
{
const char *names[65] = { NULL, };
unsigned int i;
for (i = 0; i <= self->max_state; i++)
{
GtkEditable *e;
const char *text;
e = GTK_EDITABLE (gtk_grid_get_child_at (self->grid, i, -1));
text = gtk_editable_get_text (e);
if (text && valid_state_name (text))
{
names[i] = text;
}
else
{
char num[64];
g_snprintf (num, sizeof (num), "%u", i);
if (strcmp (num, text) == 0)
{
names[i] = NULL;
break;
}
else
{
gtk_editable_set_text (e, num);
return;
}
}
}
names[i + 1] = NULL;
path_paintable_set_state_names (self->paintable, names);
}
static void
update_states (StateEditor *self)
{
GtkLayoutManager *mgr = gtk_widget_get_layout_manager (GTK_WIDGET (self->grid));
uint64_t *states;
states = g_newa0 (uint64_t, path_paintable_get_n_paths (self->paintable));
for (GtkWidget *child = gtk_widget_get_first_child (GTK_WIDGET (self->grid));
child != NULL;
child = gtk_widget_get_next_sibling (child))
{
if (!GTK_IS_CHECK_BUTTON (child))
continue;
if (gtk_check_button_get_active (GTK_CHECK_BUTTON (child)))
{
GtkLayoutChild *layout_child;
int row, col;
layout_child = gtk_layout_manager_get_layout_child (mgr, child);
row = gtk_grid_layout_child_get_row (GTK_GRID_LAYOUT_CHILD (layout_child));
col = gtk_grid_layout_child_get_column (GTK_GRID_LAYOUT_CHILD (layout_child));
if (col <= self->max_state)
states[row] |= (G_GUINT64_CONSTANT (1) << (unsigned int) col);
}
}
self->updating = TRUE;
for (unsigned int i = 0; i < path_paintable_get_n_paths (self->paintable); i++)
path_paintable_set_path_states (self->paintable, i, states[i]);
self->updating = FALSE;
repopulate (self);
}
static void
drop_state (StateEditor *self)
{
if (self->max_state == 0)
return;
self->max_state--;
self->max_state = CLAMP (self->max_state, 0, 63);
update_state_names (self);
update_states (self);
}
static void
add_state (StateEditor *self)
{
if (self->max_state == 63)
return;
self->max_state++;
self->max_state = CLAMP (self->max_state, 0, 63);
update_states (self);
}
static void
clear_paths (StateEditor *self)
{
GtkWidget *child;
while ((child = gtk_widget_get_first_child (GTK_WIDGET (self->grid))) != NULL)
gtk_widget_unparent (child);
}
static void
create_paths_for_shape (StateEditor *self,
Shape *shape)
{
for (unsigned int i = 0; i < shape->shapes->len; i++)
{
Shape *sh = g_ptr_array_index (shape->shapes, i);
if (sh->type == SHAPE_GROUP)
{
create_paths_for_shape (self, sh);
continue;
}
else if (shape_is_graphical (sh))
{
uint64_t states = sh->gpa.states;
GdkPaintable *paintable = get_paintable_for_shape (self, sh);
const char *id = sh->id;
GtkWidget *child;
child = gtk_image_new_from_paintable (paintable);
gtk_image_set_pixel_size (GTK_IMAGE (child), 20);
g_object_unref (paintable);
gtk_grid_attach (self->grid, child, -2, i, 1, 1);
child = gtk_label_new (id);
gtk_grid_attach (self->grid, child, -1, i, 1, 1);
for (unsigned int j = 0; j <= self->max_state; j++)
{
child = gtk_check_button_new ();
gtk_widget_set_halign (child, GTK_ALIGN_CENTER);
gtk_check_button_set_active (GTK_CHECK_BUTTON (child),
(states & ((G_GUINT64_CONSTANT (1) << j))) != 0);
g_signal_connect_swapped (child, "notify::active", G_CALLBACK (update_states), self);
gtk_grid_attach (self->grid, child, j, i, 1, 1);
}
}
}
}
static void
state_name_changed (GtkEditable *editable,
GParamSpec *pspec,
gpointer data)
{
StateEditor *self = (StateEditor *) data;
if (self->updating)
return;
if (gtk_editable_label_get_editing (GTK_EDITABLE_LABEL (editable)))
return;
update_state_names (self);
}
static void
create_paths (StateEditor *self)
{
GtkWidget *child;
const char **names;
unsigned int n_names;
names = path_paintable_get_state_names (self->paintable, &n_names);
for (unsigned int i = 0; i <= self->max_state; i++)
{
if (i < n_names)
child = gtk_editable_label_new (names[i]);
else
{
char *s = g_strdup_printf ("%u", i);
child = gtk_editable_label_new (s);
g_free (s);
}
gtk_editable_set_width_chars (GTK_EDITABLE (child), 6);
gtk_grid_attach (self->grid, child, i, -1, 1, 1);
g_signal_connect (child, "notify::editing", G_CALLBACK (state_name_changed), self);
}
create_paths_for_shape (self, path_paintable_get_content (self->paintable));
}
static void
repopulate (StateEditor *self)
{
if (self->updating)
return;
clear_paths (self);
create_paths (self);
}
static void
paths_changed (StateEditor *self)
{
self->max_state = MAX (self->max_state, path_paintable_get_max_state (self->paintable));
self->max_state = CLAMP (self->max_state, 0, 63);
repopulate (self);
}
/* }}} */
/* {{{ GObject boilerplate */
static void
state_editor_init (StateEditor *self)
{
gtk_widget_init_template (GTK_WIDGET (self));
}
static void
state_editor_set_property (GObject *object,
unsigned int prop_id,
const GValue *value,
GParamSpec *pspec)
{
StateEditor *self = STATE_EDITOR (object);
switch (prop_id)
{
case PROP_PAINTABLE:
state_editor_set_paintable (self, g_value_get_object (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
state_editor_get_property (GObject *object,
unsigned int prop_id,
GValue *value,
GParamSpec *pspec)
{
StateEditor *self = STATE_EDITOR (object);
switch (prop_id)
{
case PROP_PAINTABLE:
g_value_set_object (value, self->paintable);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
state_editor_dispose (GObject *object)
{
StateEditor *self = STATE_EDITOR (object);
if (self->paintable)
g_signal_handlers_disconnect_by_func (self->paintable, paths_changed, self);
g_clear_object (&self->paintable);
gtk_widget_dispose_template (GTK_WIDGET (object), STATE_EDITOR_TYPE);
G_OBJECT_CLASS (state_editor_parent_class)->dispose (object);
}
static void
state_editor_finalize (GObject *object)
{
G_OBJECT_CLASS (state_editor_parent_class)->finalize (object);
}
static void
state_editor_class_init (StateEditorClass *class)
{
GObjectClass *object_class = G_OBJECT_CLASS (class);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
g_type_ensure (SHAPE_EDITOR_TYPE);
object_class->dispose = state_editor_dispose;
object_class->finalize = state_editor_finalize;
object_class->set_property = state_editor_set_property;
object_class->get_property = state_editor_get_property;
properties[PROP_PAINTABLE] =
g_param_spec_object ("paintable", NULL, NULL,
PATH_PAINTABLE_TYPE,
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/state-editor.ui");
gtk_widget_class_bind_template_child (widget_class, StateEditor, grid);
gtk_widget_class_bind_template_callback (widget_class, drop_state);
gtk_widget_class_bind_template_callback (widget_class, add_state);
}
/* }}} */
/* {{{ Public API */
StateEditor *
state_editor_new (void)
{
return g_object_new (STATE_EDITOR_TYPE, NULL);
}
PathPaintable *
state_editor_get_paintable (StateEditor *self)
{
g_return_val_if_fail (STATE_IS_EDITOR (self), NULL);
return self->paintable;
}
void
state_editor_set_paintable (StateEditor *self,
PathPaintable *paintable)
{
g_return_if_fail (STATE_IS_EDITOR (self));
if (self->paintable == paintable)
return;
if (self->paintable)
{
g_signal_handlers_disconnect_by_func (self->paintable, paths_changed, self);
}
g_set_object (&self->paintable, paintable);
if (paintable)
{
g_signal_connect_swapped (paintable, "paths-changed",
G_CALLBACK (paths_changed), self);
paths_changed (self);
}
g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_PAINTABLE]);
}
/* }}} */
/* vim:set foldmethod=marker: */