2313
|
1 /* Audacious - Cross-platform multimedia player
|
|
2 * Copyright (C) 2005-2006 Audacious development team.
|
|
3 *
|
|
4 * BMP - Cross-platform multimedia player
|
|
5 * Copyright (C) 2003-2004 BMP development team.
|
|
6 *
|
|
7 * This program is free software; you can redistribute it and/or modify
|
|
8 * it under the terms of the GNU General Public License as published by
|
|
9 * the Free Software Foundation; under version 2 of the License.
|
|
10 *
|
|
11 * This program is distributed in the hope that it will be useful,
|
|
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
14 * GNU General Public License for more details.
|
|
15 *
|
|
16 * You should have received a copy of the GNU General Public License
|
|
17 * along with this program; if not, write to the Free Software
|
|
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
19 */
|
|
20
|
|
21 #ifdef HAVE_CONFIG_H
|
|
22 # include "config.h"
|
|
23 #endif
|
|
24
|
|
25 #include <glib.h>
|
|
26 #include <glib/gi18n.h>
|
|
27 #include <gtk/gtk.h>
|
|
28 #include <glade/glade.h>
|
|
29 #include <string.h>
|
|
30 #include <stddef.h>
|
|
31 #include <stdio.h>
|
|
32 #include <sys/types.h>
|
|
33 #include <dirent.h>
|
|
34 #include <unistd.h>
|
|
35 #include <errno.h>
|
|
36 #include <sys/types.h>
|
|
37 #include <sys/stat.h>
|
|
38
|
|
39 #include "glade.h"
|
|
40
|
|
41 #include "plugin.h"
|
|
42 #include "pluginenum.h"
|
|
43 #include "input.h"
|
|
44 #include "effect.h"
|
|
45 #include "general.h"
|
|
46 #include "output.h"
|
|
47 #include "visualization.h"
|
|
48
|
|
49 #include "main.h"
|
|
50 #include "widgets/widgetcore.h"
|
|
51 #include "libaudacious/urldecode.h"
|
|
52 #include "util.h"
|
|
53 #include "dnd.h"
|
|
54 #include "libaudacious/configdb.h"
|
|
55
|
|
56 #include "ui_main.h"
|
|
57 #include "ui_playlist.h"
|
|
58 #include "ui_skinselector.h"
|
|
59 #include "ui_preferences.h"
|
2328
|
60 #include "ui_equalizer.h"
|
2313
|
61
|
|
62 #include "build_stamp.h"
|
|
63
|
|
64 enum CategoryViewCols {
|
|
65 CATEGORY_VIEW_COL_ICON,
|
|
66 CATEGORY_VIEW_COL_NAME,
|
|
67 CATEGORY_VIEW_COL_ID,
|
|
68 CATEGORY_VIEW_N_COLS
|
|
69 };
|
|
70
|
|
71 enum PluginViewCols {
|
|
72 PLUGIN_VIEW_COL_ACTIVE,
|
|
73 PLUGIN_VIEW_COL_DESC,
|
|
74 PLUGIN_VIEW_COL_FILENAME,
|
|
75 PLUGIN_VIEW_COL_ID,
|
|
76 PLUGIN_VIEW_N_COLS
|
|
77 };
|
|
78
|
|
79
|
|
80 typedef struct {
|
|
81 const gchar *icon_path;
|
|
82 const gchar *name;
|
|
83 gint id;
|
|
84 } Category;
|
|
85
|
|
86 typedef struct {
|
|
87 const gchar *name;
|
|
88 const gchar *tag;
|
|
89 }
|
|
90 TitleFieldTag;
|
|
91
|
|
92 static GtkWidget *prefswin = NULL;
|
|
93 static GtkWidget *filepopup_settings = NULL;
|
|
94 static GtkWidget *colorize_settings = NULL;
|
|
95 static GtkWidget *category_treeview = NULL;
|
|
96 static GtkWidget *category_notebook = NULL;
|
|
97 GtkWidget *filepopupbutton = NULL;
|
|
98
|
|
99 static Category categories[] = {
|
|
100 {DATA_DIR "/images/appearance.png", N_("Appearance"), 1},
|
|
101 {DATA_DIR "/images/audio.png", N_("Audio"), 6},
|
|
102 {DATA_DIR "/images/connectivity.png", N_("Connectivity"), 5},
|
|
103 {DATA_DIR "/images/eq.png", N_("Equalizer"), 4},
|
|
104 {DATA_DIR "/images/mouse.png", N_("Mouse"), 2},
|
|
105 {DATA_DIR "/images/playlist.png", N_("Playlist"), 3},
|
|
106 {DATA_DIR "/images/plugins.png", N_("Plugins"), 0},
|
|
107 };
|
|
108
|
|
109 static gint n_categories = G_N_ELEMENTS(categories);
|
|
110
|
|
111 static TitleFieldTag title_field_tags[] = {
|
|
112 { N_("Artist") , "%p" },
|
|
113 { N_("Album") , "%a" },
|
|
114 { N_("Title") , "%t" },
|
|
115 { N_("Tracknumber"), "%n" },
|
|
116 { N_("Genre") , "%g" },
|
|
117 { N_("Filename") , "%f" },
|
|
118 { N_("Filepath") , "%F" },
|
|
119 { N_("Date") , "%d" },
|
|
120 { N_("Year") , "%y" },
|
|
121 { N_("Comment") , "%c" }
|
|
122 };
|
|
123
|
|
124 typedef struct {
|
|
125 void *next;
|
|
126 GtkWidget *container;
|
|
127 char *pg_name;
|
|
128 char *img_url;
|
|
129 } CategoryQueueEntry;
|
|
130
|
|
131 CategoryQueueEntry *category_queue = NULL;
|
|
132
|
|
133 static const guint n_title_field_tags = G_N_ELEMENTS(title_field_tags);
|
|
134
|
|
135 /* GLib 2.6 compatibility */
|
|
136 #if (! ((GLIB_MAJOR_VERSION > 2) || ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION >= 8))))
|
|
137 static const char *
|
|
138 g_get_host_name (void)
|
|
139 {
|
|
140 static char hostname [HOST_NAME_MAX + 1];
|
|
141 if (gethostname (hostname, HOST_NAME_MAX) == -1) {
|
|
142 return _("localhost");
|
|
143 }
|
|
144 return hostname;
|
|
145 }
|
|
146 #endif
|
|
147
|
|
148 static void prefswin_page_queue_destroy(CategoryQueueEntry *ent);
|
|
149
|
|
150 static GladeXML *
|
|
151 prefswin_get_xml(void)
|
|
152 {
|
|
153 return GLADE_XML(g_object_get_data(G_OBJECT(prefswin), "glade-xml"));
|
|
154 }
|
|
155
|
|
156 static void
|
|
157 change_category(GtkNotebook * notebook,
|
|
158 GtkTreeSelection * selection)
|
|
159 {
|
|
160 GtkTreeModel *model;
|
|
161 GtkTreeIter iter;
|
|
162 gint index;
|
|
163
|
|
164 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
|
|
165 return;
|
|
166
|
|
167 gtk_tree_model_get(model, &iter, CATEGORY_VIEW_COL_ID, &index, -1);
|
|
168 gtk_notebook_set_current_page(notebook, index);
|
|
169 }
|
|
170
|
|
171 void
|
|
172 prefswin_set_category(gint index)
|
|
173 {
|
|
174 GladeXML *xml;
|
|
175 GtkWidget *notebook;
|
|
176
|
|
177 g_return_if_fail(index >= 0 && index < n_categories);
|
|
178
|
|
179 xml = prefswin_get_xml();
|
|
180 notebook = glade_xml_get_widget(xml, "category_view");
|
|
181 gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), index);
|
|
182 }
|
|
183
|
|
184
|
|
185 static void
|
|
186 input_plugin_open_prefs(GtkTreeView * treeview,
|
|
187 gpointer data)
|
|
188 {
|
|
189 GtkTreeSelection *selection;
|
|
190 GtkTreeModel *model;
|
|
191 GtkTreeIter iter;
|
|
192 gint id;
|
|
193
|
|
194 selection = gtk_tree_view_get_selection(treeview);
|
|
195 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
|
|
196 return;
|
|
197
|
|
198 gtk_tree_model_get(model, &iter, PLUGIN_VIEW_COL_ID, &id, -1);
|
|
199 input_configure(id);
|
|
200 }
|
|
201
|
|
202 static void
|
|
203 input_plugin_open_info(GtkTreeView * treeview,
|
|
204 gpointer data)
|
|
205 {
|
|
206 GtkTreeSelection *selection;
|
|
207 GtkTreeModel *model;
|
|
208 GtkTreeIter iter;
|
|
209 gint id;
|
|
210
|
|
211 selection = gtk_tree_view_get_selection(treeview);
|
|
212 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
|
|
213 return;
|
|
214
|
|
215 gtk_tree_model_get(model, &iter, PLUGIN_VIEW_COL_ID, &id, -1);
|
|
216 input_about(id);
|
|
217 }
|
|
218
|
|
219 static void
|
|
220 output_plugin_open_prefs(GtkComboBox * cbox,
|
|
221 gpointer data)
|
|
222 {
|
|
223 output_configure(gtk_combo_box_get_active(cbox));
|
|
224 }
|
|
225
|
|
226 static void
|
|
227 output_plugin_open_info(GtkComboBox * cbox,
|
|
228 gpointer data)
|
|
229 {
|
|
230 output_about(gtk_combo_box_get_active(cbox));
|
|
231 }
|
|
232
|
|
233 static void
|
|
234 general_plugin_open_prefs(GtkTreeView * treeview,
|
|
235 gpointer data)
|
|
236 {
|
|
237 GtkTreeSelection *selection;
|
|
238 GtkTreeModel *model;
|
|
239 GtkTreeIter iter;
|
|
240 gint id;
|
|
241
|
|
242 selection = gtk_tree_view_get_selection(treeview);
|
|
243 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
|
|
244 return;
|
|
245
|
|
246 gtk_tree_model_get(model, &iter, PLUGIN_VIEW_COL_ID, &id, -1);
|
|
247 general_configure(id);
|
|
248 }
|
|
249
|
|
250 static void
|
|
251 general_plugin_open_info(GtkTreeView * treeview,
|
|
252 gpointer data)
|
|
253 {
|
|
254 GtkTreeSelection *selection;
|
|
255 GtkTreeModel *model;
|
|
256 GtkTreeIter iter;
|
|
257 gint id;
|
|
258
|
|
259 selection = gtk_tree_view_get_selection(treeview);
|
|
260 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
|
|
261 return;
|
|
262
|
|
263 gtk_tree_model_get(model, &iter, PLUGIN_VIEW_COL_ID, &id, -1);
|
|
264 general_about(id);
|
|
265 }
|
|
266
|
|
267 static void
|
|
268 input_plugin_toggle(GtkCellRendererToggle * cell,
|
|
269 const gchar * path_str,
|
|
270 gpointer data)
|
|
271 {
|
|
272 GtkTreeModel *model = GTK_TREE_MODEL(data);
|
|
273 GtkTreeIter iter;
|
|
274 GtkTreePath *path = gtk_tree_path_new_from_string(path_str);
|
|
275 gboolean fixed;
|
|
276 gint pluginnr;
|
|
277 gchar *filename, *basename;
|
|
278 /*GList *diplist, *tmplist; */
|
|
279
|
|
280 /* get toggled iter */
|
|
281 gtk_tree_model_get_iter(model, &iter, path);
|
|
282 gtk_tree_model_get(model, &iter,
|
|
283 PLUGIN_VIEW_COL_ACTIVE, &fixed,
|
|
284 PLUGIN_VIEW_COL_ID, &pluginnr,
|
|
285 PLUGIN_VIEW_COL_FILENAME, &filename,
|
|
286 -1);
|
|
287
|
|
288 basename = g_path_get_basename(filename);
|
|
289 g_free(filename);
|
|
290
|
|
291 /* do something with the value */
|
|
292 fixed ^= 1;
|
|
293
|
|
294 g_hash_table_replace(plugin_matrix, basename, GINT_TO_POINTER(fixed));
|
|
295 /* g_hash_table_foreach(pluginmatrix, (GHFunc) disp_matrix, NULL); */
|
|
296
|
|
297 /* set new value */
|
|
298 gtk_list_store_set(GTK_LIST_STORE(model), &iter,
|
|
299 PLUGIN_VIEW_COL_ACTIVE, fixed, -1);
|
|
300
|
|
301 /* clean up */
|
|
302 gtk_tree_path_free(path);
|
|
303 }
|
|
304
|
|
305
|
|
306 static void
|
|
307 vis_plugin_toggle(GtkCellRendererToggle * cell,
|
|
308 const gchar * path_str,
|
|
309 gpointer data)
|
|
310 {
|
|
311 GtkTreeModel *model = GTK_TREE_MODEL(data);
|
|
312 GtkTreeIter iter;
|
|
313 GtkTreePath *path = gtk_tree_path_new_from_string(path_str);
|
|
314 gboolean fixed;
|
|
315 gint pluginnr;
|
|
316
|
|
317 /* get toggled iter */
|
|
318 gtk_tree_model_get_iter(model, &iter, path);
|
|
319 gtk_tree_model_get(model, &iter,
|
|
320 PLUGIN_VIEW_COL_ACTIVE, &fixed,
|
|
321 PLUGIN_VIEW_COL_ID, &pluginnr, -1);
|
|
322
|
|
323 /* do something with the value */
|
|
324 fixed ^= 1;
|
|
325
|
|
326 enable_vis_plugin(pluginnr, fixed);
|
|
327
|
|
328 /* set new value */
|
|
329 gtk_list_store_set(GTK_LIST_STORE(model), &iter,
|
|
330 PLUGIN_VIEW_COL_ACTIVE, fixed, -1);
|
|
331
|
|
332 /* clean up */
|
|
333 gtk_tree_path_free(path);
|
|
334 }
|
|
335
|
|
336 static void
|
|
337 effect_plugin_toggle(GtkCellRendererToggle * cell,
|
|
338 const gchar * path_str,
|
|
339 gpointer data)
|
|
340 {
|
|
341 GtkTreeModel *model = GTK_TREE_MODEL(data);
|
|
342 GtkTreeIter iter;
|
|
343 GtkTreePath *path = gtk_tree_path_new_from_string(path_str);
|
|
344 gboolean fixed;
|
|
345 gint pluginnr;
|
|
346
|
|
347 /* get toggled iter */
|
|
348 gtk_tree_model_get_iter(model, &iter, path);
|
|
349 gtk_tree_model_get(model, &iter,
|
|
350 PLUGIN_VIEW_COL_ACTIVE, &fixed,
|
|
351 PLUGIN_VIEW_COL_ID, &pluginnr, -1);
|
|
352
|
|
353 /* do something with the value */
|
|
354 fixed ^= 1;
|
|
355
|
|
356 enable_effect_plugin(pluginnr, fixed);
|
|
357
|
|
358 /* set new value */
|
|
359 gtk_list_store_set(GTK_LIST_STORE(model), &iter,
|
|
360 PLUGIN_VIEW_COL_ACTIVE, fixed, -1);
|
|
361
|
|
362 /* clean up */
|
|
363 gtk_tree_path_free(path);
|
|
364 }
|
|
365 static void
|
|
366 general_plugin_toggle(GtkCellRendererToggle * cell,
|
|
367 const gchar * path_str,
|
|
368 gpointer data)
|
|
369 {
|
|
370 GtkTreeModel *model = GTK_TREE_MODEL(data);
|
|
371 GtkTreeIter iter;
|
|
372 GtkTreePath *path = gtk_tree_path_new_from_string(path_str);
|
|
373 gboolean fixed;
|
|
374 gint pluginnr;
|
|
375
|
|
376 /* get toggled iter */
|
|
377 gtk_tree_model_get_iter(model, &iter, path);
|
|
378 gtk_tree_model_get(model, &iter,
|
|
379 PLUGIN_VIEW_COL_ACTIVE, &fixed,
|
|
380 PLUGIN_VIEW_COL_ID, &pluginnr, -1);
|
|
381
|
|
382 /* do something with the value */
|
|
383 fixed ^= 1;
|
|
384
|
|
385 enable_general_plugin(pluginnr, fixed);
|
|
386
|
|
387 /* set new value */
|
|
388 gtk_list_store_set(GTK_LIST_STORE(model), &iter,
|
|
389 PLUGIN_VIEW_COL_ACTIVE, fixed, -1);
|
|
390
|
|
391 /* clean up */
|
|
392 gtk_tree_path_free(path);
|
|
393 }
|
|
394
|
|
395 static void
|
|
396 on_output_plugin_cbox_changed(GtkComboBox * combobox,
|
|
397 gpointer data)
|
|
398 {
|
|
399 gint selected;
|
|
400 selected = gtk_combo_box_get_active(combobox);
|
|
401
|
|
402 set_current_output_plugin(selected);
|
|
403 }
|
|
404
|
|
405 static void
|
|
406 on_output_plugin_cbox_realize(GtkComboBox * cbox,
|
|
407 gpointer data)
|
|
408 {
|
|
409 GList *olist = get_output_list();
|
|
410 OutputPlugin *op, *cp = get_current_output_plugin();
|
|
411 gint i = 0, selected = 0;
|
|
412
|
|
413 if (!olist) {
|
|
414 gtk_widget_set_sensitive(GTK_WIDGET(cbox), FALSE);
|
|
415 return;
|
|
416 }
|
|
417
|
|
418 for (i = 0; olist; i++, olist = g_list_next(olist)) {
|
|
419 op = OUTPUT_PLUGIN(olist->data);
|
|
420
|
|
421 if (olist->data == cp)
|
|
422 selected = i;
|
|
423
|
|
424 gtk_combo_box_append_text(cbox, op->description);
|
|
425 }
|
|
426
|
|
427 gtk_combo_box_set_active(cbox, selected);
|
|
428 g_signal_connect(cbox, "changed",
|
|
429 G_CALLBACK(on_output_plugin_cbox_changed), NULL);
|
|
430 }
|
|
431
|
|
432
|
|
433 static void
|
|
434 on_input_plugin_view_realize(GtkTreeView * treeview,
|
|
435 gpointer data)
|
|
436 {
|
|
437 GtkListStore *store;
|
|
438 GtkTreeIter iter;
|
|
439
|
|
440 GtkCellRenderer *renderer;
|
|
441 GtkTreeViewColumn *column;
|
|
442
|
|
443 GList *ilist;
|
|
444 gchar *description[2];
|
|
445 InputPlugin *ip;
|
|
446 gint id = 0;
|
|
447
|
|
448 gboolean enabled;
|
|
449
|
|
450 store = gtk_list_store_new(PLUGIN_VIEW_N_COLS,
|
|
451 G_TYPE_BOOLEAN, G_TYPE_STRING,
|
|
452 G_TYPE_STRING, G_TYPE_INT);
|
|
453
|
|
454 column = gtk_tree_view_column_new();
|
|
455 gtk_tree_view_column_set_title(column, _("Enabled"));
|
|
456 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
|
|
457 gtk_tree_view_column_set_spacing(column, 4);
|
|
458 gtk_tree_view_column_set_resizable(column, FALSE);
|
|
459 gtk_tree_view_column_set_fixed_width(column, 50);
|
|
460
|
|
461 renderer = gtk_cell_renderer_toggle_new();
|
|
462 g_signal_connect(renderer, "toggled",
|
|
463 G_CALLBACK(input_plugin_toggle), store);
|
|
464 gtk_tree_view_column_pack_start(column, renderer, TRUE);
|
|
465 gtk_tree_view_column_set_attributes(column, renderer, "active",
|
|
466 PLUGIN_VIEW_COL_ACTIVE, NULL);
|
|
467
|
|
468 gtk_tree_view_append_column(treeview, column);
|
|
469
|
|
470 column = gtk_tree_view_column_new();
|
|
471 gtk_tree_view_column_set_title(column, _("Description"));
|
|
472 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
|
|
473 gtk_tree_view_column_set_spacing(column, 4);
|
|
474 gtk_tree_view_column_set_resizable(column, TRUE);
|
|
475
|
|
476
|
|
477 renderer = gtk_cell_renderer_text_new();
|
|
478 gtk_tree_view_column_pack_start(column, renderer, FALSE);
|
|
479 gtk_tree_view_column_set_attributes(column, renderer,
|
|
480 "text", PLUGIN_VIEW_COL_DESC, NULL);
|
|
481 gtk_tree_view_append_column(treeview, column);
|
|
482
|
|
483 column = gtk_tree_view_column_new();
|
|
484
|
|
485 gtk_tree_view_column_set_title(column, _("Filename"));
|
|
486 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
|
|
487 gtk_tree_view_column_set_spacing(column, 4);
|
|
488 gtk_tree_view_column_set_resizable(column, TRUE);
|
|
489
|
|
490 renderer = gtk_cell_renderer_text_new();
|
|
491 gtk_tree_view_column_pack_start(column, renderer, TRUE);
|
|
492 gtk_tree_view_column_set_attributes(column, renderer, "text",
|
|
493 PLUGIN_VIEW_COL_FILENAME, NULL);
|
|
494
|
|
495 gtk_tree_view_append_column(treeview, column);
|
|
496
|
|
497 for (ilist = get_input_list(); ilist; ilist = g_list_next(ilist)) {
|
|
498 ip = INPUT_PLUGIN(ilist->data);
|
|
499
|
|
500 description[0] = g_strdup(ip->description);
|
|
501 description[1] = g_strdup(ip->filename);
|
|
502
|
|
503 enabled = input_is_enabled(description[1]);
|
|
504
|
|
505 gtk_list_store_append(store, &iter);
|
|
506 gtk_list_store_set(store, &iter,
|
|
507 PLUGIN_VIEW_COL_ACTIVE, enabled,
|
|
508 PLUGIN_VIEW_COL_DESC, description[0],
|
|
509 PLUGIN_VIEW_COL_FILENAME, description[1],
|
|
510 PLUGIN_VIEW_COL_ID, id++, -1);
|
|
511
|
|
512 g_free(description[1]);
|
|
513 g_free(description[0]);
|
|
514 }
|
|
515
|
|
516 gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(store));
|
|
517 }
|
|
518
|
|
519
|
|
520 static void
|
|
521 on_general_plugin_view_realize(GtkTreeView * treeview,
|
|
522 gpointer data)
|
|
523 {
|
|
524 GtkListStore *store;
|
|
525 GtkTreeIter iter;
|
|
526
|
|
527 GtkCellRenderer *renderer;
|
|
528 GtkTreeViewColumn *column;
|
|
529
|
|
530 GList *ilist /*, *diplist */ ;
|
|
531 gchar *description[2];
|
|
532 GeneralPlugin *gp;
|
|
533 gint id = 0;
|
|
534
|
|
535 gboolean enabled;
|
|
536
|
|
537 store = gtk_list_store_new(PLUGIN_VIEW_N_COLS,
|
|
538 G_TYPE_BOOLEAN, G_TYPE_STRING,
|
|
539 G_TYPE_STRING, G_TYPE_INT);
|
|
540
|
|
541 column = gtk_tree_view_column_new();
|
|
542 gtk_tree_view_column_set_title(column, _("Enabled"));
|
|
543 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
|
|
544 gtk_tree_view_column_set_spacing(column, 4);
|
|
545 gtk_tree_view_column_set_resizable(column, FALSE);
|
|
546 gtk_tree_view_column_set_fixed_width(column, 50);
|
|
547
|
|
548 renderer = gtk_cell_renderer_toggle_new();
|
|
549 g_signal_connect(renderer, "toggled",
|
|
550 G_CALLBACK(general_plugin_toggle), store);
|
|
551 gtk_tree_view_column_pack_start(column, renderer, TRUE);
|
|
552 gtk_tree_view_column_set_attributes(column, renderer, "active",
|
|
553 PLUGIN_VIEW_COL_ACTIVE, NULL);
|
|
554
|
|
555 gtk_tree_view_append_column(treeview, column);
|
|
556
|
|
557 column = gtk_tree_view_column_new();
|
|
558 gtk_tree_view_column_set_title(column, _("Description"));
|
|
559 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
|
|
560 gtk_tree_view_column_set_spacing(column, 4);
|
|
561 gtk_tree_view_column_set_resizable(column, TRUE);
|
|
562
|
|
563
|
|
564 renderer = gtk_cell_renderer_text_new();
|
|
565 gtk_tree_view_column_pack_start(column, renderer, FALSE);
|
|
566 gtk_tree_view_column_set_attributes(column, renderer,
|
|
567 "text", PLUGIN_VIEW_COL_DESC, NULL);
|
|
568
|
|
569 gtk_tree_view_append_column(treeview, column);
|
|
570
|
|
571
|
|
572 column = gtk_tree_view_column_new();
|
|
573 gtk_tree_view_column_set_title(column, _("Filename"));
|
|
574 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
|
|
575 gtk_tree_view_column_set_spacing(column, 4);
|
|
576 gtk_tree_view_column_set_resizable(column, TRUE);
|
|
577
|
|
578 renderer = gtk_cell_renderer_text_new();
|
|
579 gtk_tree_view_column_pack_start(column, renderer, TRUE);
|
|
580 gtk_tree_view_column_set_attributes(column, renderer, "text",
|
|
581 PLUGIN_VIEW_COL_FILENAME, NULL);
|
|
582
|
|
583 gtk_tree_view_append_column(treeview, column);
|
|
584
|
|
585 for (ilist = get_general_list(); ilist; ilist = g_list_next(ilist)) {
|
|
586 gp = GENERAL_PLUGIN(ilist->data);
|
|
587
|
|
588 description[0] = g_strdup(gp->description);
|
|
589 description[1] = g_strdup(gp->filename);
|
|
590
|
|
591 enabled = general_enabled(id);
|
|
592
|
|
593 gtk_list_store_append(store, &iter);
|
|
594 gtk_list_store_set(store, &iter,
|
|
595 PLUGIN_VIEW_COL_ACTIVE, enabled,
|
|
596 PLUGIN_VIEW_COL_DESC, description[0],
|
|
597 PLUGIN_VIEW_COL_FILENAME, description[1],
|
|
598 PLUGIN_VIEW_COL_ID, id++, -1);
|
|
599
|
|
600 g_free(description[1]);
|
|
601 g_free(description[0]);
|
|
602 }
|
|
603
|
|
604 gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(store));
|
|
605 }
|
|
606
|
|
607
|
|
608 static void
|
|
609 on_vis_plugin_view_realize(GtkTreeView * treeview,
|
|
610 gpointer data)
|
|
611 {
|
|
612 GtkListStore *store;
|
|
613 GtkTreeIter iter;
|
|
614
|
|
615 GtkCellRenderer *renderer;
|
|
616 GtkTreeViewColumn *column;
|
|
617
|
|
618 GList *vlist;
|
|
619 gchar *description[2];
|
|
620 VisPlugin *vp;
|
|
621 gint id = 0;
|
|
622
|
|
623 gboolean enabled;
|
|
624
|
|
625
|
|
626 store = gtk_list_store_new(PLUGIN_VIEW_N_COLS,
|
|
627 G_TYPE_BOOLEAN, G_TYPE_STRING,
|
|
628 G_TYPE_STRING, G_TYPE_INT);
|
|
629
|
|
630 column = gtk_tree_view_column_new();
|
|
631 gtk_tree_view_column_set_title(column, _("Enabled"));
|
|
632 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
|
|
633 gtk_tree_view_column_set_spacing(column, 4);
|
|
634 gtk_tree_view_column_set_resizable(column, FALSE);
|
|
635 gtk_tree_view_column_set_fixed_width(column, 50);
|
|
636
|
|
637 renderer = gtk_cell_renderer_toggle_new();
|
|
638 g_signal_connect(renderer, "toggled",
|
|
639 G_CALLBACK(vis_plugin_toggle), store);
|
|
640 gtk_tree_view_column_pack_start(column, renderer, TRUE);
|
|
641 gtk_tree_view_column_set_attributes(column, renderer, "active",
|
|
642 PLUGIN_VIEW_COL_ACTIVE, NULL);
|
|
643
|
|
644 gtk_tree_view_append_column(treeview, column);
|
|
645
|
|
646 column = gtk_tree_view_column_new();
|
|
647 gtk_tree_view_column_set_title(column, _("Description"));
|
|
648 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
|
|
649 gtk_tree_view_column_set_spacing(column, 4);
|
|
650 gtk_tree_view_column_set_resizable(column, TRUE);
|
|
651
|
|
652
|
|
653 renderer = gtk_cell_renderer_text_new();
|
|
654 gtk_tree_view_column_pack_start(column, renderer, FALSE);
|
|
655 gtk_tree_view_column_set_attributes(column, renderer,
|
|
656 "text", PLUGIN_VIEW_COL_DESC, NULL);
|
|
657
|
|
658 gtk_tree_view_append_column(treeview, column);
|
|
659
|
|
660
|
|
661 column = gtk_tree_view_column_new();
|
|
662 gtk_tree_view_column_set_title(column, _("Filename"));
|
|
663 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
|
|
664 gtk_tree_view_column_set_spacing(column, 4);
|
|
665 gtk_tree_view_column_set_resizable(column, TRUE);
|
|
666
|
|
667 renderer = gtk_cell_renderer_text_new();
|
|
668 gtk_tree_view_column_pack_start(column, renderer, TRUE);
|
|
669 gtk_tree_view_column_set_attributes(column, renderer, "text",
|
|
670 PLUGIN_VIEW_COL_FILENAME, NULL);
|
|
671
|
|
672 gtk_tree_view_append_column(treeview, column);
|
|
673
|
|
674 for (vlist = get_vis_list(); vlist; vlist = g_list_next(vlist)) {
|
|
675 vp = VIS_PLUGIN(vlist->data);
|
|
676
|
|
677 description[0] = g_strdup(vp->description);
|
|
678 description[1] = g_strdup(vp->filename);
|
|
679
|
|
680 enabled = vis_enabled(id);
|
|
681
|
|
682 gtk_list_store_append(store, &iter);
|
|
683 gtk_list_store_set(store, &iter,
|
|
684 PLUGIN_VIEW_COL_ACTIVE, enabled,
|
|
685 PLUGIN_VIEW_COL_DESC, description[0],
|
|
686 PLUGIN_VIEW_COL_FILENAME, description[1],
|
|
687 PLUGIN_VIEW_COL_ID, id++, -1);
|
|
688
|
|
689 g_free(description[1]);
|
|
690 g_free(description[0]);
|
|
691 }
|
|
692
|
|
693 gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(store));
|
|
694 }
|
|
695
|
|
696 static void
|
|
697 editable_insert_text(GtkEditable * editable,
|
|
698 const gchar * text,
|
|
699 gint * pos)
|
|
700 {
|
|
701 gtk_editable_insert_text(editable, text, strlen(text), pos);
|
|
702 }
|
|
703
|
|
704
|
|
705 static void
|
|
706 on_effect_plugin_view_realize(GtkTreeView * treeview,
|
|
707 gpointer data)
|
|
708 {
|
|
709 GtkListStore *store;
|
|
710 GtkTreeIter iter;
|
|
711
|
|
712 GtkCellRenderer *renderer;
|
|
713 GtkTreeViewColumn *column;
|
|
714
|
|
715 GList *elist;
|
|
716 gchar *description[2];
|
|
717 gint id = 0;
|
|
718
|
|
719 gboolean enabled;
|
|
720
|
|
721
|
|
722 store = gtk_list_store_new(PLUGIN_VIEW_N_COLS,
|
|
723 G_TYPE_BOOLEAN, G_TYPE_STRING,
|
|
724 G_TYPE_STRING, G_TYPE_INT);
|
|
725
|
|
726 column = gtk_tree_view_column_new();
|
|
727 gtk_tree_view_column_set_title(column, _("Enabled"));
|
|
728 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
|
|
729 gtk_tree_view_column_set_spacing(column, 4);
|
|
730 gtk_tree_view_column_set_resizable(column, FALSE);
|
|
731 gtk_tree_view_column_set_fixed_width(column, 50);
|
|
732
|
|
733 renderer = gtk_cell_renderer_toggle_new();
|
|
734 g_signal_connect(renderer, "toggled",
|
|
735 G_CALLBACK(effect_plugin_toggle), store);
|
|
736 gtk_tree_view_column_pack_start(column, renderer, TRUE);
|
|
737 gtk_tree_view_column_set_attributes(column, renderer, "active",
|
|
738 PLUGIN_VIEW_COL_ACTIVE, NULL);
|
|
739
|
|
740 gtk_tree_view_append_column(treeview, column);
|
|
741
|
|
742 column = gtk_tree_view_column_new();
|
|
743 gtk_tree_view_column_set_title(column, _("Description"));
|
|
744 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
|
|
745 gtk_tree_view_column_set_spacing(column, 4);
|
|
746 gtk_tree_view_column_set_resizable(column, TRUE);
|
|
747
|
|
748
|
|
749 renderer = gtk_cell_renderer_text_new();
|
|
750 gtk_tree_view_column_pack_start(column, renderer, FALSE);
|
|
751 gtk_tree_view_column_set_attributes(column, renderer,
|
|
752 "text", PLUGIN_VIEW_COL_DESC, NULL);
|
|
753
|
|
754 gtk_tree_view_append_column(treeview, column);
|
|
755
|
|
756
|
|
757 column = gtk_tree_view_column_new();
|
|
758 gtk_tree_view_column_set_title(column, _("Filename"));
|
|
759 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
|
|
760 gtk_tree_view_column_set_spacing(column, 4);
|
|
761 gtk_tree_view_column_set_resizable(column, TRUE);
|
|
762
|
|
763 renderer = gtk_cell_renderer_text_new();
|
|
764 gtk_tree_view_column_pack_start(column, renderer, TRUE);
|
|
765 gtk_tree_view_column_set_attributes(column, renderer, "text",
|
|
766 PLUGIN_VIEW_COL_FILENAME, NULL);
|
|
767
|
|
768 gtk_tree_view_append_column(treeview, column);
|
|
769
|
|
770 for (elist = get_effect_list(); elist; elist = g_list_next(elist)) {
|
|
771 EffectPlugin *ep = EFFECT_PLUGIN(elist->data);
|
|
772
|
|
773 description[0] = g_strdup(ep->description);
|
|
774 description[1] = g_strdup(ep->filename);
|
|
775
|
|
776 enabled = effect_enabled(id);
|
|
777
|
|
778 gtk_list_store_append(store, &iter);
|
|
779 gtk_list_store_set(store, &iter,
|
|
780 PLUGIN_VIEW_COL_ACTIVE, enabled,
|
|
781 PLUGIN_VIEW_COL_DESC, description[0],
|
|
782 PLUGIN_VIEW_COL_FILENAME, description[1],
|
|
783 PLUGIN_VIEW_COL_ID, id++, -1);
|
|
784
|
|
785 g_free(description[1]);
|
|
786 g_free(description[0]);
|
|
787 }
|
|
788
|
|
789 gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(store));
|
|
790 }
|
|
791
|
|
792 static void
|
|
793 titlestring_tag_menu_callback(GtkMenuItem * menuitem,
|
|
794 gpointer data)
|
|
795 {
|
|
796 const gchar *separator = " - ";
|
|
797 GladeXML *xml;
|
|
798 GtkWidget *entry;
|
|
799 gint item = GPOINTER_TO_INT(data);
|
|
800 gint pos;
|
|
801
|
|
802 xml = prefswin_get_xml();
|
|
803 entry = glade_xml_get_widget(xml, "titlestring_entry");
|
|
804
|
|
805 pos = gtk_editable_get_position(GTK_EDITABLE(entry));
|
|
806
|
|
807 /* insert separator as needed */
|
|
808 if (g_utf8_strlen(gtk_entry_get_text(GTK_ENTRY(entry)), -1) > 0)
|
|
809 editable_insert_text(GTK_EDITABLE(entry), separator, &pos);
|
|
810
|
|
811 editable_insert_text(GTK_EDITABLE(entry), _(title_field_tags[item].tag),
|
|
812 &pos);
|
|
813
|
|
814 gtk_editable_set_position(GTK_EDITABLE(entry), pos);
|
|
815 }
|
|
816
|
|
817 static void
|
|
818 on_titlestring_help_button_clicked(GtkButton * button,
|
|
819 gpointer data)
|
|
820 {
|
|
821
|
|
822 GtkMenu *menu;
|
|
823 MenuPos *pos = g_new0(MenuPos, 1);
|
|
824 GdkWindow *parent;
|
|
825
|
|
826 gint x_ro, y_ro;
|
|
827 gint x_widget, y_widget;
|
|
828 gint x_size, y_size;
|
|
829
|
|
830 g_return_if_fail (button != NULL);
|
|
831 g_return_if_fail (GTK_IS_MENU (data));
|
|
832
|
|
833 parent = gtk_widget_get_parent_window(GTK_WIDGET(button));
|
|
834
|
|
835 gdk_drawable_get_size(parent, &x_size, &y_size);
|
|
836 gdk_window_get_root_origin(GTK_WIDGET(button)->window, &x_ro, &y_ro);
|
|
837 gdk_window_get_position(GTK_WIDGET(button)->window, &x_widget, &y_widget);
|
|
838
|
|
839 pos->x = x_size + x_ro;
|
|
840 pos->y = y_size + y_ro - 100;
|
|
841
|
|
842 menu = GTK_MENU(data);
|
|
843 gtk_menu_popup (menu, NULL, NULL, util_menu_position, pos,
|
|
844 0, GDK_CURRENT_TIME);
|
|
845 }
|
|
846
|
|
847
|
|
848 static void
|
|
849 on_titlestring_entry_realize(GtkWidget * entry,
|
|
850 gpointer data)
|
|
851 {
|
|
852 gtk_entry_set_text(GTK_ENTRY(entry), cfg.gentitle_format);
|
|
853 }
|
|
854
|
|
855 static void
|
|
856 on_titlestring_entry_changed(GtkWidget * entry,
|
|
857 gpointer data)
|
|
858 {
|
|
859 g_free(cfg.gentitle_format);
|
|
860 cfg.gentitle_format = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
|
|
861 }
|
|
862
|
|
863 static void
|
|
864 on_titlestring_cbox_realize(GtkWidget * cbox,
|
|
865 gpointer data)
|
|
866 {
|
|
867 gtk_combo_box_set_active(GTK_COMBO_BOX(cbox), cfg.titlestring_preset);
|
|
868 gtk_widget_set_sensitive(GTK_WIDGET(data),
|
|
869 (cfg.titlestring_preset == (gint)n_titlestring_presets));
|
|
870 }
|
|
871
|
|
872 static void
|
|
873 on_titlestring_cbox_changed(GtkWidget * cbox,
|
|
874 gpointer data)
|
|
875 {
|
|
876 gint position = gtk_combo_box_get_active(GTK_COMBO_BOX(cbox));
|
|
877
|
|
878 cfg.titlestring_preset = position;
|
|
879 gtk_widget_set_sensitive(GTK_WIDGET(data), (position == 6));
|
|
880 }
|
|
881
|
|
882 static void
|
|
883 on_mainwin_font_button_font_set(GtkFontButton * button,
|
|
884 gpointer data)
|
|
885 {
|
|
886 g_free(cfg.mainwin_font);
|
|
887 cfg.mainwin_font = g_strdup(gtk_font_button_get_font_name(button));
|
|
888
|
|
889 textbox_set_xfont(mainwin_info, cfg.mainwin_use_xfont, cfg.mainwin_font);
|
|
890 mainwin_set_info_text();
|
|
891 draw_main_window(TRUE);
|
|
892 }
|
|
893
|
|
894 static void
|
|
895 on_use_bitmap_fonts_realize(GtkToggleButton * button,
|
|
896 gpointer data)
|
|
897 {
|
|
898 gtk_toggle_button_set_active(button,
|
|
899 cfg.mainwin_use_xfont != FALSE ? FALSE : TRUE);
|
|
900 }
|
|
901
|
|
902 static void
|
|
903 on_use_bitmap_fonts_toggled(GtkToggleButton * button,
|
|
904 gpointer data)
|
|
905 {
|
|
906 gboolean useit = gtk_toggle_button_get_active(button);
|
|
907 cfg.mainwin_use_xfont = useit != FALSE ? FALSE : TRUE;
|
|
908 textbox_set_xfont(mainwin_info, cfg.mainwin_use_xfont, cfg.mainwin_font);
|
|
909 playlistwin_set_sinfo_font(cfg.playlist_font);
|
|
910
|
|
911 mainwin_set_info_text();
|
|
912 draw_main_window(TRUE);
|
|
913 if (cfg.playlist_shaded) {
|
|
914 playlistwin_update_list(playlist_get_active());
|
|
915 draw_playlist_window(TRUE);
|
|
916 }
|
|
917 }
|
|
918
|
|
919 static void
|
|
920 on_mainwin_font_button_realize(GtkFontButton * button,
|
|
921 gpointer data)
|
|
922 {
|
|
923 gtk_font_button_set_font_name(button, cfg.mainwin_font);
|
|
924 }
|
|
925
|
|
926 static void
|
|
927 on_playlist_font_button_font_set(GtkFontButton * button,
|
|
928 gpointer data)
|
|
929 {
|
|
930 g_free(cfg.playlist_font);
|
|
931 cfg.playlist_font = g_strdup(gtk_font_button_get_font_name(button));
|
|
932
|
|
933 playlist_list_set_font(cfg.playlist_font);
|
|
934 playlistwin_set_sinfo_font(cfg.playlist_font); /* propagate font setting to playlistwin_sinfo */
|
|
935 playlistwin_update_list(playlist_get_active());
|
|
936 draw_playlist_window(TRUE);
|
|
937 }
|
|
938
|
|
939 static void
|
|
940 on_playlist_font_button_realize(GtkFontButton * button,
|
|
941 gpointer data)
|
|
942 {
|
|
943 gtk_font_button_set_font_name(button, cfg.playlist_font);
|
|
944 }
|
|
945
|
|
946 static void
|
|
947 on_playlist_show_pl_numbers_realize(GtkToggleButton * button,
|
|
948 gpointer data)
|
|
949 {
|
|
950 gtk_toggle_button_set_active(button, cfg.show_numbers_in_pl);
|
|
951 }
|
|
952
|
|
953 static void
|
|
954 on_playlist_show_pl_numbers_toggled(GtkToggleButton * button,
|
|
955 gpointer data)
|
|
956 {
|
|
957 cfg.show_numbers_in_pl = gtk_toggle_button_get_active(button);
|
|
958 playlistwin_update_list(playlist_get_active());
|
|
959 draw_playlist_window(TRUE);
|
|
960 }
|
|
961
|
|
962 static void
|
|
963 on_playlist_transparent_realize(GtkToggleButton * button,
|
|
964 gpointer data)
|
|
965 {
|
|
966 gtk_toggle_button_set_active(button, cfg.playlist_transparent);
|
|
967 }
|
|
968
|
|
969 static void
|
|
970 on_playlist_transparent_toggled(GtkToggleButton * button,
|
|
971 gpointer data)
|
|
972 {
|
|
973 cfg.playlist_transparent = gtk_toggle_button_get_active(button);
|
|
974 playlistwin_update_list(playlist_get_active());
|
|
975 draw_playlist_window(TRUE);
|
|
976 }
|
|
977
|
|
978 static void
|
|
979 on_playlist_show_pl_separator_realize(GtkToggleButton * button,
|
|
980 gpointer data)
|
|
981 {
|
|
982 gtk_toggle_button_set_active(button, cfg.show_separator_in_pl);
|
|
983 }
|
|
984
|
|
985 static void
|
|
986 on_playlist_show_pl_separator_toggled(GtkToggleButton * button,
|
|
987 gpointer data)
|
|
988 {
|
|
989 cfg.show_separator_in_pl = gtk_toggle_button_get_active(button);
|
|
990 playlistwin_update_list(playlist_get_active());
|
|
991 draw_playlist_window(TRUE);
|
|
992 }
|
|
993
|
|
994 /* format detection */
|
|
995 static void
|
|
996 on_audio_format_det_cb_toggled(GtkToggleButton * button,
|
|
997 gpointer data)
|
|
998 {
|
|
999 cfg.playlist_detect = gtk_toggle_button_get_active(button);
|
|
1000 }
|
|
1001
|
|
1002 static void
|
|
1003 on_audio_format_det_cb_realize(GtkToggleButton * button,
|
|
1004 gpointer data)
|
|
1005 {
|
|
1006 gtk_toggle_button_set_active(button, cfg.playlist_detect);
|
|
1007 }
|
|
1008
|
|
1009 static void
|
|
1010 on_detect_by_extension_cb_toggled(GtkToggleButton * button,
|
|
1011 gpointer data)
|
|
1012 {
|
|
1013 cfg.use_extension_probing = gtk_toggle_button_get_active(button);
|
|
1014 }
|
|
1015
|
|
1016 static void
|
|
1017 on_detect_by_extension_cb_realize(GtkToggleButton * button,
|
|
1018 gpointer data)
|
|
1019 {
|
|
1020 gtk_toggle_button_set_active(button, cfg.use_extension_probing);
|
|
1021 }
|
|
1022
|
|
1023 /* proxy */
|
|
1024 static void
|
|
1025 on_proxy_use_realize(GtkToggleButton * button,
|
|
1026 gpointer data)
|
|
1027 {
|
|
1028 ConfigDb *db;
|
|
1029 gboolean ret;
|
|
1030
|
|
1031 db = bmp_cfg_db_open();
|
|
1032
|
|
1033 if (bmp_cfg_db_get_bool(db, NULL, "use_proxy", &ret) != FALSE)
|
|
1034 gtk_toggle_button_set_active(button, ret);
|
|
1035
|
|
1036 bmp_cfg_db_close(db);
|
|
1037 }
|
|
1038
|
|
1039 static void
|
|
1040 on_proxy_use_toggled(GtkToggleButton * button,
|
|
1041 gpointer data)
|
|
1042 {
|
|
1043 ConfigDb *db;
|
|
1044 gboolean ret = gtk_toggle_button_get_active(button);
|
|
1045
|
|
1046 db = bmp_cfg_db_open();
|
|
1047 bmp_cfg_db_set_bool(db, NULL, "use_proxy", ret);
|
|
1048 bmp_cfg_db_close(db);
|
|
1049 }
|
|
1050
|
|
1051 static void
|
|
1052 on_proxy_auth_realize(GtkToggleButton * button,
|
|
1053 gpointer data)
|
|
1054 {
|
|
1055 ConfigDb *db;
|
|
1056 gboolean ret;
|
|
1057
|
|
1058 db = bmp_cfg_db_open();
|
|
1059
|
|
1060 if (bmp_cfg_db_get_bool(db, NULL, "proxy_use_auth", &ret) != FALSE)
|
|
1061 gtk_toggle_button_set_active(button, ret);
|
|
1062
|
|
1063 bmp_cfg_db_close(db);
|
|
1064 }
|
|
1065
|
|
1066 static void
|
|
1067 on_proxy_auth_toggled(GtkToggleButton * button,
|
|
1068 gpointer data)
|
|
1069 {
|
|
1070 ConfigDb *db;
|
|
1071 gboolean ret = gtk_toggle_button_get_active(button);
|
|
1072
|
|
1073 db = bmp_cfg_db_open();
|
|
1074 bmp_cfg_db_set_bool(db, NULL, "proxy_use_auth", ret);
|
|
1075 bmp_cfg_db_close(db);
|
|
1076 }
|
|
1077
|
|
1078 static void
|
|
1079 on_proxy_host_realize(GtkEntry * entry,
|
|
1080 gpointer data)
|
|
1081 {
|
|
1082 ConfigDb *db;
|
|
1083 gchar *ret;
|
|
1084
|
|
1085 db = bmp_cfg_db_open();
|
|
1086
|
|
1087 if (bmp_cfg_db_get_string(db, NULL, "proxy_host", &ret) != FALSE)
|
|
1088 gtk_entry_set_text(entry, ret);
|
|
1089
|
|
1090 bmp_cfg_db_close(db);
|
|
1091 }
|
|
1092
|
|
1093 static void
|
|
1094 on_proxy_host_changed(GtkEntry * entry,
|
|
1095 gpointer data)
|
|
1096 {
|
|
1097 ConfigDb *db;
|
|
1098 gchar *ret = g_strdup(gtk_entry_get_text(entry));
|
|
1099
|
|
1100 db = bmp_cfg_db_open();
|
|
1101 bmp_cfg_db_set_string(db, NULL, "proxy_host", ret);
|
|
1102 bmp_cfg_db_close(db);
|
|
1103
|
|
1104 g_free(ret);
|
|
1105 }
|
|
1106
|
|
1107 static void
|
|
1108 on_proxy_port_realize(GtkEntry * entry,
|
|
1109 gpointer data)
|
|
1110 {
|
|
1111 ConfigDb *db;
|
|
1112 gchar *ret;
|
|
1113
|
|
1114 db = bmp_cfg_db_open();
|
|
1115
|
|
1116 if (bmp_cfg_db_get_string(db, NULL, "proxy_port", &ret) != FALSE)
|
|
1117 gtk_entry_set_text(entry, ret);
|
|
1118
|
|
1119 bmp_cfg_db_close(db);
|
|
1120 }
|
|
1121
|
|
1122 static void
|
|
1123 on_proxy_port_changed(GtkEntry * entry,
|
|
1124 gpointer data)
|
|
1125 {
|
|
1126 ConfigDb *db;
|
|
1127 gchar *ret = g_strdup(gtk_entry_get_text(entry));
|
|
1128
|
|
1129 db = bmp_cfg_db_open();
|
|
1130 bmp_cfg_db_set_string(db, NULL, "proxy_port", ret);
|
|
1131 bmp_cfg_db_close(db);
|
|
1132
|
|
1133 g_free(ret);
|
|
1134 }
|
|
1135
|
|
1136 static void
|
|
1137 on_proxy_user_realize(GtkEntry * entry,
|
|
1138 gpointer data)
|
|
1139 {
|
|
1140 ConfigDb *db;
|
|
1141 gchar *ret;
|
|
1142
|
|
1143 db = bmp_cfg_db_open();
|
|
1144
|
|
1145 if (bmp_cfg_db_get_string(db, NULL, "proxy_user", &ret) != FALSE)
|
|
1146 gtk_entry_set_text(entry, ret);
|
|
1147
|
|
1148 bmp_cfg_db_close(db);
|
|
1149 }
|
|
1150
|
|
1151 static void
|
|
1152 on_proxy_user_changed(GtkEntry * entry,
|
|
1153 gpointer data)
|
|
1154 {
|
|
1155 ConfigDb *db;
|
|
1156 gchar *ret = g_strdup(gtk_entry_get_text(entry));
|
|
1157
|
|
1158 db = bmp_cfg_db_open();
|
|
1159 bmp_cfg_db_set_string(db, NULL, "proxy_user", ret);
|
|
1160 bmp_cfg_db_close(db);
|
|
1161
|
|
1162 g_free(ret);
|
|
1163 }
|
|
1164
|
|
1165 static void
|
|
1166 on_proxy_pass_realize(GtkEntry * entry,
|
|
1167 gpointer data)
|
|
1168 {
|
|
1169 ConfigDb *db;
|
|
1170 gchar *ret;
|
|
1171
|
|
1172 db = bmp_cfg_db_open();
|
|
1173
|
|
1174 if (bmp_cfg_db_get_string(db, NULL, "proxy_pass", &ret) != FALSE)
|
|
1175 gtk_entry_set_text(entry, ret);
|
|
1176
|
|
1177 bmp_cfg_db_close(db);
|
|
1178 }
|
|
1179
|
|
1180 static void
|
|
1181 on_proxy_pass_changed(GtkEntry * entry,
|
|
1182 gpointer data)
|
|
1183 {
|
|
1184 ConfigDb *db;
|
|
1185 gchar *ret = g_strdup(gtk_entry_get_text(entry));
|
|
1186
|
|
1187 db = bmp_cfg_db_open();
|
|
1188 bmp_cfg_db_set_string(db, NULL, "proxy_pass", ret);
|
|
1189 bmp_cfg_db_close(db);
|
|
1190
|
|
1191 g_free(ret);
|
|
1192 }
|
|
1193
|
|
1194 static void
|
|
1195 input_plugin_enable_prefs(GtkTreeView * treeview,
|
|
1196 GtkButton * button)
|
|
1197 {
|
|
1198 GtkTreeSelection *selection;
|
|
1199 GtkTreeModel *model;
|
|
1200 GtkTreeIter iter;
|
|
1201
|
|
1202 GList *plist;
|
|
1203 gint id;
|
|
1204
|
|
1205 selection = gtk_tree_view_get_selection(treeview);
|
|
1206 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
|
|
1207 return;
|
|
1208
|
|
1209 gtk_tree_model_get(model, &iter, PLUGIN_VIEW_COL_ID, &id, -1);
|
|
1210
|
|
1211 plist = get_input_list();
|
|
1212 plist = g_list_nth(plist, id);
|
|
1213
|
|
1214 gtk_widget_set_sensitive(GTK_WIDGET(button),
|
|
1215 INPUT_PLUGIN(plist->data)->configure != NULL);
|
|
1216 }
|
|
1217
|
|
1218 static void
|
|
1219 input_plugin_enable_info(GtkTreeView * treeview,
|
|
1220 GtkButton * button)
|
|
1221 {
|
|
1222 GtkTreeSelection *selection;
|
|
1223 GtkTreeModel *model;
|
|
1224 GtkTreeIter iter;
|
|
1225 GList *plist;
|
|
1226 gint id;
|
|
1227
|
|
1228 selection = gtk_tree_view_get_selection(treeview);
|
|
1229 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
|
|
1230 return;
|
|
1231
|
|
1232 gtk_tree_model_get(model, &iter, PLUGIN_VIEW_COL_ID, &id, -1);
|
|
1233
|
|
1234 plist = get_input_list();
|
|
1235 plist = g_list_nth(plist, id);
|
|
1236
|
|
1237 gtk_widget_set_sensitive(GTK_WIDGET(button),
|
|
1238 INPUT_PLUGIN(plist->data)->about != NULL);
|
|
1239 }
|
|
1240
|
|
1241
|
|
1242 static void
|
|
1243 output_plugin_enable_info(GtkComboBox * cbox, GtkButton * button)
|
|
1244 {
|
|
1245 GList *plist;
|
|
1246
|
|
1247 gint id = gtk_combo_box_get_active(cbox);
|
|
1248
|
|
1249 plist = get_output_list();
|
|
1250 plist = g_list_nth(plist, id);
|
|
1251
|
|
1252 gtk_widget_set_sensitive(GTK_WIDGET(button),
|
|
1253 OUTPUT_PLUGIN(plist->data)->about != NULL);
|
|
1254 }
|
|
1255
|
|
1256 static void
|
|
1257 output_plugin_enable_prefs(GtkComboBox * cbox, GtkButton * button)
|
|
1258 {
|
|
1259 GList *plist;
|
|
1260 gint id = gtk_combo_box_get_active(cbox);
|
|
1261
|
|
1262 plist = get_output_list();
|
|
1263 plist = g_list_nth(plist, id);
|
|
1264
|
|
1265 gtk_widget_set_sensitive(GTK_WIDGET(button),
|
|
1266 OUTPUT_PLUGIN(plist->data)->configure != NULL);
|
|
1267 }
|
|
1268
|
|
1269
|
|
1270 static void
|
|
1271 general_plugin_enable_info(GtkTreeView * treeview,
|
|
1272 GtkButton * button)
|
|
1273 {
|
|
1274 GtkTreeSelection *selection;
|
|
1275 GtkTreeModel *model;
|
|
1276 GtkTreeIter iter;
|
|
1277 GList *plist;
|
|
1278 gint id;
|
|
1279
|
|
1280 selection = gtk_tree_view_get_selection(treeview);
|
|
1281 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
|
|
1282 return;
|
|
1283
|
|
1284 gtk_tree_model_get(model, &iter, PLUGIN_VIEW_COL_ID, &id, -1);
|
|
1285
|
|
1286 plist = get_general_list();
|
|
1287 plist = g_list_nth(plist, id);
|
|
1288
|
|
1289 gtk_widget_set_sensitive(GTK_WIDGET(button),
|
|
1290 GENERAL_PLUGIN(plist->data)->about != NULL);
|
|
1291 }
|
|
1292
|
|
1293 static void
|
|
1294 general_plugin_enable_prefs(GtkTreeView * treeview,
|
|
1295 GtkButton * button)
|
|
1296 {
|
|
1297 GtkTreeSelection *selection;
|
|
1298 GtkTreeModel *model;
|
|
1299 GtkTreeIter iter;
|
|
1300 GList *plist;
|
|
1301 gint id;
|
|
1302
|
|
1303 selection = gtk_tree_view_get_selection(treeview);
|
|
1304 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
|
|
1305 return;
|
|
1306
|
|
1307 gtk_tree_model_get(model, &iter, PLUGIN_VIEW_COL_ID, &id, -1);
|
|
1308
|
|
1309 plist = get_general_list();
|
|
1310 plist = g_list_nth(plist, id);
|
|
1311
|
|
1312 gtk_widget_set_sensitive(GTK_WIDGET(button),
|
|
1313 GENERAL_PLUGIN(plist->data)->configure != NULL);
|
|
1314 }
|
|
1315
|
|
1316
|
|
1317
|
|
1318 static void
|
|
1319 vis_plugin_enable_prefs(GtkTreeView * treeview,
|
|
1320 GtkButton * button)
|
|
1321 {
|
|
1322 GtkTreeSelection *selection;
|
|
1323 GtkTreeModel *model;
|
|
1324 GtkTreeIter iter;
|
|
1325 GList *plist;
|
|
1326 gint id;
|
|
1327
|
|
1328 selection = gtk_tree_view_get_selection(treeview);
|
|
1329 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
|
|
1330 return;
|
|
1331
|
|
1332 gtk_tree_model_get(model, &iter, PLUGIN_VIEW_COL_ID, &id, -1);
|
|
1333
|
|
1334 plist = get_vis_list();
|
|
1335 plist = g_list_nth(plist, id);
|
|
1336
|
|
1337 gtk_widget_set_sensitive(GTK_WIDGET(button),
|
|
1338 VIS_PLUGIN(plist->data)->configure != NULL);
|
|
1339 }
|
|
1340
|
|
1341 static void
|
|
1342 vis_plugin_enable_info(GtkTreeView * treeview,
|
|
1343 GtkButton * button)
|
|
1344 {
|
|
1345 GtkTreeSelection *selection;
|
|
1346 GtkTreeModel *model;
|
|
1347 GtkTreeIter iter;
|
|
1348 GList *plist;
|
|
1349 gint id;
|
|
1350
|
|
1351 selection = gtk_tree_view_get_selection(treeview);
|
|
1352 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
|
|
1353 return;
|
|
1354
|
|
1355 gtk_tree_model_get(model, &iter, PLUGIN_VIEW_COL_ID, &id, -1);
|
|
1356
|
|
1357 plist = get_vis_list();
|
|
1358 plist = g_list_nth(plist, id);
|
|
1359
|
|
1360 gtk_widget_set_sensitive(GTK_WIDGET(button),
|
|
1361 VIS_PLUGIN(plist->data)->about != NULL);
|
|
1362 }
|
|
1363
|
|
1364 static void
|
|
1365 vis_plugin_open_prefs(GtkTreeView * treeview,
|
|
1366 gpointer data)
|
|
1367 {
|
|
1368 GtkTreeSelection *selection;
|
|
1369 GtkTreeModel *model;
|
|
1370 GtkTreeIter iter;
|
|
1371 gint id;
|
|
1372
|
|
1373 selection = gtk_tree_view_get_selection(treeview);
|
|
1374 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
|
|
1375 return;
|
|
1376
|
|
1377 gtk_tree_model_get(model, &iter, PLUGIN_VIEW_COL_ID, &id, -1);
|
|
1378 vis_configure(id);
|
|
1379 }
|
|
1380
|
|
1381
|
|
1382 static void
|
|
1383 vis_plugin_open_info(GtkTreeView * treeview,
|
|
1384 gpointer data)
|
|
1385 {
|
|
1386 GtkTreeSelection *selection;
|
|
1387 GtkTreeModel *model;
|
|
1388 GtkTreeIter iter;
|
|
1389 gint id;
|
|
1390
|
|
1391 selection = gtk_tree_view_get_selection(treeview);
|
|
1392 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
|
|
1393 return;
|
|
1394
|
|
1395 gtk_tree_model_get(model, &iter, PLUGIN_VIEW_COL_ID, &id, -1);
|
|
1396 vis_about(id);
|
|
1397 }
|
|
1398
|
|
1399
|
|
1400
|
|
1401
|
|
1402
|
|
1403
|
|
1404 static void
|
|
1405 effect_plugin_enable_prefs(GtkTreeView * treeview,
|
|
1406 GtkButton * button)
|
|
1407 {
|
|
1408 GtkTreeSelection *selection;
|
|
1409 GtkTreeModel *model;
|
|
1410 GtkTreeIter iter;
|
|
1411 GList *plist;
|
|
1412 gint id;
|
|
1413
|
|
1414 selection = gtk_tree_view_get_selection(treeview);
|
|
1415 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
|
|
1416 return;
|
|
1417
|
|
1418 gtk_tree_model_get(model, &iter, PLUGIN_VIEW_COL_ID, &id, -1);
|
|
1419
|
|
1420 plist = get_effect_list();
|
|
1421 plist = g_list_nth(plist, id);
|
|
1422
|
|
1423 gtk_widget_set_sensitive(GTK_WIDGET(button),
|
|
1424 EFFECT_PLUGIN(plist->data)->configure != NULL);
|
|
1425 }
|
|
1426
|
|
1427 static void
|
|
1428 effect_plugin_enable_info(GtkTreeView * treeview,
|
|
1429 GtkButton * button)
|
|
1430 {
|
|
1431 GtkTreeSelection *selection;
|
|
1432 GtkTreeModel *model;
|
|
1433 GtkTreeIter iter;
|
|
1434 GList *plist;
|
|
1435 gint id;
|
|
1436
|
|
1437 selection = gtk_tree_view_get_selection(treeview);
|
|
1438 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
|
|
1439 return;
|
|
1440
|
|
1441 gtk_tree_model_get(model, &iter, PLUGIN_VIEW_COL_ID, &id, -1);
|
|
1442
|
|
1443 plist = get_effect_list();
|
|
1444 plist = g_list_nth(plist, id);
|
|
1445
|
|
1446 gtk_widget_set_sensitive(GTK_WIDGET(button),
|
|
1447 EFFECT_PLUGIN(plist->data)->about != NULL);
|
|
1448 }
|
|
1449
|
|
1450 static void
|
|
1451 effect_plugin_open_prefs(GtkTreeView * treeview,
|
|
1452 gpointer data)
|
|
1453 {
|
|
1454 GtkTreeSelection *selection;
|
|
1455 GtkTreeModel *model;
|
|
1456 GtkTreeIter iter;
|
|
1457 gint id;
|
|
1458
|
|
1459 selection = gtk_tree_view_get_selection(treeview);
|
|
1460 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
|
|
1461 return;
|
|
1462
|
|
1463 gtk_tree_model_get(model, &iter, PLUGIN_VIEW_COL_ID, &id, -1);
|
|
1464 effect_configure(id);
|
|
1465 }
|
|
1466
|
|
1467
|
|
1468 static void
|
|
1469 effect_plugin_open_info(GtkTreeView * treeview,
|
|
1470 gpointer data)
|
|
1471 {
|
|
1472 GtkTreeSelection *selection;
|
|
1473 GtkTreeModel *model;
|
|
1474 GtkTreeIter iter;
|
|
1475 gint id;
|
|
1476
|
|
1477 selection = gtk_tree_view_get_selection(treeview);
|
|
1478 if (!gtk_tree_selection_get_selected(selection, &model, &iter))
|
|
1479 return;
|
|
1480
|
|
1481 gtk_tree_model_get(model, &iter, PLUGIN_VIEW_COL_ID, &id, -1);
|
|
1482 effect_about(id);
|
|
1483 }
|
|
1484
|
|
1485 static void
|
|
1486 on_output_plugin_bufsize_realize(GtkSpinButton *button,
|
|
1487 gpointer data)
|
|
1488 {
|
|
1489 gtk_spin_button_set_value(button, cfg.output_buffer_size);
|
|
1490 }
|
|
1491
|
|
1492 static void
|
|
1493 on_output_plugin_bufsize_value_changed(GtkSpinButton *button,
|
|
1494 gpointer data)
|
|
1495 {
|
|
1496 cfg.output_buffer_size = gtk_spin_button_get_value_as_int(button);
|
|
1497 }
|
|
1498
|
|
1499 static void
|
|
1500 on_mouse_wheel_volume_realize(GtkSpinButton * button,
|
|
1501 gpointer data)
|
|
1502 {
|
|
1503 gtk_spin_button_set_value(button, cfg.mouse_change);
|
|
1504 }
|
|
1505
|
|
1506 static void
|
|
1507 on_mouse_wheel_volume_changed(GtkSpinButton * button,
|
|
1508 gpointer data)
|
|
1509 {
|
|
1510 cfg.mouse_change = gtk_spin_button_get_value_as_int(button);
|
|
1511 }
|
|
1512
|
|
1513 static void
|
|
1514 on_pause_between_songs_time_realize(GtkSpinButton * button,
|
|
1515 gpointer data)
|
|
1516 {
|
|
1517 gtk_spin_button_set_value(button, cfg.pause_between_songs_time);
|
|
1518 }
|
|
1519
|
|
1520 static void
|
|
1521 on_pause_between_songs_time_changed(GtkSpinButton * button,
|
|
1522 gpointer data)
|
|
1523 {
|
|
1524 cfg.pause_between_songs_time = gtk_spin_button_get_value_as_int(button);
|
|
1525 }
|
|
1526
|
|
1527 static void
|
|
1528 on_mouse_wheel_scroll_pl_realize(GtkSpinButton * button,
|
|
1529 gpointer data)
|
|
1530 {
|
|
1531 gtk_spin_button_set_value(button, cfg.scroll_pl_by);
|
|
1532 }
|
|
1533
|
|
1534 static void
|
|
1535 on_mouse_wheel_scroll_pl_changed(GtkSpinButton * button,
|
|
1536 gpointer data)
|
|
1537 {
|
|
1538 cfg.scroll_pl_by = gtk_spin_button_get_value_as_int(button);
|
|
1539 }
|
|
1540
|
|
1541 static void
|
|
1542 on_playlist_convert_underscore_realize(GtkToggleButton * button,
|
|
1543 gpointer data)
|
|
1544 {
|
|
1545 gtk_toggle_button_set_active(button, cfg.convert_underscore);
|
|
1546 }
|
|
1547
|
|
1548 static void
|
|
1549 on_playlist_convert_underscore_toggled(GtkToggleButton * button,
|
|
1550 gpointer data)
|
|
1551 {
|
|
1552 cfg.convert_underscore = gtk_toggle_button_get_active(button);
|
|
1553 }
|
|
1554
|
|
1555 static void
|
|
1556 on_playlist_no_advance_realize(GtkToggleButton * button, gpointer data)
|
|
1557 {
|
|
1558 gtk_toggle_button_set_active(button, cfg.no_playlist_advance);
|
|
1559 }
|
|
1560
|
|
1561 static void
|
|
1562 on_playlist_no_advance_toggled(GtkToggleButton * button, gpointer data)
|
|
1563 {
|
|
1564 cfg.no_playlist_advance = gtk_toggle_button_get_active(button);
|
|
1565 }
|
|
1566
|
|
1567 static void
|
|
1568 on_continue_playback_on_startup_realize(GtkToggleButton * button, gpointer data)
|
|
1569 {
|
|
1570 gtk_toggle_button_set_active(button, cfg.resume_playback_on_startup);
|
|
1571 }
|
|
1572
|
|
1573 static void
|
|
1574 on_continue_playback_on_startup_toggled(GtkToggleButton * button, gpointer data)
|
|
1575 {
|
|
1576 cfg.resume_playback_on_startup = gtk_toggle_button_get_active(button);
|
|
1577 }
|
|
1578
|
|
1579 static void
|
|
1580 on_refresh_file_list_realize(GtkToggleButton * button, gpointer data)
|
|
1581 {
|
|
1582 gtk_toggle_button_set_active(button, cfg.refresh_file_list);
|
|
1583 }
|
|
1584
|
|
1585 static void
|
|
1586 on_refresh_file_list_toggled(GtkToggleButton * button, gpointer data)
|
|
1587 {
|
|
1588 cfg.refresh_file_list = gtk_toggle_button_get_active(button);
|
|
1589 }
|
|
1590
|
|
1591 static void
|
|
1592 on_playlist_convert_twenty_realize(GtkToggleButton * button, gpointer data)
|
|
1593 {
|
|
1594 gtk_toggle_button_set_active(button, cfg.convert_twenty);
|
|
1595 }
|
|
1596
|
|
1597 static void
|
|
1598 on_playlist_convert_twenty_toggled(GtkToggleButton * button, gpointer data)
|
|
1599 {
|
|
1600 cfg.convert_twenty = gtk_toggle_button_get_active(button);
|
|
1601 }
|
|
1602
|
|
1603 static void
|
|
1604 on_playlist_convert_slash_realize(GtkToggleButton * button, gpointer data)
|
|
1605 {
|
|
1606 gtk_toggle_button_set_active(button, cfg.convert_slash);
|
|
1607 }
|
|
1608
|
|
1609 static void
|
|
1610 on_playlist_convert_slash_toggled(GtkToggleButton * button, gpointer data)
|
|
1611 {
|
|
1612 cfg.convert_slash = gtk_toggle_button_get_active(button);
|
|
1613 }
|
|
1614
|
|
1615 static void
|
|
1616 on_use_pl_metadata_realize(GtkToggleButton * button,
|
|
1617 gpointer data)
|
|
1618 {
|
|
1619 gboolean state = cfg.use_pl_metadata;
|
|
1620 gtk_toggle_button_set_active(button, state);
|
|
1621 gtk_widget_set_sensitive(GTK_WIDGET(data), state);
|
|
1622 }
|
|
1623
|
|
1624 static void
|
|
1625 on_use_pl_metadata_toggled(GtkToggleButton * button,
|
|
1626 gpointer data)
|
|
1627 {
|
|
1628 gboolean state = gtk_toggle_button_get_active(button);
|
|
1629 cfg.use_pl_metadata = state;
|
|
1630 gtk_widget_set_sensitive(GTK_WIDGET(data), state);
|
|
1631 }
|
|
1632
|
|
1633 static void
|
|
1634 on_pause_between_songs_realize(GtkToggleButton * button,
|
|
1635 gpointer data)
|
|
1636 {
|
|
1637 gboolean state = cfg.pause_between_songs;
|
|
1638 gtk_toggle_button_set_active(button, state);
|
|
1639 gtk_widget_set_sensitive(GTK_WIDGET(data), state);
|
|
1640 }
|
|
1641
|
|
1642 static void
|
|
1643 on_pause_between_songs_toggled(GtkToggleButton * button,
|
|
1644 gpointer data)
|
|
1645 {
|
|
1646 gboolean state = gtk_toggle_button_get_active(button);
|
|
1647 cfg.pause_between_songs = state;
|
|
1648 gtk_widget_set_sensitive(GTK_WIDGET(data), state);
|
|
1649 }
|
|
1650
|
|
1651 static void
|
|
1652 on_pl_metadata_on_load_realize(GtkRadioButton * button,
|
|
1653 gpointer data)
|
|
1654 {
|
|
1655 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button),
|
|
1656 cfg.get_info_on_load);
|
|
1657 }
|
|
1658
|
|
1659 static void
|
|
1660 on_pl_metadata_on_display_realize(GtkRadioButton * button,
|
|
1661 gpointer data)
|
|
1662 {
|
|
1663 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button),
|
|
1664 cfg.get_info_on_demand);
|
|
1665 }
|
|
1666
|
|
1667 static void
|
|
1668 on_pl_metadata_on_load_toggled(GtkRadioButton * button,
|
|
1669 gpointer data)
|
|
1670 {
|
|
1671 cfg.get_info_on_load =
|
|
1672 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
|
|
1673 }
|
|
1674
|
|
1675 static void
|
|
1676 on_pl_metadata_on_display_toggled(GtkRadioButton * button,
|
|
1677 gpointer data)
|
|
1678 {
|
|
1679 cfg.get_info_on_demand =
|
|
1680 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
|
|
1681 }
|
|
1682
|
|
1683 static void
|
|
1684 on_custom_cursors_realize(GtkToggleButton * button,
|
|
1685 gpointer data)
|
|
1686 {
|
|
1687 gtk_toggle_button_set_active(button, cfg.custom_cursors);
|
|
1688 }
|
|
1689
|
|
1690 static void
|
|
1691 on_custom_cursors_toggled(GtkToggleButton *togglebutton,
|
|
1692 gpointer data)
|
|
1693 {
|
|
1694 cfg.custom_cursors = gtk_toggle_button_get_active(togglebutton);
|
|
1695 skin_reload_forced();
|
|
1696 }
|
|
1697
|
|
1698 static void
|
|
1699 on_eq_dir_preset_entry_realize(GtkEntry * entry,
|
|
1700 gpointer data)
|
|
1701 {
|
|
1702 gtk_entry_set_text(entry, cfg.eqpreset_default_file);
|
|
1703 }
|
|
1704
|
|
1705 static void
|
|
1706 on_eq_dir_preset_entry_changed(GtkEntry * entry,
|
|
1707 gpointer data)
|
|
1708 {
|
|
1709 g_free(cfg.eqpreset_default_file);
|
|
1710 cfg.eqpreset_default_file = g_strdup(gtk_entry_get_text(entry));
|
|
1711 }
|
|
1712
|
|
1713 static void
|
|
1714 on_eq_file_preset_entry_realize(GtkEntry * entry,
|
|
1715 gpointer data)
|
|
1716 {
|
|
1717 gtk_entry_set_text(entry, cfg.eqpreset_extension);
|
|
1718 }
|
|
1719
|
|
1720 static void
|
|
1721 on_eq_file_preset_entry_changed(GtkEntry * entry, gpointer data)
|
|
1722 {
|
|
1723 const gchar *text = gtk_entry_get_text(entry);
|
|
1724
|
|
1725 while (*text == '.')
|
|
1726 text++;
|
|
1727
|
|
1728 g_free(cfg.eqpreset_extension);
|
|
1729 cfg.eqpreset_extension = g_strdup(text);
|
|
1730 }
|
|
1731
|
|
1732
|
|
1733 /* FIXME: implement these */
|
|
1734
|
|
1735 static void
|
|
1736 on_eq_preset_view_realize(GtkTreeView * treeview,
|
|
1737 gpointer data)
|
|
1738 {}
|
|
1739
|
|
1740 static void
|
|
1741 on_eq_preset_add_clicked(GtkButton * button,
|
|
1742 gpointer data)
|
|
1743 {}
|
|
1744
|
|
1745 static void
|
|
1746 on_eq_preset_remove_clicked(GtkButton * button,
|
|
1747 gpointer data)
|
|
1748 {}
|
|
1749
|
|
1750 static void
|
|
1751 on_skin_refresh_button_clicked(GtkButton * button,
|
|
1752 gpointer data)
|
|
1753 {
|
|
1754 GladeXML *xml;
|
|
1755 GtkWidget *widget, *widget2;
|
|
1756
|
|
1757 const mode_t mode755 = S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
|
|
1758
|
|
1759 del_directory(bmp_paths[BMP_PATH_SKIN_THUMB_DIR]);
|
|
1760 make_directory(bmp_paths[BMP_PATH_SKIN_THUMB_DIR], mode755);
|
|
1761
|
|
1762 xml = prefswin_get_xml();
|
|
1763
|
|
1764 widget = glade_xml_get_widget(xml, "skin_view");
|
|
1765 widget2 = glade_xml_get_widget(xml, "skin_refresh_button");
|
|
1766 skin_view_update(GTK_TREE_VIEW(widget), GTK_WIDGET(widget2));
|
|
1767 }
|
|
1768
|
|
1769 static gboolean
|
|
1770 on_skin_view_realize(GtkTreeView * treeview,
|
|
1771 gpointer data)
|
|
1772 {
|
|
1773 GladeXML *xml;
|
|
1774 GtkWidget *widget;
|
|
1775
|
|
1776 xml = prefswin_get_xml();
|
|
1777 widget = glade_xml_get_widget(xml, "skin_refresh_button");
|
|
1778 skin_view_realize(treeview);
|
|
1779 skin_view_update(treeview, GTK_WIDGET(widget));
|
|
1780
|
|
1781 return TRUE;
|
|
1782 }
|
|
1783
|
|
1784 static void
|
|
1785 on_category_view_realize(GtkTreeView * treeview,
|
|
1786 GtkNotebook * notebook)
|
|
1787 {
|
|
1788 GtkListStore *store;
|
|
1789 GtkCellRenderer *renderer;
|
|
1790 GtkTreeViewColumn *column;
|
|
1791 GtkTreeSelection *selection;
|
|
1792 GtkTreeIter iter;
|
|
1793 GdkPixbuf *img;
|
|
1794 CategoryQueueEntry *qlist;
|
|
1795 gint i;
|
|
1796
|
|
1797 column = gtk_tree_view_column_new();
|
|
1798 gtk_tree_view_column_set_title(column, _("Category"));
|
|
1799 gtk_tree_view_append_column(treeview, column);
|
|
1800 gtk_tree_view_column_set_spacing(column, 2);
|
|
1801
|
|
1802 renderer = gtk_cell_renderer_pixbuf_new();
|
|
1803 gtk_tree_view_column_pack_start(column, renderer, FALSE);
|
|
1804 gtk_tree_view_column_set_attributes(column, renderer, "pixbuf", 0, NULL);
|
|
1805
|
|
1806 renderer = gtk_cell_renderer_text_new();
|
|
1807 gtk_tree_view_column_pack_start(column, renderer, FALSE);
|
|
1808 gtk_tree_view_column_set_attributes(column, renderer, "text", 1, NULL);
|
|
1809
|
|
1810 store = gtk_list_store_new(CATEGORY_VIEW_N_COLS,
|
|
1811 GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT);
|
|
1812 gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(store));
|
|
1813
|
|
1814 for (i = 0; i < n_categories; i++) {
|
|
1815 img = gdk_pixbuf_new_from_file(categories[i].icon_path, NULL);
|
|
1816 gtk_list_store_append(store, &iter);
|
|
1817 gtk_list_store_set(store, &iter,
|
|
1818 CATEGORY_VIEW_COL_ICON, img,
|
|
1819 CATEGORY_VIEW_COL_NAME,
|
|
1820 gettext(categories[i].name), CATEGORY_VIEW_COL_ID,
|
|
1821 categories[i].id, -1);
|
|
1822 g_object_unref(img);
|
|
1823 }
|
|
1824
|
|
1825 selection = gtk_tree_view_get_selection(treeview);
|
|
1826
|
|
1827 g_signal_connect_swapped(selection, "changed",
|
|
1828 G_CALLBACK(change_category), notebook);
|
|
1829
|
|
1830 /* mark the treeview widget as available to third party plugins */
|
|
1831 category_treeview = GTK_WIDGET(treeview);
|
|
1832
|
|
1833 /* prefswin_page_queue_destroy already pops the queue forward for us. */
|
|
1834 for (qlist = category_queue; qlist != NULL; qlist = category_queue)
|
|
1835 {
|
|
1836 CategoryQueueEntry *ent = (CategoryQueueEntry *) qlist;
|
|
1837
|
|
1838 prefswin_page_new(ent->container, ent->pg_name, ent->img_url);
|
|
1839 prefswin_page_queue_destroy(ent);
|
|
1840 }
|
|
1841 }
|
|
1842
|
|
1843 static void
|
|
1844 mainwin_drag_data_received1(GtkWidget * widget,
|
|
1845 GdkDragContext * context,
|
|
1846 gint x, gint y,
|
|
1847 GtkSelectionData * selection_data,
|
|
1848 guint info, guint time,
|
|
1849 gpointer user_data)
|
|
1850 {
|
|
1851 gchar *path, *decoded;
|
|
1852
|
|
1853 if (!selection_data->data) {
|
|
1854 g_warning("DND data string is NULL");
|
|
1855 return;
|
|
1856 }
|
|
1857
|
|
1858 path = (gchar *) selection_data->data;
|
|
1859
|
|
1860 /* FIXME: use a real URL validator/parser */
|
|
1861
|
|
1862 if (!str_has_prefix_nocase(path, "fonts:///"))
|
|
1863 return;
|
|
1864
|
|
1865 path[strlen(path) - 2] = 0; /* Why the hell a CR&LF? */
|
|
1866 path += 8;
|
|
1867
|
|
1868 /* plain, since we already stripped the first URI part */
|
|
1869 decoded = xmms_urldecode_plain(path);
|
|
1870
|
|
1871 /* Get the old font's size, and add it to the dropped
|
|
1872 * font's name */
|
|
1873 cfg.playlist_font = g_strconcat(decoded+1,
|
|
1874 strrchr(cfg.playlist_font, ' '),
|
|
1875 NULL);
|
|
1876 playlist_list_set_font(cfg.playlist_font);
|
|
1877 playlistwin_update_list(playlist_get_active());
|
|
1878 gtk_font_button_set_font_name(user_data, cfg.playlist_font);
|
|
1879
|
|
1880 g_free(decoded);
|
|
1881 }
|
|
1882
|
|
1883 static void
|
|
1884 on_skin_view_drag_data_received(GtkWidget * widget,
|
|
1885 GdkDragContext * context,
|
|
1886 gint x, gint y,
|
|
1887 GtkSelectionData * selection_data,
|
|
1888 guint info, guint time,
|
|
1889 gpointer user_data)
|
|
1890 {
|
|
1891 ConfigDb *db;
|
|
1892 gchar *path;
|
|
1893
|
|
1894 GladeXML *xml;
|
|
1895 GtkWidget *widget2;
|
|
1896
|
|
1897 if (!selection_data->data) {
|
|
1898 g_warning("DND data string is NULL");
|
|
1899 return;
|
|
1900 }
|
|
1901
|
|
1902 path = (gchar *) selection_data->data;
|
|
1903
|
|
1904 /* FIXME: use a real URL validator/parser */
|
|
1905
|
|
1906 if (str_has_prefix_nocase(path, "file:///")) {
|
|
1907 path[strlen(path) - 2] = 0; /* Why the hell a CR&LF? */
|
|
1908 path += 7;
|
|
1909 }
|
|
1910 else if (str_has_prefix_nocase(path, "file:")) {
|
|
1911 path += 5;
|
|
1912 }
|
|
1913
|
|
1914 if (file_is_archive(path)) {
|
|
1915 bmp_active_skin_load(path);
|
|
1916 skin_install_skin(path);
|
|
1917 xml = prefswin_get_xml();
|
|
1918 widget2 = glade_xml_get_widget(xml, "skin_refresh_button");
|
|
1919 skin_view_update(GTK_TREE_VIEW(widget), GTK_WIDGET(widget2));
|
|
1920 /* Change skin name in the config file */
|
|
1921 db = bmp_cfg_db_open();
|
|
1922 bmp_cfg_db_set_string(db, NULL, "skin", path);
|
|
1923 bmp_cfg_db_close(db);
|
|
1924 }
|
|
1925
|
|
1926 }
|
|
1927
|
|
1928 static void
|
|
1929 on_chardet_detector_cbox_changed(GtkComboBox * combobox, gpointer data)
|
|
1930 {
|
|
1931 ConfigDb *db;
|
|
1932 gint position = 0;
|
|
1933
|
|
1934 position = gtk_combo_box_get_active(GTK_COMBO_BOX(combobox));
|
|
1935 cfg.chardet_detector = (char *)chardet_detector_presets[position];
|
|
1936
|
|
1937 db = bmp_cfg_db_open();
|
|
1938 bmp_cfg_db_set_string(db, NULL, "chardet_detector", cfg.chardet_detector);
|
|
1939 bmp_cfg_db_close(db);
|
|
1940 if (data != NULL)
|
|
1941 gtk_widget_set_sensitive(GTK_WIDGET(data), 1);
|
|
1942 }
|
|
1943
|
|
1944 static void
|
|
1945 on_chardet_detector_cbox_realize(GtkComboBox *combobox, gpointer data)
|
|
1946 {
|
|
1947 ConfigDb *db;
|
|
1948 gchar *ret=NULL;
|
|
1949 guint i=0,index=0;
|
|
1950
|
|
1951 for(i=0; i<n_chardet_detector_presets; i++) {
|
|
1952 gtk_combo_box_append_text(combobox, chardet_detector_presets[i]);
|
|
1953 }
|
|
1954
|
|
1955 db = bmp_cfg_db_open();
|
|
1956 if(bmp_cfg_db_get_string(db, NULL, "chardet_detector", &ret) != FALSE) {
|
|
1957 for(i=0; i<n_chardet_detector_presets; i++) {
|
|
1958 if(!strcmp(chardet_detector_presets[i], ret)) {
|
|
1959 cfg.chardet_detector = (char *)chardet_detector_presets[i];
|
|
1960 index = i;
|
|
1961 }
|
|
1962 }
|
|
1963 }
|
|
1964 bmp_cfg_db_close(db);
|
|
1965
|
|
1966 #ifdef USE_CHARDET
|
|
1967 gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), index);
|
|
1968
|
|
1969 if (data != NULL)
|
|
1970 gtk_widget_set_sensitive(GTK_WIDGET(data), TRUE);
|
|
1971
|
|
1972 g_signal_connect(combobox, "changed",
|
|
1973 G_CALLBACK(on_chardet_detector_cbox_changed), NULL);
|
|
1974 #else
|
|
1975 gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), -1);
|
|
1976 gtk_widget_set_sensitive(GTK_WIDGET(combobox), 0);
|
|
1977 #endif
|
|
1978 if(ret)
|
|
1979 g_free(ret);
|
|
1980 }
|
|
1981
|
|
1982 static void
|
|
1983 on_chardet_fallback_realize(GtkEntry *entry, gpointer data)
|
|
1984 {
|
|
1985 ConfigDb *db;
|
|
1986 gchar *ret = NULL;
|
|
1987
|
|
1988 db = bmp_cfg_db_open();
|
|
1989
|
|
1990 if (bmp_cfg_db_get_string(db, NULL, "chardet_fallback", &ret) != FALSE) {
|
|
1991 if(cfg.chardet_fallback)
|
|
1992 g_free(cfg.chardet_fallback);
|
|
1993
|
|
1994 if(ret && strncasecmp(ret, "None", sizeof("None"))) {
|
|
1995 cfg.chardet_fallback = ret;
|
|
1996 } else {
|
|
1997 cfg.chardet_fallback = g_strdup("");
|
|
1998 }
|
|
1999 gtk_entry_set_text(entry, cfg.chardet_fallback);
|
|
2000 }
|
|
2001
|
|
2002 bmp_cfg_db_close(db);
|
|
2003 }
|
|
2004
|
|
2005 static void
|
|
2006 on_chardet_fallback_changed(GtkEntry *entry, gpointer data)
|
|
2007 {
|
|
2008 ConfigDb *db;
|
|
2009 gchar *ret = NULL;
|
|
2010
|
|
2011 if(cfg.chardet_fallback)
|
|
2012 g_free(cfg.chardet_fallback);
|
|
2013
|
|
2014 ret = g_strdup(gtk_entry_get_text(entry));
|
|
2015
|
|
2016 if(ret == NULL)
|
|
2017 cfg.chardet_fallback = g_strdup("");
|
|
2018 else
|
|
2019 cfg.chardet_fallback = ret;
|
|
2020
|
|
2021 db = bmp_cfg_db_open();
|
|
2022
|
|
2023 if(cfg.chardet_fallback == NULL || !strcmp(cfg.chardet_fallback, ""))
|
|
2024 bmp_cfg_db_set_string(db, NULL, "chardet_fallback", "None");
|
|
2025 else
|
|
2026 bmp_cfg_db_set_string(db, NULL, "chardet_fallback", cfg.chardet_fallback);
|
|
2027
|
|
2028 bmp_cfg_db_close(db);
|
|
2029 }
|
|
2030
|
|
2031 static void
|
|
2032 on_show_filepopup_for_tuple_realize(GtkToggleButton * button, gpointer data)
|
|
2033 {
|
|
2034 GladeXML *xml = prefswin_get_xml();
|
|
2035 GtkWidget *settings_button = glade_xml_get_widget(xml, "filepopup_for_tuple_settings_button");
|
|
2036
|
|
2037 gtk_toggle_button_set_active(button, cfg.show_filepopup_for_tuple);
|
|
2038 filepopupbutton = (GtkWidget *)button;
|
|
2039
|
|
2040 gtk_widget_set_sensitive(settings_button, cfg.show_filepopup_for_tuple);
|
|
2041 }
|
|
2042
|
|
2043 static void
|
|
2044 on_show_filepopup_for_tuple_toggled(GtkToggleButton * button, gpointer data)
|
|
2045 {
|
|
2046 GladeXML *xml = prefswin_get_xml();
|
|
2047 GtkWidget *settings_button = glade_xml_get_widget(xml, "filepopup_for_tuple_settings_button");
|
|
2048
|
|
2049 cfg.show_filepopup_for_tuple = gtk_toggle_button_get_active(button);
|
|
2050
|
|
2051 gtk_widget_set_sensitive(settings_button, cfg.show_filepopup_for_tuple);
|
|
2052 }
|
|
2053
|
|
2054 static void
|
|
2055 on_recurse_for_cover_toggled(GtkToggleButton *button, gpointer data)
|
|
2056 {
|
|
2057 gtk_widget_set_sensitive(GTK_WIDGET(data),
|
|
2058 gtk_toggle_button_get_active(button));
|
|
2059 }
|
|
2060
|
|
2061 static void
|
|
2062 on_colorize_button_clicked(GtkButton *button, gpointer data)
|
|
2063 {
|
|
2064 GladeXML *xml = prefswin_get_xml();
|
|
2065 GtkWidget *widget;
|
|
2066
|
|
2067 widget = glade_xml_get_widget(xml, "red_scale");
|
|
2068 gtk_range_set_value(GTK_RANGE(widget), cfg.colorize_r);
|
|
2069
|
|
2070 widget = glade_xml_get_widget(xml, "green_scale");
|
|
2071 gtk_range_set_value(GTK_RANGE(widget), cfg.colorize_g);
|
|
2072
|
|
2073 widget = glade_xml_get_widget(xml, "blue_scale");
|
|
2074 gtk_range_set_value(GTK_RANGE(widget), cfg.colorize_b);
|
|
2075
|
|
2076 gtk_widget_show(colorize_settings);
|
|
2077 }
|
|
2078
|
|
2079 static void
|
|
2080 on_red_scale_value_changed(GtkHScale *scale, gpointer data)
|
|
2081 {
|
2328
|
2082 //GladeXML *xml = prefswin_get_xml();
|
|
2083 //GtkWidget *widget;
|
2313
|
2084 gint value;
|
|
2085
|
|
2086 value = gtk_range_get_value(GTK_RANGE(scale));
|
|
2087
|
|
2088 if (value != cfg.colorize_r)
|
|
2089 {
|
|
2090 cfg.colorize_r = value;
|
|
2091
|
|
2092 /* reload the skin to apply the change */
|
|
2093 skin_reload_forced();
|
|
2094 draw_main_window(TRUE);
|
|
2095 draw_equalizer_window(TRUE);
|
|
2096 draw_playlist_window(TRUE);
|
|
2097 }
|
|
2098 }
|
|
2099
|
|
2100 static void
|
|
2101 on_green_scale_value_changed(GtkHScale *scale, gpointer data)
|
|
2102 {
|
2328
|
2103 //GladeXML *xml = prefswin_get_xml();
|
|
2104 //GtkWidget *widget;
|
2313
|
2105 gint value;
|
|
2106
|
|
2107 value = gtk_range_get_value(GTK_RANGE(scale));
|
|
2108
|
|
2109 if (value != cfg.colorize_r)
|
|
2110 {
|
|
2111 cfg.colorize_g = value;
|
|
2112
|
|
2113 /* reload the skin to apply the change */
|
|
2114 skin_reload_forced();
|
|
2115 draw_main_window(TRUE);
|
|
2116 draw_equalizer_window(TRUE);
|
|
2117 draw_playlist_window(TRUE);
|
|
2118 }
|
|
2119 }
|
|
2120
|
|
2121 static void
|
|
2122 on_blue_scale_value_changed(GtkHScale *scale, gpointer data)
|
|
2123 {
|
2328
|
2124 //GladeXML *xml = prefswin_get_xml();
|
|
2125 //GtkWidget *widget;
|
2313
|
2126 gint value;
|
|
2127
|
|
2128 value = gtk_range_get_value(GTK_RANGE(scale));
|
|
2129
|
|
2130 if (value != cfg.colorize_r)
|
|
2131 {
|
|
2132 cfg.colorize_b = value;
|
|
2133
|
|
2134 /* reload the skin to apply the change */
|
|
2135 skin_reload_forced();
|
|
2136 draw_main_window(TRUE);
|
|
2137 draw_equalizer_window(TRUE);
|
|
2138 draw_playlist_window(TRUE);
|
|
2139 }
|
|
2140 }
|
|
2141
|
|
2142 static void
|
|
2143 on_colorize_close_clicked(GtkButton *button, gpointer data)
|
|
2144 {
|
|
2145 gtk_widget_hide(colorize_settings);
|
|
2146 }
|
|
2147
|
|
2148 static void
|
|
2149 on_filepopup_for_tuple_settings_clicked(GtkButton *button, gpointer data)
|
|
2150 {
|
|
2151 GladeXML *xml = prefswin_get_xml();
|
|
2152 GtkWidget *widget, *widget2;
|
|
2153
|
|
2154 widget = glade_xml_get_widget(xml, "filepopup_settings_cover_name_include");
|
|
2155 gtk_entry_set_text(GTK_ENTRY(widget), cfg.cover_name_include);
|
|
2156
|
|
2157 widget = glade_xml_get_widget(xml, "filepopup_settings_cover_name_exclude");
|
|
2158 gtk_entry_set_text(GTK_ENTRY(widget), cfg.cover_name_exclude);
|
|
2159
|
|
2160 widget2 = glade_xml_get_widget(xml, "filepopup_settings_recurse_for_cover");
|
|
2161 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget2), cfg.recurse_for_cover);
|
|
2162
|
|
2163 widget = glade_xml_get_widget(xml, "filepopup_settings_recurse_for_cover_depth");
|
|
2164 gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget), cfg.recurse_for_cover_depth);
|
|
2165
|
|
2166 widget = glade_xml_get_widget(xml, "filepopup_settings_recurse_for_cover_depth_box");
|
|
2167 on_recurse_for_cover_toggled(GTK_TOGGLE_BUTTON(widget2), widget);
|
|
2168
|
|
2169 widget = glade_xml_get_widget(xml, "filepopup_settings_use_file_cover");
|
|
2170 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), cfg.use_file_cover);
|
|
2171
|
|
2172 gtk_widget_show(filepopup_settings);
|
|
2173 }
|
|
2174
|
|
2175 static void
|
|
2176 on_filepopup_settings_ok_clicked(GtkButton *button, gpointer data)
|
|
2177 {
|
|
2178 GladeXML *xml = prefswin_get_xml();
|
|
2179 GtkWidget *widget;
|
|
2180
|
|
2181 widget = glade_xml_get_widget(xml, "filepopup_settings_cover_name_include");
|
|
2182 g_free(cfg.cover_name_include);
|
|
2183 cfg.cover_name_include = g_strdup(gtk_entry_get_text(GTK_ENTRY(widget)));
|
|
2184
|
|
2185 widget = glade_xml_get_widget(xml, "filepopup_settings_cover_name_exclude");
|
|
2186 g_free(cfg.cover_name_exclude);
|
|
2187 cfg.cover_name_exclude = g_strdup(gtk_entry_get_text(GTK_ENTRY(widget)));
|
|
2188
|
|
2189 widget = glade_xml_get_widget(xml, "filepopup_settings_recurse_for_cover");
|
|
2190 cfg.recurse_for_cover = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
|
|
2191
|
|
2192 widget = glade_xml_get_widget(xml, "filepopup_settings_recurse_for_cover_depth");
|
|
2193 cfg.recurse_for_cover_depth = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
|
|
2194
|
|
2195 widget = glade_xml_get_widget(xml, "filepopup_settings_use_file_cover");
|
|
2196 cfg.use_file_cover = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
|
|
2197
|
|
2198 gtk_widget_hide(filepopup_settings);
|
|
2199 }
|
|
2200
|
|
2201 static void
|
|
2202 on_filepopup_settings_cancel_clicked(GtkButton *button, gpointer data)
|
|
2203 {
|
|
2204 gtk_widget_hide(filepopup_settings);
|
|
2205 }
|
|
2206
|
|
2207 static void
|
|
2208 on_xmms_style_fileselector_realize(GtkToggleButton * button,
|
|
2209 gpointer data)
|
|
2210 {
|
|
2211 gtk_toggle_button_set_active(button, cfg.use_xmms_style_fileselector);
|
|
2212 }
|
|
2213
|
|
2214 static void
|
|
2215 on_xmms_style_fileselector_toggled(GtkToggleButton * button,
|
|
2216 gpointer data)
|
|
2217 {
|
|
2218 cfg.use_xmms_style_fileselector = gtk_toggle_button_get_active(button);
|
|
2219 }
|
|
2220
|
|
2221 static void
|
|
2222 on_show_wm_decorations_realize(GtkToggleButton * button,
|
|
2223 gpointer data)
|
|
2224 {
|
|
2225 gtk_toggle_button_set_active(button, cfg.show_wm_decorations);
|
|
2226 }
|
|
2227
|
|
2228 static void
|
|
2229 on_show_wm_decorations_toggled(GtkToggleButton * button,
|
|
2230 gpointer data)
|
|
2231 {
|
|
2232 extern GtkWidget *equalizerwin;
|
|
2233 cfg.show_wm_decorations = gtk_toggle_button_get_active(button);
|
|
2234 gtk_window_set_decorated(GTK_WINDOW(mainwin), cfg.show_wm_decorations);
|
|
2235 gtk_window_set_decorated(GTK_WINDOW(playlistwin), cfg.show_wm_decorations);
|
|
2236 gtk_window_set_decorated(GTK_WINDOW(equalizerwin), cfg.show_wm_decorations);
|
|
2237
|
|
2238 }
|
|
2239
|
|
2240 /* FIXME: complete the map */
|
|
2241 FUNC_MAP_BEGIN(prefswin_func_map)
|
|
2242 FUNC_MAP_ENTRY(on_input_plugin_view_realize)
|
|
2243 FUNC_MAP_ENTRY(on_output_plugin_cbox_realize)
|
|
2244 FUNC_MAP_ENTRY(on_general_plugin_view_realize)
|
|
2245 FUNC_MAP_ENTRY(on_vis_plugin_view_realize)
|
|
2246 FUNC_MAP_ENTRY(on_effect_plugin_view_realize)
|
|
2247 FUNC_MAP_ENTRY(on_custom_cursors_realize)
|
|
2248 FUNC_MAP_ENTRY(on_custom_cursors_toggled)
|
|
2249 FUNC_MAP_ENTRY(on_mainwin_font_button_realize)
|
|
2250 FUNC_MAP_ENTRY(on_mainwin_font_button_font_set)
|
|
2251 FUNC_MAP_ENTRY(on_use_bitmap_fonts_realize)
|
|
2252 FUNC_MAP_ENTRY(on_use_bitmap_fonts_toggled)
|
|
2253 FUNC_MAP_ENTRY(on_mouse_wheel_volume_realize)
|
|
2254 FUNC_MAP_ENTRY(on_mouse_wheel_volume_changed)
|
|
2255 FUNC_MAP_ENTRY(on_mouse_wheel_scroll_pl_realize)
|
|
2256 FUNC_MAP_ENTRY(on_mouse_wheel_scroll_pl_changed)
|
|
2257 FUNC_MAP_ENTRY(on_pause_between_songs_time_realize)
|
|
2258 FUNC_MAP_ENTRY(on_pause_between_songs_time_changed)
|
|
2259 FUNC_MAP_ENTRY(on_pl_metadata_on_load_realize)
|
|
2260 FUNC_MAP_ENTRY(on_pl_metadata_on_load_toggled)
|
|
2261 FUNC_MAP_ENTRY(on_pl_metadata_on_display_realize)
|
|
2262 FUNC_MAP_ENTRY(on_pl_metadata_on_display_toggled)
|
|
2263 FUNC_MAP_ENTRY(on_playlist_show_pl_numbers_realize)
|
|
2264 FUNC_MAP_ENTRY(on_playlist_show_pl_numbers_toggled)
|
|
2265 FUNC_MAP_ENTRY(on_playlist_show_pl_separator_realize)
|
|
2266 FUNC_MAP_ENTRY(on_playlist_show_pl_separator_toggled)
|
|
2267 FUNC_MAP_ENTRY(on_playlist_transparent_realize)
|
|
2268 FUNC_MAP_ENTRY(on_playlist_transparent_toggled)
|
|
2269 FUNC_MAP_ENTRY(on_playlist_convert_twenty_realize)
|
|
2270 FUNC_MAP_ENTRY(on_playlist_convert_twenty_toggled)
|
|
2271 FUNC_MAP_ENTRY(on_playlist_convert_underscore_realize)
|
|
2272 FUNC_MAP_ENTRY(on_playlist_convert_underscore_toggled)
|
|
2273 FUNC_MAP_ENTRY(on_playlist_convert_slash_realize)
|
|
2274 FUNC_MAP_ENTRY(on_playlist_convert_slash_toggled)
|
|
2275 FUNC_MAP_ENTRY(on_playlist_font_button_realize)
|
|
2276 FUNC_MAP_ENTRY(on_playlist_font_button_font_set)
|
|
2277 FUNC_MAP_ENTRY(on_playlist_no_advance_realize)
|
|
2278 FUNC_MAP_ENTRY(on_playlist_no_advance_toggled)
|
|
2279 FUNC_MAP_ENTRY(on_refresh_file_list_realize)
|
|
2280 FUNC_MAP_ENTRY(on_refresh_file_list_toggled)
|
|
2281 FUNC_MAP_ENTRY(on_skin_view_realize)
|
|
2282 FUNC_MAP_ENTRY(on_titlestring_entry_realize)
|
|
2283 FUNC_MAP_ENTRY(on_titlestring_entry_changed)
|
|
2284 FUNC_MAP_ENTRY(on_eq_dir_preset_entry_realize)
|
|
2285 FUNC_MAP_ENTRY(on_eq_dir_preset_entry_changed)
|
|
2286 FUNC_MAP_ENTRY(on_eq_file_preset_entry_realize)
|
|
2287 FUNC_MAP_ENTRY(on_eq_file_preset_entry_changed)
|
|
2288 FUNC_MAP_ENTRY(on_eq_preset_view_realize)
|
|
2289 FUNC_MAP_ENTRY(on_eq_preset_add_clicked)
|
|
2290 FUNC_MAP_ENTRY(on_eq_preset_remove_clicked)
|
|
2291 FUNC_MAP_ENTRY(on_skin_refresh_button_clicked)
|
|
2292 FUNC_MAP_ENTRY(on_proxy_use_toggled)
|
|
2293 FUNC_MAP_ENTRY(on_proxy_use_realize)
|
|
2294 FUNC_MAP_ENTRY(on_proxy_auth_toggled)
|
|
2295 FUNC_MAP_ENTRY(on_proxy_auth_realize)
|
|
2296 FUNC_MAP_ENTRY(on_proxy_host_realize)
|
|
2297 FUNC_MAP_ENTRY(on_proxy_host_changed)
|
|
2298 FUNC_MAP_ENTRY(on_proxy_port_realize)
|
|
2299 FUNC_MAP_ENTRY(on_proxy_port_changed)
|
|
2300 FUNC_MAP_ENTRY(on_proxy_user_realize)
|
|
2301 FUNC_MAP_ENTRY(on_proxy_user_changed)
|
|
2302 FUNC_MAP_ENTRY(on_proxy_pass_realize)
|
|
2303 FUNC_MAP_ENTRY(on_proxy_pass_changed)
|
|
2304 FUNC_MAP_ENTRY(on_chardet_detector_cbox_realize)
|
|
2305 FUNC_MAP_ENTRY(on_chardet_detector_cbox_changed)
|
|
2306 FUNC_MAP_ENTRY(on_chardet_fallback_realize)
|
|
2307 FUNC_MAP_ENTRY(on_chardet_fallback_changed)
|
|
2308 FUNC_MAP_ENTRY(on_output_plugin_bufsize_realize)
|
|
2309 FUNC_MAP_ENTRY(on_output_plugin_bufsize_value_changed)
|
|
2310 FUNC_MAP_ENTRY(on_audio_format_det_cb_toggled)
|
|
2311 FUNC_MAP_ENTRY(on_audio_format_det_cb_realize)
|
|
2312 FUNC_MAP_ENTRY(on_detect_by_extension_cb_toggled)
|
|
2313 FUNC_MAP_ENTRY(on_detect_by_extension_cb_realize)
|
|
2314 FUNC_MAP_ENTRY(on_show_filepopup_for_tuple_realize)
|
|
2315 FUNC_MAP_ENTRY(on_show_filepopup_for_tuple_toggled)
|
|
2316 FUNC_MAP_ENTRY(on_filepopup_for_tuple_settings_clicked)
|
|
2317 FUNC_MAP_ENTRY(on_continue_playback_on_startup_realize)
|
|
2318 FUNC_MAP_ENTRY(on_continue_playback_on_startup_toggled)
|
|
2319
|
|
2320 /* Filepopup settings */
|
|
2321 FUNC_MAP_ENTRY(on_filepopup_settings_ok_clicked)
|
|
2322 FUNC_MAP_ENTRY(on_filepopup_settings_cancel_clicked)
|
|
2323
|
|
2324 /* XMMS fileselector option -nenolod */
|
|
2325 FUNC_MAP_ENTRY(on_xmms_style_fileselector_toggled)
|
|
2326 FUNC_MAP_ENTRY(on_xmms_style_fileselector_realize)
|
|
2327
|
|
2328 /* show window manager decorations */
|
|
2329 FUNC_MAP_ENTRY(on_show_wm_decorations_toggled)
|
|
2330 FUNC_MAP_ENTRY(on_show_wm_decorations_realize)
|
|
2331
|
|
2332 /* colorize */
|
|
2333 FUNC_MAP_ENTRY(on_colorize_button_clicked)
|
|
2334 FUNC_MAP_ENTRY(on_red_scale_value_changed)
|
|
2335 FUNC_MAP_ENTRY(on_green_scale_value_changed)
|
|
2336 FUNC_MAP_ENTRY(on_blue_scale_value_changed)
|
|
2337 FUNC_MAP_ENTRY(on_colorize_close_clicked)
|
|
2338 FUNC_MAP_END
|
|
2339
|
|
2340 void
|
|
2341 create_prefs_window(void)
|
|
2342 {
|
|
2343 const gchar *glade_file = DATA_DIR "/glade/prefswin.glade";
|
|
2344
|
|
2345 GladeXML *xml;
|
|
2346 GtkWidget *widget, *widget2;
|
|
2347 GString *aud_version_string;
|
|
2348
|
|
2349 GtkWidget *titlestring_tag_menu, *menu_item;
|
|
2350 guint i;
|
|
2351
|
|
2352 /* load the interface */
|
|
2353 xml = glade_xml_new_or_die(_("Preferences Window"), glade_file, NULL,
|
|
2354 NULL);
|
|
2355
|
|
2356
|
|
2357 /* connect the signals in the interface */
|
|
2358 glade_xml_signal_autoconnect_map(xml, prefswin_func_map);
|
|
2359
|
|
2360 prefswin = glade_xml_get_widget(xml, "prefswin");
|
|
2361 g_object_set_data(G_OBJECT(prefswin), "glade-xml", xml);
|
|
2362 /* this will hide only mainwin. it's annoying! yaz */
|
|
2363 // gtk_window_set_transient_for(GTK_WINDOW(prefswin), GTK_WINDOW(mainwin));
|
|
2364
|
|
2365 /* create category view */
|
|
2366 widget = glade_xml_get_widget(xml, "category_view");
|
|
2367 widget2 = glade_xml_get_widget(xml, "category_notebook");
|
|
2368 g_signal_connect_after(G_OBJECT(widget), "realize",
|
|
2369 G_CALLBACK(on_category_view_realize),
|
|
2370 widget2);
|
|
2371
|
|
2372 category_treeview = GTK_WIDGET(widget);
|
|
2373 category_notebook = GTK_WIDGET(widget2);
|
|
2374
|
|
2375 /* plugin->input page */
|
|
2376
|
|
2377 widget = glade_xml_get_widget(xml, "input_plugin_view");
|
|
2378 widget2 = glade_xml_get_widget(xml, "input_plugin_prefs");
|
|
2379 g_signal_connect(G_OBJECT(widget), "cursor-changed",
|
|
2380 G_CALLBACK(input_plugin_enable_prefs),
|
|
2381 widget2);
|
|
2382
|
|
2383 g_signal_connect_swapped(G_OBJECT(widget2), "clicked",
|
|
2384 G_CALLBACK(input_plugin_open_prefs),
|
|
2385 widget);
|
|
2386 widget2 = glade_xml_get_widget(xml, "input_plugin_info");
|
|
2387 g_signal_connect(G_OBJECT(widget), "cursor-changed",
|
|
2388 G_CALLBACK(input_plugin_enable_info),
|
|
2389 widget2);
|
|
2390 g_signal_connect_swapped(G_OBJECT(widget2), "clicked",
|
|
2391 G_CALLBACK(input_plugin_open_info),
|
|
2392 widget);
|
|
2393
|
|
2394 /* plugin->output page */
|
|
2395
|
|
2396 widget = glade_xml_get_widget(xml, "output_plugin_cbox");
|
|
2397
|
|
2398 widget2 = glade_xml_get_widget(xml, "output_plugin_prefs");
|
|
2399 g_signal_connect(G_OBJECT(widget), "changed",
|
|
2400 G_CALLBACK(output_plugin_enable_prefs),
|
|
2401 widget2);
|
|
2402 g_signal_connect_swapped(G_OBJECT(widget2), "clicked",
|
|
2403 G_CALLBACK(output_plugin_open_prefs),
|
|
2404 widget);
|
|
2405
|
|
2406 widget2 = glade_xml_get_widget(xml, "output_plugin_info");
|
|
2407 g_signal_connect(G_OBJECT(widget), "changed",
|
|
2408 G_CALLBACK(output_plugin_enable_info),
|
|
2409 widget2);
|
|
2410 g_signal_connect_swapped(G_OBJECT(widget2), "clicked",
|
|
2411 G_CALLBACK(output_plugin_open_info),
|
|
2412 widget);
|
|
2413
|
|
2414 /* plugin->general page */
|
|
2415
|
|
2416 widget = glade_xml_get_widget(xml, "general_plugin_view");
|
|
2417
|
|
2418 widget2 = glade_xml_get_widget(xml, "general_plugin_prefs");
|
|
2419 g_signal_connect(G_OBJECT(widget), "cursor-changed",
|
|
2420 G_CALLBACK(general_plugin_enable_prefs),
|
|
2421 widget2);
|
|
2422 g_signal_connect_swapped(G_OBJECT(widget2), "clicked",
|
|
2423 G_CALLBACK(general_plugin_open_prefs),
|
|
2424 widget);
|
|
2425
|
|
2426 widget2 = glade_xml_get_widget(xml, "general_plugin_info");
|
|
2427 g_signal_connect(G_OBJECT(widget), "cursor-changed",
|
|
2428 G_CALLBACK(general_plugin_enable_info),
|
|
2429 widget2);
|
|
2430 g_signal_connect_swapped(G_OBJECT(widget2), "clicked",
|
|
2431 G_CALLBACK(general_plugin_open_info),
|
|
2432 widget);
|
|
2433
|
|
2434
|
|
2435 /* plugin->vis page */
|
|
2436
|
|
2437 widget = glade_xml_get_widget(xml, "vis_plugin_view");
|
|
2438 widget2 = glade_xml_get_widget(xml, "vis_plugin_prefs");
|
|
2439
|
|
2440 g_signal_connect_swapped(G_OBJECT(widget2), "clicked",
|
|
2441 G_CALLBACK(vis_plugin_open_prefs),
|
|
2442 widget);
|
|
2443 g_signal_connect(G_OBJECT(widget), "cursor-changed",
|
|
2444 G_CALLBACK(vis_plugin_enable_prefs), widget2);
|
|
2445
|
|
2446
|
|
2447 widget2 = glade_xml_get_widget(xml, "vis_plugin_info");
|
|
2448 g_signal_connect(G_OBJECT(widget), "cursor-changed",
|
|
2449 G_CALLBACK(vis_plugin_enable_info), widget2);
|
|
2450 g_signal_connect_swapped(G_OBJECT(widget2), "clicked",
|
|
2451 G_CALLBACK(vis_plugin_open_info),
|
|
2452 widget);
|
|
2453
|
|
2454
|
|
2455 /* plugin->effects page */
|
|
2456
|
|
2457 widget = glade_xml_get_widget(xml, "effect_plugin_view");
|
|
2458 widget2 = glade_xml_get_widget(xml, "effect_plugin_prefs");
|
|
2459
|
|
2460 g_signal_connect_swapped(G_OBJECT(widget2), "clicked",
|
|
2461 G_CALLBACK(effect_plugin_open_prefs),
|
|
2462 widget);
|
|
2463 g_signal_connect(G_OBJECT(widget), "cursor-changed",
|
|
2464 G_CALLBACK(effect_plugin_enable_prefs), widget2);
|
|
2465
|
|
2466
|
|
2467 widget2 = glade_xml_get_widget(xml, "effect_plugin_info");
|
|
2468 g_signal_connect(G_OBJECT(widget), "cursor-changed",
|
|
2469 G_CALLBACK(effect_plugin_enable_info), widget2);
|
|
2470 g_signal_connect_swapped(G_OBJECT(widget2), "clicked",
|
|
2471 G_CALLBACK(effect_plugin_open_info),
|
|
2472 widget);
|
|
2473
|
|
2474 /* playlist page */
|
|
2475
|
|
2476 widget = glade_xml_get_widget(xml, "pause_between_songs_box");
|
|
2477 widget2 = glade_xml_get_widget(xml, "pause_between_songs");
|
|
2478 g_signal_connect_after(G_OBJECT(widget2), "realize",
|
|
2479 G_CALLBACK(on_pause_between_songs_realize),
|
|
2480 widget);
|
|
2481 g_signal_connect(G_OBJECT(widget2), "toggled",
|
|
2482 G_CALLBACK(on_pause_between_songs_toggled),
|
|
2483 widget);
|
|
2484
|
|
2485 widget = glade_xml_get_widget(xml, "playlist_use_metadata_box");
|
|
2486 widget2 = glade_xml_get_widget(xml, "playlist_use_metadata");
|
|
2487 g_signal_connect_after(G_OBJECT(widget2), "realize",
|
|
2488 G_CALLBACK(on_use_pl_metadata_realize),
|
|
2489 widget);
|
|
2490 g_signal_connect(G_OBJECT(widget2), "toggled",
|
|
2491 G_CALLBACK(on_use_pl_metadata_toggled),
|
|
2492 widget);
|
|
2493
|
|
2494 widget = glade_xml_get_widget(xml, "skin_view");
|
|
2495 g_signal_connect(widget, "drag-data-received",
|
|
2496 G_CALLBACK(on_skin_view_drag_data_received),
|
|
2497 NULL);
|
|
2498 bmp_drag_dest_set(widget);
|
|
2499
|
|
2500 g_signal_connect(mainwin, "drag-data-received",
|
|
2501 G_CALLBACK(mainwin_drag_data_received),
|
|
2502 widget);
|
|
2503
|
|
2504 widget = glade_xml_get_widget(xml, "skin_refresh_button");
|
|
2505 g_signal_connect(widget, "clicked",
|
|
2506 G_CALLBACK(on_skin_refresh_button_clicked),
|
|
2507 NULL);
|
|
2508
|
|
2509 widget = glade_xml_get_widget(xml, "playlist_font_button");
|
|
2510 g_signal_connect(mainwin, "drag-data-received",
|
|
2511 G_CALLBACK(mainwin_drag_data_received1),
|
|
2512 widget);
|
|
2513
|
|
2514 widget = glade_xml_get_widget(xml, "titlestring_cbox");
|
|
2515 widget2 = glade_xml_get_widget(xml, "titlestring_entry");
|
|
2516 g_signal_connect(widget, "realize",
|
|
2517 G_CALLBACK(on_titlestring_cbox_realize),
|
|
2518 widget2);
|
|
2519 g_signal_connect(widget, "changed",
|
|
2520 G_CALLBACK(on_titlestring_cbox_changed),
|
|
2521 widget2);
|
|
2522
|
|
2523 /* FIXME: move this into a function */
|
|
2524 /* create tag menu */
|
|
2525 titlestring_tag_menu = gtk_menu_new();
|
|
2526 for(i = 0; i < n_title_field_tags; i++) {
|
|
2527 menu_item = gtk_menu_item_new_with_label(_(title_field_tags[i].name));
|
|
2528 gtk_menu_shell_append(GTK_MENU_SHELL(titlestring_tag_menu), menu_item);
|
|
2529 g_signal_connect(menu_item, "activate",
|
|
2530 G_CALLBACK(titlestring_tag_menu_callback),
|
|
2531 GINT_TO_POINTER(i));
|
|
2532 };
|
|
2533 gtk_widget_show_all(titlestring_tag_menu);
|
|
2534
|
|
2535 widget = glade_xml_get_widget(xml, "titlestring_help_button");
|
|
2536 widget2 = glade_xml_get_widget(xml, "titlestring_cbox");
|
|
2537
|
|
2538 g_signal_connect(widget2, "changed",
|
|
2539 G_CALLBACK(on_titlestring_cbox_changed),
|
|
2540 widget);
|
|
2541 g_signal_connect(widget, "clicked",
|
|
2542 G_CALLBACK(on_titlestring_help_button_clicked),
|
|
2543 titlestring_tag_menu);
|
|
2544
|
|
2545 /* audacious version label */
|
|
2546 widget = glade_xml_get_widget(xml, "audversionlabel");
|
|
2547 aud_version_string = g_string_new( "" );
|
|
2548
|
|
2549 if (strcasecmp(svn_stamp, "exported"))
|
|
2550 {
|
|
2551 g_string_printf( aud_version_string , "<span size='small'>%s (r%s) (%s@%s)</span>" , "Audacious " PACKAGE_VERSION ,
|
|
2552 svn_stamp , g_get_user_name() , g_get_host_name() );
|
|
2553 }
|
|
2554 else
|
|
2555 {
|
|
2556 g_string_printf( aud_version_string , "<span size='small'>%s (%s@%s)</span>" , "Audacious " PACKAGE_VERSION ,
|
|
2557 g_get_user_name() , g_get_host_name() );
|
|
2558 }
|
|
2559
|
|
2560 gtk_label_set_markup( GTK_LABEL(widget) , aud_version_string->str );
|
|
2561 g_string_free( aud_version_string , TRUE );
|
|
2562
|
|
2563 /* Create window for filepopup settings */
|
|
2564 filepopup_settings = glade_xml_get_widget(xml, "filepopup_for_tuple_settings");
|
|
2565 gtk_window_set_transient_for(GTK_WINDOW(filepopup_settings), GTK_WINDOW(prefswin));
|
|
2566
|
|
2567 widget = glade_xml_get_widget(xml, "filepopup_settings_recurse_for_cover_depth_box");
|
|
2568 widget2 = glade_xml_get_widget(xml, "filepopup_settings_recurse_for_cover");
|
|
2569 g_signal_connect(G_OBJECT(widget2), "toggled",
|
|
2570 G_CALLBACK(on_recurse_for_cover_toggled),
|
|
2571 widget);
|
|
2572
|
|
2573 /* Create window for filepopup settings */
|
|
2574 colorize_settings = glade_xml_get_widget(xml, "colorize_popup");
|
|
2575 gtk_window_set_transient_for(GTK_WINDOW(colorize_settings), GTK_WINDOW(prefswin));
|
|
2576 gtk_widget_hide(colorize_settings);
|
|
2577 }
|
|
2578
|
|
2579 void
|
|
2580 show_prefs_window(void)
|
|
2581 {
|
|
2582 gtk_widget_show(prefswin);
|
|
2583 }
|
|
2584
|
|
2585 static void
|
|
2586 prefswin_page_queue_new(GtkWidget *container, gchar *name, gchar *imgurl)
|
|
2587 {
|
|
2588 CategoryQueueEntry *ent = g_malloc0(sizeof(CategoryQueueEntry));
|
|
2589
|
|
2590 ent->container = container;
|
|
2591 ent->pg_name = name;
|
|
2592 ent->img_url = imgurl;
|
|
2593
|
|
2594 if (category_queue)
|
|
2595 ent->next = category_queue;
|
|
2596
|
|
2597 category_queue = ent;
|
|
2598 }
|
|
2599
|
|
2600 static void
|
|
2601 prefswin_page_queue_destroy(CategoryQueueEntry *ent)
|
|
2602 {
|
|
2603 category_queue = ent->next;
|
|
2604 g_free(ent);
|
|
2605 }
|
|
2606
|
|
2607 /*
|
|
2608 * Public APIs for adding new pages to the prefs window.
|
|
2609 *
|
|
2610 * Basically, the concept here is that third party components can register themselves in the root
|
|
2611 * preferences window.
|
|
2612 *
|
|
2613 * From a usability standpoint this makes the application look more "united", instead of cluttered
|
|
2614 * and malorganised. Hopefully this option will be used further in the future.
|
|
2615 *
|
|
2616 * - nenolod
|
|
2617 */
|
|
2618 gint
|
|
2619 prefswin_page_new(GtkWidget *container, gchar *name, gchar *imgurl)
|
|
2620 {
|
|
2621 GtkTreeModel *model;
|
|
2622 GtkTreeIter iter;
|
|
2623 GdkPixbuf *img = NULL;
|
|
2624 GtkTreeView *treeview = GTK_TREE_VIEW(category_treeview);
|
|
2625 gint id;
|
|
2626
|
|
2627 if (treeview == NULL || category_notebook == NULL)
|
|
2628 {
|
|
2629 prefswin_page_queue_new(container, name, imgurl);
|
|
2630 return -1;
|
|
2631 }
|
|
2632
|
|
2633 model = gtk_tree_view_get_model(treeview);
|
|
2634
|
|
2635 if (model == NULL)
|
|
2636 {
|
|
2637 prefswin_page_queue_new(container, name, imgurl);
|
|
2638 return -1;
|
|
2639 }
|
|
2640
|
|
2641 /* Make sure the widgets are visible. */
|
|
2642 gtk_widget_show(container);
|
|
2643 id = gtk_notebook_append_page(GTK_NOTEBOOK(category_notebook), container, NULL);
|
|
2644
|
|
2645 if (id == -1)
|
|
2646 return -1;
|
|
2647
|
|
2648 if (imgurl != NULL)
|
|
2649 img = gdk_pixbuf_new_from_file(imgurl, NULL);
|
|
2650
|
|
2651 gtk_list_store_append(GTK_LIST_STORE(model), &iter);
|
|
2652 gtk_list_store_set(GTK_LIST_STORE(model), &iter,
|
|
2653 CATEGORY_VIEW_COL_ICON, img,
|
|
2654 CATEGORY_VIEW_COL_NAME,
|
|
2655 name, CATEGORY_VIEW_COL_ID, id, -1);
|
|
2656
|
|
2657 if (img != NULL)
|
|
2658 g_object_unref(img);
|
|
2659
|
|
2660 return id;
|
|
2661 }
|
|
2662
|
|
2663 void
|
|
2664 prefswin_page_destroy(GtkWidget *container)
|
|
2665 {
|
|
2666 GtkTreeModel *model;
|
|
2667 GtkTreeIter iter;
|
|
2668 GtkTreeView *treeview = GTK_TREE_VIEW(category_treeview);
|
|
2669 gboolean ret;
|
|
2670 gint id;
|
|
2671 gint index = -1;
|
|
2672
|
|
2673 if (category_notebook == NULL || treeview == NULL || container == NULL)
|
|
2674 return;
|
|
2675
|
|
2676 id = gtk_notebook_page_num(GTK_NOTEBOOK(category_notebook), container);
|
|
2677
|
|
2678 if (id == -1)
|
|
2679 return;
|
|
2680
|
|
2681 gtk_notebook_remove_page(GTK_NOTEBOOK(category_notebook), id);
|
|
2682
|
|
2683 model = gtk_tree_view_get_model(treeview);
|
|
2684
|
|
2685 if (model == NULL)
|
|
2686 return;
|
|
2687
|
|
2688 ret = gtk_tree_model_get_iter_first(model, &iter);
|
|
2689
|
|
2690 while (ret == TRUE)
|
|
2691 {
|
|
2692 gtk_tree_model_get(model, &iter, CATEGORY_VIEW_COL_ID, &index, -1);
|
|
2693
|
|
2694 if (index == id)
|
|
2695 {
|
|
2696 gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
|
|
2697 ret = gtk_tree_model_get_iter_first(model, &iter);
|
|
2698 }
|
|
2699
|
|
2700 if (index > id)
|
|
2701 {
|
|
2702 index--;
|
|
2703 gtk_list_store_set(GTK_LIST_STORE(model), &iter, CATEGORY_VIEW_COL_ID, index, -1);
|
|
2704 }
|
|
2705
|
|
2706 ret = gtk_tree_model_iter_next(model, &iter);
|
|
2707 }
|
|
2708 }
|