static void psppire_dialog_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { PsppireDialog *dialog = PSPPIRE_DIALOG (object); switch (prop_id) { case PROP_ORIENTATION: { if ( GTK_IS_VBOX (dialog->box) || GTK_VPANED (dialog->box)) g_value_set_enum (value, PSPPIRE_VERTICAL); else if ( GTK_IS_HBOX (dialog->box) || GTK_HPANED (dialog->box)) g_value_set_enum (value, PSPPIRE_HORIZONTAL); else if ( GTK_IS_TABLE (dialog->box)) g_value_set_enum (value, PSPPIRE_TABULAR); } break; case PROP_SLIDING: g_value_set_boolean (value, dialog->slidable); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; }; }
/* This tries to find the pixmap and label in the message box. */ static void get_message_box_widgets (GtkWidget *dialog, GtkWidget **pixmap, GtkWidget **label) { GtkWidget *vbox, *hbox; GtkBoxChild *child; GList *elem; *pixmap = NULL; *label = NULL; vbox = GNOME_DIALOG (dialog)->vbox; if (!vbox || !GTK_IS_VBOX (vbox)) return; elem = GTK_BOX (vbox)->children; child = (GtkBoxChild*)elem->data; if (!child || !GTK_IS_HBOX (child->widget)) return; hbox = child->widget; elem = GTK_BOX (hbox)->children; while (elem) { child = (GtkBoxChild*)elem->data; if (GTK_IS_LABEL (child->widget)) *label = child->widget; if (GNOME_IS_PIXMAP (child->widget)) *pixmap = child->widget; elem = elem->next; } }
static void set_label(GtkWidget *dialog, const char *str) { GList *list; GtkWidget *hbox = NULL; list = gtk_container_children(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox)); while (list != NULL) { GtkWidget *w = (GtkWidget *) list->data; list = g_list_next(list); if (GTK_IS_HBOX(w)) { hbox = w; break; } } if (hbox == NULL) return; list = gtk_container_children(GTK_CONTAINER(hbox)); while (list != NULL) { GtkWidget *w = (GtkWidget *) list->data; list = g_list_next(list); if (GTK_IS_LABEL(w)) { gtk_label_set_text(GTK_LABEL(w), str); return; } } }
void fixup_labels( GObject *gobject, GParamSpec *arg1, gpointer user_data ) { /* TODO: handle 'use-markup' getting changed also */ if ( arg1 && arg1->name && (strcmp("label", arg1->name) == 0) ) { GSList* proxies = gtk_action_get_proxies( GTK_ACTION(gobject) ); gchar* str = 0; g_object_get( gobject, "label", &str, NULL ); (void)user_data; while ( proxies ) { if ( GTK_IS_TOOL_ITEM(proxies->data) ) { /* Search for the things we built up in create_tool_item() */ GList* children = gtk_container_get_children( GTK_CONTAINER(proxies->data) ); if ( children && children->data ) { if ( GTK_IS_HBOX(children->data) ) { children = gtk_container_get_children( GTK_CONTAINER(children->data) ); if ( children && g_list_next(children) ) { GtkWidget* child = GTK_WIDGET( g_list_next(children)->data ); if ( GTK_IS_LABEL(child) ) { GtkLabel* lbl = GTK_LABEL(child); if ( EGE_OUTPUT_ACTION(gobject)->private_data->useMarkup ) { gtk_label_set_markup( lbl, str ); } else { gtk_label_set_text( lbl, str ); } } } } } } proxies = g_slist_next( proxies ); } g_free( str ); } }
void RenderThemeGtk::refreshComboBoxChildren() const { gtkComboBox(); // Ensure that we've initialized the combo box. // Some themes look at widget ancestry to determine how to render widgets, so // get the GtkButton that is the actual child of the combo box. gtk_container_forall(GTK_CONTAINER(m_gtkComboBox), getGtkComboBoxButton, &m_gtkComboBoxButton); ASSERT(m_gtkComboBoxButton); setupWidget(m_gtkComboBoxButton); g_object_add_weak_pointer(G_OBJECT(m_gtkComboBoxButton), reinterpret_cast<gpointer*>(&m_gtkComboBoxButton)); ComboBoxWidgetPieces pieces = { 0, 0 }; GtkWidget* buttonChild = gtk_bin_get_child(GTK_BIN(gtkComboBoxButton())); if (GTK_IS_HBOX(buttonChild)) gtk_container_forall(GTK_CONTAINER(buttonChild), getGtkComboBoxPieces, &pieces); else if (GTK_IS_ARROW(buttonChild)) pieces.arrow = buttonChild; ASSERT(pieces.arrow); m_gtkComboBoxArrow = pieces.arrow; setupWidget(m_gtkComboBoxArrow); // When the style changes, the combo box may destroy its children. g_object_add_weak_pointer(G_OBJECT(m_gtkComboBoxArrow), reinterpret_cast<gpointer*>(&m_gtkComboBoxArrow)); m_gtkComboBoxSeparator = pieces.separator; if (m_gtkComboBoxSeparator) { setupWidget(m_gtkComboBoxSeparator); // When the style changes, the combo box may destroy its children. g_object_add_weak_pointer(G_OBJECT(m_gtkComboBoxSeparator), reinterpret_cast<gpointer*>(&m_gtkComboBoxSeparator)); } }
/* From contacts src/contacts-utils.c */ static GList * contacts_set_widget_desensitive_recurse (GtkWidget *widget, GList **widgets) { if (GTK_IS_WIDGET (widget)) { if (GTK_WIDGET_SENSITIVE (widget) && GTK_WIDGET_VISIBLE (widget)) { gtk_widget_set_sensitive (widget, FALSE); *widgets = g_list_append (*widgets, widget); } if (GTK_IS_TABLE (widget) || GTK_IS_HBOX (widget) || GTK_IS_VBOX (widget) || GTK_IS_EVENT_BOX (widget)) { GList *c, *children = gtk_container_get_children ( GTK_CONTAINER (widget)); for (c = children; c; c = c->next) { contacts_set_widget_desensitive_recurse ( c->data, widgets); } g_list_free (children); } } return *widgets; }
void wxFrame::SetToolBar(wxToolBar *toolbar) { m_frameToolBar = toolbar; if (toolbar) { if (toolbar->IsVertical()) { // Vertical toolbar and m_wxwindow go into an hbox, inside the // vbox (m_mainWidget). hbox is created on demand. GtkWidget* hbox = gtk_widget_get_parent(m_wxwindow); if (!GTK_IS_HBOX(hbox)) { hbox = gtk_hbox_new(false, 0); gtk_widget_show(hbox); gtk_container_add(GTK_CONTAINER(m_mainWidget), hbox); gtk_widget_reparent(m_wxwindow, hbox); } gtk_widget_reparent(toolbar->m_widget, hbox); gtk_box_set_child_packing(GTK_BOX(hbox), toolbar->m_widget, false, false, 0, GTK_PACK_START); int pos = 0; // left if (toolbar->HasFlag(wxTB_RIGHT)) pos = 1; // right gtk_box_reorder_child(GTK_BOX(hbox), toolbar->m_widget, pos); } else { // Horizontal toolbar goes into vbox (m_mainWidget) gtk_widget_reparent(toolbar->m_widget, m_mainWidget); gtk_box_set_child_packing(GTK_BOX(m_mainWidget), toolbar->m_widget, false, false, 0, GTK_PACK_START); int pos = 0; // top if (m_frameMenuBar) pos = 1; // below menubar if (toolbar->HasFlag(wxTB_BOTTOM)) pos += 2; // below client area (m_wxwindow) gtk_box_reorder_child( GTK_BOX(m_mainWidget), toolbar->m_widget, pos); } // disconnect wxWindowGTK "size_request" handler, // it interferes with sizing of detached GtkHandleBox gulong handler_id = g_signal_handler_find( toolbar->m_widget, GSignalMatchType(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA), g_signal_lookup("size_request", GTK_TYPE_WIDGET), 0, NULL, NULL, toolbar); if (handler_id != 0) g_signal_handler_disconnect(toolbar->m_widget, handler_id); // reset size request to allow native sizing to work gtk_widget_set_size_request(toolbar->m_widget, -1, -1); } // make sure next size_allocate causes a wxSizeEvent m_oldClientWidth = 0; }
cpufreq_applet_size_request (GtkWidget *widget, GtkRequisition *requisition) #endif { CPUFreqApplet *applet; gint labels_width = 0; gint width; applet = CPUFREQ_APPLET (widget); #if !GTK_CHECK_VERSION (3, 0, 0) GTK_WIDGET_CLASS (cpufreq_applet_parent_class)->size_request (widget, requisition); #endif if (applet->orient == MATE_PANEL_APPLET_ORIENT_LEFT || applet->orient == MATE_PANEL_APPLET_ORIENT_RIGHT) return; if (applet->show_freq) { labels_width += cpufreq_applet_get_max_label_width (applet) + 2; } if (applet->show_perc) { labels_width += cpufreq_applet_get_max_perc_width (applet); } if (applet->show_unit) { labels_width += cpufreq_applet_get_max_unit_width (applet); } if (applet->show_icon) { #if GTK_CHECK_VERSION (3, 0, 0) gint icon_width; gtk_widget_get_preferred_width (applet->icon, &icon_width, NULL); width = gtk_orientable_get_orientation (GTK_ORIENTABLE (applet->box)) == GTK_ORIENTATION_HORIZONTAL ? labels_width + icon_width + 2 : MAX (labels_width, icon_width + 2); #else GtkRequisition req; gtk_widget_size_request (applet->icon, &req); width = GTK_IS_HBOX (applet->box) ? labels_width + req.width + 2 : MAX (labels_width, req.width + 2); #endif } else { width = labels_width; } #if GTK_CHECK_VERSION (3, 0, 0) *minimum_width = *natural_width = width; #else requisition->width = width; #endif }
static void do_align_left_widgets (GtkWidget *first_level_child, GtkSizeGroup *size_group) { if (GTK_IS_HBOX (first_level_child) || GTK_IS_HBUTTON_BOX (first_level_child)) { GtkSizeGroup *size_group_copy = size_group; gtk_container_foreach (GTK_CONTAINER (first_level_child), (GtkCallback) do_align_left_widget, &size_group_copy); } else if (GTK_IS_CONTAINER (first_level_child)) { gtk_container_foreach (GTK_CONTAINER (first_level_child), (GtkCallback) do_align_left_widgets, size_group); } }
void wxFrame::SetToolBar(wxToolBar *toolbar) { m_frameToolBar = toolbar; if (toolbar) { if (toolbar->IsVertical()) { // Vertical toolbar and m_wxwindow go into an hbox, inside the // vbox (m_mainWidget). hbox is created on demand. GtkWidget* hbox = gtk_widget_get_parent(m_wxwindow); if (!GTK_IS_HBOX(hbox)) { hbox = gtk_hbox_new(false, 0); gtk_widget_show(hbox); gtk_container_add(GTK_CONTAINER(m_mainWidget), hbox); gtk_widget_reparent(m_wxwindow, hbox); } gtk_widget_reparent(toolbar->m_widget, hbox); gtk_box_set_child_packing(GTK_BOX(hbox), toolbar->m_widget, false, false, 0, GTK_PACK_START); int pos = 0; // left if (toolbar->HasFlag(wxTB_RIGHT)) pos = 1; // right gtk_box_reorder_child(GTK_BOX(hbox), toolbar->m_widget, pos); } else { // Horizontal toolbar goes into vbox (m_mainWidget) gtk_widget_reparent(toolbar->m_widget, m_mainWidget); gtk_box_set_child_packing(GTK_BOX(m_mainWidget), toolbar->m_widget, false, false, 0, GTK_PACK_START); int pos = 0; // top if (m_frameMenuBar) pos = 1; // below menubar if (toolbar->HasFlag(wxTB_BOTTOM)) pos += 2; // below client area (m_wxwindow) gtk_box_reorder_child( GTK_BOX(m_mainWidget), toolbar->m_widget, pos); } // reset size request to allow native sizing to work gtk_widget_set_size_request(toolbar->m_widget, -1, -1); } // make sure next size_allocate causes a wxSizeEvent m_oldClientWidth = 0; }
/* this is pretty ugly, as the compose struct does not maintain a pointer to the account selection combo */ static PyObject* ComposeWindow_get_account_selection(clawsmail_ComposeWindowObject *self, PyObject *args) { GList *children, *walk; children = gtk_container_get_children(GTK_CONTAINER(self->compose->header_table)); for(walk = children; walk; walk = walk->next) { if(GTK_IS_HBOX(walk->data)) { GList *children2, *walk2; children2 = gtk_container_get_children(GTK_CONTAINER(walk->data)); for(walk2 = children2; walk2; walk2 = walk2->next) { if(GTK_IS_EVENT_BOX(walk2->data)) { return get_gobj_from_address(gtk_container_get_children(GTK_CONTAINER(walk2->data))->data); } } } } Py_INCREF(Py_None); return Py_None; }
static gboolean process_tab( GtkWidget* widget, int direction ) { gboolean handled = FALSE; GtkWidget* parent = gtk_widget_get_parent(widget); GtkWidget* gp = parent ? gtk_widget_get_parent(parent) : 0; GtkWidget* ggp = gp ? gtk_widget_get_parent(gp) : 0; if ( ggp && GTK_IS_TOOLBAR(ggp) ) { GList* kids = gtk_container_get_children( GTK_CONTAINER(ggp) ); if ( kids ) { GtkWidget* curr = widget; while ( curr && (gtk_widget_get_parent(curr) != ggp) ) { curr = gtk_widget_get_parent( curr ); } if ( curr ) { GList* mid = g_list_find( kids, curr ); while ( mid ) { mid = ( direction < 0 ) ? g_list_previous(mid) : g_list_next(mid); if ( mid && GTK_IS_TOOL_ITEM(mid->data) ) { /* potential target */ GtkWidget* child = gtk_bin_get_child( GTK_BIN(mid->data) ); if ( child && GTK_IS_HBOX(child) ) { /* could be ours */ GList* subChildren = gtk_container_get_children( GTK_CONTAINER(child) ); if ( subChildren ) { GList* last = g_list_last(subChildren); if ( last && GTK_IS_SPIN_BUTTON(last->data) && GTK_WIDGET_IS_SENSITIVE( GTK_WIDGET(last->data) ) ) { gtk_widget_grab_focus( GTK_WIDGET(last->data) ); handled = TRUE; mid = 0; /* to stop loop */ } g_list_free(subChildren); } } } } } g_list_free( kids ); } } return handled; }
static void rejilla_file_chooser_find_pane (GtkWidget *child, gpointer footer) { if (GTK_IS_PANED (child)) { GList *children_vbox; GList *iter_vbox; GtkWidget *vbox; vbox = gtk_paned_get_child2 (GTK_PANED (child)); children_vbox = gtk_container_get_children (GTK_CONTAINER (vbox)); for (iter_vbox = children_vbox; iter_vbox; iter_vbox = iter_vbox->next) { if (GTK_IS_HBOX (iter_vbox->data)) { GtkPackType packing; gtk_box_query_child_packing (GTK_BOX (vbox), GTK_WIDGET (iter_vbox->data), NULL, NULL, NULL, &packing); if (packing == GTK_PACK_START) { GtkRequisition total_request, footer_request; gtk_widget_size_request (GTK_WIDGET (vbox), &total_request); gtk_widget_size_request (GTK_WIDGET (iter_vbox->data), &footer_request); *((gint *) footer) = total_request.height - footer_request.height; break; } } } g_list_free (children_vbox); } else if (GTK_IS_CONTAINER (child)) { gtk_container_foreach (GTK_CONTAINER (child), rejilla_file_chooser_find_pane, footer); } }
static void he_check_button_style_set (GtkWidget *widget, GtkStyle *previous_style) { guint horizontal_spacing, vertical_spacing, image_spacing; HeCheckButtonPrivate *priv = HE_CHECK_BUTTON_GET_PRIVATE (widget); if (GTK_WIDGET_CLASS (he_check_button_parent_class)->style_set) GTK_WIDGET_CLASS (he_check_button_parent_class)->style_set (widget, previous_style); /* Prevent infinite recursion when calling set_logical_font() and * set_logical_color() */ if (priv->setting_style) return; /* Get horizontal-spacing style property from ourself */ gtk_widget_style_get (widget, "horizontal-spacing", &horizontal_spacing, NULL); /* Get vertical-spacing style property of HildonButton from theme */ GtkStyle *style = gtk_rc_get_style_by_paths (gtk_widget_get_settings (widget), "*.*Button-finger", NULL, HILDON_TYPE_BUTTON); vertical_spacing = get_style_property_long (style, HILDON_TYPE_BUTTON, "vertical-spacing"); /* Get image-spacing style property of HildonCheckButton from theme */ style = gtk_rc_get_style_by_paths (gtk_widget_get_settings (widget), NULL, "*.HildonCheckButton", HILDON_TYPE_CHECK_BUTTON); image_spacing = get_style_property_long (style, GTK_TYPE_BUTTON, "image-spacing"); /* Setting values we got from above */ if (GTK_IS_HBOX (priv->label_box)) { gtk_box_set_spacing (GTK_BOX (priv->label_box), horizontal_spacing); } else { gtk_box_set_spacing (GTK_BOX (priv->label_box), vertical_spacing); } if (GTK_IS_BOX (priv->hbox)) { gtk_box_set_spacing (priv->hbox, image_spacing); } set_logical_font (widget); set_logical_color (widget); }
static void cpufreq_applet_size_request (GtkWidget *widget, GtkRequisition *requisition) { CPUFreqApplet *applet; gint labels_width = 0; gint width; applet = CPUFREQ_APPLET (widget); GTK_WIDGET_CLASS (cpufreq_applet_parent_class)->size_request (widget, requisition); if (applet->orient == MATE_PANEL_APPLET_ORIENT_LEFT || applet->orient == MATE_PANEL_APPLET_ORIENT_RIGHT) return; if (applet->show_freq) { labels_width += cpufreq_applet_get_max_label_width (applet) + 2; } if (applet->show_perc) { labels_width += cpufreq_applet_get_max_perc_width (applet); } if (applet->show_unit) { labels_width += cpufreq_applet_get_max_unit_width (applet); } if (applet->show_icon) { GtkRequisition req; gtk_widget_size_request (applet->icon, &req); width = GTK_IS_HBOX (applet->box) ? labels_width + req.width + 2 : MAX (labels_width, req.width + 2); } else { width = labels_width; } requisition->width = width; }
GtkWidget * add_separator (GtkWidget * box, gint fill, gint pad) { GtkWidget *sep; if (GTK_IS_HBOX (box)) { sep = gtk_vseparator_new (); gtk_box_pack_start (GTK_BOX (box), sep, fill, TRUE, pad); } else if (GTK_IS_VBOX (box)) { sep = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (box), sep, fill, TRUE, pad); } else { return NULL; } gtk_widget_show (sep); return sep; }
/** Connect one dialog widget to the appropriate callback function for * its type. * * @internal * * @param name The name of the widget. * * @param widget A pointer to the widget. * * @param dialog A pointer to the dialog. */ static void gnc_prefs_connect_one (const gchar *name, GtkWidget *widget, gpointer user_data) { /* These tests must be ordered from more specific widget to less * specific widget. */ if (GTK_IS_FONT_BUTTON(widget)) { DEBUG(" %s - entry", name); gnc_prefs_connect_font_button(GTK_FONT_BUTTON(widget)); } else if (GTK_IS_RADIO_BUTTON(widget)) { DEBUG(" %s - radio button", name); gnc_prefs_connect_radio_button(GTK_RADIO_BUTTON(widget)); } else if (GTK_IS_CHECK_BUTTON(widget)) { DEBUG(" %s - check button", name); gnc_prefs_connect_check_button(GTK_CHECK_BUTTON(widget)); } else if (GTK_IS_SPIN_BUTTON(widget)) { DEBUG(" %s - spin button", name); gnc_prefs_connect_spin_button(GTK_SPIN_BUTTON(widget)); } else if (GTK_IS_COMBO_BOX(widget)) { DEBUG(" %s - combo box", name); gnc_prefs_connect_combo_box(GTK_COMBO_BOX(widget)); } else if (GTK_IS_ENTRY(widget)) { DEBUG(" %s - entry", name); gnc_prefs_connect_entry(GTK_ENTRY(widget)); } else if (GTK_IS_HBOX(widget)) { /* Test custom widgets are all children of a hbox */ GtkWidget *widget_child; GList* child = gtk_container_get_children(GTK_CONTAINER(widget)); widget_child = child->data; g_list_free(child); DEBUG(" %s - hbox", name); DEBUG("Hbox widget type is %s and name is %s", gtk_widget_get_name(GTK_WIDGET(widget_child)), name); if (GNC_IS_CURRENCY_EDIT(widget_child)) { DEBUG(" %s - currency_edit", name); gnc_prefs_connect_currency_edit(GNC_CURRENCY_EDIT(widget_child), name ); } else if (GNC_IS_PERIOD_SELECT(widget_child)) { DEBUG(" %s - period_Select", name); gnc_prefs_connect_period_select(GNC_PERIOD_SELECT(widget_child), name ); } else if (GNC_IS_DATE_EDIT(widget_child)) { DEBUG(" %s - date_edit", name); gnc_prefs_connect_date_edit(GNC_DATE_EDIT(widget_child), name ); } } else { DEBUG(" %s - unsupported %s", name, G_OBJECT_TYPE_NAME(G_OBJECT(widget))); } }
AtkRelationSet* gail_label_ref_relation_set (AtkObject *obj) { GtkWidget *widget; AtkRelationSet *relation_set; g_return_val_if_fail (GAIL_IS_LABEL (obj), NULL); widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj)); if (widget == NULL) /* * State is defunct */ return NULL; relation_set = ATK_OBJECT_CLASS (gail_label_parent_class)->ref_relation_set (obj); if (!atk_relation_set_contains (relation_set, ATK_RELATION_LABEL_FOR)) { /* * Get the mnemonic widget * * The relation set is not updated if the mnemonic widget is changed */ GtkWidget *mnemonic_widget = gtk_label_get_mnemonic_widget (GTK_LABEL (widget)); if (mnemonic_widget) { AtkObject *accessible_array[1]; AtkRelation* relation; if (!gtk_widget_get_can_focus (mnemonic_widget)) { /* * Handle the case where a GtkFileChooserButton is specified as the * mnemonic widget. use the combobox which is a child of the * GtkFileChooserButton as the mnemonic widget. See bug #359843. */ if (GTK_IS_BOX (mnemonic_widget)) { GList *list, *tmpl; list = gtk_container_get_children (GTK_CONTAINER (mnemonic_widget)); if (g_list_length (list) == 2) { tmpl = g_list_last (list); if (GTK_IS_COMBO_BOX(tmpl->data)) { mnemonic_widget = GTK_WIDGET(tmpl->data); } } g_list_free (list); } /* * Handle the case where a GnomeIconEntry is specified as the * mnemonic widget. use the button which is a grandchild of the * GnomeIconEntry as the mnemonic widget. See bug #133967. */ else if (GTK_IS_BOX (mnemonic_widget)) { GList *list; list = gtk_container_get_children (GTK_CONTAINER (mnemonic_widget)); if (g_list_length (list) == 1) { if (GTK_IS_ALIGNMENT (list->data)) { GtkWidget *temp_widget; temp_widget = gtk_bin_get_child (GTK_BIN (list->data)); if (GTK_IS_BUTTON (temp_widget)) mnemonic_widget = temp_widget; } else if (GTK_IS_HBOX (list->data)) { GtkWidget *temp_widget; temp_widget = GTK_WIDGET (list->data); g_list_free (list); list = gtk_container_get_children (GTK_CONTAINER (temp_widget)); } } g_list_free (list); } } accessible_array[0] = gtk_widget_get_accessible (mnemonic_widget); relation = atk_relation_new (accessible_array, 1, ATK_RELATION_LABEL_FOR); atk_relation_set_add (relation_set, relation); /* * Unref the relation so that it is not leaked. */ g_object_unref (relation); } } return relation_set; }
static gint ensure_combo_box_widgets() { GtkWidget* buttonChild; if (gParts->comboBoxButtonWidget && gParts->comboBoxArrowWidget) return MOZ_GTK_SUCCESS; /* Create a ComboBox if needed */ if (!gParts->comboBoxWidget) { gParts->comboBoxWidget = gtk_combo_box_new(); setup_widget_prototype(gParts->comboBoxWidget); } /* Get its inner Button */ gtk_container_forall(GTK_CONTAINER(gParts->comboBoxWidget), moz_gtk_get_combo_box_inner_button, NULL); if (gParts->comboBoxButtonWidget) { /* Get the widgets inside the Button */ buttonChild = gtk_bin_get_child(GTK_BIN(gParts->comboBoxButtonWidget)); if (GTK_IS_HBOX(buttonChild)) { /* appears-as-list = FALSE, cell-view = TRUE; the button * contains an hbox. This hbox is there because the ComboBox * needs to place a cell renderer, a separator, and an arrow in * the button when appears-as-list is FALSE. */ gtk_container_forall(GTK_CONTAINER(buttonChild), moz_gtk_get_combo_box_button_inner_widgets, NULL); } else if(GTK_IS_ARROW(buttonChild)) { /* appears-as-list = TRUE, or cell-view = FALSE; * the button only contains an arrow */ gParts->comboBoxArrowWidget = buttonChild; g_object_add_weak_pointer(G_OBJECT(buttonChild), (gpointer) &gParts->comboBoxArrowWidget); gtk_widget_realize(gParts->comboBoxArrowWidget); g_object_set_data(G_OBJECT(gParts->comboBoxArrowWidget), "transparent-bg-hint", GINT_TO_POINTER(TRUE)); } } else { /* Shouldn't be reached with current internal gtk implementation; we * use a generic toggle button as last resort fallback to avoid * crashing. */ ensure_toggle_button_widget(); gParts->comboBoxButtonWidget = gParts->toggleButtonWidget; } if (!gParts->comboBoxArrowWidget) { /* Shouldn't be reached with current internal gtk implementation; * we gParts->buttonArrowWidget as last resort fallback to avoid * crashing. */ ensure_button_arrow_widget(); gParts->comboBoxArrowWidget = gParts->buttonArrowWidget; } /* We don't test the validity of gParts->comboBoxSeparatorWidget since there * is none when "appears-as-list" = TRUE or "cell-view" = FALSE; if it * is invalid we just won't paint it. */ return MOZ_GTK_SUCCESS; }
EaseDialogProgress* ease_dialog_progress_construct_with_image (GType object_type, const char* title, gboolean cancellable, double max, GtkWindow* modal, GtkImage* image) { #line 190 "ease-dialog-progress.c" EaseDialogProgress * self; GObject* _tmp0_; GtkHBox* hbox; GtkAlignment* align; #line 77 "ease-dialog-progress.vala" g_return_val_if_fail (title != NULL, NULL); #line 77 "ease-dialog-progress.vala" g_return_val_if_fail (image != NULL, NULL); #line 80 "ease-dialog-progress.vala" self = (EaseDialogProgress*) ease_dialog_progress_construct (object_type, title, cancellable, max, modal); #line 83 "ease-dialog-progress.vala" hbox = _g_object_ref0 ((_tmp0_ = gtk_builder_get_object (self->priv->builder, "hbox"), GTK_IS_HBOX (_tmp0_) ? ((GtkHBox*) _tmp0_) : NULL)); #line 84 "ease-dialog-progress.vala" align = g_object_ref_sink ((GtkAlignment*) gtk_alignment_new (0.5f, 0.5f, (float) 0, (float) 0)); #line 85 "ease-dialog-progress.vala" gtk_alignment_set_padding (align, (guint) 0, (guint) 0, (guint) 4, (guint) 4); #line 86 "ease-dialog-progress.vala" gtk_container_add ((GtkContainer*) align, (GtkWidget*) image); #line 87 "ease-dialog-progress.vala" gtk_widget_show ((GtkWidget*) align); #line 88 "ease-dialog-progress.vala" gtk_widget_show ((GtkWidget*) image); #line 89 "ease-dialog-progress.vala" gtk_box_pack_start ((GtkBox*) hbox, (GtkWidget*) align, FALSE, FALSE, (guint) 0); #line 215 "ease-dialog-progress.c" _g_object_unref0 (align); _g_object_unref0 (hbox); return self; }