← Back to branch summary

~blackskad/gnomeradio/dev-vol-button

« back to all changes in this revision

Viewing changes to src/gui.c

  • Committer: mfcn
  • Date: 2006-02-24 09:42:47 UTC
  • Revision ID: svn-v3-trunk0:ba97a3d1-ec25-0410-b1c6-e06ad936ea6c:trunk:125
        * src/gui.c, src/gui.h, src/prefs.c, src/prefs.h, src/tech.c,
        src/tech.h, src/trayicon.h: added an function that scans for
        stations on first run, and adds them to the presets.
        * Code cleanup here and there

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gui.c
56
56
static int timeout_id, bp_timeout_id = -1, bp_timeout_steps = 0;
57
57
static int mute_button_toggled_cb_id;
58
58
 
59
 
void start_radio(gboolean restart)
 
59
static gboolean is_first_start(void)
 
60
{
 
61
        GConfClient *client = gconf_client_get_default();
 
62
        if (!client)
 
63
                return TRUE;
 
64
 
 
65
        return !gconf_client_get_bool(client, "/apps/gnomeradio/first_time_flag", NULL);
 
66
}
 
67
 
 
68
static void set_first_time_flag(void)
 
69
{
 
70
        GConfClient *client = gconf_client_get_default();
 
71
        if (!client)
 
72
                return;
 
73
 
 
74
        gconf_client_set_bool(client, "/apps/gnomeradio/first_time_flag", TRUE, NULL);
 
75
}
 
76
 
 
77
typedef struct {
 
78
        GtkWidget *dialog;
 
79
        GtkWidget *progress;
 
80
        GList *stations;
 
81
        GtkWidget *label;
 
82
} FreqScanData;
 
83
 
 
84
static gboolean initial_frequency_scan_cb(gpointer data)
 
85
{
 
86
        static gfloat freq = FREQ_MIN - 4.0f/STEPS;
 
87
        FreqScanData *fsd = data;
 
88
        
 
89
        g_assert(fsd);
 
90
        
 
91
        if (freq > FREQ_MAX) {
 
92
                gtk_widget_destroy(fsd->dialog);
 
93
                timeout_id = 0;
 
94
                return FALSE;
 
95
        }
 
96
        
 
97
        if (radio_check_station(freq)) {
 
98
                char *text = g_strdup_printf(_("%d stations found"), g_list_length(fsd->stations) + 1);
 
99
                gfloat *f = g_malloc(sizeof(gfloat));
 
100
                gtk_label_set_text(GTK_LABEL(fsd->label), text);
 
101
                g_free(text);
 
102
                
 
103
                g_print("%.2f is a station\n", freq);
 
104
                
 
105
                *f = freq;
 
106
                fsd->stations = g_list_append(fsd->stations, f);
 
107
        }
 
108
 
 
109
        gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(fsd->progress), MAX(0, (freq - FREQ_MIN)/(FREQ_MAX - FREQ_MIN)));        
 
110
        
 
111
        freq += 1.0/STEPS;
 
112
        radio_setfreq(freq);
 
113
        
 
114
        return TRUE;
 
115
}
 
116
 
 
117
static void initial_frequency_scan(GtkWidget *app)
 
118
{
 
119
        FreqScanData data;
 
120
        GtkWidget *title;
 
121
        char *title_hdr;
 
122
        
 
123
        data.stations = NULL;
 
124
        
 
125
        data.dialog = gtk_dialog_new_with_buttons(_("Scanning"),
 
126
                GTK_WINDOW(app), DIALOG_FLAGS, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
 
127
        gtk_dialog_set_has_separator(GTK_DIALOG(data.dialog), FALSE);
 
128
        gtk_window_set_resizable(GTK_WINDOW(data.dialog), FALSE);
 
129
        
 
130
        title_hdr = g_strconcat("<span weight=\"bold\">", _("Scanning for available stations:"), "</span>", NULL);
 
131
        title = gtk_label_new(title_hdr);
 
132
        gtk_misc_set_alignment(GTK_MISC(title), 0, 0.5);
 
133
        gtk_label_set_use_markup(GTK_LABEL(title), TRUE);
 
134
        g_free(title_hdr);
 
135
        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(data.dialog)->vbox), title, FALSE, FALSE, 6);
 
