intf.m

video linux conference

            b_seekable = val.b_bool;

            /* check wether slow/fast motion is possible*/
            b_control = p_input->input.b_can_pace_control;

            /* chapters & titles */
            //b_chapters = p_input->stream.i_area_nb > 1;
        }

        [o_btn_stop setEnabled: b_input];
        [o_btn_ff setEnabled: b_seekable];
        [o_btn_rewind setEnabled: b_seekable];
        [o_btn_prev setEnabled: (b_plmul || b_chapters)];
        [o_btn_next setEnabled: (b_plmul || b_chapters)];

        [o_timeslider setFloatValue: 0.0];
        [o_timeslider setEnabled: b_seekable];
        [o_timefield setStringValue: @"0:00:00"];

        p_intf->p_sys->b_intf_update = VLC_FALSE;
    }

    if( p_intf->p_sys->b_playmode_update )
    {
        [o_playlist playModeUpdated];
        p_intf->p_sys->b_playmode_update = VLC_FALSE;
    }
    if( p_intf->p_sys->b_playlist_update )
    {
        [o_playlist playlistUpdated];
        p_intf->p_sys->b_playlist_update = VLC_FALSE;
    }

    if( p_intf->p_sys->b_fullscreen_update )
    {
        playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
                                                   FIND_ANYWHERE );
        var_Get( p_playlist, "fullscreen", &val );
        [o_btn_fullscreen setState: val.b_bool];
        vlc_object_release( p_playlist );

        p_intf->p_sys->b_fullscreen_update = VLC_FALSE;
    }

    if( p_input && !p_input->b_die )
    {
        vlc_value_t val;

        if( p_intf->p_sys->b_current_title_update )
        {
            NSString *o_temp;
            vout_thread_t *p_vout;
            playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
                                                       FIND_ANYWHERE );

            if( p_playlist == NULL || p_playlist->status.p_item == NULL )
            {
                return;
            }
            o_temp = [NSString stringWithUTF8String:
                p_playlist->status.p_item->input.psz_name];
            if( o_temp == NULL )
                o_temp = [NSString stringWithCString:
                    p_playlist->status.p_item->input.psz_name];
            [self setScrollField: o_temp stopAfter:-1];

            p_vout = vlc_object_find( p_intf, VLC_OBJECT_VOUT,
                                                    FIND_ANYWHERE );
            if( p_vout != NULL )
            {
                id o_vout_wnd;
                NSEnumerator * o_enum = [[NSApp orderedWindows] objectEnumerator];

                while( ( o_vout_wnd = [o_enum nextObject] ) )
                {
                    if( [[o_vout_wnd className] isEqualToString: @"VLCWindow"] )
                    {
                        [o_vout_wnd updateTitle];
                    }
                }
                vlc_object_release( (vlc_object_t *)p_vout );
            }
            [o_playlist updateRowSelection];
            vlc_object_release( p_playlist );
            p_intf->p_sys->b_current_title_update = FALSE;
        }

        if( p_input && [o_timeslider isEnabled] )
        {
            /* Update the slider */
            vlc_value_t time;
            NSString * o_time;
            mtime_t i_seconds;
            vlc_value_t pos;
            float f_updated;

            var_Get( p_input, "position", &pos );
            f_updated = 10000. * pos.f_float;
            [o_timeslider setFloatValue: f_updated];

            var_Get( p_input, "time", &time );
            i_seconds = time.i_time / 1000000;

            o_time = [NSString stringWithFormat: @"%d:%02d:%02d",
                            (int) (i_seconds / (60 * 60)),
                            (int) (i_seconds / 60 % 60),
                            (int) (i_seconds % 60)];
            [o_timefield setStringValue: o_time];
        }
        
        if( p_intf->p_sys->b_volume_update )
        {
            NSString *o_text;
            o_text = [NSString stringWithFormat: _NS("Volume: %d"), i_lastShownVolume * 200 / AOUT_VOLUME_MAX];
            if( i_lastShownVolume != -1 )
            [self setScrollField:o_text stopAfter:1000000];

            [o_volumeslider setFloatValue: (float)i_lastShownVolume / AOUT_VOLUME_STEP];
            [o_volumeslider setEnabled: TRUE];
            p_intf->p_sys->b_mute = ( i_lastShownVolume == 0 );
            p_intf->p_sys->b_volume_update = FALSE;
        }

        /* Manage Playing status */
        var_Get( p_input, "state", &val );
        if( p_intf->p_sys->i_play_status != val.i_int )
        {
            p_intf->p_sys->i_play_status = val.i_int;
            [self playStatusUpdated: p_intf->p_sys->i_play_status];
        }
    }
    else
    {
        p_intf->p_sys->i_play_status = END_S;
        p_intf->p_sys->b_intf_update = VLC_TRUE;
        [self playStatusUpdated: p_intf->p_sys->i_play_status];
        [self setSubmenusEnabled: FALSE];
    }

