Skip to content

V
vlc-2-2
Commit 254f695e authored by Eric Petit's avatar Eric Petit
Browse files
Options

+ src/libvlc.h: use KEY_SPACE instead of ' ' 

 + gui/beos/*: got rid of the VlcWrapper thing which is unneccessaraly
               complex now that we have variables

 Language/subtitle selection works again in the BeOS UI, but there's
 still a lot to fix :|
parent 4632a220
Show whitespace changes
Inline Side-by-side
Showing with 1543 additions and 2437 deletions
modules/gui/beos/Interface.cpp
View file @ 254f695e
......@@ -2,7 +2,7 @@
* intf_beos.cpp: beos interface
*****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN
* $Id: Interface.cpp,v 1.16 2004/01/26 16:52:31 zorglub Exp $
* $Id$
*
* Authors: Jean-Marc Dressler <polux@via.ecp.fr>
* Samuel Hocevar <sam@zoy.org>
......@@ -41,10 +41,17 @@
#include <vlc/aout.h>
#include <aout_internal.h>
#include "VlcWrapper.h"
#include "InterfaceWindow.h"
#include "MsgVals.h"
/*****************************************************************************
* intf_sys_t: internal variables of the BeOS interface
*****************************************************************************/
struct intf_sys_t
{
InterfaceWindow * p_window;
};
/*****************************************************************************
* Local prototype
*****************************************************************************/
......@@ -59,44 +66,36 @@ int E_(OpenIntf) ( vlc_object_t *p_this )
/* Allocate instance and initialize some members */
p_intf->p_sys = (intf_sys_t*) malloc( sizeof( intf_sys_t ) );
if( p_intf->p_sys == NULL )
if( !p_intf->p_sys )
{
msg_Err( p_intf, "out of memory" );
return( 1 );
return VLC_EGENERIC;
}
p_intf->p_sys->p_sub = msg_Subscribe( p_intf );
p_intf->p_sys->p_wrapper = new VlcWrapper( p_intf );
p_intf->pf_run = Run;
/* Create the interface window */
BScreen screen(B_MAIN_SCREEN_ID);
BScreen screen( B_MAIN_SCREEN_ID );
BRect rect = screen.Frame();
rect.top = rect.bottom-100;
rect.top = rect.bottom - 100;
rect.bottom -= 50;
rect.left += 50;
rect.right = rect.left + 350;
p_intf->p_sys->p_window =
new InterfaceWindow( rect,
"VLC " PACKAGE_VERSION,
p_intf );
if( p_intf->p_sys->p_window == 0 )
new InterfaceWindow( p_intf, rect, "VLC " VERSION );
if( !p_intf->p_sys->p_window )
{
free( p_intf->p_sys );
msg_Err( p_intf, "cannot allocate InterfaceWindow" );
return( 1 );
return VLC_EGENERIC;
}
else
{
/* Make the be_app aware the interface has been created */
BMessage message(INTERFACE_CREATED);
message.AddPointer("window", p_intf->p_sys->p_window);
be_app->PostMessage(&message);
}
p_intf->p_sys->b_loop = 0;
p_intf->p_sys->b_mute = 0;
BMessage message( INTERFACE_CREATED );
message.AddPointer( "window", p_intf->p_sys->p_window );
be_app->PostMessage( &message );
return( 0 );
return VLC_SUCCESS;
}
/*****************************************************************************
......@@ -106,14 +105,11 @@ void E_(CloseIntf) ( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t*) p_this;
msg_Unsubscribe( p_intf, p_intf->p_sys->p_sub );
/* Destroy the interface window */
if( p_intf->p_sys->p_window->Lock() )
p_intf->p_sys->p_window->Quit();
/* Destroy structure */
delete p_intf->p_sys->p_wrapper;
free( p_intf->p_sys );
}
......@@ -125,13 +121,7 @@ static void Run( intf_thread_t *p_intf )
{
while( !p_intf->b_die )
{
/* Update VlcWrapper internals (p_input, etc) */
p_intf->p_sys->p_wrapper->UpdateInput();
/* Manage the slider */
p_intf->p_sys->p_window->UpdateInterface();
/* Wait a bit */
msleep( INTF_IDLE_SLEEP );
}
}
modules/gui/beos/InterfaceWindow.cpp
View file @ 254f695e
......@@ -44,7 +44,6 @@
#include <vlc/input.h>
/* BeOS interface headers */
#include "VlcWrapper.h"
#include "MsgVals.h"
#include "MediaControlView.h"
#include "PlayListWindow.h"
......@@ -180,17 +179,24 @@ collect_folder_contents( BDirectory& dir, BList& list, bool& deep, bool& asked,
* InterfaceWindow
*****************************************************************************/
InterfaceWindow::InterfaceWindow( BRect frame, const char* name,
intf_thread_t* p_interface )
InterfaceWindow::InterfaceWindow( intf_thread_t * _p_intf, BRect frame,
const char * name )
: BWindow( frame, name, B_TITLED_WINDOW_LOOK, B_NORMAL_WINDOW_FEEL,
B_NOT_ZOOMABLE | B_WILL_ACCEPT_FIRST_CLICK | B_ASYNCHRONOUS_CONTROLS ),
p_intf( p_interface ),
/* Initializations */
p_intf( _p_intf ),
p_input( NULL ),
p_playlist( NULL ),
fFilePanel( NULL ),
fLastUpdateTime( system_time() ),
fSettings( new BMessage( 'sett' ) ),
p_wrapper( p_intf->p_sys->p_wrapper )
fSettings( new BMessage( 'sett' ) )
{
fPlaylistIsEmpty = !( p_wrapper->PlaylistSize() > 0 );
char psz_tmp[1024];
#define ADD_ELLIPSIS( a ) \
memset( psz_tmp, 0, 1024 ); \
snprintf( psz_tmp, 1024, "%s%s", a, B_UTF8_ELLIPSIS );
BScreen screen;
BRect screen_rect = screen.Frame();
......@@ -212,8 +218,7 @@ InterfaceWindow::InterfaceWindow( BRect frame, const char* name,
fMessagesWindow = new MessagesWindow( p_intf, window_rect, _("Messages") );
// the media control view
p_mediaControl = new MediaControlView( BRect( 0.0, 0.0, 250.0, 50.0 ),
p_intf );
p_mediaControl = new MediaControlView( p_intf, BRect( 0.0, 0.0, 250.0, 50.0 ) );
p_mediaControl->SetViewColor( ui_color( B_PANEL_BACKGROUND_COLOR ) );
float width, height;
......@@ -234,26 +239,25 @@ InterfaceWindow::InterfaceWindow( BRect frame, const char* name,
p_mediaControl->MoveTo( fMenuBar->Bounds().LeftBottom() + BPoint(0.0, 1.0) );
AddChild( fMenuBar );
// Add the file Menu
BMenu* fileMenu = new BMenu( _("File") );
fMenuBar->AddItem( fileMenu );
fileMenu->AddItem( new BMenuItem( _AddEllipsis(_("Open File")),
new BMessage( OPEN_FILE ), 'O') );
ADD_ELLIPSIS( _("Open File") );
fileMenu->AddItem( new BMenuItem( psz_tmp, new BMessage( OPEN_FILE ), 'O') );
fileMenu->AddItem( new CDMenu( _("Open Disc") ) );
fileMenu->AddItem( new BMenuItem( _AddEllipsis(_("Open Subtitles")),
new BMessage( LOAD_SUBFILE ) ) );
ADD_ELLIPSIS( _("Open Subtitles") );
fileMenu->AddItem( new BMenuItem( psz_tmp, new BMessage( LOAD_SUBFILE ) ) );
fileMenu->AddSeparatorItem();
BMenuItem* item = new BMenuItem( _AddEllipsis(_("About")),
new BMessage( B_ABOUT_REQUESTED ), 'A');
ADD_ELLIPSIS( _("About") );
BMenuItem* item = new BMenuItem( psz_tmp, new BMessage( B_ABOUT_REQUESTED ), 'A');
item->SetTarget( be_app );
fileMenu->AddItem( item );
fileMenu->AddItem( new BMenuItem( _("Quit"), new BMessage( B_QUIT_REQUESTED ), 'Q') );
fLanguageMenu = new LanguageMenu( _("Language"), AUDIO_ES, p_wrapper);
fSubtitlesMenu = new LanguageMenu( _("Subtitles"), SPU_ES, p_wrapper);
fLanguageMenu = new LanguageMenu( p_intf, _("Language"), "audio-es" );
fSubtitlesMenu = new LanguageMenu( p_intf, _("Subtitles"), "spu-es" );
/* Add the Audio menu */
fAudioMenu = new BMenu( _("Audio") );
......@@ -301,12 +305,12 @@ InterfaceWindow::InterfaceWindow( BRect frame, const char* name,
/* Add the Show menu */
fShowMenu = new BMenu( _("Window") );
fShowMenu->AddItem( new BMenuItem( _AddEllipsis(_("Playlist")),
new BMessage( OPEN_PLAYLIST ), 'P') );
fShowMenu->AddItem( new BMenuItem( _AddEllipsis(_("Messages")),
new BMessage( OPEN_MESSAGES ), 'M' ) );
fShowMenu->AddItem( new BMenuItem( _AddEllipsis(_("Preferences")),
new BMessage( OPEN_PREFERENCES ), 'S' ) );
ADD_ELLIPSIS( _("Playlist") );
fShowMenu->AddItem( new BMenuItem( psz_tmp, new BMessage( OPEN_PLAYLIST ), 'P') );
ADD_ELLIPSIS( _("Messages") );
fShowMenu->AddItem( new BMenuItem( psz_tmp, new BMessage( OPEN_MESSAGES ), 'M' ) );
ADD_ELLIPSIS( _("Preferences") );
fShowMenu->AddItem( new BMenuItem( psz_tmp, new BMessage( OPEN_PREFERENCES ), 'S' ) );
fMenuBar->AddItem( fShowMenu );
// add the media control view after the menubar is complete
......@@ -325,15 +329,26 @@ InterfaceWindow::InterfaceWindow( BRect frame, const char* name,
InterfaceWindow::~InterfaceWindow()
{
if( p_input )
{
vlc_object_release( p_input );
}
if( p_playlist )
{
vlc_object_release( p_playlist );
}
if( fPlaylistWindow )
{
fPlaylistWindow->ReallyQuit();
fPlaylistWindow = NULL;
}
if( fMessagesWindow )
{
fMessagesWindow->ReallyQuit();
fMessagesWindow = NULL;
}
if( fPreferencesWindow )
{
fPreferencesWindow->ReallyQuit();
fPreferencesWindow = NULL;
}
delete fFilePanel;
delete fSettings;
}
......@@ -357,16 +372,16 @@ InterfaceWindow::FrameResized(float width, float height)
*****************************************************************************/
void InterfaceWindow::MessageReceived( BMessage * p_message )
{
int playback_status; // remember playback state
playback_status = p_wrapper->InputStatus();
switch( p_message->what )
{
case B_ABOUT_REQUESTED:
{
BAlert* alert = new BAlert( "VLC " PACKAGE_VERSION,
"VLC " PACKAGE_VERSION " for BeOS"
"\n\n<www.videolan.org>", _("OK"));
BAlert * alert;
alert = new BAlert( "VLC media player" VERSION,
"VLC media player" VERSION " (BeOS interface)\n\n"
"The VideoLAN team <videolan@videolan.org>\n"
"http://www.videolan.org/", _("OK") );
alert->Go();
break;
}
......@@ -391,14 +406,18 @@ void InterfaceWindow::MessageReceived( BMessage * p_message )
fPlaylistWindow->Unlock();
}
break;
case OPEN_DVD:
{
const char *psz_device;
BString type( "dvd" );
if( p_message->FindString( "device", &psz_device ) == B_OK )
const char * psz_device;
if( p_playlist &&
p_message->FindString( "device", &psz_device ) == B_OK )
{
BString device( psz_device );
p_wrapper->OpenDisc( type, device, 0, 0 );
char psz_uri[1024];
memset( psz_uri, 0, 1024 );
snprintf( psz_uri, 1024, "dvdnav:%s", psz_device );
playlist_Add( p_playlist, psz_uri, psz_device,
PLAYLIST_APPEND | PLAYLIST_GO, PLAYLIST_END );
}
_UpdatePlaylist();
}
......@@ -411,167 +430,266 @@ void InterfaceWindow::MessageReceived( BMessage * p_message )
{
BPath path( &ref );
if ( path.InitCheck() == B_OK )
p_wrapper->LoadSubFile( path.Path() );
config_PutPsz( p_intf, "sub-file", path.Path() );
}
break;
}
case STOP_PLAYBACK:
// this currently stops playback not nicely
if (playback_status != -1)
if( p_playlist )
{
p_wrapper->PlaylistStop();
p_mediaControl->SetStatus(-1, INPUT_RATE_DEFAULT);
playlist_Stop( p_playlist );
}
p_mediaControl->SetStatus(-1, INPUT_RATE_DEFAULT);
break;
case START_PLAYBACK:
/* starts playing in normal mode */
case PAUSE_PLAYBACK:
/* toggle between pause and play */
if (playback_status > -1)
if( p_input )
{
/* pause if currently playing */
if ( playback_status == PLAYING_S )
if( var_GetInteger( p_input, "state" ) == PAUSE_S )
{
p_wrapper->PlaylistPause();
}
else
if( p_playlist )
{
p_wrapper->PlaylistPlay();
playlist_Play( p_playlist );
}
}
else
{
/* Play a new file */
p_wrapper->PlaylistPlay();
var_SetInteger( p_input, "state", PAUSE_S );
}
}
break;
case HEIGHTH_PLAY:
p_wrapper->InputSetRate( INPUT_RATE_DEFAULT * 8 );
if( p_input )
{
var_SetInteger( p_input, "rate", INPUT_RATE_DEFAULT * 8 );
}
break;
case QUARTER_PLAY:
p_wrapper->InputSetRate( INPUT_RATE_DEFAULT * 4 );
if( p_input )
{
var_SetInteger( p_input, "rate", INPUT_RATE_DEFAULT * 4 );
}
break;
case HALF_PLAY:
p_wrapper->InputSetRate( INPUT_RATE_DEFAULT * 2 );
if( p_input )
{
var_SetInteger( p_input, "rate", INPUT_RATE_DEFAULT * 2 );
}
break;
case NORMAL_PLAY:
p_wrapper->InputSetRate( INPUT_RATE_DEFAULT );
if( p_input )
{
var_SetInteger( p_input, "rate", INPUT_RATE_DEFAULT );
}
break;
case TWICE_PLAY:
p_wrapper->InputSetRate( INPUT_RATE_DEFAULT / 2 );
if( p_input )
{
var_SetInteger( p_input, "rate", INPUT_RATE_DEFAULT / 2 );
}
break;
case FOUR_PLAY:
p_wrapper->InputSetRate( INPUT_RATE_DEFAULT / 4 );
if( p_input )
{
var_SetInteger( p_input, "rate", INPUT_RATE_DEFAULT / 4 );
}
break;
case HEIGHT_PLAY:
p_wrapper->InputSetRate( INPUT_RATE_DEFAULT / 8 );
if( p_input )
{
var_SetInteger( p_input, "rate", INPUT_RATE_DEFAULT / 8 );
}
break;
case SEEK_PLAYBACK:
/* handled by semaphores */
break;
// volume related messages
case VOLUME_CHG:
/* adjust the volume */
if (playback_status > -1)
{
p_wrapper->SetVolume( p_mediaControl->GetVolume() );
p_mediaControl->SetMuted( p_wrapper->IsMuted() );
}
aout_VolumeSet( p_intf, p_mediaControl->GetVolume() );
break;
case VOLUME_MUTE:
// toggle muting
if( p_wrapper->IsMuted() )
p_wrapper->VolumeRestore();
else
p_wrapper->VolumeMute();
p_mediaControl->SetMuted( p_wrapper->IsMuted() );
aout_VolumeMute( p_intf, NULL );
break;
case SELECT_CHANNEL:
if ( playback_status > -1 )
{
int32 channel;
if ( p_message->FindInt32( "channel", &channel ) == B_OK )
if( p_input )
{
p_wrapper->ToggleLanguage( channel );
}
if( p_message->FindInt32( "audio-es", &channel ) == B_OK )
{
var_SetInteger( p_input, "audio-es", channel );
}
break;
case SELECT_SUBTITLE:
if ( playback_status > -1 )
else if( p_message->FindInt32( "spu-es", &channel ) == B_OK )
{
int32 subtitle;
if ( p_message->FindInt32( "subtitle", &subtitle ) == B_OK )
p_wrapper->ToggleSubtitle( subtitle );
var_SetInteger( p_input, "spu-es", channel );
}
}
break;
}
// specific navigation messages
case PREV_TITLE:
if( p_input )
{
p_wrapper->PrevTitle();
break;
var_SetVoid( p_input, "prev-title" );
}
break;
case NEXT_TITLE:
if( p_input )
{
p_wrapper->NextTitle();
break;
var_SetVoid( p_input, "next-title" );
}
break;
case NAVIGATE_MENU:
p_wrapper->ToggleTitle( 0 );
if( p_input )
{
var_SetInteger( p_input, "title", 0 );
}
break;
case TOGGLE_TITLE:
if ( playback_status > -1 )
{
int32 index;
if( p_message->FindInt32( "index", &index ) == B_OK )
p_wrapper->ToggleTitle( index );
if( p_input &&
p_message->FindInt32( "index", &index ) == B_OK )
{
var_SetInteger( p_input, "title", index );
}
break;
}
case PREV_CHAPTER:
if( p_input )
{
p_wrapper->PrevChapter();
break;
var_SetVoid( p_input, "prev-chapter" );
}
break;
case NEXT_CHAPTER:
if( p_input )
{
p_wrapper->NextChapter();
break;
var_SetVoid( p_input, "next-chapter" );
}
break;
case TOGGLE_CHAPTER:
if ( playback_status > -1 )
{
int32 index;
if( p_message->FindInt32( "index", &index ) == B_OK )
p_wrapper->ToggleChapter( index );
if( p_input &&
p_message->FindInt32( "index", &index ) == B_OK )
{
var_SetInteger( p_input, "chapter", index );
}
break;
}
case PREV_FILE:
p_wrapper->PlaylistPrev();
if( p_playlist )
{
playlist_Prev( p_playlist );
}
break;
case NEXT_FILE:
p_wrapper->PlaylistNext();
if( p_playlist )
{
playlist_Next( p_playlist );
}
break;
// general next/prev functionality (skips to whatever makes most sense)
case NAVIGATE_PREV:
p_wrapper->NavigatePrev();
if( p_input )
{
vlc_value_t val;
/* First try to go to previous chapter */
if( !var_Get( p_input, "chapter", &val ) )
{
if( val.i_int > 1 )
{
var_SetVoid( p_input, "prev-chapter" );
break;
}
}
/* Try to go to previous title */
if( !var_Get( p_input, "title", &val ) )
{
if( val.i_int > 1 )
{
var_SetVoid( p_input, "prev-title" );
break;
}
}
/* Try to go to previous file */
if( p_playlist )
{
playlist_Prev( p_playlist );
}
}
break;
case NAVIGATE_NEXT:
p_wrapper->NavigateNext();
if( p_input )
{
vlc_value_t val, val_list;
/* First try to go to next chapter */
if( !var_Get( p_input, "chapter", &val ) )
{
var_Change( p_input, "chapter", VLC_VAR_GETCHOICES,
&val_list, NULL );
if( val_list.p_list->i_count > val.i_int )
{
var_Change( p_input, "chapter", VLC_VAR_FREELIST,
&val_list, NULL );
var_SetVoid( p_input, "next-chapter" );
break;
}
var_Change( p_input, "chapter", VLC_VAR_FREELIST,
&val_list, NULL );
}
/* Try to go to next 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 > val.i_int )
{
var_Change( p_input, "title", VLC_VAR_FREELIST,
&val_list, NULL );
var_SetVoid( p_input, "next-title" );
break;
}
var_Change( p_input, "title", VLC_VAR_FREELIST,
&val_list, NULL );
}
/* Try to go to next file */
if( p_playlist )
{
playlist_Next( p_playlist );
}
}
break;
// drag'n'drop and system messages
case MSG_SOUNDPLAY:
// convert soundplay drag'n'drop message (containing paths)
......@@ -590,101 +708,46 @@ void InterfaceWindow::MessageReceived( BMessage * p_message )
case B_SIMPLE_DATA:
{
/* file(s) opened by the File menu -> append to the playlist;
* file(s) opened by drag & drop -> replace playlist;
* file(s) opened by 'shift' + drag & drop -> append */
bool replace = false;
bool reverse = false;
if ( p_message->WasDropped() )
{
replace = !( modifiers() & B_SHIFT_KEY );
reverse = true;
}
// build list of files to be played from message contents
entry_ref ref;
BList files;
file(s) opened by drag & drop -> replace playlist;
file(s) opened by 'shift' + drag & drop -> append */
// if we should parse sub-folders as well
bool askedAlready = false;
bool parseSubFolders = askedAlready;
// traverse refs in reverse order
int32 count;
type_code dummy;
if ( p_message->GetInfo( "refs", &dummy, &count ) == B_OK && count > 0 )
if( p_message->GetInfo( "refs", &dummy, &count ) != B_OK ||
count < 1 )
{
int32 i = reverse ? count - 1 : 0;
int32 increment = reverse ? -1 : 1;
for ( ; p_message->FindRef( "refs", i, &ref ) == B_OK; i += increment )
{
BPath path( &ref );
if ( path.InitCheck() == B_OK )
{
bool add = true;
// has the user dropped a folder?
BDirectory dir( &ref );
if ( dir.InitCheck() == B_OK)
{
// has the user dropped a dvd disk icon?
if ( dir.IsRootDirectory() )
{
BVolumeRoster volRoster;
BVolume vol;
BDirectory volumeRoot;
status_t status = volRoster.GetNextVolume( &vol );
while ( status == B_NO_ERROR )
{
if ( vol.GetRootDirectory( &volumeRoot ) == B_OK
&& dir == volumeRoot )
{
BString volumeName;
BString deviceName;
bool isCDROM;
if ( get_volume_info( vol, volumeName, isCDROM, deviceName )
&& isCDROM )
{
BMessage msg( OPEN_DVD );
msg.AddString( "device", deviceName.String() );
PostMessage( &msg );
add = false;
}
break;
}
else
vlc_bool_t b_remove = ( p_message->WasDropped() &&
!( modifiers() & B_SHIFT_KEY ) );
if( b_remove && p_playlist )
{
vol.Unset();
status = volRoster.GetNextVolume( &vol );
}
}
}
if ( add )
/* Empty playlist */
while( p_playlist->i_size > 0 )
{
add = false;
dir.Rewind(); // defensive programming
BEntry entry;
collect_folder_contents( dir, files,
parseSubFolders,
askedAlready,
entry );
playlist_Delete( p_playlist, 0 );
}
}
if ( add )
entry_ref ref;
for( int i = 0; p_message->FindRef( "refs", i, &ref ) == B_OK; i++ )
{
BString* string = new BString( path.Path() );
if ( !files.AddItem( string, 0 ) )
delete string; // at least don't leak
}
BPath path( &ref );
/* TODO: find out if this is a DVD icon */
if( p_playlist )
{
playlist_Add( p_playlist, path.Path(), path.Path(),
PLAYLIST_APPEND | PLAYLIST_GO, PLAYLIST_END );
}
}
// give the list to VLC
// BString objects allocated here will be deleted there
int32 index;
if ( p_message->FindInt32("drop index", &index) != B_OK )
index = -1;
p_wrapper->OpenFiles( &files, replace, index );
_UpdatePlaylist();
}
}
break;
}
case OPEN_PREFERENCES:
{
......@@ -718,7 +781,6 @@ void InterfaceWindow::MessageReceived( BMessage * p_message )
BWindow::MessageReceived( p_message );
break;
}
}
/*****************************************************************************
......@@ -726,7 +788,10 @@ void InterfaceWindow::MessageReceived( BMessage * p_message )
*****************************************************************************/
bool InterfaceWindow::QuitRequested()
{
p_wrapper->PlaylistStop();
if( p_playlist )
{
playlist_Stop( p_playlist );
}
p_mediaControl->SetStatus(-1, INPUT_RATE_DEFAULT);
_StoreSettings();
......@@ -741,41 +806,57 @@ bool InterfaceWindow::QuitRequested()
*****************************************************************************/
void InterfaceWindow::UpdateInterface()
{
if( p_wrapper->HasInput() )
/* Manage the input part */
if( !p_playlist )
{
p_playlist = (playlist_t *)
vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
}
if( !p_input )
{
if ( acquire_sem( p_mediaControl->fScrubSem ) == B_OK )
p_input = (input_thread_t *)
vlc_object_find( p_intf, VLC_OBJECT_INPUT, FIND_ANYWHERE );
}
else if( p_input->b_dead )
{
vlc_object_release( p_input );
p_input = NULL;
}
/* Get ready to update the interface */
if( LockWithTimeout( INTERFACE_LOCKING_TIMEOUT ) != B_OK )
{
p_wrapper->SetTimeAsFloat( p_mediaControl->GetSeekTo() );
return;
}
else if ( LockWithTimeout( INTERFACE_LOCKING_TIMEOUT ) == B_OK )
if( p_input )
{
vlc_value_t val;
p_mediaControl->SetEnabled( true );
bool hasTitles = p_wrapper->HasTitles();
bool hasChapters = p_wrapper->HasChapters();
p_mediaControl->SetStatus( p_wrapper->InputStatus(),
p_wrapper->InputRate() );
p_mediaControl->SetProgress( p_wrapper->GetTimeAsFloat() );
bool hasTitles = var_Get( p_input, "title", &val );
bool hasChapters = var_Get( p_input, "chapter", &val );
p_mediaControl->SetStatus( var_GetInteger( p_input, "state" ),
var_GetInteger( p_input, "rate" ) );
var_Get( p_input, "position", &val );
p_mediaControl->SetProgress( val.f_float );
_SetMenusEnabled( true, hasChapters, hasTitles );
_UpdateSpeedMenu( p_wrapper->InputRate() );
_UpdateSpeedMenu( var_GetInteger( p_input, "rate" ) );
// enable/disable skip buttons
#if 0
bool canSkipPrev;
bool canSkipNext;
p_wrapper->GetNavCapabilities( &canSkipPrev, &canSkipNext );
p_mediaControl->SetSkippable( canSkipPrev, canSkipNext );
#endif
if ( p_wrapper->HasInput() )
{
audio_volume_t i_volume;
aout_VolumeGet( p_input, &i_volume );
p_mediaControl->SetAudioEnabled( true );
p_mediaControl->SetMuted( p_wrapper->IsMuted() );
} else
p_mediaControl->SetAudioEnabled( false );
p_mediaControl->SetMuted( i_volume );
Unlock();
}
// update playlist as well
if ( fPlaylistWindow->LockWithTimeout( INTERFACE_LOCKING_TIMEOUT ) == B_OK )
if( fPlaylistWindow->LockWithTimeout( INTERFACE_LOCKING_TIMEOUT ) == B_OK )
{
fPlaylistWindow->UpdatePlaylist();
fPlaylistWindow->Unlock();
......@@ -783,24 +864,29 @@ void InterfaceWindow::UpdateInterface()
}
else
{
if ( LockWithTimeout(INTERFACE_LOCKING_TIMEOUT) == B_OK )
{
p_mediaControl->SetAudioEnabled( false );
_SetMenusEnabled( false );
if( !( p_wrapper->PlaylistSize() > 0 ) )
p_mediaControl->SetEnabled( false );
else
if( !p_playlist || p_playlist->i_size <= 0 )
{
p_mediaControl->SetProgress( 0 );
#if 0
// enable/disable skip buttons
bool canSkipPrev;
bool canSkipNext;
p_wrapper->GetNavCapabilities( &canSkipPrev, &canSkipNext );
p_mediaControl->SetSkippable( canSkipPrev, canSkipNext );
#endif
}
Unlock();
else
{
p_mediaControl->SetEnabled( false );
}
}
Unlock();
fLastUpdateTime = system_time();
}
......@@ -819,12 +905,12 @@ InterfaceWindow::IsStopped() const
void
InterfaceWindow::_UpdatePlaylist()
{
if ( fPlaylistWindow->Lock() )
if( fPlaylistWindow->Lock() )
{
fPlaylistWindow->UpdatePlaylist( true );
fPlaylistWindow->Unlock();
p_mediaControl->SetEnabled( p_wrapper->PlaylistSize() );
}
p_mediaControl->SetEnabled( p_playlist->i_size );
}
/*****************************************************************************
......@@ -862,10 +948,7 @@ InterfaceWindow::_SetMenusEnabled(bool hasFile, bool hasChapters, bool hasTitles
fSubtitlesMenu->SetEnabled( hasFile );
if ( fSpeedMenu->IsEnabled() != hasFile )
fSpeedMenu->SetEnabled( hasFile );
// "goto menu" menu item
bool hasMenu = p_wrapper->IsUsingMenus();
if ( fGotoMenuMI->IsEnabled() != hasMenu )
fGotoMenuMI->SetEnabled( hasMenu );
fGotoMenuMI->SetEnabled( true );
Unlock();
}
}
......@@ -909,8 +992,10 @@ InterfaceWindow::_UpdateSpeedMenu( int rate )
break;
}
if ( !toMark->IsMarked() )
if ( toMark && !toMark->IsMarked() )
{
toMark->SetMarked( true );
}
}
/*****************************************************************************
......@@ -1113,12 +1198,12 @@ int CDMenu::GetCD( const char *directory )
/*****************************************************************************
* LanguageMenu::LanguageMenu
*****************************************************************************/
LanguageMenu::LanguageMenu( const char *name, int menu_kind,
VlcWrapper *p_wrapper )
:BMenu(name)
LanguageMenu::LanguageMenu( intf_thread_t * _p_intf, const char * psz_name,
char * _psz_variable )
: BMenu( psz_name )
{
kind = menu_kind;
this->p_wrapper = p_wrapper;
p_intf = _p_intf;
psz_variable = strdup( _psz_variable );
}
/*****************************************************************************
......@@ -1126,6 +1211,7 @@ LanguageMenu::LanguageMenu( const char *name, int menu_kind,
*****************************************************************************/
LanguageMenu::~LanguageMenu()
{
free( psz_variable );
}
/*****************************************************************************
......@@ -1133,19 +1219,44 @@ LanguageMenu::~LanguageMenu()
*****************************************************************************/
void LanguageMenu::AttachedToWindow()
{
BMenuItem * item;
// remove all items
while ( BMenuItem* item = RemoveItem( 0L ) )
while( ( item = RemoveItem( 0L ) ) )
{
delete item;
}
SetRadioMode( true );
if ( BList *list = p_wrapper->GetChannels( kind ) )
input_thread_t * p_input = (input_thread_t *)
vlc_object_find( p_intf, VLC_OBJECT_INPUT, FIND_ANYWHERE );
if( !p_input )
{
for ( int32 i = 0; BMenuItem* item = (BMenuItem*)list->ItemAt( i ); i++ )
AddItem( item );
return;
}
if ( list->CountItems() > 1 )
AddItem( new BSeparatorItem(), 1 );
vlc_value_t val_list, text_list;
BMessage * message;
int i_current;
i_current = var_GetInteger( p_input, psz_variable );
var_Change( p_input, psz_variable, VLC_VAR_GETLIST, &val_list, &text_list );
for( int i = 0; i < val_list.p_list->i_count; i++ )
{
message = new BMessage( SELECT_CHANNEL );
message->AddInt32( psz_variable, val_list.p_list->p_values[i].i_int );
item = new BMenuItem( text_list.p_list->p_values[i].psz_string, message );
if( val_list.p_list->p_values[i].i_int == i_current )
{
item->SetMarked( true );
}
AddItem( item );
}
var_Change( p_input, psz_variable, VLC_VAR_FREELIST, &val_list, &text_list );
vlc_object_release( p_input );
BMenu::AttachedToWindow();
}
......@@ -1170,14 +1281,41 @@ TitleMenu::~TitleMenu()
*****************************************************************************/
void TitleMenu::AttachedToWindow()
{
while( BMenuItem* item = RemoveItem( 0L ) )
BMenuItem * item;
while( ( item = RemoveItem( 0L ) ) )
{
delete item;
}
input_thread_t * p_input;
p_input = (input_thread_t *)
vlc_object_find( p_intf, VLC_OBJECT_INPUT, FIND_ANYWHERE );
if( !p_input )
{
return;
}
vlc_value_t val;
if( !var_Get( p_input, "title", &val ) )
{
vlc_value_t val_list, text_list;
var_Change( p_input, "title", VLC_VAR_GETCHOICES,
&val_list, &text_list );
if ( BList *list = p_intf->p_sys->p_wrapper->GetTitles() )
for( int i = 0; i < val_list.p_list->i_count; i++ )
{
for( int i = 0; BMenuItem* item = (BMenuItem*)list->ItemAt( i ); i++ )
item = new BMenuItem( text_list.p_list->p_values[i].psz_string,
NULL );
if( val_list.p_list->p_values[i].i_int == val.i_int )
{
item->SetMarked( true );
}
AddItem( item );
}
var_Change( p_input, "title", VLC_VAR_FREELIST,
&val_list, &text_list );
}
BMenu::AttachedToWindow();
}
......@@ -1203,26 +1341,45 @@ ChapterMenu::~ChapterMenu()
*****************************************************************************/
void ChapterMenu::AttachedToWindow()
{
while( BMenuItem* item = RemoveItem( 0L ) )
BMenuItem * item;
while( ( item = RemoveItem( 0L ) ) )
{
delete item;
}
input_thread_t * p_input;
p_input = (input_thread_t *)
vlc_object_find( p_intf, VLC_OBJECT_INPUT, FIND_ANYWHERE );
if( !p_input )
{
return;
}
vlc_value_t val;
if( !var_Get( p_input, "chapter", &val ) )
{
vlc_value_t val_list, text_list;
var_Change( p_input, "chapter", VLC_VAR_GETCHOICES,
&val_list, &text_list );
if ( BList* list = p_intf->p_sys->p_wrapper->GetChapters() )
for( int i = 0; i < val_list.p_list->i_count; i++ )
{
for( int i = 0; BMenuItem* item = (BMenuItem*)list->ItemAt( i ); i++ )
item = new BMenuItem( text_list.p_list->p_values[i].psz_string,
NULL );
if( val_list.p_list->p_values[i].i_int == val.i_int )
{
item->SetMarked( true );
}
AddItem( item );
}
var_Change( p_input, "chapter", VLC_VAR_FREELIST,
&val_list, &text_list );
}
BMenu::AttachedToWindow();
}
/*****************************************************************************
* load_settings
*****************************************************************************/
......
modules/gui/beos/InterfaceWindow.h
View file @ 254f695e
......@@ -2,7 +2,7 @@
* InterfaceWindow.h: BeOS interface window class prototype
*****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN
* $Id: InterfaceWindow.h,v 1.15 2004/01/26 16:52:31 zorglub Exp $
* $Id$
*
* Authors: Jean-Marc Dressler <polux@via.ecp.fr>
* Tony Castley <tcastley@mail.powerup.com.au>
......@@ -36,7 +36,6 @@ class PlayListWindow;
class BFilePanel;
class PreferencesWindow;
class MessagesWindow;
class VlcWrapper;
class CDMenu : public BMenu
{
......@@ -53,16 +52,16 @@ class CDMenu : public BMenu
class LanguageMenu : public BMenu
{
public:
LanguageMenu( const char* name,
int menu_kind,
VlcWrapper *p_wrapper );
LanguageMenu( intf_thread_t * p_intf,
const char * psz_name,
char * psz_variable );
virtual ~LanguageMenu();
virtual void AttachedToWindow();
private:
VlcWrapper * p_wrapper;
int kind;
intf_thread_t * p_intf;
char * psz_variable;
};
class TitleMenu : public BMenu
......@@ -91,9 +90,9 @@ class ChapterMenu : public BMenu
class InterfaceWindow : public BWindow
{
public:
InterfaceWindow( BRect frame,
const char* name,
intf_thread_t* p_interface );
InterfaceWindow( intf_thread_t * p_intf,
BRect frame,
const char * name );
virtual ~InterfaceWindow();
// BWindow
......@@ -119,10 +118,11 @@ class InterfaceWindow : public BWindow
void _RestoreSettings();
void _StoreSettings();
intf_thread_t* p_intf;
es_descriptor_t* p_spu_es;
intf_thread_t * p_intf;
input_thread_t * p_input;
playlist_t * p_playlist;
es_descriptor_t * p_spu_es;
bool fPlaylistIsEmpty;
BFilePanel* fFilePanel;
PlayListWindow* fPlaylistWindow;
PreferencesWindow* fPreferencesWindow;
......@@ -151,7 +151,6 @@ class InterfaceWindow : public BWindow
bigtime_t fLastUpdateTime;
BMessage* fSettings; // we keep the message arround
// for forward compatibility
VlcWrapper* p_wrapper;
};
......
modules/gui/beos/ListViews.cpp
View file @ 254f695e
......@@ -2,7 +2,7 @@
* ListViews.h: BeOS interface list view class implementation
*****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN
* $Id: ListViews.cpp,v 1.6 2004/01/26 16:52:31 zorglub Exp $
* $Id$
*
* Authors: Stephan Aßmus <stippi@yellowbites.com>
*
......@@ -32,7 +32,6 @@
#include <vlc/vlc.h>
#include <vlc/intf.h>
#include "VlcWrapper.h"
#include "InterfaceWindow.h"
#include "ListViews.h"
#include "MsgVals.h"
......@@ -607,20 +606,20 @@ DragSortableListView::_RemoveDropAnticipationRect()
/*****************************************************************************
* PlaylistView class
*****************************************************************************/
PlaylistView::PlaylistView( BRect frame, InterfaceWindow* mainWindow,
VlcWrapper* wrapper,
PlaylistView::PlaylistView( intf_thread_t * _p_intf,
BRect frame, InterfaceWindow* mainWindow,
BMessage* selectionChangeMessage )
: DragSortableListView( frame, "playlist listview",
B_MULTIPLE_SELECTION_LIST, B_FOLLOW_ALL_SIDES,
B_WILL_DRAW | B_NAVIGABLE | B_PULSE_NEEDED
| B_FRAME_EVENTS | B_FULL_UPDATE_ON_RESIZE ),
p_intf( _p_intf ),
fCurrentIndex( -1 ),
fPlaying( false ),
fDisplayMode( DISPLAY_PATH ),
fMainWindow( mainWindow ),
fSelectionChangeMessage( selectionChangeMessage ),
fLastClickedItem( NULL ),
fVlcWrapper( wrapper )
fLastClickedItem( NULL )
{
}
......@@ -686,7 +685,14 @@ PlaylistView::MouseDown( BPoint where )
// only do something if user clicked the same item twice
if ( fLastClickedItem == item )
{
fVlcWrapper->PlaylistJumpTo( i );
playlist_t * p_playlist;
p_playlist = (playlist_t *) vlc_object_find( p_intf,
VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
if( p_playlist )
{
playlist_Goto( p_playlist, i );
vlc_object_release( p_playlist );
}
handled = true;
}
}
......@@ -759,6 +765,7 @@ PlaylistView::SelectionChanged()
void
PlaylistView::MoveItems( BList& items, int32 index )
{
#if 0
DeselectAll();
// we remove the items while we look at them, the insertion index is decreased
// when the items index is lower, so that we insert at the right spot after
......@@ -808,6 +815,7 @@ PlaylistView::MoveItems( BList& items, int32 index )
fMainWindow->PostMessage( MSG_UPDATE );
fVlcWrapper->PlaylistUnlock();
}
#endif
}
/*****************************************************************************
......@@ -816,6 +824,7 @@ PlaylistView::MoveItems( BList& items, int32 index )
void
PlaylistView::CopyItems( BList& items, int32 toIndex )
{
#if 0
DeselectAll();
// we remove the items while we look at them, the insertion index is decreased
// when the items index is lower, so that we insert at the right spot after
......@@ -855,6 +864,7 @@ PlaylistView::CopyItems( BList& items, int32 toIndex )
fMainWindow->PostMessage( MSG_UPDATE );
fVlcWrapper->PlaylistUnlock();
}
#endif
}
/*****************************************************************************
......@@ -863,6 +873,7 @@ PlaylistView::CopyItems( BList& items, int32 toIndex )
void
PlaylistView::RemoveItemList( BList& items )
{
#if 0
if ( fVlcWrapper->PlaylistLock() )
{
// remember currently playing item
......@@ -892,6 +903,7 @@ PlaylistView::RemoveItemList( BList& items )
fMainWindow->PostMessage( MSG_UPDATE );
fVlcWrapper->PlaylistUnlock();
}
#endif
}
/*****************************************************************************
......@@ -974,14 +986,28 @@ PlaylistView::SetPlaying( bool playing )
void
PlaylistView::RebuildList()
{
playlist_t * p_playlist;
p_playlist = (playlist_t *) vlc_object_find( p_intf,
VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
if( !p_playlist )
{
return;
}
// remove all items
BListItem * item;
int32 count = CountItems();
while ( BListItem* item = RemoveItem( --count ) )
while( ( item = RemoveItem( --count ) ) )
delete item;
// rebuild listview from VLC's playlist
for ( int i = 0; i < fVlcWrapper->PlaylistSize(); i++ )
AddItem( new PlaylistItem( fVlcWrapper->PlaylistItemName( i ) ) );
vlc_mutex_lock( &p_playlist->object_lock );
for( int i = 0; i < p_playlist->i_size; i++ )
AddItem( new PlaylistItem( p_playlist->pp_items[i]->input.psz_name ) );
vlc_mutex_unlock( &p_playlist->object_lock );
vlc_object_release( p_playlist );
}
......@@ -991,6 +1017,7 @@ PlaylistView::RebuildList()
void
PlaylistView::SortReverse()
{
#if 0
if ( int32 count = CountSelectedItems() )
{
int32 last = count - 1;
......@@ -1014,6 +1041,7 @@ PlaylistView::SortReverse()
// restore currently playing item
_SetPlayingIndex( playingItem );
}
#endif
}
/*****************************************************************************
......@@ -1052,9 +1080,18 @@ PlaylistView::SetDisplayMode( uint32 mode )
BListItem*
PlaylistView::_PlayingItem() const
{
int32 currentIndex, size;
fVlcWrapper->GetPlaylistInfo( currentIndex, size );
return ItemAt( currentIndex );
playlist_t * p_playlist;
p_playlist = (playlist_t *) vlc_object_find( p_intf,
VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
if( !p_playlist )
{
return NULL;
}
BListItem * item = ItemAt( p_playlist->i_index );
vlc_object_release( p_playlist );
return item;
}
/*****************************************************************************
......@@ -1067,8 +1104,19 @@ PlaylistView::_SetPlayingIndex( BListItem* playingItem )
{
if ( item == playingItem )
{
fVlcWrapper->PlaylistSetPlaying( i );
playlist_t * p_playlist;
p_playlist = (playlist_t *) vlc_object_find( p_intf,
VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
if( !p_playlist )
{
return;
}
playlist_Goto( p_playlist, i );
SetCurrent( i );
vlc_object_release( p_playlist );
break;
}
}
......
modules/gui/beos/ListViews.h
View file @ 254f695e
......@@ -2,7 +2,7 @@
* ListViews.h: BeOS interface list view class prototype
*****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN
* $Id: ListViews.h,v 1.5 2004/01/26 16:52:31 zorglub Exp $
* $Id$
*
* Authors: Stephan Aßmus <stippi@yellowbites.com>
*
......@@ -113,9 +113,9 @@ class DragSortableListView : public BListView
class PlaylistView : public DragSortableListView
{
public:
PlaylistView( BRect frame,
PlaylistView( intf_thread_t * p_intf,
BRect frame,
InterfaceWindow* mainWindow,
VlcWrapper* wrapper,
BMessage* selectionChangeMessage = NULL );
~PlaylistView();
......@@ -154,14 +154,14 @@ class PlaylistView : public DragSortableListView
BListItem* _PlayingItem() const;
void _SetPlayingIndex( BListItem* item );
intf_thread_t * p_intf;
int32 fCurrentIndex;
bool fPlaying;
uint32 fDisplayMode;
InterfaceWindow* fMainWindow;
BMessage* fSelectionChangeMessage;
PlaylistItem* fLastClickedItem;
VlcWrapper* fVlcWrapper;
};
#endif // LIST_VIEWS_H
modules/gui/beos/MediaControlView.cpp
View file @ 254f695e
......@@ -38,7 +38,6 @@ extern "C"
}
/* BeOS interface headers */
#include "VlcWrapper.h"
#include "Bitmaps.h"
#include "DrawingTidbits.h"
#include "InterfaceWindow.h"
......@@ -67,6 +66,7 @@ const rgb_color kSeekRedLight = (rgb_color){ 255, 152, 152, 255 };
const rgb_color kSeekRedShadow = (rgb_color){ 178, 0, 0, 255 };
#define DISABLED_SEEK_MESSAGE _("Drop files to play")
#define SEEKSLIDER_RANGE 2048
enum
{
......@@ -77,17 +77,16 @@ enum
};
// constructor
MediaControlView::MediaControlView(BRect frame, intf_thread_t *p_interface)
MediaControlView::MediaControlView( intf_thread_t * _p_intf, BRect frame)
: BBox(frame, NULL, B_FOLLOW_NONE, B_WILL_DRAW | B_FRAME_EVENTS | B_PULSE_NEEDED,
B_PLAIN_BORDER),
p_intf( _p_intf ),
fScrubSem(B_ERROR),
fCurrentRate(INPUT_RATE_DEFAULT),
fCurrentStatus(-1),
fBottomControlHeight(0.0),
fIsEnabled( true )
{
p_intf = p_interface;
BRect frame(0.0, 0.0, 10.0, 10.0);
// Seek Slider
......@@ -1335,6 +1334,7 @@ PositionInfoView::Pulse()
bigtime_t now = system_time();
if ( now - fLastPulseUpdate > 900000 )
{
#if 0
int32 index, size;
p_intf->p_sys->p_wrapper->GetPlaylistInfo( index, size );
SetFile( index + 1, size );
......@@ -1344,6 +1344,7 @@ PositionInfoView::Pulse()
SetChapter( index, size );
SetTime( p_intf->p_sys->p_wrapper->GetTimeAsString() );
fLastPulseUpdate = now;
#endif
}
}
......
modules/gui/beos/MediaControlView.h
View file @ 254f695e
......@@ -2,7 +2,7 @@
* MediaControlView.h: beos interface
*****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN
* $Id: MediaControlView.h,v 1.5 2003/01/25 01:03:44 titer Exp $
* $Id$
*
* Authors: Tony Castley <tony@castley.net>
* Stephan Aßmus <stippi@yellowbites.com>
......@@ -38,7 +38,7 @@ class VolumeSlider;
class MediaControlView : public BBox
{
public:
MediaControlView( BRect frame, intf_thread_t *p_intf );
MediaControlView( intf_thread_t * p_intf, BRect frame );
virtual ~MediaControlView();
// BBox
......@@ -70,6 +70,7 @@ class MediaControlView : public BBox
bool resizeWidth = false,
bool resizeHeight = false) const;
intf_thread_t * p_intf;
VolumeSlider* fVolumeSlider;
SeekSlider* fSeekSlider;
......@@ -88,7 +89,6 @@ class MediaControlView : public BBox
BRect fOldBounds;
bool fIsEnabled;
intf_thread_t * p_intf;
};
class SeekSlider : public BControl
......
modules/gui/beos/MessagesWindow.cpp
View file @ 254f695e
......@@ -2,7 +2,7 @@
* MessagesWindow.cpp: beos interface
*****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN
* $Id: MessagesWindow.cpp,v 1.12 2004/01/26 16:52:31 zorglub Exp $
* $Id$
*
* Authors: Eric Petit <titer@videolan.org>
*
......@@ -30,7 +30,6 @@
#include <vlc/intf.h>
/* BeOS module headers */
#include "VlcWrapper.h"
#include "InterfaceWindow.h"
#include "MessagesWindow.h"
......@@ -39,6 +38,7 @@
*****************************************************************************/
void MessagesView::Pulse()
{
#if 0
bool isScrolling = false;
if( fScrollBar->LockLooper() )
{
......@@ -123,6 +123,7 @@ void MessagesView::Pulse()
}
BTextView::Pulse();
#endif
}
/*****************************************************************************
......
modules/gui/beos/MessagesWindow.h
View file @ 254f695e
......@@ -2,7 +2,7 @@
* MessagesWindow.h
*****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN
* $Id: MessagesWindow.h,v 1.4 2003/05/17 18:30:41 titer Exp $
* $Id$
*
* Authors: Eric Petit <titer@videolan.org>
*
......@@ -36,7 +36,6 @@ class MessagesView : public BTextView
resizingMode, flags )
{
p_intf = _p_intf;
p_sub = ((intf_sys_t*)p_intf->p_sys)->p_sub;
}
virtual void Pulse();
......
modules/gui/beos/Modules.am
View file @ 254f695e
......@@ -19,8 +19,6 @@ SOURCES_beos = \
MessagesWindow.h \
MediaControlView.cpp \
MediaControlView.h \
VlcWrapper.cpp \
VlcWrapper.h \
Bitmaps.h \
MsgVals.h \
VideoWindow.h \
......
modules/gui/beos/PlayListWindow.cpp
View file @ 254f695e
......@@ -2,7 +2,7 @@
* PlayListWindow.cpp: beos interface
*****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN
* $Id: PlayListWindow.cpp,v 1.10 2004/01/26 16:52:31 zorglub Exp $
* $Id$
*
* Authors: Jean-Marc Dressler <polux@via.ecp.fr>
* Samuel Hocevar <sam@zoy.org>
......@@ -35,7 +35,6 @@
#include <vlc/intf.h>
/* BeOS interface headers */
#include "VlcWrapper.h"
#include "InterfaceWindow.h"
#include "ListViews.h"
#include "MsgVals.h"
......@@ -67,8 +66,12 @@ PlayListWindow::PlayListWindow( BRect frame, const char* name,
B_WILL_ACCEPT_FIRST_CLICK | B_ASYNCHRONOUS_CONTROLS ),
fMainWindow( mainWindow )
{
char psz_tmp[1024];
#define ADD_ELLIPSIS( a ) \
memset( psz_tmp, 0, 1024 ); \
snprintf( psz_tmp, 1024, "%s%s", a, B_UTF8_ELLIPSIS );
p_intf = p_interface;
p_wrapper = p_intf->p_sys->p_wrapper;
SetName( _("playlist") );
......@@ -81,8 +84,8 @@ PlayListWindow::PlayListWindow( BRect frame, const char* name,
// Add the File menu
BMenu *fileMenu = new BMenu( _("File") );
fMenuBar->AddItem( fileMenu );
BMenuItem* item = new BMenuItem( _AddEllipsis(_("Open File")),
new BMessage( OPEN_FILE ), 'O' );
ADD_ELLIPSIS( _("Open File") );
BMenuItem* item = new BMenuItem( psz_tmp, new BMessage( OPEN_FILE ), 'O' );
item->SetTarget( fMainWindow );
fileMenu->AddItem( item );
......@@ -154,7 +157,7 @@ fRandomizeMI->SetEnabled( false );
frame.top += fMenuBar->Bounds().IntegerHeight() + 1;
frame.right -= B_V_SCROLL_BAR_WIDTH;
fListView = new PlaylistView( frame, fMainWindow, p_wrapper,
fListView = new PlaylistView( p_intf, frame, fMainWindow,
new BMessage( MSG_SELECTION_CHANGED ) );
fBackgroundView = new BScrollView( "playlist scrollview",
fListView, B_FOLLOW_ALL_SIDES,
......@@ -282,9 +285,10 @@ PlayListWindow::UpdatePlaylist( bool rebuild )
{
if ( rebuild )
fListView->RebuildList();
#if 0
fListView->SetCurrent( p_wrapper->PlaylistCurrent() );
fListView->SetPlaying( p_wrapper->IsPlaying() );
#endif
_CheckItemsEnableState();
}
......
modules/gui/beos/PlayListWindow.h
View file @ 254f695e
......@@ -2,7 +2,7 @@
* PlayListWindow.h: BeOS interface window class prototype
*****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN
* $Id: PlayListWindow.h,v 1.8 2004/01/26 16:52:31 zorglub Exp $
* $Id$
*
* Authors: Jean-Marc Dressler <polux@via.ecp.fr>
* Tony Castley <tcastley@mail.powerup.com.au>
......@@ -75,7 +75,6 @@ class PlayListWindow : public BWindow
BMenu* fViewMenu;
intf_thread_t * p_intf;
VlcWrapper * p_wrapper;
};
#endif // BEOS_PLAY_LIST_WINDOW_H
......
modules/gui/beos/VlcWrapper.cpp deleted 100644 → 0
View file @ 4632a220
/*****************************************************************************
* VlcWrapper.cpp: BeOS plugin for vlc (derived from MacOS X port)
*****************************************************************************
* Copyright (C) 2001 VideoLAN
* $Id$
*
* Authors: Florian G. Pflug <fgp@phlo.org>
* Jon Lech Johansen <jon-vl@nanocrew.net>
* Tony Casltey <tony@castley.net>
* Stephan Aßmus <stippi@yellowbites.com>
* Eric Petit <titer@videolan.org>
*
* This program is free software{} you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation{} either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY{} without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program{} if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
*****************************************************************************/
#include <AppKit.h>
#include <InterfaceKit.h>
#include <SupportKit.h>
#include <vlc/vlc.h>
#include <vlc/intf.h>
#include <vlc/vout.h>
#include <vlc/input.h>
extern "C"
{
#include <audio_output.h>
#include <aout_internal.h>
}
#include "VlcWrapper.h"
#include "MsgVals.h"
const char * _AddEllipsis( char * string )
{
char * temp;
temp = (char*) calloc( strlen( string ) + 4, 1 );
sprintf( temp, "%s%s", string, B_UTF8_ELLIPSIS );
return temp;
}
/* constructor */
VlcWrapper::VlcWrapper( intf_thread_t *p_interface )
{
p_intf = p_interface;
p_input = NULL;
p_playlist = (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
FIND_ANYWHERE );
}
/* destructor */
VlcWrapper::~VlcWrapper()
{
if( p_input )
vlc_object_release( p_input );
if( p_playlist )
vlc_object_release( p_playlist );
}
/* UpdateInput: updates p_input */
void VlcWrapper::UpdateInput()
{
if( !p_input )
p_input = (input_thread_t *)vlc_object_find( p_intf, VLC_OBJECT_INPUT,
FIND_ANYWHERE );
if( p_input )
if( p_input->b_dead )
{
vlc_object_release( p_input );
p_input = NULL;
}
}
/***************************
* input infos and control *
***************************/
bool VlcWrapper::HasInput()
{
return ( p_input != NULL );
}
int VlcWrapper::InputStatus()
{
if( !p_input )
{
return -1;
}
return var_GetInteger( p_input, "state" );
}
int VlcWrapper::InputRate()
{
if( !p_input )
{
return INPUT_RATE_DEFAULT;
}
return var_GetInteger( p_input, "rate" );
}
void VlcWrapper::InputSetRate( int rate )
{
if( !p_input )
{
return;
}
var_SetInteger( p_input, "rate", rate );
}
BList * VlcWrapper::GetChannels( int i_cat )
{
if( p_input )
{
unsigned int i;
uint32 what;
const char* fieldName;
switch( i_cat )
{
case AUDIO_ES:
{
what = SELECT_CHANNEL;
fieldName = "channel";
break;
}
case SPU_ES:
{
what = SELECT_SUBTITLE;
fieldName = "subtitle";
break;
}
default:
return NULL;
}
BList *list = new BList();
#if 0
vlc_mutex_lock( &p_input->stream.stream_lock );
/* find which track is currently playing */
es_descriptor_t *p_es = NULL;
for( i = 0; i < p_input->stream.i_selected_es_number; i++ )
{
if( p_input->stream.pp_selected_es[i]->i_cat == i_cat )
p_es = p_input->stream.pp_selected_es[i];
}
/* build a list of all tracks */
BMenuItem *menuItem;
BMessage *message;
char *trackName;
/* "None" */
message = new BMessage( what );
message->AddInt32( fieldName, -1 );
menuItem = new BMenuItem( _("None"), message );
if( !p_es )
menuItem->SetMarked( true );
list->AddItem( menuItem );
for( i = 0; i < p_input->stream.i_es_number; i++ )
{
if( p_input->stream.pp_es[i]->i_cat == i_cat )
{
message = new BMessage( what );
message->AddInt32( fieldName, i );
if( !p_input->stream.pp_es[i]->psz_desc ||
!*p_input->stream.pp_es[i]->psz_desc )
trackName = _("<unknown>");
else
trackName = strdup( p_input->stream.pp_es[i]->psz_desc );
menuItem = new BMenuItem( trackName, message );
if( p_input->stream.pp_es[i] == p_es )
menuItem->SetMarked( true );
list->AddItem( menuItem );
}
}
vlc_mutex_unlock( &p_input->stream.stream_lock );
#endif
return list;
}
return NULL;
}
void VlcWrapper::ToggleLanguage( int i_language )
{
if( i_language < 0 )
var_SetInteger( p_input, "audio-es", -1 ); /* Disable audio */
else
var_SetInteger( p_input, "audio-es", i_language );
}
void VlcWrapper::ToggleSubtitle( int i_subtitle )
{
if( i_subtitle < 0 )
var_SetInteger( p_input, "spu-es", -1 ); /* Disable SPU */
else
var_SetInteger( p_input, "spu-es", i_subtitle );
}
const char * VlcWrapper::GetTimeAsString()
{
static char psz_time[ MSTRTIME_MAX_SIZE ];
if( !p_input )
{
return ("-:--:--");
}
vlc_value_t time;
var_Get( p_input, "time", &time );
mtime_t seconds = time.i_time / 1000000;
sprintf( psz_time, "%d:%02d:%02d",
(int) ( seconds / (60 * 60 ) ),
(int) ( ( seconds / 60 ) % 60 ),
(int) ( seconds % 60 ) );
return psz_time;
}
float VlcWrapper::GetTimeAsFloat()
{
if( !p_input )
{
return 0.0;
}
vlc_value_t pos;
var_Get( p_input, "position", &pos );
return pos.f_float;
}
void VlcWrapper::SetTimeAsFloat( float f_position )
{
if( !p_input )
{
return;
}
vlc_value_t pos;
pos.f_float = f_position / SEEKSLIDER_RANGE;
var_Set( p_input, "position", pos );
}
bool VlcWrapper::IsPlaying()
{
bool playing = false;
if( p_input )
{
switch( var_GetInteger( p_input, "state" ) )
{
case INIT_S:
case PLAYING_S:
playing = true;
break;
default:
break;
}
}
return playing;
}
/************
* playlist *
************/
void VlcWrapper::OpenFiles( BList* o_files, bool replace, int32 index )
{
if ( o_files && o_files->CountItems() > 0)
{
int size = PlaylistSize();
bool wasEmpty = ( size < 1 );
if ( index == -1 )
index = PLAYLIST_END;
int mode = index == PLAYLIST_END ? PLAYLIST_APPEND : PLAYLIST_INSERT;
/* delete current playlist */
if( replace )
{
for( int i = 0; i < size; i++ )
{
playlist_Delete( p_playlist, 0 );
}
}
/* insert files */
int32 count = o_files->CountItems();
for ( int32 i = count - 1; i >= 0; i-- )
{
if ( BString* o_file = (BString *)o_files->RemoveItem( i ) )
{
playlist_Add( p_playlist, o_file->String(),
o_file->String(), mode, index );
if ( mode == PLAYLIST_INSERT )
index++;
delete o_file;
}
}
// TODO: implement a user setting
// if to start automatically
/* eventually restart playing */
if( replace || wasEmpty )
{
playlist_Stop( p_playlist );
playlist_Play( p_playlist );
}
}
}
void VlcWrapper::OpenDisc(BString o_type, BString o_device, int i_title, int i_chapter)
{
if( config_GetInt( p_intf, "beos-dvdmenus" ) )
o_device.Prepend( "dvdplay:" );
else
o_device.Prepend( "dvdold:" );
playlist_Add( p_playlist, o_device.String(), o_device.String(),
PLAYLIST_APPEND | PLAYLIST_GO, PLAYLIST_END );
}
int VlcWrapper::PlaylistSize()
{
vlc_mutex_lock( &p_playlist->object_lock );
int i_size = p_playlist->i_size;
vlc_mutex_unlock( &p_playlist->object_lock );
return i_size;
}
char * VlcWrapper::PlaylistItemName( int i )
{
return p_playlist->pp_items[i]->input.psz_name;
}
int VlcWrapper::PlaylistCurrent()
{
return p_playlist->i_index;
}
bool VlcWrapper::PlaylistPlay()
{
if( PlaylistSize() )
{
playlist_Play( p_playlist );
}
return( true );
}
void VlcWrapper::PlaylistPause()
{
if( p_input )
{
var_SetInteger( p_input, "state", PAUSE_S );
}
}
void VlcWrapper::PlaylistStop()
{
playlist_Stop( p_playlist );
}
void VlcWrapper::PlaylistNext()
{
playlist_Next( p_playlist );
}
void VlcWrapper::PlaylistPrev()
{
playlist_Prev( p_playlist );
}
void VlcWrapper::GetPlaylistInfo( int32& currentIndex, int32& maxIndex )
{
currentIndex = -1;
maxIndex = -1;
if ( p_playlist )
{
vlc_mutex_lock( &p_playlist->object_lock );
maxIndex = p_playlist->i_size;
if ( maxIndex > 0 )
currentIndex = p_playlist->i_index/* + 1 -> why?!?*/;
else
maxIndex = -1;
vlc_mutex_unlock( &p_playlist->object_lock );
}
}
void VlcWrapper::PlaylistJumpTo( int pos )
{
playlist_Goto( p_playlist, pos );
}
void VlcWrapper::GetNavCapabilities( bool *canSkipPrev, bool *canSkipNext )
{
if ( canSkipPrev && canSkipNext )
{
// init the parameters
*canSkipPrev = false;
*canSkipNext = false;
// get playlist info
int pos = PlaylistCurrent();
int size = PlaylistSize();
// see if we have got a stream going
if ( p_input )
{
#if 0
vlc_mutex_lock( &p_input->stream.stream_lock );
bool hasTitles = p_input->stream.i_area_nb > 1;
int numChapters = p_input->stream.p_selected_area->i_part_nb;
bool hasChapters = numChapters > 1;
// first, look for chapters
if ( hasChapters )
{
*canSkipPrev = p_input->stream.p_selected_area->i_part > 0;
*canSkipNext = p_input->stream.p_selected_area->i_part <
p_input->stream.p_selected_area->i_part_nb - 1;
}
// if one of the skip capabilities is false,
// make it depend on titles instead
if ( !*canSkipPrev && hasTitles )
*canSkipPrev = p_input->stream.p_selected_area->i_id > 1;
if ( !*canSkipNext && hasTitles )
*canSkipNext = p_input->stream.p_selected_area->i_id <
p_input->stream.i_area_nb - 1;
vlc_mutex_unlock( &p_input->stream.stream_lock );
#endif
}
// last but not least, make capabilities depend on playlist
if ( !*canSkipPrev )
*canSkipPrev = pos > 0;
if ( !*canSkipNext )
*canSkipNext = pos < size - 1;
}
}
void VlcWrapper::NavigatePrev()
{
bool hasSkiped = false;
// see if we have got a stream going
if ( p_input )
{
#if 0
// get information from stream (lock it while looking at it)
vlc_mutex_lock( &p_input->stream.stream_lock );
int currentTitle = p_input->stream.p_selected_area->i_id;
int currentChapter = p_input->stream.p_selected_area->i_part;
int numTitles = p_input->stream.i_area_nb;
bool hasTitles = numTitles > 1;
int numChapters = p_input->stream.p_selected_area->i_part_nb;
bool hasChapters = numChapters > 1;
vlc_mutex_unlock( &p_input->stream.stream_lock );
// first, look for chapters
if ( hasChapters )
{
// skip to the previous chapter
currentChapter--;
if ( currentChapter >= 0 )
{
ToggleChapter( currentChapter );
hasSkiped = true;
}
}
// if we couldn't skip chapters, try titles instead
if ( !hasSkiped && hasTitles )
{
// skip to the previous title
currentTitle--;
// disallow area 0 since it is used for video_ts.vob
if( currentTitle > 0 )
{
ToggleTitle(currentTitle);
hasSkiped = true;
}
}
#endif
}
// last but not least, skip to previous file
if ( !hasSkiped )
PlaylistPrev();
}
void VlcWrapper::NavigateNext()
{
bool hasSkiped = false;
// see if we have got a stream going
if ( p_input )
{
#if 0
// get information from stream (lock it while looking at it)
vlc_mutex_lock( &p_input->stream.stream_lock );
int currentTitle = p_input->stream.p_selected_area->i_id;
int currentChapter = p_input->stream.p_selected_area->i_part;
int numTitles = p_input->stream.i_area_nb;
bool hasTitles = numTitles > 1;
int numChapters = p_input->stream.p_selected_area->i_part_nb;
bool hasChapters = numChapters > 1;
vlc_mutex_unlock( &p_input->stream.stream_lock );
// first, look for chapters
if ( hasChapters )
{
// skip to the next chapter
currentChapter++;
if ( currentChapter < numChapters )
{
ToggleChapter( currentChapter );
hasSkiped = true;
}
}
// if we couldn't skip chapters, try titles instead
if ( !hasSkiped && hasTitles )
{
// skip to the next title
currentTitle++;
// disallow area 0 since it is used for video_ts.vob
if ( currentTitle < numTitles - 1 )
{
ToggleTitle(currentTitle);
hasSkiped = true;
}
}
#endif
}
// last but not least, skip to next file
if ( !hasSkiped )
PlaylistNext();
}
/*************************
* Playlist manipulation *
*************************/
// PlaylistLock
bool
VlcWrapper::PlaylistLock() const
{
// TODO: search and destroy -> deadlock!
return true;
if ( p_playlist )
{
vlc_mutex_lock( &p_playlist->object_lock );
return true;
}
return false;
}
// PlaylistUnlock
void
VlcWrapper::PlaylistUnlock() const
{
// TODO: search and destroy -> deadlock!
return;
vlc_mutex_unlock( &p_playlist->object_lock );
}
// PlaylistItemAt
void*
VlcWrapper::PlaylistItemAt( int index ) const
{
playlist_item_t* item = NULL;
if ( index >= 0 && index < p_playlist->i_size )
item = p_playlist->pp_items[index];
return (void*)item;
}
// PlaylistRemoveItem
void*
VlcWrapper::PlaylistRemoveItem( int index ) const
{
playlist_item_t* copy = NULL;
// check if item exists at the provided index
if ( index >= 0 && index < p_playlist->i_size )
{
playlist_item_t* item = p_playlist->pp_items[index];
if ( item )
{
// make a copy of the removed item
copy = (playlist_item_t*)PlaylistCloneItem( (void*)item );
// remove item from playlist (unfortunately, this frees it)
playlist_Delete( p_playlist, index );
}
}
return (void*)copy;
}
// PlaylistRemoveItem
void*
VlcWrapper::PlaylistRemoveItem( void* item ) const
{
playlist_item_t* copy = NULL;
for ( int32 i = 0; i < p_playlist->i_size; i++ )
{
if ( p_playlist->pp_items[i] == item )
{
copy = (playlist_item_t*)PlaylistRemoveItem( i );
break;
}
}
return (void*)copy;
}
// PlaylistAddItem
bool
VlcWrapper::PlaylistAddItem( void* item, int index ) const
{
if ( item )
{
playlist_AddItem( p_playlist, (playlist_item_t*)item,
PLAYLIST_INSERT, index );
}
// TODO: once playlist is returning useful info, return that instead
return true;
}
// PlaylistCloneItem
void*
VlcWrapper::PlaylistCloneItem( void* castToItem ) const
{
playlist_item_t* copy = NULL;
playlist_item_t* item = (playlist_item_t*)castToItem;
if ( item )
{
copy = (playlist_item_t*)malloc( sizeof( playlist_item_t ) );
if ( copy )
{
// make a copy of the item at index
*copy = *item;
copy->input.psz_name = strdup( item->input.psz_name );
copy->input.psz_uri = strdup( item->input.psz_uri );
}
}
return (void*)copy;
}
// Careful! You need to know what you're doing here!
// The reason for having it, is to be able to deal with
// the rather lame list implementation of the playlist.
// It is meant to help manipulate the playlist with the above
// methods while keeping it valid.
//
// PlaylistSetPlaying
void
VlcWrapper::PlaylistSetPlaying( int index ) const
{
if ( index < 0 )
index = 0;
if ( index >= p_playlist->i_size )
index = p_playlist->i_size - 1;
p_playlist->i_index = index;
}
/*********
* audio *
*********/
unsigned short VlcWrapper::GetVolume()
{
unsigned short i_volume;
aout_VolumeGet( p_intf, (audio_volume_t*)&i_volume );
return i_volume;
}
void VlcWrapper::SetVolume( int value )
{
if ( p_intf->p_sys->b_mute )
{
p_intf->p_sys->b_mute = 0;
}
aout_VolumeSet( p_intf, value );
}
void VlcWrapper::VolumeMute()
{
aout_VolumeMute( p_intf, NULL );
p_intf->p_sys->b_mute = 1;
}
void VlcWrapper::VolumeRestore()
{
audio_volume_t dummy;
aout_VolumeMute( p_intf, &dummy );
p_intf->p_sys->b_mute = 0;
}
bool VlcWrapper::IsMuted()
{
return p_intf->p_sys->b_mute;
}
/*******
* DVD *
*******/
bool VlcWrapper::IsUsingMenus()
{
if( !p_input )
return false;
vlc_mutex_lock( &p_playlist->object_lock );
if( p_playlist->i_index < 0 )
{
vlc_mutex_unlock( &p_playlist->object_lock );
return false;
}
char * psz_name = p_playlist->pp_items[p_playlist->i_index]->input.psz_name;
if( !strncmp( psz_name, "dvdplay:", 8 ) )
{
vlc_mutex_unlock( &p_playlist->object_lock );
return true;
}
vlc_mutex_unlock( &p_playlist->object_lock );
return false;
}
bool VlcWrapper::HasTitles()
{
if( !p_input )
return false;
/* FIXME */
return false;
}
BList * VlcWrapper::GetTitles()
{
if( p_input )
{
BList *list = new BList();
#if 0
vlc_mutex_lock( &p_input->stream.stream_lock );
BMenuItem *menuItem;
BMessage *message;
for( unsigned int i = 1; i < p_input->stream.i_area_nb; i++ )
{
message = new BMessage( TOGGLE_TITLE );
message->AddInt32( "index", i );
BString helper( "" );
helper << i;
menuItem = new BMenuItem( helper.String(), message );
menuItem->SetMarked( p_input->stream.p_selected_area->i_id == i );
list->AddItem( menuItem );
}
vlc_mutex_unlock( &p_input->stream.stream_lock );
#endif
return list;
}
return NULL;
}
void VlcWrapper::PrevTitle()
{
var_SetVoid( p_input, "prev-title" );
}
void VlcWrapper::NextTitle()
{
var_SetVoid( p_input, "next-title" );
}
void VlcWrapper::ToggleTitle(int i_title)
{
if( p_input != NULL )
{
var_SetInteger( p_input, "title", i_title );
}
}
void VlcWrapper::TitleInfo( int32 &currentIndex, int32 &maxIndex )
{
currentIndex = -1;
maxIndex = -1;
if ( p_input )
{
#if 0
vlc_mutex_lock( &p_input->stream.stream_lock );
maxIndex = p_input->stream.i_area_nb - 1;
if ( maxIndex > 0)
currentIndex = p_input->stream.p_selected_area->i_id;
else
maxIndex = -1;
vlc_mutex_unlock( &p_input->stream.stream_lock );
#endif
}
}
bool VlcWrapper::HasChapters()
{
if( !p_input )
{
return false;
}
/* FIXME */
return false;
}
BList * VlcWrapper::GetChapters()
{
if( p_input )
{
BList *list = new BList();
#if 0
vlc_mutex_lock( &p_input->stream.stream_lock );
BMenuItem *menuItem;
BMessage *message;
for( unsigned int i = 1;
i < p_input->stream.p_selected_area->i_part_nb + 1; i++ )
{
message = new BMessage( TOGGLE_CHAPTER );
message->AddInt32( "index", i );
BString helper( "" );
helper << i;
menuItem = new BMenuItem( helper.String(), message );
menuItem->SetMarked( p_input->stream.p_selected_area->i_part == i );
list->AddItem( menuItem );
}
vlc_mutex_unlock( &p_input->stream.stream_lock );
#endif
return list;
}
return NULL;
}
void VlcWrapper::PrevChapter()
{
var_SetVoid( p_input, "prev-chapter" );
}
void VlcWrapper::NextChapter()
{
var_SetVoid( p_input, "next-chapter" );
}
void VlcWrapper::ToggleChapter(int i_chapter)
{
if( p_input != NULL )
{
var_SetInteger( p_input, "chapter", i_chapter );
}
}
void VlcWrapper::ChapterInfo( int32 &currentIndex, int32 &maxIndex )
{
currentIndex = -1;
maxIndex = -1;
if ( p_input )
{
#if 0
vlc_mutex_lock( &p_input->stream.stream_lock );
maxIndex = p_input->stream.p_selected_area->i_part_nb - 1;
if ( maxIndex > 0)
currentIndex = p_input->stream.p_selected_area->i_part;
else
maxIndex = -1;
vlc_mutex_unlock( &p_input->stream.stream_lock );
#endif
}
}
/****************
* Miscellanous *
****************/
void VlcWrapper::LoadSubFile( const char * psz_file )
{
config_PutPsz( p_intf, "sub-file", strdup( psz_file ) );
}
void VlcWrapper::FilterChange()
{
if( !p_input )
return;
#if 0
vout_thread_t * p_vout;
vlc_mutex_lock( &p_input->stream.stream_lock );
// Warn the vout we are about to change the filter chain
p_vout = (vout_thread_t*)vlc_object_find( p_intf, VLC_OBJECT_VOUT,
FIND_ANYWHERE );
if( p_vout )
{
p_vout->b_filter_change = VLC_TRUE;
vlc_object_release( p_vout );
}
// restart all video stream
for( unsigned int i = 0; i < p_input->stream.i_es_number; i++ )
{
if( ( p_input->stream.pp_es[i]->i_cat == VIDEO_ES ) &&
( p_input->stream.pp_es[i]->p_dec != NULL ) )
{
input_UnselectES( p_input, p_input->stream.pp_es[i] );
input_SelectES( p_input, p_input->stream.pp_es[i] );
}
}
vlc_mutex_unlock( &p_input->stream.stream_lock );
#endif
}
modules/gui/beos/VlcWrapper.h deleted 100644 → 0
View file @ 4632a220
/*****************************************************************************
* VlcWrapper.h: BeOS plugin for vlc (derived from MacOS X port)
*****************************************************************************
* Copyright (C) 2001 VideoLAN
* $Id: VlcWrapper.h,v 1.26 2003/06/22 00:40:18 titer Exp $
*
* Authors: Florian G. Pflug <fgp@phlo.org>
* Jon Lech Johansen <jon-vl@nanocrew.net>
* Tony Castley <tony@castley.net>
* Stephan Aßmus <stippi@yellowbites.com>
* Eric Petit <titer@videolan.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
*****************************************************************************/
#include <SupportKit.h>
#define SEEKSLIDER_RANGE 2048
class InterfaceWindow;
class VlcWrapper;
/*****************************************************************************
* intf_sys_t: internal variables of the BeOS interface
*****************************************************************************/
struct intf_sys_t
{
msg_subscription_t * p_sub;
InterfaceWindow * p_window;
vlc_bool_t b_loop;
vlc_bool_t b_mute;
int i_part;
int i_channel;
VlcWrapper * p_wrapper;
};
/* Necessary because of i18n */
const char * _AddEllipsis( char * string );
/*****************************************************************************
* VlcWrapper
*****************************************************************************
* This class makes the link between the BeOS interface and the vlc core.
* There is only one VlcWrapper instance at any time, which is stored
* in p_intf->p_sys->p_wrapper
*****************************************************************************/
class VlcWrapper
{
public:
VlcWrapper( intf_thread_t *p_intf );
~VlcWrapper();
/* Input */
void UpdateInput();
bool HasInput();
int InputStatus();
int InputRate();
void InputSetRate( int rate );
BList * GetChannels( int i_cat );
void ToggleLanguage( int i_language );
void ToggleSubtitle( int i_subtitle );
const char * GetTimeAsString();
float GetTimeAsFloat();
void SetTimeAsFloat( float i_offset );
bool IsPlaying();
/* Playlist */
void OpenFiles( BList *o_files, bool replace = true,
int32 index = -1 );
void OpenDisc( BString o_type, BString o_device,
int i_title, int i_chapter );
int PlaylistSize();
char * PlaylistItemName( int );
int PlaylistCurrent();
bool PlaylistPlay();
void PlaylistPause();
void PlaylistStop();
void PlaylistNext();
void PlaylistPrev();
bool PlaylistPlaying();
void GetPlaylistInfo( int32& currentIndex,
int32& maxIndex );
void PlaylistJumpTo( int );
void GetNavCapabilities( bool * canSkipPrev,
bool * canSkipNext );
void NavigatePrev();
void NavigateNext();
/* Playlist manipulation */
bool PlaylistLock() const;
void PlaylistUnlock() const;
// playlist must be locked prior to calling all of these!
void* PlaylistItemAt( int index ) const;
// both functions return a copy of the removed item
// so that it can be added at another index
void* PlaylistRemoveItem( int index ) const;
void* PlaylistRemoveItem( void* item ) const;
// uses playlist_AddItem()
bool PlaylistAddItem( void* item, int index ) const;
void* PlaylistCloneItem( void* item ) const;
// only modifies playlist, doesn't effect playback
void PlaylistSetPlaying( int index ) const;
/* Audio */
unsigned short GetVolume();
void SetVolume( int value );
void VolumeMute();
void VolumeRestore();
bool IsMuted();
/* DVD */
bool IsUsingMenus();
bool HasTitles();
BList * GetTitles();
void PrevTitle();
void NextTitle();
void ToggleTitle( int i_title );
void TitleInfo( int32& currentIndex, int32& maxIndex );
bool HasChapters();
BList * GetChapters();
void PrevChapter();
void NextChapter();
void ToggleChapter( int i_chapter );
void ChapterInfo( int32& currentIndex, int32& maxIndex );
/* Miscellanous */
void LoadSubFile( const char * psz_file );
void FilterChange();
private:
intf_thread_t * p_intf;
input_thread_t * p_input;
playlist_t * p_playlist;
};
src/libvlc.h
View file @ 254f695e
......@@ -1065,7 +1065,7 @@ vlc_module_begin();
#else
# define KEY_FULLSCREEN 'f'
# define KEY_PLAY_PAUSE ' '
# define KEY_PLAY_PAUSE KEY_SPACE
# define KEY_PAUSE KEY_UNSET
# define KEY_PLAY KEY_UNSET
# define KEY_FASTER '+'
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment