开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 驱动编程 > 查看源码
gui.c
资源名称：fmradio.zip　[点击查看]
上传用户：ledjyj
上传日期：2014-08-27
资源大小：2639k
文件大小：36k
源码类别：

驱动编程

开发平台：

Unix_Linux

gui.c：源码内容
  1. /* gui.c
  2.  *
  3.  * Copyright (C) 2001 J鰎gen Scheibengruber
  4.  *
  5.  * This program is free software; you can redistribute it and/or 
  6.  * modify it under the terms of the GNU General Public License as 
  7.  * published by the Free Software Foundation; either version 2 of the
  8.  * License, or (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
  18.  * USA
  19.  */
  21. /*** the gui to gnomeradio */
  23. #include <config.h>
  24. #include <gnome.h>
  25. #include <gconf/gconf-client.h>
  26. #include <math.h>
  27. #include "eggtrayicon.h"
  28. #include "bacon-volume.h"
  29. #include "gui.h"
  30. #include "trayicon.h"
  31. #include "tech.h"
  32. #include "rec_tech.h"
  33. #include "lirc.h"
  34. #include "prefs.h"
  35. #include "record.h"
  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. #define DIGIT_WIDTH 20
  43. #define DIGIT_HEIGTH 30
  44. #define SIGNAL_WIDTH 25
  45. #define STEREO_WIDTH 35
  46. #define SCAN_SPEED 20
  48. #define TRANSLATORS "TRANSLATORS"
  50. static GtkWidget *drawing_area;
  51. static GdkPixmap *digits, *signal_s, *stereo;
  52. static GtkWidget *freq_scale;
  53. static GtkWidget *rec_pixmap;
  55. static int timeout_id, bp_timeout_id = -1, bp_timeout_steps = 0;
  57. static gboolean is_first_start(void)
  58. {
  59. GConfClient *client = gconf_client_get_default();
  60. if (!client)
  61. return TRUE;
  63. return !gconf_client_get_bool(client, "/apps/gnomeradio/first_time_flag", NULL);
  64. }
  66. static void set_first_time_flag(void)
  67. {
  68. GConfClient *client = gconf_client_get_default();
  69. if (!client)
  70. return;
  72. gconf_client_set_bool(client, "/apps/gnomeradio/first_time_flag", TRUE, NULL);
  73. }
  75. typedef struct {
  76. GtkWidget *dialog;
  77. GtkWidget *progress;
  78. GList *stations;
  79. GtkWidget *label;
  80. } FreqScanData;
  82. static gboolean initial_frequency_scan_cb(gpointer data)
  83. {
  84. static gfloat freq = FREQ_MIN - 4.0f/STEPS;
  85. FreqScanData *fsd = data;
  87. g_assert(fsd);
  89. if (freq > FREQ_MAX) {
  90. gtk_widget_destroy(fsd->dialog);
  91. timeout_id = 0;
  92. return FALSE;
  93. }
  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);
  101. g_print("%.2f is a stationn", freq);
  103. *f = freq;
  104. fsd->stations = g_list_append(fsd->stations, f);
  105. }
  107. gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(fsd->progress), MAX(0, (freq - FREQ_MIN)/(FREQ_MAX - FREQ_MIN)));
  109. freq += 1.0/STEPS;
  110. radio_setfreq(freq);
  112. return TRUE;
  113. }
  115. static void initial_frequency_scan(GtkWidget *app)
  116. {
  117. FreqScanData data;
  118. GtkWidget *title;
  119. char *title_hdr;
  121. data.stations = NULL;
  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);
  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);
  135. data.progress = gtk_progress_bar_new();
  136. gtk_box_pack_start(GTK_BOX(GTK_DIALOG(data.dialog)->vbox), data.progress, TRUE, FALSE, 6);
  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);
  142. gtk_widget_show_all(data.dialog);
  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));
  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);
  159. GtkWidget *dialog;
  160. GList *ptr;
  161. char *text;
  163. text = g_strdup_printf(_("%d stations found. nDo you want to add them as presets?n"),
  164. g_list_length(data.stations));
  166. dialog = gtk_message_dialog_new(GTK_WINDOW(app), DIALOG_FLAGS, GTK_MESSAGE_QUESTION,
  167. GTK_BUTTONS_YES_NO, text);
  168. g_free(text);
  170. int response = gtk_dialog_run(GTK_DIALOG(dialog));
  171. gtk_widget_destroy(dialog);
  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. }
  186. static void prefs_button_clicked_cb(GtkButton *button, gpointer app)
  187. {
  188. GtkWidget* dialog;
  189. gint choise;
  191. dialog = prefs_window(app);
  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);
  198. /*gnome_dialog_set_parent(GNOME_DIALOG(dialog), GTK_WINDOW(app));*/
  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. }
  217. void start_radio(gboolean restart, GtkWidget *app)
  218. {
  219. if (restart)
  220. radio_stop();
  222. if (!radio_init(settings.device)) 
  223. {
  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 othern"
  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);
  231. if (!restart)
  232. prefs_button_clicked_cb(NULL, app);
  233. }
  234. }
  236. void start_mixer(gboolean restart, GtkWidget *app)
  237. {
  238. gint res, vol;
  240. if (restart)
  241. mixer_close();
  243. res = mixer_init(settings.mixer_dev, settings.mixer);
  244. if (res <1) 
  245. {
  246. char *buffer;
  248. if (res == -1)
  249. buffer = g_strdup_printf(_("Mixer source "%s" is not a valid source!"), settings.mixer);
  250. else 
  251. buffer = g_strdup_printf(_("Could not open "%s"!"), settings.mixer_dev);
  253. show_error_message(buffer, NULL);
  255. g_free(buffer);
  256. }
  257. vol = mixer_get_volume();
  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. }
  262. }
  264. GList* get_mixer_recdev_list(void)
  265. {
  266. int i;
  267. char **array, *dev;
  268. GList *result = NULL;
  270. array = mixer_get_rec_devices();
  271. if (!array)
  272. return NULL;
  274. i = 0;
  275. dev = array[i];
  276. while (dev)
  277. {
  278. char *text = g_strdup(dev);
  279. result = g_list_append(result, text);
  280. free(dev);
  281. dev = array[++i];
  282. }
  283. free(array);
  285. return result;
  286. }
  288. static gboolean redraw_status_window(void)
  289. {
  291. GdkWindow *real_window, *window;
  292. GdkGC *gc;
  293. int win_width, win_height;
  294. int val, freq[5], signal_strength, is_stereo;
  296. val = (int)(rint(adj->value/STEPS * 100.0));
  298. freq[0] = val / 10000;
  299. freq[1] = (val % 10000) / 1000;
  300. freq[2] = (val % 1000) / 100; 
  301. freq[3] = (val % 100) / 10;
  302. freq[4] = val % 10;
  304. signal_strength = radio_getsignal();
  305. is_stereo = radio_getstereo();
  307. if (signal_strength > 3) signal_strength = 3;
  308. if (signal_strength < 0) signal_strength = 0;
  309. is_stereo = (is_stereo == 1) ? 1 : 0;
  311. real_window = drawing_area->window;
  312. if (real_window == NULL)
  313. /* UI has not been realized yet */
  314. return TRUE;
  315. gc = gdk_gc_new(real_window);
  316. gdk_drawable_get_size(real_window, &win_width, &win_height);
  318. /* use doublebuffering to avoid flickering */
  319. window = gdk_pixmap_new(real_window, win_width, win_height, -1);
  321. gdk_draw_rectangle(window, gc, TRUE, 0, 0, win_width, win_height);
  323. win_width -= 5;
  325. if (freq[0]) gdk_draw_drawable(window, gc, digits, freq[0] * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*6, 5, DIGIT_WIDTH, DIGIT_HEIGTH);
  326. else gdk_draw_rectangle(window, gc, TRUE, win_width - DIGIT_WIDTH*6, 5, DIGIT_WIDTH, DIGIT_HEIGTH);
  328. gdk_draw_drawable(window, gc, digits, freq[1] * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*5, 5, DIGIT_WIDTH, DIGIT_HEIGTH);
  329. gdk_draw_drawable(window, gc, digits, freq[2] * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*4, 5, DIGIT_WIDTH, DIGIT_HEIGTH);
  330. gdk_draw_drawable(window, gc, digits, 10 * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*3, 5, DIGIT_WIDTH, DIGIT_HEIGTH);
  331. gdk_draw_drawable(window, gc, digits, freq[3] * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*2, 5, DIGIT_WIDTH, DIGIT_HEIGTH);
  332. gdk_draw_drawable(window, gc, digits, freq[4] * DIGIT_WIDTH, 0, win_width - DIGIT_WIDTH*1, 5, DIGIT_WIDTH, DIGIT_HEIGTH);
  333. gdk_draw_drawable(window, gc, signal_s, signal_strength * SIGNAL_WIDTH, 0, win_width - DIGIT_WIDTH*6-SIGNAL_WIDTH, 5, SIGNAL_WIDTH, DIGIT_HEIGTH);
  334. gdk_draw_drawable(window, gc, stereo, is_stereo * STEREO_WIDTH, 0, win_width - DIGIT_WIDTH*6-SIGNAL_WIDTH-STEREO_WIDTH, 5, STEREO_WIDTH, DIGIT_HEIGTH);
  336. /* draw the pixmap to the real window */
  337. gdk_draw_drawable(real_window, gc, window, 0, 0, 0, 0, win_width + 5, win_height);
  339. g_object_unref(G_OBJECT(gc));
  340. g_object_unref(G_OBJECT(window));
  342. return TRUE;
  343. }
  346. static gboolean expose_event_cb(GtkWidget *widget, GdkEventExpose *event, gpointer data)
  347. {
  348. redraw_status_window();
  349. return TRUE;
  350. }
  352. void exit_gnome_radio(void)
  353. {
  354. if (settings.mute_on_exit)
  355. {
  356. radio_mute();
  357. radio_stop();
  358. }
  359. mixer_close();
  360. save_settings();
  361. gtk_main_quit();
  362. }
  364. const char* get_preset(float freq, int *num)
  365. {
  366. GList *node = settings.presets;
  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. }
  383. static void adj_value_changed_cb(GtkAdjustment* data, gpointer window)
  384. {
  385. char *buffer;
  386. float freq = rint(adj->value)/STEPS;
  387. const char *preset_title = get_preset(freq, &mom_ps);
  389. preset_combo_set_item(mom_ps);
  391. redraw_status_window();
  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);
  399. g_free(buffer);
  401. buffer = g_strdup_printf(_("Frequency: %.2f MHz"), freq);
  402. gtk_tooltips_set_tip(tooltips, freq_scale, buffer, NULL);
  403. g_free(buffer);
  405. radio_setfreq(adj->value/STEPS);
  406. }
  408. static void volume_value_changed_cb(BaconVolumeButton *button, gpointer user_data)
  409. {
  410. char *text;
  411. int vol = (int)(bacon_volume_button_get_value(BACON_VOLUME_BUTTON(mute_button)) + 0.5f);
  413. mixer_set_volume(vol);
  415. /* text = g_strdup_printf(_("Volume: %d%%"), vol);
  416. gtk_tooltips_set_tip(tooltips, vol_scale, text, NULL);
  417. g_free(text);*/
  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);
  423. }
  425. #if 0
  426. static gboolean poll_volume_change(gpointer data)
  427. {
  428. int vol;
  429. if ((vol = mixer_get_volume()) < 0)
  430. return FALSE;
  432. if (vol != (int)volume->value)
  433. {
  434. g_print("external volume change detectedn");
  435. gtk_adjustment_set_value(volume, (double)vol);
  436. }
  438. return TRUE;
  439. }
  440. #endif
  442. static void change_frequency(gpointer data)
  443. {
  444. gboolean increase = (gboolean)data;
  446. if (increase)
  447. {
  448. if (adj->value >= FREQ_MAX*STEPS)
  449. gtk_adjustment_set_value(adj, FREQ_MIN*STEPS);
  450. else
  451. gtk_adjustment_set_value(adj, adj->value+1);
  452. }
  453. else
  454. {
  455. if (adj->value <= FREQ_MIN*STEPS)
  456. gtk_adjustment_set_value(adj, FREQ_MAX*STEPS);
  457. else
  458. gtk_adjustment_set_value(adj, adj->value-1);
  459. }
  460. }
  462. static gboolean change_frequency_timeout(gpointer data)
  463. {
  464. change_frequency(data);
  465. if (bp_timeout_steps < 10)
  466. {
  467. gtk_timeout_remove(bp_timeout_id);
  468. bp_timeout_id = gtk_timeout_add(200 - 20*bp_timeout_steps,
  469. (GtkFunction)change_frequency_timeout, data);
  470. bp_timeout_steps++; 
  471. }
  472. return TRUE;
  473. }
  475. static void step_button_pressed_cb(GtkButton *button, gpointer data)
  476. {
  477. bp_timeout_id = gtk_timeout_add(500, (GtkFunction)change_frequency_timeout, data);
  478. }
  480. static void step_button_clicked_cb(GtkButton *button, gpointer data)
  481. {
  482. change_frequency(data);
  483. }
  485. static void step_button_released_cb(GtkButton *button, gpointer data)
  486. {
  487. if (bp_timeout_id > -1)
  488. gtk_timeout_remove(bp_timeout_id);
  489. bp_timeout_id = -1;
  490. bp_timeout_steps = 0;
  491. }
  493. static gboolean scan_freq(gpointer data)
  494. {
  495. static gint start, mom, max;
  496. gint dir = (gint)(data);
  498. if (!max) {
  499. max = (FREQ_MAX - FREQ_MIN) * STEPS;
  500. }
  502. if (radio_check_station(adj->value/STEPS) || (start > max)) {
  503. start = mom = 0;
  504. radio_unmute();
  505. timeout_id = 0;
  506. return FALSE;
  507. }
  508. if (!mom) {
  509. mom = adj->value;
  510. }
  512. if (mom > FREQ_MAX*STEPS) 
  513. mom = FREQ_MIN*STEPS;
  514. else if (mom < FREQ_MIN*STEPS)
  515. mom = FREQ_MAX*STEPS;
  516. else
  517. mom = mom + dir;
  518. start += 1;
  519. gtk_adjustment_set_value(adj, mom);
  521. return TRUE;
  522. }
  524. void scfw_button_clicked_cb(GtkButton *button, gpointer data)
  525. {
  526. if (timeout_id) {
  527. gtk_timeout_remove(timeout_id);
  528. timeout_id = 0;
  529. radio_unmute();
  530. return;
  531. }
  532. radio_mute();
  533. timeout_id = gtk_timeout_add(1000/SCAN_SPEED, (GtkFunction)scan_freq, (gpointer)1);
  534. }
  536. void scbw_button_clicked_cb(GtkButton *button, gpointer data)
  537. {
  538. if (timeout_id) {
  539. gtk_timeout_remove(timeout_id);
  540. timeout_id = 0;
  541. radio_unmute();
  542. return;
  543. }
  544. radio_mute();
  545. timeout_id = gtk_timeout_add(1000/SCAN_SPEED, (GtkFunction)scan_freq, (gpointer)(-1));
  546. }
  548. void preset_combo_set_item(gint i)
  549. {
  550. if (i < -1) return;
  551. if (preset_combo == NULL) return;
  552. gtk_combo_box_set_active(GTK_COMBO_BOX(preset_combo), i + 1);
  553. }
  555. static void preset_combo_change_cb(GtkWidget *combo, gpointer data)
  556. {
  557. preset* ps;
  558. mom_ps = gtk_combo_box_get_active(GTK_COMBO_BOX(combo)) - 1;
  560. if (mom_ps < 0) return;
  562. ps = (preset*)g_list_nth_data(settings.presets, mom_ps);
  563. gtk_adjustment_set_value(adj, ps->freq * STEPS);
  564. }
  566. void change_preset(gboolean next)
  567. {
  568. preset *ps;
  569. int len = g_list_length(settings.presets);
  570. if (len < 1)
  571. return;
  573. if (next)
  574. mom_ps = (mom_ps + 1) % len;
  575. else
  576. mom_ps = (mom_ps - 1 + len) % len;
  578. ps = g_list_nth_data(settings.presets, mom_ps);
  579. gtk_adjustment_set_value(adj, ps->freq*STEPS);
  580. preset_combo_set_item(mom_ps);
  581. }
  583. static void quit_button_clicked_cb(GtkButton *button, gpointer data)
  584. {
  585. exit_gnome_radio();
  586. }
  588. void tray_icon_items_set_sensible(gboolean sensible)
  589. {
  590. GList* menuitems;
  591. GtkWidget *menuitem;
  592. int i, cnt = g_list_length(settings.presets);
  595. menuitems = GTK_MENU_SHELL(tray_menu)->children;
  597. g_assert(cnt + 6 == g_list_length(menuitems));
  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. }
  605. /* Disable the mute button (separator => +1) */
  606. menuitem = g_list_nth_data(menuitems, cnt + 1);
  607. gtk_widget_set_sensitive(menuitem, sensible);
  609. /* Disable the record button */
  610. menuitem = g_list_nth_data(menuitems, cnt + 2);
  611. gtk_widget_set_sensitive(menuitem, sensible);
  613. /* Disable the quit button */
  614. menuitem = g_list_nth_data(menuitems, cnt + 5);
  615. gtk_widget_set_sensitive(menuitem, sensible);
  616. }
  618. static int start_recording(const gchar *destination, const char* station, const char* time)
  619. {
  620. GtkWidget *dialog;
  621. Recording* recording;
  622. char *filename;
  624. if (!mixer_set_rec_device())
  625. {
  626. GtkWidget *dialog;
  627. dialog = gtk_message_dialog_new(NULL, DIALOG_FLAGS, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
  628. "Could not set "%s" as recording Source", settings.mixer);
  629. gtk_dialog_run (GTK_DIALOG (dialog));
  630. gtk_widget_destroy (dialog);
  631. return -1;
  632. }
  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;
  646. tray_icon_items_set_sensible(FALSE);
  648. recording->station = g_strdup(station);
  649. dialog = record_status_window(recording);
  651. run_status_window(recording);
  653. return 1;
  654. }
  656. void rec_button_clicked_cb(GtkButton *button, gpointer app)
  657. {
  658. GtkWidget *dialog;
  659. char *station;
  660. char time_str[100];
  661. time_t t;
  663. t = time(NULL);
  664. /* consult man strftime to translate this. This is a filename, so don't use "/" or ":", please */
  665. strftime(time_str, 100, _("%B-%d-%Y_%H-%M-%S"), localtime(&t));
  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);
  674. station = g_strdup(ps->title);
  675. }
  677. /* if (!check_filename(filename)) {
  678. GtkWidget *errdialog;
  679. errdialog = gtk_message_dialog_new(GTK_WINDOW(app), DIALOG_FLAGS, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
  680. _("Error opening file '%s':n%s"), filename, strerror(errno));
  681. gtk_dialog_run (GTK_DIALOG (errdialog));
  682. gtk_widget_destroy (errdialog);
  683. } else */
  684. start_recording(rec_settings.destination, station, time_str);
  685. g_free(station);
  686. }
  688. void toggle_volume(void)
  689. {
  690. static int old_vol;
  691. int vol = mixer_get_volume();
  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. }
  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
  711. {
  712. gtk_tooltips_set_tip(tooltips, mute_button, _("Mute"), NULL);
  713. }
  714. toggle_volume();
  715. }
  717. static void about_button_clicked_cb(GtkButton *button, gpointer data)
  718. {
  719. GdkPixbuf *app_icon;
  720. GtkIconTheme *icontheme;
  721. static GtkWidget *about;
  722. const char *authors[] = {"J枚rgen Scheibengruber <mfcn@gmx.de>", NULL};
  723. char *text;
  725. /* Feel free to put your names here translators :-) */
  726. char *translators = _("TRANSLATORS");
  728. if (about)
  729. {
  730. gtk_window_present(GTK_WINDOW(about));
  731. return;
  732. }
  733. icontheme = gtk_icon_theme_get_default();
  734. app_icon = gtk_icon_theme_load_icon(icontheme, "gnomeradio", 48, 0, NULL);
  736. #ifdef HAVE_LIRC
  737. text =_("Gnomeradio is a FM-Tuner application for the GNOME desktop. "
  738. "It should work with all tuner hardware that is supported by the video4linux drivers.nn"
  739. "This version has been compiled with LIRC support.");
  740. #else
  741. text =_("Gnomeradio is a FM-Tuner application for the GNOME desktop. "
  742. "It should work with all tuner hardware that is supported by the video4linux drivers.nn"
  743. "This version has been compiled without LIRC support.");
  744. #endif
  746. about = gnome_about_new ("Gnomeradio", VERSION, "Copyright 2001 - 2006 J枚rgen Scheibengruber",
  747. text, (const char **) authors, NULL, 
  748. strcmp("TRANSLATORS", translators) ? translators : NULL, 
  749. app_icon);
  751. gtk_widget_show(about);
  752. g_object_add_weak_pointer(G_OBJECT(about), (gpointer)&about);
  753. g_object_add_weak_pointer(G_OBJECT(about), (gpointer)&app_icon);
  754. }
  756. static gint delete_event_cb(GtkWidget* window, GdkEventAny* e, gpointer data)
  757. {
  758. exit_gnome_radio();
  759. return TRUE;
  760. }
  762. void display_help_cb(char *topic)
  763. {
  764. GError *error = NULL;
  766. gnome_help_display(PACKAGE, topic, &error);
  767. if (error)
  768. {
  769. GtkWidget *dialog;
  770. dialog = gtk_message_dialog_new(NULL, DIALOG_FLAGS, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
  771. error->message);
  772. gtk_dialog_run (GTK_DIALOG (dialog));
  773. gtk_widget_destroy (dialog);
  774. g_error_free (error);
  775. error = NULL;
  776. }
  777. }
  779. void toggle_mainwindow_visibility(GtkWidget *app)
  780. {
  781. static gint posx, posy;
  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. }
  795. GtkWidget* gnome_radio_gui(void)
  796. {
  797. GtkWidget *app;
  798. GtkWidget *prefs_button, *quit_button, *scfw_button, *scbw_button;
  799. GtkWidget *stfw_button, *stbw_button, *about_button, *rec_button;
  800. GtkWidget *prefs_pixmap, *quit_pixmap, *scfw_pixmap, *scbw_pixmap;
  801. GtkWidget *stfw_pixmap, *stbw_pixmap, *about_pixmap;
  802. GtkWidget *vol_up_pixmap, *vol_down_pixmap, *freq_up_pixmap, *freq_down_pixmap;
  803. GdkPixbuf *vol_up_pixbuf, *vol_down_pixbuf, *freq_up_pixbuf, *freq_down_pixbuf;
  804. GtkWidget *hbox1, *hbox2, *vbox, *menubox, *freq_vol_box;
  805. GtkWidget *vseparator1, *vseparator2, *vseparator4;
  806. GtkWidget *label;
  807. GtkWidget *frame;
  808. gchar *text;
  810. app = gnome_app_new(PACKAGE, _("Gnomeradio"));
  812. gtk_window_set_resizable(GTK_WINDOW(app), FALSE);
  813. /*gtk_window_set_policy(GTK_WINDOW(app), FALSE, FALSE, FALSE);*/
  814. gtk_window_set_wmclass(GTK_WINDOW(app), "gnomeradio", "Gnomeradio");
  816. frame = gtk_frame_new(NULL);
  818. quit_pixmap = gtk_image_new_from_stock(GTK_STOCK_QUIT, GTK_ICON_SIZE_BUTTON);
  819. prefs_pixmap = gtk_image_new_from_stock(GTK_STOCK_PROPERTIES, GTK_ICON_SIZE_LARGE_TOOLBAR);
  820. scfw_pixmap = gtk_image_new_from_stock(GTK_STOCK_MEDIA_FORWARD, GTK_ICON_SIZE_LARGE_TOOLBAR);
  821. scbw_pixmap = gtk_image_new_from_stock(GTK_STOCK_MEDIA_REWIND, GTK_ICON_SIZE_LARGE_TOOLBAR);
  822. stfw_pixmap = gtk_image_new_from_stock(GTK_STOCK_MEDIA_NEXT, GTK_ICON_SIZE_LARGE_TOOLBAR);
  823. stbw_pixmap = gtk_image_new_from_stock(GTK_STOCK_MEDIA_PREVIOUS, GTK_ICON_SIZE_LARGE_TOOLBAR);
  824. about_pixmap = gtk_image_new_from_stock(GTK_STOCK_ABOUT, GTK_ICON_SIZE_LARGE_TOOLBAR);
  825. /*mute_pixmap = gtk_image_new_from_stock(GNOME_STOCK_VOLUME, GTK_ICON_SIZE_LARGE_TOOLBAR);*/
  826. rec_pixmap = gtk_image_new_from_stock(GTK_STOCK_MEDIA_RECORD, GTK_ICON_SIZE_LARGE_TOOLBAR);
  827. /*help_pixmap = gtk_image_new_from_stock(GTK_STOCK_HELP, GTK_ICON_SIZE_LARGE_TOOLBAR);*/
  829. quit_button = gtk_button_new();
  830. prefs_button = gtk_button_new();
  831. scfw_button = gtk_button_new();
  832. scbw_button = gtk_button_new();
  833. stfw_button = gtk_button_new();
  834. stbw_button = gtk_button_new();
  835. about_button = gtk_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);
  839. rec_button = gtk_button_new();
  840. /*help_button = gtk_button_new();*/
  842. gtk_container_add(GTK_CONTAINER(quit_button), quit_pixmap);
  843. gtk_container_add(GTK_CONTAINER(prefs_button), prefs_pixmap);
  844. gtk_container_add(GTK_CONTAINER(scfw_button), scfw_pixmap);
  845. gtk_container_add(GTK_CONTAINER(scbw_button), scbw_pixmap);
  846. gtk_container_add(GTK_CONTAINER(stfw_button), stfw_pixmap);
  847. gtk_container_add(GTK_CONTAINER(stbw_button), stbw_pixmap);
  848. gtk_container_add(GTK_CONTAINER(about_button), about_pixmap);
  849. /*gtk_container_add(GTK_CONTAINER(mute_button), mute_pixmap);*/
  850. gtk_container_add(GTK_CONTAINER(rec_button), rec_pixmap);
  851. /*gtk_container_add(GTK_CONTAINER(help_button), help_pixmap);*/
  853. vbox = gtk_vbox_new(FALSE, 0);
  854. hbox1 = gtk_hbox_new(FALSE, 0);
  855. hbox2 = gtk_hbox_new(FALSE, 0);
  856. menubox = gtk_vbox_new(FALSE, 0);
  857. freq_vol_box = gtk_hbox_new(FALSE, 0);
  859. adj = GTK_ADJUSTMENT(gtk_adjustment_new(SUNSHINE*STEPS, FREQ_MIN*STEPS, FREQ_MAX*STEPS+1, 1, STEPS, 1));
  860. /* volume = GTK_ADJUSTMENT(gtk_adjustment_new(100, 0, 101, 1, 10, 1)); */
  862. preset_combo = gtk_combo_box_new_text();
  863. g_signal_connect(GTK_OBJECT(preset_combo), "changed", GTK_SIGNAL_FUNC(preset_combo_change_cb), NULL);
  865. gtk_widget_set_size_request(preset_combo, 10, -1);
  866. label = gtk_label_new(_("Presets:"));
  868. freq_scale = gtk_hscale_new(adj);
  869. /*gtk_range_set_update_policy(GTK_RANGE(freq_scale), GTK_UPDATE_DELAYED);*/
  870. /*vol_scale = gtk_hscale_new(volume);*/
  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);*/
  874. freq_up_pixbuf = gdk_pixbuf_new_from_xpm_data((const char**)freq_up_xpm);
  875. freq_down_pixbuf = gdk_pixbuf_new_from_xpm_data((const char**)freq_down_xpm);
  877. /*vol_up_pixmap = gtk_image_new_from_pixbuf(vol_up_pixbuf);
  878. vol_down_pixmap = gtk_image_new_from_pixbuf(vol_down_pixbuf);*/
  879. freq_up_pixmap = gtk_image_new_from_pixbuf(freq_up_pixbuf);
  880. freq_down_pixmap = gtk_image_new_from_pixbuf(freq_down_pixbuf);
  882. /*gtk_widget_set_usize(freq_scale, 160, 10);*/
  883. /*gtk_widget_set_size_request(freq_scale, 160, -1);*/
  885. gtk_widget_realize(app);
  886. drawing_area = gtk_drawing_area_new();
  887. digits = gdk_pixmap_create_from_xpm_d (app->window, NULL, NULL, digits_xpm);
  888. signal_s = gdk_pixmap_create_from_xpm_d (app->window, NULL, NULL, signal_xpm);
  889. stereo = gdk_pixmap_create_from_xpm_d (app->window, NULL, NULL, stereo_xpm);
  891. vseparator1 = gtk_vseparator_new();
  892. vseparator2 = gtk_vseparator_new();
  893. /*vseparator3 = gtk_vseparator_new();*/
  894. vseparator4 = gtk_vseparator_new();
  896. gtk_scale_set_digits(GTK_SCALE(freq_scale), 0);
  897. gtk_scale_set_draw_value(GTK_SCALE(freq_scale), FALSE);
  898. /* gtk_scale_set_digits(GTK_SCALE(vol_scale), 0);
  899. gtk_scale_set_draw_value(GTK_SCALE(vol_scale), FALSE);
  901. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mute_button), mixer_get_volume() == 0);*/
  903. gtk_widget_set_size_request(drawing_area, DIGIT_WIDTH*6+10+SIGNAL_WIDTH+STEREO_WIDTH, DIGIT_HEIGTH+10);
  905. gtk_container_add(GTK_CONTAINER(frame), drawing_area);
  907. gtk_box_pack_start(GTK_BOX(hbox2), scbw_button, FALSE, FALSE, 2);
  908. gtk_box_pack_start(GTK_BOX(hbox2), stbw_button, FALSE, FALSE, 2);
  909. gtk_box_pack_start(GTK_BOX(hbox2), stfw_button, FALSE, FALSE, 2);
  910. gtk_box_pack_start(GTK_BOX(hbox2), scfw_button, FALSE, FALSE, 2);
  911. gtk_box_pack_start(GTK_BOX(hbox2), vseparator1, FALSE, FALSE, 2);
  912. gtk_box_pack_start(GTK_BOX(hbox2), mute_button, FALSE, FALSE, 2);
  913. /*gtk_box_pack_start(GTK_BOX(hbox2), vseparator2, TRUE, TRUE, 3);*/
  914. gtk_box_pack_start(GTK_BOX(hbox2), rec_button, FALSE, FALSE, 2);
  915. gtk_box_pack_start(GTK_BOX(hbox2), vseparator4, FALSE, FALSE, 2);
  916. /*gtk_box_pack_start(GTK_BOX(hbox2), help_button, FALSE, FALSE, 2);*/
  917. gtk_box_pack_start(GTK_BOX(hbox2), prefs_button, FALSE, FALSE, 2);
  918. gtk_box_pack_start(GTK_BOX(hbox2), about_button, FALSE, FALSE, 2);
  919. /*gtk_box_pack_start(GTK_BOX(hbox2), quit_button, FALSE, FALSE, 2);*/
  921. gtk_box_pack_start(GTK_BOX(hbox1), frame, FALSE, FALSE, 3);
  922. gtk_box_pack_start(GTK_BOX(hbox1), menubox, TRUE, TRUE, 3);
  924. gtk_box_pack_start(GTK_BOX(menubox), label, TRUE, TRUE, 0);
  925. gtk_box_pack_start(GTK_BOX(menubox), preset_combo, TRUE, TRUE, 0);
  927. gtk_box_pack_start(GTK_BOX(freq_vol_box), freq_down_pixmap, FALSE, FALSE, 2);
  928. gtk_box_pack_start(GTK_BOX(freq_vol_box), freq_scale, TRUE, TRUE, 0);
  929. gtk_box_pack_start(GTK_BOX(freq_vol_box), freq_up_pixmap, FALSE, FALSE, 2);
  930. /*gtk_box_pack_start(GTK_BOX(freq_vol_box), vseparator3, FALSE, FALSE, 2);
  931. gtk_box_pack_start(GTK_BOX(freq_vol_box), vol_down_pixmap, FALSE, FALSE, 2);
  932. gtk_box_pack_start(GTK_BOX(freq_vol_box), vol_scale, TRUE, TRUE, 0);
  933. gtk_box_pack_start(GTK_BOX(freq_vol_box), vol_up_pixmap, FALSE, FALSE, 2);*/
  935. gtk_box_pack_start(GTK_BOX(vbox), hbox1, FALSE, FALSE, 4);
  936. gtk_box_pack_start(GTK_BOX(vbox), freq_vol_box, TRUE, TRUE, 2);
  937. gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 4);
  939. gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
  941. gtk_container_set_border_width(GTK_CONTAINER(vbox), 3);
  942. gtk_container_set_border_width(GTK_CONTAINER(frame), 2);
  944. gnome_app_set_contents(GNOME_APP(app), vbox);
  946. /*status = gnome_appbar_new(FALSE, TRUE, GNOME_PREFERENCES_NEVER);*/
  948. /*gnome_app_set_statusbar(GNOME_APP(app), status);*/
  950. tooltips = gtk_tooltips_new();
  952. g_signal_connect(GTK_OBJECT(app), "delete_event", GTK_SIGNAL_FUNC(delete_event_cb), NULL);
  953. g_signal_connect(GTK_OBJECT(quit_button), "clicked", GTK_SIGNAL_FUNC(quit_button_clicked_cb), NULL);
  954. g_signal_connect(GTK_OBJECT(adj), "value-changed", GTK_SIGNAL_FUNC(adj_value_changed_cb), (gpointer) app);
  955. g_signal_connect(GTK_OBJECT(mute_button), "value-changed", GTK_SIGNAL_FUNC(volume_value_changed_cb), NULL);
  956. g_signal_connect(GTK_OBJECT(stfw_button), "pressed", GTK_SIGNAL_FUNC(step_button_pressed_cb), (gpointer)TRUE);
  957. g_signal_connect(GTK_OBJECT(stbw_button), "pressed", GTK_SIGNAL_FUNC(step_button_pressed_cb), (gpointer)FALSE);
  958. g_signal_connect(GTK_OBJECT(stfw_button), "clicked", GTK_SIGNAL_FUNC(step_button_clicked_cb), (gpointer)TRUE);
  959. g_signal_connect(GTK_OBJECT(stbw_button), "clicked", GTK_SIGNAL_FUNC(step_button_clicked_cb), (gpointer)FALSE);
  960. g_signal_connect(GTK_OBJECT(stfw_button), "released", GTK_SIGNAL_FUNC(step_button_released_cb), NULL);
  961. g_signal_connect(GTK_OBJECT(stbw_button), "released", GTK_SIGNAL_FUNC(step_button_released_cb), NULL);
  962. g_signal_connect(GTK_OBJECT(scfw_button), "clicked", GTK_SIGNAL_FUNC(scfw_button_clicked_cb), NULL);
  963. g_signal_connect(GTK_OBJECT(scbw_button), "clicked", GTK_SIGNAL_FUNC(scbw_button_clicked_cb), NULL);
  964. g_signal_connect(GTK_OBJECT(about_button), "clicked", GTK_SIGNAL_FUNC(about_button_clicked_cb), NULL);
  965. g_signal_connect(GTK_OBJECT(rec_button), "clicked", GTK_SIGNAL_FUNC(rec_button_clicked_cb), (gpointer) app);
  966. g_signal_connect(GTK_OBJECT(prefs_button), "clicked", GTK_SIGNAL_FUNC(prefs_button_clicked_cb), (gpointer) app);
  967. g_signal_connect(GTK_OBJECT(drawing_area), "expose-event", GTK_SIGNAL_FUNC(expose_event_cb), NULL);
  969. gtk_tooltips_set_tip(tooltips, scbw_button, _("Scan Backwards"), NULL);
  970. gtk_tooltips_set_tip(tooltips, scfw_button, _("Scan Forwards"), NULL);
  971. gtk_tooltips_set_tip(tooltips, stbw_button, _("0.05 MHz Backwards"), NULL);
  972. gtk_tooltips_set_tip(tooltips, stfw_button, _("0.05 MHz Forwards"), NULL);
  973. gtk_tooltips_set_tip(tooltips, about_button, _("About Gnomeradio"), NULL);
  974. gtk_tooltips_set_tip(tooltips, rec_button, _("Record radio as Wave, OGG or MP3"), NULL);
  975. gtk_tooltips_set_tip(tooltips, prefs_button, _("Edit your Preferences"), NULL);
  976. gtk_tooltips_set_tip(tooltips, mute_button, _("Adjust the Volume"), NULL);
  977. gtk_tooltips_set_tip(tooltips, quit_button, _("Quit"), NULL);
  978. text = g_strdup_printf(_("Frequency: %.2f MHz"), adj->value/STEPS);
  979. gtk_tooltips_set_tip(tooltips, freq_scale, text, NULL);
  980. g_free(text);
  981. /* text = g_strdup_printf(_("Volume: %d%%"), (gint)volume->value);
  982. gtk_tooltips_set_tip(tooltips, vol_scale, text, NULL);
  983. g_free(text);*/
  985. return app;
  986. }
  988. static void
  989. session_die_cb(GnomeClient* client, gpointer client_data)
  990. {
  991. if (settings.mute_on_exit)
  992. {
  993. radio_mute();
  994. radio_stop();
  995. }
  996. mixer_close();
  997. gtk_main_quit();
  998. exit (0);
  999. }
  1001. static void 
  1002. save_session_cb(GnomeClient *client, gint phase, GnomeSaveStyle save_style,
  1003. gint is_shutdown, GnomeInteractStyle interact_style,
  1004. gint is_fast, gpointer client_data)
  1005. {
  1006. save_settings();
  1007. }
  1009. static void
  1010. gconf_error_handler(GConfClient *client, GError *error)
  1011. {
  1012. g_print("GConf error: %sn", error->message);
  1013. }
  1015. static gboolean
  1016. key_press_event_cb(GtkWidget *app, GdkEventKey *event, gpointer data)
  1017. {
  1018. int vol = (int)(bacon_volume_button_get_value(BACON_VOLUME_BUTTON(mute_button)) + 0.5f);
  1020. switch (event->keyval)
  1021. {
  1022. case GDK_F1: display_help_cb(NULL);
  1023. break;
  1024. case GDK_m: 
  1025. toggle_volume();
  1026. break;
  1027. case GDK_q: 
  1028. exit_gnome_radio();
  1029. break;
  1030. case GDK_r: 
  1031. rec_button_clicked_cb(NULL, app);
  1032. break;
  1033. case GDK_f: 
  1034. scfw_button_clicked_cb(NULL, NULL);
  1035. break;
  1036. case GDK_b: 
  1037. scbw_button_clicked_cb(NULL, NULL);
  1038. break;
  1039. case GDK_n: 
  1040. change_preset(TRUE);
  1041. break;
  1042. case GDK_p: 
  1043. change_preset(FALSE);
  1044. break;
  1045. case GDK_KP_Add:
  1046. case GDK_plus:
  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);*/
  1049. break;
  1050. case GDK_minus:
  1051. case GDK_KP_Subtract: 
  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);*/
  1054. break;
  1055. }
  1056. return FALSE;
  1057. }
  1059. int main(int argc, char* argv[])
  1060. {
  1061. GtkWidget* app;
  1062. GList *ptr;
  1063. GnomeClient *client;
  1064. GError *err = NULL;
  1065. int redraw_timeout_id;
  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
  1074. bindtextdomain(PACKAGE, GNOMELOCALEDIR);  
  1075. bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
  1076. textdomain(PACKAGE);
  1078. g_set_application_name(_("Gnomeradio"));
  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
  1087. gnome_program_init(PACKAGE, VERSION, 
  1088. LIBGNOMEUI_MODULE, argc, argv, 
  1089. GNOME_PROGRAM_STANDARD_PROPERTIES,
  1090. #if GNOME_14
  1091. GNOME_PARAM_GOPTION_CONTEXT, ctx,
  1092. #endif
  1093. NULL);
  1094. gtk_window_set_default_icon_name("gnomeradio");
  1095. /* Main app */
  1096. app = gnome_radio_gui();
  1098. /* Initizialize GStreamer */
  1099. gst_init(&argc, &argv);
  1101. /* Initizialize Gconf */
  1102. if (!gconf_init(argc, argv, &err)) {
  1103. char *details;
  1104. details = g_strdup_printf(_("%snnChanges to the settings won't be saved."), err->message);
  1105. show_warning_message(_("Failed to init GConf!"), details);
  1106. g_error_free(err); 
  1107. g_free(details);
  1108. err = NULL;
  1109. } else {
  1110. gconf_client_set_global_default_error_handler((GConfClientErrorHandlerFunc)gconf_error_handler);
  1111. gconf_client_set_error_handling(gconf_client_get_default(),  GCONF_CLIENT_HANDLE_ALL);
  1112. gnome_media_profiles_init(gconf_client_get_default());
  1113. }
  1115. load_settings();
  1116. create_tray_menu(app);
  1118. gtk_combo_box_append_text(GTK_COMBO_BOX(preset_combo), _("manual"));
  1119. for (ptr = settings.presets; ptr; ptr = g_list_next(ptr)) {
  1120. preset *ps = (preset*)ptr->data;
  1121. gtk_combo_box_append_text(GTK_COMBO_BOX(preset_combo), ps->title);
  1122. }
  1123. preset_combo_set_item(mom_ps);
  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);
  1137. /* Create an tray icon */
  1138. create_tray_icon(app);
  1140. adj_value_changed_cb(NULL, (gpointer) app);
  1141. /*volume_value_changed_cb(NULL, NULL);*/
  1143. #ifdef HAVE_LIRC
  1144. if(!my_lirc_init())
  1145. {
  1146. /* GtkWidget *dialog;
  1147. dialog = gtk_message_dialog_new(NULL, DIALOG_FLAGS, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
  1148. _("Could not start lirc"));
  1149. gtk_dialog_run (GTK_DIALOG (dialog));
  1150. gtk_widget_destroy (dialog);
  1151. */
  1152. g_message(_("Could not start lirc!"));
  1153. }
  1154. else
  1155. start_lirc();
  1156. #endif
  1158. /* Connect the Session Management signals
  1159.  */
  1160. client = gnome_master_client();
  1161. g_signal_connect(GTK_OBJECT(client), "save_yourself",
  1162. GTK_SIGNAL_FUNC(save_session_cb), NULL);
  1163. g_signal_connect(GTK_OBJECT(client), "die",
  1164. GTK_SIGNAL_FUNC(session_die_cb), NULL);
  1165. g_signal_connect(GTK_OBJECT(app), "key-press-event",
  1166. GTK_SIGNAL_FUNC(key_press_event_cb), NULL);
  1168. /* Redraw the status window every 3 seconds
  1169.  * Necessary, because the mono/stereo reception
  1170.  * needs some time to be correctly detected
  1171.  */
  1172. redraw_timeout_id = gtk_timeout_add(3000, (GtkFunction)redraw_status_window, NULL);
  1174. /* Checks if the volume has been changed by an 
  1175.  * external app
  1176.  */
  1177. /*gtk_timeout_add(100, (GtkFunction)poll_volume_change, NULL);*/
  1179. gtk_main();
  1181. #ifdef HAVE_LIRC
  1182. my_lirc_deinit();
  1183. #endif
  1185. return 0;
  1186. }
  1188. static show_message(GtkMessageType type, const char* text, const char* details)
  1189. {
  1190. GtkWidget *dialog;
  1192. g_assert(text);
  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. }
  1203. void show_error_message(const char* error, const char* details)
  1204. {
  1205. show_message(GTK_MESSAGE_ERROR, error, details);
  1206. }
  1208. void show_warning_message(const char* warning, const char* details)
  1209. {
  1210. show_message(GTK_MESSAGE_WARNING, warning, details);
  1211. }