#undef p_input

    [self updateMessageArray];

    if( (i_end_scroll != -1) && (mdate() > i_end_scroll) )
        [self resetScrollField];


    [NSTimer scheduledTimerWithTimeInterval: 0.3
        target: self selector: @selector(manageIntf:)
        userInfo: nil repeats: FALSE];
}

- (void)setupMenus
{
#define p_input p_intf->p_sys->p_input
    if( p_input != NULL )
    {
        [o_controls setupVarMenuItem: o_mi_program target: (vlc_object_t *)p_input
            var: "program" selector: @selector(toggleVar:)];

        [o_controls setupVarMenuItem: o_mi_title target: (vlc_object_t *)p_input
            var: "title" selector: @selector(toggleVar:)];

        [o_controls setupVarMenuItem: o_mi_chapter target: (vlc_object_t *)p_input
            var: "chapter" selector: @selector(toggleVar:)];

        [o_controls setupVarMenuItem: o_mi_audiotrack target: (vlc_object_t *)p_input
            var: "audio-es" selector: @selector(toggleVar:)];

        [o_controls setupVarMenuItem: o_mi_videotrack target: (vlc_object_t *)p_input
            var: "video-es" selector: @selector(toggleVar:)];

        [o_controls setupVarMenuItem: o_mi_subtitle target: (vlc_object_t *)p_input
            var: "spu-es" selector: @selector(toggleVar:)];

        aout_instance_t * p_aout = vlc_object_find( p_intf, VLC_OBJECT_AOUT,
                                                    FIND_ANYWHERE );
        if ( p_aout != NULL )
        {
            [o_controls setupVarMenuItem: o_mi_channels target: (vlc_object_t *)p_aout
                var: "audio-channels" selector: @selector(toggleVar:)];

            [o_controls setupVarMenuItem: o_mi_device target: (vlc_object_t *)p_aout
                var: "audio-device" selector: @selector(toggleVar:)];

            [o_controls setupVarMenuItem: o_mi_visual target: (vlc_object_t *)p_aout
                var: "visual" selector: @selector(toggleVar:)];
            vlc_object_release( (vlc_object_t *)p_aout );
        }

        vout_thread_t * p_vout = vlc_object_find( p_intf, VLC_OBJECT_VOUT,
                                                            FIND_ANYWHERE );

        if ( p_vout != NULL )
        {
            vlc_object_t * p_dec_obj;

            [o_controls setupVarMenuItem: o_mi_screen target: (vlc_object_t *)p_vout
                var: "video-device" selector: @selector(toggleVar:)];

            [o_controls setupVarMenuItem: o_mi_deinterlace target: (vlc_object_t *)p_vout
                var: "deinterlace" selector: @selector(toggleVar:)];

            p_dec_obj = (vlc_object_t *)vlc_object_find(
                                                 (vlc_object_t *)p_vout,
                                                 VLC_OBJECT_DECODER,
                                                 FIND_PARENT );
            if ( p_dec_obj != NULL )
            {
               [o_controls setupVarMenuItem: o_mi_ffmpeg_pp target:
                    (vlc_object_t *)p_dec_obj var:"ffmpeg-pp-q" selector:
                    @selector(toggleVar:)];

                vlc_object_release(p_dec_obj);
            }
            vlc_object_release( (vlc_object_t *)p_vout );
        }
    }
#undef p_input
}

