← Back to branch summary

~ubuntu-branches/ubuntu/precise/gnomeradio/precise-updates

« back to all changes in this revision

Viewing changes to src/gui.c

  • Committer: Bazaar Package Importer
  • Author(s): Francesco Namuri
  • Date: 2008-05-12 00:36:27 UTC
  • mfrom: (2.1.5 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080512003627-m4r405wwqc2e3xgv
Tags: 1.7-6
http://bugs.debian.org/468796
http://bugs.debian.org/462891
* debian/changelog: sync with the one from ubuntu.
* debian/patches/prefs.c.patch: fixed. In 1.7-6 I've uploaded a wrong
  version of the patch, now it's the right one that Cesare Tirabassi
  has included in the ubuntu's package. (Closes: #468796, #462891)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gui.c
25
25
#include <gconf/gconf-client.h>
26
26
#include <math.h>
27
27
#include "eggtrayicon.h"
 
28
#include "bacon-volume.h"
28
29
#include "gui.h"
 
30
#include "trayicon.h"
29
31
#include "tech.h"
30
32
#include "rec_tech.h"
31
33
#include "lirc.h"
32
34
#include "prefs.h"
33
35
#include "record.h"
34
 
#include "../pixmaps/digits.xpm"
35
 
#include "../pixmaps/signal.xpm"
36
 
#include "../pixmaps/stereo.xpm"
37
 
#include "../pixmaps/vol_up.xpm"
38
 
#include "../pixmaps/vol_down.xpm"
39
 
#include "../pixmaps/freq_up.xpm"
40
 
#include "../pixmaps/freq_down.xpm"
41
 
#include "../pixmaps/radio.xpm"
 
36
#include "../data/pixmaps/digits.xpm"
 
37
#include "../data/pixmaps/signal.xpm"
 
38
#include "../data/pixmaps/stereo.xpm"
 
39
#include "../data/pixmaps/freq_up.xpm"
 
40
#include "../data/pixmaps/freq_down.xpm"
42
41
 
43
42
#define DIGIT_WIDTH 20
44
43
#define DIGIT_HEIGTH 30
50
49
 
51
50
static GtkWidget *drawing_area;
52
51
static GdkPixmap *digits, *signal_s, *stereo;
53
 
static GtkWidget *freq_scale, *vol_scale;
54
 
static GtkWidget *tray_icon;
 
52
static GtkWidget *freq_scale;
 
53
static GtkWidget *rec_pixmap;
55
54
 
56
55
static int timeout_id, bp_timeout_id = -1, bp_timeout_steps = 0;
57
56
 
58
 
void start_radio(gboolean restart)
 
57
static gboolean is_first_start(void)
 
58
{
 
59
        GConfClient *client = gconf_client_get_default();
 
60
        if (!client)
 
61
                return TRUE;
 
62
 
 
63
        return !gconf_client_get_bool(client, "/apps/gnomeradio/first_time_flag", NULL);
 
64
}
 
65
 
 
66
static void set_first_time_flag(void)
 
67
{
 
68
        GConfClient *client = gconf_client_get_default();
 
69
        if (!client)
 
70
                return;
 
71
 
 
72
        gconf_client_set_bool(client, "/apps/gnomeradio/first_time_flag", TRUE, NULL);
 
73
}
 
74
 
 
75
typedef struct {
 
76
        GtkWidget *dialog;
 
77
        GtkWidget *progress;
 
78
        GList *stations;
 
79
        GtkWidget *label;
 
80
} FreqScanData;
 
81
 
 
82
static gboolean initial_frequency_scan_cb(gpointer data)
 
83
{
 
84
        static gfloat freq = FREQ_MIN - 4.0f/STEPS;
 
85
        FreqScanData *fsd = data;
 
86
        
 
87
        g_assert(fsd);
 
88
        
 
89
        if (freq > FREQ_MAX) {
 
90
                gtk_widget_destroy(fsd->dialog);
 
91
                timeout_id = 0;
 
92
                return FALSE;
 
93
        }
 
94
        
 
95
        if (radio_check_station(freq)) {
 
96
                char *text = g_strdup_printf(_("%d stations found"), g_list_length(fsd->stations) + 1);
 
97
                gfloat *f = g_malloc(sizeof(gfloat));
 
98
                gtk_label_set_text(GTK_LABEL(fsd->label), text);
 
99
                g_free(text);
 
100
                
 
101
                g_print("%.2f is a station\n", freq);
 
102
                
 
103
                *f = freq;
 
104
                fsd->stations = g_list_append(fsd->stations, f);
 
105
        }
 
106
 
 
107
        gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(fsd->progress), MAX(0, (freq - FREQ_MIN)/(FREQ_MAX - FREQ_MIN)));        
 
108
        
 
109
        freq += 1.0/STEPS;
 
110
        radio_setfreq(freq);
 
111
        
 
112
        return TRUE;
 
113
}
 
114
 
 
115
static void initial_frequency_scan(GtkWidget *app)
 
116
{
 
117
        FreqScanData data;
 
118
        GtkWidget *title;
 
119
        char *title_hdr;
 
120
        
 
121
        data.stations = NULL;
 
122
        
 
123
        data.dialog = gtk_dialog_new_with_buttons(_("Scanning"),
 
124
                GTK_WINDOW(app), DIALOG_FLAGS, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
 
125
        gtk_dialog_set_has_separator(GTK_DIALOG(data.dialog), FALSE);
 
126
        gtk_window_set_resizable(GTK_WINDOW(data.dialog), FALSE);
 
127
        
 
128
        title_hdr = g_strconcat("<span weight=\"bold\">", _("Scanning for available stations:"), "</span>", NULL);
 
129
        title = gtk_label_new(title_hdr);
 
130
        gtk_misc_set_alignment(GTK_MISC(title), 0, 0.5);
 
131
        gtk_label_set_use_markup(GTK_LABEL(title), TRUE);
 
132
        g_free(title_hdr);
 
133
        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(data.dialog)->vbox), title, FALSE, FALSE, 6);
 
134
        
 
135
        data.progress = gtk_progress_bar_new();
 
136
        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(data.dialog)->vbox), data.progress, TRUE, FALSE, 6);
 
137
        
 
138
        data.label = gtk_label_new(_("No stations found"));
 
139
        gtk_misc_set_alignment(GTK_MISC(data.label), 0, 0.5);
 
140
        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(data.dialog)->vbox), data.label, TRUE, FALSE, 6);
 
141
        
 
142
        gtk_widget_show_all(data.dialog);
 
143
        
 
144
        radio_mute();
 
145
        timeout_id = g_timeout_add(1000/SCAN_SPEED, (GSourceFunc)initial_frequency_scan_cb, (gpointer)&data);   
 
146
        int response = gtk_dialog_run(GTK_DIALOG(data.dialog));
 
147
 
 
148
        radio_unmute();
 
149
        if (timeout_id) {
 
150
                g_source_remove(timeout_id);
 
151
                timeout_id = 0;
 
152
                gtk_widget_destroy(data.dialog);
 
153
        } else {
 
154
                if (g_list_length(data.stations) > 0) {
 
155
                        gfloat f = *((gfloat*)data.stations->data);
 
156
                        adj->value = f*STEPS;
 
157
                        radio_setfreq(f);
 
158
                        
 
159
                        GtkWidget *dialog;
 
160
                        GList *ptr;
 
161
                        char *text;
 
162
                        
 
163
                        text = g_strdup_printf(_("%d stations found. \nDo you want to add them as presets?\n"),
 
164
                                        g_list_length(data.stations));
 
165
                        
 
166
                        dialog = gtk_message_dialog_new(GTK_WINDOW(app), DIALOG_FLAGS, GTK_MESSAGE_QUESTION,
 
167
                                        GTK_BUTTONS_YES_NO, text);
 
168
                        g_free(text);
 
169
                        
 
170
                        int response = gtk_dialog_run(GTK_DIALOG(dialog));
 
171
                        gtk_widget_destroy(dialog);
 
172
 
 
173
                        for (ptr = data.stations; ptr; ptr = ptr->next) {
 
174
                                if (response == GTK_RESPONSE_YES) {
 
175
                                        preset *ps = g_malloc0(sizeof(preset));
 
176
                                        ps->title = g_strdup(_("unnamed"));
 
177
                                        ps->freq = *((gfloat*)ptr->data);
 
178
                                        settings.presets = g_list_append(settings.presets, ps);
 
179
                                }
 
180
                                g_free(ptr->data);
 
181
                        }       
 
182
                }
 
183
        }       
 
184
}       
 
