- Added LCD info view from 0.4.x
authorEric Petit <titer@videolan.org>
Mon, 28 Oct 2002 19:42:24 +0000 (19:42 +0000)
committerEric Petit <titer@videolan.org>
Mon, 28 Oct 2002 19:42:24 +0000 (19:42 +0000)
modules/gui/beos/InterfaceWindow.cpp
modules/gui/beos/MediaControlView.cpp
modules/gui/beos/MediaControlView.h
modules/gui/beos/VlcWrapper.cpp
modules/gui/beos/VlcWrapper.h

index 2e43c34..d6df642 100644 (file)
@@ -2,7 +2,7 @@
  * InterfaceWindow.cpp: beos interface
  *****************************************************************************
  * Copyright (C) 1999, 2000, 2001 VideoLAN
- * $Id: InterfaceWindow.cpp,v 1.4 2002/10/28 16:55:05 titer Exp $
+ * $Id: InterfaceWindow.cpp,v 1.5 2002/10/28 19:42:24 titer Exp $
  *
  * Authors: Jean-Marc Dressler <polux@via.ecp.fr>
  *          Samuel Hocevar <sam@zoy.org>
@@ -86,7 +86,8 @@ InterfaceWindow::InterfaceWindow( BRect frame, const char *name,
        SetTitle( VOUT_TITLE );
 
        // the media control view
-       p_mediaControl = new MediaControlView( BRect( 0.0, 0.0, 250.0, 50.0 ) );
+       p_mediaControl = new MediaControlView( BRect( 0.0, 0.0, 250.0, 50.0 ),
+                                              p_intf );
        p_mediaControl->SetViewColor( ui_color( B_PANEL_BACKGROUND_COLOR ) );
        p_mediaControl->SetEnabled( !fPlaylistIsEmpty );
 
index 9202e51..db7f053 100644 (file)
@@ -2,7 +2,7 @@
  * MediaControlView.cpp: beos interface
  *****************************************************************************
  * Copyright (C) 1999, 2000, 2001 VideoLAN
- * $Id: MediaControlView.cpp,v 1.4 2002/10/14 20:09:17 titer Exp $
+ * $Id: MediaControlView.cpp,v 1.5 2002/10/28 19:42:24 titer Exp $
  *
  * Authors: Tony Castley <tony@castley.net>
  *          Stephan Aßmus <stippi@yellowbites.com>
@@ -25,6 +25,7 @@
 /* System headers */
 #include <InterfaceKit.h>
 #include <AppKit.h>
+#include <String.h>
 #include <string.h>
 
 /* VLC headers */
@@ -71,7 +72,7 @@ enum
 };
 
 // constructor
-MediaControlView::MediaControlView(BRect frame)
+MediaControlView::MediaControlView(BRect frame, intf_thread_t *p_interface)
        : BBox(frame, NULL, B_FOLLOW_NONE, B_WILL_DRAW | B_FRAME_EVENTS | B_PULSE_NEEDED,
                   B_PLAIN_BORDER),
       fScrubSem(B_ERROR),
@@ -79,6 +80,8 @@ MediaControlView::MediaControlView(BRect frame)
       fCurrentStatus(UNDEF_S),
       fBottomControlHeight(0.0)
 {
+    p_intf = p_interface;
+
        BRect frame(0.0, 0.0, 10.0, 10.0);
        
     // Seek Slider
@@ -170,6 +173,12 @@ MediaControlView::MediaControlView(BRect frame)
                                                                         new BMessage(VOLUME_CHG));
        fVolumeSlider->SetValue(AOUT_VOLUME_DEFAULT);
        AddChild( fVolumeSlider );
+       
+       // Position Info View
+    fPositionInfo = new PositionInfoView(BRect(0.0, 0.0, 10.0, 10.0), "led",
+                                         p_intf);
+    fPositionInfo->ResizeToPreferred();
+    AddChild( fPositionInfo );
 }
 
 // destructor
@@ -192,7 +201,7 @@ MediaControlView::AttachedToWindow()
        if (BMenuBar* menuBar = Window()->KeyMenuBar())
                r.bottom += menuBar->Bounds().Height();
 
