git.sesse.net Git - vlc/blob - modules/gui/beos/MediaControlView.h

   1 /*****************************************************************************
   2  * MediaControlView.h: beos interface
   3  *****************************************************************************
   4  * Copyright (C) 1999, 2000, 2001 VideoLAN (Centrale Réseaux) and its contributors
   5  * $Id$
   6  *
   7  * Authors: Tony Castley <tony@castley.net>
   8  *          Stephan Aßmus <stippi@yellowbites.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 #ifndef BEOS_MEDIA_CONTROL_VIEW_H
  26 #define BEOS_MEDIA_CONTROL_VIEW_H
  27
  28 #include <Box.h>
  29 #include <Control.h>
  30
  31 class BBitmap;
  32 class PlayPauseButton;
  33 class PositionInfoView;
  34 class SeekSlider;
  35 class TransportButton;
  36 class VolumeSlider;
  37
  38 class MediaControlView : public BBox
  39 {
  40  public:
  41                                                                 MediaControlView( intf_thread_t * p_intf, BRect frame );
  42         virtual                                         ~MediaControlView();
  43
  44                                                                 // BBox
  45         virtual void                            AttachedToWindow();
  46         virtual void                            FrameResized(float width, float height);
  47         virtual void                            GetPreferredSize(float* width, float* height);
  48         virtual void                            MessageReceived(BMessage* message);
  49         virtual void                            Pulse(); // detect stopped stream
  50
  51                                                                 // MediaControlView
  52                         void                            SetProgress( float position );
  53
  54                         void                            SetStatus(int status, int rate);
  55                         void                            SetEnabled(bool enable);
  56                         void                            SetAudioEnabled(bool enable);
  57                         uint32                          GetVolume() const;
  58                         void                            SetSkippable(bool backward,
  59                                                                                          bool forward);
  60                         void                            SetMuted(bool mute);
  61
  62  private:
  63                         void                            _LayoutControls(BRect frame) const;
  64                         BRect                           _MinFrame() const;
  65                         void                            _LayoutControl(BView* view,
  66                                                                                            BRect frame,
  67                                                                                            bool resizeWidth = false,
  68                                                                                            bool resizeHeight = false) const;
  69
  70                         intf_thread_t *     p_intf;
  71
  72                         VolumeSlider*           fVolumeSlider;
  73                         SeekSlider*                     fSeekSlider;
  74                         TransportButton*        fSkipBack;
  75                         TransportButton*        fSkipForward;
  76                         TransportButton*        fRewind;
  77                         TransportButton*        fForward;
  78                         PlayPauseButton*        fPlayPause;
  79                         TransportButton*        fStop;
  80                         TransportButton*        fMute;
  81                         PositionInfoView*   fPositionInfo;
  82
  83                         int                                     fCurrentRate;
  84                         int                                     fCurrentStatus;
  85                         float                           fBottomControlHeight;
  86                         BRect                           fOldBounds;
  87                         bool                fIsEnabled;
  88
  89 };
  90
  91 class SeekSlider : public BControl
  92 {
  93  public:
  94                                                                 SeekSlider(intf_thread_t * p_intf,
  95                                                                            BRect frame,
  96                                                                                    const char* name,
  97                                                                                    MediaControlView* owner );
  98
  99         virtual                                         ~SeekSlider();
 100
 101                                                                 // BControl
 102         virtual void                            AttachedToWindow();
 103         virtual void                            Draw(BRect updateRect);
 104         virtual void                            MouseDown(BPoint where);
 105         virtual void                            MouseMoved(BPoint where, uint32 transit,
 106                                                                                    const BMessage* dragMessage);
 107         virtual void                            MouseUp(BPoint where);
 108         virtual void                            ResizeToPreferred();
 109
 110                                                                 // SeekSlider
 111                         void                            SetPosition(float position);
 112
 113 private:
 114                         int32                           _ValueFor(float x) const;
 115                         void                            _StrokeFrame(BRect frame,
 116                                                                                          rgb_color left,
 117                                                                                          rgb_color top,
 118                                                                                          rgb_color right,
 119                                                                                          rgb_color bottom);
 120
 121             intf_thread_t     * p_intf;
 122                         MediaControlView*       fOwner;
 123                         bool                            fTracking;
 124 };
 125
 126 class VolumeSlider : public BControl
 127 {
 128  public:
 129                                                                 VolumeSlider(BRect frame,
 130                                                                                          const char* name,
 131                                                                                          int32 minValue,
 132                                                                                          int32 maxValue,
 133                                                                                          BMessage* message = NULL,
 134                                                                                          BHandler* target = NULL);
 135
 136         virtual                                         ~VolumeSlider();
 137
 138                                                                 // BControl
 139         virtual void                            AttachedToWindow();
 140         virtual void                            SetValue(int32 value);
 141         virtual void                            SetEnabled(bool enable);
 142         virtual void                            Draw(BRect updateRect);
 143         virtual void                            MouseDown(BPoint where);
 144         virtual void                            MouseMoved(BPoint where, uint32 transit,
 145                                                                                    const BMessage* dragMessage);
 146         virtual void                            MouseUp(BPoint where);
 147
 148                                                                 // VolumeSlider
 149                         bool                            IsValid() const;
 150                         void                            SetMuted(bool mute);
 151
 152  private:
 153                         void                            _MakeBitmaps();
 154                         void                            _DimBitmap(BBitmap* bitmap);
 155                         int32                           _ValueFor(float xPos) const;
 156
 157                         BBitmap*                        fLeftSideBits;
 158                         BBitmap*                        fRightSideBits;
 159                         BBitmap*                        fKnobBits;
 160                         bool                            fTracking;
 161                         bool                            fMuted;
 162                         int32                           fMinValue;
 163                         int32                           fMaxValue;
 164 };
 165
 166 class PositionInfoView : public BView
 167 {
 168  public:
 169                                                                 PositionInfoView( BRect frame,
 170                                                                                                   const char* name,
 171                                                                                                   intf_thread_t *p_intf );
 172         virtual                                         ~PositionInfoView();
 173
 174                                                                 // BView
 175         virtual void                            Draw( BRect updateRect );
 176         virtual void                            ResizeToPreferred();
 177         virtual void                            GetPreferredSize( float* width,
 178                                                                                                   float* height );
 179         virtual void                            Pulse();
 180
 181                                                                 // PositionInfoView
 182         enum
 183         {
 184                 MODE_SMALL,
 185                 MODE_BIG,
 186         };
 187
 188                         void                            SetMode( uint32 mode );
 189                         void                            GetBigPreferredSize( float* width,
 190                                                                                                          float* height );
 191
 192                         void                            SetFile( int32 index, int32 size );
 193                         void                            SetTitle( int32 index, int32 size );
 194                         void                            SetChapter( int32 index, int32 size );
 195                         void                            SetTime( int32 seconds );
 196                         void                            SetTime( const char* string );
 197  private:
 198                         void                            _InvalidateContents( uint32 which = 0 );
 199                         void                            _MakeString( BString& into,
 200                                                                                          int32 index,
 201                                                                                          int32 maxIndex ) const;
 202 //                      void                            _DrawAlignedString( const char* string,
 203 //                                                                                                      BRect frame,
 204 //                                                                                                      alignment mode = B_ALIGN_LEFT );
 205
 206                         uint32                          fMode;
 207                         int32                           fCurrentFileIndex;
 208                         int32                           fCurrentFileSize;
 209                         int32                           fCurrentTitleIndex;
 210                         int32                           fCurrentTitleSize;
 211                         int32                           fCurrentChapterIndex;
 212                         int32                           fCurrentChapterSize;
 213
 214                         int32                           fSeconds;
 215                         BString                         fTimeString;
 216                         bigtime_t                       fLastPulseUpdate;
 217                         float                           fStackedWidthCache;
 218                         float                           fStackedHeightCache;
 219
 220                         intf_thread_t *     p_intf;
 221
 222 };
 223
 224 #endif  // BEOS_MEDIA_CONTROL_VIEW_H