git.sesse.net Git - vlc/blob - modules/gui/wxwindows/playlist.cpp

   1 /*****************************************************************************
   2  * playlist.cpp : wxWindows plugin for vlc
   3  *****************************************************************************
   4  * Copyright (C) 2000-2004 VideoLAN
   5  * $Id: playlist.cpp,v 1.45 2004/02/26 08:24:29 gbazin Exp $
   6  *
   7  * Authors: Olivier Teulière <ipkiss@via.ecp.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #include <vlc/vlc.h>
  28 #include <vlc/intf.h>
  29
  30 #include "wxwindows.h"
  31
  32 /* Callback prototype */
  33 int PlaylistChanged( vlc_object_t *p_this, const char *psz_variable,
  34                      vlc_value_t old_val, vlc_value_t new_val, void *param );
  35 int PlaylistNext( vlc_object_t *p_this, const char *psz_variable,
  36                      vlc_value_t old_val, vlc_value_t new_val, void *param );
  37 int ItemChanged( vlc_object_t *p_this, const char *psz_variable,
  38                      vlc_value_t old_val, vlc_value_t new_val, void *param );
  39
  40 /*****************************************************************************
  41  * Event Table.
  42  *****************************************************************************/
  43
  44 /* IDs for the controls and the menu commands */
  45 enum
  46 {
  47     /* menu items */
  48     AddFile_Event = 1,
  49     AddMRL_Event,
  50     Close_Event,
  51     Open_Event,
  52     Save_Event,
  53
  54     SortTitle_Event,
  55     RSortTitle_Event,
  56     SortAuthor_Event,
  57     RSortAuthor_Event,
  58     SortGroup_Event,
  59     RSortGroup_Event,
  60     Randomize_Event,
  61
  62     EnableSelection_Event,
  63     DisableSelection_Event,
  64
  65     InvertSelection_Event,
  66     DeleteSelection_Event,
  67     Random_Event,
  68     Loop_Event,
  69     Repeat_Event,
  70     SelectAll_Event,
  71
  72     EnableGroup_Event,
  73     DisableGroup_Event,
  74
  75     Up_Event,
  76     Down_Event,
  77     Infos_Event,
  78
  79     PopupPlay_Event,
  80     PopupDel_Event,
  81     PopupEna_Event,
  82     PopupInfo_Event,
  83
  84     SearchText_Event,
  85     Search_Event,
  86
  87     /* controls */
  88     ListView_Event,
  89
  90     Browse_Event,  /* For export playlist */
  91
  92     /* custom events */
  93     UpdateItem_Event
  94 };
  95
  96 DEFINE_LOCAL_EVENT_TYPE( wxEVT_PLAYLIST );
  97
  98 BEGIN_EVENT_TABLE(Playlist, wxFrame)
  99     /* Menu events */
 100     EVT_MENU(AddFile_Event, Playlist::OnAddFile)
 101     EVT_MENU(AddMRL_Event, Playlist::OnAddMRL)
 102     EVT_MENU(Close_Event, Playlist::OnClose)
 103     EVT_MENU(Open_Event, Playlist::OnOpen)
 104     EVT_MENU(Save_Event, Playlist::OnSave)
 105
 106     EVT_MENU(SortTitle_Event, Playlist::OnSort)
 107     EVT_MENU(RSortTitle_Event, Playlist::OnSort)
 108     EVT_MENU(SortAuthor_Event, Playlist::OnSort)
 109     EVT_MENU(RSortAuthor_Event, Playlist::OnSort)
 110     EVT_MENU(SortGroup_Event, Playlist::OnSort)
 111     EVT_MENU(RSortGroup_Event, Playlist::OnSort)
 112
 113     EVT_MENU(Randomize_Event, Playlist::OnSort)
 114
 115     EVT_MENU(EnableSelection_Event, Playlist::OnEnableSelection)
 116     EVT_MENU(DisableSelection_Event, Playlist::OnDisableSelection)
 117     EVT_MENU(InvertSelection_Event, Playlist::OnInvertSelection)
 118     EVT_MENU(DeleteSelection_Event, Playlist::OnDeleteSelection)
 119     EVT_MENU(SelectAll_Event, Playlist::OnSelectAll)
 120     EVT_MENU(Infos_Event, Playlist::OnInfos)
 121     EVT_CHECKBOX(Random_Event, Playlist::OnRandom)
 122     EVT_CHECKBOX(Repeat_Event, Playlist::OnRepeat)
 123     EVT_CHECKBOX(Loop_Event, Playlist::OnLoop)
 124
 125     EVT_MENU(EnableGroup_Event, Playlist::OnEnDis)
 126     EVT_MENU(DisableGroup_Event, Playlist::OnEnDis)
 127
 128     /* Listview events */
 129     EVT_LIST_ITEM_ACTIVATED(ListView_Event, Playlist::OnActivateItem)
 130     EVT_LIST_COL_CLICK(ListView_Event, Playlist::OnColSelect)
 131     EVT_LIST_KEY_DOWN(ListView_Event, Playlist::OnKeyDown)
 132     EVT_LIST_ITEM_RIGHT_CLICK(ListView_Event, Playlist::OnPopup)
 133
 134     /* Popup events */
 135     EVT_MENU( PopupPlay_Event, Playlist::OnPopupPlay)
 136     EVT_MENU( PopupDel_Event, Playlist::OnPopupDel)
 137     EVT_MENU( PopupEna_Event, Playlist::OnPopupEna)
 138     EVT_MENU( PopupInfo_Event, Playlist::OnPopupInfo)
 139
 140
 141     /* Button events */
 142     EVT_BUTTON( Search_Event, Playlist::OnSearch)
 143     EVT_BUTTON( Save_Event, Playlist::OnSave)
 144     EVT_BUTTON( Infos_Event, Playlist::OnInfos)
 145
 146     EVT_BUTTON( Up_Event, Playlist::OnUp)
 147     EVT_BUTTON( Down_Event, Playlist::OnDown)
 148
 149     EVT_TEXT(SearchText_Event, Playlist::OnSearchTextChange)
 150
 151     /* Custom events */
 152     EVT_COMMAND(-1, wxEVT_PLAYLIST, Playlist::OnPlaylistEvent)
 153
 154     /* Special events : we don't want to destroy the window when the user
 155      * clicks on (X) */
 156     EVT_CLOSE(Playlist::OnClose)
 157 END_EVENT_TABLE()
 158
 159
 160 /* Event Table for the Newgroup class */
 161 BEGIN_EVENT_TABLE(NewGroup, wxDialog)
 162     EVT_BUTTON( wxID_OK, NewGroup::OnOk)
 163     EVT_BUTTON( wxID_CANCEL, NewGroup::OnCancel)
 164 END_EVENT_TABLE()
 165
 166
 167 /*****************************************************************************
 168  * Constructor.
 169  *****************************************************************************/
 170 Playlist::Playlist( intf_thread_t *_p_intf, wxWindow *p_parent ):
 171     wxFrame( p_parent, -1, wxU(_("Playlist")), wxDefaultPosition,
 172              wxDefaultSize, wxDEFAULT_FRAME_STYLE )
 173 {
 174     vlc_value_t val;
 175
 176     /* Initializations */
 177     iteminfo_dialog = NULL;
 178     p_intf = _p_intf;
 179     i_update_counter = 0;
 180     i_sort_mode = MODE_NONE;
 181     b_need_update = VLC_FALSE;
 182     SetIcon( *p_intf->p_sys->p_icon );
 183
 184     i_title_sorted = 0;
 185     i_author_sorted = 0;
 186     i_group_sorted = 0;
 187     i_duration_sorted = 0;
 188
 189     var_Create( p_intf, "random", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 190     var_Create( p_intf, "loop", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 191     var_Create( p_intf, "repeat", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );;
 192
 193     /* Create our "Manage" menu */
 194     wxMenu *manage_menu = new wxMenu;
 195     manage_menu->Append( AddFile_Event, wxU(_("&Simple Add...")) );
 196     manage_menu->Append( AddMRL_Event, wxU(_("&Add MRL...")) );
 197     manage_menu->AppendSeparator();
 198     manage_menu->Append( Open_Event, wxU(_("&Open Playlist...")) );
 199     manage_menu->Append( Save_Event, wxU(_("&Save Playlist...")) );
 200     manage_menu->AppendSeparator();
 201     manage_menu->Append( Close_Event, wxU(_("&Close")) );
 202
 203     /* Create our "Sort" menu */
 204     wxMenu *sort_menu = new wxMenu;
 205     sort_menu->Append( SortTitle_Event, wxU(_("Sort by &title")) );
 206     sort_menu->Append( RSortTitle_Event, wxU(_("&Reverse sort by title")) );
 207     sort_menu->AppendSeparator();
 208     sort_menu->Append( SortAuthor_Event, wxU(_("Sort by &author")) );
 209     sort_menu->Append( RSortAuthor_Event, wxU(_("Reverse sort by author")) );
 210     sort_menu->AppendSeparator();
 211     sort_menu->Append( SortGroup_Event, wxU(_("Sort by &group")) );
 212     sort_menu->Append( RSortGroup_Event, wxU(_("Reverse sort by group")) );
 213     sort_menu->AppendSeparator();
 214     sort_menu->Append( Randomize_Event, wxU(_("&Shuffle Playlist")) );
 215
 216     /* Create our "Selection" menu */
 217     wxMenu *selection_menu = new wxMenu;
 218     selection_menu->Append( EnableSelection_Event, wxU(_("&Enable")) );
 219     selection_menu->Append( DisableSelection_Event, wxU(_("&Disable")) );
 220     selection_menu->AppendSeparator();
 221     selection_menu->Append( InvertSelection_Event, wxU(_("&Invert")) );
 222     selection_menu->Append( DeleteSelection_Event, wxU(_("D&elete")) );
 223     selection_menu->Append( SelectAll_Event, wxU(_("&Select All")) );
 224
 225     /* Create our "Group" menu */
 226     wxMenu *group_menu = new wxMenu;
 227     group_menu->Append( EnableGroup_Event, wxU(_("&Enable all group items")) );
 228     group_menu->Append( DisableGroup_Event,
 229                         wxU(_("&Disable all group items")) );
 230
 231     /* Append the freshly created menus to the menu bar */
 232     wxMenuBar *menubar = new wxMenuBar( wxMB_DOCKABLE );
 233     menubar->Append( manage_menu, wxU(_("&Manage")) );
 234     menubar->Append( sort_menu, wxU(_("S&ort")) );
 235     menubar->Append( selection_menu, wxU(_("&Selection")) );
 236     menubar->Append( group_menu, wxU(_("&Groups")) );
 237
 238     /* Attach the menu bar to the frame */
 239     SetMenuBar( menubar );
 240
 241     /* Create the popup menu */
 242     popup_menu = new wxMenu;
 243     popup_menu->Append( PopupPlay_Event, wxU(_("Play")) );
 244     popup_menu->Append( PopupDel_Event, wxU(_("Delete")) );
 245     popup_menu->Append( PopupEna_Event, wxU(_("Toggle enabled")) );
 246     popup_menu->Append( PopupInfo_Event, wxU(_("Info")) );
 247
 248     /* Create a panel to put everything in */
 249     wxPanel *playlist_panel = new wxPanel( this, -1 );
 250     playlist_panel->SetAutoLayout( TRUE );
 251
 252     /* Create the Random checkbox */
 253     wxCheckBox *random_checkbox =
 254         new wxCheckBox( playlist_panel, Random_Event, wxU(_("Random")) );
 255     var_Get( p_intf, "random", &val );
 256     vlc_bool_t b_random = val.b_bool;
 257     random_checkbox->SetValue( b_random == VLC_FALSE ? 0 : 1 );
 258
 259     /* Create the Loop Checkbox */
 260     wxCheckBox *loop_checkbox =
 261         new wxCheckBox( playlist_panel, Loop_Event, wxU(_("Repeat All")) );
 262     var_Get( p_intf, "loop", &val );
 263     int b_loop = val.b_bool ;
 264     loop_checkbox->SetValue( b_loop );
 265
 266     /* Create the Repeat one checkbox */
 267     wxCheckBox *repeat_checkbox =
 268         new wxCheckBox( playlist_panel, Repeat_Event, wxU(_("Repeat One")) );
 269     var_Get( p_intf, "repeat", &val );
 270     int b_repeat = val.b_bool ;
 271     repeat_checkbox->SetValue( b_repeat );
 272
 273     /* Create the Search Textbox */
 274     search_text =
 275         new wxTextCtrl( playlist_panel, SearchText_Event, wxT(""),
 276                         wxDefaultPosition, wxSize(140, -1),
 277                         wxTE_PROCESS_ENTER);
 278
 279     /* Create the search button */
 280     search_button =
 281         new wxButton( playlist_panel, Search_Event, wxU(_("Search")) );
 282
 283
 284     /* Create the listview */
 285     /* FIXME: the given size is arbitrary, and prevents us from resizing
 286      * the window to smaller dimensions. But the sizers don't seem to adjust
 287      * themselves to the size of a listview, and with a wxDefaultSize the
 288      * playlist window is ridiculously small */
 289     listview = new wxListView( playlist_panel, ListView_Event,
 290                                wxDefaultPosition, wxSize( 500, 300 ),
 291                                wxLC_REPORT | wxSUNKEN_BORDER );
 292     listview->InsertColumn( 0, wxU(_("Name")) );
 293     listview->InsertColumn( 1, wxU(_("Author")) );
 294     listview->InsertColumn( 2, wxU(_("Duration")) );
 295     listview->InsertColumn( 3, wxU(_("Group")) );
 296     listview->SetColumnWidth( 0, 270 );
 297     listview->SetColumnWidth( 1, 150 );
 298     listview->SetColumnWidth( 2, 80 );
 299
 300     /* Create the Up-Down buttons */
 301     wxButton *up_button =
 302         new wxButton( playlist_panel, Up_Event, wxU(_("Up") ) );
 303
 304     wxButton *down_button =
 305         new wxButton( playlist_panel, Down_Event, wxU(_("Down") ) );
 306
 307     /* Create the iteminfo button */
 308     wxButton *iteminfo_button =
 309         new wxButton( playlist_panel, Infos_Event, wxU(_("Item info") ) );
 310
 311     /* Place everything in sizers */
 312     wxBoxSizer *button_sizer = new wxBoxSizer( wxHORIZONTAL );
 313     button_sizer->Add( iteminfo_button, 0, wxALIGN_CENTER|wxLEFT , 5);
 314     button_sizer->Layout();
 315
 316     wxBoxSizer *updown_sizer = new wxBoxSizer( wxHORIZONTAL );
 317     updown_sizer->Add( up_button, 0, wxALIGN_LEFT|wxRIGHT, 3);
 318     updown_sizer->Add( down_button, 0, wxALIGN_LEFT|wxLEFT, 3);
 319     updown_sizer->Layout();
 320
 321     wxBoxSizer *checkbox_sizer = new wxBoxSizer( wxHORIZONTAL );
 322     checkbox_sizer->Add( random_checkbox, 0,
 323                          wxEXPAND | wxALIGN_RIGHT | wxALL, 5);
 324     checkbox_sizer->Add( loop_checkbox, 0,
 325                          wxEXPAND | wxALIGN_RIGHT | wxALL, 5);
 326     checkbox_sizer->Add( repeat_checkbox, 0,
 327                          wxEXPAND | wxALIGN_RIGHT | wxALL, 5);
 328     checkbox_sizer->Layout();
 329
 330     wxBoxSizer *search_sizer = new wxBoxSizer( wxHORIZONTAL );
 331     search_sizer->Add( search_text, 0, wxRIGHT|wxALIGN_CENTER, 3);
 332     search_sizer->Add( search_button, 0, wxLEFT|wxALIGN_CENTER, 3);
 333     search_sizer->Layout();
 334
 335     /* The top and bottom sizers */
 336     wxBoxSizer *top_sizer = new wxBoxSizer( wxHORIZONTAL );
 337     top_sizer->Add( checkbox_sizer, 1, wxLEFT|wxRIGHT|wxALIGN_LEFT, 4 );
 338     top_sizer->Add( search_sizer, 1, wxLEFT|wxRIGHT|wxALIGN_RIGHT, 4 );
 339     top_sizer->Layout();
 340
 341     wxBoxSizer *bottom_sizer = new wxBoxSizer( wxHORIZONTAL );
 342     bottom_sizer->Add( updown_sizer, 0,
 343                        wxEXPAND |wxRIGHT | wxLEFT | wxALIGN_LEFT, 4 );
 344     bottom_sizer->Add( button_sizer , 0,
 345                        wxEXPAND|wxLEFT | wxRIGHT | wxALIGN_RIGHT, 4 );
 346     bottom_sizer->Layout();
 347
 348     wxBoxSizer *main_sizer = new wxBoxSizer( wxVERTICAL );
 349
 350     wxBoxSizer *panel_sizer = new wxBoxSizer( wxVERTICAL );
 351     panel_sizer->Add( top_sizer, 0, wxEXPAND | wxALL, 5 );
 352     panel_sizer->Add( listview, 1, wxEXPAND | wxALL, 5 );
 353     panel_sizer->Add( bottom_sizer, 0 , wxEXPAND | wxALL, 5);
 354     panel_sizer->Layout();
 355
 356     playlist_panel->SetSizerAndFit( panel_sizer );
 357     main_sizer->Add( playlist_panel, 1, wxGROW, 0 );
 358     main_sizer->Layout();
 359     SetSizerAndFit( main_sizer );
 360
 361 #if !defined(__WXX11__)
 362     /* Associate drop targets with the playlist */
 363     SetDropTarget( new DragAndDrop( p_intf, VLC_TRUE ) );
 364 #endif
 365
 366     playlist_t *p_playlist =
 367         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 368                                        FIND_ANYWHERE );
 369     if( p_playlist == NULL )
 370     {
 371         return;
 372     }
 373
 374     /* We want to be noticed of playlist changes */
 375
 376     /* Some global changes happened -> Rebuild all */
 377     var_AddCallback( p_playlist, "intf-change", PlaylistChanged, this );
 378
 379     /* We went to the next item */
 380     var_AddCallback( p_playlist, "playlist-current", PlaylistNext, this );
 381
 382     /* One item has been updated */
 383     var_AddCallback( p_playlist, "item-change", ItemChanged, this );
 384
 385
 386     vlc_object_release( p_playlist );
 387
 388     /* Update the playlist */
 389     Rebuild();
 390 }
 391
 392 Playlist::~Playlist()
 393 {
 394     playlist_t *p_playlist =
 395         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 396                                        FIND_ANYWHERE );
 397     if( p_playlist == NULL )
 398     {
 399         return;
 400     }
 401
 402     delete iteminfo_dialog;
 403
 404     var_DelCallback( p_playlist, "item-change", ItemChanged, this );
 405     var_DelCallback( p_playlist, "playlist-current", PlaylistNext, this );
 406     var_DelCallback( p_playlist, "intf-change", PlaylistChanged, this );
 407     vlc_object_release( p_playlist );
 408 }
 409
 410 /**********************************************************************
 411  * Update one playlist item
 412  **********************************************************************/
 413 void Playlist::UpdateItem( int i )
 414 {
 415     if( i < 0 ) return; /* Sanity check */
 416
 417     playlist_t *p_playlist =
 418         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 419                                        FIND_ANYWHERE );
 420
 421     if( p_playlist == NULL )
 422     {
 423         return;
 424     }
 425
 426     playlist_item_t *p_item = playlist_ItemGetByPos( p_playlist, i );
 427
 428     if( !p_item )
 429     {
 430         vlc_object_release(p_playlist);
 431         return;
 432     }
 433
 434     listview->SetItem( i, 0, wxL2U(p_item->psz_name) );
 435     listview->SetItem( i, 1, wxU( playlist_ItemGetInfo( p_item,
 436                                        _("General") , _("Author") ) ) );
 437     char *psz_group = playlist_FindGroup(p_playlist,
 438                                          p_item->i_group);
 439     listview->SetItem( i, 3,
 440              wxL2U( psz_group ? psz_group : _("Normal") ) );
 441
 442     if( p_item->b_enabled == VLC_FALSE )
 443     {
 444         wxListItem listitem;
 445         listitem.m_itemId = i;
 446         listitem.SetTextColour( *wxLIGHT_GREY);
 447         listview->SetItem(listitem);
 448     }
 449
 450     char psz_duration[MSTRTIME_MAX_SIZE];
 451     mtime_t dur = p_item->i_duration;
 452     if( dur != -1 ) secstotimestr( psz_duration, dur/1000000 );
 453     else memcpy( psz_duration , "-:--:--", sizeof("-:--:--") );
 454     listview->SetItem( i, 2, wxU(psz_duration) );
 455
 456     /* Change the colour for the currenty played stream */
 457     wxListItem listitem;
 458     listitem.m_itemId = i;
 459     if( i == p_playlist->i_index )
 460     {
 461         listitem.SetTextColour( *wxRED );
 462     }
 463     else
 464     {
 465         listitem.SetTextColour( *wxBLACK );
 466     }
 467     listview->SetItem( listitem );
 468
 469     vlc_object_release(p_playlist);
 470 }
 471
 472 /**********************************************************************
 473  * Rebuild the playlist
 474  **********************************************************************/
 475 void Playlist::Rebuild()
 476 {
 477     playlist_t *p_playlist =
 478         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 479                                        FIND_ANYWHERE );
 480     if( p_playlist == NULL )
 481     {
 482         return;
 483     }
 484
 485     int i_focused = listview->GetFocusedItem();
 486
 487     /* Clear the list... */
 488     listview->DeleteAllItems();
 489
 490     /* ...and rebuild it */
 491     vlc_mutex_lock( &p_playlist->object_lock );
 492     for( int i = 0; i < p_playlist->i_size; i++ )
 493     {
 494         wxString filename = wxL2U(p_playlist->pp_items[i]->psz_name);
 495         listview->InsertItem( i, filename );
 496         UpdateItem( i );
 497     }
 498     vlc_mutex_unlock( &p_playlist->object_lock );
 499
 500     if( i_focused >= 0 && i_focused < p_playlist->i_size )
 501     {
 502         listview->Focus( i_focused );
 503         listview->Select( i_focused );
 504     }
 505     else if( p_playlist->i_index >= 0 )
 506     {
 507         listview->Focus( p_playlist->i_index );
 508     }
 509
 510     vlc_object_release( p_playlist );
 511 }
 512
 513 void Playlist::ShowPlaylist( bool show )
 514 {
 515     if( show ) Rebuild();
 516     Show( show );
 517 }
 518
 519 void Playlist::UpdatePlaylist()
 520 {
 521     i_update_counter++;
 522
 523     /* If the playlist isn't show there's no need to update it */
 524     if( !IsShown() ) return;
 525
 526     if( this->b_need_update )
 527     {
 528         this->b_need_update = VLC_FALSE;
 529         Rebuild();
 530     }
 531
 532     /* Updating the playing status every 0.5s is enough */
 533     if( i_update_counter % 5 ) return;
 534
 535     playlist_t *p_playlist =
 536         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 537                                        FIND_ANYWHERE );
 538     if( p_playlist == NULL )
 539     {
 540         return;
 541     }
 542
 543     /* Update the colour of items */
 544     vlc_mutex_lock( &p_playlist->object_lock );
 545     if( p_intf->p_sys->i_playing != p_playlist->i_index )
 546     {
 547         wxListItem listitem;
 548         listitem.m_itemId = p_playlist->i_index;
 549         listitem.SetTextColour( *wxRED );
 550         listview->SetItem( listitem );
 551
 552         if( p_intf->p_sys->i_playing != -1 )
 553         {
 554             listitem.m_itemId = p_intf->p_sys->i_playing;
 555             listitem.SetTextColour( *wxBLACK );
 556             listview->SetItem( listitem );
 557         }
 558         p_intf->p_sys->i_playing = p_playlist->i_index;
 559     }
 560     vlc_mutex_unlock( &p_playlist->object_lock );
 561
 562     vlc_object_release( p_playlist );
 563 }
 564
 565 /*****************************************************************************
 566  * Private methods.
 567  *****************************************************************************/
 568 void Playlist::DeleteItem( int item )
 569 {
 570     playlist_t *p_playlist =
 571         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 572                                        FIND_ANYWHERE );
 573     if( p_playlist == NULL )
 574     {
 575         return;
 576     }
 577
 578     playlist_Delete( p_playlist, item );
 579     listview->DeleteItem( item );
 580
 581     vlc_object_release( p_playlist );
 582 }
 583
 584 void Playlist::OnClose( wxCommandEvent& WXUNUSED(event) )
 585 {
 586     Hide();
 587 }
 588
 589 void Playlist::OnSave( wxCommandEvent& WXUNUSED(event) )
 590 {
 591     struct {
 592         char *psz_desc;
 593         char *psz_filter;
 594         char *psz_module;
 595     } formats[] = {{ _("M3U file"), "*.m3u", "export-m3u" },
 596                    { _("PLS file"), "*.pls", "export-pls" }};
 597     wxString filter = wxT("");
 598     for( unsigned int i = 0; i < sizeof(formats)/sizeof(formats[0]); i++)
 599     {
 600         filter.Append( wxU(formats[i].psz_desc) );
 601         filter.Append( wxT("|") );
 602         filter.Append( wxU(formats[i].psz_filter) );
 603         filter.Append( wxT("|") );
 604     }
 605     wxFileDialog dialog( this, wxU(_("Save playlist")),
 606                          wxT(""), wxT(""), filter, wxSAVE );
 607
 608     if( dialog.ShowModal() == wxID_OK )
 609     {
 610
 611         playlist_t * p_playlist =
 612             (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 613                                            FIND_ANYWHERE );
 614
 615         if( p_playlist )
 616         {
 617             if( dialog.GetFilename().mb_str() )
 618             {
 619                 playlist_Export( p_playlist, dialog.GetFilename().mb_str(),
 620                                  formats[dialog.GetFilterIndex()].psz_module );
 621             }
 622         }
 623
 624         vlc_object_release( p_playlist );
 625
 626     }
 627 }
 628
 629 void Playlist::OnOpen( wxCommandEvent& WXUNUSED(event) )
 630 {
 631     playlist_t *p_playlist =
 632         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 633                                        FIND_ANYWHERE );
 634     if( p_playlist == NULL )
 635     {
 636         return;
 637     }
 638
 639     wxFileDialog dialog( this, wxU(_("Open playlist")), wxT(""), wxT(""),
 640         wxT("All playlists|*.pls;*.m3u;*.asx;*.b4s|M3U files|*.m3u"), wxOPEN );
 641
 642     if( dialog.ShowModal() == wxID_OK )
 643     {
 644         playlist_Import( p_playlist, dialog.GetPath().mb_str() );
 645     }
 646
 647     vlc_object_release( p_playlist );
 648 }
 649
 650 void Playlist::OnAddFile( wxCommandEvent& WXUNUSED(event) )
 651 {
 652     p_intf->p_sys->pf_show_dialog( p_intf, INTF_DIALOG_FILE_SIMPLE, 0, 0 );
 653
 654 #if 0
 655     Rebuild();
 656 #endif
 657 }
 658
 659 void Playlist::OnAddMRL( wxCommandEvent& WXUNUSED(event) )
 660 {
 661     p_intf->p_sys->pf_show_dialog( p_intf, INTF_DIALOG_FILE, 0, 0 );
 662
 663 #if 0
 664     Rebuild();
 665 #endif
 666 }
 667
 668 /********************************************************************
 669  * Move functions
 670  ********************************************************************/
 671 void Playlist::OnUp( wxCommandEvent& event )
 672 {
 673     playlist_t *p_playlist =
 674         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 675                                        FIND_ANYWHERE );
 676     if( p_playlist == NULL )
 677     {
 678         return;
 679     }
 680
 681     /* We use the first selected item, so find it */
 682     long i_item = listview->GetNextItem( -1, wxLIST_NEXT_ALL,
 683                                          wxLIST_STATE_SELECTED);
 684     if( i_item > 0 && i_item < p_playlist->i_size )
 685     {
 686         playlist_Move( p_playlist, i_item, i_item - 1 );
 687         listview->Focus( i_item - 1 );
 688     }
 689     vlc_object_release( p_playlist );
 690     return;
 691 }
 692
 693 void Playlist::OnDown( wxCommandEvent& event )
 694 {
 695     playlist_t *p_playlist =
 696         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 697                                        FIND_ANYWHERE );
 698     if( p_playlist == NULL )
 699     {
 700         return;
 701     }
 702
 703     /* We use the first selected item, so find it */
 704     long i_item = listview->GetNextItem( -1, wxLIST_NEXT_ALL,
 705                                          wxLIST_STATE_SELECTED );
 706     if( i_item >= 0 && i_item < p_playlist->i_size - 1 )
 707     {
 708         playlist_Move( p_playlist , i_item, i_item + 2 );
 709         listview->Focus( i_item + 1 );
 710     }
 711     vlc_object_release( p_playlist );
 712     return;
 713 }
 714
 715 /********************************************************************
 716  * Sorting functions
 717  ********************************************************************/
 718 void Playlist::OnSort( wxCommandEvent& event )
 719 {
 720     playlist_t *p_playlist =
 721         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 722                                        FIND_ANYWHERE );
 723     if( p_playlist == NULL )
 724     {
 725         return;
 726     }
 727     switch( event.GetId() )
 728     {
 729         case SortTitle_Event:
 730            playlist_SortTitle( p_playlist , ORDER_NORMAL );
 731            break;
 732         case RSortTitle_Event:
 733            playlist_SortTitle( p_playlist , ORDER_REVERSE );
 734            break;
 735         case SortAuthor_Event:
 736            playlist_SortAuthor(p_playlist , ORDER_NORMAL );
 737            break;
 738         case RSortAuthor_Event:
 739            playlist_SortAuthor( p_playlist , ORDER_REVERSE );
 740            break;
 741         case SortGroup_Event:
 742            playlist_SortGroup( p_playlist , ORDER_NORMAL );
 743            break;
 744         case RSortGroup_Event:
 745            playlist_SortGroup( p_playlist , ORDER_REVERSE );
 746            break;
 747         case Randomize_Event:
 748            playlist_Sort( p_playlist , SORT_RANDOM, ORDER_NORMAL );
 749            break;
 750     }
 751     vlc_object_release( p_playlist );
 752
 753     Rebuild();
 754
 755     return;
 756 }
 757
 758 void Playlist::OnColSelect( wxListEvent& event )
 759 {
 760     playlist_t *p_playlist =
 761         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 762                                        FIND_ANYWHERE );
 763     if( p_playlist == NULL )
 764     {
 765         return;
 766     }
 767     switch( event.GetColumn() )
 768     {
 769         case 0:
 770             if( i_title_sorted != 1 )
 771             {
 772                 playlist_SortTitle( p_playlist, ORDER_NORMAL );
 773                 i_title_sorted = 1;
 774             }
 775             else
 776             {
 777                 playlist_SortTitle( p_playlist, ORDER_REVERSE );
 778                 i_title_sorted = -1;
 779             }
 780             break;
 781         case 1:
 782             if( i_author_sorted != 1 )
 783             {
 784                 playlist_SortAuthor( p_playlist, ORDER_NORMAL );
 785                 i_author_sorted = 1;
 786             }
 787             else
 788             {
 789                 playlist_SortAuthor( p_playlist, ORDER_REVERSE );
 790                 i_author_sorted = -1;
 791             }
 792             break;
 793         case 2:
 794             if( i_duration_sorted != 1 )
 795             {
 796                 playlist_Sort( p_playlist, SORT_DURATION, ORDER_NORMAL );
 797                 i_duration_sorted = 1;
 798             }
 799             else
 800             {
 801                 playlist_Sort( p_playlist, SORT_DURATION, ORDER_REVERSE );
 802                 i_duration_sorted = -1;
 803             }
 804             break;
 805         case 3:
 806             if( i_group_sorted != 1 )
 807             {
 808                 playlist_SortGroup( p_playlist, ORDER_NORMAL );
 809                 i_group_sorted = 1;
 810             }
 811             else
 812             {
 813                 playlist_SortGroup( p_playlist, ORDER_REVERSE );
 814                 i_group_sorted = -1;
 815             }
 816             break;
 817         default:
 818             break;
 819     }
 820     vlc_object_release( p_playlist );
 821
 822     Rebuild();
 823
 824     return;
 825 }
 826
 827 /**********************************************************************
 828  * Search functions
 829  **********************************************************************/
 830 void Playlist::OnSearchTextChange( wxCommandEvent& WXUNUSED(event) )
 831 {
 832    search_button->SetDefault();
 833 }
 834
 835 void Playlist::OnSearch( wxCommandEvent& WXUNUSED(event) )
 836 {
 837     wxString search_string = search_text->GetValue();
 838
 839     int i_current;
 840     int i_first = 0 ;
 841     int i_item = -1;
 842
 843     for( i_current = 0; i_current < listview->GetItemCount(); i_current++ )
 844     {
 845         if( listview->GetItemState( i_current, wxLIST_STATE_SELECTED ) ==
 846               wxLIST_STATE_SELECTED )
 847         {
 848             i_first = i_current;
 849             break;
 850         }
 851     }
 852
 853     for( i_current = i_first + 1; i_current < listview->GetItemCount();
 854          i_current++ )
 855     {
 856         wxListItem listitem;
 857         listitem.SetId( i_current );
 858         listview->GetItem( listitem );
 859         if( listitem.m_text.Lower().Contains( search_string.Lower() ) )
 860         {
 861             i_item = i_current;
 862             break;
 863         }
 864     }
 865
 866     if( i_item < 0 || i_item >= listview->GetItemCount() ) return;
 867
 868     for( long item = 0; item < listview->GetItemCount(); item++ )
 869     {
 870         listview->Select( item, FALSE );
 871     }
 872
 873     wxListItem listitem;
 874     listitem.SetId(i_item);
 875     listitem.m_state = wxLIST_STATE_SELECTED;
 876     listview->Select( i_item, TRUE );
 877     listview->Focus( i_item );
 878
 879 }
 880
 881 /**********************************************************************
 882  * Selection functions
 883  **********************************************************************/
 884 void Playlist::OnInvertSelection( wxCommandEvent& WXUNUSED(event) )
 885 {
 886     for( long item = 0; item < listview->GetItemCount(); item++ )
 887     {
 888         listview->Select( item, ! listview->IsSelected( item ) );
 889     }
 890 }
 891
 892 void Playlist::OnDeleteSelection( wxCommandEvent& WXUNUSED(event) )
 893 {
 894     /* Delete from the end to the beginning, to avoid a shift of indices */
 895     for( long item = listview->GetItemCount() - 1; item >= 0; item-- )
 896     {
 897         if( listview->IsSelected( item ) )
 898         {
 899             DeleteItem( item );
 900         }
 901     }
 902
 903     Rebuild();
 904 }
 905
 906 void Playlist::OnEnableSelection( wxCommandEvent& WXUNUSED(event) )
 907 {
 908     playlist_t *p_playlist =
 909         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 910                                        FIND_ANYWHERE );
 911     if( p_playlist == NULL )
 912     {
 913         return;
 914     }
 915
 916     for( long item = listview->GetItemCount() - 1; item >= 0; item-- )
 917     {
 918         if( listview->IsSelected( item ) )
 919         {
 920             /*XXX*/
 921             playlist_Enable( p_playlist, item );
 922             UpdateItem( item );
 923         }
 924     }
 925     vlc_object_release( p_playlist);
 926 }
 927
 928 void Playlist::OnDisableSelection( wxCommandEvent& WXUNUSED(event) )
 929 {
 930     playlist_t *p_playlist =
 931         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 932                                        FIND_ANYWHERE );
 933     if( p_playlist == NULL )
 934     {
 935         return;
 936     }
 937
 938     for( long item = listview->GetItemCount() - 1; item >= 0; item-- )
 939     {
 940         if( listview->IsSelected( item ) )
 941         {
 942             /*XXX*/
 943             playlist_Disable( p_playlist, item );
 944             UpdateItem( item );
 945         }
 946     }
 947     vlc_object_release( p_playlist);
 948 }
 949
 950 void Playlist::OnSelectAll( wxCommandEvent& WXUNUSED(event) )
 951 {
 952     for( long item = 0; item < listview->GetItemCount(); item++ )
 953     {
 954         listview->Select( item, TRUE );
 955     }
 956 }
 957
 958 /**********************************************************************
 959  * Playlist mode functions
 960  **********************************************************************/
 961 void Playlist::OnRandom( wxCommandEvent& event )
 962 {
 963     vlc_value_t val;
 964     val.b_bool = event.IsChecked();
 965     playlist_t *p_playlist =
 966         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 967                                        FIND_ANYWHERE );
 968     if( p_playlist == NULL )
 969     {
 970         return;
 971     }
 972     var_Set( p_playlist , "random", val);
 973     vlc_object_release( p_playlist );
 974 }
 975
 976 void Playlist::OnLoop ( wxCommandEvent& event )
 977 {
 978     vlc_value_t val;
 979     val.b_bool = event.IsChecked();
 980     playlist_t *p_playlist =
 981         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 982                                        FIND_ANYWHERE );
 983     if( p_playlist == NULL )
 984     {
 985         return;
 986     }
 987     var_Set( p_playlist , "loop", val);
 988     vlc_object_release( p_playlist );
 989 }
 990
 991 void Playlist::OnRepeat ( wxCommandEvent& event )
 992 {
 993     vlc_value_t val;
 994     val.b_bool = event.IsChecked();
 995     playlist_t *p_playlist =
 996         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 997                                        FIND_ANYWHERE );
 998     if( p_playlist == NULL )
 999     {
1000         return;
1001     }
1002     var_Set( p_playlist , "repeat", val);
1003     vlc_object_release( p_playlist );
1004 }
1005
1006
1007
1008 void Playlist::OnActivateItem( wxListEvent& event )
1009 {
1010     playlist_t *p_playlist =
1011         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
1012                                        FIND_ANYWHERE );
1013     if( p_playlist == NULL )
1014     {
1015         return;
1016     }
1017
1018     playlist_Goto( p_playlist, event.GetIndex() );
1019
1020     vlc_object_release( p_playlist );
1021 }
1022
1023 void Playlist::OnKeyDown( wxListEvent& event )
1024 {
1025     long keycode = event.GetKeyCode();
1026     /* Delete selected items */
1027     if( keycode == WXK_BACK || keycode == WXK_DELETE )
1028     {
1029         /* We send a dummy event */
1030         OnDeleteSelection( event );
1031     }
1032 }
1033
1034 void Playlist::ShowInfos( int i_item )
1035 {
1036     playlist_t *p_playlist =
1037         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
1038                                        FIND_ANYWHERE );
1039     if( p_playlist == NULL )
1040     {
1041         return;
1042     }
1043     if( iteminfo_dialog == NULL )
1044     {
1045         vlc_mutex_lock( &p_playlist->object_lock);
1046         playlist_item_t *p_item = playlist_ItemGetByPos( p_playlist, i_item );
1047         vlc_mutex_unlock( &p_playlist->object_lock );
1048
1049         if( p_item )
1050         {
1051             iteminfo_dialog = new ItemInfoDialog(
1052                               p_intf, p_item , this );
1053             if( iteminfo_dialog->ShowModal()  == wxID_OK )
1054                 UpdateItem( i_item );
1055             delete iteminfo_dialog;
1056             iteminfo_dialog = NULL;
1057         }
1058     }
1059     vlc_object_release( p_playlist );
1060 }
1061
1062 void Playlist::OnInfos( wxCommandEvent& WXUNUSED(event) )
1063 {
1064     /* We use the first selected item, so find it */
1065     long i_item = listview->GetNextItem( -1 , wxLIST_NEXT_ALL,
1066                                          wxLIST_STATE_SELECTED );
1067     ShowInfos( i_item );
1068 }
1069
1070 void Playlist::OnEnDis( wxCommandEvent& event )
1071 {
1072     playlist_t *p_playlist =
1073         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
1074                                        FIND_ANYWHERE );
1075     if( p_playlist == NULL )
1076     {
1077         return;
1078     }
1079
1080     long i_item = listview->GetNextItem( i_item, wxLIST_NEXT_ALL,
1081                                          wxLIST_STATE_SELECTED );
1082
1083     if( i_item >= 0 && i_item < p_playlist->i_size )
1084     {
1085        switch( event.GetId() )
1086        {
1087            case EnableGroup_Event:
1088                /*XXX*/
1089                playlist_EnableGroup( p_playlist ,
1090                                   p_playlist->pp_items[i_item]->i_group );
1091                break;
1092            case DisableGroup_Event:
1093                playlist_DisableGroup( p_playlist ,
1094                                   p_playlist->pp_items[i_item]->i_group );
1095                break;
1096        }
1097        Rebuild();
1098     }
1099
1100     vlc_object_release( p_playlist );
1101 }
1102
1103 /*****************************************************************************
1104  * Popup management functions
1105  *****************************************************************************/
1106 void Playlist::OnPopup( wxListEvent& event )
1107 {
1108     i_popup_item = event.GetIndex();
1109     Playlist::PopupMenu( popup_menu , ScreenToClient( wxGetMousePosition() ) );
1110 }
1111
1112 void Playlist::OnPopupPlay( wxMenuEvent& event )
1113 {
1114     playlist_t *p_playlist =
1115         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
1116                                        FIND_ANYWHERE );
1117     if( p_playlist == NULL )
1118     {
1119         return;
1120     }
1121     if( i_popup_item != -1 )
1122     {
1123         playlist_Goto( p_playlist, i_popup_item );
1124     }
1125     vlc_object_release( p_playlist );
1126 }
1127
1128 void Playlist::OnPopupDel( wxMenuEvent& event )
1129 {
1130     DeleteItem( i_popup_item );
1131 }
1132
1133 void Playlist::OnPopupEna( wxMenuEvent& event )
1134 {
1135     playlist_t *p_playlist =
1136         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
1137                                        FIND_ANYWHERE );
1138     if( p_playlist == NULL )
1139     {
1140         return;
1141     }
1142
1143     if( p_playlist->pp_items[i_popup_item]->b_enabled )
1144         //playlist_IsEnabled( p_playlist, i_popup_item ) )
1145     {
1146         playlist_Disable( p_playlist, i_popup_item );
1147     }
1148     else
1149     {
1150         playlist_Enable( p_playlist, i_popup_item );
1151     }
1152     vlc_object_release( p_playlist);
1153     UpdateItem( i_popup_item );
1154 }
1155
1156 void Playlist::OnPopupInfo( wxMenuEvent& event )
1157 {
1158     ShowInfos( i_popup_item );
1159 }
1160
1161 /*****************************************************************************
1162  * Custom events management
1163  *****************************************************************************/
1164 void Playlist::OnPlaylistEvent( wxCommandEvent& event )
1165 {
1166     switch( event.GetId() )
1167     {
1168     case UpdateItem_Event:
1169         UpdateItem( event.GetInt() );
1170         break;
1171     }
1172 }
1173
1174 /*****************************************************************************
1175  * PlaylistChanged: callback triggered by the intf-change playlist variable
1176  *  We don't rebuild the playlist directly here because we don't want the
1177  *  caller to block for a too long time.
1178  *****************************************************************************/
1179 int PlaylistChanged( vlc_object_t *p_this, const char *psz_variable,
1180                      vlc_value_t old_val, vlc_value_t new_val, void *param )
1181 {
1182     Playlist *p_playlist_dialog = (Playlist *)param;
1183     p_playlist_dialog->b_need_update = VLC_TRUE;
1184     return VLC_SUCCESS;
1185 }
1186
1187 /*****************************************************************************
1188  * Next: callback triggered by the playlist-current playlist variable
1189  *****************************************************************************/
1190 int PlaylistNext( vlc_object_t *p_this, const char *psz_variable,
1191                  vlc_value_t old_val, vlc_value_t new_val, void *param )
1192 {
1193     Playlist *p_playlist_dialog = (Playlist *)param;
1194
1195     wxCommandEvent event( wxEVT_PLAYLIST, UpdateItem_Event );
1196     event.SetInt( old_val.i_int );
1197     p_playlist_dialog->AddPendingEvent( event );
1198     event.SetInt( new_val.i_int );
1199     p_playlist_dialog->AddPendingEvent( event );
1200
1201     return 0;
1202 }
1203
1204 /*****************************************************************************
1205  * ItemChanged: callback triggered by the item-change playlist variable
1206  *****************************************************************************/
1207 int ItemChanged( vlc_object_t *p_this, const char *psz_variable,
1208                  vlc_value_t old_val, vlc_value_t new_val, void *param )
1209 {
1210     Playlist *p_playlist_dialog = (Playlist *)param;
1211
1212     wxCommandEvent event( wxEVT_PLAYLIST, UpdateItem_Event );
1213     event.SetInt( new_val.i_int );
1214     p_playlist_dialog->AddPendingEvent( event );
1215
1216     return 0;
1217 }
1218
1219 /***************************************************************************
1220  * NewGroup Class
1221  ***************************************************************************/
1222 NewGroup::NewGroup( intf_thread_t *_p_intf, wxWindow *_p_parent ):
1223     wxDialog( _p_parent, -1, wxU(_("New Group")), wxDefaultPosition,
1224              wxDefaultSize, wxDEFAULT_FRAME_STYLE )
1225 {
1226     /* Initializations */
1227     p_intf = _p_intf;
1228     psz_name = NULL;
1229     SetIcon( *p_intf->p_sys->p_icon );
1230
1231     /* Create a panel to put everything in*/
1232     wxPanel *panel = new wxPanel( this, -1 );
1233     panel->SetAutoLayout( TRUE );
1234
1235     wxStaticText *group_label =
1236             new wxStaticText( panel , -1,
1237                 wxU(_("Enter a name for the new group:")));
1238
1239     groupname = new wxTextCtrl(panel, -1, wxU(""),wxDefaultPosition,
1240                                wxSize(100,27),wxTE_PROCESS_ENTER);
1241
1242     wxButton *ok_button = new wxButton(panel, wxID_OK, wxU(_("OK")) );
1243     ok_button->SetDefault();
1244     wxButton *cancel_button = new wxButton( panel, wxID_CANCEL,
1245                                             wxU(_("Cancel")) );
1246
1247     wxBoxSizer *button_sizer = new wxBoxSizer( wxHORIZONTAL );
1248
1249     button_sizer->Add( ok_button, 0, wxALL, 5 );
1250     button_sizer->Add( cancel_button, 0, wxALL, 5 );
1251     button_sizer->Layout();
1252
1253     wxBoxSizer *panel_sizer = new wxBoxSizer( wxVERTICAL );
1254     panel_sizer->Add( group_label, 0, wxEXPAND | wxALL, 5 );
1255     panel_sizer->Add( groupname, 0, wxEXPAND | wxALL, 5 );
1256     panel_sizer->Add( button_sizer, 0, wxEXPAND | wxALL, 5 );
1257     panel_sizer->Layout();
1258
1259     panel->SetSizerAndFit( panel_sizer );
1260
1261     wxBoxSizer *main_sizer = new wxBoxSizer( wxVERTICAL );
1262     main_sizer->Add( panel, 1, wxEXPAND, 0 );
1263     main_sizer->Layout();
1264     SetSizerAndFit( main_sizer );
1265 }
1266
1267 NewGroup::~NewGroup()
1268 {
1269 }
1270
1271 void NewGroup::OnOk( wxCommandEvent& event )
1272 {
1273     psz_name = strdup( groupname->GetLineText(0).mb_str() );
1274
1275     playlist_t * p_playlist =
1276           (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
1277                                        FIND_ANYWHERE );
1278
1279     if( p_playlist )
1280     {
1281         if( !playlist_CreateGroup( p_playlist, psz_name ) )
1282         {
1283             psz_name = NULL;
1284         }
1285         vlc_object_release( p_playlist );
1286     }
1287
1288     EndModal( wxID_OK );
1289 }
1290
1291 void NewGroup::OnCancel( wxCommandEvent& WXUNUSED(event) )
1292 {
1293     EndModal( wxID_CANCEL );
1294 }