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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
ncurses.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：85k
源码类别：

midi

开发平台：

Unix_Linux

ncurses.c：源码内容
  1. /*****************************************************************************
  2.  * ncurses.c : NCurses interface for vlc
  3.  *****************************************************************************
  4.  * Copyright © 2001-2007 the VideoLAN team
  5.  * $Id: 2e815993932f817dc805a0316d87c210b7ba66ea $
  6.  *
  7.  * Authors: Sam Hocevar <sam@zoy.org>
  8.  *          Laurent Aimar <fenrir@via.ecp.fr>
  9.  *          Yoann Peronneau <yoann@videolan.org>
  10.  *          Derk-Jan Hartman <hartman at videolan dot org>
  11.  *          Rafaël Carré <funman@videolanorg>
  12.  *
  13.  * This program is free software; you can redistribute it and/or modify
  14.  * it under the terms of the GNU General Public License as published by
  15.  * the Free Software Foundation; either version 2 of the License, or
  16.  * (at your option) any later version.
  17.  *
  18.  * This program is distributed in the hope that it will be useful,
  19.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21.  * GNU General Public License for more details.
  22.  *
  23.  * You should have received a copy of the GNU General Public License
  24.  * along with this program; if not, write to the Free Software
  25.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  26.  *****************************************************************************/
  28. /*
  29.  * Note that when we use wide characters (and link with libncursesw),
  30.  * we assume that an UTF8 locale is used (or compatible, such as ASCII).
  31.  * Other characters encodings are not supported.
  32.  */
  34. /*****************************************************************************
  35.  * Preamble
  36.  *****************************************************************************/
  37. #ifdef HAVE_CONFIG_H
  38. # include "config.h"
  39. #endif
  41. #include <vlc_common.h>
  42. #include <vlc_plugin.h>
  44. #ifdef HAVE_NCURSESW
  45. #   define _XOPEN_SOURCE_EXTENDED 1
  46. #   include <wchar.h>
  47. #endif
  49. #include <ncurses.h>
  51. #include <vlc_interface.h>
  52. #include <vlc_vout.h>
  53. #include <vlc_aout.h>
  54. #include <vlc_charset.h>
  55. #include <vlc_input.h>
  56. #include <vlc_es.h>
  57. #include <vlc_playlist.h>
  58. #include <vlc_meta.h>
  60. #include <assert.h>
  62. #ifdef HAVE_SYS_STAT_H
  63. #   include <sys/stat.h>
  64. #endif
  65. #if (!defined( WIN32 ) || defined(__MINGW32__))
  66. /* Mingw has its own version of dirent */
  67. #   include <dirent.h>
  68. #endif
  70. #ifdef HAVE_CDDAX
  71. #define CDDA_MRL "cddax://"
  72. #else
  73. #define CDDA_MRL "cdda://"
  74. #endif
  76. #ifdef HAVE_VCDX
  77. #define VCD_MRL "vcdx://"
  78. #else
  79. #define VCD_MRL "vcd://"
  80. #endif
  82. #define SEARCH_CHAIN_SIZE 20
  83. #define OPEN_CHAIN_SIZE 50
  85. /*****************************************************************************
  86.  * Local prototypes.
  87.  *****************************************************************************/
  88. static int  Open           ( vlc_object_t * );
  89. static void Close          ( vlc_object_t * );
  91. static void Run            ( intf_thread_t * );
  92. static void PlayPause      ( intf_thread_t * );
  93. static void Eject          ( intf_thread_t * );
  95. static int  HandleKey      ( intf_thread_t *, int );
  96. static void Redraw         ( intf_thread_t *, time_t * );
  98. static playlist_item_t *PlaylistGetRoot( intf_thread_t * );
  99. static void PlaylistRebuild( intf_thread_t * );
  100. static void PlaylistAddNode( intf_thread_t *, playlist_item_t *, int, const char *);
  101. static void PlaylistDestroy( intf_thread_t * );
  102. static int  PlaylistChanged( vlc_object_t *, const char *, vlc_value_t,
  103.                              vlc_value_t, void * );
  104. static inline bool PlaylistIsPlaying( playlist_t *, playlist_item_t * );
  105. static void FindIndex      ( intf_thread_t *, playlist_t * );
  106. static void SearchPlaylist ( intf_thread_t *, char * );
  107. static int  SubSearchPlaylist( intf_thread_t *, char *, int, int );
  109. static void ManageSlider   ( intf_thread_t * );
  110. static void ReadDir        ( intf_thread_t * );
  112. static void start_color_and_pairs ( intf_thread_t * );
  114. /*****************************************************************************
  115.  * Module descriptor
  116.  *****************************************************************************/
  118. #define BROWSE_TEXT N_("Filebrowser starting point")
  119. #define BROWSE_LONGTEXT N_( 
  120.     "This option allows you to specify the directory the ncurses filebrowser " 
  121.     "will show you initially.")
  123. vlc_module_begin ()
  124.     set_shortname( "Ncurses" )
  125.     set_description( N_("Ncurses interface") )
  126.     set_capability( "interface", 10 )
  127.     set_category( CAT_INTERFACE )
  128.     set_subcategory( SUBCAT_INTERFACE_MAIN )
  129.     set_callbacks( Open, Close )
  130.     add_shortcut( "curses" )
  131.     add_directory( "browse-dir", NULL, NULL, BROWSE_TEXT, BROWSE_LONGTEXT, false )
  132. vlc_module_end ()
  134. /*****************************************************************************
  135.  * intf_sys_t: description and status of ncurses interface
  136.  *****************************************************************************/
  137. enum
  138. {
  139.     BOX_NONE,
  140.     BOX_HELP,
  141.     BOX_INFO,
  142.     BOX_LOG,
  143.     BOX_PLAYLIST,
  144.     BOX_SEARCH,
  145.     BOX_OPEN,
  146.     BOX_BROWSE,
  147.     BOX_META,
  148.     BOX_OBJECTS,
  149.     BOX_STATS
  150. };
  151. enum
  152. {
  153.     C_DEFAULT = 0,
  154.     C_TITLE,
  155.     C_PLAYLIST_1,
  156.     C_PLAYLIST_2,
  157.     C_PLAYLIST_3,
  158.     C_BOX,
  159.     C_STATUS,
  160.     C_INFO,
  161.     C_ERROR,
  162.     C_WARNING,
  163.     C_DEBUG,
  164.     C_CATEGORY,
  165.     C_FOLDER
  166. };
  167. enum
  168. {
  169.     VIEW_CATEGORY,
  170.     VIEW_ONELEVEL
  171. };
  172. struct dir_entry_t
  173. {
  174.     bool  b_file;
  175.     char        *psz_path;
  176. };
  177. struct pl_item_t
  178. {
  179.     playlist_item_t *p_item;
  180.     char            *psz_display;
  181. };
  182. struct intf_sys_t
  183. {
  184.     input_thread_t *p_input;
  185.     playlist_t     *p_playlist;
  187.     bool      b_color;
  188.     bool      b_color_started;
  190.     float           f_slider;
  191.     float           f_slider_old;
  193.     WINDOW          *w;
  195.     int             i_box_type;
  196.     int             i_box_y;
  197.     int             i_box_lines;
  198.     int             i_box_lines_total;
  199.     int             i_box_start;
  201.     int             i_box_plidx;    /* Playlist index */
  202.     int             b_box_plidx_follow;
  203.     int             i_box_bidx;     /* browser index */
  205.     playlist_item_t *p_node;        /* current node */
  207.     int             b_box_cleared;
  209.     msg_subscription_t* p_sub;                  /* message bank subscription */
  211.     char            *psz_search_chain;          /* for playlist searching    */
  212.     char            *psz_old_search;            /* for searching next        */
  213.     int             i_before_search;
  215.     char            *psz_open_chain;
  216. #ifndef HAVE_NCURSESW
  217.     char             psz_partial_keys[7];
  218. #endif
  220.     char            *psz_current_dir;
  221.     int             i_dir_entries;
  222.     struct dir_entry_t  **pp_dir_entries;
  223.     bool      b_show_hidden_files;
  225.     int             i_current_view;             /* playlist view             */
  226.     struct pl_item_t    **pp_plist;
  227.     int             i_plist_entries;
  228.     bool      b_need_update;              /* for playlist view         */
  229. };
  231. static void DrawBox( WINDOW *win, int y, int x, int h, int w, const char *title, bool b_color );
  232. static void DrawLine( WINDOW *win, int y, int x, int w );
  233. static void DrawEmptyLine( WINDOW *win, int y, int x, int w );
  235. /*****************************************************************************
  236.  * Open: initialize and create window
  237.  *****************************************************************************/
  238. static int Open( vlc_object_t *p_this )
  239. {
  240.     intf_thread_t *p_intf = (intf_thread_t *)p_this;
  241.     intf_sys_t    *p_sys;
  243.     /* Allocate instance and initialize some members */
  244.     p_sys = p_intf->p_sys = malloc( sizeof( intf_sys_t ) );
  245.     if( !p_sys )
  246.         return VLC_ENOMEM;
  247.     p_sys->p_node = NULL;
  248.     p_sys->p_input = NULL;
  249.     p_sys->f_slider = 0.0;
  250.     p_sys->f_slider_old = 0.0;
  251.     p_sys->i_box_type = BOX_PLAYLIST;
  252.     p_sys->i_box_lines = 0;
  253.     p_sys->i_box_start= 0;
  254.     p_sys->i_box_lines_total = 0;
  255.     p_sys->b_box_plidx_follow = true;
  256.     p_sys->b_box_cleared = false;
  257.     p_sys->i_box_plidx = 0;
  258.     p_sys->i_box_bidx = 0;
  259. // FIXME    p_sys->p_sub = msg_Subscribe( p_intf );
  260.     p_sys->b_color = var_CreateGetBool( p_intf, "color" );
  261.     p_sys->b_color_started = false;
  263. #ifndef HAVE_NCURSESW
  264.     memset( p_sys->psz_partial_keys, 0, sizeof( p_sys->psz_partial_keys ) );
  265. #endif
  267.     /* Initialize the curses library */
  268.     p_sys->w = initscr();
  270.     if( p_sys->b_color )
  271.         start_color_and_pairs( p_intf );
  273.     keypad( p_sys->w, TRUE );
  274.     /* Don't do NL -> CR/NL */
  275.     nonl();
  276.     /* Take input chars one at a time */
  277.     cbreak();
  278.     /* Don't echo */
  279.     noecho();
  280.     /* Invisible cursor */
  281.     curs_set( 0 );
  282.     /* Non blocking wgetch() */
  283.     wtimeout( p_sys->w, 0 );
  285.     clear();
  287.     /* exported function */
  288.     p_intf->pf_run = Run;
  290.     /* Stop printing errors to the console */
  291.     freopen( "/dev/null", "wb", stderr );
  293.     /* Set defaul playlist view */
  294.     p_sys->i_current_view = VIEW_CATEGORY;
  295.     p_sys->pp_plist = NULL;
  296.     p_sys->i_plist_entries = 0;
  297.     p_sys->b_need_update = false;
  299.     /* Initialize search chain */
  300.     p_sys->psz_search_chain = malloc( SEARCH_CHAIN_SIZE + 1 );
  301.     p_sys->psz_old_search = NULL;
  302.     p_sys->i_before_search = 0;
  304.     /* Initialize open chain */
  305.     p_sys->psz_open_chain = malloc( OPEN_CHAIN_SIZE + 1 );
  307.     /* Initialize browser options */
  308.     char* psz_tmp = var_CreateGetString( p_intf, "browse-dir" );
  309.     if( psz_tmp && *psz_tmp )
  310.         p_sys->psz_current_dir = psz_tmp;
  311.     else
  312.     {
  313.         p_sys->psz_current_dir = strdup( config_GetHomeDir() );
  314.         free( psz_tmp );
  315.     }
  317.     p_sys->i_dir_entries = 0;
  318.     p_sys->pp_dir_entries = NULL;
  319.     p_sys->b_show_hidden_files = false;
  320.     ReadDir( p_intf );
  322.     return VLC_SUCCESS;
  323. }
  325. /*****************************************************************************
  326.  * Close: destroy interface window
  327.  *****************************************************************************/
  328. static void Close( vlc_object_t *p_this )
  329. {
  330.     intf_thread_t *p_intf = (intf_thread_t *)p_this;
  331.     intf_sys_t    *p_sys = p_intf->p_sys;
  333.     PlaylistDestroy( p_intf );
  335.     while( p_sys->i_dir_entries )
  336.     {
  337.         struct dir_entry_t *p_dir_entry = p_sys->pp_dir_entries[0];
  338.         free( p_dir_entry->psz_path );
  339.         REMOVE_ELEM( p_sys->pp_dir_entries, p_sys->i_dir_entries, 0 );
  340.         free( p_dir_entry );
  341.     }
  342.     p_sys->pp_dir_entries = NULL;
  344.     free( p_sys->psz_current_dir );
  345.     free( p_sys->psz_search_chain );
  346.     free( p_sys->psz_old_search );
  347.     free( p_sys->psz_open_chain );
  349.     if( p_sys->p_input )
  350.     {
  351.         vlc_object_release( p_sys->p_input );
  352.     }
  353.     pl_Release( p_intf );
  355.     /* Close the ncurses interface */
  356.     endwin();
  358. // FIXME    msg_Unsubscribe( p_intf, p_sys->p_sub );
  360.     /* Destroy structure */
  361.     free( p_sys );
  362. }
  364. /*****************************************************************************
  365.  * Run: ncurses thread
  366.  *****************************************************************************/
  367. static void Run( intf_thread_t *p_intf )
  368. {
  369.     intf_sys_t    *p_sys = p_intf->p_sys;
  370.     playlist_t    *p_playlist = pl_Hold( p_intf );
  371.     p_sys->p_playlist = p_playlist;
  373.     int i_key;
  374.     time_t t_last_refresh;
  375.     int canc = vlc_savecancel();
  377.     /*
  378.      * force drawing the interface for the first time
  379.      */
  380.     t_last_refresh = ( time( 0 ) - 1);
  381.     /*
  382.      * force building of the playlist array
  383.      */
  384.     PlaylistRebuild( p_intf );
  385.     var_AddCallback( p_playlist, "intf-change", PlaylistChanged, p_intf );
  386.     var_AddCallback( p_playlist, "playlist-item-append", PlaylistChanged, p_intf );
  388.     while( vlc_object_alive( p_intf ) )
  389.     {
  390.         msleep( INTF_IDLE_SLEEP );
  392.         /* Update the input */
  393.         if( p_sys->p_input == NULL )
  394.         {
  395.             p_sys->p_input = playlist_CurrentInput( p_playlist );
  396.         }
  397.         else if( p_sys->p_input->b_dead )
  398.         {
  399.             vlc_object_release( p_sys->p_input );
  400.             p_sys->p_input = NULL;
  401.             p_sys->f_slider = p_sys->f_slider_old = 0.0;
  402.             p_sys->b_box_cleared = false;
  403.         }
  405.         PL_LOCK;
  406.         if( p_sys->b_box_plidx_follow && playlist_CurrentPlayingItem(p_playlist) )
  407.         {
  408.             PL_UNLOCK;
  409.             FindIndex( p_intf, p_playlist );
  410.         }
  411.         else
  412.             PL_UNLOCK;
  414.         while( ( i_key = wgetch( p_sys->w ) ) != -1 )
  415.         {
  416.             /*
  417.              * HandleKey returns 1 if the screen needs to be redrawn
  418.              */
  419.             if( HandleKey( p_intf, i_key ) )
  420.             {
  421.                 Redraw( p_intf, &t_last_refresh );
  422.             }
  423.         }
  424.         /* Hack */
  425.         if( p_sys->f_slider > 0.0001 && !p_sys->b_box_cleared )
  426.         {
  427.             clear();
  428.             Redraw( p_intf, &t_last_refresh );
  429.             p_sys->b_box_cleared = true;
  430.         }
  432.         /*
  433.          * redraw the screen every second
  434.          */
  435.         if( (time(0) - t_last_refresh) >= 1 )
  436.         {
  437.             ManageSlider( p_intf );
  438.             Redraw( p_intf, &t_last_refresh );
  439.         }
  440.     }
  441.     var_DelCallback( p_playlist, "intf-change", PlaylistChanged, p_intf );
  442.     var_DelCallback( p_playlist, "playlist-item-append", PlaylistChanged, p_intf );
  443.     vlc_restorecancel( canc );
  444. }
  446. /* following functions are local */
  447. static void start_color_and_pairs( intf_thread_t *p_intf )
  448. {
  449.     assert( p_intf->p_sys->b_color && !p_intf->p_sys->b_color_started );
  451.     if( !has_colors() )
  452.     {
  453.         p_intf->p_sys->b_color = false;
  454.         msg_Warn( p_intf, "Terminal doesn't support colors" );
  455.         return;
  456.     }
  458.     start_color();
  460.     /* Available colors: BLACK RED GREEN YELLOW BLUE MAGENTA CYAN WHITE */
  462.     /* untested, in all my terminals, !can_change_color() --funman */
  463.     if( can_change_color() )
  464.         init_color( COLOR_YELLOW, 960, 500, 0 ); /* YELLOW -> ORANGE */
  466.     /* title */
  467.     init_pair( C_TITLE, COLOR_YELLOW, COLOR_BLACK );
  469.     /* jamaican playlist */
  470.     init_pair( C_PLAYLIST_1, COLOR_GREEN, COLOR_BLACK );
  471.     init_pair( C_PLAYLIST_2, COLOR_YELLOW, COLOR_BLACK );
  472.     init_pair( C_PLAYLIST_3, COLOR_RED, COLOR_BLACK );
  474.     /* used in DrawBox() */
  475.     init_pair( C_BOX, COLOR_CYAN, COLOR_BLACK );
  476.     /* Source, State, Position, Volume, Chapters, etc...*/
  477.     init_pair( C_STATUS, COLOR_BLUE, COLOR_BLACK );
  479.     /* VLC messages, keep the order from highest priority to lowest */
  481.     /* infos */
  482.     init_pair( C_INFO, COLOR_BLACK, COLOR_WHITE );
  483.     /* errors */
  484.     init_pair( C_ERROR, COLOR_RED, COLOR_BLACK );
  485.     /* warnings */
  486.     init_pair( C_WARNING, COLOR_YELLOW, COLOR_BLACK );
  487. /* debug */
  488.     init_pair( C_DEBUG, COLOR_WHITE, COLOR_BLACK );
  490.     /* Category title (help, info, metadata) */
  491.     init_pair( C_CATEGORY, COLOR_MAGENTA, COLOR_BLACK );
  493.     /* Folder (BOX_BROWSE) */
  494.     init_pair( C_FOLDER, COLOR_RED, COLOR_BLACK );
  496.     p_intf->p_sys->b_color_started = true;
  497. }
  499. #ifndef HAVE_NCURSESW
  500. static char *KeyToUTF8( int i_key, char *psz_part )
  501. {
  502.     char *psz_utf8;
  503.     int len = strlen( psz_part );
  504.     if( len == 6 )
  505.     {
  506.         /* overflow error - should not happen */
  507.         memset( psz_part, 0, 6 );
  508.         return NULL;
  509.     }
  511.     psz_part[len] = (char)i_key;
  513.     psz_utf8 = FromLocaleDup( psz_part );
  515.     /* Ugly check for incomplete bytes sequences
  516.      * (in case of non-UTF8 multibyte local encoding) */
  517.     char *psz;
  518.     for( psz = psz_utf8; *psz; psz++ )
  519.         if( ( *psz == '?' ) && ( *psz_utf8 != '?' ) )
  520.         {
  521.             /* incomplete bytes sequence detected
  522.              * (VLC core inserted dummy question marks) */
  523.             free( psz_utf8 );
  524.             return NULL;
  525.         }
  527.     /* Check for incomplete UTF8 bytes sequence */
  528.     if( EnsureUTF8( psz_utf8 ) == NULL )
  529.     {
  530.         free( psz_utf8 );
  531.         return NULL;
  532.     }
  534.     memset( psz_part, 0, 6 );
  535.     return psz_utf8;
  536. }
  537. #endif
  539. static inline int RemoveLastUTF8Entity( char *psz, int len )
  540. {
  541.     while( len && ( (psz[--len] & 0xc0) == 0x80 ) );
  542.                        /* UTF8 continuation byte */
  544.     psz[len] = '';
  545.     return len;
  546. }
  548. static int HandleKey( intf_thread_t *p_intf, int i_key )
  549. {
  550.     intf_sys_t *p_sys = p_intf->p_sys;
  551.     vlc_value_t val;
  553.     #define ReturnTrue 
  554.     do { 
  555.     pl_Release( p_intf ); 
  556.     return 1; 
  557.     } while(0)
  559.     #define ReturnFalse 
  560.     do { 
  561.     pl_Release( p_intf ); 
  562.     return 0; 
  563.     } while(0)
  565.     playlist_t *p_playlist = pl_Hold( p_intf );
  567.     if( p_sys->i_box_type == BOX_PLAYLIST )
  568.     {
  569.         int b_ret = true;
  570.         bool b_box_plidx_follow = false;
  572.         switch( i_key )
  573.         {
  574.             vlc_value_t val;
  575.             /* Playlist Settings */
  576.             case 'r':
  577.                 var_Get( p_playlist, "random", &val );
  578.                 val.b_bool = !val.b_bool;
  579.                 var_Set( p_playlist, "random", val );
  580.                 ReturnTrue;
  581.             case 'l':
  582.                 var_Get( p_playlist, "loop", &val );
  583.                 val.b_bool = !val.b_bool;
  584.                 var_Set( p_playlist, "loop", val );
  585.                 ReturnTrue;
  586.             case 'R':
  587.                 var_Get( p_playlist, "repeat", &val );
  588.                 val.b_bool = !val.b_bool;
  589.                 var_Set( p_playlist, "repeat", val );
  590.                 ReturnTrue;
  592.             /* Playlist sort */
  593.             case 'o':
  594.                 playlist_RecursiveNodeSort( p_playlist,
  595.                                             PlaylistGetRoot( p_intf ),
  596.                                             SORT_TITLE_NODES_FIRST, ORDER_NORMAL );
  597.                 p_sys->b_need_update = true;
  598.                 ReturnTrue;
  599.             case 'O':
  600.                 playlist_RecursiveNodeSort( p_playlist,
  601.                                             PlaylistGetRoot( p_intf ),
  602.                                             SORT_TITLE_NODES_FIRST, ORDER_REVERSE );
  603.                 p_sys->b_need_update = true;
  604.                 ReturnTrue;
  606.             /* Playlist view */
  607.             case 'v':
  608.                 switch( p_sys->i_current_view )
  609.                 {
  610.                     case VIEW_CATEGORY:
  611.                         p_sys->i_current_view = VIEW_ONELEVEL;
  612.                         break;
  613.                     default:
  614.                         p_sys->i_current_view = VIEW_CATEGORY;
  615.                 }
  616.                 //p_sys->b_need_update = true;
  617.                 PlaylistRebuild( p_intf );
  618.                 ReturnTrue;
  620.             /* Playlist navigation */
  621.             case 'g':
  622.                 FindIndex( p_intf, p_playlist );
  623.                 break;
  624.             case KEY_HOME:
  625.                 p_sys->i_box_plidx = 0;
  626.                 break;
  627. #ifdef __FreeBSD__
  628. /* workaround for FreeBSD + xterm:
  629.  * see http://www.nabble.com/curses-vs.-xterm-key-mismatch-t3574377.html */
  630.             case KEY_SELECT:
  631. #endif
  632.             case KEY_END:
  633.                 p_sys->i_box_plidx = p_playlist->items.i_size - 1;
  634.                 break;
  635.             case KEY_UP:
  636.                 p_sys->i_box_plidx--;
  637.                 break;
  638.             case KEY_DOWN:
  639.                 p_sys->i_box_plidx++;
  640.                 break;
  641.             case KEY_PPAGE:
  642.                 p_sys->i_box_plidx -= p_sys->i_box_lines;
  643.                 break;
  644.             case KEY_NPAGE:
  645.                 p_sys->i_box_plidx += p_sys->i_box_lines;
  646.                 break;
  647.             case 'D':
  648.             case KEY_BACKSPACE:
  649.             case 0x7f:
  650.             case KEY_DC:
  651.             {
  652.                 playlist_item_t *p_item;
  654.                 PL_LOCK;
  655.                 p_item = p_sys->pp_plist[p_sys->i_box_plidx]->p_item;
  656.                 if( p_item->i_children == -1 )
  657.                 {
  658.                     playlist_DeleteFromInput( p_playlist,
  659.                                               p_item->p_input->i_id, pl_Locked );
  660.                 }
  661.                 else
  662.                 {
  663.                     playlist_NodeDelete( p_playlist, p_item,
  664.                                          true , false );
  665.                 }
  666.                 PL_UNLOCK;
  667.                 PlaylistRebuild( p_intf );
  668.                 break;
  669.             }
  671.             case KEY_ENTER:
  672.             case 'r':
  673.             case 'n':
  674.                 if( !p_sys->pp_plist[p_sys->i_box_plidx] )
  675.                 {
  676.                     b_ret = false;
  677.                     break;
  678.                 }
  679.                 if( p_sys->pp_plist[p_sys->i_box_plidx]->p_item->i_children
  680.                         == -1 )
  681.                 {
  682.                     playlist_item_t *p_item, *p_parent;
  683.                     p_item = p_parent =
  684.                             p_sys->pp_plist[p_sys->i_box_plidx]->p_item;
  686.                     if( !p_parent )
  687.                         p_parent = p_playlist->p_root_onelevel;
  688.                     while( p_parent->p_parent )
  689.                         p_parent = p_parent->p_parent;
  690.                     playlist_Control( p_playlist, PLAYLIST_VIEWPLAY,
  691.                                       pl_Unlocked, p_parent, p_item );
  692.                 }
  693.                 else if( p_sys->pp_plist[p_sys->i_box_plidx]->p_item->i_children
  694.                         == 0 )
  695.                 {   /* We only want to set the current node */
  696.                     playlist_Stop( p_playlist );
  697.                     p_sys->p_node = p_sys->pp_plist[p_sys->i_box_plidx]->p_item;
  698.                 }
  699.                 else
  700.                 {
  701.                     p_sys->p_node = p_sys->pp_plist[p_sys->i_box_plidx]->p_item;
  702.                     playlist_Control( p_playlist, PLAYLIST_VIEWPLAY, pl_Unlocked,
  703.                         p_sys->pp_plist[p_sys->i_box_plidx]->p_item, NULL );
  704.                 }
  705.                 b_box_plidx_follow = true;
  706.                 break;
  707.             default:
  708.                 b_ret = false;
  709.                 break;
  710.         }
  712.         if( b_ret )
  713.         {
  714.             int i_max = p_sys->i_plist_entries;
  715.             if( p_sys->i_box_plidx >= i_max ) p_sys->i_box_plidx = i_max - 1;
  716.             if( p_sys->i_box_plidx < 0 ) p_sys->i_box_plidx = 0;
  718.             PL_LOCK;
  719.             if( PlaylistIsPlaying( p_playlist,
  720.                                    p_sys->pp_plist[p_sys->i_box_plidx]->p_item ) )
  721.                 b_box_plidx_follow = true;
  722.             PL_UNLOCK;
  723.             p_sys->b_box_plidx_follow = b_box_plidx_follow;
  724.             ReturnTrue;
  725.         }
  726.     }
  727.     if( p_sys->i_box_type == BOX_BROWSE )
  728.     {
  729.         bool b_ret = true;
  730.         /* Browser navigation */
  731.         switch( i_key )
  732.         {
  733.             case KEY_HOME:
  734.                 p_sys->i_box_bidx = 0;
  735.                 break;
  736. #ifdef __FreeBSD__
  737.             case KEY_SELECT:
  738. #endif
  739.             case KEY_END:
  740.                 p_sys->i_box_bidx = p_sys->i_dir_entries - 1;
  741.                 break;
  742.             case KEY_UP:
  743.                 p_sys->i_box_bidx--;
  744.                 break;
  745.             case KEY_DOWN:
  746.                 p_sys->i_box_bidx++;
  747.                 break;
  748.             case KEY_PPAGE:
  749.                 p_sys->i_box_bidx -= p_sys->i_box_lines;
  750.                 break;
  751.             case KEY_NPAGE:
  752.                 p_sys->i_box_bidx += p_sys->i_box_lines;
  753.                 break;
  754.             case '.': /* Toggle show hidden files */
  755.                 p_sys->b_show_hidden_files = ( p_sys->b_show_hidden_files ==
  756.                     true ? false : true );
  757.                 ReadDir( p_intf );
  758.                 break;
  760.             case KEY_ENTER:
  761.             case 'r':
  762.             case 'n':
  763.             case ' ':
  764.                 if( p_sys->pp_dir_entries[p_sys->i_box_bidx]->b_file || i_key == ' ' )
  765.                 {
  766.                     char* psz_uri;
  767.                     if( asprintf( &psz_uri, "%s://%s/%s",
  768.                         p_sys->pp_dir_entries[p_sys->i_box_bidx]->b_file ?
  769.                             "file" : "directory",
  770.                         p_sys->psz_current_dir,
  771.                         p_sys->pp_dir_entries[p_sys->i_box_bidx]->psz_path
  772.                         ) == -1 )
  773.                     {
  774.                         psz_uri = NULL;
  775.                     }
  777.                     playlist_item_t *p_parent = p_sys->p_node;
  778.                     if( !p_parent )
  779.                     {
  780.                         PL_LOCK;
  781.                         p_parent = playlist_CurrentPlayingItem(p_playlist) ? playlist_CurrentPlayingItem(p_playlist)->p_parent : NULL;
  782.                         PL_UNLOCK;
  783.                         if( !p_parent )
  784.                             p_parent = p_playlist->p_local_onelevel;
  785.                     }
  787.                     while( p_parent->p_parent && p_parent->p_parent->p_parent )
  788.                         p_parent = p_parent->p_parent;
  790.                     playlist_Add( p_playlist, psz_uri, NULL, PLAYLIST_APPEND,
  791.                                   PLAYLIST_END,
  792.                                   p_parent->p_input ==
  793.                                     p_playlist->p_local_onelevel->p_input
  794.                                   , false );
  796.                     p_sys->i_box_type = BOX_PLAYLIST;
  797.                     free( psz_uri );
  798.                 }
  799.                 else
  800.                 {
  801.                     if( asprintf( &(p_sys->psz_current_dir), "%s/%s", p_sys->psz_current_dir,
  802.                                   p_sys->pp_dir_entries[p_sys->i_box_bidx]->psz_path ) != -1 )
  803.                         ReadDir( p_intf );
  804.                 }
  805.                 break;
  806.             default:
  807.                 b_ret = false;
  808.                 break;
  809.         }
  810.         if( b_ret )
  811.         {
  812.             if( p_sys->i_box_bidx >= p_sys->i_dir_entries ) p_sys->i_box_bidx = p_sys->i_dir_entries - 1;
  813.             if( p_sys->i_box_bidx < 0 ) p_sys->i_box_bidx = 0;
  814.             ReturnTrue;
  815.         }
  816.     }
  817.     else if( p_sys->i_box_type == BOX_HELP || p_sys->i_box_type == BOX_INFO ||
  818.              p_sys->i_box_type == BOX_META || p_sys->i_box_type == BOX_STATS ||
  819.              p_sys->i_box_type == BOX_OBJECTS )
  820.     {
  821.         switch( i_key )
  822.         {
  823.             case KEY_HOME:
  824.                 p_sys->i_box_start = 0;
  825.                 ReturnTrue;
  826. #ifdef __FreeBSD__
  827.             case KEY_SELECT:
  828. #endif
  829.             case KEY_END:
  830.                 p_sys->i_box_start = p_sys->i_box_lines_total - 1;
  831.                 ReturnTrue;
  832.             case KEY_UP:
  833.                 if( p_sys->i_box_start > 0 ) p_sys->i_box_start--;
  834.                 ReturnTrue;
  835.             case KEY_DOWN:
  836.                 if( p_sys->i_box_start < p_sys->i_box_lines_total - 1 )
  837.                 {
  838.                     p_sys->i_box_start++;
  839.                 }
  840.                 ReturnTrue;
  841.             case KEY_PPAGE:
  842.                 p_sys->i_box_start -= p_sys->i_box_lines;
  843.                 if( p_sys->i_box_start < 0 ) p_sys->i_box_start = 0;
  844.                 ReturnTrue;
  845.             case KEY_NPAGE:
  846.                 p_sys->i_box_start += p_sys->i_box_lines;
  847.                 if( p_sys->i_box_start >= p_sys->i_box_lines_total )
  848.                 {
  849.                     p_sys->i_box_start = p_sys->i_box_lines_total - 1;
  850.                 }
  851.                 ReturnTrue;
  852.             default:
  853.                 break;
  854.         }
  855.     }
  856.     else if( p_sys->i_box_type == BOX_NONE )
  857.     {
  858.         switch( i_key )
  859.         {
  860.             case KEY_HOME:
  861.                 p_sys->f_slider = 0;
  862.                 ManageSlider( p_intf );
  863.                 ReturnTrue;
  864. #ifdef __FreeBSD__
  865.             case KEY_SELECT:
  866. #endif
  867.             case KEY_END:
  868.                 p_sys->f_slider = 99.9;
  869.                 ManageSlider( p_intf );
  870.                 ReturnTrue;
  871.             case KEY_UP:
  872.                 p_sys->f_slider += 5.0;
  873.                 if( p_sys->f_slider >= 99.0 ) p_sys->f_slider = 99.0;
  874.                 ManageSlider( p_intf );
  875.                 ReturnTrue;
  876.             case KEY_DOWN:
  877.                 p_sys->f_slider -= 5.0;
  878.                 if( p_sys->f_slider < 0.0 ) p_sys->f_slider = 0.0;
  879.                 ManageSlider( p_intf );
  880.                 ReturnTrue;
  882.             default:
  883.                 break;
  884.         }
  885.     }
  886.     else if( p_sys->i_box_type == BOX_SEARCH && p_sys->psz_search_chain )
  887.     {
  888.         int i_chain_len = strlen( p_sys->psz_search_chain );
  889.         switch( i_key )
  890.         {
  891.             case KEY_CLEAR:
  892.             case 0x0c:      /* ^l */
  893.                 clear();
  894.                 ReturnTrue;
  895.             case KEY_ENTER:
  896.             case 'r':
  897.             case 'n':
  898.                 if( i_chain_len > 0 )
  899.                 {
  900.                     p_sys->psz_old_search = strdup( p_sys->psz_search_chain );
  901.                 }
  902.                 else if( p_sys->psz_old_search )
  903.                 {
  904.                     SearchPlaylist( p_intf, p_sys->psz_old_search );
  905.                 }
  906.                 p_sys->i_box_type = BOX_PLAYLIST;
  907.                 ReturnTrue;
  908.             case 0x1b: /* ESC */
  909.                 /* Alt+key combinations return 2 keys in the terminal keyboard:
  910.                  * ESC, and the 2nd key.
  911.                  * If some other key is available immediately (where immediately
  912.                  * means after wgetch() 1 second delay ), that means that the
  913.                  * ESC key was not pressed.
  914.                  *
  915.                  * man 3X curs_getch says:
  916.                  *
  917.                  * Use of the escape key by a programmer for a single
  918.                  * character function is discouraged, as it will cause a delay
  919.                  * of up to one second while the keypad code looks for a
  920.                  * following function-key sequence.
  921.                  *
  922.                  */
  923.                 if( wgetch( p_sys->w ) != ERR )
  924.                     ReturnFalse;
  925.                 p_sys->i_box_plidx = p_sys->i_before_search;
  926.                 p_sys->i_box_type = BOX_PLAYLIST;
  927.                 ReturnTrue;
  928.             case KEY_BACKSPACE:
  929.             case 0x7f:
  930.                 RemoveLastUTF8Entity( p_sys->psz_search_chain, i_chain_len );
  931.                 break;
  932.             default:
  933.             {
  934. #ifdef HAVE_NCURSESW
  935.                 if( i_chain_len + 1 < SEARCH_CHAIN_SIZE )
  936.                 {
  937.                     p_sys->psz_search_chain[i_chain_len] = (char) i_key;
  938.                     p_sys->psz_search_chain[i_chain_len + 1] = '';
  939.                 }
  940. #else
  941.                 char *psz_utf8 = KeyToUTF8( i_key, p_sys->psz_partial_keys );
  943.                 if( psz_utf8 != NULL )
  944.                 {
  945.                     if( i_chain_len + strlen( psz_utf8 ) < SEARCH_CHAIN_SIZE )
  946.                     {
  947.                         strcpy( p_sys->psz_search_chain + i_chain_len,
  948.                                 psz_utf8 );
  949.                     }
  950.                     free( psz_utf8 );
  951.                 }
  952. #endif
  953.                 break;
  954.             }
  955.         }
  956.         free( p_sys->psz_old_search );
  957.         p_sys->psz_old_search = NULL;
  958.         SearchPlaylist( p_intf, p_sys->psz_search_chain );
  959.         ReturnTrue;
  960.     }
  961.     else if( p_sys->i_box_type == BOX_OPEN && p_sys->psz_open_chain )
  962.     {
  963.         int i_chain_len = strlen( p_sys->psz_open_chain );
  965.         switch( i_key )
  966.         {
  967.             case KEY_CLEAR:
  968.             case 0x0c:          /* ^l */
  969.                 clear();
  970.                 ReturnTrue;
  971.             case KEY_ENTER:
  972.             case 'r':
  973.             case 'n':
  974.                 if( i_chain_len > 0 )
  975.                 {
  976.                     playlist_item_t *p_parent = p_sys->p_node;
  978.                     if( !p_parent )
  979.                     p_parent = playlist_CurrentPlayingItem(p_playlist) ? playlist_CurrentPlayingItem(p_playlist)->p_parent : NULL;
  980.                     if( !p_parent )
  981.                         p_parent = p_playlist->p_local_onelevel;
  983.                     while( p_parent->p_parent && p_parent->p_parent->p_parent )
  984.                         p_parent = p_parent->p_parent;
  986.                     playlist_Add( p_playlist, p_sys->psz_open_chain, NULL,
  987.                                   PLAYLIST_APPEND|PLAYLIST_GO, PLAYLIST_END,
  988.                                   p_parent->p_input ==
  989.                                     p_playlist->p_local_onelevel->p_input
  990.                                   , false );
  992.                     p_sys->b_box_plidx_follow = true;
  993.                 }
  994.                 p_sys->i_box_type = BOX_PLAYLIST;
  995.                 ReturnTrue;
  996.             case 0x1b:  /* ESC */
  997.                 if( wgetch( p_sys->w ) != ERR )
  998.                     ReturnFalse;
  999.                 p_sys->i_box_type = BOX_PLAYLIST;
  1000.                 ReturnTrue;
  1001.             case KEY_BACKSPACE:
  1002.             case 0x7f:
  1003.                 RemoveLastUTF8Entity( p_sys->psz_open_chain, i_chain_len );
  1004.                 break;
  1005.             default:
  1006.             {
  1007. #ifdef HAVE_NCURSESW
  1008.                 if( i_chain_len + 1 < OPEN_CHAIN_SIZE )
  1009.                 {
  1010.                     p_sys->psz_open_chain[i_chain_len] = (char) i_key;
  1011.                     p_sys->psz_open_chain[i_chain_len + 1] = '';
  1012.                 }
  1013. #else
  1014.                 char *psz_utf8 = KeyToUTF8( i_key, p_sys->psz_partial_keys );
  1016.                 if( psz_utf8 != NULL )
  1017.                 {
  1018.                     if( i_chain_len + strlen( psz_utf8 ) < OPEN_CHAIN_SIZE )
  1019.                     {
  1020.                         strcpy( p_sys->psz_open_chain + i_chain_len,
  1021.                                 psz_utf8 );
  1022.                     }
  1023.                     free( psz_utf8 );
  1024.                 }
  1025. #endif
  1026.                 break;
  1027.             }
  1028.         }
  1029.         ReturnTrue;
  1030.     }
  1033.     /* Common keys */
  1034.     switch( i_key )
  1035.     {
  1036.         case 0x1b:  /* ESC */
  1037.             if( wgetch( p_sys->w ) != ERR )
  1038.                 ReturnFalse;
  1039.         case 'q':
  1040.         case 'Q':
  1041.         case KEY_EXIT:
  1042.             libvlc_Quit( p_intf->p_libvlc );
  1043.             ReturnFalse;
  1045.         /* Box switching */
  1046.         case 'i':
  1047.             if( p_sys->i_box_type == BOX_INFO )
  1048.                 p_sys->i_box_type = BOX_NONE;
  1049.             else
  1050.                 p_sys->i_box_type = BOX_INFO;
  1051.             p_sys->i_box_lines_total = 0;
  1052.             ReturnTrue;
  1053.         case 'm':
  1054.             if( p_sys->i_box_type == BOX_META )
  1055.                 p_sys->i_box_type = BOX_NONE;
  1056.             else
  1057.                 p_sys->i_box_type = BOX_META;
  1058.             p_sys->i_box_lines_total = 0;
  1059.             ReturnTrue;
  1060.         case 'L':
  1061.             if( p_sys->i_box_type == BOX_LOG )
  1062.                 p_sys->i_box_type = BOX_NONE;
  1063.             else
  1064.                 p_sys->i_box_type = BOX_LOG;
  1065.             ReturnTrue;
  1066.         case 'P':
  1067.             if( p_sys->i_box_type == BOX_PLAYLIST )
  1068.                 p_sys->i_box_type = BOX_NONE;
  1069.             else
  1070.                 p_sys->i_box_type = BOX_PLAYLIST;
  1071.             ReturnTrue;
  1072.         case 'B':
  1073.             if( p_sys->i_box_type == BOX_BROWSE )
  1074.                 p_sys->i_box_type = BOX_NONE;
  1075.             else
  1076.                 p_sys->i_box_type = BOX_BROWSE;
  1077.             ReturnTrue;
  1078.         case 'x':
  1079.             if( p_sys->i_box_type == BOX_OBJECTS )
  1080.                 p_sys->i_box_type = BOX_NONE;
  1081.             else
  1082.                 p_sys->i_box_type = BOX_OBJECTS;
  1083.             ReturnTrue;
  1084.         case 'S':
  1085.             if( p_sys->i_box_type == BOX_STATS )
  1086.                 p_sys->i_box_type = BOX_NONE;
  1087.             else
  1088.                 p_sys->i_box_type = BOX_STATS;
  1089.             ReturnTrue;
  1090.         case 'c':
  1091.             p_sys->b_color = !p_sys->b_color;
  1092.             if( p_sys->b_color && !p_sys->b_color_started )
  1093.                 start_color_and_pairs( p_intf );
  1094.             ReturnTrue;
  1095.         case 'h':
  1096.         case 'H':
  1097.             if( p_sys->i_box_type == BOX_HELP )
  1098.                 p_sys->i_box_type = BOX_NONE;
  1099.             else
  1100.                 p_sys->i_box_type = BOX_HELP;
  1101.             p_sys->i_box_lines_total = 0;
  1102.             ReturnTrue;
  1103.         case '/':
  1104.             if( p_sys->i_box_type != BOX_SEARCH )
  1105.             {
  1106.                 if( p_sys->psz_search_chain == NULL )
  1107.                     ReturnTrue;
  1108.                 p_sys->psz_search_chain[0] = '';
  1109.                 p_sys->b_box_plidx_follow = false;
  1110.                 p_sys->i_before_search = p_sys->i_box_plidx;
  1111.                 p_sys->i_box_type = BOX_SEARCH;
  1112.             }
  1113.             ReturnTrue;
  1114.         case 'A': /* Open */
  1115.             if( p_sys->i_box_type != BOX_OPEN )
  1116.             {
  1117.                 if( p_sys->psz_open_chain == NULL )
  1118.                     ReturnTrue;
  1119.                 p_sys->psz_open_chain[0] = '';
  1120.                 p_sys->i_box_type = BOX_OPEN;
  1121.             }
  1122.             ReturnTrue;
  1124.         /* Navigation */
  1125.         case KEY_RIGHT:
  1126.             p_sys->f_slider += 1.0;
  1127.             if( p_sys->f_slider > 99.9 ) p_sys->f_slider = 99.9;
  1128.             ManageSlider( p_intf );
  1129.             ReturnTrue;
  1131.         case KEY_LEFT:
  1132.             p_sys->f_slider -= 1.0;
  1133.             if( p_sys->f_slider < 0.0 ) p_sys->f_slider = 0.0;
  1134.             ManageSlider( p_intf );
  1135.             ReturnTrue;
  1137.         /* Common control */
  1138.         case 'f':
  1139.         {
  1140.             if( p_intf->p_sys->p_input )
  1141.             {
  1142.                 vout_thread_t *p_vout;
  1143.                 p_vout = vlc_object_find( p_intf->p_sys->p_input,
  1144.                                           VLC_OBJECT_VOUT, FIND_CHILD );
  1145.                 if( p_vout )
  1146.                 {
  1147.                     var_Get( p_vout, "fullscreen", &val );
  1148.                     val.b_bool = !val.b_bool;
  1149.                     var_Set( p_vout, "fullscreen", val );
  1150.                     vlc_object_release( p_vout );
  1151.                 }
  1152.                 else
  1153.                 {
  1154.                     var_Get( p_playlist, "fullscreen", &val );
  1155.                     val.b_bool = !val.b_bool;
  1156.                     var_Set( p_playlist, "fullscreen", val );
  1157.                 }
  1158.             }
  1159.             ReturnFalse;
  1160.         }
  1162.         case ' ':
  1163.             PlayPause( p_intf );
  1164.             ReturnTrue;
  1166.         case 's':
  1167.             playlist_Stop( p_playlist );
  1168.             ReturnTrue;
  1170.         case 'e':
  1171.             Eject( p_intf );
  1172.             ReturnTrue;
  1174.         case '[':
  1175.             if( p_sys->p_input )
  1176.                 var_SetVoid( p_sys->p_input, "prev-title" );
  1177.             ReturnTrue;
  1179.         case ']':
  1180.             if( p_sys->p_input )
  1181.                 var_SetVoid( p_sys->p_input, "next-title" );
  1182.             ReturnTrue;
  1184.         case '<':
  1185.             if( p_sys->p_input )
  1186.                 var_SetVoid( p_sys->p_input, "prev-chapter" );
  1187.             ReturnTrue;
  1189.         case '>':
  1190.             if( p_sys->p_input )
  1191.                 var_SetVoid( p_sys->p_input, "next-chapter" );
  1192.             ReturnTrue;
  1194.         case 'p':
  1195.             playlist_Prev( p_playlist );
  1196.             clear();
  1197.             ReturnTrue;
  1199.         case 'n':
  1200.             playlist_Next( p_playlist );
  1201.             clear();
  1202.             ReturnTrue;
  1204.         case 'a':
  1205.             aout_VolumeUp( p_intf, 1, NULL );
  1206.             clear();
  1207.             ReturnTrue;
  1209.         case 'z':
  1210.             aout_VolumeDown( p_intf, 1, NULL );
  1211.             clear();
  1212.             ReturnTrue;
  1214.         /*
  1215.          * ^l should clear and redraw the screen
  1216.          */
  1217.         case KEY_CLEAR:
  1218.         case 0x0c:          /* ^l */
  1219.             clear();
  1220.             ReturnTrue;
  1222.         default:
  1223.             ReturnFalse;
  1224.     }
  1225. #undef ReturnFalse
  1226. #undef ReturnTrue
  1227. }
  1229. static void ManageSlider( intf_thread_t *p_intf )
  1230. {
  1231.     intf_sys_t     *p_sys = p_intf->p_sys;
  1232.     input_thread_t *p_input = p_sys->p_input;
  1233.     vlc_value_t     val;
  1235.     if( p_input == NULL )
  1236.     {
  1237.         return;
  1238.     }
  1239.     var_Get( p_input, "state", &val );
  1240.     if( val.i_int != PLAYING_S )
  1241.     {
  1242.         return;
  1243.     }
  1245.     var_Get( p_input, "position", &val );
  1246.     if( p_sys->f_slider == p_sys->f_slider_old )
  1247.     {
  1248.         p_sys->f_slider =
  1249.         p_sys->f_slider_old = 100 * val.f_float;
  1250.     }
  1251.     else
  1252.     {
  1253.         p_sys->f_slider_old = p_sys->f_slider;
  1255.         val.f_float = p_sys->f_slider / 100.0;
  1256.         var_Set( p_input, "position", val );
  1257.     }
  1258. }
  1260. static void SearchPlaylist( intf_thread_t *p_intf, char *psz_searchstring )
  1261. {
  1262.     int i_max;
  1263.     int i_first = 0 ;
  1264.     int i_item = -1;
  1265.     intf_sys_t *p_sys = p_intf->p_sys;
  1267.     if( p_sys->i_before_search >= 0 )
  1268.     {
  1269.         i_first = p_sys->i_before_search;
  1270.     }
  1272.     if( ( ! psz_searchstring ) ||  strlen( psz_searchstring ) <= 0 )
  1273.     {
  1274.         p_sys->i_box_plidx = p_sys->i_before_search;
  1275.         return;
  1276.     }
  1278.     i_max = p_sys->i_plist_entries;
  1280.     i_item = SubSearchPlaylist( p_intf, psz_searchstring, i_first + 1, i_max );
  1281.     if( i_item < 0 )
  1282.     {
  1283.         i_item = SubSearchPlaylist( p_intf, psz_searchstring, 0, i_first );
  1284.     }
  1286.     if( i_item < 0 || i_item >= i_max ) return;
  1288.     p_sys->i_box_plidx = i_item;
  1289. }
  1291. static int SubSearchPlaylist( intf_thread_t *p_intf, char *psz_searchstring,
  1292.                               int i_start, int i_stop )
  1293. {
  1294.     intf_sys_t *p_sys = p_intf->p_sys;
  1295.     int i, i_item = -1;
  1297.     for( i = i_start + 1; i < i_stop; i++ )
  1298.     {
  1299.         if( strcasestr( p_sys->pp_plist[i]->psz_display,
  1300.                         psz_searchstring ) != NULL )
  1301.         {
  1302.             i_item = i;
  1303.             break;
  1304.         }
  1305.     }
  1307.     return i_item;
  1308. }
  1311. static void mvnprintw( int y, int x, int w, const char *p_fmt, ... )
  1312. {
  1313.     va_list  vl_args;
  1314.     char    *p_buf = NULL;
  1315.     int      i_len;
  1317.     if( w <= 0 )
  1318.         return;
  1320.     va_start( vl_args, p_fmt );
  1321.     if( vasprintf( &p_buf, p_fmt, vl_args ) == -1 )
  1322.         return;
  1323.     va_end( vl_args );
  1325.     i_len = strlen( p_buf );
  1327. #ifdef HAVE_NCURSESW
  1328.     wchar_t psz_wide[i_len + 1];
  1330.     EnsureUTF8( p_buf );
  1331.     size_t i_char_len = mbstowcs( psz_wide, p_buf, i_len );
  1333.     size_t i_width; /* number of columns */
  1335.     if( i_char_len == (size_t)-1 )
  1336.     /* an invalid character was encountered */
  1337.     {
  1338.         free( p_buf );
  1339.         return;
  1340.     }
  1341.     else
  1342.     {
  1343.         i_width = wcswidth( psz_wide, i_char_len );
  1344.         if( i_width == (size_t)-1 )
  1345.         {
  1346.             /* a non printable character was encountered */
  1347.             unsigned int i;
  1348.             int i_cwidth;
  1349.             i_width = 0;
  1350.             for( i = 0 ; i < i_char_len ; i++ )
  1351.             {
  1352.                 i_cwidth = wcwidth( psz_wide[i] );
  1353.                 if( i_cwidth != -1 )
  1354.                     i_width += i_cwidth;
  1355.             }
  1356.         }
  1357.     }
  1358.     if( i_width > (size_t)w )
  1359.     {
  1360.         int i_total_width = 0;
  1361.         int i = 0;
  1362.         while( i_total_width < w )
  1363.         {
  1364.             i_total_width += wcwidth( psz_wide[i] );
  1365.             if( w > 7 && i_total_width >= w/2 )
  1366.             {
  1367.                 psz_wide[i  ] = '.';
  1368.                 psz_wide[i+1] = '.';
  1369.                 i_total_width -= wcwidth( psz_wide[i] ) - 2;
  1370.                 if( i > 0 )
  1371.                 {
  1372.                     /* we require this check only if at least one character
  1373.                      * 4 or more columns wide exists (which i doubt) */
  1374.                     psz_wide[i-1] = '.';
  1375.                     i_total_width -= wcwidth( psz_wide[i-1] ) - 1;
  1376.                 }
  1378.                 /* find the widest string */
  1379.                 int j, i_2nd_width = 0;
  1380.                 for( j = i_char_len - 1; i_2nd_width < w - i_total_width; j-- )
  1381.                     i_2nd_width += wcwidth( psz_wide[j] );
  1383.                 /* we already have i_total_width columns filled, and we can't
  1384.                  * have more than w columns */
  1385.                 if( i_2nd_width > w - i_total_width )
  1386.                     j++;
  1388.                 wmemmove( &psz_wide[i+2], &psz_wide[j+1], i_char_len - j - 1 );
  1389.                 psz_wide[i + 2 + i_char_len - j - 1] = '';
  1390.                 break;
  1391.             }
  1392.             i++;
  1393.         }
  1394.         if( w <= 7 ) /* we don't add the '...' else we lose too much chars */
  1395.             psz_wide[i] = '';
  1397.         size_t i_wlen = wcslen( psz_wide ) * 6 + 1; /* worst case */
  1398.         char psz_ellipsized[i_wlen];
  1399.         wcstombs( psz_ellipsized, psz_wide, i_wlen );
  1400.         mvprintw( y, x, "%s", psz_ellipsized );
  1401.     }
  1402.     else
  1403.     {
  1404.         mvprintw( y, x, "%s", p_buf );
  1405.         mvhline( y, x + i_width, ' ', w - i_width );
  1406.     }
  1408. #else
  1409.     if( i_len > w )
  1410.     {
  1411.         int i_cut = i_len - w;
  1412.         int x1 = i_len/2 - i_cut/2;
  1413.         int x2 = x1 + i_cut;
  1415.         if( i_len > x2 )
  1416.         {
  1417.             memmove( &p_buf[x1], &p_buf[x2], i_len - x2 );
  1418.         }
  1419.         p_buf[w] = '';
  1420.         if( w > 7 )
  1421.         {
  1422.             p_buf[w/2-1] = '.';
  1423.             p_buf[w/2  ] = '.';
  1424.             p_buf[w/2+1] = '.';
  1425.         }
  1426.         char *psz_local = ToLocale( p_buf );
  1427.         mvprintw( y, x, "%s", psz_local );
  1428.         LocaleFree( p_buf );
  1429.     }
  1430.     else
  1431.     {
  1432.         char *psz_local = ToLocale( p_buf );
  1433.         mvprintw( y, x, "%s", psz_local );
  1434.         LocaleFree( p_buf );
  1435.         mvhline( y, x + i_len, ' ', w - i_len );
  1436.     }
  1437. #endif
  1438.     free( p_buf );
  1439. }
  1440. static void MainBoxWrite( intf_thread_t *p_intf, int l, int x, const char *p_fmt, ... )
  1441. {
  1442.     intf_sys_t     *p_sys = p_intf->p_sys;
  1444.     va_list  vl_args;
  1445.     char    *p_buf = NULL;
  1447.     if( l < p_sys->i_box_start || l - p_sys->i_box_start >= p_sys->i_box_lines )
  1448.     {
  1449.         return;
  1450.     }
  1452.     va_start( vl_args, p_fmt );
  1453.     if( vasprintf( &p_buf, p_fmt, vl_args ) == -1 )
  1454.         return;
  1455.     va_end( vl_args );
  1457.     mvnprintw( p_sys->i_box_y + l - p_sys->i_box_start, x, COLS - x - 1, "%s", p_buf );
  1458.     free( p_buf );
  1459. }
  1461. static void DumpObject( intf_thread_t *p_intf, int *l, vlc_object_t *p_obj, int i_level )
  1462. {
  1463.     if( p_obj->psz_object_name )
  1464.         MainBoxWrite( p_intf, (*l)++, 1 + 2 * i_level, "%s "%s" (%p)",
  1465.                 p_obj->psz_object_type, p_obj->psz_object_name,
  1466.                 p_obj );
  1467.     else
  1468.         MainBoxWrite( p_intf, (*l)++, 1 + 2 * i_level, "%s (%o)",
  1469.                 p_obj->psz_object_type, p_obj );
  1471.     vlc_list_t *list = vlc_list_children( p_obj );
  1472.     for( int i = 0; i < list->i_count ; i++ )
  1473.     {
  1474.         MainBoxWrite( p_intf, *l, 1 + 2 * i_level,
  1475.             i == list->i_count - 1 ? "`-" : "|-" );
  1476.         DumpObject( p_intf, l, list->p_values[i].p_object, i_level + 1 );
  1477.     }
  1478.     vlc_list_release( list );
  1479. }
  1481. static void Redraw( intf_thread_t *p_intf, time_t *t_last_refresh )
  1482. {
  1483.     intf_sys_t     *p_sys = p_intf->p_sys;
  1484.     input_thread_t *p_input = p_sys->p_input;
  1485.     playlist_t     *p_playlist = pl_Hold( p_intf );
  1486.     int y = 0;
  1487.     int h;
  1488.     int y_end;
  1490.     /* Title */
  1491.     attrset( A_REVERSE );
  1492.     int i_len = strlen( "VLC media player "PACKAGE_VERSION );
  1493.     int mid = ( COLS - i_len ) / 2;
  1494.     if( mid < 0 )
  1495.         mid = 0;
  1496.     int i_size = ( COLS > i_len + 1 ) ? COLS : i_len + 1;
  1497.     char psz_title[i_size];
  1498.     memset( psz_title, ' ', mid );
  1499.     if( p_sys->b_color )
  1500.         wcolor_set( p_sys->w, C_TITLE, NULL );
  1501.     snprintf( &psz_title[mid], i_size, "VLC media player "PACKAGE_VERSION );
  1502.     mvnprintw( y, 0, COLS, "%s", psz_title );
  1503.     attroff( A_REVERSE );
  1504.     y += 2;
  1506.     if( p_sys->b_color )
  1507.         wcolor_set( p_sys->w, C_STATUS, NULL );
  1509.     /* Infos */
  1510.     char *psz_state;
  1511.     if( asprintf( &psz_state, "%s%s%s",
  1512.             var_GetBool( p_playlist, "repeat" ) ? _( "[Repeat] " ) : "",
  1513.             var_GetBool( p_playlist, "random" ) ? _( "[Random] " ) : "",
  1514.             var_GetBool( p_playlist, "loop" ) ? _( "[Loop]" ) : "" ) == -1 )
  1515.         psz_state = NULL;
  1517.     if( p_input && !p_input->b_dead )
  1518.     {
  1519.         char buf1[MSTRTIME_MAX_SIZE];
  1520.         char buf2[MSTRTIME_MAX_SIZE];
  1521.         vlc_value_t val;
  1522.         vlc_value_t val_list;
  1524.         /* Source */
  1525.         char *psz_uri = input_item_GetURI( input_GetItem( p_input ) );
  1526.         mvnprintw( y++, 0, COLS, _(" Source   : %s"), psz_uri );
  1527.         free( psz_uri );
  1529.         /* State */
  1530.         var_Get( p_input, "state", &val );
  1531.         if( val.i_int == PLAYING_S )
  1532.         {
  1533.             mvnprintw( y++, 0, COLS, _(" State    : Playing %s"), psz_state );
  1534.         }
  1535.         else if( val.i_int == OPENING_S )
  1536.         {
  1537.             mvnprintw( y++, 0, COLS, _(" State    : Opening/Connecting %s"), psz_state );
  1538.         }
  1539.         else if( val.i_int == PAUSE_S )
  1540.         {
  1541.             mvnprintw( y++, 0, COLS, _(" State    : Paused %s"), psz_state );
  1542.         }
  1544.         if( val.i_int != INIT_S && val.i_int != END_S )
  1545.         {
  1546.             audio_volume_t i_volume;
  1548.             /* Position */
  1549.             var_Get( p_input, "time", &val );
  1550.             msecstotimestr( buf1, val.i_time / 1000 );
  1552.             var_Get( p_input, "length", &val );
  1553.             msecstotimestr( buf2, val.i_time / 1000 );
  1555.             mvnprintw( y++, 0, COLS, _(" Position : %s/%s (%.2f%%)"), buf1, buf2, p_sys->f_slider );
  1557.             /* Volume */
  1558.             aout_VolumeGet( p_intf, &i_volume );
  1559.             mvnprintw( y++, 0, COLS, _(" Volume   : %i%%"), i_volume*200/AOUT_VOLUME_MAX );
  1561.             /* Title */
  1562.             if( !var_Get( p_input, "title", &val ) )
  1563.             {
  1564.                 var_Change( p_input, "title", VLC_VAR_GETCHOICES, &val_list, NULL );
  1565.                 if( val_list.p_list->i_count > 0 )
  1566.                 {
  1567.                     mvnprintw( y++, 0, COLS, _(" Title    : %d/%d"), val.i_int, val_list.p_list->i_count );
  1568.                 }
  1569.                 var_Change( p_input, "title", VLC_VAR_FREELIST, &val_list, NULL );
  1570.             }
  1572.             /* Chapter */
  1573.             if( !var_Get( p_input, "chapter", &val ) )
  1574.             {
  1575.                 var_Change( p_input, "chapter", VLC_VAR_GETCHOICES, &val_list, NULL );
  1576.                 if( val_list.p_list->i_count > 0 )
  1577.                 {
  1578.                     mvnprintw( y++, 0, COLS, _(" Chapter  : %d/%d"), val.i_int, val_list.p_list->i_count );
  1579.                 }
  1580.                 var_Change( p_input, "chapter", VLC_VAR_FREELIST, &val_list, NULL );
  1581.             }
  1582.         }
  1583.         else
  1584.         {
  1585.             y += 2;
  1586.         }
  1587.     }
  1588.     else
  1589.     {
  1590.         mvnprintw( y++, 0, COLS, _(" Source: <no current item> %s"), psz_state );
  1591.         DrawEmptyLine( p_sys->w, y++, 0, COLS );
  1592.         mvnprintw( y++, 0, COLS, _(" [ h for help ]") );
  1593.         DrawEmptyLine( p_sys->w, y++, 0, COLS );
  1594.     }
  1595.     free( psz_state );
  1596.     if( p_sys->b_color )
  1597.         wcolor_set( p_sys->w, C_DEFAULT, NULL );
  1599.     DrawBox( p_sys->w, y, 0, 3, COLS, "", p_sys->b_color );
  1600.     DrawEmptyLine( p_sys->w, y+1, 1, COLS-2);
  1601.     DrawLine( p_sys->w, y+1, 1, (int)(p_intf->p_sys->f_slider/100.0 * (COLS -2)) );
  1602.     y += 3;
  1604.     p_sys->i_box_y = y + 1;
  1605.     p_sys->i_box_lines = LINES - y - 2;
  1607.     h = LINES - y;
  1608.     y_end = y + h - 1;
  1610.     if( p_sys->i_box_type == BOX_HELP )
  1611.     {
  1612.         /* Help box */
  1613.         int l = 0;
  1614.         DrawBox( p_sys->w, y++, 0, h, COLS, _(" Help "), p_sys->b_color );
  1616.         if( p_sys->b_color )
  1617.             wcolor_set( p_sys->w, C_CATEGORY, NULL );
  1618.         MainBoxWrite( p_intf, l++, 1, _("[Display]") );
  1619.         if( p_sys->b_color )
  1620.             wcolor_set( p_sys->w, C_DEFAULT, NULL );
  1621.         MainBoxWrite( p_intf, l++, 1, _("     h,H         Show/Hide help box") );
  1622.         MainBoxWrite( p_intf, l++, 1, _("     i           Show/Hide info box") );
  1623.         MainBoxWrite( p_intf, l++, 1, _("     m           Show/Hide metadata box") );
  1624.         MainBoxWrite( p_intf, l++, 1, _("     L           Show/Hide messages box") );
  1625.         MainBoxWrite( p_intf, l++, 1, _("     P           Show/Hide playlist box") );
  1626.         MainBoxWrite( p_intf, l++, 1, _("     B           Show/Hide filebrowser") );
  1627.         MainBoxWrite( p_intf, l++, 1, _("     x           Show/Hide objects box") );
  1628.         MainBoxWrite( p_intf, l++, 1, _("     S           Show/Hide statistics box" ) );
  1629.         MainBoxWrite( p_intf, l++, 1, _("     c           Switch color on/off") );
  1630.         MainBoxWrite( p_intf, l++, 1, _("     Esc         Close Add/Search entry") );
  1631.         MainBoxWrite( p_intf, l++, 1, "" );
  1633.         if( p_sys->b_color )
  1634.             wcolor_set( p_sys->w, C_CATEGORY, NULL );
  1635.         MainBoxWrite( p_intf, l++, 1, _("[Global]") );
  1636.         if( p_sys->b_color )
  1637.             wcolor_set( p_sys->w, C_DEFAULT, NULL );
  1638.         MainBoxWrite( p_intf, l++, 1, _("     q, Q, Esc   Quit") );
  1639.         MainBoxWrite( p_intf, l++, 1, _("     s           Stop") );
  1640.         MainBoxWrite( p_intf, l++, 1, _("     <space>     Pause/Play") );
  1641.         MainBoxWrite( p_intf, l++, 1, _("     f           Toggle Fullscreen") );
  1642.         MainBoxWrite( p_intf, l++, 1, _("     n, p        Next/Previous playlist item") );
  1643.         MainBoxWrite( p_intf, l++, 1, _("     [, ]        Next/Previous title") );
  1644.         MainBoxWrite( p_intf, l++, 1, _("     <, >        Next/Previous chapter") );
  1645.         MainBoxWrite( p_intf, l++, 1, _("     <right>     Seek +1%%") );
  1646.         MainBoxWrite( p_intf, l++, 1, _("     <left>      Seek -1%%") );
  1647.         MainBoxWrite( p_intf, l++, 1, _("     a           Volume Up") );
  1648.         MainBoxWrite( p_intf, l++, 1, _("     z           Volume Down") );
  1649.         MainBoxWrite( p_intf, l++, 1, "" );
  1651.         if( p_sys->b_color )
  1652.             wcolor_set( p_sys->w, C_CATEGORY, NULL );
  1653.         MainBoxWrite( p_intf, l++, 1, _("[Playlist]") );
  1654.         if( p_sys->b_color )
  1655.             wcolor_set( p_sys->w, C_DEFAULT, NULL );
  1656.         MainBoxWrite( p_intf, l++, 1, _("     r           Toggle Random playing") );
  1657.         MainBoxWrite( p_intf, l++, 1, _("     l           Toggle Loop Playlist") );
  1658.         MainBoxWrite( p_intf, l++, 1, _("     R           Toggle Repeat item") );
  1659.         MainBoxWrite( p_intf, l++, 1, _("     o           Order Playlist by title") );
  1660.         MainBoxWrite( p_intf, l++, 1, _("     O           Reverse order Playlist by title") );
  1661.         MainBoxWrite( p_intf, l++, 1, _("     g           Go to the current playing item") );
  1662.         MainBoxWrite( p_intf, l++, 1, _("     /           Look for an item") );
  1663.         MainBoxWrite( p_intf, l++, 1, _("     A           Add an entry") );
  1664.         MainBoxWrite( p_intf, l++, 1, _("     D, <del>    Delete an entry") );
  1665.         MainBoxWrite( p_intf, l++, 1, _("     <backspace> Delete an entry") );
  1666.         MainBoxWrite( p_intf, l++, 1, _("     e           Eject (if stopped)") );
  1667.         MainBoxWrite( p_intf, l++, 1, "" );
  1669.         if( p_sys->b_color )
  1670.             wcolor_set( p_sys->w, C_CATEGORY, NULL );
  1671.         MainBoxWrite( p_intf, l++, 1, _("[Filebrowser]") );
  1672.         if( p_sys->b_color )
  1673.             wcolor_set( p_sys->w, C_DEFAULT, NULL );
  1674.         MainBoxWrite( p_intf, l++, 1, _("     <enter>     Add the selected file to the playlist") );
  1675.         MainBoxWrite( p_intf, l++, 1, _("     <space>     Add the selected directory to the playlist") );
  1676.         MainBoxWrite( p_intf, l++, 1, _("     .           Show/Hide hidden files") );
  1677.         MainBoxWrite( p_intf, l++, 1, "" );
  1679.         if( p_sys->b_color )
  1680.             wcolor_set( p_sys->w, C_CATEGORY, NULL );
  1681.         MainBoxWrite( p_intf, l++, 1, _("[Boxes]") );
  1682.         if( p_sys->b_color )
  1683.             wcolor_set( p_sys->w, C_DEFAULT, NULL );
  1684.         MainBoxWrite( p_intf, l++, 1, _("     <up>,<down>     Navigate through the box line by line") );
  1685.         MainBoxWrite( p_intf, l++, 1, _("     <pgup>,<pgdown> Navigate through the box page by page") );
  1686.         MainBoxWrite( p_intf, l++, 1, "" );
  1688.         if( p_sys->b_color )
  1689.             wcolor_set( p_sys->w, C_CATEGORY, NULL );
  1690.         MainBoxWrite( p_intf, l++, 1, _("[Player]") );
  1691.         if( p_sys->b_color )
  1692.             wcolor_set( p_sys->w, C_DEFAULT, NULL );
  1693.         MainBoxWrite( p_intf, l++, 1, _("     <up>,<down>     Seek +/-5%%") );
  1694.         MainBoxWrite( p_intf, l++, 1, "" );
  1696.         if( p_sys->b_color )
  1697.             wcolor_set( p_sys->w, C_CATEGORY, NULL );
  1698.         MainBoxWrite( p_intf, l++, 1, _("[Miscellaneous]") );
  1699.         if( p_sys->b_color )
  1700.             wcolor_set( p_sys->w, C_DEFAULT, NULL );
  1701.         MainBoxWrite( p_intf, l++, 1, _("     Ctrl-l          Refresh the screen") );
  1703.         p_sys->i_box_lines_total = l;
  1704.         if( p_sys->i_box_start >= p_sys->i_box_lines_total )
  1705.         {
  1706.             p_sys->i_box_start = p_sys->i_box_lines_total - 1;
  1707.         }
  1709.         if( l - p_sys->i_box_start < p_sys->i_box_lines )
  1710.         {
  1711.             y += l - p_sys->i_box_start;
  1712.         }
  1713.         else
  1714.         {
  1715.             y += p_sys->i_box_lines;
  1716.         }
  1717.     }
  1718.     else if( p_sys->i_box_type == BOX_INFO )
  1719.     {
  1720.         /* Info box */
  1721.         int l = 0;
  1722.         DrawBox( p_sys->w, y++, 0, h, COLS, _(" Information "), p_sys->b_color );
  1724.         if( p_input )
  1725.         {
  1726.             int i,j;
  1727.             vlc_mutex_lock( &input_GetItem(p_input)->lock );
  1728.             for( i = 0; i < input_GetItem(p_input)->i_categories; i++ )
  1729.             {
  1730.                 info_category_t *p_category = input_GetItem(p_input)->pp_categories[i];
  1731.                 if( y >= y_end ) break;
  1732.                 if( p_sys->b_color )
  1733.                     wcolor_set( p_sys->w, C_CATEGORY, NULL );
  1734.                 MainBoxWrite( p_intf, l++, 1, _("  [%s]"), p_category->psz_name );
  1735.                 if( p_sys->b_color )
  1736.                     wcolor_set( p_sys->w, C_DEFAULT, NULL );
  1737.                 for( j = 0; j < p_category->i_infos; j++ )
  1738.                 {
  1739.                     info_t *p_info = p_category->pp_infos[j];
  1740.                     if( y >= y_end ) break;
  1741.                     MainBoxWrite( p_intf, l++, 1, _("      %s: %s"), p_info->psz_name, p_info->psz_value );
  1742.                 }
  1743.             }
  1744.             vlc_mutex_unlock( &input_GetItem(p_input)->lock );
  1745.         }
  1746.         else
  1747.         {
  1748.             MainBoxWrite( p_intf, l++, 1, _("No item currently playing") );
  1749.         }
  1750.         p_sys->i_box_lines_total = l;
  1751.         if( p_sys->i_box_start >= p_sys->i_box_lines_total )
  1752.         {
  1753.             p_sys->i_box_start = p_sys->i_box_lines_total - 1;
  1754.         }
  1756.         if( l - p_sys->i_box_start < p_sys->i_box_lines )
  1757.         {
  1758.             y += l - p_sys->i_box_start;
  1759.         }
  1760.         else
  1761.         {
  1762.             y += p_sys->i_box_lines;
  1763.         }
  1764.     }
  1765.     else if( p_sys->i_box_type == BOX_META )
  1766.     {
  1767.         /* Meta data box */
  1768.         int l = 0;
  1770.         DrawBox( p_sys->w, y++, 0, h, COLS, _("Meta-information"),
  1771.                  p_sys->b_color );
  1773.         if( p_input )
  1774.         {
  1775.             int i;
  1776.             input_item_t *p_item = input_GetItem( p_input );
  1777.             vlc_mutex_lock( &p_item->lock );
  1778.             for( i=0; i<VLC_META_TYPE_COUNT; i++ )
  1779.             {
  1780.                 if( y >= y_end ) break;
  1781.                 char *psz_meta = p_item->p_meta->ppsz_meta[i];
  1782.                 if( psz_meta && *psz_meta )
  1783.                 {
  1784.                     const char *psz_meta_title;
  1785.                     switch( i )
  1786.                     {
  1787.                         case 0:
  1788.                             psz_meta_title = VLC_META_TITLE; break;
  1789.                         case 1:
  1790.                             psz_meta_title = VLC_META_ARTIST; break;
  1791.                         case 2:
  1792.                             psz_meta_title = VLC_META_GENRE ; break;
  1793.                         case 3:
  1794.                             psz_meta_title = VLC_META_COPYRIGHT; break;
  1795.                         case 4:
  1796.                             psz_meta_title = VLC_META_ALBUM; break;
  1797.                         case 5:
  1798.                             psz_meta_title = VLC_META_TRACK_NUMBER; break;
  1799.                         case 6:
  1800.                             psz_meta_title = VLC_META_DESCRIPTION; break;
  1801.                         case 7:
  1802.                             psz_meta_title = VLC_META_RATING; break;
  1803.                         case 8:
  1804.                             psz_meta_title = VLC_META_DATE; break;
  1805.                         case 9:
  1806.                             psz_meta_title = VLC_META_SETTING; break;
  1807.                         case 10:
  1808.                             psz_meta_title = VLC_META_URL; break;
  1809.                         case 11:
  1810.                             psz_meta_title = VLC_META_LANGUAGE; break;
  1811.                         case 12:
  1812.                             psz_meta_title = VLC_META_NOW_PLAYING; break;
  1813.                         case 13:
  1814.                             psz_meta_title = VLC_META_PUBLISHER; break;
  1815.                         case 14:
  1816.                             psz_meta_title = VLC_META_ENCODED_BY; break;
  1817.                         case 15:
  1818.                             psz_meta_title = VLC_META_ART_URL; break;
  1819.                         case 16:
  1820.                             psz_meta_title = VLC_META_TRACKID; break;
  1821.                         default:
  1822.                             psz_meta_title = ""; break;
  1823.                     }
  1824.                     if( p_sys->b_color )
  1825.                         wcolor_set( p_sys->w, C_CATEGORY, NULL );
  1826.                     MainBoxWrite( p_intf, l++, 1, "  [%s]", psz_meta_title );
  1827.                     if( p_sys->b_color )
  1828.                         wcolor_set( p_sys->w, C_DEFAULT, NULL );
  1829.                     MainBoxWrite( p_intf, l++, 1, "      %s", psz_meta );
  1830.                 }
  1831.             }
  1832.             vlc_mutex_unlock( &p_item->lock );
  1833.         }
  1834.         else
  1835.         {
  1836.             MainBoxWrite( p_intf, l++, 1, _("No item currently playing") );
  1837.         }
  1838.         p_sys->i_box_lines_total = l;
  1839.         if( p_sys->i_box_start >= p_sys->i_box_lines_total )
  1840.         {
  1841.             p_sys->i_box_start = p_sys->i_box_lines_total - 1;
  1842.         }
  1844.         if( l - p_sys->i_box_start < p_sys->i_box_lines )
  1845.         {
  1846.             y += l - p_sys->i_box_start;
  1847.         }
  1848.         else
  1849.         {
  1850.             y += p_sys->i_box_lines;
  1851.         }
  1852.     }
  1853.     else if( p_sys->i_box_type == BOX_LOG )
  1854.     {
  1855. #warning Deprecated API
  1856. #if 0
  1857.         int i_line = 0;
  1858.         int i_stop;
  1859.         int i_start;
  1861.         DrawBox( p_sys->w, y++, 0, h, COLS, _(" Logs "), p_sys->b_color );
  1864.         i_start = p_intf->p_sys->p_sub->i_start;
  1866.         vlc_mutex_lock( p_intf->p_sys->p_sub->p_lock );
  1867.         i_stop = *p_intf->p_sys->p_sub->pi_stop;
  1868.         vlc_mutex_unlock( p_intf->p_sys->p_sub->p_lock );
  1870.         for( ;; )
  1871.         {
  1872.             static const char *ppsz_type[4] = { "", "error", "warning", "debug" };
  1873.             if( i_line >= h - 2 )
  1874.             {
  1875.                 break;
  1876.             }
  1877.             i_stop--;
  1878.             i_line++;
  1879.             if( i_stop < 0 ) i_stop += VLC_MSG_QSIZE;
  1880.             if( i_stop == i_start )
  1881.             {
  1882.                 break;
  1883.             }
  1884.             if( p_sys->b_color )
  1885.                 wcolor_set( p_sys->w,
  1886.                     p_sys->p_sub->p_msg[i_stop].i_type + C_INFO,
  1887.                     NULL );
  1888.             mvnprintw( y + h-2-i_line, 1, COLS - 2, "   [%s] %s",
  1889.                       ppsz_type[p_sys->p_sub->p_msg[i_stop].i_type],
  1890.                       p_sys->p_sub->p_msg[i_stop].psz_msg );
  1891.             if( p_sys->b_color )
  1892.                 wcolor_set( p_sys->w, C_DEFAULT, NULL );
  1893.         }
  1895.         vlc_mutex_lock( p_intf->p_sys->p_sub->p_lock );
  1896.         p_intf->p_sys->p_sub->i_start = i_stop;
  1897.         vlc_mutex_unlock( p_intf->p_sys->p_sub->p_lock );
  1898.         y = y_end;
  1899. #endif
  1900.     }
  1901.     else if( p_sys->i_box_type == BOX_BROWSE )
  1902.     {
  1903.         /* Filebrowser box */
  1904.         int        i_start, i_stop;
  1905.         int        i_item;
  1906.         DrawBox( p_sys->w, y++, 0, h, COLS, _(" Browse "), p_sys->b_color );
  1908.         if( p_sys->i_box_bidx >= p_sys->i_dir_entries ) p_sys->i_box_plidx = p_sys->i_dir_entries - 1;
  1909.         if( p_sys->i_box_bidx < 0 ) p_sys->i_box_bidx = 0;
  1911.         if( p_sys->i_box_bidx < (h - 2)/2 )
  1912.         {
  1913.             i_start = 0;
  1914.             i_stop = h - 2;
  1915.         }
  1916.         else if( p_sys->i_dir_entries - p_sys->i_box_bidx > (h - 2)/2 )
  1917.         {
  1918.             i_start = p_sys->i_box_bidx - (h - 2)/2;
  1919.             i_stop = i_start + h - 2;
  1920.         }
  1921.         else
  1922.         {
  1923.             i_stop = p_sys->i_dir_entries;
  1924.             i_start = p_sys->i_dir_entries - (h - 2);
  1925.         }
  1926.         if( i_start < 0 )
  1927.         {
  1928.             i_start = 0;
  1929.         }
  1930.         if( i_stop > p_sys->i_dir_entries )
  1931.         {
  1932.             i_stop = p_sys->i_dir_entries;
  1933.         }
  1935.         for( i_item = i_start; i_item < i_stop; i_item++ )
  1936.         {
  1937.             bool b_selected = ( p_sys->i_box_bidx == i_item );
  1939.             if( y >= y_end ) break;
  1940.             if( b_selected )
  1941.             {
  1942.                 attrset( A_REVERSE );
  1943.             }
  1944.             if( p_sys->b_color && !p_sys->pp_dir_entries[i_item]->b_file )
  1945.                 wcolor_set( p_sys->w, C_FOLDER, NULL );
  1946.             mvnprintw( y++, 1, COLS - 2, " %c %s", p_sys->pp_dir_entries[i_item]->b_file == true ? ' ' : '+',
  1947.                             p_sys->pp_dir_entries[i_item]->psz_path );
  1948.             if( p_sys->b_color && !p_sys->pp_dir_entries[i_item]->b_file )
  1949.                 wcolor_set( p_sys->w, C_DEFAULT, NULL );
  1951.             if( b_selected )
  1952.             {
  1953.                 attroff( A_REVERSE );
  1954.             }
  1955.         }
  1957.     }
  1958.     else if( p_sys->i_box_type == BOX_OBJECTS )
  1959.     {
  1960.         int l = 0;
  1961.         DrawBox( p_sys->w, y++, 0, h, COLS, _(" Objects "), p_sys->b_color );
  1962.         DumpObject( p_intf, &l, VLC_OBJECT( p_intf->p_libvlc ), 0 );
  1964.         p_sys->i_box_lines_total = l;
  1965.         if( p_sys->i_box_start >= p_sys->i_box_lines_total )
  1966.             p_sys->i_box_start = p_sys->i_box_lines_total - 1;
  1968.         if( l - p_sys->i_box_start < p_sys->i_box_lines )
  1969.             y += l - p_sys->i_box_start;
  1970.         else
  1971.             y += p_sys->i_box_lines;
  1972.     }
  1973.     else if( p_sys->i_box_type == BOX_STATS )
  1974.     {
  1975.         DrawBox( p_sys->w, y++, 0, h, COLS, _(" Stats "), p_sys->b_color );
  1977.         if( p_input )
  1978.         {
  1979.             input_item_t *p_item = input_GetItem( p_input );
  1980.             assert( p_item );
  1981.             vlc_mutex_lock( &p_item->lock );
  1982.             vlc_mutex_lock( &p_item->p_stats->lock );
  1984.             int i_audio = 0;
  1985.             int i_video = 0;
  1986.             int i;
  1988.             if( !p_item->i_es )
  1989.                 i_video = i_audio = 1;
  1990.             else
  1991.                 for( i = 0; i < p_item->i_es ; i++ )
  1992.                 {
  1993.                     i_audio += ( p_item->es[i]->i_cat == AUDIO_ES );
  1994.                     i_video += ( p_item->es[i]->i_cat == VIDEO_ES );
  1995.                 }
  1997.             int l = 0;
  1999. #define SHOW_ACS(x,c) 
  2000.     if(l >= p_sys->i_box_start && l - p_sys->i_box_start < p_sys->i_box_lines) 
  2001.         mvaddch( p_sys->i_box_y - p_sys->i_box_start + l, x, c )
  2003.             /* Input */
  2004.             if( p_sys->b_color ) wcolor_set( p_sys->w, C_CATEGORY, NULL );
  2005.             MainBoxWrite( p_intf, l, 1, _("+-[Incoming]"));
  2006.             SHOW_ACS( 1, ACS_ULCORNER );  SHOW_ACS( 2, ACS_HLINE ); l++;
  2007.             if( p_sys->b_color ) wcolor_set( p_sys->w, C_DEFAULT, NULL );
  2008.             MainBoxWrite( p_intf, l, 1, _("| input bytes read : %8.0f kB"),
  2009.                     (float)(p_item->p_stats->i_read_bytes)/1000 );
  2010.             SHOW_ACS( 1, ACS_VLINE ); l++;
  2011.             MainBoxWrite( p_intf, l, 1, _("| input bitrate    :   %6.0f kb/s"),
  2012.                     (float)(p_item->p_stats->f_input_bitrate)*8000 );
  2013.             MainBoxWrite( p_intf, l, 1, _("| demux bytes read : %8.0f kB"),
  2014.                     (float)(p_item->p_stats->i_demux_read_bytes)/1000 );
  2015.             SHOW_ACS( 1, ACS_VLINE ); l++;
  2016.             MainBoxWrite( p_intf, l, 1, _("| demux bitrate    :   %6.0f kb/s"),
  2017.                     (float)(p_item->p_stats->f_demux_bitrate)*8000 );
  2018.             SHOW_ACS( 1, ACS_VLINE ); l++;
  2019.             DrawEmptyLine( p_sys->w, p_sys->i_box_y + l - p_sys->i_box_start, 1, COLS - 2 );
  2020.             SHOW_ACS( 1, ACS_VLINE ); l++;
  2022.             /* Video */
  2023.             if( i_video )
  2024.             {
  2025.                 if( p_sys->b_color ) wcolor_set( p_sys->w, C_CATEGORY, NULL );
  2026.                 MainBoxWrite( p_intf, l, 1, _("+-[Video Decoding]"));
  2027.                 SHOW_ACS( 1, ACS_LTEE );  SHOW_ACS( 2, ACS_HLINE ); l++;
  2028.                 if( p_sys->b_color ) wcolor_set( p_sys->w, C_DEFAULT, NULL );
  2029.                 MainBoxWrite( p_intf, l, 1, _("| video decoded    :    %5i"),
  2030.                         p_item->p_stats->i_decoded_video );
  2031.                 SHOW_ACS( 1, ACS_VLINE ); l++;
  2032.                 MainBoxWrite( p_intf, l, 1, _("| frames displayed :    %5i"),
  2033.                         p_item->p_stats->i_displayed_pictures );
  2034.                 SHOW_ACS( 1, ACS_VLINE ); l++;
  2035.                 MainBoxWrite( p_intf, l, 1, _("| frames lost      :    %5i"),
  2036.                         p_item->p_stats->i_lost_pictures );
  2037.                 SHOW_ACS( 1, ACS_VLINE ); l++;
  2038.                 DrawEmptyLine( p_sys->w, p_sys->i_box_y + l - p_sys->i_box_start, 1, COLS - 2 );
  2039.                 SHOW_ACS( 1, ACS_VLINE ); l++;
  2040.             }
  2041.             /* Audio*/
  2042.             if( i_audio )
  2043.             {
  2044.                 if( p_sys->b_color ) wcolor_set( p_sys->w, C_CATEGORY, NULL );
  2045.                 MainBoxWrite( p_intf, l, 1, _("+-[Audio Decoding]"));
  2046.                 SHOW_ACS( 1, ACS_LTEE );  SHOW_ACS( 2, ACS_HLINE ); l++;
  2047.                 if( p_sys->b_color ) wcolor_set( p_sys->w, C_DEFAULT, NULL );
  2048.                 MainBoxWrite( p_intf, l, 1, _("| audio decoded    :    %5i"),
  2049.                         p_item->p_stats->i_decoded_audio );
  2050.                 SHOW_ACS( 1, ACS_VLINE ); l++;
  2051.                 MainBoxWrite( p_intf, l, 1, _("| buffers played   :    %5i"),
  2052.                         p_item->p_stats->i_played_abuffers );
  2053.                 SHOW_ACS( 1, ACS_VLINE ); l++;
  2054.                 MainBoxWrite( p_intf, l, 1, _("| buffers lost     :    %5i"),
  2055.                         p_item->p_stats->i_lost_abuffers );
  2056.                 SHOW_ACS( 1, ACS_VLINE ); l++;
  2057.                 DrawEmptyLine( p_sys->w, p_sys->i_box_y + l - p_sys->i_box_start, 1, COLS - 2 );
  2058.                 SHOW_ACS( 1, ACS_VLINE ); l++;
  2059.             }
  2060.             /* Sout */
  2061.             if( p_sys->b_color ) wcolor_set( p_sys->w, C_CATEGORY, NULL );
  2062.             MainBoxWrite( p_intf, l, 1, _("+-[Streaming]"));
  2063.             SHOW_ACS( 1, ACS_LTEE );  SHOW_ACS( 2, ACS_HLINE ); l++;
  2064.             if( p_sys->b_color ) wcolor_set( p_sys->w, C_DEFAULT, NULL );
  2065.             MainBoxWrite( p_intf, l, 1, _("| packets sent     :    %5i"), p_item->p_stats->i_sent_packets );
  2066.             SHOW_ACS( 1, ACS_VLINE ); l++;
  2067.             MainBoxWrite( p_intf, l, 1, _("| bytes sent       : %8.0f kB"),
  2068.                     (float)(p_item->p_stats->i_sent_bytes)/1000 );
  2069.             SHOW_ACS( 1, ACS_VLINE ); l++;
  2070.             MainBoxWrite( p_intf, l, 1, _("\ sending bitrate  :   %6.0f kb/s"),
  2071.                     (float)(p_item->p_stats->f_send_bitrate*8)*1000 );
  2072.             SHOW_ACS( 1, ACS_LLCORNER ); l++;
  2073.             if( p_sys->b_color ) wcolor_set( p_sys->w, C_DEFAULT, NULL );
  2075. #undef SHOW_ACS
  2077.             p_sys->i_box_lines_total = l;
  2078.             if( p_sys->i_box_start >= p_sys->i_box_lines_total )
  2079.                 p_sys->i_box_start = p_sys->i_box_lines_total - 1;
  2081.             if( l - p_sys->i_box_start < p_sys->i_box_lines )
  2082.                 y += l - p_sys->i_box_start;
  2083.             else
  2084.                 y += p_sys->i_box_lines;
  2086.             vlc_mutex_unlock( &p_item->p_stats->lock );
  2087.             vlc_mutex_unlock( &p_item->lock );
  2089.         }
  2090.     }
  2091.     else if( p_sys->i_box_type == BOX_PLAYLIST ||
  2092.                p_sys->i_box_type == BOX_SEARCH ||
  2093.                p_sys->i_box_type == BOX_OPEN   )
  2094.     {
  2095.         /* Playlist box */
  2096.         int        i_start, i_stop, i_max = p_sys->i_plist_entries;
  2097.         int        i_item;
  2098.         char       *psz_title;
  2100.         switch( p_sys->i_current_view )
  2101.         {
  2102.             case VIEW_ONELEVEL:
  2103.                 psz_title = strdup( _(" Playlist (All, one level) ") );
  2104.                 break;
  2105.             case VIEW_CATEGORY:
  2106.                 psz_title = strdup( _(" Playlist (By category) ") );
  2107.                 break;
  2108.             default:
  2109.                 psz_title = strdup( _(" Playlist (Manually added) ") );
  2110.         }
  2112.         DrawBox( p_sys->w, y++, 0, h, COLS, psz_title, p_sys->b_color );
  2113.         free( psz_title );
  2115.         if( p_sys->b_need_update || p_sys->pp_plist == NULL )
  2116.         {
  2117.             PlaylistRebuild( p_intf );
  2118.         }
  2119.         if( p_sys->b_box_plidx_follow )
  2120.         {
  2121.             FindIndex( p_intf, p_playlist );
  2122.         }
  2124.         if( p_sys->i_box_plidx < 0 ) p_sys->i_box_plidx = 0;
  2125.         if( p_sys->i_box_plidx < 0 ) p_sys->i_box_plidx = 0;
  2126.         if( p_sys->i_box_plidx >= i_max ) p_sys->i_box_plidx = i_max - 1;
  2128.         if( p_sys->i_box_plidx < (h - 2)/2 )
  2129.         {
  2130.             i_start = 0;
  2131.             i_stop = h - 2;
  2132.         }
  2133.         else if( i_max - p_sys->i_box_plidx > (h - 2)/2 )
  2134.         {
  2135.             i_start = p_sys->i_box_plidx - (h - 2)/2;
  2136.             i_stop = i_start + h - 2;
  2137.         }
  2138.         else
  2139.         {
  2140.             i_stop = i_max;
  2141.             i_start = i_max - (h - 2);
  2142.         }
  2143.         if( i_start < 0 )
  2144.         {
  2145.             i_start = 0;
  2146.         }
  2147.         if( i_stop > i_max )
  2148.         {
  2149.             i_stop = i_max;
  2150.         }
  2152.         for( i_item = i_start; i_item < i_stop; i_item++ )
  2153.         {
  2154.             bool b_selected = ( p_sys->i_box_plidx == i_item );
  2155.             playlist_item_t *p_item = p_sys->pp_plist[i_item]->p_item;
  2156.             playlist_item_t *p_node = p_sys->p_node;
  2157.             int c = ' ';
  2158.             input_thread_t *p_input2 = playlist_CurrentInput( p_playlist );
  2160.             PL_LOCK;
  2161.             if( ( p_node && p_item->p_input == p_node->p_input ) ||
  2162.                         ( !p_node && p_input2 &&
  2163.                           p_item->p_input == playlist_CurrentPlayingItem(p_playlist)->p_input ) )
  2164.                 c = '*';
  2165.             else if( p_item == p_node || ( p_item != p_node &&
  2166.                         PlaylistIsPlaying( p_playlist, p_item ) ) )
  2167.                 c = '>';
  2168.             PL_UNLOCK;
  2170.             if( p_input2 )
  2171.                 vlc_object_release( p_input2 );
  2173.             if( y >= y_end ) break;
  2174.             if( b_selected )
  2175.             {
  2176.                 attrset( A_REVERSE );
  2177.             }
  2178.             if( p_sys->b_color )
  2179.                 wcolor_set( p_sys->w, i_item % 3 + C_PLAYLIST_1, NULL );
  2180.             mvnprintw( y++, 1, COLS - 2, "%c%s", c,
  2181.                        p_sys->pp_plist[i_item]->psz_display );
  2182.             if( p_sys->b_color )
  2183.                 wcolor_set( p_sys->w, C_DEFAULT, NULL );
  2184.             if( b_selected )
  2185.             {
  2186.                 attroff( A_REVERSE );
  2187.             }
  2188.         }
  2190.     }
  2191.     else
  2192.     {
  2193.         y++;
  2194.     }
  2195.     if( p_sys->i_box_type == BOX_SEARCH )
  2196.     {
  2197.         DrawEmptyLine( p_sys->w, 7, 1, COLS-2 );
  2198.         if( p_sys->psz_search_chain )
  2199.         {
  2200.             if( strlen( p_sys->psz_search_chain ) == 0 &&
  2201.                 p_sys->psz_old_search != NULL )
  2202.             {
  2203.                 /* Searching next entry */
  2204.                 mvnprintw( 7, 1, COLS-2, _("Find: %s"), p_sys->psz_old_search );
  2205.             }
  2206.             else
  2207.             {
  2208.                 mvnprintw( 7, 1, COLS-2, _("Find: %s"), p_sys->psz_search_chain );
  2209.             }
  2210.         }
  2211.     }
  2212.     if( p_sys->i_box_type == BOX_OPEN )
  2213.     {
  2214.         if( p_sys->psz_open_chain )
  2215.         {
  2216.             DrawEmptyLine( p_sys->w, 7, 1, COLS-2 );
  2217.             mvnprintw( 7, 1, COLS-2, _("Open: %s"), p_sys->psz_open_chain );
  2218.         }
  2219.     }
  2221.     while( y < y_end )
  2222.     {
  2223.         DrawEmptyLine( p_sys->w, y++, 1, COLS - 2 );
  2224.     }
  2226.     refresh();
  2228.     *t_last_refresh = time( 0 );
  2229.     pl_Release( p_intf );
  2230. }
  2232. static playlist_item_t *PlaylistGetRoot( intf_thread_t *p_intf )
  2233. {
  2234.     intf_sys_t *p_sys = p_intf->p_sys;
  2235.     playlist_t *p_playlist = pl_Hold( p_intf );
  2236.     playlist_item_t *p_item;
  2238.     switch( p_sys->i_current_view )
  2239.     {
  2240.         case VIEW_CATEGORY:
  2241.             p_item = p_playlist->p_root_category;
  2242.             break;
  2243.         default:
  2244.             p_item = p_playlist->p_root_onelevel;
  2245.     }
  2246.     pl_Release( p_intf );
  2247.     return p_item;
  2248. }
  2250. static void PlaylistRebuild( intf_thread_t *p_intf )
  2251. {
  2252.     intf_sys_t *p_sys = p_intf->p_sys;
  2253.     playlist_t *p_playlist = pl_Hold( p_intf );
  2255.     PL_LOCK;
  2257.     /* First clear the old one */
  2258.     PlaylistDestroy( p_intf );
  2260.     /* Build the new one */
  2261.     PlaylistAddNode( p_intf, PlaylistGetRoot( p_intf ), 0, "" );
  2263.     p_sys->b_need_update = false;
  2265.     PL_UNLOCK;
  2267.     pl_Release( p_intf );
  2268. }
  2270. static void PlaylistAddNode( intf_thread_t *p_intf, playlist_item_t *p_node,
  2271.                              int i, const char *c )
  2272. {
  2273.     intf_sys_t *p_sys = p_intf->p_sys;
  2274.     playlist_item_t *p_child;
  2275.     int k;
  2277.     for( k = 0; k < p_node->i_children; k++ )
  2278.     {
  2279.         char *psz_display;
  2280.         p_child = p_node->pp_children[k];
  2281.         char *psz_name = input_item_GetTitleFbName( p_child->p_input );
  2283.         if( c && *c )
  2284.         {
  2285.             if( asprintf( &psz_display, "%s%c-%s", c,
  2286.                     k == p_node->i_children - 1 ?  '`' : '|', psz_name ) == -1 )
  2287.                 return;
  2288.         }
  2289.         else
  2290.         {
  2291.             if( asprintf( &psz_display, " %s", psz_name ) == -1 )
  2292.                 return;
  2293.         }
  2294.         free( psz_name );
  2295.         struct pl_item_t *p_pl_item = malloc( sizeof( struct pl_item_t ) );
  2296.         if( !p_pl_item )
  2297.             return;
  2298.         p_pl_item->psz_display = psz_display;
  2299.         p_pl_item->p_item = p_child;
  2300.         INSERT_ELEM( p_sys->pp_plist, p_sys->i_plist_entries,
  2301.                      p_sys->i_plist_entries, p_pl_item );
  2302.         i++;
  2304.         if( p_child->i_children > 0 )
  2305.         {
  2306.             char *psz_tmp;
  2307.             if( asprintf( &psz_tmp, "%s%c ", c,
  2308.                      k == p_node->i_children - 1 ? ' ' : '|' ) == -1 )
  2309.                 return;
  2310.             PlaylistAddNode( p_intf, p_child, i,
  2311.                              strlen( c ) ? psz_tmp : " " );
  2312.             free( psz_tmp );
  2313.         }
  2314.     }
  2315. }
  2317. static int PlaylistChanged( vlc_object_t *p_this, const char *psz_variable,
  2318.                             vlc_value_t oval, vlc_value_t nval, void *param )
  2319. {
  2320.     VLC_UNUSED(p_this); VLC_UNUSED(psz_variable);
  2321.     VLC_UNUSED(oval); VLC_UNUSED(nval);
  2322.     intf_thread_t *p_intf = (intf_thread_t *)param;
  2323.     playlist_t *p_playlist = pl_Hold( p_intf );
  2324.     p_intf->p_sys->b_need_update = true;
  2325.     p_intf->p_sys->p_node = playlist_CurrentPlayingItem(p_playlist) ? playlist_CurrentPlayingItem(p_playlist)->p_parent : NULL;
  2326.     pl_Release( p_intf );
  2327.     return VLC_SUCCESS;
  2328. }
  2330. /* Playlist suxx */
  2331. /* This function have to be called with the playlist locked */
  2332. static inline bool PlaylistIsPlaying( playlist_t *p_playlist,
  2333.                                       playlist_item_t *p_item )
  2334. {
  2335.     playlist_item_t *p_played_item = playlist_CurrentPlayingItem( p_playlist );
  2336.     return( p_item != NULL && p_played_item != NULL &&
  2337.             p_item->p_input != NULL && p_played_item->p_input != NULL &&
  2338.             p_item->p_input->i_id == p_played_item->p_input->i_id );
  2339. }
  2341. static void FindIndex( intf_thread_t *p_intf, playlist_t *p_playlist )
  2342. {
  2343.     intf_sys_t *p_sys = p_intf->p_sys;
  2344.     int i;
  2346.     if( p_sys->i_box_plidx < p_sys->i_plist_entries && p_sys->i_box_plidx >= 0 )
  2347.     {
  2348.         playlist_item_t *p_item = p_sys->pp_plist[p_sys->i_box_plidx]->p_item;
  2349.         PL_LOCK;
  2350.         if( ( p_item->i_children == 0 && p_item == p_sys->p_node ) ||
  2351.                 PlaylistIsPlaying( p_playlist, p_item ) )
  2352.         {
  2353.             PL_UNLOCK;
  2354.             return;
  2355.         }
  2356.     }
  2358.     for( i = 0; i < p_sys->i_plist_entries; i++ )
  2359.     {
  2360.         playlist_item_t *p_item = p_sys->pp_plist[i]->p_item;
  2361.         if( ( p_item->i_children == 0 && p_item == p_sys->p_node ) ||
  2362.                 PlaylistIsPlaying( p_playlist, p_sys->pp_plist[i]->p_item ) )
  2363.         {
  2364.             p_sys->i_box_plidx = i;
  2365.             break;
  2366.         }
  2367.     }
  2368.     PL_UNLOCK;
  2369. }
  2371. static void PlaylistDestroy( intf_thread_t *p_intf )
  2372. {
  2373.     intf_sys_t *p_sys = p_intf->p_sys;
  2375.     while( p_sys->i_plist_entries )
  2376.     {
  2377.         struct pl_item_t *p_pl_item = p_sys->pp_plist[0];
  2378.         free( p_pl_item->psz_display );
  2379.         REMOVE_ELEM( p_sys->pp_plist, p_sys->i_plist_entries, 0 );
  2380.         free( p_pl_item );
  2381.     }
  2382.     p_sys->pp_plist = NULL;
  2383. }
  2385. static void Eject( intf_thread_t *p_intf )
  2386. {
  2387.     char *psz_device = NULL, *psz_parser, *psz_name;
  2389.     /*
  2390.      * Get the active input
  2391.      * Determine whether we can eject a media, ie it's a DVD, VCD or CD-DA
  2392.      * If it's neither of these, then return
  2393.      */
  2395.     playlist_t * p_playlist = pl_Hold( p_intf );
  2396.     PL_LOCK;
  2398.     if( playlist_CurrentPlayingItem(p_playlist) == NULL )
  2399.     {
  2400.         PL_UNLOCK;
  2401.         pl_Release( p_intf );
  2402.         return;
  2403.     }
  2405.     psz_name = playlist_CurrentPlayingItem(p_playlist)->p_input->psz_name;
  2407.     if( psz_name )
  2408.     {
  2409.         if( !strncmp(psz_name, "dvd://", 4) )
  2410.         {
  2411.             switch( psz_name[strlen("dvd://")] )
  2412.             {
  2413.             case '':
  2414.             case '@':
  2415.                 psz_device = config_GetPsz( p_intf, "dvd" );
  2416.                 break;
  2417.             default:
  2418.                 /* Omit the first MRL-selector characters */
  2419.                 psz_device = strdup( psz_name + strlen("dvd://" ) );
  2420.                 break;
  2421.             }
  2422.         }
  2423.         else if( !strncmp(psz_name, VCD_MRL, strlen(VCD_MRL)) )
  2424.         {
  2425.             switch( psz_name[strlen(VCD_MRL)] )
  2426.             {
  2427.             case '':
  2428.             case '@':
  2429.                 psz_device = config_GetPsz( p_intf, VCD_MRL );
  2430.                 break;
  2431.             default:
  2432.                 /* Omit the beginning MRL-selector characters */
  2433.                 psz_device = strdup( psz_name + strlen(VCD_MRL) );
  2434.                 break;
  2435.             }
  2436.         }
  2437.         else if( !strncmp(psz_name, CDDA_MRL, strlen(CDDA_MRL) ) )
  2438.         {
  2439.             switch( psz_name[strlen(CDDA_MRL)] )
  2440.             {
  2441.             case '':
  2442.             case '@':
  2443.                 psz_device = config_GetPsz( p_intf, "cd-audio" );
  2444.                 break;
  2445.             default:
  2446.                 /* Omit the beginning MRL-selector characters */
  2447.                 psz_device = strdup( psz_name + strlen(CDDA_MRL) );
  2448.                 break;
  2449.             }
  2450.         }
  2451.         else
  2452.         {
  2453.             psz_device = strdup( psz_name );
  2454.         }
  2455.     }
  2457.     PL_UNLOCK;
  2459.     if( psz_device == NULL )
  2460.     {
  2461.         pl_Release( p_intf );
  2462.         return;
  2463.     }
  2465.     /* Remove what we have after @ */
  2466.     psz_parser = psz_device;
  2467.     for( psz_parser = psz_device ; *psz_parser ; psz_parser++ )
  2468.     {
  2469.         if( *psz_parser == '@' )
  2470.         {
  2471.             *psz_parser = '';
  2472.             break;
  2473.         }
  2474.     }
  2476.     /* If there's a stream playing, we aren't allowed to eject ! */
  2477.     if( p_intf->p_sys->p_input == NULL )
  2478.     {
  2479.         msg_Dbg( p_intf, "ejecting %s", psz_device );
  2481.         intf_Eject( p_intf, psz_device );
  2482.     }
  2484.     free( psz_device );
  2485.     pl_Release( p_intf );
  2486.     return;
  2487. }
  2489. static int comp_dir_entries( const void *pp_dir_entry1,
  2490.                              const void *pp_dir_entry2 )
  2491. {
  2492.     struct dir_entry_t *p_dir_entry1 = *(struct dir_entry_t**)pp_dir_entry1;
  2493.     struct dir_entry_t *p_dir_entry2 = *(struct dir_entry_t**)pp_dir_entry2;
  2494.     if ( p_dir_entry1->b_file == p_dir_entry2->b_file ) {
  2495.         return strcasecmp( p_dir_entry1->psz_path, p_dir_entry2->psz_path );
  2496.     }
  2497.     else
  2498.     {
  2499.         return ( p_dir_entry1->b_file ? 1 : -1 );
  2500.     }
  2501. }
  2503. static void ReadDir( intf_thread_t *p_intf )
  2504. {
  2505.     intf_sys_t *p_sys = p_intf->p_sys;
  2506.     DIR *p_current_dir;
  2507.     int i;
  2509.     if( p_sys->psz_current_dir && *p_sys->psz_current_dir )
  2510.     {
  2511.         char *psz_entry;
  2513.         /* Open the dir */
  2514.         p_current_dir = utf8_opendir( p_sys->psz_current_dir );
  2516.         if( p_current_dir == NULL )
  2517.         {
  2518.             /* something went bad, get out of here ! */
  2519.             msg_Warn( p_intf, "cannot open directory `%s' (%m)",
  2520.                       p_sys->psz_current_dir );
  2521.             return;
  2522.         }
  2524.         /* Clean the old shit */
  2525.         for( i = 0; i < p_sys->i_dir_entries; i++ )
  2526.         {
  2527.             struct dir_entry_t *p_dir_entry = p_sys->pp_dir_entries[i];
  2528.             free( p_dir_entry->psz_path );
  2529.             REMOVE_ELEM( p_sys->pp_dir_entries, p_sys->i_dir_entries, i );
  2530.             free( p_dir_entry );
  2531.         }
  2532.         p_sys->pp_dir_entries = NULL;
  2533.         p_sys->i_dir_entries = 0;
  2535.         /* while we still have entries in the directory */
  2536.         while( ( psz_entry = utf8_readdir( p_current_dir ) ) != NULL )
  2537.         {
  2538. #if defined( S_ISDIR )
  2539.             struct stat stat_data;
  2540. #endif
  2541.             struct dir_entry_t *p_dir_entry;
  2542.             char *psz_uri;
  2544.             if( p_sys->b_show_hidden_files == false &&
  2545.                 ( strlen( psz_entry ) && psz_entry[0] == '.' ) &&
  2546.                 strcmp( psz_entry, ".." ) )
  2547.             {
  2548.                 free( psz_entry );
  2549.                 continue;
  2550.             }
  2552.             if( asprintf( &psz_uri, "%s/%s", p_sys->psz_current_dir,
  2553.                         psz_entry ) == -1)
  2554.             {
  2555.                 free( psz_entry );
  2556.                 continue;
  2557.             }
  2559.             if( !( p_dir_entry = malloc( sizeof( struct dir_entry_t) ) ) )
  2560.             {
  2561.                 free( psz_uri );
  2562.                 free( psz_entry );
  2563.                 continue;
  2564.             }
  2566. #if defined( S_ISDIR )
  2567.             if( !utf8_stat( psz_uri, &stat_data )
  2568.              && S_ISDIR(stat_data.st_mode) )
  2569. /*#elif defined( DT_DIR )
  2570.             if( p_dir_content->d_type & DT_DIR )*/
  2571. #else
  2572.             if( 0 )
  2573. #endif
  2574.             {
  2575.                 p_dir_entry->psz_path = strdup( psz_entry );
  2576.                 p_dir_entry->b_file = false;
  2577.                 INSERT_ELEM( p_sys->pp_dir_entries, p_sys->i_dir_entries,
  2578.                      p_sys->i_dir_entries, p_dir_entry );
  2579.             }
  2580.             else
  2581.             {
  2582.                 p_dir_entry->psz_path = strdup( psz_entry );
  2583.                 p_dir_entry->b_file = true;
  2584.                 INSERT_ELEM( p_sys->pp_dir_entries, p_sys->i_dir_entries,
  2585.                      p_sys->i_dir_entries, p_dir_entry );
  2586.             }
  2588.             free( psz_uri );
  2589.             free( psz_entry );
  2590.         }
  2592.         /* Sort */
  2593.         qsort( p_sys->pp_dir_entries, p_sys->i_dir_entries,
  2594.                sizeof(struct dir_entry_t*), &comp_dir_entries );
  2596.         closedir( p_current_dir );
  2597.         return;
  2598.     }
  2599.     else
  2600.     {
  2601.         msg_Dbg( p_intf, "no current dir set" );
  2602.         return;
  2603.     }
  2604. }
  2606. static void PlayPause( intf_thread_t *p_intf )
  2607. {
  2608.     input_thread_t *p_input = p_intf->p_sys->p_input;
  2609.     playlist_t *p_playlist = pl_Hold( p_intf );
  2610.     vlc_value_t val;
  2612.     if( p_input )
  2613.     {
  2614.         var_Get( p_input, "state", &val );
  2615.         if( val.i_int != PAUSE_S )
  2616.         {
  2617.             val.i_int = PAUSE_S;
  2618.         }
  2619.         else
  2620.         {
  2621.             val.i_int = PLAYING_S;
  2622.         }
  2623.         var_Set( p_input, "state", val );
  2624.     }
  2625.     else
  2626.         playlist_Play( p_playlist );
  2628.     pl_Release( p_intf );
  2629. }
  2631. /****************************************************************************
  2632.  *
  2633.  ****************************************************************************/
  2634. static void DrawBox( WINDOW *win, int y, int x, int h, int w, const char *title, bool b_color )
  2635. {
  2636.     int i;
  2637.     int i_len;
  2639.     if( w > 3 && h > 2 )
  2640.     {
  2641.         if( b_color )
  2642.             wcolor_set( win, C_BOX, NULL );
  2643.         if( title == NULL ) title = "";
  2644.         i_len = strlen( title );
  2646.         if( i_len > w - 2 ) i_len = w - 2;
  2648.         mvwaddch( win, y, x,    ACS_ULCORNER );
  2649.         mvwhline( win, y, x+1,  ACS_HLINE, ( w-i_len-2)/2 );
  2650.         mvwprintw( win,y, x+1+(w-i_len-2)/2, "%s", title );
  2651.         mvwhline( win, y, x+(w-i_len)/2+i_len,  ACS_HLINE, w - 1 - ((w-i_len)/2+i_len) );
  2652.         mvwaddch( win, y, x+w-1,ACS_URCORNER );
  2654.         for( i = 0; i < h-2; i++ )
  2655.         {
  2656.             mvwaddch( win, y+i+1, x,     ACS_VLINE );
  2657.             mvwaddch( win, y+i+1, x+w-1, ACS_VLINE );
  2658.         }
  2660.         mvwaddch( win, y+h-1, x,     ACS_LLCORNER );
  2661.         mvwhline( win, y+h-1, x+1,   ACS_HLINE, w - 2 );
  2662.         mvwaddch( win, y+h-1, x+w-1, ACS_LRCORNER );
  2663.         if( b_color )
  2664.             wcolor_set( win, C_DEFAULT, NULL );
  2665.     }
  2666. }
  2668. static void DrawEmptyLine( WINDOW *win, int y, int x, int w )
  2669. {
  2670.     if( w > 0 )
  2671.     {
  2672.         mvwhline( win, y, x, ' ', w );
  2673.     }
  2674. }
  2676. static void DrawLine( WINDOW *win, int y, int x, int w )
  2677. {
  2678.     if( w > 0 )
  2679.     {
  2680.         attrset( A_REVERSE );
  2681.         mvwhline( win, y, x, ' ', w );
  2682.         attroff( A_REVERSE );
  2683.     }
  2684. }