]> git.sesse.net Git - vlc/blob - modules/gui/beos/MediaControlView.cpp
Support for UDP-Lite (with full checksum coverage only atm)
[vlc] / modules / gui / beos / MediaControlView.cpp
1 /*****************************************************************************
2  * MediaControlView.cpp: beos interface
3  *****************************************************************************
4  * Copyright (C) 1999, 2000, 2001 the VideoLAN team
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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /* System headers */
26 #include <InterfaceKit.h>
27 #include <AppKit.h>
28 #include <String.h>
29
30 /* VLC headers */
31 #include <vlc/vlc.h>
32 #include <vlc_interface.h>
33 extern "C"
34 {
35   #include <audio_output.h>
36 }
37
38 /* BeOS interface headers */
39 #include "Bitmaps.h"
40 #include "DrawingTidbits.h"
41 #include "InterfaceWindow.h"
42 #include "MsgVals.h"
43 #include "TransportButton.h"
44 #include "ListViews.h"
45 #include "MediaControlView.h"
46
47 #define BORDER_INSET 6.0
48 #define MIN_SPACE 4.0
49 #define SPEAKER_SLIDER_DIST 6.0
50 #define VOLUME_MIN_WIDTH 70.0
51 #define DIM_LEVEL 0.4
52 #define VOLUME_SLIDER_LAYOUT_WEIGHT 2.0
53 #define SEEK_SLIDER_KNOB_WIDTH 8.0
54
55 // slider colors are hardcoded here, because that's just
56 // what they currently are within those bitmaps
57 const rgb_color kGreen = (rgb_color){ 152, 203, 152, 255 };
58 const rgb_color kGreenShadow = (rgb_color){ 102, 152, 102, 255 };
59 const rgb_color kBackground = (rgb_color){ 216, 216, 216, 255 };
60 const rgb_color kSeekGreen = (rgb_color){ 171, 221, 161, 255 };
61 const rgb_color kSeekGreenShadow = (rgb_color){ 144, 186, 136, 255 };
62 const rgb_color kSeekRed = (rgb_color){ 255, 0, 0, 255 };
63 const rgb_color kSeekRedLight = (rgb_color){ 255, 152, 152, 255 };
64 const rgb_color kSeekRedShadow = (rgb_color){ 178, 0, 0, 255 };
65
66 #define DISABLED_SEEK_MESSAGE _("Drop files to play")
67 #define SEEKSLIDER_RANGE 2048
68
69 enum
70 {
71         MSG_REWIND                              = 'rwnd',
72         MSG_FORWARD                             = 'frwd',
73         MSG_SKIP_BACKWARDS              = 'skpb',
74         MSG_SKIP_FORWARD                = 'skpf',
75 };
76
77 // constructor
78 MediaControlView::MediaControlView( intf_thread_t * _p_intf, BRect frame)
79         : BBox(frame, NULL, B_FOLLOW_NONE, B_WILL_DRAW | B_FRAME_EVENTS | B_PULSE_NEEDED,
80                    B_PLAIN_BORDER),
81       p_intf( _p_intf ),
82       fCurrentRate(INPUT_RATE_DEFAULT),
83       fCurrentStatus(-1),
84       fBottomControlHeight(0.0),
85       fIsEnabled( true )
86 {
87         BRect frame(0.0, 0.0, 10.0, 10.0);
88         
89     // Seek Slider
90     fSeekSlider = new SeekSlider( p_intf, frame, "seek slider", this );
91     fSeekSlider->SetValue(0);
92     fSeekSlider->ResizeToPreferred();
93     AddChild( fSeekSlider );
94
95     // Buttons
96     // Skip Back
97     frame.SetRightBottom(kSkipButtonSize);
98         fBottomControlHeight = kRewindBitmapHeight - 1.0;
99     fSkipBack = new TransportButton(frame, B_EMPTY_STRING,
100                                     kSkipBackBitmapBits,
101                                     kPressedSkipBackBitmapBits,
102                                     kDisabledSkipBackBitmapBits,
103                                     new BMessage(MSG_SKIP_BACKWARDS));
104     AddChild( fSkipBack );
105
106         // Play Pause
107     frame.SetRightBottom(kPlayButtonSize);
108         if (fBottomControlHeight < kPlayPauseBitmapHeight - 1.0)
109                 fBottomControlHeight = kPlayPauseBitmapHeight - 1.0;
110     fPlayPause = new PlayPauseButton(frame, B_EMPTY_STRING,
111                                      kPlayButtonBitmapBits,
112                                      kPressedPlayButtonBitmapBits,
113                                      kDisabledPlayButtonBitmapBits,
114                                      kPlayingPlayButtonBitmapBits,
115                                      kPressedPlayingPlayButtonBitmapBits,
116                                      kPausedPlayButtonBitmapBits,
117                                      kPressedPausedPlayButtonBitmapBits,
118                                      new BMessage(START_PLAYBACK));
119
120     AddChild( fPlayPause );
121
122     // Skip Foward
123     frame.SetRightBottom(kSkipButtonSize);
124     fSkipForward = new TransportButton(frame, B_EMPTY_STRING,
125                                        kSkipForwardBitmapBits,
126                                        kPressedSkipForwardBitmapBits,
127                                        kDisabledSkipForwardBitmapBits,
128                                        new BMessage(MSG_SKIP_FORWARD));
129     AddChild( fSkipForward );
130
131         // Forward
132         fForward = new TransportButton(frame, B_EMPTY_STRING,
133                                                                    kForwardBitmapBits,
134                                                                    kPressedForwardBitmapBits,
135                                                                    kDisabledForwardBitmapBits,
136                                                                    new BMessage(MSG_FORWARD));
137 //      AddChild( fForward );
138
139         // Rewind
140         fRewind = new TransportButton(frame, B_EMPTY_STRING,
141                                                                   kRewindBitmapBits,
142                                                                   kPressedRewindBitmapBits,
143                                                                   kDisabledRewindBitmapBits,
144                                                                   new BMessage(MSG_REWIND));
145 //      AddChild( fRewind );
146
147     // Stop
148     frame.SetRightBottom(kStopButtonSize);
149         if (fBottomControlHeight < kStopBitmapHeight - 1.0)
150                 fBottomControlHeight = kStopBitmapHeight - 1.0;
151     fStop = new TransportButton(frame, B_EMPTY_STRING,
152                                 kStopButtonBitmapBits,
153                                 kPressedStopButtonBitmapBits,
154                                 kDisabledStopButtonBitmapBits,
155                                 new BMessage(STOP_PLAYBACK));
156         AddChild( fStop );
157
158         // Mute
159     frame.SetRightBottom(kSpeakerButtonSize);
160         if (fBottomControlHeight < kSpeakerIconBitmapHeight - 1.0)
161                 fBottomControlHeight = kSpeakerIconBitmapHeight - 1.0;
162     fMute = new TransportButton(frame, B_EMPTY_STRING,
163                                 kSpeakerIconBits,
164                                 kPressedSpeakerIconBits,
165                                 kSpeakerIconBits,
166                                 new BMessage(VOLUME_MUTE));
167
168         AddChild( fMute );
169
170     // Volume Slider
171         fVolumeSlider = new VolumeSlider(BRect(0.0, 0.0, VOLUME_MIN_WIDTH,
172                                                                                    kVolumeSliderBitmapHeight - 1.0),
173                                                                          "volume slider", 1, AOUT_VOLUME_MAX,
174                                                                          new BMessage(VOLUME_CHG));
175         fVolumeSlider->SetValue( config_GetInt( p_intf, "volume" ) );
176         AddChild( fVolumeSlider );
177         
178         // Position Info View
179     fPositionInfo = new PositionInfoView(BRect(0.0, 0.0, 10.0, 10.0), "led",
180                                          p_intf);
181     fPositionInfo->ResizeToPreferred();
182     AddChild( fPositionInfo );
183 }
184
185 // destructor
186 MediaControlView::~MediaControlView()
187 {
188 }
189
190 // AttachedToWindow
191 void
192 MediaControlView::AttachedToWindow()
193 {
194         // we are now a valid BHandler
195         fRewind->SetTarget(this);
196         fForward->SetTarget(this);
197         fSkipBack->SetTarget(this);
198         fSkipForward->SetTarget(this);
199         fVolumeSlider->SetTarget(Window());
200
201         BRect r(_MinFrame());
202         if (BMenuBar* menuBar = Window()->KeyMenuBar()) {
203                 float width, height;
204                 menuBar->GetPreferredSize(&width, &height);
205 //              r.bottom += menuBar->Bounds().Height();
206                 r.bottom += height;
207                 // see that our calculated minimal width is not smaller than what
208                 // the menubar can be
209                 width -= r.Width();
210                 if (width > 0.0)
211                         r.right += width;
212         }
213
214         Window()->SetSizeLimits(r.Width(), r.Width() * 1.8, r.Height(), r.Height() * 1.3);
215         if (!Window()->Bounds().Contains(r))
216                 Window()->ResizeTo(r.Width(), r.Height());
217         else
218                 FrameResized(Bounds().Width(), Bounds().Height());
219
220         // get pulse message every two frames
221         Window()->SetPulseRate(80000);
222 }
223
224 // FrameResized
225 void
226 MediaControlView::FrameResized(float width, float height)
227 {
228         BRect r(Bounds());
229         // make sure we don't leave dirty pixels
230         // (B_FULL_UPDATE_ON_RESIZE == annoying flicker -> this is smarter)
231         if (fOldBounds.Width() < r.Width())
232                 Invalidate(BRect(fOldBounds.right, fOldBounds.top + 1.0,
233                                                  fOldBounds.right, fOldBounds.bottom - 1.0));
234         else
235                 Invalidate(BRect(r.right, r.top + 1.0,
236                                                  r.right, r.bottom - 1.0));
237         if (fOldBounds.Height() < r.Height())
238                 Invalidate(BRect(fOldBounds.left + 1.0, fOldBounds.bottom,
239                                                  fOldBounds.right - 1.0, fOldBounds.bottom));
240         else
241                 Invalidate(BRect(r.left + 1.0, r.bottom,
242                                                  r.right - 1.0, r.bottom));
243         // remember for next time
244         fOldBounds = r;
245         // layout controls
246         r.InsetBy(BORDER_INSET, BORDER_INSET);
247         _LayoutControls(r);
248 }
249
250 // GetPreferredSize
251 void
252 MediaControlView::GetPreferredSize(float* width, float* height)
253 {
254         if (width && height)
255         {
256                 BRect r(_MinFrame());
257                 *width = r.Width();
258                 *height = r.Height();
259         }
260 }
261
262 // MessageReceived
263 void
264 MediaControlView::MessageReceived(BMessage* message)
265 {
266         switch (message->what)
267         {
268                 case MSG_REWIND:
269                         break;
270                 case MSG_FORWARD:
271                         break;
272                 case MSG_SKIP_BACKWARDS:
273                         Window()->PostMessage(NAVIGATE_PREV);
274                         break;
275                 case MSG_SKIP_FORWARD:
276                         Window()->PostMessage(NAVIGATE_NEXT);
277                         break;
278                 default:
279                     BBox::MessageReceived(message);
280                     break;
281         }
282 }
283
284 // Pulse
285 void
286 MediaControlView::Pulse()
287 {
288         InterfaceWindow* window = dynamic_cast<InterfaceWindow*>(Window());
289         if (window && window->IsStopped())
290                         fPlayPause->SetStopped();
291
292     unsigned short i_volume;
293     aout_VolumeGet( p_intf, (audio_volume_t*)&i_volume );
294     fVolumeSlider->SetValue( i_volume );
295 }
296
297 // SetProgress
298 void
299 MediaControlView::SetProgress( float position )
300 {
301         fSeekSlider->SetPosition( position );
302 }
303
304 // SetStatus
305 void
306 MediaControlView::SetStatus(int status, int rate)
307 {
308         // we need to set the button status periodically
309         // (even if it is the same) to get a blinking button
310         fCurrentStatus = status;
311     switch( status )
312     {
313         case PLAYING_S:
314         case OPENNING_S:
315         case BUFFERING_S:
316             fPlayPause->SetPlaying();
317             break;
318         case PAUSE_S:
319             fPlayPause->SetPaused();
320             break;
321         default:
322             fPlayPause->SetStopped();
323             break;
324     }
325         if (rate != fCurrentRate)
326         {
327                 fCurrentRate = rate;
328             if ( rate < INPUT_RATE_DEFAULT )
329             {
330                 // TODO: ...
331             }
332         }
333 }
334
335 // SetEnabled
336 void
337 MediaControlView::SetEnabled(bool enabled)
338 {
339     if( ( enabled && fIsEnabled ) ||
340         ( !enabled && !fIsEnabled ) )
341     {
342         /* do not redraw if it is not necessary */
343         return;
344     }
345     
346         if( LockLooper() )
347         {
348                 fSkipBack->SetEnabled( enabled );
349                 fPlayPause->SetEnabled( enabled );
350                 fSkipForward->SetEnabled( enabled );
351                 fStop->SetEnabled( enabled );
352                 fMute->SetEnabled( enabled );
353                 fVolumeSlider->SetEnabled( enabled );
354                 fSeekSlider->SetEnabled( enabled );
355                 fRewind->SetEnabled( enabled );
356                 fForward->SetEnabled( enabled );
357                 UnlockLooper();
358                 fIsEnabled = enabled;
359         }
360 }
361
362 // SetAudioEnabled
363 void
364 MediaControlView::SetAudioEnabled(bool enabled)
365 {
366         fMute->SetEnabled(enabled);
367         fVolumeSlider->SetEnabled(enabled);
368 }
369
370 // GetVolume
371 uint32
372 MediaControlView::GetVolume() const
373 {
374         return fVolumeSlider->Value();
375 }
376
377 // SetSkippable
378 void
379 MediaControlView::SetSkippable(bool backward, bool forward)
380 {
381         fSkipBack->SetEnabled(backward);
382         fSkipForward->SetEnabled(forward);
383 }
384
385 // SetMuted
386 void
387 MediaControlView::SetMuted(bool mute)
388 {
389         fVolumeSlider->SetMuted(mute);
390 }
391
392 // _LayoutControls
393 void
394 MediaControlView::_LayoutControls(BRect frame) const
395 {
396         // seek slider
397         BRect r(frame);
398         // calculate absolutly minimal width
399         float minWidth = fSkipBack->Bounds().Width();
400 //      minWidth += fRewind->Bounds().Width();
401         minWidth += fStop->Bounds().Width();
402         minWidth += fPlayPause->Bounds().Width();
403 //      minWidth += fForward->Bounds().Width();
404         minWidth += fSkipForward->Bounds().Width();
405         minWidth += fMute->Bounds().Width();
406         minWidth += VOLUME_MIN_WIDTH;
407         
408         // layout time slider and info view
409     float width, height;
410     fPositionInfo->GetBigPreferredSize( &width, &height );
411     float ratio = width / height;
412     width = r.Height() * ratio;
413     if (frame.Width() - minWidth - MIN_SPACE >= width
414               && frame.Height() >= height)
415     {
416         r.right = r.left + width;
417         fPositionInfo->SetMode(PositionInfoView::MODE_BIG);
418         _LayoutControl(fPositionInfo, r, true, true);
419         frame.left = r.right + MIN_SPACE;
420         r.left = frame.left;
421         r.right = frame.right;
422     //    r.bottom = r.top + r.Height() / 2.0 - MIN_SPACE / 2.0;
423         r.bottom = r.top + fSeekSlider->Bounds().Height();
424         _LayoutControl(fSeekSlider, r, true);
425     }
426     else
427     {
428         fPositionInfo->GetPreferredSize( &width, &height );
429         fPositionInfo->SetMode(PositionInfoView::MODE_SMALL);
430         fPositionInfo->ResizeTo(width, height);
431         r.bottom = r.top + r.Height() / 2.0 - MIN_SPACE / 2.0;
432         r.right = r.left + fPositionInfo->Bounds().Width();
433         _LayoutControl(fPositionInfo, r, true );
434         r.left = r.right + MIN_SPACE;
435         r.right = frame.right;
436         _LayoutControl(fSeekSlider, r, true);
437     }
438         float currentWidth = frame.Width();
439         float space = (currentWidth - minWidth) / 6.0;//8.0;
440         // apply weighting
441         space = MIN_SPACE + (space - MIN_SPACE) / VOLUME_SLIDER_LAYOUT_WEIGHT;
442         // layout controls with "space" inbetween
443         r.left = frame.left;
444         r.top = r.bottom + MIN_SPACE + 1.0;
445         r.bottom = frame.bottom;
446         // skip back
447         r.right = r.left + fSkipBack->Bounds().Width();
448         _LayoutControl(fSkipBack, r);
449         // rewind
450 //      r.left = r.right + space;
451 //      r.right = r.left + fRewind->Bounds().Width();
452 //      _LayoutControl(fRewind, r);
453         // stop
454         r.left = r.right + space;
455         r.right = r.left + fStop->Bounds().Width();
456         _LayoutControl(fStop, r);
457         // play/pause
458         r.left = r.right + space;
459         r.right = r.left + fPlayPause->Bounds().Width();
460         _LayoutControl(fPlayPause, r);
461         // forward
462 //      r.left = r.right + space;
463 //      r.right = r.left + fForward->Bounds().Width();
464 //      _LayoutControl(fForward, r);
465         // skip forward
466         r.left = r.right + space;
467         r.right = r.left + fSkipForward->Bounds().Width();
468         _LayoutControl(fSkipForward, r);
469         // speaker icon
470         r.left = r.right + space + space;
471         r.right = r.left + fMute->Bounds().Width();
472         _LayoutControl(fMute, r);
473         // volume slider
474         r.left = r.right + SPEAKER_SLIDER_DIST; // keep speaker icon and volume slider attached
475         r.right = frame.right;
476         _LayoutControl(fVolumeSlider, r, true);
477 }
478
479 // _MinFrame
480 BRect           
481 MediaControlView::_MinFrame() const
482 {
483         // add up width of controls along bottom (seek slider will likely adopt)
484         float minWidth = 2 * BORDER_INSET;
485         minWidth += fSkipBack->Bounds().Width() + MIN_SPACE;
486 //      minWidth += fRewind->Bounds().Width() + MIN_SPACE;
487         minWidth += fStop->Bounds().Width() + MIN_SPACE;
488         minWidth += fPlayPause->Bounds().Width() + MIN_SPACE;
489 //      minWidth += fForward->Bounds().Width() + MIN_SPACE;
490         minWidth += fSkipForward->Bounds().Width() + MIN_SPACE + MIN_SPACE;
491         minWidth += fMute->Bounds().Width() + SPEAKER_SLIDER_DIST;
492         minWidth += VOLUME_MIN_WIDTH;
493
494         // add up height of seek slider and heighest control on bottom
495         float minHeight = 2 * BORDER_INSET;
496         minHeight += fSeekSlider->Bounds().Height() + MIN_SPACE + MIN_SPACE / 2.0;
497         minHeight += fBottomControlHeight;
498         return BRect(0.0, 0.0, minWidth - 1.0, minHeight - 1.0);
499 }
500
501 // _LayoutControl
502 void
503 MediaControlView::_LayoutControl(BView* view, BRect frame,
504                                  bool resizeWidth, bool resizeHeight) const
505 {
506     if (!resizeHeight)
507             // center vertically
508             frame.top = (frame.top + frame.bottom) / 2.0 - view->Bounds().Height() / 2.0;
509         if (!resizeWidth)
510             //center horizontally
511                 frame.left = (frame.left + frame.right) / 2.0 - view->Bounds().Width() / 2.0;
512         view->MoveTo(frame.LeftTop());
513         float width = resizeWidth ? frame.Width() : view->Bounds().Width();
514         float height = resizeHeight ? frame.Height() : view->Bounds().Height();
515     if (resizeWidth || resizeHeight)
516         view->ResizeTo(width, height);
517 }
518
519
520
521 /*****************************************************************************
522  * SeekSlider
523  *****************************************************************************/
524 SeekSlider::SeekSlider( intf_thread_t * _p_intf,
525                         BRect frame, const char* name, MediaControlView *owner )
526         : BControl(frame, name, NULL, NULL, B_FOLLOW_NONE,
527                            B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE),
528           p_intf(_p_intf),
529           fOwner(owner),
530           fTracking(false)
531 {
532         BFont font(be_plain_font);
533         font.SetSize(9.0);
534         SetFont(&font);
535 }
536
537 SeekSlider::~SeekSlider()
538 {
539 }
540
541 /*****************************************************************************
542  * VolumeSlider::AttachedToWindow
543  *****************************************************************************/
544 void
545 SeekSlider::AttachedToWindow()
546 {
547         BControl::AttachedToWindow();
548         SetViewColor(B_TRANSPARENT_32_BIT);
549 }
550
551 /*****************************************************************************
552  * VolumeSlider::Draw
553  *****************************************************************************/
554 void
555 SeekSlider::Draw(BRect updateRect)
556 {
557         BRect r(Bounds());
558         float knobWidth2 = SEEK_SLIDER_KNOB_WIDTH / 2.0;
559         float sliderStart = (r.left + knobWidth2);
560         float sliderEnd = (r.right - knobWidth2);
561         float knobPos = sliderStart
562                                         + floorf((sliderEnd - sliderStart - 1.0) * Value()
563                                         / SEEKSLIDER_RANGE);
564         // draw both sides (the original from Be doesn't seem
565         // to make a difference for enabled/disabled state)
566 //      DrawBitmapAsync(fLeftSideBits, r.LeftTop());
567 //      DrawBitmapAsync(fRightSideBits, BPoint(sliderEnd + 1.0, r.top));
568         // colors for the slider area between the two bitmaps
569         rgb_color background = kBackground;//ui_color(B_PANEL_BACKGROUND_COLOR);
570         rgb_color shadow = tint_color(background, B_DARKEN_2_TINT);
571         rgb_color softShadow = tint_color(background, B_DARKEN_1_TINT);
572         rgb_color darkShadow = tint_color(background, B_DARKEN_4_TINT);
573         rgb_color midShadow = tint_color(background, B_DARKEN_3_TINT);
574         rgb_color light = tint_color(background, B_LIGHTEN_MAX_TINT);
575         rgb_color softLight = tint_color(background, B_LIGHTEN_1_TINT);
576         rgb_color green = kSeekGreen;
577         rgb_color greenShadow = kSeekGreenShadow;
578         rgb_color black = kBlack;
579         rgb_color dotGrey = midShadow;
580         rgb_color dotGreen = greenShadow;
581         // draw frame
582         _StrokeFrame(r, softShadow, softShadow, softLight, softLight);
583         r.InsetBy(1.0, 1.0);
584         _StrokeFrame(r, black, black, light, light);
585         if (IsEnabled())
586         {
587                 r.InsetBy(1.0, 1.0);
588                 // inner shadow
589                 _StrokeFrame(r, greenShadow, greenShadow, green, green);
590                 r.top++;
591                 r.left++;
592                 _StrokeFrame(r, greenShadow, greenShadow, green, green);
593                 // inside area
594                 r.InsetBy(1.0, 1.0);
595                 SetHighColor(green);
596                 FillRect(r);
597                 // dots
598                 int32 dotCount = (int32)(r.Width() / 6.0);
599                 BPoint dotPos;
600                 dotPos.y = r.top + 2.0;
601                 SetHighColor(dotGreen);
602                 for (int32 i = 0; i < dotCount; i++)
603                 {
604                         dotPos.x = sliderStart + i * 6.0 + 5.0;
605                         StrokeLine(dotPos, BPoint(dotPos.x, dotPos.y + 6.0));
606                 }
607                 // slider handle
608                 r.top -= 4.0;
609                 r.bottom += 3.0;
610                 r.left = knobPos - knobWidth2;
611                 r.right = knobPos + knobWidth2;
612                 // black outline
613                 float handleBottomSize = 2.0;
614                 float handleArrowSize = 6.0;
615                 BeginLineArray(10);
616                         // upper handle
617                         AddLine(BPoint(r.left, r.top + handleBottomSize),
618                                         BPoint(r.left, r.top), black);
619                         AddLine(BPoint(r.left + 1.0, r.top),
620                                         BPoint(r.right, r.top), black);
621                         AddLine(BPoint(r.right, r.top + 1.0),
622                                         BPoint(r.right, r.top + handleBottomSize), black);
623                         AddLine(BPoint(r.right - 1.0, r.top + handleBottomSize + 1.0),
624                                         BPoint(knobPos, r.top + handleArrowSize), black);
625                         AddLine(BPoint(knobPos - 1.0, r.top + handleArrowSize - 1.0),
626                                         BPoint(r.left + 1.0, r.top + handleBottomSize + 1.0), black);
627                         // lower handle
628                         AddLine(BPoint(r.left, r.bottom),
629                                         BPoint(r.left, r.bottom - handleBottomSize), black);
630                         AddLine(BPoint(r.left + 1.0, r.bottom - handleBottomSize - 1.0),
631                                         BPoint(knobPos, r.bottom - handleArrowSize), black);
632                         AddLine(BPoint(knobPos + 1.0, r.bottom - handleArrowSize + 1.0),
633                                         BPoint(r.right, r.bottom - handleBottomSize), black);
634                         AddLine(BPoint(r.right, r.bottom - handleBottomSize + 1.0),
635                                         BPoint(r.right, r.bottom), black);
636                         AddLine(BPoint(r.right - 1.0, r.bottom),
637                                         BPoint(r.left + 1.0, r.bottom), black);
638                 EndLineArray();
639                 // inner red light and shadow lines
640                 r.InsetBy(1.0, 1.0);
641                 handleBottomSize--;
642                 handleArrowSize -= 2.0;
643                 BeginLineArray(10);
644                         // upper handle
645                         AddLine(BPoint(r.left, r.top + handleBottomSize),
646                                         BPoint(r.left, r.top), kSeekRedLight);
647                         AddLine(BPoint(r.left + 1.0, r.top),
648                                         BPoint(r.right, r.top), kSeekRedLight);
649                         AddLine(BPoint(r.right, r.top + 1.0),
650                                         BPoint(r.right, r.top + handleBottomSize), kSeekRedShadow);
651                         AddLine(BPoint(r.right - 1.0, r.top + handleBottomSize + 1.0),
652                                         BPoint(knobPos, r.top + handleArrowSize), kSeekRedShadow);
653                         AddLine(BPoint(knobPos - 1.0, r.top + handleArrowSize - 1.0),
654                                         BPoint(r.left + 1.0, r.top + handleBottomSize + 1.0), kSeekRedLight);
655                         // lower handle
656                         AddLine(BPoint(r.left, r.bottom),
657                                         BPoint(r.left, r.bottom - handleBottomSize), kSeekRedLight);
658                         AddLine(BPoint(r.left + 1.0, r.bottom - handleBottomSize - 1.0),
659                                         BPoint(knobPos, r.bottom - handleArrowSize), kSeekRedLight);
660                         AddLine(BPoint(knobPos + 1.0, r.bottom - handleArrowSize + 1.0),
661                                         BPoint(r.right, r.bottom - handleBottomSize), kSeekRedShadow);
662                         AddLine(BPoint(r.right, r.bottom - handleBottomSize + 1.0),
663                                         BPoint(r.right, r.bottom), kSeekRedShadow);
664                         AddLine(BPoint(r.right - 1.0, r.bottom),
665                                         BPoint(r.left + 1.0, r.bottom), kSeekRedShadow);
666                 EndLineArray();
667                 // fill rest of handles with red
668                 SetHighColor(kSeekRed);
669                 r.InsetBy(1.0, 1.0);
670                 handleArrowSize -= 2.0;
671                 BPoint arrow[3];
672                 // upper handle arrow
673                 arrow[0].x = r.left;
674                 arrow[0].y = r.top;
675                 arrow[1].x = r.right;
676                 arrow[1].y = r.top;
677                 arrow[2].x = knobPos;
678                 arrow[2].y = r.top + handleArrowSize;
679                 FillPolygon(arrow, 3);
680                 // lower handle arrow
681                 arrow[0].x = r.left;
682                 arrow[0].y = r.bottom;
683                 arrow[1].x = r.right;
684                 arrow[1].y = r.bottom;
685                 arrow[2].x = knobPos;
686                 arrow[2].y = r.bottom - handleArrowSize;
687                 FillPolygon(arrow, 3);
688         }
689         else
690         {
691                 r.InsetBy(1.0, 1.0);
692                 _StrokeFrame(r, darkShadow, darkShadow, darkShadow, darkShadow);
693                 r.InsetBy(1.0, 1.0);
694                 _StrokeFrame(r, darkShadow, darkShadow, darkShadow, darkShadow);
695                 r.InsetBy(1.0, 1.0);
696                 SetHighColor(darkShadow);
697                 SetLowColor(shadow);
698                 // stripes
699                 float width = floorf(StringWidth(DISABLED_SEEK_MESSAGE));
700                 float textPos = r.left + r.Width() / 2.0 - width / 2.0;
701                 pattern stripes = {{ 0xc7, 0x8f, 0x1f, 0x3e, 0x7c, 0xf8, 0xf1, 0xe3 }};
702                 BRect stripesRect(r);
703                 stripesRect.right = textPos - 5.0;
704                 FillRect(stripesRect, stripes);
705                 stripesRect.left = textPos + width + 3.0;
706                 stripesRect.right = r.right;
707                 FillRect(stripesRect, stripes);
708                 // info text
709                 r.left = textPos - 4.0;
710                 r.right = textPos + width + 2.0;
711                 FillRect(r);
712                 SetHighColor(shadow);
713                 SetLowColor(darkShadow);
714                 font_height fh;
715                 GetFontHeight(&fh);
716                 DrawString(DISABLED_SEEK_MESSAGE, BPoint(textPos, r.top + ceilf(fh.ascent) - 1.0));
717         }
718 }
719
720 /*****************************************************************************
721  * SeekSlider::MouseDown
722  *****************************************************************************/
723 void
724 SeekSlider::MouseDown(BPoint where)
725 {
726         if (IsEnabled() && Bounds().Contains(where))
727         {
728                 SetValue(_ValueFor(where.x));
729                 fTracking = true;
730                 SetMouseEventMask(B_POINTER_EVENTS, B_LOCK_WINDOW_FOCUS);
731         }
732 }
733
734 /*****************************************************************************
735  * SeekSlider::MouseMoved
736  *****************************************************************************/
737 void
738 SeekSlider::MouseMoved(BPoint where, uint32 code, const BMessage* dragMessage)
739 {
740         if (fTracking)
741         {
742                 SetValue(_ValueFor(where.x));
743         }
744 }
745
746 /*****************************************************************************
747  * SeekSlider::MouseUp
748  *****************************************************************************/
749 void
750 SeekSlider::MouseUp(BPoint where)
751 {
752         if (fTracking)
753         {
754                 fTracking = false;
755                 input_thread_t * p_input;
756                 p_input = (input_thread_t *)
757             vlc_object_find( p_intf, VLC_OBJECT_INPUT, FIND_ANYWHERE );
758
759         if( p_input )
760         {
761                     var_SetFloat( p_input, "position",
762                                   (float) Value() / SEEKSLIDER_RANGE );
763                     vlc_object_release( p_input );
764                 }
765         }
766 }
767
768 /*****************************************************************************
769  * SeekSlider::ResizeToPreferred
770  *****************************************************************************/
771 void
772 SeekSlider::ResizeToPreferred()
773 {
774         float width = 15.0 + StringWidth(DISABLED_SEEK_MESSAGE) + 15.0;
775         ResizeTo(width, 17.0);
776 }
777
778 /*****************************************************************************
779  * SeekSlider::SetPosition
780  *****************************************************************************/
781 void
782 SeekSlider::SetPosition(float position)
783 {
784         if ( LockLooper() )
785         {
786             if( !fTracking )
787             {
788                     SetValue( SEEKSLIDER_RANGE * position );
789                 }
790                 UnlockLooper();
791         }
792 }
793
794 /*****************************************************************************
795  * SeekSlider::_ValueFor
796  *****************************************************************************/
797 int32
798 SeekSlider::_ValueFor(float xPos) const
799 {
800         BRect r(Bounds());
801         float knobWidth2 = SEEK_SLIDER_KNOB_WIDTH / 2.0;
802         float sliderStart = (r.left + knobWidth2);
803         float sliderEnd = (r.right - knobWidth2);
804         int32 value =  (int32)(((xPos - sliderStart) * SEEKSLIDER_RANGE)
805                                   / (sliderEnd - sliderStart - 1.0));
806         if (value < 0)
807                 value = 0;
808         if (value > SEEKSLIDER_RANGE)
809                 value = SEEKSLIDER_RANGE;
810         return value;
811 }
812
813 /*****************************************************************************
814  * SeekSlider::_StrokeFrame
815  *****************************************************************************/
816 void
817 SeekSlider::_StrokeFrame(BRect r, rgb_color left, rgb_color top,
818                                                  rgb_color right, rgb_color bottom)
819 {
820         BeginLineArray(4);
821                 AddLine(BPoint(r.left, r.bottom), BPoint(r.left, r.top), left);
822                 AddLine(BPoint(r.left + 1.0, r.top), BPoint(r.right, r.top), top);
823                 AddLine(BPoint(r.right, r.top + 1.0), BPoint(r.right, r.bottom), right);
824                 AddLine(BPoint(r.right - 1.0, r.bottom), BPoint(r.left + 1.0, r.bottom), bottom);
825         EndLineArray();
826 }
827
828 /*****************************************************************************
829  * VolumeSlider
830  *****************************************************************************/
831 VolumeSlider::VolumeSlider(BRect frame, const char* name, int32 minValue, int32 maxValue,
832                                                    BMessage* message, BHandler* target)
833         : BControl(frame, name, NULL, message, B_FOLLOW_NONE,
834                            B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE),
835           fLeftSideBits(NULL),
836           fRightSideBits(NULL),
837           fKnobBits(NULL),
838           fTracking(false),
839           fMuted(false),
840           fMinValue(minValue),
841           fMaxValue(maxValue)
842 {
843         SetTarget(target);
844
845         // create bitmaps
846         BRect r(BPoint(0.0, 0.0), kVolumeSliderBitmapSize);
847         fLeftSideBits = new BBitmap(r, B_CMAP8);
848         fRightSideBits = new BBitmap(r, B_CMAP8);
849         r.Set(0.0, 0.0, kVolumeSliderKnobBitmapSize.x, kVolumeSliderKnobBitmapSize.y);
850         fKnobBits = new BBitmap(r, B_CMAP8);
851
852         _MakeBitmaps();
853 }
854
855 /*****************************************************************************
856  * VolumeSlider destructor
857  *****************************************************************************/
858 VolumeSlider::~VolumeSlider()
859 {
860         delete fLeftSideBits;
861         delete fRightSideBits;
862         delete fKnobBits;
863 }
864
865 /*****************************************************************************
866  * VolumeSlider::AttachedToWindow
867  *****************************************************************************/
868 void
869 VolumeSlider::AttachedToWindow()
870 {
871         BControl::AttachedToWindow();
872         SetViewColor(B_TRANSPARENT_32_BIT);
873 }
874
875 /*****************************************************************************
876  * VolumeSlider::SetValue
877  *****************************************************************************/
878 void
879 VolumeSlider::SetValue(int32 value)
880 {
881         if (value != Value())
882         {
883                 BControl::SetValue(value);
884                 Invoke();
885         }
886 }
887
888 /*****************************************************************************
889  * VolumeSlider::SetEnabled
890  *****************************************************************************/
891 void
892 VolumeSlider::SetEnabled(bool enable)
893 {
894         if (enable != IsEnabled())
895         {
896                 BControl::SetEnabled(enable);
897                 _MakeBitmaps();
898                 Invalidate();
899         }
900 }
901
902 /*****************************************************************************
903  * VolumeSlider::Draw
904  *****************************************************************************/
905 void
906 VolumeSlider::Draw(BRect updateRect)
907 {
908         if (IsValid())
909         {
910                 BRect r(Bounds());
911                 float sliderSideWidth = kVolumeSliderBitmapWidth;
912                 float sliderStart = (r.left + sliderSideWidth);
913                 float sliderEnd = (r.right - sliderSideWidth);
914                 float knobPos = sliderStart
915                                                 + (sliderEnd - sliderStart - 1.0) * (Value() - fMinValue)
916                                                 / (fMaxValue - fMinValue);
917                 // draw both sides (the original from Be doesn't seem
918                 // to make a difference for enabled/disabled state)
919                 DrawBitmapAsync(fLeftSideBits, r.LeftTop());
920                 DrawBitmapAsync(fRightSideBits, BPoint(sliderEnd + 1.0, r.top));
921                 // colors for the slider area between the two bitmaps
922                 rgb_color background = kBackground;//ui_color(B_PANEL_BACKGROUND_COLOR);
923                 rgb_color shadow = tint_color(background, B_DARKEN_2_TINT);
924                 rgb_color softShadow = tint_color(background, B_DARKEN_1_TINT);
925                 rgb_color darkShadow = tint_color(background, B_DARKEN_4_TINT);
926                 rgb_color midShadow = tint_color(background, B_DARKEN_3_TINT);
927                 rgb_color light = tint_color(background, B_LIGHTEN_MAX_TINT);
928                 rgb_color softLight = tint_color(background, B_LIGHTEN_1_TINT);
929                 rgb_color green = kGreen;
930                 rgb_color greenShadow = kGreenShadow;
931                 rgb_color black = kBlack;
932                 rgb_color dotGrey = midShadow;
933                 rgb_color dotGreen = greenShadow;
934                 // make dimmed version of colors if we're disabled
935                 if (!IsEnabled())
936                 {
937                         shadow = (rgb_color){ 200, 200, 200, 255 };
938                         softShadow = dimmed_color_cmap8(softShadow, background, DIM_LEVEL);
939                         darkShadow = dimmed_color_cmap8(darkShadow, background, DIM_LEVEL);
940                         midShadow = shadow;
941                         light = dimmed_color_cmap8(light, background, DIM_LEVEL);
942                         softLight = dimmed_color_cmap8(softLight, background, DIM_LEVEL);
943                         green = dimmed_color_cmap8(green, background, DIM_LEVEL);
944                         greenShadow = dimmed_color_cmap8(greenShadow, background, DIM_LEVEL);
945                         black = dimmed_color_cmap8(black, background, DIM_LEVEL);
946                         dotGreen = dotGrey;
947                 }
948                 else if (fMuted)
949                 {
950                         green = tint_color(kBackground, B_DARKEN_3_TINT);
951                         greenShadow = tint_color(kBackground, B_DARKEN_4_TINT);
952                         dotGreen = greenShadow;
953                 }
954                 // draw slider edges between bitmaps
955                 BeginLineArray(7);
956                         AddLine(BPoint(sliderStart, r.top),
957                                         BPoint(sliderEnd, r.top), softShadow);
958                         AddLine(BPoint(sliderStart, r.bottom),
959                                         BPoint(sliderEnd, r.bottom), softLight);
960                         r.InsetBy(0.0, 1.0);
961                         AddLine(BPoint(sliderStart, r.top),
962                                         BPoint(sliderEnd, r.top), black);
963                         AddLine(BPoint(sliderStart, r.bottom),
964                                         BPoint(sliderEnd, r.bottom), light);
965                         r.top++;
966                         AddLine(BPoint(sliderStart, r.top),
967                                         BPoint(knobPos, r.top), greenShadow);
968                         AddLine(BPoint(knobPos, r.top),
969                                         BPoint(sliderEnd, r.top), midShadow);
970                         r.top++;
971                         AddLine(BPoint(sliderStart, r.top),
972                                         BPoint(knobPos, r.top), greenShadow);
973                 EndLineArray();
974                 // fill rest inside of slider
975                 r.InsetBy(0.0, 1.0);
976                 r.left = sliderStart;
977                 r.right = knobPos;
978                 SetHighColor(green);
979                 FillRect(r, B_SOLID_HIGH);
980                 r.left = knobPos + 1.0;
981                 r.right = sliderEnd;
982                 r.top -= 1.0;
983                 SetHighColor(shadow);
984                 FillRect(r, B_SOLID_HIGH);
985                 // draw little dots inside
986                 int32 dotCount = (int32)((sliderEnd - sliderStart) / 5.0);
987                 BPoint dotPos;
988                 dotPos.y = r.top + 4.0;
989                 for (int32 i = 0; i < dotCount; i++)
990                 {
991                         dotPos.x = sliderStart + i * 5.0 + 4.0;
992                         SetHighColor(dotPos.x < knobPos ? dotGreen : dotGrey);
993                         StrokeLine(dotPos, BPoint(dotPos.x, dotPos.y + 1.0));
994                 }
995                 // draw knob
996                 r.top -= 1.0;
997                 SetDrawingMode(B_OP_OVER); // part of knob is transparent
998                 DrawBitmapAsync(fKnobBits, BPoint(knobPos - kVolumeSliderKnobWidth / 2, r.top));
999         }
1000 }
1001
1002 /*****************************************************************************
1003  * VolumeSlider::MouseDown
1004  *****************************************************************************/
1005 void
1006 VolumeSlider::MouseDown(BPoint where)
1007 {
1008         if (Bounds().Contains(where) && IsEnabled())
1009         {
1010                 fTracking = true;
1011                 SetValue(_ValueFor(where.x));
1012                 SetMouseEventMask(B_POINTER_EVENTS, B_LOCK_WINDOW_FOCUS);
1013         }
1014 }
1015
1016 /*****************************************************************************
1017  * VolumeSlider::MouseMoved
1018  *****************************************************************************/
1019 void
1020 VolumeSlider::MouseMoved(BPoint where, uint32 transit, const BMessage* dragMessage)
1021 {
1022         if (fTracking)
1023                 SetValue(_ValueFor(where.x));
1024 }
1025
1026 /*****************************************************************************
1027  * VolumeSlider::MouseUp
1028  *****************************************************************************/
1029 void
1030 VolumeSlider::MouseUp(BPoint where)
1031 {
1032         fTracking = false;
1033 }
1034
1035
1036 /*****************************************************************************
1037  * VolumeSlider::IsValid
1038  *****************************************************************************/
1039 bool
1040 VolumeSlider::IsValid() const
1041 {
1042         return (fLeftSideBits && fLeftSideBits->IsValid()
1043                         && fRightSideBits && fRightSideBits->IsValid()
1044                         && fKnobBits && fKnobBits->IsValid());
1045 }
1046
1047 /*****************************************************************************
1048  * VolumeSlider::SetMuted
1049  *****************************************************************************/
1050 void
1051 VolumeSlider::SetMuted(bool mute)
1052 {
1053         if (mute != fMuted)
1054         {
1055                 fMuted = mute;
1056                 _MakeBitmaps();
1057                 Invalidate();
1058         }
1059 }
1060
1061 /*****************************************************************************
1062  * VolumeSlider::_MakeBitmaps
1063  *****************************************************************************/
1064 void
1065 VolumeSlider::_MakeBitmaps()
1066 {
1067         if (IsValid())
1068         {
1069                 // left side of slider
1070                 memcpy(fLeftSideBits->Bits(), kVolumeSliderLeftBitmapBits,
1071                            fLeftSideBits->BitsLength());
1072                 // right side of slider
1073                 memcpy(fRightSideBits->Bits(), kVolumeSliderRightBits,
1074                            fRightSideBits->BitsLength());
1075                 // slider knob
1076                 int32 length = fKnobBits->BitsLength();
1077                 memcpy(fKnobBits->Bits(), kVolumeSliderKnobBits, length);
1078                 uint8* bits = (uint8*)fKnobBits->Bits();
1079                 // black was used in the knob to represent transparency
1080                 // use screen to get index for the "transarent" color used in the bitmap
1081                 BScreen screen(B_MAIN_SCREEN_ID);
1082                 uint8 blackIndex = screen.IndexForColor(kBlack);
1083                 // replace black index with transparent index
1084                 for (int32 i = 0; i < length; i++)
1085                         if (bits[i] == blackIndex)
1086                                 bits[i] = B_TRANSPARENT_MAGIC_CMAP8;
1087
1088                 if (!IsEnabled())
1089                 {
1090                         // make ghosted versions of the bitmaps
1091                         dim_bitmap(fLeftSideBits, kBackground, DIM_LEVEL);
1092                         dim_bitmap(fRightSideBits, kBackground, DIM_LEVEL);
1093                         dim_bitmap(fKnobBits, kBackground, DIM_LEVEL);
1094                 }
1095                 else if (fMuted)
1096                 {
1097                         // replace green color (and shadow) in left slider side
1098                         bits = (uint8*)fLeftSideBits->Bits();
1099                         length = fLeftSideBits->BitsLength();
1100                         uint8 greenIndex = screen.IndexForColor(kGreen);
1101                         uint8 greenShadowIndex = screen.IndexForColor(kGreenShadow);
1102                         rgb_color shadow = tint_color(kBackground, B_DARKEN_3_TINT);
1103                         rgb_color midShadow = tint_color(kBackground, B_DARKEN_4_TINT);
1104                         uint8 replaceIndex = screen.IndexForColor(shadow);
1105                         uint8 replaceShadowIndex = screen.IndexForColor(midShadow);
1106                         for (int32 i = 0; i < length; i++)
1107                         {
1108                                 if (bits[i] == greenIndex)
1109                                         bits[i] = replaceIndex;
1110                                 else if (bits[i] == greenShadowIndex)
1111                                         bits[i] = replaceShadowIndex;
1112                         }
1113                 }
1114         }
1115 }
1116
1117 /*****************************************************************************
1118  * VolumeSlider::_ValueFor
1119  *****************************************************************************/
1120 int32
1121 VolumeSlider::_ValueFor(float xPos) const
1122 {
1123         BRect r(Bounds());
1124         float sliderStart = (r.left + kVolumeSliderBitmapWidth);
1125         float sliderEnd = (r.right - kVolumeSliderBitmapWidth);
1126         int32 value =  fMinValue + (int32)(((xPos - sliderStart) * (fMaxValue - fMinValue))
1127                                   / (sliderEnd - sliderStart - 1.0));
1128         if (value < fMinValue)
1129                 value = fMinValue;
1130         if (value > fMaxValue)
1131                 value = fMaxValue;
1132         return value;
1133 }
1134
1135 /*****************************************************************************
1136  * PositionInfoView::PositionInfoView
1137  *****************************************************************************/
1138 PositionInfoView::PositionInfoView( BRect frame, const char* name,
1139                                     intf_thread_t * p_interface )
1140         : BView( frame, name, B_FOLLOW_NONE,
1141                          B_WILL_DRAW | B_PULSE_NEEDED | B_FULL_UPDATE_ON_RESIZE ),
1142           fMode( MODE_SMALL ),
1143           fCurrentFileIndex( -1 ),
1144           fCurrentFileSize( -1 ),
1145           fCurrentTitleIndex( -1 ),
1146           fCurrentTitleSize( -1 ),
1147           fCurrentChapterIndex( -1 ),
1148           fCurrentChapterSize( -1 ),
1149           fSeconds( -1 ),
1150           fTimeString( "-:--:--" ),
1151           fLastPulseUpdate( system_time() ),
1152           fStackedWidthCache( 0.0 ),
1153           fStackedHeightCache( 0.0 )
1154 {
1155     p_intf = p_interface;
1156
1157         SetViewColor( B_TRANSPARENT_32_BIT );
1158         SetLowColor( kBlack );
1159         SetHighColor( 0, 255, 0, 255 );
1160         SetFontSize( 11.0 );
1161 }
1162
1163 /*****************************************************************************
1164  * PositionInfoView::~PositionInfoView
1165  *****************************************************************************/
1166 PositionInfoView::~PositionInfoView()
1167 {
1168 }
1169
1170 /*****************************************************************************
1171  * PositionInfoView::Draw
1172  *****************************************************************************/
1173 void
1174 PositionInfoView::Draw( BRect updateRect )
1175 {
1176         rgb_color background = ui_color( B_PANEL_BACKGROUND_COLOR );
1177         rgb_color shadow = tint_color( background, B_DARKEN_1_TINT );
1178         rgb_color darkShadow = tint_color( background, B_DARKEN_4_TINT );
1179         rgb_color light = tint_color( background, B_LIGHTEN_MAX_TINT );
1180         rgb_color softLight = tint_color( background, B_LIGHTEN_1_TINT );
1181         // frame
1182         BRect r( Bounds() );
1183         BeginLineArray( 8 );
1184                 AddLine( BPoint( r.left, r.bottom ),
1185                                  BPoint( r.left, r.top ), shadow );
1186                 AddLine( BPoint( r.left + 1.0, r.top ),
1187                                  BPoint( r.right, r.top ), shadow );
1188                 AddLine( BPoint( r.right, r.top + 1.0 ),
1189                                  BPoint( r.right, r.bottom ), softLight );
1190                 AddLine( BPoint( r.right - 1.0, r.bottom ),
1191                                  BPoint( r.left + 1.0, r.bottom ), softLight );
1192                 r.InsetBy( 1.0, 1.0 );
1193                 AddLine( BPoint( r.left, r.bottom ),
1194                                  BPoint( r.left, r.top ), darkShadow );
1195                 AddLine( BPoint( r.left + 1.0, r.top ),
1196                                  BPoint( r.right, r.top ), darkShadow );
1197                 AddLine( BPoint( r.right, r.top + 1.0 ),
1198                                  BPoint( r.right, r.bottom ), light );
1199                 AddLine( BPoint( r.right - 1.0, r.bottom ),
1200                                  BPoint( r.left + 1.0, r.bottom ), light );
1201         EndLineArray();
1202         // background
1203         r.InsetBy( 1.0, 1.0 );
1204         FillRect( r, B_SOLID_LOW );
1205         // contents
1206         font_height fh;
1207         GetFontHeight( &fh );
1208         switch ( fMode )
1209         {
1210                 case MODE_SMALL:
1211                 {
1212                         float width = StringWidth( fTimeString.String() );
1213                         DrawString( fTimeString.String(),
1214                                                 BPoint( r.left + r.Width() / 2.0 - width / 2.0,
1215                                                                 r.top + r.Height() / 2.0 + fh.ascent / 2.0 - 1.0 ) );
1216                         break;
1217                 }
1218                 case MODE_BIG:
1219                 {
1220                         BFont font;
1221                         GetFont( &font );
1222                         BFont smallFont = font;
1223                         BFont bigFont = font;
1224                         BFont tinyFont = font;
1225                         smallFont.SetSize( r.Height() / 5.0 );
1226                         bigFont.SetSize( r.Height() / 3.0 );
1227                         tinyFont.SetSize( r.Height() / 7.0 );
1228                         float timeHeight = r.Height() / 2.5;
1229                         float height = ( r.Height() - timeHeight ) / 3.0;
1230                         SetFont( &tinyFont );
1231                         SetHighColor( 0, 180, 0, 255 );
1232                         DrawString( _("File"), BPoint( r.left + 3.0, r.top + height ) );
1233                         DrawString( _("Title"), BPoint( r.left + 3.0, r.top + 2.0 * height ) );
1234                         DrawString( _("Chapter"), BPoint( r.left + 3.0, r.top + 3.0 * height ) );
1235                         SetFont( &smallFont );
1236                         BString helper;
1237                         SetHighColor( 0, 255, 0, 255 );
1238                         // file
1239                         _MakeString( helper, fCurrentFileIndex, fCurrentFileSize );
1240                         float width = StringWidth( helper.String() );
1241                         DrawString( helper.String(), BPoint( r.right - 3.0 - width, r.top + height ) );
1242                         // title
1243                         _MakeString( helper, fCurrentTitleIndex, fCurrentTitleSize );
1244                         width = StringWidth( helper.String() );
1245                         DrawString( helper.String(), BPoint( r.right - 3.0 - width, r.top + 2.0 * height ) );
1246                         // chapter
1247                         _MakeString( helper, fCurrentChapterIndex, fCurrentChapterSize );
1248                         width = StringWidth( helper.String() );
1249                         DrawString( helper.String(), BPoint( r.right - 3.0 - width, r.top + 3.0 * height ) );
1250                         // time
1251                         SetFont( &bigFont );
1252                         width = StringWidth( fTimeString.String() );
1253                         DrawString( fTimeString.String(),
1254                                                 BPoint( r.left + r.Width() / 2.0 - width / 2.0,
1255                                                                 r.bottom - 3.0 ) );
1256                         break;
1257                 }
1258         }
1259 }
1260
1261 /*****************************************************************************
1262  * PositionInfoView::ResizeToPreferred
1263  *****************************************************************************/
1264 void
1265 PositionInfoView::ResizeToPreferred()
1266 {
1267         float width, height;
1268         GetPreferredSize( &width, &height );
1269         ResizeTo( width, height );
1270 }
1271
1272 /*****************************************************************************
1273  * PositionInfoView::GetPreferredSize
1274  *****************************************************************************/
1275 void
1276 PositionInfoView::GetPreferredSize( float* width, float* height )
1277 {
1278         if ( width && height )
1279         {
1280                 *width = 5.0 + ceilf( StringWidth( "0:00:00" ) ) + 5.0;
1281                 font_height fh;
1282                 GetFontHeight( &fh );
1283                 *height = 3.0 + ceilf( fh.ascent ) + 3.0;
1284                 fStackedWidthCache = *width * 1.2;
1285                 fStackedHeightCache = *height * 2.7;
1286         }
1287 }
1288
1289 /*****************************************************************************
1290  * PositionInfoView::Pulse
1291  *****************************************************************************/
1292 void
1293 PositionInfoView::Pulse()
1294 {
1295         // allow for Pulse frequency to be higher, MediaControlView needs it
1296         bigtime_t now = system_time();
1297         if ( now - fLastPulseUpdate > 900000 )
1298         {
1299 #if 0
1300                 int32 index, size;
1301                 p_intf->p_sys->p_wrapper->GetPlaylistInfo( index, size );
1302                 SetFile( index + 1, size );
1303                 p_intf->p_sys->p_wrapper->TitleInfo( index, size );
1304                 SetTitle( index, size );
1305                 p_intf->p_sys->p_wrapper->ChapterInfo( index, size );
1306                 SetChapter( index, size );
1307                 SetTime( p_intf->p_sys->p_wrapper->GetTimeAsString() );
1308                 fLastPulseUpdate = now;
1309 #endif
1310         }
1311 }
1312
1313 /*****************************************************************************
1314  * PositionInfoView::GetBigPreferredSize
1315  *****************************************************************************/
1316 void
1317 PositionInfoView::GetBigPreferredSize( float* width, float* height )
1318 {
1319         if ( width && height )
1320         {
1321                 *width = fStackedWidthCache;
1322                 *height = fStackedHeightCache;
1323         }
1324 }
1325
1326 /*****************************************************************************
1327  * PositionInfoView::SetMode
1328  *****************************************************************************/
1329 void
1330 PositionInfoView::SetMode( uint32 mode )
1331 {
1332         if ( fMode != mode )
1333         {
1334                 fMode = mode;
1335                 _InvalidateContents();
1336         }
1337 }
1338
1339 /*****************************************************************************
1340  * PositionInfoView::SetFile
1341  *****************************************************************************/
1342 void
1343 PositionInfoView::SetFile( int32 index, int32 size )
1344 {
1345         if ( fCurrentFileIndex != index || fCurrentFileSize != size )
1346         {
1347                 fCurrentFileIndex = index;
1348                 fCurrentFileSize = size;
1349                 _InvalidateContents();
1350         }
1351 }
1352
1353 /*****************************************************************************
1354  * PositionInfoView::SetTitle
1355  *****************************************************************************/
1356 void
1357 PositionInfoView::SetTitle( int32 index, int32 size )
1358 {
1359         if ( fCurrentTitleIndex != index || fCurrentFileSize != size )
1360         {
1361                 fCurrentTitleIndex = index;
1362                 fCurrentTitleSize = size;
1363                 _InvalidateContents();
1364         }
1365 }
1366
1367 /*****************************************************************************
1368  * PositionInfoView::SetChapter
1369  *****************************************************************************/
1370 void
1371 PositionInfoView::SetChapter( int32 index, int32 size )
1372 {
1373         if ( fCurrentChapterIndex != index || fCurrentFileSize != size )
1374         {
1375                 fCurrentChapterIndex = index;
1376                 fCurrentChapterSize = size;
1377                 _InvalidateContents();
1378         }
1379 }
1380
1381 /*****************************************************************************
1382  * PositionInfoView::SetTime
1383  *****************************************************************************/
1384 void
1385 PositionInfoView::SetTime( int32 seconds )
1386 {
1387         if ( fSeconds != seconds )
1388         {
1389                 if ( seconds >= 0 )
1390                 {
1391                         int32 minutes = seconds / 60;
1392                         int32 hours = minutes / 60;
1393                         seconds -= minutes * 60 - hours * 60 * 60;
1394                         minutes -= hours * 60;
1395                         fTimeString.SetTo( "" );
1396                         fTimeString << hours << ":" << minutes << ":" << seconds;
1397                 }
1398                 else
1399                         fTimeString.SetTo( "-:--:--" );
1400
1401                 fSeconds = seconds;
1402                 _InvalidateContents();
1403         }
1404 }
1405
1406 /*****************************************************************************
1407  * PositionInfoView::SetTime
1408  *****************************************************************************/
1409 void
1410 PositionInfoView::SetTime( const char* string )
1411 {
1412         fTimeString.SetTo( string );
1413         _InvalidateContents();
1414 }
1415
1416 /*****************************************************************************
1417  * PositionInfoView::_InvalidateContents
1418  *****************************************************************************/
1419 void
1420 PositionInfoView::_InvalidateContents( uint32 which )
1421 {
1422         BRect r( Bounds() );
1423         r.InsetBy( 2.0, 2.0 );
1424         Invalidate( r );
1425 }
1426
1427 /*****************************************************************************
1428  * PositionInfoView::_InvalidateContents
1429  *****************************************************************************/
1430 void
1431 PositionInfoView::_MakeString( BString& into, int32 index, int32 maxIndex ) const
1432 {
1433         into = "";
1434         if ( index >= 0 && maxIndex >= 0 )
1435                 into << index;
1436         else
1437                 into << "-";
1438         into << "/";
1439         if ( maxIndex >= 0 )
1440                 into << maxIndex;
1441         else
1442                 into << "-";
1443 }