136
        
 
137
        data.progress = gtk_progress_bar_new();
 
138
        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(data.dialog)->vbox), data.progress, TRUE, FALSE, 6);
 
139
        
 
140
        data.label = gtk_label_new(_("No stations found"));
 
141
        gtk_misc_set_alignment(GTK_MISC(data.label), 0, 0.5);
 
142
        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(data.dialog)->vbox), data.label, TRUE, FALSE, 6);
 
143
        
 
144
        gtk_widget_show_all(data.dialog);
 
145
        
 
146
        radio_mute();
 
147
        timeout_id = g_timeout_add(1000/SCAN_SPEED, (GSourceFunc)initial_frequency_scan_cb, (gpointer)&data);   
 
148
        int response = gtk_dialog_run(GTK_DIALOG(data.dialog));
 
149
 
 
150
        radio_unmute();
 
151
        if (timeout_id) {
 
152
                g_source_remove(timeout_id);
 
153
                timeout_id = 0;
 
154
                gtk_widget_destroy(data.dialog);
 
155
        } else {
 
156
                if (g_list_length(data.stations) > 0) {
 
157
                        gfloat f = *((gfloat*)data.stations->data);
 
158
                        adj->value = f*STEPS;
 
159
                        radio_setfreq(f);
 
160
                        
 
161
                        GtkWidget *dialog;
 
162
                        GList *ptr;
 
163
                        char *text;
 
164
                        
 
165
                        text = g_strdup_printf(_("%d stations found. \nDo you want to add them as presets?\n"),
 
166
                                        g_list_length(data.stations));
 
167
                        
 
168
                        dialog = gtk_message_dialog_new(GTK_WINDOW(app), DIALOG_FLAGS, GTK_MESSAGE_QUESTION,
 
169
                                        GTK_BUTTONS_YES_NO, text);
 
170
                        g_free(text);
 
171
                        
 
172
                        int response = gtk_dialog_run(GTK_DIALOG(dialog));
 
173
                        gtk_widget_destroy(dialog);
 
174
 
 
175
                        for (ptr = data.stations; ptr; ptr = ptr->next) {
 
176
                                if (response == GTK_RESPONSE_YES) {
 
177
                                        preset *ps = g_malloc0(sizeof(preset));
 
178
                                        ps->title = g_strdup(_("unnamed"));
 
179
                                        ps->freq = *((gfloat*)ptr->data);
 
180
                                        settings.presets = g_list_append(settings.presets, ps);
 
181
                                }
 
182
                                g_free(ptr->data);
 
183
                        }       
 
184
                }
 
185
        }       
 
186
}       
 
187
 
 
188
static void prefs_button_clicked_cb(GtkButton *button, gpointer app)
 
189
{
 
190
        GtkWidget* dialog;
 
191
        gint choise;
 
192
        
 
193
        dialog = prefs_window(app);
 
194
        
 
195
        /* Michael Jochum <e9725005@stud3.tuwien.ac.at> proposed to not use gnome_dialog_set_parent()
 
196
           but following instead. */
 
197
        gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(app));
 
198
        gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
 
199
        
 
200
        /*gnome_dialog_set_parent(GNOME_DIALOG(dialog), GTK_WINDOW(app));*/
 
201
        
 
202
        choise = GTK_RESPONSE_HELP;
 
203
        while (choise == GTK_RESPONSE_HELP)
 
