- Added LCD info view from 0.4.x
[vlc.git] / modules / gui / beos / MediaControlView.h
1 /*****************************************************************************
2  * MediaControlView.h: beos interface
3  *****************************************************************************
4  * Copyright (C) 1999, 2000, 2001 VideoLAN
5  * $Id: MediaControlView.h,v 1.3 2002/10/28 19:42:24 titer Exp $
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( BRect frame, intf_thread_t *p_intf );
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(uint64 seek, uint64 size);
53
54                         void                            SetStatus(int status, int rate); 
55                         void                            SetEnabled(bool enable);
56                         void                            SetAudioEnabled(bool enable);
57                         uint32                          GetSeekTo() const;
58                         uint32                          GetVolume() const;
59                         void                            SetSkippable(bool backward,
60                                                                                          bool forward);
61                         void                            SetMuted(bool mute);
62
63                         sem_id                          fScrubSem;
64     
65  private:
66                         void                            _LayoutControls(BRect frame) const;
67                         BRect                           _MinFrame() const;
68                         void                            _LayoutControl(BView* view,
69                                                                                            BRect frame,
70                                                                                            bool resizeWidth = false,
71                                                                                            bool resizeHeight = false) const;
72
73
74                         VolumeSlider*           fVolumeSlider;
75                         SeekSlider*                     fSeekSlider;
76                         TransportButton*        fSkipBack;
77                         TransportButton*        fSkipForward;
78                         TransportButton*        fRewind;
79                         TransportButton*        fForward;
80                         PlayPauseButton*        fPlayPause;
81                         TransportButton*        fStop;
82                         TransportButton*        fMute;
83                         PositionInfoView*   fPositionInfo;
84
85                         int                                     fCurrentRate;
86                         int                                     fCurrentStatus;
87                         float                           fBottomControlHeight;
88                         BRect                           fOldBounds;
89                         
90                         intf_thread_t *     p_intf;
91 };
92
93 class SeekSlider : public BControl
94 {
95  public:
96                                                                 SeekSlider(BRect frame,
97                                                                                    const char* name,
98                                                                                    MediaControlView* owner,
99                                                                                    int32 minValue,
100                                                                                    int32 maxValue);
101
102         virtual                                         ~SeekSlider();
103
104                                                                 // BControl
105         virtual void                            AttachedToWindow();
106         virtual void                            Draw(BRect updateRect);
107         virtual void                            MouseDown(BPoint where);
108         virtual void                            MouseMoved(BPoint where, uint32 transit,
109                                                                                    const BMessage* dragMessage);
110         virtual void                            MouseUp(BPoint where);
111         virtual void                            ResizeToPreferred();
112
113                                                                 // SeekSlider
114                         void                            SetPosition(float position);
115
116 private:
117                         int32                           _ValueFor(float x) const;
118                         void                            _StrokeFrame(BRect frame,
119                                                                                          rgb_color left,
120                                                                                          rgb_color top,
121                                                                                          rgb_color right,
122                                                                                          rgb_color bottom);
123                         void                            _BeginSeek();
124                         void                            _Seek();
125                         void                            _EndSeek();
126
127                         MediaControlView*       fOwner; 
128                         bool                            fTracking;
129                         int32                           fMinValue;
130                         int32                           fMaxValue;
131 };
132
133 class VolumeSlider : public BControl
134 {
135  public:
136                                                                 VolumeSlider(BRect frame,
137                                                                                          const char* name,
138                                                                                          int32 minValue,
139                                                                                          int32 maxValue,
140                                                                                          BMessage* message = NULL,
141                                                                                          BHandler* target = NULL);
142
143         virtual                                         ~VolumeSlider();
144
145                                                                 // BControl
146         virtual void                            AttachedToWindow();
147         virtual void                            SetValue(int32 value);
148         virtual void                            SetEnabled(bool enable);
149         virtual void                            Draw(BRect updateRect);
150         virtual void                            MouseDown(BPoint where);
151         virtual void                            MouseMoved(BPoint where, uint32 transit,
152                                                                                    const BMessage* dragMessage);
153         virtual void                            MouseUp(BPoint where);
154
155                                                                 // VolumeSlider
156                         bool                            IsValid() const;
157                         void                            SetMuted(bool mute);
158
159  private:
160                         void                            _MakeBitmaps();
161                         void                            _DimBitmap(BBitmap* bitmap);
162                         int32                           _ValueFor(float xPos) const;
163
164                         BBitmap*                        fLeftSideBits;
165                         BBitmap*                        fRightSideBits;
166                         BBitmap*                        fKnobBits;
167                         bool                            fTracking;
168                         bool                            fMuted;
169                         int32                           fMinValue;
170                         int32                           fMaxValue;
171 };
172
173 class PositionInfoView : public BView
174 {
175  public:
176                                                                 PositionInfoView( BRect frame,
177                                                                                                   const char* name,
178                                                                                                   intf_thread_t *p_intf );
179         virtual                                         ~PositionInfoView();
180
181                                                                 // BView
182         virtual void                            Draw( BRect updateRect );
183         virtual void                            ResizeToPreferred();
184         virtual void                            GetPreferredSize( float* width,
185                                                                                                   float* height );
186         virtual void                            Pulse();
187
188                                                                 // PositionInfoView
189         enum
190         {
191                 MODE_SMALL,
192                 MODE_BIG,
193         };
194
195                         void                            SetMode( uint32 mode );
196                         void                            GetBigPreferredSize( float* width,
197                                                                                                          float* height );
198
199                         void                            SetFile( int32 index, int32 size );
200                         void                            SetTitle( int32 index, int32 size );
201                         void                            SetChapter( int32 index, int32 size );
202                         void                            SetTime( int32 seconds );
203                         void                            SetTime( const char* string );
204  private:
205                         void                            _InvalidateContents( uint32 which = 0 );
206                         void                            _MakeString( BString& into,
207                                                                                          int32 index,
208                                                                                          int32 maxIndex ) const;
209 //                      void                            _DrawAlignedString( const char* string,
210 //                                                                                                      BRect frame,
211 //                                                                                                      alignment mode = B_ALIGN_LEFT );
212
213                         uint32                          fMode;
214                         int32                           fCurrentFileIndex;
215                         int32                           fCurrentFileSize;
216                         int32                           fCurrentTitleIndex;
217                         int32                           fCurrentTitleSize;
218                         int32                           fCurrentChapterIndex;
219                         int32                           fCurrentChapterSize;
220
221                         int32                           fSeconds;
222                         BString                         fTimeString;
223                         bigtime_t                       fLastPulseUpdate;
224                         float                           fStackedWidthCache;
225                         float                           fStackedHeightCache;
226                         
227                         intf_thread_t *     p_intf;
228                         
229 };
230
231 #endif  // BEOS_MEDIA_CONTROL_VIEW_H