void
glade_gtk_menu_item_action_activate (GladeWidgetAdaptor * adaptor,
GObject * object,
const gchar * action_path)
{
GObject *obj = NULL, *shell = NULL;
GladeWidget *w = glade_widget_get_from_gobject (object);
while ((w = glade_widget_get_parent (w)))
{
obj = glade_widget_get_object (w);
if (GTK_IS_MENU_SHELL (obj))
shell = obj;
}
if (strcmp (action_path, "launch_editor") == 0)
{
if (shell)
object = shell;
if (GTK_IS_MENU_BAR (object))
glade_gtk_menu_shell_launch_editor (object, _("Edit Menu Bar"));
else if (GTK_IS_MENU (object))
glade_gtk_menu_shell_launch_editor (object, _("Edit Menu"));
}
else
GWA_GET_CLASS (GTK_TYPE_CONTAINER)->action_activate (adaptor,
object, action_path);
if (shell)
gtk_menu_shell_deactivate (GTK_MENU_SHELL (shell));
}
static gboolean
glade_gtk_sheet_layout_move_child (GladeBaseEditor *editor,
GladeWidget *gparent,
GladeWidget *gchild,
gpointer data)
{
GObject *parent = glade_widget_get_object (gparent);
GObject *child = glade_widget_get_object (gchild);
GList list = { 0,};
#ifdef GTK_SHEET_DEBUG
g_debug("glade_gtk_sheet_layout_move_child: called");
#endif
if (GTK_IS_SHEET(parent) && !GTK_IS_SHEET_COLUMN (child)) return FALSE;
if (GTK_IS_CELL_LAYOUT(parent) && !GTK_IS_CELL_RENDERER (child)) return FALSE;
if (GTK_IS_CELL_RENDERER(parent)) return FALSE;
if (gparent != glade_widget_get_parent (gchild))
{
list.data = gchild;
glade_command_dnd(&list, gparent, NULL);
}
return TRUE;
}
void
glade_gtk_dialog_write_child (GladeWidgetAdaptor * adaptor,
GladeWidget * widget,
GladeXmlContext * context, GladeXmlNode * node)
{
GladeWidget *parent = glade_widget_get_parent (widget);
GWA_GET_CLASS (GTK_TYPE_CONTAINER)->write_child (adaptor, widget, context, node);
if (parent && GTK_IS_DIALOG (glade_widget_get_object (parent)))
glade_gtk_action_widgets_write_child (parent, context, node, "action_area");
}
static void
glade_popup_menuitem_packing_activated (GtkMenuItem *item,
const gchar *action_path)
{
GladeWidget *widget, *parent;
if ((widget = g_object_get_data (G_OBJECT (item), "gwa-data")))
{
parent = glade_widget_get_parent (widget);
glade_widget_adaptor_child_action_activate (glade_widget_get_adaptor (parent),
glade_widget_get_object (parent),
glade_widget_get_object (widget), action_path);
}
}
static void
on_assistant_project_selection_changed (GladeProject *project,
GladeWidget *gassist)
{
GList *selection = glade_project_selection_get (project);
if (selection && g_list_next (selection) == NULL)
{
GladeWidget *selected = glade_widget_get_from_gobject (selection->data);
GtkAssistant *assist = GTK_ASSISTANT (glade_widget_get_object (gassist));
gint pos;
if (!selected) return;
if (glade_widget_get_parent (selected) == gassist &&
glade_widget_property_get (selected, "position", &pos, NULL))
gtk_assistant_set_current_page (assist, pos);
}
}
static void
widget_parent_changed (GtkWidget * widget,
GParamSpec * pspec, GladeWidgetAdaptor * adaptor)
{
GladeWidget *gwidget = glade_widget_get_from_gobject (widget);
GladeWidget *parent;
/* this could get called for a stale instance of an object
* being rebuilt for a contruct-only property. */
if (!gwidget)
return;
parent = glade_widget_get_parent (gwidget);
if (parent && !glade_widget_get_internal (parent))
glade_widget_set_action_sensitive (gwidget, "remove_parent", TRUE);
else
glade_widget_set_action_sensitive (gwidget, "remove_parent", FALSE);
}
static gboolean
glade_gtk_table_verify_attach_common (GObject * object,
GValue * value,
guint * val,
const gchar * prop,
guint * prop_val,
const gchar * parent_prop,
guint * parent_val)
{
GladeWidget *widget, *parent;
widget = glade_widget_get_from_gobject (object);
g_return_val_if_fail (GLADE_IS_WIDGET (widget), TRUE);
parent = glade_widget_get_parent (widget);
g_return_val_if_fail (GLADE_IS_WIDGET (parent), TRUE);
*val = g_value_get_uint (value);
glade_widget_property_get (widget, prop, prop_val);
glade_widget_property_get (parent, parent_prop, parent_val);
return FALSE;
}
static gboolean
glade_property_verify (GladeProperty * property, const GValue * value)
{
gboolean ret = FALSE;
GladeWidget *parent;
parent = glade_widget_get_parent (property->priv->widget);
if (glade_property_class_get_is_packing (property->priv->klass) && parent)
ret =
glade_widget_adaptor_child_verify_property (glade_widget_get_adaptor (parent),
glade_widget_get_object (parent),
glade_widget_get_object (property->priv->widget),
glade_property_class_id (property->priv->klass),
value);
else if (!glade_property_class_get_is_packing (property->priv->klass))
ret = glade_widget_adaptor_verify_property (glade_widget_get_adaptor (property->priv->widget),
glade_widget_get_object (property->priv->widget),
glade_property_class_id (property->priv->klass), value);
return ret;
}
static gboolean
glade_gtk_grid_verify_attach_common (GObject *object,
GValue *value,
const gchar *prop,
const gchar *parent_prop)
{
GladeWidget *widget, *parent;
guint parent_val;
gint val, prop_val;
widget = glade_widget_get_from_gobject (object);
g_return_val_if_fail (GLADE_IS_WIDGET (widget), TRUE);
parent = glade_widget_get_parent (widget);
g_return_val_if_fail (GLADE_IS_WIDGET (parent), TRUE);
val = g_value_get_int (value);
glade_widget_property_get (widget, prop, &prop_val);
glade_widget_property_get (parent, parent_prop, &parent_val);
if (val < 0 || (val+prop_val) > parent_val)
return FALSE;
return TRUE;
}
static void
glade_editor_table_load (GladeEditable *editable, GladeWidget *widget)
{
GladeEditorTable *table = GLADE_EDITOR_TABLE (editable);
GladeEditorProperty *property;
GList *list;
/* Setup the table the first time the widget is loaded */
if (widget && table->priv->adaptor == NULL)
{
table->priv->adaptor = glade_widget_get_adaptor (widget);
if (table->priv->type == GLADE_PAGE_GENERAL)
append_name_field (table);
append_items (table, table->priv->adaptor, table->priv->type);
}
/* abort mission */
if (table->priv->loaded_widget == widget)
return;
if (table->priv->loaded_widget)
{
g_signal_handlers_disconnect_by_func (G_OBJECT (table->priv->loaded_widget),
G_CALLBACK (widget_name_changed),
table);
g_signal_handlers_disconnect_by_func (G_OBJECT (table->priv->loaded_widget),
G_CALLBACK (widget_composite_changed),
table);
/* The widget could die unexpectedly... */
g_object_weak_unref (G_OBJECT (table->priv->loaded_widget),
(GWeakNotify) widget_finalized, table);
}
table->priv->loaded_widget = widget;
BLOCK_NAME_ENTRY_CB (table);
if (table->priv->loaded_widget)
{
g_signal_connect (G_OBJECT (table->priv->loaded_widget), "notify::name",
G_CALLBACK (widget_name_changed), table);
g_signal_connect (G_OBJECT (table->priv->loaded_widget), "notify::composite",
G_CALLBACK (widget_composite_changed), table);
/* The widget could die unexpectedly... */
g_object_weak_ref (G_OBJECT (table->priv->loaded_widget),
(GWeakNotify) widget_finalized, table);
if (table->priv->composite_check)
{
GObject *object = glade_widget_get_object (table->priv->loaded_widget);
if (GTK_IS_WIDGET (object) &&
glade_widget_get_parent (table->priv->loaded_widget) == NULL)
gtk_widget_show (table->priv->composite_check);
else
gtk_widget_hide (table->priv->composite_check);
}
if (table->priv->name_entry)
gtk_entry_set_text (GTK_ENTRY (table->priv->name_entry),
glade_widget_get_name (widget));
if (table->priv->name_label)
widget_composite_changed (widget, NULL, table);
}
else if (table->priv->name_entry)
gtk_entry_set_text (GTK_ENTRY (table->priv->name_entry), "");
UNBLOCK_NAME_ENTRY_CB (table);
/* Sync up properties, even if widget is NULL */
for (list = table->priv->properties; list; list = list->next)
{
property = list->data;
glade_editor_property_load_by_widget (property, widget);
}
}
static void
glade_property_sync_impl (GladeProperty * property)
{
/* Heh, here are the many reasons not to
* sync a property ;-)
*/
if (/* the class can be NULL during object,
* construction this is just a temporary state */
property->priv->klass == NULL ||
/* optional properties that are disabled */
property->priv->enabled == FALSE ||
/* explicit "never sync" flag */
glade_property_class_get_ignore (property->priv->klass) ||
/* recursion guards */
property->priv->syncing >= property->priv->sync_tolerance ||
/* No widget owns this property yet */
property->priv->widget == NULL)
return;
/* Only the properties from widget->properties should affect the runtime widget.
* (other properties may be used for convenience in the plugin).
*/
if ((glade_property_class_get_is_packing (property->priv->klass) &&
!glade_widget_get_pack_property (property->priv->widget,
glade_property_class_id (property->priv->klass)))
|| !glade_widget_get_property (property->priv->widget,
glade_property_class_id (property->priv->klass)))
return;
property->priv->syncing++;
/* In the case of construct_only, the widget instance must be rebuilt
* to apply the property
*/
if (glade_property_class_get_construct_only (property->priv->klass) &&
property->priv->syncing == 1)
{
/* Virtual properties can be construct only, in which
* case they are allowed to trigger a rebuild, and in
* the process are allowed to get "synced" after the
* instance is rebuilt.
*/
if (glade_property_class_get_virtual (property->priv->klass))
property->priv->sync_tolerance++;
glade_widget_rebuild (property->priv->widget);
if (glade_property_class_get_virtual (property->priv->klass))
property->priv->sync_tolerance--;
}
else if (glade_property_class_get_is_packing (property->priv->klass))
glade_widget_child_set_property (glade_widget_get_parent (property->priv->widget),
property->priv->widget,
glade_property_class_id (property->priv->klass),
property->priv->value);
else
glade_widget_object_set_property (property->priv->widget,
glade_property_class_id (property->priv->klass),
property->priv->value);
property->priv->syncing--;
}
void
glade_gtk_widget_action_activate (GladeWidgetAdaptor * adaptor,
GObject * object, const gchar * action_path)
{
GladeWidget *gwidget = glade_widget_get_from_gobject (object), *gparent;
GList this_widget = { 0, }, that_widget = { 0,};
GladeProject *project;
gparent = glade_widget_get_parent (gwidget);
project = glade_widget_get_project (gwidget);
if (strcmp (action_path, "preview") == 0)
{
glade_project_preview (project,
glade_widget_get_from_gobject ((gpointer) object));
}
else if (strcmp (action_path, "edit_separate") == 0)
{
GtkWidget *dialog = glade_editor_dialog_for_widget (gwidget);
gtk_widget_show_all (dialog);
}
else if (strcmp (action_path, "remove_parent") == 0)
{
GladeWidget *new_gparent;
GladeProperty *property;
g_return_if_fail (gparent);
property = glade_widget_get_parentless_widget_ref (gparent);
new_gparent = glade_widget_get_parent (gparent);
glade_command_push_group (_("Removing parent of %s"), glade_widget_get_name (gwidget));
/* Remove "this" widget, If the parent we're removing is a parentless
* widget reference, the reference will be implicitly broken by the 'cut' command */
this_widget.data = gwidget;
glade_command_delete (&this_widget);
/* Delete the parent */
that_widget.data = gparent;
glade_command_delete (&that_widget);
/* Add "this" widget to the new parent, if there is no new parent this will re-add
* the widget to the project at the toplevel without a parent
*/
glade_command_add (&this_widget, new_gparent, NULL, project, FALSE);
/* If the parent had a parentless widget reference, undoably add the child
* as the new parentless widget reference here */
if (property)
glade_command_set_property (property, glade_widget_get_object (gwidget));
glade_command_pop_group ();
}
else if (strncmp (action_path, "add_parent/", 11) == 0)
{
const gchar *action = action_path + 11;
GType new_type = 0;
if (strcmp (action, "alignment") == 0)
new_type = GTK_TYPE_ALIGNMENT;
else if (strcmp (action, "viewport") == 0)
new_type = GTK_TYPE_VIEWPORT;
else if (strcmp (action, "eventbox") == 0)
new_type = GTK_TYPE_EVENT_BOX;
else if (strcmp (action, "frame") == 0)
new_type = GTK_TYPE_FRAME;
else if (strcmp (action, "aspect_frame") == 0)
new_type = GTK_TYPE_ASPECT_FRAME;
else if (strcmp (action, "scrolled_window") == 0)
new_type = GTK_TYPE_SCROLLED_WINDOW;
else if (strcmp (action, "expander") == 0)
new_type = GTK_TYPE_EXPANDER;
else if (strcmp (action, "grid") == 0)
new_type = GTK_TYPE_GRID;
else if (strcmp (action, "box") == 0)
new_type = GTK_TYPE_BOX;
else if (strcmp (action, "paned") == 0)
new_type = GTK_TYPE_PANED;
else if (strcmp (action, "stack") == 0)
new_type = GTK_TYPE_STACK;
if (new_type)
{
GladeWidgetAdaptor *adaptor =
glade_widget_adaptor_get_by_type (new_type);
GList *saved_props, *prop_cmds;
GladeWidget *gnew_parent;
GladeProperty *property;
glade_command_push_group (_("Adding parent %s for %s"),
glade_widget_adaptor_get_title (adaptor),
glade_widget_get_name (gwidget));
/* Record packing properties */
saved_props =
glade_widget_dup_properties (gwidget, glade_widget_get_packing_properties (gwidget),
FALSE, FALSE, FALSE);
property = glade_widget_get_parentless_widget_ref (gwidget);
/* Remove "this" widget, If the parent we're removing is a parentless
* widget reference, the reference will be implicitly broken by the 'cut' command */
this_widget.data = gwidget;
glade_command_delete (&this_widget);
/* Create new widget and put it where the placeholder was */
if ((gnew_parent =
glade_command_create (adaptor, gparent, NULL, project)) != NULL)
{
/* Now we created the new parent, if gwidget had a parentless widget reference...
* set that reference to the new parent instead */
if (property)
glade_command_set_property (property, glade_widget_get_object (gnew_parent));
/* Remove the alignment that we added in the frame's post_create... */
if (new_type == GTK_TYPE_FRAME)
{
GObject *frame = glade_widget_get_object (gnew_parent);
GladeWidget *galign =
glade_widget_get_from_gobject (gtk_bin_get_child (GTK_BIN (frame)));
GList to_delete = { 0, };
to_delete.data = galign;
glade_command_delete (&to_delete);
}
/* Create heavy-duty glade-command properties stuff */
prop_cmds =
create_command_property_list (gnew_parent, saved_props);
/* Apply the properties in an undoable way */
if (prop_cmds)
glade_command_set_properties_list
(glade_widget_get_project (gparent), prop_cmds);
/* Add "this" widget to the new parent */
glade_command_add (&this_widget, gnew_parent, NULL, project, FALSE);
glade_command_pop_group ();
}
else
{
glade_command_pop_group ();
/* Undo delete command
* FIXME: this will leave the "Adding parent..." comand in the
* redo list, which I think its better than leaving it in the
* undo list by using glade_command_add() to add the widget back
* to the original parent.
* Ideally we need a way to remove a redo item from the project or
* simply do not let the user cancel a widget creation!
*/
glade_project_undo (project);
}
g_list_foreach (saved_props, (GFunc) g_object_unref, NULL);
g_list_free (saved_props);
}
}
else if (strcmp (action_path, "sizegroup_add") == 0)
{
/* Ignore dummy */
}
else if (strcmp (action_path, "clear_properties") == 0)
{
glade_editor_reset_dialog_run (gtk_widget_get_toplevel (GTK_WIDGET (object)), gwidget);
}
else if (strcmp (action_path, "read_documentation") == 0)
{
glade_app_search_docs (glade_widget_adaptor_get_book (adaptor),
glade_widget_adaptor_get_name (adaptor),
NULL);
}
else
GWA_GET_CLASS (G_TYPE_OBJECT)->action_activate (adaptor,
object, action_path);
}
/*
* glade_popup_action_populate_menu:
* @menu: a GtkMenu to put the actions menu items.
* @widget: A #GladeWidget
* @action: a @widget subaction or NULL to include all actions.
* @packing: TRUE to include packing actions
*
* Populate a GtkMenu with widget's actions
*
* Returns the number of action appended to the menu.
*/
gint
glade_popup_action_populate_menu (GtkWidget *menu,
GladeWidget *widget,
GladeWidgetAction *action,
gboolean packing)
{
gint n;
g_return_val_if_fail (GTK_IS_MENU (menu), 0);
g_return_val_if_fail (GLADE_IS_WIDGET (widget), 0);
g_return_val_if_fail (action == NULL || GLADE_IS_WIDGET_ACTION (action), 0);
if (action)
{
GWActionClass *aclass = glade_widget_action_get_class (action);
GList *children = glade_widget_action_get_children (action);
if (glade_widget_get_action (widget, aclass->path) &&
glade_widget_action_get_visible (action))
return glade_popup_action_populate_menu_real (menu,
widget,
children,
G_CALLBACK
(glade_popup_menuitem_activated),
widget);
if (glade_widget_get_pack_action (widget, aclass->path) &&
glade_widget_action_get_visible (action))
return glade_popup_action_populate_menu_real (menu,
glade_widget_get_parent
(widget), children,
G_CALLBACK
(glade_popup_menuitem_packing_activated),
widget);
return 0;
}
n = glade_popup_action_populate_menu_real (menu,
widget,
glade_widget_get_actions (widget),
G_CALLBACK
(glade_popup_menuitem_activated),
widget);
if (packing && glade_widget_get_pack_actions (widget))
{
if (n)
{
GtkWidget *separator = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), separator);
gtk_widget_show (separator);
}
n += glade_popup_action_populate_menu_real
(menu, glade_widget_get_parent (widget),
glade_widget_get_pack_actions (widget),
G_CALLBACK (glade_popup_menuitem_packing_activated), widget);
}
return n;
}