185
 
 
186
static void prefs_button_clicked_cb(GtkButton *button, gpointer app)
 
187
{
 
188
        GtkWidget* dialog;
 
189
        gint choise;
 
190
        
 
191
        dialog = prefs_window(app);
 
192
        
 
193
        /* Michael Jochum <e9725005@stud3.tuwien.ac.at> proposed to not use gnome_dialog_set_parent()
 
194
           but following instead. */
 
195
        gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(app));
 
196
        gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
 
197
        
 
198
        /*gnome_dialog_set_parent(GNOME_DIALOG(dialog), GTK_WINDOW(app));*/
 
199
        
 
200
        choise = GTK_RESPONSE_HELP;
 
201
        while (choise == GTK_RESPONSE_HELP)
 
202
        {
 
203
                choise = gtk_dialog_run(GTK_DIALOG(dialog)); 
 
204
                switch (choise)
 
205
                {
 
206
                        case GTK_RESPONSE_HELP:
 
207
                                display_help_cb("gnomeradio-settings");
 
208
                        break;
 
209
                        default:
 
210
                                /* We need the hide signal to get the value of the device_entry */
 
211
                                gtk_widget_hide_all(dialog);
 
212
                                gtk_widget_destroy(dialog);
 
213
                }
 
214
        }
 
215
}
 
216
 
 
217
void start_radio(gboolean restart, GtkWidget *app)
59
218
{
60
219
        if (restart)
61
220
                radio_stop();
62
221
        
63
222
        if (!radio_init(settings.device)) 
64
223
        {
65
 
                GtkWidget *dialog;
 
224
                char *caption = g_strdup_printf(_("Could not open device \"%s\"!"), settings.device);
 
225
                char *detail = g_strdup_printf(_("Check your settings and make sure that no other\n"
 
226
                                "program is using %s.\nAlso make sure that you have read-access to it."), settings.device);
 
227
                show_error_message(caption, detail);
 
228
                g_free(caption);
 
229
                g_free(detail);
66
230
                
67
 
                dialog = gtk_message_dialog_new(NULL, DIALOG_FLAGS, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
68
 
                                _("Could not open device \"%s\" !\n\nCheck your Settings and make sure that no other\n"
69
 
                                "program is using %s.\nMake also sure that you have read-access to it."), 
70
 
                                settings.device, settings.device);
71
 
                gtk_dialog_run (GTK_DIALOG (dialog));
72
 
                gtk_widget_destroy (dialog);
73
 
        }               
 
231
                if (!restart)
 
232
                        prefs_button_clicked_cb(NULL, app);
 
233
        }
74
234
}
75
235
 
76
 
void start_mixer(gboolean restart)
 
236
void start_mixer(gboolean restart, GtkWidget *app)
77
237
{
78
238
        gint res, vol;
79
239
        
83
243
        res = mixer_init(settings.mixer_dev, settings.mixer);
84
244
        if (res <1) 
85
245
        {
86
 
                GtkWidget *dialog;
87
246
                char *buffer;
88
247
                
89
248
                if (res == -1)
90
249
                        buffer = g_strdup_printf(_("Mixer source \"%s\" is not a valid source!"), settings.mixer);
91
250
                else 
92
251
                        buffer = g_strdup_printf(_("Could not open \"%s\"!"), settings.mixer_dev);
93
 
 
94
 
                dialog = gtk_message_dialog_new(NULL, DIALOG_FLAGS, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, buffer);
95
 
                gtk_dialog_run (GTK_DIALOG (dialog));
96
 
                gtk_widget_destroy (dialog);
 
252
                
 
253
                show_error_message(buffer, NULL);
97
254
                
98
255
                g_free(buffer);
99
256
        }               
100
257
        vol = mixer_get_volume();
101
 
        
102
 
        if (vol >= 0)
103
 
                gtk_adjustment_set_value(volume, (double)vol);
 
258
        if (vol >= 0) {
 
259
                bacon_volume_button_set_value(BACON_VOLUME_BUTTON(mute_button), vol);
 
260
                /*gtk_adjustment_set_value(volume, (double)vol);*/
 
261
        }
104
262
}
105
263
 
106
264
GList* get_mixer_recdev_list(void)
107
265
{
108
266
        int i;
109
267
        char **array, *dev;
110
 
        char *gconf_path = NULL, *sndcard_name = NULL;
111
268
        GList *result = NULL;
112
 
        GConfClient *client = NULL;
113
269
        
114
270
        array = mixer_get_rec_devices();
115
271
        if (!array)
116
272
                return NULL;
117
 
 
118
 
        if (!gconf_is_initialized())
119
 
                return NULL;
120
 
        
121
 
        client = gconf_client_get_default();
122
 
        
123
 
        sndcard_name = mixer_get_sndcard_name();
124
 
        if (sndcard_name)
125
 
        {
126
 
                g_strdelimit (sndcard_name, " ", '_');
127
 
                gconf_path = g_strdup_printf("/apps/gnome-volume-control/OSS-%s-%d/%%s/title", sndcard_name, 1);
128
 
                //puts(gconf_path);
129
 
                free(sndcard_name);
130
 
        }
131
273
        
132
274
        i = 0;  
133
275
        dev = array[i];
134
276
        while (dev)
135
277
        {
136
 
                char *gconf_dev = NULL;
137
 
                char *text = NULL;
138
 
                
139
 
                if (client && gconf_path)
140
 
                {
141
 
                        char *path = g_strdup_printf(gconf_path, dev);
142
 
                        gconf_dev = gconf_client_get_string(client, path , NULL);
143
 
                        g_free(path);
144
 
                }
145
 
                if (gconf_dev)
146
 
                {
147
 
                        if (strcmp(gconf_dev, dev))
148
 
                                text = g_strdup_printf("%s (%s)", dev, gconf_dev);
149
 
                        else
150
 
                                text = g_strdup(dev);
151
 
                        g_free(gconf_dev);
152
 
                        gconf_dev = NULL;
153
 
                }
154
 
                else
155
 
                        text = g_strdup(dev);
 
278
                char *text = g_strdup(dev);
156
279
                result = g_list_append(result, text);
157
280
                free(dev);
158
281
                dev = array[++i];
159
282
        }                       
160
283
        free(array);
161
 
        g_free(gconf_path);
162
284
        
163
285
        return result;
164
286
}
165
287
 
166
 
static gboolean
167
 
redraw_status_window(void)
 
288
static gboolean redraw_status_window(void)
168
289
{
169
290
 
170
291
        GdkWindow *real_window, *window;
172
293
        int win_width, win_height;
173
294
        int val, freq[5], signal_strength, is_stereo;
174
295
        
175
 
        val = (int)(rint(adj->value)/STEPS * 100.0);
 
296
        val = (int)(rint(adj->value/STEPS * 100.0));
176
297
        
177
298
        freq[0] = val / 10000;
178
299
        freq[1] = (val % 10000) / 1000;
188
309
        is_stereo = (is_stereo == 1) ? 1 : 0;
189
310
        
190
311
        real_window = drawing_area->window;
 
312
        if (real_window == NULL)
 
313
                /* UI has not been realized yet */
 
314
                return TRUE;
191
315
        gc = gdk_gc_new(real_window);
192
316
        gdk_drawable_get_size(real_window, &win_width, &win_height);
193
317
        
219
343
}
220
344
        
221
345
 
222
 
static gboolean
223
 
expose_event_cb(GtkWidget *widget, GdkEventExpose *event, gpointer data)
 
346
static gboolean expose_event_cb(GtkWidget *widget, GdkEventExpose *event, gpointer data)
224
347
{
225
348
        redraw_status_window();
226
349
        return TRUE;
238
361
        gtk_main_quit();
239
362
}
240
363
 
 
364
const char* get_preset(float freq, int *num)
 
365
{
 
366
        GList *node = settings.presets;
 
367
 
 
368
        int i = *num = -1;
 
369
        for (;node;)
 
370
        {
 
371
                ++i;
 
372
                preset *ps = (preset*)node->data;
 
373
                if (fabs(ps->freq - freq) < 0.01)
 
374
                {
 
375
                        *num = i;
 
376
                        return ps->title;
 
377
                }
 
378
                node = node->next;
 
379
        }
 
380
        return NULL;
 
381
}
 
382
 
