## GladeCommand GladeCommand — An event filter to implement the Undo/Redo stack. |

## Synopsis

    struct              GCSetPropData;
    struct              GladeCommand;
    void                glade_command_push_group            (const gchar *fmt,
                                                             ...);
    void                glade_command_pop_group             (void);
    gboolean            glade_command_execute               (GladeCommand *command);
    gboolean            glade_command_undo                  (GladeCommand *command);
    gboolean            glade_command_unifies               (GladeCommand *command,
                                                             GladeCommand *other);
    void                glade_command_collapse              (GladeCommand *command,
                                                             GladeCommand *other);
    void                glade_command_set_property          (GladeProperty *property,
                                                             ...);
    void                glade_command_set_property_value    (GladeProperty *property,
                                                             const GValue *value);
    void                glade_command_set_properties        (GladeProperty *property,
                                                             const GValue *old_value,
                                                             const GValue *new_value,
                                                             ...);
    void                glade_command_set_properties_list   (GladeProject *project,
                                                             GList *props);
    void                glade_command_set_name              (GladeWidget *glade_widget,
                                                             const gchar *name);
    void                glade_command_delete                (GList *widgets);
    GladeWidget *       glade_command_create                (GladeWidgetAdaptor *adaptor,
                                                             GladeWidget *parent,
                                                             GladePlaceholder *placeholder,
                                                             GladeProject *project);
    void                glade_command_cut                   (GList *widgets);
    void                glade_command_paste                 (GList *widgets,
                                                             GladeWidget *parent,
                                                             GladePlaceholder *placeholder,
                                                             GladeProject *project);
    void                glade_command_dnd                   (GList *widgets,
                                                             GladeWidget *parent,
                                                             GladePlaceholder *placeholder);
    void                glade_command_add_signal            (GladeWidget *glade_widget,
                                                             const GladeSignal *signal);
    void                glade_command_remove_signal         (GladeWidget *glade_widget,
                                                             const GladeSignal *signal);
    void                glade_command_change_signal         (GladeWidget *glade_widget,
                                                             const GladeSignal *old_signal,
                                                             const GladeSignal *new_signal);
    void                glade_command_set_i18n              (GladeProperty *property,
                                                             gboolean translatable,
                                                             const gchar *context,
                                                             const gchar *comment);

## Object Hierarchy

      GObject
       +----GladeCommand

## Description

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.

## Details

### struct GCSetPropData

    struct GCSetPropData {
      GladeProperty *property;
      GValue        *new_value;
      GValue        *old_value;
    };

GladeProperties can be set in a list as one command, for Undo purposes; we store the list of GCSetPropData with their old and new GValue.

GladeProperty *`property`; | A GladeProperty to set
GValue *`new_value`; | The new GValue to assign to `property`
GValue *`old_value`; | The old GValue of `property`

### struct GladeCommand

    struct GladeCommand;

### glade_command_push_group ()

    void                glade_command_push_group            (const gchar *fmt,
                                                             ...);

Marks the begining of a 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.

### glade_command_pop_group ()

    void                glade_command_pop_group             (void);

Mark the end of a command group.

### glade_command_execute ()

    gboolean            glade_command_execute               (GladeCommand *command);

Executes `command`

`command` : | A GladeCommand
Returns : | whether the command was successfully executed

### glade_command_undo ()

    gboolean            glade_command_undo                  (GladeCommand *command);

Undo the effects of `command`

`command` : | A GladeCommand
Returns : | whether the command was successfully reversed

### glade_command_unifies ()

    gboolean            glade_command_unifies               (GladeCommand *command,
                                                             GladeCommand *other);

Checks whether `command` and `other` can be unified to make one single command.

`command` : | A GladeCommand
`other` : | another GladeCommand
Returns : | whether they can be unified.

### glade_command_collapse ()

    void                glade_command_collapse              (GladeCommand *command,
                                                             GladeCommand *other);

Merges `other` into `command`, so that `command` now covers both commands and `other` can be dispensed with.

`command` : | A GladeCommand
`other` : | another GladeCommand

### glade_command_set_property ()

    void                glade_command_set_property          (GladeProperty *property,
                                                             ...);

### glade_command_set_property_value ()

    void                glade_command_set_property_value    (GladeProperty *property,
                                                             const GValue *value);

### glade_command_set_properties ()

    void                glade_command_set_properties        (GladeProperty *property,
                                                             const GValue *old_value,
                                                             const GValue *new_value,
                                                             ...);

### glade_command_set_properties_list ()

    void                glade_command_set_properties_list   (GladeProject *project,
                                                             GList *props);

`props` (element-type GladeProperty): List of GladeProperty

### glade_command_set_name ()

    void                glade_command_set_name              (GladeWidget *glade_widget,
                                                             const gchar *name);

### glade_command_delete ()

    void                glade_command_delete                (GList *widgets);

Performs a delete command on the list of widgets.

### glade_command_create ()

    GladeWidget *       glade_command_create                (GladeWidgetAdaptor *adaptor,
                                                             GladeWidget *parent,
                                                             GladePlaceholder *placeholder,
                                                             GladeProject *project);

Creates a new widget using `adaptor` and put in place of the `placeholder` in the `project`

`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.
Returns : | the newly created widget.

### glade_command_cut ()

    void                glade_command_cut                   (GList *widgets);

Removes the list of widgets and adds them to the clipboard.

### glade_command_paste ()

    void                glade_command_paste                 (GList *widgets,
                                                             GladeWidget *parent,
                                                             GladePlaceholder *placeholder,
                                                             GladeProject *project);

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).

### glade_command_dnd ()

    void                glade_command_dnd                   (GList *widgets,
                                                             GladeWidget *parent,
                                                             GladePlaceholder *placeholder);

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).

### glade_command_add_signal ()

    void                glade_command_add_signal            (GladeWidget *glade_widget,
                                                             const GladeSignal *signal);

TODO: write me

`glade_widget` : | a GladeWidget
`signal` : | a GladeSignal

### glade_command_remove_signal ()

    void                glade_command_remove_signal         (GladeWidget *glade_widget,
                                                             const GladeSignal *signal);

TODO: write me

`glade_widget` : | a GladeWidget
`signal` : | a GladeSignal

### glade_command_change_signal ()

    void                glade_command_change_signal         (GladeWidget *glade_widget,
                                                             const GladeSignal *old_signal,
                                                             const GladeSignal *new_signal);

TODO: write me

`glade_widget` : | a GladeWidget
`old_signal` : | a GladeSignal
`new_signal` : | a GladeSignal

### glade_command_set_i18n ()

    void                glade_command_set_i18n              (GladeProperty *property,
                                                             gboolean translatable,
                                                             const gchar *context,
                                                             const gchar *comment);

Sets the i18n data on the property.

`property` : | a GladeProperty
`translatable` : | a gboolean
`context` : | a const gchar *
`comment` : | a const gchar *