2620
|
1 /* Audacious - Cross-platform multimedia player
|
|
2 * Copyright (C) 2005-2006 Audacious development team.
|
|
3 *
|
|
4 * BMP - Cross-platform multimedia player
|
|
5 * Copyright (C) 2003-2004 BMP development team.
|
|
6 *
|
|
7 * Based on XMMS:
|
|
8 * Copyright (C) 1998-2003 XMMS development team.
|
|
9 *
|
|
10 * This program is free software; you can redistribute it and/or modify
|
|
11 * it under the terms of the GNU General Public License as published by
|
|
12 * the Free Software Foundation; under version 3 of the License.
|
|
13 *
|
|
14 * This program is distributed in the hope that it will be useful,
|
|
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
17 * GNU General Public License for more details.
|
|
18 *
|
|
19 * You should have received a copy of the GNU General Public License
|
|
20 * along with this program. If not, see <http://www.gnu.org/licenses>.
|
|
21 *
|
|
22 * The Audacious team does not consider modular code linking to
|
|
23 * Audacious or using our public API to be a derived work.
|
|
24 */
|
|
25
|
|
26 /* #define AUD_DEBUG 1 */
|
|
27
|
|
28 #include "ui_playlist.h"
|
|
29
|
|
30 #include <glib.h>
|
|
31 #include <glib/gi18n.h>
|
|
32 #include <gdk/gdk.h>
|
|
33 #include <gdk/gdkkeysyms.h>
|
|
34 #include <gtk/gtk.h>
|
|
35 #include <string.h>
|
|
36
|
|
37 #include "platform/smartinclude.h"
|
|
38
|
|
39 #include <unistd.h>
|
|
40 #include <errno.h>
|
|
41
|
|
42 #include "actions-playlist.h"
|
|
43 #if 0
|
|
44 #include "dnd.h"
|
|
45 #include "input.h"
|
|
46 #include "main.h"
|
|
47 #include "playback.h"
|
|
48 #include "playlist.h"
|
|
49 #include "playlist_container.h"
|
|
50 #include "strings.h"
|
|
51 #endif
|
|
52 #include "ui_dock.h"
|
|
53 #include "ui_equalizer.h"
|
|
54 #if 0
|
|
55 #include "ui_fileinfo.h"
|
|
56 #include "ui_fileopener.h"
|
|
57 #endif
|
|
58 #include "ui_main.h"
|
|
59 #include "ui_manager.h"
|
|
60 #include "ui_playlist_evlisteners.h"
|
|
61 #if 0
|
|
62 #include "ui_playlist_manager.h"
|
|
63 #endif
|
|
64 #include "util.h"
|
|
65
|
|
66 #include "ui_skinned_window.h"
|
|
67 #include "ui_skinned_button.h"
|
|
68 #include "ui_skinned_textbox.h"
|
|
69 #include "ui_skinned_playlist_slider.h"
|
|
70 #include "ui_skinned_playlist.h"
|
|
71
|
|
72 #include "icons-stock.h"
|
|
73 #include "images/audacious_playlist.xpm"
|
|
74
|
|
75 GtkWidget *playlistwin;
|
|
76
|
|
77 static GMutex *resize_mutex = NULL;
|
|
78
|
|
79 static GtkWidget *playlistwin_list = NULL;
|
|
80 static GtkWidget *playlistwin_shade, *playlistwin_close;
|
|
81
|
|
82 static gboolean playlistwin_hint_flag = FALSE;
|
|
83
|
|
84 static GtkWidget *playlistwin_slider;
|
|
85 static GtkWidget *playlistwin_time_min, *playlistwin_time_sec;
|
|
86 static GtkWidget *playlistwin_info, *playlistwin_sinfo;
|
|
87 static GtkWidget *playlistwin_srew, *playlistwin_splay;
|
|
88 static GtkWidget *playlistwin_spause, *playlistwin_sstop;
|
|
89 static GtkWidget *playlistwin_sfwd, *playlistwin_seject;
|
|
90 static GtkWidget *playlistwin_sscroll_up, *playlistwin_sscroll_down;
|
|
91
|
|
92 static void playlistwin_select_search_cbt_cb(GtkWidget *called_cbt,
|
|
93 gpointer other_cbt);
|
|
94 static gboolean playlistwin_select_search_kp_cb(GtkWidget *entry,
|
|
95 GdkEventKey *event,
|
|
96 gpointer searchdlg_win);
|
|
97
|
|
98 static gboolean playlistwin_resizing = FALSE;
|
|
99 static gint playlistwin_resize_x, playlistwin_resize_y;
|
|
100
|
|
101 gboolean
|
|
102 playlistwin_is_shaded(void)
|
|
103 {
|
|
104 return config.playlist_shaded;
|
|
105 }
|
|
106
|
|
107 gint
|
|
108 playlistwin_get_width(void)
|
|
109 {
|
|
110 config.playlist_width /= PLAYLISTWIN_WIDTH_SNAP;
|
|
111 config.playlist_width *= PLAYLISTWIN_WIDTH_SNAP;
|
|
112 return config.playlist_width;
|
|
113 }
|
|
114
|
|
115 gint
|
|
116 playlistwin_get_height_unshaded(void)
|
|
117 {
|
|
118 config.playlist_height /= PLAYLISTWIN_HEIGHT_SNAP;
|
|
119 config.playlist_height *= PLAYLISTWIN_HEIGHT_SNAP;
|
|
120 return config.playlist_height;
|
|
121 }
|
|
122
|
|
123 gint
|
|
124 playlistwin_get_height_shaded(void)
|
|
125 {
|
|
126 return PLAYLISTWIN_SHADED_HEIGHT;
|
|
127 }
|
|
128
|
|
129 gint
|
|
130 playlistwin_get_height(void)
|
|
131 {
|
|
132 if (playlistwin_is_shaded())
|
|
133 return playlistwin_get_height_shaded();
|
|
134 else
|
|
135 return playlistwin_get_height_unshaded();
|
|
136 }
|
|
137
|
|
138 static void
|
|
139 playlistwin_update_info(Playlist *playlist)
|
|
140 {
|
|
141 #if 0
|
|
142 gchar *text, *sel_text, *tot_text;
|
|
143 gulong selection, total;
|
|
144 gboolean selection_more, total_more;
|
|
145
|
|
146 aud_playlist_get_total_time(playlist, &total, &selection, &total_more, &selection_more);
|
|
147
|
|
148 if (selection > 0 || (selection == 0 && !selection_more)) {
|
|
149 if (selection > 3600)
|
|
150 sel_text =
|
|
151 g_strdup_printf("%lu:%-2.2lu:%-2.2lu%s", selection / 3600,
|
|
152 (selection / 60) % 60, selection % 60,
|
|
153 (selection_more ? "+" : ""));
|
|
154 else
|
|
155 sel_text =
|
|
156 g_strdup_printf("%lu:%-2.2lu%s", selection / 60,
|
|
157 selection % 60, (selection_more ? "+" : ""));
|
|
158 }
|
|
159 else
|
|
160 sel_text = g_strdup("?");
|
|
161 if (total > 0 || (total == 0 && !total_more)) {
|
|
162 if (total > 3600)
|
|
163 tot_text =
|
|
164 g_strdup_printf("%lu:%-2.2lu:%-2.2lu%s", total / 3600,
|
|
165 (total / 60) % 60, total % 60,
|
|
166 total_more ? "+" : "");
|
|
167 else
|
|
168 tot_text =
|
|
169 g_strdup_printf("%lu:%-2.2lu%s", total / 60, total % 60,
|
|
170 total_more ? "+" : "");
|
|
171 }
|
|
172 else
|
|
173 tot_text = g_strdup("?");
|
|
174 text = g_strconcat(sel_text, "/", tot_text, NULL);
|
|
175 ui_skinned_textbox_set_text(playlistwin_info, text ? text : "");
|
|
176 g_free(text);
|
|
177 g_free(tot_text);
|
|
178 g_free(sel_text);
|
|
179 #endif
|
|
180 }
|
|
181
|
|
182 static void
|
|
183 playlistwin_update_sinfo(Playlist *playlist)
|
|
184 {
|
|
185 gchar *posstr, *timestr, *title, *info;
|
|
186 gint pos, time;
|
|
187
|
|
188 pos = aud_playlist_get_position(playlist);
|
|
189 title = aud_playlist_get_songtitle(playlist, pos);
|
|
190
|
|
191 if (!title) {
|
|
192 ui_skinned_textbox_set_text(playlistwin_sinfo, "");
|
|
193 return;
|
|
194 }
|
|
195
|
|
196 aud_convert_title_text(title);
|
|
197
|
|
198 time = aud_playlist_get_songtime(playlist, pos);
|
|
199
|
|
200 if (config.show_numbers_in_pl)
|
|
201 posstr = g_strdup_printf("%d. ", pos + 1);
|
|
202 else
|
|
203 posstr = g_strdup("");
|
|
204
|
|
205 if (time != -1) {
|
|
206 timestr = g_strdup_printf(" (%d:%-2.2d)", time / 60000,
|
|
207 (time / 1000) % 60);
|
|
208 }
|
|
209 else
|
|
210 timestr = g_strdup("");
|
|
211
|
|
212 info = g_strdup_printf("%s%s%s", posstr, title, timestr);
|
|
213
|
|
214 g_free(posstr);
|
|
215 g_free(title);
|
|
216 g_free(timestr);
|
|
217
|
|
218 ui_skinned_textbox_set_text(playlistwin_sinfo, info ? info : "");
|
|
219 g_free(info);
|
|
220 }
|
|
221
|
|
222 gboolean
|
|
223 playlistwin_item_visible(gint index)
|
|
224 {
|
|
225 g_return_val_if_fail(UI_SKINNED_IS_PLAYLIST(playlistwin_list), FALSE);
|
|
226
|
|
227 if (index >= UI_SKINNED_PLAYLIST(playlistwin_list)->first &&
|
|
228 index < (UI_SKINNED_PLAYLIST(playlistwin_list)->first + UI_SKINNED_PLAYLIST(playlistwin_list)->num_visible) ) {
|
|
229 return TRUE;
|
|
230 }
|
|
231 return FALSE;
|
|
232 }
|
|
233
|
|
234 gint
|
|
235 playlistwin_list_get_visible_count(void)
|
|
236 {
|
|
237 g_return_val_if_fail(UI_SKINNED_IS_PLAYLIST(playlistwin_list), -1);
|
|
238
|
|
239 return UI_SKINNED_PLAYLIST(playlistwin_list)->num_visible;
|
|
240 }
|
|
241
|
|
242 gint
|
|
243 playlistwin_list_get_first(void)
|
|
244 {
|
|
245 g_return_val_if_fail(UI_SKINNED_IS_PLAYLIST(playlistwin_list), -1);
|
|
246
|
|
247 return UI_SKINNED_PLAYLIST(playlistwin_list)->first;
|
|
248 }
|
|
249
|
|
250 gint
|
|
251 playlistwin_get_toprow(void)
|
|
252 {
|
|
253 g_return_val_if_fail(UI_SKINNED_IS_PLAYLIST(playlistwin_list), -1);
|
|
254
|
|
255 return (UI_SKINNED_PLAYLIST(playlistwin_list)->first);
|
|
256 }
|
|
257
|
|
258 void
|
|
259 playlistwin_set_toprow(gint toprow)
|
|
260 {
|
|
261 if (UI_SKINNED_IS_PLAYLIST(playlistwin_list))
|
|
262 UI_SKINNED_PLAYLIST(playlistwin_list)->first = toprow;
|
|
263 #if 0
|
|
264 g_cond_signal(cond_scan);
|
|
265 #endif
|
|
266 playlistwin_update_list(aud_playlist_get_active());
|
|
267 }
|
|
268
|
|
269 void
|
|
270 playlistwin_update_list(Playlist *playlist)
|
|
271 {
|
|
272 /* this can happen early on. just bail gracefully. */
|
|
273 g_return_if_fail(playlistwin_list);
|
|
274
|
|
275 playlistwin_update_info(playlist);
|
|
276 playlistwin_update_sinfo(playlist);
|
|
277 gtk_widget_queue_draw(playlistwin_list);
|
|
278 gtk_widget_queue_draw(playlistwin_slider);
|
|
279 }
|
|
280
|
|
281 static void
|
|
282 playlistwin_set_geometry_hints(gboolean shaded)
|
|
283 {
|
|
284 GdkGeometry geometry;
|
|
285 GdkWindowHints mask;
|
|
286
|
|
287 geometry.min_width = PLAYLISTWIN_MIN_WIDTH;
|
|
288 geometry.max_width = G_MAXUINT16;
|
|
289
|
|
290 geometry.width_inc = PLAYLISTWIN_WIDTH_SNAP;
|
|
291 geometry.height_inc = PLAYLISTWIN_HEIGHT_SNAP;
|
|
292
|
|
293 if (shaded) {
|
|
294 geometry.min_height = PLAYLISTWIN_SHADED_HEIGHT;
|
|
295 geometry.max_height = PLAYLISTWIN_SHADED_HEIGHT;
|
|
296 geometry.base_height = PLAYLISTWIN_SHADED_HEIGHT;
|
|
297 }
|
|
298 else {
|
|
299 geometry.min_height = PLAYLISTWIN_MIN_HEIGHT;
|
|
300 geometry.max_height = G_MAXUINT16;
|
|
301 }
|
|
302
|
|
303 mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE | GDK_HINT_RESIZE_INC;
|
|
304
|
|
305 gtk_window_set_geometry_hints(GTK_WINDOW(playlistwin),
|
|
306 playlistwin, &geometry, mask);
|
|
307 }
|
|
308
|
|
309 void
|
|
310 playlistwin_set_sinfo_font(gchar *font)
|
|
311 {
|
|
312 gchar *tmp = NULL, *tmp2 = NULL;
|
|
313
|
|
314 g_return_if_fail(font);
|
|
315 AUDDBG("Attempt to set font \"%s\"\n", font);
|
|
316
|
|
317 tmp = g_strdup(font);
|
|
318 g_return_if_fail(tmp);
|
|
319
|
|
320 *strrchr(tmp, ' ') = '\0';
|
|
321 tmp2 = g_strdup_printf("%s 8", tmp);
|
|
322 g_return_if_fail(tmp2);
|
|
323
|
|
324 ui_skinned_textbox_set_xfont(playlistwin_sinfo, !config.mainwin_use_bitmapfont, tmp2);
|
|
325
|
|
326 g_free(tmp);
|
|
327 g_free(tmp2);
|
|
328 }
|
|
329
|
|
330 void
|
|
331 playlistwin_set_sinfo_scroll(gboolean scroll)
|
|
332 {
|
|
333 if(playlistwin_is_shaded())
|
|
334 ui_skinned_textbox_set_scroll(playlistwin_sinfo, config.autoscroll);
|
|
335 else
|
|
336 ui_skinned_textbox_set_scroll(playlistwin_sinfo, FALSE);
|
|
337 }
|
|
338
|
|
339 void
|
|
340 playlistwin_set_shade(gboolean shaded)
|
|
341 {
|
|
342 config.playlist_shaded = shaded;
|
|
343
|
|
344 if (shaded) {
|
|
345 playlistwin_set_sinfo_font(aud_cfg->playlist_font);
|
|
346 playlistwin_set_sinfo_scroll(config.autoscroll);
|
|
347 gtk_widget_show(playlistwin_sinfo);
|
|
348 ui_skinned_set_push_button_data(playlistwin_shade, 128, 45, 150, 42);
|
|
349 ui_skinned_set_push_button_data(playlistwin_close, 138, 45, -1, -1);
|
|
350 }
|
|
351 else {
|
|
352 gtk_widget_hide(playlistwin_sinfo);
|
|
353 playlistwin_set_sinfo_scroll(FALSE);
|
|
354 ui_skinned_set_push_button_data(playlistwin_shade, 157, 3, 62, 42);
|
|
355 ui_skinned_set_push_button_data(playlistwin_close, 167, 3, -1, -1);
|
|
356 }
|
|
357
|
|
358 dock_shade(get_dock_window_list(), GTK_WINDOW(playlistwin),
|
|
359 playlistwin_get_height());
|
|
360
|
|
361 playlistwin_set_geometry_hints(config.playlist_shaded);
|
|
362
|
|
363 gtk_window_resize(GTK_WINDOW(playlistwin),
|
|
364 playlistwin_get_width(),
|
|
365 playlistwin_get_height());
|
|
366 }
|
|
367
|
|
368 static void
|
|
369 playlistwin_set_shade_menu(gboolean shaded)
|
|
370 {
|
|
371 GtkAction *action = gtk_action_group_get_action(
|
|
372 toggleaction_group_others , "roll up playlist editor" );
|
|
373 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(action) , shaded );
|
|
374
|
|
375 playlistwin_set_shade(shaded);
|
|
376 playlistwin_update_list(aud_playlist_get_active());
|
|
377 }
|
|
378
|
|
379 void
|
|
380 playlistwin_shade_toggle(void)
|
|
381 {
|
|
382 playlistwin_set_shade_menu(!config.playlist_shaded);
|
|
383 }
|
|
384
|
|
385 static gboolean
|
|
386 playlistwin_release(GtkWidget * widget,
|
|
387 GdkEventButton * event,
|
|
388 gpointer callback_data)
|
|
389 {
|
|
390 playlistwin_resizing = FALSE;
|
|
391 return FALSE;
|
|
392 }
|
|
393
|
|
394 void
|
|
395 playlistwin_scroll(gint num)
|
|
396 {
|
|
397 if (UI_SKINNED_IS_PLAYLIST(playlistwin_list))
|
|
398 UI_SKINNED_PLAYLIST(playlistwin_list)->first += num;
|
|
399 playlistwin_update_list(aud_playlist_get_active());
|
|
400 }
|
|
401
|
|
402 void
|
|
403 playlistwin_scroll_up_pushed(void)
|
|
404 {
|
|
405 playlistwin_scroll(-3);
|
|
406 }
|
|
407
|
|
408 void
|
|
409 playlistwin_scroll_down_pushed(void)
|
|
410 {
|
|
411 playlistwin_scroll(3);
|
|
412 }
|
|
413
|
|
414 static void
|
|
415 playlistwin_select_all(void)
|
|
416 {
|
|
417 Playlist *playlist = aud_playlist_get_active();
|
|
418
|
|
419 aud_playlist_select_all(playlist, TRUE);
|
|
420 if (UI_SKINNED_IS_PLAYLIST(playlistwin_list)) {
|
|
421 UI_SKINNED_PLAYLIST(playlistwin_list)->prev_selected = 0;
|
|
422 UI_SKINNED_PLAYLIST(playlistwin_list)->prev_min = 0;
|
|
423 UI_SKINNED_PLAYLIST(playlistwin_list)->prev_max = aud_playlist_get_length(playlist) - 1;
|
|
424 }
|
|
425 playlistwin_update_list(playlist);
|
|
426 }
|
|
427
|
|
428 static void
|
|
429 playlistwin_select_none(void)
|
|
430 {
|
|
431 aud_playlist_select_all(aud_playlist_get_active(), FALSE);
|
|
432 if (UI_SKINNED_IS_PLAYLIST(playlistwin_list)) {
|
|
433 UI_SKINNED_PLAYLIST(playlistwin_list)->prev_selected = -1;
|
|
434 UI_SKINNED_PLAYLIST(playlistwin_list)->prev_min = -1;
|
|
435 }
|
|
436 playlistwin_update_list(aud_playlist_get_active());
|
|
437 }
|
|
438
|
|
439 static void
|
|
440 playlistwin_select_search(void)
|
|
441 {
|
|
442 Playlist *playlist = aud_playlist_get_active();
|
|
443 GtkWidget *searchdlg_win, *searchdlg_table;
|
|
444 GtkWidget *searchdlg_hbox, *searchdlg_logo, *searchdlg_helptext;
|
|
445 GtkWidget *searchdlg_entry_title, *searchdlg_label_title;
|
|
446 GtkWidget *searchdlg_entry_album, *searchdlg_label_album;
|
|
447 GtkWidget *searchdlg_entry_file_name, *searchdlg_label_file_name;
|
|
448 GtkWidget *searchdlg_entry_performer, *searchdlg_label_performer;
|
|
449 GtkWidget *searchdlg_checkbt_clearprevsel;
|
|
450 GtkWidget *searchdlg_checkbt_newplaylist;
|
|
451 GtkWidget *searchdlg_checkbt_autoenqueue;
|
|
452 gint result;
|
|
453
|
|
454 /* create dialog */
|
|
455 searchdlg_win = gtk_dialog_new_with_buttons(
|
|
456 _("Search entries in active playlist") , GTK_WINDOW(mainwin) ,
|
|
457 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT ,
|
|
458 GTK_STOCK_CANCEL , GTK_RESPONSE_REJECT , GTK_STOCK_OK , GTK_RESPONSE_ACCEPT , NULL );
|
|
459 gtk_window_set_position(GTK_WINDOW(searchdlg_win), GTK_WIN_POS_CENTER);
|
|
460
|
|
461 /* help text and logo */
|
|
462 searchdlg_hbox = gtk_hbox_new( FALSE , 4 );
|
|
463 searchdlg_logo = gtk_image_new_from_stock( GTK_STOCK_FIND , GTK_ICON_SIZE_DIALOG );
|
|
464 searchdlg_helptext = gtk_label_new( _("Select entries in playlist by filling one or more "
|
|
465 "fields. Fields use regular expressions syntax, case-insensitive. If you don't know how "
|
|
466 "regular expressions work, simply insert a literal portion of what you're searching for.") );
|
|
467 gtk_label_set_line_wrap( GTK_LABEL(searchdlg_helptext) , TRUE );
|
|
468 gtk_box_pack_start( GTK_BOX(searchdlg_hbox) , searchdlg_logo , FALSE , FALSE , 0 );
|
|
469 gtk_box_pack_start( GTK_BOX(searchdlg_hbox) , searchdlg_helptext , FALSE , FALSE , 0 );
|
|
470
|
|
471 /* title */
|
|
472 searchdlg_label_title = gtk_label_new( _("Title: ") );
|
|
473 searchdlg_entry_title = gtk_entry_new();
|
|
474 gtk_misc_set_alignment( GTK_MISC(searchdlg_label_title) , 0 , 0.5 );
|
|
475 g_signal_connect( G_OBJECT(searchdlg_entry_title) , "key-press-event" ,
|
|
476 G_CALLBACK(playlistwin_select_search_kp_cb) , searchdlg_win );
|
|
477
|
|
478 /* album */
|
|
479 searchdlg_label_album= gtk_label_new( _("Album: ") );
|
|
480 searchdlg_entry_album= gtk_entry_new();
|
|
481 gtk_misc_set_alignment( GTK_MISC(searchdlg_label_album) , 0 , 0.5 );
|
|
482 g_signal_connect( G_OBJECT(searchdlg_entry_album) , "key-press-event" ,
|
|
483 G_CALLBACK(playlistwin_select_search_kp_cb) , searchdlg_win );
|
|
484
|
|
485 /* artist */
|
|
486 searchdlg_label_performer = gtk_label_new( _("Artist: ") );
|
|
487 searchdlg_entry_performer = gtk_entry_new();
|
|
488 gtk_misc_set_alignment( GTK_MISC(searchdlg_label_performer) , 0 , 0.5 );
|
|
489 g_signal_connect( G_OBJECT(searchdlg_entry_performer) , "key-press-event" ,
|
|
490 G_CALLBACK(playlistwin_select_search_kp_cb) , searchdlg_win );
|
|
491
|
|
492 /* file name */
|
|
493 searchdlg_label_file_name = gtk_label_new( _("Filename: ") );
|
|
494 searchdlg_entry_file_name = gtk_entry_new();
|
|
495 gtk_misc_set_alignment( GTK_MISC(searchdlg_label_file_name) , 0 , 0.5 );
|
|
496 g_signal_connect( G_OBJECT(searchdlg_entry_file_name) , "key-press-event" ,
|
|
497 G_CALLBACK(playlistwin_select_search_kp_cb) , searchdlg_win );
|
|
498
|
|
499 /* some options that control behaviour */
|
|
500 searchdlg_checkbt_clearprevsel = gtk_check_button_new_with_label(
|
|
501 _("Clear previous selection before searching") );
|
|
502 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(searchdlg_checkbt_clearprevsel) , TRUE );
|
|
503 searchdlg_checkbt_autoenqueue = gtk_check_button_new_with_label(
|
|
504 _("Automatically toggle queue for matching entries") );
|
|
505 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(searchdlg_checkbt_autoenqueue) , FALSE );
|
|
506 searchdlg_checkbt_newplaylist = gtk_check_button_new_with_label(
|
|
507 _("Create a new playlist with matching entries") );
|
|
508 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(searchdlg_checkbt_newplaylist) , FALSE );
|
|
509 g_signal_connect( G_OBJECT(searchdlg_checkbt_autoenqueue) , "clicked" ,
|
|
510 G_CALLBACK(playlistwin_select_search_cbt_cb) , searchdlg_checkbt_newplaylist );
|
|
511 g_signal_connect( G_OBJECT(searchdlg_checkbt_newplaylist) , "clicked" ,
|
|
512 G_CALLBACK(playlistwin_select_search_cbt_cb) , searchdlg_checkbt_autoenqueue );
|
|
513
|
|
514 /* place fields in searchdlg_table */
|
|
515 searchdlg_table = gtk_table_new( 8 , 2 , FALSE );
|
|
516 gtk_table_set_row_spacing( GTK_TABLE(searchdlg_table) , 0 , 8 );
|
|
517 gtk_table_set_row_spacing( GTK_TABLE(searchdlg_table) , 4 , 8 );
|
|
518 gtk_table_attach( GTK_TABLE(searchdlg_table) , searchdlg_hbox ,
|
|
519 0 , 2 , 0 , 1 , GTK_FILL | GTK_EXPAND , GTK_FILL | GTK_EXPAND , 0 , 2 );
|
|
520 gtk_table_attach( GTK_TABLE(searchdlg_table) , searchdlg_label_title ,
|
|
521 0 , 1 , 1 , 2 , GTK_FILL , GTK_FILL | GTK_EXPAND , 0 , 2 );
|
|
522 gtk_table_attach( GTK_TABLE(searchdlg_table) , searchdlg_entry_title ,
|
|
523 1 , 2 , 1 , 2 , GTK_FILL | GTK_EXPAND , GTK_FILL | GTK_EXPAND , 0 , 2 );
|
|
524 gtk_table_attach( GTK_TABLE(searchdlg_table) , searchdlg_label_album,
|
|
525 0 , 1 , 2 , 3 , GTK_FILL , GTK_FILL | GTK_EXPAND , 0 , 2 );
|
|
526 gtk_table_attach( GTK_TABLE(searchdlg_table) , searchdlg_entry_album,
|
|
527 1 , 2 , 2 , 3 , GTK_FILL | GTK_EXPAND , GTK_FILL | GTK_EXPAND , 0 , 2 );
|
|
528 gtk_table_attach( GTK_TABLE(searchdlg_table) , searchdlg_label_performer ,
|
|
529 0 , 1 , 3 , 4 , GTK_FILL , GTK_FILL | GTK_EXPAND , 0 , 2 );
|
|
530 gtk_table_attach( GTK_TABLE(searchdlg_table) , searchdlg_entry_performer ,
|
|
531 1 , 2 , 3 , 4 , GTK_FILL | GTK_EXPAND , GTK_FILL | GTK_EXPAND , 0 , 2 );
|
|
532 gtk_table_attach( GTK_TABLE(searchdlg_table) , searchdlg_label_file_name ,
|
|
533 0 , 1 , 4 , 5 , GTK_FILL , GTK_FILL | GTK_EXPAND , 0 , 2 );
|
|
534 gtk_table_attach( GTK_TABLE(searchdlg_table) , searchdlg_entry_file_name ,
|
|
535 1 , 2 , 4 , 5 , GTK_FILL | GTK_EXPAND , GTK_FILL | GTK_EXPAND , 0 , 2 );
|
|
536 gtk_table_attach( GTK_TABLE(searchdlg_table) , searchdlg_checkbt_clearprevsel ,
|
|
537 0 , 2 , 5 , 6 , GTK_FILL | GTK_EXPAND , GTK_FILL | GTK_EXPAND , 0 , 1 );
|
|
538 gtk_table_attach( GTK_TABLE(searchdlg_table) , searchdlg_checkbt_autoenqueue ,
|
|
539 0 , 2 , 6 , 7 , GTK_FILL | GTK_EXPAND , GTK_FILL | GTK_EXPAND , 0 , 1 );
|
|
540 gtk_table_attach( GTK_TABLE(searchdlg_table) , searchdlg_checkbt_newplaylist ,
|
|
541 0 , 2 , 7 , 8 , GTK_FILL | GTK_EXPAND , GTK_FILL | GTK_EXPAND , 0 , 1 );
|
|
542
|
|
543 gtk_container_set_border_width( GTK_CONTAINER(searchdlg_table) , 5 );
|
|
544 gtk_container_add( GTK_CONTAINER(GTK_DIALOG(searchdlg_win)->vbox) , searchdlg_table );
|
|
545 gtk_widget_show_all( searchdlg_win );
|
|
546 result = gtk_dialog_run( GTK_DIALOG(searchdlg_win) );
|
|
547 switch(result)
|
|
548 {
|
|
549 case GTK_RESPONSE_ACCEPT:
|
|
550 {
|
|
551 gint matched_entries_num = 0;
|
|
552 /* create a TitleInput tuple with user search data */
|
|
553 Tuple *tuple = aud_tuple_new();
|
|
554 gchar *searchdata = NULL;
|
|
555
|
|
556 searchdata = (gchar*)gtk_entry_get_text( GTK_ENTRY(searchdlg_entry_title) );
|
|
557 AUDDBG("title=\"%s\"\n", searchdata);
|
|
558 aud_tuple_associate_string(tuple, FIELD_TITLE, NULL, searchdata);
|
|
559
|
|
560 searchdata = (gchar*)gtk_entry_get_text( GTK_ENTRY(searchdlg_entry_album) );
|
|
561 AUDDBG("album=\"%s\"\n", searchdata);
|
|
562 aud_tuple_associate_string(tuple, FIELD_ALBUM, NULL, searchdata);
|
|
563
|
|
564 searchdata = (gchar*)gtk_entry_get_text( GTK_ENTRY(searchdlg_entry_performer) );
|
|
565 AUDDBG("performer=\"%s\"\n", searchdata);
|
|
566 aud_tuple_associate_string(tuple, FIELD_ARTIST, NULL, searchdata);
|
|
567
|
|
568 searchdata = (gchar*)gtk_entry_get_text( GTK_ENTRY(searchdlg_entry_file_name) );
|
|
569 AUDDBG("filename=\"%s\"\n", searchdata);
|
|
570 aud_tuple_associate_string(tuple, FIELD_FILE_NAME, NULL, searchdata);
|
|
571
|
|
572 /* check if previous selection should be cleared before searching */
|
|
573 if ( gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(searchdlg_checkbt_clearprevsel)) == TRUE )
|
|
574 playlistwin_select_none();
|
|
575 /* now send this tuple to the real search function */
|
|
576 matched_entries_num = aud_playlist_select_search( playlist , tuple , 0 );
|
|
577 /* we do not need the tuple and its data anymore */
|
|
578 mowgli_object_unref(tuple);
|
|
579 playlistwin_update_list(aud_playlist_get_active());
|
|
580 /* check if a new playlist should be created after searching */
|
|
581 if ( gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(searchdlg_checkbt_newplaylist)) == TRUE )
|
|
582 aud_playlist_new_from_selected();
|
|
583 /* check if matched entries should be queued */
|
|
584 else if ( gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(searchdlg_checkbt_autoenqueue)) == TRUE )
|
|
585 aud_playlist_queue(aud_playlist_get_active());
|
|
586 break;
|
|
587 }
|
|
588 default:
|
|
589 break;
|
|
590 }
|
|
591 /* done here :) */
|
|
592 gtk_widget_destroy( searchdlg_win );
|
|
593 }
|
|
594
|
|
595 static void
|
|
596 playlistwin_inverse_selection(void)
|
|
597 {
|
|
598 aud_playlist_select_invert_all(aud_playlist_get_active());
|
|
599 if (UI_SKINNED_IS_PLAYLIST(playlistwin_list)) {
|
|
600 UI_SKINNED_PLAYLIST(playlistwin_list)->prev_selected = -1;
|
|
601 UI_SKINNED_PLAYLIST(playlistwin_list)->prev_min = -1;
|
|
602 }
|
|
603 playlistwin_update_list(aud_playlist_get_active());
|
|
604 }
|
|
605
|
|
606 static void
|
|
607 playlistwin_resize(gint width, gint height)
|
|
608 {
|
|
609 gint tx, ty;
|
|
610 gint dx, dy;
|
|
611
|
|
612 g_return_if_fail(width > 0 && height > 0);
|
|
613
|
|
614 tx = (width - PLAYLISTWIN_MIN_WIDTH) / PLAYLISTWIN_WIDTH_SNAP;
|
|
615 tx = (tx * PLAYLISTWIN_WIDTH_SNAP) + PLAYLISTWIN_MIN_WIDTH;
|
|
616 if (tx < PLAYLISTWIN_MIN_WIDTH)
|
|
617 tx = PLAYLISTWIN_MIN_WIDTH;
|
|
618
|
|
619 if (!config.playlist_shaded)
|
|
620 {
|
|
621 ty = (height - PLAYLISTWIN_MIN_HEIGHT) / PLAYLISTWIN_HEIGHT_SNAP;
|
|
622 ty = (ty * PLAYLISTWIN_HEIGHT_SNAP) + PLAYLISTWIN_MIN_HEIGHT;
|
|
623 if (ty < PLAYLISTWIN_MIN_HEIGHT)
|
|
624 ty = PLAYLISTWIN_MIN_HEIGHT;
|
|
625 }
|
|
626 else
|
|
627 ty = config.playlist_height;
|
|
628
|
|
629 if (tx == config.playlist_width && ty == config.playlist_height)
|
|
630 return;
|
|
631
|
|
632 /* difference between previous size and new size */
|
|
633 dx = tx - config.playlist_width;
|
|
634 dy = ty - config.playlist_height;
|
|
635
|
|
636 config.playlist_width = width = tx;
|
|
637 config.playlist_height = height = ty;
|
|
638
|
|
639 g_mutex_lock(resize_mutex);
|
|
640 ui_skinned_playlist_resize_relative(playlistwin_list, dx, dy);
|
|
641
|
|
642 ui_skinned_playlist_slider_move_relative(playlistwin_slider, dx);
|
|
643 ui_skinned_playlist_slider_resize_relative(playlistwin_slider, dy);
|
|
644
|
|
645 playlistwin_update_sinfo(aud_playlist_get_active());
|
|
646
|
|
647 ui_skinned_button_move_relative(playlistwin_shade, dx, 0);
|
|
648 ui_skinned_button_move_relative(playlistwin_close, dx, 0);
|
|
649 ui_skinned_textbox_move_relative(playlistwin_time_min, dx, dy);
|
|
650 ui_skinned_textbox_move_relative(playlistwin_time_sec, dx, dy);
|
|
651 ui_skinned_textbox_move_relative(playlistwin_info, dx, dy);
|
|
652 ui_skinned_button_move_relative(playlistwin_srew, dx, dy);
|
|
653 ui_skinned_button_move_relative(playlistwin_splay, dx, dy);
|
|
654 ui_skinned_button_move_relative(playlistwin_spause, dx, dy);
|
|
655 ui_skinned_button_move_relative(playlistwin_sstop, dx, dy);
|
|
656 ui_skinned_button_move_relative(playlistwin_sfwd, dx, dy);
|
|
657 ui_skinned_button_move_relative(playlistwin_seject, dx, dy);
|
|
658 ui_skinned_button_move_relative(playlistwin_sscroll_up, dx, dy);
|
|
659 ui_skinned_button_move_relative(playlistwin_sscroll_down, dx, dy);
|
|
660
|
|
661 gtk_widget_set_size_request(playlistwin_sinfo, playlistwin_get_width() - 35,
|
|
662 aud_active_skin->properties.textbox_bitmap_font_height);
|
|
663 GList *iter;
|
|
664 for (iter = GTK_FIXED (SKINNED_WINDOW(playlistwin)->fixed)->children; iter; iter = g_list_next (iter)) {
|
|
665 GtkFixedChild *child_data = (GtkFixedChild *) iter->data;
|
|
666 GtkWidget *child = child_data->widget;
|
|
667 g_signal_emit_by_name(child, "redraw");
|
|
668 }
|
|
669 g_mutex_unlock(resize_mutex);
|
|
670 }
|
|
671
|
|
672 static void
|
|
673 playlistwin_motion(GtkWidget * widget,
|
|
674 GdkEventMotion * event,
|
|
675 gpointer callback_data)
|
|
676 {
|
|
677 GdkEvent *gevent;
|
|
678
|
|
679 /*
|
|
680 * GDK2's resize is broken and doesn't really play nice, so we have
|
|
681 * to do all of this stuff by hand.
|
|
682 */
|
|
683 if (playlistwin_resizing == TRUE)
|
|
684 {
|
|
685 if (event->x + playlistwin_resize_x != playlistwin_get_width() ||
|
|
686 event->y + playlistwin_resize_y != playlistwin_get_height())
|
|
687 {
|
|
688 playlistwin_resize(event->x + playlistwin_resize_x,
|
|
689 event->y + playlistwin_resize_y);
|
|
690 gdk_window_resize(playlistwin->window,
|
|
691 config.playlist_width, playlistwin_get_height());
|
|
692 gdk_flush();
|
|
693 }
|
|
694 }
|
|
695 else if (dock_is_moving(GTK_WINDOW(playlistwin)))
|
|
696 dock_move_motion(GTK_WINDOW(playlistwin), event);
|
|
697
|
|
698 while ((gevent = gdk_event_get()) != NULL) gdk_event_free(gevent);
|
|
699 }
|
|
700
|
|
701 static void
|
|
702 playlistwin_show_filebrowser(void)
|
|
703 {
|
|
704 #if 0
|
|
705 run_filebrowser(NO_PLAY_BUTTON);
|
|
706 #endif
|
|
707 }
|
|
708
|
|
709 static void
|
|
710 playlistwin_fileinfo(void)
|
|
711 {
|
|
712 #if 0
|
|
713 Playlist *playlist = aud_playlist_get_active();
|
|
714
|
|
715 /* Show the first selected file, or the current file if nothing is
|
|
716 * selected */
|
|
717 GList *list = aud_playlist_get_selected(playlist);
|
|
718 if (list) {
|
|
719 ui_fileinfo_show(playlist, GPOINTER_TO_INT(list->data));
|
|
720 g_list_free(list);
|
|
721 }
|
|
722 else
|
|
723
|
|
724 ui_fileinfo_show_current(playlist);
|
|
725 #endif
|
|
726 }
|
|
727
|
|
728 static void
|
|
729 show_playlist_save_error(GtkWindow *parent,
|
|
730 const gchar *filename)
|
|
731 {
|
|
732 GtkWidget *dialog;
|
|
733
|
|
734 g_return_if_fail(GTK_IS_WINDOW(parent));
|
|
735 g_return_if_fail(filename);
|
|
736
|
|
737 dialog = gtk_message_dialog_new(GTK_WINDOW(parent),
|
|
738 GTK_DIALOG_DESTROY_WITH_PARENT,
|
|
739 GTK_MESSAGE_ERROR,
|
|
740 GTK_BUTTONS_OK,
|
|
741 _("Error writing playlist \"%s\": %s"),
|
|
742 filename, strerror(errno));
|
|
743
|
|
744 gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER); /* centering */
|
|
745 gtk_dialog_run(GTK_DIALOG(dialog));
|
|
746 gtk_widget_destroy(dialog);
|
|
747 }
|
|
748
|
|
749 static gboolean
|
|
750 show_playlist_overwrite_prompt(GtkWindow * parent,
|
|
751 const gchar * filename)
|
|
752 {
|
|
753 GtkWidget *dialog;
|
|
754 gint result;
|
|
755
|
|
756 g_return_val_if_fail(GTK_IS_WINDOW(parent), FALSE);
|
|
757 g_return_val_if_fail(filename != NULL, FALSE);
|
|
758
|
|
759 dialog = gtk_message_dialog_new(GTK_WINDOW(parent),
|
|
760 GTK_DIALOG_DESTROY_WITH_PARENT,
|
|
761 GTK_MESSAGE_QUESTION,
|
|
762 GTK_BUTTONS_YES_NO,
|
|
763 _("%s already exist. Continue?"),
|
|
764 filename);
|
|
765
|
|
766 gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER); /* centering */
|
|
767 result = gtk_dialog_run(GTK_DIALOG(dialog));
|
|
768 gtk_widget_destroy(dialog);
|
|
769
|
|
770 return (result == GTK_RESPONSE_YES);
|
|
771 }
|
|
772
|
|
773 static void
|
|
774 show_playlist_save_format_error(GtkWindow * parent,
|
|
775 const gchar * filename)
|
|
776 {
|
|
777 const gchar *markup =
|
|
778 N_("<b><big>Unable to save playlist.</big></b>\n\n"
|
|
779 "Unknown file type for '%s'.\n");
|
|
780
|
|
781 GtkWidget *dialog;
|
|
782
|
|
783 g_return_if_fail(GTK_IS_WINDOW(parent));
|
|
784 g_return_if_fail(filename != NULL);
|
|
785
|
|
786 dialog =
|
|
787 gtk_message_dialog_new_with_markup(GTK_WINDOW(parent),
|
|
788 GTK_DIALOG_DESTROY_WITH_PARENT,
|
|
789 GTK_MESSAGE_ERROR,
|
|
790 GTK_BUTTONS_OK,
|
|
791 _(markup),
|
|
792 filename);
|
|
793
|
|
794 gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER); /* centering */
|
|
795 gtk_dialog_run(GTK_DIALOG(dialog));
|
|
796 gtk_widget_destroy(dialog);
|
|
797 }
|
|
798
|
|
799 static void
|
|
800 playlistwin_save_playlist(const gchar * filename)
|
|
801 {
|
|
802 PlaylistContainer *plc;
|
|
803 gchar *ext = strrchr(filename, '.') + 1;
|
|
804
|
|
805 plc = aud_playlist_container_find(ext);
|
|
806 if (plc == NULL) {
|
|
807 show_playlist_save_format_error(GTK_WINDOW(playlistwin), filename);
|
|
808 return;
|
|
809 }
|
|
810
|
|
811 aud_str_replace_in(&aud_cfg->playlist_path, g_path_get_dirname(filename));
|
|
812
|
|
813 if (g_file_test(filename, G_FILE_TEST_IS_REGULAR))
|
|
814 if (!show_playlist_overwrite_prompt(GTK_WINDOW(playlistwin), filename))
|
|
815 return;
|
|
816
|
|
817 if (!aud_playlist_save(aud_playlist_get_active(), filename))
|
|
818 show_playlist_save_error(GTK_WINDOW(playlistwin), filename);
|
|
819 }
|
|
820
|
|
821 static void
|
|
822 playlistwin_load_playlist(const gchar * filename)
|
|
823 {
|
|
824 const gchar *title;
|
|
825 Playlist *playlist = aud_playlist_get_active();
|
|
826
|
|
827 g_return_if_fail(filename != NULL);
|
|
828
|
|
829 aud_str_replace_in(&aud_cfg->playlist_path, g_path_get_dirname(filename));
|
|
830
|
|
831 aud_playlist_clear(playlist);
|
|
832 mainwin_clear_song_info();
|
|
833
|
|
834 aud_playlist_load(playlist, filename);
|
|
835 title = aud_playlist_get_current_name(playlist);
|
|
836 if(!title || !title[0])
|
|
837 aud_playlist_set_current_name(playlist, filename);
|
|
838 }
|
|
839
|
|
840 static gchar *
|
|
841 playlist_file_selection_load(const gchar * title,
|
|
842 const gchar * default_filename)
|
|
843 {
|
|
844 GtkWidget *dialog;
|
|
845 gchar *filename;
|
|
846
|
|
847 g_return_val_if_fail(title != NULL, NULL);
|
|
848
|
|
849 dialog = make_filebrowser(title, FALSE);
|
|
850 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), aud_cfg->playlist_path);
|
|
851 if (default_filename)
|
|
852 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), default_filename);
|
|
853 gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER); /* centering */
|
|
854
|
|
855 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
|
|
856 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
|
|
857 else
|
|
858 filename = NULL;
|
|
859
|
|
860 gtk_widget_destroy(dialog);
|
|
861 return filename;
|
|
862 }
|
|
863
|
|
864 static void
|
|
865 on_static_toggle(GtkToggleButton *button, gpointer data)
|
|
866 {
|
|
867 Playlist *playlist = aud_playlist_get_active();
|
|
868
|
|
869 playlist->attribute =
|
|
870 gtk_toggle_button_get_active(button) ?
|
|
871 playlist->attribute | PLAYLIST_STATIC :
|
|
872 playlist->attribute & ~PLAYLIST_STATIC;
|
|
873 }
|
|
874
|
|
875 static void
|
|
876 on_relative_toggle(GtkToggleButton *button, gpointer data)
|
|
877 {
|
|
878 Playlist *playlist = aud_playlist_get_active();
|
|
879
|
|
880 playlist->attribute =
|
|
881 gtk_toggle_button_get_active(button) ?
|
|
882 playlist->attribute | PLAYLIST_USE_RELATIVE :
|
|
883 playlist->attribute & ~PLAYLIST_USE_RELATIVE;
|
|
884 }
|
|
885
|
|
886 static gchar *
|
|
887 playlist_file_selection_save(const gchar * title,
|
|
888 const gchar * default_filename)
|
|
889 {
|
|
890 GtkWidget *dialog;
|
|
891 gchar *filename;
|
|
892 GtkWidget *hbox;
|
|
893 GtkWidget *toggle, *toggle2;
|
|
894
|
|
895 g_return_val_if_fail(title != NULL, NULL);
|
|
896
|
|
897 dialog = make_filebrowser(title, TRUE);
|
|
898 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), aud_cfg->playlist_path);
|
|
899 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), default_filename);
|
|
900
|
|
901 hbox = gtk_hbox_new(FALSE, 5);
|
|
902
|
|
903 /* static playlist */
|
|
904 toggle = gtk_check_button_new_with_label(_("Save as Static Playlist"));
|
|
905 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle),
|
|
906 (aud_playlist_get_active()->attribute & PLAYLIST_STATIC) ? TRUE : FALSE);
|
|
907 g_signal_connect(G_OBJECT(toggle), "toggled", G_CALLBACK(on_static_toggle), dialog);
|
|
908 gtk_box_pack_start(GTK_BOX(hbox), toggle, FALSE, FALSE, 0);
|
|
909
|
|
910 /* use relative path */
|
|
911 toggle2 = gtk_check_button_new_with_label(_("Use Relative Path"));
|
|
912 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle2),
|
|
913 (aud_playlist_get_active()->attribute & PLAYLIST_USE_RELATIVE) ? TRUE : FALSE);
|
|
914 g_signal_connect(G_OBJECT(toggle2), "toggled", G_CALLBACK(on_relative_toggle), dialog);
|
|
915 gtk_box_pack_start(GTK_BOX(hbox), toggle2, FALSE, FALSE, 0);
|
|
916
|
|
917 gtk_widget_show_all(hbox);
|
|
918 gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(dialog), hbox);
|
|
919
|
|
920 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
|
|
921 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
|
|
922 else
|
|
923 filename = NULL;
|
|
924
|
|
925 gtk_widget_destroy(dialog);
|
|
926 return filename;
|
|
927 }
|
|
928
|
|
929 void
|
|
930 playlistwin_select_playlist_to_load(const gchar * default_filename)
|
|
931 {
|
|
932 gchar *filename =
|
|
933 playlist_file_selection_load(_("Load Playlist"), default_filename);
|
|
934
|
|
935 if (filename) {
|
|
936 playlistwin_load_playlist(filename);
|
|
937 g_free(filename);
|
|
938 }
|
|
939 }
|
|
940
|
|
941 static void
|
|
942 playlistwin_select_playlist_to_save(const gchar * default_filename)
|
|
943 {
|
|
944 gchar *dot = NULL, *basename = NULL;
|
|
945 gchar *filename =
|
|
946 playlist_file_selection_save(_("Save Playlist"), default_filename);
|
|
947
|
|
948 if (filename) {
|
|
949 /* Default extension */
|
|
950 basename = g_path_get_basename(filename);
|
|
951 dot = strrchr(basename, '.');
|
|
952 if( dot == NULL || dot == basename) {
|
|
953 gchar *oldname = filename;
|
|
954 #ifdef HAVE_XSPF_PLAYLIST
|
|
955 filename = g_strconcat(oldname, ".xspf", NULL);
|
|
956 #else
|
|
957 filename = g_strconcat(oldname, ".m3u", NULL);
|
|
958 #endif
|
|
959 g_free(oldname);
|
|
960 }
|
|
961 g_free(basename);
|
|
962
|
|
963 playlistwin_save_playlist(filename);
|
|
964 g_free(filename);
|
|
965 }
|
|
966 }
|
|
967
|
|
968 #define REGION_L(x1,x2,y1,y2) \
|
|
969 (event->x >= (x1) && event->x < (x2) && \
|
|
970 event->y >= config.playlist_height - (y1) && \
|
|
971 event->y < config.playlist_height - (y2))
|
|
972
|
|
973 #define REGION_R(x1,x2,y1,y2) \
|
|
974 (event->x >= playlistwin_get_width() - (x1) && \
|
|
975 event->x < playlistwin_get_width() - (x2) && \
|
|
976 event->y >= config.playlist_height - (y1) && \
|
|
977 event->y < config.playlist_height - (y2))
|
|
978
|
|
979 static void
|
|
980 playlistwin_scrolled(GtkWidget * widget,
|
|
981 GdkEventScroll * event,
|
|
982 gpointer callback_data)
|
|
983 {
|
|
984 if (event->direction == GDK_SCROLL_DOWN)
|
|
985 playlistwin_scroll(config.scroll_pl_by);
|
|
986
|
|
987 if (event->direction == GDK_SCROLL_UP)
|
|
988 playlistwin_scroll(-config.scroll_pl_by);
|
|
989 #if 0
|
|
990 g_cond_signal(cond_scan);
|
|
991 #endif
|
|
992 }
|
|
993
|
|
994 static gboolean
|
|
995 playlistwin_press(GtkWidget * widget,
|
|
996 GdkEventButton * event,
|
|
997 gpointer callback_data)
|
|
998 {
|
|
999 gint xpos, ypos;
|
|
1000 GtkRequisition req;
|
|
1001
|
|
1002 gtk_window_get_position(GTK_WINDOW(playlistwin), &xpos, &ypos);
|
|
1003
|
|
1004 if (event->button == 1 && !config.show_wm_decorations &&
|
|
1005 ((!config.playlist_shaded &&
|
|
1006 event->x > playlistwin_get_width() - 20 &&
|
|
1007 event->y > config.playlist_height - 20) ||
|
|
1008 (config.playlist_shaded &&
|
|
1009 event->x >= playlistwin_get_width() - 31 &&
|
|
1010 event->x < playlistwin_get_width() - 22))) {
|
|
1011
|
|
1012 if (event->type != GDK_2BUTTON_PRESS &&
|
|
1013 event->type != GDK_3BUTTON_PRESS) {
|
|
1014 playlistwin_resizing = TRUE;
|
|
1015 playlistwin_resize_x = config.playlist_width - event->x;
|
|
1016 playlistwin_resize_y = config.playlist_height - event->y;
|
|
1017 }
|
|
1018 }
|
|
1019 else if (event->button == 1 && REGION_L(12, 37, 29, 11)) {
|
|
1020 /* ADD button menu */
|
|
1021 gtk_widget_size_request(playlistwin_pladd_menu, &req);
|
|
1022 ui_manager_popup_menu_show(GTK_MENU(playlistwin_pladd_menu),
|
|
1023 xpos + 12,
|
|
1024 (ypos + playlistwin_get_height()) - 8 - req.height,
|
|
1025 event->button,
|
|
1026 event->time);
|
|
1027 }
|
|
1028 else if (event->button == 1 && REGION_L(41, 66, 29, 11)) {
|
|
1029 /* SUB button menu */
|
|
1030 gtk_widget_size_request(playlistwin_pldel_menu, &req);
|
|
1031 ui_manager_popup_menu_show(GTK_MENU(playlistwin_pldel_menu),
|
|
1032 xpos + 40,
|
|
1033 (ypos + playlistwin_get_height()) - 8 - req.height,
|
|
1034 event->button,
|
|
1035 event->time);
|
|
1036 }
|
|
1037 else if (event->button == 1 && REGION_L(70, 95, 29, 11)) {
|
|
1038 /* SEL button menu */
|
|
1039 gtk_widget_size_request(playlistwin_plsel_menu, &req);
|
|
1040 ui_manager_popup_menu_show(GTK_MENU(playlistwin_plsel_menu),
|
|
1041 xpos + 68,
|
|
1042 (ypos + playlistwin_get_height()) - 8 - req.height,
|
|
1043 event->button,
|
|
1044 event->time);
|
|
1045 }
|
|
1046 else if (event->button == 1 && REGION_L(99, 124, 29, 11)) {
|
|
1047 /* MISC button menu */
|
|
1048 gtk_widget_size_request(playlistwin_plsort_menu, &req);
|
|
1049 ui_manager_popup_menu_show(GTK_MENU(playlistwin_plsort_menu),
|
|
1050 xpos + 100,
|
|
1051 (ypos + playlistwin_get_height()) - 8 - req.height,
|
|
1052 event->button,
|
|
1053 event->time);
|
|
1054 }
|
|
1055 else if (event->button == 1 && REGION_R(46, 23, 29, 11)) {
|
|
1056 /* LIST button menu */
|
|
1057 gtk_widget_size_request(playlistwin_pllist_menu, &req);
|
|
1058 ui_manager_popup_menu_show(GTK_MENU(playlistwin_pllist_menu),
|
|
1059 xpos + playlistwin_get_width() - req.width - 12,
|
|
1060 (ypos + playlistwin_get_height()) - 8 - req.height,
|
|
1061 event->button,
|
|
1062 event->time);
|
|
1063 }
|
|
1064 else if (event->button == 1 && event->type == GDK_BUTTON_PRESS &&
|
|
1065 (config.easy_move || event->y < 14))
|
|
1066 {
|
|
1067 return FALSE;
|
|
1068 }
|
|
1069 else if (event->button == 1 && event->type == GDK_2BUTTON_PRESS
|
|
1070 && event->y < 14) {
|
|
1071 /* double click on title bar */
|
|
1072 playlistwin_shade_toggle();
|
|
1073 if (dock_is_moving(GTK_WINDOW(playlistwin)))
|
|
1074 dock_move_release(GTK_WINDOW(playlistwin));
|
|
1075 return TRUE;
|
|
1076 }
|
|
1077 else if (event->button == 3) {
|
|
1078 /*
|
|
1079 * Pop up the main menu a few pixels down to avoid
|
|
1080 * anything to be selected initially.
|
|
1081 */
|
|
1082 ui_manager_popup_menu_show(GTK_MENU(mainwin_general_menu), event->x_root,
|
|
1083 event->y_root + 2, 3, event->time);
|
|
1084 }
|
|
1085
|
|
1086 return TRUE;
|
|
1087 }
|
|
1088
|
|
1089 static gboolean
|
|
1090 playlistwin_delete(GtkWidget * w, gpointer data)
|
|
1091 {
|
|
1092 playlistwin_hide();
|
|
1093 return TRUE;
|
|
1094 }
|
|
1095
|
|
1096 static gboolean
|
|
1097 playlistwin_keypress_up_down_handler(UiSkinnedPlaylist * pl,
|
|
1098 gboolean up, guint state)
|
|
1099 {
|
|
1100 Playlist *playlist = aud_playlist_get_active();
|
|
1101 if ((!(pl->prev_selected || pl->first) && up) ||
|
|
1102 ((pl->prev_selected >= aud_playlist_get_length(playlist) - 1) && !up))
|
|
1103 return FALSE;
|
|
1104
|
|
1105 if ((state & GDK_MOD1_MASK) && (state & GDK_SHIFT_MASK))
|
|
1106 return FALSE;
|
|
1107 if (!(state & GDK_MOD1_MASK))
|
|
1108 aud_playlist_select_all(playlist, FALSE);
|
|
1109
|
|
1110 if (pl->prev_selected == -1 ||
|
|
1111 (!playlistwin_item_visible(pl->prev_selected) &&
|
|
1112 !(state & GDK_SHIFT_MASK && pl->prev_min != -1))) {
|
|
1113 pl->prev_selected = pl->first;
|
|
1114 }
|
|
1115 else if (state & GDK_SHIFT_MASK) {
|
|
1116 if (pl->prev_min == -1) {
|
|
1117 pl->prev_max = pl->prev_selected;
|
|
1118 pl->prev_min = pl->prev_selected;
|
|
1119 }
|
|
1120 pl->prev_max += (up ? -1 : 1);
|
|
1121 pl->prev_max =
|
|
1122 CLAMP(pl->prev_max, 0, aud_playlist_get_length(playlist) - 1);
|
|
1123
|
|
1124 pl->first = MIN(pl->first, pl->prev_max);
|
|
1125 pl->first = MAX(pl->first, pl->prev_max -
|
|
1126 pl->num_visible + 1);
|
|
1127 aud_playlist_select_range(playlist, pl->prev_min, pl->prev_max, TRUE);
|
|
1128 return TRUE;
|
|
1129 }
|
|
1130 else if (state & GDK_MOD1_MASK) {
|
|
1131 if (up)
|
|
1132 ui_skinned_playlist_move_up(pl);
|
|
1133 else
|
|
1134 ui_skinned_playlist_move_down(pl);
|
|
1135 if (pl->prev_min < pl->first)
|
|
1136 pl->first = pl->prev_min;
|
|
1137 else if (pl->prev_max >= (pl->first + pl->num_visible))
|
|
1138 pl->first = pl->prev_max - pl->num_visible + 1;
|
|
1139 return TRUE;
|
|
1140 }
|
|
1141 else if (up)
|
|
1142 pl->prev_selected--;
|
|
1143 else
|
|
1144 pl->prev_selected++;
|
|
1145
|
|
1146 pl->prev_selected =
|
|
1147 CLAMP(pl->prev_selected, 0, aud_playlist_get_length(playlist) - 1);
|
|
1148
|
|
1149 if (pl->prev_selected < pl->first)
|
|
1150 pl->first--;
|
|
1151 else if (pl->prev_selected >= (pl->first + pl->num_visible))
|
|
1152 pl->first++;
|
|
1153
|
|
1154 aud_playlist_select_range(playlist, pl->prev_selected, pl->prev_selected, TRUE);
|
|
1155 pl->prev_min = -1;
|
|
1156
|
|
1157 return TRUE;
|
|
1158 }
|
|
1159
|
|
1160 /* FIXME: Handle the keys through menu */
|
|
1161
|
|
1162 static gboolean
|
|
1163 playlistwin_keypress(GtkWidget * w, GdkEventKey * event, gpointer data)
|
|
1164 {
|
|
1165 g_return_val_if_fail(UI_SKINNED_IS_PLAYLIST(playlistwin_list), FALSE);
|
|
1166 Playlist *playlist = aud_playlist_get_active();
|
|
1167
|
|
1168 guint keyval;
|
|
1169 gboolean refresh = FALSE;
|
|
1170 guint cur_pos;
|
|
1171
|
|
1172 if (config.playlist_shaded)
|
|
1173 return FALSE;
|
|
1174
|
|
1175 switch (keyval = event->keyval) {
|
|
1176 case GDK_KP_Up:
|
|
1177 case GDK_KP_Down:
|
|
1178 case GDK_Up:
|
|
1179 case GDK_Down:
|
|
1180 refresh = playlistwin_keypress_up_down_handler(UI_SKINNED_PLAYLIST(playlistwin_list),
|
|
1181 keyval == GDK_Up
|
|
1182 || keyval == GDK_KP_Up,
|
|
1183 event->state);
|
|
1184 break;
|
|
1185 case GDK_Page_Up:
|
|
1186 playlistwin_scroll(-UI_SKINNED_PLAYLIST(playlistwin_list)->num_visible);
|
|
1187 refresh = TRUE;
|
|
1188 break;
|
|
1189 case GDK_Page_Down:
|
|
1190 playlistwin_scroll(UI_SKINNED_PLAYLIST(playlistwin_list)->num_visible);
|
|
1191 refresh = TRUE;
|
|
1192 break;
|
|
1193 case GDK_Home:
|
|
1194 UI_SKINNED_PLAYLIST(playlistwin_list)->first = 0;
|
|
1195 refresh = TRUE;
|
|
1196 break;
|
|
1197 case GDK_End:
|
|
1198 UI_SKINNED_PLAYLIST(playlistwin_list)->first =
|
|
1199 aud_playlist_get_length(playlist) - UI_SKINNED_PLAYLIST(playlistwin_list)->num_visible;
|
|
1200 refresh = TRUE;
|
|
1201 break;
|
|
1202 case GDK_Return:
|
|
1203 if (UI_SKINNED_PLAYLIST(playlistwin_list)->prev_selected > -1
|
|
1204 && playlistwin_item_visible(UI_SKINNED_PLAYLIST(playlistwin_list)->prev_selected)) {
|
|
1205 aud_playlist_set_position(playlist, UI_SKINNED_PLAYLIST(playlistwin_list)->prev_selected);
|
|
1206 if (!audacious_drct_get_playing())
|
|
1207 audacious_drct_initiate();
|
|
1208 }
|
|
1209 refresh = TRUE;
|
|
1210 break;
|
|
1211 case GDK_3:
|
|
1212 if (event->state & GDK_CONTROL_MASK)
|
|
1213 playlistwin_fileinfo();
|
|
1214 break;
|
|
1215 case GDK_Delete:
|
|
1216 if (event->state & GDK_CONTROL_MASK)
|
|
1217 aud_playlist_delete(playlist, TRUE);
|
|
1218 else
|
|
1219 aud_playlist_delete(playlist, FALSE);
|
|
1220 break;
|
|
1221 case GDK_Insert:
|
|
1222 if (event->state & GDK_MOD1_MASK)
|
|
1223 mainwin_show_add_url_window();
|
|
1224 else
|
|
1225 playlistwin_show_filebrowser();
|
|
1226 break;
|
|
1227 case GDK_Left:
|
|
1228 case GDK_KP_Left:
|
|
1229 case GDK_KP_7:
|
|
1230 if (aud_playlist_get_current_length(playlist) != -1)
|
|
1231 audacious_drct_seek(CLAMP
|
|
1232 (audacious_drct_get_time() - 5000, 0,
|
|
1233 aud_playlist_get_current_length(playlist)));
|
|
1234 break;
|
|
1235 case GDK_Right:
|
|
1236 case GDK_KP_Right:
|
|
1237 case GDK_KP_9:
|
|
1238 if (aud_playlist_get_current_length(playlist) != -1)
|
|
1239 audacious_drct_seek(CLAMP
|
|
1240 (audacious_drct_get_time() + 5000, 0,
|
|
1241 aud_playlist_get_current_length(playlist)));
|
|
1242 break;
|
|
1243 case GDK_KP_4:
|
|
1244 aud_playlist_prev(playlist);
|
|
1245 break;
|
|
1246 case GDK_KP_6:
|
|
1247 aud_playlist_next(playlist);
|
|
1248 break;
|
|
1249
|
|
1250 case GDK_Escape:
|
|
1251 mainwin_minimize_cb();
|
|
1252 break;
|
|
1253 case GDK_Tab:
|
|
1254 if (event->state & GDK_CONTROL_MASK) {
|
|
1255 if (config.player_visible)
|
|
1256 gtk_window_present(GTK_WINDOW(mainwin));
|
|
1257 else if (config.equalizer_visible)
|
|
1258 gtk_window_present(GTK_WINDOW(equalizerwin));
|
|
1259 }
|
|
1260 break;
|
|
1261 case GDK_space:
|
|
1262 cur_pos=aud_playlist_get_position(playlist);
|
|
1263 UI_SKINNED_PLAYLIST(playlistwin_list)->first =
|
|
1264 cur_pos - (UI_SKINNED_PLAYLIST(playlistwin_list)->num_visible >> 1);
|
|
1265 refresh = TRUE;
|
|
1266 break;
|
|
1267 default:
|
|
1268 return FALSE;
|
|
1269 }
|
|
1270 #if 0
|
|
1271 if (refresh) {
|
|
1272 g_cond_signal(cond_scan);
|
|
1273 playlistwin_update_list(aud_playlist_get_active());
|
|
1274 }
|
|
1275 #endif
|
|
1276 return TRUE;
|
|
1277 }
|
|
1278
|
|
1279 void
|
|
1280 playlistwin_hide_timer(void)
|
|
1281 {
|
|
1282 ui_skinned_textbox_set_text(playlistwin_time_min, " ");
|
|
1283 ui_skinned_textbox_set_text(playlistwin_time_sec, " ");
|
|
1284 }
|
|
1285
|
|
1286 void
|
|
1287 playlistwin_set_time(gint time, gint length, TimerMode mode)
|
|
1288 {
|
|
1289 gchar *text, sign;
|
|
1290
|
|
1291 if (mode == TIMER_REMAINING && length != -1) {
|
|
1292 time = length - time;
|
|
1293 sign = '-';
|
|
1294 }
|
|
1295 else
|
|
1296 sign = ' ';
|
|
1297
|
|
1298 time /= 1000;
|
|
1299
|
|
1300 if (time < 0)
|
|
1301 time = 0;
|
|
1302 if (time > 99 * 60)
|
|
1303 time /= 60;
|
|
1304
|
|
1305 text = g_strdup_printf("%c%-2.2d", sign, time / 60);
|
|
1306 ui_skinned_textbox_set_text(playlistwin_time_min, text);
|
|
1307 g_free(text);
|
|
1308
|
|
1309 text = g_strdup_printf("%-2.2d", time % 60);
|
|
1310 ui_skinned_textbox_set_text(playlistwin_time_sec, text);
|
|
1311 g_free(text);
|
|
1312 }
|
|
1313
|
|
1314 static void
|
|
1315 playlistwin_drag_motion(GtkWidget * widget,
|
|
1316 GdkDragContext * context,
|
|
1317 gint x, gint y,
|
|
1318 GtkSelectionData * selection_data,
|
|
1319 guint info, guint time, gpointer user_data)
|
|
1320 {
|
|
1321 if (UI_SKINNED_IS_PLAYLIST(playlistwin_list)) {
|
|
1322 UI_SKINNED_PLAYLIST(playlistwin_list)->drag_motion = TRUE;
|
|
1323 UI_SKINNED_PLAYLIST(playlistwin_list)->drag_motion_x = x;
|
|
1324 UI_SKINNED_PLAYLIST(playlistwin_list)->drag_motion_y = y;
|
|
1325 }
|
|
1326 playlistwin_update_list(aud_playlist_get_active());
|
|
1327 playlistwin_hint_flag = TRUE;
|
|
1328 }
|
|
1329
|
|
1330 static void
|
|
1331 playlistwin_drag_end(GtkWidget * widget,
|
|
1332 GdkDragContext * context, gpointer user_data)
|
|
1333 {
|
|
1334 if (UI_SKINNED_IS_PLAYLIST(playlistwin_list))
|
|
1335 UI_SKINNED_PLAYLIST(playlistwin_list)->drag_motion = FALSE;
|
|
1336 playlistwin_hint_flag = FALSE;
|
|
1337 playlistwin_update_list(aud_playlist_get_active());
|
|
1338 }
|
|
1339
|
|
1340 static void
|
|
1341 playlistwin_drag_data_received(GtkWidget * widget,
|
|
1342 GdkDragContext * context,
|
|
1343 gint x, gint y,
|
|
1344 GtkSelectionData *
|
|
1345 selection_data, guint info,
|
|
1346 guint time, gpointer user_data)
|
|
1347 {
|
|
1348 gint pos;
|
|
1349 Playlist *playlist = aud_playlist_get_active();
|
|
1350
|
|
1351 g_return_if_fail(selection_data);
|
|
1352
|
|
1353 if (!selection_data->data) {
|
|
1354 g_message("Received no DND data!");
|
|
1355 return;
|
|
1356 }
|
|
1357 if (UI_SKINNED_IS_PLAYLIST(playlistwin_list) &&
|
|
1358 (x < playlistwin_get_width() - 20 || y < config.playlist_height - 38)) {
|
|
1359 pos = y / UI_SKINNED_PLAYLIST(playlistwin_list)->fheight + UI_SKINNED_PLAYLIST(playlistwin_list)->first;
|
|
1360
|
|
1361 pos = MIN(pos, aud_playlist_get_length(playlist));
|
|
1362 aud_playlist_ins_url(playlist, (gchar *) selection_data->data, pos);
|
|
1363 }
|
|
1364 else
|
|
1365 aud_playlist_add_url(playlist, (gchar *) selection_data->data);
|
|
1366 }
|
|
1367
|
|
1368 static void
|
|
1369 local_playlist_prev(void)
|
|
1370 {
|
|
1371 aud_playlist_prev(aud_playlist_get_active());
|
|
1372 }
|
|
1373
|
|
1374 static void
|
|
1375 local_playlist_next(void)
|
|
1376 {
|
|
1377 aud_playlist_next(aud_playlist_get_active());
|
|
1378 }
|
|
1379
|
|
1380 static void
|
|
1381 playlistwin_create_widgets(void)
|
|
1382 {
|
|
1383 /* This function creates the custom widgets used by the playlist editor */
|
|
1384
|
|
1385 /* text box for displaying song title in shaded mode */
|
|
1386 playlistwin_sinfo = ui_skinned_textbox_new(SKINNED_WINDOW(playlistwin)->fixed,
|
|
1387 4, 4, playlistwin_get_width() - 35, TRUE, SKIN_TEXT);
|
|
1388
|
|
1389 playlistwin_set_sinfo_font(aud_cfg->playlist_font);
|
|
1390
|
|
1391 playlistwin_shade = ui_skinned_button_new();
|
|
1392 /* shade/unshade window push button */
|
|
1393 if (config.playlist_shaded)
|
|
1394 ui_skinned_push_button_setup(playlistwin_shade, SKINNED_WINDOW(playlistwin)->fixed,
|
|
1395 playlistwin_get_width() - 21, 3,
|
|
1396 9, 9, 128, 45, 150, 42, SKIN_PLEDIT);
|
|
1397 else
|
|
1398 ui_skinned_push_button_setup(playlistwin_shade, SKINNED_WINDOW(playlistwin)->fixed,
|
|
1399 playlistwin_get_width() - 21, 3,
|
|
1400 9, 9, 157, 3, 62, 42, SKIN_PLEDIT);
|
|
1401
|
|
1402 g_signal_connect(playlistwin_shade, "clicked", playlistwin_shade_toggle, NULL );
|
|
1403
|
|
1404 /* close window push button */
|
|
1405 playlistwin_close = ui_skinned_button_new();
|
|
1406 ui_skinned_push_button_setup(playlistwin_close, SKINNED_WINDOW(playlistwin)->fixed,
|
|
1407 playlistwin_get_width() - 11, 3, 9, 9,
|
|
1408 config.playlist_shaded ? 138 : 167,
|
|
1409 config.playlist_shaded ? 45 : 3, 52, 42, SKIN_PLEDIT);
|
|
1410
|
|
1411 g_signal_connect(playlistwin_close, "clicked", playlistwin_hide, NULL );
|
|
1412
|
|
1413 /* playlist list box */
|
|
1414 playlistwin_list = ui_skinned_playlist_new(SKINNED_WINDOW(playlistwin)->fixed, 12, 20,
|
|
1415 playlistwin_get_width() - 31,
|
|
1416 config.playlist_height - 58);
|
|
1417 ui_skinned_playlist_set_font(aud_cfg->playlist_font);
|
|
1418
|
|
1419 /* playlist list box slider */
|
|
1420 playlistwin_slider = ui_skinned_playlist_slider_new(SKINNED_WINDOW(playlistwin)->fixed, playlistwin_get_width() - 15,
|
|
1421 20, config.playlist_height - 58);
|
|
1422
|
|
1423 /* track time (minute) */
|
|
1424 playlistwin_time_min = ui_skinned_textbox_new(SKINNED_WINDOW(playlistwin)->fixed,
|
|
1425 playlistwin_get_width() - 82,
|
|
1426 config.playlist_height - 15, 15, FALSE, SKIN_TEXT);
|
|
1427 g_signal_connect(playlistwin_time_min, "button-press-event", G_CALLBACK(change_timer_mode_cb), NULL);
|
|
1428
|
|
1429 /* track time (second) */
|
|
1430 playlistwin_time_sec = ui_skinned_textbox_new(SKINNED_WINDOW(playlistwin)->fixed,
|
|
1431 playlistwin_get_width() - 64,
|
|
1432 config.playlist_height - 15, 10, FALSE, SKIN_TEXT);
|
|
1433 g_signal_connect(playlistwin_time_sec, "button-press-event", G_CALLBACK(change_timer_mode_cb), NULL);
|
|
1434
|
|
1435 /* playlist information (current track length / total track length) */
|
|
1436 playlistwin_info = ui_skinned_textbox_new(SKINNED_WINDOW(playlistwin)->fixed,
|
|
1437 playlistwin_get_width() - 143,
|
|
1438 config.playlist_height - 28, 90, FALSE, SKIN_TEXT);
|
|
1439
|
|
1440 /* mini play control buttons at right bottom corner */
|
|
1441
|
|
1442 /* rewind button */
|
|
1443 playlistwin_srew = ui_skinned_button_new();
|
|
1444 ui_skinned_small_button_setup(playlistwin_srew, SKINNED_WINDOW(playlistwin)->fixed,
|
|
1445 playlistwin_get_width() - 144,
|
|
1446 config.playlist_height - 16, 8, 7);
|
|
1447 g_signal_connect(playlistwin_srew, "clicked", local_playlist_prev, NULL);
|
|
1448
|
|
1449 /* play button */
|
|
1450 playlistwin_splay = ui_skinned_button_new();
|
|
1451 ui_skinned_small_button_setup(playlistwin_splay, SKINNED_WINDOW(playlistwin)->fixed,
|
|
1452 playlistwin_get_width() - 138,
|
|
1453 config.playlist_height - 16, 10, 7);
|
|
1454 g_signal_connect(playlistwin_splay, "clicked", mainwin_play_pushed, NULL);
|
|
1455
|
|
1456 /* pause button */
|
|
1457 playlistwin_spause = ui_skinned_button_new();
|
|
1458 ui_skinned_small_button_setup(playlistwin_spause, SKINNED_WINDOW(playlistwin)->fixed,
|
|
1459 playlistwin_get_width() - 128,
|
|
1460 config.playlist_height - 16, 10, 7);
|
|
1461 g_signal_connect(playlistwin_spause, "clicked", audacious_drct_pause, NULL);
|
|
1462
|
|
1463 /* stop button */
|
|
1464 playlistwin_sstop = ui_skinned_button_new();
|
|
1465 ui_skinned_small_button_setup(playlistwin_sstop, SKINNED_WINDOW(playlistwin)->fixed,
|
|
1466 playlistwin_get_width() - 118,
|
|
1467 config.playlist_height - 16, 9, 7);
|
|
1468 g_signal_connect(playlistwin_sstop, "clicked", mainwin_stop_pushed, NULL);
|
|
1469
|
|
1470 /* forward button */
|
|
1471 playlistwin_sfwd = ui_skinned_button_new();
|
|
1472 ui_skinned_small_button_setup(playlistwin_sfwd, SKINNED_WINDOW(playlistwin)->fixed,
|
|
1473 playlistwin_get_width() - 109,
|
|
1474 config.playlist_height - 16, 8, 7);
|
|
1475 g_signal_connect(playlistwin_sfwd, "clicked", local_playlist_next, NULL);
|
|
1476
|
|
1477 /* eject button */
|
|
1478 playlistwin_seject = ui_skinned_button_new();
|
|
1479 ui_skinned_small_button_setup(playlistwin_seject, SKINNED_WINDOW(playlistwin)->fixed,
|
|
1480 playlistwin_get_width() - 100,
|
|
1481 config.playlist_height - 16, 9, 7);
|
|
1482 g_signal_connect(playlistwin_seject, "clicked", mainwin_eject_pushed, NULL);
|
|
1483
|
|
1484 playlistwin_sscroll_up = ui_skinned_button_new();
|
|
1485 ui_skinned_small_button_setup(playlistwin_sscroll_up, SKINNED_WINDOW(playlistwin)->fixed,
|
|
1486 playlistwin_get_width() - 14,
|
|
1487 config.playlist_height - 35, 8, 5);
|
|
1488 g_signal_connect(playlistwin_sscroll_up, "clicked", playlistwin_scroll_up_pushed, NULL);
|
|
1489
|
|
1490 playlistwin_sscroll_down = ui_skinned_button_new();
|
|
1491 ui_skinned_small_button_setup(playlistwin_sscroll_down, SKINNED_WINDOW(playlistwin)->fixed,
|
|
1492 playlistwin_get_width() - 14,
|
|
1493 config.playlist_height - 30, 8, 5);
|
|
1494 g_signal_connect(playlistwin_sscroll_down, "clicked", playlistwin_scroll_down_pushed, NULL);
|
|
1495
|
|
1496 ui_playlist_evlistener_init();
|
|
1497 }
|
|
1498
|
|
1499 static void
|
|
1500 selection_received(GtkWidget * widget,
|
|
1501 GtkSelectionData * selection_data, gpointer data)
|
|
1502 {
|
|
1503 if (selection_data->type == GDK_SELECTION_TYPE_STRING &&
|
|
1504 selection_data->length > 0)
|
|
1505 aud_playlist_add_url(aud_playlist_get_active(), (gchar *) selection_data->data);
|
|
1506 }
|
|
1507
|
|
1508 static void
|
|
1509 playlistwin_create_window(void)
|
|
1510 {
|
|
1511 GdkPixbuf *icon;
|
|
1512
|
|
1513 playlistwin = ui_skinned_window_new("playlist");
|
|
1514 gtk_window_set_title(GTK_WINDOW(playlistwin), _("Audacious Playlist Editor"));
|
|
1515 gtk_window_set_role(GTK_WINDOW(playlistwin), "playlist");
|
|
1516 gtk_window_set_default_size(GTK_WINDOW(playlistwin),
|
|
1517 playlistwin_get_width(),
|
|
1518 playlistwin_get_height());
|
|
1519 gtk_window_set_resizable(GTK_WINDOW(playlistwin), TRUE);
|
|
1520 playlistwin_set_geometry_hints(config.playlist_shaded);
|
|
1521
|
|
1522 gtk_window_set_transient_for(GTK_WINDOW(playlistwin),
|
|
1523 GTK_WINDOW(mainwin));
|
|
1524 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(playlistwin), TRUE);
|
|
1525
|
|
1526 icon = gdk_pixbuf_new_from_xpm_data((const gchar **) audacious_playlist_icon);
|
|
1527 gtk_window_set_icon(GTK_WINDOW(playlistwin), icon);
|
|
1528 g_object_unref(icon);
|
|
1529
|
|
1530 if (config.playlist_x != -1 && config.save_window_position)
|
|
1531 gtk_window_move(GTK_WINDOW(playlistwin),
|
|
1532 config.playlist_x, config.playlist_y);
|
|
1533
|
|
1534 gtk_widget_add_events(playlistwin, GDK_POINTER_MOTION_MASK |
|
|
1535 GDK_FOCUS_CHANGE_MASK | GDK_BUTTON_MOTION_MASK |
|
|
1536 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
|
|
1537 GDK_SCROLL_MASK | GDK_VISIBILITY_NOTIFY_MASK);
|
|
1538 gtk_widget_realize(playlistwin);
|
|
1539
|
|
1540 g_signal_connect(playlistwin, "delete_event",
|
|
1541 G_CALLBACK(playlistwin_delete), NULL);
|
|
1542 g_signal_connect(playlistwin, "button_press_event",
|
|
1543 G_CALLBACK(playlistwin_press), NULL);
|
|
1544 g_signal_connect(playlistwin, "button_release_event",
|
|
1545 G_CALLBACK(playlistwin_release), NULL);
|
|
1546 g_signal_connect(playlistwin, "scroll_event",
|
|
1547 G_CALLBACK(playlistwin_scrolled), NULL);
|
|
1548 g_signal_connect(playlistwin, "motion_notify_event",
|
|
1549 G_CALLBACK(playlistwin_motion), NULL);
|
|
1550 #if 0
|
|
1551 aud_drag_dest_set(playlistwin);
|
|
1552 #endif
|
|
1553 /* DnD stuff */
|
|
1554 g_signal_connect(playlistwin, "drag-leave",
|
|
1555 G_CALLBACK(playlistwin_drag_end), NULL);
|
|
1556 g_signal_connect(playlistwin, "drag-data-delete",
|
|
1557 G_CALLBACK(playlistwin_drag_end), NULL);
|
|
1558 g_signal_connect(playlistwin, "drag-end",
|
|
1559 G_CALLBACK(playlistwin_drag_end), NULL);
|
|
1560 g_signal_connect(playlistwin, "drag-drop",
|
|
1561 G_CALLBACK(playlistwin_drag_end), NULL);
|
|
1562 g_signal_connect(playlistwin, "drag-data-received",
|
|
1563 G_CALLBACK(playlistwin_drag_data_received), NULL);
|
|
1564 g_signal_connect(playlistwin, "drag-motion",
|
|
1565 G_CALLBACK(playlistwin_drag_motion), NULL);
|
|
1566
|
|
1567 g_signal_connect(playlistwin, "key_press_event",
|
|
1568 G_CALLBACK(playlistwin_keypress), NULL);
|
|
1569 g_signal_connect(playlistwin, "selection_received",
|
|
1570 G_CALLBACK(selection_received), NULL);
|
|
1571 }
|
|
1572
|
|
1573 void
|
|
1574 playlistwin_create(void)
|
|
1575 {
|
|
1576 resize_mutex = g_mutex_new();
|
|
1577 playlistwin_create_window();
|
|
1578
|
|
1579 playlistwin_create_widgets();
|
|
1580 playlistwin_update_info(aud_playlist_get_active());
|
|
1581
|
|
1582 gtk_window_add_accel_group(GTK_WINDOW(playlistwin), ui_manager_get_accel_group());
|
|
1583 }
|
|
1584
|
|
1585
|
|
1586 void
|
|
1587 playlistwin_show(void)
|
|
1588 {
|
|
1589 gtk_window_move(GTK_WINDOW(playlistwin), config.playlist_x, config.playlist_y);
|
|
1590 GtkAction *action = gtk_action_group_get_action(
|
|
1591 toggleaction_group_others , "show playlist editor" );
|
|
1592 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(action) , TRUE );
|
|
1593
|
|
1594 config.playlist_visible = TRUE;
|
|
1595 UI_SKINNED_BUTTON(mainwin_pl)->inside = TRUE;
|
|
1596 gtk_widget_queue_draw(mainwin_pl);
|
|
1597
|
|
1598 playlistwin_set_toprow(0);
|
|
1599 aud_playlist_check_pos_current(aud_playlist_get_active());
|
|
1600
|
|
1601 gtk_widget_show_all(playlistwin);
|
|
1602 if (!config.playlist_shaded)
|
|
1603 gtk_widget_hide(playlistwin_sinfo);
|
|
1604 gtk_window_present(GTK_WINDOW(playlistwin));
|
|
1605 }
|
|
1606
|
|
1607 void
|
|
1608 playlistwin_hide(void)
|
|
1609 {
|
|
1610 GtkAction *action = gtk_action_group_get_action(
|
|
1611 toggleaction_group_others , "show playlist editor" );
|
|
1612 gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(action) , FALSE );
|
|
1613
|
|
1614 gtk_widget_hide(playlistwin);
|
|
1615 config.playlist_visible = FALSE;
|
|
1616 UI_SKINNED_BUTTON(mainwin_pl)->inside = FALSE;
|
|
1617 gtk_widget_queue_draw(mainwin_pl);
|
|
1618
|
|
1619 if ( config.player_visible )
|
|
1620 {
|
|
1621 gtk_window_present(GTK_WINDOW(mainwin));
|
|
1622 gtk_widget_grab_focus(mainwin);
|
|
1623 }
|
|
1624 }
|
|
1625
|
|
1626 void action_playlist_track_info(void)
|
|
1627 {
|
|
1628 playlistwin_fileinfo();
|
|
1629 }
|
|
1630
|
|
1631 void action_queue_toggle(void)
|
|
1632 {
|
|
1633 aud_playlist_queue(aud_playlist_get_active());
|
|
1634 }
|
|
1635
|
|
1636 void action_playlist_sort_by_playlist_entry(void)
|
|
1637 {
|
|
1638 Playlist *playlist = aud_playlist_get_active();
|
|
1639
|
|
1640 aud_playlist_sort(playlist, PLAYLIST_SORT_PLAYLIST);
|
|
1641 playlistwin_update_list(playlist);
|
|
1642 }
|
|
1643
|
|
1644 void action_playlist_sort_by_track_number(void)
|
|
1645 {
|
|
1646 Playlist *playlist = aud_playlist_get_active();
|
|
1647
|
|
1648 aud_playlist_sort(playlist, PLAYLIST_SORT_TRACK);
|
|
1649 playlistwin_update_list(playlist);
|
|
1650 }
|
|
1651
|
|
1652 void action_playlist_sort_by_title(void)
|
|
1653 {
|
|
1654 Playlist *playlist = aud_playlist_get_active();
|
|
1655
|
|
1656 aud_playlist_sort(playlist, PLAYLIST_SORT_TITLE);
|
|
1657 playlistwin_update_list(playlist);
|
|
1658 }
|
|
1659
|
|
1660 void action_playlist_sort_by_artist(void)
|
|
1661 {
|
|
1662 Playlist *playlist = aud_playlist_get_active();
|
|
1663
|
|
1664 aud_playlist_sort(playlist, PLAYLIST_SORT_ARTIST);
|
|
1665 playlistwin_update_list(playlist);
|
|
1666 }
|
|
1667
|
|
1668 void action_playlist_sort_by_full_path(void)
|
|
1669 {
|
|
1670 Playlist *playlist = aud_playlist_get_active();
|
|
1671
|
|
1672 aud_playlist_sort(playlist, PLAYLIST_SORT_PATH);
|
|
1673 playlistwin_update_list(playlist);
|
|
1674 }
|
|
1675
|
|
1676 void action_playlist_sort_by_date(void)
|
|
1677 {
|
|
1678 Playlist *playlist = aud_playlist_get_active();
|
|
1679
|
|
1680 aud_playlist_sort(playlist, PLAYLIST_SORT_DATE);
|
|
1681 playlistwin_update_list(playlist);
|
|
1682 }
|
|
1683
|
|
1684 void action_playlist_sort_by_filename(void)
|
|
1685 {
|
|
1686 Playlist *playlist = aud_playlist_get_active();
|
|
1687
|
|
1688 aud_playlist_sort(playlist, PLAYLIST_SORT_FILENAME);
|
|
1689 playlistwin_update_list(playlist);
|
|
1690 }
|
|
1691
|
|
1692 void action_playlist_sort_selected_by_playlist_entry(void)
|
|
1693 {
|
|
1694 Playlist *playlist = aud_playlist_get_active();
|
|
1695
|
|
1696 aud_playlist_sort_selected(playlist, PLAYLIST_SORT_PLAYLIST);
|
|
1697 playlistwin_update_list(playlist);
|
|
1698 }
|
|
1699
|
|
1700 void action_playlist_sort_selected_by_track_number(void)
|
|
1701 {
|
|
1702 Playlist *playlist = aud_playlist_get_active();
|
|
1703
|
|
1704 aud_playlist_sort_selected(playlist, PLAYLIST_SORT_TRACK);
|
|
1705 playlistwin_update_list(playlist);
|
|
1706 }
|
|
1707
|
|
1708 void action_playlist_sort_selected_by_title(void)
|
|
1709 {
|
|
1710 Playlist *playlist = aud_playlist_get_active();
|
|
1711
|
|
1712 aud_playlist_sort_selected(playlist, PLAYLIST_SORT_TITLE);
|
|
1713 playlistwin_update_list(playlist);
|
|
1714 }
|
|
1715
|
|
1716 void action_playlist_sort_selected_by_artist(void)
|
|
1717 {
|
|
1718 Playlist *playlist = aud_playlist_get_active();
|
|
1719
|
|
1720 aud_playlist_sort_selected(playlist, PLAYLIST_SORT_ARTIST);
|
|
1721 playlistwin_update_list(playlist);
|
|
1722 }
|
|
1723
|
|
1724 void action_playlist_sort_selected_by_full_path(void)
|
|
1725 {
|
|
1726 Playlist *playlist = aud_playlist_get_active();
|
|
1727
|
|
1728 aud_playlist_sort_selected(playlist, PLAYLIST_SORT_PATH);
|
|
1729 playlistwin_update_list(playlist);
|
|
1730 }
|
|
1731
|
|
1732 void action_playlist_sort_selected_by_date(void)
|
|
1733 {
|
|
1734 Playlist *playlist = aud_playlist_get_active();
|
|
1735
|
|
1736 aud_playlist_sort_selected(playlist, PLAYLIST_SORT_DATE);
|
|
1737 playlistwin_update_list(playlist);
|
|
1738 }
|
|
1739
|
|
1740 void action_playlist_sort_selected_by_filename(void)
|
|
1741 {
|
|
1742 Playlist *playlist = aud_playlist_get_active();
|
|
1743
|
|
1744 aud_playlist_sort_selected(playlist, PLAYLIST_SORT_FILENAME);
|
|
1745 playlistwin_update_list(playlist);
|
|
1746 }
|
|
1747
|
|
1748 void action_playlist_randomize_list(void)
|
|
1749 {
|
|
1750 Playlist *playlist = aud_playlist_get_active();
|
|
1751
|
|
1752 aud_playlist_random(playlist);
|
|
1753 playlistwin_update_list(playlist);
|
|
1754 }
|
|
1755
|
|
1756 void action_playlist_reverse_list(void)
|
|
1757 {
|
|
1758 Playlist *playlist = aud_playlist_get_active();
|
|
1759
|
|
1760 aud_playlist_reverse(playlist);
|
|
1761 playlistwin_update_list(playlist);
|
|
1762 }
|
|
1763
|
|
1764 void
|
|
1765 action_playlist_clear_queue(void)
|
|
1766 {
|
|
1767 aud_playlist_clear_queue(aud_playlist_get_active());
|
|
1768 }
|
|
1769
|
|
1770 void
|
|
1771 action_playlist_remove_unavailable(void)
|
|
1772 {
|
|
1773 aud_playlist_remove_dead_files(aud_playlist_get_active());
|
|
1774 }
|
|
1775
|
|
1776 void
|
|
1777 action_playlist_remove_dupes_by_title(void)
|
|
1778 {
|
|
1779 aud_playlist_remove_duplicates(aud_playlist_get_active(), PLAYLIST_DUPS_TITLE);
|
|
1780 }
|
|
1781
|
|
1782 void
|
|
1783 action_playlist_remove_dupes_by_filename(void)
|
|
1784 {
|
|
1785 aud_playlist_remove_duplicates(aud_playlist_get_active(), PLAYLIST_DUPS_FILENAME);
|
|
1786 }
|
|
1787
|
|
1788 void
|
|
1789 action_playlist_remove_dupes_by_full_path(void)
|
|
1790 {
|
|
1791 aud_playlist_remove_duplicates(aud_playlist_get_active(), PLAYLIST_DUPS_PATH);
|
|
1792 }
|
|
1793
|
|
1794 void
|
|
1795 action_playlist_remove_all(void)
|
|
1796 {
|
|
1797 aud_playlist_clear(aud_playlist_get_active());
|
|
1798
|
|
1799 /* XXX -- should this really be coupled here? -nenolod */
|
|
1800 mainwin_clear_song_info();
|
|
1801 }
|
|
1802
|
|
1803 void
|
|
1804 action_playlist_remove_selected(void)
|
|
1805 {
|
|
1806 aud_playlist_delete(aud_playlist_get_active(), FALSE);
|
|
1807 }
|
|
1808
|
|
1809 void
|
|
1810 action_playlist_remove_unselected(void)
|
|
1811 {
|
|
1812 aud_playlist_delete(aud_playlist_get_active(), TRUE);
|
|
1813 }
|
|
1814
|
|
1815 void
|
|
1816 action_playlist_add_files(void)
|
|
1817 {
|
|
1818 #if 0
|
|
1819 run_filebrowser(NO_PLAY_BUTTON);
|
|
1820 #endif
|
|
1821 }
|
|
1822
|
|
1823 void
|
|
1824 action_playlist_add_url(void)
|
|
1825 {
|
|
1826 mainwin_show_add_url_window();
|
|
1827 }
|
|
1828
|
|
1829 void
|
|
1830 action_playlist_new( void )
|
|
1831 {
|
|
1832 Playlist *new_pl = aud_playlist_new();
|
|
1833 aud_playlist_add_playlist(new_pl);
|
|
1834 aud_playlist_select_playlist(new_pl);
|
|
1835 }
|
|
1836
|
|
1837 void
|
|
1838 action_playlist_prev( void )
|
|
1839 {
|
|
1840 aud_playlist_select_prev();
|
|
1841 }
|
|
1842
|
|
1843 void
|
|
1844 action_playlist_next( void )
|
|
1845 {
|
|
1846 aud_playlist_select_next();
|
|
1847 }
|
|
1848
|
|
1849 void
|
|
1850 action_playlist_delete( void )
|
|
1851 {
|
|
1852 aud_playlist_remove_playlist( aud_playlist_get_active() );
|
|
1853 }
|
|
1854
|
|
1855 void
|
|
1856 action_playlist_save_list(void)
|
|
1857 {
|
|
1858 Playlist *playlist = aud_playlist_get_active();
|
|
1859
|
|
1860 playlistwin_select_playlist_to_save(aud_playlist_get_current_name(playlist));
|
|
1861 }
|
|
1862
|
|
1863 void
|
|
1864 action_playlist_save_default_list(void)
|
|
1865 {
|
|
1866 #if 0
|
|
1867 Playlist *playlist = aud_playlist_get_active();
|
|
1868
|
|
1869 aud_playlist_save(playlist, aud_paths[BMP_PATH_PLAYLIST_FILE]);
|
|
1870 #endif
|
|
1871 }
|
|
1872
|
|
1873 void
|
|
1874 action_playlist_load_list(void)
|
|
1875 {
|
|
1876 Playlist *playlist = aud_playlist_get_active();
|
|
1877
|
|
1878 playlistwin_select_playlist_to_load(aud_playlist_get_current_name(playlist));
|
|
1879 }
|
|
1880
|
|
1881 void
|
|
1882 action_playlist_refresh_list(void)
|
|
1883 {
|
|
1884 Playlist *playlist = aud_playlist_get_active();
|
|
1885
|
|
1886 aud_playlist_read_info_selection(playlist);
|
|
1887 playlistwin_update_list(playlist);
|
|
1888 }
|
|
1889
|
|
1890 void
|
|
1891 action_open_list_manager(void)
|
|
1892 {
|
|
1893 #if 0
|
|
1894 playlist_manager_ui_show();
|
|
1895 #endif
|
|
1896 }
|
|
1897
|
|
1898 void
|
|
1899 action_playlist_search_and_select(void)
|
|
1900 {
|
|
1901 playlistwin_select_search();
|
|
1902 }
|
|
1903
|
|
1904 void
|
|
1905 action_playlist_invert_selection(void)
|
|
1906 {
|
|
1907 playlistwin_inverse_selection();
|
|
1908 }
|
|
1909
|
|
1910 void
|
|
1911 action_playlist_select_none(void)
|
|
1912 {
|
|
1913 playlistwin_select_none();
|
|
1914 }
|
|
1915
|
|
1916 void
|
|
1917 action_playlist_select_all(void)
|
|
1918 {
|
|
1919 playlistwin_select_all();
|
|
1920 }
|
|
1921
|
|
1922
|
|
1923 static void
|
|
1924 playlistwin_select_search_cbt_cb(GtkWidget *called_cbt, gpointer other_cbt)
|
|
1925 {
|
|
1926 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(called_cbt)) == TRUE)
|
|
1927 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(other_cbt), FALSE);
|
|
1928 return;
|
|
1929 }
|
|
1930
|
|
1931 static gboolean
|
|
1932 playlistwin_select_search_kp_cb(GtkWidget *entry, GdkEventKey *event,
|
|
1933 gpointer searchdlg_win)
|
|
1934 {
|
|
1935 switch (event->keyval)
|
|
1936 {
|
|
1937 case GDK_Return:
|
|
1938 if (gtk_im_context_filter_keypress (GTK_ENTRY (entry)->im_context, event)) {
|
|
1939 GTK_ENTRY (entry)->need_im_reset = TRUE;
|
|
1940 return TRUE;
|
|
1941 } else {
|
|
1942 gtk_dialog_response(GTK_DIALOG(searchdlg_win), GTK_RESPONSE_ACCEPT);
|
|
1943 return TRUE;
|
|
1944 }
|
|
1945 default:
|
|
1946 return FALSE;
|
|
1947 }
|
|
1948 }
|