-       Window()->SetSizeLimits(r.Width(), r.Width() * 2.0, r.Height(), r.Height() * 2.0);
+       Window()->SetSizeLimits(r.Width(), r.Width() * 1.8, r.Height(), r.Height() * 1.3);
        if (!Window()->Bounds().Contains(r))
                Window()->ResizeTo(r.Width(), r.Height());
        else
@@ -370,8 +379,6 @@ MediaControlView::_LayoutControls(BRect frame) const
 {
        // seek slider
        BRect r(frame);
-       r.bottom = r.top + r.Height() / 2.0 - MIN_SPACE / 2.0;
-       _LayoutControl(fSeekSlider, r, true);
        // calculate absolutly minimal width
        float minWidth = fSkipBack->Bounds().Width();
 //     minWidth += fRewind->Bounds().Width();
@@ -381,11 +388,43 @@ MediaControlView::_LayoutControls(BRect frame) const
        minWidth += fSkipForward->Bounds().Width();
        minWidth += fMute->Bounds().Width();
        minWidth += VOLUME_MIN_WIDTH;
+       
+       // layout time slider and info view
+    float width, height;
+    fPositionInfo->GetBigPreferredSize( &width, &height );
+    float ratio = width / height;
+    width = r.Height() * ratio;
+    if (frame.Width() - minWidth - MIN_SPACE >= width
+              && frame.Height() >= height)
+    {
+        r.right = r.left + width;
+        fPositionInfo->SetMode(PositionInfoView::MODE_BIG);
+        _LayoutControl(fPositionInfo, r, true, true);
+        frame.left = r.right + MIN_SPACE;
+        r.left = frame.left;
+        r.right = frame.right;
+    //    r.bottom = r.top + r.Height() / 2.0 - MIN_SPACE / 2.0;
+        r.bottom = r.top + fSeekSlider->Bounds().Height();
+        _LayoutControl(fSeekSlider, r, true);
+    }
+    else
+    {
+        fPositionInfo->GetPreferredSize( &width, &height );
+        fPositionInfo->SetMode(PositionInfoView::MODE_SMALL);
+        fPositionInfo->ResizeTo(width, height);
+        r.bottom = r.top + r.Height() / 2.0 - MIN_SPACE / 2.0;
+        r.right = r.left + fPositionInfo->Bounds().Width();
+        _LayoutControl(fPositionInfo, r, true );
+        r.left = r.right + MIN_SPACE;
+        r.right = frame.right;
+        _LayoutControl(fSeekSlider, r, true);
+    }
        float currentWidth = frame.Width();
        float space = (currentWidth - minWidth) / 6.0;//8.0;
        // apply weighting
        space = MIN_SPACE + (space - MIN_SPACE) / VOLUME_SLIDER_LAYOUT_WEIGHT;
        // layout controls with "space" inbetween
+       r.left = frame.left;
        r.top = r.bottom + MIN_SPACE + 1.0;
        r.bottom = frame.bottom;
        // skip back
@@ -445,15 +484,20 @@ MediaControlView::_MinFrame() const
 
 // _LayoutControl
 void
-MediaControlView::_LayoutControl(BView* view, BRect frame, bool resize) const
+MediaControlView::_LayoutControl(BView* view, BRect frame,
+                                 bool resizeWidth, bool resizeHeight) const
 {
-       // center vertically
-       frame.top = (frame.top + frame.bottom) / 2.0 - view->Bounds().Height() / 2.0;
-       if (!resize)
+    if (!resizeHeight)
+           // center vertically
+           frame.top = (frame.top + frame.bottom) / 2.0 - view->Bounds().Height() / 2.0;
+       if (!resizeWidth)
+           //center horizontally
                frame.left = (frame.left + frame.right) / 2.0 - view->Bounds().Width() / 2.0;
        view->MoveTo(frame.LeftTop());
-       if (resize)
-               view->ResizeTo(frame.Width(), view->Bounds().Height());
+       float width = resizeWidth ? frame.Width() : view->Bounds().Width();
+       float height = resizeHeight ? frame.Height() : view->Bounds().Height();
+    if (resizeWidth || resizeHeight)
+        view->ResizeTo(width, height);
 }
 
 
@@ -1098,7 +1142,310 @@ VolumeSlider::_ValueFor(float xPos) const
        return value;
 }
 
