applications/gnome-control-center
3
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

sound: Use G_DEFINE_TYPE

Browse source
This commit is contained in:
Robert Ancell 2017-09-26 21:09:45 -04:00
parent e779a30927
commit 43129a1cfd
16 changed files with 777 additions and 956 deletions
Download patch file Download diff file Expand all files Collapse all files

8
panels/sound/cc-sound-panel.c
View file

@ -32,6 +32,14 @@
#include "cc-sound-panel.h"
#include "gvc-mixer-dialog.h"
struct _CcSoundPanel {
CcPanel parent_instance;
GvcMixerControl *control;
GvcMixerDialog *dialog;
GtkWidget *connecting_label;
};
CC_PANEL_REGISTER (CcSoundPanel, cc_sound_panel)
enum {

26
panels/sound/cc-sound-panel.h
View file

@ -25,30 +25,8 @@
G_BEGIN_DECLS
#define CC_TYPE_SOUND_PANEL cc_sound_panel_get_type()
#define CC_SOUND_PANEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CC_TYPE_SOUND_PANEL, CcSoundPanel))
#define CC_SOUND_PANEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CC_TYPE_SOUND_PANEL, CcSoundPanelClass))
#define CC_IS_SOUND_PANEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CC_TYPE_SOUND_PANEL))
#define CC_IS_SOUND_PANEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CC_TYPE_SOUND_PANEL))
#define CC_SOUND_PANEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CC_TYPE_SOUND_PANEL, CcSoundPanelClass))
typedef struct _CcSoundPanel CcSoundPanel;
typedef struct _CcSoundPanelClass CcSoundPanelClass;
typedef struct _CcSoundPanelPrivate CcSoundPanelPrivate;
struct _CcSoundPanel {
CcPanel parent;
GvcMixerControl *control;
GvcMixerDialog *dialog;
GtkWidget *connecting_label;
};
struct _CcSoundPanelClass {
CcPanelClass parent_class;
};
GType cc_sound_panel_get_type (void) G_GNUC_CONST;
#define CC_TYPE_SOUND_PANEL (cc_sound_panel_get_type ())
G_DECLARE_FINAL_TYPE (CcSoundPanel, cc_sound_panel, CC, SOUND_PANEL, CcPanel)
G_END_DECLS

150
panels/sound/gvc-balance-bar.c
View file

@ -35,10 +35,10 @@
#define SCALE_SIZE 128
#define ADJUSTMENT_MAX_NORMAL 65536.0 /* PA_VOLUME_NORM */
#define GVC_BALANCE_BAR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GVC_TYPE_BALANCE_BAR, GvcBalanceBarPrivate))
struct GvcBalanceBarPrivate
struct _GvcBalanceBar
{
GtkBox parent_instance;
GvcChannelMap *channel_map;
GvcBalanceType btype;
GtkWidget *scale_box;
@ -80,27 +80,26 @@ G_DEFINE_TYPE (GvcBalanceBar, gvc_balance_bar, GTK_TYPE_BOX)
static GtkWidget *
_scale_box_new (GvcBalanceBar *bar)
{
GvcBalanceBarPrivate *priv = bar->priv;
GtkWidget *box;
GtkWidget *sbox;
GtkWidget *ebox;
GtkAdjustment *adjustment = bar->priv->adjustment;
GtkAdjustment *adjustment = bar->adjustment;
char *str_lower, *str_upper;
gdouble lower, upper;
bar->priv->scale_box = box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
priv->scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, priv->adjustment);
gtk_scale_set_has_origin (GTK_SCALE (priv->scale), FALSE);
gtk_widget_set_size_request (priv->scale, SCALE_SIZE, -1);
bar->scale_box = box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
bar->scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, bar->adjustment);
gtk_scale_set_has_origin (GTK_SCALE (bar->scale), FALSE);
gtk_widget_set_size_request (bar->scale, SCALE_SIZE, -1);
bar->priv->start_box = sbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
bar->start_box = sbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (box), sbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (sbox), priv->label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (sbox), bar->label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), priv->scale, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box), bar->scale, TRUE, TRUE, 0);
switch (bar->priv->btype) {
switch (bar->btype) {
case BALANCE_TYPE_RL:
str_lower = g_strdup_printf ("<small>%s</small>", C_("balance", "Left"));
str_upper = g_strdup_printf ("<small>%s</small>", C_("balance", "Right"));
@ -118,42 +117,42 @@ _scale_box_new (GvcBalanceBar *bar)
}
lower = gtk_adjustment_get_lower (adjustment);
gtk_scale_add_mark (GTK_SCALE (priv->scale), lower,
gtk_scale_add_mark (GTK_SCALE (bar->scale), lower,
GTK_POS_BOTTOM, str_lower);
g_free (str_lower);
upper = gtk_adjustment_get_upper (adjustment);
gtk_scale_add_mark (GTK_SCALE (priv->scale), upper,
gtk_scale_add_mark (GTK_SCALE (bar->scale), upper,
GTK_POS_BOTTOM, str_upper);
g_free (str_upper);
if (bar->priv->btype != BALANCE_TYPE_LFE) {
gtk_scale_add_mark (GTK_SCALE (priv->scale),
if (bar->btype != BALANCE_TYPE_LFE) {
gtk_scale_add_mark (GTK_SCALE (bar->scale),
(upper - lower)/2 + lower,
GTK_POS_BOTTOM, NULL);
}
bar->priv->end_box = ebox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
bar->end_box = ebox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (box), ebox, FALSE, FALSE, 0);
ca_gtk_widget_disable_sounds (bar->priv->scale, FALSE);
gtk_widget_add_events (bar->priv->scale, GDK_SCROLL_MASK);
ca_gtk_widget_disable_sounds (bar->scale, FALSE);
gtk_widget_add_events (bar->scale, GDK_SCROLL_MASK);
g_signal_connect (G_OBJECT (bar->priv->scale), "button-press-event",
g_signal_connect (G_OBJECT (bar->scale), "button-press-event",
G_CALLBACK (on_scale_button_press_event), bar);
g_signal_connect (G_OBJECT (bar->priv->scale), "button-release-event",
g_signal_connect (G_OBJECT (bar->scale), "button-release-event",
G_CALLBACK (on_scale_button_release_event), bar);
g_signal_connect (G_OBJECT (bar->priv->scale), "scroll-event",
g_signal_connect (G_OBJECT (bar->scale), "scroll-event",
G_CALLBACK (on_scale_scroll_event), bar);
if (bar->priv->size_group != NULL) {
gtk_size_group_add_widget (bar->priv->size_group, sbox);
if (bar->size_group != NULL) {
gtk_size_group_add_widget (bar->size_group, sbox);
if (bar->priv->symmetric) {
gtk_size_group_add_widget (bar->priv->size_group, ebox);
if (bar->symmetric) {
gtk_size_group_add_widget (bar->size_group, ebox);
}
}
gtk_scale_set_draw_value (GTK_SCALE (priv->scale), FALSE);
gtk_scale_set_draw_value (GTK_SCALE (bar->scale), FALSE);
return box;
}
@ -165,16 +164,16 @@ gvc_balance_bar_set_size_group (GvcBalanceBar *bar,
{
g_return_if_fail (GVC_IS_BALANCE_BAR (bar));
bar->priv->size_group = group;
bar->priv->symmetric = symmetric;
bar->size_group = group;
bar->symmetric = symmetric;
if (bar->priv->size_group != NULL) {
gtk_size_group_add_widget (bar->priv->size_group,
bar->priv->start_box);
if (bar->size_group != NULL) {
gtk_size_group_add_widget (bar->size_group,
bar->start_box);
if (bar->priv->symmetric) {
gtk_size_group_add_widget (bar->priv->size_group,
bar->priv->end_box);
if (bar->symmetric) {
gtk_size_group_add_widget (bar->size_group,
bar->end_box);
}
}
gtk_widget_queue_draw (GTK_WIDGET (bar));
@ -204,10 +203,10 @@ update_level_from_map (GvcBalanceBar *bar,
const gdouble *volumes;
gdouble val;
g_debug ("Volume changed (for %s bar)", btype_to_string (bar->priv->btype));
g_debug ("Volume changed (for %s bar)", btype_to_string (bar->btype));
volumes = gvc_channel_map_get_volume (map);
switch (bar->priv->btype) {
switch (bar->btype) {
case BALANCE_TYPE_RL:
val = volumes[BALANCE];
break;
@ -221,7 +220,7 @@ update_level_from_map (GvcBalanceBar *bar,
g_assert_not_reached ();
}
gtk_adjustment_set_value (bar->priv->adjustment, val);
gtk_adjustment_set_value (bar->adjustment, val);
}
static void
@ -238,12 +237,12 @@ gvc_balance_bar_set_channel_map (GvcBalanceBar *bar,
{
g_return_if_fail (GVC_BALANCE_BAR (bar));
if (bar->priv->channel_map != NULL) {
g_signal_handlers_disconnect_by_func (G_OBJECT (bar->priv->channel_map),
if (bar->channel_map != NULL) {
g_signal_handlers_disconnect_by_func (G_OBJECT (bar->channel_map),
on_channel_map_volume_changed, bar);
g_object_unref (bar->priv->channel_map);
g_object_unref (bar->channel_map);
}
bar->priv->channel_map = g_object_ref (map);
bar->channel_map = g_object_ref (map);
update_level_from_map (bar, map);
@ -261,16 +260,16 @@ gvc_balance_bar_set_balance_type (GvcBalanceBar *bar,
g_return_if_fail (GVC_BALANCE_BAR (bar));
bar->priv->btype = btype;
if (bar->priv->btype != BALANCE_TYPE_LFE) {
bar->priv->adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0,
bar->btype = btype;
if (bar->btype != BALANCE_TYPE_LFE) {
bar->adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0,
-1.0,
1.0,
0.5,
0.5,
0.0));
} else {
bar->priv->adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0,
bar->adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0,
0.0,
ADJUSTMENT_MAX_NORMAL,
ADJUSTMENT_MAX_NORMAL/100.0,
@ -278,27 +277,27 @@ gvc_balance_bar_set_balance_type (GvcBalanceBar *bar,
0.0));
}
g_object_ref_sink (bar->priv->adjustment);
g_signal_connect (bar->priv->adjustment,
g_object_ref_sink (bar->adjustment);
g_signal_connect (bar->adjustment,
"value-changed",
G_CALLBACK (on_adjustment_value_changed),
bar);
switch (btype) {
case BALANCE_TYPE_RL:
bar->priv->label = gtk_label_new_with_mnemonic (_("_Balance:"));
bar->label = gtk_label_new_with_mnemonic (_("_Balance:"));
break;
case BALANCE_TYPE_FR:
bar->priv->label = gtk_label_new_with_mnemonic (_("_Fade:"));
bar->label = gtk_label_new_with_mnemonic (_("_Fade:"));
break;
case BALANCE_TYPE_LFE:
bar->priv->label = gtk_label_new_with_mnemonic (_("_Subwoofer:"));
bar->label = gtk_label_new_with_mnemonic (_("_Subwoofer:"));
break;
default:
g_assert_not_reached ();
}
gtk_widget_set_halign (bar->priv->label, GTK_ALIGN_START);
gtk_widget_set_valign (bar->priv->label, GTK_ALIGN_START);
gtk_widget_set_halign (bar->label, GTK_ALIGN_START);
gtk_widget_set_valign (bar->label, GTK_ALIGN_START);
/* frame */
frame = gtk_frame_new (NULL);
@ -306,13 +305,13 @@ gvc_balance_bar_set_balance_type (GvcBalanceBar *bar,
gtk_box_pack_start (GTK_BOX (bar), frame, TRUE, TRUE, 0);
/* box with scale */
bar->priv->scale_box = _scale_box_new (bar);
gtk_container_add (GTK_CONTAINER (frame), bar->priv->scale_box);
bar->scale_box = _scale_box_new (bar);
gtk_container_add (GTK_CONTAINER (frame), bar->scale_box);
gtk_widget_show_all (frame);
gtk_widget_set_direction (bar->priv->scale, GTK_TEXT_DIR_LTR);
gtk_label_set_mnemonic_widget (GTK_LABEL (bar->priv->label),
bar->priv->scale);
gtk_widget_set_direction (bar->scale, GTK_TEXT_DIR_LTR);
gtk_label_set_mnemonic_widget (GTK_LABEL (bar->label),
bar->scale);
g_object_notify (G_OBJECT (bar), "balance-type");
}
@ -348,7 +347,7 @@ gvc_balance_bar_get_property (GObject *object,
switch (prop_id) {
case PROP_CHANNEL_MAP:
g_value_set_object (value, self->priv->channel_map);
g_value_set_object (value, self->channel_map);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -388,8 +387,6 @@ gvc_balance_bar_class_init (GvcBalanceBarClass *klass)
"Whether the balance is right-left or front-rear",
BALANCE_TYPE_RL, NUM_BALANCE_TYPES - 1, BALANCE_TYPE_RL,
G_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY));
g_type_class_add_private (klass, sizeof (GvcBalanceBarPrivate));
}
@ -398,7 +395,7 @@ on_scale_button_press_event (GtkWidget *widget,
GdkEventButton *event,
GvcBalanceBar *bar)
{
bar->priv->click_lock = TRUE;
bar->click_lock = TRUE;
return FALSE;
}
@ -408,7 +405,7 @@ on_scale_button_release_event (GtkWidget *widget,
GdkEventButton *event,
GvcBalanceBar *bar)
{
bar->priv->click_lock = FALSE;
bar->click_lock = FALSE;
return FALSE;
}
@ -421,7 +418,7 @@ on_scale_scroll_event (GtkWidget *widget,
gdouble value;
gdouble dx, dy;
value = gtk_adjustment_get_value (bar->priv->adjustment);
value = gtk_adjustment_get_value (bar->adjustment);
if (!gdk_event_get_scroll_deltas ((GdkEvent*)event, &dx, &dy)) {
dx = 0.0;
@ -441,7 +438,7 @@ on_scale_scroll_event (GtkWidget *widget,
}
}
if (bar->priv->btype == BALANCE_TYPE_LFE) {
if (bar->btype == BALANCE_TYPE_LFE) {
if (dy > 0) {
if (value + dy * ADJUSTMENT_MAX_NORMAL/100.0 > ADJUSTMENT_MAX_NORMAL)
value = ADJUSTMENT_MAX_NORMAL;
@ -466,7 +463,7 @@ on_scale_scroll_event (GtkWidget *widget,
value = value + dy * 0.01;
}
}
gtk_adjustment_set_value (bar->priv->adjustment, value);
gtk_adjustment_set_value (bar->adjustment, value);
return TRUE;
}
@ -479,15 +476,15 @@ on_adjustment_value_changed (GtkAdjustment *adjustment,
pa_cvolume cv;
const pa_channel_map *pa_map;
if (bar->priv->channel_map == NULL)
if (bar->channel_map == NULL)
return;
cv = *gvc_channel_map_get_cvolume (bar->priv->channel_map);
cv = *gvc_channel_map_get_cvolume (bar->channel_map);
val = gtk_adjustment_get_value (adjustment);
pa_map = gvc_channel_map_get_pa_channel_map (bar->priv->channel_map);
pa_map = gvc_channel_map_get_pa_channel_map (bar->channel_map);
switch (bar->priv->btype) {
switch (bar->btype) {
case BALANCE_TYPE_RL:
pa_cvolume_set_balance (&cv, pa_map, val);
break;
@ -499,13 +496,12 @@ on_adjustment_value_changed (GtkAdjustment *adjustment,
break;
}
gvc_channel_map_volume_changed (bar->priv->channel_map, &cv, TRUE);
gvc_channel_map_volume_changed (bar->channel_map, &cv, TRUE);
}
static void
gvc_balance_bar_init (GvcBalanceBar *bar)
{
bar->priv = GVC_BALANCE_BAR_GET_PRIVATE (bar);
}
static void
@ -518,12 +514,12 @@ gvc_balance_bar_finalize (GObject *object)
bar = GVC_BALANCE_BAR (object);
g_return_if_fail (bar->priv != NULL);
g_return_if_fail (bar != NULL);
if (bar->priv->channel_map != NULL) {
g_signal_handlers_disconnect_by_func (G_OBJECT (bar->priv->channel_map),
if (bar->channel_map != NULL) {
g_signal_handlers_disconnect_by_func (G_OBJECT (bar->channel_map),
on_channel_map_volume_changed, bar);
g_object_unref (bar->priv->channel_map);
g_object_unref (bar->channel_map);
}
G_OBJECT_CLASS (gvc_balance_bar_parent_class)->finalize (object);

23
panels/sound/gvc-balance-bar.h
View file

@ -26,12 +26,8 @@
G_BEGIN_DECLS
#define GVC_TYPE_BALANCE_BAR (gvc_balance_bar_get_type ())
#define GVC_BALANCE_BAR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GVC_TYPE_BALANCE_BAR, GvcBalanceBar))
#define GVC_BALANCE_BAR_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GVC_TYPE_BALANCE_BAR, GvcBalanceBarClass))
#define GVC_IS_BALANCE_BAR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GVC_TYPE_BALANCE_BAR))
#define GVC_IS_BALANCE_BAR_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GVC_TYPE_BALANCE_BAR))
#define GVC_BALANCE_BAR_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GVC_TYPE_BALANCE_BAR, GvcBalanceBarClass))
#define GVC_TYPE_BALANCE_BAR (gvc_balance_bar_get_type ())
G_DECLARE_FINAL_TYPE (GvcBalanceBar, gvc_balance_bar, GVC, BALANCE_BAR, GtkBox)
typedef enum {
BALANCE_TYPE_RL,
@ -41,21 +37,6 @@ typedef enum {
#define NUM_BALANCE_TYPES BALANCE_TYPE_LFE + 1
typedef struct GvcBalanceBarPrivate GvcBalanceBarPrivate;
typedef struct
{
GtkBox parent;
GvcBalanceBarPrivate *priv;
} GvcBalanceBar;
typedef struct
{
GtkBoxClass parent_class;
} GvcBalanceBarClass;
GType gvc_balance_bar_get_type (void);
GtkWidget * gvc_balance_bar_new (const GvcChannelMap *map,
GvcBalanceType btype);

405
panels/sound/gvc-channel-bar.c
View file

@ -36,13 +36,13 @@
#define SCALE_SIZE 128
#define ADJUSTMENT_MAX_NORMAL gvc_mixer_control_get_vol_max_norm(NULL)
#define ADJUSTMENT_MAX_AMPLIFIED gvc_mixer_control_get_vol_max_amplified(NULL)
#define ADJUSTMENT_MAX (bar->priv->is_amplified ? ADJUSTMENT_MAX_AMPLIFIED : ADJUSTMENT_MAX_NORMAL)
#define ADJUSTMENT_MAX (bar->is_amplified ? ADJUSTMENT_MAX_AMPLIFIED : ADJUSTMENT_MAX_NORMAL)
#define SCROLLSTEP (ADJUSTMENT_MAX / 100.0 * 5.0)
#define GVC_CHANNEL_BAR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GVC_TYPE_CHANNEL_BAR, GvcChannelBarPrivate))
struct GvcChannelBarPrivate
struct _GvcChannelBar
{
GtkBox parent_instance;
GtkOrientation orientation;
GtkWidget *scale_box;
GtkWidget *start_box;
@ -102,80 +102,79 @@ G_DEFINE_TYPE (GvcChannelBar, gvc_channel_bar, GTK_TYPE_BOX)
static GtkWidget *
_scale_box_new (GvcChannelBar *bar)
{
GvcChannelBarPrivate *priv = bar->priv;
GtkWidget *box;
GtkWidget *sbox;
GtkWidget *ebox;
if (priv->orientation == GTK_ORIENTATION_VERTICAL) {
bar->priv->scale_box = box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
if (bar->orientation == GTK_ORIENTATION_VERTICAL) {
bar->scale_box = box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
priv->scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, priv->adjustment);
bar->scale = gtk_scale_new (GTK_ORIENTATION_VERTICAL, bar->adjustment);
gtk_widget_set_size_request (priv->scale, -1, SCALE_SIZE);
gtk_range_set_inverted (GTK_RANGE (priv->scale), TRUE);
gtk_widget_set_size_request (bar->scale, -1, SCALE_SIZE);
gtk_range_set_inverted (GTK_RANGE (bar->scale), TRUE);
bar->priv->start_box = sbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
bar->start_box = sbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (box), sbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (sbox), priv->image, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (sbox), priv->label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (sbox), bar->image, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (sbox), bar->label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (sbox), priv->high_image, FALSE, FALSE, 0);
gtk_widget_hide (priv->high_image);
gtk_box_pack_start (GTK_BOX (box), priv->scale, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (sbox), bar->high_image, FALSE, FALSE, 0);
gtk_widget_hide (bar->high_image);
gtk_box_pack_start (GTK_BOX (box), bar->scale, TRUE, TRUE, 0);
bar->priv->end_box = ebox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
bar->end_box = ebox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (box), ebox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (ebox), priv->low_image, FALSE, FALSE, 0);
gtk_widget_hide (priv->low_image);
gtk_box_pack_start (GTK_BOX (ebox), bar->low_image, FALSE, FALSE, 0);
gtk_widget_hide (bar->low_image);
gtk_box_pack_start (GTK_BOX (ebox), priv->mute_switch, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (ebox), bar->mute_switch, FALSE, FALSE, 0);
} else {
bar->priv->scale_box = box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (box), priv->image, FALSE, FALSE, 0);
bar->scale_box = box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (box), bar->image, FALSE, FALSE, 0);
priv->scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, priv->adjustment);
bar->scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, bar->adjustment);
gtk_widget_set_size_request (priv->scale, SCALE_SIZE, -1);
gtk_widget_set_size_request (bar->scale, SCALE_SIZE, -1);
bar->priv->start_box = sbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
bar->start_box = sbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (box), sbox, FALSE, FALSE, 0);
gtk_box_pack_end (GTK_BOX (sbox), priv->low_image, FALSE, FALSE, 0);
gtk_widget_show (priv->low_image);
gtk_box_pack_end (GTK_BOX (sbox), bar->low_image, FALSE, FALSE, 0);
gtk_widget_show (bar->low_image);
gtk_box_pack_start (GTK_BOX (sbox), priv->label, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box), priv->scale, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (sbox), bar->label, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box), bar->scale, TRUE, TRUE, 0);
bar->priv->end_box = ebox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
bar->end_box = ebox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (box), ebox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (ebox), priv->high_image, FALSE, FALSE, 0);
gtk_widget_show (priv->high_image);
gtk_box_pack_start (GTK_BOX (ebox), priv->mute_switch, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (ebox), bar->high_image, FALSE, FALSE, 0);
gtk_widget_show (bar->high_image);
gtk_box_pack_start (GTK_BOX (ebox), bar->mute_switch, FALSE, FALSE, 0);
}
ca_gtk_widget_disable_sounds (bar->priv->scale, FALSE);
gtk_widget_add_events (bar->priv->scale, GDK_SCROLL_MASK);
ca_gtk_widget_disable_sounds (bar->scale, FALSE);
gtk_widget_add_events (bar->scale, GDK_SCROLL_MASK);
g_signal_connect (G_OBJECT (bar->priv->scale), "button-press-event",
g_signal_connect (G_OBJECT (bar->scale), "button-press-event",
G_CALLBACK (on_scale_button_press_event), bar);
g_signal_connect (G_OBJECT (bar->priv->scale), "button-release-event",
g_signal_connect (G_OBJECT (bar->scale), "button-release-event",
G_CALLBACK (on_scale_button_release_event), bar);
g_signal_connect (G_OBJECT (bar->priv->scale), "scroll-event",
g_signal_connect (G_OBJECT (bar->scale), "scroll-event",
G_CALLBACK (on_scale_scroll_event), bar);
if (bar->priv->size_group != NULL) {
gtk_size_group_add_widget (bar->priv->size_group, sbox);
if (bar->size_group != NULL) {
gtk_size_group_add_widget (bar->size_group, sbox);
if (bar->priv->symmetric) {
gtk_size_group_add_widget (bar->priv->size_group, ebox);
if (bar->symmetric) {
gtk_size_group_add_widget (bar->size_group, ebox);
}
}
gtk_scale_set_draw_value (GTK_SCALE (priv->scale), FALSE);
gtk_scale_set_draw_value (GTK_SCALE (bar->scale), FALSE);
return box;
}
@ -183,29 +182,29 @@ _scale_box_new (GvcChannelBar *bar)
static void
update_image (GvcChannelBar *bar)
{
gtk_image_set_from_icon_name (GTK_IMAGE (bar->priv->image),
bar->priv->icon_name,
gtk_image_set_from_icon_name (GTK_IMAGE (bar->image),
bar->icon_name,
GTK_ICON_SIZE_DIALOG);
if (bar->priv->icon_name != NULL) {
gtk_widget_show (bar->priv->image);
if (bar->icon_name != NULL) {
gtk_widget_show (bar->image);
} else {
gtk_widget_hide (bar->priv->image);
gtk_widget_hide (bar->image);
}
}
static void
update_label (GvcChannelBar *bar)
{
if (bar->priv->name != NULL) {
gtk_label_set_text_with_mnemonic (GTK_LABEL (bar->priv->label),
bar->priv->name);
gtk_label_set_mnemonic_widget (GTK_LABEL (bar->priv->label),
bar->priv->scale);
gtk_widget_show (bar->priv->label);
if (bar->name != NULL) {
gtk_label_set_text_with_mnemonic (GTK_LABEL (bar->label),
bar->name);
gtk_label_set_mnemonic_widget (GTK_LABEL (bar->label),
bar->scale);
gtk_widget_show (bar->label);
} else {
gtk_label_set_text (GTK_LABEL (bar->priv->label), NULL);
gtk_widget_hide (bar->priv->label);
gtk_label_set_text (GTK_LABEL (bar->label), NULL);
gtk_widget_hide (bar->label);
}
}
@ -215,44 +214,44 @@ update_layout (GvcChannelBar *bar)
GtkWidget *box;
GtkWidget *frame;
if (bar->priv->scale == NULL) {
if (bar->scale == NULL) {
return;
}
box = bar->priv->scale_box;
box = bar->scale_box;
frame = gtk_widget_get_parent (box);
g_object_ref (bar->priv->image);
g_object_ref (bar->priv->label);
g_object_ref (bar->priv->mute_switch);
g_object_ref (bar->priv->low_image);
g_object_ref (bar->priv->high_image);
g_object_ref (bar->image);
g_object_ref (bar->label);
g_object_ref (bar->mute_switch);
g_object_ref (bar->low_image);
g_object_ref (bar->high_image);
gtk_container_remove (GTK_CONTAINER (bar->priv->start_box), bar->priv->image);
gtk_container_remove (GTK_CONTAINER (bar->priv->start_box), bar->priv->label);
gtk_container_remove (GTK_CONTAINER (bar->priv->end_box), bar->priv->mute_switch);
gtk_container_remove (GTK_CONTAINER (bar->start_box), bar->image);
gtk_container_remove (GTK_CONTAINER (bar->start_box), bar->label);
gtk_container_remove (GTK_CONTAINER (bar->end_box), bar->mute_switch);
if (bar->priv->orientation == GTK_ORIENTATION_VERTICAL) {
gtk_container_remove (GTK_CONTAINER (bar->priv->start_box), bar->priv->low_image);
gtk_container_remove (GTK_CONTAINER (bar->priv->end_box), bar->priv->high_image);
if (bar->orientation == GTK_ORIENTATION_VERTICAL) {
gtk_container_remove (GTK_CONTAINER (bar->start_box), bar->low_image);
gtk_container_remove (GTK_CONTAINER (bar->end_box), bar->high_image);
} else {
gtk_container_remove (GTK_CONTAINER (bar->priv->end_box), bar->priv->low_image);
gtk_container_remove (GTK_CONTAINER (bar->priv->start_box), bar->priv->high_image);
gtk_container_remove (GTK_CONTAINER (bar->end_box), bar->low_image);
gtk_container_remove (GTK_CONTAINER (bar->start_box), bar->high_image);
}
gtk_container_remove (GTK_CONTAINER (box), bar->priv->start_box);
gtk_container_remove (GTK_CONTAINER (box), bar->priv->scale);
gtk_container_remove (GTK_CONTAINER (box), bar->priv->end_box);
gtk_container_remove (GTK_CONTAINER (box), bar->start_box);
gtk_container_remove (GTK_CONTAINER (box), bar->scale);
gtk_container_remove (GTK_CONTAINER (box), bar->end_box);
gtk_container_remove (GTK_CONTAINER (frame), box);
bar->priv->scale_box = _scale_box_new (bar);
gtk_container_add (GTK_CONTAINER (frame), bar->priv->scale_box);
bar->scale_box = _scale_box_new (bar);
gtk_container_add (GTK_CONTAINER (frame), bar->scale_box);
g_object_unref (bar->priv->image);
g_object_unref (bar->priv->label);
g_object_unref (bar->priv->mute_switch);
g_object_unref (bar->priv->low_image);
g_object_unref (bar->priv->high_image);
g_object_unref (bar->image);
g_object_unref (bar->label);
g_object_unref (bar->mute_switch);
g_object_unref (bar->low_image);
g_object_unref (bar->high_image);
gtk_widget_show_all (frame);
}
@ -264,16 +263,16 @@ gvc_channel_bar_set_size_group (GvcChannelBar *bar,
{
g_return_if_fail (GVC_IS_CHANNEL_BAR (bar));
bar->priv->size_group = group;
bar->priv->symmetric = symmetric;
bar->size_group = group;
bar->symmetric = symmetric;
if (bar->priv->size_group != NULL) {
gtk_size_group_add_widget (bar->priv->size_group,
bar->priv->start_box);
if (bar->size_group != NULL) {
gtk_size_group_add_widget (bar->size_group,
bar->start_box);
if (bar->priv->symmetric) {
gtk_size_group_add_widget (bar->priv->size_group,
bar->priv->end_box);
if (bar->symmetric) {
gtk_size_group_add_widget (bar->size_group,
bar->end_box);
}
}
gtk_widget_queue_draw (GTK_WIDGET (bar));
@ -285,8 +284,8 @@ gvc_channel_bar_set_name (GvcChannelBar *bar,
{
g_return_if_fail (GVC_IS_CHANNEL_BAR (bar));
g_free (bar->priv->name);
bar->priv->name = g_strdup (name);
g_free (bar->name);
bar->name = g_strdup (name);
update_label (bar);
g_object_notify (G_OBJECT (bar), "name");
}
@ -297,8 +296,8 @@ gvc_channel_bar_set_icon_name (GvcChannelBar *bar,
{
g_return_if_fail (GVC_IS_CHANNEL_BAR (bar));
g_free (bar->priv->icon_name);
bar->priv->icon_name = g_strdup (name);
g_free (bar->icon_name);
bar->icon_name = g_strdup (name);
update_image (bar);
g_object_notify (G_OBJECT (bar), "icon-name");
}
@ -309,11 +308,11 @@ gvc_channel_bar_set_low_icon_name (GvcChannelBar *bar,
{
g_return_if_fail (GVC_IS_CHANNEL_BAR (bar));
if (name != NULL && strcmp (bar->priv->low_icon_name, name) != 0) {
g_free (bar->priv->low_icon_name);
bar->priv->low_icon_name = g_strdup (name);
gtk_image_set_from_icon_name (GTK_IMAGE (bar->priv->low_image),
bar->priv->low_icon_name,
if (name != NULL && strcmp (bar->low_icon_name, name) != 0) {
g_free (bar->low_icon_name);
bar->low_icon_name = g_strdup (name);
gtk_image_set_from_icon_name (GTK_IMAGE (bar->low_image),
bar->low_icon_name,
GTK_ICON_SIZE_MENU);
g_object_notify (G_OBJECT (bar), "low-icon-name");
}
@ -325,11 +324,11 @@ gvc_channel_bar_set_high_icon_name (GvcChannelBar *bar,
{
g_return_if_fail (GVC_IS_CHANNEL_BAR (bar));
if (name != NULL && strcmp (bar->priv->high_icon_name, name) != 0) {
g_free (bar->priv->high_icon_name);
bar->priv->high_icon_name = g_strdup (name);
gtk_image_set_from_icon_name (GTK_IMAGE (bar->priv->high_image),
bar->priv->high_icon_name,
if (name != NULL && strcmp (bar->high_icon_name, name) != 0) {
g_free (bar->high_icon_name);
bar->high_icon_name = g_strdup (name);
gtk_image_set_from_icon_name (GTK_IMAGE (bar->high_image),
bar->high_icon_name,
GTK_ICON_SIZE_MENU);
g_object_notify (G_OBJECT (bar), "high-icon-name");
}
@ -341,8 +340,8 @@ gvc_channel_bar_set_orientation (GvcChannelBar *bar,
{
g_return_if_fail (GVC_IS_CHANNEL_BAR (bar));
if (orientation != bar->priv->orientation) {
bar->priv->orientation = orientation;
if (orientation != bar->orientation) {
bar->orientation = orientation;
update_layout (bar);
g_object_notify (G_OBJECT (bar), "orientation");
}
@ -355,13 +354,13 @@ gvc_channel_bar_set_adjustment (GvcChannelBar *bar,
g_return_if_fail (GVC_CHANNEL_BAR (bar));
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
if (bar->priv->adjustment != NULL) {
g_object_unref (bar->priv->adjustment);
if (bar->adjustment != NULL) {
g_object_unref (bar->adjustment);
}
bar->priv->adjustment = g_object_ref_sink (adjustment);
bar->adjustment = g_object_ref_sink (adjustment);
if (bar->priv->scale != NULL) {
gtk_range_set_adjustment (GTK_RANGE (bar->priv->scale), adjustment);
if (bar->scale != NULL) {
gtk_range_set_adjustment (GTK_RANGE (bar->scale), adjustment);
}
g_object_notify (G_OBJECT (bar), "adjustment");
@ -372,7 +371,7 @@ gvc_channel_bar_get_adjustment (GvcChannelBar *bar)
{
g_return_val_if_fail (GVC_IS_CHANNEL_BAR (bar), NULL);
return bar->priv->adjustment;
return bar->adjustment;
}
static gboolean
@ -380,7 +379,7 @@ on_scale_button_press_event (GtkWidget *widget,
GdkEventButton *event,
GvcChannelBar *bar)
{
bar->priv->click_lock = TRUE;
bar->click_lock = TRUE;
return FALSE;
}
@ -393,7 +392,7 @@ on_scale_button_release_event (GtkWidget *widget,
GtkAdjustment *adj;
gdouble value;
bar->priv->click_lock = FALSE;
bar->click_lock = FALSE;
adj = gtk_range_get_adjustment (GTK_RANGE (widget));
@ -426,7 +425,7 @@ gvc_channel_bar_scroll (GvcChannelBar *bar, GdkEventScroll *event)
direction = event->direction;
if (bar->priv->orientation == GTK_ORIENTATION_VERTICAL) {
if (bar->orientation == GTK_ORIENTATION_VERTICAL) {
if (direction == GDK_SCROLL_LEFT || direction == GDK_SCROLL_RIGHT)
return FALSE;
} else {
@ -462,8 +461,8 @@ gvc_channel_bar_scroll (GvcChannelBar *bar, GdkEventScroll *event)
}
}
adj = gtk_range_get_adjustment (GTK_RANGE (bar->priv->scale));
if (adj == bar->priv->zero_adjustment) {
adj = gtk_range_get_adjustment (GTK_RANGE (bar->scale));
if (adj == bar->zero_adjustment) {
if (dy > 0)
gvc_channel_bar_set_is_muted (bar, FALSE);
return TRUE;
@ -484,7 +483,7 @@ gvc_channel_bar_scroll (GvcChannelBar *bar, GdkEventScroll *event)
}
gvc_channel_bar_set_is_muted (bar, (value == 0.0));
adj = gtk_range_get_adjustment (GTK_RANGE (bar->priv->scale));
adj = gtk_range_get_adjustment (GTK_RANGE (bar->scale));
gtk_adjustment_set_value (adj, value);
return TRUE;
@ -504,15 +503,15 @@ on_zero_adjustment_value_changed (GtkAdjustment *adjustment,
{
gdouble value;
if (bar->priv->click_lock != FALSE) {
if (bar->click_lock != FALSE) {
return;
}
value = gtk_adjustment_get_value (bar->priv->zero_adjustment);
gtk_adjustment_set_value (bar->priv->adjustment, value);
value = gtk_adjustment_get_value (bar->zero_adjustment);
gtk_adjustment_set_value (bar->adjustment, value);
if (bar->priv->show_mute == FALSE) {
if (bar->show_mute == FALSE) {
/* this means the adjustment moved away from zero and
* therefore we should unmute and set the volume. */
gvc_channel_bar_set_is_muted (bar, value > 0.0);
@ -522,33 +521,33 @@ on_zero_adjustment_value_changed (GtkAdjustment *adjustment,
static void
update_mute_switch (GvcChannelBar *bar)
{
if (bar->priv->show_mute) {
gtk_widget_show (bar->priv->mute_switch);
gtk_switch_set_active (GTK_SWITCH (bar->priv->mute_switch),
!bar->priv->is_muted);
if (bar->show_mute) {
gtk_widget_show (bar->mute_switch);
gtk_switch_set_active (GTK_SWITCH (bar->mute_switch),
!bar->is_muted);
} else {
gtk_widget_hide (bar->priv->mute_switch);
gtk_widget_hide (bar->mute_switch);
}
if (bar->priv->is_muted) {
if (bar->is_muted) {
/* If we aren't showing the mute button then
* move slider to the zero. But we don't want to
* change the adjustment. */
g_signal_handlers_block_by_func (bar->priv->zero_adjustment,
g_signal_handlers_block_by_func (bar->zero_adjustment,
on_zero_adjustment_value_changed,
bar);
gtk_adjustment_set_value (bar->priv->zero_adjustment, 0);
g_signal_handlers_unblock_by_func (bar->priv->zero_adjustment,
gtk_adjustment_set_value (bar->zero_adjustment, 0);
g_signal_handlers_unblock_by_func (bar->zero_adjustment,
on_zero_adjustment_value_changed,
bar);
gtk_range_set_adjustment (GTK_RANGE (bar->priv->scale),
bar->priv->zero_adjustment);
gtk_range_set_adjustment (GTK_RANGE (bar->scale),
bar->zero_adjustment);
} else {
/* no longer muted so restore the original adjustment
* and tell the front-end that the value changed */
gtk_range_set_adjustment (GTK_RANGE (bar->priv->scale),
bar->priv->adjustment);
gtk_adjustment_value_changed (bar->priv->adjustment);
gtk_range_set_adjustment (GTK_RANGE (bar->scale),
bar->adjustment);
gtk_adjustment_value_changed (bar->adjustment);
}
}
@ -558,10 +557,10 @@ gvc_channel_bar_set_is_muted (GvcChannelBar *bar,
{
g_return_if_fail (GVC_IS_CHANNEL_BAR (bar));
if (is_muted != bar->priv->is_muted) {
if (is_muted != bar->is_muted) {
/* Update our internal state before telling the
* front-end about our changes */
bar->priv->is_muted = is_muted;
bar->is_muted = is_muted;
update_mute_switch (bar);
g_object_notify (G_OBJECT (bar), "is-muted");
}
@ -571,7 +570,7 @@ gboolean
gvc_channel_bar_get_is_muted (GvcChannelBar *bar)
{
g_return_val_if_fail (GVC_IS_CHANNEL_BAR (bar), FALSE);
return bar->priv->is_muted;
return bar->is_muted;
}
void
@ -580,8 +579,8 @@ gvc_channel_bar_set_show_mute (GvcChannelBar *bar,
{
g_return_if_fail (GVC_IS_CHANNEL_BAR (bar));
if (show_mute != bar->priv->show_mute) {
bar->priv->show_mute = show_mute;
if (show_mute != bar->show_mute) {
bar->show_mute = show_mute;
g_object_notify (G_OBJECT (bar), "show-mute");
update_mute_switch (bar);
}
@ -591,7 +590,7 @@ gboolean
gvc_channel_bar_get_show_mute (GvcChannelBar *bar)
{
g_return_val_if_fail (GVC_IS_CHANNEL_BAR (bar), FALSE);
return bar->priv->show_mute;
return bar->show_mute;
}
void
@ -599,26 +598,26 @@ gvc_channel_bar_set_is_amplified (GvcChannelBar *bar, gboolean amplified)
{
g_return_if_fail (GVC_IS_CHANNEL_BAR (bar));
bar->priv->is_amplified = amplified;
gtk_adjustment_set_upper (bar->priv->adjustment, ADJUSTMENT_MAX);
gtk_adjustment_set_upper (bar->priv->zero_adjustment, ADJUSTMENT_MAX);
gtk_scale_clear_marks (GTK_SCALE (bar->priv->scale));
bar->is_amplified = amplified;
gtk_adjustment_set_upper (bar->adjustment, ADJUSTMENT_MAX);
gtk_adjustment_set_upper (bar->zero_adjustment, ADJUSTMENT_MAX);
gtk_scale_clear_marks (GTK_SCALE (bar->scale));
if (amplified) {
char *str;
if (bar->priv->base_volume == ADJUSTMENT_MAX_NORMAL) {
if (bar->base_volume == ADJUSTMENT_MAX_NORMAL) {
str = g_strdup_printf ("<small>%s</small>", C_("volume", "100%"));
gtk_scale_add_mark (GTK_SCALE (bar->priv->scale), ADJUSTMENT_MAX_NORMAL,
gtk_scale_add_mark (GTK_SCALE (bar->scale), ADJUSTMENT_MAX_NORMAL,
GTK_POS_BOTTOM, str);
} else {
str = g_strdup_printf ("<small>%s</small>", C_("volume", "Unamplified"));
gtk_scale_add_mark (GTK_SCALE (bar->priv->scale), bar->priv->base_volume,
gtk_scale_add_mark (GTK_SCALE (bar->scale), bar->base_volume,
GTK_POS_BOTTOM, str);
/* Only show 100% if it's higher than the base volume */
if (bar->priv->base_volume < ADJUSTMENT_MAX_NORMAL) {
if (bar->base_volume < ADJUSTMENT_MAX_NORMAL) {
str = g_strdup_printf ("<small>%s</small>", C_("volume", "100%"));
gtk_scale_add_mark (GTK_SCALE (bar->priv->scale), ADJUSTMENT_MAX_NORMAL,
gtk_scale_add_mark (GTK_SCALE (bar->scale), ADJUSTMENT_MAX_NORMAL,
GTK_POS_BOTTOM, str);
}
}
@ -629,19 +628,19 @@ gvc_channel_bar_set_is_amplified (GvcChannelBar *bar, gboolean amplified)
* these widgets plus the scale but neither GtkScale
* nor GtkSwitch support baseline alignment yet. */
gtk_widget_set_valign (bar->priv->mute_switch, GTK_ALIGN_START);
gtk_widget_set_valign (bar->mute_switch, GTK_ALIGN_START);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gtk_misc_set_alignment (GTK_MISC (bar->priv->low_image), 0.5, 0.15);
gtk_misc_set_alignment (GTK_MISC (bar->priv->high_image), 0.5, 0.15);
gtk_misc_set_alignment (GTK_MISC (bar->low_image), 0.5, 0.15);
gtk_misc_set_alignment (GTK_MISC (bar->high_image), 0.5, 0.15);
G_GNUC_END_IGNORE_DEPRECATIONS
gtk_widget_set_valign (bar->priv->label, GTK_ALIGN_START);
gtk_widget_set_valign (bar->label, GTK_ALIGN_START);
} else {
gtk_widget_set_valign (bar->priv->mute_switch, GTK_ALIGN_CENTER);
gtk_widget_set_valign (bar->mute_switch, GTK_ALIGN_CENTER);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gtk_misc_set_alignment (GTK_MISC (bar->priv->low_image), 0.5, 0.5);
gtk_misc_set_alignment (GTK_MISC (bar->priv->high_image), 0.5, 0.5);
gtk_misc_set_alignment (GTK_MISC (bar->low_image), 0.5, 0.5);
gtk_misc_set_alignment (GTK_MISC (bar->high_image), 0.5, 0.5);
G_GNUC_END_IGNORE_DEPRECATIONS
gtk_widget_set_valign (bar->priv->label, GTK_ALIGN_CENTER);
gtk_widget_set_valign (bar->label, GTK_ALIGN_CENTER);
}
}
@ -650,7 +649,7 @@ gvc_channel_bar_get_ellipsize (GvcChannelBar *bar)
{
g_return_val_if_fail (GVC_IS_CHANNEL_BAR (bar), FALSE);
return gtk_label_get_ellipsize (GTK_LABEL (bar->priv->label)) != PANGO_ELLIPSIZE_NONE;
return gtk_label_get_ellipsize (GTK_LABEL (bar->label)) != PANGO_ELLIPSIZE_NONE;
}
void
@ -660,9 +659,9 @@ gvc_channel_bar_set_ellipsize (GvcChannelBar *bar,
g_return_if_fail (GVC_IS_CHANNEL_BAR (bar));
if (ellipsized)
gtk_label_set_ellipsize (GTK_LABEL (bar->priv->label), PANGO_ELLIPSIZE_END);
gtk_label_set_ellipsize (GTK_LABEL (bar->label), PANGO_ELLIPSIZE_END);
else
gtk_label_set_ellipsize (GTK_LABEL (bar->priv->label), PANGO_ELLIPSIZE_NONE);
gtk_label_set_ellipsize (GTK_LABEL (bar->label), PANGO_ELLIPSIZE_NONE);
}
void
@ -672,12 +671,12 @@ gvc_channel_bar_set_base_volume (GvcChannelBar *bar,
g_return_if_fail (GVC_IS_CHANNEL_BAR (bar));
if (base_volume == 0) {
bar->priv->base_volume = ADJUSTMENT_MAX_NORMAL;
bar->base_volume = ADJUSTMENT_MAX_NORMAL;
return;
}
/* Note that you need to call _is_amplified() afterwards to update the marks */
bar->priv->base_volume = base_volume;
bar->base_volume = base_volume;
}
static void
@ -732,35 +731,34 @@ gvc_channel_bar_get_property (GObject *object,
GParamSpec *pspec)
{
GvcChannelBar *self = GVC_CHANNEL_BAR (object);
GvcChannelBarPrivate *priv = self->priv;
switch (prop_id) {
case PROP_ORIENTATION:
g_value_set_enum (value, priv->orientation);
g_value_set_enum (value, self->orientation);
break;
case PROP_IS_MUTED:
g_value_set_boolean (value, priv->is_muted);
g_value_set_boolean (value, self->is_muted);
break;
case PROP_SHOW_MUTE:
g_value_set_boolean (value, priv->show_mute);
g_value_set_boolean (value, self->show_mute);
break;
case PROP_NAME:
g_value_set_string (value, priv->name);
g_value_set_string (value, self->name);
break;
case PROP_ICON_NAME:
g_value_set_string (value, priv->icon_name);
g_value_set_string (value, self->icon_name);
break;
case PROP_LOW_ICON_NAME:
g_value_set_string (value, priv->low_icon_name);
g_value_set_string (value, self->low_icon_name);
break;
case PROP_HIGH_ICON_NAME:
g_value_set_string (value, priv->high_icon_name);
g_value_set_string (value, self->high_icon_name);
break;
case PROP_ADJUSTMENT:
g_value_set_object (value, gvc_channel_bar_get_adjustment (self));
break;
case PROP_IS_AMPLIFIED:
g_value_set_boolean (value, priv->is_amplified);
g_value_set_boolean (value, self->is_amplified);
break;
case PROP_ELLIPSIZE:
g_value_set_boolean (value, gvc_channel_bar_get_ellipsize (self));
@ -870,7 +868,6 @@ gvc_channel_bar_class_init (GvcChannelBarClass *klass)
"Whether the label is ellipsized",
FALSE,
G_PARAM_READWRITE|G_PARAM_CONSTRUCT));
g_type_class_add_private (klass, sizeof (GvcChannelBarPrivate));
}
static void
@ -888,56 +885,54 @@ gvc_channel_bar_init (GvcChannelBar *bar)
{
GtkWidget *frame;
bar->priv = GVC_CHANNEL_BAR_GET_PRIVATE (bar);
bar->base_volume = ADJUSTMENT_MAX_NORMAL;
bar->low_icon_name = g_strdup ("audio-volume-low-symbolic");
bar->high_icon_name = g_strdup ("audio-volume-high-symbolic");
bar->priv->base_volume = ADJUSTMENT_MAX_NORMAL;
bar->priv->low_icon_name = g_strdup ("audio-volume-low-symbolic");
bar->priv->high_icon_name = g_strdup ("audio-volume-high-symbolic");
bar->priv->orientation = GTK_ORIENTATION_HORIZONTAL;
bar->priv->adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0,
bar->orientation = GTK_ORIENTATION_HORIZONTAL;
bar->adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0,
0.0,
ADJUSTMENT_MAX_NORMAL,
ADJUSTMENT_MAX_NORMAL/100.0,
ADJUSTMENT_MAX_NORMAL/10.0,
0.0));
g_object_ref_sink (bar->priv->adjustment);
g_object_ref_sink (bar->adjustment);
bar->priv->zero_adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0,
bar->zero_adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0,
0.0,
ADJUSTMENT_MAX_NORMAL,
ADJUSTMENT_MAX_NORMAL/100.0,
ADJUSTMENT_MAX_NORMAL/10.0,
0.0));
g_object_ref_sink (bar->priv->zero_adjustment);
g_object_ref_sink (bar->zero_adjustment);
g_signal_connect (bar->priv->zero_adjustment,
g_signal_connect (bar->zero_adjustment,
"value-changed",
G_CALLBACK (on_zero_adjustment_value_changed),
bar);
bar->priv->mute_switch = gtk_switch_new ();
gtk_widget_set_no_show_all (bar->priv->mute_switch, TRUE);
g_signal_connect (bar->priv->mute_switch,
bar->mute_switch = gtk_switch_new ();
gtk_widget_set_no_show_all (bar->mute_switch, TRUE);
g_signal_connect (bar->mute_switch,
"notify::active",
G_CALLBACK (on_mute_switch_toggled),
bar);
bar->priv->low_image = gtk_image_new_from_icon_name ("audio-volume-low-symbolic",
bar->low_image = gtk_image_new_from_icon_name ("audio-volume-low-symbolic",
GTK_ICON_SIZE_MENU);
gtk_style_context_add_class (gtk_widget_get_style_context (bar->priv->low_image), "dim-label");
gtk_widget_set_no_show_all (bar->priv->low_image, TRUE);
bar->priv->high_image = gtk_image_new_from_icon_name ("audio-volume-high-symbolic",
gtk_style_context_add_class (gtk_widget_get_style_context (bar->low_image), "dim-label");
gtk_widget_set_no_show_all (bar->low_image, TRUE);
bar->high_image = gtk_image_new_from_icon_name ("audio-volume-high-symbolic",
GTK_ICON_SIZE_MENU);
gtk_style_context_add_class (gtk_widget_get_style_context (bar->priv->high_image), "dim-label");
gtk_widget_set_no_show_all (bar->priv->high_image, TRUE);
gtk_style_context_add_class (gtk_widget_get_style_context (bar->high_image), "dim-label");
gtk_widget_set_no_show_all (bar->high_image, TRUE);
bar->priv->image = gtk_image_new ();
gtk_widget_set_no_show_all (bar->priv->image, TRUE);
bar->image = gtk_image_new ();
gtk_widget_set_no_show_all (bar->image, TRUE);
bar->priv->label = gtk_label_new (NULL);
gtk_widget_set_halign (bar->priv->label, GTK_ALIGN_START);
gtk_widget_set_no_show_all (bar->priv->label, TRUE);
bar->label = gtk_label_new (NULL);
gtk_widget_set_halign (bar->label, GTK_ALIGN_START);
gtk_widget_set_no_show_all (bar->label, TRUE);
/* frame */
frame = gtk_frame_new (NULL);
@ -946,9 +941,9 @@ gvc_channel_bar_init (GvcChannelBar *bar)
gtk_widget_show_all (frame);
/* box with scale */
bar->priv->scale_box = _scale_box_new (bar);
bar->scale_box = _scale_box_new (bar);
gtk_container_add (GTK_CONTAINER (frame), bar->priv->scale_box);
gtk_container_add (GTK_CONTAINER (frame), bar->scale_box);
gtk_widget_show_all (frame);
}
@ -962,12 +957,12 @@ gvc_channel_bar_finalize (GObject *object)
channel_bar = GVC_CHANNEL_BAR (object);
g_return_if_fail (channel_bar->priv != NULL);
g_return_if_fail (channel_bar != NULL);
g_free (channel_bar->priv->name);
g_free (channel_bar->priv->icon_name);
g_free (channel_bar->priv->low_icon_name);
g_free (channel_bar->priv->high_icon_name);
g_free (channel_bar->name);
g_free (channel_bar->icon_name);
g_free (channel_bar->low_icon_name);
g_free (channel_bar->high_icon_name);
G_OBJECT_CLASS (gvc_channel_bar_parent_class)->finalize (object);
}

23
panels/sound/gvc-channel-bar.h
View file

@ -24,27 +24,8 @@
G_BEGIN_DECLS
#define GVC_TYPE_CHANNEL_BAR (gvc_channel_bar_get_type ())
#define GVC_CHANNEL_BAR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GVC_TYPE_CHANNEL_BAR, GvcChannelBar))
#define GVC_CHANNEL_BAR_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GVC_TYPE_CHANNEL_BAR, GvcChannelBarClass))
#define GVC_IS_CHANNEL_BAR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GVC_TYPE_CHANNEL_BAR))
#define GVC_IS_CHANNEL_BAR_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GVC_TYPE_CHANNEL_BAR))
#define GVC_CHANNEL_BAR_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GVC_TYPE_CHANNEL_BAR, GvcChannelBarClass))
typedef struct GvcChannelBarPrivate GvcChannelBarPrivate;
typedef struct
{
GtkBox parent;
GvcChannelBarPrivate *priv;
} GvcChannelBar;
typedef struct
{
GtkBoxClass parent_class;
} GvcChannelBarClass;
GType gvc_channel_bar_get_type (void);
#define GVC_TYPE_CHANNEL_BAR (gvc_channel_bar_get_type ())
G_DECLARE_FINAL_TYPE (GvcChannelBar, gvc_channel_bar, GVC, CHANNEL_BAR, GtkBox)
GtkWidget * gvc_channel_bar_new (void);

124
panels/sound/gvc-combo-box.c
View file

@ -33,10 +33,10 @@
#include "gvc-mixer-stream.h"
#include "gvc-mixer-card.h"
#define GVC_COMBO_BOX_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GVC_TYPE_COMBO_BOX, GvcComboBoxPrivate))
struct GvcComboBoxPrivate
struct _GvcComboBox
{
GtkBox parent_instance;
GtkWidget *drop_box;
GtkWidget *start_box;
GtkWidget *end_box;
@ -83,16 +83,16 @@ gvc_combo_box_set_size_group (GvcComboBox *combo_box,
{
g_return_if_fail (GVC_IS_COMBO_BOX (combo_box));
combo_box->priv->size_group = group;
combo_box->priv->symmetric = symmetric;
combo_box->size_group = group;
combo_box->symmetric = symmetric;
if (combo_box->priv->size_group != NULL) {
gtk_size_group_add_widget (combo_box->priv->size_group,
combo_box->priv->start_box);
if (combo_box->size_group != NULL) {
gtk_size_group_add_widget (combo_box->size_group,
combo_box->start_box);
if (combo_box->priv->symmetric) {
gtk_size_group_add_widget (combo_box->priv->size_group,
combo_box->priv->end_box);
if (combo_box->symmetric) {
gtk_size_group_add_widget (combo_box->size_group,
combo_box->end_box);
}
}
gtk_widget_queue_draw (GTK_WIDGET (combo_box));
@ -108,13 +108,13 @@ gvc_combo_box_set_property (GObject *object,
switch (prop_id) {
case PROP_LABEL:
gtk_label_set_text_with_mnemonic (GTK_LABEL (self->priv->label), g_value_get_string (value));
gtk_label_set_text_with_mnemonic (GTK_LABEL (self->label), g_value_get_string (value));
break;
case PROP_BUTTON_LABEL:
gtk_button_set_label (GTK_BUTTON (self->priv->button), g_value_get_string (value));
gtk_button_set_label (GTK_BUTTON (self->button), g_value_get_string (value));
break;
case PROP_SHOW_BUTTON:
gtk_widget_set_visible (self->priv->button, g_value_get_boolean (value));
gtk_widget_set_visible (self->button, g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -133,15 +133,15 @@ gvc_combo_box_get_property (GObject *object,
switch (prop_id) {
case PROP_LABEL:
g_value_set_string (value,
gtk_label_get_text (GTK_LABEL (self->priv->label)));
gtk_label_get_text (GTK_LABEL (self->label)));
break;
case PROP_BUTTON_LABEL:
g_value_set_string (value,
gtk_button_get_label (GTK_BUTTON (self->priv->button)));
gtk_button_get_label (GTK_BUTTON (self->button)));
break;
case PROP_SHOW_BUTTON:
g_value_set_boolean (value,
gtk_widget_get_visible (self->priv->button));
gtk_widget_get_visible (self->button));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -183,7 +183,7 @@ gvc_combo_box_class_init (GvcComboBoxClass *klass)
g_signal_new ("changed",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GvcComboBoxClass, changed),
0,
NULL, NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1, G_TYPE_STRING);
@ -191,12 +191,10 @@ gvc_combo_box_class_init (GvcComboBoxClass *klass)
g_signal_new ("button-clicked",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GvcComboBoxClass, button_clicked),
0,
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0, G_TYPE_NONE);
g_type_class_add_private (klass, sizeof (GvcComboBoxPrivate));
}
void
@ -206,19 +204,19 @@ gvc_combo_box_set_profiles (GvcComboBox *combo_box,
const GList *l;
g_return_if_fail (GVC_IS_COMBO_BOX (combo_box));
g_return_if_fail (combo_box->priv->set_called == FALSE);
g_return_if_fail (combo_box->set_called == FALSE);
for (l = profiles; l != NULL; l = l->next) {
GvcMixerCardProfile *p = l->data;
gtk_list_store_insert_with_values (GTK_LIST_STORE (combo_box->priv->model),
gtk_list_store_insert_with_values (GTK_LIST_STORE (combo_box->model),
NULL,
G_MAXINT,
COL_NAME, p->profile,
COL_HUMAN_NAME, p->human_profile,
-1);
}
combo_box->priv->set_called = TRUE;
combo_box->set_called = TRUE;
}
void
@ -228,19 +226,19 @@ gvc_combo_box_set_ports (GvcComboBox *combo_box,
const GList *l;
g_return_if_fail (GVC_IS_COMBO_BOX (combo_box));
g_return_if_fail (combo_box->priv->set_called == FALSE);
g_return_if_fail (combo_box->set_called == FALSE);
for (l = ports; l != NULL; l = l->next) {
GvcMixerStreamPort *p = l->data;
gtk_list_store_insert_with_values (GTK_LIST_STORE (combo_box->priv->model),
gtk_list_store_insert_with_values (GTK_LIST_STORE (combo_box->model),
NULL,
G_MAXINT,
COL_NAME, p->port,
COL_HUMAN_NAME, p->human_port,
-1);
}
combo_box->priv->set_called = TRUE;
combo_box->set_called = TRUE;
}
void
@ -250,18 +248,18 @@ gvc_combo_box_set_active (GvcComboBox *combo_box,
GtkTreeIter iter;
gboolean cont;
cont = gtk_tree_model_get_iter_first (combo_box->priv->model, &iter);
cont = gtk_tree_model_get_iter_first (combo_box->model, &iter);
while (cont != FALSE) {
char *name;
gtk_tree_model_get (combo_box->priv->model, &iter,
gtk_tree_model_get (combo_box->model, &iter,
COL_NAME, &name,
-1);
if (g_strcmp0 (name, id) == 0) {
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo_box->priv->combobox), &iter);
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo_box->combobox), &iter);
return;
}
cont = gtk_tree_model_iter_next (combo_box->priv->model, &iter);
cont = gtk_tree_model_iter_next (combo_box->model, &iter);
}
g_warning ("Could not find id '%s' in combo box", id);
}
@ -278,7 +276,7 @@ on_combo_box_changed (GtkComboBox *widget,
return;
}
gtk_tree_model_get (combo_box->priv->model, &iter,
gtk_tree_model_get (combo_box->model, &iter,
COL_NAME, &profile,
-1);
g_signal_emit (combo_box, signals[CHANGED], 0, profile);
@ -301,67 +299,65 @@ gvc_combo_box_init (GvcComboBox *combo_box)
GtkWidget *ebox;
GtkCellRenderer *renderer;
combo_box->priv = GVC_COMBO_BOX_GET_PRIVATE (combo_box);
combo_box->model = GTK_TREE_MODEL (gtk_list_store_new (NUM_COLS,
G_TYPE_STRING,
G_TYPE_STRING));
combo_box->priv->model = GTK_TREE_MODEL (gtk_list_store_new (NUM_COLS,
G_TYPE_STRING,
G_TYPE_STRING));
combo_box->priv->label = gtk_label_new (NULL);
gtk_widget_set_halign (combo_box->priv->label, GTK_ALIGN_START);
combo_box->label = gtk_label_new (NULL);
gtk_widget_set_halign (combo_box->label, GTK_ALIGN_START);
/* frame */
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
gtk_box_pack_start (GTK_BOX (combo_box), frame, TRUE, TRUE, 0);
combo_box->priv->drop_box = box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
combo_box->priv->combobox = gtk_combo_box_new_with_model (combo_box->priv->model);
combo_box->drop_box = box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
combo_box->combobox = gtk_combo_box_new_with_model (combo_box->model);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box->priv->combobox),
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box->combobox),
renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo_box->priv->combobox),
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo_box->combobox),
renderer,
"text", COL_HUMAN_NAME);
/* Make sure that the combo box isn't too wide when human names are overly long,
* but that we can still read the full length of it */
g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
g_object_set (G_OBJECT (combo_box->priv->combobox), "popup-fixed-width", FALSE, NULL);
g_object_set (G_OBJECT (combo_box->combobox), "popup-fixed-width", FALSE, NULL);
combo_box->priv->start_box = sbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
combo_box->start_box = sbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (box), sbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (sbox), combo_box->priv->label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (sbox), combo_box->label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), combo_box->priv->combobox, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box), combo_box->combobox, TRUE, TRUE, 0);
combo_box->priv->button = gtk_button_new_with_label ("APPLICATION BUG");
gtk_button_set_use_underline (GTK_BUTTON (combo_box->priv->button), TRUE);
gtk_widget_set_no_show_all (combo_box->priv->button, TRUE);
gtk_box_pack_start (GTK_BOX (box), combo_box->priv->button, FALSE, FALSE, 0);
combo_box->button = gtk_button_new_with_label ("APPLICATION BUG");
gtk_button_set_use_underline (GTK_BUTTON (combo_box->button), TRUE);
gtk_widget_set_no_show_all (combo_box->button, TRUE);
gtk_box_pack_start (GTK_BOX (box), combo_box->button, FALSE, FALSE, 0);
combo_box->priv->end_box = ebox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
combo_box->end_box = ebox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (box), ebox, FALSE, FALSE, 0);
if (combo_box->priv->size_group != NULL) {
gtk_size_group_add_widget (combo_box->priv->size_group, sbox);
if (combo_box->size_group != NULL) {
gtk_size_group_add_widget (combo_box->size_group, sbox);
if (combo_box->priv->symmetric) {
gtk_size_group_add_widget (combo_box->priv->size_group, ebox);
if (combo_box->symmetric) {
gtk_size_group_add_widget (combo_box->size_group, ebox);
}
}
gtk_container_add (GTK_CONTAINER (frame), combo_box->priv->drop_box);
gtk_container_add (GTK_CONTAINER (frame), combo_box->drop_box);
gtk_widget_show_all (frame);
gtk_label_set_mnemonic_widget (GTK_LABEL (combo_box->priv->label),
combo_box->priv->combobox);
gtk_label_set_mnemonic_widget (GTK_LABEL (combo_box->label),
combo_box->combobox);
g_signal_connect (G_OBJECT (combo_box->priv->combobox), "changed",
g_signal_connect (G_OBJECT (combo_box->combobox), "changed",
G_CALLBACK (on_combo_box_changed), combo_box);
g_signal_connect (G_OBJECT (combo_box->priv->button), "clicked",
g_signal_connect (G_OBJECT (combo_box->button), "clicked",
G_CALLBACK (on_combo_box_button_clicked), combo_box);
}
@ -375,10 +371,10 @@ gvc_combo_box_finalize (GObject *object)
combo_box = GVC_COMBO_BOX (object);
g_return_if_fail (combo_box->priv != NULL);
g_return_if_fail (combo_box != NULL);
g_object_unref (combo_box->priv->model);
combo_box->priv->model = NULL;
g_object_unref (combo_box->model);
combo_box->model = NULL;
G_OBJECT_CLASS (gvc_combo_box_parent_class)->finalize (object);
}

25
panels/sound/gvc-combo-box.h
View file

@ -24,29 +24,8 @@
G_BEGIN_DECLS
#define GVC_TYPE_COMBO_BOX (gvc_combo_box_get_type ())
#define GVC_COMBO_BOX(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GVC_TYPE_COMBO_BOX, GvcComboBox))
#define GVC_COMBO_BOX_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GVC_TYPE_COMBO_BOX, GvcComboBoxClass))
#define GVC_IS_COMBO_BOX(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GVC_TYPE_COMBO_BOX))
#define GVC_IS_COMBO_BOX_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GVC_TYPE_COMBO_BOX))
#define GVC_COMBO_BOX_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GVC_TYPE_COMBO_BOX, GvcComboBoxClass))
typedef struct GvcComboBoxPrivate GvcComboBoxPrivate;
typedef struct
{
GtkBox parent;
GvcComboBoxPrivate *priv;
} GvcComboBox;
typedef struct
{
GtkBoxClass parent_class;
void (* changed) (GvcComboBox *combobox, const char *name);
void (* button_clicked) (GvcComboBox *combobox);
} GvcComboBoxClass;
GType gvc_combo_box_get_type (void);
#define GVC_TYPE_COMBO_BOX (gvc_combo_box_get_type ())
G_DECLARE_FINAL_TYPE (GvcComboBox, gvc_combo_box, GVC, COMBO_BOX, GtkBox)
GtkWidget * gvc_combo_box_new (const char *label);

218
panels/sound/gvc-level-bar.c
View file

@ -32,8 +32,6 @@
#define NUM_BOXES 30
#define GVC_LEVEL_BAR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GVC_TYPE_LEVEL_BAR, GvcLevelBarPrivate))
#define MIN_HORIZONTAL_BAR_WIDTH 150
#define HORIZONTAL_BAR_HEIGHT 6
#define VERTICAL_BAR_WIDTH 6
@ -59,8 +57,10 @@ typedef struct {
double fl_b;
} LevelBarLayout;
struct GvcLevelBarPrivate
struct _GvcLevelBar
{
GtkWidget parent_instance;
GtkOrientation orientation;
GtkAdjustment *peak_adjustment;
GtkAdjustment *rms_adjustment;
@ -132,7 +132,7 @@ fraction_from_adjustment (GvcLevelBar *bar,
min = gtk_adjustment_get_lower (adjustment);
max = gtk_adjustment_get_upper (adjustment);
switch (bar->priv->scale) {
switch (bar->scale) {
case GVC_LEVEL_SCALE_LINEAR:
fraction = (level - min) / (max - min);
break;
@ -151,11 +151,11 @@ reset_max_peak (GvcLevelBar *bar)
{
gdouble min;
min = gtk_adjustment_get_lower (bar->priv->peak_adjustment);
bar->priv->max_peak = min;
bar->priv->layout.max_peak_num = 0;
min = gtk_adjustment_get_lower (bar->peak_adjustment);
bar->max_peak = min;
bar->layout.max_peak_num = 0;
gtk_widget_queue_draw (GTK_WIDGET (bar));
bar->priv->max_peak_id = 0;
bar->max_peak_id = 0;
return FALSE;
}
@ -169,51 +169,51 @@ bar_calc_layout (GvcLevelBar *bar)
GtkStyle *style;
gtk_widget_get_allocation (GTK_WIDGET (bar), &allocation);
bar->priv->layout.area.width = allocation.width - 2;
bar->priv->layout.area.height = allocation.height - 2;
bar->layout.area.width = allocation.width - 2;
bar->layout.area.height = allocation.height - 2;
style = gtk_widget_get_style (GTK_WIDGET (bar));
color = style->bg [GTK_STATE_NORMAL];
bar->priv->layout.bg_r = (float)color.red / 65535.0;
bar->priv->layout.bg_g = (float)color.green / 65535.0;
bar->priv->layout.bg_b = (float)color.blue / 65535.0;
bar->layout.bg_r = (float)color.red / 65535.0;
bar->layout.bg_g = (float)color.green / 65535.0;
bar->layout.bg_b = (float)color.blue / 65535.0;
color = style->dark [GTK_STATE_NORMAL];
bar->priv->layout.bdr_r = (float)color.red / 65535.0;
bar->priv->layout.bdr_g = (float)color.green / 65535.0;
bar->priv->layout.bdr_b = (float)color.blue / 65535.0;
bar->layout.bdr_r = (float)color.red / 65535.0;
bar->layout.bdr_g = (float)color.green / 65535.0;
bar->layout.bdr_b = (float)color.blue / 65535.0;
color = style->bg [GTK_STATE_SELECTED];
bar->priv->layout.fl_r = (float)color.red / 65535.0;
bar->priv->layout.fl_g = (float)color.green / 65535.0;
bar->priv->layout.fl_b = (float)color.blue / 65535.0;
bar->layout.fl_r = (float)color.red / 65535.0;
bar->layout.fl_g = (float)color.green / 65535.0;
bar->layout.fl_b = (float)color.blue / 65535.0;
if (bar->priv->orientation == GTK_ORIENTATION_VERTICAL) {
peak_level = bar->priv->peak_fraction * bar->priv->layout.area.height;
max_peak_level = bar->priv->max_peak * bar->priv->layout.area.height;
if (bar->orientation == GTK_ORIENTATION_VERTICAL) {
peak_level = bar->peak_fraction * bar->layout.area.height;
max_peak_level = bar->max_peak * bar->layout.area.height;
bar->priv->layout.delta = bar->priv->layout.area.height / NUM_BOXES;
bar->priv->layout.area.x = 0;
bar->priv->layout.area.y = 0;
bar->priv->layout.box_height = bar->priv->layout.delta / 2;
bar->priv->layout.box_width = bar->priv->layout.area.width;
bar->priv->layout.box_radius = bar->priv->layout.box_width / 2;
bar->layout.delta = bar->layout.area.height / NUM_BOXES;
bar->layout.area.x = 0;
bar->layout.area.y = 0;
bar->layout.box_height = bar->layout.delta / 2;
bar->layout.box_width = bar->layout.area.width;
bar->layout.box_radius = bar->layout.box_width / 2;
} else {
peak_level = bar->priv->peak_fraction * bar->priv->layout.area.width;
max_peak_level = bar->priv->max_peak * bar->priv->layout.area.width;
peak_level = bar->peak_fraction * bar->layout.area.width;
max_peak_level = bar->max_peak * bar->layout.area.width;
bar->priv->layout.delta = bar->priv->layout.area.width / NUM_BOXES;
bar->priv->layout.area.x = 0;
bar->priv->layout.area.y = 0;
bar->priv->layout.box_width = bar->priv->layout.delta / 2;
bar->priv->layout.box_height = bar->priv->layout.area.height;
bar->priv->layout.box_radius = bar->priv->layout.box_height / 2;
bar->layout.delta = bar->layout.area.width / NUM_BOXES;
bar->layout.area.x = 0;
bar->layout.area.y = 0;
bar->layout.box_width = bar->layout.delta / 2;
bar->layout.box_height = bar->layout.area.height;
bar->layout.box_radius = bar->layout.box_height / 2;
}
/* This can happen if the level bar isn't realized */
if (bar->priv->layout.delta == 0)
if (bar->layout.delta == 0)
return;
bar->priv->layout.peak_num = peak_level / bar->priv->layout.delta;
bar->priv->layout.max_peak_num = max_peak_level / bar->priv->layout.delta;
bar->layout.peak_num = peak_level / bar->layout.delta;
bar->layout.max_peak_num = max_peak_level / bar->layout.delta;
}
static void
@ -222,22 +222,22 @@ update_peak_value (GvcLevelBar *bar)
gdouble val;
LevelBarLayout layout;
layout = bar->priv->layout;
layout = bar->layout;
val = fraction_from_adjustment (bar, bar->priv->peak_adjustment);
bar->priv->peak_fraction = val;
val = fraction_from_adjustment (bar, bar->peak_adjustment);
bar->peak_fraction = val;
if (val > bar->priv->max_peak) {
if (bar->priv->max_peak_id > 0) {
g_source_remove (bar->priv->max_peak_id);
if (val > bar->max_peak) {
if (bar->max_peak_id > 0) {
g_source_remove (bar->max_peak_id);
}
bar->priv->max_peak_id = g_timeout_add_seconds (1, (GSourceFunc)reset_max_peak, bar);
bar->priv->max_peak = val;
bar->max_peak_id = g_timeout_add_seconds (1, (GSourceFunc)reset_max_peak, bar);
bar->max_peak = val;
}
bar_calc_layout (bar);
if (layout_changed (&bar->priv->layout, &layout)) {
if (layout_changed (&bar->layout, &layout)) {
gtk_widget_queue_draw (GTK_WIDGET (bar));
}
}
@ -247,15 +247,15 @@ update_rms_value (GvcLevelBar *bar)
{
gdouble val;
val = fraction_from_adjustment (bar, bar->priv->rms_adjustment);
bar->priv->rms_fraction = val;
val = fraction_from_adjustment (bar, bar->rms_adjustment);
bar->rms_fraction = val;
}
GtkOrientation
gvc_level_bar_get_orientation (GvcLevelBar *bar)
{
g_return_val_if_fail (GVC_IS_LEVEL_BAR (bar), 0);
return bar->priv->orientation;
return bar->orientation;
}
void
@ -264,8 +264,8 @@ gvc_level_bar_set_orientation (GvcLevelBar *bar,
{
g_return_if_fail (GVC_IS_LEVEL_BAR (bar));
if (orientation != bar->priv->orientation) {
bar->priv->orientation = orientation;
if (orientation != bar->orientation) {
bar->orientation = orientation;
gtk_widget_queue_draw (GTK_WIDGET (bar));
g_object_notify (G_OBJECT (bar), "orientation");
}
@ -292,16 +292,16 @@ gvc_level_bar_set_peak_adjustment (GvcLevelBar *bar,
g_return_if_fail (GVC_LEVEL_BAR (bar));
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
if (bar->priv->peak_adjustment != NULL) {
g_signal_handlers_disconnect_by_func (bar->priv->peak_adjustment,
if (bar->peak_adjustment != NULL) {
g_signal_handlers_disconnect_by_func (bar->peak_adjustment,
G_CALLBACK (on_peak_adjustment_value_changed),
bar);
g_object_unref (bar->priv->peak_adjustment);
g_object_unref (bar->peak_adjustment);
}
bar->priv->peak_adjustment = g_object_ref_sink (adjustment);
bar->peak_adjustment = g_object_ref_sink (adjustment);
g_signal_connect (bar->priv->peak_adjustment,
g_signal_connect (bar->peak_adjustment,
"value-changed",
G_CALLBACK (on_peak_adjustment_value_changed),
bar);
@ -318,17 +318,17 @@ gvc_level_bar_set_rms_adjustment (GvcLevelBar *bar,
g_return_if_fail (GVC_LEVEL_BAR (bar));
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
if (bar->priv->rms_adjustment != NULL) {
g_signal_handlers_disconnect_by_func (bar->priv->peak_adjustment,
if (bar->rms_adjustment != NULL) {
g_signal_handlers_disconnect_by_func (bar->peak_adjustment,
G_CALLBACK (on_rms_adjustment_value_changed),
bar);
g_object_unref (bar->priv->rms_adjustment);
g_object_unref (bar->rms_adjustment);
}
bar->priv->rms_adjustment = g_object_ref_sink (adjustment);
bar->rms_adjustment = g_object_ref_sink (adjustment);
g_signal_connect (bar->priv->peak_adjustment,
g_signal_connect (bar->peak_adjustment,
"value-changed",
G_CALLBACK (on_peak_adjustment_value_changed),
bar);
@ -343,7 +343,7 @@ gvc_level_bar_get_peak_adjustment (GvcLevelBar *bar)
{
g_return_val_if_fail (GVC_IS_LEVEL_BAR (bar), NULL);
return bar->priv->peak_adjustment;
return bar->peak_adjustment;
}
GtkAdjustment *
@ -351,7 +351,7 @@ gvc_level_bar_get_rms_adjustment (GvcLevelBar *bar)
{
g_return_val_if_fail (GVC_IS_LEVEL_BAR (bar), NULL);
return bar->priv->rms_adjustment;
return bar->rms_adjustment;
}
void
@ -360,8 +360,8 @@ gvc_level_bar_set_scale (GvcLevelBar *bar,
{
g_return_if_fail (GVC_IS_LEVEL_BAR (bar));
if (scale != bar->priv->scale) {
bar->priv->scale = scale;
if (scale != bar->scale) {
bar->scale = scale;
update_peak_value (bar);
update_rms_value (bar);
@ -407,16 +407,16 @@ gvc_level_bar_get_property (GObject *object,
switch (prop_id) {
case PROP_SCALE:
g_value_set_int (value, self->priv->scale);
g_value_set_int (value, self->scale);
break;
case PROP_ORIENTATION:
g_value_set_enum (value, self->priv->orientation);
g_value_set_enum (value, self->orientation);
break;
case PROP_PEAK_ADJUSTMENT:
g_value_set_object (value, self->priv->peak_adjustment);
g_value_set_object (value, self->peak_adjustment);
break;
case PROP_RMS_ADJUSTMENT:
g_value_set_object (value, self->priv->rms_adjustment);
g_value_set_object (value, self->rms_adjustment);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -438,7 +438,7 @@ gvc_level_bar_size_request (GtkWidget *widget,
{
GvcLevelBar *bar = GVC_LEVEL_BAR (widget);
switch (bar->priv->orientation) {
switch (bar->orientation) {
case GTK_ORIENTATION_VERTICAL:
requisition->width = VERTICAL_BAR_WIDTH;
requisition->height = MIN_VERTICAL_BAR_HEIGHT;
@ -504,7 +504,7 @@ gvc_level_bar_size_allocate (GtkWidget *widget,
gtk_widget_set_allocation (widget, allocation);
gtk_widget_get_allocation (widget, allocation);
if (bar->priv->orientation == GTK_ORIENTATION_VERTICAL) {
if (bar->orientation == GTK_ORIENTATION_VERTICAL) {
allocation->height = MIN (allocation->height, MIN_VERTICAL_BAR_HEIGHT);
allocation->width = MAX (allocation->width, VERTICAL_BAR_WIDTH);
} else {
@ -584,37 +584,37 @@ gvc_level_bar_draw (GtkWidget *widget,
cairo_save (cr);
if (bar->priv->orientation == GTK_ORIENTATION_VERTICAL) {
if (bar->orientation == GTK_ORIENTATION_VERTICAL) {
int i;
int by;
for (i = 0; i < NUM_BOXES; i++) {
by = i * bar->priv->layout.delta;
by = i * bar->layout.delta;
curved_rectangle (cr,
bar->priv->layout.area.x + 0.5,
bar->layout.area.x + 0.5,
by + 0.5,
bar->priv->layout.box_width - 1,
bar->priv->layout.box_height - 1,
bar->priv->layout.box_radius);
if ((bar->priv->layout.max_peak_num - 1) == i) {
bar->layout.box_width - 1,
bar->layout.box_height - 1,
bar->layout.box_radius);
if ((bar->layout.max_peak_num - 1) == i) {
/* fill peak foreground */
cairo_set_source_rgb (cr, bar->priv->layout.fl_r, bar->priv->layout.fl_g, bar->priv->layout.fl_b);
cairo_set_source_rgb (cr, bar->layout.fl_r, bar->layout.fl_g, bar->layout.fl_b);
cairo_fill_preserve (cr);
} else if ((bar->priv->layout.peak_num - 1) >= i) {
} else if ((bar->layout.peak_num - 1) >= i) {
/* fill background */
cairo_set_source_rgb (cr, bar->priv->layout.bg_r, bar->priv->layout.bg_g, bar->priv->layout.bg_b);
cairo_set_source_rgb (cr, bar->layout.bg_r, bar->layout.bg_g, bar->layout.bg_b);
cairo_fill_preserve (cr);
/* fill foreground */
cairo_set_source_rgba (cr, bar->priv->layout.fl_r, bar->priv->layout.fl_g, bar->priv->layout.fl_b, 0.5);
cairo_set_source_rgba (cr, bar->layout.fl_r, bar->layout.fl_g, bar->layout.fl_b, 0.5);
cairo_fill_preserve (cr);
} else {
/* fill background */
cairo_set_source_rgb (cr, bar->priv->layout.bg_r, bar->priv->layout.bg_g, bar->priv->layout.bg_b);
cairo_set_source_rgb (cr, bar->layout.bg_r, bar->layout.bg_g, bar->layout.bg_b);
cairo_fill_preserve (cr);
}
/* stroke border */
cairo_set_source_rgb (cr, bar->priv->layout.bdr_r, bar->priv->layout.bdr_g, bar->priv->layout.bdr_b);
cairo_set_source_rgb (cr, bar->layout.bdr_r, bar->layout.bdr_g, bar->layout.bdr_b);
cairo_set_line_width (cr, 1);
cairo_stroke (cr);
}
@ -629,33 +629,33 @@ gvc_level_bar_draw (GtkWidget *widget,
}
for (i = 0; i < NUM_BOXES; i++) {
bx = i * bar->priv->layout.delta;
bx = i * bar->layout.delta;
curved_rectangle (cr,
bx + 0.5,
bar->priv->layout.area.y + 0.5,
bar->priv->layout.box_width - 1,
bar->priv->layout.box_height - 1,
bar->priv->layout.box_radius);
bar->layout.area.y + 0.5,
bar->layout.box_width - 1,
bar->layout.box_height - 1,
bar->layout.box_radius);
if ((bar->priv->layout.max_peak_num - 1) == i) {
if ((bar->layout.max_peak_num - 1) == i) {
/* fill peak foreground */
cairo_set_source_rgb (cr, bar->priv->layout.fl_r, bar->priv->layout.fl_g, bar->priv->layout.fl_b);
cairo_set_source_rgb (cr, bar->layout.fl_r, bar->layout.fl_g, bar->layout.fl_b);
cairo_fill_preserve (cr);
} else if ((bar->priv->layout.peak_num - 1) >= i) {
} else if ((bar->layout.peak_num - 1) >= i) {
/* fill background */
cairo_set_source_rgb (cr, bar->priv->layout.bg_r, bar->priv->layout.bg_g, bar->priv->layout.bg_b);
cairo_set_source_rgb (cr, bar->layout.bg_r, bar->layout.bg_g, bar->layout.bg_b);
cairo_fill_preserve (cr);
/* fill foreground */
cairo_set_source_rgba (cr, bar->priv->layout.fl_r, bar->priv->layout.fl_g, bar->priv->layout.fl_b, 0.5);
cairo_set_source_rgba (cr, bar->layout.fl_r, bar->layout.fl_g, bar->layout.fl_b, 0.5);
cairo_fill_preserve (cr);
} else {
/* fill background */
cairo_set_source_rgb (cr, bar->priv->layout.bg_r, bar->priv->layout.bg_g, bar->priv->layout.bg_b);
cairo_set_source_rgb (cr, bar->layout.bg_r, bar->layout.bg_g, bar->layout.bg_b);
cairo_fill_preserve (cr);
}
/* stroke border */
cairo_set_source_rgb (cr, bar->priv->layout.bdr_r, bar->priv->layout.bdr_g, bar->priv->layout.bdr_b);
cairo_set_source_rgb (cr, bar->layout.bdr_r, bar->layout.bdr_g, bar->layout.bdr_b);
cairo_set_line_width (cr, 1);
cairo_stroke (cr);
}
@ -713,35 +713,31 @@ gvc_level_bar_class_init (GvcLevelBarClass *klass)
G_MAXINT,
GVC_LEVEL_SCALE_LINEAR,
G_PARAM_READWRITE|G_PARAM_CONSTRUCT));
g_type_class_add_private (klass, sizeof (GvcLevelBarPrivate));
}
static void
gvc_level_bar_init (GvcLevelBar *bar)
{
bar->priv = GVC_LEVEL_BAR_GET_PRIVATE (bar);
bar->priv->peak_adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0,
bar->peak_adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0,
0.0,
1.0,
0.05,
0.1,
0.1));
g_object_ref_sink (bar->priv->peak_adjustment);
g_signal_connect (bar->priv->peak_adjustment,
g_object_ref_sink (bar->peak_adjustment);
g_signal_connect (bar->peak_adjustment,
"value-changed",
G_CALLBACK (on_peak_adjustment_value_changed),
bar);
bar->priv->rms_adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0,
bar->rms_adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0,
0.0,
1.0,
0.05,
0.1,
0.1));
g_object_ref_sink (bar->priv->rms_adjustment);
g_signal_connect (bar->priv->rms_adjustment,
g_object_ref_sink (bar->rms_adjustment);
g_signal_connect (bar->rms_adjustment,
"value-changed",
G_CALLBACK (on_rms_adjustment_value_changed),
bar);
@ -759,12 +755,10 @@ gvc_level_bar_finalize (GObject *object)
bar = GVC_LEVEL_BAR (object);
if (bar->priv->max_peak_id > 0) {
g_source_remove (bar->priv->max_peak_id);
if (bar->max_peak_id > 0) {
g_source_remove (bar->max_peak_id);
}
g_return_if_fail (bar->priv != NULL);
G_OBJECT_CLASS (gvc_level_bar_parent_class)->finalize (object);
}

23
panels/sound/gvc-level-bar.h
View file

@ -25,25 +25,8 @@
G_BEGIN_DECLS
#define GVC_TYPE_LEVEL_BAR (gvc_level_bar_get_type ())
#define GVC_LEVEL_BAR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GVC_TYPE_LEVEL_BAR, GvcLevelBar))
#define GVC_LEVEL_BAR_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GVC_TYPE_LEVEL_BAR, GvcLevelBarClass))
#define GVC_IS_LEVEL_BAR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GVC_TYPE_LEVEL_BAR))
#define GVC_IS_LEVEL_BAR_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GVC_TYPE_LEVEL_BAR))
#define GVC_LEVEL_BAR_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GVC_TYPE_LEVEL_BAR, GvcLevelBarClass))
typedef struct GvcLevelBarPrivate GvcLevelBarPrivate;
typedef struct
{
GtkWidget parent;
GvcLevelBarPrivate *priv;
} GvcLevelBar;
typedef struct
{
GtkWidgetClass parent_class;
} GvcLevelBarClass;
#define GVC_TYPE_LEVEL_BAR (gvc_level_bar_get_type ())
G_DECLARE_FINAL_TYPE (GvcLevelBar, gvc_level_bar, GVC, LEVEL_BAR, GtkBox)
typedef enum
{
@ -52,8 +35,6 @@ typedef enum
GVC_LEVEL_SCALE_LAST
} GvcLevelScale;
GType gvc_level_bar_get_type (void);
GtkWidget * gvc_level_bar_new (void);
void gvc_level_bar_set_orientation (GvcLevelBar *bar,
GtkOrientation orientation);

499
panels/sound/gvc-mixer-dialog.c
View file

File diff suppressed because it is too large Load diff

23
panels/sound/gvc-mixer-dialog.h
View file

@ -25,27 +25,8 @@
G_BEGIN_DECLS
#define GVC_TYPE_MIXER_DIALOG (gvc_mixer_dialog_get_type ())
#define GVC_MIXER_DIALOG(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GVC_TYPE_MIXER_DIALOG, GvcMixerDialog))
#define GVC_MIXER_DIALOG_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GVC_TYPE_MIXER_DIALOG, GvcMixerDialogClass))
#define GVC_IS_MIXER_DIALOG(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GVC_TYPE_MIXER_DIALOG))
#define GVC_IS_MIXER_DIALOG_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GVC_TYPE_MIXER_DIALOG))
#define GVC_MIXER_DIALOG_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GVC_TYPE_MIXER_DIALOG, GvcMixerDialogClass))
typedef struct GvcMixerDialogPrivate GvcMixerDialogPrivate;
typedef struct
{
GtkVBox parent;
GvcMixerDialogPrivate *priv;
} GvcMixerDialog;
typedef struct
{
GtkVBoxClass parent_class;
} GvcMixerDialogClass;
GType gvc_mixer_dialog_get_type (void);
#define GVC_TYPE_MIXER_DIALOG (gvc_mixer_dialog_get_type ())
G_DECLARE_FINAL_TYPE (GvcMixerDialog, gvc_mixer_dialog, GVC, MIXER_DIALOG, GtkBox)
GvcMixerDialog * gvc_mixer_dialog_new (GvcMixerControl *control);
gboolean gvc_mixer_dialog_set_page (GvcMixerDialog *dialog, const gchar* page);

82
panels/sound/gvc-sound-theme-chooser.c
View file

@ -37,10 +37,9 @@
#include "gvc-sound-theme-chooser.h"
#include "sound-theme-file-utils.h"
#define GVC_SOUND_THEME_CHOOSER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GVC_TYPE_SOUND_THEME_CHOOSER, GvcSoundThemeChooserPrivate))
struct GvcSoundThemeChooserPrivate
struct _GvcSoundThemeChooser
{
GtkBox parent_instance;
GtkWidget *treeview;
GtkWidget *selection_box;
GSettings *settings;
@ -290,7 +289,7 @@ update_alert_model (GvcSoundThemeChooser *chooser,
GtkTreeModel *model;
GtkTreeIter iter;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (chooser->priv->treeview));
model = gtk_tree_view_get_model (GTK_TREE_VIEW (chooser->treeview));
g_assert (gtk_tree_model_get_iter_first (model, &iter));
do {
char *this_id;
@ -302,7 +301,7 @@ update_alert_model (GvcSoundThemeChooser *chooser,
if (strcmp (this_id, id) == 0) {
GtkTreeSelection *selection;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (chooser->priv->treeview));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (chooser->treeview));
gtk_tree_selection_select_iter (selection, &iter);
}
@ -321,13 +320,13 @@ save_theme_name (GvcSoundThemeChooser *chooser,
/* special case for no sounds */
if (strcmp (theme_name, NO_SOUNDS_THEME_NAME) == 0) {
g_settings_set_boolean (chooser->priv->sound_settings, EVENT_SOUNDS_KEY, FALSE);
g_settings_set_boolean (chooser->sound_settings, EVENT_SOUNDS_KEY, FALSE);
return;
} else {
g_settings_set_boolean (chooser->priv->sound_settings, EVENT_SOUNDS_KEY, TRUE);
g_settings_set_boolean (chooser->sound_settings, EVENT_SOUNDS_KEY, TRUE);
}
g_settings_set_string (chooser->priv->sound_settings, SOUND_THEME_KEY, theme_name);
g_settings_set_string (chooser->sound_settings, SOUND_THEME_KEY, theme_name);
}
static gboolean
@ -397,7 +396,7 @@ update_alert (GvcSoundThemeChooser *chooser,
gboolean add_custom;
gboolean remove_custom;
is_custom = strcmp (chooser->priv->current_theme, CUSTOM_THEME_NAME) == 0;
is_custom = strcmp (chooser->current_theme, CUSTOM_THEME_NAME) == 0;
is_default = strcmp (alert_id, DEFAULT_ALERT_ID) == 0;
/* So a few possibilities:
@ -412,8 +411,8 @@ update_alert (GvcSoundThemeChooser *chooser,
/* remove custom just in case */
remove_custom = TRUE;
} else if (! is_custom && ! is_default) {
if (chooser->priv->current_parent)
create_custom_theme (chooser->priv->current_parent);
if (chooser->current_parent)
create_custom_theme (chooser->current_parent);
else
create_custom_theme (DEFAULT_THEME);
save_alert_sounds (chooser, alert_id);
@ -433,7 +432,7 @@ update_alert (GvcSoundThemeChooser *chooser,
} else if (remove_custom) {
delete_custom_theme_dir ();
if (is_custom) {
save_theme_name (chooser, chooser->priv->current_parent);
save_theme_name (chooser, chooser->current_parent);
}
}
@ -449,11 +448,11 @@ play_preview_for_id (GvcSoundThemeChooser *chooser,
/* special case: for the default item on custom themes
* play the alert for the parent theme */
if (strcmp (id, DEFAULT_ALERT_ID) == 0) {
if (chooser->priv->current_parent != NULL) {
if (chooser->current_parent != NULL) {
ca_gtk_play_for_widget (GTK_WIDGET (chooser), 0,
CA_PROP_APPLICATION_NAME, _("Sound Preferences"),
CA_PROP_EVENT_ID, "bell-window-system",
CA_PROP_CANBERRA_XDG_THEME_NAME, chooser->priv->current_parent,
CA_PROP_CANBERRA_XDG_THEME_NAME, chooser->current_parent,
CA_PROP_EVENT_DESCRIPTION, _("Testing event sound"),
CA_PROP_CANBERRA_CACHE_CONTROL, "never",
CA_PROP_APPLICATION_ID, "org.gnome.VolumeControl",
@ -498,7 +497,7 @@ on_treeview_row_activated (GtkTreeView *treeview,
GtkTreeIter iter;
char *id;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (chooser->priv->treeview));
model = gtk_tree_view_get_model (GTK_TREE_VIEW (chooser->treeview));
if (!gtk_tree_model_get_iter (model, &iter, path)) {
return;
}
@ -630,30 +629,30 @@ update_theme (GvcSoundThemeChooser *chooser)
gboolean events_enabled;
char *last_theme;
events_enabled = g_settings_get_boolean (chooser->priv->sound_settings, EVENT_SOUNDS_KEY);
events_enabled = g_settings_get_boolean (chooser->sound_settings, EVENT_SOUNDS_KEY);
last_theme = chooser->priv->current_theme;
last_theme = chooser->current_theme;
if (events_enabled) {
chooser->priv->current_theme = g_settings_get_string (chooser->priv->sound_settings, SOUND_THEME_KEY);
chooser->current_theme = g_settings_get_string (chooser->sound_settings, SOUND_THEME_KEY);
} else {
chooser->priv->current_theme = g_strdup (NO_SOUNDS_THEME_NAME);
chooser->current_theme = g_strdup (NO_SOUNDS_THEME_NAME);
}
if (g_strcmp0 (last_theme, chooser->priv->current_theme) != 0) {
g_clear_pointer (&chooser->priv->current_parent, g_free);
if (load_theme_name (chooser->priv->current_theme,
&chooser->priv->current_parent) == FALSE) {
g_free (chooser->priv->current_theme);
chooser->priv->current_theme = g_strdup (DEFAULT_THEME);
if (g_strcmp0 (last_theme, chooser->current_theme) != 0) {
g_clear_pointer (&chooser->current_parent, g_free);
if (load_theme_name (chooser->current_theme,
&chooser->current_parent) == FALSE) {
g_free (chooser->current_theme);
chooser->current_theme = g_strdup (DEFAULT_THEME);
load_theme_name (DEFAULT_THEME,
&chooser->priv->current_parent);
&chooser->current_parent);
}
}
g_free (last_theme);
gtk_widget_set_sensitive (chooser->priv->selection_box, events_enabled);
gtk_widget_set_sensitive (chooser->selection_box, events_enabled);
update_alerts_from_theme_name (chooser, chooser->priv->current_theme);
update_alerts_from_theme_name (chooser, chooser->current_theme);
}
static GObject *
@ -680,8 +679,6 @@ gvc_sound_theme_chooser_class_init (GvcSoundThemeChooserClass *klass)
object_class->constructor = gvc_sound_theme_chooser_constructor;
object_class->finalize = gvc_sound_theme_chooser_finalize;
g_type_class_add_private (klass, sizeof (GvcSoundThemeChooserPrivate));
}
static void
@ -732,13 +729,12 @@ gvc_sound_theme_chooser_init (GvcSoundThemeChooser *chooser)
gtk_orientable_set_orientation (GTK_ORIENTABLE (chooser),
GTK_ORIENTATION_VERTICAL);
chooser->priv = GVC_SOUND_THEME_CHOOSER_GET_PRIVATE (chooser);
chooser->priv->settings = g_settings_new (WM_SCHEMA);
chooser->priv->sound_settings = g_settings_new (KEY_SOUNDS_SCHEMA);
chooser->settings = g_settings_new (WM_SCHEMA);
chooser->sound_settings = g_settings_new (KEY_SOUNDS_SCHEMA);
str = g_strdup_printf ("<b>%s</b>", _("C_hoose an alert sound:"));
chooser->priv->selection_box = box = gtk_frame_new (str);
chooser->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);
@ -748,24 +744,24 @@ gvc_sound_theme_chooser_init (GvcSoundThemeChooser *chooser)
gtk_widget_set_margin_top (box, 6);
gtk_box_pack_start (GTK_BOX (chooser), box, TRUE, TRUE, 6);
chooser->priv->treeview = create_alert_treeview (chooser);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), chooser->priv->treeview);
chooser->treeview = create_alert_treeview (chooser);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), chooser->treeview);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
setup_list_size_constraint (scrolled_window, chooser->priv->treeview);
setup_list_size_constraint (scrolled_window, chooser->treeview);
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 (scrolled_window), chooser->treeview);
gtk_widget_set_margin_top (scrolled_window, 6);
gtk_container_add (GTK_CONTAINER (box), scrolled_window);
g_signal_connect (G_OBJECT (chooser->priv->sound_settings), "changed",
g_signal_connect (G_OBJECT (chooser->sound_settings), "changed",
G_CALLBACK (on_sound_settings_changed), chooser);
g_signal_connect (chooser->priv->settings, "changed::" AUDIO_BELL_KEY,
g_signal_connect (chooser->settings, "changed::" AUDIO_BELL_KEY,
G_CALLBACK (on_audible_bell_changed), chooser);
}
@ -779,9 +775,9 @@ gvc_sound_theme_chooser_finalize (GObject *object)
sound_theme_chooser = GVC_SOUND_THEME_CHOOSER (object);
if (sound_theme_chooser->priv != NULL) {
g_object_unref (sound_theme_chooser->priv->settings);
g_object_unref (sound_theme_chooser->priv->sound_settings);
if (sound_theme_chooser != NULL) {
g_object_unref (sound_theme_chooser->settings);
g_object_unref (sound_theme_chooser->sound_settings);
}
G_OBJECT_CLASS (gvc_sound_theme_chooser_parent_class)->finalize (object);

23
panels/sound/gvc-sound-theme-chooser.h
View file

@ -24,27 +24,8 @@
G_BEGIN_DECLS
#define GVC_TYPE_SOUND_THEME_CHOOSER (gvc_sound_theme_chooser_get_type ())
#define GVC_SOUND_THEME_CHOOSER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GVC_TYPE_SOUND_THEME_CHOOSER, GvcSoundThemeChooser))
#define GVC_SOUND_THEME_CHOOSER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GVC_TYPE_SOUND_THEME_CHOOSER, GvcSoundThemeChooserClass))
#define GVC_IS_SOUND_THEME_CHOOSER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GVC_TYPE_SOUND_THEME_CHOOSER))
#define GVC_IS_SOUND_THEME_CHOOSER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GVC_TYPE_SOUND_THEME_CHOOSER))
#define GVC_SOUND_THEME_CHOOSER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GVC_TYPE_SOUND_THEME_CHOOSER, GvcSoundThemeChooserClass))
typedef struct GvcSoundThemeChooserPrivate GvcSoundThemeChooserPrivate;
typedef struct
{
GtkVBox parent;
GvcSoundThemeChooserPrivate *priv;
} GvcSoundThemeChooser;
typedef struct
{
GtkVBoxClass parent_class;
} GvcSoundThemeChooserClass;
GType gvc_sound_theme_chooser_get_type (void);
#define GVC_TYPE_SOUND_THEME_CHOOSER (gvc_sound_theme_chooser_get_type ())
G_DECLARE_FINAL_TYPE (GvcSoundThemeChooser, gvc_sound_theme_chooser, GVC, SOUND_THEME_CHOOSER, GtkBox)
GtkWidget * gvc_sound_theme_chooser_new (void);

58
panels/sound/gvc-speaker-test.c
View file

@ -33,10 +33,9 @@
#include "gvc-speaker-test.h"
#include "gvc-mixer-stream.h"
#define GVC_SPEAKER_TEST_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GVC_TYPE_SPEAKER_TEST, GvcSpeakerTestPrivate))
struct GvcSpeakerTestPrivate
struct _GvcSpeakerTest
{
GtkGrid parent_instance;
GtkWidget *channel_controls[PA_CHANNEL_POSITION_MAX];
ca_context *canberra;
GvcMixerStream *stream;
@ -88,13 +87,13 @@ gvc_speaker_test_set_property (GObject *object,
switch (prop_id) {
case PROP_STREAM:
self->priv->stream = g_value_dup_object (value);
if (self->priv->control != NULL)
self->stream = g_value_dup_object (value);
if (self->control != NULL)
update_channel_map (self);
break;
case PROP_CONTROL:
self->priv->control = g_value_dup_object (value);
if (self->priv->stream != NULL)
self->control = g_value_dup_object (value);
if (self->stream != NULL)
update_channel_map (self);
break;
default:
@ -113,10 +112,10 @@ gvc_speaker_test_get_property (GObject *object,
switch (prop_id) {
case PROP_STREAM:
g_value_set_object (value, self->priv->stream);
g_value_set_object (value, self->stream);
break;
case PROP_CONTROL:
g_value_set_object (value, self->priv->control);
g_value_set_object (value, self->control);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -147,7 +146,6 @@ gvc_speaker_test_class_init (GvcSpeakerTestClass *klass)
"The mixer controller",
GVC_TYPE_MIXER_CONTROL,
G_PARAM_READWRITE|G_PARAM_CONSTRUCT_ONLY));
g_type_class_add_private (klass, sizeof (GvcSpeakerTestPrivate));
}
static const char *
@ -365,9 +363,9 @@ create_channel_controls (GvcSpeakerTest *speaker_test)
guint i;
for (i = 0; i < G_N_ELEMENTS (position_table); i += 3) {
speaker_test->priv->channel_controls[position_table[i]] = channel_control_new (speaker_test->priv->canberra, (pa_channel_position_t) position_table[i]);
speaker_test->channel_controls[position_table[i]] = channel_control_new (speaker_test->canberra, (pa_channel_position_t) position_table[i]);
gtk_grid_attach (GTK_GRID (speaker_test),
speaker_test->priv->channel_controls[position_table[i]],
speaker_test->channel_controls[position_table[i]],
position_table[i+1], position_table[i+2], 1, 1);
}
}
@ -378,19 +376,19 @@ update_channel_map (GvcSpeakerTest *speaker_test)
guint i;
const GvcChannelMap *map;
g_return_if_fail (speaker_test->priv->control != NULL);
g_return_if_fail (speaker_test->priv->stream != NULL);
g_return_if_fail (speaker_test->control != NULL);
g_return_if_fail (speaker_test->stream != NULL);
g_debug ("XXX update_channel_map called XXX");
map = gvc_mixer_stream_get_channel_map (speaker_test->priv->stream);
map = gvc_mixer_stream_get_channel_map (speaker_test->stream);
g_return_if_fail (map != NULL);
ca_context_change_device (speaker_test->priv->canberra,
gvc_mixer_stream_get_name (speaker_test->priv->stream));
ca_context_change_device (speaker_test->canberra,
gvc_mixer_stream_get_name (speaker_test->stream));
for (i = 0; i < G_N_ELEMENTS (position_table); i += 3) {
gtk_widget_set_visible (speaker_test->priv->channel_controls[position_table[i]],
gtk_widget_set_visible (speaker_test->channel_controls[position_table[i]],
gvc_channel_map_has_position(map, position_table[i]));
}
}
@ -418,14 +416,12 @@ gvc_speaker_test_init (GvcSpeakerTest *speaker_test)
{
GtkWidget *face;
speaker_test->priv = GVC_SPEAKER_TEST_GET_PRIVATE (speaker_test);
ca_context_create (&speaker_test->priv->canberra);
ca_context_set_driver (speaker_test->priv->canberra, "pulse");
ca_context_change_props (speaker_test->priv->canberra,
ca_context_create (&speaker_test->canberra);
ca_context_set_driver (speaker_test->canberra, "pulse");
ca_context_change_props (speaker_test->canberra,
CA_PROP_APPLICATION_ID, "org.gnome.VolumeControl",
NULL);
gvc_speaker_test_set_theme (speaker_test->priv->canberra);
gvc_speaker_test_set_theme (speaker_test->canberra);
gtk_widget_set_direction (GTK_WIDGET (speaker_test), GTK_TEXT_DIR_LTR);
gtk_container_set_border_width (GTK_CONTAINER (speaker_test), 12);
@ -451,16 +447,16 @@ gvc_speaker_test_finalize (GObject *object)
speaker_test = GVC_SPEAKER_TEST (object);
g_return_if_fail (speaker_test->priv != NULL);
g_return_if_fail (speaker_test != NULL);
g_object_unref (speaker_test->priv->stream);
speaker_test->priv->stream = NULL;
g_object_unref (speaker_test->stream);
speaker_test->stream = NULL;
g_object_unref (speaker_test->priv->control);
speaker_test->priv->control = NULL;
g_object_unref (speaker_test->control);
speaker_test->control = NULL;
ca_context_destroy (speaker_test->priv->canberra);
speaker_test->priv->canberra = NULL;
ca_context_destroy (speaker_test->canberra);
speaker_test->canberra = NULL;
G_OBJECT_CLASS (gvc_speaker_test_parent_class)->finalize (object);
}

23
panels/sound/gvc-speaker-test.h
View file

@ -26,27 +26,8 @@
G_BEGIN_DECLS
#define GVC_TYPE_SPEAKER_TEST (gvc_speaker_test_get_type ())
#define GVC_SPEAKER_TEST(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GVC_TYPE_SPEAKER_TEST, GvcSpeakerTest))
#define GVC_SPEAKER_TEST_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), GVC_TYPE_SPEAKER_TEST, GvcSpeakerTestClass))
#define GVC_IS_SPEAKER_TEST(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GVC_TYPE_SPEAKER_TEST))
#define GVC_IS_SPEAKER_TEST_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GVC_TYPE_SPEAKER_TEST))
#define GVC_SPEAKER_TEST_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GVC_TYPE_SPEAKER_TEST, GvcSpeakerTestClass))
typedef struct GvcSpeakerTestPrivate GvcSpeakerTestPrivate;
typedef struct
{
GtkNotebook parent;
GvcSpeakerTestPrivate *priv;
} GvcSpeakerTest;
typedef struct
{
GtkNotebookClass parent_class;
} GvcSpeakerTestClass;
GType gvc_speaker_test_get_type (void);
#define GVC_TYPE_SPEAKER_TEST (gvc_speaker_test_get_type ())
G_DECLARE_FINAL_TYPE (GvcSpeakerTest, gvc_speaker_test, GVC, SPEAKER_TEST, GtkGrid)
GtkWidget * gvc_speaker_test_new (GvcMixerControl *control,
GvcMixerStream *stream);