|
0
|
1 /* BMP - Cross-platform multimedia player
|
|
|
2 * Copyright (C) 2003-2004 BMP development team.
|
|
|
3 *
|
|
|
4 * Based on XMMS:
|
|
|
5 * Copyright (C) 1998-2003 XMMS development team.
|
|
|
6 *
|
|
|
7 * This program is free software; you can redistribute it and/or modify
|
|
|
8 * it under the terms of the GNU General Public License as published by
|
|
|
9 * the Free Software Foundation; either version 2 of the License, or
|
|
|
10 * (at your option) any later version.
|
|
|
11 *
|
|
|
12 * This program is distributed in the hope that it will be useful,
|
|
|
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
15 * GNU General Public License for more details.
|
|
|
16 *
|
|
|
17 * You should have received a copy of the GNU General Public License
|
|
|
18 * along with this program; if not, write to the Free Software
|
|
|
19 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
20 */
|
|
|
21
|
|
|
22 #ifdef HAVE_CONFIG_H
|
|
|
23 # include "config.h"
|
|
|
24 #endif
|
|
|
25
|
|
|
26
|
|
|
27 #include <glib.h>
|
|
|
28 #include <glib/gi18n.h>
|
|
|
29 #include <glib/gprintf.h>
|
|
|
30 #include <gtk/gtk.h>
|
|
|
31 #include <gdk/gdkx.h>
|
|
|
32 #include <gdk/gdkkeysyms.h>
|
|
|
33
|
|
|
34 #include <math.h>
|
|
|
35 #include <stdlib.h>
|
|
|
36 #include <string.h>
|
|
|
37
|
|
|
38 #include <X11/Xlib.h>
|
|
|
39
|
|
|
40 #include "textbox.h"
|
|
|
41 #include "mainwin.h"
|
|
|
42 #include "pixmaps.h"
|
|
|
43
|
|
|
44 #include "main.h"
|
|
|
45
|
|
|
46 #include "controlsocket.h"
|
|
|
47 #include "pluginenum.h"
|
|
|
48
|
|
|
49 #include "about.h"
|
|
|
50 #include "dnd.h"
|
|
|
51 #include "dock.h"
|
|
|
52 #include "equalizer.h"
|
|
|
53 #include "hints.h"
|
|
|
54 #include "input.h"
|
|
|
55 #include "playlistwin.h"
|
|
|
56 #include "prefswin.h"
|
|
|
57 #include "skinwin.h"
|
|
|
58
|
|
|
59 #include "hslider.h"
|
|
|
60 #include "menurow.h"
|
|
|
61 #include "monostereo.h"
|
|
|
62 #include "pbutton.h"
|
|
|
63 #include "playback.h"
|
|
|
64 #include "playlist.h"
|
|
|
65 #include "playlist_list.h"
|
|
|
66 #include "playstatus.h"
|
|
|
67 #include "sbutton.h"
|
|
|
68 #include "svis.h"
|
|
|
69 #include "textbox.h"
|
|
|
70 #include "urldecode.h"
|
|
|
71 #include "util.h"
|
|
|
72 #include "vis.h"
|
|
|
73 #include "visualization.h"
|
|
|
74 #include "libaudacious/configdb.h"
|
|
|
75
|
|
|
76
|
|
|
77 #define ITEM_SEPARATOR {"/-", NULL, NULL, 0, "<Separator>"}
|
|
|
78
|
|
|
79 /*
|
|
|
80 * If you change the menu above change these defines also
|
|
|
81 */
|
|
|
82
|
|
|
83 #define MAINWIN_VIS_MENU_VIS_MODE 1
|
|
|
84 #define MAINWIN_VIS_MENU_NUM_VIS_MODE 3
|
|
|
85 #define MAINWIN_VIS_MENU_ANALYZER_MODE 5
|
|
|
86 #define MAINWIN_VIS_MENU_NUM_ANALYZER_MODE 3
|
|
|
87 #define MAINWIN_VIS_MENU_ANALYZER_TYPE 9
|
|
|
88 #define MAINWIN_VIS_MENU_NUM_ANALYZER_TYPE 2
|
|
|
89 #define MAINWIN_VIS_MENU_ANALYZER_PEAKS 12
|
|
|
90 #define MAINWIN_VIS_MENU_SCOPE_MODE 14
|
|
|
91 #define MAINWIN_VIS_MENU_NUM_SCOPE_MODE 3
|
|
|
92 #define MAINWIN_VIS_MENU_WSHADEVU_MODE 18
|
|
|
93 #define MAINWIN_VIS_MENU_NUM_WSHADEVU_MODE 2
|
|
|
94 #define MAINWIN_VIS_MENU_REFRESH_RATE 21
|
|
|
95 #define MAINWIN_VIS_MENU_NUM_REFRESH_RATE 4
|
|
|
96 #define MAINWIN_VIS_MENU_AFALLOFF 26
|
|
|
97 #define MAINWIN_VIS_MENU_NUM_AFALLOFF 5
|
|
|
98 #define MAINWIN_VIS_MENU_PFALLOFF 32
|
|
|
99 #define MAINWIN_VIS_MENU_NUM_PFALLOFF 5
|
|
|
100
|
|
|
101 #define VOLSET_DISP_TIMES 5
|
|
|
102
|
|
|
103
|
|
|
104 enum {
|
|
|
105 MAINWIN_SONGNAME_FILEINFO,
|
|
|
106 MAINWIN_SONGNAME_JTF,
|
|
|
107 MAINWIN_SONGNAME_JTT,
|
|
|
108 MAINWIN_SONGNAME_SCROLL
|
|
|
109 };
|
|
|
110
|
|
|
111 enum {
|
|
|
112 MAINWIN_OPT_SKIN, MAINWIN_OPT_RELOADSKIN,
|
|
|
113 MAINWIN_OPT_REPEAT, MAINWIN_OPT_SHUFFLE, MAINWIN_OPT_NPA,
|
|
|
114 MAINWIN_OPT_TELAPSED, MAINWIN_OPT_TREMAINING,
|
|
|
115 MAINWIN_OPT_ALWAYS,
|
|
|
116 MAINWIN_OPT_STICKY,
|
|
|
117 MAINWIN_OPT_WS,
|
|
|
118 MAINWIN_OPT_PWS,
|
|
|
119 MAINWIN_OPT_EQWS
|
|
|
120 };
|
|
|
121
|
|
|
122 enum {
|
|
|
123 MAINWIN_VIS_ANALYZER, MAINWIN_VIS_SCOPE, MAINWIN_VIS_OFF,
|
|
|
124 MAINWIN_VIS_ANALYZER_NORMAL, MAINWIN_VIS_ANALYZER_FIRE,
|
|
|
125 MAINWIN_VIS_ANALYZER_VLINES,
|
|
|
126 MAINWIN_VIS_ANALYZER_LINES, MAINWIN_VIS_ANALYZER_BARS,
|
|
|
127 MAINWIN_VIS_ANALYZER_PEAKS,
|
|
|
128 MAINWIN_VIS_SCOPE_DOT, MAINWIN_VIS_SCOPE_LINE, MAINWIN_VIS_SCOPE_SOLID,
|
|
|
129 MAINWIN_VIS_VU_NORMAL, MAINWIN_VIS_VU_SMOOTH,
|
|
|
130 MAINWIN_VIS_REFRESH_FULL, MAINWIN_VIS_REFRESH_HALF,
|
|
|
131 MAINWIN_VIS_REFRESH_QUARTER, MAINWIN_VIS_REFRESH_EIGHTH,
|
|
|
132 MAINWIN_VIS_AFALLOFF_SLOWEST, MAINWIN_VIS_AFALLOFF_SLOW,
|
|
|
133 MAINWIN_VIS_AFALLOFF_MEDIUM, MAINWIN_VIS_AFALLOFF_FAST,
|
|
|
134 MAINWIN_VIS_AFALLOFF_FASTEST,
|
|
|
135 MAINWIN_VIS_PFALLOFF_SLOWEST, MAINWIN_VIS_PFALLOFF_SLOW,
|
|
|
136 MAINWIN_VIS_PFALLOFF_MEDIUM, MAINWIN_VIS_PFALLOFF_FAST,
|
|
|
137 MAINWIN_VIS_PFALLOFF_FASTEST,
|
|
|
138 MAINWIN_VIS_PLUGINS
|
|
|
139 };
|
|
|
140
|
|
|
141 enum {
|
|
|
142 MAINWIN_VIS_ACTIVE_MAINWIN, MAINWIN_VIS_ACTIVE_PLAYLISTWIN
|
|
|
143 };
|
|
|
144
|
|
|
145
|
|
|
146 typedef struct _PlaybackInfo PlaybackInfo;
|
|
|
147
|
|
|
148 struct _PlaybackInfo {
|
|
|
149 gchar *title;
|
|
|
150 gint bitrate;
|
|
|
151 gint frequency;
|
|
|
152 gint n_channels;
|
|
|
153 };
|
|
|
154
|
|
|
155
|
|
|
156 GtkWidget *mainwin = NULL;
|
|
|
157
|
|
|
158 static GdkBitmap *nullmask;
|
|
|
159 static gint balance;
|
|
|
160
|
|
|
161 GtkWidget *mainwin_jtf = NULL;
|
|
|
162 static GtkWidget *mainwin_jtt = NULL;
|
|
|
163
|
|
|
164 GtkItemFactory *mainwin_songname_menu, *mainwin_vis_menu;
|
|
|
165 GtkItemFactory *mainwin_general_menu, *mainwin_play_menu, *mainwin_add_menu;
|
|
|
166 GtkItemFactory *mainwin_view_menu;
|
|
|
167
|
|
|
168
|
|
|
169 GdkGC *mainwin_gc;
|
|
|
170 static GdkPixmap *mainwin_bg = NULL;
|
|
|
171
|
|
|
172 GtkAccelGroup *mainwin_accel = NULL;
|
|
|
173
|
|
|
174 static PButton *mainwin_menubtn;
|
|
|
175 static PButton *mainwin_minimize, *mainwin_shade, *mainwin_close;
|
|
|
176
|
|
|
177 static PButton *mainwin_rew, *mainwin_fwd;
|
|
|
178 static PButton *mainwin_eject;
|
|
|
179 static PButton *mainwin_play, *mainwin_pause, *mainwin_stop;
|
|
|
180
|
|
|
181 TButton *mainwin_shuffle, *mainwin_repeat, *mainwin_eq, *mainwin_pl;
|
|
|
182 TextBox *mainwin_info;
|
|
|
183
|
|
|
184 static TextBox *mainwin_rate_text, *mainwin_freq_text;
|
|
|
185 static TextBox *mainwin_stime_min, *mainwin_stime_sec;
|
|
|
186
|
|
|
187 PlayStatus *mainwin_playstatus;
|
|
|
188
|
|
|
189 static Number *mainwin_minus_num, *mainwin_10min_num, *mainwin_min_num;
|
|
|
190 static Number *mainwin_10sec_num, *mainwin_sec_num;
|
|
|
191
|
|
|
192 static gboolean setting_volume = FALSE;
|
|
|
193
|
|
|
194 Vis *active_vis;
|
|
|
195 Vis *mainwin_vis;
|
|
|
196 SVis *mainwin_svis;
|
|
|
197
|
|
|
198 static MenuRow *mainwin_menurow;
|
|
|
199 static HSlider *mainwin_volume, *mainwin_balance, *mainwin_position;
|
|
|
200 static HSlider *mainwin_sposition = NULL;
|
|
|
201 static MonoStereo *mainwin_monostereo;
|
|
|
202 static SButton *mainwin_srew, *mainwin_splay, *mainwin_spause;
|
|
|
203 static SButton *mainwin_sstop, *mainwin_sfwd, *mainwin_seject, *mainwin_about;
|
|
|
204
|
|
|
205 static GList *mainwin_wlist = NULL;
|
|
|
206
|
|
|
207 static gint mainwin_timeout_id;
|
|
|
208
|
|
|
209 G_LOCK_DEFINE_STATIC(mainwin_title);
|
|
|
210
|
|
|
211 static gboolean mainwin_force_redraw = FALSE;
|
|
|
212 static gchar *mainwin_title_text = NULL;
|
|
|
213 static gboolean mainwin_info_text_locked = FALSE;
|
|
|
214
|
|
|
215
|
|
|
216 static void mainwin_songname_menu_callback(gpointer user_data,
|
|
|
217 guint action,
|
|
|
218 GtkWidget * widget);
|
|
|
219
|
|
|
220 static void mainwin_vis_menu_callback(gpointer user_data,
|
|
|
221 guint action,
|
|
|
222 GtkWidget * widget);
|
|
|
223
|
|
|
224 static void mainwin_view_menu_callback(gpointer user_data,
|
|
|
225 guint action,
|
|
|
226 GtkWidget * widget);
|
|
|
227
|
|
|
228 static void mainwin_play_menu_callback(gpointer user_data,
|
|
|
229 guint action,
|
|
|
230 GtkWidget * widget);
|
|
|
231
|
|
|
232 /* Song name area menu */
|
|
|
233
|
|
|
234 static GtkItemFactoryEntry mainwin_songname_menu_entries[] = {
|
|
|
235 {N_("/View Track Details"), "<alt>i", mainwin_general_menu_callback,
|
|
|
236 MAINWIN_GENERAL_FILEINFO, "<ImageItem>", my_pixbuf},
|
|
|
237 {"/-", NULL, NULL, 0, "<Separator>"},
|
|
|
238 {N_("/Autoscroll Songname"), NULL, mainwin_songname_menu_callback,
|
|
|
239 MAINWIN_SONGNAME_SCROLL, "<ToggleItem>"},
|
|
|
240 };
|
|
|
241
|
|
|
242 static gint mainwin_songname_menu_entries_num =
|
|
|
243 G_N_ELEMENTS(mainwin_songname_menu_entries);
|
|
|
244
|
|
|
245 /* Mini-visualizer area menu */
|
|
|
246
|
|
|
247 static GtkItemFactoryEntry mainwin_vis_menu_entries[] = {
|
|
|
248 {N_("/Visualization Mode"), NULL, NULL, 0, "<Branch>"},
|
|
|
249 {N_("/Visualization Mode/Analyzer"), NULL, mainwin_vis_menu_callback,
|
|
|
250 MAINWIN_VIS_ANALYZER, "<RadioItem>"},
|
|
|
251 {N_("/Visualization Mode/Scope"), NULL, mainwin_vis_menu_callback,
|
|
|
252 MAINWIN_VIS_SCOPE, "/Visualization Mode/Analyzer"},
|
|
|
253 {N_("/Visualization Mode/Off"), NULL, mainwin_vis_menu_callback,
|
|
|
254 MAINWIN_VIS_OFF, "/Visualization Mode/Analyzer"},
|
|
|
255 {N_("/Analyzer Mode"), NULL, NULL, 0, "<Branch>"},
|
|
|
256 {N_("/Analyzer Mode/Normal"), NULL, mainwin_vis_menu_callback,
|
|
|
257 MAINWIN_VIS_ANALYZER_NORMAL, "<RadioItem>"},
|
|
|
258 {N_("/Analyzer Mode/Fire"), NULL, mainwin_vis_menu_callback,
|
|
|
259 MAINWIN_VIS_ANALYZER_FIRE, "/Analyzer Mode/Normal"},
|
|
|
260 {N_("/Analyzer Mode/Vertical Lines"), NULL, mainwin_vis_menu_callback,
|
|
|
261 MAINWIN_VIS_ANALYZER_VLINES, "/Analyzer Mode/Normal"},
|
|
|
262 {"/Analyzer Mode/-", NULL, NULL, 0, "<Separator>"},
|
|
|
263 {N_("/Analyzer Mode/Lines"), NULL, mainwin_vis_menu_callback,
|
|
|
264 MAINWIN_VIS_ANALYZER_LINES, "<RadioItem>"},
|
|
|
265 {N_("/Analyzer Mode/Bars"), NULL, mainwin_vis_menu_callback,
|
|
|
266 MAINWIN_VIS_ANALYZER_BARS, "/Analyzer Mode/Lines"},
|
|
|
267 {"/Analyzer Mode/-", NULL, NULL, 0, "<Separator>"},
|
|
|
268 {N_("/Analyzer Mode/Peaks"), NULL, mainwin_vis_menu_callback,
|
|
|
269 MAINWIN_VIS_ANALYZER_PEAKS, "<ToggleItem>"},
|
|
|
270 {N_("/Scope Mode"), NULL, NULL, 0, "<Branch>"},
|
|
|
271 {N_("/Scope Mode/Dot Scope"), NULL, mainwin_vis_menu_callback,
|
|
|
272 MAINWIN_VIS_SCOPE_DOT, "<RadioItem>"},
|
|
|
273 {N_("/Scope Mode/Line Scope"), NULL, mainwin_vis_menu_callback,
|
|
|
274 MAINWIN_VIS_SCOPE_LINE, "/Scope Mode/Dot Scope"},
|
|
|
275 {N_("/Scope Mode/Solid Scope"), NULL, mainwin_vis_menu_callback,
|
|
|
276 MAINWIN_VIS_SCOPE_SOLID, "/Scope Mode/Dot Scope"},
|
|
|
277 {N_("/WindowShade VU Mode"), NULL, NULL, 0, "<Branch>"},
|
|
|
278 {N_("/WindowShade VU Mode/Normal"), NULL, mainwin_vis_menu_callback,
|
|
|
279 MAINWIN_VIS_VU_NORMAL, "<RadioItem>"},
|
|
|
280 {N_("/WindowShade VU Mode/Smooth"), NULL, mainwin_vis_menu_callback,
|
|
|
281 MAINWIN_VIS_VU_SMOOTH, "/WindowShade VU Mode/Normal"},
|
|
|
282 {N_("/Refresh Rate"), NULL, NULL, 0, "<Branch>"},
|
|
|
283 {N_("/Refresh Rate/Full (~50 fps)"), NULL, mainwin_vis_menu_callback,
|
|
|
284 MAINWIN_VIS_REFRESH_FULL, "<RadioItem>"},
|
|
|
285 {N_("/Refresh Rate/Half (~25 fps)"), NULL, mainwin_vis_menu_callback,
|
|
|
286 MAINWIN_VIS_REFRESH_HALF, "/Refresh Rate/Full (~50 fps)"},
|
|
|
287 {N_("/Refresh Rate/Quarter (~13 fps)"), NULL, mainwin_vis_menu_callback,
|
|
|
288 MAINWIN_VIS_REFRESH_QUARTER, "/Refresh Rate/Full (~50 fps)"},
|
|
|
289 {N_("/Refresh Rate/Eighth (~6 fps)"), NULL, mainwin_vis_menu_callback,
|
|
|
290 MAINWIN_VIS_REFRESH_EIGHTH, "/Refresh Rate/Full (~50 fps)"},
|
|
|
291 {N_("/Analyzer Falloff"), NULL, NULL, 0, "<Branch>"},
|
|
|
292 {N_("/Analyzer Falloff/Slowest"), NULL, mainwin_vis_menu_callback,
|
|
|
293 MAINWIN_VIS_AFALLOFF_SLOWEST, "<RadioItem>"},
|
|
|
294 {N_("/Analyzer Falloff/Slow"), NULL, mainwin_vis_menu_callback,
|
|
|
295 MAINWIN_VIS_AFALLOFF_SLOW, "/Analyzer Falloff/Slowest"},
|
|
|
296 {N_("/Analyzer Falloff/Medium"), NULL, mainwin_vis_menu_callback,
|
|
|
297 MAINWIN_VIS_AFALLOFF_MEDIUM, "/Analyzer Falloff/Slowest"},
|
|
|
298 {N_("/Analyzer Falloff/Fast"), NULL, mainwin_vis_menu_callback,
|
|
|
299 MAINWIN_VIS_AFALLOFF_FAST, "/Analyzer Falloff/Slowest"},
|
|
|
300 {N_("/Analyzer Falloff/Fastest"), NULL, mainwin_vis_menu_callback,
|
|
|
301 MAINWIN_VIS_AFALLOFF_FASTEST, "/Analyzer Falloff/Slowest"},
|
|
|
302 {N_("/Peaks Falloff"), NULL, NULL, 0, "<Branch>"},
|
|
|
303 {N_("/Peaks Falloff/Slowest"), NULL, mainwin_vis_menu_callback,
|
|
|
304 MAINWIN_VIS_PFALLOFF_SLOWEST, "<RadioItem>"},
|
|
|
305 {N_("/Peaks Falloff/Slow"), NULL, mainwin_vis_menu_callback,
|
|
|
306 MAINWIN_VIS_PFALLOFF_SLOW, "/Peaks Falloff/Slowest"},
|
|
|
307 {N_("/Peaks Falloff/Medium"), NULL, mainwin_vis_menu_callback,
|
|
|
308 MAINWIN_VIS_PFALLOFF_MEDIUM, "/Peaks Falloff/Slowest"},
|
|
|
309 {N_("/Peaks Falloff/Fast"), NULL, mainwin_vis_menu_callback,
|
|
|
310 MAINWIN_VIS_PFALLOFF_FAST, "/Peaks Falloff/Slowest"},
|
|
|
311 {N_("/Peaks Falloff/Fastest"), NULL, mainwin_vis_menu_callback,
|
|
|
312 MAINWIN_VIS_PFALLOFF_FASTEST, "/Peaks Falloff/Slowest"}
|
|
|
313 };
|
|
|
314
|
|
|
315 static const gint mainwin_vis_menu_entries_num =
|
|
|
316 G_N_ELEMENTS(mainwin_vis_menu_entries);
|
|
|
317
|
|
|
318 /* Playback menu (now used only for accelerators) */
|
|
|
319
|
|
|
320 static GtkItemFactoryEntry mainwin_playback_menu_entries[] = {
|
|
|
321 /*
|
|
|
322 {N_("/Play CD"), "<alt>C", mainwin_general_menu_callback,
|
|
|
323 MAINWIN_GENERAL_PLAYCD, "<StockItem>", GTK_STOCK_CDROM},
|
|
|
324 {"/-", NULL, NULL, 0, "<Separator>"},
|
|
|
325 */
|
|
|
326 {N_("/Repeat"), "R", mainwin_play_menu_callback,
|
|
|
327 MAINWIN_OPT_REPEAT, "<ToggleItem>"},
|
|
|
328 {N_("/Shuffle"), "S", mainwin_play_menu_callback,
|
|
|
329 MAINWIN_OPT_SHUFFLE, "<ToggleItem>"},
|
|
|
330 /*
|
|
|
331 {N_("/No Playlist Advance"), "<control>N", mainwin_play_menu_callback,
|
|
|
332 MAINWIN_OPT_NPA, "<ToggleItem>"},
|
|
|
333 */
|
|
|
334 {"/-", NULL, NULL, 0, "<Separator>"},
|
|
|
335 {N_("/Play"), "x", mainwin_general_menu_callback,
|
|
|
336 MAINWIN_GENERAL_PLAY, "<Item>"},
|
|
|
337 {N_("/Pause"), "c", mainwin_general_menu_callback,
|
|
|
338 MAINWIN_GENERAL_PAUSE, "<Item>"},
|
|
|
339 {N_("/Stop"), "v", mainwin_general_menu_callback,
|
|
|
340 MAINWIN_GENERAL_STOP, "<StockItem>", GTK_STOCK_STOP},
|
|
|
341 {N_("/Previous"), "z", mainwin_general_menu_callback,
|
|
|
342 MAINWIN_GENERAL_PREV, "<StockItem>", GTK_STOCK_GO_BACK},
|
|
|
343 {N_("/Next"), "b", mainwin_general_menu_callback,
|
|
|
344 MAINWIN_GENERAL_NEXT, "<StockItem>", GTK_STOCK_GO_FORWARD},
|
|
|
345 {"/-", NULL, NULL, 0, "<Separator>"},
|
|
|
346 {N_("/Jump to Playlist Start"), "<control>Z", mainwin_general_menu_callback,
|
|
|
347 MAINWIN_GENERAL_START, "<StockItem>", GTK_STOCK_GOTO_TOP},
|
|
|
348 {"/-", NULL, NULL, 0, "<Separator>"},
|
|
|
349 {N_("/Jump to File"), "J", mainwin_general_menu_callback,
|
|
|
350 MAINWIN_GENERAL_JTF, "<StockItem>", GTK_STOCK_JUMP_TO},
|
|
|
351 {N_("/Jump to Time"), "<control>J", mainwin_general_menu_callback,
|
|
|
352 MAINWIN_GENERAL_JTT, "<StockItem>", GTK_STOCK_JUMP_TO},
|
|
|
353 };
|
|
|
354
|
|
|
355 static const gint mainwin_playback_menu_entries_num =
|
|
|
356 G_N_ELEMENTS(mainwin_playback_menu_entries);
|
|
|
357
|
|
|
358 /* Main menu */
|
|
|
359
|
|
|
360 static GtkItemFactoryEntry mainwin_general_menu_entries[] = {
|
|
|
361 { N_("/View Track Details"), "<alt>I", mainwin_general_menu_callback,
|
|
|
362 MAINWIN_GENERAL_FILEINFO, "<ImageItem>", my_pixbuf},
|
|
|
363 {"/-", NULL, NULL, 0, "<Separator>"},
|
|
|
364 {N_("/Preferences"), "<control>P", mainwin_general_menu_callback,
|
|
|
365 MAINWIN_GENERAL_PREFS, "<StockItem>", GTK_STOCK_PREFERENCES},
|
|
|
366 {N_("/_View"), NULL, NULL, 0, "<Item>"},
|
|
|
367 {"/-", NULL, NULL, 0, "<Separator>"},
|
|
|
368 {N_("/About Audacious"), NULL, mainwin_general_menu_callback,
|
|
|
369 MAINWIN_GENERAL_ABOUT, "<StockItem>", GTK_STOCK_DIALOG_INFO},
|
|
|
370 {N_("/_Quit"), NULL, mainwin_general_menu_callback,
|
|
|
371 MAINWIN_GENERAL_EXIT, "<StockItem>", GTK_STOCK_QUIT}
|
|
|
372 };
|
|
|
373
|
|
|
374 static const gint mainwin_general_menu_entries_num =
|
|
|
375 G_N_ELEMENTS(mainwin_general_menu_entries);
|
|
|
376
|
|
|
377 /* Add submenu */
|
|
|
378
|
|
|
379 static GtkItemFactoryEntry mainwin_add_menu_entries[] = {
|
|
|
380 {N_("/Files..."), "f", mainwin_general_menu_callback,
|
|
|
381 MAINWIN_GENERAL_PLAYFILE, "<StockItem>", GTK_STOCK_OPEN},
|
|
|
382 /*
|
|
|
383 {N_("/Folders..."), "d",
|
|
|
384 mainwin_general_menu_callback,
|
|
|
385 MAINWIN_GENERAL_PLAYDIRECTORY, "<StockItem>", GTK_STOCK_OPEN},
|
|
|
386 */
|
|
|
387 {N_("/Internet location..."), "<control>h", mainwin_general_menu_callback,
|
|
|
388 MAINWIN_GENERAL_PLAYLOCATION, "<StockItem>", GTK_STOCK_NETWORK},
|
|
|
389 };
|
|
|
390
|
|
|
391 static const gint mainwin_add_menu_entries_num =
|
|
|
392 G_N_ELEMENTS(mainwin_add_menu_entries);
|
|
|
393
|
|
|
394
|
|
|
395 /*
|
|
|
396 */
|
|
|
397
|
|
|
398 /* View submenu */
|
|
|
399
|
|
|
400 static GtkItemFactoryEntry mainwin_view_menu_entries[] = {
|
|
|
401 {N_("/Show Playlist Editor"), "<alt>E", mainwin_general_menu_callback,
|
|
|
402 MAINWIN_GENERAL_SHOWPLWIN, "<ToggleItem>"},
|
|
|
403 {N_("/Show Equalizer"), "<alt>G", mainwin_general_menu_callback,
|
|
|
404 MAINWIN_GENERAL_SHOWEQWIN, "<ToggleItem>"},
|
|
|
405 {"/-", NULL, NULL, 0, "<Separator>"},
|
|
|
406 {N_("/Time Elapsed"), "<control>E", mainwin_view_menu_callback,
|
|
|
407 MAINWIN_OPT_TELAPSED, "<RadioItem>"},
|
|
|
408 {N_("/Time Remaining"), "<control>R", mainwin_view_menu_callback,
|
|
|
409 MAINWIN_OPT_TREMAINING, "/Time Elapsed"},
|
|
|
410 {"/-", NULL, NULL, 0, "<Separator>"},
|
|
|
411 {N_("/Always On Top"), "<control>o", mainwin_view_menu_callback,
|
|
|
412 MAINWIN_OPT_ALWAYS, "<ToggleItem>"},
|
|
|
413 {N_("/Put on All Workspaces"), "<control>S",
|
|
|
414 mainwin_view_menu_callback, MAINWIN_OPT_STICKY, "<ToggleItem>"},
|
|
|
415 {"/-", NULL, NULL, 0, "<Separator>"},
|
|
|
416 {N_("/Roll up Player"), "<control>W", mainwin_view_menu_callback,
|
|
|
417 MAINWIN_OPT_WS, "<ToggleItem>"},
|
|
|
418 {N_("/Roll up Playlist Editor"), "<control><shift>W", mainwin_view_menu_callback,
|
|
|
419 MAINWIN_OPT_PWS, "<ToggleItem>"},
|
|
|
420 {N_("/Roll up Equalizer"), "<control><alt>W", mainwin_view_menu_callback,
|
|
|
421 MAINWIN_OPT_EQWS, "<ToggleItem>"}
|
|
|
422 };
|
|
|
423
|
|
|
424 static const gint mainwin_view_menu_entries_num =
|
|
|
425 G_N_ELEMENTS(mainwin_view_menu_entries);
|
|
|
426
|
|
|
427
|
|
|
428 static PlaybackInfo playback_info = { NULL, 0, 0, 0 };
|
|
|
429
|
|
|
430
|
|
|
431 static gint mainwin_idle_func(gpointer data);
|
|
|
432
|
|
|
433 static void set_timer_mode_menu_cb(TimerMode mode);
|
|
|
434 static void set_timer_mode(TimerMode mode);
|
|
|
435
|
|
|
436
|
|
|
437 /* FIXME: placed here for now */
|
|
|
438 void
|
|
|
439 playback_get_sample_params(gint * bitrate,
|
|
|
440 gint * frequency,
|
|
|
441 gint * n_channels)
|
|
|
442 {
|
|
|
443 if (bitrate)
|
|
|
444 *bitrate = playback_info.bitrate;
|
|
|
445
|
|
|
446 if (frequency)
|
|
|
447 *frequency = playback_info.frequency;
|
|
|
448
|
|
|
449 if (n_channels)
|
|
|
450 *n_channels = playback_info.n_channels;
|
|
|
451 }
|
|
|
452
|
|
|
453 static void
|
|
|
454 playback_set_sample_params(gint bitrate,
|
|
|
455 gint frequency,
|
|
|
456 gint n_channels)
|
|
|
457 {
|
|
|
458 if (bitrate >= 0)
|
|
|
459 playback_info.bitrate = bitrate;
|
|
|
460
|
|
|
461 if (frequency >= 0)
|
|
|
462 playback_info.frequency = frequency;
|
|
|
463
|
|
|
464 if (n_channels >= 0)
|
|
|
465 playback_info.n_channels = n_channels;
|
|
|
466 }
|
|
|
467
|
|
|
468 static void
|
|
|
469 mainwin_set_title_scroll(gboolean scroll)
|
|
|
470 {
|
|
|
471 cfg.autoscroll = scroll;
|
|
|
472 textbox_set_scroll(mainwin_info, cfg.autoscroll);
|
|
|
473 }
|
|
|
474
|
|
|
475
|
|
|
476 void
|
|
|
477 mainwin_set_always_on_top(gboolean always)
|
|
|
478 {
|
|
|
479 GtkWidget *widget = gtk_item_factory_get_widget(mainwin_view_menu,
|
|
|
480 "/Always On Top");
|
|
|
481 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget),
|
|
|
482 mainwin_menurow->mr_always_selected);
|
|
|
483 }
|
|
|
484
|
|
|
485 static void
|
|
|
486 mainwin_set_shape_mask(void)
|
|
|
487 {
|
|
|
488 GdkBitmap *mask;
|
|
|
489
|
|
|
490 if (!cfg.player_visible)
|
|
|
491 return;
|
|
|
492
|
|
|
493 mask = skin_get_mask(bmp_active_skin, SKIN_MASK_MAIN + cfg.player_shaded);
|
|
|
494 gtk_widget_shape_combine_mask(mainwin, mask, 0, 0);
|
|
|
495 }
|
|
|
496
|
|
|
497 static void
|
|
|
498 mainwin_set_shade(gboolean shaded)
|
|
|
499 {
|
|
|
500 GtkWidget *widget;
|
|
|
501 widget = gtk_item_factory_get_widget(mainwin_view_menu,
|
|
|
502 "/Roll up Player");
|
|
|
503 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), shaded);
|
|
|
504 }
|
|
|
505
|
|
|
506 static void
|
|
|
507 mainwin_set_shade_menu_cb(gboolean shaded)
|
|
|
508 {
|
|
|
509 cfg.player_shaded = shaded;
|
|
|
510
|
|
|
511 mainwin_set_shape_mask();
|
|
|
512
|
|
|
513 if (shaded) {
|
|
|
514 dock_shade(dock_window_list, GTK_WINDOW(mainwin),
|
|
|
515 MAINWIN_SHADED_HEIGHT);
|
|
|
516
|
|
|
517 widget_show(WIDGET(mainwin_svis));
|
|
|
518 vis_clear_data(mainwin_vis);
|
|
|
519
|
|
|
520 widget_show(WIDGET(mainwin_srew));
|
|
|
521 widget_show(WIDGET(mainwin_splay));
|
|
|
522 widget_show(WIDGET(mainwin_spause));
|
|
|
523 widget_show(WIDGET(mainwin_sstop));
|
|
|
524 widget_show(WIDGET(mainwin_sfwd));
|
|
|
525 widget_show(WIDGET(mainwin_seject));
|
|
|
526
|
|
|
527 widget_show(WIDGET(mainwin_stime_min));
|
|
|
528 widget_show(WIDGET(mainwin_stime_sec));
|
|
|
529
|
|
|
530 textbox_set_scroll(mainwin_info, FALSE);
|
|
|
531 if (bmp_playback_get_playing()
|
|
|
532 && playlist_get_current_length() != -1)
|
|
|
533 widget_show(WIDGET(mainwin_sposition));
|
|
|
534
|
|
|
535 mainwin_shade->pb_ny = mainwin_shade->pb_py = 27;
|
|
|
536 }
|
|
|
537 else {
|
|
|
538 dock_shade(dock_window_list, GTK_WINDOW(mainwin), MAINWIN_HEIGHT);
|
|
|
539
|
|
|
540 widget_hide(WIDGET(mainwin_svis));
|
|
|
541 svis_clear_data(mainwin_svis);
|
|
|
542
|
|
|
543 widget_hide(WIDGET(mainwin_srew));
|
|
|
544 widget_hide(WIDGET(mainwin_splay));
|
|
|
545 widget_hide(WIDGET(mainwin_spause));
|
|
|
546 widget_hide(WIDGET(mainwin_sstop));
|
|
|
547 widget_hide(WIDGET(mainwin_sfwd));
|
|
|
548 widget_hide(WIDGET(mainwin_seject));
|
|
|
549
|
|
|
550 widget_hide(WIDGET(mainwin_stime_min));
|
|
|
551 widget_hide(WIDGET(mainwin_stime_sec));
|
|
|
552 widget_hide(WIDGET(mainwin_sposition));
|
|
|
553
|
|
|
554 textbox_set_scroll(mainwin_info, TRUE);
|
|
|
555 mainwin_shade->pb_ny = mainwin_shade->pb_py = 18;
|
|
|
556 }
|
|
|
557
|
|
|
558 draw_main_window(TRUE);
|
|
|
559 }
|
|
|
560
|
|
|
561 static void
|
|
|
562 mainwin_vis_set_active_vis(gint new_vis)
|
|
|
563 {
|
|
|
564 switch (new_vis) {
|
|
|
565 case MAINWIN_VIS_ACTIVE_MAINWIN:
|
|
|
566 playlistwin_vis_disable();
|
|
|
567 active_vis = mainwin_vis;
|
|
|
568 break;
|
|
|
569 case MAINWIN_VIS_ACTIVE_PLAYLISTWIN:
|
|
|
570 playlistwin_vis_enable();
|
|
|
571 active_vis = playlistwin_vis;
|
|
|
572 break;
|
|
|
573 }
|
|
|
574 }
|
|
|
575
|
|
|
576 static void
|
|
|
577 mainwin_vis_set_refresh(RefreshRate rate)
|
|
|
578 {
|
|
|
579 cfg.vis_refresh = rate;
|
|
|
580 }
|
|
|
581
|
|
|
582 static void
|
|
|
583 mainwin_vis_set_afalloff(FalloffSpeed speed)
|
|
|
584 {
|
|
|
585 cfg.analyzer_falloff = speed;
|
|
|
586 }
|
|
|
587
|
|
|
588 static void
|
|
|
589 mainwin_vis_set_pfalloff(FalloffSpeed speed)
|
|
|
590 {
|
|
|
591 cfg.peaks_falloff = speed;
|
|
|
592 }
|
|
|
593
|
|
|
594 static void
|
|
|
595 mainwin_vis_set_analyzer_mode(AnalyzerMode mode)
|
|
|
596 {
|
|
|
597 cfg.analyzer_mode = mode;
|
|
|
598 }
|
|
|
599
|
|
|
600 static void
|
|
|
601 mainwin_vis_set_analyzer_type(AnalyzerType mode)
|
|
|
602 {
|
|
|
603 cfg.analyzer_type = mode;
|
|
|
604 }
|
|
|
605
|
|
|
606 void
|
|
|
607 mainwin_vis_set_type(VisType mode)
|
|
|
608 {
|
|
|
609 gchar *path =
|
|
|
610 mainwin_vis_menu_entries[MAINWIN_VIS_MENU_VIS_MODE + mode].path;
|
|
|
611 GtkWidget *widget = gtk_item_factory_get_widget(mainwin_vis_menu, path);
|
|
|
612 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), TRUE);
|
|
|
613 }
|
|
|
614
|
|
|
615 static void
|
|
|
616 mainwin_vis_set_type_menu_cb(VisType mode)
|
|
|
617 {
|
|
|
618 cfg.vis_type = mode;
|
|
|
619
|
|
|
620 if (mode == VIS_OFF) {
|
|
|
621 if (cfg.player_shaded && cfg.player_visible)
|
|
|
622 svis_clear(mainwin_svis);
|
|
|
623 else
|
|
|
624 vis_clear(active_vis);
|
|
|
625 }
|
|
|
626 if (mode == VIS_ANALYZER) {
|
|
|
627 vis_clear_data(active_vis);
|
|
|
628 svis_clear_data(mainwin_svis);
|
|
|
629 }
|
|
|
630 }
|
|
|
631
|
|
|
632 static void
|
|
|
633 mainwin_menubtn_cb(void)
|
|
|
634 {
|
|
|
635 gint x, y;
|
|
|
636 gtk_window_get_position(GTK_WINDOW(mainwin), &x, &y);
|
|
|
637 util_item_factory_popup(mainwin_general_menu,
|
|
|
638 x + 6,
|
|
|
639 y + MAINWIN_SHADED_HEIGHT,
|
|
|
640 1, GDK_CURRENT_TIME);
|
|
|
641 }
|
|
|
642
|
|
|
643 void
|
|
|
644 mainwin_minimize_cb(void)
|
|
|
645 {
|
|
|
646 if (!mainwin)
|
|
|
647 return;
|
|
|
648
|
|
|
649 gtk_window_iconify(GTK_WINDOW(mainwin));
|
|
|
650 }
|
|
|
651
|
|
|
652 static void
|
|
|
653 mainwin_shade_toggle(void)
|
|
|
654 {
|
|
|
655 mainwin_set_shade(!cfg.player_shaded);
|
|
|
656 }
|
|
|
657
|
|
|
658 void
|
|
|
659 mainwin_quit_cb(void)
|
|
|
660 {
|
|
|
661 gtk_widget_hide(equalizerwin);
|
|
|
662 gtk_widget_hide(playlistwin);
|
|
|
663 gtk_widget_hide(mainwin);
|
|
|
664 gdk_flush();
|
|
|
665
|
|
|
666 g_source_remove(mainwin_timeout_id);
|
|
|
667
|
|
|
668 util_set_cursor(NULL);
|
|
|
669
|
|
|
670 bmp_config_save();
|
|
|
671 gtk_accel_map_save(bmp_paths[BMP_PATH_ACCEL_FILE]);
|
|
|
672
|
|
|
673 ctrlsocket_cleanup();
|
|
|
674
|
|
|
675 playlist_stop_get_info_thread();
|
|
|
676 playlist_clear();
|
|
|
677
|
|
|
678 plugin_system_cleanup();
|
|
|
679
|
|
|
680 gtk_main_quit();
|
|
|
681 }
|
|
|
682
|
|
|
683 static void
|
|
|
684 mainwin_destroy(GtkWidget * widget, gpointer data)
|
|
|
685 {
|
|
|
686 mainwin_quit_cb();
|
|
|
687 }
|
|
|
688
|
|
|
689 static void
|
|
|
690 mainwin_draw_titlebar(gboolean focus)
|
|
|
691 {
|
|
|
692 skin_draw_mainwin_titlebar(bmp_active_skin, mainwin_bg, mainwin_gc,
|
|
|
693 cfg.player_shaded, focus || !cfg.dim_titlebar);
|
|
|
694 }
|
|
|
695
|
|
|
696 void
|
|
|
697 draw_main_window(gboolean force)
|
|
|
698 {
|
|
|
699 GList *wl;
|
|
|
700 Widget *w;
|
|
|
701 gboolean redraw;
|
|
|
702
|
|
|
703 if (!cfg.player_visible)
|
|
|
704 return;
|
|
|
705
|
|
|
706 widget_list_lock(mainwin_wlist);
|
|
|
707
|
|
|
708 if (force) {
|
|
|
709 if (!cfg.player_shaded)
|
|
|
710 skin_draw_pixmap(bmp_active_skin, mainwin_bg, mainwin_gc,
|
|
|
711 SKIN_MAIN, 0, 0, 0, 0, MAINWIN_WIDTH,
|
|
|
712 MAINWIN_HEIGHT);
|
|
|
713 mainwin_draw_titlebar(gtk_window_has_toplevel_focus
|
|
|
714 (GTK_WINDOW(mainwin)));
|
|
|
715 }
|
|
|
716
|
|
|
717 widget_list_draw(mainwin_wlist, &redraw, force);
|
|
|
718
|
|
|
719 if (redraw || force) {
|
|
|
720 if (force) {
|
|
|
721 gdk_window_clear(mainwin->window);
|
|
|
722 }
|
|
|
723 else {
|
|
|
724 for (wl = mainwin_wlist; wl; wl = g_list_next(wl)) {
|
|
|
725 w = WIDGET(wl->data);
|
|
|
726
|
|
|
727 if (!w->redraw || !w->visible)
|
|
|
728 continue;
|
|
|
729
|
|
|
730 gdk_window_clear_area(mainwin->window, w->x, w->y,
|
|
|
731 w->width, w->height);
|
|
|
732 w->redraw = FALSE;
|
|
|
733 }
|
|
|
734 }
|
|
|
735
|
|
|
736 gdk_flush();
|
|
|
737 }
|
|
|
738
|
|
|
739 widget_list_unlock(mainwin_wlist);
|
|
|
740 }
|
|
|
741
|
|
|
742
|
|
|
743 void
|
|
|
744 mainwin_set_info_text(void)
|
|
|
745 {
|
|
|
746 gchar *text;
|
|
|
747
|
|
|
748 if (mainwin_info_text_locked)
|
|
|
749 return;
|
|
|
750
|
|
|
751 if ((text = input_get_info_text()) != NULL) {
|
|
|
752 textbox_set_text(mainwin_info, text);
|
|
|
753 g_free(text);
|
|
|
754 }
|
|
|
755 else if ((text = playlist_get_info_text()) != NULL) {
|
|
|
756 textbox_set_text(mainwin_info, text);
|
|
|
757 g_free(text);
|
|
|
758 }
|
|
|
759 }
|
|
|
760
|
|
|
761 void
|
|
|
762 mainwin_lock_info_text(const gchar * text)
|
|
|
763 {
|
|
|
764 mainwin_info_text_locked = TRUE;
|
|
|
765 textbox_set_text(mainwin_info, text);
|
|
|
766 }
|
|
|
767
|
|
|
768 void
|
|
|
769 mainwin_release_info_text(void)
|
|
|
770 {
|
|
|
771 mainwin_info_text_locked = FALSE;
|
|
|
772 mainwin_set_info_text();
|
|
|
773 }
|
|
|
774
|
|
|
775
|
|
|
776 static gchar *
|
|
|
777 make_mainwin_title(const gchar * title)
|
|
|
778 {
|
|
|
779 if (title)
|
|
|
780 return g_strdup_printf(_("%s - Audacious"), title);
|
|
|
781 else
|
|
|
782 return g_strdup(_("Audacious"));
|
|
|
783 }
|
|
|
784
|
|
|
785 void
|
|
|
786 mainwin_set_song_title(const gchar * title)
|
|
|
787 {
|
|
|
788 G_LOCK(mainwin_title);
|
|
|
789 g_free(mainwin_title_text);
|
|
|
790 mainwin_title_text = make_mainwin_title(title);
|
|
|
791 G_UNLOCK(mainwin_title);
|
|
|
792 }
|
|
|
793
|
|
|
794 void
|
|
|
795 mainwin_set_song_info(gint bitrate,
|
|
|
796 gint frequency,
|
|
|
797 gint n_channels)
|
|
|
798 {
|
|
|
799 gchar text[10];
|
|
|
800 gchar *title;
|
|
|
801
|
|
|
802 playback_set_sample_params(bitrate, frequency, n_channels);
|
|
|
803
|
|
|
804 if (bitrate != -1) {
|
|
|
805 bitrate /= 1000;
|
|
|
806
|
|
|
807 if (bitrate < 1000) {
|
|
|
808 /* Show bitrate in 1000s */
|
|
|
809 g_snprintf(text, sizeof(text), "%3d", bitrate);
|
|
|
810 textbox_set_text(mainwin_rate_text, text);
|
|
|
811 }
|
|
|
812 else {
|
|
|
813 /* Show bitrate in 100,000s */
|
|
|
814 bitrate /= 100;
|
|
|
815 g_snprintf(text, sizeof(text), "%2dH", bitrate);
|
|
|
816 textbox_set_text(mainwin_rate_text, text);
|
|
|
817 }
|
|
|
818 }
|
|
|
819 else
|
|
|
820 textbox_set_text(mainwin_rate_text, _("VBR"));
|
|
|
821
|
|
|
822 /* Show sampling frequency in kHz */
|
|
|
823 g_snprintf(text, sizeof(text), "%2d", frequency / 1000);
|
|
|
824 textbox_set_text(mainwin_freq_text, text);
|
|
|
825
|
|
|
826 monostereo_set_num_channels(mainwin_monostereo, n_channels);
|
|
|
827
|
|
|
828 widget_show(WIDGET(mainwin_minus_num));
|
|
|
829 widget_show(WIDGET(mainwin_10min_num));
|
|
|
830 widget_show(WIDGET(mainwin_min_num));
|
|
|
831 widget_show(WIDGET(mainwin_10sec_num));
|
|
|
832 widget_show(WIDGET(mainwin_sec_num));
|
|
|
833
|
|
|
834 if (!bmp_playback_get_paused())
|
|
|
835 playstatus_set_status(mainwin_playstatus, STATUS_PLAY);
|
|
|
836
|
|
|
837 if (playlist_get_current_length() != -1) {
|
|
|
838 if (cfg.player_shaded)
|
|
|
839 widget_show(WIDGET(mainwin_sposition));
|
|
|
840 widget_show(WIDGET(mainwin_position));
|
|
|
841 }
|
|
|
842 else {
|
|
|
843 widget_hide(WIDGET(mainwin_position));
|
|
|
844 widget_hide(WIDGET(mainwin_sposition));
|
|
|
845 mainwin_force_redraw = TRUE;
|
|
|
846 }
|
|
|
847
|
|
|
848 title = playlist_get_info_text();
|
|
|
849 mainwin_set_song_title(title);
|
|
|
850 g_free(title);
|
|
|
851 }
|
|
|
852
|
|
|
853 void
|
|
|
854 mainwin_clear_song_info(void)
|
|
|
855 {
|
|
|
856 /* clear title */
|
|
|
857 G_LOCK(mainwin_title);
|
|
|
858 g_free(mainwin_title_text);
|
|
|
859 mainwin_title_text = NULL;
|
|
|
860 G_UNLOCK(mainwin_title);
|
|
|
861
|
|
|
862 /* clear sampling parameters */
|
|
|
863 playback_set_sample_params(0, 0, 0);
|
|
|
864
|
|
|
865 mainwin_position->hs_pressed = FALSE;
|
|
|
866 mainwin_sposition->hs_pressed = FALSE;
|
|
|
867
|
|
|
868 /* clear sampling parameter displays */
|
|
|
869 textbox_set_text(mainwin_rate_text, " ");
|
|
|
870 textbox_set_text(mainwin_freq_text, " ");
|
|
|
871 monostereo_set_num_channels(mainwin_monostereo, 0);
|
|
|
872
|
|
|
873 playstatus_set_status(mainwin_playstatus, STATUS_STOP);
|
|
|
874
|
|
|
875 /* hide playback time */
|
|
|
876 widget_hide(WIDGET(mainwin_minus_num));
|
|
|
877 widget_hide(WIDGET(mainwin_10min_num));
|
|
|
878 widget_hide(WIDGET(mainwin_min_num));
|
|
|
879 widget_hide(WIDGET(mainwin_10sec_num));
|
|
|
880 widget_hide(WIDGET(mainwin_sec_num));
|
|
|
881
|
|
|
882 textbox_set_text(mainwin_stime_min, " ");
|
|
|
883 textbox_set_text(mainwin_stime_sec, " ");
|
|
|
884
|
|
|
885 widget_hide(WIDGET(mainwin_position));
|
|
|
886 widget_hide(WIDGET(mainwin_sposition));
|
|
|
887
|
|
|
888 playlistwin_hide_timer();
|
|
|
889 draw_main_window(TRUE);
|
|
|
890
|
|
|
891 vis_clear(active_vis);
|
|
|
892 }
|
|
|
893
|
|
|
894 void
|
|
|
895 mainwin_disable_seekbar(void)
|
|
|
896 {
|
|
|
897 /*
|
|
|
898 * We dont call draw_main_window() here so this will not
|
|
|
899 * remove them visually. It will only prevent us from sending
|
|
|
900 * any seek calls to the input plugin before the input plugin
|
|
|
901 * calls ->set_info().
|
|
|
902 */
|
|
|
903 widget_hide(WIDGET(mainwin_position));
|
|
|
904 widget_hide(WIDGET(mainwin_sposition));
|
|
|
905 }
|
|
|
906
|
|
|
907 static gboolean
|
|
|
908 mainwin_mouse_button_release(GtkWidget * widget,
|
|
|
909 GdkEventButton * event,
|
|
|
910 gpointer callback_data)
|
|
|
911 {
|
|
|
912 gdk_pointer_ungrab(GDK_CURRENT_TIME);
|
|
|
913
|
|
|
914 /*
|
|
|
915 * The gdk_flush() is just for making sure that the pointer really
|
|
|
916 * gets ungrabbed before calling any button callbacks
|
|
|
917 *
|
|
|
918 */
|
|
|
919
|
|
|
920 gdk_flush();
|
|
|
921
|
|
|
922 if (dock_is_moving(GTK_WINDOW(mainwin))) {
|
|
|
923 dock_move_release(GTK_WINDOW(mainwin));
|
|
|
924 }
|
|
|
925
|
|
|
926 if (mainwin_menurow->mr_doublesize_selected) {
|
|
|
927 event->x /= 2;
|
|
|
928 event->y /= 2;
|
|
|
929 }
|
|
|
930
|
|
|
931 handle_release_cb(mainwin_wlist, widget, event);
|
|
|
932
|
|
|
933 draw_main_window(FALSE);
|
|
|
934
|
|
|
935 return FALSE;
|
|
|
936 }
|
|
|
937
|
|
|
938 static gboolean
|
|
|
939 mainwin_motion(GtkWidget * widget,
|
|
|
940 GdkEventMotion * event,
|
|
|
941 gpointer callback_data)
|
|
|
942 {
|
|
|
943 XEvent ev;
|
|
|
944 gint i = 0;
|
|
|
945
|
|
|
946 XSync(GDK_DISPLAY(), False);
|
|
|
947
|
|
|
948 while (XCheckTypedEvent(GDK_DISPLAY(), MotionNotify, &ev)) {
|
|
|
949 event->x = ev.xmotion.x;
|
|
|
950 event->y = ev.xmotion.y;
|
|
|
951 i++;
|
|
|
952 }
|
|
|
953
|
|
|
954 if (dock_is_moving(GTK_WINDOW(mainwin))) {
|
|
|
955 dock_move_motion(GTK_WINDOW(mainwin), event);
|
|
|
956 }
|
|
|
957 else {
|
|
|
958 handle_motion_cb(mainwin_wlist, widget, event);
|
|
|
959 draw_main_window(FALSE);
|
|
|
960 }
|
|
|
961 gdk_flush();
|
|
|
962
|
|
|
963 return FALSE;
|
|
|
964 }
|
|
|
965
|
|
|
966 static gboolean
|
|
|
967 inside_sensitive_widgets(gint x, gint y)
|
|
|
968 {
|
|
|
969 return (widget_contains(WIDGET(mainwin_menubtn), x, y)
|
|
|
970 || widget_contains(WIDGET(mainwin_minimize), x, y)
|
|
|
971 || widget_contains(WIDGET(mainwin_shade), x, y)
|
|
|
972 || widget_contains(WIDGET(mainwin_close), x, y)
|
|
|
973 || widget_contains(WIDGET(mainwin_rew), x, y)
|
|
|
974 || widget_contains(WIDGET(mainwin_play), x, y)
|
|
|
975 || widget_contains(WIDGET(mainwin_pause), x, y)
|
|
|
976 || widget_contains(WIDGET(mainwin_stop), x, y)
|
|
|
977 || widget_contains(WIDGET(mainwin_fwd), x, y)
|
|
|
978 || widget_contains(WIDGET(mainwin_eject), x, y)
|
|
|
979 || widget_contains(WIDGET(mainwin_shuffle), x, y)
|
|
|
980 || widget_contains(WIDGET(mainwin_repeat), x, y)
|
|
|
981 || widget_contains(WIDGET(mainwin_pl), x, y)
|
|
|
982 || widget_contains(WIDGET(mainwin_eq), x, y)
|
|
|
983 || widget_contains(WIDGET(mainwin_info), x, y)
|
|
|
984 || widget_contains(WIDGET(mainwin_menurow), x, y)
|
|
|
985 || widget_contains(WIDGET(mainwin_volume), x, y)
|
|
|
986 || widget_contains(WIDGET(mainwin_balance), x, y)
|
|
|
987 || (widget_contains(WIDGET(mainwin_position), x, y) &&
|
|
|
988 widget_is_visible(WIDGET(mainwin_position)))
|
|
|
989 || widget_contains(WIDGET(mainwin_minus_num), x, y)
|
|
|
990 || widget_contains(WIDGET(mainwin_10min_num), x, y)
|
|
|
991 || widget_contains(WIDGET(mainwin_min_num), x, y)
|
|
|
992 || widget_contains(WIDGET(mainwin_10sec_num), x, y)
|
|
|
993 || widget_contains(WIDGET(mainwin_sec_num), x, y)
|
|
|
994 || widget_contains(WIDGET(mainwin_vis), x, y)
|
|
|
995 || widget_contains(WIDGET(mainwin_minimize), x, y)
|
|
|
996 || widget_contains(WIDGET(mainwin_shade), x, y)
|
|
|
997 || widget_contains(WIDGET(mainwin_close), x, y)
|
|
|
998 || widget_contains(WIDGET(mainwin_menubtn), x, y)
|
|
|
999 || widget_contains(WIDGET(mainwin_sposition), x, y)
|
|
|
1000 || widget_contains(WIDGET(mainwin_stime_min), x, y)
|
|
|
1001 || widget_contains(WIDGET(mainwin_stime_sec), x, y)
|
|
|
1002 || widget_contains(WIDGET(mainwin_srew), x, y)
|
|
|
1003 || widget_contains(WIDGET(mainwin_splay), x, y)
|
|
|
1004 || widget_contains(WIDGET(mainwin_spause), x, y)
|
|
|
1005 || widget_contains(WIDGET(mainwin_sstop), x, y)
|
|
|
1006 || widget_contains(WIDGET(mainwin_sfwd), x, y)
|
|
|
1007 || widget_contains(WIDGET(mainwin_seject), x, y)
|
|
|
1008 || widget_contains(WIDGET(mainwin_svis), x, y)
|
|
|
1009 || widget_contains(WIDGET(mainwin_about), x, y));
|
|
|
1010 }
|
|
|
1011
|
|
|
1012 void
|
|
|
1013 mainwin_scrolled(GtkWidget * widget,
|
|
|
1014 GdkEventScroll * event,
|
|
|
1015 gpointer callback_data)
|
|
|
1016 {
|
|
|
1017 gint d = cfg.mouse_change;
|
|
|
1018 if (event->direction == GDK_SCROLL_DOWN)
|
|
|
1019 d *= -1;
|
|
|
1020 mainwin_set_volume_diff(d);
|
|
|
1021 }
|
|
|
1022
|
|
|
1023
|
|
|
1024 static gboolean
|
|
|
1025 mainwin_mouse_button_press(GtkWidget * widget,
|
|
|
1026 GdkEventButton * event,
|
|
|
1027 gpointer callback_data)
|
|
|
1028 {
|
|
|
1029
|
|
|
1030 gboolean grab = TRUE;
|
|
|
1031
|
|
|
1032 if (event->button == 1 && event->type == GDK_BUTTON_PRESS &&
|
|
|
1033 !inside_sensitive_widgets(event->x, event->y) && event->y < 14) {
|
|
|
1034 if (0 && hint_move_resize_available()) {
|
|
|
1035 hint_move_resize(mainwin, event->x_root, event->y_root, TRUE);
|
|
|
1036 grab = FALSE;
|
|
|
1037 }
|
|
|
1038 else {
|
|
|
1039 gtk_window_present(GTK_WINDOW(mainwin));
|
|
|
1040 dock_move_press(dock_window_list, GTK_WINDOW(mainwin), event,
|
|
|
1041 TRUE);
|
|
|
1042 }
|
|
|
1043 }
|
|
|
1044 else if (event->button == 1 && event->type == GDK_2BUTTON_PRESS &&
|
|
|
1045 event->y < 14 && !inside_sensitive_widgets(event->x, event->y)) {
|
|
|
1046 mainwin_set_shade(!cfg.player_shaded);
|
|
|
1047 if (dock_is_moving(GTK_WINDOW(mainwin)))
|
|
|
1048 dock_move_release(GTK_WINDOW(mainwin));
|
|
|
1049 }
|
|
|
1050 else if (event->button == 1 && event->type == GDK_2BUTTON_PRESS &&
|
|
|
1051 widget_contains(WIDGET(mainwin_info), event->x, event->y)) {
|
|
|
1052 playlist_fileinfo_current();
|
|
|
1053 }
|
|
|
1054 else {
|
|
|
1055 handle_press_cb(mainwin_wlist, widget, event);
|
|
|
1056 draw_main_window(FALSE);
|
|
|
1057 }
|
|
|
1058
|
|
|
1059 if ((event->button == 1) && event->type != GDK_2BUTTON_PRESS &&
|
|
|
1060 (widget_contains(WIDGET(mainwin_vis), event->x, event->y) ||
|
|
|
1061 widget_contains(WIDGET(mainwin_svis), event->x, event->y))) {
|
|
|
1062
|
|
|
1063 cfg.vis_type++;
|
|
|
1064
|
|
|
1065 if (cfg.vis_type > VIS_OFF)
|
|
|
1066 cfg.vis_type = VIS_ANALYZER;
|
|
|
1067
|
|
|
1068 mainwin_vis_set_type(cfg.vis_type);
|
|
|
1069 }
|
|
|
1070
|
|
|
1071 if (event->button == 3) {
|
|
|
1072 if (widget_contains(WIDGET(mainwin_info), event->x, event->y)) {
|
|
|
1073 util_item_factory_popup(mainwin_songname_menu,
|
|
|
1074 event->x_root, event->y_root,
|
|
|
1075 3, event->time);
|
|
|
1076 grab = FALSE;
|
|
|
1077 }
|
|
|
1078 else if (widget_contains(WIDGET(mainwin_vis), event->x, event->y) ||
|
|
|
1079 widget_contains(WIDGET(mainwin_svis), event->x, event->y)) {
|
|
|
1080 util_item_factory_popup(mainwin_vis_menu, event->x_root,
|
|
|
1081 event->y_root, 3, event->time);
|
|
|
1082 grab = FALSE;
|
|
|
1083 }
|
|
|
1084 else if ( (event->y > 70) && (event->x < 128) )
|
|
|
1085 {
|
|
|
1086
|
|
|
1087 util_item_factory_popup(mainwin_play_menu,
|
|
|
1088 event->x_root,
|
|
|
1089 event->y_root, 3, event->time);
|
|
|
1090 grab = FALSE;
|
|
|
1091 } else {
|
|
|
1092 /*
|
|
|
1093 * Pop up the main menu a few pixels down.
|
|
|
1094 * This will avoid that anything is selected
|
|
|
1095 * if one right-clicks to focus the window
|
|
|
1096 * without raising it.
|
|
|
1097 *
|
|
|
1098 ***MD I think the above is stupid, people don't expect this
|
|
|
1099 *
|
|
|
1100 */
|
|
|
1101 util_item_factory_popup(mainwin_general_menu,
|
|
|
1102 event->x_root,
|
|
|
1103 event->y_root, 3, event->time);
|
|
|
1104 grab = FALSE;
|
|
|
1105 }
|
|
|
1106 }
|
|
|
1107 if (event->button == 1) {
|
|
|
1108 if ((event->x > 35 && event->x < 100 &&
|
|
|
1109 event->y > 25 && event->y < 40) ||
|
|
|
1110 widget_contains(WIDGET(mainwin_stime_min), event->x, event->y) ||
|
|
|
1111 widget_contains(WIDGET(mainwin_stime_sec), event->x, event->y)) {
|
|
|
1112
|
|
|
1113 if (cfg.timer_mode == TIMER_ELAPSED)
|
|
|
1114 set_timer_mode(TIMER_REMAINING);
|
|
|
1115 else
|
|
|
1116 set_timer_mode(TIMER_ELAPSED);
|
|
|
1117 }
|
|
|
1118
|
|
|
1119 }
|
|
|
1120
|
|
|
1121 if (grab)
|
|
|
1122 gdk_pointer_grab(mainwin->window, FALSE,
|
|
|
1123 GDK_BUTTON_MOTION_MASK |
|
|
|
1124 GDK_BUTTON_RELEASE_MASK,
|
|
|
1125 GDK_WINDOW(GDK_NONE), NULL, GDK_CURRENT_TIME);
|
|
|
1126
|
|
|
1127 return FALSE;
|
|
|
1128 }
|
|
|
1129
|
|
|
1130 static gboolean
|
|
|
1131 mainwin_focus_in(GtkWidget * window,
|
|
|
1132 GdkEventFocus * event,
|
|
|
1133 gpointer data)
|
|
|
1134 {
|
|
|
1135 mainwin_menubtn->pb_allow_draw = TRUE;
|
|
|
1136 mainwin_minimize->pb_allow_draw = TRUE;
|
|
|
1137 mainwin_shade->pb_allow_draw = TRUE;
|
|
|
1138 mainwin_close->pb_allow_draw = TRUE;
|
|
|
1139 draw_main_window(TRUE);
|
|
|
1140
|
|
|
1141 return TRUE;
|
|
|
1142 }
|
|
|
1143
|
|
|
1144
|
|
|
1145 static gboolean
|
|
|
1146 mainwin_focus_out(GtkWidget * widget,
|
|
|
1147 GdkEventFocus * event,
|
|
|
1148 gpointer callback_data)
|
|
|
1149 {
|
|
|
1150 mainwin_menubtn->pb_allow_draw = FALSE;
|
|
|
1151 mainwin_minimize->pb_allow_draw = FALSE;
|
|
|
1152 mainwin_shade->pb_allow_draw = FALSE;
|
|
|
1153 mainwin_close->pb_allow_draw = FALSE;
|
|
|
1154 draw_main_window(TRUE);
|
|
|
1155
|
|
|
1156 return TRUE;
|
|
|
1157 }
|
|
|
1158
|
|
|
1159 static gboolean
|
|
|
1160 mainwin_keypress(GtkWidget * grab_widget,
|
|
|
1161 GdkEventKey * event,
|
|
|
1162 gpointer data)
|
|
|
1163 {
|
|
|
1164
|
|
|
1165 switch (event->keyval) {
|
|
|
1166
|
|
|
1167 case GDK_Up:
|
|
|
1168 case GDK_KP_Up:
|
|
|
1169 mainwin_set_volume_diff(2);
|
|
|
1170 break;
|
|
|
1171 case GDK_Down:
|
|
|
1172 case GDK_KP_Down:
|
|
|
1173 mainwin_set_volume_diff(-2);
|
|
|
1174 break;
|
|
|
1175 case GDK_Left:
|
|
|
1176 case GDK_KP_Left:
|
|
|
1177 if (playlist_get_current_length() != -1)
|
|
|
1178 bmp_playback_seek(CLAMP
|
|
|
1179 (bmp_playback_get_time() - 5000, 0,
|
|
|
1180 playlist_get_current_length()) / 1000);
|
|
|
1181 break;
|
|
|
1182 case GDK_Right:
|
|
|
1183 case GDK_KP_Right:
|
|
|
1184 if (playlist_get_current_length() != -1)
|
|
|
1185 bmp_playback_seek(CLAMP
|
|
|
1186 (bmp_playback_get_time() + 5000, 0,
|
|
|
1187 playlist_get_current_length()) / 1000);
|
|
|
1188 break;
|
|
|
1189 case GDK_Escape:
|
|
|
1190 mainwin_minimize_cb();
|
|
|
1191 break;
|
|
|
1192 default:
|
|
|
1193 return FALSE;
|
|
|
1194 }
|
|
|
1195
|
|
|
1196 return TRUE;
|
|
|
1197 }
|
|
|
1198
|
|
|
1199 static void
|
|
|
1200 mainwin_jump_to_time_cb(GtkWidget * widget,
|
|
|
1201 GtkWidget * entry)
|
|
|
1202 {
|
|
|
1203 guint min = 0, sec = 0, params, time;
|
|
|
1204
|
|
|
1205 params = sscanf(gtk_entry_get_text(GTK_ENTRY(entry)), "%u:%u",
|
|
|
1206 &min, &sec);
|
|
|
1207 if (params == 2)
|
|
|
1208 time = (min * 60) + sec;
|
|
|
1209 else if (params == 1)
|
|
|
1210 time = min;
|
|
|
1211 else
|
|
|
1212 return;
|
|
|
1213
|
|
|
1214 if (playlist_get_current_length() > -1 &&
|
|
|
1215 time <= (playlist_get_current_length() / 1000)) {
|
|
|
1216 bmp_playback_seek(time);
|
|
|
1217 gtk_widget_destroy(mainwin_jtt);
|
|
|
1218 }
|
|
|
1219 }
|
|
|
1220
|
|
|
1221
|
|
|
1222 void
|
|
|
1223 mainwin_jump_to_time(void)
|
|
|
1224 {
|
|
|
1225 GtkWidget *vbox, *hbox_new, *hbox_total;
|
|
|
1226 GtkWidget *time_entry, *label, *bbox, *jump, *cancel;
|
|
|
1227 guint tindex;
|
|
|
1228 gchar time_str[10];
|
|
|
1229
|
|
|
1230 if (!bmp_playback_get_playing()) {
|
|
|
1231 /* FIXME: pop an error dialog and/or disable menu option to
|
|
|
1232 indicate JTT can't be launched when no track is being
|
|
|
1233 played */
|
|
|
1234 return;
|
|
|
1235 }
|
|
|
1236
|
|
|
1237 if (mainwin_jtt) {
|
|
|
1238 gtk_window_present(GTK_WINDOW(mainwin_jtt));
|
|
|
1239 return;
|
|
|
1240 }
|
|
|
1241
|
|
|
1242 mainwin_jtt = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
|
|
1243 gtk_window_set_type_hint(GTK_WINDOW(mainwin_jtt),
|
|
|
1244 GDK_WINDOW_TYPE_HINT_DIALOG);
|
|
|
1245
|
|
|
1246 gtk_window_set_title(GTK_WINDOW(mainwin_jtt), _("Jump to Time"));
|
|
|
1247 gtk_window_set_position(GTK_WINDOW(mainwin_jtt), GTK_WIN_POS_CENTER);
|
|
|
1248 gtk_window_set_transient_for(GTK_WINDOW(mainwin_jtt),
|
|
|
1249 GTK_WINDOW(mainwin));
|
|
|
1250
|
|
|
1251 g_signal_connect(mainwin_jtt, "destroy",
|
|
|
1252 G_CALLBACK(gtk_widget_destroyed), &mainwin_jtt);
|
|
|
1253 gtk_container_border_width(GTK_CONTAINER(mainwin_jtt), 10);
|
|
|
1254
|
|
|
1255 vbox = gtk_vbox_new(FALSE, 5);
|
|
|
1256 gtk_container_add(GTK_CONTAINER(mainwin_jtt), vbox);
|
|
|
1257
|
|
|
1258 hbox_new = gtk_hbox_new(FALSE, 0);
|
|
|
1259 gtk_box_pack_start(GTK_BOX(vbox), hbox_new, TRUE, TRUE, 5);
|
|
|
1260
|
|
|
1261 time_entry = gtk_entry_new();
|
|
|
1262 gtk_box_pack_start(GTK_BOX(hbox_new), time_entry, FALSE, FALSE, 5);
|
|
|
1263 g_signal_connect(time_entry, "activate",
|
|
|
1264 G_CALLBACK(mainwin_jump_to_time_cb), time_entry);
|
|
|
1265
|
|
|
1266 gtk_widget_set_size_request(time_entry, 70, -1);
|
|
|
1267 label = gtk_label_new(_("minutes:seconds"));
|
|
|
1268 gtk_box_pack_start(GTK_BOX(hbox_new), label, FALSE, FALSE, 5);
|
|
|
1269
|
|
|
1270 hbox_total = gtk_hbox_new(FALSE, 0);
|
|
|
1271 gtk_box_pack_start(GTK_BOX(vbox), hbox_total, TRUE, TRUE, 5);
|
|
|
1272 gtk_widget_show(hbox_total);
|
|
|
1273
|
|
|
1274 /* FIXME: Disable display of current track length. It's not
|
|
|
1275 updated when track changes */
|
|
|
1276 #if 0
|
|
|
1277 label = gtk_label_new(_("Track length:"));
|
|
|
1278 gtk_box_pack_start(GTK_BOX(hbox_total), label, FALSE, FALSE, 5);
|
|
|
1279
|
|
|
1280 len = playlist_get_current_length() / 1000;
|
|
|
1281 g_snprintf(time_str, sizeof(time_str), "%u:%2.2u", len / 60, len % 60);
|
|
|
1282 label = gtk_label_new(time_str);
|
|
|
1283
|
|
|
1284 gtk_box_pack_start(GTK_BOX(hbox_total), label, FALSE, FALSE, 10);
|
|
|
1285 #endif
|
|
|
1286
|
|
|
1287 bbox = gtk_hbutton_box_new();
|
|
|
1288 gtk_box_pack_start(GTK_BOX(vbox), bbox, TRUE, TRUE, 0);
|
|
|
1289 gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
|
|
|
1290 gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
|
|
|
1291
|
|
|
1292 cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
|
|
|
1293 GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
|
|
|
1294 gtk_container_add(GTK_CONTAINER(bbox), cancel);
|
|
|
1295 g_signal_connect_swapped(cancel, "clicked",
|
|
|
1296 G_CALLBACK(gtk_widget_destroy), mainwin_jtt);
|
|
|
1297
|
|
|
1298 jump = gtk_button_new_from_stock(GTK_STOCK_JUMP_TO);
|
|
|
1299 GTK_WIDGET_SET_FLAGS(jump, GTK_CAN_DEFAULT);
|
|
|
1300 gtk_container_add(GTK_CONTAINER(bbox), jump);
|
|
|
1301 g_signal_connect(jump, "clicked",
|
|
|
1302 G_CALLBACK(mainwin_jump_to_time_cb), time_entry);
|
|
|
1303
|
|
|
1304 tindex = bmp_playback_get_time() / 1000;
|
|
|
1305 g_snprintf(time_str, sizeof(time_str), "%u:%2.2u", tindex / 60,
|
|
|
1306 tindex % 60);
|
|
|
1307 gtk_entry_set_text(GTK_ENTRY(time_entry), time_str);
|
|
|
1308
|
|
|
1309 gtk_entry_select_region(GTK_ENTRY(time_entry), 0, strlen(time_str));
|
|
|
1310
|
|
|
1311 gtk_widget_show_all(mainwin_jtt);
|
|
|
1312
|
|
|
1313 gtk_widget_grab_focus(time_entry);
|
|
|
1314 gtk_widget_grab_default(jump);
|
|
|
1315 }
|
|
|
1316
|
|
|
1317 static void
|
|
|
1318 change_song(guint pos)
|
|
|
1319 {
|
|
|
1320 if (bmp_playback_get_playing())
|
|
|
1321 bmp_playback_stop();
|
|
|
1322
|
|
|
1323 playlist_set_position(pos);
|
|
|
1324 bmp_playback_initiate();
|
|
|
1325 }
|
|
|
1326
|
|
|
1327 static void
|
|
|
1328 mainwin_jump_to_file_jump(GtkTreeView * treeview)
|
|
|
1329 {
|
|
|
1330 GtkTreeModel *model;
|
|
|
1331 GtkTreeSelection *selection;
|
|
|
1332 GtkTreeIter iter;
|
|
|
1333 gchar *pos_str;
|
|
|
1334 guint pos;
|
|
|
1335
|
|
|
1336 model = gtk_tree_view_get_model(treeview);
|
|
|
1337 selection = gtk_tree_view_get_selection(treeview);
|
|
|
1338
|
|
|
1339 if (!gtk_tree_selection_get_selected(selection, NULL, &iter))
|
|
|
1340 return;
|
|
|
1341
|
|
|
1342 gtk_tree_model_get(model, &iter, 0, &pos_str, -1);
|
|
|
1343 pos = g_ascii_strtoull(pos_str, NULL, 10) - 1;
|
|
|
1344
|
|
|
1345 change_song(pos);
|
|
|
1346
|
|
|
1347 /* FIXME: should only hide window */
|
|
|
1348 gtk_widget_destroy(mainwin_jtf);
|
|
|
1349 mainwin_jtf = NULL;
|
|
|
1350 }
|
|
|
1351
|
|
|
1352 static void
|
|
|
1353 mainwin_jump_to_file_jump_cb(GtkTreeView * treeview,
|
|
|
1354 gpointer data)
|
|
|
1355 {
|
|
|
1356 mainwin_jump_to_file_jump(treeview);
|
|
|
1357 }
|
|
|
1358
|
|
|
1359 static void
|
|
|
1360 mainwin_jump_to_file_set_queue_button_label(GtkButton * button,
|
|
|
1361 guint pos)
|
|
|
1362 {
|
|
|
1363 if (playlist_is_position_queued(pos))
|
|
|
1364 gtk_button_set_label(button, _("Un_queue"));
|
|
|
1365 else
|
|
|
1366 gtk_button_set_label(button, _("_Queue"));
|
|
|
1367 }
|
|
|
1368
|
|
|
1369 static void
|
|
|
1370 mainwin_jump_to_file_queue_cb(GtkButton * button,
|
|
|
1371 gpointer data)
|
|
|
1372 {
|
|
|
1373 GtkTreeView *treeview;
|
|
|
1374 GtkTreeModel *model;
|
|
|
1375 GtkTreeSelection *selection;
|
|
|
1376 GtkTreeIter iter;
|
|
|
1377 gchar *pos_str;
|
|
|
1378 guint pos;
|
|
|
1379
|
|
|
1380 treeview = GTK_TREE_VIEW(data);
|
|
|
1381 model = gtk_tree_view_get_model(treeview);
|
|
|
1382 selection = gtk_tree_view_get_selection(treeview);
|
|
|
1383
|
|
|
1384 if (!gtk_tree_selection_get_selected(selection, NULL, &iter))
|
|
|
1385 return;
|
|
|
1386
|
|
|
1387 gtk_tree_model_get(model, &iter, 0, &pos_str, -1);
|
|
|
1388 pos = g_ascii_strtoull(pos_str, NULL, 10) - 1;
|
|
|
1389
|
|
|
1390 playlist_queue_position(pos);
|
|
|
1391
|
|
|
1392 mainwin_jump_to_file_set_queue_button_label(button, pos);
|
|
|
1393 }
|
|
|
1394
|
|
|
1395 static void
|
|
|
1396 mainwin_jump_to_file_selection_changed_cb(GtkTreeSelection *treesel,
|
|
|
1397 gpointer data)
|
|
|
1398 {
|
|
|
1399 GtkTreeView *treeview;
|
|
|
1400 GtkTreeModel *model;
|
|
|
1401 GtkTreeSelection *selection;
|
|
|
1402 GtkTreeIter iter;
|
|
|
1403 gchar *pos_str;
|
|
|
1404 guint pos;
|
|
|
1405
|
|
|
1406 treeview = gtk_tree_selection_get_tree_view(treesel);
|
|
|
1407 model = gtk_tree_view_get_model(treeview);
|
|
|
1408 selection = gtk_tree_view_get_selection(treeview);
|
|
|
1409
|
|
|
1410 if (!gtk_tree_selection_get_selected(selection, NULL, &iter))
|
|
|
1411 return;
|
|
|
1412
|
|
|
1413 gtk_tree_model_get(model, &iter, 0, &pos_str, -1);
|
|
|
1414 pos = g_ascii_strtoull(pos_str, NULL, 10) - 1;
|
|
|
1415
|
|
|
1416 mainwin_jump_to_file_set_queue_button_label(GTK_BUTTON(data), pos);
|
|
|
1417 }
|
|
|
1418
|
|
|
1419 static gboolean
|
|
|
1420 mainwin_jump_to_file_keypress_cb(GtkWidget * object,
|
|
|
1421 GdkEventKey * event,
|
|
|
1422 gpointer data)
|
|
|
1423 {
|
|
|
1424 switch (event->keyval) {
|
|
|
1425 case GDK_Escape:
|
|
|
1426 /* FIXME: show only hide window */
|
|
|
1427 gtk_widget_destroy(mainwin_jtf);
|
|
|
1428 mainwin_jtf = NULL;
|
|
|
1429 return TRUE;
|
|
|
1430 case GDK_Return:
|
|
|
1431 mainwin_jump_to_file_jump(GTK_TREE_VIEW(data));
|
|
|
1432 return TRUE;
|
|
|
1433 default:
|
|
|
1434 return FALSE;
|
|
|
1435 };
|
|
|
1436 }
|
|
|
1437
|
|
|
1438 static gboolean
|
|
|
1439 mainwin_jump_to_file_match(const gchar * song, gchar ** keys)
|
|
|
1440 {
|
|
|
1441 gint i = 0;
|
|
|
1442 gchar *key;
|
|
|
1443 gchar *song_lc;
|
|
|
1444
|
|
|
1445 song_lc = g_ascii_strdown(song, -1);
|
|
|
1446
|
|
|
1447 while (keys[i]) {
|
|
|
1448 key = g_ascii_strdown(keys[i], -1);
|
|
|
1449 if (!g_strrstr(song_lc, key)) {
|
|
|
1450 g_free(key);
|
|
|
1451 g_free(song_lc);
|
|
|
1452 return FALSE;
|
|
|
1453 }
|
|
|
1454
|
|
|
1455 g_free(key);
|
|
|
1456 i++;
|
|
|
1457 }
|
|
|
1458
|
|
|
1459 g_free(song_lc);
|
|
|
1460
|
|
|
1461 return TRUE;
|
|
|
1462 }
|
|
|
1463
|
|
|
1464 /* FIXME: Clear the entry when the list gets updated */
|
|
|
1465 static void
|
|
|
1466 mainwin_update_jtf(GtkWidget * widget, gpointer user_data)
|
|
|
1467 {
|
|
|
1468 /* FIXME: Is not in sync with playlist due to delayed extinfo
|
|
|
1469 * reading */
|
|
|
1470 gint row;
|
|
|
1471 GList *playlist;
|
|
|
1472 gchar *desc_buf;
|
|
|
1473 gchar *row_str;
|
|
|
1474 GtkTreeIter iter;
|
|
|
1475 GtkTreeSelection *selection;
|
|
|
1476
|
|
|
1477 GtkTreeModel *store;
|
|
|
1478
|
|
|
1479 if (!mainwin_jtf)
|
|
|
1480 return;
|
|
|
1481
|
|
|
1482 store = gtk_tree_view_get_model(GTK_TREE_VIEW(user_data));
|
|
|
1483 gtk_list_store_clear(GTK_LIST_STORE(store));
|
|
|
1484
|
|
|
1485 row = 1;
|
|
|
1486 for (playlist = playlist_get(); playlist;
|
|
|
1487 playlist = g_list_next(playlist)) {
|
|
|
1488 PlaylistEntry *entry = PLAYLIST_ENTRY(playlist->data);
|
|
|
1489
|
|
|
1490 if (entry->title)
|
|
|
1491 desc_buf = entry->title;
|
|
|
1492 else if (strchr(entry->filename, '/'))
|
|
|
1493 desc_buf = strrchr(entry->filename, '/') + 1;
|
|
|
1494 else
|
|
|
1495 desc_buf = entry->filename;
|
|
|
1496
|
|
|
1497 row_str = g_strdup_printf("%d", row++);
|
|
|
1498
|
|
|
1499 gtk_list_store_append(GTK_LIST_STORE(store), &iter);
|
|
|
1500 gtk_list_store_set(GTK_LIST_STORE(store), &iter,
|
|
|
1501 0, row_str, 1, desc_buf, -1);
|
|
|
1502
|
|
|
1503 g_free(row_str);
|
|
|
1504 }
|
|
|
1505
|
|
|
1506 gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter);
|
|
|
1507 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(user_data));
|
|
|
1508 gtk_tree_selection_select_iter(selection, &iter);
|
|
|
1509 }
|
|
|
1510
|
|
|
1511 static void
|
|
|
1512 mainwin_jump_to_file_edit_cb(GtkEntry * entry, gpointer user_data)
|
|
|
1513 {
|
|
|
1514 GtkTreeView *treeview = GTK_TREE_VIEW(user_data);
|
|
|
1515 GtkTreeSelection *selection;
|
|
|
1516 GtkTreeIter iter;
|
|
|
1517
|
|
|
1518 GtkListStore *store;
|
|
|
1519
|
|
|
1520 gint song_index = 0;
|
|
|
1521 gchar **words;
|
|
|
1522 GList *playlist;
|
|
|
1523
|
|
|
1524 gboolean match = FALSE;
|
|
|
1525
|
|
|
1526 /* Chop the key string into ' '-separated key words */
|
|
|
1527 words = g_strsplit(gtk_entry_get_text(entry), " ", 0);
|
|
|
1528
|
|
|
1529 /* FIXME: Remove the connected signals before clearing
|
|
|
1530 * (row-selected will still eventually arrive once) */
|
|
|
1531 store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
|
|
|
1532 gtk_list_store_clear(store);
|
|
|
1533
|
|
|
1534 PLAYLIST_LOCK();
|
|
|
1535
|
|
|
1536 for (playlist = playlist_get(); playlist;
|
|
|
1537 playlist = g_list_next(playlist)) {
|
|
|
1538
|
|
|
1539 PlaylistEntry *entry = PLAYLIST_ENTRY(playlist->data);
|
|
|
1540 const gchar *title, *filename;
|
|
|
1541
|
|
|
1542 title = entry->title;
|
|
|
1543 if (!title) {
|
|
|
1544 filename = entry->filename;
|
|
|
1545
|
|
|
1546 if (strchr(filename, '/'))
|
|
|
1547 title = strrchr(filename, '/') + 1;
|
|
|
1548 else
|
|
|
1549 title = filename;
|
|
|
1550 }
|
|
|
1551
|
|
|
1552 /* Compare the key words to the string - if all the words
|
|
|
1553 match, add to the ListStore */
|
|
|
1554
|
|
|
1555 /*
|
|
|
1556 * FIXME: The search string should be adapted to the
|
|
|
1557 * current display setting, e.g. if the user has set it to
|
|
|
1558 * "%p - %t" then build the match string like that too, or
|
|
|
1559 * even better, search for each of the tags seperatly.
|
|
|
1560 *
|
|
|
1561 * In any case the string to match should _never_ contain
|
|
|
1562 * something the user can't actually see in the playlist.
|
|
|
1563 */
|
|
|
1564 if (words[0])
|
|
|
1565 match = mainwin_jump_to_file_match(title, words);
|
|
|
1566 else
|
|
|
1567 match = TRUE;
|
|
|
1568
|
|
|
1569 if (match) {
|
|
|
1570 gchar *song_index_str = g_strdup_printf("%d", song_index + 1);
|
|
|
1571 gtk_list_store_append(store, &iter);
|
|
|
1572 gtk_list_store_set(store, &iter, 0, song_index_str, 1, title, -1);
|
|
|
1573 g_free(song_index_str);
|
|
|
1574 }
|
|
|
1575
|
|
|
1576 song_index++;
|
|
|
1577 }
|
|
|
1578
|
|
|
1579 PLAYLIST_UNLOCK();
|
|
|
1580
|
|
|
1581 g_strfreev(words);
|
|
|
1582
|
|
|
1583 if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter)) {
|
|
|
1584 selection = gtk_tree_view_get_selection(treeview);
|
|
|
1585 gtk_tree_selection_select_iter(selection, &iter);
|
|
|
1586 }
|
|
|
1587 }
|
|
|
1588
|
|
|
1589 void
|
|
|
1590 mainwin_jump_to_file(void)
|
|
|
1591 {
|
|
|
1592 GtkWidget *scrollwin;
|
|
|
1593 GtkWidget *vbox, *bbox, *sep;
|
|
|
1594 GtkWidget *jump, *queue, *cancel;
|
|
|
1595 GtkWidget *rescan, *edit;
|
|
|
1596 GtkWidget *search_label, *hbox;
|
|
|
1597 GList *playlist;
|
|
|
1598 gchar *desc_buf;
|
|
|
1599 gchar *row_str;
|
|
|
1600 gint row;
|
|
|
1601
|
|
|
1602 GtkWidget *treeview;
|
|
|
1603 GtkListStore *jtf_store;
|
|
|
1604
|
|
|
1605 GtkTreeIter iter;
|
|
|
1606 GtkCellRenderer *renderer;
|
|
|
1607 GtkTreeViewColumn *column;
|
|
|
1608
|
|
|
1609 if (mainwin_jtf) {
|
|
|
1610 gtk_window_present(GTK_WINDOW(mainwin_jtf));
|
|
|
1611 return;
|
|
|
1612 }
|
|
|
1613
|
|
|
1614 mainwin_jtf = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
|
|
1615 gtk_window_set_type_hint(GTK_WINDOW(mainwin_jtf),
|
|
|
1616 GDK_WINDOW_TYPE_HINT_DIALOG);
|
|
|
1617
|
|
|
1618 gtk_window_set_title(GTK_WINDOW(mainwin_jtf), _("Jump to Track"));
|
|
|
1619
|
|
|
1620 gtk_window_set_position(GTK_WINDOW(mainwin_jtf), GTK_WIN_POS_CENTER);
|
|
|
1621 g_signal_connect(mainwin_jtf, "destroy",
|
|
|
1622 G_CALLBACK(gtk_widget_destroyed), &mainwin_jtf);
|
|
|
1623
|
|
|
1624 gtk_container_border_width(GTK_CONTAINER(mainwin_jtf), 10);
|
|
|
1625 gtk_window_set_default_size(GTK_WINDOW(mainwin_jtf), 550, 350);
|
|
|
1626
|
|
|
1627 vbox = gtk_vbox_new(FALSE, 5);
|
|
|
1628 gtk_container_add(GTK_CONTAINER(mainwin_jtf), vbox);
|
|
|
1629
|
|
|
1630 jtf_store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
|
|
|
1631 treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(jtf_store));
|
|
|
1632 g_object_unref(jtf_store);
|
|
|
1633
|
|
|
1634 gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);
|
|
|
1635
|
|
|
1636 column = gtk_tree_view_column_new();
|
|
|
1637 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
|
|
|
1638 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
|
|
|
1639
|
|
|
1640 renderer = gtk_cell_renderer_text_new();
|
|
|
1641 gtk_tree_view_column_pack_start(column, renderer, FALSE);
|
|
|
1642 gtk_tree_view_column_set_attributes(column, renderer, "text", 0, NULL);
|
|
|
1643 gtk_tree_view_column_set_spacing(column, 4);
|
|
|
1644
|
|
|
1645 renderer = gtk_cell_renderer_text_new();
|
|
|
1646 gtk_tree_view_column_pack_start(column, renderer, FALSE);
|
|
|
1647 gtk_tree_view_column_set_attributes(column, renderer, "text", 1, NULL);
|
|
|
1648 gtk_tree_view_column_set_spacing(column, 4);
|
|
|
1649 gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
|
|
|
1650
|
|
|
1651 g_signal_connect(treeview, "row-activated",
|
|
|
1652 G_CALLBACK(mainwin_jump_to_file_jump), NULL);
|
|
|
1653
|
|
|
1654 hbox = gtk_hbox_new(FALSE, 3);
|
|
|
1655 gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);
|
|
|
1656
|
|
|
1657 search_label = gtk_label_new(_("Filter: "));
|
|
|
1658 gtk_label_set_markup_with_mnemonic(GTK_LABEL(search_label), "_Filter:");
|
|
|
1659 gtk_box_pack_start(GTK_BOX(hbox), search_label, FALSE, FALSE, 0);
|
|
|
1660
|
|
|
1661 edit = gtk_entry_new();
|
|
|
1662 gtk_entry_set_editable(GTK_ENTRY(edit), TRUE);
|
|
|
1663 gtk_label_set_mnemonic_widget(GTK_LABEL(search_label), edit);
|
|
|
1664 g_signal_connect(edit, "changed",
|
|
|
1665 G_CALLBACK(mainwin_jump_to_file_edit_cb), treeview);
|
|
|
1666
|
|
|
1667 g_signal_connect(mainwin_jtf, "key_press_event",
|
|
|
1668 G_CALLBACK(mainwin_jump_to_file_keypress_cb), treeview);
|
|
|
1669
|
|
|
1670 gtk_box_pack_start(GTK_BOX(hbox), edit, TRUE, TRUE, 3);
|
|
|
1671
|
|
|
1672 scrollwin = gtk_scrolled_window_new(NULL, NULL);
|
|
|
1673 gtk_container_add(GTK_CONTAINER(scrollwin), treeview);
|
|
|
1674 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
|
|
|
1675 GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
|
|
|
1676 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrollwin),
|
|
|
1677 GTK_SHADOW_IN);
|
|
|
1678 gtk_box_pack_start(GTK_BOX(vbox), scrollwin, TRUE, TRUE, 0);
|
|
|
1679
|
|
|
1680 sep = gtk_hseparator_new();
|
|
|
1681 gtk_box_pack_start(GTK_BOX(vbox), sep, FALSE, FALSE, 0);
|
|
|
1682
|
|
|
1683 bbox = gtk_hbutton_box_new();
|
|
|
1684 gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
|
|
|
1685 gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
|
|
|
1686 gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
|
|
|
1687
|
|
|
1688 queue = gtk_button_new_with_mnemonic(_("_Queue"));
|
|
|
1689 gtk_box_pack_start(GTK_BOX(bbox), queue, FALSE, FALSE, 0);
|
|
|
1690 GTK_WIDGET_SET_FLAGS(queue, GTK_CAN_DEFAULT);
|
|
|
1691 g_signal_connect(queue, "clicked",
|
|
|
1692 G_CALLBACK(mainwin_jump_to_file_queue_cb),
|
|
|
1693 treeview);
|
|
|
1694 g_signal_connect(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)), "changed",
|
|
|
1695 G_CALLBACK(mainwin_jump_to_file_selection_changed_cb),
|
|
|
1696 queue);
|
|
|
1697
|
|
|
1698 rescan = gtk_button_new_from_stock(GTK_STOCK_REFRESH);
|
|
|
1699 gtk_box_pack_start(GTK_BOX(bbox), rescan, FALSE, FALSE, 0);
|
|
|
1700 g_signal_connect(rescan, "clicked",
|
|
|
1701 G_CALLBACK(mainwin_update_jtf), treeview);
|
|
|
1702 GTK_WIDGET_SET_FLAGS(rescan, GTK_CAN_DEFAULT);
|
|
|
1703 gtk_widget_grab_default(rescan);
|
|
|
1704
|
|
|
1705 jump = gtk_button_new_from_stock(GTK_STOCK_JUMP_TO);
|
|
|
1706 gtk_box_pack_start(GTK_BOX(bbox), jump, FALSE, FALSE, 0);
|
|
|
1707
|
|
|
1708 g_signal_connect_swapped(jump, "clicked",
|
|
|
1709 G_CALLBACK(mainwin_jump_to_file_jump_cb),
|
|
|
1710 treeview);
|
|
|
1711
|
|
|
1712 GTK_WIDGET_SET_FLAGS(jump, GTK_CAN_DEFAULT);
|
|
|
1713 gtk_widget_grab_default(jump);
|
|
|
1714
|
|
|
1715 cancel = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
|
|
|
1716 gtk_box_pack_start(GTK_BOX(bbox), cancel, FALSE, FALSE, 0);
|
|
|
1717 g_signal_connect_swapped(cancel, "clicked",
|
|
|
1718 G_CALLBACK(gtk_widget_destroy),
|
|
|
1719 mainwin_jtf);
|
|
|
1720 GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
|
|
|
1721
|
|
|
1722 gtk_list_store_clear(jtf_store);
|
|
|
1723
|
|
|
1724 row = 1;
|
|
|
1725
|
|
|
1726 PLAYLIST_LOCK();
|
|
|
1727
|
|
|
1728 for (playlist = playlist_get(); playlist;
|
|
|
1729 playlist = g_list_next(playlist)) {
|
|
|
1730
|
|
|
1731 PlaylistEntry *entry = PLAYLIST_ENTRY(playlist->data);
|
|
|
1732
|
|
|
1733 if (entry->title)
|
|
|
1734 desc_buf = entry->title;
|
|
|
1735 else if (strchr(entry->filename, '/'))
|
|
|
1736 desc_buf = strrchr(entry->filename, '/') + 1;
|
|
|
1737 else
|
|
|
1738 desc_buf = entry->filename;
|
|
|
1739
|
|
|
1740 row_str = g_strdup_printf("%d", row++);
|
|
|
1741
|
|
|
1742 gtk_list_store_append(GTK_LIST_STORE(jtf_store), &iter);
|
|
|
1743 gtk_list_store_set(GTK_LIST_STORE(jtf_store), &iter,
|
|
|
1744 0, row_str, 1, desc_buf, -1);
|
|
|
1745
|
|
|
1746 g_free(row_str);
|
|
|
1747 }
|
|
|
1748
|
|
|
1749 PLAYLIST_UNLOCK();
|
|
|
1750
|
|
|
1751 gtk_widget_show_all(mainwin_jtf);
|
|
|
1752 }
|
|
|
1753
|
|
|
1754 static gboolean
|
|
|
1755 mainwin_configure(GtkWidget * window,
|
|
|
1756 GdkEventConfigure * event,
|
|
|
1757 gpointer data)
|
|
|
1758 {
|
|
|
1759 if (!GTK_WIDGET_VISIBLE(window))
|
|
|
1760 return FALSE;
|
|
|
1761
|
|
|
1762 if (cfg.show_wm_decorations)
|
|
|
1763 gdk_window_get_root_origin(window->window,
|
|
|
1764 &cfg.player_x, &cfg.player_y);
|
|
|
1765 else
|
|
|
1766 gdk_window_get_deskrelative_origin(window->window,
|
|
|
1767 &cfg.player_x, &cfg.player_y);
|
|
|
1768 return FALSE;
|
|
|
1769 }
|
|
|
1770
|
|
|
1771 void
|
|
|
1772 mainwin_set_back_pixmap(void)
|
|
|
1773 {
|
|
|
1774 gdk_window_set_back_pixmap(mainwin->window, mainwin_bg, 0);
|
|
|
1775 gdk_window_clear(mainwin->window);
|
|
|
1776 }
|
|
|
1777
|
|
|
1778 void
|
|
|
1779 mainwin_drag_data_received(GtkWidget * widget,
|
|
|
1780 GdkDragContext * context,
|
|
|
1781 gint x,
|
|
|
1782 gint y,
|
|
|
1783 GtkSelectionData * selection_data,
|
|
|
1784 guint info,
|
|
|
1785 guint time,
|
|
|
1786 gpointer user_data)
|
|
|
1787 {
|
|
|
1788 ConfigDb *db;
|
|
|
1789 gchar *path, *decoded;
|
|
|
1790
|
|
|
1791 if (!selection_data->data) {
|
|
|
1792 g_warning("DND data string is NULL");
|
|
|
1793 return;
|
|
|
1794 }
|
|
|
1795
|
|
|
1796 path = (gchar *) selection_data->data;
|
|
|
1797
|
|
|
1798 g_message(path);
|
|
|
1799
|
|
|
1800 /* FIXME: use a real URL validator/parser */
|
|
|
1801
|
|
|
1802 if (str_has_prefix_nocase(path, "fonts:///")) {
|
|
|
1803 path[strlen(path) - 2] = 0; /* Why the hell a CR&LF? */
|
|
|
1804 path += 8;
|
|
|
1805
|
|
|
1806 /* plain, since we already stripped the first URI part */
|
|
|
1807 decoded = xmms_urldecode_plain(path);
|
|
|
1808
|
|
|
1809 /* Get the old font's size, and add it to the dropped
|
|
|
1810 * font's name */
|
|
|
1811 cfg.playlist_font = g_strconcat(decoded + 1,
|
|
|
1812 strrchr(cfg.playlist_font, ' '),
|
|
|
1813 NULL);
|
|
|
1814 playlist_list_set_font(cfg.playlist_font);
|
|
|
1815 playlistwin_update_list();
|
|
|
1816
|
|
|
1817 g_free(decoded);
|
|
|
1818 return;
|
|
|
1819 }
|
|
|
1820
|
|
|
1821 if (str_has_prefix_nocase(path, "file:///")) {
|
|
|
1822 path[strlen(path) - 2] = 0; /* Why the hell a CR&LF? */
|
|
|
1823 path += 7;
|
|
|
1824 }
|
|
|
1825 else if (str_has_prefix_nocase(path, "file:")) {
|
|
|
1826 path += 5;
|
|
|
1827 }
|
|
|
1828
|
|
|
1829 if (file_is_archive(path)) {
|
|
|
1830 bmp_active_skin_load(path);
|
|
|
1831 skin_install_skin(path); /* ...and install the skin */
|
|
|
1832 skin_view_update(user_data);
|
|
|
1833 /* Change skin name in the config file */
|
|
|
1834 db = bmp_cfg_db_open();
|
|
|
1835 bmp_cfg_db_set_string(db, NULL, "skin", path);
|
|
|
1836 bmp_cfg_db_close(db);
|
|
|
1837 }
|
|
|
1838 else {
|
|
|
1839 if (input_check_file((gchar *) selection_data->data, FALSE)) {
|
|
|
1840 playlist_clear();
|
|
|
1841 playlist_add_url((gchar *) selection_data->data);
|
|
|
1842 bmp_playback_initiate();
|
|
|
1843 }
|
|
|
1844 }
|
|
|
1845 }
|
|
|
1846
|
|
|
1847 static void
|
|
|
1848 dirbrowser_add_dir(const gchar * dir)
|
|
|
1849 {
|
|
|
1850 g_free(cfg.filesel_path);
|
|
|
1851 cfg.filesel_path = g_strdup(dir);
|
|
|
1852 playlist_add_dir(dir);
|
|
|
1853 }
|
|
|
1854
|
|
|
1855 static void
|
|
|
1856 dirbrowser_on_response(GtkFileChooserDialog * dialog,
|
|
|
1857 gint result,
|
|
|
1858 gpointer data)
|
|
|
1859 {
|
|
|
1860
|
|
|
1861 gchar *pathname;
|
|
|
1862
|
|
|
1863 // gtk_widget_hide(GTK_WIDGET(dialog));
|
|
|
1864
|
|
|
1865 switch (result) {
|
|
|
1866 case GTK_RESPONSE_ACCEPT:
|
|
|
1867 pathname = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
|
|
|
1868 dirbrowser_add_dir(pathname);
|
|
|
1869 g_free(pathname);
|
|
|
1870 break;
|
|
|
1871
|
|
|
1872 case GTK_RESPONSE_CLOSE:
|
|
|
1873 break;
|
|
|
1874 }
|
|
|
1875
|
|
|
1876 }
|
|
|
1877
|
|
|
1878
|
|
|
1879 static GtkWidget *
|
|
|
1880 dirbrowser_new(const gchar * path)
|
|
|
1881 {
|
|
|
1882 GtkWidget *dialog;
|
|
|
1883
|
|
|
1884 dialog = gtk_file_chooser_dialog_new(_("Add Folders"),
|
|
|
1885 GTK_WINDOW(mainwin),
|
|
|
1886 GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
|
|
|
1887 GTK_STOCK_ADD, GTK_RESPONSE_OK,
|
|
|
1888 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
|
|
|
1889 NULL);
|
|
|
1890 gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
|
|
|
1891
|
|
|
1892 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
|
|
|
1893 path);
|
|
|
1894 g_signal_connect(dialog, "response",
|
|
|
1895 G_CALLBACK(dirbrowser_on_response),
|
|
|
1896 NULL);
|
|
|
1897
|
|
|
1898 return dialog;
|
|
|
1899 }
|
|
|
1900
|
|
|
1901 void
|
|
|
1902 mainwin_run_dirbrowser(void)
|
|
|
1903 {
|
|
|
1904 static GtkWidget *browser = NULL;
|
|
|
1905
|
|
|
1906 if (!browser) {
|
|
|
1907 browser = dirbrowser_new(cfg.filesel_path);
|
|
|
1908
|
|
|
1909 g_signal_connect(browser, "destroy",
|
|
|
1910 G_CALLBACK(gtk_widget_destroyed),
|
|
|
1911 &browser);
|
|
|
1912
|
|
|
1913 gtk_widget_show(GTK_WIDGET(browser));
|
|
|
1914 }
|
|
|
1915
|
|
|
1916 gtk_window_present(GTK_WINDOW(browser));
|
|
|
1917 }
|
|
|
1918
|
|
|
1919 static void
|
|
|
1920 on_add_url_add_clicked(GtkWidget * widget,
|
|
|
1921 GtkWidget * entry)
|
|
|
1922 {
|
|
|
1923 const gchar *text = gtk_entry_get_text(GTK_ENTRY(entry));
|
|
|
1924 if (text && *text)
|
|
|
1925 playlist_add_url(text);
|
|
|
1926 }
|
|
|
1927
|
|
|
1928 void
|
|
|
1929 mainwin_show_add_url_window(void)
|
|
|
1930 {
|
|
|
1931 static GtkWidget *url_window = NULL;
|
|
|
1932
|
|
|
1933 if (!url_window) {
|
|
|
1934 url_window =
|
|
|
1935 util_add_url_dialog_new(_("Add Internet Address"),
|
|
|
1936 G_CALLBACK(on_add_url_add_clicked));
|
|
|
1937 gtk_window_set_transient_for(GTK_WINDOW(url_window),
|
|
|
1938 GTK_WINDOW(mainwin));
|
|
|
1939 g_signal_connect(url_window, "destroy",
|
|
|
1940 G_CALLBACK(gtk_widget_destroyed),
|
|
|
1941 &url_window);
|
|
|
1942 }
|
|
|
1943
|
|
|
1944 gtk_window_present(GTK_WINDOW(url_window));
|
|
|
1945 }
|
|
|
1946
|
|
|
1947 static void
|
|
|
1948 check_set(GtkItemFactory * factory,
|
|
|
1949 const gchar * path,
|
|
|
1950 gboolean active)
|
|
|
1951 {
|
|
|
1952 GtkWidget *item = gtk_item_factory_get_widget(factory, path);
|
|
|
1953 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), active);
|
|
|
1954 }
|
|
|
1955
|
|
|
1956 void
|
|
|
1957 mainwin_eject_pushed(void)
|
|
|
1958 {
|
|
|
1959 util_run_filebrowser(PLAY_BUTTON);
|
|
|
1960 }
|
|
|
1961
|
|
|
1962 void
|
|
|
1963 mainwin_play_pushed(void)
|
|
|
1964 {
|
|
|
1965 if (bmp_playback_get_paused()) {
|
|
|
1966 bmp_playback_pause();
|
|
|
1967 return;
|
|
|
1968 }
|
|
|
1969
|
|
|
1970 if (playlist_get_length())
|
|
|
1971 bmp_playback_initiate();
|
|
|
1972 else
|
|
|
1973 mainwin_eject_pushed();
|
|
|
1974 }
|
|
|
1975
|
|
|
1976 void
|
|
|
1977 mainwin_stop_pushed(void)
|
|
|
1978 {
|
|
|
1979 mainwin_clear_song_info();
|
|
|
1980 bmp_playback_stop();
|
|
|
1981 }
|
|
|
1982
|
|
|
1983 void
|
|
|
1984 mainwin_shuffle_pushed(gboolean toggled)
|
|
|
1985 {
|
|
|
1986 check_set(mainwin_play_menu, "/Shuffle", toggled);
|
|
|
1987 }
|
|
|
1988
|
|
|
1989 void
|
|
|
1990 mainwin_repeat_pushed(gboolean toggled)
|
|
|
1991 {
|
|
|
1992 check_set(mainwin_play_menu, "/Repeat", toggled);
|
|
|
1993 }
|
|
|
1994
|
|
|
1995 void
|
|
|
1996 mainwin_pl_pushed(gboolean toggled)
|
|
|
1997 {
|
|
|
1998 if (toggled)
|
|
|
1999 playlistwin_show();
|
|
|
2000 else
|
|
|
2001 playlistwin_hide();
|
|
|
2002 }
|
|
|
2003
|
|
|
2004 gint
|
|
|
2005 mainwin_spos_frame_cb(gint pos)
|
|
|
2006 {
|
|
|
2007 if (mainwin_sposition) {
|
|
|
2008 if (pos < 6)
|
|
|
2009 mainwin_sposition->hs_knob_nx = mainwin_sposition->hs_knob_px =
|
|
|
2010 17;
|
|
|
2011 else if (pos < 9)
|
|
|
2012 mainwin_sposition->hs_knob_nx = mainwin_sposition->hs_knob_px =
|
|
|
2013 20;
|
|
|
2014 else
|
|
|
2015 mainwin_sposition->hs_knob_nx = mainwin_sposition->hs_knob_px =
|
|
|
2016 23;
|
|
|
2017 }
|
|
|
2018 return 1;
|
|
|
2019 }
|
|
|
2020
|
|
|
2021 void
|
|
|
2022 mainwin_spos_motion_cb(gint pos)
|
|
|
2023 {
|
|
|
2024 gint time;
|
|
|
2025 gchar *time_msg;
|
|
|
2026
|
|
|
2027 pos--;
|
|
|
2028
|
|
|
2029 time = ((playlist_get_current_length() / 1000) * pos) / 12;
|
|
|
2030
|
|
|
2031 if (cfg.timer_mode == TIMER_REMAINING) {
|
|
|
2032 time = (playlist_get_current_length() / 1000) - time;
|
|
|
2033 time_msg = g_strdup_printf("-%2.2d", time / 60);
|
|
|
2034 textbox_set_text(mainwin_stime_min, time_msg);
|
|
|
2035 g_free(time_msg);
|
|
|
2036 }
|
|
|
2037 else {
|
|
|
2038 time_msg = g_strdup_printf(" %2.2d", time / 60);
|
|
|
2039 textbox_set_text(mainwin_stime_min, time_msg);
|
|
|
2040 g_free(time_msg);
|
|
|
2041 }
|
|
|
2042
|
|
|
2043 time_msg = g_strdup_printf("%2.2d", time % 60);
|
|
|
2044 textbox_set_text(mainwin_stime_sec, time_msg);
|
|
|
2045 g_free(time_msg);
|
|
|
2046 }
|
|
|
2047
|
|
|
2048 void
|
|
|
2049 mainwin_spos_release_cb(gint pos)
|
|
|
2050 {
|
|
|
2051 bmp_playback_seek(((playlist_get_current_length() / 1000) *
|
|
|
2052 (pos - 1)) / 12);
|
|
|
2053 }
|
|
|
2054
|
|
|
2055 void
|
|
|
2056 mainwin_position_motion_cb(gint pos)
|
|
|
2057 {
|
|
|
2058 gint length, time;
|
|
|
2059 gchar *seek_msg;
|
|
|
2060
|
|
|
2061 length = playlist_get_current_length() / 1000;
|
|
|
2062 time = (length * pos) / 219;
|
|
|
2063 seek_msg = g_strdup_printf(_("SEEK TO: %d:%-2.2d/%d:%-2.2d (%d%%)"),
|
|
|
2064 time / 60, time % 60,
|
|
|
2065 length / 60, length % 60,
|
|
|
2066 (length != 0) ? (time * 100) / length : 0);
|
|
|
2067 mainwin_lock_info_text(seek_msg);
|
|
|
2068 g_free(seek_msg);
|
|
|
2069 }
|
|
|
2070
|
|
|
2071 void
|
|
|
2072 mainwin_position_release_cb(gint pos)
|
|
|
2073 {
|
|
|
2074 gint length, time;
|
|
|
2075
|
|
|
2076 length = playlist_get_current_length() / 1000;
|
|
|
2077 time = (length * pos) / 219;
|
|
|
2078 bmp_playback_seek(time);
|
|
|
2079 mainwin_release_info_text();
|
|
|
2080 }
|
|
|
2081
|
|
|
2082 gint
|
|
|
2083 mainwin_volume_frame_cb(gint pos)
|
|
|
2084 {
|
|
|
2085 return (gint) rint((pos / 52.0) * 28);
|
|
|
2086 }
|
|
|
2087
|
|
|
2088 void
|
|
|
2089 mainwin_adjust_volume_motion(gint v)
|
|
|
2090 {
|
|
|
2091 gchar *volume_msg;
|
|
|
2092
|
|
|
2093 setting_volume = TRUE;
|
|
|
2094
|
|
|
2095 volume_msg = g_strdup_printf(_("VOLUME: %d%%"), v);
|
|
|
2096 mainwin_lock_info_text(volume_msg);
|
|
|
2097 g_free(volume_msg);
|
|
|
2098
|
|
|
2099 if (balance < 0)
|
|
|
2100 input_set_volume(v, (v * (100 - abs(balance))) / 100);
|
|
|
2101 else if (balance > 0)
|
|
|
2102 input_set_volume((v * (100 - abs(balance))) / 100, v);
|
|
|
2103 else
|
|
|
2104 input_set_volume(v, v);
|
|
|
2105 }
|
|
|
2106
|
|
|
2107 void
|
|
|
2108 mainwin_adjust_volume_release(void)
|
|
|
2109 {
|
|
|
2110 mainwin_release_info_text();
|
|
|
2111 setting_volume = FALSE;
|
|
|
2112 read_volume(VOLUME_ADJUSTED);
|
|
|
2113 }
|
|
|
2114
|
|
|
2115 void
|
|
|
2116 mainwin_adjust_balance_motion(gint b)
|
|
|
2117 {
|
|
|
2118 gchar *balance_msg;
|
|
|
2119 gint v, pvl, pvr;
|
|
|
2120
|
|
|
2121 setting_volume = TRUE;
|
|
|
2122 balance = b;
|
|
|
2123 input_get_volume(&pvl, &pvr);
|
|
|
2124 v = MAX(pvl, pvr);
|
|
|
2125 if (b < 0) {
|
|
|
2126 balance_msg = g_strdup_printf(_("BALANCE: %d%% LEFT"), -b);
|
|
|
2127 input_set_volume(v, (gint) rint(((100 + b) / 100.0) * v));
|
|
|
2128 }
|
|
|
2129 else if (b == 0) {
|
|
|
2130 balance_msg = g_strdup_printf(_("BALANCE: CENTER"));
|
|
|
2131 input_set_volume(v, v);
|
|
|
2132 }
|
|
|
2133 else { /* b > 0 */
|
|
|
2134 balance_msg = g_strdup_printf(_("BALANCE: %d%% RIGHT"), b);
|
|
|
2135 input_set_volume((gint) rint(((100 - b) / 100.0) * v), v);
|
|
|
2136 }
|
|
|
2137 mainwin_lock_info_text(balance_msg);
|
|
|
2138 g_free(balance_msg);
|
|
|
2139 }
|
|
|
2140
|
|
|
2141 void
|
|
|
2142 mainwin_adjust_balance_release(void)
|
|
|
2143 {
|
|
|
2144 mainwin_release_info_text();
|
|
|
2145 setting_volume = FALSE;
|
|
|
2146 read_volume(VOLUME_ADJUSTED);
|
|
|
2147 }
|
|
|
2148
|
|
|
2149 void
|
|
|
2150 mainwin_set_volume_slider(gint percent)
|
|
|
2151 {
|
|
|
2152 hslider_set_position(mainwin_volume, (gint) rint((percent * 51) / 100.0));
|
|
|
2153 }
|
|
|
2154
|
|
|
2155 void
|
|
|
2156 mainwin_set_balance_slider(gint percent)
|
|
|
2157 {
|
|
|
2158 hslider_set_position(mainwin_balance,
|
|
|
2159 (gint) rint(((percent * 12) / 100.0) + 12));
|
|
|
2160 }
|
|
|
2161
|
|
|
2162 void
|
|
|
2163 mainwin_volume_motion_cb(gint pos)
|
|
|
2164 {
|
|
|
2165 gint vol = (pos * 100) / 51;
|
|
|
2166 mainwin_adjust_volume_motion(vol);
|
|
|
2167 equalizerwin_set_volume_slider(vol);
|
|
|
2168 }
|
|
|
2169
|
|
|
2170 void
|
|
|
2171 mainwin_volume_release_cb(gint pos)
|
|
|
2172 {
|
|
|
2173 mainwin_adjust_volume_release();
|
|
|
2174 }
|
|
|
2175
|
|
|
2176 gint
|
|
|
2177 mainwin_balance_frame_cb(gint pos)
|
|
|
2178 {
|
|
|
2179 return ((abs(pos - 12) * 28) / 13);
|
|
|
2180 }
|
|
|
2181
|
|
|
2182 void
|
|
|
2183 mainwin_balance_motion_cb(gint pos)
|
|
|
2184 {
|
|
|
2185 gint bal = ((pos - 12) * 100) / 12;
|
|
|
2186 mainwin_adjust_balance_motion(bal);
|
|
|
2187 equalizerwin_set_balance_slider(bal);
|
|
|
2188 }
|
|
|
2189
|
|
|
2190 void
|
|
|
2191 mainwin_balance_release_cb(gint pos)
|
|
|
2192 {
|
|
|
2193 mainwin_adjust_volume_release();
|
|
|
2194 }
|
|
|
2195
|
|
|
2196 void
|
|
|
2197 mainwin_set_volume_diff(gint diff)
|
|
|
2198 {
|
|
|
2199 gint vl, vr, vol;
|
|
|
2200
|
|
|
2201 input_get_volume(&vl, &vr);
|
|
|
2202 vol = MAX(vl, vr);
|
|
|
2203 vol = CLAMP(vol + diff, 0, 100);
|
|
|
2204
|
|
|
2205 mainwin_adjust_volume_motion(vol);
|
|
|
2206 setting_volume = FALSE;
|
|
|
2207 mainwin_set_volume_slider(vol);
|
|
|
2208 equalizerwin_set_volume_slider(vol);
|
|
|
2209 read_volume(VOLUME_SET);
|
|
|
2210 }
|
|
|
2211
|
|
|
2212 void
|
|
|
2213 mainwin_set_balance_diff(gint diff)
|
|
|
2214 {
|
|
|
2215 gint b;
|
|
|
2216 b = CLAMP(balance + diff, -100, 100);
|
|
|
2217 mainwin_adjust_balance_motion(b);
|
|
|
2218 setting_volume = FALSE;
|
|
|
2219 mainwin_set_balance_slider(b);
|
|
|
2220 equalizerwin_set_balance_slider(b);
|
|
|
2221 read_volume(VOLUME_SET);
|
|
|
2222 }
|
|
|
2223
|
|
|
2224 void
|
|
|
2225 mainwin_show(gboolean show)
|
|
|
2226 {
|
|
|
2227 if (show)
|
|
|
2228 mainwin_real_show();
|
|
|
2229 else
|
|
|
2230 mainwin_real_hide();
|
|
|
2231 }
|
|
|
2232
|
|
|
2233 void
|
|
|
2234 mainwin_real_show(void)
|
|
|
2235 {
|
|
|
2236 cfg.player_visible = TRUE;
|
|
|
2237
|
|
|
2238 if (cfg.player_shaded)
|
|
|
2239 vis_clear_data(active_vis);
|
|
|
2240
|
|
|
2241 mainwin_vis_set_active_vis(MAINWIN_VIS_ACTIVE_MAINWIN);
|
|
|
2242 mainwin_set_shape_mask();
|
|
|
2243
|
|
|
2244 if (cfg.show_wm_decorations) {
|
|
|
2245 if (!pposition_broken && cfg.player_x != -1
|
|
|
2246 && cfg.save_window_position)
|
|
|
2247 gtk_window_move(GTK_WINDOW(mainwin), cfg.player_x, cfg.player_y);
|
|
|
2248
|
|
|
2249 gtk_widget_show(mainwin);
|
|
|
2250
|
|
|
2251 if (pposition_broken && cfg.player_x != -1
|
|
|
2252 && cfg.save_window_position)
|
|
|
2253 gtk_window_move(GTK_WINDOW(mainwin), cfg.player_x, cfg.player_y);
|
|
|
2254
|
|
|
2255 return;
|
|
|
2256 }
|
|
|
2257
|
|
|
2258 gtk_widget_show_all(mainwin);
|
|
|
2259
|
|
|
2260 if (!nullmask)
|
|
|
2261 return;
|
|
|
2262
|
|
|
2263 g_object_unref(nullmask);
|
|
|
2264 nullmask = NULL;
|
|
|
2265
|
|
|
2266 gdk_window_set_hints(mainwin->window, 0, 0,
|
|
|
2267 PLAYER_WIDTH, PLAYER_HEIGHT,
|
|
|
2268 PLAYER_WIDTH, PLAYER_HEIGHT,
|
|
|
2269 GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
|
|
|
2270 gtk_window_resize(GTK_WINDOW(mainwin), PLAYER_WIDTH, PLAYER_HEIGHT);
|
|
|
2271
|
|
|
2272 if (cfg.player_x != -1 && cfg.player_y != -1)
|
|
|
2273 gtk_window_move(GTK_WINDOW(mainwin), cfg.player_x, cfg.player_y);
|
|
|
2274
|
|
|
2275 draw_main_window(TRUE);
|
|
|
2276
|
|
|
2277 gtk_window_present(GTK_WINDOW(mainwin));
|
|
|
2278 }
|
|
|
2279
|
|
|
2280 void
|
|
|
2281 mainwin_real_hide(void)
|
|
|
2282 {
|
|
|
2283 GdkGC *gc;
|
|
|
2284 GdkColor pattern;
|
|
|
2285
|
|
|
2286 if (cfg.player_shaded) {
|
|
|
2287 svis_clear_data(mainwin_svis);
|
|
|
2288 vis_clear_data(playlistwin_vis);
|
|
|
2289 }
|
|
|
2290
|
|
|
2291 if (!cfg.show_wm_decorations) {
|
|
|
2292 nullmask = gdk_pixmap_new(mainwin->window, 20, 20, 1);
|
|
|
2293 gc = gdk_gc_new(nullmask);
|
|
|
2294 pattern.pixel = 0;
|
|
|
2295 gdk_gc_set_foreground(gc, &pattern);
|
|
|
2296 gdk_draw_rectangle(nullmask, gc, TRUE, 0, 0, 20, 20);
|
|
|
2297 gdk_gc_destroy(gc);
|
|
|
2298 gtk_widget_shape_combine_mask(mainwin, nullmask, 0, 0);
|
|
|
2299
|
|
|
2300 gdk_window_set_hints(mainwin->window, 0, 0, 0, 0, 0, 0,
|
|
|
2301 GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
|
|
|
2302 gdk_window_resize(mainwin->window, 0, 0);
|
|
|
2303 }
|
|
|
2304
|
|
|
2305 gtk_widget_hide(mainwin);
|
|
|
2306
|
|
|
2307 mainwin_vis_set_active_vis(MAINWIN_VIS_ACTIVE_PLAYLISTWIN);
|
|
|
2308 cfg.player_visible = FALSE;
|
|
|
2309 }
|
|
|
2310
|
|
|
2311 static void
|
|
|
2312 mainwin_songname_menu_callback(gpointer data,
|
|
|
2313 guint action,
|
|
|
2314 GtkWidget * item)
|
|
|
2315 {
|
|
|
2316 GtkCheckMenuItem *check;
|
|
|
2317
|
|
|
2318 switch (action) {
|
|
|
2319 case MAINWIN_SONGNAME_FILEINFO:
|
|
|
2320 playlist_fileinfo_current();
|
|
|
2321 break;
|
|
|
2322 case MAINWIN_SONGNAME_JTF:
|
|
|
2323 mainwin_jump_to_file();
|
|
|
2324 break;
|
|
|
2325 case MAINWIN_SONGNAME_JTT:
|
|
|
2326 mainwin_jump_to_time();
|
|
|
2327 break;
|
|
|
2328 case MAINWIN_SONGNAME_SCROLL:
|
|
|
2329 check = GTK_CHECK_MENU_ITEM(item);
|
|
|
2330 mainwin_set_title_scroll(gtk_check_menu_item_get_active(check));
|
|
|
2331 break;
|
|
|
2332 }
|
|
|
2333 }
|
|
|
2334
|
|
|
2335 static void
|
|
|
2336 mainwin_play_menu_callback(gpointer data,
|
|
|
2337 guint action,
|
|
|
2338 GtkWidget * item)
|
|
|
2339 {
|
|
|
2340 GtkCheckMenuItem *check;
|
|
|
2341
|
|
|
2342 switch (action) {
|
|
|
2343 case MAINWIN_OPT_SHUFFLE:
|
|
|
2344 check = GTK_CHECK_MENU_ITEM(item);
|
|
|
2345 cfg.shuffle = gtk_check_menu_item_get_active(check);
|
|
|
2346 playlist_set_shuffle(cfg.shuffle);
|
|
|
2347 tbutton_set_toggled(mainwin_shuffle, cfg.shuffle);
|
|
|
2348 break;
|
|
|
2349 case MAINWIN_OPT_REPEAT:
|
|
|
2350 check = GTK_CHECK_MENU_ITEM(item);
|
|
|
2351 cfg.repeat = gtk_check_menu_item_get_active(check);
|
|
|
2352 tbutton_set_toggled(mainwin_repeat, cfg.repeat);
|
|
|
2353 break;
|
|
|
2354 case MAINWIN_OPT_NPA:
|
|
|
2355 check = GTK_CHECK_MENU_ITEM(item);
|
|
|
2356 cfg.no_playlist_advance = gtk_check_menu_item_get_active(check);
|
|
|
2357 break;
|
|
|
2358 }
|
|
|
2359 }
|
|
|
2360
|
|
|
2361
|
|
|
2362 static void
|
|
|
2363 mainwin_view_menu_callback(gpointer data,
|
|
|
2364 guint action,
|
|
|
2365 GtkWidget * item)
|
|
|
2366 {
|
|
|
2367 switch (action) {
|
|
|
2368 case MAINWIN_OPT_TELAPSED:
|
|
|
2369 set_timer_mode_menu_cb(TIMER_ELAPSED);
|
|
|
2370 break;
|
|
|
2371 case MAINWIN_OPT_TREMAINING:
|
|
|
2372 set_timer_mode_menu_cb(TIMER_REMAINING);
|
|
|
2373 break;
|
|
|
2374 case MAINWIN_OPT_ALWAYS:
|
|
|
2375 mainwin_menurow->mr_always_selected = GTK_CHECK_MENU_ITEM(item)->active;
|
|
|
2376 cfg.always_on_top = mainwin_menurow->mr_always_selected;
|
|
|
2377 widget_draw(WIDGET(mainwin_menurow));
|
|
|
2378 hint_set_always(cfg.always_on_top);
|
|
|
2379 break;
|
|
|
2380 case MAINWIN_OPT_STICKY:
|
|
|
2381 cfg.sticky = GTK_CHECK_MENU_ITEM(item)->active;
|
|
|
2382 hint_set_sticky(cfg.sticky);
|
|
|
2383 break;
|
|
|
2384 case MAINWIN_OPT_WS:
|
|
|
2385 mainwin_set_shade_menu_cb(GTK_CHECK_MENU_ITEM(item)->active);
|
|
|
2386 break;
|
|
|
2387 case MAINWIN_OPT_PWS:
|
|
|
2388 playlistwin_set_shade(GTK_CHECK_MENU_ITEM(item)->active);
|
|
|
2389 break;
|
|
|
2390 case MAINWIN_OPT_EQWS:
|
|
|
2391 equalizerwin_set_shade_menu_cb(GTK_CHECK_MENU_ITEM(item)->active);
|
|
|
2392 break;
|
|
|
2393 }
|
|
|
2394 }
|
|
|
2395
|
|
|
2396 void
|
|
|
2397 mainwin_vis_menu_callback(gpointer data,
|
|
|
2398 guint action,
|
|
|
2399 GtkWidget * item)
|
|
|
2400 {
|
|
|
2401 switch (action) {
|
|
|
2402 case MAINWIN_VIS_ANALYZER:
|
|
|
2403 case MAINWIN_VIS_SCOPE:
|
|
|
2404 case MAINWIN_VIS_OFF:
|
|
|
2405 mainwin_vis_set_type_menu_cb(action - MAINWIN_VIS_ANALYZER);
|
|
|
2406 break;
|
|
|
2407 case MAINWIN_VIS_ANALYZER_NORMAL:
|
|
|
2408 case MAINWIN_VIS_ANALYZER_FIRE:
|
|
|
2409 case MAINWIN_VIS_ANALYZER_VLINES:
|
|
|
2410 mainwin_vis_set_analyzer_mode(action - MAINWIN_VIS_ANALYZER_NORMAL);
|
|
|
2411 break;
|
|
|
2412 case MAINWIN_VIS_ANALYZER_LINES:
|
|
|
2413 case MAINWIN_VIS_ANALYZER_BARS:
|
|
|
2414 mainwin_vis_set_analyzer_type(action - MAINWIN_VIS_ANALYZER_LINES);
|
|
|
2415 break;
|
|
|
2416 case MAINWIN_VIS_ANALYZER_PEAKS:
|
|
|
2417 cfg.analyzer_peaks = GTK_CHECK_MENU_ITEM(item)->active;
|
|
|
2418 break;
|
|
|
2419 case MAINWIN_VIS_SCOPE_DOT:
|
|
|
2420 case MAINWIN_VIS_SCOPE_LINE:
|
|
|
2421 case MAINWIN_VIS_SCOPE_SOLID:
|
|
|
2422 cfg.scope_mode = action - MAINWIN_VIS_SCOPE_DOT;
|
|
|
2423 break;
|
|
|
2424 case MAINWIN_VIS_VU_NORMAL:
|
|
|
2425 case MAINWIN_VIS_VU_SMOOTH:
|
|
|
2426 cfg.vu_mode = action - MAINWIN_VIS_VU_NORMAL;
|
|
|
2427 break;
|
|
|
2428 case MAINWIN_VIS_REFRESH_FULL:
|
|
|
2429 case MAINWIN_VIS_REFRESH_HALF:
|
|
|
2430 case MAINWIN_VIS_REFRESH_QUARTER:
|
|
|
2431 case MAINWIN_VIS_REFRESH_EIGHTH:
|
|
|
2432 mainwin_vis_set_refresh(action - MAINWIN_VIS_REFRESH_FULL);
|
|
|
2433 break;
|
|
|
2434 case MAINWIN_VIS_AFALLOFF_SLOWEST:
|
|
|
2435 case MAINWIN_VIS_AFALLOFF_SLOW:
|
|
|
2436 case MAINWIN_VIS_AFALLOFF_MEDIUM:
|
|
|
2437 case MAINWIN_VIS_AFALLOFF_FAST:
|
|
|
2438 case MAINWIN_VIS_AFALLOFF_FASTEST:
|
|
|
2439 mainwin_vis_set_afalloff(action - MAINWIN_VIS_AFALLOFF_SLOWEST);
|
|
|
2440 break;
|
|
|
2441 case MAINWIN_VIS_PFALLOFF_SLOWEST:
|
|
|
2442 case MAINWIN_VIS_PFALLOFF_SLOW:
|
|
|
2443 case MAINWIN_VIS_PFALLOFF_MEDIUM:
|
|
|
2444 case MAINWIN_VIS_PFALLOFF_FAST:
|
|
|
2445 case MAINWIN_VIS_PFALLOFF_FASTEST:
|
|
|
2446 mainwin_vis_set_pfalloff(action - MAINWIN_VIS_PFALLOFF_SLOWEST);
|
|
|
2447 break;
|
|
|
2448 }
|
|
|
2449 }
|
|
|
2450
|
|
|
2451 void
|
|
|
2452 mainwin_general_menu_callback(gpointer data,
|
|
|
2453 guint action,
|
|
|
2454 GtkWidget * item)
|
|
|
2455 {
|
|
|
2456 switch (action) {
|
|
|
2457 case MAINWIN_GENERAL_PREFS:
|
|
|
2458 show_prefs_window();
|
|
|
2459 break;
|
|
|
2460 case MAINWIN_GENERAL_ABOUT:
|
|
|
2461 show_about_window();
|
|
|
2462 break;
|
|
|
2463 case MAINWIN_GENERAL_PLAYFILE:
|
|
|
2464 util_run_filebrowser(NO_PLAY_BUTTON);
|
|
|
2465 break;
|
|
|
2466 case MAINWIN_GENERAL_PLAYDIRECTORY:
|
|
|
2467 mainwin_run_dirbrowser();
|
|
|
2468 break;
|
|
|
2469 case MAINWIN_GENERAL_PLAYCD:
|
|
|
2470 play_medium();
|
|
|
2471 break;
|
|
|
2472 case MAINWIN_GENERAL_ADDCD:
|
|
|
2473 add_medium();
|
|
|
2474 break;
|
|
|
2475 case MAINWIN_GENERAL_PLAYLOCATION:
|
|
|
2476 mainwin_show_add_url_window();
|
|
|
2477 break;
|
|
|
2478 case MAINWIN_GENERAL_FILEINFO:
|
|
|
2479 playlist_fileinfo_current();
|
|
|
2480 break;
|
|
|
2481 case MAINWIN_GENERAL_FOCUSPLWIN:
|
|
|
2482 gtk_window_present(GTK_WINDOW(playlistwin));
|
|
|
2483 break;
|
|
|
2484 case MAINWIN_GENERAL_SHOWPLWIN:
|
|
|
2485 if (GTK_CHECK_MENU_ITEM(item)->active)
|
|
|
2486 playlistwin_show();
|
|
|
2487 else
|
|
|
2488 playlistwin_hide();
|
|
|
2489 break;
|
|
|
2490 case MAINWIN_GENERAL_SHOWEQWIN:
|
|
|
2491 if (GTK_CHECK_MENU_ITEM(item)->active)
|
|
|
2492 equalizerwin_real_show();
|
|
|
2493 else
|
|
|
2494 equalizerwin_real_hide();
|
|
|
2495 break;
|
|
|
2496 case MAINWIN_GENERAL_PREV:
|
|
|
2497 playlist_prev();
|
|
|
2498 break;
|
|
|
2499 case MAINWIN_GENERAL_PLAY:
|
|
|
2500 mainwin_play_pushed();
|
|
|
2501 break;
|
|
|
2502 case MAINWIN_GENERAL_PAUSE:
|
|
|
2503 bmp_playback_pause();
|
|
|
2504 break;
|
|
|
2505 case MAINWIN_GENERAL_STOP:
|
|
|
2506 mainwin_stop_pushed();
|
|
|
2507 break;
|
|
|
2508 case MAINWIN_GENERAL_NEXT:
|
|
|
2509 playlist_next();
|
|
|
2510 break;
|
|
|
2511 case MAINWIN_GENERAL_BACK5SEC:
|
|
|
2512 if (bmp_playback_get_playing()
|
|
|
2513 && playlist_get_current_length() != -1)
|
|
|
2514 bmp_playback_seek_relative(-5);
|
|
|
2515 break;
|
|
|
2516 case MAINWIN_GENERAL_FWD5SEC:
|
|
|
2517 if (bmp_playback_get_playing()
|
|
|
2518 && playlist_get_current_length() != -1)
|
|
|
2519 bmp_playback_seek_relative(5);
|
|
|
2520 break;
|
|
|
2521 case MAINWIN_GENERAL_START:
|
|
|
2522 playlist_set_position(0);
|
|
|
2523 break;
|
|
|
2524 case MAINWIN_GENERAL_JTT:
|
|
|
2525 mainwin_jump_to_time();
|
|
|
2526 break;
|
|
|
2527 case MAINWIN_GENERAL_JTF:
|
|
|
2528 mainwin_jump_to_file();
|
|
|
2529 break;
|
|
|
2530 case MAINWIN_GENERAL_EXIT:
|
|
|
2531 mainwin_quit_cb();
|
|
|
2532 break;
|
|
|
2533 }
|
|
|
2534 }
|
|
|
2535
|
|
|
2536 static void
|
|
|
2537 mainwin_mr_change(MenuRowItem i)
|
|
|
2538 {
|
|
|
2539 switch (i) {
|
|
|
2540 case MENUROW_NONE:
|
|
|
2541 mainwin_set_info_text();
|
|
|
2542 break;
|
|
|
2543 case MENUROW_OPTIONS:
|
|
|
2544 mainwin_lock_info_text(_("OPTIONS MENU"));
|
|
|
2545 break;
|
|
|
2546 case MENUROW_ALWAYS:
|
|
|
2547 if (!hint_always_on_top_available()) {
|
|
|
2548 if (mainwin_menurow->mr_always_selected)
|
|
|
2549 mainwin_lock_info_text(_("DISABLE ALWAYS ON TOP (N/A)"));
|
|
|
2550 else
|
|
|
2551 mainwin_lock_info_text(_("ENABLE ALWAYS ON TOP (N/A)"));
|
|
|
2552 }
|
|
|
2553 else if (mainwin_menurow->mr_doublesize_selected)
|
|
|
2554 mainwin_lock_info_text(_("DISABLE ALWAYS ON TOP"));
|
|
|
2555 else
|
|
|
2556 mainwin_lock_info_text(_("ENABLE ALWAYS ON TOP"));
|
|
|
2557 break;
|
|
|
2558 case MENUROW_FILEINFOBOX:
|
|
|
2559 mainwin_lock_info_text(_("FILE INFO BOX"));
|
|
|
2560 break;
|
|
|
2561 case MENUROW_DOUBLESIZE:
|
|
|
2562 mainwin_lock_info_text(_("** DOUBLESIZE HAS BEEN REMOVED **"));
|
|
|
2563 break;
|
|
|
2564 case MENUROW_VISUALIZATION:
|
|
|
2565 mainwin_lock_info_text(_("VISUALIZATION MENU"));
|
|
|
2566 break;
|
|
|
2567 }
|
|
|
2568 }
|
|
|
2569
|
|
|
2570 static void
|
|
|
2571 mainwin_mr_release(MenuRowItem i)
|
|
|
2572 {
|
|
|
2573 GdkModifierType modmask;
|
|
|
2574 GtkWidget *widget;
|
|
|
2575 gint x, y;
|
|
|
2576
|
|
|
2577 switch (i) {
|
|
|
2578 case MENUROW_OPTIONS:
|
|
|
2579 gdk_window_get_pointer(NULL, &x, &y, &modmask);
|
|
|
2580 util_item_factory_popup(mainwin_view_menu, x, y, 1,
|
|
|
2581 GDK_CURRENT_TIME);
|
|
|
2582 break;
|
|
|
2583 case MENUROW_ALWAYS:
|
|
|
2584 widget =
|
|
|
2585 gtk_item_factory_get_widget(mainwin_view_menu,
|
|
|
2586 "/Always On Top");
|
|
|
2587 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget),
|
|
|
2588 mainwin_menurow->mr_always_selected);
|
|
|
2589 break;
|
|
|
2590 case MENUROW_FILEINFOBOX:
|
|
|
2591 playlist_fileinfo_current();
|
|
|
2592 break;
|
|
|
2593 case MENUROW_DOUBLESIZE:
|
|
|
2594 /* double size removed, do nothing */
|
|
|
2595 break;
|
|
|
2596 case MENUROW_VISUALIZATION:
|
|
|
2597 gdk_window_get_pointer(NULL, &x, &y, &modmask);
|
|
|
2598 util_item_factory_popup(mainwin_vis_menu, x, y, 1, GDK_CURRENT_TIME);
|
|
|
2599 break;
|
|
|
2600 case MENUROW_NONE:
|
|
|
2601 break;
|
|
|
2602 }
|
|
|
2603 mainwin_release_info_text();
|
|
|
2604 }
|
|
|
2605
|
|
|
2606 static void
|
|
|
2607 run_no_audiocd_dialog(void)
|
|
|
2608 {
|
|
|
2609 const gchar *markup =
|
|
|
2610 N_("<b><big>No playable CD found.</big></b>\n\n"
|
|
|
2611 "No CD inserted, or inserted CD is not an audio CD.\n");
|
|
|
2612
|
|
|
2613 GtkWidget *dialog =
|
|
|
2614 gtk_message_dialog_new_with_markup(GTK_WINDOW(mainwin),
|
|
|
2615 GTK_DIALOG_DESTROY_WITH_PARENT,
|
|
|
2616 GTK_MESSAGE_ERROR,
|
|
|
2617 GTK_BUTTONS_OK,
|
|
|
2618 _(markup));
|
|
|
2619 gtk_dialog_run(GTK_DIALOG(dialog));
|
|
|
2620 gtk_widget_destroy(dialog);
|
|
|
2621 }
|
|
|
2622
|
|
|
2623 static void
|
|
|
2624 run_no_output_device_dialog(void)
|
|
|
2625 {
|
|
|
2626 const gchar *markup =
|
|
|
2627 N_("<b><big>Couldn't open audio.</big></b>\n\n"
|
|
|
2628 "Please check that:\n"
|
|
|
2629 "1. You have the correct output plugin selected.\n"
|
|
|
2630 "2. No other programs is blocking the soundcard.\n"
|
|
|
2631 "3. Your soundcard is configured properly.\n");
|
|
|
2632
|
|
|
2633 GtkWidget *dialog =
|
|
|
2634 gtk_message_dialog_new_with_markup(GTK_WINDOW(mainwin),
|
|
|
2635 GTK_DIALOG_DESTROY_WITH_PARENT,
|
|
|
2636 GTK_MESSAGE_ERROR,
|
|
|
2637 GTK_BUTTONS_OK,
|
|
|
2638 _(markup));
|
|
|
2639 gtk_dialog_run(GTK_DIALOG(dialog));
|
|
|
2640 gtk_widget_destroy(dialog);
|
|
|
2641 }
|
|
|
2642
|
|
|
2643
|
|
|
2644 void
|
|
|
2645 add_medium(void)
|
|
|
2646 {
|
|
|
2647 GList *list, *node;
|
|
|
2648 gchar *filename;
|
|
|
2649 gchar *path;
|
|
|
2650 ConfigDb *db;
|
|
|
2651
|
|
|
2652 db = bmp_cfg_db_open();
|
|
|
2653
|
|
|
2654 bmp_cfg_db_get_string(db, "CDDA", "directory", &path);
|
|
|
2655 bmp_cfg_db_close(db);
|
|
|
2656
|
|
|
2657 if (!(list = input_scan_dir(path))) {
|
|
|
2658 run_no_audiocd_dialog();
|
|
|
2659 return;
|
|
|
2660 }
|
|
|
2661
|
|
|
2662 for (node = list; node; node = g_list_next(node)) {
|
|
|
2663 filename = g_build_filename(path, node->data, NULL);
|
|
|
2664 playlist_add(filename);
|
|
|
2665 g_free(filename);
|
|
|
2666 g_free(node->data);
|
|
|
2667 }
|
|
|
2668
|
|
|
2669 g_free(path);
|
|
|
2670 g_list_free(list);
|
|
|
2671
|
|
|
2672 }
|
|
|
2673
|
|
|
2674 void
|
|
|
2675 play_medium(void)
|
|
|
2676 {
|
|
|
2677 GList *list, *node;
|
|
|
2678 gchar *filename;
|
|
|
2679 gchar *path;
|
|
|
2680 ConfigDb *db;
|
|
|
2681
|
|
|
2682 db = bmp_cfg_db_open();
|
|
|
2683 bmp_cfg_db_get_string(db, "CDDA", "directory", &path);
|
|
|
2684 bmp_cfg_db_close(db);
|
|
|
2685
|
|
|
2686 if (!(list = input_scan_dir(path))) {
|
|
|
2687 run_no_audiocd_dialog();
|
|
|
2688 return;
|
|
|
2689 }
|
|
|
2690
|
|
|
2691 playlist_clear();
|
|
|
2692
|
|
|
2693 for (node = list; node; node = g_list_next(node)) {
|
|
|
2694 filename = g_build_filename(path, node->data, NULL);
|
|
|
2695 playlist_add(filename);
|
|
|
2696 g_free(filename);
|
|
|
2697 g_free(node->data);
|
|
|
2698 }
|
|
|
2699
|
|
|
2700 g_free(path);
|
|
|
2701 g_list_free(list);
|
|
|
2702
|
|
|
2703 playlist_set_position(0);
|
|
|
2704 bmp_playback_initiate();
|
|
|
2705 }
|
|
|
2706
|
|
|
2707 void
|
|
|
2708 read_volume(gint when)
|
|
|
2709 {
|
|
|
2710 static gint pvl = 0, pvr = 0;
|
|
|
2711 static gint times = VOLSET_DISP_TIMES;
|
|
|
2712 static gboolean changing = FALSE;
|
|
|
2713
|
|
|
2714 gint vl, vr, b, v;
|
|
|
2715
|
|
|
2716 input_get_volume(&vl, &vr);
|
|
|
2717
|
|
|
2718 switch (when) {
|
|
|
2719 case VOLSET_STARTUP:
|
|
|
2720 vl = CLAMP(vl, 0, 100);
|
|
|
2721 vr = CLAMP(vr, 0, 100);
|
|
|
2722 pvl = vl;
|
|
|
2723 pvr = vr;
|
|
|
2724 v = MAX(vl, vr);
|
|
|
2725 if (vl > vr)
|
|
|
2726 b = (gint) rint(((gdouble) vr / vl) * 100) - 100;
|
|
|
2727 else if (vl < vr)
|
|
|
2728 b = 100 - (gint) rint(((gdouble) vl / vr) * 100);
|
|
|
2729 else
|
|
|
2730 b = 0;
|
|
|
2731
|
|
|
2732 balance = b;
|
|
|
2733 mainwin_set_volume_slider(v);
|
|
|
2734 equalizerwin_set_volume_slider(v);
|
|
|
2735 mainwin_set_balance_slider(b);
|
|
|
2736 equalizerwin_set_balance_slider(b);
|
|
|
2737 return;
|
|
|
2738
|
|
|
2739 case VOLSET_UPDATE:
|
|
|
2740 if (vl == -1 || vr == -1)
|
|
|
2741 return;
|
|
|
2742
|
|
|
2743 if (setting_volume) {
|
|
|
2744 pvl = vl;
|
|
|
2745 pvr = vr;
|
|
|
2746 return;
|
|
|
2747 }
|
|
|
2748
|
|
|
2749 if (pvr == vr && pvl == vl && changing) {
|
|
|
2750 if (times < VOLSET_DISP_TIMES)
|
|
|
2751 times++;
|
|
|
2752 else {
|
|
|
2753 mainwin_release_info_text();
|
|
|
2754 changing = FALSE;
|
|
|
2755 }
|
|
|
2756 }
|
|
|
2757 else if (pvr != vr || pvl != vl) {
|
|
|
2758 gchar *tmp;
|
|
|
2759
|
|
|
2760 v = MAX(vl, vr);
|
|
|
2761 if (vl > vr)
|
|
|
2762 b = (gint) rint(((gdouble) vr / vl) * 100) - 100;
|
|
|
2763 else if (vl < vr)
|
|
|
2764 b = 100 - (gint) rint(((gdouble) vl / vr) * 100);
|
|
|
2765 else
|
|
|
2766 b = 0;
|
|
|
2767
|
|
|
2768 if (MAX(vl, vr) != MAX(pvl, pvr))
|
|
|
2769 tmp = g_strdup_printf(_("VOLUME: %d%%"), v);
|
|
|
2770 else {
|
|
|
2771 if (vl > vr) {
|
|
|
2772 tmp = g_strdup_printf(_("BALANCE: %d%% LEFT"), -b);
|
|
|
2773 }
|
|
|
2774 else if (vr == vl)
|
|
|
2775 tmp = g_strdup_printf(_("BALANCE: CENTER"));
|
|
|
2776 else { /* (vl < vr) */
|
|
|
2777 tmp = g_strdup_printf(_("BALANCE: %d%% RIGHT"), b);
|
|
|
2778 }
|
|
|
2779 }
|
|
|
2780 mainwin_lock_info_text(tmp);
|
|
|
2781 g_free(tmp);
|
|
|
2782
|
|
|
2783 pvr = vr;
|
|
|
2784 pvl = vl;
|
|
|
2785 times = 0;
|
|
|
2786 changing = TRUE;
|
|
|
2787 mainwin_set_volume_slider(v);
|
|
|
2788 equalizerwin_set_volume_slider(v);
|
|
|
2789
|
|
|
2790 /* Don't change the balance slider if the volume has been
|
|
|
2791 * set to zero. The balance can be anything, and our best
|
|
|
2792 * guess is what is was before. */
|
|
|
2793 if (v > 0) {
|
|
|
2794 balance = b;
|
|
|
2795 mainwin_set_balance_slider(b);
|
|
|
2796 equalizerwin_set_balance_slider(b);
|
|
|
2797 }
|
|
|
2798 }
|
|
|
2799 break;
|
|
|
2800
|
|
|
2801 case VOLUME_ADJUSTED:
|
|
|
2802 pvl = vl;
|
|
|
2803 pvr = vr;
|
|
|
2804 break;
|
|
|
2805
|
|
|
2806 case VOLUME_SET:
|
|
|
2807 times = 0;
|
|
|
2808 changing = TRUE;
|
|
|
2809 pvl = vl;
|
|
|
2810 pvr = vr;
|
|
|
2811 break;
|
|
|
2812 }
|
|
|
2813 }
|
|
|
2814
|
|
|
2815
|
|
|
2816 /* TODO: HAL! */
|
|
|
2817 gboolean
|
|
|
2818 can_play_cd(void)
|
|
|
2819 {
|
|
|
2820 GList *ilist;
|
|
|
2821
|
|
|
2822 for (ilist = get_input_list(); ilist; ilist = g_list_next(ilist)) {
|
|
|
2823 InputPlugin *ip = INPUT_PLUGIN(ilist->data);
|
|
|
2824
|
|
|
2825 if (!g_ascii_strcasecmp(g_basename(ip->filename),
|
|
|
2826 PLUGIN_FILENAME("cdaudio"))) {
|
|
|
2827 return TRUE;
|
|
|
2828 }
|
|
|
2829 }
|
|
|
2830
|
|
|
2831 return FALSE;
|
|
|
2832 }
|
|
|
2833
|
|
|
2834
|
|
|
2835 static void
|
|
|
2836 set_timer_mode(TimerMode mode)
|
|
|
2837 {
|
|
|
2838 if (mode == TIMER_ELAPSED)
|
|
|
2839 check_set(mainwin_view_menu, "/Time Elapsed", TRUE);
|
|
|
2840 else
|
|
|
2841 check_set(mainwin_view_menu, "/Time Remaining", TRUE);
|
|
|
2842 }
|
|
|
2843
|
|
|
2844 static void
|
|
|
2845 set_timer_mode_menu_cb(TimerMode mode)
|
|
|
2846 {
|
|
|
2847 cfg.timer_mode = mode;
|
|
|
2848 }
|
|
|
2849
|
|
|
2850
|
|
|
2851 void
|
|
|
2852 mainwin_setup_menus(void)
|
|
|
2853 {
|
|
|
2854 set_timer_mode(cfg.timer_mode);
|
|
|
2855
|
|
|
2856 /* View menu */
|
|
|
2857
|
|
|
2858 check_set(mainwin_view_menu, "/Always On Top", cfg.always_on_top);
|
|
|
2859 check_set(mainwin_view_menu, "/Put on All Workspaces", cfg.sticky);
|
|
|
2860 check_set(mainwin_view_menu, "/Roll up Player", cfg.player_shaded);
|
|
|
2861 check_set(mainwin_view_menu, "/Roll up Playlist Editor", cfg.playlist_shaded);
|
|
|
2862 check_set(mainwin_view_menu, "/Roll up Equalizer", cfg.equalizer_shaded);
|
|
|
2863
|
|
|
2864 /* Songname menu */
|
|
|
2865
|
|
|
2866 check_set(mainwin_songname_menu, "/Autoscroll Songname", cfg.autoscroll);
|
|
|
2867
|
|
|
2868 /* Playback menu */
|
|
|
2869
|
|
|
2870 check_set(mainwin_play_menu, "/Repeat", cfg.repeat);
|
|
|
2871 check_set(mainwin_play_menu, "/Shuffle", cfg.shuffle);
|
|
|
2872
|
|
|
2873 /* Visualization menu */
|
|
|
2874
|
|
|
2875 check_set(mainwin_vis_menu,
|
|
|
2876 mainwin_vis_menu_entries[MAINWIN_VIS_MENU_VIS_MODE +
|
|
|
2877 cfg.vis_type].path, TRUE);
|
|
|
2878 check_set(mainwin_vis_menu,
|
|
|
2879 mainwin_vis_menu_entries[MAINWIN_VIS_MENU_ANALYZER_MODE +
|
|
|
2880 cfg.analyzer_mode].path, TRUE);
|
|
|
2881 check_set(mainwin_vis_menu,
|
|
|
2882 mainwin_vis_menu_entries[MAINWIN_VIS_MENU_ANALYZER_TYPE +
|
|
|
2883 cfg.analyzer_type].path, TRUE);
|
|
|
2884 check_set(mainwin_vis_menu,
|
|
|
2885 mainwin_vis_menu_entries[MAINWIN_VIS_MENU_ANALYZER_PEAKS].
|
|
|
2886 path, cfg.analyzer_peaks);
|
|
|
2887 check_set(mainwin_vis_menu,
|
|
|
2888 mainwin_vis_menu_entries[MAINWIN_VIS_MENU_SCOPE_MODE +
|
|
|
2889 cfg.scope_mode].path, TRUE);
|
|
|
2890 check_set(mainwin_vis_menu,
|
|
|
2891 mainwin_vis_menu_entries[MAINWIN_VIS_MENU_WSHADEVU_MODE +
|
|
|
2892 cfg.vu_mode].path, TRUE);
|
|
|
2893 check_set(mainwin_vis_menu,
|
|
|
2894 mainwin_vis_menu_entries[MAINWIN_VIS_MENU_REFRESH_RATE +
|
|
|
2895 cfg.vis_refresh].path, TRUE);
|
|
|
2896 check_set(mainwin_vis_menu,
|
|
|
2897 mainwin_vis_menu_entries[MAINWIN_VIS_MENU_AFALLOFF +
|
|
|
2898 cfg.analyzer_falloff].path, TRUE);
|
|
|
2899 check_set(mainwin_vis_menu,
|
|
|
2900 mainwin_vis_menu_entries[MAINWIN_VIS_MENU_PFALLOFF +
|
|
|
2901 cfg.peaks_falloff].path, TRUE);
|
|
|
2902 }
|
|
|
2903
|
|
|
2904 static void
|
|
|
2905 mainwin_create_widgets(void)
|
|
|
2906 {
|
|
|
2907 mainwin_menubtn =
|
|
|
2908 create_pbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 6, 3, 9, 9,
|
|
|
2909 0, 0, 0, 9, mainwin_menubtn_cb, SKIN_TITLEBAR);
|
|
|
2910 mainwin_menubtn->pb_allow_draw = FALSE;
|
|
|
2911 mainwin_minimize =
|
|
|
2912 create_pbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 244, 3, 9,
|
|
|
2913 9, 9, 0, 9, 9, mainwin_minimize_cb, SKIN_TITLEBAR);
|
|
|
2914 mainwin_minimize->pb_allow_draw = FALSE;
|
|
|
2915 mainwin_shade =
|
|
|
2916 create_pbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 254, 3, 9,
|
|
|
2917 9, 0, cfg.player_shaded ? 27 : 18, 9,
|
|
|
2918 cfg.player_shaded ? 27 : 18, mainwin_shade_toggle,
|
|
|
2919 SKIN_TITLEBAR);
|
|
|
2920 mainwin_shade->pb_allow_draw = FALSE;
|
|
|
2921 mainwin_close =
|
|
|
2922 create_pbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 264, 3, 9,
|
|
|
2923 9, 18, 0, 18, 9, mainwin_quit_cb, SKIN_TITLEBAR);
|
|
|
2924 mainwin_close->pb_allow_draw = FALSE;
|
|
|
2925
|
|
|
2926 mainwin_rew =
|
|
|
2927 create_pbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 16, 88, 23,
|
|
|
2928 18, 0, 0, 0, 18, playlist_prev, SKIN_CBUTTONS);
|
|
|
2929 mainwin_play =
|
|
|
2930 create_pbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 39, 88, 23,
|
|
|
2931 18, 23, 0, 23, 18, mainwin_play_pushed, SKIN_CBUTTONS);
|
|
|
2932 mainwin_pause =
|
|
|
2933 create_pbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 62, 88, 23,
|
|
|
2934 18, 46, 0, 46, 18, bmp_playback_pause, SKIN_CBUTTONS);
|
|
|
2935 mainwin_stop =
|
|
|
2936 create_pbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 85, 88, 23,
|
|
|
2937 18, 69, 0, 69, 18, mainwin_stop_pushed, SKIN_CBUTTONS);
|
|
|
2938 mainwin_fwd =
|
|
|
2939 create_pbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 108, 88, 22,
|
|
|
2940 18, 92, 0, 92, 18, playlist_next, SKIN_CBUTTONS);
|
|
|
2941 mainwin_eject =
|
|
|
2942 create_pbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 136, 89, 22,
|
|
|
2943 16, 114, 0, 114, 16, mainwin_eject_pushed,
|
|
|
2944 SKIN_CBUTTONS);
|
|
|
2945
|
|
|
2946 mainwin_srew =
|
|
|
2947 create_sbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 169, 4, 8,
|
|
|
2948 7, playlist_prev);
|
|
|
2949 mainwin_splay =
|
|
|
2950 create_sbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 177, 4, 10,
|
|
|
2951 7, mainwin_play_pushed);
|
|
|
2952 mainwin_spause =
|
|
|
2953 create_sbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 187, 4, 10,
|
|
|
2954 7, bmp_playback_pause);
|
|
|
2955 mainwin_sstop =
|
|
|
2956 create_sbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 197, 4, 9,
|
|
|
2957 7, mainwin_stop_pushed);
|
|
|
2958 mainwin_sfwd =
|
|
|
2959 create_sbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 206, 4, 8,
|
|
|
2960 7, playlist_next);
|
|
|
2961 mainwin_seject =
|
|
|
2962 create_sbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 216, 4, 9,
|
|
|
2963 7, mainwin_eject_pushed);
|
|
|
2964
|
|
|
2965 mainwin_shuffle =
|
|
|
2966 create_tbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 164, 89, 46,
|
|
|
2967 15, 28, 0, 28, 15, 28, 30, 28, 45,
|
|
|
2968 mainwin_shuffle_pushed, SKIN_SHUFREP);
|
|
|
2969
|
|
|
2970 mainwin_repeat =
|
|
|
2971 create_tbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 210, 89, 28,
|
|
|
2972 15, 0, 0, 0, 15, 0, 30, 0, 45,
|
|
|
2973 mainwin_repeat_pushed, SKIN_SHUFREP);
|
|
|
2974
|
|
|
2975 mainwin_eq =
|
|
|
2976 create_tbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 219, 58, 23,
|
|
|
2977 12, 0, 61, 46, 61, 0, 73, 46, 73, equalizerwin_show,
|
|
|
2978 SKIN_SHUFREP);
|
|
|
2979 tbutton_set_toggled(mainwin_eq, cfg.equalizer_visible);
|
|
|
2980 mainwin_pl =
|
|
|
2981 create_tbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 242, 58, 23,
|
|
|
2982 12, 23, 61, 69, 61, 23, 73, 69, 73,
|
|
|
2983 mainwin_pl_pushed, SKIN_SHUFREP);
|
|
|
2984 tbutton_set_toggled(mainwin_pl, cfg.playlist_visible);
|
|
|
2985
|
|
|
2986 mainwin_info =
|
|
|
2987 create_textbox(&mainwin_wlist, mainwin_bg, mainwin_gc, 112, 27,
|
|
|
2988 153, 1, SKIN_TEXT);
|
|
|
2989 textbox_set_scroll(mainwin_info, cfg.autoscroll);
|
|
|
2990 textbox_set_xfont(mainwin_info, TRUE, cfg.mainwin_font);
|
|
|
2991 mainwin_rate_text =
|
|
|
2992 create_textbox(&mainwin_wlist, mainwin_bg, mainwin_gc, 111, 43, 15,
|
|
|
2993 0, SKIN_TEXT);
|
|
|
2994 mainwin_freq_text =
|
|
|
2995 create_textbox(&mainwin_wlist, mainwin_bg, mainwin_gc, 156, 43, 10,
|
|
|
2996 0, SKIN_TEXT);
|
|
|
2997
|
|
|
2998 mainwin_menurow =
|
|
|
2999 create_menurow(&mainwin_wlist, mainwin_bg, mainwin_gc, 10, 22, 304,
|
|
|
3000 0, 304, 44, mainwin_mr_change, mainwin_mr_release,
|
|
|
3001 SKIN_TITLEBAR);
|
|
|
3002 mainwin_menurow->mr_doublesize_selected = FALSE;
|
|
|
3003 mainwin_menurow->mr_always_selected = cfg.always_on_top;
|
|
|
3004
|
|
|
3005 mainwin_volume =
|
|
|
3006 create_hslider(&mainwin_wlist, mainwin_bg, mainwin_gc, 107, 57, 68,
|
|
|
3007 13, 15, 422, 0, 422, 14, 11, 15, 0, 0, 51,
|
|
|
3008 mainwin_volume_frame_cb, mainwin_volume_motion_cb,
|
|
|
3009 mainwin_volume_release_cb, SKIN_VOLUME);
|
|
|
3010 mainwin_balance =
|
|
|
3011 create_hslider(&mainwin_wlist, mainwin_bg, mainwin_gc, 177, 57, 38,
|
|
|
3012 13, 15, 422, 0, 422, 14, 11, 15, 9, 0, 24,
|
|
|
3013 mainwin_balance_frame_cb, mainwin_balance_motion_cb,
|
|
|
3014 mainwin_balance_release_cb, SKIN_BALANCE);
|
|
|
3015
|
|
|
3016 mainwin_monostereo =
|
|
|
3017 create_monostereo(&mainwin_wlist, mainwin_bg, mainwin_gc, 212, 41,
|
|
|
3018 SKIN_MONOSTEREO);
|
|
|
3019
|
|
|
3020 mainwin_playstatus =
|
|
|
3021 create_playstatus(&mainwin_wlist, mainwin_bg, mainwin_gc, 24, 28);
|
|
|
3022
|
|
|
3023 mainwin_minus_num =
|
|
|
3024 create_number(&mainwin_wlist, mainwin_bg, mainwin_gc, 36, 26,
|
|
|
3025 SKIN_NUMBERS);
|
|
|
3026 widget_hide(WIDGET(mainwin_minus_num));
|
|
|
3027 mainwin_10min_num =
|
|
|
3028 create_number(&mainwin_wlist, mainwin_bg, mainwin_gc, 48, 26,
|
|
|
3029 SKIN_NUMBERS);
|
|
|
3030 widget_hide(WIDGET(mainwin_10min_num));
|
|
|
3031
|
|
|
3032 mainwin_min_num =
|
|
|
3033 create_number(&mainwin_wlist, mainwin_bg, mainwin_gc, 60, 26,
|
|
|
3034 SKIN_NUMBERS);
|
|
|
3035 widget_hide(WIDGET(mainwin_min_num));
|
|
|
3036
|
|
|
3037 mainwin_10sec_num =
|
|
|
3038 create_number(&mainwin_wlist, mainwin_bg, mainwin_gc, 78, 26,
|
|
|
3039 SKIN_NUMBERS);
|
|
|
3040 widget_hide(WIDGET(mainwin_10sec_num));
|
|
|
3041
|
|
|
3042 mainwin_sec_num =
|
|
|
3043 create_number(&mainwin_wlist, mainwin_bg, mainwin_gc, 90, 26,
|
|
|
3044 SKIN_NUMBERS);
|
|
|
3045 widget_hide(WIDGET(mainwin_sec_num));
|
|
|
3046
|
|
|
3047 mainwin_about =
|
|
|
3048 create_sbutton(&mainwin_wlist, mainwin_bg, mainwin_gc, 247, 83, 20,
|
|
|
3049 25, show_about_window);
|
|
|
3050
|
|
|
3051 mainwin_vis =
|
|
|
3052 create_vis(&mainwin_wlist, mainwin_bg, mainwin->window, mainwin_gc,
|
|
|
3053 24, 43, 76);
|
|
|
3054 mainwin_svis = create_svis(&mainwin_wlist, mainwin_bg, mainwin_gc, 79, 5);
|
|
|
3055 active_vis = mainwin_vis;
|
|
|
3056
|
|
|
3057 mainwin_position =
|
|
|
3058 create_hslider(&mainwin_wlist, mainwin_bg, mainwin_gc, 16, 72, 248,
|
|
|
3059 10, 248, 0, 278, 0, 29, 10, 10, 0, 0, 219, NULL,
|
|
|
3060 mainwin_position_motion_cb,
|
|
|
3061 mainwin_position_release_cb, SKIN_POSBAR);
|
|
|
3062 widget_hide(WIDGET(mainwin_position));
|
|
|
3063
|
|
|
3064 mainwin_sposition =
|
|
|
3065 create_hslider(&mainwin_wlist, mainwin_bg, mainwin_gc, 226, 4, 17,
|
|
|
3066 7, 17, 36, 17, 36, 3, 7, 36, 0, 1, 13,
|
|
|
3067 mainwin_spos_frame_cb, mainwin_spos_motion_cb,
|
|
|
3068 mainwin_spos_release_cb, SKIN_TITLEBAR);
|
|
|
3069 widget_hide(WIDGET(mainwin_sposition));
|
|
|
3070
|
|
|
3071 mainwin_stime_min =
|
|
|
3072 create_textbox(&mainwin_wlist, mainwin_bg, mainwin_gc, 130, 4, 15,
|
|
|
3073 FALSE, SKIN_TEXT);
|
|
|
3074 mainwin_stime_sec =
|
|
|
3075 create_textbox(&mainwin_wlist, mainwin_bg, mainwin_gc, 147, 4, 10,
|
|
|
3076 FALSE, SKIN_TEXT);
|
|
|
3077
|
|
|
3078 if (!cfg.player_shaded) {
|
|
|
3079 widget_hide(WIDGET(mainwin_svis));
|
|
|
3080 widget_hide(WIDGET(mainwin_srew));
|
|
|
3081 widget_hide(WIDGET(mainwin_splay));
|
|
|
3082 widget_hide(WIDGET(mainwin_spause));
|
|
|
3083 widget_hide(WIDGET(mainwin_sstop));
|
|
|
3084 widget_hide(WIDGET(mainwin_sfwd));
|
|
|
3085 widget_hide(WIDGET(mainwin_seject));
|
|
|
3086 widget_hide(WIDGET(mainwin_stime_min));
|
|
|
3087 widget_hide(WIDGET(mainwin_stime_sec));
|
|
|
3088 }
|
|
|
3089
|
|
|
3090 }
|
|
|
3091
|
|
|
3092 static void
|
|
|
3093 mainwin_create_window(void)
|
|
|
3094 {
|
|
|
3095 gint width, height;
|
|
|
3096
|
|
|
3097 mainwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
|
|
3098 gtk_window_set_title(GTK_WINDOW(mainwin), _("Audacious"));
|
|
|
3099 gtk_window_set_role(GTK_WINDOW(mainwin), "player");
|
|
|
3100 gtk_window_set_resizable(GTK_WINDOW(mainwin), FALSE);
|
|
|
3101
|
|
|
3102 width = MAINWIN_WIDTH;
|
|
|
3103 height = cfg.player_shaded ? MAINWIN_SHADED_HEIGHT : MAINWIN_HEIGHT;
|
|
|
3104
|
|
|
3105 gtk_widget_set_size_request(mainwin, width, height);
|
|
|
3106 gtk_widget_set_app_paintable(mainwin, TRUE);
|
|
|
3107
|
|
|
3108 dock_window_list = dock_window_set_decorated(dock_window_list,
|
|
|
3109 GTK_WINDOW(mainwin),
|
|
|
3110 cfg.show_wm_decorations);
|
|
|
3111
|
|
|
3112 if (cfg.player_x != -1 && cfg.save_window_position)
|
|
|
3113 gtk_window_move(GTK_WINDOW(mainwin), cfg.player_x, cfg.player_y);
|
|
|
3114
|
|
|
3115 gtk_widget_add_events(mainwin,
|
|
|
3116 GDK_FOCUS_CHANGE_MASK | GDK_BUTTON_MOTION_MASK |
|
|
|
3117 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
|
|
|
3118 GDK_SCROLL_MASK | GDK_KEY_PRESS_MASK |
|
|
|
3119 GDK_VISIBILITY_NOTIFY_MASK);
|
|
|
3120 gtk_widget_realize(mainwin);
|
|
|
3121
|
|
|
3122 util_set_cursor(mainwin);
|
|
|
3123
|
|
|
3124 g_signal_connect(mainwin, "destroy", G_CALLBACK(mainwin_destroy), NULL);
|
|
|
3125 g_signal_connect(mainwin, "button_press_event",
|
|
|
3126 G_CALLBACK(mainwin_mouse_button_press), NULL);
|
|
|
3127 g_signal_connect(mainwin, "scroll_event",
|
|
|
3128 G_CALLBACK(mainwin_scrolled), NULL);
|
|
|
3129 g_signal_connect(mainwin, "button_release_event",
|
|
|
3130 G_CALLBACK(mainwin_mouse_button_release), NULL);
|
|
|
3131 g_signal_connect(mainwin, "motion_notify_event",
|
|
|
3132 G_CALLBACK(mainwin_motion), NULL);
|
|
|
3133 g_signal_connect_after(mainwin, "focus_in_event",
|
|
|
3134 G_CALLBACK(mainwin_focus_in), NULL);
|
|
|
3135 g_signal_connect_after(mainwin, "focus_out_event",
|
|
|
3136 G_CALLBACK(mainwin_focus_out), NULL);
|
|
|
3137 g_signal_connect(mainwin, "configure_event",
|
|
|
3138 G_CALLBACK(mainwin_configure), NULL);
|
|
|
3139 g_signal_connect(mainwin, "style_set",
|
|
|
3140 G_CALLBACK(mainwin_set_back_pixmap), NULL);
|
|
|
3141
|
|
|
3142 bmp_drag_dest_set(mainwin);
|
|
|
3143
|
|
|
3144 g_signal_connect(mainwin, "key_press_event",
|
|
|
3145 G_CALLBACK(mainwin_keypress), NULL);
|
|
|
3146 }
|
|
|
3147
|
|
|
3148 static void
|
|
|
3149 mainwin_create_menus(void)
|
|
|
3150 {
|
|
|
3151 mainwin_general_menu = create_menu(mainwin_general_menu_entries,
|
|
|
3152 mainwin_general_menu_entries_num,
|
|
|
3153 mainwin_accel);
|
|
|
3154
|
|
|
3155 mainwin_play_menu = create_menu(mainwin_playback_menu_entries,
|
|
|
3156 mainwin_playback_menu_entries_num,
|
|
|
3157 mainwin_accel);
|
|
|
3158
|
|
|
3159 mainwin_view_menu = create_menu(mainwin_view_menu_entries,
|
|
|
3160 mainwin_view_menu_entries_num,
|
|
|
3161 mainwin_accel);
|
|
|
3162
|
|
|
3163 mainwin_songname_menu = create_menu(mainwin_songname_menu_entries,
|
|
|
3164 mainwin_songname_menu_entries_num,
|
|
|
3165 mainwin_accel);
|
|
|
3166
|
|
|
3167 mainwin_add_menu = create_menu(mainwin_add_menu_entries,
|
|
|
3168 mainwin_add_menu_entries_num,
|
|
|
3169 mainwin_accel);
|
|
|
3170
|
|
|
3171 mainwin_vis_menu = create_menu(mainwin_vis_menu_entries,
|
|
|
3172 mainwin_vis_menu_entries_num,
|
|
|
3173 mainwin_accel);
|
|
|
3174
|
|
|
3175 make_submenu(mainwin_general_menu, "/View", mainwin_view_menu);
|
|
|
3176
|
|
|
3177 gtk_window_add_accel_group(GTK_WINDOW(mainwin), mainwin_accel);
|
|
|
3178 }
|
|
|
3179
|
|
|
3180 void
|
|
|
3181 mainwin_create(void)
|
|
|
3182 {
|
|
|
3183 mainwin_create_window();
|
|
|
3184
|
|
|
3185 mainwin_accel = gtk_accel_group_new();
|
|
|
3186 mainwin_create_menus();
|
|
|
3187
|
|
|
3188 mainwin_gc = gdk_gc_new(mainwin->window);
|
|
|
3189 mainwin_bg = gdk_pixmap_new(mainwin->window,
|
|
|
3190 MAINWIN_WIDTH, MAINWIN_HEIGHT, -1);
|
|
|
3191 mainwin_set_back_pixmap();
|
|
|
3192 mainwin_create_widgets();
|
|
|
3193
|
|
|
3194 vis_set_window(mainwin_vis, mainwin->window);
|
|
|
3195 }
|
|
|
3196
|
|
|
3197 void
|
|
|
3198 mainwin_attach_idle_func(void)
|
|
|
3199 {
|
|
|
3200 mainwin_timeout_id = g_timeout_add(MAINWIN_UPDATE_INTERVAL,
|
|
|
3201 mainwin_idle_func, NULL);
|
|
|
3202 }
|
|
|
3203
|
|
|
3204 static gboolean
|
|
|
3205 idle_func_change_song(gboolean waiting)
|
|
|
3206 {
|
|
|
3207 static GTimer *pause_timer = NULL;
|
|
|
3208
|
|
|
3209 if (!pause_timer)
|
|
|
3210 pause_timer = g_timer_new();
|
|
|
3211
|
|
|
3212 if (cfg.pause_between_songs) {
|
|
|
3213 gint timeleft;
|
|
|
3214
|
|
|
3215 if (!waiting) {
|
|
|
3216 g_timer_start(pause_timer);
|
|
|
3217 waiting = TRUE;
|
|
|
3218 }
|
|
|
3219
|
|
|
3220 timeleft = cfg.pause_between_songs_time -
|
|
|
3221 (gint) g_timer_elapsed(pause_timer, NULL);
|
|
|
3222
|
|
|
3223 number_set_number(mainwin_10min_num, timeleft / 600);
|
|
|
3224 number_set_number(mainwin_min_num, (timeleft / 60) % 10);
|
|
|
3225 number_set_number(mainwin_10sec_num, (timeleft / 10) % 6);
|
|
|
3226 number_set_number(mainwin_sec_num, timeleft % 10);
|
|
|
3227
|
|
|
3228 if (!mainwin_sposition->hs_pressed) {
|
|
|
3229 gchar time_str[5];
|
|
|
3230
|
|
|
3231 g_snprintf(time_str, sizeof(time_str), "%2.2d", timeleft / 60);
|
|
|
3232 textbox_set_text(mainwin_stime_min, time_str);
|
|
|
3233
|
|
|
3234 g_snprintf(time_str, sizeof(time_str), "%2.2d", timeleft % 60);
|
|
|
3235 textbox_set_text(mainwin_stime_sec, time_str);
|
|
|
3236 }
|
|
|
3237
|
|
|
3238 playlistwin_set_time(timeleft * 1000, 0, TIMER_ELAPSED);
|
|
|
3239 }
|
|
|
3240
|
|
|
3241 if (!cfg.pause_between_songs ||
|
|
|
3242 g_timer_elapsed(pause_timer, NULL) >= cfg.pause_between_songs_time) {
|
|
|
3243
|
|
|
3244 GDK_THREADS_ENTER();
|
|
|
3245 playlist_eof_reached();
|
|
|
3246 GDK_THREADS_LEAVE();
|
|
|
3247
|
|
|
3248 waiting = FALSE;
|
|
|
3249 }
|
|
|
3250
|
|
|
3251 return waiting;
|
|
|
3252 }
|
|
|
3253
|
|
|
3254 static void
|
|
|
3255 idle_func_update_song_info(gint time)
|
|
|
3256 {
|
|
|
3257 gint length, t;
|
|
|
3258 gchar stime_prefix;
|
|
|
3259
|
|
|
3260 length = playlist_get_current_length();
|
|
|
3261 playlistwin_set_time(time, length, cfg.timer_mode);
|
|
|
3262 input_update_vis(time);
|
|
|
3263
|
|
|
3264 if (cfg.timer_mode == TIMER_REMAINING) {
|
|
|
3265 if (length != -1) {
|
|
|
3266 number_set_number(mainwin_minus_num, 11);
|
|
|
3267 t = length - time;
|
|
|
3268 stime_prefix = '-';
|
|
|
3269 }
|
|
|
3270 else {
|
|
|
3271 number_set_number(mainwin_minus_num, 10);
|
|
|
3272 t = time;
|
|
|
3273 stime_prefix = ' ';
|
|
|
3274 }
|
|
|
3275 }
|
|
|
3276 else {
|
|
|
3277 number_set_number(mainwin_minus_num, 10);
|
|
|
3278 t = time;
|
|
|
3279 stime_prefix = ' ';
|
|
|
3280 }
|
|
|
3281 t /= 1000;
|
|
|
3282
|
|
|
3283 /* Show the time in the format HH:MM when we have more than 100
|
|
|
3284 * minutes. */
|
|
|
3285 if (t >= 100 * 60)
|
|
|
3286 t /= 60;
|
|
|
3287 number_set_number(mainwin_10min_num, t / 600);
|
|
|
3288 number_set_number(mainwin_min_num, (t / 60) % 10);
|
|
|
3289 number_set_number(mainwin_10sec_num, (t / 10) % 6);
|
|
|
3290 number_set_number(mainwin_sec_num, t % 10);
|
|
|
3291
|
|
|
3292 if (!mainwin_sposition->hs_pressed) {
|
|
|
3293 gchar *time_str;
|
|
|
3294
|
|
|
3295 time_str = g_strdup_printf("%c%2.2d", stime_prefix, t / 60);
|
|
|
3296 textbox_set_text(mainwin_stime_min, time_str);
|
|
|
3297 g_free(time_str);
|
|
|
3298
|
|
|
3299 time_str = g_strdup_printf("%2.2d", t % 60);
|
|
|
3300 textbox_set_text(mainwin_stime_sec, time_str);
|
|
|
3301 g_free(time_str);
|
|
|
3302 }
|
|
|
3303
|
|
|
3304 time /= 1000;
|
|
|
3305 length /= 1000;
|
|
|
3306 if (length > 0) {
|
|
|
3307 if (time > length) {
|
|
|
3308 hslider_set_position(mainwin_position, 219);
|
|
|
3309 hslider_set_position(mainwin_sposition, 13);
|
|
|
3310 }
|
|
|
3311 else {
|
|
|
3312 hslider_set_position(mainwin_position, (time * 219) / length);
|
|
|
3313 hslider_set_position(mainwin_sposition,
|
|
|
3314 ((time * 12) / length) + 1);
|
|
|
3315 }
|
|
|
3316 }
|
|
|
3317 else {
|
|
|
3318 hslider_set_position(mainwin_position, 0);
|
|
|
3319 hslider_set_position(mainwin_sposition, 1);
|
|
|
3320 }
|
|
|
3321 }
|
|
|
3322
|
|
|
3323
|
|
|
3324 static gboolean
|
|
|
3325 mainwin_idle_func(gpointer data)
|
|
|
3326 {
|
|
|
3327 static gboolean waiting = FALSE;
|
|
|
3328 static gint count = 0;
|
|
|
3329
|
|
|
3330 gint time;
|
|
|
3331
|
|
|
3332 if (bmp_playback_get_playing()) {
|
|
|
3333 GDK_THREADS_ENTER();
|
|
|
3334 vis_playback_start();
|
|
|
3335 GDK_THREADS_LEAVE();
|
|
|
3336
|
|
|
3337 time = bmp_playback_get_time();
|
|
|
3338
|
|
|
3339 switch (time) {
|
|
|
3340 case -1:
|
|
|
3341 /* no song playing */
|
|
|
3342 waiting = idle_func_change_song(waiting);
|
|
|
3343 break;
|
|
|
3344
|
|
|
3345 case -2:
|
|
|
3346 /* no usable output device */
|
|
|
3347 GDK_THREADS_ENTER();
|
|
|
3348 run_no_output_device_dialog();
|
|
|
3349 mainwin_stop_pushed();
|
|
|
3350 GDK_THREADS_LEAVE();
|
|
|
3351 waiting = FALSE;
|
|
|
3352 break;
|
|
|
3353
|
|
|
3354 default:
|
|
|
3355 /* song playing, all's well */
|
|
|
3356 idle_func_update_song_info(time);
|
|
|
3357 waiting = FALSE;
|
|
|
3358 }
|
|
|
3359 }
|
|
|
3360 else {
|
|
|
3361 GDK_THREADS_ENTER();
|
|
|
3362 vis_playback_stop();
|
|
|
3363 GDK_THREADS_LEAVE();
|
|
|
3364 }
|
|
|
3365
|
|
|
3366 GDK_THREADS_ENTER();
|
|
|
3367
|
|
|
3368 ctrlsocket_check();
|
|
|
3369
|
|
|
3370 draw_main_window(mainwin_force_redraw);
|
|
|
3371
|
|
|
3372 if (!count) {
|
|
|
3373 read_volume(VOLSET_UPDATE);
|
|
|
3374 count = 10;
|
|
|
3375 }
|
|
|
3376 else
|
|
|
3377 count--;
|
|
|
3378
|
|
|
3379 mainwin_force_redraw = FALSE;
|
|
|
3380 draw_playlist_window(FALSE);
|
|
|
3381 draw_equalizer_window(FALSE);
|
|
|
3382
|
|
|
3383 if (mainwin_title_text) {
|
|
|
3384 G_LOCK(mainwin_title);
|
|
|
3385 gtk_window_set_title(GTK_WINDOW(mainwin), mainwin_title_text);
|
|
|
3386 g_free(mainwin_title_text);
|
|
|
3387 mainwin_title_text = NULL;
|
|
|
3388 G_UNLOCK(mainwin_title);
|
|
|
3389
|
|
|
3390 mainwin_set_info_text();
|
|
|
3391 playlistwin_update_list();
|
|
|
3392 }
|
|
|
3393
|
|
|
3394 GDK_THREADS_LEAVE();
|
|
|
3395
|
|
|
3396 return TRUE;
|
|
|
3397 }
|
