| /* Copyright 2015 Red Hat, Inc. |
| * |
| * GTK 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 of the |
| * License, or (at your option) any later version. |
| * |
| * GLib 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 GTK; see the file COPYING. If not, |
| * see <http://www.gnu.org/licenses/>. |
| * |
| * Author: Matthias Clasen |
| */ |
| |
| #include "config.h" |
| |
| #include <stdlib.h> |
| #include <string.h> |
| #include <errno.h> |
| |
| #include <glib/gi18n-lib.h> |
| #include <glib/gprintf.h> |
| #include <glib/gstdio.h> |
| #include <gtk/gtk.h> |
| #include "gtkbuilderprivate.h" |
| #include "gtk-builder-tool.h" |
| |
| typedef struct Element Element; |
| struct Element { |
| Element *parent; |
| char *element_name; |
| char **attribute_names; |
| char **attribute_values; |
| char *data; |
| GList *children; |
| |
| int line_number; |
| int char_number; |
| }; |
| |
| static void |
| free_element (gpointer data) |
| { |
| Element *element = data; |
| g_list_free_full (element->children, free_element); |
| g_free (element->element_name); |
| g_strfreev (element->attribute_names); |
| g_strfreev (element->attribute_values); |
| g_free (element->data); |
| g_free (element); |
| } |
| |
| typedef struct { |
| Element *root; |
| Element *current; |
| GString *value; |
| GtkBuilder *builder; |
| const char *input_filename; |
| char *output_filename; |
| FILE *output; |
| gboolean convert3to4; |
| gboolean has_gtk_requires; |
| } MyParserData; |
| |
| static void |
| start_element (GMarkupParseContext *context, |
| const char *element_name, |
| const char **attribute_names, |
| const char **attribute_values, |
| gpointer user_data, |
| GError **error) |
| { |
| MyParserData *data = user_data; |
| Element *elt; |
| |
| elt = g_new0 (Element, 1); |
| elt->parent = data->current; |
| elt->element_name = g_strdup (element_name); |
| elt->attribute_names = g_strdupv ((char **)attribute_names); |
| elt->attribute_values = g_strdupv ((char **)attribute_values); |
| |
| g_markup_parse_context_get_position (context, &elt->line_number, &elt->char_number); |
| |
| if (data->current) |
| data->current->children = g_list_append (data->current->children, elt); |
| data->current = elt; |
| |
| if (data->root == NULL) |
| data->root = elt; |
| |
| g_string_truncate (data->value, 0); |
| } |
| |
| static void |
| end_element (GMarkupParseContext *context, |
| const char *element_name, |
| gpointer user_data, |
| GError **error) |
| { |
| MyParserData *data = user_data; |
| |
| data->current->data = g_strdup (data->value->str); |
| |
| data->current = data->current->parent; |
| } |
| |
| static void |
| text (GMarkupParseContext *context, |
| const char *text, |
| gsize text_len, |
| gpointer user_data, |
| GError **error) |
| { |
| MyParserData *data = user_data; |
| |
| if (data->value) |
| { |
| g_string_append_len (data->value, text, text_len); |
| return; |
| } |
| } |
| |
| static GMarkupParser parser = { |
| start_element, |
| end_element, |
| text, |
| NULL, |
| NULL |
| }; |
| |
| static const char * |
| canonical_boolean_value (MyParserData *data, |
| const char *string) |
| { |
| GValue value = G_VALUE_INIT; |
| gboolean b = FALSE; |
| |
| if (gtk_builder_value_from_string_type (data->builder, G_TYPE_BOOLEAN, string, &value, NULL)) |
| b = g_value_get_boolean (&value); |
| |
| return b ? "1" : "0"; |
| } |
| |
| typedef enum { |
| PROP_KIND_OBJECT, |
| PROP_KIND_PACKING, |
| PROP_KIND_CELL_PACKING, |
| PROP_KIND_LAYOUT |
| } PropKind; |
| |
| static PropKind |
| get_prop_kind (Element *element) |
| { |
| g_assert (g_str_equal (element->element_name, "property")); |
| |
| if (g_str_equal (element->parent->element_name, "packing")) |
| return PROP_KIND_PACKING; |
| else if (g_str_equal (element->parent->element_name, "layout")) |
| return PROP_KIND_LAYOUT; |
| else if (g_str_equal (element->parent->element_name, "cell-packing")) |
| return PROP_KIND_CELL_PACKING; |
| else |
| return PROP_KIND_OBJECT; |
| } |
| |
| /* A number of properties unfortunately can't be omitted even |
| * if they are nominally set to their default value. In many |
| * cases, this is due to subclasses not overriding the default |
| * value from the superclass. |
| */ |
| static gboolean |
| needs_explicit_setting (GParamSpec *pspec, |
| PropKind kind) |
| { |
| struct _Prop { |
| const char *class; |
| const char *property; |
| PropKind kind; |
| } props[] = { |
| { "GtkAboutDialog", "program-name", PROP_KIND_OBJECT }, |
| { "GtkCalendar", "year", PROP_KIND_OBJECT }, |
| { "GtkCalendar", "month", PROP_KIND_OBJECT }, |
| { "GtkCalendar", "day", PROP_KIND_OBJECT }, |
| { "GtkPlacesSidebar", "show-desktop", PROP_KIND_OBJECT }, |
| { "GtkRadioButton", "draw-indicator", PROP_KIND_OBJECT }, |
| { "GtkWidget", "hexpand", PROP_KIND_OBJECT }, |
| { "GtkWidget", "vexpand", PROP_KIND_OBJECT }, |
| { "GtkGridLayoutChild", "row", PROP_KIND_LAYOUT }, |
| { "GtkGridLayoutChild", "column", PROP_KIND_LAYOUT }, |
| }; |
| gboolean found; |
| int k; |
| const char *class_name; |
| |
| class_name = g_type_name (pspec->owner_type); |
| |
| found = FALSE; |
| for (k = 0; k < G_N_ELEMENTS (props); k++) |
| { |
| if (strcmp (class_name, props[k].class) == 0 && |
| strcmp (pspec->name, props[k].property) == 0 && |
| kind == props[k].kind) |
| { |
| found = TRUE; |
| break; |
| } |
| } |
| |
| return found; |
| } |
| |
| static gboolean |
| has_attribute (Element *elt, |
| const char *name, |
| const char *value) |
| { |
| int i; |
| |
| for (i = 0; elt->attribute_names[i]; i++) |
| { |
| if (strcmp (elt->attribute_names[i], name) == 0 && |
| (value == NULL || strcmp (elt->attribute_values[i], value) == 0)) |
| return TRUE; |
| } |
| |
| return FALSE; |
| } |
| |
| static gboolean |
| is_cdata_property (Element *element) |
| { |
| if (g_str_equal (element->element_name, "property") && |
| has_attribute (element, "name", "bytes") && |
| element->parent != NULL && |
| g_str_equal (element->parent->element_name, "object") && |
| has_attribute (element->parent, "class", "GtkBuilderListItemFactory")) |
| return TRUE; |
| |
| return FALSE; |
| } |
| |
| static gboolean |
| is_pcdata_element (Element *element) |
| { |
| /* elements that can contain text */ |
| const char *names[] = { |
| "property", |
| "attribute", |
| "action-widget", |
| "pattern", |
| "mime-type", |
| "col", |
| "item", |
| "mark", |
| "lookup", |
| NULL, |
| }; |
| |
| if (g_str_equal (element->element_name, "property") && |
| (g_strv_contains ((const char * const *)element->attribute_names, "bind-source") || |
| g_strv_contains ((const char * const *)element->attribute_names, "bind_source"))) |
| return FALSE; |
| |
| if (g_strv_contains (names, element->element_name)) |
| return TRUE; |
| |
| return FALSE; |
| } |
| |
| static gboolean |
| is_container_element (Element *element) |
| { |
| /* elements that just hold a list of things and |
| * can be omitted when they have no children |
| */ |
| const char *names[] = { |
| "packing", |
| "layout", |
| "cell-packing", |
| "attributes", |
| "action-widgets", |
| "patterns", |
| "mime-types", |
| "attributes", |
| "row", |
| "items", |
| NULL |
| }; |
| |
| if (g_strv_contains (names, element->element_name)) |
| return TRUE; |
| |
| return FALSE; |
| } |
| |
| static void |
| canonicalize_key (char *key) |
| { |
| char *p; |
| |
| for (p = key; *p != 0; p++) |
| { |
| char c = *p; |
| |
| /* We may meet something like AtkObject::accessible-name */ |
| if (c == ':' && ((p > key && p[-1] == ':') || p[1] == ':')) |
| continue; |
| |
| if (c != '-' && |
| (c < '0' || c > '9') && |
| (c < 'A' || c > 'Z') && |
| (c < 'a' || c > 'z')) |
| *p = '-'; |
| } |
| } |
| |
| static struct { |
| const char *class; |
| const char *layout_manager; |
| } layout_managers[] = { |
| { "GtkBox", "GtkBoxLayout" }, |
| { "GtkGrid", "GtkGridLayout" }, |
| { "GtkFixed", "GtkFixedLayout" }, |
| { "GtkFileChooserButton", "GtkBinLayout" }, |
| { "GtkFileChooserWidget", "GtkBinLayout" }, |
| { "GtkOverlay", "GtkOverlayLayout" } |
| }; |
| |
| static GParamSpec * |
| get_property_pspec (MyParserData *data, |
| const char *class_name, |
| const char *property_name, |
| PropKind kind) |
| { |
| GType type; |
| GObjectClass *class; |
| GParamSpec *pspec; |
| char *canonical_name; |
| |
| type = g_type_from_name (class_name); |
| if (type == G_TYPE_INVALID) |
| { |
| type = gtk_builder_get_type_from_name (data->builder, class_name); |
| if (type == G_TYPE_INVALID) |
| return NULL; |
| } |
| |
| class = g_type_class_ref (type); |
| canonical_name = g_strdup (property_name); |
| canonicalize_key (canonical_name); |
| switch (kind) |
| { |
| case PROP_KIND_OBJECT: |
| pspec = g_object_class_find_property (class, canonical_name); |
| break; |
| |
| case PROP_KIND_PACKING: |
| pspec = NULL; |
| break; |
| |
| case PROP_KIND_CELL_PACKING: |
| { |
| GObjectClass *cell_class; |
| |
| G_GNUC_BEGIN_IGNORE_DEPRECATIONS |
| /* We're just assuming that the cell layout is using a GtkCellAreaBox. */ |
| cell_class = g_type_class_ref (GTK_TYPE_CELL_AREA_BOX); |
| pspec = gtk_cell_area_class_find_cell_property (GTK_CELL_AREA_CLASS (cell_class), canonical_name); |
| g_type_class_unref (cell_class); |
| G_GNUC_END_IGNORE_DEPRECATIONS |
| } |
| break; |
| |
| case PROP_KIND_LAYOUT: |
| { |
| int i; |
| const char *layout_manager = NULL; |
| |
| pspec = NULL; |
| |
| for (i = 0; i < G_N_ELEMENTS (layout_managers); i++) |
| { |
| if (g_str_equal (layout_managers[i].class, class_name)) |
| { |
| layout_manager = layout_managers[i].layout_manager; |
| break; |
| } |
| } |
| |
| if (layout_manager) |
| { |
| GtkLayoutManagerClass *layout_manager_class; |
| |
| layout_manager_class = GTK_LAYOUT_MANAGER_CLASS (g_type_class_ref (g_type_from_name (layout_manager))); |
| if (layout_manager_class->layout_child_type != G_TYPE_INVALID) |
| { |
| GObjectClass *layout_child_class; |
| layout_child_class = g_type_class_ref (layout_manager_class->layout_child_type); |
| pspec = g_object_class_find_property (layout_child_class, canonical_name); |
| g_type_class_unref (layout_child_class); |
| } |
| g_type_class_unref (layout_manager_class); |
| } |
| } |
| break; |
| |
| default: |
| g_assert_not_reached (); |
| } |
| g_free (canonical_name); |
| g_type_class_unref (class); |
| |
| return pspec; |
| } |
| |
| static const char *get_class_name (Element *element); |
| |
| static gboolean |
| value_is_default (Element *element, |
| MyParserData *data, |
| GParamSpec *pspec, |
| const char *value_string) |
| { |
| GValue value = { 0, }; |
| gboolean ret; |
| GError *error = NULL; |
| |
| if (g_type_is_a (G_PARAM_SPEC_VALUE_TYPE (pspec), G_TYPE_OBJECT)) |
| return FALSE; |
| |
| if (g_type_is_a (G_PARAM_SPEC_VALUE_TYPE (pspec), G_TYPE_BOXED)) |
| return FALSE; |
| |
| if (!value_string) |
| return FALSE; |
| |
| if (!gtk_builder_value_from_string (data->builder, pspec, value_string, &value, &error)) |
| { |
| g_printerr (_("%s:%d: Couldn’t parse value for property '%s': %s\n"), data->input_filename, element->line_number, pspec->name, error->message); |
| g_error_free (error); |
| ret = FALSE; |
| } |
| else |
| { |
| /* GtkWidget::visible has a 'smart' default */ |
| if (pspec->owner_type == GTK_TYPE_WIDGET && |
| g_str_equal (pspec->name, "visible")) |
| { |
| const char *class_name = get_class_name (element); |
| GType type = g_type_from_name (class_name); |
| gboolean default_value; |
| |
| if (g_type_is_a (type, GTK_TYPE_ROOT) || |
| g_type_is_a (type, GTK_TYPE_POPOVER)) |
| default_value = FALSE; |
| else |
| default_value = TRUE; |
| |
| ret = g_value_get_boolean (&value) == default_value; |
| } |
| else if (pspec->owner_type == GTK_TYPE_WINDOW && |
| (g_str_equal (pspec->name, "default-width") || |
| g_str_equal (pspec->name, "default-height"))) |
| { |
| int default_size; |
| |
| default_size = g_value_get_int (&value); |
| ret = default_size <= 0; |
| } |
| else |
| ret = g_param_value_defaults (pspec, &value); |
| } |
| |
| g_value_reset (&value); |
| |
| return ret; |
| } |
| |
| static const char * |
| get_attribute_value (Element *element, |
| const char *name) |
| { |
| int i; |
| |
| for (i = 0; element->attribute_names[i]; i++) |
| { |
| if (g_str_equal (element->attribute_names[i], name)) |
| return element->attribute_values[i]; |
| } |
| |
| return ""; |
| } |
| |
| static void |
| set_attribute_value (Element *element, |
| const char *name, |
| const char *value) |
| { |
| int i; |
| int len; |
| |
| for (i = 0; element->attribute_names[i]; i++) |
| { |
| if (g_str_equal (element->attribute_names[i], name)) |
| { |
| g_free (element->attribute_values[i]); |
| element->attribute_values[i] = g_strdup (value); |
| return; |
| } |
| } |
| |
| len = g_strv_length (element->attribute_names); |
| element->attribute_names = g_realloc_n (element->attribute_names, len + 2, sizeof (char *)); |
| element->attribute_values = g_realloc_n (element->attribute_values, len + 2, sizeof (char *)); |
| element->attribute_names[len] = g_strdup (name); |
| element->attribute_values[len] = g_strdup (value); |
| element->attribute_names[len + 1] = NULL; |
| element->attribute_values[len + 1] = NULL; |
| } |
| |
| static gboolean |
| element_is_object_or_template (Element *element) |
| { |
| return g_str_equal (element->element_name, "object") || |
| g_str_equal (element->element_name, "template"); |
| } |
| |
| static const char * |
| get_class_name (Element *element) |
| { |
| Element *parent = element->parent; |
| |
| if (element_is_object_or_template (element)) |
| parent = element; |
| |
| if (g_str_equal (parent->element_name, "packing")) |
| parent = parent->parent->parent; /* child - object */ |
| else if (g_str_equal (parent->element_name, "layout")) |
| parent = parent->parent->parent->parent; /* object - child - object */ |
| |
| |
| if (g_str_equal (parent->element_name, "object")) |
| { |
| return get_attribute_value (parent, "class"); |
| } |
| else if (g_str_equal (parent->element_name, "template")) |
| { |
| if (get_attribute_value (parent, "parent")) |
| return get_attribute_value (parent, "parent"); |
| else |
| return get_attribute_value (parent, "class"); |
| } |
| |
| return ""; |
| } |
| |
| static gboolean |
| property_is_boolean (Element *element, |
| MyParserData *data) |
| { |
| GParamSpec *pspec = NULL; |
| const char *class_name; |
| const char *property_name; |
| int i; |
| PropKind kind; |
| |
| kind = get_prop_kind (element); |
| class_name = get_class_name (element); |
| property_name = ""; |
| |
| for (i = 0; element->attribute_names[i]; i++) |
| { |
| if (strcmp (element->attribute_names[i], "name") == 0) |
| property_name = (const char *)element->attribute_values[i]; |
| } |
| |
| if (class_name && property_name) |
| pspec = get_property_pspec (data, class_name, property_name, kind); |
| if (pspec) |
| return G_PARAM_SPEC_VALUE_TYPE (pspec) == G_TYPE_BOOLEAN; |
| |
| return FALSE; |
| } |
| |
| static gboolean |
| property_is_enum (Element *element, |
| MyParserData *data, |
| GType *type) |
| { |
| GParamSpec *pspec = NULL; |
| const char *class_name; |
| const char *property_name; |
| int i; |
| PropKind kind; |
| |
| kind = get_prop_kind (element); |
| class_name = get_class_name (element); |
| property_name = ""; |
| |
| for (i = 0; element->attribute_names[i]; i++) |
| { |
| if (strcmp (element->attribute_names[i], "name") == 0) |
| property_name = (const char *)element->attribute_values[i]; |
| } |
| |
| if (class_name && property_name) |
| pspec = get_property_pspec (data, class_name, property_name, kind); |
| if (pspec && G_TYPE_IS_ENUM (G_PARAM_SPEC_VALUE_TYPE (pspec))) |
| { |
| *type = G_PARAM_SPEC_VALUE_TYPE (pspec); |
| return TRUE; |
| } |
| |
| *type = G_TYPE_NONE; |
| return FALSE; |
| } |
| |
| static char * |
| canonical_enum_value (MyParserData *data, |
| GType type, |
| const char *string) |
| { |
| GValue value = G_VALUE_INIT; |
| |
| if (gtk_builder_value_from_string_type (data->builder, type, string, &value, NULL)) |
| { |
| GEnumClass *eclass = g_type_class_ref (type); |
| GEnumValue *evalue = g_enum_get_value (eclass, g_value_get_enum (&value)); |
| |
| if (evalue) |
| return g_strdup (evalue->value_nick); |
| else |
| return g_strdup_printf ("%d", g_value_get_enum (&value)); |
| } |
| |
| return NULL; |
| } |
| |
| static void |
| warn_missing_property (Element *element, |
| MyParserData *data, |
| const char *class_name, |
| const char *property_name, |
| PropKind kind) |
| { |
| char *name; |
| char *msg; |
| |
| name = g_strconcat (class_name, "::", property_name, NULL); |
| switch (kind) |
| { |
| case PROP_KIND_OBJECT: |
| msg = g_strdup_printf (_("Property %s not found"), name); |
| break; |
| case PROP_KIND_PACKING: |
| msg = g_strdup_printf (_("Packing property %s not found"), name); |
| break; |
| case PROP_KIND_CELL_PACKING: |
| msg = g_strdup_printf (_("Cell property %s not found"), name); |
| break; |
| case PROP_KIND_LAYOUT: |
| msg = g_strdup_printf (_("Layout property %s not found"), name); |
| break; |
| default: |
| g_assert_not_reached (); |
| } |
| |
| g_printerr ("%s:%d: %s\n", data->input_filename, element->line_number, msg); |
| g_free (name); |
| g_free (msg); |
| } |
| |
| static gboolean |
| property_can_be_omitted (Element *element, |
| MyParserData *data) |
| { |
| int i; |
| gboolean bound; |
| gboolean translatable; |
| const char *class_name; |
| const char *property_name; |
| const char *value_string; |
| GParamSpec *pspec; |
| PropKind kind; |
| |
| kind = get_prop_kind (element); |
| class_name = get_class_name (element); |
| property_name = ""; |
| value_string = element->data; |
| |
| bound = FALSE; |
| translatable = FALSE; |
| for (i = 0; element->attribute_names[i]; i++) |
| { |
| if (strcmp (element->attribute_names[i], "bind-source") == 0 || |
| strcmp (element->attribute_names[i], "bind_source") == 0) |
| bound = TRUE; |
| else if (strcmp (element->attribute_names[i], "translatable") == 0) |
| translatable = TRUE; |
| else if (strcmp (element->attribute_names[i], "name") == 0) |
| property_name = (const char *)element->attribute_values[i]; |
| } |
| |
| if (translatable) |
| return FALSE; |
| |
| if (bound) |
| return FALSE; |
| |
| pspec = get_property_pspec (data, class_name, property_name, kind); |
| if (pspec == NULL) |
| { |
| warn_missing_property (element, data, class_name, property_name, kind); |
| return FALSE; |
| } |
| |
| if (needs_explicit_setting (pspec, kind)) |
| return FALSE; |
| |
| return value_is_default (element, data, pspec, value_string); |
| } |
| |
| static gboolean |
| property_has_been_removed (Element *element, |
| MyParserData *data) |
| { |
| const char *class_name; |
| const char *property_name; |
| struct _Prop { |
| const char *class; |
| const char *property; |
| PropKind kind; |
| } props[] = { |
| { "GtkActionBar", "position", PROP_KIND_PACKING }, |
| { "GtkButtonBox", "secondary", PROP_KIND_PACKING }, |
| { "GtkButtonBox", "non-homogeneous", PROP_KIND_PACKING }, |
| { "GtkBox", "position", PROP_KIND_PACKING }, |
| { "GtkBox", "pack-type", PROP_KIND_PACKING }, |
| { "GtkHeaderBar", "position", PROP_KIND_PACKING }, |
| { "GtkPopoverMenu", "position",PROP_KIND_PACKING }, |
| { "GtkCheckButton", "draw-indicator", PROP_KIND_OBJECT }, |
| }; |
| char *canonical_name; |
| gboolean found; |
| int i, k; |
| PropKind kind; |
| |
| kind = get_prop_kind (element); |
| |
| class_name = get_class_name (element); |
| property_name = ""; |
| |
| for (i = 0; element->attribute_names[i]; i++) |
| { |
| if (strcmp (element->attribute_names[i], "name") == 0) |
| property_name = (const char *)element->attribute_values[i]; |
| } |
| |
| canonical_name = g_strdup (property_name); |
| g_strdelimit (canonical_name, "_", '-'); |
| |
| found = FALSE; |
| for (k = 0; k < G_N_ELEMENTS (props); k++) |
| { |
| if (strcmp (class_name, props[k].class) == 0 && |
| strcmp (canonical_name, props[k].property) == 0 && |
| kind == props[k].kind) |
| { |
| found = TRUE; |
| break; |
| } |
| } |
| |
| g_free (canonical_name); |
| |
| return found; |
| } |
| |
| static void |
| maybe_rename_property (Element *element, MyParserData *data) |
| { |
| const char *class_name; |
| const char *property_name; |
| struct _Prop { |
| const char *class; |
| const char *property; |
| GType type; |
| PropKind kind; |
| const char *new_name; |
| const char *alt_names[3]; |
| } props[] = { |
| /* the "replacement" property is placed *after* the "added" properties */ |
| { "GtkPopover", "modal", GTK_TYPE_POPOVER, PROP_KIND_OBJECT, "autohide", { NULL, NULL, NULL } }, |
| { "GtkWidget", "expand", GTK_TYPE_WIDGET, PROP_KIND_OBJECT, "vexpand", { "hexpand", NULL, NULL } }, |
| { "GtkWidget", "margin", GTK_TYPE_WIDGET, PROP_KIND_OBJECT, "margin-bottom", { "margin-start", "margin-end", "margin-top" } }, |
| { "GtkWidget", "margin-left", GTK_TYPE_WIDGET, PROP_KIND_OBJECT, "margin-start", { NULL, NULL, NULL } }, |
| { "GtkWidget", "margin-right", GTK_TYPE_WIDGET, PROP_KIND_OBJECT, "margin-end", { NULL, NULL, NULL } }, |
| { "GtkHeaderBar", "show-close-button", GTK_TYPE_HEADER_BAR, PROP_KIND_OBJECT, "show-title-buttons", { NULL, NULL, NULL } }, |
| { "GtkHeaderBar", "custom-title", GTK_TYPE_HEADER_BAR, PROP_KIND_OBJECT, "title-widget", { NULL, NULL, NULL } }, |
| { "GtkStack", "homogeneous", GTK_TYPE_STACK, PROP_KIND_OBJECT, "hhomogeneous", { "vhomogeneous", NULL, NULL } }, |
| { "GtkImage", "pixbuf", GTK_TYPE_IMAGE, PROP_KIND_OBJECT, "file", { NULL, NULL, NULL } }, |
| { "GtkWidget", "can-focus", GTK_TYPE_WIDGET, PROP_KIND_OBJECT, "focusable", { NULL, NULL, NULL } }, |
| }; |
| int i, k, l; |
| PropKind kind; |
| int prop_name_index = 0; |
| GType type; |
| char *canonical_name; |
| |
| kind = get_prop_kind (element); |
| |
| class_name = get_class_name (element); |
| property_name = NULL; |
| |
| for (i = 0; element->attribute_names[i]; i++) |
| { |
| if (strcmp (element->attribute_names[i], "name") == 0) |
| { |
| prop_name_index = i; |
| property_name = (const char *)element->attribute_values[i]; |
| } |
| } |
| |
| if (property_name == NULL) |
| return; |
| |
| type = g_type_from_name (class_name); |
| |
| canonical_name = g_strdup (property_name); |
| g_strdelimit (canonical_name, "_", '-'); |
| |
| for (k = 0; k < G_N_ELEMENTS (props); k++) |
| { |
| if (g_type_is_a (type, props[k].type) && |
| strcmp (canonical_name, props[k].property) == 0 && |
| kind == props[k].kind) |
| { |
| g_free (element->attribute_values[prop_name_index]); |
| element->attribute_values[prop_name_index] = g_strdup (props[k].new_name); |
| for (l = 0; l < 3 && props[k].alt_names[l]; l++) |
| { |
| Element *elt; |
| GList *sibling; |
| |
| elt = g_new0 (Element, 1); |
| elt->parent = element->parent; |
| elt->element_name = g_strdup (element->element_name); |
| elt->attribute_names = g_strdupv ((char **) element->attribute_names); |
| elt->attribute_values = g_strdupv ((char **) element->attribute_values); |
| elt->data = g_strdup (element->data); |
| |
| g_free (elt->attribute_values[prop_name_index]); |
| elt->attribute_values[prop_name_index] = g_strdup (props[k].alt_names[l]); |
| |
| sibling = g_list_find (element->parent->children, element); |
| element->parent->children = g_list_insert_before (element->parent->children, |
| sibling, |
| elt); |
| } |
| break; |
| } |
| } |
| |
| g_free (canonical_name); |
| } |
| |
| static Element * |
| rewrite_stack_child (Element *child, MyParserData *data) |
| { |
| Element *object = NULL; |
| Element *packing = NULL; |
| Element *new_object; |
| Element *prop; |
| GList *l; |
| |
| if (!g_str_equal (child->element_name, "child")) |
| return child; |
| |
| for (l = child->children; l; l = l->next) |
| { |
| Element *elt = l->data; |
| if (g_str_equal (elt->element_name, "object")) |
| object = elt; |
| else if (g_str_equal (elt->element_name, "packing")) |
| packing = elt; |
| } |
| |
| if (!packing) |
| return child; |
| |
| new_object = g_new0 (Element, 1); |
| new_object->element_name = g_strdup ("object"); |
| new_object->attribute_names = g_new0 (char *, 2); |
| new_object->attribute_names[0] = g_strdup ("class"); |
| new_object->attribute_values = g_new0 (char *, 2); |
| new_object->attribute_values[0] = g_strdup ("GtkStackPage"); |
| new_object->children = packing->children; |
| new_object->parent = child; |
| packing->children = NULL; |
| |
| prop = g_new0 (Element, 1); |
| prop->element_name = g_strdup ("property"); |
| prop->attribute_names = g_new0 (char *, 2); |
| prop->attribute_names[0] = g_strdup ("name"); |
| prop->attribute_values = g_new0 (char *, 2); |
| prop->attribute_values[0] = g_strdup ("child"); |
| prop->children = g_list_append (prop->children, object); |
| prop->parent = new_object; |
| new_object->children = g_list_append (new_object->children, prop); |
| |
| g_list_free (child->children); |
| child->children = g_list_append (NULL, new_object); |
| |
| return child; |
| } |
| |
| static void |
| rewrite_stack (Element *element, |
| MyParserData *data) |
| { |
| GList *l, *new_children; |
| |
| new_children = NULL; |
| for (l = element->children; l; l = l->next) |
| { |
| Element *child = l->data; |
| new_children = g_list_append (new_children, rewrite_stack_child (child, data)); |
| } |
| |
| g_list_free (element->children); |
| element->children = new_children; |
| } |
| |
| static Element * |
| rewrite_assistant_child (Element *child, MyParserData *data) |
| { |
| Element *object = NULL; |
| Element *packing = NULL; |
| Element *new_object; |
| Element *prop; |
| GList *l; |
| |
| if (!g_str_equal (child->element_name, "child")) |
| return child; |
| |
| for (l = child->children; l; l = l->next) |
| { |
| Element *elt = l->data; |
| if (g_str_equal (elt->element_name, "object")) |
| object = elt; |
| else if (g_str_equal (elt->element_name, "packing")) |
| packing = elt; |
| } |
| |
| if (!packing) |
| return child; |
| |
| new_object = g_new0 (Element, 1); |
| new_object->element_name = g_strdup ("object"); |
| new_object->attribute_names = g_new0 (char *, 2); |
| new_object->attribute_names[0] = g_strdup ("class"); |
| new_object->attribute_values = g_new0 (char *, 2); |
| new_object->attribute_values[0] = g_strdup ("GtkAssistantPage"); |
| new_object->children = packing->children; |
| new_object->parent = child; |
| packing->children = NULL; |
| |
| prop = g_new0 (Element, 1); |
| prop->element_name = g_strdup ("property"); |
| prop->attribute_names = g_new0 (char *, 2); |
| prop->attribute_names[0] = g_strdup ("name"); |
| prop->attribute_values = g_new0 (char *, 2); |
| prop->attribute_values[0] = g_strdup ("child"); |
| prop->children = g_list_append (prop->children, object); |
| prop->parent = new_object; |
| new_object->children = g_list_append (new_object->children, prop); |
| |
| g_list_free (child->children); |
| child->children = g_list_append (NULL, new_object); |
| |
| return child; |
| } |
| |
| static void |
| rewrite_assistant (Element *element, |
| MyParserData *data) |
| { |
| GList *l, *new_children; |
| |
| new_children = NULL; |
| for (l = element->children; l; l = l->next) |
| { |
| Element *child = l->data; |
| new_children = g_list_append (new_children, rewrite_assistant_child (child, data)); |
| } |
| |
| g_list_free (element->children); |
| element->children = new_children; |
| } |
| |
| static Element * |
| rewrite_notebook_page (Element *child, Element *tab, MyParserData *data) |
| { |
| Element *object = NULL; |
| Element *tab_obj = NULL; |
| Element *packing = NULL; |
| Element *new_object; |
| Element *prop; |
| GList *l; |
| |
| if (!g_str_equal (child->element_name, "child")) |
| return child; |
| |
| if (has_attribute (child, "type", "tab") || |
| has_attribute (child, "type", "action-start") || |
| has_attribute (child, "type", "action-end")) |
| return child; |
| |
| for (l = child->children; l; l = l->next) |
| { |
| Element *elt = l->data; |
| if (g_str_equal (elt->element_name, "object")) |
| object = elt; |
| else if (g_str_equal (elt->element_name, "packing")) |
| packing = elt; |
| else if (g_str_equal (elt->element_name, "placeholder")) |
| return child; |
| } |
| |
| if (!packing && !tab) |
| return child; |
| |
| if (tab) |
| { |
| for (l = tab->children; l; l = l->next) |
| { |
| Element *elt = l->data; |
| if (g_str_equal (elt->element_name, "object")) |
| tab_obj = elt; |
| } |
| } |
| |
| new_object = g_new0 (Element, 1); |
| new_object->element_name = g_strdup ("object"); |
| new_object->attribute_names = g_new0 (char *, 2); |
| new_object->attribute_names[0] = g_strdup ("class"); |
| new_object->attribute_values = g_new0 (char *, 2); |
| new_object->attribute_values[0] = g_strdup ("GtkNotebookPage"); |
| new_object->parent = child; |
| if (packing) |
| { |
| new_object->children = packing->children; |
| packing->children = NULL; |
| } |
| |
| prop = g_new0 (Element, 1); |
| prop->element_name = g_strdup ("property"); |
| prop->attribute_names = g_new0 (char *, 2); |
| prop->attribute_names[0] = g_strdup ("name"); |
| prop->attribute_values = g_new0 (char *, 2); |
| prop->attribute_values[0] = g_strdup ("child"); |
| prop->children = g_list_append (prop->children, object); |
| prop->parent = new_object; |
| new_object->children = g_list_append (new_object->children, prop); |
| |
| if (tab_obj) |
| { |
| prop = g_new0 (Element, 1); |
| prop->element_name = g_strdup ("property"); |
| prop->attribute_names = g_new0 (char *, 2); |
| prop->attribute_names[0] = g_strdup ("name"); |
| prop->attribute_values = g_new0 (char *, 2); |
| prop->attribute_values[0] = g_strdup ("tab"); |
| prop->children = g_list_append (prop->children, tab_obj); |
| prop->parent = new_object; |
| new_object->children = g_list_append (new_object->children, prop); |
| } |
| |
| g_list_free (child->children); |
| child->children = g_list_append (NULL, new_object); |
| |
| return child; |
| } |
| |
| static void |
| rewrite_notebook (Element *element, |
| MyParserData *data) |
| { |
| GList *l, *new_children; |
| |
| new_children = NULL; |
| for (l = element->children; l; l = l->next) |
| { |
| Element *child = l->data; |
| Element *tab = l->next ? l->next->data : NULL; |
| |
| if (tab && has_attribute (tab, "type", "tab")) |
| { |
| new_children = g_list_append (new_children, rewrite_notebook_page (child, tab, data)); |
| l = l->next; /* skip the tab */ |
| } |
| else |
| new_children = g_list_append (new_children, rewrite_notebook_page (child, NULL, data)); |
| } |
| |
| g_list_free (element->children); |
| element->children = new_children; |
| } |
| |
| static void |
| rewrite_pack_type_child (Element *element, |
| MyParserData *data) |
| { |
| Element *pack_type = NULL; |
| GList *l, *ll; |
| |
| if (!g_str_equal (element->element_name, "child")) |
| return; |
| |
| for (l = element->children; l; l = l->next) |
| { |
| Element *elt = l->data; |
| |
| if (g_str_equal (elt->element_name, "packing")) |
| { |
| for (ll = elt->children; ll; ll = ll->next) |
| { |
| Element *elt2 = ll->data; |
| |
| if (g_str_equal (elt2->element_name, "property") && |
| has_attribute (elt2, "name", "pack-type")) |
| { |
| pack_type = elt2; |
| elt->children = g_list_remove (elt->children, pack_type); |
| if (elt->children == NULL) |
| { |
| element->children = g_list_remove (element->children, elt); |
| free_element (elt); |
| } |
| break; |
| } |
| } |
| } |
| |
| if (pack_type) |
| break; |
| } |
| |
| if (pack_type) |
| { |
| char **attnames = g_new0 (char *, g_strv_length (element->attribute_names) + 2); |
| char **attvalues = g_new0 (char *, g_strv_length (element->attribute_names) + 2); |
| int i; |
| |
| for (i = 0; element->attribute_names[i]; i++) |
| { |
| attnames[i] = g_strdup (element->attribute_names[i]); |
| attvalues[i] = g_strdup (element->attribute_values[i]); |
| } |
| |
| attnames[i] = g_strdup ("type"); |
| attvalues[i] = g_strdup (pack_type->data); |
| |
| g_strfreev (element->attribute_names); |
| g_strfreev (element->attribute_values); |
| |
| element->attribute_names = attnames; |
| element->attribute_values = attvalues; |
| |
| free_element (pack_type); |
| } |
| } |
| |
| static void |
| rewrite_pack_type (Element *element, |
| MyParserData *data) |
| { |
| GList *l; |
| |
| for (l = element->children; l; l = l->next) |
| { |
| Element *elt = l->data; |
| if (g_str_equal (elt->element_name, "child")) |
| rewrite_pack_type_child (elt, data); |
| } |
| } |
| |
| static void |
| rewrite_paned_child (Element *element, |
| MyParserData *data, |
| Element *child, |
| const char *suffix) |
| { |
| Element *resize = NULL; |
| Element *shrink = NULL; |
| GList *l, *ll; |
| |
| for (l = child->children; l; l = l->next) |
| { |
| Element *elt = l->data; |
| |
| if (g_str_equal (elt->element_name, "packing")) |
| { |
| for (ll = elt->children; ll; ll = ll->next) |
| { |
| Element *elt2 = ll->data; |
| |
| if (g_str_equal (elt2->element_name, "property") && |
| has_attribute (elt2, "name", "resize")) |
| resize = elt2; |
| else if (g_str_equal (elt2->element_name, "property") && |
| has_attribute (elt2, "name", "shrink")) |
| shrink = elt2; |
| } |
| if (resize) |
| elt->children = g_list_remove (elt->children, resize); |
| if (shrink) |
| elt->children = g_list_remove (elt->children, shrink); |
| if (elt->children == NULL) |
| { |
| child->children = g_list_remove (child->children, elt); |
| free_element (elt); |
| } |
| } |
| |
| if (resize || shrink) |
| break; |
| } |
| |
| if (resize) |
| { |
| Element *elt; |
| |
| elt = g_new0 (Element, 1); |
| elt->parent = element; |
| elt->element_name = g_strdup ("property"); |
| elt->attribute_names = g_new0 (char *, 2); |
| elt->attribute_names[0] = g_strdup ("name"); |
| elt->attribute_values = g_new0 (char *, 2); |
| elt->attribute_values[0] = g_strconcat ("resize-", suffix, NULL); |
| elt->data = g_strdup (resize->data); |
| |
| element->children = g_list_prepend (element->children, elt); |
| |
| free_element (resize); |
| } |
| |
| if (shrink) |
| { |
| Element *elt; |
| |
| elt = g_new0 (Element, 1); |
| elt->parent = element; |
| elt->element_name = g_strdup ("property"); |
| elt->attribute_names = g_new0 (char *, 2); |
| elt->attribute_names[0] = g_strdup ("name"); |
| elt->attribute_values = g_new0 (char *, 2); |
| elt->attribute_values[0] = g_strconcat ("shrink-", suffix, NULL); |
| elt->data = g_strdup (shrink->data); |
| |
| element->children = g_list_prepend (element->children, elt); |
| |
| free_element (shrink); |
| } |
| } |
| |
| static void |
| rewrite_paned (Element *element, |
| MyParserData *data) |
| { |
| Element *child1 = NULL; |
| Element *child2 = NULL; |
| GList *l; |
| |
| for (l = element->children; l; l = l->next) |
| { |
| Element *elt = l->data; |
| |
| if (g_str_equal (elt->element_name, "child")) |
| { |
| if (child1 == NULL) |
| child1 = elt; |
| else if (child2 == NULL) |
| child2 = elt; |
| else |
| break; |
| } |
| } |
| |
| if (child1) |
| rewrite_paned_child (element, data, child1, "start-child"); |
| |
| if (child2) |
| rewrite_paned_child (element, data, child2, "end-child"); |
| } |
| |
| static void |
| replace_child_by_property (Element *element, |
| Element *child, |
| const char *property, |
| MyParserData *data) |
| { |
| Element *obj, *elt; |
| |
| obj = child->children->data; |
| g_assert (obj && g_str_equal (obj->element_name, "object")); |
| child->children = g_list_remove (child->children, obj); |
| |
| elt = g_new0 (Element, 1); |
| elt->parent = element; |
| elt->element_name = g_strdup ("property"); |
| elt->attribute_names = g_new0 (char *, 2); |
| elt->attribute_names[0] = g_strdup ("name"); |
| elt->attribute_values = g_new0 (char *, 2); |
| elt->attribute_values[0] = g_strdup (property); |
| elt->children = g_list_prepend (NULL, obj); |
| |
| for (GList *l = element->children; l; l = l->next) |
| { |
| if (l->data == child) |
| { |
| l->data = elt; |
| elt = NULL; |
| free_element (child); |
| break; |
| } |
| } |
| |
| g_assert (elt == NULL); |
| } |
| |
| static void |
| rewrite_start_end_children (Element *element, |
| MyParserData *data) |
| { |
| Element *start_child = NULL; |
| Element *end_child = NULL; |
| GList *l; |
| |
| for (l = element->children; l; l = l->next) |
| { |
| Element *child = l->data; |
| |
| if (!g_str_equal (child->element_name, "child")) |
| continue; |
| |
| if (has_attribute (child, "type", "start")) |
| start_child = child; |
| else if (has_attribute (child, "type", "end")) |
| end_child = child; |
| else if (start_child == NULL) |
| start_child = child; |
| else if (end_child == NULL) |
| end_child = child; |
| else |
| g_warning ("%s only accepts two children", get_class_name (element)); |
| } |
| |
| if (start_child) |
| replace_child_by_property (element, start_child, "start-child", data); |
| |
| if (end_child) |
| replace_child_by_property (element, end_child, "end-child", data); |
| } |
| |
| static void |
| rewrite_start_center_end_children (Element *element, |
| MyParserData *data) |
| { |
| Element *start_child = NULL; |
| Element *center_child = NULL; |
| Element *end_child = NULL; |
| GList *l; |
| |
| for (l = element->children; l; l = l->next) |
| { |
| Element *child = l->data; |
| |
| if (has_attribute (child, "type", "start")) |
| start_child = child; |
| else if (has_attribute (child, "type", "center")) |
| center_child = child; |
| else if (has_attribute (child, "type", "end")) |
| end_child = child; |
| else if (start_child == NULL) |
| start_child = child; |
| else if (center_child == NULL) |
| center_child = child; |
| else if (end_child == NULL) |
| end_child = child; |
| else |
| g_warning (_("%s only accepts three children"), get_class_name (element)); |
| } |
| |
| if (start_child) |
| replace_child_by_property (element, start_child, "start-widget", data); |
| |
| if (center_child) |
| replace_child_by_property (element, center_child, "center-widget", data); |
| |
| if (end_child) |
| replace_child_by_property (element, end_child, "end-widget", data); |
| } |
| |
| static void |
| rewrite_dialog (Element *element, |
| MyParserData *data) |
| { |
| Element *content_area = NULL; |
| Element *vbox = NULL; |
| Element *action_area = NULL; |
| GList *l; |
| |
| for (l = element->children; l; l = l->next) |
| { |
| Element *elt = l->data; |
| |
| if (g_str_equal (elt->element_name, "child") && |
| g_strcmp0 (get_attribute_value (elt, "internal-child"), "vbox") == 0) |
| { |
| content_area = elt; |
| break; |
| } |
| } |
| |
| if (!content_area || !content_area->children) |
| return; |
| |
| vbox = content_area->children->data; |
| |
| for (l = vbox->children; l; l = l->next) |
| { |
| Element *elt = l->data; |
| |
| if (g_str_equal (elt->element_name, "child") && |
| g_strcmp0 (get_attribute_value (elt, "internal-child"), "action_area") == 0) |
| { |
| action_area = elt; |
| break; |
| } |
| } |
| |
| if (!action_area) |
| return; |
| |
| set_attribute_value (content_area, "internal-child", "content_area"); |
| vbox->children = g_list_remove (vbox->children, action_area); |
| action_area->parent = element; |
| element->children = g_list_append (element->children, action_area); |
| |
| for (l = action_area->children; l; l = l->next) |
| { |
| Element *elt = l->data; |
| |
| if (g_str_equal (elt->element_name, "packing")) |
| { |
| action_area->children = g_list_remove (action_area->children, elt); |
| free_element (elt); |
| break; |
| } |
| } |
| |
| } |
| |
| static void |
| rewrite_grid_layout_prop (Element *element, |
| const char *attr_name, |
| const char *old_value, |
| const char *new_value) |
| { |
| if (g_str_equal (element->element_name, "property")) |
| { |
| char *canonical_name; |
| |
| canonical_name = g_strdup (old_value); |
| g_strdelimit (canonical_name, "_", '-'); |
| |
| if (has_attribute (element, attr_name, old_value) || |
| has_attribute (element, attr_name, canonical_name)) |
| { |
| set_attribute_value (element, attr_name, new_value); |
| } |
| |
| g_free (canonical_name); |
| } |
| } |
| |
| static void |
| rewrite_grid_layout (Element *element, |
| MyParserData *data) |
| { |
| struct _Prop { |
| const char *attr_name; |
| const char *old_value; |
| const char *new_value; |
| } props[] = { |
| { "name", "left_attach", "column", }, |
| { "name", "top_attach", "row", }, |
| { "name", "width", "column-span", }, |
| { "name", "height", "row-span", }, |
| }; |
| GList *l, *ll; |
| |
| for (l = element->children; l; l = l->next) |
| { |
| Element *child = l->data; |
| |
| if (g_str_equal (child->element_name, "child")) |
| { |
| Element *object = NULL; |
| Element *packing = NULL; |
| |
| for (ll = child->children; ll; ll = ll->next) |
| { |
| Element *elt2 = ll->data; |
| |
| if (g_str_equal (elt2->element_name, "object")) |
| object = elt2; |
| |
| if (g_str_equal (elt2->element_name, "packing")) |
| packing = elt2; |
| } |
| |
| if (object && packing) |
| { |
| int i; |
| |
| child->children = g_list_remove (child->children, packing); |
| |
| g_free (packing->element_name); |
| packing->element_name = g_strdup ("layout"); |
| |
| packing->parent = object; |
| object->children = g_list_append (object->children, packing); |
| |
| for (ll = packing->children; ll; ll = ll->next) |
| { |
| Element *elt = ll->data; |
| |
| for (i = 0; i < G_N_ELEMENTS (props); i++) |
| rewrite_grid_layout_prop (elt, |
| props[i].attr_name, |
| props[i].old_value, |
| props[i].new_value); |
| } |
| } |
| } |
| } |
| } |
| |
| static Element * |
| add_element (Element *parent, |
| const char *element_name) |
| { |
| Element *child; |
| |
| child = g_new0 (Element, 1); |
| child->parent = parent; |
| child->element_name = g_strdup (element_name); |
| child->attribute_names = g_new0 (char *, 1); |
| child->attribute_values = g_new0 (char *, 1); |
| parent->children = g_list_prepend (parent->children, child); |
| |
| return child; |
| } |
| |
| static Element * |
| write_box_prop (Element *element, |
| Element *parent, |
| const char *name, |
| const char *value) |
| { |
| |
| if (element) |
| g_free (element->data); |
| else |
| { |
| element = add_element (parent, "property"); |
| set_attribute_value (element, "name", name); |
| } |
| element->data = g_strdup (value); |
| |
| return element; |
| } |
| |
| static void |
| rewrite_box (Element *element, |
| MyParserData *data) |
| { |
| GList *l, *ll; |
| GtkOrientation orientation = GTK_ORIENTATION_HORIZONTAL; |
| |
| if (g_str_equal (get_class_name (element), "GtkVBox")) |
| write_box_prop (NULL, element, "orientation", "vertical"); |
| |
| if (!g_str_equal (get_class_name (element), "GtkBox")) |
| set_attribute_value (element, "class", "GtkBox"); |
| |
| for (l = element->children; l; l = l->next) |
| { |
| Element *child = l->data; |
| |
| if (g_str_equal (child->element_name, "property")) |
| { |
| if (has_attribute (child, "name", "orientation")) |
| { |
| GValue value = G_VALUE_INIT; |
| |
| if (gtk_builder_value_from_string_type (data->builder, |
| GTK_TYPE_ORIENTATION, |
| child->data, |
| &value, |
| NULL)) |
| orientation = g_value_get_enum (&value); |
| } |
| } |
| } |
| |
| for (l = element->children; l; l = l->next) |
| { |
| Element *child = l->data; |
| if (g_str_equal (child->element_name, "child")) |
| { |
| Element *object = NULL; |
| Element *packing = NULL; |
| |
| for (ll = child->children; ll; ll = ll->next) |
| { |
| Element *elt2 = ll->data; |
| |
| if (g_str_equal (elt2->element_name, "object")) |
| object = elt2; |
| |
| if (g_str_equal (elt2->element_name, "packing")) |
| packing = elt2; |
| } |
| |
| if (object && packing) |
| { |
| Element *halign = NULL; |
| Element *hexpand = NULL; |
| Element *valign = NULL; |
| Element *vexpand = NULL; |
| |
| gboolean expand = FALSE; |
| gboolean fill = TRUE; |
| |
| for (ll = object->children; ll; ll = ll->next) |
| { |
| Element *elt = ll->data; |
| if (g_str_equal (elt->element_name, "property")) |
| { |
| if (has_attribute (elt, "name", "halign")) |
| halign = elt; |
| else if (has_attribute (elt, "name", "hexpand")) |
| hexpand = elt; |
| else if (has_attribute (elt, "name", "valign")) |
| valign = elt; |
| else if (has_attribute (elt, "name", "vexpand")) |
| vexpand = elt; |
| } |
| } |
| |
| for (ll = packing->children; ll; ll = ll->next) |
| { |
| Element *elt = ll->data; |
| |
| if (has_attribute (elt, "name", "expand")) |
| { |
| GValue value = G_VALUE_INIT; |
| |
| if (gtk_builder_value_from_string_type (data->builder, |
| G_TYPE_BOOLEAN, |
| elt->data, |
| &value, |
| NULL)) |
| expand = g_value_get_boolean (&value); |
| } |
| |
| if (has_attribute (elt, "name", "fill")) |
| { |
| GValue value = G_VALUE_INIT; |
| |
| if (gtk_builder_value_from_string_type (data->builder, |
| G_TYPE_BOOLEAN, |
| elt->data, |
| &value, |
| NULL)) |
| fill = g_value_get_boolean (&value); |
| } |
| } |
| |
| if (orientation == GTK_ORIENTATION_HORIZONTAL) |
| { |
| if (expand) |
| write_box_prop (hexpand, object, "hexpand", "1"); |
| if (!fill) |
| write_box_prop (halign, object, "halign", "center"); |
| } |
| else if (orientation == GTK_ORIENTATION_VERTICAL) |
| { |
| if (expand) |
| write_box_prop (vexpand, object, "vexpand", "1"); |
| if (!fill) |
| write_box_prop (valign, object, "valign", "center"); |
| } |
| |
| child->children = g_list_remove (child->children, packing); |
| free_element (packing); |
| } |
| } |
| } |
| } |
| |
| static void |
| rewrite_bin_child (Element *element, |
| MyParserData *data) |
| { |
| GList *l, *ll; |
| const char *class_name; |
| GType type; |
| |
| for (l = element->children; l; l = l->next) |
| { |
| Element *child = l->data; |
| Element *object = NULL; |
| |
| if (!g_str_equal (child->element_name, "child") || |
| has_attribute (child, "type", NULL)) |
| continue; |
| |
| for (ll = child->children; ll; ll = ll->next) |
| { |
| Element *elem = ll->data; |
| |
| if (!g_str_equal (elem->element_name, "object")) |
| continue; |
| |
| class_name = get_attribute_value (elem, "class"); |
| if (!class_name) |
| continue; |
| |
| type = g_type_from_name (class_name); |
| if (!g_type_is_a (type, GTK_TYPE_WIDGET)) |
| continue; |
| |
| object = elem; |
| } |
| |
| if (object) |
| { |
| g_free (child->element_name); |
| g_strfreev (child->attribute_names); |
| g_strfreev (child->attribute_values); |
| child->element_name = g_strdup ("property"); |
| child->attribute_names = g_new0 (char *, 2); |
| child->attribute_names[0] = g_strdup ("name"); |
| child->attribute_values = g_new0 (char *, 2); |
| child->attribute_values[0] = g_strdup ("child"); |
| break; |
| } |
| } |
| } |
| |
| static gboolean |
| remove_boolean_prop (Element *element, |
| MyParserData *data, |
| const char *prop_name, |
| gboolean *value) |
| { |
| GList *l; |
| |
| for (l = element->children; l; l = l->next) |
| { |
| Element *child = l->data; |
| |
| if (g_str_equal (child->element_name, "property") && |
| has_attribute (child, "name", prop_name)) |
| { |
| *value = strcmp (canonical_boolean_value (data, child->data), "1") == 0; |
| element->children = g_list_remove (element->children, child); |
| free_element (child); |
| return TRUE; |
| } |
| } |
| |
| return FALSE; |
| } |
| |
| static void |
| rewrite_radio_button (Element *element, |
| MyParserData *data) |
| { |
| gboolean draw_indicator = TRUE; |
| |
| if (!remove_boolean_prop (element, data, "draw-indicator", &draw_indicator)) |
| remove_boolean_prop (element, data, "draw_indicator", &draw_indicator); |
| |
| if (draw_indicator) |
| set_attribute_value (element, "class", "GtkCheckButton"); |
| else |
| set_attribute_value (element, "class", "GtkToggleButton"); |
| |
| } |
| |
| static gboolean |
| has_prop (Element *element, |
| MyParserData *data, |
| const char *prop_name) |
| { |
| GList *l; |
| |
| for (l = element->children; l; l = l->next) |
| { |
| Element *child = l->data; |
| |
| if (g_str_equal (child->element_name, "property") && |
| has_attribute (child, "name", prop_name)) |
| return TRUE; |
| } |
| |
| return FALSE; |
| } |
| |
| static void |
| rewrite_scale (Element *element, |
| MyParserData *data) |
| { |
| if (!has_prop (element, data, "draw-value") && |
| !has_prop (element, data, "draw_value")) |
| { |
| Element *child; |
| child = add_element (element, "property"); |
| set_attribute_value (child, "name", "draw-value"); |
| child->data = g_strdup ("1"); |
| } |
| } |
| |
| static void |
| rewrite_requires (Element *element, |
| MyParserData *data) |
| { |
| if (has_attribute (element, "lib", "gtk+")) |
| { |
| set_attribute_value (element, "lib", "gtk"); |
| set_attribute_value (element, "version", "4.0"); |
| } |
| } |
| |
| static void |
| rewrite_overlay (Element *element, |
| MyParserData *data) |
| { |
| GList *l, *ll; |
| |
| for (l = element->children; l; l = l->next) |
| { |
| Element *child = l->data; |
| |
| if (g_str_equal (child->element_name, "child")) |
| { |
| Element *object = NULL; |
| Element *packing = NULL; |
| |
| for (ll = child->children; ll; ll = ll->next) |
| { |
| Element *elt2 = ll->data; |
| |
| if (g_str_equal (elt2->element_name, "object")) |
| object = elt2; |
| |
| if (g_str_equal (elt2->element_name, "packing")) |
| packing = elt2; |
| } |
| |
| if (object && packing) |
| { |
| child->children = g_list_remove (child->children, packing); |
| |
| for (ll = packing->children; ll; ll = ll->next) |
| { |
| Element *elt2 = ll->data; |
| |
| if (g_str_equal (elt2->element_name, "property") && |
| (has_attribute (elt2, "name", "pass-through") || |
| has_attribute (elt2, "name", "pass_through"))) |
| { |
| const char *b = canonical_boolean_value (data, elt2->data); |
| if (g_str_equal (b, "1")) |
| { |
| Element *new_prop; |
| |
| new_prop = add_element (object, "property"); |
| set_attribute_value (new_prop, "name", "can-target"); |
| new_prop->data = g_strdup ("0"); |
| } |
| break; |
| } |
| } |
| |
| free_element (packing); |
| } |
| } |
| } |
| } |
| |
| static void |
| rewrite_toolbar (Element *element, |
| MyParserData *data) |
| { |
| GList *l, *ll; |
| |
| set_attribute_value (element, "class", "GtkBox"); |
| |
| for (l = element->children; l; l = l->next) |
| { |
| Element *child = l->data; |
| |
| if (g_str_equal (child->element_name, "property") && |
| (has_attribute (child, "name", "toolbar_style") || |
| has_attribute (child, "name", "toolbar-style"))) |
| { |
| element->children = g_list_remove (element->children, child); |
| free_element (child); |
| break; |
| } |
| } |
| |
| for (l = element->children; l; l = l->next) |
| { |
| Element *child = l->data; |
| Element *object = NULL; |
| Element *packing = NULL; |
| |
| if (!g_str_equal (child->element_name, "child")) |
| continue; |
| |
| for (ll = child->children; ll; ll = ll->next) |
| { |
| Element *elt2 = ll->data; |
| |
| if (g_str_equal (elt2->element_name, "object")) |
| object = elt2; |
| |
| if (g_str_equal (elt2->element_name, "packing")) |
| packing = elt2; |
| } |
| |
| if (object) |
| { |
| const char *class_name; |
| |
| class_name = get_class_name (object); |
| |
| if (g_str_equal (class_name, "GtkToolButton")) |
| { |
| set_attribute_value (object, "class", "GtkButton"); |
| } |
| else if (g_str_equal (class_name, "GtkToggleToolButton") || |
| g_str_equal (class_name, "GtkRadioToolButton")) |
| { |
| set_attribute_value (object, "class", "GtkToggleButton"); |
| } |
| else if (g_str_equal (class_name, "GtkSeparatorToolItem")) |
| { |
| Element *prop; |
| |
| set_attribute_value (object, "class", "GtkSeparator"); |
| prop = add_element (object, "property"); |
| set_attribute_value (prop, "name", "orientation"); |
| prop->data = g_strdup ("vertical"); |
| } |
| } |
| |
| if (packing) |
| child->children = g_list_remove (child->children, packing); |
| } |
| |
| { |
| Element *child; |
| |
| child = add_element (element, "property"); |
| set_attribute_value (child, "name", "css-classes"); |
| child->data = g_strdup ("toolbar"); |
| } |
| } |
| |
| static void |
| rewrite_fixed (Element *element, |
| MyParserData *data) |
| { |
| GList *l, *ll; |
| |
| for (l = element->children; l; l = l->next) |
| { |
| Element *child = l->data; |
| |
| if (g_str_equal (child->element_name, "child")) |
| { |
| Element *object = NULL; |
| Element *packing = NULL; |
| |
| for (ll = child->children; ll; ll = ll->next) |
| { |
| Element *elt2 = ll->data; |
| |
| if (g_str_equal (elt2->element_name, "object")) |
| object = elt2; |
| |
| if (g_str_equal (elt2->element_name, "packing")) |
| packing = elt2; |
| } |
| |
| if (object && packing) |
| { |
| int x = 0; |
| int y = 0; |
| Element *layout; |
| Element *new_prop; |
| GskTransform *transform; |
| |
| for (ll = packing->children; ll; ll = ll->next) |
| { |
| Element *elt2 = ll->data; |
| GValue value = G_VALUE_INIT; |
| |
| if (has_attribute (elt2, "name", "x")) |
| { |
| if (gtk_builder_value_from_string_type (data->builder, G_TYPE_INT, elt2->data, &value, NULL)) |
| x = g_value_get_int (&value); |
| } |
| else if (has_attribute (elt2, "name", "y")) |
| { |
| if (gtk_builder_value_from_string_type (data->builder, G_TYPE_INT, elt2->data, &value, NULL)) |
| y = g_value_get_int (&value); |
| } |
| } |
| |
| child->children = g_list_remove (child->children, packing); |
| free_element (packing); |
| |
| layout = add_element (object, "layout"); |
| new_prop = add_element (layout, "property"); |
| set_attribute_value (new_prop, "name", "transform"); |
| |
| transform = gsk_transform_translate (NULL, &GRAPHENE_POINT_INIT (x, y)); |
| new_prop->data = gsk_transform_to_string (transform); |
| gsk_transform_unref (transform); |
| } |
| } |
| } |
| } |
| |
| /* returns TRUE to remove the element from the parent */ |
| static gboolean |
| simplify_element (Element *element, |
| MyParserData *data) |
| { |
| GList *l; |
| GType type; |
| |
| if (!is_pcdata_element (element)) |
| { |
| g_clear_pointer (&element->data, g_free); |
| } |
| else if (g_str_equal (element->element_name, "property")) |
| { |
| if (property_is_boolean (element, data)) |
| { |
| const char *b = canonical_boolean_value (data, element->data); |
| g_free (element->data); |
| element->data = g_strdup (b); |
| } |
| else if (property_is_enum (element, data, &type)) |
| { |
| char *e = canonical_enum_value (data, type, element->data); |
| g_free (element->data); |
| element->data = e; |
| } |
| |
| for (int i = 0; element->attribute_names[i]; i++) |
| { |
| if (g_str_equal (element->attribute_names[i], "translatable")) |
| { |
| const char *b = canonical_boolean_value (data, element->attribute_values[i]); |
| g_free (element->attribute_values[i]); |
| element->attribute_values[i] = g_strdup (b); |
| break; |
| } |
| } |
| } |
| |
| l = element->children; |
| while (l) |
| { |
| GList *next = l->next; |
| Element *child = l->data; |
| if (simplify_element (child, data)) |
| { |
| element->children = g_list_remove (element->children, child); |
| free_element (child); |
| } |
| l = next; |
| } |
| |
| if (is_container_element (element) && element->children == NULL) |
| return TRUE; |
| |
| if (g_str_equal (element->element_name, "property") && |
| property_can_be_omitted (element, data)) |
| return TRUE; |
| |
| if (g_str_equal (element->element_name, "binding")) |
| { |
| const char *property_name = get_attribute_value (element, "name"); |
| const char *class_name = get_class_name (element); |
| if (!get_property_pspec (data, class_name, property_name, PROP_KIND_OBJECT)) |
| warn_missing_property (element, data, class_name, property_name, PROP_KIND_OBJECT); |
| } |
| |
| return FALSE; |
| } |
| |
| static void |
| simplify_tree (MyParserData *data) |
| { |
| simplify_element (data->root, data); |
| } |
| |
| static gboolean |
| rewrite_element_3to4 (Element *element, |
| MyParserData *data) |
| { |
| GList *l; |
| |
| l = element->children; |
| while (l) |
| { |
| GList *next = l->next; |
| Element *child = l->data; |
| if (rewrite_element_3to4 (child, data)) |
| { |
| element->children = g_list_remove (element->children, child); |
| free_element (child); |
| } |
| l = next; |
| } |
| |
| if (element_is_object_or_template (element) && |
| g_str_equal (get_class_name (element), "GtkStack")) |
| rewrite_stack (element, data); |
| |
| if (element_is_object_or_template (element) && |
| g_str_equal (get_class_name (element), "GtkAssistant")) |
| rewrite_assistant (element, data); |
| |
| if (element_is_object_or_template (element) && |
| g_str_equal (get_class_name (element), "GtkNotebook")) |
| rewrite_notebook (element, data); |
| |
| if (element_is_object_or_template (element) && |
| (g_str_equal (get_class_name (element), "GtkActionBar") || |
| g_str_equal (get_class_name (element), "GtkHeaderBar"))) |
| rewrite_pack_type (element, data); |
| |
| if (element_is_object_or_template (element) && |
| g_str_equal (get_class_name (element), "GtkToolbar")) |
| rewrite_toolbar (element, data); |
| |
| if (element_is_object_or_template (element) && |
| g_str_equal (get_class_name (element), "GtkPaned")) |
| rewrite_paned (element, data); |
| |
| if (element_is_object_or_template (element) && |
| g_str_equal (get_class_name (element), "GtkDialog")) |
| rewrite_dialog (element, data); |
| |
| if (element_is_object_or_template (element) && |
| g_str_equal (get_class_name (element), "GtkOverlay")) |
| rewrite_overlay (element, data); |
| |
| if (element_is_object_or_template (element) && |
| g_str_equal (get_class_name (element), "GtkGrid")) |
| rewrite_grid_layout (element, data); |
| |
| if (element_is_object_or_template (element) && |
| (g_str_equal (get_class_name (element), "GtkHBox") || |
| g_str_equal (get_class_name (element), "GtkVBox") || |
| g_str_equal (get_class_name (element), "GtkBox"))) |
| rewrite_box (element, data); |
| |
| if (element_is_object_or_template (element) && |
| g_str_equal (get_class_name (element), "GtkFixed")) |
| rewrite_fixed (element, data); |
| |
| if (element_is_object_or_template (element) && |
| g_str_equal (get_class_name (element), "GtkRadioButton")) |
| rewrite_radio_button (element, data); |
| |
| if (element_is_object_or_template (element) && |
| g_str_equal (get_class_name (element), "GtkScale")) |
| rewrite_scale (element, data); |
| |
| if (g_str_equal (element->element_name, "property")) |
| maybe_rename_property (element, data); |
| |
| if (g_str_equal (element->element_name, "property") && |
| property_has_been_removed (element, data)) |
| return TRUE; |
| |
| if (g_str_equal (element->element_name, "requires")) |
| rewrite_requires (element, data); |
| |
| return FALSE; |
| } |
| |
| static void |
| rewrite_tree_3to4 (MyParserData *data) |
| { |
| rewrite_element_3to4 (data->root, data); |
| } |
| |
| static gboolean |
| rewrite_element (Element *element, |
| MyParserData *data) |
| { |
| GList *l; |
| |
| l = element->children; |
| while (l) |
| { |
| GList *next = l->next; |
| Element *child = l->data; |
| if (rewrite_element (child, data)) |
| { |
| element->children = g_list_remove (element->children, child); |
| free_element (child); |
| } |
| l = next; |
| } |
| |
| if (element_is_object_or_template (element) && |
| (g_str_equal (get_class_name (element), "GtkAspectFrame") || |
| g_str_equal (get_class_name (element), "GtkComboBox") || |
| g_str_equal (get_class_name (element), "GtkComboBoxText") || |
| g_str_equal (get_class_name (element), "GtkFlowBoxChild") || |
| g_str_equal (get_class_name (element), "GtkFrame") || |
| g_str_equal (get_class_name (element), "GtkListBoxRow") || |
| g_str_equal (get_class_name (element), "GtkOverlay") || |
| g_str_equal (get_class_name (element), "GtkPopover") || |
| g_str_equal (get_class_name (element), "GtkPopoverMenu") || |
| g_str_equal (get_class_name (element), "GtkRevealer") || |
| g_str_equal (get_class_name (element), "GtkScrolledWindow") || |
| g_str_equal (get_class_name (element), "GtkSearchBar") || |
| g_str_equal (get_class_name (element), "GtkViewport") || |
| g_str_equal (get_class_name (element), "GtkWindow"))) |
| rewrite_bin_child (element, data); |
| |
| if (element_is_object_or_template (element) && |
| g_str_equal (get_class_name (element), "GtkPaned")) |
| rewrite_start_end_children (element, data); |
| |
| if (element_is_object_or_template (element) && |
| g_str_equal (get_class_name (element), "GtkCenterBox")) |
| rewrite_start_center_end_children (element, data); |
| |
| return FALSE; |
| } |
| |
| static void |
| rewrite_tree (MyParserData *data) |
| { |
| rewrite_element (data->root, data); |
| } |
| |
| /* For properties which have changed their default |
| * value between 3 and 4, we make sure that their |
| * old default value is present in the tree before |
| * simplifying it. |
| * |
| * So far, this is just GtkWidget::visible, |
| * changing its default from 0 to 1. |
| */ |
| static void |
| add_old_default_properties (Element *element, |
| MyParserData *data) |
| { |
| const char *class_name; |
| GType type; |
| |
| if (!g_str_equal (element->element_name, "object")) |
| return; |
| |
| class_name = get_class_name (element); |
| type = g_type_from_name (class_name); |
| if (g_type_is_a (type, GTK_TYPE_WIDGET)) |
| { |
| GList *l; |
| gboolean has_visible = FALSE; |
| |
| for (l = element->children; l; l = l->next) |
| { |
| Element *prop = l->data; |
| const char *name = get_attribute_value (prop, "name"); |
| |
| if (g_str_equal (prop->element_name, "property") && |
| g_str_equal (name, "visible")) |
| has_visible = TRUE; |
| } |
| |
| if (!has_visible) |
| { |
| Element *new_prop; |
| |
| new_prop = add_element (element, "property"); |
| set_attribute_value (new_prop, "name", "visible"); |
| new_prop->data = g_strdup ("0"); |
| } |
| } |
| } |
| |
| static void |
| enhance_element (Element *element, |
| MyParserData *data) |
| { |
| GList *l; |
| |
| if (strcmp (element->element_name, "requires") == 0 && |
| has_attribute (element, "lib", "gtk+")) |
| { |
| data->has_gtk_requires = TRUE; |
| } |
| |
| add_old_default_properties (element, data); |
| |
| for (l = element->children; l; l = l->next) |
| { |
| Element *child = l->data; |
| enhance_element (child, data); |
| } |
| |
| if (element == data->root && !data->has_gtk_requires) |
| { |
| Element *requires = add_element (element, "requires"); |
| set_attribute_value (requires, "lib", "gtk+"); |
| set_attribute_value (requires, "version", "3.0"); |
| } |
| } |
| |
| static void |
| enhance_tree (MyParserData *data) |
| { |
| enhance_element (data->root, data); |
| } |
| |
| static void |
| dump_element (Element *element, |
| FILE *output, |
| int indent) |
| { |
| g_fprintf (output, "%*s<%s", indent, "", element->element_name); |
| if (element->attribute_names[0]) |
| { |
| int i; |
| for (i = 0; element->attribute_names[i]; i++) |
| { |
| char *escaped = g_markup_escape_text (element->attribute_values[i], -1); |
| g_fprintf (output, " %s=\"%s\"", element->attribute_names[i], escaped); |
| g_free (escaped); |
| } |
| } |
| if (element->children || element->data) |
| { |
| g_fprintf (output, ">"); |
| |
| if (element->children) |
| { |
| GList *l; |
| |
| g_fprintf (output, "\n"); |
| for (l = element->children; l; l = l->next) |
| { |
| Element *child = l->data; |
| dump_element (child, output, indent + 2); |
| } |
| g_fprintf (output, "%*s", indent, ""); |
| } |
| else |
| { |
| if (is_cdata_property (element)) |
| { |
| g_fprintf (output, "<![CDATA["); |
| g_fprintf (output, "%s", element->data); |
| g_fprintf (output, "]]>"); |
| } |
| else |
| { |
| char *escaped = g_markup_escape_text (element->data, -1); |
| g_fprintf (output, "%s", escaped); |
| g_free (escaped); |
| } |
| } |
| g_fprintf (output, "</%s>\n", element->element_name); |
| } |
| else |
| g_fprintf (output, "/>\n"); |
| } |
| |
| static void |
| write_xml_declaration (FILE *output) |
| { |
| g_fprintf (output, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); |
| } |
| |
| static void |
| dump_tree (MyParserData *data) |
| { |
| write_xml_declaration (data->output); |
| dump_element (data->root, data->output, 0); |
| } |
| |
| static gboolean |
| simplify_file (const char *filename, |
| gboolean replace, |
| gboolean convert3to4) |
| { |
| GMarkupParseContext *context; |
| char *buffer; |
| MyParserData data; |
| GError *error = NULL; |
| |
| data.input_filename = filename; |
| data.output_filename = NULL; |
| data.convert3to4 = convert3to4; |
| data.has_gtk_requires = FALSE; |
| |
| if (replace) |
| { |
| int fd; |
| fd = g_file_open_tmp ("gtk-builder-tool-XXXXXX", &data.output_filename, NULL); |
| data.output = fdopen (fd, "w"); |
| } |
| else |
| { |
| data.output = stdout; |
| } |
| |
| if (!g_file_get_contents (filename, &buffer, NULL, &error)) |
| { |
| g_printerr (_("Can’t load “%s”: %s\n"), filename, error->message); |
| return FALSE; |
| } |
| |
| data.root = NULL; |
| data.current = NULL; |
| data.value = g_string_new (""); |
| |
| context = g_markup_parse_context_new (&parser, G_MARKUP_TREAT_CDATA_AS_TEXT, &data, NULL); |
| if (!g_markup_parse_context_parse (context, buffer, -1, &error)) |
| { |
| g_printerr (_("Can’t parse “%s”: %s\n"), filename, error->message); |
| return FALSE; |
| } |
| |
| if (!g_markup_parse_context_end_parse (context, &error)) |
| { |
| g_printerr (_("Can’t parse “%s”: %s\n"), filename, error->message); |
| return FALSE; |
| } |
| |
| if (data.root == NULL) |
| { |
| g_printerr (_("Can’t parse “%s”: %s\n"), filename, ""); |
| return FALSE; |
| } |
| |
| data.builder = gtk_builder_new (); |
| |
| if (data.convert3to4) |
| { |
| enhance_tree (&data); |
| rewrite_tree_3to4 (&data); |
| } |
| |
| rewrite_tree (&data); |
| simplify_tree (&data); |
| |
| dump_tree (&data); |
| |
| fclose (data.output); |
| |
| if (data.output_filename) |
| { |
| char *content; |
| gsize length; |
| |
| if (!g_file_get_contents (data.output_filename, &content, &length, &error)) |
| { |
| g_printerr (_("Failed to read “%s”: %s\n"), data.output_filename, error->message); |
| return FALSE; |
| } |
| |
| if (!g_file_set_contents (data.input_filename, content, length, &error)) |
| { |
| g_printerr (_("Failed to write “%s”: “%s”\n"), data.input_filename, error->message); |
| return FALSE; |
| } |
| } |
| |
| return TRUE; |
| } |
| |
| void |
| do_simplify (int *argc, |
| const char ***argv) |
| { |
| gboolean replace = FALSE; |
| gboolean convert3to4 = FALSE; |
| char **filenames = NULL; |
| GOptionContext *context; |
| const GOptionEntry entries[] = { |
| { "replace", 0, 0, G_OPTION_ARG_NONE, &replace, N_("Replace the file"), NULL }, |
| { "3to4", 0, 0, G_OPTION_ARG_NONE, &convert3to4, N_("Convert from GTK 3 to GTK 4"), NULL }, |
| { G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &filenames, NULL, N_("FILE") }, |
| { NULL, } |
| }; |
| GError *error = NULL; |
| int i; |
| |
| g_set_prgname ("gtk4-builder-tool simplify"); |
| context = g_option_context_new (NULL); |
| g_option_context_set_translation_domain (context, GETTEXT_PACKAGE); |
| g_option_context_add_main_entries (context, entries, NULL); |
| g_option_context_set_summary (context, _("Simplify the file.")); |
| |
| if (!g_option_context_parse (context, argc, (char ***)argv, &error)) |
| { |
| g_printerr ("%s\n", error->message); |
| g_error_free (error); |
| exit (1); |
| } |
| |
| g_option_context_free (context); |
| |
| if (filenames == NULL) |
| { |
| g_printerr (_("No .ui file specified\n")); |
| exit (1); |
| } |
| |
| if (g_strv_length (filenames) > 1 && !replace) |
| { |
| g_printerr (_("Can only simplify a single .ui file without --replace\n")); |
| exit (1); |
| } |
| |
| for (i = 0; filenames[i]; i++) |
| { |
| if (!simplify_file (filenames[i], replace, convert3to4)) |
| exit (1); |
| } |
| |
| g_strfreev (filenames); |
| } |
