/****f* widget/gnoclConfigLinkButtonText * AUTHOR * PGB * SOURCE */ int gnoclConfigLinkButtonText ( Tcl_Interp *interp, GtkWidget *widget, Tcl_Obj *txtObj ) { GnoclStringType type = gnoclGetStringType ( txtObj ); if ( type & GNOCL_STR_STOCK ) { GtkStockItem sp; if ( gnoclGetStockItem ( txtObj, interp, &sp ) != TCL_OK ) return TCL_ERROR; gtk_button_set_label ( widget, sp.stock_id ); gtk_button_set_use_stock ( widget, 1 ); } else { GtkLabel *label; char *txt = gnoclGetString ( txtObj ); gtk_button_set_label ( widget, txt ); gtk_button_set_use_stock ( widget, 0 ); label = GTK_LABEL ( gnoclFindChild ( GTK_WIDGET ( widget ), GTK_TYPE_LABEL ) ); assert ( label ); /* TODO? pango_parse_markup for error message */ gtk_label_set_use_markup ( label, ( type & GNOCL_STR_MARKUP ) != 0 ); gtk_label_set_use_underline ( label, ( type & GNOCL_STR_UNDERLINE ) != 0 ); } return TCL_OK; }
/** * gtk_button_set_use_underline: * @button: a #GtkButton * @use_underline: %TRUE if underlines in the text indicate mnemonics * * If true, an underline in the text of the button label indicates * the next character should be used for the mnemonic accelerator key. */ void gtk_button_set_use_underline (GtkButton *button, gboolean use_underline) { GtkButtonPrivate *priv; g_return_if_fail (GTK_IS_BUTTON (button)); priv = button->priv; use_underline = use_underline != FALSE; if (use_underline != priv->use_underline) { if (priv->child_type == LABEL_CHILD) { GtkWidget *child; child = gtk_bin_get_child (GTK_BIN (button)); gtk_label_set_use_underline (GTK_LABEL (child), use_underline); gtk_label_set_mnemonic_widget (GTK_LABEL (child), GTK_WIDGET (button)); } priv->use_underline = use_underline; g_object_notify_by_pspec (G_OBJECT (button), props[PROP_USE_UNDERLINE]); } }
static void connect_proxy_cb (GtkActionGroup *action_group, GtkAction *action, GtkWidget *proxy, gpointer dummy) { GtkLabel *label; GIcon *icon; if (!GTK_IS_MENU_ITEM (proxy)) return; label = GTK_LABEL (gtk_bin_get_child (GTK_BIN (proxy))); gtk_label_set_use_underline (label, FALSE); gtk_label_set_ellipsize (label, PANGO_ELLIPSIZE_END); gtk_label_set_max_width_chars (label, MENU_ITEM_MAX_WIDTH_CHARS); icon = g_object_get_data (G_OBJECT (action), "menu-icon"); if (icon != NULL) { gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy), gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_MENU)); } }
/** * gtk_ellipsis_set_label: * @ellipsis: a #GtkEllipsis * @label: a string * * Sets the text of the label of the ellipsis to @label. * * This will also clear any previously set labels. * * Since: 2.4 **/ void gtk_ellipsis_set_label (GtkEllipsis *ellipsis, const gchar *label) { g_return_if_fail (GTK_IS_ELLIPSIS (ellipsis)); if (!label) { gtk_ellipsis_set_label_widget (ellipsis, NULL); } else { GtkWidget *child; child = gtk_label_new (label); gtk_label_set_line_wrap (GTK_LABEL (child), TRUE); gtk_label_set_line_wrap_mode (GTK_LABEL (child), ellipsis->priv->wrap_mode); gtk_label_set_use_underline (GTK_LABEL (child), ellipsis->priv->use_underline); gtk_label_set_use_markup (GTK_LABEL (child), ellipsis->priv->use_markup); gtk_widget_show (child); gtk_ellipsis_set_label_widget (ellipsis, child); } g_object_notify (G_OBJECT (ellipsis), "label"); }
/** * gtk_button_set_label: * @button: a #GtkButton * @label: a string * * Sets the text of the label of the button to @label. * * This will also clear any previously set labels. */ void gtk_button_set_label (GtkButton *button, const gchar *label) { GtkButtonPrivate *priv = gtk_button_get_instance_private (button); GtkWidget *child; GtkStyleContext *context; g_return_if_fail (GTK_IS_BUTTON (button)); context = gtk_widget_get_style_context (GTK_WIDGET (button)); child = gtk_bin_get_child (GTK_BIN (button)); if (priv->child_type != LABEL_CHILD || child == NULL) { if (child != NULL) gtk_container_remove (GTK_CONTAINER (button), child); child = gtk_label_new (NULL); if (priv->use_underline) { gtk_label_set_use_underline (GTK_LABEL (child), priv->use_underline); gtk_label_set_mnemonic_widget (GTK_LABEL (child), GTK_WIDGET (button)); } gtk_widget_show (child); gtk_container_add (GTK_CONTAINER (button), child); gtk_style_context_remove_class (context, "image-button"); gtk_style_context_add_class (context, "text-button"); } gtk_label_set_label (GTK_LABEL (child), label); gtk_button_set_child_type (button, LABEL_CHILD); g_object_notify_by_pspec (G_OBJECT (button), props[PROP_LABEL]); }
void GtkLabel_::set_use_underline(Php::Parameters ¶meters) { gboolean setting = (gboolean)parameters[0]; gtk_label_set_use_underline (GTK_LABEL(instance), setting); }
static void glade_gtk_menu_item_set_use_underline (GObject * object, const GValue * value) { GtkWidget *label; label = gtk_bin_get_child (GTK_BIN (object)); gtk_label_set_use_underline (GTK_LABEL (label), g_value_get_boolean (value)); }
static void set_item_text (GtkWidget *mi, const char *text) { gtk_label_set_text (GTK_LABEL (GTK_BIN (mi)->child), text); gtk_label_set_use_underline (GTK_LABEL (GTK_BIN (mi)->child), TRUE); }
static void set_item_text (GtkWidget *mi, const char *text) { GtkLabel *label; label = GTK_LABEL (gtk_bin_get_child (GTK_BIN (mi))); gtk_label_set_text (label, text); gtk_label_set_use_underline (label, TRUE); }
/** * set_category_description: * @self: a pointer to a GamesScoresDialog * @description: A description of the categories * * Sets the category description label. i.e. the widget to the * left of the category combo box. * **/ void games_scores_dialog_set_category_description (GamesScoresDialog *self, const gchar *description) { gchar *lstr; lstr = g_strdup_printf ("<b>%s</b>", description); gtk_label_set_markup (GTK_LABEL (self->priv->label), lstr); gtk_label_set_use_underline (GTK_LABEL (self->priv->label), TRUE); g_free(lstr); }
bool wxStaticText::SetFont( const wxFont &font ) { const bool wasUnderlined = GetFont().GetUnderlined(); const bool wasStrickenThrough = GetFont().GetStrikethrough(); bool ret = wxControl::SetFont(font); const bool isUnderlined = GetFont().GetUnderlined(); const bool isStrickenThrough = GetFont().GetStrikethrough(); if ( (isUnderlined != wasUnderlined) || (isStrickenThrough != wasStrickenThrough) ) { // We need to update the Pango attributes used for the text. if ( isUnderlined || isStrickenThrough ) { PangoAttrList* const attrs = pango_attr_list_new(); if ( isUnderlined ) { PangoAttribute *a = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE); a->start_index = 0; a->end_index = (guint)-1; pango_attr_list_insert(attrs, a); } if ( isStrickenThrough ) { PangoAttribute *a = pango_attr_strikethrough_new( TRUE ); a->start_index = 0; a->end_index = (guint) -1; pango_attr_list_insert(attrs, a); } gtk_label_set_attributes(GTK_LABEL(m_widget), attrs); pango_attr_list_unref(attrs); } else // No special attributes any more. { // Just remove any attributes we had set. gtk_label_set_attributes(GTK_LABEL(m_widget), NULL); } // The underlines for mnemonics are incompatible with using attributes // so turn them off when setting underlined font. gtk_label_set_use_underline(GTK_LABEL(m_widget), !isUnderlined); } // adjust the label size to the new label unless disabled if (!HasFlag(wxST_NO_AUTORESIZE)) { SetSize( GetBestSize() ); } return ret; }
static void proxy_set_use_underline (GtkWidget *proxy, gboolean use_underline) { g_return_if_fail (GTK_IS_WIDGET (proxy)); if (GTK_IS_MENU_ITEM (proxy) && GTK_BIN (proxy)->child && GTK_IS_LABEL (GTK_BIN (proxy)->child)) gtk_label_set_use_underline (GTK_LABEL (GTK_BIN (proxy)->child), use_underline); else if (GTK_IS_BUTTON (proxy)) gtk_button_set_use_underline (GTK_BUTTON (proxy), use_underline); }
GtkWidget * hard_drive_status_tile_new () { GtkWidget *tile; GtkWidget *image; GtkWidget *header; GtkWidget *subheader; AtkObject *accessible; char *name; image = gtk_image_new (); slab_load_image (GTK_IMAGE (image), GTK_ICON_SIZE_BUTTON, "utilities-system-monitor"); name = g_strdup (_("_System Monitor")); header = gtk_label_new (name); gtk_label_set_use_underline (GTK_LABEL (header), TRUE); gtk_misc_set_alignment (GTK_MISC (header), 0.0, 0.5); subheader = gtk_label_new (NULL); gtk_misc_set_alignment (GTK_MISC (subheader), 0.0, 0.5); gtk_widget_modify_fg (subheader, GTK_STATE_NORMAL, &subheader->style->fg[GTK_STATE_INSENSITIVE]); tile = g_object_new (HARD_DRIVE_STATUS_TILE_TYPE, "tile-uri", "tile://hard-drive-status", "nameplate-image", image, "nameplate-header", header, "nameplate-subheader", subheader, NULL); TILE (tile)->actions = g_new0 (TileAction *, 1); TILE (tile)->n_actions = 1; TILE (tile)->actions[HARD_DRIVE_STATUS_TILE_ACTION_OPEN] = tile_action_new (TILE (tile), open_hard_drive_tile, NULL, TILE_ACTION_OPENS_NEW_WINDOW); TILE (tile)->default_action = TILE (tile)->actions[HARD_DRIVE_STATUS_TILE_ACTION_OPEN]; g_signal_connect (G_OBJECT (tile), "hide", G_CALLBACK (tile_hide_event_cb), NULL); g_signal_connect (G_OBJECT (tile), "show", G_CALLBACK (tile_show_event_cb), NULL); accessible = gtk_widget_get_accessible (tile); atk_object_set_name (accessible, name); gtk_label_set_mnemonic_widget (GTK_LABEL (header), GTK_WIDGET (tile)); g_free (name); return GTK_WIDGET (tile); }
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 add_toolbar_constructor(MainWindow *mw, LttvToolbarClosure *toolbar_c) { LttvIAttribute *attributes = mw->attributes; LttvAttributeValue value; LttvToolbars * instance_toolbar; lttvwindow_viewer_constructor constructor; GtkWidget * tool_menu_title_menu, *new_widget, *pixmap; GdkPixbuf *pixbuf; gboolean retval; retval= lttv_iattribute_find_by_path(attributes, "viewers/toolbar", LTTV_POINTER, &value); g_assert(retval); if(*(value.v_pointer) == NULL) *(value.v_pointer) = lttv_toolbars_new(); instance_toolbar = (LttvToolbars*)*(value.v_pointer); constructor = toolbar_c->con; tool_menu_title_menu = lookup_widget(mw->mwindow,"MToolbar1"); pixbuf = gdk_pixbuf_new_from_xpm_data((const char**)toolbar_c->pixmap); pixmap = gtk_image_new_from_pixbuf(pixbuf); new_widget = gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu), GTK_TOOLBAR_CHILD_BUTTON, NULL, "", toolbar_c->tooltip, NULL, pixmap, NULL, NULL); gtk_label_set_use_underline( GTK_LABEL (((GtkToolbarChild*) ( g_list_last (GTK_TOOLBAR (tool_menu_title_menu)->children)->data))->label), TRUE); gtk_container_set_border_width (GTK_CONTAINER (new_widget), 1); g_signal_connect ((gpointer) new_widget, "clicked", G_CALLBACK (insert_viewer_wrap), constructor); gtk_widget_show (new_widget); lttv_toolbars_add(instance_toolbar, toolbar_c->con, toolbar_c->tooltip, toolbar_c->pixmap, new_widget); }
GtkWidget *createDialog(GtkWidget *window, GtkWidget *entry, const char *name, const char *message) { GtkWidget *dialog = gtk_dialog_new_with_buttons(l10n("Signing"), GTK_WINDOW(window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); setDialogProperties(dialog, window); GtkWidget* vbox = gtk_vbox_new(FALSE, 12); if (message && message[0]) { GtkWidget *messageLabel = gtk_label_new(NULL); char *markup = g_markup_printf_escaped("<span color='red'>%s</span>", message); gtk_label_set_markup(GTK_LABEL(messageLabel), markup); free(markup); gtk_container_add(GTK_CONTAINER(vbox), messageLabel); } GtkWidget *nameLabel = gtk_label_new(name); gtk_container_add(GTK_CONTAINER(vbox), nameLabel); gtk_misc_set_alignment(GTK_MISC(nameLabel), 0.0, 0.0); GtkWidget* hbox = gtk_hbox_new(FALSE, 12); gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE); gtk_entry_set_max_length(GTK_ENTRY(entry), 12); gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE); GtkWidget *label = gtk_label_new(l10n("Please enter PIN2:")); gtk_label_set_use_underline(GTK_LABEL(label), TRUE); gtk_label_set_mnemonic_widget(GTK_LABEL(label), entry); gtk_container_add(GTK_CONTAINER(hbox), label); gtk_container_add(GTK_CONTAINER(hbox), entry); gtk_container_add(GTK_CONTAINER(vbox), hbox); gtk_container_set_border_width(GTK_CONTAINER(vbox), 5); gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), vbox); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); gtk_container_set_border_width(GTK_CONTAINER(dialog), 5); gtk_widget_show_all(dialog); return dialog; }
static void connect_proxy_cb (GtkActionGroup *action_group, GtkAction *action, GtkWidget *proxy, gpointer dummy) { GtkLabel *label; if (!GTK_IS_MENU_ITEM (proxy)) return; label = GTK_LABEL (GTK_BIN (proxy)->child); gtk_label_set_use_underline (label, FALSE); gtk_label_set_ellipsize (label, PANGO_ELLIPSIZE_END); gtk_label_set_max_width_chars (label, MENU_ITEM_MAX_WIDTH_CHARS); }
/** \brief Description yet to be added. **/ static GtkWidget *getLabel ( Tcl_Interp *interp, Tcl_Obj *obj ) { const char *name = Tcl_GetString ( obj ); GtkWidget *widget = gnoclGetWidgetFromName ( name, NULL ); if ( widget == NULL ) { GnoclStringType type = gnoclGetStringType ( obj ); widget = gtk_label_new ( gnoclGetString ( obj ) ); gtk_label_set_use_markup ( GTK_LABEL ( widget ), ( type & GNOCL_STR_MARKUP ) != 0 ); gtk_label_set_use_underline ( GTK_LABEL ( widget ), ( type & GNOCL_STR_UNDERLINE ) != 0 ); } else if ( gnoclAssertNotPacked ( widget, interp, name ) ) return NULL; return widget; }
/** * gtk_ellipsis_set_use_underline: * @ellipsis: a #GtkEllipsis * @use_underline: %TRUE if underlines in the text indicate mnemonics * * If true, an underline in the text of the ellipsis label indicates * the next character should be used for the mnemonic accelerator key. * * Since: 2.4 **/ void gtk_ellipsis_set_use_underline (GtkEllipsis *ellipsis, gboolean use_underline) { GtkEllipsisPrivate *priv; g_return_if_fail (GTK_IS_ELLIPSIS (ellipsis)); priv = ellipsis->priv; use_underline = use_underline != FALSE; if (priv->use_underline != use_underline) { priv->use_underline = use_underline; if (priv->label && GTK_IS_LABEL (priv->label)) gtk_label_set_use_underline (GTK_LABEL (priv->label), use_underline); g_object_notify (G_OBJECT (ellipsis), "use-underline"); } }
/** * gtk_expander_set_use_underline: * @expander: a #GtkExpander * @use_underline: %TRUE if underlines in the text indicate mnemonics * * If true, an underline in the text of the expander label indicates * the next character should be used for the mnemonic accelerator key. * * Since: 2.4 **/ void gtk_expander_set_use_underline (GtkExpander *expander, gboolean use_underline) { GtkExpanderPrivate *priv; g_return_if_fail (GTK_IS_EXPANDER (expander)); priv = expander->priv; use_underline = use_underline != FALSE; if (priv->use_underline != use_underline) { priv->use_underline = use_underline; if (GTK_IS_LABEL (priv->label_widget)) gtk_label_set_use_underline (GTK_LABEL (priv->label_widget), use_underline); g_object_notify (G_OBJECT (expander), "use-underline"); } }
BOOL xwt_gtk_createMenu( PXWT_WIDGET xwtData ) { GtkWidget *menu, *bar_menu_item; PXWT_GTK_MENU widget; menu = gtk_menu_new(); bar_menu_item = gtk_menu_item_new(); g_object_ref( G_OBJECT(bar_menu_item)); // add a container to the window gtk_menu_item_set_submenu( GTK_MENU_ITEM(bar_menu_item), menu ); gtk_widget_show( bar_menu_item ); widget = (PXWT_GTK_MENU) hb_xgrab( sizeof( XWT_GTK_MENU) ); widget->INH(nId) = 0; widget->INH( fgColor ) = NULL; widget->INH( bgColor ) = NULL; widget->INH( textColor ) = NULL; widget->INH( baseColor ) = NULL; widget->INH(main_widget) = menu; widget->INH(top_widget) = menu_topwidget; widget->bar_item = bar_menu_item; widget->label = gtk_label_new(""); gtk_label_set_use_underline( GTK_LABEL(widget->label), TRUE ); gtk_container_add( GTK_CONTAINER( bar_menu_item ), widget->label ); gtk_widget_show( widget->label ); // no need for destructor, the data is just our widget for now xwtData->widget_data = (void *)widget; xwtData->destroy = xwt_gtk_menu_destroy; xwtData->set_property = xwt_gtk_menu_setprop; xwtData->set_pgroup = xwt_gtk_setpgroup; xwtData->get_property = xwt_gtk_menu_getprop; xwtData->get_all_properties = xwt_gtk_menu_getall; xwt_gtk_base_signal_connect( xwtData ); return TRUE; }
bool wxStaticText::SetFont( const wxFont &font ) { const bool wasUnderlined = GetFont().GetUnderlined(); bool ret = wxControl::SetFont(font); if ( font.GetUnderlined() != wasUnderlined ) { // the underlines for mnemonics are incompatible with using attributes // so turn them off when setting underlined font and restore them when // unsetting it gtk_label_set_use_underline(GTK_LABEL(m_widget), wasUnderlined); if ( wasUnderlined ) { // it's not underlined any more, remove the attributes we set gtk_label_set_attributes(GTK_LABEL(m_widget), NULL); } else // the text is underlined now { PangoAttrList *attrs = pango_attr_list_new(); PangoAttribute *a = pango_attr_underline_new(PANGO_UNDERLINE_SINGLE); a->start_index = 0; a->end_index = (guint)-1; pango_attr_list_insert(attrs, a); gtk_label_set_attributes(GTK_LABEL(m_widget), attrs); pango_attr_list_unref(attrs); } } // adjust the label size to the new label unless disabled if (!HasFlag(wxST_NO_AUTORESIZE)) { SetSize( GetBestSize() ); } return ret; }
/** * gtk_expander_set_label: * @expander: a #GtkExpander * @label: (allow-none): a string * * Sets the text of the label of the expander to @label. * * This will also clear any previously set labels. * * Since: 2.4 **/ void gtk_expander_set_label (GtkExpander *expander, const gchar *label) { g_return_if_fail (GTK_IS_EXPANDER (expander)); if (!label) { gtk_expander_set_label_widget (expander, NULL); } else { GtkWidget *child; child = gtk_label_new (label); gtk_label_set_use_underline (GTK_LABEL (child), expander->priv->use_underline); gtk_label_set_use_markup (GTK_LABEL (child), expander->priv->use_markup); gtk_widget_show (child); gtk_expander_set_label_widget (expander, child); } g_object_notify (G_OBJECT (expander), "label"); }
static void mateweather_pref_create(MateWeatherPref* pref) { GtkWidget* pref_vbox; GtkWidget* pref_notebook; #ifdef RADARMAP GtkWidget* radar_toggle_hbox; #endif /* RADARMAP */ GtkWidget* pref_basic_update_alignment; GtkWidget* pref_basic_update_lbl; GtkWidget* pref_basic_update_hbox; GObject* pref_basic_update_spin_adj; GtkWidget* pref_basic_update_sec_lbl; GtkWidget* pref_basic_note_lbl; GtkWidget* pref_loc_hbox; GtkWidget* pref_loc_note_lbl; GtkWidget* scrolled_window; GtkWidget* label; GtkWidget* value_hbox; GtkWidget* tree_label; GtkTreeSelection *selection; GtkWidget* pref_basic_vbox; GtkWidget* vbox; GtkWidget* frame; GtkWidget* temp_label; GtkWidget* temp_combo; GtkWidget* speed_label; GtkWidget* speed_combo; GtkWidget* pres_label; GtkWidget* pres_combo; GtkWidget* dist_label; GtkWidget* dist_combo; #if GTK_CHECK_VERSION (3, 0, 0) GtkWidget* unit_grid; #else GtkWidget* unit_table; #endif GtkWidget* pref_find_label; GtkWidget* pref_find_hbox; GtkWidget* image; g_object_set (pref, "destroy-with-parent", TRUE, NULL); gtk_window_set_title (GTK_WINDOW (pref), _("Weather Preferences")); gtk_dialog_add_buttons (GTK_DIALOG (pref), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL); gtk_dialog_set_default_response (GTK_DIALOG (pref), GTK_RESPONSE_CLOSE); gtk_container_set_border_width (GTK_CONTAINER (pref), 5); gtk_window_set_resizable (GTK_WINDOW (pref), TRUE); gtk_window_set_screen (GTK_WINDOW (pref), gtk_widget_get_screen (GTK_WIDGET (pref->priv->applet->applet))); pref_vbox = gtk_dialog_get_content_area (GTK_DIALOG (pref)); gtk_box_set_spacing (GTK_BOX (pref_vbox), 2); gtk_widget_show (pref_vbox); pref_notebook = gtk_notebook_new (); gtk_container_set_border_width (GTK_CONTAINER (pref_notebook), 5); gtk_widget_show (pref_notebook); gtk_box_pack_start (GTK_BOX (pref_vbox), pref_notebook, TRUE, TRUE, 0); /* * General settings page. */ #if GTK_CHECK_VERSION (3, 0, 0) pref_basic_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18); #else pref_basic_vbox = gtk_vbox_new (FALSE, 18); #endif gtk_container_set_border_width (GTK_CONTAINER (pref_basic_vbox), 12); gtk_container_add (GTK_CONTAINER (pref_notebook), pref_basic_vbox); pref_basic_update_alignment = gtk_alignment_new (0, 0.5, 0, 1); gtk_widget_show (pref_basic_update_alignment); pref->priv->basic_update_btn = gtk_check_button_new_with_mnemonic (_("_Automatically update every:")); gtk_widget_show (pref->priv->basic_update_btn); gtk_container_add (GTK_CONTAINER (pref_basic_update_alignment), pref->priv->basic_update_btn); g_signal_connect (G_OBJECT (pref->priv->basic_update_btn), "toggled", G_CALLBACK (auto_update_toggled), pref); if (!g_settings_is_writable (pref->priv->applet->settings, "auto-update")) { hard_set_sensitive (pref->priv->basic_update_btn, FALSE); } /* * Units settings page. */ /* Temperature Unit */ temp_label = gtk_label_new_with_mnemonic (_("_Temperature unit:")); gtk_label_set_use_markup (GTK_LABEL (temp_label), TRUE); gtk_label_set_justify (GTK_LABEL (temp_label), GTK_JUSTIFY_LEFT); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (label), 0.0); #else gtk_misc_set_alignment (GTK_MISC (temp_label), 0.0, 0.5); #endif gtk_widget_show (temp_label); temp_combo = gtk_combo_box_text_new (); pref->priv->basic_temp_combo = temp_combo; gtk_label_set_mnemonic_widget (GTK_LABEL (temp_label), temp_combo); //gtk_combo_box_append_text (GTK_COMBO_BOX (temp_combo), _("Default")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (temp_combo), _("Kelvin")); /* TRANSLATORS: Celsius is sometimes referred Centigrade */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (temp_combo), _("Celsius")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (temp_combo), _("Fahrenheit")); gtk_widget_show (temp_combo); if ( ! g_settings_is_writable (pref->priv->applet->settings, "temperature-unit")) { hard_set_sensitive (pref->priv->basic_temp_combo, FALSE); } /* Speed Unit */ speed_label = gtk_label_new_with_mnemonic (_("_Wind speed unit:")); gtk_label_set_use_markup (GTK_LABEL (speed_label), TRUE); gtk_label_set_justify (GTK_LABEL (speed_label), GTK_JUSTIFY_LEFT); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (label), 0.0); #else gtk_misc_set_alignment (GTK_MISC (speed_label), 0.0, 0.5); #endif gtk_widget_show (speed_label); speed_combo = gtk_combo_box_text_new (); pref->priv->basic_speed_combo = speed_combo; gtk_label_set_mnemonic_widget (GTK_LABEL (speed_label), speed_combo); //gtk_combo_box_append_text (GTK_COMBO_BOX (speed_combo), _("Default")); /* TRANSLATOR: The wind speed unit "meters per second" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speed_combo), _("m/s")); /* TRANSLATOR: The wind speed unit "kilometers per hour" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speed_combo), _("km/h")); /* TRANSLATOR: The wind speed unit "miles per hour" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speed_combo), _("mph")); /* TRANSLATOR: The wind speed unit "knots" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speed_combo), _("knots")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speed_combo), _("Beaufort scale")); gtk_widget_show (speed_combo); if (!g_settings_is_writable (pref->priv->applet->settings, "speed-unit")) { hard_set_sensitive (pref->priv->basic_speed_combo, FALSE); } /* Pressure Unit */ pres_label = gtk_label_new_with_mnemonic (_("_Pressure unit:")); gtk_label_set_use_markup (GTK_LABEL (pres_label), TRUE); gtk_label_set_justify (GTK_LABEL (pres_label), GTK_JUSTIFY_LEFT); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (label), 0.0); #else gtk_misc_set_alignment (GTK_MISC (pres_label), 0.0, 0.5); #endif gtk_widget_show (pres_label); pres_combo = gtk_combo_box_text_new (); pref->priv->basic_pres_combo = pres_combo; gtk_label_set_mnemonic_widget (GTK_LABEL (pres_label), pres_combo); //gtk_combo_box_append_text (GTK_COMBO_BOX (pres_combo), _("Default")); /* TRANSLATOR: The pressure unit "kiloPascals" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("kPa")); /* TRANSLATOR: The pressure unit "hectoPascals" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("hPa")); /* TRANSLATOR: The pressure unit "millibars" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("mb")); /* TRANSLATOR: The pressure unit "millibars of mercury" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("mmHg")); /* TRANSLATOR: The pressure unit "inches of mercury" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("inHg")); /* TRANSLATOR: The pressure unit "atmospheres" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("atm")); gtk_widget_show (pres_combo); if (!g_settings_is_writable(pref->priv->applet->settings, "pressure-unit")) { hard_set_sensitive(pref->priv->basic_pres_combo, FALSE); } /* Distance Unit */ dist_label = gtk_label_new_with_mnemonic (_("_Visibility unit:")); gtk_label_set_use_markup (GTK_LABEL (dist_label), TRUE); gtk_label_set_justify (GTK_LABEL (dist_label), GTK_JUSTIFY_LEFT); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (label), 0.0); #else gtk_misc_set_alignment (GTK_MISC (dist_label), 0, 0.5); #endif gtk_widget_show (dist_label); dist_combo = gtk_combo_box_text_new (); pref->priv->basic_dist_combo = dist_combo; gtk_label_set_mnemonic_widget (GTK_LABEL (dist_label), dist_combo); //gtk_combo_box_append_text (GTK_COMBO_BOX (dist_combo), _("Default")); /* TRANSLATOR: The distance unit "meters" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (dist_combo), _("meters")); /* TRANSLATOR: The distance unit "kilometers" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (dist_combo), _("km")); /* TRANSLATOR: The distance unit "miles" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (dist_combo), _("miles")); gtk_widget_show (dist_combo); if ( ! g_settings_is_writable (pref->priv->applet->settings, "distance-unit")) hard_set_sensitive (pref->priv->basic_dist_combo, FALSE); #if GTK_CHECK_VERSION (3, 0, 0) unit_grid = gtk_grid_new (); gtk_grid_set_row_spacing(GTK_GRID(unit_grid), 6); gtk_grid_set_column_spacing(GTK_GRID(unit_grid), 12); gtk_widget_set_halign (temp_label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(unit_grid), temp_label, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(unit_grid), temp_combo, 1, 0, 1, 1); gtk_widget_set_halign (speed_label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(unit_grid), speed_label, 0, 1, 1, 1); gtk_grid_attach(GTK_GRID(unit_grid), speed_combo, 1, 1, 1, 1); gtk_widget_set_halign (pres_label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(unit_grid), pres_label, 0, 2, 1, 1); gtk_grid_attach(GTK_GRID(unit_grid), pres_combo, 1, 2, 1, 1); gtk_widget_set_halign (dist_label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(unit_grid), dist_label, 0, 3, 1, 1); gtk_grid_attach(GTK_GRID(unit_grid), dist_combo, 1, 3, 1, 1); gtk_widget_show(unit_grid); #else unit_table = gtk_table_new(5, 2, FALSE); gtk_table_set_row_spacings(GTK_TABLE(unit_table), 6); gtk_table_set_col_spacings(GTK_TABLE(unit_table), 12); gtk_table_attach(GTK_TABLE(unit_table), temp_label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_table_attach_defaults(GTK_TABLE(unit_table), temp_combo, 1, 2, 0, 1); gtk_table_attach(GTK_TABLE(unit_table), speed_label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_table_attach_defaults(GTK_TABLE(unit_table), speed_combo, 1, 2, 1, 2); gtk_table_attach(GTK_TABLE(unit_table), pres_label, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_table_attach_defaults(GTK_TABLE(unit_table), pres_combo, 1, 2, 2, 3); gtk_table_attach(GTK_TABLE(unit_table), dist_label, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_table_attach_defaults(GTK_TABLE(unit_table), dist_combo, 1, 2, 3, 4); gtk_widget_show(unit_table); #endif g_signal_connect (temp_combo, "changed", G_CALLBACK (temp_combo_changed_cb), pref); g_signal_connect (speed_combo, "changed", G_CALLBACK (speed_combo_changed_cb), pref); g_signal_connect (dist_combo, "changed", G_CALLBACK (dist_combo_changed_cb), pref); g_signal_connect (pres_combo, "changed", G_CALLBACK (pres_combo_changed_cb), pref); #ifdef RADARMAP pref->priv->basic_radar_btn = gtk_check_button_new_with_mnemonic (_("Enable _radar map")); gtk_widget_show (pref->priv->basic_radar_btn); g_signal_connect (G_OBJECT (pref->priv->basic_radar_btn), "toggled", G_CALLBACK (radar_toggled), pref); if (!g_settings_is_writable (pref->priv->applet->settings, "enable-radar-map")) { hard_set_sensitive(pref->priv->basic_radar_btn, FALSE); } #if GTK_CHECK_VERSION (3, 0, 0) radar_toggle_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 12); #else radar_toggle_hbox = gtk_hbox_new(FALSE, 12); #endif gtk_widget_show(radar_toggle_hbox); label = gtk_label_new (" "); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (radar_toggle_hbox), label, FALSE, FALSE, 0); pref->priv->basic_radar_url_btn = gtk_check_button_new_with_mnemonic (_("Use _custom address for radar map")); gtk_widget_show (pref->priv->basic_radar_url_btn); gtk_box_pack_start (GTK_BOX (radar_toggle_hbox), pref->priv->basic_radar_url_btn, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (pref->priv->basic_radar_url_btn), "toggled", G_CALLBACK (use_radar_url_toggled), pref); if ( ! g_settings_is_writable (pref->priv->applet->settings, "use-custom-radar-url")) { hard_set_sensitive (pref->priv->basic_radar_url_btn, FALSE); } #if GTK_CHECK_VERSION (3, 0, 0) pref->priv->basic_radar_url_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); #else pref->priv->basic_radar_url_hbox = gtk_hbox_new (FALSE, 12); #endif gtk_widget_show (pref->priv->basic_radar_url_hbox); label = gtk_label_new (" "); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (pref->priv->basic_radar_url_hbox), label, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("A_ddress:")); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (pref->priv->basic_radar_url_hbox), label, FALSE, FALSE, 0); pref->priv->basic_radar_url_entry = gtk_entry_new (); gtk_widget_show (pref->priv->basic_radar_url_entry); gtk_box_pack_start (GTK_BOX (pref->priv->basic_radar_url_hbox), pref->priv->basic_radar_url_entry, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (pref->priv->basic_radar_url_entry), "focus_out_event", G_CALLBACK (radar_url_changed), pref); if ( ! g_settings_is_writable (pref->priv->applet->settings, "radar")) { hard_set_sensitive (pref->priv->basic_radar_url_entry, FALSE); } #endif /* RADARMAP */ #ifdef HAVE_LIBNOTIFY /* setup show-notifications button */ pref->priv->basic_show_notifications_btn = gtk_check_button_new_with_mnemonic (_("Show _notifications")); if (!g_settings_is_writable (pref->priv->applet->settings, "show-notifications")) { hard_set_sensitive (pref->priv->basic_show_notifications_btn, FALSE); } g_signal_connect (G_OBJECT (pref->priv->basic_show_notifications_btn), "toggled", G_CALLBACK (show_notifications_toggled), pref); #endif frame = create_hig_category (pref_basic_vbox, _("Update")); #if GTK_CHECK_VERSION (3, 0, 0) pref_basic_update_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); #else pref_basic_update_hbox = gtk_hbox_new (FALSE, 12); #endif pref_basic_update_lbl = gtk_label_new_with_mnemonic (_("_Automatically update every:")); gtk_widget_show (pref_basic_update_lbl); gtk_widget_show (pref_basic_update_hbox); pref_basic_update_spin_adj = gtk_adjustment_new (30, 1, 3600, 5, 25, 1); pref->priv->basic_update_spin = gtk_spin_button_new (GTK_ADJUSTMENT (pref_basic_update_spin_adj), 1, 0); gtk_widget_show (pref->priv->basic_update_spin); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (pref->priv->basic_update_spin), TRUE); gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (pref->priv->basic_update_spin), GTK_UPDATE_IF_VALID); g_signal_connect (G_OBJECT (pref->priv->basic_update_spin), "value_changed", G_CALLBACK (update_interval_changed), pref); pref_basic_update_sec_lbl = gtk_label_new (_("minutes")); gtk_widget_show (pref_basic_update_sec_lbl); if ( ! g_settings_is_writable (pref->priv->applet->settings, "auto-update-interval")) { hard_set_sensitive (pref->priv->basic_update_spin, FALSE); hard_set_sensitive (pref_basic_update_sec_lbl, FALSE); } #if GTK_CHECK_VERSION (3, 0, 0) value_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); #else value_hbox = gtk_hbox_new (FALSE, 6); #endif gtk_box_pack_start (GTK_BOX (pref_basic_update_hbox), pref_basic_update_alignment, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (pref_basic_update_hbox), value_hbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (value_hbox), pref->priv->basic_update_spin, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (value_hbox), pref_basic_update_sec_lbl, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (frame), pref_basic_update_hbox); frame = create_hig_category (pref_basic_vbox, _("Display")); #if GTK_CHECK_VERSION (3, 0, 0) vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); #else vbox = gtk_vbox_new (FALSE, 6); #endif #if GTK_CHECK_VERSION (3, 0, 0) gtk_box_pack_start (GTK_BOX (vbox), unit_grid, TRUE, TRUE, 0); #else gtk_box_pack_start (GTK_BOX (vbox), unit_table, TRUE, TRUE, 0); #endif #ifdef RADARMAP gtk_box_pack_start (GTK_BOX (vbox), pref->priv->basic_radar_btn, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), radar_toggle_hbox, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), pref->priv->basic_radar_url_hbox, TRUE, TRUE, 0); #endif /* RADARMAP */ #ifdef HAVE_LIBNOTIFY /* add the show-notification toggle button to the vbox of the display section */ gtk_box_pack_start (GTK_BOX (vbox), pref->priv->basic_show_notifications_btn, TRUE, TRUE, 0); #endif gtk_container_add (GTK_CONTAINER (frame), vbox); pref_basic_note_lbl = gtk_label_new (_("General")); gtk_widget_show (pref_basic_note_lbl); gtk_notebook_set_tab_label (GTK_NOTEBOOK (pref_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (pref_notebook), 0), pref_basic_note_lbl); /* * Location page. */ #if GTK_CHECK_VERSION (3, 0, 0) pref_loc_hbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); #else pref_loc_hbox = gtk_vbox_new (FALSE, 6); #endif gtk_container_set_border_width (GTK_CONTAINER (pref_loc_hbox), 12); gtk_container_add (GTK_CONTAINER (pref_notebook), pref_loc_hbox); tree_label = gtk_label_new_with_mnemonic (_("_Select a location:")); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (tree_label), 0.0); #else gtk_misc_set_alignment (GTK_MISC (tree_label), 0.0, 0.5); #endif gtk_box_pack_start (GTK_BOX (pref_loc_hbox), tree_label, FALSE, FALSE, 0); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); pref->priv->tree = gtk_tree_view_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (tree_label), GTK_WIDGET (pref->priv->tree)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (pref->priv->tree), FALSE); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (pref->priv->tree)); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (row_selected_cb), pref); gtk_container_add (GTK_CONTAINER (scrolled_window), pref->priv->tree); gtk_widget_show (pref->priv->tree); gtk_widget_show (scrolled_window); gtk_box_pack_start (GTK_BOX (pref_loc_hbox), scrolled_window, TRUE, TRUE, 0); load_locations(pref); #if GTK_CHECK_VERSION (3, 0, 0) pref_find_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); #else pref_find_hbox = gtk_hbox_new (FALSE, 6); #endif pref_find_label = gtk_label_new (_("_Find:")); gtk_label_set_use_underline (GTK_LABEL (pref_find_label), TRUE); pref->priv->find_entry = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (pref_find_label), pref->priv->find_entry); pref->priv->find_next_btn = gtk_button_new_with_mnemonic (_("Find _Next")); gtk_widget_set_sensitive (pref->priv->find_next_btn, FALSE); image = gtk_image_new_from_stock (GTK_STOCK_FIND, GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (pref->priv->find_next_btn), image); g_signal_connect (G_OBJECT (pref->priv->find_next_btn), "clicked", G_CALLBACK (find_next_clicked), pref); g_signal_connect (G_OBJECT (pref->priv->find_entry), "changed", G_CALLBACK (find_entry_changed), pref); gtk_container_set_border_width (GTK_CONTAINER (pref_find_hbox), 0); gtk_box_pack_start (GTK_BOX (pref_find_hbox), pref_find_label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (pref_find_hbox), pref->priv->find_entry, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (pref_find_hbox), pref->priv->find_next_btn, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (pref_loc_hbox), pref_find_hbox, FALSE, FALSE, 0); if ( ! g_settings_is_writable (pref->priv->applet->settings, "location0")) { hard_set_sensitive (scrolled_window, FALSE); } pref_loc_note_lbl = gtk_label_new (_("Location")); gtk_widget_show (pref_loc_note_lbl); gtk_notebook_set_tab_label (GTK_NOTEBOOK (pref_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (pref_notebook), 1), pref_loc_note_lbl); g_signal_connect (G_OBJECT (pref), "response", G_CALLBACK (response_cb), pref); mateweather_pref_set_accessibility (pref); gtk_label_set_mnemonic_widget (GTK_LABEL (pref_basic_update_sec_lbl), pref->priv->basic_update_spin); gtk_label_set_mnemonic_widget (GTK_LABEL (label), pref->priv->basic_radar_url_entry); }
static void brasero_project_type_chooser_build_recent (BraseroProjectTypeChooser *self, GtkRecentManager *recent) { GtkSizeGroup *image_group; GtkSizeGroup *group; GList *list = NULL; gchar *filename; GList *recents; GList *iter; recents = gtk_recent_manager_get_items (recent); for (iter = recents; iter; iter = iter->next) { GtkRecentInfo *info; const gchar *mime; info = iter->data; mime = gtk_recent_info_get_mime_type (info); if (!mime) continue; /* filter those we want */ if (strcmp (mime, "application/x-brasero") && strcmp (mime, "application/x-cd-image") && strcmp (mime, "application/x-cdrdao-toc") && strcmp (mime, "application/x-toc") && strcmp (mime, "application/x-cue") && strcmp (mime, "audio/x-scpls") && strcmp (mime, "audio/x-ms-asx") && strcmp (mime, "audio/x-mp3-playlist") && strcmp (mime, "audio/x-mpegurl")) continue; /* sort */ list = g_list_insert_sorted (list, info, brasero_project_type_chooser_sort_recent); if (g_list_length (list) > 5) list = g_list_delete_link (list, g_list_last (list)); } group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH); image_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH); /* If a project was left unfinished last time then add another entry */ filename = g_build_filename (g_get_user_config_dir (), "brasero", BRASERO_SESSION_TMP_PROJECT_PATH, NULL); if (g_file_test (filename, G_FILE_TEST_EXISTS)) { gchar *uri; GtkWidget *link; GtkWidget *image; uri = g_filename_to_uri (filename, NULL, NULL); image = gtk_image_new_from_icon_name ("brasero", GTK_ICON_SIZE_BUTTON); gtk_size_group_add_widget (image_group, image); link = gtk_button_new_with_label (_("Last _Unsaved Project")); g_object_set_data_full (G_OBJECT (link), "BraseroButtonURI", uri, g_free); gtk_button_set_relief (GTK_BUTTON (link), GTK_RELIEF_NONE); gtk_button_set_alignment (GTK_BUTTON (link), 0.0, 0.5); gtk_button_set_focus_on_click (GTK_BUTTON (link), FALSE); gtk_button_set_image (GTK_BUTTON (link), image); gtk_button_set_use_underline (GTK_BUTTON (link), TRUE); g_signal_connect (link, "clicked", G_CALLBACK (brasero_project_type_chooser_last_unsaved_clicked_cb), self); gtk_widget_show (link); gtk_widget_set_tooltip_text (link, _("Load the last project that was not burned and not saved")); gtk_box_pack_start (GTK_BOX (self->priv->recent_box), link, FALSE, TRUE, 0); gtk_size_group_add_widget (group, link); } g_free (filename); for (iter = list; iter; iter = iter->next) { GtkRecentInfo *info; GList *child_iter; const gchar *name; GIcon *icon; GtkWidget *image; const gchar *uri; GtkWidget *child; GtkWidget *link; GList *children; gchar *tooltip; info = iter->data; tooltip = gtk_recent_info_get_uri_display (info); icon = gtk_recent_info_get_gicon (info); image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_BUTTON); g_object_unref (icon); gtk_size_group_add_widget (image_group, image); gtk_widget_show (image); gtk_widget_set_tooltip_text (image, tooltip); name = gtk_recent_info_get_display_name (info); uri = gtk_recent_info_get_uri (info); /* Don't use mnemonics with filenames */ link = gtk_button_new_with_label (name); g_object_set_data_full (G_OBJECT (link), "BraseroButtonURI", g_strdup (uri), g_free); gtk_button_set_relief (GTK_BUTTON (link), GTK_RELIEF_NONE); gtk_button_set_image (GTK_BUTTON (link), image); gtk_button_set_alignment (GTK_BUTTON (link), 0.0, 0.5); gtk_button_set_focus_on_click (GTK_BUTTON (link), FALSE); g_signal_connect (link, "clicked", G_CALLBACK (brasero_project_type_chooser_recent_clicked_cb), self); gtk_widget_show (link); gtk_widget_set_tooltip_text (link, tooltip); gtk_box_pack_start (GTK_BOX (self->priv->recent_box), link, FALSE, TRUE, 0); g_free (tooltip); gtk_size_group_add_widget (group, link); /* That's a tedious hack to avoid mnemonics which are hardcoded * when you add an image to a button. BUG? */ if (!GTK_IS_BIN (link)) continue; child = gtk_bin_get_child (GTK_BIN (link)); if (!GTK_IS_ALIGNMENT (child)) continue; gtk_alignment_set (GTK_ALIGNMENT (child), 0.0, 0.5, 1.0, 1.0); child = gtk_bin_get_child (GTK_BIN (child)); if (!GTK_IS_BOX (child)) continue; children = gtk_container_get_children (GTK_CONTAINER (child)); for (child_iter = children; child_iter; child_iter = child_iter->next) { GtkWidget *widget; widget = child_iter->data; if (GTK_IS_LABEL (widget)) { gtk_label_set_use_underline (GTK_LABEL (widget), FALSE); gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5); /* Make sure that the name is not too long */ gtk_box_set_child_packing (GTK_BOX (child), widget, TRUE, TRUE, 0, GTK_PACK_START); gtk_label_set_ellipsize (GTK_LABEL (widget), PANGO_ELLIPSIZE_END); break; } } g_list_free (children); } g_object_unref (image_group); g_object_unref (group); if (!g_list_length (list)) { GtkWidget *label; gchar *string; string = g_strdup_printf ("<i>%s</i>", _("No recently used project")); label = gtk_label_new (string); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); g_free (string); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (self->priv->recent_box), label, FALSE, FALSE, 0); } g_list_free (list); g_list_foreach (recents, (GFunc) gtk_recent_info_unref, NULL); g_list_free (recents); }
GtkWidget* create_window1 (void) { GtkWidget *window1; GtkWidget *vbox1; GtkWidget *menubar1; GtkWidget *menuitem1; GtkWidget *menu1; GtkWidget *new1; GtkWidget *open1; GtkWidget *save1; GtkWidget *save_as1; GtkWidget *separatormenuitem1; GtkWidget *quit1; GtkWidget *menuitem2; GtkWidget *menu2; GtkWidget *cut1; GtkWidget *copy1; GtkWidget *paste1; GtkWidget *delete1; GtkWidget *menuitem3; GtkWidget *menu3; GtkWidget *menuitem4; GtkWidget *menu4; GtkWidget *about1; GtkWidget *handlebox1; GtkWidget *toolbar1; GtkWidget *tmp_toolbar_icon; GtkWidget *button1; GtkWidget *button2; GtkWidget *button3; GtkWidget *hscale1; GtkWidget *statusbar1; GtkAccelGroup *accel_group; accel_group = gtk_accel_group_new (); window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window1), _("window1")); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (window1), vbox1); menubar1 = gtk_menu_bar_new (); gtk_widget_show (menubar1); gtk_box_pack_start (GTK_BOX (vbox1), menubar1, FALSE, FALSE, 0); menuitem1 = gtk_menu_item_new_with_mnemonic (_("_File")); gtk_widget_show (menuitem1); gtk_container_add (GTK_CONTAINER (menubar1), menuitem1); menu1 = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem1), menu1); new1 = gtk_image_menu_item_new_from_stock ("gtk-new", accel_group); gtk_widget_show (new1); gtk_container_add (GTK_CONTAINER (menu1), new1); open1 = gtk_image_menu_item_new_from_stock ("gtk-open", accel_group); gtk_widget_show (open1); gtk_container_add (GTK_CONTAINER (menu1), open1); save1 = gtk_image_menu_item_new_from_stock ("gtk-save", accel_group); gtk_widget_show (save1); gtk_container_add (GTK_CONTAINER (menu1), save1); save_as1 = gtk_image_menu_item_new_from_stock ("gtk-save-as", accel_group); gtk_widget_show (save_as1); gtk_container_add (GTK_CONTAINER (menu1), save_as1); separatormenuitem1 = gtk_separator_menu_item_new (); gtk_widget_show (separatormenuitem1); gtk_container_add (GTK_CONTAINER (menu1), separatormenuitem1); gtk_widget_set_sensitive (separatormenuitem1, FALSE); quit1 = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group); gtk_widget_show (quit1); gtk_container_add (GTK_CONTAINER (menu1), quit1); menuitem2 = gtk_menu_item_new_with_mnemonic (_("_Edit")); gtk_widget_show (menuitem2); gtk_container_add (GTK_CONTAINER (menubar1), menuitem2); menu2 = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem2), menu2); cut1 = gtk_image_menu_item_new_from_stock ("gtk-cut", accel_group); gtk_widget_show (cut1); gtk_container_add (GTK_CONTAINER (menu2), cut1); copy1 = gtk_image_menu_item_new_from_stock ("gtk-copy", accel_group); gtk_widget_show (copy1); gtk_container_add (GTK_CONTAINER (menu2), copy1); paste1 = gtk_image_menu_item_new_from_stock ("gtk-paste", accel_group); gtk_widget_show (paste1); gtk_container_add (GTK_CONTAINER (menu2), paste1); delete1 = gtk_image_menu_item_new_from_stock ("gtk-delete", accel_group); gtk_widget_show (delete1); gtk_container_add (GTK_CONTAINER (menu2), delete1); menuitem3 = gtk_menu_item_new_with_mnemonic (_("_View")); gtk_widget_show (menuitem3); gtk_container_add (GTK_CONTAINER (menubar1), menuitem3); menu3 = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem3), menu3); menuitem4 = gtk_menu_item_new_with_mnemonic (_("_Help")); gtk_widget_show (menuitem4); gtk_container_add (GTK_CONTAINER (menubar1), menuitem4); menu4 = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem4), menu4); about1 = gtk_menu_item_new_with_mnemonic (_("_About")); gtk_widget_show (about1); gtk_container_add (GTK_CONTAINER (menu4), about1); handlebox1 = gtk_handle_box_new (); gtk_widget_show (handlebox1); gtk_box_pack_start (GTK_BOX (vbox1), handlebox1, FALSE, TRUE, 0); toolbar1 = gtk_toolbar_new (); gtk_widget_show (toolbar1); gtk_container_add (GTK_CONTAINER (handlebox1), toolbar1); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar1), GTK_TOOLBAR_BOTH); tmp_toolbar_icon = gtk_image_new_from_stock ("gtk-open", gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar1))); button1 = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, _("button1"), NULL, NULL, tmp_toolbar_icon, NULL, NULL); gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (toolbar1)->children)->data))->label), TRUE); gtk_widget_show (button1); tmp_toolbar_icon = gtk_image_new_from_stock ("gtk-cdrom", gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar1))); button2 = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, _("button2"), NULL, NULL, tmp_toolbar_icon, NULL, NULL); gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (toolbar1)->children)->data))->label), TRUE); gtk_widget_show (button2); tmp_toolbar_icon = gtk_image_new_from_stock ("gtk-refresh", gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar1))); button3 = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, _("button3"), NULL, NULL, tmp_toolbar_icon, NULL, NULL); gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (toolbar1)->children)->data))->label), TRUE); gtk_widget_show (button3); hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 0, 0, 0, 0))); gtk_widget_show (hscale1); gtk_box_pack_start (GTK_BOX (vbox1), hscale1, TRUE, TRUE, 0); statusbar1 = gtk_statusbar_new (); gtk_widget_show (statusbar1); gtk_box_pack_start (GTK_BOX (vbox1), statusbar1, FALSE, FALSE, 0); g_signal_connect ((gpointer) new1, "activate", G_CALLBACK (on_new1_activate), NULL); g_signal_connect ((gpointer) open1, "activate", G_CALLBACK (on_open1_activate), NULL); g_signal_connect ((gpointer) save1, "activate", G_CALLBACK (on_save1_activate), NULL); g_signal_connect ((gpointer) save_as1, "activate", G_CALLBACK (on_save_as1_activate), NULL); g_signal_connect ((gpointer) quit1, "activate", G_CALLBACK (on_quit1_activate), NULL); g_signal_connect ((gpointer) cut1, "activate", G_CALLBACK (on_cut1_activate), NULL); g_signal_connect ((gpointer) copy1, "activate", G_CALLBACK (on_copy1_activate), NULL); g_signal_connect ((gpointer) paste1, "activate", G_CALLBACK (on_paste1_activate), NULL); g_signal_connect ((gpointer) delete1, "activate", G_CALLBACK (on_delete1_activate), NULL); g_signal_connect ((gpointer) about1, "activate", G_CALLBACK (on_about1_activate), NULL); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (window1, window1, "window1"); GLADE_HOOKUP_OBJECT (window1, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (window1, menubar1, "menubar1"); GLADE_HOOKUP_OBJECT (window1, menuitem1, "menuitem1"); GLADE_HOOKUP_OBJECT (window1, menu1, "menu1"); GLADE_HOOKUP_OBJECT (window1, new1, "new1"); GLADE_HOOKUP_OBJECT (window1, open1, "open1"); GLADE_HOOKUP_OBJECT (window1, save1, "save1"); GLADE_HOOKUP_OBJECT (window1, save_as1, "save_as1"); GLADE_HOOKUP_OBJECT (window1, separatormenuitem1, "separatormenuitem1"); GLADE_HOOKUP_OBJECT (window1, quit1, "quit1"); GLADE_HOOKUP_OBJECT (window1, menuitem2, "menuitem2"); GLADE_HOOKUP_OBJECT (window1, menu2, "menu2"); GLADE_HOOKUP_OBJECT (window1, cut1, "cut1"); GLADE_HOOKUP_OBJECT (window1, copy1, "copy1"); GLADE_HOOKUP_OBJECT (window1, paste1, "paste1"); GLADE_HOOKUP_OBJECT (window1, delete1, "delete1"); GLADE_HOOKUP_OBJECT (window1, menuitem3, "menuitem3"); GLADE_HOOKUP_OBJECT (window1, menu3, "menu3"); GLADE_HOOKUP_OBJECT (window1, menuitem4, "menuitem4"); GLADE_HOOKUP_OBJECT (window1, menu4, "menu4"); GLADE_HOOKUP_OBJECT (window1, about1, "about1"); GLADE_HOOKUP_OBJECT (window1, handlebox1, "handlebox1"); GLADE_HOOKUP_OBJECT (window1, toolbar1, "toolbar1"); GLADE_HOOKUP_OBJECT (window1, button1, "button1"); GLADE_HOOKUP_OBJECT (window1, button2, "button2"); GLADE_HOOKUP_OBJECT (window1, button3, "button3"); GLADE_HOOKUP_OBJECT (window1, hscale1, "hscale1"); GLADE_HOOKUP_OBJECT (window1, statusbar1, "statusbar1"); gtk_window_add_accel_group (GTK_WINDOW (window1), accel_group); return window1; }
/* * Sets the properties of the widget. This is used for both applying the * properties changed in the property editor, and also for loading. */ void gb_label_set_standard_properties (GtkWidget * widget, GbWidgetSetArgData * data, const char *label_p, const char *use_underline_p, const char *use_markup_p, const char *justify_p, const char *wrap_p, const char *selectable_p, const char *xalign_p, const char *yalign_p, const char *xpad_p, const char *ypad_p, const char *focus_target_p) { gchar *label, *justify, *accel_target; const gchar *label_text; gfloat xalign, yalign; gint xpad, ypad, i; gboolean wrap, selectable, set_alignment = FALSE, set_padding = FALSE; gboolean use_underline, use_markup; gboolean set_label = FALSE; use_underline = gb_widget_input_bool (data, use_underline_p); if (data->apply) gtk_label_set_use_underline (GTK_LABEL (widget), use_underline); use_markup = gb_widget_input_bool (data, use_markup_p); if (data->apply) { set_label = TRUE; gtk_object_set_data (GTK_OBJECT (widget), use_markup_p, GINT_TO_POINTER (use_markup)); } label = gb_widget_input_text (data, label_p); if (data->apply) { set_label = TRUE; label_text = label; } else { label_text = gtk_label_get_label (GTK_LABEL (widget)); } if (set_label) { gboolean prev_use_markup; use_markup = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget), use_markup_p)); /* We try to parse the markup here, and if it isn't valid, we will turn use_markup off and show it as plain text. */ if (use_markup) { GError *error = NULL; gunichar accel_marker = 0; PangoAttrList *attrs = NULL; gunichar accel_char = 0; gchar *text = NULL; if (gtk_label_get_use_underline (GTK_LABEL (widget))) accel_marker = '_'; /* We check it is valid markup. If it isn't we will set "use_markup" to FALSE. Note that we don't need attrs, text, or accel_char but it seems to crash otherwise. */ if (!pango_parse_markup (label_text, -1, accel_marker, &attrs, &text, &accel_char, &error)) { use_markup = FALSE; g_error_free (error); } else { if (attrs) pango_attr_list_unref (attrs); g_free (text); } } /* If we are turning use_markup off, we want to do that before setting the text. If we are turning it on, we want to do it after. */ prev_use_markup = gtk_label_get_use_markup (GTK_LABEL (widget)); if (!use_markup && prev_use_markup) gtk_label_set_use_markup (GTK_LABEL (widget), use_markup); gtk_label_set_label (GTK_LABEL (widget), label_text); if (use_markup && !prev_use_markup) gtk_label_set_use_markup (GTK_LABEL (widget), use_markup); } if (data->action == GB_APPLYING) g_free (label); justify = gb_widget_input_choice (data, justify_p); if (data->apply) { for (i = 0; i < sizeof (GbJustifyValues) / sizeof (GbJustifyValues[0]); i++) { if (!strcmp (justify, GbJustifyChoices[i]) || !strcmp (justify, GbJustifySymbols[i])) { gtk_label_set_justify (GTK_LABEL (widget), GbJustifyValues[i]); break; } } } wrap = gb_widget_input_bool (data, wrap_p); if (data->apply) gtk_label_set_line_wrap (GTK_LABEL (widget), wrap); selectable = gb_widget_input_bool (data, selectable_p); if (data->apply) gtk_label_set_selectable (GTK_LABEL (widget), selectable); xalign = gb_widget_input_float (data, xalign_p); if (data->apply) set_alignment = TRUE; else xalign = GTK_MISC (widget)->xalign; yalign = gb_widget_input_float (data, yalign_p); if (data->apply) set_alignment = TRUE; else yalign = GTK_MISC (widget)->yalign; if (set_alignment) gtk_misc_set_alignment (GTK_MISC (widget), xalign, yalign); xpad = gb_widget_input_int (data, xpad_p); if (data->apply) set_padding = TRUE; else xpad = GTK_MISC (widget)->xpad; ypad = gb_widget_input_int (data, ypad_p); if (data->apply) set_padding = TRUE; else ypad = GTK_MISC (widget)->ypad; if (set_padding) gtk_misc_set_padding (GTK_MISC (widget), xpad, ypad); /* Labels not in buttons may have a focus target widget. */ accel_target = gb_widget_input_combo (data, focus_target_p); if (data->apply) { if (!gb_label_find_mnemonic_widget (widget)) { if (!strcmp (accel_target, _("Auto"))) accel_target = NULL; gtk_object_set_data_full (GTK_OBJECT (widget), focus_target_p, g_strdup (accel_target), accel_target ? g_free : NULL); } } }
void dlg_sort_order (GthBrowser *browser) { DialogData *data; GtkListStore *selection_model; GtkCellRenderer *renderer; GthFileData *file_data; GList *sort_types; GList *scan; GthFileDataSort *current_sort_type; gboolean sort_inverse; int i, i_active; if (gth_browser_get_dialog (browser, "sort-order") != NULL) { gtk_window_present (GTK_WINDOW (gth_browser_get_dialog (browser, "sort-order"))); return; } data = g_new0 (DialogData, 1); data->browser = browser; data->builder = _gtk_builder_new_from_file ("sort-order.ui", NULL); /* Get the widgets. */ data->dialog = _gtk_builder_get_widget (data->builder, "sort_order_dialog"); gth_browser_set_dialog (browser, "sort-order", data->dialog); g_object_set_data (G_OBJECT (data->dialog), "dialog_data", data); /* Set widgets data. */ selection_model = gtk_list_store_new (2, G_TYPE_POINTER, G_TYPE_STRING); data->sort_by_combobox = gtk_combo_box_new_with_model (GTK_TREE_MODEL (selection_model)); g_object_unref (selection_model); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->sort_by_combobox), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (data->sort_by_combobox), renderer, "text", SELECTION_COLUMN_NAME, NULL); file_data = gth_browser_get_location_data (data->browser); if (file_data != NULL) { current_sort_type = gth_main_get_sort_type (g_file_info_get_attribute_string (file_data->info, "sort::type")); sort_inverse = g_file_info_get_attribute_boolean (file_data->info, "sort::inverse"); } else gth_browser_get_sort_order (data->browser, ¤t_sort_type, &sort_inverse); sort_types = gth_main_get_all_sort_types (); for (i = 0, i_active = 0, scan = sort_types; scan; scan = scan->next, i++) { GthFileDataSort *sort_type = scan->data; GtkTreeIter iter; if (strcmp (sort_type->name, current_sort_type->name) == 0) i_active = i; gtk_list_store_append (selection_model, &iter); gtk_list_store_set (selection_model, &iter, SELECTION_COLUMN_DATA, sort_type, SELECTION_COLUMN_NAME, _(sort_type->display_name), -1); } g_list_free (sort_types); gtk_combo_box_set_active (GTK_COMBO_BOX (data->sort_by_combobox), i_active); gtk_widget_show (data->sort_by_combobox); gtk_container_add (GTK_CONTAINER (GET_WIDGET ("sort_by_hbox")), data->sort_by_combobox); gtk_label_set_use_underline (GTK_LABEL (GET_WIDGET ("sort_by_label")), TRUE); gtk_label_set_mnemonic_widget (GTK_LABEL (GET_WIDGET ("sort_by_label")), data->sort_by_combobox); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("inverse_checkbutton")), sort_inverse); /* Set the signals handlers. */ g_signal_connect (G_OBJECT (data->dialog), "destroy", G_CALLBACK (destroy_cb), data); g_signal_connect_swapped (GET_WIDGET ("close_button"), "clicked", G_CALLBACK (gtk_widget_destroy), G_OBJECT (data->dialog)); g_signal_connect (GET_WIDGET ("inverse_checkbutton"), "toggled", G_CALLBACK (apply_sort_order), data); g_signal_connect (data->sort_by_combobox, "changed", G_CALLBACK (apply_sort_order), data); /* run dialog. */ gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (browser)); gtk_window_set_modal (GTK_WINDOW (data->dialog), FALSE); gtk_widget_show (data->dialog); }
int music_build_element_widgets () { int i = 0; for (i = 0; i < 9; i++) { label_music_info[i] = gtk_label_new(NULL); gtk_label_set_width_chars(GTK_LABEL(label_music_info[i]), 15); gtk_label_set_max_width_chars(GTK_LABEL(label_music_info[i]), 150); gtk_label_set_line_wrap(GTK_LABEL(label_music_info[i]), TRUE); } separator_music_info = gtk_separator_new(GTK_ORIENTATION_VERTICAL); for (i = 0; i < 9; i++) { label_music_lyric[i] = gtk_label_new(NULL); gtk_label_set_max_width_chars(GTK_LABEL(label_music_lyric[i]), 305); // gtk_label_set_line_wrap(GTK_LABEL(label_music_lyric[i]), TRUE); } gtk_label_set_selectable(GTK_LABEL(label_music_lyric[4]), TRUE); gtk_label_set_use_underline (GTK_LABEL(label_music_lyric[4]), TRUE); gtk_label_set_use_markup (GTK_LABEL(label_music_lyric[4]), TRUE); gtk_label_set_pattern (GTK_LABEL(label_music_lyric[4]), "________"); separator_music_lyric1 = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL); separator_music_lyric2 = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL); button_music_start_server = gtk_button_new_with_label("启动服务器"); // set_button_music_start_server(button_music_start_server); button_music_exit_server = gtk_button_new_with_label("关闭服务器"); // set_button_music_exit_server(button_music_exit_server); button_music_play = gtk_button_new(); // box_music_play = button_with_image("/usr/share/raspi_remote_control/ui_images/ui_images_music/play.png"); // box_music_pause = button_with_image("/usr/share/raspi_remote_control/ui_images/ui_images_music/pause.png"); image_music_play = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/play.png"); image_music_play_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/play_light.png"); image_music_pause = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/pause.png"); image_music_pause_light = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/pause_light.png"); gtk_button_set_relief(GTK_BUTTON(button_music_play), GTK_RELIEF_NONE); set_button_music_play(button_music_play); button_music_pause = gtk_button_new_with_label("暂停"); // set_button_music_pause(button_music_pause); button_music_unpause = gtk_button_new_with_label("取消暂停"); // set_button_music_unpause(button_music_unpause); // button_music_stop = gtk_button_new_with_label("停止"); button_music_stop = gtk_button_new(); image_music_stop = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/stop.png"); image_music_stop_light = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/stop_light.png"); gtk_button_set_image(GTK_BUTTON(button_music_stop), image_music_stop); gtk_button_set_relief(GTK_BUTTON(button_music_stop), GTK_RELIEF_NONE); set_button_music_stop(button_music_stop); // button_music_next = gtk_button_new_with_label("下一首"); button_music_next = gtk_button_new(); image_music_next = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/next.png"); image_music_next_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/next_light.png"); gtk_button_set_image(GTK_BUTTON(button_music_next), image_music_next); gtk_button_set_relief(GTK_BUTTON(button_music_next), GTK_RELIEF_NONE); set_button_music_next(button_music_next); // button_music_pre = gtk_button_new_with_label("上一首"); button_music_pre = gtk_button_new(); image_music_pre = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/pre.png"); image_music_pre_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/pre_light.png"); gtk_button_set_image (GTK_BUTTON(button_music_pre), image_music_pre); gtk_button_set_relief(GTK_BUTTON(button_music_pre), GTK_RELIEF_NONE); set_button_music_pre(button_music_pre); // button_music_volume_up = gtk_button_new_with_label("音量+"); // set_button_music_volume_up(button_music_volume_up); // button_music_volume_silence = gtk_button_new_with_label("静音"); button_music_silence = gtk_button_new(); image_music_silence = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/silence.png"); image_music_silence_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/silence_light.png"); image_music_unsilence = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/unsilence.png"); image_music_unsilence_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/unsilence_light.png"); gtk_button_set_image (GTK_BUTTON(button_music_silence), image_music_silence); gtk_button_set_relief(GTK_BUTTON(button_music_silence), GTK_RELIEF_NONE); set_button_music_silence(button_music_silence); button_music_volume = gtk_volume_button_new(); set_button_music_volume( button_music_volume); button_music_reset_list = gtk_button_new_with_label("重设列表"); set_button_music_reset_list(button_music_reset_list); // button_music_choose_path = gtk_button_new_with_label("添加路径"); // set_button_music_choose_path(button_music_choose_path); // music_path_dialog = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); music_path_dialog = gtk_file_chooser_dialog_new ("test_title", NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, "test_button_text", NULL); button_music_choose_path = gtk_file_chooser_button_new_with_dialog (music_path_dialog); gtk_file_chooser_button_set_title (GTK_FILE_CHOOSER_BUTTON(button_music_choose_path), "添加路径"); // gtk_file_chooser_set_select_multiple (music_path_dialog, TRUE); button_music_delete_path = gtk_button_new_with_label("删除当前路径"); set_button_music_delete_path(button_music_delete_path); scale_music_process = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1); set_scale_music_process(scale_music_process); label_music_cur_time = gtk_label_new ("--:--:--"); label_music_total_time = gtk_label_new ("--:--:--"); switch_music_autonext = gtk_switch_new (); set_switch_music_autonext (); label_music_autonext = gtk_label_new ("AutoNext: "); switch_music_repeat = gtk_switch_new (); set_switch_music_repeat (); label_music_repeat = gtk_label_new ("Repeat: "); switch_music_shuffle = gtk_switch_new (); set_switch_music_shuffle (); label_music_shuffle = gtk_label_new ("Shuffle: "); radio_button_music_mode_shuffle = gtk_radio_button_new (NULL); label_music_mode_shuffle = gtk_label_new ("随机:"); radio_button_music_mode_loop_list = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (radio_button_music_mode_shuffle)); label_music_mode_loop_list = gtk_label_new ("列表循环:"); radio_button_music_mode_play_list = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (radio_button_music_mode_shuffle)); label_music_mode_play_list = gtk_label_new ("播放列表:"); radio_button_music_mode_loop_one = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (radio_button_music_mode_shuffle)); label_music_mode_loop_one = gtk_label_new ("单曲:"); spinner_music_mode_changing = gtk_spinner_new (); set_radio_button_music_mode (); store_music_dir_list = gtk_tree_store_new(dir_n_columns, G_TYPE_STRING); tree_view_music_dir_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store_music_dir_list)); text_renderer_music_dir_list = gtk_cell_renderer_text_new (); column_music_dir_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_dir_list, "text", dir_name, NULL); gtk_tree_view_column_set_fixed_width(column_music_dir_list, 100); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_dir_list), column_music_dir_list); music_dir_list_sw_adj_h = gtk_adjustment_new(100, 0, 100, 1, 1, 50); music_dir_list_sw = gtk_scrolled_window_new(NULL, music_dir_list_sw_adj_h); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(music_dir_list_sw), 330); gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(music_dir_list_sw), 100); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(music_dir_list_sw), GTK_SHADOW_NONE); // gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_dir_list_sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_dir_list_sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(music_dir_list_sw), tree_view_music_dir_list); selection_music_dir_list = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view_music_dir_list)); set_tree_view_music_dir_list (); store_music_list = gtk_tree_store_new(list_n_columns, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); // char file_index[BUFSIZ]; // printf("music_list_num is: %s\n", music_list_num); // while (i < music_list_num) { // // printf("%d: %s\n", i, music_list[i]); // sprintf(file_index, "%d", i + 1); // gtk_tree_store_append(store_music_list, &iter_music_list, NULL); // gtk_tree_store_set (store_music_list, &iter_music_list, list_index, file_index, list_title, music_list[i], list_total_sec, "03:00", -1); // i++; // } // tree_view_music_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store_music_list)); text_renderer_music_list = gtk_cell_renderer_text_new (); column_music_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_list, "text", list_index, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_list), column_music_list); gtk_tree_view_column_set_title(column_music_list, "序号"); text_renderer_music_list = gtk_cell_renderer_text_new (); column_music_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_list, "text", list_title, NULL); gtk_tree_view_column_set_fixed_width(column_music_list, 100); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_list), column_music_list); // text_renderer_music_list = gtk_cell_renderer_text_new (); // column_music_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_list, "text", list_total_sec, NULL); // gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_list), column_music_list); music_list_sw_adj_h = gtk_adjustment_new(100, 0, 100, 1, 1, 50); music_list_sw = gtk_scrolled_window_new(NULL, music_list_sw_adj_h); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(music_list_sw), 370); gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(music_list_sw), 200); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(music_list_sw), GTK_SHADOW_NONE); // gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_list_sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_list_sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(music_list_sw), tree_view_music_list); selection_music_list = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view_music_list)); set_tree_view_music_list (); return 1; }
static void gvc_sound_theme_chooser_init (GvcSoundThemeChooser *chooser) { GtkWidget *box; GtkWidget *label; GtkWidget *scrolled_window; GtkWidget *alignment; gchar *str; chooser->priv = GVC_SOUND_THEME_CHOOSER_GET_PRIVATE (chooser); #if GTK_CHECK_VERSION (3, 0, 0) chooser->priv->theme_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); #else chooser->priv->theme_box = gtk_hbox_new (FALSE, 0); #endif gtk_box_pack_start (GTK_BOX (chooser), chooser->priv->theme_box, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("Sound _theme:")); gtk_box_pack_start (GTK_BOX (chooser->priv->theme_box), label, FALSE, FALSE, 0); chooser->priv->combo_box = gtk_combo_box_new (); gtk_box_pack_start (GTK_BOX (chooser->priv->theme_box), chooser->priv->combo_box, FALSE, FALSE, 6); gtk_label_set_mnemonic_widget (GTK_LABEL (label), chooser->priv->combo_box); chooser->priv->sound_settings = g_settings_new (KEY_SOUNDS_SCHEMA); g_signal_connect (G_OBJECT (chooser->priv->sound_settings), "changed", G_CALLBACK (on_key_changed), chooser); str = g_strdup_printf ("<b>%s</b>", _("C_hoose an alert sound:")); chooser->priv->selection_box = box = gtk_frame_new (str); g_free (str); label = gtk_frame_get_label_widget (GTK_FRAME (box)); gtk_label_set_use_underline (GTK_LABEL (label), TRUE); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_frame_set_shadow_type (GTK_FRAME (box), GTK_SHADOW_NONE); alignment = gtk_alignment_new (0, 0, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 6, 0, 0, 0); gtk_container_add (GTK_CONTAINER (alignment), box); gtk_box_pack_start (GTK_BOX (chooser), alignment, TRUE, TRUE, 6); alignment = gtk_alignment_new (0, 0, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 6, 0, 0, 0); gtk_container_add (GTK_CONTAINER (box), alignment); chooser->priv->treeview = create_alert_treeview (chooser); gtk_label_set_mnemonic_widget (GTK_LABEL (label), chooser->priv->treeview); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (scrolled_window), chooser->priv->treeview); gtk_container_add (GTK_CONTAINER (alignment), scrolled_window); chooser->priv->click_feedback_button = gtk_check_button_new_with_mnemonic (_("Enable _window and button sounds")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (chooser->priv->click_feedback_button), g_settings_get_boolean (chooser->priv->sound_settings, INPUT_SOUNDS_KEY)); gtk_box_pack_start (GTK_BOX (chooser), chooser->priv->click_feedback_button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (chooser->priv->click_feedback_button), "toggled", G_CALLBACK (on_click_feedback_toggled), chooser); setup_theme_selector (chooser); update_theme (chooser); setup_list_size_constraint (scrolled_window, chooser->priv->treeview); }