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 * Based on XMMS:
|
|
8 * Copyright (C) 1998-2003 XMMS development team.
|
|
9 *
|
|
10 * This program is free software; you can redistribute it and/or modify
|
|
11 * it under the terms of the GNU General Public License as published by
|
|
12 * the Free Software Foundation; under version 2 of the License.
|
|
13 *
|
|
14 * This program is distributed in the hope that it will be useful,
|
|
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
17 * GNU General Public License for more details.
|
|
18 *
|
|
19 * You should have received a copy of the GNU General Public License
|
|
20 * along with this program; if not, write to the Free Software
|
|
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
22 */
|
|
23
|
|
24 #ifdef HAVE_CONFIG_H
|
|
25 # include "config.h"
|
|
26 #endif
|
|
27
|
|
28
|
|
29 #include <glib.h>
|
|
30 #include <glib/gi18n.h>
|
|
31 #include <glib/gprintf.h>
|
|
32 #include <gtk/gtk.h>
|
|
33 #include <gtk/gtkmessagedialog.h>
|
|
34
|
|
35 /* GDK including */
|
|
36 #include "platform/smartinclude.h"
|
|
37
|
|
38 #include <math.h>
|
|
39 #include <stdlib.h>
|
|
40 #include <string.h>
|
|
41
|
|
42 #include <X11/Xlib.h>
|
|
43
|
|
44 #include <sys/types.h>
|
|
45
|
|
46 #if defined(USE_REGEX_ONIGURUMA)
|
|
47 #include <onigposix.h>
|
|
48 #elif defined(USE_REGEX_PCRE)
|
|
49 #include <pcreposix.h>
|
|
50 #else
|
|
51 #include <regex.h>
|
|
52 #endif
|
|
53
|
|
54 #include "widgets/widgetcore.h"
|
|
55 #include "ui_main.h"
|
|
56 #include "icons-stock.h"
|
|
57
|
|
58 #include "ui_manager.h"
|
|
59 #include "actions-mainwin.h"
|
|
60
|
|
61 #include "main.h"
|
|
62
|
|
63 #include "controlsocket.h"
|
|
64 #include "pluginenum.h"
|
|
65
|
|
66 #include "ui_credits.h"
|
|
67 #include "dnd.h"
|
|
68 #include "dock.h"
|
|
69 #include "ui_equalizer.h"
|
|
70 #include "hints.h"
|
|
71 #include "input.h"
|
|
72 #include "ui_playlist.h"
|
|
73 #include "ui_preferences.h"
|
|
74 #include "ui_skinselector.h"
|
|
75 #include "genevent.h"
|
|
76 #include "playback.h"
|
|
77 #include "playlist.h"
|
|
78 #include "libaudacious/urldecode.h"
|
|
79 #include "util.h"
|
|
80 #include "visualization.h"
|
|
81 #include "libaudacious/configdb.h"
|
|
82
|
|
83 static GTimeVal cb_time; /* click delay for tristate is defined by TRISTATE_THRESHOLD */
|
|
84
|
|
85 #define ITEM_SEPARATOR {"/-", NULL, NULL, 0, "<Separator>"}
|
|
86 #define TRISTATE_THRESHOLD 200
|
|
87
|
|
88 #define VOLSET_DISP_TIMES 5
|
|
89
|
|
90 enum {
|
|
91 MAINWIN_SEEK_REV = -1,
|
|
92 MAINWIN_SEEK_NIL,
|
|
93 MAINWIN_SEEK_FWD
|
|
94 };
|
|
95
|
|
96 enum {
|
|
97 MAINWIN_VIS_ACTIVE_MAINWIN, MAINWIN_VIS_ACTIVE_PLAYLISTWIN
|
|
98 };
|
|
99
|
|
100
|
|
101 typedef struct _PlaybackInfo PlaybackInfo;
|
|
102
|
|
103 struct _PlaybackInfo {
|
|
104 gchar *title;
|
|
105 gint bitrate;
|
|
106 gint frequency;
|
|
107 gint n_channels;
|
|
108 };
|
|
109
|
|
110
|
|
111 GtkWidget *mainwin = NULL;
|
|
112 GtkWidget *err = NULL; /* an error dialog for miscellaneous error messages */
|
|
113
|
|
114 static GdkBitmap *nullmask;
|
|
115 static gint balance;
|
|
116
|
|
117 GtkWidget *mainwin_jtf = NULL;
|
|
118 static GtkWidget *mainwin_jtt = NULL;
|
|
119
|
|
120 gint seek_state = MAINWIN_SEEK_NIL;
|
|
121 gint seek_initial_pos = 0;
|
|
122
|
|
123 GdkGC *mainwin_gc;
|
|
124 static GdkPixmap *mainwin_bg = NULL, *mainwin_bg_x2 = NULL;
|
|
125
|
|
126 static PButton *mainwin_menubtn;
|
|
127 static PButton *mainwin_minimize, *mainwin_shade, *mainwin_close;
|
|
128
|
|
129 static PButton *mainwin_rew, *mainwin_fwd;
|
|
130 static PButton *mainwin_eject;
|
|
131 static PButton *mainwin_play, *mainwin_pause, *mainwin_stop;
|
|
132
|
|
133 TButton *mainwin_shuffle, *mainwin_repeat, *mainwin_eq, *mainwin_pl;
|
|
134 TextBox *mainwin_info;
|
|
135 TextBox *mainwin_stime_min, *mainwin_stime_sec;
|
|
136
|
|
137 static TextBox *mainwin_rate_text, *mainwin_freq_text,
|
|
138 *mainwin_othertext;
|
|
139
|
|
140 PlayStatus *mainwin_playstatus;
|
|
141
|
|
142 Number *mainwin_minus_num, *mainwin_10min_num, *mainwin_min_num;
|
|
143 Number *mainwin_10sec_num, *mainwin_sec_num;
|
|
144
|
|
145 static gboolean setting_volume = FALSE;
|
|
146
|
|
147 Vis *active_vis;
|
|
148 Vis *mainwin_vis;
|
|
149 SVis *mainwin_svis;
|
|
150
|
|
151 HSlider *mainwin_sposition = NULL;
|
|
152
|
|
153 static MenuRow *mainwin_menurow;
|
|
154 static HSlider *mainwin_volume, *mainwin_balance, *mainwin_position;
|
|
155 static MonoStereo *mainwin_monostereo;
|
|
156 static SButton *mainwin_srew, *mainwin_splay, *mainwin_spause;
|
|
157 static SButton *mainwin_sstop, *mainwin_sfwd, *mainwin_seject, *mainwin_about;
|
|
158
|
|
159 static GList *mainwin_wlist = NULL;
|
|
160
|
|
161 static gint mainwin_timeout_id;
|
|
162
|
|
163 G_LOCK_DEFINE_STATIC(mainwin_title);
|
|
164
|
|
165 static gboolean mainwin_force_redraw = FALSE;
|
|
166 static gchar *mainwin_title_text = NULL;
|
|
167 static gboolean mainwin_info_text_locked = FALSE;
|
|
168
|
|
169 static int ab_position_a = -1;
|
|
170 static int ab_position_b = -1;
|
|
171
|
|
172 static PlaybackInfo playback_info = { NULL, 0, 0, 0 };
|
|
173
|
|
174
|
|
175 static gint mainwin_idle_func(gpointer data);
|
|
176
|
|
177 static void set_timer_mode_menu_cb(TimerMode mode);
|
|
178 static void set_timer_mode(TimerMode mode);
|
|
179
|
|
180 static void mainwin_refresh_hints(void);
|
|
181
|
|
182 void mainwin_position_motion_cb(gint pos);
|
|
183 void mainwin_position_release_cb(gint pos);
|
|
184
|
|
185 void set_doublesize(gboolean doublesize);
|
|
186
|
|
187
|
|
188
|
|
189 /* FIXME: placed here for now */
|
|
190 void
|
|
191 playback_get_sample_params(gint * bitrate,
|
|
192 gint * frequency,
|
|
193 gint * n_channels)
|
|
194 {
|
|
195 if (bitrate)
|
|
196 *bitrate = playback_info.bitrate;
|
|
197
|
|
198 if (frequency)
|
|
199 *frequency = playback_info.frequency;
|
|
200
|
|
201 if (n_channels)
|
|
202 *n_channels = playback_info.n_channels;
|
|
203 }
|
|
204
|
|
205 static void
|
|
206 playback_set_sample_params(gint bitrate,
|
|
207 gint frequency,
|
|
208 gint n_channels)
|
|
209 {
|
|
210 if (bitrate >= 0)
|
|
211 playback_info.bitrate = bitrate;
|
|
212
|
|
213 if (frequency >= 0)
|
|
214 playback_info.frequency = frequency;
|
|
215
|
|
216 if (n_channels >= 0)
|
|
217 playback_info.n_channels = n_channels;
|
|
218 }
|
|
219
|
|
220 static void
|
|
221 mainwin_set_title_scroll(gboolean scroll)
|
|
222 {
|
|
223 cfg.autoscroll = scroll;
|
|
224 textbox_set_scroll(mainwin_info, cfg.autoscroll);
|
|
225 }
|
|
226
|
|
227
|
|
228 void
|
|
229 mainwin_set_always_on_top(gboolean always)
|
|
230 {
|
|
231 GtkAction *action = gtk_action_group_get_action(
|
|
232 toggleaction_group_others , "view always on top" );
|
|
233 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(action) , always );
|
|
234 }
|
|
235
|
|
236 static void
|
|
237 mainwin_set_shape_mask(void)
|
|
238 {
|
|
239 if (!cfg.player_visible)
|
|
240 return;
|
|
241
|
|
242 if (cfg.doublesize == FALSE)
|
|
243 gtk_widget_shape_combine_mask(mainwin,
|
|
244 skin_get_mask(bmp_active_skin,
|
|
245 SKIN_MASK_MAIN), 0, 0);
|
|
246 else
|
|
247 gtk_widget_shape_combine_mask(mainwin, NULL, 0, 0);
|
|
248 }
|
|
249
|
|
250 static void
|
|
251 mainwin_set_shade(gboolean shaded)
|
|
252 {
|
|
253 GtkAction *action = gtk_action_group_get_action(
|
|
254 toggleaction_group_others , "roll up player" );
|
|
255 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(action) , shaded );
|
|
256 }
|
|
257
|
|
258 static void
|
|
259 mainwin_set_shade_menu_cb(gboolean shaded)
|
|
260 {
|
|
261 cfg.player_shaded = shaded;
|
|
262
|
|
263 mainwin_set_shape_mask();
|
|
264
|
|
265 if (shaded) {
|
|
266 dock_shade(dock_window_list, GTK_WINDOW(mainwin),
|
|
267 MAINWIN_SHADED_HEIGHT * (cfg.doublesize + 1));
|
|
268
|
|
269 widget_show(WIDGET(mainwin_svis));
|
|
270 vis_clear_data(mainwin_vis);
|
|
271
|
|
272 widget_show(WIDGET(mainwin_srew));
|
|
273 widget_show(WIDGET(mainwin_splay));
|
|
274 widget_show(WIDGET(mainwin_spause));
|
|
275 widget_show(WIDGET(mainwin_sstop));
|
|
276 widget_show(WIDGET(mainwin_sfwd));
|
|
277 widget_show(WIDGET(mainwin_seject));
|
|
278
|
|
279 textbox_set_scroll(mainwin_info, FALSE);
|
|
280 if (playback_get_playing())
|
|
281 {
|
|
282 widget_show(WIDGET(mainwin_sposition));
|
|
283 widget_show(WIDGET(mainwin_stime_min));
|
|
284 widget_show(WIDGET(mainwin_stime_sec));
|
|
285 }
|
|
286 else
|
|
287 {
|
|
288 widget_hide(WIDGET(mainwin_sposition));
|
|
289 widget_hide(WIDGET(mainwin_stime_min));
|
|
290 widget_hide(WIDGET(mainwin_stime_sec));
|
|
291 }
|
|
292
|
|
293 mainwin_shade->pb_ny = mainwin_shade->pb_py = 27;
|
|
294 }
|
|
295 else {
|
|
296 gint height = !bmp_active_skin->properties.mainwin_height ? MAINWIN_HEIGHT :
|
|
297 bmp_active_skin->properties.mainwin_height;
|
|
298
|
|
299 dock_shade(dock_window_list, GTK_WINDOW(mainwin), height * (cfg.doublesize + 1));
|
|
300
|
|
301 widget_hide(WIDGET(mainwin_svis));
|
|
302 svis_clear_data(mainwin_svis);
|
|
303
|
|
304 widget_hide(WIDGET(mainwin_srew));
|
|
305 widget_hide(WIDGET(mainwin_splay));
|
|
306 widget_hide(WIDGET(mainwin_spause));
|
|
307 widget_hide(WIDGET(mainwin_sstop));
|
|
308 widget_hide(WIDGET(mainwin_sfwd));
|
|
309 widget_hide(WIDGET(mainwin_seject));
|
|
310
|
|
311 widget_hide(WIDGET(mainwin_stime_min));
|
|
312 widget_hide(WIDGET(mainwin_stime_sec));
|
|
313 widget_hide(WIDGET(mainwin_sposition));
|
|
314
|
|
315 textbox_set_scroll(mainwin_info, cfg.autoscroll);
|
|
316 mainwin_shade->pb_ny = mainwin_shade->pb_py = 18;
|
|
317 }
|
|
318
|
|
319 draw_main_window(TRUE);
|
|
320 }
|
|
321
|
|
322 static void
|
|
323 mainwin_vis_set_active_vis(gint new_vis)
|
|
324 {
|
|
325 active_vis = mainwin_vis;
|
|
326 }
|
|
327
|
|
328 static void
|
|
329 mainwin_vis_set_refresh(RefreshRate rate)
|
|
330 {
|
|
331 cfg.vis_refresh = rate;
|
|
332 }
|
|
333
|
|
334 static void
|
|
335 mainwin_vis_set_afalloff(FalloffSpeed speed)
|
|
336 {
|
|
337 cfg.analyzer_falloff = speed;
|
|
338 }
|
|
339
|
|
340 static void
|
|
341 mainwin_vis_set_pfalloff(FalloffSpeed speed)
|
|
342 {
|
|
343 cfg.peaks_falloff = speed;
|
|
344 }
|
|
345
|
|
346 static void
|
|
347 mainwin_vis_set_analyzer_mode(AnalyzerMode mode)
|
|
348 {
|
|
349 cfg.analyzer_mode = mode;
|
|
350 }
|
|
351
|
|
352 static void
|
|
353 mainwin_vis_set_analyzer_type(AnalyzerType mode)
|
|
354 {
|
|
355 cfg.analyzer_type = mode;
|
|
356 }
|
|
357
|
|
358 void
|
|
359 mainwin_vis_set_type(VisType mode)
|
|
360 {
|
|
361 GtkAction *action;
|
|
362
|
|
363 switch ( mode )
|
|
364 {
|
|
365 case VIS_ANALYZER:
|
|
366 action = gtk_action_group_get_action(
|
|
367 radioaction_group_vismode , "vismode analyzer" );
|
|
368 break;
|
|
369 case VIS_SCOPE:
|
|
370 action = gtk_action_group_get_action(
|
|
371 radioaction_group_vismode , "vismode scope" );
|
|
372 break;
|
|
373 case VIS_VOICEPRINT:
|
|
374 action = gtk_action_group_get_action(
|
|
375 radioaction_group_vismode , "vismode voiceprint" );
|
|
376 break;
|
|
377 case VIS_OFF:
|
|
378 default:
|
|
379 action = gtk_action_group_get_action(
|
|
380 radioaction_group_vismode , "vismode off" );
|
|
381 break;
|
|
382 }
|
|
383
|
|
384 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(action) , TRUE );
|
|
385 }
|
|
386
|
|
387 static void
|
|
388 mainwin_vis_set_type_menu_cb(VisType mode)
|
|
389 {
|
|
390 cfg.vis_type = mode;
|
|
391
|
|
392 if (mode == VIS_OFF) {
|
|
393 if (cfg.player_shaded && cfg.player_visible)
|
|
394 svis_clear(mainwin_svis);
|
|
395 else
|
|
396 vis_clear(active_vis);
|
|
397 }
|
|
398 if (mode == VIS_ANALYZER || mode == VIS_SCOPE || mode == VIS_VOICEPRINT) {
|
|
399 vis_clear_data(active_vis);
|
|
400 svis_clear_data(mainwin_svis);
|
|
401 }
|
|
402 }
|
|
403
|
|
404 static void
|
|
405 mainwin_menubtn_cb(void)
|
|
406 {
|
|
407 gint x, y;
|
|
408 gtk_window_get_position(GTK_WINDOW(mainwin), &x, &y);
|
|
409 ui_manager_popup_menu_show(GTK_MENU(mainwin_general_menu),
|
|
410 x + 6 * (1 + cfg.doublesize),
|
|
411 y + MAINWIN_SHADED_HEIGHT * (1 + cfg.doublesize),
|
|
412 1, GDK_CURRENT_TIME);
|
|
413 }
|
|
414
|
|
415 void
|
|
416 mainwin_minimize_cb(void)
|
|
417 {
|
|
418 if (!mainwin)
|
|
419 return;
|
|
420
|
|
421 gtk_window_iconify(GTK_WINDOW(mainwin));
|
|
422 }
|
|
423
|
|
424 static void
|
|
425 mainwin_shade_toggle(void)
|
|
426 {
|
|
427 mainwin_set_shade(!cfg.player_shaded);
|
|
428 }
|
|
429
|
|
430 void
|
|
431 mainwin_quit_cb(void)
|
|
432 {
|
|
433 GList *playlists = NULL, *playlists_top = NULL;
|
|
434
|
|
435 gtk_widget_hide(equalizerwin);
|
|
436 gtk_widget_hide(playlistwin);
|
|
437 gtk_widget_hide(mainwin);
|
|
438 gdk_flush();
|
|
439
|
|
440 g_source_remove(mainwin_timeout_id);
|
|
441
|
|
442 util_set_cursor(NULL);
|
|
443
|
|
444 bmp_config_save();
|
|
445 gtk_accel_map_save(bmp_paths[BMP_PATH_ACCEL_FILE]);
|
|
446
|
|
447 ctrlsocket_cleanup();
|
|
448
|
|
449 plugin_system_cleanup();
|
|
450
|
|
451 playlist_stop_get_info_thread();
|
|
452
|
|
453 /* free and clear each playlist */
|
|
454 playlists = playlist_get_playlists();
|
|
455 playlists_top = playlists;
|
|
456 while ( playlists != NULL )
|
|
457 {
|
|
458 playlist_clear((Playlist*)playlists->data);
|
|
459 playlist_free((Playlist*)playlists->data);
|
|
460 playlists = g_list_next(playlists);
|
|
461 }
|
|
462 g_list_free( playlists_top );
|
|
463
|
|
464 gtk_main_quit();
|
|
465
|
|
466 exit(EXIT_SUCCESS);
|
|
467 }
|
|
468
|
|
469 static void
|
|
470 mainwin_destroy(GtkWidget * widget, gpointer data)
|
|
471 {
|
|
472 mainwin_quit_cb();
|
|
473 }
|
|
474
|
|
475 static void
|
|
476 mainwin_draw_titlebar(gboolean focus)
|
|
477 {
|
|
478 skin_draw_mainwin_titlebar(bmp_active_skin, mainwin_bg, mainwin_gc,
|
|
479 cfg.player_shaded, focus || !cfg.dim_titlebar);
|
|
480 }
|
|
481
|
|
482 void
|
|
483 draw_main_window(gboolean force)
|
|
484 {
|
|
485 GdkImage *img, *img2x;
|
|
486 GList *wl;
|
|
487 Widget *w;
|
|
488 gboolean redraw;
|
|
489
|
|
490 if (!cfg.player_visible)
|
|
491 return;
|
|
492
|
|
493 if (force)
|
|
494 mainwin_refresh_hints();
|
|
495
|
|
496 widget_list_lock(mainwin_wlist);
|
|
497
|
|
498 if (force) {
|
|
499 if (!cfg.player_shaded)
|
|
500 skin_draw_pixmap(bmp_active_skin, mainwin_bg, mainwin_gc,
|
|
501 SKIN_MAIN, 0, 0, 0, 0, bmp_active_skin->properties.mainwin_width,
|
|
502 bmp_active_skin->properties.mainwin_height);
|
|
503 mainwin_draw_titlebar(gtk_window_has_toplevel_focus
|
|
504 (GTK_WINDOW(mainwin)));
|
|
505 }
|
|
506
|
|
507 widget_list_draw(mainwin_wlist, &redraw, force);
|
|
508
|
|
509 if (redraw || force) {
|
|
510 if (force) {
|
|
511 if (cfg.doublesize) {
|
|
512 img = gdk_drawable_get_image(mainwin_bg, 0, 0, bmp_active_skin->properties.mainwin_width,
|
|
513 cfg.player_shaded ?
|
|
514 MAINWIN_SHADED_HEIGHT :
|
|
515 bmp_active_skin->properties.mainwin_height);
|
|
516 img2x = create_dblsize_image(img);
|
|
517 gdk_draw_image(mainwin_bg_x2, mainwin_gc, img2x, 0, 0,
|
|
518 0, 0, bmp_active_skin->properties.mainwin_width * 2,
|
|
519 cfg.player_shaded ? MAINWIN_SHADED_HEIGHT *
|
|
520 2 : bmp_active_skin->properties.mainwin_height * 2);
|
|
521 g_object_unref(img2x);
|
|
522 g_object_unref(img);
|
|
523 }
|
|
524
|
|
525 gdk_window_clear(mainwin->window);
|
|
526
|
|
527 }
|
|
528 else {
|
|
529 for (wl = mainwin_wlist; wl; wl = g_list_next(wl)) {
|
|
530 w = WIDGET(wl->data);
|
|
531
|
|
532 if (!w->redraw || !w->visible)
|
|
533 continue;
|
|
534
|
|
535 if (w->x > bmp_active_skin->properties.mainwin_width ||
|
|
536 w->y > bmp_active_skin->properties.mainwin_height)
|
|
537 continue;
|
|
538
|
|
539 if (cfg.doublesize) {
|
|
540 gint width, height;
|
|
541
|
|
542 width = w->x + w->width <= bmp_active_skin->properties.mainwin_width ? w->width : (w->width - ((w->x + w->width) - bmp_active_skin->properties.mainwin_width));
|
|
543 height = w->y + w->height <= bmp_active_skin->properties.mainwin_width ? w->height : (w->height - ((w->y + w->height) - bmp_active_skin->properties.mainwin_height));
|
|
544
|
|
545 img = gdk_drawable_get_image(mainwin_bg, w->x, w->y,
|
|
546 width, height);
|
|
547 img2x = create_dblsize_image(img);
|
|
548 gdk_draw_image(mainwin_bg_x2, mainwin_gc,
|
|
549 img2x, 0, 0, w->x << 1, w->y << 1,
|
|
550 width << 1, height << 1);
|
|
551 g_object_unref(img2x);
|
|
552 g_object_unref(img);
|
|
553 gdk_window_clear_area(mainwin->window, w->x << 1,
|
|
554 w->y << 1, width << 1,
|
|
555 height << 1);
|
|
556 }
|
|
557 else
|
|
558 gdk_window_clear_area(mainwin->window, w->x, w->y,
|
|
559 w->width, w->height);
|
|
560 w->redraw = FALSE;
|
|
561 }
|
|
562 }
|
|
563
|
|
564 gdk_flush();
|
|
565 }
|
|
566
|
|
567 widget_list_unlock(mainwin_wlist);
|
|
568 }
|
|
569
|
|
570
|
|
571 void
|
|
572 mainwin_set_info_text(void)
|
|
573 {
|
|
574 gchar *text;
|
|
575
|
|
576 if (mainwin_info_text_locked)
|
|
577 return;
|
|
578
|
|
579 if ((text = input_get_info_text()) != NULL) {
|
|
580 textbox_set_text(mainwin_info, text);
|
|
581 g_free(text);
|
|
582 }
|
|
583 else if ((text = playlist_get_info_text(playlist_get_active())) != NULL) {
|
|
584 textbox_set_text(mainwin_info, text);
|
|
585 g_free(text);
|
|
586 }
|
|
587 }
|
|
588
|
|
589 static gchar *mainwin_tb_old_text = NULL;
|
|
590
|
|
591 void
|
|
592 mainwin_lock_info_text(const gchar * text)
|
|
593 {
|
|
594 if (mainwin_info_text_locked != TRUE)
|
|
595 mainwin_tb_old_text = g_strdup(bmp_active_skin->properties.mainwin_othertext_is_status ?
|
|
596 mainwin_othertext->tb_text : mainwin_info->tb_text);
|
|
597
|
|
598 mainwin_info_text_locked = TRUE;
|
|
599 textbox_set_text(bmp_active_skin->properties.mainwin_othertext_is_status ?
|
|
600 mainwin_othertext : mainwin_info, text);
|
|
601 }
|
|
602
|
|
603 void
|
|
604 mainwin_release_info_text(void)
|
|
605 {
|
|
606 mainwin_info_text_locked = FALSE;
|
|
607
|
|
608 if (mainwin_tb_old_text != NULL)
|
|
609 {
|
|
610 textbox_set_text(bmp_active_skin->properties.mainwin_othertext_is_status ?
|
|
611 mainwin_othertext : mainwin_info, mainwin_tb_old_text);
|
|
612 g_free(mainwin_tb_old_text);
|
|
613 mainwin_tb_old_text = NULL;
|
|
614 }
|
|
615 else
|
|
616 mainwin_set_info_text(); /* XXX: best we can do */
|
|
617 }
|
|
618
|
|
619
|
|
620 static gchar *
|
|
621 make_mainwin_title(const gchar * title)
|
|
622 {
|
|
623 if (title)
|
|
624 return g_strdup_printf(_("%s - Audacious"), title);
|
|
625 else
|
|
626 return g_strdup(_("Audacious"));
|
|
627 }
|
|
628
|
|
629 void
|
|
630 mainwin_set_song_title(const gchar * title)
|
|
631 {
|
|
632 G_LOCK(mainwin_title);
|
|
633 g_free(mainwin_title_text);
|
|
634 mainwin_title_text = make_mainwin_title(title);
|
|
635 G_UNLOCK(mainwin_title);
|
|
636 }
|
|
637
|
|
638 static void
|
|
639 mainwin_refresh_hints(void)
|
|
640 {
|
|
641 if (bmp_active_skin && bmp_active_skin->properties.mainwin_othertext
|
|
642 == TRUE)
|
|
643 {
|
|
644 widget_hide(WIDGET(mainwin_rate_text));
|
|
645 widget_hide(WIDGET(mainwin_freq_text));
|
|
646 widget_hide(WIDGET(mainwin_monostereo));
|
|
647
|
|
648 if (bmp_active_skin->properties.mainwin_othertext_visible)
|
|
649 widget_show(WIDGET(mainwin_othertext));
|
|
650 }
|
|
651 else
|
|
652 {
|
|
653 widget_show(WIDGET(mainwin_rate_text));
|
|
654 widget_show(WIDGET(mainwin_freq_text));
|
|
655 widget_show(WIDGET(mainwin_monostereo));
|
|
656 widget_hide(WIDGET(mainwin_othertext));
|
|
657 }
|
|
658
|
|
659 /* positioning and size attributes */
|
|
660 if (bmp_active_skin->properties.mainwin_vis_x && bmp_active_skin->properties.mainwin_vis_y)
|
|
661 widget_move(WIDGET(mainwin_vis), bmp_active_skin->properties.mainwin_vis_x,
|
|
662 bmp_active_skin->properties.mainwin_vis_y);
|
|
663
|
|
664 if (bmp_active_skin->properties.mainwin_vis_width)
|
|
665 widget_resize(WIDGET(mainwin_vis), bmp_active_skin->properties.mainwin_vis_width,
|
|
666 mainwin_vis->vs_widget.height);
|
|
667
|
|
668 if (bmp_active_skin->properties.mainwin_text_x && bmp_active_skin->properties.mainwin_text_y)
|
|
669 widget_move(WIDGET(mainwin_info), bmp_active_skin->properties.mainwin_text_x,
|
|
670 bmp_active_skin->properties.mainwin_text_y);
|
|
671
|
|
672 if (bmp_active_skin->properties.mainwin_text_width)
|
|
673 widget_resize(WIDGET(mainwin_info), bmp_active_skin->properties.mainwin_text_width,
|
|
674 mainwin_info->tb_widget.height);
|
|
675
|
|
676 if (bmp_active_skin->properties.mainwin_infobar_x && bmp_active_skin->properties.mainwin_infobar_y)
|
|
677 widget_move(WIDGET(mainwin_othertext), bmp_active_skin->properties.mainwin_infobar_x,
|
|
678 bmp_active_skin->properties.mainwin_infobar_y);
|
|
679
|
|
680 if (bmp_active_skin->properties.mainwin_number_0_x && bmp_active_skin->properties.mainwin_number_0_y)
|
|
681 widget_move(WIDGET(mainwin_minus_num), bmp_active_skin->properties.mainwin_number_0_x,
|
|
682 bmp_active_skin->properties.mainwin_number_0_y);
|
|
683
|
|
684 if (bmp_active_skin->properties.mainwin_number_1_x && bmp_active_skin->properties.mainwin_number_1_y)
|
|
685 widget_move(WIDGET(mainwin_10min_num), bmp_active_skin->properties.mainwin_number_1_x,
|
|
686 bmp_active_skin->properties.mainwin_number_1_y);
|
|
687
|
|
688 if (bmp_active_skin->properties.mainwin_number_2_x && bmp_active_skin->properties.mainwin_number_2_y)
|
|
689 widget_move(WIDGET(mainwin_min_num), bmp_active_skin->properties.mainwin_number_2_x,
|
|
690 bmp_active_skin->properties.mainwin_number_2_y);
|
|
691
|
|
692 if (bmp_active_skin->properties.mainwin_number_3_x && bmp_active_skin->properties.mainwin_number_3_y)
|
|
693 widget_move(WIDGET(mainwin_10sec_num), bmp_active_skin->properties.mainwin_number_3_x,
|
|
694 bmp_active_skin->properties.mainwin_number_3_y);
|
|
695
|
|
696 if (bmp_active_skin->properties.mainwin_number_4_x && bmp_active_skin->properties.mainwin_number_4_y)
|
|
697 widget_move(WIDGET(mainwin_sec_num), bmp_active_skin->properties.mainwin_number_4_x,
|
|
698 bmp_active_skin->properties.mainwin_number_4_y);
|
|
699
|
|
700 if (bmp_active_skin->properties.mainwin_playstatus_x && bmp_active_skin->properties.mainwin_playstatus_y)
|
|
701 widget_move(WIDGET(mainwin_playstatus), bmp_active_skin->properties.mainwin_playstatus_x,
|
|
702 bmp_active_skin->properties.mainwin_playstatus_y);
|
|
703
|
|
704 if (bmp_active_skin->properties.mainwin_volume_x && bmp_active_skin->properties.mainwin_volume_y)
|
|
705 widget_move(WIDGET(mainwin_volume), bmp_active_skin->properties.mainwin_volume_x,
|
|
706 bmp_active_skin->properties.mainwin_volume_y);
|
|
707
|
|
708 if (bmp_active_skin->properties.mainwin_balance_x && bmp_active_skin->properties.mainwin_balance_y)
|
|
709 widget_move(WIDGET(mainwin_balance), bmp_active_skin->properties.mainwin_balance_x,
|
|
710 bmp_active_skin->properties.mainwin_balance_y);
|
|
711
|
|
712 if (bmp_active_skin->properties.mainwin_position_x && bmp_active_skin->properties.mainwin_position_y)
|
|
713 widget_move(WIDGET(mainwin_position), bmp_active_skin->properties.mainwin_position_x,
|
|
714 bmp_active_skin->properties.mainwin_position_y);
|
|
715
|
|
716 if (bmp_active_skin->properties.mainwin_previous_x && bmp_active_skin->properties.mainwin_previous_y)
|
|
717 widget_move(WIDGET(mainwin_rew), bmp_active_skin->properties.mainwin_previous_x,
|
|
718 bmp_active_skin->properties.mainwin_previous_y);
|
|
719
|
|
720 if (bmp_active_skin->properties.mainwin_play_x && bmp_active_skin->properties.mainwin_play_y)
|
|
721 widget_move(WIDGET(mainwin_play), bmp_active_skin->properties.mainwin_play_x,
|
|
722 bmp_active_skin->properties.mainwin_play_y);
|
|
723
|
|
724 if (bmp_active_skin->properties.mainwin_pause_x && bmp_active_skin->properties.mainwin_pause_y)
|
|
725 widget_move(WIDGET(mainwin_pause), bmp_active_skin->properties.mainwin_pause_x,
|
|
726 bmp_active_skin->properties.mainwin_pause_y);
|
|
727
|
|
728 if (bmp_active_skin->properties.mainwin_stop_x && bmp_active_skin->properties.mainwin_stop_y)
|
|
729 widget_move(WIDGET(mainwin_stop), bmp_active_skin->properties.mainwin_stop_x,
|
|
730 bmp_active_skin->properties.mainwin_stop_y);
|
|
731
|
|
732 if (bmp_active_skin->properties.mainwin_next_x && bmp_active_skin->properties.mainwin_next_y)
|
|
733 widget_move(WIDGET(mainwin_fwd), bmp_active_skin->properties.mainwin_next_x,
|
|
734 bmp_active_skin->properties.mainwin_next_y);
|
|
735
|
|
736 if (bmp_active_skin->properties.mainwin_eject_x && bmp_active_skin->properties.mainwin_eject_y)
|
|
737 widget_move(WIDGET(mainwin_eject), bmp_active_skin->properties.mainwin_eject_x,
|
|
738 bmp_active_skin->properties.mainwin_eject_y);
|
|
739
|
|
740 if (bmp_active_skin->properties.mainwin_eqbutton_x && bmp_active_skin->properties.mainwin_eqbutton_y)
|
|
741 widget_move(WIDGET(mainwin_eq), bmp_active_skin->properties.mainwin_eqbutton_x,
|
|
742 bmp_active_skin->properties.mainwin_eqbutton_y);
|
|
743
|
|
744 if (bmp_active_skin->properties.mainwin_plbutton_x && bmp_active_skin->properties.mainwin_plbutton_y)
|
|
745 widget_move(WIDGET(mainwin_pl), bmp_active_skin->properties.mainwin_plbutton_x,
|
|
746 bmp_active_skin->properties.mainwin_plbutton_y);
|
|
747
|
|
748 if (bmp_active_skin->properties.mainwin_shuffle_x && bmp_active_skin->properties.mainwin_shuffle_y)
|
|
749 widget_move(WIDGET(mainwin_shuffle), bmp_active_skin->properties.mainwin_shuffle_x,
|
|
750 bmp_active_skin->properties.mainwin_shuffle_y);
|
|
751
|
|
752 if (bmp_active_skin->properties.mainwin_repeat_x && bmp_active_skin->properties.mainwin_repeat_y)
|
|
753 widget_move(WIDGET(mainwin_repeat), bmp_active_skin->properties.mainwin_repeat_x,
|
|
754 bmp_active_skin->properties.mainwin_repeat_y);
|
|
755
|
|
756 if (bmp_active_skin->properties.mainwin_about_x && bmp_active_skin->properties.mainwin_about_y)
|
|
757 widget_move(WIDGET(mainwin_about), bmp_active_skin->properties.mainwin_about_x,
|
|
758 bmp_active_skin->properties.mainwin_about_y);
|
|
759
|
|
760 if (bmp_active_skin->properties.mainwin_minimize_x && bmp_active_skin->properties.mainwin_minimize_y)
|
|
761 widget_move(WIDGET(mainwin_minimize), cfg.player_shaded ? 244 : bmp_active_skin->properties.mainwin_minimize_x,
|
|
762 cfg.player_shaded ? 3 : bmp_active_skin->properties.mainwin_minimize_y);
|
|
763
|
|
764 if (bmp_active_skin->properties.mainwin_shade_x && bmp_active_skin->properties.mainwin_shade_y)
|
|
765 widget_move(WIDGET(mainwin_shade), cfg.player_shaded ? 254 : bmp_active_skin->properties.mainwin_shade_x,
|
|
766 cfg.player_shaded ? 3 : bmp_active_skin->properties.mainwin_shade_y);
|
|
767
|
|
768 if (bmp_active_skin->properties.mainwin_close_x && bmp_active_skin->properties.mainwin_close_y)
|
|
769 widget_move(WIDGET(mainwin_close), cfg.player_shaded ? 264 : bmp_active_skin->properties.mainwin_close_x,
|
|
770 cfg.player_shaded ? 3 : bmp_active_skin->properties.mainwin_close_y);
|
|
771
|
|
772 /* visibility attributes */
|
|
773 if (bmp_active_skin->properties.mainwin_menurow_visible)
|
|
774 widget_show(WIDGET(mainwin_menurow));
|
|
775 else
|
|
776 widget_hide(WIDGET(mainwin_menurow));
|
|
777
|
|
778 if (bmp_active_skin->properties.mainwin_text_visible)
|
|
779 widget_show(WIDGET(mainwin_info));
|
|
780 else
|
|
781 widget_hide(WIDGET(mainwin_info));
|
|
782
|
|
783 if (bmp_active_skin->properties.mainwin_othertext_visible)
|
|
784 widget_show(WIDGET(mainwin_othertext));
|
|
785 else
|
|
786 widget_hide(WIDGET(mainwin_othertext));
|
|
787
|
|
788 if (bmp_active_skin->properties.mainwin_vis_visible)
|
|
789 widget_show(WIDGET(mainwin_vis));
|
|
790 else
|
|
791 widget_hide(WIDGET(mainwin_vis));
|
|
792
|
|
793 /* window size, mainwinWidth && mainwinHeight properties */
|
|
794 if (bmp_active_skin->properties.mainwin_height && bmp_active_skin->properties.mainwin_width)
|
|
795 {
|
|
796 gint width, height;
|
|
797
|
|
798 gdk_window_get_size(mainwin->window, &width, &height);
|
|
799
|
|
800 if (width == bmp_active_skin->properties.mainwin_width * (cfg.doublesize + 1) &&
|
|
801 height == bmp_active_skin->properties.mainwin_height * (cfg.doublesize + 1))
|
|
802 return;
|
|
803
|
|
804 dock_window_resize(GTK_WINDOW(mainwin), cfg.player_shaded ? MAINWIN_SHADED_WIDTH * (cfg.doublesize + 1) : bmp_active_skin->properties.mainwin_width * (cfg.doublesize + 1),
|
|
805 cfg.player_shaded ? MAINWIN_SHADED_HEIGHT * (cfg.doublesize + 1) : bmp_active_skin->properties.mainwin_height * (cfg.doublesize + 1),
|
|
806 bmp_active_skin->properties.mainwin_width * (cfg.doublesize + 1),
|
|
807 bmp_active_skin->properties.mainwin_height * (cfg.doublesize + 1));
|
|
808
|
|
809 g_object_unref(mainwin_bg);
|
|
810 g_object_unref(mainwin_bg_x2);
|
|
811 mainwin_bg = gdk_pixmap_new(mainwin->window,
|
|
812 bmp_active_skin->properties.mainwin_width,
|
|
813 bmp_active_skin->properties.mainwin_height, -1);
|
|
814 mainwin_bg_x2 = gdk_pixmap_new(mainwin->window,
|
|
815 bmp_active_skin->properties.mainwin_width * 2,
|
|
816 bmp_active_skin->properties.mainwin_height * 2, -1);
|
|
817 mainwin_set_back_pixmap();
|
|
818 widget_list_change_pixmap(mainwin_wlist, mainwin_bg);
|
|
819 gdk_flush();
|
|
820 }
|
|
821 }
|
|
822
|
|
823 void
|
|
824 mainwin_set_song_info(gint bitrate,
|
|
825 gint frequency,
|
|
826 gint n_channels)
|
|
827 {
|
|
828 gchar text[512];
|
|
829 gchar *title;
|
|
830 Playlist *playlist = playlist_get_active();
|
|
831
|
|
832 playback_set_sample_params(bitrate, frequency, n_channels);
|
|
833
|
|
834 if (bitrate != -1) {
|
|
835 bitrate /= 1000;
|
|
836
|
|
837 if (bitrate < 1000) {
|
|
838 /* Show bitrate in 1000s */
|
|
839 g_snprintf(text, sizeof(text), "%3d", bitrate);
|
|
840 textbox_set_text(mainwin_rate_text, text);
|
|
841 }
|
|
842 else {
|
|
843 /* Show bitrate in 100,000s */
|
|
844 g_snprintf(text, sizeof(text), "%2dH", bitrate / 100);
|
|
845 textbox_set_text(mainwin_rate_text, text);
|
|
846 }
|
|
847 }
|
|
848 else
|
|
849 textbox_set_text(mainwin_rate_text, _("VBR"));
|
|
850
|
|
851 /* Show sampling frequency in kHz */
|
|
852 g_snprintf(text, sizeof(text), "%2d", frequency / 1000);
|
|
853 textbox_set_text(mainwin_freq_text, text);
|
|
854
|
|
855 monostereo_set_num_channels(mainwin_monostereo, n_channels);
|
|
856
|
|
857 if (cfg.player_shaded)
|
|
858 {
|
|
859 widget_show(WIDGET(mainwin_stime_min));
|
|
860 widget_show(WIDGET(mainwin_stime_sec));
|
|
861 }
|
|
862
|
|
863 widget_show(WIDGET(mainwin_minus_num));
|
|
864 widget_show(WIDGET(mainwin_10min_num));
|
|
865 widget_show(WIDGET(mainwin_min_num));
|
|
866 widget_show(WIDGET(mainwin_10sec_num));
|
|
867 widget_show(WIDGET(mainwin_sec_num));
|
|
868
|
|
869 if (!playback_get_paused() && mainwin_playstatus != NULL)
|
|
870 playstatus_set_status(mainwin_playstatus, STATUS_PLAY);
|
|
871
|
|
872 if (playlist_get_current_length(playlist) != -1) {
|
|
873 if (cfg.player_shaded)
|
|
874 widget_show(WIDGET(mainwin_sposition));
|
|
875 widget_show(WIDGET(mainwin_position));
|
|
876 }
|
|
877 else {
|
|
878 widget_hide(WIDGET(mainwin_position));
|
|
879 widget_hide(WIDGET(mainwin_sposition));
|
|
880 mainwin_force_redraw = TRUE;
|
|
881 }
|
|
882
|
|
883 if (bmp_active_skin && bmp_active_skin->properties.mainwin_othertext
|
|
884 == TRUE)
|
|
885 {
|
|
886 if (bitrate != -1)
|
|
887 g_snprintf(text, 512, "%d kbps, %0.1f kHz, %s",
|
|
888 bitrate,
|
|
889 (gfloat) frequency / 1000,
|
|
890 (n_channels > 1) ? _("stereo") : _("mono"));
|
|
891 else
|
|
892 g_snprintf(text, 512, "VBR, %0.1f kHz, %s",
|
|
893 (gfloat) frequency / 1000,
|
|
894 (n_channels > 1) ? _("stereo") : _("mono"));
|
|
895
|
|
896 textbox_set_text(mainwin_othertext, text);
|
|
897
|
|
898 widget_hide(WIDGET(mainwin_rate_text));
|
|
899 widget_hide(WIDGET(mainwin_freq_text));
|
|
900 widget_hide(WIDGET(mainwin_monostereo));
|
|
901
|
|
902 if (bmp_active_skin->properties.mainwin_othertext_visible)
|
|
903 widget_show(WIDGET(mainwin_othertext));
|
|
904 }
|
|
905 else
|
|
906 {
|
|
907 widget_show(WIDGET(mainwin_rate_text));
|
|
908 widget_show(WIDGET(mainwin_freq_text));
|
|
909 widget_show(WIDGET(mainwin_monostereo));
|
|
910 widget_hide(WIDGET(mainwin_othertext));
|
|
911 }
|
|
912
|
|
913 title = playlist_get_info_text(playlist);
|
|
914 mainwin_set_song_title(title);
|
|
915 g_free(title);
|
|
916 }
|
|
917
|
|
918 void
|
|
919 mainwin_clear_song_info(void)
|
|
920 {
|
|
921 if (!mainwin)
|
|
922 return;
|
|
923
|
|
924 /* clear title */
|
|
925 G_LOCK(mainwin_title);
|
|
926 g_free(mainwin_title_text);
|
|
927 mainwin_title_text = NULL;
|
|
928 G_UNLOCK(mainwin_title);
|
|
929
|
|
930 /* clear sampling parameters */
|
|
931 playback_set_sample_params(0, 0, 0);
|
|
932
|
|
933 mainwin_position->hs_pressed = FALSE;
|
|
934 mainwin_sposition->hs_pressed = FALSE;
|
|
935
|
|
936 /* clear sampling parameter displays */
|
|
937 textbox_set_text(mainwin_rate_text, " ");
|
|
938 textbox_set_text(mainwin_freq_text, " ");
|
|
939 monostereo_set_num_channels(mainwin_monostereo, 0);
|
|
940
|
|
941 if (mainwin_playstatus != NULL)
|
|
942 playstatus_set_status(mainwin_playstatus, STATUS_STOP);
|
|
943
|
|
944 /* hide playback time */
|
|
945 widget_hide(WIDGET(mainwin_minus_num));
|
|
946 widget_hide(WIDGET(mainwin_10min_num));
|
|
947 widget_hide(WIDGET(mainwin_min_num));
|
|
948 widget_hide(WIDGET(mainwin_10sec_num));
|
|
949 widget_hide(WIDGET(mainwin_sec_num));
|
|
950
|
|
951 widget_hide(WIDGET(mainwin_stime_min));
|
|
952 widget_hide(WIDGET(mainwin_stime_sec));
|
|
953
|
|
954 widget_hide(WIDGET(mainwin_position));
|
|
955 widget_hide(WIDGET(mainwin_sposition));
|
|
956
|
|
957 widget_hide(WIDGET(mainwin_othertext));
|
|
958
|
|
959 playlistwin_hide_timer();
|
|
960 draw_main_window(TRUE);
|
|
961
|
|
962 vis_clear(active_vis);
|
|
963 }
|
|
964
|
|
965 void
|
|
966 mainwin_disable_seekbar(void)
|
|
967 {
|
|
968 if (!mainwin)
|
|
969 return;
|
|
970
|
|
971 /*
|
|
972 * We dont call draw_main_window() here so this will not
|
|
973 * remove them visually. It will only prevent us from sending
|
|
974 * any seek calls to the input plugin before the input plugin
|
|
975 * calls ->set_info().
|
|
976 */
|
|
977 widget_hide(WIDGET(mainwin_position));
|
|
978 widget_hide(WIDGET(mainwin_sposition));
|
|
979 }
|
|
980
|
|
981 static gboolean
|
|
982 mainwin_mouse_button_release(GtkWidget * widget,
|
|
983 GdkEventButton * event,
|
|
984 gpointer callback_data)
|
|
985 {
|
|
986 gdk_pointer_ungrab(GDK_CURRENT_TIME);
|
|
987
|
|
988 /*
|
|
989 * The gdk_flush() is just for making sure that the pointer really
|
|
990 * gets ungrabbed before calling any button callbacks
|
|
991 *
|
|
992 */
|
|
993
|
|
994 gdk_flush();
|
|
995
|
|
996 if (dock_is_moving(GTK_WINDOW(mainwin))) {
|
|
997 dock_move_release(GTK_WINDOW(mainwin));
|
|
998 draw_playlist_window(TRUE);
|
|
999 }
|
|
1000
|
|
1001 if (mainwin_menurow->mr_doublesize_selected) {
|
|
1002 event->x /= 2;
|
|
1003 event->y /= 2;
|
|
1004 }
|
|
1005
|
|
1006 handle_release_cb(mainwin_wlist, widget, event);
|
|
1007
|
|
1008 draw_main_window(FALSE);
|
|
1009
|
|
1010 return FALSE;
|
|
1011 }
|
|
1012
|
|
1013 static gboolean
|
|
1014 mainwin_motion(GtkWidget * widget,
|
|
1015 GdkEventMotion * event,
|
|
1016 gpointer callback_data)
|
|
1017 {
|
|
1018 int x, y;
|
|
1019 GdkModifierType state;
|
|
1020
|
|
1021 if (event->is_hint != FALSE)
|
|
1022 {
|
|
1023 gdk_window_get_pointer(GDK_WINDOW(mainwin->window),
|
|
1024 &x, &y, &state);
|
|
1025
|
|
1026 /* If it's a hint, we had to query X, so override the
|
|
1027 * information we we're given... it's probably useless... --nenolod
|
|
1028 */
|
|
1029 event->x = x;
|
|
1030 event->y = y;
|
|
1031 event->state = state;
|
|
1032 }
|
|
1033 else
|
|
1034 {
|
|
1035 x = event->x;
|
|
1036 y = event->y;
|
|
1037 state = event->state;
|
|
1038 }
|
|
1039 if (cfg.doublesize) {
|
|
1040 event->x /= 2;
|
|
1041 event->y /= 2;
|
|
1042 }
|
|
1043 if (dock_is_moving(GTK_WINDOW(mainwin))) {
|
|
1044 dock_move_motion(GTK_WINDOW(mainwin), event);
|
|
1045 }
|
|
1046 else {
|
|
1047 handle_motion_cb(mainwin_wlist, widget, event);
|
|
1048 draw_main_window(FALSE);
|
|
1049 }
|
|
1050
|
|
1051 gdk_flush();
|
|
1052
|
|
1053 return FALSE;
|
|
1054 }
|
|
1055
|
|
1056 static gboolean
|
|
1057 inside_sensitive_widgets(gint x, gint y)
|
|
1058 {
|
|
1059 return (widget_contains(WIDGET(mainwin_menubtn), x, y)
|
|
1060 || widget_contains(WIDGET(mainwin_minimize), x, y)
|
|
1061 || widget_contains(WIDGET(mainwin_shade), x, y)
|
|
1062 || widget_contains(WIDGET(mainwin_close), x, y)
|
|
1063 || widget_contains(WIDGET(mainwin_rew), x, y)
|
|
1064 || widget_contains(WIDGET(mainwin_play), x, y)
|
|
1065 || widget_contains(WIDGET(mainwin_pause), x, y)
|
|
1066 || widget_contains(WIDGET(mainwin_stop), x, y)
|
|
1067 || widget_contains(WIDGET(mainwin_fwd), x, y)
|
|
1068 || widget_contains(WIDGET(mainwin_eject), x, y)
|
|
1069 || widget_contains(WIDGET(mainwin_shuffle), x, y)
|
|
1070 || widget_contains(WIDGET(mainwin_repeat), x, y)
|
|
1071 || widget_contains(WIDGET(mainwin_pl), x, y)
|
|
1072 || widget_contains(WIDGET(mainwin_eq), x, y)
|
|
1073 || widget_contains(WIDGET(mainwin_info), x, y)
|
|
1074 || widget_contains(WIDGET(mainwin_menurow), x, y)
|
|
1075 || widget_contains(WIDGET(mainwin_volume), x, y)
|
|
1076 || widget_contains(WIDGET(mainwin_balance), x, y)
|
|
1077 || (widget_contains(WIDGET(mainwin_position), x, y) &&
|
|
1078 widget_is_visible(WIDGET(mainwin_position)))
|
|
1079 || widget_contains(WIDGET(mainwin_minus_num), x, y)
|
|
1080 || widget_contains(WIDGET(mainwin_10min_num), x, y)
|
|
1081 || widget_contains(WIDGET(mainwin_min_num), x, y)
|
|
1082 || widget_contains(WIDGET(mainwin_10sec_num), x, y)
|
|
1083 || widget_contains(WIDGET(mainwin_sec_num), x, y)
|
|
1084 || widget_contains(WIDGET(mainwin_vis), x, y)
|
|
1085 || widget_contains(WIDGET(mainwin_minimize), x, y)
|
|
1086 || widget_contains(WIDGET(mainwin_shade), x, y)
|
|
1087 || widget_contains(WIDGET(mainwin_close), x, y)
|
|
1088 || widget_contains(WIDGET(mainwin_menubtn), x, y)
|
|
1089 || widget_contains(WIDGET(mainwin_sposition), x, y)
|
|
1090 || widget_contains(WIDGET(mainwin_stime_min), x, y)
|
|
1091 || widget_contains(WIDGET(mainwin_stime_sec), x, y)
|
|
1092 || widget_contains(WIDGET(mainwin_srew), x, y)
|
|
1093 || widget_contains(WIDGET(mainwin_splay), x, y)
|
|
1094 || widget_contains(WIDGET(mainwin_spause), x, y)
|
|
1095 || widget_contains(WIDGET(mainwin_sstop), x, y)
|
|
1096 || widget_contains(WIDGET(mainwin_sfwd), x, y)
|
|
1097 || widget_contains(WIDGET(mainwin_seject), x, y)
|
|
1098 || widget_contains(WIDGET(mainwin_svis), x, y)
|
|
1099 || widget_contains(WIDGET(mainwin_about), x, y));
|
|
1100 }
|
|
1101
|
|
1102 void
|
|
1103 mainwin_scrolled(GtkWidget *widget, GdkEventScroll *event,
|
|
1104 gpointer callback_data)
|
|
1105 {
|
|
1106 Playlist *playlist = playlist_get_active();
|
|
1107
|
|
1108 switch (event->direction) {
|
|
1109 case GDK_SCROLL_UP:
|
|
1110 mainwin_set_volume_diff(cfg.mouse_change);
|
|
1111 break;
|
|
1112 case GDK_SCROLL_DOWN:
|
|
1113 mainwin_set_volume_diff(-cfg.mouse_change);
|
|
1114 break;
|
|
1115 case GDK_SCROLL_LEFT:
|
|
1116 if (playlist_get_current_length(playlist) != -1)
|
|
1117 playback_seek(CLAMP(playback_get_time() - 1000,
|
|
1118 0, playlist_get_current_length(playlist)) / 1000);
|
|
1119 break;
|
|
1120 case GDK_SCROLL_RIGHT:
|
|
1121 if (playlist_get_current_length(playlist) != -1)
|
|
1122 playback_seek(CLAMP(playback_get_time() + 1000,
|
|
1123 0, playlist_get_current_length(playlist)) / 1000);
|
|
1124 break;
|
|
1125 }
|
|
1126 }
|
|
1127
|
|
1128 static gboolean
|
|
1129 mainwin_mouse_button_press(GtkWidget * widget,
|
|
1130 GdkEventButton * event,
|
|
1131 gpointer callback_data)
|
|
1132 {
|
|
1133
|
|
1134 gboolean grab = TRUE;
|
|
1135
|
|
1136 if (cfg.doublesize) {
|
|
1137 /*
|
|
1138 * A hack to make doublesize transparent to callbacks.
|
|
1139 * We should make a copy of this data instead of
|
|
1140 * tampering with the data we get from gtk+
|
|
1141 */
|
|
1142 event->x /= 2;
|
|
1143 event->y /= 2;
|
|
1144 }
|
|
1145
|
|
1146 if (event->button == 1 && event->type == GDK_BUTTON_PRESS &&
|
|
1147 !inside_sensitive_widgets(event->x, event->y) &&
|
|
1148 (cfg.easy_move || event->y < 14)) {
|
|
1149 if (0 && hint_move_resize_available()) {
|
|
1150 hint_move_resize(mainwin, event->x_root, event->y_root, TRUE);
|
|
1151 grab = FALSE;
|
|
1152 }
|
|
1153 else {
|
|
1154 gtk_window_present(GTK_WINDOW(mainwin));
|
|
1155 dock_move_press(dock_window_list, GTK_WINDOW(mainwin), event,
|
|
1156 TRUE);
|
|
1157 }
|
|
1158 }
|
|
1159 else if (event->button == 1 && event->type == GDK_2BUTTON_PRESS &&
|
|
1160 event->y < 14 && !inside_sensitive_widgets(event->x, event->y)) {
|
|
1161 mainwin_set_shade(!cfg.player_shaded);
|
|
1162 if (dock_is_moving(GTK_WINDOW(mainwin)))
|
|
1163 dock_move_release(GTK_WINDOW(mainwin));
|
|
1164 }
|
|
1165 else if (event->button == 1 && event->type == GDK_2BUTTON_PRESS &&
|
|
1166 widget_contains(WIDGET(mainwin_info), event->x, event->y)) {
|
|
1167 playlist_fileinfo_current(playlist_get_active());
|
|
1168 }
|
|
1169 else {
|
|
1170 handle_press_cb(mainwin_wlist, widget, event);
|
|
1171 draw_main_window(FALSE);
|
|
1172 }
|
|
1173
|
|
1174 if ((event->button == 1) && event->type != GDK_2BUTTON_PRESS &&
|
|
1175 (widget_contains(WIDGET(mainwin_vis), event->x, event->y) ||
|
|
1176 widget_contains(WIDGET(mainwin_svis), event->x, event->y))) {
|
|
1177
|
|
1178 cfg.vis_type++;
|
|
1179
|
|
1180 if (cfg.vis_type > VIS_OFF)
|
|
1181 cfg.vis_type = VIS_ANALYZER;
|
|
1182
|
|
1183 mainwin_vis_set_type(cfg.vis_type);
|
|
1184 }
|
|
1185
|
|
1186 if (event->button == 3) {
|
|
1187 if (widget_contains(WIDGET(mainwin_info), event->x, event->y)) {
|
|
1188 ui_manager_popup_menu_show(GTK_MENU(mainwin_songname_menu),
|
|
1189 event->x_root, event->y_root,
|
|
1190 3, event->time);
|
|
1191 grab = FALSE;
|
|
1192 }
|
|
1193 else if (widget_contains(WIDGET(mainwin_vis), event->x, event->y) ||
|
|
1194 widget_contains(WIDGET(mainwin_svis), event->x, event->y)) {
|
|
1195 ui_manager_popup_menu_show(GTK_MENU(mainwin_visualization_menu), event->x_root,
|
|
1196 event->y_root, 3, event->time);
|
|
1197 grab = FALSE;
|
|
1198 }
|
|
1199 else if ( (event->y > 70) && (event->x < 128) )
|
|
1200 {
|
|
1201
|
|
1202 ui_manager_popup_menu_show(GTK_MENU(mainwin_playback_menu),
|
|
1203 event->x_root,
|
|
1204 event->y_root, 3, event->time);
|
|
1205 grab = FALSE;
|
|
1206 } else {
|
|
1207 /*
|
|
1208 * Pop up the main menu a few pixels down.
|
|
1209 * This will avoid that anything is selected
|
|
1210 * if one right-clicks to focus the window
|
|
1211 * without raising it.
|
|
1212 *
|
|
1213 ***MD I think the above is stupid, people don't expect this
|
|
1214 *
|
|
1215 */
|
|
1216 ui_manager_popup_menu_show(GTK_MENU(mainwin_general_menu),
|
|
1217 event->x_root,
|
|
1218 event->y_root, 3, event->time);
|
|
1219 grab = FALSE;
|
|
1220 }
|
|
1221 }
|
|
1222
|
|
1223 if (event->button == 1)
|
|
1224 {
|
|
1225 if (widget_contains(WIDGET(mainwin_minus_num), event->x, event->y) ||
|
|
1226 widget_contains(WIDGET(mainwin_10min_num), event->x, event->y) ||
|
|
1227 widget_contains(WIDGET(mainwin_min_num), event->x, event->y) ||
|
|
1228 widget_contains(WIDGET(mainwin_10sec_num), event->x, event->y) ||
|
|
1229 widget_contains(WIDGET(mainwin_sec_num), event->x, event->y) ||
|
|
1230 widget_contains(WIDGET(mainwin_stime_min), event->x, event->y) ||
|
|
1231 widget_contains(WIDGET(mainwin_stime_sec), event->x, event->y))
|
|
1232 {
|
|
1233 if (cfg.timer_mode == TIMER_ELAPSED)
|
|
1234 set_timer_mode(TIMER_REMAINING);
|
|
1235 else
|
|
1236 set_timer_mode(TIMER_ELAPSED);
|
|
1237 }
|
|
1238 }
|
|
1239
|
|
1240 if (grab)
|
|
1241 gdk_pointer_grab(mainwin->window, FALSE,
|
|
1242 GDK_BUTTON_MOTION_MASK |
|
|
1243 GDK_BUTTON_RELEASE_MASK,
|
|
1244 GDK_WINDOW(GDK_NONE), NULL, GDK_CURRENT_TIME);
|
|
1245
|
|
1246 return FALSE;
|
|
1247 }
|
|
1248
|
|
1249 static gboolean
|
|
1250 mainwin_focus_in(GtkWidget * window,
|
|
1251 GdkEventFocus * event,
|
|
1252 gpointer data)
|
|
1253 {
|
|
1254 mainwin_menubtn->pb_allow_draw = TRUE;
|
|
1255 mainwin_minimize->pb_allow_draw = TRUE;
|
|
1256 mainwin_shade->pb_allow_draw = TRUE;
|
|
1257 mainwin_close->pb_allow_draw = TRUE;
|
|
1258 draw_main_window(TRUE);
|
|
1259
|
|
1260 return TRUE;
|
|
1261 }
|
|
1262
|
|
1263
|
|
1264 static gboolean
|
|
1265 mainwin_focus_out(GtkWidget * widget,
|
|
1266 GdkEventFocus * event,
|
|
1267 gpointer callback_data)
|
|
1268 {
|
|
1269 mainwin_menubtn->pb_allow_draw = FALSE;
|
|
1270 mainwin_minimize->pb_allow_draw = FALSE;
|
|
1271 mainwin_shade->pb_allow_draw = FALSE;
|
|
1272 mainwin_close->pb_allow_draw = FALSE;
|
|
1273 draw_main_window(TRUE);
|
|
1274
|
|
1275 return TRUE;
|
|
1276 }
|
|
1277
|
|
1278 static gboolean
|
|
1279 mainwin_keypress(GtkWidget * grab_widget,
|
|
1280 GdkEventKey * event,
|
|
1281 gpointer data)
|
|
1282 {
|
|
1283 Playlist *playlist = playlist_get_active();
|
|
1284
|
|
1285 switch (event->keyval) {
|
|
1286
|
|
1287 case GDK_Up:
|
|
1288 case GDK_KP_Up:
|
|
1289 case GDK_KP_8:
|
|
1290 mainwin_set_volume_diff(2);
|
|
1291 break;
|
|
1292 case GDK_Down:
|
|
1293 case GDK_KP_Down:
|
|
1294 case GDK_KP_2:
|
|
1295 mainwin_set_volume_diff(-2);
|
|
1296 break;
|
|
1297 case GDK_Left:
|
|
1298 case GDK_KP_Left:
|
|
1299 case GDK_KP_7:
|
|
1300 if (playlist_get_current_length(playlist) != -1)
|
|
1301 playback_seek(CLAMP
|
|
1302 (playback_get_time() - 5000, 0,
|
|
1303 playlist_get_current_length(playlist)) / 1000);
|
|
1304 break;
|
|
1305 case GDK_Right:
|
|
1306 case GDK_KP_Right:
|
|
1307 case GDK_KP_9:
|
|
1308 if (playlist_get_current_length(playlist) != -1)
|
|
1309 playback_seek(CLAMP
|
|
1310 (playback_get_time() + 5000, 0,
|
|
1311 playlist_get_current_length(playlist)) / 1000);
|
|
1312 break;
|
|
1313 case GDK_KP_4:
|
|
1314 playlist_prev(playlist);
|
|
1315 break;
|
|
1316 case GDK_KP_6:
|
|
1317 playlist_next(playlist);
|
|
1318 break;
|
|
1319 case GDK_KP_Insert:
|
|
1320 mainwin_jump_to_file();
|
|
1321 break;
|
|
1322 case GDK_KP_5:
|
|
1323 mainwin_play_pushed();
|
|
1324 break;
|
|
1325 case GDK_Escape:
|
|
1326 mainwin_minimize_cb();
|
|
1327 break;
|
|
1328 default:
|
|
1329 return FALSE;
|
|
1330 }
|
|
1331
|
|
1332 return TRUE;
|
|
1333 }
|
|
1334
|
|
1335 static void
|
|
1336 mainwin_jump_to_time_cb(GtkWidget * widget,
|
|
1337 GtkWidget * entry)
|
|
1338 {
|
|
1339 guint min = 0, sec = 0, params;
|
|
1340 gint time;
|
|
1341 Playlist *playlist = playlist_get_active();
|
|
1342
|
|
1343 params = sscanf(gtk_entry_get_text(GTK_ENTRY(entry)), "%u:%u",
|
|
1344 &min, &sec);
|
|
1345 if (params == 2)
|
|
1346 time = (min * 60) + sec;
|
|
1347 else if (params == 1)
|
|
1348 time = min;
|
|
1349 else
|
|
1350 return;
|
|
1351
|
|
1352 if (playlist_get_current_length(playlist) > -1 &&
|
|
1353 time <= (playlist_get_current_length(playlist) / 1000))
|
|
1354 {
|
|
1355 playback_seek(time);
|
|
1356 gtk_widget_destroy(mainwin_jtt);
|
|
1357 }
|
|
1358 }
|
|
1359
|
|
1360
|
|
1361 void
|
|
1362 mainwin_jump_to_time(void)
|
|
1363 {
|
|
1364 GtkWidget *vbox, *hbox_new, *hbox_total;
|
|
1365 GtkWidget *time_entry, *label, *bbox, *jump, *cancel;
|
|
1366 guint tindex;
|
|
1367 gchar time_str[10];
|
|
1368
|
|
1369 if (!playback_get_playing()) {
|
|
1370 report_error("JIT can't be launched when no track is being played.\n");
|
|
1371 return;
|
|
1372 }
|
|
1373
|
|
1374 if (mainwin_jtt) {
|
|
1375 gtk_window_present(GTK_WINDOW(mainwin_jtt));
|
|
1376 return;
|
|
1377 }
|
|
1378
|
|
1379 mainwin_jtt = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
|
1380 gtk_window_set_type_hint(GTK_WINDOW(mainwin_jtt),
|
|
1381 GDK_WINDOW_TYPE_HINT_DIALOG);
|
|
1382
|
|
1383 gtk_window_set_title(GTK_WINDOW(mainwin_jtt), _("Jump to Time"));
|
|
1384 gtk_window_set_position(GTK_WINDOW(mainwin_jtt), GTK_WIN_POS_CENTER);
|
|
1385 gtk_window_set_transient_for(GTK_WINDOW(mainwin_jtt),
|
|
1386 GTK_WINDOW(mainwin));
|
|
1387
|
|
1388 g_signal_connect(mainwin_jtt, "destroy",
|
|
1389 G_CALLBACK(gtk_widget_destroyed), &mainwin_jtt);
|
|
1390 gtk_container_border_width(GTK_CONTAINER(mainwin_jtt), 10);
|
|
1391
|
|
1392 vbox = gtk_vbox_new(FALSE, 5);
|
|
1393 gtk_container_add(GTK_CONTAINER(mainwin_jtt), vbox);
|
|
1394
|
|
1395 hbox_new = gtk_hbox_new(FALSE, 0);
|
|
1396 gtk_box_pack_start(GTK_BOX(vbox), hbox_new, TRUE, TRUE, 5);
|
|
1397
|
|
1398 time_entry = gtk_entry_new();
|
|
1399 gtk_box_pack_start(GTK_BOX(hbox_new), time_entry, FALSE, FALSE, 5);
|
|
1400 g_signal_connect(time_entry, "activate",
|
|
1401 G_CALLBACK(mainwin_jump_to_time_cb), time_entry);
|
|
1402
|
|
1403 gtk_widget_set_size_request(time_entry, 70, -1);
|
|
1404 label = gtk_label_new(_("minutes:seconds"));
|
|
1405 gtk_box_pack_start(GTK_BOX(hbox_new), label, FALSE, FALSE, 5);
|
|
1406
|
|
1407 hbox_total = gtk_hbox_new(FALSE, 0);
|
|
1408 gtk_box_pack_start(GTK_BOX(vbox), hbox_total, TRUE, TRUE, 5);
|
|
1409 gtk_widget_show(hbox_total);
|
|
1410
|
|
1411 /* FIXME: Disable display of current track length. It's not
|
|
1412 updated when track changes */
|
|
1413 #if 0
|
|
1414 label = gtk_label_new(_("Track length:"));
|
|
1415 gtk_box_pack_start(GTK_BOX(hbox_total), label, FALSE, FALSE, 5);
|
|
1416
|
|
1417 len = playlist_get_current_length() / 1000;
|
|
1418 g_snprintf(time_str, sizeof(time_str), "%u:%2.2u", len / 60, len % 60);
|
|
1419 label = gtk_label_new(time_str);
|
|
1420
|
|
1421 gtk_box_pack_start(GTK_BOX(hbox_total), label, FALSE, FALSE, 10);
|
|
1422 #endif
|
|
1423
|
|
1424 bbox = gtk_hbutton_box_new();
|
|
1425 gtk_box_pack_start(GTK_BOX(vbox), bbox, TRUE, TRUE, 0);
|
|
1426 gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
|
|
1427 gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
|
|
1428
|
|
1429 cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
|
|
1430 GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
|
|
1431 gtk_container_add(GTK_CONTAINER(bbox), cancel);
|
|
1432 g_signal_connect_swapped(cancel, "clicked",
|
|
1433 G_CALLBACK(gtk_widget_destroy), mainwin_jtt);
|
|
1434
|
|
1435 jump = gtk_button_new_from_stock(GTK_STOCK_JUMP_TO);
|
|
1436 GTK_WIDGET_SET_FLAGS(jump, GTK_CAN_DEFAULT);
|
|
1437 gtk_container_add(GTK_CONTAINER(bbox), jump);
|
|
1438 g_signal_connect(jump, "clicked",
|
|
1439 G_CALLBACK(mainwin_jump_to_time_cb), time_entry);
|
|
1440
|
|
1441 tindex = playback_get_time() / 1000;
|
|
1442 g_snprintf(time_str, sizeof(time_str), "%u:%2.2u", tindex / 60,
|
|
1443 tindex % 60);
|
|
1444 gtk_entry_set_text(GTK_ENTRY(time_entry), time_str);
|
|
1445
|
|
1446 gtk_entry_select_region(GTK_ENTRY(time_entry), 0, strlen(time_str));
|
|
1447
|
|
1448 gtk_widget_show_all(mainwin_jtt);
|
|
1449
|
|
1450 gtk_widget_grab_focus(time_entry);
|
|
1451 gtk_widget_grab_default(jump);
|
|
1452 }
|
|
1453
|
|
1454 static void
|
|
1455 change_song(guint pos)
|
|
1456 {
|
|
1457 if (playback_get_playing())
|
|
1458 playback_stop();
|
|
1459
|
|
1460 playlist_set_position(playlist_get_active(), pos);
|
|
1461 playback_initiate();
|
|
1462 }
|
|
1463
|
|
1464 static void
|
|
1465 mainwin_jump_to_file_jump(GtkTreeView * treeview)
|
|
1466 {
|
|
1467 GtkTreeModel *model;
|
|
1468 GtkTreeSelection *selection;
|
|
1469 GtkTreeIter iter;
|
|
1470 guint pos;
|
|
1471
|
|
1472 model = gtk_tree_view_get_model(treeview);
|
|
1473 selection = gtk_tree_view_get_selection(treeview);
|
|
1474
|
|
1475 if (!gtk_tree_selection_get_selected(selection, NULL, &iter))
|
|
1476 return;
|
|
1477
|
|
1478 gtk_tree_model_get(model, &iter, 0, &pos, -1);
|
|
1479
|
|
1480 change_song(pos - 1);
|
|
1481
|
|
1482 /* FIXME: should only hide window */
|
|
1483 gtk_widget_destroy(mainwin_jtf);
|
|
1484 mainwin_jtf = NULL;
|
|
1485 }
|
|
1486
|
|
1487 static void
|
|
1488 mainwin_jump_to_file_jump_cb(GtkTreeView * treeview,
|
|
1489 gpointer data)
|
|
1490 {
|
|
1491 mainwin_jump_to_file_jump(treeview);
|
|
1492 }
|
|
1493
|
|
1494 static void
|
|
1495 mainwin_jump_to_file_set_queue_button_label(GtkButton * button,
|
|
1496 guint pos)
|
|
1497 {
|
|
1498 if (playlist_is_position_queued(playlist_get_active(), pos))
|
|
1499 gtk_button_set_label(button, _("Un_queue"));
|
|
1500 else
|
|
1501 gtk_button_set_label(button, _("_Queue"));
|
|
1502 }
|
|
1503
|
|
1504 static void
|
|
1505 mainwin_jump_to_file_queue_cb(GtkButton * button,
|
|
1506 gpointer data)
|
|
1507 {
|
|
1508 GtkTreeView *treeview;
|
|
1509 GtkTreeModel *model;
|
|
1510 GtkTreeSelection *selection;
|
|
1511 GtkTreeIter iter;
|
|
1512 guint pos;
|
|
1513
|
|
1514 treeview = GTK_TREE_VIEW(data);
|
|
1515 model = gtk_tree_view_get_model(treeview);
|
|
1516 selection = gtk_tree_view_get_selection(treeview);
|
|
1517
|
|
1518 if (!gtk_tree_selection_get_selected(selection, NULL, &iter))
|
|
1519 return;
|
|
1520
|
|
1521 gtk_tree_model_get(model, &iter, 0, &pos, -1);
|
|
1522
|
|
1523 playlist_queue_position(playlist_get_active(), (pos - 1));
|
|
1524
|
|
1525 mainwin_jump_to_file_set_queue_button_label(button, (pos - 1));
|
|
1526 }
|
|
1527
|
|
1528 static void
|
|
1529 mainwin_jump_to_file_selection_changed_cb(GtkTreeSelection *treesel,
|
|
1530 gpointer data)
|
|
1531 {
|
|
1532 GtkTreeView *treeview;
|
|
1533 GtkTreeModel *model;
|
|
1534 GtkTreeSelection *selection;
|
|
1535 GtkTreeIter iter;
|
|
1536 guint pos;
|
|
1537
|
|
1538 treeview = gtk_tree_selection_get_tree_view(treesel);
|
|
1539 model = gtk_tree_view_get_model(treeview);
|
|
1540 selection = gtk_tree_view_get_selection(treeview);
|
|
1541
|
|
1542 if (!gtk_tree_selection_get_selected(selection, NULL, &iter))
|
|
1543 return;
|
|
1544
|
|
1545 gtk_tree_model_get(model, &iter, 0, &pos, -1);
|
|
1546
|
|
1547 mainwin_jump_to_file_set_queue_button_label(GTK_BUTTON(data), (pos - 1));
|
|
1548 }
|
|
1549
|
|
1550 static gboolean
|
|
1551 mainwin_jump_to_file_edit_keypress_cb(GtkWidget * object,
|
|
1552 GdkEventKey * event,
|
|
1553 gpointer data)
|
|
1554 {
|
|
1555 switch (event->keyval) {
|
|
1556 case GDK_Return:
|
|
1557 if (gtk_im_context_filter_keypress (GTK_ENTRY (object)->im_context, event)) {
|
|
1558 GTK_ENTRY (object)->need_im_reset = TRUE;
|
|
1559 return TRUE;
|
|
1560 } else {
|
|
1561 mainwin_jump_to_file_jump(GTK_TREE_VIEW(data));
|
|
1562 return TRUE;
|
|
1563 }
|
|
1564 default:
|
|
1565 return FALSE;
|
|
1566 }
|
|
1567 }
|
|
1568
|
|
1569 static gboolean
|
|
1570 mainwin_jump_to_file_keypress_cb(GtkWidget * object,
|
|
1571 GdkEventKey * event,
|
|
1572 gpointer data)
|
|
1573 {
|
|
1574 switch (event->keyval) {
|
|
1575 case GDK_Escape:
|
|
1576 /* FIXME: show only hide window */
|
|
1577 gtk_widget_destroy(mainwin_jtf);
|
|
1578 mainwin_jtf = NULL;
|
|
1579 return TRUE;
|
|
1580 case GDK_KP_Enter:
|
|
1581 mainwin_jump_to_file_queue_cb(NULL, data);
|
|
1582 return TRUE;
|
|
1583 default:
|
|
1584 return FALSE;
|
|
1585 };
|
|
1586
|
|
1587 return FALSE;
|
|
1588 }
|
|
1589
|
|
1590 static gboolean
|
|
1591 mainwin_jump_to_file_match(const gchar * song, GSList *regex_list)
|
|
1592 {
|
|
1593 gint i = 0;
|
|
1594 gboolean rv = TRUE;
|
|
1595
|
|
1596 if ( song == NULL )
|
|
1597 return FALSE;
|
|
1598
|
|
1599 for ( ; regex_list ; regex_list = g_slist_next(regex_list) )
|
|
1600 {
|
|
1601 regex_t *regex = regex_list->data;
|
|
1602 if ( regexec( regex , song , 0 , NULL , 0 ) != 0 )
|
|
1603 {
|
|
1604 rv = FALSE;
|
|
1605 break;
|
|
1606 }
|
|
1607 }
|
|
1608
|
|
1609 return rv;
|
|
1610 }
|
|
1611
|
|
1612 /* FIXME: Clear the entry when the list gets updated */
|
|
1613 static void
|
|
1614 mainwin_update_jtf(GtkWidget * widget, gpointer user_data)
|
|
1615 {
|
|
1616 /* FIXME: Is not in sync with playlist due to delayed extinfo
|
|
1617 * reading */
|
|
1618 guint row;
|
|
1619 GList *playlist_glist;
|
|
1620 gchar *desc_buf = NULL;
|
|
1621 gchar *row_str;
|
|
1622 GtkTreeIter iter;
|
|
1623 GtkTreeSelection *selection;
|
|
1624 Playlist *playlist;
|
|
1625
|
|
1626 GtkTreeModel *store;
|
|
1627
|
|
1628 if (!mainwin_jtf)
|
|
1629 return;
|
|
1630
|
|
1631 store = gtk_tree_view_get_model(GTK_TREE_VIEW(user_data));
|
|
1632 gtk_list_store_clear(GTK_LIST_STORE(store));
|
|
1633
|
|
1634 row = 1;
|
|
1635 playlist = playlist_get_active();
|
|
1636 for (playlist_glist = playlist->entries; playlist_glist;
|
|
1637 playlist_glist = g_list_next(playlist_glist)) {
|
|
1638 PlaylistEntry *entry = PLAYLIST_ENTRY(playlist_glist->data);
|
|
1639
|
|
1640 if (entry->title)
|
|
1641 desc_buf = g_strdup(entry->title);
|
|
1642 else if (strchr(entry->filename, '/'))
|
|
1643 desc_buf = str_to_utf8(strrchr(entry->filename, '/') + 1);
|
|
1644 else
|
|
1645 desc_buf = str_to_utf8(entry->filename);
|
|
1646
|
|
1647 gtk_list_store_append(GTK_LIST_STORE(store), &iter);
|
|
1648 gtk_list_store_set(GTK_LIST_STORE(store), &iter,
|
|
1649 0, row, 1, desc_buf, -1);
|
|
1650 row++;
|
|
1651
|
|
1652 if(desc_buf) {
|
|
1653 g_free(desc_buf);
|
|
1654 desc_buf = NULL;
|
|
1655 }
|
|
1656 }
|
|
1657
|
|
1658 gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter);
|
|
1659 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(user_data));
|
|
1660 gtk_tree_selection_select_iter(selection, &iter);
|
|
1661 }
|
|
1662
|
|
1663 static void
|
|
1664 mainwin_jump_to_file_edit_cb(GtkEntry * entry, gpointer user_data)
|
|
1665 {
|
|
1666 GtkTreeView *treeview = GTK_TREE_VIEW(user_data);
|
|
1667 GtkTreeSelection *selection;
|
|
1668 GtkTreeIter iter;
|
|
1669
|
|
1670 GtkListStore *store;
|
|
1671
|
|
1672 guint song_index = 0;
|
|
1673 gchar **words;
|
|
1674 GList *playlist_glist;
|
|
1675 Playlist *playlist;
|
|
1676
|
|
1677 gboolean match = FALSE;
|
|
1678
|
|
1679 GSList *regex_list = NULL, *regex_list_tmp = NULL;
|
|
1680 gint i = -1;
|
|
1681
|
|
1682 /* Chop the key string into ' '-separated key regex-pattern strings */
|
|
1683 words = g_strsplit(gtk_entry_get_text(entry), " ", 0);
|
|
1684
|
|
1685 /* create a list of regex using the regex-pattern strings */
|
|
1686 while ( words[++i] != NULL )
|
|
1687 {
|
|
1688 regex_t *regex = g_malloc(sizeof(regex_t));
|
|
1689 #if defined(USE_REGEX_PCRE)
|
|
1690 if ( regcomp( regex , words[i] , REG_NOSUB | REG_ICASE | REG_UTF8 ) == 0 )
|
|
1691 #else
|
|
1692 if ( regcomp( regex , words[i] , REG_NOSUB | REG_ICASE ) == 0 )
|
|
1693 #endif
|
|
1694 regex_list = g_slist_append( regex_list , regex );
|
|
1695 }
|
|
1696
|
|
1697 /* FIXME: Remove the connected signals before clearing
|
|
1698 * (row-selected will still eventually arrive once) */
|
|
1699 store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
|
|
1700 /* detach model from treeview */
|
|
1701 g_object_ref( store );
|
|
1702 gtk_tree_view_set_model( GTK_TREE_VIEW(treeview) , NULL );
|
|
1703
|
|
1704 gtk_list_store_clear(store);
|
|
1705
|
|
1706 playlist = playlist_get_active();
|
|
1707
|
|
1708 PLAYLIST_LOCK(playlist->mutex);
|
|
1709
|
|
1710 for (playlist_glist = playlist->entries; playlist_glist;
|
|
1711 playlist_glist = g_list_next(playlist_glist)) {
|
|
1712
|
|
1713 PlaylistEntry *entry = PLAYLIST_ENTRY(playlist_glist->data);
|
|
1714 const gchar *title;
|
|
1715 gchar *filename = NULL;
|
|
1716
|
|
1717 title = entry->title;
|
|
1718 if (!title) {
|
|
1719 filename = str_to_utf8(entry->filename);
|
|
1720
|
|
1721 if (strchr(filename, '/'))
|
|
1722 title = strrchr(filename, '/') + 1;
|
|
1723 else
|
|
1724 title = filename;
|
|
1725 }
|
|
1726
|
|
1727 /* Compare the reg.expressions to the string - if all the
|
|
1728 regexp in regex_list match, add to the ListStore */
|
|
1729
|
|
1730 /*
|
|
1731 * FIXME: The search string should be adapted to the
|
|
1732 * current display setting, e.g. if the user has set it to
|
|
1733 * "%p - %t" then build the match string like that too, or
|
|
1734 * even better, search for each of the tags seperatly.
|
|
1735 *
|
|
1736 * In any case the string to match should _never_ contain
|
|
1737 * something the user can't actually see in the playlist.
|
|
1738 */
|
|
1739 if (regex_list != NULL)
|
|
1740 match = mainwin_jump_to_file_match(title, regex_list);
|
|
1741 else
|
|
1742 match = TRUE;
|
|
1743
|
|
1744 if (match) {
|
|
1745 gtk_list_store_append(store, &iter);
|
|
1746 gtk_list_store_set(store, &iter, 0, song_index + 1 , 1, title, -1);
|
|
1747 }
|
|
1748
|
|
1749 song_index++;
|
|
1750 if (filename) {
|
|
1751 g_free(filename);
|
|
1752 filename = NULL;
|
|
1753 }
|
|
1754 }
|
|
1755
|
|
1756 PLAYLIST_UNLOCK(playlist->mutex);
|
|
1757
|
|
1758 /* attach the model again to the treeview */
|
|
1759 gtk_tree_view_set_model( GTK_TREE_VIEW(treeview) , GTK_TREE_MODEL(store) );
|
|
1760 g_object_unref( store );
|
|
1761
|
|
1762 if ( regex_list != NULL )
|
|
1763 {
|
|
1764 regex_list_tmp = regex_list;
|
|
1765 while ( regex_list != NULL )
|
|
1766 {
|
|
1767 regex_t *regex = regex_list->data;
|
|
1768 regfree( regex );
|
|
1769 regex_list = g_slist_next(regex_list);
|
|
1770 }
|
|
1771 g_slist_free( regex_list_tmp );
|
|
1772 }
|
|
1773 g_strfreev(words);
|
|
1774
|
|
1775 if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter)) {
|
|
1776 selection = gtk_tree_view_get_selection(treeview);
|
|
1777 gtk_tree_selection_select_iter(selection, &iter);
|
|
1778 }
|
|
1779 }
|
|
1780
|
|
1781 void
|
|
1782 mainwin_jump_to_file(void)
|
|
1783 {
|
|
1784 GtkWidget *scrollwin;
|
|
1785 GtkWidget *vbox, *bbox, *sep;
|
|
1786 GtkWidget *jump, *queue, *cancel;
|
|
1787 GtkWidget *rescan, *edit;
|
|
1788 GtkWidget *search_label, *hbox;
|
|
1789 GList *playlist_glist;
|
|
1790 Playlist *playlist;
|
|
1791 gchar *desc_buf = NULL;
|
|
1792 guint row;
|
|
1793
|
|
1794 GtkWidget *treeview;
|
|
1795 GtkListStore *jtf_store;
|
|
1796
|
|
1797 GtkTreeIter iter;
|
|
1798 GtkCellRenderer *renderer;
|
|
1799 GtkTreeViewColumn *column;
|
|
1800
|
|
1801 if (mainwin_jtf) {
|
|
1802 gtk_window_present(GTK_WINDOW(mainwin_jtf));
|
|
1803 return;
|
|
1804 }
|
|
1805
|
|
1806 #if defined(USE_REGEX_ONIGURUMA)
|
|
1807 /* set encoding for Oniguruma regex to UTF-8 */
|
|
1808 reg_set_encoding( REG_POSIX_ENCODING_UTF8 );
|
|
1809 onig_set_default_syntax( ONIG_SYNTAX_POSIX_BASIC );
|
|
1810 #endif
|
|
1811
|
|
1812 mainwin_jtf = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
|
1813 gtk_window_set_type_hint(GTK_WINDOW(mainwin_jtf),
|
|
1814 GDK_WINDOW_TYPE_HINT_DIALOG);
|
|
1815
|
|
1816 gtk_window_set_title(GTK_WINDOW(mainwin_jtf), _("Jump to Track"));
|
|
1817
|
|
1818 gtk_window_set_position(GTK_WINDOW(mainwin_jtf), GTK_WIN_POS_CENTER);
|
|
1819 g_signal_connect(mainwin_jtf, "destroy",
|
|
1820 G_CALLBACK(gtk_widget_destroyed), &mainwin_jtf);
|
|
1821
|
|
1822 gtk_container_border_width(GTK_CONTAINER(mainwin_jtf), 10);
|
|
1823 gtk_window_set_default_size(GTK_WINDOW(mainwin_jtf), 550, 350);
|
|
1824
|
|
1825 vbox = gtk_vbox_new(FALSE, 5);
|
|
1826 gtk_container_add(GTK_CONTAINER(mainwin_jtf), vbox);
|
|
1827
|
|
1828 jtf_store = gtk_list_store_new(2, G_TYPE_UINT, G_TYPE_STRING);
|
|
1829 treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(jtf_store));
|
|
1830 g_object_unref(jtf_store);
|
|
1831
|
|
1832 gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);
|
|
1833
|
|
1834 column = gtk_tree_view_column_new();
|
|
1835 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
|
|
1836 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
|
|
1837
|
|
1838 renderer = gtk_cell_renderer_text_new();
|
|
1839 gtk_tree_view_column_pack_start(column, renderer, FALSE);
|
|
1840 gtk_tree_view_column_set_attributes(column, renderer, "text", 0, NULL);
|
|
1841 gtk_tree_view_column_set_spacing(column, 4);
|
|
1842
|
|
1843 renderer = gtk_cell_renderer_text_new();
|
|
1844 gtk_tree_view_column_pack_start(column, renderer, FALSE);
|
|
1845 gtk_tree_view_column_set_attributes(column, renderer, "text", 1, NULL);
|
|
1846 gtk_tree_view_column_set_spacing(column, 4);
|
|
1847 gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
|
|
1848
|
|
1849 gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), 1);
|
|
1850
|
|
1851 g_signal_connect(treeview, "row-activated",
|
|
1852 G_CALLBACK(mainwin_jump_to_file_jump), NULL);
|
|
1853
|
|
1854 hbox = gtk_hbox_new(FALSE, 3);
|
|
1855 gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);
|
|
1856
|
|
1857 search_label = gtk_label_new(_("Filter: "));
|
|
1858 gtk_label_set_markup_with_mnemonic(GTK_LABEL(search_label), _("_Filter:"));
|
|
1859 gtk_box_pack_start(GTK_BOX(hbox), search_label, FALSE, FALSE, 0);
|
|
1860
|
|
1861 edit = gtk_entry_new();
|
|
1862 gtk_entry_set_editable(GTK_ENTRY(edit), TRUE);
|
|
1863 gtk_label_set_mnemonic_widget(GTK_LABEL(search_label), edit);
|
|
1864 g_signal_connect(edit, "changed",
|
|
1865 G_CALLBACK(mainwin_jump_to_file_edit_cb), treeview);
|
|
1866
|
|
1867 g_signal_connect(edit, "key_press_event",
|
|
1868 G_CALLBACK(mainwin_jump_to_file_edit_keypress_cb), treeview);
|
|
1869
|
|
1870 g_signal_connect(mainwin_jtf, "key_press_event",
|
|
1871 G_CALLBACK(mainwin_jump_to_file_keypress_cb), treeview);
|
|
1872
|
|
1873 gtk_box_pack_start(GTK_BOX(hbox), edit, TRUE, TRUE, 3);
|
|
1874
|
|
1875 scrollwin = gtk_scrolled_window_new(NULL, NULL);
|
|
1876 gtk_container_add(GTK_CONTAINER(scrollwin), treeview);
|
|
1877 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
|
|
1878 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
|
|
1879 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrollwin),
|
|
1880 GTK_SHADOW_IN);
|
|
1881 gtk_box_pack_start(GTK_BOX(vbox), scrollwin, TRUE, TRUE, 0);
|
|
1882
|
|
1883 sep = gtk_hseparator_new();
|
|
1884 gtk_box_pack_start(GTK_BOX(vbox), sep, FALSE, FALSE, 0);
|
|
1885
|
|
1886 bbox = gtk_hbutton_box_new();
|
|
1887 gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
|
|
1888 gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
|
|
1889 gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
|
|
1890
|
|
1891 queue = gtk_button_new_with_mnemonic(_("_Queue"));
|
|
1892 gtk_box_pack_start(GTK_BOX(bbox), queue, FALSE, FALSE, 0);
|
|
1893 GTK_WIDGET_SET_FLAGS(queue, GTK_CAN_DEFAULT);
|
|
1894 g_signal_connect(queue, "clicked",
|
|
1895 G_CALLBACK(mainwin_jump_to_file_queue_cb),
|
|
1896 treeview);
|
|
1897 g_signal_connect(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)), "changed",
|
|
1898 G_CALLBACK(mainwin_jump_to_file_selection_changed_cb),
|
|
1899 queue);
|
|
1900
|
|
1901 rescan = gtk_button_new_from_stock(GTK_STOCK_REFRESH);
|
|
1902 gtk_box_pack_start(GTK_BOX(bbox), rescan, FALSE, FALSE, 0);
|
|
1903 g_signal_connect(rescan, "clicked",
|
|
1904 G_CALLBACK(mainwin_update_jtf), treeview);
|
|
1905 GTK_WIDGET_SET_FLAGS(rescan, GTK_CAN_DEFAULT);
|
|
1906 gtk_widget_grab_default(rescan);
|
|
1907
|
|
1908 jump = gtk_button_new_from_stock(GTK_STOCK_JUMP_TO);
|
|
1909 gtk_box_pack_start(GTK_BOX(bbox), jump, FALSE, FALSE, 0);
|
|
1910
|
|
1911 g_signal_connect_swapped(jump, "clicked",
|
|
1912 G_CALLBACK(mainwin_jump_to_file_jump_cb),
|
|
1913 treeview);
|
|
1914
|
|
1915 GTK_WIDGET_SET_FLAGS(jump, GTK_CAN_DEFAULT);
|
|
1916 gtk_widget_grab_default(jump);
|
|
1917
|
|
1918 cancel = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
|
|
1919 gtk_box_pack_start(GTK_BOX(bbox), cancel, FALSE, FALSE, 0);
|
|
1920 g_signal_connect_swapped(cancel, "clicked",
|
|
1921 G_CALLBACK(gtk_widget_destroy),
|
|
1922 mainwin_jtf);
|
|
1923 GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
|
|
1924
|
|
1925 gtk_list_store_clear(jtf_store);
|
|
1926
|
|
1927 row = 1;
|
|
1928
|
|
1929 playlist = playlist_get_active();
|
|
1930
|
|
1931 PLAYLIST_LOCK(playlist->mutex);
|
|
1932
|
|
1933 for (playlist_glist = playlist->entries; playlist_glist;
|
|
1934 playlist_glist = g_list_next(playlist_glist)) {
|
|
1935
|
|
1936 PlaylistEntry *entry = PLAYLIST_ENTRY(playlist_glist->data);
|
|
1937
|
|
1938 if (entry->title)
|
|
1939 desc_buf = g_strdup(entry->title);
|
|
1940 else if (strchr(entry->filename, '/'))
|
|
1941 desc_buf = str_to_utf8(strrchr(entry->filename, '/') + 1);
|
|
1942 else
|
|
1943 desc_buf = str_to_utf8(entry->filename);
|
|
1944
|
|
1945 gtk_list_store_append(GTK_LIST_STORE(jtf_store), &iter);
|
|
1946 gtk_list_store_set(GTK_LIST_STORE(jtf_store), &iter,
|
|
1947 0, row, 1, desc_buf, -1);
|
|
1948 row++;
|
|
1949
|
|
1950 if (desc_buf) {
|
|
1951 g_free(desc_buf);
|
|
1952 desc_buf = NULL;
|
|
1953 }
|
|
1954 }
|
|
1955
|
|
1956 PLAYLIST_UNLOCK(playlist->mutex);
|
|
1957
|
|
1958 gtk_widget_show_all(mainwin_jtf);
|
|
1959 }
|
|
1960
|
|
1961 static gboolean
|
|
1962 mainwin_configure(GtkWidget * window,
|
|
1963 GdkEventConfigure * event,
|
|
1964 gpointer data)
|
|
1965 {
|
|
1966 if (!GTK_WIDGET_VISIBLE(window))
|
|
1967 return FALSE;
|
|
1968
|
|
1969 if (cfg.show_wm_decorations)
|
|
1970 gdk_window_get_root_origin(window->window,
|
|
1971 &cfg.player_x, &cfg.player_y);
|
|
1972 else
|
|
1973 gdk_window_get_deskrelative_origin(window->window,
|
|
1974 &cfg.player_x, &cfg.player_y);
|
|
1975 return FALSE;
|
|
1976 }
|
|
1977
|
|
1978 void
|
|
1979 mainwin_set_back_pixmap(void)
|
|
1980 {
|
|
1981 if (cfg.doublesize)
|
|
1982 gdk_window_set_back_pixmap(mainwin->window, mainwin_bg_x2, 0);
|
|
1983 else
|
|
1984 gdk_window_set_back_pixmap(mainwin->window, mainwin_bg, 0);
|
|
1985 gdk_window_clear(mainwin->window);
|
|
1986 }
|
|
1987
|
|
1988 /*
|
|
1989 * Rewritten 09/13/06:
|
|
1990 *
|
|
1991 * Remove all of this flaky iter/sourcelist/strsplit stuff.
|
|
1992 * All we care about is the filepath.
|
|
1993 *
|
|
1994 * We can figure this out and easily pass it to xmms_urldecode_plain().
|
|
1995 * - nenolod
|
|
1996 */
|
|
1997 void
|
|
1998 mainwin_drag_data_received(GtkWidget * widget,
|
|
1999 GdkDragContext * context,
|
|
2000 gint x,
|
|
2001 gint y,
|
|
2002 GtkSelectionData * selection_data,
|
|
2003 guint info,
|
|
2004 guint time,
|
|
2005 gpointer user_data)
|
|
2006 {
|
|
2007 Playlist *playlist = playlist_get_active();
|
|
2008
|
|
2009 g_return_if_fail(selection_data != NULL);
|
|
2010 g_return_if_fail(selection_data->data != NULL);
|
|
2011
|
|
2012 if (str_has_prefix_nocase((gchar *) selection_data->data, "fonts:///"))
|
|
2013 {
|
|
2014 gchar *path = (gchar *) selection_data->data + 9; /* skip fonts:/// */
|
|
2015 gchar *decoded = xmms_urldecode_plain(path);
|
|
2016
|
|
2017 cfg.playlist_font = g_strconcat(decoded, strrchr(cfg.playlist_font, ' '), NULL);
|
|
2018 playlist_list_set_font(cfg.playlist_font);
|
|
2019 playlistwin_update_list(playlist);
|
|
2020
|
|
2021 g_free(decoded);
|
|
2022
|
|
2023 return;
|
|
2024 }
|
|
2025
|
|
2026 playlist_clear(playlist);
|
|
2027 playlist_add_url(playlist, (gchar *) selection_data->data);
|
|
2028 playback_initiate();
|
|
2029 }
|
|
2030
|
|
2031 static void
|
|
2032 on_add_url_add_clicked(GtkWidget * widget,
|
|
2033 GtkWidget * entry)
|
|
2034 {
|
|
2035 const gchar *text = gtk_entry_get_text(GTK_ENTRY(entry));
|
|
2036 if (text && *text)
|
|
2037 playlist_add_url(playlist_get_active(), text);
|
|
2038 }
|
|
2039
|
|
2040 static void
|
|
2041 on_add_url_ok_clicked(GtkWidget * widget,
|
|
2042 GtkWidget * entry)
|
|
2043 {
|
|
2044 Playlist *playlist = playlist_get_active();
|
|
2045
|
|
2046 const gchar *text = gtk_entry_get_text(GTK_ENTRY(entry));
|
|
2047 if (text && *text)
|
|
2048 {
|
|
2049 playlist_clear(playlist);
|
|
2050 playlist_add_url(playlist, text);
|
|
2051 playback_initiate();
|
|
2052 }
|
|
2053 }
|
|
2054
|
|
2055 void
|
|
2056 mainwin_show_add_url_window(void)
|
|
2057 {
|
|
2058 static GtkWidget *url_window = NULL;
|
|
2059
|
|
2060 if (!url_window) {
|
|
2061 url_window =
|
|
2062 util_add_url_dialog_new(_("Enter location to play:"),
|
|
2063 G_CALLBACK(on_add_url_ok_clicked),
|
|
2064 G_CALLBACK(on_add_url_add_clicked));
|
|
2065 gtk_window_set_transient_for(GTK_WINDOW(url_window),
|
|
2066 GTK_WINDOW(mainwin));
|
|
2067 g_signal_connect(url_window, "destroy",
|
|
2068 G_CALLBACK(gtk_widget_destroyed),
|
|
2069 &url_window);
|
|
2070 }
|
|
2071
|
|
2072 gtk_window_present(GTK_WINDOW(url_window));
|
|
2073 }
|
|
2074
|
|
2075 static void
|
|
2076 check_set( GtkActionGroup * action_group ,
|
|
2077 const gchar * action_name ,
|
|
2078 gboolean is_on )
|
|
2079 {
|
|
2080 /* check_set noew uses gtkaction */
|
|
2081 GtkAction *action = gtk_action_group_get_action( action_group , action_name );
|
|
2082 if ( action != NULL )
|
|
2083 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(action) , is_on );
|
|
2084 return;
|
|
2085 }
|
|
2086
|
|
2087 void
|
|
2088 mainwin_eject_pushed(void)
|
|
2089 {
|
|
2090 util_run_filebrowser(PLAY_BUTTON);
|
|
2091 }
|
|
2092
|
|
2093 void
|
|
2094 mainwin_rev_pushed(void)
|
|
2095 {
|
|
2096 g_get_current_time(&cb_time);
|
|
2097
|
|
2098 seek_initial_pos = hslider_get_position(mainwin_position);
|
|
2099 seek_state = MAINWIN_SEEK_REV;
|
|
2100 }
|
|
2101
|
|
2102 void
|
|
2103 mainwin_rev_release(void)
|
|
2104 {
|
|
2105 GTimeVal now_time;
|
|
2106 GTimeVal delta_time;
|
|
2107 gulong now_dur;
|
|
2108
|
|
2109 g_get_current_time(&now_time);
|
|
2110
|
|
2111 delta_time.tv_usec = now_time.tv_usec - cb_time.tv_usec;
|
|
2112 delta_time.tv_sec = now_time.tv_sec - cb_time.tv_sec;
|
|
2113
|
|
2114 now_dur = labs((delta_time.tv_sec * 1000) + (glong) (delta_time.tv_usec / 1000));
|
|
2115
|
|
2116 if ( now_dur <= TRISTATE_THRESHOLD )
|
|
2117 {
|
|
2118 /* interpret as 'skip to previous song' */
|
|
2119 playlist_prev(playlist_get_active());
|
|
2120 }
|
|
2121 else
|
|
2122 {
|
|
2123 /* interpret as 'seek' */
|
|
2124 mainwin_position_release_cb( hslider_get_position(mainwin_position) );
|
|
2125 }
|
|
2126
|
|
2127 seek_state = MAINWIN_SEEK_NIL;
|
|
2128 }
|
|
2129
|
|
2130 void
|
|
2131 mainwin_fwd_pushed(void)
|
|
2132 {
|
|
2133 g_get_current_time(&cb_time);
|
|
2134
|
|
2135 seek_initial_pos = hslider_get_position(mainwin_position);
|
|
2136 seek_state = MAINWIN_SEEK_FWD;
|
|
2137 }
|
|
2138
|
|
2139 void
|
|
2140 mainwin_fwd_release(void)
|
|
2141 {
|
|
2142 GTimeVal now_time;
|
|
2143 GTimeVal delta_time;
|
|
2144 gulong now_dur;
|
|
2145
|
|
2146 g_get_current_time(&now_time);
|
|
2147
|
|
2148 delta_time.tv_usec = now_time.tv_usec - cb_time.tv_usec;
|
|
2149 delta_time.tv_sec = now_time.tv_sec - cb_time.tv_sec;
|
|
2150
|
|
2151 now_dur = labs((delta_time.tv_sec * 1000) + (glong) (delta_time.tv_usec / 1000));
|
|
2152
|
|
2153 if ( now_dur <= TRISTATE_THRESHOLD )
|
|
2154 {
|
|
2155 /* interpret as 'skip to previous song' */
|
|
2156 playlist_next(playlist_get_active());
|
|
2157 }
|
|
2158 else
|
|
2159 {
|
|
2160 /* interpret as 'seek' */
|
|
2161 mainwin_position_release_cb( hslider_get_position(mainwin_position) );
|
|
2162 }
|
|
2163
|
|
2164 seek_state = MAINWIN_SEEK_NIL;
|
|
2165 }
|
|
2166
|
|
2167 void
|
|
2168 mainwin_play_pushed(void)
|
|
2169 {
|
|
2170 if (ab_position_a != -1)
|
|
2171 playback_seek(ab_position_a / 1000);
|
|
2172 if (playback_get_paused()) {
|
|
2173 playback_pause();
|
|
2174 return;
|
|
2175 }
|
|
2176
|
|
2177 if (playlist_get_length(playlist_get_active()))
|
|
2178 playback_initiate();
|
|
2179 else
|
|
2180 mainwin_eject_pushed();
|
|
2181 }
|
|
2182
|
|
2183 void
|
|
2184 mainwin_stop_pushed(void)
|
|
2185 {
|
|
2186 ip_data.stop = TRUE;
|
|
2187 mainwin_clear_song_info();
|
|
2188 playback_stop();
|
|
2189 ip_data.stop = FALSE;
|
|
2190 }
|
|
2191
|
|
2192 void
|
|
2193 mainwin_shuffle_pushed(gboolean toggled)
|
|
2194 {
|
|
2195 check_set( toggleaction_group_others , "playback shuffle" , toggled );
|
|
2196 }
|
|
2197
|
|
2198 void
|
|
2199 mainwin_repeat_pushed(gboolean toggled)
|
|
2200 {
|
|
2201 check_set( toggleaction_group_others , "playback repeat" , toggled );
|
|
2202 }
|
|
2203
|
|
2204 void
|
|
2205 mainwin_pl_pushed(gboolean toggled)
|
|
2206 {
|
|
2207 if (toggled)
|
|
2208 playlistwin_show();
|
|
2209 else
|
|
2210 playlistwin_hide();
|
|
2211 }
|
|
2212
|
|
2213 gint
|
|
2214 mainwin_spos_frame_cb(gint pos)
|
|
2215 {
|
|
2216 if (mainwin_sposition) {
|
|
2217 if (pos < 6)
|
|
2218 mainwin_sposition->hs_knob_nx = mainwin_sposition->hs_knob_px =
|
|
2219 17;
|
|
2220 else if (pos < 9)
|
|
2221 mainwin_sposition->hs_knob_nx = mainwin_sposition->hs_knob_px =
|
|
2222 20;
|
|
2223 else
|
|
2224 mainwin_sposition->hs_knob_nx = mainwin_sposition->hs_knob_px =
|
|
2225 23;
|
|
2226 }
|
|
2227 return 1;
|
|
2228 }
|
|
2229
|
|
2230 void
|
|
2231 mainwin_spos_motion_cb(gint pos)
|
|
2232 {
|
|
2233 gint time;
|
|
2234 gchar *time_msg;
|
|
2235 Playlist *playlist = playlist_get_active();
|
|
2236
|
|
2237 pos--;
|
|
2238
|
|
2239 time = ((playlist_get_current_length(playlist) / 1000) * pos) / 12;
|
|
2240
|
|
2241 if (cfg.timer_mode == TIMER_REMAINING) {
|
|
2242 time = (playlist_get_current_length(playlist) / 1000) - time;
|
|
2243 time_msg = g_strdup_printf("-%2.2d", time / 60);
|
|
2244 textbox_set_text(mainwin_stime_min, time_msg);
|
|
2245 g_free(time_msg);
|
|
2246 }
|
|
2247 else {
|
|
2248 time_msg = g_strdup_printf(" %2.2d", time / 60);
|
|
2249 textbox_set_text(mainwin_stime_min, time_msg);
|
|
2250 g_free(time_msg);
|
|
2251 }
|
|
2252
|
|
2253 time_msg = g_strdup_printf("%2.2d", time % 60);
|
|
2254 textbox_set_text(mainwin_stime_sec, time_msg);
|
|
2255 g_free(time_msg);
|
|
2256 }
|
|
2257
|
|
2258 void
|
|
2259 mainwin_spos_release_cb(gint pos)
|
|
2260 {
|
|
2261 playback_seek(((playlist_get_current_length(playlist_get_active()) / 1000) *
|
|
2262 (pos - 1)) / 12);
|
|
2263 }
|
|
2264
|
|
2265 void
|
|
2266 mainwin_position_motion_cb(gint pos)
|
|
2267 {
|
|
2268 gint length, time;
|
|
2269 gchar *seek_msg;
|
|
2270
|
|
2271 length = playlist_get_current_length(playlist_get_active()) / 1000;
|
|
2272 time = (length * pos) / 219;
|
|
2273 seek_msg = g_strdup_printf(_("SEEK TO: %d:%-2.2d/%d:%-2.2d (%d%%)"),
|
|
2274 time / 60, time % 60,
|
|
2275 length / 60, length % 60,
|
|
2276 (length != 0) ? (time * 100) / length : 0);
|
|
2277 mainwin_lock_info_text(seek_msg);
|
|
2278 g_free(seek_msg);
|
|
2279 }
|
|
2280
|
|
2281 void
|
|
2282 mainwin_position_release_cb(gint pos)
|
|
2283 {
|
|
2284 gint length, time;
|
|
2285
|
|
2286 length = playlist_get_current_length(playlist_get_active()) / 1000;
|
|
2287 time = (length * pos) / 219;
|
|
2288 playback_seek(time);
|
|
2289 mainwin_release_info_text();
|
|
2290 }
|
|
2291
|
|
2292 gint
|
|
2293 mainwin_volume_frame_cb(gint pos)
|
|
2294 {
|
|
2295 return (gint) rint((pos / 52.0) * 28);
|
|
2296 }
|
|
2297
|
|
2298 void
|
|
2299 mainwin_adjust_volume_motion(gint v)
|
|
2300 {
|
|
2301 gchar *volume_msg;
|
|
2302
|
|
2303 setting_volume = TRUE;
|
|
2304
|
|
2305 volume_msg = g_strdup_printf(_("VOLUME: %d%%"), v);
|
|
2306 mainwin_lock_info_text(volume_msg);
|
|
2307 g_free(volume_msg);
|
|
2308
|
|
2309 if (balance < 0)
|
|
2310 input_set_volume(v, (v * (100 - abs(balance))) / 100);
|
|
2311 else if (balance > 0)
|
|
2312 input_set_volume((v * (100 - abs(balance))) / 100, v);
|
|
2313 else
|
|
2314 input_set_volume(v, v);
|
|
2315 }
|
|
2316
|
|
2317 void
|
|
2318 mainwin_adjust_volume_release(void)
|
|
2319 {
|
|
2320 mainwin_release_info_text();
|
|
2321 setting_volume = FALSE;
|
|
2322 read_volume(VOLUME_ADJUSTED);
|
|
2323 }
|
|
2324
|
|
2325 void
|
|
2326 mainwin_adjust_balance_motion(gint b)
|
|
2327 {
|
|
2328 gchar *balance_msg;
|
|
2329 gint v, pvl, pvr;
|
|
2330
|
|
2331 setting_volume = TRUE;
|
|
2332 balance = b;
|
|
2333 input_get_volume(&pvl, &pvr);
|
|
2334 v = MAX(pvl, pvr);
|
|
2335 if (b < 0) {
|
|
2336 balance_msg = g_strdup_printf(_("BALANCE: %d%% LEFT"), -b);
|
|
2337 input_set_volume(v, (gint) rint(((100 + b) / 100.0) * v));
|
|
2338 }
|
|
2339 else if (b == 0) {
|
|
2340 balance_msg = g_strdup_printf(_("BALANCE: CENTER"));
|
|
2341 input_set_volume(v, v);
|
|
2342 }
|
|
2343 else { /* b > 0 */
|
|
2344 balance_msg = g_strdup_printf(_("BALANCE: %d%% RIGHT"), b);
|
|
2345 input_set_volume((gint) rint(((100 - b) / 100.0) * v), v);
|
|
2346 }
|
|
2347 mainwin_lock_info_text(balance_msg);
|
|
2348 g_free(balance_msg);
|
|
2349 }
|
|
2350
|
|
2351 void
|
|
2352 mainwin_adjust_balance_release(void)
|
|
2353 {
|
|
2354 mainwin_release_info_text();
|
|
2355 setting_volume = FALSE;
|
|
2356 read_volume(VOLUME_ADJUSTED);
|
|
2357 }
|
|
2358
|
|
2359 void
|
|
2360 mainwin_set_volume_slider(gint percent)
|
|
2361 {
|
|
2362 hslider_set_position(mainwin_volume, (gint) rint((percent * 51) / 100.0));
|
|
2363 }
|
|
2364
|
|
2365 void
|
|
2366 mainwin_set_balance_slider(gint percent)
|
|
2367 {
|
|
2368 hslider_set_position(mainwin_balance,
|
|
2369 (gint) rint(((percent * 12) / 100.0) + 12));
|
|
2370 }
|
|
2371
|
|
2372 void
|
|
2373 mainwin_volume_motion_cb(gint pos)
|
|
2374 {
|
|
2375 gint vol = (pos * 100) / 51;
|
|
2376 mainwin_adjust_volume_motion(vol);
|
|
2377 equalizerwin_set_volume_slider(vol);
|
|
2378 }
|
|
2379
|
|
2380 void
|
|
2381 mainwin_volume_release_cb(gint pos)
|
|
2382 {
|
|
2383 mainwin_adjust_volume_release();
|
|
2384 }
|
|
2385
|
|
2386 gint
|
|
2387 mainwin_balance_frame_cb(gint pos)
|
|
2388 {
|
|
2389 return ((abs(pos - 12) * 28) / 13);
|
|
2390 }
|
|
2391
|
|
2392 void
|
|
2393 mainwin_balance_motion_cb(gint pos)
|
|
2394 {
|
|
2395 gint bal = ((pos - 12) * 100) / 12;
|
|
2396 mainwin_adjust_balance_motion(bal);
|
|
2397 equalizerwin_set_balance_slider(bal);
|
|
2398 }
|
|
2399
|
|
2400 void
|
|
2401 mainwin_balance_release_cb(gint pos)
|
|
2402 {
|
|
2403 mainwin_adjust_volume_release();
|
|
2404 }
|
|
2405
|
|
2406 void
|
|
2407 mainwin_set_volume_diff(gint diff)
|
|
2408 {
|
|
2409 gint vl, vr, vol;
|
|
2410
|
|
2411 input_get_volume(&vl, &vr);
|
|
2412 vol = MAX(vl, vr);
|
|
2413 vol = CLAMP(vol + diff, 0, 100);
|
|
2414
|
|
2415 mainwin_adjust_volume_motion(vol);
|
|
2416 setting_volume = FALSE;
|
|
2417 mainwin_set_volume_slider(vol);
|
|
2418 equalizerwin_set_volume_slider(vol);
|
|
2419 read_volume(VOLUME_SET);
|
|
2420 }
|
|
2421
|
|
2422 void
|
|
2423 mainwin_set_balance_diff(gint diff)
|
|
2424 {
|
|
2425 gint b;
|
|
2426 b = CLAMP(balance + diff, -100, 100);
|
|
2427 mainwin_adjust_balance_motion(b);
|
|
2428 setting_volume = FALSE;
|
|
2429 mainwin_set_balance_slider(b);
|
|
2430 equalizerwin_set_balance_slider(b);
|
|
2431 read_volume(VOLUME_SET);
|
|
2432 }
|
|
2433
|
|
2434 void
|
|
2435 mainwin_show(gboolean show)
|
|
2436 {
|
|
2437 if (show)
|
|
2438 mainwin_real_show();
|
|
2439 else
|
|
2440 mainwin_real_hide();
|
|
2441 }
|
|
2442
|
|
2443 void
|
|
2444 mainwin_real_show(void)
|
|
2445 {
|
|
2446 cfg.player_visible = TRUE;
|
|
2447
|
|
2448 check_set( toggleaction_group_others , "show player" , TRUE );
|
|
2449
|
|
2450 if (cfg.player_shaded)
|
|
2451 vis_clear_data(active_vis);
|
|
2452
|
|
2453 mainwin_vis_set_active_vis(MAINWIN_VIS_ACTIVE_MAINWIN);
|
|
2454 mainwin_set_shape_mask();
|
|
2455
|
|
2456 if (cfg.show_wm_decorations) {
|
|
2457 if (!pposition_broken && cfg.player_x != -1
|
|
2458 && cfg.save_window_position)
|
|
2459 gtk_window_move(GTK_WINDOW(mainwin), cfg.player_x, cfg.player_y);
|
|
2460
|
|
2461 gtk_widget_show(mainwin);
|
|
2462
|
|
2463 if (pposition_broken && cfg.player_x != -1
|
|
2464 && cfg.save_window_position)
|
|
2465 gtk_window_move(GTK_WINDOW(mainwin), cfg.player_x, cfg.player_y);
|
|
2466
|
|
2467 return;
|
|
2468 }
|
|
2469
|
|
2470 gtk_widget_show_all(mainwin);
|
|
2471
|
|
2472 if (!nullmask)
|
|
2473 return;
|
|
2474
|
|
2475 g_object_unref(nullmask);
|
|
2476 nullmask = NULL;
|
|
2477
|
|
2478 gdk_window_set_hints(mainwin->window, 0, 0,
|
|
2479 !bmp_active_skin->properties.mainwin_width ? PLAYER_WIDTH :
|
|
2480 bmp_active_skin->properties.mainwin_width,
|
|
2481 !bmp_active_skin->properties.mainwin_height ? PLAYER_HEIGHT :
|
|
2482 bmp_active_skin->properties.mainwin_height,
|
|
2483 !bmp_active_skin->properties.mainwin_width ? PLAYER_WIDTH :
|
|
2484 bmp_active_skin->properties.mainwin_width,
|
|
2485 !bmp_active_skin->properties.mainwin_height ? PLAYER_HEIGHT :
|
|
2486 bmp_active_skin->properties.mainwin_height,
|
|
2487 GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
|
|
2488 gtk_window_resize(GTK_WINDOW(mainwin),
|
|
2489 !bmp_active_skin->properties.mainwin_width ? PLAYER_WIDTH :
|
|
2490 bmp_active_skin->properties.mainwin_width,
|
|
2491 !bmp_active_skin->properties.mainwin_height ? PLAYER_HEIGHT :
|
|
2492 bmp_active_skin->properties.mainwin_height);
|
|
2493 if (cfg.player_x != -1 && cfg.player_y != -1)
|
|
2494 gtk_window_move(GTK_WINDOW(mainwin), cfg.player_x, cfg.player_y);
|
|
2495
|
|
2496 draw_main_window(TRUE);
|
|
2497
|
|
2498 gtk_window_present(GTK_WINDOW(mainwin));
|
|
2499 }
|
|
2500
|
|
2501 void
|
|
2502 mainwin_real_hide(void)
|
|
2503 {
|
|
2504 GdkGC *gc;
|
|
2505 GdkColor pattern;
|
|
2506
|
|
2507 check_set( toggleaction_group_others , "show player", FALSE);
|
|
2508
|
|
2509 if (cfg.player_shaded)
|
|
2510 svis_clear_data(mainwin_svis);
|
|
2511
|
|
2512 if (!cfg.show_wm_decorations) {
|
|
2513 nullmask = gdk_pixmap_new(mainwin->window, 20, 20, 1);
|
|
2514 gc = gdk_gc_new(nullmask);
|
|
2515 pattern.pixel = 0;
|
|
2516 gdk_gc_set_foreground(gc, &pattern);
|
|
2517 gdk_draw_rectangle(nullmask, gc, TRUE, 0, 0, 20, 20);
|
|
2518 g_object_unref(gc);
|
|
2519 gtk_widget_shape_combine_mask(mainwin, nullmask, 0, 0);
|
|
2520
|
|
2521 gdk_window_set_hints(mainwin->window, 0, 0, 0, 0, 0, 0,
|
|
2522 GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
|
|
2523 gdk_window_resize(mainwin->window, 0, 0);
|
|
2524 }
|
|
2525
|
|
2526 gtk_widget_hide(mainwin);
|
|
2527
|
|
2528 mainwin_vis_set_active_vis(MAINWIN_VIS_ACTIVE_PLAYLISTWIN);
|
|
2529 cfg.player_visible = FALSE;
|
|
2530 }
|
|
2531
|
|
2532
|
|
2533 void
|
|
2534 mainwin_set_stopaftersong(gboolean stop)
|
|
2535 {
|
|
2536 cfg.stopaftersong = stop;
|
|
2537 check_set(toggleaction_group_others, "stop after current song", cfg.stopaftersong);
|
|
2538 }
|
|
2539
|
|
2540
|
|
2541 static void
|
|
2542 mainwin_set_doublesize(gboolean doublesize)
|
|
2543 {
|
|
2544 gint height;
|
|
2545
|
|
2546 if (cfg.player_shaded)
|
|
2547 height = MAINWIN_SHADED_HEIGHT;
|
|
2548 else
|
|
2549 height = bmp_active_skin->properties.mainwin_height;
|
|
2550
|
|
2551 mainwin_set_shape_mask();
|
|
2552
|
|
2553 dock_window_resize(GTK_WINDOW(mainwin), cfg.player_shaded ? MAINWIN_SHADED_WIDTH : bmp_active_skin->properties.mainwin_width,
|
|
2554 cfg.player_shaded ? MAINWIN_SHADED_HEIGHT : bmp_active_skin->properties.mainwin_height,
|
|
2555 bmp_active_skin->properties.mainwin_width * 2, bmp_active_skin->properties.mainwin_height * 2);
|
|
2556
|
|
2557 if (cfg.doublesize) {
|
|
2558 gdk_window_set_back_pixmap(mainwin->window, mainwin_bg_x2, 0);
|
|
2559 }
|
|
2560 else {
|
|
2561 gdk_window_set_back_pixmap(mainwin->window, mainwin_bg, 0);
|
|
2562 }
|
|
2563
|
|
2564 draw_main_window(TRUE);
|
|
2565 vis_set_doublesize(mainwin_vis, doublesize);
|
|
2566 }
|
|
2567
|
|
2568 void
|
|
2569 set_doublesize(gboolean doublesize)
|
|
2570 {
|
|
2571 cfg.doublesize = doublesize;
|
|
2572
|
|
2573 mainwin_set_doublesize(doublesize);
|
|
2574
|
|
2575 if (cfg.eq_doublesize_linked)
|
|
2576 equalizerwin_set_doublesize(doublesize);
|
|
2577 }
|
|
2578
|
|
2579
|
|
2580
|
|
2581 void
|
|
2582 mainwin_general_menu_callback(gpointer data,
|
|
2583 guint action,
|
|
2584 GtkWidget * item)
|
|
2585 {
|
|
2586 Playlist *playlist = playlist_get_active();
|
|
2587
|
|
2588 switch (action) {
|
|
2589 case MAINWIN_GENERAL_PREFS:
|
|
2590 show_prefs_window();
|
|
2591 break;
|
|
2592 case MAINWIN_GENERAL_ABOUT:
|
|
2593 show_about_window();
|
|
2594 break;
|
|
2595 case MAINWIN_GENERAL_PLAYFILE:
|
|
2596 util_run_filebrowser(NO_PLAY_BUTTON);
|
|
2597 break;
|
|
2598 case MAINWIN_GENERAL_PLAYCD:
|
|
2599 play_medium();
|
|
2600 break;
|
|
2601 case MAINWIN_GENERAL_ADDCD:
|
|
2602 add_medium();
|
|
2603 break;
|
|
2604 case MAINWIN_GENERAL_PLAYLOCATION:
|
|
2605 mainwin_show_add_url_window();
|
|
2606 break;
|
|
2607 case MAINWIN_GENERAL_FILEINFO:
|
|
2608 playlist_fileinfo_current(playlist);
|
|
2609 break;
|
|
2610 case MAINWIN_GENERAL_FOCUSPLWIN:
|
|
2611 gtk_window_present(GTK_WINDOW(playlistwin));
|
|
2612 break;
|
|
2613 case MAINWIN_GENERAL_SHOWMWIN:
|
|
2614 mainwin_show(GTK_CHECK_MENU_ITEM(item)->active);
|
|
2615 break;
|
|
2616 case MAINWIN_GENERAL_SHOWPLWIN:
|
|
2617 if (GTK_CHECK_MENU_ITEM(item)->active)
|
|
2618 playlistwin_show();
|
|
2619 else
|
|
2620 playlistwin_hide();
|
|
2621 break;
|
|
2622 case MAINWIN_GENERAL_SHOWEQWIN:
|
|
2623 if (GTK_CHECK_MENU_ITEM(item)->active)
|
|
2624 equalizerwin_real_show();
|
|
2625 else
|
|
2626 equalizerwin_real_hide();
|
|
2627 break;
|
|
2628 case MAINWIN_GENERAL_PREV:
|
|
2629 playlist_prev(playlist);
|
|
2630 break;
|
|
2631 case MAINWIN_GENERAL_PLAY:
|
|
2632 mainwin_play_pushed();
|
|
2633 break;
|
|
2634 case MAINWIN_GENERAL_PAUSE:
|
|
2635 playback_pause();
|
|
2636 break;
|
|
2637 case MAINWIN_GENERAL_STOP:
|
|
2638 mainwin_stop_pushed();
|
|
2639 break;
|
|
2640 case MAINWIN_GENERAL_NEXT:
|
|
2641 playlist_next(playlist);
|
|
2642 break;
|
|
2643 case MAINWIN_GENERAL_BACK5SEC:
|
|
2644 if (playback_get_playing()
|
|
2645 && playlist_get_current_length(playlist) != -1)
|
|
2646 playback_seek_relative(-5);
|
|
2647 break;
|
|
2648 case MAINWIN_GENERAL_FWD5SEC:
|
|
2649 if (playback_get_playing()
|
|
2650 && playlist_get_current_length(playlist) != -1)
|
|
2651 playback_seek_relative(5);
|
|
2652 break;
|
|
2653 case MAINWIN_GENERAL_START:
|
|
2654 playlist_set_position(playlist, 0);
|
|
2655 break;
|
|
2656 case MAINWIN_GENERAL_JTT:
|
|
2657 mainwin_jump_to_time();
|
|
2658 break;
|
|
2659 case MAINWIN_GENERAL_JTF:
|
|
2660 mainwin_jump_to_file();
|
|
2661 break;
|
|
2662 case MAINWIN_GENERAL_EXIT:
|
|
2663 mainwin_quit_cb();
|
|
2664 break;
|
|
2665 case MAINWIN_GENERAL_SETAB:
|
|
2666 if (playlist_get_current_length(playlist) != -1) {
|
|
2667 if (ab_position_a == -1) {
|
|
2668 ab_position_a = playback_get_time();
|
|
2669 ab_position_b = -1;
|
|
2670 mainwin_lock_info_text("LOOP-POINT A POSITION SET.");
|
|
2671 } else if (ab_position_b == -1) {
|
|
2672 int time = playback_get_time();
|
|
2673 if (time > ab_position_a)
|
|
2674 ab_position_b = time;
|
|
2675 mainwin_release_info_text();
|
|
2676 } else {
|
|
2677 ab_position_a = playback_get_time();
|
|
2678 ab_position_b = -1;
|
|
2679 mainwin_lock_info_text("LOOP-POINT A POSITION RESET.");
|
|
2680 }
|
|
2681 }
|
|
2682 break;
|
|
2683 case MAINWIN_GENERAL_CLEARAB:
|
|
2684 if (playlist_get_current_length(playlist) != -1) {
|
|
2685 ab_position_a = ab_position_b = -1;
|
|
2686 mainwin_release_info_text();
|
|
2687 }
|
|
2688 break;
|
|
2689 case MAINWIN_GENERAL_NEW_PL:
|
|
2690 {
|
|
2691 Playlist *new_pl = playlist_new();
|
|
2692 playlist_add_playlist(new_pl);
|
|
2693 playlist_select_playlist(new_pl);
|
|
2694 }
|
|
2695 break;
|
|
2696 case MAINWIN_GENERAL_PREV_PL:
|
|
2697 playlist_select_prev();
|
|
2698 break;
|
|
2699 case MAINWIN_GENERAL_NEXT_PL:
|
|
2700 playlist_select_next();
|
|
2701 break;
|
|
2702 }
|
|
2703 }
|
|
2704
|
|
2705 static void
|
|
2706 mainwin_mr_change(MenuRowItem i)
|
|
2707 {
|
|
2708 switch (i) {
|
|
2709 case MENUROW_NONE:
|
|
2710 mainwin_set_info_text();
|
|
2711 break;
|
|
2712 case MENUROW_OPTIONS:
|
|
2713 mainwin_lock_info_text(_("OPTIONS MENU"));
|
|
2714 break;
|
|
2715 case MENUROW_ALWAYS:
|
|
2716 if (mainwin_menurow->mr_always_selected)
|
|
2717 mainwin_lock_info_text(_("DISABLE ALWAYS ON TOP"));
|
|
2718 else
|
|
2719 mainwin_lock_info_text(_("ENABLE ALWAYS ON TOP"));
|
|
2720 break;
|
|
2721 case MENUROW_FILEINFOBOX:
|
|
2722 mainwin_lock_info_text(_("FILE INFO BOX"));
|
|
2723 break;
|
|
2724 case MENUROW_DOUBLESIZE:
|
|
2725 if (mainwin_menurow->mr_doublesize_selected)
|
|
2726 mainwin_lock_info_text(_("DISABLE DOUBLESIZE"));
|
|
2727 else
|
|
2728 mainwin_lock_info_text(_("ENABLE DOUBLESIZE"));
|
|
2729 break;
|
|
2730 case MENUROW_VISUALIZATION:
|
|
2731 mainwin_lock_info_text(_("VISUALIZATION MENU"));
|
|
2732 break;
|
|
2733 }
|
|
2734 }
|
|
2735
|
|
2736 static void
|
|
2737 mainwin_mr_release(MenuRowItem i)
|
|
2738 {
|
|
2739 GdkModifierType modmask;
|
|
2740 GtkWidget *widget;
|
|
2741 gint x, y;
|
|
2742
|
|
2743 switch (i) {
|
|
2744 case MENUROW_OPTIONS:
|
|
2745 gdk_window_get_pointer(NULL, &x, &y, &modmask);
|
|
2746 ui_manager_popup_menu_show(GTK_MENU(mainwin_view_menu), x, y, 1,
|
|
2747 GDK_CURRENT_TIME);
|
|
2748 break;
|
|
2749 case MENUROW_ALWAYS:
|
|
2750 gtk_toggle_action_set_active(
|
|
2751 GTK_TOGGLE_ACTION(gtk_action_group_get_action(
|
|
2752 toggleaction_group_others , "view always on top" )) ,
|
|
2753 mainwin_menurow->mr_always_selected );
|
|
2754 break;
|
|
2755 case MENUROW_FILEINFOBOX:
|
|
2756 playlist_fileinfo_current(playlist_get_active());
|
|
2757 break;
|
|
2758 case MENUROW_DOUBLESIZE:
|
|
2759 gtk_toggle_action_set_active(
|
|
2760 GTK_TOGGLE_ACTION(gtk_action_group_get_action(
|
|
2761 toggleaction_group_others , "view doublesize" )) ,
|
|
2762 mainwin_menurow->mr_doublesize_selected );
|
|
2763 break;
|
|
2764 case MENUROW_VISUALIZATION:
|
|
2765 gdk_window_get_pointer(NULL, &x, &y, &modmask);
|
|
2766 ui_manager_popup_menu_show(GTK_MENU(mainwin_visualization_menu), x, y, 1, GDK_CURRENT_TIME);
|
|
2767 break;
|
|
2768 case MENUROW_NONE:
|
|
2769 break;
|
|
2770 }
|
|
2771 mainwin_release_info_text();
|
|
2772 }
|
|
2773
|
|
2774 static void
|
|
2775 run_no_audiocd_dialog(void)
|
|
2776 {
|
|
2777 const gchar *markup =
|
|
2778 N_("<b><big>No playable CD found.</big></b>\n\n"
|
|
2779 "No CD inserted, or inserted CD is not an audio CD.\n");
|
|
2780
|
|
2781 GtkWidget *dialog =
|
|
2782 gtk_message_dialog_new_with_markup(GTK_WINDOW(mainwin),
|
|
2783 GTK_DIALOG_DESTROY_WITH_PARENT,
|
|
2784 GTK_MESSAGE_ERROR,
|
|
2785 GTK_BUTTONS_OK,
|
|
2786 _(markup));
|
|
2787 gtk_dialog_run(GTK_DIALOG(dialog));
|
|
2788 gtk_widget_destroy(dialog);
|
|
2789 }
|
|
2790
|
|
2791 static void
|
|
2792 run_no_output_device_dialog(void)
|
|
2793 {
|
|
2794 const gchar *markup =
|
|
2795 N_("<b><big>Couldn't open audio.</big></b>\n\n"
|
|
2796 "Please check that:\n"
|
|
2797 "1. You have the correct output plugin selected.\n"
|
|
2798 "2. No other programs is blocking the soundcard.\n"
|
|
2799 "3. Your soundcard is configured properly.\n");
|
|
2800
|
|
2801 GtkWidget *dialog =
|
|
2802 gtk_message_dialog_new_with_markup(GTK_WINDOW(mainwin),
|
|
2803 GTK_DIALOG_DESTROY_WITH_PARENT,
|
|
2804 GTK_MESSAGE_ERROR,
|
|
2805 GTK_BUTTONS_OK,
|
|
2806 _(markup));
|
|
2807 gtk_dialog_run(GTK_DIALOG(dialog));
|
|
2808 gtk_widget_destroy(dialog);
|
|
2809 }
|
|
2810
|
|
2811
|
|
2812 void
|
|
2813 add_medium(void)
|
|
2814 {
|
|
2815 GList *list, *node;
|
|
2816 gchar *filename;
|
|
2817 gchar *path;
|
|
2818 ConfigDb *db;
|
|
2819
|
|
2820 db = bmp_cfg_db_open();
|
|
2821
|
|
2822 bmp_cfg_db_get_string(db, "CDDA", "directory", &path);
|
|
2823 bmp_cfg_db_close(db);
|
|
2824
|
|
2825 if (!(list = input_scan_dir(path))) {
|
|
2826 run_no_audiocd_dialog();
|
|
2827 return;
|
|
2828 }
|
|
2829
|
|
2830 for (node = list; node; node = g_list_next(node)) {
|
|
2831 filename = g_build_filename(path, node->data, NULL);
|
|
2832 playlist_add(playlist_get_active(), filename);
|
|
2833 g_free(filename);
|
|
2834 g_free(node->data);
|
|
2835 }
|
|
2836
|
|
2837 g_free(path);
|
|
2838 g_list_free(list);
|
|
2839
|
|
2840 }
|
|
2841
|
|
2842 void
|
|
2843 play_medium(void)
|
|
2844 {
|
|
2845 GList *list, *node;
|
|
2846 gchar *filename;
|
|
2847 gchar *path;
|
|
2848 ConfigDb *db;
|
|
2849 Playlist *playlist = playlist_get_active();
|
|
2850
|
|
2851 db = bmp_cfg_db_open();
|
|
2852 bmp_cfg_db_get_string(db, "CDDA", "directory", &path);
|
|
2853 bmp_cfg_db_close(db);
|
|
2854
|
|
2855 if (!(list = input_scan_dir(path))) {
|
|
2856 run_no_audiocd_dialog();
|
|
2857 return;
|
|
2858 }
|
|
2859
|
|
2860 playlist_clear(playlist);
|
|
2861
|
|
2862 for (node = list; node; node = g_list_next(node)) {
|
|
2863 filename = g_build_filename(path, node->data, NULL);
|
|
2864 playlist_add(playlist, filename);
|
|
2865 g_free(filename);
|
|
2866 g_free(node->data);
|
|
2867 }
|
|
2868
|
|
2869 g_free(path);
|
|
2870 g_list_free(list);
|
|
2871
|
|
2872 playlist_set_position(playlist, 0);
|
|
2873 playback_initiate();
|
|
2874 }
|
|
2875
|
|
2876 void
|
|
2877 read_volume(gint when)
|
|
2878 {
|
|
2879 static gint pvl = 0, pvr = 0;
|
|
2880 static gint times = VOLSET_DISP_TIMES;
|
|
2881 static gboolean changing = FALSE;
|
|
2882
|
|
2883 gint vl, vr, b, v;
|
|
2884
|
|
2885 input_get_volume(&vl, &vr);
|
|
2886
|
|
2887 switch (when) {
|
|
2888 case VOLSET_STARTUP:
|
|
2889 vl = CLAMP(vl, 0, 100);
|
|
2890 vr = CLAMP(vr, 0, 100);
|
|
2891 pvl = vl;
|
|
2892 pvr = vr;
|
|
2893 v = MAX(vl, vr);
|
|
2894 if (vl > vr)
|
|
2895 b = (gint) rint(((gdouble) vr / vl) * 100) - 100;
|
|
2896 else if (vl < vr)
|
|
2897 b = 100 - (gint) rint(((gdouble) vl / vr) * 100);
|
|
2898 else
|
|
2899 b = 0;
|
|
2900
|
|
2901 balance = b;
|
|
2902 mainwin_set_volume_slider(v);
|
|
2903 equalizerwin_set_volume_slider(v);
|
|
2904 mainwin_set_balance_slider(b);
|
|
2905 equalizerwin_set_balance_slider(b);
|
|
2906 return;
|
|
2907
|
|
2908 case VOLSET_UPDATE:
|
|
2909 if (vl == -1 || vr == -1)
|
|
2910 return;
|
|
2911
|
|
2912 if (setting_volume) {
|
|
2913 pvl = vl;
|
|
2914 pvr = vr;
|
|
2915 return;
|
|
2916 }
|
|
2917
|
|
2918 if (pvr == vr && pvl == vl && changing) {
|
|
2919 if (times < VOLSET_DISP_TIMES)
|
|
2920 times++;
|
|
2921 else {
|
|
2922 mainwin_release_info_text();
|
|
2923 changing = FALSE;
|
|
2924 }
|
|
2925 }
|
|
2926 else if (pvr != vr || pvl != vl) {
|
|
2927 gchar *tmp;
|
|
2928
|
|
2929 v = MAX(vl, vr);
|
|
2930 if (vl > vr)
|
|
2931 b = (gint) rint(((gdouble) vr / vl) * 100) - 100;
|
|
2932 else if (vl < vr)
|
|
2933 b = 100 - (gint) rint(((gdouble) vl / vr) * 100);
|
|
2934 else
|
|
2935 b = 0;
|
|
2936
|
|
2937 if (MAX(vl, vr) != MAX(pvl, pvr))
|
|
2938 tmp = g_strdup_printf(_("VOLUME: %d%%"), v);
|
|
2939 else {
|
|
2940 if (vl > vr) {
|
|
2941 tmp = g_strdup_printf(_("BALANCE: %d%% LEFT"), -b);
|
|
2942 }
|
|
2943 else if (vr == vl)
|
|
2944 tmp = g_strdup_printf(_("BALANCE: CENTER"));
|
|
2945 else { /* (vl < vr) */
|
|
2946 tmp = g_strdup_printf(_("BALANCE: %d%% RIGHT"), b);
|
|
2947 }
|
|
2948 }
|
|
2949 mainwin_lock_info_text(tmp);
|
|
2950 g_free(tmp);
|
|
2951
|
|
2952 pvr = vr;
|
|
2953 pvl = vl;
|
|
2954 times = 0;
|
|
2955 changing = TRUE;
|
|
2956 mainwin_set_volume_slider(v);
|
|
2957 equalizerwin_set_volume_slider(v);
|
|
2958
|
|
2959 /* Don't change the balance slider if the volume has been
|
|
2960 * set to zero. The balance can be anything, and our best
|
|
2961 * guess is what is was before. */
|
|
2962 if (v > 0) {
|
|
2963 balance = b;
|
|
2964 mainwin_set_balance_slider(b);
|
|
2965 equalizerwin_set_balance_slider(b);
|
|
2966 }
|
|
2967 }
|
|
2968 break;
|
|
2969
|
|
2970 case VOLUME_ADJUSTED:
|
|
2971 pvl = vl;
|
|
2972 pvr = vr;
|
|
2973 break;
|
|
2974
|
|
2975 case VOLUME_SET:
|
|
2976 times = 0;
|
|
2977 changing = TRUE;
|
|
2978 pvl = vl;
|
|
2979 pvr = vr;
|
|
2980 break;
|
|
2981 }
|
|
2982 }
|
|
2983
|
|
2984
|
|
2985 /* TODO: HAL! */
|
|
2986 gboolean
|
|
2987 can_play_cd(void)
|
|
2988 {
|
|
2989 GList *ilist;
|
|
2990
|
|
2991 for (ilist = get_input_list(); ilist; ilist = g_list_next(ilist)) {
|
|
2992 InputPlugin *ip = INPUT_PLUGIN(ilist->data);
|
|
2993
|
|
2994 if (!g_ascii_strcasecmp(g_basename(ip->filename),
|
|
2995 PLUGIN_FILENAME("cdaudio"))) {
|
|
2996 return TRUE;
|
|
2997 }
|
|
2998 }
|
|
2999
|
|
3000 return FALSE;
|
|
3001 }
|
|
3002
|
|
3003
|
|
3004 static void
|
|
3005 set_timer_mode(TimerMode mode)
|
|
3006 {
|
|
3007 if (mode == TIMER_ELAPSED)
|
|
3008 check_set(radioaction_group_viewtime, "view time elapsed", TRUE);
|
|
3009 else
|
|
3010 check_set(radioaction_group_viewtime, "view time remaining", TRUE);
|
|
3011 }
|
|
3012
|
|
3013 static void
|
|
3014 set_timer_mode_menu_cb(TimerMode mode)
|
|
3015 {
|
|
3016 cfg.timer_mode = mode;
|
|
3017 }
|
|
3018
|
|
3019 static void
|
|
3020 mainwin_playlist_prev(void)
|
|
3021 {
|
|
3022 playlist_prev(playlist_get_active());
|
|
3023 }
|
|
3024
|
|
3025 static void
|
|
3026 mainwin_playlist_next(void)
|
|
3027 {
|
|
3028 playlist_next(playlist_get_active());
|
|
3029 }
|
|
3030
|
|
3031 void
|
|
3032 mainwin_setup_menus(void)
|
|
3033 {
|
|
3034 set_timer_mode(cfg.timer_mode);
|
|
3035
|
|
3036 /* View menu */
|
|
3037
|
|
3038 check_set(toggleaction_group_others, "view always on top", cfg.always_on_top);
|
|
3039 check_set(toggleaction_group_others, "view put on all workspaces", cfg.sticky);
|
|
3040 check_set(toggleaction_group_others, "roll up player", cfg.player_shaded);
|
|
3041 check_set(toggleaction_group_others, "roll up playlist editor", cfg.playlist_shaded);
|
|
3042 check_set(toggleaction_group_others, "roll up equalizer", cfg.equalizer_shaded);
|
|
3043 check_set(toggleaction_group_others, "view easy move", cfg.easy_move);
|
|
3044 check_set(toggleaction_group_others, "view doublesize", cfg.doublesize);
|
|
3045
|
|
3046 /* Songname menu */
|
|
3047
|
|
3048 check_set(toggleaction_group_others, "autoscroll songname", cfg.autoscroll);
|
|
3049 check_set(toggleaction_group_others, "stop after current song", cfg.stopaftersong);
|
|
3050
|
|
3051 /* Playback menu */
|
|
3052
|
|
3053 check_set(toggleaction_group_others, "playback repeat", cfg.repeat);
|
|
3054 check_set(toggleaction_group_others, "playback shuffle", cfg.shuffle);
|
|
3055 check_set(toggleaction_group_others, "playback no playlist advance", cfg.no_playlist_advance);
|
|
3056
|
|
3057 /* Visualization menu */
|
|
3058
|
|
3059 switch ( cfg.vis_type )
|
|
3060 {
|
|
3061 case VIS_ANALYZER:
|
|
3062 check_set(radioaction_group_vismode, "vismode analyzer", TRUE);
|
|
3063 break;
|
|
3064 case VIS_SCOPE:
|
|
3065 check_set(radioaction_group_vismode, "vismode scope", TRUE);
|
|
3066 break;
|
|
3067 case VIS_VOICEPRINT:
|
|
3068 check_set(radioaction_group_vismode, "vismode voiceprint", TRUE);
|
|
3069 break;
|
|
3070 case VIS_OFF:
|
|
3071 default:
|
|
3072 check_set(radioaction_group_vismode, "vismode off", TRUE);
|
|
3073 break;
|
|
3074 }
|
|
3075
|
|
3076 switch ( cfg.analyzer_mode )
|
|
3077 {
|
|
3078 case ANALYZER_FIRE:
|
|
3079 check_set(radioaction_group_anamode, "anamode fire", TRUE);
|
|
3080 break;
|
|
3081 case ANALYZER_VLINES:
|
|
3082 check_set(radioaction_group_anamode, "anamode vertical lines", TRUE);
|
|
3083 break;
|
|
3084 case ANALYZER_NORMAL:
|
|
3085 default:
|
|
3086 check_set(radioaction_group_anamode, "anamode normal", TRUE);
|
|
3087 break;
|
|
3088 }
|
|
3089
|
|
3090 switch ( cfg.analyzer_type )
|
|
3091 {
|
|
3092 case ANALYZER_BARS:
|
|
3093 check_set(radioaction_group_anatype, "anatype bars", TRUE);
|
|
3094 break;
|
|
3095 case ANALYZER_LINES:
|
|
3096 default:
|
|
3097 check_set(radioaction_group_anatype, "anatype lines", TRUE);
|
|
3098 break;
|
|
3099 }
|
|
3100
|
|
3101 check_set(toggleaction_group_others, "anamode peaks", cfg.analyzer_peaks );
|
|
3102
|
|
3103 switch ( cfg.scope_mode )
|
|
3104 {
|
|
3105 case SCOPE_LINE:
|
|
3106 check_set(radioaction_group_scomode, "scomode line", TRUE);
|
|
3107 break;
|
|
3108 case SCOPE_SOLID:
|
|
3109 check_set(radioaction_group_scomode, "scomode solid", TRUE);
|
|
3110 break;
|
|
3111 case SCOPE_DOT:
|
|
3112 default:
|
|
3113 check_set(radioaction_group_scomode, "scomode dot", TRUE);
|
|
3114 break;
|
|
3115 }
|
|
3116
|
|
3117 switch ( cfg.voiceprint_mode )
|
|
3118 {
|
|
3119 case VOICEPRINT_FIRE:
|
|
3120 check_set(radioaction_group_vprmode, "vprmode fire", TRUE);
|
|
3121 break;
|
|
3122 case VOICEPRINT_ICE:
|
|
3123 check_set(radioaction_group_vprmode, "vprmode ice", TRUE);
|
|
3124 break;
|
|
3125 case VOICEPRINT_NORMAL:
|
|
3126 default:
|
|
3127 check_set(radioaction_group_vprmode, "vprmode normal", TRUE);
|
|
3128 break;
|
|
3129 }
|
|
3130
|
|
3131 switch ( cfg.vu_mode )
|
|
3132 {
|
|
3133 case VU_SMOOTH:
|
|
3134 check_set(radioaction_group_wshmode, "wshmode smooth", TRUE);
|
|
3135 break;
|
|
3136 case VU_NORMAL:
|
|
3137 default:
|
|
3138 check_set(radioaction_group_wshmode, "wshmode normal", TRUE);
|
|
3139 break;
|
|
3140 }
|
|
3141
|
|
3142 switch ( cfg.vis_refresh )
|
|
3143 {
|
|
3144 case REFRESH_HALF:
|
|
3145 check_set(radioaction_group_refrate, "refrate half", TRUE);
|
|
3146 break;
|
|
3147 case REFRESH_QUARTER:
|
|
3148 check_set(radioaction_group_refrate, "refrate quarter", TRUE);
|
|
3149 break;
|
|
3150 case REFRESH_EIGTH:
|
|
3151 check_set(radioaction_group_refrate, "refrate eighth", TRUE);
|
|
3152 break;
|
|
3153 case REFRESH_FULL:
|
|
3154 default:
|
|
3155 check_set(radioaction_group_refrate, "refrate full", TRUE);
|
|
3156 break;
|
|
3157 }
|
|
3158
|
|
3159 switch ( cfg.analyzer_falloff )
|
|
3160 {
|
|
3161 case FALLOFF_SLOW:
|
|
3162 check_set(radioaction_group_anafoff, "anafoff slow", TRUE);
|
|
3163 break;
|
|
3164 case FALLOFF_MEDIUM:
|
|
3165 check_set(radioaction_group_anafoff, "anafoff medium", TRUE);
|
|
3166 break;
|
|
3167 case FALLOFF_FAST:
|
|
3168 check_set(radioaction_group_anafoff, "anafoff fast", TRUE);
|
|
3169 break;
|
|
3170 case FALLOFF_FASTEST:
|
|
3171 check_set(radioaction_group_anafoff, "anafoff fastest", TRUE);
|
|
3172 break;
|
|
3173 case FALLOFF_SLOWEST:
|
|
3174 default:
|
|
3175 check_set(radioaction_group_anafoff, "anafoff slowest", TRUE);
|
|
3176 break;
|
|
3177 }
|
|
3178
|
|
3179 switch ( cfg.peaks_falloff )
|
|
3180 {
|
|
3181 case FALLOFF_SLOW:
|
|
3182 check_set(radioaction_group_peafoff, "peafoff slow", TRUE);
|
|
3183 break;
|
|
3184 case FALLOFF_MEDIUM:
|
|
3185 check_set(radioaction_group_peafoff, "peafoff medium", TRUE);
|
|
3186 break;
|
|
3187 case FALLOFF_FAST:
|
|
3188 check_set(radioaction_group_peafoff, "peafoff fast", TRUE);
|
|
3189 break;
|
|
3190 case FALLOFF_FASTEST:
|
|
3191 check_set(radioaction_group_peafoff, "peafoff fastest", TRUE);
|
|
3192 break;
|
|
3193 case FALLOFF_SLOWEST:
|
|
3194 default:
|
|
3195 check_set(radioaction_group_peafoff, "peafoff slowest", TRUE);
|
|
3196 break;
|
|
3197 }
|
|
3198
|
|
3199 }
|
|
3200
|
|
3201 static void
|
|
3202 mainwin_create_widgets(void)
|
|
3203 {
|
|
3204 mainwin_menubtn =
|
|
3205 create_pbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 6, 3, 9, 9,
|
|
3206 0, 0, 0, 9, mainwin_menubtn_cb, SKIN_TITLEBAR);
|
|
3207 mainwin_menubtn->pb_allow_draw = FALSE;
|
|
3208 mainwin_minimize =
|
|
3209 create_pbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 244, 3, 9,
|
|
3210 9, 9, 0, 9, 9, mainwin_minimize_cb, SKIN_TITLEBAR);
|
|
3211 mainwin_minimize->pb_allow_draw = FALSE;
|
|
3212 mainwin_shade =
|
|
3213 create_pbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 254, 3, 9,
|
|
3214 9, 0, cfg.player_shaded ? 27 : 18, 9,
|
|
3215 cfg.player_shaded ? 27 : 18, mainwin_shade_toggle,
|
|
3216 SKIN_TITLEBAR);
|
|
3217 mainwin_shade->pb_allow_draw = FALSE;
|
|
3218 mainwin_close =
|
|
3219 create_pbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 264, 3, 9,
|
|
3220 9, 18, 0, 18, 9, mainwin_quit_cb, SKIN_TITLEBAR);
|
|
3221 mainwin_close->pb_allow_draw = FALSE;
|
|
3222
|
|
3223 mainwin_rew =
|
|
3224 create_pbutton_ex(&mainwin_wlist, mainwin_bg, mainwin_gc, 16, 88, 23,
|
|
3225 18, 0, 0, 0, 18, mainwin_rev_pushed, mainwin_rev_release,
|
|
3226 SKIN_CBUTTONS, SKIN_CBUTTONS);
|
|
3227 mainwin_play =
|
|
3228 create_pbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 39, 88, 23,
|
|
3229 18, 23, 0, 23, 18, mainwin_play_pushed, SKIN_CBUTTONS);
|
|
3230 mainwin_pause =
|
|
3231 create_pbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 62, 88, 23,
|
|
3232 18, 46, 0, 46, 18, playback_pause, SKIN_CBUTTONS);
|
|
3233 mainwin_stop =
|
|
3234 create_pbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 85, 88, 23,
|
|
3235 18, 69, 0, 69, 18, mainwin_stop_pushed, SKIN_CBUTTONS);
|
|
3236 #if 0
|
|
3237 mainwin_fwd =
|
|
3238 create_pbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 108, 88, 22,
|
|
3239 18, 92, 0, 92, 18, playlist_next, SKIN_CBUTTONS);
|
|
3240 #endif
|
|
3241 mainwin_fwd =
|
|
3242 create_pbutton_ex(&mainwin_wlist, mainwin_bg, mainwin_gc, 108, 88, 22,
|
|
3243 18, 92, 0, 92, 18, mainwin_fwd_pushed, mainwin_fwd_release,
|
|
3244 SKIN_CBUTTONS, SKIN_CBUTTONS);
|
|
3245
|
|
3246 mainwin_eject =
|
|
3247 create_pbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 136, 89, 22,
|
|
3248 16, 114, 0, 114, 16, mainwin_eject_pushed,
|
|
3249 SKIN_CBUTTONS);
|
|
3250
|
|
3251 mainwin_srew =
|
|
3252 create_sbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 169, 4, 8,
|
|
3253 7, mainwin_playlist_prev);
|
|
3254 mainwin_splay =
|
|
3255 create_sbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 177, 4, 10,
|
|
3256 7, mainwin_play_pushed);
|
|
3257 mainwin_spause =
|
|
3258 create_sbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 187, 4, 10,
|
|
3259 7, playback_pause);
|
|
3260 mainwin_sstop =
|
|
3261 create_sbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 197, 4, 9,
|
|
3262 7, mainwin_stop_pushed);
|
|
3263 mainwin_sfwd =
|
|
3264 create_sbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 206, 4, 8,
|
|
3265 7, mainwin_playlist_next);
|
|
3266 mainwin_seject =
|
|
3267 create_sbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 216, 4, 9,
|
|
3268 7, mainwin_eject_pushed);
|
|
3269
|
|
3270 mainwin_shuffle =
|
|
3271 create_tbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 164, 89, 46,
|
|
3272 15, 28, 0, 28, 15, 28, 30, 28, 45,
|
|
3273 mainwin_shuffle_pushed, SKIN_SHUFREP);
|
|
3274
|
|
3275 mainwin_repeat =
|
|
3276 create_tbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 210, 89, 28,
|
|
3277 15, 0, 0, 0, 15, 0, 30, 0, 45,
|
|
3278 mainwin_repeat_pushed, SKIN_SHUFREP);
|
|
3279
|
|
3280 mainwin_eq =
|
|
3281 create_tbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 219, 58, 23,
|
|
3282 12, 0, 61, 46, 61, 0, 73, 46, 73, equalizerwin_show,
|
|
3283 SKIN_SHUFREP);
|
|
3284 tbutton_set_toggled(mainwin_eq, cfg.equalizer_visible);
|
|
3285 mainwin_pl =
|
|
3286 create_tbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 242, 58, 23,
|
|
3287 12, 23, 61, 69, 61, 23, 73, 69, 73,
|
|
3288 mainwin_pl_pushed, SKIN_SHUFREP);
|
|
3289 tbutton_set_toggled(mainwin_pl, cfg.playlist_visible);
|
|
3290
|
|
3291 mainwin_info =
|
|
3292 create_textbox(&mainwin_wlist, mainwin_bg, mainwin_gc, 112, 27,
|
|
3293 153, 1, SKIN_TEXT);
|
|
3294 textbox_set_scroll(mainwin_info, cfg.autoscroll);
|
|
3295 textbox_set_xfont(mainwin_info, cfg.mainwin_use_xfont, cfg.mainwin_font);
|
|
3296
|
|
3297 mainwin_othertext =
|
|
3298 create_textbox(&mainwin_wlist, mainwin_bg, mainwin_gc, 112, 43,
|
|
3299 153, 1, SKIN_TEXT);
|
|
3300
|
|
3301 mainwin_rate_text =
|
|
3302 create_textbox(&mainwin_wlist, mainwin_bg, mainwin_gc, 111, 43, 15,
|
|
3303 0, SKIN_TEXT);
|
|
3304 mainwin_freq_text =
|
|
3305 create_textbox(&mainwin_wlist, mainwin_bg, mainwin_gc, 156, 43, 10,
|
|
3306 0, SKIN_TEXT);
|
|
3307
|
|
3308 mainwin_menurow =
|
|
3309 create_menurow(&mainwin_wlist, mainwin_bg, mainwin_gc, 10, 22, 304,
|
|
3310 0, 304, 44, mainwin_mr_change, mainwin_mr_release,
|
|
3311 SKIN_TITLEBAR);
|
|
3312 mainwin_menurow->mr_doublesize_selected = cfg.doublesize;
|
|
3313 mainwin_menurow->mr_always_selected = cfg.always_on_top;
|
|
3314
|
|
3315 mainwin_volume =
|
|
3316 create_hslider(&mainwin_wlist, mainwin_bg, mainwin_gc, 107, 57, 68,
|
|
3317 13, 15, 422, 0, 422, 14, 11, 15, 0, 0, 51,
|
|
3318 mainwin_volume_frame_cb, mainwin_volume_motion_cb,
|
|
3319 mainwin_volume_release_cb, SKIN_VOLUME);
|
|
3320 mainwin_balance =
|
|
3321 create_hslider(&mainwin_wlist, mainwin_bg, mainwin_gc, 177, 57, 38,
|
|
3322 13, 15, 422, 0, 422, 14, 11, 15, 9, 0, 24,
|
|
3323 mainwin_balance_frame_cb, mainwin_balance_motion_cb,
|
|
3324 mainwin_balance_release_cb, SKIN_BALANCE);
|
|
3325
|
|
3326 mainwin_monostereo =
|
|
3327 create_monostereo(&mainwin_wlist, mainwin_bg, mainwin_gc, 212, 41,
|
|
3328 SKIN_MONOSTEREO);
|
|
3329
|
|
3330 mainwin_playstatus =
|
|
3331 create_playstatus(&mainwin_wlist, mainwin_bg, mainwin_gc, 24, 28);
|
|
3332
|
|
3333 mainwin_minus_num =
|
|
3334 create_number(&mainwin_wlist, mainwin_bg, mainwin_gc, 36, 26,
|
|
3335 SKIN_NUMBERS);
|
|
3336 widget_hide(WIDGET(mainwin_minus_num));
|
|
3337 mainwin_10min_num =
|
|
3338 create_number(&mainwin_wlist, mainwin_bg, mainwin_gc, 48, 26,
|
|
3339 SKIN_NUMBERS);
|
|
3340 widget_hide(WIDGET(mainwin_10min_num));
|
|
3341
|
|
3342 mainwin_min_num =
|
|
3343 create_number(&mainwin_wlist, mainwin_bg, mainwin_gc, 60, 26,
|
|
3344 SKIN_NUMBERS);
|
|
3345 widget_hide(WIDGET(mainwin_min_num));
|
|
3346
|
|
3347 mainwin_10sec_num =
|
|
3348 create_number(&mainwin_wlist, mainwin_bg, mainwin_gc, 78, 26,
|
|
3349 SKIN_NUMBERS);
|
|
3350 widget_hide(WIDGET(mainwin_10sec_num));
|
|
3351
|
|
3352 mainwin_sec_num =
|
|
3353 create_number(&mainwin_wlist, mainwin_bg, mainwin_gc, 90, 26,
|
|
3354 SKIN_NUMBERS);
|
|
3355 widget_hide(WIDGET(mainwin_sec_num));
|
|
3356
|
|
3357 mainwin_about =
|
|
3358 create_sbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 247, 83, 20,
|
|
3359 25, show_about_window);
|
|
3360
|
|
3361 mainwin_vis =
|
|
3362 create_vis(&mainwin_wlist, mainwin_bg, mainwin->window, mainwin_gc,
|
|
3363 24, 43, 76, cfg.doublesize);
|
|
3364 mainwin_svis = create_svis(&mainwin_wlist, mainwin_bg, mainwin_gc, 79, 5);
|
|
3365 active_vis = mainwin_vis;
|
|
3366
|
|
3367 mainwin_position =
|
|
3368 create_hslider(&mainwin_wlist, mainwin_bg, mainwin_gc, 16, 72, 248,
|
|
3369 10, 248, 0, 278, 0, 29, 10, 10, 0, 0, 219, NULL,
|
|
3370 mainwin_position_motion_cb,
|
|
3371 mainwin_position_release_cb, SKIN_POSBAR);
|
|
3372 widget_hide(WIDGET(mainwin_position));
|
|
3373
|
|
3374 mainwin_sposition =
|
|
3375 create_hslider(&mainwin_wlist, mainwin_bg, mainwin_gc, 226, 4, 17,
|
|
3376 7, 17, 36, 17, 36, 3, 7, 36, 0, 1, 13,
|
|
3377 mainwin_spos_frame_cb, mainwin_spos_motion_cb,
|
|
3378 mainwin_spos_release_cb, SKIN_TITLEBAR);
|
|
3379 widget_hide(WIDGET(mainwin_sposition));
|
|
3380
|
|
3381 mainwin_stime_min =
|
|
3382 create_textbox(&mainwin_wlist, mainwin_bg, mainwin_gc, 130, 4, 15,
|
|
3383 FALSE, SKIN_TEXT);
|
|
3384 mainwin_stime_sec =
|
|
3385 create_textbox(&mainwin_wlist, mainwin_bg, mainwin_gc, 147, 4, 10,
|
|
3386 FALSE, SKIN_TEXT);
|
|
3387
|
|
3388 if (!cfg.player_shaded) {
|
|
3389 widget_hide(WIDGET(mainwin_svis));
|
|
3390 widget_hide(WIDGET(mainwin_srew));
|
|
3391 widget_hide(WIDGET(mainwin_splay));
|
|
3392 widget_hide(WIDGET(mainwin_spause));
|
|
3393 widget_hide(WIDGET(mainwin_sstop));
|
|
3394 widget_hide(WIDGET(mainwin_sfwd));
|
|
3395 widget_hide(WIDGET(mainwin_seject));
|
|
3396 widget_hide(WIDGET(mainwin_stime_min));
|
|
3397 widget_hide(WIDGET(mainwin_stime_sec));
|
|
3398 }
|
|
3399
|
|
3400 err = gtk_message_dialog_new(GTK_WINDOW(mainwin), GTK_DIALOG_DESTROY_WITH_PARENT|GTK_DIALOG_MODAL,
|
|
3401 GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, _("Error in Audacious."));
|
|
3402
|
|
3403
|
|
3404 gtk_window_set_position(GTK_WINDOW(err), GTK_WIN_POS_CENTER);
|
|
3405 /* Dang well better set an error message or you'll see this */
|
|
3406 gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(err),
|
|
3407 "Boo! Bad stuff! Booga Booga!");
|
|
3408
|
|
3409 }
|
|
3410
|
|
3411 static void
|
|
3412 mainwin_create_window(void)
|
|
3413 {
|
|
3414 gint width, height;
|
|
3415
|
|
3416 mainwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
|
3417 gtk_window_set_title(GTK_WINDOW(mainwin), _("Audacious"));
|
|
3418 gtk_window_set_role(GTK_WINDOW(mainwin), "player");
|
|
3419 gtk_window_set_resizable(GTK_WINDOW(mainwin), FALSE);
|
|
3420
|
|
3421 width = cfg.player_shaded ? MAINWIN_SHADED_WIDTH : bmp_active_skin->properties.mainwin_width;
|
|
3422 height = cfg.player_shaded ? MAINWIN_SHADED_HEIGHT : bmp_active_skin->properties.mainwin_height;
|
|
3423
|
|
3424 if (cfg.doublesize) {
|
|
3425 width *= 2;
|
|
3426 height *= 2;
|
|
3427 }
|
|
3428
|
|
3429 gtk_widget_set_size_request(mainwin, width, height);
|
|
3430 gtk_widget_set_app_paintable(mainwin, TRUE);
|
|
3431
|
|
3432 dock_window_list = dock_window_set_decorated(dock_window_list,
|
|
3433 GTK_WINDOW(mainwin),
|
|
3434 cfg.show_wm_decorations);
|
|
3435
|
|
3436 if (cfg.player_x != -1 && cfg.save_window_position)
|
|
3437 gtk_window_move(GTK_WINDOW(mainwin), cfg.player_x, cfg.player_y);
|
|
3438
|
|
3439 gtk_widget_add_events(mainwin,
|
|
3440 GDK_FOCUS_CHANGE_MASK | GDK_BUTTON_MOTION_MASK |
|
|
3441 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
|
|
3442 GDK_SCROLL_MASK | GDK_KEY_PRESS_MASK |
|
|
3443 GDK_VISIBILITY_NOTIFY_MASK);
|
|
3444 gtk_widget_realize(mainwin);
|
|
3445
|
|
3446 util_set_cursor(mainwin);
|
|
3447
|
|
3448 g_signal_connect(mainwin, "destroy", G_CALLBACK(mainwin_destroy), NULL);
|
|
3449 g_signal_connect(mainwin, "button_press_event",
|
|
3450 G_CALLBACK(mainwin_mouse_button_press), NULL);
|
|
3451 g_signal_connect(mainwin, "scroll_event",
|
|
3452 G_CALLBACK(mainwin_scrolled), NULL);
|
|
3453 g_signal_connect(mainwin, "button_release_event",
|
|
3454 G_CALLBACK(mainwin_mouse_button_release), NULL);
|
|
3455 g_signal_connect(mainwin, "motion_notify_event",
|
|
3456 G_CALLBACK(mainwin_motion), NULL);
|
|
3457 g_signal_connect_after(mainwin, "focus_in_event",
|
|
3458 G_CALLBACK(mainwin_focus_in), NULL);
|
|
3459 g_signal_connect_after(mainwin, "focus_out_event",
|
|
3460 G_CALLBACK(mainwin_focus_out), NULL);
|
|
3461 g_signal_connect(mainwin, "configure_event",
|
|
3462 G_CALLBACK(mainwin_configure), NULL);
|
|
3463 g_signal_connect(mainwin, "style_set",
|
|
3464 G_CALLBACK(mainwin_set_back_pixmap), NULL);
|
|
3465
|
|
3466 bmp_drag_dest_set(mainwin);
|
|
3467
|
|
3468 g_signal_connect(mainwin, "key_press_event",
|
|
3469 G_CALLBACK(mainwin_keypress), NULL);
|
|
3470 }
|
|
3471
|
|
3472 void
|
|
3473 mainwin_create(void)
|
|
3474 {
|
|
3475 mainwin_create_window();
|
|
3476
|
|
3477 gtk_window_add_accel_group( GTK_WINDOW(mainwin) , ui_manager_get_accel_group() );
|
|
3478
|
|
3479 mainwin_gc = gdk_gc_new(mainwin->window);
|
|
3480 mainwin_bg = gdk_pixmap_new(mainwin->window,
|
|
3481 bmp_active_skin->properties.mainwin_width,
|
|
3482 bmp_active_skin->properties.mainwin_height, -1);
|
|
3483 mainwin_bg_x2 = gdk_pixmap_new(mainwin->window,
|
|
3484 bmp_active_skin->properties.mainwin_width * 2,
|
|
3485 bmp_active_skin->properties.mainwin_height * 2, -1);
|
|
3486 mainwin_set_back_pixmap();
|
|
3487 mainwin_create_widgets();
|
|
3488
|
|
3489 vis_set_window(mainwin_vis, mainwin->window);
|
|
3490 }
|
|
3491
|
|
3492 void
|
|
3493 mainwin_attach_idle_func(void)
|
|
3494 {
|
|
3495 mainwin_timeout_id = g_timeout_add(MAINWIN_UPDATE_INTERVAL,
|
|
3496 mainwin_idle_func, NULL);
|
|
3497 }
|
|
3498
|
|
3499 static void
|
|
3500 idle_func_update_song_info(gint time)
|
|
3501 {
|
|
3502 gint length, t;
|
|
3503 gchar stime_prefix;
|
|
3504
|
|
3505 if (ab_position_a != -1 && ab_position_b != -1 && time > ab_position_b)
|
|
3506 playback_seek(ab_position_a/1000);
|
|
3507
|
|
3508 length = playlist_get_current_length(playlist_get_active());
|
|
3509 if (playback_get_playing())
|
|
3510 playlistwin_set_time(time, length, cfg.timer_mode);
|
|
3511 else
|
|
3512 playlistwin_hide_timer();
|
|
3513 input_update_vis(time);
|
|
3514
|
|
3515 if (cfg.timer_mode == TIMER_REMAINING) {
|
|
3516 if (length != -1) {
|
|
3517 number_set_number(mainwin_minus_num, 11);
|
|
3518 t = length - time;
|
|
3519 stime_prefix = '-';
|
|
3520 }
|
|
3521 else {
|
|
3522 number_set_number(mainwin_minus_num, 10);
|
|
3523 t = time;
|
|
3524 stime_prefix = ' ';
|
|
3525 }
|
|
3526 }
|
|
3527 else {
|
|
3528 number_set_number(mainwin_minus_num, 10);
|
|
3529 t = time;
|
|
3530 stime_prefix = ' ';
|
|
3531 }
|
|
3532 t /= 1000;
|
|
3533
|
|
3534 /* Show the time in the format HH:MM when we have more than 100
|
|
3535 * minutes. */
|
|
3536 if (t >= 100 * 60)
|
|
3537 t /= 60;
|
|
3538 number_set_number(mainwin_10min_num, t / 600);
|
|
3539 number_set_number(mainwin_min_num, (t / 60) % 10);
|
|
3540 number_set_number(mainwin_10sec_num, (t / 10) % 6);
|
|
3541 number_set_number(mainwin_sec_num, t % 10);
|
|
3542
|
|
3543 if (!mainwin_sposition->hs_pressed) {
|
|
3544 gchar *time_str;
|
|
3545
|
|
3546 time_str = g_strdup_printf("%c%2.2d", stime_prefix, t / 60);
|
|
3547 textbox_set_text(mainwin_stime_min, time_str);
|
|
3548 g_free(time_str);
|
|
3549
|
|
3550 time_str = g_strdup_printf("%2.2d", t % 60);
|
|
3551 textbox_set_text(mainwin_stime_sec, time_str);
|
|
3552 g_free(time_str);
|
|
3553 }
|
|
3554
|
|
3555 time /= 1000;
|
|
3556 length /= 1000;
|
|
3557 if (length > 0) {
|
|
3558 if (time > length) {
|
|
3559 hslider_set_position(mainwin_position, 219);
|
|
3560 hslider_set_position(mainwin_sposition, 13);
|
|
3561 }
|
|
3562 /* update the slider position ONLY if there is not a seek in progress */
|
|
3563 else if (seek_state == MAINWIN_SEEK_NIL) {
|
|
3564 hslider_set_position(mainwin_position, (time * 219) / length);
|
|
3565 hslider_set_position(mainwin_sposition,
|
|
3566 ((time * 12) / length) + 1);
|
|
3567 }
|
|
3568 }
|
|
3569 else {
|
|
3570 hslider_set_position(mainwin_position, 0);
|
|
3571 hslider_set_position(mainwin_sposition, 1);
|
|
3572 }
|
|
3573 }
|
|
3574
|
|
3575 static gboolean
|
|
3576 mainwin_idle_func(gpointer data)
|
|
3577 {
|
|
3578 static gint count = 0;
|
|
3579 gint time = 0;
|
|
3580
|
|
3581 /* run audcore events, then run our own. --nenolod */
|
|
3582 switch((time = audcore_generic_events()))
|
|
3583 {
|
|
3584 case -2:
|
|
3585 /* no usable output device */
|
|
3586 GDK_THREADS_ENTER();
|
|
3587 run_no_output_device_dialog();
|
|
3588 mainwin_stop_pushed();
|
|
3589 GDK_THREADS_LEAVE();
|
|
3590 ev_waiting = FALSE;
|
|
3591 break;
|
|
3592
|
|
3593 default:
|
|
3594 idle_func_update_song_info(time);
|
|
3595 /* nothing at this time */
|
|
3596 }
|
|
3597
|
|
3598 GDK_THREADS_ENTER();
|
|
3599
|
|
3600 if (playback_get_playing())
|
|
3601 vis_playback_start();
|
|
3602 else {
|
|
3603 vis_playback_stop();
|
|
3604 ab_position_a = ab_position_b = -1;
|
|
3605 }
|
|
3606
|
|
3607 draw_main_window(mainwin_force_redraw);
|
|
3608
|
|
3609 if (!count) {
|
|
3610 read_volume(VOLSET_UPDATE);
|
|
3611 count = 10;
|
|
3612 }
|
|
3613 else
|
|
3614 count--;
|
|
3615
|
|
3616 mainwin_force_redraw = FALSE;
|
|
3617 draw_equalizer_window(FALSE);
|
|
3618 draw_playlist_window(FALSE);
|
|
3619
|
|
3620 if (mainwin_title_text) {
|
|
3621 G_LOCK(mainwin_title);
|
|
3622 gtk_window_set_title(GTK_WINDOW(mainwin), mainwin_title_text);
|
|
3623 g_free(mainwin_title_text);
|
|
3624 mainwin_title_text = NULL;
|
|
3625 G_UNLOCK(mainwin_title);
|
|
3626
|
|
3627 mainwin_set_info_text();
|
|
3628 playlistwin_update_list(playlist_get_active());
|
|
3629 }
|
|
3630
|
|
3631 /* tristate buttons seek */
|
|
3632 if ( seek_state != MAINWIN_SEEK_NIL )
|
|
3633 {
|
|
3634 GTimeVal now_time;
|
|
3635 GTimeVal delta_time;
|
|
3636 gulong now_dur;
|
|
3637 g_get_current_time(&now_time);
|
|
3638
|
|
3639 delta_time.tv_usec = now_time.tv_usec - cb_time.tv_usec;
|
|
3640 delta_time.tv_sec = now_time.tv_sec - cb_time.tv_sec;
|
|
3641
|
|
3642 now_dur = labs((delta_time.tv_sec * 1000) + (glong) (delta_time.tv_usec / 1000));
|
|
3643
|
|
3644 if ( now_dur > TRISTATE_THRESHOLD )
|
|
3645 {
|
|
3646 gint np;
|
|
3647 if (seek_state == MAINWIN_SEEK_REV)
|
|
3648 np = seek_initial_pos - labs((gulong)(now_dur/100)); /* seek back */
|
|
3649 else
|
|
3650 np = seek_initial_pos + labs((gulong)(now_dur/100)); /* seek forward */
|
|
3651
|
|
3652 /* boundaries check */
|
|
3653 if (np < 0 )
|
|
3654 np = 0;
|
|
3655 else if ( np > 219 )
|
|
3656 np = 219;
|
|
3657
|
|
3658 hslider_set_position( mainwin_position , np );
|
|
3659 mainwin_position_motion_cb( np );
|
|
3660 }
|
|
3661 }
|
|
3662
|
|
3663 GDK_THREADS_LEAVE();
|
|
3664
|
|
3665 /*
|
|
3666 if (seek_state == MAINWIN_SEEK_REV)
|
|
3667 playback_seek(CLAMP(playback_get_time() - 1000, 0,
|
|
3668 playlist_get_current_length()) / 1000);
|
|
3669 else if (seek_state == MAINWIN_SEEK_FWD)
|
|
3670 playback_seek(CLAMP(playback_get_time() + 1000, 0,
|
|
3671 playlist_get_current_length()) / 1000);
|
|
3672 */
|
|
3673
|
|
3674 return TRUE;
|
|
3675 }
|
|
3676
|
|
3677
|
|
3678 /* toggleactionentries actions */
|
|
3679
|
|
3680 void
|
|
3681 action_anamode_peaks( GtkToggleAction * action )
|
|
3682 {
|
|
3683 cfg.analyzer_peaks = gtk_toggle_action_get_active( action );
|
|
3684 }
|
|
3685
|
|
3686 void
|
|
3687 action_autoscroll_songname( GtkToggleAction * action )
|
|
3688 {
|
|
3689 mainwin_set_title_scroll(gtk_toggle_action_get_active(action));
|
|
3690 playlistwin_set_sinfo_scroll(cfg.autoscroll); /* propagate scroll setting to playlistwin_sinfo */
|
|
3691 }
|
|
3692
|
|
3693 void
|
|
3694 action_playback_noplaylistadvance( GtkToggleAction * action )
|
|
3695 {
|
|
3696 cfg.no_playlist_advance = gtk_toggle_action_get_active( action );
|
|
3697 }
|
|
3698
|
|
3699 void
|
|
3700 action_playback_repeat( GtkToggleAction * action )
|
|
3701 {
|
|
3702 cfg.repeat = gtk_toggle_action_get_active( action );
|
|
3703 tbutton_set_toggled(mainwin_repeat, cfg.repeat);
|
|
3704 }
|
|
3705
|
|
3706 void
|
|
3707 action_playback_shuffle( GtkToggleAction * action )
|
|
3708 {
|
|
3709 cfg.shuffle = gtk_toggle_action_get_active( action );
|
|
3710 playlist_set_shuffle(cfg.shuffle);
|
|
3711 tbutton_set_toggled(mainwin_shuffle, cfg.shuffle);
|
|
3712 }
|
|
3713
|
|
3714 void
|
|
3715 action_stop_after_current_song( GtkToggleAction * action )
|
|
3716 {
|
|
3717 cfg.stopaftersong = gtk_toggle_action_get_active( action );
|
|
3718 }
|
|
3719
|
|
3720 void
|
|
3721 action_view_always_on_top( GtkToggleAction * action )
|
|
3722 {
|
|
3723 mainwin_menurow->mr_always_selected = gtk_toggle_action_get_active( action );
|
|
3724 cfg.always_on_top = mainwin_menurow->mr_always_selected;
|
|
3725 widget_draw(WIDGET(mainwin_menurow));
|
|
3726
|
|
3727 if (starting_up == FALSE)
|
|
3728 hint_set_always(cfg.always_on_top);
|
|
3729 }
|
|
3730
|
|
3731 void
|
|
3732 action_view_doublesize( GtkToggleAction * action )
|
|
3733 {
|
|
3734 mainwin_menurow->mr_doublesize_selected = gtk_toggle_action_get_active( action );
|
|
3735 widget_draw(WIDGET(mainwin_menurow));
|
|
3736 set_doublesize(mainwin_menurow->mr_doublesize_selected);
|
|
3737 gdk_flush();
|
|
3738 }
|
|
3739
|
|
3740 void
|
|
3741 action_view_easymove( GtkToggleAction * action )
|
|
3742 {
|
|
3743 cfg.easy_move = gtk_toggle_action_get_active( action );
|
|
3744 }
|
|
3745
|
|
3746 void
|
|
3747 action_view_on_all_workspaces( GtkToggleAction * action )
|
|
3748 {
|
|
3749 cfg.sticky = gtk_toggle_action_get_active( action );
|
|
3750 hint_set_sticky(cfg.sticky);
|
|
3751 }
|
|
3752
|
|
3753 void
|
|
3754 action_roll_up_equalizer( GtkToggleAction * action )
|
|
3755 {
|
|
3756 equalizerwin_set_shade_menu_cb(gtk_toggle_action_get_active(action));
|
|
3757 }
|
|
3758
|
|
3759 void
|
|
3760 action_roll_up_player( GtkToggleAction * action )
|
|
3761 {
|
|
3762 mainwin_set_shade_menu_cb(gtk_toggle_action_get_active(action));
|
|
3763 }
|
|
3764
|
|
3765 void
|
|
3766 action_roll_up_playlist_editor( GtkToggleAction * action )
|
|
3767 {
|
|
3768 playlistwin_set_shade(gtk_toggle_action_get_active(action));
|
|
3769 }
|
|
3770
|
|
3771 void
|
|
3772 action_show_equalizer( GtkToggleAction * action )
|
|
3773 {
|
|
3774 if (gtk_toggle_action_get_active(action))
|
|
3775 equalizerwin_real_show();
|
|
3776 else
|
|
3777 equalizerwin_real_hide();
|
|
3778 }
|
|
3779
|
|
3780 void
|
|
3781 action_show_playlist_editor( GtkToggleAction * action )
|
|
3782 {
|
|
3783 if (gtk_toggle_action_get_active(action))
|
|
3784 playlistwin_show();
|
|
3785 else
|
|
3786 playlistwin_hide();
|
|
3787 }
|
|
3788
|
|
3789 void
|
|
3790 action_show_player( GtkToggleAction * action )
|
|
3791 {
|
|
3792 mainwin_show(gtk_toggle_action_get_active(action));
|
|
3793 }
|
|
3794
|
|
3795
|
|
3796 /* radioactionentries actions (one callback for each radio group) */
|
|
3797
|
|
3798 void
|
|
3799 action_anafoff( GtkAction *action, GtkRadioAction *current )
|
|
3800 {
|
|
3801 mainwin_vis_set_afalloff(gtk_radio_action_get_current_value(current));
|
|
3802 }
|
|
3803
|
|
3804 void
|
|
3805 action_anamode( GtkAction *action, GtkRadioAction *current )
|
|
3806 {
|
|
3807 mainwin_vis_set_analyzer_mode(gtk_radio_action_get_current_value(current));
|
|
3808 }
|
|
3809
|
|
3810 void
|
|
3811 action_anatype( GtkAction *action, GtkRadioAction *current )
|
|
3812 {
|
|
3813 mainwin_vis_set_analyzer_type(gtk_radio_action_get_current_value(current));
|
|
3814 }
|
|
3815
|
|
3816 void
|
|
3817 action_peafoff( GtkAction *action, GtkRadioAction *current )
|
|
3818 {
|
|
3819 mainwin_vis_set_pfalloff(gtk_radio_action_get_current_value(current));
|
|
3820 }
|
|
3821
|
|
3822 void
|
|
3823 action_refrate( GtkAction *action, GtkRadioAction *current )
|
|
3824 {
|
|
3825 mainwin_vis_set_refresh(gtk_radio_action_get_current_value(current));
|
|
3826 }
|
|
3827
|
|
3828 void
|
|
3829 action_scomode( GtkAction *action, GtkRadioAction *current )
|
|
3830 {
|
|
3831 cfg.scope_mode = gtk_radio_action_get_current_value(current);
|
|
3832 }
|
|
3833
|
|
3834 void
|
|
3835 action_vismode( GtkAction *action, GtkRadioAction *current )
|
|
3836 {
|
|
3837 mainwin_vis_set_type_menu_cb(gtk_radio_action_get_current_value(current));
|
|
3838 }
|
|
3839
|
|
3840 void
|
|
3841 action_vprmode( GtkAction *action, GtkRadioAction *current )
|
|
3842 {
|
|
3843 cfg.voiceprint_mode = gtk_radio_action_get_current_value(current);
|
|
3844 }
|
|
3845
|
|
3846 void
|
|
3847 action_wshmode( GtkAction *action, GtkRadioAction *current )
|
|
3848 {
|
|
3849 cfg.vu_mode = gtk_radio_action_get_current_value(current);
|
|
3850 }
|
|
3851
|
|
3852 void
|
|
3853 action_viewtime( GtkAction *action, GtkRadioAction *current )
|
|
3854 {
|
|
3855 set_timer_mode_menu_cb(gtk_radio_action_get_current_value(current));
|
|
3856 }
|
|
3857
|
|
3858
|
|
3859 /* actionentries actions */
|
|
3860
|
|
3861 void
|
|
3862 action_about_audacious( void )
|
|
3863 {
|
|
3864 show_about_window();
|
|
3865 }
|
|
3866
|
|
3867 void
|
|
3868 action_play_file( void )
|
|
3869 {
|
|
3870 util_run_filebrowser(PLAY_BUTTON);
|
|
3871 }
|
|
3872
|
|
3873 void
|
|
3874 action_play_location( void )
|
|
3875 {
|
|
3876 mainwin_show_add_url_window();
|
|
3877 }
|
|
3878
|
|
3879 void
|
|
3880 action_ab_set( void )
|
|
3881 {
|
|
3882 Playlist *playlist = playlist_get_active();
|
|
3883 if (playlist_get_current_length(playlist) != -1)
|
|
3884 {
|
|
3885 if (ab_position_a == -1)
|
|
3886 {
|
|
3887 ab_position_a = playback_get_time();
|
|
3888 ab_position_b = -1;
|
|
3889 mainwin_lock_info_text("LOOP-POINT A POSITION SET.");
|
|
3890 }
|
|
3891 else if (ab_position_b == -1)
|
|
3892 {
|
|
3893 int time = playback_get_time();
|
|
3894 if (time > ab_position_a)
|
|
3895 ab_position_b = time;
|
|
3896 mainwin_release_info_text();
|
|
3897 }
|
|
3898 else
|
|
3899 {
|
|
3900 ab_position_a = playback_get_time();
|
|
3901 ab_position_b = -1;
|
|
3902 mainwin_lock_info_text("LOOP-POINT A POSITION RESET.");
|
|
3903 }
|
|
3904 }
|
|
3905 }
|
|
3906
|
|
3907 void
|
|
3908 action_ab_clear( void )
|
|
3909 {
|
|
3910 Playlist *playlist = playlist_get_active();
|
|
3911 if (playlist_get_current_length(playlist) != -1)
|
|
3912 {
|
|
3913 ab_position_a = ab_position_b = -1;
|
|
3914 mainwin_release_info_text();
|
|
3915 }
|
|
3916 }
|
|
3917
|
|
3918 void
|
|
3919 action_current_track_info( void )
|
|
3920 {
|
|
3921 playlist_fileinfo_current(playlist_get_active());
|
|
3922 }
|
|
3923
|
|
3924 void
|
|
3925 action_jump_to_file( void )
|
|
3926 {
|
|
3927 mainwin_jump_to_file();
|
|
3928 }
|
|
3929
|
|
3930 void
|
|
3931 action_jump_to_playlist_start( void )
|
|
3932 {
|
|
3933 Playlist *playlist = playlist_get_active();
|
|
3934 playlist_set_position(playlist, 0);
|
|
3935 }
|
|
3936
|
|
3937 void
|
|
3938 action_jump_to_time( void )
|
|
3939 {
|
|
3940 mainwin_jump_to_time();
|
|
3941 }
|
|
3942
|
|
3943 void
|
|
3944 action_playback_next( void )
|
|
3945 {
|
|
3946 Playlist *playlist = playlist_get_active();
|
|
3947 playlist_next(playlist);
|
|
3948 }
|
|
3949
|
|
3950 void
|
|
3951 action_playback_previous( void )
|
|
3952 {
|
|
3953 Playlist *playlist = playlist_get_active();
|
|
3954 playlist_prev(playlist);
|
|
3955 }
|
|
3956
|
|
3957 void
|
|
3958 action_playback_play( void )
|
|
3959 {
|
|
3960 mainwin_play_pushed();
|
|
3961 }
|
|
3962
|
|
3963 void
|
|
3964 action_playback_playcd( void )
|
|
3965 {
|
|
3966 play_medium();
|
|
3967 }
|
|
3968
|
|
3969 void
|
|
3970 action_playback_pause( void )
|
|
3971 {
|
|
3972 playback_pause();
|
|
3973 }
|
|
3974
|
|
3975 void
|
|
3976 action_playback_stop( void )
|
|
3977 {
|
|
3978 mainwin_stop_pushed();
|
|
3979 }
|
|
3980
|
|
3981 void
|
|
3982 action_preferences( void )
|
|
3983 {
|
|
3984 show_prefs_window();
|
|
3985 }
|
|
3986
|
|
3987 void
|
|
3988 action_quit( void )
|
|
3989 {
|
|
3990 mainwin_quit_cb();
|
|
3991 }
|