ncurses.c

VLC Player Source Code

        case '<':
            if( p_sys->p_input )
            {
                val.b_bool = true;
                var_Set( p_sys->p_input, "prev-chapter", val );
            }
            ReturnTrue;

        case '>':
            if( p_sys->p_input )
            {
                val.b_bool = true;
                var_Set( p_sys->p_input, "next-chapter", val );
            }
            ReturnTrue;

        case 'p':
            playlist_Prev( p_playlist );
            clear();
            ReturnTrue;

        case 'n':
            playlist_Next( p_playlist );
            clear();
            ReturnTrue;

        case 'a':
            aout_VolumeUp( p_intf, 1, NULL );
            clear();
            ReturnTrue;

        case 'z':
            aout_VolumeDown( p_intf, 1, NULL );
            clear();
            ReturnTrue;

        /*
         * ^l should clear and redraw the screen
         */
        case KEY_CLEAR:
        case 0x0c:          /* ^l */
            clear();
            ReturnTrue;

        default:
            ReturnFalse;
    }
#undef ReturnFalse
#undef ReturnTrue
}

static void ManageSlider( intf_thread_t *p_intf )
{
    intf_sys_t     *p_sys = p_intf->p_sys;
    input_thread_t *p_input = p_sys->p_input;
    vlc_value_t     val;

    if( p_input == NULL )
    {
        return;
    }
    var_Get( p_input, "state", &val );
    if( val.i_int != PLAYING_S )
    {
        return;
    }

    var_Get( p_input, "position", &val );
    if( p_sys->f_slider == p_sys->f_slider_old )
    {
        p_sys->f_slider =
        p_sys->f_slider_old = 100 * val.f_float;
    }
    else
    {
        p_sys->f_slider_old = p_sys->f_slider;

        val.f_float = p_sys->f_slider / 100.0;
        var_Set( p_input, "position", val );
    }
}

static void SearchPlaylist( intf_thread_t *p_intf, char *psz_searchstring )
{
    int i_max;
    int i_first = 0 ;
    int i_item = -1;
    intf_sys_t *p_sys = p_intf->p_sys;

    if( p_sys->i_before_search >= 0 )
    {
        i_first = p_sys->i_before_search;
    }

    if( ( ! psz_searchstring ) ||  strlen( psz_searchstring ) <= 0 )
    {
        p_sys->i_box_plidx = p_sys->i_before_search;
        return;
    }

    i_max = p_sys->i_plist_entries;

    i_item = SubSearchPlaylist( p_intf, psz_searchstring, i_first + 1, i_max );
    if( i_item < 0 )
    {
        i_item = SubSearchPlaylist( p_intf, psz_searchstring, 0, i_first );
    }

    if( i_item < 0 || i_item >= i_max ) return;

    p_sys->i_box_plidx = i_item;
}

static int SubSearchPlaylist( intf_thread_t *p_intf, char *psz_searchstring,
                              int i_start, int i_stop )
{
    intf_sys_t *p_sys = p_intf->p_sys;
    int i, i_item = -1;

    for( i = i_start + 1; i < i_stop; i++ )
    {
        if( strcasestr( p_sys->pp_plist[i]->psz_display,
                        psz_searchstring ) != NULL )
        {
            i_item = i;
            break;
        }
    }

    return i_item;
}


