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 @@ ...@@ -2,7 +2,7 @@
* intf_beos.cpp: beos interface * intf_beos.cpp: beos interface
***************************************************************************** *****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN * 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> * Authors: Jean-Marc Dressler <polux@via.ecp.fr>
* Samuel Hocevar <sam@zoy.org> * Samuel Hocevar <sam@zoy.org>
...@@ -41,10 +41,17 @@ ...@@ -41,10 +41,17 @@
#include <vlc/aout.h> #include <vlc/aout.h>
#include <aout_internal.h> #include <aout_internal.h>
#include "VlcWrapper.h"
#include "InterfaceWindow.h" #include "InterfaceWindow.h"
#include "MsgVals.h" #include "MsgVals.h"
/*****************************************************************************
* intf_sys_t: internal variables of the BeOS interface
*****************************************************************************/
struct intf_sys_t
{
InterfaceWindow * p_window;
};
/***************************************************************************** /*****************************************************************************
* Local prototype * Local prototype
*****************************************************************************/ *****************************************************************************/
...@@ -59,44 +66,36 @@ int E_(OpenIntf) ( vlc_object_t *p_this ) ...@@ -59,44 +66,36 @@ int E_(OpenIntf) ( vlc_object_t *p_this )
/* Allocate instance and initialize some members */ /* Allocate instance and initialize some members */
p_intf->p_sys = (intf_sys_t*) malloc( sizeof( intf_sys_t ) ); 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" ); 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; p_intf->pf_run = Run;
/* Create the interface window */ /* Create the interface window */
BScreen screen(B_MAIN_SCREEN_ID); BScreen screen( B_MAIN_SCREEN_ID );
BRect rect = screen.Frame(); BRect rect = screen.Frame();
rect.top = rect.bottom-100; rect.top = rect.bottom - 100;
rect.bottom -= 50; rect.bottom -= 50;
rect.left += 50; rect.left += 50;
rect.right = rect.left + 350; rect.right = rect.left + 350;
p_intf->p_sys->p_window = p_intf->p_sys->p_window =
new InterfaceWindow( rect, new InterfaceWindow( p_intf, rect, "VLC " VERSION );
"VLC " PACKAGE_VERSION, if( !p_intf->p_sys->p_window )
p_intf );
if( p_intf->p_sys->p_window == 0 )
{ {
free( p_intf->p_sys ); free( p_intf->p_sys );
msg_Err( p_intf, "cannot allocate InterfaceWindow" ); msg_Err( p_intf, "cannot allocate InterfaceWindow" );
return( 1 ); return VLC_EGENERIC;
} }
else
{
/* Make the be_app aware the interface has been created */ /* Make the be_app aware the interface has been created */
BMessage message(INTERFACE_CREATED); BMessage message( INTERFACE_CREATED );
message.AddPointer("window", p_intf->p_sys->p_window); message.AddPointer( "window", p_intf->p_sys->p_window );
be_app->PostMessage(&message); be_app->PostMessage( &message );
}
p_intf->p_sys->b_loop = 0;
p_intf->p_sys->b_mute = 0;
return( 0 ); return VLC_SUCCESS;
} }
/***************************************************************************** /*****************************************************************************
...@@ -106,14 +105,11 @@ void E_(CloseIntf) ( vlc_object_t *p_this ) ...@@ -106,14 +105,11 @@ void E_(CloseIntf) ( vlc_object_t *p_this )
{ {
intf_thread_t *p_intf = (intf_thread_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 */ /* Destroy the interface window */
if( p_intf->p_sys->p_window->Lock() ) if( p_intf->p_sys->p_window->Lock() )
p_intf->p_sys->p_window->Quit(); p_intf->p_sys->p_window->Quit();
/* Destroy structure */ /* Destroy structure */
delete p_intf->p_sys->p_wrapper;
free( p_intf->p_sys ); free( p_intf->p_sys );
} }
...@@ -125,13 +121,7 @@ static void Run( intf_thread_t *p_intf ) ...@@ -125,13 +121,7 @@ static void Run( intf_thread_t *p_intf )
{ {
while( !p_intf->b_die ) 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(); p_intf->p_sys->p_window->UpdateInterface();
/* Wait a bit */
msleep( INTF_IDLE_SLEEP ); msleep( INTF_IDLE_SLEEP );
} }
} }
modules/gui/beos/InterfaceWindow.cpp
View file @ 254f695e
...@@ -44,7 +44,6 @@ ...@@ -44,7 +44,6 @@
#include <vlc/input.h> #include <vlc/input.h>
/* BeOS interface headers */ /* BeOS interface headers */
#include "VlcWrapper.h"
#include "MsgVals.h" #include "MsgVals.h"
#include "MediaControlView.h" #include "MediaControlView.h"
#include "PlayListWindow.h" #include "PlayListWindow.h"
...@@ -180,17 +179,24 @@ collect_folder_contents( BDirectory& dir, BList& list, bool& deep, bool& asked, ...@@ -180,17 +179,24 @@ collect_folder_contents( BDirectory& dir, BList& list, bool& deep, bool& asked,
* InterfaceWindow * InterfaceWindow
*****************************************************************************/ *****************************************************************************/
InterfaceWindow::InterfaceWindow( BRect frame, const char* name, InterfaceWindow::InterfaceWindow( intf_thread_t * _p_intf, BRect frame,
intf_thread_t* p_interface ) const char * name )
: BWindow( frame, name, B_TITLED_WINDOW_LOOK, B_NORMAL_WINDOW_FEEL, : BWindow( frame, name, B_TITLED_WINDOW_LOOK, B_NORMAL_WINDOW_FEEL,
B_NOT_ZOOMABLE | B_WILL_ACCEPT_FIRST_CLICK | B_ASYNCHRONOUS_CONTROLS ), 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 ), fFilePanel( NULL ),
fLastUpdateTime( system_time() ), fLastUpdateTime( system_time() ),
fSettings( new BMessage( 'sett' ) ), fSettings( new BMessage( 'sett' ) )
p_wrapper( p_intf->p_sys->p_wrapper )
{ {
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; BScreen screen;
BRect screen_rect = screen.Frame(); BRect screen_rect = screen.Frame();
...@@ -212,8 +218,7 @@ InterfaceWindow::InterfaceWindow( BRect frame, const char* name, ...@@ -212,8 +218,7 @@ InterfaceWindow::InterfaceWindow( BRect frame, const char* name,
fMessagesWindow = new MessagesWindow( p_intf, window_rect, _("Messages") ); fMessagesWindow = new MessagesWindow( p_intf, window_rect, _("Messages") );
// the media control view // the media control view
p_mediaControl = new MediaControlView( BRect( 0.0, 0.0, 250.0, 50.0 ), p_mediaControl = new MediaControlView( p_intf, BRect( 0.0, 0.0, 250.0, 50.0 ) );
p_intf );
p_mediaControl->SetViewColor( ui_color( B_PANEL_BACKGROUND_COLOR ) ); p_mediaControl->SetViewColor( ui_color( B_PANEL_BACKGROUND_COLOR ) );
float width, height; float width, height;
...@@ -234,26 +239,25 @@ InterfaceWindow::InterfaceWindow( BRect frame, const char* name, ...@@ -234,26 +239,25 @@ InterfaceWindow::InterfaceWindow( BRect frame, const char* name,
p_mediaControl->MoveTo( fMenuBar->Bounds().LeftBottom() + BPoint(0.0, 1.0) ); p_mediaControl->MoveTo( fMenuBar->Bounds().LeftBottom() + BPoint(0.0, 1.0) );
AddChild( fMenuBar ); AddChild( fMenuBar );
// Add the file Menu // Add the file Menu
BMenu* fileMenu = new BMenu( _("File") ); BMenu* fileMenu = new BMenu( _("File") );
fMenuBar->AddItem( fileMenu ); fMenuBar->AddItem( fileMenu );
fileMenu->AddItem( new BMenuItem( _AddEllipsis(_("Open File")), ADD_ELLIPSIS( _("Open File") );
new BMessage( OPEN_FILE ), 'O') ); fileMenu->AddItem( new BMenuItem( psz_tmp, new BMessage( OPEN_FILE ), 'O') );
fileMenu->AddItem( new CDMenu( _("Open Disc") ) ); fileMenu->AddItem( new CDMenu( _("Open Disc") ) );
ADD_ELLIPSIS( _("Open Subtitles") );
fileMenu->AddItem( new BMenuItem( _AddEllipsis(_("Open Subtitles")), fileMenu->AddItem( new BMenuItem( psz_tmp, new BMessage( LOAD_SUBFILE ) ) );
new BMessage( LOAD_SUBFILE ) ) );
fileMenu->AddSeparatorItem(); fileMenu->AddSeparatorItem();
BMenuItem* item = new BMenuItem( _AddEllipsis(_("About")), ADD_ELLIPSIS( _("About") );
new BMessage( B_ABOUT_REQUESTED ), 'A'); BMenuItem* item = new BMenuItem( psz_tmp, new BMessage( B_ABOUT_REQUESTED ), 'A');
item->SetTarget( be_app ); item->SetTarget( be_app );
fileMenu->AddItem( item ); fileMenu->AddItem( item );
fileMenu->AddItem( new BMenuItem( _("Quit"), new BMessage( B_QUIT_REQUESTED ), 'Q') ); fileMenu->AddItem( new BMenuItem( _("Quit"), new BMessage( B_QUIT_REQUESTED ), 'Q') );
fLanguageMenu = new LanguageMenu( _("Language"), AUDIO_ES, p_wrapper); fLanguageMenu = new LanguageMenu( p_intf, _("Language"), "audio-es" );
fSubtitlesMenu = new LanguageMenu( _("Subtitles"), SPU_ES, p_wrapper); fSubtitlesMenu = new LanguageMenu( p_intf, _("Subtitles"), "spu-es" );
/* Add the Audio menu */ /* Add the Audio menu */
fAudioMenu = new BMenu( _("Audio") ); fAudioMenu = new BMenu( _("Audio") );
...@@ -301,12 +305,12 @@ InterfaceWindow::InterfaceWindow( BRect frame, const char* name, ...@@ -301,12 +305,12 @@ InterfaceWindow::InterfaceWindow( BRect frame, const char* name,
/* Add the Show menu */ /* Add the Show menu */
fShowMenu = new BMenu( _("Window") ); fShowMenu = new BMenu( _("Window") );
fShowMenu->AddItem( new BMenuItem( _AddEllipsis(_("Playlist")), ADD_ELLIPSIS( _("Playlist") );
new BMessage( OPEN_PLAYLIST ), 'P') ); fShowMenu->AddItem( new BMenuItem( psz_tmp, new BMessage( OPEN_PLAYLIST ), 'P') );
fShowMenu->AddItem( new BMenuItem( _AddEllipsis(_("Messages")), ADD_ELLIPSIS( _("Messages") );
new BMessage( OPEN_MESSAGES ), 'M' ) ); fShowMenu->AddItem( new BMenuItem( psz_tmp, new BMessage( OPEN_MESSAGES ), 'M' ) );
fShowMenu->AddItem( new BMenuItem( _AddEllipsis(_("Preferences")), ADD_ELLIPSIS( _("Preferences") );
new BMessage( OPEN_PREFERENCES ), 'S' ) ); fShowMenu->AddItem( new BMenuItem( psz_tmp, new BMessage( OPEN_PREFERENCES ), 'S' ) );
fMenuBar->AddItem( fShowMenu ); fMenuBar->AddItem( fShowMenu );
// add the media control view after the menubar is complete // add the media control view after the menubar is complete
...@@ -325,15 +329,26 @@ InterfaceWindow::InterfaceWindow( BRect frame, const char* name, ...@@ -325,15 +329,26 @@ InterfaceWindow::InterfaceWindow( BRect frame, const char* name,
InterfaceWindow::~InterfaceWindow() InterfaceWindow::~InterfaceWindow()
{ {
if( p_input )
{
vlc_object_release( p_input );
}
if( p_playlist )
{
vlc_object_release( p_playlist );
}
if( fPlaylistWindow ) if( fPlaylistWindow )
{
fPlaylistWindow->ReallyQuit(); fPlaylistWindow->ReallyQuit();
fPlaylistWindow = NULL; }
if( fMessagesWindow ) if( fMessagesWindow )
{
fMessagesWindow->ReallyQuit(); fMessagesWindow->ReallyQuit();
fMessagesWindow = NULL; }
if( fPreferencesWindow ) if( fPreferencesWindow )
{
fPreferencesWindow->ReallyQuit(); fPreferencesWindow->ReallyQuit();
fPreferencesWindow = NULL; }
delete fFilePanel; delete fFilePanel;
delete fSettings; delete fSettings;
} }
...@@ -357,16 +372,16 @@ InterfaceWindow::FrameResized(float width, float height) ...@@ -357,16 +372,16 @@ InterfaceWindow::FrameResized(float width, float height)
*****************************************************************************/ *****************************************************************************/
void InterfaceWindow::MessageReceived( BMessage * p_message ) void InterfaceWindow::MessageReceived( BMessage * p_message )
{ {
int playback_status; // remember playback state
playback_status = p_wrapper->InputStatus();
switch( p_message->what ) switch( p_message->what )
{ {
case B_ABOUT_REQUESTED: case B_ABOUT_REQUESTED:
{ {
BAlert* alert = new BAlert( "VLC " PACKAGE_VERSION, BAlert * alert;
"VLC " PACKAGE_VERSION " for BeOS"
"\n\n<www.videolan.org>", _("OK")); 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(); alert->Go();
break; break;
} }
...@@ -391,14 +406,18 @@ void InterfaceWindow::MessageReceived( BMessage * p_message ) ...@@ -391,14 +406,18 @@ void InterfaceWindow::MessageReceived( BMessage * p_message )
fPlaylistWindow->Unlock(); fPlaylistWindow->Unlock();
} }
break; break;
case OPEN_DVD: case OPEN_DVD:
{ {
const char *psz_device; const char * psz_device;
BString type( "dvd" ); if( p_playlist &&
if( p_message->FindString( "device", &psz_device ) == B_OK ) p_message->FindString( "device", &psz_device ) == B_OK )
{ {
BString device( psz_device ); char psz_uri[1024];
p_wrapper->OpenDisc( type, device, 0, 0 ); 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(); _UpdatePlaylist();
} }
...@@ -411,167 +430,266 @@ void InterfaceWindow::MessageReceived( BMessage * p_message ) ...@@ -411,167 +430,266 @@ void InterfaceWindow::MessageReceived( BMessage * p_message )
{ {
BPath path( &ref ); BPath path( &ref );
if ( path.InitCheck() == B_OK ) if ( path.InitCheck() == B_OK )
p_wrapper->LoadSubFile( path.Path() ); config_PutPsz( p_intf, "sub-file", path.Path() );
} }
break; break;
} }
case STOP_PLAYBACK: case STOP_PLAYBACK:
// this currently stops playback not nicely if( p_playlist )
if (playback_status != -1)
{ {
p_wrapper->PlaylistStop(); playlist_Stop( p_playlist );
p_mediaControl->SetStatus(-1, INPUT_RATE_DEFAULT);
} }
p_mediaControl->SetStatus(-1, INPUT_RATE_DEFAULT);
break; break;
case START_PLAYBACK: case START_PLAYBACK:
/* starts playing in normal mode */ /* starts playing in normal mode */
case PAUSE_PLAYBACK: case PAUSE_PLAYBACK:
/* toggle between pause and play */ if( p_input )
if (playback_status > -1)
{ {
/* pause if currently playing */ if( var_GetInteger( p_input, "state" ) == PAUSE_S )
if ( playback_status == PLAYING_S )
{ {
p_wrapper->PlaylistPause(); if( p_playlist )
}
else
{ {
p_wrapper->PlaylistPlay(); playlist_Play( p_playlist );
} }
} }
else else
{ {
/* Play a new file */ var_SetInteger( p_input, "state", PAUSE_S );
p_wrapper->PlaylistPlay(); }
} }
break; break;
case HEIGHTH_PLAY: case HEIGHTH_PLAY:
p_wrapper->InputSetRate( INPUT_RATE_DEFAULT * 8 ); if( p_input )
{
var_SetInteger( p_input, "rate", INPUT_RATE_DEFAULT * 8 );
}
break; break;
case QUARTER_PLAY: case QUARTER_PLAY:
p_wrapper->InputSetRate( INPUT_RATE_DEFAULT * 4 ); if( p_input )
{
var_SetInteger( p_input, "rate", INPUT_RATE_DEFAULT * 4 );
}
break; break;
case HALF_PLAY: case HALF_PLAY:
p_wrapper->InputSetRate( INPUT_RATE_DEFAULT * 2 ); if( p_input )
{
var_SetInteger( p_input, "rate", INPUT_RATE_DEFAULT * 2 );
}
break; break;
case NORMAL_PLAY: case NORMAL_PLAY:
p_wrapper->InputSetRate( INPUT_RATE_DEFAULT ); if( p_input )
{
var_SetInteger( p_input, "rate", INPUT_RATE_DEFAULT );
}
break; break;
case TWICE_PLAY: case TWICE_PLAY:
p_wrapper->InputSetRate( INPUT_RATE_DEFAULT / 2 ); if( p_input )
{
var_SetInteger( p_input, "rate", INPUT_RATE_DEFAULT / 2 );
}
break; break;
case FOUR_PLAY: case FOUR_PLAY:
p_wrapper->InputSetRate( INPUT_RATE_DEFAULT / 4 ); if( p_input )
{
var_SetInteger( p_input, "rate", INPUT_RATE_DEFAULT / 4 );
}
break; break;
case HEIGHT_PLAY: case HEIGHT_PLAY:
p_wrapper->InputSetRate( INPUT_RATE_DEFAULT / 8 ); if( p_input )
{
var_SetInteger( p_input, "rate", INPUT_RATE_DEFAULT / 8 );
}
break; break;
case SEEK_PLAYBACK: case SEEK_PLAYBACK:
/* handled by semaphores */ /* handled by semaphores */
break; break;
// volume related messages
case VOLUME_CHG: case VOLUME_CHG:
/* adjust the volume */ aout_VolumeSet( p_intf, p_mediaControl->GetVolume() );
if (playback_status > -1)
{
p_wrapper->SetVolume( p_mediaControl->GetVolume() );
p_mediaControl->SetMuted( p_wrapper->IsMuted() );
}
break; break;
case VOLUME_MUTE: case VOLUME_MUTE:
// toggle muting aout_VolumeMute( p_intf, NULL );
if( p_wrapper->IsMuted() )
p_wrapper->VolumeRestore();
else
p_wrapper->VolumeMute();
p_mediaControl->SetMuted( p_wrapper->IsMuted() );
break; break;
case SELECT_CHANNEL: case SELECT_CHANNEL:
if ( playback_status > -1 )
{ {
int32 channel; 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; else if( p_message->FindInt32( "spu-es", &channel ) == B_OK )
case SELECT_SUBTITLE:
if ( playback_status > -1 )
{ {
int32 subtitle; var_SetInteger( p_input, "spu-es", channel );
if ( p_message->FindInt32( "subtitle", &subtitle ) == B_OK ) }
p_wrapper->ToggleSubtitle( subtitle );
} }
break; break;
}
// specific navigation messages
case PREV_TITLE: case PREV_TITLE:
if( p_input )
{ {
p_wrapper->PrevTitle(); var_SetVoid( p_input, "prev-title" );
break;
} }
break;
case NEXT_TITLE: case NEXT_TITLE:
if( p_input )
{ {
p_wrapper->NextTitle(); var_SetVoid( p_input, "next-title" );
break;
} }
break;
case NAVIGATE_MENU: case NAVIGATE_MENU:
p_wrapper->ToggleTitle( 0 ); if( p_input )
{
var_SetInteger( p_input, "title", 0 );
}
break; break;
case TOGGLE_TITLE: case TOGGLE_TITLE:
if ( playback_status > -1 )
{ {
int32 index; int32 index;
if( p_message->FindInt32( "index", &index ) == B_OK ) if( p_input &&
p_wrapper->ToggleTitle( index ); p_message->FindInt32( "index", &index ) == B_OK )
{
var_SetInteger( p_input, "title", index );
} }
break; break;
}
case PREV_CHAPTER: case PREV_CHAPTER:
if( p_input )
{ {
p_wrapper->PrevChapter(); var_SetVoid( p_input, "prev-chapter" );
break;
} }
break;
case NEXT_CHAPTER: case NEXT_CHAPTER:
if( p_input )
{ {
p_wrapper->NextChapter(); var_SetVoid( p_input, "next-chapter" );
break;
} }
break;
case TOGGLE_CHAPTER: case TOGGLE_CHAPTER:
if ( playback_status > -1 )
{ {
int32 index; int32 index;
if( p_message->FindInt32( "index", &index ) == B_OK ) if( p_input &&
p_wrapper->ToggleChapter( index ); p_message->FindInt32( "index", &index ) == B_OK )
{
var_SetInteger( p_input, "chapter", index );
} }
break; break;
}
case PREV_FILE: case PREV_FILE:
p_wrapper->PlaylistPrev(); if( p_playlist )
{
playlist_Prev( p_playlist );
}
break; break;
case NEXT_FILE: case NEXT_FILE:
p_wrapper->PlaylistNext(); if( p_playlist )
{
playlist_Next( p_playlist );
}
break; break;
// general next/prev functionality (skips to whatever makes most sense)
case NAVIGATE_PREV: 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; break;
}
}
/* Try to go to previous file */
if( p_playlist )
{
playlist_Prev( p_playlist );
}
}
break;
case NAVIGATE_NEXT: 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; break;
// drag'n'drop and system messages // drag'n'drop and system messages
case MSG_SOUNDPLAY: case MSG_SOUNDPLAY:
// convert soundplay drag'n'drop message (containing paths) // convert soundplay drag'n'drop message (containing paths)
...@@ -590,101 +708,46 @@ void InterfaceWindow::MessageReceived( BMessage * p_message ) ...@@ -590,101 +708,46 @@ void InterfaceWindow::MessageReceived( BMessage * p_message )
case B_SIMPLE_DATA: case B_SIMPLE_DATA:
{ {
/* file(s) opened by the File menu -> append to the playlist; /* file(s) opened by the File menu -> append to the playlist;
* file(s) opened by drag & drop -> replace playlist; file(s) opened by drag & drop -> replace playlist;
* file(s) opened by 'shift' + drag & drop -> append */ 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;
// if we should parse sub-folders as well
bool askedAlready = false;
bool parseSubFolders = askedAlready;
// traverse refs in reverse order
int32 count; int32 count;
type_code dummy; 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; break;
} }
else
vlc_bool_t b_remove = ( p_message->WasDropped() &&
!( modifiers() & B_SHIFT_KEY ) );
if( b_remove && p_playlist )
{ {
vol.Unset(); /* Empty playlist */
status = volRoster.GetNextVolume( &vol ); while( p_playlist->i_size > 0 )
}
}
}
if ( add )
{ {
add = false; playlist_Delete( p_playlist, 0 );
dir.Rewind(); // defensive programming
BEntry entry;
collect_folder_contents( dir, files,
parseSubFolders,
askedAlready,
entry );
} }
} }
if ( add )
entry_ref ref;
for( int i = 0; p_message->FindRef( "refs", i, &ref ) == B_OK; i++ )
{ {
BString* string = new BString( path.Path() ); BPath path( &ref );
if ( !files.AddItem( string, 0 ) )
delete string; // at least don't leak /* 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(); _UpdatePlaylist();
}
}
break; break;
}
case OPEN_PREFERENCES: case OPEN_PREFERENCES:
{ {
...@@ -718,7 +781,6 @@ void InterfaceWindow::MessageReceived( BMessage * p_message ) ...@@ -718,7 +781,6 @@ void InterfaceWindow::MessageReceived( BMessage * p_message )
BWindow::MessageReceived( p_message ); BWindow::MessageReceived( p_message );
break; break;
} }
} }
/***************************************************************************** /*****************************************************************************
...@@ -726,7 +788,10 @@ void InterfaceWindow::MessageReceived( BMessage * p_message ) ...@@ -726,7 +788,10 @@ void InterfaceWindow::MessageReceived( BMessage * p_message )
*****************************************************************************/ *****************************************************************************/
bool InterfaceWindow::QuitRequested() bool InterfaceWindow::QuitRequested()
{ {
p_wrapper->PlaylistStop(); if( p_playlist )
{
playlist_Stop( p_playlist );
}
p_mediaControl->SetStatus(-1, INPUT_RATE_DEFAULT); p_mediaControl->SetStatus(-1, INPUT_RATE_DEFAULT);
_StoreSettings(); _StoreSettings();
...@@ -741,41 +806,57 @@ bool InterfaceWindow::QuitRequested() ...@@ -741,41 +806,57 @@ bool InterfaceWindow::QuitRequested()
*****************************************************************************/ *****************************************************************************/
void InterfaceWindow::UpdateInterface() 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 ); p_mediaControl->SetEnabled( true );
bool hasTitles = p_wrapper->HasTitles(); bool hasTitles = var_Get( p_input, "title", &val );
bool hasChapters = p_wrapper->HasChapters(); bool hasChapters = var_Get( p_input, "chapter", &val );
p_mediaControl->SetStatus( p_wrapper->InputStatus(), p_mediaControl->SetStatus( var_GetInteger( p_input, "state" ),
p_wrapper->InputRate() ); var_GetInteger( p_input, "rate" ) );
p_mediaControl->SetProgress( p_wrapper->GetTimeAsFloat() ); var_Get( p_input, "position", &val );
p_mediaControl->SetProgress( val.f_float );
_SetMenusEnabled( true, hasChapters, hasTitles ); _SetMenusEnabled( true, hasChapters, hasTitles );
_UpdateSpeedMenu( var_GetInteger( p_input, "rate" ) );
_UpdateSpeedMenu( p_wrapper->InputRate() );
// enable/disable skip buttons // enable/disable skip buttons
#if 0
bool canSkipPrev; bool canSkipPrev;
bool canSkipNext; bool canSkipNext;
p_wrapper->GetNavCapabilities( &canSkipPrev, &canSkipNext ); p_wrapper->GetNavCapabilities( &canSkipPrev, &canSkipNext );
p_mediaControl->SetSkippable( 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->SetAudioEnabled( true );
p_mediaControl->SetMuted( p_wrapper->IsMuted() ); p_mediaControl->SetMuted( i_volume );
} else
p_mediaControl->SetAudioEnabled( false );
Unlock();
}
// update playlist as well // update playlist as well
if ( fPlaylistWindow->LockWithTimeout( INTERFACE_LOCKING_TIMEOUT ) == B_OK ) if( fPlaylistWindow->LockWithTimeout( INTERFACE_LOCKING_TIMEOUT ) == B_OK )
{ {
fPlaylistWindow->UpdatePlaylist(); fPlaylistWindow->UpdatePlaylist();
fPlaylistWindow->Unlock(); fPlaylistWindow->Unlock();
...@@ -783,24 +864,29 @@ void InterfaceWindow::UpdateInterface() ...@@ -783,24 +864,29 @@ void InterfaceWindow::UpdateInterface()
} }
else else
{ {
if ( LockWithTimeout(INTERFACE_LOCKING_TIMEOUT) == B_OK ) p_mediaControl->SetAudioEnabled( false );
{
_SetMenusEnabled( false ); _SetMenusEnabled( false );
if( !( p_wrapper->PlaylistSize() > 0 ) )
p_mediaControl->SetEnabled( false ); if( !p_playlist || p_playlist->i_size <= 0 )
else
{ {
p_mediaControl->SetProgress( 0 ); p_mediaControl->SetProgress( 0 );
#if 0
// enable/disable skip buttons // enable/disable skip buttons
bool canSkipPrev; bool canSkipPrev;
bool canSkipNext; bool canSkipNext;
p_wrapper->GetNavCapabilities( &canSkipPrev, &canSkipNext ); p_wrapper->GetNavCapabilities( &canSkipPrev, &canSkipNext );
p_mediaControl->SetSkippable( canSkipPrev, canSkipNext ); p_mediaControl->SetSkippable( canSkipPrev, canSkipNext );
#endif
} }
Unlock(); else
{
p_mediaControl->SetEnabled( false );
} }
} }
Unlock();
fLastUpdateTime = system_time(); fLastUpdateTime = system_time();
} }
...@@ -819,12 +905,12 @@ InterfaceWindow::IsStopped() const ...@@ -819,12 +905,12 @@ InterfaceWindow::IsStopped() const
void void
InterfaceWindow::_UpdatePlaylist() InterfaceWindow::_UpdatePlaylist()
{ {
if ( fPlaylistWindow->Lock() ) if( fPlaylistWindow->Lock() )
{ {
fPlaylistWindow->UpdatePlaylist( true ); fPlaylistWindow->UpdatePlaylist( true );
fPlaylistWindow->Unlock(); 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 ...@@ -862,10 +948,7 @@ InterfaceWindow::_SetMenusEnabled(bool hasFile, bool hasChapters, bool hasTitles
fSubtitlesMenu->SetEnabled( hasFile ); fSubtitlesMenu->SetEnabled( hasFile );
if ( fSpeedMenu->IsEnabled() != hasFile ) if ( fSpeedMenu->IsEnabled() != hasFile )
fSpeedMenu->SetEnabled( hasFile ); fSpeedMenu->SetEnabled( hasFile );
// "goto menu" menu item fGotoMenuMI->SetEnabled( true );
bool hasMenu = p_wrapper->IsUsingMenus();
if ( fGotoMenuMI->IsEnabled() != hasMenu )
fGotoMenuMI->SetEnabled( hasMenu );
Unlock(); Unlock();
} }
} }
...@@ -909,8 +992,10 @@ InterfaceWindow::_UpdateSpeedMenu( int rate ) ...@@ -909,8 +992,10 @@ InterfaceWindow::_UpdateSpeedMenu( int rate )
break; break;
} }
if ( !toMark->IsMarked() ) if ( toMark && !toMark->IsMarked() )
{
toMark->SetMarked( true ); toMark->SetMarked( true );
}
} }
/***************************************************************************** /*****************************************************************************
...@@ -1113,12 +1198,12 @@ int CDMenu::GetCD( const char *directory ) ...@@ -1113,12 +1198,12 @@ int CDMenu::GetCD( const char *directory )
/***************************************************************************** /*****************************************************************************
* LanguageMenu::LanguageMenu * LanguageMenu::LanguageMenu
*****************************************************************************/ *****************************************************************************/
LanguageMenu::LanguageMenu( const char *name, int menu_kind, LanguageMenu::LanguageMenu( intf_thread_t * _p_intf, const char * psz_name,
VlcWrapper *p_wrapper ) char * _psz_variable )
:BMenu(name) : BMenu( psz_name )
{ {
kind = menu_kind; p_intf = _p_intf;
this->p_wrapper = p_wrapper; psz_variable = strdup( _psz_variable );
} }
/***************************************************************************** /*****************************************************************************
...@@ -1126,6 +1211,7 @@ LanguageMenu::LanguageMenu( const char *name, int menu_kind, ...@@ -1126,6 +1211,7 @@ LanguageMenu::LanguageMenu( const char *name, int menu_kind,
*****************************************************************************/ *****************************************************************************/
LanguageMenu::~LanguageMenu() LanguageMenu::~LanguageMenu()
{ {
free( psz_variable );
} }
/***************************************************************************** /*****************************************************************************
...@@ -1133,19 +1219,44 @@ LanguageMenu::~LanguageMenu() ...@@ -1133,19 +1219,44 @@ LanguageMenu::~LanguageMenu()
*****************************************************************************/ *****************************************************************************/
void LanguageMenu::AttachedToWindow() void LanguageMenu::AttachedToWindow()
{ {
BMenuItem * item;
// remove all items // remove all items
while ( BMenuItem* item = RemoveItem( 0L ) ) while( ( item = RemoveItem( 0L ) ) )
{
delete item; delete item;
}
SetRadioMode( true ); 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++ ) return;
AddItem( item ); }
if ( list->CountItems() > 1 ) vlc_value_t val_list, text_list;
AddItem( new BSeparatorItem(), 1 ); 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(); BMenu::AttachedToWindow();
} }
...@@ -1170,14 +1281,41 @@ TitleMenu::~TitleMenu() ...@@ -1170,14 +1281,41 @@ TitleMenu::~TitleMenu()
*****************************************************************************/ *****************************************************************************/
void TitleMenu::AttachedToWindow() void TitleMenu::AttachedToWindow()
{ {
while( BMenuItem* item = RemoveItem( 0L ) ) BMenuItem * item;
while( ( item = RemoveItem( 0L ) ) )
{
delete item; 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 ); AddItem( item );
} }
var_Change( p_input, "title", VLC_VAR_FREELIST,
&val_list, &text_list );
}
BMenu::AttachedToWindow(); BMenu::AttachedToWindow();
} }
...@@ -1203,26 +1341,45 @@ ChapterMenu::~ChapterMenu() ...@@ -1203,26 +1341,45 @@ ChapterMenu::~ChapterMenu()
*****************************************************************************/ *****************************************************************************/
void ChapterMenu::AttachedToWindow() void ChapterMenu::AttachedToWindow()
{ {
while( BMenuItem* item = RemoveItem( 0L ) ) BMenuItem * item;
while( ( item = RemoveItem( 0L ) ) )
{
delete item; 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 ); AddItem( item );
} }
var_Change( p_input, "chapter", VLC_VAR_FREELIST,
&val_list, &text_list );
}
BMenu::AttachedToWindow(); BMenu::AttachedToWindow();
} }
/***************************************************************************** /*****************************************************************************
* load_settings * load_settings
*****************************************************************************/ *****************************************************************************/
......
modules/gui/beos/InterfaceWindow.h
View file @ 254f695e
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
* InterfaceWindow.h: BeOS interface window class prototype * InterfaceWindow.h: BeOS interface window class prototype
***************************************************************************** *****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN * 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> * Authors: Jean-Marc Dressler <polux@via.ecp.fr>
* Tony Castley <tcastley@mail.powerup.com.au> * Tony Castley <tcastley@mail.powerup.com.au>
...@@ -36,7 +36,6 @@ class PlayListWindow; ...@@ -36,7 +36,6 @@ class PlayListWindow;
class BFilePanel; class BFilePanel;
class PreferencesWindow; class PreferencesWindow;
class MessagesWindow; class MessagesWindow;
class VlcWrapper;
class CDMenu : public BMenu class CDMenu : public BMenu
{ {
...@@ -53,16 +52,16 @@ class CDMenu : public BMenu ...@@ -53,16 +52,16 @@ class CDMenu : public BMenu
class LanguageMenu : public BMenu class LanguageMenu : public BMenu
{ {
public: public:
LanguageMenu( const char* name, LanguageMenu( intf_thread_t * p_intf,
int menu_kind, const char * psz_name,
VlcWrapper *p_wrapper ); char * psz_variable );
virtual ~LanguageMenu(); virtual ~LanguageMenu();
virtual void AttachedToWindow(); virtual void AttachedToWindow();
private: private:
VlcWrapper * p_wrapper; intf_thread_t * p_intf;
int kind; char * psz_variable;
}; };
class TitleMenu : public BMenu class TitleMenu : public BMenu
...@@ -91,9 +90,9 @@ class ChapterMenu : public BMenu ...@@ -91,9 +90,9 @@ class ChapterMenu : public BMenu
class InterfaceWindow : public BWindow class InterfaceWindow : public BWindow
{ {
public: public:
InterfaceWindow( BRect frame, InterfaceWindow( intf_thread_t * p_intf,
const char* name, BRect frame,
intf_thread_t* p_interface ); const char * name );
virtual ~InterfaceWindow(); virtual ~InterfaceWindow();
// BWindow // BWindow
...@@ -119,10 +118,11 @@ class InterfaceWindow : public BWindow ...@@ -119,10 +118,11 @@ class InterfaceWindow : public BWindow
void _RestoreSettings(); void _RestoreSettings();
void _StoreSettings(); void _StoreSettings();
intf_thread_t* p_intf; intf_thread_t * p_intf;
es_descriptor_t* p_spu_es; input_thread_t * p_input;
playlist_t * p_playlist;
es_descriptor_t * p_spu_es;
bool fPlaylistIsEmpty;
BFilePanel* fFilePanel; BFilePanel* fFilePanel;
PlayListWindow* fPlaylistWindow; PlayListWindow* fPlaylistWindow;
PreferencesWindow* fPreferencesWindow; PreferencesWindow* fPreferencesWindow;
...@@ -151,7 +151,6 @@ class InterfaceWindow : public BWindow ...@@ -151,7 +151,6 @@ class InterfaceWindow : public BWindow
bigtime_t fLastUpdateTime; bigtime_t fLastUpdateTime;
BMessage* fSettings; // we keep the message arround BMessage* fSettings; // we keep the message arround
// for forward compatibility // for forward compatibility
VlcWrapper* p_wrapper;
}; };
......
modules/gui/beos/ListViews.cpp
View file @ 254f695e
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
* ListViews.h: BeOS interface list view class implementation * ListViews.h: BeOS interface list view class implementation
***************************************************************************** *****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN * 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> * Authors: Stephan Aßmus <stippi@yellowbites.com>
* *
...@@ -32,7 +32,6 @@ ...@@ -32,7 +32,6 @@
#include <vlc/vlc.h> #include <vlc/vlc.h>
#include <vlc/intf.h> #include <vlc/intf.h>
#include "VlcWrapper.h"
#include "InterfaceWindow.h" #include "InterfaceWindow.h"
#include "ListViews.h" #include "ListViews.h"
#include "MsgVals.h" #include "MsgVals.h"
...@@ -607,20 +606,20 @@ DragSortableListView::_RemoveDropAnticipationRect() ...@@ -607,20 +606,20 @@ DragSortableListView::_RemoveDropAnticipationRect()
/***************************************************************************** /*****************************************************************************
* PlaylistView class * PlaylistView class
*****************************************************************************/ *****************************************************************************/
PlaylistView::PlaylistView( BRect frame, InterfaceWindow* mainWindow, PlaylistView::PlaylistView( intf_thread_t * _p_intf,
VlcWrapper* wrapper, BRect frame, InterfaceWindow* mainWindow,
BMessage* selectionChangeMessage ) BMessage* selectionChangeMessage )
: DragSortableListView( frame, "playlist listview", : DragSortableListView( frame, "playlist listview",
B_MULTIPLE_SELECTION_LIST, B_FOLLOW_ALL_SIDES, B_MULTIPLE_SELECTION_LIST, B_FOLLOW_ALL_SIDES,
B_WILL_DRAW | B_NAVIGABLE | B_PULSE_NEEDED B_WILL_DRAW | B_NAVIGABLE | B_PULSE_NEEDED
| B_FRAME_EVENTS | B_FULL_UPDATE_ON_RESIZE ), | B_FRAME_EVENTS | B_FULL_UPDATE_ON_RESIZE ),
p_intf( _p_intf ),
fCurrentIndex( -1 ), fCurrentIndex( -1 ),
fPlaying( false ), fPlaying( false ),
fDisplayMode( DISPLAY_PATH ), fDisplayMode( DISPLAY_PATH ),
fMainWindow( mainWindow ), fMainWindow( mainWindow ),
fSelectionChangeMessage( selectionChangeMessage ), fSelectionChangeMessage( selectionChangeMessage ),
fLastClickedItem( NULL ), fLastClickedItem( NULL )
fVlcWrapper( wrapper )
{ {
} }
...@@ -686,7 +685,14 @@ PlaylistView::MouseDown( BPoint where ) ...@@ -686,7 +685,14 @@ PlaylistView::MouseDown( BPoint where )
// only do something if user clicked the same item twice // only do something if user clicked the same item twice
if ( fLastClickedItem == item ) 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; handled = true;
} }
} }
...@@ -759,6 +765,7 @@ PlaylistView::SelectionChanged() ...@@ -759,6 +765,7 @@ PlaylistView::SelectionChanged()
void void
PlaylistView::MoveItems( BList& items, int32 index ) PlaylistView::MoveItems( BList& items, int32 index )
{ {
#if 0
DeselectAll(); DeselectAll();
// we remove the items while we look at them, the insertion index is decreased // 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 // 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 ) ...@@ -808,6 +815,7 @@ PlaylistView::MoveItems( BList& items, int32 index )
fMainWindow->PostMessage( MSG_UPDATE ); fMainWindow->PostMessage( MSG_UPDATE );
fVlcWrapper->PlaylistUnlock(); fVlcWrapper->PlaylistUnlock();
} }
#endif
} }
/***************************************************************************** /*****************************************************************************
...@@ -816,6 +824,7 @@ PlaylistView::MoveItems( BList& items, int32 index ) ...@@ -816,6 +824,7 @@ PlaylistView::MoveItems( BList& items, int32 index )
void void
PlaylistView::CopyItems( BList& items, int32 toIndex ) PlaylistView::CopyItems( BList& items, int32 toIndex )
{ {
#if 0
DeselectAll(); DeselectAll();
// we remove the items while we look at them, the insertion index is decreased // 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 // 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 ) ...@@ -855,6 +864,7 @@ PlaylistView::CopyItems( BList& items, int32 toIndex )
fMainWindow->PostMessage( MSG_UPDATE ); fMainWindow->PostMessage( MSG_UPDATE );
fVlcWrapper->PlaylistUnlock(); fVlcWrapper->PlaylistUnlock();
} }
#endif
} }
/***************************************************************************** /*****************************************************************************
...@@ -863,6 +873,7 @@ PlaylistView::CopyItems( BList& items, int32 toIndex ) ...@@ -863,6 +873,7 @@ PlaylistView::CopyItems( BList& items, int32 toIndex )
void void
PlaylistView::RemoveItemList( BList& items ) PlaylistView::RemoveItemList( BList& items )
{ {
#if 0
if ( fVlcWrapper->PlaylistLock() ) if ( fVlcWrapper->PlaylistLock() )
{ {
// remember currently playing item // remember currently playing item
...@@ -892,6 +903,7 @@ PlaylistView::RemoveItemList( BList& items ) ...@@ -892,6 +903,7 @@ PlaylistView::RemoveItemList( BList& items )
fMainWindow->PostMessage( MSG_UPDATE ); fMainWindow->PostMessage( MSG_UPDATE );
fVlcWrapper->PlaylistUnlock(); fVlcWrapper->PlaylistUnlock();
} }
#endif
} }
/***************************************************************************** /*****************************************************************************
...@@ -974,14 +986,28 @@ PlaylistView::SetPlaying( bool playing ) ...@@ -974,14 +986,28 @@ PlaylistView::SetPlaying( bool playing )
void void
PlaylistView::RebuildList() 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 // remove all items
BListItem * item;
int32 count = CountItems(); int32 count = CountItems();
while ( BListItem* item = RemoveItem( --count ) ) while( ( item = RemoveItem( --count ) ) )
delete item; delete item;
// rebuild listview from VLC's playlist // rebuild listview from VLC's playlist
for ( int i = 0; i < fVlcWrapper->PlaylistSize(); i++ ) vlc_mutex_lock( &p_playlist->object_lock );
AddItem( new PlaylistItem( fVlcWrapper->PlaylistItemName( i ) ) ); 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() ...@@ -991,6 +1017,7 @@ PlaylistView::RebuildList()
void void
PlaylistView::SortReverse() PlaylistView::SortReverse()
{ {
#if 0
if ( int32 count = CountSelectedItems() ) if ( int32 count = CountSelectedItems() )
{ {
int32 last = count - 1; int32 last = count - 1;
...@@ -1014,6 +1041,7 @@ PlaylistView::SortReverse() ...@@ -1014,6 +1041,7 @@ PlaylistView::SortReverse()
// restore currently playing item // restore currently playing item
_SetPlayingIndex( playingItem ); _SetPlayingIndex( playingItem );
} }
#endif
} }
/***************************************************************************** /*****************************************************************************
...@@ -1052,9 +1080,18 @@ PlaylistView::SetDisplayMode( uint32 mode ) ...@@ -1052,9 +1080,18 @@ PlaylistView::SetDisplayMode( uint32 mode )
BListItem* BListItem*
PlaylistView::_PlayingItem() const PlaylistView::_PlayingItem() const
{ {
int32 currentIndex, size; playlist_t * p_playlist;
fVlcWrapper->GetPlaylistInfo( currentIndex, size ); p_playlist = (playlist_t *) vlc_object_find( p_intf,
return ItemAt( currentIndex ); 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 ) ...@@ -1067,8 +1104,19 @@ PlaylistView::_SetPlayingIndex( BListItem* playingItem )
{ {
if ( item == 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 ); SetCurrent( i );
vlc_object_release( p_playlist );
break; break;
} }
} }
......
modules/gui/beos/ListViews.h
View file @ 254f695e
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
* ListViews.h: BeOS interface list view class prototype * ListViews.h: BeOS interface list view class prototype
***************************************************************************** *****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN * 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> * Authors: Stephan Aßmus <stippi@yellowbites.com>
* *
...@@ -113,9 +113,9 @@ class DragSortableListView : public BListView ...@@ -113,9 +113,9 @@ class DragSortableListView : public BListView
class PlaylistView : public DragSortableListView class PlaylistView : public DragSortableListView
{ {
public: public:
PlaylistView( BRect frame, PlaylistView( intf_thread_t * p_intf,
BRect frame,
InterfaceWindow* mainWindow, InterfaceWindow* mainWindow,
VlcWrapper* wrapper,
BMessage* selectionChangeMessage = NULL ); BMessage* selectionChangeMessage = NULL );
~PlaylistView(); ~PlaylistView();
...@@ -154,14 +154,14 @@ class PlaylistView : public DragSortableListView ...@@ -154,14 +154,14 @@ class PlaylistView : public DragSortableListView
BListItem* _PlayingItem() const; BListItem* _PlayingItem() const;
void _SetPlayingIndex( BListItem* item ); void _SetPlayingIndex( BListItem* item );
intf_thread_t * p_intf;
int32 fCurrentIndex; int32 fCurrentIndex;
bool fPlaying; bool fPlaying;
uint32 fDisplayMode; uint32 fDisplayMode;
InterfaceWindow* fMainWindow; InterfaceWindow* fMainWindow;
BMessage* fSelectionChangeMessage; BMessage* fSelectionChangeMessage;
PlaylistItem* fLastClickedItem; PlaylistItem* fLastClickedItem;
VlcWrapper* fVlcWrapper;
}; };
#endif // LIST_VIEWS_H #endif // LIST_VIEWS_H
modules/gui/beos/MediaControlView.cpp
View file @ 254f695e
...@@ -38,7 +38,6 @@ extern "C" ...@@ -38,7 +38,6 @@ extern "C"
} }
/* BeOS interface headers */ /* BeOS interface headers */
#include "VlcWrapper.h"
#include "Bitmaps.h" #include "Bitmaps.h"
#include "DrawingTidbits.h" #include "DrawingTidbits.h"
#include "InterfaceWindow.h" #include "InterfaceWindow.h"
...@@ -67,6 +66,7 @@ const rgb_color kSeekRedLight = (rgb_color){ 255, 152, 152, 255 }; ...@@ -67,6 +66,7 @@ const rgb_color kSeekRedLight = (rgb_color){ 255, 152, 152, 255 };
const rgb_color kSeekRedShadow = (rgb_color){ 178, 0, 0, 255 }; const rgb_color kSeekRedShadow = (rgb_color){ 178, 0, 0, 255 };
#define DISABLED_SEEK_MESSAGE _("Drop files to play") #define DISABLED_SEEK_MESSAGE _("Drop files to play")
#define SEEKSLIDER_RANGE 2048
enum enum
{ {
...@@ -77,17 +77,16 @@ enum ...@@ -77,17 +77,16 @@ enum
}; };
// constructor // 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, : BBox(frame, NULL, B_FOLLOW_NONE, B_WILL_DRAW | B_FRAME_EVENTS | B_PULSE_NEEDED,
B_PLAIN_BORDER), B_PLAIN_BORDER),
p_intf( _p_intf ),
fScrubSem(B_ERROR), fScrubSem(B_ERROR),
fCurrentRate(INPUT_RATE_DEFAULT), fCurrentRate(INPUT_RATE_DEFAULT),
fCurrentStatus(-1), fCurrentStatus(-1),
fBottomControlHeight(0.0), fBottomControlHeight(0.0),
fIsEnabled( true ) fIsEnabled( true )
{ {
p_intf = p_interface;
BRect frame(0.0, 0.0, 10.0, 10.0); BRect frame(0.0, 0.0, 10.0, 10.0);
// Seek Slider // Seek Slider
...@@ -1335,6 +1334,7 @@ PositionInfoView::Pulse() ...@@ -1335,6 +1334,7 @@ PositionInfoView::Pulse()
bigtime_t now = system_time(); bigtime_t now = system_time();
if ( now - fLastPulseUpdate > 900000 ) if ( now - fLastPulseUpdate > 900000 )
{ {
#if 0
int32 index, size; int32 index, size;
p_intf->p_sys->p_wrapper->GetPlaylistInfo( index, size ); p_intf->p_sys->p_wrapper->GetPlaylistInfo( index, size );
SetFile( index + 1, size ); SetFile( index + 1, size );
...@@ -1344,6 +1344,7 @@ PositionInfoView::Pulse() ...@@ -1344,6 +1344,7 @@ PositionInfoView::Pulse()
SetChapter( index, size ); SetChapter( index, size );
SetTime( p_intf->p_sys->p_wrapper->GetTimeAsString() ); SetTime( p_intf->p_sys->p_wrapper->GetTimeAsString() );
fLastPulseUpdate = now; fLastPulseUpdate = now;
#endif
} }
} }
......
modules/gui/beos/MediaControlView.h
View file @ 254f695e
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
* MediaControlView.h: beos interface * MediaControlView.h: beos interface
***************************************************************************** *****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN * 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> * Authors: Tony Castley <tony@castley.net>
* Stephan Aßmus <stippi@yellowbites.com> * Stephan Aßmus <stippi@yellowbites.com>
...@@ -38,7 +38,7 @@ class VolumeSlider; ...@@ -38,7 +38,7 @@ class VolumeSlider;
class MediaControlView : public BBox class MediaControlView : public BBox
{ {
public: public:
MediaControlView( BRect frame, intf_thread_t *p_intf ); MediaControlView( intf_thread_t * p_intf, BRect frame );
virtual ~MediaControlView(); virtual ~MediaControlView();
// BBox // BBox
...@@ -70,6 +70,7 @@ class MediaControlView : public BBox ...@@ -70,6 +70,7 @@ class MediaControlView : public BBox
bool resizeWidth = false, bool resizeWidth = false,
bool resizeHeight = false) const; bool resizeHeight = false) const;
intf_thread_t * p_intf;
VolumeSlider* fVolumeSlider; VolumeSlider* fVolumeSlider;
SeekSlider* fSeekSlider; SeekSlider* fSeekSlider;
...@@ -88,7 +89,6 @@ class MediaControlView : public BBox ...@@ -88,7 +89,6 @@ class MediaControlView : public BBox
BRect fOldBounds; BRect fOldBounds;
bool fIsEnabled; bool fIsEnabled;
intf_thread_t * p_intf;
}; };
class SeekSlider : public BControl class SeekSlider : public BControl
......
modules/gui/beos/MessagesWindow.cpp
View file @ 254f695e
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
* MessagesWindow.cpp: beos interface * MessagesWindow.cpp: beos interface
***************************************************************************** *****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN * 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> * Authors: Eric Petit <titer@videolan.org>
* *
...@@ -30,7 +30,6 @@ ...@@ -30,7 +30,6 @@
#include <vlc/intf.h> #include <vlc/intf.h>
/* BeOS module headers */ /* BeOS module headers */
#include "VlcWrapper.h"
#include "InterfaceWindow.h" #include "InterfaceWindow.h"
#include "MessagesWindow.h" #include "MessagesWindow.h"
...@@ -39,6 +38,7 @@ ...@@ -39,6 +38,7 @@
*****************************************************************************/ *****************************************************************************/
void MessagesView::Pulse() void MessagesView::Pulse()
{ {
#if 0
bool isScrolling = false; bool isScrolling = false;
if( fScrollBar->LockLooper() ) if( fScrollBar->LockLooper() )
{ {
...@@ -123,6 +123,7 @@ void MessagesView::Pulse() ...@@ -123,6 +123,7 @@ void MessagesView::Pulse()
} }
BTextView::Pulse(); BTextView::Pulse();
#endif
} }
/***************************************************************************** /*****************************************************************************
......
modules/gui/beos/MessagesWindow.h
View file @ 254f695e
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
* MessagesWindow.h * MessagesWindow.h
***************************************************************************** *****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN * 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> * Authors: Eric Petit <titer@videolan.org>
* *
...@@ -36,7 +36,6 @@ class MessagesView : public BTextView ...@@ -36,7 +36,6 @@ class MessagesView : public BTextView
resizingMode, flags ) resizingMode, flags )
{ {
p_intf = _p_intf; p_intf = _p_intf;
p_sub = ((intf_sys_t*)p_intf->p_sys)->p_sub;
} }
virtual void Pulse(); virtual void Pulse();
......
modules/gui/beos/Modules.am
View file @ 254f695e
...@@ -19,8 +19,6 @@ SOURCES_beos = \ ...@@ -19,8 +19,6 @@ SOURCES_beos = \
MessagesWindow.h \ MessagesWindow.h \
MediaControlView.cpp \ MediaControlView.cpp \
MediaControlView.h \ MediaControlView.h \
VlcWrapper.cpp \
VlcWrapper.h \
Bitmaps.h \ Bitmaps.h \
MsgVals.h \ MsgVals.h \
VideoWindow.h \ VideoWindow.h \
......
modules/gui/beos/PlayListWindow.cpp
View file @ 254f695e
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
* PlayListWindow.cpp: beos interface * PlayListWindow.cpp: beos interface
***************************************************************************** *****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN * 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> * Authors: Jean-Marc Dressler <polux@via.ecp.fr>
* Samuel Hocevar <sam@zoy.org> * Samuel Hocevar <sam@zoy.org>
...@@ -35,7 +35,6 @@ ...@@ -35,7 +35,6 @@
#include <vlc/intf.h> #include <vlc/intf.h>
/* BeOS interface headers */ /* BeOS interface headers */
#include "VlcWrapper.h"
#include "InterfaceWindow.h" #include "InterfaceWindow.h"
#include "ListViews.h" #include "ListViews.h"
#include "MsgVals.h" #include "MsgVals.h"
...@@ -67,8 +66,12 @@ PlayListWindow::PlayListWindow( BRect frame, const char* name, ...@@ -67,8 +66,12 @@ PlayListWindow::PlayListWindow( BRect frame, const char* name,
B_WILL_ACCEPT_FIRST_CLICK | B_ASYNCHRONOUS_CONTROLS ), B_WILL_ACCEPT_FIRST_CLICK | B_ASYNCHRONOUS_CONTROLS ),
fMainWindow( mainWindow ) 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_intf = p_interface;
p_wrapper = p_intf->p_sys->p_wrapper;
SetName( _("playlist") ); SetName( _("playlist") );
...@@ -81,8 +84,8 @@ PlayListWindow::PlayListWindow( BRect frame, const char* name, ...@@ -81,8 +84,8 @@ PlayListWindow::PlayListWindow( BRect frame, const char* name,
// Add the File menu // Add the File menu
BMenu *fileMenu = new BMenu( _("File") ); BMenu *fileMenu = new BMenu( _("File") );
fMenuBar->AddItem( fileMenu ); fMenuBar->AddItem( fileMenu );
BMenuItem* item = new BMenuItem( _AddEllipsis(_("Open File")), ADD_ELLIPSIS( _("Open File") );
new BMessage( OPEN_FILE ), 'O' ); BMenuItem* item = new BMenuItem( psz_tmp, new BMessage( OPEN_FILE ), 'O' );
item->SetTarget( fMainWindow ); item->SetTarget( fMainWindow );
fileMenu->AddItem( item ); fileMenu->AddItem( item );
...@@ -154,7 +157,7 @@ fRandomizeMI->SetEnabled( false ); ...@@ -154,7 +157,7 @@ fRandomizeMI->SetEnabled( false );
frame.top += fMenuBar->Bounds().IntegerHeight() + 1; frame.top += fMenuBar->Bounds().IntegerHeight() + 1;
frame.right -= B_V_SCROLL_BAR_WIDTH; 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 ) ); new BMessage( MSG_SELECTION_CHANGED ) );
fBackgroundView = new BScrollView( "playlist scrollview", fBackgroundView = new BScrollView( "playlist scrollview",
fListView, B_FOLLOW_ALL_SIDES, fListView, B_FOLLOW_ALL_SIDES,
...@@ -282,9 +285,10 @@ PlayListWindow::UpdatePlaylist( bool rebuild ) ...@@ -282,9 +285,10 @@ PlayListWindow::UpdatePlaylist( bool rebuild )
{ {
if ( rebuild ) if ( rebuild )
fListView->RebuildList(); fListView->RebuildList();
#if 0
fListView->SetCurrent( p_wrapper->PlaylistCurrent() ); fListView->SetCurrent( p_wrapper->PlaylistCurrent() );
fListView->SetPlaying( p_wrapper->IsPlaying() ); fListView->SetPlaying( p_wrapper->IsPlaying() );
#endif
_CheckItemsEnableState(); _CheckItemsEnableState();
} }
......
modules/gui/beos/PlayListWindow.h
View file @ 254f695e
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
* PlayListWindow.h: BeOS interface window class prototype * PlayListWindow.h: BeOS interface window class prototype
***************************************************************************** *****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN * 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> * Authors: Jean-Marc Dressler <polux@via.ecp.fr>
* Tony Castley <tcastley@mail.powerup.com.au> * Tony Castley <tcastley@mail.powerup.com.au>
...@@ -75,7 +75,6 @@ class PlayListWindow : public BWindow ...@@ -75,7 +75,6 @@ class PlayListWindow : public BWindow
BMenu* fViewMenu; BMenu* fViewMenu;
intf_thread_t * p_intf; intf_thread_t * p_intf;
VlcWrapper * p_wrapper;
}; };
#endif // BEOS_PLAY_LIST_WINDOW_H #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(); ...@@ -1065,7 +1065,7 @@ vlc_module_begin();
#else #else
# define KEY_FULLSCREEN 'f' # define KEY_FULLSCREEN 'f'
# define KEY_PLAY_PAUSE ' ' # define KEY_PLAY_PAUSE KEY_SPACE
# define KEY_PAUSE KEY_UNSET # define KEY_PAUSE KEY_UNSET
# define KEY_PLAY KEY_UNSET # define KEY_PLAY KEY_UNSET
# define KEY_FASTER '+' # 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