204
        {
 
205
                choise = gtk_dialog_run(GTK_DIALOG(dialog)); 
 
206
                switch (choise)
 
207
                {
 
208
                        case GTK_RESPONSE_HELP:
 
209
                                display_help_cb("gnomeradio-settings");
 
210
                        break;
 
211
                        default:
 
212
                                /* We need the hide signal to get the value of the device_entry */
 
213
                                gtk_widget_hide_all(dialog);
 
214
                                gtk_widget_destroy(dialog);
 
215
                }
 
216
        }
 
217
}
 
218
 
 
219
void start_radio(gboolean restart, GtkWidget *app)
60
220
{
61
221
        if (restart)
62
222
                radio_stop();
69
229
                show_error_message(caption, detail);
70
230
                g_free(caption);
71
231
                g_free(detail);
72
 
        }               
 
232
                
 
233
                if (!restart)
 
234
                        prefs_button_clicked_cb(NULL, app);
 
235
        }
 
236
        if (is_first_start() && radio_is_init()) {
 
237
                initial_frequency_scan(app);
 
238
                set_first_time_flag();
 
239
        }
73
240
}
74
241
 
75
 
void start_mixer(gboolean restart)
 
242
void start_mixer(gboolean restart, GtkWidget *app)
76
243
{
77
244
        gint res, vol;
78
245
        
82
249
        res = mixer_init(settings.mixer_dev, settings.mixer);
83
250
        if (res <1) 
84
251
        {
85
 
                GtkWidget *dialog;
86
252
                char *buffer;
87
253
                
88
254
                if (res == -1)
89
255
                        buffer = g_strdup_printf(_("Mixer source \"%s\" is not a valid source!"), settings.mixer);
90
256
                else 
91
257
                        buffer = g_strdup_printf(_("Could not open \"%s\"!"), settings.mixer_dev);
92
 
 
93
 
                dialog = gtk_message_dialog_new(NULL, DIALOG_FLAGS, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, buffer);
94
 
                gtk_dialog_run (GTK_DIALOG (dialog));
95
 
                gtk_widget_destroy (dialog);
 
258
                
 
259
                show_error_message(buffer, NULL);
96
260
                
97
261
                g_free(buffer);
98
262
        }               
99
263
        vol = mixer_get_volume();
100
 
        
101
 
        if (vol >= 0)
 
264
        if (vol >= 0) {
102
265
                gtk_adjustment_set_value(volume, (double)vol);
 
266
        }
103
267
}
104
268
 
105
269
GList* get_mixer_recdev_list(void)
254
418
        gtk_tooltips_set_tip(tooltips, vol_scale, text, NULL);
255
419
        g_free(text);
256
420
        
 
421
        if (tray_menu) {
 
422
                g_signal_handler_block(G_OBJECT(mute_menuitem), mute_menuitem_toggled_cb_id);
 
423
                gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mute_menuitem), vol == 0);
 
424
                g_signal_handler_unblock(G_OBJECT(mute_menuitem), mute_menuitem_toggled_cb_id);
 
425
        }
257
426
        g_signal_handler_block(G_OBJECT(mute_button), mute_button_toggled_cb_id);
258
 
        g_signal_handler_block(G_OBJECT(mute_menuitem), mute_menuitem_toggled_cb_id);
259
427
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mute_button), vol == 0);
260
 
        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mute_menuitem), vol == 0);
261
428
        g_signal_handler_unblock(G_OBJECT(mute_button), mute_button_toggled_cb_id);
262
 
        g_signal_handler_unblock(G_OBJECT(mute_menuitem), mute_menuitem_toggled_cb_id);
263
429
}
264
430
 
265
431
#if 0
330
496
        bp_timeout_steps = 0;
331
497
}
332
498
 
