playlist.cpp

video linux conference

#endif

    if( event.GetEventObject() == p_view_menu )
    {
        p_view_menu = ViewMenu();
    }
#if defined( __WXMSW__ )
#   undef GetEventObject
#endif
}

void Playlist::OnMenuEvent( wxCommandEvent& event )
{
    if( event.GetId() < FirstView_Event )
    {
        event.Skip();
        return;
    }
    else if( event.GetId() < LastView_Event )
    {

        int i_new_view = event.GetId() - FirstView_Event;

        playlist_view_t *p_view = playlist_ViewFind( p_playlist, i_new_view );

        if( p_view != NULL )
        {
            b_changed_view = VLC_TRUE;
            i_current_view = i_new_view;
            playlist_ViewUpdate( p_playlist, i_new_view );
            Rebuild( VLC_TRUE );
            return;
        }
        else if( i_new_view >= VIEW_FIRST_SORTED &&
                 i_new_view <= VIEW_LAST_SORTED )
        {
            b_changed_view = VLC_TRUE;
            playlist_ViewInsert( p_playlist, i_new_view, "View" );
            playlist_ViewUpdate( p_playlist, i_new_view );

            i_current_view = i_new_view;

            Rebuild( VLC_TRUE );
        }
    }
    else if( event.GetId() >= FirstSD_Event && event.GetId() < LastSD_Event )
    {
        if( !playlist_IsServicesDiscoveryLoaded( p_playlist,
                                pp_sds[event.GetId() - FirstSD_Event] ) )
        {
            playlist_ServicesDiscoveryAdd( p_playlist,
                            pp_sds[event.GetId() - FirstSD_Event] );
        }
        else
        {
            //wxMutexGuiLeave();
            playlist_ServicesDiscoveryRemove( p_playlist,
                            pp_sds[event.GetId() - FirstSD_Event] );
            //wxMutexGuiEnter();
        }
    }
}

wxMenu * Playlist::ViewMenu()
{
    if( !p_view_menu )
    {
        p_view_menu = new wxMenu;
    }
    else
    {
        wxMenuItemList::Node *node = p_view_menu->GetMenuItems().GetFirst();
        for( ; node; )
        {
            wxMenuItem *item = node->GetData();
            node = node->GetNext();
            p_view_menu->Delete( item );
        }
    }

    /* FIXME : have a list of "should have" views */
    p_view_menu->Append( FirstView_Event + VIEW_CATEGORY,
                           wxU(_("Normal") ) );
    p_view_menu->Append( FirstView_Event + VIEW_S_AUTHOR,
                           wxU(_("Sorted by artist") ) );

    return p_view_menu;
}

wxMenu *Playlist::SDMenu()
{
    p_sd_menu = new wxMenu;

    vlc_list_t *p_list = vlc_list_find( p_playlist, VLC_OBJECT_MODULE,
                                        FIND_ANYWHERE );

    int i_number = 0;
    for( int i_index = 0; i_index < p_list->i_count; i_index++ )
    {
        module_t * p_parser = (module_t *)p_list->p_values[i_index].p_object ;

        if( !strcmp( p_parser->psz_capability, "services_discovery" ) )
            i_number++;
    }
    if( i_number ) pp_sds = (char **)calloc( i_number, sizeof(void *) );

    i_number = 0;
    for( int i_index = 0; i_index < p_list->i_count; i_index++ )
    {
        module_t * p_parser = (module_t *)p_list->p_values[i_index].p_object ;

        if( !strcmp( p_parser->psz_capability, "services_discovery" ) )
        {
            p_sd_menu->AppendCheckItem( FirstSD_Event + i_number ,
                wxU( p_parser->psz_longname ? p_parser->psz_longname :
                     (p_parser->psz_shortname ?
                      p_parser->psz_shortname : p_parser->psz_object_name) ) );

            if( playlist_IsServicesDiscoveryLoaded( p_playlist,
                                    p_parser->psz_object_name ) )
            {
                p_sd_menu->Check( FirstSD_Event + i_number, TRUE );
            }

            pp_sds[i_number++] = p_parser->psz_object_name;
        }
    }
    vlc_list_release( p_list );
    return p_sd_menu;
}


/*****************************************************************************
 * Popup management functions
 *****************************************************************************/
