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.46 2004/02/26 12:04:14 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     int i_playlist_index = p_playlist->i_index;
 545     if( p_intf->p_sys->i_playing != i_playlist_index )
 546     {
 547         wxListItem listitem;
 548         listitem.m_itemId = i_playlist_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 = i_playlist_index;
 559     }
 560
 561     vlc_object_release( p_playlist );
 562 }
 563
 564 /*****************************************************************************
 565  * Private methods.
 566  *****************************************************************************/
 567 void Playlist::DeleteItem( int item )
 568 {
 569     playlist_t *p_playlist =
 570         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 571                                        FIND_ANYWHERE );
 572     if( p_playlist == NULL )
 573     {
 574         return;
 575     }
 576
 577     playlist_Delete( p_playlist, item );
 578     listview->DeleteItem( item );
 579
 580     vlc_object_release( p_playlist );
 581 }
 582
 583 void Playlist::OnClose( wxCommandEvent& WXUNUSED(event) )
 584 {
 585     Hide();
 586 }
 587
 588 void Playlist::OnSave( wxCommandEvent& WXUNUSED(event) )
 589 {
 590     struct {
 591         char *psz_desc;
 592         char *psz_filter;
 593         char *psz_module;
 594     } formats[] = {{ _("M3U file"), "*.m3u", "export-m3u" },
 595                    { _("PLS file"), "*.pls", "export-pls" }};
 596     wxString filter = wxT("");
 597     for( unsigned int i = 0; i < sizeof(formats)/sizeof(formats[0]); i++)
 598     {
 599         filter.Append( wxU(formats[i].psz_desc) );
 600         filter.Append( wxT("|") );
 601         filter.Append( wxU(formats[i].psz_filter) );
 602         filter.Append( wxT("|") );
 603     }
 604     wxFileDialog dialog( this, wxU(_("Save playlist")),
 605                          wxT(""), wxT(""), filter, wxSAVE );
 606
 607     if( dialog.ShowModal() == wxID_OK )
 608     {
 609
 610         playlist_t * p_playlist =
 611             (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 612                                            FIND_ANYWHERE );
 613
 614         if( p_playlist )
 615         {
 616             if( dialog.GetFilename().mb_str() )
 617             {
 618                 playlist_Export( p_playlist, dialog.GetFilename().mb_str(),
 619                                  formats[dialog.GetFilterIndex()].psz_module );
 620             }
 621         }
 622
 623         vlc_object_release( p_playlist );
 624
 625     }
 626 }
 627
 628 void Playlist::OnOpen( wxCommandEvent& WXUNUSED(event) )
 629 {
 630     playlist_t *p_playlist =
 631         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 632                                        FIND_ANYWHERE );
 633     if( p_playlist == NULL )
 634     {
 635         return;
 636     }
 637
 638     wxFileDialog dialog( this, wxU(_("Open playlist")), wxT(""), wxT(""),
 639         wxT("All playlists|*.pls;*.m3u;*.asx;*.b4s|M3U files|*.m3u"), wxOPEN );
 640
 641     if( dialog.ShowModal() == wxID_OK )
 642     {
 643         playlist_Import( p_playlist, dialog.GetPath().mb_str() );
 644     }
 645
 646     vlc_object_release( p_playlist );
 647 }
 648
 649 void Playlist::OnAddFile( wxCommandEvent& WXUNUSED(event) )
 650 {
 651     p_intf->p_sys->pf_show_dialog( p_intf, INTF_DIALOG_FILE_SIMPLE, 0, 0 );
 652
 653 #if 0
 654     Rebuild();
 655 #endif
 656 }
 657
 658 void Playlist::OnAddMRL( wxCommandEvent& WXUNUSED(event) )
 659 {
 660     p_intf->p_sys->pf_show_dialog( p_intf, INTF_DIALOG_FILE, 0, 0 );
 661
 662 #if 0
 663     Rebuild();
 664 #endif
 665 }
 666
 667 /********************************************************************
 668  * Move functions
 669  ********************************************************************/
 670 void Playlist::OnUp( wxCommandEvent& event )
 671 {
 672     playlist_t *p_playlist =
 673         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 674                                        FIND_ANYWHERE );
 675     if( p_playlist == NULL )
 676     {
 677         return;
 678     }
 679
 680     /* We use the first selected item, so find it */
 681     long i_item = listview->GetNextItem( -1, wxLIST_NEXT_ALL,
 682                                          wxLIST_STATE_SELECTED);
 683     if( i_item > 0 && i_item < p_playlist->i_size )
 684     {
 685         playlist_Move( p_playlist, i_item, i_item - 1 );
 686         listview->Focus( i_item - 1 );
 687     }
 688     vlc_object_release( p_playlist );
 689     return;
 690 }
 691
 692 void Playlist::OnDown( wxCommandEvent& event )
 693 {
 694     playlist_t *p_playlist =
 695         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 696                                        FIND_ANYWHERE );
 697     if( p_playlist == NULL )
 698     {
 699         return;
 700     }
 701
 702     /* We use the first selected item, so find it */
 703     long i_item = listview->GetNextItem( -1, wxLIST_NEXT_ALL,
 704                                          wxLIST_STATE_SELECTED );
 705     if( i_item >= 0 && i_item < p_playlist->i_size - 1 )
 706     {
 707         playlist_Move( p_playlist , i_item, i_item + 2 );
 708         listview->Focus( i_item + 1 );
 709     }
 710     vlc_object_release( p_playlist );
 711     return;
 712 }
 713
 714 /********************************************************************
 715  * Sorting functions
 716  ********************************************************************/
 717 void Playlist::OnSort( wxCommandEvent& event )
 718 {
 719     playlist_t *p_playlist =
 720         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 721                                        FIND_ANYWHERE );
 722     if( p_playlist == NULL )
 723     {
 724         return;
 725     }
 726     switch( event.GetId() )
 727     {
 728         case SortTitle_Event:
 729            playlist_SortTitle( p_playlist , ORDER_NORMAL );
 730            break;
 731         case RSortTitle_Event:
 732            playlist_SortTitle( p_playlist , ORDER_REVERSE );
 733            break;
 734         case SortAuthor_Event:
 735            playlist_SortAuthor(p_playlist , ORDER_NORMAL );
 736            break;
 737         case RSortAuthor_Event:
 738            playlist_SortAuthor( p_playlist , ORDER_REVERSE );
 739            break;
 740         case SortGroup_Event:
 741            playlist_SortGroup( p_playlist , ORDER_NORMAL );
 742            break;
 743         case RSortGroup_Event:
 744            playlist_SortGroup( p_playlist , ORDER_REVERSE );
 745            break;
 746         case Randomize_Event:
 747            playlist_Sort( p_playlist , SORT_RANDOM, ORDER_NORMAL );
 748            break;
 749     }
 750     vlc_object_release( p_playlist );
 751
 752     Rebuild();
 753
 754     return;
 755 }
 756
 757 void Playlist::OnColSelect( wxListEvent& event )
 758 {
 759     playlist_t *p_playlist =
 760         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 761                                        FIND_ANYWHERE );
 762     if( p_playlist == NULL )
 763     {
 764         return;
 765     }
 766     switch( event.GetColumn() )
 767     {
 768         case 0:
 769             if( i_title_sorted != 1 )
 770             {
 771                 playlist_SortTitle( p_playlist, ORDER_NORMAL );
 772                 i_title_sorted = 1;
 773             }
 774             else
 775             {
 776                 playlist_SortTitle( p_playlist, ORDER_REVERSE );
 777                 i_title_sorted = -1;
 778             }
 779             break;
 780         case 1:
 781             if( i_author_sorted != 1 )
 782             {
 783                 playlist_SortAuthor( p_playlist, ORDER_NORMAL );
 784                 i_author_sorted = 1;
 785             }
 786             else
 787             {
 788                 playlist_SortAuthor( p_playlist, ORDER_REVERSE );
 789                 i_author_sorted = -1;
 790             }
 791             break;
 792         case 2:
 793             if( i_duration_sorted != 1 )
 794             {
 795                 playlist_Sort( p_playlist, SORT_DURATION, ORDER_NORMAL );
 796                 i_duration_sorted = 1;
 797             }
 798             else
 799             {
 800                 playlist_Sort( p_playlist, SORT_DURATION, ORDER_REVERSE );
 801                 i_duration_sorted = -1;
 802             }
 803             break;
 804         case 3:
 805             if( i_group_sorted != 1 )
 806             {
 807                 playlist_SortGroup( p_playlist, ORDER_NORMAL );
 808                 i_group_sorted = 1;
 809             }
 810             else
 811             {
 812                 playlist_SortGroup( p_playlist, ORDER_REVERSE );
 813                 i_group_sorted = -1;
 814             }
 815             break;
 816         default:
 817             break;
 818     }
 819     vlc_object_release( p_playlist );
 820
 821     Rebuild();
 822
 823     return;
 824 }
 825
 826 /**********************************************************************
 827  * Search functions
 828  **********************************************************************/
 829 void Playlist::OnSearchTextChange( wxCommandEvent& WXUNUSED(event) )
 830 {
 831    search_button->SetDefault();
 832 }
 833
 834 void Playlist::OnSearch( wxCommandEvent& WXUNUSED(event) )
 835 {
 836     wxString search_string = search_text->GetValue();
 837
 838     int i_current;
 839     int i_first = 0 ;
 840     int i_item = -1;
 841
 842     for( i_current = 0; i_current < listview->GetItemCount(); i_current++ )
 843     {
 844         if( listview->GetItemState( i_current, wxLIST_STATE_SELECTED ) ==
 845               wxLIST_STATE_SELECTED )
 846         {
 847             i_first = i_current;
 848             break;
 849         }
 850     }
 851
 852     for( i_current = i_first + 1; i_current < listview->GetItemCount();
 853          i_current++ )
 854     {
 855         wxListItem listitem;
 856         listitem.SetId( i_current );
 857         listview->GetItem( listitem );
 858         if( listitem.m_text.Lower().Contains( search_string.Lower() ) )
 859         {
 860             i_item = i_current;
 861             break;
 862         }
 863     }
 864
 865     if( i_item < 0 || i_item >= listview->GetItemCount() ) return;
 866
 867     for( long item = 0; item < listview->GetItemCount(); item++ )
 868     {
 869         listview->Select( item, FALSE );
 870     }
 871
 872     wxListItem listitem;
 873     listitem.SetId(i_item);
 874     listitem.m_state = wxLIST_STATE_SELECTED;
 875     listview->Select( i_item, TRUE );
 876     listview->Focus( i_item );
 877
 878 }
 879
 880 /**********************************************************************
 881  * Selection functions
 882  **********************************************************************/
 883 void Playlist::OnInvertSelection( wxCommandEvent& WXUNUSED(event) )
 884 {
 885     for( long item = 0; item < listview->GetItemCount(); item++ )
 886     {
 887         listview->Select( item, ! listview->IsSelected( item ) );
 888     }
 889 }
 890
 891 void Playlist::OnDeleteSelection( wxCommandEvent& WXUNUSED(event) )
 892 {
 893     /* Delete from the end to the beginning, to avoid a shift of indices */
 894     for( long item = listview->GetItemCount() - 1; item >= 0; item-- )
 895     {
 896         if( listview->IsSelected( item ) )
 897         {
 898             DeleteItem( item );
 899         }
 900     }
 901
 902     Rebuild();
 903 }
 904
 905 void Playlist::OnEnableSelection( wxCommandEvent& WXUNUSED(event) )
 906 {
 907     playlist_t *p_playlist =
 908         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 909                                        FIND_ANYWHERE );
 910     if( p_playlist == NULL )
 911     {
 912         return;
 913     }
 914
 915     for( long item = listview->GetItemCount() - 1; item >= 0; item-- )
 916     {
 917         if( listview->IsSelected( item ) )
 918         {
 919             /*XXX*/
 920             playlist_Enable( p_playlist, item );
 921             UpdateItem( item );
 922         }
 923     }
 924     vlc_object_release( p_playlist);
 925 }
 926
 927 void Playlist::OnDisableSelection( wxCommandEvent& WXUNUSED(event) )
 928 {
 929     playlist_t *p_playlist =
 930         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 931                                        FIND_ANYWHERE );
 932     if( p_playlist == NULL )
 933     {
 934         return;
 935     }
 936
 937     for( long item = listview->GetItemCount() - 1; item >= 0; item-- )
 938     {
 939         if( listview->IsSelected( item ) )
 940         {
 941             /*XXX*/
 942             playlist_Disable( p_playlist, item );
 943             UpdateItem( item );
 944         }
 945     }
 946     vlc_object_release( p_playlist);
 947 }
 948
 949 void Playlist::OnSelectAll( wxCommandEvent& WXUNUSED(event) )
 950 {
 951     for( long item = 0; item < listview->GetItemCount(); item++ )
 952     {
 953         listview->Select( item, TRUE );
 954     }
 955 }
 956
 957 /**********************************************************************
 958  * Playlist mode functions
 959  **********************************************************************/
 960 void Playlist::OnRandom( wxCommandEvent& event )
 961 {
 962     vlc_value_t val;
 963     val.b_bool = event.IsChecked();
 964     playlist_t *p_playlist =
 965         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 966                                        FIND_ANYWHERE );
 967     if( p_playlist == NULL )
 968     {
 969         return;
 970     }
 971     var_Set( p_playlist , "random", val);
 972     vlc_object_release( p_playlist );
 973 }
 974
 975 void Playlist::OnLoop ( wxCommandEvent& event )
 976 {
 977     vlc_value_t val;
 978     val.b_bool = event.IsChecked();
 979     playlist_t *p_playlist =
 980         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 981                                        FIND_ANYWHERE );
 982     if( p_playlist == NULL )
 983     {
 984         return;
 985     }
 986     var_Set( p_playlist , "loop", val);
 987     vlc_object_release( p_playlist );
 988 }
 989
 990 void Playlist::OnRepeat ( wxCommandEvent& event )
 991 {
 992     vlc_value_t val;
 993     val.b_bool = event.IsChecked();
 994     playlist_t *p_playlist =
 995         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 996                                        FIND_ANYWHERE );
 997     if( p_playlist == NULL )
 998     {
 999         return;
1000     }
1001     var_Set( p_playlist , "repeat", val);
1002     vlc_object_release( p_playlist );
1003 }
1004
1005
1006
1007 void Playlist::OnActivateItem( wxListEvent& event )
1008 {
1009     playlist_t *p_playlist =
1010         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
1011                                        FIND_ANYWHERE );
1012     if( p_playlist == NULL )
1013     {
1014         return;
1015     }
1016
1017     playlist_Goto( p_playlist, event.GetIndex() );
1018
1019     vlc_object_release( p_playlist );
1020 }
1021
1022 void Playlist::OnKeyDown( wxListEvent& event )
1023 {
1024     long keycode = event.GetKeyCode();
1025     /* Delete selected items */
1026     if( keycode == WXK_BACK || keycode == WXK_DELETE )
1027     {
1028         /* We send a dummy event */
1029         OnDeleteSelection( event );
1030     }
1031 }
1032
1033 void Playlist::ShowInfos( int i_item )
1034 {
1035     playlist_t *p_playlist =
1036         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
1037                                        FIND_ANYWHERE );
1038     if( p_playlist == NULL )
1039     {
1040         return;
1041     }
1042     if( iteminfo_dialog == NULL )
1043     {
1044         vlc_mutex_lock( &p_playlist->object_lock);
1045         playlist_item_t *p_item = playlist_ItemGetByPos( p_playlist, i_item );
1046         vlc_mutex_unlock( &p_playlist->object_lock );
1047
1048         if( p_item )
1049         {
1050             iteminfo_dialog = new ItemInfoDialog(
1051                               p_intf, p_item , this );
1052             if( iteminfo_dialog->ShowModal()  == wxID_OK )
1053                 UpdateItem( i_item );
1054             delete iteminfo_dialog;
1055             iteminfo_dialog = NULL;
1056         }
1057     }
1058     vlc_object_release( p_playlist );
1059 }
1060
1061 void Playlist::OnInfos( wxCommandEvent& WXUNUSED(event) )
1062 {
1063     /* We use the first selected item, so find it */
1064     long i_item = listview->GetNextItem( -1 , wxLIST_NEXT_ALL,
1065                                          wxLIST_STATE_SELECTED );
1066     ShowInfos( i_item );
1067 }
1068
1069 void Playlist::OnEnDis( wxCommandEvent& event )
1070 {
1071     playlist_t *p_playlist =
1072         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
1073                                        FIND_ANYWHERE );
1074     if( p_playlist == NULL )
1075     {
1076         return;
1077     }
1078
1079     long i_item = listview->GetNextItem( i_item, wxLIST_NEXT_ALL,
1080                                          wxLIST_STATE_SELECTED );
1081
1082     if( i_item >= 0 && i_item < p_playlist->i_size )
1083     {
1084        switch( event.GetId() )
1085        {
1086            case EnableGroup_Event:
1087                /*XXX*/
1088                playlist_EnableGroup( p_playlist ,
1089                                   p_playlist->pp_items[i_item]->i_group );
1090                break;
1091            case DisableGroup_Event:
1092                playlist_DisableGroup( p_playlist ,
1093                                   p_playlist->pp_items[i_item]->i_group );
1094                break;
1095        }
1096        Rebuild();
1097     }
1098
1099     vlc_object_release( p_playlist );
1100 }
1101
1102 /*****************************************************************************
1103  * Popup management functions
1104  *****************************************************************************/
1105 void Playlist::OnPopup( wxListEvent& event )
1106 {
1107     i_popup_item = event.GetIndex();
1108     Playlist::PopupMenu( popup_menu , ScreenToClient( wxGetMousePosition() ) );
1109 }
1110
1111 void Playlist::OnPopupPlay( wxMenuEvent& event )
1112 {
1113     playlist_t *p_playlist =
1114         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
1115                                        FIND_ANYWHERE );
1116     if( p_playlist == NULL )
1117     {
1118         return;
1119     }
1120     if( i_popup_item != -1 )
1121     {
1122         playlist_Goto( p_playlist, i_popup_item );
1123     }
1124     vlc_object_release( p_playlist );
1125 }
1126
1127 void Playlist::OnPopupDel( wxMenuEvent& event )
1128 {
1129     DeleteItem( i_popup_item );
1130 }
1131
1132 void Playlist::OnPopupEna( wxMenuEvent& event )
1133 {
1134     playlist_t *p_playlist =
1135         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
1136                                        FIND_ANYWHERE );
1137     if( p_playlist == NULL )
1138     {
1139         return;
1140     }
1141
1142     if( p_playlist->pp_items[i_popup_item]->b_enabled )
1143         //playlist_IsEnabled( p_playlist, i_popup_item ) )
1144     {
1145         playlist_Disable( p_playlist, i_popup_item );
1146     }
1147     else
1148     {
1149         playlist_Enable( p_playlist, i_popup_item );
1150     }
1151     vlc_object_release( p_playlist);
1152     UpdateItem( i_popup_item );
1153 }
1154
1155 void Playlist::OnPopupInfo( wxMenuEvent& event )
1156 {
1157     ShowInfos( i_popup_item );
1158 }
1159
1160 /*****************************************************************************
1161  * Custom events management
1162  *****************************************************************************/
1163 void Playlist::OnPlaylistEvent( wxCommandEvent& event )
1164 {
1165     switch( event.GetId() )
1166     {
1167     case UpdateItem_Event:
1168         UpdateItem( event.GetInt() );
1169         break;
1170     }
1171 }
1172
1173 /*****************************************************************************
1174  * PlaylistChanged: callback triggered by the intf-change playlist variable
1175  *  We don't rebuild the playlist directly here because we don't want the
1176  *  caller to block for a too long time.
1177  *****************************************************************************/
1178 int PlaylistChanged( vlc_object_t *p_this, const char *psz_variable,
1179                      vlc_value_t old_val, vlc_value_t new_val, void *param )
1180 {
1181     Playlist *p_playlist_dialog = (Playlist *)param;
1182     p_playlist_dialog->b_need_update = VLC_TRUE;
1183     return VLC_SUCCESS;
1184 }
1185
1186 /*****************************************************************************
1187  * Next: callback triggered by the playlist-current playlist variable
1188  *****************************************************************************/
1189 int PlaylistNext( vlc_object_t *p_this, const char *psz_variable,
1190                  vlc_value_t old_val, vlc_value_t new_val, void *param )
1191 {
1192     Playlist *p_playlist_dialog = (Playlist *)param;
1193
1194     wxCommandEvent event( wxEVT_PLAYLIST, UpdateItem_Event );
1195     event.SetInt( old_val.i_int );
1196     p_playlist_dialog->AddPendingEvent( event );
1197     event.SetInt( new_val.i_int );
1198     p_playlist_dialog->AddPendingEvent( event );
1199
1200     return 0;
1201 }
1202
1203 /*****************************************************************************
1204  * ItemChanged: callback triggered by the item-change playlist variable
1205  *****************************************************************************/
1206 int ItemChanged( vlc_object_t *p_this, const char *psz_variable,
1207                  vlc_value_t old_val, vlc_value_t new_val, void *param )
1208 {
1209     Playlist *p_playlist_dialog = (Playlist *)param;
1210
1211     wxCommandEvent event( wxEVT_PLAYLIST, UpdateItem_Event );
1212     event.SetInt( new_val.i_int );
1213     p_playlist_dialog->AddPendingEvent( event );
1214
1215     return 0;
1216 }
1217
1218 /***************************************************************************
1219  * NewGroup Class
1220  ***************************************************************************/
1221 NewGroup::NewGroup( intf_thread_t *_p_intf, wxWindow *_p_parent ):
1222     wxDialog( _p_parent, -1, wxU(_("New Group")), wxDefaultPosition,
1223              wxDefaultSize, wxDEFAULT_FRAME_STYLE )
1224 {
1225     /* Initializations */
1226     p_intf = _p_intf;
1227     psz_name = NULL;
1228     SetIcon( *p_intf->p_sys->p_icon );
1229
1230     /* Create a panel to put everything in*/
1231     wxPanel *panel = new wxPanel( this, -1 );
1232     panel->SetAutoLayout( TRUE );
1233
1234     wxStaticText *group_label =
1235             new wxStaticText( panel , -1,
1236                 wxU(_("Enter a name for the new group:")));
1237
1238     groupname = new wxTextCtrl(panel, -1, wxU(""),wxDefaultPosition,
1239                                wxSize(100,27),wxTE_PROCESS_ENTER);
1240
1241     wxButton *ok_button = new wxButton(panel, wxID_OK, wxU(_("OK")) );
1242     ok_button->SetDefault();
1243     wxButton *cancel_button = new wxButton( panel, wxID_CANCEL,
1244                                             wxU(_("Cancel")) );
1245
1246     wxBoxSizer *button_sizer = new wxBoxSizer( wxHORIZONTAL );
1247
1248     button_sizer->Add( ok_button, 0, wxALL, 5 );
1249     button_sizer->Add( cancel_button, 0, wxALL, 5 );
1250     button_sizer->Layout();
1251
1252     wxBoxSizer *panel_sizer = new wxBoxSizer( wxVERTICAL );
1253     panel_sizer->Add( group_label, 0, wxEXPAND | wxALL, 5 );
1254     panel_sizer->Add( groupname, 0, wxEXPAND | wxALL, 5 );
1255     panel_sizer->Add( button_sizer, 0, wxEXPAND | wxALL, 5 );
1256     panel_sizer->Layout();
1257
1258     panel->SetSizerAndFit( panel_sizer );
1259
1260     wxBoxSizer *main_sizer = new wxBoxSizer( wxVERTICAL );
1261     main_sizer->Add( panel, 1, wxEXPAND, 0 );
1262     main_sizer->Layout();
1263     SetSizerAndFit( main_sizer );
1264 }
1265
1266 NewGroup::~NewGroup()
1267 {
1268 }
1269
1270 void NewGroup::OnOk( wxCommandEvent& event )
1271 {
1272     psz_name = strdup( groupname->GetLineText(0).mb_str() );
1273
1274     playlist_t * p_playlist =
1275           (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
1276                                        FIND_ANYWHERE );
1277
1278     if( p_playlist )
1279     {
1280         if( !playlist_CreateGroup( p_playlist, psz_name ) )
1281         {
1282             psz_name = NULL;
1283         }
1284         vlc_object_release( p_playlist );
1285     }
1286
1287     EndModal( wxID_OK );
1288 }
1289
1290 void NewGroup::OnCancel( wxCommandEvent& WXUNUSED(event) )
1291 {
1292     EndModal( wxID_CANCEL );
1293 }