static GtkWidget *create_media_ui(GtkWidget *window) { GtkWidget *label = NULL, *vbox = NULL, *vhbox = NULL, *vvbox = NULL; gchar str[1024] = {0}; snprintf(str, 1024, H1_FONT_FORMAT, _("M_usic")); vbox = gtk_vbox_new(FALSE, 48); vvbox = gtk_vbox_new(FALSE, 12); vhbox = gtk_hbox_new(FALSE, 0); label = gtk_label_new(NULL); gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), str); gtk_box_pack_start(GTK_BOX(vhbox), label, FALSE, TRUE, 2); gtk_box_pack_start(GTK_BOX(vvbox), vhbox, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vvbox), create_media_preview_ui_by_type(window, EBOX_MUSIC_UI), FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), vvbox, FALSE, TRUE, 0); vvbox = gtk_vbox_new(FALSE, 12); vhbox = gtk_hbox_new(FALSE, 0); label = gtk_label_new(NULL); bzero(str, 1024); snprintf(str, 1024, H1_FONT_FORMAT, _("_Photos")); gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), str); gtk_box_pack_start(GTK_BOX(vhbox), label, FALSE, TRUE, 2); gtk_box_pack_start(GTK_BOX(vvbox), vhbox, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vvbox), create_media_preview_ui_by_type(window, EBOX_PHOTO_UI), FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), vvbox, FALSE, TRUE, 0); return vbox; }
/************************************************************************** Changes the lable (with mnemonic) on an existing stockbutton. See gtk_stockbutton_new. **************************************************************************/ void gtk_stockbutton_set_label(GtkWidget *button, const gchar *label_text) { GtkWidget *label; label = g_object_get_data(G_OBJECT(button), "label"); gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), label_text); }
static void mini_dialog_add_button(PidginMiniDialog *self, const char *text, PidginMiniDialogCallback clicked_cb, gpointer user_data, gboolean close_dialog_after_click) { PidginMiniDialogPrivate *priv = PIDGIN_MINI_DIALOG_GET_PRIVATE(self); struct _mini_dialog_button_clicked_cb_data *callback_data = g_new0(struct _mini_dialog_button_clicked_cb_data, 1); GtkWidget *button = gtk_button_new(); GtkWidget *label = gtk_label_new(NULL); char *button_text = g_strdup_printf("<span size=\"smaller\">%s</span>", text); gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), button_text); g_free(button_text); callback_data->mini_dialog = self; callback_data->callback = clicked_cb; callback_data->user_data = user_data; callback_data->close_dialog_after_click = close_dialog_after_click; g_signal_connect(G_OBJECT(button), "clicked", (GCallback) mini_dialog_button_clicked_cb, callback_data); g_signal_connect(G_OBJECT(button), "destroy", (GCallback) mini_dialog_button_destroy_cb, callback_data); gtk_misc_set_alignment(GTK_MISC(label), 0.5, 0.5); gtk_container_add(GTK_CONTAINER(button), label); gtk_box_pack_end(GTK_BOX(priv->buttons), button, FALSE, FALSE, 0); gtk_widget_show_all(GTK_WIDGET(button)); }
/** * rb_glade_boldify_label: * @xml: GladeXML instance * @name: name of the label to boldify * * Makes a label built from a glade xml file bold. */ void rb_glade_boldify_label (GladeXML *xml, const char *name) { GtkWidget *widget; widget = glade_xml_get_widget (xml, name); if (widget == NULL) { g_warning ("widget '%s' not found", name); return; } /* this way is probably better, but for some reason doesn't work with * labels with mnemonics. static PangoAttrList *pattrlist = NULL; if (pattrlist == NULL) { PangoAttribute *attr; pattrlist = pango_attr_list_new (); attr = pango_attr_weight_new (PANGO_WEIGHT_BOLD); attr->start_index = 0; attr->end_index = G_MAXINT; pango_attr_list_insert (pattrlist, attr); } gtk_label_set_attributes (GTK_LABEL (widget), pattrlist);*/ gchar *str_final; str_final = g_strdup_printf ("<b>%s</b>", gtk_label_get_label (GTK_LABEL (widget))); gtk_label_set_markup_with_mnemonic (GTK_LABEL (widget), str_final); g_free (str_final); }
GtkWidget * util_image_menu_item( const gchar * icon_stock_id, const gchar * label_text, GCallback activate_cb, gpointer activate_user_data) { GtkWidget * item_w; if(icon_stock_id) { item_w = gtk_image_menu_item_new_with_label(""); gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(item_w), gtk_image_new_from_stock(icon_stock_id, GTK_ICON_SIZE_MENU)); } else { item_w = gtk_menu_item_new_with_label(""); } gtk_label_set_markup_with_mnemonic(GTK_LABEL(GTK_BIN(item_w)->child), label_text); /* hook up signal callback */ if(activate_cb) g_signal_connect(G_OBJECT(item_w), "activate", activate_cb, activate_user_data); return item_w; }
void lmplayer_interface_italicise_label (GtkBuilder *builder, const char *name) { GtkLabel *widget; gchar *str_final; widget = GTK_LABEL (gtk_builder_get_object (builder, name)); if (widget == NULL) { g_warning ("widget '%s' not found", name); return; } /* this way is probably better, but for some reason doesn't work with * labels with mnemonics. static PangoAttrList *pattrlist = NULL; if (pattrlist == NULL) { PangoAttribute *attr; pattrlist = pango_attr_list_new (); attr = pango_attr_style_new (PANGO_STYLE_ITALIC); attr->start_index = 0; attr->end_index = G_MAXINT; pango_attr_list_insert (pattrlist, attr); } gtk_label_set_attributes (widget, pattrlist);*/ str_final = g_strdup_printf ("<i>%s</i>", gtk_label_get_label (widget)); gtk_label_set_markup_with_mnemonic (widget, str_final); g_free (str_final); }
void FormDialog::private_text (const std::string name, const std::string description, const std::string value, const std::string tooltip, bool advanced) { GtkWidget *label = NULL; GtkWidget *widget = NULL; PrivateTextSubmitter *submitter = NULL; gchar *label_text = NULL; grow_fields (advanced); label = gtk_label_new (NULL); gtk_size_group_add_widget (labels_group, label); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); label_text = g_strdup_printf ("<b>%s</b>", description.c_str()); gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), label_text); g_free (label_text); widget = gtk_entry_new (); gtk_widget_set_tooltip_text (widget, tooltip.c_str ()); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); gtk_entry_set_activates_default (GTK_ENTRY (widget), true); gtk_entry_set_visibility (GTK_ENTRY (widget), FALSE); gtk_size_group_add_widget (options_group, widget); gtk_entry_set_text (GTK_ENTRY (widget), value.c_str ()); if (advanced) { gtk_table_attach (GTK_TABLE (advanced_fields), label, 0, 1, advanced_rows - 1, advanced_rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); gtk_table_attach (GTK_TABLE (advanced_fields), widget, 1, 2, advanced_rows - 1, advanced_rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); } else { gtk_table_attach (GTK_TABLE (fields), label, 0, 1, rows - 1, rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); gtk_table_attach (GTK_TABLE (fields), widget, 1, 2, rows - 1, rows, (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), (GtkAttachOptions) (GTK_FILL|GTK_EXPAND), 0, 0); } submitter = new PrivateTextSubmitter (name, description, advanced, widget); submitters.push_back (submitter); }
void GtkLabel_::set_markup_with_mnemonic(Php::Parameters ¶meters) { std::string s_str = parameters[0]; gchar *str = (gchar *)s_str.c_str(); gtk_label_set_markup_with_mnemonic (GTK_LABEL(instance), str); }
static GtkWidget * brasero_project_type_chooser_new_item (BraseroProjectTypeChooser *chooser, ItemDescription *description) { GtkWidget *hbox; GtkWidget *vbox; GtkWidget *image; GtkWidget *label; GtkWidget *eventbox; gchar *description_str; eventbox = gtk_button_new (); g_signal_connect (eventbox, "clicked", G_CALLBACK (brasero_project_type_chooser_button_clicked), chooser); gtk_widget_show (eventbox); if (description->tooltip) gtk_widget_set_tooltip_text (eventbox, _(description->tooltip)); g_object_set_data (G_OBJECT (eventbox), ID_KEY, GINT_TO_POINTER (description->type)); g_object_set_data (G_OBJECT (eventbox), DESCRIPTION_KEY, description); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 4); gtk_container_add (GTK_CONTAINER (eventbox), vbox); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, FALSE, 0); image = gtk_image_new_from_icon_name (description->image, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (image), 1.0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, TRUE, 0); label = gtk_label_new (NULL); gtk_label_set_mnemonic_widget (GTK_LABEL (label), eventbox); description_str = g_strdup_printf ("<big>%s</big>", _(description->text)); gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), description_str); g_free (description_str); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0); g_object_set_data (G_OBJECT (eventbox), LABEL_KEY, label); label = gtk_label_new (NULL); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_label_set_markup (GTK_LABEL (label), _(description->description)); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0); return eventbox; }
static GtkWidget * menu_quick_item (char *cmd, char *label, GtkWidget * menu, int flags, gpointer userdata, char *icon) { GtkWidget *img, *item; if (!label) item = gtk_menu_item_new (); else { if (icon) { /*if (flags & XCMENU_MARKUP) item = gtk_image_menu_item_new_with_markup (label); else*/ item = gtk_image_menu_item_new_with_mnemonic (label); img = gtk_image_new_from_file (icon); if (img) gtk_image_menu_item_set_image ((GtkImageMenuItem *)item, img); else { img = gtk_image_new_from_stock (icon, GTK_ICON_SIZE_MENU); if (img) gtk_image_menu_item_set_image ((GtkImageMenuItem *)item, img); } } else { if (flags & XCMENU_MARKUP) { item = gtk_menu_item_new_with_label (""); if (flags & XCMENU_MNEMONIC) gtk_label_set_markup_with_mnemonic (GTK_LABEL (GTK_BIN (item)->child), label); else gtk_label_set_markup (GTK_LABEL (GTK_BIN (item)->child), label); } else { if (flags & XCMENU_MNEMONIC) item = gtk_menu_item_new_with_mnemonic (label); else item = gtk_menu_item_new_with_label (label); } } } gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); g_object_set_data (G_OBJECT (item), "u", userdata); if (cmd) g_signal_connect (G_OBJECT (item), "activate", G_CALLBACK (popup_menu_cb), cmd); if (flags & XCMENU_SHADED) gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE); gtk_widget_show_all (item); return item; }
/** * dialog_vbox_label_new: * @labeltext: #const gchar * The label text. * @xalign: #gfloat The horizontal alignment, from 0 (left) to 1 (right). * @yalign: #gfloat the vertical alignment, from 0 (top) to 1 (bottom). * @box: #GtkWidget * GtkBox the label is packed into. * * Creates a GtkLabel, aligns it, and packs it in a GtkBox. * * Return value: #GtkWidget * The new GtkLabel widget. */ static GtkWidget * dialog_vbox_label_new(const gchar *labeltext, gfloat xalign, gfloat yalign, GtkWidget *box) { GtkWidget *label; label = gtk_label_new (NULL); gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), labeltext); gtk_misc_set_alignment (GTK_MISC (label), xalign, yalign); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); return label; }
static VALUE label_set_markup(int argc, VALUE *argv, VALUE self) { VALUE str, with_mnemonic; rb_scan_args(argc, argv, "02", &str, &with_mnemonic); if (NIL_P(with_mnemonic) || ! RVAL2CBOOL(with_mnemonic)){ gtk_label_set_markup(_SELF(self), RVAL2CSTR(str)); } else { gtk_label_set_markup_with_mnemonic(_SELF(self), RVAL2CSTR(str)); } return self; }
GtkWidget * dialog_mnemonic_label_new(const gchar * labeltext, GtkWidget * m_widget) { GtkWidget *label; label = gtk_label_new(NULL); gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), labeltext); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); if (m_widget) gtk_label_set_mnemonic_widget(GTK_LABEL(label), m_widget); return label; }
/** @brief set new label for existing widget @a button e2 uses non-standard dialog buttons, containing alignment containing h/vbox, the latter with label packed after icon (if any) @param button the button widget to be updated @param label string optionally with mnemonic @return */ void e2_button_set_label (GtkWidget *button, const gchar *label) { if (label != NULL && *label != '\0') { GtkWidget *bbox = #ifdef USE_GTK2_14 gtk_bin_get_child (GTK_BIN (button)); bbox = gtk_bin_get_child (GTK_BIN (bbox)); GList *children = gtk_container_get_children (GTK_CONTAINER (bbox)); GtkWidget *child = (GtkWidget*) children->data; if (!GTK_IS_LABEL (child)) child = (GtkWidget*) children->next->data; gtk_label_set_markup_with_mnemonic (GTK_LABEL (child), label); g_list_free (children); #else GTK_BIN (GTK_BIN (button)->child)->child; GtkBoxChild *child = (GtkBoxChild *) GTK_BOX (bbox)->children->data; if (!GTK_IS_LABEL (child->widget)) child = (GtkBoxChild *) GTK_BOX (bbox)->children->next->data; gtk_label_set_markup_with_mnemonic (GTK_LABEL (child->widget), label); #endif } }
void FormDialog::error (const std::string _error) { GtkWidget *widget = NULL; if (!_error.empty ()) { widget = gtk_label_new (NULL); gtk_label_set_line_wrap (GTK_LABEL (widget), TRUE); gtk_label_set_line_wrap_mode (GTK_LABEL (widget), PANGO_WRAP_WORD); gtk_label_set_markup_with_mnemonic (GTK_LABEL (widget), ("<span foreground=\"red\">" + _error + "</span>").c_str ()); gtk_container_add (GTK_CONTAINER (preamble), widget); } }
void FormDialog::instructions (const std::string _instructions) { GtkWidget *widget = NULL; InstructionsSubmitter *submitter = NULL; gchar * label_text = NULL; widget = gtk_label_new (NULL); label_text = g_strdup_printf ("<i>%s</i>", _instructions.c_str()); gtk_label_set_markup_with_mnemonic (GTK_LABEL (widget), label_text); g_free (label_text); gtk_label_set_line_wrap (GTK_LABEL (widget), TRUE); gtk_label_set_line_wrap_mode (GTK_LABEL (widget), PANGO_WRAP_WORD); gtk_box_pack_start (GTK_BOX (preamble), widget, FALSE, FALSE, 0); submitter = new InstructionsSubmitter (_instructions); submitters.push_back (submitter); }
/** * rb_builder_boldify_label: * @builder: a #GtkBuilder instance * @name: name of the label to boldify * * Makes a label built from a GtkBuilder file bold. */ void rb_builder_boldify_label (GtkBuilder *builder, const char *name) { GObject *widget; gchar *str_final; /* once we require gtk+ 2.16 or newer, we can set the attributes on * the labels in the builder files, so we won't need this any more. */ widget = gtk_builder_get_object (builder, name); if (widget == NULL) { g_warning ("widget '%s' not found", name); return; } str_final = g_strdup_printf ("<b>%s</b>", gtk_label_get_label (GTK_LABEL (widget))); gtk_label_set_markup_with_mnemonic (GTK_LABEL (widget), str_final); g_free (str_final); }
void FormDialog::link (const std::string _link, const std::string _uri) { GtkWidget *widget = NULL; GtkWidget *label = NULL; gchar *label_text = NULL; widget = gtk_button_new (); label = gtk_label_new (NULL); label_text = g_strdup_printf ("<span foreground=\"blue\"><u>%s</u></span>", _link.c_str ()); gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), label_text); g_free (label_text); gtk_container_add (GTK_CONTAINER (widget), label); gtk_button_set_relief (GTK_BUTTON (widget), GTK_RELIEF_NONE); gtk_box_pack_start (GTK_BOX (preamble), widget, FALSE, FALSE, 0); g_signal_connect_data (widget, "clicked", G_CALLBACK (link_clicked_cb), (gpointer) g_strdup (_uri.c_str ()), (GClosureNotify) g_free, (GConnectFlags) 0); }
/** * \param selection Selection to use; should not be NULL. */ static void sp_item_widget_setup ( SPWidget *spw, Inkscape::Selection *selection ) { g_assert (selection != NULL); if (gtk_object_get_data (GTK_OBJECT (spw), "blocked")) return; if (!selection->singleItem()) { gtk_widget_set_sensitive (GTK_WIDGET (spw), FALSE); return; } else { gtk_widget_set_sensitive (GTK_WIDGET (spw), TRUE); } gtk_object_set_data (GTK_OBJECT (spw), "blocked", GUINT_TO_POINTER (TRUE)); SPItem *item = selection->singleItem(); /* Sensitive */ GtkWidget *w = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "sensitive")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), item->isLocked()); /* Hidden */ w = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "hidden")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), item->isExplicitlyHidden()); if (SP_OBJECT_IS_CLONED (item)) { /* ID */ w = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "id")); gtk_entry_set_text (GTK_ENTRY (w), ""); gtk_widget_set_sensitive (w, FALSE); w = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "id_label")); gtk_label_set_text (GTK_LABEL (w), _("Ref")); /* Label */ w = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "label")); gtk_entry_set_text (GTK_ENTRY (w), ""); gtk_widget_set_sensitive (w, FALSE); w = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "label_label")); gtk_label_set_text (GTK_LABEL (w), _("Ref")); } else { SPObject *obj = (SPObject*)item; /* ID */ w = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "id")); gtk_entry_set_text (GTK_ENTRY (w), obj->getId()); gtk_widget_set_sensitive (w, TRUE); w = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "id_label")); gtk_label_set_markup_with_mnemonic (GTK_LABEL (w), _("_Id")); /* Label */ w = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "label")); gtk_entry_set_text (GTK_ENTRY (w), obj->defaultLabel()); gtk_widget_set_sensitive (w, TRUE); /* Title */ w = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "title")); gchar *title = obj->title(); if (title) { gtk_entry_set_text(GTK_ENTRY(w), title); g_free(title); } else gtk_entry_set_text(GTK_ENTRY(w), ""); gtk_widget_set_sensitive(w, TRUE); /* Description */ w = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "desc")); GtkTextBuffer *buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(w)); gchar *desc = obj->desc(); if (desc) { gtk_text_buffer_set_text(buf, desc, -1); g_free(desc); } else { gtk_text_buffer_set_text(buf, "", 0); } w = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "desc_frame")); gtk_widget_set_sensitive(w, TRUE); w = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "interactivity")); GtkWidget* int_table = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "interactivity_table")); if (int_table){ gtk_container_remove(GTK_CONTAINER(w), int_table); } const gchar* int_labels[10] = {"onclick", "onmouseover", "onmouseout", "onmousedown", "onmouseup", "onmousemove","onfocusin", "onfocusout", "onactivate", "onload"}; int_table = sp_attribute_table_new (obj, 10, int_labels, int_labels); gtk_widget_show_all (int_table); gtk_object_set_data(GTK_OBJECT(spw), "interactivity_table", int_table); gtk_container_add (GTK_CONTAINER (w), int_table); } gtk_object_set_data (GTK_OBJECT (spw), "blocked", GUINT_TO_POINTER (FALSE)); } // end of sp_item_widget_setup()
static GcrDisplayItem* create_display_item (GcrDisplayView *self, GcrRenderer *renderer) { GcrDisplayItem *item; GtkTextTagTable *tags; GtkTextIter iter; GtkWidget *widget; GtkWidget *label; GtkWidget *alignment; item = g_new0 (GcrDisplayItem, 1); item->display_view = self; item->renderer = renderer; tags = gtk_text_buffer_get_tag_table (self->pv->buffer); g_assert (!item->field_tag); item->field_width = 0; item->field_tag = g_object_new (GTK_TYPE_TEXT_TAG, "left-margin", item->field_width + FIELD_MARGIN, "indent", item->field_width, "pixels-below-lines", 3, "wrap-mode", GTK_WRAP_WORD_CHAR, NULL); gtk_text_tag_table_add (tags, item->field_tag); g_assert (!item->details_tag); item->details_tag = g_object_new (GTK_TYPE_TEXT_TAG, NULL); gtk_text_tag_table_add (tags, item->details_tag); /* The mark that determines the beginning of this item, with left gravity. */ gtk_text_buffer_get_end_iter (self->pv->buffer, &iter); item->beginning = gtk_text_buffer_create_mark (self->pv->buffer, NULL, &iter, TRUE); g_object_ref (item->beginning); /* The mark that determines the end of this item, with right gravity. */ gtk_text_buffer_get_end_iter (self->pv->buffer, &iter); item->ending = gtk_text_buffer_create_mark (self->pv->buffer, NULL, &iter, FALSE); g_object_ref (item->ending); widget = gtk_expander_new_with_mnemonic (""); label = gtk_expander_get_label_widget (GTK_EXPANDER (widget)); gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), "<b>_Details</b>"); g_signal_connect (widget, "notify::expanded", G_CALLBACK (on_expander_expanded), item); g_signal_connect (widget, "realize", G_CALLBACK (on_expander_realize), NULL); item->expanded = gtk_expander_get_expanded (GTK_EXPANDER (widget)); alignment = gtk_alignment_new (0.5, 0.5, 0.5, 0.5); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 6, 9, 0, 0); gtk_container_add (GTK_CONTAINER (alignment), widget); gtk_widget_show_all (alignment); item->details_widget = gtk_event_box_new (); gtk_container_add (GTK_CONTAINER (item->details_widget), alignment); g_signal_connect (item->details_widget, "realize", G_CALLBACK (on_expander_realize), NULL); g_object_ref (item->details_widget); if (gtk_widget_get_realized (GTK_WIDGET (self))) style_display_item (GTK_WIDGET (self), item); /* TODO: Initialize the rest of the fields */ return item; }
void wxControl::GTKSetLabelWithMarkupForLabel(GtkLabel *w, const wxString& label) { const wxString labelGTK = GTKConvertMnemonicsWithMarkup(label); gtk_label_set_markup_with_mnemonic(w, wxGTK_CONV(labelGTK)); }
static void gdaui_dsn_editor_init (GdauiDsnEditor *config, G_GNUC_UNUSED GdauiDsnEditorClass *klass) { GtkWidget *grid; GtkWidget *label; GtkWidget *exp; gchar *str; g_return_if_fail (GDAUI_IS_DSN_EDITOR (config)); gtk_orientable_set_orientation (GTK_ORIENTABLE (config), GTK_ORIENTATION_VERTICAL); /* allocate private structure */ config->priv = g_new0 (GdauiDsnEditorPrivate, 1); config->priv->dsn_info = g_new0 (GdaDsnInfo, 1); config->priv->no_change_signal = TRUE; /* data source's name and icon */ GtkWidget *hbox_header; hbox_header = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (config), hbox_header, FALSE, FALSE, 6); config->priv->icon = gtk_image_new (); gtk_widget_set_size_request (config->priv->icon, -1, SUPPORT_ICON_SIZE); gtk_box_pack_start (GTK_BOX (hbox_header), config->priv->icon, FALSE, FALSE, 0); config->priv->wname = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox_header), config->priv->wname, FALSE, FALSE, 10); GtkWidget *menu_button; menu_button = gtk_menu_button_new (); gtk_box_pack_end (GTK_BOX (hbox_header), menu_button, FALSE, FALSE, 0); GtkWidget *menu_icon; menu_icon = gtk_image_new_from_icon_name ("open-menu-symbolic", GTK_ICON_SIZE_MENU); gtk_button_set_image (GTK_BUTTON (menu_button), menu_icon); GMenu *smenu; smenu = g_menu_new (); gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (menu_button), G_MENU_MODEL (smenu)); GMenuItem *mitem; mitem = g_menu_item_new ("Test data source", "win.DSNTest"); g_menu_insert_item (smenu, -1, mitem); mitem = g_menu_item_new ("Reset data source's changes", "win.DSNReset"); g_menu_insert_item (smenu, -1, mitem); mitem = g_menu_item_new ("Duplicate data source", "win.DSNCopy"); g_menu_insert_item (smenu, -1, mitem); GtkWindow *win; win = gtk_application_get_active_window (GTK_APPLICATION (g_application_get_default ())); g_action_map_add_action_entries (G_ACTION_MAP (win), win_entries, G_N_ELEMENTS (win_entries), config); /* stack in a scrolled window */ GtkWidget *sw; sw = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_vexpand (sw, TRUE); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_NONE); gtk_box_pack_start (GTK_BOX (config), sw, TRUE, TRUE, 6); /* Stack */ config->priv->stack = gtk_stack_new (); gtk_stack_set_transition_type (GTK_STACK (config->priv->stack), GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT); gtk_container_add (GTK_CONTAINER (sw), config->priv->stack); /* set up widgets */ grid = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (grid), 6); gtk_grid_set_column_spacing (GTK_GRID (grid), 6); gtk_widget_show (grid); label = gtk_label_new_with_mnemonic (_("_System wide data source:")); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_widget_set_hexpand (label, FALSE); g_object_set (G_OBJECT (label), "xalign", 0., NULL); gtk_widget_show (label); gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1); config->priv->is_system = gtk_check_button_new (); gtk_widget_show (config->priv->is_system); g_signal_connect (G_OBJECT (config->priv->is_system), "toggled", G_CALLBACK (field_toggled_cb), config); gtk_grid_attach (GTK_GRID (grid), config->priv->is_system, 1, 1, 1, 1); str = g_strdup_printf ("%s <span foreground='red' weight='bold'>*</span>", _("_Provider:")); label = gtk_label_new (""); gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), str); g_free (str); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_widget_set_hexpand (label, FALSE); g_object_set (G_OBJECT (label), "xalign", 0., NULL); gtk_widget_show (label); gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1); config->priv->wprovider = gdaui_provider_selector_new (); gtk_widget_set_hexpand (config->priv->wprovider, TRUE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), config->priv->wprovider); gtk_widget_show (config->priv->wprovider); g_signal_connect (G_OBJECT (config->priv->wprovider), "changed", G_CALLBACK (field_changed_cb), config); gtk_grid_attach (GTK_GRID (grid), config->priv->wprovider, 1, 2, 1, 1); label = gtk_label_new_with_mnemonic (_("_Description:")); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_widget_set_hexpand (label, FALSE); g_object_set (G_OBJECT (label), "xalign", 0., NULL); gtk_widget_show (label); gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER); config->priv->wdesc = gtk_text_view_new (); gtk_container_add (GTK_CONTAINER (sw), config->priv->wdesc); gtk_text_view_set_editable (GTK_TEXT_VIEW (config->priv->wdesc), TRUE); gtk_widget_set_vexpand (config->priv->wdesc, TRUE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), config->priv->wdesc); g_signal_connect (gtk_text_view_get_buffer (GTK_TEXT_VIEW (config->priv->wdesc)), "changed", G_CALLBACK (field_changed_cb), config); gtk_grid_attach (GTK_GRID (grid), sw, 1, 3, 1, 1); config->priv->warning = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (config->priv->warning), _("<span foreground='red'>The database provider used by this data source is not available,\n" "editing the data source's attributes is disabled</span>")); gtk_widget_set_halign (config->priv->warning, GTK_ALIGN_CENTER); gtk_widget_set_hexpand (config->priv->warning, TRUE); g_object_set (G_OBJECT (config->priv->warning), "xalign", 0.5, NULL); gtk_label_set_justify (GTK_LABEL (config->priv->warning), GTK_JUSTIFY_CENTER); gtk_label_set_line_wrap (GTK_LABEL (config->priv->warning), TRUE); gtk_grid_attach (GTK_GRID (grid), config->priv->warning, 0, 8, 2, 1); gtk_stack_add_named (GTK_STACK (config->priv->stack), grid, PANE_DEFINITION); /* connection's spec */ config->priv->dsn_spec = _gdaui_provider_spec_editor_new (gdaui_provider_selector_get_provider (GDAUI_PROVIDER_SELECTOR (config->priv->wprovider))); g_signal_connect (G_OBJECT (config->priv->dsn_spec), "changed", G_CALLBACK (field_changed_cb), config); gtk_widget_show (config->priv->dsn_spec); gtk_stack_add_named (GTK_STACK (config->priv->stack), config->priv->dsn_spec, PANE_PARAMS); /* connection's authentication */ config->priv->dsn_auth = _gdaui_provider_auth_editor_new (gdaui_provider_selector_get_provider (GDAUI_PROVIDER_SELECTOR (config->priv->wprovider))); g_signal_connect (G_OBJECT (config->priv->dsn_auth), "changed", G_CALLBACK (field_changed_cb), config); gtk_widget_show (config->priv->dsn_auth); gtk_stack_add_named (GTK_STACK (config->priv->stack), config->priv->dsn_auth, PANE_AUTH); config->priv->no_change_signal = FALSE; }
static void create_window (void) { jump_to_track_win = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_type_hint(GTK_WINDOW(jump_to_track_win), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_title(GTK_WINDOW(jump_to_track_win), _("Jump to Song")); g_signal_connect (jump_to_track_win, "key_press_event", (GCallback) keypress_cb, NULL); g_signal_connect (jump_to_track_win, "delete-event", (GCallback) delete_cb, NULL); gtk_container_set_border_width(GTK_CONTAINER(jump_to_track_win), 10); gtk_window_set_default_size(GTK_WINDOW(jump_to_track_win), 600, 500); GtkWidget * vbox = gtk_vbox_new (FALSE, 5); gtk_container_add(GTK_CONTAINER(jump_to_track_win), vbox); treeview = mlpgui_list_new (& callbacks, NULL, 0); gtk_tree_view_set_headers_visible ((GtkTreeView *) treeview, FALSE); mlpgui_list_add_column (treeview, NULL, 0, G_TYPE_INT, 7); mlpgui_list_add_column (treeview, NULL, 1, G_TYPE_STRING, -1); g_signal_connect (gtk_tree_view_get_selection ((GtkTreeView *) treeview), "changed", (GCallback) selection_changed, NULL); g_signal_connect (treeview, "row-activated", (GCallback) do_jump, NULL); GtkWidget * hbox = gtk_hbox_new (FALSE, 3); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3); /* filter box */ GtkWidget * search_label = gtk_label_new (_("Filter: ")); gtk_label_set_markup_with_mnemonic(GTK_LABEL(search_label), _("_Filter:")); gtk_box_pack_start(GTK_BOX(hbox), search_label, FALSE, FALSE, 0); filter_entry = gtk_entry_new (); gtk_label_set_mnemonic_widget ((GtkLabel *) search_label, filter_entry); g_signal_connect (filter_entry, "changed", (GCallback) fill_list, NULL); gtk_entry_set_activates_default ((GtkEntry *) filter_entry, TRUE); gtk_box_pack_start ((GtkBox *) hbox, filter_entry, TRUE, TRUE, 3); /* remember text entry */ GtkWidget * toggle2 = gtk_check_button_new_with_label (_("Remember")); gtk_toggle_button_set_active ((GtkToggleButton *) toggle2, mlp_get_bool ("mlpgui", "remember_jtf_entry")); gtk_box_pack_start(GTK_BOX(hbox), toggle2, FALSE, FALSE, 0); g_signal_connect (toggle2, "clicked", (GCallback) toggle_button_cb, "remember_jtf_entry"); /* clear button */ GtkWidget * rescan = gtk_button_new_with_mnemonic (_("Clea_r")); gtk_button_set_image ((GtkButton *) rescan, gtk_image_new_from_stock (GTK_STOCK_CLEAR, GTK_ICON_SIZE_BUTTON)); gtk_box_pack_start(GTK_BOX(hbox), rescan, FALSE, FALSE, 0); g_signal_connect (rescan, "clicked", (GCallback) clear_cb, NULL); GtkWidget * scrollwin = gtk_scrolled_window_new (NULL, NULL); gtk_container_add(GTK_CONTAINER(scrollwin), treeview); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrollwin), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(vbox), scrollwin, TRUE, TRUE, 0); GtkWidget * bbox = gtk_hbutton_box_new (); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(bbox), 4); gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0); /* close dialog toggle */ GtkWidget * toggle = gtk_check_button_new_with_label(_("Close on Jump")); gtk_toggle_button_set_active ((GtkToggleButton *) toggle, mlp_get_bool ("mlpgui", "close_jtf_dialog")); gtk_box_pack_start(GTK_BOX(bbox), toggle, FALSE, FALSE, 0); g_signal_connect (toggle, "clicked", (GCallback) toggle_button_cb, "close_jtf_dialog"); /* queue button */ queue_button = gtk_button_new_with_mnemonic(_("_Queue")); gtk_button_set_image ((GtkButton *) queue_button, gtk_image_new_from_stock (AUD_STOCK_QUEUETOGGLE, GTK_ICON_SIZE_BUTTON)); gtk_box_pack_start ((GtkBox *) bbox, queue_button, FALSE, FALSE, 0); g_signal_connect (queue_button, "clicked", (GCallback) do_queue, NULL); /* jump button */ GtkWidget * jump = gtk_button_new_from_stock (GTK_STOCK_JUMP_TO); gtk_box_pack_start(GTK_BOX(bbox), jump, FALSE, FALSE, 0); g_signal_connect (jump, "clicked", (GCallback) do_jump, NULL); gtk_widget_set_can_default(jump, TRUE); gtk_widget_grab_default(jump); /* close button */ GtkWidget * close = gtk_button_new_from_stock (GTK_STOCK_CLOSE); gtk_box_pack_start(GTK_BOX(bbox), close, FALSE, FALSE, 0); g_signal_connect (close, "clicked", (GCallback) mlpgui_jump_to_track_hide, NULL); gtk_widget_set_can_default(close, TRUE); }
void show_login() { GtkWidget *image; GtkWidget *hbox_toplevel; GtkWidget *vbox; GtkWidget *button; GtkWidget *hbox; GtkWidget *label; GtkWidget *vbox2; GtkWidget *table; #ifdef GAIM_SMALL_SCREEN #ifdef ENABLE_HILDON GtkWidget *hbox1; GtkWidget *vbox1; #endif GtkWidget *hseparator; #endif /* Do we already have a main window opened? If so, bring it back, baby... ribs... yeah */ #ifdef ENABLE_HILDON if (login_app_view) { hildon_app_set_appview(HILDON_APP(app), HILDON_APPVIEW(login_app_view)); g_object_unref(login_app_view); return; } mainwindow = current_app_view = login_app_view = hildon_appview_new(_("Login")); hildon_app_set_appview(HILDON_APP(app), HILDON_APPVIEW(login_app_view)); hbox_toplevel = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(login_app_view), hbox_toplevel); g_signal_connect(G_OBJECT(login_app_view), "delete_event", G_CALLBACK(login_window_closed), login_app_view); #else if (mainwindow) { gtk_window_present(GTK_WINDOW(mainwindow)); return; } #ifdef GAIM_SMALL_SCREEN mainwindow = gtk_dialog_new(); gtk_window_set_modal(GTK_WINDOW(mainwindow), TRUE); gtk_dialog_set_has_separator(mainwindow, FALSE); #else mainwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); #endif gtk_window_set_role(GTK_WINDOW(mainwindow), "login"); gtk_window_set_resizable(GTK_WINDOW(mainwindow), FALSE); gtk_window_set_title(GTK_WINDOW(mainwindow), _("Login")); gtk_container_set_border_width(GTK_CONTAINER(mainwindow), 5); g_signal_connect(G_OBJECT(mainwindow), "delete_event", G_CALLBACK(login_window_closed), mainwindow); hbox_toplevel = gtk_hbox_new(FALSE, 0); #ifdef GAIM_SMALL_SCREEN gtk_container_add(GTK_CONTAINER(GTK_DIALOG(mainwindow)->vbox), hbox_toplevel); #else gtk_container_add(GTK_CONTAINER(mainwindow), hbox_toplevel); #endif #endif vbox_toplevel = vbox = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox_toplevel), vbox, FALSE, FALSE, BOX_SPACING); #ifdef GAIM_SMALL_SCREEN /* Now for the button box */ hbox = gtk_hbox_new(FALSE, 0); #ifdef ENABLE_HILDON hbox1 = gtk_hbox_new(FALSE, BOX_SPACING); vbox1 = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox1, TRUE, FALSE, 0); gtk_box_pack_end(GTK_BOX(hbox1), vbox1, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox1), hbox, FALSE, FALSE, 0); vbox = vbox1; #else gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); #endif /* lets put the image also in the hbox */ image = gtk_image_new_from_stock(GAIM_STOCK_LOGO, gtk_icon_size_from_name(GAIM_ICON_SIZE_LOGO)); #ifdef ENABLE_HILDON gtk_box_pack_start(GTK_BOX(hbox1), image, FALSE, FALSE, 0); #else gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0); #endif /* And now for the buttons */ button = gaim_pixbuf_button_from_stock(_("A_ccounts"), GAIM_STOCK_ACCOUNTS, GAIM_BUTTON_VERTICAL); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(gaim_gtk_accounts_window_show), mainwindow); gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0); button = gaim_pixbuf_button_from_stock(_("P_references"), GTK_STOCK_PREFERENCES, GAIM_BUTTON_VERTICAL); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(gaim_gtk_prefs_show), mainwindow); gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0); button = gaim_pixbuf_button_from_stock(_("_Sign on"), GAIM_STOCK_SIGN_ON, GAIM_BUTTON_VERTICAL); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(dologin), mainwindow); g_signal_connect(G_OBJECT(button), "button-press-event", G_CALLBACK(domiddleclick), NULL); gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox), hseparator, FALSE, TRUE, 2); #else image = gtk_image_new_from_stock(GAIM_STOCK_LOGO, gtk_icon_size_from_name(GAIM_ICON_SIZE_LOGO)); gtk_box_pack_start(GTK_BOX(vbox), image, FALSE, FALSE, 0); #endif table = gtk_table_new (2, 2, FALSE); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox), table, TRUE, TRUE, 0); gtk_table_set_row_spacings (GTK_TABLE (table), 2); gtk_table_set_col_spacings (GTK_TABLE (table), 2); /* why isn't there a gtk_label_new_with_markup? */ label = gtk_label_new(NULL); gtk_widget_show (label); gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), _("<b>_Account:</b>")); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); name = gaim_gtk_account_option_menu_new(NULL, TRUE, G_CALLBACK(combo_changed), NULL, NULL); gtk_label_set_mnemonic_widget(GTK_LABEL(label), name); gtk_widget_show (name); gtk_table_attach (GTK_TABLE (table), name, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); label = gtk_label_new(NULL); gtk_widget_show (label); gtk_label_set_markup_with_mnemonic(GTK_LABEL(label), _("<b>_Password:</b>")); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); pass = gtk_entry_new(); gtk_label_set_mnemonic_widget(GTK_LABEL(label), pass); gtk_entry_set_visibility(GTK_ENTRY(pass), FALSE); gtk_table_attach (GTK_TABLE (table), pass, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); #ifndef GAIM_SMALL_SCREEN g_signal_connect(G_OBJECT(pass), "activate", G_CALLBACK(dologin), mainwindow); /* gtk_box_pack_start(GTK_BOX(vbox2), pass, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), vbox2, FALSE, TRUE, 0); */ /* Now for the button box */ hbox = gtk_hbox_new(TRUE, 0); /* gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 5); */ gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5); /* And now for the buttons */ button = gaim_pixbuf_button_from_stock(_("A_ccounts"), GAIM_STOCK_ACCOUNTS, GAIM_BUTTON_VERTICAL); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(gaim_gtk_accounts_window_show), mainwindow); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); button = gaim_pixbuf_button_from_stock(_("P_references"), GTK_STOCK_PREFERENCES, GAIM_BUTTON_VERTICAL); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(gaim_gtk_prefs_show), mainwindow); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); button = gaim_pixbuf_button_from_stock(_("_Sign on"), GAIM_STOCK_SIGN_ON, GAIM_BUTTON_VERTICAL); gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(dologin), mainwindow); g_signal_connect(G_OBJECT(button), "button-press-event", G_CALLBACK(domiddleclick), NULL); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); #endif /* Now grab the focus that we need */ if (gaim_accounts_get_all()) { GaimAccount *account = gaim_accounts_get_all()->data; if (gaim_account_get_remember_password(account)) { combo_changed(NULL, account, NULL); gtk_widget_grab_focus(button); } else { gtk_widget_grab_focus(pass); } } else { gaim_gtk_accounts_window_show(); gtk_widget_grab_focus(button); } #ifndef ENABLE_HILDON /* And raise the curtain! */ gtk_widget_show_all(mainwindow); #else gtk_widget_show_all(login_app_view); #endif }
GtkWidget * entry_create_widget (GtkWidget * dlg) { GtkWidget *c, *l = NULL, *w = NULL; #if !GTK_CHECK_VERSION(3,0,0) w = gtk_hbox_new (FALSE, 5); #else w = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); #endif if (options.entry_data.entry_label) { l = gtk_label_new (NULL); if (options.data.no_markup) gtk_label_set_text_with_mnemonic (GTK_LABEL (l), options.entry_data.entry_label); else gtk_label_set_markup_with_mnemonic (GTK_LABEL (l), options.entry_data.entry_label); gtk_widget_set_name (l, "yad-entry-label"); gtk_box_pack_start (GTK_BOX (w), l, FALSE, FALSE, 1); } if (options.entry_data.numeric) { gdouble min, max, step, val; guint prec; min = 0.0; max = 65535.0; step = 1.0; prec = 0; if (options.extra_data && options.extra_data[0]) { min = g_ascii_strtod (options.extra_data[0], NULL); if (options.extra_data[1]) max = g_ascii_strtod (options.extra_data[1], NULL); if (options.extra_data[2]) step = g_ascii_strtod (options.extra_data[2], NULL); if (options.extra_data[3]) { prec = (guint) g_ascii_strtoull (options.extra_data[3], NULL, 0); if (prec > 20) prec = 20; } } c = entry = gtk_spin_button_new_with_range (min, max, step); gtk_entry_set_alignment (GTK_ENTRY (c), 1.0); gtk_spin_button_set_digits (GTK_SPIN_BUTTON (c), prec); gtk_widget_set_name (entry, "yad-entry-spin"); if (options.entry_data.entry_text) { val = g_ascii_strtod (options.entry_data.entry_text, NULL); if (min >= max) { g_printerr (_("Maximum value must be greater than minimum value.\n")); min = 0.0; max = 65535.0; } if (val < min) { g_printerr (_("Initial value less than minimal.\n")); val = min; } else if (val > max) { g_printerr (_("Initial value greater than maximum.\n")); val = max; } gtk_spin_button_set_value (GTK_SPIN_BUTTON (c), val); } } else if (!options.entry_data.completion && options.extra_data && *options.extra_data) { gint active, i; if (options.common_data.editable || settings.combo_always_editable) { #if GTK_CHECK_VERSION(2,24,0) c = gtk_combo_box_text_new_with_entry (); #else c = gtk_combo_box_entry_new_text (); #endif gtk_widget_set_name (c, "yad-entry-edit-combo"); entry = gtk_bin_get_child (GTK_BIN (c)); if (options.entry_data.licon) { GdkPixbuf *pb = get_pixbuf (options.entry_data.licon, YAD_SMALL_ICON); if (pb) gtk_entry_set_icon_from_pixbuf (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, pb); } if (options.entry_data.ricon) { GdkPixbuf *pb = get_pixbuf (options.entry_data.ricon, YAD_SMALL_ICON); if (pb) gtk_entry_set_icon_from_pixbuf (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, pb); } } else { #if GTK_CHECK_VERSION(2,24,0) c = entry = gtk_combo_box_text_new (); #else c = entry = gtk_combo_box_new_text (); #endif gtk_widget_set_name (c, "yad-entry-combo"); is_combo = TRUE; } i = 0; active = -1; while (options.extra_data[i] != NULL) { if (options.entry_data.entry_text && g_ascii_strcasecmp (options.extra_data[i], options.entry_data.entry_text) == 0) active = i; #if GTK_CHECK_VERSION(2,24,0) gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (c), options.extra_data[i]); #else gtk_combo_box_append_text (GTK_COMBO_BOX (c), options.extra_data[i]); #endif i++; } if (options.entry_data.entry_text && active == -1) { #if GTK_CHECK_VERSION(2,24,0) gtk_combo_box_text_prepend_text (GTK_COMBO_BOX_TEXT (c), options.entry_data.entry_text); #else gtk_combo_box_prepend_text (GTK_COMBO_BOX (c), options.entry_data.entry_text); #endif } /* set first iter active */ if (!options.common_data.editable) gtk_combo_box_set_active (GTK_COMBO_BOX (c), (active != -1 ? active : 0)); } else { c = entry = gtk_entry_new (); gtk_widget_set_name (c, "yad-entry-widget"); gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE); if (options.entry_data.entry_text) gtk_entry_set_text (GTK_ENTRY (entry), options.entry_data.entry_text); if (options.entry_data.hide_text) g_object_set (G_OBJECT (entry), "visibility", FALSE, NULL); if (options.entry_data.completion) { GtkEntryCompletion *completion; GtkTreeModel *completion_model; completion = gtk_entry_completion_new (); gtk_entry_set_completion (GTK_ENTRY (entry), completion); completion_model = create_completion_model (); gtk_entry_completion_set_model (completion, completion_model); g_object_unref (completion_model); gtk_entry_completion_set_text_column (completion, 0); g_object_unref (completion); } if (options.entry_data.licon) { GdkPixbuf *pb = get_pixbuf (options.entry_data.licon, YAD_SMALL_ICON); if (pb) gtk_entry_set_icon_from_pixbuf (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, pb); } if (options.entry_data.ricon) { GdkPixbuf *pb = get_pixbuf (options.entry_data.ricon, YAD_SMALL_ICON); if (pb) gtk_entry_set_icon_from_pixbuf (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, pb); } } if (l) gtk_label_set_mnemonic_widget (GTK_LABEL (l), entry); if (!is_combo) g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (entry_activate_cb), dlg); else g_signal_connect (G_OBJECT (entry), "key-press-event", G_CALLBACK (combo_activate_cb), dlg); if (options.entry_data.licon || options.entry_data.ricon) g_signal_connect (G_OBJECT (entry), "icon-press", G_CALLBACK (icon_cb), NULL); gtk_box_pack_start (GTK_BOX (w), c, TRUE, TRUE, 1); return w; }
/** @brief create button This is used for toolbar buttons, and (maybe indirectly) for dialog buttons @param label button label which may contain markup and/or mnemonic, or NULL @param stock string describing icon, or NULL @param size code for size of button-icon @param tip tooltip for the button, or NULL @param callback callback function for button's "clicked" signal, or NULL @param data data specified for the callback @param flags flags indicating button properties @return the (unshown) button widget */ GtkWidget *e2_button_get_full (const gchar *label, const gchar *stock, GtkIconSize size, const gchar *tip, void (*callback)(/*GtkButton*,gpointer*/), gpointer data, E2_ButtonFlags flags) { GtkWidget *button = gtk_button_new (); #ifdef USE_GTK2_18 gtk_widget_set_can_default (button, (flags & E2_BUTTON_CAN_DEFAULT) > 0); gtk_widget_set_can_focus (button, (flags & E2_BUTTON_CAN_FOCUS) > 0); #else if (flags & E2_BUTTON_CAN_DEFAULT) GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); else GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_DEFAULT); if (flags & E2_BUTTON_CAN_FOCUS) GTK_WIDGET_SET_FLAGS (button, GTK_CAN_FOCUS); else GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_FOCUS); #endif if (tip != NULL) e2_widget_set_safetip (button, tip); if (callback != NULL) g_signal_connect_data (G_OBJECT (button), "clicked", G_CALLBACK (callback), data, (flags & E2_BUTTON_FREE_DATA) ? (GClosureNotify) g_free : NULL, 0); GtkWidget *bbox; #ifdef USE_GTK3_0 if (flags & E2_BUTTON_ICON_ABOVE_LABEL) bbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); //constant gap, not E2_PADDING_XSMALL else bbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); #else if (flags & E2_BUTTON_ICON_ABOVE_LABEL) bbox = gtk_vbox_new (FALSE, 2); else bbox = gtk_hbox_new (FALSE, 2); #endif gboolean need_align = FALSE; if (stock != NULL) { GtkWidget *img = e2_widget_get_icon (stock, size); if (img == NULL && (flags & E2_BUTTON_SHOW_MISSING_ICON)) img = e2_widget_get_icon (STOCK_NAME_MISSING_IMAGE, size); if (img != NULL) { gtk_box_pack_start (GTK_BOX (bbox), img, FALSE, FALSE, 0); need_align = TRUE; } } if ((label != NULL) && (*label != '\0')) { GtkWidget *wlab = gtk_label_new (""); gtk_label_set_markup_with_mnemonic (GTK_LABEL (wlab), label); gtk_label_set_mnemonic_widget ((GtkLabel*)wlab, button); //NEEDED? label not a child of button gtk_box_pack_start (GTK_BOX (bbox), wlab, TRUE, TRUE, 0); need_align = TRUE; } if (need_align) { GtkWidget *align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); gtk_container_add (GTK_CONTAINER (align), bbox); gtk_container_add (GTK_CONTAINER (button), align); } else //should never happen gtk_container_add (GTK_CONTAINER (button), bbox); return button; }
static void OutputImageDialogSetupItem(GtkWidget *w, struct OutputImageDialog *d) { int i; GtkWidget *vlabel; #if GTK_CHECK_VERSION(3, 0, 0) GtkWidget *window; GtkRequisition minimum_size; #endif vlabel = get_mnemonic_label(d->version); gtk_label_set_text(GTK_LABEL(vlabel), ""); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->use_opacity), FALSE); combo_box_clear(d->version); switch (d->DlgType) { case MenuIdOutputPSFile: case MenuIdOutputEPSFile: for (i = 0; PsVersion[i]; i++) { combo_box_append_text(d->version, PsVersion[i]); } set_widget_visibility_with_label(d->dpi, FALSE); set_widget_visibility_with_label(d->version, TRUE); gtk_widget_set_visible(d->t2p, TRUE); gtk_label_set_markup_with_mnemonic(GTK_LABEL(vlabel), _("_PostScript Version:")); gtk_spin_button_set_value(GTK_SPIN_BUTTON(d->dpi), 72); combo_box_set_active(d->version, Menulocal.ps_version); break; case MenuIdOutputPNGFile: set_widget_visibility_with_label(d->dpi, TRUE); set_widget_visibility_with_label(d->version, FALSE); gtk_widget_set_visible(d->t2p, FALSE); gtk_spin_button_set_value(GTK_SPIN_BUTTON(d->dpi), Menulocal.png_dpi); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->use_opacity), Menulocal.use_opacity); break; case MenuIdOutputPDFFile: set_widget_visibility_with_label(d->dpi, FALSE); set_widget_visibility_with_label(d->version, FALSE); gtk_widget_set_visible(d->t2p, TRUE); gtk_spin_button_set_value(GTK_SPIN_BUTTON(d->dpi), 72); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->use_opacity), Menulocal.use_opacity); break; case MenuIdOutputSVGFile: for (i = 0; PsVersion[i]; i++) { combo_box_append_text(d->version, SvgVersion[i]); } set_widget_visibility_with_label(d->dpi, FALSE); set_widget_visibility_with_label(d->version, TRUE); gtk_widget_set_visible(d->t2p, TRUE); gtk_label_set_markup_with_mnemonic(GTK_LABEL(vlabel), _("_SVG Version:")); gtk_spin_button_set_value(GTK_SPIN_BUTTON(d->dpi), 72); combo_box_set_active(d->version, Menulocal.svg_version); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->use_opacity), Menulocal.use_opacity); break; #ifdef CAIRO_HAS_WIN32_SURFACE case MenuIdOutputCairoEMFFile: set_widget_visibility_with_label(d->dpi, TRUE); set_widget_visibility_with_label(d->version, FALSE); gtk_widget_set_visible(d->t2p, FALSE); gtk_spin_button_set_value(GTK_SPIN_BUTTON(d->dpi), Menulocal.emf_dpi); break; #endif /* CAIRO_HAS_WIN32_SURFACE */ } #if GTK_CHECK_VERSION(3, 0, 0) window = gtk_widget_get_parent(GTK_WIDGET(d->vbox)); if (GTK_IS_WINDOW(window)) { gtk_widget_get_preferred_size(GTK_WIDGET(d->vbox), &minimum_size, NULL); gtk_window_resize(GTK_WINDOW(window), minimum_size.width, minimum_size.height); } #endif }
static void sp_item_widget_label_changed( GtkWidget */*widget*/, SPWidget *spw ) { if (gtk_object_get_data (GTK_OBJECT (spw), "blocked")) return; SPItem *item = sp_desktop_selection(SP_ACTIVE_DESKTOP)->singleItem(); g_return_if_fail (item != NULL); gtk_object_set_data (GTK_OBJECT (spw), "blocked", GUINT_TO_POINTER (TRUE)); /* Retrieve the label widget for the object's id */ GtkWidget *id_entry = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "id")); gchar *id = (gchar *) gtk_entry_get_text (GTK_ENTRY (id_entry)); g_strcanon (id, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.:", '_'); GtkWidget *id_label = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "id_label")); if (!strcmp (id, item->getId())) { gtk_label_set_markup_with_mnemonic (GTK_LABEL (id_label), _("_Id")); } else if (!*id || !isalnum (*id)) { gtk_label_set_text (GTK_LABEL (id_label), _("Id invalid! ")); } else if (SP_ACTIVE_DOCUMENT->getObjectById(id) != NULL) { gtk_label_set_text (GTK_LABEL (id_label), _("Id exists! ")); } else { SPException ex; gtk_label_set_markup_with_mnemonic (GTK_LABEL (id_label), _("_Id")); SP_EXCEPTION_INIT (&ex); sp_object_setAttribute (SP_OBJECT (item), "id", id, &ex); sp_document_done (SP_ACTIVE_DOCUMENT, SP_VERB_DIALOG_ITEM, _("Set object ID")); } /* Retrieve the label widget for the object's label */ GtkWidget *label_entry = GTK_WIDGET(gtk_object_get_data (GTK_OBJECT (spw), "label")); gchar *label = (gchar *)gtk_entry_get_text (GTK_ENTRY (label_entry)); g_assert(label != NULL); /* Give feedback on success of setting the drawing object's label * using the widget's label text */ SPObject *obj = (SPObject*)item; if (strcmp (label, obj->defaultLabel())) { obj->setLabel(label); sp_document_done (SP_ACTIVE_DOCUMENT, SP_VERB_DIALOG_ITEM, _("Set object label")); } /* Retrieve the title */ GtkWidget *w = GTK_WIDGET(gtk_object_get_data(GTK_OBJECT(spw), "title")); gchar *title = (gchar *)gtk_entry_get_text(GTK_ENTRY (w)); if (obj->setTitle(title)) sp_document_done(SP_ACTIVE_DOCUMENT, SP_VERB_DIALOG_ITEM, _("Set object title")); /* Retrieve the description */ GtkTextView *tv = GTK_TEXT_VIEW(gtk_object_get_data(GTK_OBJECT(spw), "desc")); GtkTextBuffer *buf = gtk_text_view_get_buffer(tv); GtkTextIter start, end; gtk_text_buffer_get_bounds(buf, &start, &end); gchar *desc = gtk_text_buffer_get_text(buf, &start, &end, TRUE); if (obj->setDesc(desc)) sp_document_done(SP_ACTIVE_DOCUMENT, SP_VERB_DIALOG_ITEM, _("Set object description")); g_free(desc); gtk_object_set_data (GTK_OBJECT (spw), "blocked", GUINT_TO_POINTER (FALSE)); } // end of sp_item_widget_label_changed()
GtkWidget* file_properties_dlg_new( GtkWindow* parent, const char* dir_path, GList* sel_files, int page ) { GtkBuilder* builder = _gtk_builder_new_from_file( PACKAGE_UI_DIR "/file_properties.ui", NULL ); GtkWidget * dlg = (GtkWidget*)gtk_builder_get_object( builder, "dlg" ); GtkNotebook* notebook = (GtkNotebook*)gtk_builder_get_object( builder, "notebook" ); xset_set_window_icon( GTK_WINDOW( dlg ) ); FilePropertiesDialogData* data; gboolean need_calc_size = TRUE; VFSFileInfo *file, *file2; VFSMimeType* mime; const char* multiple_files = _( "( multiple files )" ); const char* calculating; GtkWidget* name = (GtkWidget*)gtk_builder_get_object( builder, "file_name" ); GtkWidget* label_name = (GtkWidget*)gtk_builder_get_object( builder, "label_filename" ); GtkWidget* location = (GtkWidget*)gtk_builder_get_object( builder, "location" ); gtk_editable_set_editable ( GTK_EDITABLE( location ), FALSE ); GtkWidget* target = (GtkWidget*)gtk_builder_get_object( builder, "target" ); GtkWidget* label_target = (GtkWidget*)gtk_builder_get_object( builder, "label_target" ); gtk_editable_set_editable ( GTK_EDITABLE( target ), FALSE ); GtkWidget* mime_type = (GtkWidget*)gtk_builder_get_object( builder, "mime_type" ); GtkWidget* open_with = (GtkWidget*)gtk_builder_get_object( builder, "open_with" ); char buf[ 64 ]; char buf2[ 32 ]; const char* time_format = "%Y-%m-%d %H:%M:%S"; gchar* disp_path; gchar* file_type; int i; GList* l; gboolean same_type = TRUE; gboolean is_dirs = FALSE; char *owner_group, *tmp; gtk_dialog_set_alternative_button_order( GTK_DIALOG(dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1 ); ptk_dialog_fit_small_screen( GTK_DIALOG(dlg) ); int width = xset_get_int( "app_dlg", "s" ); int height = xset_get_int( "app_dlg", "z" ); if ( width && height ) gtk_window_set_default_size( GTK_WINDOW( dlg ), width, -1 ); data = g_slice_new0( FilePropertiesDialogData ); /* FIXME: When will the data be freed??? */ g_object_set_data( G_OBJECT( dlg ), "DialogData", data ); data->file_list = sel_files; data->dlg = dlg; data->dir_path = g_strdup( dir_path ); disp_path = g_filename_display_name( dir_path ); //gtk_label_set_text( GTK_LABEL( location ), disp_path ); gtk_entry_set_text( GTK_ENTRY( location ), disp_path ); g_free( disp_path ); data->total_size_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "total_size" ) ); data->size_on_disk_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "size_on_disk" ) ); data->count_label = GTK_LABEL( (GtkWidget*)gtk_builder_get_object( builder, "count" ) ); data->owner = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "owner" ) ); data->group = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "group" ) ); data->mtime = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "mtime" ) ); data->atime = GTK_ENTRY( (GtkWidget*)gtk_builder_get_object( builder, "atime" ) ); for ( i = 0; i < N_CHMOD_ACTIONS; ++i ) { data->chmod_btns[ i ] = GTK_TOGGLE_BUTTON( (GtkWidget*)gtk_builder_get_object( builder, chmod_names[ i ] ) ); } //MOD VFSMimeType* type; VFSMimeType* type2 = NULL; for ( l = sel_files; l ; l = l->next ) { file = ( VFSFileInfo* ) l->data; type = vfs_file_info_get_mime_type( file ); if ( !type2 ) type2 = vfs_file_info_get_mime_type( file ); if ( vfs_file_info_is_dir( file ) ) is_dirs = TRUE; if ( type != type2 ) same_type = FALSE; vfs_mime_type_unref( type ); if ( is_dirs && !same_type ) break; } if ( type2 ) vfs_mime_type_unref( type2 ); data->recurse = (GtkWidget*)gtk_builder_get_object( builder, "recursive" ); gtk_widget_set_sensitive( data->recurse, is_dirs ); /* //MOD for ( l = sel_files; l && l->next; l = l->next ) { VFSMimeType *type, *type2; file = ( VFSFileInfo* ) l->data; file2 = ( VFSFileInfo* ) l->next->data; type = vfs_file_info_get_mime_type( file ); type2 = vfs_file_info_get_mime_type( file2 ); if ( type != type2 ) { vfs_mime_type_unref( type ); vfs_mime_type_unref( type2 ); same_type = FALSE; break; } vfs_mime_type_unref( type ); vfs_mime_type_unref( type2 ); } */ file = ( VFSFileInfo* ) sel_files->data; if ( same_type ) { mime = vfs_file_info_get_mime_type( file ); file_type = g_strdup_printf( "%s\n%s", vfs_mime_type_get_description( mime ), vfs_mime_type_get_type( mime ) ); gtk_label_set_text( GTK_LABEL( mime_type ), file_type ); g_free( file_type ); vfs_mime_type_unref( mime ); } else { gtk_label_set_text( GTK_LABEL( mime_type ), _( "( multiple types )" ) ); } /* Open with... * Don't show this option menu if files of different types are selected, * ,the selected file is a folder, or its type is unknown. */ if( ! same_type || vfs_file_info_is_desktop_entry( file ) || /* vfs_file_info_is_unknown_type( file ) || */ vfs_file_info_is_executable( file, NULL ) ) { /* if open with shouldn't show, destroy it. */ gtk_widget_destroy( open_with ); open_with = NULL; gtk_widget_destroy( (GtkWidget*)gtk_builder_get_object( builder, "open_with_label" ) ); } else /* Add available actions to the option menu */ { GtkTreeIter it; char **action, **actions; mime = vfs_file_info_get_mime_type( file ); actions = vfs_mime_type_get_actions( mime ); GtkCellRenderer* renderer; GtkListStore* model; gtk_cell_layout_clear( GTK_CELL_LAYOUT(open_with) ); renderer = gtk_cell_renderer_pixbuf_new(); gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(open_with), renderer, FALSE); gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT(open_with), renderer, "pixbuf", 0, NULL ); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(open_with), renderer, TRUE); gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT(open_with),renderer, "text", 1, NULL ); model = gtk_list_store_new( 3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); if( actions ) { for( action = actions; *action; ++action ) { VFSAppDesktop* desktop; GdkPixbuf* icon; desktop = vfs_app_desktop_new( *action ); gtk_list_store_append( model, &it ); icon = vfs_app_desktop_get_icon(desktop, 20, TRUE); gtk_list_store_set( model, &it, 0, icon, 1, vfs_app_desktop_get_disp_name(desktop), 2, *action, -1 ); if( icon ) g_object_unref( icon ); vfs_app_desktop_unref( desktop ); } } else { g_object_set_data( G_OBJECT(open_with), "prev_sel", GINT_TO_POINTER(-1) ); } /* separator */ gtk_list_store_append( model, &it ); gtk_list_store_append( model, &it ); gtk_list_store_set( model, &it, 0, NULL, 1, _("Choose..."), -1 ); gtk_combo_box_set_model( GTK_COMBO_BOX(open_with), GTK_TREE_MODEL(model) ); gtk_combo_box_set_row_separator_func( GTK_COMBO_BOX(open_with), combo_sep, NULL, NULL ); gtk_combo_box_set_active(GTK_COMBO_BOX(open_with), 0); g_signal_connect( open_with, "changed", G_CALLBACK(on_combo_change), mime ); /* vfs_mime_type_unref( mime ); */ /* We can unref mime when combo box gets destroyed */ g_object_weak_ref( G_OBJECT(open_with), (GWeakNotify)vfs_mime_type_unref, mime ); } g_object_set_data( G_OBJECT(dlg), "open_with", open_with ); /* Multiple files are selected */ if ( sel_files && sel_files->next ) { gtk_widget_set_sensitive( name, FALSE ); gtk_entry_set_text( GTK_ENTRY( name ), multiple_files ); data->orig_mtime = NULL; data->orig_atime = NULL; for ( i = 0; i < N_CHMOD_ACTIONS; ++i ) { gtk_toggle_button_set_inconsistent ( data->chmod_btns[ i ], TRUE ); data->chmod_states[ i ] = 2; /* Don't touch this bit */ g_signal_connect( G_OBJECT( data->chmod_btns[ i ] ), "toggled", G_CALLBACK( on_chmod_btn_toggled ), data ); } } else { /* special processing for files with special display names */ if( vfs_file_info_is_desktop_entry( file ) ) { char* disp_name = g_filename_display_name( file->name ); gtk_entry_set_text( GTK_ENTRY( name ), disp_name ); g_free( disp_name ); } else { if ( vfs_file_info_is_dir( file ) && !vfs_file_info_is_symlink( file ) ) gtk_label_set_markup_with_mnemonic( GTK_LABEL( label_name ), _("<b>Folder _Name:</b>") ); gtk_entry_set_text( GTK_ENTRY( name ), vfs_file_info_get_disp_name( file ) ); } gtk_editable_set_editable ( GTK_EDITABLE( name ), FALSE ); if ( ! vfs_file_info_is_dir( file ) ) { /* Only single "file" is selected, so we don't need to caculate total file size */ need_calc_size = FALSE; sprintf( buf, _("%s ( %lu bytes )"), vfs_file_info_get_disp_size( file ), ( guint64 ) vfs_file_info_get_size( file ) ); gtk_label_set_text( data->total_size_label, buf ); vfs_file_size_to_string( buf2, vfs_file_info_get_blocks( file ) * 512 ); sprintf( buf, _("%s ( %lu bytes )"), buf2, ( guint64 ) vfs_file_info_get_blocks( file ) * 512 ); gtk_label_set_text( data->size_on_disk_label, buf ); gtk_label_set_text( data->count_label, _("1 file") ); } // Modified / Accessed //gtk_entry_set_text( GTK_ENTRY( mtime ), // vfs_file_info_get_disp_mtime( file ) ); strftime( buf, sizeof( buf ), time_format, localtime( vfs_file_info_get_mtime( file ) ) ); gtk_entry_set_text( GTK_ENTRY( data->mtime ), buf ); data->orig_mtime = g_strdup( buf ); strftime( buf, sizeof( buf ), time_format, localtime( vfs_file_info_get_atime( file ) ) ); gtk_entry_set_text( GTK_ENTRY( data->atime ), buf ); data->orig_atime = g_strdup( buf ); // Permissions owner_group = (char *) vfs_file_info_get_disp_owner( file ); tmp = strchr( owner_group, ':' ); data->owner_name = g_strndup( owner_group, tmp - owner_group ); gtk_entry_set_text( GTK_ENTRY( data->owner ), data->owner_name ); data->group_name = g_strdup( tmp + 1 ); gtk_entry_set_text( GTK_ENTRY( data->group ), data->group_name ); for ( i = 0; i < N_CHMOD_ACTIONS; ++i ) { if ( data->chmod_states[ i ] != 2 ) /* allow to touch this bit */ { data->chmod_states[ i ] = ( vfs_file_info_get_mode( file ) & chmod_flags[ i ] ? 1 : 0 ); gtk_toggle_button_set_active( data->chmod_btns[ i ], data->chmod_states[ i ] ); } } // target if ( vfs_file_info_is_symlink( file ) ) { gtk_label_set_markup_with_mnemonic( GTK_LABEL( label_name ), _("<b>Link _Name:</b>") ); disp_path = g_build_filename( dir_path, file->name, NULL ); char* target_path = g_file_read_link( disp_path, NULL ); if ( target_path ) { gtk_entry_set_text( GTK_ENTRY( target ), target_path ); if ( target_path[0] && target_path[0] != '/' ) { // relative link to absolute char* str = target_path; target_path = g_build_filename( dir_path, str, NULL ); g_free( str ); } if ( !g_file_test( target_path, G_FILE_TEST_EXISTS ) ) gtk_label_set_text( GTK_LABEL( mime_type ), _("( broken link )") ); g_free( target_path ); } else gtk_entry_set_text( GTK_ENTRY( target ), _("( read link error )") ); g_free( disp_path ); gtk_widget_show( target ); gtk_widget_show( label_target ); } } if ( need_calc_size ) { /* The total file size displayed in "File Properties" is not completely calculated yet. So "Calculating..." is displayed. */ calculating = _( "Calculating..." ); gtk_label_set_text( data->total_size_label, calculating ); gtk_label_set_text( data->size_on_disk_label, calculating ); g_object_set_data( G_OBJECT( dlg ), "calc_size", data ); data->calc_size_thread = g_thread_create ( ( GThreadFunc ) calc_size, data, TRUE, NULL ); data->update_label_timer = g_timeout_add( 250, ( GSourceFunc ) on_update_labels, data ); } g_signal_connect( dlg, "response", G_CALLBACK(on_dlg_response), dlg ); g_signal_connect_swapped( gtk_builder_get_object(builder, "ok_button"), "clicked", G_CALLBACK(gtk_widget_destroy), dlg ); g_signal_connect_swapped( gtk_builder_get_object(builder, "cancel_button"), "clicked", G_CALLBACK(gtk_widget_destroy), dlg ); g_object_unref( builder ); gtk_notebook_set_current_page( notebook, page ); gtk_window_set_transient_for( GTK_WINDOW( dlg ), parent ); return dlg; }
void TextMenuItemAccelerator::setAccelerator(const std::string& newAccel) { if (_accel != NULL) { _accelLabelText = newAccel; gtk_label_set_markup_with_mnemonic(GTK_LABEL(_accel), newAccel.c_str()); } }