void Playlist::OnPopup( wxContextMenuEvent& event )
{
    wxPoint pt = event.GetPosition();
    playlist_item_t *p_item;

    i_wx_popup_item = treectrl->HitTest( ScreenToClient( pt ) );
    if( i_wx_popup_item.IsOk() )
    {
        PlaylistItem *p_wxitem = (PlaylistItem *)treectrl->GetItemData(
                                                            i_wx_popup_item );
        PlaylistItem *p_wxparent= (PlaylistItem *)treectrl->GetItemData(
                                  treectrl->GetItemParent( i_wx_popup_item ) );
        i_popup_item = p_wxitem->i_id;
        i_popup_parent = p_wxparent->i_id;
        treectrl->SelectItem( i_wx_popup_item );

        LockPlaylist( p_intf->p_sys, p_playlist );
        p_item = playlist_ItemGetById( p_playlist, i_popup_item );

        if( !p_item )
        {
            UnlockPlaylist( p_intf->p_sys, p_playlist );
            return;
        }
        if( p_item->i_children == -1 )
        {
            UnlockPlaylist( p_intf->p_sys, p_playlist );
            Playlist::PopupMenu( item_popup,
                                 ScreenToClient( wxGetMousePosition() ) );
        }
        else
        {
            UnlockPlaylist( p_intf->p_sys, p_playlist );
            Playlist::PopupMenu( node_popup,
                                 ScreenToClient( wxGetMousePosition() ) );
        }
    }
}

void Playlist::OnPopupPlay( wxCommandEvent& event )
{
    playlist_item_t *p_popup_item, *p_popup_parent;
    LockPlaylist( p_intf->p_sys, p_playlist );
    p_popup_item = playlist_ItemGetById( p_playlist, i_popup_item );
    p_popup_parent = playlist_ItemGetById( p_playlist, i_popup_parent );
    if( p_popup_item != NULL )
    {
        if( p_popup_item->i_children > -1 )
        {
            if( event.GetId() == PopupPlay_Event &&
                p_popup_item->i_children > 0 )
            {
                playlist_Control( p_playlist, PLAYLIST_VIEWPLAY,
                                  i_current_view, p_popup_item,
                                  p_popup_item->pp_children[0] );
            }
            else
            {
                playlist_Control( p_playlist, PLAYLIST_VIEWPLAY,
                                  i_current_view, p_popup_item, NULL );
            }
        }
        else
        {
            if( event.GetId() == PopupPlay_Event )
            {
                playlist_Control( p_playlist, PLAYLIST_VIEWPLAY,
                                  i_current_view, p_popup_parent,
                                  p_popup_item );
            }
        }
    }
    UnlockPlaylist( p_intf->p_sys, p_playlist );
}

void Playlist::OnPopupPreparse( wxCommandEvent& event )
{
    Preparse();
}

void Playlist::Preparse()
{
    playlist_item_t *p_popup_item;
    LockPlaylist( p_intf->p_sys, p_playlist );
    p_popup_item = playlist_ItemGetById( p_playlist, i_popup_item );

    if( p_popup_item != NULL )
    {
        if( p_popup_item->i_children == -1 )
        {
            playlist_PreparseEnqueue( p_playlist, &p_popup_item->input );
        }
        else
        {
            int i = 0;
            playlist_item_t *p_parent = p_popup_item;
            for( i = 0; i< p_parent->i_children ; i++ )
            {
                wxMenuEvent dummy;
                i_wx_popup_item = FindItem( treectrl->GetRootItem(),
                                         p_parent->pp_children[i]->input.i_id );
                i_popup_item = p_parent->pp_children[i]->input.i_id;
                Preparse();
            }
        }
    }
    UnlockPlaylist( p_intf->p_sys, p_playlist );
}

void Playlist::OnPopupDel( wxCommandEvent& event )
{
    DeleteTreeItem( i_wx_popup_item );
}

void Playlist::OnPopupSort( wxCommandEvent& event )
{
    PlaylistItem *p_wxitem;
    playlist_item_t *p_item;

    p_wxitem = (PlaylistItem *)treectrl->GetItemData( i_wx_popup_item );
    LockPlaylist( p_intf->p_sys, p_playlist );

    p_item = playlist_ItemGetById( p_playlist, p_wxitem->i_id );
    if( p_item->i_children >= 0 )
    {
        playlist_RecursiveNodeSort( p_playlist, p_item,
                                    SORT_TITLE_NODES_FIRST, ORDER_NORMAL );
        
        treectrl->DeleteChildren( i_wx_popup_item );
        i_saved_id = -1;
        UpdateNodeChildren( p_item, i_wx_popup_item );

    }
    UnlockPlaylist( p_intf->p_sys, p_playlist );
}