- (void)setScrollField:(NSString *)o_string stopAfter:(int)timeout
{
    if( timeout != -1 )
        i_end_scroll = mdate() + timeout;
    else
        i_end_scroll = -1;
    [o_scrollfield setStringValue: o_string];
}

- (void)resetScrollField
{
    i_end_scroll = -1;
#define p_input p_intf->p_sys->p_input
    if( p_input && !p_input->b_die )
    {
        NSString *o_temp;
        playlist_t * p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
                                                   FIND_ANYWHERE );
        if( p_playlist == NULL )
        {
            return;
        }
        o_temp = [NSString stringWithUTF8String:
                  p_playlist->status.p_item->input.psz_name];
        if( o_temp == NULL )
            o_temp = [NSString stringWithCString:
                    p_playlist->status.p_item->input.psz_name];
        [self setScrollField: o_temp stopAfter:-1];
        vlc_object_release( p_playlist );
        return;
    }
#undef p_input
    [self setScrollField: _NS("VLC media player") stopAfter:-1];
}

- (void)updateMessageArray
{
    int i_start, i_stop;
    vlc_value_t quiet;

    vlc_mutex_lock( p_intf->p_sys->p_sub->p_lock );
    i_stop = *p_intf->p_sys->p_sub->pi_stop;
    vlc_mutex_unlock( p_intf->p_sys->p_sub->p_lock );

    if( p_intf->p_sys->p_sub->i_start != i_stop )
    {
        NSColor *o_white = [NSColor whiteColor];
        NSColor *o_red = [NSColor redColor];
        NSColor *o_yellow = [NSColor yellowColor];
        NSColor *o_gray = [NSColor grayColor];

        NSColor * pp_color[4] = { o_white, o_red, o_yellow, o_gray };
        static const char * ppsz_type[4] = { ": ", " error: ",
                                             " warning: ", " debug: " };

        for( i_start = p_intf->p_sys->p_sub->i_start;
             i_start != i_stop;
             i_start = (i_start+1) % VLC_MSG_QSIZE )
        {
            NSString *o_msg;
            NSDictionary *o_attr;
            NSAttributedString *o_msg_color;

            int i_type = p_intf->p_sys->p_sub->p_msg[i_start].i_type;

            [o_msg_lock lock];

            if( [o_msg_arr count] + 2 > 400 )
            {
                unsigned rid[] = { 0, 1 };
                [o_msg_arr removeObjectsFromIndices: (unsigned *)&rid
                           numIndices: sizeof(rid)/sizeof(rid[0])];
            }

            o_attr = [NSDictionary dictionaryWithObject: o_gray
                forKey: NSForegroundColorAttributeName];
            o_msg = [NSString stringWithFormat: @"%s%s",
                p_intf->p_sys->p_sub->p_msg[i_start].psz_module,
                ppsz_type[i_type]];
            o_msg_color = [[NSAttributedString alloc]
                initWithString: o_msg attributes: o_attr];
            [o_msg_arr addObject: [o_msg_color autorelease]];

            o_attr = [NSDictionary dictionaryWithObject: pp_color[i_type]
                forKey: NSForegroundColorAttributeName];
            o_msg = [NSString stringWithFormat: @"%s\n",
                p_intf->p_sys->p_sub->p_msg[i_start].psz_msg];
            o_msg_color = [[NSAttributedString alloc]
                initWithString: o_msg attributes: o_attr];
            [o_msg_arr addObject: [o_msg_color autorelease]];

            [o_msg_lock unlock];

            var_Get( p_intf->p_vlc, "verbose", &quiet );

            if( i_type == 1 && quiet.i_int > -1 )
            {
                NSString *o_my_msg = [NSString stringWithFormat: @"%s: %s\n",
                    p_intf->p_sys->p_sub->p_msg[i_start].psz_module,
                    p_intf->p_sys->p_sub->p_msg[i_start].psz_msg];

                NSRange s_r = NSMakeRange( [[o_err_msg string] length], 0 );
                [o_err_msg setEditable: YES];
                [o_err_msg setSelectedRange: s_r];
                [o_err_msg insertText: o_my_msg];

                [o_error makeKeyAndOrderFront: self];
                [o_err_msg setEditable: NO];
            }
        }

        vlc_mutex_lock( p_intf->p_sys->p_sub->p_lock );
        p_intf->p_sys->p_sub->i_start = i_start;
        vlc_mutex_unlock( p_intf->p_sys->p_sub->p_lock );
    }
}