333
 
 
334
499
static gboolean scan_freq(gpointer data)
335
500
{
336
 
        static gint signal, a, b, c;    
337
501
        static gint start, mom, max;
338
502
        gint dir = (gint)(data);
339
503
        
340
 
        if (!max)
 
504
        if (!max) {
341
505
                max = (FREQ_MAX - FREQ_MIN) * STEPS;
342
 
 
343
 
        if ((a + b + c > 8) || (start > max))   
344
 
        {
345
 
                start = mom = a = b = c = 0;
 
506
        }       
 
507
                
 
508
        if (radio_check_station(adj->value/STEPS) || (start > max))     {
 
509
                start = mom = 0;
346
510
                radio_unmute();
347
511
                timeout_id = 0;
348
512
                return FALSE;
349
513
        }
350
 
        if (!mom)
351
 
        mom= adj->value;
 
514
        if (!mom) {
 
515
                mom = adj->value;
 
516
        }
 
517
                
352
518
        if (mom > FREQ_MAX*STEPS) 
353
519
                mom = FREQ_MIN*STEPS;
354
 
        else
355
 
        if (mom < FREQ_MIN*STEPS)
 
520
        else if (mom < FREQ_MIN*STEPS)
356
521
                mom = FREQ_MAX*STEPS;
357
522
        else    
358
523
                mom = mom + dir;
359
524
        start += 1;
360
525
        gtk_adjustment_set_value(adj, mom);
361
 
        signal = radio_getsignal();
362
 
        a = b;
363
 
        b = c;
364
 
        c = signal;
 
526
 
365
527
        return TRUE;
366
528
}
367
529
 
370
532
        if (timeout_id) {
371
533
                gtk_timeout_remove(timeout_id);
372
534
                timeout_id = 0;
 
535
                radio_unmute();
373
536
                return;
374
537
        }
375
538
        radio_mute();
381
544
        if (timeout_id) {
382
545
                gtk_timeout_remove(timeout_id);
383
546
                timeout_id = 0;
 
547
                radio_unmute();
384
548
                return;
385
549
        }
386
550
        radio_mute();
426
590
        exit_gnome_radio();
427
591
}
428
592
 
429
 
static void prefs_button_clicked_cb(GtkButton *button, gpointer app)
430
 
{
431
 
        GtkWidget* dialog;
432
 
        gint choise;
433
 
        
434
 
        dialog = prefs_window();
435
 
        
436
 
        /* Michael Jochum <e9725005@stud3.tuwien.ac.at> proposed to not use gnome_dialog_set_parent()
437
 
           but following instead. */
438
 
        gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(app));
439
 
        gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
440
 
        
441
 
        /*gnome_dialog_set_parent(GNOME_DIALOG(dialog), GTK_WINDOW(app));*/
442
 
        
443
 
        choise = GTK_RESPONSE_HELP;
444
 
        while (choise == GTK_RESPONSE_HELP)
445
 
        {
446
 
                choise = gtk_dialog_run(GTK_DIALOG(dialog)); 
447
 
                switch (choise)
448
 
                {
449
 
                        case GTK_RESPONSE_HELP:
450
 
                                display_help_cb("gnomeradio-settings");
451
 
                        break;
452
 
                        default:
453
 
                                /* We need the hide signal to get the value of the device_entry */
454
 
                                gtk_widget_hide_all(dialog);
455
 
                                gtk_widget_destroy(dialog);
456
 
                }
457
 
        }
458
 
}
459
 
 
460
593
void tray_icon_items_set_sensible(gboolean sensible)
461
594
{
462
595
        GList* menuitems;
573
706
{
574
707
        if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mute_button)))
575
708
        {               
 
709
                gtk_tooltips_set_tip(tooltips, mute_button, _("Unmute"), NULL);
 
710
        }
 
711
        else
 
712
        {
576
713
                gtk_tooltips_set_tip(tooltips, mute_button, _("Mute"), NULL);
577
714
        }
578
 
        else
579
 
        {
580
 
                gtk_tooltips_set_tip(tooltips, mute_button, _("Unmute"), NULL);
581
 
        }
582
715
        toggle_volume();
583
716
}
584
717
 
921
1054
        }
922
1055
        return FALSE;
923
1056
}
924
 
 
 
1057
        