static void mvnprintw( int y, int x, int w, const char *p_fmt, ... )
{
    va_list  vl_args;
    char    *p_buf = NULL;
    int      i_len;

    if( w <= 0 )
        return;

    va_start( vl_args, p_fmt );
    if( vasprintf( &p_buf, p_fmt, vl_args ) == -1 )
        return;
    va_end( vl_args );

    i_len = strlen( p_buf );

#ifdef HAVE_NCURSESW
    wchar_t psz_wide[i_len + 1];

    EnsureUTF8( p_buf );
    size_t i_char_len = mbstowcs( psz_wide, p_buf, i_len );

    size_t i_width; /* number of columns */

    if( i_char_len == (size_t)-1 )
    /* an invalid character was encountered */
    {
        free( p_buf );
        return;
    }
    else
    {
        i_width = wcswidth( psz_wide, i_char_len );
        if( i_width == (size_t)-1 )
        {
            /* a non printable character was encountered */
            unsigned int i;
            int i_cwidth;
            i_width = 0;
            for( i = 0 ; i < i_char_len ; i++ )
            {
                i_cwidth = wcwidth( psz_wide[i] );
                if( i_cwidth != -1 )
                    i_width += i_cwidth;
            }
        }
    }
    if( i_width > (size_t)w )
    {
        int i_total_width = 0;
        int i = 0;
        while( i_total_width < w )
        {
            i_total_width += wcwidth( psz_wide[i] );
            if( w > 7 && i_total_width >= w/2 )
            {
                psz_wide[i  ] = '.';
                psz_wide[i+1] = '.';
                i_total_width -= wcwidth( psz_wide[i] ) - 2;
                if( i > 0 )
                {
                    /* we require this check only if at least one character
                     * 4 or more columns wide exists (which i doubt) */
                    psz_wide[i-1] = '.';
                    i_total_width -= wcwidth( psz_wide[i-1] ) - 1;
                }

                /* find the widest string */
                int j, i_2nd_width = 0;
                for( j = i_char_len - 1; i_2nd_width < w - i_total_width; j-- )
                    i_2nd_width += wcwidth( psz_wide[j] );

                /* we already have i_total_width columns filled, and we can't
                 * have more than w columns */
                if( i_2nd_width > w - i_total_width )
                    j++;

                wmemmove( &psz_wide[i+2], &psz_wide[j+1], i_char_len - j - 1 );
                psz_wide[i + 2 + i_char_len - j - 1] = '\0';
                break;
            }
            i++;
        }
        if( w <= 7 ) /* we don't add the '...' else we lose too much chars */
            psz_wide[i] = '\0';

        size_t i_wlen = wcslen( psz_wide ) * 6 + 1; /* worst case */
        char psz_ellipsized[i_wlen];
        wcstombs( psz_ellipsized, psz_wide, i_wlen );
        mvprintw( y, x, "%s", psz_ellipsized );
    }
    else
    {
        mvprintw( y, x, "%s", p_buf );
        mvhline( y, x + i_width, ' ', w - i_width );
    }

#else
    if( i_len > w )
    {
        int i_cut = i_len - w;
        int x1 = i_len/2 - i_cut/2;
        int x2 = x1 + i_cut;

        if( i_len > x2 )
        {
            memmove( &p_buf[x1], &p_buf[x2], i_len - x2 );
        }
        p_buf[w] = '\0';
        if( w > 7 )
        {
            p_buf[w/2-1] = '.';
            p_buf[w/2  ] = '.';
            p_buf[w/2+1] = '.';
        }
        char *psz_local = ToLocale( p_buf );
        mvprintw( y, x, "%s", psz_local );
        LocaleFree( p_buf );
    }
    else
    {
        char *psz_local = ToLocale( p_buf );
        mvprintw( y, x, "%s", psz_local );
        LocaleFree( p_buf );
        mvhline( y, x + i_len, ' ', w - i_len );
    }
#endif
    free( p_buf );
}
static void MainBoxWrite( intf_thread_t *p_intf, int l, int x, const char *p_fmt, ... )
{
    intf_sys_t     *p_sys = p_intf->p_sys;

    va_list  vl_args;
    char    *p_buf = NULL;

    if( l < p_sys->i_box_start || l - p_sys->i_box_start >= p_sys->i_box_lines )
    {
        return;
    }

    va_start( vl_args, p_fmt );
    if( vasprintf( &p_buf, p_fmt, vl_args ) == -1 )
        return;
    va_end( vl_args );

    mvnprintw( p_sys->i_box_y + l - p_sys->i_box_start, x, COLS - x - 1, "%s", p_buf );
    free( p_buf );
}

static void DumpObject( intf_thread_t *p_intf, int *l, vlc_object_t *p_obj, int i_level )
{
    if( p_obj->psz_object_name )
        MainBoxWrite( p_intf, (*l)++, 1 + 2 * i_level, "%s \"%s\" (%d)",
                p_obj->psz_object_type, p_obj->psz_object_name,
                p_obj->i_object_id );
    else
        MainBoxWrite( p_intf, (*l)++, 1 + 2 * i_level, "%s (%d)",
                p_obj->psz_object_type, p_obj->i_object_id );

    vlc_list_t *list = vlc_list_children( p_obj );
    for( int i = 0; i < list->i_count ; i++ )
    {
        MainBoxWrite( p_intf, *l, 1 + 2 * i_level,
            i == list->i_count - 1 ? "`-" : "|-" );
        DumpObject( p_intf, l, list->p_values[i].p_object, i_level + 1 );
    }
    vlc_list_release( list );
}

