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;
}
static void
glade_gtk_widget_add2group_cb (GtkMenuItem * item, GladeWidget * gwidget)
{
GladeWidget *group =
g_object_get_data (G_OBJECT (item), "glade-group-widget");
GladeWidgetAdaptor *adaptor =
glade_widget_adaptor_get_by_type (GTK_TYPE_SIZE_GROUP);
GList *widget_list = NULL, *new_list;
GladeProperty *property;
if (group)
glade_command_push_group (_("Adding %s to Size Group %s"),
glade_widget_get_name (gwidget),
glade_widget_get_name (group));
else
glade_command_push_group (_("Adding %s to a new Size Group"),
glade_widget_get_name (gwidget));
if (!group)
/* Cant cancel a size group */
group =
glade_command_create (adaptor, NULL, NULL,
glade_widget_get_project (gwidget));
property = glade_widget_get_property (group, "widgets");
glade_property_get (property, &widget_list);
new_list = g_list_copy (widget_list);
if (!g_list_find (widget_list, glade_widget_get_object (gwidget)))
new_list = g_list_append (new_list, glade_widget_get_object (gwidget));
glade_command_set_property (property, new_list);
g_list_free (new_list);
glade_command_pop_group ();
}
static void
glade_gtk_widget_add2group_cb (GtkMenuItem * item, GladeWidget * gwidget)
{
GladeWidget *group =
g_object_get_data (G_OBJECT (item), "glade-group-widget");
GladeWidgetAdaptor *adaptor =
glade_widget_adaptor_get_by_type (GTK_TYPE_SIZE_GROUP);
GList *widget_list = NULL, *new_list;
GladeProperty *property;
const gchar *current_name;
const gchar *size_group_name = NULL;
gchar *widget_name;
/* Display "(unnamed)" for unnamed size groups */
if (group)
{
size_group_name = glade_widget_get_name (group);
if (g_str_has_prefix (size_group_name, GLADE_UNNAMED_PREFIX))
size_group_name = _("(unnamed)");
}
/* Ensure the widget has a name if it's going to be referred to by a size group */
current_name = glade_widget_get_name (gwidget);
if (g_str_has_prefix (current_name, GLADE_UNNAMED_PREFIX))
widget_name = glade_project_new_widget_name (glade_widget_get_project (gwidget), NULL,
glade_widget_adaptor_get_generic_name (glade_widget_get_adaptor (gwidget)));
else
widget_name = g_strdup (current_name);
if (group)
glade_command_push_group (_("Adding %s to Size Group %s"),
widget_name,
size_group_name);
else
glade_command_push_group (_("Adding %s to a new Size Group"),
widget_name);
glade_command_set_name (gwidget, widget_name);
if (!group)
/* Cant cancel a size group */
group =
glade_command_create (adaptor, NULL, NULL,
glade_widget_get_project (gwidget));
property = glade_widget_get_property (group, "widgets");
glade_property_get (property, &widget_list);
new_list = g_list_copy (widget_list);
if (!g_list_find (widget_list, glade_widget_get_object (gwidget)))
new_list = g_list_append (new_list, glade_widget_get_object (gwidget));
glade_command_set_property (property, new_list);
g_list_free (new_list);
g_free (widget_name);
glade_command_pop_group ();
}
static void
glade_popup_copy_cb (GtkMenuItem *item, GladeWidget *widget)
{
GladeProject *project = glade_widget_get_project (widget);
/* Assign selection first */
if (!glade_project_is_selected (project, glade_widget_get_object (widget)))
glade_project_selection_set (project, glade_widget_get_object (widget), FALSE);
glade_project_copy_selection (project);
}
static void
glade_popup_cut_cb (GtkMenuItem *item, GladeWidget *widget)
{
GladeProject *project = glade_widget_get_project (widget);
/* Assign selection first only if its not already assigned (it may be a delete
* of multiple widgets) */
if (!glade_project_is_selected (project, glade_widget_get_object (widget)))
glade_project_selection_set (project, glade_widget_get_object (widget), FALSE);
glade_project_command_cut (project);
}
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);
}
}
void
glade_gtk_button_read_widget (GladeWidgetAdaptor * adaptor,
GladeWidget * widget, GladeXmlNode * node)
{
GObject *object;
if (!(glade_xml_node_verify_silent (node, GLADE_XML_TAG_WIDGET) ||
glade_xml_node_verify_silent (node, GLADE_XML_TAG_TEMPLATE)))
return;
/* First chain up and read in all the normal properties.. */
GWA_GET_CLASS (GTK_TYPE_CONTAINER)->read_widget (adaptor, widget, node);
glade_gtk_button_update_stock (widget);
/* Fold "font-name" property into the "font" propery */
object = glade_widget_get_object (widget);
if (GTK_IS_FONT_BUTTON (object))
{
gchar *font_prop_value = NULL;
glade_widget_property_get (widget, "font-name", &font_prop_value);
if (font_prop_value != NULL)
{
glade_widget_property_set (widget, "font", font_prop_value);
glade_widget_property_set (widget, "font-name", NULL);
}
}
}
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 void
glade_gtk_sheet_layout_child_selected (GladeBaseEditor *editor,
GladeWidget *gchild,
gpointer data)
{
GObject *child = glade_widget_get_object (gchild);
#ifdef GTK_SHEET_DEBUG
g_debug("glade_gtk_sheet_layout_child_selected: called");
#endif
glade_base_editor_add_label (editor, GTK_IS_SHEET_COLUMN (child) ?
_("GtkSheet Column") : _("Unknown"));
glade_base_editor_add_default_properties (editor, gchild);
glade_base_editor_add_label (editor, GTK_IS_SHEET_COLUMN (child) ?
_("Properties") : _("Properties and Attributes"));
glade_base_editor_add_editable (editor, gchild, GLADE_PAGE_GENERAL);
if (GTK_IS_CELL_RENDERER (child))
{
glade_base_editor_add_label (editor, _("Common Properties and Attributes"));
glade_base_editor_add_editable (editor, gchild, GLADE_PAGE_COMMON);
}
}
static void
glade_tree_view_editor_load (GladeEditable * editable, GladeWidget * widget)
{
GladeTreeViewEditor *view_editor = GLADE_TREE_VIEW_EDITOR (editable);
GladeWidget *model_widget;
/* Chain up to default implementation */
parent_editable_iface->load (editable, widget);
/* load the embedded editable... */
if (view_editor->embed)
glade_editable_load (GLADE_EDITABLE (view_editor->embed), widget);
if (view_editor->embed_list_store && view_editor->embed_tree_store)
{
gtk_widget_hide (view_editor->no_model_message);
gtk_widget_hide (view_editor->embed_list_store);
gtk_widget_hide (view_editor->embed_tree_store);
glade_editable_load (GLADE_EDITABLE (view_editor->embed_list_store),
NULL);
glade_editable_load (GLADE_EDITABLE (view_editor->embed_tree_store),
NULL);
/* Finalize safe code here... */
if (widget && (model_widget = get_model_widget (widget)))
{
if (GTK_IS_LIST_STORE (glade_widget_get_object (model_widget)))
{
gtk_widget_show (view_editor->embed_list_store);
glade_editable_load (GLADE_EDITABLE
(view_editor->embed_list_store),
model_widget);
}
else if (GTK_IS_TREE_STORE (glade_widget_get_object (model_widget)))
{
gtk_widget_show (view_editor->embed_tree_store);
glade_editable_load (GLADE_EDITABLE
(view_editor->embed_tree_store),
model_widget);
}
else
gtk_widget_show (view_editor->no_model_message);
}
else
gtk_widget_show (view_editor->no_model_message);
}
}
static void
glade_gtk_box_parse_finished (GladeProject * project, GObject *gbox)
{
GObject *box = glade_widget_get_object (gbox);
glade_widget_property_set (gbox, "use-center-child",
gtk_box_get_center_widget (GTK_BOX (box)) != NULL);
}
gboolean
glade_gtk_size_group_depends (GladeWidgetAdaptor * adaptor,
GladeWidget * widget, GladeWidget * another)
{
if (GTK_IS_WIDGET (glade_widget_get_object (another)))
return TRUE;
return GWA_GET_CLASS (G_TYPE_OBJECT)->depends (adaptor, widget, another);
}
gboolean
glade_gtk_treeview_depends (GladeWidgetAdaptor * adaptor,
GladeWidget * widget, GladeWidget * another)
{
if (GTK_IS_TREE_MODEL (glade_widget_get_object (another)))
return TRUE;
return GWA_GET_CLASS (GTK_TYPE_CONTAINER)->depends (adaptor, widget, another);
}
static void
glade_popup_menuitem_activated (GtkMenuItem *item, const gchar *action_path)
{
GladeWidget *widget;
if ((widget = g_object_get_data (G_OBJECT (item), "gwa-data")))
glade_widget_adaptor_action_activate (glade_widget_get_adaptor (widget),
glade_widget_get_object (widget), action_path);
}
static void
use_center_child_toggled (GtkWidget * widget,
GladeActionBarEditor * box_editor)
{
GladeActionBarEditorPrivate *priv = box_editor->priv;
GladeWidget *gwidget = glade_editable_loaded_widget (GLADE_EDITABLE (box_editor));
GladeWidget *gcenter = NULL;
GtkWidget *box;
GtkWidget *center;
GladeProperty *property;
gboolean use_center_child;
if (glade_editable_loading (GLADE_EDITABLE (box_editor)) || !gwidget)
return;
/* Get new desired property state */
use_center_child = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->use_center_child));
/* Get any existing center child */
box = (GtkWidget *)glade_widget_get_object (gwidget);
center = gtk_action_bar_get_center_widget (GTK_ACTION_BAR (box));
if (center && !GLADE_IS_PLACEHOLDER (center))
gcenter = glade_widget_get_from_gobject (center);
glade_editable_block (GLADE_EDITABLE (box_editor));
if (use_center_child)
glade_command_push_group (_("Setting %s to use a center child"),
glade_widget_get_name (gwidget));
else
glade_command_push_group (_("Setting %s to not use a center child"),
glade_widget_get_name (gwidget));
/* If a project widget exists when were disabling center child, it needs
* to be removed first as a part of the issuing GladeCommand group
*/
if (gcenter)
{
GList list;
list.prev = list.next = NULL;
list.data = gcenter;
glade_command_delete (&list);
}
property = glade_widget_get_property (gwidget, "use-center-child");
glade_command_set_property (property, use_center_child);
glade_command_pop_group ();
glade_editable_unblock (GLADE_EDITABLE (box_editor));
/* reload buttons and sensitivity and stuff... */
glade_editable_load (GLADE_EDITABLE (box_editor), gwidget);
}
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");
}
void
glade_gtk_button_write_widget (GladeWidgetAdaptor * adaptor,
GladeWidget * widget,
GladeXmlContext * context, GladeXmlNode * node)
{
GladeProperty *prop;
gboolean use_stock;
gchar *stock = NULL;
if (!(glade_xml_node_verify_silent (node, GLADE_XML_TAG_WIDGET) ||
glade_xml_node_verify_silent (node, GLADE_XML_TAG_TEMPLATE)))
return;
/* Do not save GtkColorButton GtkFontButton and GtkScaleButton label property */
if (!(GTK_IS_COLOR_BUTTON (glade_widget_get_object (widget)) ||
GTK_IS_FONT_BUTTON (glade_widget_get_object (widget)) ||
GTK_IS_SCALE_BUTTON (glade_widget_get_object (widget))))
{
/* Make a copy of the GladeProperty,
* override its value and ensure non-translatable if use-stock is TRUE
*/
prop = glade_widget_get_property (widget, "label");
prop = glade_property_dup (prop, widget);
glade_widget_property_get (widget, "use-stock", &use_stock);
if (use_stock)
{
glade_widget_property_get (widget, "stock", &stock);
glade_property_i18n_set_translatable (prop, FALSE);
glade_property_set (prop, stock);
}
glade_property_write (prop, context, node);
g_object_unref (G_OBJECT (prop));
}
/* Write out other normal properties and any other class derived custom properties after ... */
GWA_GET_CLASS (GTK_TYPE_CONTAINER)->write_widget (adaptor, widget, context,
node);
}
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 gint
glade_popup_action_populate_menu_real (GtkWidget *menu,
GladeWidget *gwidget,
GList *actions,
GCallback callback,
gpointer data)
{
GtkWidget *item;
GList *list;
gint n = 0;
for (list = actions; list; list = g_list_next (list))
{
GladeWidgetAction *action = list->data;
GWActionClass *aclass = glade_widget_action_get_class (action);
GList *children = glade_widget_action_get_children (action);
GtkWidget *submenu = NULL;
if (!glade_widget_action_get_visible (action))
continue;
if (children)
{
submenu = gtk_menu_new ();
n += glade_popup_action_populate_menu_real (submenu,
gwidget,
children,
callback, data);
}
else
submenu = glade_widget_adaptor_action_submenu (glade_widget_get_adaptor (gwidget),
glade_widget_get_object (gwidget),
aclass->path);
item = glade_popup_append_item (menu, aclass->label, TRUE,
(children) ? NULL : callback,
(children) ? NULL : aclass->path);
g_object_set_data (G_OBJECT (item), "gwa-data", data);
gtk_widget_set_sensitive (item, glade_widget_action_get_sensitive (action));
if (submenu)
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
n++;
}
return n;
}
static GList *
list_sizegroups (GladeWidget * gwidget)
{
GladeProject *project = glade_widget_get_project (gwidget);
GList *groups = NULL;
const GList *list;
for (list = glade_project_get_objects (project); list; list = list->next)
{
GladeWidget *iter = glade_widget_get_from_gobject (list->data);
if (GTK_IS_SIZE_GROUP (glade_widget_get_object (iter)))
groups = g_list_prepend (groups, iter);
}
return g_list_reverse (groups);
}
static gchar *
glade_gtk_sheet_layout_get_display_name (GladeBaseEditor *editor,
GladeWidget *gchild,
gpointer user_data)
{
GObject *child = glade_widget_get_object (gchild);
gchar *name;
if (GTK_IS_TREE_VIEW_COLUMN (child))
glade_widget_property_get (gchild, "title", &name);
else
name = gchild->name;
#ifdef GTK_SHEET_DEBUG
g_debug("glade_gtk_sheet_layout_get_display_name: called <%s>", name ? name : "NULL");
#endif
return g_strdup (name);
}
static GladeWidget *
get_model_widget (GladeWidget * view)
{
GtkTreeModel *model = NULL;
GObject *object = glade_widget_get_object (view);
if (GTK_IS_TREE_VIEW (object))
model = gtk_tree_view_get_model (GTK_TREE_VIEW (object));
else if (GTK_IS_ICON_VIEW (object))
model = gtk_icon_view_get_model (GTK_ICON_VIEW (object));
else if (GTK_IS_COMBO_BOX (object))
model = gtk_combo_box_get_model (GTK_COMBO_BOX (object));
if (model)
return glade_widget_get_from_gobject (model);
return NULL;
}
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
test_create_widget (gconstpointer data)
{
GladeWidgetAdaptor *adaptor = (GladeWidgetAdaptor *)data;
GladeWidget *widget;
GObject *object;
gboolean widget_finalized = FALSE;
gboolean object_finalized = FALSE;
g_test_log_set_fatal_handler (ignore_gvfs_warning, NULL);
widget = glade_widget_adaptor_create_widget (adaptor, FALSE, NULL);
g_assert (GLADE_IS_WIDGET (widget));
object = glade_widget_get_object (widget);
g_assert (G_IS_OBJECT (object));
g_object_weak_ref (G_OBJECT (widget), check_finalized, &widget_finalized);
g_object_weak_ref (G_OBJECT (object), check_finalized, &object_finalized);
/* filechoosers hold a reference until an async operation is complete */
if (GTK_IS_FILE_CHOOSER (object))
{
g_timeout_add (2000, main_loop_quit_cb, NULL);
gtk_main();
}
/* Our plugin code adds an idle when cell renderers are created */
else if (GTK_IS_CELL_RENDERER (object))
{
g_timeout_add (50, main_loop_quit_cb, NULL);
gtk_main();
}
/* Get rid of the GladeWidget and assert that it finalizes along
* with it's internal object
*/
g_object_unref (widget);
g_assert (widget_finalized);
g_assert (object_finalized);
}
static void
glade_recent_chooser_editor_load (GladeEditable *editable,
GladeWidget *gwidget)
{
GladeRecentChooserEditor *recent_editor = GLADE_RECENT_CHOOSER_EDITOR (editable);
GladeRecentChooserEditorPrivate *priv = recent_editor->priv;
/* Chain up to default implementation */
parent_editable_iface->load (editable, gwidget);
if (gwidget)
{
GObject *object = glade_widget_get_object (gwidget);
gboolean has_show_numbers = (GTK_IS_RECENT_ACTION (object) || GTK_IS_RECENT_CHOOSER_MENU (object));
/* Update subclass specific editor visibility */
gtk_widget_set_visible (priv->select_multiple_editor, !has_show_numbers);
gtk_widget_set_visible (priv->show_numbers_editor, has_show_numbers);
}
}
static void
on_widget_project_notify (GObject *gobject,
GParamSpec *pspec,
GladeProject *old_project)
{
GladeWidget *gwidget = GLADE_WIDGET (gobject);
GladeProject *project = glade_widget_get_project (gwidget);
GObject *object = glade_widget_get_object (gwidget);
if (old_project)
g_signal_handlers_disconnect_by_func (old_project, on_project_selection_changed, object);
g_signal_handlers_disconnect_by_func (gwidget, on_widget_project_notify, old_project);
g_signal_connect_object (gwidget, "notify::project",
G_CALLBACK (on_widget_project_notify),
project, 0);
if (project)
g_signal_connect_object (project, "selection-changed",
G_CALLBACK (on_project_selection_changed),
object, 0);
}
static void
glade_widget_editor_load (GladeEditable * editable, GladeWidget * gwidget)
{
GladeWidgetEditor *widget_editor = GLADE_WIDGET_EDITOR (editable);
GladeWidgetEditorPrivate *priv = widget_editor->priv;
/* Chain up to default implementation */
parent_editable_iface->load (editable, gwidget);
if (gwidget)
{
GtkWidget *widget = (GtkWidget *)glade_widget_get_object (gwidget);
gboolean is_container = GTK_IS_CONTAINER (widget);
gboolean tooltip_markup = FALSE;
gboolean custom_tooltip = FALSE;
glade_widget_property_get (gwidget, "glade-tooltip-markup", &tooltip_markup);
glade_widget_property_get (gwidget, "has-tooltip", &custom_tooltip);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->tooltip_markup_check), tooltip_markup);
gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->tooltip_label_notebook),
tooltip_markup ? TOOLTIP_MARKUP_PAGE : TOOLTIP_TEXT_PAGE);
gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->tooltip_editor_notebook),
tooltip_markup ? TOOLTIP_MARKUP_PAGE : TOOLTIP_TEXT_PAGE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->custom_tooltip_check), custom_tooltip);
gtk_widget_set_sensitive (priv->tooltip_markup_check, !custom_tooltip);
gtk_widget_set_sensitive (priv->tooltip_label_notebook, !custom_tooltip);
gtk_widget_set_sensitive (priv->tooltip_editor_notebook, !custom_tooltip);
/* Set visibility of GtkContainer only properties */
gtk_widget_set_visible (priv->resize_mode_label, is_container);
gtk_widget_set_visible (priv->resize_mode_editor, is_container);
gtk_widget_set_visible (priv->border_width_label, is_container);
gtk_widget_set_visible (priv->border_width_editor, is_container);
}
}
static void
glade_popup_paste_cb (GtkMenuItem *item, gpointer data)
{
GladeWidget *widget = NULL;
GladeProject *project;
if (GLADE_IS_WIDGET (data))
{
widget = GLADE_WIDGET (data);
project = glade_widget_get_project (widget);
}
else if (GLADE_IS_PROJECT (data))
project = GLADE_PROJECT (data);
else
g_return_if_reached ();
/* The selected widget is the paste destination */
if (widget)
glade_project_selection_set (project, glade_widget_get_object (widget), FALSE);
else
glade_project_selection_clear (project, FALSE);
glade_project_command_paste (project, NULL);
}
static void
glade_gtk_text_tag_table_launch_editor (GObject *table)
{
GladeWidget *widget = glade_widget_get_from_gobject (table);
GladeWidgetAdaptor *adaptor = glade_widget_get_adaptor (widget);
GladeBaseEditor *editor;
GladeEditable *action_editor;
GtkWidget *window;
action_editor = glade_widget_adaptor_create_editable (adaptor, GLADE_PAGE_GENERAL);
/* Editor */
editor = glade_base_editor_new (glade_widget_get_object (widget), action_editor,
_("Tag"), GTK_TYPE_TEXT_TAG,
NULL);
g_signal_connect (editor, "child-selected", G_CALLBACK (glade_gtk_text_tag_table_child_selected), NULL);
g_signal_connect (editor, "move-child", G_CALLBACK (glade_gtk_text_tag_table_move_child), NULL);
gtk_widget_show (GTK_WIDGET (editor));
window = glade_base_editor_pack_new_window (editor, _("Text Tag Table Editor"), NULL);
gtk_widget_show (window);
}
static void
glade_property_load_impl (GladeProperty * property)
{
GObject *object;
GObjectClass *oclass;
GParamSpec *pspec;
pspec = glade_property_class_get_pspec (property->priv->klass);
if (property->priv->widget == NULL ||
glade_property_class_get_virtual (property->priv->klass) ||
glade_property_class_get_is_packing (property->priv->klass) ||
glade_property_class_get_ignore (property->priv->klass) ||
!(pspec->flags & G_PARAM_READABLE) || G_IS_PARAM_SPEC_OBJECT (pspec))
return;
object = glade_widget_get_object (property->priv->widget);
oclass = G_OBJECT_GET_CLASS (object);
if (g_object_class_find_property (oclass, glade_property_class_id (property->priv->klass)))
glade_widget_object_get_property (property->priv->widget,
glade_property_class_id (property->priv->klass),
property->priv->value);
}
