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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
configure.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：39k
源码类别：

Windows CE

开发平台：

C/C++

configure.c：源码内容
  1. /* libxmms-flac - XMMS FLAC input plugin
  2.  * Copyright (C) 2002,2003,2004,2005  Daisuke Shimamura
  3.  *
  4.  * Based on mpg123 plugin
  5.  *          and prefs.c - 2000/05/06
  6.  *  EasyTAG - Tag editor for MP3 and OGG files
  7.  *  Copyright (C) 2000-2002  Jerome Couderc <j.couderc@ifrance.com>
  8.  *
  9.  * This program is free software; you can redistribute it and/or
  10.  * modify it under the terms of the GNU General Public License
  11.  * as published by the Free Software Foundation; either version 2
  12.  * of the License, or (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22.  */
  24. #include <stdlib.h>
  25. #include <string.h>
  26. #include <glib.h>
  27. #include <gtk/gtk.h>
  28. #include <pthread.h>
  29. #include <math.h>
  31. #include <xmms/configfile.h>
  32. #include <xmms/dirbrowser.h>
  33. #include <xmms/titlestring.h>
  34. #include <xmms/util.h>
  35. #include <xmms/plugin.h>
  37. #include "plugin_common/locale_hack.h"
  38. #include "share/replaygain_synthesis.h" /* for NOISE_SHAPING_LOW */
  39. #include "charset.h"
  40. #include "configure.h"
  42. /*
  43.  * Initialize Global Valueable
  44.  */
  45. flac_config_t flac_cfg = {
  46. /* title */
  47. {
  48. FALSE, /* tag_override */
  49. NULL, /* tag_format */
  50. FALSE, /* convert_char_set */
  51. NULL /* user_char_set */
  52. },
  53. /* stream */
  54. {
  55. 100 /* KB */, /* http_buffer_size */
  56. 50, /* http_prebuffer */
  57. FALSE, /* use_proxy */
  58. "", /* proxy_host */
  59. 0, /* proxy_port */
  60. FALSE, /* proxy_use_auth */
  61. "", /* proxy_user */
  62. "", /* proxy_pass */
  63. FALSE, /* save_http_stream */
  64. "", /* save_http_path */
  65. FALSE, /* cast_title_streaming */
  66. FALSE /* use_udp_channel */
  67. },
  68. /* output */
  69. {
  70. /* replaygain */
  71. {
  72. FALSE, /* enable */
  73. TRUE, /* album_mode */
  74. 0, /* preamp */
  75. FALSE /* hard_limit */
  76. },
  77. /* resolution */
  78. {
  79. /* normal */
  80. {
  81. TRUE /* dither_24_to_16 */
  82. },
  83. /* replaygain */
  84. {
  85. TRUE, /* dither */
  86. NOISE_SHAPING_LOW, /* noise_shaping */
  87. 16 /* bps_out */
  88. }
  89. }
  90. }
  91. };
  94. static GtkWidget *flac_configurewin = NULL;
  95. static GtkWidget *vbox, *notebook;
  97. static GtkWidget *title_tag_override, *title_tag_box, *title_tag_entry, *title_desc;
  98. static GtkWidget *convert_char_set, *fileCharacterSetEntry, *userCharacterSetEntry;
  99. static GtkWidget *replaygain_enable, *replaygain_album_mode;
  100. static GtkWidget *replaygain_preamp_hscale, *replaygain_preamp_label, *replaygain_hard_limit;
  101. static GtkObject *replaygain_preamp;
  102. static GtkWidget *resolution_normal_dither_24_to_16;
  103. static GtkWidget *resolution_replaygain_dither;
  104. static GtkWidget *resolution_replaygain_noise_shaping_frame;
  105. static GtkWidget *resolution_replaygain_noise_shaping_radio_none;
  106. static GtkWidget *resolution_replaygain_noise_shaping_radio_low;
  107. static GtkWidget *resolution_replaygain_noise_shaping_radio_medium;
  108. static GtkWidget *resolution_replaygain_noise_shaping_radio_high;
  109. static GtkWidget *resolution_replaygain_bps_out_frame;
  110. static GtkWidget *resolution_replaygain_bps_out_radio_16bps;
  111. static GtkWidget *resolution_replaygain_bps_out_radio_24bps;
  113. static GtkObject *streaming_size_adj, *streaming_pre_adj;
  114. static GtkWidget *streaming_proxy_use, *streaming_proxy_host_entry;
  115. static GtkWidget *streaming_proxy_port_entry, *streaming_save_use, *streaming_save_entry;
  116. static GtkWidget *streaming_proxy_auth_use;
  117. static GtkWidget *streaming_proxy_auth_pass_entry, *streaming_proxy_auth_user_entry;
  118. static GtkWidget *streaming_proxy_auth_user_label, *streaming_proxy_auth_pass_label;
  119. #ifdef FLAC_ICECAST
  120. static GtkWidget *streaming_cast_title, *streaming_udp_title;
  121. #endif
  122. static GtkWidget *streaming_proxy_hbox, *streaming_proxy_auth_hbox, *streaming_save_dirbrowser;
  123. static GtkWidget *streaming_save_hbox;
  125. static gchar *gtk_entry_get_text_1 (GtkWidget *widget);
  126. static void flac_configurewin_ok(GtkWidget * widget, gpointer data);
  127. static void configure_destroy(GtkWidget * w, gpointer data);
  129. static void flac_configurewin_ok(GtkWidget * widget, gpointer data)
  130. {
  131. ConfigFile *cfg;
  132. gchar *filename;
  134. (void)widget, (void)data; /* unused arguments */
  135. g_free(flac_cfg.title.tag_format);
  136. flac_cfg.title.tag_format = g_strdup(gtk_entry_get_text(GTK_ENTRY(title_tag_entry)));
  137. flac_cfg.title.user_char_set = Charset_Get_Name_From_Title(gtk_entry_get_text_1(userCharacterSetEntry));
  139. filename = g_strconcat(g_get_home_dir(), "/.xmms/config", NULL);
  140. cfg = xmms_cfg_open_file(filename);
  141. if (!cfg)
  142. cfg = xmms_cfg_new();
  143. /* title */
  144. xmms_cfg_write_boolean(cfg, "flac", "title.tag_override", flac_cfg.title.tag_override);
  145. xmms_cfg_write_string(cfg, "flac", "title.tag_format", flac_cfg.title.tag_format);
  146. xmms_cfg_write_boolean(cfg, "flac", "title.convert_char_set", flac_cfg.title.convert_char_set);
  147. xmms_cfg_write_string(cfg, "flac", "title.user_char_set", flac_cfg.title.user_char_set);
  148. /* output */
  149. xmms_cfg_write_boolean(cfg, "flac", "output.replaygain.enable", flac_cfg.output.replaygain.enable);
  150. xmms_cfg_write_boolean(cfg, "flac", "output.replaygain.album_mode", flac_cfg.output.replaygain.album_mode);
  151. xmms_cfg_write_int(cfg, "flac", "output.replaygain.preamp", flac_cfg.output.replaygain.preamp);
  152. xmms_cfg_write_boolean(cfg, "flac", "output.replaygain.hard_limit", flac_cfg.output.replaygain.hard_limit);
  153. xmms_cfg_write_boolean(cfg, "flac", "output.resolution.normal.dither_24_to_16", flac_cfg.output.resolution.normal.dither_24_to_16);
  154. xmms_cfg_write_boolean(cfg, "flac", "output.resolution.replaygain.dither", flac_cfg.output.resolution.replaygain.dither);
  155. xmms_cfg_write_int(cfg, "flac", "output.resolution.replaygain.noise_shaping", flac_cfg.output.resolution.replaygain.noise_shaping);
  156. xmms_cfg_write_int(cfg, "flac", "output.resolution.replaygain.bps_out", flac_cfg.output.resolution.replaygain.bps_out);
  157. /* streaming */
  158. flac_cfg.stream.http_buffer_size = (gint) GTK_ADJUSTMENT(streaming_size_adj)->value;
  159. flac_cfg.stream.http_prebuffer = (gint) GTK_ADJUSTMENT(streaming_pre_adj)->value;
  161. flac_cfg.stream.use_proxy = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_proxy_use));
  162. g_free(flac_cfg.stream.proxy_host);
  163. flac_cfg.stream.proxy_host = g_strdup(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_host_entry)));
  164. flac_cfg.stream.proxy_port = atoi(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_port_entry)));
  166. flac_cfg.stream.proxy_use_auth = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_proxy_auth_use));
  168. if(flac_cfg.stream.proxy_user)
  169. g_free(flac_cfg.stream.proxy_user);
  170. flac_cfg.stream.proxy_user = NULL;
  171. if(strlen(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_auth_user_entry))) > 0)
  172. flac_cfg.stream.proxy_user = g_strdup(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_auth_user_entry)));
  174. if(flac_cfg.stream.proxy_pass)
  175. g_free(flac_cfg.stream.proxy_pass);
  176. flac_cfg.stream.proxy_pass = NULL;
  177. if(strlen(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_auth_pass_entry))) > 0)
  178. flac_cfg.stream.proxy_pass = g_strdup(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_auth_pass_entry)));
  181. flac_cfg.stream.save_http_stream = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_save_use));
  182. if (flac_cfg.stream.save_http_path)
  183. g_free(flac_cfg.stream.save_http_path);
  184. flac_cfg.stream.save_http_path = g_strdup(gtk_entry_get_text(GTK_ENTRY(streaming_save_entry)));
  186. #ifdef FLAC_ICECAST
  187. flac_cfg.stream.cast_title_streaming = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_cast_title));
  188. flac_cfg.stream.use_udp_channel = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_udp_title));
  189. #endif
  191. xmms_cfg_write_int(cfg, "flac", "stream.http_buffer_size", flac_cfg.stream.http_buffer_size);
  192. xmms_cfg_write_int(cfg, "flac", "stream.http_prebuffer", flac_cfg.stream.http_prebuffer);
  193. xmms_cfg_write_boolean(cfg, "flac", "stream.use_proxy", flac_cfg.stream.use_proxy);
  194. xmms_cfg_write_string(cfg, "flac", "stream.proxy_host", flac_cfg.stream.proxy_host);
  195. xmms_cfg_write_int(cfg, "flac", "stream.proxy_port", flac_cfg.stream.proxy_port);
  196. xmms_cfg_write_boolean(cfg, "flac", "stream.proxy_use_auth", flac_cfg.stream.proxy_use_auth);
  197. if(flac_cfg.stream.proxy_user)
  198. xmms_cfg_write_string(cfg, "flac", "stream.proxy_user", flac_cfg.stream.proxy_user);
  199. else
  200. xmms_cfg_remove_key(cfg, "flac", "stream.proxy_user");
  201. if(flac_cfg.stream.proxy_pass)
  202. xmms_cfg_write_string(cfg, "flac", "stream.proxy_pass", flac_cfg.stream.proxy_pass);
  203. else
  204. xmms_cfg_remove_key(cfg, "flac", "stream.proxy_pass");
  205. xmms_cfg_write_boolean(cfg, "flac", "stream.save_http_stream", flac_cfg.stream.save_http_stream);
  206. xmms_cfg_write_string(cfg, "flac", "stream.save_http_path", flac_cfg.stream.save_http_path);
  207. #ifdef FLAC_ICECAST
  208. xmms_cfg_write_boolean(cfg, "flac", "stream.cast_title_streaming", flac_cfg.stream.cast_title_streaming);
  209. xmms_cfg_write_boolean(cfg, "flac", "stream.use_udp_channel", flac_cfg.stream.use_udp_channel);
  210. #endif
  212. xmms_cfg_write_file(cfg, filename);
  213. xmms_cfg_free(cfg);
  214. g_free(filename);
  215. gtk_widget_destroy(flac_configurewin);
  216. }
  218. static void configure_destroy(GtkWidget *widget, gpointer data)
  219. {
  220. (void)widget, (void)data; /* unused arguments */
  221. }
  223. static void title_tag_override_cb(GtkWidget *widget, gpointer data)
  224. {
  225. (void)widget, (void)data; /* unused arguments */
  226. flac_cfg.title.tag_override = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(title_tag_override));
  228. gtk_widget_set_sensitive(title_tag_box, flac_cfg.title.tag_override);
  229. gtk_widget_set_sensitive(title_desc, flac_cfg.title.tag_override);
  231. }
  233. static void convert_char_set_cb(GtkWidget *widget, gpointer data)
  234. {
  235. (void)widget, (void)data; /* unused arguments */
  236. flac_cfg.title.convert_char_set = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(convert_char_set));
  238. gtk_widget_set_sensitive(fileCharacterSetEntry, FALSE);
  239. gtk_widget_set_sensitive(userCharacterSetEntry, flac_cfg.title.convert_char_set);
  240. }
  242. static void replaygain_enable_cb(GtkWidget *widget, gpointer data)
  243. {
  244. (void)widget, (void)data; /* unused arguments */
  245. flac_cfg.output.replaygain.enable = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(replaygain_enable));
  247. gtk_widget_set_sensitive(replaygain_album_mode, flac_cfg.output.replaygain.enable);
  248. gtk_widget_set_sensitive(replaygain_preamp_hscale, flac_cfg.output.replaygain.enable);
  249. gtk_widget_set_sensitive(replaygain_hard_limit, flac_cfg.output.replaygain.enable);
  250. }
  252. static void replaygain_album_mode_cb(GtkWidget *widget, gpointer data)
  253. {
  254. (void)widget, (void)data; /* unused arguments */
  255. flac_cfg.output.replaygain.album_mode = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(replaygain_album_mode));
  256. }
  258. static void replaygain_hard_limit_cb(GtkWidget *widget, gpointer data)
  259. {
  260. (void)widget, (void)data; /* unused arguments */
  261. flac_cfg.output.replaygain.hard_limit = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(replaygain_hard_limit));
  262. }
  264. static void replaygain_preamp_cb(GtkWidget *widget, gpointer data)
  265. {
  266. GString *gstring = g_string_new("");
  267. (void)widget, (void)data; /* unused arguments */
  268. flac_cfg.output.replaygain.preamp = (int) floor(GTK_ADJUSTMENT(replaygain_preamp)->value + 0.5);
  270. g_string_sprintf(gstring, "%i dB", flac_cfg.output.replaygain.preamp);
  271. gtk_label_set_text(GTK_LABEL(replaygain_preamp_label), _(gstring->str));
  272. }
  274. static void resolution_normal_dither_24_to_16_cb(GtkWidget *widget, gpointer data)
  275. {
  276. (void)widget, (void)data; /* unused arguments */
  277. flac_cfg.output.resolution.normal.dither_24_to_16 = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(resolution_normal_dither_24_to_16));
  278. }
  280. static void resolution_replaygain_dither_cb(GtkWidget *widget, gpointer data)
  281. {
  282. (void)widget, (void)data; /* unused arguments */
  283. flac_cfg.output.resolution.replaygain.dither = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(resolution_replaygain_dither));
  285. gtk_widget_set_sensitive(resolution_replaygain_noise_shaping_frame, flac_cfg.output.resolution.replaygain.dither);
  286. }
  288. static void resolution_replaygain_noise_shaping_cb(GtkWidget *widget, gpointer data)
  289. {
  290. (void)widget, (void)data; /* unused arguments */
  291. flac_cfg.output.resolution.replaygain.noise_shaping =
  292. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_none))? 0 :
  293. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_low))? 1 :
  294. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_medium))? 2 :
  295. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_high))? 3 :
  296. 0
  297. ;
  298. }
  300. static void resolution_replaygain_bps_out_cb(GtkWidget *widget, gpointer data)
  301. {
  302. (void)widget, (void)data; /* unused arguments */
  303. flac_cfg.output.resolution.replaygain.bps_out =
  304. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(resolution_replaygain_bps_out_radio_16bps))? 16 :
  305. gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(resolution_replaygain_bps_out_radio_24bps))? 24 :
  306. 16
  307. ;
  308. }
  310. static void proxy_use_cb(GtkWidget * w, gpointer data)
  311. {
  312. gboolean use_proxy, use_proxy_auth;
  313. (void) w;
  314. (void) data;
  316. use_proxy = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_proxy_use));
  317. use_proxy_auth = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_proxy_auth_use));
  319. gtk_widget_set_sensitive(streaming_proxy_hbox, use_proxy);
  320. gtk_widget_set_sensitive(streaming_proxy_auth_use, use_proxy);
  321. gtk_widget_set_sensitive(streaming_proxy_auth_hbox, use_proxy && use_proxy_auth);
  322. }
  324. static void proxy_auth_use_cb(GtkWidget *w, gpointer data)
  325. {
  326. gboolean use_proxy, use_proxy_auth;
  327. (void) w;
  328. (void) data;
  330. use_proxy = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_proxy_use));
  331. use_proxy_auth = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_proxy_auth_use));
  333. gtk_widget_set_sensitive(streaming_proxy_auth_hbox, use_proxy && use_proxy_auth);
  334. }
  336. static void streaming_save_dirbrowser_cb(gchar * dir)
  337. {
  338. gtk_entry_set_text(GTK_ENTRY(streaming_save_entry), dir);
  339. }
  341. static void streaming_save_browse_cb(GtkWidget * w, gpointer data)
  342. {
  343. (void) w;
  344. (void) data;
  345. if (!streaming_save_dirbrowser)
  346. {
  347. streaming_save_dirbrowser = xmms_create_dir_browser(_("Select the directory where you want to store the MPEG streams:"),
  348.     flac_cfg.stream.save_http_path, GTK_SELECTION_SINGLE, streaming_save_dirbrowser_cb);
  349. gtk_signal_connect(GTK_OBJECT(streaming_save_dirbrowser), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &streaming_save_dirbrowser);
  350. gtk_window_set_transient_for(GTK_WINDOW(streaming_save_dirbrowser), GTK_WINDOW(flac_configurewin));
  351. gtk_widget_show(streaming_save_dirbrowser);
  352. }
  353. }
  355. static void streaming_save_use_cb(GtkWidget * w, gpointer data)
  356. {
  357. gboolean save_stream;
  358. (void) w;
  359. (void) data;
  361. save_stream = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_save_use));
  363. gtk_widget_set_sensitive(streaming_save_hbox, save_stream);
  364. }
  367. void FLAC_XMMS__configure(void)
  368. {
  369. GtkWidget *title_frame, *title_tag_vbox, *title_tag_label;
  370. GtkWidget *replaygain_frame, *resolution_frame, *output_vbox, *resolution_normal_frame, *resolution_replaygain_frame;
  371. GtkWidget *replaygain_vbox, *resolution_hbox, *resolution_normal_vbox, *resolution_replaygain_vbox;
  372. GtkWidget *resolution_replaygain_noise_shaping_vbox;
  373. GtkWidget *resolution_replaygain_bps_out_vbox;
  374. GtkWidget *label, *hbox;
  375. GtkWidget *bbox, *ok, *cancel;
  376. GList *list;
  378. GtkWidget *streaming_vbox;
  379. GtkWidget *streaming_buf_frame, *streaming_buf_hbox;
  380. GtkWidget *streaming_size_box, *streaming_size_label, *streaming_size_spin;
  381. GtkWidget *streaming_pre_box, *streaming_pre_label, *streaming_pre_spin;
  382. GtkWidget *streaming_proxy_frame, *streaming_proxy_vbox;
  383. GtkWidget *streaming_proxy_port_label,  *streaming_proxy_host_label;
  384. GtkWidget *streaming_save_frame, *streaming_save_vbox;
  385. GtkWidget *streaming_save_label, *streaming_save_browse;
  386. #ifdef FLAC_ICECAST
  387. GtkWidget *streaming_cast_frame, *streaming_cast_vbox;
  388. #endif
  389. char *temp;
  391. if (flac_configurewin != NULL) {
  392. gdk_window_raise(flac_configurewin->window);
  393. return;
  394. }
  395. flac_configurewin = gtk_window_new(GTK_WINDOW_DIALOG);
  396. gtk_signal_connect(GTK_OBJECT(flac_configurewin), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &flac_configurewin);
  397. gtk_signal_connect(GTK_OBJECT(flac_configurewin), "destroy", GTK_SIGNAL_FUNC(configure_destroy), &flac_configurewin);
  398. gtk_window_set_title(GTK_WINDOW(flac_configurewin), _("Flac Configuration"));
  399. gtk_window_set_policy(GTK_WINDOW(flac_configurewin), FALSE, FALSE, FALSE);
  400. gtk_container_border_width(GTK_CONTAINER(flac_configurewin), 10);
  402. vbox = gtk_vbox_new(FALSE, 10);
  403. gtk_container_add(GTK_CONTAINER(flac_configurewin), vbox);
  405. notebook = gtk_notebook_new();
  406. gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
  408. /* Title config.. */
  410. title_frame = gtk_frame_new(_("Tag Handling"));
  411. gtk_container_border_width(GTK_CONTAINER(title_frame), 5);
  413. title_tag_vbox = gtk_vbox_new(FALSE, 10);
  414. gtk_container_border_width(GTK_CONTAINER(title_tag_vbox), 5);
  415. gtk_container_add(GTK_CONTAINER(title_frame), title_tag_vbox);
  417. /* Convert Char Set */
  419. convert_char_set = gtk_check_button_new_with_label(_("Convert Character Set"));
  420. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(convert_char_set), flac_cfg.title.convert_char_set);
  421. gtk_signal_connect(GTK_OBJECT(convert_char_set), "clicked", convert_char_set_cb, NULL);
  422. gtk_box_pack_start(GTK_BOX(title_tag_vbox), convert_char_set, FALSE, FALSE, 0);
  423. /*  Combo boxes... */
  424. hbox = gtk_hbox_new(FALSE,4);
  425. gtk_container_add(GTK_CONTAINER(title_tag_vbox),hbox);
  426. label = gtk_label_new(_("Convert character set from :"));
  427. gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
  428. fileCharacterSetEntry = gtk_combo_new();
  429. gtk_box_pack_start(GTK_BOX(hbox),fileCharacterSetEntry,TRUE,TRUE,0);
  431. label = gtk_label_new (_("to :"));
  432. gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
  433. userCharacterSetEntry = gtk_combo_new();
  434. gtk_box_pack_start(GTK_BOX(hbox),userCharacterSetEntry,TRUE,TRUE,0);
  436. gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(fileCharacterSetEntry)->entry),FALSE);
  437. gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(userCharacterSetEntry)->entry),FALSE);
  438. gtk_combo_set_value_in_list(GTK_COMBO(fileCharacterSetEntry),TRUE,FALSE);
  439. gtk_combo_set_value_in_list(GTK_COMBO(userCharacterSetEntry),TRUE,FALSE);
  441. list = Charset_Create_List();
  442. gtk_combo_set_popdown_strings(GTK_COMBO(fileCharacterSetEntry),Charset_Create_List_UTF8_Only());
  443. gtk_combo_set_popdown_strings(GTK_COMBO(userCharacterSetEntry),list);
  444. gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(userCharacterSetEntry)->entry),Charset_Get_Title_From_Name(flac_cfg.title.user_char_set));
  445. gtk_widget_set_sensitive(fileCharacterSetEntry, FALSE);
  446. gtk_widget_set_sensitive(userCharacterSetEntry, flac_cfg.title.convert_char_set);
  448. /* Override Tagging Format */
  450. title_tag_override = gtk_check_button_new_with_label(_("Override generic titles"));
  451. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(title_tag_override), flac_cfg.title.tag_override);
  452. gtk_signal_connect(GTK_OBJECT(title_tag_override), "clicked", title_tag_override_cb, NULL);
  453. gtk_box_pack_start(GTK_BOX(title_tag_vbox), title_tag_override, FALSE, FALSE, 0);
  455. title_tag_box = gtk_hbox_new(FALSE, 5);
  456. gtk_widget_set_sensitive(title_tag_box, flac_cfg.title.tag_override);
  457. gtk_box_pack_start(GTK_BOX(title_tag_vbox), title_tag_box, FALSE, FALSE, 0);
  459. title_tag_label = gtk_label_new(_("Title format:"));
  460. gtk_box_pack_start(GTK_BOX(title_tag_box), title_tag_label, FALSE, FALSE, 0);
  462. title_tag_entry = gtk_entry_new();
  463. gtk_entry_set_text(GTK_ENTRY(title_tag_entry), flac_cfg.title.tag_format);
  464. gtk_box_pack_start(GTK_BOX(title_tag_box), title_tag_entry, TRUE, TRUE, 0);
  466. title_desc = xmms_titlestring_descriptions("pafFetnygc", 2);
  467. gtk_widget_set_sensitive(title_desc, flac_cfg.title.tag_override);
  468. gtk_box_pack_start(GTK_BOX(title_tag_vbox), title_desc, FALSE, FALSE, 0);
  470. gtk_notebook_append_page(GTK_NOTEBOOK(notebook), title_frame, gtk_label_new(_("Title")));
  472. /* Output config.. */
  474. output_vbox = gtk_vbox_new(FALSE, 10);
  475. gtk_container_border_width(GTK_CONTAINER(output_vbox), 5);
  477. /* replaygain */
  479. replaygain_frame = gtk_frame_new(_("ReplayGain"));
  480. gtk_container_border_width(GTK_CONTAINER(replaygain_frame), 5);
  481. gtk_box_pack_start(GTK_BOX(output_vbox), replaygain_frame, TRUE, TRUE, 0);
  483. replaygain_vbox = gtk_vbox_new(FALSE, 10);
  484. gtk_container_border_width(GTK_CONTAINER(replaygain_vbox), 5);
  485. gtk_container_add(GTK_CONTAINER(replaygain_frame), replaygain_vbox);
  487. replaygain_enable = gtk_check_button_new_with_label(_("Enable ReplayGain processing"));
  488. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(replaygain_enable), flac_cfg.output.replaygain.enable);
  489. gtk_signal_connect(GTK_OBJECT(replaygain_enable), "clicked", replaygain_enable_cb, NULL);
  490. gtk_box_pack_start(GTK_BOX(replaygain_vbox), replaygain_enable, FALSE, FALSE, 0);
  492. replaygain_album_mode = gtk_check_button_new_with_label(_("Album mode"));
  493. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(replaygain_album_mode), flac_cfg.output.replaygain.album_mode);
  494. gtk_signal_connect(GTK_OBJECT(replaygain_album_mode), "clicked", replaygain_album_mode_cb, NULL);
  495. gtk_box_pack_start(GTK_BOX(replaygain_vbox), replaygain_album_mode, FALSE, FALSE, 0);
  497. hbox = gtk_hbox_new(FALSE,3);
  498. gtk_container_add(GTK_CONTAINER(replaygain_vbox),hbox);
  499. label = gtk_label_new(_("Preamp:"));
  500. gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
  501. replaygain_preamp = gtk_adjustment_new(flac_cfg.output.replaygain.preamp, -24.0, +24.0, 1.0, 6.0, 0.0);
  502. gtk_signal_connect(GTK_OBJECT(replaygain_preamp), "value-changed", replaygain_preamp_cb, NULL);
  503. replaygain_preamp_hscale = gtk_hscale_new(GTK_ADJUSTMENT(replaygain_preamp));
  504. gtk_scale_set_draw_value(GTK_SCALE(replaygain_preamp_hscale), FALSE);
  505. gtk_box_pack_start(GTK_BOX(hbox),replaygain_preamp_hscale,TRUE,TRUE,0);
  506. replaygain_preamp_label = gtk_label_new(_("0 dB"));
  507. gtk_box_pack_start(GTK_BOX(hbox),replaygain_preamp_label,FALSE,FALSE,0);
  508. gtk_adjustment_value_changed(GTK_ADJUSTMENT(replaygain_preamp));
  510. replaygain_hard_limit = gtk_check_button_new_with_label(_("6dB hard limiting"));
  511. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(replaygain_hard_limit), flac_cfg.output.replaygain.hard_limit);
  512. gtk_signal_connect(GTK_OBJECT(replaygain_hard_limit), "clicked", replaygain_hard_limit_cb, NULL);
  513. gtk_box_pack_start(GTK_BOX(replaygain_vbox), replaygain_hard_limit, FALSE, FALSE, 0);
  515. replaygain_enable_cb(replaygain_enable, NULL);
  517. /* resolution */
  519. resolution_frame = gtk_frame_new(_("Resolution"));
  520. gtk_container_border_width(GTK_CONTAINER(resolution_frame), 5);
  521. gtk_box_pack_start(GTK_BOX(output_vbox), resolution_frame, TRUE, TRUE, 0);
  523. resolution_hbox = gtk_hbox_new(FALSE, 10);
  524. gtk_container_border_width(GTK_CONTAINER(resolution_hbox), 5);
  525. gtk_container_add(GTK_CONTAINER(resolution_frame), resolution_hbox);
  527. resolution_normal_frame = gtk_frame_new(_("Without ReplayGain"));
  528. gtk_container_border_width(GTK_CONTAINER(resolution_normal_frame), 5);
  529. gtk_box_pack_start(GTK_BOX(resolution_hbox), resolution_normal_frame, TRUE, TRUE, 0);
  531. resolution_normal_vbox = gtk_vbox_new(FALSE, 10);
  532. gtk_container_border_width(GTK_CONTAINER(resolution_normal_vbox), 5);
  533. gtk_container_add(GTK_CONTAINER(resolution_normal_frame), resolution_normal_vbox);
  535. resolution_normal_dither_24_to_16 = gtk_check_button_new_with_label(_("Dither 24bps to 16bps"));
  536. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_normal_dither_24_to_16), flac_cfg.output.resolution.normal.dither_24_to_16);
  537. gtk_signal_connect(GTK_OBJECT(resolution_normal_dither_24_to_16), "clicked", resolution_normal_dither_24_to_16_cb, NULL);
  538. gtk_box_pack_start(GTK_BOX(resolution_normal_vbox), resolution_normal_dither_24_to_16, FALSE, FALSE, 0);
  540. resolution_replaygain_frame = gtk_frame_new(_("With ReplayGain"));
  541. gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_frame), 5);
  542. gtk_box_pack_start(GTK_BOX(resolution_hbox), resolution_replaygain_frame, TRUE, TRUE, 0);
  544. resolution_replaygain_vbox = gtk_vbox_new(FALSE, 10);
  545. gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_vbox), 5);
  546. gtk_container_add(GTK_CONTAINER(resolution_replaygain_frame), resolution_replaygain_vbox);
  548. resolution_replaygain_dither = gtk_check_button_new_with_label(_("Enable dithering"));
  549. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_dither), flac_cfg.output.resolution.replaygain.dither);
  550. gtk_signal_connect(GTK_OBJECT(resolution_replaygain_dither), "clicked", resolution_replaygain_dither_cb, NULL);
  551. gtk_box_pack_start(GTK_BOX(resolution_replaygain_vbox), resolution_replaygain_dither, FALSE, FALSE, 0);
  553. hbox = gtk_hbox_new(FALSE, 10);
  554. gtk_container_border_width(GTK_CONTAINER(hbox), 5);
  555. gtk_box_pack_start(GTK_BOX(resolution_replaygain_vbox), hbox, TRUE, TRUE, 0);
  557. resolution_replaygain_noise_shaping_frame = gtk_frame_new(_("Noise shaping"));
  558. gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_noise_shaping_frame), 5);
  559. gtk_box_pack_start(GTK_BOX(hbox), resolution_replaygain_noise_shaping_frame, TRUE, TRUE, 0);
  561. resolution_replaygain_noise_shaping_vbox = gtk_vbutton_box_new();
  562. gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), 5);
  563. gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_frame), resolution_replaygain_noise_shaping_vbox);
  565. resolution_replaygain_noise_shaping_radio_none = gtk_radio_button_new_with_label(NULL, _("none"));
  566. if(flac_cfg.output.resolution.replaygain.noise_shaping == 0)
  567. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_none), TRUE);
  568. gtk_signal_connect(GTK_OBJECT(resolution_replaygain_noise_shaping_radio_none), "clicked", resolution_replaygain_noise_shaping_cb, NULL);
  569. gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), resolution_replaygain_noise_shaping_radio_none);
  571. resolution_replaygain_noise_shaping_radio_low = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(resolution_replaygain_noise_shaping_radio_none), _("low"));
  572. if(flac_cfg.output.resolution.replaygain.noise_shaping == 1)
  573. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_low), TRUE);
  574. gtk_signal_connect(GTK_OBJECT(resolution_replaygain_noise_shaping_radio_low), "clicked", resolution_replaygain_noise_shaping_cb, NULL);
  575. gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), resolution_replaygain_noise_shaping_radio_low);
  577. resolution_replaygain_noise_shaping_radio_medium = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(resolution_replaygain_noise_shaping_radio_none), _("medium"));
  578. if(flac_cfg.output.resolution.replaygain.noise_shaping == 2)
  579. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_medium), TRUE);
  580. gtk_signal_connect(GTK_OBJECT(resolution_replaygain_noise_shaping_radio_medium), "clicked", resolution_replaygain_noise_shaping_cb, NULL);
  581. gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), resolution_replaygain_noise_shaping_radio_medium);
  583. resolution_replaygain_noise_shaping_radio_high = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(resolution_replaygain_noise_shaping_radio_none), _("high"));
  584. if(flac_cfg.output.resolution.replaygain.noise_shaping == 3)
  585. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_noise_shaping_radio_high), TRUE);
  586. gtk_signal_connect(GTK_OBJECT(resolution_replaygain_noise_shaping_radio_high), "clicked", resolution_replaygain_noise_shaping_cb, NULL);
  587. gtk_container_add(GTK_CONTAINER(resolution_replaygain_noise_shaping_vbox), resolution_replaygain_noise_shaping_radio_high);
  589. resolution_replaygain_bps_out_frame = gtk_frame_new(_("Dither to"));
  590. gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_bps_out_frame), 5);
  591. gtk_box_pack_start(GTK_BOX(hbox), resolution_replaygain_bps_out_frame, FALSE, FALSE, 0);
  593. resolution_replaygain_bps_out_vbox = gtk_vbutton_box_new();
  594. gtk_container_border_width(GTK_CONTAINER(resolution_replaygain_bps_out_vbox), 0);
  595. gtk_container_add(GTK_CONTAINER(resolution_replaygain_bps_out_frame), resolution_replaygain_bps_out_vbox);
  597. resolution_replaygain_bps_out_radio_16bps = gtk_radio_button_new_with_label(NULL, _("16 bps"));
  598. if(flac_cfg.output.resolution.replaygain.bps_out == 16)
  599. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_bps_out_radio_16bps), TRUE);
  600. gtk_signal_connect(GTK_OBJECT(resolution_replaygain_bps_out_radio_16bps), "clicked", resolution_replaygain_bps_out_cb, NULL);
  601. gtk_container_add(GTK_CONTAINER(resolution_replaygain_bps_out_vbox), resolution_replaygain_bps_out_radio_16bps);
  603. resolution_replaygain_bps_out_radio_24bps = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(resolution_replaygain_bps_out_radio_16bps), _("24 bps"));
  604. if(flac_cfg.output.resolution.replaygain.bps_out == 24)
  605. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(resolution_replaygain_bps_out_radio_24bps), TRUE);
  606. gtk_signal_connect(GTK_OBJECT(resolution_replaygain_bps_out_radio_24bps), "clicked", resolution_replaygain_bps_out_cb, NULL);
  607. gtk_container_add(GTK_CONTAINER(resolution_replaygain_bps_out_vbox), resolution_replaygain_bps_out_radio_24bps);
  609. resolution_replaygain_dither_cb(resolution_replaygain_dither, NULL);
  611. gtk_notebook_append_page(GTK_NOTEBOOK(notebook), output_vbox, gtk_label_new(_("Output")));
  613. /* Streaming */
  615. streaming_vbox = gtk_vbox_new(FALSE, 0);
  617. streaming_buf_frame = gtk_frame_new(_("Buffering:"));
  618. gtk_container_set_border_width(GTK_CONTAINER(streaming_buf_frame), 5);
  619. gtk_box_pack_start(GTK_BOX(streaming_vbox), streaming_buf_frame, FALSE, FALSE, 0);
  621. streaming_buf_hbox = gtk_hbox_new(TRUE, 5);
  622. gtk_container_set_border_width(GTK_CONTAINER(streaming_buf_hbox), 5);
  623. gtk_container_add(GTK_CONTAINER(streaming_buf_frame), streaming_buf_hbox);
  625. streaming_size_box = gtk_hbox_new(FALSE, 5);
  626. /*gtk_table_attach_defaults(GTK_TABLE(streaming_buf_table),streaming_size_box,0,1,0,1); */
  627. gtk_box_pack_start(GTK_BOX(streaming_buf_hbox), streaming_size_box, TRUE, TRUE, 0);
  628. streaming_size_label = gtk_label_new(_("Buffer size (kb):"));
  629. gtk_box_pack_start(GTK_BOX(streaming_size_box), streaming_size_label, FALSE, FALSE, 0);
  630. streaming_size_adj = gtk_adjustment_new(flac_cfg.stream.http_buffer_size, 4, 4096, 4, 4, 4);
  631. streaming_size_spin = gtk_spin_button_new(GTK_ADJUSTMENT(streaming_size_adj), 8, 0);
  632. gtk_widget_set_usize(streaming_size_spin, 60, -1);
  633. gtk_box_pack_start(GTK_BOX(streaming_size_box), streaming_size_spin, FALSE, FALSE, 0);
  635. streaming_pre_box = gtk_hbox_new(FALSE, 5);
  636. /*gtk_table_attach_defaults(GTK_TABLE(streaming_buf_table),streaming_pre_box,1,2,0,1); */
  637. gtk_box_pack_start(GTK_BOX(streaming_buf_hbox), streaming_pre_box, TRUE, TRUE, 0);
  638. streaming_pre_label = gtk_label_new(_("Pre-buffer (percent):"));
  639. gtk_box_pack_start(GTK_BOX(streaming_pre_box), streaming_pre_label, FALSE, FALSE, 0);
  640. streaming_pre_adj = gtk_adjustment_new(flac_cfg.stream.http_prebuffer, 0, 90, 1, 1, 1);
  641. streaming_pre_spin = gtk_spin_button_new(GTK_ADJUSTMENT(streaming_pre_adj), 1, 0);
  642. gtk_widget_set_usize(streaming_pre_spin, 60, -1);
  643. gtk_box_pack_start(GTK_BOX(streaming_pre_box), streaming_pre_spin, FALSE, FALSE, 0);
  645.   /*
  646.    * Proxy config.
  647.    */
  648. streaming_proxy_frame = gtk_frame_new(_("Proxy:"));
  649. gtk_container_set_border_width(GTK_CONTAINER(streaming_proxy_frame), 5);
  650. gtk_box_pack_start(GTK_BOX(streaming_vbox), streaming_proxy_frame, FALSE, FALSE, 0);
  652. streaming_proxy_vbox = gtk_vbox_new(FALSE, 5);
  653. gtk_container_set_border_width(GTK_CONTAINER(streaming_proxy_vbox), 5);
  654. gtk_container_add(GTK_CONTAINER(streaming_proxy_frame), streaming_proxy_vbox);
  656. streaming_proxy_use = gtk_check_button_new_with_label(_("Use proxy"));
  657. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_proxy_use), flac_cfg.stream.use_proxy);
  658. gtk_signal_connect(GTK_OBJECT(streaming_proxy_use), "clicked", GTK_SIGNAL_FUNC(proxy_use_cb), NULL);
  659. gtk_box_pack_start(GTK_BOX(streaming_proxy_vbox), streaming_proxy_use, FALSE, FALSE, 0);
  661. streaming_proxy_hbox = gtk_hbox_new(FALSE, 5);
  662. gtk_widget_set_sensitive(streaming_proxy_hbox, flac_cfg.stream.use_proxy);
  663. gtk_box_pack_start(GTK_BOX(streaming_proxy_vbox), streaming_proxy_hbox, FALSE, FALSE, 0);
  665. streaming_proxy_host_label = gtk_label_new(_("Host:"));
  666. gtk_box_pack_start(GTK_BOX(streaming_proxy_hbox), streaming_proxy_host_label, FALSE, FALSE, 0);
  668. streaming_proxy_host_entry = gtk_entry_new();
  669. gtk_entry_set_text(GTK_ENTRY(streaming_proxy_host_entry), flac_cfg.stream.proxy_host);
  670. gtk_box_pack_start(GTK_BOX(streaming_proxy_hbox), streaming_proxy_host_entry, TRUE, TRUE, 0);
  672. streaming_proxy_port_label = gtk_label_new(_("Port:"));
  673. gtk_box_pack_start(GTK_BOX(streaming_proxy_hbox), streaming_proxy_port_label, FALSE, FALSE, 0);
  675. streaming_proxy_port_entry = gtk_entry_new();
  676. gtk_widget_set_usize(streaming_proxy_port_entry, 50, -1);
  677. temp = g_strdup_printf("%d", flac_cfg.stream.proxy_port);
  678. gtk_entry_set_text(GTK_ENTRY(streaming_proxy_port_entry), temp);
  679. g_free(temp);
  680. gtk_box_pack_start(GTK_BOX(streaming_proxy_hbox), streaming_proxy_port_entry, FALSE, FALSE, 0);
  682. streaming_proxy_auth_use = gtk_check_button_new_with_label(_("Use authentication"));
  683. gtk_widget_set_sensitive(streaming_proxy_auth_use, flac_cfg.stream.use_proxy);
  684. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_proxy_auth_use), flac_cfg.stream.proxy_use_auth);
  685. gtk_signal_connect(GTK_OBJECT(streaming_proxy_auth_use), "clicked", GTK_SIGNAL_FUNC(proxy_auth_use_cb), NULL);
  686. gtk_box_pack_start(GTK_BOX(streaming_proxy_vbox), streaming_proxy_auth_use, FALSE, FALSE, 0);
  688. streaming_proxy_auth_hbox = gtk_hbox_new(FALSE, 5);
  689. gtk_widget_set_sensitive(streaming_proxy_auth_hbox, flac_cfg.stream.use_proxy && flac_cfg.stream.proxy_use_auth);
  690. gtk_box_pack_start(GTK_BOX(streaming_proxy_vbox), streaming_proxy_auth_hbox, FALSE, FALSE, 0);
  692. streaming_proxy_auth_user_label = gtk_label_new(_("Username:"));
  693. gtk_box_pack_start(GTK_BOX(streaming_proxy_auth_hbox), streaming_proxy_auth_user_label, FALSE, FALSE, 0);
  695. streaming_proxy_auth_user_entry = gtk_entry_new();
  696. if(flac_cfg.stream.proxy_user)
  697. gtk_entry_set_text(GTK_ENTRY(streaming_proxy_auth_user_entry), flac_cfg.stream.proxy_user);
  698. gtk_box_pack_start(GTK_BOX(streaming_proxy_auth_hbox), streaming_proxy_auth_user_entry, TRUE, TRUE, 0);
  700. streaming_proxy_auth_pass_label = gtk_label_new(_("Password:"));
  701. gtk_box_pack_start(GTK_BOX(streaming_proxy_auth_hbox), streaming_proxy_auth_pass_label, FALSE, FALSE, 0);
  703. streaming_proxy_auth_pass_entry = gtk_entry_new();
  704. if(flac_cfg.stream.proxy_pass)
  705. gtk_entry_set_text(GTK_ENTRY(streaming_proxy_auth_pass_entry), flac_cfg.stream.proxy_pass);
  706. gtk_entry_set_visibility(GTK_ENTRY(streaming_proxy_auth_pass_entry), FALSE);
  707. gtk_box_pack_start(GTK_BOX(streaming_proxy_auth_hbox), streaming_proxy_auth_pass_entry, TRUE, TRUE, 0);
  710. /*
  711.  * Save to disk config.
  712.  */
  713. streaming_save_frame = gtk_frame_new(_("Save stream to disk:"));
  714. gtk_container_set_border_width(GTK_CONTAINER(streaming_save_frame), 5);
  715. gtk_box_pack_start(GTK_BOX(streaming_vbox), streaming_save_frame, FALSE, FALSE, 0);
  717. streaming_save_vbox = gtk_vbox_new(FALSE, 5);
  718. gtk_container_set_border_width(GTK_CONTAINER(streaming_save_vbox), 5);
  719. gtk_container_add(GTK_CONTAINER(streaming_save_frame), streaming_save_vbox);
  721. streaming_save_use = gtk_check_button_new_with_label(_("Save stream to disk"));
  722. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_save_use), flac_cfg.stream.save_http_stream);
  723. gtk_signal_connect(GTK_OBJECT(streaming_save_use), "clicked", GTK_SIGNAL_FUNC(streaming_save_use_cb), NULL);
  724. gtk_box_pack_start(GTK_BOX(streaming_save_vbox), streaming_save_use, FALSE, FALSE, 0);
  726. streaming_save_hbox = gtk_hbox_new(FALSE, 5);
  727. gtk_widget_set_sensitive(streaming_save_hbox, flac_cfg.stream.save_http_stream);
  728. gtk_box_pack_start(GTK_BOX(streaming_save_vbox), streaming_save_hbox, FALSE, FALSE, 0);
  730. streaming_save_label = gtk_label_new(_("Path:"));
  731. gtk_box_pack_start(GTK_BOX(streaming_save_hbox), streaming_save_label, FALSE, FALSE, 0);
  733. streaming_save_entry = gtk_entry_new();
  734. gtk_entry_set_text(GTK_ENTRY(streaming_save_entry), flac_cfg.stream.save_http_path);
  735. gtk_box_pack_start(GTK_BOX(streaming_save_hbox), streaming_save_entry, TRUE, TRUE, 0);
  737. streaming_save_browse = gtk_button_new_with_label(_("Browse"));
  738. gtk_signal_connect(GTK_OBJECT(streaming_save_browse), "clicked", GTK_SIGNAL_FUNC(streaming_save_browse_cb), NULL);
  739. gtk_box_pack_start(GTK_BOX(streaming_save_hbox), streaming_save_browse, FALSE, FALSE, 0);
  741. #ifdef FLAC_ICECAST
  742. streaming_cast_frame = gtk_frame_new(_("SHOUT/Icecast:"));
  743. gtk_container_set_border_width(GTK_CONTAINER(streaming_cast_frame), 5);
  744. gtk_box_pack_start(GTK_BOX(streaming_vbox), streaming_cast_frame, FALSE, FALSE, 0);
  746. streaming_cast_vbox = gtk_vbox_new(5, FALSE);
  747. gtk_container_add(GTK_CONTAINER(streaming_cast_frame), streaming_cast_vbox);
  749. streaming_cast_title = gtk_check_button_new_with_label(_("Enable SHOUT/Icecast title streaming"));
  750. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_cast_title), flac_cfg.stream.cast_title_streaming);
  751. gtk_box_pack_start(GTK_BOX(streaming_cast_vbox), streaming_cast_title, FALSE, FALSE, 0);
  753. streaming_udp_title = gtk_check_button_new_with_label(_("Enable Icecast Metadata UDP Channel"));
  754. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(streaming_udp_title), flac_cfg.stream.use_udp_channel);
  755. gtk_box_pack_start(GTK_BOX(streaming_cast_vbox), streaming_udp_title, FALSE, FALSE, 0);
  756. #endif
  758. gtk_notebook_append_page(GTK_NOTEBOOK(notebook), streaming_vbox, gtk_label_new(_("Streaming")));
  760. /* Buttons */
  762. bbox = gtk_hbutton_box_new();
  763. gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
  764. gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
  765. gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
  767. ok = gtk_button_new_with_label(_("Ok"));
  768. gtk_signal_connect(GTK_OBJECT(ok), "clicked", GTK_SIGNAL_FUNC(flac_configurewin_ok), NULL);
  769. GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
  770. gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0);
  771. gtk_widget_grab_default(ok);
  773. cancel = gtk_button_new_with_label(_("Cancel"));
  774. gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(flac_configurewin));
  775. GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
  776. gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0);
  778. gtk_widget_show_all(flac_configurewin);
  779. }
  781. void FLAC_XMMS__aboutbox()
  782. {
  783. static GtkWidget *about_window;
  785. if (about_window)
  786. gdk_window_raise(about_window->window);
  788. about_window = xmms_show_message(
  789. _("About Flac Plugin"),
  790. _("Flac Plugin by Josh Coalsonn"
  791.   "contributions byn"
  792.   "......n"
  793.   "......n"
  794.   "andn"
  795.   "Daisuke Shimamuran"
  796.   "Visit http://flac.sourceforge.net/"),
  797. _("Ok"), FALSE, NULL, NULL);
  798. gtk_signal_connect(GTK_OBJECT(about_window), "destroy",
  799.    GTK_SIGNAL_FUNC(gtk_widget_destroyed),
  800.    &about_window);
  801. }
  803. /*
  804.  * Get text of an Entry or a ComboBox
  805.  */
  806. static gchar *gtk_entry_get_text_1 (GtkWidget *widget)
  807. {
  808. if (GTK_IS_COMBO(widget))
  809. {
  810. return gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(widget)->entry));
  811. }else if (GTK_IS_ENTRY(widget))
  812. {
  813. return gtk_entry_get_text(GTK_ENTRY(widget));
  814. }else
  815. {
  816. return NULL;
  817. }
  818. }