+ src/libvlc.h: use KEY_SPACE instead of ' '
authorEric Petit <titer@videolan.org>
Tue, 17 Aug 2004 17:24:02 +0000 (17:24 +0000)
committerEric Petit <titer@videolan.org>
Tue, 17 Aug 2004 17:24:02 +0000 (17:24 +0000)
 + gui/beos/*: got rid of the VlcWrapper thing which is unneccessaraly
               complex now that we have variables

 Language/subtitle selection works again in the BeOS UI, but there's
 still a lot to fix :|

15 files changed:
modules/gui/beos/Interface.cpp
modules/gui/beos/InterfaceWindow.cpp
modules/gui/beos/InterfaceWindow.h
modules/gui/beos/ListViews.cpp
modules/gui/beos/ListViews.h
modules/gui/beos/MediaControlView.cpp
modules/gui/beos/MediaControlView.h
modules/gui/beos/MessagesWindow.cpp
modules/gui/beos/MessagesWindow.h
modules/gui/beos/Modules.am
modules/gui/beos/PlayListWindow.cpp
modules/gui/beos/PlayListWindow.h
modules/gui/beos/VlcWrapper.cpp [deleted file]
modules/gui/beos/VlcWrapper.h [deleted file]
src/libvlc.h

index 4a4f8ae..e14de40 100644 (file)
@@ -2,7 +2,7 @@
  * intf_beos.cpp: beos interface
  *****************************************************************************
  * Copyright (C) 1999, 2000, 2001 VideoLAN
- * $Id: Interface.cpp,v 1.16 2004/01/26 16:52:31 zorglub Exp $
+ * $Id$
  *
  * Authors: Jean-Marc Dressler <polux@via.ecp.fr>
  *          Samuel Hocevar <sam@zoy.org>
 #include <vlc/aout.h>
 #include <aout_internal.h>
 
-#include "VlcWrapper.h"
 #include "InterfaceWindow.h"
 #include "MsgVals.h"
 
+/*****************************************************************************
+ * intf_sys_t: internal variables of the BeOS interface
+ *****************************************************************************/
+struct intf_sys_t
+{
+    InterfaceWindow * p_window;
+};
+
 /*****************************************************************************
  * Local prototype
  *****************************************************************************/
@@ -59,44 +66,36 @@ int E_(OpenIntf) ( vlc_object_t *p_this )
 
     /* Allocate instance and initialize some members */
     p_intf->p_sys = (intf_sys_t*) malloc( sizeof( intf_sys_t ) );
-    if( p_intf->p_sys == NULL )
+    if( !p_intf->p_sys )
     {
         msg_Err( p_intf, "out of memory" );
-        return( 1 );
+        return VLC_EGENERIC;
     }
     
-    p_intf->p_sys->p_sub = msg_Subscribe( p_intf );
-    p_intf->p_sys->p_wrapper = new VlcWrapper( p_intf );
     p_intf->pf_run = Run;
 
     /* Create the interface window */
-    BScreen screen(B_MAIN_SCREEN_ID);
-    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;
 }
 
 /*****************************************************************************
@@ -106,14 +105,11 @@ void E_(CloseIntf) ( vlc_object_t *p_this )
 {
     intf_thread_t *p_intf = (intf_thread_t*) p_this;
 
-    msg_Unsubscribe( p_intf, p_intf->p_sys->p_sub );
-
     /* Destroy the interface window */
     if( p_intf->p_sys->p_window->Lock() )
         p_intf->p_sys->p_window->Quit();
 
     /* Destroy structure */
-    delete p_intf->p_sys->p_wrapper;
     free( p_intf->p_sys );
 }
 
@@ -125,13 +121,7 @@ static void Run( intf_thread_t *p_intf )
 {
     while( !p_intf->b_die )
     {
-        /* Update VlcWrapper internals (p_input, etc) */
-        p_intf->p_sys->p_wrapper->UpdateInput();
-
-        /* Manage the slider */
         p_intf->p_sys->p_window->UpdateInterface();
-
-        /* Wait a bit */
         msleep( INTF_IDLE_SLEEP );
     }
 }
index 532aac0..9e4da26 100644 (file)
@@ -44,7 +44,6 @@
 #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
@@ -101,78 +100,78 @@ make_sure_frame_is_within_limits( BRect& frame, float minWidth, float minHeight,
 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 );
+            }
+        }
+    }
 }
 
 
