1653
|
1 /* Audacious - Cross-platform multimedia player
|
|
2 * Copyright (C) 2005-2006 Audacious development team.
|
|
3 *
|
|
4 * BMP - Cross-platform multimedia player
|
|
5 * Copyright (C) 2003-2004 BMP development team.
|
|
6 *
|
|
7 * Based on XMMS:
|
|
8 * Copyright (C) 1998-2003 XMMS development team.
|
|
9 *
|
|
10 * This program is free software; you can redistribute it and/or modify
|
|
11 * it under the terms of the GNU General Public License as published by
|
|
12 * the Free Software Foundation; either version 2 of the License, or
|
|
13 * (at your option) any later version.
|
|
14 *
|
|
15 * This program is distributed in the hope that it will be useful,
|
|
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
18 * GNU General Public License for more details.
|
|
19 *
|
|
20 * You should have received a copy of the GNU General Public License
|
|
21 * along with this program; if not, write to the Free Software
|
|
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
23 */
|
|
24
|
|
25 #include "ui_playlist.h"
|
|
26
|
|
27 #include <glib.h>
|
|
28 #include <glib/gi18n.h>
|
|
29 #include <gdk/gdk.h>
|
|
30 #include <gdk/gdkkeysyms.h>
|
|
31 #include <gtk/gtk.h>
|
|
32 #include <string.h>
|
|
33
|
|
34 #include "platform/smartinclude.h"
|
|
35
|
|
36 #include <unistd.h>
|
|
37 #include <errno.h>
|
|
38
|
|
39 #include "libaudacious/util.h"
|
|
40
|
|
41 #include "dnd.h"
|
|
42 #include "dock.h"
|
|
43 #include "equalizer.h"
|
|
44 #include "hints.h"
|
|
45 #include "input.h"
|
|
46 #include "main.h"
|
|
47 #include "mainwin.h"
|
|
48 #include "playback.h"
|
|
49 #include "playlist.h"
|
|
50 #include "playlist_container.h"
|
|
51 #include "util.h"
|
|
52
|
|
53 #include "pixmaps.h"
|
|
54 #include "images/audacious_playlist.xpm"
|
|
55
|
|
56
|
|
57 #define ITEM_SEPARATOR {"/-", NULL, NULL, 0, "<Separator>", NULL}
|
|
58
|
|
59
|
|
60 enum {
|
|
61 ADD_URL, ADD_DIR, ADD_FILES,
|
|
62 SUB_MISC, SUB_ALL, SUB_CROP, SUB_SELECTED,
|
|
63 SUB_DUPLICATE_BYTITLE, SUB_DUPLICATE_BYFILENAME, SUB_DUPLICATE_BYPATH,
|
|
64 SEL_INV, SEL_ZERO, SEL_ALL,
|
|
65 MISC_SORT, MISC_FILEINFO, MISC_MISCOPTS,
|
|
66 PLIST_NEW, PLIST_SAVE_AS, PLIST_LOAD,
|
|
67 SEL_LOOKUP, CLOSE_PL_WINDOW, MOVE_UP, PLIST_SAVE,
|
|
68 MISC_QUEUE, PLIST_CQUEUE, PLIST_JTF, PLIST_JTT,
|
|
69 PLAYLISTWIN_REMOVE_DEAD_FILES,
|
|
70 PLAYLISTWIN_REFRESH, PLIST_DEFAULTSAVE, MISC_FILEPOPUP
|
|
71 };
|
|
72
|
|
73 enum {
|
|
74 PLAYLISTWIN_SORT_BYTITLE, PLAYLISTWIN_SORT_BYFILENAME,
|
|
75 PLAYLISTWIN_SORT_BYPATH, PLAYLISTWIN_SORT_BYDATE,
|
|
76 PLAYLISTWIN_SORT_BYARTIST, PLAYLISTWIN_SORT_SEL_BYARTIST,
|
|
77 PLAYLISTWIN_SORT_SEL_BYTITLE, PLAYLISTWIN_SORT_SEL_BYFILENAME,
|
|
78 PLAYLISTWIN_SORT_SEL_BYPATH, PLAYLISTWIN_SORT_SEL_BYDATE,
|
|
79 PLAYLISTWIN_SORT_RANDOMIZE, PLAYLISTWIN_SORT_REVERSE,
|
|
80 PLAYLISTWIN_SORT_BYTRACK, PLAYLISTWIN_SORT_SEL_BYTRACK,
|
|
81 PLAYLISTWIN_SORT_BYPLAYLIST, PLAYLISTWIN_SORT_SEL_BYPLAYLIST
|
|
82 };
|
|
83
|
|
84 GtkWidget *playlistwin;
|
|
85
|
|
86 PlayList_List *playlistwin_list = NULL;
|
|
87 PButton *playlistwin_shade, *playlistwin_close;
|
|
88
|
|
89 static gboolean playlistwin_resizing = FALSE;
|
|
90
|
|
91 static GtkItemFactory *playlistwin_popup_menu;
|
|
92 static GtkItemFactory *pladd_menu, *pldel_menu;
|
|
93 static GtkItemFactory *plsel_menu, *plsort_menu;
|
|
94 static GtkItemFactory *pllist_menu;
|
|
95
|
|
96 static GdkPixmap *playlistwin_bg;
|
|
97 static GdkBitmap *playlistwin_mask = NULL;
|
|
98 static GdkGC *playlistwin_gc;
|
|
99
|
|
100 static GtkAccelGroup *playlistwin_accel;
|
|
101
|
|
102 static gboolean playlistwin_hint_flag = FALSE;
|
|
103
|
|
104 static PlaylistSlider *playlistwin_slider = NULL;
|
|
105 static TextBox *playlistwin_time_min, *playlistwin_time_sec;
|
|
106 static TextBox *playlistwin_info, *playlistwin_sinfo;
|
|
107 static SButton *playlistwin_srew, *playlistwin_splay;
|
|
108 static SButton *playlistwin_spause, *playlistwin_sstop;
|
|
109 static SButton *playlistwin_sfwd, *playlistwin_seject;
|
|
110 static SButton *playlistwin_sscroll_up, *playlistwin_sscroll_down;
|
|
111
|
|
112 static GList *playlistwin_wlist = NULL;
|
|
113
|
|
114 static void plsort_menu_callback(gpointer cb_data, guint action,
|
|
115 GtkWidget * w);
|
|
116 static void playlistwin_sub_menu_callback(gpointer cb_data, guint action,
|
|
117 GtkWidget * w);
|
|
118 static void playlistwin_popup_menu_callback(gpointer cb_data, guint action,
|
|
119 GtkWidget * w);
|
|
120
|
|
121 static GtkItemFactoryEntry playlistwin_popup_menu_entries[] = {
|
|
122 {N_("/View Track Details"), NULL,
|
|
123 playlistwin_popup_menu_callback,
|
|
124 MISC_FILEINFO, "<ImageItem>", my_pixbuf},
|
|
125
|
|
126 {N_("/Show Popup Info"), NULL,
|
|
127 playlistwin_popup_menu_callback,
|
|
128 MISC_FILEPOPUP, "<ToggleItem>", NULL},
|
|
129
|
|
130 ITEM_SEPARATOR,
|
|
131
|
|
132 {N_("/Remove Selected"), "Delete",
|
|
133 playlistwin_sub_menu_callback,
|
|
134 SUB_SELECTED, "<StockItem>", GTK_STOCK_REMOVE},
|
|
135
|
|
136 {N_("/Remove Unselected"), NULL,
|
|
137 playlistwin_sub_menu_callback,
|
|
138 SUB_CROP, "<StockItem>", GTK_STOCK_REMOVE},
|
|
139
|
|
140 {N_("/Remove All"), NULL,
|
|
141 playlistwin_sub_menu_callback,
|
|
142 SUB_ALL, "<StockItem>", GTK_STOCK_CLEAR},
|
|
143
|
|
144 ITEM_SEPARATOR,
|
|
145
|
|
146 {N_("/Queue Toggle"), "q",
|
|
147 playlistwin_popup_menu_callback,
|
|
148 MISC_QUEUE, "<ImageItem>", queuetoggle_pixbuf},
|
|
149 };
|
|
150
|
|
151 static GtkItemFactoryEntry pladd_menu_entries[] = {
|
|
152 {N_("/Add CD..."), "<shift>c",
|
|
153 mainwin_general_menu_callback,
|
|
154 MAINWIN_GENERAL_ADDCD, "<StockItem>", GTK_STOCK_CDROM},
|
|
155
|
|
156 {N_("/Add Internet Address..."), "<control>h",
|
|
157 mainwin_general_menu_callback,
|
|
158 MAINWIN_GENERAL_PLAYLOCATION, "<StockItem>", GTK_STOCK_NETWORK},
|
|
159
|
|
160 {N_("/Add Files..."), "f",
|
|
161 mainwin_general_menu_callback,
|
|
162 MAINWIN_GENERAL_PLAYFILE, "<StockItem>", GTK_STOCK_ADD},
|
|
163 };
|
|
164
|
|
165 static GtkItemFactoryEntry pldel_menu_entries[] = {
|
|
166 {N_("/Clear Queue"), "<shift>Q",
|
|
167 playlistwin_popup_menu_callback,
|
|
168 PLIST_CQUEUE, "<StockItem>", GTK_STOCK_CANCEL},
|
|
169
|
|
170 ITEM_SEPARATOR,
|
|
171
|
|
172 {N_("/Remove Unavailable Files"), NULL,
|
|
173 playlistwin_sub_menu_callback,
|
|
174 PLAYLISTWIN_REMOVE_DEAD_FILES, "<ImageItem>", removeunavail_pixbuf},
|
|
175
|
|
176 {N_("/Remove Duplicates"), NULL, NULL, 0, "<Branch>", NULL},
|
|
177 {N_("/Remove Duplicates/By Title"), NULL,
|
|
178 playlistwin_sub_menu_callback,
|
|
179 SUB_DUPLICATE_BYTITLE, "<ImageItem>", removedups_pixbuf},
|
|
180 {N_("/Remove Duplicates/By Filename"), NULL,
|
|
181 playlistwin_sub_menu_callback,
|
|
182 SUB_DUPLICATE_BYFILENAME, "<ImageItem>", removedups_pixbuf},
|
|
183 {N_("/Remove Duplicates/By Path + Filename"), NULL,
|
|
184 playlistwin_sub_menu_callback,
|
|
185 SUB_DUPLICATE_BYPATH, "<ImageItem>", removedups_pixbuf},
|
|
186
|
|
187 ITEM_SEPARATOR,
|
|
188
|
|
189 {N_("/Remove All"), NULL,
|
|
190 playlistwin_sub_menu_callback,
|
|
191 SUB_ALL, "<StockItem>", GTK_STOCK_CLEAR},
|
|
192
|
|
193 {N_("/Remove Unselected"), NULL,
|
|
194 playlistwin_sub_menu_callback,
|
|
195 SUB_CROP, "<StockItem>", GTK_STOCK_REMOVE},
|
|
196
|
|
197 {N_("/Remove Selected"), "Delete",
|
|
198 playlistwin_sub_menu_callback,
|
|
199 SUB_SELECTED, "<StockItem>", GTK_STOCK_REMOVE}
|
|
200 };
|
|
201
|
|
202 static GtkItemFactoryEntry pllist_menu_entries[] = {
|
|
203 {N_("/New List"), "<shift>N",
|
|
204 playlistwin_sub_menu_callback,
|
|
205 PLIST_NEW, "<StockItem>", GTK_STOCK_NEW},
|
|
206
|
|
207 ITEM_SEPARATOR,
|
|
208
|
|
209 {N_("/Load List"), "o",
|
|
210 playlistwin_sub_menu_callback,
|
|
211 PLIST_LOAD, "<StockItem>", GTK_STOCK_OPEN},
|
|
212
|
|
213 {N_("/Save List"), "<shift>S",
|
|
214 playlistwin_sub_menu_callback,
|
|
215 PLIST_SAVE, "<StockItem>", GTK_STOCK_SAVE},
|
|
216
|
|
217 {N_("/Save Default List"), "<alt>S",
|
|
218 playlistwin_sub_menu_callback,
|
|
219 PLIST_DEFAULTSAVE, "<StockItem>", GTK_STOCK_SAVE},
|
|
220
|
|
221 ITEM_SEPARATOR,
|
|
222
|
|
223 {N_("/Update View"), "F5",
|
|
224 playlistwin_sub_menu_callback,
|
|
225 PLAYLISTWIN_REFRESH, "<StockItem>", GTK_STOCK_REFRESH}
|
|
226 };
|
|
227
|
|
228 static GtkItemFactoryEntry plsel_menu_entries[] = {
|
|
229 {N_("/Invert Selection"), NULL,
|
|
230 playlistwin_sub_menu_callback,
|
|
231 SEL_INV, "<ImageItem>", selectinvert_pixbuf},
|
|
232
|
|
233 ITEM_SEPARATOR,
|
|
234
|
|
235 {N_("/Select None"),"<Ctrl><Shift>A",
|
|
236 playlistwin_sub_menu_callback,
|
|
237 SEL_ZERO, "<ImageItem>", selectnone_pixbuf},
|
|
238
|
|
239 {N_("/Select All"), "<Ctrl>A",
|
|
240 playlistwin_sub_menu_callback,
|
|
241 SEL_ALL, "<ImageItem>", selectall_pixbuf},
|
|
242 };
|
|
243
|
|
244 static GtkItemFactoryEntry plsort_menu_entries[] = {
|
|
245 {N_("/Randomize List"), NULL, plsort_menu_callback,
|
|
246 PLAYLISTWIN_SORT_RANDOMIZE, "<ImageItem>", randomizepl_pixbuf},
|
|
247 {N_("/Reverse List"), NULL, plsort_menu_callback,
|
|
248 PLAYLISTWIN_SORT_REVERSE, "<ImageItem>", invertpl_pixbuf},
|
|
249 ITEM_SEPARATOR,
|
|
250 {N_("/Sort List"), NULL, NULL, 0, "<Branch>", NULL},
|
|
251 {N_("/Sort List/By Title"), NULL, plsort_menu_callback,
|
|
252 PLAYLISTWIN_SORT_BYTITLE, "<ImageItem>", sortbytitle_pixbuf},
|
|
253 {N_("/Sort List/By Artist"), NULL, plsort_menu_callback,
|
|
254 PLAYLISTWIN_SORT_BYARTIST, "<ImageItem>", sortbytitle_pixbuf},
|
|
255 {N_("/Sort List/By Filename"), NULL, plsort_menu_callback,
|
|
256 PLAYLISTWIN_SORT_BYFILENAME, "<ImageItem>", sortbyfilename_pixbuf},
|
|
257 {N_("/Sort List/By Path + Filename"), NULL, plsort_menu_callback,
|
|
258 PLAYLISTWIN_SORT_BYPATH, "<ImageItem>", sortbypathfile_pixbuf},
|
|
259 {N_("/Sort List/By Date"), NULL, plsort_menu_callback,
|
|
260 PLAYLISTWIN_SORT_BYDATE, "<ImageItem>", sortbydate_pixbuf},
|
|
261 {N_("/Sort List/By Track Number"), NULL, plsort_menu_callback,
|
|
262 PLAYLISTWIN_SORT_BYTRACK, "<ImageItem>", sortbytitle_pixbuf},
|
|
263 {N_("/Sort List/By Playlist Entry"), NULL, plsort_menu_callback,
|
|
264 PLAYLISTWIN_SORT_BYPLAYLIST, "<ImageItem>", sortbytitle_pixbuf},
|
|
265 {N_("/Sort Selection"), NULL, NULL, 0, "<Branch>", NULL},
|
|
266 {N_("/Sort Selection/By Title"), NULL, plsort_menu_callback,
|
|
267 PLAYLISTWIN_SORT_SEL_BYTITLE, "<ImageItem>", sortbytitle_pixbuf},
|
|
268 {N_("/Sort Selection/By Artist"), NULL, plsort_menu_callback,
|
|
269 PLAYLISTWIN_SORT_SEL_BYARTIST, "<ImageItem>", sortbytitle_pixbuf},
|
|
270 {N_("/Sort Selection/By Filename"), NULL, plsort_menu_callback,
|
|
271 PLAYLISTWIN_SORT_SEL_BYFILENAME, "<ImageItem>", sortbyfilename_pixbuf},
|
|
272 {N_("/Sort Selection/By Path + Filename"), NULL, plsort_menu_callback,
|
|
273 PLAYLISTWIN_SORT_SEL_BYPATH, "<ImageItem>", sortbypathfile_pixbuf},
|
|
274 {N_("/Sort Selection/By Date"), NULL, plsort_menu_callback,
|
|
275 PLAYLISTWIN_SORT_SEL_BYDATE, "<ImageItem>", sortbydate_pixbuf},
|
|
276 {N_("/Sort Selection/By Track Number"), NULL, plsort_menu_callback,
|
|
277 PLAYLISTWIN_SORT_SEL_BYTRACK, "<ImageItem>", sortbytitle_pixbuf},
|
|
278 {N_("/Sort Selection/By Playlist Entry"), NULL, plsort_menu_callback,
|
|
279 PLAYLISTWIN_SORT_SEL_BYPLAYLIST, "<ImageItem>", sortbytitle_pixbuf}
|
|
280 };
|
|
281
|
|
282
|
|
283 static void playlistwin_draw_frame(void);
|
|
284
|
|
285
|
|
286 gboolean
|
|
287 playlistwin_is_shaded(void)
|
|
288 {
|
|
289 return cfg.playlist_shaded;
|
|
290 }
|
|
291
|
|
292 gint
|
|
293 playlistwin_get_width(void)
|
|
294 {
|
|
295 cfg.playlist_width /= PLAYLISTWIN_WIDTH_SNAP;
|
|
296 cfg.playlist_width *= PLAYLISTWIN_WIDTH_SNAP;
|
|
297 return cfg.playlist_width;
|
|
298 }
|
|
299
|
|
300 gint
|
|
301 playlistwin_get_height_unshaded(void)
|
|
302 {
|
|
303 cfg.playlist_height /= PLAYLISTWIN_HEIGHT_SNAP;
|
|
304 cfg.playlist_height *= PLAYLISTWIN_HEIGHT_SNAP;
|
|
305 gint height = cfg.playlist_height;
|
|
306 return height;
|
|
307 }
|
|
308
|
|
309 gint
|
|
310 playlistwin_get_height_shaded(void)
|
|
311 {
|
|
312 return PLAYLISTWIN_SHADED_HEIGHT;
|
|
313 }
|
|
314
|
|
315 gint
|
|
316 playlistwin_get_height(void)
|
|
317 {
|
|
318 if (playlistwin_is_shaded())
|
|
319 return playlistwin_get_height_shaded();
|
|
320 else
|
|
321 return playlistwin_get_height_unshaded();
|
|
322 }
|
|
323
|
|
324 void
|
|
325 playlistwin_get_size(gint * width, gint * height)
|
|
326 {
|
|
327 if (width)
|
|
328 *width = playlistwin_get_width();
|
|
329
|
|
330 if (height)
|
|
331 *height = playlistwin_get_height();
|
|
332 }
|
|
333
|
|
334 static void
|
|
335 playlistwin_update_info(void)
|
|
336 {
|
|
337 gchar *text, *sel_text, *tot_text;
|
|
338 gulong selection, total;
|
|
339 gboolean selection_more, total_more;
|
|
340
|
|
341 playlist_get_total_time(&total, &selection, &total_more, &selection_more);
|
|
342
|
|
343 if (selection > 0 || (selection == 0 && !selection_more)) {
|
|
344 if (selection > 3600)
|
|
345 sel_text =
|
|
346 g_strdup_printf("%lu:%-2.2lu:%-2.2lu%s", selection / 3600,
|
|
347 (selection / 60) % 60, selection % 60,
|
|
348 (selection_more ? "+" : ""));
|
|
349 else
|
|
350 sel_text =
|
|
351 g_strdup_printf("%lu:%-2.2lu%s", selection / 60,
|
|
352 selection % 60, (selection_more ? "+" : ""));
|
|
353 }
|
|
354 else
|
|
355 sel_text = g_strdup("?");
|
|
356 if (total > 0 || (total == 0 && !total_more)) {
|
|
357 if (total > 3600)
|
|
358 tot_text =
|
|
359 g_strdup_printf("%lu:%-2.2lu:%-2.2lu%s", total / 3600,
|
|
360 (total / 60) % 60, total % 60,
|
|
361 total_more ? "+" : "");
|
|
362 else
|
|
363 tot_text =
|
|
364 g_strdup_printf("%lu:%-2.2lu%s", total / 60, total % 60,
|
|
365 total_more ? "+" : "");
|
|
366 }
|
|
367 else
|
|
368 tot_text = g_strdup("?");
|
|
369 text = g_strconcat(sel_text, "/", tot_text, NULL);
|
|
370 textbox_set_text(playlistwin_info, text);
|
|
371 g_free(text);
|
|
372 g_free(tot_text);
|
|
373 g_free(sel_text);
|
|
374 }
|
|
375
|
|
376 static void
|
|
377 playlistwin_update_sinfo(void)
|
|
378 {
|
|
379 gchar *posstr, *timestr, *title, *info, *dots;
|
|
380 gint pos, time;
|
|
381 guint max_len;
|
|
382
|
|
383 pos = playlist_get_position();
|
|
384 title = playlist_get_songtitle(pos);
|
|
385 time = playlist_get_songtime(pos);
|
|
386
|
|
387 if (!title) {
|
|
388 textbox_set_text(playlistwin_sinfo, "");
|
|
389 return;
|
|
390 }
|
|
391
|
|
392 if (cfg.show_numbers_in_pl)
|
|
393 posstr = g_strdup_printf("%d. ", pos + 1);
|
|
394 else
|
|
395 posstr = g_strdup("");
|
|
396
|
|
397 max_len = (playlistwin_get_width() - 35) / 5 - strlen(posstr);
|
|
398
|
|
399 if (time != -1) {
|
|
400 timestr = g_strdup_printf(" %d:%-2.2d", time / 60000,
|
|
401 (time / 1000) % 60);
|
|
402 max_len -= strlen(timestr);
|
|
403 }
|
|
404 else
|
|
405 timestr = g_strdup("");
|
|
406
|
|
407 convert_title_text(title);
|
|
408
|
|
409 if (strlen(title) > max_len) {
|
|
410 max_len -= 1;
|
|
411 dots = "\r";
|
|
412 /* textbox.c interprets \r as the ellipsis character, as there
|
|
413 is none in ASCII. */
|
|
414 }
|
|
415 else
|
|
416 dots = "";
|
|
417
|
|
418 info = g_strdup_printf("%s%-*.*s%s%s", posstr, max_len, max_len,
|
|
419 title, dots, timestr);
|
|
420 g_free(posstr);
|
|
421 g_free(title);
|
|
422 g_free(timestr);
|
|
423
|
|
424 textbox_set_text(playlistwin_sinfo, info);
|
|
425 g_free(info);
|
|
426 }
|
|
427
|
|
428 gboolean
|
|
429 playlistwin_item_visible(gint index)
|
|
430 {
|
|
431 if (index >= playlistwin_list->pl_first
|
|
432 && index <
|
|
433 (playlistwin_list->pl_first + playlistwin_list->pl_num_visible))
|
|
434 return TRUE;
|
|
435 return FALSE;
|
|
436 }
|
|
437
|
|
438 gint
|
|
439 playlistwin_get_toprow(void)
|
|
440 {
|
|
441 if (playlistwin_list)
|
|
442 return (playlistwin_list->pl_first);
|
|
443 return (-1);
|
|
444 }
|
|
445
|
|
446 void
|
|
447 playlistwin_set_toprow(gint toprow)
|
|
448 {
|
|
449 if (playlistwin_list)
|
|
450 playlistwin_list->pl_first = toprow;
|
|
451 playlistwin_update_list();
|
|
452 }
|
|
453
|
|
454 void
|
|
455 playlistwin_update_list(void)
|
|
456 {
|
|
457 g_return_if_fail(playlistwin_list != NULL);
|
|
458
|
|
459 widget_draw(WIDGET(playlistwin_list));
|
|
460 widget_draw(WIDGET(playlistwin_slider));
|
|
461 playlistwin_update_info();
|
|
462 playlistwin_update_sinfo();
|
|
463 /* mainwin_update_jtf(); */
|
|
464 }
|
|
465
|
|
466 #if 0
|
|
467 static void
|
|
468 playlistwin_redraw_list(void)
|
|
469 {
|
|
470 g_return_if_fail(playlistwin_list != NULL);
|
|
471
|
|
472 draw_widget(playlistwin_list);
|
|
473 draw_widget(playlistwin_slider);
|
|
474 }
|
|
475 #endif
|
|
476
|
|
477 static void
|
|
478 playlistwin_set_mask(void)
|
|
479 {
|
|
480 GdkGC *gc;
|
|
481 GdkColor pattern;
|
|
482
|
|
483 if (playlistwin_mask)
|
|
484 g_object_unref(playlistwin_mask);
|
|
485
|
|
486 playlistwin_mask =
|
|
487 gdk_pixmap_new(playlistwin->window, playlistwin_get_width(),
|
|
488 playlistwin_get_height(), 1);
|
|
489 gc = gdk_gc_new(playlistwin_mask);
|
|
490 pattern.pixel = 1;
|
|
491 gdk_gc_set_foreground(gc, &pattern);
|
|
492 gdk_draw_rectangle(playlistwin_mask, gc, TRUE, 0, 0,
|
|
493 playlistwin_get_width(), playlistwin_get_height());
|
|
494 gdk_gc_destroy(gc);
|
|
495
|
|
496 gtk_widget_shape_combine_mask(playlistwin, playlistwin_mask, 0, 0);
|
|
497 }
|
|
498
|
|
499 static void
|
|
500 playlistwin_set_geometry_hints(gboolean shaded)
|
|
501 {
|
|
502 GdkGeometry geometry;
|
|
503 GdkWindowHints mask;
|
|
504
|
|
505 geometry.min_width = PLAYLISTWIN_MIN_WIDTH;
|
|
506 geometry.max_width = G_MAXUINT16;
|
|
507
|
|
508 geometry.width_inc = PLAYLISTWIN_WIDTH_SNAP;
|
|
509 geometry.height_inc = PLAYLISTWIN_HEIGHT_SNAP;
|
|
510
|
|
511 if (shaded) {
|
|
512 geometry.min_height = PLAYLISTWIN_SHADED_HEIGHT;
|
|
513 geometry.max_height = PLAYLISTWIN_SHADED_HEIGHT;
|
|
514 geometry.base_height = PLAYLISTWIN_SHADED_HEIGHT;
|
|
515 }
|
|
516 else {
|
|
517 geometry.min_height = PLAYLISTWIN_MIN_HEIGHT;
|
|
518 geometry.max_height = G_MAXUINT16;
|
|
519 }
|
|
520
|
|
521 mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE | GDK_HINT_RESIZE_INC;
|
|
522
|
|
523 gtk_window_set_geometry_hints(GTK_WINDOW(playlistwin),
|
|
524 playlistwin, &geometry, mask);
|
|
525 }
|
|
526
|
|
527 void
|
|
528 playlistwin_set_shade(gboolean shaded)
|
|
529 {
|
|
530 cfg.playlist_shaded = shaded;
|
|
531
|
|
532 if (shaded) {
|
|
533 widget_show(WIDGET(playlistwin_sinfo));
|
|
534 playlistwin_shade->pb_nx = 128;
|
|
535 playlistwin_shade->pb_ny = 45;
|
|
536 playlistwin_shade->pb_px = 150;
|
|
537 playlistwin_shade->pb_py = 42;
|
|
538 playlistwin_close->pb_nx = 138;
|
|
539 playlistwin_close->pb_ny = 45;
|
|
540 }
|
|
541 else {
|
|
542 widget_hide(WIDGET(playlistwin_sinfo));
|
|
543 playlistwin_shade->pb_nx = 157;
|
|
544 playlistwin_shade->pb_ny = 3;
|
|
545 playlistwin_shade->pb_px = 62;
|
|
546 playlistwin_shade->pb_py = 42;
|
|
547 playlistwin_close->pb_nx = 167;
|
|
548 playlistwin_close->pb_ny = 3;
|
|
549 }
|
|
550
|
|
551 dock_shade(dock_window_list, GTK_WINDOW(playlistwin),
|
|
552 playlistwin_get_height());
|
|
553
|
|
554 playlistwin_set_geometry_hints(cfg.playlist_shaded);
|
|
555
|
|
556 gtk_window_resize(GTK_WINDOW(playlistwin),
|
|
557 playlistwin_get_width(),
|
|
558 playlistwin_get_height());
|
|
559
|
|
560 playlistwin_set_mask();
|
|
561
|
|
562 widget_draw(WIDGET(playlistwin_list));
|
|
563 widget_draw(WIDGET(playlistwin_slider));
|
|
564
|
|
565 draw_playlist_window(TRUE);
|
|
566 }
|
|
567
|
|
568 static void
|
|
569 playlistwin_set_shade_menu(gboolean shaded)
|
|
570 {
|
|
571 GtkWidget *item;
|
|
572
|
|
573 item = gtk_item_factory_get_widget(mainwin_view_menu,
|
|
574 "/Roll up Playlist Editor");
|
|
575 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), shaded);
|
|
576
|
|
577 playlistwin_set_shade(shaded);
|
|
578 }
|
|
579
|
|
580 void
|
|
581 playlistwin_shade_toggle(void)
|
|
582 {
|
|
583 playlistwin_set_shade_menu(!cfg.playlist_shaded);
|
|
584 }
|
|
585
|
|
586 static void
|
|
587 playlistwin_release(GtkWidget * widget,
|
|
588 GdkEventButton * event,
|
|
589 gpointer callback_data)
|
|
590 {
|
|
591 if (event->button == 3)
|
|
592 return;
|
|
593
|
|
594 gdk_pointer_ungrab(GDK_CURRENT_TIME);
|
|
595 playlistwin_resizing = FALSE;
|
|
596 gdk_flush();
|
|
597
|
|
598 if (dock_is_moving(GTK_WINDOW(playlistwin)))
|
|
599 {
|
|
600 dock_move_release(GTK_WINDOW(playlistwin));
|
|
601
|
|
602 if (cfg.playlist_transparent)
|
|
603 playlistwin_update_list();
|
|
604 }
|
|
605 else
|
|
606 {
|
|
607 handle_release_cb(playlistwin_wlist, widget, event);
|
|
608 draw_playlist_window(FALSE);
|
|
609 }
|
|
610 }
|
|
611
|
|
612 void
|
|
613 playlistwin_scroll(gint num)
|
|
614 {
|
|
615 playlistwin_list->pl_first += num;
|
|
616 playlistwin_update_list();
|
|
617 }
|
|
618
|
|
619 void
|
|
620 playlistwin_scroll_up_pushed(void)
|
|
621 {
|
|
622 playlistwin_list->pl_first -= 3;
|
|
623 playlistwin_update_list();
|
|
624 }
|
|
625
|
|
626 void
|
|
627 playlistwin_scroll_down_pushed(void)
|
|
628 {
|
|
629 playlistwin_list->pl_first += 3;
|
|
630 playlistwin_update_list();
|
|
631 }
|
|
632
|
|
633 static void
|
|
634 playlistwin_select_all(void)
|
|
635 {
|
|
636 playlist_select_all(TRUE);
|
|
637 playlistwin_list->pl_prev_selected = 0;
|
|
638 playlistwin_list->pl_prev_min = 0;
|
|
639 playlistwin_list->pl_prev_max = playlist_get_length() - 1;
|
|
640 playlistwin_update_list();
|
|
641 }
|
|
642
|
|
643 static void
|
|
644 playlistwin_select_none(void)
|
|
645 {
|
|
646 playlist_select_all(FALSE);
|
|
647 playlistwin_list->pl_prev_selected = -1;
|
|
648 playlistwin_list->pl_prev_min = -1;
|
|
649 playlistwin_update_list();
|
|
650 }
|
|
651
|
|
652 static void
|
|
653 playlistwin_inverse_selection(void)
|
|
654 {
|
|
655 playlist_select_invert_all();
|
|
656 playlistwin_list->pl_prev_selected = -1;
|
|
657 playlistwin_list->pl_prev_min = -1;
|
|
658 playlistwin_update_list();
|
|
659 }
|
|
660
|
|
661 static void
|
|
662 playlistwin_resize(gint width, gint height)
|
|
663 {
|
|
664 gboolean redraw;
|
|
665
|
|
666 g_return_if_fail(width > 0 && height > 0);
|
|
667
|
|
668 cfg.playlist_width = width;
|
|
669
|
|
670 if (!cfg.playlist_shaded)
|
|
671 cfg.playlist_height = height;
|
|
672 else
|
|
673 height = cfg.playlist_height;
|
|
674
|
|
675 /* FIXME: why the fsck are we doing this manually? */
|
|
676 /* adjust widget positions and sizes */
|
|
677
|
|
678 widget_resize(WIDGET(playlistwin_list), width - 31, height - 58);
|
|
679
|
|
680 widget_move(WIDGET(playlistwin_slider), width - 15, 20);
|
|
681 widget_resize(WIDGET(playlistwin_slider), 8, height - 58);
|
|
682
|
|
683 widget_resize(WIDGET(playlistwin_sinfo), width - 35, 14);
|
|
684 playlistwin_update_sinfo();
|
|
685
|
|
686 widget_move(WIDGET(playlistwin_shade), width - 21, 3);
|
|
687 widget_move(WIDGET(playlistwin_close), width - 11, 3);
|
|
688 widget_move(WIDGET(playlistwin_time_min), width - 82, height - 15);
|
|
689 widget_move(WIDGET(playlistwin_time_sec), width - 64, height - 15);
|
|
690 widget_move(WIDGET(playlistwin_info), width - 143, height - 28);
|
|
691 widget_move(WIDGET(playlistwin_srew), width - 144, height - 16);
|
|
692 widget_move(WIDGET(playlistwin_splay), width - 138, height - 16);
|
|
693 widget_move(WIDGET(playlistwin_spause), width - 128, height - 16);
|
|
694 widget_move(WIDGET(playlistwin_sstop), width - 118, height - 16);
|
|
695 widget_move(WIDGET(playlistwin_sfwd), width - 109, height - 16);
|
|
696 widget_move(WIDGET(playlistwin_seject), width - 100, height - 16);
|
|
697 widget_move(WIDGET(playlistwin_sscroll_up), width - 14, height - 35);
|
|
698 widget_move(WIDGET(playlistwin_sscroll_down), width - 14, height - 30);
|
|
699
|
|
700 g_object_unref(playlistwin_bg);
|
|
701 playlistwin_bg = gdk_pixmap_new(playlistwin->window, width, height, -1);
|
|
702 playlistwin_set_mask();
|
|
703
|
|
704 widget_list_lock(playlistwin_wlist);
|
|
705
|
|
706 widget_list_change_pixmap(playlistwin_wlist, playlistwin_bg);
|
|
707 playlistwin_draw_frame();
|
|
708 widget_list_draw(playlistwin_wlist, &redraw, TRUE);
|
|
709 widget_list_clear_redraw(playlistwin_wlist);
|
|
710
|
|
711 widget_list_unlock(playlistwin_wlist);
|
|
712
|
|
713 gdk_window_set_back_pixmap(playlistwin->window, playlistwin_bg, 0);
|
|
714 gdk_window_clear(playlistwin->window);
|
|
715 }
|
|
716
|
|
717
|
|
718
|
|
719 static void
|
|
720 playlistwin_motion(GtkWidget * widget,
|
|
721 GdkEventMotion * event,
|
|
722 gpointer callback_data)
|
|
723 {
|
|
724 GdkEvent *gevent;
|
|
725
|
|
726 if (dock_is_moving(GTK_WINDOW(playlistwin))) {
|
|
727 dock_move_motion(GTK_WINDOW(playlistwin), event);
|
|
728 }
|
|
729 else {
|
|
730 handle_motion_cb(playlistwin_wlist, widget, event);
|
|
731 draw_playlist_window(FALSE);
|
|
732 }
|
|
733 gdk_flush();
|
|
734
|
|
735 while ((gevent = gdk_event_get()) != NULL) gdk_event_free(gevent);
|
|
736 }
|
|
737
|
|
738 static void
|
|
739 playlistwin_enter(GtkWidget * widget,
|
|
740 GdkEventMotion * event,
|
|
741 gpointer callback_data)
|
|
742 {
|
|
743 playlistwin_list->pl_tooltips = TRUE;
|
|
744 }
|
|
745
|
|
746 static void
|
|
747 playlistwin_leave(GtkWidget * widget,
|
|
748 GdkEventMotion * event,
|
|
749 gpointer callback_data)
|
|
750 {
|
|
751 playlistwin_list->pl_tooltips = FALSE;
|
|
752 }
|
|
753
|
|
754 static void
|
|
755 playlistwin_show_filebrowser(void)
|
|
756 {
|
|
757 util_run_filebrowser(NO_PLAY_BUTTON);
|
|
758 }
|
|
759
|
|
760 #if 0
|
|
761 static void
|
|
762 playlistwin_add_dir_handler(const gchar * dir)
|
|
763 {
|
|
764 g_free(cfg.filesel_path);
|
|
765 cfg.filesel_path = g_strdup(dir);
|
|
766 playlist_add_dir(dir);
|
|
767 }
|
|
768 #endif
|
|
769
|
|
770 static void
|
|
771 playlistwin_fileinfo(void)
|
|
772 {
|
|
773 /* Show the first selected file, or the current file if nothing is
|
|
774 * selected */
|
|
775 GList *list = playlist_get_selected();
|
|
776 if (list) {
|
|
777 playlist_fileinfo(GPOINTER_TO_INT(list->data));
|
|
778 g_list_free(list);
|
|
779 }
|
|
780 else
|
|
781 playlist_fileinfo_current();
|
|
782 }
|
|
783
|
|
784 static void
|
|
785 menu_set_item_sensitive(GtkItemFactory * item_factory,
|
|
786 const gchar * path,
|
|
787 gboolean sensitive)
|
|
788 {
|
|
789 GtkWidget *item = gtk_item_factory_get_widget(item_factory, path);
|
|
790 gtk_widget_set_sensitive(item, sensitive);
|
|
791 }
|
|
792
|
|
793 /* FIXME: broken */
|
|
794 static void
|
|
795 playlistwin_set_sensitive_sortmenu(void)
|
|
796 {
|
|
797 gboolean set = playlist_get_num_selected() > 1;
|
|
798 menu_set_item_sensitive(plsort_menu, "/Sort Selection/By Title", set);
|
|
799 menu_set_item_sensitive(plsort_menu, "/Sort Selection/By Filename", set);
|
|
800 menu_set_item_sensitive(plsort_menu, "/Sort Selection/By Path + Filename", set);
|
|
801 menu_set_item_sensitive(plsort_menu, "/Sort Selection/By Date", set);
|
|
802 }
|
|
803
|
|
804 static void
|
|
805 show_playlist_save_error(GtkWindow * parent,
|
|
806 const gchar * filename)
|
|
807 {
|
|
808 GtkWidget *dialog;
|
|
809
|
|
810 g_return_if_fail(GTK_IS_WINDOW(parent));
|
|
811 g_return_if_fail(filename != NULL);
|
|
812
|
|
813 dialog = gtk_message_dialog_new(GTK_WINDOW(parent),
|
|
814 GTK_DIALOG_DESTROY_WITH_PARENT,
|
|
815 GTK_MESSAGE_ERROR,
|
|
816 GTK_BUTTONS_OK,
|
|
817 _("Error writing playlist \"%s\": %s"),
|
|
818 filename, strerror(errno));
|
|
819
|
|
820 gtk_dialog_run(GTK_DIALOG(dialog));
|
|
821 gtk_widget_destroy(dialog);
|
|
822 }
|
|
823
|
|
824 static gboolean
|
|
825 show_playlist_overwrite_prompt(GtkWindow * parent,
|
|
826 const gchar * filename)
|
|
827 {
|
|
828 GtkWidget *dialog;
|
|
829 gint result;
|
|
830
|
|
831 g_return_val_if_fail(GTK_IS_WINDOW(parent), FALSE);
|
|
832 g_return_val_if_fail(filename != NULL, FALSE);
|
|
833
|
|
834 dialog = gtk_message_dialog_new(GTK_WINDOW(parent),
|
|
835 GTK_DIALOG_DESTROY_WITH_PARENT,
|
|
836 GTK_MESSAGE_QUESTION,
|
|
837 GTK_BUTTONS_YES_NO,
|
|
838 _("%s already exist. Continue?"),
|
|
839 filename);
|
|
840
|
|
841 result = gtk_dialog_run(GTK_DIALOG(dialog));
|
|
842 gtk_widget_destroy(dialog);
|
|
843
|
|
844 return (result == GTK_RESPONSE_YES);
|
|
845 }
|
|
846
|
|
847 static void
|
|
848 show_playlist_save_format_error(GtkWindow * parent,
|
|
849 const gchar * filename)
|
|
850 {
|
|
851 const gchar *markup =
|
|
852 N_("<b><big>Unable to save playlist.</big></b>\n\n"
|
|
853 "Unknown file type for '%s'.\n");
|
|
854
|
|
855 GtkWidget *dialog;
|
|
856
|
|
857 g_return_if_fail(GTK_IS_WINDOW(parent));
|
|
858 g_return_if_fail(filename != NULL);
|
|
859
|
|
860 dialog =
|
|
861 gtk_message_dialog_new_with_markup(GTK_WINDOW(parent),
|
|
862 GTK_DIALOG_DESTROY_WITH_PARENT,
|
|
863 GTK_MESSAGE_ERROR,
|
|
864 GTK_BUTTONS_OK,
|
|
865 _(markup),
|
|
866 filename);
|
|
867 gtk_dialog_run(GTK_DIALOG(dialog));
|
|
868 gtk_widget_destroy(dialog);
|
|
869 }
|
|
870
|
|
871 static void
|
|
872 playlistwin_save_playlist(const gchar * filename)
|
|
873 {
|
|
874 PlaylistContainer *plc;
|
|
875 gchar *ext = strrchr(filename, '.') + 1;
|
|
876
|
|
877 plc = playlist_container_find(ext);
|
|
878 if (plc == NULL) {
|
|
879 show_playlist_save_format_error(GTK_WINDOW(playlistwin), filename);
|
|
880 return;
|
|
881 }
|
|
882
|
|
883 str_replace_in(&cfg.playlist_path, g_path_get_dirname(filename));
|
|
884
|
|
885 if (g_file_test(filename, G_FILE_TEST_IS_REGULAR))
|
|
886 if (!show_playlist_overwrite_prompt(GTK_WINDOW(playlistwin), filename))
|
|
887 return;
|
|
888
|
|
889 if (!playlist_save(filename))
|
|
890 show_playlist_save_error(GTK_WINDOW(playlistwin), filename);
|
|
891 }
|
|
892
|
|
893 #if 0
|
|
894 static void
|
|
895 playlistwin_save_current(void)
|
|
896 {
|
|
897 const gchar *filename;
|
|
898
|
|
899 if (!(filename = playlist_get_current_name()))
|
|
900 return;
|
|
901
|
|
902 playlistwin_save_playlist(filename);
|
|
903 }
|
|
904 #endif
|
|
905
|
|
906 static void
|
|
907 playlistwin_load_playlist(const gchar * filename)
|
|
908 {
|
|
909 g_return_if_fail(filename != NULL);
|
|
910
|
|
911 str_replace_in(&cfg.playlist_path, g_strdup(filename));
|
|
912
|
|
913 playlist_clear();
|
|
914 mainwin_clear_song_info();
|
|
915 mainwin_set_info_text();
|
|
916
|
|
917 playlist_load(filename);
|
|
918 playlist_set_current_name(filename);
|
|
919 }
|
|
920
|
|
921 static gchar *
|
|
922 playlist_file_selection(const gchar * title,
|
|
923 gboolean save,
|
|
924 const gchar * default_filename)
|
|
925 {
|
|
926 GtkWidget *dialog, *button;
|
|
927 gchar *filename;
|
|
928
|
|
929 g_return_val_if_fail(title != NULL, NULL);
|
|
930
|
|
931 dialog = gtk_file_chooser_dialog_new(title, GTK_WINDOW(mainwin),
|
|
932 save ? GTK_FILE_CHOOSER_ACTION_SAVE :
|
|
933 GTK_FILE_CHOOSER_ACTION_OPEN, NULL, NULL);
|
|
934 if (default_filename)
|
|
935 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
|
|
936 default_filename);
|
|
937
|
|
938 button = gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CANCEL,
|
|
939 GTK_RESPONSE_REJECT);
|
|
940 gtk_button_set_use_stock(GTK_BUTTON(button), TRUE);
|
|
941 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
|
|
942
|
|
943 button = gtk_dialog_add_button(GTK_DIALOG(dialog),
|
|
944 save ? GTK_STOCK_SAVE : GTK_STOCK_OPEN,
|
|
945 GTK_RESPONSE_ACCEPT);
|
|
946 gtk_button_set_use_stock(GTK_BUTTON(button), TRUE);
|
|
947 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
|
|
948
|
|
949 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
|
|
950 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
|
|
951 else
|
|
952 filename = NULL;
|
|
953
|
|
954 gtk_widget_destroy(dialog);
|
|
955
|
|
956 return filename;
|
|
957 }
|
|
958
|
|
959 void
|
|
960 playlistwin_select_playlist_to_load(const gchar * default_filename)
|
|
961 {
|
|
962 gchar *filename =
|
|
963 playlist_file_selection(_("Load Playlist"), FALSE, default_filename);
|
|
964
|
|
965 if (filename) {
|
|
966 playlistwin_load_playlist(filename);
|
|
967 g_free(filename);
|
|
968 }
|
|
969 }
|
|
970
|
|
971 static void
|
|
972 playlistwin_select_playlist_to_save(const gchar * default_filename)
|
|
973 {
|
|
974 gchar *filename =
|
|
975 playlist_file_selection(_("Save Playlist"), TRUE, default_filename);
|
|
976
|
|
977 if (filename) {
|
|
978 /* Default to M3U if no filename has extension */
|
|
979
|
|
980 /* NOTE: This doesn't work correctly for hidden files
|
|
981 - descender */
|
|
982 if (!strchr(filename, '.')) {
|
|
983 gchar *tmpstr = filename;
|
|
984 filename = g_strconcat(filename, ".m3u", NULL);
|
|
985 g_free(tmpstr);
|
|
986 }
|
|
987
|
|
988 playlistwin_save_playlist(filename);
|
|
989 g_free(filename);
|
|
990 }
|
|
991 }
|
|
992
|
|
993 static gboolean
|
|
994 inside_sensitive_widgets(gint x, gint y)
|
|
995 {
|
|
996 return (widget_contains(WIDGET(playlistwin_list), x, y) ||
|
|
997 widget_contains(WIDGET(playlistwin_slider), x, y) ||
|
|
998 widget_contains(WIDGET(playlistwin_close), x, y) ||
|
|
999 widget_contains(WIDGET(playlistwin_shade), x, y) ||
|
|
1000 widget_contains(WIDGET(playlistwin_time_min), x, y) ||
|
|
1001 widget_contains(WIDGET(playlistwin_time_sec), x, y) ||
|
|
1002 widget_contains(WIDGET(playlistwin_info), x, y) ||
|
|
1003 widget_contains(WIDGET(playlistwin_srew), x, y) ||
|
|
1004 widget_contains(WIDGET(playlistwin_splay), x, y) ||
|
|
1005 widget_contains(WIDGET(playlistwin_spause), x, y) ||
|
|
1006 widget_contains(WIDGET(playlistwin_sstop), x, y) ||
|
|
1007 widget_contains(WIDGET(playlistwin_sfwd), x, y) ||
|
|
1008 widget_contains(WIDGET(playlistwin_seject), x, y) ||
|
|
1009 widget_contains(WIDGET(playlistwin_sscroll_up), x, y) ||
|
|
1010 widget_contains(WIDGET(playlistwin_sscroll_down), x, y));
|
|
1011 }
|
|
1012
|
|
1013 #define REGION_L(x1,x2,y1,y2) \
|
|
1014 (event->x >= (x1) && event->x < (x2) && \
|
|
1015 event->y >= cfg.playlist_height - (y1) && \
|
|
1016 event->y < cfg.playlist_height - (y2))
|
|
1017
|
|
1018 #define REGION_R(x1,x2,y1,y2) \
|
|
1019 (event->x >= playlistwin_get_width() - (x1) && \
|
|
1020 event->x < playlistwin_get_width() - (x2) && \
|
|
1021 event->y >= cfg.playlist_height - (y1) && \
|
|
1022 event->y < cfg.playlist_height - (y2))
|
|
1023
|
|
1024 static void
|
|
1025 playlistwin_scrolled(GtkWidget * widget,
|
|
1026 GdkEventScroll * event,
|
|
1027 gpointer callback_data)
|
|
1028 {
|
|
1029
|
|
1030 if (event->direction == GDK_SCROLL_DOWN)
|
|
1031 playlistwin_scroll(cfg.scroll_pl_by);
|
|
1032
|
|
1033 if (event->direction == GDK_SCROLL_UP)
|
|
1034 playlistwin_scroll(-cfg.scroll_pl_by);
|
|
1035
|
|
1036 }
|
|
1037
|
|
1038
|
|
1039
|
|
1040
|
|
1041 static gboolean
|
|
1042 playlistwin_press(GtkWidget * widget,
|
|
1043 GdkEventButton * event,
|
|
1044 gpointer callback_data)
|
|
1045 {
|
|
1046 gboolean grab = TRUE;
|
|
1047 gint xpos, ypos;
|
|
1048 GtkWidget *_menu;
|
|
1049 GtkRequisition req;
|
|
1050
|
|
1051 gtk_window_get_position(GTK_WINDOW(playlistwin), &xpos, &ypos);
|
|
1052
|
|
1053 if (event->button == 1 && !cfg.show_wm_decorations &&
|
|
1054 ((!cfg.playlist_shaded &&
|
|
1055 event->x > playlistwin_get_width() - 20 &&
|
|
1056 event->y > cfg.playlist_height - 20) ||
|
|
1057 (cfg.playlist_shaded &&
|
|
1058 event->x >= playlistwin_get_width() - 31 &&
|
|
1059 event->x < playlistwin_get_width() - 22))) {
|
|
1060
|
|
1061 /* NOTE: Workaround for bug #214 */
|
|
1062 if (event->type != GDK_2BUTTON_PRESS &&
|
|
1063 event->type != GDK_3BUTTON_PRESS) {
|
|
1064 /* resize area */
|
|
1065 playlistwin_resizing = TRUE;
|
|
1066 gtk_window_begin_resize_drag(GTK_WINDOW(widget),
|
|
1067 GDK_WINDOW_EDGE_SOUTH_EAST,
|
|
1068 event->button,
|
|
1069 event->x + xpos, event->y + ypos,
|
|
1070 event->time);
|
|
1071 }
|
|
1072 grab = FALSE;
|
|
1073 }
|
|
1074 else if (event->button == 1 && REGION_L(12, 37, 29, 11)) {
|
|
1075 /* ADD button menu */
|
|
1076
|
|
1077 _menu = GTK_WIDGET(pladd_menu->widget);
|
|
1078 if (!GTK_WIDGET_REALIZED(_menu)) gtk_widget_realize(_menu);
|
|
1079 gtk_widget_size_request(_menu, &req);
|
|
1080 gtk_item_factory_popup_with_data(pladd_menu,
|
|
1081 NULL, NULL,
|
|
1082 xpos+12,
|
|
1083 (ypos + playlistwin_get_height()) - 8 - req.height, 1, event->time);
|
|
1084 grab = FALSE;
|
|
1085 }
|
|
1086 else if (event->button == 1 && REGION_L(41, 66, 29, 11)) {
|
|
1087 /* SUB button menu */
|
|
1088 _menu = GTK_WIDGET(pldel_menu->widget);
|
|
1089 if (!GTK_WIDGET_REALIZED(_menu)) gtk_widget_realize(_menu);
|
|
1090 gtk_widget_size_request(_menu, &req);
|
|
1091 gtk_item_factory_popup_with_data(pldel_menu,
|
|
1092 NULL, NULL,
|
|
1093 xpos+40,
|
|
1094 (ypos + playlistwin_get_height()) - 8 - req.height, 1, event->time);
|
|
1095 grab = FALSE;
|
|
1096 }
|
|
1097 else if (event->button == 1 && REGION_L(70, 95, 29, 11)) {
|
|
1098 /* SEL button menu */
|
|
1099 _menu = GTK_WIDGET(plsel_menu->widget);
|
|
1100 if (!GTK_WIDGET_REALIZED(_menu)) gtk_widget_realize(_menu);
|
|
1101 gtk_widget_size_request(_menu, &req);
|
|
1102 gtk_item_factory_popup_with_data(plsel_menu,
|
|
1103 NULL, NULL,
|
|
1104 xpos+68,
|
|
1105 (ypos + playlistwin_get_height()) - 8 - req.height, 1, event->time);
|
|
1106
|
|
1107 grab = FALSE;
|
|
1108 }
|
|
1109 else if (event->button == 1 && REGION_L(99, 124, 29, 11)) {
|
|
1110 /* MISC button menu */
|
|
1111 _menu = GTK_WIDGET(plsort_menu->widget);
|
|
1112 if (!GTK_WIDGET_REALIZED(_menu)) gtk_widget_realize(_menu);
|
|
1113 gtk_widget_size_request(_menu, &req);
|
|
1114 gtk_item_factory_popup_with_data(plsort_menu,
|
|
1115 NULL, NULL,
|
|
1116 xpos+100,
|
|
1117 (ypos + playlistwin_get_height()) - 8 - req.height, 1, event->time);
|
|
1118 grab = FALSE;
|
|
1119 }
|
|
1120 else if (event->button == 1 && REGION_R(46, 23, 29, 11)) {
|
|
1121 /* LIST button menu */
|
|
1122 _menu = GTK_WIDGET(pllist_menu->widget);
|
|
1123 if (!GTK_WIDGET_REALIZED(_menu)) gtk_widget_realize(_menu);
|
|
1124 gtk_widget_size_request(_menu, &req);
|
|
1125 gtk_item_factory_popup_with_data(pllist_menu,
|
|
1126 NULL, NULL,
|
|
1127 xpos + playlistwin_get_width() - req.width - 12,
|
|
1128 (ypos + playlistwin_get_height()) - 8 - req.height, 1, event->time);
|
|
1129 grab = FALSE;
|
|
1130 }
|
|
1131 else if (event->button == 1 && REGION_R(82, 54, 15, 9)) {
|
|
1132 if (cfg.timer_mode == TIMER_ELAPSED)
|
|
1133 cfg.timer_mode = TIMER_REMAINING;
|
|
1134 else
|
|
1135 cfg.timer_mode = TIMER_ELAPSED;
|
|
1136 }
|
|
1137 else if (event->button == 2 && (event->type == GDK_BUTTON_PRESS) &&
|
|
1138 widget_contains(WIDGET(playlistwin_list), event->x, event->y)) {
|
|
1139 gtk_selection_convert(widget, GDK_SELECTION_PRIMARY,
|
|
1140 GDK_TARGET_STRING, event->time);
|
|
1141 }
|
|
1142 else if (event->button == 1 && event->type == GDK_BUTTON_PRESS &&
|
|
1143 !inside_sensitive_widgets(event->x, event->y) && event->y < 14)
|
|
1144 {
|
|
1145 dock_move_press(dock_window_list, GTK_WINDOW(playlistwin), event,
|
|
1146 FALSE);
|
|
1147 gtk_window_present(GTK_WINDOW(playlistwin));
|
|
1148 }
|
|
1149 else if (event->button == 1 && event->type == GDK_2BUTTON_PRESS &&
|
|
1150 !inside_sensitive_widgets(event->x, event->y)
|
|
1151 && event->y < 14) {
|
|
1152 /* double click on title bar */
|
|
1153 playlistwin_shade_toggle();
|
|
1154 if (dock_is_moving(GTK_WINDOW(playlistwin)))
|
|
1155 dock_move_release(GTK_WINDOW(playlistwin));
|
|
1156 return TRUE;
|
|
1157 }
|
|
1158 else if (event->button == 3 &&
|
|
1159 !(widget_contains(WIDGET(playlistwin_list), event->x, event->y) ||
|
|
1160 (event->y >= cfg.playlist_height - 29 &&
|
|
1161 event->y < cfg.playlist_height - 11 &&
|
|
1162 ((event->x >= 12 && event->x < 37) ||
|
|
1163 (event->x >= 41 && event->x < 66) ||
|
|
1164 (event->x >= 70 && event->x < 95) ||
|
|
1165 (event->x >= 99 && event->x < 124) ||
|
|
1166 (event->x >= playlistwin_get_width() - 46 &&
|
|
1167 event->x < playlistwin_get_width() - 23))))) {
|
|
1168 /*
|
|
1169 * Pop up the main menu a few pixels down to avoid
|
|
1170 * anything to be selected initially.
|
|
1171 */
|
|
1172 util_item_factory_popup(mainwin_general_menu, event->x_root,
|
|
1173 event->y_root + 2, 3, event->time);
|
|
1174 grab = FALSE;
|
|
1175 }
|
|
1176 else if (event->button == 3 &&
|
|
1177 widget_contains(WIDGET(playlistwin_list), event->x, event->y)) {
|
|
1178 /* popup menu */
|
|
1179 playlistwin_set_sensitive_sortmenu();
|
|
1180 {
|
|
1181 GtkWidget *item = gtk_item_factory_get_widget(playlistwin_popup_menu, "/Show Popup Info");
|
|
1182 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), cfg.show_filepopup_for_tuple);
|
|
1183 }
|
|
1184 gtk_item_factory_popup(playlistwin_popup_menu,
|
|
1185 event->x_root, event->y_root + 5,
|
|
1186 3, event->time);
|
|
1187 grab = FALSE;
|
|
1188 }
|
|
1189 else {
|
|
1190 handle_press_cb(playlistwin_wlist, widget, event);
|
|
1191 draw_playlist_window(FALSE);
|
|
1192 }
|
|
1193
|
|
1194 if (grab)
|
|
1195 gdk_pointer_grab(playlistwin->window, FALSE,
|
|
1196 GDK_BUTTON_MOTION_MASK | GDK_BUTTON_RELEASE_MASK |
|
|
1197 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
|
|
1198 GDK_BUTTON1_MOTION_MASK, NULL, NULL,
|
|
1199 GDK_CURRENT_TIME);
|
|
1200
|
|
1201 return FALSE;
|
|
1202 }
|
|
1203
|
|
1204 static gboolean
|
|
1205 playlistwin_focus_in(GtkWidget * widget, GdkEvent * event, gpointer data)
|
|
1206 {
|
|
1207 playlistwin_close->pb_allow_draw = TRUE;
|
|
1208 playlistwin_shade->pb_allow_draw = TRUE;
|
|
1209 draw_playlist_window(TRUE);
|
|
1210 return FALSE;
|
|
1211 }
|
|
1212
|
|
1213 static gboolean
|
|
1214 playlistwin_focus_out(GtkWidget * widget,
|
|
1215 GdkEventButton * event, gpointer data)
|
|
1216 {
|
|
1217 playlistwin_close->pb_allow_draw = FALSE;
|
|
1218 playlistwin_shade->pb_allow_draw = FALSE;
|
|
1219 draw_playlist_window(TRUE);
|
|
1220 return FALSE;
|
|
1221 }
|
|
1222
|
|
1223 static gboolean
|
|
1224 playlistwin_configure(GtkWidget * window,
|
|
1225 GdkEventConfigure * event, gpointer data)
|
|
1226 {
|
|
1227 if (!GTK_WIDGET_VISIBLE(window))
|
|
1228 return FALSE;
|
|
1229
|
|
1230 cfg.playlist_x = event->x;
|
|
1231 cfg.playlist_y = event->y;
|
|
1232
|
|
1233 if (playlistwin_resizing) {
|
|
1234 if (event->width != playlistwin_get_width() ||
|
|
1235 event->height != playlistwin_get_height())
|
|
1236 playlistwin_resize(event->width, event->height);
|
|
1237 }
|
|
1238 return TRUE;
|
|
1239 }
|
|
1240
|
|
1241 void
|
|
1242 playlistwin_set_back_pixmap(void)
|
|
1243 {
|
|
1244 gdk_window_set_back_pixmap(playlistwin->window, playlistwin_bg, 0);
|
|
1245 gdk_window_clear(playlistwin->window);
|
|
1246 }
|
|
1247
|
|
1248 static gboolean
|
|
1249 playlistwin_delete(GtkWidget * w, gpointer data)
|
|
1250 {
|
|
1251 playlistwin_hide();
|
|
1252 return TRUE;
|
|
1253 }
|
|
1254
|
|
1255 static void
|
|
1256 playlistwin_keypress_up_down_handler(PlayList_List * pl,
|
|
1257 gboolean up, guint state)
|
|
1258 {
|
|
1259 if ((state & GDK_MOD1_MASK) && (state & GDK_SHIFT_MASK))
|
|
1260 return;
|
|
1261 if (!(state & GDK_MOD1_MASK))
|
|
1262 playlist_select_all(FALSE);
|
|
1263
|
|
1264 if (pl->pl_prev_selected == -1 ||
|
|
1265 (!playlistwin_item_visible(pl->pl_prev_selected) &&
|
|
1266 !(state & GDK_SHIFT_MASK && pl->pl_prev_min != -1))) {
|
|
1267 pl->pl_prev_selected = pl->pl_first;
|
|
1268 }
|
|
1269 else if (state & GDK_SHIFT_MASK) {
|
|
1270 if (pl->pl_prev_min == -1) {
|
|
1271 pl->pl_prev_max = pl->pl_prev_selected;
|
|
1272 pl->pl_prev_min = pl->pl_prev_selected;
|
|
1273 }
|
|
1274 pl->pl_prev_max += (up ? -1 : 1);
|
|
1275 pl->pl_prev_max =
|
|
1276 CLAMP(pl->pl_prev_max, 0, playlist_get_length() - 1);
|
|
1277
|
|
1278 pl->pl_first = MIN(pl->pl_first, pl->pl_prev_max);
|
|
1279 pl->pl_first = MAX(pl->pl_first, pl->pl_prev_max -
|
|
1280 pl->pl_num_visible + 1);
|
|
1281 playlist_select_range(pl->pl_prev_min, pl->pl_prev_max, TRUE);
|
|
1282 return;
|
|
1283 }
|
|
1284 else if (state & GDK_MOD1_MASK) {
|
|
1285 if (up)
|
|
1286 playlist_list_move_up(pl);
|
|
1287 else
|
|
1288 playlist_list_move_down(pl);
|
|
1289 if (pl->pl_prev_min < pl->pl_first)
|
|
1290 pl->pl_first = pl->pl_prev_min;
|
|
1291 else if (pl->pl_prev_max >= (pl->pl_first + pl->pl_num_visible))
|
|
1292 pl->pl_first = pl->pl_prev_max - pl->pl_num_visible + 1;
|
|
1293 return;
|
|
1294 }
|
|
1295 else if (up)
|
|
1296 pl->pl_prev_selected--;
|
|
1297 else
|
|
1298 pl->pl_prev_selected++;
|
|
1299
|
|
1300 pl->pl_prev_selected =
|
|
1301 CLAMP(pl->pl_prev_selected, 0, playlist_get_length() - 1);
|
|
1302
|
|
1303 if (pl->pl_prev_selected < pl->pl_first)
|
|
1304 pl->pl_first--;
|
|
1305 else if (pl->pl_prev_selected >= (pl->pl_first + pl->pl_num_visible))
|
|
1306 pl->pl_first++;
|
|
1307
|
|
1308 playlist_select_range(pl->pl_prev_selected, pl->pl_prev_selected, TRUE);
|
|
1309 pl->pl_prev_min = -1;
|
|
1310
|
|
1311 }
|
|
1312
|
|
1313 /* FIXME: Handle the keys through menu */
|
|
1314
|
|
1315 static gboolean
|
|
1316 playlistwin_keypress(GtkWidget * w, GdkEventKey * event, gpointer data)
|
|
1317 {
|
|
1318 guint keyval;
|
|
1319 gboolean refresh = FALSE;
|
|
1320
|
|
1321 if (cfg.playlist_shaded)
|
|
1322 return FALSE;
|
|
1323
|
|
1324 switch (keyval = event->keyval) {
|
|
1325 case GDK_KP_Up:
|
|
1326 case GDK_KP_Down:
|
|
1327 case GDK_Up:
|
|
1328 case GDK_Down:
|
|
1329 playlistwin_keypress_up_down_handler(playlistwin_list,
|
|
1330 keyval == GDK_Up
|
|
1331 || keyval == GDK_KP_Up,
|
|
1332 event->state);
|
|
1333 refresh = TRUE;
|
|
1334 break;
|
|
1335 case GDK_Page_Up:
|
|
1336 playlistwin_scroll(-playlistwin_list->pl_num_visible);
|
|
1337 refresh = TRUE;
|
|
1338 break;
|
|
1339 case GDK_Page_Down:
|
|
1340 playlistwin_scroll(playlistwin_list->pl_num_visible);
|
|
1341 refresh = TRUE;
|
|
1342 break;
|
|
1343 case GDK_Home:
|
|
1344 playlistwin_list->pl_first = 0;
|
|
1345 refresh = TRUE;
|
|
1346 break;
|
|
1347 case GDK_End:
|
|
1348 playlistwin_list->pl_first =
|
|
1349 playlist_get_length() - playlistwin_list->pl_num_visible;
|
|
1350 refresh = TRUE;
|
|
1351 break;
|
|
1352 case GDK_Return:
|
|
1353 if (playlistwin_list->pl_prev_selected > -1
|
|
1354 && playlistwin_item_visible(playlistwin_list->pl_prev_selected)) {
|
|
1355 playlist_set_position(playlistwin_list->pl_prev_selected);
|
|
1356 if (!bmp_playback_get_playing())
|
|
1357 bmp_playback_initiate();
|
|
1358 }
|
|
1359 break;
|
|
1360 case GDK_3:
|
|
1361 if (event->state & GDK_CONTROL_MASK)
|
|
1362 playlistwin_fileinfo();
|
|
1363 break;
|
|
1364 case GDK_Delete:
|
|
1365 if (event->state & GDK_CONTROL_MASK)
|
|
1366 playlist_delete(TRUE);
|
|
1367 else
|
|
1368 playlist_delete(FALSE);
|
|
1369 break;
|
|
1370 case GDK_Insert:
|
|
1371 if (event->state & GDK_MOD1_MASK)
|
|
1372 mainwin_show_add_url_window();
|
|
1373 else
|
|
1374 playlistwin_show_filebrowser();
|
|
1375 break;
|
|
1376 case GDK_Left:
|
|
1377 case GDK_KP_Left:
|
|
1378 case GDK_KP_7:
|
|
1379 if (playlist_get_current_length() != -1)
|
|
1380 bmp_playback_seek(CLAMP
|
|
1381 (bmp_playback_get_time() - 1000, 0,
|
|
1382 playlist_get_current_length()) / 1000);
|
|
1383 break;
|
|
1384 case GDK_Right:
|
|
1385 case GDK_KP_Right:
|
|
1386 case GDK_KP_9:
|
|
1387 if (playlist_get_current_length() != -1)
|
|
1388 bmp_playback_seek(CLAMP
|
|
1389 (bmp_playback_get_time() + 1000, 0,
|
|
1390 playlist_get_current_length()) / 1000);
|
|
1391 break;
|
|
1392
|
|
1393 case GDK_Escape:
|
|
1394 mainwin_minimize_cb();
|
|
1395 break;
|
|
1396 default:
|
|
1397 return FALSE;
|
|
1398 }
|
|
1399
|
|
1400 if (refresh)
|
|
1401 playlistwin_update_list();
|
|
1402
|
|
1403 return TRUE;
|
|
1404 }
|
|
1405
|
|
1406 static void
|
|
1407 playlistwin_draw_frame(void)
|
|
1408 {
|
|
1409 gboolean focus =
|
|
1410 gtk_window_has_toplevel_focus(GTK_WINDOW(playlistwin)) ||
|
|
1411 !cfg.dim_titlebar;
|
|
1412
|
|
1413 if (cfg.playlist_shaded) {
|
|
1414 skin_draw_playlistwin_shaded(bmp_active_skin,
|
|
1415 playlistwin_bg, playlistwin_gc,
|
|
1416 playlistwin_get_width(), focus);
|
|
1417 }
|
|
1418 else {
|
|
1419 skin_draw_playlistwin_frame(bmp_active_skin,
|
|
1420 playlistwin_bg, playlistwin_gc,
|
|
1421 playlistwin_get_width(),
|
|
1422 cfg.playlist_height, focus);
|
|
1423 }
|
|
1424 }
|
|
1425
|
|
1426 void
|
|
1427 draw_playlist_window(gboolean force)
|
|
1428 {
|
|
1429 gboolean redraw;
|
|
1430 GList *wl;
|
|
1431 Widget *w;
|
|
1432
|
|
1433 if (force)
|
|
1434 playlistwin_draw_frame();
|
|
1435
|
|
1436 widget_list_lock(playlistwin_wlist);
|
|
1437 widget_list_draw(playlistwin_wlist, &redraw, force);
|
|
1438
|
|
1439 if (redraw || force) {
|
|
1440 if (force) {
|
|
1441 gdk_window_clear(playlistwin->window);
|
|
1442 }
|
|
1443 else {
|
|
1444 for (wl = playlistwin_wlist; wl; wl = g_list_next(wl)) {
|
|
1445 w = WIDGET(wl->data);
|
|
1446 if (w->redraw && w->visible) {
|
|
1447 gdk_window_clear_area(playlistwin->window, w->x, w->y,
|
|
1448 w->width, w->height);
|
|
1449 w->redraw = FALSE;
|
|
1450 }
|
|
1451 }
|
|
1452 }
|
|
1453
|
|
1454 gdk_flush();
|
|
1455 }
|
|
1456
|
|
1457 widget_list_unlock(playlistwin_wlist);
|
|
1458 }
|
|
1459
|
|
1460
|
|
1461 void
|
|
1462 playlistwin_hide_timer(void)
|
|
1463 {
|
|
1464 textbox_set_text(playlistwin_time_min, " ");
|
|
1465 textbox_set_text(playlistwin_time_sec, " ");
|
|
1466 }
|
|
1467
|
|
1468 void
|
|
1469 playlistwin_set_time(gint time, gint length, TimerMode mode)
|
|
1470 {
|
|
1471 gchar *text, sign;
|
|
1472
|
|
1473 if (mode == TIMER_REMAINING && length != -1) {
|
|
1474 time = length - time;
|
|
1475 sign = '-';
|
|
1476 }
|
|
1477 else
|
|
1478 sign = ' ';
|
|
1479
|
|
1480 time /= 1000;
|
|
1481
|
|
1482 if (time < 0)
|
|
1483 time = 0;
|
|
1484 if (time > 99 * 60)
|
|
1485 time /= 60;
|
|
1486
|
|
1487 text = g_strdup_printf("%c%-2.2d", sign, time / 60);
|
|
1488 textbox_set_text(playlistwin_time_min, text);
|
|
1489 g_free(text);
|
|
1490
|
|
1491 text = g_strdup_printf("%-2.2d", time % 60);
|
|
1492 textbox_set_text(playlistwin_time_sec, text);
|
|
1493 g_free(text);
|
|
1494 }
|
|
1495
|
|
1496 static void
|
|
1497 playlistwin_drag_motion(GtkWidget * widget,
|
|
1498 GdkDragContext * context,
|
|
1499 gint x, gint y,
|
|
1500 GtkSelectionData * selection_data,
|
|
1501 guint info, guint time, gpointer user_data)
|
|
1502 {
|
|
1503 playlistwin_list->pl_drag_motion = TRUE;
|
|
1504 playlistwin_list->drag_motion_x = x;
|
|
1505 playlistwin_list->drag_motion_y = y;
|
|
1506 playlistwin_update_list();
|
|
1507 playlistwin_hint_flag = TRUE;
|
|
1508 }
|
|
1509
|
|
1510 static void
|
|
1511 playlistwin_drag_end(GtkWidget * widget,
|
|
1512 GdkDragContext * context, gpointer user_data)
|
|
1513 {
|
|
1514 playlistwin_list->pl_drag_motion = FALSE;
|
|
1515 playlistwin_hint_flag = FALSE;
|
|
1516 playlistwin_update_list();
|
|
1517 }
|
|
1518
|
|
1519 static void
|
|
1520 playlistwin_drag_data_received(GtkWidget * widget,
|
|
1521 GdkDragContext * context,
|
|
1522 gint x, gint y,
|
|
1523 GtkSelectionData *
|
|
1524 selection_data, guint info,
|
|
1525 guint time, gpointer user_data)
|
|
1526 {
|
|
1527 gint pos;
|
|
1528
|
|
1529 g_return_if_fail(selection_data != NULL);
|
|
1530
|
|
1531 if (!selection_data->data) {
|
|
1532 g_message("Received no DND data!");
|
|
1533 return;
|
|
1534 }
|
|
1535
|
|
1536 if (widget_contains(WIDGET(playlistwin_list), x, y)) {
|
|
1537 pos = (y - WIDGET(playlistwin_list)->y) /
|
|
1538 playlistwin_list->pl_fheight + playlistwin_list->pl_first;
|
|
1539
|
|
1540 pos = MIN(pos, playlist_get_length());
|
|
1541 playlist_ins_url((gchar *) selection_data->data, pos);
|
|
1542 }
|
|
1543 else
|
|
1544 playlist_add_url((gchar *) selection_data->data);
|
|
1545 }
|
|
1546
|
|
1547 static void
|
|
1548 playlistwin_create_widgets(void)
|
|
1549 {
|
|
1550 /* This function creates the custom widgets used by the playlist editor */
|
|
1551
|
|
1552 /* text box for displaying song title in shaded mode */
|
|
1553 playlistwin_sinfo =
|
|
1554 create_textbox(&playlistwin_wlist, playlistwin_bg, playlistwin_gc,
|
|
1555 4, 4, playlistwin_get_width() - 35, FALSE, SKIN_TEXT);
|
|
1556
|
|
1557 if (!cfg.playlist_shaded)
|
|
1558 widget_hide(WIDGET(playlistwin_sinfo));
|
|
1559
|
|
1560 /* shade/unshade window push button */
|
|
1561 if (cfg.playlist_shaded)
|
|
1562 playlistwin_shade =
|
|
1563 create_pbutton(&playlistwin_wlist, playlistwin_bg,
|
|
1564 playlistwin_gc, playlistwin_get_width() - 21, 3,
|
|
1565 9, 9, 128, 45, 150, 42,
|
|
1566 playlistwin_shade_toggle, SKIN_PLEDIT);
|
|
1567 else
|
|
1568 playlistwin_shade =
|
|
1569 create_pbutton(&playlistwin_wlist, playlistwin_bg,
|
|
1570 playlistwin_gc, playlistwin_get_width() - 21, 3,
|
|
1571 9, 9, 157, 3, 62, 42, playlistwin_shade_toggle,
|
|
1572 SKIN_PLEDIT);
|
|
1573
|
|
1574 playlistwin_shade->pb_allow_draw = FALSE;
|
|
1575
|
|
1576 /* close window push button */
|
|
1577 playlistwin_close =
|
|
1578 create_pbutton(&playlistwin_wlist, playlistwin_bg, playlistwin_gc,
|
|
1579 playlistwin_get_width() - 11, 3, 9, 9,
|
|
1580 cfg.playlist_shaded ? 138 : 167,
|
|
1581 cfg.playlist_shaded ? 45 : 3, 52, 42,
|
|
1582 playlistwin_hide, SKIN_PLEDIT);
|
|
1583 playlistwin_close->pb_allow_draw = FALSE;
|
|
1584
|
|
1585 /* playlist list box */
|
|
1586 playlistwin_list =
|
|
1587 create_playlist_list(&playlistwin_wlist, playlistwin_bg,
|
|
1588 playlistwin_gc, 12, 20,
|
|
1589 playlistwin_get_width() - 31,
|
|
1590 cfg.playlist_height - 58);
|
|
1591 playlist_list_set_font(cfg.playlist_font);
|
|
1592
|
|
1593 /* playlist list box slider */
|
|
1594 playlistwin_slider =
|
|
1595 create_playlistslider(&playlistwin_wlist, playlistwin_bg,
|
|
1596 playlistwin_gc, playlistwin_get_width() - 15,
|
|
1597 20, cfg.playlist_height - 58, playlistwin_list);
|
|
1598 /* track time (minute) */
|
|
1599 playlistwin_time_min =
|
|
1600 create_textbox(&playlistwin_wlist, playlistwin_bg, playlistwin_gc,
|
|
1601 playlistwin_get_width() - 82,
|
|
1602 cfg.playlist_height - 15, 15, FALSE, SKIN_TEXT);
|
|
1603
|
|
1604 /* track time (second) */
|
|
1605 playlistwin_time_sec =
|
|
1606 create_textbox(&playlistwin_wlist, playlistwin_bg, playlistwin_gc,
|
|
1607 playlistwin_get_width() - 64,
|
|
1608 cfg.playlist_height - 15, 10, FALSE, SKIN_TEXT);
|
|
1609
|
|
1610 /* playlist information (current track length / total track length) */
|
|
1611 playlistwin_info =
|
|
1612 create_textbox(&playlistwin_wlist, playlistwin_bg, playlistwin_gc,
|
|
1613 playlistwin_get_width() - 143,
|
|
1614 cfg.playlist_height - 28, 90, FALSE, SKIN_TEXT);
|
|
1615
|
|
1616 /* mini play control buttons at right bottom corner */
|
|
1617
|
|
1618 /* rewind button */
|
|
1619 playlistwin_srew =
|
|
1620 create_sbutton(&playlistwin_wlist, playlistwin_bg, playlistwin_gc,
|
|
1621 playlistwin_get_width() - 144,
|
|
1622 cfg.playlist_height - 16, 8, 7, playlist_prev);
|
|
1623
|
|
1624 /* play button */
|
|
1625 playlistwin_splay =
|
|
1626 create_sbutton(&playlistwin_wlist, playlistwin_bg, playlistwin_gc,
|
|
1627 playlistwin_get_width() - 138,
|
|
1628 cfg.playlist_height - 16, 10, 7, mainwin_play_pushed);
|
|
1629
|
|
1630 /* pause button */
|
|
1631 playlistwin_spause =
|
|
1632 create_sbutton(&playlistwin_wlist, playlistwin_bg, playlistwin_gc,
|
|
1633 playlistwin_get_width() - 128,
|
|
1634 cfg.playlist_height - 16, 10, 7, bmp_playback_pause);
|
|
1635
|
|
1636 /* stop button */
|
|
1637 playlistwin_sstop =
|
|
1638 create_sbutton(&playlistwin_wlist, playlistwin_bg, playlistwin_gc,
|
|
1639 playlistwin_get_width() - 118,
|
|
1640 cfg.playlist_height - 16, 9, 7, mainwin_stop_pushed);
|
|
1641
|
|
1642 /* forward button */
|
|
1643 playlistwin_sfwd =
|
|
1644 create_sbutton(&playlistwin_wlist, playlistwin_bg, playlistwin_gc,
|
|
1645 playlistwin_get_width() - 109,
|
|
1646 cfg.playlist_height - 16, 8, 7, playlist_next);
|
|
1647
|
|
1648 /* eject button */
|
|
1649 playlistwin_seject =
|
|
1650 create_sbutton(&playlistwin_wlist, playlistwin_bg, playlistwin_gc,
|
|
1651 playlistwin_get_width() - 100,
|
|
1652 cfg.playlist_height - 16, 9, 7, mainwin_eject_pushed);
|
|
1653
|
|
1654
|
|
1655 playlistwin_sscroll_up =
|
|
1656 create_sbutton(&playlistwin_wlist, playlistwin_bg, playlistwin_gc,
|
|
1657 playlistwin_get_width() - 14,
|
|
1658 cfg.playlist_height - 35, 8, 5,
|
|
1659 playlistwin_scroll_up_pushed);
|
|
1660 playlistwin_sscroll_down =
|
|
1661 create_sbutton(&playlistwin_wlist, playlistwin_bg, playlistwin_gc,
|
|
1662 playlistwin_get_width() - 14,
|
|
1663 cfg.playlist_height - 30, 8, 5,
|
|
1664 playlistwin_scroll_down_pushed);
|
|
1665
|
|
1666 }
|
|
1667
|
|
1668 static void
|
|
1669 selection_received(GtkWidget * widget,
|
|
1670 GtkSelectionData * selection_data, gpointer data)
|
|
1671 {
|
|
1672 if (selection_data->type == GDK_SELECTION_TYPE_STRING &&
|
|
1673 selection_data->length > 0)
|
|
1674 playlist_add_url((gchar *) selection_data->data);
|
|
1675 }
|
|
1676
|
|
1677 static void
|
|
1678 playlistwin_create_window(void)
|
|
1679 {
|
|
1680 GdkPixbuf *icon;
|
|
1681
|
|
1682 playlistwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
|
|
1683 gtk_window_set_title(GTK_WINDOW(playlistwin), _("Audacious Playlist Editor"));
|
|
1684 gtk_window_set_wmclass(GTK_WINDOW(playlistwin), "playlist", "Audacious");
|
|
1685 gtk_window_set_role(GTK_WINDOW(playlistwin), "playlist");
|
|
1686 gtk_window_set_default_size(GTK_WINDOW(playlistwin),
|
|
1687 playlistwin_get_width(),
|
|
1688 playlistwin_get_height());
|
|
1689 gtk_window_set_resizable(GTK_WINDOW(playlistwin), TRUE);
|
|
1690 playlistwin_set_geometry_hints(cfg.playlist_shaded);
|
|
1691 dock_window_list = dock_window_set_decorated(dock_window_list,
|
|
1692 GTK_WINDOW(playlistwin),
|
|
1693 cfg.show_wm_decorations);
|
|
1694
|
|
1695 gtk_window_set_transient_for(GTK_WINDOW(playlistwin),
|
|
1696 GTK_WINDOW(mainwin));
|
|
1697 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(playlistwin), TRUE);
|
|
1698
|
|
1699 icon = gdk_pixbuf_new_from_xpm_data((const gchar **) bmp_playlist_icon);
|
|
1700 gtk_window_set_icon(GTK_WINDOW(playlistwin), icon);
|
|
1701 g_object_unref(icon);
|
|
1702
|
|
1703 gtk_widget_set_app_paintable(playlistwin, TRUE);
|
|
1704
|
|
1705 if (cfg.playlist_x != -1 && cfg.save_window_position)
|
|
1706 gtk_window_move(GTK_WINDOW(playlistwin),
|
|
1707 cfg.playlist_x, cfg.playlist_y);
|
|
1708
|
|
1709 gtk_widget_add_events(playlistwin, GDK_POINTER_MOTION_MASK |
|
|
1710 GDK_FOCUS_CHANGE_MASK | GDK_BUTTON_MOTION_MASK |
|
|
1711 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
|
|
1712 GDK_SCROLL_MASK | GDK_VISIBILITY_NOTIFY_MASK);
|
|
1713 gtk_widget_realize(playlistwin);
|
|
1714
|
|
1715 util_set_cursor(playlistwin);
|
|
1716
|
|
1717 g_signal_connect(playlistwin, "delete_event",
|
|
1718 G_CALLBACK(playlistwin_delete), NULL);
|
|
1719 g_signal_connect(playlistwin, "button_press_event",
|
|
1720 G_CALLBACK(playlistwin_press), NULL);
|
|
1721 g_signal_connect(playlistwin, "button_release_event",
|
|
1722 G_CALLBACK(playlistwin_release), NULL);
|
|
1723 g_signal_connect(playlistwin, "scroll_event",
|
|
1724 G_CALLBACK(playlistwin_scrolled), NULL);
|
|
1725 g_signal_connect(playlistwin, "motion_notify_event",
|
|
1726 G_CALLBACK(playlistwin_motion), NULL);
|
|
1727 g_signal_connect(playlistwin, "enter_notify_event",
|
|
1728 G_CALLBACK(playlistwin_enter), NULL);
|
|
1729 g_signal_connect(playlistwin, "leave_notify_event",
|
|
1730 G_CALLBACK(playlistwin_leave), NULL);
|
|
1731 g_signal_connect_after(playlistwin, "focus_in_event",
|
|
1732 G_CALLBACK(playlistwin_focus_in), NULL);
|
|
1733 g_signal_connect_after(playlistwin, "focus_out_event",
|
|
1734 G_CALLBACK(playlistwin_focus_out), NULL);
|
|
1735 g_signal_connect(playlistwin, "configure_event",
|
|
1736 G_CALLBACK(playlistwin_configure), NULL);
|
|
1737 g_signal_connect(playlistwin, "style_set",
|
|
1738 G_CALLBACK(playlistwin_set_back_pixmap), NULL);
|
|
1739
|
|
1740 bmp_drag_dest_set(playlistwin);
|
|
1741
|
|
1742 /* DnD stuff */
|
|
1743 g_signal_connect(playlistwin, "drag-leave",
|
|
1744 G_CALLBACK(playlistwin_drag_end), NULL);
|
|
1745 g_signal_connect(playlistwin, "drag-data-delete",
|
|
1746 G_CALLBACK(playlistwin_drag_end), NULL);
|
|
1747 g_signal_connect(playlistwin, "drag-end",
|
|
1748 G_CALLBACK(playlistwin_drag_end), NULL);
|
|
1749 g_signal_connect(playlistwin, "drag-drop",
|
|
1750 G_CALLBACK(playlistwin_drag_end), NULL);
|
|
1751 g_signal_connect(playlistwin, "drag-data-received",
|
|
1752 G_CALLBACK(playlistwin_drag_data_received), NULL);
|
|
1753 g_signal_connect(playlistwin, "drag-motion",
|
|
1754 G_CALLBACK(playlistwin_drag_motion), NULL);
|
|
1755
|
|
1756 g_signal_connect(playlistwin, "key_press_event",
|
|
1757 G_CALLBACK(playlistwin_keypress), NULL);
|
|
1758 g_signal_connect(playlistwin, "selection_received",
|
|
1759 G_CALLBACK(selection_received), NULL);
|
|
1760
|
|
1761 playlistwin_set_mask();
|
|
1762 }
|
|
1763
|
|
1764 void
|
|
1765 playlistwin_create_popup_menus(void)
|
|
1766 {
|
|
1767 playlistwin_accel = gtk_accel_group_new();
|
|
1768
|
|
1769 /* playlist window popup menu */
|
|
1770 playlistwin_popup_menu = create_menu(playlistwin_popup_menu_entries,
|
|
1771 G_N_ELEMENTS(playlistwin_popup_menu_entries),
|
|
1772 playlistwin_accel);
|
|
1773
|
|
1774 pladd_menu = create_menu(pladd_menu_entries, G_N_ELEMENTS(pladd_menu_entries),
|
|
1775 playlistwin_accel);
|
|
1776 pldel_menu = create_menu(pldel_menu_entries, G_N_ELEMENTS(pldel_menu_entries),
|
|
1777 playlistwin_accel);
|
|
1778 plsel_menu = create_menu(plsel_menu_entries, G_N_ELEMENTS(plsel_menu_entries),
|
|
1779 playlistwin_accel);
|
|
1780 plsort_menu = create_menu(plsort_menu_entries,
|
|
1781 G_N_ELEMENTS(plsort_menu_entries),
|
|
1782 playlistwin_accel);
|
|
1783 pllist_menu = create_menu(pllist_menu_entries, G_N_ELEMENTS(pllist_menu_entries),
|
|
1784 playlistwin_accel);
|
|
1785
|
|
1786 #if 0
|
|
1787 make_submenu(playlistwin_popup_menu, "/Playlist",
|
|
1788 playlistwin_playlist_menu);
|
|
1789 make_submenu(playlistwin_popup_menu, "/Playback",
|
|
1790 playlistwin_playback_menu);
|
|
1791 make_submenu(playlistwin_popup_menu, "/Add",
|
|
1792 pladd_menu);
|
|
1793 #endif
|
|
1794 }
|
|
1795
|
|
1796 void
|
|
1797 playlistwin_create(void)
|
|
1798 {
|
|
1799 playlistwin_create_window();
|
|
1800 playlistwin_create_popup_menus();
|
|
1801
|
|
1802 /* create GC and back pixmap for custom widget to draw on */
|
|
1803 playlistwin_gc = gdk_gc_new(playlistwin->window);
|
|
1804 playlistwin_bg = gdk_pixmap_new(playlistwin->window,
|
|
1805 playlistwin_get_width(),
|
|
1806 playlistwin_get_height_unshaded(), -1);
|
|
1807 gdk_window_set_back_pixmap(playlistwin->window, playlistwin_bg, 0);
|
|
1808
|
|
1809 playlistwin_create_widgets();
|
|
1810 playlistwin_update_info();
|
|
1811
|
|
1812 gtk_window_add_accel_group(GTK_WINDOW(playlistwin), playlistwin_accel);
|
|
1813 gtk_window_add_accel_group(GTK_WINDOW(playlistwin), mainwin_accel);
|
|
1814 }
|
|
1815
|
|
1816
|
|
1817 void
|
|
1818 playlistwin_show(void)
|
|
1819 {
|
|
1820 GtkWidget *item;
|
|
1821
|
|
1822 item = gtk_item_factory_get_widget(mainwin_view_menu,
|
|
1823 "/Show Playlist Editor");
|
|
1824 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
|
|
1825
|
|
1826 tbutton_set_toggled(mainwin_pl, TRUE);
|
|
1827 cfg.playlist_visible = TRUE;
|
|
1828
|
|
1829 playlistwin_set_toprow(0);
|
|
1830 playlist_check_pos_current();
|
|
1831
|
|
1832 gtk_widget_show(playlistwin);
|
|
1833 }
|
|
1834
|
|
1835 void
|
|
1836 playlistwin_hide(void)
|
|
1837 {
|
|
1838 GtkWidget *item;
|
|
1839
|
|
1840 item = gtk_item_factory_get_widget(mainwin_view_menu,
|
|
1841 "/Show Playlist Editor");
|
|
1842 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), FALSE);
|
|
1843
|
|
1844 gtk_widget_hide(playlistwin);
|
|
1845 tbutton_set_toggled(mainwin_pl, FALSE);
|
|
1846 cfg.playlist_visible = FALSE;
|
|
1847
|
|
1848 gtk_window_present(GTK_WINDOW(mainwin));
|
|
1849 gtk_widget_grab_focus(mainwin);
|
|
1850 }
|
|
1851
|
|
1852
|
|
1853 static void
|
|
1854 plsort_menu_callback(gpointer data,
|
|
1855 guint action,
|
|
1856 GtkWidget * widget)
|
|
1857 {
|
|
1858 switch (action) {
|
|
1859 case PLAYLISTWIN_SORT_BYPLAYLIST:
|
|
1860 playlist_sort(PLAYLIST_SORT_PLAYLIST);
|
|
1861 playlistwin_update_list();
|
|
1862 break;
|
|
1863 case PLAYLISTWIN_SORT_BYTRACK:
|
|
1864 playlist_sort(PLAYLIST_SORT_TRACK);
|
|
1865 playlistwin_update_list();
|
|
1866 break;
|
|
1867 case PLAYLISTWIN_SORT_BYTITLE:
|
|
1868 playlist_sort(PLAYLIST_SORT_TITLE);
|
|
1869 playlistwin_update_list();
|
|
1870 break;
|
|
1871 case PLAYLISTWIN_SORT_BYARTIST:
|
|
1872 playlist_sort(PLAYLIST_SORT_ARTIST);
|
|
1873 playlistwin_update_list();
|
|
1874 break;
|
|
1875 case PLAYLISTWIN_SORT_BYPATH:
|
|
1876 playlist_sort(PLAYLIST_SORT_PATH);
|
|
1877 playlistwin_update_list();
|
|
1878 break;
|
|
1879 case PLAYLISTWIN_SORT_BYDATE:
|
|
1880 playlist_sort(PLAYLIST_SORT_DATE);
|
|
1881 playlistwin_update_list();
|
|
1882 break;
|
|
1883 case PLAYLISTWIN_SORT_BYFILENAME:
|
|
1884 playlist_sort(PLAYLIST_SORT_FILENAME);
|
|
1885 playlistwin_update_list();
|
|
1886 break;
|
|
1887 case PLAYLISTWIN_SORT_SEL_BYPLAYLIST:
|
|
1888 playlist_sort_selected(PLAYLIST_SORT_PLAYLIST);
|
|
1889 playlistwin_update_list();
|
|
1890 break;
|
|
1891 case PLAYLISTWIN_SORT_SEL_BYTRACK:
|
|
1892 playlist_sort_selected(PLAYLIST_SORT_TRACK);
|
|
1893 playlistwin_update_list();
|
|
1894 break;
|
|
1895 case PLAYLISTWIN_SORT_SEL_BYTITLE:
|
|
1896 playlist_sort_selected(PLAYLIST_SORT_TITLE);
|
|
1897 playlistwin_update_list();
|
|
1898 break;
|
|
1899 case PLAYLISTWIN_SORT_SEL_BYARTIST:
|
|
1900 playlist_sort_selected(PLAYLIST_SORT_ARTIST);
|
|
1901 playlistwin_update_list();
|
|
1902 break;
|
|
1903 case PLAYLISTWIN_SORT_SEL_BYFILENAME:
|
|
1904 playlist_sort_selected(PLAYLIST_SORT_FILENAME);
|
|
1905 playlistwin_update_list();
|
|
1906 break;
|
|
1907 case PLAYLISTWIN_SORT_SEL_BYPATH:
|
|
1908 playlist_sort_selected(PLAYLIST_SORT_PATH);
|
|
1909 playlistwin_update_list();
|
|
1910 break;
|
|
1911 case PLAYLISTWIN_SORT_SEL_BYDATE:
|
|
1912 playlist_sort_selected(PLAYLIST_SORT_DATE);
|
|
1913 playlistwin_update_list();
|
|
1914 break;
|
|
1915 case PLAYLISTWIN_SORT_REVERSE:
|
|
1916 playlist_reverse();
|
|
1917 playlistwin_update_list();
|
|
1918 break;
|
|
1919 case PLAYLISTWIN_SORT_RANDOMIZE:
|
|
1920 playlist_random();
|
|
1921 playlistwin_update_list();
|
|
1922 break;
|
|
1923 }
|
|
1924 }
|
|
1925
|
|
1926 static void
|
|
1927 playlistwin_sub_menu_callback(gpointer data,
|
|
1928 guint action,
|
|
1929 GtkWidget * widget)
|
|
1930 {
|
|
1931 switch (action) {
|
|
1932 case PLIST_NEW:
|
|
1933 playlist_set_current_name(NULL);
|
|
1934 playlist_clear();
|
|
1935 mainwin_clear_song_info();
|
|
1936 mainwin_set_info_text();
|
|
1937 break;
|
|
1938 case PLIST_SAVE:
|
|
1939 playlistwin_select_playlist_to_save(playlist_get_current_name());
|
|
1940 break;
|
|
1941 case PLIST_DEFAULTSAVE:
|
|
1942 playlist_save(bmp_paths[BMP_PATH_PLAYLIST_FILE]);
|
|
1943 break;
|
|
1944 case PLIST_SAVE_AS:
|
|
1945 playlistwin_select_playlist_to_save(playlist_get_current_name());
|
|
1946 break;
|
|
1947 case PLIST_LOAD:
|
|
1948 playlistwin_select_playlist_to_load(playlist_get_current_name());
|
|
1949 break;
|
|
1950 case SEL_INV:
|
|
1951 playlistwin_inverse_selection();
|
|
1952 break;
|
|
1953 case SEL_ZERO:
|
|
1954 playlistwin_select_none();
|
|
1955 break;
|
|
1956 case SEL_ALL:
|
|
1957 playlistwin_select_all();
|
|
1958 break;
|
|
1959 case SUB_ALL:
|
|
1960 playlist_clear();
|
|
1961 mainwin_clear_song_info();
|
|
1962 mainwin_set_info_text();
|
|
1963 break;
|
|
1964 case SUB_CROP:
|
|
1965 playlist_delete(TRUE);
|
|
1966 break;
|
|
1967 case SUB_SELECTED:
|
|
1968 playlist_delete(FALSE);
|
|
1969 break;
|
|
1970 case SUB_DUPLICATE_BYTITLE:
|
|
1971 playlist_remove_duplicates(PLAYLIST_DUPS_TITLE);
|
|
1972 break;
|
|
1973 case SUB_DUPLICATE_BYFILENAME:
|
|
1974 playlist_remove_duplicates(PLAYLIST_DUPS_FILENAME);
|
|
1975 break;
|
|
1976 case SUB_DUPLICATE_BYPATH:
|
|
1977 playlist_remove_duplicates(PLAYLIST_DUPS_PATH);
|
|
1978 break;
|
|
1979 case PLAYLISTWIN_REMOVE_DEAD_FILES:
|
|
1980 playlist_remove_dead_files();
|
|
1981 break;
|
|
1982 case PLAYLISTWIN_REFRESH:
|
|
1983 playlist_read_info_selection();
|
|
1984 playlistwin_update_list();
|
|
1985 break;
|
|
1986 }
|
|
1987 }
|
|
1988
|
|
1989 static void
|
|
1990 playlistwin_popup_menu_callback(gpointer data,
|
|
1991 guint action,
|
|
1992 GtkWidget * widget)
|
|
1993 {
|
|
1994 extern GtkWidget *filepopupbutton;
|
|
1995
|
|
1996 switch (action) {
|
|
1997 case ADD_FILES:
|
|
1998 playlistwin_show_filebrowser();
|
|
1999 break;
|
|
2000 case CLOSE_PL_WINDOW:
|
|
2001 playlistwin_hide();
|
|
2002 break;
|
|
2003 case MISC_FILEINFO:
|
|
2004 playlistwin_fileinfo();
|
|
2005 break;
|
|
2006 case SEL_LOOKUP:
|
|
2007 playlist_read_info_selection();
|
|
2008 break;
|
|
2009 case MISC_QUEUE:
|
|
2010 playlist_queue();
|
|
2011 break;
|
|
2012 case PLIST_CQUEUE:
|
|
2013 playlist_clear_queue();
|
|
2014 break;
|
|
2015 case PLIST_JTT:
|
|
2016 mainwin_jump_to_time();
|
|
2017 break;
|
|
2018 case PLIST_JTF:
|
|
2019 mainwin_jump_to_file();
|
|
2020 break;
|
|
2021 case MISC_FILEPOPUP:
|
|
2022 cfg.show_filepopup_for_tuple = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));
|
|
2023 if(filepopupbutton != NULL){
|
|
2024 gtk_signal_emit_by_name(GTK_OBJECT(filepopupbutton), "realize");
|
|
2025 }
|
|
2026 break;
|
|
2027
|
|
2028 }
|
|
2029 }
|