241
383
static void adj_value_changed_cb(GtkAdjustment* data, gpointer window)
242
384
{
243
 
        gchar *buffer;
 
385
        char *buffer;
 
386
        float freq = rint(adj->value)/STEPS;
 
387
        const char *preset_title = get_preset(freq, &mom_ps);
 
388
 
 
389
        preset_combo_set_item(mom_ps);
244
390
        
245
391
        redraw_status_window();
246
392
        
247
 
        buffer = g_strdup_printf(_("Gnomeradio - %.2f MHz"), rint(adj->value)/STEPS);
248
 
        gtk_window_set_title (GTK_WINDOW(window), buffer);
 
393
        if (preset_title)
 
394
                buffer = g_strdup_printf(_("Gnomeradio - %s"), preset_title);
 
395
        else
 
396
                buffer = g_strdup_printf(_("Gnomeradio - %.2f MHz"), freq);
 
397
        gtk_window_set_title(GTK_WINDOW(window), buffer);
 
398
        if (tray_icon) gtk_tooltips_set_tip(tooltips, tray_icon, buffer, NULL);
249
399
        g_free(buffer);
250
400
        
251
 
        buffer = g_strdup_printf(_("Frequency: %.2f MHz"), rint(adj->value)/STEPS);
 
401
        buffer = g_strdup_printf(_("Frequency: %.2f MHz"), freq);
252
402
        gtk_tooltips_set_tip(tooltips, freq_scale, buffer, NULL);
253
403
        g_free(buffer);
254
 
        
255
 
        buffer = g_strdup_printf(_("Gnomeradio - %.2f MHz"), rint(adj->value)/STEPS);
256
 
        gtk_tooltips_set_tip(tooltips, tray_icon, buffer, NULL);
257
 
        g_free(buffer);
258
404
 
259
405
        radio_setfreq(adj->value/STEPS);
260
406
}
261
407
 
262
 
static gboolean freq_scale_focus_cb(GtkWidget *widget, GdkEventFocus *event, gpointer data)
263
 
{
264
 
        mom_ps = -1;
265
 
        preset_combo_set_item(mom_ps);
266
 
        return FALSE;
267
 
}
268
 
 
269
 
static void volume_value_changed_cb(GtkAdjustment* data, gpointer window)
 
408
static void volume_value_changed_cb(BaconVolumeButton *button, gpointer user_data)
270
409
{
271
410
        char *text;
272
 
        
273
 
        mixer_set_volume((gint)volume->value);
274
 
        
275
 
        text = g_strdup_printf(_("Volume: %d%%"), (gint)volume->value);
 
411
        int vol = (int)(bacon_volume_button_get_value(BACON_VOLUME_BUTTON(mute_button)) + 0.5f);
 
412
        
 
413
        mixer_set_volume(vol);
 
414
        
 
415
/*      text = g_strdup_printf(_("Volume: %d%%"), vol);
276
416
        gtk_tooltips_set_tip(tooltips, vol_scale, text, NULL);
277
 
        g_free(text);
278
 
 
 
417
        g_free(text);*/
 
418
        
 
419
        g_assert(tray_menu);
 
420
        g_signal_handler_block(G_OBJECT(mute_menuitem), mute_menuitem_toggled_cb_id);
 
421
        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mute_menuitem), vol == 0);
 
422
        g_signal_handler_unblock(G_OBJECT(mute_menuitem), mute_menuitem_toggled_cb_id);
279
423
}
280
424
 
281
425
#if 0
295
439
}
296
440
#endif
297
441
 
298
 
static void
299
 
change_frequency(gpointer data)
 
442
static void change_frequency(gpointer data)
300
443
{
301
444
        gboolean increase = (gboolean)data;
302
445
        
316
459
        }
317
460
}
318
461
 
319
 
static gboolean
320
 
change_frequency_timeout(gpointer data)
 
462
static gboolean change_frequency_timeout(gpointer data)
321
463
{
322
464
        change_frequency(data);
323
465
        if (bp_timeout_steps < 10)
324
466
        {
325
467
                gtk_timeout_remove(bp_timeout_id);
326
 
                //g_print("adding timeout with interval %d\n", 200 - 20*bp_timeout_steps);
327
468
                bp_timeout_id = gtk_timeout_add(200 - 20*bp_timeout_steps,
328
469
                        (GtkFunction)change_frequency_timeout, data);
329
470
                bp_timeout_steps++; 
333
474
 
334
475
static void step_button_pressed_cb(GtkButton *button, gpointer data)
335
476
{
336
 
        //change_frequency(data);
337
477
        bp_timeout_id = gtk_timeout_add(500, (GtkFunction)change_frequency_timeout, data);
338
 
        
339
 
        mom_ps = -1;
340
 
        preset_combo_set_item(mom_ps);
341
478
}
342
479
 
343
480
static void step_button_clicked_cb(GtkButton *button, gpointer data)
344
481
{
345
482
        change_frequency(data);
346
 
 
347
 
        mom_ps = -1;
348
 
        preset_combo_set_item(mom_ps);
349
483
}
350
484
 
351
485
static void step_button_released_cb(GtkButton *button, gpointer data)
356
490
        bp_timeout_steps = 0;
357
491
}
358
492
 
359
 
 
360
493
static gboolean scan_freq(gpointer data)
361
494
{
362
 
        static gint signal, a, b, c;    
363
495
        static gint start, mom, max;
364
496
        gint dir = (gint)(data);
365
497
        
366
 
        if (!max)
 
498
        if (!max) {
367
499
                max = (FREQ_MAX - FREQ_MIN) * STEPS;
368
 
 
369
 
        if ((a + b + c > 8) || (start > max))   
370
 
        {
371
 
                start = mom = a = b = c = 0;
 
500
        }       
 
501
                
 
502
        if (radio_check_station(adj->value/STEPS) || (start > max))     {
 
503
                start = mom = 0;
372
504
                radio_unmute();
373
505
                timeout_id = 0;
374
506
                return FALSE;
375
507
        }
376
 
        if (!mom)
377
 
        mom= adj->value;
 
508
        if (!mom) {
 
509
                mom = adj->value;
 
510
        }
 
511
                
378
512
        if (mom > FREQ_MAX*STEPS) 
379
513
                mom = FREQ_MIN*STEPS;
380
 
        else
381
 
        if (mom < FREQ_MIN*STEPS)
 
514
        else if (mom < FREQ_MIN*STEPS)
382
515
                mom = FREQ_MAX*STEPS;
383
516
        else    
384
517
                mom = mom + dir;
385
518
        start += 1;
386
519
        gtk_adjustment_set_value(adj, mom);
387
 
        signal = radio_getsignal();
388
 
        a = b;
389
 
        b = c;
390
 
        c = signal;
 
520
 
391
521
        return TRUE;
392
522
}
393
523
 
396
526
        if (timeout_id) {
397
527
                gtk_timeout_remove(timeout_id);
398
528
                timeout_id = 0;
 
529
                radio_unmute();
399
530
                return;
400
531
        }
401
532
        radio_mute();
402
533
        timeout_id = gtk_timeout_add(1000/SCAN_SPEED, (GtkFunction)scan_freq, (gpointer)1);     
403
 
        mom_ps = -1;
404
 
        preset_combo_set_item(mom_ps);
405
 
 
406
534
}
407
535
 
408
536
void scbw_button_clicked_cb(GtkButton *button, gpointer data)
410
538
        if (timeout_id) {
411
539
                gtk_timeout_remove(timeout_id);
412
540
                timeout_id = 0;
 
541
                radio_unmute();
413
542
                return;
414
543
        }
415
544
        radio_mute();
416
545
        timeout_id = gtk_timeout_add(1000/SCAN_SPEED, (GtkFunction)scan_freq, (gpointer)(-1));  
417
 
        mom_ps = -1;
418
 
        preset_combo_set_item(mom_ps);
419
546
}
420
547
 
421
548
void preset_combo_set_item(gint i)
422
549
{
423
550
        if (i < -1) return;
 
551
        if (preset_combo == NULL) return;
424
552
        gtk_combo_box_set_active(GTK_COMBO_BOX(preset_combo), i + 1);
425
553
}
426
554
 
435
563
        gtk_adjustment_set_value(adj, ps->freq * STEPS);
436
564
}
437
565
 
438
 
/*static void update_preset_menu(void)
439
 
{
440
 
        gint i, count;
441
 
        GtkWidget *item;
442
 
        preset *ps;
443
 
        
444
 
        if (menu)
445
 
                gtk_widget_destroy(menu);
446
 
        menu = gtk_menu_new();
447
 
        
448
 
        count = g_list_length(settings.presets);
449
 
        
450
 
        item = gtk_menu_item_new_with_label(_("manual"));
451
 
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
452
 
        
453
 
        for (i=0;i<count;i++)
454
 
        {
455
 
                ps = g_list_nth_data(settings.presets, i);
456
 
                item = gtk_menu_item_new_with_label(ps->title);
457
 
                g_signal_connect(GTK_OBJECT(item), "activate", GTK_SIGNAL_FUNC(pref_item_activate_cb), (gpointer)i);
458
 
                gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
459
 
        }
460
 
        gtk_widget_show_all(menu);
461
 
        gtk_option_menu_set_menu(GTK_OPTION_MENU(preset_menu), menu);
462
 
}*/
463
 
 
464
 
