summaryrefslogtreecommitdiff
path: root/mate-volume-control/src/gvc-level-bar.c
diff options
context:
space:
mode:
Diffstat (limited to 'mate-volume-control/src/gvc-level-bar.c')
-rw-r--r--mate-volume-control/src/gvc-level-bar.c753
1 files changed, 753 insertions, 0 deletions
diff --git a/mate-volume-control/src/gvc-level-bar.c b/mate-volume-control/src/gvc-level-bar.c
new file mode 100644
index 0000000..12e2f1f
--- /dev/null
+++ b/mate-volume-control/src/gvc-level-bar.c
@@ -0,0 +1,753 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2008 William Jon McCann <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <math.h>
+
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#include "gvc-level-bar.h"
+
+#define NUM_BOXES 15
+
+#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
+#define MIN_VERTICAL_BAR_HEIGHT 400
+
+typedef struct {
+ int peak_num;
+ int max_peak_num;
+
+ GdkRectangle area;
+ int delta;
+ int box_width;
+ int box_height;
+ int box_radius;
+ double bg_r;
+ double bg_g;
+ double bg_b;
+ double bdr_r;
+ double bdr_g;
+ double bdr_b;
+ double fl_r;
+ double fl_g;
+ double fl_b;
+} LevelBarLayout;
+
+struct GvcLevelBarPrivate
+{
+ GtkOrientation orientation;
+ GtkAdjustment *peak_adjustment;
+ GtkAdjustment *rms_adjustment;
+ int scale;
+ gdouble peak_fraction;
+ gdouble rms_fraction;
+ gdouble max_peak;
+ guint max_peak_id;
+ LevelBarLayout layout;
+};
+
+enum
+{
+ PROP_0,
+ PROP_PEAK_ADJUSTMENT,
+ PROP_RMS_ADJUSTMENT,
+ PROP_SCALE,
+ PROP_ORIENTATION,
+};
+
+static void gvc_level_bar_class_init (GvcLevelBarClass *klass);
+static void gvc_level_bar_init (GvcLevelBar *level_bar);
+static void gvc_level_bar_finalize (GObject *object);
+
+G_DEFINE_TYPE (GvcLevelBar, gvc_level_bar, GTK_TYPE_HBOX)
+
+#define check_rectangle(rectangle1, rectangle2) \
+ { \
+ if (rectangle1.x != rectangle2.x) return TRUE; \
+ if (rectangle1.y != rectangle2.y) return TRUE; \
+ if (rectangle1.width != rectangle2.width) return TRUE; \
+ if (rectangle1.height != rectangle2.height) return TRUE; \
+ }
+
+static gboolean
+layout_changed (LevelBarLayout *layout1,
+ LevelBarLayout *layout2)
+{
+ check_rectangle (layout1->area, layout2->area);
+ if (layout1->delta != layout2->delta) return TRUE;
+ if (layout1->peak_num != layout2->peak_num) return TRUE;
+ if (layout1->max_peak_num != layout2->max_peak_num) return TRUE;
+ if (layout1->bg_r != layout2->bg_r
+ || layout1->bg_g != layout2->bg_g
+ || layout1->bg_b != layout2->bg_b)
+ return TRUE;
+ if (layout1->bdr_r != layout2->bdr_r
+ || layout1->bdr_g != layout2->bdr_g
+ || layout1->bdr_b != layout2->bdr_b)
+ return TRUE;
+ if (layout1->fl_r != layout2->fl_r
+ || layout1->fl_g != layout2->fl_g
+ || layout1->fl_b != layout2->fl_b)
+ return TRUE;
+
+ return FALSE;
+}
+
+static gdouble
+fraction_from_adjustment (GvcLevelBar *bar,
+ GtkAdjustment *adjustment)
+{
+ gdouble level;
+ gdouble fraction;
+ gdouble min;
+ gdouble max;
+
+ level = gtk_adjustment_get_value (adjustment);
+
+ min = gtk_adjustment_get_lower (adjustment);
+ max = gtk_adjustment_get_upper (adjustment);
+
+ switch (bar->priv->scale) {
+ case GVC_LEVEL_SCALE_LINEAR:
+ fraction = (level - min) / (max - min);
+ break;
+ case GVC_LEVEL_SCALE_LOG:
+ fraction = log10 ((level - min + 1) / (max - min + 1));
+ break;
+ default:
+ g_assert_not_reached ();
+ }
+
+ return fraction;
+}
+
+static gboolean
+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;
+ gtk_widget_queue_draw (GTK_WIDGET (bar));
+ bar->priv->max_peak_id = 0;
+ return FALSE;
+}
+
+static void
+bar_calc_layout (GvcLevelBar *bar)
+{
+ GdkColor color;
+ int peak_level;
+ int max_peak_level;
+ GtkAllocation allocation;
+ 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;
+
+ 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;
+ 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;
+ 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;
+
+ 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;
+
+ 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;
+ } else {
+ peak_level = bar->priv->peak_fraction * bar->priv->layout.area.width;
+ max_peak_level = bar->priv->max_peak * bar->priv->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->priv->layout.peak_num = peak_level / bar->priv->layout.delta;
+ bar->priv->layout.max_peak_num = max_peak_level / bar->priv->layout.delta;
+}
+
+static void
+update_peak_value (GvcLevelBar *bar)
+{
+ gdouble val;
+ LevelBarLayout layout;
+
+ layout = bar->priv->layout;
+
+ val = fraction_from_adjustment (bar, bar->priv->peak_adjustment);
+ bar->priv->peak_fraction = val;
+
+ if (val > bar->priv->max_peak) {
+ if (bar->priv->max_peak_id > 0) {
+ g_source_remove (bar->priv->max_peak_id);
+ }
+ bar->priv->max_peak_id = g_timeout_add_seconds (1, (GSourceFunc)reset_max_peak, bar);
+ bar->priv->max_peak = val;
+ }
+
+ bar_calc_layout (bar);
+
+ if (layout_changed (&bar->priv->layout, &layout)) {
+ gtk_widget_queue_draw (GTK_WIDGET (bar));
+ }
+}
+
+static void
+update_rms_value (GvcLevelBar *bar)
+{
+ gdouble val;
+
+ val = fraction_from_adjustment (bar, bar->priv->rms_adjustment);
+ bar->priv->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;
+}
+
+void
+gvc_level_bar_set_orientation (GvcLevelBar *bar,
+ GtkOrientation orientation)
+{
+ g_return_if_fail (GVC_IS_LEVEL_BAR (bar));
+
+ if (orientation != bar->priv->orientation) {
+ bar->priv->orientation = orientation;
+ gtk_widget_queue_draw (GTK_WIDGET (bar));
+ g_object_notify (G_OBJECT (bar), "orientation");
+ }
+}
+
+static void
+on_peak_adjustment_value_changed (GtkAdjustment *adjustment,
+ GvcLevelBar *bar)
+{
+ update_peak_value (bar);
+}
+
+static void
+on_rms_adjustment_value_changed (GtkAdjustment *adjustment,
+ GvcLevelBar *bar)
+{
+ update_rms_value (bar);
+}
+
+void
+gvc_level_bar_set_peak_adjustment (GvcLevelBar *bar,
+ GtkAdjustment *adjustment)
+{
+ 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,
+ G_CALLBACK (on_peak_adjustment_value_changed),
+ bar);
+ g_object_unref (bar->priv->peak_adjustment);
+ }
+
+ bar->priv->peak_adjustment = g_object_ref_sink (adjustment);
+
+ g_signal_connect (bar->priv->peak_adjustment,
+ "value-changed",
+ G_CALLBACK (on_peak_adjustment_value_changed),
+ bar);
+
+ update_peak_value (bar);
+
+ g_object_notify (G_OBJECT (bar), "peak-adjustment");
+}
+
+void
+gvc_level_bar_set_rms_adjustment (GvcLevelBar *bar,
+ GtkAdjustment *adjustment)
+{
+ 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,
+ G_CALLBACK (on_rms_adjustment_value_changed),
+ bar);
+ g_object_unref (bar->priv->rms_adjustment);
+ }
+
+ bar->priv->rms_adjustment = g_object_ref_sink (adjustment);
+
+
+ g_signal_connect (bar->priv->peak_adjustment,
+ "value-changed",
+ G_CALLBACK (on_peak_adjustment_value_changed),
+ bar);
+
+ update_rms_value (bar);
+
+ g_object_notify (G_OBJECT (bar), "rms-adjustment");
+}
+
+GtkAdjustment *
+gvc_level_bar_get_peak_adjustment (GvcLevelBar *bar)
+{
+ g_return_val_if_fail (GVC_IS_LEVEL_BAR (bar), NULL);
+
+ return bar->priv->peak_adjustment;
+}
+
+GtkAdjustment *
+gvc_level_bar_get_rms_adjustment (GvcLevelBar *bar)
+{
+ g_return_val_if_fail (GVC_IS_LEVEL_BAR (bar), NULL);
+
+ return bar->priv->rms_adjustment;
+}
+
+void
+gvc_level_bar_set_scale (GvcLevelBar *bar,
+ GvcLevelScale scale)
+{
+ g_return_if_fail (GVC_IS_LEVEL_BAR (bar));
+
+ if (scale != bar->priv->scale) {
+ bar->priv->scale = scale;
+
+ update_peak_value (bar);
+ update_rms_value (bar);
+
+ g_object_notify (G_OBJECT (bar), "scale");
+ }
+}
+
+static void
+gvc_level_bar_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GvcLevelBar *self = GVC_LEVEL_BAR (object);
+
+ switch (prop_id) {
+ case PROP_SCALE:
+ gvc_level_bar_set_scale (self, g_value_get_int (value));
+ break;
+ case PROP_ORIENTATION:
+ gvc_level_bar_set_orientation (self, g_value_get_enum (value));
+ break;
+ case PROP_PEAK_ADJUSTMENT:
+ gvc_level_bar_set_peak_adjustment (self, g_value_get_object (value));
+ break;
+ case PROP_RMS_ADJUSTMENT:
+ gvc_level_bar_set_rms_adjustment (self, g_value_get_object (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gvc_level_bar_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GvcLevelBar *self = GVC_LEVEL_BAR (object);
+
+ switch (prop_id) {
+ case PROP_SCALE:
+ g_value_set_int (value, self->priv->scale);
+ break;
+ case PROP_ORIENTATION:
+ g_value_set_enum (value, self->priv->orientation);
+ break;
+ case PROP_PEAK_ADJUSTMENT:
+ g_value_set_object (value, self->priv->peak_adjustment);
+ break;
+ case PROP_RMS_ADJUSTMENT:
+ g_value_set_object (value, self->priv->rms_adjustment);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static GObject *
+gvc_level_bar_constructor (GType type,
+ guint n_construct_properties,
+ GObjectConstructParam *construct_params)
+{
+ return G_OBJECT_CLASS (gvc_level_bar_parent_class)->constructor (type, n_construct_properties, construct_params);
+}
+
+static void
+gvc_level_bar_size_request (GtkWidget *widget,
+ GtkRequisition *requisition)
+{
+ GvcLevelBar *bar;
+
+ g_return_if_fail (GVC_IS_LEVEL_BAR (widget));
+ g_return_if_fail (requisition != NULL);
+
+ bar = GVC_LEVEL_BAR (widget);
+
+ switch (bar->priv->orientation) {
+ case GTK_ORIENTATION_VERTICAL:
+ requisition->width = VERTICAL_BAR_WIDTH;
+ requisition->height = MIN_VERTICAL_BAR_HEIGHT;
+ break;
+ case GTK_ORIENTATION_HORIZONTAL:
+ requisition->width = MIN_HORIZONTAL_BAR_WIDTH;
+ requisition->height = HORIZONTAL_BAR_HEIGHT;
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+}
+
+static void
+gvc_level_bar_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation)
+{
+ GvcLevelBar *bar;
+
+ g_return_if_fail (GVC_IS_LEVEL_BAR (widget));
+ g_return_if_fail (allocation != NULL);
+
+ bar = GVC_LEVEL_BAR (widget);
+
+ /* FIXME: add height property, labels, etc */
+ GTK_WIDGET_CLASS (gvc_level_bar_parent_class)->size_allocate (widget, allocation);
+
+ gtk_widget_set_allocation (widget, allocation);
+ gtk_widget_get_allocation (widget, allocation);
+
+ if (bar->priv->orientation == GTK_ORIENTATION_VERTICAL) {
+ allocation->height = MIN (allocation->height, MIN_VERTICAL_BAR_HEIGHT);
+ allocation->width = MAX (allocation->width, VERTICAL_BAR_WIDTH);
+ } else {
+ allocation->width = MIN (allocation->width, MIN_HORIZONTAL_BAR_WIDTH);
+ allocation->height = MAX (allocation->height, HORIZONTAL_BAR_HEIGHT);
+ }
+
+ bar_calc_layout (bar);
+}
+
+static void
+curved_rectangle (cairo_t *cr,
+ double x0,
+ double y0,
+ double width,
+ double height,
+ double radius)
+{
+ double x1;
+ double y1;
+
+ x1 = x0 + width;
+ y1 = y0 + height;
+
+ if (!width || !height) {
+ return;
+ }
+
+ if (width / 2 < radius) {
+ if (height / 2 < radius) {
+ cairo_move_to (cr, x0, (y0 + y1) / 2);
+ cairo_curve_to (cr, x0 ,y0, x0, y0, (x0 + x1) / 2, y0);
+ cairo_curve_to (cr, x1, y0, x1, y0, x1, (y0 + y1) / 2);
+ cairo_curve_to (cr, x1, y1, x1, y1, (x1 + x0) / 2, y1);
+ cairo_curve_to (cr, x0, y1, x0, y1, x0, (y0 + y1) / 2);
+ } else {
+ cairo_move_to (cr, x0, y0 + radius);
+ cairo_curve_to (cr, x0, y0, x0, y0, (x0 + x1) / 2, y0);
+ cairo_curve_to (cr, x1, y0, x1, y0, x1, y0 + radius);
+ cairo_line_to (cr, x1, y1 - radius);
+ cairo_curve_to (cr, x1, y1, x1, y1, (x1 + x0) / 2, y1);
+ cairo_curve_to (cr, x0, y1, x0, y1, x0, y1 - radius);
+ }
+ } else {
+ if (height / 2 < radius) {
+ cairo_move_to (cr, x0, (y0 + y1) / 2);
+ cairo_curve_to (cr, x0, y0, x0 , y0, x0 + radius, y0);
+ cairo_line_to (cr, x1 - radius, y0);
+ cairo_curve_to (cr, x1, y0, x1, y0, x1, (y0 + y1) / 2);
+ cairo_curve_to (cr, x1, y1, x1, y1, x1 - radius, y1);
+ cairo_line_to (cr, x0 + radius, y1);
+ cairo_curve_to (cr, x0, y1, x0, y1, x0, (y0 + y1) / 2);
+ } else {
+ cairo_move_to (cr, x0, y0 + radius);
+ cairo_curve_to (cr, x0 , y0, x0 , y0, x0 + radius, y0);
+ cairo_line_to (cr, x1 - radius, y0);
+ cairo_curve_to (cr, x1, y0, x1, y0, x1, y0 + radius);
+ cairo_line_to (cr, x1, y1 - radius);
+ cairo_curve_to (cr, x1, y1, x1, y1, x1 - radius, y1);
+ cairo_line_to (cr, x0 + radius, y1);
+ cairo_curve_to (cr, x0, y1, x0, y1, x0, y1 - radius);
+ }
+ }
+
+ cairo_close_path (cr);
+}
+
+static int
+gvc_level_bar_expose (GtkWidget *widget,
+ GdkEventExpose *event)
+{
+ GvcLevelBar *bar;
+ cairo_t *cr;
+ GtkAllocation allocation;
+
+ g_return_val_if_fail (GVC_IS_LEVEL_BAR (widget), FALSE);
+ g_return_val_if_fail (event != NULL, FALSE);
+
+ /* event queue compression */
+ if (event->count > 0) {
+ return FALSE;
+ }
+
+ bar = GVC_LEVEL_BAR (widget);
+
+ cr = gdk_cairo_create (gtk_widget_get_window (widget));
+
+ gtk_widget_get_allocation (widget, &allocation);
+ cairo_translate (cr,
+ allocation.x,
+ allocation.y);
+
+ if (bar->priv->orientation == GTK_ORIENTATION_VERTICAL) {
+ int i;
+ int by;
+
+ for (i = 0; i < NUM_BOXES; i++) {
+ by = i * bar->priv->layout.delta;
+ curved_rectangle (cr,
+ bar->priv->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) {
+ /* fill peak foreground */
+ cairo_set_source_rgb (cr, bar->priv->layout.fl_r, bar->priv->layout.fl_g, bar->priv->layout.fl_b);
+ cairo_fill_preserve (cr);
+ } else if ((bar->priv->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_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_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_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_line_width (cr, 1);
+ cairo_stroke (cr);
+ }
+
+ } else {
+ int i;
+ int bx;
+
+ for (i = 0; i < NUM_BOXES; i++) {
+ bx = i * bar->priv->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);
+
+ if ((bar->priv->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_fill_preserve (cr);
+ } else if ((bar->priv->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_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_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_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_line_width (cr, 1);
+ cairo_stroke (cr);
+ }
+ }
+ cairo_destroy (cr);
+
+ return FALSE;
+}
+
+static void
+gvc_level_bar_class_init (GvcLevelBarClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+ object_class->constructor = gvc_level_bar_constructor;
+ object_class->finalize = gvc_level_bar_finalize;
+ object_class->set_property = gvc_level_bar_set_property;
+ object_class->get_property = gvc_level_bar_get_property;
+
+ widget_class->expose_event = gvc_level_bar_expose;
+ widget_class->size_request = gvc_level_bar_size_request;
+ widget_class->size_allocate = gvc_level_bar_size_allocate;
+
+ g_object_class_install_property (object_class,
+ PROP_ORIENTATION,
+ g_param_spec_enum ("orientation",
+ "Orientation",
+ "The orientation of the bar",
+ GTK_TYPE_ORIENTATION,
+ GTK_ORIENTATION_HORIZONTAL,
+ G_PARAM_READWRITE));
+ g_object_class_install_property (object_class,
+ PROP_PEAK_ADJUSTMENT,
+ g_param_spec_object ("peak-adjustment",
+ "Peak Adjustment",
+ "The GtkAdjustment that contains the current peak value",
+ GTK_TYPE_ADJUSTMENT,
+ G_PARAM_READWRITE));
+ g_object_class_install_property (object_class,
+ PROP_RMS_ADJUSTMENT,
+ g_param_spec_object ("rms-adjustment",
+ "RMS Adjustment",
+ "The GtkAdjustment that contains the current rms value",
+ GTK_TYPE_ADJUSTMENT,
+ G_PARAM_READWRITE));
+ g_object_class_install_property (object_class,
+ PROP_SCALE,
+ g_param_spec_int ("scale",
+ "Scale",
+ "Scale",
+ 0,
+ 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,
+ 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,
+ "value-changed",
+ G_CALLBACK (on_peak_adjustment_value_changed),
+ bar);
+
+ bar->priv->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,
+ "value-changed",
+ G_CALLBACK (on_rms_adjustment_value_changed),
+ bar);
+
+ gtk_widget_set_has_window (GTK_WIDGET (bar), FALSE);
+}
+
+static void
+gvc_level_bar_finalize (GObject *object)
+{
+ GvcLevelBar *bar;
+
+ g_return_if_fail (object != NULL);
+ g_return_if_fail (GVC_IS_LEVEL_BAR (object));
+
+ bar = GVC_LEVEL_BAR (object);
+
+ if (bar->priv->max_peak_id > 0) {
+ g_source_remove (bar->priv->max_peak_id);
+ }
+
+ g_return_if_fail (bar->priv != NULL);
+
+ G_OBJECT_CLASS (gvc_level_bar_parent_class)->finalize (object);
+}
+
+GtkWidget *
+gvc_level_bar_new (void)
+{
+ GObject *bar;
+ bar = g_object_new (GVC_TYPE_LEVEL_BAR,
+ NULL);
+ return GTK_WIDGET (bar);
+}