+/*****************************************************************************
+ * PositionInfoView::PositionInfoView
+ *****************************************************************************/
+PositionInfoView::PositionInfoView( BRect frame, const char* name,
+                                    intf_thread_t * p_interface )
+       : BView( frame, name, B_FOLLOW_NONE,
+                        B_WILL_DRAW | B_PULSE_NEEDED | B_FULL_UPDATE_ON_RESIZE ),
+         fMode( MODE_SMALL ),
+         fCurrentFileIndex( -1 ),
+         fCurrentFileSize( -1 ),
+         fCurrentTitleIndex( -1 ),
+         fCurrentTitleSize( -1 ),
+         fCurrentChapterIndex( -1 ),
+         fCurrentChapterSize( -1 ),
+         fSeconds( -1 ),
+         fTimeString( "-:--:--" ),
+         fLastPulseUpdate( system_time() ),
+         fStackedWidthCache( 0.0 ),
+         fStackedHeightCache( 0.0 )
+{
+    p_intf = p_interface;
+
+       SetViewColor( B_TRANSPARENT_32_BIT );
+       SetLowColor( kBlack );
+       SetHighColor( 0, 255, 0, 255 );
+       SetFontSize( 11.0 );
+}
+
+/*****************************************************************************
+ * PositionInfoView::~PositionInfoView
+ *****************************************************************************/
+PositionInfoView::~PositionInfoView()
+{
+}
+
+/*****************************************************************************
+ * PositionInfoView::Draw
+ *****************************************************************************/
+void
+PositionInfoView::Draw( BRect updateRect )
+{
+       rgb_color background = ui_color( B_PANEL_BACKGROUND_COLOR );
+       rgb_color shadow = tint_color( background, B_DARKEN_1_TINT );
+       rgb_color darkShadow = tint_color( background, B_DARKEN_4_TINT );
+       rgb_color light = tint_color( background, B_LIGHTEN_MAX_TINT );
+       rgb_color softLight = tint_color( background, B_LIGHTEN_1_TINT );
+       // frame
+       BRect r( Bounds() );
+       BeginLineArray( 8 );
+               AddLine( BPoint( r.left, r.bottom ),
+                                BPoint( r.left, r.top ), shadow );
+               AddLine( BPoint( r.left + 1.0, r.top ),
+                                BPoint( r.right, r.top ), shadow );
+               AddLine( BPoint( r.right, r.top + 1.0 ),
+                                BPoint( r.right, r.bottom ), softLight );
+               AddLine( BPoint( r.right - 1.0, r.bottom ),
+                                BPoint( r.left + 1.0, r.bottom ), softLight );
+               r.InsetBy( 1.0, 1.0 );
+               AddLine( BPoint( r.left, r.bottom ),
+                                BPoint( r.left, r.top ), darkShadow );
+               AddLine( BPoint( r.left + 1.0, r.top ),
+                                BPoint( r.right, r.top ), darkShadow );
+               AddLine( BPoint( r.right, r.top + 1.0 ),
+                                BPoint( r.right, r.bottom ), light );
+               AddLine( BPoint( r.right - 1.0, r.bottom ),
+                                BPoint( r.left + 1.0, r.bottom ), light );
+       EndLineArray();
+       // background
+       r.InsetBy( 1.0, 1.0 );
+       FillRect( r, B_SOLID_LOW );
+       // contents
+       font_height fh;
+       GetFontHeight( &fh );
+       switch ( fMode )
+       {
+               case MODE_SMALL:
+               {
+                       float width = StringWidth( fTimeString.String() );
+                       DrawString( fTimeString.String(),
+                                               BPoint( r.left + r.Width() / 2.0 - width / 2.0,
+                                                               r.top + r.Height() / 2.0 + fh.ascent / 2.0 - 1.0 ) );
+                       break;
+               }
+               case MODE_BIG:
+               {
+                       BFont font;
+                       GetFont( &font );
+                       BFont smallFont = font;
+                       BFont bigFont = font;
+                       BFont tinyFont = font;
+                       smallFont.SetSize( r.Height() / 5.0 );
+                       bigFont.SetSize( r.Height() / 3.0 );
+                       tinyFont.SetSize( r.Height() / 7.0 );
+                       float timeHeight = r.Height() / 2.5;
+                       float height = ( r.Height() - timeHeight ) / 3.0;
+                       SetFont( &tinyFont );
+                       SetHighColor( 0, 180, 0, 255 );
+                       DrawString( "File", BPoint( r.left + 3.0, r.top + height ) );
+                       DrawString( "Title", BPoint( r.left + 3.0, r.top + 2.0 * height ) );
+                       DrawString( "Chapter", BPoint( r.left + 3.0, r.top + 3.0 * height ) );
+                       SetFont( &smallFont );
+                       BString helper;
+                       SetHighColor( 0, 255, 0, 255 );
+                       // file
+                       _MakeString( helper, fCurrentFileIndex, fCurrentFileSize );
+                       float width = StringWidth( helper.String() );
+                       DrawString( helper.String(), BPoint( r.right - 3.0 - width, r.top + height ) );
+                       // title
+                       _MakeString( helper, fCurrentTitleIndex, fCurrentTitleSize );
+                       width = StringWidth( helper.String() );
+                       DrawString( helper.String(), BPoint( r.right - 3.0 - width, r.top + 2.0 * height ) );
+                       // chapter
+                       _MakeString( helper, fCurrentChapterIndex, fCurrentChapterSize );
+                       width = StringWidth( helper.String() );
+                       DrawString( helper.String(), BPoint( r.right - 3.0 - width, r.top + 3.0 * height ) );
+                       // time
+                       SetFont( &bigFont );
+                       width = StringWidth( fTimeString.String() );
+                       DrawString( fTimeString.String(),
+                                               BPoint( r.left + r.Width() / 2.0 - width / 2.0,
+                                                               r.bottom - 3.0 ) );
+                       break;
+               }
+       }
+}
+
+/*****************************************************************************
+ * PositionInfoView::ResizeToPreferred
+ *****************************************************************************/
+void
+PositionInfoView::ResizeToPreferred()
+{
+       float width, height;
+       GetPreferredSize( &width, &height );
+       ResizeTo( width, height );
+}
+
+/*****************************************************************************
+ * PositionInfoView::GetPreferredSize
+ *****************************************************************************/
+void
+PositionInfoView::GetPreferredSize( float* width, float* height )
+{
+       if ( width && height )
+       {
+               *width = 5.0 + ceilf( StringWidth( "0:00:00" ) ) + 5.0;
+               font_height fh;
+               GetFontHeight( &fh );
+               *height = 3.0 + ceilf( fh.ascent ) + 3.0;
+               fStackedWidthCache = *width * 1.2;
+               fStackedHeightCache = *height * 2.7;
+       }
+}
+
+/*****************************************************************************
+ * PositionInfoView::Pulse
+ *****************************************************************************/
+void
+PositionInfoView::Pulse()
+{
+       // allow for Pulse frequency to be higher, MediaControlView needs it
+       bigtime_t now = system_time();
+       if ( now - fLastPulseUpdate > 900000 )
+       {
+               int32 index, size;
+               p_intf->p_sys->p_vlc_wrapper->getPlaylistInfo( index, size );
+               SetFile( index, size );
+               p_intf->p_sys->p_vlc_wrapper->getTitleInfo( index, size );
+               SetTitle( index, size );
+               p_intf->p_sys->p_vlc_wrapper->getChapterInfo( index, size );
+               SetChapter( index, size );
+               SetTime( p_intf->p_sys->p_vlc_wrapper->getTimeAsString() );
+               fLastPulseUpdate = now;
+       }
+}
+
+/*****************************************************************************
+ * PositionInfoView::GetBigPreferredSize
+ *****************************************************************************/
+void
+PositionInfoView::GetBigPreferredSize( float* width, float* height )
+{
+       if ( width && height )
+       {
+               *width = fStackedWidthCache;
+               *height = fStackedHeightCache;
+       }
+}
+
+/*****************************************************************************
+ * PositionInfoView::SetMode
+ *****************************************************************************/
+void
+PositionInfoView::SetMode( uint32 mode )
+{
+       if ( fMode != mode )
+       {
+               fMode = mode;
+               _InvalidateContents();
+       }
+}
 