void
465
 
change_preset(gboolean next)
 
566
void change_preset(gboolean next)
466
567
{
467
568
        preset *ps;
468
569
        int len = g_list_length(settings.presets);
484
585
        exit_gnome_radio();
485
586
}
486
587
 
487
 
static void prefs_button_clicked_cb(GtkButton *button, gpointer app)
 
588
void tray_icon_items_set_sensible(gboolean sensible)
488
589
{
489
 
        GtkWidget* dialog;
490
 
        gint choise;
491
 
        
492
 
        dialog = prefs_window();
493
 
        
494
 
        /* Michael Jochum <e9725005@stud3.tuwien.ac.at> proposed to not use gnome_dialog_set_parent()
495
 
           but following instead. */
496
 
        gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(app));
497
 
        gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
498
 
        
499
 
        /*gnome_dialog_set_parent(GNOME_DIALOG(dialog), GTK_WINDOW(app));*/
500
 
        
501
 
        choise = GTK_RESPONSE_HELP;
502
 
        while (choise == GTK_RESPONSE_HELP)
503
 
        {
504
 
                choise = gtk_dialog_run(GTK_DIALOG(dialog)); 
505
 
                switch (choise)
506
 
                {
507
 
                        case GTK_RESPONSE_HELP:
508
 
                                display_help_cb("gnomeradio-settings");
509
 
                        break;
510
 
                        default:
511
 
                                /* We need the hide signal to get the value of the device_entry */
512
 
                                gtk_widget_hide_all(dialog);
513
 
                                gtk_widget_destroy(dialog);
514
 
                }
515
 
        }
 
590
        GList* menuitems;
 
591
        GtkWidget *menuitem;
 
592
        int i, cnt = g_list_length(settings.presets);
 
593
        
 
594
        
 
595
        menuitems = GTK_MENU_SHELL(tray_menu)->children;
 
596
        
 
597
        g_assert(cnt + 6 == g_list_length(menuitems));
 
598
        
 
599
        /* Disable the presets */
 
600
        for (i = 0; i < cnt; i++) {
 
601
                menuitem = g_list_nth_data(menuitems, i);
 
602
                gtk_widget_set_sensitive(menuitem, sensible);
 
603
        }       
 
604
        
 
605
        /* Disable the mute button (separator => +1) */
 
606
        menuitem = g_list_nth_data(menuitems, cnt + 1);
 
607
        gtk_widget_set_sensitive(menuitem, sensible);
 
608
 
 
609
        /* Disable the record button */
 
610
        menuitem = g_list_nth_data(menuitems, cnt + 2);
 
611
        gtk_widget_set_sensitive(menuitem, sensible);
 
612
        
 
613
        /* Disable the quit button */
 
614
        menuitem = g_list_nth_data(menuitems, cnt + 5);
 
615
        gtk_widget_set_sensitive(menuitem, sensible);
516
616
}
517
617
 
518
 
static int
519
 
start_recording(const gchar *filename)
 
618
static int start_recording(const gchar *destination, const char* station, const char* time)
520
619
{
521
 
        GIOChannel *wavioc = NULL, *mp3ioc = NULL;
522
620
        GtkWidget *dialog;
 
621
        Recording* recording;
 
622
        char *filename;
523
623
        
524
624
        if (!mixer_set_rec_device())
525
625
        {
531
631
                return -1;
532
632
        }
533
633
        
534
 
        if (rec_settings.mp3)
535
 
                record_as_mp3(&wavioc, &mp3ioc, filename);
536
 
        else    
537
 
                record_as_wave(&wavioc, filename);
538
 
 
539
 
        dialog = record_status_window();
540
 
        
541
 
        run_status_window(wavioc, mp3ioc, filename);
 
634
        /* You can translate the filename for a recording:
 
635
         * args for this format are: path, station title, time 
 
636
         */ 
 
637
        filename = g_strdup_printf(_("%s/%s_%s"), 
 
638
                destination, 
 
639
                station, 
 
640
                time);
 
641
        recording = recording_start(filename);
 
642
        g_free(filename);
 
643
        if (!recording)
 
644
                return -1;
 
645
        
 
646
        tray_icon_items_set_sensible(FALSE);
 
647
        
 
648
        recording->station = g_strdup(station);
 
649
        dialog = record_status_window(recording);
 
650
        
 
651
        run_status_window(recording);
542
652
 
543
653
        return 1;
544
654
}
545
655
 
546
 
static void rec_button_clicked_cb(GtkButton *button, gpointer app)
 
656
void rec_button_clicked_cb(GtkButton *button, gpointer app)
547
657
{
548
658
        GtkWidget *dialog;
549
 
        gchar *filename, *suffix;
 
659
        char *station;
550
660
        char time_str[100];
551
661
        time_t t;
552
662
        
553
 
        if (!check_sox_installation())
554
 
        {
555
 
                dialog = gtk_message_dialog_new(GTK_WINDOW(app), DIALOG_FLAGS, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
556
 
                                _("Sox could not be detected. Please ensure"
557
 
                                " that it is installed in your PATH."));
558
 
                gtk_dialog_run (GTK_DIALOG (dialog));
559
 
                gtk_widget_destroy (dialog);
560
 
                return;
561
 
        }
562
 
 
563
 
        if (rec_settings.mp3) {
564
 
                if (g_str_equal(rec_settings.encoder, "oggenc")) suffix = ".ogg";
565
 
                else suffix = ".mp3";
566
 
        } else suffix = ".wav";
567
 
        
568
663
        t = time(NULL);
569
664
        /* consult man strftime to translate this. This is a filename, so don't use "/" or ":", please */
570
665
        strftime(time_str, 100, _("%B-%d-%Y_%H-%M-%S"), localtime(&t));
571
666
        
572
 
        /* Only change the "MHz" part here (if applicable) */
573
 
        filename = g_strdup_printf(_("%s/%.2fMHz_%s%s"), 
574
 
                rec_settings.destination, 
575
 
                rint(adj->value)/STEPS, 
576
 
                time_str,
577
 
                suffix);
 
667
        if (mom_ps < 0) {
 
668
                station = g_strdup_printf(_("%.2f MHz"), rint(adj->value)/STEPS);
 
669
        } else {
 
670
                g_assert(mom_ps < g_list_length(settings.presets));
 
671
                preset* ps = g_list_nth_data(settings.presets, mom_ps);
 
672
                g_assert(ps);
578
673
        
579
 
        if (!check_filename(filename)) {
 
674
                station = g_strdup(ps->title);
 
675
        }       
 
676
                
 
677
/*      if (!check_filename(filename)) {
580
678
                GtkWidget *errdialog;
581
679
                errdialog = gtk_message_dialog_new(GTK_WINDOW(app), DIALOG_FLAGS, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
582
680
                                        _("Error opening file '%s':\n%s"), filename, strerror(errno));
583
681
                gtk_dialog_run (GTK_DIALOG (errdialog));
584
682
                gtk_widget_destroy (errdialog);
585
 
        } else start_recording(filename);
586
 
        g_free(filename);               
 
683
        } else */
 
684
        start_recording(rec_settings.destination, station, time_str);
 
685
        g_free(station);
587
686
}
588
687
 
589
 
void mute_button_toggled_cb(GtkButton *button, gpointer data)
 
688
void toggle_volume(void)
590
689
{
591
 
        static gboolean muted = FALSE;
 
690
        static int old_vol;
 
691
        int vol = mixer_get_volume();
592
692
        
593
 
        if (muted)
 
693
        if (vol) {
 
694
                old_vol = vol;
 
695
                vol = 0;
 
696
        } else {
 
697
                vol = old_vol;
 
698
        }       
 
699
        mixer_set_volume(vol);
 
700
        bacon_volume_button_set_value(BACON_VOLUME_BUTTON(mute_button), vol);
 
701
        /*gtk_adjustment_set_value(volume, vol);*/
 
702
}       
 
703
 
 
704
static void mute_button_toggled_cb(GtkButton *button, gpointer data)
 
705
{
 
706
        if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mute_button)))
 
