/*
- * This file is part of hildon-libs
+ * This file is a part of hildon
*
* Copyright (C) 2005, 2006 Nokia Corporation, all rights reserved.
*
/**
* SECTION:hildon-volumebar
- * @short_description: Base class for widgets that display a volume bar
+ * @short_description: Base class for widgets that display a volume bar.
* @see_also: #HildonHVolumebar, #HildonVVolumebar
*
* #HildonVolumebar is a base class for widgets that display a volume bar that
* the volume when users click the mute icon.
*/
-#include <config.h>
-#include "hildon-volumebar.h"
-#include <gtk/gtk.h>
-#include <gdk/gdkkeysyms.h>
-#include "hildon-volumebar-range.h"
-#include "hildon-volumebar-private.h"
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
-static GtkContainerClass *parent_class;
+#include "hildon-volumebar.h"
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+#include "hildon-volumebar-range.h"
+#include "hildon-volumebar-private.h"
+
+static GtkContainerClass* parent_class;
static void
-hildon_volumebar_class_init(HildonVolumebarClass * volumebar_class);
+hildon_volumebar_class_init (HildonVolumebarClass* volumebar_class);
+
+static void
+hildon_volumebar_init (HildonVolumebar* volumebar);
+
static void
-hildon_volumebar_init(HildonVolumebar * volumebar);
+hildon_child_forall (GtkContainer * container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data);
static void
-hildon_child_forall(GtkContainer * container,
- gboolean include_internals,
- GtkCallback callback,
- gpointer callback_data);
+hildon_volumebar_destroy (GtkObject *self);
+
static void
-hildon_volumebar_destroy(GtkObject * self);
+hildon_volumebar_set_property (GObject* object,
+ guint prop_id,
+ const GValue* value,
+ GParamSpec* pspec);
-static void hildon_volumebar_set_property(GObject * object,
- guint prop_id,
- const GValue * value,
- GParamSpec * pspec);
-static void hildon_volumebar_get_property(GObject * object,
- guint prop_id,
- GValue * value,
- GParamSpec * pspec);
+static void
+hildon_volumebar_get_property (GObject * object,
+ guint prop_id,
+ GValue* value,
+ GParamSpec* pspec);
-static void mute_toggled (HildonVolumebar *self);
+static void
+mute_toggled (HildonVolumebar *self);
static gboolean
-hildon_volumebar_key_press(GtkWidget * widget,
- GdkEventKey * event);
+hildon_volumebar_key_press (GtkWidget* widget,
+ GdkEventKey* event);
+
+static void
+hildon_volumebar_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation);
+
+static void
+hildon_volumebar_realize (GtkWidget *widget);
+
+static void
+hildon_volumebar_unrealize (GtkWidget *widget);
+
+static void
+hildon_volumebar_map (GtkWidget *widget);
-static void hildon_volumebar_size_allocate (GtkWidget *widget,
- GtkAllocation *allocation);
-static void hildon_volumebar_realize (GtkWidget *widget);
-static void hildon_volumebar_unrealize (GtkWidget *widget);
-static void hildon_volumebar_map (GtkWidget *widget);
-static void hildon_volumebar_unmap (GtkWidget *widget);
-static void hildon_volumebar_notify (GObject *self, GParamSpec *param);
+static void
+hildon_volumebar_unmap (GtkWidget *widget);
+static void
+hildon_volumebar_notify (GObject *self, GParamSpec *param);
enum
{
};
enum {
- PROP_NONE = 0,
+ PROP_0,
PROP_HILDON_HAS_MUTE,
PROP_HILDON_FOCUSABLE,
PROP_HILDON_LEVEL,
PROP_HILDON_MUTE
};
-static guint signals[LAST_SIGNAL] = { 0 };
+static guint signals [LAST_SIGNAL] = { 0 };
-GType
-hildon_volumebar_get_type(void)
+/**
+ * hildon_volumebar_get_type:
+ *
+ * Initializes and returns the type of a hildon volumebar.
+ *
+ * @Returns: GType of #HildonVolumebar
+ */
+GType G_GNUC_CONST
+hildon_volumebar_get_type (void)
{
static GType volumebar_type = 0;
(GInstanceInitFunc) hildon_volumebar_init,
};
volumebar_type = g_type_register_static(GTK_TYPE_CONTAINER,
- "HildonVolumebar",
- &volumebar_info, 0);
+ "HildonVolumebar",
+ &volumebar_info, 0);
}
return volumebar_type;
}
static void
-hildon_volumebar_class_init(HildonVolumebarClass *volumebar_class)
+hildon_volumebar_class_init (HildonVolumebarClass *volumebar_class)
{
- GObjectClass *gobject_class = G_OBJECT_CLASS (volumebar_class);
- GtkObjectClass *object_class = GTK_OBJECT_CLASS(volumebar_class);
- GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(volumebar_class);
- GtkContainerClass *container_class = GTK_CONTAINER_CLASS(volumebar_class);
-
- parent_class = g_type_class_peek_parent(volumebar_class);
-
- g_type_class_add_private(volumebar_class,
- sizeof(HildonVolumebarPrivate));
-
- /* Because we derived our widget from GtkContainer, we should also
- override forall method */
- volumebar_class->mute_toggled = mute_toggled;
- container_class->forall = hildon_child_forall;
- widget_class->size_allocate = hildon_volumebar_size_allocate;
- widget_class->realize = hildon_volumebar_realize;
- widget_class->unrealize = hildon_volumebar_unrealize;
- widget_class->map = hildon_volumebar_map;
- widget_class->unmap = hildon_volumebar_unmap;
- widget_class->key_press_event = hildon_volumebar_key_press;
- object_class->destroy = hildon_volumebar_destroy;
-
- signals[MUTE_TOGGLED_SIGNAL] = g_signal_new("mute_toggled",
- G_OBJECT_CLASS_TYPE
- (object_class),
- G_SIGNAL_RUN_LAST |
- G_SIGNAL_ACTION,
- G_STRUCT_OFFSET
- (HildonVolumebarClass,
- mute_toggled), NULL, NULL,
- gtk_marshal_VOID__VOID,
- G_TYPE_NONE, 0);
-
- signals[LEVEL_CHANGED_SIGNAL] = g_signal_new("level_changed",
- G_OBJECT_CLASS_TYPE
- (object_class),
- G_SIGNAL_RUN_LAST |
- G_SIGNAL_ACTION,
- G_STRUCT_OFFSET
- (HildonVolumebarClass,
- level_changed), NULL,
- NULL,
- gtk_marshal_VOID__VOID,
- G_TYPE_NONE, 0);
-
- gobject_class->notify = hildon_volumebar_notify;
- gobject_class->set_property = hildon_volumebar_set_property;
- gobject_class->get_property = hildon_volumebar_get_property;
-
- /*This kind of property could be usefull in the gtkcontainer*/
- g_object_class_install_property(gobject_class,
- PROP_HILDON_FOCUSABLE,
- g_param_spec_boolean("can-focus",
- "The widget focusablility",
- "The widget focusablility. TRUE is focusable",
- TRUE,
- G_PARAM_CONSTRUCT | G_PARAM_READWRITE));
-
- g_object_class_install_property(gobject_class,
- PROP_HILDON_HAS_MUTE,
- g_param_spec_boolean("has_mute",
- "Show/Hide the mute button",
+ GObjectClass *gobject_class = G_OBJECT_CLASS (volumebar_class);
+ GtkObjectClass *object_class = GTK_OBJECT_CLASS (volumebar_class);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (volumebar_class);
+ GtkContainerClass *container_class = GTK_CONTAINER_CLASS (volumebar_class);
+
+ parent_class = g_type_class_peek_parent (volumebar_class);
+
+ g_type_class_add_private (volumebar_class,
+ sizeof (HildonVolumebarPrivate));
+
+ /* Because we derived our widget from GtkContainer, we should also
+ * override forall method
+ */
+ volumebar_class->mute_toggled = mute_toggled;
+ container_class->forall = hildon_child_forall;
+ widget_class->size_allocate = hildon_volumebar_size_allocate;
+ widget_class->realize = hildon_volumebar_realize;
+ widget_class->unrealize = hildon_volumebar_unrealize;
+ widget_class->map = hildon_volumebar_map;
+ widget_class->unmap = hildon_volumebar_unmap;
+ widget_class->key_press_event = hildon_volumebar_key_press;
+ object_class->destroy = hildon_volumebar_destroy;
+
+ signals[MUTE_TOGGLED_SIGNAL] = g_signal_new ("mute_toggled",
+ G_OBJECT_CLASS_TYPE
+ (object_class),
+ G_SIGNAL_RUN_LAST |
+ G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET
+ (HildonVolumebarClass,
+ mute_toggled), NULL, NULL,
+ gtk_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+
+ signals[LEVEL_CHANGED_SIGNAL] = g_signal_new ("level_changed",
+ G_OBJECT_CLASS_TYPE
+ (object_class),
+ G_SIGNAL_RUN_LAST |
+ G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET
+ (HildonVolumebarClass,
+ level_changed), NULL,
+ NULL,
+ gtk_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+
+ gobject_class->notify = hildon_volumebar_notify;
+ gobject_class->set_property = hildon_volumebar_set_property;
+ gobject_class->get_property = hildon_volumebar_get_property;
+
+ /**
+ * HildonVolumebar:can-focus:
+ *
+ * The widget focusability.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_HILDON_FOCUSABLE,
+ g_param_spec_boolean ("can-focus",
+ "The widget focusablility",
+ "The widget focusablility. TRUE is focusable",
+ TRUE,
+ G_PARAM_CONSTRUCT | G_PARAM_READWRITE));
+
+ /**
+ * HildonVolumebar:has-mute:
+ *
+ * Whether the mute button is visibile.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_HILDON_HAS_MUTE,
+ g_param_spec_boolean ("has_mute",
+ "Show/Hide the mute button",
"Whether the mute button is visible. Default value: TRUE",
- TRUE,
- G_PARAM_CONSTRUCT | G_PARAM_READWRITE));
-
- g_object_class_install_property(gobject_class,
- PROP_HILDON_LEVEL,
- g_param_spec_double("level",
- "Level",
- "Current volume level",
- 0.0,
- 100.0,
- 50.0,
- G_PARAM_READWRITE));
-
- g_object_class_install_property(gobject_class,
- PROP_HILDON_MUTE,
- g_param_spec_boolean("mute",
- "Mute",
- "Whether volume is muted",
- FALSE,
- G_PARAM_READWRITE));
+ TRUE,
+ G_PARAM_CONSTRUCT | G_PARAM_READWRITE));
+
+ /**
+ * HildonVolumebar:level:
+ *
+ * Current volume level.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_HILDON_LEVEL,
+ g_param_spec_double ("level",
+ "Level",
+ "Current volume level",
+ 0.0,
+ 100.0,
+ 50.0,
+ G_PARAM_READWRITE));
+
+ /**
+ * HildonVolumebar:can-focus:
+ *
+ * Whether volume is muted.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_HILDON_MUTE,
+ g_param_spec_boolean ("mute",
+ "Mute",
+ "Whether volume is muted",
+ FALSE,
+ G_PARAM_READWRITE));
}
static void
-hildon_volumebar_init(HildonVolumebar * volumebar)
+hildon_volumebar_init (HildonVolumebar *volumebar)
{
HildonVolumebarPrivate *priv;
priv = HILDON_VOLUMEBAR_GET_PRIVATE(volumebar);
+ g_assert (priv);
/* Should set GTK_NO_WINDOW flag, because widget is derived from
GtkContainer */
- GTK_WIDGET_SET_FLAGS(GTK_WIDGET(volumebar), GTK_NO_WINDOW);
- GTK_WIDGET_UNSET_FLAGS(GTK_WIDGET(volumebar), GTK_CAN_FOCUS);
+ GTK_WIDGET_SET_FLAGS (GTK_WIDGET (volumebar), GTK_NO_WINDOW);
+ GTK_WIDGET_UNSET_FLAGS (GTK_WIDGET (volumebar), GTK_CAN_FOCUS);
/* Initialize mute button */
- priv->tbutton = GTK_TOGGLE_BUTTON(gtk_toggle_button_new());
+ priv->tbutton = GTK_TOGGLE_BUTTON (gtk_toggle_button_new ());
g_object_set (G_OBJECT (priv->tbutton), "can-focus", FALSE, NULL);
}
static void
-hildon_volumebar_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
+hildon_volumebar_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation)
{
HildonVolumebarPrivate *priv;
priv = HILDON_VOLUMEBAR_GET_PRIVATE(widget);
+ g_assert (priv);
if (GTK_WIDGET_CLASS (parent_class)->size_allocate)
- GTK_WIDGET_CLASS (parent_class)->size_allocate (widget, allocation);
+ GTK_WIDGET_CLASS (parent_class)->size_allocate (widget, allocation);
if (GTK_WIDGET_REALIZED (widget))
- gdk_window_move_resize (priv->event_window,
- allocation->x, allocation->y,
- allocation->width, allocation->height);
+ gdk_window_move_resize (priv->event_window,
+ allocation->x, allocation->y,
+ allocation->width, allocation->height);
}
static void
-hildon_volumebar_realize (GtkWidget *widget)
+hildon_volumebar_realize (GtkWidget *widget)
{
HildonVolumebarPrivate *priv;
GdkWindowAttr attributes;
gint attributes_mask;
- priv = HILDON_VOLUMEBAR_GET_PRIVATE(widget);
+ priv = HILDON_VOLUMEBAR_GET_PRIVATE (widget);
+ g_assert (priv);
- GTK_WIDGET_CLASS(parent_class)->realize(widget);
+ GTK_WIDGET_CLASS (parent_class)->realize (widget);
attributes.window_type = GDK_WINDOW_CHILD;
attributes.x = widget->allocation.x;
attributes_mask = GDK_WA_X | GDK_WA_Y;
priv->event_window = gdk_window_new (widget->window,
- &attributes, attributes_mask);
+ &attributes, attributes_mask);
+
gdk_window_set_user_data (priv->event_window, widget);
}
static void
-hildon_volumebar_unrealize (GtkWidget *widget)
+hildon_volumebar_unrealize (GtkWidget *widget)
{
HildonVolumebarPrivate *priv;
priv = HILDON_VOLUMEBAR_GET_PRIVATE(widget);
+ g_assert (priv);
if (priv->event_window) {
- gdk_window_set_user_data (priv->event_window, NULL);
- gdk_window_destroy (priv->event_window);
- priv->event_window = NULL;
+ gdk_window_set_user_data (priv->event_window, NULL);
+ gdk_window_destroy (priv->event_window);
+ priv->event_window = NULL;
}
- GTK_WIDGET_CLASS(parent_class)->unrealize(widget);
+ GTK_WIDGET_CLASS (parent_class)->unrealize(widget);
}
static void
-hildon_volumebar_map (GtkWidget *widget)
+hildon_volumebar_map (GtkWidget *widget)
{
HildonVolumebarPrivate *priv;
priv = HILDON_VOLUMEBAR_GET_PRIVATE(widget);
+ g_assert (priv);
- GTK_WIDGET_CLASS(parent_class)->map(widget);
+ GTK_WIDGET_CLASS (parent_class)->map (widget);
/* the event window must be on top of all other widget windows, so show it
* last */
- if (!GTK_WIDGET_SENSITIVE (widget))
- gdk_window_show (priv->event_window);
+ if (! GTK_WIDGET_SENSITIVE (widget))
+ gdk_window_show (priv->event_window);
}
-static void hildon_volumebar_unmap (GtkWidget *widget)
+static void
+hildon_volumebar_unmap (GtkWidget *widget)
{
HildonVolumebarPrivate *priv;
- priv = HILDON_VOLUMEBAR_GET_PRIVATE(widget);
+ priv = HILDON_VOLUMEBAR_GET_PRIVATE (widget);
+ g_assert (priv);
gdk_window_hide (priv->event_window);
- GTK_WIDGET_CLASS(parent_class)->unmap(widget);
+ GTK_WIDGET_CLASS (parent_class)->unmap(widget);
}
static void
-hildon_child_forall(GtkContainer * container,
- gboolean include_internals,
- GtkCallback callback, gpointer callback_data)
+hildon_child_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
{
HildonVolumebarPrivate *priv;
- g_assert(HILDON_IS_VOLUMEBAR(container));
- g_assert(callback != NULL);
-
- priv = HILDON_VOLUMEBAR_GET_PRIVATE(container);
+ priv = HILDON_VOLUMEBAR_GET_PRIVATE (container);
+ g_assert (callback != NULL);
+ g_assert (priv);
/* No external children */
- if (!include_internals)
+ if (! include_internals)
return;
/* Execute callback for both internals */
- (*callback) (GTK_WIDGET(priv->tbutton), callback_data);
- (*callback) (GTK_WIDGET(priv->volumebar), callback_data);
+ (*callback) (GTK_WIDGET (priv->tbutton), callback_data);
+ (*callback) (GTK_WIDGET (priv->volumebar), callback_data);
}
static void
-hildon_volumebar_notify (GObject *self, GParamSpec *param)
+hildon_volumebar_notify (GObject *self,
+ GParamSpec *param)
{
HildonVolumebarPrivate *priv;
priv = HILDON_VOLUMEBAR_GET_PRIVATE(self);
+ g_assert (priv);
if (GTK_WIDGET_MAPPED (self)) {
- /* show/hide the event window on sensitivity change */
- if (g_str_equal (param->name, "sensitive")) {
- if (GTK_WIDGET_SENSITIVE (self))
- gdk_window_hide (priv->event_window);
- else
- gdk_window_show (priv->event_window);
- }
+ /* show/hide the event window on sensitivity change */
+ if (g_str_equal (param->name, "sensitive")) {
+ if (GTK_WIDGET_SENSITIVE (self))
+ gdk_window_hide (priv->event_window);
+ else
+ gdk_window_show (priv->event_window);
+ }
}
if (G_OBJECT_CLASS(parent_class)->notify)
- G_OBJECT_CLASS(parent_class)->notify (self, param);
+ G_OBJECT_CLASS(parent_class)->notify (self, param);
}
static void
-hildon_volumebar_destroy(GtkObject * self)
+hildon_volumebar_destroy (GtkObject *self)
{
HildonVolumebarPrivate *priv;
priv = HILDON_VOLUMEBAR_GET_PRIVATE(self);
+ g_assert (priv);
if (priv->tbutton) {
- gtk_widget_unparent(GTK_WIDGET(priv->tbutton));
+ gtk_widget_unparent (GTK_WIDGET (priv->tbutton));
priv->tbutton = NULL;
}
if (priv->volumebar) {
- gtk_widget_unparent(GTK_WIDGET(priv->volumebar));
+ gtk_widget_unparent (GTK_WIDGET (priv->volumebar));
priv->volumebar = NULL;
}
- if (GTK_OBJECT_CLASS(parent_class)->destroy)
- GTK_OBJECT_CLASS(parent_class)->destroy(self);
+ if (GTK_OBJECT_CLASS (parent_class)->destroy)
+ GTK_OBJECT_CLASS (parent_class)->destroy (self);
}
static void
-hildon_volumebar_set_property(GObject * object,
- guint prop_id,
- const GValue * value,
- GParamSpec * pspec)
+hildon_volumebar_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
{
HildonVolumebarPrivate *priv;
priv = HILDON_VOLUMEBAR_GET_PRIVATE(object);
+ g_assert (priv);
switch (prop_id) {
- case PROP_HILDON_HAS_MUTE:
- /* Mute button always exists, but might be hidden */
- if (g_value_get_boolean(value))
- gtk_widget_show(GTK_WIDGET(priv->tbutton));
- else
- gtk_widget_hide(GTK_WIDGET(priv->tbutton));
- break;
- case PROP_HILDON_FOCUSABLE:
- g_object_set( G_OBJECT(priv->volumebar), "can-focus",
- g_value_get_boolean(value), NULL );
- break;
- case PROP_HILDON_LEVEL:
- hildon_volumebar_set_level(HILDON_VOLUMEBAR(priv->volumebar),
- g_value_get_double(value));
- break;
- case PROP_HILDON_MUTE:
- hildon_volumebar_set_mute(HILDON_VOLUMEBAR(priv->volumebar),
- g_value_get_boolean(value));
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
-
- break;
+
+ case PROP_HILDON_HAS_MUTE:
+ /* Mute button always exists but might be hidden */
+ if (g_value_get_boolean (value))
+ gtk_widget_show (GTK_WIDGET (priv->tbutton));
+ else
+ gtk_widget_hide (GTK_WIDGET (priv->tbutton));
+ break;
+
+ case PROP_HILDON_FOCUSABLE:
+ g_object_set (G_OBJECT (priv->volumebar), "can-focus",
+ g_value_get_boolean (value), NULL );
+ break;
+
+ case PROP_HILDON_LEVEL:
+ hildon_volumebar_set_level (HILDON_VOLUMEBAR (priv->volumebar),
+ g_value_get_double (value));
+ break;
+
+ case PROP_HILDON_MUTE:
+ hildon_volumebar_set_mute (HILDON_VOLUMEBAR (priv->volumebar),
+ g_value_get_boolean (value));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+
+ break;
}
}
static void
-hildon_volumebar_get_property(GObject * object,
- guint prop_id, GValue * value,
- GParamSpec * pspec)
+hildon_volumebar_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
{
- HildonVolumebar *vb = HILDON_VOLUMEBAR(object);
- HildonVolumebarPrivate *priv = HILDON_VOLUMEBAR_GET_PRIVATE(vb);
+ HildonVolumebarPrivate *priv;
+ HildonVolumebar *vb;
+
+ priv = HILDON_VOLUMEBAR_GET_PRIVATE(object);
+ g_assert (priv);
+
+ vb = HILDON_VOLUMEBAR (object);
switch (prop_id) {
- case PROP_HILDON_HAS_MUTE:
- g_value_set_boolean(value, GTK_WIDGET_VISIBLE(priv->tbutton));
- break;
- case PROP_HILDON_FOCUSABLE:
- g_value_set_boolean(value, GTK_WIDGET_CAN_FOCUS(priv->volumebar));
- break;
- case PROP_HILDON_LEVEL:
- g_value_set_double(value, hildon_volumebar_get_level(vb));
- break;
- case PROP_HILDON_MUTE:
- g_value_set_boolean(value, hildon_volumebar_get_mute(vb));
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
- break;
- }
-}
-/**
- * hildon_volumebar_level_change:
- * @self: a #HildonVolumebar widget
- *
- * Emits "level_changed" signal to the given volume bar. This function
- * is mainly used by derived classes.
- */
-void
-hildon_volumebar_level_change(HildonVolumebar * self)
-{
- g_return_if_fail(HILDON_IS_VOLUMEBAR(self));
- g_signal_emit_by_name(GTK_WIDGET(self), "level_changed");
+ case PROP_HILDON_HAS_MUTE:
+ g_value_set_boolean (value, GTK_WIDGET_VISIBLE (priv->tbutton));
+ break;
+
+ case PROP_HILDON_FOCUSABLE:
+ g_value_set_boolean (value, GTK_WIDGET_CAN_FOCUS (priv->volumebar));
+ break;
+
+ case PROP_HILDON_LEVEL:
+ g_value_set_double (value, hildon_volumebar_get_level (vb));
+ break;
+
+ case PROP_HILDON_MUTE:
+ g_value_set_boolean (value, hildon_volumebar_get_mute (vb));
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+ break;
+
+ }
}
/**
* Sets new volume level for this #HildonVolumebar.
*/
void
-hildon_volumebar_set_level(HildonVolumebar * self, gdouble level)
+hildon_volumebar_set_level (HildonVolumebar *self,
+ gdouble level)
{
HildonVolumebarPrivate *priv;
- g_return_if_fail(HILDON_IS_VOLUMEBAR(self));
+ g_return_if_fail(HILDON_IS_VOLUMEBAR (self));
- priv = HILDON_VOLUMEBAR_GET_PRIVATE(self);
-
- hildon_volumebar_range_set_level(priv->volumebar, level);
+ priv = HILDON_VOLUMEBAR_GET_PRIVATE (self);
+ g_assert (priv);
+
+ hildon_volumebar_range_set_level (priv->volumebar, level);
}
/**
* Returns: volume level or -1 on error
*/
gdouble
-hildon_volumebar_get_level(HildonVolumebar * self)
+hildon_volumebar_get_level (HildonVolumebar *self)
{
HildonVolumebarPrivate *priv;
- g_return_val_if_fail(HILDON_IS_VOLUMEBAR(self), -1);
+ g_return_val_if_fail(HILDON_IS_VOLUMEBAR (self), -1);
priv = HILDON_VOLUMEBAR_GET_PRIVATE(self);
+ g_assert (priv);
- return hildon_volumebar_range_get_level(priv->volumebar);
+ return hildon_volumebar_range_get_level (priv->volumebar);
}
/**
* Sets mute status for this #HildonVolumebar.
*/
void
-hildon_volumebar_set_mute(HildonVolumebar * self, gboolean mute)
+hildon_volumebar_set_mute (HildonVolumebar *self,
+ gboolean mute)
{
HildonVolumebarPrivate *priv;
gboolean focusable = TRUE;
-
- g_return_if_fail(HILDON_IS_VOLUMEBAR(self));
- priv = HILDON_VOLUMEBAR_GET_PRIVATE(self);
+ g_return_if_fail (HILDON_IS_VOLUMEBAR (self));
+
+ priv = HILDON_VOLUMEBAR_GET_PRIVATE (self);
+ g_assert (priv);
/* Slider should be insensitive when mute is on */
- gtk_widget_set_sensitive(GTK_WIDGET(priv->volumebar), !mute);
-
+ gtk_widget_set_sensitive (GTK_WIDGET (priv->volumebar), !mute);
+
focusable = GTK_WIDGET_CAN_FOCUS (GTK_WIDGET (priv->volumebar));
-
+
if (mute){
- if (focusable){
- /* Make mute button focusable since the slider isn't anymore */
+ if (focusable) {
+ /* Make mute button focusable since the slider isn't anymore */
g_object_set (G_OBJECT (priv->tbutton), "can-focus", TRUE, NULL);
- gtk_widget_grab_focus (GTK_WIDGET(priv->tbutton));
+ gtk_widget_grab_focus (GTK_WIDGET (priv->tbutton));
}
}
else
{
g_object_set (G_OBJECT (priv->tbutton), "can-focus", FALSE, NULL);
-
- /* Mute off grabs focus */
+
+ /* Mute off grabs focus */
if (focusable){
gtk_widget_grab_focus (GTK_WIDGET (self));
}
else{
- /* If volumebar is not focusable, focus the parent window instead */
+ /* If volumebar is not focusable, focus the parent window instead */
GtkWidget *win = gtk_widget_get_ancestor (GTK_WIDGET (self),
- GTK_TYPE_WINDOW);
+ GTK_TYPE_WINDOW);
gtk_window_set_focus (GTK_WINDOW (win), NULL);
}
}
/* Update mute button state and redraw */
- gtk_toggle_button_set_active(priv->tbutton, mute);
+ gtk_toggle_button_set_active (priv->tbutton, mute);
+ /* FIXME I'm darn sure that's not really needed */
gtk_widget_queue_draw (GTK_WIDGET (self));
}
* Returns: Mute status as #gboolean value.
*/
gboolean
-hildon_volumebar_get_mute(HildonVolumebar * self)
+hildon_volumebar_get_mute (HildonVolumebar *self)
{
HildonVolumebarPrivate *priv;
- g_return_val_if_fail(HILDON_IS_VOLUMEBAR(self), TRUE);
+ g_return_val_if_fail (HILDON_IS_VOLUMEBAR (self), TRUE);
priv = HILDON_VOLUMEBAR_GET_PRIVATE(self);
+ g_assert (priv);
- return gtk_toggle_button_get_active(priv->tbutton);
+ return gtk_toggle_button_get_active (priv->tbutton);
}
/**
* @self : a #HildonVolumebar
*
* Gets the GtkAdjustment used in volume bar. This can be handy
- * to give to hildon_appview_set_connected_adjustment which
- * will allow changing the volume with increase / decrease
+ * to pass to hildon_appview_set_connected_adjustment which
+ * will allow changing the volume with 'increase' / 'decrease'
* hardware buttons.
*
- * This is a temporary solution until volume bar is restructured to
- * be a child class of GtkRange.
- *
* Returns: a #GtkAdjustment used by volume bar.
*/
-GtkAdjustment *
-hildon_volumebar_get_adjustment (HildonVolumebar * self)
+GtkAdjustment*
+hildon_volumebar_get_adjustment (HildonVolumebar *self)
{
HildonVolumebarPrivate *priv;
g_return_val_if_fail(HILDON_IS_VOLUMEBAR(self), NULL);
priv = HILDON_VOLUMEBAR_GET_PRIVATE(self);
+ g_assert (priv);
return gtk_range_get_adjustment (GTK_RANGE (priv->volumebar));
}
static void
-mute_toggled (HildonVolumebar *self)
+mute_toggled (HildonVolumebar *self)
{
- /* This looks like no-op, but it still does something meaningfull!
- set_mute also updates the ui to match new state that
- is already reported by get_mute */
- hildon_volumebar_set_mute (self, hildon_volumebar_get_mute(self));
+ /* This looks like no-op, but it still does something meaningfull!
+ set_mute also updates the ui to match new state that
+ is already reported by get_mute */
+
+ hildon_volumebar_set_mute (self, hildon_volumebar_get_mute (self));
}
static gboolean
-hildon_volumebar_key_press (GtkWidget * widget,
- GdkEventKey * event)
+hildon_volumebar_key_press (GtkWidget *widget,
+ GdkEventKey *event)
{
HildonVolumebarPrivate *priv;
-
+
priv = HILDON_VOLUMEBAR_GET_PRIVATE(widget);
+ g_assert (priv != NULL);
/* Enter key toggles mute button (unless it is hidden) */
- if (event->keyval == GDK_Return && GTK_WIDGET_VISIBLE(priv->tbutton)) {
- gtk_toggle_button_set_active(priv->tbutton,
- !hildon_volumebar_get_mute(HILDON_VOLUMEBAR(widget)));
+ if (event->keyval == GDK_Return && GTK_WIDGET_VISIBLE (priv->tbutton)) {
+ gtk_toggle_button_set_active (priv->tbutton,
+ ! hildon_volumebar_get_mute(HILDON_VOLUMEBAR(widget)));
+
return TRUE;
}
- return GTK_WIDGET_CLASS(parent_class)->key_press_event(widget, event);
+ return GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, event);
}
-/* Sends mute-toggled signal to widget, used as a callback in derived classes
- Just keep this "protected" in order to avoid introducing new API. */
-void
-_hildon_volumebar_mute_toggled(HildonVolumebar * self)
+/*
+ * Sends mute-toggled signal to widget, used as a callback in derived classes.
+ */
+void G_GNUC_INTERNAL
+hildon_volumebar_mute_toggled (HildonVolumebar * self)
{
- g_return_if_fail(HILDON_IS_VOLUMEBAR(self));
- g_signal_emit_by_name(self, "mute_toggled");
+ g_return_if_fail (HILDON_IS_VOLUMEBAR (self));
+ /* FIXME Emit by id */
+ g_signal_emit_by_name (self, "mute_toggled");
+}
+
+void G_GNUC_INTERNAL
+hildon_volumebar_level_change (HildonVolumebar *self)
+{
+ g_return_if_fail (HILDON_IS_VOLUMEBAR (self));
+
+ /* FIXME Use numerical val, id */
+ g_signal_emit_by_name (GTK_WIDGET (self), "level_changed");
}
projects / hildon / blobdiff