void
glade_gtk_file_filter_write_widget (GladeWidgetAdaptor *adaptor,
GladeWidget *widget,
GladeXmlContext *context,
GladeXmlNode *node)
{
GladeXmlNode *strings_node;
if (!(glade_xml_node_verify_silent (node, GLADE_XML_TAG_WIDGET) ||
glade_xml_node_verify_silent (node, GLADE_XML_TAG_TEMPLATE)))
return;
/* First chain up and read in all the normal properties.. */
GWA_GET_CLASS (G_TYPE_OBJECT)->write_widget (adaptor, widget, context, node);
strings_node = glade_xml_node_new (context, GLADE_TAG_MIME_TYPES);
glade_gtk_filter_write_strings (widget, context, strings_node, FILTER_MIME, "glade-mime-types");
if (!glade_xml_node_get_children (strings_node))
glade_xml_node_delete (strings_node);
else
glade_xml_node_append_child (node, strings_node);
strings_node = glade_xml_node_new (context, GLADE_TAG_PATTERNS);
glade_gtk_filter_write_strings (widget, context, strings_node, FILTER_PATTERN, "glade-patterns");
if (!glade_xml_node_get_children (strings_node))
glade_xml_node_delete (strings_node);
else
glade_xml_node_append_child (node, strings_node);
}
static void
glade_gtk_window_write_accel_groups (GladeWidget * widget,
GladeXmlContext * context,
GladeXmlNode * node)
{
GladeXmlNode *groups_node, *group_node;
GList *groups = NULL, *list;
GladeWidget *agroup;
groups_node = glade_xml_node_new (context, GLADE_TAG_ACCEL_GROUPS);
if (glade_widget_property_get (widget, "accel-groups", &groups))
{
for (list = groups; list; list = list->next)
{
agroup = glade_widget_get_from_gobject (list->data);
group_node = glade_xml_node_new (context, GLADE_TAG_ACCEL_GROUP);
glade_xml_node_append_child (groups_node, group_node);
glade_xml_node_set_property_string (group_node, GLADE_TAG_NAME,
glade_widget_get_name (agroup));
}
}
if (!glade_xml_node_get_children (groups_node))
glade_xml_node_delete (groups_node);
else
glade_xml_node_append_child (node, groups_node);
}
void
glade_gtk_read_accels (GladeWidget * widget,
GladeXmlNode * node, gboolean require_signal)
{
GladeProperty *property;
GladeXmlNode *prop;
GladeAccelInfo *ainfo;
GValue *value = NULL;
GList *accels = NULL;
for (prop = glade_xml_node_get_children (node);
prop; prop = glade_xml_node_next (prop))
{
if (!glade_xml_node_verify_silent (prop, GLADE_TAG_ACCEL))
continue;
if ((ainfo = glade_accel_read (prop, require_signal)) != NULL)
accels = g_list_prepend (accels, ainfo);
}
if (accels)
{
value = g_new0 (GValue, 1);
g_value_init (value, GLADE_TYPE_ACCEL_GLIST);
g_value_take_boxed (value, accels);
property = glade_widget_get_property (widget, "accelerator");
glade_property_set_value (property, value);
g_value_unset (value);
g_free (value);
}
}
void
glade_gtk_combo_box_text_write_widget (GladeWidgetAdaptor *adaptor,
GladeWidget *widget,
GladeXmlContext *context,
GladeXmlNode *node)
{
GladeXmlNode *attrs_node;
if (!(glade_xml_node_verify_silent (node, GLADE_XML_TAG_WIDGET) ||
glade_xml_node_verify_silent (node, GLADE_XML_TAG_TEMPLATE)))
return;
/* First chain up and read in all the normal properties.. */
GWA_GET_CLASS (GTK_TYPE_COMBO_BOX)->write_widget (adaptor, widget, context, node);
attrs_node = glade_xml_node_new (context, GLADE_TAG_ITEMS);
glade_gtk_combo_box_text_write_items (widget, context, attrs_node);
if (!glade_xml_node_get_children (attrs_node))
glade_xml_node_delete (attrs_node);
else
glade_xml_node_append_child (node, attrs_node);
}
static void
glade_gtk_size_group_write_widgets (GladeWidget * widget,
GladeXmlContext * context,
GladeXmlNode * node)
{
GladeXmlNode *widgets_node, *widget_node;
GList *widgets = NULL, *list;
GladeWidget *awidget;
widgets_node = glade_xml_node_new (context, GLADE_TAG_SIZEGROUP_WIDGETS);
if (glade_widget_property_get (widget, "widgets", &widgets))
{
for (list = widgets; list; list = list->next)
{
awidget = glade_widget_get_from_gobject (list->data);
widget_node =
glade_xml_node_new (context, GLADE_TAG_SIZEGROUP_WIDGET);
glade_xml_node_append_child (widgets_node, widget_node);
glade_xml_node_set_property_string (widget_node, GLADE_TAG_NAME,
glade_widget_get_name (awidget));
}
}
if (!glade_xml_node_get_children (widgets_node))
glade_xml_node_delete (widgets_node);
else
glade_xml_node_append_child (node, widgets_node);
}
static void
glade_gtk_parse_atk_relation (GladeProperty * property, GladeXmlNode * node)
{
GladeXmlNode *prop;
GladePropertyClass *pclass;
gchar *type, *target, *id, *tmp;
gchar *string = NULL;
for (prop = glade_xml_node_get_children (node);
prop; prop = glade_xml_node_next (prop))
{
if (!glade_xml_node_verify_silent (prop, GLADE_TAG_A11Y_RELATION))
continue;
if (!(type =
glade_xml_get_property_string_required
(prop, GLADE_TAG_A11Y_TYPE, NULL)))
continue;
if (!(target =
glade_xml_get_property_string_required
(prop, GLADE_TAG_A11Y_TARGET, NULL)))
{
g_free (type);
continue;
}
id = glade_util_read_prop_name (type);
pclass = glade_property_get_class (property);
if (!strcmp (id, glade_property_class_id (pclass)))
{
if (string == NULL)
string = g_strdup (target);
else
{
tmp = g_strdup_printf ("%s%s%s", string,
GPC_OBJECT_DELIMITER, target);
string = (g_free (string), tmp);
}
}
g_free (id);
g_free (type);
g_free (target);
}
/* we must synchronize this directly after loading this project
* (i.e. lookup the actual objects after they've been parsed and
* are present). this is a feature of object and object list properties
* that needs a better api.
*/
if (string)
{
g_object_set_data_full (G_OBJECT (property), "glade-loaded-object",
/* 'string' here is already allocated on the heap */
string, g_free);
}
}
static void
glade_gtk_icon_factory_write_sources (GladeWidget *widget,
GladeXmlContext *context,
GladeXmlNode *node)
{
GladeXmlNode *sources_node;
GladeIconSources *sources = NULL;
SourceWriteTab tab;
glade_widget_property_get (widget, "sources", &sources);
if (!sources)
return;
sources_node = glade_xml_node_new (context, GLADE_TAG_SOURCES);
tab.context = context;
tab.node = sources_node;
g_hash_table_foreach (sources->sources, (GHFunc) write_icon_sources, &tab);
if (!glade_xml_node_get_children (sources_node))
glade_xml_node_delete (sources_node);
else
glade_xml_node_append_child (node, sources_node);
}
static void
glade_gtk_widget_write_style_classes (GladeWidget * widget,
GladeXmlContext * context,
GladeXmlNode * node)
{
GladeXmlNode *class_node, *style_node;
GList *string_list = NULL, *l;
GladeString *string;
if (!glade_widget_property_get (widget, "glade-style-classes", &string_list) || !string_list)
return;
style_node = glade_xml_node_new (context, GLADE_TAG_STYLE);
for (l = string_list; l; l = l->next)
{
string = l->data;
class_node = glade_xml_node_new (context, GLADE_TAG_CLASS);
glade_xml_node_append_child (style_node, class_node);
glade_xml_node_set_property_string (class_node,
GLADE_TAG_NAME,
string->string);
}
if (!glade_xml_node_get_children (style_node))
glade_xml_node_delete (style_node);
else
glade_xml_node_append_child (node, style_node);
}
static void
glade_gtk_widget_read_style_classes (GladeWidget * widget, GladeXmlNode * node)
{
GladeXmlNode *style_node;
GladeXmlNode *class_node;
GList *string_list = NULL;
if ((style_node = glade_xml_search_child (node, GLADE_TAG_STYLE)) != NULL)
{
for (class_node = glade_xml_node_get_children (style_node);
class_node; class_node = glade_xml_node_next (class_node))
{
gchar *name;
if (!glade_xml_node_verify (class_node, GLADE_TAG_CLASS))
continue;
name = glade_xml_get_property_string (class_node, GLADE_TAG_NAME);
string_list = glade_string_list_append (string_list, name, NULL, NULL, FALSE, NULL);
g_free (name);
}
glade_widget_property_set (widget, "glade-style-classes", string_list);
glade_string_list_free (string_list);
}
}
static void
glade_gtk_parse_atk_props_gtkbuilder (GladeWidget * widget, GladeXmlNode * node)
{
GladeXmlNode *child, *object_node;
gchar *internal;
/* Search for internal "accessible" child and redirect parse from there */
for (child = glade_xml_node_get_children (node);
child; child = glade_xml_node_next (child))
{
if (glade_xml_node_verify_silent (child, GLADE_XML_TAG_CHILD))
{
if ((internal =
glade_xml_get_property_string (child,
GLADE_XML_TAG_INTERNAL_CHILD)))
{
if (!strcmp (internal, GLADE_TAG_A11Y_INTERNAL_NAME) &&
(object_node =
glade_xml_search_child_required (child,
GLADE_XML_TAG_WIDGET)))
glade_gtk_parse_atk_props (widget, object_node);
g_free (internal);
}
}
}
}
static void
glade_gtk_filter_read_strings (GladeWidget *widget,
GladeXmlNode *node,
FilterType type,
const gchar *property_name)
{
GladeXmlNode *items_node;
GladeXmlNode *item_node;
GList *string_list = NULL;
const gchar *string_group_tag;
const gchar *string_tag;
switch (type)
{
case FILTER_PATTERN:
string_group_tag = GLADE_TAG_PATTERNS;
string_tag = GLADE_TAG_PATTERN;
break;
case FILTER_MIME:
string_group_tag = GLADE_TAG_MIME_TYPES;
string_tag = GLADE_TAG_MIME_TYPE;
break;
case FILTER_APPLICATION:
string_group_tag = GLADE_TAG_APPLICATIONS;
string_tag = GLADE_TAG_APPLICATION;
break;
default:
g_assert_not_reached ();
break;
}
if ((items_node =
glade_xml_search_child (node, string_group_tag)) != NULL)
{
for (item_node = glade_xml_node_get_children (items_node);
item_node; item_node = glade_xml_node_next (item_node))
{
gchar *str;
if (!glade_xml_node_verify (item_node, string_tag))
continue;
if ((str = glade_xml_get_content (item_node)) == NULL)
continue;
string_list = glade_string_list_append (string_list, str, NULL, NULL, FALSE, NULL);
g_free (str);
}
glade_widget_property_set (widget, property_name, string_list);
glade_string_list_free (string_list);
}
}
static void
glade_gtk_size_group_read_widgets (GladeWidget * widget, GladeXmlNode * node)
{
GladeXmlNode *widgets_node;
GladeProperty *property;
gchar *string = NULL;
if ((widgets_node =
glade_xml_search_child (node, GLADE_TAG_SIZEGROUP_WIDGETS)) != NULL)
{
GladeXmlNode *node;
for (node = glade_xml_node_get_children (widgets_node);
node; node = glade_xml_node_next (node))
{
gchar *widget_name, *tmp;
if (!glade_xml_node_verify (node, GLADE_TAG_SIZEGROUP_WIDGET))
continue;
widget_name = glade_xml_get_property_string_required
(node, GLADE_TAG_NAME, NULL);
if (string == NULL)
string = widget_name;
else if (widget_name != NULL)
{
tmp =
g_strdup_printf ("%s%s%s", string, GPC_OBJECT_DELIMITER,
widget_name);
string = (g_free (string), tmp);
g_free (widget_name);
}
}
}
if (string)
{
property = glade_widget_get_property (widget, "widgets");
g_assert (property);
/* we must synchronize this directly after loading this project
* (i.e. lookup the actual objects after they've been parsed and
* are present).
*/
g_object_set_data_full (G_OBJECT (property),
"glade-loaded-object", string, g_free);
}
}
static void
glade_gtk_combo_box_text_read_items (GladeWidget *widget, GladeXmlNode *node)
{
GladeXmlNode *items_node;
GladeXmlNode *item_node;
GList *string_list = NULL;
if ((items_node =
glade_xml_search_child (node, GLADE_TAG_ITEMS)) != NULL)
{
for (item_node = glade_xml_node_get_children (items_node);
item_node; item_node = glade_xml_node_next (item_node))
{
gchar *str, *comment, *context;
gchar *id;
gboolean translatable;
if (!glade_xml_node_verify (item_node, GLADE_TAG_ITEM))
continue;
if ((str = glade_xml_get_content (item_node)) == NULL)
continue;
id = glade_xml_get_property_string (item_node, GLADE_TAG_ID);
context = glade_xml_get_property_string (item_node, GLADE_TAG_CONTEXT);
comment = glade_xml_get_property_string (item_node, GLADE_TAG_COMMENT);
translatable = glade_xml_get_property_boolean (item_node, GLADE_TAG_TRANSLATABLE, FALSE);
string_list =
glade_string_list_append (string_list,
str, comment, context, translatable, id);
g_free (str);
g_free (context);
g_free (comment);
g_free (id);
}
glade_widget_property_set (widget, "glade-items", string_list);
glade_string_list_free (string_list);
}
}
static void
glade_gtk_widget_write_atk_props (GladeWidget * widget,
GladeXmlContext * context,
GladeXmlNode * node)
{
GladeXmlNode *atk_node;
atk_node = glade_xml_node_new (context, GLADE_TAG_A11Y_A11Y);
glade_gtk_widget_write_atk_relations (widget, context, atk_node);
glade_gtk_widget_write_atk_actions (widget, context, atk_node);
if (!glade_xml_node_get_children (atk_node))
glade_xml_node_delete (atk_node);
else
glade_xml_node_append_child (node, atk_node);
glade_gtk_widget_write_atk_properties (widget, context, node);
}
static void
glade_gtk_icon_factory_read_sources (GladeWidget *widget, GladeXmlNode *node)
{
GladeIconSources *sources;
GtkIconSource *source;
GladeXmlNode *sources_node, *source_node;
GValue *value;
GList *list;
gchar *current_icon_name = NULL;
GdkPixbuf *pixbuf;
if ((sources_node = glade_xml_search_child (node, GLADE_TAG_SOURCES)) == NULL)
return;
sources = glade_icon_sources_new ();
/* Here we expect all icon sets to remain together in the list. */
for (source_node = glade_xml_node_get_children (sources_node); source_node;
source_node = glade_xml_node_next (source_node))
{
gchar *icon_name;
gchar *str;
if (!glade_xml_node_verify (source_node, GLADE_TAG_SOURCE))
continue;
if (!(icon_name =
glade_xml_get_property_string_required (source_node,
GLADE_TAG_STOCK_ID, NULL)))
continue;
if (!
(str =
glade_xml_get_property_string_required (source_node,
GLADE_TAG_FILENAME, NULL)))
{
g_free (icon_name);
continue;
}
if (!current_icon_name || strcmp (current_icon_name, icon_name) != 0)
current_icon_name = (g_free (current_icon_name), g_strdup (icon_name));
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
source = gtk_icon_source_new ();
G_GNUC_END_IGNORE_DEPRECATIONS
/* Deal with the filename... */
value = glade_utils_value_from_string (GDK_TYPE_PIXBUF, str, glade_widget_get_project (widget));
pixbuf = g_value_dup_object (value);
g_value_unset (value);
g_free (value);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gtk_icon_source_set_pixbuf (source, pixbuf);
G_GNUC_END_IGNORE_DEPRECATIONS
g_object_unref (G_OBJECT (pixbuf));
g_free (str);
/* Now the attributes... */
if ((str =
glade_xml_get_property_string (source_node,
GLADE_TAG_DIRECTION)) != NULL)
{
GtkTextDirection direction =
glade_utils_enum_value_from_string (GTK_TYPE_TEXT_DIRECTION, str);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gtk_icon_source_set_direction_wildcarded (source, FALSE);
gtk_icon_source_set_direction (source, direction);
G_GNUC_END_IGNORE_DEPRECATIONS
g_free (str);
}
if ((str =
glade_xml_get_property_string (source_node, GLADE_TAG_SIZE)) != NULL)
{
GtkIconSize size =
glade_utils_enum_value_from_string (GTK_TYPE_ICON_SIZE, str);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gtk_icon_source_set_size_wildcarded (source, FALSE);
gtk_icon_source_set_size (source, size);
G_GNUC_END_IGNORE_DEPRECATIONS
g_free (str);
}
if ((str =
glade_xml_get_property_string (source_node,
GLADE_TAG_STATE)) != NULL)
{
GtkStateType state =
glade_utils_enum_value_from_string (GTK_TYPE_STATE_TYPE, str);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gtk_icon_source_set_state_wildcarded (source, FALSE);
gtk_icon_source_set_state (source, state);
G_GNUC_END_IGNORE_DEPRECATIONS
g_free (str);
}
if ((list =
g_hash_table_lookup (sources->sources,
g_strdup (current_icon_name))) != NULL)
{
GList *new_list = g_list_append (list, source);
/* Warning: if we use g_list_prepend() the returned pointer will be different
* so we would have to replace the list pointer in the hash table.
* But before doing that we have to steal the old list pointer otherwise
* we would have to make a copy then add the new icon to finally replace the hash table
* value.
* Anyways if we choose to prepend we would have to reverse the list outside this loop
* so its better to append.
*/
if (new_list != list)
{
/* current g_list_append() returns the same pointer so this is not needed */
g_hash_table_steal (sources->sources, current_icon_name);
g_hash_table_insert (sources->sources,
g_strdup (current_icon_name), new_list);
}
}
else
{
list = g_list_append (NULL, source);
g_hash_table_insert (sources->sources, g_strdup (current_icon_name),
list);
}
}
if (g_hash_table_size (sources->sources) > 0)
glade_widget_property_set (widget, "sources", sources);
glade_icon_sources_free (sources);
}
static void
glade_gtk_parse_atk_props (GladeWidget * widget, GladeXmlNode * node)
{
GladeXmlNode *prop;
GladeProperty *property;
GValue *gvalue;
gchar *value, *name, *id, *comment;
gint translatable;
gboolean is_action;
for (prop = glade_xml_node_get_children (node);
prop; prop = glade_xml_node_next (prop))
{
if (glade_xml_node_verify_silent (prop, GLADE_TAG_A11Y_PROPERTY))
is_action = FALSE;
else if (glade_xml_node_verify_silent (prop, GLADE_TAG_A11Y_ACTION))
is_action = TRUE;
else
continue;
if (!is_action &&
!(name = glade_xml_get_property_string_required
(prop, GLADE_XML_TAG_NAME, NULL)))
continue;
else if (is_action &&
!(name = glade_xml_get_property_string_required
(prop, GLADE_TAG_A11Y_ACTION_NAME, NULL)))
continue;
/* Make sure we are working with dashes and
* not underscores ...
*/
id = glade_util_read_prop_name (name);
g_free (name);
/* We are namespacing the action properties internally
* just incase they clash (all property names must be
* unique...)
*/
if (is_action)
{
name = g_strdup_printf ("atk-%s", id);
g_free (id);
id = name;
}
if ((property = glade_widget_get_property (widget, id)) != NULL)
{
/* Complex statement just getting the value here... */
if ((!is_action &&
!(value = glade_xml_get_content (prop))) ||
(is_action &&
!(value = glade_xml_get_property_string_required
(prop, GLADE_TAG_A11Y_DESC, NULL))))
{
/* XXX should be a glade_xml_get_content_required()... */
g_free (id);
continue;
}
/* Set the parsed value on the property ... */
gvalue = glade_property_class_make_gvalue_from_string
(glade_property_get_class (property), value, glade_widget_get_project (widget));
glade_property_set_value (property, gvalue);
g_value_unset (gvalue);
g_free (gvalue);
/* Deal with i18n... ... XXX Do i18n context !!! */
translatable = glade_xml_get_property_boolean
(prop, GLADE_TAG_TRANSLATABLE, FALSE);
comment = glade_xml_get_property_string (prop, GLADE_TAG_COMMENT);
glade_property_i18n_set_translatable (property, translatable);
glade_property_i18n_set_comment (property, comment);
g_free (comment);
g_free (value);
}
g_free (id);
}
}
