Mercurial > audlegacy-plugins

comparison src/amidi-plug/i_configure-fluidsynth.c @ 12:3da1b8942b8b trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[svn] - remove src/Input src/Output src/Effect src/General src/Visualization src/Container
author nenolod
date Mon, 18 Sep 2006 03:14:20 -0700
parents src/Input/amidi-plug/i_configure-fluidsynth.c@13389e613d67
children 59d793da5395
comparison
equal deleted inserted replaced
11:cff1d04026ae 12:3da1b8942b8b
1 /*
2 *
3 * Author: Giacomo Lozito <james@develia.org>, (C) 2005-2006
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the
7 * Free Software Foundation; either version 2 of the License, or (at your
8 * option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 *
19 */
20
21
22 #include "i_configure-fluidsynth.h"
23 #include "backend-fluidsynth/b-fluidsynth-config.h"
24 #include "backend-fluidsynth/backend-fluidsynth-icon.xpm"
25 #include <glib/gstdio.h>
26
27
28 enum
29 {
30 LISTSFONT_FILENAME_COLUMN = 0,
31 LISTSFONT_FILESIZE_COLUMN,
32 LISTSFONT_N_COLUMNS
33 };
34
35
36 void i_configure_ev_toggle_default( GtkToggleButton *togglebutton , gpointer hbox )
37 {
38 if ( gtk_toggle_button_get_active( togglebutton ) )
39 gtk_widget_set_sensitive( GTK_WIDGET(hbox) , FALSE );
40 else
41 gtk_widget_set_sensitive( GTK_WIDGET(hbox) , TRUE );
42 }
43
44
45 void i_configure_ev_buffertuner_valuechanged( GtkRange *buffertuner_range )
46 {
47 gint bufsize_val, bufmarginsize_val;
48 gint i = (gint)gtk_range_get_value( GTK_RANGE(buffertuner_range) );
49 GtkWidget *bufsize_spin = g_object_get_data( G_OBJECT(buffertuner_range) , "bufsize_spin" );
50 GtkWidget *bufmarginsize_spin = g_object_get_data( G_OBJECT(buffertuner_range) , "bufmarginsize_spin" );
51
52 if ( i < 33 )
53 {
54 bufsize_val = 256 + (i * 16); /* linear growth of 16i - bufsize_val <= 768 */
55 if ( i > 16 )
56 bufmarginsize_val = 15 + ((i - 15) / 2); /* linear growth of i/2 */
57 else
58 bufmarginsize_val = 15; /* do not go below 10 even when bufsize < 512 */
59 }
60 else if ( i < 42 )
61 {
62 bufsize_val = 768 + ((i - 33) * 32); /* linear growth of 32i - bufsize_val <= 1024 */
63 bufmarginsize_val = 15 + ( (i - 16) / 2 ); /* linear growth of i/2 */
64 }
65 else
66 {
67 bufsize_val = 1024 + ( 32 << (i - 42) ); /* exponential growth - bufsize_val > 1024 */
68 bufmarginsize_val = 15 + ( (i - 16) / 2 ); /* linear growth of i/2 */
69 }
70
71 gtk_spin_button_set_value( GTK_SPIN_BUTTON(bufsize_spin) , bufsize_val );
72 gtk_spin_button_set_value( GTK_SPIN_BUTTON(bufmarginsize_spin) , bufmarginsize_val );
73 }
74
75
76 void i_configure_ev_sflist_add( gpointer sfont_lv )
77 {
78 GtkWidget *parent_window = gtk_widget_get_toplevel( sfont_lv );
79 if ( GTK_WIDGET_TOPLEVEL(parent_window) )
80 {
81 GtkTreeSelection *listsel = gtk_tree_view_get_selection( GTK_TREE_VIEW(sfont_lv) );
82 GtkTreeIter itersel, iterapp;
83 GtkWidget *browse_dialog = gtk_file_chooser_dialog_new( _("AMIDI-Plug - select SoundFont file") ,
84 GTK_WINDOW(parent_window) ,
85 GTK_FILE_CHOOSER_ACTION_OPEN ,
86 GTK_STOCK_CANCEL , GTK_RESPONSE_CANCEL ,
87 GTK_STOCK_OPEN , GTK_RESPONSE_ACCEPT , NULL );
88 if ( gtk_tree_selection_get_selected( listsel , NULL , &itersel ) )
89 {
90 gchar *selfilename = NULL, *selfiledir = NULL;
91 GtkTreeModel *store = gtk_tree_view_get_model( GTK_TREE_VIEW(sfont_lv) );
92 gtk_tree_model_get( GTK_TREE_MODEL(store) , &itersel , LISTSFONT_FILENAME_COLUMN , &selfilename , -1 );
93 selfiledir = g_path_get_dirname( selfilename );
94 gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER(browse_dialog) , selfiledir );
95 g_free( selfiledir ); g_free( selfilename );
96 }
97 if ( gtk_dialog_run(GTK_DIALOG(browse_dialog)) == GTK_RESPONSE_ACCEPT )
98 {
99 struct stat finfo;
100 GtkTreeModel *store = gtk_tree_view_get_model( GTK_TREE_VIEW(sfont_lv) );
101 gchar *filename = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER(browse_dialog) );
102 gint filesize = -1;
103 if ( g_stat( filename , &finfo ) == 0 )
104 filesize = finfo.st_size;
105 gtk_list_store_append( GTK_LIST_STORE(store) , &iterapp );
106 gtk_list_store_set( GTK_LIST_STORE(store) , &iterapp ,
107 LISTSFONT_FILENAME_COLUMN , filename ,
108 LISTSFONT_FILESIZE_COLUMN , filesize , -1 );
109 DEBUGMSG( "selected file: %s\n" , filename );
110 g_free( filename );
111 }
112 gtk_widget_destroy( browse_dialog );
113 }
114 }
115
116
117 void i_configure_ev_sflist_rem( gpointer sfont_lv )
118 {
119 GtkTreeModel *store;
120 GtkTreeIter iter;
121 GtkTreeSelection *listsel = gtk_tree_view_get_selection( GTK_TREE_VIEW(sfont_lv) );
122 if ( gtk_tree_selection_get_selected( listsel , &store , &iter ) )
123 gtk_list_store_remove( GTK_LIST_STORE(store) , &iter );
124 }
125
126
127 void i_configure_ev_sflist_swap( GtkWidget * button , gpointer sfont_lv )
128 {
129 GtkTreeModel *store;
130 GtkTreeIter iter;
131 GtkTreeSelection *listsel = gtk_tree_view_get_selection( GTK_TREE_VIEW(sfont_lv) );
132
133 if ( gtk_tree_selection_get_selected( listsel , &store , &iter ) )
134 {
135 guint swapdire = GPOINTER_TO_UINT(g_object_get_data( G_OBJECT(button) , "swapdire" ));
136 if ( swapdire == 0 ) /* move up */
137 {
138 GtkTreePath *treepath = gtk_tree_model_get_path( store, &iter );
139 if ( gtk_tree_path_prev( treepath ) )
140 {
141 GtkTreeIter iter_prev;
142 if ( gtk_tree_model_get_iter( store , &iter_prev , treepath ) )
143 gtk_list_store_swap( GTK_LIST_STORE(store) , &iter , &iter_prev );
144 }
145 gtk_tree_path_free( treepath );
146 }
147 else /* move down */
148 {
149 GtkTreeIter iter_prev = iter;
150 if ( gtk_tree_model_iter_next( store , &iter ) )
151 gtk_list_store_swap( GTK_LIST_STORE(store) , &iter , &iter_prev );
152 }
153 }
154 }
155
156
157 void i_configure_ev_sflist_commit( gpointer sfont_lv )
158 {
159 amidiplug_cfg_fsyn_t * fsyncfg = amidiplug_cfg_backend->fsyn;
160 GtkTreeIter iter;
161 GtkTreeModel *store = gtk_tree_view_get_model( GTK_TREE_VIEW(sfont_lv) );
162 GString *sflist_string = g_string_new( "" );
163
164 if ( gtk_tree_model_get_iter_first( GTK_TREE_MODEL(store) , &iter ) == TRUE )
165 {
166 gboolean iter_is_valid = FALSE;
167 do
168 {
169 gchar *fname;
170 gtk_tree_model_get( GTK_TREE_MODEL(store) , &iter ,
171 LISTSFONT_FILENAME_COLUMN , &fname , -1 );
172 g_string_prepend_c( sflist_string , ';' );
173 g_string_prepend( sflist_string , fname );
174 g_free( fname );
175 iter_is_valid = gtk_tree_model_iter_next( GTK_TREE_MODEL(store) , &iter );
176 }
177 while ( iter_is_valid == TRUE );
178 }
179
180 if ( sflist_string->len > 0 )
181 g_string_truncate( sflist_string , sflist_string->len - 1 );
182
183 g_free( fsyncfg->fsyn_soundfont_file ); /* free previous */
184 fsyncfg->fsyn_soundfont_file = g_strdup( sflist_string->str );
185 g_string_free( sflist_string , TRUE );
186 }
187
188
189 void i_configure_ev_sfload_commit( gpointer sfload_radiobt )
190 {
191 amidiplug_cfg_fsyn_t * fsyncfg = amidiplug_cfg_backend->fsyn;
192 GSList *group = gtk_radio_button_get_group( GTK_RADIO_BUTTON(sfload_radiobt) );
193 while ( group != NULL )
194 {
195 if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(group->data) ) )
196 fsyncfg->fsyn_soundfont_load = GPOINTER_TO_INT(g_object_get_data( G_OBJECT(group->data) , "val" ));
197 group = group->next;
198 }
199 }
200
201
202 void i_configure_ev_sygain_commit( gpointer gain_spinbt )
203 {
204 amidiplug_cfg_fsyn_t * fsyncfg = amidiplug_cfg_backend->fsyn;
205 if ( GTK_WIDGET_IS_SENSITIVE(GTK_WIDGET(gain_spinbt)) )
206 fsyncfg->fsyn_synth_gain = (gint)(gtk_spin_button_get_value(GTK_SPIN_BUTTON(gain_spinbt)) * 10);
207 else
208 fsyncfg->fsyn_synth_gain = -1;
209 }
210
211
212 void i_configure_ev_sypoly_commit( gpointer poly_spinbt )
213 {
214 amidiplug_cfg_fsyn_t * fsyncfg = amidiplug_cfg_backend->fsyn;
215 if ( GTK_WIDGET_IS_SENSITIVE(GTK_WIDGET(poly_spinbt)) )
216 fsyncfg->fsyn_synth_poliphony = (gint)(gtk_spin_button_get_value(GTK_SPIN_BUTTON(poly_spinbt)));
217 else
218 fsyncfg->fsyn_synth_poliphony = -1;
219 }
220
221
222 void i_configure_ev_syreverb_commit( gpointer reverb_yes_radiobt )
223 {
224 amidiplug_cfg_fsyn_t * fsyncfg = amidiplug_cfg_backend->fsyn;
225 if ( GTK_WIDGET_IS_SENSITIVE(GTK_WIDGET(reverb_yes_radiobt)) )
226 {
227 if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(reverb_yes_radiobt) ) )
228 fsyncfg->fsyn_synth_reverb = 1;
229 else
230 fsyncfg->fsyn_synth_reverb = 0;
231 }
232 else
233 fsyncfg->fsyn_synth_reverb = -1;
234 }
235
236
237 void i_configure_ev_sychorus_commit( gpointer chorus_yes_radiobt )
238 {
239 amidiplug_cfg_fsyn_t * fsyncfg = amidiplug_cfg_backend->fsyn;
240 if ( GTK_WIDGET_IS_SENSITIVE(GTK_WIDGET(chorus_yes_radiobt)) )
241 {
242 if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(chorus_yes_radiobt) ) )
243 fsyncfg->fsyn_synth_chorus = 1;
244 else
245 fsyncfg->fsyn_synth_chorus = 0;
246 }
247 else
248 fsyncfg->fsyn_synth_chorus = -1;
249 }
250
251
252 void i_configure_ev_sysamplerate_togglecustom( GtkToggleButton *custom_radiobt , gpointer custom_entry )
253 {
254 if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(custom_radiobt) ) )
255 gtk_widget_set_sensitive( GTK_WIDGET(custom_entry) , TRUE );
256 else
257 gtk_widget_set_sensitive( GTK_WIDGET(custom_entry) , FALSE );
258 }
259
260
261 void i_configure_ev_sysamplerate_commit( gpointer samplerate_custom_radiobt )
262 {
263 amidiplug_cfg_fsyn_t * fsyncfg = amidiplug_cfg_backend->fsyn;
264 if ( gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(samplerate_custom_radiobt)) )
265 {
266 GtkWidget *customentry = g_object_get_data( G_OBJECT(samplerate_custom_radiobt) , "customentry" );
267 gint customvalue = strtol( gtk_entry_get_text(GTK_ENTRY(customentry)) , NULL , 10 );
268 if (( customvalue > 22050 ) && ( customvalue < 96000 ))
269 fsyncfg->fsyn_synth_samplerate = customvalue;
270 else
271 fsyncfg->fsyn_synth_samplerate = 44100;
272 }
273 else
274 {
275 GSList *group = gtk_radio_button_get_group( GTK_RADIO_BUTTON(samplerate_custom_radiobt) );
276 while ( group != NULL )
277 {
278 if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(group->data) ) )
279 fsyncfg->fsyn_synth_samplerate = GPOINTER_TO_INT(g_object_get_data( G_OBJECT(group->data) , "val" ));
280 group = group->next;
281 }
282 }
283 }
284
285
286 void i_configure_ev_bufsize_commit( gpointer bufsize_spinbt )
287 {
288 amidiplug_cfg_fsyn_t * fsyncfg = amidiplug_cfg_backend->fsyn;
289 fsyncfg->fsyn_buffer_size = (gint)(gtk_spin_button_get_value(GTK_SPIN_BUTTON(bufsize_spinbt)));
290 }
291
292
293 void i_configure_ev_bufmarginsize_commit( gpointer marginsize_spinbt )
294 {
295 amidiplug_cfg_fsyn_t * fsyncfg = amidiplug_cfg_backend->fsyn;
296 fsyncfg->fsyn_buffer_margin = (gint)(gtk_spin_button_get_value(GTK_SPIN_BUTTON(marginsize_spinbt)));
297 }
298
299
300 void i_configure_ev_bufmargininc_commit( gpointer margininc_spinbt )
301 {
302 amidiplug_cfg_fsyn_t * fsyncfg = amidiplug_cfg_backend->fsyn;
303 fsyncfg->fsyn_buffer_increment = (gint)(gtk_spin_button_get_value(GTK_SPIN_BUTTON(margininc_spinbt)));
304 }
305
306
307 void i_configure_buffertuner_setvalue( GtkWidget * buftuner_hscale , gint bufsize )
308 {
309 gint scale_value = 0;
310 if ( bufsize <= 768 )
311 {
312 scale_value = ( bufsize - 256 ) / 16;
313 }
314 else if ( bufsize <= 1024 )
315 {
316 scale_value = ( bufsize + 288 ) / 32;
317 }
318 else
319 {
320 gint tcount = 0, tval = bufsize - 1024;
321 tval = tval >> 1;
322 while ( tval > 0 )
323 {
324 tval = tval >> 1;
325 tcount++;
326 }
327 scale_value = 37 + tcount;
328 }
329 if ( scale_value < 0 )
330 scale_value = 0;
331 else if ( scale_value > 53 )
332 scale_value = 53;
333 gtk_range_set_value( GTK_RANGE(buftuner_hscale) , scale_value );
334 }
335
336
337 void i_configure_ev_buffertuner_default( gpointer buffertuner_hscale )
338 {
339 GtkWidget *bufsize_spin = g_object_get_data( G_OBJECT(buffertuner_hscale) , "bufsize_spin" );
340 GtkWidget *bufmarginsize_spin = g_object_get_data( G_OBJECT(buffertuner_hscale) , "bufmarginsize_spin" );
341 GtkWidget *bufmargininc_spin = g_object_get_data( G_OBJECT(buffertuner_hscale) , "bufmargininc_spin" );
342 i_configure_buffertuner_setvalue( GTK_WIDGET(buffertuner_hscale) , 512 );
343 gtk_spin_button_set_value( GTK_SPIN_BUTTON(bufsize_spin) , 512 );
344 gtk_spin_button_set_value( GTK_SPIN_BUTTON(bufmarginsize_spin) , 15 );
345 gtk_spin_button_set_value( GTK_SPIN_BUTTON(bufmargininc_spin) , 18 );
346 }
347
348
349 void i_configure_gui_tab_fsyn( GtkWidget * fsyn_page_alignment ,
350 gpointer backend_list_p ,
351 gpointer commit_button )
352 {
353 GtkWidget *fsyn_page_vbox;
354 GtkWidget *title_widget;
355 GtkWidget *content_vbox; /* this vbox will contain the various frames for config sections */
356 GSList * backend_list = backend_list_p;
357 gboolean fsyn_module_ok = FALSE;
358 gchar * fsyn_module_pathfilename;
359
360 fsyn_page_vbox = gtk_vbox_new( FALSE , 0 );
361
362 title_widget = i_configure_gui_draw_title( _("FLUIDSYNTH BACKEND CONFIGURATION") );
363 gtk_box_pack_start( GTK_BOX(fsyn_page_vbox) , title_widget , FALSE , FALSE , 2 );
364
365 content_vbox = gtk_vbox_new( FALSE , 2 );
366
367 /* check if the FluidSynth module is available */
368 while ( backend_list != NULL )
369 {
370 amidiplug_sequencer_backend_name_t * mn = backend_list->data;
371 if ( !strcmp( mn->name , "fluidsynth" ) )
372 {
373 fsyn_module_ok = TRUE;
374 fsyn_module_pathfilename = mn->filename;
375 break;
376 }
377 backend_list = backend_list->next;
378 }
379
380 if ( fsyn_module_ok )
381 {
382 GtkWidget *soundfont_frame, *soundfont_vbox;
383 GtkListStore *soundfont_file_store;
384 GtkCellRenderer *soundfont_file_lv_text_rndr;
385 GtkTreeViewColumn *soundfont_file_lv_fname_col, *soundfont_file_lv_fsize_col;
386 GtkWidget *soundfont_file_hbox, *soundfont_file_lv, *soundfont_file_lv_sw, *soundfont_file_lv_frame;
387 GtkTreeSelection *soundfont_file_lv_sel;
388 GtkWidget *soundfont_file_bbox_vbox, *soundfont_file_bbox_addbt, *soundfont_file_bbox_rembt;
389 GtkWidget *soundfont_file_bbox_mvupbt, *soundfont_file_bbox_mvdownbt;
390 GtkWidget *soundfont_load_hsep, *soundfont_load_hbox, *soundfont_load_option[2];
391 GtkWidget *synth_frame, *synth_hbox, *synth_leftcol_vbox, *synth_rightcol_vbox;
392 GtkWidget *synth_samplerate_frame, *synth_samplerate_vbox, *synth_samplerate_option[4];
393 GtkWidget *synth_samplerate_optionhbox, *synth_samplerate_optionentry, *synth_samplerate_optionlabel;
394 GtkWidget *synth_gain_frame, *synth_gain_hbox, *synth_gain_value_hbox;
395 GtkWidget *synth_gain_value_label, *synth_gain_value_spin, *synth_gain_defcheckbt;
396 GtkWidget *synth_poly_frame, *synth_poly_hbox, *synth_poly_value_hbox;
397 GtkWidget *synth_poly_value_label, *synth_poly_value_spin, *synth_poly_defcheckbt;
398 GtkWidget *synth_reverb_frame, *synth_reverb_hbox, *synth_reverb_value_hbox;
399 GtkWidget *synth_reverb_value_option[2], *synth_reverb_defcheckbt;
400 GtkWidget *synth_chorus_frame, *synth_chorus_hbox, *synth_chorus_value_hbox;
401 GtkWidget *synth_chorus_value_option[2], *synth_chorus_defcheckbt;
402 GtkWidget *buffer_frame, *buffer_table , *buffer_vsep[4];
403 GtkWidget *buffer_tuner_label, *buffer_tuner_hscale;
404 GtkWidget *buffer_tuner_defbt, *buffer_tuner_defbt_label;
405 GtkWidget *buffer_bufsize_label, *buffer_bufsize_spin;
406 GtkWidget *buffer_marginsize_label, *buffer_marginsize_spin;
407 GtkWidget *buffer_margininc_label, *buffer_margininc_spin;
408 GtkTooltips *tips;
409
410 amidiplug_cfg_fsyn_t * fsyncfg = amidiplug_cfg_backend->fsyn;
411
412 tips = gtk_tooltips_new();
413 g_object_set_data_full( G_OBJECT(fsyn_page_alignment) , "tt" , tips , g_object_unref );
414
415 /* soundfont settings */
416 soundfont_frame = gtk_frame_new( _("SoundFont settings") );
417 soundfont_vbox = gtk_vbox_new( FALSE , 2 );
418 gtk_container_set_border_width( GTK_CONTAINER(soundfont_vbox), 4 );
419 gtk_container_add( GTK_CONTAINER(soundfont_frame) , soundfont_vbox );
420 /* soundfont settings - soundfont files - listview */
421 soundfont_file_store = gtk_list_store_new( LISTSFONT_N_COLUMNS, G_TYPE_STRING , G_TYPE_INT );
422 if ( strlen(fsyncfg->fsyn_soundfont_file) > 0 )
423 {
424 /* fill soundfont list with fsyn_soundfont_file information */
425 gchar **sffiles = g_strsplit( fsyncfg->fsyn_soundfont_file , ";" , 0 );
426 GtkTreeIter iter;
427 gint i = 0;
428 while ( sffiles[i] != NULL )
429 {
430 gint filesize = -1;
431 struct stat finfo;
432 if ( g_stat( sffiles[i] , &finfo ) == 0 )
433 filesize = finfo.st_size;
434 gtk_list_store_prepend( GTK_LIST_STORE(soundfont_file_store) , &iter );
435 gtk_list_store_set( GTK_LIST_STORE(soundfont_file_store) , &iter ,
436 LISTSFONT_FILENAME_COLUMN , sffiles[i] ,
437 LISTSFONT_FILESIZE_COLUMN , filesize , -1 );
438 i++;
439 }
440 g_strfreev( sffiles );
441 }
442 soundfont_file_hbox = gtk_hbox_new( FALSE , 2 );
443 soundfont_file_lv = gtk_tree_view_new_with_model( GTK_TREE_MODEL(soundfont_file_store) );
444 gtk_tree_view_set_rules_hint( GTK_TREE_VIEW(soundfont_file_lv), TRUE );
445 g_object_unref( soundfont_file_store );
446 soundfont_file_lv_text_rndr = gtk_cell_renderer_text_new();
447 soundfont_file_lv_fname_col = gtk_tree_view_column_new_with_attributes(
448 _("Filename") , soundfont_file_lv_text_rndr , "text" ,
449 LISTSFONT_FILENAME_COLUMN, NULL );
450 gtk_tree_view_column_set_expand( GTK_TREE_VIEW_COLUMN(soundfont_file_lv_fname_col) , TRUE );
451 soundfont_file_lv_fsize_col = gtk_tree_view_column_new_with_attributes(
452 _("Size (bytes)") , soundfont_file_lv_text_rndr , "text" ,
453 LISTSFONT_FILESIZE_COLUMN, NULL );
454 gtk_tree_view_column_set_expand( GTK_TREE_VIEW_COLUMN(soundfont_file_lv_fsize_col) , FALSE );
455 gtk_tree_view_append_column( GTK_TREE_VIEW(soundfont_file_lv), soundfont_file_lv_fname_col );
456 gtk_tree_view_append_column( GTK_TREE_VIEW(soundfont_file_lv), soundfont_file_lv_fsize_col );
457 soundfont_file_lv_sel = gtk_tree_view_get_selection( GTK_TREE_VIEW(soundfont_file_lv) );
458 gtk_tree_selection_set_mode( GTK_TREE_SELECTION(soundfont_file_lv_sel) , GTK_SELECTION_SINGLE );
459 soundfont_file_lv_sw = gtk_scrolled_window_new( NULL , NULL );
460 gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(soundfont_file_lv_sw) ,
461 GTK_POLICY_NEVER , GTK_POLICY_ALWAYS );
462 soundfont_file_lv_frame = gtk_frame_new( NULL );
463 gtk_container_add( GTK_CONTAINER(soundfont_file_lv_sw) , soundfont_file_lv );
464 gtk_container_add( GTK_CONTAINER(soundfont_file_lv_frame) , soundfont_file_lv_sw );
465 /* soundfont settings - soundfont files - buttonbox */
466 soundfont_file_bbox_vbox = gtk_vbox_new( TRUE , 0 );
467 soundfont_file_bbox_addbt = gtk_button_new();
468 gtk_button_set_image( GTK_BUTTON(soundfont_file_bbox_addbt) ,
469 gtk_image_new_from_stock( GTK_STOCK_ADD , GTK_ICON_SIZE_MENU ) );
470 g_signal_connect_swapped( G_OBJECT(soundfont_file_bbox_addbt) , "clicked" ,
471 G_CALLBACK(i_configure_ev_sflist_add) , soundfont_file_lv );
472 gtk_box_pack_start( GTK_BOX(soundfont_file_bbox_vbox) , soundfont_file_bbox_addbt , FALSE , FALSE , 0 );
473 soundfont_file_bbox_rembt = gtk_button_new();
474 gtk_button_set_image( GTK_BUTTON(soundfont_file_bbox_rembt) ,
475 gtk_image_new_from_stock( GTK_STOCK_REMOVE , GTK_ICON_SIZE_MENU ) );
476 g_signal_connect_swapped( G_OBJECT(soundfont_file_bbox_rembt) , "clicked" ,
477 G_CALLBACK(i_configure_ev_sflist_rem) , soundfont_file_lv );
478 gtk_box_pack_start( GTK_BOX(soundfont_file_bbox_vbox) , soundfont_file_bbox_rembt , FALSE , FALSE , 0 );
479 soundfont_file_bbox_mvupbt = gtk_button_new();
480 gtk_button_set_image( GTK_BUTTON(soundfont_file_bbox_mvupbt) ,
481 gtk_image_new_from_stock( GTK_STOCK_GO_UP , GTK_ICON_SIZE_MENU ) );
482 g_object_set_data( G_OBJECT(soundfont_file_bbox_mvupbt) , "swapdire" , GUINT_TO_POINTER(0) );
483 g_signal_connect( G_OBJECT(soundfont_file_bbox_mvupbt) , "clicked" ,
484 G_CALLBACK(i_configure_ev_sflist_swap) , soundfont_file_lv );
485 gtk_box_pack_start( GTK_BOX(soundfont_file_bbox_vbox) , soundfont_file_bbox_mvupbt , FALSE , FALSE , 0 );
486 soundfont_file_bbox_mvdownbt = gtk_button_new();
487 gtk_button_set_image( GTK_BUTTON(soundfont_file_bbox_mvdownbt) ,
488 gtk_image_new_from_stock( GTK_STOCK_GO_DOWN , GTK_ICON_SIZE_MENU ) );
489 g_object_set_data( G_OBJECT(soundfont_file_bbox_mvdownbt) , "swapdire" , GUINT_TO_POINTER(1) );
490 g_signal_connect( G_OBJECT(soundfont_file_bbox_mvdownbt) , "clicked" ,
491 G_CALLBACK(i_configure_ev_sflist_swap) , soundfont_file_lv );
492 gtk_box_pack_start( GTK_BOX(soundfont_file_bbox_vbox) , soundfont_file_bbox_mvdownbt , FALSE , FALSE , 0 );
493 gtk_box_pack_start( GTK_BOX(soundfont_file_hbox) , soundfont_file_lv_frame , TRUE , TRUE , 0 );
494 gtk_box_pack_start( GTK_BOX(soundfont_file_hbox) , soundfont_file_bbox_vbox , FALSE , FALSE , 0 );
495 gtk_box_pack_start( GTK_BOX(soundfont_vbox) , soundfont_file_hbox , FALSE , FALSE , 0 );
496
497 /* soundfont settings - load */
498 soundfont_load_hsep = gtk_hseparator_new();
499 soundfont_load_hbox = gtk_hbox_new( FALSE , 0 );
500 soundfont_load_option[0] = gtk_radio_button_new_with_label( NULL ,
501 _("Load SF on player start") );
502 g_object_set_data( G_OBJECT(soundfont_load_option[0]) , "val" , GINT_TO_POINTER(0) );
503 soundfont_load_option[1] = gtk_radio_button_new_with_label_from_widget(
504 GTK_RADIO_BUTTON(soundfont_load_option[0]) ,
505 _("Load SF on first midifile play") );
506 g_object_set_data( G_OBJECT(soundfont_load_option[1]) , "val" , GINT_TO_POINTER(1) );
507 if ( fsyncfg->fsyn_soundfont_load == 0 )
508 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(soundfont_load_option[0]) , TRUE );
509 else
510 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(soundfont_load_option[1]) , TRUE );
511 gtk_box_pack_start( GTK_BOX(soundfont_load_hbox) , soundfont_load_option[0] , TRUE , TRUE , 0 );
512 gtk_box_pack_start( GTK_BOX(soundfont_load_hbox) , gtk_vseparator_new() , FALSE , FALSE , 4 );
513 gtk_box_pack_start( GTK_BOX(soundfont_load_hbox) , soundfont_load_option[1] , TRUE , TRUE , 0 );
514 gtk_box_pack_start( GTK_BOX(soundfont_vbox) , soundfont_load_hsep , FALSE , FALSE , 3 );
515 gtk_box_pack_start( GTK_BOX(soundfont_vbox) , soundfont_load_hbox , FALSE , FALSE , 0 );
516
517 gtk_box_pack_start( GTK_BOX(content_vbox) , soundfont_frame , FALSE , FALSE , 0 );
518
519 /* synth settings */
520 synth_frame = gtk_frame_new( _("Synthesizer settings") );
521 synth_hbox = gtk_hbox_new( FALSE , 4 );
522 gtk_container_set_border_width( GTK_CONTAINER(synth_hbox), 4 );
523 gtk_container_add( GTK_CONTAINER(synth_frame) , synth_hbox );
524 synth_leftcol_vbox = gtk_vbox_new( TRUE , 0 );
525 synth_rightcol_vbox = gtk_vbox_new( FALSE , 0 );
526 gtk_box_pack_start( GTK_BOX(synth_hbox) , synth_leftcol_vbox , TRUE , TRUE , 0 );
527 gtk_box_pack_start( GTK_BOX(synth_hbox) , synth_rightcol_vbox , FALSE , FALSE , 0 );
528 /* synth settings - gain */
529 synth_gain_frame = gtk_frame_new( _("gain") );
530 gtk_frame_set_label_align( GTK_FRAME(synth_gain_frame) , 0.5 , 0.5 );
531 gtk_box_pack_start( GTK_BOX(synth_leftcol_vbox) , synth_gain_frame , TRUE , TRUE , 0 );
532 synth_gain_hbox = gtk_hbox_new( TRUE , 2 );
533 gtk_container_set_border_width( GTK_CONTAINER(synth_gain_hbox), 2 );
534 gtk_container_add( GTK_CONTAINER(synth_gain_frame) , synth_gain_hbox );
535 synth_gain_defcheckbt = gtk_check_button_new_with_label( _("use default") );
536 gtk_box_pack_start( GTK_BOX(synth_gain_hbox) , synth_gain_defcheckbt , FALSE , FALSE , 0 );
537 synth_gain_value_hbox = gtk_hbox_new( FALSE , 4 );
538 synth_gain_value_label = gtk_label_new( _("value:") );
539 synth_gain_value_spin = gtk_spin_button_new_with_range( 0.0 , 10.0 , 0.1 );
540 gtk_spin_button_set_value( GTK_SPIN_BUTTON(synth_gain_value_spin) , 0.2 );
541 g_signal_connect( G_OBJECT(synth_gain_defcheckbt) , "toggled" ,
542 G_CALLBACK(i_configure_ev_toggle_default) , synth_gain_value_hbox );
543 if ( fsyncfg->fsyn_synth_gain < 0 )
544 {
545 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(synth_gain_defcheckbt) , TRUE );
546 }
547 else
548 {
549 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(synth_gain_defcheckbt) , FALSE );
550 gtk_spin_button_set_value( GTK_SPIN_BUTTON(synth_gain_value_spin) ,
551 (gdouble)fsyncfg->fsyn_synth_gain / 10 );
552 }
553 gtk_box_pack_start( GTK_BOX(synth_gain_hbox) , synth_gain_value_hbox , FALSE , FALSE , 0 );
554 gtk_box_pack_start( GTK_BOX(synth_gain_value_hbox) , synth_gain_value_label , FALSE , FALSE , 0 );
555 gtk_box_pack_start( GTK_BOX(synth_gain_value_hbox) , synth_gain_value_spin , FALSE , FALSE , 0 );
556 /* synth settings - poliphony */
557 synth_poly_frame = gtk_frame_new( _("poliphony") );
558 gtk_frame_set_label_align( GTK_FRAME(synth_poly_frame) , 0.5 , 0.5 );
559 gtk_box_pack_start( GTK_BOX(synth_leftcol_vbox) , synth_poly_frame , TRUE , TRUE , 0 );
560 synth_poly_hbox = gtk_hbox_new( TRUE , 2 );
561 gtk_container_set_border_width( GTK_CONTAINER(synth_poly_hbox), 2 );
562 gtk_container_add( GTK_CONTAINER(synth_poly_frame) , synth_poly_hbox );
563 synth_poly_defcheckbt = gtk_check_button_new_with_label( _("use default") );
564 gtk_box_pack_start( GTK_BOX(synth_poly_hbox) , synth_poly_defcheckbt , FALSE , FALSE , 0 );
565 synth_poly_value_hbox = gtk_hbox_new( FALSE , 4 );
566 synth_poly_value_label = gtk_label_new( _("value:") );
567 synth_poly_value_spin = gtk_spin_button_new_with_range( 16 , 4096 , 1 );
568 gtk_spin_button_set_value( GTK_SPIN_BUTTON(synth_poly_value_spin) , 256 );
569 g_signal_connect( G_OBJECT(synth_poly_defcheckbt) , "toggled" ,
570 G_CALLBACK(i_configure_ev_toggle_default) , synth_poly_value_hbox );
571 if ( fsyncfg->fsyn_synth_poliphony < 0 )
572 {
573 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(synth_poly_defcheckbt) , TRUE );
574 }
575 else
576 {
577 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(synth_poly_defcheckbt) , FALSE );
578 gtk_spin_button_set_value( GTK_SPIN_BUTTON(synth_poly_value_spin) ,
579 (gdouble)fsyncfg->fsyn_synth_poliphony );
580 }
581 gtk_box_pack_start( GTK_BOX(synth_poly_hbox) , synth_poly_value_hbox , FALSE , FALSE , 0 );
582 gtk_box_pack_start( GTK_BOX(synth_poly_value_hbox) , synth_poly_value_label , FALSE , FALSE , 0 );
583 gtk_box_pack_start( GTK_BOX(synth_poly_value_hbox) , synth_poly_value_spin , FALSE , FALSE , 0 );
584 /* synth settings - reverb */
585 synth_reverb_frame = gtk_frame_new( _("reverb") );
586 gtk_frame_set_label_align( GTK_FRAME(synth_reverb_frame) , 0.5 , 0.5 );
587 gtk_box_pack_start( GTK_BOX(synth_leftcol_vbox) , synth_reverb_frame , TRUE , TRUE , 0 );
588 synth_reverb_hbox = gtk_hbox_new( TRUE , 2 );
589 gtk_container_set_border_width( GTK_CONTAINER(synth_reverb_hbox), 2 );
590 gtk_container_add( GTK_CONTAINER(synth_reverb_frame) , synth_reverb_hbox );
591 synth_reverb_defcheckbt = gtk_check_button_new_with_label( _("use default") );
592 gtk_box_pack_start( GTK_BOX(synth_reverb_hbox) , synth_reverb_defcheckbt , FALSE , FALSE , 0 );
593 synth_reverb_value_hbox = gtk_hbox_new( TRUE , 4 );
594 synth_reverb_value_option[0] = gtk_radio_button_new_with_label( NULL , _("yes") );
595 synth_reverb_value_option[1] = gtk_radio_button_new_with_label_from_widget(
596 GTK_RADIO_BUTTON(synth_reverb_value_option[0]) , _("no") );
597 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(synth_reverb_value_option[0]) , TRUE );
598 g_signal_connect( G_OBJECT(synth_reverb_defcheckbt) , "toggled" ,
599 G_CALLBACK(i_configure_ev_toggle_default) , synth_reverb_value_hbox );
600 if ( fsyncfg->fsyn_synth_reverb < 0 )
601 {
602 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(synth_reverb_defcheckbt) , TRUE );
603 }
604 else
605 {
606 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(synth_reverb_defcheckbt) , FALSE );
607 if ( fsyncfg->fsyn_synth_reverb == 0 )
608 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(synth_reverb_value_option[1]) , TRUE );
609 else
610 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(synth_reverb_value_option[0]) , TRUE );
611 }
612 gtk_box_pack_start( GTK_BOX(synth_reverb_hbox) , synth_reverb_value_hbox , FALSE , FALSE , 0 );
613 gtk_box_pack_start( GTK_BOX(synth_reverb_value_hbox) , synth_reverb_value_option[0] , FALSE , FALSE , 0 );
614 gtk_box_pack_start( GTK_BOX(synth_reverb_value_hbox) , synth_reverb_value_option[1] , FALSE , FALSE , 0 );
615 /* synth settings - chorus */
616 synth_chorus_frame = gtk_frame_new( _("chorus") );
617 gtk_frame_set_label_align( GTK_FRAME(synth_chorus_frame) , 0.5 , 0.5 );
618 gtk_box_pack_start( GTK_BOX(synth_leftcol_vbox) , synth_chorus_frame , TRUE , TRUE , 0 );
619 synth_chorus_hbox = gtk_hbox_new( TRUE , 2 );
620 gtk_container_set_border_width( GTK_CONTAINER(synth_chorus_hbox), 2 );
621 gtk_container_add( GTK_CONTAINER(synth_chorus_frame) , synth_chorus_hbox );
622 synth_chorus_defcheckbt = gtk_check_button_new_with_label( _("use default") );
623 gtk_box_pack_start( GTK_BOX(synth_chorus_hbox) , synth_chorus_defcheckbt , FALSE , FALSE , 0 );
624 synth_chorus_value_hbox = gtk_hbox_new( TRUE , 4 );
625 synth_chorus_value_option[0] = gtk_radio_button_new_with_label( NULL , _("yes") );
626 synth_chorus_value_option[1] = gtk_radio_button_new_with_label_from_widget(
627 GTK_RADIO_BUTTON(synth_chorus_value_option[0]) , _("no") );
628 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(synth_chorus_value_option[0]) , TRUE );
629 g_signal_connect( G_OBJECT(synth_chorus_defcheckbt) , "toggled" ,
630 G_CALLBACK(i_configure_ev_toggle_default) , synth_chorus_value_hbox );
631 if ( fsyncfg->fsyn_synth_chorus < 0 )
632 {
633 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(synth_chorus_defcheckbt) , TRUE );
634 }
635 else
636 {
637 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(synth_chorus_defcheckbt) , FALSE );
638 if ( fsyncfg->fsyn_synth_chorus == 0 )
639 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(synth_chorus_value_option[1]) , TRUE );
640 else
641 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(synth_chorus_value_option[0]) , TRUE );
642 }
643 gtk_box_pack_start( GTK_BOX(synth_chorus_hbox) , synth_chorus_value_hbox , FALSE , FALSE , 0 );
644 gtk_box_pack_start( GTK_BOX(synth_chorus_value_hbox) , synth_chorus_value_option[0] , FALSE , FALSE , 0 );
645 gtk_box_pack_start( GTK_BOX(synth_chorus_value_hbox) , synth_chorus_value_option[1] , FALSE , FALSE , 0 );
646 /* synth settings - samplerate */
647 synth_samplerate_frame = gtk_frame_new( _("sample rate") );
648 gtk_frame_set_label_align( GTK_FRAME(synth_samplerate_frame) , 0.5 , 0.5 );
649 synth_samplerate_vbox = gtk_vbox_new( TRUE , 0 );
650 gtk_container_set_border_width( GTK_CONTAINER(synth_samplerate_vbox), 6 );
651 gtk_container_add( GTK_CONTAINER(synth_samplerate_frame) , synth_samplerate_vbox );
652 gtk_box_pack_start( GTK_BOX(synth_rightcol_vbox) , synth_samplerate_frame , FALSE , FALSE , 0 );
653 synth_samplerate_option[0] = gtk_radio_button_new_with_label( NULL , "22050 Hz " );
654 g_object_set_data( G_OBJECT(synth_samplerate_option[0]) , "val" , GINT_TO_POINTER(22050) );
655 synth_samplerate_option[1] = gtk_radio_button_new_with_label_from_widget(
656 GTK_RADIO_BUTTON(synth_samplerate_option[0]) , "44100 Hz " );
657 g_object_set_data( G_OBJECT(synth_samplerate_option[1]) , "val" , GINT_TO_POINTER(44100) );
658 synth_samplerate_option[2] = gtk_radio_button_new_with_label_from_widget(
659 GTK_RADIO_BUTTON(synth_samplerate_option[0]) , "96000 Hz " );
660 g_object_set_data( G_OBJECT(synth_samplerate_option[2]) , "val" , GINT_TO_POINTER(96000) );
661 synth_samplerate_option[3] = gtk_radio_button_new_with_label_from_widget(
662 GTK_RADIO_BUTTON(synth_samplerate_option[0]) , _("custom ") );
663 synth_samplerate_optionhbox = gtk_hbox_new( FALSE , 4 );
664 synth_samplerate_optionentry = gtk_entry_new();
665 gtk_widget_set_sensitive( GTK_WIDGET(synth_samplerate_optionentry) , FALSE );
666 gtk_entry_set_width_chars( GTK_ENTRY(synth_samplerate_optionentry) , 8 );
667 gtk_entry_set_max_length( GTK_ENTRY(synth_samplerate_optionentry) , 5 );
668 g_object_set_data( G_OBJECT(synth_samplerate_option[3]) , "customentry" , synth_samplerate_optionentry );
669 g_signal_connect( G_OBJECT(synth_samplerate_option[3]) , "toggled" ,
670 G_CALLBACK(i_configure_ev_sysamplerate_togglecustom) , synth_samplerate_optionentry );
671 synth_samplerate_optionlabel = gtk_label_new( "Hz " );
672 gtk_box_pack_start( GTK_BOX(synth_samplerate_optionhbox) , synth_samplerate_optionentry , TRUE , TRUE , 0 );
673 gtk_box_pack_start( GTK_BOX(synth_samplerate_optionhbox) , synth_samplerate_optionlabel , FALSE , FALSE , 0 );
674 switch ( fsyncfg->fsyn_synth_samplerate )
675 {
676 case 22050:
677 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(synth_samplerate_option[0]) , TRUE );
678 break;
679 case 44100:
680 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(synth_samplerate_option[1]) , TRUE );
681 break;
682 case 96000:
683 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(synth_samplerate_option[2]) , TRUE );
684 break;
685 default:
686 if (( fsyncfg->fsyn_synth_samplerate > 22050 ) && ( fsyncfg->fsyn_synth_samplerate < 96000 ))
687 {
688 gchar *samplerate_value = g_strdup_printf( "%i" , fsyncfg->fsyn_synth_samplerate );
689 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(synth_samplerate_option[3]) , TRUE );
690 gtk_entry_set_text( GTK_ENTRY(synth_samplerate_optionentry) , samplerate_value );
691 g_free( samplerate_value );
692 }
693 else
694 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(synth_samplerate_option[1]) , TRUE );
695 }
696 gtk_box_pack_start( GTK_BOX(synth_samplerate_vbox) , synth_samplerate_option[0] , FALSE , FALSE , 0 );
697 gtk_box_pack_start( GTK_BOX(synth_samplerate_vbox) , synth_samplerate_option[1] , FALSE , FALSE , 0 );
698 gtk_box_pack_start( GTK_BOX(synth_samplerate_vbox) , synth_samplerate_option[2] , FALSE , FALSE , 0 );
699 gtk_box_pack_start( GTK_BOX(synth_samplerate_vbox) , synth_samplerate_option[3] , FALSE , FALSE , 0 );
700 gtk_box_pack_start( GTK_BOX(synth_samplerate_vbox) , synth_samplerate_optionhbox , FALSE , FALSE , 0 );
701
702 gtk_box_pack_start( GTK_BOX(content_vbox) , synth_frame , TRUE , TRUE , 0 );
703
704 /* buffer settings */
705 buffer_frame = gtk_frame_new( _("Buffer settings") );
706 buffer_table = gtk_table_new( 2 , 9 , FALSE );
707 gtk_table_set_col_spacings( GTK_TABLE(buffer_table) , 2 );
708 gtk_container_set_border_width( GTK_CONTAINER(buffer_table), 4 );
709 gtk_container_add( GTK_CONTAINER(buffer_frame) , buffer_table );
710 /* buffer settings - slider */
711 buffer_tuner_defbt = gtk_button_new();
712 buffer_tuner_defbt_label = gtk_label_new( "" );
713 gtk_label_set_markup( GTK_LABEL(buffer_tuner_defbt_label) ,
714 _("<span size=\"smaller\">def</span>") );
715 gtk_container_add( GTK_CONTAINER(buffer_tuner_defbt) , buffer_tuner_defbt_label );
716 gtk_table_attach( GTK_TABLE(buffer_table) , buffer_tuner_defbt , 0 , 1 , 0 , 2 ,
717 0 , GTK_FILL , 2 , 0 );
718 buffer_vsep[0] = gtk_vseparator_new();
719 gtk_table_attach( GTK_TABLE(buffer_table) , buffer_vsep[0] , 1 , 2 , 0 , 2 ,
720 0 , GTK_FILL , 0 , 0 );
721 buffer_tuner_label = gtk_label_new( "" );
722 gtk_label_set_markup( GTK_LABEL(buffer_tuner_label) ,
723 _("<span size=\"smaller\">handy buffer tuner</span>") );
724 buffer_tuner_hscale = gtk_hscale_new_with_range( 0 , 53 , 1 );
725 gtk_scale_set_draw_value( GTK_SCALE(buffer_tuner_hscale) , FALSE );
726 i_configure_buffertuner_setvalue( buffer_tuner_hscale , fsyncfg->fsyn_buffer_size );
727 gtk_table_attach( GTK_TABLE(buffer_table) , buffer_tuner_label , 2 , 3 , 0 , 1 ,
728 GTK_EXPAND | GTK_FILL , GTK_EXPAND | GTK_FILL , 0 , 0 );
729 gtk_table_attach( GTK_TABLE(buffer_table) , buffer_tuner_hscale , 2 , 3 , 1 , 2 ,
730 GTK_EXPAND | GTK_FILL , GTK_EXPAND | GTK_FILL , 0 , 0 );
731 buffer_vsep[1] = gtk_vseparator_new();
732 gtk_table_attach( GTK_TABLE(buffer_table) , buffer_vsep[1] , 3 , 4 , 0 , 2 ,
733 0 , GTK_FILL , 0 , 0 );
734 /* buffer settings - size */
735 buffer_bufsize_label = gtk_label_new( "" );
736 gtk_label_set_markup( GTK_LABEL(buffer_bufsize_label) ,
737 _("<span size=\"smaller\">size</span>") );
738 buffer_bufsize_spin = gtk_spin_button_new_with_range( 100 , 99999 , 20 );
739 gtk_spin_button_set_value( GTK_SPIN_BUTTON(buffer_bufsize_spin) ,
740 (gdouble)fsyncfg->fsyn_buffer_size );
741 gtk_table_attach( GTK_TABLE(buffer_table) , buffer_bufsize_label , 4 , 5 , 0 , 1 ,
742 GTK_FILL , 0 , 1 , 1 );
743 gtk_table_attach( GTK_TABLE(buffer_table) , buffer_bufsize_spin , 4 , 5 , 1 , 2 ,
744 0 , 0 , 1 , 1 );
745 buffer_vsep[2] = gtk_vseparator_new();
746 gtk_table_attach( GTK_TABLE(buffer_table) , buffer_vsep[2] , 5 , 6 , 0 , 2 ,
747 0 , GTK_FILL , 0 , 0 );
748 /* buffer settings - margin */
749 buffer_marginsize_label = gtk_label_new( "" );
750 gtk_label_set_markup( GTK_LABEL(buffer_marginsize_label) ,
751 _("<span size=\"smaller\">margin</span>") );
752 buffer_marginsize_spin = gtk_spin_button_new_with_range( 0 , 100 , 1 );
753 gtk_spin_button_set_value( GTK_SPIN_BUTTON(buffer_marginsize_spin) ,
754 (gdouble)fsyncfg->fsyn_buffer_margin );
755 gtk_table_attach( GTK_TABLE(buffer_table) , buffer_marginsize_label , 6 , 7 , 0 , 1 ,
756 GTK_FILL , 0 , 1 , 1 );
757 gtk_table_attach( GTK_TABLE(buffer_table) , buffer_marginsize_spin , 6 , 7 , 1 , 2 ,
758 0 , 0 , 1 , 1 );
759 buffer_vsep[3] = gtk_vseparator_new();
760 gtk_table_attach( GTK_TABLE(buffer_table) , buffer_vsep[3] , 7 , 8 , 0 , 2 ,
761 0 , GTK_FILL , 0 , 0 );
762 /* buffer settings - increment */
763 buffer_margininc_label = gtk_label_new( "" );
764 gtk_label_set_markup( GTK_LABEL(buffer_margininc_label) ,
765 _("<span size=\"smaller\">increment</span>") );
766 buffer_margininc_spin = gtk_spin_button_new_with_range( 6 , 1000 , 1 );
767 gtk_spin_button_set_value( GTK_SPIN_BUTTON(buffer_margininc_spin) ,
768 (gdouble)fsyncfg->fsyn_buffer_increment );
769 gtk_table_attach( GTK_TABLE(buffer_table) , buffer_margininc_label , 8 , 9 , 0 , 1 ,
770 GTK_FILL , 0 , 1 , 1 );
771 gtk_table_attach( GTK_TABLE(buffer_table) , buffer_margininc_spin , 8 , 9 , 1 , 2 ,
772 0 , 0 , 1 , 1 );
773
774 g_object_set_data( G_OBJECT(buffer_tuner_hscale) , "bufsize_spin" , buffer_bufsize_spin );
775 g_object_set_data( G_OBJECT(buffer_tuner_hscale) , "bufmarginsize_spin" , buffer_marginsize_spin );
776 g_object_set_data( G_OBJECT(buffer_tuner_hscale) , "bufmargininc_spin" , buffer_margininc_spin );
777 g_signal_connect_swapped( G_OBJECT(buffer_tuner_defbt) , "clicked" ,
778 G_CALLBACK(i_configure_ev_buffertuner_default) , buffer_tuner_hscale );
779 g_signal_connect( G_OBJECT(buffer_tuner_hscale) , "value-changed" ,
780 G_CALLBACK(i_configure_ev_buffertuner_valuechanged) , NULL );
781
782 gtk_box_pack_start( GTK_BOX(content_vbox) , buffer_frame , FALSE , FALSE , 0 );
783
784 /* commit events */
785 g_signal_connect_swapped( G_OBJECT(commit_button) , "ap-commit" ,
786 G_CALLBACK(i_configure_ev_sflist_commit) , soundfont_file_lv );
787 g_signal_connect_swapped( G_OBJECT(commit_button) , "ap-commit" ,
788 G_CALLBACK(i_configure_ev_sfload_commit) , soundfont_load_option[0] );
789 g_signal_connect_swapped( G_OBJECT(commit_button) , "ap-commit" ,
790 G_CALLBACK(i_configure_ev_sygain_commit) , synth_gain_value_spin );
791 g_signal_connect_swapped( G_OBJECT(commit_button) , "ap-commit" ,
792 G_CALLBACK(i_configure_ev_sypoly_commit) , synth_poly_value_spin );
793 g_signal_connect_swapped( G_OBJECT(commit_button) , "ap-commit" ,
794 G_CALLBACK(i_configure_ev_syreverb_commit) , synth_reverb_value_option[0] );
795 g_signal_connect_swapped( G_OBJECT(commit_button) , "ap-commit" ,
796 G_CALLBACK(i_configure_ev_sychorus_commit) , synth_chorus_value_option[0] );
797 g_signal_connect_swapped( G_OBJECT(commit_button) , "ap-commit" ,
798 G_CALLBACK(i_configure_ev_sysamplerate_commit) , synth_samplerate_option[3] );
799 g_signal_connect_swapped( G_OBJECT(commit_button) , "ap-commit" ,
800 G_CALLBACK(i_configure_ev_bufsize_commit) , buffer_bufsize_spin );
801 g_signal_connect_swapped( G_OBJECT(commit_button) , "ap-commit" ,
802 G_CALLBACK(i_configure_ev_bufmarginsize_commit) , buffer_marginsize_spin );
803 g_signal_connect_swapped( G_OBJECT(commit_button) , "ap-commit" ,
804 G_CALLBACK(i_configure_ev_bufmargininc_commit) , buffer_margininc_spin );
805
806 gtk_tooltips_set_tip( GTK_TOOLTIPS(tips) , soundfont_file_lv ,
807 _("* Select SoundFont files *\n"
808 "In order to play MIDI with FluidSynth, you need to specify at "
809 "least one valid SoundFont file here (use absolute paths). The "
810 "loading order is from the top (first) to the bottom (last).") , "" );
811 gtk_tooltips_set_tip( GTK_TOOLTIPS(tips) , soundfont_load_option[0] ,
812 _("* Load SoundFont on player start *\n"
813 "Depending on your system speed, SoundFont loading in FluidSynth will "
814 "require up to a few seconds. This is a one-time task (the soundfont "
815 "will stay loaded until it is changed or the backend is unloaded) that "
816 "can be done at player start, or before the first MIDI file is played "
817 "(the latter is a better choice if you don't use your player to listen "
818 "MIDI files only).") , "" );
819 gtk_tooltips_set_tip( GTK_TOOLTIPS(tips) , soundfont_load_option[1] ,
820 _("* Load SoundFont on first midifile play *\n"
821 "Depending on your system speed, SoundFont loading in FluidSynth will "
822 "require up to a few seconds. This is a one-time task (the soundfont "
823 "will stay loaded until it is changed or the backend is unloaded) that "
824 "can be done at player start, or before the first MIDI file is played "
825 "(the latter is a better choice if you don't use your player to listen "
826 "MIDI files only).") , "" );
827 gtk_tooltips_set_tip( GTK_TOOLTIPS(tips) , synth_gain_value_spin ,
828 _("* Synthesizer gain *\n"
829 "From FluidSynth docs: the gain is applied to the final or master output "
830 "of the synthesizer; it is set to a low value by default to avoid the "
831 "saturation of the output when random MIDI files are played.") , "" );
832 gtk_tooltips_set_tip( GTK_TOOLTIPS(tips) , synth_poly_value_spin ,
833 _("* Synthesizer polyphony *\n"
834 "From FluidSynth docs: the polyphony defines how many voices can be played "
835 "in parallel; the number of voices is not necessarily equivalent to the "
836 "number of notes played simultaneously; indeed, when a note is struck on a "
837 "specific MIDI channel, the preset on that channel may create several voices, "
838 "for example, one for the left audio channel and one for the right audio "
839 "channels; the number of voices activated depends on the number of instrument "
840 "zones that fall in the correspond to the velocity and key of the played "
841 "note.") , "" );
842 gtk_tooltips_set_tip( GTK_TOOLTIPS(tips) , synth_reverb_value_option[0] ,
843 _("* Synthesizer reverb *\n"
844 "From FluidSynth docs: when set to \"yes\" the reverb effects module is "
845 "activated; note that when the reverb module is active, the amount of "
846 "signal sent to the reverb module depends on the \"reverb send\" generator "
847 "defined in the SoundFont.") , "" );
848 gtk_tooltips_set_tip( GTK_TOOLTIPS(tips) , synth_reverb_value_option[1] ,
849 _("* Synthesizer reverb *\n"
850 "From FluidSynth docs: when set to \"yes\" the reverb effects module is "
851 "activated; note that when the reverb module is active, the amount of "
852 "signal sent to the reverb module depends on the \"reverb send\" generator "
853 "defined in the SoundFont.") , "" );
854 gtk_tooltips_set_tip( GTK_TOOLTIPS(tips) , synth_chorus_value_option[0] ,
855 _("* Synthesizer chorus *\n"
856 "From FluidSynth docs: when set to \"yes\" the chorus effects module is "
857 "activated; note that when the chorus module is active, the amount of "
858 "signal sent to the chorus module depends on the \"chorus send\" generator "
859 "defined in the SoundFont.") , "" );
860 gtk_tooltips_set_tip( GTK_TOOLTIPS(tips) , synth_chorus_value_option[1] ,
861 _("* Synthesizer chorus *\n"
862 "From FluidSynth docs: when set to \"yes\" the chorus effects module is "
863 "activated; note that when the chorus module is active, the amount of "
864 "signal sent to the chorus module depends on the \"chorus send\" generator "
865 "defined in the SoundFont.") , "" );
866 gtk_tooltips_set_tip( GTK_TOOLTIPS(tips) , synth_samplerate_option[0] ,
867 _("* Synthesizer samplerate *\n"
868 "The sample rate of the audio generated by the synthesizer. You can also specify "
869 "a custom value in the interval 22050Hz-96000Hz.\n"
870 "NOTE: the default buffer parameters are tuned for 44100Hz; changing the sample "
871 "rate may require buffer params tuning to obtain good sound quality.") , "" );
872 gtk_tooltips_set_tip( GTK_TOOLTIPS(tips) , synth_samplerate_option[1] ,
873 _("* Synthesizer samplerate *\n"
874 "The sample rate of the audio generated by the synthesizer. You can also specify "
875 "a custom value in the interval 22050Hz-96000Hz.\n"
876 "NOTE: the default buffer parameters are tuned for 44100Hz; changing the sample "
877 "rate may require buffer params tuning to obtain good sound quality.") , "" );
878 gtk_tooltips_set_tip( GTK_TOOLTIPS(tips) , synth_samplerate_option[2] ,
879 _("* Synthesizer samplerate *\n"
880 "The sample rate of the audio generated by the synthesizer. You can also specify "
881 "a custom value in the interval 22050Hz-96000Hz.\n"
882 "NOTE: the default buffer parameters are tuned for 44100Hz; changing the sample "
883 "rate may require buffer params tuning to obtain good sound quality.") , "" );
884 gtk_tooltips_set_tip( GTK_TOOLTIPS(tips) , synth_samplerate_option[3] ,
885 _("* Synthesizer samplerate *\n"
886 "The sample rate of the audio generated by the synthesizer. You can also specify "
887 "a custom value in the interval 22050Hz-96000Hz.\n"
888 "NOTE: the default buffer parameters are tuned for 44100Hz; changing the sample "
889 "rate may require buffer params tuning to obtain good sound quality.") , "" );
890 gtk_tooltips_set_tip( GTK_TOOLTIPS(tips) , buffer_tuner_defbt ,
891 _("* FluidSynth backend buffer *\n"
892 "This button resets the backend buffer parameters to default values.") , "" );
893 gtk_tooltips_set_tip( GTK_TOOLTIPS(tips) , buffer_tuner_hscale ,
894 _("* FluidSynth backend buffer *\n"
895 "If you notice skips during song playback and your system is not performing "
896 "any cpu-intensive task (except FluidSynth itself), you may want to tune the "
897 "buffer in order to prevent skipping. Try to move the \"handy buffer tuner\" "
898 "a single step to the right until playback is fluid again.") , "" );
899 gtk_tooltips_set_tip( GTK_TOOLTIPS(tips) , buffer_bufsize_spin ,
900 _("* FluidSynth backend buffer *\n"
901 "It is a good idea to make buffer adjustments with the \"handy buffer tuner\" "
902 "before resorting to manual editing of buffer parameters.\n"
903 "However, if you want to fine-tune something and want to know what you're doing, "
904 "you can understand how these parameters work by reading the backend code "
905 "(b-fluidsynth.c). In short words, every amount of time "
906 "(proportional to buffer_SIZE and sample rate), right before gathering samples, "
907 "the buffer is resized as follows:\n"
908 "buffer_SIZE + buffer_MARGIN + extramargin\nwhere extramargin is a value "
909 "computed as number_of_seconds_of_playback / margin_INCREMENT .") , "" );
910 gtk_tooltips_set_tip( GTK_TOOLTIPS(tips) , buffer_marginsize_spin ,
911 _("* FluidSynth backend buffer *\n"
912 "It is a good idea to make buffer adjustments with the \"handy buffer tuner\" "
913 "before resorting to manual editing of buffer parameters.\n"
914 "However, if you want to fine-tune something and want to know what you're doing, "
915 "you can understand how these parameters work by reading the backend code "
916 "(b-fluidsynth.c). In short words, every amount of time "
917 "(proportional to buffer_SIZE and sample rate), right before gathering samples, "
918 "the buffer is resized as follows:\n"
919 "buffer_SIZE + buffer_MARGIN + extramargin\nwhere extramargin is a value "
920 "computed as number_of_seconds_of_playback / margin_INCREMENT .") , "" );
921 gtk_tooltips_set_tip( GTK_TOOLTIPS(tips) , buffer_margininc_spin ,
922 _("* FluidSynth backend buffer *\n"
923 "It is a good idea to make buffer adjustments with the \"handy buffer tuner\" "
924 "before resorting to manual editing of buffer parameters.\n"
925 "However, if you want to fine-tune something and want to know what you're doing, "
926 "you can understand how these parameters work by reading the backend code "
927 "(b-fluidsynth.c). In short words, every amount of time "
928 "(proportional to buffer_SIZE and sample rate), right before gathering samples, "
929 "the buffer is resized as follows:\n"
930 "buffer_SIZE + buffer_MARGIN + extramargin\nwhere extramargin is a value "
931 "computed as number_of_seconds_of_playback / margin_INCREMENT .") , "" );
932 }
933 else
934 {
935 /* display "not available" information */
936 GtkWidget * info_label;
937 info_label = gtk_label_new( _("FluidSynth Backend not loaded or not available") );
938 gtk_box_pack_start( GTK_BOX(fsyn_page_vbox) , info_label , FALSE , FALSE , 2 );
939 }
940
941 gtk_box_pack_start( GTK_BOX(fsyn_page_vbox) , content_vbox , TRUE , TRUE , 2 );
942 gtk_container_add( GTK_CONTAINER(fsyn_page_alignment) , fsyn_page_vbox );
943 }
944
945
946 void i_configure_gui_tablabel_fsyn( GtkWidget * fsyn_page_alignment ,
947 gpointer backend_list_p ,
948 gpointer commit_button )
949 {
950 GtkWidget *pagelabel_vbox, *pagelabel_image, *pagelabel_label;
951 GdkPixbuf *pagelabel_image_pix;
952 pagelabel_vbox = gtk_vbox_new( FALSE , 1 );
953 pagelabel_image_pix = gdk_pixbuf_new_from_xpm_data( (const gchar **)backend_fluidsynth_icon_xpm );
954 pagelabel_image = gtk_image_new_from_pixbuf( pagelabel_image_pix ); g_object_unref( pagelabel_image_pix );
955 pagelabel_label = gtk_label_new( "" );
956 gtk_label_set_markup( GTK_LABEL(pagelabel_label) , "<span size=\"smaller\">FluidSynth\nbackend</span>" );
957 gtk_label_set_justify( GTK_LABEL(pagelabel_label) , GTK_JUSTIFY_CENTER );
958 gtk_box_pack_start( GTK_BOX(pagelabel_vbox) , pagelabel_image , FALSE , FALSE , 1 );
959 gtk_box_pack_start( GTK_BOX(pagelabel_vbox) , pagelabel_label , FALSE , FALSE , 1 );
960 gtk_container_add( GTK_CONTAINER(fsyn_page_alignment) , pagelabel_vbox );
961 gtk_widget_show_all( fsyn_page_alignment );
962 return;
963 }
964
965
966 void i_configure_cfg_fsyn_alloc( void )
967 {
968 amidiplug_cfg_fsyn_t * fsyncfg = g_malloc(sizeof(amidiplug_cfg_fsyn_t));
969 amidiplug_cfg_backend->fsyn = fsyncfg;
970 }
971
972
973 void i_configure_cfg_fsyn_free( void )
974 {
975 amidiplug_cfg_fsyn_t * fsyncfg = amidiplug_cfg_backend->fsyn;
976 g_free( fsyncfg->fsyn_soundfont_file );
977 }
978
979
980 void i_configure_cfg_fsyn_read( pcfg_t * cfgfile )
981 {
982 amidiplug_cfg_fsyn_t * fsyncfg = amidiplug_cfg_backend->fsyn;
983
984 if (!cfgfile)
985 {
986 /* fluidsynth backend defaults */
987 fsyncfg->fsyn_soundfont_file = g_strdup( "" );
988 fsyncfg->fsyn_soundfont_load = 1;
989 fsyncfg->fsyn_synth_samplerate = 44100;
990 fsyncfg->fsyn_synth_gain = -1;
991 fsyncfg->fsyn_synth_poliphony = -1;
992 fsyncfg->fsyn_synth_reverb = -1;
993 fsyncfg->fsyn_synth_chorus = -1;
994 fsyncfg->fsyn_buffer_size = 512;
995 fsyncfg->fsyn_buffer_margin = 10;
996 fsyncfg->fsyn_buffer_increment = 18;
997 }
998 else
999 {
1000 i_pcfg_read_string( cfgfile , "fsyn" , "fsyn_soundfont_file" , &fsyncfg->fsyn_soundfont_file , "" );
1001 i_pcfg_read_integer( cfgfile , "fsyn" , "fsyn_soundfont_load" , &fsyncfg->fsyn_soundfont_load , 1 );
1002 i_pcfg_read_integer( cfgfile , "fsyn" , "fsyn_synth_samplerate" , &fsyncfg->fsyn_synth_samplerate , 44100 );
1003 i_pcfg_read_integer( cfgfile , "fsyn" , "fsyn_synth_gain" , &fsyncfg->fsyn_synth_gain , -1 );
1004 i_pcfg_read_integer( cfgfile , "fsyn" , "fsyn_synth_poliphony" , &fsyncfg->fsyn_synth_poliphony , -1 );
1005 i_pcfg_read_integer( cfgfile , "fsyn" , "fsyn_synth_reverb" , &fsyncfg->fsyn_synth_reverb , -1 );
1006 i_pcfg_read_integer( cfgfile , "fsyn" , "fsyn_synth_chorus" , &fsyncfg->fsyn_synth_chorus , -1 );
1007 i_pcfg_read_integer( cfgfile , "fsyn" , "fsyn_buffer_size" , &fsyncfg->fsyn_buffer_size , 512 );
1008 i_pcfg_read_integer( cfgfile , "fsyn" , "fsyn_buffer_margin" , &fsyncfg->fsyn_buffer_margin , 15 );
1009 i_pcfg_read_integer( cfgfile , "fsyn" , "fsyn_buffer_increment" , &fsyncfg->fsyn_buffer_increment , 18 );
1010 }
1011 }
1012
1013
1014 void i_configure_cfg_fsyn_save( pcfg_t * cfgfile )
1015 {
1016 amidiplug_cfg_fsyn_t * fsyncfg = amidiplug_cfg_backend->fsyn;
1017
1018 i_pcfg_write_string( cfgfile , "fsyn" , "fsyn_soundfont_file" , fsyncfg->fsyn_soundfont_file );
1019 i_pcfg_write_integer( cfgfile , "fsyn" , "fsyn_soundfont_load" , fsyncfg->fsyn_soundfont_load );
1020 i_pcfg_write_integer( cfgfile , "fsyn" , "fsyn_synth_samplerate" , fsyncfg->fsyn_synth_samplerate );
1021 i_pcfg_write_integer( cfgfile , "fsyn" , "fsyn_synth_gain" , fsyncfg->fsyn_synth_gain );
1022 i_pcfg_write_integer( cfgfile , "fsyn" , "fsyn_synth_poliphony" , fsyncfg->fsyn_synth_poliphony );
1023 i_pcfg_write_integer( cfgfile , "fsyn" , "fsyn_synth_reverb" , fsyncfg->fsyn_synth_reverb );
1024 i_pcfg_write_integer( cfgfile , "fsyn" , "fsyn_synth_chorus" , fsyncfg->fsyn_synth_chorus );
1025 i_pcfg_write_integer( cfgfile , "fsyn" , "fsyn_buffer_size" , fsyncfg->fsyn_buffer_size );
1026 i_pcfg_write_integer( cfgfile , "fsyn" , "fsyn_buffer_margin" , fsyncfg->fsyn_buffer_margin );
1027 i_pcfg_write_integer( cfgfile , "fsyn" , "fsyn_buffer_increment" , fsyncfg->fsyn_buffer_increment );
1028 }