开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 查看源码
playlist.cpp
资源名称：vlc-0.8.1.tar.gz　[点击查看]
上传用户：riyaled888
上传日期：2009-03-27
资源大小：7338k
文件大小：41k
源码类别：

多媒体

开发平台：

MultiPlatform

playlist.cpp：源码内容
  1. /*****************************************************************************
  2.  * playlist.cpp : wxWindows plugin for vlc
  3.  *****************************************************************************
  4.  * Copyright (C) 2000-2004 VideoLAN
  5.  * $Id: playlist.cpp 8563 2004-08-29 09:04:20Z zorglub $
  6.  *
  7.  * Authors: Olivier Teuli鑢e <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.  *****************************************************************************/
  24. /*****************************************************************************
  25.  * Preamble
  26.  *****************************************************************************/
  27. #include <vlc/vlc.h>
  28. #include <vlc/intf.h>
  30. #include "wxwindows.h"
  32. #include "bitmaps/shuffle.xpm"
  33. #include "bitmaps/repeat.xpm"
  34. #include "bitmaps/loop.xpm"
  37. #define HELP_SHUFFLE N_( "Shuffle" )
  38. #define HELP_LOOP N_( "Loop" )
  39. #define HELP_REPEAT N_( "Repeat" )
  41. /* Callback prototype */
  42. static int PlaylistChanged( vlc_object_t *, const char *,
  43.                             vlc_value_t, vlc_value_t, void * );
  44. static int PlaylistNext( vlc_object_t *, const char *,
  45.                          vlc_value_t, vlc_value_t, void * );
  46. static int ItemChanged( vlc_object_t *, const char *,
  47.                         vlc_value_t, vlc_value_t, void * );
  49. /*****************************************************************************
  50.  * Event Table.
  51.  *****************************************************************************/
  53. /* IDs for the controls and the menu commands */
  54. enum
  55. {
  56.     /* menu items */
  57.     AddFile_Event = 1,
  58.     AddMRL_Event,
  59.     Close_Event,
  60.     Open_Event,
  61.     Save_Event,
  63.     SortTitle_Event,
  64.     RSortTitle_Event,
  65.     SortAuthor_Event,
  66.     RSortAuthor_Event,
  67.     SortGroup_Event,
  68.     RSortGroup_Event,
  69.     Randomize_Event,
  71.     EnableSelection_Event,
  72.     DisableSelection_Event,
  74.     InvertSelection_Event,
  75.     DeleteSelection_Event,
  76.     Random_Event,
  77.     Loop_Event,
  78.     Repeat_Event,
  79.     SelectAll_Event,
  81.     EnableGroup_Event,
  82.     DisableGroup_Event,
  84.     Up_Event,
  85.     Down_Event,
  86.     Infos_Event,
  88.     PopupPlay_Event,
  89.     PopupDel_Event,
  90.     PopupEna_Event,
  91.     PopupInfo_Event,
  93.     SearchText_Event,
  94.     Search_Event,
  96.     /* controls */
  97.     ListView_Event,
  99.     Browse_Event,  /* For export playlist */
  101.     /* custom events */
  102.     UpdateItem_Event
  103. };
  105. DEFINE_LOCAL_EVENT_TYPE( wxEVT_PLAYLIST );
  107. BEGIN_EVENT_TABLE(Playlist, wxFrame)
  108.     EVT_SIZE(Playlist::OnSize)
  110.     /* Menu events */
  111.     EVT_MENU(AddFile_Event, Playlist::OnAddFile)
  112.     EVT_MENU(AddMRL_Event, Playlist::OnAddMRL)
  113.     EVT_MENU(Close_Event, Playlist::OnClose)
  114.     EVT_MENU(Open_Event, Playlist::OnOpen)
  115.     EVT_MENU(Save_Event, Playlist::OnSave)
  117.     EVT_MENU(SortTitle_Event, Playlist::OnSort)
  118.     EVT_MENU(RSortTitle_Event, Playlist::OnSort)
  119.     EVT_MENU(SortAuthor_Event, Playlist::OnSort)
  120.     EVT_MENU(RSortAuthor_Event, Playlist::OnSort)
  121.     EVT_MENU(SortGroup_Event, Playlist::OnSort)
  122.     EVT_MENU(RSortGroup_Event, Playlist::OnSort)
  124.     EVT_MENU(Randomize_Event, Playlist::OnSort)
  126.     EVT_MENU(EnableSelection_Event, Playlist::OnEnableSelection)
  127.     EVT_MENU(DisableSelection_Event, Playlist::OnDisableSelection)
  128.     EVT_MENU(InvertSelection_Event, Playlist::OnInvertSelection)
  129.     EVT_MENU(DeleteSelection_Event, Playlist::OnDeleteSelection)
  130.     EVT_MENU(SelectAll_Event, Playlist::OnSelectAll)
  131.     EVT_MENU(Infos_Event, Playlist::OnInfos)
  133.     EVT_TOOL(Random_Event, Playlist::OnRandom)
  134.     EVT_TOOL(Repeat_Event, Playlist::OnRepeat)
  135.     EVT_TOOL(Loop_Event, Playlist::OnLoop)
  137.     EVT_MENU(EnableGroup_Event, Playlist::OnEnDis)
  138.     EVT_MENU(DisableGroup_Event, Playlist::OnEnDis)
  140.     /* Listview events */
  141.     EVT_LIST_ITEM_ACTIVATED(ListView_Event, Playlist::OnActivateItem)
  142.     EVT_LIST_COL_CLICK(ListView_Event, Playlist::OnColSelect)
  143.     EVT_LIST_KEY_DOWN(ListView_Event, Playlist::OnKeyDown)
  144.     EVT_LIST_ITEM_RIGHT_CLICK(ListView_Event, Playlist::OnPopup)
  146.     /* Popup events */
  147.     EVT_MENU( PopupPlay_Event, Playlist::OnPopupPlay)
  148.     EVT_MENU( PopupDel_Event, Playlist::OnPopupDel)
  149.     EVT_MENU( PopupEna_Event, Playlist::OnPopupEna)
  150.     EVT_MENU( PopupInfo_Event, Playlist::OnPopupInfo)
  153.     /* Button events */
  154.     EVT_BUTTON( Search_Event, Playlist::OnSearch)
  155.     EVT_BUTTON( Save_Event, Playlist::OnSave)
  156.     EVT_BUTTON( Infos_Event, Playlist::OnInfos)
  158.     EVT_BUTTON( Up_Event, Playlist::OnUp)
  159.     EVT_BUTTON( Down_Event, Playlist::OnDown)
  161.     EVT_TEXT(SearchText_Event, Playlist::OnSearchTextChange)
  163.     /* Custom events */
  164.     EVT_COMMAND(-1, wxEVT_PLAYLIST, Playlist::OnPlaylistEvent)
  166.     /* Special events : we don't want to destroy the window when the user
  167.      * clicks on (X) */
  168.     EVT_CLOSE(Playlist::OnClose)
  169. END_EVENT_TABLE()
  172. /* Event Table for the Newgroup class */
  173. BEGIN_EVENT_TABLE(NewGroup, wxDialog)
  174.     EVT_BUTTON( wxID_OK, NewGroup::OnOk)
  175.     EVT_BUTTON( wxID_CANCEL, NewGroup::OnCancel)
  176. END_EVENT_TABLE()
  179. /*****************************************************************************
  180.  * Constructor.
  181.  *****************************************************************************/
  182. Playlist::Playlist( intf_thread_t *_p_intf, wxWindow *p_parent ):
  183.     wxFrame( p_parent, -1, wxU(_("Playlist")), wxDefaultPosition,
  184.              wxSize(345,400), wxDEFAULT_FRAME_STYLE ), listview(NULL)
  185. {
  186.     vlc_value_t val;
  188.     /* Initializations */
  189.     p_intf = _p_intf;
  190.     i_update_counter = 0;
  191.     i_sort_mode = MODE_NONE;
  192.     b_need_update = VLC_FALSE;
  193.     SetIcon( *p_intf->p_sys->p_icon );
  195.     i_title_sorted = 0;
  196.     i_author_sorted = 0;
  197.     i_group_sorted = 0;
  198.     i_duration_sorted = 0;
  200.     var_Create( p_intf, "random", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
  201.     var_Create( p_intf, "loop", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
  202.     var_Create( p_intf, "repeat", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );;
  204.     /* Create our "Manage" menu */
  205.     wxMenu *manage_menu = new wxMenu;
  206.     manage_menu->Append( AddFile_Event, wxU(_("&Simple Add...")) );
  207.     manage_menu->Append( AddMRL_Event, wxU(_("&Add MRL...")) );
  208.     manage_menu->AppendSeparator();
  209.     manage_menu->Append( Open_Event, wxU(_("&Open Playlist...")) );
  210.     manage_menu->Append( Save_Event, wxU(_("&Save Playlist...")) );
  211.     manage_menu->AppendSeparator();
  212.     manage_menu->Append( Close_Event, wxU(_("&Close")) );
  214.     /* Create our "Sort" menu */
  215.     wxMenu *sort_menu = new wxMenu;
  216.     sort_menu->Append( SortTitle_Event, wxU(_("Sort by &title")) );
  217.     sort_menu->Append( RSortTitle_Event, wxU(_("&Reverse sort by title")) );
  218.     sort_menu->AppendSeparator();
  219.     sort_menu->Append( SortAuthor_Event, wxU(_("Sort by &author")) );
  220.     sort_menu->Append( RSortAuthor_Event, wxU(_("Reverse sort by author")) );
  221.     sort_menu->AppendSeparator();
  222.     sort_menu->Append( SortGroup_Event, wxU(_("Sort by &group")) );
  223.     sort_menu->Append( RSortGroup_Event, wxU(_("Reverse sort by group")) );
  224.     sort_menu->AppendSeparator();
  225.     sort_menu->Append( Randomize_Event, wxU(_("&Shuffle Playlist")) );
  227.     /* Create our "Selection" menu */
  228.     wxMenu *selection_menu = new wxMenu;
  229.     selection_menu->Append( EnableSelection_Event, wxU(_("&Enable")) );
  230.     selection_menu->Append( DisableSelection_Event, wxU(_("&Disable")) );
  231.     selection_menu->AppendSeparator();
  232.     selection_menu->Append( InvertSelection_Event, wxU(_("&Invert")) );
  233.     selection_menu->Append( DeleteSelection_Event, wxU(_("D&elete")) );
  234.     selection_menu->Append( SelectAll_Event, wxU(_("&Select All")) );
  236.     /* Create our "Group" menu */
  237.     wxMenu *group_menu = new wxMenu;
  238.     group_menu->Append( EnableGroup_Event, wxU(_("&Enable all group items")) );
  239.     group_menu->Append( DisableGroup_Event,
  240.                         wxU(_("&Disable all group items")) );
  242.     /* Append the freshly created menus to the menu bar */
  243.     wxMenuBar *menubar = new wxMenuBar( wxMB_DOCKABLE );
  244.     menubar->Append( manage_menu, wxU(_("&Manage")) );
  245.     menubar->Append( sort_menu, wxU(_("S&ort")) );
  246.     menubar->Append( selection_menu, wxU(_("&Selection")) );
  247.     menubar->Append( group_menu, wxU(_("&Groups")) );
  249.     /* Attach the menu bar to the frame */
  250.     SetMenuBar( menubar );
  252.     /* Create the popup menu */
  253.     popup_menu = new wxMenu;
  254.     popup_menu->Append( PopupPlay_Event, wxU(_("Play")) );
  255.     popup_menu->Append( PopupDel_Event, wxU(_("Delete")) );
  256.     popup_menu->Append( PopupEna_Event, wxU(_("Enable/Disable")) );
  257.     popup_menu->Append( PopupInfo_Event, wxU(_("Info")) );
  259.     /* Create a panel to put everything in */
  260.     wxPanel *playlist_panel = new wxPanel( this, -1 );
  261.     playlist_panel->SetAutoLayout( TRUE );
  263.     /* Create the toolbar */
  264.     wxToolBar *toolbar =
  265.         CreateToolBar( wxTB_HORIZONTAL | wxTB_FLAT | wxTB_DOCKABLE );
  267.     /* Create the random tool */
  268.     toolbar->AddTool( Random_Event, wxT(""), wxBitmap(shuffle_on_xpm),
  269.                        wxBitmap(shuffle_on_xpm), wxITEM_CHECK,
  270.                        wxU(_(HELP_SHUFFLE) ) );
  271.     var_Get( p_intf, "random", &val );
  272.     toolbar->ToggleTool( Random_Event, val.b_bool );
  274.     /* Create the Loop tool */
  275.     toolbar->AddTool( Loop_Event, wxT(""), wxBitmap( loop_xpm),
  276.                       wxBitmap( loop_xpm), wxITEM_CHECK,
  277.                       wxU(_(HELP_LOOP )  ) );
  278.     var_Get( p_intf, "loop", &val );
  279.     toolbar->ToggleTool( Loop_Event, val.b_bool );
  281.     /* Create the Repeat one checkbox */
  282.     toolbar->AddTool( Repeat_Event, wxT(""), wxBitmap( repeat_xpm),
  283.                       wxBitmap( repeat_xpm), wxITEM_CHECK,
  284.                       wxU(_(HELP_REPEAT )  ) );
  285.     var_Get( p_intf, "repeat", &val );
  286.     toolbar->ToggleTool( Repeat_Event, val.b_bool ) ;
  288.     /* Create the Search Textbox */
  289.     search_text = new wxTextCtrl( toolbar, SearchText_Event, wxT(""),
  290.                                   wxDefaultPosition, wxSize(100, -1),
  291.                                   wxTE_PROCESS_ENTER);
  293.     /* Create the search button */
  294.     search_button = new wxButton( toolbar , Search_Event, wxU(_("Search")) );
  296.     toolbar->AddControl( new wxControl( toolbar, -1, wxDefaultPosition,
  297.                          wxSize(16, 16), wxBORDER_NONE ) );
  298.     toolbar->AddControl( search_text );
  299.     toolbar->AddControl( new wxControl( toolbar, -1, wxDefaultPosition,
  300.                          wxSize(5, 5), wxBORDER_NONE ) );
  301.     toolbar->AddControl( search_button );
  302.     search_button->SetDefault();
  303.     toolbar->Realize();
  305.     /* Create the listview */
  306.     /* FIXME: the given size is arbitrary, and prevents us from resizing
  307.      * the window to smaller dimensions. But the sizers don't seem to adjust
  308.      * themselves to the size of a listview, and with a wxDefaultSize the
  309.      * playlist window is ridiculously small */
  310.     listview = new wxListView( playlist_panel, ListView_Event,
  311.                                wxDefaultPosition, wxDefaultSize,
  312.                                wxLC_REPORT | wxSUNKEN_BORDER );
  314.     /* Reduce font size */
  315.     wxFont font= listview->GetFont();
  316.     font.SetPointSize(8);
  317.     listview->SetFont( font );
  319.     listview->InsertColumn( 0, wxU(_("Name")) );
  320.     listview->SetColumnWidth( 0, 250 );
  321.     listview->InsertColumn( 1, wxU(_("Duration")) );
  322.     listview->SetColumnWidth( 1, 75 );
  323.     listview->Layout();
  325.     /* Create the Up-Down buttons */
  326.     wxButton *up_button =
  327.         new wxButton( playlist_panel, Up_Event, wxU(_("Up") ) );
  328.     wxButton *down_button =
  329.         new wxButton( playlist_panel, Down_Event, wxU(_("Down") ) );
  331.     wxBoxSizer *updown_sizer = new wxBoxSizer( wxHORIZONTAL );
  332.     updown_sizer->Layout();
  334.     /* The top and bottom sizers */
  335.     wxBoxSizer *bottom_sizer = new wxBoxSizer( wxHORIZONTAL );
  336.     bottom_sizer->Add( up_button, 0, wxALIGN_LEFT | wxRIGHT, 3);
  337.     bottom_sizer->Add( down_button, 0, wxALIGN_LEFT | wxLEFT, 3);
  338.     bottom_sizer->Layout();
  340.     wxBoxSizer *panel_sizer = new wxBoxSizer( wxVERTICAL );
  341.     panel_sizer->Add( listview, 1, wxEXPAND | wxALL, 5 );
  342.     panel_sizer->Add( bottom_sizer, 0, wxALL, 5);
  343.     panel_sizer->Layout();
  345.     playlist_panel->SetSizerAndFit( panel_sizer );
  347. #if wxUSE_DRAG_AND_DROP
  348.     /* Associate drop targets with the playlist */
  349.     SetDropTarget( new DragAndDrop( p_intf, VLC_TRUE ) );
  350. #endif
  352.     playlist_t *p_playlist =
  353.         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  354.                                        FIND_ANYWHERE );
  355.     if( p_playlist == NULL )
  356.     {
  357.         return;
  358.     }
  360.     /* We want to be noticed of playlist changes */
  362.     /* Some global changes happened -> Rebuild all */
  363.     var_AddCallback( p_playlist, "intf-change", PlaylistChanged, this );
  365.     /* We went to the next item */
  366.     var_AddCallback( p_playlist, "playlist-current", PlaylistNext, this );
  368.     /* One item has been updated */
  369.     var_AddCallback( p_playlist, "item-change", ItemChanged, this );
  371.     vlc_object_release( p_playlist );
  373.     /* Update the playlist */
  374.     Rebuild();
  375. }
  377. void Playlist::OnSize( wxSizeEvent& event)
  378. {
  379.     wxSize size = GetClientSize();
  380.     if( listview )
  381.         listview->SetColumnWidth( 0, size.x - listview->GetColumnWidth(1)
  382.   - 15 /* margins */ );
  383.     event.Skip();
  384. }
  386. Playlist::~Playlist()
  387. {
  388.     playlist_t *p_playlist =
  389.         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  390.                                        FIND_ANYWHERE );
  391.     if( p_playlist == NULL )
  392.     {
  393.         return;
  394.     }
  396.     var_DelCallback( p_playlist, "item-change", ItemChanged, this );
  397.     var_DelCallback( p_playlist, "playlist-current", PlaylistNext, this );
  398.     var_DelCallback( p_playlist, "intf-change", PlaylistChanged, this );
  399.     vlc_object_release( p_playlist );
  400. }
  402. /**********************************************************************
  403.  * Update one playlist item
  404.  **********************************************************************/
  405. void Playlist::UpdateItem( int i )
  406. {
  407.     if( i < 0 ) return; /* Sanity check */
  409.     playlist_t *p_playlist =
  410.         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  411.                                        FIND_ANYWHERE );
  413.     if( p_playlist == NULL )
  414.     {
  415.         return;
  416.     }
  418.     playlist_item_t *p_item = playlist_ItemGetByPos( p_playlist, i );
  420.     if( !p_item )
  421.     {
  422.         vlc_object_release(p_playlist);
  423.         return;
  424.     }
  426.     char *psz_author = playlist_ItemGetInfo( p_item, _("General"), _("Author"));
  428.     if( !strcmp( psz_author, "" ) )
  429.     {
  430.         listview->SetItem( i, 0, wxL2U(p_item->input.psz_name) );
  431.     }
  432.     else
  433.     {
  434.         wxString msg;
  435.         msg.Printf( wxString(wxU( psz_author )) + wxT(" - ") +
  436.                     wxString(wxL2U(p_item->input.psz_name)) );
  437.         listview->SetItem( i, 0, msg );
  438.     }
  439. #if 0
  440.     listview->SetItem( i, 0, wxL2U(p_item->input.psz_name) );
  441.     listview->SetItem( i, 1, wxU( playlist_ItemGetInfo( p_item,
  442.                                        _("General"), _("Author") ) ) );
  443.     char *psz_group = playlist_FindGroup(p_playlist,
  444.                                          p_item->i_group);
  445.     listview->SetItem( i, 3,
  446.              wxL2U( psz_group ? psz_group : _("Normal") ) );
  447. #endif
  448.     if( p_item->b_enabled == VLC_FALSE )
  449.     {
  450.         wxListItem listitem;
  451.         listitem.m_itemId = i;
  452.         listitem.SetTextColour( *wxLIGHT_GREY);
  453.         listview->SetItem(listitem);
  454.     }
  456.     char psz_duration[MSTRTIME_MAX_SIZE];
  457.     mtime_t dur = p_item->input.i_duration;
  458.     if( dur != -1 )
  459.         secstotimestr( psz_duration, dur/1000000 );
  460.     else
  461.         memcpy( psz_duration, "-:--:--", sizeof("-:--:--") );
  462.     listview->SetItem( i, 1, wxU(psz_duration) );
  464.     /* Change the colour for the currenty played stream */
  465.     wxListItem listitem;
  466.     listitem.m_itemId = i;
  467.     if( i == p_playlist->i_index )
  468.     {
  469.         listitem.SetTextColour( *wxRED );
  470.     }
  471.     else
  472.     {
  473.         listitem.SetTextColour( *wxBLACK );
  474.     }
  475.     listview->SetItem( listitem );
  477.     vlc_object_release(p_playlist);
  478. }
  480. /**********************************************************************
  481.  * Rebuild the playlist
  482.  **********************************************************************/
  483. void Playlist::Rebuild()
  484. {
  485.     playlist_t *p_playlist =
  486.         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  487.                                        FIND_ANYWHERE );
  488.     if( p_playlist == NULL )
  489.     {
  490.         return;
  491.     }
  493.     int i_focused = listview->GetFocusedItem();
  495.     /* Clear the list... */
  496.     listview->DeleteAllItems();
  498.     /* ...and rebuild it */
  499.     vlc_mutex_lock( &p_playlist->object_lock );
  500.     for( int i = 0; i < p_playlist->i_size; i++ )
  501.     {
  502.         wxString filename = wxL2U(p_playlist->pp_items[i]->input.psz_name);
  503.         listview->InsertItem( i, filename );
  504.         /* FIXME: Very slow, need to find the playlist many times */
  505.         UpdateItem( i );
  506.     }
  507.     vlc_mutex_unlock( &p_playlist->object_lock );
  509.     if( i_focused >= 0 && i_focused < p_playlist->i_size )
  510.     {
  511.         listview->Focus( i_focused );
  512.         listview->Select( i_focused );
  513.     }
  514.     else if( p_playlist->i_index >= 0 )
  515.     {
  516.         listview->Focus( p_playlist->i_index );
  517.     }
  518.     vlc_object_release( p_playlist );
  519. }
  521. void Playlist::ShowPlaylist( bool show )
  522. {
  523.     if( show ) Rebuild();
  524.     Show( show );
  525. }
  527. void Playlist::UpdatePlaylist()
  528. {
  529.     i_update_counter++;
  531.     /* If the playlist isn't show there's no need to update it */
  532.     if( !IsShown() ) return;
  534.     if( this->b_need_update )
  535.     {
  536.         this->b_need_update = VLC_FALSE;
  537.         Rebuild();
  538.     }
  540.     /* Updating the playing status every 0.5s is enough */
  541.     if( i_update_counter % 5 ) return;
  543.     playlist_t *p_playlist =
  544.         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  545.                                        FIND_ANYWHERE );
  546.     if( p_playlist == NULL )
  547.     {
  548.         return;
  549.     }
  551.     /* Update the colour of items */
  552.     int i_playlist_index = p_playlist->i_index;
  553.     if( p_intf->p_sys->i_playing != i_playlist_index )
  554.     {
  555.         wxListItem listitem;
  556.         listitem.m_itemId = i_playlist_index;
  557.         listitem.SetTextColour( *wxRED );
  558.         listview->SetItem( listitem );
  560.         if( p_intf->p_sys->i_playing != -1 )
  561.         {
  562.             listitem.m_itemId = p_intf->p_sys->i_playing;
  563.             listitem.SetTextColour( *wxBLACK );
  564.             listview->SetItem( listitem );
  565.         }
  566.         p_intf->p_sys->i_playing = i_playlist_index;
  567.     }
  569.     vlc_object_release( p_playlist );
  570. }
  572. /*****************************************************************************
  573.  * Private methods.
  574.  *****************************************************************************/
  575. void Playlist::DeleteItem( int item )
  576. {
  577.     playlist_t *p_playlist =
  578.         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  579.                                        FIND_ANYWHERE );
  580.     if( p_playlist == NULL )
  581.     {
  582.         return;
  583.     }
  585.     playlist_Delete( p_playlist, item );
  586.     listview->DeleteItem( item );
  588.     vlc_object_release( p_playlist );
  589. }
  591. void Playlist::OnClose( wxCommandEvent& WXUNUSED(event) )
  592. {
  593.     Hide();
  594. }
  596. void Playlist::OnSave( wxCommandEvent& WXUNUSED(event) )
  597. {
  598.     struct {
  599.         char *psz_desc;
  600.         char *psz_filter;
  601.         char *psz_module;
  602.     } formats[] = {{ _("M3U file"), "*.m3u", "export-m3u" },
  603.                    { _("PLS file"), "*.pls", "export-pls" }};
  604.     wxString filter = wxT("");
  606.     playlist_t * p_playlist =
  607.                 (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  608.                                                FIND_ANYWHERE );
  610.     if( ! p_playlist )
  611.     {
  612.         return;
  613.     }
  614.     if( p_playlist->i_size == 0 )
  615.     {
  616.         wxMessageBox( wxU(_("Playlist is empty") ), wxU(_("Can't save")),
  617.                       wxICON_WARNING | wxOK, this );
  618.         vlc_object_release( p_playlist );
  619.         return;
  620.     }
  622.     for( unsigned int i = 0; i < sizeof(formats)/sizeof(formats[0]); i++)
  623.     {
  624.         filter.Append( wxU(formats[i].psz_desc) );
  625.         filter.Append( wxT("|") );
  626.         filter.Append( wxU(formats[i].psz_filter) );
  627.         filter.Append( wxT("|") );
  628.     }
  629.     wxFileDialog dialog( this, wxU(_("Save playlist")),
  630.                          wxT(""), wxT(""), filter, wxSAVE );
  632.     if( dialog.ShowModal() == wxID_OK )
  633.     {
  634.         if( dialog.GetPath().mb_str() )
  635.         {
  636.             playlist_Export( p_playlist, dialog.GetPath().mb_str(),
  637.                              formats[dialog.GetFilterIndex()].psz_module );
  638.         }
  639.     }
  641.     vlc_object_release( p_playlist );
  643. }
  645. void Playlist::OnOpen( wxCommandEvent& WXUNUSED(event) )
  646. {
  647.     playlist_t *p_playlist =
  648.         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  649.                                        FIND_ANYWHERE );
  650.     if( p_playlist == NULL )
  651.     {
  652.         return;
  653.     }
  655.     wxFileDialog dialog( this, wxU(_("Open playlist")), wxT(""), wxT(""),
  656.         wxT("All playlists|*.pls;*.m3u;*.asx;*.b4s|M3U files|*.m3u"), wxOPEN );
  658.     if( dialog.ShowModal() == wxID_OK )
  659.     {
  660.         playlist_Import( p_playlist, dialog.GetPath().mb_str() );
  661.     }
  663.     vlc_object_release( p_playlist );
  664. }
  666. void Playlist::OnAddFile( wxCommandEvent& WXUNUSED(event) )
  667. {
  668.     p_intf->p_sys->pf_show_dialog( p_intf, INTF_DIALOG_FILE_SIMPLE, 0, 0 );
  670. #if 0
  671.     Rebuild();
  672. #endif
  673. }
  675. void Playlist::OnAddMRL( wxCommandEvent& WXUNUSED(event) )
  676. {
  677.     p_intf->p_sys->pf_show_dialog( p_intf, INTF_DIALOG_FILE, 0, 0 );
  679. #if 0
  680.     Rebuild();
  681. #endif
  682. }
  684. /********************************************************************
  685.  * Move functions
  686.  ********************************************************************/
  687. void Playlist::OnUp( wxCommandEvent& event )
  688. {
  689.     playlist_t *p_playlist =
  690.         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  691.                                        FIND_ANYWHERE );
  692.     if( p_playlist == NULL )
  693.     {
  694.         return;
  695.     }
  697.     /* We use the first selected item, so find it */
  698.     long i_item = listview->GetNextItem( -1, wxLIST_NEXT_ALL,
  699.                                          wxLIST_STATE_SELECTED);
  700.     if( i_item > 0 && i_item < p_playlist->i_size )
  701.     {
  702.         playlist_Move( p_playlist, i_item, i_item - 1 );
  703.         listview->Focus( i_item - 1 );
  704.     }
  705.     vlc_object_release( p_playlist );
  706. }
  708. void Playlist::OnDown( wxCommandEvent& event )
  709. {
  710.     playlist_t *p_playlist =
  711.         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  712.                                        FIND_ANYWHERE );
  713.     if( p_playlist == NULL )
  714.     {
  715.         return;
  716.     }
  718.     /* We use the first selected item, so find it */
  719.     long i_item = listview->GetNextItem( -1, wxLIST_NEXT_ALL,
  720.                                          wxLIST_STATE_SELECTED );
  721.     if( i_item >= 0 && i_item < p_playlist->i_size - 1 )
  722.     {
  723.         playlist_Move( p_playlist, i_item, i_item + 2 );
  724.         listview->Focus( i_item + 1 );
  725.     }
  726.     vlc_object_release( p_playlist );
  727. }
  729. /********************************************************************
  730.  * Sorting functions
  731.  ********************************************************************/
  732. void Playlist::OnSort( wxCommandEvent& event )
  733. {
  734.     playlist_t *p_playlist =
  735.         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  736.                                        FIND_ANYWHERE );
  737.     if( p_playlist == NULL )
  738.     {
  739.         return;
  740.     }
  741.     switch( event.GetId() )
  742.     {
  743.         case SortTitle_Event:
  744.            playlist_SortTitle( p_playlist, ORDER_NORMAL );
  745.            break;
  746.         case RSortTitle_Event:
  747.            playlist_SortTitle( p_playlist, ORDER_REVERSE );
  748.            break;
  749.         case SortAuthor_Event:
  750.            playlist_SortAuthor(p_playlist, ORDER_NORMAL );
  751.            break;
  752.         case RSortAuthor_Event:
  753.            playlist_SortAuthor( p_playlist, ORDER_REVERSE );
  754.            break;
  755.         case SortGroup_Event:
  756.            playlist_SortGroup( p_playlist, ORDER_NORMAL );
  757.            break;
  758.         case RSortGroup_Event:
  759.            playlist_SortGroup( p_playlist, ORDER_REVERSE );
  760.            break;
  761.         case Randomize_Event:
  762.            playlist_Sort( p_playlist, SORT_RANDOM, ORDER_NORMAL );
  763.            break;
  764.     }
  765.     vlc_object_release( p_playlist );
  767.     Rebuild();
  768. }
  770. void Playlist::OnColSelect( wxListEvent& event )
  771. {
  772.     playlist_t *p_playlist =
  773.         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  774.                                        FIND_ANYWHERE );
  775.     if( p_playlist == NULL )
  776.     {
  777.         return;
  778.     }
  779.     switch( event.GetColumn() )
  780.     {
  781.         case 0:
  782.             if( i_title_sorted != 1 )
  783.             {
  784.                 playlist_SortTitle( p_playlist, ORDER_NORMAL );
  785.                 i_title_sorted = 1;
  786.             }
  787.             else
  788.             {
  789.                 playlist_SortTitle( p_playlist, ORDER_REVERSE );
  790.                 i_title_sorted = -1;
  791.             }
  792.             break;
  793.         case 1:
  794.             if( i_author_sorted != 1 )
  795.             {
  796.                 playlist_SortAuthor( p_playlist, ORDER_NORMAL );
  797.                 i_author_sorted = 1;
  798.             }
  799.             else
  800.             {
  801.                 playlist_SortAuthor( p_playlist, ORDER_REVERSE );
  802.                 i_author_sorted = -1;
  803.             }
  804.             break;
  805.         case 2:
  806.             if( i_duration_sorted != 1 )
  807.             {
  808.                 playlist_Sort( p_playlist, SORT_DURATION, ORDER_NORMAL );
  809.                 i_duration_sorted = 1;
  810.             }
  811.             else
  812.             {
  813.                 playlist_Sort( p_playlist, SORT_DURATION, ORDER_REVERSE );
  814.                 i_duration_sorted = -1;
  815.             }
  816.             break;
  817.         case 3:
  818.             if( i_group_sorted != 1 )
  819.             {
  820.                 playlist_SortGroup( p_playlist, ORDER_NORMAL );
  821.                 i_group_sorted = 1;
  822.             }
  823.             else
  824.             {
  825.                 playlist_SortGroup( p_playlist, ORDER_REVERSE );
  826.                 i_group_sorted = -1;
  827.             }
  828.             break;
  829.         default:
  830.             break;
  831.     }
  832.     vlc_object_release( p_playlist );
  834.     Rebuild();
  835. }
  837. /**********************************************************************
  838.  * Search functions
  839.  **********************************************************************/
  840. void Playlist::OnSearchTextChange( wxCommandEvent& WXUNUSED(event) )
  841. {
  842.    search_button->SetDefault();
  843. }
  845. void Playlist::OnSearch( wxCommandEvent& WXUNUSED(event) )
  846. {
  847.     wxString search_string = search_text->GetValue();
  849.     bool b_ok = false;
  850.     int i_current;
  851.     int i_first = 0 ;
  852.     int i_item = -1;
  854.     for( i_current = 0; i_current < listview->GetItemCount(); i_current++ )
  855.     {
  856.         if( listview->GetItemState( i_current, wxLIST_STATE_SELECTED ) ==
  857.               wxLIST_STATE_SELECTED )
  858.         {
  859.             i_first = i_current;
  860.             break;
  861.         }
  862.     }
  864.     if( i_first == listview->GetItemCount() )
  865.     {
  866.         i_first = -1;
  867.     }
  869.     for( i_current = i_first + 1; i_current < listview->GetItemCount();
  870.          i_current++ )
  871.     {
  872.         wxListItem listitem;
  873.         listitem.SetId( i_current );
  874.         listview->GetItem( listitem );
  875.         if( listitem.m_text.Lower().Contains( search_string.Lower() ) )
  876.         {
  877.             i_item = i_current;
  878.             b_ok = true;
  879.             break;
  880.         }
  881.         listitem.SetColumn( 1 );
  882.         listview->GetItem( listitem );
  883.         if( listitem.m_text.Lower().Contains( search_string.Lower() ) )
  884.         {
  885.             i_item = i_current;
  886.             b_ok = true;
  887.             break;
  888.         }
  889.     }
  890.     if( !b_ok )
  891.     {
  892.         for( i_current = -1 ; i_current < i_first - 1;
  893.              i_current++ )
  894.         {
  895.             wxListItem listitem;
  896.             listitem.SetId( i_current );
  897.             listview->GetItem( listitem );
  898.             if( listitem.m_text.Lower().Contains( search_string.Lower() ) )
  899.             {
  900.                 i_item = i_current;
  901.                 b_ok = true;
  902.                 break;
  903.             }
  904.             listitem.SetColumn( 1 );
  905.             listview->GetItem( listitem );
  906.             if( listitem.m_text.Lower().Contains( search_string.Lower() ) )
  907.             {
  908.                 i_item = i_current;
  909.                 b_ok = true;
  910.                 break;
  911.             }
  912.         }
  913.     }
  915.     if( i_item < 0 || i_item >= listview->GetItemCount() )
  916.     {
  917.         return;
  918.     }
  920.     for( long item = 0; item < listview->GetItemCount(); item++ )
  921.     {
  922.         listview->Select( item, FALSE );
  923.     }
  925.     wxListItem listitem;
  926.     listitem.SetId(i_item);
  927.     listitem.m_state = wxLIST_STATE_SELECTED;
  928.     listview->Select( i_item, TRUE );
  929.     listview->Focus( i_item );
  930. }
  932. /**********************************************************************
  933.  * Selection functions
  934.  **********************************************************************/
  935. void Playlist::OnInvertSelection( wxCommandEvent& WXUNUSED(event) )
  936. {
  937.     for( long item = 0; item < listview->GetItemCount(); item++ )
  938.     {
  939.         listview->Select( item, ! listview->IsSelected( item ) );
  940.     }
  941. }
  943. void Playlist::OnDeleteSelection( wxCommandEvent& WXUNUSED(event) )
  944. {
  945.     long *pd_del = NULL;
  946.     int i_del = 0;
  947.     int i;
  949.     /* Delete from the end to the beginning, to avoid a shift of indices */
  950.     for( long item = listview->GetItemCount() - 1; item >= 0; item-- )
  951.     {
  952.         /* TODO : use vector */
  953.         if( listview->IsSelected( item ) )
  954.         {
  955.             if( i_del> 0 )
  956.             {
  957.                 pd_del = (long *)realloc( pd_del, sizeof( void **) *
  958.                                                          (i_del + 1 ) );
  959.             }
  960.             else
  961.             {
  962.                 pd_del = (long *)malloc( sizeof( void ** ) );
  963.             }
  964.             pd_del[i_del] = item;
  965.             i_del ++;
  966.         }
  967.     }
  968.     for( long item = listview->GetItemCount() - 1; item >= 0; item-- )
  969.     {
  970.         for( i = 0 ; i < i_del; i++ )
  971.         {
  972.             if( item == pd_del[i] )
  973.             {
  974.                 DeleteItem( item );
  975.             }
  976.         }
  977.     }
  979.     Rebuild();
  980. }
  982. void Playlist::OnEnableSelection( wxCommandEvent& WXUNUSED(event) )
  983. {
  984.     playlist_t *p_playlist =
  985.         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  986.                                        FIND_ANYWHERE );
  987.     if( p_playlist == NULL )
  988.     {
  989.         return;
  990.     }
  992.     for( long item = listview->GetItemCount() - 1; item >= 0; item-- )
  993.     {
  994.         if( listview->IsSelected( item ) )
  995.         {
  996.             /*XXX*/
  997.             playlist_Enable( p_playlist, item );
  998.             UpdateItem( item );
  999.         }
  1000.     }
  1001.     vlc_object_release( p_playlist);
  1002. }
  1004. void Playlist::OnDisableSelection( wxCommandEvent& WXUNUSED(event) )
  1005. {
  1006.     playlist_t *p_playlist =
  1007.         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  1008.                                        FIND_ANYWHERE );
  1009.     if( p_playlist == NULL )
  1010.     {
  1011.         return;
  1012.     }
  1014.     for( long item = listview->GetItemCount() - 1; item >= 0; item-- )
  1015.     {
  1016.         if( listview->IsSelected( item ) )
  1017.         {
  1018.             /*XXX*/
  1019.             playlist_Disable( p_playlist, item );
  1020.             UpdateItem( item );
  1021.         }
  1022.     }
  1023.     vlc_object_release( p_playlist);
  1024. }
  1026. void Playlist::OnSelectAll( wxCommandEvent& WXUNUSED(event) )
  1027. {
  1028.     for( long item = 0; item < listview->GetItemCount(); item++ )
  1029.     {
  1030.         listview->Select( item, TRUE );
  1031.     }
  1032. }
  1034. /**********************************************************************
  1035.  * Playlist mode functions
  1036.  **********************************************************************/
  1037. void Playlist::OnRandom( wxCommandEvent& event )
  1038. {
  1039.     vlc_value_t val;
  1040.     val.b_bool = event.IsChecked();
  1041.     playlist_t *p_playlist =
  1042.         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  1043.                                        FIND_ANYWHERE );
  1044.     if( p_playlist == NULL )
  1045.     {
  1046.         return;
  1047.     }
  1048.     var_Set( p_playlist, "random", val);
  1049.     vlc_object_release( p_playlist );
  1050. }
  1052. void Playlist::OnLoop( wxCommandEvent& event )
  1053. {
  1054.     vlc_value_t val;
  1055.     val.b_bool = event.IsChecked();
  1056.     playlist_t *p_playlist =
  1057.         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  1058.                                        FIND_ANYWHERE );
  1059.     if( p_playlist == NULL )
  1060.     {
  1061.         return;
  1062.     }
  1063.     var_Set( p_playlist, "loop", val);
  1064.     vlc_object_release( p_playlist );
  1065. }
  1067. void Playlist::OnRepeat( wxCommandEvent& event )
  1068. {
  1069.     vlc_value_t val;
  1070.     val.b_bool = event.IsChecked();
  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.     var_Set( p_playlist, "repeat", val);
  1079.     vlc_object_release( p_playlist );
  1080. }
  1084. void Playlist::OnActivateItem( wxListEvent& event )
  1085. {
  1086.     playlist_t *p_playlist =
  1087.         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  1088.                                        FIND_ANYWHERE );
  1089.     if( p_playlist == NULL )
  1090.     {
  1091.         return;
  1092.     }
  1094.     playlist_Goto( p_playlist, event.GetIndex() );
  1096.     vlc_object_release( p_playlist );
  1097. }
  1099. void Playlist::OnKeyDown( wxListEvent& event )
  1100. {
  1101.     long keycode = event.GetKeyCode();
  1102.     /* Delete selected items */
  1103.     if( keycode == WXK_BACK || keycode == WXK_DELETE )
  1104.     {
  1105.         /* We send a dummy event */
  1106.         OnDeleteSelection( event );
  1107.     }
  1108. }
  1110. void Playlist::ShowInfos( int i_item )
  1111. {
  1112.     if( i_item == -1 )
  1113.     {
  1114.         return;
  1115.     }
  1117.     playlist_t *p_playlist =
  1118.         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  1119.                                        FIND_ANYWHERE );
  1120.     if( p_playlist == NULL )
  1121.     {
  1122.         return;
  1123.     }
  1125.     vlc_mutex_lock( &p_playlist->object_lock);
  1126.     playlist_item_t *p_item = playlist_ItemGetByPos( p_playlist, i_item );
  1127.     vlc_mutex_unlock( &p_playlist->object_lock );
  1129.     if( p_item )
  1130.     {
  1131.         iteminfo_dialog = new ItemInfoDialog( p_intf, p_item, this );
  1132.         if( iteminfo_dialog->ShowModal() == wxID_OK ) UpdateItem( i_item );
  1133.         delete iteminfo_dialog;
  1134.     }
  1136.     vlc_object_release( p_playlist );
  1137. }
  1139. void Playlist::OnInfos( wxCommandEvent& WXUNUSED(event) )
  1140. {
  1141.     /* We use the first selected item, so find it */
  1142.     long i_item = listview->GetNextItem( -1, wxLIST_NEXT_ALL,
  1143.                                          wxLIST_STATE_SELECTED );
  1144.     ShowInfos( i_item );
  1145. }
  1147. void Playlist::OnEnDis( wxCommandEvent& event )
  1148. {
  1149.     playlist_t *p_playlist =
  1150.         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  1151.                                        FIND_ANYWHERE );
  1152.     if( p_playlist == NULL )
  1153.     {
  1154.         return;
  1155.     }
  1157.     long i_item = listview->GetNextItem( -1, wxLIST_NEXT_ALL,
  1158.                                          wxLIST_STATE_SELECTED );
  1160.     if( i_item >= 0 && i_item < p_playlist->i_size )
  1161.     {
  1162.        switch( event.GetId() )
  1163.        {
  1164.            case EnableGroup_Event:
  1165.                /*XXX*/
  1166.                playlist_EnableGroup( p_playlist,
  1167.                                      p_playlist->pp_items[i_item]->i_group );
  1168.                break;
  1169.            case DisableGroup_Event:
  1170.                playlist_DisableGroup( p_playlist,
  1171.                                       p_playlist->pp_items[i_item]->i_group );
  1172.                break;
  1173.        }
  1174.        Rebuild();
  1175.     }
  1177.     vlc_object_release( p_playlist );
  1178. }
  1180. /*****************************************************************************
  1181.  * Popup management functions
  1182.  *****************************************************************************/
  1183. void Playlist::OnPopup( wxListEvent& event )
  1184. {
  1185.     i_popup_item = event.GetIndex();
  1186.     for( long item = 0; item < listview->GetItemCount(); item++ )
  1187.     {
  1188.         listview->Select( item, FALSE );
  1189.     }
  1190.     listview->Select( i_popup_item );
  1191.     Playlist::PopupMenu( popup_menu, ScreenToClient( wxGetMousePosition() ) );
  1192. }
  1194. void Playlist::OnPopupPlay( wxMenuEvent& event )
  1195. {
  1196.     playlist_t *p_playlist =
  1197.         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  1198.                                        FIND_ANYWHERE );
  1199.     if( p_playlist == NULL )
  1200.     {
  1201.         return;
  1202.     }
  1203.     if( i_popup_item != -1 )
  1204.     {
  1205.         playlist_Goto( p_playlist, i_popup_item );
  1206.     }
  1207.     vlc_object_release( p_playlist );
  1208. }
  1210. void Playlist::OnPopupDel( wxMenuEvent& event )
  1211. {
  1212.     DeleteItem( i_popup_item );
  1213. }
  1215. void Playlist::OnPopupEna( wxMenuEvent& event )
  1216. {
  1217.     playlist_t *p_playlist =
  1218.         (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  1219.                                        FIND_ANYWHERE );
  1220.     if( p_playlist == NULL )
  1221.     {
  1222.         return;
  1223.     }
  1225.     if( p_playlist->pp_items[i_popup_item]->b_enabled )
  1226.         //playlist_IsEnabled( p_playlist, i_popup_item ) )
  1227.     {
  1228.         playlist_Disable( p_playlist, i_popup_item );
  1229.     }
  1230.     else
  1231.     {
  1232.         playlist_Enable( p_playlist, i_popup_item );
  1233.     }
  1234.     vlc_object_release( p_playlist);
  1235.     UpdateItem( i_popup_item );
  1236. }
  1238. void Playlist::OnPopupInfo( wxMenuEvent& event )
  1239. {
  1240.     ShowInfos( i_popup_item );
  1241. }
  1243. /*****************************************************************************
  1244.  * Custom events management
  1245.  *****************************************************************************/
  1246. void Playlist::OnPlaylistEvent( wxCommandEvent& event )
  1247. {
  1248.     switch( event.GetId() )
  1249.     {
  1250.     case UpdateItem_Event:
  1251.         UpdateItem( event.GetInt() );
  1252.         break;
  1253.     }
  1254. }
  1256. /*****************************************************************************
  1257.  * PlaylistChanged: callback triggered by the intf-change playlist variable
  1258.  *  We don't rebuild the playlist directly here because we don't want the
  1259.  *  caller to block for a too long time.
  1260.  *****************************************************************************/
  1261. static int PlaylistChanged( vlc_object_t *p_this, const char *psz_variable,
  1262.                             vlc_value_t oval, vlc_value_t nval, void *param )
  1263. {
  1264.     Playlist *p_playlist_dialog = (Playlist *)param;
  1265.     p_playlist_dialog->b_need_update = VLC_TRUE;
  1266.     return VLC_SUCCESS;
  1267. }
  1269. /*****************************************************************************
  1270.  * Next: callback triggered by the playlist-current playlist variable
  1271.  *****************************************************************************/
  1272. static int PlaylistNext( vlc_object_t *p_this, const char *psz_variable,
  1273.                          vlc_value_t oval, vlc_value_t nval, void *param )
  1274. {
  1275.     Playlist *p_playlist_dialog = (Playlist *)param;
  1277.     wxCommandEvent event( wxEVT_PLAYLIST, UpdateItem_Event );
  1278.     event.SetInt( oval.i_int );
  1279.     p_playlist_dialog->AddPendingEvent( event );
  1280.     event.SetInt( nval.i_int );
  1281.     p_playlist_dialog->AddPendingEvent( event );
  1283.     return 0;
  1284. }
  1286. /*****************************************************************************
  1287.  * ItemChanged: callback triggered by the item-change playlist variable
  1288.  *****************************************************************************/
  1289. static int ItemChanged( vlc_object_t *p_this, const char *psz_variable,
  1290.                         vlc_value_t old_val, vlc_value_t new_val, void *param )
  1291. {
  1292.     Playlist *p_playlist_dialog = (Playlist *)param;
  1294.     wxCommandEvent event( wxEVT_PLAYLIST, UpdateItem_Event );
  1295.     event.SetInt( new_val.i_int );
  1296.     p_playlist_dialog->AddPendingEvent( event );
  1298.     return 0;
  1299. }
  1301. /***************************************************************************
  1302.  * NewGroup Class
  1303.  ***************************************************************************/
  1304. NewGroup::NewGroup( intf_thread_t *_p_intf, wxWindow *_p_parent ):
  1305.     wxDialog( _p_parent, -1, wxU(_("New Group")), wxDefaultPosition,
  1306.              wxDefaultSize, wxDEFAULT_FRAME_STYLE )
  1307. {
  1308.     /* Initializations */
  1309.     p_intf = _p_intf;
  1310.     psz_name = NULL;
  1311.     SetIcon( *p_intf->p_sys->p_icon );
  1313.     /* Create a panel to put everything in*/
  1314.     wxPanel *panel = new wxPanel( this, -1 );
  1315.     panel->SetAutoLayout( TRUE );
  1317.     wxStaticText *group_label =
  1318.             new wxStaticText( panel, -1,
  1319.                 wxU(_("Enter a name for the new group:")));
  1321.     groupname = new wxTextCtrl(panel, -1, wxU(""), wxDefaultPosition,
  1322.                                wxSize(100, 27), wxTE_PROCESS_ENTER);
  1324.     wxButton *ok_button = new wxButton(panel, wxID_OK, wxU(_("OK")) );
  1325.     ok_button->SetDefault();
  1326.     wxButton *cancel_button = new wxButton( panel, wxID_CANCEL,
  1327.                                             wxU(_("Cancel")) );
  1329.     wxBoxSizer *button_sizer = new wxBoxSizer( wxHORIZONTAL );
  1331.     button_sizer->Add( ok_button, 0, wxALL, 5 );
  1332.     button_sizer->Add( cancel_button, 0, wxALL, 5 );
  1333.     button_sizer->Layout();
  1335.     wxBoxSizer *panel_sizer = new wxBoxSizer( wxVERTICAL );
  1336.     panel_sizer->Add( group_label, 0, wxEXPAND | wxALL, 5 );
  1337.     panel_sizer->Add( groupname, 0, wxEXPAND | wxALL, 5 );
  1338.     panel_sizer->Add( button_sizer, 0, wxEXPAND | wxALL, 5 );
  1339.     panel_sizer->Layout();
  1341.     panel->SetSizerAndFit( panel_sizer );
  1343.     wxBoxSizer *main_sizer = new wxBoxSizer( wxVERTICAL );
  1344.     main_sizer->Add( panel, 1, wxEXPAND, 0 );
  1345.     main_sizer->Layout();
  1346.     SetSizerAndFit( main_sizer );
  1347. }
  1349. NewGroup::~NewGroup()
  1350. {
  1351. }
  1353. void NewGroup::OnOk( wxCommandEvent& event )
  1354. {
  1355.     psz_name = strdup( groupname->GetLineText(0).mb_str() );
  1357.     playlist_t * p_playlist =
  1358.           (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
  1359.                                        FIND_ANYWHERE );
  1361.     if( p_playlist )
  1362.     {
  1363.         if( !playlist_CreateGroup( p_playlist, psz_name ) )
  1364.         {
  1365.             psz_name = NULL;
  1366.         }
  1367.         vlc_object_release( p_playlist );
  1368.     }
  1370.     EndModal( wxID_OK );
  1371. }
  1373. void NewGroup::OnCancel( wxCommandEvent& WXUNUSED(event) )
  1374. {
  1375.     EndModal( wxID_CANCEL );
  1376. }