static void Redraw( intf_thread_t *p_intf, time_t *t_last_refresh )
{
    intf_sys_t     *p_sys = p_intf->p_sys;
    input_thread_t *p_input = p_sys->p_input;
    playlist_t     *p_playlist = pl_Yield( p_intf );
    int y = 0;
    int h;
    int y_end;

    /* Title */
    attrset( A_REVERSE );
    int i_len = strlen( "VLC media player "PACKAGE_VERSION );
    int mid = ( COLS - i_len ) / 2;
    if( mid < 0 )
        mid = 0;
    int i_size = ( COLS > i_len + 1 ) ? COLS : i_len + 1;
    char psz_title[i_size];
    memset( psz_title, ' ', mid );
    if( p_sys->b_color )
        wcolor_set( p_sys->w, C_TITLE, NULL );
    snprintf( &psz_title[mid], i_size, "VLC media player "PACKAGE_VERSION );
    mvnprintw( y, 0, COLS, "%s", psz_title );
    attroff( A_REVERSE );
    y += 2;

    if( p_sys->b_color )
        wcolor_set( p_sys->w, C_STATUS, NULL );

    /* Infos */
    char *psz_state;
    if( asprintf( &psz_state, "%s%s%s",
            var_GetBool( p_playlist, "repeat" ) ? _( "[Repeat] " ) : "",
            var_GetBool( p_playlist, "random" ) ? _( "[Random] " ) : "",
            var_GetBool( p_playlist, "loop" ) ? _( "[Loop]" ) : "" ) == -1 )
        psz_state = NULL;

    if( p_input && !p_input->b_dead )
    {
        char buf1[MSTRTIME_MAX_SIZE];
        char buf2[MSTRTIME_MAX_SIZE];
        vlc_value_t val;
        vlc_value_t val_list;

        /* Source */
        char *psz_uri = input_item_GetURI( input_GetItem( p_input ) );
        mvnprintw( y++, 0, COLS, _(" Source   : %s"), psz_uri );
        free( psz_uri );

        /* State */
        var_Get( p_input, "state", &val );
        if( val.i_int == PLAYING_S )
        {
            mvnprintw( y++, 0, COLS, _(" State    : Playing %s"), psz_state );
        }
        else if( val.i_int == STOP_S )
        {
            mvnprintw( y++, 0, COLS, _(" State    : Stopped %s"), psz_state );
        }
        else if( val.i_int == OPENING_S )
        {
            mvnprintw( y++, 0, COLS, _(" State    : Opening/Connecting %s"), psz_state );
        }
        else if( val.i_int == BUFFERING_S )
        {
            mvnprintw( y++, 0, COLS, _(" State    : Buffering %s"), psz_state );
        }
        else if( val.i_int == PAUSE_S )
        {
            mvnprintw( y++, 0, COLS, _(" State    : Paused %s"), psz_state );
        }

        if( val.i_int != INIT_S && val.i_int != END_S )
        {
            audio_volume_t i_volume;

            /* Position */
            var_Get( p_input, "time", &val );
            msecstotimestr( buf1, val.i_time / 1000 );

            var_Get( p_input, "length", &val );
            msecstotimestr( buf2, val.i_time / 1000 );

            mvnprintw( y++, 0, COLS, _(" Position : %s/%s (%.2f%%)"), buf1, buf2, p_sys->f_slider );

            /* Volume */
            aout_VolumeGet( p_intf, &i_volume );
            mvnprintw( y++, 0, COLS, _(" Volume   : %i%%"), i_volume*200/AOUT_VOLUME_MAX );

            /* Title */
            if( !var_Get( p_input, "title", &val ) )
            {
                var_Change( p_input, "title", VLC_VAR_GETCHOICES, &val_list, NULL );
                if( val_list.p_list->i_count > 0 )
                {
                    mvnprintw( y++, 0, COLS, _(" Title    : %d/%d"), val.i_int, val_list.p_list->i_count );
                }
                var_Change( p_input, "title", VLC_VAR_FREELIST, &val_list, NULL );
            }