- (void)playStatusUpdated:(int)i_status
{
    if( i_status == PLAYING_S )
    {
        [o_btn_play setImage: o_img_pause];
        [o_btn_play setAlternateImage: o_img_pause_pressed];
        [o_btn_play setToolTip: _NS("Pause")];
        [o_mi_play setTitle: _NS("Pause")];
        [o_dmi_play setTitle: _NS("Pause")];
    }
    else
    {
        [o_btn_play setImage: o_img_play];
        [o_btn_play setAlternateImage: o_img_play_pressed];
        [o_btn_play setToolTip: _NS("Play")];
        [o_mi_play setTitle: _NS("Play")];
        [o_dmi_play setTitle: _NS("Play")];
    }
}

- (void)setSubmenusEnabled:(BOOL)b_enabled
{
    [o_mi_program setEnabled: b_enabled];
    [o_mi_title setEnabled: b_enabled];
    [o_mi_chapter setEnabled: b_enabled];
    [o_mi_audiotrack setEnabled: b_enabled];
    [o_mi_visual setEnabled: b_enabled];
    [o_mi_videotrack setEnabled: b_enabled];
    [o_mi_subtitle setEnabled: b_enabled];
    [o_mi_channels setEnabled: b_enabled];
    [o_mi_deinterlace setEnabled: b_enabled];
    [o_mi_ffmpeg_pp setEnabled: b_enabled];
    [o_mi_device setEnabled: b_enabled];
    [o_mi_screen setEnabled: b_enabled];
}

- (void)manageVolumeSlider
{
    audio_volume_t i_volume;
    aout_VolumeGet( p_intf, &i_volume );

    if( i_volume != i_lastShownVolume )
    {
        i_lastShownVolume = i_volume;
        p_intf->p_sys->b_volume_update = TRUE;
    }
}

- (IBAction)timesliderUpdate:(id)sender
{
#define p_input p_intf->p_sys->p_input
    float f_updated;

    switch( [[NSApp currentEvent] type] )
    {
        case NSLeftMouseUp:
        case NSLeftMouseDown:
        case NSLeftMouseDragged:
            f_updated = [sender floatValue];
            break;

        default:
            return;
    }

    if( p_input != NULL )
    {
        vlc_value_t time;
        vlc_value_t pos;
        mtime_t i_seconds;
        NSString * o_time;

        pos.f_float = f_updated / 10000.;
        var_Set( p_input, "position", pos );
        [o_timeslider setFloatValue: f_updated];

        var_Get( p_input, "time", &time );
        i_seconds = time.i_time / 1000000;

        o_time = [NSString stringWithFormat: @"%d:%02d:%02d",
                        (int) (i_seconds / (60 * 60)),
                        (int) (i_seconds / 60 % 60),
                        (int) (i_seconds % 60)];
        [o_timefield setStringValue: o_time];
    }
#undef p_input
}

- (void)terminate
{
    playlist_t * p_playlist;
    vout_thread_t * p_vout;

    /* Stop playback */
    if( ( p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
                                        FIND_ANYWHERE ) ) )