mediacontrolview.cpp

VLC媒体播放程序

/*****************************************************************************
 * MediaControlView.cpp: beos interface
 *****************************************************************************
 * Copyright (C) 1999, 2000, 2001 VideoLAN
 * $Id: MediaControlView.cpp,v 1.21 2003/12/28 01:49:12 titer Exp $
 *
 * Authors: Tony Castley <[e-mail]>
 *          Stephan Aßmus <[e-mail]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
 *****************************************************************************/

/* System headers */
#include <InterfaceKit.h>
#include <AppKit.h>
#include <String.h>
#include <string.h>

/* VLC headers */
#include <vlc/vlc.h>
#include <vlc/intf.h>
extern "C"
{
  #include <audio_output.h>
}

/* BeOS interface headers */
#include "VlcWrapper.h"
#include "Bitmaps.h"
#include "DrawingTidbits.h"
#include "InterfaceWindow.h"
#include "MsgVals.h"
#include "TransportButton.h"
#include "ListViews.h"
#include "MediaControlView.h"

#define BORDER_INSET 6.0
#define MIN_SPACE 4.0
#define SPEAKER_SLIDER_DIST 6.0
#define VOLUME_MIN_WIDTH 70.0
#define DIM_LEVEL 0.4
#define VOLUME_SLIDER_LAYOUT_WEIGHT 2.0
#define SEEK_SLIDER_KNOB_WIDTH 8.0

// slider colors are hardcoded here, because that's just
// what they currently are within those bitmaps
const rgb_color kGreen = (rgb_color){ 152, 203, 152, 255 };
const rgb_color kGreenShadow = (rgb_color){ 102, 152, 102, 255 };
const rgb_color kBackground = (rgb_color){ 216, 216, 216, 255 };
const rgb_color kSeekGreen = (rgb_color){ 171, 221, 161, 255 };
const rgb_color kSeekGreenShadow = (rgb_color){ 144, 186, 136, 255 };
const rgb_color kSeekRed = (rgb_color){ 255, 0, 0, 255 };
const rgb_color kSeekRedLight = (rgb_color){ 255, 152, 152, 255 };
const rgb_color kSeekRedShadow = (rgb_color){ 178, 0, 0, 255 };

#define DISABLED_SEEK_MESSAGE _("Drop files to play")

enum
{
	MSG_REWIND				= 'rwnd',
	MSG_FORWARD				= 'frwd',
	MSG_SKIP_BACKWARDS		= 'skpb',
	MSG_SKIP_FORWARD		= 'skpf',
};