+/*****************************************************************************
+ * PositionInfoView::SetFile
+ *****************************************************************************/
+void
+PositionInfoView::SetFile( int32 index, int32 size )
+{
+       if ( fCurrentFileIndex != index || fCurrentFileSize != size )
+       {
+               fCurrentFileIndex = index;
+               fCurrentFileSize = size;
+               _InvalidateContents();
+       }
+}
 
+/*****************************************************************************
+ * PositionInfoView::SetTitle
+ *****************************************************************************/
+void
+PositionInfoView::SetTitle( int32 index, int32 size )
+{
+       if ( fCurrentTitleIndex != index || fCurrentFileSize != size )
+       {
+               fCurrentTitleIndex = index;
+               fCurrentTitleSize = size;
+               _InvalidateContents();
+       }
+}
 
+/*****************************************************************************
+ * PositionInfoView::SetChapter
+ *****************************************************************************/
+void
+PositionInfoView::SetChapter( int32 index, int32 size )
+{
+       if ( fCurrentChapterIndex != index || fCurrentFileSize != size )
+       {
+               fCurrentChapterIndex = index;
+               fCurrentChapterSize = size;
+               _InvalidateContents();
+       }
+}
 
+/*****************************************************************************
+ * PositionInfoView::SetTime
+ *****************************************************************************/
+void
+PositionInfoView::SetTime( int32 seconds )
+{
+       if ( fSeconds != seconds )
+       {
+               if ( seconds >= 0 )
+               {
+                       int32 minutes = seconds / 60;
+                       int32 hours = minutes / 60;
+                       seconds -= minutes * 60 - hours * 60 * 60;
+                       minutes -= hours * 60;
+                       fTimeString.SetTo( "" );
+                       fTimeString << hours << ":" << minutes << ":" << seconds;
+               }
+               else
+                       fTimeString.SetTo( "-:--:--" );
+
+               fSeconds = seconds;
+               _InvalidateContents();
+       }
+}
+
+/*****************************************************************************
+ * PositionInfoView::SetTime
+ *****************************************************************************/
+void
+PositionInfoView::SetTime( const char* string )
+{
+       fTimeString.SetTo( string );
+       _InvalidateContents();
+}
+
+/*****************************************************************************
+ * PositionInfoView::_InvalidateContents
+ *****************************************************************************/
+void
+PositionInfoView::_InvalidateContents( uint32 which )
+{
+       BRect r( Bounds() );
+       r.InsetBy( 2.0, 2.0 );
+       Invalidate( r );
+}
+
+/*****************************************************************************
+ * PositionInfoView::_InvalidateContents
+ *****************************************************************************/
+void
+PositionInfoView::_MakeString( BString& into, int32 index, int32 maxIndex ) const
+{
+       into = "";
+       if ( index >= 0)
+               into << index;
+       else
+               into << "-";
+       into << "/";
+       if ( maxIndex >= 0)
+               into << maxIndex;
+       else
+               into << "-";
+}
index 86b0dd4..7bee538 100644 (file)
@@ -2,7 +2,7 @@
  * MediaControlView.h: beos interface
  *****************************************************************************
  * Copyright (C) 1999, 2000, 2001 VideoLAN