707
        {               
 
708
                gtk_tooltips_set_tip(tooltips, mute_button, _("Unmute"), NULL);
 
709
        }
 
710
        else
594
711
        {
595
 
                radio_unmute();
596
 
                muted = FALSE;
597
712
                gtk_tooltips_set_tip(tooltips, mute_button, _("Mute"), NULL);
598
713
        }
599
 
        else
600
 
        {
601
 
                radio_mute();
602
 
                muted = TRUE;
603
 
                gtk_tooltips_set_tip(tooltips, mute_button, _("Unmute"), NULL);
604
 
        }
 
714
        toggle_volume();
605
715
}
606
716
 
607
717
static void about_button_clicked_cb(GtkButton *button, gpointer data)
608
718
{
609
719
        GdkPixbuf *app_icon;
 
720
        GtkIconTheme *icontheme;
610
721
        static GtkWidget *about;
611
722
        const char *authors[] = {"Jörgen Scheibengruber <mfcn@gmx.de>", NULL};
612
723
        char *text;
619
730
                gtk_window_present(GTK_WINDOW(about));
620
731
                return;
621
732
        }
622
 
 
623
 
        app_icon = gdk_pixbuf_new_from_xpm_data((const char**)radio_xpm);
 
733
        icontheme = gtk_icon_theme_get_default();
 
734
        app_icon = gtk_icon_theme_load_icon(icontheme, "gnomeradio", 48, 0, NULL);
624
735
 
625
736
#ifdef HAVE_LIRC        
626
737
        text =_("Gnomeradio is a FM-Tuner application for the GNOME desktop. "
632
743
                                                        "This version has been compiled without LIRC support.");
633
744
#endif
634
745
        
635
 
        about = gnome_about_new ("Gnomeradio", VERSION, "Copyright 2001 - 2003 Jörgen Scheibengruber",
 
746
        about = gnome_about_new ("Gnomeradio", VERSION, "Copyright 2001 - 2006 Jörgen Scheibengruber",
636
747
                                                        text, (const char **) authors, NULL, 
637
748
                                                        strcmp("TRANSLATORS", translators) ? translators : NULL, 
638
749
                                                        app_icon);
639
750
 
640
751
        gtk_widget_show(about);
641
752
        g_object_add_weak_pointer(G_OBJECT(about), (gpointer)&about);
 
753
        g_object_add_weak_pointer(G_OBJECT(about), (gpointer)&app_icon);
642
754
}
643
755
 
644
756
static gint delete_event_cb(GtkWidget* window, GdkEventAny* e, gpointer data)
664
776
        }
665
777
}
666
778
 
667
 
gboolean
668
 
tray_clicked(GtkWidget *widget, GdkEventButton *event, gpointer data)
 
779
void toggle_mainwindow_visibility(GtkWidget *app)
669
780
{
670
781
        static gint posx, posy;
671
 
        GtkWidget *app = GTK_WIDGET(data);
672
 
        switch (event->button)
673
 
        {
674
 
                case 1:
675
 
                        if (event->type != GDK_BUTTON_PRESS)
676
 
                                break;
677
 
                        if (GTK_WIDGET_VISIBLE(app))
678
 
                        {
679
 
                                gtk_window_get_position(GTK_WINDOW(app), &posx, &posy);
680
 
                                gtk_widget_hide(app);
681
 
                        }
682
 
                        else
683
 
                        {
684
 
                                if ((posx >= 0) && (posy >= 0))
685
 
                                        gtk_window_move(GTK_WINDOW(app), posx, posy);
686
 
                                gtk_window_present(GTK_WINDOW(app));
687
 
                        }
688
 
                        break;
689
 
                case 3:
690
 
                        if (event->type != GDK_BUTTON_PRESS)
691
 
                                break;
692
 
/*                      if (tray_menu_disabled)
693
 
                                break;
694
 
                        gtk_menu_popup(GTK_MENU(menu), NULL, NULL, 
695
 
                                NULL, NULL, event->button, event->time);*/
696
 
                        break;
697
 
        }                       
698
 
        return FALSE;
699
 
}       
700
 
 
701
 
gboolean
702
 
tray_destroyed (GtkWidget *widget, GdkEvent *event, gpointer data)
703
 
{
704
 
        create_tray_icon(GTK_WIDGET(data));
705
 
        return TRUE;
706
 
}
707
 
 
708
 
void create_tray_icon(GtkWidget *app)
709
 
{
710
 
        GdkPixbuf *pixbuf, *scaled;
711
 
        GtkWidget *tray_icon_image;
712
 
        GtkWidget *eventbox;
713
 
        char *text;
714
 
        
715
 
        tray_icon = GTK_WIDGET(egg_tray_icon_new (PACKAGE));
716
 
        pixbuf = gdk_pixbuf_new_from_xpm_data((const char**)radio_xpm);
717
 
        scaled = gdk_pixbuf_scale_simple(pixbuf, 16, 16, GDK_INTERP_HYPER);
718
 
        gdk_pixbuf_unref(pixbuf);
719
 
        tray_icon_image = gtk_image_new_from_pixbuf(scaled);
720
 
        gdk_pixbuf_unref(scaled);
721
 
 
722
 
        eventbox = gtk_event_box_new();
723
 
        gtk_container_add(GTK_CONTAINER(eventbox), tray_icon_image);
724
 
        gtk_container_add (GTK_CONTAINER(tray_icon), eventbox);
725
 
 
726
 
        g_signal_connect(G_OBJECT(eventbox), "button-press-event", 
727
 
                G_CALLBACK(tray_clicked), (gpointer)app);
728
 
        g_signal_connect(G_OBJECT(tray_icon), "destroy-event",
729
 
                G_CALLBACK(tray_destroyed), (gpointer)app);
730
 
        gtk_widget_show_all(GTK_WIDGET(tray_icon));
731
 
        
732
 
        text = g_strdup_printf(_("Gnomeradio - %.2f MHz"), adj->value/STEPS);
733
 
        gtk_tooltips_set_tip(tooltips, tray_icon, text, NULL);
734
 
        g_free(text);
735
 
}       
736
 
 
 
782
        if (GTK_WIDGET_VISIBLE(app))
 
783
        {
 
784
                gtk_window_get_position(GTK_WINDOW(app), &posx, &posy);
 
785
                gtk_widget_hide(app);
 
786
        }
 
787
        else
 
788
        {
 
789
                if ((posx >= 0) && (posy >= 0))
 
790
                        gtk_window_move(GTK_WINDOW(app), posx, posy);
 
791
                gtk_window_present(GTK_WINDOW(app));
 
792
        }
 
793
}       
 
794
        
