t_size playlist_manager::create_playlist_autoname(t_size p_index) {
static const char new_playlist_text[] = "New Playlist";
if (find_playlist(new_playlist_text,pfc_infinite) == pfc_infinite) return create_playlist(new_playlist_text,pfc_infinite,p_index);
for(t_size walk = 2; ; walk++) {
pfc::string_fixed_t<64> namebuffer;
namebuffer << new_playlist_text << " (" << walk << ")";
if (find_playlist(namebuffer,pfc_infinite) == pfc_infinite) return create_playlist(namebuffer,pfc_infinite,p_index);
}
}
mlt_producer create_tracks( int argc, char **argv )
{
// Create the field
mlt_field field = mlt_field_init( );
// Obtain the multitrack
mlt_multitrack multitrack = mlt_field_multitrack( field );
// Obtain the tractor
mlt_tractor tractor = mlt_field_tractor( field );
// Obtain a composite transition
mlt_transition transition = mlt_factory_transition( "composite", "10%,10%:15%x15%" );
// Create track 0
mlt_producer track0 = create_playlist( argc, argv );
// Get the length of track0
mlt_position length = mlt_producer_get_playtime( track0 );
// Create the watermark track
mlt_producer track1 = mlt_factory_producer( NULL, "pango:" );
// Get the properties of track1
mlt_properties properties = mlt_producer_properties( track1 );
// Set the properties
mlt_properties_set( properties, "text", "Hello\nWorld" );
mlt_properties_set_position( properties, "in", 0 );
mlt_properties_set_position( properties, "out", length - 1 );
mlt_properties_set_position( properties, "length", length );
// Now set the properties on the transition
properties = mlt_transition_properties( transition );
mlt_properties_set_position( properties, "in", 0 );
mlt_properties_set_position( properties, "out", length - 1 );
// Add our tracks to the multitrack
mlt_multitrack_connect( multitrack, track0, 0 );
mlt_multitrack_connect( multitrack, track1, 1 );
// Now plant the transition
mlt_field_plant_transition( field, transition, 0, 1 );
// Now set the properties on the transition
properties = mlt_tractor_properties( tractor );
// Ensure clean up and set properties correctly
mlt_properties_set_data( properties, "multitrack", multitrack, 0, ( mlt_destructor )mlt_multitrack_close, NULL );
mlt_properties_set_data( properties, "field", field, 0, ( mlt_destructor )mlt_field_close, NULL );
mlt_properties_set_data( properties, "track0", track0, 0, ( mlt_destructor )mlt_producer_close, NULL );
mlt_properties_set_data( properties, "track1", track1, 0, ( mlt_destructor )mlt_producer_close, NULL );
mlt_properties_set_data( properties, "transition", transition, 0, ( mlt_destructor )mlt_transition_close, NULL );
mlt_properties_set_position( properties, "length", length );
mlt_properties_set_position( properties, "out", length - 1 );
// Return the tractor
return mlt_tractor_producer( tractor );
}
t_size playlist_manager::find_or_create_playlist_unlocked(const char * p_name, t_size p_name_length) {
t_size n, m = get_playlist_count();
pfc::string_formatter temp;
for(n=0;n<m;n++) {
if (!playlist_lock_is_present(n) && playlist_get_name(n,temp)) {
if (stricmp_utf8_ex(temp,~0,p_name,p_name_length) == 0) return n;
}
}
return create_playlist(p_name,p_name_length,pfc_infinite);
}
static void begin_add (const char * path)
{
int list = get_playlist (FALSE, FALSE);
if (list < 0)
list = create_playlist ();
aud_set_str ("search-tool", "path", path);
char * uri = filename_to_uri (path);
g_return_if_fail (uri);
if (! g_str_has_suffix (uri, "/"))
{
SCONCAT2 (temp, uri, "/");
str_unref (uri);
uri = str_get (temp);
}
destroy_added_table ();
added_table = g_hash_table_new_full ((GHashFunc) str_hash, (GEqualFunc)
str_equal, (GDestroyNotify) str_unref, NULL);
int entries = aud_playlist_entry_count (list);
for (int entry = 0; entry < entries; entry ++)
{
char * filename = aud_playlist_entry_get_filename (list, entry);
if (g_str_has_prefix (filename, uri) && ! g_hash_table_contains (added_table, filename))
{
aud_playlist_entry_set_selected (list, entry, FALSE);
g_hash_table_insert (added_table, filename, NULL);
}
else
{
aud_playlist_entry_set_selected (list, entry, TRUE);
str_unref (filename);
}
}
aud_playlist_delete_selected (list);
aud_playlist_remove_failed (list);
Index * add = index_new ();
index_insert (add, -1, uri);
aud_playlist_entry_insert_filtered (list, -1, add, NULL, filter_cb, NULL, FALSE);
adding = TRUE;
}
/*
* This function executes the command specified in the command line
*/
static gboolean
execute_command (gpointer user_data)
{
GError *error;
switch (command) {
case COMMAND_CREATE:
error = create_playlist ();
if (error == NULL) {
g_print ("Playlist %s created\n", playlist_name);
}
break;
case COMMAND_REMOVE:
error = remove_playlist ();
if (error == NULL) {
g_print ("Playlist %s removed\n", playlist_name);
}
break;
case COMMAND_SHOW:
error = show_playlist ();
break;
case COMMAND_ADD_ITEM:
error = add_item_to_playlist ();
if (error == NULL) {
g_print ("Item %s added to playlist %s\n",
object_id, playlist_name);
}
break;
case COMMAND_REMOVE_ITEM:
error = remove_item_from_playlist ();
break;
}
if (error != NULL) {
g_print ("Operation failed: %s\n", error->message);
} else {
g_print ("Operation executed successfully.\n");
}
g_main_loop_quit (main_loop);
return FALSE;
}
t_size playlist_manager::find_or_create_playlist(const char * p_name,t_size p_name_length)
{
t_size index = find_playlist(p_name,p_name_length);
if (index != pfc_infinite) return index;
return create_playlist(p_name,p_name_length,pfc_infinite);
}
int main(int argc, char *argv[])
{
char *buff;
int ch;
int i;
initscr();
cbreak();
noecho();
nonl();
curs_set(0);
// nodelay(stdscr, TRUE);
intrflush(stdscr, FALSE);
keypad(stdscr, TRUE);
if((color = has_colors())) {
start_color();
init_pair(1, COLOR_WHITE, COLOR_BLUE);
init_pair(2, COLOR_CYAN, COLOR_BLUE);
}
signal(SIGINT, cleanup);
init_windows();
init_bass();
create_playlist(&playlist_h, &playlist_t);
if(argc>1) {
if(strncmp("/", argv[1], 1) != 0) {
error("argument must be an absolute path", FALSE);
}
if(dirname(opendir(argv[1]))) { // is a dir
if(add(&playlist_h, argv[1], &playlist_t)) {
p_p++;
c_p_p++;
nsongs++;
active_win = PLAYLIST_WIN;
bass_loop = BASS_MUSIC_LOOP;
play(argv[1], PLAYING_PLAYLIST);
}
current_path = strdup((char*)dirname(argv[1]));
} else {
error("argument not valid", FALSE);
}
} else {
current_path = (char*)malloc(sizeof(char)*PATH_MAX);
current_path = (char*)getcwd(current_path, PATH_MAX);
}
entries = refresh_browser(current_path, 0);
mvprintw(0, 0, "%s", current_path);
repaint_windows();
while((ch = getch()) != 'q') {
switch(ch) {
case 'a': // add song to playlist
if(active_win == BROWSER_WIN) {
if(!is_dir(current_path, entries[p_b])) {
buff = mystrcat(current_path,entries[p_b],1);
if(add(&playlist_h, buff, &playlist_t)) {
if(p_p == -1) p_p++;
nsongs++;
repaint_windows();
}
free(buff);
}
}
break;
case 'e': // add all songs in current dir
if(active_win == BROWSER_WIN) {
for(i=0; i<nfiles; i++) {
if(!is_dir(current_path, entries[i])) {
buff = mystrcat(current_path,entries[i],1);
if(add(&playlist_h, buff, &playlist_t)) {
if(p_p == -1) p_p++;
nsongs++;
}
free(buff);
}
}
}
repaint_windows();
break;
case 'c': // recursive add
if(active_win == BROWSER_WIN) {
//printw("---%s+++", current_path);
add_recursive(current_path, entries, nfiles);
repaint_windows();
//printw("---%s", current_path);
}
break;
case 'd': // remove one song from playlist
if(active_win == PLAYLIST_WIN) {
if(del(&playlist_h, p_p, &playlist_t)) {
nsongs--;
if(p_p > nsongs - 1) {
p_p = nsongs - 1;
}
if(p_p < c_p_p) {
c_p_p--;
}
//stop();
repaint_windows();
}
}
break;
case 'r': // remove all songs from playlist
if(del_all(&playlist_h, &playlist_t)) {
p_p = -1;
c_p_p = -1;
nsongs = 0;
repaint_windows();
}
break;
case ' ': // start playback or browse filesystem
case 13: //enter key
if(active_win == BROWSER_WIN) {
if(strcmp(entries[p_b], "..\0") == 0) {
current_path = dirname(current_path);
p_b = 0;
entries = refresh_browser(current_path, 0);
} else {
if(is_dir(current_path, entries[p_b])) {
current_path = dir_up(current_path, entries[p_b]);
p_b = 0;
entries = refresh_browser(current_path, 0);
} else {
buff = mystrcat(current_path,entries[p_b],1);
play(buff, PLAYING_BROWSER);
free(buff);
c_p_p = -1;
if(p_b < nfiles-1) {
p_b++;
}
}
}
refresh_path();
} else { // PLAYLIST_WIN
if(nsongs != 0) {
play(get(&playlist_h, p_p, &playlist_t)->file, PLAYING_PLAYLIST);
c_p_p = p_p;
if(p_p < nsongs - 1) {
p_p++;
}
}
}
repaint_windows();
break;
case 's': // stop playback
stop();
c_p_p = -1;
repaint_windows();
clear_statusbar(NULL);
break;
case 'n': // next song
next();
break;
case 'p': // prev song
prev();
break;
case 'g': // go to current song
p_p = c_p_p;
repaint_windows();
break;
case 'l': // toggle loop
loop();
stop();
c_p_p = -1;
repaint_windows();
break;
case 'z': // toggle random
random_mode();
break;
case '.': // seek forward
seek(1);
break;
case ',': // seek backward
seek(-1);
break;
case '+':
volume_up();
break;
case '-':
volume_down();
break;
case '>':
amplify_up();
break;
case '<':
amplify_down();
break;
case KEY_UP:
if(active_win == BROWSER_WIN) {
if(p_b > 0) {
p_b--;
}
} else {
if(p_p > 0) {
p_p--;
}
}
repaint_windows();
break;
case KEY_DOWN:
if(active_win == BROWSER_WIN) {
if(p_b < nfiles-1) {
p_b++;
}
} else {
if(p_p < nsongs - 1) {
p_p++;
}
}
repaint_windows();
break;
case KEY_LEFT:
case KEY_RIGHT:
switch_activewindow();
repaint_windows();
break;
case KEY_HOME:
if(active_win == BROWSER_WIN) {
p_b = 0;
} else {
if(p_p != -1) p_p = 0;
}
repaint_windows();
break;
case KEY_END:
if(active_win == BROWSER_WIN) {
p_b = nfiles-1;
} else {
if(p_p != -1) p_p = nsongs - 1;
}
repaint_windows();
break;
case KEY_NPAGE:
if(active_win == BROWSER_WIN) {
if((p_b + (browser_win->_maxy - 2)) < nfiles-1 ) {
p_b += browser_win->_maxy - 1;
} else {
p_b = nfiles-1;
}
} else {
if((p_p + (playlist_win->_maxy - 2)) < nsongs) {
p_p += playlist_win->_maxy - 1;
} else {
p_p = nsongs - 1;
}
}
repaint_windows();
break;
case KEY_PPAGE:
if(active_win == BROWSER_WIN) {
if((p_b - (browser_win->_maxy - 2)) > 0) {
p_b -= browser_win->_maxy - 1;
} else {
p_b = 0;
}
} else {
if((p_p - (playlist_win->_maxy - 2)) > 0) {
p_p -= playlist_win->_maxy - 1;
} else {
if(p_p != -1) p_p = 0;
}
}
repaint_windows();
break;
}
//usleep(10);
//update_status();
}
cleanup();
return 0;
}
/*****************************************************************************
* Initialize and launch the interface
*****************************************************************************/
static void *Thread( void *obj )
{
intf_thread_t *p_intf = (intf_thread_t *)obj;
const char *p_args[] = { "vlc" };
int i_args = sizeof(p_args)/sizeof(char *);
char **pp_args = (char **)p_args;
HildonProgram *program;
HildonWindow *window;
GtkWidget *main_vbox, *bottom_hbox;
GtkWidget *video, *seekbar;
GtkWidget *play_button, *prev_button, *next_button;
GtkWidget *stop_button, *playlist_button;
gtk_init( &i_args, &pp_args );
program = HILDON_PROGRAM( hildon_program_get_instance() );
g_set_application_name( "VLC Media Player" );
window = HILDON_WINDOW( hildon_window_new() );
hildon_program_add_window( program, window );
gtk_object_set_data( GTK_OBJECT( window ), "p_intf", p_intf );
p_intf->p_sys->p_main_window = window;
g_signal_connect( GTK_WIDGET(window), "key-press-event",
G_CALLBACK( key_cb ), p_intf );
g_signal_connect (GTK_WIDGET(window), "delete_event",
GTK_SIGNAL_FUNC( quit_event), p_intf );
// A little theming
char *psz_rc_file = NULL;
char *psz_data = config_GetDataDir( p_intf );
if( asprintf( &psz_rc_file, "%s/maemo/vlc_intf.rc", psz_data ) != -1 )
{
gtk_rc_parse( psz_rc_file );
free( psz_rc_file );
}
free( psz_data );
// We create the main vertical box
main_vbox = gtk_vbox_new( FALSE, 0 );
gtk_container_add( GTK_CONTAINER( window ), main_vbox );
// Menubar
GtkWidget *main_menu = create_menu( p_intf );
#ifdef HAVE_MAEMO
hildon_window_set_menu( HILDON_WINDOW( p_intf->p_sys->p_main_window ),
GTK_MENU( main_menu ) );
#else
GtkWidget *menu_bar = gtk_menu_bar_new ();
GtkWidget *item = gtk_menu_item_new_with_label ("Menu");
gtk_menu_bar_append(menu_bar, item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), main_menu);
gtk_widget_show_all (menu_bar);
gtk_box_pack_start(GTK_BOX(main_vbox), menu_bar, FALSE, FALSE, 0);
#endif
// We put first the embedded video
video = gtk_event_box_new();
GdkColor black = {0,0,0,0};
gtk_widget_modify_bg(video, GTK_STATE_NORMAL, &black);
p_intf->p_sys->p_video_window = video;
gtk_box_pack_start( GTK_BOX( main_vbox ), video, TRUE, TRUE, 0 );
create_playlist( p_intf );
gtk_box_pack_start( GTK_BOX( main_vbox ), p_intf->p_sys->p_playlist_window, TRUE, TRUE, 0 );
// We put the horizontal box which contains all the buttons
p_intf->p_sys->p_control_window = bottom_hbox = gtk_hbox_new( FALSE, 0 );
// We create the buttons
play_button = gtk_button_new();
gtk_button_set_image( GTK_BUTTON( play_button ),
gtk_image_new_from_stock( "vlc-play", GTK_ICON_SIZE_BUTTON ) );
p_intf->p_sys->p_play_button = play_button;
stop_button = gtk_button_new();
gtk_button_set_image( GTK_BUTTON( stop_button ),
gtk_image_new_from_stock( "vlc-stop", GTK_ICON_SIZE_BUTTON ) );
prev_button = gtk_button_new();
gtk_button_set_image( GTK_BUTTON( prev_button ),
gtk_image_new_from_stock( "vlc-previous", GTK_ICON_SIZE_BUTTON ) );
next_button = gtk_button_new();
gtk_button_set_image( GTK_BUTTON( next_button ),
gtk_image_new_from_stock( "vlc-next", GTK_ICON_SIZE_BUTTON ) );
playlist_button = gtk_button_new();
gtk_button_set_image( GTK_BUTTON( playlist_button ),
gtk_image_new_from_stock( "vlc-playlist", GTK_ICON_SIZE_BUTTON ) );
seekbar = hildon_seekbar_new();
p_intf->p_sys->p_seekbar = HILDON_SEEKBAR( seekbar );
// We add them to the hbox
gtk_box_pack_start( GTK_BOX( bottom_hbox ), play_button, FALSE, FALSE, 0 );
gtk_box_pack_start( GTK_BOX( bottom_hbox ), stop_button, FALSE, FALSE, 0 );
gtk_box_pack_start( GTK_BOX( bottom_hbox ), prev_button, FALSE, FALSE, 0 );
gtk_box_pack_start( GTK_BOX( bottom_hbox ), next_button, FALSE, FALSE, 0 );
gtk_box_pack_start( GTK_BOX( bottom_hbox ), playlist_button, FALSE, FALSE, 0 );
gtk_box_pack_start( GTK_BOX( bottom_hbox ), seekbar , TRUE , TRUE , 5 );
// We add the hbox to the main vbox
gtk_box_pack_start( GTK_BOX( main_vbox ), bottom_hbox, FALSE, FALSE, 0 );
g_signal_connect( play_button, "clicked", G_CALLBACK( play_cb ), NULL );
g_signal_connect( stop_button, "clicked", G_CALLBACK( stop_cb ), NULL );
g_signal_connect( prev_button, "clicked", G_CALLBACK( prev_cb ), NULL );
g_signal_connect( next_button, "clicked", G_CALLBACK( next_cb ), NULL );
g_signal_connect( playlist_button, "clicked", G_CALLBACK( playlist_cb ), NULL );
g_signal_connect( seekbar, "change-value",
G_CALLBACK( seekbar_changed_cb ), NULL );
gtk_widget_show_all( GTK_WIDGET( window ) );
gtk_widget_hide_all( p_intf->p_sys->p_playlist_window );
#if 1
/* HACK: Only one X11 client can subscribe to mouse button press events.
* VLC currently handles those in the video display.
* Force GTK to unsubscribe from mouse press and release events. */
Display *dpy = GDK_WINDOW_XDISPLAY( gtk_widget_get_window(p_intf->p_sys->p_video_window) );
Window w = GDK_WINDOW_XID( gtk_widget_get_window(p_intf->p_sys->p_video_window) );
XWindowAttributes attr;
XGetWindowAttributes( dpy, w, &attr );
attr.your_event_mask &= ~(ButtonPressMask|ButtonReleaseMask);
XSelectInput( dpy, w, attr.your_event_mask );
#endif
// The embedded video is only ready after gtk_main and windows are shown
g_idle_add( interface_ready, p_intf );
gtk_main();
delete_input( p_intf );
delete_playlist( p_intf );
gtk_object_destroy( GTK_OBJECT( main_menu ) );
gtk_object_destroy( GTK_OBJECT( window ) );
return NULL;
}
static int init_playlist()
{
WNDCLASS wc;
HINSTANCE user32;
LANGID _SysLangId;
HINSTANCE hInstance = GetModuleHandle(NULL);
if(hPlaylistWnd) {
updatetracklist(hPlaylistWnd);
ShowWindow(hPlaylistWnd, SW_SHOW);
return 0;
}
if(sys_Language == 1) {
LoadString(hInstance, IDS_PLAYLIST_SC, TitalPlaylist, 20);
LoadString(hInstance, IDS_BT_PLAY_SC, BottonPlayAll, 20);
LoadString(hInstance, IDS_BT_UP_SC, BottonUp, 20);
LoadString(hInstance, IDS_BT_DOWN_SC, BottonDown, 20);
LoadString(hInstance, IDS_BT_ADD_SC, BottonAdd, 20);
LoadString(hInstance, IDS_BT_REMOVE_SC, BottonRemove, 20);
LoadString(hInstance, IDS_BT_SAVE_SC, BottonSave, 20);
LoadString(hInstance, IDS_BT_CLOSE_SC, BottonClose, 20);
LoadString(hInstance, IDS_MU_ADD_SC, MenuAdd, 20);
LoadString(hInstance, IDS_MU_REMOVE_SC, MenuRemove, 20);
LoadString(hInstance, IDS_MU_CLEAR_SC, MenuClear, 20);
LoadString(hInstance, IDS_MU_CLOSE_SC, MenuClose, 20);
} else if(sys_Language == 3 || sys_Language == 4) {
LoadString(hInstance, IDS_PLAYLIST_TC, TitalPlaylist, 20);
LoadString(hInstance, IDS_BT_PLAY_TC, BottonPlayAll, 20);
LoadString(hInstance, IDS_BT_UP_TC, BottonUp, 20);
LoadString(hInstance, IDS_BT_DOWN_TC, BottonDown, 20);
LoadString(hInstance, IDS_BT_ADD_TC, BottonAdd, 20);
LoadString(hInstance, IDS_BT_REMOVE_TC, BottonRemove, 20);
LoadString(hInstance, IDS_BT_SAVE_TC, BottonSave, 20);
LoadString(hInstance, IDS_BT_CLOSE_TC, BottonClose, 20);
LoadString(hInstance, IDS_MU_ADD_TC, MenuAdd, 20);
LoadString(hInstance, IDS_MU_REMOVE_TC, MenuRemove, 20);
LoadString(hInstance, IDS_MU_CLEAR_TC, MenuClear, 20);
LoadString(hInstance, IDS_MU_CLOSE_TC, MenuClose, 20);
} else {
LoadString(hInstance, IDS_PLAYLIST_EN, TitalPlaylist, 20);
LoadString(hInstance, IDS_BT_PLAY_EN, BottonPlayAll, 20);
LoadString(hInstance, IDS_BT_UP_EN, BottonUp, 20);
LoadString(hInstance, IDS_BT_DOWN_EN, BottonDown, 20);
LoadString(hInstance, IDS_BT_ADD_EN, BottonAdd, 20);
LoadString(hInstance, IDS_BT_REMOVE_EN, BottonRemove, 20);
LoadString(hInstance, IDS_BT_SAVE_EN, BottonSave, 20);
LoadString(hInstance, IDS_BT_CLOSE_EN, BottonClose, 20);
LoadString(hInstance, IDS_MU_ADD_EN, MenuAdd, 20);
LoadString(hInstance, IDS_MU_REMOVE_EN, MenuRemove, 20);
LoadString(hInstance, IDS_MU_CLEAR_EN, MenuClear, 20);
LoadString(hInstance, IDS_MU_CLOSE_EN, MenuClose, 20);
}
code_page = CP_ACP;
_SysLangId = GetSystemDefaultLangID();
if(PRIMARYLANGID(_SysLangId) == LANG_CHINESE) {
if(SUBLANGID(_SysLangId) == SUBLANG_CHINESE_SIMPLIFIED)
code_page = 936;
else
code_page = 950;
}
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = PlayListWndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hCursor = LoadCursor(NULL,IDC_ARROW);
mplayericon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_APPICON));
wc.hIcon = mplayericon;
wc.hbrBackground = SOLID_GREY;
wc.lpszClassName = "MPlayer - Playlist";
wc.lpszMenuName = NULL;
RegisterClass(&wc);
create_playlistmenu();
bkgndbrush = CreateSolidBrush(RGB(236,236,236));
if(playlist_x < 0)
playlist_x = (GetSystemMetrics(SM_CXSCREEN) / 2) - (WinWidth / 2); /* Erik: center popup window on screen */
if(playlist_y < 0)
playlist_y = (GetSystemMetrics(SM_CYSCREEN) / 2) - (WinHeight / 2);
hPlaylistWnd = CreateWindow("MPlayer - Playlist",
TitalPlaylist, WS_OVERLAPPEDWINDOW | WS_SIZEBOX,
playlist_x, playlist_y, WinWidth, WinHeight,
playlist_parent, NULL, hInstance, NULL);
if((vo_dirver != VO_DIRV_OPENGL || is_vista) && controlbar_alpha > 0) {
user32 = GetModuleHandle("user32.dll");
if (user32) {
SetLayeredWinAttributes = GetProcAddress(user32, "SetLayeredWindowAttributes");
if(SetLayeredWinAttributes) {
SetWindowLong(hPlaylistWnd, GWL_EXSTYLE, GetWindowLong(hPlaylistWnd ,GWL_EXSTYLE) | WS_EX_LAYERED );
SetLayeredWinAttributes(hPlaylistWnd, 0, 255, 2);
}
}
}
DragAcceptFiles(hPlaylistWnd, TRUE);
if(!playlist)
playlist = create_playlist();
if(!need_update_playtree) {
playlist->clear_playlist(playlist);
import_playtree_into_playlist(mpctx->playtree, mconfig);
}
updatetracklist(hPlaylistWnd);
SetWindowPos(hPlaylistWnd, playlist_layer,playlist_x,playlist_y,WinWidth,WinHeight,SWP_SHOWWINDOW);
return 1;
}