- * $Id: MediaControlView.h,v 1.2 2002/09/30 18:30:27 titer Exp $
+ * $Id: MediaControlView.h,v 1.3 2002/10/28 19:42:24 titer Exp $
  *
  * Authors: Tony Castley <tony@castley.net>
  *          Stephan Aßmus <stippi@yellowbites.com>
@@ -30,6 +30,7 @@
 
 class BBitmap;
 class PlayPauseButton;
+class PositionInfoView;
 class SeekSlider;
 class TransportButton;
 class VolumeSlider;
@@ -37,7 +38,7 @@ class VolumeSlider;
 class MediaControlView : public BBox
 {
  public:
-                                                               MediaControlView( BRect frame );
+                                                               MediaControlView( BRect frame, intf_thread_t *p_intf );
        virtual                                         ~MediaControlView();
 
                                                                // BBox
@@ -66,7 +67,8 @@ class MediaControlView : public BBox
                        BRect                           _MinFrame() const;
                        void                            _LayoutControl(BView* view,
                                                                                           BRect frame,
-                                                                                          bool resize = false) const;
+                                                                                          bool resizeWidth = false,
+                                                                                          bool resizeHeight = false) const;
 
 
                        VolumeSlider*           fVolumeSlider;
@@ -78,11 +80,14 @@ class MediaControlView : public BBox
                        PlayPauseButton*        fPlayPause;
                        TransportButton*        fStop;
                        TransportButton*        fMute;