@@ -180,18 +179,25 @@ collect_folder_contents( BDirectory& dir, BList& list, bool& deep, bool& asked,
  * InterfaceWindow
  *****************************************************************************/
 
-InterfaceWindow::InterfaceWindow( BRect frame, const char* name,
-                                  intf_thread_t* p_interface )
+InterfaceWindow::InterfaceWindow( intf_thread_t * _p_intf, BRect frame,
+                                  const char * name )
     : BWindow( frame, name, B_TITLED_WINDOW_LOOK, B_NORMAL_WINDOW_FEEL,
                B_NOT_ZOOMABLE | B_WILL_ACCEPT_FIRST_CLICK | B_ASYNCHRONOUS_CONTROLS ),
-      p_intf( p_interface ),
+      
+      /* Initializations */
+      p_intf( _p_intf ),
+      p_input( NULL ),
+      p_playlist( NULL ),
+      
       fFilePanel( NULL ),
       fLastUpdateTime( system_time() ),
-         fSettings( new BMessage( 'sett' ) ),
-         p_wrapper( p_intf->p_sys->p_wrapper )
+      fSettings( new BMessage( 'sett' ) )
 {
-    fPlaylistIsEmpty = !( p_wrapper->PlaylistSize() > 0 );
-    
+    char psz_tmp[1024];
+#define ADD_ELLIPSIS( a ) \
+    memset( psz_tmp, 0, 1024 ); \
+    snprintf( psz_tmp, 1024, "%s%s", a, B_UTF8_ELLIPSIS );
+
     BScreen screen;
     BRect screen_rect = screen.Frame();
     BRect window_rect;
@@ -212,8 +218,7 @@ InterfaceWindow::InterfaceWindow( BRect frame, const char* name,
     fMessagesWindow = new MessagesWindow( p_intf, window_rect, _("Messages") );
 
     // the media control view
-    p_mediaControl = new MediaControlView( BRect( 0.0, 0.0, 250.0, 50.0 ),
-                                           p_intf );
+    p_mediaControl = new MediaControlView( p_intf, BRect( 0.0, 0.0, 250.0, 50.0 ) );
     p_mediaControl->SetViewColor( ui_color( B_PANEL_BACKGROUND_COLOR ) );
 
     float width, height;
@@ -234,26 +239,25 @@ InterfaceWindow::InterfaceWindow( BRect frame, const char* name,
     p_mediaControl->MoveTo( fMenuBar->Bounds().LeftBottom() + BPoint(0.0, 1.0) );
     AddChild( fMenuBar );
 
+
     // Add the file Menu
     BMenu* fileMenu = new BMenu( _("File") );
     fMenuBar->AddItem( fileMenu );
-    fileMenu->AddItem( new BMenuItem( _AddEllipsis(_("Open File")),
-                                      new BMessage( OPEN_FILE ), 'O') );
-    
+    ADD_ELLIPSIS( _("Open File") );
+    fileMenu->AddItem( new BMenuItem( psz_tmp, new BMessage( OPEN_FILE ), 'O') );
     fileMenu->AddItem( new CDMenu( _("Open Disc") ) );
-
-    fileMenu->AddItem( new BMenuItem( _AddEllipsis(_("Open Subtitles")),
-                                      new BMessage( LOAD_SUBFILE ) ) );
+    ADD_ELLIPSIS( _("Open Subtitles") );
+    fileMenu->AddItem( new BMenuItem( psz_tmp, new BMessage( LOAD_SUBFILE ) ) );
 
     fileMenu->AddSeparatorItem();
-    BMenuItem* item = new BMenuItem( _AddEllipsis(_("About")),
-                                     new BMessage( B_ABOUT_REQUESTED ), 'A');
+    ADD_ELLIPSIS( _("About") );
+    BMenuItem* item = new BMenuItem( psz_tmp, new BMessage( B_ABOUT_REQUESTED ), 'A');
     item->SetTarget( be_app );
     fileMenu->AddItem( item );
     fileMenu->AddItem( new BMenuItem( _("Quit"), new BMessage( B_QUIT_REQUESTED ), 'Q') );
 
-    fLanguageMenu = new LanguageMenu( _("Language"), AUDIO_ES, p_wrapper);
-    fSubtitlesMenu = new LanguageMenu( _("Subtitles"), SPU_ES, p_wrapper);
+    fLanguageMenu = new LanguageMenu( p_intf, _("Language"), "audio-es" );
+    fSubtitlesMenu = new LanguageMenu( p_intf, _("Subtitles"), "spu-es" );
 
     /* Add the Audio menu */
     fAudioMenu = new BMenu( _("Audio") );
@@ -301,17 +305,17 @@ InterfaceWindow::InterfaceWindow( BRect frame, const char* name,
 
     /* Add the Show menu */
     fShowMenu = new BMenu( _("Window") );
-    fShowMenu->AddItem( new BMenuItem( _AddEllipsis(_("Playlist")),
-                                       new BMessage( OPEN_PLAYLIST ), 'P') );
-    fShowMenu->AddItem( new BMenuItem( _AddEllipsis(_("Messages")),
-                                       new BMessage( OPEN_MESSAGES ), 'M' ) );
-    fShowMenu->AddItem( new BMenuItem( _AddEllipsis(_("Preferences")),
-                                       new BMessage( OPEN_PREFERENCES ), 'S' ) );
+    ADD_ELLIPSIS( _("Playlist") );
+    fShowMenu->AddItem( new BMenuItem( psz_tmp, new BMessage( OPEN_PLAYLIST ), 'P') );
+    ADD_ELLIPSIS( _("Messages") );
+    fShowMenu->AddItem( new BMenuItem( psz_tmp, new BMessage( OPEN_MESSAGES ), 'M' ) );
+    ADD_ELLIPSIS( _("Preferences") );
+    fShowMenu->AddItem( new BMenuItem( psz_tmp, new BMessage( OPEN_PREFERENCES ), 'S' ) );
     fMenuBar->AddItem( fShowMenu );
 
-       // add the media control view after the menubar is complete
-       // 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 */
@@ -325,17 +329,28 @@ InterfaceWindow::InterfaceWindow( BRect frame, const char* name,
 
 InterfaceWindow::~InterfaceWindow()
 {
+    if( p_input )
+    {
+        vlc_object_release( p_input );
+    }
+    if( p_playlist )
+    {
+        vlc_object_release( p_playlist );
+    }
     if( fPlaylistWindow )
+    {
         fPlaylistWindow->ReallyQuit();
-    fPlaylistWindow = NULL;
+    }
     if( fMessagesWindow )
+    {
         fMessagesWindow->ReallyQuit();
-    fMessagesWindow = NULL;
+    }
     if( fPreferencesWindow )
+    {
         fPreferencesWindow->ReallyQuit();
-    fPreferencesWindow = NULL;
-       delete fFilePanel;
-       delete fSettings;
+    }
+    delete fFilePanel;
+    delete fSettings;
 }
 
 /*****************************************************************************
@@ -357,16 +372,16 @@ InterfaceWindow::FrameResized(float width, float height)
  *****************************************************************************/
 void InterfaceWindow::MessageReceived( BMessage * p_message )
 {
-    int playback_status;      // remember playback state
-    playback_status = p_wrapper->InputStatus();
-
     switch( p_message->what )
     {
         case B_ABOUT_REQUESTED:
         {
-            BAlert* alert = new BAlert( "VLC " PACKAGE_VERSION,
-                                        "VLC " PACKAGE_VERSION " for BeOS"
-                                        "\n\n<www.videolan.org>", _("OK"));
+            BAlert * alert;
+            
+            alert = new BAlert( "VLC media player" VERSION,
+                                "VLC media player" VERSION " (BeOS interface)\n\n"
+                                "The VideoLAN team <videolan@videolan.org>\n"
+                                "http://www.videolan.org/", _("OK") );
             alert->Go();
             break;
         }
@@ -374,11 +389,11 @@ void InterfaceWindow::MessageReceived( BMessage * p_message )
             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:
@@ -391,14 +406,18 @@ void InterfaceWindow::MessageReceived( BMessage * p_message )
                 fPlaylistWindow->Unlock();
             }
             break;
+
         case OPEN_DVD:
             {
-                const char *psz_device;
-                BString type( "dvd" );
-                if( p_message->FindString( "device", &psz_device ) == B_OK )
+                const char * psz_device;
+                if( p_playlist &&
+                    p_message->FindString( "device", &psz_device ) == B_OK )
                 {
-                    BString device( psz_device );
-                    p_wrapper->OpenDisc( type, device, 0, 0 );
+                    char psz_uri[1024];
+                    memset( psz_uri, 0, 1024 );
+                    snprintf( psz_uri, 1024, "dvdnav:%s", psz_device );
+                    playlist_Add( p_playlist, psz_uri, psz_device,
+                                  PLAYLIST_APPEND | PLAYLIST_GO, PLAYLIST_END );
                 }
                 _UpdatePlaylist();
             }
@@ -411,280 +430,324 @@ void InterfaceWindow::MessageReceived( BMessage * p_message )
             {
                 BPath path( &ref );
                 if ( path.InitCheck() == B_OK )
-                    p_wrapper->LoadSubFile( path.Path() );
+                    config_PutPsz( p_intf, "sub-file", path.Path() );
             }
             break;
         }
 
         case STOP_PLAYBACK:
-            // this currently stops playback not nicely
-            if (playback_status != -1)
+            if( p_playlist )
             {
-                p_wrapper->PlaylistStop();
-                p_mediaControl->SetStatus(-1, INPUT_RATE_DEFAULT);
+                playlist_Stop( p_playlist );
             }
+            p_mediaControl->SetStatus(-1, INPUT_RATE_DEFAULT);
             break;
     
         case START_PLAYBACK:
             /*  starts playing in normal mode */
     
         case PAUSE_PLAYBACK:
-            /* toggle between pause and play */
-            if (playback_status > -1)
+            if( p_input )
             {
-                /* pause if currently playing */
-                if ( playback_status == PLAYING_S )
+                if( var_GetInteger( p_input, "state" ) == PAUSE_S )
                 {
-                    p_wrapper->PlaylistPause();
+                    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:
         {
@@ -712,13 +775,12 @@ void InterfaceWindow::MessageReceived( BMessage * p_message )
             break;
         }
         case MSG_UPDATE:
-               UpdateInterface();
-               break;
+            UpdateInterface();
+            break;
         default:
             BWindow::MessageReceived( p_message );
             break;
     }
-
 }
 
 /*****************************************************************************
@@ -726,10 +788,13 @@ void InterfaceWindow::MessageReceived( BMessage * p_message )
  *****************************************************************************/
 bool InterfaceWindow::QuitRequested()
 {
-    p_wrapper->PlaylistStop();
+    if( p_playlist )
+    {
+        playlist_Stop( p_playlist );
+    }
     p_mediaControl->SetStatus(-1, INPUT_RATE_DEFAULT);
 
-       _StoreSettings();
+     _StoreSettings();
    
     p_intf->b_die = 1;
 
@@ -741,41 +806,57 @@ bool InterfaceWindow::QuitRequested()
  *****************************************************************************/
 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();
@@ -783,24 +864,29 @@ void InterfaceWindow::UpdateInterface()
     }
     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();
 }
 
@@ -819,12 +905,12 @@ InterfaceWindow::IsStopped() const
 void
 InterfaceWindow::_UpdatePlaylist()
 {
-    if ( fPlaylistWindow->Lock() )
+    if( fPlaylistWindow->Lock() )
     {
         fPlaylistWindow->UpdatePlaylist( true );
         fPlaylistWindow->Unlock();
-        p_mediaControl->SetEnabled( p_wrapper->PlaylistSize() );
     }
+    p_mediaControl->SetEnabled( p_playlist->i_size );
 }
 
 /*****************************************************************************
@@ -862,10 +948,7 @@ InterfaceWindow::_SetMenusEnabled(bool hasFile, bool hasChapters, bool hasTitles
              fSubtitlesMenu->SetEnabled( hasFile );
         if ( fSpeedMenu->IsEnabled() != hasFile )
              fSpeedMenu->SetEnabled( hasFile );
-        // "goto menu" menu item
-        bool hasMenu = p_wrapper->IsUsingMenus();
-        if ( fGotoMenuMI->IsEnabled() != hasMenu )
-             fGotoMenuMI->SetEnabled( hasMenu );
+        fGotoMenuMI->SetEnabled( true );
         Unlock();
     }
 }
@@ -909,8 +992,10 @@ InterfaceWindow::_UpdateSpeedMenu( int rate )
             break;
     }
 
-    if ( !toMark->IsMarked() )
+    if ( toMark && !toMark->IsMarked() )
+    {
         toMark->SetMarked( true );
+    }
 }
 
 /*****************************************************************************
@@ -919,58 +1004,58 @@ InterfaceWindow::_UpdateSpeedMenu( int rate )
 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();
+    }
 }
 
 /*****************************************************************************
@@ -979,35 +1064,35 @@ launch_window( BWindow* window, bool showing )
 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 );
+    }
 }
 
 /*****************************************************************************
@@ -1021,37 +1106,37 @@ InterfaceWindow::_StoreSettings()
     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" );
 }
 
 
@@ -1087,38 +1172,38 @@ void CDMenu::AttachedToWindow(void)
  *****************************************************************************/
 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 );
 }
 
 /*****************************************************************************
@@ -1126,6 +1211,7 @@ LanguageMenu::LanguageMenu( const char *name, int menu_kind,
  *****************************************************************************/
 LanguageMenu::~LanguageMenu()
 {
+    free( psz_variable );
 }
 
 /*****************************************************************************
@@ -1133,19 +1219,44 @@ LanguageMenu::~LanguageMenu()
  *****************************************************************************/
 void LanguageMenu::AttachedToWindow()
 {
+    BMenuItem * item;
+
     // remove all items
-    while ( BMenuItem* item = RemoveItem( 0L ) )
+    while( ( item = RemoveItem( 0L ) ) )
+    {
         delete item;
+    }
 
     SetRadioMode( true );
-       if ( BList *list = p_wrapper->GetChannels( kind ) )
-       {
-           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();
 }
 
@@ -1170,14 +1281,41 @@ TitleMenu::~TitleMenu()
  *****************************************************************************/
 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();
 }
 
@@ -1203,24 +1341,43 @@ ChapterMenu::~ChapterMenu()
  *****************************************************************************/
 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();
+}
 
 
 /*****************************************************************************
@@ -1229,27 +1386,27 @@ void ChapterMenu::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;
 }
 
 /*****************************************************************************
@@ -1258,25 +1415,25 @@ load_settings( BMessage* message, const char* fileName, const char* folder )
 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;
 }
index c2932a8..30897e6 100644 (file)
@@ -2,7 +2,7 @@
  * InterfaceWindow.h: BeOS interface window class prototype
  *****************************************************************************
  * Copyright (C) 1999, 2000, 2001 VideoLAN
- * $Id: InterfaceWindow.h,v 1.15 2004/01/26 16:52:31 zorglub Exp $
+ * $Id$
  *
  * Authors: Jean-Marc Dressler <polux@via.ecp.fr>
  *          Tony Castley <tcastley@mail.powerup.com.au>
@@ -36,7 +36,6 @@ class PlayListWindow;
 class BFilePanel;
 class PreferencesWindow;
 class MessagesWindow;
-class VlcWrapper;
 
 class CDMenu : public BMenu
 {
@@ -53,16 +52,16 @@ class CDMenu : public BMenu
 class LanguageMenu : public BMenu
 {
  public:
-                            LanguageMenu( const char* name,
-                                          int menu_kind,
-                                          VlcWrapper *p_wrapper );
+                            LanguageMenu( intf_thread_t * p_intf,
+                                          const char * psz_name,
+                                          char * psz_variable );
     virtual                 ~LanguageMenu();
 
     virtual void            AttachedToWindow();
 
  private:
-    VlcWrapper *            p_wrapper;
-    int                     kind;
+    intf_thread_t         * p_intf;
+    char                  * psz_variable;
 };
 
 class TitleMenu : public BMenu
@@ -91,9 +90,9 @@ class ChapterMenu : public BMenu
 class InterfaceWindow : public BWindow
 {
  public:
-                            InterfaceWindow( BRect frame,
-                                             const char* name,
-                                             intf_thread_t* p_interface );
+                            InterfaceWindow( intf_thread_t * p_intf,
+                                             BRect frame,
+                                             const char * name );
     virtual                 ~InterfaceWindow();
 
                             // BWindow
@@ -119,10 +118,11 @@ class InterfaceWindow : public BWindow
                        void                    _RestoreSettings();
                        void                    _StoreSettings();
 
-    intf_thread_t*          p_intf;
-    es_descriptor_t*        p_spu_es;
+    intf_thread_t         * p_intf;
+    input_thread_t        * p_input;
+    playlist_t            * p_playlist;
+    es_descriptor_t       * p_spu_es;
 
-    bool                    fPlaylistIsEmpty;
     BFilePanel*             fFilePanel;
     PlayListWindow*         fPlaylistWindow;
     PreferencesWindow*      fPreferencesWindow;
@@ -151,7 +151,6 @@ class InterfaceWindow : public BWindow
     bigtime_t               fLastUpdateTime;
        BMessage*                               fSettings;      // we keep the message arround
                                                                                // for forward compatibility
-    VlcWrapper*                                p_wrapper;
 };
 
 
index cdeefda..ef613db 100644 (file)
@@ -2,7 +2,7 @@
  * ListViews.h: BeOS interface list view class implementation
  *****************************************************************************
  * Copyright (C) 1999, 2000, 2001 VideoLAN
- * $Id: ListViews.cpp,v 1.6 2004/01/26 16:52:31 zorglub Exp $
+ * $Id$
  *
  * Authors: Stephan Aßmus <stippi@yellowbites.com>
  *
 #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()
@@ -62,93 +61,93 @@ 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()
@@ -161,37 +160,37 @@ 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 );
+    }
 }
 
 /*****************************************************************************
@@ -200,91 +199,91 @@ DragSortableListView::Draw( BRect updateRect )
 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;
 }
 
 /*****************************************************************************
@@ -293,9 +292,9 @@ DragSortableListView::InitiateDrag( BPoint point, int32 index, bool )
 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();
 }
 
 /*****************************************************************************
@@ -304,40 +303,40 @@ DragSortableListView::WindowActivated( bool active )
 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;
+    }
 }
 
 /*****************************************************************************
@@ -346,51 +345,51 @@ DragSortableListView::MessageReceived(BMessage* message)
 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;
+    }
 }
 
 /*****************************************************************************
@@ -399,11 +398,11 @@ DragSortableListView::MouseMoved(BPoint where, uint32 transit, const BMessage *m
 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 );
 }
 
 /*****************************************************************************
@@ -412,7 +411,7 @@ DragSortableListView::MouseUp( BPoint where )
 void
 DragSortableListView::DrawItem( BListItem *item, BRect itemFrame, bool complete )
 {
-       DrawListItem( this, IndexOf( item ), itemFrame );
+    DrawListItem( this, IndexOf( item ), itemFrame );
 }
 
 /*****************************************************************************
@@ -421,11 +420,11 @@ DragSortableListView::DrawItem( BListItem *item, BRect itemFrame, bool complete
 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 );
 }
 
 /*****************************************************************************
@@ -434,35 +433,35 @@ DragSortableListView::ModifiersChanged()
 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;
+    }
 }
 
 /*****************************************************************************
@@ -471,31 +470,31 @@ DragSortableListView::MoveItems( BList& items, int32 index )
 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;
+    }
 }
 
 /*****************************************************************************
@@ -504,13 +503,13 @@ DragSortableListView::CopyItems( BList& items, int32 index )
 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;
+    }
 }
 
 /*****************************************************************************
@@ -519,10 +518,10 @@ DragSortableListView::RemoveItemList( BList& items )
 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 );
 }
 
 /*****************************************************************************
@@ -531,10 +530,10 @@ DragSortableListView::RemoveSelected()
 int32
 DragSortableListView::CountSelectedItems() const
 {
-       int32 count = 0;
-       while ( CurrentSelection( count ) >= 0 )
-               count++;
-       return count;
+    int32 count = 0;
+    while ( CurrentSelection( count ) >= 0 )
+        count++;
+    return count;
 }
 
 /*****************************************************************************
@@ -543,14 +542,14 @@ DragSortableListView::CountSelectedItems() const
 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 );
+    }
 }
 
 /*****************************************************************************
@@ -559,38 +558,38 @@ DragSortableListView::_SetDropAnticipationRect( BRect r )
 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 );
+            }
+        }
+    }
 }
 
 /*****************************************************************************
@@ -599,34 +598,34 @@ DragSortableListView::_SetDropIndex( int32 index )
 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;
 }
 
 /*****************************************************************************
@@ -635,8 +634,8 @@ PlaylistView::~PlaylistView()
 void
 PlaylistView::AttachedToWindow()
 {
-       // get pulse message every two frames
-       Window()->SetPulseRate( 80000 );
+    // get pulse message every two frames
+    Window()->SetPulseRate( 80000 );
 }
 
 /*****************************************************************************
@@ -645,26 +644,26 @@ PlaylistView::AttachedToWindow()
 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;
+    }
 }
 
 /*****************************************************************************
@@ -673,43 +672,50 @@ PlaylistView::MessageReceived( BMessage* message)
 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);
 }
 
 /*****************************************************************************
@@ -718,14 +724,14 @@ PlaylistView::MouseDown( BPoint 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 );
 }
 
 /*****************************************************************************
@@ -734,8 +740,8 @@ PlaylistView::KeyDown( const char* bytes, int32 numBytes )
 void
 PlaylistView::Pulse()
 {
-       if ( fMainWindow->IsStopped() )
-               SetPlaying( false );
+    if ( fMainWindow->IsStopped() )
+        SetPlaying( false );
 }
 
 /*****************************************************************************
@@ -744,12 +750,12 @@ PlaylistView::Pulse()
 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 );
+    }
 }
 
 
@@ -759,55 +765,57 @@ PlaylistView::SelectionChanged()
 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
 }
 
 /*****************************************************************************
@@ -816,45 +824,47 @@ PlaylistView::MoveItems( BList& items, int32 index )
 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
 }
 
 /*****************************************************************************
@@ -863,35 +873,37 @@ PlaylistView::CopyItems( BList& items, int32 toIndex )
 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
 }
 
 /*****************************************************************************
@@ -900,10 +912,10 @@ PlaylistView::RemoveItemList( BList& items )
 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;
 }
 
 /*****************************************************************************
@@ -912,9 +924,9 @@ PlaylistView::CloneItem( int32 atIndex ) const
 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 );
 }
 
 /*****************************************************************************
@@ -923,22 +935,22 @@ PlaylistView::DrawListItem( BView* owner, int32 index, BRect frame ) const
 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 );
+            }
+        }
+    }
 }
 
 /*****************************************************************************
@@ -947,12 +959,12 @@ PlaylistView::MakeDragMessage( BMessage* message ) const
 void
 PlaylistView::SetCurrent( int32 index )
 {
-       if ( fCurrentIndex != index )
-       {
-               InvalidateItem( fCurrentIndex );
-               fCurrentIndex = index;
-               InvalidateItem( fCurrentIndex );
-       }
+    if ( fCurrentIndex != index )
+    {
+        InvalidateItem( fCurrentIndex );
+        fCurrentIndex = index;
+        InvalidateItem( fCurrentIndex );
+    }
 }
 
 /*****************************************************************************
@@ -961,11 +973,11 @@ PlaylistView::SetCurrent( int32 index )
 void
 PlaylistView::SetPlaying( bool playing )
 {
-       if ( fPlaying != playing )
-       {
-               fPlaying = playing;
-               InvalidateItem( fCurrentIndex );
-       }
+    if ( fPlaying != playing )
+    {
+        fPlaying = playing;
+        InvalidateItem( fCurrentIndex );
+    }
 }
 
 /*****************************************************************************
@@ -974,14 +986,28 @@ PlaylistView::SetPlaying( bool playing )
 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 );
 }
 
 
@@ -991,29 +1017,31 @@ PlaylistView::RebuildList()
 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
 }
 
 /*****************************************************************************
@@ -1022,7 +1050,7 @@ PlaylistView::SortReverse()
 void
 PlaylistView::SortByPath()
 {
-       
+    
 }
 
 /*****************************************************************************
@@ -1039,11 +1067,11 @@ PlaylistView::SortByName()
 void
 PlaylistView::SetDisplayMode( uint32 mode )
 {
-       if ( mode != fDisplayMode )
-       {
-               fDisplayMode = mode;
-               Invalidate();
-       }
+    if ( mode != fDisplayMode )
+    {
+        fDisplayMode = mode;
+        Invalidate();
+    }
 }
 
 /*****************************************************************************
@@ -1052,9 +1080,18 @@ PlaylistView::SetDisplayMode( uint32 mode )
 BListItem*
 PlaylistView::_PlayingItem() const
 {
-       int32 currentIndex, size;
-       fVlcWrapper->GetPlaylistInfo( currentIndex, size );
-       return ItemAt( currentIndex );
+    playlist_t * p_playlist;
+    p_playlist = (playlist_t *) vlc_object_find( p_intf,
+        VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
+
+    if( !p_playlist )
+    {
+        return NULL;
+    }
+
+    BListItem * item = ItemAt( p_playlist->i_index );
+    vlc_object_release( p_playlist );
+    return item;
 }
 
 /*****************************************************************************
@@ -1063,13 +1100,24 @@ PlaylistView::_PlayingItem() const
 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;
+        }
+    }
 }
index 9628598..87f3eef 100644 (file)
@@ -2,7 +2,7 @@
  * ListViews.h: BeOS interface list view class prototype
  *****************************************************************************
  * Copyright (C) 1999, 2000, 2001 VideoLAN
- * $Id: ListViews.h,v 1.5 2004/01/26 16:52:31 zorglub Exp $
+ * $Id$
  *
  * Authors: Stephan Aßmus <stippi@yellowbites.com>
  *
@@ -113,9 +113,9 @@ class DragSortableListView : public BListView
 class PlaylistView : public DragSortableListView
 {
  public:
-                                                       PlaylistView( BRect frame,
+                                                       PlaylistView( intf_thread_t * p_intf,
+                                                                     BRect frame,
                                                                                  InterfaceWindow* mainWindow,
-                                                                                 VlcWrapper* wrapper,
                                                                                  BMessage* selectionChangeMessage = NULL );
                                                        ~PlaylistView();
 
@@ -154,14 +154,14 @@ class PlaylistView : public DragSortableListView
                        BListItem*              _PlayingItem() const;
                        void                    _SetPlayingIndex( BListItem* item );
 
+    intf_thread_t * p_intf;
+
        int32                                   fCurrentIndex;
        bool                                    fPlaying;
        uint32                                  fDisplayMode;
        InterfaceWindow*                fMainWindow;
        BMessage*                               fSelectionChangeMessage;
        PlaylistItem*                   fLastClickedItem;
-       
-       VlcWrapper*                             fVlcWrapper;
 };
 
 #endif // LIST_VIEWS_H
index d580b31..1839e34 100644 (file)
@@ -38,7 +38,6 @@ extern "C"
 }
 
 /* BeOS interface headers */
-#include "VlcWrapper.h"
 #include "Bitmaps.h"
 #include "DrawingTidbits.h"
 #include "InterfaceWindow.h"
@@ -67,6 +66,7 @@ const rgb_color kSeekRedLight = (rgb_color){ 255, 152, 152, 255 };
 const rgb_color kSeekRedShadow = (rgb_color){ 178, 0, 0, 255 };
 
 #define DISABLED_SEEK_MESSAGE _("Drop files to play")
+#define SEEKSLIDER_RANGE 2048
 
 enum
 {
@@ -77,17 +77,16 @@ enum
 };
 
 // constructor
-MediaControlView::MediaControlView(BRect frame, intf_thread_t *p_interface)
+MediaControlView::MediaControlView( intf_thread_t * _p_intf, BRect frame)
        : BBox(frame, NULL, B_FOLLOW_NONE, B_WILL_DRAW | B_FRAME_EVENTS | B_PULSE_NEEDED,
                   B_PLAIN_BORDER),
+      p_intf( _p_intf ),
       fScrubSem(B_ERROR),
       fCurrentRate(INPUT_RATE_DEFAULT),
       fCurrentStatus(-1),
       fBottomControlHeight(0.0),
       fIsEnabled( true )
 {
-    p_intf = p_interface;
-
        BRect frame(0.0, 0.0, 10.0, 10.0);
        
     // Seek Slider
@@ -1335,6 +1334,7 @@ PositionInfoView::Pulse()
        bigtime_t now = system_time();
        if ( now - fLastPulseUpdate > 900000 )
        {
+#if 0
                int32 index, size;
                p_intf->p_sys->p_wrapper->GetPlaylistInfo( index, size );
                SetFile( index + 1, size );
@@ -1344,6 +1344,7 @@ PositionInfoView::Pulse()
                SetChapter( index, size );
                SetTime( p_intf->p_sys->p_wrapper->GetTimeAsString() );
                fLastPulseUpdate = now;
+#endif
        }
 }
 
index 7da17d7..f324a35 100644 (file)
@@ -2,7 +2,7 @@
  * MediaControlView.h: beos interface
  *****************************************************************************
  * Copyright (C) 1999, 2000, 2001 VideoLAN
- * $Id: MediaControlView.h,v 1.5 2003/01/25 01:03:44 titer Exp $
+ * $Id$
  *
  * Authors: Tony Castley <tony@castley.net>
  *          Stephan Aßmus <stippi@yellowbites.com>
@@ -38,7 +38,7 @@ class VolumeSlider;
 class MediaControlView : public BBox
 {
  public:
-                                                               MediaControlView( BRect frame, intf_thread_t *p_intf );
+                                                               MediaControlView( intf_thread_t * p_intf, BRect frame );
        virtual                                         ~MediaControlView();
 
                                                                // BBox
@@ -70,6 +70,7 @@ class MediaControlView : public BBox
                                                                                           bool resizeWidth = false,
                                                                                           bool resizeHeight = false) const;
 
+                       intf_thread_t *     p_intf;
 
                        VolumeSlider*           fVolumeSlider;
                        SeekSlider*                     fSeekSlider;
@@ -88,7 +89,6 @@ class MediaControlView : public BBox
                        BRect                           fOldBounds;
                        bool                fIsEnabled;
                        
-                       intf_thread_t *     p_intf;
 };
 
 class SeekSlider : public BControl
index c54e0fd..a3f957d 100644 (file)
@@ -2,7 +2,7 @@
  * MessagesWindow.cpp: beos interface
  *****************************************************************************
  * Copyright (C) 1999, 2000, 2001 VideoLAN
- * $Id: MessagesWindow.cpp,v 1.12 2004/01/26 16:52:31 zorglub Exp $
+ * $Id$
  *
  * Authors: Eric Petit <titer@videolan.org>
  *
@@ -30,7 +30,6 @@
 #include <vlc/intf.h>
 
 /* BeOS module headers */
-#include "VlcWrapper.h"
 #include "InterfaceWindow.h"
 #include "MessagesWindow.h"
 
@@ -39,6 +38,7 @@
  *****************************************************************************/
 void MessagesView::Pulse()
 {
+#if 0
     bool isScrolling = false;
     if( fScrollBar->LockLooper() )
     {
@@ -123,6 +123,7 @@ void MessagesView::Pulse()
     }
 
     BTextView::Pulse();
+#endif
 }
 
 /*****************************************************************************
index ef269b8..e6e54ad 100644 (file)
@@ -2,7 +2,7 @@
  * MessagesWindow.h
  *****************************************************************************
  * Copyright (C) 1999, 2000, 2001 VideoLAN
- * $Id: MessagesWindow.h,v 1.4 2003/05/17 18:30:41 titer Exp $
+ * $Id$
  *
  * Authors: Eric Petit <titer@videolan.org>
  *
@@ -36,7 +36,6 @@ class MessagesView : public BTextView
                                               resizingMode, flags )
                              {
                                  p_intf = _p_intf;
-                                 p_sub = ((intf_sys_t*)p_intf->p_sys)->p_sub;
                              }
         virtual void         Pulse();
 
index 86b7d6f..4cdf360 100644 (file)
@@ -19,8 +19,6 @@ SOURCES_beos = \
        MessagesWindow.h \
        MediaControlView.cpp \
        MediaControlView.h \
-       VlcWrapper.cpp \
-       VlcWrapper.h \
        Bitmaps.h \
        MsgVals.h \
        VideoWindow.h \
index 547c099..5ee3476 100644 (file)
@@ -2,7 +2,7 @@
  * PlayListWindow.cpp: beos interface
  *****************************************************************************
  * Copyright (C) 1999, 2000, 2001 VideoLAN
- * $Id: PlayListWindow.cpp,v 1.10 2004/01/26 16:52:31 zorglub Exp $
+ * $Id$
  *
  * Authors: Jean-Marc Dressler <polux@via.ecp.fr>
  *          Samuel Hocevar <sam@zoy.org>
@@ -35,7 +35,6 @@
 #include <vlc/intf.h>
 
 /* BeOS interface headers */
-#include "VlcWrapper.h"
 #include "InterfaceWindow.h"
 #include "ListViews.h"
 #include "MsgVals.h"
@@ -67,8 +66,12 @@ PlayListWindow::PlayListWindow( BRect frame, const char* name,
                                 B_WILL_ACCEPT_FIRST_CLICK | B_ASYNCHRONOUS_CONTROLS ),
                fMainWindow( mainWindow )
 {
+    char psz_tmp[1024];
+#define ADD_ELLIPSIS( a ) \
+    memset( psz_tmp, 0, 1024 ); \
+    snprintf( psz_tmp, 1024, "%s%s", a, B_UTF8_ELLIPSIS );
+
        p_intf = p_interface;
-    p_wrapper = p_intf->p_sys->p_wrapper;
     
     SetName( _("playlist") );
 
@@ -81,8 +84,8 @@ PlayListWindow::PlayListWindow( BRect frame, const char* name,
        // Add the File menu
        BMenu *fileMenu = new BMenu( _("File") );
        fMenuBar->AddItem( fileMenu );
-       BMenuItem* item = new BMenuItem( _AddEllipsis(_("Open File")),
-                                                                        new BMessage( OPEN_FILE ), 'O' );
+       ADD_ELLIPSIS( _("Open File") );
+       BMenuItem* item = new BMenuItem( psz_tmp, new BMessage( OPEN_FILE ), 'O' );
        item->SetTarget( fMainWindow );
        fileMenu->AddItem( item );
 
@@ -154,7 +157,7 @@ fRandomizeMI->SetEnabled( false );
        frame.top += fMenuBar->Bounds().IntegerHeight() + 1;
        frame.right -= B_V_SCROLL_BAR_WIDTH;
 
-       fListView = new PlaylistView( frame, fMainWindow, p_wrapper,
+       fListView = new PlaylistView( p_intf, frame, fMainWindow,
                                                                  new BMessage( MSG_SELECTION_CHANGED ) );
        fBackgroundView = new BScrollView( "playlist scrollview",
                                                                           fListView, B_FOLLOW_ALL_SIDES,
@@ -282,9 +285,10 @@ PlayListWindow::UpdatePlaylist( bool rebuild )
 {
        if ( rebuild )
                fListView->RebuildList();
+#if 0
        fListView->SetCurrent( p_wrapper->PlaylistCurrent() );
        fListView->SetPlaying( p_wrapper->IsPlaying() );
-
+#endif
        _CheckItemsEnableState();
 }
 
index 0938b5f..2557635 100644 (file)
@@ -2,7 +2,7 @@
  * PlayListWindow.h: BeOS interface window class prototype
  *****************************************************************************
  * Copyright (C) 1999, 2000, 2001 VideoLAN
- * $Id: PlayListWindow.h,v 1.8 2004/01/26 16:52:31 zorglub Exp $
+ * $Id$
  *
  * Authors: Jean-Marc Dressler <polux@via.ecp.fr>
  *          Tony Castley <tcastley@mail.powerup.com.au>
@@ -75,7 +75,6 @@ class PlayListWindow : public BWindow
                        BMenu*                          fViewMenu;
                        
                        intf_thread_t *     p_intf;
-                       VlcWrapper *            p_wrapper;
 };
 
 #endif // BEOS_PLAY_LIST_WINDOW_H
diff --git a/modules/gui/beos/VlcWrapper.cpp b/modules/gui/beos/VlcWrapper.cpp
deleted file mode 100644 (file)
index 250b37e..0000000
+++ /dev/null
@@ -1,940 +0,0 @@
-/*****************************************************************************
- * VlcWrapper.cpp: BeOS plugin for vlc (derived from MacOS X port)
- *****************************************************************************
- * Copyright (C) 2001 VideoLAN
- * $Id$
- *
- * Authors: Florian G. Pflug <fgp@phlo.org>
- *          Jon Lech Johansen <jon-vl@nanocrew.net>
- *          Tony Casltey <tony@castley.net>
- *          Stephan Aßmus <stippi@yellowbites.com>
- *          Eric Petit <titer@videolan.org>
- *
- * This program is free software{} you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation{} either version 2 of the License, or
- * (at your option) any later version.
- * 
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY{} without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program{} if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
- *****************************************************************************/
-#include <AppKit.h>
-#include <InterfaceKit.h>
-#include <SupportKit.h>
-
-#include <vlc/vlc.h>
-#include <vlc/intf.h>
-#include <vlc/vout.h>
-#include <vlc/input.h>
-extern "C"
-{
-  #include <audio_output.h>
-  #include <aout_internal.h>
-}
-
-#include "VlcWrapper.h"
-#include "MsgVals.h"
-
-const char * _AddEllipsis( char * string )
-{
-    char * temp;
-    temp = (char*) calloc( strlen( string ) + 4, 1 );
-    sprintf( temp, "%s%s", string, B_UTF8_ELLIPSIS );
-    return temp;
-}
-
-/* constructor */
-VlcWrapper::VlcWrapper( intf_thread_t *p_interface )
-{
-    p_intf = p_interface;
-    p_input = NULL;
-    p_playlist = (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
-                                                FIND_ANYWHERE );
-}
-
-/* destructor */
-VlcWrapper::~VlcWrapper()
-{
-    if( p_input )
-        vlc_object_release( p_input );
-
-    if( p_playlist )
-        vlc_object_release( p_playlist );
-}
-
-/* UpdateInput: updates p_input */
-void VlcWrapper::UpdateInput()
-{
-    if( !p_input )
-        p_input = (input_thread_t *)vlc_object_find( p_intf, VLC_OBJECT_INPUT,
-                                                     FIND_ANYWHERE );
-        
-    if( p_input )
-        if( p_input->b_dead )
-        {
-            vlc_object_release( p_input );
-            p_input = NULL;
-        }
-}
-
-
-/***************************
- * input infos and control *
- ***************************/
-
-bool VlcWrapper::HasInput()
-{
-    return ( p_input != NULL );
-}
-
-int VlcWrapper::InputStatus()
-{
-    if( !p_input )
-    {
-        return -1;
-    }
-    
-    return var_GetInteger( p_input, "state" );
-}
-
-int VlcWrapper::InputRate()
-{
-    if( !p_input )
-    {
-        return INPUT_RATE_DEFAULT;
-    }
-    
-    return var_GetInteger( p_input, "rate" );
-}
-
-void VlcWrapper::InputSetRate( int rate )
-{
-    if( !p_input )
-    {
-        return;
-    }
-    var_SetInteger( p_input, "rate", rate );
-}
-
-BList * VlcWrapper::GetChannels( int i_cat )
-{
-    if( p_input )
-    {
-        unsigned int i;
-        uint32 what;
-        const char* fieldName;
-
-        switch( i_cat )
-        {
-            case AUDIO_ES:
-            {
-                what = SELECT_CHANNEL;
-                fieldName = "channel";
-                break;
-            }
-            case SPU_ES:
-            {
-                what = SELECT_SUBTITLE;
-                fieldName = "subtitle";
-                break;
-            }
-            default:
-            return NULL;
-       }
-
-        BList *list = new BList();
-#if 0
-        vlc_mutex_lock( &p_input->stream.stream_lock );
-      
-        /* find which track is currently playing */
-        es_descriptor_t *p_es = NULL;
-        for( i = 0; i < p_input->stream.i_selected_es_number; i++ )
-        {
-            if( p_input->stream.pp_selected_es[i]->i_cat == i_cat )
-                p_es = p_input->stream.pp_selected_es[i];
-        }
-        
-        /* build a list of all tracks */
-        BMenuItem *menuItem;
-        BMessage *message;
-        char *trackName;
-        
-        /* "None" */
-        message = new BMessage( what );
-        message->AddInt32( fieldName, -1 );
-        menuItem = new BMenuItem( _("None"), message );
-        if( !p_es )
-            menuItem->SetMarked( true );
-        list->AddItem( menuItem );
-        
-        for( i = 0; i < p_input->stream.i_es_number; i++ )
-        {
-            if( p_input->stream.pp_es[i]->i_cat == i_cat )
-            {
-                message = new BMessage( what );
-                message->AddInt32( fieldName, i );
-                if( !p_input->stream.pp_es[i]->psz_desc ||
-                    !*p_input->stream.pp_es[i]->psz_desc )
-                    trackName = _("<unknown>");
-                else
-                    trackName = strdup( p_input->stream.pp_es[i]->psz_desc );
-                menuItem = new BMenuItem( trackName, message );
-                if( p_input->stream.pp_es[i] == p_es )
-                    menuItem->SetMarked( true );
-                list->AddItem( menuItem );
-            }
-        }
-        
-        vlc_mutex_unlock( &p_input->stream.stream_lock );
-#endif
-
-        return list;
-    }
-    return NULL;
-}
-
-void VlcWrapper::ToggleLanguage( int i_language )
-{
-    if( i_language < 0 )
-        var_SetInteger( p_input, "audio-es", -1 );  /* Disable audio */
-    else
-        var_SetInteger( p_input, "audio-es", i_language );
-}
-
-void VlcWrapper::ToggleSubtitle( int i_subtitle )
-{
-    if( i_subtitle < 0 )
-        var_SetInteger( p_input, "spu-es", -1 );  /* Disable SPU */
-    else
-        var_SetInteger( p_input, "spu-es", i_subtitle );
-}
-
-const char * VlcWrapper::GetTimeAsString()
-{
-    static char psz_time[ MSTRTIME_MAX_SIZE ];
-        
-    if( !p_input )
-    {
-        return ("-:--:--");
-    }     
-   
-    vlc_value_t time;
-    var_Get( p_input, "time", &time );
-    
-    mtime_t seconds = time.i_time / 1000000;
-    sprintf( psz_time, "%d:%02d:%02d",
-             (int) ( seconds / (60 * 60 ) ),
-             (int) ( ( seconds / 60 ) % 60 ),
-             (int) ( seconds % 60 ) );
-
-    return psz_time;
-}
-
-float VlcWrapper::GetTimeAsFloat()
-{
-    if( !p_input )
-    {
-        return 0.0;
-    }
-    
-    vlc_value_t pos;
-    var_Get( p_input, "position", &pos );
-    return pos.f_float;
-}
-
-void VlcWrapper::SetTimeAsFloat( float f_position )
-{
-    if( !p_input )
-    {
-        return;
-    }
-    
-    vlc_value_t pos;
-    pos.f_float = f_position / SEEKSLIDER_RANGE;
-    var_Set( p_input, "position", pos );
-}
-
-bool VlcWrapper::IsPlaying()
-{
-    bool playing = false;
-    if( p_input )
-    {
-        switch( var_GetInteger( p_input, "state" ) )
-        {
-            case INIT_S:
-            case PLAYING_S:
-                playing = true;
-                break;
-            default:
-                break;
-        }
-    }
-    return playing;
-}
-
-/************
- * playlist *
- ************/
-
-void VlcWrapper::OpenFiles( BList* o_files, bool replace, int32 index )
-{
-    if ( o_files && o_files->CountItems() > 0)
-    {
-        int size = PlaylistSize();
-        bool wasEmpty = ( size < 1 );
-        if ( index == -1 )
-            index = PLAYLIST_END;
-        int mode = index == PLAYLIST_END ? PLAYLIST_APPEND : PLAYLIST_INSERT;
-    
-        /* delete current playlist */
-        if( replace )
-        {
-            for( int i = 0; i < size; i++ )
-            {
-                playlist_Delete( p_playlist, 0 );
-            }
-        }
-    
-        /* insert files */
-        int32 count = o_files->CountItems();
-        for ( int32 i = count - 1; i >= 0; i-- )
-        {
-            if ( BString* o_file = (BString *)o_files->RemoveItem( i ) )
-            {
-                playlist_Add( p_playlist, o_file->String(),
-                      o_file->String(), mode, index );
-                if ( mode == PLAYLIST_INSERT )
-                    index++;
-                delete o_file;
-            }
-        }
-        // TODO: implement a user setting
-        // if to start automatically
-        /* eventually restart playing */
-        if( replace || wasEmpty )
-        {
-            playlist_Stop( p_playlist );
-            playlist_Play( p_playlist );
-        }
-    }
-}
-void VlcWrapper::OpenDisc(BString o_type, BString o_device, int i_title, int i_chapter)
-{
-    if( config_GetInt( p_intf, "beos-dvdmenus" ) )
-        o_device.Prepend( "dvdplay:" );
-    else
-        o_device.Prepend( "dvdold:" );
-    playlist_Add( p_playlist, o_device.String(), o_device.String(),
-                  PLAYLIST_APPEND | PLAYLIST_GO, PLAYLIST_END );
-}
-
-int VlcWrapper::PlaylistSize()
-{
-    vlc_mutex_lock( &p_playlist->object_lock );
-    int i_size = p_playlist->i_size;
-    vlc_mutex_unlock( &p_playlist->object_lock );
-    return i_size;
-}
-
-char * VlcWrapper::PlaylistItemName( int i )
-{
-   return p_playlist->pp_items[i]->input.psz_name;
-}
-
-int VlcWrapper::PlaylistCurrent()
-{
-    return p_playlist->i_index;
-}
-
-bool VlcWrapper::PlaylistPlay()
-{
-    if( PlaylistSize() )
-    {
-        playlist_Play( p_playlist );
-    }
-    return( true );
-}
-
-void VlcWrapper::PlaylistPause()
-{
-    if( p_input )
-    {
-        var_SetInteger( p_input, "state", PAUSE_S );
-    }
-}
-
-void VlcWrapper::PlaylistStop()
-{
-    playlist_Stop( p_playlist );
-}
-
-void VlcWrapper::PlaylistNext()
-{
-    playlist_Next( p_playlist );
-}
-
-void VlcWrapper::PlaylistPrev()
-{
-    playlist_Prev( p_playlist );
-}
-
-void VlcWrapper::GetPlaylistInfo( int32& currentIndex, int32& maxIndex )
-{
-    currentIndex = -1;
-    maxIndex = -1;
-    if ( p_playlist )
-    {
-        vlc_mutex_lock( &p_playlist->object_lock );
-
-        maxIndex = p_playlist->i_size;
-        if ( maxIndex > 0 )
-            currentIndex = p_playlist->i_index/* + 1 -> why?!?*/;
-        else
-            maxIndex = -1;
-
-        vlc_mutex_unlock( &p_playlist->object_lock );
-    }
-}
-
-void VlcWrapper::PlaylistJumpTo( int pos )
-{
-    playlist_Goto( p_playlist, pos );
-}
-
-void VlcWrapper::GetNavCapabilities( bool *canSkipPrev, bool *canSkipNext )
-{
-    if ( canSkipPrev && canSkipNext )
-    {
-        // init the parameters
-        *canSkipPrev = false;
-        *canSkipNext = false;
-        // get playlist info
-        int pos = PlaylistCurrent();
-        int size = PlaylistSize();
-
-        // see if we have got a stream going        
-        if ( p_input )
-        {
-#if 0
-            vlc_mutex_lock( &p_input->stream.stream_lock );
-
-            bool hasTitles = p_input->stream.i_area_nb > 1;
-            int numChapters = p_input->stream.p_selected_area->i_part_nb;
-            bool hasChapters = numChapters > 1;
-            // first, look for chapters
-            if ( hasChapters )
-            {
-                *canSkipPrev = p_input->stream.p_selected_area->i_part > 0;
-                *canSkipNext = p_input->stream.p_selected_area->i_part <
-                                     p_input->stream.p_selected_area->i_part_nb - 1;
-            }
-            // if one of the skip capabilities is false,
-            // make it depend on titles instead
-            if ( !*canSkipPrev && hasTitles )
-                *canSkipPrev = p_input->stream.p_selected_area->i_id > 1;
-            if ( !*canSkipNext && hasTitles )
-                *canSkipNext = p_input->stream.p_selected_area->i_id <
-                                   p_input->stream.i_area_nb - 1;
-
-            vlc_mutex_unlock( &p_input->stream.stream_lock );
-#endif
-        }
-        // last but not least, make capabilities depend on playlist
-        if ( !*canSkipPrev )
-            *canSkipPrev = pos > 0;
-        if ( !*canSkipNext )
-            *canSkipNext = pos < size - 1;
-    }
-}
-
-void VlcWrapper::NavigatePrev()
-{
-    bool hasSkiped = false;
-
-    // see if we have got a stream going        
-    if ( p_input )
-    {
-#if 0
-        // get information from stream (lock it while looking at it)
-        vlc_mutex_lock( &p_input->stream.stream_lock );
-
-        int currentTitle = p_input->stream.p_selected_area->i_id;
-        int currentChapter = p_input->stream.p_selected_area->i_part;
-        int numTitles = p_input->stream.i_area_nb;
-        bool hasTitles = numTitles > 1;
-        int numChapters = p_input->stream.p_selected_area->i_part_nb;
-        bool hasChapters = numChapters > 1;
-
-        vlc_mutex_unlock( &p_input->stream.stream_lock );
-
-        // first, look for chapters
-        if ( hasChapters )
-        {
-            // skip to the previous chapter
-            currentChapter--;
-
-            if ( currentChapter >= 0 )
-            {
-                ToggleChapter( currentChapter );
-                hasSkiped = true;
-            }
-        }
-        // if we couldn't skip chapters, try titles instead
-        if ( !hasSkiped && hasTitles )
-        {
-            // skip to the previous title
-            currentTitle--;
-            // disallow area 0 since it is used for video_ts.vob
-            if( currentTitle > 0 )
-            {
-                ToggleTitle(currentTitle);
-                hasSkiped = true;
-            }
-        }
-#endif
-    }
-    // last but not least, skip to previous file
-    if ( !hasSkiped )
-        PlaylistPrev();
-}
-
-void VlcWrapper::NavigateNext()
-{
-    bool hasSkiped = false;
-
-    // see if we have got a stream going        
-    if ( p_input )
-    {
-#if 0
-        // get information from stream (lock it while looking at it)
-        vlc_mutex_lock( &p_input->stream.stream_lock );
-
-        int currentTitle = p_input->stream.p_selected_area->i_id;
-        int currentChapter = p_input->stream.p_selected_area->i_part;
-        int numTitles = p_input->stream.i_area_nb;
-        bool hasTitles = numTitles > 1;
-        int numChapters = p_input->stream.p_selected_area->i_part_nb;
-        bool hasChapters = numChapters > 1;
-
-        vlc_mutex_unlock( &p_input->stream.stream_lock );
-
-        // first, look for chapters
-        if ( hasChapters )
-        {
-            // skip to the next chapter
-            currentChapter++;
-            if ( currentChapter < numChapters )
-            {
-                ToggleChapter( currentChapter );
-                hasSkiped = true;
-            }
-        }
-        // if we couldn't skip chapters, try titles instead
-        if ( !hasSkiped && hasTitles )
-        {
-            // skip to the next title
-            currentTitle++;
-            // disallow area 0 since it is used for video_ts.vob
-            if ( currentTitle < numTitles - 1 )
-            {
-                ToggleTitle(currentTitle);
-                hasSkiped = true;
-            }
-        }
-#endif
-    }
-    // last but not least, skip to next file
-    if ( !hasSkiped )
-        PlaylistNext();
-}
-
-/*************************
- * Playlist manipulation *
- *************************/
-
-// PlaylistLock
-bool
-VlcWrapper::PlaylistLock() const
-{
-// TODO: search and destroy -> deadlock!
-return true;
-    if ( p_playlist )
-    {
-        vlc_mutex_lock( &p_playlist->object_lock );
-        return true;
-    }
-    return false;
-}
-
-// PlaylistUnlock
-void
-VlcWrapper::PlaylistUnlock() const
-{
-// TODO: search and destroy -> deadlock!
-return;
-    vlc_mutex_unlock( &p_playlist->object_lock );
-}
-
-// PlaylistItemAt
-void*
-VlcWrapper::PlaylistItemAt( int index ) const
-{
-    playlist_item_t* item = NULL;
-    if ( index >= 0 && index < p_playlist->i_size )
-        item = p_playlist->pp_items[index];
-    return (void*)item;
-}
-
-// PlaylistRemoveItem
-void*
-VlcWrapper::PlaylistRemoveItem( int index ) const
-{
-    playlist_item_t* copy = NULL;
-    // check if item exists at the provided index
-    if ( index >= 0 && index < p_playlist->i_size )
-    {
-        playlist_item_t* item = p_playlist->pp_items[index];
-        if ( item )
-        {
-            // make a copy of the removed item
-            copy = (playlist_item_t*)PlaylistCloneItem( (void*)item );
-            // remove item from playlist (unfortunately, this frees it)
-            playlist_Delete( p_playlist, index );
-        }
-    }
-    return (void*)copy;
-}
-
-// PlaylistRemoveItem
-void*
-VlcWrapper::PlaylistRemoveItem( void* item ) const
-{
-    playlist_item_t* copy = NULL;
-    for ( int32 i = 0; i < p_playlist->i_size; i++ )
-    {
-        if ( p_playlist->pp_items[i] == item )
-        {
-            copy = (playlist_item_t*)PlaylistRemoveItem( i );
-            break;
-        }
-    }
-    return (void*)copy;
-}
-
-// PlaylistAddItem
-bool
-VlcWrapper::PlaylistAddItem( void* item, int index ) const
-{
-    if ( item )
-    {
-        playlist_AddItem( p_playlist, (playlist_item_t*)item,
-                          PLAYLIST_INSERT, index );
-    }
-    // TODO: once playlist is returning useful info, return that instead
-    return true;
-}
-
-// PlaylistCloneItem
-void*
-VlcWrapper::PlaylistCloneItem( void* castToItem ) const
-{
-    playlist_item_t* copy = NULL;
-    playlist_item_t* item = (playlist_item_t*)castToItem;
-    if ( item )
-    {
-        copy = (playlist_item_t*)malloc( sizeof( playlist_item_t ) );
-        if ( copy )
-        {
-            // make a copy of the item at index
-                        *copy = *item;
-            copy->input.psz_name = strdup( item->input.psz_name );
-            copy->input.psz_uri  = strdup( item->input.psz_uri );
-        }
-    }
-    return (void*)copy;
-}
-
-// Careful! You need to know what you're doing here!
-// The reason for having it, is to be able to deal with
-// the rather lame list implementation of the playlist.
-// It is meant to help manipulate the playlist with the above
-// methods while keeping it valid.
-//
-// PlaylistSetPlaying
-void
-VlcWrapper::PlaylistSetPlaying( int index ) const
-{
-    if ( index < 0 )
-        index = 0;
-    if ( index >= p_playlist->i_size )
-        index = p_playlist->i_size - 1;
-    p_playlist->i_index = index;
-}
-
-
-/*********
- * audio *
- *********/
-
-unsigned short VlcWrapper::GetVolume()
-{
-    unsigned short i_volume;
-    aout_VolumeGet( p_intf, (audio_volume_t*)&i_volume );
-    return i_volume;
-}
-
-void VlcWrapper::SetVolume( int value )
-{
-    if ( p_intf->p_sys->b_mute )
-    {
-        p_intf->p_sys->b_mute = 0;
-    }
-    aout_VolumeSet( p_intf, value );
-}
-
-void VlcWrapper::VolumeMute()
-{
-    aout_VolumeMute( p_intf, NULL );
-    p_intf->p_sys->b_mute = 1;
-}
-
-void VlcWrapper::VolumeRestore()
-{
-    audio_volume_t dummy;
-    aout_VolumeMute( p_intf, &dummy );
-    p_intf->p_sys->b_mute = 0;
-}
-
-bool VlcWrapper::IsMuted()
-{
-    return p_intf->p_sys->b_mute;
-}
-
-/*******
- * DVD *
- *******/
-
-bool VlcWrapper::IsUsingMenus()
-{
-    if( !p_input )
-        return false;
-
-    vlc_mutex_lock( &p_playlist->object_lock );
-    if( p_playlist->i_index < 0 )
-    {
-        vlc_mutex_unlock( &p_playlist->object_lock );
-        return false;
-    }
-    
-    char * psz_name = p_playlist->pp_items[p_playlist->i_index]->input.psz_name;
-    if( !strncmp( psz_name, "dvdplay:", 8 ) )
-    {
-        vlc_mutex_unlock( &p_playlist->object_lock );
-        return true;
-    }
-    vlc_mutex_unlock( &p_playlist->object_lock );
-
-    return false;
-}
-
-bool VlcWrapper::HasTitles()
-{
-    if( !p_input )
-        return false;
-
-    /* FIXME */
-    return false;
-}
-
-BList * VlcWrapper::GetTitles()
-{
-    if( p_input )
-    {
-        BList *list = new BList();
-#if 0
-        vlc_mutex_lock( &p_input->stream.stream_lock );
-      
-        BMenuItem *menuItem;
-        BMessage *message;
-        
-        for( unsigned int i = 1; i < p_input->stream.i_area_nb; i++ )
-        {
-            message = new BMessage( TOGGLE_TITLE );
-            message->AddInt32( "index", i );
-            BString helper( "" );
-            helper << i;
-            menuItem = new BMenuItem( helper.String(), message );
-            menuItem->SetMarked( p_input->stream.p_selected_area->i_id == i );
-            list->AddItem( menuItem );
-        }
-        
-        vlc_mutex_unlock( &p_input->stream.stream_lock );
-#endif
-        return list;
-    }
-    return NULL;
-}
-
-void VlcWrapper::PrevTitle()
-{
-    var_SetVoid( p_input, "prev-title" );
-}
-
-void VlcWrapper::NextTitle()
-{
-    var_SetVoid( p_input, "next-title" );
-}
-
-void VlcWrapper::ToggleTitle(int i_title)
-{
-    if( p_input != NULL )
-    {
-        var_SetInteger( p_input, "title", i_title );
-    }
-}
-
-void VlcWrapper::TitleInfo( int32 &currentIndex, int32 &maxIndex )
-{
-    currentIndex = -1;
-    maxIndex = -1;
-    if ( p_input )
-    {
-#if 0
-        vlc_mutex_lock( &p_input->stream.stream_lock );
-
-        maxIndex = p_input->stream.i_area_nb - 1;
-        if ( maxIndex > 0)
-            currentIndex = p_input->stream.p_selected_area->i_id;
-        else
-            maxIndex = -1;
-
-        vlc_mutex_unlock( &p_input->stream.stream_lock );
-#endif
-    }
-}
-
-bool VlcWrapper::HasChapters()
-{
-    if( !p_input )
-    {
-        return false;
-    }
-    /* FIXME */
-    return false;
-}
-
-BList * VlcWrapper::GetChapters()
-{
-    if( p_input )
-    {
-        BList *list = new BList();
-#if 0
-        vlc_mutex_lock( &p_input->stream.stream_lock );
-      
-        BMenuItem *menuItem;
-        BMessage *message;
-        
-        for( unsigned int i = 1;
-             i < p_input->stream.p_selected_area->i_part_nb + 1; i++ )
-        {
-            message = new BMessage( TOGGLE_CHAPTER );
-            message->AddInt32( "index", i );
-            BString helper( "" );
-            helper << i;
-            menuItem = new BMenuItem( helper.String(), message );
-            menuItem->SetMarked( p_input->stream.p_selected_area->i_part == i );
-            list->AddItem( menuItem );
-        }
-        
-        vlc_mutex_unlock( &p_input->stream.stream_lock );
-#endif
-        return list;
-    }
-    return NULL;
-}
-
-void VlcWrapper::PrevChapter()
-{
-    var_SetVoid( p_input, "prev-chapter" );
-}
-
-void VlcWrapper::NextChapter()
-{
-    var_SetVoid( p_input, "next-chapter" );
-}
-
-void VlcWrapper::ToggleChapter(int i_chapter)
-{
-    if( p_input != NULL )
-    {
-        var_SetInteger( p_input, "chapter", i_chapter );
-    }
-}
-
-void VlcWrapper::ChapterInfo( int32 &currentIndex, int32 &maxIndex )
-{
-    currentIndex = -1;
-    maxIndex = -1;
-    if ( p_input )
-    {
-#if 0
-        vlc_mutex_lock( &p_input->stream.stream_lock );
-
-        maxIndex = p_input->stream.p_selected_area->i_part_nb - 1;
-        if ( maxIndex > 0)
-            currentIndex = p_input->stream.p_selected_area->i_part;
-        else
-            maxIndex = -1;
-
-        vlc_mutex_unlock( &p_input->stream.stream_lock );
-#endif
-    }
-}
-
-/****************
- * Miscellanous *
- ****************/
-void VlcWrapper::LoadSubFile( const char * psz_file )
-{
-    config_PutPsz( p_intf, "sub-file", strdup( psz_file ) );
-}
-
-void VlcWrapper::FilterChange()
-{
-    if( !p_input )
-        return;
-    
-#if 0
-    vout_thread_t * p_vout;
-    vlc_mutex_lock( &p_input->stream.stream_lock );
-
-    // Warn the vout we are about to change the filter chain
-    p_vout = (vout_thread_t*)vlc_object_find( p_intf, VLC_OBJECT_VOUT,
-                                              FIND_ANYWHERE );
-    if( p_vout )
-    {
-        p_vout->b_filter_change = VLC_TRUE;
-        vlc_object_release( p_vout );
-    }
-
-    // restart all video stream
-    for( unsigned int i = 0; i < p_input->stream.i_es_number; i++ )
-    {
-        if( ( p_input->stream.pp_es[i]->i_cat == VIDEO_ES ) &&
-            ( p_input->stream.pp_es[i]->p_dec != NULL ) )
-        {
-            input_UnselectES( p_input, p_input->stream.pp_es[i] );
-            input_SelectES( p_input, p_input->stream.pp_es[i] );
-        }
-    }
-    vlc_mutex_unlock( &p_input->stream.stream_lock );
-#endif
-}
diff --git a/modules/gui/beos/VlcWrapper.h b/modules/gui/beos/VlcWrapper.h
deleted file mode 100644 (file)
index 1fc1153..0000000
+++ /dev/null
@@ -1,150 +0,0 @@
-/*****************************************************************************
- * 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;
-};
index 5a16758..5357304 100644 (file)
@@ -1065,7 +1065,7 @@ vlc_module_begin();
 
 #else
 #   define KEY_FULLSCREEN         'f'
-#   define KEY_PLAY_PAUSE         ' '
+#   define KEY_PLAY_PAUSE         KEY_SPACE
 #   define KEY_PAUSE              KEY_UNSET
 #   define KEY_PLAY               KEY_UNSET
 #   define KEY_FASTER             '+'