737
795
GtkWidget* gnome_radio_gui(void)
738
796
{
739
797
        GtkWidget *app;
740
798
        GtkWidget *prefs_button, *quit_button, *scfw_button, *scbw_button;
741
799
        GtkWidget *stfw_button, *stbw_button, *about_button, *rec_button;
742
800
        GtkWidget *prefs_pixmap, *quit_pixmap, *scfw_pixmap, *scbw_pixmap;
743
 
        GtkWidget *stfw_pixmap, *stbw_pixmap, *about_pixmap, *mute_pixmap, *rec_pixmap;
 
801
        GtkWidget *stfw_pixmap, *stbw_pixmap, *about_pixmap;
744
802
        GtkWidget *vol_up_pixmap, *vol_down_pixmap, *freq_up_pixmap, *freq_down_pixmap;
745
803
        GdkPixbuf *vol_up_pixbuf, *vol_down_pixbuf, *freq_up_pixbuf, *freq_down_pixbuf;
746
804
        GtkWidget *hbox1, *hbox2, *vbox, *menubox, *freq_vol_box;
747
 
        GtkWidget *vseparator1, *vseparator2, *vseparator3, *vseparator4;
 
805
        GtkWidget *vseparator1, *vseparator2, *vseparator4;
748
806
        GtkWidget *label;
749
807
        GtkWidget *frame;
750
808
        gchar *text;
752
810
        app = gnome_app_new(PACKAGE, _("Gnomeradio"));
753
811
 
754
812
        gtk_window_set_resizable(GTK_WINDOW(app), FALSE);
755
 
        //gtk_window_set_policy(GTK_WINDOW(app), FALSE, FALSE, FALSE);
 
813
        /*gtk_window_set_policy(GTK_WINDOW(app), FALSE, FALSE, FALSE);*/
756
814
        gtk_window_set_wmclass(GTK_WINDOW(app), "gnomeradio", "Gnomeradio");
757
815
 
758
816
        frame = gtk_frame_new(NULL);
764
822
        stfw_pixmap = gtk_image_new_from_stock(GTK_STOCK_MEDIA_NEXT, GTK_ICON_SIZE_LARGE_TOOLBAR);
765
823
        stbw_pixmap = gtk_image_new_from_stock(GTK_STOCK_MEDIA_PREVIOUS, GTK_ICON_SIZE_LARGE_TOOLBAR);
766
824
        about_pixmap = gtk_image_new_from_stock(GTK_STOCK_ABOUT, GTK_ICON_SIZE_LARGE_TOOLBAR);
767
 
        mute_pixmap = gtk_image_new_from_stock(GNOME_STOCK_VOLUME, GTK_ICON_SIZE_LARGE_TOOLBAR);
 
825
        /*mute_pixmap = gtk_image_new_from_stock(GNOME_STOCK_VOLUME, GTK_ICON_SIZE_LARGE_TOOLBAR);*/
768
826
        rec_pixmap = gtk_image_new_from_stock(GTK_STOCK_MEDIA_RECORD, GTK_ICON_SIZE_LARGE_TOOLBAR);
769
 
        //help_pixmap = gtk_image_new_from_stock(GTK_STOCK_HELP, GTK_ICON_SIZE_LARGE_TOOLBAR);
 
827
        /*help_pixmap = gtk_image_new_from_stock(GTK_STOCK_HELP, GTK_ICON_SIZE_LARGE_TOOLBAR);*/
770
828
        
771
829
        quit_button = gtk_button_new();
772
830
        prefs_button = gtk_button_new();
775
833
        stfw_button = gtk_button_new();
776
834
        stbw_button = gtk_button_new();
777
835
        about_button = gtk_button_new();
778
 
        mute_button = gtk_toggle_button_new();
 
836
        /*mute_button = gtk_toggle_button_new();*/
 
837
        mute_button = bacon_volume_button_new(GTK_ICON_SIZE_LARGE_TOOLBAR, 0, 100, 1);
 
838
        gtk_button_set_relief(GTK_BUTTON(mute_button), GTK_RELIEF_NORMAL);
779
839
        rec_button = gtk_button_new();
780
 
        //help_button = gtk_button_new();
 
840
        /*help_button = gtk_button_new();*/
781
841
 
782
842
        gtk_container_add(GTK_CONTAINER(quit_button), quit_pixmap);
783
843
        gtk_container_add(GTK_CONTAINER(prefs_button), prefs_pixmap);
786
846
        gtk_container_add(GTK_CONTAINER(stfw_button), stfw_pixmap);
787
847
        gtk_container_add(GTK_CONTAINER(stbw_button), stbw_pixmap);
788
848
        gtk_container_add(GTK_CONTAINER(about_button), about_pixmap);
789
 
        gtk_container_add(GTK_CONTAINER(mute_button), mute_pixmap);
 
849
        /*gtk_container_add(GTK_CONTAINER(mute_button), mute_pixmap);*/
790
850
        gtk_container_add(GTK_CONTAINER(rec_button), rec_pixmap);
791
 
        //gtk_container_add(GTK_CONTAINER(help_button), help_pixmap);
 
851
        /*gtk_container_add(GTK_CONTAINER(help_button), help_pixmap);*/
792
852
 
793
853
        vbox = gtk_vbox_new(FALSE, 0);
794
854
        hbox1 = gtk_hbox_new(FALSE, 0);
797
857
        freq_vol_box = gtk_hbox_new(FALSE, 0);
798
858
        
799
859
        adj = GTK_ADJUSTMENT(gtk_adjustment_new(SUNSHINE*STEPS, FREQ_MIN*STEPS, FREQ_MAX*STEPS+1, 1, STEPS, 1));
800
 
        volume = GTK_ADJUSTMENT(gtk_adjustment_new(100, 0, 101, 1, 10, 1));
 
860
/*      volume = GTK_ADJUSTMENT(gtk_adjustment_new(100, 0, 101, 1, 10, 1)); */
801
861
        
802
862
        preset_combo = gtk_combo_box_new_text();
803
863
        g_signal_connect(GTK_OBJECT(preset_combo), "changed", GTK_SIGNAL_FUNC(preset_combo_change_cb), NULL);
806
866
        label = gtk_label_new(_("Presets:"));
807
867
        
808
868
        freq_scale = gtk_hscale_new(adj);
809
 
        //gtk_range_set_update_policy(GTK_RANGE(freq_scale), GTK_UPDATE_DELAYED);
810
 
        vol_scale = gtk_hscale_new(volume);
 
869
        /*gtk_range_set_update_policy(GTK_RANGE(freq_scale), GTK_UPDATE_DELAYED);*/
 
870
        /*vol_scale = gtk_hscale_new(volume);*/
811
871
        
812
 
        vol_up_pixbuf = gdk_pixbuf_new_from_xpm_data((const char**)vol_up_xpm);
813
 
        vol_down_pixbuf = gdk_pixbuf_new_from_xpm_data((const char**)vol_down_xpm);
 
872
        /*vol_up_pixbuf = gdk_pixbuf_new_from_xpm_data((const char**)vol_up_xpm);
 
873
        vol_down_pixbuf = gdk_pixbuf_new_from_xpm_data((const char**)vol_down_xpm);*/
814
874
        freq_up_pixbuf = gdk_pixbuf_new_from_xpm_data((const char**)freq_up_xpm);
815
875
        freq_down_pixbuf = gdk_pixbuf_new_from_xpm_data((const char**)freq_down_xpm);
816
876
 
817
 
        vol_up_pixmap = gtk_image_new_from_pixbuf(vol_up_pixbuf);
818
 
        vol_down_pixmap = gtk_image_new_from_pixbuf(vol_down_pixbuf);
 
877
        /*vol_up_pixmap = gtk_image_new_from_pixbuf(vol_up_pixbuf);
 
878
        vol_down_pixmap = gtk_image_new_from_pixbuf(vol_down_pixbuf);*/
819
879
        freq_up_pixmap = gtk_image_new_from_pixbuf(freq_up_pixbuf);
820
880
        freq_down_pixmap = gtk_image_new_from_pixbuf(freq_down_pixbuf);
821
881
 
822
 
        //gtk_widget_set_usize(freq_scale, 160, 10);
823
 
        gtk_widget_set_size_request(freq_scale, 160, -1);
 
882
        /*gtk_widget_set_usize(freq_scale, 160, 10);*/
 
883
        /*gtk_widget_set_size_request(freq_scale, 160, -1);*/
824
884
 
825
885
        gtk_widget_realize(app);
826
886
        drawing_area = gtk_drawing_area_new();
830
890
        
831
891
        vseparator1 = gtk_vseparator_new();
832
892
        vseparator2 = gtk_vseparator_new();
833
 
        vseparator3 = gtk_vseparator_new();
 
893
        /*vseparator3 = gtk_vseparator_new();*/
834
894
        vseparator4 = gtk_vseparator_new();
835
895
        
836
896
        gtk_scale_set_digits(GTK_SCALE(freq_scale), 0);
837
897
        gtk_scale_set_draw_value(GTK_SCALE(freq_scale), FALSE);
838
 
        gtk_scale_set_digits(GTK_SCALE(vol_scale), 0);
 
898
/*      gtk_scale_set_digits(GTK_SCALE(vol_scale), 0);
839
899
        gtk_scale_set_draw_value(GTK_SCALE(vol_scale), FALSE);
840
900
 
 
901
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mute_button), mixer_get_volume() == 0);*/
 
902
 
841
903
        gtk_widget_set_size_request(drawing_area, DIGIT_WIDTH*6+10+SIGNAL_WIDTH+STEREO_WIDTH, DIGIT_HEIGTH+10);
842
904
 
843
905
        gtk_container_add(GTK_CONTAINER(frame), drawing_area);
848
910
        gtk_box_pack_start(GTK_BOX(hbox2), scfw_button, FALSE, FALSE, 2);
849
911
        gtk_box_pack_start(GTK_BOX(hbox2), vseparator1, FALSE, FALSE, 2);
850
912
        gtk_box_pack_start(GTK_BOX(hbox2), mute_button, FALSE, FALSE, 2);
851
 
        //gtk_box_pack_start(GTK_BOX(hbox2), vseparator2, TRUE, TRUE, 3);
 
913
        /*gtk_box_pack_start(GTK_BOX(hbox2), vseparator2, TRUE, TRUE, 3);*/
852
914
        gtk_box_pack_start(GTK_BOX(hbox2), rec_button, FALSE, FALSE, 2);
853
915
        gtk_box_pack_start(GTK_BOX(hbox2), vseparator4, FALSE, FALSE, 2);
854
 
        //gtk_box_pack_start(GTK_BOX(hbox2), help_button, FALSE, FALSE, 2);
 
916
        /*gtk_box_pack_start(GTK_BOX(hbox2), help_button, FALSE, FALSE, 2);*/
855
917
        gtk_box_pack_start(GTK_BOX(hbox2), prefs_button, FALSE, FALSE, 2);
856
918
        gtk_box_pack_start(GTK_BOX(hbox2), about_button, FALSE, FALSE, 2);
857
 
        //gtk_box_pack_start(GTK_BOX(hbox2), quit_button, FALSE, FALSE, 2);
 
919
        /*gtk_box_pack_start(GTK_BOX(hbox2), quit_button, FALSE, FALSE, 2);*/
858
920
 
859
921
        gtk_box_pack_start(GTK_BOX(hbox1), frame, FALSE, FALSE, 3);
860
922
        gtk_box_pack_start(GTK_BOX(hbox1), menubox, TRUE, TRUE, 3);
863
925
        gtk_box_pack_start(GTK_BOX(menubox), preset_combo, TRUE, TRUE, 0);
864
926
 
865
927
        gtk_box_pack_start(GTK_BOX(freq_vol_box), freq_down_pixmap, FALSE, FALSE, 2);
866
 
        gtk_box_pack_start(GTK_BOX(freq_vol_box), freq_scale, FALSE, FALSE, 0);
 
928
        gtk_box_pack_start(GTK_BOX(freq_vol_box), freq_scale, TRUE, TRUE, 0);
867
929
        gtk_box_pack_start(GTK_BOX(freq_vol_box), freq_up_pixmap, FALSE, FALSE, 2);
868
 
        gtk_box_pack_start(GTK_BOX(freq_vol_box), vseparator3, FALSE, FALSE, 2);
 
930
        /*gtk_box_pack_start(GTK_BOX(freq_vol_box), vseparator3, FALSE, FALSE, 2);
869
931
        gtk_box_pack_start(GTK_BOX(freq_vol_box), vol_down_pixmap, FALSE, FALSE, 2);
870
932
        gtk_box_pack_start(GTK_BOX(freq_vol_box), vol_scale, TRUE, TRUE, 0);
871
 
        gtk_box_pack_start(GTK_BOX(freq_vol_box), vol_up_pixmap, FALSE, FALSE, 2);
 
933
        gtk_box_pack_start(GTK_BOX(freq_vol_box), vol_up_pixmap, FALSE, FALSE, 2);*/
872
934
 
873
935
        gtk_box_pack_start(GTK_BOX(vbox), hbox1, FALSE, FALSE, 4);
874
936
        gtk_box_pack_start(GTK_BOX(vbox), freq_vol_box, TRUE, TRUE, 2);
881
943
 
882
944
        gnome_app_set_contents(GNOME_APP(app), vbox);
883
945
 
884
 
        //status = gnome_appbar_new(FALSE, TRUE, GNOME_PREFERENCES_NEVER);
 
946
        /*status = gnome_appbar_new(FALSE, TRUE, GNOME_PREFERENCES_NEVER);*/
885
947
 
886
 
        //gnome_app_set_statusbar(GNOME_APP(app), status);
 
948
        /*gnome_app_set_statusbar(GNOME_APP(app), status);*/
887
949
 
888
950
        tooltips = gtk_tooltips_new();
889
951
 
890
952
        g_signal_connect(GTK_OBJECT(app), "delete_event", GTK_SIGNAL_FUNC(delete_event_cb), NULL);
891
953
        g_signal_connect(GTK_OBJECT(quit_button), "clicked", GTK_SIGNAL_FUNC(quit_button_clicked_cb), NULL);
892
954
        g_signal_connect(GTK_OBJECT(adj), "value-changed", GTK_SIGNAL_FUNC(adj_value_changed_cb), (gpointer) app);
893
 
        g_signal_connect(GTK_OBJECT(freq_scale), "button-release-event", GTK_SIGNAL_FUNC(freq_scale_focus_cb), NULL);
894
 
        g_signal_connect(GTK_OBJECT(volume), "value-changed", GTK_SIGNAL_FUNC(volume_value_changed_cb), NULL);
 
955
        g_signal_connect(GTK_OBJECT(mute_button), "value-changed", GTK_SIGNAL_FUNC(volume_value_changed_cb), NULL);
895
956
        g_signal_connect(GTK_OBJECT(stfw_button), "pressed", GTK_SIGNAL_FUNC(step_button_pressed_cb), (gpointer)TRUE);
896
957
        g_signal_connect(GTK_OBJECT(stbw_button), "pressed", GTK_SIGNAL_FUNC(step_button_pressed_cb), (gpointer)FALSE);
897
958
        g_signal_connect(GTK_OBJECT(stfw_button), "clicked", GTK_SIGNAL_FUNC(step_button_clicked_cb), (gpointer)TRUE);
901
962
        g_signal_connect(GTK_OBJECT(scfw_button), "clicked", GTK_SIGNAL_FUNC(scfw_button_clicked_cb), NULL);
902
963
        g_signal_connect(GTK_OBJECT(scbw_button), "clicked", GTK_SIGNAL_FUNC(scbw_button_clicked_cb), NULL);
903
964
        g_signal_connect(GTK_OBJECT(about_button), "clicked", GTK_SIGNAL_FUNC(about_button_clicked_cb), NULL);
904
 
        g_signal_connect(GTK_OBJECT(mute_button), "toggled", GTK_SIGNAL_FUNC(mute_button_toggled_cb), NULL);
905
965
        g_signal_connect(GTK_OBJECT(rec_button), "clicked", GTK_SIGNAL_FUNC(rec_button_clicked_cb), (gpointer) app);
906
966
        g_signal_connect(GTK_OBJECT(prefs_button), "clicked", GTK_SIGNAL_FUNC(prefs_button_clicked_cb), (gpointer) app);
907
967
        g_signal_connect(GTK_OBJECT(drawing_area), "expose-event", GTK_SIGNAL_FUNC(expose_event_cb), NULL);
913
973
        gtk_tooltips_set_tip(tooltips, about_button, _("About Gnomeradio"), NULL);
914
974
        gtk_tooltips_set_tip(tooltips, rec_button, _("Record radio as Wave, OGG or MP3"), NULL);
915
975
        gtk_tooltips_set_tip(tooltips, prefs_button, _("Edit your Preferences"), NULL);
916
 
        gtk_tooltips_set_tip(tooltips, mute_button, _("Mute"), NULL);
 
976
        gtk_tooltips_set_tip(tooltips, mute_button, _("Adjust the Volume"), NULL);
917
977
        gtk_tooltips_set_tip(tooltips, quit_button, _("Quit"), NULL);
918
978
        text = g_strdup_printf(_("Frequency: %.2f MHz"), adj->value/STEPS);
919
979
        gtk_tooltips_set_tip(tooltips, freq_scale, text, NULL);
920
980
        g_free(text);
921
 
        text = g_strdup_printf(_("Volume: %d%%"), (gint)volume->value);
 
981
/*      text = g_strdup_printf(_("Volume: %d%%"), (gint)volume->value);
922
982
        gtk_tooltips_set_tip(tooltips, vol_scale, text, NULL);
923
 
        g_free(text);
 
983
        g_free(text);*/
924
984
        
925
985
        return app;
926
986
}
955
1015
static gboolean
956
1016
key_press_event_cb(GtkWidget *app, GdkEventKey *event, gpointer data)
957
1017
{
958
 
        GtkToggleButton *tb = GTK_TOGGLE_BUTTON(mute_button);
959
 
        gboolean state = gtk_toggle_button_get_active(tb);
960
 
        //g_print("%s key pressed: %d\n",  gdk_keyval_name(event->keyval), event->keyval);
 
1018
        int vol = (int)(bacon_volume_button_get_value(BACON_VOLUME_BUTTON(mute_button)) + 0.5f);
961
1019
        
962
1020
        switch (event->keyval)
963
1021
        {
964
1022
                case GDK_F1: display_help_cb(NULL);
965
1023
                                break;
966
1024
                case GDK_m: 
967
 
                                gtk_toggle_button_set_active(tb, !state);
 
1025
                                toggle_volume();
968
1026
                                break;
969
1027
                case GDK_q: 
970
1028
                                exit_gnome_radio();
986
1044
                                break;
987
1045
                case GDK_KP_Add:
988
1046
                case GDK_plus:  
989
 
                                gtk_adjustment_set_value(volume, (volume->value > 95) ? 100 : volume->value+5);
 
1047
                                bacon_volume_button_set_value(BACON_VOLUME_BUTTON(mute_button), vol > 95 ? 100 : vol + 5);
 
1048
                                /*gtk_adjustment_set_value(volume, (volume->value > 95) ? 100 : volume->value+5);*/
990
1049
                                break;
991
1050
                case GDK_minus:
992
1051
                case GDK_KP_Subtract: 
993
 
                                gtk_adjustment_set_value(volume,(volume->value < 5) ? 0 : volume->value-5);
 
1052
                                bacon_volume_button_set_value(BACON_VOLUME_BUTTON(mute_button), vol < 5 ? 0 : vol - 5);
 
1053
                                /*gtk_adjustment_set_value(volume,(volume->value < 5) ? 0 : volume->value-5);*/
994
1054
                                break;
995
1055
        }
996
1056
        return FALSE;
999
1059
int main(int argc, char* argv[])
1000
1060
{
1001
1061
        GtkWidget* app;
1002
 
        GList *icons, *ptr;
1003
 
        GdkPixbuf *app_icon;
 
1062
        GList *ptr;
1004
1063
        GnomeClient *client;
1005
1064
        GError *err = NULL;
1006
1065
        int redraw_timeout_id;
1007
 
        
 
1066
        gboolean do_scan = FALSE;
 
1067
#if GNOME_14 
 
1068
        GOptionContext *ctx;
 
1069
        const GOptionEntry entries[] = {
 
1070
                { "scan", 0, 0, G_OPTION_ARG_NONE, &do_scan, N_("Scan for stations"), NULL },
 
1071
                { NULL }
 
1072
        };
 
1073
#endif  
1008
1074
        bindtextdomain(PACKAGE, GNOMELOCALEDIR);  
1009
1075
        bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
1010
1076
        textdomain(PACKAGE);
1011
1077
 
 
1078
        g_set_application_name(_("Gnomeradio"));
 
1079
        
 
1080
#if GNOME_14
 
1081
        ctx = g_option_context_new("- Gnomeradio");
 
1082
        g_option_context_add_main_entries(ctx, entries, GETTEXT_PACKAGE);  
 
1083
        g_option_context_add_group(ctx, gst_init_get_option_group());
 
1084
        g_option_context_set_ignore_unknown_options(ctx, TRUE); 
 
1085
#endif  
 
1086
 
1012
1087
        gnome_program_init(PACKAGE, VERSION, 
1013
1088
                                        LIBGNOMEUI_MODULE, argc, argv, 
1014
 
                                        GNOME_PROGRAM_STANDARD_PROPERTIES, 
 
1089
                                        GNOME_PROGRAM_STANDARD_PROPERTIES,
 
1090
#if GNOME_14
 
1091
                                        GNOME_PARAM_GOPTION_CONTEXT, ctx,
 
1092
#endif
1015
1093
                                        NULL);
1016
 
                
1017
 
        app_icon = gdk_pixbuf_new_from_xpm_data((const char**)radio_xpm);
1018
 
        icons = g_list_append(NULL, (gpointer)app_icon);
1019
 
        gtk_window_set_default_icon_list(icons);
1020
 
 
1021
 
        
 
1094
        gtk_window_set_default_icon_name("gnomeradio");
1022
1095
        /* Main app */
1023
 
 
1024
1096
        app = gnome_radio_gui();
1025
1097
 
1026
 
        gtk_widget_show_all(app);
1027
 
 
1028
 
        /* Create an tray icon */
1029
 
        create_tray_icon(app);
 
1098
        /* Initizialize GStreamer */
 
1099
        gst_init(&argc, &argv);
1030
1100
        
1031
1101
        /* Initizialize Gconf */
1032
 
        if (!gconf_init(argc, argv, &err))
1033
 
        {
1034
 
                GtkWidget *dialog;
1035
 
                dialog = gtk_message_dialog_new(NULL, DIALOG_FLAGS, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
1036
 
                                                _("Failed to init GConf: %s\n"
1037
 
                                                "Changes to the settings won't be saved\n"), err->message);
1038
 
                gtk_dialog_run (GTK_DIALOG (dialog));
1039
 
                gtk_widget_destroy (dialog);
 
1102
        if (!gconf_init(argc, argv, &err)) {
 
1103
                char *details;
 
1104
                details = g_strdup_printf(_("%s\n\nChanges to the settings won't be saved."), err->message);
 
1105
                show_warning_message(_("Failed to init GConf!"), details);
1040
1106
                g_error_free(err); 
 
1107
                g_free(details);
1041
1108
                err = NULL;
1042
 
        }
1043
 
        else
1044
 
        {
 
1109
        } else {
1045
1110
                gconf_client_set_global_default_error_handler((GConfClientErrorHandlerFunc)gconf_error_handler);
1046
1111
                gconf_client_set_error_handling(gconf_client_get_default(),  GCONF_CLIENT_HANDLE_ALL);
 
1112
                gnome_media_profiles_init(gconf_client_get_default());
1047
1113
        }
1048
 
                
 
1114
 
1049
1115
        load_settings();
 
1116
        create_tray_menu(app);
 
1117
        
1050
1118
        gtk_combo_box_append_text(GTK_COMBO_BOX(preset_combo), _("manual"));
1051
1119
        for (ptr = settings.presets; ptr; ptr = g_list_next(ptr)) {
1052
1120
                preset *ps = (preset*)ptr->data;
1053
1121
                gtk_combo_box_append_text(GTK_COMBO_BOX(preset_combo), ps->title);
1054
1122
        }
1055
1123
        preset_combo_set_item(mom_ps);
1056
 
        
1057
 
        start_radio(FALSE);
1058
 
        
1059
 
        start_mixer(FALSE);
 
1124
 
 
1125
        start_mixer(FALSE, app);
 
1126
        start_radio(FALSE, app);
 
1127
        if (is_first_start() || do_scan) {
 
1128
                if (!radio_is_init()) {
 
1129
                        g_message(_("Could not scan. Radio is not initialized."));
 
1130
                } else {
 
1131
                        initial_frequency_scan(app);
 
1132
                        set_first_time_flag();
 
1133
                }
 
1134
        }
 
1135
        gtk_widget_show_all(app);
 
1136
 
 
1137
        /* Create an tray icon */
 
1138
        create_tray_icon(app);
 
1139
 
1060
1140
        adj_value_changed_cb(NULL, (gpointer) app);
1061
 
        volume_value_changed_cb(NULL, NULL);
1062
 
 
 
1141
        /*volume_value_changed_cb(NULL, NULL);*/
1063
1142
        
1064
1143
#ifdef HAVE_LIRC
1065
1144
        if(!my_lirc_init())
1070
1149
                gtk_dialog_run (GTK_DIALOG (dialog));
1071
1150
                gtk_widget_destroy (dialog);
1072
1151
*/
1073
 
                g_print(_("Could not start lirc!\n"));
 
1152
                g_message(_("Could not start lirc!"));
1074
1153
        }
1075
1154
        else
1076
1155
                start_lirc();
1095
1174
        /* Checks if the volume has been changed by an 
1096
1175
         * external app
1097
1176
         */
1098
 
        //gtk_timeout_add(100, (GtkFunction)poll_volume_change, NULL);
 
1177
        /*gtk_timeout_add(100, (GtkFunction)poll_volume_change, NULL);*/
1099
1178
 
1100
1179
        gtk_main();
1101
1180
                
1105
1184
 
1106
1185
        return 0;
1107
1186
}
 
1187
 
 
1188
static show_message(GtkMessageType type, const char* text, const char* details)
 
1189
{
 
1190
        GtkWidget *dialog;
 
1191
        
 
1192
        g_assert(text);
 
1193
        
 
1194
        dialog = gtk_message_dialog_new(NULL, DIALOG_FLAGS, type, GTK_BUTTONS_CLOSE,
 
1195
                        text);
 
1196
        if (details) {
 
1197
                gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog), details);
 
1198
        }
 
1199
        gtk_dialog_run(GTK_DIALOG (dialog));
 
1200
        gtk_widget_destroy(dialog);
 
1201
}       
 
1202
 
 
1203
void show_error_message(const char* error, const char* details)
 
1204
{
 
1205
        show_message(GTK_MESSAGE_ERROR, error, details);
 
1206
}       
 
1207
 
 
1208
void show_warning_message(const char* warning, const char* details)
 
1209
{
 
1210
        show_message(GTK_MESSAGE_WARNING, warning, details);
 
1211
}