+                       PositionInfoView*   fPositionInfo;
 
                        int                                     fCurrentRate;
                        int                                     fCurrentStatus;
                        float                           fBottomControlHeight;
                        BRect                           fOldBounds;
+                       
+                       intf_thread_t *     p_intf;
 };
 
 class SeekSlider : public BControl
@@ -165,4 +170,62 @@ class VolumeSlider : public BControl
                        int32                           fMaxValue;
 };
 
+class PositionInfoView : public BView
+{
+ public:
+                                                               PositionInfoView( BRect frame,
+                                                                                                 const char* name,
+                                                                                                 intf_thread_t *p_intf );
+       virtual                                         ~PositionInfoView();
+
+                                                               // BView
+       virtual void                            Draw( BRect updateRect );
+       virtual void                            ResizeToPreferred();
+       virtual void                            GetPreferredSize( float* width,
+                                                                                                 float* height );
+       virtual void                            Pulse();
+
+                                                               // PositionInfoView
+       enum
+       {
+               MODE_SMALL,
+               MODE_BIG,
+       };
+
+                       void                            SetMode( uint32 mode );
+                       void                            GetBigPreferredSize( float* width,
+                                                                                                        float* height );
+
+                       void                            SetFile( int32 index, int32 size );
+                       void                            SetTitle( int32 index, int32 size );
+                       void                            SetChapter( int32 index, int32 size );
+                       void                            SetTime( int32 seconds );
+                       void                            SetTime( const char* string );
+ private:
+                       void                            _InvalidateContents( uint32 which = 0 );
+                       void                            _MakeString( BString& into,
+                                                                                        int32 index,
+                                                                                        int32 maxIndex ) const;
+//                     void                            _DrawAlignedString( const char* string,
+//                                                                                                     BRect frame,
+//                                                                                                     alignment mode = B_ALIGN_LEFT );
+
+                       uint32                          fMode;
+                       int32                           fCurrentFileIndex;
+                       int32                           fCurrentFileSize;
+                       int32                           fCurrentTitleIndex;
+                       int32                           fCurrentTitleSize;
+                       int32                           fCurrentChapterIndex;
+                       int32                           fCurrentChapterSize;
+
+                       int32                           fSeconds;
+                       BString                         fTimeString;
+                       bigtime_t                       fLastPulseUpdate;
+                       float                           fStackedWidthCache;
+                       float                           fStackedHeightCache;
+                       
+                       intf_thread_t *     p_intf;
+                       
+};
+
 #endif // BEOS_MEDIA_CONTROL_VIEW_H
index 2915a2b..6b29f7f 100644 (file)
@@ -2,7 +2,7 @@
  * intf_vlc_wrapper.h: BeOS plugin for vlc (derived from MacOS X port )
  *****************************************************************************
  * Copyright (C) 2001 VideoLAN
- * $Id: VlcWrapper.cpp,v 1.6 2002/10/14 20:09:17 titer Exp $
+ * $Id: VlcWrapper.cpp,v 1.7 2002/10/28 19:42:24 titer Exp $
  *
  * Authors: Florian G. Pflug <fgp@phlo.org>
  *          Jon Lech Johansen <jon-vl@nanocrew.net>
@@ -621,20 +621,20 @@ void Intf_VLCWrapper::eject(){}
 
     /* playback info */
 
