static void glade_window_editor_load (GladeEditable *editable, GladeWidget *gwidget) { GladeWindowEditor *window_editor = GLADE_WINDOW_EDITOR (editable); GladeWindowEditorPrivate *priv = window_editor->priv; /* Chain up to default implementation */ parent_editable_iface->load (editable, gwidget); if (gwidget) { gboolean icon_name; gboolean use_csd; glade_widget_property_get (gwidget, "glade-window-icon-name", &icon_name); glade_widget_property_get (gwidget, "use-csd", &use_csd); if (icon_name) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->icon_name_radio), TRUE); else gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->icon_file_radio), TRUE); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->use_csd_check), use_csd); } }
static void glade_gtk_fixed_layout_sync_size_requests (GtkWidget *widget) { GList *children, *l; if ((children = gtk_container_get_children (GTK_CONTAINER (widget))) != NULL) { for (l = children; l; l = l->next) { GtkWidget *child = l->data; GladeWidget *gchild = glade_widget_get_from_gobject (child); gint width = -1, height = -1; if (!gchild) continue; glade_widget_property_get (gchild, "width-request", &width); glade_widget_property_get (gchild, "height-request", &height); gtk_widget_set_size_request (child, width, height); } g_list_free (children); } }
static void glade_gtk_grid_set_n_common (GObject *object, const GValue *value, gboolean for_rows) { GladeWidget *widget; GtkGrid *grid; guint new_size, n_columns, n_rows; grid = GTK_GRID (object); widget = glade_widget_get_from_gobject (GTK_WIDGET (grid)); glade_widget_property_get (widget, "n-columns", &n_columns); glade_widget_property_get (widget, "n-rows", &n_rows); new_size = g_value_get_uint (value); if (new_size < 1) return; if (glade_gtk_grid_widget_exceeds_bounds (grid, for_rows ? new_size : n_rows, for_rows ? n_columns : new_size)) /* Refuse to shrink if it means orphaning widgets */ return; /* Fill grid with placeholders */ glade_gtk_grid_refresh_placeholders (grid, FALSE); }
static void glade_gtk_button_update_stock (GladeWidget *widget) { gboolean use_stock; gchar *label = NULL; /* Update the stock property */ glade_widget_property_get (widget, "use-stock", &use_stock); if (use_stock) { glade_widget_property_get (widget, "label", &label); glade_widget_property_set (widget, "stock", label); } }
static void glade_gtk_icon_factory_write_sources (GladeWidget *widget, GladeXmlContext *context, GladeXmlNode *node) { GladeXmlNode *sources_node; GladeIconSources *sources = NULL; SourceWriteTab tab; glade_widget_property_get (widget, "sources", &sources); if (!sources) return; sources_node = glade_xml_node_new (context, GLADE_TAG_SOURCES); tab.context = context; tab.node = sources_node; g_hash_table_foreach (sources->sources, (GHFunc) write_icon_sources, &tab); if (!glade_xml_node_get_children (sources_node)) glade_xml_node_delete (sources_node); else glade_xml_node_append_child (node, sources_node); }
void glade_gtk_box_remove_child (GladeWidgetAdaptor * adaptor, GObject * object, GObject * child) { GladeWidget *gbox; gint size; gchar *special_child_type; g_return_if_fail (GTK_IS_BOX (object)); g_return_if_fail (GTK_IS_WIDGET (child)); gbox = glade_widget_get_from_gobject (object); special_child_type = g_object_get_data (child, "special-child-type"); if (special_child_type && !strcmp (special_child_type, "center")) { GtkWidget *w; w = glade_placeholder_new (); g_object_set_data (G_OBJECT (w), "special-child-type", "center"); gtk_box_set_center_widget (GTK_BOX (object), w); return; } gtk_container_remove (GTK_CONTAINER (object), GTK_WIDGET (child)); if (glade_widget_superuser () == FALSE) { glade_widget_property_get (gbox, "size", &size); glade_widget_property_set (gbox, "size", size); } fix_response_id_on_child (gbox, child, FALSE); }
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_action_bar_remove_child (GladeWidgetAdaptor * adaptor, GObject * object, GObject * child) { GladeWidget *gbox; gint size; gchar *special_child_type; gbox = glade_widget_get_from_gobject (object); special_child_type = g_object_get_data (child, "special-child-type"); if (special_child_type && !strcmp (special_child_type, "center")) { GtkWidget *w; w = glade_placeholder_new (); g_object_set_data (G_OBJECT (w), "special-child-type", "center"); gtk_action_bar_set_center_widget (GTK_ACTION_BAR (object), w); return; } gtk_container_remove (GTK_CONTAINER (object), GTK_WIDGET (child)); if (!glade_widget_superuser ()) { glade_widget_property_get (gbox, "size", &size); glade_widget_property_set (gbox, "size", size); } }
void glade_gtk_widget_read_widget (GladeWidgetAdaptor * adaptor, GladeWidget * widget, GladeXmlNode * node) { const gchar *tooltip_markup = NULL; 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 (G_TYPE_OBJECT)->read_widget (adaptor, widget, node); /* Read in accelerators */ glade_gtk_read_accels (widget, node, TRUE); /* Read in atk props */ glade_gtk_widget_read_atk_props (widget, node); /* Read in the style classes */ glade_gtk_widget_read_style_classes (widget, node); /* Resolve the virtual tooltip use markup property */ glade_widget_property_get (widget, "tooltip-markup", &tooltip_markup); if (tooltip_markup != NULL) glade_widget_property_set (widget, "glade-tooltip-markup", TRUE); }
static void glade_tool_item_group_editor_load (GladeEditable *editable, GladeWidget *widget) { GladeToolItemGroupEditor *group_editor = GLADE_TOOL_ITEM_GROUP_EDITOR (editable); gboolean custom_label = FALSE; GList *l; /* Chain up to default implementation */ parent_editable_iface->load (editable, widget); /* load the embedded editable... */ if (group_editor->embed) glade_editable_load (GLADE_EDITABLE (group_editor->embed), widget); for (l = group_editor->properties; l; l = l->next) glade_editor_property_load_by_widget (GLADE_EDITOR_PROPERTY (l->data), widget); if (widget) { glade_widget_property_get (widget, "custom-label", &custom_label); if (custom_label) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (group_editor->label_widget_radio), TRUE); else gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (group_editor->label_radio), TRUE); } }
static void glade_eprop_model_data_add_row (GladeEditorProperty * eprop) { GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop); GValue value = { 0, }; GNode *node = NULL; GList *columns = NULL; GladeProperty *property = glade_editor_property_get_property (eprop); glade_property_get (property, &node); glade_widget_property_get (glade_property_get_widget (property), "columns", &columns); if (!columns) return; clear_view (eprop); if (!node) node = g_node_new (NULL); else node = glade_model_data_tree_copy (node); append_row (node, columns); eprop_data->adding_row = TRUE; g_value_init (&value, GLADE_TYPE_MODEL_DATA_TREE); g_value_take_boxed (&value, node); glade_editor_property_commit (eprop, &value); g_value_unset (&value); eprop_data->adding_row = FALSE; }
static void glade_gtk_widget_write_style_classes (GladeWidget * widget, GladeXmlContext * context, GladeXmlNode * node) { GladeXmlNode *class_node, *style_node; GList *string_list = NULL, *l; GladeString *string; if (!glade_widget_property_get (widget, "glade-style-classes", &string_list) || !string_list) return; style_node = glade_xml_node_new (context, GLADE_TAG_STYLE); for (l = string_list; l; l = l->next) { string = l->data; class_node = glade_xml_node_new (context, GLADE_TAG_CLASS); glade_xml_node_append_child (style_node, class_node); glade_xml_node_set_property_string (class_node, GLADE_TAG_NAME, string->string); } if (!glade_xml_node_get_children (style_node)) glade_xml_node_delete (style_node); else glade_xml_node_append_child (node, style_node); }
void glade_gtk_header_bar_add_child (GladeWidgetAdaptor *adaptor, GObject *parent, GObject *child) { GladeWidget *gbox, *gchild; gint size; gchar *special_child_type; gchild = glade_widget_get_from_gobject (child); if (gchild) glade_widget_set_pack_action_visible (gchild, "remove_slot", FALSE); special_child_type = g_object_get_data (child, "special-child-type"); d(g_message ("Add %s %p (special: %s)", GLADE_IS_PLACEHOLDER (child) ? "placeholder" : "child", child, special_child_type)); if (special_child_type && !strcmp (special_child_type, "title")) { gtk_header_bar_set_custom_title (GTK_HEADER_BAR (parent), GTK_WIDGET (child)); return; } GWA_GET_CLASS (GTK_TYPE_CONTAINER)->add (adaptor, parent, child); gbox = glade_widget_get_from_gobject (parent); if (!glade_widget_superuser ()) { glade_widget_property_get (gbox, "size", &size); glade_widget_property_set (gbox, "size", size); } }
static void glade_gtk_filter_write_strings (GladeWidget *widget, GladeXmlContext *context, GladeXmlNode *node, FilterType type, const gchar *property_name) { GladeXmlNode *item_node; GList *string_list = NULL, *l; GladeString *string; const gchar *string_tag; switch (type) { case FILTER_PATTERN: string_tag = GLADE_TAG_PATTERN; break; case FILTER_MIME: string_tag = GLADE_TAG_MIME_TYPE; break; case FILTER_APPLICATION: string_tag = GLADE_TAG_APPLICATION; break; default: g_assert_not_reached (); break; } if (!glade_widget_property_get (widget, property_name, &string_list) || !string_list) return; for (l = string_list; l; l = l->next) { string = l->data; item_node = glade_xml_node_new (context, string_tag); glade_xml_node_append_child (node, item_node); glade_xml_set_content (item_node, string->string); } }
static void glade_gtk_size_group_write_widgets (GladeWidget * widget, GladeXmlContext * context, GladeXmlNode * node) { GladeXmlNode *widgets_node, *widget_node; GList *widgets = NULL, *list; GladeWidget *awidget; widgets_node = glade_xml_node_new (context, GLADE_TAG_SIZEGROUP_WIDGETS); if (glade_widget_property_get (widget, "widgets", &widgets)) { for (list = widgets; list; list = list->next) { awidget = glade_widget_get_from_gobject (list->data); widget_node = glade_xml_node_new (context, GLADE_TAG_SIZEGROUP_WIDGET); glade_xml_node_append_child (widgets_node, widget_node); glade_xml_node_set_property_string (widget_node, GLADE_TAG_NAME, glade_widget_get_name (awidget)); } } if (!glade_xml_node_get_children (widgets_node)) glade_xml_node_delete (widgets_node); else glade_xml_node_append_child (node, widgets_node); }
static void glade_gtk_window_write_accel_groups (GladeWidget * widget, GladeXmlContext * context, GladeXmlNode * node) { GladeXmlNode *groups_node, *group_node; GList *groups = NULL, *list; GladeWidget *agroup; groups_node = glade_xml_node_new (context, GLADE_TAG_ACCEL_GROUPS); if (glade_widget_property_get (widget, "accel-groups", &groups)) { for (list = groups; list; list = list->next) { agroup = glade_widget_get_from_gobject (list->data); group_node = glade_xml_node_new (context, GLADE_TAG_ACCEL_GROUP); glade_xml_node_append_child (groups_node, group_node); glade_xml_node_set_property_string (group_node, GLADE_TAG_NAME, glade_widget_get_name (agroup)); } } if (!glade_xml_node_get_children (groups_node)) glade_xml_node_delete (groups_node); else glade_xml_node_append_child (node, groups_node); }
static void glade_gtk_grid_refresh_placeholders (GtkGrid *grid, gboolean load_finished) { GladeWidget *widget; GladeProject *project; GtkContainer *container; GList *list, *children; guint n_columns, n_rows; gint i, j; widget = glade_widget_get_from_gobject (grid); project = glade_widget_get_project (widget); /* Wait for project to finish loading */ if ((project && glade_project_is_loading (project)) && !load_finished) return; glade_widget_property_get (widget, "n-columns", &n_columns); glade_widget_property_get (widget, "n-rows", &n_rows); container = GTK_CONTAINER (grid); children = gtk_container_get_children (container); for (list = children; list && list->data; list = list->next) { GtkWidget *child = list->data; if (GLADE_IS_PLACEHOLDER (child)) gtk_container_remove (container, child); } g_list_free (children); children = gtk_container_get_children (container); for (i = 0; i < n_columns; i++) for (j = 0; j < n_rows; j++) if (glade_gtk_grid_has_child (grid, children, i, j) == FALSE) gtk_grid_attach (grid, glade_placeholder_new (), i, j, 1, 1); if (gtk_widget_get_realized (GTK_WIDGET (grid))) gtk_container_check_resize (container); g_list_free (children); }
static gboolean glade_gtk_grid_verify_n_common (GObject *object, const GValue *value, gboolean for_rows) { GtkGrid *grid = GTK_GRID (object); GladeWidget *widget; guint n_columns, n_rows, new_size = g_value_get_uint (value); widget = glade_widget_get_from_gobject (GTK_WIDGET (grid)); glade_widget_property_get (widget, "n-columns", &n_columns); glade_widget_property_get (widget, "n-rows", &n_rows); if (glade_gtk_grid_widget_exceeds_bounds (grid, for_rows ? new_size : n_rows, for_rows ? n_columns : new_size)) /* Refuse to shrink if it means orphaning widgets */ return FALSE; return TRUE; }
static void glade_gtk_entry_changed (GtkEditable * editable, GladeWidget * gentry) { const gchar *text, *text_prop; GladeProperty *prop; gboolean use_buffer; if (glade_widget_superuser ()) return; text = gtk_entry_get_text (GTK_ENTRY (editable)); glade_widget_property_get (gentry, "text", &text_prop); glade_widget_property_get (gentry, "use-entry-buffer", &use_buffer); if (use_buffer == FALSE && g_strcmp0 (text, text_prop)) { if ((prop = glade_widget_get_property (gentry, "text"))) glade_command_set_property (prop, text); } }
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; }
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 void glade_gtk_tool_button_parse_finished (GladeProject * project, GladeWidget * widget) { gchar *stock_str = NULL, *icon_name = NULL; gint stock_id = 0; GtkWidget *label_widget = NULL, *image_widget = NULL; glade_widget_property_get (widget, "stock-id", &stock_str); glade_widget_property_get (widget, "icon-name", &icon_name); glade_widget_property_get (widget, "icon-widget", &image_widget); glade_widget_property_get (widget, "label-widget", &label_widget); if (label_widget) glade_widget_property_set (widget, "custom-label", TRUE); else glade_widget_property_set (widget, "custom-label", FALSE); if (image_widget) glade_widget_property_set (widget, "image-mode", GLADE_TB_MODE_CUSTOM); else if (icon_name) glade_widget_property_set (widget, "image-mode", GLADE_TB_MODE_ICON); else if (stock_str) { /* Update the stock property */ stock_id = glade_utils_enum_value_from_string (GLADE_TYPE_STOCK_IMAGE, stock_str); if (stock_id < 0) stock_id = 0; glade_widget_property_set (widget, "glade-stock", stock_id); glade_widget_property_set (widget, "image-mode", GLADE_TB_MODE_STOCK); } else glade_widget_property_set (widget, "image-mode", GLADE_TB_MODE_STOCK); }
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); } }
void glade_gtk_image_set_property (GladeWidgetAdaptor *adaptor, GObject *object, const gchar *id, const GValue *value) { if (!strcmp (id, "image-mode")) glade_gtk_image_set_image_mode (object, value); else if (!strcmp (id, "icon-size")) { /* Make the enum an int... */ GValue int_value = { 0, }; g_value_init (&int_value, G_TYPE_INT); g_value_set_int (&int_value, g_value_get_enum (value)); GWA_GET_CLASS (GTK_TYPE_WIDGET)->set_property (adaptor, object, id, &int_value); g_value_unset (&int_value); } else { GladeWidget *widget = glade_widget_get_from_gobject (object); GladeImageEditMode mode = 0; glade_widget_property_get (widget, "image-mode", &mode); /* avoid setting properties in the wrong mode... */ switch (mode) { case GLADE_IMAGE_MODE_STOCK: if (!strcmp (id, "icon-name") || !strcmp (id, "pixbuf")) return; break; case GLADE_IMAGE_MODE_ICON: if (!strcmp (id, "stock") || !strcmp (id, "pixbuf")) return; break; case GLADE_IMAGE_MODE_FILENAME: if (!strcmp (id, "stock") || !strcmp (id, "icon-name")) return; case GLADE_IMAGE_MODE_RESOURCE: /* Screw the resource mode here, we can't apply them at Glade's runtime anyway */ default: break; } GWA_GET_CLASS (GTK_TYPE_WIDGET)->set_property (adaptor, object, id, value); } }
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_gtk_menu_item_set_label (GObject * object, const GValue * value) { GladeWidget *gitem; GtkWidget *label; gboolean use_underline; gitem = glade_widget_get_from_gobject (object); label = gtk_bin_get_child (GTK_BIN (object)); gtk_label_set_text (GTK_LABEL (label), g_value_get_string (value)); /* Update underline incase... */ glade_widget_property_get (gitem, "use-underline", &use_underline); gtk_label_set_use_underline (GTK_LABEL (label), use_underline); }
void glade_gtk_button_set_property (GladeWidgetAdaptor * adaptor, GObject * object, const gchar * id, const GValue * value) { GladeWidget *widget = glade_widget_get_from_gobject (object); GladeProperty *property = glade_widget_get_property (widget, id); if (strcmp (id, "custom-child") == 0) { GtkWidget *child = gtk_bin_get_child (GTK_BIN (object)); gboolean custom_child = g_value_get_boolean (value); /* Avoid removing a child if we already have a custom child */ if (custom_child && (child && glade_widget_get_from_gobject (child))) return; if (custom_child) { if (child) gtk_container_remove (GTK_CONTAINER (object), child); gtk_container_add (GTK_CONTAINER (object), glade_placeholder_new ()); } else if (child && GLADE_IS_PLACEHOLDER (child)) gtk_container_remove (GTK_CONTAINER (object), child); } else if (strcmp (id, "stock") == 0) { gboolean use_stock = FALSE; glade_widget_property_get (widget, "use-stock", &use_stock); if (use_stock) gtk_button_set_label (GTK_BUTTON (object), g_value_get_string (value)); } else if (strcmp (id, "use-stock") == 0) { /* I guess its my bug in GTK+, we need to resync the appearance property * on GtkButton when the GtkButton:use-stock property changes. */ GWA_GET_CLASS (GTK_TYPE_CONTAINER)->set_property (adaptor, object, id, value); glade_gtk_sync_use_appearance (widget); } else if (GPC_VERSION_CHECK (glade_property_get_class (property), gtk_major_version, gtk_minor_version + 1)) GWA_GET_CLASS (GTK_TYPE_CONTAINER)->set_property (adaptor, object, id, value); }
static void glade_notebook_editor_load (GladeEditable * editable, GladeWidget * widget) { GladeNotebookEditor *notebook_editor = GLADE_NOTEBOOK_EDITOR (editable); GladeNotebookEditorPrivate *priv = notebook_editor->priv; gboolean show_tabs = FALSE; /* Chain up to default implementation */ parent_editable_iface->load (editable, widget); if (widget) { glade_widget_property_get (widget, "show-tabs", &show_tabs); gtk_widget_set_visible (priv->tabs_grid, show_tabs); } }
static void glade_action_bar_editor_load (GladeEditable *editable, GladeWidget *gwidget) { GladeActionBarEditor *box_editor = GLADE_ACTION_BAR_EDITOR (editable); GladeActionBarEditorPrivate *priv = box_editor->priv; /* Chain up to default implementation */ parent_editable_iface->load (editable, gwidget); if (gwidget) { gboolean use_center_child; glade_widget_property_get (gwidget, "use-center-child", &use_center_child); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->use_center_child), use_center_child); } }
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); }