925
1058
int main(int argc, char* argv[])
926
1059
{
927
1060
        GtkWidget* app;
947
1080
        /* Main app */
948
1081
        app = gnome_radio_gui();
949
1082
 
950
 
        gtk_widget_show_all(app);
951
 
 
952
 
        /* Create an tray icon */
953
 
        create_tray_icon(app);
954
 
        
955
1083
        /* Initizialize GStreamer */
956
1084
        gst_init(&argc, &argv);
957
1085
        
973
1101
                gconf_client_set_error_handling(gconf_client_get_default(),  GCONF_CLIENT_HANDLE_ALL);
974
1102
                gnome_media_profiles_init(gconf_client_get_default());
975
1103
        }
976
 
        
 
1104
 
977
1105
        load_settings();
 
1106
 
 
1107
        tray_menu = NULL;
 
1108
        start_mixer(FALSE, app);
 
1109
        start_radio(FALSE, app);
 
1110
 
978
1111
        gtk_combo_box_append_text(GTK_COMBO_BOX(preset_combo), _("manual"));
979
1112
        for (ptr = settings.presets; ptr; ptr = g_list_next(ptr)) {
980
1113
                preset *ps = (preset*)ptr->data;
981
1114
                gtk_combo_box_append_text(GTK_COMBO_BOX(preset_combo), ps->title);
982
1115
        }
983
1116
        preset_combo_set_item(mom_ps);
 
1117
        
 
1118
        gtk_widget_show_all(app);
 
1119
 
 
1120
        /* Create an tray icon */
 
1121
        create_tray_icon(app);
984
1122
        create_tray_menu(app);
985
 
        
986
 
        start_radio(FALSE);
987
 
        
988
 
        start_mixer(FALSE);
 
1123
 
989
1124
        adj_value_changed_cb(NULL, (gpointer) app);
990
 
        volume_value_changed_cb(NULL, NULL);
991
 
 
 
1125
        //volume_value_changed_cb(NULL, NULL);
992
1126
        
993
1127
#ifdef HAVE_LIRC
994
1128
        if(!my_lirc_init())
1035
1169
        return 0;
1036
1170
}
1037
1171
 
1038
 
static show_message(GtkMessageType type, const char* caption, const char* error_msg)
 
1172
static show_message(GtkMessageType type, const char* text, const char* details)
1039
1173
{
1040
1174
        GtkWidget *dialog;
1041
1175
        
1042
 
        char *text = g_strdup_printf("<b>%s</b>\n\n%s", caption, error_msg);
 
1176
        g_assert(text);
1043
1177
        
1044
 
        dialog = gtk_message_dialog_new_with_markup(NULL, DIALOG_FLAGS, type, GTK_BUTTONS_CLOSE,
 
1178
        dialog = gtk_message_dialog_new(NULL, DIALOG_FLAGS, type, GTK_BUTTONS_CLOSE,
1045
1179
                        text);
 
1180
        if (details) {
 
1181
                gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog), details);
 
1182
        }
1046
1183
        gtk_dialog_run(GTK_DIALOG (dialog));
1047
1184
        gtk_widget_destroy(dialog);
1048
 
        g_free(text);
1049
 
}       
1050
 
 
1051
 
void show_error_message(const char* caption, const char* error_msg)
1052
 
{
1053
 
        show_message(GTK_MESSAGE_ERROR, caption, error_msg);
1054
 
}       
1055
 
 
1056
 
void show_warning_message(const char* caption, const char* error_msg)
1057
 
{
1058
 
        show_message(GTK_MESSAGE_WARNING, caption, error_msg);
 
1185
}       
 
1186
 
 
1187
void show_error_message(const char* error, const char* details)
 
1188
{
 
1189
        show_message(GTK_MESSAGE_ERROR, error, details);
 
1190
}       
 
1191
 
 
1192
void show_warning_message(const char* warning, const char* details)
 
1193
{
 
1194
        show_message(GTK_MESSAGE_WARNING, warning, details);
1059
1195
}