-BString*  Intf_VLCWrapper::getTimeAsString()
+const char*  Intf_VLCWrapper::getTimeAsString()
 {
     static char psz_currenttime[ OFFSETTOTIME_MAX_SIZE ];
         
     if( p_intf->p_sys->p_input == NULL )
     {
-        return (new BString("00:00:00"));
+        return ("-:--:--");
     }     
    
     input_OffsetToTime( p_intf->p_sys->p_input, 
                         psz_currenttime, 
                         p_intf->p_sys->p_input->stream.p_selected_area->i_tell );        
 
-    return(new BString(psz_currenttime));
+    return(psz_currenttime);
 }
 
 float  Intf_VLCWrapper::getTimeAsFloat()
@@ -690,6 +690,62 @@ BList  *Intf_VLCWrapper::playlistAsArray()
     return( p_list );
 }
 
+// getPlaylistInfo
+void
+Intf_VLCWrapper::getPlaylistInfo( int32& currentIndex, int32& maxIndex )
+{
+       currentIndex = -1;
+       maxIndex = -1;
+       if ( playlist_t* list = (playlist_t*)p_intf->p_sys->p_playlist )
+       {
+               maxIndex = list->i_size;
+               if ( maxIndex > 0 )
+                       currentIndex = list->i_index + 1;
+               else
+                       maxIndex = -1;
+       }
+}
+
+// getTitleInfo
+void  
+Intf_VLCWrapper::getTitleInfo( int32& currentIndex, int32& maxIndex )
+{
+       currentIndex = -1;
+       maxIndex = -1;
+       if ( input_thread_t* input = p_intf->p_sys->p_input )
+       {
+               vlc_mutex_lock( &input->stream.stream_lock );
+
+               maxIndex = input->stream.i_area_nb - 1;
+               if ( maxIndex > 0)
+                       currentIndex = input->stream.p_selected_area->i_id;
+               else
+                       maxIndex = -1;
+
+               vlc_mutex_unlock( &input->stream.stream_lock );
+       }
+}
+
+// getChapterInfo
+void
+Intf_VLCWrapper::getChapterInfo( int32& currentIndex, int32& maxIndex )
+{
+       currentIndex = -1;
+       maxIndex = -1;
+       if ( input_thread_t* input = p_intf->p_sys->p_input )
+       {
+               vlc_mutex_lock( &input->stream.stream_lock );
+
+               maxIndex = input->stream.p_selected_area->i_part_nb - 1;
+               if ( maxIndex > 0)
+                       currentIndex = input->stream.p_selected_area->i_part;
+               else
+                       maxIndex = -1;
+
+               vlc_mutex_unlock( &input->stream.stream_lock );
+       }
+}
+
     /* open file/disc/network */
 void Intf_VLCWrapper::openFiles( BList* o_files, bool replace )
 {
index 1ac65e9..002cc2f 100644 (file)
@@ -2,7 +2,7 @@
  * intf_vlc_wrapper.h: BeOS plugin for vlc (derived from MacOS X port )
  *****************************************************************************
  * Copyright (C) 2001 VideoLAN
- * $Id: VlcWrapper.h,v 1.4 2002/10/14 20:09:17 titer Exp $
+ * $Id: VlcWrapper.h,v 1.5 2002/10/28 19:42:24 titer Exp $
  *
  * Authors: Florian G. Pflug <fgp@phlo.org>
  *          Jon Lech Johansen <jon-vl@nanocrew.net>
@@ -118,11 +118,18 @@ public:
     void inputSeek();
 
     /* playback info */
-    BString* getTimeAsString();
+    const char* getTimeAsString();
     float  getTimeAsFloat();
     void   setTimeAsFloat( float i_offset );
     bool   playlistPlaying();
     BList* playlistAsArray();
+    
+    void   getPlaylistInfo( int32& currentIndex,
+                            int32& maxIndex );
+    void   getTitleInfo( int32& currentIndex,
+                                int32& maxIndex );
+    void   getChapterInfo( int32& currentIndex,
+                                  int32& maxIndex );
 
     /* open file/disc/network */
     void openFiles( BList *o_files, bool replace = true );