/* * Copyright (C) 2002 Joaquín Cuenca Abela * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * * Authors: * Joaquín Cuenca Abela * Archit Baweja */ #ifdef HAVE_CONFIG_H #include #endif /** * SECTION:glade-command * @Short_Description: An event filter to implement the Undo/Redo stack. * * The Glade Command api allows us to view user actions as items and execute * and undo those items; each #GladeProject has its own Undo/Redo stack. */ #include #include #include #include "glade.h" #include "glade-project.h" #include "glade-xml-utils.h" #include "glade-widget.h" #include "glade-palette.h" #include "glade-command.h" #include "glade-property.h" #include "glade-property-class.h" #include "glade-debug.h" #include "glade-placeholder.h" #include "glade-clipboard.h" #include "glade-signal.h" #include "glade-app.h" #include "glade-name-context.h" struct _GladeCommandPrivate { GladeProject *project; /* The project this command is created for */ gchar *description; /* a string describing the command. * It's used in the undo/redo menu entry. */ gint group_id; /* If this is part of a command group, this is * the group id (id is needed only to ensure that * consecutive groups dont get merged). */ }; /* Concerning placeholders: we do not hold any reference to placeholders, * placeholders that are supplied by the backend are not reffed, placeholders * that are created by glade-command are temporarily owned by glade-command * untill they are added to a container; in which case it belongs to GTK+ * and the backend (but I prefer to think of it as the backend). */ typedef struct { GladeWidget *widget; GladeWidget *parent; GList *reffed; GladePlaceholder *placeholder; gboolean props_recorded; GList *pack_props; gchar *special_type; gulong handler_id; } CommandData; /* Group description used for the current group */ static gchar *gc_group_description = NULL; /* Use an id to avoid grouping together consecutive groups */ static gint gc_group_id = 1; /* Groups can be grouped together, push/pop must balance (duh!) */ static gint gc_group_depth = 0; G_DEFINE_TYPE_WITH_PRIVATE (GladeCommand, glade_command, G_TYPE_OBJECT) static void glade_command_finalize (GObject *obj) { GladeCommand *cmd = (GladeCommand *) obj; g_return_if_fail (cmd != NULL); if (cmd->priv->description) g_free (cmd->priv->description); /* Call the base class dtor */ (*G_OBJECT_CLASS (glade_command_parent_class)->finalize) (obj); } static gboolean glade_command_unifies_impl (GladeCommand *this_cmd, GladeCommand *other_cmd) { return FALSE; } static void glade_command_collapse_impl (GladeCommand *this_cmd, GladeCommand *other_cmd) { g_return_if_reached (); } static void glade_command_init (GladeCommand *command) { command->priv = glade_command_get_instance_private (command); } static void glade_command_class_init (GladeCommandClass *klass) { GObjectClass *object_class; object_class = G_OBJECT_CLASS (klass); object_class->finalize = glade_command_finalize; klass->undo = NULL; klass->execute = NULL; klass->unifies = glade_command_unifies_impl; klass->collapse = glade_command_collapse_impl; } /* Macros for defining the derived command types */ #define MAKE_TYPE(func, type, parent) \ GType \ func ## _get_type (void) \ { \ static GType cmd_type = 0; \ \ if (!cmd_type) \ { \ static const GTypeInfo info = \ { \ sizeof (type ## Class), \ (GBaseInitFunc) NULL, \ (GBaseFinalizeFunc) NULL, \ (GClassInitFunc) func ## _class_init, \ (GClassFinalizeFunc) NULL, \ NULL, \ sizeof (type), \ 0, \ (GInstanceInitFunc) NULL \ }; \ \ cmd_type = g_type_register_static (parent, #type, &info, 0); \ } \ \ return cmd_type; \ } \ #define GLADE_MAKE_COMMAND(type, func) \ static gboolean \ func ## _undo (GladeCommand *me); \ static gboolean \ func ## _execute (GladeCommand *me); \ static void \ func ## _finalize (GObject *object); \ static gboolean \ func ## _unifies (GladeCommand *this_cmd, GladeCommand *other_cmd); \ static void \ func ## _collapse (GladeCommand *this_cmd, GladeCommand *other_cmd); \ static void \ func ## _class_init (gpointer parent_tmp, gpointer notused) \ { \ GladeCommandClass *parent = parent_tmp; \ GObjectClass* object_class; \ object_class = G_OBJECT_CLASS (parent); \ parent->undo = func ## _undo; \ parent->execute = func ## _execute; \ parent->unifies = func ## _unifies; \ parent->collapse = func ## _collapse; \ object_class->finalize = func ## _finalize; \ } \ typedef struct { \ GladeCommandClass cmd; \ } type ## Class; \ static MAKE_TYPE(func, type, GLADE_TYPE_COMMAND) G_CONST_RETURN gchar * glade_command_description (GladeCommand *command) { g_return_val_if_fail (GLADE_IS_COMMAND (command), NULL); return command->priv->description; } gint glade_command_group_id (GladeCommand *command) { g_return_val_if_fail (GLADE_IS_COMMAND (command), -1); return command->priv->group_id; } /** * glade_command_execute: * @command: A #GladeCommand * * Executes @command * * Returns: whether the command was successfully executed */ gboolean glade_command_execute (GladeCommand *command) { g_return_val_if_fail (GLADE_IS_COMMAND (command), FALSE); return GLADE_COMMAND_GET_CLASS (command)->execute (command); } /** * glade_command_undo: * @command: A #GladeCommand * * Undo the effects of @command * * Returns: whether the command was successfully reversed */ gboolean glade_command_undo (GladeCommand *command) { g_return_val_if_fail (GLADE_IS_COMMAND (command), FALSE); return GLADE_COMMAND_GET_CLASS (command)->undo (command); } /** * glade_command_unifies: * @command: A #GladeCommand * @other: another #GladeCommand * * Checks whether @command and @other can be unified * to make one single command. * * Returns: whether they can be unified. */ gboolean glade_command_unifies (GladeCommand *command, GladeCommand *other) { g_return_val_if_fail (command, FALSE); /* Cannot unify with a part of a command group. * Unify atomic commands only */ if (command->priv->group_id != 0 || (other && other->priv->group_id != 0)) return FALSE; return GLADE_COMMAND_GET_CLASS (command)->unifies (command, other); } /** * glade_command_collapse: * @command: A #GladeCommand * @other: another #GladeCommand * * Merges @other into @command, so that @command now * covers both commands and @other can be dispensed with. */ void glade_command_collapse (GladeCommand *command, GladeCommand *other) { g_return_if_fail (command); GLADE_COMMAND_GET_CLASS (command)->collapse (command, other); } /** * glade_command_push_group: * @fmt: The collective desctiption of the command group. * only the description of the first group on the * stack is used when embedding groups. * @...: args to the format string. * * Marks the begining of a group. */ void glade_command_push_group (const gchar *fmt, ...) { va_list args; g_return_if_fail (fmt); /* Only use the description for the first group. */ if (gc_group_depth++ == 0) { va_start (args, fmt); gc_group_description = g_strdup_vprintf (fmt, args); va_end (args); } } /** * glade_command_pop_group: * * Mark the end of a command group. */ void glade_command_pop_group (void) { if (gc_group_depth-- == 1) { gc_group_description = (g_free (gc_group_description), NULL); gc_group_id++; } if (gc_group_depth < 0) g_critical ("Unbalanced group stack detected in %s\n", G_STRFUNC); } gint glade_command_get_group_depth (void) { return gc_group_depth; } static void glade_command_check_group (GladeCommand *cmd) { g_return_if_fail (GLADE_IS_COMMAND (cmd)); if (gc_group_description) { cmd->priv->description = (g_free (cmd->priv->description), g_strdup (gc_group_description)); cmd->priv->group_id = gc_group_id; } } /****************************************************/ /******* GLADE_COMMAND_PROPERTY_ENABLED *******/ /****************************************************/ typedef struct { GladeCommand parent; GladeProperty *property; gboolean old_enabled; gboolean new_enabled; } GladeCommandPropertyEnabled; /* standard macros */ GLADE_MAKE_COMMAND (GladeCommandPropertyEnabled, glade_command_property_enabled); #define GLADE_COMMAND_PROPERTY_ENABLED_TYPE (glade_command_property_enabled_get_type ()) #define GLADE_COMMAND_PROPERTY_ENABLED(o) (G_TYPE_CHECK_INSTANCE_CAST \ ((o), GLADE_COMMAND_PROPERTY_ENABLED_TYPE, \ GladeCommandPropertyEnabled)) #define GLADE_COMMAND_PROPERTY_ENABLED_CLASS(k) (G_TYPE_CHECK_CLASS_CAST \ ((k), GLADE_COMMAND_PROPERTY_ENABLED_TYPE, \ GladeCommandPropertyEnabledClass)) #define GLADE_IS_COMMAND_PROPERTY_ENABLED(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GLADE_COMMAND_PROPERTY_ENABLED_TYPE)) #define GLADE_IS_COMMAND_PROPERTY_ENABLED_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GLADE_COMMAND_PROPERTY_ENABLED_TYPE)) static gboolean glade_command_property_enabled_execute (GladeCommand *cmd) { GladeCommandPropertyEnabled *me = GLADE_COMMAND_PROPERTY_ENABLED (cmd); glade_property_set_enabled (me->property, me->new_enabled); return TRUE; } static gboolean glade_command_property_enabled_undo (GladeCommand *cmd) { GladeCommandPropertyEnabled *me = GLADE_COMMAND_PROPERTY_ENABLED (cmd); glade_property_set_enabled (me->property, me->old_enabled); return TRUE; } static void glade_command_property_enabled_finalize (GObject *obj) { GladeCommandPropertyEnabled *me; g_return_if_fail (GLADE_IS_COMMAND_PROPERTY_ENABLED (obj)); me = GLADE_COMMAND_PROPERTY_ENABLED (obj); g_object_unref (me->property); glade_command_finalize (obj); } static gboolean glade_command_property_enabled_unifies (GladeCommand *this_cmd, GladeCommand *other_cmd) { GladeCommandPropertyEnabled *cmd1; GladeCommandPropertyEnabled *cmd2; if (!other_cmd) { if (GLADE_IS_COMMAND_PROPERTY_ENABLED (this_cmd)) { cmd1 = (GladeCommandPropertyEnabled *) this_cmd; return (cmd1->old_enabled == cmd1->new_enabled); } return FALSE; } if (GLADE_IS_COMMAND_PROPERTY_ENABLED (this_cmd) && GLADE_IS_COMMAND_PROPERTY_ENABLED (other_cmd)) { cmd1 = GLADE_COMMAND_PROPERTY_ENABLED (this_cmd); cmd2 = GLADE_COMMAND_PROPERTY_ENABLED (other_cmd); return (cmd1->property == cmd2->property); } return FALSE; } static void glade_command_property_enabled_collapse (GladeCommand *this_cmd, GladeCommand *other_cmd) { GladeCommandPropertyEnabled *this = GLADE_COMMAND_PROPERTY_ENABLED (this_cmd); GladeCommandPropertyEnabled *other = GLADE_COMMAND_PROPERTY_ENABLED (other_cmd); GladeWidget *widget; GladePropertyClass *pclass; this->new_enabled = other->new_enabled; widget = glade_property_get_widget (this->property); pclass = glade_property_get_class (this->property); g_free (this_cmd->priv->description); if (this->new_enabled) this_cmd->priv->description = g_strdup_printf (_("Enabling property %s on widget %s"), glade_property_class_get_name (pclass), glade_widget_get_name (widget)); else this_cmd->priv->description = g_strdup_printf (_("Disabling property %s on widget %s"), glade_property_class_get_name (pclass), glade_widget_get_name (widget)); } /** * glade_command_set_property_enabled: * @property: An optional #GladeProperty * @enabled: Whether the property should be enabled * * Enables or disables @property. * * @property must be an optional property. */ void glade_command_set_property_enabled (GladeProperty *property, gboolean enabled) { GladeCommandPropertyEnabled *me; GladeCommand *cmd; GladeWidget *widget; GladePropertyClass *pclass; gboolean old_enabled; /* Sanity checks */ g_return_if_fail (GLADE_IS_PROPERTY (property)); widget = glade_property_get_widget (property); g_return_if_fail (GLADE_IS_WIDGET (widget)); /* Only applies to optional properties */ pclass = glade_property_get_class (property); g_return_if_fail (glade_property_class_optional (pclass)); /* Fetch current state */ old_enabled = glade_property_get_enabled (property); /* Avoid useless command */ if (old_enabled == enabled) return; me = g_object_new (GLADE_COMMAND_PROPERTY_ENABLED_TYPE, NULL); cmd = GLADE_COMMAND (me); cmd->priv->project = glade_widget_get_project (widget); me->property = g_object_ref (property); me->new_enabled = enabled; me->old_enabled = old_enabled; if (enabled) cmd->priv->description = g_strdup_printf (_("Enabling property %s on widget %s"), glade_property_class_get_name (pclass), glade_widget_get_name (widget)); else cmd->priv->description = g_strdup_printf (_("Disabling property %s on widget %s"), glade_property_class_get_name (pclass), glade_widget_get_name (widget)); glade_command_check_group (GLADE_COMMAND (me)); if (glade_command_property_enabled_execute (GLADE_COMMAND (me))) glade_project_push_undo (cmd->priv->project, cmd); else g_object_unref (G_OBJECT (me)); } /**************************************************/ /******* GLADE_COMMAND_SET_PROPERTY *******/ /**************************************************/ /* create a new GladeCommandSetProperty class. Objects of this class will * encapsulate a "set property" operation */ typedef struct { GladeCommand parent; gboolean set_once; gboolean undo; GList *sdata; } GladeCommandSetProperty; /* standard macros */ GLADE_MAKE_COMMAND (GladeCommandSetProperty, glade_command_set_property); #define GLADE_COMMAND_SET_PROPERTY_TYPE (glade_command_set_property_get_type ()) #define GLADE_COMMAND_SET_PROPERTY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GLADE_COMMAND_SET_PROPERTY_TYPE, GladeCommandSetProperty)) #define GLADE_COMMAND_SET_PROPERTY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GLADE_COMMAND_SET_PROPERTY_TYPE, GladeCommandSetPropertyClass)) #define GLADE_IS_COMMAND_SET_PROPERTY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GLADE_COMMAND_SET_PROPERTY_TYPE)) #define GLADE_IS_COMMAND_SET_PROPERTY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GLADE_COMMAND_SET_PROPERTY_TYPE)) /* Undo the last "set property command" */ static gboolean glade_command_set_property_undo (GladeCommand *cmd) { return glade_command_set_property_execute (cmd); } /* * Execute the set property command and revert it. IE, after the execution of * this function cmd will point to the undo action */ static gboolean glade_command_set_property_execute (GladeCommand *cmd) { GladeCommandSetProperty *me = (GladeCommandSetProperty *) cmd; GList *l; gboolean success; gboolean retval = FALSE; g_return_val_if_fail (me != NULL, FALSE); if (me->set_once != FALSE) glade_property_push_superuser (); for (l = me->sdata; l; l = l->next) { GValue new_value = { 0, }; GCSetPropData *sdata = l->data; GladePropertyClass *pclass = glade_property_get_class (sdata->property); GladeWidget *widget = glade_property_get_widget (sdata->property); g_value_init (&new_value, G_VALUE_TYPE (sdata->new_value)); if (me->undo) g_value_copy (sdata->old_value, &new_value); else g_value_copy (sdata->new_value, &new_value); #ifdef GLADE_ENABLE_DEBUG if (glade_get_debug_flags () & GLADE_DEBUG_COMMANDS) { gchar *str = glade_widget_adaptor_string_from_value (glade_property_class_get_adaptor (pclass), pclass, &new_value); g_print ("Setting %s property of %s to %s (sumode: %d)\n", glade_property_class_id (pclass), glade_widget_get_name (widget), str, glade_property_superuser ()); g_free (str); } #endif /* Packing properties need to be refreshed here since * they are reset when they get added to containers. */ if (glade_property_class_get_is_packing (pclass)) { GladeProperty *tmp_prop; tmp_prop = glade_widget_get_pack_property (widget, glade_property_class_id (pclass)); if (sdata->property != tmp_prop) { g_object_unref (sdata->property); sdata->property = g_object_ref (tmp_prop); } } success = glade_property_set_value (sdata->property, &new_value); retval = retval || success; if (!me->set_once && success) { /* If some verify functions didnt pass on * the first go.. we need to record the actual * properties here. XXX should be able to use glade_property_get_value() here */ g_value_copy (glade_property_inline_value (sdata->property), sdata->new_value); } g_value_unset (&new_value); } if (me->set_once != FALSE) glade_property_pop_superuser (); me->set_once = TRUE; me->undo = !me->undo; return retval; } static void glade_command_set_property_finalize (GObject *obj) { GladeCommandSetProperty *me; GList *l; me = GLADE_COMMAND_SET_PROPERTY (obj); for (l = me->sdata; l; l = l->next) { GCSetPropData *sdata = l->data; if (sdata->property) g_object_unref (G_OBJECT (sdata->property)); if (sdata->old_value) { if (G_VALUE_TYPE (sdata->old_value) != 0) g_value_unset (sdata->old_value); g_free (sdata->old_value); } if (G_VALUE_TYPE (sdata->new_value) != 0) g_value_unset (sdata->new_value); g_free (sdata->new_value); } glade_command_finalize (obj); } static gboolean glade_command_set_property_unifies (GladeCommand *this_cmd, GladeCommand *other_cmd) { GladeCommandSetProperty *cmd1, *cmd2; GladePropertyClass *pclass1, *pclass2; GCSetPropData *pdata1, *pdata2; GladeWidget *widget1, *widget2; GList *list, *l; if (!other_cmd) { if (GLADE_IS_COMMAND_SET_PROPERTY (this_cmd)) { cmd1 = (GladeCommandSetProperty *) this_cmd; for (list = cmd1->sdata; list; list = list->next) { pdata1 = list->data; pclass1 = glade_property_get_class (pdata1->property); if (glade_property_class_compare (pclass1, pdata1->old_value, pdata1->new_value)) return FALSE; } return TRUE; } return FALSE; } if (GLADE_IS_COMMAND_SET_PROPERTY (this_cmd) && GLADE_IS_COMMAND_SET_PROPERTY (other_cmd)) { cmd1 = (GladeCommandSetProperty *) this_cmd; cmd2 = (GladeCommandSetProperty *) other_cmd; if (g_list_length (cmd1->sdata) != g_list_length (cmd2->sdata)) return FALSE; for (list = cmd1->sdata; list; list = list->next) { pdata1 = list->data; pclass1 = glade_property_get_class (pdata1->property); widget1 = glade_property_get_widget (pdata1->property); for (l = cmd2->sdata; l; l = l->next) { pdata2 = l->data; pclass2 = glade_property_get_class (pdata2->property); widget2 = glade_property_get_widget (pdata2->property); if (widget1 == widget2 && glade_property_class_match (pclass1, pclass2)) break; } /* If both lists are the same length, and one class type * is not found in the other list, then we cant unify. */ if (l == NULL) return FALSE; } return TRUE; } return FALSE; } static void glade_command_set_property_collapse (GladeCommand *this_cmd, GladeCommand *other_cmd) { GladeCommandSetProperty *cmd1, *cmd2; GCSetPropData *pdata1, *pdata2; GladePropertyClass *pclass1, *pclass2; GList *list, *l; g_return_if_fail (GLADE_IS_COMMAND_SET_PROPERTY (this_cmd) && GLADE_IS_COMMAND_SET_PROPERTY (other_cmd)); cmd1 = (GladeCommandSetProperty *) this_cmd; cmd2 = (GladeCommandSetProperty *) other_cmd; for (list = cmd1->sdata; list; list = list->next) { pdata1 = list->data; pclass1 = glade_property_get_class (pdata1->property); for (l = cmd2->sdata; l; l = l->next) { pdata2 = l->data; pclass2 = glade_property_get_class (pdata2->property); if (glade_property_class_match (pclass1, pclass2)) { /* Merge the GCSetPropData structs manually here */ g_value_copy (pdata2->new_value, pdata1->new_value); break; } } } /* Set the description */ g_free (this_cmd->priv->description); this_cmd->priv->description = other_cmd->priv->description; other_cmd->priv->description = NULL; } #define MAX_UNDO_MENU_ITEM_VALUE_LEN 10 static gchar * glade_command_set_property_description (GladeCommandSetProperty *me) { GCSetPropData *sdata; gchar *description = NULL; gchar *value_name; GladePropertyClass *pclass; GladeWidget *widget; g_assert (me->sdata); if (g_list_length (me->sdata) > 1) description = g_strdup_printf (_("Setting multiple properties")); else { sdata = me->sdata->data; pclass = glade_property_get_class (sdata->property); widget = glade_property_get_widget (sdata->property); value_name = glade_widget_adaptor_string_from_value (glade_property_class_get_adaptor (pclass), pclass, sdata->new_value); if (!value_name || strlen (value_name) > MAX_UNDO_MENU_ITEM_VALUE_LEN || strchr (value_name, '_')) { description = g_strdup_printf (_("Setting %s of %s"), glade_property_class_get_name (pclass), glade_widget_get_name (widget)); } else { description = g_strdup_printf (_("Setting %s of %s to %s"), glade_property_class_get_name (pclass), glade_widget_get_name (widget), value_name); } g_free (value_name); } return description; } /** * glade_command_set_properties_list: * * @props (element-type GladeProperty): List of #GladeProperty */ void glade_command_set_properties_list (GladeProject *project, GList *props) { GladeCommandSetProperty *me; GladeCommand *cmd; GCSetPropData *sdata; GList *list; gboolean success; gboolean multiple; g_return_if_fail (GLADE_IS_PROJECT (project)); g_return_if_fail (props); me = (GladeCommandSetProperty *) g_object_new (GLADE_COMMAND_SET_PROPERTY_TYPE, NULL); cmd = GLADE_COMMAND (me); cmd->priv->project = project; /* Ref all props */ for (list = props; list; list = list->next) { sdata = list->data; g_object_ref (G_OBJECT (sdata->property)); } me->sdata = props; cmd->priv->description = glade_command_set_property_description (me); multiple = g_list_length (me->sdata) > 1; if (multiple) glade_command_push_group ("%s", cmd->priv->description); glade_command_check_group (GLADE_COMMAND (me)); /* Push onto undo stack only if it executes successfully. */ success = glade_command_set_property_execute (cmd); if (success) glade_project_push_undo (cmd->priv->project, cmd); else g_object_unref (G_OBJECT (me)); if (multiple) glade_command_pop_group (); } void glade_command_set_properties (GladeProperty *property, const GValue *old_value, const GValue *new_value, ...) { GCSetPropData *sdata; GladeProperty *prop; GladeWidget *widget; GladeProject *project; GValue *ovalue, *nvalue; GList *list = NULL; va_list vl; g_return_if_fail (GLADE_IS_PROPERTY (property)); /* Add first set */ sdata = g_new (GCSetPropData, 1); sdata->property = property; sdata->old_value = g_new0 (GValue, 1); sdata->new_value = g_new0 (GValue, 1); g_value_init (sdata->old_value, G_VALUE_TYPE (old_value)); g_value_init (sdata->new_value, G_VALUE_TYPE (new_value)); g_value_copy (old_value, sdata->old_value); g_value_copy (new_value, sdata->new_value); list = g_list_prepend (list, sdata); va_start (vl, new_value); while ((prop = va_arg (vl, GladeProperty *)) != NULL) { ovalue = va_arg (vl, GValue *); nvalue = va_arg (vl, GValue *); g_assert (GLADE_IS_PROPERTY (prop)); g_assert (G_IS_VALUE (ovalue)); g_assert (G_IS_VALUE (nvalue)); sdata = g_new (GCSetPropData, 1); sdata->property = g_object_ref (G_OBJECT (prop)); sdata->old_value = g_new0 (GValue, 1); sdata->new_value = g_new0 (GValue, 1); g_value_init (sdata->old_value, G_VALUE_TYPE (ovalue)); g_value_init (sdata->new_value, G_VALUE_TYPE (nvalue)); g_value_copy (ovalue, sdata->old_value); g_value_copy (nvalue, sdata->new_value); list = g_list_prepend (list, sdata); } va_end (vl); widget = glade_property_get_widget (property); project = glade_widget_get_project (widget); glade_command_set_properties_list (project, list); } void glade_command_set_property_value (GladeProperty *property, const GValue *pvalue) { /* Dont generate undo/redo items for unchanging property values. */ if (glade_property_equals_value (property, pvalue)) return; glade_command_set_properties (property, glade_property_inline_value (property), pvalue, NULL); } void glade_command_set_property (GladeProperty * property, ...) { GValue *value; va_list args; g_return_if_fail (GLADE_IS_PROPERTY (property)); va_start (args, property); value = glade_property_class_make_gvalue_from_vl (glade_property_get_class (property), args); va_end (args); glade_command_set_property_value (property, value); } /**************************************************/ /******* GLADE_COMMAND_SET_NAME *******/ /**************************************************/ /* create a new GladeCommandSetName class. Objects of this class will * encapsulate a "set name" operation */ typedef struct { GladeCommand parent; GladeWidget *widget; gchar *old_name; gchar *name; } GladeCommandSetName; /* standard macros */ GLADE_MAKE_COMMAND (GladeCommandSetName, glade_command_set_name); #define GLADE_COMMAND_SET_NAME_TYPE (glade_command_set_name_get_type ()) #define GLADE_COMMAND_SET_NAME(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GLADE_COMMAND_SET_NAME_TYPE, GladeCommandSetName)) #define GLADE_COMMAND_SET_NAME_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GLADE_COMMAND_SET_NAME_TYPE, GladeCommandSetNameClass)) #define GLADE_IS_COMMAND_SET_NAME(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GLADE_COMMAND_SET_NAME_TYPE)) #define GLADE_IS_COMMAND_SET_NAME_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GLADE_COMMAND_SET_NAME_TYPE)) /* Undo the last "set name command" */ static gboolean glade_command_set_name_undo (GladeCommand *cmd) { return glade_command_set_name_execute (cmd); } /* * Execute the set name command and revert it. Ie, after the execution of this * function cmd will point to the undo action */ static gboolean glade_command_set_name_execute (GladeCommand *cmd) { GladeCommandSetName *me = GLADE_COMMAND_SET_NAME (cmd); char *tmp; g_return_val_if_fail (me != NULL, TRUE); g_return_val_if_fail (me->widget != NULL, TRUE); g_return_val_if_fail (me->name != NULL, TRUE); glade_project_set_widget_name (cmd->priv->project, me->widget, me->name); tmp = me->old_name; me->old_name = me->name; me->name = tmp; return TRUE; } static void glade_command_set_name_finalize (GObject *obj) { GladeCommandSetName *me; g_return_if_fail (GLADE_IS_COMMAND_SET_NAME (obj)); me = GLADE_COMMAND_SET_NAME (obj); g_free (me->old_name); g_free (me->name); glade_command_finalize (obj); } static gboolean glade_command_set_name_unifies (GladeCommand *this_cmd, GladeCommand *other_cmd) { GladeCommandSetName *cmd1; GladeCommandSetName *cmd2; if (!other_cmd) { if (GLADE_IS_COMMAND_SET_NAME (this_cmd)) { cmd1 = (GladeCommandSetName *) this_cmd; return (g_strcmp0 (cmd1->old_name, cmd1->name) == 0); } return FALSE; } if (GLADE_IS_COMMAND_SET_NAME (this_cmd) && GLADE_IS_COMMAND_SET_NAME (other_cmd)) { cmd1 = GLADE_COMMAND_SET_NAME (this_cmd); cmd2 = GLADE_COMMAND_SET_NAME (other_cmd); return (cmd1->widget == cmd2->widget); } return FALSE; } static void glade_command_set_name_collapse (GladeCommand *this_cmd, GladeCommand *other_cmd) { GladeCommandSetName *nthis = GLADE_COMMAND_SET_NAME (this_cmd); GladeCommandSetName *nother = GLADE_COMMAND_SET_NAME (other_cmd); g_return_if_fail (GLADE_IS_COMMAND_SET_NAME (this_cmd) && GLADE_IS_COMMAND_SET_NAME (other_cmd)); g_free (nthis->old_name); nthis->old_name = nother->old_name; nother->old_name = NULL; g_free (this_cmd->priv->description); this_cmd->priv->description = g_strdup_printf (_("Renaming %s to %s"), nthis->name, nthis->old_name); } /* this function takes the ownership of name */ void glade_command_set_name (GladeWidget *widget, const gchar *name) { GladeCommandSetName *me; GladeCommand *cmd; g_return_if_fail (GLADE_IS_WIDGET (widget)); g_return_if_fail (name && name[0]); /* Dont spam the queue with false name changes. */ if (!strcmp (glade_widget_get_name (widget), name)) return; me = g_object_new (GLADE_COMMAND_SET_NAME_TYPE, NULL); cmd = GLADE_COMMAND (me); cmd->priv->project = glade_widget_get_project (widget); me->widget = widget; me->name = g_strdup (name); me->old_name = g_strdup (glade_widget_get_name (widget)); cmd->priv->description = g_strdup_printf (_("Renaming %s to %s"), me->old_name, me->name); glade_command_check_group (GLADE_COMMAND (me)); if (glade_command_set_name_execute (GLADE_COMMAND (me))) glade_project_push_undo (cmd->priv->project, cmd); else g_object_unref (G_OBJECT (me)); } /****************************************************************************** * * add/remove * * These canonical commands add/remove a widget list to/from the project. * *****************************************************************************/ typedef struct { GladeCommand parent; GList *widgets; gboolean add; gboolean from_clipboard; } GladeCommandAddRemove; GLADE_MAKE_COMMAND (GladeCommandAddRemove, glade_command_add_remove); #define GLADE_COMMAND_ADD_REMOVE_TYPE (glade_command_add_remove_get_type ()) #define GLADE_COMMAND_ADD_REMOVE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GLADE_COMMAND_ADD_REMOVE_TYPE, GladeCommandAddRemove)) #define GLADE_COMMAND_ADD_REMOVE_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GLADE_COMMAND_ADD_REMOVE_TYPE, GladeCommandAddRemoveClass)) #define GLADE_IS_COMMAND_ADD_REMOVE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GLADE_COMMAND_ADD_REMOVE_TYPE)) #define GLADE_IS_COMMAND_ADD_REMOVE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GLADE_COMMAND_ADD_REMOVE_TYPE)) static void glade_command_placeholder_destroyed (GtkWidget *object, CommandData *cdata) { if (GTK_WIDGET (cdata->placeholder) == object) { cdata->placeholder = NULL; cdata->handler_id = 0; } } static void glade_command_placeholder_connect (CommandData *cdata, GladePlaceholder *placeholder) { g_assert (cdata && cdata->placeholder == NULL); /* Something like a no-op with no placeholder */ if ((cdata->placeholder = placeholder) == NULL) return; cdata->handler_id = g_signal_connect (placeholder, "destroy", G_CALLBACK (glade_command_placeholder_destroyed), cdata); } /** * get_all_parentless_reffed_widgetst: * * @props (element-type GladeWidget) : List of #GladeWidget * @return (element-type GladeWidget) : List of #GladeWidget */ static GList * get_all_parentless_reffed_widgets (GList *reffed, GladeWidget *widget) { GList *children, *l, *list; GladeWidget *child; if ((list = glade_widget_get_parentless_reffed_widgets (widget)) != NULL) reffed = g_list_concat (reffed, list); children = glade_widget_get_children (widget); for (l = children; l; l = l->next) { child = glade_widget_get_from_gobject (l->data); reffed = get_all_parentless_reffed_widgets (reffed, child); } g_list_free (children); return reffed; } /** * glade_command_add: * @widgets (element-type GladeWidget): a #Glist * @parent: a #GladeWidget * @placeholder: a #GladePlaceholder * @pasting: whether we are pasting an existing widget or creating a new one. * * Performs an add command on all widgets in @widgets to @parent, possibly * replacing @placeholder (note toplevels dont need a parent; the active project * will be used when pasting toplevel objects). * Pasted widgets will persist packing properties from thier cut/copy source * while newly added widgets will prefer packing defaults. * */ void glade_command_add (GList *widgets, GladeWidget *parent, GladePlaceholder *placeholder, GladeProject *project, gboolean pasting) { GladeCommandAddRemove *me; GladeCommand *cmd; CommandData *cdata; GladeWidget *widget = NULL; GladeWidgetAdaptor *adaptor; GList *l, *list, *children, *placeholders = NULL; GtkWidget *child; g_return_if_fail (widgets && widgets->data); g_return_if_fail (parent == NULL || GLADE_IS_WIDGET (parent)); me = g_object_new (GLADE_COMMAND_ADD_REMOVE_TYPE, NULL); cmd = GLADE_COMMAND (me); me->add = TRUE; me->from_clipboard = pasting; /* Things can go wrong in this function if the dataset is inacurate, * we make no real attempt here to recover, just g_critical() and * fix the bugs as they pop up. */ widget = GLADE_WIDGET (widgets->data); adaptor = glade_widget_get_adaptor (widget); if (placeholder && GWA_IS_TOPLEVEL (adaptor) == FALSE) cmd->priv->project = glade_placeholder_get_project (placeholder); else cmd->priv->project = project; GLADE_COMMAND (me)->priv->description = g_strdup_printf (_("Add %s"), g_list_length (widgets) == 1 ? glade_widget_get_name (widget) : _("multiple")); for (list = widgets; list && list->data; list = list->next) { widget = list->data; cdata = g_new0 (CommandData, 1); if (glade_widget_get_internal (widget)) g_critical ("Internal widget in Add"); adaptor = glade_widget_get_adaptor (widget); /* Widget */ cdata->widget = g_object_ref (G_OBJECT (widget)); /* Parentless ref */ if ((cdata->reffed = get_all_parentless_reffed_widgets (cdata->reffed, widget)) != NULL) g_list_foreach (cdata->reffed, (GFunc) g_object_ref, NULL); /* Parent */ if (parent == NULL) cdata->parent = glade_widget_get_parent (widget); else if (placeholder && GWA_IS_TOPLEVEL (adaptor) == FALSE) cdata->parent = glade_placeholder_get_parent (placeholder); else cdata->parent = parent; /* Placeholder */ if (placeholder != NULL && g_list_length (widgets) == 1) { glade_command_placeholder_connect (cdata, placeholder); } else if (cdata->parent && glade_widget_placeholder_relation (cdata->parent, widget)) { if ((children = glade_widget_adaptor_get_children (glade_widget_get_adaptor (cdata->parent), glade_widget_get_object (cdata->parent))) != NULL) { for (l = children; l && l->data; l = l->next) { child = l->data; /* Find a placeholder for this child */ if (GLADE_IS_PLACEHOLDER (child) && g_list_find (placeholders, child) == NULL) { placeholders = g_list_append (placeholders, child); glade_command_placeholder_connect (cdata, GLADE_PLACEHOLDER (child)); break; } } g_list_free (children); } } me->widgets = g_list_prepend (me->widgets, cdata); } glade_command_check_group (GLADE_COMMAND (me)); /* * Push it onto the undo stack only on success */ if (glade_command_add_remove_execute (cmd)) glade_project_push_undo (cmd->priv->project, cmd); else g_object_unref (G_OBJECT (me)); if (placeholders) g_list_free (placeholders); } static void glade_command_delete_prop_refs (GladeWidget *widget) { GladeProperty *property; GList *refs, *l; refs = glade_widget_list_prop_refs (widget); for (l = refs; l; l = l->next) { property = l->data; glade_command_set_property (property, NULL); } g_list_free (refs); } static void glade_command_remove (GList *widgets); static void glade_command_remove_locked (GladeWidget *widget, GList *reffed) { GList list = { 0, }, *widgets, *l; GladeWidget *locked; widgets = glade_widget_list_locked_widgets (widget); for (l = widgets; l; l = l->next) { locked = l->data; list.data = locked; if (g_list_find (reffed, locked)) continue; glade_command_unlock_widget (locked); glade_command_remove (&list); } g_list_free (widgets); } /** * glade_command_remove: * @widgets (element-type GladeWidget): a #GList of #GladeWidgets * @return_placeholders: whether or not to return a list of placehodlers * * Performs a remove command on all widgets in @widgets from @parent. */ static void glade_command_remove (GList *widgets) { GladeCommandAddRemove *me; GladeWidget *widget = NULL; GladeWidget *lock; CommandData *cdata; GtkWidget *placeholder; GList *list, *l; g_return_if_fail (widgets != NULL); /* internal children cannot be deleted. Notify the user. */ for (list = widgets; list && list->data; list = list->next) { widget = list->data; lock = glade_widget_get_locker (widget); if (glade_widget_get_internal (widget)) { glade_util_ui_message (glade_app_get_window (), GLADE_UI_WARN, NULL, _ ("You cannot remove a widget internal to a composite widget.")); return; } else if (lock) { glade_util_ui_message (glade_app_get_window (), GLADE_UI_WARN, NULL, _("%s is locked by %s, edit %s first."), glade_widget_get_name (widget), glade_widget_get_name (lock), glade_widget_get_name (lock)); return; } } me = g_object_new (GLADE_COMMAND_ADD_REMOVE_TYPE, NULL); me->add = FALSE; me->from_clipboard = FALSE; GLADE_COMMAND (me)->priv->project = glade_widget_get_project (widget); GLADE_COMMAND (me)->priv->description = g_strdup ("dummy"); if (g_list_length (widgets) == 1) glade_command_push_group (_("Remove %s"), glade_widget_get_name (GLADE_WIDGET (widgets->data))); else glade_command_push_group (_("Remove multiple")); for (list = widgets; list && list->data; list = list->next) { widget = list->data; cdata = g_new0 (CommandData, 1); cdata->widget = g_object_ref (G_OBJECT (widget)); cdata->parent = glade_widget_get_parent (widget); if ((cdata->reffed = get_all_parentless_reffed_widgets (cdata->reffed, widget)) != NULL) g_list_foreach (cdata->reffed, (GFunc) g_object_ref, NULL); /* If we're removing the template widget, then we need to unset it as template */ if (glade_project_get_template (GLADE_COMMAND (me)->priv->project) == widget) glade_command_set_project_template (GLADE_COMMAND (me)->priv->project, NULL); /* Undoably unset any object properties that may point to the removed object */ glade_command_delete_prop_refs (widget); /* Undoably unlock and remove any widgets locked by this widget */ glade_command_remove_locked (widget, cdata->reffed); if (cdata->parent != NULL && glade_widget_placeholder_relation (cdata->parent, cdata->widget)) { placeholder = glade_placeholder_new (); glade_command_placeholder_connect (cdata, GLADE_PLACEHOLDER (placeholder)); } me->widgets = g_list_prepend (me->widgets, cdata); /* Record packing props if not deleted from the clipboard */ if (me->from_clipboard == FALSE) { for (l = glade_widget_get_packing_properties (widget); l; l = l->next) cdata->pack_props = g_list_prepend (cdata->pack_props, glade_property_dup (GLADE_PROPERTY (l->data), cdata->widget)); } } g_assert (widget); glade_command_check_group (GLADE_COMMAND (me)); if (glade_command_add_remove_execute (GLADE_COMMAND (me))) glade_project_push_undo (GLADE_COMMAND (me)->priv->project, GLADE_COMMAND (me)); else g_object_unref (G_OBJECT (me)); glade_command_pop_group (); } /* end of glade_command_remove() */ static void glade_command_transfer_props (GladeWidget *gnew, GList *saved_props) { GList *l; for (l = saved_props; l; l = l->next) { GladeProperty *prop, *sprop = l->data; GladePropertyClass *pclass = glade_property_get_class (sprop); prop = glade_widget_get_pack_property (gnew, glade_property_class_id (pclass)); if (prop && glade_property_class_transfer_on_paste (pclass) && glade_property_class_match (glade_property_get_class (prop), pclass)) glade_property_set_value (prop, glade_property_inline_value (sprop)); } } static gboolean glade_command_add_execute (GladeCommandAddRemove *me) { CommandData *cdata; GList *list, *l, *saved_props; gchar *special_child_type; if (me->widgets) { glade_project_selection_clear (GLADE_COMMAND (me)->priv->project, FALSE); for (list = me->widgets; list && list->data; list = list->next) { cdata = list->data; saved_props = NULL; GLADE_NOTE (COMMANDS, g_print ("Adding widget '%s' to parent '%s' " "(from clipboard: %s, props recorded: %s, have placeholder: %s, child_type: %s)\n", glade_widget_get_name (cdata->widget), cdata->parent ? glade_widget_get_name (cdata->parent) : "(none)", me->from_clipboard ? "yes" : "no", cdata->props_recorded ? "yes" : "no", cdata->placeholder ? "yes" : "no", cdata->special_type)); if (cdata->parent != NULL) { /* Prepare special-child-type for the paste. */ if (me->from_clipboard) { /* Only transfer properties when they are from the clipboard, * otherwise prioritize packing defaults. */ saved_props = glade_widget_dup_properties (cdata->widget, glade_widget_get_packing_properties (cdata->widget), FALSE, FALSE, FALSE); glade_widget_set_packing_properties (cdata->widget, cdata->parent); } /* Clear it the first time around, ensure we record it after adding */ if (cdata->props_recorded == FALSE) g_object_set_data (glade_widget_get_object (cdata->widget), "special-child-type", NULL); else g_object_set_data_full (glade_widget_get_object (cdata->widget), "special-child-type", g_strdup (cdata->special_type), g_free); /* glade_command_paste ganauntees that if * there we are pasting to a placeholder, * there is only one widget. */ if (cdata->placeholder) glade_widget_replace (cdata->parent, G_OBJECT (cdata->placeholder), glade_widget_get_object (cdata->widget)); else glade_widget_add_child (cdata->parent, cdata->widget, cdata->props_recorded == FALSE); glade_command_transfer_props (cdata->widget, saved_props); if (saved_props) { g_list_foreach (saved_props, (GFunc) g_object_unref, NULL); g_list_free (saved_props); } /* Now that we've added, apply any packing props if nescisary. */ for (l = cdata->pack_props; l; l = l->next) { GValue value = { 0, }; GladeProperty *saved_prop = l->data; GladePropertyClass *pclass = glade_property_get_class (saved_prop); GladeProperty *widget_prop = glade_widget_get_pack_property (cdata->widget, glade_property_class_id (pclass)); glade_property_get_value (saved_prop, &value); glade_property_set_value (widget_prop, &value); glade_property_sync (widget_prop); g_value_unset (&value); } if (cdata->props_recorded == FALSE) { /* Save the packing properties after the initial paste. * (this will be the defaults returned by the container * implementation after initially adding them). * * Otherwise this recorded marker was set when cutting */ g_assert (cdata->pack_props == NULL); for (l = glade_widget_get_packing_properties (cdata->widget); l; l = l->next) cdata->pack_props = g_list_prepend (cdata->pack_props, glade_property_dup (GLADE_PROPERTY (l->data), cdata->widget)); /* Record the special-type here after replacing */ if ((special_child_type = g_object_get_data (glade_widget_get_object (cdata->widget), "special-child-type")) != NULL) { g_free (cdata->special_type); cdata->special_type = g_strdup (special_child_type); } GLADE_NOTE (COMMANDS, g_print ("Recorded properties for adding widget '%s' to parent '%s' (special child: %s)\n", glade_widget_get_name (cdata->widget), cdata->parent ? glade_widget_get_name (cdata->parent) : "(none)", cdata->special_type)); /* Mark the properties as recorded */ cdata->props_recorded = TRUE; } } glade_project_add_object (GLADE_COMMAND (me)->priv->project, glade_widget_get_object (cdata->widget)); for (l = cdata->reffed; l; l = l->next) { GladeWidget *reffed = l->data; glade_project_add_object (GLADE_COMMAND (me)->priv->project, glade_widget_get_object (reffed)); } glade_project_selection_add (GLADE_COMMAND (me)->priv->project, glade_widget_get_object (cdata->widget), FALSE); glade_widget_show (cdata->widget); } glade_project_queue_selection_changed (GLADE_COMMAND (me)->priv->project); } return TRUE; } /* end of glade_command_add_execute() */ static gboolean glade_command_remove_execute (GladeCommandAddRemove *me) { CommandData *cdata; GladeWidget *reffed; GList *list, *l; gchar *special_child_type; for (list = me->widgets; list && list->data; list = list->next) { cdata = list->data; GLADE_NOTE (COMMANDS, g_print ("Removing widget '%s' from parent '%s' " "(from clipboard: %s, props recorded: %s, have placeholder: %s, child_type: %s)\n", glade_widget_get_name (cdata->widget), cdata->parent ? glade_widget_get_name (cdata->parent) : "(none)", me->from_clipboard ? "yes" : "no", cdata->props_recorded ? "yes" : "no", cdata->placeholder ? "yes" : "no", cdata->special_type)); glade_widget_hide (cdata->widget); if (cdata->props_recorded == FALSE) { /* Record the special-type here after replacing */ if ((special_child_type = g_object_get_data (glade_widget_get_object (cdata->widget), "special-child-type")) != NULL) { g_free (cdata->special_type); cdata->special_type = g_strdup (special_child_type); } GLADE_NOTE (COMMANDS, g_print ("Recorded properties for removing widget '%s' from parent '%s' (special child: %s)\n", glade_widget_get_name (cdata->widget), cdata->parent ? glade_widget_get_name (cdata->parent) : "(none)", cdata->special_type)); /* Mark the properties as recorded */ cdata->props_recorded = TRUE; } glade_project_remove_object (GLADE_COMMAND (me)->priv->project, glade_widget_get_object (cdata->widget)); for (l = cdata->reffed; l; l = l->next) { reffed = l->data; glade_project_remove_object (GLADE_COMMAND (me)->priv->project, glade_widget_get_object (reffed)); } if (cdata->parent) { if (cdata->placeholder) glade_widget_replace (cdata->parent, glade_widget_get_object (cdata->widget), G_OBJECT (cdata->placeholder)); else glade_widget_remove_child (cdata->parent, cdata->widget); } } return TRUE; } /* * Execute the cmd and revert it. Ie, after the execution of this * function cmd will point to the undo action */ static gboolean glade_command_add_remove_execute (GladeCommand *cmd) { GladeCommandAddRemove *me = (GladeCommandAddRemove *) cmd; gboolean retval; if (me->add) retval = glade_command_add_execute (me); else retval = glade_command_remove_execute (me); me->add = !me->add; return retval; } static gboolean glade_command_add_remove_undo (GladeCommand *cmd) { return glade_command_add_remove_execute (cmd); } static void glade_command_add_remove_finalize (GObject *obj) { GladeCommandAddRemove *cmd; CommandData *cdata; GList *list; g_return_if_fail (GLADE_IS_COMMAND_ADD_REMOVE (obj)); cmd = GLADE_COMMAND_ADD_REMOVE (obj); for (list = cmd->widgets; list && list->data; list = list->next) { cdata = list->data; if (cdata->placeholder) { if (cdata->handler_id) g_signal_handler_disconnect (cdata->placeholder, cdata->handler_id); if (g_object_is_floating (G_OBJECT (cdata->placeholder))) gtk_widget_destroy (GTK_WIDGET (cdata->placeholder)); } if (cdata->widget) g_object_unref (G_OBJECT (cdata->widget)); g_list_foreach (cdata->reffed, (GFunc) g_object_unref, NULL); g_list_free (cdata->reffed); } g_list_free (cmd->widgets); glade_command_finalize (obj); } static gboolean glade_command_add_remove_unifies (GladeCommand *this_cmd, GladeCommand *other_cmd) { return FALSE; } static void glade_command_add_remove_collapse (GladeCommand *this_cmd, GladeCommand *other_cmd) { g_return_if_reached (); } /****************************************************************************** * * The following are command aliases. Their implementations are the actual * glade commands. * *****************************************************************************/ /** * glade_command_create: * @adaptor: A #GladeWidgetAdaptor * @parent (allow-none): the parent #GladeWidget to add the new widget to. * @placeholder (allow-none): the placeholder which will be substituted by the widget * @project: the project his widget belongs to. * * Creates a new widget using @adaptor and put in place of the @placeholder * in the @project * * Returns: the newly created widget. */ GladeWidget * glade_command_create (GladeWidgetAdaptor *adaptor, GladeWidget *parent, GladePlaceholder *placeholder, GladeProject *project) { GladeWidget *widget; GList *widgets = NULL; g_return_val_if_fail (GLADE_IS_WIDGET_ADAPTOR (adaptor), NULL); g_return_val_if_fail (GLADE_IS_PROJECT (project), NULL); /* attempt to create the widget -- widget may be null, e.g. the user clicked cancel on a query */ widget = glade_widget_adaptor_create_widget (adaptor, TRUE, "parent", parent, "project", project, NULL); if (widget == NULL) { return NULL; } if (parent && !glade_widget_add_verify (parent, widget, TRUE)) { g_object_ref_sink (widget); g_object_unref (widget); return NULL; } widgets = g_list_prepend (widgets, widget); glade_command_push_group (_("Create %s"), glade_widget_get_name (widget)); glade_command_add (widgets, parent, placeholder, project, FALSE); glade_command_pop_group (); g_list_free (widgets); /* Make selection change immediately when a widget is created */ glade_project_selection_changed (project); return widget; } /** * glade_command_delete: * @widgets (element-type GladeWidget): a #GList of #GladeWidgets * * Performs a delete command on the list of widgets. */ void glade_command_delete (GList *widgets) { GladeWidget *widget; g_return_if_fail (widgets != NULL); widget = widgets->data; glade_command_push_group (_("Delete %s"), g_list_length (widgets) == 1 ? glade_widget_get_name (widget) : _("multiple")); glade_command_remove (widgets); glade_command_pop_group (); } /** * glade_command_cut: * @widgets (element-type GladeWidget): a #GList of #GladeWidgets * * Removes the list of widgets and adds them to the clipboard. */ void glade_command_cut (GList *widgets) { GladeWidget *widget; GList *l; g_return_if_fail (widgets != NULL); for (l = widgets; l; l = l->next) g_object_set_data (G_OBJECT (l->data), "glade-command-was-cut", GINT_TO_POINTER (TRUE)); widget = widgets->data; glade_command_push_group (_("Cut %s"), g_list_length (widgets) == 1 ? glade_widget_get_name (widget) : _("multiple")); glade_command_remove (widgets); glade_command_pop_group (); glade_clipboard_add (glade_app_get_clipboard (), widgets); } #if 0 static void glade_command_break_references_for_widget (GladeWidget *widget, GList *widgets) { GList *l, *children; for (l = widget->properties; l; l = l->next) { property = l->data; if (glade_property_class_is_object (property->klass) && property->klass->parentless_widget == FALSE) { GList *obj_list; GObject *reffed_obj = NULL; GladeWidget *reffed_widget; if (GLADE_IS_PARAM_SPEC_OBJECTS (klass->pspec)) { glade_property_get (property, &obj_list); } else { glade_property_get (property, &reffed_obj); } } } children = glade_widget_adaptor_get_children (widget->adaptor, widget->object); for (l = children; l; l = l->next) { if ((child = glade_widget_get_from_gobject (l->data)) != NULL) glade_command_break_references_for_widget (child, widgets); } g_list_free (children); } static void glade_command_break_references (GladeProject *project, GList *widgets) { GList *list; GladeWidget *widget; for (list = widgets; list && list->data; list = list->next) { widget = l->data; if (project == widget->project) continue; glade_command_break_references_for_widget (widget, widgets); } } #endif /** * glade_command_paste: * @widgets (element-type GladeWidget): a #GList of #GladeWidget * @parent (allow-none): a #GladeWidget * @placeholder (allow-none): a #GladePlaceholder * * Performs a paste command on all widgets in @widgets to @parent, possibly * replacing @placeholder (note toplevels dont need a parent; the active project * will be used when pasting toplevel objects). */ void glade_command_paste (GList *widgets, GladeWidget *parent, GladePlaceholder *placeholder, GladeProject *project) { GList *list, *copied_widgets = NULL; GladeWidget *copied_widget = NULL; gboolean exact; g_return_if_fail (widgets != NULL); for (list = widgets; list && list->data; list = list->next) { exact = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (list->data), "glade-command-was-cut")); copied_widget = glade_widget_dup (list->data, exact); copied_widgets = g_list_prepend (copied_widgets, copied_widget); } glade_command_push_group (_("Paste %s"), g_list_length (widgets) == 1 ? glade_widget_get_name (copied_widget) : _("multiple")); glade_command_add (copied_widgets, parent, placeholder, project, TRUE); glade_command_pop_group (); if (copied_widgets) g_list_free (copied_widgets); } /** * glade_command_dnd: * @widgets (element-type GladeWidget): a #GList of #GladeWidget * @parent (allow-none): a #GladeWidget * @placeholder (allow-none): a #GladePlaceholder * * Performs a drag-n-drop command, i.e. removes the list of widgets and adds them * to the new parent, possibly replacing @placeholder (note toplevels dont need a * parent; the active project will be used when pasting toplevel objects). */ void glade_command_dnd (GList *widgets, GladeWidget *parent, GladePlaceholder *placeholder) { GladeWidget *widget; GladeProject *project; g_return_if_fail (widgets != NULL); widget = widgets->data; if (parent) project = glade_widget_get_project (parent); else if (placeholder) project = glade_placeholder_get_project (placeholder); else project = glade_widget_get_project (widget); g_return_if_fail (project); glade_command_push_group (_("Drag %s and Drop to %s"), g_list_length (widgets) == 1 ? glade_widget_get_name (widget) : _("multiple"), parent ? glade_widget_get_name (parent) : _("root")); glade_command_remove (widgets); glade_command_add (widgets, parent, placeholder, project, TRUE); glade_command_pop_group (); } /*********************************************************/ /******* GLADE_COMMAND_ADD_SIGNAL *******/ /*********************************************************/ /* create a new GladeCommandAddRemoveChangeSignal class. Objects of this class will * encapsulate an "add or remove signal handler" operation */ typedef enum { GLADE_ADD, GLADE_REMOVE, GLADE_CHANGE } GladeAddType; typedef struct { GladeCommand parent; GladeWidget *widget; GladeSignal *signal; GladeSignal *new_signal; GladeAddType type; } GladeCommandAddSignal; /* standard macros */ GLADE_MAKE_COMMAND (GladeCommandAddSignal, glade_command_add_signal); #define GLADE_COMMAND_ADD_SIGNAL_TYPE (glade_command_add_signal_get_type ()) #define GLADE_COMMAND_ADD_SIGNAL(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GLADE_COMMAND_ADD_SIGNAL_TYPE, GladeCommandAddSignal)) #define GLADE_COMMAND_ADD_SIGNAL_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GLADE_COMMAND_ADD_SIGNAL_TYPE, GladeCommandAddSignalClass)) #define GLADE_IS_COMMAND_ADD_SIGNAL(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GLADE_COMMAND_ADD_SIGNAL_TYPE)) #define GLADE_IS_COMMAND_ADD_SIGNAL_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GLADE_COMMAND_ADD_SIGNAL_TYPE)) static void glade_command_add_signal_finalize (GObject *obj) { GladeCommandAddSignal *cmd = GLADE_COMMAND_ADD_SIGNAL (obj); g_object_unref (cmd->widget); if (cmd->signal) g_object_unref (cmd->signal); if (cmd->new_signal) g_object_unref (cmd->new_signal); glade_command_finalize (obj); } static gboolean glade_command_add_signal_undo (GladeCommand *this_cmd) { return glade_command_add_signal_execute (this_cmd); } static gboolean glade_command_add_signal_execute (GladeCommand *this_cmd) { GladeCommandAddSignal *cmd = GLADE_COMMAND_ADD_SIGNAL (this_cmd); GladeSignal *temp; switch (cmd->type) { case GLADE_ADD: glade_widget_add_signal_handler (cmd->widget, cmd->signal); cmd->type = GLADE_REMOVE; break; case GLADE_REMOVE: glade_widget_remove_signal_handler (cmd->widget, cmd->signal); cmd->type = GLADE_ADD; break; case GLADE_CHANGE: glade_widget_change_signal_handler (cmd->widget, cmd->signal, cmd->new_signal); temp = cmd->signal; cmd->signal = cmd->new_signal; cmd->new_signal = temp; break; default: break; } return TRUE; } static gboolean glade_command_add_signal_unifies (GladeCommand *this_cmd, GladeCommand *other_cmd) { return FALSE; } static void glade_command_add_signal_collapse (GladeCommand *this_cmd, GladeCommand *other_cmd) { g_return_if_reached (); } static void glade_command_add_remove_change_signal (GladeWidget *glade_widget, const GladeSignal *signal, const GladeSignal *new_signal, GladeAddType type) { GladeCommandAddSignal *me = GLADE_COMMAND_ADD_SIGNAL (g_object_new (GLADE_COMMAND_ADD_SIGNAL_TYPE, NULL)); GladeCommand *cmd = GLADE_COMMAND (me); /* we can only add/remove a signal to a widget that has been wrapped by a GladeWidget */ g_assert (glade_widget != NULL); g_assert (glade_widget_get_project (glade_widget) != NULL); me->widget = g_object_ref (glade_widget); me->type = type; me->signal = glade_signal_clone (signal); me->new_signal = new_signal ? glade_signal_clone (new_signal) : NULL; cmd->priv->project = glade_widget_get_project (glade_widget); cmd->priv->description = g_strdup_printf (type == GLADE_ADD ? _("Add signal handler %s") : type == GLADE_REMOVE ? _("Remove signal handler %s") : _("Change signal handler %s"), glade_signal_get_handler ((GladeSignal *)signal)); glade_command_check_group (GLADE_COMMAND (me)); if (glade_command_add_signal_execute (cmd)) glade_project_push_undo (cmd->priv->project, cmd); else g_object_unref (G_OBJECT (me)); } /** * glade_command_add_signal: * @glade_widget: a #GladeWidget * @signal: a #GladeSignal * * TODO: write me */ void glade_command_add_signal (GladeWidget *glade_widget, const GladeSignal *signal) { glade_command_add_remove_change_signal (glade_widget, signal, NULL, GLADE_ADD); } /** * glade_command_remove_signal: * @glade_widget: a #GladeWidget * @signal: a #GladeSignal * * TODO: write me */ void glade_command_remove_signal (GladeWidget *glade_widget, const GladeSignal *signal) { glade_command_add_remove_change_signal (glade_widget, signal, NULL, GLADE_REMOVE); } /** * glade_command_change_signal: * @glade_widget: a #GladeWidget * @old_signal: a #GladeSignal * @new_signal: a #GladeSignal * * TODO: write me */ void glade_command_change_signal (GladeWidget *glade_widget, const GladeSignal *old_signal, const GladeSignal *new_signal) { glade_command_add_remove_change_signal (glade_widget, old_signal, new_signal, GLADE_CHANGE); } /****************************************************************************** * * set i18n metadata * * This command sets the i18n metadata on a label property. * *****************************************************************************/ typedef struct { GladeCommand parent; GladeProperty *property; gboolean translatable; gchar *context; gchar *comment; gboolean old_translatable; gchar *old_context; gchar *old_comment; } GladeCommandSetI18n; GLADE_MAKE_COMMAND (GladeCommandSetI18n, glade_command_set_i18n); #define GLADE_COMMAND_SET_I18N_TYPE (glade_command_set_i18n_get_type ()) #define GLADE_COMMAND_SET_I18N(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GLADE_COMMAND_SET_I18N_TYPE, GladeCommandSetI18n)) #define GLADE_COMMAND_SET_I18N_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GLADE_COMMAND_SET_I18N_TYPE, GladeCommandSetI18nClass)) #define GLADE_IS_COMMAND_SET_I18N(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GLADE_COMMAND_SET_I18N_TYPE)) #define GLADE_IS_COMMAND_SET_I18N_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GLADE_COMMAND_SET_I18N_TYPE)) static gboolean glade_command_set_i18n_execute (GladeCommand *cmd) { GladeCommandSetI18n *me = (GladeCommandSetI18n *) cmd; gboolean temp_translatable; gchar *temp_context; gchar *temp_comment; /* sanity check */ g_return_val_if_fail (me != NULL, TRUE); g_return_val_if_fail (me->property != NULL, TRUE); /* set the new values in the property */ glade_property_i18n_set_translatable (me->property, me->translatable); glade_property_i18n_set_context (me->property, me->context); glade_property_i18n_set_comment (me->property, me->comment); /* swap the current values with the old values to prepare for undo */ temp_translatable = me->translatable; temp_context = me->context; temp_comment = me->comment; me->translatable = me->old_translatable; me->context = me->old_context; me->comment = me->old_comment; me->old_translatable = temp_translatable; me->old_context = temp_context; me->old_comment = temp_comment; return TRUE; } static gboolean glade_command_set_i18n_undo (GladeCommand *cmd) { return glade_command_set_i18n_execute (cmd); } static void glade_command_set_i18n_finalize (GObject *obj) { GladeCommandSetI18n *me; g_return_if_fail (GLADE_IS_COMMAND_SET_I18N (obj)); me = GLADE_COMMAND_SET_I18N (obj); g_free (me->context); g_free (me->comment); g_free (me->old_context); g_free (me->old_comment); glade_command_finalize (obj); } static gboolean glade_command_set_i18n_unifies (GladeCommand *this_cmd, GladeCommand *other_cmd) { GladeCommandSetI18n *cmd1; GladeCommandSetI18n *cmd2; if (GLADE_IS_COMMAND_SET_I18N (this_cmd) && GLADE_IS_COMMAND_SET_I18N (other_cmd)) { cmd1 = GLADE_COMMAND_SET_I18N (this_cmd); cmd2 = GLADE_COMMAND_SET_I18N (other_cmd); return (cmd1->property == cmd2->property); } return FALSE; } static void glade_command_set_i18n_collapse (GladeCommand *this_cmd, GladeCommand *other_cmd) { /* this command is the one that will be used for an undo of the sequence of like commands */ GladeCommandSetI18n *this = GLADE_COMMAND_SET_I18N (this_cmd); /* the other command contains the values that will be used for a redo */ GladeCommandSetI18n *other = GLADE_COMMAND_SET_I18N (other_cmd); g_return_if_fail (GLADE_IS_COMMAND_SET_I18N (this_cmd) && GLADE_IS_COMMAND_SET_I18N (other_cmd)); /* adjust this command to contain, as its old values, the other command's current values */ this->old_translatable = other->old_translatable; g_free (this->old_context); g_free (this->old_comment); this->old_context = other->old_context; this->old_comment = other->old_comment; other->old_context = NULL; other->old_comment = NULL; } /** * glade_command_set_i18n: * @property: a #GladeProperty * @translatable: a #gboolean * @context: a #const gchar * * @comment: a #const gchar * * * Sets the i18n data on the property. */ void glade_command_set_i18n (GladeProperty *property, gboolean translatable, const gchar *context, const gchar *comment) { GladeCommandSetI18n *me; g_return_if_fail (property); /* check that something changed before continuing with the command */ if (translatable == glade_property_i18n_get_translatable (property) && !g_strcmp0 (glade_property_i18n_get_context (property), context) && !g_strcmp0 (glade_property_i18n_get_comment (property), comment)) return; /* load up the command */ me = g_object_new (GLADE_COMMAND_SET_I18N_TYPE, NULL); me->property = property; me->translatable = translatable; me->context = g_strdup (context); me->comment = g_strdup (comment); me->old_translatable = glade_property_i18n_get_translatable (property); me->old_context = g_strdup (glade_property_i18n_get_context (property)); me->old_comment = g_strdup (glade_property_i18n_get_comment (property)); GLADE_COMMAND (me)->priv->project = glade_widget_get_project (glade_property_get_widget (property)); GLADE_COMMAND (me)->priv->description = g_strdup_printf (_("Setting i18n metadata"));; glade_command_check_group (GLADE_COMMAND (me)); /* execute the command and push it on the stack if successful */ if (glade_command_set_i18n_execute (GLADE_COMMAND (me))) glade_project_push_undo (GLADE_COMMAND (me)->priv->project, GLADE_COMMAND (me)); else g_object_unref (G_OBJECT (me)); } /****************************************************************************** * * This command sets protection warnings on widgets * *****************************************************************************/ typedef struct { GladeCommand parent; GladeWidget *widget; GladeWidget *locked; gboolean locking; } GladeCommandLock; GLADE_MAKE_COMMAND (GladeCommandLock, glade_command_lock); #define GLADE_COMMAND_LOCK_TYPE (glade_command_lock_get_type ()) #define GLADE_COMMAND_LOCK(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GLADE_COMMAND_LOCK_TYPE, GladeCommandLock)) #define GLADE_COMMAND_LOCK_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GLADE_COMMAND_LOCK_TYPE, GladeCommandLockClass)) #define GLADE_IS_COMMAND_LOCK(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GLADE_COMMAND_LOCK_TYPE)) #define GLADE_IS_COMMAND_LOCK_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GLADE_COMMAND_LOCK_TYPE)) static gboolean glade_command_lock_execute (GladeCommand *cmd) { GladeCommandLock *me = (GladeCommandLock *) cmd; /* set the new policy */ if (me->locking) glade_widget_lock (me->widget, me->locked); else glade_widget_unlock (me->locked); /* swap the current values with the old values to prepare for undo */ me->locking = !me->locking; return TRUE; } static gboolean glade_command_lock_undo (GladeCommand *cmd) { return glade_command_lock_execute (cmd); } static void glade_command_lock_finalize (GObject *obj) { GladeCommandLock *me = (GladeCommandLock *) obj; g_object_unref (me->widget); g_object_unref (me->locked); glade_command_finalize (obj); } static gboolean glade_command_lock_unifies (GladeCommand *this_cmd, GladeCommand *other_cmd) { /* GladeCommandLock *cmd1; */ /* GladeCommandLock *cmd2; */ /* No point here, this command undoubtedly always runs in groups */ return FALSE; } static void glade_command_lock_collapse (GladeCommand *this_cmd, GladeCommand *other_cmd) { /* this command is the one that will be used for an undo of the sequence of like commands */ //GladeCommandLock *this = GLADE_COMMAND_LOCK (this_cmd); /* the other command contains the values that will be used for a redo */ //GladeCommandLock *other = GLADE_COMMAND_LOCK (other_cmd); g_return_if_fail (GLADE_IS_COMMAND_LOCK (this_cmd) && GLADE_IS_COMMAND_LOCK (other_cmd)); /* no unify/collapse */ } /** * glade_command_lock_widget: * @widget: A #GladeWidget * @locked: The #GladeWidget to lock * * Sets @locked to be in a locked up state * spoken for by @widget, locked widgets cannot * be removed from the project until unlocked. */ void glade_command_lock_widget (GladeWidget *widget, GladeWidget *locked) { GladeCommandLock *me; g_return_if_fail (GLADE_IS_WIDGET (widget)); g_return_if_fail (GLADE_IS_WIDGET (locked)); g_return_if_fail (glade_widget_get_locker (locked) == NULL); /* load up the command */ me = g_object_new (GLADE_COMMAND_LOCK_TYPE, NULL); me->widget = g_object_ref (widget); me->locked = g_object_ref (locked); me->locking = TRUE; GLADE_COMMAND (me)->priv->project = glade_widget_get_project (widget); GLADE_COMMAND (me)->priv->description = g_strdup_printf (_("Locking %s by widget %s"), glade_widget_get_name (locked), glade_widget_get_name (widget)); glade_command_check_group (GLADE_COMMAND (me)); /* execute the command and push it on the stack if successful * this sets the actual policy */ if (glade_command_lock_execute (GLADE_COMMAND (me))) glade_project_push_undo (GLADE_COMMAND (me)->priv->project, GLADE_COMMAND (me)); else g_object_unref (G_OBJECT (me)); } /** * glade_command_unlock_widget: * @widget: A #GladeWidget * * Unlocks @widget so that it can be removed * from the project again * */ void glade_command_unlock_widget (GladeWidget *widget) { GladeCommandLock *me; g_return_if_fail (GLADE_IS_WIDGET (widget)); g_return_if_fail (GLADE_IS_WIDGET (glade_widget_get_locker (widget))); /* load up the command */ me = g_object_new (GLADE_COMMAND_LOCK_TYPE, NULL); me->widget = g_object_ref (glade_widget_get_locker (widget)); me->locked = g_object_ref (widget); me->locking = FALSE; GLADE_COMMAND (me)->priv->project = glade_widget_get_project (widget); GLADE_COMMAND (me)->priv->description = g_strdup_printf (_("Unlocking %s"), glade_widget_get_name (widget)); glade_command_check_group (GLADE_COMMAND (me)); /* execute the command and push it on the stack if successful * this sets the actual policy */ if (glade_command_lock_execute (GLADE_COMMAND (me))) glade_project_push_undo (GLADE_COMMAND (me)->priv->project, GLADE_COMMAND (me)); else g_object_unref (G_OBJECT (me)); } /****************************************************************************** * * This command sets the target version of a GladeProject * *****************************************************************************/ typedef struct { GladeCommand parent; gchar *catalog; gint old_major; gint old_minor; gint new_major; gint new_minor; } GladeCommandTarget; GLADE_MAKE_COMMAND (GladeCommandTarget, glade_command_target); #define GLADE_COMMAND_TARGET_TYPE (glade_command_target_get_type ()) #define GLADE_COMMAND_TARGET(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GLADE_COMMAND_TARGET_TYPE, GladeCommandTarget)) #define GLADE_COMMAND_TARGET_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GLADE_COMMAND_TARGET_TYPE, GladeCommandTargetClass)) #define GLADE_IS_COMMAND_TARGET(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GLADE_COMMAND_TARGET_TYPE)) #define GLADE_IS_COMMAND_TARGET_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GLADE_COMMAND_TARGET_TYPE)) static gboolean glade_command_target_execute (GladeCommand *cmd) { GladeCommandTarget *me = (GladeCommandTarget *) cmd; glade_project_set_target_version (cmd->priv->project, me->catalog, me->new_major, me->new_minor); return TRUE; } static gboolean glade_command_target_undo (GladeCommand *cmd) { GladeCommandTarget *me = (GladeCommandTarget *) cmd; glade_project_set_target_version (cmd->priv->project, me->catalog, me->old_major, me->old_minor); return TRUE; } static void glade_command_target_finalize (GObject *obj) { GladeCommandTarget *me = (GladeCommandTarget *) obj; g_free (me->catalog); glade_command_finalize (obj); } static gboolean glade_command_target_unifies (GladeCommand *this_cmd, GladeCommand *other_cmd) { GladeCommandTarget *me; /* Do we unify with self ? */ if (!other_cmd) { if (GLADE_IS_COMMAND_TARGET (this_cmd)) { me = (GladeCommandTarget *) this_cmd; return (me->old_major == me->new_major && me->old_minor == me->new_minor); } return FALSE; } if (GLADE_IS_COMMAND_TARGET (this_cmd) && GLADE_IS_COMMAND_TARGET (other_cmd)) { GladeCommandTarget *other; me = (GladeCommandTarget *) this_cmd; other = (GladeCommandTarget *) other_cmd; return g_strcmp0 (me->catalog, other->catalog) == 0; } return FALSE; } static void glade_command_target_collapse (GladeCommand *this_cmd, GladeCommand *other_cmd) { GladeCommandTarget *this; GladeCommandTarget *other; g_return_if_fail (GLADE_IS_COMMAND_TARGET (this_cmd) && GLADE_IS_COMMAND_TARGET (other_cmd)); this = GLADE_COMMAND_TARGET (this_cmd); other = GLADE_COMMAND_TARGET (other_cmd); this->new_major = other->new_major; this->new_minor = other->new_minor; g_free (this_cmd->priv->description); this_cmd->priv->description = g_strdup_printf (_("Setting target version of '%s' to %d.%d"), this->catalog, this->new_major, this->new_minor); } /** * glade_command_set_project_target: * @project: A #GladeProject * @catalog: The name of the catalog to set the project's target for * @major: The new major version of @catalog to target * @minor: The new minor version of @catalog to target * * Sets the target of @catalog to @major.@minor in @project. */ void glade_command_set_project_target (GladeProject *project, const gchar *catalog, gint major, gint minor) { GladeCommandTarget *me; gint old_major = 0; gint old_minor = 0; g_return_if_fail (GLADE_IS_PROJECT (project)); g_return_if_fail (catalog && catalog[0]); g_return_if_fail (major >= 0); g_return_if_fail (minor >= 0); /* load up the command */ me = g_object_new (GLADE_COMMAND_TARGET_TYPE, NULL); GLADE_COMMAND (me)->priv->project = project; me->catalog = g_strdup (catalog); glade_project_get_target_version (project, me->catalog, &old_major, &old_minor); me->new_major = major; me->new_minor = minor; me->old_major = old_major; me->old_minor = old_minor; GLADE_COMMAND (me)->priv->description = g_strdup_printf (_("Setting target version of '%s' to %d.%d"), me->catalog, me->new_major, me->new_minor); glade_command_check_group (GLADE_COMMAND (me)); /* execute the command and push it on the stack if successful * this sets the actual policy */ if (glade_command_target_execute (GLADE_COMMAND (me))) glade_project_push_undo (GLADE_COMMAND (me)->priv->project, GLADE_COMMAND (me)); else g_object_unref (G_OBJECT (me)); } /****************************************************************************** * * This command sets can set different properties of a GladeProject * *****************************************************************************/ typedef gchar *(*DescriptionNewFunc) (GladeCommand *); typedef struct { GladeCommand parent; const gchar *property_id; /* Intern string */ DescriptionNewFunc description_new; /* Used to update command description */ GValue old_value; GValue new_value; } GladeCommandProperty; GLADE_MAKE_COMMAND (GladeCommandProperty, glade_command_property); #define GLADE_COMMAND_PROPERTY_TYPE (glade_command_property_get_type ()) #define GLADE_COMMAND_PROPERTY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GLADE_COMMAND_PROPERTY_TYPE, GladeCommandProperty)) #define GLADE_COMMAND_PROPERTY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GLADE_COMMAND_PROPERTY_TYPE, GladeCommandPropertyClass)) #define GLADE_IS_COMMAND_PROPERTY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GLADE_COMMAND_PROPERTY_TYPE)) #define GLADE_IS_COMMAND_PROPERTY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GLADE_COMMAND_PROPERTY_TYPE)) /* Return true if a == b, this could be exported in glade_utils */ static gboolean glade_command_property_compare (GValue *a, GValue *b) { if (G_VALUE_TYPE (a) != G_VALUE_TYPE (b)) { g_warning ("Comparing a %s with a %s type is not supported", G_VALUE_TYPE_NAME (a), G_VALUE_TYPE_NAME (b)); return FALSE; } if (G_VALUE_HOLDS_STRING (a)) return g_strcmp0 (g_value_get_string (a), g_value_get_string (b)) == 0; else if (G_VALUE_HOLDS_OBJECT (a)) return g_value_get_object (a) == g_value_get_object (b); else if (G_VALUE_HOLDS_BOOLEAN (a)) return g_value_get_boolean (a) == g_value_get_boolean (b); else if (G_VALUE_HOLDS_CHAR (a)) return g_value_get_schar (a) == g_value_get_schar (b); else if (G_VALUE_HOLDS_DOUBLE (a)) return g_value_get_double (a) == g_value_get_double (b); else if (G_VALUE_HOLDS_ENUM (a)) return g_value_get_enum (a) == g_value_get_enum (b); else if (G_VALUE_HOLDS_FLAGS (a)) return g_value_get_flags (a) == g_value_get_flags (b); else if (G_VALUE_HOLDS_FLOAT (a)) return g_value_get_float (a) == g_value_get_float (b); else if (G_VALUE_HOLDS_GTYPE (a)) return g_value_get_gtype (a) == g_value_get_gtype (b); else if (G_VALUE_HOLDS_INT (a)) return g_value_get_int (a) == g_value_get_int (b); else if (G_VALUE_HOLDS_INT64 (a)) return g_value_get_int64 (a) == g_value_get_int64 (b); else if (G_VALUE_HOLDS_LONG (a)) return g_value_get_long (a) == g_value_get_long (b); else if (G_VALUE_HOLDS_POINTER (a)) return g_value_get_pointer (a) == g_value_get_pointer (b); else if (G_VALUE_HOLDS_UCHAR (a)) return g_value_get_uchar (a) == g_value_get_uchar (b); else if (G_VALUE_HOLDS_UINT (a)) return g_value_get_uint (a) == g_value_get_uint (b); else if (G_VALUE_HOLDS_UINT64 (a)) return g_value_get_uint64 (a) == g_value_get_uint64 (b); else if (G_VALUE_HOLDS_ULONG (a)) return g_value_get_ulong (a) == g_value_get_ulong (b); g_warning ("%s type not supported", G_VALUE_TYPE_NAME (a)); return FALSE; } static gboolean glade_command_property_execute (GladeCommand *cmd) { GladeCommandProperty *me = (GladeCommandProperty *) cmd; g_object_set_property (G_OBJECT (cmd->priv->project), me->property_id, &me->new_value); return TRUE; } static gboolean glade_command_property_undo (GladeCommand *cmd) { GladeCommandProperty *me = (GladeCommandProperty *) cmd; g_object_set_property (G_OBJECT (cmd->priv->project), me->property_id, &me->old_value); return TRUE; } static void glade_command_property_finalize (GObject *obj) { GladeCommandProperty *me = (GladeCommandProperty *) obj; /* NOTE: we do not free me->property_id because it is an intern string */ g_value_unset (&me->new_value); g_value_unset (&me->old_value); glade_command_finalize (obj); } static gboolean glade_command_property_unifies (GladeCommand *this_cmd, GladeCommand *other_cmd) { /* Do we unify with self ? */ if (!other_cmd) { if (GLADE_IS_COMMAND_PROPERTY (this_cmd)) { GladeCommandProperty *me = (GladeCommandProperty *) this_cmd; return glade_command_property_compare (&me->new_value, &me->old_value); } else return FALSE; } if (GLADE_IS_COMMAND_PROPERTY (this_cmd) && GLADE_IS_COMMAND_PROPERTY (other_cmd)) { GladeCommandProperty *this = (GladeCommandProperty *) this_cmd; GladeCommandProperty *other = (GladeCommandProperty *) other_cmd; /* Intern strings can be compared by comparind the pointers */ return this->property_id == other->property_id; } return FALSE; } static void glade_command_property_update_description (GladeCommand *cmd) { GladeCommandProperty *me = (GladeCommandProperty *) cmd; g_free (cmd->priv->description); if (me->description_new) cmd->priv->description = me->description_new (cmd); else cmd->priv->description = g_strdup_printf (_("Setting project's %s property"), me->property_id); } static void glade_command_property_collapse (GladeCommand *this_cmd, GladeCommand *other_cmd) { GladeCommandProperty *this; GladeCommandProperty *other; g_return_if_fail (GLADE_IS_COMMAND_PROPERTY (this_cmd) && GLADE_IS_COMMAND_PROPERTY (other_cmd)); this = GLADE_COMMAND_PROPERTY (this_cmd); other = GLADE_COMMAND_PROPERTY (other_cmd); g_return_if_fail (this->property_id == other->property_id); g_value_copy (&other->new_value, &this->new_value); glade_command_property_update_description (this_cmd); } /** * glade_command_set_project_property: * @project: A #GladeProject * @description_new: function to create the command description. * @property_id: property this command should use * @new_value: the value to set @property_id * * Sets @new_value as the @property_id property for @project. */ static void glade_command_set_project_property (GladeProject *project, DescriptionNewFunc description_new, const gchar *property_id, GValue *new_value) { GladeCommandProperty *me; GValue old_value = G_VALUE_INIT; g_value_init (&old_value, G_VALUE_TYPE (new_value)); g_object_get_property (G_OBJECT (project), property_id, &old_value); if (glade_command_property_compare (&old_value, new_value)) { g_value_unset (&old_value); return; } me = g_object_new (GLADE_COMMAND_PROPERTY_TYPE, NULL); GLADE_COMMAND (me)->priv->project = project; me->description_new = description_new; me->property_id = g_intern_static_string (property_id); /* move the old value to the comand struct */ me->old_value = old_value; /* set new value */ g_value_init (&me->new_value, G_VALUE_TYPE (new_value)); g_value_copy (new_value, &me->new_value); glade_command_property_update_description (GLADE_COMMAND (me)); glade_command_check_group (GLADE_COMMAND (me)); /* execute the command and push it on the stack if successful * this sets the actual policy */ if (glade_command_property_execute (GLADE_COMMAND (me))) glade_project_push_undo (GLADE_COMMAND (me)->priv->project, GLADE_COMMAND (me)); else g_object_unref (G_OBJECT (me)); } /** * glade_command_set_project_license: * @project: A #GladeProject * @license: License of @project * * Sets the license agreement for @project. It will be saved in the xml as comment. */ void glade_command_set_project_license (GladeProject *project, const gchar *license) { GValue new_value = G_VALUE_INIT; g_return_if_fail (GLADE_IS_PROJECT (project)); g_value_init (&new_value, G_TYPE_STRING); g_value_set_string (&new_value, license); glade_command_set_project_property (project, NULL, "license", &new_value); g_value_unset (&new_value); } static gchar * gcp_resource_path_description_new (GladeCommand *cmd) { GladeCommandProperty *me = (GladeCommandProperty *) cmd; return g_strdup_printf (_("Setting resource path to '%s'"), g_value_get_string (&me->new_value)); } /** * glade_command_set_project_resource_path: * @project: A #GladeProject * @path: path to load resources from. * * Sets a resource path @project. */ void glade_command_set_project_resource_path (GladeProject *project, const gchar *path) { GValue new_value = G_VALUE_INIT; g_return_if_fail (GLADE_IS_PROJECT (project)); g_value_init (&new_value, G_TYPE_STRING); g_value_set_string (&new_value, path); glade_command_set_project_property (project, gcp_resource_path_description_new, "resource-path", &new_value); g_value_unset (&new_value); } static gchar * gcp_domain_description_new (GladeCommand *cmd) { GladeCommandProperty *me = (GladeCommandProperty *) cmd; return g_strdup_printf (_("Setting translation domain to '%s'"), g_value_get_string (&me->new_value)); } /** * glade_command_set_project_domain: * @project: A #GladeProject * @domain: The translation domain for @project * * Sets @domain as the translation domain for @project. */ void glade_command_set_project_domain (GladeProject *project, const gchar *domain) { GValue new_value = G_VALUE_INIT; g_return_if_fail (GLADE_IS_PROJECT (project)); g_value_init (&new_value, G_TYPE_STRING); g_value_set_string (&new_value, domain); glade_command_set_project_property (project, gcp_domain_description_new, "translation-domain", &new_value); g_value_unset (&new_value); } static gchar * gcp_template_description_new (GladeCommand *cmd) { GladeCommandProperty *me = (GladeCommandProperty *) cmd; GObject *new_template = g_value_get_object (&me->new_value); GObject *old_template = g_value_get_object (&me->old_value); if (new_template == NULL && old_template != NULL) return g_strdup_printf (_("Unsetting widget '%s' as template"), glade_widget_get_name (GLADE_WIDGET (old_template))); else if (new_template != NULL) return g_strdup_printf (_("Setting widget '%s' as template"), glade_widget_get_name (GLADE_WIDGET (new_template))); else return g_strdup (_("Unsetting template")); } /** * glade_command_set_project_template: * @project: A #GladeProject * @widget: The #GladeWidget to make template * * Sets @widget to be the template widget in @project. */ void glade_command_set_project_template (GladeProject *project, GladeWidget *widget) { GValue new_value = G_VALUE_INIT; g_return_if_fail (GLADE_IS_PROJECT (project)); g_value_init (&new_value, G_TYPE_OBJECT); g_value_set_object (&new_value, widget); glade_command_set_project_property (project, gcp_template_description_new, "template", &new_value); g_value_unset (&new_value); }