← Back to branch summary

~ubuntu-branches/ubuntu/edgy/gnome-media/edgy

« back to all changes in this revision

Viewing changes to vu-meter/gtkledbar.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2005-09-05 01:34:20 UTC
  • Revision ID: james.westby@ubuntu.com-20050905013420-p3wd1q9kmdh3tic2
Tags: 2.12.O-0ubuntu1
New upstream version.

Show diffs side-by-side

added added

removed removed

Lines of Context:
vu-meter/gtkledbar.c
 
1
/*
 
2
 * $Id: gtkledbar.c,v 1.7 2005/06/13 09:38:44 rburton Exp $
 
3
 * GTKEXT - Extensions to The GIMP Toolkit
 
4
 * Copyright (C) 1998 Gregory McLean
 
5
 *
 
6
 * This library is free software; you can redistribute it and/or
 
7
 * modify it under the terms of the GNU Library General Public
 
8
 * License as published by the Free Software Foundation; either
 
9
 * version 2 of the License, or (at your option) any later version.
 
10
 *
 
11
 * This library is distributed in the hope that it will be useful,
 
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
 * Library General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU Library General Public
 
17
 * License along with this library; if not, write to the Free
 
18
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Cambridge, MA 
 
19
 * 02139, USA.
 
20
 *
 
21
 * Eye candy!
 
22
 */
 
23
 
 
24
#ifdef HAVE_CONFIG_H
 
25
#include <config.h>
 
26
#endif
 
27
 
 
28
#include <glib-object.h>
 
29
#include <gtk/gtktable.h>
 
30
 
 
31
#include "gtkledbar.h"
 
32
 
 
33
G_DEFINE_TYPE (LedBar, led_bar, GTK_TYPE_VBOX);
 
34
 
 
35
static void
 
36
led_bar_class_init (LedBarClass *class)
 
37
{
 
38
}
 
39
 
 
40
static void
 
41
led_bar_init (LedBar *led_bar)
 
42
{
 
43
        led_bar->num_segments = 0;
 
44
        led_bar->lit_segments = 0;
 
45
        led_bar->seq_segment  = 0;
 
46
        led_bar->seq_dir      = 1;
 
47
}
 
48
 
 
49
GtkWidget *
 
50
led_bar_new (gint segments, gint orientation )
 
51
{
 
52
        LedBar    *led_bar;
 
53
        GtkWidget *table;
 
54
        gint      i;
 
55
        GdkColor  active;
 
56
        GdkColor  inactive;
 
57
        gint      half, full;
 
58
        
 
59
        led_bar = gtk_type_new (led_bar_get_type ());
 
60
        if (segments > MAX_SEGMENTS) {
 
61
                segments = MAX_SEGMENTS;
 
62
        }
 
63
 
 
64
        led_bar->num_segments = segments;
 
65
        led_bar->orientation = orientation;
 
66
 
 
67
        if ( !orientation ) {/* horiz */
 
68
                table = gtk_table_new (1, segments, FALSE);
 
69
        } else { /* vert */
 
70
                table = gtk_table_new (segments, 1, FALSE);
 
71
        }
 
72
 
 
73
        gtk_container_add (GTK_CONTAINER (led_bar), table);
 
74
        gtk_widget_show (table);
 
75
 
 
76
        half = .50 * segments;
 
77
        full = .75 * segments;
 
78
 
 
79
        gdk_color_parse ("#00F100", &active);
 
80
        gdk_color_parse ("#008C00", &inactive);
 
81
 
 
82
        for (i = 0; i < segments; i++) {
 
83
                if (i >= half && i <= full) {
 
84
                        gdk_color_parse ("#F1EE00", &active);
 
85
                        gdk_color_parse ("#8CAA00", &inactive);
 
86
                } else {
 
87
                        if (i >= full) {
 
88
                                gdk_color_parse ("#F10000", &active);
 
89
                                gdk_color_parse ("#8C0000", &inactive);
 
90
                        }
 
91
                }                       
 
92
 
 
93
                led_bar->segments[i] = gtk_led_new ();
 
94
                gtk_led_set_colors (GTK_LED (led_bar->segments[i]), &active, &inactive);
 
95
                
 
96
                if ( !orientation ) {/* horiz */
 
97
                        gtk_table_attach (GTK_TABLE (table), led_bar->segments[i],
 
98
                                          i, (i + 1), 0, 1, 0, 0, 0, 0);
 
99
                } else { /* vert */
 
100
                        gtk_table_attach (GTK_TABLE (table), led_bar->segments[i],
 
101
                                          0, 1, (segments - i - 1), (segments - i),
 
102
                                          0, 0, 0, 0 );
 
103
                }
 
104
                
 
105
                gtk_widget_show (led_bar->segments[i]);
 
106
        }
 
107
        
 
108
        return GTK_WIDGET (led_bar);
 
109
}
 
110
 
 
111
gint
 
112
led_bar_get_num_segments (GtkWidget *bar)
 
113
{
 
114
        g_return_val_if_fail (IS_LEDBAR (bar), 0);
 
115
        
 
116
        return LEDBAR (bar)->num_segments;
 
117
}
 
118
 
 
119
void
 
120
led_bar_light_segments (GtkWidget *bar, 
 
121
                        gint num)
 
