← Back to branch summary

~ubuntu-branches/ubuntu/utopic/gnome-control-center/utopic-proposed

« back to all changes in this revision

Viewing changes to panels/sound-nua/gvc-level-bar.c

  • Committer: Package Import Robot
  • Author(s): Sebastien Bacher, Sebastien Bacher, Robert Ancell, Iain Lane, Edward Donovan, Rico Tzschichholz, Jeremy Bicha, David Henningsson
  • Date: 2012-11-21 19:32:45 UTC
  • mfrom: (1.1.63)
  • Revision ID: package-import@ubuntu.com-20121121193245-mj61nzz1z4fk3z25
Tags: 1:3.6.3-0ubuntu1
https://launchpad.net/bugs/1004973
https://launchpad.net/bugs/1010317
https://launchpad.net/bugs/1013171
https://launchpad.net/bugs/1035219
[ Sebastien Bacher ]
* New upstream version
* debian/control.in: recommends libcanberra-pulse (lp: #1004973)
* debian/patches/58_ubuntu_icon_views_redesign.patch:
  - drop most of the changes, keep the different grid size though
    to fit on screen with our extra icons
* debian/patches/91_dont_show_in_unity.patch:
  - dropped, show the upstream printer panel and the layout tab
* debian/patches/revert_git_keyboard_gsettings.patch,
  debian/patches/revert_git_stop_using_gconf.patch:
  - dropped the gconf->gsettings reverts

[ Robert Ancell ]
* New upstream release (LP: #1010317)
* debian/control:
  - Bump build-depends on libgnome-desktop-3-dev, libwacom-dev
  - Add build-depends on libclutter-1.0-dev, libclutter-gtk-1.0-dev,
    libpwquality-dev
  - Drop build-depends on libgnomekbd-dev
* debian/patches/60_ubuntu_nav_bar.patch:
  - Disabled for now, doesn't apply
* debian/patches/revert_ua_gsettings.patch:
  - We can use GSettings for universal access now
* debian/patches/00git_online_accounts_gtkgrid.patch:
* debian/patches/00git_online_accounts_layout.part:
* debian/patches/git_wacom_translations.patch:
  - Applied upstream

[ Iain Lane ]
* Add Build-Depends on libxkbfile-dev
* New upstream release.
* Refresh all patches to apply cleanly.

[ Edward Donovan ]
* debian/source_gnome-control-center.py: Fix for Python 3. (LP: #1013171)

[ Rico Tzschichholz ]
* debian/control.in:
  - Build-depend on gtk-doc-tools instead of docbook directly
  - Bump minimum glib-2.0, gnome-desktop3, gnome-settings-daemon
     and gsettings-desktop-schemas

[ Jeremy Bicha ]
* Dropped more patches applied in new version:
  - git_unmute_sound_event.patch
  - git_fix_big_editable_labels.patch
  - 96_sound_nua_panel.patch
* debian/patches/04_new_appearance_settings.patch:
  - Dropped, this is now packaged separately as gnome-control-center-unity
* debian/patches/10_keyboard_layout_on_unity.patch:
  - Don't change the keyboard panel name when not running Unity
* debian/patches/52_ubuntu_language_list_mods.patch:
  - Don't disable adding current language to the list. While this
    fix shows the current language twice, at least it avoids the
    "Ubuntu suddenly in Chinese" bug (LP: #1035219)
* debian/patches/53_use_ubuntu_help.patch:
  - Only show Ubuntu help when running Unity
* debian/patches/58_hide_gdm_notifications.patch:
  - Hide "Show notifications when locked" settings when running Unity
    since it's a GNOME Shell-specific feature
* debian/patches/63_normal_scrollbar_in_a11y.patch:
  - Drop, overlay-scrollbars should handle this instead
* debian/patches/91_dont_show_in_unity.patch:
  - Hide Printers & Region panels in Unity until we're ready to switch
    to them.
* debian/patches/fix-crash-on-user-panel.patch:
  - Dropped, GNOME says it's obsolete
* debian/rules:
  - Build with -z,defs again
  - Explicitly disable ibus support since ibus 1.4 isn't supported in
    this version
* debian/control.in:
  - Drop ubuntu-docs and gnome-user-guide from recommends to suggests
  - Don't recommend indicators; let's leave that to Unity

[ David Henningsson ]
* sound_nua_panel.patch: Rebase to gnome 3.6 

Show diffs side-by-side

added added

removed removed

Lines of Context:
panels/sound-nua/gvc-level-bar.c
1
 
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
2
 
 *
3
 
 * Copyright (C) 2008 William Jon McCann <william.jon.mccann@gmail.com>
4
 
 *
5
 
 * This program is free software; you can redistribute it and/or modify
6
 
 * it under the terms of the GNU General Public License as published by
7
 
 * the Free Software Foundation; either version 2 of the License, or
8
 
 * (at your option) any later version.
9
 
 *
10
 
 * This program is distributed in the hope that it will be useful,
11
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 * GNU General Public License for more details.
14
 
 *
15
 
 * You should have received a copy of the GNU General Public License
16
 
 * along with this program; if not, write to the Free Software
17
 
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18
 
 *
19
 
 */
20
 
 
21
 
#include "config.h"
22
 
 
23
 
#include <stdlib.h>
24
 
#include <stdio.h>
25
 
#include <unistd.h>
26
 
#include <math.h>
27
 
 
28
 
#include <glib.h>
29
 
#include <glib/gi18n-lib.h>
30
 
#include <gtk/gtk.h>
31
 
 
32
 
#include "gvc-level-bar.h"
33
 
 
34
 
#define NUM_BOXES 30
35
 
 
36
 
#define GVC_LEVEL_BAR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GVC_TYPE_LEVEL_BAR, GvcLevelBarPrivate))
37
 
 
38
 
#define MIN_HORIZONTAL_BAR_WIDTH   150
39
 
#define HORIZONTAL_BAR_HEIGHT      6
40
 
#define VERTICAL_BAR_WIDTH         6
41
 
#define MIN_VERTICAL_BAR_HEIGHT    400
42
 
 
43
 
typedef struct {
44
 
        int          peak_num;
45
 
        int          max_peak_num;
46
 
 
47
 
        GdkRectangle area;
48
 
        int          delta;
49
 
        int          box_width;
50
 
        int          box_height;
51
 
        int          box_radius;
52
 
        double       bg_r;
53
 
        double       bg_g;
54
 
        double       bg_b;
55
 
        double       bdr_r;
56
 
        double       bdr_g;
57
 
        double       bdr_b;
58
 
        double       fl_r;
59
 
        double       fl_g;
60
 
        double       fl_b;
61
 
} LevelBarLayout;
62
 
 
63
 
struct GvcLevelBarPrivate
64
 
{
65
 
        GtkOrientation orientation;
66
 
        GtkAdjustment *peak_adjustment;
67
 
        GtkAdjustment *rms_adjustment;
68
 
        int            scale;
69
 
        gdouble        peak_fraction;
70
 
        gdouble        rms_fraction;
71
 
        gdouble        max_peak;
72
 
        guint          max_peak_id;
73
 
        LevelBarLayout layout;
74
 
};
75
 
 
76
 
enum
77
 
{
78
 
        PROP_0,
79
 
        PROP_PEAK_ADJUSTMENT,
80
 
        PROP_RMS_ADJUSTMENT,
81
 
        PROP_SCALE,
82
 
        PROP_ORIENTATION,
83
 
};
84
 
 
85
 
static void     gvc_level_bar_class_init (GvcLevelBarClass *klass);
86
 
static void     gvc_level_bar_init       (GvcLevelBar      *level_bar);
87
 
static void     gvc_level_bar_finalize   (GObject            *object);
88
 
 
89
 
G_DEFINE_TYPE (GvcLevelBar, gvc_level_bar, GTK_TYPE_WIDGET)
90
 
 
91
 
#define check_rectangle(rectangle1, rectangle2)                          \
92
 
        {                                                                \
93
 
                /* .x and .y are always 0 */                             \
94
 
                if (rectangle1.width  != rectangle2.width)  return TRUE; \
95
 
                if (rectangle1.height != rectangle2.height) return TRUE; \
96
 
        }
97
 
 
98
 
static gboolean
99
 
layout_changed (LevelBarLayout *layout1,
100
 
                LevelBarLayout *layout2)
101
 
{
102
 
        check_rectangle (layout1->area, layout2->area);
103
 
        if (layout1->delta != layout2->delta) return TRUE;
104
 
        if (layout1->peak_num != layout2->peak_num) return TRUE;
105
 
        if (layout1->max_peak_num != layout2->max_peak_num) return TRUE;
106
 
        if (layout1->bg_r != layout2->bg_r
107
 
            || layout1->bg_g != layout2->bg_g
108
 
            || layout1->bg_b != layout2->bg_b)
109
 
                return TRUE;
110
 
        if (layout1->bdr_r != layout2->bdr_r
111
 
            || layout1->bdr_g != layout2->bdr_g
112
 
            || layout1->bdr_b != layout2->bdr_b)
113
 
                return TRUE;
114
 
        if (layout1->fl_r != layout2->fl_r
115
 
            || layout1->fl_g != layout2->fl_g
116
 
            || layout1->fl_b != layout2->fl_b)
117
 
                return TRUE;
118
 
 
119
 
        return FALSE;
120
 
}
121
 
 
122
 
static gdouble
123
 
fraction_from_adjustment (GvcLevelBar   *bar,
124
 
                          GtkAdjustment *adjustment)
125
 
{
126
 
        gdouble level;
127
 
        gdouble fraction;
128
 
        gdouble min;
129
 
        gdouble max;
130
 
 
131
 
        level = gtk_adjustment_get_value (adjustment);
132
 
 
133
 
        min = gtk_adjustment_get_lower (adjustment);
134
 
        max = gtk_adjustment_get_upper (adjustment);
135
 
 
136
 
        switch (bar->priv->scale) {
137
 
        case GVC_LEVEL_SCALE_LINEAR:
138
 
                fraction = (level - min) / (max - min);
139
 
                break;
140
 
        case GVC_LEVEL_SCALE_LOG:
141
 
                fraction = log10 ((level - min + 1) / (max - min + 1));
142
 
                break;
143
 
        default:
144
 
                g_assert_not_reached ();
145
 
        }
146
 
 
147
 
        return fraction;
148
 
}
149
 
 
150
 
static gboolean
151
 
reset_max_peak (GvcLevelBar *bar)
152
 
{
153
 
        gdouble min;
154
 
 
155
 
        min = gtk_adjustment_get_lower (bar->priv->peak_adjustment);
156
 
        bar->priv->max_peak = min;
157
 
        bar->priv->layout.max_peak_num = 0;
158
 
        gtk_widget_queue_draw (GTK_WIDGET (bar));
159
 
        bar->priv->max_peak_id = 0;
160
 
        return FALSE;
161
 
}
162
 
 
163
 
static void
164
 
bar_calc_layout (GvcLevelBar *bar)
165
 
{
166
 
        GdkColor color;
167
 
        int      peak_level;
168
 
        int      max_peak_level;
169
 
        GtkAllocation allocation;
170
 
        GtkStyle *style;
171
 
 
172
 
        gtk_widget_get_allocation (GTK_WIDGET (bar), &allocation);
173
 
        bar->priv->layout.area.width = allocation.width - 2;
174
 
        bar->priv->layout.area.height = allocation.height - 2;
175
 
 
176
 
        style = gtk_widget_get_style (GTK_WIDGET (bar));
177
 
        color = style->bg [GTK_STATE_NORMAL];
178
 
        bar->priv->layout.bg_r = (float)color.red / 65535.0;
179
 
        bar->priv->layout.bg_g = (float)color.green / 65535.0;
180
 
        bar->priv->layout.bg_b = (float)color.blue / 65535.0;
181
 
        color = style->dark [GTK_STATE_NORMAL];
182
 
        bar->priv->layout.bdr_r = (float)color.red / 65535.0;
183
 
        bar->priv->layout.bdr_g = (float)color.green / 65535.0;
184
 
        bar->priv->layout.bdr_b = (float)color.blue / 65535.0;
185
 
        color = style->bg [GTK_STATE_SELECTED];
186
 
        bar->priv->layout.fl_r = (float)color.red / 65535.0;
187
 
        bar->priv->layout.fl_g = (float)color.green / 65535.0;
188
 
        bar->priv->layout.fl_b = (float)color.blue / 65535.0;
189
 
 
190
 
        if (bar->priv->orientation == GTK_ORIENTATION_VERTICAL) {
191
 
                peak_level = bar->priv->peak_fraction * bar->priv->layout.area.height;
192
 
                max_peak_level = bar->priv->max_peak * bar->priv->layout.area.height;
193
 
 
194
 
                bar->priv->layout.delta = bar->priv->layout.area.height / NUM_BOXES;
195
 
                bar->priv->layout.area.x = 0;
196
 
                bar->priv->layout.area.y = 0;
197
 
                bar->priv->layout.box_height = bar->priv->layout.delta / 2;
198
 
                bar->priv->layout.box_width = bar->priv->layout.area.width;
199
 
                bar->priv->layout.box_radius = bar->priv->layout.box_width / 2;
200
 
        } else {
201
 
                peak_level = bar->priv->peak_fraction * bar->priv->layout.area.width;
202
 
                max_peak_level = bar->priv->max_peak * bar->priv->layout.area.width;
203
 
 
204
 
                bar->priv->layout.delta = bar->priv->layout.area.width / NUM_BOXES;
205
 
                bar->priv->layout.area.x = 0;
206
 
                bar->priv->layout.area.y = 0;
207
 
                bar->priv->layout.box_width = bar->priv->layout.delta / 2;
208
 
                bar->priv->layout.box_height = bar->priv->layout.area.height;
209
 
                bar->priv->layout.box_radius = bar->priv->layout.box_height / 2;
210
 
        }
211
 
 
212
 
        /* This can happen if the level bar isn't realized */
213
 
        if (bar->priv->layout.delta == 0)
214
 
                return;
215
 
 
216
 
        bar->priv->layout.peak_num = peak_level / bar->priv->layout.delta;
217
 
        bar->priv->layout.max_peak_num = max_peak_level / bar->priv->layout.delta;
218
 
}
219
 
 
220
 
static void
221
 
update_peak_value (GvcLevelBar *bar)
222
 
{
223
 
        gdouble        val;
224
 
        LevelBarLayout layout;
225
 
 
226
 
        layout = bar->priv->layout;
227
 
 
228
 
        val = fraction_from_adjustment (bar, bar->priv->peak_adjustment);
229
 
        bar->priv->peak_fraction = val;
230
 
 
231
 
        if (val > bar->priv->max_peak) {
232
 
                if (bar->priv->max_peak_id > 0) {
233
 
                        g_source_remove (bar->priv->max_peak_id);
234
 
                }
235
 
                bar->priv->max_peak_id = g_timeout_add_seconds (1, (GSourceFunc)reset_max_peak, bar);
236
 
                bar->priv->max_peak = val;
237
 
        }
238
 
 
239
 
        bar_calc_layout (bar);
240
 
 
241
 
        if (layout_changed (&bar->priv->layout, &layout)) {
242
 
                gtk_widget_queue_draw (GTK_WIDGET (bar));
243
 
        }
244
 
}
245
 
 
246
 
static void
247
 
update_rms_value (GvcLevelBar *bar)
248
 
{
249
 
        gdouble val;
250
 
 
251
 
        val = fraction_from_adjustment (bar, bar->priv->rms_adjustment);
252
 
        bar->priv->rms_fraction = val;
253
 
}
254
 
 
255
 
GtkOrientation
256
 
gvc_level_bar_get_orientation (GvcLevelBar *bar)
257
 
{
258
 
        g_return_val_if_fail (GVC_IS_LEVEL_BAR (bar), 0);
259
 
        return bar->priv->orientation;
260
 
}
261
 
 
262
 
void
263
 
gvc_level_bar_set_orientation (GvcLevelBar   *bar,
264
 
                               GtkOrientation orientation)
265
 
{
266
 
        g_return_if_fail (GVC_IS_LEVEL_BAR (bar));
267
 
 
268
 
        if (orientation != bar->priv->orientation) {
269
 
                bar->priv->orientation = orientation;
270
 
                gtk_widget_queue_draw (GTK_WIDGET (bar));
271
 
                g_object_notify (G_OBJECT (bar), "orientation");
272
 
        }
273
 
}
274
 
 
275
 
static void
276
 
on_peak_adjustment_value_changed (GtkAdjustment *adjustment,
277
 
                                  GvcLevelBar   *bar)
278
 
{
279
 
        update_peak_value (bar);
280
 
}
281
 
 
282
 
static void
283
 
on_rms_adjustment_value_changed (GtkAdjustment *adjustment,
284
 
                                 GvcLevelBar   *bar)
285
 
{
286
 
        update_rms_value (bar);
287
 
}
288
 
 
289
 
void
290
 
gvc_level_bar_set_peak_adjustment (GvcLevelBar   *bar,
291
 
                                   GtkAdjustment *adjustment)
292
 
{
293
 
        g_return_if_fail (GVC_LEVEL_BAR (bar));
294
 
        g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
295
 
 
296
 
        if (bar->priv->peak_adjustment != NULL) {
297
 
                g_signal_handlers_disconnect_by_func (bar->priv->peak_adjustment,
298
 
                                                      G_CALLBACK (on_peak_adjustment_value_changed),
299
 
                                                      bar);
300
 
                g_object_unref (bar->priv->peak_adjustment);
301
 
        }
302
 
 
303
 
        bar->priv->peak_adjustment = g_object_ref_sink (adjustment);
304
 
 
305
 
        g_signal_connect (bar->priv->peak_adjustment,
306
 
                          "value-changed",
307
 
                          G_CALLBACK (on_peak_adjustment_value_changed),
308
 
                          bar);
309
 
 
310
 
        update_peak_value (bar);
311
 
 
312
 
        g_object_notify (G_OBJECT (bar), "peak-adjustment");
313
 
}
314
 
 
315
 
void
316
 
gvc_level_bar_set_rms_adjustment (GvcLevelBar   *bar,
317
 
                                  GtkAdjustment *adjustment)
318
 
{
319
 
        g_return_if_fail (GVC_LEVEL_BAR (bar));
320
 
        g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
321
 
 
322
 
        if (bar->priv->rms_adjustment != NULL) {
323
 
                g_signal_handlers_disconnect_by_func (bar->priv->peak_adjustment,
324
 
                                                      G_CALLBACK (on_rms_adjustment_value_changed),
325
 
                                                      bar);
326
 
                g_object_unref (bar->priv->rms_adjustment);
327
 
        }
328
 
 
329
 
        bar->priv->rms_adjustment = g_object_ref_sink (adjustment);
330
 
 
331
 
 
332
 
        g_signal_connect (bar->priv->peak_adjustment,
333
 
                          "value-changed",
334
 
                          G_CALLBACK (on_peak_adjustment_value_changed),
335
 
                          bar);
336
 
 
337
 
        update_rms_value (bar);
338
 
 
339
 
        g_object_notify (G_OBJECT (bar), "rms-adjustment");
340
 
}
341
 
 
342
 
GtkAdjustment *
343
 
gvc_level_bar_get_peak_adjustment (GvcLevelBar *bar)
344
 
{
345
 
        g_return_val_if_fail (GVC_IS_LEVEL_BAR (bar), NULL);
346
 
 
347
 
        return bar->priv->peak_adjustment;
348
 
}
349
 
 
350
 
GtkAdjustment *
351
 
gvc_level_bar_get_rms_adjustment (GvcLevelBar *bar)
352
 
{
353
 
        g_return_val_if_fail (GVC_IS_LEVEL_BAR (bar), NULL);
354
 
 
355
 
        return bar->priv->rms_adjustment;
356
 
}
357
 
 
358
 
void
359
 
gvc_level_bar_set_scale (GvcLevelBar  *bar,
360
 
                         GvcLevelScale scale)
361
 
{
362
 
        g_return_if_fail (GVC_IS_LEVEL_BAR (bar));
363
 
 
364
 
        if (scale != bar->priv->scale) {
365
 
                bar->priv->scale = scale;
366
 
 
367
 
                update_peak_value (bar);
368
 
                update_rms_value (bar);
369
 
 
370
 
                g_object_notify (G_OBJECT (bar), "scale");
371
 
        }
372
 
}
373
 
 
374
 
static void
375
 
gvc_level_bar_set_property (GObject       *object,
376
 
                              guint          prop_id,
377
 
                              const GValue  *value,
378
 
                              GParamSpec    *pspec)
379
 
{
380
 
        GvcLevelBar *self = GVC_LEVEL_BAR (object);
381
 
 
382
 
        switch (prop_id) {
383
 
        case PROP_SCALE:
384
 
                gvc_level_bar_set_scale (self, g_value_get_int (value));
385
 
                break;
386
 
        case PROP_ORIENTATION:
387
 
                gvc_level_bar_set_orientation (self, g_value_get_enum (value));
388
 
                break;
389
 
        case PROP_PEAK_ADJUSTMENT:
390
 
                gvc_level_bar_set_peak_adjustment (self, g_value_get_object (value));
391
 
                break;
392
 
        case PROP_RMS_ADJUSTMENT:
393
 
                gvc_level_bar_set_rms_adjustment (self, g_value_get_object (value));
394
 
                break;
395
 
        default:
396
 
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
397
 
                break;
398
 
        }
399
 
}
400
 
 
401
 
static void
402
 
gvc_level_bar_get_property (GObject     *object,
403
 
                              guint        prop_id,
404
 
                              GValue      *value,
405
 
                              GParamSpec  *pspec)
406
 
{
407
 
        GvcLevelBar *self = GVC_LEVEL_BAR (object);
408
 
 
409
 
        switch (prop_id) {
410
 
        case PROP_SCALE:
411
 
                g_value_set_int (value, self->priv->scale);
412
 
                break;
413
 
        case PROP_ORIENTATION:
414
 
                g_value_set_enum (value, self->priv->orientation);
415
 
                break;
416
 
        case PROP_PEAK_ADJUSTMENT:
417
 
                g_value_set_object (value, self->priv->peak_adjustment);
418
 
                break;
419
 
        case PROP_RMS_ADJUSTMENT:
420
 
                g_value_set_object (value, self->priv->rms_adjustment);
421
 
                break;
422
 
        default:
423
 
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
424
 
                break;
425
 
        }
426
 
}
427
 
 
428
 
static GObject *
429
 
gvc_level_bar_constructor (GType                  type,
430
 
                           guint                  n_construct_properties,
431
 
                           GObjectConstructParam *construct_params)
432
 
{
433
 
        return G_OBJECT_CLASS (gvc_level_bar_parent_class)->constructor (type, n_construct_properties, construct_params);
434
 
}
435
 
 
436
 
static void
437
 
gvc_level_bar_size_request (GtkWidget      *widget,
438
 
                            GtkRequisition *requisition)
439
 
{
440
 
        GvcLevelBar *bar = GVC_LEVEL_BAR (widget);
441
 
 
442
 
        switch (bar->priv->orientation) {
443
 
        case GTK_ORIENTATION_VERTICAL:
444
 
                requisition->width = VERTICAL_BAR_WIDTH;
445
 
                requisition->height = MIN_VERTICAL_BAR_HEIGHT;
446
 
                break;
447
 
        case GTK_ORIENTATION_HORIZONTAL:
448
 
                requisition->width = MIN_HORIZONTAL_BAR_WIDTH;
449
 
                requisition->height = HORIZONTAL_BAR_HEIGHT;
450
 
                break;
451
 
        default:
452
 
                g_assert_not_reached ();
453
 
                break;
454
 
        }
455
 
}
456
 
 
457
 
static void
458
 
gvc_level_bar_get_preferred_width (GtkWidget *widget,
459
 
                                   gint      *minimum,
460
 
                                   gint      *natural)
461
 
{
462
 
        GtkRequisition requisition;
463
 
 
464
 
        gvc_level_bar_size_request (widget, &requisition);
465
 
 
466
 
        if (minimum != NULL) {
467
 
                *minimum = requisition.width;
468
 
        }
469
 
        if (natural != NULL) {
470
 
                *natural = requisition.width;
471
 
        }
472
 
}
473
 
 
474
 
static void
475
 
gvc_level_bar_get_preferred_height (GtkWidget *widget,
476
 
                                    gint      *minimum,
477
 
                                    gint      *natural)
478
 
{
479
 
        GtkRequisition requisition;
480
 
 
481
 
        gvc_level_bar_size_request (widget, &requisition);
482
 
 
483
 
        if (minimum != NULL) {
484
 
                *minimum = requisition.height;
485
 
        }
486
 
        if (natural != NULL) {
487
 
                *natural = requisition.height;
488
 
        }
489
 
}
490
 
 
491
 
static void
492
 
gvc_level_bar_size_allocate (GtkWidget     *widget,
493
 
                             GtkAllocation *allocation)
494
 
{
495
 
        GvcLevelBar *bar;
496
 
 
497
 
        g_return_if_fail (GVC_IS_LEVEL_BAR (widget));
498
 
        g_return_if_fail (allocation != NULL);
499
 
 
500
 
        bar = GVC_LEVEL_BAR (widget);
501
 
 
502
 
        /* FIXME: add height property, labels, etc */
503
 
        GTK_WIDGET_CLASS (gvc_level_bar_parent_class)->size_allocate (widget, allocation);
504
 
 
505
 
        gtk_widget_set_allocation (widget, allocation);
506
 
        gtk_widget_get_allocation (widget, allocation);
507
 
 
508
 
        if (bar->priv->orientation == GTK_ORIENTATION_VERTICAL) {
509
 
                allocation->height = MIN (allocation->height, MIN_VERTICAL_BAR_HEIGHT);
510
 
                allocation->width = MAX (allocation->width, VERTICAL_BAR_WIDTH);
511
 
        } else {
512
 
                allocation->width = MIN (allocation->width, MIN_HORIZONTAL_BAR_WIDTH);
513
 
                allocation->height = MAX (allocation->height, HORIZONTAL_BAR_HEIGHT);
514
 
        }
515
 
 
516
 
        bar_calc_layout (bar);
517
 
}
518
 
 
519
 
static void
520
 
curved_rectangle (cairo_t *cr,
521
 
                  double   x0,
522
 
                  double   y0,
523
 
                  double   width,
524
 
                  double   height,
525
 
                  double   radius)
526
 
{
527
 
        double x1;
528
 
        double y1;
529
 
 
530
 
        x1 = x0 + width;
531
 
        y1 = y0 + height;
532
 
 
533
 
        if (!width || !height) {
534
 
                return;
535
 
        }
536
 
 
537
 
        if (width / 2 < radius) {
538
 
                if (height / 2 < radius) {
539
 
                        cairo_move_to  (cr, x0, (y0 + y1) / 2);
540
 
                        cairo_curve_to (cr, x0 ,y0, x0, y0, (x0 + x1) / 2, y0);
541
 
                        cairo_curve_to (cr, x1, y0, x1, y0, x1, (y0 + y1) / 2);
542
 
                        cairo_curve_to (cr, x1, y1, x1, y1, (x1 + x0) / 2, y1);
543
 
                        cairo_curve_to (cr, x0, y1, x0, y1, x0, (y0 + y1) / 2);
544
 
                } else {
545
 
                        cairo_move_to  (cr, x0, y0 + radius);
546
 
                        cairo_curve_to (cr, x0, y0, x0, y0, (x0 + x1) / 2, y0);
547
 
                        cairo_curve_to (cr, x1, y0, x1, y0, x1, y0 + radius);
548
 
                        cairo_line_to (cr, x1, y1 - radius);
549
 
                        cairo_curve_to (cr, x1, y1, x1, y1, (x1 + x0) / 2, y1);
550
 
                        cairo_curve_to (cr, x0, y1, x0, y1, x0, y1 - radius);
551
 
                }
552
 
        } else {
553
 
                if (height / 2 < radius) {
554
 
                        cairo_move_to  (cr, x0, (y0 + y1) / 2);
555
 
                        cairo_curve_to (cr, x0, y0, x0 , y0, x0 + radius, y0);
556
 
                        cairo_line_to (cr, x1 - radius, y0);
557
 
                        cairo_curve_to (cr, x1, y0, x1, y0, x1, (y0 + y1) / 2);
558
 
                        cairo_curve_to (cr, x1, y1, x1, y1, x1 - radius, y1);
559
 
                        cairo_line_to (cr, x0 + radius, y1);
560
 
                        cairo_curve_to (cr, x0, y1, x0, y1, x0, (y0 + y1) / 2);
561
 
                } else {
562
 
                        cairo_move_to  (cr, x0, y0 + radius);
563
 
                        cairo_curve_to (cr, x0 , y0, x0 , y0, x0 + radius, y0);
564
 
                        cairo_line_to (cr, x1 - radius, y0);
565
 
                        cairo_curve_to (cr, x1, y0, x1, y0, x1, y0 + radius);
566
 
                        cairo_line_to (cr, x1, y1 - radius);
567
 
                        cairo_curve_to (cr, x1, y1, x1, y1, x1 - radius, y1);
568
 
                        cairo_line_to (cr, x0 + radius, y1);
569
 
                        cairo_curve_to (cr, x0, y1, x0, y1, x0, y1 - radius);
570
 
                }
571
 
        }
572
 
 
573
 
        cairo_close_path (cr);
574
 
}
575
 
 
576
 
static int
577
 
gvc_level_bar_draw (GtkWidget *widget,
578
 
                    cairo_t   *cr)
579
 
{
580
 
        GvcLevelBar     *bar;
581
 
 
582
 
        g_return_val_if_fail (GVC_IS_LEVEL_BAR (widget), FALSE);
583
 
 
584
 
        bar = GVC_LEVEL_BAR (widget);
585
 
 
586
 
        if (bar->priv->orientation == GTK_ORIENTATION_VERTICAL) {
587
 
                int i;
588
 
                int by;
589
 
 
590
 
                for (i = 0; i < NUM_BOXES; i++) {
591
 
                        by = i * bar->priv->layout.delta;
592
 
                        curved_rectangle (cr,
593
 
                                          bar->priv->layout.area.x + 0.5,
594
 
                                          by + 0.5,
595
 
                                          bar->priv->layout.box_width - 1,
596
 
                                          bar->priv->layout.box_height - 1,
597
 
                                          bar->priv->layout.box_radius);
598
 
                        if ((bar->priv->layout.max_peak_num - 1) == i) {
599
 
                                /* fill peak foreground */
600
 
                                cairo_set_source_rgb (cr, bar->priv->layout.fl_r, bar->priv->layout.fl_g, bar->priv->layout.fl_b);
601
 
                                cairo_fill_preserve (cr);
602
 
                        } else if ((bar->priv->layout.peak_num - 1) >= i) {
603
 
                                /* fill background */
604
 
                                cairo_set_source_rgb (cr, bar->priv->layout.bg_r, bar->priv->layout.bg_g, bar->priv->layout.bg_b);
605
 
                                cairo_fill_preserve (cr);
606
 
                                /* fill foreground */
607
 
                                cairo_set_source_rgba (cr, bar->priv->layout.fl_r, bar->priv->layout.fl_g, bar->priv->layout.fl_b, 0.5);
608
 
                                cairo_fill_preserve (cr);
609
 
                        } else {
610
 
                                /* fill background */
611
 
                                cairo_set_source_rgb (cr, bar->priv->layout.bg_r, bar->priv->layout.bg_g, bar->priv->layout.bg_b);
612
 
                                cairo_fill_preserve (cr);
613
 
                        }
614
 
 
615
 
                        /* stroke border */
616
 
                        cairo_set_source_rgb (cr, bar->priv->layout.bdr_r, bar->priv->layout.bdr_g, bar->priv->layout.bdr_b);
617
 
                        cairo_set_line_width (cr, 1);
618
 
                        cairo_stroke (cr);
619
 
                }
620
 
 
621
 
        } else {
622
 
                int i;
623
 
                int bx;
624
 
 
625
 
                for (i = 0; i < NUM_BOXES; i++) {
626
 
                        bx = i * bar->priv->layout.delta;
627
 
                        curved_rectangle (cr,
628
 
                                          bx + 0.5,
629
 
                                          bar->priv->layout.area.y + 0.5,
630
 
                                          bar->priv->layout.box_width - 1,
631
 
                                          bar->priv->layout.box_height - 1,
632
 
                                          bar->priv->layout.box_radius);
633
 
 
634
 
                        if ((bar->priv->layout.max_peak_num - 1) == i) {
635
 
                                /* fill peak foreground */
636
 
                                cairo_set_source_rgb (cr, bar->priv->layout.fl_r, bar->priv->layout.fl_g, bar->priv->layout.fl_b);
637
 
                                cairo_fill_preserve (cr);
638
 
                        } else if ((bar->priv->layout.peak_num - 1) >= i) {
639
 
                                /* fill background */
640
 
                                cairo_set_source_rgb (cr, bar->priv->layout.bg_r, bar->priv->layout.bg_g, bar->priv->layout.bg_b);
641
 
                                cairo_fill_preserve (cr);
642
 
                                /* fill foreground */
643
 
                                cairo_set_source_rgba (cr, bar->priv->layout.fl_r, bar->priv->layout.fl_g, bar->priv->layout.fl_b, 0.5);
644
 
                                cairo_fill_preserve (cr);
645
 
                        } else {
646
 
                                /* fill background */
647
 
                                cairo_set_source_rgb (cr, bar->priv->layout.bg_r, bar->priv->layout.bg_g, bar->priv->layout.bg_b);
648
 
                                cairo_fill_preserve (cr);
649
 
                        }
650
 
 
651
 
                        /* stroke border */
652
 
                        cairo_set_source_rgb (cr, bar->priv->layout.bdr_r, bar->priv->layout.bdr_g, bar->priv->layout.bdr_b);
653
 
                        cairo_set_line_width (cr, 1);
654
 
                        cairo_stroke (cr);
655
 
                }
656
 
        }
657
 
 
658
 
        return FALSE;
659
 
}
660
 
 
661
 
static void
662
 
gvc_level_bar_class_init (GvcLevelBarClass *klass)
663
 
{
664
 
        GObjectClass   *object_class = G_OBJECT_CLASS (klass);
665
 
        GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
666
 
 
667
 
        object_class->constructor = gvc_level_bar_constructor;
668
 
        object_class->finalize = gvc_level_bar_finalize;
669
 
        object_class->set_property = gvc_level_bar_set_property;
670
 
        object_class->get_property = gvc_level_bar_get_property;
671
 
 
672
 
        widget_class->draw = gvc_level_bar_draw;
673
 
        widget_class->get_preferred_width = gvc_level_bar_get_preferred_width;
674
 
        widget_class->get_preferred_height = gvc_level_bar_get_preferred_height;
675
 
        widget_class->size_allocate = gvc_level_bar_size_allocate;
676
 
 
677
 
        g_object_class_install_property (object_class,
678
 
                                         PROP_ORIENTATION,
679
 
                                         g_param_spec_enum ("orientation",
680
 
                                                            "Orientation",
681
 
                                                            "The orientation of the bar",
682
 
                                                            GTK_TYPE_ORIENTATION,
683
 
                                                            GTK_ORIENTATION_HORIZONTAL,
684
 
                                                            G_PARAM_READWRITE));
685
 
        g_object_class_install_property (object_class,
686
 
                                         PROP_PEAK_ADJUSTMENT,
687
 
                                         g_param_spec_object ("peak-adjustment",
688
 
                                                              "Peak Adjustment",
689
 
                                                              "The GtkAdjustment that contains the current peak value",
690
 
                                                              GTK_TYPE_ADJUSTMENT,
691
 
                                                              G_PARAM_READWRITE));
692
 
        g_object_class_install_property (object_class,
693
 
                                         PROP_RMS_ADJUSTMENT,
694
 
                                         g_param_spec_object ("rms-adjustment",
695
 
                                                              "RMS Adjustment",
696
 
                                                              "The GtkAdjustment that contains the current rms value",
697
 
                                                              GTK_TYPE_ADJUSTMENT,
698
 
                                                              G_PARAM_READWRITE));
699
 
        g_object_class_install_property (object_class,
700
 
                                         PROP_SCALE,
701
 
                                         g_param_spec_int ("scale",
702
 
                                                           "Scale",
703
 
                                                           "Scale",
704
 
                                                           0,
705
 
                                                           G_MAXINT,
706
 
                                                           GVC_LEVEL_SCALE_LINEAR,
707
 
                                                           G_PARAM_READWRITE|G_PARAM_CONSTRUCT));
708
 
 
709
 
        g_type_class_add_private (klass, sizeof (GvcLevelBarPrivate));
710
 
}
711
 
 
712
 
static void
713
 
gvc_level_bar_init (GvcLevelBar *bar)
714
 
{
715
 
        bar->priv = GVC_LEVEL_BAR_GET_PRIVATE (bar);
716
 
 
717
 
        bar->priv->peak_adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0,
718
 
                                                                         0.0,
719
 
                                                                         1.0,
720
 
                                                                         0.05,
721
 
                                                                         0.1,
722
 
                                                                         0.1));
723
 
        g_object_ref_sink (bar->priv->peak_adjustment);
724
 
        g_signal_connect (bar->priv->peak_adjustment,
725
 
                          "value-changed",
726
 
                          G_CALLBACK (on_peak_adjustment_value_changed),
727
 
                          bar);
728
 
 
729
 
        bar->priv->rms_adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0,
730
 
                                                                        0.0,
731
 
                                                                        1.0,
732
 
                                                                        0.05,
733
 
                                                                        0.1,
734
 
                                                                        0.1));
735
 
        g_object_ref_sink (bar->priv->rms_adjustment);
736
 
        g_signal_connect (bar->priv->rms_adjustment,
737
 
                          "value-changed",
738
 
                          G_CALLBACK (on_rms_adjustment_value_changed),
739
 
                          bar);
740
 
 
741
 
        gtk_widget_set_has_window (GTK_WIDGET (bar), FALSE);
742
 
}
743
 
 
744
 
static void
745
 
gvc_level_bar_finalize (GObject *object)
746
 
{
747
 
        GvcLevelBar *bar;
748
 
 
749
 
        g_return_if_fail (object != NULL);
750
 
        g_return_if_fail (GVC_IS_LEVEL_BAR (object));
751
 
 
752
 
        bar = GVC_LEVEL_BAR (object);
753
 
 
754
 
        if (bar->priv->max_peak_id > 0) {
755
 
                g_source_remove (bar->priv->max_peak_id);
756
 
        }
757
 
 
758
 
        g_return_if_fail (bar->priv != NULL);
759
 
 
760
 
        G_OBJECT_CLASS (gvc_level_bar_parent_class)->finalize (object);
761
 
}
762
 
 
763
 
GtkWidget *
764
 
gvc_level_bar_new (void)
765
 
{
766
 
        GObject *bar;
767
 
        bar = g_object_new (GVC_TYPE_LEVEL_BAR,
768
 
                            NULL);
769
 
        return GTK_WIDGET (bar);
770
 
}