/****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);
}