// constructor
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),
      fCurrentRate(DEFAULT_RATE),
      fCurrentStatus(UNDEF_S),
      fBottomControlHeight(0.0),
      fIsEnabled( true )
{
    p_intf = p_interface;

	BRect frame(0.0, 0.0, 10.0, 10.0);
	
    // Seek Slider
    fSeekSlider = new SeekSlider( frame, "seek slider", this,
                                  0, SEEKSLIDER_RANGE );
    fSeekSlider->SetValue(0);
    fSeekSlider->ResizeToPreferred();
    AddChild( fSeekSlider );

    // Buttons
    // Skip Back
    frame.SetRightBottom(kSkipButtonSize);
	fBottomControlHeight = kRewindBitmapHeight - 1.0;
    fSkipBack = new TransportButton(frame, B_EMPTY_STRING,
                                    kSkipBackBitmapBits,
                                    kPressedSkipBackBitmapBits,
                                    kDisabledSkipBackBitmapBits,
                                    new BMessage(MSG_SKIP_BACKWARDS));
    AddChild( fSkipBack );

	// Play Pause
    frame.SetRightBottom(kPlayButtonSize);
	if (fBottomControlHeight < kPlayPauseBitmapHeight - 1.0)
		fBottomControlHeight = kPlayPauseBitmapHeight - 1.0;
    fPlayPause = new PlayPauseButton(frame, B_EMPTY_STRING,
                                     kPlayButtonBitmapBits,
                                     kPressedPlayButtonBitmapBits,
                                     kDisabledPlayButtonBitmapBits,
                                     kPlayingPlayButtonBitmapBits,
                                     kPressedPlayingPlayButtonBitmapBits,
                                     kPausedPlayButtonBitmapBits,
                                     kPressedPausedPlayButtonBitmapBits,
                                     new BMessage(START_PLAYBACK));

    AddChild( fPlayPause );

    // Skip Foward
    frame.SetRightBottom(kSkipButtonSize);
    fSkipForward = new TransportButton(frame, B_EMPTY_STRING,
                                       kSkipForwardBitmapBits,
                                       kPressedSkipForwardBitmapBits,
                                       kDisabledSkipForwardBitmapBits,
                                       new BMessage(MSG_SKIP_FORWARD));
    AddChild( fSkipForward );

	// Forward
	fForward = new TransportButton(frame, B_EMPTY_STRING,
								   kForwardBitmapBits,
								   kPressedForwardBitmapBits,
								   kDisabledForwardBitmapBits,
								   new BMessage(MSG_FORWARD));
//	AddChild( fForward );

	// Rewind
	fRewind = new TransportButton(frame, B_EMPTY_STRING,
								  kRewindBitmapBits,
								  kPressedRewindBitmapBits,
								  kDisabledRewindBitmapBits,
								  new BMessage(MSG_REWIND));
//	AddChild( fRewind );

    // Stop
    frame.SetRightBottom(kStopButtonSize);
	if (fBottomControlHeight < kStopBitmapHeight - 1.0)
		fBottomControlHeight = kStopBitmapHeight - 1.0;
    fStop = new TransportButton(frame, B_EMPTY_STRING,
                                kStopButtonBitmapBits,
                                kPressedStopButtonBitmapBits,
                                kDisabledStopButtonBitmapBits,
                                new BMessage(STOP_PLAYBACK));
	AddChild( fStop );

	// Mute
    frame.SetRightBottom(kSpeakerButtonSize);
	if (fBottomControlHeight < kSpeakerIconBitmapHeight - 1.0)
		fBottomControlHeight = kSpeakerIconBitmapHeight - 1.0;
    fMute = new TransportButton(frame, B_EMPTY_STRING,
                                kSpeakerIconBits,
                                kPressedSpeakerIconBits,
                                kSpeakerIconBits,
                                new BMessage(VOLUME_MUTE));

	AddChild( fMute );

    // Volume Slider
	fVolumeSlider = new VolumeSlider(BRect(0.0, 0.0, VOLUME_MIN_WIDTH,
										   kVolumeSliderBitmapHeight - 1.0),
									 "volume slider", 1, AOUT_VOLUME_MAX,
									 new BMessage(VOLUME_CHG));
	fVolumeSlider->SetValue( config_GetInt( p_intf, "volume" ) );
	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
MediaControlView::~MediaControlView()
{
}

// AttachedToWindow
void
MediaControlView::AttachedToWindow()
{
	// we are now a valid BHandler
	fRewind->SetTarget(this);
	fForward->SetTarget(this);
	fSkipBack->SetTarget(this);
	fSkipForward->SetTarget(this);
	fVolumeSlider->SetTarget(Window());

	BRect r(_MinFrame());
	if (BMenuBar* menuBar = Window()->KeyMenuBar())
		r.bottom += menuBar->Bounds().Height();

	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
		FrameResized(Bounds().Width(), Bounds().Height());

	// get pulse message every two frames
	Window()->SetPulseRate(80000);
}

// FrameResized
void
MediaControlView::FrameResized(float width, float height)
{
	BRect r(Bounds());
	// make sure we don't leave dirty pixels
	// (B_FULL_UPDATE_ON_RESIZE == annoying flicker -> this is smarter)
	if (fOldBounds.Width() < r.Width())
		Invalidate(BRect(fOldBounds.right, fOldBounds.top + 1.0,
						 fOldBounds.right, fOldBounds.bottom - 1.0));
	else
		Invalidate(BRect(r.right, r.top + 1.0,
						 r.right, r.bottom - 1.0));
	if (fOldBounds.Height() < r.Height())
		Invalidate(BRect(fOldBounds.left + 1.0, fOldBounds.bottom,
						 fOldBounds.right - 1.0, fOldBounds.bottom));
	else
		Invalidate(BRect(r.left + 1.0, r.bottom,
						 r.right - 1.0, r.bottom));
	// remember for next time
	fOldBounds = r;
	// layout controls
	r.InsetBy(BORDER_INSET, BORDER_INSET);
	_LayoutControls(r);
}

// GetPreferredSize
void
MediaControlView::GetPreferredSize(float* width, float* height)
{
	if (width && height)
	{
		BRect r(_MinFrame());
		*width = r.Width();
		*height = r.Height();
	}
}

// MessageReceived
void
MediaControlView::MessageReceived(BMessage* message)
{
	switch (message->what)
	{
		case MSG_REWIND:
			break;
		case MSG_FORWARD:
			break;
		case MSG_SKIP_BACKWARDS:
			Window()->PostMessage(NAVIGATE_PREV);
			break;
		case MSG_SKIP_FORWARD:
			Window()->PostMessage(NAVIGATE_NEXT);
			break;
		default:
		    BBox::MessageReceived(message);
		    break;
	}
}

// Pulse
void
MediaControlView::Pulse()
{
	InterfaceWindow* window = dynamic_cast<InterfaceWindow*>(Window());
	if (window && window->IsStopped())
			fPlayPause->SetStopped();

    unsigned short i_volume;
    aout_VolumeGet( p_intf, (audio_volume_t*)&i_volume );
    fVolumeSlider->SetValue( i_volume );
}

// SetProgress
void
MediaControlView::SetProgress( float position )
{
	fSeekSlider->SetPosition( position );
}

// SetStatus
void
MediaControlView::SetStatus(int status, int rate)
{
	// we need to set the button status periodically
	// (even if it is the same) to get a blinking button
	fCurrentStatus = status;
    switch( status )
    {
        case PLAYING_S:
        case FORWARD_S:
        case BACKWARD_S:
            fPlayPause->SetPlaying();
            break;
        case PAUSE_S:
            fPlayPause->SetPaused();
            break;
        case UNDEF_S:
        default:
            fPlayPause->SetStopped();
            break;
    }
	if (rate != fCurrentRate)
	{
		fCurrentRate = rate;
	    if ( rate < DEFAULT_RATE )
	    {
	    	// TODO: ...
	    }
	}
}

// SetEnabled
void
MediaControlView::SetEnabled(bool enabled)
{
    if( ( enabled && fIsEnabled ) ||
        ( !enabled && !fIsEnabled ) )
    {
        /* do not redraw if it is not necessary */
        return;
    }
    
	if( LockLooper() )
	{
		fSkipBack->SetEnabled( enabled );
		fPlayPause->SetEnabled( enabled );
		fSkipForward->SetEnabled( enabled );
		fStop->SetEnabled( enabled );
		fMute->SetEnabled( enabled );
		fVolumeSlider->SetEnabled( enabled );
		fSeekSlider->SetEnabled( enabled );
		fRewind->SetEnabled( enabled );
		fForward->SetEnabled( enabled );
		UnlockLooper();
		fIsEnabled = enabled;
	}
}

// SetAudioEnabled
void
MediaControlView::SetAudioEnabled(bool enabled)
{
	fMute->SetEnabled(enabled);
	fVolumeSlider->SetEnabled(enabled);
}

// GetSeekTo
uint32
MediaControlView::GetSeekTo() const
{