void Playlist::OnPopupInfo( wxCommandEvent& event )
{
    LockPlaylist( p_intf->p_sys, p_playlist );
    playlist_item_t *p_popup_item = playlist_ItemGetById( p_playlist, i_popup_item );
    if( p_popup_item )
    {
        iteminfo_dialog = new ItemInfoDialog( p_intf, p_popup_item, this );
        if( iteminfo_dialog->ShowModal() == wxID_OK )
        {
            UpdateItem( i_wx_popup_item );
        }
        delete iteminfo_dialog;
    }
    UnlockPlaylist( p_intf->p_sys, p_playlist );
}


/*****************************************************************************
 * Custom events management
 *****************************************************************************/
void Playlist::OnPlaylistEvent( wxCommandEvent& event )
{
    switch( event.GetId() )
    {
        case UpdateItem_Event:
            UpdateItem( event.GetInt() );
            break;
        case AppendItem_Event:
            AppendItem( event );
            break;
        case RemoveItem_Event:
            RemoveItem( event.GetInt() );
            break;
    }
}

/*****************************************************************************
 * PlaylistChanged: callback triggered by the intf-change playlist variable
 *  We don't rebuild the playlist directly here because we don't want the
 *  caller to block for a too long time.
 *****************************************************************************/
static int PlaylistChanged( vlc_object_t *p_this, const char *psz_variable,
                            vlc_value_t oval, vlc_value_t nval, void *param )
{
    Playlist *p_playlist_dialog = (Playlist *)param;
    p_playlist_dialog->b_need_update = VLC_TRUE;
    return VLC_SUCCESS;
}

/*****************************************************************************
 * Next: callback triggered by the playlist-current playlist variable
 *****************************************************************************/
static int PlaylistNext( vlc_object_t *p_this, const char *psz_variable,
                         vlc_value_t oval, vlc_value_t nval, void *param )
{
    Playlist *p_playlist_dialog = (Playlist *)param;

    wxCommandEvent event( wxEVT_PLAYLIST, UpdateItem_Event );
    event.SetInt( oval.i_int );
    p_playlist_dialog->AddPendingEvent( event );
    event.SetInt( nval.i_int );
    p_playlist_dialog->AddPendingEvent( event );

    return 0;
}

/*****************************************************************************
 * ItemChanged: callback triggered by the item-change playlist variable
 *****************************************************************************/
static int ItemChanged( vlc_object_t *p_this, const char *psz_variable,
                        vlc_value_t old_val, vlc_value_t new_val, void *param )
{
    Playlist *p_playlist_dialog = (Playlist *)param;

    wxCommandEvent event( wxEVT_PLAYLIST, UpdateItem_Event );
    event.SetInt( new_val.i_int );
    p_playlist_dialog->AddPendingEvent( event );

    return 0;
}
static int ItemDeleted( vlc_object_t *p_this, const char *psz_variable,
                        vlc_value_t old_val, vlc_value_t new_val, void *param )
{
    Playlist *p_playlist_dialog = (Playlist *)param;

    wxCommandEvent event( wxEVT_PLAYLIST, RemoveItem_Event );
    event.SetInt( new_val.i_int );
    p_playlist_dialog->AddPendingEvent( event );

    return 0;
}

static int ItemAppended( vlc_object_t *p_this, const char *psz_variable,
                         vlc_value_t oval, vlc_value_t nval, void *param )
{
    Playlist *p_playlist_dialog = (Playlist *)param;

    playlist_add_t *p_add = (playlist_add_t *)malloc(sizeof( playlist_add_t));

    memcpy( p_add, nval.p_address, sizeof( playlist_add_t ) );

    wxCommandEvent event( wxEVT_PLAYLIST, AppendItem_Event );
    event.SetClientData( (void *)p_add );
    p_playlist_dialog->AddPendingEvent( event );

    return VLC_SUCCESS;
}
}