set_category( CAT_INTERFACE );
set_subcategory( SUBCAT_INTERFACE_MAIN );
set_callbacks( Open, Close );
+ set_program( "nvlc" );
add_shortcut( "curses" );
add_directory( "browse-dir", NULL, NULL, BROWSE_TEXT, BROWSE_LONGTEXT, VLC_FALSE );
vlc_module_end();
};
struct intf_sys_t
{
- playlist_t *p_playlist;
input_thread_t *p_input;
float f_slider;
int b_box_plidx_follow;
int i_box_bidx; /* browser index */
+ playlist_item_t *p_node; /* current node */
+
int b_box_cleared;
msg_subscription_t* p_sub; /* message bank subscription */
/* Allocate instance and initialize some members */
p_sys = p_intf->p_sys = malloc( sizeof( intf_sys_t ) );
- p_sys->p_playlist = NULL;
+ p_sys->p_node = NULL;
p_sys->p_input = NULL;
p_sys->f_slider = 0.0;
p_sys->f_slider_old = 0.0;
{
intf_thread_t *p_intf = (intf_thread_t *)p_this;
intf_sys_t *p_sys = p_intf->p_sys;
+ playlist_t *p_playlist = pl_Get( p_intf );
int i;
- var_DelCallback( p_sys->p_playlist, "intf-change", PlaylistChanged,
- p_intf );
- var_DelCallback( p_sys->p_playlist, "item-append", PlaylistChanged,
- p_intf );
+ var_DelCallback( p_playlist, "intf-change", PlaylistChanged, p_intf );
+ var_DelCallback( p_playlist, "item-append", PlaylistChanged, p_intf );
PlaylistDestroy( p_intf );
{
vlc_object_release( p_sys->p_input );
}
- if( p_sys->p_playlist )
- {
- vlc_object_release( p_sys->p_playlist );
- }
+ pl_Release( p_intf );
/* Close the ncurses interface */
endwin();
static void Run( intf_thread_t *p_intf )
{
intf_sys_t *p_sys = p_intf->p_sys;
+ playlist_t *p_playlist = pl_Yield( p_intf );
int i_key;
time_t t_last_refresh;
msleep( INTF_IDLE_SLEEP );
/* Update the input */
- if( p_sys->p_playlist == NULL )
- {
- p_sys->p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
- FIND_ANYWHERE );
- if( p_sys->p_playlist )
- {
- var_AddCallback( p_sys->p_playlist, "intf-change",
- PlaylistChanged, p_intf );
- var_AddCallback( p_sys->p_playlist, "item-append",
- PlaylistChanged, p_intf );
- }
- }
- if( p_sys->p_playlist )
+ var_AddCallback( p_playlist, "intf-change", PlaylistChanged, p_intf );
+ var_AddCallback( p_playlist, "item-append", PlaylistChanged, p_intf );
+
+ PL_LOCK;
+ if( p_sys->p_input == NULL )
{
- vlc_mutex_lock( &p_sys->p_playlist->object_lock );
- if( p_sys->p_input == NULL )
+ p_sys->p_input = p_playlist->p_input;
+ if( p_sys->p_input )
{
- p_sys->p_input = p_sys->p_playlist->p_input;
- if( p_sys->p_input )
+ if( !p_sys->p_input->b_dead )
{
- if( !p_sys->p_input->b_dead )
- {
- vlc_object_yield( p_sys->p_input );
- }
+ vlc_object_yield( p_sys->p_input );
}
}
- else if( p_sys->p_input->b_dead )
- {
- vlc_object_release( p_sys->p_input );
- p_sys->p_input = NULL;
- p_sys->f_slider = p_sys->f_slider_old = 0.0;
- p_sys->b_box_cleared = VLC_FALSE;
- }
- vlc_mutex_unlock( &p_sys->p_playlist->object_lock );
}
+ else if( p_sys->p_input->b_dead )
+ {
+ vlc_object_release( p_sys->p_input );
+ p_sys->p_input = NULL;
+ p_sys->f_slider = p_sys->f_slider_old = 0.0;
+ p_sys->b_box_cleared = VLC_FALSE;
+ }
+ PL_UNLOCK;
- if( p_sys->b_box_plidx_follow && p_sys->p_playlist->status.p_item )
+ if( p_sys->b_box_plidx_follow && p_playlist->status.p_item )
{
FindIndex( p_intf );
}
{
intf_sys_t *p_sys = p_intf->p_sys;
vlc_value_t val;
+ playlist_t *p_playlist = pl_Get( p_intf );
- if( p_sys->i_box_type == BOX_PLAYLIST && p_sys->p_playlist )
+ if( p_sys->i_box_type == BOX_PLAYLIST )
{
int b_ret = VLC_TRUE;
vlc_bool_t b_box_plidx_follow = VLC_FALSE;
vlc_value_t val;
/* Playlist Settings */
case 'r':
- var_Get( p_sys->p_playlist, "random", &val );
+ var_Get( p_playlist, "random", &val );
val.b_bool = !val.b_bool;
- var_Set( p_sys->p_playlist, "random", val );
+ var_Set( p_playlist, "random", val );
return 1;
case 'l':
- var_Get( p_sys->p_playlist, "loop", &val );
+ var_Get( p_playlist, "loop", &val );
val.b_bool = !val.b_bool;
- var_Set( p_sys->p_playlist, "loop", val );
+ var_Set( p_playlist, "loop", val );
return 1;
case 'R':
- var_Get( p_sys->p_playlist, "repeat", &val );
+ var_Get( p_playlist, "repeat", &val );
val.b_bool = !val.b_bool;
- var_Set( p_sys->p_playlist, "repeat", val );
+ var_Set( p_playlist, "repeat", val );
return 1;
/* Playlist sort */
case 'o':
- playlist_RecursiveNodeSort( p_sys->p_playlist,
+ playlist_RecursiveNodeSort( p_playlist,
PlaylistGetRoot( p_intf ),
SORT_TITLE_NODES_FIRST, ORDER_NORMAL );
p_sys->b_need_update = VLC_TRUE;
return 1;
case 'O':
- playlist_RecursiveNodeSort( p_sys->p_playlist,
+ playlist_RecursiveNodeSort( p_playlist,
PlaylistGetRoot( p_intf ),
SORT_TITLE_NODES_FIRST, ORDER_REVERSE );
p_sys->b_need_update = VLC_TRUE;
return 1;
/* Playlist navigation */
+ case 'g':
+ FindIndex( p_intf );
+ break;
case KEY_HOME:
p_sys->i_box_plidx = 0;
break;
+#ifdef __FreeBSD__
+/* workaround for FreeBSD + xterm:
+ * see http://www.nabble.com/curses-vs.-xterm-key-mismatch-t3574377.html */
+ case KEY_SELECT:
+#endif
case KEY_END:
- p_sys->i_box_plidx = p_sys->p_playlist->items.i_size - 1;
+ p_sys->i_box_plidx = p_playlist->items.i_size - 1;
break;
case KEY_UP:
p_sys->i_box_plidx--;
case KEY_BACKSPACE:
case KEY_DC:
{
- playlist_t *p_playlist = p_sys->p_playlist;
playlist_item_t *p_item;
- vlc_mutex_lock( &p_playlist->object_lock );
+ PL_LOCK;
p_item = p_sys->pp_plist[p_sys->i_box_plidx]->p_item;
if( p_item->i_children == -1 )
{
playlist_NodeDelete( p_playlist, p_item,
VLC_TRUE , VLC_FALSE );
}
- vlc_mutex_unlock( &p_playlist->object_lock );
+ PL_UNLOCK;
PlaylistRebuild( p_intf );
break;
}
p_sys->pp_plist[p_sys->i_box_plidx]->p_item;
if( !p_parent )
- p_parent = p_sys->p_playlist->p_root_onelevel;
+ p_parent = p_playlist->p_root_onelevel;
while( p_parent->p_parent )
p_parent = p_parent->p_parent;
- playlist_Control( p_sys->p_playlist, PLAYLIST_VIEWPLAY,
+ playlist_Control( p_playlist, PLAYLIST_VIEWPLAY,
VLC_TRUE, p_parent, p_item );
}
+ else if( p_sys->pp_plist[p_sys->i_box_plidx]->p_item->i_children
+ == 0 )
+ { /* We only want to set the current node */
+ playlist_Stop( p_playlist );
+ p_sys->p_node = p_sys->pp_plist[p_sys->i_box_plidx]->p_item;
+ }
else
- { /* FIXME doesn't work if the node is empty */
- playlist_Control( p_sys->p_playlist, PLAYLIST_VIEWPLAY,
- VLC_TRUE,
- p_sys->pp_plist[p_sys->i_box_plidx]->p_item,
- NULL );
+ {
+ p_sys->p_node = p_sys->pp_plist[p_sys->i_box_plidx]->p_item;
+ playlist_Control( p_playlist, PLAYLIST_VIEWPLAY, VLC_TRUE,
+ p_sys->pp_plist[p_sys->i_box_plidx]->p_item, NULL );
}
b_box_plidx_follow = VLC_TRUE;
break;
case KEY_HOME:
p_sys->i_box_bidx = 0;
break;
+#ifdef __FreeBSD__
+ case KEY_SELECT:
+#endif
case KEY_END:
p_sys->i_box_bidx = p_sys->i_dir_entries - 1;
break;
sprintf( psz_uri, "%s/%s", p_sys->psz_current_dir, p_sys->pp_dir_entries[p_sys->i_box_bidx]->psz_path );
- playlist_item_t *p_parent = p_sys->p_playlist->status.p_node;
+ playlist_item_t *p_parent = p_sys->p_node;
if( !p_parent )
- p_parent = p_sys->p_playlist->p_root_onelevel;
+ p_parent = p_playlist->status.p_node;
+ if( !p_parent )
+ p_parent = p_playlist->p_local_onelevel;
- while( p_parent->p_parent )
+ while( p_parent->p_parent && p_parent->p_parent->p_parent )
p_parent = p_parent->p_parent;
- playlist_Add( p_sys->p_playlist, psz_uri, NULL,
- PLAYLIST_APPEND, PLAYLIST_END,
- p_parent == p_sys->p_playlist->p_root_onelevel
+ playlist_Add( p_playlist, psz_uri, NULL, PLAYLIST_APPEND,
+ PLAYLIST_END,
+ p_parent->p_input ==
+ p_playlist->p_local_onelevel->p_input
, VLC_FALSE );
+
p_sys->i_box_type = BOX_PLAYLIST;
free( psz_uri );
}
case KEY_HOME:
p_sys->i_box_start = 0;
return 1;
+#ifdef __FreeBSD__
+ case KEY_SELECT:
+#endif
case KEY_END:
p_sys->i_box_start = p_sys->i_box_lines_total - 1;
return 1;
p_sys->f_slider = 0;
ManageSlider( p_intf );
return 1;
+#ifdef __FreeBSD__
+ case KEY_SELECT:
+#endif
case KEY_END:
p_sys->f_slider = 99.9;
ManageSlider( p_intf );
else if( p_sys->i_box_type == BOX_OPEN && p_sys->psz_open_chain )
{
int i_chain_len = strlen( p_sys->psz_open_chain );
- playlist_t *p_playlist = p_sys->p_playlist;
switch( i_key )
{
return 1;
case KEY_ENTER:
case 0x0d:
- if( p_playlist && i_chain_len > 0 )
+ if( i_chain_len > 0 )
{
- playlist_item_t *p_parent = p_sys->p_playlist->status.p_node;
+ playlist_item_t *p_parent = p_sys->p_node;
+
if( !p_parent )
- p_parent = p_sys->p_playlist->p_root_onelevel;
+ p_parent = p_playlist->status.p_node;
+ if( !p_parent )
+ p_parent = p_playlist->p_local_onelevel;
- while( p_parent->p_parent )
+ while( p_parent->p_parent && p_parent->p_parent->p_parent )
p_parent = p_parent->p_parent;
playlist_Add( p_playlist, p_sys->psz_open_chain, NULL,
PLAYLIST_APPEND|PLAYLIST_GO, PLAYLIST_END,
- p_parent == p_sys->p_playlist->p_root_onelevel
+ p_parent->p_input ==
+ p_playlist->p_local_onelevel->p_input
, VLC_FALSE );
+
p_sys->b_box_plidx_follow = VLC_TRUE;
}
p_sys->i_box_type = BOX_PLAYLIST;
}
else
{
- playlist_t *p_playlist;
- p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
- FIND_ANYWHERE );
- if( p_playlist )
- {
- var_Get( p_playlist, "fullscreen", &val );
- val.b_bool = !val.b_bool;
- var_Set( p_playlist, "fullscreen", val );
- vlc_object_release( p_playlist );
- }
+ var_Get( p_playlist, "fullscreen", &val );
+ val.b_bool = !val.b_bool;
+ var_Set( p_playlist, "fullscreen", val );
}
}
return 0;
return 1;
case 's':
- if( p_intf->p_sys->p_playlist )
- {
- playlist_Stop( p_intf->p_sys->p_playlist );
- }
+ playlist_Stop( p_playlist );
return 1;
case 'e':
return 1;
case 'p':
- if( p_intf->p_sys->p_playlist )
- {
- playlist_Prev( p_intf->p_sys->p_playlist );
- }
+ playlist_Prev( p_playlist );
clear();
return 1;
case 'n':
- if( p_intf->p_sys->p_playlist )
- {
- playlist_Next( p_intf->p_sys->p_playlist );
- }
+ playlist_Next( p_playlist );
clear();
return 1;
{
i_width = wcswidth( psz_wide, i_char_len );
if( i_width == (size_t)-1 )
+ {
/* a non printable character was encountered */
- abort();
+ unsigned int i;
+ int i_cwidth;
+ i_width = 0;
+ for( i = 0 ; i < i_char_len ; i++ )
+ {
+ i_cwidth = wcwidth( psz_wide[i] );
+ if( i_cwidth != -1 )
+ i_width += i_cwidth;
+ }
+ }
}
if( i_width > (size_t)w )
{
{
intf_sys_t *p_sys = p_intf->p_sys;
input_thread_t *p_input = p_sys->p_input;
+ playlist_t *p_playlist = pl_Get( p_intf );
int y = 0;
int h;
int y_end;
char psz_state[25];
/* strlen( "[Repeat] [Random] [Loop]" ) == 24, + '\0' */
psz_state[0] = '\0';
- if( var_GetBool( p_sys->p_playlist, "repeat" ) )
+ if( var_GetBool( p_playlist, "repeat" ) )
strcat( psz_state, "[Repeat] " );
- if( var_GetBool( p_sys->p_playlist, "random" ) )
+ if( var_GetBool( p_playlist, "random" ) )
strcat( psz_state, "[Random] " );
- if( var_GetBool( p_sys->p_playlist, "loop" ) )
+ if( var_GetBool( p_playlist, "loop" ) )
strcat( psz_state, "[Loop]" );
if( p_input && !p_input->b_dead )
MainBoxWrite( p_intf, l++, 1, " R Toggle Repeat item" );
MainBoxWrite( p_intf, l++, 1, " o Order Playlist by title" );
MainBoxWrite( p_intf, l++, 1, " O Reverse order Playlist by title" );
+ MainBoxWrite( p_intf, l++, 1, " g Go to the current playing item" );
MainBoxWrite( p_intf, l++, 1, " / Look for an item" );
MainBoxWrite( p_intf, l++, 1, " A Add an entry" );
MainBoxWrite( p_intf, l++, 1, " D, <del> Delete an entry" );
}
}
- else if( ( p_sys->i_box_type == BOX_PLAYLIST ||
+ else if( p_sys->i_box_type == BOX_PLAYLIST ||
p_sys->i_box_type == BOX_SEARCH ||
- p_sys->i_box_type == BOX_OPEN ) && p_sys->p_playlist )
+ p_sys->i_box_type == BOX_OPEN )
{
/* Playlist box */
int i_start, i_stop, i_max = p_sys->i_plist_entries;
for( i_item = i_start; i_item < i_stop; i_item++ )
{
vlc_bool_t b_selected = ( p_sys->i_box_plidx == i_item );
- int c = ( PlaylistIsPlaying( p_intf,
- p_sys->pp_plist[i_item]->p_item ) ) ? '>' : ' ';
+ playlist_item_t *p_item = p_sys->pp_plist[i_item]->p_item;
+ playlist_item_t *p_node = p_sys->p_node;
+ int c = ' ';
+ if( ( p_node && p_item->p_input == p_node->p_input ) ||
+ ( !p_node && p_item->p_input ==
+ p_playlist->status.p_node->p_input ) )
+ c = '*';
+ else if( p_item == p_node || ( p_item != p_node &&
+ PlaylistIsPlaying( p_intf, p_item ) ) )
+ c = '>';
if( y >= y_end ) break;
if( b_selected )
static playlist_item_t *PlaylistGetRoot( intf_thread_t *p_intf )
{
intf_sys_t *p_sys = p_intf->p_sys;
- playlist_t *p_playlist = p_sys->p_playlist;
-
- if( p_playlist == NULL )
- {
- return NULL;
- }
+ playlist_t *p_playlist = pl_Get( p_intf );
switch( p_sys->i_current_view )
{
static void PlaylistRebuild( intf_thread_t *p_intf )
{
intf_sys_t *p_sys = p_intf->p_sys;
- playlist_t *p_playlist = p_sys->p_playlist;
-
- if( p_playlist == NULL )
- {
- return;
- }
+ playlist_t *p_playlist = pl_Get( p_intf );
- vlc_mutex_lock( &p_playlist->object_lock );
+ PL_LOCK;
/* First clear the old one */
PlaylistDestroy( p_intf );
p_sys->b_need_update = VLC_FALSE;
- vlc_mutex_unlock( &p_playlist->object_lock );
+ PL_UNLOCK;
}
static void PlaylistAddNode( intf_thread_t *p_intf, playlist_item_t *p_node,
{
intf_sys_t *p_sys = p_intf->p_sys;
playlist_item_t *p_child;
- char *psz_tmp;
int k;
- psz_tmp = (char *)malloc( strlen( c ) + 4 );
- if( psz_tmp == NULL ) return;
for( k = 0; k < p_node->i_children; k++ )
{
- struct pl_item_t *p_pl_item;
- char *buff;
- int i_size;
-
+ char *psz_display;
p_child = p_node->pp_children[k];
- i_size = strlen( c ) + strlen( p_child->p_input->psz_name ) + 4;
- buff = (char *)malloc( sizeof( char ) * i_size );
- p_pl_item = (struct pl_item_t *)malloc( sizeof( struct pl_item_t ) );
- if( p_pl_item == NULL || buff == NULL ) return;
+ char *psz_name = input_item_GetTitle( p_child->p_input );
+ if( !psz_name || !*psz_name )
+ {
+ free( psz_name );
+ psz_name = input_item_GetName( p_child->p_input );
+ }
- if( strlen( c ) )
+ if( c && *c )
{
- sprintf( buff, "%s%c-%s", c, k == p_node->i_children - 1 ?
- '`' : '|', p_child->p_input->psz_name );
+ if( asprintf( &psz_display, "%s%c-%s", c,
+ k == p_node->i_children - 1 ? '`' : '|', psz_name ) == -1 )
+ return;
}
else
{
- sprintf( buff, " %s", p_child->p_input->psz_name );
+ if( asprintf( &psz_display, " %s", psz_name ) == -1 )
+ return;
}
- p_pl_item->psz_display = strdup( buff );
+ free( psz_name );
+ struct pl_item_t *p_pl_item = malloc( sizeof( struct pl_item_t ) );
+ if( !p_pl_item )
+ return;
+ p_pl_item->psz_display = psz_display;
p_pl_item->p_item = p_child;
INSERT_ELEM( p_sys->pp_plist, p_sys->i_plist_entries,
p_sys->i_plist_entries, p_pl_item );
- free( buff );
i++;
if( p_child->i_children > 0 )
{
- sprintf( psz_tmp, "%s%c ", c,
- k == p_node->i_children - 1 ? ' ' : '|' );
+ char *psz_tmp;
+ if( asprintf( &psz_tmp, "%s%c ", c,
+ k == p_node->i_children - 1 ? ' ' : '|' ) == -1 )
+ return;
PlaylistAddNode( p_intf, p_child, i,
strlen( c ) ? psz_tmp : " " );
+ free( psz_tmp );
}
}
- free( psz_tmp );
}
static int PlaylistChanged( vlc_object_t *p_this, const char *psz_variable,
vlc_value_t oval, vlc_value_t nval, void *param )
{
intf_thread_t *p_intf = (intf_thread_t *)param;
+ playlist_t *p_playlist = pl_Get( p_intf );
p_intf->p_sys->b_need_update = VLC_TRUE;
+ p_intf->p_sys->p_node = p_playlist->status.p_node;
return VLC_SUCCESS;
}
static inline vlc_bool_t PlaylistIsPlaying( intf_thread_t *p_intf,
playlist_item_t *p_item )
{
- playlist_item_t *p_played_item = p_intf->p_sys->p_playlist->status.p_item;
+ playlist_t *p_playlist = pl_Get( p_intf );
+ playlist_item_t *p_played_item = p_playlist->status.p_item;
return( p_item != NULL && p_played_item != NULL &&
p_item->p_input != NULL && p_played_item->p_input != NULL &&
p_item->p_input->i_id == p_played_item->p_input->i_id );
intf_sys_t *p_sys = p_intf->p_sys;
int i;
- if( p_sys->i_box_plidx < p_sys->i_plist_entries &&
- p_sys->i_box_plidx >= 0 &&
- PlaylistIsPlaying( p_intf,
- p_sys->pp_plist[p_sys->i_box_plidx]->p_item ) )
+ if( p_sys->i_box_plidx < p_sys->i_plist_entries && p_sys->i_box_plidx >= 0 )
{
- return;
+ playlist_item_t *p_item = p_sys->pp_plist[p_sys->i_box_plidx]->p_item;
+ if( ( p_item->i_children == 0 && p_item == p_sys->p_node ) ||
+ PlaylistIsPlaying( p_intf, p_item ) )
+ return;
}
for( i = 0; i < p_sys->i_plist_entries; i++ )
{
- if( PlaylistIsPlaying( p_intf, p_sys->pp_plist[i]->p_item ) )
+ playlist_item_t *p_item = p_sys->pp_plist[i]->p_item;
+ if( ( p_item->i_children == 0 && p_item == p_sys->p_node ) ||
+ PlaylistIsPlaying( p_intf, p_sys->pp_plist[i]->p_item ) )
{
p_sys->i_box_plidx = i;
break;
* If it's neither of these, then return
*/
- playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
- FIND_ANYWHERE );
-
- if( p_playlist == NULL )
- {
- return;
- }
-
- vlc_mutex_lock( &p_playlist->object_lock );
+ playlist_t * p_playlist = pl_Get( p_intf );
+ PL_LOCK;
if( p_playlist->status.p_item == NULL )
{
- vlc_mutex_unlock( &p_playlist->object_lock );
- vlc_object_release( p_playlist );
+ PL_UNLOCK;
return;
}
}
}
- vlc_mutex_unlock( &p_playlist->object_lock );
- vlc_object_release( p_playlist );
+ PL_UNLOCK;
if( psz_device == NULL )
{
static void PlayPause( intf_thread_t *p_intf )
{
input_thread_t *p_input = p_intf->p_sys->p_input;
+ playlist_t *p_playlist = pl_Get( p_intf );
vlc_value_t val;
if( p_input )
}
var_Set( p_input, "state", val );
}
- else if( p_intf->p_sys->p_playlist )
- {
- playlist_Play( p_intf->p_sys->p_playlist );
- }
+ else
+ playlist_Play( p_playlist );
}
/****************************************************************************