static void
glade_eprop_model_data_add_row (GladeEditorProperty * eprop)
{
GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);
GValue value = { 0, };
GNode *node = NULL;
GList *columns = NULL;
GladeProperty *property = glade_editor_property_get_property (eprop);
glade_property_get (property, &node);
glade_widget_property_get (glade_property_get_widget (property), "columns", &columns);
if (!columns)
return;
clear_view (eprop);
if (!node)
node = g_node_new (NULL);
else
node = glade_model_data_tree_copy (node);
append_row (node, columns);
eprop_data->adding_row = TRUE;
g_value_init (&value, GLADE_TYPE_MODEL_DATA_TREE);
g_value_take_boxed (&value, node);
glade_editor_property_commit (eprop, &value);
g_value_unset (&value);
eprop_data->adding_row = FALSE;
}
/**
* glade_property_add_object:
* @property: a #GladeProperty
* @object: The #GObject to add
*
* Adds @object to the object list in @property.
*
* Note: This function expects @property to be a #GladeParamSpecObjects
* or #GParamSpecObject type property.
*/
void
glade_property_add_object (GladeProperty * property, GObject * object)
{
GList *list = NULL, *new_list = NULL;
GParamSpec *pspec;
g_return_if_fail (GLADE_IS_PROPERTY (property));
g_return_if_fail (G_IS_OBJECT (object));
pspec = glade_property_class_get_pspec (property->priv->klass);
g_return_if_fail (GLADE_IS_PARAM_SPEC_OBJECTS (pspec) ||
G_IS_PARAM_SPEC_OBJECT (pspec));
if (GLADE_IS_PARAM_SPEC_OBJECTS (pspec))
{
glade_property_get (property, &list);
new_list = g_list_copy (list);
new_list = g_list_append (new_list, object);
glade_property_set (property, new_list);
/* ownership of the list is not passed
* through glade_property_set()
*/
g_list_free (new_list);
}
else
{
glade_property_set (property, object);
}
}
static void
glade_eprop_model_data_delete_selected (GladeEditorProperty * eprop)
{
GtkTreeIter iter;
GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);
GladeProperty *property = glade_editor_property_get_property (eprop);
GNode *data_tree = NULL, *row;
gint rownum = -1;
/* NOTE: This will trigger row-deleted below... */
if (!gtk_tree_selection_get_selected (eprop_data->selection, NULL, &iter))
return;
gtk_tree_model_get (GTK_TREE_MODEL (eprop_data->store), &iter,
COLUMN_ROW, &rownum, -1);
g_assert (rownum >= 0);
/* if theres a sected row, theres data... */
glade_property_get (property, &data_tree);
g_assert (data_tree);
data_tree = glade_model_data_tree_copy (data_tree);
row = g_node_nth_child (data_tree, rownum);
g_node_unlink (row);
glade_model_data_tree_free (row);
if (eprop_data->pending_data_tree)
glade_model_data_tree_free (eprop_data->pending_data_tree);
eprop_data->pending_data_tree = data_tree;
g_idle_add ((GSourceFunc) update_data_tree_idle, eprop);
}
static void
icon_name_entry_activated (GtkEntry * entry,
GladeEPropIconSources * eprop_sources)
{
const gchar *text = gtk_entry_get_text (entry);
GladeProperty *property;
GladeIconSources *sources = NULL;
if (!text || !text[0])
return;
property = glade_editor_property_get_property (GLADE_EDITOR_PROPERTY (eprop_sources));
if (!property)
return;
glade_property_get (property, &sources);
if (sources == NULL || g_hash_table_lookup (sources->sources, text) == NULL)
{
/* Add the new source if it doesnt already exist */
gtk_combo_box_text_insert (GTK_COMBO_BOX_TEXT (eprop_sources->combo), -1, text, text);
}
/* Set the active id whether it existed or not */
gtk_combo_box_set_active_id (GTK_COMBO_BOX (eprop_sources->combo), text);
}
/* Shared with other classes */
void
glade_gtk_write_icon_size (GladeWidget *widget,
GladeXmlContext *context,
GladeXmlNode *node,
const gchar *prop_name)
{
GladeXmlNode *prop_node;
GladeProperty *size_prop;
GtkIconSize icon_size;
gchar *value;
/* We have to save icon-size as an integer, the core will take care of
* loading the int value though.
*/
size_prop = glade_widget_get_property (widget, prop_name);
if (glade_property_get_enabled (size_prop) &&
!glade_property_original_default (size_prop))
{
gchar *write_prop_name = g_strdup (prop_name);
glade_util_replace (write_prop_name, '-', '_');
prop_node = glade_xml_node_new (context, GLADE_TAG_PROPERTY);
glade_xml_node_append_child (node, prop_node);
glade_xml_node_set_property_string (prop_node, GLADE_TAG_NAME, write_prop_name);
glade_property_get (size_prop, &icon_size);
value = g_strdup_printf ("%d", icon_size);
glade_xml_set_content (prop_node, value);
g_free (value);
g_free (write_prop_name);
}
}
static void
eprop_model_data_generate_columns (GladeEditorProperty * eprop)
{
GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);
GladeProperty *property = glade_editor_property_get_property (eprop);
GladeModelData *iter_data;
GtkTreeViewColumn *column;
GNode *data_tree = NULL, *iter_node;
gint colnum;
glade_property_get (property, &data_tree);
if (!data_tree || !data_tree->children || !data_tree->children->children)
return;
/* Append new columns */
for (colnum = 0, iter_node = data_tree->children->children; iter_node;
colnum++, iter_node = iter_node->next)
{
iter_data = iter_node->data;
column = eprop_model_generate_column (eprop, colnum, iter_data);
gtk_tree_view_append_column (eprop_data->view, column);
}
}
/**
* glade_property_remove_object:
* @property: a #GladeProperty
* @object: The #GObject to add
*
* Removes @object from the object list in @property.
*
* Note: This function expects @property to be a #GladeParamSpecObjects
* or #GParamSpecObject type property.
*/
void
glade_property_remove_object (GladeProperty * property, GObject * object)
{
GList *list = NULL, *new_list = NULL;
GParamSpec *pspec;
g_return_if_fail (GLADE_IS_PROPERTY (property));
g_return_if_fail (G_IS_OBJECT (object));
pspec = glade_property_class_get_pspec (property->priv->klass);
g_return_if_fail (GLADE_IS_PARAM_SPEC_OBJECTS (pspec) ||
G_IS_PARAM_SPEC_OBJECT (pspec));
if (GLADE_IS_PARAM_SPEC_OBJECTS (pspec))
{
/* If object isnt in list; list should stay in tact.
* not bothering to check for now.
*/
glade_property_get (property, &list);
new_list = g_list_copy (list);
new_list = g_list_remove (new_list, object);
glade_property_set (property, new_list);
/* ownership of the list is not passed
* through glade_property_set()
*/
g_list_free (new_list);
}
else
{
glade_property_set (property, NULL);
}
}
static void
glade_gtk_widget_add2group_cb (GtkMenuItem * item, GladeWidget * gwidget)
{
GladeWidget *group =
g_object_get_data (G_OBJECT (item), "glade-group-widget");
GladeWidgetAdaptor *adaptor =
glade_widget_adaptor_get_by_type (GTK_TYPE_SIZE_GROUP);
GList *widget_list = NULL, *new_list;
GladeProperty *property;
if (group)
glade_command_push_group (_("Adding %s to Size Group %s"),
glade_widget_get_name (gwidget),
glade_widget_get_name (group));
else
glade_command_push_group (_("Adding %s to a new Size Group"),
glade_widget_get_name (gwidget));
if (!group)
/* Cant cancel a size group */
group =
glade_command_create (adaptor, NULL, NULL,
glade_widget_get_project (gwidget));
property = glade_widget_get_property (group, "widgets");
glade_property_get (property, &widget_list);
new_list = g_list_copy (widget_list);
if (!g_list_find (widget_list, glade_widget_get_object (gwidget)))
new_list = g_list_append (new_list, glade_widget_get_object (gwidget));
glade_command_set_property (property, new_list);
g_list_free (new_list);
glade_command_pop_group ();
}
static void
value_attribute_toggled (GtkCellRendererToggle * cell_renderer,
gchar * path, GladeEditorProperty * eprop)
{
GladeEPropIconSources *eprop_sources = GLADE_EPROP_ICON_SOURCES (eprop);
GladeProperty *property = glade_editor_property_get_property (eprop);
GtkTreeIter iter;
GladeIconSources *icon_sources = NULL;
GtkIconSource *source;
gchar *icon_name;
gint index, edit_column;
gboolean edit_column_active = FALSE;
if (!gtk_tree_model_get_iter_from_string
(GTK_TREE_MODEL (eprop_sources->store), &iter, path))
return;
edit_column =
GPOINTER_TO_INT (g_object_get_data
(G_OBJECT (cell_renderer), "attribute-column"));
gtk_tree_model_get (GTK_TREE_MODEL (eprop_sources->store), &iter,
COLUMN_ICON_NAME, &icon_name, COLUMN_LIST_INDEX, &index,
edit_column, &edit_column_active, -1);
glade_property_get (property, &icon_sources);
if (icon_sources)
icon_sources = glade_icon_sources_copy (icon_sources);
if (icon_sources &&
(source = get_icon_source (icon_sources, icon_name, index)) != NULL)
{
/* Note the reverse meaning of active toggles vs. wildcarded sources... */
switch (edit_column)
{
case COLUMN_DIRECTION_ACTIVE:
gtk_icon_source_set_direction_wildcarded (source,
edit_column_active);
break;
case COLUMN_SIZE_ACTIVE:
gtk_icon_source_set_size_wildcarded (source, edit_column_active);
break;
case COLUMN_STATE_ACTIVE:
gtk_icon_source_set_state_wildcarded (source, edit_column_active);
break;
default:
break;
}
update_icon_sources (eprop, icon_sources);
g_free (icon_name);
return;
}
if (icon_sources)
glade_icon_sources_free (icon_sources);
g_free (icon_name);
return;
}
static void
glade_gtk_widget_add2group_cb (GtkMenuItem * item, GladeWidget * gwidget)
{
GladeWidget *group =
g_object_get_data (G_OBJECT (item), "glade-group-widget");
GladeWidgetAdaptor *adaptor =
glade_widget_adaptor_get_by_type (GTK_TYPE_SIZE_GROUP);
GList *widget_list = NULL, *new_list;
GladeProperty *property;
const gchar *current_name;
const gchar *size_group_name = NULL;
gchar *widget_name;
/* Display "(unnamed)" for unnamed size groups */
if (group)
{
size_group_name = glade_widget_get_name (group);
if (g_str_has_prefix (size_group_name, GLADE_UNNAMED_PREFIX))
size_group_name = _("(unnamed)");
}
/* Ensure the widget has a name if it's going to be referred to by a size group */
current_name = glade_widget_get_name (gwidget);
if (g_str_has_prefix (current_name, GLADE_UNNAMED_PREFIX))
widget_name = glade_project_new_widget_name (glade_widget_get_project (gwidget), NULL,
glade_widget_adaptor_get_generic_name (glade_widget_get_adaptor (gwidget)));
else
widget_name = g_strdup (current_name);
if (group)
glade_command_push_group (_("Adding %s to Size Group %s"),
widget_name,
size_group_name);
else
glade_command_push_group (_("Adding %s to a new Size Group"),
widget_name);
glade_command_set_name (gwidget, widget_name);
if (!group)
/* Cant cancel a size group */
group =
glade_command_create (adaptor, NULL, NULL,
glade_widget_get_project (gwidget));
property = glade_widget_get_property (group, "widgets");
glade_property_get (property, &widget_list);
new_list = g_list_copy (widget_list);
if (!g_list_find (widget_list, glade_widget_get_object (gwidget)))
new_list = g_list_append (new_list, glade_widget_get_object (gwidget));
glade_command_set_property (property, new_list);
g_list_free (new_list);
g_free (widget_name);
glade_command_pop_group ();
}
static void
value_text_edited (GtkCellRendererText * cell,
const gchar * path,
const gchar * new_text, GladeEditorProperty * eprop)
{
GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);
GtkTreeIter iter;
gint colnum = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), "column-number"));
gint row;
GNode *data_tree = NULL;
GladeModelData *data;
GValue *value;
GladeProperty *property = glade_editor_property_get_property (eprop);
if (!gtk_tree_model_get_iter_from_string
(GTK_TREE_MODEL (eprop_data->store), &iter, path))
return;
gtk_tree_model_get (GTK_TREE_MODEL (eprop_data->store), &iter,
COLUMN_ROW, &row, -1);
glade_property_get (property, &data_tree);
/* if we are editing, then there is data in the datatree */
g_assert (data_tree);
data_tree = glade_model_data_tree_copy (data_tree);
data = glade_model_data_tree_get_data (data_tree, row, colnum);
/* Untranslate string and update value in tree. */
if (G_VALUE_HOLDS_ENUM (&data->value) || G_VALUE_HOLDS_FLAGS (&data->value))
value = glade_utils_value_from_string (G_VALUE_TYPE (&data->value),
glade_get_value_from_displayable
(G_VALUE_TYPE (&data->value),
new_text),
glade_widget_get_project (glade_property_get_widget (property)));
else
value =
glade_utils_value_from_string (G_VALUE_TYPE (&data->value), new_text,
glade_widget_get_project (glade_property_get_widget (property)));
g_value_copy (value, &data->value);
g_value_unset (value);
g_free (value);
eprop_data->editing_row = row;
eprop_data->editing_column = colnum;
if (eprop_data->pending_data_tree)
glade_model_data_tree_free (eprop_data->pending_data_tree);
eprop_data->pending_data_tree = data_tree;
g_idle_add ((GSourceFunc) update_and_focus_data_tree_idle, eprop);
}
static void
value_i18n_activate (GladeCellRendererIcon * cell,
const gchar * path, GladeEditorProperty * eprop)
{
GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);
GtkTreeIter iter;
gint colnum = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), "column-number"));
gint row;
GNode *data_tree = NULL;
GladeModelData *data;
gchar *new_text;
GladeProperty *property = glade_editor_property_get_property (eprop);
if (!gtk_tree_model_get_iter_from_string
(GTK_TREE_MODEL (eprop_data->store), &iter, path))
return;
gtk_tree_model_get (GTK_TREE_MODEL (eprop_data->store), &iter,
COLUMN_ROW, &row, -1);
glade_property_get (property, &data_tree);
/* if we are editing, then there is data in the datatree */
g_assert (data_tree);
data_tree = glade_model_data_tree_copy (data_tree);
data = glade_model_data_tree_get_data (data_tree, row, colnum);
g_assert (G_VALUE_TYPE (&data->value) == G_TYPE_STRING);
new_text = g_value_dup_string (&data->value);
if (glade_editor_property_show_i18n_dialog (NULL,
&new_text,
&data->i18n_context,
&data->i18n_comment,
&data->i18n_translatable))
{
g_value_set_string (&data->value, new_text);
eprop_data->editing_row = row;
eprop_data->editing_column = colnum;
if (eprop_data->pending_data_tree)
glade_model_data_tree_free (eprop_data->pending_data_tree);
eprop_data->pending_data_tree = data_tree;
g_idle_add ((GSourceFunc) update_and_focus_data_tree_idle, eprop);
}
else
glade_model_data_tree_free (data_tree);
g_free (new_text);
}
static void
delete_clicked (GtkWidget * button, GladeEditorProperty * eprop)
{
GladeEPropIconSources *eprop_sources = GLADE_EPROP_ICON_SOURCES (eprop);
GladeProperty *property = glade_editor_property_get_property (eprop);
GtkTreeIter iter;
GladeIconSources *icon_sources = NULL;
GList *list, *sources, *new_list_head;
gchar *icon_name;
gint index = 0;
/* NOTE: This will trigger row-deleted below... */
if (!gtk_tree_selection_get_selected
(gtk_tree_view_get_selection (eprop_sources->view), NULL, &iter))
return;
gtk_tree_model_get (GTK_TREE_MODEL (eprop_sources->store), &iter,
COLUMN_ICON_NAME, &icon_name,
COLUMN_LIST_INDEX, &index, -1);
/* Could be the user pressed add and then delete without touching the
* new item.
*/
if (index < 0)
{
g_idle_add ((GSourceFunc) reload_icon_sources_idle, eprop);
return;
}
glade_property_get (property, &icon_sources);
if (icon_sources)
{
icon_sources = glade_icon_sources_copy (icon_sources);
if ((sources =
g_hash_table_lookup (icon_sources->sources, icon_name)) != NULL)
{
new_list_head = icon_set_copy (sources);
list = g_list_nth (new_list_head, index);
new_list_head = g_list_remove_link (new_list_head, list);
gtk_icon_source_free ((GtkIconSource *) list->data);
g_list_free (list);
/* We copied all that above cause this will free the old list */
g_hash_table_insert (icon_sources->sources, g_strdup (icon_name),
new_list_head);
}
update_icon_sources (eprop, icon_sources);
}
g_free (icon_name);
}
static void
glade_eprop_string_list_load (GladeEditorProperty * eprop, GladeProperty * property)
{
GladeEPropStringList *eprop_string_list = GLADE_EPROP_STRING_LIST (eprop);
GladeEditorPropertyClass *parent_class =
g_type_class_peek_parent (G_OBJECT_GET_CLASS (eprop));
GList *string_list, *list;
GtkTreeIter iter;
guint i;
g_signal_handlers_block_by_func (eprop_string_list->model, row_deleted, eprop);
gtk_list_store_clear (GTK_LIST_STORE (eprop_string_list->model));
g_signal_handlers_unblock_by_func (eprop_string_list->model, row_deleted, eprop);
parent_class->load (eprop, property);
if (!property)
return;
glade_property_get (property, &string_list);
for (list = string_list, i = 0; list; list = list->next, i++)
{
GladeString *string = list->data;
gtk_list_store_append (GTK_LIST_STORE (eprop_string_list->model), &iter);
gtk_list_store_set (GTK_LIST_STORE (eprop_string_list->model), &iter,
COLUMN_STRING, string->string,
COLUMN_INDEX, i,
COLUMN_DUMMY, FALSE,
COLUMN_ID, string->id,
-1);
}
gtk_list_store_append (GTK_LIST_STORE (eprop_string_list->model), &iter);
gtk_list_store_set (GTK_LIST_STORE (eprop_string_list->model), &iter,
COLUMN_STRING, _("<Type Here>"),
COLUMN_INDEX, i,
COLUMN_DUMMY, TRUE,
COLUMN_ID, NULL,
-1);
if (eprop_string_list->want_focus)
{
GtkTreePath *path = gtk_tree_path_new_from_indices (eprop_string_list->editing_index, -1);
GtkTreeViewColumn *column = gtk_tree_view_get_column (GTK_TREE_VIEW (eprop_string_list->view), 0);
gtk_widget_grab_focus (eprop_string_list->view);
gtk_tree_view_set_cursor (GTK_TREE_VIEW (eprop_string_list->view), path, column, FALSE);
gtk_tree_path_free (path);
}
}
static void
id_edited (GtkCellRendererText *renderer,
gchar *path,
gchar *new_text,
GladeEditorProperty *eprop)
{
GladeEPropStringList *eprop_string_list = GLADE_EPROP_STRING_LIST (eprop);
GtkTreePath *tree_path = gtk_tree_path_new_from_string (path);
GtkTreeIter iter;
guint index;
GladeProperty *property = glade_editor_property_get_property (eprop);
GList *string_list = NULL;
GladeString *string;
gtk_tree_model_get_iter (eprop_string_list->model, &iter, tree_path);
gtk_tree_model_get (eprop_string_list->model, &iter,
COLUMN_INDEX, &index,
-1);
glade_property_get (property, &string_list);
if (string_list)
string_list = glade_string_list_copy (string_list);
string = g_list_nth_data (string_list, index);
g_free (string->id);
if (new_text && new_text[0])
string->id = g_strdup (new_text);
else
string->id = NULL;
eprop_string_list->editing_index = index;
if (eprop_string_list->pending_string_list)
glade_string_list_free (eprop_string_list->pending_string_list);
eprop_string_list->pending_string_list = string_list;
if (eprop_string_list->update_id == 0)
eprop_string_list->update_id =
g_idle_add ((GSourceFunc) update_string_list_idle, eprop);
gtk_tree_path_free (tree_path);
}
static void
i18n_icon_activate (GtkCellRenderer *renderer,
const gchar *path,
GladeEditorProperty *eprop)
{
GladeEPropStringList *eprop_string_list = GLADE_EPROP_STRING_LIST (eprop);
GtkTreePath *tree_path = gtk_tree_path_new_from_string (path);
GtkTreeIter iter;
guint index;
GladeProperty *property = glade_editor_property_get_property (eprop);
GList *string_list = NULL;
GladeString *string;
gtk_tree_model_get_iter (eprop_string_list->model, &iter, tree_path);
gtk_tree_model_get (eprop_string_list->model, &iter,
COLUMN_INDEX, &index,
-1);
glade_property_get (property, &string_list);
string_list = glade_string_list_copy (string_list);
string = g_list_nth_data (string_list, index);
if (glade_editor_property_show_i18n_dialog (NULL,
&string->string,
&string->context,
&string->comment,
&string->translatable))
{
eprop_string_list->editing_index = index;
if (eprop_string_list->pending_string_list)
glade_string_list_free (eprop_string_list->pending_string_list);
eprop_string_list->pending_string_list = string_list;
if (eprop_string_list->update_id == 0)
eprop_string_list->update_id =
g_idle_add ((GSourceFunc) update_string_list_idle, eprop);
}
else
glade_string_list_free (string_list);
gtk_tree_path_free (tree_path);
}
static gboolean
data_changed_idle (GladeEditorProperty *eprop)
{
GladeEPropStringList *eprop_string_list = GLADE_EPROP_STRING_LIST (eprop);
GladeProperty *property = glade_editor_property_get_property (eprop);
GladeString *string, *copy;
GList *string_list = NULL;
GList *new_list = NULL;
GtkTreeIter iter;
guint index;
/* Create a new list based on the order and contents
* of the model state */
glade_property_get (property, &string_list);
if (gtk_tree_model_get_iter_first (eprop_string_list->model, &iter))
{
do
{
gtk_tree_model_get (eprop_string_list->model, &iter,
COLUMN_INDEX, &index, -1);
if ((string = g_list_nth_data (string_list, index)) != NULL)
{
copy = glade_string_copy (string);
new_list = g_list_prepend (new_list, copy);
}
}
while (gtk_tree_model_iter_next (eprop_string_list->model, &iter));
}
new_list = g_list_reverse (new_list);
if (eprop_string_list->pending_string_list)
glade_string_list_free (eprop_string_list->pending_string_list);
eprop_string_list->pending_string_list = new_list;
/* We're already in an idle, just call it directly here */
update_string_list_idle (eprop);
eprop_string_list->changed_id = 0;
return FALSE;
}
static void
icon_sources_populate_store (GladeEPropIconSources * eprop_sources)
{
GladeIconSources *sources = NULL;
GladeProperty *property;
gtk_tree_store_clear (eprop_sources->store);
gtk_combo_box_text_remove_all (GTK_COMBO_BOX_TEXT (eprop_sources->combo));
property = glade_editor_property_get_property (GLADE_EDITOR_PROPERTY (eprop_sources));
if (!property)
return;
glade_property_get (property, &sources);
if (sources)
g_hash_table_foreach (sources->sources, (GHFunc) populate_store_foreach,
eprop_sources);
}
/* Shared with other classes */
void
glade_gtk_sync_use_appearance (GladeWidget *gwidget)
{
GladeProperty *prop;
gboolean use_appearance;
/* This is the kind of thing we avoid doing at project load time ;-) */
if (glade_widget_superuser ())
return;
prop = glade_widget_get_property (gwidget, "use-action-appearance");
use_appearance = FALSE;
glade_property_get (prop, &use_appearance);
if (use_appearance)
{
glade_property_set (prop, FALSE);
glade_property_set (prop, TRUE);
}
}
static gboolean
data_changed_idle (GladeEditorProperty * eprop)
{
GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);
GladeProperty *property = glade_editor_property_get_property (eprop);
GNode *data_tree = NULL, *new_tree, *row;
GtkTreeIter iter;
gint rownum;
glade_property_get (property, &data_tree);
g_assert (data_tree);
new_tree = g_node_new (NULL);
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (eprop_data->store), &iter))
{
do
{
gtk_tree_model_get (GTK_TREE_MODEL (eprop_data->store), &iter,
COLUMN_ROW, &rownum, -1);
if ((row = g_node_nth_child (data_tree, rownum)) != NULL)
{
/* Make a new tree by copying row by row... */
row = glade_model_data_tree_copy (row);
g_node_append (new_tree, row);
}
}
while (gtk_tree_model_iter_next
(GTK_TREE_MODEL (eprop_data->store), &iter));
}
/* Were already in an idle, no need to idle from here... */
if (eprop_data->pending_data_tree)
glade_model_data_tree_free (eprop_data->pending_data_tree);
eprop_data->pending_data_tree = new_tree;
update_data_tree_idle (eprop);
return FALSE;
}
static void
value_toggled (GtkCellRendererToggle * cell,
gchar * path, GladeEditorProperty * eprop)
{
GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);
GtkTreeIter iter;
gint colnum = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), "column-number"));
gint row;
GNode *data_tree = NULL;
GladeModelData *data;
gboolean active;
GladeProperty *property = glade_editor_property_get_property (eprop);
if (!gtk_tree_model_get_iter_from_string
(GTK_TREE_MODEL (eprop_data->store), &iter, path))
return;
gtk_tree_model_get (GTK_TREE_MODEL (eprop_data->store), &iter,
COLUMN_ROW, &row, NUM_COLUMNS + colnum, &active, -1);
glade_property_get (property, &data_tree);
/* if we are editing, then there is data in the datatree */
g_assert (data_tree);
data_tree = glade_model_data_tree_copy (data_tree);
data = glade_model_data_tree_get_data (data_tree, row, colnum);
g_value_set_boolean (&data->value, !active);
eprop_data->editing_row = row;
eprop_data->editing_column = colnum;
if (eprop_data->pending_data_tree)
glade_model_data_tree_free (eprop_data->pending_data_tree);
eprop_data->pending_data_tree = data_tree;
g_idle_add ((GSourceFunc) update_and_focus_data_tree_idle, eprop);
}
static void
transfer_text_property (GladeWidget *gwidget,
const gchar *from,
const gchar *to)
{
gchar *value = NULL;
gchar *comment = NULL, *context = NULL;
gboolean translatable = FALSE;
GladeProperty *prop_from;
GladeProperty *prop_to;
prop_from = glade_widget_get_property (gwidget, from);
prop_to = glade_widget_get_property (gwidget, to);
g_assert (prop_from);
g_assert (prop_to);
glade_property_get (prop_from, &value);
comment = (gchar *)glade_property_i18n_get_comment (prop_from);
context = (gchar *)glade_property_i18n_get_context (prop_from);
translatable = glade_property_i18n_get_translatable (prop_from);
/* Get our own copies */
value = g_strdup (value);
context = g_strdup (context);
comment = g_strdup (comment);
/* Set target values */
glade_command_set_property (prop_to, value);
glade_command_set_i18n (prop_to, translatable, context, comment);
/* Clear source values */
glade_command_set_property (prop_from, NULL);
glade_command_set_i18n (prop_from, TRUE, NULL, NULL);
g_free (value);
g_free (comment);
g_free (context);
}
static void
glade_gtk_widget_write_atk_property (GladeProperty * property,
GladeXmlContext * context,
GladeXmlNode * node)
{
GladeXmlNode *prop_node;
GladePropertyClass *pclass;
gchar *value;
glade_property_get (property, &value);
if (value && value[0])
{
pclass = glade_property_get_class (property);
prop_node = glade_xml_node_new (context, GLADE_TAG_A11Y_PROPERTY);
glade_xml_node_append_child (node, prop_node);
glade_xml_node_set_property_string (prop_node,
GLADE_TAG_NAME, glade_property_class_id (pclass));
glade_xml_set_content (prop_node, value);
if (glade_property_i18n_get_translatable (property))
glade_xml_node_set_property_string (prop_node,
GLADE_TAG_TRANSLATABLE,
GLADE_XML_TAG_I18N_TRUE);
if (glade_property_i18n_get_comment (property))
glade_xml_node_set_property_string (prop_node,
GLADE_TAG_COMMENT,
glade_property_i18n_get_comment (property));
if (glade_property_i18n_get_context (property))
glade_xml_node_set_property_string (prop_node,
GLADE_TAG_CONTEXT,
glade_property_i18n_get_context (property));
}
}
void
glade_gtk_header_bar_child_action_activate (GladeWidgetAdaptor * adaptor,
GObject * container,
GObject * object,
const gchar * action_path)
{
if (strcmp (action_path, "remove_slot") == 0)
{
GladeWidget *parent;
GladeProperty *property;
parent = glade_widget_get_from_gobject (container);
glade_command_push_group (_("Remove placeholder from %s"), glade_widget_get_name (parent));
if (g_object_get_data (object, "special-child-type"))
{
property = glade_widget_get_property (parent, "use-custom-title");
glade_command_set_property (property, FALSE);
}
else
{
gint size;
gtk_container_remove (GTK_CONTAINER (container), GTK_WIDGET (object));
property = glade_widget_get_property (parent, "size");
glade_property_get (property, &size);
glade_command_set_property (property, size - 1);
}
glade_command_pop_group ();
}
else
GWA_GET_CLASS (GTK_TYPE_CONTAINER)->child_action_activate (adaptor,
container,
object,
action_path);
}
static void
glade_gtk_widget_write_atk_action (GladeProperty * property,
GladeXmlContext * context,
GladeXmlNode * node)
{
GladeXmlNode *prop_node;
GladePropertyClass *pclass;
gchar *value = NULL;
glade_property_get (property, &value);
if (value && value[0])
{
pclass = glade_property_get_class (property);
prop_node = glade_xml_node_new (context, GLADE_TAG_A11Y_ACTION);
glade_xml_node_append_child (node, prop_node);
glade_xml_node_set_property_string (prop_node,
GLADE_TAG_A11Y_ACTION_NAME,
&glade_property_class_id (pclass)[4]);
glade_xml_node_set_property_string (prop_node,
GLADE_TAG_A11Y_DESC, value);
}
}
void
glade_gtk_header_bar_action_activate (GladeWidgetAdaptor *adaptor,
GObject * object,
const gchar *action_path)
{
if (!strcmp (action_path, "add_slot"))
{
GladeWidget *parent;
GladeProperty *property;
gint size;
parent = glade_widget_get_from_gobject (object);
glade_command_push_group (_("Insert placeholder to %s"), glade_widget_get_name (parent));
property = glade_widget_get_property (parent, "size");
glade_property_get (property, &size);
glade_command_set_property (property, size + 1);
glade_command_pop_group ();
}
else
GWA_GET_CLASS (GTK_TYPE_CONTAINER)->action_activate (adaptor, object, action_path);
}
static void
value_filename_edited (GtkCellRendererText * cell,
const gchar * path,
const gchar * new_text, GladeEditorProperty * eprop)
{
GladeEPropIconSources *eprop_sources = GLADE_EPROP_ICON_SOURCES (eprop);
GladeProperty *property = glade_editor_property_get_property (eprop);
GtkTreeIter iter;
GladeIconSources *icon_sources = NULL;
GtkIconSource *source;
gchar *icon_name;
gint index = -1;
GValue *value;
GdkPixbuf *pixbuf;
GList *source_list;
if (!new_text || !new_text[0])
{
g_idle_add ((GSourceFunc) reload_icon_sources_idle, eprop);
return;
}
if (!gtk_tree_model_get_iter_from_string
(GTK_TREE_MODEL (eprop_sources->store), &iter, path))
return;
gtk_tree_model_get (GTK_TREE_MODEL (eprop_sources->store), &iter,
COLUMN_ICON_NAME, &icon_name,
COLUMN_LIST_INDEX, &index, -1);
/* get new pixbuf value... */
value = glade_utils_value_from_string (GDK_TYPE_PIXBUF, new_text,
glade_widget_get_project (glade_property_get_widget (property)));
pixbuf = g_value_get_object (value);
glade_property_get (property, &icon_sources);
if (icon_sources)
{
icon_sources = glade_icon_sources_copy (icon_sources);
if (index >= 0 &&
(source = get_icon_source (icon_sources, icon_name, index)) != NULL)
gtk_icon_source_set_pixbuf (source, pixbuf);
else
{
source = gtk_icon_source_new ();
gtk_icon_source_set_pixbuf (source, pixbuf);
if ((source_list = g_hash_table_lookup (icon_sources->sources,
icon_name)) != NULL)
{
source_list = g_list_append (source_list, source);
}
else
{
source_list = g_list_prepend (NULL, source);
g_hash_table_insert (icon_sources->sources, g_strdup (icon_name),
source_list);
}
}
}
else
{
icon_sources = glade_icon_sources_new ();
source = gtk_icon_source_new ();
gtk_icon_source_set_pixbuf (source, pixbuf);
source_list = g_list_prepend (NULL, source);
g_hash_table_insert (icon_sources->sources, g_strdup (icon_name),
source_list);
}
g_value_unset (value);
g_free (value);
update_icon_sources (eprop, icon_sources);
}
static void
value_attribute_edited (GtkCellRendererText * cell,
const gchar * path,
const gchar * new_text, GladeEditorProperty * eprop)
{
GladeEPropIconSources *eprop_sources = GLADE_EPROP_ICON_SOURCES (eprop);
GladeProperty *property = glade_editor_property_get_property (eprop);
GtkTreeIter iter;
GladeIconSources *icon_sources = NULL;
GtkIconSource *source;
gchar *icon_name;
gint index, edit_column;
if (!new_text || !new_text[0])
return;
if (!gtk_tree_model_get_iter_from_string
(GTK_TREE_MODEL (eprop_sources->store), &iter, path))
return;
edit_column =
GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), "attribute-column"));
gtk_tree_model_get (GTK_TREE_MODEL (eprop_sources->store), &iter,
COLUMN_ICON_NAME, &icon_name, COLUMN_LIST_INDEX, &index,
-1);
glade_property_get (property, &icon_sources);
if (icon_sources)
icon_sources = glade_icon_sources_copy (icon_sources);
if (icon_sources &&
(source = get_icon_source (icon_sources, icon_name, index)) != NULL)
{
GtkTextDirection direction;
GtkIconSize size;
GtkStateType state;
switch (edit_column)
{
case COLUMN_DIRECTION:
direction =
glade_utils_enum_value_from_string (GTK_TYPE_TEXT_DIRECTION,
new_text);
gtk_icon_source_set_direction (source, direction);
break;
case COLUMN_SIZE:
size =
glade_utils_enum_value_from_string (GTK_TYPE_ICON_SIZE,
new_text);
gtk_icon_source_set_size (source, size);
break;
case COLUMN_STATE:
state =
glade_utils_enum_value_from_string (GTK_TYPE_STATE_TYPE,
new_text);
gtk_icon_source_set_state (source, state);
break;
default:
break;
}
update_icon_sources (eprop, icon_sources);
g_free (icon_name);
return;
}
if (icon_sources)
glade_icon_sources_free (icon_sources);
g_free (icon_name);
return;
}
static void
string_edited (GtkCellRendererText *renderer,
gchar *path,
gchar *new_text,
GladeEditorProperty *eprop)
{
GladeEPropStringList *eprop_string_list = GLADE_EPROP_STRING_LIST (eprop);
GtkTreePath *tree_path = gtk_tree_path_new_from_string (path);
GtkTreeIter iter;
gboolean dummy;
guint index;
GladeProperty *property = glade_editor_property_get_property (eprop);
GList *string_list = NULL;
gtk_tree_model_get_iter (eprop_string_list->model, &iter, tree_path);
gtk_tree_model_get (eprop_string_list->model, &iter,
COLUMN_INDEX, &index,
COLUMN_DUMMY, &dummy,
-1);
glade_property_get (property, &string_list);
if (string_list)
string_list = glade_string_list_copy (string_list);
if (dummy)
{
if (new_text && new_text[0] && strcmp (new_text, _("<Type Here>")) != 0)
string_list =
glade_string_list_append (string_list,
new_text, NULL, NULL,
eprop_string_list->translatable,
NULL);
}
else if (new_text && new_text[0])
{
GladeString *string =
g_list_nth_data (string_list, index);
g_free (string->string);
string->string = g_strdup (new_text);
}
else
{
GList *node = g_list_nth (string_list, index);
glade_string_free (node->data);
string_list =
g_list_delete_link (string_list, node);
}
eprop_string_list->editing_index = index;
if (eprop_string_list->pending_string_list)
glade_string_list_free (eprop_string_list->pending_string_list);
eprop_string_list->pending_string_list = string_list;
if (eprop_string_list->update_id == 0)
eprop_string_list->update_id =
g_idle_add ((GSourceFunc) update_string_list_idle, eprop);
gtk_tree_path_free (tree_path);
}
static GtkListStore *
eprop_model_data_generate_store (GladeEditorProperty * eprop)
{
GtkListStore *store = NULL;
GladeModelData *iter_data;
GNode *data_tree = NULL, *iter_node, *row_node;
GArray *gtypes = g_array_new (FALSE, TRUE, sizeof (GType));
GtkTreeIter iter;
gint column_num, row_num;
GType index_type = G_TYPE_INT, string_type = G_TYPE_STRING, pointer_type = G_TYPE_POINTER;
GladeProperty *property = glade_editor_property_get_property (eprop);
glade_property_get (property, &data_tree);
if (!data_tree || !data_tree->children || !data_tree->children->children)
return NULL;
/* Generate store with tailored column types */
g_array_append_val (gtypes, index_type);
for (iter_node = data_tree->children->children; iter_node;
iter_node = iter_node->next)
{
iter_data = iter_node->data;
if (G_VALUE_TYPE (&iter_data->value) == 0)
g_array_append_val (gtypes, pointer_type);
else if (G_VALUE_TYPE (&iter_data->value) == GDK_TYPE_PIXBUF)
g_array_append_val (gtypes, string_type);
else
g_array_append_val (gtypes, G_VALUE_TYPE (&iter_data->value));
}
store = gtk_list_store_newv (gtypes->len, (GType *) gtypes->data);
g_array_free (gtypes, TRUE);
/* Now populate the store with data */
for (row_num = 0, row_node = data_tree->children; row_node;
row_num++, row_node = row_node->next)
{
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, COLUMN_ROW, row_num, -1);
for (column_num = NUM_COLUMNS, iter_node = row_node->children; iter_node;
column_num++, iter_node = iter_node->next)
{
iter_data = iter_node->data;
if (G_VALUE_TYPE (&iter_data->value) == 0)
continue;
/* Special case, show the filename in the cellrenderertext */
if (G_VALUE_TYPE (&iter_data->value) == GDK_TYPE_PIXBUF)
{
GObject *object = g_value_get_object (&iter_data->value);
gchar *filename = NULL;
if (object)
filename = g_object_get_data (object, "GladeFileName");
gtk_list_store_set (store, &iter, column_num, filename, -1);
}
else
gtk_list_store_set_value (store, &iter, column_num,
&iter_data->value);
}
}
return store;
}