122
{
 
123
        LedBar    *led_bar;
 
124
        int       i;
 
125
        
 
126
        g_return_if_fail (IS_LEDBAR (bar));
 
127
        
 
128
        led_bar = LEDBAR (bar);
 
129
        if (num == 0 && led_bar->lit_segments == 0) {
 
130
                return;
 
131
        }
 
132
 
 
133
        if (num < led_bar->lit_segments) {
 
134
                for (i = 0; i < num; i++) {
 
135
                        gtk_led_set_state (GTK_LED (led_bar->segments[i]), 
 
136
                                           GTK_STATE_SELECTED,
 
137
                                           TRUE);
 
138
                }
 
139
        } else {
 
140
                for (i = led_bar->lit_segments; i < num; i++)
 
141
                        gtk_led_set_state (GTK_LED (led_bar->segments[i]),
 
142
                                           GTK_STATE_SELECTED, TRUE);
 
143
        }
 
144
 
 
145
        led_bar->lit_segments = i;
 
146
}
 
147
 
 
148
void 
 
149
led_bar_unlight_segments (GtkWidget *bar, 
 
150
                          gint num)
 
151
{
 
152
        LedBar    *led_bar;
 
153
        int       i;
 
154
        
 
155
        g_return_if_fail (IS_LEDBAR (bar));
 
156
        
 
157
        led_bar = LEDBAR (bar);
 
158
        if (led_bar->lit_segments == 0) {
 
159
                return;
 
160
        }
 
161
 
 
162
        for (i = 0; i < num; i++) {
 
163
                gtk_led_set_state (GTK_LED (led_bar->segments[i]),
 
164
                                   GTK_STATE_SELECTED, FALSE);
 
165
        }
 
166
 
 
167
        led_bar->lit_segments -= num;
 
168
 
 
169
        if (led_bar->lit_segments < 0) {
 
170
                led_bar->lit_segments = 0;
 
171
        }
 
172
}
 
173
 
 
174
void 
 
175
led_bar_light_segment (GtkWidget *bar, 
 
176
                       gint segment)
 
177
{
 
178
        LedBar     *led_bar;
 
179
 
 
180
        g_return_if_fail (IS_LEDBAR (bar));
 
181
        
 
182
        led_bar = LEDBAR (bar);
 
183
        gtk_led_set_state (GTK_LED (led_bar->segments[segment]),
 
184
                           GTK_STATE_SELECTED, TRUE);
 
185
}
 
186
 
 
187
void
 
188
led_bar_unlight_segment (GtkWidget *bar, 
 
189
                         gint segment)
 
190
{
 
191
        LedBar     *led_bar;
 
192
        
 
193
        g_return_if_fail (IS_LEDBAR (bar));
 
194
        
 
195
        led_bar = LEDBAR (bar);
 
196
        gtk_led_set_state (GTK_LED (led_bar->segments[segment]),
 
197
                           GTK_STATE_SELECTED, FALSE);
 
198
}
 
199
 
 
200
void
 
201
led_bar_light_percent (GtkWidget *bar, 
 
202
                       gfloat percent)
 
203
{
 
204
        LedBar     *led_bar;
 
205
        gint       num, i;
 
206
 
 
207
        g_return_if_fail (IS_LEDBAR (bar));
 
208
        
 
209
        led_bar = LEDBAR (bar);
 
210
        num = percent * led_bar->num_segments;
 
211
 
 
212
        led_bar->lit_segments = num;
 
213
        for (i = 0; i < led_bar->num_segments; i++) {
 
214
                if (num > 0 )  {
 
215
                        if (! (GTK_LED (led_bar->segments[i])->is_on)) {
 
216
                                gtk_led_set_state (GTK_LED (led_bar->segments[i]),
 
217
                                                   GTK_STATE_SELECTED, TRUE);
 
218
                        }
 
219
 
 
220
                        num--;
 
221
                } else {
 
222
                        if (GTK_LED (led_bar->segments[i])->is_on) {
 
223
                                gtk_led_set_state (GTK_LED (led_bar->segments[i]),
 
224
                                                   GTK_STATE_SELECTED, FALSE);
 
225
                        }
 
226
                }
 
227
        }
 
228
}
 
229
 
 
230
void
 
231
led_bar_clear (GtkWidget *bar)
 
232
{
 
233
        LedBar     *led_bar;
 
234
        int        i;
 
235
        
 
236
        g_return_if_fail (IS_LEDBAR (bar));
 
237
        
 
238
        led_bar = LEDBAR (bar);
 
239
        for (i = 0; i < led_bar->num_segments; i++) 
 
240
        {
 
241
                if (GTK_LED (led_bar->segments[i])->is_on) {
 
242
                        gtk_led_set_state (GTK_LED (led_bar->segments[i]),
 
243
                                           GTK_STATE_SELECTED, FALSE);
 
244
                }
 
245
        }
 
246
}
 
247
 
 
248
void
 
249
led_bar_sequence_step (GtkWidget *bar)
 
250
{
 
251
        LedBar    *led_bar;
 
252
        
 
253
        g_return_if_fail (IS_LEDBAR (bar));
 
254
        
 
255
        led_bar = LEDBAR (bar);
 
256
 
 
257
        if (led_bar->seq_segment >= (led_bar->num_segments - 1)) {
 
258
                led_bar->seq_dir = -1;
 
259
        } else if (led_bar->seq_segment <= 0) {
 
260
                led_bar->seq_dir = 1;
 
261
        }
 
262
 
 
263
        led_bar_unlight_segment (GTK_WIDGET(led_bar), led_bar->seq_segment);
 
264
        led_bar->seq_segment += led_bar->seq_dir;
 
265
        led_bar_light_segment (GTK_WIDGET(led_bar), led_bar->seq_segment);
 
266
}
 
267
 
 
268
/* EOF */
 
269
 
 
270
 
 
271