intf.m

来自「VLC媒体播放程序」· M 代码 · 共 1,410 行 · 第 1/4 页

    {
        return;
    }

    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_current_title_update )
    {
        vout_thread_t *p_vout = vlc_object_find( p_intf, VLC_OBJECT_VOUT,
                                                FIND_ANYWHERE );

        vlc_mutex_lock( &p_playlist->object_lock );
        [o_scrollfield setStringValue: [NSString stringWithUTF8String: 
            p_playlist->pp_items[p_playlist->i_index]->psz_name]]; 
        vlc_mutex_unlock( &p_playlist->object_lock );

        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];
        [o_info updateInfo];

        p_intf->p_sys->b_current_title_update = FALSE;
    }

    vlc_mutex_lock( &p_playlist->object_lock );

#define p_input p_playlist->p_input

    if( p_intf->p_sys->b_intf_update )
    {
        vlc_bool_t b_input = VLC_FALSE;
        vlc_bool_t b_plmul = VLC_FALSE;
        vlc_bool_t b_control = VLC_FALSE;
        vlc_bool_t b_seekable = VLC_FALSE;
        vlc_bool_t b_chapters = VLC_FALSE;

        b_plmul = p_playlist->i_size > 1;

        if( ( b_input = ( p_input != NULL ) ) )
        {
            vlc_mutex_lock( &p_input->stream.stream_lock );

            /* seekable streams */
            b_seekable = p_input->stream.b_seekable;

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

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

        [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"];

        [self manageVolumeSlider];
        p_intf->p_sys->b_intf_update = VLC_FALSE;
    }

    if (p_intf->p_sys->b_fullscreen_update )
    {
        vout_thread_t * p_vout;
        vlc_value_t val;
        if (var_Change (p_intf, "fullscreen", VLC_VAR_INHERITVALUE, &val, NULL)>=0 &&  val.b_bool )
        {
            [o_btn_fullscreen setState:VLC_TRUE];
        }
        else
        {
            [o_btn_fullscreen setState:VLC_FALSE];
        }
        p_vout = vlc_object_find(p_intf,VLC_OBJECT_VOUT,FIND_ANYWHERE);
        if (p_vout != NULL)
        {
            [o_btn_fullscreen setEnabled: VLC_TRUE];
            vlc_object_release(p_vout);
        }
        else
        {
            [o_btn_fullscreen setEnabled: VLC_FALSE];
        }
        p_intf->p_sys->b_fullscreen_update = VLC_FALSE;
    }

    if( p_intf->p_sys->b_playing && p_input != NULL )
    {
        vlc_value_t time;
        NSString * o_time;
        mtime_t i_seconds;

        if( p_input->stream.b_seekable )
        {
            vlc_value_t pos;
            float f_updated;
            
            var_Get( p_input, "position", &pos );
            f_updated = 10000. * pos.f_float;

            if( f_slider != f_updated )
            {
                [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_input )
    {
        vlc_value_t val;
        var_Get( p_input, "state", &val );

        if( val.i_int != PAUSE_S )
        {
            p_intf->p_sys->b_play_status = TRUE;
        }
        else
        {
            p_intf->p_sys->b_play_status = FALSE;
        }
        [self playStatusUpdated: p_intf->p_sys->b_play_status];
    }
    else
    {
        p_intf->p_sys->b_play_status = FALSE;
        [self playStatusUpdated: p_intf->p_sys->b_play_status];
        [self setSubmenusEnabled: FALSE];
    }

#undef p_input

    vlc_mutex_unlock( &p_playlist->object_lock );
    vlc_object_release( p_playlist );

    [self updateMessageArray];

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

- (void)setupMenus
{
    intf_thread_t * p_intf = [NSApp getIntf];
    playlist_t *p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST, 
                                                FIND_ANYWHERE );
    
    if( p_playlist != NULL )
    {
#define p_input p_playlist->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 )
            {
                [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:)];
                vlc_object_release( (vlc_object_t *)p_vout );
            }
        }
#undef p_input
    }
    vlc_object_release( (vlc_object_t *)p_playlist );
}

- (void)updateMessageArray
{
    int i_start, i_stop;
    intf_thread_t * p_intf = [NSApp getIntf];
    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:(BOOL)b_pause
{
    if( b_pause )
    {
        [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_device setEnabled: b_enabled];
    [o_mi_screen setEnabled: b_enabled];
}

- (void)manageVolumeSlider