* 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>
#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
*****************************************************************************/
/* 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);
- BRect rect = screen.Frame();
- rect.top = rect.bottom-100;
+ BScreen screen( B_MAIN_SCREEN_ID );
+ BRect rect = screen.Frame();
+ rect.top = rect.bottom - 100;
rect.bottom -= 50;
- rect.left += 50;
- rect.right = rect.left + 350;
+ 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 );
- }
- 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);
+ return VLC_EGENERIC;
}
- p_intf->p_sys->b_loop = 0;
- p_intf->p_sys->b_mute = 0;
-
- return( 0 );
+
+ /* 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 );
+
+ return VLC_SUCCESS;
}
/*****************************************************************************
{
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 );
}
{
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 );
}
}
#include <vlc/input.h>
/* BeOS interface headers */
-#include "VlcWrapper.h"
#include "MsgVals.h"
#include "MediaControlView.h"
#include "PlayListWindow.h"
#include "MessagesWindow.h"
#include "InterfaceWindow.h"
-#define INTERFACE_UPDATE_TIMEOUT 80000 // 2 frames if at 25 fps
+#define INTERFACE_UPDATE_TIMEOUT 80000 // 2 frames if at 25 fps
#define INTERFACE_LOCKING_TIMEOUT 5000
// make_sure_frame_is_on_screen
bool
make_sure_frame_is_on_screen( BRect& frame )
{
- BScreen screen( B_MAIN_SCREEN_ID );
- if (frame.IsValid() && screen.IsValid()) {
- if (!screen.Frame().Contains(frame)) {
- // make sure frame fits in the screen
- if (frame.Width() > screen.Frame().Width())
- frame.right -= frame.Width() - screen.Frame().Width() + 10.0;
- if (frame.Height() > screen.Frame().Height())
- frame.bottom -= frame.Height() - screen.Frame().Height() + 30.0;
- // frame is now at the most the size of the screen
- if (frame.right > screen.Frame().right)
- frame.OffsetBy(-(frame.right - screen.Frame().right), 0.0);
- if (frame.bottom > screen.Frame().bottom)
- frame.OffsetBy(0.0, -(frame.bottom - screen.Frame().bottom));
- if (frame.left < screen.Frame().left)
- frame.OffsetBy((screen.Frame().left - frame.left), 0.0);
- if (frame.top < screen.Frame().top)
- frame.OffsetBy(0.0, (screen.Frame().top - frame.top));
- }
- return true;
- }
- return false;
+ BScreen screen( B_MAIN_SCREEN_ID );
+ if (frame.IsValid() && screen.IsValid()) {
+ if (!screen.Frame().Contains(frame)) {
+ // make sure frame fits in the screen
+ if (frame.Width() > screen.Frame().Width())
+ frame.right -= frame.Width() - screen.Frame().Width() + 10.0;
+ if (frame.Height() > screen.Frame().Height())
+ frame.bottom -= frame.Height() - screen.Frame().Height() + 30.0;
+ // frame is now at the most the size of the screen
+ if (frame.right > screen.Frame().right)
+ frame.OffsetBy(-(frame.right - screen.Frame().right), 0.0);
+ if (frame.bottom > screen.Frame().bottom)
+ frame.OffsetBy(0.0, -(frame.bottom - screen.Frame().bottom));
+ if (frame.left < screen.Frame().left)
+ frame.OffsetBy((screen.Frame().left - frame.left), 0.0);
+ if (frame.top < screen.Frame().top)
+ frame.OffsetBy(0.0, (screen.Frame().top - frame.top));
+ }
+ return true;
+ }
+ return false;
}
// make_sure_frame_is_within_limits
bool
get_volume_info( BVolume& volume, BString& volumeName, bool& isCDROM, BString& deviceName )
{
- bool success = false;
- isCDROM = false;
- deviceName = "";
- volumeName = "";
- char name[B_FILE_NAME_LENGTH];
- if ( volume.GetName( name ) >= B_OK ) // disk is currently mounted
- {
- volumeName = name;
- dev_t dev = volume.Device();
- fs_info info;
- if ( fs_stat_dev( dev, &info ) == B_OK )
- {
- success = true;
- deviceName = info.device_name;
- if ( volume.IsReadOnly() )
- {
- int i_dev = open( info.device_name, O_RDONLY );
- if ( i_dev >= 0 )
- {
- device_geometry g;
- if ( ioctl( i_dev, B_GET_GEOMETRY, &g, sizeof( g ) ) >= 0 )
- isCDROM = ( g.device_type == B_CD );
- close( i_dev );
- }
- }
- }
- }
- return success;
+ bool success = false;
+ isCDROM = false;
+ deviceName = "";
+ volumeName = "";
+ char name[B_FILE_NAME_LENGTH];
+ if ( volume.GetName( name ) >= B_OK ) // disk is currently mounted
+ {
+ volumeName = name;
+ dev_t dev = volume.Device();
+ fs_info info;
+ if ( fs_stat_dev( dev, &info ) == B_OK )
+ {
+ success = true;
+ deviceName = info.device_name;
+ if ( volume.IsReadOnly() )
+ {
+ int i_dev = open( info.device_name, O_RDONLY );
+ if ( i_dev >= 0 )
+ {
+ device_geometry g;
+ if ( ioctl( i_dev, B_GET_GEOMETRY, &g, sizeof( g ) ) >= 0 )
+ isCDROM = ( g.device_type == B_CD );
+ close( i_dev );
+ }
+ }
+ }
+ }
+ return success;
}
// collect_folder_contents
void
collect_folder_contents( BDirectory& dir, BList& list, bool& deep, bool& asked, BEntry& entry )
{
- while ( dir.GetNextEntry( &entry, true ) == B_OK )
- {
- if ( !entry.IsDirectory() )
- {
- BPath path;
- // since the directory will give us the entries in reverse order,
- // we put them each at the same index, effectively reversing the
- // items while adding them
- if ( entry.GetPath( &path ) == B_OK )
- {
- BString* string = new BString( path.Path() );
- if ( !list.AddItem( string, 0 ) )
- delete string; // at least don't leak
- }
- }
- else
- {
- if ( !asked )
- {
- // ask user if we should parse sub-folders as well
- BAlert* alert = new BAlert( "sub-folders?",
- _("Open files from all sub-folders as well?"),
- _("Cancel"), _("Open"), NULL, B_WIDTH_AS_USUAL,
- B_IDEA_ALERT );
- int32 buttonIndex = alert->Go();
- deep = buttonIndex == 1;
- asked = true;
- // never delete BAlerts!!
- }
- if ( deep )
- {
- BDirectory subDir( &entry );
- if ( subDir.InitCheck() == B_OK )
- collect_folder_contents( subDir, list,
- deep, asked, entry );
- }
- }
- }
+ while ( dir.GetNextEntry( &entry, true ) == B_OK )
+ {
+ if ( !entry.IsDirectory() )
+ {
+ BPath path;
+ // since the directory will give us the entries in reverse order,
+ // we put them each at the same index, effectively reversing the
+ // items while adding them
+ if ( entry.GetPath( &path ) == B_OK )
+ {
+ BString* string = new BString( path.Path() );
+ if ( !list.AddItem( string, 0 ) )
+ delete string; // at least don't leak
+ }
+ }
+ else
+ {
+ if ( !asked )
+ {
+ // ask user if we should parse sub-folders as well
+ BAlert* alert = new BAlert( "sub-folders?",
+ _("Open files from all sub-folders as well?"),
+ _("Cancel"), _("Open"), NULL, B_WIDTH_AS_USUAL,
+ B_IDEA_ALERT );
+ int32 buttonIndex = alert->Go();
+ deep = buttonIndex == 1;
+ asked = true;
+ // never delete BAlerts!!
+ }
+ if ( deep )
+ {
+ BDirectory subDir( &entry );
+ if ( subDir.InitCheck() == B_OK )
+ collect_folder_contents( subDir, list,
+ deep, asked, entry );
+ }
+ }
+ }
}
* 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();
BRect window_rect;
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;
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") );
/* 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
- // because it will set the window size limits in AttachedToWindow()
- // and the menubar needs to report the correct PreferredSize()
+ // add the media control view after the menubar is complete
+ // because it will set the window size limits in AttachedToWindow()
+ // and the menubar needs to report the correct PreferredSize()
AddChild( p_mediaControl );
/* Prepare fow showing */
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;
+ }
+ delete fFilePanel;
+ delete fSettings;
}
/*****************************************************************************
*****************************************************************************/
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;
}
break;
case OPEN_FILE:
- _ShowFilePanel( B_REFS_RECEIVED, _("VLC media player: Open Media Files") );
+ _ShowFilePanel( B_REFS_RECEIVED, _("VLC media player: Open Media Files") );
break;
case LOAD_SUBFILE:
- _ShowFilePanel( SUBFILE_RECEIVED, _("VLC media player: Open Subtitle File") );
+ _ShowFilePanel( SUBFILE_RECEIVED, _("VLC media player: Open Subtitle File") );
break;
case OPEN_PLAYLIST:
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();
}
{
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();
+ if( p_playlist )
+ {
+ playlist_Play( p_playlist );
+ }
}
else
{
- p_wrapper->PlaylistPlay();
+ var_SetInteger( p_input, "state", PAUSE_S );
}
}
- else
- {
- /* Play a new file */
- p_wrapper->PlaylistPlay();
- }
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_input )
{
- int32 channel;
- if ( p_message->FindInt32( "channel", &channel ) == B_OK )
+ if( p_message->FindInt32( "audio-es", &channel ) == B_OK )
+ {
+ var_SetInteger( p_input, "audio-es", channel );
+ }
+ else if( p_message->FindInt32( "spu-es", &channel ) == B_OK )
{
- p_wrapper->ToggleLanguage( channel );
+ var_SetInteger( p_input, "spu-es", channel );
}
}
break;
+ }
- case SELECT_SUBTITLE:
- if ( playback_status > -1 )
+ case PREV_TITLE:
+ if( p_input )
{
- int32 subtitle;
- if ( p_message->FindInt32( "subtitle", &subtitle ) == B_OK )
- p_wrapper->ToggleSubtitle( subtitle );
+ var_SetVoid( p_input, "prev-title" );
}
break;
-
- // specific navigation messages
- case PREV_TITLE:
- {
- p_wrapper->PrevTitle();
- break;
- }
+
case NEXT_TITLE:
- {
- p_wrapper->NextTitle();
+ if( p_input )
+ {
+ var_SetVoid( p_input, "next-title" );
+ }
break;
- }
+
case NAVIGATE_MENU:
- p_wrapper->ToggleTitle( 0 );
- break;
- case TOGGLE_TITLE:
- if ( playback_status > -1 )
+ if( p_input )
{
- int32 index;
- if( p_message->FindInt32( "index", &index ) == B_OK )
- p_wrapper->ToggleTitle( index );
+ var_SetInteger( p_input, "title", 0 );
}
break;
- case PREV_CHAPTER:
+
+ case TOGGLE_TITLE:
{
- p_wrapper->PrevChapter();
+ int32 index;
+ if( p_input &&
+ p_message->FindInt32( "index", &index ) == B_OK )
+ {
+ var_SetInteger( p_input, "title", index );
+ }
break;
}
+
+ case PREV_CHAPTER:
+ if( p_input )
+ {
+ var_SetVoid( p_input, "prev-chapter" );
+ }
+ break;
+
case NEXT_CHAPTER:
- {
- p_wrapper->NextChapter();
+ if( p_input )
+ {
+ var_SetVoid( p_input, "next-chapter" );
+ }
break;
- }
+
case TOGGLE_CHAPTER:
- if ( playback_status > -1 )
+ {
+ int32 index;
+ if( p_input &&
+ p_message->FindInt32( "index", &index ) == B_OK )
{
- int32 index;
- if( p_message->FindInt32( "index", &index ) == B_OK )
- p_wrapper->ToggleChapter( index );
+ 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)
- // to normal message (containing refs)
- {
- const char* path;
- for ( int32 i = 0; p_message->FindString( "path", i, &path ) == B_OK; i++ )
- {
- entry_ref ref;
- if ( get_ref_for_path( path, &ref ) == B_OK )
- p_message->AddRef( "refs", &ref );
- }
- }
- // fall through
+ // convert soundplay drag'n'drop message (containing paths)
+ // to normal message (containing refs)
+ {
+ const char* path;
+ for ( int32 i = 0; p_message->FindString( "path", i, &path ) == B_OK; i++ )
+ {
+ entry_ref ref;
+ if ( get_ref_for_path( path, &ref ) == B_OK )
+ p_message->AddRef( "refs", &ref );
+ }
+ }
+ // fall through
case B_REFS_RECEIVED:
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 */
+
+ int32 count;
+ type_code dummy;
+ if( p_message->GetInfo( "refs", &dummy, &count ) != B_OK ||
+ count < 1 )
{
- /* 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() )
+ break;
+ }
+
+ vlc_bool_t b_remove = ( p_message->WasDropped() &&
+ !( modifiers() & B_SHIFT_KEY ) );
+
+ if( b_remove && p_playlist )
+ {
+ /* Empty playlist */
+ while( p_playlist->i_size > 0 )
{
- replace = !( modifiers() & B_SHIFT_KEY );
- reverse = true;
+ playlist_Delete( p_playlist, 0 );
}
-
- // 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;
- type_code dummy;
- if ( p_message->GetInfo( "refs", &dummy, &count ) == B_OK && count > 0 )
- {
- 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
- {
- vol.Unset();
- status = volRoster.GetNextVolume( &vol );
- }
- }
- }
- if ( add )
- {
- add = false;
- dir.Rewind(); // defensive programming
- BEntry entry;
- collect_folder_contents( dir, files,
- parseSubFolders,
- askedAlready,
- entry );
- }
- }
- if ( add )
- {
- BString* string = new BString( path.Path() );
- if ( !files.AddItem( string, 0 ) )
- delete string; // at least don't leak
- }
- }
- }
- // 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();
- }
}
+
+ entry_ref ref;
+ for( int i = 0; p_message->FindRef( "refs", i, &ref ) == B_OK; i++ )
+ {
+ 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 );
+ }
+ }
+
+ _UpdatePlaylist();
break;
+ }
case OPEN_PREFERENCES:
{
break;
}
case MSG_UPDATE:
- UpdateInterface();
- break;
+ UpdateInterface();
+ break;
default:
BWindow::MessageReceived( p_message );
break;
}
-
}
/*****************************************************************************
*****************************************************************************/
bool InterfaceWindow::QuitRequested()
{
- p_wrapper->PlaylistStop();
+ if( p_playlist )
+ {
+ playlist_Stop( p_playlist );
+ }
p_mediaControl->SetStatus(-1, INPUT_RATE_DEFAULT);
- _StoreSettings();
+ _StoreSettings();
p_intf->b_die = 1;
*****************************************************************************/
void InterfaceWindow::UpdateInterface()
{
- if( p_wrapper->HasInput() )
+ /* Manage the input part */
+ if( !p_playlist )
{
- if ( acquire_sem( p_mediaControl->fScrubSem ) == B_OK )
- {
- p_wrapper->SetTimeAsFloat( p_mediaControl->GetSeekTo() );
- }
- else if ( LockWithTimeout( INTERFACE_LOCKING_TIMEOUT ) == B_OK )
- {
- 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() );
- _SetMenusEnabled( true, hasChapters, hasTitles );
-
- _UpdateSpeedMenu( p_wrapper->InputRate() );
-
- // enable/disable skip buttons
- bool canSkipPrev;
- bool canSkipNext;
- p_wrapper->GetNavCapabilities( &canSkipPrev, &canSkipNext );
- p_mediaControl->SetSkippable( canSkipPrev, canSkipNext );
+ p_playlist = (playlist_t *)
+ vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
+ }
+ if( !p_input )
+ {
+ 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;
+ }
- if ( p_wrapper->HasInput() )
- {
- p_mediaControl->SetAudioEnabled( true );
- p_mediaControl->SetMuted( p_wrapper->IsMuted() );
- } else
- p_mediaControl->SetAudioEnabled( false );
+ /* Get ready to update the interface */
+ if( LockWithTimeout( INTERFACE_LOCKING_TIMEOUT ) != B_OK )
+ {
+ return;
+ }
+
+ if( p_input )
+ {
+ vlc_value_t val;
+ p_mediaControl->SetEnabled( true );
+ 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( 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
+
+ audio_volume_t i_volume;
+ aout_VolumeGet( p_input, &i_volume );
+ p_mediaControl->SetAudioEnabled( true );
+ 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();
}
else
{
- if ( LockWithTimeout(INTERFACE_LOCKING_TIMEOUT) == B_OK )
- {
- _SetMenusEnabled( false );
- if( !( p_wrapper->PlaylistSize() > 0 ) )
- p_mediaControl->SetEnabled( false );
- else
- {
- p_mediaControl->SetProgress( 0 );
- // enable/disable skip buttons
- bool canSkipPrev;
- bool canSkipNext;
- p_wrapper->GetNavCapabilities( &canSkipPrev, &canSkipNext );
- p_mediaControl->SetSkippable( canSkipPrev, canSkipNext );
- }
- Unlock();
+ p_mediaControl->SetAudioEnabled( false );
+
+ _SetMenusEnabled( false );
+
+ 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
+ }
+ else
+ {
+ p_mediaControl->SetEnabled( false );
}
}
-
+
+ Unlock();
fLastUpdateTime = system_time();
}
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 );
}
/*****************************************************************************
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();
}
}
break;
}
- if ( !toMark->IsMarked() )
+ if ( toMark && !toMark->IsMarked() )
+ {
toMark->SetMarked( true );
+ }
}
/*****************************************************************************
void
InterfaceWindow::_ShowFilePanel( uint32 command, const char* windowTitle )
{
- if( !fFilePanel )
- {
- fFilePanel = new BFilePanel( B_OPEN_PANEL, NULL, NULL,
- B_FILE_NODE | B_DIRECTORY_NODE );
- fFilePanel->SetTarget( this );
- }
- fFilePanel->Window()->SetTitle( windowTitle );
- BMessage message( command );
- fFilePanel->SetMessage( &message );
- if ( !fFilePanel->IsShowing() )
- {
- fFilePanel->Refresh();
- fFilePanel->Show();
- }
+ if( !fFilePanel )
+ {
+ fFilePanel = new BFilePanel( B_OPEN_PANEL, NULL, NULL,
+ B_FILE_NODE | B_DIRECTORY_NODE );
+ fFilePanel->SetTarget( this );
+ }
+ fFilePanel->Window()->SetTitle( windowTitle );
+ BMessage message( command );
+ fFilePanel->SetMessage( &message );
+ if ( !fFilePanel->IsShowing() )
+ {
+ fFilePanel->Refresh();
+ fFilePanel->Show();
+ }
}
// set_window_pos
void
set_window_pos( BWindow* window, BRect frame )
{
- // sanity checks: make sure window is not too big/small
- // and that it's not off-screen
- float minWidth, maxWidth, minHeight, maxHeight;
- window->GetSizeLimits( &minWidth, &maxWidth, &minHeight, &maxHeight );
-
- make_sure_frame_is_within_limits( frame,
- minWidth, minHeight, maxWidth, maxHeight );
- if ( make_sure_frame_is_on_screen( frame ) )
- {
- window->MoveTo( frame.LeftTop() );
- window->ResizeTo( frame.Width(), frame.Height() );
- }
+ // sanity checks: make sure window is not too big/small
+ // and that it's not off-screen
+ float minWidth, maxWidth, minHeight, maxHeight;
+ window->GetSizeLimits( &minWidth, &maxWidth, &minHeight, &maxHeight );
+
+ make_sure_frame_is_within_limits( frame,
+ minWidth, minHeight, maxWidth, maxHeight );
+ if ( make_sure_frame_is_on_screen( frame ) )
+ {
+ window->MoveTo( frame.LeftTop() );
+ window->ResizeTo( frame.Width(), frame.Height() );
+ }
}
// set_window_pos
void
launch_window( BWindow* window, bool showing )
{
- if ( window->Lock() )
- {
- if ( showing )
- {
- if ( window->IsHidden() )
- window->Show();
- }
- else
- {
- if ( !window->IsHidden() )
- window->Hide();
- }
- window->Unlock();
- }
+ if ( window->Lock() )
+ {
+ if ( showing )
+ {
+ if ( window->IsHidden() )
+ window->Show();
+ }
+ else
+ {
+ if ( !window->IsHidden() )
+ window->Hide();
+ }
+ window->Unlock();
+ }
}
/*****************************************************************************
void
InterfaceWindow::_RestoreSettings()
{
- if ( load_settings( fSettings, "interface_settings", "VideoLAN Client" ) == B_OK )
- {
- BRect frame;
- if ( fSettings->FindRect( "main frame", &frame ) == B_OK )
- set_window_pos( this, frame );
- if (fSettings->FindRect( "playlist frame", &frame ) == B_OK )
- set_window_pos( fPlaylistWindow, frame );
- if (fSettings->FindRect( "messages frame", &frame ) == B_OK )
- set_window_pos( fMessagesWindow, frame );
- if (fSettings->FindRect( "settings frame", &frame ) == B_OK )
- {
- /* FIXME: Preferences resizing doesn't work correctly yet */
- frame.right = frame.left + fPreferencesWindow->Frame().Width();
- frame.bottom = frame.top + fPreferencesWindow->Frame().Height();
- set_window_pos( fPreferencesWindow, frame );
- }
-
- bool showing;
- if ( fSettings->FindBool( "playlist showing", &showing ) == B_OK )
- launch_window( fPlaylistWindow, showing );
- if ( fSettings->FindBool( "messages showing", &showing ) == B_OK )
- launch_window( fMessagesWindow, showing );
- if ( fSettings->FindBool( "settings showing", &showing ) == B_OK )
- launch_window( fPreferencesWindow, showing );
-
- uint32 displayMode;
- if ( fSettings->FindInt32( "playlist display mode", (int32*)&displayMode ) == B_OK )
- fPlaylistWindow->SetDisplayMode( displayMode );
- }
+ if ( load_settings( fSettings, "interface_settings", "VideoLAN Client" ) == B_OK )
+ {
+ BRect frame;
+ if ( fSettings->FindRect( "main frame", &frame ) == B_OK )
+ set_window_pos( this, frame );
+ if (fSettings->FindRect( "playlist frame", &frame ) == B_OK )
+ set_window_pos( fPlaylistWindow, frame );
+ if (fSettings->FindRect( "messages frame", &frame ) == B_OK )
+ set_window_pos( fMessagesWindow, frame );
+ if (fSettings->FindRect( "settings frame", &frame ) == B_OK )
+ {
+ /* FIXME: Preferences resizing doesn't work correctly yet */
+ frame.right = frame.left + fPreferencesWindow->Frame().Width();
+ frame.bottom = frame.top + fPreferencesWindow->Frame().Height();
+ set_window_pos( fPreferencesWindow, frame );
+ }
+
+ bool showing;
+ if ( fSettings->FindBool( "playlist showing", &showing ) == B_OK )
+ launch_window( fPlaylistWindow, showing );
+ if ( fSettings->FindBool( "messages showing", &showing ) == B_OK )
+ launch_window( fMessagesWindow, showing );
+ if ( fSettings->FindBool( "settings showing", &showing ) == B_OK )
+ launch_window( fPreferencesWindow, showing );
+
+ uint32 displayMode;
+ if ( fSettings->FindInt32( "playlist display mode", (int32*)&displayMode ) == B_OK )
+ fPlaylistWindow->SetDisplayMode( displayMode );
+ }
}
/*****************************************************************************
config_SaveConfigFile( p_intf, "main" );
/* Save the windows positions */
- if ( fSettings->ReplaceRect( "main frame", Frame() ) != B_OK )
- fSettings->AddRect( "main frame", Frame() );
- if ( fPlaylistWindow->Lock() )
- {
- if (fSettings->ReplaceRect( "playlist frame", fPlaylistWindow->Frame() ) != B_OK)
- fSettings->AddRect( "playlist frame", fPlaylistWindow->Frame() );
- if (fSettings->ReplaceBool( "playlist showing", !fPlaylistWindow->IsHidden() ) != B_OK)
- fSettings->AddBool( "playlist showing", !fPlaylistWindow->IsHidden() );
- fPlaylistWindow->Unlock();
- }
- if ( fMessagesWindow->Lock() )
- {
- if (fSettings->ReplaceRect( "messages frame", fMessagesWindow->Frame() ) != B_OK)
- fSettings->AddRect( "messages frame", fMessagesWindow->Frame() );
- if (fSettings->ReplaceBool( "messages showing", !fMessagesWindow->IsHidden() ) != B_OK)
- fSettings->AddBool( "messages showing", !fMessagesWindow->IsHidden() );
- fMessagesWindow->Unlock();
- }
- if ( fPreferencesWindow->Lock() )
- {
- if (fSettings->ReplaceRect( "settings frame", fPreferencesWindow->Frame() ) != B_OK)
- fSettings->AddRect( "settings frame", fPreferencesWindow->Frame() );
- if (fSettings->ReplaceBool( "settings showing", !fPreferencesWindow->IsHidden() ) != B_OK)
- fSettings->AddBool( "settings showing", !fPreferencesWindow->IsHidden() );
- fPreferencesWindow->Unlock();
- }
- uint32 displayMode = fPlaylistWindow->DisplayMode();
- if (fSettings->ReplaceInt32( "playlist display mode", displayMode ) != B_OK )
- fSettings->AddInt32( "playlist display mode", displayMode );
-
- save_settings( fSettings, "interface_settings", "VideoLAN Client" );
+ if ( fSettings->ReplaceRect( "main frame", Frame() ) != B_OK )
+ fSettings->AddRect( "main frame", Frame() );
+ if ( fPlaylistWindow->Lock() )
+ {
+ if (fSettings->ReplaceRect( "playlist frame", fPlaylistWindow->Frame() ) != B_OK)
+ fSettings->AddRect( "playlist frame", fPlaylistWindow->Frame() );
+ if (fSettings->ReplaceBool( "playlist showing", !fPlaylistWindow->IsHidden() ) != B_OK)
+ fSettings->AddBool( "playlist showing", !fPlaylistWindow->IsHidden() );
+ fPlaylistWindow->Unlock();
+ }
+ if ( fMessagesWindow->Lock() )
+ {
+ if (fSettings->ReplaceRect( "messages frame", fMessagesWindow->Frame() ) != B_OK)
+ fSettings->AddRect( "messages frame", fMessagesWindow->Frame() );
+ if (fSettings->ReplaceBool( "messages showing", !fMessagesWindow->IsHidden() ) != B_OK)
+ fSettings->AddBool( "messages showing", !fMessagesWindow->IsHidden() );
+ fMessagesWindow->Unlock();
+ }
+ if ( fPreferencesWindow->Lock() )
+ {
+ if (fSettings->ReplaceRect( "settings frame", fPreferencesWindow->Frame() ) != B_OK)
+ fSettings->AddRect( "settings frame", fPreferencesWindow->Frame() );
+ if (fSettings->ReplaceBool( "settings showing", !fPreferencesWindow->IsHidden() ) != B_OK)
+ fSettings->AddBool( "settings showing", !fPreferencesWindow->IsHidden() );
+ fPreferencesWindow->Unlock();
+ }
+ uint32 displayMode = fPlaylistWindow->DisplayMode();
+ if (fSettings->ReplaceInt32( "playlist display mode", displayMode ) != B_OK )
+ fSettings->AddInt32( "playlist display mode", displayMode );
+
+ save_settings( fSettings, "interface_settings", "VideoLAN Client" );
}
*****************************************************************************/
int CDMenu::GetCD( const char *directory )
{
- BVolumeRoster volRoster;
- BVolume vol;
- BDirectory dir;
- status_t status = volRoster.GetNextVolume( &vol );
- while ( status == B_NO_ERROR )
- {
- BString deviceName;
- BString volumeName;
- bool isCDROM;
- if ( get_volume_info( vol, volumeName, isCDROM, deviceName )
- && isCDROM )
- {
- BMessage* msg = new BMessage( OPEN_DVD );
- msg->AddString( "device", deviceName.String() );
- BMenuItem* item = new BMenuItem( volumeName.String(), msg );
- AddItem( item );
- }
- vol.Unset();
- status = volRoster.GetNextVolume( &vol );
- }
- return 0;
+ BVolumeRoster volRoster;
+ BVolume vol;
+ BDirectory dir;
+ status_t status = volRoster.GetNextVolume( &vol );
+ while ( status == B_NO_ERROR )
+ {
+ BString deviceName;
+ BString volumeName;
+ bool isCDROM;
+ if ( get_volume_info( vol, volumeName, isCDROM, deviceName )
+ && isCDROM )
+ {
+ BMessage* msg = new BMessage( OPEN_DVD );
+ msg->AddString( "device", deviceName.String() );
+ BMenuItem* item = new BMenuItem( volumeName.String(), msg );
+ AddItem( item );
+ }
+ vol.Unset();
+ status = volRoster.GetNextVolume( &vol );
+ }
+ return 0;
}
/*****************************************************************************
* 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 );
}
/*****************************************************************************
*****************************************************************************/
LanguageMenu::~LanguageMenu()
{
+ free( psz_variable );
}
/*****************************************************************************
*****************************************************************************/
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 ) )
- {
- for ( int32 i = 0; BMenuItem* item = (BMenuItem*)list->ItemAt( i ); i++ )
- AddItem( item );
-
- if ( list->CountItems() > 1 )
- AddItem( new BSeparatorItem(), 1 );
- }
+
+ input_thread_t * p_input = (input_thread_t *)
+ vlc_object_find( p_intf, VLC_OBJECT_INPUT, FIND_ANYWHERE );
+ if( !p_input )
+ {
+ return;
+ }
+
+ 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();
}
*****************************************************************************/
void TitleMenu::AttachedToWindow()
{
- while( BMenuItem* item = RemoveItem( 0L ) )
+ BMenuItem * item;
+ while( ( item = RemoveItem( 0L ) ) )
+ {
delete item;
+ }
- if ( BList *list = p_intf->p_sys->p_wrapper->GetTitles() )
- {
- for( int i = 0; BMenuItem* item = (BMenuItem*)list->ItemAt( i ); i++ )
- AddItem( 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 );
+
+ for( int i = 0; i < val_list.p_list->i_count; 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();
}
*****************************************************************************/
void ChapterMenu::AttachedToWindow()
{
- while( BMenuItem* item = RemoveItem( 0L ) )
+ BMenuItem * item;
+ while( ( item = RemoveItem( 0L ) ) )
+ {
delete item;
+ }
- if ( BList* list = p_intf->p_sys->p_wrapper->GetChapters() )
- {
- for( int i = 0; BMenuItem* item = (BMenuItem*)list->ItemAt( i ); i++ )
- AddItem( item );
- }
-
- BMenu::AttachedToWindow();
-}
-
-
-
-
-
+ 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 );
+
+ for( int i = 0; i < val_list.p_list->i_count; 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();
+}
/*****************************************************************************
status_t
load_settings( BMessage* message, const char* fileName, const char* folder )
{
- status_t ret = B_BAD_VALUE;
- if ( message )
- {
- BPath path;
- if ( ( ret = find_directory( B_USER_SETTINGS_DIRECTORY, &path ) ) == B_OK )
- {
- // passing folder is optional
- if ( folder )
- ret = path.Append( folder );
- if ( ret == B_OK && ( ret = path.Append( fileName ) ) == B_OK )
- {
- BFile file( path.Path(), B_READ_ONLY );
- if ( ( ret = file.InitCheck() ) == B_OK )
- {
- ret = message->Unflatten( &file );
- file.Unset();
- }
- }
- }
- }
- return ret;
+ status_t ret = B_BAD_VALUE;
+ if ( message )
+ {
+ BPath path;
+ if ( ( ret = find_directory( B_USER_SETTINGS_DIRECTORY, &path ) ) == B_OK )
+ {
+ // passing folder is optional
+ if ( folder )
+ ret = path.Append( folder );
+ if ( ret == B_OK && ( ret = path.Append( fileName ) ) == B_OK )
+ {
+ BFile file( path.Path(), B_READ_ONLY );
+ if ( ( ret = file.InitCheck() ) == B_OK )
+ {
+ ret = message->Unflatten( &file );
+ file.Unset();
+ }
+ }
+ }
+ }
+ return ret;
}
/*****************************************************************************
status_t
save_settings( BMessage* message, const char* fileName, const char* folder )
{
- status_t ret = B_BAD_VALUE;
- if ( message )
- {
- BPath path;
- if ( ( ret = find_directory( B_USER_SETTINGS_DIRECTORY, &path ) ) == B_OK )
- {
- // passing folder is optional
- if ( folder && ( ret = path.Append( folder ) ) == B_OK )
- ret = create_directory( path.Path(), 0777 );
- if ( ret == B_OK && ( ret = path.Append( fileName ) ) == B_OK )
- {
- BFile file( path.Path(), B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE );
- if ( ( ret = file.InitCheck() ) == B_OK )
- {
- ret = message->Flatten( &file );
- file.Unset();
- }
- }
- }
- }
- return ret;
+ status_t ret = B_BAD_VALUE;
+ if ( message )
+ {
+ BPath path;
+ if ( ( ret = find_directory( B_USER_SETTINGS_DIRECTORY, &path ) ) == B_OK )
+ {
+ // passing folder is optional
+ if ( folder && ( ret = path.Append( folder ) ) == B_OK )
+ ret = create_directory( path.Path(), 0777 );
+ if ( ret == B_OK && ( ret = path.Append( fileName ) ) == B_OK )
+ {
+ BFile file( path.Path(), B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE );
+ if ( ( ret = file.InitCheck() ) == B_OK )
+ {
+ ret = message->Flatten( &file );
+ file.Unset();
+ }
+ }
+ }
+ }
+ return ret;
}
* 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>
class BFilePanel;
class PreferencesWindow;
class MessagesWindow;
-class VlcWrapper;
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
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
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;
bigtime_t fLastUpdateTime;
BMessage* fSettings; // we keep the message arround
// for forward compatibility
- VlcWrapper* p_wrapper;
};
* 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>
*
#include <vlc/vlc.h>
#include <vlc/intf.h>
-#include "VlcWrapper.h"
#include "InterfaceWindow.h"
#include "ListViews.h"
#include "MsgVals.h"
-#define MAX_DRAG_HEIGHT 200.0
-#define ALPHA 170
-#define TEXT_OFFSET 20.0
+#define MAX_DRAG_HEIGHT 200.0
+#define ALPHA 170
+#define TEXT_OFFSET 20.0
/*****************************************************************************
* PlaylistItem class
*****************************************************************************/
PlaylistItem::PlaylistItem( const char *name )
- : BStringItem( name ),
- fName( "" )
+ : BStringItem( name ),
+ fName( "" )
{
- entry_ref ref;
- if ( get_ref_for_path( name, &ref) == B_OK )
- fName.SetTo( ref.name );
+ entry_ref ref;
+ if ( get_ref_for_path( name, &ref) == B_OK )
+ fName.SetTo( ref.name );
}
PlaylistItem::~PlaylistItem()
*****************************************************************************/
void
PlaylistItem::Draw( BView *owner, BRect frame, bool tintedLine,
- uint32 mode, bool active, bool playing )
+ uint32 mode, bool active, bool playing )
{
- rgb_color color = (rgb_color){ 255, 255, 255, 255 };
- if ( tintedLine )
- color = tint_color( color, 1.04 );
- // background
- if ( IsSelected() )
- color = tint_color( color, B_DARKEN_2_TINT );
- owner->SetLowColor( color );
- owner->FillRect( frame, B_SOLID_LOW );
- // label
- owner->SetHighColor( 0, 0, 0, 255 );
- font_height fh;
- owner->GetFontHeight( &fh );
- const char* text = Text();
- switch ( mode )
- {
- case DISPLAY_NAME:
- if ( fName.CountChars() > 0 )
- text = fName.String();
- break;
- case DISPLAY_PATH:
- default:
- break;
- }
- BString truncatedString( text );
- owner->TruncateString( &truncatedString, B_TRUNCATE_MIDDLE,
- frame.Width() - TEXT_OFFSET - 4.0 );
- owner->DrawString( truncatedString.String(),
- BPoint( frame.left + TEXT_OFFSET,
- frame.top + fh.ascent + 1.0 ) );
- // playmark
- if ( active )
- {
- rgb_color black = (rgb_color){ 0, 0, 0, 255 };
- rgb_color green = (rgb_color){ 0, 255, 0, 255 };
- BRect r( 0.0, 0.0, 10.0, 10.0 );
- r.OffsetTo( frame.left + 4.0,
- ceilf( ( frame.top + frame.bottom ) / 2.0 ) - 5.0 );
- if ( !playing )
- green = tint_color( color, B_DARKEN_1_TINT );
- rgb_color lightGreen = tint_color( green, B_LIGHTEN_2_TINT );
- rgb_color darkGreen = tint_color( green, B_DARKEN_2_TINT );
- BPoint arrow[3];
- arrow[0] = r.LeftTop();
- arrow[1] = r.LeftBottom();
- arrow[2].x = r.right;
- arrow[2].y = ( r.top + r.bottom ) / 2.0;
- owner->BeginLineArray( 6 );
- // black outline
- owner->AddLine( arrow[0], arrow[1], black );
- owner->AddLine( BPoint( arrow[1].x + 1.0, arrow[1].y - 1.0 ),
- arrow[2], black );
- owner->AddLine( arrow[0], arrow[2], black );
- // inset arrow
- arrow[0].x += 1.0;
- arrow[0].y += 2.0;
- arrow[1].x += 1.0;
- arrow[1].y -= 2.0;
- arrow[2].x -= 2.0;
- // highlights and shadow
- owner->AddLine( arrow[1], arrow[2], darkGreen );
- owner->AddLine( arrow[0], arrow[2], lightGreen );
- owner->AddLine( arrow[0], arrow[1], lightGreen );
- owner->EndLineArray();
- // fill green
- arrow[0].x += 1.0;
- arrow[0].y += 1.0;
- arrow[1].x += 1.0;
- arrow[1].y -= 1.0;
- arrow[2].x -= 2.0;
- owner->SetHighColor( green );
- owner->FillPolygon( arrow, 3 );
- }
+ rgb_color color = (rgb_color){ 255, 255, 255, 255 };
+ if ( tintedLine )
+ color = tint_color( color, 1.04 );
+ // background
+ if ( IsSelected() )
+ color = tint_color( color, B_DARKEN_2_TINT );
+ owner->SetLowColor( color );
+ owner->FillRect( frame, B_SOLID_LOW );
+ // label
+ owner->SetHighColor( 0, 0, 0, 255 );
+ font_height fh;
+ owner->GetFontHeight( &fh );
+ const char* text = Text();
+ switch ( mode )
+ {
+ case DISPLAY_NAME:
+ if ( fName.CountChars() > 0 )
+ text = fName.String();
+ break;
+ case DISPLAY_PATH:
+ default:
+ break;
+ }
+ BString truncatedString( text );
+ owner->TruncateString( &truncatedString, B_TRUNCATE_MIDDLE,
+ frame.Width() - TEXT_OFFSET - 4.0 );
+ owner->DrawString( truncatedString.String(),
+ BPoint( frame.left + TEXT_OFFSET,
+ frame.top + fh.ascent + 1.0 ) );
+ // playmark
+ if ( active )
+ {
+ rgb_color black = (rgb_color){ 0, 0, 0, 255 };
+ rgb_color green = (rgb_color){ 0, 255, 0, 255 };
+ BRect r( 0.0, 0.0, 10.0, 10.0 );
+ r.OffsetTo( frame.left + 4.0,
+ ceilf( ( frame.top + frame.bottom ) / 2.0 ) - 5.0 );
+ if ( !playing )
+ green = tint_color( color, B_DARKEN_1_TINT );
+ rgb_color lightGreen = tint_color( green, B_LIGHTEN_2_TINT );
+ rgb_color darkGreen = tint_color( green, B_DARKEN_2_TINT );
+ BPoint arrow[3];
+ arrow[0] = r.LeftTop();
+ arrow[1] = r.LeftBottom();
+ arrow[2].x = r.right;
+ arrow[2].y = ( r.top + r.bottom ) / 2.0;
+ owner->BeginLineArray( 6 );
+ // black outline
+ owner->AddLine( arrow[0], arrow[1], black );
+ owner->AddLine( BPoint( arrow[1].x + 1.0, arrow[1].y - 1.0 ),
+ arrow[2], black );
+ owner->AddLine( arrow[0], arrow[2], black );
+ // inset arrow
+ arrow[0].x += 1.0;
+ arrow[0].y += 2.0;
+ arrow[1].x += 1.0;
+ arrow[1].y -= 2.0;
+ arrow[2].x -= 2.0;
+ // highlights and shadow
+ owner->AddLine( arrow[1], arrow[2], darkGreen );
+ owner->AddLine( arrow[0], arrow[2], lightGreen );
+ owner->AddLine( arrow[0], arrow[1], lightGreen );
+ owner->EndLineArray();
+ // fill green
+ arrow[0].x += 1.0;
+ arrow[0].y += 1.0;
+ arrow[1].x += 1.0;
+ arrow[1].y -= 1.0;
+ arrow[2].x -= 2.0;
+ owner->SetHighColor( green );
+ owner->FillPolygon( arrow, 3 );
+ }
}
/*****************************************************************************
* DragSortableListView class
*****************************************************************************/
DragSortableListView::DragSortableListView( BRect frame, const char* name,
- list_view_type type, uint32 resizingMode,
- uint32 flags )
- : BListView( frame, name, type, resizingMode, flags ),
- fDropRect( 0.0, 0.0, -1.0, -1.0 ),
- fDropIndex( -1 )
+ list_view_type type, uint32 resizingMode,
+ uint32 flags )
+ : BListView( frame, name, type, resizingMode, flags ),
+ fDropRect( 0.0, 0.0, -1.0, -1.0 ),
+ fDropIndex( -1 )
{
- SetViewColor( B_TRANSPARENT_32_BIT );
+ SetViewColor( B_TRANSPARENT_32_BIT );
}
DragSortableListView::~DragSortableListView()
void
DragSortableListView::Draw( BRect updateRect )
{
- int32 firstIndex = IndexOf( updateRect.LeftTop() );
- int32 lastIndex = IndexOf( updateRect.RightBottom() );
- if ( firstIndex >= 0 )
- {
- if ( lastIndex < firstIndex )
- lastIndex = CountItems() - 1;
- // update rect contains items
- BRect r( updateRect );
- for ( int32 i = firstIndex; i <= lastIndex; i++)
- {
- r = ItemFrame( i );
- DrawListItem( this, i, r );
- }
- updateRect.top = r.bottom + 1.0;
- if ( updateRect.IsValid() )
- {
- SetLowColor( 255, 255, 255, 255 );
- FillRect( updateRect, B_SOLID_LOW );
- }
- }
- else
- {
- SetLowColor( 255, 255, 255, 255 );
- FillRect( updateRect, B_SOLID_LOW );
- }
- // drop anticipation indication
- if ( fDropRect.IsValid() )
- {
- SetHighColor( 255, 0, 0, 255 );
- StrokeRect( fDropRect );
- }
+ int32 firstIndex = IndexOf( updateRect.LeftTop() );
+ int32 lastIndex = IndexOf( updateRect.RightBottom() );
+ if ( firstIndex >= 0 )
+ {
+ if ( lastIndex < firstIndex )
+ lastIndex = CountItems() - 1;
+ // update rect contains items
+ BRect r( updateRect );
+ for ( int32 i = firstIndex; i <= lastIndex; i++)
+ {
+ r = ItemFrame( i );
+ DrawListItem( this, i, r );
+ }
+ updateRect.top = r.bottom + 1.0;
+ if ( updateRect.IsValid() )
+ {
+ SetLowColor( 255, 255, 255, 255 );
+ FillRect( updateRect, B_SOLID_LOW );
+ }
+ }
+ else
+ {
+ SetLowColor( 255, 255, 255, 255 );
+ FillRect( updateRect, B_SOLID_LOW );
+ }
+ // drop anticipation indication
+ if ( fDropRect.IsValid() )
+ {
+ SetHighColor( 255, 0, 0, 255 );
+ StrokeRect( fDropRect );
+ }
}
/*****************************************************************************
bool
DragSortableListView::InitiateDrag( BPoint point, int32 index, bool )
{
- bool success = false;
- BListItem* item = ItemAt( CurrentSelection( 0 ) );
- if ( !item )
- {
- // workarround a timing problem
- Select( index );
- item = ItemAt( index );
- }
- if ( item )
- {
- // create drag message
- BMessage msg( B_SIMPLE_DATA );
- MakeDragMessage( &msg );
- // figure out drag rect
- float width = Bounds().Width();
- BRect dragRect(0.0, 0.0, width, -1.0);
- // figure out, how many items fit into our bitmap
- int32 numItems;
- bool fade = false;
- for (numItems = 0; BListItem* item = ItemAt( CurrentSelection( numItems ) ); numItems++) {
- dragRect.bottom += ceilf( item->Height() ) + 1.0;
- if ( dragRect.Height() > MAX_DRAG_HEIGHT ) {
- fade = true;
- dragRect.bottom = MAX_DRAG_HEIGHT;
- numItems++;
- break;
- }
- }
- BBitmap* dragBitmap = new BBitmap( dragRect, B_RGB32, true );
- if ( dragBitmap && dragBitmap->IsValid() ) {
- if ( BView *v = new BView( dragBitmap->Bounds(), "helper", B_FOLLOW_NONE, B_WILL_DRAW ) ) {
- dragBitmap->AddChild( v );
- dragBitmap->Lock();
- BRect itemBounds( dragRect) ;
- itemBounds.bottom = 0.0;
- // let all selected items, that fit into our drag_bitmap, draw
- for ( int32 i = 0; i < numItems; i++ ) {
- int32 index = CurrentSelection( i );
- BListItem* item = ItemAt( index );
- itemBounds.bottom = itemBounds.top + ceilf( item->Height() );
- if ( itemBounds.bottom > dragRect.bottom )
- itemBounds.bottom = dragRect.bottom;
- DrawListItem( v, index, itemBounds );
- itemBounds.top = itemBounds.bottom + 1.0;
- }
- // make a black frame arround the edge
- v->SetHighColor( 0, 0, 0, 255 );
- v->StrokeRect( v->Bounds() );
- v->Sync();
-
- uint8 *bits = (uint8 *)dragBitmap->Bits();
- int32 height = (int32)dragBitmap->Bounds().Height() + 1;
- int32 width = (int32)dragBitmap->Bounds().Width() + 1;
- int32 bpr = dragBitmap->BytesPerRow();
-
- if (fade) {
- for ( int32 y = 0; y < height - ALPHA / 2; y++, bits += bpr ) {
- uint8 *line = bits + 3;
- for (uint8 *end = line + 4 * width; line < end; line += 4)
- *line = ALPHA;
- }
- for ( int32 y = height - ALPHA / 2; y < height; y++, bits += bpr ) {
- uint8 *line = bits + 3;
- for (uint8 *end = line + 4 * width; line < end; line += 4)
- *line = (height - y) << 1;
- }
- } else {
- for ( int32 y = 0; y < height; y++, bits += bpr ) {
- uint8 *line = bits + 3;
- for (uint8 *end = line + 4 * width; line < end; line += 4)
- *line = ALPHA;
- }
- }
- dragBitmap->Unlock();
- success = true;
- }
- }
- if (success)
- DragMessage( &msg, dragBitmap, B_OP_ALPHA, BPoint( 0.0, 0.0 ) );
- else {
- delete dragBitmap;
- DragMessage( &msg, dragRect.OffsetToCopy( point ), this );
- }
- }
- return success;
+ bool success = false;
+ BListItem* item = ItemAt( CurrentSelection( 0 ) );
+ if ( !item )
+ {
+ // workarround a timing problem
+ Select( index );
+ item = ItemAt( index );
+ }
+ if ( item )
+ {
+ // create drag message
+ BMessage msg( B_SIMPLE_DATA );
+ MakeDragMessage( &msg );
+ // figure out drag rect
+ float width = Bounds().Width();
+ BRect dragRect(0.0, 0.0, width, -1.0);
+ // figure out, how many items fit into our bitmap
+ int32 numItems;
+ bool fade = false;
+ for (numItems = 0; BListItem* item = ItemAt( CurrentSelection( numItems ) ); numItems++) {
+ dragRect.bottom += ceilf( item->Height() ) + 1.0;
+ if ( dragRect.Height() > MAX_DRAG_HEIGHT ) {
+ fade = true;
+ dragRect.bottom = MAX_DRAG_HEIGHT;
+ numItems++;
+ break;
+ }
+ }
+ BBitmap* dragBitmap = new BBitmap( dragRect, B_RGB32, true );
+ if ( dragBitmap && dragBitmap->IsValid() ) {
+ if ( BView *v = new BView( dragBitmap->Bounds(), "helper", B_FOLLOW_NONE, B_WILL_DRAW ) ) {
+ dragBitmap->AddChild( v );
+ dragBitmap->Lock();
+ BRect itemBounds( dragRect) ;
+ itemBounds.bottom = 0.0;
+ // let all selected items, that fit into our drag_bitmap, draw
+ for ( int32 i = 0; i < numItems; i++ ) {
+ int32 index = CurrentSelection( i );
+ BListItem* item = ItemAt( index );
+ itemBounds.bottom = itemBounds.top + ceilf( item->Height() );
+ if ( itemBounds.bottom > dragRect.bottom )
+ itemBounds.bottom = dragRect.bottom;
+ DrawListItem( v, index, itemBounds );
+ itemBounds.top = itemBounds.bottom + 1.0;
+ }
+ // make a black frame arround the edge
+ v->SetHighColor( 0, 0, 0, 255 );
+ v->StrokeRect( v->Bounds() );
+ v->Sync();
+
+ uint8 *bits = (uint8 *)dragBitmap->Bits();
+ int32 height = (int32)dragBitmap->Bounds().Height() + 1;
+ int32 width = (int32)dragBitmap->Bounds().Width() + 1;
+ int32 bpr = dragBitmap->BytesPerRow();
+
+ if (fade) {
+ for ( int32 y = 0; y < height - ALPHA / 2; y++, bits += bpr ) {
+ uint8 *line = bits + 3;
+ for (uint8 *end = line + 4 * width; line < end; line += 4)
+ *line = ALPHA;
+ }
+ for ( int32 y = height - ALPHA / 2; y < height; y++, bits += bpr ) {
+ uint8 *line = bits + 3;
+ for (uint8 *end = line + 4 * width; line < end; line += 4)
+ *line = (height - y) << 1;
+ }
+ } else {
+ for ( int32 y = 0; y < height; y++, bits += bpr ) {
+ uint8 *line = bits + 3;
+ for (uint8 *end = line + 4 * width; line < end; line += 4)
+ *line = ALPHA;
+ }
+ }
+ dragBitmap->Unlock();
+ success = true;
+ }
+ }
+ if (success)
+ DragMessage( &msg, dragBitmap, B_OP_ALPHA, BPoint( 0.0, 0.0 ) );
+ else {
+ delete dragBitmap;
+ DragMessage( &msg, dragRect.OffsetToCopy( point ), this );
+ }
+ }
+ return success;
}
/*****************************************************************************
void
DragSortableListView::WindowActivated( bool active )
{
- // workarround for buggy focus indication of BScrollView
- if ( BView* view = Parent() )
- view->Invalidate();
+ // workarround for buggy focus indication of BScrollView
+ if ( BView* view = Parent() )
+ view->Invalidate();
}
/*****************************************************************************
void
DragSortableListView::MessageReceived(BMessage* message)
{
- switch ( message->what )
- {
- case B_MODIFIERS_CHANGED:
- ModifiersChanged();
- break;
- case B_SIMPLE_DATA:
- {
- DragSortableListView *list = NULL;
- if ( message->FindPointer( "list", (void **)&list ) == B_OK
- && list == this )
- {
- int32 count = CountItems();
- if ( fDropIndex < 0 || fDropIndex > count )
- fDropIndex = count;
- BList items;
- int32 index;
- for ( int32 i = 0; message->FindInt32( "index", i, &index ) == B_OK; i++ )
- if ( BListItem* item = ItemAt(index) )
- items.AddItem( (void*)item );
- if ( items.CountItems() > 0 )
- {
- if ( modifiers() & B_SHIFT_KEY )
- CopyItems( items, fDropIndex );
- else
- MoveItems( items, fDropIndex );
- }
- fDropIndex = -1;
- }
- break;
- }
- default:
- BListView::MessageReceived( message );
- break;
- }
+ switch ( message->what )
+ {
+ case B_MODIFIERS_CHANGED:
+ ModifiersChanged();
+ break;
+ case B_SIMPLE_DATA:
+ {
+ DragSortableListView *list = NULL;
+ if ( message->FindPointer( "list", (void **)&list ) == B_OK
+ && list == this )
+ {
+ int32 count = CountItems();
+ if ( fDropIndex < 0 || fDropIndex > count )
+ fDropIndex = count;
+ BList items;
+ int32 index;
+ for ( int32 i = 0; message->FindInt32( "index", i, &index ) == B_OK; i++ )
+ if ( BListItem* item = ItemAt(index) )
+ items.AddItem( (void*)item );
+ if ( items.CountItems() > 0 )
+ {
+ if ( modifiers() & B_SHIFT_KEY )
+ CopyItems( items, fDropIndex );
+ else
+ MoveItems( items, fDropIndex );
+ }
+ fDropIndex = -1;
+ }
+ break;
+ }
+ default:
+ BListView::MessageReceived( message );
+ break;
+ }
}
/*****************************************************************************
void
DragSortableListView::MouseMoved(BPoint where, uint32 transit, const BMessage *msg)
{
- if ( msg && ( msg->what == B_SIMPLE_DATA || msg->what == MSG_SOUNDPLAY ) )
- {
- bool replaceAll = !msg->HasPointer("list") && !(modifiers() & B_SHIFT_KEY);
- switch ( transit )
- {
- case B_ENTERED_VIEW:
- // remember drag message
- // this is needed to react on modifier changes
- fDragMessageCopy = *msg;
- case B_INSIDE_VIEW:
- {
- if ( replaceAll )
- {
- BRect r( Bounds() );
- r.bottom--; // compensate for scrollbar offset
- _SetDropAnticipationRect( r );
- fDropIndex = -1;
- }
- else
- {
- // offset where by half of item height
- BRect r( ItemFrame( 0 ) );
- where.y += r.Height() / 2.0;
-
- int32 index = IndexOf( where );
- if ( index < 0 )
- index = CountItems();
- _SetDropIndex( index );
- }
- break;
- }
- case B_EXITED_VIEW:
- // forget drag message
- fDragMessageCopy.what = 0;
- case B_OUTSIDE_VIEW:
- _RemoveDropAnticipationRect();
- break;
- }
- }
- else
- {
- _RemoveDropAnticipationRect();
- BListView::MouseMoved(where, transit, msg);
- fDragMessageCopy.what = 0;
- }
+ if ( msg && ( msg->what == B_SIMPLE_DATA || msg->what == MSG_SOUNDPLAY ) )
+ {
+ bool replaceAll = !msg->HasPointer("list") && !(modifiers() & B_SHIFT_KEY);
+ switch ( transit )
+ {
+ case B_ENTERED_VIEW:
+ // remember drag message
+ // this is needed to react on modifier changes
+ fDragMessageCopy = *msg;
+ case B_INSIDE_VIEW:
+ {
+ if ( replaceAll )
+ {
+ BRect r( Bounds() );
+ r.bottom--; // compensate for scrollbar offset
+ _SetDropAnticipationRect( r );
+ fDropIndex = -1;
+ }
+ else
+ {
+ // offset where by half of item height
+ BRect r( ItemFrame( 0 ) );
+ where.y += r.Height() / 2.0;
+
+ int32 index = IndexOf( where );
+ if ( index < 0 )
+ index = CountItems();
+ _SetDropIndex( index );
+ }
+ break;
+ }
+ case B_EXITED_VIEW:
+ // forget drag message
+ fDragMessageCopy.what = 0;
+ case B_OUTSIDE_VIEW:
+ _RemoveDropAnticipationRect();
+ break;
+ }
+ }
+ else
+ {
+ _RemoveDropAnticipationRect();
+ BListView::MouseMoved(where, transit, msg);
+ fDragMessageCopy.what = 0;
+ }
}
/*****************************************************************************
void
DragSortableListView::MouseUp( BPoint where )
{
- // remove drop mark
- _SetDropAnticipationRect( BRect( 0.0, 0.0, -1.0, -1.0 ) );
- // be sure to forget drag message
- fDragMessageCopy.what = 0;
- BListView::MouseUp( where );
+ // remove drop mark
+ _SetDropAnticipationRect( BRect( 0.0, 0.0, -1.0, -1.0 ) );
+ // be sure to forget drag message
+ fDragMessageCopy.what = 0;
+ BListView::MouseUp( where );
}
/*****************************************************************************
void
DragSortableListView::DrawItem( BListItem *item, BRect itemFrame, bool complete )
{
- DrawListItem( this, IndexOf( item ), itemFrame );
+ DrawListItem( this, IndexOf( item ), itemFrame );
}
/*****************************************************************************
void
DragSortableListView::ModifiersChanged()
{
- BPoint where;
- uint32 buttons;
- GetMouse( &where, &buttons, false );
- uint32 transit = Bounds().Contains( where ) ? B_INSIDE_VIEW : B_OUTSIDE_VIEW;
- MouseMoved( where, transit, &fDragMessageCopy );
+ BPoint where;
+ uint32 buttons;
+ GetMouse( &where, &buttons, false );
+ uint32 transit = Bounds().Contains( where ) ? B_INSIDE_VIEW : B_OUTSIDE_VIEW;
+ MouseMoved( where, transit, &fDragMessageCopy );
}
/*****************************************************************************
void
DragSortableListView::MoveItems( BList& items, int32 index )
{
- 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
- // removal
- BList removedItems;
- int32 count = items.CountItems();
- for ( int32 i = 0; i < count; i++ )
- {
- BListItem* item = (BListItem*)items.ItemAt( i );
- int32 removeIndex = IndexOf( item );
- if ( RemoveItem( item ) && removedItems.AddItem( (void*)item ) )
- {
- if ( removeIndex < index )
- index--;
- }
- // else ??? -> blow up
- }
- for ( int32 i = 0; BListItem* item = (BListItem*)removedItems.ItemAt( i ); i++ )
- {
- if ( AddItem( item, index ) )
- {
- // after we're done, the newly inserted items will be selected
- Select( index, true );
- // next items will be inserted after this one
- index++;
- }
- else
- delete item;
- }
+ 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
+ // removal
+ BList removedItems;
+ int32 count = items.CountItems();
+ for ( int32 i = 0; i < count; i++ )
+ {
+ BListItem* item = (BListItem*)items.ItemAt( i );
+ int32 removeIndex = IndexOf( item );
+ if ( RemoveItem( item ) && removedItems.AddItem( (void*)item ) )
+ {
+ if ( removeIndex < index )
+ index--;
+ }
+ // else ??? -> blow up
+ }
+ for ( int32 i = 0; BListItem* item = (BListItem*)removedItems.ItemAt( i ); i++ )
+ {
+ if ( AddItem( item, index ) )
+ {
+ // after we're done, the newly inserted items will be selected
+ Select( index, true );
+ // next items will be inserted after this one
+ index++;
+ }
+ else
+ delete item;
+ }
}
/*****************************************************************************
void
DragSortableListView::CopyItems( BList& items, int32 index )
{
- DeselectAll();
- // by inserting the items after we copied all items first, we avoid
- // cloning an item we already inserted and messing everything up
- // in other words, don't touch the list before we know which items
- // need to be cloned
- BList clonedItems;
- int32 count = items.CountItems();
- for ( int32 i = 0; i < count; i++ )
- {
- BListItem* item = CloneItem( IndexOf( (BListItem*)items.ItemAt( i ) ) );
- if ( item && !clonedItems.AddItem( (void*)item ) )
- delete item;
- }
- for ( int32 i = 0; BListItem* item = (BListItem*)clonedItems.ItemAt( i ); i++ )
- {
- if ( AddItem( item, index ) )
- {
- // after we're done, the newly inserted items will be selected
- Select( index, true );
- // next items will be inserted after this one
- index++;
- }
- else
- delete item;
- }
+ DeselectAll();
+ // by inserting the items after we copied all items first, we avoid
+ // cloning an item we already inserted and messing everything up
+ // in other words, don't touch the list before we know which items
+ // need to be cloned
+ BList clonedItems;
+ int32 count = items.CountItems();
+ for ( int32 i = 0; i < count; i++ )
+ {
+ BListItem* item = CloneItem( IndexOf( (BListItem*)items.ItemAt( i ) ) );
+ if ( item && !clonedItems.AddItem( (void*)item ) )
+ delete item;
+ }
+ for ( int32 i = 0; BListItem* item = (BListItem*)clonedItems.ItemAt( i ); i++ )
+ {
+ if ( AddItem( item, index ) )
+ {
+ // after we're done, the newly inserted items will be selected
+ Select( index, true );
+ // next items will be inserted after this one
+ index++;
+ }
+ else
+ delete item;
+ }
}
/*****************************************************************************
void
DragSortableListView::RemoveItemList( BList& items )
{
- int32 count = items.CountItems();
- for ( int32 i = 0; i < count; i++ )
- {
- BListItem* item = (BListItem*)items.ItemAt( i );
- if ( RemoveItem( item ) )
- delete item;
- }
+ int32 count = items.CountItems();
+ for ( int32 i = 0; i < count; i++ )
+ {
+ BListItem* item = (BListItem*)items.ItemAt( i );
+ if ( RemoveItem( item ) )
+ delete item;
+ }
}
/*****************************************************************************
void
DragSortableListView::RemoveSelected()
{
- BList items;
- for ( int32 i = 0; BListItem* item = ItemAt( CurrentSelection( i ) ); i++ )
- items.AddItem( (void*)item );
- RemoveItemList( items );
+ BList items;
+ for ( int32 i = 0; BListItem* item = ItemAt( CurrentSelection( i ) ); i++ )
+ items.AddItem( (void*)item );
+ RemoveItemList( items );
}
/*****************************************************************************
int32
DragSortableListView::CountSelectedItems() const
{
- int32 count = 0;
- while ( CurrentSelection( count ) >= 0 )
- count++;
- return count;
+ int32 count = 0;
+ while ( CurrentSelection( count ) >= 0 )
+ count++;
+ return count;
}
/*****************************************************************************
void
DragSortableListView::_SetDropAnticipationRect( BRect r )
{
- if ( fDropRect != r )
- {
- if ( fDropRect.IsValid() )
- Invalidate( fDropRect );
- fDropRect = r;
- if ( fDropRect.IsValid() )
- Invalidate( fDropRect );
- }
+ if ( fDropRect != r )
+ {
+ if ( fDropRect.IsValid() )
+ Invalidate( fDropRect );
+ fDropRect = r;
+ if ( fDropRect.IsValid() )
+ Invalidate( fDropRect );
+ }
}
/*****************************************************************************
void
DragSortableListView::_SetDropIndex( int32 index )
{
- if ( fDropIndex != index )
- {
- fDropIndex = index;
- if ( fDropIndex == -1 )
- _SetDropAnticipationRect( BRect( 0.0, 0.0, -1.0, -1.0 ) );
- else
- {
- int32 count = CountItems();
- if ( fDropIndex == count )
- {
- BRect r;
- if ( BListItem* item = ItemAt( count - 1 ) )
- {
- r = ItemFrame( count - 1 );
- r.top = r.bottom + 1.0;
- r.bottom = r.top + 1.0;
- }
- else
- {
- r = Bounds();
- r.bottom--; // compensate for scrollbars moved slightly out of window
- }
- _SetDropAnticipationRect( r );
- }
- else
- {
- BRect r = ItemFrame( fDropIndex );
- r.bottom = r.top + 1.0;
- _SetDropAnticipationRect( r );
- }
- }
- }
+ if ( fDropIndex != index )
+ {
+ fDropIndex = index;
+ if ( fDropIndex == -1 )
+ _SetDropAnticipationRect( BRect( 0.0, 0.0, -1.0, -1.0 ) );
+ else
+ {
+ int32 count = CountItems();
+ if ( fDropIndex == count )
+ {
+ BRect r;
+ if ( BListItem* item = ItemAt( count - 1 ) )
+ {
+ r = ItemFrame( count - 1 );
+ r.top = r.bottom + 1.0;
+ r.bottom = r.top + 1.0;
+ }
+ else
+ {
+ r = Bounds();
+ r.bottom--; // compensate for scrollbars moved slightly out of window
+ }
+ _SetDropAnticipationRect( r );
+ }
+ else
+ {
+ BRect r = ItemFrame( fDropIndex );
+ r.bottom = r.top + 1.0;
+ _SetDropAnticipationRect( r );
+ }
+ }
+ }
}
/*****************************************************************************
void
DragSortableListView::_RemoveDropAnticipationRect()
{
- _SetDropAnticipationRect( BRect( 0.0, 0.0, -1.0, -1.0 ) );
- _SetDropIndex( -1 );
+ _SetDropAnticipationRect( BRect( 0.0, 0.0, -1.0, -1.0 ) );
+ _SetDropIndex( -1 );
}
/*****************************************************************************
* 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 ),
- fCurrentIndex( -1 ),
- fPlaying( false ),
- fDisplayMode( DISPLAY_PATH ),
- fMainWindow( mainWindow ),
- fSelectionChangeMessage( selectionChangeMessage ),
- fLastClickedItem( NULL ),
- fVlcWrapper( wrapper )
+ : 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 )
{
}
PlaylistView::~PlaylistView()
{
- delete fSelectionChangeMessage;
+ delete fSelectionChangeMessage;
}
/*****************************************************************************
void
PlaylistView::AttachedToWindow()
{
- // get pulse message every two frames
- Window()->SetPulseRate( 80000 );
+ // get pulse message every two frames
+ Window()->SetPulseRate( 80000 );
}
/*****************************************************************************
void
PlaylistView::MessageReceived( BMessage* message)
{
- switch ( message->what )
- {
- case MSG_SOUNDPLAY:
- case B_SIMPLE_DATA:
- if ( message->HasPointer( "list" ) )
- {
- // message comes from ourself
- DragSortableListView::MessageReceived( message );
- }
- else
- {
- // message comes from another app (for example Tracker)
- message->AddInt32( "drop index", fDropIndex );
- fMainWindow->PostMessage( message, fMainWindow );
- }
- break;
- default:
- DragSortableListView::MessageReceived( message );
- break;
- }
+ switch ( message->what )
+ {
+ case MSG_SOUNDPLAY:
+ case B_SIMPLE_DATA:
+ if ( message->HasPointer( "list" ) )
+ {
+ // message comes from ourself
+ DragSortableListView::MessageReceived( message );
+ }
+ else
+ {
+ // message comes from another app (for example Tracker)
+ message->AddInt32( "drop index", fDropIndex );
+ fMainWindow->PostMessage( message, fMainWindow );
+ }
+ break;
+ default:
+ DragSortableListView::MessageReceived( message );
+ break;
+ }
}
/*****************************************************************************
void
PlaylistView::MouseDown( BPoint where )
{
- int32 clicks = 1;
- Window()->CurrentMessage()->FindInt32( "clicks", &clicks );
- bool handled = false;
- for ( int32 i = 0; PlaylistItem* item = (PlaylistItem*)ItemAt( i ); i++ )
- {
- BRect r = ItemFrame( i );
- if ( r.Contains( where ) )
- {
- if ( clicks == 2 )
- {
- // only do something if user clicked the same item twice
- if ( fLastClickedItem == item )
- {
- fVlcWrapper->PlaylistJumpTo( i );
- handled = true;
- }
- }
- else
- {
- // remember last clicked item
- fLastClickedItem = item;
- if ( i == fCurrentIndex )
- {
- r.right = r.left + TEXT_OFFSET;
- if ( r.Contains ( where ) )
- {
- fMainWindow->PostMessage( PAUSE_PLAYBACK );
- InvalidateItem( i );
- handled = true;
- }
- }
- }
- break;
- }
- }
- if ( !handled )
- DragSortableListView::MouseDown(where);
+ int32 clicks = 1;
+ Window()->CurrentMessage()->FindInt32( "clicks", &clicks );
+ bool handled = false;
+ for ( int32 i = 0; PlaylistItem* item = (PlaylistItem*)ItemAt( i ); i++ )
+ {
+ BRect r = ItemFrame( i );
+ if ( r.Contains( where ) )
+ {
+ if ( clicks == 2 )
+ {
+ // only do something if user clicked the same item twice
+ if ( fLastClickedItem == item )
+ {
+ 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;
+ }
+ }
+ else
+ {
+ // remember last clicked item
+ fLastClickedItem = item;
+ if ( i == fCurrentIndex )
+ {
+ r.right = r.left + TEXT_OFFSET;
+ if ( r.Contains ( where ) )
+ {
+ fMainWindow->PostMessage( PAUSE_PLAYBACK );
+ InvalidateItem( i );
+ handled = true;
+ }
+ }
+ }
+ break;
+ }
+ }
+ if ( !handled )
+ DragSortableListView::MouseDown(where);
}
/*****************************************************************************
void
PlaylistView::KeyDown( const char* bytes, int32 numBytes )
{
- if ( numBytes < 1 )
- return;
-
- if ( ( bytes[0] == B_BACKSPACE ) || ( bytes[0] == B_DELETE ) )
- {
- RemoveSelected();
- }
- DragSortableListView::KeyDown( bytes, numBytes );
+ if ( numBytes < 1 )
+ return;
+
+ if ( ( bytes[0] == B_BACKSPACE ) || ( bytes[0] == B_DELETE ) )
+ {
+ RemoveSelected();
+ }
+ DragSortableListView::KeyDown( bytes, numBytes );
}
/*****************************************************************************
void
PlaylistView::Pulse()
{
- if ( fMainWindow->IsStopped() )
- SetPlaying( false );
+ if ( fMainWindow->IsStopped() )
+ SetPlaying( false );
}
/*****************************************************************************
void
PlaylistView::SelectionChanged()
{
- BLooper* looper = Looper();
- if ( fSelectionChangeMessage && looper )
- {
- BMessage message( *fSelectionChangeMessage );
- looper->PostMessage( &message );
- }
+ BLooper* looper = Looper();
+ if ( fSelectionChangeMessage && looper )
+ {
+ BMessage message( *fSelectionChangeMessage );
+ looper->PostMessage( &message );
+ }
}
void
PlaylistView::MoveItems( BList& items, int32 index )
{
- 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
- // removal
- if ( fVlcWrapper->PlaylistLock() )
- {
- BList removedItems;
- BList removeItems;
- int32 count = items.CountItems();
- int32 indexOriginal = index;
- // remember currently playing item
- BListItem* playingItem = _PlayingItem();
- // collect item pointers for removal by index
- for ( int32 i = 0; i < count; i++ )
- {
- int32 removeIndex = IndexOf( (BListItem*)items.ItemAt( i ) );
- void* item = fVlcWrapper->PlaylistItemAt( removeIndex );
- if ( item && removeItems.AddItem( item ) )
- {
- if ( removeIndex < index )
- index--;
- }
- // else ??? -> blow up
- }
- // actually remove items using pointers
- for ( int32 i = 0; i < count; i++ )
- {
- void* item = fVlcWrapper->PlaylistRemoveItem( removeItems.ItemAt( i ) );
- if ( item && !removedItems.AddItem( item ) )
- free( item );
- }
- // add items at index
- for ( int32 i = 0; void* item = removedItems.ItemAt( i ); i++ )
- {
- if ( fVlcWrapper->PlaylistAddItem( item, index ) )
- // next items will be inserted after this one
- index++;
- else
- free( item );
- }
- // update GUI
- DragSortableListView::MoveItems( items, indexOriginal );
- // restore currently playing item
- _SetPlayingIndex( playingItem );
- // update interface (in case it isn't playing,
- // there is a chance that it needs to update)
- fMainWindow->PostMessage( MSG_UPDATE );
- fVlcWrapper->PlaylistUnlock();
- }
+#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
+ // removal
+ if ( fVlcWrapper->PlaylistLock() )
+ {
+ BList removedItems;
+ BList removeItems;
+ int32 count = items.CountItems();
+ int32 indexOriginal = index;
+ // remember currently playing item
+ BListItem* playingItem = _PlayingItem();
+ // collect item pointers for removal by index
+ for ( int32 i = 0; i < count; i++ )
+ {
+ int32 removeIndex = IndexOf( (BListItem*)items.ItemAt( i ) );
+ void* item = fVlcWrapper->PlaylistItemAt( removeIndex );
+ if ( item && removeItems.AddItem( item ) )
+ {
+ if ( removeIndex < index )
+ index--;
+ }
+ // else ??? -> blow up
+ }
+ // actually remove items using pointers
+ for ( int32 i = 0; i < count; i++ )
+ {
+ void* item = fVlcWrapper->PlaylistRemoveItem( removeItems.ItemAt( i ) );
+ if ( item && !removedItems.AddItem( item ) )
+ free( item );
+ }
+ // add items at index
+ for ( int32 i = 0; void* item = removedItems.ItemAt( i ); i++ )
+ {
+ if ( fVlcWrapper->PlaylistAddItem( item, index ) )
+ // next items will be inserted after this one
+ index++;
+ else
+ free( item );
+ }
+ // update GUI
+ DragSortableListView::MoveItems( items, indexOriginal );
+ // restore currently playing item
+ _SetPlayingIndex( playingItem );
+ // update interface (in case it isn't playing,
+ // there is a chance that it needs to update)
+ fMainWindow->PostMessage( MSG_UPDATE );
+ fVlcWrapper->PlaylistUnlock();
+ }
+#endif
}
/*****************************************************************************
void
PlaylistView::CopyItems( BList& items, int32 toIndex )
{
- 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
- // removal
- if ( fVlcWrapper->PlaylistLock() )
- {
- BList clonedItems;
- int32 count = items.CountItems();
- // remember currently playing item
- BListItem* playingItem = _PlayingItem();
- // collect cloned item pointers
- for ( int32 i = 0; i < count; i++ )
- {
- int32 index = IndexOf( (BListItem*)items.ItemAt( i ) );
- void* item = fVlcWrapper->PlaylistItemAt( index );
- void* cloned = fVlcWrapper->PlaylistCloneItem( item );
- if ( cloned && !clonedItems.AddItem( cloned ) )
- free( cloned );
-
- }
- // add cloned items at index
- int32 index = toIndex;
- for ( int32 i = 0; void* item = clonedItems.ItemAt( i ); i++ )
- {
- if ( fVlcWrapper->PlaylistAddItem( item, index ) )
- // next items will be inserted after this one
- index++;
- else
- free( item );
- }
- // update GUI
- DragSortableListView::CopyItems( items, toIndex );
- // restore currently playing item
- _SetPlayingIndex( playingItem );
- // update interface (in case it isn't playing,
- // there is a chance that it needs to update)
- fMainWindow->PostMessage( MSG_UPDATE );
- fVlcWrapper->PlaylistUnlock();
- }
+#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
+ // removal
+ if ( fVlcWrapper->PlaylistLock() )
+ {
+ BList clonedItems;
+ int32 count = items.CountItems();
+ // remember currently playing item
+ BListItem* playingItem = _PlayingItem();
+ // collect cloned item pointers
+ for ( int32 i = 0; i < count; i++ )
+ {
+ int32 index = IndexOf( (BListItem*)items.ItemAt( i ) );
+ void* item = fVlcWrapper->PlaylistItemAt( index );
+ void* cloned = fVlcWrapper->PlaylistCloneItem( item );
+ if ( cloned && !clonedItems.AddItem( cloned ) )
+ free( cloned );
+
+ }
+ // add cloned items at index
+ int32 index = toIndex;
+ for ( int32 i = 0; void* item = clonedItems.ItemAt( i ); i++ )
+ {
+ if ( fVlcWrapper->PlaylistAddItem( item, index ) )
+ // next items will be inserted after this one
+ index++;
+ else
+ free( item );
+ }
+ // update GUI
+ DragSortableListView::CopyItems( items, toIndex );
+ // restore currently playing item
+ _SetPlayingIndex( playingItem );
+ // update interface (in case it isn't playing,
+ // there is a chance that it needs to update)
+ fMainWindow->PostMessage( MSG_UPDATE );
+ fVlcWrapper->PlaylistUnlock();
+ }
+#endif
}
/*****************************************************************************
void
PlaylistView::RemoveItemList( BList& items )
{
- if ( fVlcWrapper->PlaylistLock() )
- {
- // remember currently playing item
- BListItem* playingItem = _PlayingItem();
- // collect item pointers for removal
- BList removeItems;
- int32 count = items.CountItems();
- for ( int32 i = 0; i < count; i++ )
- {
- int32 index = IndexOf( (BListItem*)items.ItemAt( i ) );
- void* item = fVlcWrapper->PlaylistItemAt( index );
- if ( item && !removeItems.AddItem( item ) )
- free( item );
- }
- // remove items from playlist
- count = removeItems.CountItems();
- for ( int32 i = 0; void* item = removeItems.ItemAt( i ); i++ )
- {
- fVlcWrapper->PlaylistRemoveItem( item );
- }
- // update GUI
- DragSortableListView::RemoveItemList( items );
- // restore currently playing item
- _SetPlayingIndex( playingItem );
- // update interface (in case it isn't playing,
- // there is a chance that it needs to update)
- fMainWindow->PostMessage( MSG_UPDATE );
- fVlcWrapper->PlaylistUnlock();
- }
+#if 0
+ if ( fVlcWrapper->PlaylistLock() )
+ {
+ // remember currently playing item
+ BListItem* playingItem = _PlayingItem();
+ // collect item pointers for removal
+ BList removeItems;
+ int32 count = items.CountItems();
+ for ( int32 i = 0; i < count; i++ )
+ {
+ int32 index = IndexOf( (BListItem*)items.ItemAt( i ) );
+ void* item = fVlcWrapper->PlaylistItemAt( index );
+ if ( item && !removeItems.AddItem( item ) )
+ free( item );
+ }
+ // remove items from playlist
+ count = removeItems.CountItems();
+ for ( int32 i = 0; void* item = removeItems.ItemAt( i ); i++ )
+ {
+ fVlcWrapper->PlaylistRemoveItem( item );
+ }
+ // update GUI
+ DragSortableListView::RemoveItemList( items );
+ // restore currently playing item
+ _SetPlayingIndex( playingItem );
+ // update interface (in case it isn't playing,
+ // there is a chance that it needs to update)
+ fMainWindow->PostMessage( MSG_UPDATE );
+ fVlcWrapper->PlaylistUnlock();
+ }
+#endif
}
/*****************************************************************************
BListItem*
PlaylistView::CloneItem( int32 atIndex ) const
{
- BListItem* clone = NULL;
-
if ( PlaylistItem* item = dynamic_cast<PlaylistItem*>( ItemAt( atIndex ) ) )
- clone = new PlaylistItem( item->Text() );
- return clone;
+ BListItem* clone = NULL;
+ if ( PlaylistItem* item = dynamic_cast<PlaylistItem*>( ItemAt( atIndex ) ) )
+ clone = new PlaylistItem( item->Text() );
+ return clone;
}
/*****************************************************************************
void
PlaylistView::DrawListItem( BView* owner, int32 index, BRect frame ) const
{
-
if ( PlaylistItem* item = dynamic_cast<PlaylistItem*>( ItemAt( index ) ) )
- item->Draw( owner, frame, index % 2,
- fDisplayMode, index == fCurrentIndex, fPlaying );
+ if ( PlaylistItem* item = dynamic_cast<PlaylistItem*>( ItemAt( index ) ) )
+ item->Draw( owner, frame, index % 2,
+ fDisplayMode, index == fCurrentIndex, fPlaying );
}
/*****************************************************************************
void
PlaylistView::MakeDragMessage( BMessage* message ) const
{
- if ( message )
- {
- message->AddPointer( "list", (void*)this );
- int32 index;
- for ( int32 i = 0; ( index = CurrentSelection( i ) ) >= 0; i++ )
- {
- message->AddInt32( "index", index );
- // add refs to message (inter application communication)
- if ( BStringItem* item = dynamic_cast<BStringItem*>( ItemAt( index ) ) )
- {
- entry_ref ref;
- if ( get_ref_for_path( item->Text(), &ref ) == B_OK )
- message->AddRef( "refs", &ref );
- }
- }
- }
+ if ( message )
+ {
+ message->AddPointer( "list", (void*)this );
+ int32 index;
+ for ( int32 i = 0; ( index = CurrentSelection( i ) ) >= 0; i++ )
+ {
+ message->AddInt32( "index", index );
+ // add refs to message (inter application communication)
+ if ( BStringItem* item = dynamic_cast<BStringItem*>( ItemAt( index ) ) )
+ {
+ entry_ref ref;
+ if ( get_ref_for_path( item->Text(), &ref ) == B_OK )
+ message->AddRef( "refs", &ref );
+ }
+ }
+ }
}
/*****************************************************************************
void
PlaylistView::SetCurrent( int32 index )
{
- if ( fCurrentIndex != index )
- {
- InvalidateItem( fCurrentIndex );
- fCurrentIndex = index;
- InvalidateItem( fCurrentIndex );
- }
+ if ( fCurrentIndex != index )
+ {
+ InvalidateItem( fCurrentIndex );
+ fCurrentIndex = index;
+ InvalidateItem( fCurrentIndex );
+ }
}
/*****************************************************************************
void
PlaylistView::SetPlaying( bool playing )
{
- if ( fPlaying != playing )
- {
- fPlaying = playing;
- InvalidateItem( fCurrentIndex );
- }
+ if ( fPlaying != playing )
+ {
+ fPlaying = playing;
+ InvalidateItem( fCurrentIndex );
+ }
}
/*****************************************************************************
void
PlaylistView::RebuildList()
{
- // remove all items
- int32 count = CountItems();
- while ( BListItem* 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 ) ) );
+ 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( ( item = RemoveItem( --count ) ) )
+ delete item;
+
+ // rebuild listview from VLC's playlist
+ 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 );
}
void
PlaylistView::SortReverse()
{
- if ( int32 count = CountSelectedItems() )
- {
- int32 last = count - 1;
- // remember currently playing item
- BListItem* playingItem = _PlayingItem();
- for ( int32 first = 0; first < count / 2; first++, last-- )
- {
- int32 index1 = CurrentSelection( first);
- int32 index2 = CurrentSelection( last);
- if ( SwapItems( index1, index2 ) )
- {
- // index2 > index1, so the list won't get messed up
- // if we remove the items in that order
- // TODO: Error checking + handling!
- void* item2 = fVlcWrapper->PlaylistRemoveItem( index2 );
- void* item1 = fVlcWrapper->PlaylistRemoveItem( index1 );
- fVlcWrapper->PlaylistAddItem( item2, index1 );
- fVlcWrapper->PlaylistAddItem( item1, index2 );
- }
- }
- // restore currently playing item
- _SetPlayingIndex( playingItem );
- }
+#if 0
+ if ( int32 count = CountSelectedItems() )
+ {
+ int32 last = count - 1;
+ // remember currently playing item
+ BListItem* playingItem = _PlayingItem();
+ for ( int32 first = 0; first < count / 2; first++, last-- )
+ {
+ int32 index1 = CurrentSelection( first);
+ int32 index2 = CurrentSelection( last);
+ if ( SwapItems( index1, index2 ) )
+ {
+ // index2 > index1, so the list won't get messed up
+ // if we remove the items in that order
+ // TODO: Error checking + handling!
+ void* item2 = fVlcWrapper->PlaylistRemoveItem( index2 );
+ void* item1 = fVlcWrapper->PlaylistRemoveItem( index1 );
+ fVlcWrapper->PlaylistAddItem( item2, index1 );
+ fVlcWrapper->PlaylistAddItem( item1, index2 );
+ }
+ }
+ // restore currently playing item
+ _SetPlayingIndex( playingItem );
+ }
+#endif
}
/*****************************************************************************
void
PlaylistView::SortByPath()
{
-
+
}
/*****************************************************************************
void
PlaylistView::SetDisplayMode( uint32 mode )
{
- if ( mode != fDisplayMode )
- {
- fDisplayMode = mode;
- Invalidate();
- }
+ if ( mode != fDisplayMode )
+ {
+ fDisplayMode = mode;
+ Invalidate();
+ }
}
/*****************************************************************************
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;
}
/*****************************************************************************
void
PlaylistView::_SetPlayingIndex( BListItem* playingItem )
{
- for ( int32 i = 0; BListItem* item = ItemAt( i ); i++ )
- {
- if ( item == playingItem )
- {
- fVlcWrapper->PlaylistSetPlaying( i );
- SetCurrent( i );
- break;
- }
- }
+ for ( int32 i = 0; BListItem* item = ItemAt( i ); i++ )
+ {
+ if ( item == playingItem )
+ {
+ 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;
+ }
+ }
}
* 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>
*
class PlaylistView : public DragSortableListView
{
public:
- PlaylistView( BRect frame,
+ PlaylistView( intf_thread_t * p_intf,
+ BRect frame,
InterfaceWindow* mainWindow,
- VlcWrapper* wrapper,
BMessage* selectionChangeMessage = NULL );
~PlaylistView();
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
}
/* BeOS interface headers */
-#include "VlcWrapper.h"
#include "Bitmaps.h"
#include "DrawingTidbits.h"
#include "InterfaceWindow.h"
const rgb_color kSeekRedShadow = (rgb_color){ 178, 0, 0, 255 };
#define DISABLED_SEEK_MESSAGE _("Drop files to play")
+#define SEEKSLIDER_RANGE 2048
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
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 );
SetChapter( index, size );
SetTime( p_intf->p_sys->p_wrapper->GetTimeAsString() );
fLastPulseUpdate = now;
+#endif
}
}
* 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>
class MediaControlView : public BBox
{
public:
- MediaControlView( BRect frame, intf_thread_t *p_intf );
+ MediaControlView( intf_thread_t * p_intf, BRect frame );
virtual ~MediaControlView();
// BBox
bool resizeWidth = false,
bool resizeHeight = false) const;
+ intf_thread_t * p_intf;
VolumeSlider* fVolumeSlider;
SeekSlider* fSeekSlider;
BRect fOldBounds;
bool fIsEnabled;
- intf_thread_t * p_intf;
};
class SeekSlider : public BControl
* 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>
*
#include <vlc/intf.h>
/* BeOS module headers */
-#include "VlcWrapper.h"
#include "InterfaceWindow.h"
#include "MessagesWindow.h"
*****************************************************************************/
void MessagesView::Pulse()
{
+#if 0
bool isScrolling = false;
if( fScrollBar->LockLooper() )
{
}
BTextView::Pulse();
+#endif
}
/*****************************************************************************
* 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>
*
resizingMode, flags )
{
p_intf = _p_intf;
- p_sub = ((intf_sys_t*)p_intf->p_sys)->p_sub;
}
virtual void Pulse();
MessagesWindow.h \
MediaControlView.cpp \
MediaControlView.h \
- VlcWrapper.cpp \
- VlcWrapper.h \
Bitmaps.h \
MsgVals.h \
VideoWindow.h \
* 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>
#include <vlc/intf.h>
/* BeOS interface headers */
-#include "VlcWrapper.h"
#include "InterfaceWindow.h"
#include "ListViews.h"
#include "MsgVals.h"
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") );
// 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 );
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,
{
if ( rebuild )
fListView->RebuildList();
+#if 0
fListView->SetCurrent( p_wrapper->PlaylistCurrent() );
fListView->SetPlaying( p_wrapper->IsPlaying() );
-
+#endif
_CheckItemsEnableState();
}
* 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>
BMenu* fViewMenu;
intf_thread_t * p_intf;
- VlcWrapper * p_wrapper;
};
#endif // BEOS_PLAY_LIST_WINDOW_H
+++ /dev/null
-/*****************************************************************************
- * 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 ¤tIndex, 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 ¤tIndex, 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
-}
+++ /dev/null
-/*****************************************************************************
- * 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;
-};
#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 '+'
projects / vlc / commitdiff